diff --git a/.config/nextest.toml b/.config/nextest.toml
new file mode 100644
index 000000000..2a4cd2cb9
--- /dev/null
+++ b/.config/nextest.toml
@@ -0,0 +1,3 @@
+# Minimum cargo-nextest for this repository: GHSA-vc25-qg58-w57c is fixed in 0.9.150 and CI
+# installs exactly that version, so an older nextest refuses to run (exit 92 REQUIRED_VERSION_NOT_MET).
+nextest-version = "0.9.150"
diff --git a/.github/workflows/packaging-lint.yml b/.github/workflows/packaging-lint.yml
index 1353830f8..b903f82ea 100644
--- a/.github/workflows/packaging-lint.yml
+++ b/.github/workflows/packaging-lint.yml
@@ -22,3 +22,27 @@ jobs:
   lint:
     # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
     uses: storytold/craft-common-actions/.github/workflows/packaging-lint.yml@main
+
+  windows-install-policy:
+    timeout-minutes: 10
+    name: Windows installation policy (no app build)
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - name: Install the pinned packaging toolchain
+        shell: pwsh
+        run: |
+          $tools = Join-Path $env:RUNNER_TEMP 'craft-install-policy-wix'
+          dotnet tool install --tool-path $tools wix --version 5.0.2
+          if ($LASTEXITCODE -ne 0) { throw 'WiX installation failed.' }
+          $tools >> $env:GITHUB_PATH
+          $policy = Get-Content -Raw -LiteralPath packaging/windows/install-policy.json | ConvertFrom-Json
+          foreach ($extension in @($policy.extensions)) {
+            & (Join-Path $tools 'wix.exe') extension add -g "WixToolset.$extension.wixext/5.0.2"
+            if ($LASTEXITCODE -ne 0) { throw "WiX extension $extension installation failed." }
+          }
+      - name: Build and check non-executable installer fixtures
+        shell: pwsh
+        run: ./packaging/windows/test-install-policy.ps1 -OutputDirectory (Join-Path $env:RUNNER_TEMP 'craft-install-policy-tests')
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 3cfbdc8b0..603b21c18 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -18,6 +18,7 @@ jobs:
   release:
     permissions:
       contents: write
+      packages: write
     # Intentionally tracked at @main (not SHA-pinned) so org-wide CI improvements, security fixes, and build optimizations propagate without PR churn across all craftapp repos.
     uses: storytold/craft-common-actions/.github/workflows/release.yml@main
     with:
diff --git a/.github/workflows/sonarcloud.yml b/.github/workflows/sonarcloud.yml
index e78fe1ea3..8f1aa5ad5 100644
--- a/.github/workflows/sonarcloud.yml
+++ b/.github/workflows/sonarcloud.yml
@@ -16,6 +16,9 @@ concurrency:
 
 jobs:
   sonarcloud:
-    # Tracked at @main so org-wide CI improvements propagate without PR churn.
+    # Track shared CI improvements on main.
     uses: storytold/craft-common-actions/.github/workflows/sonarcloud.yml@main
+    with:
+      timeout-minutes: 120
+      fonts-ref: b076417b5880bd4154bd22f00695b1d28c6bea83
     secrets: inherit
diff --git a/.github/workflows/windows-arm64.yml b/.github/workflows/windows-arm64.yml
index a074e6dbe..2cedc1a57 100644
--- a/.github/workflows/windows-arm64.yml
+++ b/.github/workflows/windows-arm64.yml
@@ -33,3 +33,5 @@ jobs:
     with:
       app-name: effectcraft
       app-dir: EffectCraft
+      install-relative-path: Programs/ArtCraft/EffectCraft
+      install-scope: perUser
diff --git a/AGENTS.md b/AGENTS.md
index 24abee6a1..97c35c2b9 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -9,7 +9,7 @@ People trust EffectCraft with hours of work. A malformed project, PSD, SVG, Lott
 expression or script, a broken plug-in, a bad control-channel or MCP argument, a corrupt preferences file
 or a full disk must produce an error the user (or agent) can act on, never a crash and never lost work.
 **This rule outranks feature work:** don't ship a feature by adding a panic path, and fix a crash before
-building on top of it. Full standard: [craftrules `standards/never-crash.md`](https://github.com/storytold/craftrules/blob/main/standards/never-crash.md).
+building on top of it.
 
 - **Fail with `Result<T, E>`** through the crate's error type and propagate with `?`; add context
   (`map_err`, an error variant) rather than discarding it. Lenient readers fall back and record the repair.
@@ -108,8 +108,7 @@ a command, everything is agent-drivable, and the quality gates (`cargo xtask ci`
 - **Time goes through `chrono`** (workspace dependency). Never hand-roll UTC/calendar conversion (days-to-date algorithms, leap-year math); a crate owns only its output format string. The one exception is range extension: past the years chrono can represent, shift the date by whole 400-year Gregorian cycles (146,097 days, after which the calendar repeats), let chrono compute the month and day, and add the cycles back to the year (splitting seconds into hours, minutes and seconds is plain arithmetic).
 
 Shared real-file test corpora (Photoshop-authored PSDs, etc.) live in
-[`storytold/photocraft-corpus`](https://github.com/storytold/photocraft-corpus), explained in
-[craftrules `standards/test-corpora.md`](https://github.com/storytold/craftrules/blob/main/standards/test-corpora.md).
+[`storytold/photocraft-corpus`](https://github.com/storytold/photocraft-corpus).
 Never commit large binary fixtures to this repo; fetch them pinned by commit and sha256-verified,
 as PhotoCraft does with `cargo xtask corpus`.
 
@@ -118,7 +117,7 @@ as PhotoCraft does with `cargo xtask corpus`.
 
 - [ROADMAP.md](ROADMAP.md): stage, headline numbers and what's next
 - [docs/gaps.md](docs/gaps.md): every known shortfall against After Effects, ranked, and the prioritised workstreams (G1–G9); read it before choosing work
-- [docs/target-app-parity.md](docs/target-app-parity.md): the parity numbers and how they were measured, with the per-area docs it links (UI, file formats, hardware, localization, effects, scripting); progress docs follow [craftrules `standards/progress-docs.md`](https://github.com/storytold/craftrules/blob/main/standards/progress-docs.md)
+- [docs/target-app-parity.md](docs/target-app-parity.md): the parity numbers and how they were measured, with the per-area docs it links (UI, file formats, hardware, localization, effects, scripting)
 - [CONTRIBUTING.md](CONTRIBUTING.md): setup, gates, commits, how to add things
 - [docs/architecture.md](docs/architecture.md): layers, data model, commands, pipeline
 - [docs/testing.md](docs/testing.md): oracle tests, criteria, benchmarks
@@ -136,11 +135,13 @@ as PhotoCraft does with `cargo xtask corpus`.
   username has a `[people.<username>]` entry in `contributors/people.toml`. If not, ask them once
   whether they want to be credited by more than their username: a real name, a display name, and/or
   their public GitHub profile name (`sync_github_name = true`). If yes, add **only their own** entry
-  (copy the template at the top of the file, or run
-  `python3 ../../craftrules/scripts/contributors.py --add-me . --real-name "…" --sync-github-name`)
+  (copy the template at the top of the file)
   and include it in their PR, committed as them. If no, change nothing: they are credited as
   `@username` anyway.
 - Never add, edit, guess or copy anyone else's entry or name (not from git config, commit authors or
   GitHub profiles). Never hand-edit `contributors.json`.
-- Maintainers refresh the stats with `python3 ../../craftrules/scripts/contributors.py .` (it also
-  re-verifies who wrote each `people.toml` entry; `--check` only verifies).
+
+## CI workflows
+- Workflows in `.github/workflows/` call the shared workflows in [`storytold/craft-common-actions`](https://github.com/storytold/craft-common-actions) at `@main`, with their inputs and secrets. No other jobs: if no shared workflow does what's needed, it doesn't go here.
+- Don't add or change CI in a feature or fix PR. If the existing workflows can't build or test a change, link an existing craft-common-actions issue or PR, or open a new issue, or a PR only for a small fix that is safe for every app and does not increase CI time.
+- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md
index 77a9cc432..c97d32ed9 100644
--- a/ATTRIBUTION.md
+++ b/ATTRIBUTION.md
@@ -89,6 +89,8 @@ Screenshots of EffectCraft itself, rendered headlessly, showing only procedurall
   `crates/engine/presets/transitions.json` (sidecar `.attribution`).
 - Backgrounds animation presets (23: drifting gradients, fog, cloud and smoke, plasma and magma, cells and crystals, scrolling grids
   and checks, pulse rings, bokeh, light sweep): `crates/engine/presets/backgrounds.json` (sidecar `.attribution`).
+- Behaviors animation presets (22: wiggle, shake, float, orbit, bounce, drift, pendulum, spin, pulse, heartbeat, blink, strobe, flicker):
+  `crates/engine/presets/behaviors.json` (sidecar `.attribution`).
 - Sample scripts (File ▸ Scripts) and ScriptUI panel: `crates/engine/scripts/Rename Layers.jsx`,
   `crates/engine/scripts/Sort Layers by In Point.jsx`, `crates/engine/scripts/Create Null at Selected Layers.jsx`,
   `crates/engine/scripts/Render Queue Batch.jsx`, `crates/engine/scripts/ScriptUI Panels/Layer Tools.jsx`
diff --git a/CLAUDE.md b/CLAUDE.md
index e52386942..640b9800e 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -11,7 +11,7 @@ EffectCraft is a clean-room, open-source, pure-Rust motion graphics and visual e
 
 ## Non-negotiables
 **Read [`AGENTS.md`](AGENTS.md) first; its rules override everything here.** No Adobe assets, every asset licensed + attributed (`cargo xtask assets`).
-- **Never crash** (AGENTS.md "Never crash"; outranks feature work: a crash loses people's work). Non-test code has no `unwrap()`/`expect()`/`panic!`/`unreachable!`/`todo!`/`unimplemented!` and no `unsafe`: return `Result` and use `?`, `ok_or`, `let … else`. Input-derived indices, slices and arithmetic use `get()` and checked/saturating math; recursion is depth-limited; locks handle poisoning. The app's last-resort guard turns an escaped panic into an error and keeps the document. Every crash fix gets a regression test. Standard: [craftrules `standards/never-crash.md`](https://github.com/storytold/craftrules/blob/main/standards/never-crash.md).
+- **Never crash** (AGENTS.md "Never crash"; outranks feature work: a crash loses people's work). Non-test code has no `unwrap()`/`expect()`/`panic!`/`unreachable!`/`todo!`/`unimplemented!` and no `unsafe`: return `Result` and use `?`, `ok_or`, `let … else`. Input-derived indices, slices and arithmetic use `get()` and checked/saturating math; recursion is depth-limited; locks handle poisoning. The app's last-resort guard turns an escaped panic into an error and keeps the document. Every crash fix gets a regression test.
 - **Clean-room.** Behaviour and public docs only. No GPL/LGPL/AGPL code. ffmpeg only as an external test oracle.
 - **Pure Rust.** Media codecs come from FilmCraft crates (git deps behind `crates/media`, see `plan/adr/0001`).
 - **Layering** (`cargo xtask layers`): nothing below L5 depends on egui/eframe/winit/rfd/cpal; L0–L4 build for wasm32.
@@ -22,6 +22,7 @@ EffectCraft is a clean-room, open-source, pure-Rust motion graphics and visual e
 - **Everything is agent-drivable:** every interactive widget registers an automation id; UI state is serde.
 - **Community links** (Help menu, About, header Discord button): https://discord.gg/artcraft, https://getartcraft.com, https://getartcraft.com/apps/effectcraft, https://github.com/storytold/effectcraft.
 - **Quality gates** before every commit: `cargo xtask ci` (fmt, clippy -D warnings, tests, layers, assets, wasm).
+- **New workspace crates** must include `[lints] workspace = true` in `Cargo.toml` to inherit `[workspace.lints]`. Production crate roots must declare the required crate-level lint attributes before modules or other crate items; crate-level `//!` documentation may precede them.
 - **Commits:** one task id per commit (`M6.3: trim paths`). Only green states.
 
 ## Running and looking at the app
@@ -29,3 +30,8 @@ EffectCraft is a clean-room, open-source, pure-Rust motion graphics and visual e
 - For UI work, **look at the result**. Headless (no window, works while the user is busy on the machine): `cargo run -p effectcraft-ui-egui --example snapshot -- --out ui.png --step '{"method":"engine.execute","params":{"command":"layer.select","params":{"layers":["#2"]}}}'` (steps are control-channel requests; `--script steps.jsonl`; `{"method":"snap","params":{"path":…}}` for intermediate shots). Or drive the live app via the control channel and take `ui.screenshot` (needs the window visible on screen).
 - After Effects reference: drive AE via ExtendScript (`osascript -e 'tell application "Adobe After Effects 2026" to DoScriptFile "x.jsx"'`) and capture only AE's window (`screencapture -l <windowid>`); keep captures in `plan/aftereffects/ref/` (gitignored), never commit them, never capture the Home screen.
 - Parallel agents: separate git worktrees and `CARGO_TARGET_DIR=target/agent-<name>`; keep every `Cargo.toml` valid (the `crates/*` glob).
+
+## CI workflows
+- Workflows in `.github/workflows/` call the shared workflows in [`storytold/craft-common-actions`](https://github.com/storytold/craft-common-actions) at `@main`, with their inputs and secrets. No other jobs: if no shared workflow does what's needed, it doesn't go here.
+- Don't add or change CI in a feature or fix PR. If the existing workflows can't build or test a change, link an existing craft-common-actions issue or PR, or open a new issue, or a PR only for a small fix that is safe for every app and does not increase CI time.
+- Some workflow files here still run their own jobs. Don't add to them. Moving a job into craft-common-actions is its own task, never part of another PR, and the job stays here until a shared workflow runs it.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index dfa28c9f0..29521ad73 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -7,12 +7,75 @@ work apply to everyone, people and AI agents alike, and they are not negotiable.
 
 You need [Rust](https://rustup.rs/) 1.95 or newer.
 
+On Linux the desktop app plays preview sound through `cpal`, so the build needs a usable ALSA
+pkg-config package: an `alsa.pc` that pkg-config can find, naming the linkable ALSA runtime
+library (usually `libasound.so.2`). `alsa-sys` runs pkg-config at build time; it does not compile
+ALSA's headers. Without a usable package the build fails at link time with an unrelated-looking
+error; `cargo xtask ci` probes pkg-config up front and names the package:
+
+```sh
+sudo dnf install alsa-lib-devel        # Fedora
+sudo apt install libasound2-dev        # Debian / Ubuntu
+sudo pacman -S alsa-lib                # Arch
+```
+
+If you cannot install the package, point `PKG_CONFIG_PATH` at a directory holding an `alsa.pc`
+whose `Libs` line names your system's `libasound` (usually `libasound.so.2`); every CI run needs
+that variable set.
+
 ```sh
 cargo run -p effectcraft -- --demo       # the desktop app, with the demo project
 cargo test --workspace
 cargo xtask ci                           # what every commit must pass
 ```
 
+The default `dev` profile keeps debug info to line tables: builds are fast and panics/backtraces
+still name the file and line, but a debugger cannot show local variables. For an interactive
+debugger session use the `dev-full` profile, which is the same build with full debug info:
+
+```sh
+cargo run --profile dev-full -p effectcraft -- --demo
+```
+
+### Windows
+
+The MSVC toolchain, rustup's default on Windows, is what the releases use: with the Visual Studio
+C++ build tools installed, the commands above work as they are.
+
+The GNU toolchain (`x86_64-pc-windows-gnu`) needs a current mingw-w64 GCC and binutils first on
+`PATH`. They provide the linker and the Windows import libraries, such as `libshlwapi.a` for
+opening links from the app. With MSYS2:
+
+```powershell
+C:\msys64\usr\bin\pacman.exe -S --needed mingw-w64-x86_64-gcc
+$env:PATH = "C:\msys64\mingw64\bin;$env:PATH"
+cargo +stable-x86_64-pc-windows-gnu run -p effectcraft -- --demo
+```
+
+An older MinGW earlier on `PATH` can break the build: CodeBlocks' GCC 8.1 fails to link
+`boa_engine` ([#1882](https://github.com/storytold/effectcraft/issues/1882)).
+
+Rust's bundled LLD and self-contained libraries don't include every import library EffectCraft
+needs, so on their own they stop with `unable to find library` for `-lshlwapi`, `-lktmw32`,
+`-lpropsys` and `-lversion` ([#1886](https://github.com/storytold/effectcraft/issues/1886)). To
+link that way, copy those four from mingw-w64 into a folder of its own and add that folder to the
+search path in your own Cargo config (`%USERPROFILE%\.cargo\config.toml`). Don't add all of
+mingw-w64's `lib` folder: its C runtime clashes with Rust's bundled one
+(`undefined symbol: DllEntryPoint`).
+
+```powershell
+New-Item -ItemType Directory -Force C:\gnu-import-libs
+foreach ($lib in "shlwapi", "ktmw32", "propsys", "version") {
+    Copy-Item "C:\msys64\mingw64\lib\lib$lib.a" C:\gnu-import-libs\
+}
+```
+
+```toml
+[target.x86_64-pc-windows-gnu]
+linker = "rust-lld"
+rustflags = ["-C", "link-self-contained=yes", "-L", "native=C:/gnu-import-libs"]
+```
+
 ## Ground rules
 
 - **Clean room.** Work from After Effects' public documentation and its observable behaviour only.
diff --git a/Cargo.lock b/Cargo.lock
index 512889540..7d27b959f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -209,14 +209,14 @@ dependencies = [
  "clipboard-win",
  "image",
  "log",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-core-foundation",
  "objc2-core-graphics",
  "objc2-foundation 0.3.2",
  "parking_lot",
  "percent-encoding",
- "windows-sys 0.60.2",
+ "windows-sys 0.59.0",
  "wl-clipboard-rs",
  "x11rb",
 ]
@@ -437,15 +437,6 @@ version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
-[[package]]
-name = "bit-set"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
-dependencies = [
- "bit-vec 0.8.0",
-]
-
 [[package]]
 name = "bit-set"
 version = "0.10.0"
@@ -456,10 +447,13 @@ dependencies = [
 ]
 
 [[package]]
-name = "bit-vec"
-version = "0.8.0"
+name = "bit-set"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+checksum = "56d87354e4229f54a44f7bf2435906a4656dba36026ab6eaca629a2c436a691c"
+dependencies = [
+ "bit-vec 0.10.1",
+]
 
 [[package]]
 name = "bit-vec"
@@ -467,6 +461,16 @@ version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b71798fca2c1fe1086445a7258a4bc81e6e49dcd24c8d0dd9a1e57395b603f51"
 
+[[package]]
+name = "bit-vec"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5727b15fa97d4f4fee0a3b7c3d550ed0269f54329207b86388de918604e31269"
+dependencies = [
+ "borsh",
+ "serde",
+]
+
 [[package]]
 name = "bit_field"
 version = "0.10.3"
@@ -509,7 +513,7 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
 dependencies = [
- "objc2 0.6.4",
+ "objc2 0.6.5",
 ]
 
 [[package]]
@@ -669,6 +673,30 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "borsh"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "553c5d846a6ba5150c65e3b1b8ec073bcf1abc20f9b7220de384a4443ea4e20a"
+dependencies = [
+ "borsh-derive",
+ "bytes",
+ "cfg_aliases",
+]
+
+[[package]]
+name = "borsh-derive"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12cdfe656708a01f89b451a7d36466e6fe6c414de0aa18fc54f864f6f9ca9f56"
+dependencies = [
+ "once_cell",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 3.0.6",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
@@ -695,6 +723,12 @@ dependencies = [
  "syn 3.0.6",
 ]
 
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
 [[package]]
 name = "byteorder-lite"
 version = "0.1.0"
@@ -758,6 +792,45 @@ dependencies = [
  "wayland-client",
 ]
 
+[[package]]
+name = "candle-core"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c15b675b80d994b2eadb20a4bbe434eabeb454eac3ee5e2b4cf6f147ee9be091"
+dependencies = [
+ "byteorder",
+ "float8",
+ "gemm",
+ "half",
+ "libm",
+ "memmap2",
+ "num-traits",
+ "num_cpus",
+ "rand 0.9.5",
+ "rand_distr",
+ "rayon",
+ "safetensors",
+ "thiserror 2.0.21",
+ "yoke",
+ "zip 7.4.0",
+]
+
+[[package]]
+name = "candle-nn"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3045fa9e7aef8567d209a27d56b692f60b96f4d0569f4c3011f8ca6715c65e03"
+dependencies = [
+ "candle-core",
+ "half",
+ "libc",
+ "num-traits",
+ "rayon",
+ "safetensors",
+ "serde",
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "cast"
 version = "0.3.0"
@@ -832,6 +905,15 @@ dependencies = [
  "error-code",
 ]
 
+[[package]]
+name = "cobs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "codespan-reporting"
 version = "0.13.1"
@@ -1010,36 +1092,98 @@ dependencies = [
 [[package]]
 name = "craft-docpath"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=82a24b006eefa036b43c09a67fb9a3fbd17ffe63#82a24b006eefa036b43c09a67fb9a3fbd17ffe63"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
+
+[[package]]
+name = "craft-ecproj-format"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=ca1b5e2edb8568335c6c14f390307bd5beae8238#ca1b5e2edb8568335c6c14f390307bd5beae8238"
+dependencies = [
+ "serde",
+ "serde_json",
+ "thiserror 2.0.21",
+]
+
+[[package]]
+name = "craft-fonts-build"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
+
+[[package]]
+name = "craft-i18n"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
+dependencies = [
+ "fixed_decimal",
+ "icu_decimal",
+ "icu_locale_core",
+ "icu_locale_fallback",
+ "icu_normalizer",
+ "icu_plurals",
+ "icu_properties",
+ "icu_provider",
+ "icu_provider_adapters",
+ "icu_provider_blob",
+ "log",
+ "objc2-foundation 0.3.2",
+ "sys-locale",
+ "unicode-bidi",
+ "windows-registry",
+ "writeable",
+]
 
 [[package]]
 name = "craft-pdf"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef#9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
  "hayro-syntax",
  "thiserror 2.0.21",
 ]
 
+[[package]]
+name = "craft-quit"
+version = "0.1.0"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
+dependencies = [
+ "dispatch2",
+ "egui",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+]
+
 [[package]]
 name = "craft-ui"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=25da1314d443171b4adeaad2cd9454b273f35c6f#25da1314d443171b4adeaad2cd9454b273f35c6f"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
+ "craft-fonts-build",
+ "craft-i18n",
  "egui",
+ "epaint",
+ "js-sys",
+ "log",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+ "objc2-foundation 0.3.2",
  "serde",
+ "skrifa",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
 name = "craft-update"
 version = "0.1.0"
-source = "git+https://github.com/storytold/craft-libs?rev=495e5971bc024aa96e6ed318cb6e7cd3a0103184#495e5971bc024aa96e6ed318cb6e7cd3a0103184"
+source = "git+https://github.com/storytold/craft-libs?rev=c5a1cbfb5f9049f9270955caffb5bee5997aebf7#c5a1cbfb5f9049f9270955caffb5bee5997aebf7"
 dependencies = [
  "chrono",
  "dunce",
  "egui",
  "flate2",
  "getrandom 0.3.4",
+ "image",
  "log",
  "plist",
  "semver",
@@ -1052,7 +1196,7 @@ dependencies = [
  "verifysign",
  "winreg",
  "winsafe",
- "zip",
+ "zip 9.1.3",
 ]
 
 [[package]]
@@ -1171,7 +1315,7 @@ dependencies = [
  "bitflags 2.13.2",
  "block2 0.6.2",
  "libc",
- "objc2 0.6.4",
+ "objc2 0.6.5",
 ]
 
 [[package]]
@@ -1221,6 +1365,22 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
 
+[[package]]
+name = "dyn-stack"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c4713e43e2886ba72b8271aa66c93d722116acf7a75555cce11dcde84388fe8"
+dependencies = [
+ "bytemuck",
+ "dyn-stack-macros",
+]
+
+[[package]]
+name = "dyn-stack-macros"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d926b4d407d372f141f93bb444696142c29d32962ccbd3531117cf3aa0bfa9"
+
 [[package]]
 name = "dynify"
 version = "0.1.2"
@@ -1252,7 +1412,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "cpal",
  "craft-update",
@@ -1264,10 +1424,10 @@ dependencies = [
  "fmv-macos-events",
  "log",
  "muda",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-foundation 0.3.2",
- "pollster 0.4.0",
+ "pollster 1.0.1",
  "rfd",
  "serde",
  "serde_json",
@@ -1278,10 +1438,11 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-automation"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-engine",
  "effectcraft-host",
+ "effectcraft-model",
  "effectcraft-script",
  "image",
  "serde_json",
@@ -1290,14 +1451,14 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-av1enc"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "filmcraft-av1",
 ]
 
 [[package]]
 name = "effectcraft-cli"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "cpu-time",
  "effectcraft-automation",
@@ -1305,7 +1466,10 @@ dependencies = [
  "effectcraft-gpu",
  "effectcraft-host",
  "effectcraft-render",
+ "effectcraft-sam2",
+ "effectcraft-segment",
  "effectcraft-time",
+ "effectcraft-track",
  "effectcraft-ui-egui",
  "image",
  "serde_json",
@@ -1313,7 +1477,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-color"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "proptest",
  "serde",
@@ -1321,7 +1485,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-effects"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "chrono",
  "effectcraft-color",
@@ -1339,7 +1503,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-engine"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "chrono",
  "craft-docpath",
@@ -1356,6 +1520,7 @@ dependencies = [
  "effectcraft-psd",
  "effectcraft-raster",
  "effectcraft-render",
+ "effectcraft-sam2",
  "effectcraft-segment",
  "effectcraft-svg",
  "effectcraft-text",
@@ -1366,15 +1531,17 @@ dependencies = [
  "kurbo",
  "log",
  "rayon",
+ "same-file",
  "serde",
  "serde_json",
+ "tempfile",
  "thiserror 2.0.21",
  "web-time",
 ]
 
 [[package]]
 name = "effectcraft-export"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-av1enc",
  "effectcraft-color",
@@ -1404,7 +1571,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-expr"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "boa_engine",
  "effectcraft-color",
@@ -1421,7 +1588,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-geom"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "proptest",
  "serde",
@@ -1429,7 +1596,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-gpu"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "bytemuck",
  "effectcraft-color",
@@ -1443,7 +1610,7 @@ dependencies = [
  "effectcraft-time",
  "js-sys",
  "log",
- "pollster 0.4.0",
+ "pollster 1.0.1",
  "wasm-bindgen",
  "web-time",
  "wgpu",
@@ -1451,14 +1618,14 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-hevcenc"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "filmcraft-hevc",
 ]
 
 [[package]]
 name = "effectcraft-host"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-engine",
  "effectcraft-export",
@@ -1483,7 +1650,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-interchange"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-color",
  "effectcraft-keyframe",
@@ -1502,7 +1669,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-keyframe"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-color",
  "effectcraft-geom",
@@ -1514,7 +1681,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-lottie"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "craft-docpath",
  "effectcraft-color",
@@ -1532,9 +1699,10 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-media"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "craft-docpath",
+ "effectcraft-color",
  "effectcraft-model",
  "effectcraft-pdf",
  "effectcraft-project",
@@ -1544,28 +1712,31 @@ dependencies = [
  "effectcraft-svg",
  "effectcraft-time",
  "exr",
+ "filmcraft-aac",
  "filmcraft-codecs",
  "filmcraft-color",
  "filmcraft-frame",
  "filmcraft-isobmff",
+ "filmcraft-matroska",
  "filmcraft-media",
+ "filmcraft-mpegts",
  "filmcraft-time",
  "gif",
  "image",
  "log",
  "rayon",
  "serde_json",
- "symphonia",
  "thiserror 2.0.21",
 ]
 
 [[package]]
 name = "effectcraft-model"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-geom",
  "image",
- "miniz_oxide 0.8.9",
+ "log",
+ "miniz_oxide 0.9.1",
  "serde",
  "serde_json",
  "thiserror 2.0.21",
@@ -1573,14 +1744,14 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-opusenc"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "filmcraft-opus",
 ]
 
 [[package]]
 name = "effectcraft-path"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-geom",
  "effectcraft-keyframe",
@@ -1592,7 +1763,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-pdf"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "craft-pdf",
  "effectcraft-raster",
@@ -1600,7 +1771,7 @@ dependencies = [
  "effectcraft-text",
  "image",
  "kurbo",
- "miniz_oxide 0.8.9",
+ "miniz_oxide 0.9.1",
  "skrifa",
  "wasm-bindgen-test",
  "zune-jpeg",
@@ -1608,7 +1779,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-plugin"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-effects",
  "effectcraft-keyframe",
@@ -1620,8 +1791,9 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-project"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
+ "craft-ecproj-format",
  "effectcraft-color",
  "effectcraft-geom",
  "effectcraft-keyframe",
@@ -1633,14 +1805,14 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-psd"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
- "miniz_oxide 0.8.9",
+ "miniz_oxide 0.9.1",
 ]
 
 [[package]]
 name = "effectcraft-raster"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-color",
  "effectcraft-geom",
@@ -1649,7 +1821,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-render"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-color",
  "effectcraft-effects",
@@ -1669,9 +1841,24 @@ dependencies = [
  "web-time",
 ]
 
+[[package]]
+name = "effectcraft-sam2"
+version = "0.20.0"
+dependencies = [
+ "bytemuck",
+ "candle-core",
+ "candle-nn",
+ "effectcraft-segment",
+ "half",
+ "log",
+ "pollster 1.0.1",
+ "rayon",
+ "wgpu",
+]
+
 [[package]]
 name = "effectcraft-script"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "boa_engine",
  "effectcraft-engine",
@@ -1689,16 +1876,16 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-segment"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
- "miniz_oxide 0.8.9",
+ "miniz_oxide 0.9.1",
  "ndarray",
  "rayon",
 ]
 
 [[package]]
 name = "effectcraft-svg"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-geom",
  "effectcraft-path",
@@ -1710,7 +1897,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-text"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-keyframe",
  "harfrust",
@@ -1722,7 +1909,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-time"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "proptest",
  "serde",
@@ -1730,7 +1917,7 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-track"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-raster",
  "effectcraft-segment",
@@ -1742,9 +1929,10 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-ui-egui"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "chrono",
+ "craft-quit",
  "craft-ui",
  "craft-update",
  "effectcraft-color",
@@ -1756,6 +1944,7 @@ dependencies = [
  "effectcraft-path",
  "effectcraft-project",
  "effectcraft-render",
+ "effectcraft-segment",
  "effectcraft-text",
  "effectcraft-time",
  "eframe",
@@ -1765,7 +1954,7 @@ dependencies = [
  "image",
  "kurbo",
  "log",
- "pollster 0.4.0",
+ "pollster 1.0.1",
  "rayon",
  "serde",
  "serde_json",
@@ -1776,11 +1965,11 @@ dependencies = [
 
 [[package]]
 name = "effectcraft-vp9enc"
-version = "0.17.0"
+version = "0.20.0"
 
 [[package]]
 name = "effectcraft-web"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "effectcraft-engine",
  "effectcraft-export",
@@ -1818,7 +2007,7 @@ dependencies = [
  "image",
  "js-sys",
  "log",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-foundation 0.3.2",
  "parking_lot",
@@ -1886,7 +2075,7 @@ dependencies = [
  "egui",
  "image",
  "log",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-foundation 0.3.2",
  "objc2-ui-kit 0.3.2",
@@ -1964,6 +2153,18 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
 
+[[package]]
+name = "enum-as-inner"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+
 [[package]]
 name = "enumflags2"
 version = "0.7.12"
@@ -2049,7 +2250,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2155,8 +2356,8 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-aac"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-bitstream",
  "thiserror 2.0.21",
@@ -2164,40 +2365,57 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-ac3"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "thiserror 2.0.21",
 ]
 
 [[package]]
-name = "filmcraft-av1"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+name = "filmcraft-apv"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-bitstream",
  "rayon",
  "thiserror 2.0.21",
 ]
 
+[[package]]
+name = "filmcraft-av1"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
+dependencies = [
+ "filmcraft-bitstream",
+ "rayon",
+ "thiserror 2.0.21",
+]
+
+[[package]]
+name = "filmcraft-avi"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
+
 [[package]]
 name = "filmcraft-bitstream"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 
 [[package]]
 name = "filmcraft-cfb"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 
 [[package]]
 name = "filmcraft-codecs"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-aac",
  "filmcraft-ac3",
+ "filmcraft-apv",
  "filmcraft-av1",
+ "filmcraft-avi",
  "filmcraft-bitstream",
  "filmcraft-color",
  "filmcraft-dnx",
@@ -2207,6 +2425,7 @@ dependencies = [
  "filmcraft-isobmff",
  "filmcraft-matroska",
  "filmcraft-media",
+ "filmcraft-mpa",
  "filmcraft-mpeg2v",
  "filmcraft-mpegts",
  "filmcraft-mxf",
@@ -2214,9 +2433,11 @@ dependencies = [
  "filmcraft-opus",
  "filmcraft-prores",
  "filmcraft-time",
+ "filmcraft-vp8",
  "filmcraft-vp9",
  "image",
  "log",
+ "rayon",
  "symphonia",
  "thiserror 2.0.21",
  "web-time",
@@ -2224,16 +2445,25 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-color"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "filmcraft-dng"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
+dependencies = [
+ "rayon",
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "filmcraft-dnx"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-bitstream",
  "rayon",
@@ -2242,8 +2472,8 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-frame"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-color",
  "filmcraft-time",
@@ -2253,16 +2483,16 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-geom"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "filmcraft-h264"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-bitstream",
  "rayon",
@@ -2271,8 +2501,8 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-h264enc"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-bitstream",
  "rayon",
@@ -2281,8 +2511,8 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-hevc"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-bitstream",
  "rayon",
@@ -2291,8 +2521,8 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-interchange"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-cfb",
  "filmcraft-color",
@@ -2308,8 +2538,8 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-isobmff"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-bitstream",
  "thiserror 2.0.21",
@@ -2317,15 +2547,16 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-matroska"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 
 [[package]]
 name = "filmcraft-media"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-color",
+ "filmcraft-dng",
  "filmcraft-frame",
  "filmcraft-time",
  "image",
@@ -2334,10 +2565,19 @@ dependencies = [
  "thiserror 2.0.21",
 ]
 
+[[package]]
+name = "filmcraft-mpa"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
+dependencies = [
+ "filmcraft-bitstream",
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "filmcraft-mpeg2v"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "rayon",
  "thiserror 2.0.21",
@@ -2345,31 +2585,31 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-mpegts"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "thiserror 2.0.21",
 ]
 
 [[package]]
 name = "filmcraft-mxf"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 
 [[package]]
 name = "filmcraft-ogg"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 
 [[package]]
 name = "filmcraft-opus"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 
 [[package]]
 name = "filmcraft-project"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-color",
  "filmcraft-geom",
@@ -2382,8 +2622,8 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-prores"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-bitstream",
  "rayon",
@@ -2392,16 +2632,24 @@ dependencies = [
 
 [[package]]
 name = "filmcraft-time"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "filmcraft-vp8"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
+dependencies = [
+ "thiserror 2.0.21",
+]
+
 [[package]]
 name = "filmcraft-vp9"
-version = "0.1.1"
-source = "git+https://github.com/storytold/filmcraft?rev=2c5ba7a72619935f0481f99d59409e0d1844b234#2c5ba7a72619935f0481f99d59409e0d1844b234"
+version = "0.8.0"
+source = "git+https://github.com/storytold/filmcraft?rev=09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5#09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5"
 dependencies = [
  "filmcraft-bitstream",
  "rayon",
@@ -2414,6 +2662,17 @@ version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aedcfb3409746eddb02b9e19ebda1c3394f759a152e48ee875a0844d1b955484"
 
+[[package]]
+name = "fixed_decimal"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2214fb00f669ee96bee5bb29dfb1ddabe058b2bc426817efc79afa03c9bc55ae"
+dependencies = [
+ "displaydoc",
+ "smallvec",
+ "writeable",
+]
+
 [[package]]
 name = "fixedbitset"
 version = "0.5.7"
@@ -2431,13 +2690,25 @@ dependencies = [
  "zlib-rs",
 ]
 
+[[package]]
+name = "float8"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "719a903cc23e4a89e87962c2a80fdb45cdaad0983a89bd150bb57b4c8571a7d5"
+dependencies = [
+ "half",
+ "num-traits",
+ "rand 0.9.5",
+ "rand_distr",
+]
+
 [[package]]
 name = "fmv-macos-events"
 version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "90642cf66dde7f205dc8b42dfe57b47d0f3a29f571b832742883ef512e23fe55"
 dependencies = [
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-foundation 0.3.2",
 ]
@@ -2573,6 +2844,125 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "gemm"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa0673db364b12263d103b68337a68fbecc541d6f6b61ba72fe438654709eacb"
+dependencies = [
+ "dyn-stack",
+ "gemm-c32",
+ "gemm-c64",
+ "gemm-common",
+ "gemm-f16",
+ "gemm-f32",
+ "gemm-f64",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-c32"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "086936dbdcb99e37aad81d320f98f670e53c1e55a98bee70573e83f95beb128c"
+dependencies = [
+ "dyn-stack",
+ "gemm-common",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-c64"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20c8aeeeec425959bda4d9827664029ba1501a90a0d1e6228e48bef741db3a3f"
+dependencies = [
+ "dyn-stack",
+ "gemm-common",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-common"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88027625910cc9b1085aaaa1c4bc46bb3a36aad323452b33c25b5e4e7c8e2a3e"
+dependencies = [
+ "bytemuck",
+ "dyn-stack",
+ "half",
+ "libm",
+ "num-complex",
+ "num-traits",
+ "once_cell",
+ "paste",
+ "pulp",
+ "raw-cpuid",
+ "rayon",
+ "seq-macro",
+ "sysctl",
+]
+
+[[package]]
+name = "gemm-f16"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3df7a55202e6cd6739d82ae3399c8e0c7e1402859b30e4cb780e61525d9486e"
+dependencies = [
+ "dyn-stack",
+ "gemm-common",
+ "gemm-f32",
+ "half",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid",
+ "rayon",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-f32"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02e0b8c9da1fbec6e3e3ab2ce6bc259ef18eb5f6f0d3e4edf54b75f9fd41a81c"
+dependencies = [
+ "dyn-stack",
+ "gemm-common",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid",
+ "seq-macro",
+]
+
+[[package]]
+name = "gemm-f64"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "056131e8f2a521bfab322f804ccd652520c79700d81209e9d9275bbdecaadc6a"
+dependencies = [
+ "dyn-stack",
+ "gemm-common",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "raw-cpuid",
+ "seq-macro",
+]
+
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -2693,7 +3083,7 @@ dependencies = [
  "glutin_glx_sys",
  "glutin_wgl_sys",
  "libloading",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-core-foundation",
  "objc2-foundation 0.3.2",
@@ -2774,9 +3164,12 @@ version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
+ "bytemuck",
  "cfg-if",
  "crunchy",
  "num-traits",
+ "rand 0.9.5",
+ "rand_distr",
  "zerocopy",
 ]
 
@@ -2816,6 +3209,8 @@ dependencies = [
  "allocator-api2",
  "equivalent",
  "foldhash 0.2.0",
+ "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -2838,7 +3233,7 @@ checksum = "9f4d0e94ddd48749f06bbe4e5389fb9799a0c45bcaf00495042076ef05e3241a"
 [[package]]
 name = "hayro-jbig2"
 version = "0.3.0"
-source = "git+https://github.com/storytold/craft-libs?rev=9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef#9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
  "hayro-ccitt",
 ]
@@ -2852,7 +3247,7 @@ checksum = "c75ab947623ef4ccaa7acf0579edf7cbb5a73838e3839a7be73335e522f433a1"
 [[package]]
 name = "hayro-syntax"
 version = "0.7.2"
-source = "git+https://github.com/storytold/craft-libs?rev=9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef#9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef"
+source = "git+https://github.com/storytold/craft-libs?rev=92d392cff132eaf53e13afff77f38b5c11b73aa0#92d392cff132eaf53e13afff77f38b5c11b73aa0"
 dependencies = [
  "hayro-jbig2",
  "hayro-jpeg2000",
@@ -2910,6 +3305,23 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "icu_decimal"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9eb8f655bba2d0c0459e43a5b0e6cd3cd388109898fb3d85d048165e8b0abd08"
+dependencies = [
+ "displaydoc",
+ "fixed_decimal",
+ "icu_locale_core",
+ "icu_pattern",
+ "icu_plurals",
+ "icu_provider",
+ "serde",
+ "writeable",
+ "zerovec",
+]
+
 [[package]]
 name = "icu_locale_core"
 version = "2.3.0"
@@ -2918,11 +3330,32 @@ checksum = "d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb"
 dependencies = [
  "displaydoc",
  "litemap",
+ "serde",
  "tinystr",
  "writeable",
  "zerovec",
 ]
 
+[[package]]
+name = "icu_locale_fallback"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9"
+dependencies = [
+ "icu_locale_core",
+ "icu_locale_fallback_data",
+ "icu_provider",
+ "potential_utf",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_fallback_data"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8"
+
 [[package]]
 name = "icu_normalizer"
 version = "2.3.0"
@@ -2935,6 +3368,7 @@ dependencies = [
  "icu_provider",
  "smallvec",
  "utf16_iter",
+ "utf8_iter",
  "write16",
  "zerovec",
 ]
@@ -2945,6 +3379,32 @@ version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0"
 
+[[package]]
+name = "icu_pattern"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b3db611446bd92c246b03e4aa0bafa71ddb194af431ddbb42b9d70e4bfce1a0"
+dependencies = [
+ "displaydoc",
+ "either",
+ "serde",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_plurals"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e475e6766ef87b1d3c1f97be6363995b0bfaeddbc789671615df598a97ff0593"
+dependencies = [
+ "displaydoc",
+ "fixed_decimal",
+ "icu_provider",
+ "serde",
+ "zerovec",
+]
+
 [[package]]
 name = "icu_properties"
 version = "2.3.0"
@@ -2974,6 +3434,9 @@ checksum = "d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73"
 dependencies = [
  "displaydoc",
  "icu_locale_core",
+ "postcard",
+ "serde",
+ "stable_deref_trait",
  "writeable",
  "yoke",
  "zerofrom",
@@ -2981,6 +3444,30 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "icu_provider_adapters"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df887bc4f55dbc773c7c45a0c7dfa75be886f7b7812830a71ab7271cc1801820"
+dependencies = [
+ "icu_locale_fallback",
+ "icu_provider",
+]
+
+[[package]]
+name = "icu_provider_blob"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5916b44fac319d3f58e4d8d805a627df19e27937b582cd99fcde3bb6b7ce1b0e"
+dependencies = [
+ "icu_provider",
+ "postcard",
+ "serde",
+ "writeable",
+ "zerotrie",
+ "zerovec",
+]
+
 [[package]]
 name = "idna"
 version = "1.1.0"
@@ -3268,9 +3755,9 @@ checksum = "d4a5ff6bcca6c4867b1c4fd4ef63e4db7436ef363e0ad7531d1558856bae64f4"
 
 [[package]]
 name = "linesweeper"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c19728333c060c6569a53c9a0e56c4be0df52cb4e6e07a8fbe16084cecce769"
+checksum = "a25df1b0c5432893f41bba817150e323703ee5f6d974f3a6808ac7fd7f046d18"
 dependencies = [
  "arrayvec",
  "kurbo",
@@ -3296,6 +3783,9 @@ name = "litemap"
 version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
 name = "litrs"
@@ -3320,9 +3810,9 @@ checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
 
 [[package]]
 name = "lz4_flex"
-version = "0.11.6"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "373f5eceeeab7925e0c1098212f2fbc4d416adec9d35051a6ab251e824c1854a"
+checksum = "ecbdfe44b1bd960b68170b417450a628c43f7cf56bb3c5317e61cb230ee7f226"
 
 [[package]]
 name = "mach2"
@@ -3356,6 +3846,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0"
 dependencies = [
  "libc",
+ "stable_deref_trait",
 ]
 
 [[package]]
@@ -3409,21 +3900,20 @@ dependencies = [
 
 [[package]]
 name = "muda"
-version = "0.21.0"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6744ab645ebe79f9c428455c7cb9dfa4275fa3b50a25408e08f927da8dc618c"
+checksum = "4340e89c178916e62879c5c36b7f699019369be413e496178a6983ce91b8bc03"
 dependencies = [
  "crossbeam-channel",
  "dpi",
  "keyboard-types",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-core-foundation",
  "objc2-foundation 0.3.2",
- "once_cell",
  "png",
  "thiserror 2.0.21",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3548,7 +4038,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3608,6 +4098,16 @@ dependencies = [
  "libm",
 ]
 
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
 [[package]]
 name = "num_enum"
 version = "0.7.6"
@@ -3657,9 +4157,9 @@ dependencies = [
 
 [[package]]
 name = "objc2"
-version = "0.6.4"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
+checksum = "08849bbd4767dfae9457696856ae1c84fe4e0281bbe4a7abff2d0e06fb7981f8"
 dependencies = [
  "objc2-encode",
 ]
@@ -3688,7 +4188,7 @@ checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
 dependencies = [
  "bitflags 2.13.2",
  "block2 0.6.2",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-core-foundation",
  "objc2-core-graphics",
  "objc2-foundation 0.3.2",
@@ -3702,7 +4202,7 @@ checksum = "6948501a91121d6399b79abaa33a8aa4ea7857fe019f341b8c23ad6e81b79b08"
 dependencies = [
  "bitflags 2.13.2",
  "libc",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-core-audio",
  "objc2-core-audio-types",
  "objc2-core-foundation",
@@ -3740,7 +4240,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1eebcea8b0dbff5f7c8504f3107c68fc061a3eb44932051c8cf8a68d969c3b2"
 dependencies = [
  "dispatch2",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-core-audio-types",
  "objc2-core-foundation",
 ]
@@ -3752,7 +4252,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a89f2ec274a0cf4a32642b2991e8b351a404d290da87bb6a9a9d8632490bd1c"
 dependencies = [
  "bitflags 2.13.2",
- "objc2 0.6.4",
+ "objc2 0.6.5",
 ]
 
 [[package]]
@@ -3775,7 +4275,7 @@ checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
 dependencies = [
  "bitflags 2.13.2",
  "dispatch2",
- "objc2 0.6.4",
+ "objc2 0.6.5",
 ]
 
 [[package]]
@@ -3786,7 +4286,7 @@ checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
 dependencies = [
  "bitflags 2.13.2",
  "dispatch2",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-core-foundation",
  "objc2-io-surface",
 ]
@@ -3842,7 +4342,7 @@ checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
 dependencies = [
  "bitflags 2.13.2",
  "block2 0.6.2",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-core-foundation",
 ]
 
@@ -3853,7 +4353,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
 dependencies = [
  "bitflags 2.13.2",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-core-foundation",
 ]
 
@@ -3889,7 +4389,7 @@ checksum = "a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794"
 dependencies = [
  "bitflags 2.13.2",
  "block2 0.6.2",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-foundation 0.3.2",
 ]
 
@@ -3913,7 +4413,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
 dependencies = [
  "bitflags 2.13.2",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-core-foundation",
  "objc2-core-graphics",
  "objc2-foundation 0.3.2",
@@ -3958,7 +4458,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22"
 dependencies = [
  "bitflags 2.13.2",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-core-foundation",
  "objc2-foundation 0.3.2",
 ]
@@ -4289,12 +4789,24 @@ dependencies = [
  "portable-atomic",
 ]
 
+[[package]]
+name = "postcard"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+dependencies = [
+ "cobs",
+ "serde",
+]
+
 [[package]]
 name = "potential_utf"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661"
 dependencies = [
+ "serde_core",
+ "writeable",
  "zerovec",
 ]
 
@@ -4345,16 +4857,17 @@ checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"
 
 [[package]]
 name = "proptest"
-version = "1.11.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
+checksum = "b8530004ccb15eae51c7e40009fbe317f341f804db54dc033eec1c50be28cfa0"
 dependencies = [
- "bit-set 0.8.0",
- "bit-vec 0.8.0",
+ "bit-set 0.11.1",
+ "bit-vec 0.10.1",
  "bitflags 2.13.2",
+ "chacha20",
+ "core_detect",
  "num-traits",
- "rand 0.9.5",
- "rand_chacha",
+ "rand 0.10.3",
  "rand_xorshift",
  "regex-syntax",
  "rusty-fork",
@@ -4489,12 +5002,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
 
 [[package]]
-name = "rand_xorshift"
-version = "0.4.0"
+name = "rand_distr"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
+checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463"
 dependencies = [
- "rand_core 0.9.5",
+ "num-traits",
+ "rand 0.9.5",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60aa6af80be32871323012e02e6e65f8a7cc7890931ae421d217ad8fe0df2ccf"
+dependencies = [
+ "rand_core 0.10.1",
 ]
 
 [[package]]
@@ -4524,7 +5047,7 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40d213455a5f1dc59214213c7330e074ddf8114c9a42411eb890c767357ce135"
 dependencies = [
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-core-foundation",
  "objc2-foundation 0.3.2",
  "objc2-quartz-core 0.3.2",
@@ -4632,7 +5155,7 @@ dependencies = [
  "js-sys",
  "libc",
  "log",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-core-foundation",
  "objc2-foundation 0.3.2",
@@ -4664,9 +5187,9 @@ dependencies = [
 
 [[package]]
 name = "roxmltree"
-version = "0.21.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb"
+checksum = "9da7f59328b09405b181fee1018925fad50f157afb43c0c0f5c522c256dd5907"
 dependencies = [
  "memchr",
 ]
@@ -4715,7 +5238,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4772,7 +5295,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4816,6 +5339,17 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04d056b875a9d2e6cb9a61d127afee9ac5999b9f87bcb32079d1318e505be714"
 
+[[package]]
+name = "safetensors"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "675656c1eabb620b921efea4f9199f97fc86e36dd6ffd1fbbe48d0f59a4987f5"
+dependencies = [
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -4902,6 +5436,12 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
 
+[[package]]
+name = "seq-macro"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
+
 [[package]]
 name = "serde"
 version = "1.0.229"
@@ -4934,9 +5474,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.151"
+version = "1.0.154"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
 dependencies = [
  "itoa",
  "memchr",
@@ -5142,7 +5682,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5423,7 +5963,24 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8eab9a99a024a169fe8a903cf9d4a3b3601109bcc13bd9e3c6fff259138626c4"
 dependencies = [
+ "js-sys",
  "libc",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "sysctl"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc"
+dependencies = [
+ "bitflags 2.13.2",
+ "byteorder",
+ "enum-as-inner",
+ "libc",
+ "thiserror 1.0.69",
+ "walkdir",
 ]
 
 [[package]]
@@ -5458,7 +6015,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix 1.1.5",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -5620,6 +6177,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643"
 dependencies = [
  "displaydoc",
+ "serde_core",
  "zerovec",
 ]
 
@@ -5741,6 +6299,12 @@ dependencies = [
  "rustc-hash 2.1.3",
 ]
 
+[[package]]
+name = "typed-path"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54ec2755506471f54baf5e4bb5499d8e510cc1caf271270e778a736bd2d7336c"
+
 [[package]]
 name = "typed-path"
 version = "0.13.0"
@@ -5761,7 +6325,7 @@ checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
 dependencies = [
  "memoffset",
  "tempfile",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -6326,7 +6890,7 @@ dependencies = [
  "jni 0.22.4",
  "log",
  "ndk-context",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-foundation 0.3.2",
  "url",
@@ -6476,7 +7040,7 @@ dependencies = [
  "naga",
  "naga-types",
  "ndk-sys",
- "objc2 0.6.4",
+ "objc2 0.6.5",
  "objc2-core-foundation",
  "objc2-core-graphics",
  "objc2-foundation 0.3.2",
@@ -6553,7 +7117,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -6665,6 +7229,17 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-registry"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
+dependencies = [
+ "windows-link",
+ "windows-result 0.4.1",
+ "windows-strings",
+]
+
 [[package]]
 name = "windows-result"
 version = "0.1.2"
@@ -6719,15 +7294,6 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
-dependencies = [
- "windows-targets 0.53.5",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -6761,30 +7327,13 @@ dependencies = [
  "windows_aarch64_gnullvm 0.52.6",
  "windows_aarch64_msvc 0.52.6",
  "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
+ "windows_i686_gnullvm",
  "windows_i686_msvc 0.52.6",
  "windows_x86_64_gnu 0.52.6",
  "windows_x86_64_gnullvm 0.52.6",
  "windows_x86_64_msvc 0.52.6",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.53.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
-dependencies = [
- "windows-link",
- "windows_aarch64_gnullvm 0.53.1",
- "windows_aarch64_msvc 0.53.1",
- "windows_i686_gnu 0.53.1",
- "windows_i686_gnullvm 0.53.1",
- "windows_i686_msvc 0.53.1",
- "windows_x86_64_gnu 0.53.1",
- "windows_x86_64_gnullvm 0.53.1",
- "windows_x86_64_msvc 0.53.1",
-]
-
 [[package]]
 name = "windows-threading"
 version = "0.2.1"
@@ -6806,12 +7355,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.42.2"
@@ -6824,12 +7367,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.42.2"
@@ -6842,24 +7379,12 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
-
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.42.2"
@@ -6872,12 +7397,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.42.2"
@@ -6890,12 +7409,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.2"
@@ -6908,12 +7421,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.42.2"
@@ -6926,12 +7433,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
-
 [[package]]
 name = "winit"
 version = "0.30.13"
@@ -7004,9 +7505,9 @@ dependencies = [
 
 [[package]]
 name = "winresource"
-version = "0.1.31"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0986a8b1d586b7d3e4fe3d9ea39fb451ae22869dcea4aa109d287a374d866087"
+checksum = "a2bc6d36480b829272a5bdabf08e6dca8004761c1da7e35efef800540c66221b"
 dependencies = [
  "toml",
  "version_check",
@@ -7053,6 +7554,9 @@ name = "writeable"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
+dependencies = [
+ "either",
+]
 
 [[package]]
 name = "x11-dl"
@@ -7119,9 +7623,10 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7"
 
 [[package]]
 name = "xtask"
-version = "0.17.0"
+version = "0.20.0"
 dependencies = [
  "chrono",
+ "pkg-config",
  "serde_json",
  "tempfile",
 ]
@@ -7309,8 +7814,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f"
 dependencies = [
  "displaydoc",
+ "litemap",
+ "serde_core",
  "yoke",
  "zerofrom",
+ "zerovec",
 ]
 
 [[package]]
@@ -7319,6 +7827,7 @@ version = "0.11.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8"
 dependencies = [
+ "serde",
  "yoke",
  "zerofrom",
  "zerovec-derive",
@@ -7337,9 +7846,21 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "9.1.0"
+version = "7.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2886b00003a72c4ccee3f42cfc34908d33b2508a74d827dc2a4244706475c704"
+checksum = "cc12baa6db2b15a140161ce53d72209dacea594230798c24774139b54ecaa980"
+dependencies = [
+ "crc32fast",
+ "indexmap",
+ "memchr",
+ "typed-path 0.12.4",
+]
+
+[[package]]
+name = "zip"
+version = "9.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1156b39d142a34b999c2310a50455e0cb3760bf7efad0122f796d813bee26ccb"
 dependencies = [
  "crc32fast",
  "flate2",
@@ -7347,7 +7868,7 @@ dependencies = [
  "indexmap",
  "memchr",
  "nix",
- "typed-path",
+ "typed-path 0.13.0",
  "windows-sys 0.61.2",
  "zopfli",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 2057b6e19..9e63ffc26 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,16 +4,19 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/*"]
 
 [workspace.package]
-version = "0.17.0"
+version = "0.20.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"
 repository = "https://github.com/storytold/effectcraft"
 
 [workspace.dependencies]
-craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef", version = "=0.1.0", default-features = false, features = ["read"] }
-craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "495e5971bc024aa96e6ed318cb6e7cd3a0103184", features = ["egui"] }
-craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "82a24b006eefa036b43c09a67fb9a3fbd17ffe63" }
+craft-pdf = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", version = "=0.1.0", default-features = false, features = ["read"] }
+craft-docpath = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
+craft-quit = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0" }
+craft-ecproj-format = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "ca1b5e2edb8568335c6c14f390307bd5beae8238" }
+# craft-update: app-specific pretend versions apply to startup and manual checks.
+craft-update = { git = "https://github.com/storytold/craft-libs", version = "=0.1.0", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7", features = ["egui"] }
 # internal
 effectcraft-time = { path = "crates/time" }
 effectcraft-geom = { path = "crates/geom" }
@@ -26,6 +29,7 @@ effectcraft-text = { path = "crates/text" }
 effectcraft-effects = { path = "crates/effects" }
 effectcraft-track = { path = "crates/track" }
 effectcraft-segment = { path = "crates/segment" }
+effectcraft-sam2 = { path = "crates/sam2" }
 effectcraft-model = { path = "crates/model" }
 effectcraft-render = { path = "crates/render" }
 effectcraft-gpu = { path = "crates/gpu" }
@@ -73,42 +77,44 @@ skrifa = { version = "0.44", default-features = false, features = ["std"] }
 harfrust = { version = "0.12", default-features = false, features = ["std"] }
 exr = "1.74"
 image = { version = "0.25", default-features = false, features = ["png", "jpeg"] }
+same-file = "1.0"
+tempfile = "3.27"
 
 # media codecs + containers: FilmCraft's pure-Rust crates, pinned to a revision (plan/adr/0001).
 # Only `crates/media`, `crates/export` and `crates/interchange` may depend on these.
-filmcraft-codecs = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-media = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-frame = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-color = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-time = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
+filmcraft-codecs = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-media = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-frame = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-color = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-time = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
 # encoders + muxer (crates/export)
-filmcraft-h264enc = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-prores = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-aac = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-isobmff = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
+filmcraft-h264enc = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-prores = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-aac = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-isobmff = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+# container headers read for AAC channel layouts (crates/media)
+filmcraft-matroska = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-mpegts = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
 # decoder used as the round-trip oracle of effectcraft-opusenc (crates/export dev-dependency)
-filmcraft-opus = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-vp9 = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
+filmcraft-opus = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-vp9 = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
 # decoders used as the round-trip oracles of effectcraft-hevcenc / effectcraft-av1enc (dev-dependencies only)
-filmcraft-hevc = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-av1 = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
+filmcraft-hevc = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-av1 = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
 # timeline interchange (EDL, FCP7 XML, FCPXML, OTIO) for Premiere Pro interop (crates/interchange only)
-filmcraft-interchange = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-project = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-filmcraft-geom = { git = "https://github.com/storytold/filmcraft", rev = "2c5ba7a72619935f0481f99d59409e0d1844b234" }
-# The symphonia filmcraft-codecs already builds, named only to turn on its AIFF reader: the pinned
-# rev enables wav alone (FilmCraft main enables aiff too). Drop it when the pin moves past that.
-symphonia = { version = "0.5.5", default-features = false, features = ["aiff"] }
+filmcraft-interchange = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-project = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
+filmcraft-geom = { git = "https://github.com/storytold/filmcraft", rev = "09aaf9bf15d510eda1c413c0ccabb1d7e08b41c5" }
 
 # gpu (the same wgpu eframe / egui-wgpu use)
 wgpu = { version = "30.0.1", features = ["fragile-send-sync-non-atomic-wasm"] }
 bytemuck = "1"
-pollster = "0.4"
+pollster = "1"
 
 # ui
 # Shared frontend components; keep this dependency above the engine boundary.
 # Shared UI and the complete egui family select reviewed immutable commits below.
-craft-ui = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "25da1314d443171b4adeaad2cd9454b273f35c6f", features = ["serde"] }
+craft-ui = { version = "0.1.0", git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", features = ["serde"] }
 # `default_fonts` and `monochrome_emoji_fonts` are explicit: the app's `FontDefinitions::default()`
 # and its `✔`/`▣` chrome glyphs need both, and kittest's own dev-dependencies do not propagate.
 egui = { version = "0.37", default-features = false, features = ["default_fonts", "monochrome_emoji_fonts"] }
@@ -130,14 +136,18 @@ sys-locale = "0.3"
 # filmcraft-prores = { path = "../filmcraft/crates/prores" }
 # filmcraft-aac = { path = "../filmcraft/crates/aac" }
 # filmcraft-isobmff = { path = "../filmcraft/crates/isobmff" }
+# filmcraft-matroska = { path = "../filmcraft/crates/matroska" }
+# filmcraft-mpegts = { path = "../filmcraft/crates/mpegts" }
 
 [workspace.lints.rust]
 unsafe_code = "forbid"
 
 [workspace.lints.clippy]
+cognitive_complexity = "deny"
+too_many_arguments = "deny"
+wildcard_imports = "deny"
 dbg_macro = "warn"
 todo = "warn"
-too_many_arguments = "allow"
 needless_range_loop = "allow"
 type_complexity = "allow"
 
@@ -150,6 +160,13 @@ opt-level = 1
 # Panics and backtraces keep file and line; full debug info only made the many test binaries large.
 debug = "line-tables-only"
 
+# Same settings as `dev`, but with full debug info for interactive debugger sessions: local
+# variables, parameters and column breakpoints work. Use `--profile dev-full` when debugging;
+# everything else stays on the fast default. See CONTRIBUTING.md, "Setup".
+[profile.dev-full]
+inherits = "dev"
+debug = true
+
 # Pixel hot loops: keep debug builds interactive.
 [profile.dev.package.effectcraft-raster]
 opt-level = 3
@@ -220,8 +237,8 @@ lto = "thin"
 codegen-units = 1
 
 [patch.crates-io]
-hayro-syntax = { git = "https://github.com/storytold/craft-libs", rev = "9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef", version = "=0.7.2" }
-hayro-jbig2 = { git = "https://github.com/storytold/craft-libs", rev = "9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef", version = "=0.3.0" }
+hayro-syntax = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", version = "=0.7.2" }
+hayro-jbig2 = { git = "https://github.com/storytold/craft-libs", rev = "92d392cff132eaf53e13afff77f38b5c11b73aa0", version = "=0.3.0" }
 ecolor = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
 emath = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
 epaint = { git = "https://github.com/storytold/egui.git", rev = "6d518fc799681571963842f95b55a6b68431b15a" }
diff --git a/README.md b/README.md
index 5fa28f0bb..81b5a0ba5 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@
 
 <p align="center">
   A free, open-source compositor: compositions, layers,
-  keyframes, 306 effects, layer styles, expressions, 3D cameras and lights, and a render queue, native on macOS,
+  keyframes, 308 effects, layer styles, expressions, 3D cameras and lights, and a render queue, native on macOS,
   Windows and Linux, and in the browser. Young, moving fast, and already usable.
 </p>
 
@@ -84,9 +84,10 @@ a few places where it matters to us:
   without a plugin.
 - **A project file you can read.** Projects are versioned JSON (`.ecproj`), so they diff cleanly
   in version control.
-- **Everything is scriptable.** Every menu item, timeline drag and property edit goes through one
-  command registry, so the same actions are reachable from a command line, a JSON control
-  channel and an MCP server for agents.
+- **Everything is scriptable.** Menu actions, timeline edits and property changes are exposed as
+  commands. Engine commands are available through the CLI, JSON control channel and MCP;
+  UI-only commands use the frontend dispatcher and can be invoked through the control channel
+  or an attached MCP bridge.
 - **No FFmpeg.** Video and audio decoding and encoding are pure Rust: FilmCraft's codecs and
   EffectCraft's own VP9, AV1, HEVC and Opus encoders.
 
@@ -126,7 +127,7 @@ or into the Timeline, between layers and at the time you point to.
 
 ## Effects
 
-306 built-in effects across its categories, each with its parameter names, order and
+308 built-in effects across its categories, each with its parameter names, order and
 defaults: blur and sharpen, channel, color correction (Curves, Levels, Hue/Saturation, a full
 color-grading panel…), distort (Warp, Bulge, Turbulent Displace, CC Power Pin…), generate (Fractal Noise,
 Gradient Ramp, Stroke, Write-on, Audio Spectrum…), keying, matte, noise and grain, perspective,
@@ -155,7 +156,7 @@ tools, and Front, Top, Left and Custom views.
 
 A dedicated Render Queue, with Render Settings and Output Modules: **H.264** MP4 and
 **ProRes** MOV (Proxy to 4444 XQ with alpha) with audio, **HEVC** (Main / Main 10) and **AV1**
-MP4, **WebM** (VP9 with inter frames and alpha, or AV1; Opus audio), PNG, JPEG, TIFF and 32-bit EXR sequences, animated GIF and WAV/AIFF. Field
+MP4, **WebM** (VP9 with inter frames and alpha, or AV1; Opus audio), PNG, JPEG, TIFF, Targa and 32-bit EXR sequences, animated GIF and WAV/AIFF. Field
 rendering with 3:2 pulldown, effect/solo/guide/depth overrides, crop, region of interest and
 resize, Render Settings and Output Module templates with defaults, post-render actions, storage
 overflow and render logs. The same queue runs from the command line. Every encoder is pure
@@ -173,8 +174,10 @@ cannot express; File ▸ Import ▸ Lottie… opens one as a new composition.
 
 ## Built for agents
 
-Everything you can do from a menu is a command with an id, and agents can reach every one of
-them:
+Engine commands are available through the CLI, JSON control channel and MCP. UI-only commands
+need the running app's frontend dispatcher: complete menu access requires the app's control
+channel or an attached MCP bridge. Headless MCP sessions expose supported engine commands,
+but not UI-only commands or bridge-only `ui_*` tools.
 
 - **MCP server:** `effectcraft-cli mcp` speaks the Model Context Protocol over stdio, headless
   or bridged to the running app (`--bridge 9877`). Tools cover commands, the project and property
@@ -228,7 +231,7 @@ tests, layering, asset attribution and the WebAssembly build). See [CONTRIBUTING
 ## Where it stands
 
 EffectCraft is young: its first commit was on 1 October 2026. A comprehensive feature set
-exists, including 306 effects, but breadth is not the same as full maturity across every edge
+exists, including 308 effects, but breadth is not the same as full maturity across every edge
 case. Today it's a good place to try things and to tell us what breaks. It isn't yet recommended
 for production client work. In particular:
 
@@ -275,9 +278,13 @@ send us right now.
 | arm64 (Snapdragon and other ARM PCs) | `effectcraft-<ver>-windows-arm64.msi` | `effectcraft-<ver>-windows-arm64-portable.zip` |
 | x86 (32-bit) | `effectcraft-<ver>-windows-x86.msi` | `effectcraft-<ver>-windows-x86-portable.zip` |
 
-Installers and executables are code-signed. The installer asks where to install EffectCraft
-(Program Files by default), and later versions install into the same folder. To install silently
+Installers and executables are code-signed. The installer asks who to install EffectCraft for and where. By default it installs for your
+account only, into `%LOCALAPPDATA%\Programs\ArtCraft\EffectCraft`, without an administrator prompt;
+"Everyone on this computer" installs into `C:\Program Files\ArtCraft\EffectCraft` (`Program Files (x86)` for the 32-bit build). Later versions
+install into the same folder. To install silently
 into a folder of your choice: `msiexec /i effectcraft-<ver>-windows-x64.msi /qn INSTALLFOLDER="D:\Apps\EffectCraft"`.
+A silent install is per-user by default. `INSTALLFOLDER` chooses the folder, not who it is installed for;
+add `ALLUSERS=1`, from an elevated terminal or deployment tool, for an all-users install.
 
 ### macOS
 
@@ -337,8 +344,17 @@ stand on its own.
 | <img src="https://raw.githubusercontent.com/storytold/filmcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.filmcraft.png" alt="" width="32" height="32"> | **FilmCraft** | Video editing, color and sound | [GitHub](https://github.com/storytold/filmcraft) | [Website](https://getartcraft.com/apps/filmcraft) |
 | <img src="https://raw.githubusercontent.com/storytold/lightcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.lightcraft.png" alt="" width="32" height="32"> | **LightCraft** | Photo library and raw development | [GitHub](https://github.com/storytold/lightcraft) | [Website](https://getartcraft.com/apps/lightcraft) |
 | <img src="https://raw.githubusercontent.com/storytold/pdfcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.pdfcraft.png" alt="" width="32" height="32"> | **PdfCraft** | Reading, organizing and protecting PDFs | [GitHub](https://github.com/storytold/pdfcraft) | [Website](https://getartcraft.com/apps/pdfcraft) |
-| <img src="https://raw.githubusercontent.com/storytold/effectcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.effectcraft.png" alt="" width="32" height="32"> | **EffectCraft** | **Motion graphics and visual effects · you are here** | [GitHub](https://github.com/storytold/effectcraft) | [Website](https://getartcraft.com/apps/effectcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/effectcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.effectcraft.png" alt="" width="32" height="32"> | **EffectCraft** | Motion graphics and visual effects | [GitHub](https://github.com/storytold/effectcraft) | [Website](https://getartcraft.com/apps/effectcraft) |
 | <img src="https://raw.githubusercontent.com/storytold/designcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.designcraft.png" alt="" width="32" height="32"> | **DesignCraft** | Page layout and publishing | [GitHub](https://github.com/storytold/designcraft) | [Website](https://getartcraft.com/apps/designcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/figcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.figcraft.png" alt="" width="32" height="32"> | **FigCraft** | Interface design and prototyping | [GitHub](https://github.com/storytold/figcraft) | [Website](https://getartcraft.com/apps/figcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/wordcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.wordcraft.png" alt="" width="32" height="32"> | **WordCraft** | Word processing and documents | [GitHub](https://github.com/storytold/wordcraft) | [Website](https://getartcraft.com/apps/wordcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/soundcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.soundcraft.png" alt="" width="32" height="32"> | **SoundCraft** | Audio recording and editing | [GitHub](https://github.com/storytold/soundcraft) | [Website](https://getartcraft.com/apps/soundcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/deckcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.deckcraft.png" alt="" width="32" height="32"> | **DeckCraft** | Presentations and slide decks | [GitHub](https://github.com/storytold/deckcraft) | [Website](https://getartcraft.com/apps/deckcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/cadcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.cadcraft.png" alt="" width="32" height="32"> | **CADCraft** | Computer-aided design | [GitHub](https://github.com/storytold/cadcraft) | [Website](https://getartcraft.com/apps/cadcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/gridcraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.gridcraft.png" alt="" width="32" height="32"> | **GridCraft** | Spreadsheets and data | [GitHub](https://github.com/storytold/gridcraft) | [Website](https://getartcraft.com/apps/gridcraft) |
+| <img src="https://raw.githubusercontent.com/storytold/texturecraft/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.texturecraft.png" alt="" width="32" height="32"> | **TextureCraft** | 3D texture painting | [GitHub](https://github.com/storytold/texturecraft) | [Website](https://getartcraft.com/apps/texturecraft) |
+| <img src="https://raw.githubusercontent.com/storytold/craft-anything/main/assets/app-icon/hicolor/64x64/apps/ai.storyteller.craft-anything.png" alt="" width="32" height="32"> | **Craft Anything** | See how any software works, then build your own | [GitHub](https://github.com/storytold/craft-anything) | [Website](https://getartcraft.com/apps/craft-anything) |
+| <img src="https://raw.githubusercontent.com/tangency-labs/solidcraft/main/assets/icons/app/linux/exports/hicolor/64x64/apps/io.tangencylabs.solidcraft.png" alt="" width="32" height="32"> | **SolidCraft** | Parametric 3D CAD by Tangency Labs (community app) | [GitHub](https://github.com/tangency-labs/solidcraft) | |
 
 And [**ArtCraft**](https://getartcraft.com/) itself, our AI image and video studio for artists who want real control.
 
diff --git a/ROADMAP.md b/ROADMAP.md
index f4c99d61f..dff795d85 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -2,7 +2,7 @@
 
 **Stage: alpha** · next: beta, ~30 points of "ready for real work" and ~350–620 h away
 
-> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-12 · **Change:** minor (open-issue count, crash list and localization share re-audited against `upstream/main` 470ea7a3) · **Target:** Adobe After Effects 2026 (26.5.0.89)
+> **Last reviewed:** 2026-10-22 · **Last updated:** 2026-10-30 · **Change:** minor (features of 30 October in the progress log: text Line Join, Timeline drag-reorder and multi-select of effects, viewer edge pan, ScriptUI drag capture and dock size; previously: localization recount after #1774) · **Target:** Adobe After Effects 2026 (26.5.0.89)
 
 EffectCraft aims to do what After Effects does, with the same panels, menus and behaviour, written
 from scratch in Rust. This page is the one-page summary; the evidence is in
@@ -51,7 +51,7 @@ Linux/Windows reliability (30–50 h) and depth in animation, masks, effects and
 | UI/UX fidelity | 65% | 60–120 | [ui-parity.md](docs/ui-parity.md) |
 | File formats | 50% | 130–230 | [file-format-parity.md](docs/file-format-parity.md) |
 | Hardware | 40% | 60–120 | [hardware-parity.md](docs/hardware-parity.md) |
-| Localization | 18% | 60–110 + review | [localization-parity.md](docs/localization-parity.md) |
+| Localization | 24% | 60–110 + review | [localization-parity.md](docs/localization-parity.md) |
 | Performance | 35% | 50–100 | [gaps.md](docs/gaps.md#g5-performance-at-real-world-scale) |
 | Stability | 45% | 40–80 | [gaps.md](docs/gaps.md#g3-stability-and-a-green-main) |
 | Platforms | 65% | 30–60 | [gaps.md](docs/gaps.md#g2-real-user-reliability-on-every-platform) |
@@ -80,24 +80,24 @@ Weights and evidence per row: [target-app-parity.md](docs/target-app-parity.md#b
 
 ## Languages
 
-UI strings translated out of ≈ 3,900 (detail: [localization-parity.md](docs/localization-parity.md)).
+UI strings translated out of ≈ 4,200 (detail: [localization-parity.md](docs/localization-parity.md)).
 
 | Language | Status | % |
 |---|---|---:|
 | English | full | 100% |
-| Simplified Chinese | partial (menus, part of the panels) | 29% |
-| Spanish | menus only | 16% |
+| Simplified Chinese | partial (menus, most of the panels) | 46% |
+| Spanish | menus only | 29% |
 | Hindi | none | 0% |
 | Arabic | none | 0% |
 | French | menus only | 16% |
-| Portuguese (Brazil) | partial (menus, part of the panels) | 26% |
+| Portuguese (Brazil) | partial (menus, part of the panels) | 34% |
 | Indonesian | none | 0% |
-| Japanese | partial (menus, part of the panels) | 27% |
+| Japanese | partial (menus, most of the panels) | 46% |
 | German | menus only | 16% |
 | Korean | none | 0% |
 | Vietnamese | none | 0% |
 
-Also shipped: Traditional Chinese (partial, 29%), Ukrainian (partial, 29%), Czech (partial, 29%), Georgian (partial, 38%; native-speaker reviewed) and Russian (menus only, 16%). No other language has had
+Also shipped: Traditional Chinese (partial, 38%), Ukrainian (partial, 29%), Czech (partial, 29%), Polish (partial, 34%), Georgian (partial, 39%; native-speaker reviewed), Russian (menus only, 15%) and Swedish (menus, panels and effect names; not yet measured). No other language has had
 native-speaker review.
 
 ## Upcoming
@@ -117,10 +117,33 @@ Come tell us what matters most to you on [Discord](https://discord.gg/artcraft).
 
 ## Progress log
 
+- 2026-10-30: Text strokes take a Line Join (Miter, Round or Bevel) in the Character panel,
+  Miter for new text as in After Effects (#2077). In the Timeline, effects, masks and shape items
+  drag to a new place in their stack (#2210) and Shift-click adds them to the selection, so one
+  animation preset can hold several (#2552). The Composition panel pans while a mask vertex is
+  held at its edge (#999). Effect buffers that pad a small layer stay within a memory budget
+  (#2261); an MP4 lasts as long as its edit list shows (#2592); the Render Queue's times tick
+  between frames (#2593). ScriptUI drags keep their control past the window edge with
+  `MouseEvent.buttons` (#2584), and docked panels get their dock's size and `onResize` (#2585).
+- 2026-10-28: A shape layer's Rectangle and Ellipse Size get the Constrain Proportions chain
+  that Scale has, so a circle stays a circle while its size is typed, scrubbed or keyed; it
+  starts off, so existing shapes behave as before (#2489).
+- 2026-10-24: Shape layers have the Wiggle Transform path operation (Contents ▸ Add, or
+  `layer.addShapeItem {kind: "wiggler"}`): it wiggles the anchor point, position, scale and
+  rotation of the paths above it by random amounts that change over time, up to the Transform
+  values it holds. The copies of a Repeater above it wiggle independently as far as its
+  Correlation allows; with the Repeater below it, they wiggle together.
+- 2026-10-22: Localization: the panel/dialog catalogs gain 303 rows in Japanese, Simplified
+  Chinese and Traditional Chinese — panel tabs, form and dialog labels, panel context menus,
+  tracker/graph/text-panel controls, File-panel footers and credits. Recounted after #1774:
+  Japanese is 1,923 of ≈ 4,200 interface strings (46%, with 297 effect names); the Chinese
+  panel catalogs hold 998 (Simplified) and 951 (Traditional) rows, and Simplified Chinese is
+  46% with its 307 effect names; the overall share is ≈ 24%.
 - 2026-10-16: Convert To Bezier Path turns a shape layer's Rectangle, Ellipse or Polystar
   path into an editable Path 1 with the same geometry, as After Effects does; it used to
   apply to mask RotoBezier only, so a parametric shape path could not be converted at all
   and its vertices could not be edited or animated (#932).
+- 2026-10-14: Georgian (`ka`): every menu row, every panel-catalog row the Chinese catalogs have plus 195 Georgian-only ones, and the effect names and categories; Match System for `ka` / `ka-GE` / `ka_GE.UTF-8` locales. Reviewed by a native speaker.
 - 2026-10-12: Roto Brush span edits report strokes outside a trimmed layer without panicking;
   strokes and undo history are preserved so restoring the timing allows the span edit again.
 - 2026-10-11: Ukrainian panels caught up with the Chinese catalogs. The 95 rows the panel
@@ -132,10 +155,9 @@ Come tell us what matters most to you on [Discord](https://discord.gg/artcraft).
   design — alongside its 618/618 menus.
 - 2026-10-10: Full parity re-measure against After Effects 2026 26.5 (installed bundle, 26.2–26.5
   release notes, repository counts): breadth ≈ 91%, ready ≈ 45%, stage alpha. Progress docs
-  follow the shared standard: `docs/parity.md` became `docs/target-app-parity.md`; new
+  restructured: `docs/parity.md` became `docs/target-app-parity.md`; new
   `docs/roadmap.md`, `localization-parity.md`, `file-format-parity.md`, `hardware-parity.md`,
   `ui-parity.md`, `effects-parity.md` and `scripting-parity.md`.
-- 2026-10-14: Georgian (`ka`): every menu row, every panel-catalog row the Chinese catalogs have plus 195 Georgian-only ones, and the effect names and categories; Match System for `ka` / `ka-GE` / `ka_GE.UTF-8` locales. Reviewed by a native speaker.
 - 2026-10-10: Spanish (#460) and Brazilian Portuguese (#217) menu translations.
 - 2026-10-10: Japanese now translates the interface below the menu bar too: `crates/ui-egui/src/i18n/ui.rs` has a Japanese table with the same 396 rows as the Chinese ones (panels, dialogs, buttons and tooltips; the shape test keeps the three catalogs listing the same source strings). Menus were already Japanese.
 - 2026-10-09: Ukrainian now covers all 396 current panel-catalog strings, including dialogs, buttons and tooltips, alongside its menu translation. The catalog keeps the same source keys and placeholder counts as the Chinese catalogs; missing or engine-generated text still falls back to English.
@@ -155,11 +177,13 @@ Come tell us what matters most to you on [Discord](https://discord.gg/artcraft).
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-30 | minor | Progress log: text Line Join, Timeline drag-reorder and Shift multi-select of effects, viewer edge pan, effect padding budget, MP4 edit-list duration, Render Queue clock, ScriptUI drag capture and docked-panel size |
+| 2026-10-22 | minor | Localization: 300 more panel/dialog rows in Japanese and the Chinese catalogs, plus the review's three missing rows (Basic, Advanced, Play/Stop) — panel tabs, form and dialog labels, context menus, tracker/graph/text-panel controls, File-panel footers, credits; language shares recounted after #1774 (Japanese 27% → 46% with 297 effect names, Simplified Chinese 29% → 46% with 307 effect names, Traditional Chinese 29% → 38%, overall 18% → 24%) |
 | 2026-10-12 | minor | Open-issue count (134 to 216), crash list and localization share (12% to 18%) updated to match docs/gaps.md |
 | 2026-10-12 | patch | Roto Brush span validation after trimming; command regressions for both layer edges |
+| 2026-10-12 | minor | Shared PDF object/xref parsing with bounded app-owned conversion and preserved stream budgets; drawing, EPS and image/font policy remain unchanged |
 | 2026-10-10 | minor | Hours to ≈ 95% for each audience |
 | 2026-10-10 | minor | Headline adds mainstream practitioner (≈ 47%) and essentials user (≈ 52%) |
-| 2026-10-12 | minor | Shared PDF object/xref parsing with bounded app-owned conversion and preserved stream budgets; drawing, EPS and image/font policy remain unchanged |
+| 2026-10-10 | major | Progress docs restructured: stage, two numbers, dimensions, features, languages, upcoming, progress log; milestones moved to docs/roadmap.md |
 | 2026-10-10 | minor | Stage checked against the new core-workflow gate (all six pass; still alpha) |
-| 2026-10-10 | major | Rewritten to the shared progress-docs standard: stage, two numbers, dimensions, features, languages, upcoming, progress log; milestones moved to docs/roadmap.md |
 | 2026-10-05 | major | Two numbers (breadth vs real use) and workstreams G1–G9 |
diff --git a/apps/effectcraft-cli/Cargo.toml b/apps/effectcraft-cli/Cargo.toml
index b5784f4eb..abfc014eb 100644
--- a/apps/effectcraft-cli/Cargo.toml
+++ b/apps/effectcraft-cli/Cargo.toml
@@ -20,6 +20,9 @@ effectcraft-ui-egui = { workspace = true }
 effectcraft-render = { workspace = true }
 effectcraft-gpu = { workspace = true }
 effectcraft-time = { workspace = true }
+effectcraft-track = { workspace = true }
+effectcraft-segment = { workspace = true }
+effectcraft-sam2 = { workspace = true }
 serde_json = { workspace = true }
 image = { workspace = true }
 cpu-time = "1"
diff --git a/apps/effectcraft-cli/src/main.rs b/apps/effectcraft-cli/src/main.rs
index 6e5b8d6cc..6ba352247 100644
--- a/apps/effectcraft-cli/src/main.rs
+++ b/apps/effectcraft-cli/src/main.rs
@@ -7,11 +7,12 @@
 //! effectcraft-cli exec --list [--filter TEXT] [--schemas]     list engine commands (as `commands`)
 //! effectcraft-cli run <id> <json> [<id> <json> …]             run several commands in order
 //! effectcraft-cli run --args-file F                           the same, one argument per line of F
+//! effectcraft-cli run --commands FILE|-                         steps {"command", "params"} from FILE or stdin
 //! effectcraft-cli props <comp> <layer> [--flat] [--time S]    a layer's property tree (with paths)
 //! effectcraft-cli get <comp> <layer> <path> [--time S]        read a property
 //! effectcraft-cli set <comp> <layer> <path> <value> [--time S] [--expression E]
 //! effectcraft-cli render-frame [--comp C] [--time S|--frame N] [--max-side PX|--scale K] [--out F.png] [--transparent]
-//! effectcraft-cli render [--comp C] --out FILE [--format h264|hevc|av1|prores|webm|png|jpeg|tiff|exr|gif|wav|aiff] [--start S] [--end S]
+//! effectcraft-cli render [--comp C] --out FILE [--format h264|hevc|av1|prores|webm|png|jpeg|tiff|exr|tga|gif|wav|aiff] [--start S] [--end S]
 //!     [--work-area] [--fps N] [--resolution full|half|third|quarter|K] [--quality best|draft] [--channels rgb|rgba]
 //!     [--jpeg-quality N] [--bitrate KBPS] [--prores proxy|lt|standard|hq|4444|4444xq] [--audio auto|on|off]
 //!     [--profile main|main10] [--level auto|4.1] [--rate-control bitrate|quality] [--video-quality 1-100]
@@ -26,6 +27,8 @@
 //!     (--gpu: CPU vs GPU ms/frame for every comp at Full and Half)
 //! effectcraft-cli bench --ops [--small] [--layers N] [--comps N] [--footage N]   everyday-operation timings
 //!     on a large generated project (open, save, auto-save, undo/redo, timeline, Project panel)
+//! effectcraft-cli bench --roto [--frames N] [--sam2 model.safetensors] [--mobilesam mobile_sam.pt] [--fixes] [--clip FRAMES --truth MASKS] [--json]   Roto Brush trackers on synthetic clips with known mattes
+//!     (classical engine, MobileSAM and SAM 2.1 (any installed size) when installed; IoU, flicker, re-appearance, seconds per frame)
 //! effectcraft-cli script FILE.jsx [F.ecproj] | --eval CODE    run an After Effects-style script
 //! effectcraft-cli mcp [--autosave | --bridge PORT]            MCP server on stdio
 //!
@@ -98,6 +101,10 @@ const USAGE: &str = "usage: effectcraft-cli <info|commands|exec|run|props|get|se
   exec <command-id> [--params JSON]        run one engine command (exec --list: list them, as `commands`)
   run <id> <json> [<id> <json> ...]        run several commands in order
   run --args-file F                        the same, one argument per line of F (no command-line length limit)
+  run --commands FILE|-                    steps from FILE, or standard input for -: a JSON array of
+                                           {\"command\": ID, \"params\": {...}} (or \"id\" for \"command\"), or one
+                                           such object per line (JSON Lines); at most 64 MiB and 100000 steps.
+                                           Repeatable; run after the <id> <json> pairs and --args-file
   props <comp> <layer> [--flat] [--time S] a layer's property tree with paths
   get <comp> <layer> <path> [--time S]     read a property
   set <comp> <layer> <path> <value> [--time S] [--expression E]
@@ -107,7 +114,7 @@ const USAGE: &str = "usage: effectcraft-cli <info|commands|exec|run|props|get|se
          [--jpeg-quality N] [--bitrate KBPS] [--prores PROFILE] [--audio auto|on|off]
          [--profile main|main10] [--level auto|4.1] [--rate-control bitrate|quality] [--video-quality N]
          [--keyint FRAMES] [--webm-codec vp9|av1] [--audio-bitrate KBPS] [--opus-app audio|voice] | --queue
-                                           (formats h264|hevc|av1|prores|webm|png|jpeg|tiff|exr|gif|wav|aiff;
+                                           (formats h264|hevc|av1|prores|webm|png|jpeg|tiff|exr|tga|gif|wav|aiff;
                                            --profile..--keyint: HEVC / AV1, --audio-bitrate/--opus-app: WebM Opus)
                                            a relative --out is relative to the working directory
                                            --progress: progress lines on stderr when it is not a terminal
@@ -119,6 +126,9 @@ const USAGE: &str = "usage: effectcraft-cli <info|commands|exec|run|props|get|se
   bench --ops [--small] [--layers N] [--comps N] [--footage N]
                                            everyday operations on a large generated project: startup, open,
                                            save, auto-save, edits + undo/redo, timeline, Project panel
+  bench --roto [--frames N] [--sam2 FILE] [--mobilesam FILE] [--fixes] [--clip FRAMES_DIR --truth MASKS_DIR] [--json]
+                                           Roto Brush trackers on synthetic clips with known mattes: movement,
+                                           lighting change, occlusion, leaving and re-entering the frame
   script FILE.jsx [F.ecproj] | --eval CODE run JavaScript with the After Effects-style object model
                                            (app.project, comps, layers, properties…); prints writeLn
                                            output and the result; errors exit 1 with file:line:col
@@ -132,6 +142,11 @@ options: --project F.ecproj | --demo | --empty   --save | --save-as F   --bridge
 /// Options that take a value.
 const VALUED: &[&str] = &[
     "--n",
+    "--clip",
+    "--truth",
+    "--frames",
+    "--sam2",
+    "--mobilesam",
     "--play",
     "--layers",
     "--comps",
@@ -151,6 +166,7 @@ const VALUED: &[&str] = &[
     "--depth",
     "--eval",
     "--args-file",
+    "--commands",
     // render
     "--template",
     "--values",
@@ -181,6 +197,7 @@ const VALUED: &[&str] = &[
 /// Options without a value. Any other `--option` is a usage error.
 const FLAGS: &[&str] = &[
     "--json",
+    "--fixes",
     "--save",
     "--demo",
     "--empty",
@@ -193,6 +210,7 @@ const FLAGS: &[&str] = &[
     "--work-area",
     "--queue",
     "--ops",
+    "--roto",
     "--small",
     "--adv3d",
     "--autosave",
@@ -279,6 +297,9 @@ fn utf8_args(raw: impl IntoIterator<Item = std::ffi::OsString>) -> Result<Vec<St
 }
 
 fn main() {
+    // Warnings and errors to standard error (`RUST_LOG` overrides), so a GPU that declines
+    // frames or runs out of memory says so instead of silently rendering on the CPU.
+    effectcraft_engine::logging::install_with("warn");
     let raw = match utf8_args(std::env::args_os().skip(1)) {
         Ok(raw) => raw,
         Err(e) => fail_usage(&e),
@@ -334,6 +355,87 @@ impl From<String> for Failure {
     }
 }
 
+/// Most bytes `run --commands` reads from a file or standard input: the steps are untrusted input.
+const MAX_COMMANDS_BYTES: u64 = 64 * 1024 * 1024;
+/// Most steps one `run --commands` takes.
+const MAX_COMMANDS_STEPS: usize = 100_000;
+
+/// The text of `--commands source`: the file `source`, or standard input for `-`, refused past
+/// [`MAX_COMMANDS_BYTES`]. This reader, [`parse_commands`] and [`command_step`] are ported from
+/// vectorcraft-cli's (storytold/vectorcraft#3630), with a tuple in place of its `Step` enum.
+fn read_commands(source: &str) -> Result<String, String> {
+    use std::io::Read;
+    let mut bytes = vec![];
+    let read = if source == "-" {
+        std::io::stdin().lock().take(MAX_COMMANDS_BYTES + 1).read_to_end(&mut bytes)
+    } else {
+        std::fs::File::open(source).and_then(|f| f.take(MAX_COMMANDS_BYTES + 1).read_to_end(&mut bytes))
+    };
+    read.map_err(|e| format!("--commands {source}: {e}"))?;
+    if bytes.len() as u64 > MAX_COMMANDS_BYTES {
+        return Err(format!("--commands {source}: more than {} MiB of steps", MAX_COMMANDS_BYTES / (1024 * 1024)));
+    }
+    String::from_utf8(bytes).map_err(|_| format!("--commands {source}: not UTF-8 text"))
+}
+
+/// The steps of `--commands source` from its `text`: a JSON array of `{"command": ID, "params":
+/// {…}}` objects (`"id"` may stand for `"command"`), or one such object per line (JSON Lines, blank
+/// lines skipped). `first` is the run's index of the first of them, which an error names with the
+/// entry's place in the text.
+fn parse_commands(source: &str, text: &str, first: usize) -> Result<Vec<(String, Value)>, String> {
+    // Notepad on Windows starts UTF-8 files with a byte order mark.
+    let text = text.strip_prefix('\u{feff}').unwrap_or(text);
+    let too_many = || format!("--commands {source}: more than {MAX_COMMANDS_STEPS} steps");
+    // Each entry with where it is in the text: its line for JSON Lines.
+    let mut entries: Vec<(Option<usize>, Value)> = vec![];
+    if text.trim_start().starts_with('[') {
+        let v: Value = serde_json::from_str(text).map_err(|e| format!("--commands {source}: {e}"))?;
+        let Value::Array(items) = v else { return Err(format!("--commands {source}: not a JSON array")) };
+        if items.len() > MAX_COMMANDS_STEPS {
+            return Err(too_many());
+        }
+        entries.extend(items.into_iter().map(|v| (None, v)));
+    } else {
+        for (n, line) in text.lines().enumerate().filter(|(_, l)| !l.trim().is_empty()) {
+            if entries.len() == MAX_COMMANDS_STEPS {
+                return Err(too_many());
+            }
+            let v = serde_json::from_str(line).map_err(|e| format!("--commands {source}: step {} (line {}): {e}", first + entries.len(), n + 1))?;
+            entries.push((Some(n + 1), v));
+        }
+    }
+    entries
+        .into_iter()
+        .enumerate()
+        .map(|(k, (line, v))| {
+            command_step(v).map_err(|e| {
+                let place = line.map_or_else(|| format!("entry {}", k + 1), |l| format!("line {l}"));
+                format!("--commands {source}: step {} ({place}): {e}", first + k)
+            })
+        })
+        .collect()
+}
+
+/// The command id and params of one `--commands` entry, `{"command": ID, "params": {…}}`.
+fn command_step(v: Value) -> Result<(String, Value), String> {
+    let Value::Object(mut o) = v else { return Err("a step must be an object such as {\"command\": \"comp.new\", \"params\": {}}".into()) };
+    let id = match (o.remove("command"), o.remove("id")) {
+        (Some(Value::String(id)), None) | (None, Some(Value::String(id))) => id,
+        (Some(_), Some(_)) => return Err("give `command` or `id`, not both".into()),
+        (None, None) => return Err("no `command`".into()),
+        _ => return Err("`command` must be a string, a command id".into()),
+    };
+    let params = match o.remove("params") {
+        None | Some(Value::Null) => json!({}),
+        Some(p @ Value::Object(_)) => p,
+        Some(_) => return Err(format!("`params` of {id} must be a JSON object")),
+    };
+    if let Some(key) = o.keys().next() {
+        return Err(format!("unknown key `{key}`: a step has `command` (or `id`) and `params`"));
+    }
+    Ok((id, params))
+}
+
 fn usage_err<T>(m: &str) -> Result<T, Failure> {
     Err(Failure::Usage(m.to_string()))
 }
@@ -524,14 +626,14 @@ fn run(cmd: &str, args: &Args, json_out: bool) -> Result<(), Failure> {
                 let text = std::fs::read_to_string(f).map_err(|e| Failure::Usage(format!("--args-file {f}: {e}")))?;
                 pairs.extend(text.lines().map(str::trim).filter(|l| !l.is_empty()).map(String::from));
             }
-            if pairs.is_empty() {
-                return usage_err("run needs <command-id> [<json>] pairs");
+            let sources = args.opts("--commands");
+            if pairs.is_empty() && sources.is_empty() {
+                return usage_err("run needs <command-id> [<json>] pairs or --commands FILE|-");
             }
-            let mut b = backend(args, true)?;
-            let mut results = vec![];
+            let mut steps = vec![];
             let mut i = 0;
             while i < pairs.len() {
-                let id = &pairs[i];
+                let id = pairs[i].clone();
                 let params = match pairs.get(i + 1).filter(|p| p.trim_start().starts_with('{')) {
                     Some(p) => {
                         i += 1;
@@ -540,9 +642,26 @@ fn run(cmd: &str, args: &Args, json_out: bool) -> Result<(), Failure> {
                     None => json!({}),
                 };
                 i += 1;
-                let r = b.exec(id, params).map_err(|e| Failure::Error(format!("{id}: {e}")))?;
-                if let Some(e) = failed_render(id, &r) {
-                    return Err(Failure::Error(format!("{id}: {e}")));
+                steps.push((id, params));
+            }
+            if sources.iter().filter(|s| **s == "-").count() > 1 {
+                return usage_err("--commands - is given twice: standard input is read once");
+            }
+            for &source in &sources {
+                let text = read_commands(source).map_err(Failure::Usage)?;
+                steps.extend(parse_commands(source, &text, steps.len()).map_err(Failure::Usage)?);
+            }
+            if steps.is_empty() {
+                return Err(Failure::Usage(format!("--commands {}: no commands", sources.join(", "))));
+            }
+            let mut b = backend(args, true)?;
+            let mut results = vec![];
+            // The step's index closes the message: a generated list repeats ids, and callers match
+            // the leading `<id>: `.
+            for (n, (id, params)) in steps.into_iter().enumerate() {
+                let r = b.exec(&id, params).map_err(|e| Failure::Error(format!("{id}: {e} (step {n})")))?;
+                if let Some(e) = failed_render(&id, &r) {
+                    return Err(Failure::Error(format!("{id}: {e} (step {n})")));
                 }
                 if !json_out {
                     emit(&r, false);
@@ -620,9 +739,8 @@ fn run(cmd: &str, args: &Args, json_out: bool) -> Result<(), Failure> {
             }
             let out = args.opt("--out").unwrap_or("frame.png").to_string();
             let t0 = std::time::Instant::now();
-            let f = b.render_with(comp.as_ref(), time, max_side, args.flag("--transparent"))?;
+            let f = b.render_to_file(comp.as_ref(), time, max_side, args.flag("--transparent"), &out)?;
             let ms = t0.elapsed().as_secs_f64() * 1000.0;
-            std::fs::write(&out, &f.png).map_err(|e| format!("cannot write {out}: {e}"))?;
             let info = json!({"path": out, "comp": f.comp, "time": f.time, "width": f.width, "height": f.height, "ms": (ms * 10.0).round() / 10.0});
             if json_out {
                 emit(&info, true);
@@ -783,6 +901,7 @@ fn render(args: &Args, json_out: bool) -> Result<(), Failure> {
             r["outputModuleSummary"].as_str().unwrap_or("")
         );
     }
+    let attempted: std::collections::HashSet<u64> = s.project.render_queue.iter().filter(|i| i.is_queued()).map(|i| i.id).collect();
     s.execute("renderQueue.render", json!({"wait": false})).map_err(err)?;
     let tty = std::io::IsTerminal::is_terminal(&std::io::stderr());
     // `--progress`: one line per update for a program reading stderr (a terminal gets the live line).
@@ -821,7 +940,7 @@ fn render(args: &Args, json_out: bool) -> Result<(), Failure> {
     }
     let mut results = vec![];
     let mut failed = vec![];
-    for it in s.project.render_queue.iter().filter(|i| i.render && i.started.is_some()) {
+    for it in s.project.render_queue.iter().filter(|i| attempted.contains(&i.id)) {
         let name = s.project.item(it.comp).map(|i| i.name.clone()).unwrap_or_else(|| "?".into());
         match &it.status {
             RenderStatus::Done => {
@@ -868,6 +987,9 @@ fn bench_cmd(args: &Args) -> Result<(), Failure> {
     if args.flag("--ops") {
         return bench_ops(args);
     }
+    if args.flag("--roto") {
+        return bench_roto(args);
+    }
     let mut s = effectcraft_host::session();
     match &args.project {
         Some(p) => s.execute("file.open", json!({"path": p})),
@@ -890,6 +1012,117 @@ fn bench_cmd(args: &Args) -> Result<(), Failure> {
     Ok(())
 }
 
+/// The model a bench option asks for: the file named on the command line, where failing to read or
+/// build it is an error saying why (not "not installed"); else the installed file, where a file that
+/// cannot be used just leaves the model out.
+fn bench_weights<T>(
+    flag: &str,
+    named: Option<&str>,
+    installed: Option<std::path::PathBuf>,
+    build: impl Fn(&[u8]) -> Result<T, String>,
+) -> Result<Option<T>, Failure> {
+    match named {
+        Some(path) => {
+            let bytes = std::fs::read(path).map_err(|e| Failure::Error(format!("{flag} {path}: {e}")))?;
+            build(&bytes).map(Some).map_err(|e| Failure::Error(format!("{flag} {path}: {e}")))
+        }
+        None => Ok(installed.and_then(|p| std::fs::read(p).ok()).and_then(|bytes| build(&bytes).ok())),
+    }
+}
+
+/// `bench --roto`: the Roto Brush's trackers on synthetic clips whose true mattes are known.
+fn bench_roto(args: &Args) -> Result<(), Failure> {
+    use effectcraft_segment::{Loaded, MOBILE_SAM, MaskModel};
+    use effectcraft_track::roto::bench;
+    let frames = args.num("--frames")?.unwrap_or(24.0).clamp(1.0, 240.0) as usize;
+    let session = effectcraft_host::session();
+    // `--mobilesam FILE` uses the weights at FILE (a file that cannot be used is an error);
+    // otherwise the installed ones.
+    let mobilesam: Option<std::sync::Arc<dyn MaskModel>> = bench_weights("--mobilesam", args.opt("--mobilesam"), session.model_path(&MOBILE_SAM), |bytes| {
+        match effectcraft_segment::load(MOBILE_SAM.id, bytes)? {
+            Loaded::Mask(m) => Ok(m),
+            _ => Err("not a mask model".to_string()),
+        }
+    })?;
+    if mobilesam.is_none() {
+        note!("bench --roto: MobileSAM is not installed; comparing the classical engine only");
+    }
+    // `--sam2 FILE` uses the weights at FILE (a file that cannot be used is an error); otherwise
+    // the installed ones.
+    let installed_sam2 = effectcraft_sam2::mask::SIZES.iter().find_map(|m| session.model_path(m));
+    let sam2: Option<std::sync::Arc<dyn MaskModel>> =
+        bench_weights("--sam2", args.opt("--sam2"), installed_sam2, |bytes| effectcraft_sam2::mask::load(bytes).map(|m| m as std::sync::Arc<dyn MaskModel>))?;
+    if sam2.is_none() {
+        note!("bench --roto: no SAM 2.1 size is installed; no SAM 2 column");
+    }
+    // `--fixes`: count correction rounds before every frame reaches IoU 0.9 (up to 6 rounds, each up to two strokes).
+    let fixes = args.flag("--fixes");
+    let measure = |sc: &bench::Scenario, run: &dyn Fn(&bench::Scenario) -> Option<bench::Run>| if fixes { bench::with_fixes(sc, 0.9, 6, run) } else { run(sc) };
+    let mut runs = vec![];
+    // User clips pair unique filename stems, allowing JPEG frames with PNG truth masks.
+    let scenarios = if let Some(dir) = args.opt("--clip") {
+        let truth = args.opt("--truth").ok_or_else(|| Failure::Error("--clip needs --truth MASKS_DIR".into()))?;
+        let name = std::path::Path::new(dir).file_name().map_or_else(|| "clip".to_string(), |n| n.to_string_lossy().chars().take(10).collect());
+        vec![load_bench_clip(&name, dir, truth, frames).map_err(Failure::Error)?]
+    } else {
+        bench::scenarios(frames)
+    };
+    for sc in scenarios {
+        runs.extend(measure(&sc, &|s| Some(bench::run_flow(s, "classical", None))));
+        if let Some(m) = &mobilesam {
+            runs.extend(measure(&sc, &|s| Some(bench::run_flow(s, "mobilesam", Some(m.as_ref())))));
+        }
+        if let Some(m) = &sam2 {
+            let label = m.info().id.replacen("sam2.1-hiera-", "sam2-", 1);
+            runs.extend(measure(&sc, &|s| bench::run_tracker(s, &label, m.as_ref())));
+        }
+    }
+    if args.flag("--json") {
+        say!("{}", serde_json::to_string_pretty(&runs).map_err(|e| Failure::Error(e.to_string()))?);
+    } else {
+        say!("{}", bench::table(&runs));
+    }
+    Ok(())
+}
+
+/// The image files of `dir` (png, jpg, jpeg), ordered by stem then full file name.
+fn image_files(dir: &str) -> Result<Vec<std::path::PathBuf>, String> {
+    let mut files: Vec<std::path::PathBuf> = std::fs::read_dir(dir)
+        .map_err(|e| format!("cannot read {dir}: {e}"))?
+        .filter_map(|e| e.ok().map(|e| e.path()))
+        .filter(|p| p.extension().and_then(|e| e.to_str()).is_some_and(|e| ["png", "jpg", "jpeg"].contains(&e.to_ascii_lowercase().as_str())))
+        .collect();
+    files.sort_by(|a, b| a.file_stem().cmp(&b.file_stem()).then_with(|| a.file_name().cmp(&b.file_name())));
+    Ok(files)
+}
+
+/// A benchmark scenario from the user's frames and truth masks (at most `limit` frames, frames at most 480 px
+/// wide; a mask pixel above 127 is the object). Nothing is copied or kept.
+fn load_bench_clip(name: &str, frames_dir: &str, truth_dir: &str, limit: usize) -> Result<effectcraft_track::roto::bench::Scenario, String> {
+    let (frames, masks) = (image_files(frames_dir)?, image_files(truth_dir)?);
+    if frames.is_empty() || frames.len() != masks.len() {
+        return Err(format!("{} frames in {frames_dir} but {} masks in {truth_dir}: they must match one to one", frames.len(), masks.len()));
+    }
+    if frames.iter().map(|p| p.file_stem()).ne(masks.iter().map(|p| p.file_stem()))
+        || frames.windows(2).chain(masks.windows(2)).any(|pair| pair.first().and_then(|p| p.file_stem()) == pair.get(1).and_then(|p| p.file_stem()))
+    {
+        return Err("frame and truth file names must match one to one, with unique stems (extensions may differ)".into());
+    }
+    let n = frames.len().min(limit.clamp(1, 240));
+    let (mut imgs, mut truth) = (vec![], vec![]);
+    for (f, m) in frames.iter().zip(&masks).take(n) {
+        let rgba = image::open(f).map_err(|e| format!("{}: {e}", f.display()))?.to_rgba8();
+        let scale = (480.0 / f64::from(rgba.width().max(1))).min(1.0);
+        let (w, h) = (((f64::from(rgba.width()) * scale).round() as u32).max(1), ((f64::from(rgba.height()) * scale).round() as u32).max(1));
+        let rgba = if (w, h) == rgba.dimensions() { rgba } else { image::imageops::resize(&rgba, w, h, image::imageops::FilterType::Triangle) };
+        let mask = image::open(m).map_err(|e| format!("{}: {e}", m.display()))?.to_luma8();
+        let mask = image::imageops::resize(&mask, w, h, image::imageops::FilterType::Nearest);
+        imgs.push(effectcraft_render::Image::from_rgba8(w, h, rgba.as_raw()));
+        truth.push(mask.as_raw().iter().map(|v| u8::from(*v > 127)).collect());
+    }
+    effectcraft_track::roto::bench::scenario_from(name, imgs, truth)
+}
+
 /// `bench --ops`: everyday operations on a large generated project (200 comps, 5,000 layers in
 /// the main comp, 300 footage items, 20-deep precomp nesting, expressions): startup to first
 /// frame, open, save, auto-save, small and large edits with undo/redo, first frame, timeline
@@ -1189,7 +1422,7 @@ fn adv3d_bench_comp(p: &mut effectcraft_engine::project::Project) -> Option<Item
         set(l, "cameraOptions/highlightGain", Value::Scalar(20.0));
         set(l, "cameraOptions/highlightThreshold", Value::Scalar(200.0));
     });
-    comp.layers = layers;
+    comp.layers = layers.into();
     Some(p.add_item("Advanced 3D (bench)", effectcraft_engine::color::Label::None, None, ItemKind::Comp(comp.into())))
 }
 
diff --git a/apps/effectcraft-cli/tests/it/cli.rs b/apps/effectcraft-cli/tests/it/cli.rs
index 538887d9b..e9a96dd7e 100644
--- a/apps/effectcraft-cli/tests/it/cli.rs
+++ b/apps/effectcraft-cli/tests/it/cli.rs
@@ -7,7 +7,7 @@ use std::process::{Command, Stdio};
 use serde_json::{Value, json};
 
 fn bin() -> Command {
-    Command::new(env!("CARGO_BIN_EXE_effectcraft-cli"))
+    Command::new(crate::binary())
 }
 
 /// Run with `--json`; returns (exit code, parsed stdout).
@@ -133,6 +133,78 @@ fn run_reads_arguments_from_a_file() {
     assert!(String::from_utf8_lossy(&out.stderr).contains("--args-file no/such/file.txt"));
 }
 
+/// Run with `stdin` piped in; returns (exit code, stdout, stderr).
+fn run_with_stdin(args: &[&str], stdin: &str) -> (i32, String, String) {
+    let mut child = bin().args(args).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
+    child.stdin.take().unwrap().write_all(stdin.as_bytes()).unwrap();
+    let out = child.wait_with_output().unwrap();
+    (out.status.code().unwrap_or(-1), String::from_utf8_lossy(&out.stdout).into_owned(), String::from_utf8_lossy(&out.stderr).into_owned())
+}
+
+/// `run --commands FILE|-` (#2251) reads `{"command", "params"}` steps from a JSON array or JSON
+/// Lines, from a file or standard input, and runs them as the same positional pairs would: after
+/// the pairs, so a generated list can follow a hand-written prefix. One command whose params are
+/// over Linux's 128 KiB per-argument limit goes through.
+#[test]
+fn run_reads_commands_from_a_file_or_stdin() {
+    let steps = [
+        ("comp.new", json!({"name": "A", "width": 64, "height": 64})),
+        ("layer.newSolid", json!({"width": 8, "height": 8, "name": "One"})),
+        ("layer.newSolid", json!({"width": 8, "height": 8, "name": "Two"})),
+        ("project.summary", json!({})),
+    ];
+    let pairs: Vec<String> = steps.iter().flat_map(|(id, p)| [id.to_string(), p.to_string()]).collect();
+    let pairs: Vec<&str> = pairs.iter().map(String::as_str).collect();
+    let expected = ok_json(&[&["run", "--empty"][..], &pairs[..]].concat());
+    let layers = |v: &Value| v[3]["result"]["items"][0]["layers"].as_u64();
+    assert_eq!(layers(&expected), Some(2), "{expected}");
+
+    let objects: Vec<Value> = steps.iter().map(|(id, p)| json!({"command": id, "params": p})).collect();
+    let array = tmp("commands.json");
+    std::fs::write(&array, serde_json::to_string_pretty(&objects).unwrap()).unwrap();
+    assert_eq!(ok_json(&["run", "--commands", array.to_str().unwrap(), "--empty"]), expected);
+
+    let lines: String = objects.iter().map(|o| format!("{o}\n\n")).collect();
+    let (code, out, err) = run_with_stdin(&["run", "--commands", "-", "--empty", "--json"], &lines);
+    assert_eq!(code, 0, "{err}");
+    assert_eq!(serde_json::from_str::<Value>(&out).unwrap(), expected);
+
+    // Positional pairs first, then the file.
+    let rest = tmp("commands-rest.jsonl");
+    std::fs::write(&rest, objects[1..].iter().map(|o| format!("{o}\n")).collect::<String>()).unwrap();
+    assert_eq!(ok_json(&[&["run", "--empty", "--commands", rest.to_str().unwrap()][..], &pairs[..2]].concat()), expected);
+
+    let name = "n".repeat(140 * 1024);
+    let big = tmp("commands-big.jsonl");
+    std::fs::write(&big, format!("{}\n{}\n", json!({"command": "comp.new", "params": {"name": name}}), json!({"command": "project.summary"}))).unwrap();
+    let v = ok_json(&["run", "--commands", big.to_str().unwrap(), "--empty"]);
+    assert_eq!(v[1]["result"]["items"][0]["name"].as_str().map(str::len), Some(name.len()));
+
+    for (input, args, error) in [
+        ("", &["run", "--commands", "-", "--empty"][..], "--commands -: no commands"),
+        (
+            "{\"command\":\"project.summary\"}\n{\"command\":\"x\",\"param\":{}}\n",
+            &["run", "project.summary", "{}", "--commands", "-", "--empty"],
+            "step 2 (line 2): unknown key `param`",
+        ),
+        ("[{\"command\":\"project.summary\"}, {\"params\":{}}]", &["run", "--commands", "-", "--empty"], "step 1 (entry 2): no `command`"),
+        ("{}", &["run", "--commands", "-", "--commands", "-", "--empty"], "standard input is read once"),
+    ] {
+        let (code, out, err) = run_with_stdin(args, input);
+        assert_eq!(code, 2, "{input:?}: {err}");
+        assert!(err.contains(error), "{input:?}: {err}");
+        assert!(out.is_empty(), "{input:?}: nothing ran");
+    }
+    // An empty list after positional pairs is no error: there is still something to run.
+    let (code, _, err) = run_with_stdin(&["run", "project.summary", "--commands", "-", "--empty"], "");
+    assert_eq!(code, 0, "{err}");
+    // A step that fails when it runs is named by its index too.
+    let (code, out, err) = run_with_stdin(&["run", "--commands", "-", "--empty", "--json"], "{\"command\":\"project.summary\"}\n{\"command\":\"no.such\"}\n");
+    assert_eq!(code, 1, "{err}");
+    let e = serde_json::from_str::<Value>(&out).unwrap()["error"].as_str().map(String::from).unwrap_or_default();
+    assert!(e.starts_with("no.such: ") && e.ends_with(" (step 1)"), "{e}");
+}
+
 #[test]
 fn render_frame_writes_png() {
     let out = tmp("f.png");
@@ -347,6 +419,67 @@ fn render_out_is_relative_to_the_working_directory() {
     let _ = std::fs::remove_dir_all(&root);
 }
 
+/// #1743: `render-frame --out` writes a PNG to the path it is given, and never over footage or
+/// the project file.
+#[test]
+fn render_frame_never_writes_over_footage_or_the_project() {
+    let root = tmp("render-frame-overwrite");
+    let _ = std::fs::remove_dir_all(&root);
+    std::fs::create_dir_all(&root).unwrap();
+    let (clip, project) = (root.join("clip.png"), root.join("p.ecproj"));
+    let (c, p) = (clip.to_str().unwrap(), project.to_str().unwrap());
+    // A real PNG to import: a frame of the demo project.
+    ok_json(&["render-frame", "--max-side", "64", "--out", c]);
+    let imported = json!({"paths": [c]}).to_string();
+    ok_json(&["run", "file.import", &imported, "comp.new", r#"{"name":"T","width":64,"height":36,"duration":1}"#, "--empty", "--save-as", p]);
+    let (footage, saved) = (std::fs::read(&clip).unwrap(), std::fs::read(&project).unwrap());
+    for (out, what) in [(c, "footage"), (p, "project")] {
+        let (code, v) = run_json(&["render-frame", "--project", p, "--out", out]);
+        assert_eq!(code, 1, "{what}: {v}");
+        let error = v["error"].as_str().unwrap();
+        assert!(error.contains(out) && error.contains(what), "{what}: {v}");
+    }
+    assert_eq!(std::fs::read(&clip).unwrap(), footage, "the footage is as it was");
+    assert_eq!(std::fs::read(&project).unwrap(), saved, "the project file is as it was");
+    // Anywhere else it writes.
+    let free = root.join("frame.png");
+    ok_json(&["render-frame", "--project", p, "--out", free.to_str().unwrap()]);
+    assert_eq!(&std::fs::read(&free).unwrap()[..8], b"\x89PNG\r\n\x1a\n");
+    let _ = std::fs::remove_dir_all(&root);
+}
+
+/// Two queue items on one file are refused by the render before anything is written, with the
+/// file as it was.
+#[test]
+fn render_refuses_two_items_on_one_file() {
+    let root = tmp("render-clash");
+    let _ = std::fs::remove_dir_all(&root);
+    std::fs::create_dir_all(&root).unwrap();
+    let out = root.join("clash.mp4");
+    std::fs::write(&out, b"EARLIER").unwrap();
+    let project = root.join("p.ecproj");
+    let p = project.to_str().unwrap();
+    let add = json!({"output": out.to_str().unwrap()}).to_string();
+    ok_json(&[
+        "run",
+        "comp.new",
+        r#"{"name":"T","width":64,"height":36,"duration":1}"#,
+        "renderQueue.add",
+        &add,
+        "renderQueue.add",
+        &add,
+        "--empty",
+        "--save-as",
+        p,
+    ]);
+    let (code, v) = run_json(&["render", "--queue", "--project", p]);
+    assert_eq!(code, 1, "{v}");
+    let error = v["error"].as_str().unwrap();
+    assert!(error.contains("#1") && error.contains("#2") && error.contains("clash.mp4"), "{v}");
+    assert_eq!(std::fs::read(&out).unwrap(), b"EARLIER");
+    let _ = std::fs::remove_dir_all(&root);
+}
+
 /// A real stdio client: each edit's reply is read before disconnecting or killing the server.
 struct McpChild {
     child: std::process::Child,
@@ -533,6 +666,49 @@ fn a_failed_render_under_run_and_exec_exits_1() {
     assert!(v["error"].as_str().is_some_and(|e| e.starts_with("T: ")), "{v}");
 }
 
+/// A source refusal happens before encoding and has no started timestamp. It must still
+/// fail the CLI, while the valid queue item finishes and the imported frame stays intact.
+#[test]
+fn a_partly_protected_queue_exits_1_under_render_run_and_exec() {
+    let root = tmp("protected-mixed-queue");
+    let _ = std::fs::remove_dir_all(&root);
+    std::fs::create_dir_all(&root).unwrap();
+    let source = root.join("source_00000.png");
+    image::RgbaImage::from_pixel(4, 4, image::Rgba([40, 80, 120, 255])).save(&source).unwrap();
+    let original = std::fs::read(&source).unwrap();
+    let project = root.join("q.ecproj");
+    let good = root.join("good.gif");
+    let import = json!({"paths": [source]}).to_string();
+    let blocked = json!({"format": "png", "output": root.join("source_[#####].png")}).to_string();
+    let valid = json!({"format": "gif", "output": good}).to_string();
+    ok_json(&[
+        "run",
+        "--empty",
+        "--save-as",
+        project.to_str().unwrap(),
+        "comp.new",
+        r#"{"name":"Main","width":16,"height":16,"frameRate":10,"duration":0.1}"#,
+        "layer.newSolid",
+        "{}",
+        "file.import",
+        &import,
+        "renderQueue.add",
+        &blocked,
+        "renderQueue.add",
+        &valid,
+    ]);
+    let p = project.to_str().unwrap();
+    for args in [vec!["render", "--queue", "--project", p], vec!["run", p, "renderQueue.render", "{}"], vec!["exec", "renderQueue.render", "--project", p]] {
+        std::fs::write(&good, b"previous output").unwrap();
+        let (code, result) = run_json(&args);
+        assert_eq!(code, 1, "{args:?}: {result}");
+        assert!(result["error"].as_str().is_some_and(|e| e.contains("footage") && e.contains("source_00000.png")), "{result}");
+        assert_eq!(std::fs::read(&source).unwrap(), original);
+        assert!(std::fs::read(&good).unwrap().starts_with(b"GIF8"), "the valid item still rendered");
+    }
+    std::fs::remove_dir_all(root).unwrap();
+}
+
 /// `render --bitrate` (#440) targets the bitrate in VP9 WebM.
 #[test]
 fn render_bitrate_applies_to_vp9_webm() {
@@ -563,6 +739,113 @@ fn render_bitrate_applies_to_vp9_webm() {
     let _ = std::fs::remove_dir_all(&root);
 }
 
+/// `bench --roto --clip FRAMES --truth MASKS` runs the trackers on the user's own image sequences: here a bright disc
+/// drifting over a dark textured frame, with its true masks. Mismatched sequences are refused with a message.
+#[test]
+fn bench_roto_runs_on_a_users_clip() {
+    let (frames, masks) = (tmp("clip-frames"), tmp("clip-masks"));
+    let config = frames.join("config");
+    for d in [&frames, &masks] {
+        let _ = std::fs::remove_dir_all(d);
+        std::fs::create_dir_all(d).unwrap();
+    }
+    let (w, h) = (96u32, 72u32);
+    for f in 0..14u32 {
+        let (cx, cy) = (30.0 + 4.0 * f as f32, 36.0f32);
+        let (mut img, mut mask) = (image::RgbImage::new(w, h), image::GrayImage::new(w, h));
+        for y in 0..h {
+            for x in 0..w {
+                let inside = ((x as f32 - cx).powi(2) + (y as f32 - cy).powi(2)).sqrt() < 14.0;
+                let tex = 40 + ((x * 7 + y * 13) % 30) as u8;
+                img.put_pixel(x, y, if inside { image::Rgb([230, 120, 40 + (x % 20) as u8]) } else { image::Rgb([tex / 2, tex, tex + 20]) });
+                mask.put_pixel(x, y, image::Luma([if inside { 255 } else { 0 }]));
+            }
+        }
+        let extension = if f == 0 { "jpg" } else { "png" };
+        let stem = match f {
+            0 => "a".into(),
+            1 => "a.jpg".into(),
+            _ => format!("f{f:03}"),
+        };
+        img.save(frames.join(format!("{stem}.{extension}"))).unwrap();
+        mask.save(masks.join(format!("{stem}.png"))).unwrap();
+    }
+    let (f, m) = (frames.to_str().unwrap(), masks.to_str().unwrap());
+    let out = bin().env("EFFECTCRAFT_CONFIG_DIR", &config).args(["bench", "--roto", "--clip", f, "--truth", m, "--frames", "6", "--json"]).output().unwrap();
+    let text = String::from_utf8_lossy(&out.stdout).to_string();
+    assert!(out.status.success(), "{text}\n{}", String::from_utf8_lossy(&out.stderr));
+    let rows: Value = serde_json::from_str(&text).unwrap();
+    let row = rows.as_array().unwrap().iter().find(|row| row["tracker"] == "classical").unwrap();
+    assert_eq!(row["per_frame"].as_array().unwrap().len(), 6, "a user clip respects the requested frame limit");
+    let mean = row["mean_iou"].as_f64().unwrap();
+    assert!(mean > 0.8, "classical mean IoU on the user's clip: {mean}\n{text}");
+    // one mask short: refused
+    std::fs::remove_file(masks.join("f005.png")).unwrap();
+    let out = bin().env("EFFECTCRAFT_CONFIG_DIR", &config).args(["bench", "--roto", "--clip", f, "--truth", m]).output().unwrap();
+    assert!(!out.status.success());
+    assert!(String::from_utf8_lossy(&out.stderr).contains("must match"), "{}", String::from_utf8_lossy(&out.stderr));
+    // --clip without --truth
+    let out = bin().env("EFFECTCRAFT_CONFIG_DIR", &config).args(["bench", "--roto", "--clip", f]).output().unwrap();
+    assert!(!out.status.success());
+}
+
+#[test]
+fn bench_roto_rejects_mismatched_names_before_loading_images() {
+    let root = tmp("bench-clip-names");
+    let (frames, masks) = (root.join("frames"), root.join("masks"));
+    let _ = std::fs::remove_dir_all(&root);
+    for dir in [&frames, &masks] {
+        std::fs::create_dir_all(dir).unwrap();
+        std::fs::write(dir.join("f000.png"), []).unwrap();
+    }
+    std::fs::write(frames.join("f001.png"), []).unwrap();
+    std::fs::write(masks.join("f002.png"), []).unwrap();
+    let out = bin()
+        .env("EFFECTCRAFT_CONFIG_DIR", root.join("config"))
+        .args(["bench", "--roto", "--frames", "1", "--clip"])
+        .arg(&frames)
+        .arg("--truth")
+        .arg(&masks)
+        .output()
+        .unwrap();
+    let error = String::from_utf8_lossy(&out.stderr);
+    assert!(!out.status.success());
+    assert!(error.contains("names must match"), "validate the entire name set before decoding: {error}");
+    std::fs::remove_file(frames.join("f001.png")).unwrap();
+    std::fs::remove_file(masks.join("f002.png")).unwrap();
+    for dir in [&frames, &masks] {
+        std::fs::write(dir.join("f000.jpg"), []).unwrap();
+    }
+    let out =
+        bin().env("EFFECTCRAFT_CONFIG_DIR", root.join("config")).args(["bench", "--roto", "--clip"]).arg(&frames).arg("--truth").arg(&masks).output().unwrap();
+    assert!(!out.status.success());
+    assert!(String::from_utf8_lossy(&out.stderr).contains("unique stems"));
+    std::fs::remove_dir_all(root).unwrap();
+}
+
+/// `bench --roto --sam2 FILE` / `--mobilesam FILE` say why a file named on the command line cannot be
+/// used (a missing file, one that is not the published weights), instead of "not installed".
+#[test]
+fn bench_roto_reports_why_a_named_model_file_failed() {
+    let dir = tmp("bench-weights");
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let bogus = dir.join("bogus.bin");
+    std::fs::write(&bogus, b"not the weights").unwrap();
+    for flag in ["--sam2", "--mobilesam"] {
+        let missing = dir.join("missing.bin");
+        let out = bin().env("EFFECTCRAFT_CONFIG_DIR", dir.join("config")).args(["bench", "--roto", flag, missing.to_str().unwrap()]).output().unwrap();
+        let err = String::from_utf8_lossy(&out.stderr).to_string();
+        assert!(!out.status.success(), "{flag}: {err}");
+        assert!(err.contains(flag) && err.contains("missing.bin"), "{flag} names the file that could not be read: {err}");
+        let out = bin().env("EFFECTCRAFT_CONFIG_DIR", dir.join("config")).args(["bench", "--roto", flag, bogus.to_str().unwrap()]).output().unwrap();
+        let err = String::from_utf8_lossy(&out.stderr).to_string();
+        assert!(!out.status.success(), "{flag}: {err}");
+        assert!(err.contains("does not match"), "{flag} says the file is not the published weights: {err}");
+    }
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
 /// Render uses the same empty/project/demo selection as the other CLI commands.
 #[test]
 fn render_empty_does_not_load_the_demo() {
diff --git a/apps/effectcraft-cli/tests/it/main.rs b/apps/effectcraft-cli/tests/it/main.rs
index 17149f545..bca36ec78 100644
--- a/apps/effectcraft-cli/tests/it/main.rs
+++ b/apps/effectcraft-cli/tests/it/main.rs
@@ -2,3 +2,8 @@
 
 mod cli;
 mod qa_template;
+
+/// Nextest archives relocate binaries; plain Cargo keeps the compile-time path valid.
+fn binary() -> std::ffi::OsString {
+    std::env::var_os("NEXTEST_BIN_EXE_effectcraft_cli").unwrap_or_else(|| env!("CARGO_BIN_EXE_effectcraft-cli").into())
+}
diff --git a/apps/effectcraft-cli/tests/it/qa_template.rs b/apps/effectcraft-cli/tests/it/qa_template.rs
index 0618c0d63..ffbdb94e9 100644
--- a/apps/effectcraft-cli/tests/it/qa_template.rs
+++ b/apps/effectcraft-cli/tests/it/qa_template.rs
@@ -9,7 +9,7 @@ use std::process::Command;
 use serde_json::Value;
 
 fn cli(dir: &PathBuf, args: &[&str]) -> (i32, Value) {
-    let out = Command::new(env!("CARGO_BIN_EXE_effectcraft-cli")).current_dir(dir).args(args).arg("--json").output().unwrap();
+    let out = Command::new(crate::binary()).current_dir(dir).args(args).arg("--json").output().unwrap();
     let stdout = String::from_utf8_lossy(&out.stdout).to_string();
     let v = serde_json::from_str(stdout.trim()).unwrap_or_else(|e| panic!("{args:?}: {e}: {stdout} {}", String::from_utf8_lossy(&out.stderr)));
     (out.status.code().unwrap_or(-1), v)
@@ -152,6 +152,13 @@ fn essential_graphics_template_via_script_and_commands() {
     assert_eq!(image::open(&frames[0]).unwrap().to_rgba8(), edit);
     assert_eq!(std::fs::read(dir.join("lt.ectemplate")).unwrap(), original_template);
 
+    invalid_template_values_fail_cleanly(&dir);
+    template_usage_errors(&dir);
+    rational_template_keeps_exact_rate(&dir, &original_template);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+fn invalid_template_values_fail_cleanly(dir: &PathBuf) {
     // Invalid values fail before the queue creates an output directory, or frame rendering
     // overwrites an existing output. A JSON object and existing control names are required.
     for (name, values, expected) in [
@@ -164,25 +171,27 @@ fn essential_graphics_template_via_script_and_commands() {
         std::fs::write(dir.join(&values_file), values).unwrap();
         let output_dir = dir.join(format!("failed-{name}"));
         let out = output_dir.join("frame_[#####].png");
-        let (code, error) = cli(&dir, &["render", "--template", "lt.ectemplate", "--values", &values_file, "--out", out.to_str().unwrap()]);
+        let (code, error) = cli(dir, &["render", "--template", "lt.ectemplate", "--values", &values_file, "--out", out.to_str().unwrap()]);
         assert_eq!(code, 1, "{name}: {error}");
         assert!(error["error"].as_str().unwrap().contains(expected), "{name}: {error}");
         assert!(!output_dir.exists(), "{name}: invalid input created render output");
         std::fs::write(dir.join("untouched.png"), b"existing output").unwrap();
-        let (code, error) = cli(&dir, &["render-frame", "--template", "lt.ectemplate", "--values", &values_file, "--out", "untouched.png"]);
+        let (code, error) = cli(dir, &["render-frame", "--template", "lt.ectemplate", "--values", &values_file, "--out", "untouched.png"]);
         assert_eq!(code, 1, "{name}: {error}");
         assert_eq!(std::fs::read(dir.join("untouched.png")).unwrap(), b"existing output");
     }
-    let (code, error) = cli(&dir, &["render-frame", "--template", "lt.ectemplate", "--values", "missing-values.json", "--out", "missing.png"]);
+    let (code, error) = cli(dir, &["render-frame", "--template", "lt.ectemplate", "--values", "missing-values.json", "--out", "missing.png"]);
     assert_eq!(code, 1, "{error}");
     assert!(error["error"].as_str().unwrap().contains("cannot read values"), "{error}");
     assert!(!dir.join("missing.png").exists());
     std::fs::write(dir.join("large-values.json"), vec![b' '; 1024 * 1024 + 1]).unwrap();
-    let (code, error) = cli(&dir, &["render-frame", "--template", "lt.ectemplate", "--values", "large-values.json", "--out", "large.png"]);
+    let (code, error) = cli(dir, &["render-frame", "--template", "lt.ectemplate", "--values", "large-values.json", "--out", "large.png"]);
     assert_eq!(code, 1, "{error}");
     assert!(error["error"].as_str().unwrap().contains("exceeds 1 MiB"), "{error}");
     assert!(!dir.join("large.png").exists());
+}
 
+fn template_usage_errors(dir: &PathBuf) {
     for args in [
         vec!["render-frame", "--values", "values.json"],
         vec!["info", "--template", "lt.ectemplate"],
@@ -191,10 +200,12 @@ fn essential_graphics_template_via_script_and_commands() {
         vec!["render", "--template", "lt.ectemplate", "--queue"],
         vec!["render-frame", "--template", "lt.ectemplate", "--bridge", "1"],
     ] {
-        let output = Command::new(env!("CARGO_BIN_EXE_effectcraft-cli")).current_dir(&dir).args(&args).output().unwrap();
+        let output = Command::new(crate::binary()).current_dir(dir).args(&args).output().unwrap();
         assert_eq!(output.status.code(), Some(2), "{args:?}: {}", String::from_utf8_lossy(&output.stderr));
     }
+}
 
+fn rational_template_keeps_exact_rate(dir: &PathBuf, original_template: &[u8]) {
     // File-loaded templates can use exact rational rates that comp.new's float parser rounds.
     // Preserve that rate, Tick duration, work area, background and locked source layers.
     let mut project = effectcraft_engine::project::Project::from_json(&std::fs::read_to_string(dir.join("t.ecproj")).unwrap()).unwrap();
@@ -207,13 +218,13 @@ fn essential_graphics_template_via_script_and_commands() {
     comp.background = [0.08, 0.16, 0.24];
     comp.layers.first_mut().unwrap().switches.locked = true;
     std::fs::write(dir.join("rational.ecproj"), project.to_json()).unwrap();
-    ok(&dir, &["exec", "essential.exportTemplate", r#"{"comp":"Lower Third","path":"rational.ectemplate"}"#, "rational.ecproj"]);
+    ok(dir, &["exec", "essential.exportTemplate", r#"{"comp":"Lower Third","path":"rational.ectemplate"}"#, "rational.ecproj"]);
     let rational_template = std::fs::read(dir.join("rational.ectemplate")).unwrap();
-    let rational = ok(&dir, &["render-frame", "--template", "rational.ectemplate", "--frame", "5", "--out", "rational.png"]);
+    let rational = ok(dir, &["render-frame", "--template", "rational.ectemplate", "--frame", "5", "--out", "rational.png"]);
     assert!((rational["time"].as_f64().unwrap() - 5.0 / rate.as_f64()).abs() < 1e-9, "{rational}");
     assert_eq!((rational["width"].as_u64().unwrap(), rational["height"].as_u64().unwrap()), (320, 90));
     let output = dir.join("rational-work-area/frame_[#####].png");
-    ok(&dir, &["render", "--template", "rational.ectemplate", "--work-area", "--out", output.to_str().unwrap(), "--format", "png", "--resolution", "0.05"]);
+    ok(dir, &["render", "--template", "rational.ectemplate", "--work-area", "--out", output.to_str().unwrap(), "--format", "png", "--resolution", "0.05"]);
     let count = std::fs::read_dir(dir.join("rational-work-area"))
         .unwrap()
         .filter_map(Result::ok)
@@ -222,8 +233,8 @@ fn essential_graphics_template_via_script_and_commands() {
     assert_eq!(count, 4, "the template's exact work area contains frames 3 through 6");
     assert_eq!(std::fs::read(dir.join("rational.ectemplate")).unwrap(), rational_template);
     assert_eq!(std::fs::read(dir.join("lt.ectemplate")).unwrap(), original_template);
-    let _ = std::fs::remove_dir_all(&dir);
 }
+
 fn template_output_alias_fixture(case: &str) -> PathBuf {
     let dir = std::env::temp_dir().join(format!("ec-qa-template-output-{case}-{}", std::process::id()));
     let _ = std::fs::remove_dir_all(&dir);
@@ -251,7 +262,7 @@ fn assert_template_output_preserves_inputs(dir: &PathBuf, out: &str) -> Value {
     let template_before = std::fs::read(dir.join("lt.ectemplate")).unwrap();
     let values_before = std::fs::read(dir.join("values.json")).unwrap();
     // Read the inputs before interpreting the subprocess status or error text.
-    let result = Command::new(env!("CARGO_BIN_EXE_effectcraft-cli"))
+    let result = Command::new(crate::binary())
         .current_dir(dir)
         .args(["render-frame", "--template", "lt.ectemplate", "--values", "values.json", "--time", "1", "--out", out, "--json"])
         .output()
@@ -527,7 +538,7 @@ fn template_unknown_control_does_not_replace_extracted_media() {
     let invalid_values_before = std::fs::read(dir.join("bad-values.json")).unwrap();
 
     // Capture every file before interpreting status/JSON, so a failed command cannot hide a write.
-    let result = Command::new(env!("CARGO_BIN_EXE_effectcraft-cli"))
+    let result = Command::new(crate::binary())
         .current_dir(&dir)
         .args(["render-frame", "--template", "lt.ectemplate", "--values", "bad-values.json", "--time", "1", "--out", "failed.png", "--json"])
         .output()
@@ -623,11 +634,8 @@ fn template_missing_output_does_not_replace_extracted_media() {
     assert_ne!(sentinel_before, source_before);
 
     // Observe writes before interpreting the actual CLI usage exit.
-    let result = Command::new(env!("CARGO_BIN_EXE_effectcraft-cli"))
-        .current_dir(&dir)
-        .args(["render", "--template", "lt.ectemplate", "--values", "values.json", "--json"])
-        .output()
-        .unwrap();
+    let result =
+        Command::new(crate::binary()).current_dir(&dir).args(["render", "--template", "lt.ectemplate", "--values", "values.json", "--json"]).output().unwrap();
     let template_after = std::fs::read(dir.join("lt.ectemplate")).unwrap();
     let values_after = std::fs::read(dir.join("values.json")).unwrap();
     let source_after = std::fs::read(dir.join("source.png")).unwrap();
diff --git a/apps/effectcraft-web/Cargo.toml b/apps/effectcraft-web/Cargo.toml
index 28ea2f369..7743347af 100644
--- a/apps/effectcraft-web/Cargo.toml
+++ b/apps/effectcraft-web/Cargo.toml
@@ -37,6 +37,8 @@ js-sys = "0.3"
 web-sys = { version = "0.3", features = [
     "Blob",
     "BlobPropertyBag",
+    "AbortController",
+    "AbortSignal",
     "CssStyleDeclaration",
     "Document",
     "Element",
@@ -51,6 +53,12 @@ web-sys = { version = "0.3", features = [
     "HtmlInputElement",
     "Location",
     "Navigator",
+    "ReadableStream",
+    "ReadableStreamDefaultReader",
+    "Request",
+    "RequestCache",
+    "RequestInit",
+    "Response",
     "Url",
     "UrlSearchParams",
     "Window",
diff --git a/apps/effectcraft-web/js/host.js b/apps/effectcraft-web/js/host.js
index 12cb90bfa..c8e91a260 100644
--- a/apps/effectcraft-web/js/host.js
+++ b/apps/effectcraft-web/js/host.js
@@ -7,6 +7,23 @@
 //
 // Plain functions only: the Rust side owns the logic.
 
+// ------------------------------------------------------------------ shortcuts
+
+/// Keep Duplicate on the app canvas instead of also opening the browser's bookmarks.
+/// The physical D key counts on layouts where it types no ASCII letter (e.g. Cyrillic), because
+/// eframe falls back to the key code there; it does not on Dvorak, where it types E.
+/// eframe still receives the key; other chords and HTML inputs keep their browser behavior.
+export function installCanvasShortcuts(canvas) {
+  canvas.addEventListener("keydown", (event) => {
+    if (event.target === canvas && (event.ctrlKey || event.metaKey)
+      && !event.shiftKey && !event.altKey && !event.isComposing
+      && (event.key.toLowerCase() === "d"
+        || (event.code === "KeyD" && !/^[a-z]$/i.test(event.key)))) {
+      event.preventDefault();
+    }
+  }, { capture: true });
+}
+
 // ------------------------------------------------------------------ storage
 
 const DIR = "effectcraft";
@@ -19,7 +36,7 @@ const enc = (k) => encodeURIComponent(k);
 const dec = (n) => decodeURIComponent(n);
 
 async function opfs() {
-  if (!navigator.storage || !navigator.storage.getDirectory) throw new Error("no OPFS");
+  if (!navigator.storage?.getDirectory) throw new Error("no OPFS");
   const root = await navigator.storage.getDirectory();
   const dir = await root.getDirectoryHandle(DIR, { create: true });
   // Probe a write: some browsers expose OPFS but only write it from workers.
@@ -116,7 +133,7 @@ export async function storeOpen(prefer) {
     try { backend = await make(); break; } catch (e) { console.info(`storage: ${make.name}: ${e.message ?? e}`); }
   }
   // Ask the browser not to evict the store under storage pressure (granted for installed apps).
-  try { if (navigator.storage && navigator.storage.persist) await navigator.storage.persist(); } catch {}
+  try { if (navigator.storage?.persist) await navigator.storage.persist(); } catch {}
   return backend.name;
 }
 
@@ -128,7 +145,7 @@ export async function storeDelete(key) { return backend.del(key); }
 /// Ask the browser to keep the origin's storage under pressure; resolves with whether it is.
 export async function storePersist() {
   try {
-    if (navigator.storage && navigator.storage.persist) return await navigator.storage.persist();
+    if (navigator.storage?.persist) return await navigator.storage.persist();
   } catch {}
   return false;
 }
@@ -227,7 +244,7 @@ export async function audioStart(workletUrl) {
       }
       if (gen !== generation) return;
       node = new AudioWorkletNode(c, "effectcraft-output", { numberOfInputs: 0, outputChannelCount: [2] });
-      node.port.onmessage = (e) => { if (e.data && e.data.underrun) underruns += e.data.underrun; };
+      node.port.onmessage = (e) => { if (e.data?.underrun) underruns += e.data.underrun; };
       kind = "worklet";
     } catch (e) {
       console.warn("audio: AudioWorklet unavailable, using ScriptProcessorNode", e);
@@ -318,11 +335,11 @@ function spawn(base) {
   const w = { worker, files: new Map(), ready: null, gpu: null };
   w.ready = new Promise((res, rej) => {
     worker.onmessage = (e) => {
-      if (e.data && e.data.type === "gpu") {
+      if (e.data?.type === "gpu") {
         w.gpu = e.data.gpu ? { adapter: e.data.gpu } : { cpu: e.data.error || "no GPU" };
         jobGpu = w.gpu;
       }
-      if (e.data && e.data.type === "ready") res();
+      if (e.data?.type === "ready") res();
     };
     worker.onerror = (e) => rej(new Error(e.message || "worker failed to start"));
   });
@@ -341,7 +358,7 @@ export function workerRun(id, json, files, base, onMessage) {
   } catch (e) {
     // `new Worker` throws at once when the page's origin is opaque (a sandboxed iframe): the job
     // fails like one whose worker didn't start.
-    setTimeout(() => onMessage("error", String((e && e.message) || e), null, null));
+    setTimeout(() => onMessage("error", String(e?.message || e), null, null));
     return;
   }
   running.set(id, w);
@@ -416,12 +433,12 @@ export function frameWorkerStart(base, onMessage, gpu) {
     // slot stays, and the failure is reported like a worker that died, after the caller has
     // recorded the index: frames then render on the page's thread (as with `?noworkers`).
     frameWorkers.push(null);
-    setTimeout(() => onMessage(index, undefined, undefined, String((e && e.message) || e || "frame worker failed")));
+    setTimeout(() => onMessage(index, undefined, undefined, String(e?.message || e || "frame worker failed")));
     return index;
   }
   worker.onmessage = (e) => {
     const m = e.data;
-    if (m && m.type === "frameReply") onMessage(index, m.json, m.bytes ? new Uint8Array(m.bytes) : null, undefined);
+    if (m?.type === "frameReply") onMessage(index, m.json, m.bytes ? new Uint8Array(m.bytes) : null, undefined);
   };
   worker.onerror = (e) => {
     onMessage(index, undefined, undefined, String(e.message || "frame worker failed"));
@@ -447,7 +464,7 @@ const cacheDirHandles = {};
 
 async function cacheDir(kind = "frames") {
   if (cacheDirHandles[kind]) return cacheDirHandles[kind];
-  if (!navigator.storage || !navigator.storage.getDirectory) throw new Error("no Origin Private File System");
+  if (!navigator.storage?.getDirectory) throw new Error("no Origin Private File System");
   let d = await navigator.storage.getDirectory();
   for (const n of [CACHE_ROOT, "v1", kind]) d = await d.getDirectoryHandle(n, { create: true });
   cacheDirHandles[kind] = d;
@@ -544,7 +561,7 @@ export async function cacheClear() {
 
 /// Whether this thread has WebGPU (`navigator.gpu`).
 export function hasWebGpu() {
-  return !!(self.navigator && self.navigator.gpu);
+  return !!self.navigator?.gpu;
 }
 
 /// Post a message ({type: "frame", json} or {type: "file", path, bytes}) to frame worker `index`.
@@ -652,7 +669,7 @@ export async function browseForget(name) {
 export async function browseRead(path) {
   const rel = path.replace(/^\/Folders\//, "");
   const folder = folders.get(rel.split("/")[0]);
-  const h = folder && folder.files.get(rel);
+  const h = folder?.files.get(rel);
   if (!h) throw new Error(`${path}: its folder is not open (reconnect it)`);
   return new Uint8Array(await (await h.getFile()).arrayBuffer());
 }
@@ -706,7 +723,7 @@ export function showDeviceLost(message, kept) {
     self.effectcraft
       .execute("file.save", {})
       .catch(() => self.effectcraft.execute("file.saveAs", { path: "/Untitled Project.ecproj" }))
-      .catch((e) => (text.textContent = `Saving failed: ${(e && e.message) || e}`));
+      .catch((e) => (text.textContent = `Saving failed: ${e?.message || e}`));
   const reload = document.createElement("button");
   reload.textContent = "Reload";
   reload.onclick = async () => {
@@ -714,7 +731,7 @@ export function showDeviceLost(message, kept) {
     try {
       await self.effectcraft.flush();
     } catch (e) {
-      text.textContent = `Writing to browser storage failed (${(e && e.message) || e}). Save the project, or reload anyway and lose the changes.`;
+      text.textContent = `Writing to browser storage failed (${e?.message || e}). Save the project, or reload anyway and lose the changes.`;
       reload.textContent = "Reload Anyway";
       reload.disabled = false;
       reload.onclick = () => location.reload();
diff --git a/apps/effectcraft-web/src/app.rs b/apps/effectcraft-web/src/app.rs
index f09bf28a1..2882b16cf 100644
--- a/apps/effectcraft-web/src/app.rs
+++ b/apps/effectcraft-web/src/app.rs
@@ -6,7 +6,8 @@ use std::sync::atomic::{AtomicBool, Ordering};
 
 use effectcraft_engine::Session;
 
-use crate::{api, audio, browse, diskcache, files, frames, persist, storage, worker};
+use crate::startup::Startup;
+use crate::{api, audio, browse, config_file, diskcache, files, frames, persist, storage, worker};
 use effectcraft_ui_egui::EffectcraftApp;
 use serde_json::json;
 use wasm_bindgen::prelude::*;
@@ -15,6 +16,8 @@ use wasm_bindgen::prelude::*;
 extern "C" {
     #[wasm_bindgen(js_name = showDeviceLost)]
     fn show_device_lost(message: &str, kept: bool);
+    #[wasm_bindgen(js_name = installCanvasShortcuts)]
+    fn install_canvas_shortcuts(canvas: &web_sys::HtmlCanvasElement);
 }
 
 /// Work for the UI thread with access to the app (posted by async tasks: picked files…).
@@ -81,11 +84,19 @@ pub(crate) fn open_or_import(app: &mut EffectcraftApp, paths: Vec<String>) {
 /// The eframe app: the shared EffectCraft UI plus the browser host's per-frame duties.
 pub struct WebApp {
     pub app: EffectcraftApp,
-    /// Keep the session snapshot (off with `?empty`).
+    /// Keep the session snapshot (off with `?empty`; off with an explicit `"demo"` startup until
+    /// the user's own work begins, see `demo_start`).
     pub persist: bool,
+    /// Started on the demo by the config: the snapshot stays off, so the demo never replaces the
+    /// last visit's project, until the user opens a project from a file or edits the demo.
+    pub demo_start: bool,
+    /// The last title written to `document.title`.
+    pub document_title: String,
 }
 
 impl eframe::App for WebApp {
+    /// Take dropped files out of `raw_input` before eframe can replay them on a hidden tab, read them asynchronously
+    /// through `open_or_import`, then run the shared app's input hook.
     fn raw_input_hook(&mut self, ctx: &egui::Context, raw_input: &mut egui::RawInput) {
         // Files dropped on the page are input: read them here, where the browser's drop event is
         // still the current pass's, not from a later (possibly logic-only) tick.
@@ -101,15 +112,28 @@ impl eframe::App for WebApp {
         self.app.raw_input_hook(ctx, raw_input);
     }
 
+    /// The browser host's logic tick: run queued UI actions, tick the shared app, poll API replies, flush Render
+    /// Queue downloads, persist the session snapshot when enabled, publish GPU/frame-worker/disk-cache info and close
+    /// the IME pass.
     fn logic(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
         let actions = ACTIONS.with(|a| std::mem::take(&mut *a.borrow_mut()));
         for f in actions {
             f(&mut self.app);
         }
         self.app.tick(ctx, frame);
+        // eframe on the web ignores `ViewportCommand::Title`: the tab title follows the open document here.
+        if self.app.window_title() != self.document_title {
+            self.document_title = self.app.window_title().to_owned();
+            set_document_title(&self.document_title);
+        }
         api::poll_replies();
         // Render Queue outputs written this frame (here or by a worker) → downloads.
         files::flush_downloads();
+        // The user's own work after a demo start is worth keeping too: turn the snapshot on.
+        if self.demo_start && (self.app.session.path.is_some() || self.app.session.is_dirty()) {
+            self.demo_start = false;
+            self.persist = true;
+        }
         // What a reload comes back to.
         if self.persist {
             // The app's monotonic clock: `ctx.input(|i| i.time)` is stale in a logic-only tick.
@@ -129,6 +153,13 @@ impl eframe::App for WebApp {
     }
 }
 
+/// The browser tab's title.
+fn set_document_title(title: &str) {
+    if let Some(doc) = web_sys::window().and_then(|w| w.document()) {
+        doc.set_title(title);
+    }
+}
+
 fn query() -> Option<web_sys::UrlSearchParams> {
     web_sys::window().and_then(|w| w.location().search().ok()).and_then(|s| web_sys::UrlSearchParams::new_with_str(&s).ok())
 }
@@ -182,8 +213,24 @@ fn install_hooks(app: &mut EffectcraftApp) {
         }
         None
     }));
-    // Saving downloads the file: the chosen name is all a "save dialog" needs.
-    app.hooks.pick_save = Some(Box::new(|name: &str| Some(files::path_for(if name.is_empty() { "Untitled Project.ecproj" } else { name }))));
+    // Saving downloads the file: the chosen name is all a "save dialog" needs. A project (Save As,
+    // Save a Copy) asks for the name, starting from the open project's (#2788): without asking,
+    // Save As would replace the open project's file; Cancel cancels. A name that is already in
+    // browser storage asks before replacing it, as the desktop's save dialogs do.
+    app.hooks.pick_save = Some(Box::new(|name: &str| {
+        let name = if name.is_empty() { "Untitled Project.ecproj" } else { name };
+        if !std::path::Path::new(name).extension().is_some_and(|e| e.eq_ignore_ascii_case("ecproj") || e.eq_ignore_ascii_case("ecprojx")) {
+            return Some(files::path_for(name));
+        }
+        let window = web_sys::window()?;
+        let typed = window.prompt_with_message_and_default("Save project as:", name).ok().flatten();
+        let typed = crate::store::typed_save_name(name, typed)?;
+        let path = files::path_for(&typed);
+        if files::get(&path).is_some() && !window.confirm_with_message(&format!("{typed} already exists. Replace it?")).unwrap_or(false) {
+            return None;
+        }
+        Some(path)
+    }));
     app.hooks.audio_device = Some(Box::new(audio::open));
     app.hooks.audio_devices = Some(Box::new(|| vec!["Browser default output".into()]));
 }
@@ -199,6 +246,7 @@ pub async fn start(canvas_id: String) -> Result<(), JsValue> {
     effectcraft_ui_egui::i18n::set_system_locales(query_value("lang"), browser.collect());
     let doc = web_sys::window().and_then(|w| w.document()).ok_or("no document")?;
     let canvas: web_sys::HtmlCanvasElement = doc.get_element_by_id(&canvas_id).ok_or("no canvas")?.dyn_into()?;
+    install_canvas_shortcuts(&canvas);
     let empty = query_flag("empty");
     let home = query_flag("home");
     // Browser storage: settings, recent projects, imported media, saved projects, auto-saves and
@@ -215,6 +263,11 @@ pub async fn start(canvas_id: String) -> Result<(), JsValue> {
     };
     api::set_info("storage", json!({"backend": persist::backend(), "entries": stored, "loadMs": t0.elapsed().as_secs_f64() * 1000.0}));
     audio::install_unlock();
+    // `./effectcraft-config.json`: what to open on load.
+    // `?empty` and `?demo` decide by themselves, so they skip the request.
+    let startup = if empty || query_flag("demo") { Startup::default() } else { config_file::startup().await };
+    // An explicit `"demo"` start leaves the saved session alone until the user opens or edits something.
+    let keep_session = !empty && startup.keeps_session();
     browse::restore();
     diskcache::init();
     storage::refresh();
@@ -240,7 +293,7 @@ pub async fn start(canvas_id: String) -> Result<(), JsValue> {
                     // The canvas can't present any more (#225): the page says so over it and
                     // offers a reload, which brings the session back when browser storage keeps it.
                     let lost = gpu_failures.clone();
-                    let kept = !empty && persist::backend() != "memory";
+                    let kept = keep_session && persist::backend() != "memory";
                     rs.device.set_device_lost_callback(move |reason, message| {
                         let message = format!("GPU device lost ({reason:?}): {message}");
                         lost.report(&message, true);
@@ -249,11 +302,14 @@ pub async fn start(canvas_id: String) -> Result<(), JsValue> {
                 }
                 let mut session = session();
                 session.load_settings();
+                // Scripts in Scripts/Startup run before a project opens.
+                let _ = session.execute("file.runStartupScripts", json!({}));
                 let recovery = session.begin_recovery();
-                // `?empty`: a blank project; `?demo`: the demo project; otherwise the last visit's
-                // project (the demo on a first visit).
-                let restored = !empty && !query_flag("demo") && persist::restore(&mut session);
-                if !restored && !empty {
+                // `?empty`: a blank project; `?demo`: the demo project; otherwise what the config's
+                // `startup` says (default: the last visit's project, the demo on a first visit).
+                let demo = query_flag("demo");
+                let restored = !empty && !demo && startup.restores() && persist::restore(&mut session);
+                if !restored && !empty && (demo || startup.demo_when_nothing_restored()) {
                     let _ = session.execute("file.openDemoProject", json!({}));
                 }
                 api::set_info("restored", json!(restored));
@@ -279,7 +335,7 @@ pub async fn start(canvas_id: String) -> Result<(), JsValue> {
                 app = app.with_control(rx);
                 let backend = cc.wgpu_render_state.as_ref().map(|rs| format!("{:?}", rs.adapter.get_info().backend));
                 api::set_info("backend", json!(backend));
-                Ok(Box::new(WebApp { app, persist: !empty }))
+                Ok(Box::new(WebApp { app, persist: keep_session, demo_start: !empty && !keep_session, document_title: String::new() }))
             }),
         )
         .await?;
diff --git a/apps/effectcraft-web/src/config_file.rs b/apps/effectcraft-web/src/config_file.rs
new file mode 100644
index 000000000..614d7d4cb
--- /dev/null
+++ b/apps/effectcraft-web/src/config_file.rs
@@ -0,0 +1,73 @@
+//! `./effectcraft-config.json`, fetched once per page load and shared by whoever reads a key.
+
+use std::cell::RefCell;
+
+use wasm_bindgen::{JsCast, closure::Closure};
+use wasm_bindgen_futures::JsFuture;
+
+use crate::startup::{self, Startup};
+
+/// Longest the request and the body read may take (ms); a stalled server must not hold up start-up.
+const TIMEOUT_MS: i32 = 5_000;
+
+thread_local! {
+    /// `None`: not fetched yet; `Some(None)`: no usable file.
+    static FILE: RefCell<Option<Option<Vec<u8>>>> = const { RefCell::new(None) };
+}
+
+/// The config file's bytes, or `None` when it is missing, too large, unreadable or the request
+/// takes longer than [`TIMEOUT_MS`] (the timer aborts the request and covers the body read).
+async fn fetch() -> Option<Vec<u8>> {
+    let win = web_sys::window()?;
+    let ctl = web_sys::AbortController::new().ok()?;
+    let init = web_sys::RequestInit::new();
+    // Always ask the server: the file is the operator's switch, never a cached copy.
+    init.set_cache(web_sys::RequestCache::NoCache);
+    init.set_signal(Some(&ctl.signal()));
+    let on_timeout = Closure::once(move || ctl.abort());
+    let timer = win.set_timeout_with_callback_and_timeout_and_arguments_0(on_timeout.as_ref().unchecked_ref(), TIMEOUT_MS).ok()?;
+    let out = read(&win, &init).await;
+    win.clear_timeout_with_handle(timer);
+    out
+}
+
+/// Fetch the file and read its body chunk by chunk, giving up as soon as it passes `CONFIG_MAX`.
+async fn read(win: &web_sys::Window, init: &web_sys::RequestInit) -> Option<Vec<u8>> {
+    let req = web_sys::Request::new_with_str_and_init("effectcraft-config.json", init).ok()?;
+    let resp: web_sys::Response = JsFuture::from(win.fetch_with_request(&req)).await.ok()?.dyn_into().ok()?;
+    if resp.status() != 200 {
+        return None;
+    }
+    let reader: web_sys::ReadableStreamDefaultReader = resp.body()?.get_reader().unchecked_into();
+    let mut out = Vec::new();
+    loop {
+        let chunk = JsFuture::from(reader.read()).await.ok()?;
+        if js_sys::Reflect::get(&chunk, &"done".into()).ok()?.as_bool() == Some(true) {
+            return Some(out);
+        }
+        let bytes: js_sys::Uint8Array = js_sys::Reflect::get(&chunk, &"value".into()).ok()?.dyn_into().ok()?;
+        if out.len().saturating_add(bytes.length() as usize) > startup::CONFIG_MAX {
+            // Stop the download: the limit is enforced while reading, not after the whole body arrived.
+            let _ = reader.cancel();
+            return None;
+        }
+        out.extend_from_slice(&bytes.to_vec());
+    }
+}
+
+/// The config file's bytes (`None` when there is none), fetched on the first call.
+pub async fn bytes() -> Option<Vec<u8>> {
+    if let Some(done) = FILE.with(|f| f.borrow().clone()) {
+        return done;
+    }
+    let got = fetch().await;
+    FILE.with(|f| *f.borrow_mut() = Some(got.clone()));
+    got
+}
+
+/// The configured startup behaviour.
+pub async fn startup() -> Startup {
+    let s = bytes().await.map(|b| startup::parse(&b)).unwrap_or_default();
+    log::info!("startup: {s:?}");
+    s
+}
diff --git a/apps/effectcraft-web/src/files.rs b/apps/effectcraft-web/src/files.rs
index 206314e4b..f6aac5aa4 100644
--- a/apps/effectcraft-web/src/files.rs
+++ b/apps/effectcraft-web/src/files.rs
@@ -151,6 +151,10 @@ impl Services for WebServices {
     fn is_dir(&self, _path: &str) -> bool {
         false
     }
+    /// The table's keys are the paths themselves.
+    fn full_path(&self, path: &str) -> Option<String> {
+        Some(path.to_string())
+    }
 }
 
 /// Media import from the table (the bytes are also handed to the media pool, which decodes them).
diff --git a/apps/effectcraft-web/src/frames.rs b/apps/effectcraft-web/src/frames.rs
index c7f350526..69089e308 100644
--- a/apps/effectcraft-web/src/frames.rs
+++ b/apps/effectcraft-web/src/frames.rs
@@ -311,10 +311,11 @@ pub fn stats() -> Value {
     })
 }
 
+type PendingFrameCheck = (js_sys::Function, js_sys::Function, (u32, u32, Vec<u8>), f64);
+
 thread_local! {
     /// `workerFrameCheck` promises waiting for their frame: id → (resolve, reject, local frame).
-    #[allow(clippy::type_complexity)]
-    static CHECKS: RefCell<std::collections::HashMap<u64, (js_sys::Function, js_sys::Function, (u32, u32, Vec<u8>), f64)>> = RefCell::new(Default::default());
+    static CHECKS: RefCell<std::collections::HashMap<u64, PendingFrameCheck>> = RefCell::new(Default::default());
 }
 
 /// `effectcraft.workerFrameCheck({time?, scale?, backend?})`: render the active comp's frame in
diff --git a/apps/effectcraft-web/src/lib.rs b/apps/effectcraft-web/src/lib.rs
index 0d59906f2..e1bf85894 100644
--- a/apps/effectcraft-web/src/lib.rs
+++ b/apps/effectcraft-web/src/lib.rs
@@ -6,22 +6,23 @@
 //!
 //! | Desktop | Web |
 //! |---|---|
-//! | file system (`FsServices`, media reads, export writes) | a virtual file table ([`files`]) persisted to the Origin Private File System / IndexedDB ([`persist`], [`store`]) |
+//! | file system (`FsServices`, media reads, export writes) | a virtual file table (`files`) persisted to the Origin Private File System / IndexedDB (`persist`, [`store`]) |
 //! | config directory (settings, shortcuts, recent projects, auto-saves) | the same store ([`store::WebConfig`]) |
 //! | rfd file dialogs | `<input type=file>` pickers; drop files on the page |
-//! | Media Browser on the file system | browser storage and folders opened with the File System Access API ([`browse`]) |
+//! | Media Browser on the file system | browser storage and folders opened with the File System Access API (`browse`) |
 //! | written files (Save, Render Queue) | browser downloads (several render files as one `.zip`) |
-//! | frame render threads | frame workers, each with a project replica fed by diffs and its own WebGPU device ([`frames`]); `Frames::pump` on the UI thread without workers |
-//! | disk cache folder | frames in the Origin Private File System, written by the frame workers ([`diskcache`]) |
-//! | (none) | the storage manager: usage, quota, persistence, clearing ([`storage`]) |
-//! | Render Queue / analysis threads | Web Workers running their own engine instance ([`worker`]) |
-//! | cpal audio output | Web Audio: an AudioWorklet fed from the preview mixdown ([`audio`]) |
-//! | TCP control channel / MCP | `window.effectcraft` JavaScript API ([`api`]) |
+//! | frame render threads | frame workers, each with a project replica fed by diffs and its own WebGPU device (`frames`); `Frames::pump` on the UI thread without workers |
+//! | disk cache folder | frames in the Origin Private File System, written by the frame workers (`diskcache`) |
+//! | (none) | the storage manager: usage, quota, persistence, clearing (`storage`) |
+//! | Render Queue / analysis threads | Web Workers running their own engine instance (`worker`) |
+//! | cpal audio output | Web Audio: an AudioWorklet fed from the preview mixdown (`audio`) |
+//! | TCP control channel / MCP | `window.effectcraft` JavaScript API (`api`) |
 //!
-//! [`store`] is portable (unit-tested natively); everything else is `wasm32`-only.
+//! [`store`] and [`startup`] are portable (unit-tested natively); everything else is `wasm32`-only.
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
+pub mod startup;
 pub mod store;
 
 #[cfg(target_arch = "wasm32")]
@@ -33,6 +34,8 @@ pub mod audio;
 #[cfg(target_arch = "wasm32")]
 pub mod browse;
 #[cfg(target_arch = "wasm32")]
+pub mod config_file;
+#[cfg(target_arch = "wasm32")]
 pub mod diskcache;
 #[cfg(target_arch = "wasm32")]
 pub mod files;
diff --git a/apps/effectcraft-web/src/startup.rs b/apps/effectcraft-web/src/startup.rs
new file mode 100644
index 000000000..4759096f3
--- /dev/null
+++ b/apps/effectcraft-web/src/startup.rs
@@ -0,0 +1,55 @@
+//! The `startup` key of `./effectcraft-config.json`: which project the page opens on load.
+//!
+//! | Value | On load |
+//! |---|---|
+//! | `"last"` (and absent) | the last visit's project; the demo project on a first visit |
+//! | `"empty"` | the last visit's project; a blank project on a first visit, never the demo |
+//! | `"demo"` | the demo project, whatever the last visit left |
+//!
+//! The `?empty` and `?demo` URL flags still win. Anything else (a missing key, another type, an
+//! unknown value, a config that is not JSON) is the default, `"last"`.
+
+use serde_json::Value;
+
+/// What the page opens on load.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Startup {
+    #[default]
+    Last,
+    Empty,
+    Demo,
+}
+
+/// The largest config file read (bytes).
+pub const CONFIG_MAX: usize = 64 * 1024;
+
+/// The `startup` key of a config file's bytes.
+pub fn parse(bytes: &[u8]) -> Startup {
+    if bytes.len() > CONFIG_MAX {
+        return Startup::default();
+    }
+    let Ok(v) = serde_json::from_slice::<Value>(bytes) else { return Startup::default() };
+    match v.get("startup").and_then(Value::as_str) {
+        Some("empty") => Startup::Empty,
+        Some("demo") => Startup::Demo,
+        _ => Startup::Last,
+    }
+}
+
+impl Startup {
+    /// Whether the last visit's project is restored (off for the demo).
+    pub fn restores(self) -> bool {
+        self != Startup::Demo
+    }
+
+    /// Whether the session snapshot keeps being saved (off for the demo, so it never replaces the
+    /// project the last visit left).
+    pub fn keeps_session(self) -> bool {
+        self != Startup::Demo
+    }
+
+    /// Whether the demo project opens when nothing was restored (off for a blank start).
+    pub fn demo_when_nothing_restored(self) -> bool {
+        self != Startup::Empty
+    }
+}
diff --git a/apps/effectcraft-web/src/store.rs b/apps/effectcraft-web/src/store.rs
index 8aafdac1c..0cc877948 100644
--- a/apps/effectcraft-web/src/store.rs
+++ b/apps/effectcraft-web/src/store.rs
@@ -152,6 +152,24 @@ pub fn key_path(key: &str) -> Option<&str> {
     key.strip_prefix(FILES).filter(|p| p.starts_with('/'))
 }
 
+/// The project file name typed in the web's Save As prompt (#2788): `None` when it was cancelled or
+/// left empty; folders are dropped (the file table is flat) and a name without the default's
+/// extension gets it (`Intro copy` → `Intro copy.ecproj`, `Intro.v2` → `Intro.v2.ecproj`), so the
+/// browser still opens and keeps it as a project.
+pub fn typed_save_name(default: &str, typed: Option<String>) -> Option<String> {
+    let typed = typed?;
+    let name = typed.trim().rsplit(['/', '\\']).next().unwrap_or("").trim();
+    if name.is_empty() {
+        return None;
+    }
+    let ext = Path::new(default).extension().map(|e| e.to_string_lossy().to_string()).unwrap_or_default();
+    if ext.is_empty() || Path::new(name).extension().is_some_and(|e| e.eq_ignore_ascii_case(&ext)) {
+        Some(name.to_string())
+    } else {
+        Some(format!("{name}.{ext}"))
+    }
+}
+
 /// FNV-1a 64. Computed when a disk-cache key first needs the file, not on every write.
 fn content_hash(data: &[u8]) -> u64 {
     let mut h: u64 = 0xcbf2_9ce4_8422_2325;
@@ -366,6 +384,21 @@ impl ConfigStore for WebConfig {
         v.sort();
         v
     }
+    /// The first name part of the keys under `dir/`.
+    fn list_dirs(&self, dir: &str) -> Vec<String> {
+        let pre = format!("{CONFIG}{}/", dir.trim_end_matches('/'));
+        let mut v: Vec<String> = self
+            .store
+            .lock()
+            .list(&pre)
+            .into_iter()
+            .filter_map(|(k, ..)| k.strip_prefix(&pre)?.split_once('/').map(|(d, _)| d.to_string()))
+            .filter(|d| !d.is_empty())
+            .collect();
+        v.sort();
+        v.dedup();
+        v
+    }
     fn dir(&self) -> Option<PathBuf> {
         Some(PathBuf::from("/"))
     }
@@ -421,6 +454,20 @@ pub struct SnapshotMeta {
 mod tests {
     use super::*;
 
+    #[test]
+    fn typed_save_names() {
+        let t = |s: &str| Some(s.to_string());
+        assert_eq!(typed_save_name("Intro.ecproj", t("Intro copy")).as_deref(), Some("Intro copy.ecproj"));
+        assert_eq!(typed_save_name("Intro.ecproj", t("  Other.ecproj ")).as_deref(), Some("Other.ecproj"));
+        assert_eq!(typed_save_name("Intro.ecproj", t("a/b\\Shot.ecproj")).as_deref(), Some("Shot.ecproj"));
+        assert_eq!(typed_save_name("Intro.ecproj", t("Intro.v2")).as_deref(), Some("Intro.v2.ecproj"));
+        assert_eq!(typed_save_name("Intro.ecproj", t("Intro.ECPROJ")).as_deref(), Some("Intro.ECPROJ"));
+        assert_eq!(typed_save_name("Intro.ecprojx", t("Intro")).as_deref(), Some("Intro.ecprojx"));
+        assert_eq!(typed_save_name("Intro.ecproj", t("   ")), None);
+        assert_eq!(typed_save_name("Intro.ecproj", t("folder/")), None);
+        assert_eq!(typed_save_name("Intro.ecproj", None), None);
+    }
+
     fn store() -> Arc<Store> {
         let s = Arc::new(Store::default());
         let _ = s.clock.set(|| 1_000.0);
@@ -533,6 +580,22 @@ mod tests {
         assert_eq!(s.file("/clip.mp4").as_deref(), Some(&b"abc"[..]));
     }
 
+    /// Scripts in a subfolder of the Scripts folder (`Tools/Hello.jsx`) are listed, as on the desktop.
+    #[test]
+    fn config_store_lists_folders() {
+        let c = WebConfig::new(store());
+        for name in ["Scripts/Top.jsx", "Scripts/Tools/Hello.jsx", "Scripts/Tools/More.jsx", "Scripts/ScriptUI Panels/Kit/A.jsx"] {
+            c.write(name, "x").unwrap();
+        }
+        assert_eq!(c.list("Scripts"), ["Top.jsx"]);
+        assert_eq!(c.list_dirs("Scripts"), ["ScriptUI Panels", "Tools"]);
+        assert_eq!(c.list_dirs("Scripts/ScriptUI Panels"), ["Kit"]);
+        let mut s = effectcraft_engine::Session { config: Some(Arc::new(c)), ..Default::default() };
+        let list = s.execute("file.scripts.list", serde_json::json!({})).unwrap();
+        let installed: Vec<&str> = list.as_array().unwrap().iter().filter(|e| e["source"] == "installed").filter_map(|e| e["name"].as_str()).collect();
+        assert_eq!(installed, ["Tools/Hello.jsx", "Tools/More.jsx", "Top.jsx", "Kit/A.jsx"]);
+    }
+
     #[test]
     fn config_store_and_file_ops() {
         let s = store();
diff --git a/apps/effectcraft-web/tests/it/main.rs b/apps/effectcraft-web/tests/it/main.rs
new file mode 100644
index 000000000..a4d242ba5
--- /dev/null
+++ b/apps/effectcraft-web/tests/it/main.rs
@@ -0,0 +1 @@
+mod startup_tests;
diff --git a/apps/effectcraft-web/tests/it/startup_tests.rs b/apps/effectcraft-web/tests/it/startup_tests.rs
new file mode 100644
index 000000000..3ce90569c
--- /dev/null
+++ b/apps/effectcraft-web/tests/it/startup_tests.rs
@@ -0,0 +1,52 @@
+//! The `startup` key of the config file.
+
+use effectcraft_web::startup::{CONFIG_MAX, Startup, parse};
+
+/// The three accepted values parse.
+#[test]
+fn the_three_values() {
+    assert_eq!(parse(br#"{"startup":"empty"}"#), Startup::Empty);
+    assert_eq!(parse(br#"{"startup":"demo"}"#), Startup::Demo);
+    assert_eq!(parse(br#"{"startup":"last"}"#), Startup::Last);
+}
+
+/// A missing key, a wrong type, an unknown value or a non-object file gives `Last`.
+#[test]
+fn absent_or_invalid_is_the_default() {
+    for bytes in
+        [&b"{}"[..], b"", b"not json", b"[]", b"null", br#"{"startup":1}"#, br#"{"startup":"Empty"}"#, br#"{"startup":null}"#, br#"{"startup":["empty"]}"#]
+    {
+        assert_eq!(parse(bytes), Startup::Last, "{:?}", String::from_utf8_lossy(bytes));
+    }
+}
+
+/// Other keys do not hide `startup`.
+#[test]
+fn a_config_with_other_keys_still_has_its_startup() {
+    assert_eq!(parse(br#"{"remote":{"mounts":[]},"startup":"empty"}"#), Startup::Empty);
+    assert_eq!(parse(br#"{"startup":"demo","unknown":{"a":1}}"#), Startup::Demo);
+}
+
+/// A file over `CONFIG_MAX` is ignored.
+#[test]
+fn an_oversized_file_is_the_default() {
+    let mut big = br#"{"startup":"empty","pad":""#.to_vec();
+    big.extend(std::iter::repeat_n(b'x', CONFIG_MAX));
+    big.extend_from_slice(br#""}"#);
+    assert_eq!(parse(&big), Startup::Last);
+}
+
+/// Which project each value restores or opens.
+#[test]
+fn what_each_value_does_on_load() {
+    assert!(Startup::Last.restores() && Startup::Last.demo_when_nothing_restored());
+    assert!(Startup::Empty.restores() && !Startup::Empty.demo_when_nothing_restored());
+    assert!(!Startup::Demo.restores() && Startup::Demo.demo_when_nothing_restored());
+}
+
+/// Only the explicit demo start stops saving the session.
+#[test]
+fn only_the_demo_start_leaves_the_saved_session_alone() {
+    assert!(Startup::Last.keeps_session() && Startup::Empty.keeps_session());
+    assert!(!Startup::Demo.keeps_session());
+}
diff --git a/apps/effectcraft-web/tests/page.mjs b/apps/effectcraft-web/tests/page.mjs
index 063015236..3728e59e2 100644
--- a/apps/effectcraft-web/tests/page.mjs
+++ b/apps/effectcraft-web/tests/page.mjs
@@ -8,6 +8,8 @@
 // - A lost WebGPU device: the page says so over the canvas and offers Save Project and Reload;
 //   the reload writes pending changes to browser storage first, and a failed write is reported
 //   instead of reloading (#225).
+// - Duplicate cancels the browser's bookmark action on the app canvas, while still delivering
+//   the key to the app; other chords and HTML inputs keep their browser behavior (#2495).
 // Exits non-zero on failure.
 import assert from "node:assert/strict";
 import { dirname, join } from "node:path";
@@ -58,6 +60,30 @@ globalThis.location = { reload: () => reloads++ };
 
 const host = await import(pathToFileURL(join(here, "../js/host.js")));
 
+// #2495: prevent the browser default without swallowing the app's Duplicate key.
+const canvas = new EventTarget();
+const input = new EventTarget();
+host.installCanvasShortcuts(canvas);
+let delivered = 0;
+canvas.addEventListener("keydown", () => delivered++);
+const key = (target, properties) => {
+  const event = new Event("keydown", { cancelable: true });
+  Object.assign(event, { key: "d", ...properties });
+  target.dispatchEvent(event);
+  return event.defaultPrevented;
+};
+assert.equal(key(canvas, { ctrlKey: true }), true);
+assert.equal(key(canvas, { metaKey: true, key: "D" }), true);
+for (const properties of [{}, { ctrlKey: true, shiftKey: true }, { ctrlKey: true, altKey: true }, { ctrlKey: true, isComposing: true }, { ctrlKey: true, key: "r" }]) {
+  assert.equal(key(canvas, properties), false);
+}
+// Non-Latin layouts: the physical D key types "в", and eframe still reads it as D.
+assert.equal(key(canvas, { ctrlKey: true, key: "в", code: "KeyD" }), true);
+// Dvorak: the physical D key types "e", which is not Duplicate.
+assert.equal(key(canvas, { ctrlKey: true, key: "e", code: "KeyD" }), false);
+assert.equal(delivered, 9, "all keys still reach the app");
+assert.equal(key(input, { ctrlKey: true }), false, "an external HTML input keeps its shortcut");
+
 // #226: one readable and one unreadable file.
 const file = (name, read) => ({ name, webkitRelativePath: "", arrayBuffer: read });
 const picked = host.browsePickFiles(false);
diff --git a/apps/effectcraft-web/tests/smoke.mjs b/apps/effectcraft-web/tests/smoke.mjs
index 3a6c1337c..83091a72a 100644
--- a/apps/effectcraft-web/tests/smoke.mjs
+++ b/apps/effectcraft-web/tests/smoke.mjs
@@ -162,7 +162,7 @@ try {
   const info = await js("effectcraft.info()");
   report.steps.gpu = { webgpu: info.webgpu, backend: info.backend, ...info.gpu };
   if (info.webgpu && info.backend === "BrowserWebGpu") {
-    check(info.gpu && info.gpu.compositor, "GPU compositor on WebGPU");
+    check(info.gpu?.compositor, "GPU compositor on WebGPU");
     check(info.gpu.viewerOnGpu, "viewer frames on the GPU");
   }
 
@@ -250,7 +250,7 @@ try {
   const st = await js(`(async () => { await new Promise((r) => setTimeout(r, 1200)); return effectcraft.execute("storage.info", {}); })()`);
   report.steps.storage = st;
   check(st.available && st.quota > 0 && st.usage > 0, `storage.info: ${JSON.stringify(st)}`);
-  check(st.diskCache && st.diskCache.enabled && st.diskCache.writes > 0, `disk cache in OPFS: ${JSON.stringify(st.diskCache)}`);
+  check(st.diskCache?.enabled && st.diskCache.writes > 0, `disk cache in OPFS: ${JSON.stringify(st.diskCache)}`);
   await js(`effectcraft.execute("prefs.open", {page: "disk"})`);
   await sleep(800);
   report.steps.storage.screenshot = await shot("01c-storage-manager");
@@ -378,14 +378,14 @@ try {
     const jobs = gj.workers.jobs || [];
     const rj = jobs.filter((j) => j.kind === "Render").pop();
     const wj = jobs.filter((j) => j.kind === "Warp").pop();
-    check(gj.workers.gpu && gj.workers.gpu.adapter, `job workers have a GPU: ${JSON.stringify(gj.workers)}`);
+    check(gj.workers.gpu?.adapter, `job workers have a GPU: ${JSON.stringify(gj.workers)}`);
     check(gj.status.every((st) => st === "Done"), `GPU job render: ${JSON.stringify(gj.status)}`);
-    check(rj && rj.gpu && rj.readbacks >= 3 && rj.passes >= 6, `Render Queue frames on the job worker's GPU, in passes: ${JSON.stringify(rj)}`);
+    check(rj?.gpu && rj.readbacks >= 3 && rj.passes >= 6, `Render Queue frames on the job worker's GPU, in passes: ${JSON.stringify(rj)}`);
     check(gj.warp.analyzed, `Warp Stabilizer analysed in a job worker: ${JSON.stringify(gj.warp)}`);
-    check(wj && wj.gpu && wj.readbacks > 0, `Warp Stabilizer input frames on the job worker's GPU: ${JSON.stringify(wj)}`);
+    check(wj?.gpu && wj.readbacks > 0, `Warp Stabilizer input frames on the job worker's GPU: ${JSON.stringify(wj)}`);
     const fj = jobs.filter((j) => j.kind === "ContentFill").pop();
     check(!gj.fill.error && gj.fillLayers.length > 0, `Content-Aware Fill in a job worker: ${JSON.stringify(gj.fill)} ${JSON.stringify(gj.fillLayers)}`);
-    check(fj && fj.gpu && fj.readbacks > 0, `Content-Aware Fill frames on the job worker's GPU: ${JSON.stringify(fj)}`);
+    check(fj?.gpu && fj.readbacks > 0, `Content-Aware Fill frames on the job worker's GPU: ${JSON.stringify(fj)}`);
     check(gj.maxGapMs < 400, `event loop blocked ${gj.maxGapMs} ms during the GPU jobs: ${JSON.stringify(gj.gaps)}`);
     check(gj.gaps.prepareFill < 50, `event loop blocked ${gj.gaps.prepareFill} ms while editing after the analysis (pre-compose, mask): ${JSON.stringify(gj.gaps)}`);
   } else {
@@ -418,7 +418,7 @@ try {
   check(mb.path === "/Browser Storage" && mb.entries.some((e) => e.name === "tone.wav" && e.kind === "audio"), `Media Browser: ${JSON.stringify(report.steps.mediaBrowser)}`);
   check(mb.actions.some((a) => a.id === "addFiles"), "Media Browser: Add Files…");
   const mbImport = await js(`effectcraft.execute("mediaBrowser.import", {paths: [${JSON.stringify(mb.entries.find((e) => e.name === "tone.wav")?.path ?? "/tone.wav")}]})`);
-  check(!mbImport.pending && mbImport.items && mbImport.items.length === 1, `Media Browser import: ${JSON.stringify(mbImport)}`);
+  check(!mbImport.pending && mbImport.items?.length === 1, `Media Browser import: ${JSON.stringify(mbImport)}`);
   await js(`effectcraft.request("ui.playback", {action: "stop"})`);
   await js(`effectcraft.execute("time.set", {time: 0})`);
   await js(`effectcraft.request("ui.playback", {action: "play"})`);
@@ -579,7 +579,7 @@ try {
   report.steps.final2 = { screenshot: await shot("03-offline") };
 } catch (e) {
   failed = true;
-  report.error = String(e && e.stack || e);
+  report.error = String(e?.stack || e);
   try { report.errorShot = await shot("error"); } catch {}
 }
 report.console = logs.slice(-40);
diff --git a/apps/effectcraft-web/web/sw.js b/apps/effectcraft-web/web/sw.js
index 4acbeeeeb..8f48a93bc 100644
--- a/apps/effectcraft-web/web/sw.js
+++ b/apps/effectcraft-web/web/sw.js
@@ -3,7 +3,8 @@
 // `cargo xtask web` fills in the build's file list and version. Every file is precached into a
 // cache named after the version, served cache-first (responses keep the server's headers, so
 // the page stays cross-origin isolated: COOP/COEP), and old versions are dropped once the new
-// one activates. Anything else same-origin is fetched from the network and cached for next time.
+// one activates. Anything else same-origin is fetched from the network and cached for next time,
+// except the config file, which must stay live.
 const VERSION = "__EC_VERSION__";
 const FILES = __EC_FILES__;
 const CACHE = `effectcraft-${VERSION}`;
@@ -30,6 +31,7 @@ self.addEventListener("fetch", (event) => {
   const req = event.request;
   const url = new URL(req.url);
   if (req.method !== "GET" || url.origin !== self.location.origin) return;
+  if (url.pathname.endsWith("/effectcraft-config.json")) return;
   event.respondWith(
     (async () => {
       const cache = await caches.open(CACHE).catch(() => null);
diff --git a/apps/effectcraft/src/main.rs b/apps/effectcraft/src/main.rs
index d49330fa5..a560b00e3 100644
--- a/apps/effectcraft/src/main.rs
+++ b/apps/effectcraft/src/main.rs
@@ -9,8 +9,8 @@
 //!
 //! `--control <port>` (or `EFFECTCRAFT_CONTROL_PORT`) starts a localhost JSON-lines control server;
 //! see `effectcraft_ui_egui::control` for the methods.
-#![cfg_attr(all(target_os = "windows", not(debug_assertions)), windows_subsystem = "windows")]
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+#![cfg_attr(all(target_os = "windows", not(debug_assertions)), windows_subsystem = "windows")]
 
 // Built everywhere so its tests run on every platform; only Linux AppImages use it.
 mod appearance;
@@ -128,20 +128,34 @@ fn control_port(name: &str, value: Option<&str>) -> Result<u16, String> {
 /// answer without pumping events, so the window stops answering the compositor and the desktop
 /// offers to force-quit it while the Open dialog is up (#1275). Windows' blocking dialog pumps
 /// its own messages, so it keeps [`effectcraft_ui_egui::Hooks::pick_files`] and friends.
-fn install_file_dialogs(app: &mut EffectcraftApp, ctx: &egui::Context) {
+/// The dialogs asked for in a frame show at its end ([`sheet_dialogs::show_asked`]), where the
+/// main window's handle is at hand.
+fn install_file_dialogs(app: &mut EffectcraftApp) -> Option<std::sync::mpsc::Receiver<sheet_dialogs::Asked>> {
     #[cfg(any(target_os = "macos", target_os = "linux"))]
     {
-        let ctx = ctx.clone();
-        app.hooks.file_dialog_async = Some(Box::new(move |dialog, done| sheet_dialogs::show(dialog, done, ctx.clone())));
+        let (tx, rx) = std::sync::mpsc::channel::<sheet_dialogs::Asked>();
+        app.hooks.file_dialog_async = Some(Box::new(move |dialog, done| {
+            if tx.send((dialog, done)).is_err() {
+                log::error!("file dialog: the window is gone");
+            }
+        }));
+        Some(rx)
     }
     #[cfg(not(any(target_os = "macos", target_os = "linux")))]
-    let _ = (app, ctx);
+    {
+        let _ = app;
+        None
+    }
 }
 
+/// Run a normal desktop launch: install logging and the panic hook, parse arguments (`--version` exits before the
+/// session log is attached), scan fonts, honor the launch guard's backend choice and open the eframe window.
+/// Builds the session, loads settings, plugins, the requested project/media and the optional control server, then
+/// reports startup failure through `startup_failed`. Returns the event loop's result.
 fn main() -> eframe::Result {
     // Windows: the update helper is a copy of this program started with `--finish-update`.
     #[cfg(windows)]
-    if let Some(result) = craft_update::self_update::finish(&craft_update::suite::EFFECTCRAFT, &std::env::args_os().skip(1).collect::<Vec<_>>()) {
+    if let Some(result) = craft_update::self_update::finish(&effectcraft_ui_egui::UPDATE_APP, &std::env::args_os().skip(1).collect::<Vec<_>>()) {
         std::process::exit(i32::from(result.is_err()));
     }
     // First, so the panic hook and every start-up warning are recorded. Records go to stderr
@@ -249,6 +263,9 @@ fn main() -> eframe::Result {
             // Fit the window to its monitor, or put it back where it was (still hidden).
             let saved_window = session.config.as_deref().and_then(window::load);
             let opened = cc.winit_window().map(|w| window::restore(w, saved_window));
+            // Scripts in Scripts/Startup run before a project opens (a failing one is reported in
+            // a toast).
+            let _ = session.execute("file.runStartupScripts", json!({}));
             let recovery = if control_port.is_none() { session.begin_recovery() } else { None };
             let project = files.iter().find(|f| is_project_file(f)).cloned();
             if let Some(p) = project {
@@ -326,7 +343,7 @@ fn main() -> eframe::Result {
             }));
             // The commands' file dialogs don't block the frame where the platform's backend
             // would (#511, #1275); see [`install_file_dialogs`].
-            install_file_dialogs(&mut app, &cc.egui_ctx);
+            let file_dialogs = install_file_dialogs(&mut app);
             #[cfg(target_os = "macos")]
             {
                 app.hooks.app_action = Some(Box::new(native_menu::app_action));
@@ -344,20 +361,18 @@ fn main() -> eframe::Result {
                 #[cfg(target_os = "macos")]
                 apple_events: apple_events.connect(&cc.egui_ctx),
                 app,
+                file_dialogs,
                 window: window::Tracker::new(opened, saved_window, control_port.is_none()),
                 launch,
                 drawn: false,
             }))
         }),
     );
-    match &result {
-        Ok(()) => log::info!("the window closed"),
-        Err(e) => {
-            if on_gl {
-                launch_guard::opengl_failed(effectcraft_host::config_dir().as_deref());
-            }
-            startup_failed(e, !on_gl && cfg!(not(target_os = "macos")));
+    if let Err(e) = &result {
+        if on_gl {
+            launch_guard::opengl_failed(effectcraft_host::config_dir().as_deref());
         }
+        startup_failed(e, !on_gl && cfg!(not(target_os = "macos")));
     }
     result
 }
@@ -366,9 +381,15 @@ fn main() -> eframe::Result {
 /// instead of eframe's fixed set: an older GPU that can't meet those (Intel HD Graphics 5500,
 /// #198) still opens the app, and the compositor then checks what it needs and falls back to
 /// the CPU when the device can't run it. `backends`: Window Graphics' choice, when it makes one.
+///
+/// The surface is eframe's own default, [`eframe::SurfaceConfig::LOW_LATENCY`]: vsync with one
+/// frame in flight, so a drag or a scrub shows one frame sooner. The bare
+/// `WgpuConfiguration::default()` is `HIGH_THROUGHPUT` instead (two frames in flight, three
+/// drawables on Metal): one more frame of pointer-to-screen lag on every interaction, about 8 ms
+/// at 120 Hz and 17 ms at 60 Hz, and a third 15 MB drawable held for the window.
 fn wgpu_options(backends: Option<eframe::wgpu::Backends>) -> eframe::WgpuConfiguration {
     use eframe::egui_wgpu::WgpuSetup;
-    let mut config = eframe::WgpuConfiguration::default();
+    let mut config = eframe::WgpuConfiguration::default().with_surface_config(eframe::SurfaceConfig::LOW_LATENCY);
     if let WgpuSetup::CreateNew(setup) = &mut config.wgpu_setup {
         if let Some(b) = backends {
             setup.instance_descriptor.backends = b;
@@ -425,6 +446,8 @@ fn startup_failed(e: &eframe::Error, gl_next: bool) {
 /// The desktop app: the egui app plus, on macOS, the system menu bar.
 struct Desktop {
     app: EffectcraftApp,
+    /// The commands' file dialogs, shown at the end of the frame that asked for them.
+    file_dialogs: Option<std::sync::mpsc::Receiver<sheet_dialogs::Asked>>,
     #[cfg(target_os = "macos")]
     menu: native_menu::NativeBar,
     /// Documents opened from Finder, the Dock or `open` (macOS).
@@ -438,15 +461,24 @@ struct Desktop {
 }
 
 impl eframe::App for Desktop {
+    /// The desktop host's logic tick: update the macOS menu bar, run the shared app tick, close the IME pass, show the
+    /// file dialogs asked for and, last, hand a close to the platform quit.
     fn logic(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
         #[cfg(target_os = "macos")]
         self.menu.update(&mut self.app, ctx);
         self.app.tick(ctx, frame);
         self.app.finish_ime_logic(ctx);
+        if let Some(asked) = &self.file_dialogs {
+            sheet_dialogs::show_asked(asked, frame, ctx);
+        }
+        effectcraft_ui_egui::panels::unsaved::quit_on_close(ctx);
     }
 
     fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
         self.app.ui(ui, frame);
+        if let Some(asked) = &self.file_dialogs {
+            sheet_dialogs::show_asked(asked, frame, ui.ctx());
+        }
         self.window.frame(ui.ctx(), self.app.session.config.as_deref());
         if !self.drawn {
             self.drawn = true;
@@ -460,9 +492,14 @@ impl eframe::App for Desktop {
     }
 
     fn on_exit(&mut self) {
+        // On macOS the app quits through `-[NSApplication terminate:]`, and the process ends
+        // before `eframe::run_native` returns (#341).
+        log::info!("the window is closing");
         self.launch.exited();
         self.window.save(self.app.session.config.as_deref());
         self.app.on_exit();
+        // Scripts in Scripts/Shutdown run with the project closed.
+        let _ = self.app.session.execute("file.runShutdownScripts", json!({}));
     }
 
     fn raw_input_hook(&mut self, ctx: &egui::Context, raw_input: &mut egui::RawInput) {
@@ -541,6 +578,19 @@ mod tests {
         assert!(!setup.instance_descriptor.flags.contains(eframe::wgpu::InstanceFlags::VALIDATION_INDIRECT_CALL));
     }
 
+    /// The window's surface keeps one frame in flight, like eframe's own default, not the two
+    /// of the bare `WgpuConfiguration::default()` (one extra frame of lag on every drag).
+    #[test]
+    fn the_window_surface_is_low_latency() {
+        for backends in [None, Some(eframe::wgpu::Backends::METAL), Some(eframe::wgpu::Backends::GL)] {
+            let surface = super::wgpu_options(backends).surface;
+            assert_eq!(surface, eframe::SurfaceConfig::LOW_LATENCY, "{backends:?}");
+            assert_eq!(surface.desired_maximum_frame_latency, Some(1));
+            assert_eq!(surface.present_mode, eframe::wgpu::PresentMode::AutoVsync);
+        }
+        assert_eq!(super::wgpu_options(None).surface, eframe::NativeOptions::default().wgpu_options.surface, "eframe's default surface");
+    }
+
     /// The window's device never asks for more than the adapter offers (#198).
     #[test]
     fn device_limits_fit_the_adapter() {
@@ -646,10 +696,10 @@ mod tests {
     #[test]
     fn commands_file_dialogs_do_not_block_the_frame() {
         let mut app = effectcraft_ui_egui::EffectcraftApp::new(effectcraft_engine::Session::default());
-        super::install_file_dialogs(&mut app, &egui::Context::default());
+        let asked = super::install_file_dialogs(&mut app);
         #[cfg(any(target_os = "macos", target_os = "linux"))]
-        assert!(app.hooks.file_dialog_async.is_some(), "the commands' file dialogs must not block the frame");
+        assert!(app.hooks.file_dialog_async.is_some() && asked.is_some(), "the commands' file dialogs must not block the frame");
         #[cfg(not(any(target_os = "macos", target_os = "linux")))]
-        assert!(app.hooks.file_dialog_async.is_none(), "the blocking dialog pumps its own messages here");
+        assert!(app.hooks.file_dialog_async.is_none() && asked.is_none(), "the blocking dialog pumps its own messages here");
     }
 }
diff --git a/apps/effectcraft/src/native_menu.rs b/apps/effectcraft/src/native_menu.rs
index 9db2ffe76..c3b142c5f 100644
--- a/apps/effectcraft/src/native_menu.rs
+++ b/apps/effectcraft/src/native_menu.rs
@@ -2,10 +2,10 @@
 //! [`effectcraft_ui_egui::native_menu`]'s spec of the engine's After Effects menu tree.
 //!
 //! Each frame [`NativeBar::update`] runs menu activations (the same command ids as the in-window
-//! bar), and when [`native_menu::state_key`] changed it rebuilds the spec and pushes labels,
-//! enabled and check state into the existing items; a structural change (Open Recent, a new
-//! shortcut preset) rebuilds the menu. Settings ▸ Appearance ▸ Use In-Window Menu Bar on macOS
-//! swaps back to the in-window bar.
+//! bar), and when [`native_menu::state_key`] or whether a text field has the keyboard changed it
+//! rebuilds the spec and pushes labels, enabled and check state into the existing items; a
+//! structural change (Open Recent, a new shortcut preset) rebuilds the menu. Settings ▸
+//! Appearance ▸ Use In-Window Menu Bar on macOS swaps back to the in-window bar.
 
 use std::collections::HashMap;
 use std::sync::mpsc::{Receiver, channel};
@@ -24,7 +24,7 @@ pub struct NativeBar {
     items: HashMap<String, CheckMenuItem>,
     spec: NativeMenu,
     structure: u64,
-    state: Option<u64>,
+    state: Option<(u64, bool)>,
     events: Receiver<MenuEvent>,
     /// The in-window-bar setting last applied (None: not yet).
     in_window: Option<bool>,
@@ -67,12 +67,13 @@ impl NativeBar {
         if in_window {
             return;
         }
-        let key = native_menu::state_key(app);
+        // While a text field has the keyboard, the Edit items it takes stay enabled.
+        let key = (native_menu::state_key(app), native_menu::text_field_window(ctx).is_some());
         if self.state == Some(key) && self.menu.is_some() {
             return;
         }
         self.state = Some(key);
-        let spec = native_menu::build(app);
+        let spec = native_menu::build_now(app, ctx);
         let structure = spec.structure();
         if self.menu.is_none() || structure != self.structure {
             self.install(&spec);
diff --git a/apps/effectcraft/src/sheet_dialogs.rs b/apps/effectcraft/src/sheet_dialogs.rs
index 7a75ef2a7..911870190 100644
--- a/apps/effectcraft/src/sheet_dialogs.rs
+++ b/apps/effectcraft/src/sheet_dialogs.rs
@@ -17,10 +17,24 @@ use std::pin::Pin;
 
 type Answer = Pin<Box<dyn Future<Output = Vec<String>> + Send>>;
 
-/// Show `dialog` (on the main thread: the sheet opens here) and hand its paths to `done` once it
-/// closes, then wake the UI.
-pub fn show(dialog: FileDialog, done: DialogDone, ctx: egui::Context) {
-    let answer = open(dialog);
+/// A command's dialog waiting for [`show_asked`].
+pub type Asked = (FileDialog, DialogDone);
+
+/// Show the dialogs the commands asked for in this frame (on the main thread: a sheet opens
+/// here) and hand each one's paths to its `done` once it closes, then wake the UI.
+///
+/// On macOS the sheet goes on the main window (`frame`'s). Without a parent rfd puts it on
+/// AppKit's main window, which is a floating panel's OS window after a click in one; that
+/// window hides while the app has no focused window, and a sheet whose window goes away ends
+/// without answering, with later sheets queued behind it on the same window.
+pub fn show_asked(asked: &std::sync::mpsc::Receiver<Asked>, frame: &eframe::Frame, ctx: &egui::Context) {
+    while let Ok((dialog, done)) = asked.try_recv() {
+        show(dialog, done, frame, ctx.clone());
+    }
+}
+
+fn show(dialog: FileDialog, done: DialogDone, frame: &eframe::Frame, ctx: egui::Context) {
+    let answer = open(dialog, frame);
     let spawned = std::thread::Builder::new().name("ec-file-dialog".into()).spawn(move || {
         done(pollster::block_on(answer));
         ctx.request_repaint();
@@ -30,6 +44,13 @@ pub fn show(dialog: FileDialog, done: DialogDone, ctx: egui::Context) {
     }
 }
 
+/// A dialog on the main window. Linux keeps the portal's dialog unparented: rfd exports the
+/// window for the portal from the dialog's worker thread there.
+fn parented(frame: &eframe::Frame) -> AsyncFileDialog {
+    let d = AsyncFileDialog::new();
+    if cfg!(target_os = "macos") { d.set_parent(frame) } else { d }
+}
+
 fn paths(files: Option<Vec<FileHandle>>) -> Vec<String> {
     files.unwrap_or_default().into_iter().map(|f| f.path().to_string_lossy().to_string()).collect()
 }
@@ -39,10 +60,10 @@ fn path(file: Option<FileHandle>) -> Vec<String> {
 }
 
 /// The dialog, as the blocking hooks in `main.rs` show it.
-fn open(dialog: FileDialog) -> Answer {
+fn open(dialog: FileDialog, frame: &eframe::Frame) -> Answer {
     match dialog {
         FileDialog::Open { exts, many } => {
-            let d = AsyncFileDialog::new().add_filter("Media", &exts);
+            let d = parented(frame).add_filter("Media", &exts);
             if many {
                 let f = d.pick_files();
                 Box::pin(async move { paths(f.await) })
@@ -52,22 +73,22 @@ fn open(dialog: FileDialog) -> Answer {
             }
         }
         FileDialog::OpenProject => {
-            let f = AsyncFileDialog::new().add_filter("EffectCraft Project", &["ecproj", "ecprojx"]).pick_file();
+            let f = parented(frame).add_filter("EffectCraft Project", &["ecproj", "ecprojx"]).pick_file();
             Box::pin(async move { path(f.await) })
         }
         FileDialog::Folder => {
-            let f = AsyncFileDialog::new().pick_folder();
+            let f = parented(frame).pick_folder();
             Box::pin(async move { path(f.await) })
         }
         FileDialog::Save { default, ext, project } => {
             let at = std::path::Path::new(&default);
             let name = at.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();
             let mut d = if project {
-                AsyncFileDialog::new().add_filter("EffectCraft Project", &["ecproj"])
+                parented(frame).add_filter("EffectCraft Project", &["ecproj"])
             } else if ext.is_empty() {
-                AsyncFileDialog::new()
+                parented(frame)
             } else {
-                AsyncFileDialog::new().add_filter(&ext, &[ext.as_str()])
+                parented(frame).add_filter(&ext, &[ext.as_str()])
             };
             // A default with a folder that exists opens the dialog there.
             if let Some(dir) = at.parent().filter(|d| d.is_dir()) {
diff --git a/apps/effectcraft/tests/args.rs b/apps/effectcraft/tests/args.rs
index 8367d2a99..62c591b45 100644
--- a/apps/effectcraft/tests/args.rs
+++ b/apps/effectcraft/tests/args.rs
@@ -1,11 +1,14 @@
 //! The desktop binary rejects a bad command line before it starts anything (#997).
-// Integration tests: unwrapping and panicking on failure is fine here.
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
 use std::time::{Duration, Instant};
 
+/// Nextest archives relocate binaries; plain Cargo keeps the compile-time path valid.
+fn binary() -> std::ffi::OsString {
+    std::env::var_os("NEXTEST_BIN_EXE_effectcraft").unwrap_or_else(|| env!("CARGO_BIN_EXE_effectcraft").into())
+}
+
 /// A settings folder of its own, so a launch that got past the arguments would show up as
 /// preferences (Recent Footage) written there instead of in the user's settings.
 fn config_dir(name: &str) -> PathBuf {
@@ -19,7 +22,7 @@ fn config_dir(name: &str) -> PathBuf {
 /// regression fails instead of leaving a window open: the process is killed after 5 s.
 fn rejects(name: &str, args: &[&str], env: &[(&str, &str)], message: &str) {
     let config = config_dir(name);
-    let mut cmd = Command::new(env!("CARGO_BIN_EXE_effectcraft"));
+    let mut cmd = Command::new(binary());
     cmd.args(args).env_remove("EFFECTCRAFT_CONTROL_PORT").env_remove("RUST_LOG").env("EFFECTCRAFT_CONFIG_DIR", &config);
     for (k, v) in env {
         cmd.env(k, v);
@@ -67,7 +70,7 @@ fn a_bad_control_port_stops_the_launch() {
 
 #[test]
 fn version_still_prints_with_a_bad_port_variable() {
-    let out = Command::new(env!("CARGO_BIN_EXE_effectcraft")).arg("--version").env("EFFECTCRAFT_CONTROL_PORT", "abc").output().unwrap();
+    let out = Command::new(binary()).arg("--version").env("EFFECTCRAFT_CONTROL_PORT", "abc").output().unwrap();
     assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
     assert_eq!(String::from_utf8(out.stdout).unwrap(), format!("effectcraft {}\n", env!("CARGO_PKG_VERSION")));
 }
diff --git a/assets/app-icon/README.md b/assets/app-icon/README.md
index 814ad601a..f0265ce9e 100644
--- a/assets/app-icon/README.md
+++ b/assets/app-icon/README.md
@@ -15,9 +15,8 @@ full-bleed colour field, tight head-and-shoulders crop, the body running off the
 | Paper | `#efe9dc` | the figure |
 | Ink | `#0b0b0c` | line work and contour |
 
-**Provenance:** the project owner drew it in ArtCraft (a 2880 px engraving-style image, kept in
-craftrules at `assets/app-icons/effectcraft/source.png`). It was vectorised with craftrules
-`assets/logo-options/_tools/vectorize_tile.py`, which keys out the field and traces the ink with potrace.
+**Provenance:** the project owner drew it in ArtCraft (a 2880 px engraving-style image). It was
+vectorised with potrace, which keys out the field and traces the ink.
 Licence: see [LICENSE.txt](LICENSE.txt) (MIT OR Apache-2.0, like the repo).
 
 ## Files
@@ -37,6 +36,5 @@ App ID: `ai.storyteller.effectcraft` (Wayland app ID, `packaging/linux/ai.storyt
 
 ## Regenerate
 
-Copy a new `icon-master.svg` / `icon.svg` from craftrules `assets/app-icons/effectcraft/` over
-`effectcraft.svg` / `effectcraft-small.svg`, then run `packaging/icons.sh` (needs `resvg`; `iconutil`
+After replacing `effectcraft.svg` / `effectcraft-small.svg`, run `packaging/icons.sh` (needs `resvg`; `iconutil`
 on macOS for the `.icns`). Copy `effectcraft-small.svg` to `apps/effectcraft-web/web/favicon.svg` too.
diff --git a/assets/app-icon/effectcraft-small.svg.attribution b/assets/app-icon/effectcraft-small.svg.attribution
index 6dbaab168..88fd92379 100644
--- a/assets/app-icon/effectcraft-small.svg.attribution
+++ b/assets/app-icon/effectcraft-small.svg.attribution
@@ -5,4 +5,4 @@ source:       original work
 license:      MIT OR Apache-2.0
 license-file: assets/app-icon/LICENSE.txt
 added:        2026-10-02 by EffectCraft contributors (Claude agent, app icon)
-notes:        The same drawing vectorised at 1024 px with craftrules vectorize_tile.py, about 350 KB, for places where size matters.
+notes:        The same drawing vectorised at 1024 px, about 350 KB, for places where size matters.
diff --git a/assets/app-icon/effectcraft.svg.attribution b/assets/app-icon/effectcraft.svg.attribution
index 219606236..19bf871bd 100644
--- a/assets/app-icon/effectcraft.svg.attribution
+++ b/assets/app-icon/effectcraft.svg.attribution
@@ -5,4 +5,4 @@ source:       original work
 license:      MIT OR Apache-2.0
 license-file: assets/app-icon/LICENSE.txt
 added:        2026-10-02 by EffectCraft contributors (Claude agent, app icon)
-notes:        The owner's ArtCraft drawing of an engraved unicorn bust, vectorised at 2048 px with craftrules assets/logo-options/_tools/vectorize_tile.py (potrace; three colours). Canonical artwork; the other icon files derive from it.
+notes:        The owner's ArtCraft drawing of an engraved unicorn bust, vectorised at 2048 px (potrace; three colours). Canonical artwork; the other icon files derive from it.
diff --git a/clippy.toml b/clippy.toml
index 4b6c79f55..3522a15b6 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -2,3 +2,7 @@ allow-unwrap-in-tests = true
 allow-expect-in-tests = true
 allow-panic-in-tests = true
 allow-indexing-slicing-in-tests = true
+disallowed-types = [
+    { path = "egui::ComboBox", reason = "use craft_ui::ComboBox: egui's combo box menu can't grow back while open (egui#5225)" },
+]
+cognitive-complexity-threshold = 30
diff --git a/contributors/people.toml b/contributors/people.toml
index 1012a37bd..95e7e2e93 100644
--- a/contributors/people.toml
+++ b/contributors/people.toml
@@ -1,13 +1,10 @@
-# Contributor names for the About window (craftrules standards/contributors.md).
+# Contributor names for the About window.
 #
 # Everyone who contributes is credited by GitHub username automatically. Anything more is up to
 # you: add YOUR OWN entry below, in your own PR (commit it yourself). Never add someone else; a
 # maintainer may add a person only when that person asked, recording where in consent_source.
 #
-# Easiest: python3 ../../craftrules/scripts/contributors.py --add-me . \
-#            [--real-name "Ada Lovelace"] [--display-name "Ada"] [--sync-github-name]
-#
-# Or copy this block, replacing your-github-username (every field is optional):
+# Copy this block, replacing your-github-username (every field is optional):
 #
 #   [people.your-github-username]
 #   real_name = "Your Name"        # shown when the viewer picks "Real name"
@@ -17,11 +14,19 @@
 # To remove your names, delete your entry (or set fields empty) in a PR. The next
 # contributors.py run, and the next build, drop them.
 
+[people.Krueels]
+sync_github_name = true
+
 [people.echelon]
 real_name = "Brandon Thomas"
 display_name = "Brandon Thomas"
 sync_github_name = false
 
+[people.lewandowskit]
+real_name = "Tomasz Lewandowski"
+display_name = "Tomasz Lewandowski"
+sync_github_name = false
+
 [people.switch87]
 real_name = "Gert Pellin"
 display_name = "Gert Pellin"
@@ -98,3 +103,27 @@ sync_github_name = false
 
 [people.ki2pixel]
 display_name = "ki2pixel"
+
+[people.becauseno7]
+real_name = "Shuvra Basak"
+display_name = "Shuvra Basak"
+sync_github_name = false
+
+[people.ashokram-si]
+real_name = "Ashok Ram"
+
+[people.dylanmtaylor]
+sync_github_name = true
+
+[people.adikshan11]
+real_name = "Adithya Shankaran"
+sync_github_name = true
+
+[people.marshiyar]
+real_name = "Arshiya Rahgozar"
+display_name = "Arshiya"
+sync_github_name = false
+
+[people.JonRC]
+real_name = "Jonathan Cardoso"
+display_name = "Jonathan Cardoso"
diff --git a/crates/automation/Cargo.toml b/crates/automation/Cargo.toml
index b14b16321..916cc3501 100644
--- a/crates/automation/Cargo.toml
+++ b/crates/automation/Cargo.toml
@@ -14,6 +14,7 @@ effectcraft-engine = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 image = { workspace = true }
+effectcraft-model = { workspace = true }
 
 [dev-dependencies]
 effectcraft-script = { workspace = true }
diff --git a/crates/automation/src/backend.rs b/crates/automation/src/backend.rs
index c3947c876..69f75df2e 100644
--- a/crates/automation/src/backend.rs
+++ b/crates/automation/src/backend.rs
@@ -4,7 +4,7 @@ use effectcraft_engine::Session;
 use effectcraft_engine::time::Tick;
 use serde_json::{Value, json};
 
-use crate::confine::Confinement;
+use crate::confine::{ConfinedFootage, ConfinedServices, Confinement, Lookup};
 use crate::{BridgeClient, Error, Result, base64, encode_png, recompress_png};
 
 pub struct Backend {
@@ -39,8 +39,14 @@ impl Backend {
         Ok(Backend { target: Target::Bridge(BridgeClient::new(addr)?), confinement: None })
     }
 
-    /// Confine the files the commands run here may read and write ([`Confinement`]).
+    /// Confine the files the commands run here may read and write ([`Confinement`]). In-process,
+    /// the session's own footage and file reads are confined too, so a project from a read root
+    /// can't show footage from outside it.
     pub fn confine(&mut self, confinement: Confinement) {
+        if let Target::Headless(s) = &mut self.target {
+            s.footage = std::sync::Arc::new(ConfinedFootage::new(s.footage.clone(), confinement.clone()));
+            s.services = std::sync::Arc::new(ConfinedServices::new(s.services.clone(), confinement.clone()));
+        }
         self.confinement = Some(confinement);
     }
 
@@ -63,12 +69,11 @@ impl Backend {
     pub fn exec(&mut self, id: &str, params: Value) -> Result<Value> {
         let params = if params.is_null() { json!({}) } else { params };
         if let Some(c) = self.confinement.clone() {
-            let lookup = match c.check_command(id, &params)? {
-                Some(crate::confine::Lookup::ProjectFile) => Some((crate::confine::Lookup::ProjectFile, self.run("project.summary", json!({}))?)),
-                Some(crate::confine::Lookup::RenderOutputs) => Some((crate::confine::Lookup::RenderOutputs, self.run("renderQueue.list", json!({}))?)),
-                None => None,
-            };
-            if let Some((lookup, found)) = lookup {
+            for lookup in c.check_command(id, &params)? {
+                let found = match lookup {
+                    Lookup::ProjectFile | Lookup::QueueDefault => self.run("project.summary", json!({}))?,
+                    Lookup::RenderOutputs => self.run("renderQueue.list", json!({}))?,
+                };
                 c.check_lookup(&lookup, &found)?;
             }
         }
@@ -86,6 +91,18 @@ impl Backend {
         }
     }
 
+    /// Query whether the current project protects `path`. This is an advisory snapshot, not a
+    /// reservation: use [`Self::render_to_file`] to validate and write in the owning session.
+    /// Relative paths are resolved against this process's folder, because the app has its own.
+    pub fn check_output(&mut self, path: &str) -> Result<()> {
+        let absolute = std::path::absolute(path).map_err(|e| Error::BadArgs(format!("cannot resolve {path}: {e}")))?;
+        let found = self.exec("file.checkOutput", json!({"path": absolute.to_string_lossy()}))?;
+        match found.get("blocked").and_then(Value::as_bool) {
+            Some(false) => Ok(()),
+            _ => Err(Error::BadArgs(found.get("reason").and_then(Value::as_str).unwrap_or("this file is one the project reads").to_string())),
+        }
+    }
+
     /// Call a raw control-channel method (bridge only).
     pub fn control(&mut self, method: &str, params: Value) -> Result<Value> {
         match &mut self.target {
@@ -103,16 +120,40 @@ impl Backend {
     /// [`Backend::render`]; `transparent` keeps the frame's alpha instead of compositing it over
     /// the comp's background colour.
     pub fn render_with(&mut self, comp: Option<&Value>, time: Option<f64>, max_side: u32, transparent: bool) -> Result<Frame> {
+        self.render_output(comp, time, max_side, transparent, None)
+    }
+
+    /// Render and save in the owning session. In bridge mode, checking and writing are one
+    /// desktop operation, so another command cannot make the destination protected in between.
+    pub fn render_to_file(&mut self, comp: Option<&Value>, time: Option<f64>, max_side: u32, transparent: bool, path: &str) -> Result<Frame> {
+        if let Some(confinement) = self.confinement() {
+            confinement.check(path, crate::confine::Access::Write)?;
+        }
+        let absolute = std::path::absolute(path).map_err(|e| Error::BadArgs(format!("cannot resolve {path}: {e}")))?;
+        self.render_output(comp, time, max_side, transparent, Some(&absolute.to_string_lossy()))
+    }
+
+    fn render_output(&mut self, comp: Option<&Value>, time: Option<f64>, max_side: u32, transparent: bool, path: Option<&str>) -> Result<Frame> {
         match &mut self.target {
             Target::Headless(s) => {
+                if let Some(path) = path {
+                    s.refuse_export(path)?;
+                }
                 let cid = s.resolve_comp(comp).map_err(|_| no_comp(comp))?;
                 let t = time.map(Tick::from_seconds_f64).unwrap_or_else(|| s.time());
                 let (w, h, rgba) = s.render_rgba8_alpha(cid, t, max_side, transparent)?;
                 let png = encode_png(w, h, rgba, max_side)?;
+                if let Some(path) = path {
+                    s.write_output(path, &png)?;
+                }
                 Ok(Frame { png, comp: json!(cid.0), time: t.seconds(), width: w, height: h })
             }
             Target::Bridge(b) => {
                 let mut p = json!({"max_side": max_side, "base64": true});
+                if let Some(path) = path {
+                    p["path"] = json!(path);
+                    p["write"] = json!(true);
+                }
                 if transparent {
                     p["transparent"] = json!(true);
                 }
@@ -123,6 +164,11 @@ impl Backend {
                     p["comp"] = c.clone();
                 }
                 let r = b.call("render.frame", p)?;
+                if let Some(path) = path
+                    && r.get("path").and_then(Value::as_str) != Some(path)
+                {
+                    return Err(Error::App("render.frame did not confirm the saved path; update the connected app before saving frames".into()));
+                }
                 let data = r.get("png").and_then(Value::as_str).ok_or_else(|| Error::App("render.frame returned no `png`".into()))?;
                 let raw = base64::decode(data).ok_or_else(|| Error::App("render.frame: bad base64".into()))?;
                 let (png, width, height) = recompress_png(&raw, max_side)?;
diff --git a/crates/automation/src/confine.rs b/crates/automation/src/confine.rs
index f396b3da0..5f0a7a51a 100644
--- a/crates/automation/src/confine.rs
+++ b/crates/automation/src/confine.rs
@@ -6,11 +6,23 @@
 //! `engine.batch`) is checked before it runs: its file parameters must be absolute paths inside
 //! the roots (symbolic links resolved, no `..`), any other absolute path in its parameters too,
 //! and commands that write to a file they are not given (Save, Increment and Save, rendering the
-//! Render Queue) are checked against where they would write. Commands that run code or open
-//! other applications (scripts, Execute File, Reveal in Finder…) are refused while confined.
+//! Render Queue) are checked against where they would write. Queueing a render without naming
+//! its output needs a saved project, because the default output of an unsaved one is the home
+//! folder. In a headless session the footage and other files a project or an imported file names
+//! are read only inside the roots ([`ConfinedFootage`], [`ConfinedServices`]). Commands that run
+//! code or open other applications (scripts, ScriptUI panels and the events that reach them,
+//! Execute File, Reveal in Finder…) are refused while confined, as is granting scripts the file
+//! and network access the user withheld.
 
 use std::path::{Component, Path, PathBuf};
+use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
 
+use effectcraft_engine::Services;
+use effectcraft_engine::project::{Footage, ItemId};
+use effectcraft_engine::raster::{AuxChannels, Image};
+use effectcraft_engine::render::{FloatCurve, FootageSource};
+use effectcraft_engine::time::Tick;
 use serde_json::Value;
 
 use crate::{Error, Result};
@@ -28,13 +40,21 @@ pub struct Confinement {
     write: Vec<PathBuf>,
 }
 
-/// Commands that run code, act outside the project or open other applications.
+/// Commands that run code, act outside the project or open other applications, besides the
+/// commands that run scripts ([`effectcraft_engine::commands::scripts::RUNS_SCRIPTS`]).
 const REFUSED: &[&str] = &[
-    "script.run",
-    "file.runScript",
     "file.installScript",
     "file.installScriptUIPanel",
     "file.uninstallScript",
+    // A ScriptUI panel's script runs when the panel opens, when an event reaches one of its
+    // controls, and when one of its `app.scheduleTask` tasks comes due.
+    "window.scriptPanel",
+    "window.restoreScriptPanels",
+    "script.runTasks",
+    "scriptui.click",
+    "scriptui.set",
+    "scriptui.mouse",
+    "scriptui.close",
     "file.executeFile",
     "file.revealInFinder",
     "layer.openSource",
@@ -64,15 +84,38 @@ const READS: &[(&str, &[&str])] = &[
     ("effect.plugins.load", &["path", "folder"]),
     ("mediaBrowser.go", &["path"]),
     ("mediaBrowser.addFavorite", &["path"]),
+    // #1243: these read the files they are given but were missing, so a relative path went
+    // unchecked.
+    ("essential.templateInfo", &["path"]),
+    ("file.importProject", &["path"]),
+    ("file.watchFolder.poll", &["folder"]),
+    ("footage.relink", &["path"]),
+    ("layer.newModel", &["path"]),
+    ("mediaBrowser.fileInfo", &["path"]),
+    ("mediaBrowser.list", &["path"]),
+    ("mediaBrowser.import", &["paths"]),
+    ("mediaBrowser.removeFavorite", &["path"]),
+    ("face.model.install", &["path"]),
+    ("roto.model.install", &["path"]),
+    // Looks up what the file at `path` is (writable roots are readable too).
+    ("file.checkOutput", &["path"]),
+    // Reads the template at `path`; what it writes is in `MIXED_WRITES`.
+    ("templates.create", &["path"]),
 ];
 
+/// Commands that read some parameters (listed in [`READS`]) and write others.
+const MIXED_WRITES: &[(&str, &[&str])] = &[("templates.create", &["projectPath", "footageDir"])];
+
 /// Commands that write files named by these parameters.
 const WRITES: &[(&str, &[&str])] = &[
+    ("camera.exportBlender", &["path"]),
     ("file.save", &["path"]),
     ("file.saveAs", &["path"]),
     ("file.saveCopy", &["path"]),
     ("file.saveCopyAsXml", &["path"]),
     ("file.collectFiles", &["folder"]),
+    // This query checks a proposed write destination, so it follows write confinement.
+    ("file.checkOutput", &["path"]),
     ("file.exportLottie", &["path"]),
     ("comp.saveFrameAs", &["path"]),
     ("comp.saveFrameAsPsd", &["path"]),
@@ -84,11 +127,17 @@ const WRITES: &[(&str, &[&str])] = &[
     ("essential.exportTemplate", &["path"]),
     ("shortcuts.export", &["path"]),
     ("renderQueue.add", &["output", "path"]),
+    ("file.exportTimeline", &["path"]),
+    // `path` / `output` may also be a file-name template, as for render.preRender.
+    ("file.createProxy", &["path", "output"]),
 ];
 
 /// Commands that write where they are not told: the project's file, the Render Queue's outputs.
 const IMPLICIT_WRITES: &[&str] = &["file.save", "file.incrementAndSave", "renderQueue.render", "render.preRender"];
 
+/// Commands that queue a render, whose output defaults to the project's folder when not given.
+const QUEUES_AN_OUTPUT: &[&str] = &["renderQueue.add", "render.preRender", "file.createProxy"];
+
 /// What must be looked up before an implicitly writing command may run.
 #[derive(Debug, PartialEq, Eq)]
 pub enum Lookup {
@@ -96,6 +145,10 @@ pub enum Lookup {
     ProjectFile,
     /// Every output of the queued Render Queue items (`renderQueue.list`).
     RenderOutputs,
+    /// Whether the open project has a file (`project.summary` → `path`): a render queued without
+    /// `output` (Render Queue, Pre-render, Create Proxy) writes beside it, or to the home folder
+    /// before the first save.
+    QueueDefault,
 }
 
 impl Confinement {
@@ -134,24 +187,34 @@ impl Confinement {
 
     /// Check engine command `id` with `params` before it runs. Returns what must still be looked
     /// up and passed to [`Confinement::check_lookup`] for commands that write implicitly.
-    pub fn check_command(&self, id: &str, params: &Value) -> Result<Option<Lookup>> {
-        if REFUSED.contains(&id) {
+    pub fn check_command(&self, id: &str, params: &Value) -> Result<Vec<Lookup>> {
+        if REFUSED.contains(&id) || effectcraft_engine::commands::scripts::RUNS_SCRIPTS.contains(&id) {
             return Err(Error::BadArgs(format!("`{id}` is not available while file access is confined (--automation-read-root/--automation-write-root)")));
         }
+        // Scripts can't grant themselves the access the user withheld
+        // (`effectcraft_engine::prefs::Scripting::same_permissions`), and neither may a confined
+        // agent: `prefs.set` saves the settings file, so a script run long after this session
+        // would still have it. (`prefs.reset` only puts the defaults back, which grant nothing.)
+        if id == "prefs.set" && prefs_keys(params).iter().any(|k| is_scripting_pref(k)) {
+            return Err(Error::BadArgs(
+                "`prefs.set`: the Scripting settings decide what a script may do, so they can't be changed while file access is confined".into(),
+            ));
+        }
         if id == "engine.batch" {
             for step in params.get("steps").and_then(Value::as_array).into_iter().flatten() {
                 let Some(inner) = step.get("command").or_else(|| step.get("id")).and_then(Value::as_str) else { continue };
                 let inner_params = step.get("params").cloned().unwrap_or(Value::Null);
                 let named = keys_of(READS, inner).or_else(|| keys_of(WRITES, inner)).unwrap_or(&[]);
+                let mixed = keys_of(MIXED_WRITES, inner).unwrap_or(&[]);
                 // A step's `$N` reference is resolved only as the batch runs: never for a file.
-                if named.iter().filter_map(|k| inner_params.get(*k)).any(has_reference) {
+                if named.iter().chain(mixed).filter_map(|k| inner_params.get(*k)).any(has_reference) {
                     return Err(Error::BadArgs(format!("`{inner}` in a batch: file paths can't be `$N` references while file access is confined")));
                 }
-                if self.check_command(inner, &inner_params)?.is_some() {
+                if !self.check_command(inner, &inner_params)?.is_empty() {
                     return Err(Error::BadArgs(format!("`{inner}` writes to its project's or queue's files: run it on its own while file access is confined")));
                 }
             }
-            return Ok(None);
+            return Ok(vec![]);
         }
         let (named, access) = match (keys_of(WRITES, id), keys_of(READS, id)) {
             (Some(k), _) => (k, Access::Write),
@@ -160,6 +223,10 @@ impl Confinement {
             (None, None) => (&[][..], Access::Read),
         };
         let mut given = false;
+        // Whether one of them is a file: not a Render Queue template, whose own output is relative
+        // and resolved like one the agent never gave, and not an array, which the commands that
+        // take a single output read as nothing at all.
+        let mut gave_a_file = false;
         for key in named {
             let Some(v) = params.get(*key).filter(|v| !v.is_null()) else { continue };
             given = true;
@@ -170,17 +237,27 @@ impl Confinement {
             for p in paths {
                 // A Render Queue output may name a template instead of a file.
                 match p.as_str() {
-                    Some(s) if id == "render.preRender" && !looks_like_path(s) => {}
+                    Some(s) if matches!(id, "render.preRender" | "file.createProxy") && !looks_like_path(s) => {}
                     Some(s) => {
+                        gave_a_file |= v.is_string();
                         self.check(s, access)?;
                     }
                     None => return Err(Error::BadArgs(format!("`{id}`: `{key}` must be a path"))),
                 }
             }
         }
+        // Parameters of a reading command that it writes to.
+        let mixed = keys_of(MIXED_WRITES, id).unwrap_or(&[]);
+        for key in mixed {
+            if let Some(p) = params.get(*key).filter(|v| !v.is_null()) {
+                let p = p.as_str().ok_or_else(|| Error::BadArgs(format!("`{id}`: `{key}` must be a path")))?;
+                self.check(p, Access::Write)?;
+            }
+        }
         // Any other absolute path the command is given.
+        let named: Vec<&str> = named.iter().chain(mixed).copied().collect();
         let mut other = vec![];
-        absolute_strings(params, named, &mut other);
+        absolute_strings(params, &named, &mut other);
         for s in other {
             self.check(&s, access)?;
         }
@@ -188,10 +265,19 @@ impl Confinement {
         if matches!(id, "file.openRecent" | "file.importRecent" | "anim.applyRecentPreset") && !given {
             return Err(Error::BadArgs(format!("`{id}`: give `path` while file access is confined")));
         }
-        if IMPLICIT_WRITES.contains(&id) && !(given && id == "file.save") {
-            return Ok(Some(if id == "file.save" || id == "file.incrementAndSave" { Lookup::ProjectFile } else { Lookup::RenderOutputs }));
+        let mut lookups = vec![];
+        // An output the agent did not name is derived from where the project sits: the Default
+        // Output Folder preference when that is set, beside the project file otherwise — and the
+        // home folder when the project has never been saved, outside every root (#2479). Only
+        // that last case is certainly outside, and reading the preference here would duplicate
+        // the engine's precedence, so an unsaved project is told to name its output instead.
+        if QUEUES_AN_OUTPUT.contains(&id) && !gave_a_file {
+            lookups.push(Lookup::QueueDefault);
         }
-        Ok(None)
+        if IMPLICIT_WRITES.contains(&id) && !(given && id == "file.save") {
+            lookups.push(if id == "file.save" || id == "file.incrementAndSave" { Lookup::ProjectFile } else { Lookup::RenderOutputs });
+        }
+        Ok(lookups)
     }
 
     /// Check what a [`Lookup`] found: `project.summary` or `renderQueue.list`'s result.
@@ -202,6 +288,13 @@ impl Confinement {
                 Some(p) => self.check(p, Access::Write).map(drop),
                 None => Err(Error::BadArgs("the project has no file yet: give `path` (Save As) inside an automation write root".into())),
             },
+            // A saved project's default output sits beside it, and rendering checks it then.
+            Lookup::QueueDefault => match found.get("path").and_then(Value::as_str) {
+                Some(_) => Ok(()),
+                None => Err(Error::BadArgs(
+                    "the project has no file yet, so the default output would go to the home folder: give `output` inside an automation write root, or save the project inside one first".into(),
+                )),
+            },
             Lookup::RenderOutputs => {
                 let items = found.get("items").or(Some(found)).and_then(Value::as_array).cloned().unwrap_or_default();
                 for it in items.iter().filter(|it| it.get("render").and_then(Value::as_bool) != Some(false)) {
@@ -218,6 +311,142 @@ impl Confinement {
     }
 }
 
+/// The session's footage, read only inside the read roots (#2131 F-11, "Indirect reads"). The
+/// commands an agent runs are checked by the paths they are given, but a project opened or
+/// imported from a read root names its own footage, which is read when it renders: a file
+/// outside the roots shows as missing footage instead.
+pub struct ConfinedFootage {
+    inner: Arc<dyn FootageSource>,
+    confinement: Confinement,
+}
+
+impl ConfinedFootage {
+    pub fn new(inner: Arc<dyn FootageSource>, confinement: Confinement) -> Self {
+        Self { inner, confinement }
+    }
+
+    /// Whether every file of `f` (its file and each frame of a sequence) is inside the roots.
+    /// Checked on every read, not remembered: a symbolic link inside a root can be pointed
+    /// elsewhere after it was first read.
+    fn inside(&self, f: &Footage) -> bool {
+        std::iter::once(&f.path).chain(&f.sequence).filter(|p| !p.is_empty()).all(|p| self.confinement.check(p, Access::Read).is_ok())
+    }
+}
+
+impl FootageSource for ConfinedFootage {
+    fn frame(&self, item: ItemId, footage: &Footage, t: Tick) -> Option<Arc<Image>> {
+        self.inside(footage).then(|| self.inner.frame(item, footage, t)).flatten()
+    }
+    fn frame_at_size(&self, item: ItemId, footage: &Footage, t: Tick, width: u32, height: u32) -> Option<Arc<Image>> {
+        self.inside(footage).then(|| self.inner.frame_at_size(item, footage, t, width, height)).flatten()
+    }
+    fn frame_with(&self, item: ItemId, footage: &Footage, t: Tick, size: Option<(u32, u32)>, float: FloatCurve) -> Option<Arc<Image>> {
+        self.inside(footage).then(|| self.inner.frame_with(item, footage, t, size, float)).flatten()
+    }
+    fn audio(&self, item: ItemId, footage: &Footage, t: Tick, frames: usize, rate: u32) -> Option<Vec<f32>> {
+        self.inside(footage).then(|| self.inner.audio(item, footage, t, frames, rate)).flatten()
+    }
+    fn aux(&self, item: ItemId, footage: &Footage, t: Tick) -> Option<Arc<AuxChannels>> {
+        self.inside(footage).then(|| self.inner.aux(item, footage, t)).flatten()
+    }
+    fn model(&self, item: ItemId, footage: &Footage) -> Option<Arc<effectcraft_model::Model>> {
+        self.inside(footage).then(|| self.inner.model(item, footage)).flatten()
+    }
+    fn vector_frame(&self, item: ItemId, footage: &Footage, scale: f64) -> Option<Arc<Image>> {
+        self.inside(footage).then(|| self.inner.vector_frame(item, footage, scale)).flatten()
+    }
+    /// Says why footage outside the roots shows nothing, so the agent can act on it.
+    fn problem(&self, footage: &Footage) -> Option<String> {
+        if !self.inside(footage) {
+            return Some(format!("{} is outside the automation read roots, so it is not read", footage.path));
+        }
+        self.inner.problem(footage)
+    }
+    fn set_cache_budget(&self, bytes: usize) {
+        self.inner.set_cache_budget(bytes)
+    }
+    fn purge(&self) {
+        self.inner.purge()
+    }
+    fn forget(&self, path: &str) {
+        self.inner.forget(path)
+    }
+    fn set_conform_folder(&self, folder: Option<PathBuf>) {
+        self.inner.set_conform_folder(folder)
+    }
+    fn cache_budget(&self) -> Option<usize> {
+        self.inner.cache_budget()
+    }
+    fn cancellable(&self, cancel: &Arc<AtomicBool>, f: &mut dyn FnMut()) {
+        self.inner.cancellable(cancel, f)
+    }
+    fn called_off(&self) -> bool {
+        self.inner.called_off()
+    }
+}
+
+/// The session's file reads, only inside the read roots: what a project or an imported file
+/// pulls in by itself (an SVG's or Lottie's images, a timeline's media) is checked like a path
+/// the agent gives. Writes are left to the command checks.
+pub struct ConfinedServices {
+    inner: Arc<dyn Services>,
+    confinement: Confinement,
+}
+
+impl ConfinedServices {
+    pub fn new(inner: Arc<dyn Services>, confinement: Confinement) -> Self {
+        Self { inner, confinement }
+    }
+
+    fn inside(&self, path: &str) -> bool {
+        self.confinement.check(path, Access::Read).is_ok()
+    }
+}
+
+impl Services for ConfinedServices {
+    fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>> {
+        self.confinement.check(path, Access::Read).map_err(|e| std::io::Error::new(std::io::ErrorKind::PermissionDenied, e.to_string()))?;
+        self.inner.read_file(path)
+    }
+    fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
+        self.inner.write_file(path, data)
+    }
+    fn exists(&self, path: &str) -> bool {
+        self.inside(path) && self.inner.exists(path)
+    }
+    fn stamp(&self, path: &str) -> Option<(u64, u128)> {
+        if self.inside(path) { self.inner.stamp(path) } else { None }
+    }
+    fn store_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
+        self.inner.store_file(path, data)
+    }
+    fn list_dir(&self, dir: &str) -> Vec<String> {
+        if self.inside(dir) { self.inner.list_dir(dir) } else { vec![] }
+    }
+    fn is_dir(&self, path: &str) -> bool {
+        self.inside(path) && self.inner.is_dir(path)
+    }
+    fn full_path(&self, path: &str) -> Option<String> {
+        self.inner.full_path(path)
+    }
+}
+
+/// Whether a `prefs.set` key reaches the Scripting page. `Prefs::set` turns the key into a JSON
+/// pointer (`key.replace('.', "/")`), so `scripting/allowScriptsWriteFiles` resolves as well as
+/// the dotted spelling, and the page on its own replaces every setting on it.
+fn is_scripting_pref(key: &str) -> bool {
+    key.split(['.', '/']).next().is_some_and(|page| page.eq_ignore_ascii_case("scripting"))
+}
+
+/// The settings `prefs.set` is given: `key`, and the keys of `values`.
+fn prefs_keys(params: &Value) -> Vec<&str> {
+    let mut keys: Vec<&str> = params.get("key").and_then(Value::as_str).into_iter().collect();
+    if let Some(Value::Object(m)) = params.get("values") {
+        keys.extend(m.keys().map(String::as_str));
+    }
+    keys
+}
+
 fn keys_of(table: &[(&str, &'static [&'static str])], id: &str) -> Option<&'static [&'static str]> {
     table.iter().find(|(c, _)| *c == id).map(|(_, k)| *k)
 }
@@ -274,3 +503,119 @@ fn resolve(p: &Path) -> Option<PathBuf> {
         at = at.parent()?;
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Commands whose parameters are named like files but aren't: property paths
+    /// (`path|prop`), project folders, layers to track or target.
+    const NOT_FILES: &[&str] = &[
+        "camera.createFromSolve",
+        "edit.label",
+        "edit.pasteReversedKeyframes",
+        "effect.editDropdown",
+        "essential.addProperty",
+        "essential.canAdd",
+        "essential.linkProperty",
+        "essential.unlinkProperty",
+        "keys.paste",
+        "keys.set",
+        "keys.setEase",
+        "keys.setSpatialTangents",
+        "paths.nullsFollowPoints",
+        "paths.pointsFollowNulls",
+        "paths.tracePath",
+        "project.move",
+        "prop.addKey",
+        "prop.convertExpressionToKeyframes",
+        "prop.deselect",
+        "prop.editGradient",
+        "prop.get",
+        "prop.pickWhip",
+        "prop.reset",
+        "prop.select",
+        "prop.set",
+        "prop.setExpression",
+        "prop.toggleAnimation",
+        "prop.toggleKey",
+        "track.new",
+        "track.property",
+        "track.setTarget",
+    ];
+
+    /// Every engine command with a parameter named like a file is classified, so a new one
+    /// can't silently skip confinement (#1243): it reads or writes the files it is given, is
+    /// refused, writes where it isn't told (checked by a lookup), sets Render Queue outputs
+    /// (checked when the queue renders), or is listed in `NOT_FILES`.
+    #[test]
+    fn every_command_with_file_parameters_is_classified() {
+        const FILE_KEYS: &[&str] =
+            &["path", "paths", "folder", "file", "files", "dir", "directory", "output", "outputs", "source", "target", "projectPath", "footageDir"];
+        let mut missing = vec![];
+        for spec in effectcraft_engine::command_specs() {
+            let Some(params) = effectcraft_engine::commands::accepted_params(spec.params) else { continue };
+            let id = spec.id;
+            let classified = keys_of(READS, id).is_some()
+                || keys_of(WRITES, id).is_some()
+                || REFUSED.contains(&id)
+                || effectcraft_engine::commands::scripts::RUNS_SCRIPTS.contains(&id)
+                || IMPLICIT_WRITES.contains(&id)
+                || id.starts_with("renderQueue.")
+                || id == "render.addOutputModule"
+                || NOT_FILES.contains(&id);
+            if params.iter().any(|p| FILE_KEYS.contains(&p.as_str())) && !classified {
+                missing.push(format!("{id} {}", spec.params));
+            }
+        }
+        assert!(missing.is_empty(), "add these to READS / WRITES / REFUSED or NOT_FILES:\n{}", missing.join("\n"));
+        // And every listed command exists.
+        for id in READS.iter().chain(WRITES).chain(MIXED_WRITES).map(|(c, _)| *c).chain(NOT_FILES.iter().copied()) {
+            assert!(effectcraft_engine::command_specs().iter().any(|s| s.id == id), "{id} is not a command");
+        }
+    }
+
+    #[test]
+    fn relative_and_outside_paths_of_newly_listed_commands_are_refused() {
+        let base = std::env::temp_dir().join(format!("ec-confine-1243-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&base);
+        let (read, write, outside) = (base.join("in"), base.join("out"), base.join("elsewhere"));
+        for d in [&read, &write, &outside] {
+            std::fs::create_dir_all(d).unwrap();
+        }
+        let c = Confinement::new(std::slice::from_ref(&read), std::slice::from_ref(&write)).unwrap();
+        let p = |d: &std::path::Path, f: &str| d.join(f).to_string_lossy().into_owned();
+        let up = format!("{}/../elsewhere/t.ectemplate", read.display());
+        for (id, key) in [
+            ("essential.templateInfo", "path"),
+            ("file.importProject", "path"),
+            ("footage.relink", "path"),
+            ("layer.newModel", "path"),
+            ("mediaBrowser.fileInfo", "path"),
+            ("mediaBrowser.list", "path"),
+            ("face.model.install", "path"),
+            ("templates.create", "path"),
+        ] {
+            for bad in ["t.ectemplate".to_string(), "../elsewhere/t.ectemplate".to_string(), up.clone(), p(&outside, "t.ectemplate")] {
+                assert!(c.check_command(id, &serde_json::json!({key: bad})).is_err(), "{id} {key}={bad}");
+            }
+            assert!(c.check_command(id, &serde_json::json!({key: p(&read, "t.ectemplate")})).is_ok(), "{id} in a read root");
+        }
+        // Batched too.
+        let steps = serde_json::json!({"steps": [{"command": "essential.templateInfo", "params": {"path": "t.ectemplate"}}]});
+        assert!(c.check_command("engine.batch", &steps).is_err());
+        // Writes: into a write root only.
+        for id in ["file.exportTimeline", "file.checkOutput"] {
+            for bad in ["cut.xml".to_string(), p(&read, "cut.xml"), p(&outside, "cut.xml")] {
+                assert!(c.check_command(id, &serde_json::json!({"path": bad})).is_err(), "{id} {bad}");
+            }
+            assert!(c.check_command(id, &serde_json::json!({"path": p(&write, "cut.xml")})).is_ok());
+        }
+        let create = |project: String| serde_json::json!({"path": p(&read, "t.ectemplate"), "projectPath": project});
+        assert!(c.check_command("templates.create", &create(p(&read, "new.ecproj"))).is_err(), "templates.create writes projectPath");
+        assert!(c.check_command("templates.create", &create(p(&write, "new.ecproj"))).is_ok());
+        assert!(c.check_command("file.createProxy", &serde_json::json!({"output": "[compName]_proxy"})).is_ok(), "a template name");
+        assert!(c.check_command("file.createProxy", &serde_json::json!({"output": p(&outside, "proxy.mov")})).is_err());
+        let _ = std::fs::remove_dir_all(&base);
+    }
+}
diff --git a/crates/automation/src/tests.rs b/crates/automation/src/tests.rs
index 6e622b377..bb09e244b 100644
--- a/crates/automation/src/tests.rs
+++ b/crates/automation/src/tests.rs
@@ -57,6 +57,50 @@ fn property_group_error_points_to_layer_inspection() {
     assert!(call_json(&mut s, "get_property", json!({"layer": l, "path": "geometryOptions/extrusionDepth"}))["value"].is_number());
 }
 
+/// Enum properties list their values and labels, so a client can set one without guessing (#2085).
+#[test]
+fn enum_properties_list_their_options() {
+    let mut s = server();
+    call_json(&mut s, "execute_command", json!({"command": "comp.new", "params": {"name": "probe"}}));
+    call_json(&mut s, "execute_command", json!({"command": "layer.newText", "params": {"name": "T", "text": "Hello"}}));
+    call_json(&mut s, "execute_command", json!({"command": "layer.addTextAnimator", "params": {"layer": "T", "properties": ["opacity"], "name": "A"}}));
+    let path = "text/animators/animator/selectors/rangeSelector/advanced/shape";
+    let shapes = ["Square", "Ramp Up", "Ramp Down", "Triangle", "Round", "Smooth"];
+    let expected = json!(shapes.iter().enumerate().map(|(value, label)| json!({"value": value, "label": label})).collect::<Vec<_>>());
+
+    let p = call_json(&mut s, "get_property", json!({"layer": "T", "path": path}));
+    assert_eq!(p["type"], "enum");
+    assert_eq!(p["options"], expected, "{p}");
+    let opacity = call_json(&mut s, "get_property", json!({"layer": "T", "path": "transform/opacity"}));
+    assert!(opacity.get("options").is_none(), "{opacity}");
+
+    fn find<'a>(node: &'a Value, path: &str) -> Option<&'a Value> {
+        if node["path"] == path {
+            return Some(node);
+        }
+        node["children"].as_array()?.iter().find_map(|c| find(c, path))
+    }
+    let tree = call_json(&mut s, "get_layer", json!({"layer": "T"}));
+    let node = find(&tree["properties"], path).unwrap_or_else(|| panic!("{tree}"));
+    assert_eq!(node["options"], expected);
+    assert!(find(&tree["properties"], "transform/opacity").unwrap()["options"].is_null());
+
+    let flat = call_json(&mut s, "get_layer", json!({"layer": "T", "flat": true}));
+    let props = flat["properties"].as_array().unwrap();
+    assert_eq!(props.iter().find(|p| p["path"] == path).unwrap()["options"], expected);
+    assert!(props.iter().find(|p| p["path"] == "transform/opacity").unwrap().get("options").is_none());
+
+    // Path Options ▸ Path offers None and the layer's masks, as the Timeline does.
+    for _ in 0..2 {
+        call_json(&mut s, "execute_command", json!({"command": "mask.new", "params": {"layer": "T", "vertices": [[0, 0], [40, 0], [40, 40]], "closed": true}}));
+    }
+    let masks = json!([{"value": 0, "label": "None"}, {"value": 1, "label": "Mask 1"}, {"value": 2, "label": "Mask 2"}]);
+    let p = call_json(&mut s, "get_property", json!({"layer": "T", "path": "text/pathOptions/path"}));
+    assert_eq!(p["options"], masks, "{p}");
+    let tree = call_json(&mut s, "get_layer", json!({"layer": "T"}));
+    assert_eq!(find(&tree["properties"], "text/pathOptions/path").unwrap_or_else(|| panic!("{tree}"))["options"], masks);
+}
+
 #[test]
 fn initialize_and_list_tools() {
     let mut s = server();
@@ -442,6 +486,21 @@ fn autosave_flushes_on_read_errors_and_broken_output() {
     std::fs::remove_dir_all(dir).unwrap();
 }
 
+fn fake_render_frame(session: &Session, params: &Value) -> Value {
+    let png = crate::encode_png(4, 2, vec![255; 32], 0).unwrap();
+    if params["write"] == true {
+        let Some(path) = params["path"].as_str() else { return json!({"ok": false, "error": "missing output path"}) };
+        if let Err(error) = session.write_output(path, &png) {
+            return json!({"ok": false, "error": error.to_string()});
+        }
+    }
+    let mut result = json!({"comp": 1, "time": 0.5, "width": 4, "height": 2, "png": base64::encode(&png)});
+    if params["write"] == true {
+        result["path"] = params["path"].clone();
+    }
+    json!({"ok": true, "result": result})
+}
+
 /// A fake desktop control channel: answers `engine.execute` from a real session, and canned
 /// `render.frame` / `ui.screenshot` replies.
 fn fake_app() -> u16 {
@@ -459,10 +518,7 @@ fn fake_app() -> u16 {
                     Ok(v) => json!({"ok": true, "result": v}),
                     Err(e) => json!({"ok": false, "error": e.to_string()}),
                 },
-                "render.frame" => {
-                    let png = crate::encode_png(4, 2, vec![255; 32], 0).unwrap();
-                    json!({"ok": true, "result": {"comp": 1, "time": 0.5, "width": 4, "height": 2, "png": base64::encode(&png)}})
-                }
+                "render.frame" => fake_render_frame(&session, p),
                 "ui.screenshot" => {
                     let png = crate::encode_png(8, 8, vec![128; 256], 0).unwrap();
                     std::fs::write(p["path"].as_str().unwrap(), png).unwrap();
@@ -491,6 +547,8 @@ fn bridge_forwards_to_control_channel() {
 
     call_json(&mut s, "execute_command", json!({"command": "comp.new", "params": {"name": "B", "width": 64, "height": 64}}));
     assert_eq!(call_json(&mut s, "get_comp", json!({}))["name"], "B");
+    let cmds = call_json(&mut s, "list_commands", json!({"filter": "layer.newSolid", "compact": true}));
+    assert!(cmds.as_array().unwrap().contains(&json!({"id": "layer.newSolid", "label": "Solid..."})), "{cmds}");
 
     let (c, err) = call(&mut s, "render_frame", json!({}));
     assert!(!err, "{c:?}");
@@ -738,6 +796,40 @@ fn every_engine_command_is_reachable_over_mcp() {
     }
 }
 
+/// `compact: true` shrinks the listings for MCP clients' tool-result limits (#2020): commands with
+/// only `id` and `label`, effects with only `id`, `name` and `category`.
+#[test]
+fn compact_listings_keep_only_ids_and_names() {
+    let mut s = server();
+    let cmds = call_json(&mut s, "list_commands", json!({"filter": "layer.new", "compact": true}));
+    assert!(cmds.as_array().unwrap().contains(&json!({"id": "layer.newSolid", "label": "Solid..."})), "{cmds}");
+    let fx = call_json(&mut s, "list_effects", json!({"filter": "gaussian", "compact": true}));
+    assert!(fx.as_array().unwrap().contains(&json!({"id": "ec.blur.gaussian", "name": "Gaussian Blur", "category": "Blur & Sharpen"})), "{fx}");
+    // Each compact listing is the full one with the same arguments, entry for entry; `compact`
+    // wins over `schemas`.
+    let check = |s: &mut McpServer, tool: &str, args: Value, keys: &[&str]| {
+        let full = call_json(s, tool, args.clone());
+        let want: Value = full.as_array().unwrap().iter().map(|e| Value::Object(keys.iter().map(|&k| (k.to_string(), e[k].clone())).collect())).collect();
+        let mut compact = args.clone();
+        compact["compact"] = json!(true);
+        assert_eq!(call_json(s, tool, compact), want, "{tool} {args}");
+    };
+    for args in [json!({}), json!({"filter": "layer.new"}), json!({"enabled_only": true}), json!({"schemas": true})] {
+        check(&mut s, "list_commands", args.clone(), &["id", "label"]);
+        check(&mut s, "command_list", args, &["id", "label"]);
+    }
+    check(&mut s, "list_effects", json!({}), &["id", "name", "category"]);
+    check(&mut s, "list_effects", json!({"filter": "gaussian"}), &["id", "name", "category"]);
+    // `compact: false` is the default listing, byte for byte; `compact: true` is a fraction of it.
+    let text = |s: &mut McpServer, tool: &str, args: Value| call(s, tool, args).0[0]["text"].as_str().unwrap().to_string();
+    for (tool, ratio) in [("list_commands", 2), ("list_effects", 10)] {
+        let full = text(&mut s, tool, json!({}));
+        assert_eq!(text(&mut s, tool, json!({"compact": false})), full, "{tool}");
+        let compact = text(&mut s, tool, json!({"compact": true})).len();
+        assert!(compact * ratio < full.len(), "{tool}: {compact} of {} bytes", full.len());
+    }
+}
+
 #[test]
 fn high_level_tools_add_effect_and_report_state() {
     let mut s = server();
@@ -1336,6 +1428,12 @@ fn automation_roots_confine_file_access() {
         assert!(err, "{name} {args} should be refused: {c:?}");
         c[0]["text"].as_str().unwrap_or_default().to_string()
     };
+    // #2479: an unsaved project's queue item without `output` would write to the home folder.
+    call_json(&mut s, "execute_command", json!({"command": "comp.new", "params": {"name": "Unsaved", "width": 64, "height": 64}}));
+    let msg = denied(&mut s, "execute_command", json!({"command": "renderQueue.add", "params": {"comp": "Unsaved"}}));
+    assert!(msg.contains("home folder") && msg.contains("give `output`"), "{msg}");
+    call_json(&mut s, "execute_command", json!({"command": "renderQueue.add", "params": {"comp": "Unsaved", "output": p(&write, "unsaved.mp4")}}));
+    call_json(&mut s, "execute_command", json!({"command": "renderQueue.remove"}));
     // Reading: inside a read root, not outside.
     call_json(&mut s, "open_project", json!({"path": p(&read, "source.ecproj")}));
     let msg = denied(&mut s, "open_project", json!({"path": p(&outside, "free.ecproj")}));
@@ -1376,7 +1474,383 @@ fn automation_roots_confine_file_access() {
     // Scripts can read and write anything: refused.
     denied(&mut s, "run_script", json!({"code": "1 + 1"}));
     denied(&mut s, "execute_command", json!({"command": "file.runScript", "params": {"path": p(&read, "x.jsx")}}));
+    for (id, params) in [
+        ("file.runStartupScripts", json!({})),
+        ("file.runShutdownScripts", json!({})),
+        // ScriptUI panels run their script when they open.
+        ("window.scriptPanel", json!({"name": "Layer Tools.jsx"})),
+        ("window.restoreScriptPanels", json!({})),
+    ] {
+        let msg = denied(&mut s, "execute_command", json!({"command": id, "params": params}));
+        assert!(msg.contains("not available while file access is confined"), "{id}: {msg}");
+        let msg = denied(&mut s, "batch", json!({"steps": [{"command": id, "params": params}]}));
+        assert!(msg.contains("not available while file access is confined"), "{id}: {msg}");
+    }
     // Writes to the files the agent named: none outside.
     assert_eq!(std::fs::read_dir(&outside).unwrap().count(), 1, "only the unconfined save");
     let _ = std::fs::remove_dir_all(&base);
 }
+
+/// #2479: a queued output the agent didn't name is derived from where the project sits, so on a
+/// project that has never been saved it lands in the home folder, outside every automation root.
+/// Queueing it there is refused, rather than leaving an item that can never be rendered.
+#[test]
+fn automation_roots_refuse_a_queued_output_from_an_unsaved_project() {
+    use crate::confine::Confinement;
+    let base = std::env::temp_dir().join(format!("ec-mcp-default-out-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&base);
+    let write = base.join("out");
+    std::fs::create_dir_all(&write).unwrap();
+    let p = |f: &str| write.join(f).to_string_lossy().into_owned();
+    let mut s = server();
+    s.backend().confine(Confinement::new(&[], std::slice::from_ref(&write)).unwrap());
+    call_json(&mut s, "execute_command", json!({"command": "comp.new", "params": {"name": "A", "width": 64, "height": 64}}));
+    // Never saved: neither way of queueing a render may fall back to the home folder.
+    for command in ["renderQueue.add", "render.preRender", "file.createProxy"] {
+        let (c, err) = call(&mut s, "execute_command", json!({"command": command, "params": {"comp": "A"}}));
+        assert!(err, "`{command}` without an output should be refused: {c:?}");
+        let msg = c[0]["text"].as_str().unwrap_or_default();
+        assert!(msg.contains("the project has no file yet"), "`{command}`: {msg}");
+    }
+    // An array where a path goes: the engine reads a scalar, so this is no output either.
+    let (c, err) = call(&mut s, "execute_command", json!({"command": "file.createProxy", "params": {"comp": "A", "path": [p("arr.mov")]}}));
+    assert!(err, "an array where the output goes should be refused: {c:?}");
+    assert!(c[0]["text"].as_str().unwrap_or_default().contains("the project has no file yet"), "{c:?}");
+    // Naming an Output Module template instead of a file is the same: its own output is relative.
+    let (c, err) = call(&mut s, "execute_command", json!({"command": "render.preRender", "params": {"comp": "A", "output": "Lossless"}}));
+    assert!(err, "a template output should be refused too: {c:?}");
+    assert!(c[0]["text"].as_str().unwrap_or_default().contains("the project has no file yet"), "{c:?}");
+    let queue = call_json(&mut s, "execute_command", json!({"command": "renderQueue.list"}));
+    assert_eq!(queue["items"].as_array().map(Vec::len), Some(0), "nothing was queued: {queue}");
+    // Naming an output inside a write root is how it is done.
+    call_json(&mut s, "execute_command", json!({"command": "renderQueue.add", "params": {"comp": "A", "output": p("named.mp4")}}));
+    // A proxy named outside the roots is refused. Whether that reads as a write or a read is
+    // #1347's to classify, so this asserts the refusal and not its wording. The path is a sibling
+    // of the write root rather than `/elsewhere/…`, which is not absolute on Windows and would be
+    // refused for that instead.
+    let outside = base.join("elsewhere").join("proxy.mov").to_string_lossy().into_owned();
+    let (c, err) = call(&mut s, "execute_command", json!({"command": "file.createProxy", "params": {"comp": "A", "path": outside}}));
+    assert!(err, "a proxy outside the roots should be refused: {c:?}");
+    assert!(c[0]["text"].as_str().unwrap_or_default().contains("outside the automation roots"), "{c:?}");
+    // Once the project is saved there, the default output (beside it) is queued as before.
+    call_json(&mut s, "save_project", json!({"path": p("proj.ecproj")}));
+    // A name that is not a path is an Output Module template, and the output it resolves to lands
+    // beside the saved project: inside the write root, so it is allowed (#1347 relies on this).
+    call_json(&mut s, "execute_command", json!({"command": "file.createProxy", "params": {"comp": "A", "path": "ProxyTemplate"}}));
+    call_json(&mut s, "execute_command", json!({"command": "renderQueue.add", "params": {"comp": "A"}}));
+    let queue = call_json(&mut s, "execute_command", json!({"command": "renderQueue.list"}));
+    let out = queue["items"][1]["outputPath"].as_str().unwrap_or_default();
+    assert!(out.starts_with(&*write.to_string_lossy()), "{queue}");
+    let _ = std::fs::remove_dir_all(&base);
+}
+
+/// #2131 (audit F-11, "Running code"): `script.run` and the Scripts menu are refused while file
+/// access is confined, but a ScriptUI panel's script runs just as freely — when the panel opens,
+/// when an event reaches one of its controls, or when one of its tasks comes due — and
+/// `prefs.set` could grant every script run afterwards the file and network access the user
+/// withheld, in the settings file, long after the session. All of that is refused too.
+#[test]
+fn automation_roots_refuse_running_script_code() {
+    use crate::confine::Confinement;
+    let base = std::env::temp_dir().join(format!("ec-mcp-scripts-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&base);
+    std::fs::create_dir_all(&base).unwrap();
+    let mut s = server();
+    s.backend().confine(Confinement::new(&[], std::slice::from_ref(&base)).unwrap());
+    let refused = |s: &mut McpServer, name: &str, args: Value| {
+        let (c, err) = call(s, name, args.clone());
+        assert!(err, "{name} {args} should be refused: {c:?}");
+        c[0]["text"].as_str().unwrap_or_default().to_string()
+    };
+    // Every way a script's code starts.
+    for (command, params) in [
+        ("window.scriptPanel", json!({"name": "Layer Tools.jsx"})),
+        ("window.restoreScriptPanels", json!({})),
+        ("script.runTasks", json!({})),
+        ("scriptui.click", json!({"window": 1, "widget": 2})),
+        ("scriptui.set", json!({"window": 1, "widget": 2, "value": 1})),
+        ("scriptui.mouse", json!({"window": 1, "widget": 2, "type": "click"})),
+        ("scriptui.close", json!({"window": 1})),
+    ] {
+        let msg = refused(&mut s, "execute_command", json!({"command": command, "params": params}));
+        assert!(msg.contains("not available while file access is confined"), "`{command}`: {msg}");
+    }
+    // Including as a batch step.
+    let msg = refused(&mut s, "batch", json!({"steps": [{"command": "window.scriptPanel", "params": {"name": "x.jsx"}}]}));
+    assert!(msg.contains("not available while file access is confined"), "{msg}");
+    // What scripts may do stays as the user left it, by either spelling of the setting.
+    for params in [
+        json!({"key": "scripting.allowScriptsWriteFiles", "value": true}),
+        json!({"key": "scripting.allow_scripts_write_files", "value": true}),
+        json!({"values": {"scripting.warnExecutingFiles": false}}),
+        json!({"values": {"general.showToolTips": false, "scripting.enableJsDebugger": true}}),
+        // `Prefs::set` makes a JSON pointer of the key, so this spelling resolves too…
+        json!({"key": "scripting/allowScriptsWriteFiles", "value": true}),
+        // …and the page on its own replaces every setting on it.
+        json!({"key": "scripting", "value": {"allowScriptsWriteFiles": true}}),
+        json!({"values": {"scripting": {"warnExecutingFiles": false}}}),
+    ] {
+        let msg = refused(&mut s, "execute_command", json!({"command": "prefs.set", "params": params}));
+        assert!(msg.contains("what a script may do"), "{msg}");
+    }
+    let got = call_json(&mut s, "execute_command", json!({"command": "prefs.get", "params": {"key": "scripting.allowScriptsWriteFiles"}}));
+    assert_eq!(got, json!(false), "{got}");
+    // Other settings, and looking at the script windows, still work.
+    call_json(&mut s, "execute_command", json!({"command": "prefs.set", "params": {"key": "general.showToolTips", "value": false}}));
+    call_json(&mut s, "execute_command", json!({"command": "scriptui.list"}));
+    let _ = std::fs::remove_dir_all(&base);
+}
+
+#[test]
+fn blender_export_requires_an_absolute_path_in_a_write_root() {
+    use crate::confine::Confinement;
+    let base = std::env::temp_dir().join(format!("ec-blender-confine-{}", std::process::id()));
+    let (read, write) = (base.join("read"), base.join("write"));
+    for dir in [&read, &write] {
+        std::fs::create_dir_all(dir).unwrap();
+    }
+    let confinement = Confinement::new(std::slice::from_ref(&read), std::slice::from_ref(&write)).unwrap();
+    let check = |path: &std::path::Path| confinement.check_command("camera.exportBlender", &json!({"path": path}));
+    assert!(check(&write.join("scene.py")).unwrap().is_empty());
+    for path in [read.join("scene.py"), base.join("outside.py"), write.join("../read/scene.py")] {
+        assert!(check(&path).is_err(), "must deny {}", path.display());
+    }
+    for path in ["scene.py", "./scene.py", "write/scene.py", "../scene.py"] {
+        let error = check(std::path::Path::new(path)).unwrap_err().to_string();
+        assert!(error.contains("give an absolute path"), "{path}: {error}");
+    }
+    let read_only = Confinement::new(std::slice::from_ref(&write), &[]).unwrap();
+    assert!(read_only.check_command("camera.exportBlender", &json!({"path": write.join("scene.py")})).is_err());
+    for path in [json!(read.join("scene.py")), json!("scene.py"), json!("$1.path")] {
+        let batch = json!({"steps": [{"command": "camera.exportBlender", "params": {"path": path}}]});
+        assert!(confinement.check_command("engine.batch", &batch).is_err());
+    }
+    std::fs::remove_dir_all(&base).unwrap();
+}
+
+/// `render_frame` writes the frame to the `path` it is given, and never over a file the open
+/// project reads (#1743): footage, a proxy or the project file. The refusal comes before the
+/// frame is rendered, and the file is untouched.
+#[test]
+fn render_frame_never_writes_over_a_file_the_project_reads() {
+    use effectcraft_engine::{
+        color::Label,
+        project::{Footage, FootageKind, ItemKind},
+    };
+    use std::sync::Arc;
+    let dir = std::env::temp_dir().join(format!("effectcraft-mcp-overwrite-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let (clip, project) = (dir.join("clip.png"), dir.join("Project.ecproj"));
+    std::fs::write(&clip, b"SOURCE FOOTAGE").unwrap();
+    let mut session = Session::default();
+    session.execute("comp.new", json!({"width": 16, "height": 16})).unwrap();
+    session.execute("file.saveAs", json!({"path": project.to_string_lossy()})).unwrap();
+    Arc::make_mut(&mut session.project).add_item(
+        "clip.png",
+        Label::Aqua,
+        None,
+        ItemKind::Footage(Footage {
+            path: clip.to_string_lossy().into_owned(),
+            kind: FootageKind::Still,
+            width: 16,
+            height: 16,
+            has_video: true,
+            ..Default::default()
+        }),
+    );
+    let saved = std::fs::read(&project).unwrap();
+    let mut s = McpServer::new(Backend::headless(session));
+    for (file, what) in [(&clip, "footage"), (&project, "project")] {
+        let (c, err) = call(&mut s, "render_frame", json!({"path": file.to_string_lossy(), "inline": false}));
+        let text = c[0]["text"].as_str().unwrap();
+        assert!(err && text.contains(&*file.to_string_lossy()) && text.contains(what), "{what}: {text}");
+    }
+    assert_eq!(std::fs::read(&clip).unwrap(), b"SOURCE FOOTAGE", "the footage is as it was");
+    assert_eq!(std::fs::read(&project).unwrap(), saved, "the project file is as it was");
+    // Anywhere else it writes the PNG.
+    let free = dir.join("frame.png");
+    let (c, err) = call(&mut s, "render_frame", json!({"path": free.to_string_lossy(), "inline": false}));
+    assert!(!err, "{c:?}");
+    assert_eq!(&std::fs::read(&free).unwrap()[..8], b"\x89PNG\r\n\x1a\n");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// The same through the desktop app: the app knows the project's files, so the tool asks it
+/// (`file.checkOutput`) before it writes anything.
+#[test]
+fn bridged_render_frame_asks_the_app_before_it_writes() {
+    use effectcraft_engine::project::{Footage, FootageKind};
+    struct Probe;
+    impl effectcraft_engine::Importer for Probe {
+        fn probe(&self, path: &str) -> Result<Footage, String> {
+            Ok(Footage { path: path.to_string(), kind: FootageKind::Still, width: 4, height: 4, has_video: true, ..Default::default() })
+        }
+    }
+    let dir = std::env::temp_dir().join(format!("effectcraft-mcp-bridge-overwrite-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let clip = dir.join("clip.png");
+    std::fs::write(&clip, b"SOURCE FOOTAGE").unwrap();
+
+    let l = TcpListener::bind("127.0.0.1:0").unwrap();
+    let port = l.local_addr().unwrap().port();
+    std::thread::spawn(move || {
+        let (stream, _) = l.accept().unwrap();
+        let mut out = stream.try_clone().unwrap();
+        let mut session = Session { importer: Some(std::sync::Arc::new(Probe)), ..Default::default() };
+        for line in BufReader::new(stream).lines() {
+            let msg: Value = serde_json::from_str(&line.unwrap()).unwrap();
+            let p = &msg["params"];
+            let mut reply = match msg["method"].as_str().unwrap() {
+                "engine.execute" => match session.execute(p["command"].as_str().unwrap(), p["params"].clone()) {
+                    Ok(v) => json!({"ok": true, "result": v}),
+                    Err(e) => json!({"ok": false, "error": e.to_string()}),
+                },
+                "render.frame" if p["write"] == true && p["path"].is_string() => fake_render_frame(&session, p),
+                "render.frame" => json!({"ok": false, "error": "a frame save must be one app-owned write"}),
+                m => json!({"ok": false, "error": format!("unknown method `{m}`")}),
+            };
+            reply["id"] = msg["id"].clone();
+            writeln!(out, "{reply}").unwrap();
+        }
+    });
+    let mut s = McpServer::new(Backend::bridge(&port.to_string()).unwrap());
+    call_json(&mut s, "execute_command", json!({"command": "comp.new", "params": {"width": 16, "height": 16}}));
+    call_json(&mut s, "execute_command", json!({"command": "file.import", "params": {"paths": [clip.to_string_lossy()]}}));
+
+    let (c, err) = call(&mut s, "render_frame", json!({"path": clip.to_string_lossy(), "inline": false}));
+    let text = c[0]["text"].as_str().unwrap();
+    assert!(err && text.contains("clip.png") && text.contains("footage"), "{text}");
+    assert_eq!(std::fs::read(&clip).unwrap(), b"SOURCE FOOTAGE", "the footage is as it was");
+    // Anywhere else it writes the PNG.
+    let free = dir.join("frame.png");
+    let (c, err) = call(&mut s, "render_frame", json!({"path": free.to_string_lossy(), "inline": false}));
+    assert!(!err, "{c:?}");
+    assert_eq!(&std::fs::read(&free).unwrap()[..8], b"\x89PNG\r\n\x1a\n");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// #2131 F-11 ("Indirect reads"): a project opened or imported from inside a read root names its
+/// footage, and those files are read when it renders. Footage outside the roots (an absolute
+/// path, `../`, a symbolic link to a file or a folder out of the root) must not reach the agent:
+/// its layer renders as missing footage, while footage inside the roots still renders.
+#[test]
+fn automation_roots_confine_the_footage_a_project_names() {
+    use crate::confine::Confinement;
+    let base = std::env::temp_dir().join(format!("ec-mcp-footage-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&base);
+    let (read, write, outside) = (base.join("in"), base.join("out"), base.join("elsewhere"));
+    for d in [&read, &write, &outside] {
+        std::fs::create_dir_all(d).unwrap();
+    }
+    let red = image::RgbaImage::from_pixel(8, 8, image::Rgba([255, 0, 0, 255]));
+    red.save(outside.join("secret.png")).unwrap();
+    red.save(read.join("own.png")).unwrap();
+    let p = |d: &std::path::Path, f: &str| d.join(f).to_string_lossy().into_owned();
+    // A project in the read root showing `footage`, saved unconfined.
+    let project = |name: &str, footage: &str| {
+        let mut s = McpServer::new(Backend::headless(effectcraft_host::session()));
+        call_json(&mut s, "execute_command", json!({"command": "comp.new", "params": {"name": "C", "width": 8, "height": 8}}));
+        let imported = call_json(&mut s, "execute_command", json!({"command": "file.import", "params": {"paths": [footage]}}));
+        let item = imported["items"][0].as_u64().or_else(|| imported["item"].as_u64()).unwrap_or_else(|| panic!("{imported}"));
+        call_json(&mut s, "execute_command", json!({"command": "layer.addItem", "params": {"comp": "C", "item": item}}));
+        let path = p(&read, name);
+        call_json(&mut s, "save_project", json!({"path": path}));
+        path
+    };
+    // The middle pixel of comp C: red when the footage was read.
+    let shows_red = |s: &mut McpServer| {
+        let (c, err) = call(s, "render_frame", json!({"comp": "C"}));
+        assert!(!err, "{c:?}");
+        let png = base64::decode(c[0]["data"].as_str().unwrap()).unwrap();
+        let px = image::load_from_memory(&png).unwrap().to_rgba8().get_pixel(4, 4).0;
+        px[0] > 200 && px[3] > 200
+    };
+    let mut projects = vec![("absolute", project("absolute.ecproj", &p(&outside, "secret.png")))];
+    #[cfg(unix)]
+    {
+        std::os::unix::fs::symlink(outside.join("secret.png"), read.join("link.png")).unwrap();
+        std::os::unix::fs::symlink(&outside, read.join("dir")).unwrap();
+        projects.push(("linked file", project("linked-file.ecproj", &p(&read, "link.png"))));
+        projects.push(("linked folder", project("linked-folder.ecproj", &p(&read.join("dir"), "secret.png"))));
+    }
+    // Relative to the project: `../elsewhere/secret.png`, written into a copy of a project.
+    let own = project("own.ecproj", &p(&read, "own.png"));
+    let text = std::fs::read_to_string(&own).unwrap();
+    assert!(text.contains(&p(&read, "own.png")) || text.contains("own.png"), "{text}");
+    let relative = text.replace(&p(&read, "own.png"), "../elsewhere/secret.png").replace("\"own.png\"", "\"../elsewhere/secret.png\"");
+    std::fs::write(read.join("relative.ecproj"), relative).unwrap();
+    projects.push(("relative", p(&read, "relative.ecproj")));
+
+    let confined = || {
+        let mut s = McpServer::new(Backend::headless(effectcraft_host::session()));
+        s.backend().confine(Confinement::new(std::slice::from_ref(&read), std::slice::from_ref(&write)).unwrap());
+        s
+    };
+    // Footage inside the read root renders.
+    let mut s = confined();
+    call_json(&mut s, "open_project", json!({"path": own}));
+    assert!(shows_red(&mut s), "footage inside the read root");
+    for (how, path) in &projects {
+        // Unconfined, the project shows the outside file.
+        let mut s = McpServer::new(Backend::headless(effectcraft_host::session()));
+        call_json(&mut s, "open_project", json!({"path": path}));
+        assert!(shows_red(&mut s), "{how}: unconfined shows the footage");
+        // Confined: opened, or imported into the open project.
+        let mut s = confined();
+        call_json(&mut s, "open_project", json!({"path": path}));
+        assert!(!shows_red(&mut s), "{how}: opened, the footage outside the roots was read");
+        let mut s = confined();
+        call_json(&mut s, "execute_command", json!({"command": "file.importProject", "params": {"path": path}}));
+        assert!(!shows_red(&mut s), "{how}: imported, the footage outside the roots was read");
+    }
+    let _ = std::fs::remove_dir_all(&base);
+}
+
+/// A symbolic link inside the read root, read once while it pointed inside, is checked again
+/// on every read: pointed outside afterwards, its footage must not come back once the frame
+/// cache is emptied.
+#[cfg(unix)]
+#[test]
+fn automation_roots_check_relinked_footage_again() {
+    use crate::confine::Confinement;
+    let base = std::env::temp_dir().join(format!("ec-mcp-relink-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&base);
+    let (read, write, outside) = (base.join("in"), base.join("out"), base.join("elsewhere"));
+    for d in [&read, &write, &outside] {
+        std::fs::create_dir_all(d).unwrap();
+    }
+    image::RgbaImage::from_pixel(8, 8, image::Rgba([0, 0, 255, 255])).save(read.join("own.png")).unwrap();
+    image::RgbaImage::from_pixel(8, 8, image::Rgba([255, 0, 0, 255])).save(outside.join("secret.png")).unwrap();
+    let link = read.join("link.png");
+    std::os::unix::fs::symlink(read.join("own.png"), &link).unwrap();
+    let link_path = link.to_string_lossy().into_owned();
+    let project = read.join("relink.ecproj").to_string_lossy().into_owned();
+    {
+        let mut s = McpServer::new(Backend::headless(effectcraft_host::session()));
+        call_json(&mut s, "execute_command", json!({"command": "comp.new", "params": {"name": "C", "width": 8, "height": 8}}));
+        let imported = call_json(&mut s, "execute_command", json!({"command": "file.import", "params": {"paths": [link_path]}}));
+        let item = imported["items"][0].as_u64().or_else(|| imported["item"].as_u64()).unwrap_or_else(|| panic!("{imported}"));
+        call_json(&mut s, "execute_command", json!({"command": "layer.addItem", "params": {"comp": "C", "item": item}}));
+        call_json(&mut s, "save_project", json!({"path": project}));
+    }
+    // The middle pixel of comp C.
+    let pixel = |s: &mut McpServer| {
+        let (c, err) = call(s, "render_frame", json!({"comp": "C"}));
+        assert!(!err, "{c:?}");
+        let png = base64::decode(c[0]["data"].as_str().unwrap()).unwrap();
+        image::load_from_memory(&png).unwrap().to_rgba8().get_pixel(4, 4).0
+    };
+    let mut s = McpServer::new(Backend::headless(effectcraft_host::session()));
+    s.backend().confine(Confinement::new(std::slice::from_ref(&read), std::slice::from_ref(&write)).unwrap());
+    call_json(&mut s, "open_project", json!({"path": project}));
+    let px = pixel(&mut s);
+    assert!(px[2] > 200 && px[0] < 50, "the link pointing inside renders: {px:?}");
+    std::fs::remove_file(&link).unwrap();
+    std::os::unix::fs::symlink(outside.join("secret.png"), &link).unwrap();
+    call_json(&mut s, "execute_command", json!({"command": "edit.purge", "params": {"what": "memory"}}));
+    let px = pixel(&mut s);
+    assert!(!(px[0] > 200 && px[3] > 200), "the link pointed outside afterwards was read: {px:?}");
+    let _ = std::fs::remove_dir_all(&base);
+}
diff --git a/crates/automation/src/tools.rs b/crates/automation/src/tools.rs
index a83e0d1ec..cb1a3cdab 100644
--- a/crates/automation/src/tools.rs
+++ b/crates/automation/src/tools.rs
@@ -175,16 +175,21 @@ fn params_of(v: Option<&Value>) -> Result<Value> {
 
 // ------------------------------------------------------------------ engine tools
 
+/// `list_commands` tool: the engine command list, minus empty fields; with `compact`, only `id` and `label`.
 fn list_commands(b: &mut Backend, a: &Value) -> Result<Reply> {
-    let schemas = get(a, "schemas").and_then(Value::as_bool).unwrap_or(false).then_some(json!(true));
+    let compact = get(a, "compact").and_then(Value::as_bool).unwrap_or(false);
+    let schemas = (!compact && get(a, "schemas").and_then(Value::as_bool).unwrap_or(false)).then_some(json!(true));
     let r = b.exec("command.list", obj(&[("filter", get(a, "filter")), ("enabledOnly", get(a, "enabled_only")), ("schemas", schemas.as_ref())]))?;
-    // Drop empty fields to keep the listing compact.
     let list: Vec<Value> = r
         .as_array()
         .cloned()
         .unwrap_or_default()
         .into_iter()
         .map(|mut c| {
+            if compact {
+                return json!({"id": c["id"], "label": c["label"]});
+            }
+            // Drop empty fields.
             if let Some(o) = c.as_object_mut() {
                 o.retain(|_, v| !(v.is_null() || v.as_array().is_some_and(Vec::is_empty) || v.as_str() == Some("{}")));
             }
@@ -205,8 +210,13 @@ fn describe_command(b: &mut Backend, a: &Value) -> Result<Reply> {
     json_reply(b.exec("command.describe", json!({"command": id}))?)
 }
 
+/// `list_effects` tool: the effect registry; with `compact`, only `id`, `name` and `category`.
 fn list_effects(b: &mut Backend, a: &Value) -> Result<Reply> {
-    json_reply(b.exec("effect.list", obj(&[("filter", get(a, "filter"))]))?)
+    let mut r = b.exec("effect.list", obj(&[("filter", get(a, "filter"))]))?;
+    if get(a, "compact").and_then(Value::as_bool).unwrap_or(false) {
+        r = r.as_array().into_iter().flatten().map(|e| json!({"id": e["id"], "name": e["name"], "category": e["category"]})).collect();
+    }
+    json_reply(r)
 }
 
 fn list_fonts(b: &mut Backend, a: &Value) -> Result<Reply> {
@@ -275,7 +285,7 @@ fn get_comp(b: &mut Backend, a: &Value) -> Result<Reply> {
     json_reply(b.exec("comp.info", obj(&[("comp", get(a, "comp"))]))?)
 }
 
-/// Flatten a `layer.tree` property tree into `[{path, type, value, keys?, expression?}]`.
+/// Flatten a `layer.tree` property tree into `[{path, type, value, keys?, expression?, options?}]`.
 fn flatten(node: &Value, out: &mut Vec<Value>) {
     // A group cut off by `depth` stays visible (instead of vanishing from the flat list).
     if node.get("truncated").and_then(Value::as_bool) == Some(true) {
@@ -292,6 +302,9 @@ fn flatten(node: &Value, out: &mut Vec<Value>) {
             if let Some(e) = node.get("expression") {
                 o["expression"] = e.clone();
             }
+            if let Some(opts) = node.get("options") {
+                o["options"] = opts.clone();
+            }
             out.push(o);
         }
     }
@@ -393,13 +406,15 @@ fn add_keyframe(b: &mut Backend, a: &Value) -> Result<Reply> {
 fn render_frame(b: &mut Backend, a: &Value) -> Result<Reply> {
     let max_side = get(a, "max_side").and_then(Value::as_u64).unwrap_or(960) as u32;
     let transparent = get(a, "transparent").and_then(Value::as_bool).unwrap_or(false);
-    let f = b.render_with(get(a, "comp"), get(a, "time").and_then(Value::as_f64), max_side, transparent)?;
+    let path = get(a, "path").and_then(Value::as_str);
+    let comp = get(a, "comp");
+    let time = get(a, "time").and_then(Value::as_f64);
+    let f = match path {
+        Some(path) => b.render_to_file(comp, time, max_side, transparent, path)?,
+        None => b.render_with(comp, time, max_side, transparent)?,
+    };
     let mut info = json!({"comp": f.comp, "time": f.time, "width": f.width, "height": f.height});
-    if let Some(p) = get(a, "path").and_then(Value::as_str) {
-        if let Some(c) = b.confinement() {
-            c.check(p, crate::confine::Access::Write)?;
-        }
-        std::fs::write(p, &f.png).map_err(|e| Error::Other(format!("cannot write {p}: {e}")))?;
+    if let Some(p) = path {
         info["path"] = json!(p);
     }
     if get(a, "inline").and_then(Value::as_bool) == Some(false) {
@@ -542,14 +557,15 @@ fn control(b: &mut Backend, a: &Value) -> Result<Reply> {
 static TOOLS: &[ToolDef] = &[
     ToolDef {
         name: "list_commands",
-        description: "List engine commands: id, label, menu path, shortcut, `params` doc (e.g. `{name?, width?, height?, frameRate?, duration? (s)}`) and whether it can run now (`why` if not). Every menu item, shortcut and panel gesture maps to one of these ids; run them with execute_command. Narrow with `filter` (e.g. `layer.new`, `keys`, `effect`).",
+        description: "List engine commands: id, label, menu path, shortcut, `params` doc (e.g. `{name?, width?, height?, frameRate?, duration? (s)}`) and whether it can run now (`why` if not). Every menu item, shortcut and panel gesture maps to one of these ids; run them with execute_command. Narrow with `filter` (e.g. `layer.new`, `keys`, `effect`); `compact: true` lists only ids and labels.",
         bridge_only: false,
         schema: || {
             schema(
                 json!({
                     "filter": {"type": "string", "description": "Only commands whose id or label contains this text (case-insensitive)."},
                     "enabled_only": {"type": "boolean", "description": "Only commands that can run right now."},
-                    "schemas": {"type": "boolean", "description": "Also return each command's parameter JSON Schema (`schema`)."}
+                    "schemas": {"type": "boolean", "description": "Also return each command's parameter JSON Schema (`schema`)."},
+                    "compact": {"type": "boolean", "description": "Return only each command's `id` and `label` (overrides `schemas`)."}
                 }),
                 &[],
             )
@@ -615,7 +631,7 @@ static TOOLS: &[ToolDef] = &[
     },
     ToolDef {
         name: "get_layer",
-        description: "A layer's property tree (transform, masks, effects, text, shape contents, ...): leaf properties have a `path` usable with get_property/set_property/add_keyframe, plus uid, match id, name, type, value at `time`, keyframes and expression. Groups contain children; inspect them here, then select a leaf path. `flat: true` returns just a list of {path, type, value, keys, expression} (compact).",
+        description: "A layer's property tree (transform, masks, effects, text, shape contents, ...): leaf properties have a `path` usable with get_property/set_property/add_keyframe, plus uid, match id, name, type, value at `time`, keyframes and expression; popup (enum) properties add `options` ([{value, label}]). Groups contain children; inspect them here, then select a leaf path. `flat: true` returns just a list of {path, type, value, keys, expression, options} (compact).",
         bridge_only: false,
         schema: || {
             schema(
@@ -632,7 +648,7 @@ static TOOLS: &[ToolDef] = &[
     },
     ToolDef {
         name: "get_property",
-        description: "Read one property: type, value at `time` (comp seconds; default the current time), whether it is animated, its keyframes (time, value, in/out interpolation) and expression.",
+        description: "Read one property: type, value at `time` (comp seconds; default the current time), whether it is animated, its keyframes (time, value, in/out interpolation) and expression. Popup (enum) properties add `options`: [{value, label}], the values set_property takes.",
         bridge_only: false,
         schema: || {
             schema(
@@ -696,9 +712,17 @@ static TOOLS: &[ToolDef] = &[
     },
     ToolDef {
         name: "list_effects",
-        description: "The effect registry: id, After Effects name, category, GPU and 32-bpc support. Narrow with `filter` (id, name or category text). Apply with add_effect.",
+        description: "The effect registry: id, After Effects name, category, GPU and 32-bpc support. Narrow with `filter` (id, name or category text); `compact: true` lists only ids, names and categories. Apply with add_effect.",
         bridge_only: false,
-        schema: || schema(json!({"filter": {"type": "string", "description": "Only effects whose id, name or category contains this text."}}), &[]),
+        schema: || {
+            schema(
+                json!({
+                    "filter": {"type": "string", "description": "Only effects whose id, name or category contains this text."},
+                    "compact": {"type": "boolean", "description": "Return only each effect's `id`, `name` and `category`."}
+                }),
+                &[],
+            )
+        },
         run: list_effects,
     },
     ToolDef {
@@ -911,14 +935,15 @@ static TOOLS: &[ToolDef] = &[
     },
     ToolDef {
         name: "command_list",
-        description: "List engine commands: id, label, menu path, shortcut, `params` doc (e.g. `{name?, width?, height?, frameRate?, duration? (s)}`) and whether it can run now (`why` if not). Every menu item, shortcut and panel gesture maps to one of these ids; run them with execute_command. Narrow with `filter` (e.g. `layer.new`, `keys`, `effect`).",
+        description: "List engine commands: id, label, menu path, shortcut, `params` doc (e.g. `{name?, width?, height?, frameRate?, duration? (s)}`) and whether it can run now (`why` if not). Every menu item, shortcut and panel gesture maps to one of these ids; run them with execute_command. Narrow with `filter` (e.g. `layer.new`, `keys`, `effect`); `compact: true` lists only ids and labels.",
         bridge_only: false,
         schema: || {
             schema(
                 json!({
                     "filter": {"type": "string", "description": "Only commands whose id or label contains this text (case-insensitive)."},
                     "enabled_only": {"type": "boolean", "description": "Only commands that can run right now."},
-                    "schemas": {"type": "boolean", "description": "Also return each command's parameter JSON Schema (`schema`)."}
+                    "schemas": {"type": "boolean", "description": "Also return each command's parameter JSON Schema (`schema`)."},
+                    "compact": {"type": "boolean", "description": "Return only each command's `id` and `label` (overrides `schemas`)."}
                 }),
                 &[],
             )
diff --git a/crates/automation/tests/qa/compositing.rs b/crates/automation/tests/qa/compositing.rs
index 52d5e4fb2..d5de8f687 100644
--- a/crates/automation/tests/qa/compositing.rs
+++ b/crates/automation/tests/qa/compositing.rs
@@ -7,6 +7,10 @@ use serde_json::{Value, json};
 
 use crate::harness::{Img, Qa, coverage, luma, mean_diff};
 
+fn lum(i: &Img, x: u32, y: u32) -> f64 {
+    luma(i.get_pixel(x, y))
+}
+
 fn px(img: &Img, x: u32, y: u32) -> [u8; 4] {
     img.get_pixel(x, y).0
 }
@@ -25,14 +29,13 @@ fn write_sequence(qa: &Qa) -> String {
     qa.path("seq/ball_000.png")
 }
 
-#[test]
-fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
-    let mut qa = Qa::new("compositing");
-
+/// Import the sequence (reinterpreted at 12 fps) and a PSD written by the app; returns the
+/// sequence item and the PSD's composition.
+fn import_footage(qa: &mut Qa) -> (Value, Value) {
     // Footage: the sequence, and a layered PSD written by the app itself (Save Frame As ▸
     // Photoshop Layers) from a small comp.
-    let seq = write_sequence(&qa);
-    let imp = qa.exec("file.import", json!({"paths": [seq]}));
+    let seq = write_sequence(qa);
+    let imp = qa.exec("file.import", json!({"paths": [seq], "sequence": true}));
     let seq_item = imp["items"][0].clone();
     let project = qa.tool("get_project", json!({}));
     let it = project["items"].as_array().unwrap().iter().find(|i| i["id"] == seq_item).unwrap().clone();
@@ -55,10 +58,14 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
     let pc = qa.tool("get_comp", json!({"comp": psd_comp.clone()}));
     let names: Vec<&str> = pc["layers"].as_array().unwrap().iter().map(|l| l["name"].as_str().unwrap()).collect();
     assert_eq!(names, ["Bar", "Gray"], "the PSD's layers, top first: {pc}");
+    (seq_item, psd_comp)
+}
 
+/// The main comp: the sequence plays, then a Screen-blended PSD; returns the Normal-mode frame.
+fn main_comp_and_blend(qa: &mut Qa, seq_item: &Value, psd_comp: &Value) -> Img {
     // The main comp.
-    let main = qa.exec("comp.new", json!({"name": "Main", "width": 160, "height": 90, "frameRate": 12, "duration": 1}))["comp"].clone();
-    qa.exec("layer.addItem", json!({"item": seq_item}));
+    qa.exec("comp.new", json!({"name": "Main", "width": 160, "height": 90, "frameRate": 12, "duration": 1}));
+    qa.exec("layer.addItem", json!({"item": seq_item.clone()}));
     let a = qa.frame(None, 0.0);
     let b = qa.frame(None, 0.5);
     assert!(mean_diff(&a, &b) > 1.0, "the sequence plays");
@@ -75,7 +82,10 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
     for c in 0..3 {
         assert!(s[c] > n[c] && s[c] > [32, 64, 96][c], "Screen brightens channel {c}: {s:?}");
     }
+    normal
+}
 
+fn track_matte(qa: &mut Qa) {
     // Track matte: a magenta solid seen only through text.
     qa.exec("layer.newText", json!({"text": "MATTE", "name": "Matte", "size": 40, "fill": "#ffffff"}));
     qa.exec("layer.newSolid", json!({"name": "Fill", "color": "#ff00ff", "width": 160, "height": 90}));
@@ -91,7 +101,9 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
     let fill = info["layers"].as_array().unwrap().iter().find(|l| l["name"] == "Fill").unwrap().clone();
     assert_eq!(fill["trackMatte"]["kind"], "Alpha Matte");
     qa.exec("layer.setSwitch", json!({"layers": ["Fill", "Matte"], "switch": "video", "value": false}));
+}
 
+fn adjustment_layer(qa: &mut Qa, normal: &Img) {
     // Adjustment layer: Lumetri exposure, inside a feathered, expanded elliptical mask; then Glow.
     qa.exec("layer.newAdjustment", json!({"name": "Grade"}));
     let fx = qa.exec("effect.apply", json!({"effect": "Lumetri Color", "layers": ["Grade"]}));
@@ -103,7 +115,6 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
     let mk = qa.exec("layer.addMask", json!({"layer": "Grade", "shape": "ellipse", "rect": [40, 20, 80, 50]}));
     assert!(mk["mask"].is_u64(), "{mk}");
     let hard = qa.frame(None, 0.5);
-    let lum = |i: &Img, x, y| luma(i.get_pixel(x, y));
     assert!(lum(&hard, 80, 45) > lum(&before, 80, 45) - 1.0 && lum(&hard, 5, 5) < lum(&before, 5, 5) - 10.0, "the mask limits the grade to the ellipse");
     qa.exec("layer.mask.set", json!({"layer": "Grade", "field": "expansion", "value": 8}));
     let grown = qa.frame(None, 0.5);
@@ -116,7 +127,7 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
         }
         n
     };
-    assert!(bright(&grown, &normal) > bright(&hard, &normal) + 100, "expansion grows the graded area");
+    assert!(bright(&grown, normal) > bright(&hard, normal) + 100, "expansion grows the graded area");
     qa.exec("layer.mask.set", json!({"layer": "Grade", "field": "feather", "value": 20}));
     let soft = qa.frame(None, 0.5);
     // At the ellipse's edge (x = 40 − 8): feathered is in between none and full.
@@ -125,7 +136,10 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
     qa.exec("effect.apply", json!({"effect": "Glow", "layers": ["Grade"]}));
     let glow = qa.frame(None, 0.5);
     assert!(mean_diff(&soft, &glow) > 0.5, "Glow changes the frame");
+}
 
+/// The 3D stage with depth of field and a light; returns the stage comp.
+fn stage_3d(qa: &mut Qa) -> Value {
     // 3D stage: a near and a far card, a camera with depth of field, a light.
     let stage = qa.exec("comp.new", json!({"name": "Stage", "width": 160, "height": 90, "frameRate": 12, "duration": 1}))["comp"].clone();
     qa.exec("layer.newSolid", json!({"name": "Near", "color": "#ff4040", "width": 40, "height": 40}));
@@ -155,7 +169,10 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
     let advanced = qa.frame(None, 0.0);
     assert!(mean_diff(&classic, &advanced) > 0.2, "Advanced 3D renders the stage its own way");
     assert!(lum(&advanced, 50, 45) > 60.0, "Advanced 3D still lights the card");
+    stage
+}
 
+fn alpha_renders(qa: &mut Qa, stage: &Value) {
     // Renders with alpha: the stage has no background layer, so most of it is transparent.
     let mov = qa.path("stage.mov");
     let webm = qa.path("stage.webm");
@@ -165,7 +182,7 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
     assert!(done["items"].as_array().unwrap().iter().all(|i| i["status"] == "Done"), "{done}");
     let reference = qa.tool("render_frame", json!({"comp": stage.clone(), "time": 0, "transparent": true, "inline": false}));
     assert_eq!(reference["width"], 160);
-    let refa = alpha_frame(&mut qa, stage.clone());
+    let refa = alpha_frame(qa, stage.clone());
     assert!(px(&refa, 2, 2)[3] < 40 && px(&refa, 50, 45)[3] == 255, "render_frame transparent keeps alpha: {:?} {:?}", px(&refa, 2, 2), px(&refa, 50, 45));
     // ProRes 4444 carries alpha in the frame; WebM VP9 as a second VP9 stream in BlockAdditions
     // (AlphaMode 1), which FilmCraft's Matroska reader decodes into the frame's alpha plane.
@@ -174,14 +191,24 @@ fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
         assert_eq!(r["errors"], json!([]));
         assert_eq!(r["unlabeledAlpha"], r["items"], "{path}: the importer sees an alpha channel");
         let c = qa.exec("file.newCompFromSelection", json!({}))["comps"][0].clone();
-        let f = alpha_frame(&mut qa, c.clone());
+        let f = alpha_frame(qa, c.clone());
         // The opaque card decodes to the stage's colours (lossy codecs, so loosely).
         let (got, want) = (px(&f, 50, 45), px(&refa, 50, 45));
         assert!((0..3).all(|c| got[c].abs_diff(want[c]) < 12), "{path} decodes to the stage: {got:?} vs {want:?}");
         assert!(mean_diff(&qa.frame(Some(c.clone()), 0.0), &qa.frame(Some(stage.clone()), 0.0)) < 8.0, "{path} composites like the stage");
         assert!(px(&f, 2, 2)[3] < 40 && px(&f, 50, 45)[3] > 250, "{path}: transparent corners, opaque card: {:?} {:?}", px(&f, 2, 2), px(&f, 50, 45));
     }
-    let _ = main;
+}
+
+#[test]
+fn compositing_matte_blend_adjustment_3d_and_alpha_renders() {
+    let mut qa = Qa::new("compositing");
+    let (seq_item, psd_comp) = import_footage(&mut qa);
+    let normal = main_comp_and_blend(&mut qa, &seq_item, &psd_comp);
+    track_matte(&mut qa);
+    adjustment_layer(&mut qa, &normal);
+    let stage = stage_3d(&mut qa);
+    alpha_renders(&mut qa, &stage);
 }
 
 fn alpha_frame(qa: &mut Qa, comp: Value) -> Img {
diff --git a/crates/automation/tests/qa/tracking.rs b/crates/automation/tests/qa/tracking.rs
index 837872658..ee6bbb2e9 100644
--- a/crates/automation/tests/qa/tracking.rs
+++ b/crates/automation/tests/qa/tracking.rs
@@ -52,7 +52,7 @@ fn shake_offset(f: u32) -> (i64, i64) {
 
 /// Import a sequence at 12 fps and make a comp of it; returns (comp, layer).
 fn plate_comp(qa: &mut Qa, first: &str, name: &str) -> (Value, Value) {
-    let item = qa.exec("file.import", json!({"paths": [first]}))["items"][0].clone();
+    let item = qa.exec("file.import", json!({"paths": [first], "sequence": true}))["items"][0].clone();
     qa.exec("file.interpretFootage", json!({"items": [item.clone()], "frameRate": 12}));
     let comp = qa.exec("comp.new", json!({"name": name, "width": 160, "height": 90, "frameRate": 12, "duration": 1}))["comp"].clone();
     let layer = qa.exec("layer.addItem", json!({"item": item}))["layer"].clone();
diff --git a/crates/av1enc/README.md b/crates/av1enc/README.md
index c922c95eb..dcc343693 100644
--- a/crates/av1enc/README.md
+++ b/crates/av1enc/README.md
@@ -48,8 +48,10 @@ reconstruction, so prediction never drifts.
   reconstruction loop; full coefficient coding (all_zero, tx type, eob_pt, eob_extra,
   coeff_base_eob, coeff_base, coeff_br, dc_sign, Golomb) with the exact contexts.
 - **Rate control**: `ConstantQ(base_q_idx)`; `Bitrate { kbps }` adapts `base_q_idx` per frame
-  towards the average target (key frames get a lower quantizer and a larger share; the first
-  key frame is searched in a few passes).
+  towards the average target (key frames get a lower quantizer and a larger share of the budget of
+  their group of `keyint` frames, the inter frames the rest; the first key frame is searched in a
+  few passes, a later key frame that misses its budget by more than 19 % is coded again; the
+  deviation from the budget is paid back over 16 frames).
 
 ## Limits
 
diff --git a/crates/av1enc/src/cdf.rs b/crates/av1enc/src/cdf.rs
index 0466a1592..777164d1a 100644
--- a/crates/av1enc/src/cdf.rs
+++ b/crates/av1enc/src/cdf.rs
@@ -2,7 +2,15 @@
 //! init_coeff_cdfs that its syntax uses). Layout as in filmcraft-av1: each innermost array
 //! holds N cumulative values (the last is 32768) plus the adaptation counter.
 
-use crate::tables::*;
+use crate::tables::{
+    DEFAULT_ANGLE_DELTA_CDF, DEFAULT_COEFF_BASE_CDF, DEFAULT_COEFF_BASE_EOB_CDF, DEFAULT_COEFF_BR_CDF, DEFAULT_DC_SIGN_CDF, DEFAULT_DRL_MODE_CDF,
+    DEFAULT_EOB_EXTRA_CDF, DEFAULT_EOB_PT_16_CDF, DEFAULT_EOB_PT_32_CDF, DEFAULT_EOB_PT_64_CDF, DEFAULT_EOB_PT_128_CDF, DEFAULT_EOB_PT_256_CDF,
+    DEFAULT_EOB_PT_512_CDF, DEFAULT_EOB_PT_1024_CDF, DEFAULT_INTER_TX_TYPE_SET3_CDF, DEFAULT_INTRA_TX_TYPE_SET2_CDF, DEFAULT_IS_INTER_CDF, DEFAULT_MV_BIT_CDF,
+    DEFAULT_MV_CLASS_CDF, DEFAULT_MV_CLASS0_BIT_CDF, DEFAULT_MV_CLASS0_FR_CDF, DEFAULT_MV_FR_CDF, DEFAULT_MV_JOINT_CDF, DEFAULT_MV_SIGN_CDF,
+    DEFAULT_NEW_MV_CDF, DEFAULT_PARTITION_W8_CDF, DEFAULT_PARTITION_W16_CDF, DEFAULT_PARTITION_W32_CDF, DEFAULT_PARTITION_W64_CDF, DEFAULT_REF_MV_CDF,
+    DEFAULT_SINGLE_REF_CDF, DEFAULT_SKIP_CDF, DEFAULT_TXB_SKIP_CDF, DEFAULT_UV_MODE_CFL_ALLOWED_CDF, DEFAULT_UV_MODE_CFL_NOT_ALLOWED_CDF, DEFAULT_Y_MODE_CDF,
+    DEFAULT_ZERO_MV_CDF,
+};
 
 #[derive(Clone)]
 pub(crate) struct Cdfs {
diff --git a/crates/av1enc/src/decide.rs b/crates/av1enc/src/decide.rs
index 494e914c0..d8bc1f825 100644
--- a/crates/av1enc/src/decide.rs
+++ b/crates/av1enc/src/decide.rs
@@ -3,8 +3,12 @@
 //! processes, so the reconstruction built here is exactly what a decoder produces; the syntax
 //! is written afterwards by `writer.rs`.
 
-use crate::pred::*;
-use crate::tables::*;
+use crate::pred::{INTRA_MODES_USED, InterBlock, IntraEdge, Plane, edges, half_planes, predict_inter, predict_intra};
+use crate::tables::{
+    AC_QLOOKUP, BLOCK_8X8, BLOCK_64X64, DC_PRED, DC_QLOOKUP, DCT_DCT, DEFAULT_SCAN_4X4, DEFAULT_SCAN_8X8, DEFAULT_SCAN_16X16, DEFAULT_SCAN_32X32, MODE_TO_TXFM,
+    NEWMV, NUM_4X4_BLOCKS_WIDE, PARTITION_SPLIT, PARTITION_SUBSIZE, TX_4X4, TX_8X8, TX_16X16, TX_32X32, TX_64X64, TX_SET_DCTONLY, TX_SET_INTER_3,
+    TX_SET_INTRA_2, TX_SIZE_SQR_UP, TX_TYPE_IN_SET_INTER, TX_TYPE_IN_SET_INTRA,
+};
 use crate::transform::{forward_2d, inverse_2d};
 
 /// Decisions for one coded block.
@@ -100,6 +104,17 @@ pub(crate) fn intra_uv_tx_type(uv_mode: usize, uv_tx: usize) -> usize {
     if tx_in_set(tx_set(uv_tx, false), false, t) { t } else { DCT_DCT }
 }
 
+/// Geometry and coding mode of one square transform block.
+#[derive(Clone, Copy)]
+struct TransformBlock {
+    plane: usize,
+    x: usize,
+    y: usize,
+    log2: u32,
+    tx_type: usize,
+    intra: bool,
+}
+
 struct TxResult {
     levels: Vec<i32>,
     nonzero: bool,
@@ -107,6 +122,38 @@ struct TxResult {
     bits: f64,
 }
 
+/// The output and scratch buffers of one reconstruction, each `n * n` entries long.
+struct ReconBuffers<'a> {
+    deq: &'a mut [i32],
+    resid: &'a mut [i32],
+    recon: &'a mut [u16],
+}
+
+/// Outcome of trying one transform block; the levels and the reconstruction stay in `TxScratch`.
+#[derive(Clone, Copy)]
+struct TxEval {
+    nonzero: bool,
+    dist: f64,
+    bits: f64,
+}
+
+/// Buffers of the transform path, sized for the largest coded transform block (32x32). Only the
+/// first `n * n` entries are used; they are reused across candidates instead of being allocated.
+struct TxScratch {
+    res: [i32; 1024],
+    coef: [f32; 1024],
+    levels: [i32; 1024],
+    deq: [i32; 1024],
+    resid: [i32; 1024],
+    recon: [u16; 1024],
+}
+
+impl Default for TxScratch {
+    fn default() -> Self {
+        TxScratch { res: [0; 1024], coef: [0.0; 1024], levels: [0; 1024], deq: [0; 1024], resid: [0; 1024], recon: [0; 1024] }
+    }
+}
+
 /// Saved encoder state of a block area (reconstruction, BlockDecoded flags).
 struct Snapshot {
     planes: [Vec<u16>; 3],
@@ -127,13 +174,20 @@ pub(crate) struct Decider<'a> {
     ac_q: f32,
     dc_qi: i64,
     ac_qi: i64,
+    /// Smallest magnitude that quantises to a non-zero level, `[dc, ac][intra]`.
+    dead_zone: [[f32; 2]; 2],
     lambda: f64,
     lambda_sad: f64,
     /// Half-sample interpolations of the reference luma (visible area): (8, 0), (0, 8), (8, 8).
     half: [Vec<u16>; 3],
+    /// Transform buffers, taken out while a block is being tried (see `code_tx`).
+    scratch: Option<Box<TxScratch>>,
 }
 
 const MODE_BITS_INTRA: f64 = 3.0;
+/// Dead-zone quantiser rounding offsets (below one half) for inter and intra blocks.
+const INTER_RND: f32 = 0.30;
+const INTRA_RND: f32 = 0.38;
 
 impl<'a> Decider<'a> {
     pub fn new(g: &'a FrameGeom, bd: u32, qidx: u8, intra_only: bool, src: &'a [Plane; 3], refr: Option<&'a RefFrame>) -> Self {
@@ -160,12 +214,14 @@ impl<'a> Decider<'a> {
             ac_q: ac_qi as f32,
             dc_qi,
             ac_qi,
+            dead_zone: [dc_qi, ac_qi].map(|q| [INTER_RND, INTRA_RND].map(|rnd| zero_threshold(q as f32, rnd))),
             lambda,
             lambda_sad: lambda.sqrt(),
             half: match refr {
-                Some(rf) => [(8, 0), (0, 8), (8, 8)].map(|(fx, fy)| subpel_plane(&rf.planes[0], g.width, g.height, fx, fy, bd)),
+                Some(rf) => half_planes(&rf.planes[0], g.width, g.height, bd),
                 None => Default::default(),
             },
+            scratch: None,
         }
     }
 
@@ -324,8 +380,10 @@ impl<'a> Decider<'a> {
         let log2 = (n4 * 4).trailing_zeros();
         let (sbr, sbc) = ((r & 15) as isize, (c & 15) as isize);
         let bd = self.bd;
-        let mut pred = vec![0u16; 32 * 32];
-        let mut best_pred = vec![0u16; 32 * 32];
+        let mut pred = [0u16; 32 * 32];
+        let mut best_pred = [0u16; 32 * 32];
+        let mut best_levels = [0i32; 32 * 32];
+        let mut best_recon = [0u16; 32 * 32];
         let n = 1usize << log2;
         // luma
         let e = IntraEdge {
@@ -343,26 +401,26 @@ impl<'a> Decider<'a> {
         let ed = edges(&self.rec[0], &e);
         // modes ranked by SATD, then a rate-distortion choice of mode and transform type among
         // the best three
-        let mut ranked: Vec<(f64, usize)> = INTRA_MODES_USED
-            .iter()
-            .map(|&mode| {
-                predict_intra(&ed, &e, mode, &mut pred);
-                let sad = self.satd(0, c * 4, r * 4, n, &pred[..n * n]) as f64;
-                (sad + self.lambda_sad * if mode == DC_PRED { 1.0 } else { MODE_BITS_INTRA }, mode)
-            })
-            .collect();
+        let mut ranked: [(f64, usize); INTRA_MODES_USED.len()] = INTRA_MODES_USED.map(|mode| {
+            predict_intra(&ed, &e, mode, &mut pred);
+            let sad = self.satd(0, c * 4, r * 4, n, &pred[..n * n]) as f64;
+            (sad + self.lambda_sad * if mode == DC_PRED { 1.0 } else { MODE_BITS_INTRA }, mode)
+        });
         ranked.sort_by(|a, b| a.0.total_cmp(&b.0));
         let tx_y = tx_size_for(log2);
-        let mut best: Option<(f64, usize, usize, TxResult, Option<Vec<u16>>)> = None;
+        let mut best: Option<(f64, usize, usize, TxEval, bool)> = None;
+        let mut sc = self.scratch.take().unwrap_or_default();
         for &(_, mode) in ranked.iter().take(3) {
             predict_intra(&ed, &e, mode, &mut pred);
-            let mut types = vec![DCT_DCT];
+            let mut types = [DCT_DCT; 2];
+            let mut n_types = 1;
             let alt = MODE_TO_TXFM[mode] as usize;
             if alt != DCT_DCT && tx_in_set(tx_set(tx_y, false), false, alt) {
-                types.push(alt);
+                types[1] = alt;
+                n_types = 2;
             }
-            for &t in &types {
-                let (res, recon) = self.try_tx(0, c * 4, r * 4, log2, t, &pred[..n * n], true);
+            for &t in &types[..n_types] {
+                let (res, has_recon) = self.try_tx(&mut sc, TransformBlock { plane: 0, x: c * 4, y: r * 4, log2, tx_type: t, intra: true }, &pred[..n * n]);
                 let type_bits = if !res.nonzero || tx_set(tx_y, false) == TX_SET_DCTONLY {
                     0.0
                 } else if t == DCT_DCT {
@@ -374,18 +432,24 @@ impl<'a> Decider<'a> {
                 let cost = res.dist + self.lambda * (res.bits + type_bits + mode_bits);
                 if best.as_ref().is_none_or(|b| cost < b.0) {
                     best_pred[..n * n].copy_from_slice(&pred[..n * n]);
-                    best = Some((cost, mode, t, res, recon));
+                    best_levels[..n * n].copy_from_slice(&sc.levels[..n * n]);
+                    if has_recon {
+                        best_recon[..n * n].copy_from_slice(&sc.recon[..n * n]);
+                    }
+                    best = Some((cost, mode, t, res, has_recon));
                 }
             }
         }
+        self.scratch = Some(sc);
         // Every ranked mode tries DCT_DCT, so `best` is always set; without a candidate the block
         // can't be coded intra (an infinite cost keeps it from being chosen).
-        let Some((_, y_mode, tx_type_y, ty, recon)) = best else {
+        let Some((_, y_mode, tx_type_y, ty, has_recon)) = best else {
             let leaf =
                 Leaf { bsize, is_inter: false, y_mode: DC_PRED, uv_mode: DC_PRED, tx_type_y: DCT_DCT, mv: [0, 0], skip: true, coefs: Default::default() };
             return (leaf, f64::INFINITY);
         };
-        self.put(0, c * 4, r * 4, n, recon.as_deref().unwrap_or(&best_pred[..n * n]));
+        self.put(0, c * 4, r * 4, n, if has_recon { &best_recon[..n * n] } else { &best_pred[..n * n] });
+        let ty = TxResult { levels: best_levels[..n * n].to_vec(), nonzero: ty.nonzero, dist: ty.dist, bits: ty.bits };
         let tx_type_y = if ty.nonzero { tx_type_y } else { DCT_DCT };
         self.mark_decoded(0, r, c, n4);
         // chroma (one mode for both planes)
@@ -422,7 +486,7 @@ impl<'a> Decider<'a> {
         let uv_type = intra_uv_tx_type(uv_mode, uv_tx);
         let mut code_uv = |i: usize| {
             predict_intra(&ced[i], &ce[i], uv_mode, &mut pred);
-            let t = self.code_tx(1 + i, c * 2, r * 2, clog2, uv_type, &pred[..cn * cn], true);
+            let t = self.code_tx(TransformBlock { plane: 1 + i, x: c * 2, y: r * 2, log2: clog2, tx_type: uv_type, intra: true }, &pred[..cn * cn]);
             self.mark_decoded(1 + i, r, c, n4);
             t
         };
@@ -450,13 +514,17 @@ impl<'a> Decider<'a> {
             let (vw, vh) = self.g.visible(p);
             let pn = n >> s;
             let (x, y) = ((c * 4) >> s, (r * 4) >> s);
-            predict_inter(&refr.planes[p], vw as i32 - 1, vh as i32 - 1, x, y, pn, pn, mv, s, self.bd, &mut pred[..pn * pn]);
+            predict_inter(
+                &refr.planes[p],
+                &InterBlock { last_x: vw as i32 - 1, last_y: vh as i32 - 1, x, y, width: pn, height: pn, mv, subsampling: s, bit_depth: self.bd },
+                &mut pred[..pn * pn],
+            );
             if bsize == BLOCK_64X64 {
                 // coded as a skip block: the prediction is the reconstruction
                 dist += self.sse(p, x, y, pn, &pred[..pn * pn]);
                 self.put(p, x, y, pn, &pred[..pn * pn]);
             } else {
-                let t = self.code_tx(p, x, y, log2 - s as u32, DCT_DCT, &pred[..pn * pn], false);
+                let t = self.code_tx(TransformBlock { plane: p, x, y, log2: log2 - s as u32, tx_type: DCT_DCT, intra: false }, &pred[..pn * pn]);
                 dist += t.dist;
                 tx.push(t);
             }
@@ -515,8 +583,9 @@ impl<'a> Decider<'a> {
             let (dy, dx) = (m[0] >> 3, m[1] >> 3);
             dx >= lim_x.0 && dx <= lim_x.1 && dy >= lim_y.0 && dy <= lim_y.1
         };
+        let lg = log2_table();
         let mv_bits = |m: [i32; 2]| -> f64 {
-            let comp = |d: i32| if d == 0 { 0.5 } else { 2.0 + 2.0 * ((d.abs() / 8) as f64 + 1.0).log2() };
+            let comp = |d: i32| if d == 0 { 0.5 } else { 2.0 + 2.0 * log2_of(lg, (d.abs() / 8) as usize + 1) };
             comp(m[0] - pred_mv[0]) + comp(m[1] - pred_mv[1])
         };
         let cost =
@@ -771,36 +840,48 @@ impl<'a> Decider<'a> {
 
     /// Transform, quantise and reconstruct one square transform block of `plane` at (x, y)
     /// over the prediction `pred`; the reconstruction is written to `rec`.
-    fn code_tx(&mut self, p: usize, x: usize, y: usize, log2: u32, tx_type: usize, pred: &[u16], intra: bool) -> TxResult {
-        let (res, recon) = self.try_tx(p, x, y, log2, tx_type, pred, intra);
+    fn code_tx(&mut self, block: TransformBlock, pred: &[u16]) -> TxResult {
+        let TransformBlock { plane: p, x, y, log2, .. } = block;
+        let mut sc = self.scratch.take().unwrap_or_default();
+        let (res, has_recon) = self.try_tx(&mut sc, block, pred);
         let n = 1usize << log2;
-        self.put(p, x, y, n, recon.as_deref().unwrap_or(pred));
-        res
+        self.put(p, x, y, n, if has_recon { &sc.recon[..n * n] } else { pred });
+        let levels = sc.levels[..n * n].to_vec();
+        self.scratch = Some(sc);
+        TxResult { levels, nonzero: res.nonzero, dist: res.dist, bits: res.bits }
     }
 
-    /// Transform and quantise one block; returns the result and its reconstruction (None: the
-    /// prediction) without writing it.
-    fn try_tx(&self, p: usize, x: usize, y: usize, log2: u32, tx_type: usize, pred: &[u16], intra: bool) -> (TxResult, Option<Vec<u16>>) {
+    /// Transform and quantise one block without writing it. The levels are left in `sc.levels`;
+    /// the flag tells whether `sc.recon` holds the reconstruction (false: it is the prediction).
+    fn try_tx(&self, sc: &mut TxScratch, block: TransformBlock, pred: &[u16]) -> (TxEval, bool) {
+        let TransformBlock { plane: p, x, y, log2, tx_type, intra } = block;
         let n = 1usize << log2;
+        let nn = n * n;
         let tx_sz = tx_size_for(log2);
         let bd = self.bd;
         let src = &self.src[p];
-        let mut res = vec![0i32; n * n];
+        let TxScratch { res, coef, levels, deq, resid, recon } = sc;
+        let (res, coef, levels) = (&mut res[..nn], &mut coef[..nn], &mut levels[..nn]);
         for i in 0..n {
             let row = &src.row(y + i)[x..x + n];
             for j in 0..n {
                 res[i * n + j] = row[j] as i32 - pred[i * n + j] as i32;
             }
         }
-        let mut coef = vec![0f32; n * n];
-        forward_2d(&res, &mut coef, n, tx_type);
+        forward_2d(res, coef, n, tx_type);
         // dead-zone quantiser: rounding offset below one half
-        let rnd = if intra { 0.38f32 } else { 0.30f32 };
-        let mut levels = vec![0i32; n * n];
+        let rnd = if intra { INTRA_RND } else { INTER_RND };
+        let [dc_thr, ac_thr] = [self.dead_zone[0][intra as usize], self.dead_zone[1][intra as usize]];
+        levels.fill(0);
         let mut nonzero = false;
         for (k, (&cf, l)) in coef.iter().zip(levels.iter_mut()).enumerate() {
-            let q = if k == 0 { self.dc_q } else { self.ac_q };
-            let a = (cf.abs() / q + rnd).floor() as i32;
+            let (q, thr) = if k == 0 { (self.dc_q, dc_thr) } else { (self.ac_q, ac_thr) };
+            // dead zone: below the exact threshold the level is zero, no division needed
+            if cf.abs() < thr {
+                continue;
+            }
+            // the operand is >= 0, so truncation equals floor
+            let a = (cf.abs() / q + rnd) as i32;
             if a != 0 {
                 *l = if cf < 0.0 { -a.min(1 << 16) } else { a.min(1 << 16) };
                 nonzero = true;
@@ -808,23 +889,26 @@ impl<'a> Decider<'a> {
         }
         let zero_dist = self.sse(p, x, y, n, pred);
         if !nonzero {
-            return (TxResult { levels, nonzero, dist: zero_dist, bits: 1.0 }, None);
+            return (TxEval { nonzero, dist: zero_dist, bits: 1.0 }, false);
         }
-        let recon = self.reconstruct(&levels, tx_sz, tx_type, pred, n, bd);
-        let dist = self.sse(p, x, y, n, &recon);
-        let bits = estimate_bits(&levels, tx_sz);
+        let recon = &mut recon[..nn];
+        self.reconstruct(levels, ReconBuffers { deq: &mut deq[..nn], resid: &mut resid[..nn], recon }, tx_sz, tx_type, pred, bd);
+        let dist = self.sse(p, x, y, n, recon);
+        let bits = estimate_bits(levels, tx_sz);
         if dist + self.lambda * bits >= zero_dist + self.lambda {
-            levels.iter_mut().for_each(|l| *l = 0);
-            return (TxResult { levels, nonzero: false, dist: zero_dist, bits: 1.0 }, None);
+            levels.fill(0);
+            return (TxEval { nonzero: false, dist: zero_dist, bits: 1.0 }, false);
         }
-        (TxResult { levels, nonzero: true, dist, bits }, Some(recon))
+        (TxEval { nonzero: true, dist, bits }, true)
     }
 
-    /// Dequantisation (7.12.3) and the inverse transform, added to the prediction.
-    fn reconstruct(&self, levels: &[i32], tx_sz: usize, tx_type: usize, pred: &[u16], n: usize, bd: u32) -> Vec<u16> {
+    /// Dequantisation (7.12.3) and the inverse transform, added to the prediction; the result is
+    /// written to `recon`. `deq` and `resid` are scratch buffers of `n * n` entries.
+    fn reconstruct(&self, levels: &[i32], bufs: ReconBuffers, tx_sz: usize, tx_type: usize, pred: &[u16], bd: u32) {
+        let ReconBuffers { deq, resid, recon } = bufs;
         let denom: i64 = if tx_sz == TX_32X32 { 2 } else { 1 };
         let lim = 1i64 << (7 + bd);
-        let mut deq = vec![0i32; n * n];
+        deq.fill(0);
         for (k, (&l, d)) in levels.iter().zip(deq.iter_mut()).enumerate() {
             if l == 0 {
                 continue;
@@ -834,13 +918,41 @@ impl<'a> Decider<'a> {
             let mag = (dq.abs() & 0xFF_FFFF) / denom;
             *d = (if dq < 0 { -mag } else { mag }).clamp(-lim, lim - 1) as i32;
         }
-        let mut resid = vec![0i32; n * n];
-        inverse_2d(&deq, &mut resid, tx_sz, tx_type, bd);
+        inverse_2d(deq, resid, tx_sz, tx_type, bd);
         let max = (1i32 << bd) - 1;
-        pred.iter().zip(&resid).map(|(&p, &r)| (p as i32 + r).clamp(0, max) as u16).collect()
+        for ((o, &p), &r) in recon.iter_mut().zip(pred).zip(resid.iter()) {
+            *o = (p as i32 + r).clamp(0, max) as u16;
+        }
     }
 }
 
+/// Smallest `x >= 0` with `(x / q + rnd) as i32 >= 1` in f32 arithmetic. The expression is
+/// monotone in `x`, so a binary search over the bit patterns finds the exact boundary.
+fn zero_threshold(q: f32, rnd: f32) -> f32 {
+    let (mut lo, mut hi) = (0u32, f32::MAX.to_bits());
+    while lo < hi {
+        let mid = lo + (hi - lo) / 2;
+        if (f32::from_bits(mid) / q + rnd) as i32 >= 1 {
+            hi = mid;
+        } else {
+            lo = mid + 1;
+        }
+    }
+    f32::from_bits(lo)
+}
+
+const LOG2_TABLE_LEN: usize = 1025;
+
+/// `log2(i)` for `i < LOG2_TABLE_LEN`, computed with the same `f64::log2` call as the direct form.
+fn log2_table() -> &'static [f64; LOG2_TABLE_LEN] {
+    static TABLE: std::sync::OnceLock<[f64; LOG2_TABLE_LEN]> = std::sync::OnceLock::new();
+    TABLE.get_or_init(|| std::array::from_fn(|i| (i as f64).log2()))
+}
+
+fn log2_of(table: &[f64; LOG2_TABLE_LEN], v: usize) -> f64 {
+    if v < LOG2_TABLE_LEN { table[v] } else { (v as f64).log2() }
+}
+
 /// Unnormalised Walsh-Hadamard transform of 4 or 8 values, in place.
 fn hadamard(v: &mut [i32]) {
     let n = v.len();
@@ -869,13 +981,14 @@ fn estimate_bits(levels: &[i32], tx_sz: usize) -> f64 {
     if eob == 0 {
         return 1.0;
     }
-    let mut bits = 3.0 + (eob as f64).log2();
+    let lg = log2_table();
+    let mut bits = 3.0 + log2_of(lg, eob);
     for &pos in &scan[..eob] {
         let a = levels[pos as usize].unsigned_abs();
         bits += match a {
             0 => 0.7,
             1 => 2.5,
-            _ => 3.5 + 1.6 * (a as f64).log2(),
+            _ => 3.5 + 1.6 * log2_of(lg, a as usize),
         };
     }
     bits
@@ -889,3 +1002,64 @@ pub(crate) fn scan_for(tx_sz: usize) -> &'static [u16] {
         _ => &DEFAULT_SCAN_32X32,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::tables::{AC_QLOOKUP, DC_QLOOKUP};
+
+    /// The quantiser as it was before the dead-zone threshold and the truncation.
+    fn quant_ref(cf: f32, q: f32, rnd: f32) -> i32 {
+        (cf.abs() / q + rnd).floor() as i32
+    }
+
+    fn quant_new(cf: f32, q: f32, rnd: f32, thr: f32) -> i32 {
+        if cf.abs() < thr {
+            return 0;
+        }
+        (cf.abs() / q + rnd) as i32
+    }
+
+    #[test]
+    fn dead_zone_threshold_is_exact() {
+        let mut state = 0x1234_5678_9abc_def0u64;
+        let mut next = move || {
+            state ^= state << 13;
+            state ^= state >> 7;
+            state ^= state << 17;
+            state
+        };
+        for table in AC_QLOOKUP.iter().chain(DC_QLOOKUP.iter()) {
+            for &qi in table.iter() {
+                let q = qi as f32;
+                for rnd in [INTER_RND, INTRA_RND] {
+                    let thr = zero_threshold(q, rnd);
+                    // the boundary itself and its neighbours
+                    let b = thr.to_bits();
+                    for bits in b.saturating_sub(3)..=b + 3 {
+                        let cf = f32::from_bits(bits);
+                        assert_eq!(quant_ref(cf, q, rnd), quant_new(cf, q, rnd, thr), "q {q} rnd {rnd} cf {cf}");
+                        assert_eq!(quant_ref(-cf, q, rnd), quant_new(-cf, q, rnd, thr));
+                    }
+                    for _ in 0..200 {
+                        let cf = f32::from_bits((next() >> 32) as u32 & 0x7fff_ffff);
+                        if cf.is_nan() {
+                            continue;
+                        }
+                        assert_eq!(quant_ref(cf, q, rnd), quant_new(cf, q, rnd, thr));
+                        let cf = (next() % 100_000) as f32 / 100.0;
+                        assert_eq!(quant_ref(cf, q, rnd), quant_new(cf, q, rnd, thr));
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn log2_table_matches_direct_log2() {
+        let t = log2_table();
+        for v in 1..3000usize {
+            assert_eq!(log2_of(t, v).to_bits(), (v as f64).log2().to_bits(), "{v}");
+        }
+    }
+}
diff --git a/crates/av1enc/src/lib.rs b/crates/av1enc/src/lib.rs
index 6b1edfbe8..b86db0fa2 100644
--- a/crates/av1enc/src/lib.rs
+++ b/crates/av1enc/src/lib.rs
@@ -24,6 +24,7 @@ use bitw::{BitWriter, obu};
 use decide::{Decider, FrameGeom, RefFrame};
 use loopfilter::{LfInfo, loop_filter};
 use pred::Plane;
+use tables::AC_QLOOKUP;
 use writer::TileWriter;
 
 /// Rate control.
@@ -136,10 +137,118 @@ struct RateState {
     frame_bits: f64,
     /// Quantizer index for inter frames (continuous).
     q: f64,
+    /// Key frame quantizer index minus the inter frame one.
+    key_off: f64,
+    /// Quantizer index steps per halving of the frame size, measured from consecutive inter
+    /// frames (the size/quantizer curve is much steeper than the default on noisy content).
+    slope: f64,
+    /// Quantizer index and size (in bits) of the previous inter frame.
+    prev_inter: Option<(f64, f64)>,
     /// Accumulated (spent - budget) bits.
     debt: f64,
 }
 
+/// Quantizer index steps per halving of the frame size before any measurement.
+const RC_SLOPE: f64 = 28.0;
+/// Fraction of the quantizer step the size error asks for that is applied per frame.
+const RC_GAIN: f64 = 0.8;
+/// Frames over which an accumulated deviation from the budget is paid back.
+const RC_PAYBACK: f64 = 16.0;
+
+impl RateState {
+    /// The nominal bit budget and the starting quantizer index of a key or inter frame. A key
+    /// frame gets a larger share, and the inter frames of the group get the rest, so that a whole
+    /// group of `keyint` frames adds up to `keyint * frame_bits`.
+    fn frame_budget(&self, keyint: u32, key: bool) -> (f64, f64) {
+        let keyint = keyint.max(1) as f64;
+        let boost = (1.0 + (keyint.clamp(1.0, 60.0) - 1.0).sqrt() * 0.75).min(0.5 * keyint + 0.5);
+        if key {
+            (self.frame_bits * boost, (self.q + self.key_off).clamp(1.0, 255.0))
+        } else if keyint > 1.0 {
+            (self.frame_bits * (keyint - boost) / (keyint - 1.0), self.q)
+        } else {
+            (self.frame_bits, self.q)
+        }
+    }
+
+    /// Adapts the quantizers to the size of the frame just coded at `q_used` against `target`.
+    fn update(&mut self, key: bool, first: bool, q_used: f64, bits: f64, target: f64) {
+        let err = (bits / target).log2().clamp(-1.5, 1.5);
+        if first && key {
+            // four passes ran: the key frame quantizer is known, the inter one follows from the offset
+            self.q = (q_used - self.key_off).clamp(1.0, 255.0);
+        } else if key {
+            self.key_off = q_used - self.q + RC_GAIN * self.slope * err;
+        } else {
+            if let Some((pq, pbits)) = self.prev_inter {
+                let (dq, dr) = (q_used - pq, (pbits / bits).log2());
+                if dq.abs() >= 3.0 && dr.abs() >= 0.15 && dq * dr > 0.0 {
+                    self.slope = (0.6 * self.slope + 0.4 * (dq / dr)).clamp(3.0, 45.0);
+                }
+            }
+            self.prev_inter = Some((q_used, bits));
+            self.q = (q_used + RC_GAIN * self.slope * err).clamp(1.0, 255.0);
+        }
+    }
+}
+
+/// Most passes on the first frame, and how far from the target (octaves, 3 %) its size may be
+/// before it is accepted.
+const RC_FIRST_PASSES: usize = 4;
+const RC_FIRST_TOLERANCE: f64 = 0.04;
+/// Quantizer index steps per halving of the size, for the first correction of the first frame
+/// (the starting quantizer comes from the bits per sample; the first pass shows how far off it
+/// is, and from there on the passes are placed by `next_probe_q`).
+const RC_FIRST_SLOPE: f64 = 30.0;
+/// The same for a key frame after the first: coded again when its size is more than 0.25 octaves
+/// (19 %) off the target.
+const RC_KEY_PASSES: usize = 3;
+const RC_KEY_TOLERANCE: f64 = 0.25;
+/// Octaves of frame size per octave of quantizer step assumed for the first correction of a frame.
+const RC_PROBE_SLOPE: f64 = 1.0;
+/// Largest change of the quantizer step (octaves) between two passes on one frame.
+const RC_PROBE_MAX_STEP: f64 = 2.0;
+
+/// The quantizer index whose step size is closest to `2^x`.
+fn q_for_step(bit_depth: u8, x: f64) -> u8 {
+    let table = &AC_QLOOKUP[((bit_depth - 8) / 2) as usize];
+    let mut best = 1;
+    for q in 1..=255usize {
+        if ((table[q] as f64).log2() - x).abs() < ((table[best] as f64).log2() - x).abs() {
+            best = q;
+        }
+    }
+    best as u8
+}
+
+/// The next quantizer to try for a frame, from the `(quantizer, log2(size / target))`
+/// pairs coded so far. The size follows the quantizer step (not the index, which is linear in the
+/// step only below about 60) in a near log-log line: false position between the closest pair of
+/// passes that enclose the target, otherwise a step from the latest one with the slope of the
+/// last two. `None` when no untried quantizer lies between the enclosing passes.
+fn next_probe_q(bit_depth: u8, tried: &[(u8, f64)]) -> Option<u8> {
+    let table = &AC_QLOOKUP[((bit_depth - 8) / 2) as usize];
+    let x = |q: u8| (table[q as usize] as f64).log2();
+    let over = tried.iter().filter(|t| t.1 > 0.0).max_by_key(|t| t.0);
+    let under = tried.iter().filter(|t| t.1 <= 0.0).min_by_key(|t| t.0);
+    if let (Some(&(q_lo, e_lo)), Some(&(q_hi, e_hi))) = (over, under) {
+        if q_hi - q_lo < 2 {
+            return None;
+        }
+        let next = x(q_lo) + (x(q_hi) - x(q_lo)) * e_lo / (e_lo - e_hi);
+        return Some(q_for_step(bit_depth, next).clamp(q_lo + 1, q_hi - 1));
+    }
+    let &(q, err) = tried.last()?;
+    let mut slope = RC_PROBE_SLOPE;
+    if let [.., (q0, e0), (q1, e1)] = tried
+        && (x(*q1) - x(*q0)).abs() > 0.05
+        && (e0 - e1) / (x(*q1) - x(*q0)) > 0.0
+    {
+        slope = ((e0 - e1) / (x(*q1) - x(*q0))).clamp(0.25, 3.0);
+    }
+    Some(q_for_step(bit_depth, x(q) + (err / slope).clamp(-RC_PROBE_MAX_STEP, RC_PROBE_MAX_STEP)))
+}
+
 /// AV1 encoder. Frames come out in input order (no hidden/reordered frames).
 pub struct Encoder {
     cfg: EncoderConfig,
@@ -185,7 +294,7 @@ impl Encoder {
                 // initial guess from the bits per sample
                 let bpp = frame_bits / (cfg.width as f64 * cfg.height as f64);
                 let q = (110.0 - 40.0 * (bpp / 0.1).log2()).clamp(20.0, 230.0);
-                Some(RateState { frame_bits, q, debt: 0.0 })
+                Some(RateState { frame_bits, q, key_off: -24.0, slope: RC_SLOPE, prev_inter: None, debt: 0.0 })
             }
         };
         let mut enc = Encoder { cfg, geom, level, seq_obu: Vec::new(), frame_num: 0, refr: None, rc };
@@ -409,11 +518,13 @@ impl Encoder {
         };
         let bd = self.cfg.bit_depth as u32;
         let mut cache: Vec<(u32, u64)> = vec![(0, sse(&rec[0]))];
+        // one working copy of the luma plane for all candidate levels
+        let mut planes = [rec[0].clone(), Plane::new(0, 0), Plane::new(0, 0)];
         let mut eval = |lvl: u32| -> u64 {
             if let Some(&(_, e)) = cache.iter().find(|(l, _)| *l == lvl) {
                 return e;
             }
-            let mut planes = [rec[0].clone(), Plane::new(0, 0), Plane::new(0, 0)];
+            planes[0].data.copy_from_slice(&rec[0].data);
             loop_filter(&mut planes, info, [lvl; 4], bd, true, sb_row_step);
             let e = sse(&planes[0]);
             cache.push((lvl, e));
@@ -469,38 +580,52 @@ impl Encoder {
 
     fn encode_rate_controlled(&mut self, src: &[Plane; 3], key: bool, rc: &mut RateState) -> (Vec<u8>, RefFrame) {
         let first = self.frame_num == 0;
-        let (frame_bits, debt, q_inter) = (rc.frame_bits, rc.debt, rc.q);
-        // key frames get a lower quantizer and a larger share of the budget
-        let key_boost = 1.0 + (self.cfg.keyint.clamp(1, 60) as f64 - 1.0).sqrt() * 0.75;
-        let budget = if key { frame_bits * key_boost } else { frame_bits };
-        // pay back a fraction of the accumulated deviation
-        let target = (budget - debt * 0.25).max(budget * 0.25);
-        let mut q = if key { q_inter - 24.0 } else { q_inter };
-        let mut best: Option<(Vec<u8>, RefFrame, f64)> = None;
-        let passes = if first { 4 } else { 1 };
-        for pass in 0..passes {
+        let (budget, q_start) = rc.frame_budget(self.cfg.keyint, key);
+        // pay back the accumulated deviation over the next RC_PAYBACK frames
+        let target = (budget - rc.debt / RC_PAYBACK).clamp(budget * 0.35, budget * 2.0);
+        let mut q = q_start;
+        let mut best: Option<(Vec<u8>, RefFrame, f64, f64)> = None;
+        // The first frame is coded up to four times to find its quantizer (it fixes the
+        // quantizers of everything after it), a later key frame up to three times (it is a large
+        // part of the budget of its group). A frame is coded again only while its size is far from
+        // the target and an untried quantizer is left to try; other frames are coded once.
+        let (max_passes, tolerance) = if first {
+            (RC_FIRST_PASSES, RC_FIRST_TOLERANCE)
+        } else if key {
+            (RC_KEY_PASSES, RC_KEY_TOLERANCE)
+        } else {
+            (1, 0.0)
+        };
+        let mut tried: Vec<(u8, f64)> = Vec::new();
+        for _ in 0..max_passes {
             let qi = q.round().clamp(1.0, 255.0) as u8;
+            if tried.iter().any(|t| t.0 == qi) {
+                break;
+            }
             let (obu, rf) = self.encode_frame(src, key, qi);
             let bits = obu.len() as f64 * 8.0;
             let err = (bits / target).log2();
-            let better = best.as_ref().is_none_or(|b| err.abs() < (b.2 / target).log2().abs());
-            if better {
-                best = Some((obu, rf, bits));
+            tried.push((qi, err));
+            if best.as_ref().is_none_or(|b| err.abs() < (b.2 / target).log2().abs()) {
+                best = Some((obu, rf, bits, qi as f64));
             }
-            if pass + 1 < passes {
-                q = (q + 30.0 * err).clamp(1.0, 255.0);
+            if err.abs() <= tolerance {
+                break;
+            }
+            let next = if first && tried.len() == 1 {
+                Some((q + RC_FIRST_SLOPE * err).clamp(1.0, 255.0))
+            } else {
+                next_probe_q(self.cfg.bit_depth, &tried).map(f64::from)
+            };
+            match next {
+                Some(next) => q = next,
+                None => break,
             }
         }
         // At least one pass ran, so `best` is set.
-        let Some((obu, rf, bits)) = best else { return self.encode_frame(src, key, q.round().clamp(1.0, 255.0) as u8) };
+        let Some((obu, rf, bits, q_used)) = best else { return self.encode_frame(src, key, q.round().clamp(1.0, 255.0) as u8) };
         rc.debt += bits - budget;
-        // adapt the inter quantizer: about 30 index steps per doubling of the rate
-        let err = (bits / target).log2().clamp(-1.0, 1.0);
-        if first && key {
-            rc.q = (q + 24.0).clamp(1.0, 255.0);
-        } else {
-            rc.q = (rc.q + 12.0 * err).clamp(1.0, 255.0);
-        }
+        rc.update(key, first, q_used, bits, target);
         (obu, rf)
     }
 
diff --git a/crates/av1enc/src/loopfilter.rs b/crates/av1enc/src/loopfilter.rs
index 2add41edc..cf350fbd2 100644
--- a/crates/av1enc/src/loopfilter.rs
+++ b/crates/av1enc/src/loopfilter.rs
@@ -3,7 +3,7 @@
 //! is 0 in the frames this encoder writes.
 
 use crate::pred::Plane;
-use crate::tables::*;
+use crate::tables::{MAX_LOOP_FILTER, NUM_4X4_BLOCKS_HIGH, NUM_4X4_BLOCKS_WIDE, SUBSAMPLED_SIZE, TX_HEIGHT, TX_WIDTH};
 
 /// Mode info the loop filter reads (per 4x4 luma unit, row stride `mi_cols`), and the
 /// transform size per 4x4 unit of each plane (`LoopfilterTxSizes`, row stride `mi_cols + 32`).
@@ -39,7 +39,7 @@ pub(crate) fn loop_filter(planes: &mut [Plane; 3], info: &LfInfo, level: [u32; 4
                 }
                 let mut col = 0;
                 while col < info.mi_cols {
-                    edge(pl, info, level, bit_depth, plane, pass, row, col);
+                    edge(pl, info, level, bit_depth, plane, pass, (row, col));
                     col += step;
                 }
                 row += step;
@@ -48,7 +48,8 @@ pub(crate) fn loop_filter(planes: &mut [Plane; 3], info: &LfInfo, level: [u32; 4
     }
 }
 
-fn edge(pl: &mut Plane, info: &LfInfo, level: [u32; 4], bd: u32, plane: usize, pass: usize, row: usize, col: usize) {
+fn edge(pl: &mut Plane, info: &LfInfo, level: [u32; 4], bd: u32, plane: usize, pass: usize, position: (usize, usize)) {
+    let (row, col) = position;
     let s = (plane > 0) as usize;
     let (dx, dy) = if pass == 0 { (1usize, 0usize) } else { (0, 1) };
     let x = col * 4;
@@ -88,13 +89,24 @@ fn edge(pl: &mut Plane, info: &LfInfo, level: [u32; 4], bd: u32, plane: usize, p
     let limit = lvl.max(1);
     let blimit = 2 * (lvl + 2) + limit;
     let thresh = lvl >> 4;
+    let strength = FilterStrength { limit, blimit, thresh };
     for k in 0..4 {
-        sample_filter(pl, xp + dy * k, yp + dx * k, plane, limit, blimit, thresh, dx as isize, dy as isize, filter_size, bd);
+        sample_filter(pl, (xp + dy * k, yp + dx * k), plane, &strength, (dx as isize, dy as isize), filter_size, bd);
     }
 }
 
+/// Thresholds derived from the loop-filter level (spec 7.14.4).
+struct FilterStrength {
+    limit: i32,
+    blimit: i32,
+    thresh: i32,
+}
+
 #[inline]
-fn sample_filter(pl: &mut Plane, x: usize, y: usize, plane: usize, limit: i32, blimit: i32, thresh: i32, dx: isize, dy: isize, filter_size: usize, bd: u32) {
+fn sample_filter(pl: &mut Plane, position: (usize, usize), plane: usize, strength: &FilterStrength, direction: (isize, isize), filter_size: usize, bd: u32) {
+    let (x, y) = position;
+    let (dx, dy) = direction;
+    let FilterStrength { limit, blimit, thresh } = *strength;
     let stride = pl.stride as isize;
     let step = dy * stride + dx;
     let base = y as isize * stride + x as isize;
diff --git a/crates/av1enc/src/pred.rs b/crates/av1enc/src/pred.rs
index d61a6fa94..b899202f4 100644
--- a/crates/av1enc/src/pred.rs
+++ b/crates/av1enc/src/pred.rs
@@ -2,7 +2,10 @@
 //! modes plus V_PRED / H_PRED without edge filtering, 7.11.3 block inter prediction without
 //! reference scaling) so that the encoder predicts exactly like a decoder.
 
-use crate::tables::*;
+use crate::tables::{
+    DC_PRED, EIGHTTAP, H_PRED, PAETH_PRED, SM_WEIGHTS_TX_4X4, SM_WEIGHTS_TX_8X8, SM_WEIGHTS_TX_16X16, SM_WEIGHTS_TX_32X32, SMOOTH_H_PRED, SMOOTH_PRED,
+    SMOOTH_V_PRED, SUBPEL_FILTERS, V_PRED,
+};
 use crate::transform::round2;
 
 /// A plane buffer (padded to whole superblocks).
@@ -184,19 +187,20 @@ pub(crate) fn predict_intra(ed: &Edges, e: &IntraEdge, mode: usize, pred: &mut [
 /// final rounding is the identity) of the `w x h` block at plane position (x, y) displaced by
 /// `mv` (1/8 luma sample units, [row, col]). `last_x` / `last_y` are the largest sample
 /// coordinates of the reference plane; the result goes to `pred` (row stride `w`).
-pub(crate) fn predict_inter(
-    refp: &Plane,
-    last_x: i32,
-    last_y: i32,
-    x: usize,
-    y: usize,
-    w: usize,
-    h: usize,
-    mv: [i32; 2],
-    ss: usize,
-    bit_depth: u32,
-    pred: &mut [u16],
-) {
+pub(crate) struct InterBlock {
+    pub last_x: i32,
+    pub last_y: i32,
+    pub x: usize,
+    pub y: usize,
+    pub width: usize,
+    pub height: usize,
+    pub mv: [i32; 2],
+    pub subsampling: usize,
+    pub bit_depth: u32,
+}
+
+pub(crate) fn predict_inter(refp: &Plane, block: &InterBlock, pred: &mut [u16]) {
+    let InterBlock { last_x, last_y, x, y, width: w, height: h, mv, subsampling: ss, bit_depth } = *block;
     // positions in 1/16 sample units ((startX >> 6) & 15 is the filter phase)
     let px = ((x as i32) << 4) + ((2 * mv[1]) >> ss);
     let py = ((y as i32) << 4) + ((2 * mv[0]) >> ss);
@@ -293,7 +297,8 @@ pub(crate) fn predict_inter(
 
 /// The visible `w x h` area of a reference plane interpolated at the sub-sample phase
 /// (`fx`, `fy`) (1/16 units) with the EIGHTTAP filter, as `predict_inter` computes it for
-/// blocks wider and taller than 4. Used for motion search.
+/// blocks wider and taller than 4. The reference for `half_planes`, which the encoder uses.
+#[cfg(test)]
 pub(crate) fn subpel_plane(refp: &Plane, w: usize, h: usize, fx: usize, fy: usize, bit_depth: u32) -> Vec<u16> {
     let kh = &SUBPEL_FILTERS[EIGHTTAP][fx];
     let kv = &SUBPEL_FILTERS[EIGHTTAP][fy];
@@ -323,6 +328,66 @@ pub(crate) fn subpel_plane(refp: &Plane, w: usize, h: usize, fx: usize, fy: usiz
     out
 }
 
+/// The three half-sample planes (8, 0), (0, 8), (8, 8) of `subpel_plane` in one pass: the
+/// horizontal half-sample pass is shared by (8, 0) and (8, 8), and the phase-0 kernels reduce to
+/// exact shifts (Round2( 128 * v, 11 ) = Round2( v, 4 ), Round2( 16 * s, 11 ) = Round2( s, 7 )),
+/// so the result equals three `subpel_plane` calls bit for bit.
+pub(crate) fn half_planes(refp: &Plane, w: usize, h: usize, bit_depth: u32) -> [Vec<u16>; 3] {
+    let k = &SUBPEL_FILTERS[EIGHTTAP][8];
+    let max = (1i32 << bit_depth) - 1;
+    let (lx, ly) = (w as i32 - 1, h as i32 - 1);
+    // horizontal pass at phase 8: Round2( sum, 3 )
+    let mut hp = vec![0i32; w * h];
+    for y in 0..h {
+        let row = &refp.row(y)[..w];
+        let out = &mut hp[y * w..y * w + w];
+        let tap = |x: i32| -> i32 {
+            let mut s = 0i32;
+            for t in 0..8 {
+                s += k[t] as i32 * row[(x + t as i32 - 3).clamp(0, lx) as usize] as i32;
+            }
+            round2(s, 3)
+        };
+        if w >= 8 {
+            for x in 0..3 {
+                out[x] = tap(x as i32);
+            }
+            for (x, o) in out.iter_mut().enumerate().take(w - 4).skip(3) {
+                let seg = &row[x - 3..x + 5];
+                let mut s = 0i32;
+                for t in 0..8 {
+                    s += k[t] as i32 * seg[t] as i32;
+                }
+                *o = round2(s, 3);
+            }
+            for x in w - 4..w {
+                out[x] = tap(x as i32);
+            }
+        } else {
+            for (x, o) in out.iter_mut().enumerate() {
+                *o = tap(x as i32);
+            }
+        }
+    }
+    let p80: Vec<u16> = hp.iter().map(|&v| round2(v, 4).clamp(0, max) as u16).collect();
+    let mut p08 = vec![0u16; w * h];
+    let mut p88 = vec![0u16; w * h];
+    for y in 0..h {
+        let rows: [usize; 8] = std::array::from_fn(|t| (y as i32 + t as i32 - 3).clamp(0, ly) as usize);
+        let (o08, o88) = (&mut p08[y * w..y * w + w], &mut p88[y * w..y * w + w]);
+        for x in 0..w {
+            let (mut a, mut b) = (0i32, 0i32);
+            for t in 0..8 {
+                a += k[t] as i32 * refp.data[rows[t] * refp.stride + x] as i32;
+                b += k[t] as i32 * hp[rows[t] * w + x];
+            }
+            o08[x] = round2(a, 7).clamp(0, max) as u16;
+            o88[x] = round2(b, 11).clamp(0, max) as u16;
+        }
+    }
+    [p80, p08, p88]
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -340,7 +405,11 @@ mod tests {
             for (bx, by) in [(0i32, 0i32), (8, 8), (24, 16), (-5, 20), (30, -3)] {
                 let mut pred = vec![0u16; 64];
                 let mv = [by * 8 + fy as i32 / 2, bx * 8 + fx as i32 / 2];
-                predict_inter(&p, w as i32 - 1, h as i32 - 1, 0, 0, 8, 8, mv, 0, 8, &mut pred);
+                predict_inter(
+                    &p,
+                    &InterBlock { last_x: w as i32 - 1, last_y: h as i32 - 1, x: 0, y: 0, width: 8, height: 8, mv, subsampling: 0, bit_depth: 8 },
+                    &mut pred,
+                );
                 for r in 0..8 {
                     for c in 0..8 {
                         let (x, y) = ((bx + c).clamp(0, w as i32 - 1), (by + r).clamp(0, h as i32 - 1));
@@ -353,6 +422,20 @@ mod tests {
         }
     }
 
+    #[test]
+    fn half_planes_match_subpel_plane() {
+        for (w, h) in [(37usize, 29usize), (5, 3), (1, 1), (64, 64)] {
+            let mut p = Plane::new(64, 64);
+            for (i, v) in p.data.iter_mut().enumerate() {
+                *v = ((i * 7919) % 1024) as u16;
+            }
+            let hp = half_planes(&p, w, h, 10);
+            for (i, (fx, fy)) in [(8, 0), (0, 8), (8, 8)].into_iter().enumerate() {
+                assert_eq!(hp[i], subpel_plane(&p, w, h, fx, fy, 10), "{w}x{h} phase ({fx}, {fy})");
+            }
+        }
+    }
+
     #[test]
     fn phase_zero_filters_are_impulses() {
         for f in SUBPEL_FILTERS.iter() {
diff --git a/crates/av1enc/src/transform.rs b/crates/av1enc/src/transform.rs
index 90042e26a..9d81ead0b 100644
--- a/crates/av1enc/src/transform.rs
+++ b/crates/av1enc/src/transform.rs
@@ -4,7 +4,7 @@
 
 use std::sync::OnceLock;
 
-use crate::tables::*;
+use crate::tables::{ADST_ADST, ADST_DCT, COS128_LOOKUP, DCT_ADST, DCT_DCT, TRANSFORM_ROW_SHIFT, TX_WIDTH_LOG2};
 
 #[inline(always)]
 fn round2_64(x: i64, n: u32) -> i32 {
@@ -32,6 +32,7 @@ fn sin128(angle: i32) -> i64 {
     cos128(angle - 64)
 }
 
+#[inline(always)]
 fn brev(num_bits: u32, x: usize) -> usize {
     let mut t = 0;
     for i in 0..num_bits {
@@ -63,14 +64,24 @@ fn hd(t: &mut [i32], a: usize, b: usize, flip: bool, r: u32) {
     t[b] = (x - y).clamp(lo, hi);
 }
 
-/// Inverse DCT of length 2^n, n = 2..=5 (7.13.2.3), in place.
-fn inverse_dct(t: &mut [i32], n: u32, r: u32) {
+/// Inverse DCT of length 2^N, N = 2..=5 (7.13.2.3), in place. `N` is a const generic so that the
+/// bit-reversal permutations and loop bounds fold at compile time.
+#[inline(always)]
+fn inverse_dct_n<const N: u32>(t: &mut [i32], r: u32) {
+    let n = N;
     let len = 1usize << n;
     let mut copy = [0i32; 32];
     copy[..len].copy_from_slice(&t[..len]);
     for i in 0..len {
         t[i] = copy[brev(n, i)];
     }
+    inverse_dct_initial_stages(t, n, r);
+    inverse_dct_final_stages(t, n, r);
+}
+
+/// Rotate the high-frequency branches before the four-point core.
+#[inline(always)]
+fn inverse_dct_initial_stages(t: &mut [i32], n: u32, r: u32) {
     if n >= 5 {
         for i in 0..8 {
             bf(t, 16 + i, 31 - i, 6 + ((brev(3, 7 - i) as i32) << 3), false);
@@ -103,6 +114,11 @@ fn inverse_dct(t: &mut [i32], n: u32, r: u32) {
             }
         }
     }
+}
+
+/// Evaluate the four-point core and merge progressively larger branches.
+#[inline(always)]
+fn inverse_dct_final_stages(t: &mut [i32], n: u32, r: u32) {
     for i in 0..2 {
         bf(t, 2 * i, 2 * i + 1, 32 + 16 * i as i32, i == 0);
     }
@@ -180,6 +196,7 @@ const SINPI_2_9: i64 = 2482;
 const SINPI_3_9: i64 = 3344;
 const SINPI_4_9: i64 = 3803;
 
+#[inline(always)]
 fn inverse_adst4(t: &mut [i32]) {
     let (t0, t1, t2, t3) = (t[0] as i64, t[1] as i64, t[2] as i64, t[3] as i64);
     let mut s = [SINPI_1_9 * t0, SINPI_2_9 * t0, SINPI_3_9 * t1, SINPI_4_9 * t2, SINPI_1_9 * t2, SINPI_2_9 * t3, SINPI_4_9 * t3];
@@ -197,7 +214,9 @@ fn inverse_adst4(t: &mut [i32]) {
     }
 }
 
-fn adst_in_permute(t: &mut [i32], n: u32) {
+#[inline(always)]
+fn adst_in_permute<const N: u32>(t: &mut [i32]) {
+    let n = N;
     let n0 = 1usize << n;
     let mut copy = [0i32; 16];
     copy[..n0].copy_from_slice(&t[..n0]);
@@ -207,7 +226,9 @@ fn adst_in_permute(t: &mut [i32], n: u32) {
     }
 }
 
-fn adst_out_permute(t: &mut [i32], n: u32) {
+#[inline(always)]
+fn adst_out_permute<const N: u32>(t: &mut [i32]) {
+    let n = N;
     let n0 = 1usize << n;
     let mut copy = [0i32; 16];
     copy[..n0].copy_from_slice(&t[..n0]);
@@ -221,8 +242,9 @@ fn adst_out_permute(t: &mut [i32], n: u32) {
     }
 }
 
+#[inline(always)]
 fn inverse_adst8(t: &mut [i32], r: u32) {
-    adst_in_permute(t, 3);
+    adst_in_permute::<3>(t);
     for i in 0..4 {
         bf(t, 2 * i, 2 * i + 1, 60 - 16 * i as i32, true);
     }
@@ -240,11 +262,12 @@ fn inverse_adst8(t: &mut [i32], r: u32) {
     for i in 0..2 {
         bf(t, 2 + 4 * i, 3 + 4 * i, 32, true);
     }
-    adst_out_permute(t, 3);
+    adst_out_permute::<3>(t);
 }
 
+#[inline(always)]
 fn inverse_adst16(t: &mut [i32], r: u32) {
-    adst_in_permute(t, 4);
+    adst_in_permute::<4>(t);
     for i in 0..8 {
         bf(t, 2 * i, 2 * i + 1, 62 - 8 * i as i32, true);
     }
@@ -273,7 +296,7 @@ fn inverse_adst16(t: &mut [i32], r: u32) {
     for i in 0..4 {
         bf(t, 2 + 4 * i, 3 + 4 * i, 32, true);
     }
-    adst_out_permute(t, 4);
+    adst_out_permute::<4>(t);
 }
 
 /// 1-D transform kind.
@@ -298,6 +321,17 @@ pub(crate) fn kinds(tx_type: usize) -> (Kind, Kind) {
     }
 }
 
+#[inline(always)]
+fn inverse_dct(t: &mut [i32], n: u32, r: u32) {
+    match n {
+        2 => inverse_dct_n::<2>(t, r),
+        3 => inverse_dct_n::<3>(t, r),
+        4 => inverse_dct_n::<4>(t, r),
+        _ => inverse_dct_n::<5>(t, r),
+    }
+}
+
+#[inline(always)]
 fn inverse_1d(t: &mut [i32], kind: Kind, n: u32, r: u32) {
     match kind {
         Kind::Dct => inverse_dct(t, n, r),
@@ -312,7 +346,17 @@ fn inverse_1d(t: &mut [i32], kind: Kind, n: u32, r: u32) {
 /// 2-D inverse transform (7.13.3) of a square `n x n` block (n = 4..=32) of dequantised
 /// coefficients (row stride `n`) into `residual` (row stride `n`).
 pub(crate) fn inverse_2d(dequant: &[i32], residual: &mut [i32], tx_sz: usize, tx_type: usize, bit_depth: u32) {
-    let log2 = TX_WIDTH_LOG2[tx_sz] as u32;
+    match TX_WIDTH_LOG2[tx_sz] {
+        2 => inverse_2d_n::<2>(dequant, residual, tx_sz, tx_type, bit_depth),
+        3 => inverse_2d_n::<3>(dequant, residual, tx_sz, tx_type, bit_depth),
+        4 => inverse_2d_n::<4>(dequant, residual, tx_sz, tx_type, bit_depth),
+        _ => inverse_2d_n::<5>(dequant, residual, tx_sz, tx_type, bit_depth),
+    }
+}
+
+/// `inverse_2d` for a block of width `1 << LOG2`.
+fn inverse_2d_n<const LOG2: u32>(dequant: &[i32], residual: &mut [i32], tx_sz: usize, tx_type: usize, bit_depth: u32) {
+    let log2 = LOG2;
     let n = 1usize << log2;
     let row_shift = TRANSFORM_ROW_SHIFT[tx_sz] as u32;
     let row_clamp = bit_depth + 8;
@@ -419,6 +463,51 @@ fn basis(kind: Kind, n: usize) -> &'static [f32] {
 /// Forward 2-D transform of the `n x n` residual (row stride `n`) into orthonormal-domain
 /// coefficients scaled by 8 (so that `level = out / q` with the spec's dequantiser).
 pub(crate) fn forward_2d(residual: &[i32], out: &mut [f32], n: usize, tx_type: usize) {
+    match n {
+        4 => forward_2d_n::<4, 16>(residual, out, tx_type),
+        8 => forward_2d_n::<8, 64>(residual, out, tx_type),
+        16 => forward_2d_n::<16, 256>(residual, out, tx_type),
+        _ => forward_2d_dyn(residual, out, n, tx_type),
+    }
+}
+
+/// `forward_2d` for a fixed size, so `tmp` is exactly `NN = N * N` floats (no 4 KiB zeroing).
+#[inline(always)]
+fn forward_2d_n<const N: usize, const NN: usize>(residual: &[i32], out: &mut [f32], tx_type: usize) {
+    let n = N;
+    let (ck, rk) = kinds(tx_type);
+    let bc = &basis(ck, n)[..NN];
+    let brt = &basis_t(rk, n)[..NN];
+    let residual = &residual[..NN];
+    let out = &mut out[..NN];
+    let mut tmp = [0f32; NN];
+    for i in 0..n {
+        let t = &mut tmp[i * n..i * n + n];
+        for j in 0..n {
+            let r = residual[i * n + j];
+            if r == 0 {
+                continue;
+            }
+            let r = r as f32;
+            for (o, &b) in t.iter_mut().zip(&brt[j * n..j * n + n]) {
+                *o += r * b;
+            }
+        }
+    }
+    out.iter_mut().for_each(|v| *v = 0.0);
+    for k in 0..n {
+        let o = &mut out[k * n..k * n + n];
+        for i in 0..n {
+            let b = 8.0 * bc[k * n + i];
+            for (v, &t) in o.iter_mut().zip(&tmp[i * n..i * n + n]) {
+                *v += b * t;
+            }
+        }
+    }
+}
+
+/// 32x32 (and any other size): a const-generic 32 version measured slower.
+fn forward_2d_dyn(residual: &[i32], out: &mut [f32], n: usize, tx_type: usize) {
     let (ck, rk) = kinds(tx_type);
     let bc = basis(ck, n);
     let brt = basis_t(rk, n);
@@ -454,6 +543,7 @@ pub(crate) fn forward_2d(residual: &[i32], out: &mut [f32], n: usize, tx_type: u
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::tables::{TX_4X4, TX_8X8, TX_16X16, TX_32X32};
 
     /// forward (float) then the normative inverse reproduces the residual: the forward basis
     /// and scale match the decoder's inverse transforms for every supported size and type.
diff --git a/crates/av1enc/src/writer.rs b/crates/av1enc/src/writer.rs
index 54c545fa4..a10bd2e9a 100644
--- a/crates/av1enc/src/writer.rs
+++ b/crates/av1enc/src/writer.rs
@@ -8,7 +8,15 @@ use crate::cdf::Cdfs;
 use crate::decide::{FrameGeom, Leaf, Node, intra_uv_tx_type, scan_for, tx_in_set, tx_set, tx_size_for};
 use crate::loopfilter::LfInfo;
 use crate::symbol::SymbolWriter;
-use crate::tables::*;
+use crate::tables::{
+    ADST_ADST, ADST_DCT, ALTREF_FRAME, ALTREF2_FRAME, BLOCK_8X8, BLOCK_64X64, BR_CDF_SIZE, BWDREF_FRAME, CLASS0_SIZE, COEFF_BASE_CTX_OFFSET, COEFF_BASE_RANGE,
+    D67_PRED, DC_PRED, DCT_ADST, DCT_DCT, DEFAULT_INTRA_FRAME_Y_MODE_CDF, GLOBALMV, GOLDEN_FRAME, INTRA_FRAME, INTRA_MODE_CONTEXT, LAST_FRAME, LAST2_FRAME,
+    LAST3_FRAME, MAG_REF_OFFSET_WITH_TX_CLASS, MAX_ANGLE_DELTA, MAX_REF_MV_STACK_SIZE, MI_HEIGHT_LOG2, MI_WIDTH_LOG2, MV_BORDER, MV_CLASS_0, NEARESTMV, NEARMV,
+    NEWMV, NUM_4X4_BLOCKS_HIGH, NUM_4X4_BLOCKS_WIDE, NUM_BASE_LEVELS, PARTITION_HORZ, PARTITION_HORZ_4, PARTITION_HORZ_A, PARTITION_HORZ_B, PARTITION_NONE,
+    PARTITION_SPLIT, PARTITION_SUBSIZE, PARTITION_VERT, PARTITION_VERT_4, PARTITION_VERT_A, PARTITION_VERT_B, REF_CAT_LEVEL, SIG_REF_DIFF_OFFSET, SIZE_GROUP,
+    SUBSAMPLED_SIZE, TX_32X32, TX_CLASS_2D, TX_HEIGHT, TX_HEIGHT_LOG2, TX_SIZE_SQR, TX_SIZE_SQR_UP, TX_TYPE_INTER_INV_SET3, TX_TYPE_INTRA_INV_SET2, TX_WIDTH,
+    TX_WIDTH_LOG2, V_PRED,
+};
 
 type MvP = [i32; 2];
 
@@ -62,6 +70,8 @@ pub(crate) struct TileWriter<'a> {
     left_dc: [Vec<u8>; 3],
     /// LoopfilterTxSizes per plane (row stride mi_cols + 32).
     lf_tx: [Vec<u8>; 3],
+    /// Scratch for the levels coded so far in `coeffs`.
+    quant: Vec<i32>,
     // current block
     r: usize,
     c: usize,
@@ -114,6 +124,7 @@ impl<'a> TileWriter<'a> {
             left_level: std::array::from_fn(|_| vec![0; g.mi_rows + 64]),
             left_dc: std::array::from_fn(|_| vec![0; g.mi_rows + 64]),
             lf_tx: std::array::from_fn(|_| vec![0; (g.mi_cols + 32) * (g.mi_rows + 32)]),
+            quant: Vec::new(),
             r: 0,
             c: 0,
             bsize: 0,
@@ -181,10 +192,10 @@ impl<'a> TileWriter<'a> {
             self.sw.symbol(partition, cdf);
         } else if has_cols || has_rows {
             assert!(split, "blocks crossing the frame edge are split");
-            let pcdf: Vec<u16> = match bsl {
-                2 => self.cdf.partition_w16[ctx].to_vec(),
-                3 => self.cdf.partition_w32[ctx].to_vec(),
-                _ => self.cdf.partition_w64[ctx].to_vec(),
+            let pcdf: &[u16] = match bsl {
+                2 => &self.cdf.partition_w16[ctx],
+                3 => &self.cdf.partition_w32[ctx],
+                _ => &self.cdf.partition_w64[ctx],
             };
             let pr = |k: usize| pcdf[k] as i32 - if k == 0 { 0 } else { pcdf[k - 1] as i32 };
             let psum = if has_cols {
@@ -455,23 +466,7 @@ impl<'a> TileWriter<'a> {
             }
         } else {
             if plane == 0 {
-                // transform_type( )
-                let set = tx_set(tx_sz, b.is_inter);
-                let t = b.tx_type_y;
-                if set > 0 && self.qidx > 0 {
-                    let sqr = TX_SIZE_SQR[tx_sz] as usize;
-                    if b.is_inter {
-                        // The decision only picks types of this set (DCT_DCT otherwise).
-                        let s = TX_TYPE_INTER_INV_SET3.iter().position(|&v| v as usize == t).unwrap_or_default();
-                        self.sw.symbol(s, &mut self.cdf.inter_tx_type_set3[sqr]);
-                    } else {
-                        let s = TX_TYPE_INTRA_INV_SET2.iter().position(|&v| v as usize == t).unwrap_or_default();
-                        self.sw.symbol(s, &mut self.cdf.intra_tx_type_set2[sqr][b.y_mode]);
-                    }
-                } else {
-                    assert_eq!(t, DCT_DCT);
-                }
-                self.set_tx_types(x4, y4, tx_sz, t);
+                self.write_transform_type(x4, y4, tx_sz, b);
             }
             let plane_tx_type = self.compute_tx_type(plane, tx_sz, x4, y4, b);
             debug_assert!(plane_tx_type == DCT_DCT || matches!(plane_tx_type, ADST_DCT | DCT_ADST | ADST_ADST));
@@ -501,7 +496,9 @@ impl<'a> TileWriter<'a> {
             let height = TX_HEIGHT[tx_sz] as usize;
             let width = 1usize << bwl;
             // Quant[] as the decoder sees it while parsing: the levels coded so far (capped)
-            let mut quant = vec![0i32; width * height];
+            let mut quant = std::mem::take(&mut self.quant);
+            quant.clear();
+            quant.resize(width * height, 0);
             for c in (0..eob).rev() {
                 let pos = scan[c] as usize;
                 let a = levels[pos].unsigned_abs().min(15) as i32;
@@ -526,6 +523,7 @@ impl<'a> TileWriter<'a> {
                 }
                 quant[pos] = a;
             }
+            self.quant = quant;
             for c in 0..eob {
                 let pos = scan[c] as usize;
                 let v = levels[pos];
@@ -571,6 +569,26 @@ impl<'a> TileWriter<'a> {
         }
     }
 
+    fn write_transform_type(&mut self, x4: usize, y4: usize, tx_sz: usize, b: &Leaf) {
+        // transform_type( )
+        let set = tx_set(tx_sz, b.is_inter);
+        let t = b.tx_type_y;
+        if set > 0 && self.qidx > 0 {
+            let sqr = TX_SIZE_SQR[tx_sz] as usize;
+            if b.is_inter {
+                // The decision only picks types of this set (DCT_DCT otherwise).
+                let s = TX_TYPE_INTER_INV_SET3.iter().position(|&v| v as usize == t).unwrap_or_default();
+                self.sw.symbol(s, &mut self.cdf.inter_tx_type_set3[sqr]);
+            } else {
+                let s = TX_TYPE_INTRA_INV_SET2.iter().position(|&v| v as usize == t).unwrap_or_default();
+                self.sw.symbol(s, &mut self.cdf.intra_tx_type_set2[sqr][b.y_mode]);
+            }
+        } else {
+            assert_eq!(t, DCT_DCT);
+        }
+        self.set_tx_types(x4, y4, tx_sz, t);
+    }
+
     fn set_tx_types(&mut self, x4: usize, y4: usize, tx_sz: usize, t: usize) {
         for i in 0..(TX_WIDTH[tx_sz] as usize >> 2) {
             for j in 0..(TX_HEIGHT[tx_sz] as usize >> 2) {
diff --git a/crates/av1enc/tests/it/roundtrip.rs b/crates/av1enc/tests/it/roundtrip.rs
index 282880e08..edc98c370 100644
--- a/crates/av1enc/tests/it/roundtrip.rs
+++ b/crates/av1enc/tests/it/roundtrip.rs
@@ -80,6 +80,23 @@ fn bitrate_mode_tracks_target() {
     assert!(kbps > 400.0 / 2.0 && kbps < 400.0 * 2.0, "{kbps} kbit/s");
 }
 
+/// Over several key frame intervals the average rate stays within 5 % of the target, for a
+/// range of targets (the key frame budget is taken out of the inter frames of its group).
+#[test]
+fn bitrate_mode_is_accurate_over_many_groups() {
+    let n = 180;
+    for (kbps, keyint, bd) in [(40, 30, 8), (100, 30, 8), (200, 60, 8), (150, 20, 10)] {
+        let pics: Vec<Pic> = (0..n).map(|t| synth(192, 128, bd, t)).collect();
+        let mut c = cfg(192, 128, bd as u8, 0, keyint);
+        c.rate = RateControl::Bitrate { kbps };
+        let mut enc = effectcraft_av1enc::Encoder::new(c).unwrap();
+        let bits: usize = pics.iter().map(|p| enc.encode(&p.frame()).data.len() * 8).sum();
+        let got = bits as f64 / (n as f64 / 30.0) / 1000.0;
+        eprintln!("{bd} bit, keyint {keyint}: {got:.1} kbit/s for {kbps}");
+        assert!((got / kbps as f64 - 1.0).abs() < 0.05, "{got:.1} kbit/s for a {kbps} kbit/s target ({bd} bit, keyint {keyint})");
+    }
+}
+
 #[test]
 fn headers() {
     let enc = effectcraft_av1enc::Encoder::new(cfg(1920, 1080, 10, 100, 60)).unwrap();
diff --git a/crates/color/src/lib.rs b/crates/color/src/lib.rs
index 2a0dfc50e..71eb43296 100644
--- a/crates/color/src/lib.rs
+++ b/crates/color/src/lib.rs
@@ -97,7 +97,9 @@ pub fn rgb_to_hsl(r: f32, g: f32, b: f32) -> (f32, f32, f32) {
         return (0.0, 0.0, l);
     }
     let d = max - min;
-    let s = if l > 0.5 { d / (2.0 - max - min) } else { d / (max + min) };
+    let denom = if l > 0.5 { 2.0 - max - min } else { max + min };
+    // Over-range (HDR) or negative inputs can make the denominator zero or negative.
+    let s = if denom > 0.0 { d / denom } else { 1.0 };
     let h = if max == r {
         (((g - b) / d + if g < b { 6.0 } else { 0.0 }) / 6.0).rem_euclid(1.0)
     } else if max == g {
@@ -262,6 +264,20 @@ impl Label {
 mod tests {
     use super::*;
 
+    #[test]
+    fn hsl_round_trip_is_finite_for_out_of_range_colours() {
+        for (r, g, b) in [(1.5, 0.5, 0.5), (2.0, 0.1, 0.3), (-0.5, 0.2, 0.9)] {
+            let (h, s, l) = rgb_to_hsl(r, g, b);
+            assert!(h.is_finite() && s.is_finite() && l.is_finite(), "{h} {s} {l}");
+            let (r2, g2, b2) = hsl_to_rgb(h, s, l);
+            assert!(r2.is_finite() && g2.is_finite() && b2.is_finite(), "{r2} {g2} {b2}");
+        }
+        // A 32 bpc colour whose denominator stays positive still round-trips exactly.
+        let (h, s, l) = rgb_to_hsl(1.2, 0.5, 0.5);
+        let (r, g, b) = hsl_to_rgb(h, s, l);
+        assert!((r - 1.2).abs() < 1e-5 && (g - 0.5).abs() < 1e-5 && (b - 0.5).abs() < 1e-5, "{r} {g} {b}");
+    }
+
     #[test]
     fn hsv_to_rgb_tiny_negative_hue_is_red() {
         let (r, g, b) = hsv_to_rgb(-1e-9, 1.0, 1.0);
diff --git a/crates/effects/src/analysis_cache.rs b/crates/effects/src/analysis_cache.rs
new file mode 100644
index 000000000..98764d205
--- /dev/null
+++ b/crates/effects/src/analysis_cache.rs
@@ -0,0 +1,97 @@
+//! Bounded parsed-JSON caches. Keep the content key with the owned source text so repeated
+//! renders do not rehash long analyses. Compare contents on lookup: evaluated parameter
+//! strings can be cloned, edited in place, or allocated again at an old address.
+
+use std::sync::{Arc, Mutex, OnceLock};
+
+struct Entry<T> {
+    json: Box<str>,
+    key: u64,
+    value: Arc<T>,
+}
+
+pub(crate) struct AnalysisCache<T> {
+    entries: OnceLock<Mutex<Vec<Entry<T>>>>,
+}
+
+pub(crate) fn fnv(bytes: &[u8]) -> u64 {
+    let mut h: u64 = 0xcbf2_9ce4_8422_2325;
+    for b in bytes {
+        h ^= *b as u64;
+        h = h.wrapping_mul(0x0100_0000_01b3);
+    }
+    h
+}
+
+impl<T> AnalysisCache<T> {
+    pub(crate) const fn new() -> Self {
+        Self { entries: OnceLock::new() }
+    }
+
+    pub(crate) fn get(&self, json: &str, parse: impl FnOnce(&str) -> Option<T>) -> Option<(u64, Arc<T>)> {
+        let entries = self.entries.get_or_init(Default::default);
+        {
+            let m = entries.lock().unwrap_or_else(|e| e.into_inner());
+            if let Some(e) = m.iter().rev().find(|e| e.json.as_ref() == json) {
+                return Some((e.key, e.value.clone()));
+            }
+        }
+        let value = Arc::new(parse(json)?);
+        let key = fnv(json.as_bytes());
+        let mut m = entries.lock().unwrap_or_else(|e| e.into_inner());
+        // Another render may have filled the entry while this one parsed it.
+        if let Some(e) = m.iter().rev().find(|e| e.json.as_ref() == json) {
+            return Some((e.key, e.value.clone()));
+        }
+        // Preserve the existing nine-entry bound and clear-on-overflow policy.
+        if m.len() > 8 {
+            m.clear();
+        }
+        m.push(Entry { json: json.into(), key, value: value.clone() });
+        Some((key, value))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::cell::Cell;
+
+    #[test]
+    fn reuses_content_and_invalidates_same_allocation_edits() {
+        let cache = AnalysisCache::new();
+        let calls = Cell::new(0);
+        let parse = |s: &str| {
+            calls.set(calls.get() + 1);
+            Some(s.to_owned())
+        };
+        let mut json = String::from("analysis-1");
+        let (key, a) = cache.get(&json, parse).unwrap();
+        let copy = json.clone();
+        assert_ne!(json.as_ptr(), copy.as_ptr());
+        let (same_key, same) = cache.get(&copy, parse).unwrap();
+        assert_eq!(key, fnv(json.as_bytes()));
+        assert_eq!(key, same_key);
+        assert!(Arc::ptr_eq(&a, &same));
+        assert_eq!(calls.get(), 1);
+        let ptr = json.as_ptr();
+        json.replace_range(9..10, "2");
+        assert_eq!(ptr, json.as_ptr());
+        let (changed_key, changed) = cache.get(&json, parse).unwrap();
+        assert_ne!(key, changed_key);
+        assert_eq!(&*changed, "analysis-2");
+        assert_eq!(&*a, "analysis-1");
+        assert_eq!(calls.get(), 2);
+        assert!(cache.get("invalid", |_| None).is_none());
+        assert!(Arc::ptr_eq(&cache.get(&json, parse).unwrap().1, &changed));
+    }
+
+    #[test]
+    fn source_text_retention_is_bounded() {
+        let cache = AnalysisCache::new();
+        for i in 0..30 {
+            cache.get(&i.to_string(), |s| Some(s.to_owned())).unwrap();
+            assert!(cache.entries.get().unwrap().lock().unwrap().len() <= 9);
+        }
+    }
+}
diff --git a/crates/effects/src/audio_fx.rs b/crates/effects/src/audio_fx.rs
index cd9153d66..2aab70309 100644
--- a/crates/effects/src/audio_fx.rs
+++ b/crates/effects/src/audio_fx.rs
@@ -206,6 +206,12 @@ pub fn reverses(id: &str) -> bool {
     id == "ec.audio.backwards"
 }
 
+/// Does each output sample depend only on the input sample at the same time (no state), so the
+/// mixer may run the effect in short pieces with parameters animated between them?
+pub fn per_sample(id: &str) -> bool {
+    matches!(id, "ec.audio.stereomixer" | "ec.audio.backwards")
+}
+
 /// Seconds of input history the effect needs before a block to reach the state it would have
 /// had when processing continuously.
 pub fn preroll(id: &str, params: &Params) -> f64 {
diff --git a/crates/effects/src/camera_tracker.rs b/crates/effects/src/camera_tracker.rs
index ba7878abf..c58df3593 100644
--- a/crates/effects/src/camera_tracker.rs
+++ b/crates/effects/src/camera_tracker.rs
@@ -16,8 +16,9 @@
 //! on it draws the solved points (as the viewer shows them) into the frame. The viewer overlay, target and the Create
 //! commands live in the engine and the UI.
 
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex, OnceLock};
+use std::sync::Arc;
+
+use crate::analysis_cache::AnalysisCache;
 
 use effectcraft_keyframe::Value;
 use effectcraft_project::ParamUi;
@@ -122,50 +123,24 @@ pub fn solve_key(st: &SolveSettings) -> String {
     format!("{:?}|{hfov}|{:?}|{:?}{lens}", st.shot, st.method, st.deleted)
 }
 
-fn fnv(bytes: &[u8]) -> u64 {
-    let mut h: u64 = 0xcbf2_9ce4_8422_2325;
-    for b in bytes {
-        h ^= *b as u64;
-        h = h.wrapping_mul(0x0100_0000_01b3);
-    }
-    h
-}
-
-type Cache<T> = Mutex<HashMap<u64, Arc<T>>>;
-
-fn cached<T>(c: &'static OnceLock<Cache<T>>, json: &str, parse: impl Fn(&str) -> Option<T>) -> Option<Arc<T>> {
-    let key = fnv(json.as_bytes());
-    let c = c.get_or_init(Default::default);
-    if let Some(a) = c.lock().unwrap_or_else(std::sync::PoisonError::into_inner).get(&key) {
-        return Some(a.clone());
-    }
-    let a = Arc::new(parse(json)?);
-    let mut m = c.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
-    if m.len() > 8 {
-        m.clear();
-    }
-    m.insert(key, a.clone());
-    Some(a)
-}
-
 /// The stored feature tracks of an instance (`None` when not analysed).
 pub fn tracks(params: &Params) -> Option<Arc<CameraTracks>> {
-    static C: OnceLock<Cache<CameraTracks>> = OnceLock::new();
+    static C: AnalysisCache<CameraTracks> = AnalysisCache::new();
     let j = s(params, TRACKS);
     if j.is_empty() {
         return None;
     }
-    cached(&C, j, CameraTracks::from_json).filter(|t| !t.is_empty())
+    C.get(j, CameraTracks::from_json).map(|(_, a)| a).filter(|t| !t.is_empty())
 }
 
 /// The stored camera solve of an instance (`None` when not solved).
 pub fn solve(params: &Params) -> Option<Arc<CameraSolve>> {
-    static C: OnceLock<Cache<CameraSolve>> = OnceLock::new();
+    static C: AnalysisCache<CameraSolve> = AnalysisCache::new();
     let j = s(params, SOLVE);
     if j.is_empty() {
         return None;
     }
-    cached(&C, j, CameraSolve::from_json).filter(|t| !t.is_empty())
+    C.get(j, CameraSolve::from_json).map(|(_, a)| a).filter(|t| !t.is_empty())
 }
 
 /// Screen size (layer pixels) of a target drawn for a point at depth `z`, relative to the
@@ -338,6 +313,27 @@ mod tests {
         assert!(!st.lens_distortion && !solve_key(&st).contains("lens"));
     }
 
+    #[test]
+    fn tracks_and_solve_follow_analysis_replacements() {
+        let mut t = CameraTracks { frames: 3, start: 1.0, ..Default::default() };
+        let mut sol = CameraSolve { frames: vec![SolvedFrame::default()], start: 1.0, ..Default::default() };
+        let mut ps = params_with(&sol, false);
+        ps.values.insert(TRACKS.into(), Value::Str(t.to_json()));
+        assert_eq!(*tracks(&ps).unwrap(), t);
+        assert_eq!(*solve(&ps).unwrap(), sol);
+        t.start = 2.0;
+        sol.start = 2.0;
+        ps.values.insert(TRACKS.into(), Value::Str(t.to_json()));
+        ps.values.insert(SOLVE.into(), Value::Str(sol.to_json()));
+        assert_eq!(*tracks(&ps).unwrap(), t);
+        assert_eq!(*solve(&ps).unwrap(), sol);
+        assert_eq!(*tracks(&ps.clone()).unwrap(), t);
+        ps.values.insert(TRACKS.into(), Value::Str("invalid".into()));
+        ps.values.insert(SOLVE.into(), Value::Str(String::new()));
+        assert!(tracks(&ps).is_none());
+        assert!(solve(&ps).is_none());
+    }
+
     #[test]
     fn undistort_footage_remaps_through_the_solved_lens() {
         use effectcraft_track::camtrack::Distortion;
diff --git a/crates/effects/src/catalog.rs b/crates/effects/src/catalog.rs
index 0be2b04f5..7fcb024bf 100644
--- a/crates/effects/src/catalog.rs
+++ b/crates/effects/src/catalog.rs
@@ -92,8 +92,8 @@ const CPU_ONLY_CONTROLS: &[(&str, &[&str])] = &[
 ];
 
 /// Whether the GPU kernel of effect `id` covers the instance's current settings (see
-/// [`CPU_ONLY_CONTROLS`]; plus Cell Pattern's HQ variants and Turbulent Displace's locked
-/// pinning).
+/// `CPU_ONLY_CONTROLS`; plus Cell Pattern's HQ variants, Turbulent Displace's locked
+/// pinning and CC Particle World's motion trails and textured squares).
 pub fn gpu_supported(id: &str, ctx: &crate::EffectCtx) -> bool {
     match id {
         "ec.generate.cellpattern" if (6..=10).contains(&ctx.params.e("cellPattern")) => return false,
@@ -101,6 +101,8 @@ pub fn gpu_supported(id: &str, ctx: &crate::EffectCtx) -> bool {
         // #1195: CC Particle World's motion trails (the averaged shutter samples) render on the
         // CPU kernel until the GPU particle pass supports them.
         "ec.sim.ccparticleworld" if ctx.env.shutter.filter(|(a, _, _)| *a > 0.0).is_some() => return false,
+        // #1465: Textured Square's Texture Layer is drawn on the CPU only.
+        "ec.sim.ccparticleworld" if crate::sim::particle_world_textured(ctx) => return false,
         _ => {}
     }
     let Some((_, controls)) = CPU_ONLY_CONTROLS.iter().find(|(e, _)| *e == id) else { return true };
@@ -126,7 +128,8 @@ pub fn effects_markdown() -> String {
     s.push_str("# Effects\n\n");
     s.push_str("<!-- Generated from the effect registry (crates/effects/src/catalog.rs); do not edit by hand.\n");
     s.push_str("     Regenerate: UPDATE_DOCS=1 cargo test -p effectcraft-effects --lib effects_doc_is_current -->\n\n");
-    let params: usize = r.iter().map(|e| e.params.len()).sum();
+    // The parameters the table's rows list: the shown ones, not the hidden bookkeeping ones.
+    let params: usize = r.iter().map(|e| e.params.iter().filter(|p| !matches!(p.ui, effectcraft_project::ParamUi::Hidden)).count()).sum();
     let gpu = r.iter().filter(|e| e.gpu).count();
     let float = r.iter().filter(|e| e.float).count();
     let partial = r.iter().filter(|e| PARTIAL.iter().any(|(id, _)| *id == e.id)).count();
@@ -182,6 +185,20 @@ mod tests {
         assert!(have == want, "docs/effects.md is stale: UPDATE_DOCS=1 cargo test -p effectcraft-effects --lib effects_doc_is_current");
     }
 
+    /// The README quotes the number of effects (#2565): every count it gives is the registry's.
+    #[test]
+    fn readme_effect_counts_are_current() {
+        let readme = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/../../README.md")).unwrap_or_default();
+        let words: Vec<&str> = readme.split_whitespace().collect();
+        let counts: Vec<&str> = words
+            .windows(3)
+            .filter(|w| w[0].parse::<u32>().is_ok() && (w[1].starts_with("effects") || (w[1] == "built-in" && w[2].starts_with("effects"))))
+            .map(|w| w[0])
+            .collect();
+        let n = super::registry().len().to_string();
+        assert!(!counts.is_empty() && counts.iter().all(|c| *c == n), "README.md says {counts:?} effects; the registry has {n}");
+    }
+
     #[test]
     fn cpu_only_controls_keep_effects_off_the_gpu() {
         use effectcraft_keyframe::Value;
@@ -210,6 +227,10 @@ mod tests {
             assert!(!super::gpu_supported("ec.sim.ccparticleworld", &ctx));
         }
         assert!(ok("ec.sim.ccparticleworld", &[]));
+        // #1465: the Texture Layer keeps CC Particle World on the CPU only when Textured Square draws it.
+        let tex = ("particle/texture/textureLayer", Value::Layer(Some(1)));
+        assert!(ok("ec.sim.ccparticleworld", &[tex.clone(), ("particle/particleType", Value::Enum(2))]));
+        assert!(!ok("ec.sim.ccparticleworld", &[tex, ("particle/particleType", Value::Enum(8))]));
         assert!(ok("ec.generate.cellpattern", &[("cellPattern", Value::Enum(3))]));
         assert!(!ok("ec.generate.cellpattern", &[("cellPattern", Value::Enum(9))]));
         assert!(!ok("ec.distort.turbulentdisplace", &[("pinning", Value::Enum(9))]));
diff --git a/crates/effects/src/channel3d.rs b/crates/effects/src/channel3d.rs
index 39a1c49b1..dc65c3255 100644
--- a/crates/effects/src/channel3d.rs
+++ b/crates/effects/src/channel3d.rs
@@ -7,6 +7,11 @@
 //! pass for a precomp of a 3D comp. Without auxiliary channels they pass the layer through
 //! (EXtractoR still maps the layer's own R, G, B and A).
 //!
+//! 3D Layer Instance (Create 3D Layer Instance's own effect, Layer ▸ Create) is not an aux
+//! reader: it replaces the layer's pixels with a referenced layer's render — for a 3D model
+//! layer, its render on its own through the comp's camera — so 2D effects can be applied to a
+//! 3D layer's render.
+//!
 //! Aux pixels are looked up nearest-neighbour (IDs must not be interpolated) at each buffer
 //! pixel's layer position, so render scale and layer padding are respected.
 
@@ -359,7 +364,7 @@ pub(crate) fn selection_names(sel: &str) -> Vec<String> {
     out
 }
 
-/// Parse a selection: comma-separated names (optionally quoted, see [`selection_names`]) or
+/// Parse a selection: comma-separated names (optionally quoted, see `selection_names`) or
 /// `<hex>` hashes / wildcards.
 pub fn selection_hashes(sel: &str, manifest: Option<&[(String, u32)]>) -> Vec<u32> {
     let mut out = vec![];
@@ -582,6 +587,19 @@ fn extractor(ctx: &EffectCtx, mut b: Buf) -> Buf {
     b
 }
 
+/// A 2D copy of a referenced layer (Create 3D Layer Instance's solid): the layer's pixels
+/// replaced with the referenced layer's render, alpha included — the copy is transparent
+/// where the referenced layer isn't. A 3D model or primitive layer is rendered on its own
+/// through the comp's camera, as After Effects renders 3D layers; another layer is read with
+/// its masks and effects. With no layer chosen the effect passes the layer through, as a layer
+/// parameter with nothing chosen does.
+fn instance_3d(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    if let Some(o) = ctx.layer_param("layer", true) {
+        b.img = crate::util::fit_layer(ctx, &b, &o, false);
+    }
+    b
+}
+
 pub fn specs() -> Vec<EffectSpec> {
     let text = |id: &'static str, name: &'static str, d: &str| p(id, name, Value::Str(d.into()), ParamUi::Text);
     vec![
@@ -682,388 +700,9 @@ pub fn specs() -> Vec<EffectSpec> {
             ],
             identifier,
         ),
+        spec("ec.3d.instance3d", "3D Layer Instance", vec![p("layer", "Layer", Value::Layer(None), ParamUi::Layer)], instance_3d),
     ]
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{EffectEnv, EffectHost, LayerPixels, run_fx};
-    use effectcraft_raster::channels3d::crypto_float;
-
-    /// A 20×10 layer: left half object 1 at depth 100, right half object 2 at depth 500; the
-    /// top-right corner is background. Cryptomatte: "left" / "right".
-    struct AuxHost(Arc<AuxChannels>);
-    impl EffectHost for AuxHost {
-        fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {
-            None
-        }
-        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
-            None
-        }
-        fn aux(&self) -> Option<Arc<AuxChannels>> {
-            Some(self.0.clone())
-        }
-    }
-
-    fn scene() -> AuxHost {
-        let (w, h) = (20usize, 10usize);
-        let mut a = AuxChannels::new(w as u32, h as u32, 1.0);
-        let (mut z, mut id, mut r, mut g) = (vec![0.0; w * h], vec![0.0; w * h], vec![0.0; w * h], vec![0.0; w * h]);
-        let (hl, hr) = (crypto_hash("left"), crypto_hash("right"));
-        for y in 0..h {
-            for x in 0..w {
-                let i = y * w + x;
-                if x >= 15 && y < 3 {
-                    z[i] = BACKGROUND_DEPTH;
-                } else if x < 10 {
-                    z[i] = 100.0;
-                    id[i] = 1.0;
-                    r[i] = crypto_float(hl);
-                    g[i] = 1.0;
-                } else {
-                    z[i] = 500.0;
-                    id[i] = 2.0;
-                    r[i] = crypto_float(hr);
-                    g[i] = 1.0;
-                }
-            }
-        }
-        a.channels = vec![("Z".into(), z), ("ObjectID".into(), id), ("CryptoObject00.R".into(), r), ("CryptoObject00.G".into(), g)];
-        a.manifests = vec![("CryptoObject".into(), vec![("left".into(), hl), ("right".into(), hr)])];
-        AuxHost(Arc::new(a))
-    }
-
-    fn img() -> Image {
-        Image::filled(20, 10, [0.5, 0.5, 0.5, 1.0])
-    }
-
-    fn run(id: &str, vals: &[(&str, Value)], host: &AuxHost) -> Image {
-        run_fx(id, vals, img(), 0.0, EffectEnv { host: Some(host), ..Default::default() }).img
-    }
-
-    #[test]
-    fn passes_through_without_aux_channels() {
-        for s in specs() {
-            let out = run_fx(s.id, &[], img(), 0.0, EffectEnv::default());
-            assert_eq!(out.img.data, img().data, "{}", s.id);
-        }
-    }
-
-    #[test]
-    fn depth_matte_thresholds() {
-        let h = scene();
-        let o = run("ec.3d.depthmatte", &[("depth", num(300.0))], &h);
-        assert_eq!(o.get(2, 5)[3], 0.0);
-        assert_eq!(o.get(12, 5)[3], 1.0);
-        let inv = run("ec.3d.depthmatte", &[("depth", num(300.0)), ("invert", Value::Bool(true))], &h);
-        assert_eq!(inv.get(2, 5)[3], 1.0);
-        assert_eq!(inv.get(12, 5)[3], 0.0);
-        // Feather: a ramp of 800 units centred on 300 → depth 100 at 0.25, 500 at 0.75.
-        let f = run("ec.3d.depthmatte", &[("depth", num(300.0)), ("feather", num(800.0))], &h);
-        assert!((f.get(2, 5)[3] - 0.25).abs() < 1e-5 && (f.get(12, 5)[3] - 0.75).abs() < 1e-5);
-    }
-
-    #[test]
-    fn channel_extract_maps_depth_and_ids() {
-        let h = scene();
-        let o = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(1000.0))], &h);
-        assert!((o.get(2, 5)[0] - 0.1).abs() < 1e-6 && (o.get(12, 5)[0] - 0.5).abs() < 1e-6);
-        assert_eq!(o.get(17, 1)[0], 1.0);
-        let ids = run("ec.3d.channelextract", &[("channel", Value::Enum(1)), ("whitePoint", num(2.0))], &h);
-        assert_eq!(ids.get(2, 5)[0], 0.5);
-        // Invert Depth Map flips the ramp; without Clamp Output values run past 1.
-        let inv = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(1000.0)), ("invertDepthMap", Value::Bool(true))], &h);
-        assert!((inv.get(2, 5)[0] - 0.9).abs() < 1e-6);
-        let raw = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(100.0)), ("clampOutput", Value::Bool(false))], &h);
-        assert!(raw.get(12, 5)[0] > 1.5);
-    }
-
-    #[test]
-    fn id_matte_and_identifier() {
-        let h = scene();
-        let o = run("ec.3d.idmatte", &[("idSelection", num(2.0))], &h);
-        assert_eq!(o.get(2, 5)[3], 0.0);
-        assert_eq!(o.get(12, 5)[3], 1.0);
-        let l = run("ec.3d.identifier", &[("display", Value::Enum(1)), ("id", num(1.0))], &h);
-        assert_eq!(l.get(2, 5)[0], 1.0);
-        assert_eq!(l.get(12, 5)[0], 0.0);
-        let c = run("ec.3d.identifier", &[], &h);
-        assert_ne!(c.get(2, 5), c.get(12, 5));
-    }
-
-    /// The parallel aux image (rank planes resolved once) is bit-identical to the per-pixel
-    /// reduction over `crypto_ranks` it replaces.
-    #[test]
-    fn crypto_aux_image_matches_the_per_pixel_reduction() {
-        let (w, h) = (7u32, 5u32);
-        let n = (w * h) as usize;
-        let mut a = AuxChannels::new(w, h, 1.0);
-        let ids = [crypto_hash("cube"), crypto_hash("sphere"), crypto_hash("ring")].map(effectcraft_raster::channels3d::crypto_float);
-        for (k, ch) in ["00.R", "00.G", "00.B", "00.A", "01.R", "01.G", "01.B", "01.A"].iter().enumerate() {
-            let v: Vec<f32> = (0..n).map(|i| if k % 2 == 0 { ids[(i + k) % 3] } else { ((i * 7 + k * 3) % 11) as f32 / 10.0 }).collect();
-            a.channels.push((format!("CryptoObject{ch}"), v));
-        }
-        let sel = vec![crypto_hash("sphere"), crypto_hash("ring")];
-        let img = crypto_aux_image(&a, "CryptoObject", &sel);
-        for i in 0..n {
-            let ranks = a.crypto_ranks("CryptoObject", i);
-            let m: f32 = ranks.iter().filter(|(id, c)| *c > 0.0 && sel.contains(&id.to_bits())).map(|(_, c)| *c).sum::<f32>().clamp(0.0, 1.0);
-            let mut c = [0.0f32; 3];
-            for (id, cov) in &ranks {
-                let k = id_color(*id);
-                for j in 0..3 {
-                    c[j] += k[j] * cov;
-                }
-            }
-            let want = [c[0], c[1], c[2], m];
-            assert_eq!(img.data[i].map(f32::to_bits), want.map(f32::to_bits), "pixel {i}");
-        }
-    }
-
-    /// The lookup before #473, kept as the reference: the rank channels formatted and searched
-    /// by name for every pixel.
-    fn ranks_by_name(a: &AuxChannels, layer: &str, i: usize) -> Vec<(f32, f32)> {
-        let mut out = vec![];
-        for k in 0.. {
-            let get = |c: &str| a.get(&format!("{layer}{k:02}.{c}"));
-            let (Some(r), Some(g)) = (get("R"), get("G")) else { break };
-            out.push((r[i], g[i]));
-            if let (Some(b), Some(al)) = (get("B"), get("A")) {
-                out.push((b[i], al[i]));
-            }
-        }
-        out
-    }
-
-    /// The reduction before #473 over those ranks: (ID colours, selection coverage).
-    fn reduce_by_name(a: &AuxChannels, layer: &str, sel: &[u32], i: usize) -> ([f32; 3], f32) {
-        let ranks = ranks_by_name(a, layer, i);
-        let m: f32 = ranks.iter().filter(|(id, c)| *c > 0.0 && sel.contains(&id.to_bits())).map(|(_, c)| *c).sum::<f32>().clamp(0.0, 1.0);
-        let mut c = [0.0f32; 3];
-        for (id, cov) in &ranks {
-            let k = id_color(*id);
-            for j in 0..3 {
-                c[j] += k[j] * cov;
-            }
-        }
-        (c, m)
-    }
-
-    /// A 6×2 Cryptomatte layer with awkward values: NaN, ±inf, negative and -0.0 coverage, NaN
-    /// and -0.0 IDs; rank 01 has no B/A pair, rank 02 is missing, so rank 03 (filled with values
-    /// that would change every pixel) must be ignored as before.
-    fn edge_aux(with_rank_after_gap: bool) -> AuxChannels {
-        let (w, h) = (6u32, 2u32);
-        let nan_payload = f32::from_bits(0x7fc0_1234);
-        let (hs, hc) = (crypto_float(crypto_hash("sphere")), crypto_float(crypto_hash("cube")));
-        let cov = [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, -0.5, -0.0, 0.0, 0.25, 1.0, 2.0, f32::MIN_POSITIVE, nan_payload, 0.5];
-        let ids = [hs, f32::NAN, hc, -0.0, 0.0, nan_payload, hs, hc, f32::NAN, hs, hc, -0.0];
-        let rot = |v: &[f32; 12], k: usize| -> Vec<f32> { (0..12).map(|i| v[(i + k) % 12]).collect() };
-        let mut a = AuxChannels::new(w, h, 1.0);
-        let mut push = |n: &str, v: Vec<f32>| a.channels.push((format!("CryptoObject{n}"), v));
-        push("00.R", rot(&ids, 0));
-        push("00.G", rot(&cov, 0));
-        push("00.B", rot(&ids, 3));
-        push("00.A", rot(&cov, 5));
-        push("01.R", rot(&ids, 7));
-        push("01.G", rot(&cov, 2));
-        if with_rank_after_gap {
-            push("03.R", vec![hs; 12]);
-            push("03.G", vec![1.0; 12]);
-            push("03.B", vec![hc; 12]);
-            push("03.A", vec![1.0; 12]);
-        }
-        a
-    }
-
-    /// The memo hands out exactly `id_color`'s bits for every rank and pixel of the edge values
-    /// (NaN IDs with and without a payload, -0.0 and 0.0 are keyed by their bits).
-    #[test]
-    fn id_color_memo_matches_id_color() {
-        let a = edge_aux(true);
-        let planes = a.crypto_rank_planes("CryptoObject");
-        let mut memo = IdColorMemo::default();
-        for i in 0..12 {
-            for (r, (id, _)) in planes.iter().enumerate() {
-                assert_eq!(memo.get(r, id[i]).map(f32::to_bits), id_color(id[i]).map(f32::to_bits), "pixel {i} rank {r}");
-            }
-        }
-    }
-
-    fn edge_selection() -> Vec<u32> {
-        vec![crypto_hash("sphere"), f32::NAN.to_bits(), 0x7fc0_1234, (-0.0f32).to_bits()]
-    }
-
-    /// Edge values give bit-identical results to the lookup by name, the missing B/A pair is
-    /// skipped and a rank after a gap is ignored.
-    #[test]
-    fn crypto_aux_image_is_bit_exact_on_edge_values() {
-        let sel = edge_selection();
-        let a = edge_aux(true);
-        assert_eq!(a.crypto_rank_planes("CryptoObject").len(), 3, "00.R/G, 00.B/A, 01.R/G; not 03 after the gap");
-        let img = crypto_aux_image(&a, "CryptoObject", &sel);
-        let without_gap_rank = crypto_aux_image(&edge_aux(false), "CryptoObject", &sel);
-        for i in 0..12 {
-            let (c, m) = reduce_by_name(&a, "CryptoObject", &sel, i);
-            let want = [c[0], c[1], c[2], m];
-            assert_eq!(img.data[i].map(f32::to_bits), want.map(f32::to_bits), "pixel {i}");
-            assert_eq!(img.data[i].map(f32::to_bits), without_gap_rank.data[i].map(f32::to_bits), "pixel {i}: the rank after the gap was used");
-        }
-    }
-
-    /// Without the ID colours the matte (A) is bit-identical and the RGB is 0, on the edge values.
-    #[test]
-    fn crypto_aux_image_without_colors_keeps_the_matte() {
-        let a = edge_aux(true);
-        let sel = edge_selection();
-        let full = crypto_aux_image(&a, "CryptoObject", &sel);
-        let matte = crypto_aux_image_with(&a, "CryptoObject", &sel, CryptoAux::MatteOnly);
-        for (f, m) in full.data.iter().zip(&matte.data) {
-            assert_eq!(f[3].to_bits(), m[3].to_bits());
-            assert_eq!(m[..3], [0.0; 3]);
-        }
-    }
-
-    /// Only the Colors display without Matte Only reads the ID colours.
-    #[test]
-    fn crypto_aux_for_display_reads_colors_only_for_the_colors_display() {
-        assert_eq!(CryptoAux::for_display(0, false), CryptoAux::ColorsAndMatte);
-        assert_eq!(CryptoAux::for_display(0, true), CryptoAux::MatteOnly);
-        for display in [1, 2, 3, u32::MAX] {
-            for matte_only in [false, true] {
-                assert_eq!(CryptoAux::for_display(display, matte_only), CryptoAux::MatteOnly, "display {display}");
-            }
-        }
-    }
-
-    /// The CPU effect on a 20×10 layer over the 6×2 edge aux: pixels inside the aux area match
-    /// the lookup by name bit for bit in every display mode, pixels outside it (no aux index)
-    /// get an empty matte and no ID colour.
-    #[test]
-    fn cryptomatte_cpu_path_is_bit_exact_inside_and_outside_the_aux_area() {
-        let a = edge_aux(true);
-        let host = AuxHost(Arc::new(a.clone()));
-        let names = "sphere, <7fc00000>, <7fc01234>, <80000000>";
-        assert_eq!(selection_hashes(names, None), edge_selection());
-        let src = img().data[0];
-        for (display, matte_only) in [(0, false), (1, false), (2, false), (0, true)] {
-            let out = run(
-                "ec.3d.cryptomatte",
-                &[("selection", Value::Str(names.into())), ("display", Value::Enum(display)), ("matteOnly", Value::Bool(matte_only))],
-                &host,
-            );
-            let expect = |c: [f32; 3], m: f32| -> [f32; 4] {
-                if matte_only {
-                    return [m; 4];
-                }
-                match display {
-                    0 => {
-                        let c = c.map(|v| v * (1.0 - 0.5 * m) + 0.5 * m);
-                        [c[0], c[1], c[2], 1.0]
-                    }
-                    1 => src.map(|v| v * m),
-                    _ => [src[0] * (1.0 - 0.5 * m) + 0.5 * m * src[3], src[1] * (1.0 - 0.5 * m) + 0.5 * m * src[3], src[2] * (1.0 - 0.5 * m), src[3]],
-                }
-            };
-            for (x, y) in [(0u32, 0u32), (1, 0), (5, 0), (0, 1), (3, 1), (5, 1)] {
-                let (c, m) = reduce_by_name(&a, "CryptoObject", &edge_selection(), (y * 6 + x) as usize);
-                assert_eq!(
-                    out.get(x as i64, y as i64).map(f32::to_bits),
-                    expect(c, m).map(f32::to_bits),
-                    "display {display} matteOnly {matte_only} at ({x}, {y})"
-                );
-            }
-            for (x, y) in [(6u32, 0u32), (19, 0), (0, 2), (12, 9)] {
-                assert_eq!(
-                    out.get(x as i64, y as i64).map(f32::to_bits),
-                    expect([0.0; 3], 0.0).map(f32::to_bits),
-                    "display {display} matteOnly {matte_only} outside the aux at ({x}, {y})"
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn cryptomatte_selects_by_name_and_wildcard() {
-        let h = scene();
-        let m = run("ec.3d.cryptomatte", &[("selection", Value::Str("right".into())), ("matteOnly", Value::Bool(true))], &h);
-        assert_eq!(m.get(2, 5)[3], 0.0);
-        assert_eq!(m.get(12, 5)[3], 1.0);
-        let w = run("ec.3d.cryptomatte", &[("selection", Value::Str("l*".into())), ("display", Value::Enum(1))], &h);
-        assert_eq!(w.get(2, 5)[3], 1.0);
-        assert_eq!(w.get(12, 5)[3], 0.0);
-        assert!(wild("*ight", "right") && wild("r*t", "right") && !wild("x*", "right"));
-        let hex = format!("<{:08x}>", crypto_hash("left"));
-        assert_eq!(selection_hashes(&hex, None), vec![crypto_hash("left")]);
-    }
-
-    /// #473: a name with a comma in it (Blender allows `Green, Glossy`) is selected when it is
-    /// quoted or its comma escaped, instead of being cut into two names that match nothing.
-    #[test]
-    fn cryptomatte_selection_keeps_quoted_names_with_commas_whole() {
-        let manifest = vec![("Green, Glossy".to_string(), 7), ("Green".to_string(), 1), ("Glossy".to_string(), 2), ("ring".to_string(), 3)];
-        let m = Some(manifest.as_slice());
-        assert_eq!(selection_hashes(r#""Green, Glossy""#, m), vec![7]);
-        assert_eq!(selection_hashes("'Green, Glossy', ring", m), vec![7, 3]);
-        assert_eq!(selection_hashes(r"Green\, Glossy", m), vec![7]);
-        assert_eq!(selection_hashes(r#"ring , "Green, Glossy""#, m), vec![3, 7]);
-        // Without a manifest the whole name is hashed.
-        assert_eq!(selection_hashes(r#""Green, Glossy""#, None), vec![crypto_hash("Green, Glossy")]);
-        // Plain lists, apostrophes inside names and an unclosed quote still parse.
-        assert_eq!(selection_hashes("Green, Glossy", m), vec![1, 2]);
-        assert_eq!(selection_names("Bob's mat, ring"), vec!["Bob's mat", "ring"]);
-        assert_eq!(selection_names(r#""Green, Glossy"#), vec!["Green, Glossy"]);
-        assert_eq!(selection_names(r#"say \"hi\""#), vec![r#"say "hi""#]);
-    }
-
-    #[test]
-    fn fog_and_depth_of_field_follow_depth() {
-        let h = scene();
-        let f = run("ec.3d.fog3d", &[("fogColor", col(1.0, 0.0, 0.0)), ("fogEndDepth", num(1000.0)), ("scatteringDensity", num(0.0))], &h);
-        // Linear fog: 10 % at depth 100, 50 % at 500, full on the background.
-        assert!((f.get(2, 5)[0] - 0.55).abs() < 1e-4, "{:?}", f.get(2, 5));
-        assert!((f.get(12, 5)[0] - 0.75).abs() < 1e-4);
-        assert!((f.get(17, 1)[0] - 1.0).abs() < 1e-4 && f.get(17, 1)[1] < 1e-4);
-        assert!((dof_radius(100.0, 100.0, 0.0, 10.0, 50.0)).abs() < 1e-6);
-        assert!((dof_radius(200.0, 100.0, 0.0, 10.0, 50.0) - 10.0).abs() < 1e-6);
-        assert_eq!(dof_radius(140.0, 100.0, 100.0, 10.0, 50.0), 0.0);
-        // A sharp edge at the far object blurs when focused near.
-        let mut pic = Image::new(20, 10);
-        for y in 0..10 {
-            for x in 0..20 {
-                let v = if x % 2 == 0 { 1.0 } else { 0.0 };
-                pic.set(x, y, [v, v, v, 1.0]);
-            }
-        }
-        let env = EffectEnv { host: Some(&h), ..Default::default() };
-        let d = run_fx("ec.3d.depthoffield", &[("focalPlane", num(100.0)), ("maximumRadius", num(4.0))], pic.clone(), 0.0, env).img;
-        assert_eq!(d.get(4, 5), pic.get(4, 5));
-        assert!((d.get(12, 5)[0] - 0.5).abs() < 0.3 && d.get(12, 5) != pic.get(12, 5));
-    }
-
-    #[test]
-    fn extractor_maps_named_channels() {
-        let h = scene();
-        let o = run("ec.3d.extractor", &[("red", Value::Str("Z".into())), ("whitePoint", num(1000.0))], &h);
-        assert!((o.get(2, 5)[0] - 0.1).abs() < 1e-6);
-        assert!((o.get(2, 5)[1] - 0.0005).abs() < 1e-6);
-        // Without aux: the layer's own channels can be swapped.
-        let s = run_fx("ec.3d.extractor", &[("red", Value::Str("A".into()))], Image::filled(2, 2, [0.2, 0.3, 0.4, 1.0]), 0.0, EffectEnv::default());
-        assert_eq!(s.img.get(0, 0), [1.0, 0.3, 0.4, 1.0]);
-    }
-
-    #[test]
-    fn channel_extract_antialias_averages_sub_pixels() {
-        // Depth at twice the layer resolution, alternating 0 / 1000 per aux column.
-        let mut a = AuxChannels::new(40, 20, 2.0);
-        a.channels = vec![("Z".into(), (0..800).map(|i| if i % 2 == 0 { 0.0 } else { 1000.0 }).collect())];
-        let host = AuxHost(Arc::new(a));
-        let vals = [("blackPoint", num(0.0)), ("whitePoint", num(1000.0))];
-        let hard = run("ec.3d.channelextract", &vals, &host);
-        let v = hard.get(5, 5)[0];
-        assert!(v == 0.0 || v == 1.0, "{v}");
-        let soft = run("ec.3d.channelextract", &[vals.as_slice(), &[("antialias", Value::Bool(true))]].concat(), &host);
-        assert!((soft.get(5, 5)[0] - 0.5).abs() < 1e-5, "{:?}", soft.get(5, 5));
-    }
-}
+mod tests;
diff --git a/crates/effects/src/channel3d/tests.rs b/crates/effects/src/channel3d/tests.rs
new file mode 100644
index 000000000..e69c2a6aa
--- /dev/null
+++ b/crates/effects/src/channel3d/tests.rs
@@ -0,0 +1,401 @@
+use super::*;
+use crate::{EffectEnv, EffectHost, LayerPixels, run_fx};
+use effectcraft_raster::channels3d::crypto_float;
+
+/// A 20×10 layer: left half object 1 at depth 100, right half object 2 at depth 500; the
+/// top-right corner is background. Cryptomatte: "left" / "right".
+struct AuxHost(Arc<AuxChannels>);
+impl EffectHost for AuxHost {
+    fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {
+        None
+    }
+    fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+        None
+    }
+    fn aux(&self) -> Option<Arc<AuxChannels>> {
+        Some(self.0.clone())
+    }
+}
+
+fn scene() -> AuxHost {
+    let (w, h) = (20usize, 10usize);
+    let mut a = AuxChannels::new(w as u32, h as u32, 1.0);
+    let (mut z, mut id, mut r, mut g) = (vec![0.0; w * h], vec![0.0; w * h], vec![0.0; w * h], vec![0.0; w * h]);
+    let (hl, hr) = (crypto_hash("left"), crypto_hash("right"));
+    for y in 0..h {
+        for x in 0..w {
+            let i = y * w + x;
+            if x >= 15 && y < 3 {
+                z[i] = BACKGROUND_DEPTH;
+            } else if x < 10 {
+                z[i] = 100.0;
+                id[i] = 1.0;
+                r[i] = crypto_float(hl);
+                g[i] = 1.0;
+            } else {
+                z[i] = 500.0;
+                id[i] = 2.0;
+                r[i] = crypto_float(hr);
+                g[i] = 1.0;
+            }
+        }
+    }
+    a.channels = vec![("Z".into(), z), ("ObjectID".into(), id), ("CryptoObject00.R".into(), r), ("CryptoObject00.G".into(), g)];
+    a.manifests = vec![("CryptoObject".into(), vec![("left".into(), hl), ("right".into(), hr)])];
+    AuxHost(Arc::new(a))
+}
+
+fn img() -> Image {
+    Image::filled(20, 10, [0.5, 0.5, 0.5, 1.0])
+}
+
+fn run(id: &str, vals: &[(&str, Value)], host: &AuxHost) -> Image {
+    run_fx(id, vals, img(), 0.0, EffectEnv { host: Some(host), ..Default::default() }).img
+}
+
+#[test]
+fn passes_through_without_aux_channels() {
+    for s in specs() {
+        let out = run_fx(s.id, &[], img(), 0.0, EffectEnv::default());
+        assert_eq!(out.img.data, img().data, "{}", s.id);
+    }
+}
+
+#[test]
+fn depth_matte_thresholds() {
+    let h = scene();
+    let o = run("ec.3d.depthmatte", &[("depth", num(300.0))], &h);
+    assert_eq!(o.get(2, 5)[3], 0.0);
+    assert_eq!(o.get(12, 5)[3], 1.0);
+    let inv = run("ec.3d.depthmatte", &[("depth", num(300.0)), ("invert", Value::Bool(true))], &h);
+    assert_eq!(inv.get(2, 5)[3], 1.0);
+    assert_eq!(inv.get(12, 5)[3], 0.0);
+    // Feather: a ramp of 800 units centred on 300 → depth 100 at 0.25, 500 at 0.75.
+    let f = run("ec.3d.depthmatte", &[("depth", num(300.0)), ("feather", num(800.0))], &h);
+    assert!((f.get(2, 5)[3] - 0.25).abs() < 1e-5 && (f.get(12, 5)[3] - 0.75).abs() < 1e-5);
+}
+
+#[test]
+fn channel_extract_maps_depth_and_ids() {
+    let h = scene();
+    let o = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(1000.0))], &h);
+    assert!((o.get(2, 5)[0] - 0.1).abs() < 1e-6 && (o.get(12, 5)[0] - 0.5).abs() < 1e-6);
+    assert_eq!(o.get(17, 1)[0], 1.0);
+    let ids = run("ec.3d.channelextract", &[("channel", Value::Enum(1)), ("whitePoint", num(2.0))], &h);
+    assert_eq!(ids.get(2, 5)[0], 0.5);
+    // Invert Depth Map flips the ramp; without Clamp Output values run past 1.
+    let inv = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(1000.0)), ("invertDepthMap", Value::Bool(true))], &h);
+    assert!((inv.get(2, 5)[0] - 0.9).abs() < 1e-6);
+    let raw = run("ec.3d.channelextract", &[("blackPoint", num(0.0)), ("whitePoint", num(100.0)), ("clampOutput", Value::Bool(false))], &h);
+    assert!(raw.get(12, 5)[0] > 1.5);
+}
+
+#[test]
+fn id_matte_and_identifier() {
+    let h = scene();
+    let o = run("ec.3d.idmatte", &[("idSelection", num(2.0))], &h);
+    assert_eq!(o.get(2, 5)[3], 0.0);
+    assert_eq!(o.get(12, 5)[3], 1.0);
+    let l = run("ec.3d.identifier", &[("display", Value::Enum(1)), ("id", num(1.0))], &h);
+    assert_eq!(l.get(2, 5)[0], 1.0);
+    assert_eq!(l.get(12, 5)[0], 0.0);
+    let c = run("ec.3d.identifier", &[], &h);
+    assert_ne!(c.get(2, 5), c.get(12, 5));
+}
+
+/// The parallel aux image (rank planes resolved once) is bit-identical to the per-pixel
+/// reduction over `crypto_ranks` it replaces.
+#[test]
+fn crypto_aux_image_matches_the_per_pixel_reduction() {
+    let (w, h) = (7u32, 5u32);
+    let n = (w * h) as usize;
+    let mut a = AuxChannels::new(w, h, 1.0);
+    let ids = [crypto_hash("cube"), crypto_hash("sphere"), crypto_hash("ring")].map(effectcraft_raster::channels3d::crypto_float);
+    for (k, ch) in ["00.R", "00.G", "00.B", "00.A", "01.R", "01.G", "01.B", "01.A"].iter().enumerate() {
+        let v: Vec<f32> = (0..n).map(|i| if k % 2 == 0 { ids[(i + k) % 3] } else { ((i * 7 + k * 3) % 11) as f32 / 10.0 }).collect();
+        a.channels.push((format!("CryptoObject{ch}"), v));
+    }
+    let sel = vec![crypto_hash("sphere"), crypto_hash("ring")];
+    let img = crypto_aux_image(&a, "CryptoObject", &sel);
+    for i in 0..n {
+        let ranks = a.crypto_ranks("CryptoObject", i);
+        let m: f32 = ranks.iter().filter(|(id, c)| *c > 0.0 && sel.contains(&id.to_bits())).map(|(_, c)| *c).sum::<f32>().clamp(0.0, 1.0);
+        let mut c = [0.0f32; 3];
+        for (id, cov) in &ranks {
+            let k = id_color(*id);
+            for j in 0..3 {
+                c[j] += k[j] * cov;
+            }
+        }
+        let want = [c[0], c[1], c[2], m];
+        assert_eq!(img.data[i].map(f32::to_bits), want.map(f32::to_bits), "pixel {i}");
+    }
+}
+
+/// The lookup before #473, kept as the reference: the rank channels formatted and searched
+/// by name for every pixel.
+fn ranks_by_name(a: &AuxChannels, layer: &str, i: usize) -> Vec<(f32, f32)> {
+    let mut out = vec![];
+    for k in 0.. {
+        let get = |c: &str| a.get(&format!("{layer}{k:02}.{c}"));
+        let (Some(r), Some(g)) = (get("R"), get("G")) else { break };
+        out.push((r[i], g[i]));
+        if let (Some(b), Some(al)) = (get("B"), get("A")) {
+            out.push((b[i], al[i]));
+        }
+    }
+    out
+}
+
+/// The reduction before #473 over those ranks: (ID colours, selection coverage).
+fn reduce_by_name(a: &AuxChannels, layer: &str, sel: &[u32], i: usize) -> ([f32; 3], f32) {
+    let ranks = ranks_by_name(a, layer, i);
+    let m: f32 = ranks.iter().filter(|(id, c)| *c > 0.0 && sel.contains(&id.to_bits())).map(|(_, c)| *c).sum::<f32>().clamp(0.0, 1.0);
+    let mut c = [0.0f32; 3];
+    for (id, cov) in &ranks {
+        let k = id_color(*id);
+        for j in 0..3 {
+            c[j] += k[j] * cov;
+        }
+    }
+    (c, m)
+}
+
+/// A 6×2 Cryptomatte layer with awkward values: NaN, ±inf, negative and -0.0 coverage, NaN
+/// and -0.0 IDs; rank 01 has no B/A pair, rank 02 is missing, so rank 03 (filled with values
+/// that would change every pixel) must be ignored as before.
+fn edge_aux(with_rank_after_gap: bool) -> AuxChannels {
+    let (w, h) = (6u32, 2u32);
+    let nan_payload = f32::from_bits(0x7fc0_1234);
+    let (hs, hc) = (crypto_float(crypto_hash("sphere")), crypto_float(crypto_hash("cube")));
+    let cov = [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, -0.5, -0.0, 0.0, 0.25, 1.0, 2.0, f32::MIN_POSITIVE, nan_payload, 0.5];
+    let ids = [hs, f32::NAN, hc, -0.0, 0.0, nan_payload, hs, hc, f32::NAN, hs, hc, -0.0];
+    let rot = |v: &[f32; 12], k: usize| -> Vec<f32> { (0..12).map(|i| v[(i + k) % 12]).collect() };
+    let mut a = AuxChannels::new(w, h, 1.0);
+    let mut push = |n: &str, v: Vec<f32>| a.channels.push((format!("CryptoObject{n}"), v));
+    push("00.R", rot(&ids, 0));
+    push("00.G", rot(&cov, 0));
+    push("00.B", rot(&ids, 3));
+    push("00.A", rot(&cov, 5));
+    push("01.R", rot(&ids, 7));
+    push("01.G", rot(&cov, 2));
+    if with_rank_after_gap {
+        push("03.R", vec![hs; 12]);
+        push("03.G", vec![1.0; 12]);
+        push("03.B", vec![hc; 12]);
+        push("03.A", vec![1.0; 12]);
+    }
+    a
+}
+
+/// The memo hands out exactly `id_color`'s bits for every rank and pixel of the edge values
+/// (NaN IDs with and without a payload, -0.0 and 0.0 are keyed by their bits).
+#[test]
+fn id_color_memo_matches_id_color() {
+    let a = edge_aux(true);
+    let planes = a.crypto_rank_planes("CryptoObject");
+    let mut memo = IdColorMemo::default();
+    for i in 0..12 {
+        for (r, (id, _)) in planes.iter().enumerate() {
+            assert_eq!(memo.get(r, id[i]).map(f32::to_bits), id_color(id[i]).map(f32::to_bits), "pixel {i} rank {r}");
+        }
+    }
+}
+
+fn edge_selection() -> Vec<u32> {
+    vec![crypto_hash("sphere"), f32::NAN.to_bits(), 0x7fc0_1234, (-0.0f32).to_bits()]
+}
+
+/// Edge values give bit-identical results to the lookup by name, the missing B/A pair is
+/// skipped and a rank after a gap is ignored.
+#[test]
+fn crypto_aux_image_is_bit_exact_on_edge_values() {
+    let sel = edge_selection();
+    let a = edge_aux(true);
+    assert_eq!(a.crypto_rank_planes("CryptoObject").len(), 3, "00.R/G, 00.B/A, 01.R/G; not 03 after the gap");
+    let img = crypto_aux_image(&a, "CryptoObject", &sel);
+    let without_gap_rank = crypto_aux_image(&edge_aux(false), "CryptoObject", &sel);
+    for i in 0..12 {
+        let (c, m) = reduce_by_name(&a, "CryptoObject", &sel, i);
+        let want = [c[0], c[1], c[2], m];
+        assert_eq!(img.data[i].map(f32::to_bits), want.map(f32::to_bits), "pixel {i}");
+        assert_eq!(img.data[i].map(f32::to_bits), without_gap_rank.data[i].map(f32::to_bits), "pixel {i}: the rank after the gap was used");
+    }
+}
+
+/// Without the ID colours the matte (A) is bit-identical and the RGB is 0, on the edge values.
+#[test]
+fn crypto_aux_image_without_colors_keeps_the_matte() {
+    let a = edge_aux(true);
+    let sel = edge_selection();
+    let full = crypto_aux_image(&a, "CryptoObject", &sel);
+    let matte = crypto_aux_image_with(&a, "CryptoObject", &sel, CryptoAux::MatteOnly);
+    for (f, m) in full.data.iter().zip(&matte.data) {
+        assert_eq!(f[3].to_bits(), m[3].to_bits());
+        assert_eq!(m[..3], [0.0; 3]);
+    }
+}
+
+/// Only the Colors display without Matte Only reads the ID colours.
+#[test]
+fn crypto_aux_for_display_reads_colors_only_for_the_colors_display() {
+    assert_eq!(CryptoAux::for_display(0, false), CryptoAux::ColorsAndMatte);
+    assert_eq!(CryptoAux::for_display(0, true), CryptoAux::MatteOnly);
+    for display in [1, 2, 3, u32::MAX] {
+        for matte_only in [false, true] {
+            assert_eq!(CryptoAux::for_display(display, matte_only), CryptoAux::MatteOnly, "display {display}");
+        }
+    }
+}
+
+/// The CPU effect on a 20×10 layer over the 6×2 edge aux: pixels inside the aux area match
+/// the lookup by name bit for bit in every display mode, pixels outside it (no aux index)
+/// get an empty matte and no ID colour.
+#[test]
+fn cryptomatte_cpu_path_is_bit_exact_inside_and_outside_the_aux_area() {
+    let a = edge_aux(true);
+    let host = AuxHost(Arc::new(a.clone()));
+    let names = "sphere, <7fc00000>, <7fc01234>, <80000000>";
+    assert_eq!(selection_hashes(names, None), edge_selection());
+    let src = img().data[0];
+    for (display, matte_only) in [(0, false), (1, false), (2, false), (0, true)] {
+        let out = run(
+            "ec.3d.cryptomatte",
+            &[("selection", Value::Str(names.into())), ("display", Value::Enum(display)), ("matteOnly", Value::Bool(matte_only))],
+            &host,
+        );
+        let expect = |c: [f32; 3], m: f32| -> [f32; 4] {
+            if matte_only {
+                return [m; 4];
+            }
+            match display {
+                0 => {
+                    let c = c.map(|v| v * (1.0 - 0.5 * m) + 0.5 * m);
+                    [c[0], c[1], c[2], 1.0]
+                }
+                1 => src.map(|v| v * m),
+                _ => [src[0] * (1.0 - 0.5 * m) + 0.5 * m * src[3], src[1] * (1.0 - 0.5 * m) + 0.5 * m * src[3], src[2] * (1.0 - 0.5 * m), src[3]],
+            }
+        };
+        for (x, y) in [(0u32, 0u32), (1, 0), (5, 0), (0, 1), (3, 1), (5, 1)] {
+            let (c, m) = reduce_by_name(&a, "CryptoObject", &edge_selection(), (y * 6 + x) as usize);
+            assert_eq!(out.get(x as i64, y as i64).map(f32::to_bits), expect(c, m).map(f32::to_bits), "display {display} matteOnly {matte_only} at ({x}, {y})");
+        }
+        for (x, y) in [(6u32, 0u32), (19, 0), (0, 2), (12, 9)] {
+            assert_eq!(
+                out.get(x as i64, y as i64).map(f32::to_bits),
+                expect([0.0; 3], 0.0).map(f32::to_bits),
+                "display {display} matteOnly {matte_only} outside the aux at ({x}, {y})"
+            );
+        }
+    }
+}
+
+#[test]
+fn cryptomatte_selects_by_name_and_wildcard() {
+    let h = scene();
+    let m = run("ec.3d.cryptomatte", &[("selection", Value::Str("right".into())), ("matteOnly", Value::Bool(true))], &h);
+    assert_eq!(m.get(2, 5)[3], 0.0);
+    assert_eq!(m.get(12, 5)[3], 1.0);
+    let w = run("ec.3d.cryptomatte", &[("selection", Value::Str("l*".into())), ("display", Value::Enum(1))], &h);
+    assert_eq!(w.get(2, 5)[3], 1.0);
+    assert_eq!(w.get(12, 5)[3], 0.0);
+    assert!(wild("*ight", "right") && wild("r*t", "right") && !wild("x*", "right"));
+    let hex = format!("<{:08x}>", crypto_hash("left"));
+    assert_eq!(selection_hashes(&hex, None), vec![crypto_hash("left")]);
+}
+
+/// #473: a name with a comma in it (Blender allows `Green, Glossy`) is selected when it is
+/// quoted or its comma escaped, instead of being cut into two names that match nothing.
+#[test]
+fn cryptomatte_selection_keeps_quoted_names_with_commas_whole() {
+    let manifest = vec![("Green, Glossy".to_string(), 7), ("Green".to_string(), 1), ("Glossy".to_string(), 2), ("ring".to_string(), 3)];
+    let m = Some(manifest.as_slice());
+    assert_eq!(selection_hashes(r#""Green, Glossy""#, m), vec![7]);
+    assert_eq!(selection_hashes("'Green, Glossy', ring", m), vec![7, 3]);
+    assert_eq!(selection_hashes(r"Green\, Glossy", m), vec![7]);
+    assert_eq!(selection_hashes(r#"ring , "Green, Glossy""#, m), vec![3, 7]);
+    // Without a manifest the whole name is hashed.
+    assert_eq!(selection_hashes(r#""Green, Glossy""#, None), vec![crypto_hash("Green, Glossy")]);
+    // Plain lists, apostrophes inside names and an unclosed quote still parse.
+    assert_eq!(selection_hashes("Green, Glossy", m), vec![1, 2]);
+    assert_eq!(selection_names("Bob's mat, ring"), vec!["Bob's mat", "ring"]);
+    assert_eq!(selection_names(r#""Green, Glossy"#), vec!["Green, Glossy"]);
+    assert_eq!(selection_names(r#"say \"hi\""#), vec![r#"say "hi""#]);
+}
+
+#[test]
+fn fog_and_depth_of_field_follow_depth() {
+    let h = scene();
+    let f = run("ec.3d.fog3d", &[("fogColor", col(1.0, 0.0, 0.0)), ("fogEndDepth", num(1000.0)), ("scatteringDensity", num(0.0))], &h);
+    // Linear fog: 10 % at depth 100, 50 % at 500, full on the background.
+    assert!((f.get(2, 5)[0] - 0.55).abs() < 1e-4, "{:?}", f.get(2, 5));
+    assert!((f.get(12, 5)[0] - 0.75).abs() < 1e-4);
+    assert!((f.get(17, 1)[0] - 1.0).abs() < 1e-4 && f.get(17, 1)[1] < 1e-4);
+    assert!((dof_radius(100.0, 100.0, 0.0, 10.0, 50.0)).abs() < 1e-6);
+    assert!((dof_radius(200.0, 100.0, 0.0, 10.0, 50.0) - 10.0).abs() < 1e-6);
+    assert_eq!(dof_radius(140.0, 100.0, 100.0, 10.0, 50.0), 0.0);
+    // A sharp edge at the far object blurs when focused near.
+    let mut pic = Image::new(20, 10);
+    for y in 0..10 {
+        for x in 0..20 {
+            let v = if x % 2 == 0 { 1.0 } else { 0.0 };
+            pic.set(x, y, [v, v, v, 1.0]);
+        }
+    }
+    let env = EffectEnv { host: Some(&h), ..Default::default() };
+    let d = run_fx("ec.3d.depthoffield", &[("focalPlane", num(100.0)), ("maximumRadius", num(4.0))], pic.clone(), 0.0, env).img;
+    assert_eq!(d.get(4, 5), pic.get(4, 5));
+    assert!((d.get(12, 5)[0] - 0.5).abs() < 0.3 && d.get(12, 5) != pic.get(12, 5));
+}
+
+#[test]
+fn extractor_maps_named_channels() {
+    let h = scene();
+    let o = run("ec.3d.extractor", &[("red", Value::Str("Z".into())), ("whitePoint", num(1000.0))], &h);
+    assert!((o.get(2, 5)[0] - 0.1).abs() < 1e-6);
+    assert!((o.get(2, 5)[1] - 0.0005).abs() < 1e-6);
+    // Without aux: the layer's own channels can be swapped.
+    let s = run_fx("ec.3d.extractor", &[("red", Value::Str("A".into()))], Image::filled(2, 2, [0.2, 0.3, 0.4, 1.0]), 0.0, EffectEnv::default());
+    assert_eq!(s.img.get(0, 0), [1.0, 0.3, 0.4, 1.0]);
+}
+
+#[test]
+fn channel_extract_antialias_averages_sub_pixels() {
+    // Depth at twice the layer resolution, alternating 0 / 1000 per aux column.
+    let mut a = AuxChannels::new(40, 20, 2.0);
+    a.channels = vec![("Z".into(), (0..800).map(|i| if i % 2 == 0 { 0.0 } else { 1000.0 }).collect())];
+    let host = AuxHost(Arc::new(a));
+    let vals = [("blackPoint", num(0.0)), ("whitePoint", num(1000.0))];
+    let hard = run("ec.3d.channelextract", &vals, &host);
+    let v = hard.get(5, 5)[0];
+    assert!(v == 0.0 || v == 1.0, "{v}");
+    let soft = run("ec.3d.channelextract", &[vals.as_slice(), &[("antialias", Value::Bool(true))]].concat(), &host);
+    assert!((soft.get(5, 5)[0] - 0.5).abs() < 1e-5, "{:?}", soft.get(5, 5));
+}
+
+#[test]
+fn instance3d_replaces_the_pixels_with_the_referenced_layer() {
+    // Create 3D Layer Instance's copy: the chosen layer's render takes the place of the layer's
+    // own pixels, alpha included — the copy is transparent where the referenced layer isn't —
+    // and with no layer chosen the layer passes through.
+    struct Host(Image);
+    impl EffectHost for Host {
+        fn layer(&self, id: u64, _: bool) -> Option<LayerPixels> {
+            (id == 7).then(|| LayerPixels { buf: Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 }, size: [self.0.width as f64, self.0.height as f64] })
+        }
+        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+            None
+        }
+    }
+    let solid = || Image::filled(4, 4, [1.0, 1.0, 1.0, 1.0]);
+    let mut render = Image::new(4, 4);
+    render.set(1, 1, [1.0, 0.0, 0.0, 1.0]);
+    let env = EffectEnv { host: Some(&Host(render)), ..Default::default() };
+    let out = run_fx("ec.3d.instance3d", &[("layer", Value::Layer(Some(7)))], solid(), 0.0, env);
+    assert_eq!(out.img.get(1, 1), [1.0, 0.0, 0.0, 1.0], "the referenced layer's pixel");
+    assert_eq!(out.img.get(3, 3), [0.0; 4], "transparent where the referenced layer isn't");
+    // No layer chosen: the layer's own pixels.
+    let out = run_fx("ec.3d.instance3d", &[], solid(), 0.0, EffectEnv::default());
+    assert_eq!(out.img.data, solid().data);
+}
diff --git a/crates/effects/src/color2.rs b/crates/effects/src/color2.rs
index 9547fd775..25203cd7a 100644
--- a/crates/effects/src/color2.rs
+++ b/crates/effects/src/color2.rs
@@ -1129,347 +1129,4 @@ pub fn specs() -> Vec<EffectSpec> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{Params, find};
-
-    fn run(id: &str, img: &Image, over: &[(&str, Value)]) -> Image {
-        let s = find(id).unwrap();
-        let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-        for (k, v) in over {
-            params.values.insert(k.to_string(), v.clone());
-        }
-        let ctx =
-            EffectCtx { params: &params, time: 0.0, layer_size: [img.width as f64, img.height as f64], seed: 1, adjustment: false, env: Default::default() };
-        (s.render)(&ctx, Buf { img: img.clone(), offset: [0.0, 0.0], scale: 1.0 }).img
-    }
-
-    fn ramp() -> Image {
-        let mut img = Image::new(16, 8);
-        for y in 0..8 {
-            for x in 0..16 {
-                let v = x as f32 / 15.0;
-                let a = if y == 0 { 0.5 } else { 1.0 };
-                img.set(x, y, [v * a, (1.0 - v) * a, 0.3 * a, a]);
-            }
-        }
-        img
-    }
-
-    fn close(a: &Image, b: &Image, eps: f32) -> bool {
-        a.data.iter().zip(&b.data).all(|(p, q)| (0..4).all(|i| (p[i] - q[i]).abs() <= eps))
-    }
-
-    #[test]
-    fn curve_parsing() {
-        assert!(Curve::parse("0,0 1,1").is_none());
-        assert!(Curve::parse("garbage").is_none());
-        let c = Curve::parse("1,1; 0,0 0.5,0.7").unwrap();
-        assert_eq!(c.xs, vec![0.0, 0.5, 1.0]);
-        assert!((c.eval(0.5) - 0.7).abs() < 1e-3);
-        // Monotone: never decreases.
-        let mut last = -1.0;
-        for i in 0..=100 {
-            let v = c.eval(i as f32 / 100.0);
-            assert!(v >= last - 1e-6);
-            last = v;
-        }
-    }
-
-    #[test]
-    fn curves_identity_is_identity() {
-        let img = ramp();
-        assert_eq!(run("ec.color.curves", &img, &[]), img);
-        let explicit = run("ec.color.curves", &img, &[("rgb", Value::Str("0,0 0.25,0.25 1,1".into()))]);
-        assert!(close(&explicit, &img, 1e-4));
-    }
-
-    #[test]
-    fn curves_midpoint_brightens() {
-        let img = Image::filled(4, 4, [0.5, 0.5, 0.5, 1.0]);
-        let out = run("ec.color.curves", &img, &[("rgb", Value::Str("0,0 0.5,0.75 1,1".into()))]);
-        assert!((out.data[0][0] - 0.75).abs() < 1e-3);
-        let red = run("ec.color.curves", &img, &[("red", Value::Str("0,1 1,1".into()))]);
-        assert!((red.data[0][0] - 1.0).abs() < 1e-4 && (red.data[0][1] - 0.5).abs() < 1e-6);
-    }
-
-    /// After Effects 2026, 32 bpc project, Levels (Individual Controls) with RGB Input Black 0.1,
-    /// Input White 0.9, Gamma 1.5, Output Black 0.05, Output White 0.95, Red Gamma 0.8, Green
-    /// Input White 0.8, Blue Output Black 0.2, both clips "Off for 32 bpc Color", on grey steps:
-    /// the channel controls run first, nothing clips (8-bit captures clamp the results).
-    #[test]
-    fn levels_ic_matches_after_effects_in_32_bpc() {
-        let steps = [0, 16, 32, 64, 96, 128, 160, 192, 224, 255];
-        let ae = [
-            [0, 0, 70],
-            [0, 0, 88],
-            [0, 52, 104],
-            [61, 108, 132],
-            [102, 150, 158],
-            [138, 187, 181],
-            [171, 220, 203],
-            [203, 250, 223],
-            [233, 255, 243],
-            [255, 255, 255],
-        ];
-        let mut img = Image::new(10, 1);
-        for (x, v) in steps.iter().enumerate() {
-            let v = *v as f32 / 255.0;
-            img.set(x as u32, 0, [v, v, v, 1.0]);
-        }
-        let vals = [
-            ("rgb/rgbInBlack", Value::Scalar(0.1)),
-            ("rgb/rgbInWhite", Value::Scalar(0.9)),
-            ("rgb/rgbGamma", Value::Scalar(1.5)),
-            ("rgb/rgbOutBlack", Value::Scalar(0.05)),
-            ("rgb/rgbOutWhite", Value::Scalar(0.95)),
-            ("red/redGamma", Value::Scalar(0.8)),
-            ("green/greenInWhite", Value::Scalar(0.8)),
-            ("blue/blueOutBlack", Value::Scalar(0.2)),
-        ];
-        let s = find("ec.color.levelsic").unwrap();
-        let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-        for (k, v) in &vals {
-            params.values.insert(k.to_string(), v.clone());
-        }
-        let render = |float_depth: bool| {
-            let env = crate::EffectEnv { float_depth, ..Default::default() };
-            let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [10.0, 1.0], seed: 1, adjustment: false, env };
-            (s.render)(&ctx, Buf { img: img.clone(), offset: [0.0, 0.0], scale: 1.0 }).img
-        };
-        let out = render(true);
-        for (x, want) in ae.iter().enumerate() {
-            let p = out.get(x as i64, 0);
-            for c in 0..3 {
-                let got = p[c].clamp(0.0, 1.0) * 255.0;
-                assert!((got - want[c] as f32).abs() <= 2.0, "step {} channel {c}: {got} vs AE {}", steps[x], want[c]);
-            }
-        }
-        // In 8 / 16 bpc "Off for 32 bpc Color" clips: black stops at Output Black.
-        let clipped = render(false);
-        assert!((clipped.get(0, 0)[0] - 0.05).abs() < 1e-5, "{:?}", clipped.get(0, 0));
-    }
-
-    /// After Effects 2026 (cases 962 / 963): Curves through RGB (0,0) (125,199)
-    /// (255,255) and Red (0,0) (128,44) (255,255) on grey steps 0..255, 8-bit results.
-    #[test]
-    fn curves_follow_a_natural_spline_as_in_after_effects() {
-        let steps = [0u8, 16, 32, 64, 96, 128, 160, 192, 224, 255];
-        let mut img = Image::new(10, 1);
-        for (x, v) in steps.iter().enumerate() {
-            let v = *v as f32 / 255.0;
-            img.set(x as u32, 0, [v, v, v, 1.0]);
-        }
-        let p = |pts: &[(f32, f32)]| Value::Str(pts.iter().map(|(x, y)| format!("{},{}", x / 255.0, y / 255.0)).collect::<Vec<_>>().join(" "));
-        let rgb = run("ec.color.curves", &img, &[("rgb", p(&[(0.0, 0.0), (125.0, 199.0), (255.0, 255.0)]))]);
-        let red = run("ec.color.curves", &img, &[("red", p(&[(0.0, 0.0), (128.0, 44.0), (255.0, 255.0)]))]);
-        let ae_rgb = [0, 30, 59, 115, 164, 202, 227, 242, 250, 255];
-        let ae_red = [0, 0, 1, 6, 19, 44, 83, 135, 194, 255];
-        for x in 0..10 {
-            let g = (rgb.get(x as i64, 0)[1] * 255.0).round() as i32;
-            let r = (red.get(x as i64, 0)[0] * 255.0).round() as i32;
-            assert!((g - ae_rgb[x]).abs() <= 1, "RGB step {}: {g} vs AE {}", steps[x], ae_rgb[x]);
-            assert!((r - ae_red[x]).abs() <= 1, "Red step {}: {r} vs AE {}", steps[x], ae_red[x]);
-        }
-    }
-
-    #[test]
-    fn levels_ic_identity_and_red_only() {
-        let img = ramp();
-        assert_eq!(run("ec.color.levelsic", &img, &[]), img);
-        let out = run("ec.color.levelsic", &img, &[("red/redOutWhite", num(0.5))]);
-        let p = out.get(15, 3);
-        assert!((p[0] - 0.5).abs() < 1e-4 && (p[1] - 0.0).abs() < 1e-4);
-    }
-
-    #[test]
-    fn auto_levels_stretches_low_contrast() {
-        let mut img = Image::new(32, 4);
-        for y in 0..4 {
-            for x in 0..32 {
-                let v = 0.4 + 0.2 * x as f32 / 31.0;
-                img.set(x, y, [v, v, v, 1.0]);
-            }
-        }
-        let out = run("ec.color.autolevels", &img, &[("blackClip", num(0.0)), ("whiteClip", num(0.0))]);
-        let lo = out.data.iter().map(|p| p[0]).fold(1.0, f32::min);
-        let hi = out.data.iter().map(|p| p[0]).fold(0.0, f32::max);
-        assert!(lo < 0.02 && hi > 0.98, "{lo} {hi}");
-        let ac = run("ec.color.autocontrast", &img, &[("blackClip", num(0.0)), ("whiteClip", num(0.0))]);
-        assert!(ac.data.iter().map(|p| p[0]).fold(0.0, f32::max) > 0.98);
-    }
-
-    #[test]
-    fn auto_color_neutralises_cast() {
-        let mut img = Image::new(16, 4);
-        for y in 0..4 {
-            for x in 0..16 {
-                let v = x as f32 / 15.0;
-                img.set(x, y, [v * 0.6 + 0.1, v * 0.9, v * 0.5, 1.0]);
-            }
-        }
-        let out = run("ec.color.autocolor", &img, &[]);
-        let p = out.get(8, 1);
-        assert!((p[0] - p[1]).abs() < 0.08 && (p[1] - p[2]).abs() < 0.08, "{p:?}");
-    }
-
-    #[test]
-    fn equalize_flattens_histogram() {
-        let mut img = Image::new(64, 1);
-        for x in 0..64 {
-            let v = if x < 48 { 0.1 + x as f32 * 0.001 } else { 0.9 };
-            img.set(x, 0, [v, v, v, 1.0]);
-        }
-        let out = run("ec.color.equalize", &img, &[]);
-        // The crowded dark values are spread across the range.
-        assert!(out.get(47, 0)[0] > 0.6, "{}", out.get(47, 0)[0]);
-        assert!(out.get(0, 0)[0] < 0.1);
-        assert_eq!(run("ec.color.equalize", &img, &[("amount", num(0.0))]), img);
-    }
-
-    #[test]
-    fn selective_color_zero_is_identity_and_reds_respond() {
-        let img = ramp();
-        assert_eq!(run("ec.color.selectivecolor", &img, &[]), img);
-        let red = Image::filled(2, 2, [1.0, 0.1, 0.1, 1.0]);
-        let out = run("ec.color.selectivecolor", &red, &[("details/reds/redsCyan", num(100.0)), ("method", Value::Enum(1))]);
-        assert!(out.data[0][0] < 0.3, "{:?}", out.data[0]);
-        let blue = Image::filled(2, 2, [0.1, 0.1, 1.0, 1.0]);
-        assert_eq!(run("ec.color.selectivecolor", &blue, &[("details/reds/redsCyan", num(100.0))]), blue);
-    }
-
-    #[test]
-    fn color_offset_full_turn_is_identity() {
-        let img = ramp();
-        let out = run("ec.color.cccoloroffset", &img, &[("redPhase", num(360.0)), ("greenPhase", num(720.0))]);
-        assert_eq!(out, img);
-        let out = run("ec.color.cccoloroffset", &img, &[("redPhase", num(180.0))]);
-        assert!((out.get(0, 3)[0] - 0.5).abs() < 1e-4);
-    }
-
-    #[test]
-    fn broadcast_reduces_unsafe_color() {
-        let img = Image::filled(2, 2, [1.0, 1.0, 0.0, 1.0]);
-        let out = run("ec.color.broadcast", &img, &[]);
-        assert!(out.data[0][0] < 1.0);
-        let key = run("ec.color.broadcast", &img, &[("howToMakeSafe", Value::Enum(2))]);
-        assert_eq!(key.data[0][3], 0.0);
-        let gray = Image::filled(2, 2, [0.5, 0.5, 0.5, 1.0]);
-        assert_eq!(run("ec.color.broadcast", &gray, &[]), gray);
-    }
-
-    #[test]
-    fn color_balance_hls_zero_identity_and_hue_shift() {
-        let img = ramp();
-        assert_eq!(run("ec.color.colorbalancehls", &img, &[]), img);
-        let red = Image::filled(1, 1, [1.0, 0.0, 0.0, 1.0]);
-        let out = run("ec.color.colorbalancehls", &red, &[("hue", num(120.0))]);
-        assert!(out.data[0][1] > 0.99 && out.data[0][0] < 0.01);
-    }
-
-    #[test]
-    fn color_link_fills_with_average_keeping_alpha() {
-        let mut img = Image::new(2, 1);
-        img.set(0, 0, [1.0, 0.0, 0.0, 1.0]);
-        img.set(1, 0, [0.0, 0.0, 0.5, 0.5]);
-        let out = run("ec.color.colorlink", &img, &[]);
-        assert!((out.data[1][3] - 0.5).abs() < 1e-5);
-        let (c, _) = unpremul(out.data[0]);
-        assert!((c[0] - 2.0 / 3.0).abs() < 1e-3 && (c[2] - 1.0 / 3.0).abs() < 1e-3, "{c:?}");
-    }
-
-    #[test]
-    fn cc_kernel_identity_and_toner_duotone() {
-        let img = ramp();
-        assert_eq!(run("ec.color.cckernel", &img, &[]), img);
-        let g = Image::filled(1, 1, [0.5, 0.5, 0.5, 1.0]);
-        let t = run("ec.color.cctoner", &g, &[("tones", Value::Enum(0)), ("highlights", col(1.0, 0.0, 0.0))]);
-        assert!((t.data[0][0] - 0.5).abs() < 1e-3 && t.data[0][1] < 1e-3);
-    }
-
-    #[test]
-    fn shadow_highlight_lifts_shadows() {
-        let img = Image::filled(8, 8, [0.1, 0.1, 0.1, 1.0]);
-        let out = run("ec.color.shadowhighlight", &img, &[("autoAmounts", Value::Bool(false))]);
-        assert!(out.data[0][0] > 0.15);
-    }
-
-    #[test]
-    fn levels_ic_clip_popups() {
-        let img = Image::filled(2, 2, [0.9, 0.9, 0.9, 1.0]);
-        let lv = [("rgb/rgbInWhite", num(0.5))];
-        assert!((run("ec.color.levelsic", &img, &lv).data[0][0] - 1.0).abs() < 1e-6);
-        let off = [("rgb/rgbInWhite", num(0.5)), ("clipToOutputWhite", Value::Enum(0))];
-        assert!(run("ec.color.levelsic", &img, &off).data[0][0] > 1.5);
-    }
-
-    /// A host whose other layers and other frames are a fixed image.
-    struct ImgHost(Image);
-    impl crate::EffectHost for ImgHost {
-        fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
-            Some(crate::LayerPixels { buf: Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 }, size: [2.0, 2.0] })
-        }
-        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
-            None
-        }
-        fn self_at(&self, _: f64, _: usize) -> Option<Buf> {
-            Some(Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 })
-        }
-    }
-
-    fn run_host(id: &str, img: &Image, over: &[(&str, Value)], host: &ImgHost) -> Image {
-        let env = crate::EffectEnv { host: Some(host), frame_rate: 10.0, ..Default::default() };
-        crate::run_fx(id, over, img.clone(), 1.0, env).img
-    }
-
-    #[test]
-    fn color_link_samples_clip_and_source_layer() {
-        let mut img = Image::new(5, 1);
-        for (x, v) in [0.0f32, 0.1, 0.2, 0.3, 1.0].iter().enumerate() {
-            img.set(x as u32, 0, [*v, *v, *v, 1.0]);
-        }
-        // Median ignores the outlier the average follows.
-        let med = run("ec.color.colorlink", &img, &[("sampleSource", Value::Enum(1))]);
-        assert!((med.data[0][0] - 0.2).abs() < 1e-5);
-        // Brightest with 20 % clip skips the brightest pixel.
-        let br = run("ec.color.colorlink", &img, &[("sampleSource", Value::Enum(2)), ("clip", num(20.0))]);
-        assert!((br.data[0][0] - 0.3).abs() < 1e-5);
-        // Min Alpha of a half-transparent source layer sets the alpha.
-        let host = ImgHost(Image::filled(2, 2, [0.25, 0.25, 0.25, 0.5]));
-        let out = run_host("ec.color.colorlink", &img, &[("sourceLayer", Value::Layer(Some(9))), ("sampleSource", Value::Enum(9))], &host);
-        assert!((out.data[4][3] - 0.5).abs() < 1e-5);
-        // Average of the source layer (not the effect's own pixels).
-        let out = run_host("ec.color.colorlink", &img, &[("sourceLayer", Value::Layer(Some(9)))], &host);
-        assert!((out.data[4][0] - 0.5).abs() < 1e-5);
-    }
-
-    #[test]
-    fn auto_levels_temporal_smoothing_reads_neighbour_frames() {
-        let mut img = Image::new(4, 1);
-        for x in 0..4 {
-            let v = 0.3 + 0.1 * x as f32;
-            img.set(x, 0, [v, v, v, 1.0]);
-        }
-        let wide = ImgHost(ramp());
-        let p0 = [("blackClip", num(0.0)), ("whiteClip", num(0.0))];
-        let alone = run_host("ec.color.autolevels", &img, &p0, &wide);
-        let smooth = run_host("ec.color.autolevels", &img, &[p0[0].clone(), p0[1].clone(), ("temporalSmoothing", num(0.2))], &wide);
-        // Alone the frame is stretched to full range; with full-range neighbours much less.
-        assert!(alone.data[0][0] < 0.01);
-        assert!(smooth.data[0][0] > 0.1, "{:?}", smooth.data[0]);
-    }
-
-    #[test]
-    fn shadow_highlight_clip_keeps_the_tonal_range() {
-        let img = ramp();
-        let lift = [("autoAmounts", Value::Bool(false)), ("shadowAmount", num(80.0))];
-        let unclipped = run(
-            "ec.color.shadowhighlight",
-            &img,
-            &[lift[0].clone(), lift[1].clone(), ("moreOptions/blackClip", num(0.0)), ("moreOptions/whiteClip", num(0.0))],
-        );
-        let clipped = run("ec.color.shadowhighlight", &img, &[lift[0].clone(), lift[1].clone(), ("moreOptions/blackClip", num(1.0))]);
-        let min = |im: &Image| im.data.iter().filter(|p| p[3] > 0.99).map(|p| luminance(p[0], p[1], p[2])).fold(f32::MAX, f32::min);
-        assert!(min(&clipped) < min(&unclipped));
-    }
-}
+mod tests;
diff --git a/crates/effects/src/color2/tests.rs b/crates/effects/src/color2/tests.rs
new file mode 100644
index 000000000..5f57692a0
--- /dev/null
+++ b/crates/effects/src/color2/tests.rs
@@ -0,0 +1,338 @@
+use super::*;
+use crate::{Params, find};
+
+fn run(id: &str, img: &Image, over: &[(&str, Value)]) -> Image {
+    let s = find(id).unwrap();
+    let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+    for (k, v) in over {
+        params.values.insert(k.to_string(), v.clone());
+    }
+    let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [img.width as f64, img.height as f64], seed: 1, adjustment: false, env: Default::default() };
+    (s.render)(&ctx, Buf { img: img.clone(), offset: [0.0, 0.0], scale: 1.0 }).img
+}
+
+fn ramp() -> Image {
+    let mut img = Image::new(16, 8);
+    for y in 0..8 {
+        for x in 0..16 {
+            let v = x as f32 / 15.0;
+            let a = if y == 0 { 0.5 } else { 1.0 };
+            img.set(x, y, [v * a, (1.0 - v) * a, 0.3 * a, a]);
+        }
+    }
+    img
+}
+
+fn close(a: &Image, b: &Image, eps: f32) -> bool {
+    a.data.iter().zip(&b.data).all(|(p, q)| (0..4).all(|i| (p[i] - q[i]).abs() <= eps))
+}
+
+#[test]
+fn curve_parsing() {
+    assert!(Curve::parse("0,0 1,1").is_none());
+    assert!(Curve::parse("garbage").is_none());
+    let c = Curve::parse("1,1; 0,0 0.5,0.7").unwrap();
+    assert_eq!(c.xs, vec![0.0, 0.5, 1.0]);
+    assert!((c.eval(0.5) - 0.7).abs() < 1e-3);
+    // Monotone: never decreases.
+    let mut last = -1.0;
+    for i in 0..=100 {
+        let v = c.eval(i as f32 / 100.0);
+        assert!(v >= last - 1e-6);
+        last = v;
+    }
+}
+
+#[test]
+fn curves_identity_is_identity() {
+    let img = ramp();
+    assert_eq!(run("ec.color.curves", &img, &[]), img);
+    let explicit = run("ec.color.curves", &img, &[("rgb", Value::Str("0,0 0.25,0.25 1,1".into()))]);
+    assert!(close(&explicit, &img, 1e-4));
+}
+
+#[test]
+fn curves_midpoint_brightens() {
+    let img = Image::filled(4, 4, [0.5, 0.5, 0.5, 1.0]);
+    let out = run("ec.color.curves", &img, &[("rgb", Value::Str("0,0 0.5,0.75 1,1".into()))]);
+    assert!((out.data[0][0] - 0.75).abs() < 1e-3);
+    let red = run("ec.color.curves", &img, &[("red", Value::Str("0,1 1,1".into()))]);
+    assert!((red.data[0][0] - 1.0).abs() < 1e-4 && (red.data[0][1] - 0.5).abs() < 1e-6);
+}
+
+/// After Effects 2026, 32 bpc project, Levels (Individual Controls) with RGB Input Black 0.1,
+/// Input White 0.9, Gamma 1.5, Output Black 0.05, Output White 0.95, Red Gamma 0.8, Green
+/// Input White 0.8, Blue Output Black 0.2, both clips "Off for 32 bpc Color", on grey steps:
+/// the channel controls run first, nothing clips (8-bit captures clamp the results).
+#[test]
+fn levels_ic_matches_after_effects_in_32_bpc() {
+    let steps = [0, 16, 32, 64, 96, 128, 160, 192, 224, 255];
+    let ae = [
+        [0, 0, 70],
+        [0, 0, 88],
+        [0, 52, 104],
+        [61, 108, 132],
+        [102, 150, 158],
+        [138, 187, 181],
+        [171, 220, 203],
+        [203, 250, 223],
+        [233, 255, 243],
+        [255, 255, 255],
+    ];
+    let mut img = Image::new(10, 1);
+    for (x, v) in steps.iter().enumerate() {
+        let v = *v as f32 / 255.0;
+        img.set(x as u32, 0, [v, v, v, 1.0]);
+    }
+    let vals = [
+        ("rgb/rgbInBlack", Value::Scalar(0.1)),
+        ("rgb/rgbInWhite", Value::Scalar(0.9)),
+        ("rgb/rgbGamma", Value::Scalar(1.5)),
+        ("rgb/rgbOutBlack", Value::Scalar(0.05)),
+        ("rgb/rgbOutWhite", Value::Scalar(0.95)),
+        ("red/redGamma", Value::Scalar(0.8)),
+        ("green/greenInWhite", Value::Scalar(0.8)),
+        ("blue/blueOutBlack", Value::Scalar(0.2)),
+    ];
+    let s = find("ec.color.levelsic").unwrap();
+    let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+    for (k, v) in &vals {
+        params.values.insert(k.to_string(), v.clone());
+    }
+    let render = |float_depth: bool| {
+        let env = crate::EffectEnv { float_depth, ..Default::default() };
+        let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [10.0, 1.0], seed: 1, adjustment: false, env };
+        (s.render)(&ctx, Buf { img: img.clone(), offset: [0.0, 0.0], scale: 1.0 }).img
+    };
+    let out = render(true);
+    for (x, want) in ae.iter().enumerate() {
+        let p = out.get(x as i64, 0);
+        for c in 0..3 {
+            let got = p[c].clamp(0.0, 1.0) * 255.0;
+            assert!((got - want[c] as f32).abs() <= 2.0, "step {} channel {c}: {got} vs AE {}", steps[x], want[c]);
+        }
+    }
+    // In 8 / 16 bpc "Off for 32 bpc Color" clips: black stops at Output Black.
+    let clipped = render(false);
+    assert!((clipped.get(0, 0)[0] - 0.05).abs() < 1e-5, "{:?}", clipped.get(0, 0));
+}
+
+/// After Effects 2026 (cases 962 / 963): Curves through RGB (0,0) (125,199)
+/// (255,255) and Red (0,0) (128,44) (255,255) on grey steps 0..255, 8-bit results.
+#[test]
+fn curves_follow_a_natural_spline_as_in_after_effects() {
+    let steps = [0u8, 16, 32, 64, 96, 128, 160, 192, 224, 255];
+    let mut img = Image::new(10, 1);
+    for (x, v) in steps.iter().enumerate() {
+        let v = *v as f32 / 255.0;
+        img.set(x as u32, 0, [v, v, v, 1.0]);
+    }
+    let p = |pts: &[(f32, f32)]| Value::Str(pts.iter().map(|(x, y)| format!("{},{}", x / 255.0, y / 255.0)).collect::<Vec<_>>().join(" "));
+    let rgb = run("ec.color.curves", &img, &[("rgb", p(&[(0.0, 0.0), (125.0, 199.0), (255.0, 255.0)]))]);
+    let red = run("ec.color.curves", &img, &[("red", p(&[(0.0, 0.0), (128.0, 44.0), (255.0, 255.0)]))]);
+    let ae_rgb = [0, 30, 59, 115, 164, 202, 227, 242, 250, 255];
+    let ae_red = [0, 0, 1, 6, 19, 44, 83, 135, 194, 255];
+    for x in 0..10 {
+        let g = (rgb.get(x as i64, 0)[1] * 255.0).round() as i32;
+        let r = (red.get(x as i64, 0)[0] * 255.0).round() as i32;
+        assert!((g - ae_rgb[x]).abs() <= 1, "RGB step {}: {g} vs AE {}", steps[x], ae_rgb[x]);
+        assert!((r - ae_red[x]).abs() <= 1, "Red step {}: {r} vs AE {}", steps[x], ae_red[x]);
+    }
+}
+
+#[test]
+fn levels_ic_identity_and_red_only() {
+    let img = ramp();
+    assert_eq!(run("ec.color.levelsic", &img, &[]), img);
+    let out = run("ec.color.levelsic", &img, &[("red/redOutWhite", num(0.5))]);
+    let p = out.get(15, 3);
+    assert!((p[0] - 0.5).abs() < 1e-4 && (p[1] - 0.0).abs() < 1e-4);
+}
+
+#[test]
+fn auto_levels_stretches_low_contrast() {
+    let mut img = Image::new(32, 4);
+    for y in 0..4 {
+        for x in 0..32 {
+            let v = 0.4 + 0.2 * x as f32 / 31.0;
+            img.set(x, y, [v, v, v, 1.0]);
+        }
+    }
+    let out = run("ec.color.autolevels", &img, &[("blackClip", num(0.0)), ("whiteClip", num(0.0))]);
+    let lo = out.data.iter().map(|p| p[0]).fold(1.0, f32::min);
+    let hi = out.data.iter().map(|p| p[0]).fold(0.0, f32::max);
+    assert!(lo < 0.02 && hi > 0.98, "{lo} {hi}");
+    let ac = run("ec.color.autocontrast", &img, &[("blackClip", num(0.0)), ("whiteClip", num(0.0))]);
+    assert!(ac.data.iter().map(|p| p[0]).fold(0.0, f32::max) > 0.98);
+}
+
+#[test]
+fn auto_color_neutralises_cast() {
+    let mut img = Image::new(16, 4);
+    for y in 0..4 {
+        for x in 0..16 {
+            let v = x as f32 / 15.0;
+            img.set(x, y, [v * 0.6 + 0.1, v * 0.9, v * 0.5, 1.0]);
+        }
+    }
+    let out = run("ec.color.autocolor", &img, &[]);
+    let p = out.get(8, 1);
+    assert!((p[0] - p[1]).abs() < 0.08 && (p[1] - p[2]).abs() < 0.08, "{p:?}");
+}
+
+#[test]
+fn equalize_flattens_histogram() {
+    let mut img = Image::new(64, 1);
+    for x in 0..64 {
+        let v = if x < 48 { 0.1 + x as f32 * 0.001 } else { 0.9 };
+        img.set(x, 0, [v, v, v, 1.0]);
+    }
+    let out = run("ec.color.equalize", &img, &[]);
+    // The crowded dark values are spread across the range.
+    assert!(out.get(47, 0)[0] > 0.6, "{}", out.get(47, 0)[0]);
+    assert!(out.get(0, 0)[0] < 0.1);
+    assert_eq!(run("ec.color.equalize", &img, &[("amount", num(0.0))]), img);
+}
+
+#[test]
+fn selective_color_zero_is_identity_and_reds_respond() {
+    let img = ramp();
+    assert_eq!(run("ec.color.selectivecolor", &img, &[]), img);
+    let red = Image::filled(2, 2, [1.0, 0.1, 0.1, 1.0]);
+    let out = run("ec.color.selectivecolor", &red, &[("details/reds/redsCyan", num(100.0)), ("method", Value::Enum(1))]);
+    assert!(out.data[0][0] < 0.3, "{:?}", out.data[0]);
+    let blue = Image::filled(2, 2, [0.1, 0.1, 1.0, 1.0]);
+    assert_eq!(run("ec.color.selectivecolor", &blue, &[("details/reds/redsCyan", num(100.0))]), blue);
+}
+
+#[test]
+fn color_offset_full_turn_is_identity() {
+    let img = ramp();
+    let out = run("ec.color.cccoloroffset", &img, &[("redPhase", num(360.0)), ("greenPhase", num(720.0))]);
+    assert_eq!(out, img);
+    let out = run("ec.color.cccoloroffset", &img, &[("redPhase", num(180.0))]);
+    assert!((out.get(0, 3)[0] - 0.5).abs() < 1e-4);
+}
+
+#[test]
+fn broadcast_reduces_unsafe_color() {
+    let img = Image::filled(2, 2, [1.0, 1.0, 0.0, 1.0]);
+    let out = run("ec.color.broadcast", &img, &[]);
+    assert!(out.data[0][0] < 1.0);
+    let key = run("ec.color.broadcast", &img, &[("howToMakeSafe", Value::Enum(2))]);
+    assert_eq!(key.data[0][3], 0.0);
+    let gray = Image::filled(2, 2, [0.5, 0.5, 0.5, 1.0]);
+    assert_eq!(run("ec.color.broadcast", &gray, &[]), gray);
+}
+
+#[test]
+fn color_balance_hls_zero_identity_and_hue_shift() {
+    let img = ramp();
+    assert_eq!(run("ec.color.colorbalancehls", &img, &[]), img);
+    let red = Image::filled(1, 1, [1.0, 0.0, 0.0, 1.0]);
+    let out = run("ec.color.colorbalancehls", &red, &[("hue", num(120.0))]);
+    assert!(out.data[0][1] > 0.99 && out.data[0][0] < 0.01);
+}
+
+#[test]
+fn color_link_fills_with_average_keeping_alpha() {
+    let mut img = Image::new(2, 1);
+    img.set(0, 0, [1.0, 0.0, 0.0, 1.0]);
+    img.set(1, 0, [0.0, 0.0, 0.5, 0.5]);
+    let out = run("ec.color.colorlink", &img, &[]);
+    assert!((out.data[1][3] - 0.5).abs() < 1e-5);
+    let (c, _) = unpremul(out.data[0]);
+    assert!((c[0] - 2.0 / 3.0).abs() < 1e-3 && (c[2] - 1.0 / 3.0).abs() < 1e-3, "{c:?}");
+}
+
+#[test]
+fn cc_kernel_identity_and_toner_duotone() {
+    let img = ramp();
+    assert_eq!(run("ec.color.cckernel", &img, &[]), img);
+    let g = Image::filled(1, 1, [0.5, 0.5, 0.5, 1.0]);
+    let t = run("ec.color.cctoner", &g, &[("tones", Value::Enum(0)), ("highlights", col(1.0, 0.0, 0.0))]);
+    assert!((t.data[0][0] - 0.5).abs() < 1e-3 && t.data[0][1] < 1e-3);
+}
+
+#[test]
+fn shadow_highlight_lifts_shadows() {
+    let img = Image::filled(8, 8, [0.1, 0.1, 0.1, 1.0]);
+    let out = run("ec.color.shadowhighlight", &img, &[("autoAmounts", Value::Bool(false))]);
+    assert!(out.data[0][0] > 0.15);
+}
+
+#[test]
+fn levels_ic_clip_popups() {
+    let img = Image::filled(2, 2, [0.9, 0.9, 0.9, 1.0]);
+    let lv = [("rgb/rgbInWhite", num(0.5))];
+    assert!((run("ec.color.levelsic", &img, &lv).data[0][0] - 1.0).abs() < 1e-6);
+    let off = [("rgb/rgbInWhite", num(0.5)), ("clipToOutputWhite", Value::Enum(0))];
+    assert!(run("ec.color.levelsic", &img, &off).data[0][0] > 1.5);
+}
+
+/// A host whose other layers and other frames are a fixed image.
+struct ImgHost(Image);
+impl crate::EffectHost for ImgHost {
+    fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
+        Some(crate::LayerPixels { buf: Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 }, size: [2.0, 2.0] })
+    }
+    fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+        None
+    }
+    fn self_at(&self, _: f64, _: usize) -> Option<Buf> {
+        Some(Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 })
+    }
+}
+
+fn run_host(id: &str, img: &Image, over: &[(&str, Value)], host: &ImgHost) -> Image {
+    let env = crate::EffectEnv { host: Some(host), frame_rate: 10.0, ..Default::default() };
+    crate::run_fx(id, over, img.clone(), 1.0, env).img
+}
+
+#[test]
+fn color_link_samples_clip_and_source_layer() {
+    let mut img = Image::new(5, 1);
+    for (x, v) in [0.0f32, 0.1, 0.2, 0.3, 1.0].iter().enumerate() {
+        img.set(x as u32, 0, [*v, *v, *v, 1.0]);
+    }
+    // Median ignores the outlier the average follows.
+    let med = run("ec.color.colorlink", &img, &[("sampleSource", Value::Enum(1))]);
+    assert!((med.data[0][0] - 0.2).abs() < 1e-5);
+    // Brightest with 20 % clip skips the brightest pixel.
+    let br = run("ec.color.colorlink", &img, &[("sampleSource", Value::Enum(2)), ("clip", num(20.0))]);
+    assert!((br.data[0][0] - 0.3).abs() < 1e-5);
+    // Min Alpha of a half-transparent source layer sets the alpha.
+    let host = ImgHost(Image::filled(2, 2, [0.25, 0.25, 0.25, 0.5]));
+    let out = run_host("ec.color.colorlink", &img, &[("sourceLayer", Value::Layer(Some(9))), ("sampleSource", Value::Enum(9))], &host);
+    assert!((out.data[4][3] - 0.5).abs() < 1e-5);
+    // Average of the source layer (not the effect's own pixels).
+    let out = run_host("ec.color.colorlink", &img, &[("sourceLayer", Value::Layer(Some(9)))], &host);
+    assert!((out.data[4][0] - 0.5).abs() < 1e-5);
+}
+
+#[test]
+fn auto_levels_temporal_smoothing_reads_neighbour_frames() {
+    let mut img = Image::new(4, 1);
+    for x in 0..4 {
+        let v = 0.3 + 0.1 * x as f32;
+        img.set(x, 0, [v, v, v, 1.0]);
+    }
+    let wide = ImgHost(ramp());
+    let p0 = [("blackClip", num(0.0)), ("whiteClip", num(0.0))];
+    let alone = run_host("ec.color.autolevels", &img, &p0, &wide);
+    let smooth = run_host("ec.color.autolevels", &img, &[p0[0].clone(), p0[1].clone(), ("temporalSmoothing", num(0.2))], &wide);
+    // Alone the frame is stretched to full range; with full-range neighbours much less.
+    assert!(alone.data[0][0] < 0.01);
+    assert!(smooth.data[0][0] > 0.1, "{:?}", smooth.data[0]);
+}
+
+#[test]
+fn shadow_highlight_clip_keeps_the_tonal_range() {
+    let img = ramp();
+    let lift = [("autoAmounts", Value::Bool(false)), ("shadowAmount", num(80.0))];
+    let unclipped =
+        run("ec.color.shadowhighlight", &img, &[lift[0].clone(), lift[1].clone(), ("moreOptions/blackClip", num(0.0)), ("moreOptions/whiteClip", num(0.0))]);
+    let clipped = run("ec.color.shadowhighlight", &img, &[lift[0].clone(), lift[1].clone(), ("moreOptions/blackClip", num(1.0))]);
+    let min = |im: &Image| im.data.iter().filter(|p| p[3] > 0.99).map(|p| luminance(p[0], p[1], p[2])).fold(f32::MAX, f32::min);
+    assert!(min(&clipped) < min(&unclipped));
+}
diff --git a/crates/effects/src/color_fx.rs b/crates/effects/src/color_fx.rs
index 402d0ebe2..3a52e7a54 100644
--- a/crates/effects/src/color_fx.rs
+++ b/crates/effects/src/color_fx.rs
@@ -25,7 +25,7 @@ pub(crate) fn luma_601(c: [f32; 3]) -> f32 {
     LUMA_601[0] * c[0] + LUMA_601[1] * c[1] + LUMA_601[2] * c[2]
 }
 
-/// The Rec. 601 luma weights of [`luma_601`]. The WGSL kernels repeat them as literals; the GPU
+/// The Rec. 601 luma weights of `luma_601`. The WGSL kernels repeat them as literals; the GPU
 /// test `shader_constants_match_the_cpu` checks that they are these.
 pub const LUMA_601: [f32; 3] = [0.299, 0.587, 0.114];
 
@@ -384,7 +384,7 @@ pub fn mirror_pow(v: f32, p: f32) -> f32 {
 /// back toward the gray). After Effects 2026 with Tint Color [1, 0.5, 0]: gray 0.1 (a red solid
 /// at Reds 10, case 717) → (43, 21, 0), gray 0.6 (yellow at defaults, case 825) → (255, 129, 2),
 /// white → white; the old hue / saturation / lightness mix gave (51, 26, 0) for the first.
-/// The luminosity weights of [`bw_tint`] (a Color blend's). `fx_color.wgsl` repeats them; the GPU
+/// The luminosity weights of `bw_tint` (a Color blend's). `fx_color.wgsl` repeats them; the GPU
 /// test `shader_constants_match_the_cpu` checks that they are these.
 pub const BW_TINT_LUMA: [f32; 3] = [0.3, 0.59, 0.11];
 
@@ -755,7 +755,7 @@ impl ColoramaPalette {
         }
     }
 
-    /// Parse "pos:r,g,b[,a] pos:r,g,b …" (positions 0..1, channels 0..1). `None` without stops.
+    /// Parse "pos:r,g,b\[,a\] pos:r,g,b …" (positions 0..1, channels 0..1). `None` without stops.
     pub fn parse(s: &str) -> Option<ColoramaPalette> {
         let mut stops: Vec<(f32, [f32; 4])> = s
             .split_whitespace()
@@ -1215,524 +1215,4 @@ pub fn specs() -> Vec<EffectSpec> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{EffectEnv, run_fx};
-    use effectcraft_raster::Image;
-
-    fn px(id: &str, vals: &[(&str, Value)], c: [f32; 4]) -> [f32; 4] {
-        run_fx(id, vals, Image::filled(2, 2, c), 0.0, EffectEnv::default()).img.get(0, 0)
-    }
-    fn close(a: [f32; 4], b: [f32; 4], eps: f32) -> bool {
-        a.iter().zip(b).all(|(x, y)| (x - y).abs() <= eps)
-    }
-
-    /// Projects saved before Use Legacy / the Photo Filter menu existed keep rendering as before.
-    #[test]
-    fn old_saves_get_legacy_values_for_added_params() {
-        use effectcraft_project::build::Ids;
-        let mut next = 1;
-        for (id, param, want) in
-            [("ec.color.brightnesscontrast", "useLegacy", Value::Bool(true)), ("ec.color.photofilter", "filter", Value::Enum(PHOTO_FILTER_CUSTOM))]
-        {
-            let spec = crate::find(id).unwrap();
-            let mut g = crate::instantiate(spec, &mut Ids(&mut next), spec.name, [10.0, 10.0]);
-            g.children.retain(|c| c.match_id() != param);
-            crate::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), [10.0, 10.0]);
-            assert_eq!(g.get(param).unwrap().value, want, "{id}");
-        }
-    }
-
-    /// After Effects 2026 renders of full-frame solids with Tint at its defaults (sRGB working
-    /// space, not linearised, 32 bpc, 8-bit capture): Rec. 601 weights on the encoded values.
-    #[test]
-    fn tint_defaults_match_after_effects_greys() {
-        for (c, want) in [([1.0, 0.0, 0.0], 76.0), ([0.0, 1.0, 0.0], 150.0), ([0.0, 0.0, 1.0], 29.0), ([0.5, 0.5, 0.5], 128.0)] {
-            let o = px("ec.color.tint", &[], [c[0], c[1], c[2], 1.0]);
-            let want = want / 255.0;
-            assert!(close(o, [want, want, want, 1.0], 1.0 / 255.0), "{c:?}: {o:?} vs {want}");
-        }
-    }
-
-    #[test]
-    fn colorama_reads_get_phase_from() {
-        // Same intensity, different red: Intensity gives one colour, Red gives two.
-        let a = [0.6, 0.2, 0.2, 1.0];
-        let b = [0.2, 0.2, 0.6, 1.0];
-        let red = |c| px("ec.color.colorama", &[("inputPhase/mode", Value::Enum(1))], c);
-        assert!(!close(red(a), red(b), 1e-3));
-        // Zero maps everything to the start of the cycle (red).
-        assert!(close(px("ec.color.colorama", &[("inputPhase/mode", Value::Enum(9))], b), [1.0, 0.0, 0.0, 1.0], 1e-5));
-        // Interpolate Palette off posterizes: two nearby inputs land on the same colour.
-        let off = |v: f32| px("ec.color.colorama", &[("outputCycle/interpolatePalette", Value::Bool(false))], [v, v, v, 1.0]);
-        assert_eq!(off(0.20), off(0.22));
-    }
-
-    #[test]
-    fn brightness_contrast_modern_keeps_black_and_white_and_legacy_is_linear() {
-        let bc = |vals: &[(&str, Value)], v: f32| px("ec.color.brightnesscontrast", vals, [v, v, v, 1.0])[0];
-        let up = [("brightness", num(50.0)), ("contrast", num(40.0))];
-        assert_eq!(bc(&up, 0.0), 0.0);
-        assert!((bc(&up, 1.0) - 1.0).abs() < 1e-6);
-        assert!(bc(&up, 0.4) > 0.4);
-        let legacy = [("brightness", num(50.0)), ("useLegacy", Value::Bool(true))];
-        assert!((bc(&legacy, 0.2) - 0.7).abs() < 1e-5);
-        assert!((bc(&legacy, 0.0) - 0.5).abs() < 1e-5);
-    }
-
-    /// After Effects non-legacy ramps (kasper9n, #681). B0 C-100 matched B0 C-50 and is omitted.
-    #[test]
-    fn brightness_contrast_modern_matches_ae_ramp_samples() {
-        let u8 = |v: f32| (v * 255.0).round() as i32;
-        let go = |b: f64, c: f64, x: u8| {
-            u8(px("ec.color.brightnesscontrast", &[("brightness", num(b)), ("contrast", num(c))], [x as f32 / 255.0, x as f32 / 255.0, x as f32 / 255.0, 1.0])
-                [0])
-        };
-        // (brightness, contrast, input, AE 8-bit)
-        let samples: &[(f64, f64, u8, u8)] = &[
-            (0.0, 100.0, 64, 40),
-            (0.0, 100.0, 128, 129),
-            (0.0, 100.0, 192, 217),
-            (0.0, 50.0, 64, 53),
-            (0.0, 50.0, 192, 205),
-            (0.0, -50.0, 64, 77),
-            (100.0, 0.0, 128, 209),
-            (50.0, 0.0, 128, 171),
-            (106.0, -18.0, 128, 214),
-        ];
-        for &(b, c, x, ae) in samples {
-            let got = go(b, c, x);
-            assert!((got - ae as i32).abs() <= 10, "B{b} C{c} in {x}: got {got} AE {ae}");
-        }
-        // Old g=4 S-curve put Contrast 100 at ~8/255 here.
-        assert!(go(0.0, 100.0, 64) >= 30);
-    }
-
-    /// After Effects 2026: Tritone Highlights [1, 1, 0.8], Midtones [0.6, 0.2, 0.2], Shadows
-    /// [0, 0, 0.3]. On a red solid with Blend With Original 25 (case 718) AE gives (132, 23, 46);
-    /// on a grey ramp (case 815) levels 0, 63.9, 127.6, 191.4 give (0, 0, 77), (77, 26, 64),
-    /// (153, 51, 51), (204, 153, 128).
-    #[test]
-    fn tritone_matches_after_effects() {
-        let colours = [
-            ("highlights", Value::Color([1.0, 1.0, 0.8, 1.0])),
-            ("midtones", Value::Color([0.6, 0.2, 0.2, 1.0])),
-            ("shadows", Value::Color([0.0, 0.0, 0.3, 1.0])),
-        ];
-        let near = |o: [f32; 4], ae: [f32; 3]| (0..3).all(|i| (o[i] * 255.0 - ae[i]).abs() <= 1.0);
-        let mut red = colours.to_vec();
-        red.push(("blend", num(25.0)));
-        let o = px("ec.color.tritone", &red, [1.0, 0.0, 0.0, 1.0]);
-        assert!(near(o, [132.0, 23.0, 46.0]), "{:?}", o.map(|v| v * 255.0));
-        for (level, ae) in [(0.1f32, [0.0, 0.0, 77.0]), (63.9, [77.0, 26.0, 64.0]), (127.6, [153.0, 51.0, 51.0]), (191.4, [204.0, 153.0, 128.0])] {
-            let v = level / 255.0;
-            let o = px("ec.color.tritone", &colours, [v, v, v, 1.0]);
-            assert!(near(o, ae), "level {level}: {:?} vs {ae:?}", o.map(|v| v * 255.0));
-        }
-    }
-
-    /// After Effects 2026, Tint Color [1, 0.5, 0]: a red solid at Reds 10 (case 717) and yellow
-    /// and white solids at the default sliders (case 825).
-    #[test]
-    fn black_white_tint_matches_after_effects() {
-        let tint = [("tint", Value::Bool(true)), ("tintColor", Value::Color([1.0, 0.5, 0.0, 1.0]))];
-        let near = |o: [f32; 4], ae: [f32; 3]| (0..3).all(|i| (o[i] * 255.0 - ae[i]).abs() <= 1.5);
-        let mut reds = tint.to_vec();
-        reds.push(("reds", num(10.0)));
-        let o = px("ec.color.blackwhite", &reds, [1.0, 0.0, 0.0, 1.0]);
-        assert!(near(o, [43.0, 21.0, 0.0]), "{:?}", o.map(|v| v * 255.0));
-        let o = px("ec.color.blackwhite", &tint, [1.0, 1.0, 0.0, 1.0]);
-        assert!(near(o, [255.0, 129.0, 2.0]), "{:?}", o.map(|v| v * 255.0));
-        let o = px("ec.color.blackwhite", &tint, [1.0, 1.0, 1.0, 1.0]);
-        assert!(near(o, [255.0, 255.0, 255.0]), "{:?}", o.map(|v| v * 255.0));
-        // Hostile grays stay finite.
-        for g in [f32::NAN, -1.0, 0.0, 4.0] {
-            assert!(bw_tint([1.0, 0.5, 0.0], g).iter().all(|v| v.is_finite()));
-        }
-    }
-
-    /// After Effects 2026 ramps (RENDERER round 2, session R8): negative Brightness and Contrast
-    /// are the inverses of the positive curves. (brightness, contrast, input, AE 8-bit)
-    #[test]
-    fn negative_brightness_and_contrast_invert_the_positive_curves() {
-        let go = |b: f64, c: f64, x: u8| {
-            let v = x as f32 / 255.0;
-            (px("ec.color.brightnesscontrast", &[("brightness", num(b)), ("contrast", num(c))], [v, v, v, 1.0])[0] * 255.0).round() as i32
-        };
-        let samples: &[(f64, f64, u8, u8)] = &[
-            (-40.0, 0.0, 64, 50),
-            (-40.0, 0.0, 128, 99),
-            (-40.0, 0.0, 191, 155),
-            (-40.0, 0.0, 234, 207),
-            (0.0, -50.0, 21, 28),
-            (0.0, -50.0, 64, 76),
-            (0.0, -50.0, 191, 179),
-            (0.0, -50.0, 234, 227),
-            (40.0, 0.0, 128, 162),
-            (0.0, 50.0, 64, 52),
-        ];
-        for &(b, c, x, ae) in samples {
-            let got = go(b, c, x);
-            assert!((got - ae as i32).abs() <= 7, "B{b} C{c} in {x}: got {got} AE {ae}");
-        }
-    }
-
-    /// #1463: Black & White's sliders set the gray of each pure hue and blend between
-    /// neighbouring hues; neutral pixels keep their value, overbright ones too, and an overbright
-    /// colour stays finite (it used to divide by zero).
-    #[test]
-    fn black_white_sliders_set_the_gray_of_each_hue() {
-        let bw = |vals: &[(&str, Value)], c: [f32; 3]| px("ec.color.blackwhite", vals, [c[0], c[1], c[2], 1.0]);
-        let gray = |v: f32| [v, v, v, 1.0];
-        // The defaults: Reds 40, Yellows 60, Greens 40, Cyans 60, Blues 20, Magentas 80 (%).
-        let hues = [
-            ([1.0, 0.0, 0.0], 0.4),
-            ([1.0, 1.0, 0.0], 0.6),
-            ([0.0, 1.0, 0.0], 0.4),
-            ([0.0, 1.0, 1.0], 0.6),
-            ([0.0, 0.0, 1.0], 0.2),
-            ([1.0, 0.0, 1.0], 0.8),
-            // Half as bright, half the gray; orange is halfway from Reds to Yellows.
-            ([0.5, 0.0, 0.0], 0.2),
-            ([1.0, 0.5, 0.0], 0.5),
-            // Neutral pixels keep their value.
-            ([0.3, 0.3, 0.3], 0.3),
-            ([4.0, 4.0, 4.0], 4.0),
-            // An overbright red: its smallest channel plus its chroma at Reds' 40 %.
-            ([1.5, 0.5, 0.5], 0.9),
-        ];
-        for (c, want) in hues {
-            let o = bw(&[], c);
-            assert!(close(o, gray(want), 1e-5), "{c:?}: {o:?}, want {want}");
-        }
-        assert!(close(bw(&[("reds", num(120.0))], [1.0, 0.0, 0.0]), gray(1.2), 1e-5));
-        assert!(close(bw(&[("reds", num(-200.0))], [1.0, 0.0, 0.0]), gray(0.0), 1e-5));
-        assert!(close(bw(&[("blues", num(300.0))], [0.1, 0.1, 0.3]), gray(0.7), 1e-5));
-    }
-
-    /// #1463: faint colour noise stays faint. The shadows of compressed footage carry a code or
-    /// two of colour noise, which Black & White turned into bright and black blocks (the HSL
-    /// saturation it scaled is near 1 for any tinted near-black pixel). At 8, 16 and 32 bpc the
-    /// gray of a dark ramp with ±2 steps of colour noise stays within 2 steps of the clean ramp's.
-    #[test]
-    fn black_white_keeps_faint_colour_noise_faint() {
-        // A step of 8 bpc, of 16 bpc (After Effects' 0..32768), and a small 32-bpc float one.
-        for step in [1.0 / 255.0, 1.0 / 32768.0, 1e-3_f32] {
-            let (w, h) = (64u32, 4u32);
-            let (mut clean, mut noisy) = (Image::new(w, h), Image::new(w, h));
-            for y in 0..h {
-                for x in 0..w {
-                    // A dark ramp up to a quarter gray, in whole steps...
-                    let v = (x as f32 / w as f32 * 0.25 / step).round() * step;
-                    // ...and up to ±2 steps of noise per channel, mixed differently in each pixel.
-                    let n = |k: u32| (((x * 7 + y * 13 + k * 2) % 5) as f32 - 2.0) * step;
-                    clean.set(x, y, [v, v, v, 1.0]);
-                    noisy.set(x, y, [(v + n(0)).max(0.0), (v + n(1)).max(0.0), (v + n(2)).max(0.0), 1.0]);
-                }
-            }
-            let bw = |img| run_fx("ec.color.blackwhite", &[], img, 0.0, EffectEnv::default()).img;
-            let (a, b) = (bw(clean), bw(noisy));
-            let worst = a.data.iter().zip(&b.data).map(|(p, q)| (p[0] - q[0]).abs()).fold(0.0, f32::max);
-            assert!(worst <= 2.0 * step + 1e-6, "step {step}: the noise moved the gray by {} steps", worst / step);
-        }
-    }
-
-    #[test]
-    fn levels_clips_black_and_white_independently() {
-        let lv = |vals: &[(&str, Value)], v: f32| px("ec.color.levels", vals, [v, v, v, 1.0])[0];
-        let base = [("inBlack", num(0.2)), ("inWhite", num(0.6)), ("outBlack", num(0.1)), ("outWhite", num(0.9))];
-        assert!((lv(&base, 0.9) - 0.9).abs() < 1e-5);
-        let mut no_white = base.to_vec();
-        no_white.push(("clipToOutputWhite", Value::Enum(0)));
-        assert!(lv(&no_white, 0.9) > 0.9);
-        assert!((lv(&no_white, 0.0) - 0.1).abs() < 1e-5);
-        // The hidden switch of older projects turns both off.
-        let mut legacy = base.to_vec();
-        legacy.push(("noClip", Value::Bool(true)));
-        assert!(lv(&legacy, 0.9) > 0.9);
-    }
-
-    #[test]
-    fn exposure_individual_channels_and_bypass() {
-        let g = [0.5, 0.5, 0.5, 1.0];
-        let one = px("ec.color.exposure", &[("channels", Value::Enum(1)), ("red/redExposure", num(1.0))], g);
-        assert!(one[0] > 0.6 && (one[1] - 0.5).abs() < 1e-5 && (one[2] - 0.5).abs() < 1e-5);
-        // Master values are ignored in Individual Channels mode.
-        assert!(close(px("ec.color.exposure", &[("channels", Value::Enum(1)), ("master/exposure", num(2.0))], g), g, 1e-5));
-        // Bypass Linear Light Conversion: +1 stop doubles the raw value.
-        let raw = px("ec.color.exposure", &[("master/exposure", num(1.0)), ("bypassLinearLight", Value::Bool(true))], [0.25, 0.25, 0.25, 1.0]);
-        assert!((raw[0] - 0.5).abs() < 1e-5);
-        // Negative results are mirrored, not clipped.
-        let neg = px(
-            "ec.color.exposure",
-            &[("master/offset", num(-0.5)), ("bypassLinearLight", Value::Bool(true)), ("master/gamma", num(2.0))],
-            [0.25, 0.25, 0.25, 1.0],
-        );
-        assert!((neg[0] + 0.5).abs() < 1e-4, "{neg:?}");
-    }
-
-    /// After Effects' Exposure ranges for all twelve sliders; a saved value outside them (a gamma
-    /// of 0.05, valid before, as in Photoshop) survives loading and still renders.
-    #[test]
-    fn exposure_has_after_effects_ranges_and_keeps_old_values() {
-        use effectcraft_project::build::Ids;
-        let spec = crate::find("ec.color.exposure").unwrap();
-        let want = [(-100.0, 100.0, -4.0, 4.0, 2), (-2.0, 2.0, -0.5, 0.5, 4), (0.1, 10.0, 0.1, 10.0, 2)];
-        let sliders: Vec<_> = spec
-            .params
-            .iter()
-            .filter_map(|p| match p.ui {
-                ParamUi::Slider { min, max, slider_min, slider_max, decimals } => Some((p.id, (min, max, slider_min, slider_max, decimals))),
-                _ => None,
-            })
-            .collect();
-        assert_eq!(sliders.len(), 12);
-        for (i, (id, r)) in sliders.iter().enumerate() {
-            assert_eq!(*r, want[i % 3], "{id}");
-        }
-        let mut next = 1;
-        let mut g = crate::instantiate(spec, &mut Ids(&mut next), spec.name, [10.0, 10.0]);
-        let gamma = g.prop_mut("master/gamma").unwrap();
-        gamma.value = num(0.05);
-        gamma.ui = slider(0.01, 9.99, 0.1, 3.0, 2);
-        crate::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), [10.0, 10.0]);
-        let gamma = g.prop_mut("master/gamma").unwrap();
-        assert_eq!(gamma.value, num(0.05));
-        assert!(matches!(gamma.ui, ParamUi::Slider { min, .. } if min == 0.1));
-        let o = px("ec.color.exposure", &[("master/gamma", num(0.05)), ("bypassLinearLight", Value::Bool(true))], [0.5, 0.5, 0.5, 1.0]);
-        assert!((o[0] - 0.5f32.powf(20.0)).abs() < 1e-9, "{o:?}");
-    }
-
-    /// Exposure on a red [1, 0, 0] solid against After Effects 2026 renders (sRGB working space,
-    /// not linearised, 32 bpc, 8-bit captures): the linear-light conversion is a pure 2.2 power.
-    /// The piecewise sRGB curve gave 2 / 7 / 39 for the three smallest Offsets.
-    #[test]
-    fn exposure_matches_after_effects_gamma_2_2() {
-        let red = [1.0, 0.0, 0.0, 1.0];
-        let code = |o: [f32; 4], i: usize| o[i] * 255.0;
-        // Master Offset only: G and B carry the curve; R goes over 1 (255 in the 8-bit capture).
-        for (offset, ae) in [(0.0005, 8.0), (0.002, 15.0), (0.02, 43.0), (0.1, 90.0)] {
-            let o = px("ec.color.exposure", &[("master/offset", num(offset))], red);
-            for i in [1, 2] {
-                assert!((code(o, i) - ae).abs() <= 1.0, "offset {offset}: {} vs AE {ae}", code(o, i));
-            }
-            assert!(o[0] >= 1.0, "{o:?}");
-        }
-        // Exposure −2.25: AE 126; with Bypass Linear Light Conversion (gain on encoded values) 54.
-        let o = px("ec.color.exposure", &[("master/exposure", num(-2.25))], red);
-        assert!((code(o, 0) - 126.0).abs() <= 1.0 && o[1] == 0.0, "{o:?}");
-        let o = px("ec.color.exposure", &[("master/exposure", num(-2.25)), ("bypassLinearLight", Value::Bool(true))], red);
-        assert!((code(o, 0) - 54.0).abs() <= 1.0 && o[1] == 0.0, "{o:?}");
-        // Default settings leave 32-bpc values alone, negative and over-range ones included.
-        let hdr = [-0.25, 0.5, 2.0, 1.0];
-        assert!(close(px("ec.color.exposure", &[], hdr), hdr, 1e-5));
-        // A negative Offset pushes black below zero, mirrored, rather than clipping or NaN.
-        let o = px("ec.color.exposure", &[("master/offset", num(-0.02))], [0.0, 0.0, 0.0, 1.0]);
-        assert!((o[0] + 0.02f32.powf(1.0 / 2.2)).abs() < 1e-5, "{o:?}");
-    }
-
-    #[test]
-    fn change_to_color_change_modes_tolerances_and_matte() {
-        let red = [0.8, 0.1, 0.1, 1.0];
-        let green = [0.1, 0.8, 0.1, 1.0];
-        let base = [("from", col(0.8, 0.1, 0.1)), ("to", col(0.1, 0.1, 0.8))];
-        // Hue only: red turns blue with its own lightness / saturation; green is untouched.
-        let o = px("ec.color.changetocolor", &base, red);
-        assert!(o[2] > 0.7 && o[0] < 0.2, "{o:?}");
-        assert!(close(px("ec.color.changetocolor", &base, green), green, 1e-5));
-        // The matte is white where matched, black elsewhere.
-        let mut m = base.to_vec();
-        m.push(("viewCorrectionMatte", Value::Bool(true)));
-        assert!(close(px("ec.color.changetocolor", &m, red), [1.0, 1.0, 1.0, 1.0], 1e-5));
-        assert!(close(px("ec.color.changetocolor", &m, green), [0.0, 0.0, 0.0, 1.0], 1e-5));
-        // A lightness tolerance of 0 rejects a lighter red.
-        let mut strict = m.clone();
-        strict.push(("toleranceGroup/lightness", num(0.0)));
-        strict.push(("softness", num(0.0)));
-        assert!(close(px("ec.color.changetocolor", &strict, [1.0, 0.5, 0.5, 1.0]), [0.0, 0.0, 0.0, 1.0], 1e-5));
-        // Hue, Lightness & Saturation, set: a matched pixel becomes the To colour.
-        let mut all = base.to_vec();
-        all.push(("change", Value::Enum(3)));
-        assert!(close(px("ec.color.changetocolor", &all, red), [0.1, 0.1, 0.8, 1.0], 1e-4));
-    }
-
-    #[test]
-    fn leave_color_tolerance_softness_and_match_mode() {
-        let green = [0.1, 0.8, 0.1, 1.0];
-        let lc = |vals: &[(&str, Value)]| {
-            let mut v = vec![("amount", num(100.0))];
-            v.extend_from_slice(vals);
-            px("ec.color.leavecolor", &v, green)
-        };
-        let g = luminance(0.1, 0.8, 0.1);
-        assert!(close(lc(&[]), [g, g, g, 1.0], 1e-5));
-        assert!(close(lc(&[("tolerance", num(100.0))]), green, 1e-6));
-        // Softness keeps part of the colour.
-        let s = lc(&[("tolerance", num(10.0)), ("edgeSoftness", num(100.0))]);
-        assert!(s[1] > g + 0.05 && s[1] < 0.8);
-        // Using Hue: a dark red still matches pure red.
-        let dark = px("ec.color.leavecolor", &[("amount", num(100.0)), ("tolerance", num(5.0)), ("matchColors", Value::Enum(1))], [0.4, 0.0, 0.0, 1.0]);
-        assert!(close(dark, [0.4, 0.0, 0.0, 1.0], 1e-6));
-    }
-
-    #[test]
-    fn photo_filter_presets_and_custom() {
-        let g = [0.5, 0.5, 0.5, 1.0];
-        let cool = px("ec.color.photofilter", &[("filter", Value::Enum(3)), ("preserveLuminosity", Value::Bool(false))], g);
-        assert!(cool[2] > cool[0], "a cooling filter is blue: {cool:?}");
-        let custom = |c| px("ec.color.photofilter", &[("filter", Value::Enum(PHOTO_FILTER_CUSTOM)), ("color", c)], g);
-        assert!(custom(col(0.0, 1.0, 0.0))[1] > custom(col(1.0, 0.0, 0.0))[1]);
-        // The Color swatch is ignored by the presets.
-        let warm = |c| px("ec.color.photofilter", &[("color", c)], g);
-        assert_eq!(warm(col(0.0, 1.0, 0.0)), warm(col(1.0, 0.0, 0.0)));
-    }
-
-    #[test]
-    fn color_balance_preserve_luminosity_and_black_stretch() {
-        let g = [0.5, 0.5, 0.5, 1.0];
-        let o = px("ec.color.colorbalance", &[("midRed", num(60.0)), ("preserveLuminosity", Value::Bool(true))], g);
-        assert!((luminance(o[0], o[1], o[2]) - 0.5).abs() < 1e-4 && o[0] > o[2]);
-        let dark = [0.1, 0.1, 0.1, 1.0];
-        assert!(px("ec.color.gammapedestalgain", &[("blackStretch", num(4.0))], dark)[0] > 0.15);
-        assert!(close(px("ec.color.gammapedestalgain", &[], dark), dark, 1e-6));
-    }
-
-    #[test]
-    fn levels_channel_controls_act_on_their_channel() {
-        let g = [0.5, 0.5, 0.5, 1.0];
-        assert!(close(px("ec.color.levels", &[("channel", Value::Enum(1))], g), g, 1e-6), "the popup alone changes nothing");
-        let r = px("ec.color.levels", &[("redOutWhite", num(0.5))], g);
-        assert!(close(r, [0.25, 0.5, 0.5, 1.0], 1e-5), "{r:?}");
-        let b = px("ec.color.levels", &[("blueGamma", num(2.0)), ("inWhite", num(0.5))], [0.25, 0.25, 0.25, 1.0]);
-        assert!(close(b, [0.5, 0.5, 0.5f32.sqrt(), 1.0], 1e-5), "RGB first, then blue: {b:?}");
-        let a = px("ec.color.levels", &[("alphaOutWhite", num(0.5))], [0.5, 0.5, 0.5, 1.0]);
-        assert!(close(a, [0.25, 0.25, 0.25, 0.5], 1e-5), "{a:?}");
-        // Per-channel clipping follows its own popups.
-        let hot = [0.9, 0.9, 0.9, 1.0];
-        let c = px("ec.color.levels", &[("greenInWhite", num(0.5))], hot)[1];
-        let nc = px("ec.color.levels", &[("greenInWhite", num(0.5)), ("greenClipToOutputWhite", Value::Enum(0))], hot)[1];
-        assert!((c - 1.0).abs() < 1e-6 && (nc - 1.8).abs() < 1e-5, "{c} {nc}");
-    }
-
-    #[test]
-    fn hue_saturation_ranges_adjust_their_hues_only() {
-        let red = [0.8, 0.1, 0.1, 1.0];
-        let blue = [0.1, 0.1, 0.8, 1.0];
-        let grey = [0.5, 0.5, 0.5, 1.0];
-        let v = [("redsSaturation", num(-100.0))];
-        let r = px("ec.color.huesaturation", &v, red);
-        assert!((r[0] - r[1]).abs() < 1e-4, "reds desaturated: {r:?}");
-        assert!(close(px("ec.color.huesaturation", &v, blue), blue, 1e-5));
-        assert!(close(px("ec.color.huesaturation", &v, grey), grey, 1e-5));
-        // Blues hue +120°: blue becomes red.
-        let b = px("ec.color.huesaturation", &[("bluesHue", num(120.0))], blue);
-        assert!(b[0] > 0.7 && b[2] < 0.2, "{b:?}");
-        // Fall-off: a hue 15° past the range end (Reds: −15..15, fall-off 30) gets half.
-        let orange_ish = {
-            let (r, g, b) = hsl_to_rgb(30.0 / 360.0, 0.8, 0.5);
-            [r, g, b, 1.0]
-        };
-        let o = px("ec.color.huesaturation", &[("redsLightness", num(100.0))], orange_ish);
-        let (_, _, l) = rgb_to_hsl(o[0], o[1], o[2]);
-        assert!((l - 0.75).abs() < 0.01, "half weight: {l}");
-        // Moving the range changes which hues it takes.
-        let o2 = px("ec.color.huesaturation", &[("redsLightness", num(100.0)), ("redsRangeEnd", num(40.0))], orange_ish);
-        assert!(rgb_to_hsl(o2[0], o2[1], o2[2]).2 > 0.99);
-        let params = crate::Params { values: [("redsHue".to_string(), num(10.0))].into_iter().collect() };
-        let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [1.0, 1.0], seed: 0, adjustment: false, env: Default::default() };
-        assert!(!huesat_ranges_identity(&ctx));
-    }
-
-    #[test]
-    fn fill_mask_all_masks_feather_and_invert() {
-        let sq = |x0: f64, x1: f64| crate::MaskShape {
-            name: String::new(),
-            points: vec![[x0, 0.0], [x1, 0.0], [x1, 10.0], [x0, 10.0]],
-            closed: true,
-            inverted: false,
-        };
-        let masks = [sq(0.0, 5.0), sq(15.0, 20.0)];
-        let env = EffectEnv { masks: &masks, ..Default::default() };
-        let grey = Image::filled(20, 10, [0.5, 0.5, 0.5, 1.0]);
-        let run = |vals: &[(&str, Value)]| run_fx("ec.generate.fill", vals, grey.clone(), 0.0, env).img;
-        let one = run(&[("fillMask", num(1.0))]);
-        assert_eq!(one.get(2, 5), [1.0, 0.0, 0.0, 1.0]);
-        assert_eq!(one.get(10, 5), [0.5, 0.5, 0.5, 1.0]);
-        assert_eq!(one.get(17, 5), [0.5, 0.5, 0.5, 1.0]);
-        let all = run(&[("allMasks", Value::Bool(true))]);
-        assert_eq!(all.get(17, 5), [1.0, 0.0, 0.0, 1.0]);
-        let inv = run(&[("fillMask", num(1.0)), ("invert", Value::Bool(true))]);
-        assert_eq!(inv.get(2, 5), [0.5, 0.5, 0.5, 1.0]);
-        assert_eq!(inv.get(10, 5), [1.0, 0.0, 0.0, 1.0]);
-        let soft = run(&[("fillMask", num(1.0)), ("horizontalFeather", num(6.0))]);
-        let v = soft.get(6, 5)[1];
-        assert!(v > 0.05 && v < 0.5, "feathered edge {v}");
-        // Without masks, Fill fills the layer as before.
-        let plain = run_fx("ec.generate.fill", &[("fillMask", num(1.0))], grey.clone(), 0.0, EffectEnv::default()).img;
-        assert_eq!(plain.get(10, 5), [1.0, 0.0, 0.0, 1.0]);
-    }
-
-    /// After Effects 2026: Fill (0, 0.5, 1) at Opacity 50 % on an opaque layer (a Gradient Ramp
-    /// on a red solid) renders premultiplied (0, 0.251, 0.502) at alpha 0.502 everywhere: the
-    /// fill colour at half the layer's alpha, nothing of the ramp left.
-    #[test]
-    fn fill_opacity_is_the_layers_opacity_as_in_after_effects() {
-        let mut img = Image::new(16, 4);
-        for x in 0..16 {
-            let v = x as f32 / 15.0;
-            for y in 0..4 {
-                img.set(x, y, [v, 0.0, 0.0, 1.0]);
-            }
-        }
-        let vals = [("color", Value::Color([0.0, 0.5, 1.0, 1.0])), ("opacity", num(50.0))];
-        let out = run_fx("ec.generate.fill", &vals, img, 0.0, EffectEnv::default()).img;
-        for x in [0, 7, 15] {
-            let p = out.get(x, 2);
-            let ae = [0.0, 0.251, 0.502, 0.502];
-            assert!(p.iter().zip(ae).all(|(v, a)| (v - a).abs() < 1.0 / 255.0), "x {x}: {p:?} vs AE {ae:?}");
-        }
-        // A half-transparent pixel ends at a quarter alpha, still the fill colour.
-        let half = run_fx("ec.generate.fill", &vals, Image::filled(2, 2, [0.2, 0.2, 0.2, 0.5]), 0.0, EffectEnv::default()).img;
-        assert_eq!(half.get(0, 0), [0.0, 0.125, 0.25, 0.25]);
-    }
-
-    #[test]
-    fn colorama_palettes_modify_selection_masking_and_add_phase() {
-        let grey = [0.5, 0.5, 0.5, 1.0];
-        let red = [1.0, 0.0, 0.0, 1.0];
-        // Ramp Grayscale: intensity 0.5 maps to mid grey.
-        let g = px("ec.color.colorama", &[("outputCycle/usePresetPalette", Value::Enum(1))], grey);
-        assert!((g[0] - 0.5).abs() < 0.01 && (g[0] - g[2]).abs() < 1e-5, "{g:?}");
-        // Custom palette: two stops, black at 0 and blue at 0.5.
-        let custom = [("outputCycle/usePresetPalette", Value::Enum(8)), ("outputCycle/palette", Value::Str("0:0,0,0 0.5:0,0,1".into()))];
-        let c = px("ec.color.colorama", &custom, grey);
-        assert!(c[2] > 0.99 && c[0] < 0.01, "{c:?}");
-        // Modify Lightness keeps the hue of the pixel (red stays red).
-        let l = px("ec.color.colorama", &[("modify/modify", Value::Enum(5)), ("outputCycle/usePresetPalette", Value::Enum(1))], red);
-        assert!(l[0] > l[1] + 0.2 && l[1] < 0.01 + l[2] + 1e-4, "{l:?}");
-        // Pixel Selection: only colours near Matching Color change.
-        let sel = [
-            ("pixelSelection/matchingMode", Value::Enum(1)),
-            ("pixelSelection/matchingColor", col(1.0, 0.0, 0.0)),
-            ("pixelSelection/matchingTolerance", num(10.0)),
-        ];
-        assert!(close(px("ec.color.colorama", &sel, grey), grey, 1e-6));
-        assert!(!close(px("ec.color.colorama", &sel, red), red, 1e-3));
-        // Composite Over Layer off: unselected pixels vanish.
-        let mut off = sel.to_vec();
-        off.push(("masking/compositeOverLayer", Value::Bool(false)));
-        assert_eq!(px("ec.color.colorama", &off, grey)[3], 0.0);
-        // Modify Alpha takes the palette alpha.
-        let alpha = [
-            ("outputCycle/usePresetPalette", Value::Enum(8)),
-            ("outputCycle/palette", Value::Str("0:1,1,1,0.25".into())),
-            ("modify/modifyAlpha", Value::Bool(true)),
-        ];
-        assert!((px("ec.color.colorama", &alpha, grey)[3] - 0.25).abs() < 1e-5);
-        // Palette parsing and evaluation.
-        let p = ColoramaPalette::parse("0.5:0,0,1 0:1,0,0").unwrap();
-        assert_eq!(p.eval(0.25, true), [0.5, 0.0, 0.5, 1.0]);
-        assert_eq!(p.eval(0.75, true), [0.5, 0.0, 0.5, 1.0], "wraps around");
-        assert_eq!(p.eval(0.25, false), [1.0, 0.0, 0.0, 1.0]);
-    }
-}
+mod tests;
diff --git a/crates/effects/src/color_fx/tests.rs b/crates/effects/src/color_fx/tests.rs
new file mode 100644
index 000000000..2f3370204
--- /dev/null
+++ b/crates/effects/src/color_fx/tests.rs
@@ -0,0 +1,508 @@
+use super::*;
+use crate::{EffectEnv, run_fx};
+use effectcraft_raster::Image;
+
+fn px(id: &str, vals: &[(&str, Value)], c: [f32; 4]) -> [f32; 4] {
+    run_fx(id, vals, Image::filled(2, 2, c), 0.0, EffectEnv::default()).img.get(0, 0)
+}
+fn close(a: [f32; 4], b: [f32; 4], eps: f32) -> bool {
+    a.iter().zip(b).all(|(x, y)| (x - y).abs() <= eps)
+}
+
+/// Projects saved before Use Legacy / the Photo Filter menu existed keep rendering as before.
+#[test]
+fn old_saves_get_legacy_values_for_added_params() {
+    use effectcraft_project::build::Ids;
+    let mut next = 1;
+    for (id, param, want) in
+        [("ec.color.brightnesscontrast", "useLegacy", Value::Bool(true)), ("ec.color.photofilter", "filter", Value::Enum(PHOTO_FILTER_CUSTOM))]
+    {
+        let spec = crate::find(id).unwrap();
+        let mut g = crate::instantiate(spec, &mut Ids(&mut next), spec.name, [10.0, 10.0]);
+        g.children.retain(|c| c.match_id() != param);
+        crate::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), [10.0, 10.0]);
+        assert_eq!(g.get(param).unwrap().value, want, "{id}");
+    }
+}
+
+/// After Effects 2026 renders of full-frame solids with Tint at its defaults (sRGB working
+/// space, not linearised, 32 bpc, 8-bit capture): Rec. 601 weights on the encoded values.
+#[test]
+fn tint_defaults_match_after_effects_greys() {
+    for (c, want) in [([1.0, 0.0, 0.0], 76.0), ([0.0, 1.0, 0.0], 150.0), ([0.0, 0.0, 1.0], 29.0), ([0.5, 0.5, 0.5], 128.0)] {
+        let o = px("ec.color.tint", &[], [c[0], c[1], c[2], 1.0]);
+        let want = want / 255.0;
+        assert!(close(o, [want, want, want, 1.0], 1.0 / 255.0), "{c:?}: {o:?} vs {want}");
+    }
+}
+
+#[test]
+fn colorama_reads_get_phase_from() {
+    // Same intensity, different red: Intensity gives one colour, Red gives two.
+    let a = [0.6, 0.2, 0.2, 1.0];
+    let b = [0.2, 0.2, 0.6, 1.0];
+    let red = |c| px("ec.color.colorama", &[("inputPhase/mode", Value::Enum(1))], c);
+    assert!(!close(red(a), red(b), 1e-3));
+    // Zero maps everything to the start of the cycle (red).
+    assert!(close(px("ec.color.colorama", &[("inputPhase/mode", Value::Enum(9))], b), [1.0, 0.0, 0.0, 1.0], 1e-5));
+    // Interpolate Palette off posterizes: two nearby inputs land on the same colour.
+    let off = |v: f32| px("ec.color.colorama", &[("outputCycle/interpolatePalette", Value::Bool(false))], [v, v, v, 1.0]);
+    assert_eq!(off(0.20), off(0.22));
+}
+
+#[test]
+fn brightness_contrast_modern_keeps_black_and_white_and_legacy_is_linear() {
+    let bc = |vals: &[(&str, Value)], v: f32| px("ec.color.brightnesscontrast", vals, [v, v, v, 1.0])[0];
+    let up = [("brightness", num(50.0)), ("contrast", num(40.0))];
+    assert_eq!(bc(&up, 0.0), 0.0);
+    assert!((bc(&up, 1.0) - 1.0).abs() < 1e-6);
+    assert!(bc(&up, 0.4) > 0.4);
+    let legacy = [("brightness", num(50.0)), ("useLegacy", Value::Bool(true))];
+    assert!((bc(&legacy, 0.2) - 0.7).abs() < 1e-5);
+    assert!((bc(&legacy, 0.0) - 0.5).abs() < 1e-5);
+}
+
+/// After Effects non-legacy ramps (kasper9n, #681). B0 C-100 matched B0 C-50 and is omitted.
+#[test]
+fn brightness_contrast_modern_matches_ae_ramp_samples() {
+    let u8 = |v: f32| (v * 255.0).round() as i32;
+    let go = |b: f64, c: f64, x: u8| {
+        u8(px("ec.color.brightnesscontrast", &[("brightness", num(b)), ("contrast", num(c))], [x as f32 / 255.0, x as f32 / 255.0, x as f32 / 255.0, 1.0])[0])
+    };
+    // (brightness, contrast, input, AE 8-bit)
+    let samples: &[(f64, f64, u8, u8)] = &[
+        (0.0, 100.0, 64, 40),
+        (0.0, 100.0, 128, 129),
+        (0.0, 100.0, 192, 217),
+        (0.0, 50.0, 64, 53),
+        (0.0, 50.0, 192, 205),
+        (0.0, -50.0, 64, 77),
+        (100.0, 0.0, 128, 209),
+        (50.0, 0.0, 128, 171),
+        (106.0, -18.0, 128, 214),
+    ];
+    for &(b, c, x, ae) in samples {
+        let got = go(b, c, x);
+        assert!((got - ae as i32).abs() <= 10, "B{b} C{c} in {x}: got {got} AE {ae}");
+    }
+    // Old g=4 S-curve put Contrast 100 at ~8/255 here.
+    assert!(go(0.0, 100.0, 64) >= 30);
+}
+
+/// After Effects 2026: Tritone Highlights [1, 1, 0.8], Midtones [0.6, 0.2, 0.2], Shadows
+/// [0, 0, 0.3]. On a red solid with Blend With Original 25 (case 718) AE gives (132, 23, 46);
+/// on a grey ramp (case 815) levels 0, 63.9, 127.6, 191.4 give (0, 0, 77), (77, 26, 64),
+/// (153, 51, 51), (204, 153, 128).
+#[test]
+fn tritone_matches_after_effects() {
+    let colours =
+        [("highlights", Value::Color([1.0, 1.0, 0.8, 1.0])), ("midtones", Value::Color([0.6, 0.2, 0.2, 1.0])), ("shadows", Value::Color([0.0, 0.0, 0.3, 1.0]))];
+    let near = |o: [f32; 4], ae: [f32; 3]| (0..3).all(|i| (o[i] * 255.0 - ae[i]).abs() <= 1.0);
+    let mut red = colours.to_vec();
+    red.push(("blend", num(25.0)));
+    let o = px("ec.color.tritone", &red, [1.0, 0.0, 0.0, 1.0]);
+    assert!(near(o, [132.0, 23.0, 46.0]), "{:?}", o.map(|v| v * 255.0));
+    for (level, ae) in [(0.1f32, [0.0, 0.0, 77.0]), (63.9, [77.0, 26.0, 64.0]), (127.6, [153.0, 51.0, 51.0]), (191.4, [204.0, 153.0, 128.0])] {
+        let v = level / 255.0;
+        let o = px("ec.color.tritone", &colours, [v, v, v, 1.0]);
+        assert!(near(o, ae), "level {level}: {:?} vs {ae:?}", o.map(|v| v * 255.0));
+    }
+}
+
+/// After Effects 2026, Tint Color [1, 0.5, 0]: a red solid at Reds 10 (case 717) and yellow
+/// and white solids at the default sliders (case 825).
+#[test]
+fn black_white_tint_matches_after_effects() {
+    let tint = [("tint", Value::Bool(true)), ("tintColor", Value::Color([1.0, 0.5, 0.0, 1.0]))];
+    let near = |o: [f32; 4], ae: [f32; 3]| (0..3).all(|i| (o[i] * 255.0 - ae[i]).abs() <= 1.5);
+    let mut reds = tint.to_vec();
+    reds.push(("reds", num(10.0)));
+    let o = px("ec.color.blackwhite", &reds, [1.0, 0.0, 0.0, 1.0]);
+    assert!(near(o, [43.0, 21.0, 0.0]), "{:?}", o.map(|v| v * 255.0));
+    let o = px("ec.color.blackwhite", &tint, [1.0, 1.0, 0.0, 1.0]);
+    assert!(near(o, [255.0, 129.0, 2.0]), "{:?}", o.map(|v| v * 255.0));
+    let o = px("ec.color.blackwhite", &tint, [1.0, 1.0, 1.0, 1.0]);
+    assert!(near(o, [255.0, 255.0, 255.0]), "{:?}", o.map(|v| v * 255.0));
+    // Hostile grays stay finite.
+    for g in [f32::NAN, -1.0, 0.0, 4.0] {
+        assert!(bw_tint([1.0, 0.5, 0.0], g).iter().all(|v| v.is_finite()));
+    }
+}
+
+/// After Effects 2026 ramps (RENDERER round 2, session R8): negative Brightness and Contrast
+/// are the inverses of the positive curves. (brightness, contrast, input, AE 8-bit)
+#[test]
+fn negative_brightness_and_contrast_invert_the_positive_curves() {
+    let go = |b: f64, c: f64, x: u8| {
+        let v = x as f32 / 255.0;
+        (px("ec.color.brightnesscontrast", &[("brightness", num(b)), ("contrast", num(c))], [v, v, v, 1.0])[0] * 255.0).round() as i32
+    };
+    let samples: &[(f64, f64, u8, u8)] = &[
+        (-40.0, 0.0, 64, 50),
+        (-40.0, 0.0, 128, 99),
+        (-40.0, 0.0, 191, 155),
+        (-40.0, 0.0, 234, 207),
+        (0.0, -50.0, 21, 28),
+        (0.0, -50.0, 64, 76),
+        (0.0, -50.0, 191, 179),
+        (0.0, -50.0, 234, 227),
+        (40.0, 0.0, 128, 162),
+        (0.0, 50.0, 64, 52),
+    ];
+    for &(b, c, x, ae) in samples {
+        let got = go(b, c, x);
+        assert!((got - ae as i32).abs() <= 7, "B{b} C{c} in {x}: got {got} AE {ae}");
+    }
+}
+
+/// #1463: Black & White's sliders set the gray of each pure hue and blend between
+/// neighbouring hues; neutral pixels keep their value, overbright ones too, and an overbright
+/// colour stays finite (it used to divide by zero).
+#[test]
+fn black_white_sliders_set_the_gray_of_each_hue() {
+    let bw = |vals: &[(&str, Value)], c: [f32; 3]| px("ec.color.blackwhite", vals, [c[0], c[1], c[2], 1.0]);
+    let gray = |v: f32| [v, v, v, 1.0];
+    // The defaults: Reds 40, Yellows 60, Greens 40, Cyans 60, Blues 20, Magentas 80 (%).
+    let hues = [
+        ([1.0, 0.0, 0.0], 0.4),
+        ([1.0, 1.0, 0.0], 0.6),
+        ([0.0, 1.0, 0.0], 0.4),
+        ([0.0, 1.0, 1.0], 0.6),
+        ([0.0, 0.0, 1.0], 0.2),
+        ([1.0, 0.0, 1.0], 0.8),
+        // Half as bright, half the gray; orange is halfway from Reds to Yellows.
+        ([0.5, 0.0, 0.0], 0.2),
+        ([1.0, 0.5, 0.0], 0.5),
+        // Neutral pixels keep their value.
+        ([0.3, 0.3, 0.3], 0.3),
+        ([4.0, 4.0, 4.0], 4.0),
+        // An overbright red: its smallest channel plus its chroma at Reds' 40 %.
+        ([1.5, 0.5, 0.5], 0.9),
+    ];
+    for (c, want) in hues {
+        let o = bw(&[], c);
+        assert!(close(o, gray(want), 1e-5), "{c:?}: {o:?}, want {want}");
+    }
+    assert!(close(bw(&[("reds", num(120.0))], [1.0, 0.0, 0.0]), gray(1.2), 1e-5));
+    assert!(close(bw(&[("reds", num(-200.0))], [1.0, 0.0, 0.0]), gray(0.0), 1e-5));
+    assert!(close(bw(&[("blues", num(300.0))], [0.1, 0.1, 0.3]), gray(0.7), 1e-5));
+}
+
+/// #1463: faint colour noise stays faint. The shadows of compressed footage carry a code or
+/// two of colour noise, which Black & White turned into bright and black blocks (the HSL
+/// saturation it scaled is near 1 for any tinted near-black pixel). At 8, 16 and 32 bpc the
+/// gray of a dark ramp with ±2 steps of colour noise stays within 2 steps of the clean ramp's.
+#[test]
+fn black_white_keeps_faint_colour_noise_faint() {
+    // A step of 8 bpc, of 16 bpc (After Effects' 0..32768), and a small 32-bpc float one.
+    for step in [1.0 / 255.0, 1.0 / 32768.0, 1e-3_f32] {
+        let (w, h) = (64u32, 4u32);
+        let (mut clean, mut noisy) = (Image::new(w, h), Image::new(w, h));
+        for y in 0..h {
+            for x in 0..w {
+                // A dark ramp up to a quarter gray, in whole steps...
+                let v = (x as f32 / w as f32 * 0.25 / step).round() * step;
+                // ...and up to ±2 steps of noise per channel, mixed differently in each pixel.
+                let n = |k: u32| (((x * 7 + y * 13 + k * 2) % 5) as f32 - 2.0) * step;
+                clean.set(x, y, [v, v, v, 1.0]);
+                noisy.set(x, y, [(v + n(0)).max(0.0), (v + n(1)).max(0.0), (v + n(2)).max(0.0), 1.0]);
+            }
+        }
+        let bw = |img| run_fx("ec.color.blackwhite", &[], img, 0.0, EffectEnv::default()).img;
+        let (a, b) = (bw(clean), bw(noisy));
+        let worst = a.data.iter().zip(&b.data).map(|(p, q)| (p[0] - q[0]).abs()).fold(0.0, f32::max);
+        assert!(worst <= 2.0 * step + 1e-6, "step {step}: the noise moved the gray by {} steps", worst / step);
+    }
+}
+
+#[test]
+fn levels_clips_black_and_white_independently() {
+    let lv = |vals: &[(&str, Value)], v: f32| px("ec.color.levels", vals, [v, v, v, 1.0])[0];
+    let base = [("inBlack", num(0.2)), ("inWhite", num(0.6)), ("outBlack", num(0.1)), ("outWhite", num(0.9))];
+    assert!((lv(&base, 0.9) - 0.9).abs() < 1e-5);
+    let mut no_white = base.to_vec();
+    no_white.push(("clipToOutputWhite", Value::Enum(0)));
+    assert!(lv(&no_white, 0.9) > 0.9);
+    assert!((lv(&no_white, 0.0) - 0.1).abs() < 1e-5);
+    // The hidden switch of older projects turns both off.
+    let mut legacy = base.to_vec();
+    legacy.push(("noClip", Value::Bool(true)));
+    assert!(lv(&legacy, 0.9) > 0.9);
+}
+
+#[test]
+fn exposure_individual_channels_and_bypass() {
+    let g = [0.5, 0.5, 0.5, 1.0];
+    let one = px("ec.color.exposure", &[("channels", Value::Enum(1)), ("red/redExposure", num(1.0))], g);
+    assert!(one[0] > 0.6 && (one[1] - 0.5).abs() < 1e-5 && (one[2] - 0.5).abs() < 1e-5);
+    // Master values are ignored in Individual Channels mode.
+    assert!(close(px("ec.color.exposure", &[("channels", Value::Enum(1)), ("master/exposure", num(2.0))], g), g, 1e-5));
+    // Bypass Linear Light Conversion: +1 stop doubles the raw value.
+    let raw = px("ec.color.exposure", &[("master/exposure", num(1.0)), ("bypassLinearLight", Value::Bool(true))], [0.25, 0.25, 0.25, 1.0]);
+    assert!((raw[0] - 0.5).abs() < 1e-5);
+    // Negative results are mirrored, not clipped.
+    let neg =
+        px("ec.color.exposure", &[("master/offset", num(-0.5)), ("bypassLinearLight", Value::Bool(true)), ("master/gamma", num(2.0))], [0.25, 0.25, 0.25, 1.0]);
+    assert!((neg[0] + 0.5).abs() < 1e-4, "{neg:?}");
+}
+
+/// After Effects' Exposure ranges for all twelve sliders; a saved value outside them (a gamma
+/// of 0.05, valid before, as in Photoshop) survives loading and still renders.
+#[test]
+fn exposure_has_after_effects_ranges_and_keeps_old_values() {
+    use effectcraft_project::build::Ids;
+    let spec = crate::find("ec.color.exposure").unwrap();
+    let want = [(-100.0, 100.0, -4.0, 4.0, 2), (-2.0, 2.0, -0.5, 0.5, 4), (0.1, 10.0, 0.1, 10.0, 2)];
+    let sliders: Vec<_> = spec
+        .params
+        .iter()
+        .filter_map(|p| match p.ui {
+            ParamUi::Slider { min, max, slider_min, slider_max, decimals } => Some((p.id, (min, max, slider_min, slider_max, decimals))),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(sliders.len(), 12);
+    for (i, (id, r)) in sliders.iter().enumerate() {
+        assert_eq!(*r, want[i % 3], "{id}");
+    }
+    let mut next = 1;
+    let mut g = crate::instantiate(spec, &mut Ids(&mut next), spec.name, [10.0, 10.0]);
+    let gamma = g.prop_mut("master/gamma").unwrap();
+    gamma.value = num(0.05);
+    gamma.ui = slider(0.01, 9.99, 0.1, 3.0, 2);
+    crate::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), [10.0, 10.0]);
+    let gamma = g.prop_mut("master/gamma").unwrap();
+    assert_eq!(gamma.value, num(0.05));
+    assert!(matches!(gamma.ui, ParamUi::Slider { min, .. } if min == 0.1));
+    let o = px("ec.color.exposure", &[("master/gamma", num(0.05)), ("bypassLinearLight", Value::Bool(true))], [0.5, 0.5, 0.5, 1.0]);
+    assert!((o[0] - 0.5f32.powf(20.0)).abs() < 1e-9, "{o:?}");
+}
+
+/// Exposure on a red [1, 0, 0] solid against After Effects 2026 renders (sRGB working space,
+/// not linearised, 32 bpc, 8-bit captures): the linear-light conversion is a pure 2.2 power.
+/// The piecewise sRGB curve gave 2 / 7 / 39 for the three smallest Offsets.
+#[test]
+fn exposure_matches_after_effects_gamma_2_2() {
+    let red = [1.0, 0.0, 0.0, 1.0];
+    let code = |o: [f32; 4], i: usize| o[i] * 255.0;
+    // Master Offset only: G and B carry the curve; R goes over 1 (255 in the 8-bit capture).
+    for (offset, ae) in [(0.0005, 8.0), (0.002, 15.0), (0.02, 43.0), (0.1, 90.0)] {
+        let o = px("ec.color.exposure", &[("master/offset", num(offset))], red);
+        for i in [1, 2] {
+            assert!((code(o, i) - ae).abs() <= 1.0, "offset {offset}: {} vs AE {ae}", code(o, i));
+        }
+        assert!(o[0] >= 1.0, "{o:?}");
+    }
+    // Exposure −2.25: AE 126; with Bypass Linear Light Conversion (gain on encoded values) 54.
+    let o = px("ec.color.exposure", &[("master/exposure", num(-2.25))], red);
+    assert!((code(o, 0) - 126.0).abs() <= 1.0 && o[1] == 0.0, "{o:?}");
+    let o = px("ec.color.exposure", &[("master/exposure", num(-2.25)), ("bypassLinearLight", Value::Bool(true))], red);
+    assert!((code(o, 0) - 54.0).abs() <= 1.0 && o[1] == 0.0, "{o:?}");
+    // Default settings leave 32-bpc values alone, negative and over-range ones included.
+    let hdr = [-0.25, 0.5, 2.0, 1.0];
+    assert!(close(px("ec.color.exposure", &[], hdr), hdr, 1e-5));
+    // A negative Offset pushes black below zero, mirrored, rather than clipping or NaN.
+    let o = px("ec.color.exposure", &[("master/offset", num(-0.02))], [0.0, 0.0, 0.0, 1.0]);
+    assert!((o[0] + 0.02f32.powf(1.0 / 2.2)).abs() < 1e-5, "{o:?}");
+}
+
+#[test]
+fn change_to_color_change_modes_tolerances_and_matte() {
+    let red = [0.8, 0.1, 0.1, 1.0];
+    let green = [0.1, 0.8, 0.1, 1.0];
+    let base = [("from", col(0.8, 0.1, 0.1)), ("to", col(0.1, 0.1, 0.8))];
+    // Hue only: red turns blue with its own lightness / saturation; green is untouched.
+    let o = px("ec.color.changetocolor", &base, red);
+    assert!(o[2] > 0.7 && o[0] < 0.2, "{o:?}");
+    assert!(close(px("ec.color.changetocolor", &base, green), green, 1e-5));
+    // The matte is white where matched, black elsewhere.
+    let mut m = base.to_vec();
+    m.push(("viewCorrectionMatte", Value::Bool(true)));
+    assert!(close(px("ec.color.changetocolor", &m, red), [1.0, 1.0, 1.0, 1.0], 1e-5));
+    assert!(close(px("ec.color.changetocolor", &m, green), [0.0, 0.0, 0.0, 1.0], 1e-5));
+    // A lightness tolerance of 0 rejects a lighter red.
+    let mut strict = m.clone();
+    strict.push(("toleranceGroup/lightness", num(0.0)));
+    strict.push(("softness", num(0.0)));
+    assert!(close(px("ec.color.changetocolor", &strict, [1.0, 0.5, 0.5, 1.0]), [0.0, 0.0, 0.0, 1.0], 1e-5));
+    // Hue, Lightness & Saturation, set: a matched pixel becomes the To colour.
+    let mut all = base.to_vec();
+    all.push(("change", Value::Enum(3)));
+    assert!(close(px("ec.color.changetocolor", &all, red), [0.1, 0.1, 0.8, 1.0], 1e-4));
+}
+
+#[test]
+fn leave_color_tolerance_softness_and_match_mode() {
+    let green = [0.1, 0.8, 0.1, 1.0];
+    let lc = |vals: &[(&str, Value)]| {
+        let mut v = vec![("amount", num(100.0))];
+        v.extend_from_slice(vals);
+        px("ec.color.leavecolor", &v, green)
+    };
+    let g = luminance(0.1, 0.8, 0.1);
+    assert!(close(lc(&[]), [g, g, g, 1.0], 1e-5));
+    assert!(close(lc(&[("tolerance", num(100.0))]), green, 1e-6));
+    // Softness keeps part of the colour.
+    let s = lc(&[("tolerance", num(10.0)), ("edgeSoftness", num(100.0))]);
+    assert!(s[1] > g + 0.05 && s[1] < 0.8);
+    // Using Hue: a dark red still matches pure red.
+    let dark = px("ec.color.leavecolor", &[("amount", num(100.0)), ("tolerance", num(5.0)), ("matchColors", Value::Enum(1))], [0.4, 0.0, 0.0, 1.0]);
+    assert!(close(dark, [0.4, 0.0, 0.0, 1.0], 1e-6));
+}
+
+#[test]
+fn photo_filter_presets_and_custom() {
+    let g = [0.5, 0.5, 0.5, 1.0];
+    let cool = px("ec.color.photofilter", &[("filter", Value::Enum(3)), ("preserveLuminosity", Value::Bool(false))], g);
+    assert!(cool[2] > cool[0], "a cooling filter is blue: {cool:?}");
+    let custom = |c| px("ec.color.photofilter", &[("filter", Value::Enum(PHOTO_FILTER_CUSTOM)), ("color", c)], g);
+    assert!(custom(col(0.0, 1.0, 0.0))[1] > custom(col(1.0, 0.0, 0.0))[1]);
+    // The Color swatch is ignored by the presets.
+    let warm = |c| px("ec.color.photofilter", &[("color", c)], g);
+    assert_eq!(warm(col(0.0, 1.0, 0.0)), warm(col(1.0, 0.0, 0.0)));
+}
+
+#[test]
+fn color_balance_preserve_luminosity_and_black_stretch() {
+    let g = [0.5, 0.5, 0.5, 1.0];
+    let o = px("ec.color.colorbalance", &[("midRed", num(60.0)), ("preserveLuminosity", Value::Bool(true))], g);
+    assert!((luminance(o[0], o[1], o[2]) - 0.5).abs() < 1e-4 && o[0] > o[2]);
+    let dark = [0.1, 0.1, 0.1, 1.0];
+    assert!(px("ec.color.gammapedestalgain", &[("blackStretch", num(4.0))], dark)[0] > 0.15);
+    assert!(close(px("ec.color.gammapedestalgain", &[], dark), dark, 1e-6));
+}
+
+#[test]
+fn levels_channel_controls_act_on_their_channel() {
+    let g = [0.5, 0.5, 0.5, 1.0];
+    assert!(close(px("ec.color.levels", &[("channel", Value::Enum(1))], g), g, 1e-6), "the popup alone changes nothing");
+    let r = px("ec.color.levels", &[("redOutWhite", num(0.5))], g);
+    assert!(close(r, [0.25, 0.5, 0.5, 1.0], 1e-5), "{r:?}");
+    let b = px("ec.color.levels", &[("blueGamma", num(2.0)), ("inWhite", num(0.5))], [0.25, 0.25, 0.25, 1.0]);
+    assert!(close(b, [0.5, 0.5, 0.5f32.sqrt(), 1.0], 1e-5), "RGB first, then blue: {b:?}");
+    let a = px("ec.color.levels", &[("alphaOutWhite", num(0.5))], [0.5, 0.5, 0.5, 1.0]);
+    assert!(close(a, [0.25, 0.25, 0.25, 0.5], 1e-5), "{a:?}");
+    // Per-channel clipping follows its own popups.
+    let hot = [0.9, 0.9, 0.9, 1.0];
+    let c = px("ec.color.levels", &[("greenInWhite", num(0.5))], hot)[1];
+    let nc = px("ec.color.levels", &[("greenInWhite", num(0.5)), ("greenClipToOutputWhite", Value::Enum(0))], hot)[1];
+    assert!((c - 1.0).abs() < 1e-6 && (nc - 1.8).abs() < 1e-5, "{c} {nc}");
+}
+
+#[test]
+fn hue_saturation_ranges_adjust_their_hues_only() {
+    let red = [0.8, 0.1, 0.1, 1.0];
+    let blue = [0.1, 0.1, 0.8, 1.0];
+    let grey = [0.5, 0.5, 0.5, 1.0];
+    let v = [("redsSaturation", num(-100.0))];
+    let r = px("ec.color.huesaturation", &v, red);
+    assert!((r[0] - r[1]).abs() < 1e-4, "reds desaturated: {r:?}");
+    assert!(close(px("ec.color.huesaturation", &v, blue), blue, 1e-5));
+    assert!(close(px("ec.color.huesaturation", &v, grey), grey, 1e-5));
+    // Blues hue +120°: blue becomes red.
+    let b = px("ec.color.huesaturation", &[("bluesHue", num(120.0))], blue);
+    assert!(b[0] > 0.7 && b[2] < 0.2, "{b:?}");
+    // Fall-off: a hue 15° past the range end (Reds: −15..15, fall-off 30) gets half.
+    let orange_ish = {
+        let (r, g, b) = hsl_to_rgb(30.0 / 360.0, 0.8, 0.5);
+        [r, g, b, 1.0]
+    };
+    let o = px("ec.color.huesaturation", &[("redsLightness", num(100.0))], orange_ish);
+    let (_, _, l) = rgb_to_hsl(o[0], o[1], o[2]);
+    assert!((l - 0.75).abs() < 0.01, "half weight: {l}");
+    // Moving the range changes which hues it takes.
+    let o2 = px("ec.color.huesaturation", &[("redsLightness", num(100.0)), ("redsRangeEnd", num(40.0))], orange_ish);
+    assert!(rgb_to_hsl(o2[0], o2[1], o2[2]).2 > 0.99);
+    let params = crate::Params { values: [("redsHue".to_string(), num(10.0))].into_iter().collect() };
+    let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [1.0, 1.0], seed: 0, adjustment: false, env: Default::default() };
+    assert!(!huesat_ranges_identity(&ctx));
+}
+
+#[test]
+fn fill_mask_all_masks_feather_and_invert() {
+    let sq =
+        |x0: f64, x1: f64| crate::MaskShape { name: String::new(), points: vec![[x0, 0.0], [x1, 0.0], [x1, 10.0], [x0, 10.0]], closed: true, inverted: false };
+    let masks = [sq(0.0, 5.0), sq(15.0, 20.0)];
+    let env = EffectEnv { masks: &masks, ..Default::default() };
+    let grey = Image::filled(20, 10, [0.5, 0.5, 0.5, 1.0]);
+    let run = |vals: &[(&str, Value)]| run_fx("ec.generate.fill", vals, grey.clone(), 0.0, env).img;
+    let one = run(&[("fillMask", num(1.0))]);
+    assert_eq!(one.get(2, 5), [1.0, 0.0, 0.0, 1.0]);
+    assert_eq!(one.get(10, 5), [0.5, 0.5, 0.5, 1.0]);
+    assert_eq!(one.get(17, 5), [0.5, 0.5, 0.5, 1.0]);
+    let all = run(&[("allMasks", Value::Bool(true))]);
+    assert_eq!(all.get(17, 5), [1.0, 0.0, 0.0, 1.0]);
+    let inv = run(&[("fillMask", num(1.0)), ("invert", Value::Bool(true))]);
+    assert_eq!(inv.get(2, 5), [0.5, 0.5, 0.5, 1.0]);
+    assert_eq!(inv.get(10, 5), [1.0, 0.0, 0.0, 1.0]);
+    let soft = run(&[("fillMask", num(1.0)), ("horizontalFeather", num(6.0))]);
+    let v = soft.get(6, 5)[1];
+    assert!(v > 0.05 && v < 0.5, "feathered edge {v}");
+    // Without masks, Fill fills the layer as before.
+    let plain = run_fx("ec.generate.fill", &[("fillMask", num(1.0))], grey.clone(), 0.0, EffectEnv::default()).img;
+    assert_eq!(plain.get(10, 5), [1.0, 0.0, 0.0, 1.0]);
+}
+
+/// After Effects 2026: Fill (0, 0.5, 1) at Opacity 50 % on an opaque layer (a Gradient Ramp
+/// on a red solid) renders premultiplied (0, 0.251, 0.502) at alpha 0.502 everywhere: the
+/// fill colour at half the layer's alpha, nothing of the ramp left.
+#[test]
+fn fill_opacity_is_the_layers_opacity_as_in_after_effects() {
+    let mut img = Image::new(16, 4);
+    for x in 0..16 {
+        let v = x as f32 / 15.0;
+        for y in 0..4 {
+            img.set(x, y, [v, 0.0, 0.0, 1.0]);
+        }
+    }
+    let vals = [("color", Value::Color([0.0, 0.5, 1.0, 1.0])), ("opacity", num(50.0))];
+    let out = run_fx("ec.generate.fill", &vals, img, 0.0, EffectEnv::default()).img;
+    for x in [0, 7, 15] {
+        let p = out.get(x, 2);
+        let ae = [0.0, 0.251, 0.502, 0.502];
+        assert!(p.iter().zip(ae).all(|(v, a)| (v - a).abs() < 1.0 / 255.0), "x {x}: {p:?} vs AE {ae:?}");
+    }
+    // A half-transparent pixel ends at a quarter alpha, still the fill colour.
+    let half = run_fx("ec.generate.fill", &vals, Image::filled(2, 2, [0.2, 0.2, 0.2, 0.5]), 0.0, EffectEnv::default()).img;
+    assert_eq!(half.get(0, 0), [0.0, 0.125, 0.25, 0.25]);
+}
+
+#[test]
+fn colorama_palettes_modify_selection_masking_and_add_phase() {
+    let grey = [0.5, 0.5, 0.5, 1.0];
+    let red = [1.0, 0.0, 0.0, 1.0];
+    // Ramp Grayscale: intensity 0.5 maps to mid grey.
+    let g = px("ec.color.colorama", &[("outputCycle/usePresetPalette", Value::Enum(1))], grey);
+    assert!((g[0] - 0.5).abs() < 0.01 && (g[0] - g[2]).abs() < 1e-5, "{g:?}");
+    // Custom palette: two stops, black at 0 and blue at 0.5.
+    let custom = [("outputCycle/usePresetPalette", Value::Enum(8)), ("outputCycle/palette", Value::Str("0:0,0,0 0.5:0,0,1".into()))];
+    let c = px("ec.color.colorama", &custom, grey);
+    assert!(c[2] > 0.99 && c[0] < 0.01, "{c:?}");
+    // Modify Lightness keeps the hue of the pixel (red stays red).
+    let l = px("ec.color.colorama", &[("modify/modify", Value::Enum(5)), ("outputCycle/usePresetPalette", Value::Enum(1))], red);
+    assert!(l[0] > l[1] + 0.2 && l[1] < 0.01 + l[2] + 1e-4, "{l:?}");
+    // Pixel Selection: only colours near Matching Color change.
+    let sel = [
+        ("pixelSelection/matchingMode", Value::Enum(1)),
+        ("pixelSelection/matchingColor", col(1.0, 0.0, 0.0)),
+        ("pixelSelection/matchingTolerance", num(10.0)),
+    ];
+    assert!(close(px("ec.color.colorama", &sel, grey), grey, 1e-6));
+    assert!(!close(px("ec.color.colorama", &sel, red), red, 1e-3));
+    // Composite Over Layer off: unselected pixels vanish.
+    let mut off = sel.to_vec();
+    off.push(("masking/compositeOverLayer", Value::Bool(false)));
+    assert_eq!(px("ec.color.colorama", &off, grey)[3], 0.0);
+    // Modify Alpha takes the palette alpha.
+    let alpha = [
+        ("outputCycle/usePresetPalette", Value::Enum(8)),
+        ("outputCycle/palette", Value::Str("0:1,1,1,0.25".into())),
+        ("modify/modifyAlpha", Value::Bool(true)),
+    ];
+    assert!((px("ec.color.colorama", &alpha, grey)[3] - 0.25).abs() < 1e-5);
+    // Palette parsing and evaluation.
+    let p = ColoramaPalette::parse("0.5:0,0,1 0:1,0,0").unwrap();
+    assert_eq!(p.eval(0.25, true), [0.5, 0.0, 0.5, 1.0]);
+    assert_eq!(p.eval(0.75, true), [0.5, 0.0, 0.5, 1.0], "wraps around");
+    assert_eq!(p.eval(0.25, false), [1.0, 0.0, 0.0, 1.0]);
+}
diff --git a/crates/effects/src/distort.rs b/crates/effects/src/distort.rs
index 534da8061..916e162f6 100644
--- a/crates/effects/src/distort.rs
+++ b/crates/effects/src/distort.rs
@@ -275,27 +275,70 @@ pub fn transform_shutter(ctx: &EffectCtx) -> Option<(f64, f64, u32)> {
     (angle > 0.0).then_some((angle, phase, n.clamp(2, 64)))
 }
 
-fn transform_matrix(pr: &crate::Params, b: &Buf) -> Mat3 {
-    let anchor = b.to_px(pr.v2("anchor"));
-    let pos = b.to_px(pr.v2("position"));
+/// The Transform effect's matrix in buffer pixels (`to_px` maps layer pixels into the buffer),
+/// as After Effects 2026 draws it (cases 723, 819, 820): `position + K · R · S · (p − anchor)`
+/// with the skew `K = rot(−axis) · shearY(tan skew) · rot(axis)` applied after the rotation.
+pub fn transform_matrix_px(pr: &crate::Params, to_px: impl Fn([f64; 2]) -> (f64, f64)) -> Mat3 {
+    let anchor = to_px(pr.v2("anchor"));
+    let pos = to_px(pr.v2("position"));
     let sh = pr.f("scaleHeight");
     let sw = if pr.b("uniform") { sh } else { pr.f("scaleWidth") };
+    let axis = pr.f("skewAxis");
+    let k = pr.f("skew").clamp(-85.0, 85.0).to_radians().tan();
+    let k = if k.is_finite() { k } else { 0.0 };
+    let skew = Mat3::rotate_deg(-axis) * Mat3([[1.0, 0.0, 0.0], [k, 1.0, 0.0], [0.0, 0.0, 1.0]]) * Mat3::rotate_deg(axis);
     Mat3::translate(vec2(pos.0, pos.1))
+        * skew
         * Mat3::rotate_deg(pr.f("rotation"))
-        * Mat3::skew_deg(pr.f("skew"), pr.f("skewAxis"))
         * Mat3::scale(vec2(sw / 100.0, sh / 100.0))
         * Mat3::translate(vec2(-anchor.0, -anchor.1))
 }
 
+fn transform_matrix(pr: &crate::Params, b: &Buf) -> Mat3 {
+    transform_matrix_px(pr, |p| b.to_px(p))
+}
+
+/// The transparent margins (left, top, right, bottom) a `w` x `h` buffer needs so its warp by
+/// any of `ms` stays on it: After Effects draws Transform's result outside the layer's bounds
+/// (case 723). Each side grows by its own overshoot; the grown buffer is capped at 16 384 px a
+/// side and 16 Mpx in all (the margins shrink in proportion), so a layer moved far away costs
+/// a bounded allocation.
+pub fn transform_grow(ms: &[Mat3], w: u32, h: u32) -> [u32; 4] {
+    const SIDE: f64 = 16_384.0;
+    const AREA: f64 = 16_777_216.0;
+    let (wf, hf) = (w as f64, h as f64);
+    let mut m = [0.0f64; 4];
+    for mat in ms {
+        for (x, y) in [(0.0, 0.0), (wf, 0.0), (0.0, hf), (wf, hf)] {
+            let q = mat.apply(vec2(x, y));
+            if q.x.is_finite() && q.y.is_finite() {
+                m = [m[0].max(-q.x), m[1].max(-q.y), m[2].max(q.x - wf), m[3].max(q.y - hf)];
+            }
+        }
+    }
+    let m = m.map(|v| v.ceil().max(0.0));
+    let fit = |len: f64, a: f64, b: f64| -> f64 {
+        let room = (SIDE - len).max(0.0);
+        if a + b > room && a + b > 0.0 { room / (a + b) } else { 1.0 }
+    };
+    let kx = fit(wf, m[0], m[2]);
+    let ky = fit(hf, m[1], m[3]);
+    let area = |k: f64| (wf + (m[0] + m[2]) * kx * k) * (hf + (m[1] + m[3]) * ky * k);
+    let k = if area(1.0) > AREA && area(1.0) > wf * hf {
+        // Shrink both margins by the same factor until the area fits.
+        let (mut lo, mut hi) = (0.0f64, 1.0f64);
+        for _ in 0..40 {
+            let mid = (lo + hi) / 2.0;
+            if area(mid) > AREA { hi = mid } else { lo = mid }
+        }
+        lo
+    } else {
+        1.0
+    };
+    [m[0] * kx * k, m[1] * ky * k, m[2] * kx * k, m[3] * ky * k].map(|v| v.floor().clamp(0.0, SIDE) as u32)
+}
+
 fn transform(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let anchor = b.to_px(ctx.params.v2("anchor"));
-    let pos = b.to_px(ctx.params.v2("position"));
-    let uniform = ctx.params.b("uniform");
-    let sh = ctx.params.f("scaleHeight");
-    let sw = if uniform { sh } else { ctx.params.f("scaleWidth") };
-    let skew = ctx.params.f("skew");
-    let skew_axis = ctx.params.f("skewAxis");
-    let rot = ctx.params.f("rotation");
     let opacity = ctx.params.f("opacity") as f32 / 100.0;
     let sampling = if ctx.params.e("sampling") == 1 { effectcraft_raster::Sampling::Bicubic } else { effectcraft_raster::Sampling::Bilinear };
     // Motion blur: the transform at Samples instants across the shutter, averaged (the
@@ -304,33 +347,35 @@ fn transform(ctx: &EffectCtx, mut b: Buf) -> Buf {
         && let Some(host) = ctx.env.host
     {
         let fd = 1.0 / ctx.fps();
-        let mut acc = Image::new(b.img.width, b.img.height);
-        let mut count = 0.0f32;
-        for k in 0..n {
-            let t = ctx.time + (phase + angle * k as f64 / (n - 1) as f64) / 360.0 * fd;
-            let Some(pr) = host.params_at(t) else { continue };
-            let mut one = Image::new(b.img.width, b.img.height);
-            let op = pr.f("opacity") as f32 / 100.0;
-            effectcraft_raster::composite_warp(
-                &mut one,
-                &b.img,
-                &transform_matrix(&pr, &b),
-                &effectcraft_raster::WarpOpts { opacity: op, sampling, ..Default::default() },
-            );
-            acc.data.iter_mut().zip(&one.data).for_each(|(a, o)| (0..4).for_each(|c| a[c] += o[c]));
-            count += 1.0;
-        }
-        if count > 0.0 {
+        let samples: Vec<crate::Params> = (0..n).filter_map(|k| host.params_at(ctx.time + (phase + angle * k as f64 / (n - 1) as f64) / 360.0 * fd)).collect();
+        if !samples.is_empty() {
+            if !ctx.adjustment {
+                let ms: Vec<Mat3> = samples.iter().map(|pr| transform_matrix(pr, &b)).collect();
+                b.pad_sides(transform_grow(&ms, b.img.width, b.img.height));
+            }
+            let mut acc = Image::new(b.img.width, b.img.height);
+            for pr in &samples {
+                let mut one = Image::new(b.img.width, b.img.height);
+                let op = pr.f("opacity") as f32 / 100.0;
+                effectcraft_raster::composite_warp(
+                    &mut one,
+                    &b.img,
+                    &transform_matrix(pr, &b),
+                    &effectcraft_raster::WarpOpts { opacity: op, sampling, ..Default::default() },
+                );
+                acc.data.iter_mut().zip(&one.data).for_each(|(a, o)| (0..4).for_each(|c| a[c] += o[c]));
+            }
+            let count = samples.len() as f32;
             acc.data.iter_mut().for_each(|p| p.iter_mut().for_each(|v| *v /= count));
             b.img = acc;
             return b;
         }
     }
-    let m = Mat3::translate(vec2(pos.0, pos.1))
-        * Mat3::rotate_deg(rot)
-        * Mat3::skew_deg(skew, skew_axis)
-        * Mat3::scale(vec2(sw / 100.0, sh / 100.0))
-        * Mat3::translate(vec2(-anchor.0, -anchor.1));
+    if !ctx.adjustment {
+        let m = transform_matrix(ctx.params, &b);
+        b.pad_sides(transform_grow(&[m], b.img.width, b.img.height));
+    }
+    let m = transform_matrix(ctx.params, &b);
     let mut out = Image::new(b.img.width, b.img.height);
     effectcraft_raster::composite_warp(&mut out, &b.img, &m, &effectcraft_raster::WarpOpts { opacity, sampling, ..Default::default() });
     b.img = out;
@@ -576,6 +621,144 @@ mod tests {
         }
     }
 
+    /// After Effects 2026 (cases 723, 819, 820): a grey 960 × 540 solid centred in a 1920 × 1080
+    /// comp with Transform. The skew applies after the rotation, and the result is drawn outside
+    /// the layer's bounds. Points are comp pixels sampled from AE's renders (at least 3 px from
+    /// an edge; true = the solid covers it), half where the old order and clipping differed.
+    #[test]
+    fn transform_matches_after_effects() {
+        let solid = Image::filled(960, 540, [0.5, 0.5, 0.5, 1.0]);
+        let p2 = |x: f64, y: f64| Value::Vec2([x, y]);
+        let cases: [(&str, Vec<(&str, Value)>, &[(u32, u32, bool)]); 3] = [
+            (
+                "723",
+                vec![
+                    ("anchor", p2(400.0, 200.0)),
+                    ("position", p2(500.0, 300.0)),
+                    ("uniform", Value::Bool(false)),
+                    ("scaleHeight", num(80.0)),
+                    ("scaleWidth", num(120.0)),
+                    ("skew", num(10.0)),
+                    ("skewAxis", num(20.0)),
+                    ("rotation", num(30.0)),
+                ],
+                &[
+                    (1465, 954, true),
+                    (1127, 821, true),
+                    (1378, 846, true),
+                    (1416, 878, true),
+                    (1486, 850, true),
+                    (492, 467, true),
+                    (706, 239, true),
+                    (1402, 1021, true),
+                    (518, 440, true),
+                    (1218, 882, true),
+                    (454, 448, true),
+                    (1473, 920, true),
+                    (1048, 654, true),
+                    (1050, 486, true),
+                    (1060, 736, true),
+                    (932, 804, true),
+                    (1074, 562, true),
+                    (653, 591, true),
+                    (1353, 466, false),
+                    (88, 1021, false),
+                    (1855, 886, false),
+                    (1796, 401, false),
+                    (497, 913, false),
+                    (1445, 515, false),
+                ],
+            ),
+            (
+                "819",
+                vec![("skew", num(15.0)), ("skewAxis", num(60.0))],
+                &[
+                    (465, 367, true),
+                    (554, 793, false),
+                    (481, 529, true),
+                    (1451, 599, true),
+                    (428, 575, true),
+                    (432, 600, true),
+                    (463, 444, true),
+                    (759, 803, false),
+                    (445, 684, true),
+                    (1411, 757, true),
+                    (915, 784, false),
+                    (480, 737, true),
+                    (758, 620, true),
+                    (975, 705, true),
+                    (1289, 376, true),
+                    (575, 420, true),
+                    (1015, 507, true),
+                    (1377, 448, true),
+                    (1679, 171, false),
+                    (194, 435, false),
+                    (413, 159, false),
+                    (327, 741, false),
+                    (1824, 138, false),
+                    (1093, 29, false),
+                ],
+            ),
+            (
+                "820",
+                vec![
+                    ("skew", num(15.0)),
+                    ("skewAxis", num(60.0)),
+                    ("rotation", num(-25.0)),
+                    ("uniform", Value::Bool(false)),
+                    ("scaleWidth", num(130.0)),
+                    ("scaleHeight", num(70.0)),
+                    ("anchor", p2(100.0, 50.0)),
+                ],
+                &[
+                    (1674, 566, true),
+                    (1425, 317, false),
+                    (1788, 278, true),
+                    (1530, 390, true),
+                    (1531, 652, true),
+                    (1589, 545, true),
+                    (1890, 441, true),
+                    (1724, 400, true),
+                    (1657, 511, true),
+                    (1895, 261, true),
+                    (1697, 344, true),
+                    (933, 840, true),
+                    (1413, 467, true),
+                    (1295, 691, true),
+                    (1353, 548, true),
+                    (1293, 548, true),
+                    (1103, 551, true),
+                    (973, 758, true),
+                    (446, 484, false),
+                    (1009, 420, false),
+                    (144, 761, false),
+                    (1812, 111, false),
+                    (1241, 10, false),
+                    (900, 854, false),
+                ],
+            ),
+        ];
+        for (case, set, pts) in cases {
+            let o = run("ec.distort.transform", &set, solid.clone());
+            for &(x, y, inside) in pts {
+                // Comp pixel → layer pixel (the solid's top-left sits at 480, 270) → buffer.
+                let (bx, by) = o.to_px([x as f64 + 0.5 - 480.0, y as f64 + 0.5 - 270.0]);
+                let a = if bx >= 0.0 && by >= 0.0 && bx < o.img.width as f64 && by < o.img.height as f64 { o.img.get(bx as i64, by as i64)[3] } else { 0.0 };
+                assert_eq!(a > 0.5, inside, "case {case}: comp pixel ({x}, {y}) alpha {a}");
+            }
+        }
+        // A huge scale stays within the buffer cap.
+        let o = run("ec.distort.transform", &[("scaleHeight", num(100_000.0))], Image::filled(8, 8, [1.0; 4]));
+        assert!(o.img.width <= 16_384 && o.img.height <= 16_384);
+        // A layer moved far right grows the buffer on that side only, within 16 Mpx.
+        let o = run("ec.distort.transform", &[("position", p2(960.0 + 2000.0, 540.0))], Image::filled(1920, 1080, [1.0; 4]));
+        assert_eq!((o.offset[0], o.img.height), (0.0, 1080), "only the right side grows");
+        assert!(o.img.width >= 1920 + 2000 && o.img.width as u64 * o.img.height as u64 <= 16_777_216, "{} x {}", o.img.width, o.img.height);
+        assert!(o.img.get(2000 + 960, 540)[3] > 0.99 && o.img.get(10, 540)[3] < 0.01);
+        let o = run("ec.distort.transform", &[("position", p2(40_000.0, 30_000.0))], Image::filled(1920, 1080, [1.0; 4]));
+        assert!(o.img.width as u64 * o.img.height as u64 <= 16_777_216, "{} x {}", o.img.width, o.img.height);
+    }
+
     #[test]
     fn transform_sampling_bicubic_differs_from_bilinear() {
         let im = img(32, 32);
diff --git a/crates/effects/src/distort2.rs b/crates/effects/src/distort2.rs
index 10ec59735..7add5fc58 100644
--- a/crates/effects/src/distort2.rs
+++ b/crates/effects/src/distort2.rs
@@ -19,7 +19,7 @@ use effectcraft_project::ParamUi;
 use effectcraft_raster::{Image, Px};
 use rayon::prelude::*;
 
-use crate::generate::value_noise;
+use crate::generate::value_noise_linear_z;
 use crate::util::{SRC_NAMES, Src, fit_layer, layer_cover_pad, layer_rect, lerp4, map_xy, pick, premul, remap, smoothstep, src_at, unpremul};
 use crate::{Buf, EffectCtx, EffectSpec, col, num, p, popup, slider};
 
@@ -37,13 +37,15 @@ fn pct(max: f64) -> ParamUi {
 
 // ---------------------------------------------------------------- Turbulent Displace
 
+/// Fractional-octave fBm of value noise in 0..1. Evolution (`z`) is linear: with the eased z of
+/// plain value noise a few degrees of Evolution barely moved the pattern (#943).
 fn fbm(u: f64, v: f64, z: f64, seed: u32, octaves: f64, falloff: f32) -> f32 {
     let n = octaves.ceil().max(1.0) as usize;
     let frac = (octaves - octaves.floor()) as f32;
     let (mut sum, mut norm, mut amp, mut f) = (0.0f32, 0.0f32, 1.0f32, 1.0f32);
     for o in 0..n {
         let w = if o + 1 == n && frac > 0.0 { frac } else { 1.0 };
-        sum += value_noise(u as f32 * f, v as f32 * f, z as f32 + o as f32 * 5.17, seed.wrapping_add(o as u32 * 101)) * amp * w;
+        sum += value_noise_linear_z(u as f32 * f, v as f32 * f, z as f32 + o as f32 * 5.17, seed.wrapping_add(o as u32 * 101)) * amp * w;
         norm += amp * w;
         amp *= falloff;
         f *= 2.0;
@@ -93,6 +95,9 @@ fn turbulent_displace(ctx: &EffectCtx, mut b: Buf) -> Buf {
     let size = (ctx.params.f("size") * b.scale).max(1.0);
     if ctx.params.b("resizeLayer") && !ctx.adjustment {
         b.pad(amount.abs().ceil() as u32 + 1);
+    } else {
+        // Room for pixels displaced past the content, up to the layer's edge (#1205).
+        b.pad(crate::cover_pad(ctx, [b.img.width, b.img.height], b.offset, b.scale, amount.abs().ceil() as u32 + 1));
     }
     let off = b.to_px(ctx.params.v2("offset"));
     let oct = ctx.params.f("complexity").clamp(1.0, 10.0);
@@ -1115,6 +1120,45 @@ mod tests {
         assert_eq!(TURBULENT_PINNING[11], "Pin Left Locked");
     }
 
+    /// #943: every non-equivalent Evolution value renders a visibly different frame. The eased
+    /// evolution axis left 0 and 37 degrees (or 360 and 400) within a hundredth of each other.
+    #[test]
+    fn turbulent_displace_evolution_changes_the_output() {
+        // A smooth ramp (red = x, green = y) with Pin All Locked, so the frame stays opaque and
+        // the difference is purely how far the pattern moved.
+        let mut ramp = Image::new(64, 64);
+        for y in 0..64u32 {
+            for x in 0..64u32 {
+                ramp.set(x, y, [x as f32 / 63.0, y as f32 / 63.0, 0.25, 1.0]);
+            }
+        }
+        let render = |evo: f64, extra: &[(&str, Value)]| {
+            let base = [("evolution", num(evo)), ("size", num(10.0)), ("pinning", Value::Enum(8))];
+            run("ec.distort.turbulentdisplace", &[base.as_slice(), extra].concat(), ramp.clone()).img
+        };
+        let evolutions = [0.0, 37.0, 90.5, 180.0, 360.0, 400.25, 725.0, 1000.5];
+        let frames: Vec<Image> = evolutions.iter().map(|&e| render(e, &[])).collect();
+        for (i, a) in frames.iter().enumerate() {
+            for (j, b) in frames.iter().enumerate().skip(i + 1) {
+                let d = max_diff(a, b);
+                assert!(d > 0.01, "evolution {} and {} differ by only {d}", evolutions[i], evolutions[j]);
+            }
+        }
+        // Constant rate: 20 degrees next to a whole revolution (from either side) is a visible
+        // step, not the rounding-error size the eased axis gave (under 0.001).
+        assert!(max_diff(&frames[0], &render(20.0, &[])) > 0.02);
+        assert!(max_diff(&render(340.0, &[]), &frames[4]) > 0.02);
+        // 0 and 360 degrees are different frames without Cycle Evolution, and the same frame with
+        // Cycle (in Revolutions) = 1, at any starting angle.
+        assert!(max_diff(&frames[0], &frames[4]) > 0.01);
+        let cycle = [("evolutionOptions/cycleEvolution", Value::Bool(true)), ("evolutionOptions/cycle", num(1.0))];
+        assert!(max_diff(&render(0.0, &cycle), &render(360.0, &cycle)) < 1e-4);
+        assert!(max_diff(&render(37.0, &cycle), &render(397.0, &cycle)) < 1e-4);
+        assert!(max_diff(&render(0.0, &cycle), &render(37.0, &cycle)) > 0.01);
+        // Random Seed still gives a different pattern at the same Evolution.
+        assert!(max_diff(&frames[1], &render(37.0, &[("evolutionOptions/randomSeed", num(5.0))])) > 0.01);
+    }
+
     #[test]
     fn magnify_blending_none_and_scaling() {
         let img = test_img(32, 32);
diff --git a/crates/effects/src/distort3.rs b/crates/effects/src/distort3.rs
index cb389d901..a02ab5743 100644
--- a/crates/effects/src/distort3.rs
+++ b/crates/effects/src/distort3.rs
@@ -1084,337 +1084,4 @@ pub fn specs() -> Vec<EffectSpec> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{EffectEnv, MaskShape, Params};
-
-    fn img(w: u32, h: u32) -> Image {
-        crate::util::gen_image(w, h, |x, y| [x as f32 / w as f32, y as f32 / h as f32, ((x * 7 + y * 3) % 11) as f32 / 11.0, 1.0])
-    }
-
-    /// Run with Point defaults scaled to the layer (like `instantiate`).
-    fn run(id: &str, set: &[(&str, Value)], im: Image, masks: &[MaskShape]) -> Buf {
-        let s = crate::find(id).unwrap();
-        let ls = [im.width as f64, im.height as f64];
-        let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-        for ps in &s.params {
-            if let (ParamUi::Point, Value::Vec2(v)) = (&ps.ui, &ps.default) {
-                params.values.insert(ps.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
-            }
-        }
-        for (k, v) in set {
-            assert!(params.values.contains_key(*k), "{id}: {k}");
-            params.values.insert(k.to_string(), v.clone());
-        }
-        let env = EffectEnv { masks, ..Default::default() };
-        let ctx = EffectCtx { params: &params, time: 0.5, layer_size: ls, seed: 1, adjustment: false, env };
-        crate::apply(s, &ctx, Buf { img: im, offset: [0.0, 0.0], scale: 1.0 })
-    }
-
-    fn maxd(a: &Image, b: &Image) -> f32 {
-        assert_eq!((a.width, a.height), (b.width, b.height));
-        a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|i| (p[i] - q[i]).abs()).fold(0.0, f32::max)).fold(0.0, f32::max)
-    }
-
-    fn rect_mask(x0: f64, y0: f64, x1: f64, y1: f64) -> MaskShape {
-        MaskShape { name: "m".into(), points: vec![[x0, y0], [x1, y0], [x1, y1], [x0, y1]], closed: true, inverted: false }
-    }
-
-    #[test]
-    fn identity_at_neutral_settings() {
-        let im = img(40, 30);
-        let cases: &[(&str, Vec<(&str, Value)>)] = &[
-            ("ec.distort.ccbender", vec![]),
-            ("ec.distort.ccpowerpin", vec![]),
-            ("ec.distort.ccripplepulse", vec![]),
-            ("ec.distort.ccslant", vec![]),
-            ("ec.distort.ccsmear", vec![("reach", num(0.0))]),
-            ("ec.distort.ccsplit", vec![("split", num(0.0))]),
-            ("ec.distort.ccsplit2", vec![("split1", num(0.0)), ("split2", num(0.0))]),
-            ("ec.distort.smear", vec![]),
-            ("ec.distort.reshape", vec![]),
-            ("ec.distort.twirllegacy", vec![]),
-            ("ec.distort.warp", vec![("warpStyle", Value::Enum(5))]),
-            ("ec.distort.upscale", vec![]),
-        ];
-        for (id, set) in cases {
-            let o = run(id, set, im.clone(), &[]);
-            assert!(maxd(&o.img, &im) < 1e-5, "{id} not identity");
-            assert_eq!(o.offset, [0.0, 0.0], "{id}");
-        }
-        // Power pin with perspective 0 at default corners is also identity.
-        let o = run("ec.distort.ccpowerpin", &[("perspective", num(0.0))], im.clone(), &[]);
-        assert!(maxd(&o.img, &im) < 1e-4);
-    }
-
-    #[test]
-    fn all_deterministic() {
-        let im = img(36, 28);
-        let masks = [rect_mask(8.0, 8.0, 16.0, 16.0), rect_mask(12.0, 10.0, 22.0, 20.0), rect_mask(2.0, 2.0, 34.0, 26.0)];
-        let cases: &[(&str, Vec<(&str, Value)>)] = &[
-            ("ec.distort.ccbender", vec![("amount", num(40.0)), ("style", Value::Enum(3))]),
-            ("ec.distort.ccblobbylize", vec![]),
-            ("ec.distort.ccpowerpin", vec![("topLeft", pt(5.0, 3.0)), ("perspective", num(40.0))]),
-            ("ec.distort.ccripplepulse", vec![("pulseLevel", num(80.0))]),
-            ("ec.distort.ccslant", vec![("slant", num(30.0)), ("stretching", Value::Bool(true))]),
-            ("ec.distort.ccsmear", vec![]),
-            ("ec.distort.ccsplit", vec![]),
-            ("ec.distort.ccsplit2", vec![("split2", num(10.0))]),
-            ("ec.distort.smear", vec![("sourceMask", Value::Enum(1)), ("boundaryMask", Value::Enum(3)), ("maskOffset", pt(4.0, 2.0))]),
-            ("ec.distort.reshape", vec![("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))]),
-            ("ec.distort.twirllegacy", vec![("angle", num(90.0))]),
-            ("ec.distort.warp", vec![("bend", num(50.0)), ("horizontalDistortion", num(20.0))]),
-            ("ec.distort.upscale", vec![("scale", num(200.0))]),
-        ];
-        for (id, set) in cases {
-            let a = run(id, set, im.clone(), &masks);
-            let b = run(id, set, im.clone(), &masks);
-            assert_eq!(a.img, b.img, "{id}");
-            assert!(a.img.data.iter().all(|p| p.iter().all(|v| v.is_finite())), "{id}");
-            assert!(a.img.width != im.width || a.img.height != im.height || maxd(&a.img, &im) > 1e-3, "{id} did nothing");
-        }
-    }
-
-    #[test]
-    fn blobbylize_defaults_match_ae() {
-        let s = crate::find("ec.distort.ccblobbylize").unwrap();
-        let default = |id: &str| s.params.iter().find(|p| p.id == id).unwrap().default.clone();
-        assert_eq!(default("property"), Value::Enum(0), "Property defaults to Red");
-        assert_eq!(default("softness"), num(20.0));
-        assert_eq!(default("cutAway"), num(25.0));
-        assert_eq!(default("lightHeight"), num(65.0));
-        assert_eq!(default("lightPosition"), pt(0.5, 0.5));
-        assert_eq!(default("ambient"), num(75.0));
-        assert_eq!(default("diffuse"), num(25.0));
-        assert_eq!(default("specular"), num(100.0));
-        assert_eq!(default("roughness"), num(0.025));
-        assert_eq!(default("metal"), num(100.0));
-    }
-
-    #[test]
-    fn blobbylize_cut_away_thresholds_a_height_ramp() {
-        // AE oracle: Cut Away is a linear height threshold with a ~1 px antialiased edge.
-        let im = crate::util::gen_image(1920, 8, |x, _| {
-            let h = x as f32 / 1920.0;
-            [h, h, h, 1.0]
-        });
-        let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(0)), ("softness", num(0.0)), ("cutAway", num(25.0))], im, &[]);
-        assert_eq!(o.img.get(400, 4)[3], 0.0, "below Cut Away must be transparent");
-        assert_eq!(o.img.get(560, 4)[3], 1.0, "above Cut Away must be opaque");
-        let edge = o.img.get(480, 4)[3];
-        assert!((0.45..=0.55).contains(&edge), "edge alpha {edge} is not a one-pixel threshold");
-        let partial = (450..510).filter(|&x| (0.001..0.999).contains(&o.img.get(x, 4)[3])).count();
-        assert!(partial <= 2, "{partial} antialiased columns instead of one");
-    }
-
-    #[test]
-    fn blobbylize_cut_away_100_is_empty() {
-        // Regression: the old clamp to 0.99 left the top of the ramp opaque at Cut Away 100.
-        let im = crate::util::gen_image(1920, 8, |x, _| {
-            let h = x as f32 / 1920.0;
-            [h, h, h, 1.0]
-        });
-        let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(0)), ("softness", num(0.0)), ("cutAway", num(100.0))], im, &[]);
-        assert!(o.img.data.iter().all(|p| p[3] == 0.0), "Cut Away 100 left opaque pixels");
-    }
-
-    #[test]
-    fn blobbylize_cut_away_100_clears_an_opaque_edge() {
-        // An opaque source reaches h = 1 on the high side of an edge; the gradient antialias
-        // used to leave m = 0.5 there, so Cut Away 100 still produced visible pixels.
-        let im = crate::util::gen_image(64, 8, |x, _| if x < 32 { [1.0; 4] } else { [0.0; 4] });
-        let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(3)), ("softness", num(0.0)), ("cutAway", num(100.0))], im, &[]);
-        assert!(o.img.data.iter().all(|p| p[3] == 0.0), "Cut Away 100 left an opaque edge");
-    }
-
-    #[test]
-    fn blobbylize_softness_warps_a_step_matte_inward() {
-        // AE oracle T2: a self alpha step at x = 960, Softness 20, Cut Away 0 puts the matte
-        // edge at about x = 946, not at the source edge. The PR's matte-preserving version
-        // left it at 960; the effect must warp the source matte.
-        let im = crate::util::gen_image(1920, 32, |x, _| if x < 960 { [1.0; 4] } else { [0.0; 4] });
-        let o = run(
-            "ec.distort.ccblobbylize",
-            &[
-                ("property", Value::Enum(3)),
-                ("softness", num(20.0)),
-                ("cutAway", num(0.0)),
-                ("ambient", num(100.0)),
-                ("diffuse", num(0.0)),
-                ("specular", num(0.0)),
-                ("metal", num(0.0)),
-            ],
-            im,
-            &[],
-        );
-        assert!(o.img.get(945, 16)[3] > 0.95, "the matte did not move inward: {}", o.img.get(945, 16)[3]);
-        assert!(o.img.get(949, 16)[3] < 0.05, "source alpha leaked past the warped edge");
-        assert_eq!(o.img.get(960, 16)[3], 0.0, "the source matte was preserved instead of warped");
-    }
-
-    /// A text layer's buffer: 20 × 10 opaque pixels at (90, 45)–(110, 55) of its comp-sized
-    /// (200 × 100) layer bounds, after `id` with `set`.
-    fn on_text(id: &str, set: &[(&str, Value)]) -> Buf {
-        let s = crate::find(id).unwrap();
-        let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-        for (k, v) in set {
-            assert!(params.values.contains_key(*k), "{id}: {k}");
-            params.values.insert(k.to_string(), v.clone());
-        }
-        let mut im = Image::new(20, 10);
-        im.data.iter_mut().for_each(|p| *p = [1.0; 4]);
-        let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [200.0, 100.0], seed: 1, adjustment: false, env: Default::default() };
-        crate::apply(s, &ctx, Buf { img: im, offset: [-90.0, -45.0], scale: 1.0 })
-    }
-
-    /// Alpha at layer point `p` (0 outside the buffer).
-    fn alpha_at(b: &Buf, p: [f64; 2]) -> f32 {
-        let (x, y) = b.to_px(p);
-        b.img.get(x.floor() as i64, y.floor() as i64)[3]
-    }
-
-    /// #659: CC Smear and CC Tiler on a text layer reach past the text's box to the layer bounds
-    /// (comp-sized, as in After Effects), not cut off where the glyphs end.
-    #[test]
-    fn effects_on_text_reach_past_its_box() {
-        let smear = on_text("ec.distort.ccsmear", &[("from", pt(100.0, 50.0)), ("to", pt(140.0, 50.0)), ("reach", num(100.0)), ("radius", num(30.0))]);
-        assert!(alpha_at(&smear, [130.0, 50.0]) > 0.9, "the smear is cut off at the text's box");
-        assert!(smear.img.width < 200, "it grows only as far as pixels move");
-        let tiles = on_text("ec.distort.cctiler", &[("scale", num(50.0)), ("center", pt(100.0, 50.0))]);
-        assert!(alpha_at(&tiles, [100.0, 50.0]) > 0.9);
-        assert!(alpha_at(&tiles, [2.0, 50.0]) > 0.9, "tiles fill the layer bounds");
-        assert!(alpha_at(&tiles, [50.0, 50.0]) < 0.1);
-        // A footage layer's buffer is its bounds already: no change.
-        let o = run("ec.distort.ccsmear", &[], img(40, 30), &[]);
-        assert_eq!((o.img.width, o.img.height, o.offset), (40, 30, [0.0, 0.0]));
-    }
-
-    #[test]
-    fn every_warp_style_runs_and_bends() {
-        let im = img(40, 30);
-        for s in 0..WARP_STYLES.len() as u32 {
-            for axis in 0..2 {
-                let o = run("ec.distort.warp", &[("warpStyle", Value::Enum(s)), ("warpAxis", Value::Enum(axis)), ("bend", num(50.0))], im.clone(), &[]);
-                let pad = o.offset[0] as u32;
-                // The layer centre's neighbourhood is still made of source pixels.
-                assert!(o.img.get(pad as i64 + 20, pad as i64 + 15)[3] > 0.5, "style {s}");
-                assert!(o.img.width > im.width);
-            }
-        }
-        // Arc with positive bend raises the middle of the layer: the top edge in the middle
-        // moves up (opaque pixels above the original top).
-        let o = run("ec.distort.warp", &[("warpStyle", Value::Enum(3)), ("bend", num(50.0))], im.clone(), &[]);
-        let pad = o.offset[1] as i64;
-        assert!(o.img.get(o.offset[0] as i64 + 20, pad - 3)[3] > 0.5);
-        assert!(o.img.get(o.offset[0] as i64 + 1, pad - 3)[3] < 0.5);
-    }
-
-    #[test]
-    fn power_pin_moves_corners() {
-        let im = img(20, 20);
-        // Pin to the right half: output x in 10..20 shows the whole layer squeezed.
-        let set = [("topLeft", pt(10.0, 0.0)), ("bottomLeft", pt(10.0, 20.0))];
-        let o = run("ec.distort.ccpowerpin", &set, im.clone(), &[]);
-        assert_eq!(o.img.get(3, 10)[3], 0.0);
-        let px = o.img.get(15, 10);
-        assert!((px[0] - 0.5).abs() < 0.1, "{px:?}");
-    }
-
-    #[test]
-    fn power_pin_unstretch_expands_pinned_region() {
-        let im = crate::util::gen_image(24, 16, |_, _| [1.0, 0.0, 0.0, 1.0]);
-        let inset = [("topLeft", pt(6.0, 4.0)), ("topRight", pt(18.0, 4.0)), ("bottomRight", pt(18.0, 12.0)), ("bottomLeft", pt(6.0, 12.0))];
-        let opaque = |o: &Buf| o.img.data.iter().filter(|p| p[3] > 0.99).count();
-        let off = run("ec.distort.ccpowerpin", &inset, im.clone(), &[]);
-        assert_eq!(opaque(&off), 96);
-        let mut set = inset.to_vec();
-        set.push(("unstretch", Value::Bool(true)));
-        let on = run("ec.distort.ccpowerpin", &set, im.clone(), &[]);
-        assert_eq!(opaque(&on), 24 * 16);
-        assert!(on.img.get(0, 0)[3] > 0.99);
-        // Default corners are the identity either way.
-        let id = run("ec.distort.ccpowerpin", &[("unstretch", Value::Bool(true))], im.clone(), &[]);
-        assert!(maxd(&id.img, &im) < 1e-4);
-    }
-
-    #[test]
-    fn split_opens_a_gap() {
-        let im = img(40, 30);
-        let o = run("ec.distort.ccsplit", &[("split", num(40.0))], im.clone(), &[]);
-        assert_eq!(o.img.get(20, 15)[3], 0.0);
-        assert_eq!(o.img.get(2, 2), im.get(2, 2));
-    }
-
-    #[test]
-    fn slant_shears_from_floor() {
-        let im = img(20, 20);
-        let o = run("ec.distort.ccslant", &[("slant", num(50.0))], im.clone(), &[]);
-        let pad = o.offset[0] as i64;
-        // Bottom row stays put; the top row shifts right by ~10 px.
-        assert!((o.img.get(pad + 5, pad + 19)[0] - im.get(5, 19)[0]).abs() < 0.05);
-        assert!((o.img.get(pad + 15, pad)[0] - im.get(5, 0)[0]).abs() < 0.08);
-    }
-
-    #[test]
-    fn reshape_moves_source_to_destination() {
-        // A bright square at the source mask; reshape to a shifted destination mask.
-        let im = crate::util::gen_image(40, 40, |x, y| if (10..20).contains(&x) && (10..20).contains(&y) { [1.0; 4] } else { [0.0, 0.0, 0.0, 1.0] });
-        let masks = [rect_mask(10.0, 10.0, 20.0, 20.0), rect_mask(16.0, 10.0, 26.0, 20.0), rect_mask(0.0, 0.0, 40.0, 40.0)];
-        let o = run("ec.distort.reshape", &[("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))], im, &masks);
-        assert!(o.img.get(24, 15)[0] > 0.8, "{:?}", o.img.get(24, 15));
-        assert!(o.img.get(11, 15)[0] < 0.3, "{:?}", o.img.get(11, 15));
-    }
-
-    #[test]
-    fn reshape_correspondence_points_steer_the_match() {
-        // Matching outlines with a zero pair change nothing; a quarter-turn offset twists.
-        let im = img(40, 40);
-        let masks = [rect_mask(10.0, 10.0, 30.0, 30.0), rect_mask(10.0, 10.0, 30.0, 30.0), rect_mask(0.0, 0.0, 40.0, 40.0)];
-        let base = [("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))];
-        let same = run("ec.distort.reshape", &[base.as_slice(), &[("correspondencePoints", Value::Str("0,0".into()))]].concat(), im.clone(), &masks);
-        assert!(maxd(&same.img, &im) < 1e-3, "matching outlines: no change");
-        let twisted = run("ec.distort.reshape", &[base.as_slice(), &[("correspondencePoints", Value::Str("0.25,0".into()))]].concat(), im.clone(), &masks);
-        assert!(maxd(&twisted.img, &im) > 0.1);
-        // Fraction mapping.
-        assert!((map_fraction(&[(0.0, 0.0), (0.5, 0.25)], 0.125, true) - 0.25).abs() < 1e-9);
-        assert!((map_fraction(&[(0.2, 0.0)], 0.9, true) - 0.1).abs() < 1e-9);
-        assert!((map_fraction(&[(0.5, 0.5)], 0.25, false) - 0.25).abs() < 1e-9);
-    }
-
-    #[test]
-    fn upscale_grows_about_centre() {
-        let im = img(20, 10);
-        let o = run("ec.distort.upscale", &[("scale", num(200.0)), ("detail", num(0.0))], im.clone(), &[]);
-        assert_eq!((o.img.width, o.img.height), (40, 20));
-        // Grown about the layer centre: layer point (0,0) now sits at buffer pixel (10,5), so the
-        // centre (10,5) lands in the middle of the 40×20 buffer.
-        assert_eq!(o.offset, [10.0, 5.0]);
-        let c = o.img.sample_bilinear(20.0, 10.0);
-        assert!((c[0] - im.sample_bilinear(10.0, 5.0)[0]).abs() < 0.03);
-    }
-
-    #[test]
-    fn twirl_legacy_rotates_inside_radius() {
-        let im = img(40, 40);
-        let o = run("ec.distort.twirllegacy", &[("angle", num(180.0)), ("radius", num(100.0))], im.clone(), &[]);
-        assert!(maxd(&o.img, &im) > 0.1);
-        // Corners lie outside the radius.
-        assert_eq!(o.img.get(0, 0), im.get(0, 0));
-    }
-
-    #[test]
-    fn half_resolution_matches_scaled_geometry() {
-        // Bender at scale 0.5: the buffer is half size, parameters in layer pixels.
-        let s = crate::find("ec.distort.ccbender").unwrap();
-        let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-        params.values.insert("amount".into(), num(30.0));
-        params.values.insert("top".into(), pt(20.0, 0.0));
-        params.values.insert("base".into(), pt(20.0, 40.0));
-        let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [40.0, 40.0], seed: 1, adjustment: false, env: Default::default() };
-        let full = crate::apply(s, &ctx, Buf { img: img(40, 40), offset: [0.0; 2], scale: 1.0 });
-        let half = crate::apply(s, &ctx, Buf { img: effectcraft_raster::resample(&img(40, 40), 20, 20), offset: [0.0; 2], scale: 0.5 });
-        let a = full.img.sample_bilinear(20.0, 4.0)[3];
-        let b = half.img.sample_bilinear(10.0, 2.0)[3];
-        assert!((a - b).abs() < 0.3);
-    }
-}
+mod tests;
diff --git a/crates/effects/src/distort3/tests.rs b/crates/effects/src/distort3/tests.rs
new file mode 100644
index 000000000..b50d6b450
--- /dev/null
+++ b/crates/effects/src/distort3/tests.rs
@@ -0,0 +1,332 @@
+use super::*;
+use crate::{EffectEnv, MaskShape, Params};
+
+fn img(w: u32, h: u32) -> Image {
+    crate::util::gen_image(w, h, |x, y| [x as f32 / w as f32, y as f32 / h as f32, ((x * 7 + y * 3) % 11) as f32 / 11.0, 1.0])
+}
+
+/// Run with Point defaults scaled to the layer (like `instantiate`).
+fn run(id: &str, set: &[(&str, Value)], im: Image, masks: &[MaskShape]) -> Buf {
+    let s = crate::find(id).unwrap();
+    let ls = [im.width as f64, im.height as f64];
+    let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+    for ps in &s.params {
+        if let (ParamUi::Point, Value::Vec2(v)) = (&ps.ui, &ps.default) {
+            params.values.insert(ps.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
+        }
+    }
+    for (k, v) in set {
+        assert!(params.values.contains_key(*k), "{id}: {k}");
+        params.values.insert(k.to_string(), v.clone());
+    }
+    let env = EffectEnv { masks, ..Default::default() };
+    let ctx = EffectCtx { params: &params, time: 0.5, layer_size: ls, seed: 1, adjustment: false, env };
+    crate::apply(s, &ctx, Buf { img: im, offset: [0.0, 0.0], scale: 1.0 })
+}
+
+fn maxd(a: &Image, b: &Image) -> f32 {
+    assert_eq!((a.width, a.height), (b.width, b.height));
+    a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|i| (p[i] - q[i]).abs()).fold(0.0, f32::max)).fold(0.0, f32::max)
+}
+
+fn rect_mask(x0: f64, y0: f64, x1: f64, y1: f64) -> MaskShape {
+    MaskShape { name: "m".into(), points: vec![[x0, y0], [x1, y0], [x1, y1], [x0, y1]], closed: true, inverted: false }
+}
+
+#[test]
+fn identity_at_neutral_settings() {
+    let im = img(40, 30);
+    let cases: &[(&str, Vec<(&str, Value)>)] = &[
+        ("ec.distort.ccbender", vec![]),
+        ("ec.distort.ccpowerpin", vec![]),
+        ("ec.distort.ccripplepulse", vec![]),
+        ("ec.distort.ccslant", vec![]),
+        ("ec.distort.ccsmear", vec![("reach", num(0.0))]),
+        ("ec.distort.ccsplit", vec![("split", num(0.0))]),
+        ("ec.distort.ccsplit2", vec![("split1", num(0.0)), ("split2", num(0.0))]),
+        ("ec.distort.smear", vec![]),
+        ("ec.distort.reshape", vec![]),
+        ("ec.distort.twirllegacy", vec![]),
+        ("ec.distort.warp", vec![("warpStyle", Value::Enum(5))]),
+        ("ec.distort.upscale", vec![]),
+    ];
+    for (id, set) in cases {
+        let o = run(id, set, im.clone(), &[]);
+        assert!(maxd(&o.img, &im) < 1e-5, "{id} not identity");
+        assert_eq!(o.offset, [0.0, 0.0], "{id}");
+    }
+    // Power pin with perspective 0 at default corners is also identity.
+    let o = run("ec.distort.ccpowerpin", &[("perspective", num(0.0))], im.clone(), &[]);
+    assert!(maxd(&o.img, &im) < 1e-4);
+}
+
+#[test]
+fn all_deterministic() {
+    let im = img(36, 28);
+    let masks = [rect_mask(8.0, 8.0, 16.0, 16.0), rect_mask(12.0, 10.0, 22.0, 20.0), rect_mask(2.0, 2.0, 34.0, 26.0)];
+    let cases: &[(&str, Vec<(&str, Value)>)] = &[
+        ("ec.distort.ccbender", vec![("amount", num(40.0)), ("style", Value::Enum(3))]),
+        ("ec.distort.ccblobbylize", vec![]),
+        ("ec.distort.ccpowerpin", vec![("topLeft", pt(5.0, 3.0)), ("perspective", num(40.0))]),
+        ("ec.distort.ccripplepulse", vec![("pulseLevel", num(80.0))]),
+        ("ec.distort.ccslant", vec![("slant", num(30.0)), ("stretching", Value::Bool(true))]),
+        ("ec.distort.ccsmear", vec![]),
+        ("ec.distort.ccsplit", vec![]),
+        ("ec.distort.ccsplit2", vec![("split2", num(10.0))]),
+        ("ec.distort.smear", vec![("sourceMask", Value::Enum(1)), ("boundaryMask", Value::Enum(3)), ("maskOffset", pt(4.0, 2.0))]),
+        ("ec.distort.reshape", vec![("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))]),
+        ("ec.distort.twirllegacy", vec![("angle", num(90.0))]),
+        ("ec.distort.warp", vec![("bend", num(50.0)), ("horizontalDistortion", num(20.0))]),
+        ("ec.distort.upscale", vec![("scale", num(200.0))]),
+    ];
+    for (id, set) in cases {
+        let a = run(id, set, im.clone(), &masks);
+        let b = run(id, set, im.clone(), &masks);
+        assert_eq!(a.img, b.img, "{id}");
+        assert!(a.img.data.iter().all(|p| p.iter().all(|v| v.is_finite())), "{id}");
+        assert!(a.img.width != im.width || a.img.height != im.height || maxd(&a.img, &im) > 1e-3, "{id} did nothing");
+    }
+}
+
+#[test]
+fn blobbylize_defaults_match_ae() {
+    let s = crate::find("ec.distort.ccblobbylize").unwrap();
+    let default = |id: &str| s.params.iter().find(|p| p.id == id).unwrap().default.clone();
+    assert_eq!(default("property"), Value::Enum(0), "Property defaults to Red");
+    assert_eq!(default("softness"), num(20.0));
+    assert_eq!(default("cutAway"), num(25.0));
+    assert_eq!(default("lightHeight"), num(65.0));
+    assert_eq!(default("lightPosition"), pt(0.5, 0.5));
+    assert_eq!(default("ambient"), num(75.0));
+    assert_eq!(default("diffuse"), num(25.0));
+    assert_eq!(default("specular"), num(100.0));
+    assert_eq!(default("roughness"), num(0.025));
+    assert_eq!(default("metal"), num(100.0));
+}
+
+#[test]
+fn blobbylize_cut_away_thresholds_a_height_ramp() {
+    // AE oracle: Cut Away is a linear height threshold with a ~1 px antialiased edge.
+    let im = crate::util::gen_image(1920, 8, |x, _| {
+        let h = x as f32 / 1920.0;
+        [h, h, h, 1.0]
+    });
+    let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(0)), ("softness", num(0.0)), ("cutAway", num(25.0))], im, &[]);
+    assert_eq!(o.img.get(400, 4)[3], 0.0, "below Cut Away must be transparent");
+    assert_eq!(o.img.get(560, 4)[3], 1.0, "above Cut Away must be opaque");
+    let edge = o.img.get(480, 4)[3];
+    assert!((0.45..=0.55).contains(&edge), "edge alpha {edge} is not a one-pixel threshold");
+    let partial = (450..510).filter(|&x| (0.001..0.999).contains(&o.img.get(x, 4)[3])).count();
+    assert!(partial <= 2, "{partial} antialiased columns instead of one");
+}
+
+#[test]
+fn blobbylize_cut_away_100_is_empty() {
+    // Regression: the old clamp to 0.99 left the top of the ramp opaque at Cut Away 100.
+    let im = crate::util::gen_image(1920, 8, |x, _| {
+        let h = x as f32 / 1920.0;
+        [h, h, h, 1.0]
+    });
+    let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(0)), ("softness", num(0.0)), ("cutAway", num(100.0))], im, &[]);
+    assert!(o.img.data.iter().all(|p| p[3] == 0.0), "Cut Away 100 left opaque pixels");
+}
+
+#[test]
+fn blobbylize_cut_away_100_clears_an_opaque_edge() {
+    // An opaque source reaches h = 1 on the high side of an edge; the gradient antialias
+    // used to leave m = 0.5 there, so Cut Away 100 still produced visible pixels.
+    let im = crate::util::gen_image(64, 8, |x, _| if x < 32 { [1.0; 4] } else { [0.0; 4] });
+    let o = run("ec.distort.ccblobbylize", &[("property", Value::Enum(3)), ("softness", num(0.0)), ("cutAway", num(100.0))], im, &[]);
+    assert!(o.img.data.iter().all(|p| p[3] == 0.0), "Cut Away 100 left an opaque edge");
+}
+
+#[test]
+fn blobbylize_softness_warps_a_step_matte_inward() {
+    // AE oracle T2: a self alpha step at x = 960, Softness 20, Cut Away 0 puts the matte
+    // edge at about x = 946, not at the source edge. The PR's matte-preserving version
+    // left it at 960; the effect must warp the source matte.
+    let im = crate::util::gen_image(1920, 32, |x, _| if x < 960 { [1.0; 4] } else { [0.0; 4] });
+    let o = run(
+        "ec.distort.ccblobbylize",
+        &[
+            ("property", Value::Enum(3)),
+            ("softness", num(20.0)),
+            ("cutAway", num(0.0)),
+            ("ambient", num(100.0)),
+            ("diffuse", num(0.0)),
+            ("specular", num(0.0)),
+            ("metal", num(0.0)),
+        ],
+        im,
+        &[],
+    );
+    assert!(o.img.get(945, 16)[3] > 0.95, "the matte did not move inward: {}", o.img.get(945, 16)[3]);
+    assert!(o.img.get(949, 16)[3] < 0.05, "source alpha leaked past the warped edge");
+    assert_eq!(o.img.get(960, 16)[3], 0.0, "the source matte was preserved instead of warped");
+}
+
+/// A text layer's buffer: 20 × 10 opaque pixels at (90, 45)–(110, 55) of its comp-sized
+/// (200 × 100) layer bounds, after `id` with `set`.
+fn on_text(id: &str, set: &[(&str, Value)]) -> Buf {
+    let s = crate::find(id).unwrap();
+    let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+    for (k, v) in set {
+        assert!(params.values.contains_key(*k), "{id}: {k}");
+        params.values.insert(k.to_string(), v.clone());
+    }
+    let mut im = Image::new(20, 10);
+    im.data.iter_mut().for_each(|p| *p = [1.0; 4]);
+    let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [200.0, 100.0], seed: 1, adjustment: false, env: Default::default() };
+    crate::apply(s, &ctx, Buf { img: im, offset: [-90.0, -45.0], scale: 1.0 })
+}
+
+/// Alpha at layer point `p` (0 outside the buffer).
+fn alpha_at(b: &Buf, p: [f64; 2]) -> f32 {
+    let (x, y) = b.to_px(p);
+    b.img.get(x.floor() as i64, y.floor() as i64)[3]
+}
+
+/// #659: CC Smear and CC Tiler on a text layer reach past the text's box to the layer bounds
+/// (comp-sized, as in After Effects), not cut off where the glyphs end.
+#[test]
+fn effects_on_text_reach_past_its_box() {
+    let smear = on_text("ec.distort.ccsmear", &[("from", pt(100.0, 50.0)), ("to", pt(140.0, 50.0)), ("reach", num(100.0)), ("radius", num(30.0))]);
+    assert!(alpha_at(&smear, [130.0, 50.0]) > 0.9, "the smear is cut off at the text's box");
+    assert!(smear.img.width < 200, "it grows only as far as pixels move");
+    let tiles = on_text("ec.distort.cctiler", &[("scale", num(50.0)), ("center", pt(100.0, 50.0))]);
+    assert!(alpha_at(&tiles, [100.0, 50.0]) > 0.9);
+    assert!(alpha_at(&tiles, [2.0, 50.0]) > 0.9, "tiles fill the layer bounds");
+    assert!(alpha_at(&tiles, [50.0, 50.0]) < 0.1);
+    // A footage layer's buffer is its bounds already: no change.
+    let o = run("ec.distort.ccsmear", &[], img(40, 30), &[]);
+    assert_eq!((o.img.width, o.img.height, o.offset), (40, 30, [0.0, 0.0]));
+}
+
+#[test]
+fn every_warp_style_runs_and_bends() {
+    let im = img(40, 30);
+    for s in 0..WARP_STYLES.len() as u32 {
+        for axis in 0..2 {
+            let o = run("ec.distort.warp", &[("warpStyle", Value::Enum(s)), ("warpAxis", Value::Enum(axis)), ("bend", num(50.0))], im.clone(), &[]);
+            let pad = o.offset[0] as u32;
+            // The layer centre's neighbourhood is still made of source pixels.
+            assert!(o.img.get(pad as i64 + 20, pad as i64 + 15)[3] > 0.5, "style {s}");
+            assert!(o.img.width > im.width);
+        }
+    }
+    // Arc with positive bend raises the middle of the layer: the top edge in the middle
+    // moves up (opaque pixels above the original top).
+    let o = run("ec.distort.warp", &[("warpStyle", Value::Enum(3)), ("bend", num(50.0))], im.clone(), &[]);
+    let pad = o.offset[1] as i64;
+    assert!(o.img.get(o.offset[0] as i64 + 20, pad - 3)[3] > 0.5);
+    assert!(o.img.get(o.offset[0] as i64 + 1, pad - 3)[3] < 0.5);
+}
+
+#[test]
+fn power_pin_moves_corners() {
+    let im = img(20, 20);
+    // Pin to the right half: output x in 10..20 shows the whole layer squeezed.
+    let set = [("topLeft", pt(10.0, 0.0)), ("bottomLeft", pt(10.0, 20.0))];
+    let o = run("ec.distort.ccpowerpin", &set, im.clone(), &[]);
+    assert_eq!(o.img.get(3, 10)[3], 0.0);
+    let px = o.img.get(15, 10);
+    assert!((px[0] - 0.5).abs() < 0.1, "{px:?}");
+}
+
+#[test]
+fn power_pin_unstretch_expands_pinned_region() {
+    let im = crate::util::gen_image(24, 16, |_, _| [1.0, 0.0, 0.0, 1.0]);
+    let inset = [("topLeft", pt(6.0, 4.0)), ("topRight", pt(18.0, 4.0)), ("bottomRight", pt(18.0, 12.0)), ("bottomLeft", pt(6.0, 12.0))];
+    let opaque = |o: &Buf| o.img.data.iter().filter(|p| p[3] > 0.99).count();
+    let off = run("ec.distort.ccpowerpin", &inset, im.clone(), &[]);
+    assert_eq!(opaque(&off), 96);
+    let mut set = inset.to_vec();
+    set.push(("unstretch", Value::Bool(true)));
+    let on = run("ec.distort.ccpowerpin", &set, im.clone(), &[]);
+    assert_eq!(opaque(&on), 24 * 16);
+    assert!(on.img.get(0, 0)[3] > 0.99);
+    // Default corners are the identity either way.
+    let id = run("ec.distort.ccpowerpin", &[("unstretch", Value::Bool(true))], im.clone(), &[]);
+    assert!(maxd(&id.img, &im) < 1e-4);
+}
+
+#[test]
+fn split_opens_a_gap() {
+    let im = img(40, 30);
+    let o = run("ec.distort.ccsplit", &[("split", num(40.0))], im.clone(), &[]);
+    assert_eq!(o.img.get(20, 15)[3], 0.0);
+    assert_eq!(o.img.get(2, 2), im.get(2, 2));
+}
+
+#[test]
+fn slant_shears_from_floor() {
+    let im = img(20, 20);
+    let o = run("ec.distort.ccslant", &[("slant", num(50.0))], im.clone(), &[]);
+    let pad = o.offset[0] as i64;
+    // Bottom row stays put; the top row shifts right by ~10 px.
+    assert!((o.img.get(pad + 5, pad + 19)[0] - im.get(5, 19)[0]).abs() < 0.05);
+    assert!((o.img.get(pad + 15, pad)[0] - im.get(5, 0)[0]).abs() < 0.08);
+}
+
+#[test]
+fn reshape_moves_source_to_destination() {
+    // A bright square at the source mask; reshape to a shifted destination mask.
+    let im = crate::util::gen_image(40, 40, |x, y| if (10..20).contains(&x) && (10..20).contains(&y) { [1.0; 4] } else { [0.0, 0.0, 0.0, 1.0] });
+    let masks = [rect_mask(10.0, 10.0, 20.0, 20.0), rect_mask(16.0, 10.0, 26.0, 20.0), rect_mask(0.0, 0.0, 40.0, 40.0)];
+    let o = run("ec.distort.reshape", &[("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))], im, &masks);
+    assert!(o.img.get(24, 15)[0] > 0.8, "{:?}", o.img.get(24, 15));
+    assert!(o.img.get(11, 15)[0] < 0.3, "{:?}", o.img.get(11, 15));
+}
+
+#[test]
+fn reshape_correspondence_points_steer_the_match() {
+    // Matching outlines with a zero pair change nothing; a quarter-turn offset twists.
+    let im = img(40, 40);
+    let masks = [rect_mask(10.0, 10.0, 30.0, 30.0), rect_mask(10.0, 10.0, 30.0, 30.0), rect_mask(0.0, 0.0, 40.0, 40.0)];
+    let base = [("sourceMask", Value::Enum(1)), ("destinationMask", Value::Enum(2)), ("boundaryMask", Value::Enum(3))];
+    let same = run("ec.distort.reshape", &[base.as_slice(), &[("correspondencePoints", Value::Str("0,0".into()))]].concat(), im.clone(), &masks);
+    assert!(maxd(&same.img, &im) < 1e-3, "matching outlines: no change");
+    let twisted = run("ec.distort.reshape", &[base.as_slice(), &[("correspondencePoints", Value::Str("0.25,0".into()))]].concat(), im.clone(), &masks);
+    assert!(maxd(&twisted.img, &im) > 0.1);
+    // Fraction mapping.
+    assert!((map_fraction(&[(0.0, 0.0), (0.5, 0.25)], 0.125, true) - 0.25).abs() < 1e-9);
+    assert!((map_fraction(&[(0.2, 0.0)], 0.9, true) - 0.1).abs() < 1e-9);
+    assert!((map_fraction(&[(0.5, 0.5)], 0.25, false) - 0.25).abs() < 1e-9);
+}
+
+#[test]
+fn upscale_grows_about_centre() {
+    let im = img(20, 10);
+    let o = run("ec.distort.upscale", &[("scale", num(200.0)), ("detail", num(0.0))], im.clone(), &[]);
+    assert_eq!((o.img.width, o.img.height), (40, 20));
+    // Grown about the layer centre: layer point (0,0) now sits at buffer pixel (10,5), so the
+    // centre (10,5) lands in the middle of the 40×20 buffer.
+    assert_eq!(o.offset, [10.0, 5.0]);
+    let c = o.img.sample_bilinear(20.0, 10.0);
+    assert!((c[0] - im.sample_bilinear(10.0, 5.0)[0]).abs() < 0.03);
+}
+
+#[test]
+fn twirl_legacy_rotates_inside_radius() {
+    let im = img(40, 40);
+    let o = run("ec.distort.twirllegacy", &[("angle", num(180.0)), ("radius", num(100.0))], im.clone(), &[]);
+    assert!(maxd(&o.img, &im) > 0.1);
+    // Corners lie outside the radius.
+    assert_eq!(o.img.get(0, 0), im.get(0, 0));
+}
+
+#[test]
+fn half_resolution_matches_scaled_geometry() {
+    // Bender at scale 0.5: the buffer is half size, parameters in layer pixels.
+    let s = crate::find("ec.distort.ccbender").unwrap();
+    let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+    params.values.insert("amount".into(), num(30.0));
+    params.values.insert("top".into(), pt(20.0, 0.0));
+    params.values.insert("base".into(), pt(20.0, 40.0));
+    let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [40.0, 40.0], seed: 1, adjustment: false, env: Default::default() };
+    let full = crate::apply(s, &ctx, Buf { img: img(40, 40), offset: [0.0; 2], scale: 1.0 });
+    let half = crate::apply(s, &ctx, Buf { img: effectcraft_raster::resample(&img(40, 40), 20, 20), offset: [0.0; 2], scale: 0.5 });
+    let a = full.img.sample_bilinear(20.0, 4.0)[3];
+    let b = half.img.sample_bilinear(10.0, 2.0)[3];
+    assert!((a - b).abs() < 0.3);
+}
diff --git a/crates/effects/src/generate.rs b/crates/effects/src/generate.rs
index 637cc428e..ae0d61861 100644
--- a/crates/effects/src/generate.rs
+++ b/crates/effects/src/generate.rs
@@ -292,10 +292,22 @@ pub(crate) fn fade(t: f32) -> f32 {
     t * t * t * (t * (t * 6.0 - 15.0) + 10.0)
 }
 
-/// 3D value noise in 0..1 (z = evolution).
+/// 3D value noise in 0..1 (z = evolution). The quintic fade applies on all three axes, so z
+/// eases in and out of every integer.
 pub fn value_noise(x: f32, y: f32, z: f32, seed: u32) -> f32 {
+    value_noise_z(x, y, z, seed, true)
+}
+
+/// [`value_noise`] with the evolution axis z interpolated linearly (x and y keep the quintic
+/// fade). The fade's zero slope at every integer z made a small Evolution change almost invisible
+/// next to a whole revolution (#943, #1816); linear z moves the pattern at a constant rate.
+pub fn value_noise_linear_z(x: f32, y: f32, z: f32, seed: u32) -> f32 {
+    value_noise_z(x, y, z, seed, false)
+}
+
+fn value_noise_z(x: f32, y: f32, z: f32, seed: u32, ease_z: bool) -> f32 {
     let (x0, y0, z0) = (x.floor(), y.floor(), z.floor());
-    let (fx, fy, fz) = (fade(x - x0), fade(y - y0), fade(z - z0));
+    let (fx, fy, fz) = (fade(x - x0), fade(y - y0), if ease_z { fade(z - z0) } else { z - z0 });
     let (ix, iy, iz) = (x0 as i32, y0 as i32, z0 as i32);
     let l = |a: f32, b: f32, t: f32| a + (b - a) * t;
     let c = |dx: i32, dy: i32, dz: i32| lattice(ix + dx, iy + dy, iz + dz, seed);
@@ -414,6 +426,27 @@ mod generator_tests {
         Image::filled(32, 32, [1.0, 0.0, 0.0, 1.0])
     }
 
+    /// #943: the evolution axis is linear, so z moves the noise at a constant rate, while the
+    /// classic `value_noise` keeps its eased z (other effects and their pinned goldens use it).
+    #[test]
+    fn linear_z_value_noise_moves_at_a_constant_rate() {
+        for (x, y, seed) in [(0.3f32, 0.7f32, 5u32), (2.4, -1.6, 11), (-3.1, 4.9, 0)] {
+            let a = value_noise_linear_z(x, y, 0.0, seed);
+            let b = value_noise_linear_z(x, y, 1.0, seed);
+            for z in [0.1f32, 0.25, 0.5, 0.75, 0.9] {
+                let want = a + (b - a) * z;
+                let got = value_noise_linear_z(x, y, z, seed);
+                assert!((got - want).abs() < 1e-5, "({x}, {y}) z {z}: {got} vs {want}");
+            }
+            // Same lattice values at whole z, and x / y are untouched.
+            assert_eq!(value_noise_linear_z(x, y, 2.0, seed), value_noise(x, y, 2.0, seed));
+        }
+        // The eased version still has the old shape: at z = 0.25 it lags the linear one.
+        let (a, b) = (value_noise(0.3, 0.7, 0.0, 5), value_noise(0.3, 0.7, 1.0, 5));
+        let eased = value_noise(0.3, 0.7, 0.25, 5);
+        assert!((eased - (a + (b - a) * 0.25)).abs() > 1e-3);
+    }
+
     #[test]
     fn gradient_ramp_stays_inside_the_layer_alpha() {
         // #1063: a shape's transparent pixels stay transparent; the ramp fills only the shape.
diff --git a/crates/effects/src/generate2.rs b/crates/effects/src/generate2.rs
index 80d32ce0e..b4781b793 100644
--- a/crates/effects/src/generate2.rs
+++ b/crates/effects/src/generate2.rs
@@ -61,7 +61,7 @@ const CELL_PATTERNS: [&str; 12] = [
     "Tubular",
 ];
 
-/// Shaping used for Cell Pattern option `i` (see [`cell_value`]).
+/// Shaping used for Cell Pattern option `i` (see `cell_value`).
 pub fn pattern_kind(i: u32) -> u32 {
     match i {
         0..=5 => i,
@@ -692,18 +692,33 @@ impl BoltCfg<'_> {
     }
 }
 
-/// Grow a bolt from `a` to `z` by midpoint displacement (`depth` levels), forking at random.
-/// Segments go to `out` with their intensity; `mains` marks the main core's segments.
-#[allow(clippy::too_many_arguments)]
-fn bolt(cfg: &BoltCfg, a: (f64, f64), z: (f64, f64), depth: u32, inten: f32, main: bool, rng: &mut Rng, out: &mut Vec<Seg>, mains: &mut Vec<bool>) {
-    if out.len() > 20_000 {
+/// One branch's geometry and recursive growth state.
+struct BoltBranch {
+    start: (f64, f64),
+    end: (f64, f64),
+    depth: u32,
+    intensity: f32,
+    main: bool,
+}
+
+/// Segments and their matching main-core flags, kept in the same traversal order.
+#[derive(Default)]
+struct BoltOutput {
+    segments: Vec<Seg>,
+    mains: Vec<bool>,
+}
+
+/// Grow a branch by midpoint displacement, recursively appending its segments and forks.
+fn bolt(cfg: &BoltCfg, branch: BoltBranch, rng: &mut Rng, output: &mut BoltOutput) {
+    let BoltBranch { start: a, end: z, depth, intensity: inten, main } = branch;
+    if output.segments.len() > 20_000 {
         return;
     }
     let (dx, dy) = (z.0 - a.0, z.1 - a.1);
     let len = (dx * dx + dy * dy).sqrt();
     if depth == 0 || len < 1.0 {
-        out.push((a, z, inten));
-        mains.push(main);
+        output.segments.push((a, z, inten));
+        output.mains.push(main);
         return;
     }
     let (nx, ny) = (-dy / len.max(1e-9), dx / len.max(1e-9));
@@ -725,8 +740,8 @@ fn bolt(cfg: &BoltCfg, a: (f64, f64), z: (f64, f64), depth: u32, inten: f32, mai
     if cfg.obstacle > 0.0 && !main && cfg.alpha_at(m) > 0.5 && rng.f() < cfg.obstacle / 10.0 {
         return;
     }
-    bolt(cfg, a, m, depth - 1, inten, main, rng, out, mains);
-    bolt(cfg, m, z, depth - 1, inten, main, rng, out, mains);
+    bolt(cfg, BoltBranch { start: a, end: m, depth: depth - 1, intensity: inten, main }, rng, output);
+    bolt(cfg, BoltBranch { start: m, end: z, depth: depth - 1, intensity: inten, main }, rng, output);
     if rng.f() < cfg.fork && inten > cfg.term && len >= cfg.min_fork {
         let ang = rng.s() * 0.7;
         let (s, c) = ang.sin_cos();
@@ -734,7 +749,7 @@ fn bolt(cfg: &BoltCfg, a: (f64, f64), z: (f64, f64), depth: u32, inten: f32, mai
         let k = 1.2;
         // Fork Strength 50 % keeps the decayed intensity; Fork Variation randomises it.
         let fi = inten * (1.0 - cfg.decay) * cfg.fork_strength * 2.0 * if cfg.fork_var > 0.0 { 1.0 - cfg.fork_var * rng.f() as f32 } else { 1.0 };
-        bolt(cfg, m, (m.0 + fx * k, m.1 + fy * k), depth.saturating_sub(1), fi.min(1.0), false, rng, out, mains);
+        bolt(cfg, BoltBranch { start: m, end: (m.0 + fx * k, m.1 + fy * k), depth: depth.saturating_sub(1), intensity: fi.min(1.0), main: false }, rng, output);
     }
 }
 
@@ -772,10 +787,9 @@ pub fn lightning_segments(ctx: &EffectCtx, b: &Buf) -> Vec<Seg> {
         fork_strength: (g("expertSettings/forkStrength", 50.0) / 100.0).clamp(0.0, 1.0) as f32,
         fork_var: (g("expertSettings/forkVariation", 0.0) / 100.0).clamp(0.0, 1.0) as f32,
     };
-    let mut segs = Vec::new();
-    let mut mains = Vec::new();
+    let mut output = BoltOutput::default();
     let (h, w) = (b.img.height as f64, b.img.width as f64);
-    let mut go = |a, z, depth, cfg: &BoltCfg, rng: &mut Rng| bolt(cfg, a, z, depth, 1.0, true, rng, &mut segs, &mut mains);
+    let mut go = |a, z, depth, cfg: &BoltCfg, rng: &mut Rng| bolt(cfg, BoltBranch { start: a, end: z, depth, intensity: 1.0, main: true }, rng, &mut output);
     // LIGHTNING_TYPES order.
     match kind {
         // Direction: travels toward the Direction point and beyond.
@@ -811,6 +825,7 @@ pub fn lightning_segments(ctx: &EffectCtx, b: &Buf) -> Vec<Seg> {
         // Strike.
         _ => go(o, d, depth, &cfg, &mut rng),
     }
+    let BoltOutput { segments: mut segs, mains } = output;
     let dist = |p: (f64, f64)| ((p.0 - o.0).powi(2) + (p.1 - o.1).powi(2)).sqrt();
     let far = segs.iter().map(|(_, z, _)| dist(*z)).fold(1e-9, f64::max);
     // Decay Main Core: the whole bolt fades with distance from the origin.
@@ -1223,315 +1238,4 @@ pub fn specs() -> Vec<EffectSpec> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::Params;
-    use effectcraft_raster::Image;
-
-    fn run(id: &str, set: &[(&str, Value)], img: Image) -> Buf {
-        let s = crate::find(id).unwrap();
-        let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-        let ls = [img.width as f64, img.height as f64];
-        for p in &s.params {
-            if let (ParamUi::Point, Value::Vec2(v)) = (&p.ui, &p.default) {
-                params.values.insert(p.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
-            }
-        }
-        for (k, v) in set {
-            params.values.insert(k.to_string(), v.clone());
-        }
-        let ctx = EffectCtx { params: &params, time: 0.5, layer_size: ls, seed: 3, adjustment: false, env: Default::default() };
-        crate::apply(s, &ctx, Buf { img, offset: [0.0, 0.0], scale: 1.0 })
-    }
-
-    #[test]
-    fn cell_pattern_is_deterministic_and_seeded() {
-        let a = run("ec.generate.cellpattern", &[("size", num(10.0))], Image::new(40, 30));
-        let b2 = run("ec.generate.cellpattern", &[("size", num(10.0))], Image::new(40, 30));
-        assert_eq!(a.img, b2.img);
-        let c = run("ec.generate.cellpattern", &[("size", num(10.0)), ("evolutionOptions/randomSeed", num(5.0))], Image::new(40, 30));
-        assert_ne!(a.img, c.img);
-        assert!(a.img.data.iter().all(|p| p[3] == 1.0 && (0.0..=1.0).contains(&p[0])));
-    }
-
-    #[test]
-    fn ellipse_ring_coverage() {
-        let o = run("ec.generate.ellipse", &[("width", num(40.0)), ("height", num(40.0)), ("thickness", num(6.0))], Image::new(64, 64));
-        // Ring passes through (32 + 20, 32); centre is empty.
-        assert!(o.img.get(51, 32)[3] > 0.9, "{:?}", o.img.get(51, 32));
-        assert!(o.img.get(32, 32)[3] < 1e-3);
-        assert!(o.img.get(2, 2)[3] < 1e-3);
-    }
-
-    #[test]
-    fn lightning_is_deterministic_per_conductivity() {
-        let a = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
-        let b2 = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
-        assert_eq!(a.img, b2.img);
-        assert!(a.img.data.iter().any(|p| p[3] > 0.5));
-        let c = run("ec.generate.advancedlightning", &[("conductivityState", num(11.0))], Image::new(64, 48));
-        assert_ne!(a.img, c.img);
-    }
-
-    #[test]
-    fn beam_draws_between_points() {
-        let o = run("ec.generate.beam", &[("length", num(100.0)), ("softness", num(0.0))], Image::new(64, 32));
-        assert!(o.img.get(32, 16)[3] > 0.99);
-        assert!(o.img.get(32, 2)[3] < 1e-3);
-        assert!(o.img.get(2, 16)[3] < 1e-3);
-    }
-
-    #[test]
-    fn cell_pattern_tiles() {
-        // 4×4-cell tiles of 8 px: the pattern repeats every 32 px.
-        let set = [
-            ("size", num(8.0)),
-            ("tilingOptions/enableTiling", Value::Bool(true)),
-            ("tilingOptions/cellsHorizontal", num(4.0)),
-            ("tilingOptions/cellsVertical", num(4.0)),
-        ];
-        let o = run("ec.generate.cellpattern", &set, Image::new(64, 64));
-        for (x, y) in [(3, 5), (10, 20), (17, 2)] {
-            let (a, b2) = (o.img.get(x, y), o.img.get(x + 32, y + 32));
-            assert!((a[0] - b2[0]).abs() < 1e-4, "{x},{y}: {a:?} vs {b2:?}");
-        }
-    }
-
-    #[test]
-    fn radio_waves_expansion_velocity_and_star() {
-        let r = |set: &[(&str, Value)], t: f64| {
-            let s = crate::find("ec.generate.radiowaves").unwrap();
-            let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-            params.values.insert("producerPoint".into(), Value::Vec2([32.0, 32.0]));
-            for (k, v) in set {
-                params.values.insert(k.to_string(), v.clone());
-            }
-            let ctx = EffectCtx { params: &params, time: t, layer_size: [64.0, 64.0], seed: 3, adjustment: false, env: Default::default() };
-            crate::apply(s, &ctx, Buf { img: Image::new(64, 64), offset: [0.0, 0.0], scale: 1.0 })
-        };
-        // One wave born at t = 0, 0.2 s old: radius = Expansion × age = 20 px.
-        let base = [("waveMotion/expansion", num(100.0)), ("waveMotion/frequency", num(0.5))];
-        let o = r(&base, 0.2);
-        assert!(o.img.get(52, 32)[3] > 0.9, "{:?}", o.img.get(52, 32));
-        assert!(o.img.get(32, 32)[3] < 0.01);
-        // Velocity moves the wave toward Direction (90° = right).
-        let mut moving = base.to_vec();
-        moving.push(("waveMotion/velocity", num(50.0)));
-        let o = r(&moving, 0.2);
-        assert!(o.img.get(62, 32)[3] > 0.9 && o.img.get(52, 32)[3] < 0.5, "{:?}", o.img.get(62, 32));
-        // A 4-point star: the outline dips toward the centre between the points.
-        let mut star = base.to_vec();
-        star.extend([("polygon/sides", num(4.0)), ("polygon/star", Value::Bool(true)), ("polygon/starDepth", num(-0.5))]);
-        let o = r(&star, 0.2);
-        assert!(o.img.get(32, 12)[3] > 0.9, "point straight up");
-        // Between points (45°) the outline sits near half the radius.
-        assert!(o.img.get(39, 24)[3] > 0.5, "{:?}", o.img.get(39, 24));
-        assert!(o.img.get(46, 18)[3] < 0.01, "no circle there");
-    }
-
-    #[test]
-    fn lightning_alpha_obstacle_and_expert_settings() {
-        let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::<f32>();
-        let alpha_in = |img: &Image, src: &Image| img.data.iter().zip(&src.data).filter(|(_, s)| s[3] > 0.5).map(|(p, _)| p[3]).sum::<f32>();
-        // A wall of opaque pixels across the middle of the bolt's path.
-        let mut wall = Image::new(64, 48);
-        for y in 0..48 {
-            for x in 0..64 {
-                if (18..30).contains(&y) && x < 50 {
-                    wall.set(x, y, [0.0, 0.0, 0.0, 1.0]);
-                }
-            }
-        }
-        let opts = |o: f64| {
-            vec![("alphaObstacle", num(o)), ("compositeOnOriginal", Value::Bool(false)), ("glowSettings/glowRadius", num(0.0)), ("forking", num(60.0))]
-        };
-        let free = run("ec.generate.advancedlightning", &opts(0.0), wall.clone());
-        let avoid = run("ec.generate.advancedlightning", &opts(10.0), wall.clone());
-        assert!(alpha_in(&avoid.img, &wall) < alpha_in(&free.img, &wall), "{} vs {}", alpha_in(&avoid.img, &wall), alpha_in(&free.img, &wall));
-        // Fractal Type, Core Drain, Fork Strength, Termination Threshold, Min Fork Distance.
-        let base = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
-        for (id, v) in [
-            ("expertSettings/fractalType", Value::Enum(2)),
-            ("expertSettings/coreDrain", num(100.0)),
-            ("expertSettings/forkStrength", num(100.0)),
-            ("expertSettings/forkVariation", num(100.0)),
-        ] {
-            assert_ne!(run("ec.generate.advancedlightning", &[(id, v)], Image::new(64, 48)).img, base.img, "{id}");
-        }
-        let drained = run("ec.generate.advancedlightning", &[("expertSettings/coreDrain", num(100.0))], Image::new(64, 48));
-        assert!(sum(&drained.img) < sum(&base.img));
-        let no_forks = run("ec.generate.advancedlightning", &[("expertSettings/minForkDistance", num(1000.0))], Image::new(64, 48));
-        let term = run("ec.generate.advancedlightning", &[("expertSettings/terminationThreshold", num(100.0))], Image::new(64, 48));
-        assert_eq!(no_forks.img, term.img, "no forks either way");
-        assert!(sum(&no_forks.img) < sum(&base.img));
-    }
-
-    #[test]
-    fn lightning_types_and_decay_main_core() {
-        let a = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
-        let strike = run("ec.generate.advancedlightning", &[("lightningType", Value::Enum(1))], Image::new(64, 48));
-        assert_eq!(a.img, strike.img, "Strike is the default");
-        for t in 0..8 {
-            let o = run("ec.generate.advancedlightning", &[("lightningType", Value::Enum(t))], Image::new(64, 48));
-            assert!(o.img.data.iter().any(|p| p[3] > 0.3), "type {t} draws");
-        }
-        let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::<f32>();
-        let d = run("ec.generate.advancedlightning", &[("decayMainCore", Value::Bool(true)), ("decay", num(0.9))], Image::new(64, 48));
-        let n = run("ec.generate.advancedlightning", &[("decay", num(0.9))], Image::new(64, 48));
-        assert!(sum(&d.img) < sum(&n.img));
-    }
-
-    #[test]
-    fn beam_3d_perspective_controls_thickness() {
-        // Short beam near the start: with 3D Perspective its thickness comes from its position
-        // (thin, near the start); without, its head takes the full ending thickness.
-        let set = |p: bool| {
-            vec![
-                ("length", num(20.0)),
-                ("time", num(0.0)),
-                ("softness", num(0.0)),
-                ("startThickness", num(2.0)),
-                ("endThickness", num(20.0)),
-                ("perspective3d", Value::Bool(p)),
-            ]
-        };
-        let on = run("ec.generate.beam", &set(true), Image::new(64, 32));
-        let off = run("ec.generate.beam", &set(false), Image::new(64, 32));
-        let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::<f32>();
-        assert!(sum(&off.img) > sum(&on.img) * 1.5, "{} {}", sum(&off.img), sum(&on.img));
-    }
-
-    #[test]
-    fn lens_flare_brightest_at_center() {
-        let o = run("ec.generate.lensflare", &[], Image::new(64, 64));
-        let c = o.img.get(16, 16)[0];
-        assert!(c > o.img.get(60, 4)[0]);
-        assert!(c > 0.5);
-    }
-
-    fn rw(set: &[(&str, Value)], t: f64, env: crate::EffectEnv) -> Image {
-        let mut v: Vec<(&str, Value)> =
-            vec![("producerPoint", Value::Vec2([32.0, 32.0])), ("waveMotion/frequency", num(0.5)), ("waveMotion/expansion", num(100.0))];
-        v.extend_from_slice(set);
-        crate::run_fx("ec.generate.radiowaves", &v, Image::new(64, 64), t, env).img
-    }
-
-    #[test]
-    fn signed_distance_of_a_square() {
-        let (w, h) = (20, 20);
-        let inside: Vec<bool> = (0..w * h).map(|i| (5..15).contains(&(i % w)) && (5..15).contains(&(i / w))).collect();
-        let d = crate::util::signed_distance(&inside, w, h);
-        assert!((d.get(10, 10) + 4.5).abs() < 1e-4, "{}", d.get(10, 10));
-        assert!((d.get(0, 10) - 4.5).abs() < 1e-4, "{}", d.get(0, 10));
-        assert!((d.get(0, 0) - (50f32.sqrt() - 0.5)).abs() < 1e-4);
-    }
-
-    #[test]
-    fn radio_waves_mask_contours_profile_reflection_and_birth() {
-        // Mask waves: a 10×10 square mask; after 0.1 s (10 px) the wave is 10 px outside it.
-        let sq = crate::MaskShape { name: String::new(), points: vec![[27.0, 27.0], [37.0, 27.0], [37.0, 37.0], [27.0, 37.0]], closed: true, inverted: false };
-        let masks = [sq];
-        let env = crate::EffectEnv { masks: &masks, ..Default::default() };
-        let m = rw(&[("waveType", Value::Enum(2)), ("waveMask/mask", num(1.0))], 0.1, env);
-        assert!(m.get(47, 32)[3] > 0.9, "{:?}", m.get(47, 32));
-        assert!(m.get(32, 32)[3] < 0.01 && m.get(40, 32)[3] < 0.01);
-        // Rounded corner: diagonal distance 10 from (37, 37).
-        assert!(m.get(44, 44)[3] > 0.5, "{:?}", m.get(44, 44));
-        // No mask chosen: nothing drawn.
-        assert!(rw(&[("waveType", Value::Enum(2))], 0.1, env).data.iter().all(|p| p[3] == 0.0));
-        // Image Contours: the bright square of a source layer.
-        struct Src;
-        impl crate::EffectHost for Src {
-            fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
-                let mut img = Image::new(64, 64);
-                for y in 27..37 {
-                    for x in 27..37 {
-                        img.set(x, y, [1.0, 1.0, 1.0, 1.0]);
-                    }
-                }
-                Some(crate::LayerPixels { buf: Buf { img, offset: [0.0; 2], scale: 1.0 }, size: [64.0, 64.0] })
-            }
-            fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
-                None
-            }
-            fn params_at(&self, t: f64) -> Option<Params> {
-                // Colour animates from red (born at 0) to green (born later).
-                let s = crate::find("ec.generate.radiowaves").unwrap();
-                let mut p = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-                p.values.insert("producerPoint".into(), Value::Vec2([32.0, 32.0]));
-                p.values.insert("waveMotion/frequency".into(), num(1.0));
-                p.values.insert("waveMotion/expansion".into(), num(20.0));
-                p.values.insert("waveStroke/color".into(), if t < 0.5 { col(1.0, 0.0, 0.0) } else { col(0.0, 1.0, 0.0) });
-                Some(p)
-            }
-        }
-        let env = crate::EffectEnv { host: Some(&Src), ..Default::default() };
-        let ic = rw(
-            &[
-                ("waveType", Value::Enum(1)),
-                ("imageContour/sourceLayer", Value::Layer(Some(1))),
-                ("imageContour/preBlur", num(0.0)),
-                ("imageContour/tolerance", num(0.0)),
-            ],
-            0.1,
-            env,
-        );
-        assert!(ic.get(47, 32)[3] > 0.9 && ic.get(32, 32)[3] < 0.01, "{:?}", ic.get(47, 32));
-        // Source Center off the square shifts the contour onto the producer point accordingly.
-        let sh = rw(
-            &[
-                ("waveType", Value::Enum(1)),
-                ("imageContour/sourceLayer", Value::Layer(Some(1))),
-                ("imageContour/sourceCenter", Value::Vec2([22.0, 32.0])),
-                ("imageContour/preBlur", num(0.0)),
-                ("imageContour/tolerance", num(0.0)),
-            ],
-            0.1,
-            env,
-        );
-        assert!(sh.get(57, 32)[3] > 0.9, "{:?}", sh.get(57, 32));
-        // Profile: Taper Both thins the stroke edges; Square is solid across.
-        let wide = [("waveStroke/startWidth", num(10.0)), ("waveStroke/endWidth", num(10.0))];
-        let sqr = rw(&wide, 0.2, crate::EffectEnv::default());
-        let mut tap = wide.to_vec();
-        tap.push(("waveStroke/profile", Value::Enum(3)));
-        let tap = rw(&tap, 0.2, crate::EffectEnv::default());
-        assert!(sqr.get(55, 32)[3] > 0.9 && tap.get(55, 32)[3] < 0.6, "{:?} {:?}", sqr.get(55, 32), tap.get(55, 32));
-        assert!(tap.get(52, 32)[3] > 0.8);
-        // Reflection: a fast wave bounces back off the right edge.
-        let fast = [("waveMotion/velocity", num(200.0)), ("waveMotion/expansion", num(10.0))];
-        let gone = rw(&fast, 0.3, crate::EffectEnv::default());
-        let mut rf = fast.to_vec();
-        rf.push(("waveMotion/reflection", Value::Bool(true)));
-        let back = rw(&rf, 0.3, crate::EffectEnv::default());
-        let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::<f32>();
-        assert!(sum(&back) > sum(&gone) + 5.0, "{} vs {}", sum(&back), sum(&gone));
-        // Parameters Are Set At Birth: the older wave keeps red, the newer one is green.
-        let both = rw(&[("parametersAreSetAt", Value::Enum(0)), ("waveMotion/frequency", num(1.0)), ("waveMotion/expansion", num(20.0))], 1.15, env);
-        let (old, new) = (both.get(55, 32), both.get(35, 32));
-        assert!(old[0] > 0.9 && old[1] < 0.1, "{old:?}");
-        assert!(new[1] > 0.9 && new[0] < 0.1, "{new:?}");
-    }
-
-    #[test]
-    fn cell_pattern_hq_variants_antialias() {
-        let s = crate::find("ec.generate.cellpattern").unwrap();
-        let r = |pat: u32| {
-            let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-            params.values.insert("cellPattern".into(), Value::Enum(pat));
-            params.values.insert("size".into(), num(12.0));
-            let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [48.0, 48.0], seed: 1, adjustment: false, env: Default::default() };
-            crate::apply(s, &ctx, Buf { img: Image::new(48, 48), offset: [0.0; 2], scale: 1.0 }).img
-        };
-        let distinct = |img: &Image| {
-            let mut v: Vec<u32> = img.data.iter().map(|p| (p[0] * 10000.0) as u32).collect();
-            v.sort_unstable();
-            v.dedup();
-            v.len()
-        };
-        let (std, hq) = (r(4), r(9));
-        assert_eq!(CELL_PATTERNS[9], "Crystallize HQ");
-        assert_ne!(std, hq);
-        assert!(distinct(&hq) > distinct(&std) * 2, "{} vs {}", distinct(&hq), distinct(&std));
-    }
-}
+mod tests;
diff --git a/crates/effects/src/generate2/tests.rs b/crates/effects/src/generate2/tests.rs
new file mode 100644
index 000000000..c2acff446
--- /dev/null
+++ b/crates/effects/src/generate2/tests.rs
@@ -0,0 +1,309 @@
+use super::*;
+use crate::Params;
+use effectcraft_raster::Image;
+
+fn run(id: &str, set: &[(&str, Value)], img: Image) -> Buf {
+    let s = crate::find(id).unwrap();
+    let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+    let ls = [img.width as f64, img.height as f64];
+    for p in &s.params {
+        if let (ParamUi::Point, Value::Vec2(v)) = (&p.ui, &p.default) {
+            params.values.insert(p.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
+        }
+    }
+    for (k, v) in set {
+        params.values.insert(k.to_string(), v.clone());
+    }
+    let ctx = EffectCtx { params: &params, time: 0.5, layer_size: ls, seed: 3, adjustment: false, env: Default::default() };
+    crate::apply(s, &ctx, Buf { img, offset: [0.0, 0.0], scale: 1.0 })
+}
+
+#[test]
+fn cell_pattern_is_deterministic_and_seeded() {
+    let a = run("ec.generate.cellpattern", &[("size", num(10.0))], Image::new(40, 30));
+    let b2 = run("ec.generate.cellpattern", &[("size", num(10.0))], Image::new(40, 30));
+    assert_eq!(a.img, b2.img);
+    let c = run("ec.generate.cellpattern", &[("size", num(10.0)), ("evolutionOptions/randomSeed", num(5.0))], Image::new(40, 30));
+    assert_ne!(a.img, c.img);
+    assert!(a.img.data.iter().all(|p| p[3] == 1.0 && (0.0..=1.0).contains(&p[0])));
+}
+
+#[test]
+fn ellipse_ring_coverage() {
+    let o = run("ec.generate.ellipse", &[("width", num(40.0)), ("height", num(40.0)), ("thickness", num(6.0))], Image::new(64, 64));
+    // Ring passes through (32 + 20, 32); centre is empty.
+    assert!(o.img.get(51, 32)[3] > 0.9, "{:?}", o.img.get(51, 32));
+    assert!(o.img.get(32, 32)[3] < 1e-3);
+    assert!(o.img.get(2, 2)[3] < 1e-3);
+}
+
+#[test]
+fn lightning_is_deterministic_per_conductivity() {
+    let a = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
+    let b2 = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
+    assert_eq!(a.img, b2.img);
+    assert!(a.img.data.iter().any(|p| p[3] > 0.5));
+    let c = run("ec.generate.advancedlightning", &[("conductivityState", num(11.0))], Image::new(64, 48));
+    assert_ne!(a.img, c.img);
+}
+
+#[test]
+fn beam_draws_between_points() {
+    let o = run("ec.generate.beam", &[("length", num(100.0)), ("softness", num(0.0))], Image::new(64, 32));
+    assert!(o.img.get(32, 16)[3] > 0.99);
+    assert!(o.img.get(32, 2)[3] < 1e-3);
+    assert!(o.img.get(2, 16)[3] < 1e-3);
+}
+
+#[test]
+fn cell_pattern_tiles() {
+    // 4×4-cell tiles of 8 px: the pattern repeats every 32 px.
+    let set = [
+        ("size", num(8.0)),
+        ("tilingOptions/enableTiling", Value::Bool(true)),
+        ("tilingOptions/cellsHorizontal", num(4.0)),
+        ("tilingOptions/cellsVertical", num(4.0)),
+    ];
+    let o = run("ec.generate.cellpattern", &set, Image::new(64, 64));
+    for (x, y) in [(3, 5), (10, 20), (17, 2)] {
+        let (a, b2) = (o.img.get(x, y), o.img.get(x + 32, y + 32));
+        assert!((a[0] - b2[0]).abs() < 1e-4, "{x},{y}: {a:?} vs {b2:?}");
+    }
+}
+
+#[test]
+fn radio_waves_expansion_velocity_and_star() {
+    let r = |set: &[(&str, Value)], t: f64| {
+        let s = crate::find("ec.generate.radiowaves").unwrap();
+        let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+        params.values.insert("producerPoint".into(), Value::Vec2([32.0, 32.0]));
+        for (k, v) in set {
+            params.values.insert(k.to_string(), v.clone());
+        }
+        let ctx = EffectCtx { params: &params, time: t, layer_size: [64.0, 64.0], seed: 3, adjustment: false, env: Default::default() };
+        crate::apply(s, &ctx, Buf { img: Image::new(64, 64), offset: [0.0, 0.0], scale: 1.0 })
+    };
+    // One wave born at t = 0, 0.2 s old: radius = Expansion × age = 20 px.
+    let base = [("waveMotion/expansion", num(100.0)), ("waveMotion/frequency", num(0.5))];
+    let o = r(&base, 0.2);
+    assert!(o.img.get(52, 32)[3] > 0.9, "{:?}", o.img.get(52, 32));
+    assert!(o.img.get(32, 32)[3] < 0.01);
+    // Velocity moves the wave toward Direction (90° = right).
+    let mut moving = base.to_vec();
+    moving.push(("waveMotion/velocity", num(50.0)));
+    let o = r(&moving, 0.2);
+    assert!(o.img.get(62, 32)[3] > 0.9 && o.img.get(52, 32)[3] < 0.5, "{:?}", o.img.get(62, 32));
+    // A 4-point star: the outline dips toward the centre between the points.
+    let mut star = base.to_vec();
+    star.extend([("polygon/sides", num(4.0)), ("polygon/star", Value::Bool(true)), ("polygon/starDepth", num(-0.5))]);
+    let o = r(&star, 0.2);
+    assert!(o.img.get(32, 12)[3] > 0.9, "point straight up");
+    // Between points (45°) the outline sits near half the radius.
+    assert!(o.img.get(39, 24)[3] > 0.5, "{:?}", o.img.get(39, 24));
+    assert!(o.img.get(46, 18)[3] < 0.01, "no circle there");
+}
+
+#[test]
+fn lightning_alpha_obstacle_and_expert_settings() {
+    let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::<f32>();
+    let alpha_in = |img: &Image, src: &Image| img.data.iter().zip(&src.data).filter(|(_, s)| s[3] > 0.5).map(|(p, _)| p[3]).sum::<f32>();
+    // A wall of opaque pixels across the middle of the bolt's path.
+    let mut wall = Image::new(64, 48);
+    for y in 0..48 {
+        for x in 0..64 {
+            if (18..30).contains(&y) && x < 50 {
+                wall.set(x, y, [0.0, 0.0, 0.0, 1.0]);
+            }
+        }
+    }
+    let opts =
+        |o: f64| vec![("alphaObstacle", num(o)), ("compositeOnOriginal", Value::Bool(false)), ("glowSettings/glowRadius", num(0.0)), ("forking", num(60.0))];
+    let free = run("ec.generate.advancedlightning", &opts(0.0), wall.clone());
+    let avoid = run("ec.generate.advancedlightning", &opts(10.0), wall.clone());
+    assert!(alpha_in(&avoid.img, &wall) < alpha_in(&free.img, &wall), "{} vs {}", alpha_in(&avoid.img, &wall), alpha_in(&free.img, &wall));
+    // Fractal Type, Core Drain, Fork Strength, Termination Threshold, Min Fork Distance.
+    let base = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
+    for (id, v) in [
+        ("expertSettings/fractalType", Value::Enum(2)),
+        ("expertSettings/coreDrain", num(100.0)),
+        ("expertSettings/forkStrength", num(100.0)),
+        ("expertSettings/forkVariation", num(100.0)),
+    ] {
+        assert_ne!(run("ec.generate.advancedlightning", &[(id, v)], Image::new(64, 48)).img, base.img, "{id}");
+    }
+    let drained = run("ec.generate.advancedlightning", &[("expertSettings/coreDrain", num(100.0))], Image::new(64, 48));
+    assert!(sum(&drained.img) < sum(&base.img));
+    let no_forks = run("ec.generate.advancedlightning", &[("expertSettings/minForkDistance", num(1000.0))], Image::new(64, 48));
+    let term = run("ec.generate.advancedlightning", &[("expertSettings/terminationThreshold", num(100.0))], Image::new(64, 48));
+    assert_eq!(no_forks.img, term.img, "no forks either way");
+    assert!(sum(&no_forks.img) < sum(&base.img));
+}
+
+#[test]
+fn lightning_types_and_decay_main_core() {
+    let a = run("ec.generate.advancedlightning", &[], Image::new(64, 48));
+    let strike = run("ec.generate.advancedlightning", &[("lightningType", Value::Enum(1))], Image::new(64, 48));
+    assert_eq!(a.img, strike.img, "Strike is the default");
+    for t in 0..8 {
+        let o = run("ec.generate.advancedlightning", &[("lightningType", Value::Enum(t))], Image::new(64, 48));
+        assert!(o.img.data.iter().any(|p| p[3] > 0.3), "type {t} draws");
+    }
+    let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::<f32>();
+    let d = run("ec.generate.advancedlightning", &[("decayMainCore", Value::Bool(true)), ("decay", num(0.9))], Image::new(64, 48));
+    let n = run("ec.generate.advancedlightning", &[("decay", num(0.9))], Image::new(64, 48));
+    assert!(sum(&d.img) < sum(&n.img));
+}
+
+#[test]
+fn beam_3d_perspective_controls_thickness() {
+    // Short beam near the start: with 3D Perspective its thickness comes from its position
+    // (thin, near the start); without, its head takes the full ending thickness.
+    let set = |p: bool| {
+        vec![
+            ("length", num(20.0)),
+            ("time", num(0.0)),
+            ("softness", num(0.0)),
+            ("startThickness", num(2.0)),
+            ("endThickness", num(20.0)),
+            ("perspective3d", Value::Bool(p)),
+        ]
+    };
+    let on = run("ec.generate.beam", &set(true), Image::new(64, 32));
+    let off = run("ec.generate.beam", &set(false), Image::new(64, 32));
+    let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::<f32>();
+    assert!(sum(&off.img) > sum(&on.img) * 1.5, "{} {}", sum(&off.img), sum(&on.img));
+}
+
+#[test]
+fn lens_flare_brightest_at_center() {
+    let o = run("ec.generate.lensflare", &[], Image::new(64, 64));
+    let c = o.img.get(16, 16)[0];
+    assert!(c > o.img.get(60, 4)[0]);
+    assert!(c > 0.5);
+}
+
+fn rw(set: &[(&str, Value)], t: f64, env: crate::EffectEnv) -> Image {
+    let mut v: Vec<(&str, Value)> =
+        vec![("producerPoint", Value::Vec2([32.0, 32.0])), ("waveMotion/frequency", num(0.5)), ("waveMotion/expansion", num(100.0))];
+    v.extend_from_slice(set);
+    crate::run_fx("ec.generate.radiowaves", &v, Image::new(64, 64), t, env).img
+}
+
+#[test]
+fn signed_distance_of_a_square() {
+    let (w, h) = (20, 20);
+    let inside: Vec<bool> = (0..w * h).map(|i| (5..15).contains(&(i % w)) && (5..15).contains(&(i / w))).collect();
+    let d = crate::util::signed_distance(&inside, w, h);
+    assert!((d.get(10, 10) + 4.5).abs() < 1e-4, "{}", d.get(10, 10));
+    assert!((d.get(0, 10) - 4.5).abs() < 1e-4, "{}", d.get(0, 10));
+    assert!((d.get(0, 0) - (50f32.sqrt() - 0.5)).abs() < 1e-4);
+}
+
+#[test]
+fn radio_waves_mask_contours_profile_reflection_and_birth() {
+    // Mask waves: a 10×10 square mask; after 0.1 s (10 px) the wave is 10 px outside it.
+    let sq = crate::MaskShape { name: String::new(), points: vec![[27.0, 27.0], [37.0, 27.0], [37.0, 37.0], [27.0, 37.0]], closed: true, inverted: false };
+    let masks = [sq];
+    let env = crate::EffectEnv { masks: &masks, ..Default::default() };
+    let m = rw(&[("waveType", Value::Enum(2)), ("waveMask/mask", num(1.0))], 0.1, env);
+    assert!(m.get(47, 32)[3] > 0.9, "{:?}", m.get(47, 32));
+    assert!(m.get(32, 32)[3] < 0.01 && m.get(40, 32)[3] < 0.01);
+    // Rounded corner: diagonal distance 10 from (37, 37).
+    assert!(m.get(44, 44)[3] > 0.5, "{:?}", m.get(44, 44));
+    // No mask chosen: nothing drawn.
+    assert!(rw(&[("waveType", Value::Enum(2))], 0.1, env).data.iter().all(|p| p[3] == 0.0));
+    // Image Contours: the bright square of a source layer.
+    struct Src;
+    impl crate::EffectHost for Src {
+        fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
+            let mut img = Image::new(64, 64);
+            for y in 27..37 {
+                for x in 27..37 {
+                    img.set(x, y, [1.0, 1.0, 1.0, 1.0]);
+                }
+            }
+            Some(crate::LayerPixels { buf: Buf { img, offset: [0.0; 2], scale: 1.0 }, size: [64.0, 64.0] })
+        }
+        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+            None
+        }
+        fn params_at(&self, t: f64) -> Option<Params> {
+            // Colour animates from red (born at 0) to green (born later).
+            let s = crate::find("ec.generate.radiowaves").unwrap();
+            let mut p = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+            p.values.insert("producerPoint".into(), Value::Vec2([32.0, 32.0]));
+            p.values.insert("waveMotion/frequency".into(), num(1.0));
+            p.values.insert("waveMotion/expansion".into(), num(20.0));
+            p.values.insert("waveStroke/color".into(), if t < 0.5 { col(1.0, 0.0, 0.0) } else { col(0.0, 1.0, 0.0) });
+            Some(p)
+        }
+    }
+    let env = crate::EffectEnv { host: Some(&Src), ..Default::default() };
+    let ic = rw(
+        &[
+            ("waveType", Value::Enum(1)),
+            ("imageContour/sourceLayer", Value::Layer(Some(1))),
+            ("imageContour/preBlur", num(0.0)),
+            ("imageContour/tolerance", num(0.0)),
+        ],
+        0.1,
+        env,
+    );
+    assert!(ic.get(47, 32)[3] > 0.9 && ic.get(32, 32)[3] < 0.01, "{:?}", ic.get(47, 32));
+    // Source Center off the square shifts the contour onto the producer point accordingly.
+    let sh = rw(
+        &[
+            ("waveType", Value::Enum(1)),
+            ("imageContour/sourceLayer", Value::Layer(Some(1))),
+            ("imageContour/sourceCenter", Value::Vec2([22.0, 32.0])),
+            ("imageContour/preBlur", num(0.0)),
+            ("imageContour/tolerance", num(0.0)),
+        ],
+        0.1,
+        env,
+    );
+    assert!(sh.get(57, 32)[3] > 0.9, "{:?}", sh.get(57, 32));
+    // Profile: Taper Both thins the stroke edges; Square is solid across.
+    let wide = [("waveStroke/startWidth", num(10.0)), ("waveStroke/endWidth", num(10.0))];
+    let sqr = rw(&wide, 0.2, crate::EffectEnv::default());
+    let mut tap = wide.to_vec();
+    tap.push(("waveStroke/profile", Value::Enum(3)));
+    let tap = rw(&tap, 0.2, crate::EffectEnv::default());
+    assert!(sqr.get(55, 32)[3] > 0.9 && tap.get(55, 32)[3] < 0.6, "{:?} {:?}", sqr.get(55, 32), tap.get(55, 32));
+    assert!(tap.get(52, 32)[3] > 0.8);
+    // Reflection: a fast wave bounces back off the right edge.
+    let fast = [("waveMotion/velocity", num(200.0)), ("waveMotion/expansion", num(10.0))];
+    let gone = rw(&fast, 0.3, crate::EffectEnv::default());
+    let mut rf = fast.to_vec();
+    rf.push(("waveMotion/reflection", Value::Bool(true)));
+    let back = rw(&rf, 0.3, crate::EffectEnv::default());
+    let sum = |i: &Image| i.data.iter().map(|p| p[3]).sum::<f32>();
+    assert!(sum(&back) > sum(&gone) + 5.0, "{} vs {}", sum(&back), sum(&gone));
+    // Parameters Are Set At Birth: the older wave keeps red, the newer one is green.
+    let both = rw(&[("parametersAreSetAt", Value::Enum(0)), ("waveMotion/frequency", num(1.0)), ("waveMotion/expansion", num(20.0))], 1.15, env);
+    let (old, new) = (both.get(55, 32), both.get(35, 32));
+    assert!(old[0] > 0.9 && old[1] < 0.1, "{old:?}");
+    assert!(new[1] > 0.9 && new[0] < 0.1, "{new:?}");
+}
+
+#[test]
+fn cell_pattern_hq_variants_antialias() {
+    let s = crate::find("ec.generate.cellpattern").unwrap();
+    let r = |pat: u32| {
+        let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+        params.values.insert("cellPattern".into(), Value::Enum(pat));
+        params.values.insert("size".into(), num(12.0));
+        let ctx = EffectCtx { params: &params, time: 0.0, layer_size: [48.0, 48.0], seed: 1, adjustment: false, env: Default::default() };
+        crate::apply(s, &ctx, Buf { img: Image::new(48, 48), offset: [0.0; 2], scale: 1.0 }).img
+    };
+    let distinct = |img: &Image| {
+        let mut v: Vec<u32> = img.data.iter().map(|p| (p[0] * 10000.0) as u32).collect();
+        v.sort_unstable();
+        v.dedup();
+        v.len()
+    };
+    let (std, hq) = (r(4), r(9));
+    assert_eq!(CELL_PATTERNS[9], "Crystallize HQ");
+    assert_ne!(std, hq);
+    assert!(distinct(&hq) > distinct(&std) * 2, "{} vs {}", distinct(&hq), distinct(&std));
+}
diff --git a/crates/effects/src/generate3.rs b/crates/effects/src/generate3.rs
index 6beec4cb7..a61c3f769 100644
--- a/crates/effects/src/generate3.rs
+++ b/crates/effects/src/generate3.rs
@@ -17,2430 +17,26 @@ use rayon::prelude::*;
 use crate::util::{Plane, gauss_plane, hash1, layer_or_self, morph_frac, poly_length, premul, smoothstep, unpremul};
 use crate::{Buf, EffectCtx, EffectSpec, Params, col, num, p, popup, slider};
 
-fn spec(id: &'static str, name: &'static str, params: Vec<crate::ParamSpec>, render: crate::RenderFn) -> EffectSpec {
-    EffectSpec { id, name, category: "Generate", params, render, gpu: false, float: true }
-}
-
-fn pt(x: f64, y: f64) -> Value {
-    Value::Vec2([x, y])
-}
-
-fn pct() -> ParamUi {
-    slider(0.0, 100.0, 0.0, 100.0, 1)
-}
-
-// ---------------------------------------------------------------- shared rasterisation
-
-/// A round-capped line segment in buffer pixels with radius `r` and intensity `v`.
-#[derive(Clone, Copy, Debug)]
-pub struct Seg {
-    pub a: [f64; 2],
-    pub b: [f64; 2],
-    pub r: f64,
-    pub v: f32,
-}
-
-/// Rasterise segments into a coverage plane (max-combined). `hardness` (0..1) is the fraction
-/// of the radius that is fully opaque; the rest falls off smoothly.
-pub(crate) fn raster_segs(w: usize, h: usize, segs: &[Seg], hardness: f64) -> Plane {
-    let mut out = Plane::new(w, h);
-    if w == 0 || h == 0 || segs.is_empty() {
-        return out;
-    }
-    let mut buckets: Vec<Vec<u32>> = vec![Vec::new(); h];
-    for (i, s) in segs.iter().enumerate() {
-        let pad = s.r + 1.0;
-        let y0 = (s.a[1].min(s.b[1]) - pad).floor().max(0.0) as usize;
-        let y1 = (s.a[1].max(s.b[1]) + pad).ceil().min(h as f64);
-        if y1 <= 0.0 || y0 >= h {
-            continue;
-        }
-        for row in buckets.iter_mut().take(y1 as usize).skip(y0) {
-            row.push(i as u32);
-        }
-    }
-    let hard = hardness.clamp(0.0, 1.0);
-    out.data.par_chunks_mut(w).enumerate().for_each(|(y, row)| {
-        let py = y as f64 + 0.5;
-        for &i in &buckets[y] {
-            let s = segs[i as usize];
-            let pad = s.r + 1.0;
-            let x0 = (s.a[0].min(s.b[0]) - pad).floor().max(0.0) as usize;
-            let x1 = ((s.a[0].max(s.b[0]) + pad).ceil().max(0.0) as usize).min(w);
-            let (dx, dy) = (s.b[0] - s.a[0], s.b[1] - s.a[1]);
-            let l2 = dx * dx + dy * dy;
-            let inner = s.r * hard - 0.5;
-            let outer = s.r + 0.5;
-            for (x, o) in row.iter_mut().enumerate().take(x1).skip(x0) {
-                let px = x as f64 + 0.5;
-                let t = if l2 > 1e-12 { (((px - s.a[0]) * dx + (py - s.a[1]) * dy) / l2).clamp(0.0, 1.0) } else { 0.0 };
-                let d = ((px - s.a[0] - dx * t).powi(2) + (py - s.a[1] - dy * t).powi(2)).sqrt();
-                if d >= outer {
-                    continue;
-                }
-                let c = if d <= inner { 1.0 } else { 1.0 - smoothstep(inner as f32, outer as f32, d as f32) } * s.v;
-                if c > *o {
-                    *o = c;
-                }
-            }
-        }
-    });
-    out
-}
-
-/// Segments along a polyline (buffer px).
-pub fn poly_segs(pts: &[[f64; 2]], closed: bool, r: f64, v: f32, out: &mut Vec<Seg>) {
-    let n = pts.len();
-    if n == 1 {
-        out.push(Seg { a: pts[0], b: pts[0], r, v });
-    }
-    if n < 2 {
-        return;
-    }
-    let segs = if closed { n } else { n - 1 };
-    for i in 0..segs {
-        out.push(Seg { a: pts[i], b: pts[(i + 1) % n], r, v });
-    }
-}
-
-/// Portion `[s0, s1]` (arc length) of a polyline.
-pub(crate) fn trim_poly(pts: &[[f64; 2]], closed: bool, s0: f64, s1: f64) -> Vec<[f64; 2]> {
-    let n = pts.len();
-    let mut out = Vec::new();
-    if n < 2 || s1 <= s0 {
-        return out;
-    }
-    let segs = if closed { n } else { n - 1 };
-    let mut acc = 0.0;
-    for i in 0..segs {
-        let (a, b) = (pts[i], pts[(i + 1) % n]);
-        let l = ((b[0] - a[0]).powi(2) + (b[1] - a[1]).powi(2)).sqrt();
-        let (e0, e1) = (acc, acc + l);
-        acc = e1;
-        if e1 < s0 || e0 > s1 || l <= 0.0 {
-            continue;
-        }
-        let at = |s: f64| {
-            let t = ((s - e0) / l).clamp(0.0, 1.0);
-            [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
-        };
-        let p0 = at(s0.max(e0));
-        if out.last() != Some(&p0) {
-            out.push(p0);
-        }
-        out.push(at(s1.min(e1)));
-    }
-    out
-}
-
-/// How painted coverage meets the layer: 0 On Original Image, 1 On Transparent, 2 Reveal
-/// Original Image.
-pub(crate) fn paint(img: &mut Image, cov: &Plane, color: [f32; 4], opacity: f32, style: u32) {
-    img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
-        let a = (c * opacity * color[3]).clamp(0.0, 1.0);
-        let s = [color[0] * a, color[1] * a, color[2] * a, a];
-        *px = match style {
-            1 => s,
-            2 => [px[0] * a, px[1] * a, px[2] * a, px[3] * a],
-            _ => over(*px, s),
-        };
-    });
-}
-
-/// Coverage of a plan-drawn generator: round-capped segments rasterised by [`raster_segs`]
-/// with `hardness`, or the union of convex polygons ([`raster_convex`]).
-#[derive(Clone, Debug)]
-pub enum Coverage {
-    Segs { segs: Vec<Seg>, hardness: f64 },
-    Convex(Vec<Vec<[f64; 2]>>),
-}
-
-impl Coverage {
-    fn raster(&self, w: usize, h: usize) -> Plane {
-        match self {
-            Coverage::Segs { segs, hardness } => raster_segs(w, h, segs, *hardness),
-            Coverage::Convex(polys) => raster_convex(w, h, polys),
-        }
-    }
-}
-
-/// Stroke, Scribble, Vegas and Write-on, shared with the GPU compositor (effectcraft-gpu
-/// `fx_gen2`): the coverage and how it is painted. `style` 0–2 as [`paint`] (On Original
-/// Image, On Transparent, Reveal Original Image), 3 = under the layer (Vegas' Composite Under).
-#[derive(Clone, Debug)]
-pub struct PaintPlan {
-    pub cov: Coverage,
-    pub color: [f32; 4],
-    pub opacity: f32,
-    pub style: u32,
-}
-
-/// Draw a [`PaintPlan`].
-fn draw_paint(b: &mut Buf, plan: &PaintPlan) {
-    let cov = plan.cov.raster(b.img.width as usize, b.img.height as usize);
-    if plan.style == 3 {
-        let color = plan.color;
-        b.img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
-            let a = c * color[3];
-            *px = over([color[0] * a, color[1] * a, color[2] * a, a], *px);
-        });
-    } else {
-        paint(&mut b.img, &cov, plan.color, plan.opacity, plan.style);
-    }
-}
-
-/// Generators drawn from a plan that need the layer's own pixels (`b.img`) to build it.
-pub fn plan_reads_pixels(id: &str, ctx: &EffectCtx) -> bool {
-    match id {
-        // Image Contours read the layer itself when no (resolvable) Input Layer is chosen.
-        "ec.generate.vegas" => ctx.params.e("stroke") == 0,
-        "ec.generate.paintbucket" | "ec.generate.eyedropperfill" => true,
-        "ec.generate.advancedlightning" => ctx.params.f("alphaObstacle").clamp(-10.0, 10.0) != 0.0,
-        _ => false,
-    }
-}
-
-/// [`PaintPlan`] of Stroke, Scribble, Vegas or Write-on on `b`'s geometry (`b.img` is read
-/// only when [`plan_reads_pixels`]). `None`: Scribble without a usable mask (the layer is
-/// cleared when it composites On Transparent, else kept).
-pub fn paint_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option<PaintPlan> {
-    match id {
-        "ec.generate.stroke" => Some(stroke_plan(ctx, b)),
-        "ec.generate.scribble" => scribble_plan(ctx, b),
-        "ec.generate.vegas" => Some(vegas_plan(ctx, b)),
-        "ec.generate.writeon" => Some(write_on_plan(ctx, b)),
-        _ => None,
-    }
-}
-
-/// Scribble's Composite as a [`paint`] style.
-pub fn scribble_style(ctx: &EffectCtx) -> u32 {
-    match ctx.params.e("composite") {
-        0 => 0,
-        2 => 2,
-        _ => 1,
-    }
-}
-
-#[inline]
-fn over(dst: Px, src: Px) -> Px {
-    let k = 1.0 - src[3];
-    [src[0] + dst[0] * k, src[1] + dst[1] * k, src[2] + dst[2] * k, src[3] + dst[3] * k]
-}
-
-/// Mask `idx` (1-based; 0 = none) mapped to buffer pixels.
-pub(crate) fn mask_px(ctx: &EffectCtx, b: &Buf, idx: usize) -> Option<(Vec<[f64; 2]>, bool, bool)> {
-    let m = ctx.env.masks.get(idx.checked_sub(1)?)?;
-    if m.points.is_empty() {
-        return None;
-    }
-    Some((m.points.iter().map(|&q| [q[0] * b.scale + b.offset[0], q[1] * b.scale + b.offset[1]]).collect(), m.closed, m.inverted))
-}
-
-/// All masks mapped to buffer pixels.
-fn all_masks_px(ctx: &EffectCtx, b: &Buf) -> Vec<(Vec<[f64; 2]>, bool, bool)> {
-    (1..=ctx.env.masks.len()).filter_map(|i| mask_px(ctx, b, i)).collect()
-}
-
-/// Chaikin corner cutting (open polyline, endpoints kept).
-fn chaikin(pts: &[[f64; 2]], iters: usize) -> Vec<[f64; 2]> {
-    let mut cur = pts.to_vec();
-    for _ in 0..iters {
-        if cur.len() < 3 {
-            return cur;
-        }
-        let mut nx = Vec::with_capacity(cur.len() * 2);
-        nx.push(cur[0]);
-        for w in cur.windows(2) {
-            let (a, b) = (w[0], w[1]);
-            nx.push([a[0] * 0.75 + b[0] * 0.25, a[1] * 0.75 + b[1] * 0.25]);
-            nx.push([a[0] * 0.25 + b[0] * 0.75, a[1] * 0.25 + b[1] * 0.75]);
-        }
-        nx.push(*cur.last().unwrap_or(&[0.0; 2]));
-        cur = nx;
-    }
-    cur
-}
-
-// ---------------------------------------------------------------- Fractal
-
-#[derive(Clone, Copy)]
-struct FracSet {
-    /// Mandelbrot iterations start at the Julia centre (the "Over Julia" set choices).
-    over_julia: bool,
-    julia: bool,
-    inverse: bool,
-}
-
-/// Smooth escape count, or `None` inside the set.
-fn escape(z0: (f64, f64), c: (f64, f64), power: u32, limit: f64, max_iter: u32) -> Option<f64> {
-    let (mut x, mut y) = z0;
-    let lim2 = limit * limit;
-    for i in 0..max_iter {
-        let (nx, ny) = match power {
-            3 => (x * x * x - 3.0 * x * y * y, 3.0 * x * x * y - y * y * y),
-            4 => {
-                let (a, b) = (x * x - y * y, 2.0 * x * y);
-                (a * a - b * b, 2.0 * a * b)
-            }
-            _ => (x * x - y * y, 2.0 * x * y),
-        };
-        x = nx + c.0;
-        y = ny + c.1;
-        let m2 = x * x + y * y;
-        if m2 > lim2 {
-            let lz = m2.ln() * 0.5;
-            let nu = (lz / limit.max(1.0001).ln()).max(1e-9).ln() / (power as f64).ln();
-            return Some((i as f64 + 1.0 - nu).max(0.0));
-        }
-    }
-    None
-}
-
-/// Fractal Set Choice options.
-pub(crate) const FRACTAL_SETS: [&str; 6] =
-    ["Mandelbrot", "Mandelbrot Inverse", "Mandelbrot Over Julia", "Mandelbrot Inverse Over Julia", "Julia", "Julia Inverse"];
-/// Fractal Palette options.
-pub(crate) const FRACTAL_PALETTES: [&str; 4] = ["Lightness Gradient", "Hue Wheel", "Black And White", "Solid Color"];
-/// Fractal Oversample Method options.
-pub(crate) const FRACTAL_OVERSAMPLE: [&str; 2] = ["Edge Detect-Fast-May Miss Pixels", "Brute Force-Slow-Every Pixel"];
-
-fn fractal(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let pr = ctx.params;
-    let set_choice = pr.e("setChoice");
-    let power = 2 + pr.e("equation").min(2);
-    let mc = (pr.f("mandelbrot/mandelbrotX"), pr.f("mandelbrot/mandelbrotY"));
-    let mmag = pr.f("mandelbrot/mandelbrotMagnification");
-    let mlim = pr.f("mandelbrot/mandelbrotEscapeLimit").max(1.01);
-    let jc = (pr.f("julia/juliaX"), pr.f("julia/juliaY"));
-    let jmag = pr.f("julia/juliaMagnification");
-    let jlim = pr.f("julia/juliaEscapeLimit").max(1.01);
-    let post = (pr.f("postInversionOffset/postInversionX"), pr.f("postInversionOffset/postInversionY"));
-    let overlay = pr.b("fractalColor/overlay");
-    let transparency = pr.b("fractalColor/transparency");
-    let transparent_inside = transparency || overlay;
-    let palette = pr.e("fractalColor/palette");
-    let hue = (pr.f("fractalColor/hue") / 360.0) as f32;
-    let steps = pr.f("fractalColor/cycleSteps").max(1.0);
-    let cyc_off = pr.f("fractalColor/cycleOffset") / 360.0;
-    let edge = pr.b("fractalColor/edgeHighlight");
-    let every = pr.e("highQualitySettings/samplingMethod") == 1;
-    let factor = pr.f("highQualitySettings/samplingFactor").round().clamp(1.0, 9.0) as usize;
-    let (w, h) = (b.img.width as usize, b.img.height as usize);
-    let lw = ctx.layer_size[0].max(1.0);
-    let lh = ctx.layer_size[1].max(1.0);
-    let inv = 1.0 / b.scale.max(1e-9);
-    let (off_x, off_y) = (b.offset[0], b.offset[1]);
-    // FRACTAL_SETS order.
-    let set = |julia, inverse, over_julia| FracSet { over_julia, julia, inverse };
-    let sets: (FracSet, Option<FracSet>) = match set_choice {
-        1 => (set(false, true, false), None),
-        2 => (set(false, false, true), None),
-        3 => (set(false, true, true), None),
-        4 => (set(true, false, false), None),
-        5 => (set(true, true, false), None),
-        _ => (set(false, false, false), None),
-    };
-    let iter_for = |mag: f64| (96.0 + 48.0 * mag.max(0.0)).clamp(64.0, 3000.0) as u32;
-    let eval_set = |s: FracSet, lx: f64, ly: f64| -> Option<f64> {
-        let (center, mag, lim) = if s.julia { (jc, jmag, jlim) } else { (mc, mmag, mlim) };
-        let span = 3.5 / 2f64.powf(mag);
-        let mut u = (lx - lw * 0.5) / lw * span + center.0;
-        let mut v = (ly - lh * 0.5) / lw * span + center.1;
-        if s.inverse {
-            let d = (u * u + v * v).max(1e-12);
-            u = u / d + post.0;
-            v = -v / d + post.1;
-        }
-        if s.julia {
-            escape((u, v), mc, power, lim, iter_for(mag))
-        } else {
-            let z0 = if s.over_julia { jc } else { (0.0, 0.0) };
-            escape(z0, (u, v), power, lim, iter_for(mag))
-        }
-    };
-    let eval = |lx: f64, ly: f64| -> Option<f64> {
-        let a = eval_set(sets.0, lx, ly);
-        match (a, sets.1) {
-            (None, Some(s2)) => eval_set(s2, lx, ly),
-            _ => a,
-        }
-    };
-    let shade = |n: Option<f64>| -> Px {
-        // Solid Color: only the inside of the set is drawn (Transparency flips the sides).
-        if palette == 3 {
-            let (r, g, bl) = hsl_to_rgb(hue, 1.0, 0.5);
-            return if n.is_none() != transparency { [r, g, bl, 1.0] } else { [0.0; 4] };
-        }
-        let Some(n) = n else {
-            return if transparent_inside { [0.0; 4] } else { [0.0, 0.0, 0.0, 1.0] };
-        };
-        let u = n / steps + cyc_off;
-        let band = (u.rem_euclid(1.0)) as f32;
-        let (r, g, bl) = match palette {
-            // Hue Wheel: the full hue circle at full saturation and brightness.
-            1 => hsl_to_rgb((hue + band).rem_euclid(1.0), 1.0, 0.5),
-            // Black And White: alternating bands.
-            2 => {
-                let v = if (u.floor() as i64).rem_euclid(2) == 0 { 0.0 } else { 1.0 };
-                (v, v, v)
-            }
-            // Lightness Gradient: black → hue → white, the hue moving 45° each cycle.
-            _ => hsl_to_rgb((hue + u.floor() as f32 * 0.125).rem_euclid(1.0), 0.85, band.clamp(0.0, 1.0)),
-        };
-        let mut c = [r, g, bl];
-        if edge && n.fract() < 0.12 {
-            c = [c[0] * 0.4 + 0.6, c[1] * 0.4 + 0.6, c[2] * 0.4 + 0.6];
-        }
-        [c[0], c[1], c[2], 1.0]
-    };
-    // First pass: one sample per pixel.
-    let mut first: Vec<Option<f64>> = vec![None; w * h];
-    first.par_chunks_mut(w.max(1)).enumerate().for_each(|(y, row)| {
-        for (x, v) in row.iter_mut().enumerate() {
-            *v = eval((x as f64 + 0.5 - off_x) * inv, (y as f64 + 0.5 - off_y) * inv);
-        }
-    });
-    let src = if overlay { Some(b.img.clone()) } else { None };
-    b.img.rows_mut().for_each(|(y, row)| {
-        for (x, px) in row.iter_mut().enumerate() {
-            let here = first[y * w + x];
-            let needs_ss = factor > 1
-                && (every || {
-                    let mut diff = false;
-                    for (dx, dy) in [(-1i64, 0i64), (1, 0), (0, -1), (0, 1)] {
-                        let (nx, ny) = (x as i64 + dx, y as i64 + dy);
-                        if nx < 0 || ny < 0 || nx >= w as i64 || ny >= h as i64 {
-                            continue;
-                        }
-                        let o = first[ny as usize * w + nx as usize];
-                        diff |= match (here, o) {
-                            (Some(a), Some(c)) => (a - c).abs() > steps * 0.25,
-                            (None, None) => false,
-                            _ => true,
-                        };
-                    }
-                    diff
-                });
-            let c = if needs_ss {
-                let mut acc = [0.0f32; 4];
-                for sy in 0..factor {
-                    for sx in 0..factor {
-                        let fx = x as f64 + (sx as f64 + 0.5) / factor as f64;
-                        let fy = y as f64 + (sy as f64 + 0.5) / factor as f64;
-                        let s = shade(eval((fx - off_x) * inv, (fy - off_y) * inv));
-                        let a = s[3];
-                        for k in 0..3 {
-                            acc[k] += s[k] * a;
-                        }
-                        acc[3] += a;
-                    }
-                }
-                let n = (factor * factor) as f32;
-                [acc[0] / n, acc[1] / n, acc[2] / n, acc[3] / n]
-            } else {
-                let s = shade(here);
-                [s[0] * s[3], s[1] * s[3], s[2] * s[3], s[3]]
-            };
-            *px = match &src {
-                Some(o) => over(o.data[y * w + x], c),
-                None => c,
-            };
-        }
-    });
-    b
-}
-
-// ---------------------------------------------------------------- Scribble
-
-/// Scan runs (start, end along direction `d`) of the fill region on the line `n·p = s`.
-#[allow(clippy::too_many_arguments)]
-fn scan_runs(polys: &[(Vec<[f64; 2]>, bool, bool)], fill: u32, ew: f64, d: [f64; 2], n: [f64; 2], s: f64, out: &mut Vec<(f64, f64)>) {
-    out.clear();
-    for (pts, _closed, inverted) in polys {
-        let m = pts.len();
-        if m < 2 {
-            continue;
-        }
-        // Crossings: (t along d, |sin| of crossing angle).
-        let mut xs: Vec<(f64, f64)> = Vec::new();
-        for i in 0..m {
-            let (a, b) = (pts[i], pts[(i + 1) % m]);
-            let (na, nb) = (a[0] * n[0] + a[1] * n[1] - s, b[0] * n[0] + b[1] * n[1] - s);
-            if (na > 0.0) == (nb > 0.0) {
-                continue;
-            }
-            let t = na / (na - nb);
-            let q = [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
-            let (ex, ey) = (b[0] - a[0], b[1] - a[1]);
-            let el = (ex * ex + ey * ey).sqrt().max(1e-9);
-            let sin = ((ex * n[0] + ey * n[1]) / el).abs().max(0.2);
-            xs.push((q[0] * d[0] + q[1] * d[1], sin));
-        }
-        xs.sort_by(|a, b| a.0.total_cmp(&b.0));
-        // Signed area decides which side is "left".
-        let area: f64 = (0..m).map(|i| pts[i][0] * pts[(i + 1) % m][1] - pts[(i + 1) % m][0] * pts[i][1]).sum();
-        let left_is_inside = area < 0.0;
-        let mode = match fill {
-            4 => {
-                if left_is_inside {
-                    2
-                } else {
-                    3
-                }
-            }
-            5 => {
-                if left_is_inside {
-                    3
-                } else {
-                    2
-                }
-            }
-            f => f,
-        };
-        let mode = if *inverted && mode == 0 { 6 } else { mode };
-        for (k, &(t, sin)) in xs.iter().enumerate() {
-            let entering = k % 2 == 0;
-            let l = ew / sin;
-            match mode {
-                0 if entering && k + 1 < xs.len() => {
-                    out.push((t, xs[k + 1].0));
-                }
-                1 => out.push((t - l * 0.5, t + l * 0.5)),
-                2 => out.push(if entering { (t, t + l) } else { (t - l, t) }),
-                3 => out.push(if entering { (t - l, t) } else { (t, t + l) }),
-                _ => {}
-            }
-        }
-        if mode == 6 {
-            // Inverted Inside: outside of the polygon within the bounds.
-            let lo = pts.iter().map(|q| q[0] * d[0] + q[1] * d[1]).fold(f64::INFINITY, f64::min) - ew;
-            let hi = pts.iter().map(|q| q[0] * d[0] + q[1] * d[1]).fold(f64::NEG_INFINITY, f64::max) + ew;
-            let mut cur = lo;
-            for pair in xs.chunks(2) {
-                out.push((cur, pair[0].0));
-                cur = pair.get(1).map(|v| v.0).unwrap_or(hi);
-            }
-            out.push((cur, hi));
-        }
-    }
-    out.sort_by(|a, b| a.0.total_cmp(&b.0));
-    // Merge overlaps.
-    let mut merged: Vec<(f64, f64)> = Vec::with_capacity(out.len());
-    for &(a, b) in out.iter() {
-        if let Some(last) = merged.last_mut()
-            && a <= last.1
-        {
-            last.1 = last.1.max(b);
-            continue;
-        }
-        merged.push((a, b));
-    }
-    *out = merged;
-}
-
-/// End Cap and Join options (Scribble's Edge Options).
-const END_CAPS: [&str; 3] = ["Round", "Butt", "Projecting"];
-const JOINS: [&str; 3] = ["Round", "Miter", "Bevel"];
-
-/// Convex polygons whose union is the stroke of the polylines `lines` with half width `r`:
-/// one quad per segment, plus the joins (Round discs, Miter wedges up to `miter_limit` × the
-/// half width, Bevel triangles) and the caps (Round discs, Butt none, Projecting square ends).
-pub(crate) fn stroke_outline(lines: &[Vec<[f64; 2]>], r: f64, cap: u32, join: u32, miter_limit: f64) -> Vec<Vec<[f64; 2]>> {
-    let disc = |c: [f64; 2]| -> Vec<[f64; 2]> {
-        (0..16).map(|k| (k as f64 / 16.0 * std::f64::consts::TAU).sin_cos()).map(|(s, co)| [c[0] + co * r, c[1] + s * r]).collect()
-    };
-    let mut out = Vec::new();
-    for l in lines {
-        let pts: Vec<[f64; 2]> = l.iter().copied().fold(Vec::new(), |mut v, p| {
-            if v.last().is_none_or(|q: &[f64; 2]| (q[0] - p[0]).hypot(q[1] - p[1]) > 1e-9) {
-                v.push(p);
-            }
-            v
-        });
-        if pts.len() < 2 {
-            if let (Some(p), 0) = (pts.first(), cap) {
-                out.push(disc(*p));
-            }
-            continue;
-        }
-        let dir = |a: [f64; 2], b: [f64; 2]| {
-            let (dx, dy) = (b[0] - a[0], b[1] - a[1]);
-            let l = dx.hypot(dy).max(1e-12);
-            [dx / l, dy / l]
-        };
-        let n = pts.len();
-        for k in 0..n - 1 {
-            let (mut a, mut b) = (pts[k], pts[k + 1]);
-            let d = dir(a, b);
-            // Projecting caps extend the end segments by the half width.
-            if cap == 2 && k == 0 {
-                a = [a[0] - d[0] * r, a[1] - d[1] * r];
-            }
-            if cap == 2 && k == n - 2 {
-                b = [b[0] + d[0] * r, b[1] + d[1] * r];
-            }
-            let nn = [-d[1] * r, d[0] * r];
-            out.push(vec![[a[0] + nn[0], a[1] + nn[1]], [b[0] + nn[0], b[1] + nn[1]], [b[0] - nn[0], b[1] - nn[1]], [a[0] - nn[0], a[1] - nn[1]]]);
-        }
-        // Joins.
-        for k in 1..n - 1 {
-            let (p, d0, d1) = (pts[k], dir(pts[k - 1], pts[k]), dir(pts[k], pts[k + 1]));
-            let cross = d0[0] * d1[1] - d0[1] * d1[0];
-            if cross.abs() < 1e-9 && d0[0] * d1[0] + d0[1] * d1[1] > 0.0 {
-                continue;
-            }
-            if join == 0 {
-                out.push(disc(p));
-                continue;
-            }
-            // The outer side of the turn.
-            let s = if cross > 0.0 { -1.0 } else { 1.0 };
-            let o0 = [p[0] - d0[1] * r * s, p[1] + d0[0] * r * s];
-            let o1 = [p[0] - d1[1] * r * s, p[1] + d1[0] * r * s];
-            let bevel = vec![p, o0, o1];
-            if join == 1 {
-                // Miter point: where the two offset edges meet.
-                let bis = [d0[0] - d1[0], d0[1] - d1[1]];
-                let bl = bis[0].hypot(bis[1]);
-                let cos_half = ((1.0 + d0[0] * d1[0] + d0[1] * d1[1]) * 0.5).max(0.0).sqrt();
-                let len = if cos_half > 1e-6 { r / cos_half } else { f64::INFINITY };
-                if bl > 1e-9 && len <= miter_limit * r {
-                    let m = [p[0] + (o0[0] + o1[0] - 2.0 * p[0]) * 0.5, p[1] + (o0[1] + o1[1] - 2.0 * p[1]) * 0.5];
-                    let ml = (m[0] - p[0]).hypot(m[1] - p[1]).max(1e-12);
-                    let tip = [p[0] + (m[0] - p[0]) / ml * len, p[1] + (m[1] - p[1]) / ml * len];
-                    out.push(vec![p, o0, tip, o1]);
-                    continue;
-                }
-            }
-            out.push(bevel);
-        }
-        if cap == 0 {
-            out.push(disc(pts[0]));
-            out.push(disc(pts[n - 1]));
-        }
-    }
-    out
-}
-
-/// Coverage (union, 4×4 samples per pixel) of convex polygons on a `w`×`h` grid.
-pub(crate) fn raster_convex(w: usize, h: usize, polys: &[Vec<[f64; 2]>]) -> Plane {
-    let mut out = Plane::new(w, h);
-    let inside = |poly: &[[f64; 2]], x: f64, y: f64| {
-        let n = poly.len();
-        let mut sign = 0.0;
-        for i in 0..n {
-            let (a, b) = (poly[i], poly[(i + 1) % n]);
-            let c = (b[0] - a[0]) * (y - a[1]) - (b[1] - a[1]) * (x - a[0]);
-            if c.abs() < 1e-12 {
-                continue;
-            }
-            if sign == 0.0 {
-                sign = c.signum();
-            } else if c.signum() != sign {
-                return false;
-            }
-        }
-        true
-    };
-    for poly in polys {
-        if poly.len() < 3 {
-            continue;
-        }
-        let (mut x0, mut y0, mut x1, mut y1) = (f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);
-        for p in poly {
-            x0 = x0.min(p[0]);
-            y0 = y0.min(p[1]);
-            x1 = x1.max(p[0]);
-            y1 = y1.max(p[1]);
-        }
-        let (xa, xb) = (x0.floor().max(0.0) as usize, (x1.ceil().max(0.0) as usize).min(w));
-        let (ya, yb) = (y0.floor().max(0.0) as usize, (y1.ceil().max(0.0) as usize).min(h));
-        for y in ya..yb {
-            for x in xa..xb {
-                let mut hit = 0;
-                for sy in 0..4 {
-                    for sx in 0..4 {
-                        if inside(poly, x as f64 + (sx as f64 + 0.5) / 4.0, y as f64 + (sy as f64 + 0.5) / 4.0) {
-                            hit += 1;
-                        }
-                    }
-                }
-                let v = &mut out.data[y * w + x];
-                *v = v.max(hit as f32 / 16.0);
-            }
-        }
-    }
-    out
-}
-
-fn scribble(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    match scribble_plan(ctx, &b) {
-        Some(plan) => draw_paint(&mut b, &plan),
-        None if scribble_style(ctx) == 1 => b.img = Image::new(b.img.width, b.img.height),
-        None => {}
-    }
-    b
-}
-
-fn scribble_plan(ctx: &EffectCtx, b: &Buf) -> Option<PaintPlan> {
-    let pr = ctx.params;
-    let which = pr.e("scribble");
-    let polys: Vec<_> = if which == 0 { mask_px(ctx, b, pr.f("mask").round().max(1.0) as usize).into_iter().collect() } else { all_masks_px(ctx, b) };
-    let polys: Vec<_> = polys.into_iter().filter(|p| p.0.len() >= 3).map(|(p, c, i)| (p, c, i && which == 2)).collect();
-    let style = scribble_style(ctx);
-    if polys.is_empty() {
-        return None;
-    }
-    let sc = b.scale;
-    let fill = pr.e("fillType");
-    let ew = pr.f("edgeOptions/edgeWidth").max(0.1) * sc;
-    let ang = pr.f("angle").to_radians();
-    let d = [ang.cos(), ang.sin()];
-    let n = [-d[1], d[0]];
-    let width = (pr.f("strokeWidth") * sc).max(0.1);
-    let curv = pr.f("strokeOptions/curviness") / 100.0;
-    let curv_var = pr.f("strokeOptions/curvinessVariation") / 100.0;
-    let spacing = (pr.f("strokeOptions/spacing") * sc).max(0.75).max(width * 0.25);
-    let spacing_var = pr.f("strokeOptions/spacingVariation") / 100.0;
-    let overlap = pr.f("strokeOptions/pathOverlap") / 100.0;
-    let overlap_var = pr.f("strokeOptions/pathOverlapVariation") / 100.0;
-    let start = pr.f("start").clamp(0.0, 100.0) / 100.0;
-    let end = pr.f("end").clamp(0.0, 100.0) / 100.0;
-    let sequential = pr.b("fillPathsSequentially");
-    let wiggle = pr.e("wiggleType");
-    let wps = pr.f("wigglesPerSecond").max(0.0);
-    let seed = pr.f("randomSeed") as i64 as u32 ^ ctx.seed;
-    let (step, frac) = match wiggle {
-        0 => (0u32, 0.0f32),
-        1 => ((ctx.time * wps).floor().max(0.0) as u32, 0.0),
-        _ => {
-            let u = (ctx.time * wps).max(0.0);
-            (u.floor() as u32, smoothstep(0.0, 1.0, u.fract() as f32))
-        }
-    };
-    let rnd = |i: u32, k: u32| {
-        let a = hash1(i, k.wrapping_mul(31).wrapping_add(step.wrapping_mul(7919)), seed) * 2.0 - 1.0;
-        if frac > 0.0 {
-            let c = hash1(i, k.wrapping_mul(31).wrapping_add((step + 1).wrapping_mul(7919)), seed) * 2.0 - 1.0;
-            a + (c - a) * frac
-        } else {
-            a
-        }
-    };
-    let groups: Vec<Vec<(Vec<[f64; 2]>, bool, bool)>> =
-        if which == 0 || sequential { vec![polys.clone()] } else { polys.iter().map(|p| vec![p.clone()]).collect() };
-    // Per group a zig-zag polyline (in buffer px).
-    let mut lines: Vec<Vec<Vec<[f64; 2]>>> = Vec::new();
-    let mut runs = Vec::new();
-    for (gi, g) in groups.iter().enumerate() {
-        let mut nmin = f64::INFINITY;
-        let mut nmax = f64::NEG_INFINITY;
-        for (pts, _, _) in g {
-            for q in pts {
-                let v = q[0] * n[0] + q[1] * n[1];
-                nmin = nmin.min(v);
-                nmax = nmax.max(v);
-            }
-        }
-        nmin -= ew;
-        nmax += ew;
-        // Chains of zig-zags: each run joins the nearest chain that ended on the previous
-        // scan line (so separate regions get separate strokes).
-        let mut chains: Vec<(Vec<[f64; 2]>, u32)> = Vec::new();
-        let mut s = nmin + spacing * 0.5;
-        let mut li = 0u32;
-        let reach = spacing * 3.0 + ew;
-        while s < nmax && li < 20_000 {
-            scan_runs(g, fill, ew, d, n, s, &mut runs);
-            for (ri, &(a, bb)) in runs.iter().enumerate() {
-                let k = (gi as u32) << 20 | ri as u32;
-                let ov = spacing * (overlap + overlap_var * rnd(li, k * 4) as f64 * 0.5).max(-0.45);
-                let ov2 = spacing * (overlap + overlap_var * rnd(li, k * 4 + 1) as f64 * 0.5).max(-0.45);
-                let (a, bb) = (a - ov, bb + ov2);
-                if bb <= a {
-                    continue;
-                }
-                let at = |t: f64| [d[0] * t + n[0] * s, d[1] * t + n[1] * s];
-                let (pa, pb) = (at(a), at(bb));
-                let dist = |p: [f64; 2], q: [f64; 2]| ((p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2)).sqrt();
-                let best = chains
-                    .iter()
-                    .enumerate()
-                    .filter(|(_, c)| li > 0 && c.1 == li - 1)
-                    .map(|(i, c)| {
-                        let last = *c.0.last().unwrap_or(&pa);
-                        (i, dist(last, pa).min(dist(last, pb)))
-                    })
-                    .filter(|&(_, dd)| dd < reach)
-                    .min_by(|x, y| x.1.total_cmp(&y.1));
-                match best {
-                    Some((ci, _)) => {
-                        let last = *chains[ci].0.last().unwrap_or(&pa);
-                        let (p0, p1, dir) = if dist(last, pa) <= dist(last, pb) { (pa, pb, -1.0) } else { (pb, pa, 1.0) };
-                        // Curved turn: an extra point pushed past the edge.
-                        let c = (curv + curv_var * rnd(li, k * 4 + 2) as f64 * 0.5).max(0.0);
-                        let mid = [(last[0] + p0[0]) * 0.5 + d[0] * dir * c * spacing, (last[1] + p0[1]) * 0.5 + d[1] * dir * c * spacing];
-                        let ch = &mut chains[ci];
-                        ch.0.extend([mid, p0, p1]);
-                        ch.1 = li;
-                    }
-                    None => chains.push((vec![pa, pb], li)),
-                }
-            }
-            s += spacing * (1.0 + spacing_var * rnd(li, 3) as f64 * 0.5).max(0.25);
-            li += 1;
-        }
-        lines.push(chains.into_iter().map(|(z, _)| if curv > 0.0 { chaikin(&z, 2) } else { z }).collect());
-    }
-    let r = width * 0.5;
-    // Start / End Apply To: all of a mask's strokes as one path, or each stroke on its own.
-    let each = pr.e("startEndApplyTo") == 1;
-    let mut parts: Vec<Vec<[f64; 2]>> = Vec::new();
-    for group in &lines {
-        let lens: Vec<f64> = group.iter().map(|l| poly_length(l, false)).collect();
-        let total: f64 = lens.iter().sum();
-        let (g0, g1) = (total * start, total * end);
-        let mut acc = 0.0;
-        for (l, len) in group.iter().zip(lens) {
-            let part =
-                if each { trim_poly(l, false, len * start, len * end) } else { trim_poly(l, false, (g0 - acc).clamp(0.0, len), (g1 - acc).clamp(0.0, len)) };
-            acc += len;
-            parts.push(part);
-        }
-    }
-    let cap = pr.e("edgeOptions/endCap");
-    let join = pr.e("edgeOptions/join");
-    let cov = if cap == 0 && join == 0 {
-        let mut segs = Vec::new();
-        for part in &parts {
-            poly_segs(part, false, r, 1.0, &mut segs);
-        }
-        Coverage::Segs { segs, hardness: 0.9 }
-    } else {
-        Coverage::Convex(stroke_outline(&parts, r, cap, join, pr.f("edgeOptions/miterLimit").max(1.0)))
-    };
-    Some(PaintPlan { cov, color: pr.color("color"), opacity: (pr.f("opacity") / 100.0) as f32, style })
-}
-
-// ---------------------------------------------------------------- Stroke
-
-fn stroke(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let plan = stroke_plan(ctx, &b);
-    draw_paint(&mut b, &plan);
-    b
-}
-
-fn stroke_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
-    let pr = ctx.params;
-    let all = pr.b("allMasks");
-    let polys: Vec<_> = if all { all_masks_px(ctx, b) } else { mask_px(ctx, b, pr.f("path").round() as usize).into_iter().collect() };
-    let style = pr.e("paintStyle");
-    let size = (pr.f("brushSize") * b.scale).max(0.1);
-    let r = size * 0.5;
-    let hard = pr.f("brushHardness") / 100.0;
-    let start = pr.f("start").clamp(0.0, 100.0) / 100.0;
-    let end = pr.f("end").clamp(0.0, 100.0) / 100.0;
-    let spacing = pr.f("spacing") / 100.0;
-    let sequential = pr.b("strokeSequentially");
-    let lens: Vec<f64> = polys.iter().map(|(p, c, _)| poly_length(p, *c)).collect();
-    let total: f64 = lens.iter().sum();
-    let mut segs = Vec::new();
-    let mut acc = 0.0;
-    for ((pts, closed, _), &len) in polys.iter().zip(&lens) {
-        let (s0, s1) = if all && sequential {
-            let (g0, g1) = (total * start, total * end);
-            ((g0 - acc).clamp(0.0, len), (g1 - acc).clamp(0.0, len))
-        } else {
-            (len * start, len * end)
-        };
-        acc += len;
-        if s1 <= s0 {
-            continue;
-        }
-        if spacing <= 0.5 {
-            let part = trim_poly(pts, *closed, s0, s1);
-            poly_segs(&part, false, r, 1.0, &mut segs);
-        } else {
-            let step = (size * spacing).max(0.5);
-            let mut s = s0;
-            while s <= s1 + 1e-9 && segs.len() < 200_000 {
-                let (q, _) = crate::util::poly_point_at(pts, *closed, s);
-                segs.push(Seg { a: q, b: q, r, v: 1.0 });
-                s += step;
-            }
-        }
-    }
-    PaintPlan { cov: Coverage::Segs { segs, hardness: hard }, color: pr.color("color"), opacity: (pr.f("opacity") / 100.0) as f32, style }
-}
-
-// ---------------------------------------------------------------- Vegas
-
-/// Marching-squares iso-contours of `pl` at `thr`, chained into polylines (closed flag).
-fn contours(pl: &Plane, thr: f32) -> Vec<(Vec<[f64; 2]>, bool)> {
-    use std::collections::HashMap;
-    let (w, h) = (pl.w, pl.h);
-    if w < 2 || h < 2 {
-        return Vec::new();
-    }
-    // Edge key: horizontal edge (x,y)-(x+1,y) = 2*(y*w+x), vertical (x,y)-(x,y+1) = 2*(y*w+x)+1.
-    let hk = |x: usize, y: usize| 2 * (y * w + x) as u64;
-    let vk = |x: usize, y: usize| 2 * (y * w + x) as u64 + 1;
-    let mut pos: HashMap<u64, [f64; 2]> = HashMap::new();
-    let mut adj: HashMap<u64, Vec<u64>> = HashMap::new();
-    let v = |x: usize, y: usize| pl.data[y * w + x];
-    let interp = |a: f32, b: f32| if (b - a).abs() > 1e-9 { ((thr - a) / (b - a)).clamp(0.0, 1.0) as f64 } else { 0.5 };
-    for y in 0..h - 1 {
-        for x in 0..w - 1 {
-            let (a, bb, c, d) = (v(x, y), v(x + 1, y), v(x + 1, y + 1), v(x, y + 1));
-            let idx = (a > thr) as u8 | ((bb > thr) as u8) << 1 | ((c > thr) as u8) << 2 | ((d > thr) as u8) << 3;
-            if idx == 0 || idx == 15 {
-                continue;
-            }
-            // Edge points (pixel centres at +0.5).
-            let top = (hk(x, y), [x as f64 + 0.5 + interp(a, bb), y as f64 + 0.5]);
-            let right = (vk(x + 1, y), [x as f64 + 1.5, y as f64 + 0.5 + interp(bb, c)]);
-            let bottom = (hk(x, y + 1), [x as f64 + 0.5 + interp(d, c), y as f64 + 1.5]);
-            let left = (vk(x, y), [x as f64 + 0.5, y as f64 + 0.5 + interp(a, d)]);
-            let pairs: &[(usize, usize)] = match idx {
-                1 | 14 => &[(3, 0)],
-                2 | 13 => &[(0, 1)],
-                3 | 12 => &[(3, 1)],
-                4 | 11 => &[(1, 2)],
-                5 => &[(3, 0), (1, 2)],
-                6 | 9 => &[(0, 2)],
-                7 | 8 => &[(3, 2)],
-                10 => &[(0, 1), (2, 3)],
-                _ => &[],
-            };
-            let e = [top, right, bottom, left];
-            for &(i, j) in pairs {
-                pos.insert(e[i].0, e[i].1);
-                pos.insert(e[j].0, e[j].1);
-                adj.entry(e[i].0).or_default().push(e[j].0);
-                adj.entry(e[j].0).or_default().push(e[i].0);
-            }
-        }
-    }
-    let mut keys: Vec<u64> = adj.keys().copied().collect();
-    keys.sort_unstable();
-    // Start open chains at endpoints (degree 1) first, then closed loops.
-    keys.sort_by_key(|k| adj[k].len() != 1);
-    let mut used: std::collections::HashSet<(u64, u64)> = std::collections::HashSet::new();
-    let mut out = Vec::new();
-    for &k0 in &keys {
-        for &first in &adj[&k0] {
-            if used.contains(&(k0.min(first), k0.max(first))) {
-                continue;
-            }
-            let mut chain = vec![pos[&k0]];
-            let (mut prev, mut cur) = (k0, first);
-            used.insert((prev.min(cur), prev.max(cur)));
-            let mut closed = false;
-            loop {
-                chain.push(pos[&cur]);
-                if cur == k0 {
-                    closed = true;
-                    chain.pop();
-                    break;
-                }
-                let next = adj[&cur].iter().copied().find(|&n| n != prev && !used.contains(&(cur.min(n), cur.max(n))));
-                match next {
-                    Some(n) => {
-                        used.insert((cur.min(n), cur.max(n)));
-                        prev = cur;
-                        cur = n;
-                    }
-                    None => break,
-                }
-            }
-            if chain.len() >= 2 {
-                out.push((chain, closed));
-            }
-        }
-    }
-    out
-}
-
-fn vegas(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let plan = vegas_plan(ctx, &b);
-    draw_paint(&mut b, &plan);
-    b
-}
-
-fn vegas_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
-    let pr = ctx.params;
-    let (w, h) = (b.img.width as usize, b.img.height as usize);
-    let sc = b.scale;
-    let paths: Vec<(Vec<[f64; 2]>, bool)> = if pr.e("stroke") == 1 {
-        mask_px(ctx, b, pr.f("path").round() as usize).map(|(p, c, _)| vec![(p, c)]).unwrap_or_default()
-    } else {
-        let src = layer_or_self(ctx, b, "inputLayer", true, pr.e("ifLayerSizesDiffer") == 1);
-        let ch = pr.e("channel");
-        let inv = pr.b("invertInput");
-        let mut pl = Plane::from_image(&src, |px| {
-            let (c, a) = unpremul(px);
-            let v = match ch {
-                1 => c[0],
-                2 => c[1],
-                3 => c[2],
-                4 => a,
-                _ => luminance(c[0], c[1], c[2]) * a,
-            };
-            if inv { 1.0 - v } else { v }
-        });
-        let blur = pr.f("preBlur") * sc;
-        if blur > 0.05 {
-            pl = gauss_plane(&pl, blur, blur);
-        }
-        let mut cs = contours(&pl, (pr.f("threshold") / 100.0) as f32);
-        // Simplify by tolerance (drop points closer than tol × size).
-        let tol = pr.f("tolerance").max(0.0) * (w.max(h) as f64) * 0.1;
-        if tol > 0.0 {
-            for (c, _) in cs.iter_mut() {
-                let mut keep: Vec<[f64; 2]> = Vec::with_capacity(c.len());
-                for &q in c.iter() {
-                    if keep.last().is_none_or(|l: &[f64; 2]| ((l[0] - q[0]).powi(2) + (l[1] - q[1]).powi(2)).sqrt() >= tol) {
-                        keep.push(q);
-                    }
-                }
-                *c = keep;
-            }
-        }
-        cs.sort_by(|a, b| poly_length(&b.0, b.1).total_cmp(&poly_length(&a.0, a.1)));
-        if pr.e("renderMode") == 1 {
-            let sel = (pr.f("selectedContour").round().max(1.0) as usize) - 1;
-            cs.into_iter().skip(sel).take(1).collect()
-        } else {
-            cs
-        }
-    };
-    let nseg = pr.f("segments").round().clamp(1.0, 1000.0) as usize;
-    // Shorter Contours Have Fewer Segments: segment count scales with contour length.
-    let fewer = pr.e("stroke") == 0 && pr.e("shorterContoursHave") == 1;
-    let longest = paths.iter().map(|(p, c)| poly_length(p, *c)).fold(0.0, f64::max);
-    let seg_len = pr.f("length").clamp(0.0, 1.0);
-    let bunched = pr.e("segmentDistribution") == 0;
-    let rot = pr.f("rotation") / 360.0;
-    let random_phase = pr.b("randomPhase");
-    let seed = pr.f("randomSeed") as i64 as u32 ^ ctx.seed;
-    let width = (pr.f("width") * sc).max(0.1);
-    let hard = pr.f("hardness").clamp(0.0, 1.0);
-    let (o0, om, o1, mp) = (pr.f("startOpacity") as f32, pr.f("midpointOpacity") as f32, pr.f("endOpacity") as f32, pr.f("midpointPosition").clamp(0.01, 0.99));
-    let mut segs = Vec::new();
-    for (ci, (pts, closed)) in paths.iter().enumerate() {
-        let len = poly_length(pts, *closed);
-        if len <= 0.0 {
-            continue;
-        }
-        let phase = rot + if random_phase { hash1(ci as u32, 1, seed) as f64 } else { 0.0 };
-        let nseg = if fewer && longest > 0.0 { ((nseg as f64 * len / longest).round() as usize).max(1) } else { nseg };
-        let each = len / nseg as f64 * seg_len;
-        for i in 0..nseg {
-            let base = if bunched { (i as f64 + (hash1(ci as u32, i as u32 + 7, seed) as f64 - 0.5) * 0.8) / nseg as f64 } else { i as f64 / nseg as f64 };
-            let s0 = (base + phase).rem_euclid(1.0) * len;
-            // Sub-sample the segment so opacity can ramp along it.
-            let sub = 12usize;
-            let mut prev: Option<[f64; 2]> = None;
-            for k in 0..=sub {
-                let f = k as f64 / sub as f64;
-                let mut s = s0 + each * f;
-                if *closed {
-                    s = s.rem_euclid(len);
-                } else if s > len {
-                    break;
-                }
-                let (q, _) = crate::util::poly_point_at(pts, *closed, s);
-                let op = if f < mp { o0 + (om - o0) * (f / mp) as f32 } else { om + (o1 - om) * ((f - mp) / (1.0 - mp)) as f32 };
-                if let Some(pv) = prev
-                    && ((pv[0] - q[0]).powi(2) + (pv[1] - q[1]).powi(2)) < (each * 0.5).powi(2) + 4.0
-                {
-                    segs.push(Seg { a: pv, b: q, r: width * 0.5, v: op.clamp(0.0, 1.0) });
-                }
-                prev = Some(q);
-            }
-        }
-    }
-    let style = match pr.e("blendMode") {
-        1 => 0,
-        2 => 3,
-        3 => 2,
-        _ => 1,
-    };
-    PaintPlan { cov: Coverage::Segs { segs, hardness: hard }, color: pr.color("color"), opacity: 1.0, style }
-}
-
-// ---------------------------------------------------------------- Write-on / Glue Gun
-
-/// Write-on draws a stroke along the animated Brush Position, as in After Effects: a dab every
-/// Brush Spacing seconds from the layer's start up to now, each one lasting Stroke Length
-/// seconds (0: for ever). The dabs' positions come from the host's parameters at their times;
-/// with Paint Time Properties ▸ Opacity or Brush Time Properties ▸ Size each dab keeps its own
-/// opacity or size, else the current ones apply to every dab. (Colour and hardness are one per
-/// stroke: the current ones.) Without a host (or dabs) the current dab draws. Deterministic.
-fn write_on(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let plan = write_on_plan(ctx, &b);
-    draw_paint(&mut b, &plan);
-    b
-}
-
-/// The most dabs one Write-on frame draws; longer strokes lay them further apart, joined.
-const WRITE_ON_MAX_DABS: i64 = 4096;
-
-fn write_on_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
-    let pr = ctx.params;
-    let own_opacity = pr.e("paintTimeProperties") == 1;
-    let own_size = matches!(pr.e("brushTimeProperties"), 1 | 3);
-    let opacity = |p: &Params| (p.f("brushOpacity") / 100.0).clamp(0.0, 1.0) as f32;
-    let radius = |p: &Params| (p.f("brushSize") * b.scale * 0.5).max(0.05);
-    let dab = |p: &Params| {
-        let q = b.to_px(p.v2("brushPosition"));
-        ([q.0, q.1], radius(if own_size { p } else { pr }), if own_opacity { opacity(p) } else { 1.0 })
-    };
-    let mut segs = vec![];
-    let t = ctx.time;
-    let spacing = pr.f("brushSpacing").max(0.001);
-    let life = pr.f("strokeLength").max(0.0);
-    if let Some(host) = ctx.env.host
-        && t.is_finite()
-        && t >= 0.0
-    {
-        let start = if life > 0.0 { (t - life).max(0.0) } else { 0.0 };
-        let k0 = (start / spacing - 1e-9).ceil().max(0.0) as i64;
-        let k1 = (t / spacing + 1e-9).floor().max(0.0) as i64;
-        let n = k1.saturating_sub(k0).saturating_add(1);
-        let stride = (n / WRITE_ON_MAX_DABS).saturating_add(1).max(1);
-        let mut prev: Option<[f64; 2]> = None;
-        let mut k = k0;
-        while k <= k1 {
-            let tk = k as f64 * spacing;
-            let at = if (tk - t).abs() < 1e-9 { Some(dab(pr)) } else { host.params_at(tk).map(|p| dab(&p)) };
-            if let Some((q, r, v)) = at {
-                // Dabs laid further apart than the brush spacing are joined into a line.
-                let a = if stride > 1 { prev.unwrap_or(q) } else { q };
-                segs.push(Seg { a, b: q, r, v });
-                prev = Some(q);
-            }
-            k = k.saturating_add(stride);
-        }
-    }
-    if segs.is_empty() {
-        let (q, r, v) = dab(pr);
-        segs.push(Seg { a: q, b: q, r, v });
-    }
-    PaintPlan {
-        cov: Coverage::Segs { segs, hardness: pr.f("brushHardness") / 100.0 },
-        color: pr.color("color"),
-        opacity: if own_opacity { 1.0 } else { opacity(pr) },
-        style: pr.e("paintStyle"),
-    }
-}
-
-fn glue_gun(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let pr = ctx.params;
-    let q = b.to_px(pr.v2("brushPosition"));
-    let rad = (pr.f("strokeWidth") * b.scale * 0.5).max(0.5);
-    let density = pr.f("density").max(0.0);
-    let refl = pr.f("reflection").to_radians();
-    let strength = (pr.f("strength") / 100.0) as f32;
-    let glue_only = pr.e("style") == 1;
-    let src = b.img.clone();
-    let light = [refl.cos() * 0.6, -refl.sin() * 0.6, 0.53];
-    let beads = (density.round() as usize).clamp(1, 32);
-    let seed = ctx.seed;
-    let centers: Vec<([f64; 2], f64)> = (0..beads)
-        .map(|i| {
-            let a = hash1(i as u32, 1, seed) as f64 * 2.0 * PI;
-            let d = if i == 0 { 0.0 } else { hash1(i as u32, 2, seed) as f64 * rad * 0.35 };
-            ([q.0 + a.cos() * d, q.1 + a.sin() * d], rad * (0.75 + 0.25 * hash1(i as u32, 3, seed) as f64))
-        })
-        .collect();
-    b.img.rows_mut().for_each(|(y, row)| {
-        for (x, px) in row.iter_mut().enumerate() {
-            let (fx, fy) = (x as f64 + 0.5, y as f64 + 0.5);
-            // Height field: union of hemispheres.
-            let mut best = (0.0f64, [0.0f64; 2], 1.0f64);
-            for &(c, r) in &centers {
-                let (dx, dy) = ((fx - c[0]) / r, (fy - c[1]) / r);
-                let d2 = dx * dx + dy * dy;
-                if d2 < 1.0 {
-                    let hgt = (1.0 - d2).sqrt();
-                    if hgt > best.0 {
-                        best = (hgt, [dx, dy], r);
-                    }
-                }
-            }
-            if best.0 <= 0.0 {
-                if glue_only {
-                    *px = [0.0; 4];
-                }
-                continue;
-            }
-            let nrm = [best.1[0], best.1[1], best.0];
-            let ndl = (nrm[0] * light[0] + nrm[1] * light[1] + nrm[2] * light[2]).max(0.0);
-            let spec = ndl.powi(24) as f32;
-            // Refraction: look through the bead.
-            let s = src.sample_bilinear_clamped(fx - nrm[0] * best.2 * 0.5 * strength as f64, fy - nrm[1] * best.2 * 0.5 * strength as f64);
-            let edge = smoothstep(0.0, 0.15, best.0 as f32);
-            let shade = 0.65 + 0.35 * ndl as f32;
-            let g = [s[0] * shade + spec, s[1] * shade + spec, s[2] * shade + spec, s[3].max(0.6)];
-            let gp = [g[0].min(g[3] + spec), g[1].min(g[3] + spec), g[2].min(g[3] + spec), g[3].min(1.0)];
-            let base = if glue_only { [0.0; 4] } else { *px };
-            *px = crate::util::lerp4(base, gp, edge * strength.clamp(0.0, 1.0).max(0.3));
-            px[3] = px[3].clamp(0.0, 1.0);
-        }
-    });
-    b
-}
-
-// ---------------------------------------------------------------- Paint Bucket
-
-/// Paint Bucket's filled region (1 inside) on `b`: the flood fill from the Fill Point over the
-/// layer's pixels (shared with the GPU compositor, which reads the layer back for it).
-pub fn paint_bucket_region(ctx: &EffectCtx, b: &Buf) -> Plane {
-    let pr = ctx.params;
-    let (w, h) = (b.img.width as usize, b.img.height as usize);
-    let fp = b.to_px(pr.v2("fillPoint"));
-    let (sx, sy) = (fp.0.floor() as i64, fp.1.floor() as i64);
-    let sel = pr.e("fillSelector");
-    let tol = (pr.f("tolerance") / 255.0) as f32;
-    let key = |p: Px| -> [f32; 4] {
-        let (c, a) = unpremul(p);
-        match sel {
-            1 => [c[0], c[1], c[2], 0.0],
-            2 => [0.0, 0.0, 0.0, if a <= 1e-3 { 0.0 } else { 1.0 }],
-            3 | 4 => [0.0, 0.0, 0.0, a],
-            _ => p,
-        }
-    };
-    let mut region = Plane::new(w, h);
-    if sx >= 0 && sy >= 0 && (sx as usize) < w && (sy as usize) < h {
-        let seed = key(b.img.data[sy as usize * w + sx as usize]);
-        let within = |i: usize| {
-            let k = key(b.img.data[i]);
-            if sel == 2 {
-                return k[3] == seed[3];
-            }
-            (0..4).all(|j| (k[j] - seed[j]).abs() <= tol + 1e-6)
-        };
-        let mut seen = vec![false; w * h];
-        let mut stack = vec![(sx as usize, sy as usize)];
-        while let Some((x, y)) = stack.pop() {
-            let row = y * w;
-            if seen[row + x] || !within(row + x) {
-                continue;
-            }
-            let mut l = x;
-            while l > 0 && !seen[row + l - 1] && within(row + l - 1) {
-                l -= 1;
-            }
-            let mut r = x;
-            while r + 1 < w && !seen[row + r + 1] && within(row + r + 1) {
-                r += 1;
-            }
-            for i in l..=r {
-                seen[row + i] = true;
-                region.data[row + i] = 1.0;
-                if y > 0 && !seen[row - w + i] {
-                    stack.push((i, y - 1));
-                }
-                if y + 1 < h && !seen[row + w + i] {
-                    stack.push((i, y + 1));
-                }
-            }
-        }
-    }
-    region
-}
-
-fn paint_bucket(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let pr = ctx.params;
-    let (w, h) = (b.img.width as usize, b.img.height as usize);
-    if w == 0 || h == 0 {
-        return b;
-    }
-    let region = paint_bucket_region(ctx, &b);
-    if pr.b("viewThreshold") {
-        b.img.data.par_iter_mut().zip(region.data.par_iter()).for_each(|(px, &v)| *px = [v, v, v, 1.0]);
-        return b;
-    }
-    let sc = b.scale;
-    let mut cov = match pr.e("stroke") {
-        1 => {
-            let s = pr.f("featherSoftness") * sc * 0.5;
-            if s > 0.05 { gauss_plane(&region, s, s) } else { region.clone() }
-        }
-        2 => morph_frac(&region, pr.f("spreadRadius") * sc, true),
-        3 => morph_frac(&region, pr.f("spreadRadius") * sc, false),
-        4 => {
-            let r = pr.f("strokeWidth") * sc;
-            let out = morph_frac(&region, r * 0.5, true);
-            let inn = morph_frac(&region, r * 0.5, false);
-            out.zip_map(&inn, |a, b| (a - b).max(0.0))
-        }
-        _ => gauss_plane(&region, 0.5, 0.5),
-    };
-    if pr.e("stroke") == 0 {
-        // Antialias: keep the hard interior, soften only the boundary.
-        cov = cov.zip_map(&region, |a, r| if r > 0.0 { a.max(0.5) } else { a });
-    }
-    let color = pr.color("color");
-    let op = (pr.f("opacity") / 100.0) as f32;
-    let mode = pr.e("blendingMode");
-    b.img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
-        let k = (c * op * color[3]).clamp(0.0, 1.0);
-        if k <= 0.0 {
-            if mode == 9 {
-                *px = [0.0; 4];
-            }
-            return;
-        }
-        let (dc, da) = unpremul(*px);
-        let fc = [color[0], color[1], color[2]];
-        let mixed = match mode {
-            1 => [dc[0] + fc[0], dc[1] + fc[1], dc[2] + fc[2]],
-            2 => [dc[0] * fc[0], dc[1] * fc[1], dc[2] * fc[2]],
-            3 => [1.0 - (1.0 - dc[0]) * (1.0 - fc[0]), 1.0 - (1.0 - dc[1]) * (1.0 - fc[1]), 1.0 - (1.0 - dc[2]) * (1.0 - fc[2])],
-            4..=7 => {
-                let (dh, ds, dl) = rgb_to_hsl(dc[0], dc[1], dc[2]);
-                let (fh, fs, fl) = rgb_to_hsl(fc[0], fc[1], fc[2]);
-                let (r, g, bl) = match mode {
-                    4 => hsl_to_rgb(fh, ds, dl),
-                    5 => hsl_to_rgb(dh, fs, dl),
-                    6 => hsl_to_rgb(fh, fs, dl),
-                    _ => hsl_to_rgb(dh, ds, fl),
-                };
-                [r, g, bl]
-            }
-            _ => fc,
-        };
-        *px = match mode {
-            8 => over(premul(fc, k), *px),
-            9 => premul(fc, k),
-            0 => over(*px, premul(fc, k)),
-            _ => {
-                if da <= 1e-6 {
-                    return;
-                }
-                let c3 = crate::util::lerp3(dc, mixed, k);
-                premul(c3, da)
-            }
-        };
-    });
-    b
-}
-
-// ---------------------------------------------------------------- Eyedropper Fill
-
-fn eyedropper_fill(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let pr = ctx.params;
-    let fill = eyedropper_color(ctx, &b);
-    let keep_alpha = pr.b("maintainOriginalAlpha");
-    let blend = (pr.f("blendWithOriginal") / 100.0) as f32;
-    b.img.data.par_iter_mut().for_each(|px| {
-        let a = if keep_alpha { px[3] } else { fill[3] };
-        let f = premul([fill[0], fill[1], fill[2]], a);
-        *px = crate::util::lerp4(f, *px, blend);
-    });
-    b
-}
-
-/// Eyedropper Fill's sampled colour (straight RGB, alpha) from the layer's pixels (shared with
-/// the GPU compositor, which reads the layer back for it).
-pub fn eyedropper_color(ctx: &EffectCtx, b: &Buf) -> Px {
-    let pr = ctx.params;
-    let (w, h) = (b.img.width as i64, b.img.height as i64);
-    let c = b.to_px(pr.v2("samplePoint"));
-    let r = (pr.f("sampleRadius") * b.scale).max(0.0);
-    let mode = pr.e("averagePixelColors");
-    let (cx, cy) = (c.0.floor() as i64, c.1.floor() as i64);
-    let ri = r.ceil() as i64;
-    let mut acc = [0.0f64; 4];
-    let mut n = 0.0f64;
-    for y in (cy - ri).max(0)..=(cy + ri).min(h - 1) {
-        for x in (cx - ri).max(0)..=(cx + ri).min(w - 1) {
-            if ((x - cx).pow(2) + (y - cy).pow(2)) as f64 > r * r + 0.5 {
-                continue;
-            }
-            let px = b.img.data[(y * w + x) as usize];
-            match mode {
-                0 => {
-                    if px[3] > 1e-4 {
-                        let (s, _) = unpremul(px);
-                        for k in 0..3 {
-                            acc[k] += s[k] as f64;
-                        }
-                        acc[3] += 1.0;
-                        n += 1.0;
-                    }
-                }
-                1 => {
-                    let (s, _) = unpremul(px);
-                    for k in 0..3 {
-                        acc[k] += s[k] as f64;
-                    }
-                    acc[3] += 1.0;
-                    n += 1.0;
-                }
-                2 => {
-                    for k in 0..3 {
-                        acc[k] += px[k] as f64;
-                    }
-                    acc[3] += 1.0;
-                    n += 1.0;
-                }
-                _ => {
-                    for k in 0..4 {
-                        acc[k] += px[k] as f64;
-                    }
-                    n += 1.0;
-                }
-            }
-        }
-    }
-    if n > 0.0 {
-        if mode == 3 {
-            let a = (acc[3] / n) as f32;
-            let s = if a > 1e-6 { [(acc[0] / n) as f32 / a, (acc[1] / n) as f32 / a, (acc[2] / n) as f32 / a] } else { [0.0; 3] };
-            [s[0], s[1], s[2], a]
-        } else {
-            [(acc[0] / n) as f32, (acc[1] / n) as f32, (acc[2] / n) as f32, 1.0]
-        }
-    } else {
-        [0.0, 0.0, 0.0, 0.0]
-    }
-}
-
-// ---------------------------------------------------------------- CC Threads
-
-fn threads(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let pr = ctx.params;
-    let sc = b.scale;
-    let tw = (pr.f("width") * sc).max(1.0);
-    let th = (pr.f("height") * sc).max(1.0);
-    let overlaps = pr.f("overlaps").round().clamp(1.0, 20.0) as i64;
-    let ang = pr.f("direction").to_radians();
-    let (sn, cs) = ang.sin_cos();
-    let c = b.to_px(pr.v2("center"));
-    let coverage = (pr.f("coverage") / 100.0).clamp(0.0, 1.0);
-    let shadow = (pr.f("shadowing") / 100.0) as f32;
-    let texture = (pr.f("texture") / 100.0) as f32;
-    let src = b.img.clone();
-    let to_px = |u: f64, v: f64| (c.0 + u * cs - v * sn, c.1 + u * sn + v * cs);
-    b.img.rows_mut().for_each(|(y, row)| {
-        for (x, px) in row.iter_mut().enumerate() {
-            let (dx, dy) = (x as f64 + 0.5 - c.0, y as f64 + 0.5 - c.1);
-            let u = dx * cs + dy * sn;
-            let v = -dx * sn + dy * cs;
-            let (ci, cj) = ((u / tw).floor() as i64, (v / th).floor() as i64);
-            let (fu, fv) = (u / tw - ci as f64, v / th - cj as f64);
-            // Horizontal thread j occupies the band |fv-0.5| < coverage/2; vertical thread i the
-            // band |fu-0.5| < coverage/2.
-            let in_h = (fv - 0.5).abs() < coverage * 0.5;
-            let in_v = (fu - 0.5).abs() < coverage * 0.5;
-            // Twill: horizontal is on top when (i + j) mod (2·overlaps) < overlaps.
-            let h_top = (ci + cj).rem_euclid(2 * overlaps) < overlaps;
-            let which = match (in_h, in_v) {
-                (true, true) => Some(h_top),
-                (true, false) => Some(true),
-                (false, true) => Some(false),
-                _ => None,
-            };
-            let Some(horizontal) = which else {
-                *px = [0.0; 4];
-                continue;
-            };
-            // Thread colour: the source sampled along the thread centre line.
-            let (sx, sy) = if horizontal { to_px(u, (cj as f64 + 0.5) * th) } else { to_px((ci as f64 + 0.5) * tw, v) };
-            let s = src.sample_bilinear_clamped(sx, sy);
-            // Round profile across the thread + darkening where it dives under its neighbour.
-            let across = if horizontal { (fv - 0.5) / (coverage * 0.5).max(1e-6) } else { (fu - 0.5) / (coverage * 0.5).max(1e-6) };
-            let along = if horizontal { fu } else { fv };
-            let profile = (1.0 - across * across).max(0.0).sqrt() as f32;
-            let dive = 1.0 - (along - 0.5).abs() as f32 * 2.0;
-            let shade = 1.0 - shadow * (1.0 - profile) * 0.8 - shadow * 0.25 * (1.0 - dive) * if horizontal == h_top { 0.0 } else { 1.0 };
-            let fib =
-                if texture > 0.0 { 1.0 - texture * 0.3 * hash1((along * 64.0) as u32, (across * 8.0 + 8.0) as u32, ci as u32 ^ (cj as u32) << 8) } else { 1.0 };
-            let k = (shade * fib).max(0.0);
-            *px = [s[0] * k, s[1] * k, s[2] * k, s[3]];
-        }
-    });
-    b
-}
-
-// ---------------------------------------------------------------- Audio Spectrum / Waveform
-
-/// In-place iterative radix-2 FFT (`re`, `im` lengths a power of two).
-pub(crate) fn fft(re: &mut [f64], im: &mut [f64]) {
-    let n = re.len();
-    if n < 2 {
-        return;
-    }
-    let mut j = 0;
-    for i in 1..n {
-        let mut bit = n >> 1;
-        while j & bit != 0 {
-            j ^= bit;
-            bit >>= 1;
-        }
-        j |= bit;
-        if i < j {
-            re.swap(i, j);
-            im.swap(i, j);
-        }
-    }
-    let mut len = 2;
-    while len <= n {
-        let ang = -2.0 * PI / len as f64;
-        let (ws, wc) = ang.sin_cos();
-        for start in (0..n).step_by(len) {
-            let (mut cr, mut ci) = (1.0, 0.0);
-            for k in 0..len / 2 {
-                let (a, bb) = (start + k, start + k + len / 2);
-                let tr = re[bb] * cr - im[bb] * ci;
-                let ti = re[bb] * ci + im[bb] * cr;
-                re[bb] = re[a] - tr;
-                im[bb] = im[a] - ti;
-                re[a] += tr;
-                im[a] += ti;
-                let ncr = cr * wc - ci * ws;
-                ci = cr * ws + ci * wc;
-                cr = ncr;
-            }
-        }
-        len <<= 1;
-    }
-}
-
-const AUDIO_RATE: u32 = 48_000;
-
-/// Fetch mono (or one channel) samples of the audio layer around the current time.
-fn audio_window(ctx: &EffectCtx, dur_ms: f64, offset_ms: f64, channel: u32) -> Option<Vec<f64>> {
-    let id = ctx.params.get("audioLayer")?.as_layer()?;
-    let host = ctx.env.host?;
-    let dur = (dur_ms / 1000.0).max(0.001);
-    let frames = ((dur * AUDIO_RATE as f64) as usize).clamp(16, 1 << 16);
-    let start = ctx.env.comp_time + offset_ms / 1000.0 - dur * 0.5;
-    let s = host.audio(id, start, frames, AUDIO_RATE)?;
-    Some(
-        (0..frames)
-            .map(|i| {
-                let (l, r) = (*s.get(2 * i).unwrap_or(&0.0) as f64, *s.get(2 * i + 1).unwrap_or(&0.0) as f64);
-                match channel {
-                    1 => l,
-                    2 => r,
-                    _ => (l + r) * 0.5,
-                }
-            })
-            .collect(),
-    )
-}
-
-/// The drawing baseline: a polyline in buffer px (mask path or start→end line), sampled at
-/// parameter u∈[0,1] → (point, unit normal).
-struct Baseline {
-    pts: Vec<[f64; 2]>,
-    closed: bool,
-    len: f64,
-    polar: bool,
-    center: [f64; 2],
-    radius: f64,
-}
-
-impl Baseline {
-    fn new(ctx: &EffectCtx, b: &Buf) -> Baseline {
-        let pr = ctx.params;
-        let polar = pr.b("usePolarPath");
-        let (pts, closed) = match mask_px(ctx, b, pr.f("path").round() as usize) {
-            Some((p, c, _)) if !polar => (p, c),
-            _ => {
-                let s = b.to_px(pr.v2("startPoint"));
-                let e = b.to_px(pr.v2("endPoint"));
-                (vec![[s.0, s.1], [e.0, e.1]], false)
-            }
-        };
-        let len = poly_length(&pts, closed);
-        let center = pts[0];
-        let radius = if pts.len() > 1 { ((pts[1][0] - pts[0][0]).powi(2) + (pts[1][1] - pts[0][1]).powi(2)).sqrt() } else { 1.0 };
-        Baseline { pts, closed, len, polar, center, radius }
-    }
-    fn at(&self, u: f64) -> ([f64; 2], [f64; 2]) {
-        if self.polar {
-            let a = u * 2.0 * PI - PI * 0.5;
-            let (s, c) = a.sin_cos();
-            return ([self.center[0] + c * self.radius * 0.5, self.center[1] + s * self.radius * 0.5], [c, s]);
-        }
-        let (q, d) = crate::util::poly_point_at(&self.pts, self.closed, u * self.len);
-        (q, [d[1], -d[0]])
-    }
-}
-
-/// Draw line/dot marks with core (inside colour) and soft halo (outside colour).
-fn draw_marks(b: &mut Buf, segs_core: &[Seg], thickness: f64, softness: f64, inside: [f32; 4], outside: [f32; 4], composite: bool) {
-    let (w, h) = (b.img.width as usize, b.img.height as usize);
-    let core = raster_segs(w, h, segs_core, 1.0);
-    let halo_segs: Vec<Seg> = segs_core.iter().map(|s| Seg { r: s.r + thickness * softness.max(0.0) + 0.5, ..*s }).collect();
-    let halo = if softness > 0.0 { raster_segs(w, h, &halo_segs, 0.0) } else { core.clone() };
-    b.img.data.par_iter_mut().enumerate().for_each(|(i, px)| {
-        let (c, hl) = (core.data[i], halo.data[i]);
-        let a = c.max(hl);
-        let base = if composite { *px } else { [0.0; 4] };
-        if a <= 0.0 {
-            *px = base;
-            return;
-        }
-        let t = if a > 0.0 { c / a } else { 0.0 };
-        let col = crate::util::lerp3([outside[0], outside[1], outside[2]], [inside[0], inside[1], inside[2]], t);
-        *px = over(base, premul(col, a));
-    });
-}
-
-/// Audio Spectrum / Audio Waveform, shared with the GPU compositor (effectcraft-gpu `fx_gen2`):
-/// the marks (the audio analysis runs on the CPU) and how [`draw_marks`] colours them.
-#[derive(Clone, Debug)]
-pub struct MarksPlan {
-    pub segs: Vec<Seg>,
-    pub thickness: f64,
-    pub softness: f64,
-    pub inside: [f32; 4],
-    pub outside: [f32; 4],
-    pub composite: bool,
-}
-
-/// [`MarksPlan`] of Audio Spectrum or Audio Waveform on `b`'s geometry (`None` = no audio:
-/// the layer passes through).
-pub fn marks_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option<MarksPlan> {
-    match id {
-        "ec.generate.audiospectrum" => spectrum_plan(ctx, b),
-        "ec.generate.audiowaveform" => waveform_plan(ctx, b),
-        _ => None,
-    }
-}
-
-fn marks(ctx: &EffectCtx, segs: Vec<Seg>, thick: f64, soft: f64) -> MarksPlan {
-    let pr = ctx.params;
-    MarksPlan {
-        segs,
-        thickness: thick,
-        softness: soft * 2.0,
-        inside: pr.color("insideColor"),
-        outside: pr.color("outsideColor"),
-        composite: pr.b("compositeOnOriginal"),
-    }
-}
-
-fn audio_spectrum(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    if let Some(m) = spectrum_plan(ctx, &b) {
-        draw_marks(&mut b, &m.segs, m.thickness, m.softness, m.inside, m.outside, m.composite);
-    }
-    b
-}
-
-fn audio_waveform(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    if let Some(m) = waveform_plan(ctx, &b) {
-        draw_marks(&mut b, &m.segs, m.thickness, m.softness, m.inside, m.outside, m.composite);
-    }
-    b
-}
-
-fn compute_fft_mags(samples: &[f64]) -> (usize, f64, Vec<f64>) {
-    let m = samples.len();
-    let n = m.next_power_of_two().max(64);
-    let mut re = vec![0.0; n];
-    let mut im = vec![0.0; n];
-    let denom = (m.max(2) - 1) as f64;
-    for (i, s) in samples.iter().enumerate() {
-        let w = 0.5 - 0.5 * (2.0 * PI * i as f64 / denom).cos();
-        if let Some(r) = re.get_mut(i) {
-            *r = s * w;
-        }
-    }
-    fft(&mut re, &mut im);
-    let hz_per_bin = AUDIO_RATE as f64 / n as f64;
-    let scale = 4.0 / m.max(1) as f64;
-    let num_bins = n / 2 + 1;
-    let mut mags = Vec::with_capacity(num_bins);
-    for k in 0..num_bins {
-        let r = re.get(k).copied().unwrap_or(0.0);
-        let im_val = im.get(k).copied().unwrap_or(0.0);
-        let mag = (r * r + im_val * im_val).sqrt() * scale;
-        mags.push(mag);
-    }
-    (n, hz_per_bin, mags)
-}
-
-fn spectrum_plan(ctx: &EffectCtx, b: &Buf) -> Option<MarksPlan> {
-    let pr = ctx.params;
-    let samples = audio_window(ctx, pr.f("audioDuration"), pr.f("audioOffset"), 0)?;
-    let (_n, hz_per_bin, mags) = compute_fft_mags(&samples);
-
-    let bands = pr.f("frequencyBands").round().clamp(1.0, 4096.0) as usize;
-    let f0 = pr.f("startFrequency").max(0.0);
-    let f1 = pr.f("endFrequency").max(f0 + 1.0);
-    let max_bin = mags.len().saturating_sub(1);
-
-    let get_band_mag = |fc: f64| -> f64 {
-        if mags.is_empty() || hz_per_bin <= 0.0 {
-            return 0.0;
-        }
-        let k_float = (fc / hz_per_bin).clamp(0.0, max_bin as f64);
-        let k0 = (k_float.floor() as usize).min(max_bin.saturating_sub(1));
-        let k1 = (k0 + 1).min(max_bin);
-        let frac = (k_float - k0 as f64).clamp(0.0, 1.0);
-        let m0 = mags.get(k0).copied().unwrap_or(0.0);
-        let m1 = mags.get(k1).copied().unwrap_or(0.0);
-        m0 * (1.0 - frac) + m1 * frac
-    };
-
-    let max_h = pr.f("maximumHeight") * b.scale;
-    let thick = (pr.f("thickness") * b.scale).max(0.1);
-    let soft = pr.f("softness") / 100.0;
-    let disp = pr.e("displayOptions");
-    let side = pr.e("sideOptions");
-    let base = Baseline::new(ctx, b);
-    let mut tops = Vec::with_capacity(bands);
-    let mut segs = Vec::new();
-    for i in 0..bands {
-        let u = if bands > 1 { i as f64 / (bands - 1) as f64 } else { 0.5 };
-        let fc = f0 + (f1 - f0) * u;
-        let v = get_band_mag(fc);
-        let hgt = if (v * max_h).is_finite() { (v * max_h).clamp(0.0, max_h.max(0.0)) } else { 0.0 };
-        let (q, nrm) = base.at(u);
-        let (ua, ub) = match side {
-            0 => (0.0, hgt),
-            1 => (-hgt, 0.0),
-            _ => (-hgt, hgt),
-        };
-        let pa = [q[0] + nrm[0] * ua, q[1] + nrm[1] * ua];
-        let pb = [q[0] + nrm[0] * ub, q[1] + nrm[1] * ub];
-        match disp {
-            0 => segs.push(Seg { a: pa, b: pb, r: thick * 0.5, v: 1.0 }),
-            _ => tops.push((pa, pb)),
-        }
-    }
-    if disp == 1 {
-        for w2 in tops.windows(2) {
-            segs.push(Seg { a: w2[0].1, b: w2[1].1, r: thick * 0.5, v: 1.0 });
-            if side == 2 {
-                segs.push(Seg { a: w2[0].0, b: w2[1].0, r: thick * 0.5, v: 1.0 });
-            }
-        }
-    } else if disp == 2 {
-        for &(pa, pb) in &tops {
-            segs.push(Seg { a: pb, b: pb, r: thick * 0.5, v: 1.0 });
-            if side == 2 {
-                segs.push(Seg { a: pa, b: pa, r: thick * 0.5, v: 1.0 });
-            }
-        }
-    }
-    Some(marks(ctx, segs, thick, soft))
-}
-
-fn waveform_plan(ctx: &EffectCtx, b: &Buf) -> Option<MarksPlan> {
-    let pr = ctx.params;
-    let samples = audio_window(ctx, pr.f("audioDuration"), pr.f("audioOffset"), pr.e("waveformOptions"))?;
-    let count = pr.f("displayedSamples").round().clamp(2.0, 4096.0) as usize;
-    let max_h = pr.f("maximumHeight") * b.scale;
-    let thick = (pr.f("thickness") * b.scale).max(0.1);
-    let soft = pr.f("softness") / 100.0;
-    let disp = pr.e("displayOptions");
-    let base = Baseline::new(ctx, b);
-    let m = samples.len();
-    let mut pts = Vec::with_capacity(count);
-    let mut segs = Vec::new();
-    for i in 0..count {
-        let u = i as f64 / (count - 1) as f64;
-        let a = ((u * (m - 1) as f64) as usize).min(m - 1);
-        let bnd = (((i + 1) as f64 / count as f64 * (m - 1) as f64) as usize).clamp(a, m - 1);
-        // Peak with sign of the window for a stable digital display.
-        let (mut lo, mut hi) = (0.0f64, 0.0f64);
-        for s in &samples[a..=bnd] {
-            lo = lo.min(*s);
-            hi = hi.max(*s);
-        }
-        let (q, nrm) = base.at(u);
-        match disp {
-            0 => segs.push(Seg {
-                a: [q[0] + nrm[0] * lo * max_h, q[1] + nrm[1] * lo * max_h],
-                b: [q[0] + nrm[0] * hi * max_h, q[1] + nrm[1] * hi * max_h],
-                r: thick * 0.5,
-                v: 1.0,
-            }),
-            _ => {
-                let v = samples[a] * max_h;
-                pts.push([q[0] + nrm[0] * v, q[1] + nrm[1] * v]);
-            }
-        }
-    }
-    if disp == 1 {
-        poly_segs(&pts, false, thick * 0.5, 1.0, &mut segs);
-    } else if disp == 2 {
-        segs.extend(pts.iter().map(|&q| Seg { a: q, b: q, r: thick * 0.5, v: 1.0 }));
-    }
-    Some(marks(ctx, segs, thick, soft))
-}
-
-// ---------------------------------------------------------------- registry
-
-pub fn specs() -> Vec<EffectSpec> {
-    let ang = || ParamUi::Angle;
-    let check = |id: &'static str, name: &'static str, v: bool| p(id, name, Value::Bool(v), ParamUi::Checkbox);
-    let paint_style = || popup(&["On Original Image", "On Transparent", "Reveal Original Image"]);
-    let mask_idx = |id: &'static str, name: &'static str, d: f64| p(id, name, num(d), ParamUi::Mask);
-    let display = || popup(&["Digital", "Analog lines", "Analog dots"]);
-    vec![
-        spec(
-            "ec.generate.fractal",
-            "Fractal",
-            vec![
-                p("setChoice", "Set Choice", Value::Enum(0), popup(&FRACTAL_SETS)),
-                p("equation", "Equation", Value::Enum(0), popup(&["z = z^2 + c", "z = z^3 + c", "z = z^4 + c"])),
-                p("mandelbrot/mandelbrotX", "X (Real)", num(-0.74), slider(-2.0, 2.0, -2.0, 2.0, 4)),
-                p("mandelbrot/mandelbrotY", "Y (Imaginary)", num(0.15), slider(-2.0, 2.0, -2.0, 2.0, 4)),
-                p("mandelbrot/mandelbrotMagnification", "Magnification", num(0.0), slider(-5.0, 30.0, -5.0, 30.0, 2)),
-                p("mandelbrot/mandelbrotEscapeLimit", "Escape Limit", num(4.0), slider(1.0, 1000.0, 1.0, 100.0, 1)),
-                p("julia/juliaX", "X (Real)", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
-                p("julia/juliaY", "Y (Imaginary)", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
-                p("julia/juliaMagnification", "Magnification", num(0.0), slider(-5.0, 30.0, -5.0, 30.0, 2)),
-                p("julia/juliaEscapeLimit", "Escape Limit", num(4.0), slider(1.0, 1000.0, 1.0, 100.0, 1)),
-                p("postInversionOffset/postInversionX", "X Offset", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
-                p("postInversionOffset/postInversionY", "Y Offset", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
-                check("fractalColor/overlay", "Overlay", false),
-                check("fractalColor/transparency", "Transparency", false),
-                p("fractalColor/palette", "Palette", Value::Enum(0), popup(&FRACTAL_PALETTES)),
-                p("fractalColor/hue", "Hue", num(0.0), ang()),
-                p("fractalColor/cycleSteps", "Cycle Steps", num(32.0), slider(1.0, 1000.0, 1.0, 256.0, 0)),
-                p("fractalColor/cycleOffset", "Cycle Offset", num(0.0), ang()),
-                check("fractalColor/edgeHighlight", "Edge Highlight", false),
-                p("highQualitySettings/samplingMethod", "Oversample Method", Value::Enum(0), popup(&FRACTAL_OVERSAMPLE)),
-                p("highQualitySettings/samplingFactor", "Oversample Factor", num(2.0), slider(1.0, 9.0, 1.0, 9.0, 0)),
-            ],
-            fractal,
-        ),
-        spec(
-            "ec.generate.scribble",
-            "Scribble",
-            vec![
-                p("scribble", "Scribble", Value::Enum(0), popup(&["Single Mask", "All Masks", "All Masks Using Modes"])),
-                mask_idx("mask", "Mask", 1.0),
-                p("fillType", "Fill Type", Value::Enum(0), popup(&["Inside", "Centered Edge", "Inside Edge", "Outside Edge", "Left Edge", "Right Edge"])),
-                p("edgeOptions/edgeWidth", "Edge Width", num(10.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
-                p("edgeOptions/endCap", "End Cap", Value::Enum(0), popup(&END_CAPS)),
-                p("edgeOptions/join", "Join", Value::Enum(0), popup(&JOINS)),
-                p("edgeOptions/miterLimit", "Miter Limit", num(4.0), slider(1.0, 100.0, 1.0, 20.0, 1)),
-                p("color", "Color", col(1.0, 0.0, 0.0), ParamUi::Color),
-                p("opacity", "Opacity", num(100.0), pct()),
-                p("angle", "Angle", num(45.0), ang()),
-                p("strokeWidth", "Stroke Width", num(2.0), slider(0.1, 50.0, 0.1, 50.0, 1)),
-                p("strokeOptions/curviness", "Curviness", num(50.0), pct()),
-                p("strokeOptions/curvinessVariation", "Curviness Variation", num(50.0), pct()),
-                p("strokeOptions/spacing", "Spacing", num(5.0), slider(0.1, 100.0, 0.1, 50.0, 1)),
-                p("strokeOptions/spacingVariation", "Spacing Variation", num(50.0), pct()),
-                p("strokeOptions/pathOverlap", "Path Overlap", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
-                p("strokeOptions/pathOverlapVariation", "Path Overlap Variation", num(50.0), pct()),
-                p("start", "Start", num(0.0), pct()),
-                p("end", "End", num(100.0), pct()),
-                p("startEndApplyTo", "Start/End Apply To", Value::Enum(0), popup(&["All Strokes", "Each Stroke"])),
-                check("fillPathsSequentially", "Fill Paths Sequentially", true),
-                p("wiggleType", "Wiggle Type", Value::Enum(1), popup(&["Static", "Jumpy", "Smooth"])),
-                p("wigglesPerSecond", "Wiggles/Second", num(5.0), slider(0.0, 100.0, 0.0, 30.0, 2)),
-                p("randomSeed", "Random Seed", num(1.0), slider(0.0, 10000.0, 0.0, 100.0, 0)),
-                p("composite", "Composite", Value::Enum(1), popup(&["On Original Image", "On Transparent", "Reveal Original Image"])),
-            ],
-            scribble,
-        ),
-        spec(
-            "ec.generate.stroke",
-            "Stroke",
-            vec![
-                mask_idx("path", "Path", 1.0),
-                check("allMasks", "All Masks", false),
-                check("strokeSequentially", "Stroke Sequentially", true),
-                p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("brushSize", "Brush Size", num(2.0), slider(0.0, 50.0, 0.0, 50.0, 1)),
-                p("brushHardness", "Brush Hardness", num(75.0), pct()),
-                p("opacity", "Opacity", num(100.0), pct()),
-                p("start", "Start", num(0.0), pct()),
-                p("end", "End", num(100.0), pct()),
-                p("spacing", "Spacing", num(15.0), slider(0.0, 100.0, 0.0, 100.0, 1)),
-                p("paintStyle", "Paint Style", Value::Enum(0), paint_style()),
-            ],
-            stroke,
-        ),
-        spec(
-            "ec.generate.vegas",
-            "Vegas",
-            vec![
-                p("stroke", "Stroke", Value::Enum(0), popup(&["Image Contours", "Mask/Path"])),
-                p("inputLayer", "Image Contours: Input Layer", Value::Layer(None), ParamUi::Layer),
-                check("invertInput", "Image Contours: Invert Input", false),
-                p("ifLayerSizesDiffer", "Image Contours: If Layer Sizes Differ", Value::Enum(0), popup(&["Center", "Stretch to Fit"])),
-                p("channel", "Image Contours: Channel", Value::Enum(0), popup(&["Intensity", "Red", "Green", "Blue", "Alpha"])),
-                p("threshold", "Image Contours: Threshold", num(50.0), pct()),
-                p("preBlur", "Image Contours: Pre-Blur", num(1.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
-                p("tolerance", "Image Contours: Tolerance", num(0.01), slider(0.0, 1.0, 0.0, 0.1, 3)),
-                p("renderMode", "Image Contours: Render", Value::Enum(0), popup(&["All Contours", "Selected Contour"])),
-                p("selectedContour", "Image Contours: Selected Contour", num(1.0), slider(1.0, 1000.0, 1.0, 20.0, 0)),
-                p("shorterContoursHave", "Image Contours: Shorter Contours Have", Value::Enum(0), popup(&["Same Number of Segments", "Fewer Segments"])),
-                mask_idx("path", "Mask/Path: Path", 1.0),
-                p("segments", "Segments: Segments", num(32.0), slider(1.0, 1000.0, 1.0, 100.0, 0)),
-                p("length", "Segments: Length", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("segmentDistribution", "Segments: Segment Distribution", Value::Enum(0), popup(&["Bunched", "Even"])),
-                p("rotation", "Segments: Rotation", num(0.0), ang()),
-                check("randomPhase", "Segments: Random Phase", false),
-                p("randomSeed", "Segments: Random Seed", num(1.0), slider(1.0, 10000.0, 1.0, 100.0, 0)),
-                p("blendMode", "Rendering: Blend Mode", Value::Enum(1), popup(&["Transparent", "Over", "Under", "Stencil"])),
-                p("color", "Rendering: Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("width", "Rendering: Width", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
-                p("hardness", "Rendering: Hardness", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("startOpacity", "Rendering: Start Opacity", num(1.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("midpointOpacity", "Rendering: Mid-point Opacity", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("midpointPosition", "Rendering: Mid-point Position", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("endOpacity", "Rendering: End Opacity", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
-            ],
-            vegas,
-        ),
-        spec(
-            "ec.generate.writeon",
-            "Write-on",
-            vec![
-                p("brushPosition", "Brush Position", pt(0.5, 0.5), ParamUi::Point),
-                p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("brushSize", "Brush Size", num(6.0), slider(0.0, 50.0, 0.0, 50.0, 1)),
-                p("brushHardness", "Brush Hardness", num(75.0), pct()),
-                p("brushOpacity", "Brush Opacity", num(100.0), pct()),
-                p("strokeLength", "Stroke Length (secs)", num(0.0), slider(0.0, 30.0, 0.0, 30.0, 1)),
-                p("brushSpacing", "Brush Spacing (secs)", num(0.001), slider(0.001, 5.0, 0.001, 5.0, 3)),
-                p("paintTimeProperties", "Paint Time Properties", Value::Enum(0), popup(&["None", "Opacity", "Color"])),
-                p("brushTimeProperties", "Brush Time Properties", Value::Enum(0), popup(&["None", "Size", "Hardness", "Size & Hardness"])),
-                p("paintStyle", "Paint Style", Value::Enum(0), paint_style()),
-            ],
-            write_on,
-        ),
-        spec(
-            "ec.generate.paintbucket",
-            "Paint Bucket",
-            vec![
-                p("fillPoint", "Fill Point", pt(0.5, 0.5), ParamUi::Point),
-                p("fillSelector", "Fill Selector", Value::Enum(0), popup(&["Color & Alpha", "Straight Color", "Transparency", "Opacity", "Alpha Channel"])),
-                p("tolerance", "Tolerance", num(10.0), slider(0.0, 255.0, 0.0, 100.0, 1)),
-                check("viewThreshold", "View Threshold", false),
-                p("stroke", "Stroke", Value::Enum(0), popup(&["Antialias", "Feather", "Spread", "Choke", "Stroke"])),
-                p("featherSoftness", "Feather Softness", num(10.0), slider(0.0, 100.0, 0.0, 50.0, 1)),
-                p("spreadRadius", "Spread Radius", num(3.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
-                p("strokeWidth", "Stroke Width", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
-                p("color", "Color", col(1.0, 0.0, 0.0), ParamUi::Color),
-                p("opacity", "Opacity", num(100.0), pct()),
-                p(
-                    "blendingMode",
-                    "Blending Mode",
-                    Value::Enum(0),
-                    popup(&["Normal", "Add", "Multiply", "Screen", "Hue", "Saturation", "Color", "Luminosity", "Behind", "Fill Only"]),
-                ),
-            ],
-            paint_bucket,
-        ),
-        spec(
-            "ec.generate.eyedropperfill",
-            "Eyedropper Fill",
-            vec![
-                p("samplePoint", "Sample Point", pt(0.5, 0.5), ParamUi::Point),
-                p("sampleRadius", "Sample Radius", num(0.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
-                p("averagePixelColors", "Average Pixel Colors", Value::Enum(0), popup(&["Skip Empty", "All", "All Premultiplied", "Including Alpha"])),
-                check("maintainOriginalAlpha", "Maintain Original Alpha", false),
-                p("blendWithOriginal", "Blend With Original", num(0.0), pct()),
-            ],
-            eyedropper_fill,
-        ),
-        spec(
-            "ec.generate.ccgluegun",
-            "CC Glue Gun",
-            vec![
-                p("brushPosition", "Brush Position", pt(0.5, 0.5), ParamUi::Point),
-                p("strokeWidth", "Stroke Width", num(25.0), slider(0.0, 500.0, 0.0, 100.0, 1)),
-                p("density", "Density", num(5.0), slider(0.0, 32.0, 0.0, 32.0, 1)),
-                p("timeSpan", "Time Span (sec)", num(1.0), slider(0.0, 60.0, 0.0, 10.0, 2)),
-                p("reflection", "Reflection", num(45.0), ang()),
-                p("strength", "Strength", num(100.0), pct()),
-                p("style", "Style", Value::Enum(0), popup(&["Over Layer", "Glue Only"])),
-            ],
-            glue_gun,
-        ),
-        spec(
-            "ec.generate.ccthreads",
-            "CC Threads",
-            vec![
-                p("width", "Width", num(50.0), slider(1.0, 1000.0, 1.0, 200.0, 1)),
-                p("height", "Height", num(50.0), slider(1.0, 1000.0, 1.0, 200.0, 1)),
-                p("overlaps", "Overlaps", num(1.0), slider(1.0, 20.0, 1.0, 10.0, 0)),
-                p("direction", "Direction", num(0.0), ang()),
-                p("center", "Center", pt(0.5, 0.5), ParamUi::Point),
-                p("coverage", "Coverage", num(80.0), pct()),
-                p("shadowing", "Shadowing", num(50.0), pct()),
-                p("texture", "Texture", num(10.0), pct()),
-            ],
-            threads,
-        ),
-        spec(
-            "ec.generate.audiospectrum",
-            "Audio Spectrum",
-            vec![
-                p("audioLayer", "Audio Layer", Value::Layer(None), ParamUi::Layer),
-                p("startPoint", "Start Point", pt(0.1, 0.5), ParamUi::Point),
-                p("endPoint", "End Point", pt(0.9, 0.5), ParamUi::Point),
-                mask_idx("path", "Path", 0.0),
-                check("usePolarPath", "Use Polar Path", false),
-                p("startFrequency", "Start Frequency", num(20.0), slider(1.0, 20000.0, 1.0, 2000.0, 0)),
-                p("endFrequency", "End Frequency", num(2000.0), slider(1.0, 20000.0, 1.0, 10000.0, 0)),
-                p("frequencyBands", "Frequency bands", num(64.0), slider(1.0, 4096.0, 1.0, 256.0, 0)),
-                p("maximumHeight", "Maximum Height", num(50.0), slider(0.0, 10000.0, 0.0, 500.0, 1)),
-                p("audioDuration", "Audio Duration (milliseconds)", num(90.0), slider(1.0, 30000.0, 1.0, 1000.0, 1)),
-                p("audioOffset", "Audio Offset (milliseconds)", num(0.0), slider(-30000.0, 30000.0, -1000.0, 1000.0, 1)),
-                p("thickness", "Thickness", num(3.0), slider(0.0, 1000.0, 0.0, 50.0, 2)),
-                p("softness", "Softness", num(50.0), pct()),
-                p("insideColor", "Inside Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("outsideColor", "Outside Color", col(0.2, 0.4, 1.0), ParamUi::Color),
-                check("blendOverlappingColors", "Blend Overlapping Colors", true),
-                p("hueInterpolation", "Hue Interpolation", num(0.0), ang()),
-                check("dynamicHuePhase", "Dynamic Hue Phase", false),
-                check("colorSymmetry", "Color Symmetry", false),
-                p("displayOptions", "Display Options", Value::Enum(0), display()),
-                p("sideOptions", "Side Options", Value::Enum(0), popup(&["Side A", "Side B", "Side A & B"])),
-                check("durationAveraging", "Duration Averaging", false),
-                check("compositeOnOriginal", "Composite On Original", false),
-            ],
-            audio_spectrum,
-        ),
-        spec(
-            "ec.generate.audiowaveform",
-            "Audio Waveform",
-            vec![
-                p("audioLayer", "Audio Layer", Value::Layer(None), ParamUi::Layer),
-                p("startPoint", "Start Point", pt(0.1, 0.5), ParamUi::Point),
-                p("endPoint", "End Point", pt(0.9, 0.5), ParamUi::Point),
-                mask_idx("path", "Path", 0.0),
-                check("usePolarPath", "Use Polar Path", false),
-                p("displayedSamples", "Displayed Samples", num(200.0), slider(2.0, 4096.0, 2.0, 1000.0, 0)),
-                p("maximumHeight", "Maximum Height", num(100.0), slider(0.0, 10000.0, 0.0, 500.0, 1)),
-                p("audioDuration", "Audio Duration (milliseconds)", num(200.0), slider(1.0, 30000.0, 1.0, 1000.0, 1)),
-                p("audioOffset", "Audio Offset (milliseconds)", num(0.0), slider(-30000.0, 30000.0, -1000.0, 1000.0, 1)),
-                p("thickness", "Thickness", num(2.0), slider(0.0, 1000.0, 0.0, 50.0, 2)),
-                p("softness", "Softness", num(10.0), pct()),
-                p("randomSeed", "Random Seed (Analog)", num(1.0), slider(1.0, 10000.0, 1.0, 100.0, 0)),
-                p("insideColor", "Inside Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("outsideColor", "Outside Color", col(0.2, 0.4, 1.0), ParamUi::Color),
-                p("waveformOptions", "Waveform Options", Value::Enum(0), popup(&["Mono", "Left", "Right"])),
-                p("displayOptions", "Display Options", Value::Enum(1), display()),
-                check("compositeOnOriginal", "Composite On Original", false),
-            ],
-            audio_waveform,
-        ),
-    ]
-}
+mod audio;
+mod common;
+mod fill;
+mod fractal;
+mod paths;
+mod raster;
+mod registry;
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{EffectEnv, EffectHost, LayerPixels, MaskShape, Params};
+pub(crate) use audio::fft;
+pub use audio::{MarksPlan, marks_plan};
+pub use fill::{eyedropper_color, paint_bucket_region};
+#[cfg(test)]
+use paths::contours;
+pub use paths::{Coverage, PaintPlan, paint_plan, plan_reads_pixels, scribble_style};
+pub use raster::{Seg, poly_segs};
+pub(crate) use raster::{mask_px, raster_segs};
+#[cfg(test)]
+pub(crate) use raster::{raster_convex, stroke_outline};
+pub use registry::specs;
 
-    /// Run with point defaults scaled to the layer size.
-    pub(crate) fn run_env(id: &str, set: &[(&str, Value)], img: Image, time: f64, env: EffectEnv) -> Buf {
-        let s = crate::find(id).unwrap();
-        let ls = [img.width as f64, img.height as f64];
-        let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-        for p in &s.params {
-            if let (ParamUi::Point, Value::Vec2(v)) = (&p.ui, &p.default) {
-                params.values.insert(p.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
-            }
-        }
-        for (k, v) in set {
-            assert!(params.values.contains_key(*k), "{id}: unknown {k}");
-            params.values.insert(k.to_string(), v.clone());
-        }
-        let ctx = EffectCtx { params: &params, time, layer_size: ls, seed: 3, adjustment: false, env };
-        crate::apply(s, &ctx, Buf { img, offset: [0.0, 0.0], scale: 1.0 })
-    }
-
-    fn run(id: &str, set: &[(&str, Value)], img: Image) -> Buf {
-        run_env(id, set, img, 0.5, EffectEnv::default())
-    }
-
-    fn square_mask() -> Vec<MaskShape> {
-        vec![MaskShape { name: "Mask 1".into(), points: vec![[16.0, 16.0], [48.0, 16.0], [48.0, 48.0], [16.0, 48.0]], closed: true, inverted: false }]
-    }
-
-    fn alpha_sum(img: &Image, x0: usize, y0: usize, x1: usize, y1: usize) -> f32 {
-        let mut s = 0.0;
-        for y in y0..y1 {
-            for x in x0..x1 {
-                s += img.data[y * img.width as usize + x][3];
-            }
-        }
-        s
-    }
-
-    #[test]
-    fn audio_spectrum_linear_frequency_and_linear_amplitude() {
-        let host = Tone; // Tone produces 440 Hz
-        let env = EffectEnv { host: Some(&host), comp_time: 1.0, ..Default::default() };
-        let img = Image::new(200, 100);
-        let out = run_env(
-            "ec.generate.audiospectrum",
-            &[
-                ("audioLayer", Value::Layer(Some(1))),
-                ("startPoint", Value::Vec2([0.0, 50.0])),
-                ("endPoint", Value::Vec2([200.0, 50.0])),
-                ("startFrequency", num(20.0)),
-                ("endFrequency", num(2000.0)),
-                ("frequencyBands", num(100.0)),
-                ("maximumHeight", num(40.0)),
-                ("thickness", num(2.0)),
-                ("softness", num(0.0)),
-            ],
-            img,
-            1.0,
-            env,
-        );
-        // Verify 440 Hz tone produces a peak above baseline, while high frequencies have zero bar height
-        let peak_zone = alpha_sum(&out.img, 36, 10, 48, 48);
-        let high_zone = alpha_sum(&out.img, 120, 10, 150, 48);
-        let silent_zone = alpha_sum(&out.img, 170, 10, 195, 48);
-        assert!(peak_zone > 5.0, "peak zone has energy: {peak_zone}");
-        assert!(peak_zone > high_zone * 2.0, "linear peak is distinctly taller than far frequencies: {peak_zone} vs {high_zone}");
-        assert_eq!(silent_zone, 0.0, "silent end has zero height, not boosted by dB scale");
-    }
-
-    #[test]
-    fn fractal_deterministic_and_has_inside_set() {
-        let img = Image::new(64, 48);
-        let a = run("ec.generate.fractal", &[], img.clone());
-        let b = run("ec.generate.fractal", &[], img.clone());
-        assert_eq!(a.img.data, b.img.data);
-        // The default view contains the main cardioid (black, opaque) and escaped (coloured) points.
-        assert!(a.img.data.iter().any(|p| p[3] > 0.99 && p[0] + p[1] + p[2] < 0.01));
-        assert!(a.img.data.iter().any(|p| p[0] + p[1] + p[2] > 0.3));
-        let t = run("ec.generate.fractal", &[("fractalColor/transparency", Value::Bool(true))], img);
-        assert!(t.img.data.iter().any(|p| p[3] == 0.0));
-    }
-
-    #[test]
-    fn fractal_palettes_and_set_choices() {
-        let img = Image::new(64, 48);
-        // Solid Color: only the inside of the set is drawn; Transparency flips it.
-        let solid = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(3))], img.clone());
-        assert!(solid.img.data.iter().any(|p| p[3] == 0.0) && solid.img.data.iter().any(|p| p[3] > 0.99 && p[0] > 0.9));
-        let flipped = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(3)), ("fractalColor/transparency", Value::Bool(true))], img.clone());
-        for (a, b) in solid.img.data.iter().zip(&flipped.img.data) {
-            assert!((a[3] > 0.5) != (b[3] > 0.5) || (a[3] - 0.5).abs() < 0.49);
-        }
-        // Black And White: escaped pixels are pure black or white (away from supersampled edges).
-        let bw = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(2)), ("highQualitySettings/samplingFactor", num(1.0))], img.clone());
-        assert!(bw.img.data.iter().all(|p| p[0] == p[1] && p[1] == p[2] && (p[0] == 0.0 || p[0] == 1.0)));
-        // Mandelbrot Over Julia depends on the Julia centre.
-        let o1 = run("ec.generate.fractal", &[("setChoice", Value::Enum(2)), ("julia/juliaX", num(0.3))], img.clone());
-        let o2 = run("ec.generate.fractal", &[("setChoice", Value::Enum(2)), ("julia/juliaX", num(-0.2))], img.clone());
-        assert_ne!(o1.img.data, o2.img.data);
-        let plain = run("ec.generate.fractal", &[("julia/juliaX", num(0.3))], img);
-        assert_ne!(o1.img.data, plain.img.data);
-    }
-
-    #[test]
-    fn scribble_fills_mask_and_animates() {
-        let masks = square_mask();
-        let env = EffectEnv { masks: &masks, ..Default::default() };
-        let img = Image::filled(64, 64, [0.0, 0.0, 1.0, 1.0]);
-        let a = run_env("ec.generate.scribble", &[], img.clone(), 0.5, env);
-        let b = run_env("ec.generate.scribble", &[], img.clone(), 0.5, env);
-        assert_eq!(a.img.data, b.img.data);
-        let inside = alpha_sum(&a.img, 18, 18, 46, 46);
-        let outside = alpha_sum(&a.img, 0, 0, 10, 64);
-        assert!(inside > 100.0 && outside < 1.0, "{inside} {outside}");
-        let c = run_env("ec.generate.scribble", &[], img.clone(), 1.5, env);
-        assert_ne!(a.img.data, c.img.data, "jumpy wiggle changes over time");
-        let s = run_env("ec.generate.scribble", &[("wiggleType", Value::Enum(0))], img.clone(), 0.5, env);
-        let s2 = run_env("ec.generate.scribble", &[("wiggleType", Value::Enum(0))], img.clone(), 3.5, env);
-        assert_eq!(s.img.data, s2.img.data, "static wiggle is constant");
-        let half = run_env("ec.generate.scribble", &[("end", num(50.0))], img, 0.5, env);
-        assert!(alpha_sum(&half.img, 0, 0, 64, 64) < alpha_sum(&a.img, 0, 0, 64, 64));
-    }
-
-    #[test]
-    fn scribble_edge_types() {
-        let masks = square_mask();
-        let env = EffectEnv { masks: &masks, ..Default::default() };
-        let img = Image::new(64, 64);
-        let o = run_env("ec.generate.scribble", &[("fillType", Value::Enum(3)), ("edgeOptions/edgeWidth", num(6.0))], img, 0.5, env);
-        // Outside edge: paint near the border outside, nothing in the centre.
-        assert!(alpha_sum(&o.img, 26, 26, 38, 38) < 0.5);
-        assert!(alpha_sum(&o.img, 8, 8, 16, 56) > 5.0);
-    }
-
-    #[test]
-    fn stroke_draws_along_mask() {
-        let masks = square_mask();
-        let env = EffectEnv { masks: &masks, ..Default::default() };
-        let img = Image::new(64, 64);
-        let a = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("paintStyle", Value::Enum(1))], img.clone(), 0.0, env);
-        assert!(a.img.get(32, 16)[3] > 0.9, "on the top edge");
-        assert!(a.img.get(32, 32)[3] < 0.01, "centre empty");
-        let b = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("end", num(25.0))], img.clone(), 0.0, env);
-        assert!(b.img.get(32, 16)[3] > 0.9 && b.img.get(48, 32)[3] < 0.01, "first quarter only");
-        let d = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("spacing", num(300.0))], img, 0.0, env);
-        assert!(alpha_sum(&d.img, 0, 0, 64, 64) < alpha_sum(&a.img, 0, 0, 64, 64), "spaced dabs");
-        // No masks: unchanged.
-        let src = Image::filled(8, 8, [0.2, 0.3, 0.4, 1.0]);
-        assert_eq!(run("ec.generate.stroke", &[], src.clone()).img.data, src.data);
-    }
-
-    #[test]
-    fn vegas_traces_contours() {
-        let mut img = Image::new(64, 64);
-        for y in 16..48 {
-            for x in 16..48 {
-                img.set(x, y, [1.0, 1.0, 1.0, 1.0]);
-            }
-        }
-        let a = run(
-            "ec.generate.vegas",
-            &[("blendMode", Value::Enum(0)), ("length", num(1.0)), ("midpointOpacity", num(1.0)), ("endOpacity", num(1.0))],
-            img.clone(),
-        );
-        let b = run(
-            "ec.generate.vegas",
-            &[("blendMode", Value::Enum(0)), ("length", num(1.0)), ("midpointOpacity", num(1.0)), ("endOpacity", num(1.0))],
-            img.clone(),
-        );
-        assert_eq!(a.img.data, b.img.data);
-        assert!(alpha_sum(&a.img, 14, 14, 50, 50) > 50.0, "edges drawn");
-        assert!(alpha_sum(&a.img, 26, 26, 38, 38) < 0.5, "interior untouched");
-        let r = run("ec.generate.vegas", &[("blendMode", Value::Enum(0)), ("rotation", num(90.0))], img);
-        assert_ne!(r.img.data, a.img.data);
-    }
-
-    #[test]
-    fn contours_of_square_are_closed() {
-        let mut pl = Plane::new(20, 20);
-        for y in 5..15 {
-            for x in 5..15 {
-                pl.data[y * 20 + x] = 1.0;
-            }
-        }
-        let c = contours(&pl, 0.5);
-        assert_eq!(c.len(), 1);
-        assert!(c[0].1);
-        let l = poly_length(&c[0].0, true);
-        assert!((l - 40.0).abs() < 4.0, "{l}");
-    }
-
-    #[test]
-    fn write_on_and_glue_gun_draw_at_brush() {
-        let img = Image::new(32, 32);
-        let a = run("ec.generate.writeon", &[], img.clone());
-        assert!(a.img.get(16, 16)[3] > 0.9 && a.img.get(2, 2)[3] == 0.0);
-        assert_eq!(a.img.data, run("ec.generate.writeon", &[], img.clone()).img.data);
-        let src = Image::filled(32, 32, [0.5, 0.2, 0.1, 1.0]);
-        let g = run("ec.generate.ccgluegun", &[], src.clone());
-        assert_eq!(g.img.data, run("ec.generate.ccgluegun", &[], src.clone()).img.data);
-        assert_ne!(g.img.get(16, 16), src.get(16, 16));
-        assert_eq!(g.img.get(0, 0), src.get(0, 0));
-    }
-
-    /// #536: an animated Brush Position draws a stroke that stays (Stroke Length 0), expires
-    /// after Stroke Length, and lays its dabs Brush Spacing seconds apart.
-    #[test]
-    fn write_on_accumulates_a_stroke_along_the_animated_brush() {
-        // Brush Position from [8, 16] at 0 s to [56, 16] at 1 s; red, hard, 6 px.
-        struct Brush(Vec<(&'static str, Value)>);
-        impl Brush {
-            fn at(&self, t: f64) -> Vec<(&'static str, Value)> {
-                let mut v = self.0.clone();
-                v.push(("brushPosition", Value::Vec2([8.0 + 48.0 * t.clamp(0.0, 1.0), 16.0])));
-                v
-            }
-        }
-        impl EffectHost for Brush {
-            fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {
-                None
-            }
-            fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
-                None
-            }
-            fn params_at(&self, t: f64) -> Option<Params> {
-                let s = crate::find("ec.generate.writeon").unwrap();
-                let mut p = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-                for (k, v) in self.at(t) {
-                    p.values.insert(k.to_string(), v);
-                }
-                Some(p)
-            }
-        }
-        let render = |extra: &[(&'static str, Value)], t: f64| {
-            let mut set = vec![("color", col(1.0, 0.0, 0.0)), ("brushSize", num(6.0)), ("brushHardness", num(100.0)), ("brushSpacing", num(0.05))];
-            set.extend(extra.iter().cloned());
-            let host = Brush(set);
-            let env = EffectEnv { host: Some(&host), ..Default::default() };
-            let at = host.at(t);
-            run_env("ec.generate.writeon", &at, Image::new(64, 32), t, env).img
-        };
-        let on = |img: &Image, x: i64| img.get(x, 16)[3] > 0.9;
-        let half = render(&[], 0.5);
-        assert!(on(&half, 8) && on(&half, 20) && on(&half, 32) && !on(&half, 44) && !on(&half, 56));
-        let end = render(&[], 1.0);
-        assert!([8, 20, 32, 44, 56].iter().all(|x| on(&end, *x)));
-        // Stroke Length 0.25 s: only the last quarter second's trail.
-        let trail = render(&[("strokeLength", num(0.25))], 1.0);
-        assert!(!on(&trail, 8) && !on(&trail, 32) && on(&trail, 48) && on(&trail, 56));
-        // Brush Spacing 0.5 s: three separate marks.
-        let spaced = render(&[("brushSpacing", num(0.5))], 1.0);
-        assert!(on(&spaced, 8) && on(&spaced, 32) && on(&spaced, 56) && !on(&spaced, 20) && !on(&spaced, 44));
-        // Paint Time Properties ▸ Opacity: each dab keeps the opacity it was laid with.
-        struct Fade;
-        impl EffectHost for Fade {
-            fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {
-                None
-            }
-            fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
-                None
-            }
-            fn params_at(&self, t: f64) -> Option<Params> {
-                let mut p = Brush(vec![("brushHardness", num(100.0)), ("brushSpacing", num(0.05)), ("paintTimeProperties", Value::Enum(1))]).params_at(t)?;
-                p.values.insert("brushOpacity".into(), num(if t < 0.5 { 100.0 } else { 20.0 }));
-                Some(p)
-            }
-        }
-        let p1 = Fade.params_at(1.0).unwrap();
-        let set: Vec<(&str, Value)> = p1.values.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();
-        let faded = run_env("ec.generate.writeon", &set, Image::new(64, 32), 1.0, EffectEnv { host: Some(&Fade), ..Default::default() }).img;
-        assert!(faded.get(8, 16)[3] > 0.9 && (faded.get(56, 16)[3] - 0.2).abs() < 0.05, "{:?} {:?}", faded.get(8, 16), faded.get(56, 16));
-    }
-
-    #[test]
-    fn paint_bucket_fills_enclosed_region_only() {
-        let mut img = Image::filled(32, 32, [1.0, 1.0, 1.0, 1.0]);
-        for i in 8..24 {
-            for &(x, y) in &[(i, 8), (i, 23), (8, i), (23, i)] {
-                img.set(x, y, [0.0, 0.0, 0.0, 1.0]);
-            }
-        }
-        let out = run("ec.generate.paintbucket", &[], img.clone());
-        let inside = out.img.get(16, 16);
-        assert!(inside[0] > 0.99 && inside[1] < 0.01, "{inside:?}");
-        assert_eq!(out.img.get(2, 2), [1.0, 1.0, 1.0, 1.0], "outside untouched");
-        assert_eq!(out.img.get(8, 16), [0.0, 0.0, 0.0, 1.0], "border untouched");
-        assert_eq!(out.img.data, run("ec.generate.paintbucket", &[], img).img.data);
-    }
-
-    #[test]
-    fn eyedropper_fill_uses_sample() {
-        let mut img = Image::filled(16, 16, [0.0, 0.0, 1.0, 1.0]);
-        img.set(8, 8, [1.0, 0.0, 0.0, 1.0]);
-        let out = run("ec.generate.eyedropperfill", &[], img.clone());
-        assert!(out.img.data.iter().all(|p| *p == [1.0, 0.0, 0.0, 1.0]));
-        let blended = run("ec.generate.eyedropperfill", &[("blendWithOriginal", num(100.0))], img.clone());
-        assert_eq!(blended.img.data, img.data);
-    }
-
-    #[test]
-    fn threads_weave_is_deterministic_and_gappy() {
-        let src = Image::filled(64, 64, [0.4, 0.6, 0.2, 1.0]);
-        let a = run("ec.generate.ccthreads", &[("width", num(16.0)), ("height", num(16.0)), ("coverage", num(50.0))], src.clone());
-        assert_eq!(a.img.data, run("ec.generate.ccthreads", &[("width", num(16.0)), ("height", num(16.0)), ("coverage", num(50.0))], src).img.data);
-        assert!(a.img.data.iter().any(|p| p[3] == 0.0), "gaps between threads");
-        assert!(a.img.data.iter().any(|p| p[3] > 0.99), "threads");
-    }
-
-    struct Tone;
-    impl EffectHost for Tone {
-        fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {
-            None
-        }
-        fn audio(&self, _: u64, start: f64, frames: usize, rate: u32) -> Option<Vec<f32>> {
-            Some(
-                (0..frames)
-                    .flat_map(|i| {
-                        let t = start + i as f64 / rate as f64;
-                        let v = (2.0 * PI * 440.0 * t).sin() as f32 * 0.8;
-                        [v, v]
-                    })
-                    .collect(),
-            )
-        }
-    }
-
-    #[test]
-    fn audio_effects_without_audio_pass_through() {
-        let src = Image::filled(16, 16, [0.3, 0.3, 0.3, 1.0]);
-        for id in ["ec.generate.audiospectrum", "ec.generate.audiowaveform"] {
-            assert_eq!(run(id, &[], src.clone()).img.data, src.data, "{id}");
-        }
-    }
-
-    #[test]
-    fn audio_effects_draw_with_host() {
-        let host = Tone;
-        let env = EffectEnv { host: Some(&host), comp_time: 1.0, ..Default::default() };
-        let img = Image::new(96, 64);
-        for id in ["ec.generate.audiospectrum", "ec.generate.audiowaveform"] {
-            let a = run_env(id, &[("audioLayer", Value::Layer(Some(1)))], img.clone(), 1.0, env);
-            let b = run_env(id, &[("audioLayer", Value::Layer(Some(1)))], img.clone(), 1.0, env);
-            assert_eq!(a.img.data, b.img.data, "{id}");
-            assert!(alpha_sum(&a.img, 0, 0, 96, 64) > 10.0, "{id} drew nothing");
-        }
-    }
-
-    #[test]
-    fn fft_finds_tone() {
-        let n = 256;
-        let mut re: Vec<f64> = (0..n).map(|i| (2.0 * PI * 8.0 * i as f64 / n as f64).cos()).collect();
-        let mut im = vec![0.0; n];
-        fft(&mut re, &mut im);
-        let mags: Vec<f64> = (0..n / 2).map(|k| (re[k] * re[k] + im[k] * im[k]).sqrt()).collect();
-        let peak = mags.iter().enumerate().max_by(|a, b| a.1.total_cmp(b.1)).unwrap().0;
-        assert_eq!(peak, 8);
-    }
-
-    #[test]
-    fn stroke_outline_caps_and_joins() {
-        let line = vec![vec![[10.0, 10.0], [30.0, 10.0]]];
-        let cov = |cap: u32| raster_convex(40, 20, &stroke_outline(&line, 3.0, cap, 0, 4.0));
-        // Round caps reach 3 px past the ends (on the axis), Butt stops there, Projecting is square.
-        let (round, butt, proj) = (cov(0), cov(1), cov(2));
-        assert!(round.get(8, 10) > 0.9 && butt.get(8, 10) < 0.1 && proj.get(8, 10) > 0.9);
-        assert!(proj.get(7, 7) > 0.9 && round.get(7, 7) < 0.5, "square corner");
-        // A right-angle turn: Miter fills the outer corner, Bevel cuts it.
-        let corner = vec![vec![[5.0, 30.0], [30.0, 30.0], [30.0, 5.0]]];
-        let j = |join: u32| raster_convex(40, 40, &stroke_outline(&corner, 3.0, 1, join, 4.0));
-        let (miter, bevel) = (j(1), j(2));
-        assert!(miter.get(32, 32) > 0.9 && bevel.get(32, 32) < 0.1, "{} {}", miter.get(32, 32), bevel.get(32, 32));
-        // A tight miter limit falls back to a bevel.
-        let limited = raster_convex(40, 40, &stroke_outline(&corner, 3.0, 1, 1, 1.0));
-        assert!(limited.get(32, 32) < 0.1);
-    }
-
-    #[test]
-    fn scribble_caps_and_start_end_apply_to() {
-        let masks = square_mask();
-        let env = EffectEnv { masks: &masks, ..Default::default() };
-        let img = Image::new(64, 64);
-        let base = [("wiggleType", Value::Enum(0)), ("strokeWidth", num(3.0))];
-        let round = run_env("ec.generate.scribble", &base, img.clone(), 0.0, env);
-        let butt = run_env(
-            "ec.generate.scribble",
-            &[base.as_slice(), &[("edgeOptions/endCap", Value::Enum(1)), ("edgeOptions/join", Value::Enum(2))]].concat(),
-            img.clone(),
-            0.0,
-            env,
-        );
-        assert_ne!(round.img.data, butt.img.data);
-        // Each Stroke: every stroke is trimmed on its own, so the half-way image has ink all over.
-        let two = vec![
-            crate::MaskShape { name: String::new(), points: vec![[4.0, 4.0], [28.0, 4.0], [28.0, 60.0], [4.0, 60.0]], closed: true, inverted: false },
-            crate::MaskShape { name: String::new(), points: vec![[36.0, 4.0], [60.0, 4.0], [60.0, 60.0], [36.0, 60.0]], closed: true, inverted: false },
-        ];
-        let env2 = EffectEnv { masks: &two, ..Default::default() };
-        let seq = [("scribble", Value::Enum(1)), ("end", num(50.0))];
-        let all = run_env("ec.generate.scribble", &[base.as_slice(), &seq].concat(), img.clone(), 0.0, env2);
-        let each = run_env("ec.generate.scribble", &[base.as_slice(), &seq, &[("startEndApplyTo", Value::Enum(1))]].concat(), img, 0.0, env2);
-        assert_ne!(all.img.data, each.img.data);
-    }
-}
+#[cfg(test)]
+mod tests;
diff --git a/crates/effects/src/generate3/audio.rs b/crates/effects/src/generate3/audio.rs
new file mode 100644
index 000000000..6c8d66e4a
--- /dev/null
+++ b/crates/effects/src/generate3/audio.rs
@@ -0,0 +1,314 @@
+use super::raster::{Seg, mask_px, over, poly_segs, raster_segs};
+use super::{Buf, EffectCtx, IndexedParallelIterator, IntoParallelRefMutIterator, PI, ParallelIterator, poly_length, premul};
+
+// ---------------------------------------------------------------- Audio Spectrum / Waveform
+
+/// In-place iterative radix-2 FFT (`re`, `im` lengths a power of two).
+pub(crate) fn fft(re: &mut [f64], im: &mut [f64]) {
+    let n = re.len();
+    if n < 2 {
+        return;
+    }
+    let mut j = 0;
+    for i in 1..n {
+        let mut bit = n >> 1;
+        while j & bit != 0 {
+            j ^= bit;
+            bit >>= 1;
+        }
+        j |= bit;
+        if i < j {
+            re.swap(i, j);
+            im.swap(i, j);
+        }
+    }
+    let mut len = 2;
+    while len <= n {
+        let ang = -2.0 * PI / len as f64;
+        let (ws, wc) = ang.sin_cos();
+        for start in (0..n).step_by(len) {
+            let (mut cr, mut ci) = (1.0, 0.0);
+            for k in 0..len / 2 {
+                let (a, bb) = (start + k, start + k + len / 2);
+                let tr = re[bb] * cr - im[bb] * ci;
+                let ti = re[bb] * ci + im[bb] * cr;
+                re[bb] = re[a] - tr;
+                im[bb] = im[a] - ti;
+                re[a] += tr;
+                im[a] += ti;
+                let ncr = cr * wc - ci * ws;
+                ci = cr * ws + ci * wc;
+                cr = ncr;
+            }
+        }
+        len <<= 1;
+    }
+}
+
+const AUDIO_RATE: u32 = 48_000;
+
+/// Fetch mono (or one channel) samples of the audio layer around the current time.
+fn audio_window(ctx: &EffectCtx, dur_ms: f64, offset_ms: f64, channel: u32) -> Option<Vec<f64>> {
+    let id = ctx.params.get("audioLayer")?.as_layer()?;
+    let host = ctx.env.host?;
+    let dur = (dur_ms / 1000.0).max(0.001);
+    let frames = ((dur * AUDIO_RATE as f64) as usize).clamp(16, 1 << 16);
+    let start = ctx.env.comp_time + offset_ms / 1000.0 - dur * 0.5;
+    let s = host.audio(id, start, frames, AUDIO_RATE)?;
+    Some(
+        (0..frames)
+            .map(|i| {
+                let (l, r) = (*s.get(2 * i).unwrap_or(&0.0) as f64, *s.get(2 * i + 1).unwrap_or(&0.0) as f64);
+                match channel {
+                    1 => l,
+                    2 => r,
+                    _ => (l + r) * 0.5,
+                }
+            })
+            .collect(),
+    )
+}
+
+/// The drawing baseline: a polyline in buffer px (mask path or start→end line), sampled at
+/// parameter u∈[0,1] → (point, unit normal).
+struct Baseline {
+    pts: Vec<[f64; 2]>,
+    closed: bool,
+    len: f64,
+    polar: bool,
+    center: [f64; 2],
+    radius: f64,
+}
+
+impl Baseline {
+    fn new(ctx: &EffectCtx, b: &Buf) -> Baseline {
+        let pr = ctx.params;
+        let polar = pr.b("usePolarPath");
+        let (pts, closed) = match mask_px(ctx, b, pr.f("path").round() as usize) {
+            Some((p, c, _)) if !polar => (p, c),
+            _ => {
+                let s = b.to_px(pr.v2("startPoint"));
+                let e = b.to_px(pr.v2("endPoint"));
+                (vec![[s.0, s.1], [e.0, e.1]], false)
+            }
+        };
+        let len = poly_length(&pts, closed);
+        let center = pts[0];
+        let radius = if pts.len() > 1 { ((pts[1][0] - pts[0][0]).powi(2) + (pts[1][1] - pts[0][1]).powi(2)).sqrt() } else { 1.0 };
+        Baseline { pts, closed, len, polar, center, radius }
+    }
+    fn at(&self, u: f64) -> ([f64; 2], [f64; 2]) {
+        if self.polar {
+            let a = u * 2.0 * PI - PI * 0.5;
+            let (s, c) = a.sin_cos();
+            return ([self.center[0] + c * self.radius * 0.5, self.center[1] + s * self.radius * 0.5], [c, s]);
+        }
+        let (q, d) = crate::util::poly_point_at(&self.pts, self.closed, u * self.len);
+        (q, [d[1], -d[0]])
+    }
+}
+
+/// Draw line/dot marks with core (inside colour) and soft halo (outside colour).
+fn draw_marks(b: &mut Buf, segs_core: &[Seg], thickness: f64, softness: f64, inside: [f32; 4], outside: [f32; 4], composite: bool) {
+    let (w, h) = (b.img.width as usize, b.img.height as usize);
+    let core = raster_segs(w, h, segs_core, 1.0);
+    let halo_segs: Vec<Seg> = segs_core.iter().map(|s| Seg { r: s.r + thickness * softness.max(0.0) + 0.5, ..*s }).collect();
+    let halo = if softness > 0.0 { raster_segs(w, h, &halo_segs, 0.0) } else { core.clone() };
+    b.img.data.par_iter_mut().enumerate().for_each(|(i, px)| {
+        let (c, hl) = (core.data[i], halo.data[i]);
+        let a = c.max(hl);
+        let base = if composite { *px } else { [0.0; 4] };
+        if a <= 0.0 {
+            *px = base;
+            return;
+        }
+        let t = if a > 0.0 { c / a } else { 0.0 };
+        let col = crate::util::lerp3([outside[0], outside[1], outside[2]], [inside[0], inside[1], inside[2]], t);
+        *px = over(base, premul(col, a));
+    });
+}
+
+/// Audio Spectrum / Audio Waveform, shared with the GPU compositor (effectcraft-gpu `fx_gen2`):
+/// the marks (the audio analysis runs on the CPU) and how `draw_marks` colours them.
+#[derive(Clone, Debug)]
+pub struct MarksPlan {
+    pub segs: Vec<Seg>,
+    pub thickness: f64,
+    pub softness: f64,
+    pub inside: [f32; 4],
+    pub outside: [f32; 4],
+    pub composite: bool,
+}
+
+/// [`MarksPlan`] of Audio Spectrum or Audio Waveform on `b`'s geometry (`None` = no audio:
+/// the layer passes through).
+pub fn marks_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option<MarksPlan> {
+    match id {
+        "ec.generate.audiospectrum" => spectrum_plan(ctx, b),
+        "ec.generate.audiowaveform" => waveform_plan(ctx, b),
+        _ => None,
+    }
+}
+
+fn marks(ctx: &EffectCtx, segs: Vec<Seg>, thick: f64, soft: f64) -> MarksPlan {
+    let pr = ctx.params;
+    MarksPlan {
+        segs,
+        thickness: thick,
+        softness: soft * 2.0,
+        inside: pr.color("insideColor"),
+        outside: pr.color("outsideColor"),
+        composite: pr.b("compositeOnOriginal"),
+    }
+}
+
+pub(super) fn audio_spectrum(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    if let Some(m) = spectrum_plan(ctx, &b) {
+        draw_marks(&mut b, &m.segs, m.thickness, m.softness, m.inside, m.outside, m.composite);
+    }
+    b
+}
+
+pub(super) fn audio_waveform(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    if let Some(m) = waveform_plan(ctx, &b) {
+        draw_marks(&mut b, &m.segs, m.thickness, m.softness, m.inside, m.outside, m.composite);
+    }
+    b
+}
+
+fn compute_fft_mags(samples: &[f64]) -> (usize, f64, Vec<f64>) {
+    let m = samples.len();
+    let n = m.next_power_of_two().max(64);
+    let mut re = vec![0.0; n];
+    let mut im = vec![0.0; n];
+    let denom = (m.max(2) - 1) as f64;
+    for (i, s) in samples.iter().enumerate() {
+        let w = 0.5 - 0.5 * (2.0 * PI * i as f64 / denom).cos();
+        if let Some(r) = re.get_mut(i) {
+            *r = s * w;
+        }
+    }
+    fft(&mut re, &mut im);
+    let hz_per_bin = AUDIO_RATE as f64 / n as f64;
+    let scale = 4.0 / m.max(1) as f64;
+    let num_bins = n / 2 + 1;
+    let mut mags = Vec::with_capacity(num_bins);
+    for k in 0..num_bins {
+        let r = re.get(k).copied().unwrap_or(0.0);
+        let im_val = im.get(k).copied().unwrap_or(0.0);
+        let mag = (r * r + im_val * im_val).sqrt() * scale;
+        mags.push(mag);
+    }
+    (n, hz_per_bin, mags)
+}
+
+fn spectrum_plan(ctx: &EffectCtx, b: &Buf) -> Option<MarksPlan> {
+    let pr = ctx.params;
+    let samples = audio_window(ctx, pr.f("audioDuration"), pr.f("audioOffset"), 0)?;
+    let (_n, hz_per_bin, mags) = compute_fft_mags(&samples);
+
+    let bands = pr.f("frequencyBands").round().clamp(1.0, 4096.0) as usize;
+    let f0 = pr.f("startFrequency").max(0.0);
+    let f1 = pr.f("endFrequency").max(f0 + 1.0);
+    let max_bin = mags.len().saturating_sub(1);
+
+    let get_band_mag = |fc: f64| -> f64 {
+        if mags.is_empty() || hz_per_bin <= 0.0 {
+            return 0.0;
+        }
+        let k_float = (fc / hz_per_bin).clamp(0.0, max_bin as f64);
+        let k0 = (k_float.floor() as usize).min(max_bin.saturating_sub(1));
+        let k1 = (k0 + 1).min(max_bin);
+        let frac = (k_float - k0 as f64).clamp(0.0, 1.0);
+        let m0 = mags.get(k0).copied().unwrap_or(0.0);
+        let m1 = mags.get(k1).copied().unwrap_or(0.0);
+        m0 * (1.0 - frac) + m1 * frac
+    };
+
+    let max_h = pr.f("maximumHeight") * b.scale;
+    let thick = (pr.f("thickness") * b.scale).max(0.1);
+    let soft = pr.f("softness") / 100.0;
+    let disp = pr.e("displayOptions");
+    let side = pr.e("sideOptions");
+    let base = Baseline::new(ctx, b);
+    let mut tops = Vec::with_capacity(bands);
+    let mut segs = Vec::new();
+    for i in 0..bands {
+        let u = if bands > 1 { i as f64 / (bands - 1) as f64 } else { 0.5 };
+        let fc = f0 + (f1 - f0) * u;
+        let v = get_band_mag(fc);
+        let hgt = if (v * max_h).is_finite() { (v * max_h).clamp(0.0, max_h.max(0.0)) } else { 0.0 };
+        let (q, nrm) = base.at(u);
+        let (ua, ub) = match side {
+            0 => (0.0, hgt),
+            1 => (-hgt, 0.0),
+            _ => (-hgt, hgt),
+        };
+        let pa = [q[0] + nrm[0] * ua, q[1] + nrm[1] * ua];
+        let pb = [q[0] + nrm[0] * ub, q[1] + nrm[1] * ub];
+        match disp {
+            0 => segs.push(Seg { a: pa, b: pb, r: thick * 0.5, v: 1.0 }),
+            _ => tops.push((pa, pb)),
+        }
+    }
+    if disp == 1 {
+        for w2 in tops.windows(2) {
+            segs.push(Seg { a: w2[0].1, b: w2[1].1, r: thick * 0.5, v: 1.0 });
+            if side == 2 {
+                segs.push(Seg { a: w2[0].0, b: w2[1].0, r: thick * 0.5, v: 1.0 });
+            }
+        }
+    } else if disp == 2 {
+        for &(pa, pb) in &tops {
+            segs.push(Seg { a: pb, b: pb, r: thick * 0.5, v: 1.0 });
+            if side == 2 {
+                segs.push(Seg { a: pa, b: pa, r: thick * 0.5, v: 1.0 });
+            }
+        }
+    }
+    Some(marks(ctx, segs, thick, soft))
+}
+
+fn waveform_plan(ctx: &EffectCtx, b: &Buf) -> Option<MarksPlan> {
+    let pr = ctx.params;
+    let samples = audio_window(ctx, pr.f("audioDuration"), pr.f("audioOffset"), pr.e("waveformOptions"))?;
+    let count = pr.f("displayedSamples").round().clamp(2.0, 4096.0) as usize;
+    let max_h = pr.f("maximumHeight") * b.scale;
+    let thick = (pr.f("thickness") * b.scale).max(0.1);
+    let soft = pr.f("softness") / 100.0;
+    let disp = pr.e("displayOptions");
+    let base = Baseline::new(ctx, b);
+    let m = samples.len();
+    let mut pts = Vec::with_capacity(count);
+    let mut segs = Vec::new();
+    for i in 0..count {
+        let u = i as f64 / (count - 1) as f64;
+        let a = ((u * (m - 1) as f64) as usize).min(m - 1);
+        let bnd = (((i + 1) as f64 / count as f64 * (m - 1) as f64) as usize).clamp(a, m - 1);
+        // Peak with sign of the window for a stable digital display.
+        let (mut lo, mut hi) = (0.0f64, 0.0f64);
+        for s in &samples[a..=bnd] {
+            lo = lo.min(*s);
+            hi = hi.max(*s);
+        }
+        let (q, nrm) = base.at(u);
+        match disp {
+            0 => segs.push(Seg {
+                a: [q[0] + nrm[0] * lo * max_h, q[1] + nrm[1] * lo * max_h],
+                b: [q[0] + nrm[0] * hi * max_h, q[1] + nrm[1] * hi * max_h],
+                r: thick * 0.5,
+                v: 1.0,
+            }),
+            _ => {
+                let v = samples[a] * max_h;
+                pts.push([q[0] + nrm[0] * v, q[1] + nrm[1] * v]);
+            }
+        }
+    }
+    if disp == 1 {
+        poly_segs(&pts, false, thick * 0.5, 1.0, &mut segs);
+    } else if disp == 2 {
+        segs.extend(pts.iter().map(|&q| Seg { a: q, b: q, r: thick * 0.5, v: 1.0 }));
+    }
+    Some(marks(ctx, segs, thick, soft))
+}
diff --git a/crates/effects/src/generate3/common.rs b/crates/effects/src/generate3/common.rs
new file mode 100644
index 000000000..7e341ad8d
--- /dev/null
+++ b/crates/effects/src/generate3/common.rs
@@ -0,0 +1,13 @@
+use super::{EffectSpec, ParamUi, Value, slider};
+
+pub(super) fn spec(id: &'static str, name: &'static str, params: Vec<crate::ParamSpec>, render: crate::RenderFn) -> EffectSpec {
+    EffectSpec { id, name, category: "Generate", params, render, gpu: false, float: true }
+}
+
+pub(super) fn pt(x: f64, y: f64) -> Value {
+    Value::Vec2([x, y])
+}
+
+pub(super) fn pct() -> ParamUi {
+    slider(0.0, 100.0, 0.0, 100.0, 1)
+}
diff --git a/crates/effects/src/generate3/fill.rs b/crates/effects/src/generate3/fill.rs
new file mode 100644
index 000000000..5df782a89
--- /dev/null
+++ b/crates/effects/src/generate3/fill.rs
@@ -0,0 +1,337 @@
+use super::raster::over;
+use super::{
+    Buf, EffectCtx, IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator, PI, ParallelIterator, Plane, Px, gauss_plane, hash1,
+    hsl_to_rgb, morph_frac, premul, rgb_to_hsl, smoothstep, unpremul,
+};
+
+pub(super) fn glue_gun(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let q = b.to_px(pr.v2("brushPosition"));
+    let rad = (pr.f("strokeWidth") * b.scale * 0.5).max(0.5);
+    let density = pr.f("density").max(0.0);
+    let refl = pr.f("reflection").to_radians();
+    let strength = (pr.f("strength") / 100.0) as f32;
+    let glue_only = pr.e("style") == 1;
+    let src = b.img.clone();
+    let light = [refl.cos() * 0.6, -refl.sin() * 0.6, 0.53];
+    let beads = (density.round() as usize).clamp(1, 32);
+    let seed = ctx.seed;
+    let centers: Vec<([f64; 2], f64)> = (0..beads)
+        .map(|i| {
+            let a = hash1(i as u32, 1, seed) as f64 * 2.0 * PI;
+            let d = if i == 0 { 0.0 } else { hash1(i as u32, 2, seed) as f64 * rad * 0.35 };
+            ([q.0 + a.cos() * d, q.1 + a.sin() * d], rad * (0.75 + 0.25 * hash1(i as u32, 3, seed) as f64))
+        })
+        .collect();
+    b.img.rows_mut().for_each(|(y, row)| {
+        for (x, px) in row.iter_mut().enumerate() {
+            let (fx, fy) = (x as f64 + 0.5, y as f64 + 0.5);
+            // Height field: union of hemispheres.
+            let mut best = (0.0f64, [0.0f64; 2], 1.0f64);
+            for &(c, r) in &centers {
+                let (dx, dy) = ((fx - c[0]) / r, (fy - c[1]) / r);
+                let d2 = dx * dx + dy * dy;
+                if d2 < 1.0 {
+                    let hgt = (1.0 - d2).sqrt();
+                    if hgt > best.0 {
+                        best = (hgt, [dx, dy], r);
+                    }
+                }
+            }
+            if best.0 <= 0.0 {
+                if glue_only {
+                    *px = [0.0; 4];
+                }
+                continue;
+            }
+            let nrm = [best.1[0], best.1[1], best.0];
+            let ndl = (nrm[0] * light[0] + nrm[1] * light[1] + nrm[2] * light[2]).max(0.0);
+            let spec = ndl.powi(24) as f32;
+            // Refraction: look through the bead.
+            let s = src.sample_bilinear_clamped(fx - nrm[0] * best.2 * 0.5 * strength as f64, fy - nrm[1] * best.2 * 0.5 * strength as f64);
+            let edge = smoothstep(0.0, 0.15, best.0 as f32);
+            let shade = 0.65 + 0.35 * ndl as f32;
+            let g = [s[0] * shade + spec, s[1] * shade + spec, s[2] * shade + spec, s[3].max(0.6)];
+            let gp = [g[0].min(g[3] + spec), g[1].min(g[3] + spec), g[2].min(g[3] + spec), g[3].min(1.0)];
+            let base = if glue_only { [0.0; 4] } else { *px };
+            *px = crate::util::lerp4(base, gp, edge * strength.clamp(0.0, 1.0).max(0.3));
+            px[3] = px[3].clamp(0.0, 1.0);
+        }
+    });
+    b
+}
+
+// ---------------------------------------------------------------- Paint Bucket
+
+/// Paint Bucket's filled region (1 inside) on `b`: the flood fill from the Fill Point over the
+/// layer's pixels (shared with the GPU compositor, which reads the layer back for it).
+pub fn paint_bucket_region(ctx: &EffectCtx, b: &Buf) -> Plane {
+    let pr = ctx.params;
+    let (w, h) = (b.img.width as usize, b.img.height as usize);
+    let fp = b.to_px(pr.v2("fillPoint"));
+    let (sx, sy) = (fp.0.floor() as i64, fp.1.floor() as i64);
+    let sel = pr.e("fillSelector");
+    let tol = (pr.f("tolerance") / 255.0) as f32;
+    let key = |p: Px| -> [f32; 4] {
+        let (c, a) = unpremul(p);
+        match sel {
+            1 => [c[0], c[1], c[2], 0.0],
+            2 => [0.0, 0.0, 0.0, if a <= 1e-3 { 0.0 } else { 1.0 }],
+            3 | 4 => [0.0, 0.0, 0.0, a],
+            _ => p,
+        }
+    };
+    let mut region = Plane::new(w, h);
+    if sx >= 0 && sy >= 0 && (sx as usize) < w && (sy as usize) < h {
+        let seed = key(b.img.data[sy as usize * w + sx as usize]);
+        let within = |i: usize| {
+            let k = key(b.img.data[i]);
+            if sel == 2 {
+                return k[3] == seed[3];
+            }
+            (0..4).all(|j| (k[j] - seed[j]).abs() <= tol + 1e-6)
+        };
+        let mut seen = vec![false; w * h];
+        let mut stack = vec![(sx as usize, sy as usize)];
+        while let Some((x, y)) = stack.pop() {
+            let row = y * w;
+            if seen[row + x] || !within(row + x) {
+                continue;
+            }
+            let mut l = x;
+            while l > 0 && !seen[row + l - 1] && within(row + l - 1) {
+                l -= 1;
+            }
+            let mut r = x;
+            while r + 1 < w && !seen[row + r + 1] && within(row + r + 1) {
+                r += 1;
+            }
+            for i in l..=r {
+                seen[row + i] = true;
+                region.data[row + i] = 1.0;
+                if y > 0 && !seen[row - w + i] {
+                    stack.push((i, y - 1));
+                }
+                if y + 1 < h && !seen[row + w + i] {
+                    stack.push((i, y + 1));
+                }
+            }
+        }
+    }
+    region
+}
+
+pub(super) fn paint_bucket(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let (w, h) = (b.img.width as usize, b.img.height as usize);
+    if w == 0 || h == 0 {
+        return b;
+    }
+    let region = paint_bucket_region(ctx, &b);
+    if pr.b("viewThreshold") {
+        b.img.data.par_iter_mut().zip(region.data.par_iter()).for_each(|(px, &v)| *px = [v, v, v, 1.0]);
+        return b;
+    }
+    let sc = b.scale;
+    let mut cov = match pr.e("stroke") {
+        1 => {
+            let s = pr.f("featherSoftness") * sc * 0.5;
+            if s > 0.05 { gauss_plane(&region, s, s) } else { region.clone() }
+        }
+        2 => morph_frac(&region, pr.f("spreadRadius") * sc, true),
+        3 => morph_frac(&region, pr.f("spreadRadius") * sc, false),
+        4 => {
+            let r = pr.f("strokeWidth") * sc;
+            let out = morph_frac(&region, r * 0.5, true);
+            let inn = morph_frac(&region, r * 0.5, false);
+            out.zip_map(&inn, |a, b| (a - b).max(0.0))
+        }
+        _ => gauss_plane(&region, 0.5, 0.5),
+    };
+    if pr.e("stroke") == 0 {
+        // Antialias: keep the hard interior, soften only the boundary.
+        cov = cov.zip_map(&region, |a, r| if r > 0.0 { a.max(0.5) } else { a });
+    }
+    let color = pr.color("color");
+    let op = (pr.f("opacity") / 100.0) as f32;
+    let mode = pr.e("blendingMode");
+    b.img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
+        let k = (c * op * color[3]).clamp(0.0, 1.0);
+        if k <= 0.0 {
+            if mode == 9 {
+                *px = [0.0; 4];
+            }
+            return;
+        }
+        let (dc, da) = unpremul(*px);
+        let fc = [color[0], color[1], color[2]];
+        let mixed = match mode {
+            1 => [dc[0] + fc[0], dc[1] + fc[1], dc[2] + fc[2]],
+            2 => [dc[0] * fc[0], dc[1] * fc[1], dc[2] * fc[2]],
+            3 => [1.0 - (1.0 - dc[0]) * (1.0 - fc[0]), 1.0 - (1.0 - dc[1]) * (1.0 - fc[1]), 1.0 - (1.0 - dc[2]) * (1.0 - fc[2])],
+            4..=7 => {
+                let (dh, ds, dl) = rgb_to_hsl(dc[0], dc[1], dc[2]);
+                let (fh, fs, fl) = rgb_to_hsl(fc[0], fc[1], fc[2]);
+                let (r, g, bl) = match mode {
+                    4 => hsl_to_rgb(fh, ds, dl),
+                    5 => hsl_to_rgb(dh, fs, dl),
+                    6 => hsl_to_rgb(fh, fs, dl),
+                    _ => hsl_to_rgb(dh, ds, fl),
+                };
+                [r, g, bl]
+            }
+            _ => fc,
+        };
+        *px = match mode {
+            8 => over(premul(fc, k), *px),
+            9 => premul(fc, k),
+            0 => over(*px, premul(fc, k)),
+            _ => {
+                if da <= 1e-6 {
+                    return;
+                }
+                let c3 = crate::util::lerp3(dc, mixed, k);
+                premul(c3, da)
+            }
+        };
+    });
+    b
+}
+
+// ---------------------------------------------------------------- Eyedropper Fill
+
+pub(super) fn eyedropper_fill(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let fill = eyedropper_color(ctx, &b);
+    let keep_alpha = pr.b("maintainOriginalAlpha");
+    let blend = (pr.f("blendWithOriginal") / 100.0) as f32;
+    b.img.data.par_iter_mut().for_each(|px| {
+        let a = if keep_alpha { px[3] } else { fill[3] };
+        let f = premul([fill[0], fill[1], fill[2]], a);
+        *px = crate::util::lerp4(f, *px, blend);
+    });
+    b
+}
+
+/// Eyedropper Fill's sampled colour (straight RGB, alpha) from the layer's pixels (shared with
+/// the GPU compositor, which reads the layer back for it).
+pub fn eyedropper_color(ctx: &EffectCtx, b: &Buf) -> Px {
+    let pr = ctx.params;
+    let (w, h) = (b.img.width as i64, b.img.height as i64);
+    let c = b.to_px(pr.v2("samplePoint"));
+    let r = (pr.f("sampleRadius") * b.scale).max(0.0);
+    let mode = pr.e("averagePixelColors");
+    let (cx, cy) = (c.0.floor() as i64, c.1.floor() as i64);
+    let ri = r.ceil() as i64;
+    let mut acc = [0.0f64; 4];
+    let mut n = 0.0f64;
+    for y in (cy - ri).max(0)..=(cy + ri).min(h - 1) {
+        for x in (cx - ri).max(0)..=(cx + ri).min(w - 1) {
+            if ((x - cx).pow(2) + (y - cy).pow(2)) as f64 > r * r + 0.5 {
+                continue;
+            }
+            let px = b.img.data[(y * w + x) as usize];
+            match mode {
+                0 => {
+                    if px[3] > 1e-4 {
+                        let (s, _) = unpremul(px);
+                        for k in 0..3 {
+                            acc[k] += s[k] as f64;
+                        }
+                        acc[3] += 1.0;
+                        n += 1.0;
+                    }
+                }
+                1 => {
+                    let (s, _) = unpremul(px);
+                    for k in 0..3 {
+                        acc[k] += s[k] as f64;
+                    }
+                    acc[3] += 1.0;
+                    n += 1.0;
+                }
+                2 => {
+                    for k in 0..3 {
+                        acc[k] += px[k] as f64;
+                    }
+                    acc[3] += 1.0;
+                    n += 1.0;
+                }
+                _ => {
+                    for k in 0..4 {
+                        acc[k] += px[k] as f64;
+                    }
+                    n += 1.0;
+                }
+            }
+        }
+    }
+    if n > 0.0 {
+        if mode == 3 {
+            let a = (acc[3] / n) as f32;
+            let s = if a > 1e-6 { [(acc[0] / n) as f32 / a, (acc[1] / n) as f32 / a, (acc[2] / n) as f32 / a] } else { [0.0; 3] };
+            [s[0], s[1], s[2], a]
+        } else {
+            [(acc[0] / n) as f32, (acc[1] / n) as f32, (acc[2] / n) as f32, 1.0]
+        }
+    } else {
+        [0.0, 0.0, 0.0, 0.0]
+    }
+}
+
+// ---------------------------------------------------------------- CC Threads
+
+pub(super) fn threads(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let sc = b.scale;
+    let tw = (pr.f("width") * sc).max(1.0);
+    let th = (pr.f("height") * sc).max(1.0);
+    let overlaps = pr.f("overlaps").round().clamp(1.0, 20.0) as i64;
+    let ang = pr.f("direction").to_radians();
+    let (sn, cs) = ang.sin_cos();
+    let c = b.to_px(pr.v2("center"));
+    let coverage = (pr.f("coverage") / 100.0).clamp(0.0, 1.0);
+    let shadow = (pr.f("shadowing") / 100.0) as f32;
+    let texture = (pr.f("texture") / 100.0) as f32;
+    let src = b.img.clone();
+    let to_px = |u: f64, v: f64| (c.0 + u * cs - v * sn, c.1 + u * sn + v * cs);
+    b.img.rows_mut().for_each(|(y, row)| {
+        for (x, px) in row.iter_mut().enumerate() {
+            let (dx, dy) = (x as f64 + 0.5 - c.0, y as f64 + 0.5 - c.1);
+            let u = dx * cs + dy * sn;
+            let v = -dx * sn + dy * cs;
+            let (ci, cj) = ((u / tw).floor() as i64, (v / th).floor() as i64);
+            let (fu, fv) = (u / tw - ci as f64, v / th - cj as f64);
+            // Horizontal thread j occupies the band |fv-0.5| < coverage/2; vertical thread i the
+            // band |fu-0.5| < coverage/2.
+            let in_h = (fv - 0.5).abs() < coverage * 0.5;
+            let in_v = (fu - 0.5).abs() < coverage * 0.5;
+            // Twill: horizontal is on top when (i + j) mod (2·overlaps) < overlaps.
+            let h_top = (ci + cj).rem_euclid(2 * overlaps) < overlaps;
+            let which = match (in_h, in_v) {
+                (true, true) => Some(h_top),
+                (true, false) => Some(true),
+                (false, true) => Some(false),
+                _ => None,
+            };
+            let Some(horizontal) = which else {
+                *px = [0.0; 4];
+                continue;
+            };
+            // Thread colour: the source sampled along the thread centre line.
+            let (sx, sy) = if horizontal { to_px(u, (cj as f64 + 0.5) * th) } else { to_px((ci as f64 + 0.5) * tw, v) };
+            let s = src.sample_bilinear_clamped(sx, sy);
+            // Round profile across the thread + darkening where it dives under its neighbour.
+            let across = if horizontal { (fv - 0.5) / (coverage * 0.5).max(1e-6) } else { (fu - 0.5) / (coverage * 0.5).max(1e-6) };
+            let along = if horizontal { fu } else { fv };
+            let profile = (1.0 - across * across).max(0.0).sqrt() as f32;
+            let dive = 1.0 - (along - 0.5).abs() as f32 * 2.0;
+            let shade = 1.0 - shadow * (1.0 - profile) * 0.8 - shadow * 0.25 * (1.0 - dive) * if horizontal == h_top { 0.0 } else { 1.0 };
+            let fib =
+                if texture > 0.0 { 1.0 - texture * 0.3 * hash1((along * 64.0) as u32, (across * 8.0 + 8.0) as u32, ci as u32 ^ (cj as u32) << 8) } else { 1.0 };
+            let k = (shade * fib).max(0.0);
+            *px = [s[0] * k, s[1] * k, s[2] * k, s[3]];
+        }
+    });
+    b
+}
diff --git a/crates/effects/src/generate3/fractal.rs b/crates/effects/src/generate3/fractal.rs
new file mode 100644
index 000000000..05a76d5f0
--- /dev/null
+++ b/crates/effects/src/generate3/fractal.rs
@@ -0,0 +1,193 @@
+use super::raster::over;
+use super::{Buf, EffectCtx, IndexedParallelIterator, ParallelIterator, ParallelSliceMut, Px, hsl_to_rgb};
+
+// ---------------------------------------------------------------- Fractal
+
+#[derive(Clone, Copy)]
+struct FracSet {
+    /// Mandelbrot iterations start at the Julia centre (the "Over Julia" set choices).
+    over_julia: bool,
+    julia: bool,
+    inverse: bool,
+}
+
+/// Smooth escape count, or `None` inside the set.
+fn escape(z0: (f64, f64), c: (f64, f64), power: u32, limit: f64, max_iter: u32) -> Option<f64> {
+    let (mut x, mut y) = z0;
+    let lim2 = limit * limit;
+    for i in 0..max_iter {
+        let (nx, ny) = match power {
+            3 => (x * x * x - 3.0 * x * y * y, 3.0 * x * x * y - y * y * y),
+            4 => {
+                let (a, b) = (x * x - y * y, 2.0 * x * y);
+                (a * a - b * b, 2.0 * a * b)
+            }
+            _ => (x * x - y * y, 2.0 * x * y),
+        };
+        x = nx + c.0;
+        y = ny + c.1;
+        let m2 = x * x + y * y;
+        if m2 > lim2 {
+            let lz = m2.ln() * 0.5;
+            let nu = (lz / limit.max(1.0001).ln()).max(1e-9).ln() / (power as f64).ln();
+            return Some((i as f64 + 1.0 - nu).max(0.0));
+        }
+    }
+    None
+}
+
+/// Fractal Set Choice options.
+pub(crate) const FRACTAL_SETS: [&str; 6] =
+    ["Mandelbrot", "Mandelbrot Inverse", "Mandelbrot Over Julia", "Mandelbrot Inverse Over Julia", "Julia", "Julia Inverse"];
+
+/// Fractal Palette options.
+pub(crate) const FRACTAL_PALETTES: [&str; 4] = ["Lightness Gradient", "Hue Wheel", "Black And White", "Solid Color"];
+
+/// Fractal Oversample Method options.
+pub(crate) const FRACTAL_OVERSAMPLE: [&str; 2] = ["Edge Detect-Fast-May Miss Pixels", "Brute Force-Slow-Every Pixel"];
+
+pub(super) fn fractal(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let set_choice = pr.e("setChoice");
+    let power = 2 + pr.e("equation").min(2);
+    let mc = (pr.f("mandelbrot/mandelbrotX"), pr.f("mandelbrot/mandelbrotY"));
+    let mmag = pr.f("mandelbrot/mandelbrotMagnification");
+    let mlim = pr.f("mandelbrot/mandelbrotEscapeLimit").max(1.01);
+    let jc = (pr.f("julia/juliaX"), pr.f("julia/juliaY"));
+    let jmag = pr.f("julia/juliaMagnification");
+    let jlim = pr.f("julia/juliaEscapeLimit").max(1.01);
+    let post = (pr.f("postInversionOffset/postInversionX"), pr.f("postInversionOffset/postInversionY"));
+    let overlay = pr.b("fractalColor/overlay");
+    let transparency = pr.b("fractalColor/transparency");
+    let transparent_inside = transparency || overlay;
+    let palette = pr.e("fractalColor/palette");
+    let hue = (pr.f("fractalColor/hue") / 360.0) as f32;
+    let steps = pr.f("fractalColor/cycleSteps").max(1.0);
+    let cyc_off = pr.f("fractalColor/cycleOffset") / 360.0;
+    let edge = pr.b("fractalColor/edgeHighlight");
+    let every = pr.e("highQualitySettings/samplingMethod") == 1;
+    let factor = pr.f("highQualitySettings/samplingFactor").round().clamp(1.0, 9.0) as usize;
+    let (w, h) = (b.img.width as usize, b.img.height as usize);
+    let lw = ctx.layer_size[0].max(1.0);
+    let lh = ctx.layer_size[1].max(1.0);
+    let inv = 1.0 / b.scale.max(1e-9);
+    let (off_x, off_y) = (b.offset[0], b.offset[1]);
+    // FRACTAL_SETS order.
+    let set = |julia, inverse, over_julia| FracSet { over_julia, julia, inverse };
+    let sets: (FracSet, Option<FracSet>) = match set_choice {
+        1 => (set(false, true, false), None),
+        2 => (set(false, false, true), None),
+        3 => (set(false, true, true), None),
+        4 => (set(true, false, false), None),
+        5 => (set(true, true, false), None),
+        _ => (set(false, false, false), None),
+    };
+    let iter_for = |mag: f64| (96.0 + 48.0 * mag.max(0.0)).clamp(64.0, 3000.0) as u32;
+    let eval_set = |s: FracSet, lx: f64, ly: f64| -> Option<f64> {
+        let (center, mag, lim) = if s.julia { (jc, jmag, jlim) } else { (mc, mmag, mlim) };
+        let span = 3.5 / 2f64.powf(mag);
+        let mut u = (lx - lw * 0.5) / lw * span + center.0;
+        let mut v = (ly - lh * 0.5) / lw * span + center.1;
+        if s.inverse {
+            let d = (u * u + v * v).max(1e-12);
+            u = u / d + post.0;
+            v = -v / d + post.1;
+        }
+        if s.julia {
+            escape((u, v), mc, power, lim, iter_for(mag))
+        } else {
+            let z0 = if s.over_julia { jc } else { (0.0, 0.0) };
+            escape(z0, (u, v), power, lim, iter_for(mag))
+        }
+    };
+    let eval = |lx: f64, ly: f64| -> Option<f64> {
+        let a = eval_set(sets.0, lx, ly);
+        match (a, sets.1) {
+            (None, Some(s2)) => eval_set(s2, lx, ly),
+            _ => a,
+        }
+    };
+    let shade = |n: Option<f64>| -> Px {
+        // Solid Color: only the inside of the set is drawn (Transparency flips the sides).
+        if palette == 3 {
+            let (r, g, bl) = hsl_to_rgb(hue, 1.0, 0.5);
+            return if n.is_none() != transparency { [r, g, bl, 1.0] } else { [0.0; 4] };
+        }
+        let Some(n) = n else {
+            return if transparent_inside { [0.0; 4] } else { [0.0, 0.0, 0.0, 1.0] };
+        };
+        let u = n / steps + cyc_off;
+        let band = (u.rem_euclid(1.0)) as f32;
+        let (r, g, bl) = match palette {
+            // Hue Wheel: the full hue circle at full saturation and brightness.
+            1 => hsl_to_rgb((hue + band).rem_euclid(1.0), 1.0, 0.5),
+            // Black And White: alternating bands.
+            2 => {
+                let v = if (u.floor() as i64).rem_euclid(2) == 0 { 0.0 } else { 1.0 };
+                (v, v, v)
+            }
+            // Lightness Gradient: black → hue → white, the hue moving 45° each cycle.
+            _ => hsl_to_rgb((hue + u.floor() as f32 * 0.125).rem_euclid(1.0), 0.85, band.clamp(0.0, 1.0)),
+        };
+        let mut c = [r, g, bl];
+        if edge && n.fract() < 0.12 {
+            c = [c[0] * 0.4 + 0.6, c[1] * 0.4 + 0.6, c[2] * 0.4 + 0.6];
+        }
+        [c[0], c[1], c[2], 1.0]
+    };
+    // First pass: one sample per pixel.
+    let mut first: Vec<Option<f64>> = vec![None; w * h];
+    first.par_chunks_mut(w.max(1)).enumerate().for_each(|(y, row)| {
+        for (x, v) in row.iter_mut().enumerate() {
+            *v = eval((x as f64 + 0.5 - off_x) * inv, (y as f64 + 0.5 - off_y) * inv);
+        }
+    });
+    let src = if overlay { Some(b.img.clone()) } else { None };
+    b.img.rows_mut().for_each(|(y, row)| {
+        for (x, px) in row.iter_mut().enumerate() {
+            let here = first[y * w + x];
+            let needs_ss = factor > 1
+                && (every || {
+                    let mut diff = false;
+                    for (dx, dy) in [(-1i64, 0i64), (1, 0), (0, -1), (0, 1)] {
+                        let (nx, ny) = (x as i64 + dx, y as i64 + dy);
+                        if nx < 0 || ny < 0 || nx >= w as i64 || ny >= h as i64 {
+                            continue;
+                        }
+                        let o = first[ny as usize * w + nx as usize];
+                        diff |= match (here, o) {
+                            (Some(a), Some(c)) => (a - c).abs() > steps * 0.25,
+                            (None, None) => false,
+                            _ => true,
+                        };
+                    }
+                    diff
+                });
+            let c = if needs_ss {
+                let mut acc = [0.0f32; 4];
+                for sy in 0..factor {
+                    for sx in 0..factor {
+                        let fx = x as f64 + (sx as f64 + 0.5) / factor as f64;
+                        let fy = y as f64 + (sy as f64 + 0.5) / factor as f64;
+                        let s = shade(eval((fx - off_x) * inv, (fy - off_y) * inv));
+                        let a = s[3];
+                        for k in 0..3 {
+                            acc[k] += s[k] * a;
+                        }
+                        acc[3] += a;
+                    }
+                }
+                let n = (factor * factor) as f32;
+                [acc[0] / n, acc[1] / n, acc[2] / n, acc[3] / n]
+            } else {
+                let s = shade(here);
+                [s[0] * s[3], s[1] * s[3], s[2] * s[3], s[3]]
+            };
+            *px = match &src {
+                Some(o) => over(o.data[y * w + x], c),
+                None => c,
+            };
+        }
+    });
+    b
+}
diff --git a/crates/effects/src/generate3/paths.rs b/crates/effects/src/generate3/paths.rs
new file mode 100644
index 000000000..9158a274e
--- /dev/null
+++ b/crates/effects/src/generate3/paths.rs
@@ -0,0 +1,565 @@
+use super::raster::{Seg, all_masks_px, chaikin, mask_px, over, poly_segs, raster_convex, raster_segs, scan_runs, stroke_outline, trim_poly};
+use super::{
+    Buf, EffectCtx, Image, IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelIterator, Params, Plane, gauss_plane, hash1,
+    layer_or_self, luminance, poly_length, smoothstep, unpremul,
+};
+
+/// How painted coverage meets the layer: 0 On Original Image, 1 On Transparent, 2 Reveal
+/// Original Image.
+pub(crate) fn paint(img: &mut Image, cov: &Plane, color: [f32; 4], opacity: f32, style: u32) {
+    img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
+        let a = (c * opacity * color[3]).clamp(0.0, 1.0);
+        let s = [color[0] * a, color[1] * a, color[2] * a, a];
+        *px = match style {
+            1 => s,
+            2 => [px[0] * a, px[1] * a, px[2] * a, px[3] * a],
+            _ => over(*px, s),
+        };
+    });
+}
+
+/// Coverage of a plan-drawn generator: round-capped segments rasterised by `raster_segs`
+/// with `hardness`, or the union of convex polygons (`raster_convex`).
+#[derive(Clone, Debug)]
+pub enum Coverage {
+    Segs { segs: Vec<Seg>, hardness: f64 },
+    Convex(Vec<Vec<[f64; 2]>>),
+}
+
+impl Coverage {
+    fn raster(&self, w: usize, h: usize) -> Plane {
+        match self {
+            Coverage::Segs { segs, hardness } => raster_segs(w, h, segs, *hardness),
+            Coverage::Convex(polys) => raster_convex(w, h, polys),
+        }
+    }
+}
+
+/// Stroke, Scribble, Vegas and Write-on, shared with the GPU compositor (effectcraft-gpu
+/// `fx_gen2`): the coverage and how it is painted. `style` 0–2 as `paint` (On Original
+/// Image, On Transparent, Reveal Original Image), 3 = under the layer (Vegas' Composite Under).
+#[derive(Clone, Debug)]
+pub struct PaintPlan {
+    pub cov: Coverage,
+    pub color: [f32; 4],
+    pub opacity: f32,
+    pub style: u32,
+}
+
+/// Draw a [`PaintPlan`].
+fn draw_paint(b: &mut Buf, plan: &PaintPlan) {
+    let cov = plan.cov.raster(b.img.width as usize, b.img.height as usize);
+    if plan.style == 3 {
+        let color = plan.color;
+        b.img.data.par_iter_mut().zip(cov.data.par_iter()).for_each(|(px, &c)| {
+            let a = c * color[3];
+            *px = over([color[0] * a, color[1] * a, color[2] * a, a], *px);
+        });
+    } else {
+        paint(&mut b.img, &cov, plan.color, plan.opacity, plan.style);
+    }
+}
+
+/// Generators drawn from a plan that need the layer's own pixels (`b.img`) to build it.
+pub fn plan_reads_pixels(id: &str, ctx: &EffectCtx) -> bool {
+    match id {
+        // Image Contours read the layer itself when no (resolvable) Input Layer is chosen.
+        "ec.generate.vegas" => ctx.params.e("stroke") == 0,
+        "ec.generate.paintbucket" | "ec.generate.eyedropperfill" => true,
+        "ec.generate.advancedlightning" => ctx.params.f("alphaObstacle").clamp(-10.0, 10.0) != 0.0,
+        _ => false,
+    }
+}
+
+/// [`PaintPlan`] of Stroke, Scribble, Vegas or Write-on on `b`'s geometry (`b.img` is read
+/// only when [`plan_reads_pixels`]). `None`: Scribble without a usable mask (the layer is
+/// cleared when it composites On Transparent, else kept).
+pub fn paint_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option<PaintPlan> {
+    match id {
+        "ec.generate.stroke" => Some(stroke_plan(ctx, b)),
+        "ec.generate.scribble" => scribble_plan(ctx, b),
+        "ec.generate.vegas" => Some(vegas_plan(ctx, b)),
+        "ec.generate.writeon" => Some(write_on_plan(ctx, b)),
+        _ => None,
+    }
+}
+
+/// Scribble's Composite as a `paint` style.
+pub fn scribble_style(ctx: &EffectCtx) -> u32 {
+    match ctx.params.e("composite") {
+        0 => 0,
+        2 => 2,
+        _ => 1,
+    }
+}
+
+pub(super) fn scribble(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    match scribble_plan(ctx, &b) {
+        Some(plan) => draw_paint(&mut b, &plan),
+        None if scribble_style(ctx) == 1 => b.img = Image::new(b.img.width, b.img.height),
+        None => {}
+    }
+    b
+}
+
+fn scribble_plan(ctx: &EffectCtx, b: &Buf) -> Option<PaintPlan> {
+    let pr = ctx.params;
+    let which = pr.e("scribble");
+    let polys: Vec<_> = if which == 0 { mask_px(ctx, b, pr.f("mask").round().max(1.0) as usize).into_iter().collect() } else { all_masks_px(ctx, b) };
+    let polys: Vec<_> = polys.into_iter().filter(|p| p.0.len() >= 3).map(|(p, c, i)| (p, c, i && which == 2)).collect();
+    let style = scribble_style(ctx);
+    if polys.is_empty() {
+        return None;
+    }
+    let sc = b.scale;
+    let fill = pr.e("fillType");
+    let ew = pr.f("edgeOptions/edgeWidth").max(0.1) * sc;
+    let ang = pr.f("angle").to_radians();
+    let d = [ang.cos(), ang.sin()];
+    let n = [-d[1], d[0]];
+    let width = (pr.f("strokeWidth") * sc).max(0.1);
+    let curv = pr.f("strokeOptions/curviness") / 100.0;
+    let curv_var = pr.f("strokeOptions/curvinessVariation") / 100.0;
+    let spacing = (pr.f("strokeOptions/spacing") * sc).max(0.75).max(width * 0.25);
+    let spacing_var = pr.f("strokeOptions/spacingVariation") / 100.0;
+    let overlap = pr.f("strokeOptions/pathOverlap") / 100.0;
+    let overlap_var = pr.f("strokeOptions/pathOverlapVariation") / 100.0;
+    let start = pr.f("start").clamp(0.0, 100.0) / 100.0;
+    let end = pr.f("end").clamp(0.0, 100.0) / 100.0;
+    let sequential = pr.b("fillPathsSequentially");
+    let wiggle = pr.e("wiggleType");
+    let wps = pr.f("wigglesPerSecond").max(0.0);
+    let seed = pr.f("randomSeed") as i64 as u32 ^ ctx.seed;
+    let (step, frac) = match wiggle {
+        0 => (0u32, 0.0f32),
+        1 => ((ctx.time * wps).floor().max(0.0) as u32, 0.0),
+        _ => {
+            let u = (ctx.time * wps).max(0.0);
+            (u.floor() as u32, smoothstep(0.0, 1.0, u.fract() as f32))
+        }
+    };
+    let rnd = |i: u32, k: u32| {
+        let a = hash1(i, k.wrapping_mul(31).wrapping_add(step.wrapping_mul(7919)), seed) * 2.0 - 1.0;
+        if frac > 0.0 {
+            let c = hash1(i, k.wrapping_mul(31).wrapping_add((step + 1).wrapping_mul(7919)), seed) * 2.0 - 1.0;
+            a + (c - a) * frac
+        } else {
+            a
+        }
+    };
+    let groups: Vec<Vec<(Vec<[f64; 2]>, bool, bool)>> =
+        if which == 0 || sequential { vec![polys.clone()] } else { polys.iter().map(|p| vec![p.clone()]).collect() };
+    // Per group a zig-zag polyline (in buffer px).
+    let mut lines: Vec<Vec<Vec<[f64; 2]>>> = Vec::new();
+    let mut runs = Vec::new();
+    for (gi, g) in groups.iter().enumerate() {
+        let mut nmin = f64::INFINITY;
+        let mut nmax = f64::NEG_INFINITY;
+        for (pts, _, _) in g {
+            for q in pts {
+                let v = q[0] * n[0] + q[1] * n[1];
+                nmin = nmin.min(v);
+                nmax = nmax.max(v);
+            }
+        }
+        nmin -= ew;
+        nmax += ew;
+        // Chains of zig-zags: each run joins the nearest chain that ended on the previous
+        // scan line (so separate regions get separate strokes).
+        let mut chains: Vec<(Vec<[f64; 2]>, u32)> = Vec::new();
+        let mut s = nmin + spacing * 0.5;
+        let mut li = 0u32;
+        let reach = spacing * 3.0 + ew;
+        while s < nmax && li < 20_000 {
+            scan_runs(g, fill, ew, d, n, s, &mut runs);
+            for (ri, &(a, bb)) in runs.iter().enumerate() {
+                let k = (gi as u32) << 20 | ri as u32;
+                let ov = spacing * (overlap + overlap_var * rnd(li, k * 4) as f64 * 0.5).max(-0.45);
+                let ov2 = spacing * (overlap + overlap_var * rnd(li, k * 4 + 1) as f64 * 0.5).max(-0.45);
+                let (a, bb) = (a - ov, bb + ov2);
+                if bb <= a {
+                    continue;
+                }
+                let at = |t: f64| [d[0] * t + n[0] * s, d[1] * t + n[1] * s];
+                let (pa, pb) = (at(a), at(bb));
+                let dist = |p: [f64; 2], q: [f64; 2]| ((p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2)).sqrt();
+                let best = chains
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, c)| li > 0 && c.1 == li - 1)
+                    .map(|(i, c)| {
+                        let last = *c.0.last().unwrap_or(&pa);
+                        (i, dist(last, pa).min(dist(last, pb)))
+                    })
+                    .filter(|&(_, dd)| dd < reach)
+                    .min_by(|x, y| x.1.total_cmp(&y.1));
+                match best {
+                    Some((ci, _)) => {
+                        let last = *chains[ci].0.last().unwrap_or(&pa);
+                        let (p0, p1, dir) = if dist(last, pa) <= dist(last, pb) { (pa, pb, -1.0) } else { (pb, pa, 1.0) };
+                        // Curved turn: an extra point pushed past the edge.
+                        let c = (curv + curv_var * rnd(li, k * 4 + 2) as f64 * 0.5).max(0.0);
+                        let mid = [(last[0] + p0[0]) * 0.5 + d[0] * dir * c * spacing, (last[1] + p0[1]) * 0.5 + d[1] * dir * c * spacing];
+                        let ch = &mut chains[ci];
+                        ch.0.extend([mid, p0, p1]);
+                        ch.1 = li;
+                    }
+                    None => chains.push((vec![pa, pb], li)),
+                }
+            }
+            s += spacing * (1.0 + spacing_var * rnd(li, 3) as f64 * 0.5).max(0.25);
+            li += 1;
+        }
+        lines.push(chains.into_iter().map(|(z, _)| if curv > 0.0 { chaikin(&z, 2) } else { z }).collect());
+    }
+    let r = width * 0.5;
+    // Start / End Apply To: all of a mask's strokes as one path, or each stroke on its own.
+    let each = pr.e("startEndApplyTo") == 1;
+    let mut parts: Vec<Vec<[f64; 2]>> = Vec::new();
+    for group in &lines {
+        let lens: Vec<f64> = group.iter().map(|l| poly_length(l, false)).collect();
+        let total: f64 = lens.iter().sum();
+        let (g0, g1) = (total * start, total * end);
+        let mut acc = 0.0;
+        for (l, len) in group.iter().zip(lens) {
+            let part =
+                if each { trim_poly(l, false, len * start, len * end) } else { trim_poly(l, false, (g0 - acc).clamp(0.0, len), (g1 - acc).clamp(0.0, len)) };
+            acc += len;
+            parts.push(part);
+        }
+    }
+    let cap = pr.e("edgeOptions/endCap");
+    let join = pr.e("edgeOptions/join");
+    let cov = if cap == 0 && join == 0 {
+        let mut segs = Vec::new();
+        for part in &parts {
+            poly_segs(part, false, r, 1.0, &mut segs);
+        }
+        Coverage::Segs { segs, hardness: 0.9 }
+    } else {
+        Coverage::Convex(stroke_outline(&parts, r, cap, join, pr.f("edgeOptions/miterLimit").max(1.0)))
+    };
+    Some(PaintPlan { cov, color: pr.color("color"), opacity: (pr.f("opacity") / 100.0) as f32, style })
+}
+
+// ---------------------------------------------------------------- Stroke
+
+pub(super) fn stroke(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let plan = stroke_plan(ctx, &b);
+    draw_paint(&mut b, &plan);
+    b
+}
+
+fn stroke_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
+    let pr = ctx.params;
+    let all = pr.b("allMasks");
+    let polys: Vec<_> = if all { all_masks_px(ctx, b) } else { mask_px(ctx, b, pr.f("path").round() as usize).into_iter().collect() };
+    let style = pr.e("paintStyle");
+    let size = (pr.f("brushSize") * b.scale).max(0.1);
+    let r = size * 0.5;
+    let hard = pr.f("brushHardness") / 100.0;
+    let start = pr.f("start").clamp(0.0, 100.0) / 100.0;
+    let end = pr.f("end").clamp(0.0, 100.0) / 100.0;
+    let spacing = pr.f("spacing") / 100.0;
+    let sequential = pr.b("strokeSequentially");
+    let lens: Vec<f64> = polys.iter().map(|(p, c, _)| poly_length(p, *c)).collect();
+    let total: f64 = lens.iter().sum();
+    let mut segs = Vec::new();
+    let mut acc = 0.0;
+    for ((pts, closed, _), &len) in polys.iter().zip(&lens) {
+        let (s0, s1) = if all && sequential {
+            let (g0, g1) = (total * start, total * end);
+            ((g0 - acc).clamp(0.0, len), (g1 - acc).clamp(0.0, len))
+        } else {
+            (len * start, len * end)
+        };
+        acc += len;
+        if s1 <= s0 {
+            continue;
+        }
+        if spacing <= 0.5 {
+            let part = trim_poly(pts, *closed, s0, s1);
+            poly_segs(&part, false, r, 1.0, &mut segs);
+        } else {
+            let step = (size * spacing).max(0.5);
+            let mut s = s0;
+            while s <= s1 + 1e-9 && segs.len() < 200_000 {
+                let (q, _) = crate::util::poly_point_at(pts, *closed, s);
+                segs.push(Seg { a: q, b: q, r, v: 1.0 });
+                s += step;
+            }
+        }
+    }
+    PaintPlan { cov: Coverage::Segs { segs, hardness: hard }, color: pr.color("color"), opacity: (pr.f("opacity") / 100.0) as f32, style }
+}
+
+// ---------------------------------------------------------------- Vegas
+
+/// Marching-squares iso-contours of `pl` at `thr`, chained into polylines (closed flag).
+pub(super) fn contours(pl: &Plane, thr: f32) -> Vec<(Vec<[f64; 2]>, bool)> {
+    use std::collections::HashMap;
+    let (w, h) = (pl.w, pl.h);
+    if w < 2 || h < 2 {
+        return Vec::new();
+    }
+    // Edge key: horizontal edge (x,y)-(x+1,y) = 2*(y*w+x), vertical (x,y)-(x,y+1) = 2*(y*w+x)+1.
+    let hk = |x: usize, y: usize| 2 * (y * w + x) as u64;
+    let vk = |x: usize, y: usize| 2 * (y * w + x) as u64 + 1;
+    let mut pos: HashMap<u64, [f64; 2]> = HashMap::new();
+    let mut adj: HashMap<u64, Vec<u64>> = HashMap::new();
+    let v = |x: usize, y: usize| pl.data[y * w + x];
+    let interp = |a: f32, b: f32| if (b - a).abs() > 1e-9 { ((thr - a) / (b - a)).clamp(0.0, 1.0) as f64 } else { 0.5 };
+    for y in 0..h - 1 {
+        for x in 0..w - 1 {
+            let (a, bb, c, d) = (v(x, y), v(x + 1, y), v(x + 1, y + 1), v(x, y + 1));
+            let idx = (a > thr) as u8 | ((bb > thr) as u8) << 1 | ((c > thr) as u8) << 2 | ((d > thr) as u8) << 3;
+            if idx == 0 || idx == 15 {
+                continue;
+            }
+            // Edge points (pixel centres at +0.5).
+            let top = (hk(x, y), [x as f64 + 0.5 + interp(a, bb), y as f64 + 0.5]);
+            let right = (vk(x + 1, y), [x as f64 + 1.5, y as f64 + 0.5 + interp(bb, c)]);
+            let bottom = (hk(x, y + 1), [x as f64 + 0.5 + interp(d, c), y as f64 + 1.5]);
+            let left = (vk(x, y), [x as f64 + 0.5, y as f64 + 0.5 + interp(a, d)]);
+            let pairs: &[(usize, usize)] = match idx {
+                1 | 14 => &[(3, 0)],
+                2 | 13 => &[(0, 1)],
+                3 | 12 => &[(3, 1)],
+                4 | 11 => &[(1, 2)],
+                5 => &[(3, 0), (1, 2)],
+                6 | 9 => &[(0, 2)],
+                7 | 8 => &[(3, 2)],
+                10 => &[(0, 1), (2, 3)],
+                _ => &[],
+            };
+            let e = [top, right, bottom, left];
+            for &(i, j) in pairs {
+                pos.insert(e[i].0, e[i].1);
+                pos.insert(e[j].0, e[j].1);
+                adj.entry(e[i].0).or_default().push(e[j].0);
+                adj.entry(e[j].0).or_default().push(e[i].0);
+            }
+        }
+    }
+    let mut keys: Vec<u64> = adj.keys().copied().collect();
+    keys.sort_unstable();
+    // Start open chains at endpoints (degree 1) first, then closed loops.
+    keys.sort_by_key(|k| adj[k].len() != 1);
+    let mut used: std::collections::HashSet<(u64, u64)> = std::collections::HashSet::new();
+    let mut out = Vec::new();
+    for &k0 in &keys {
+        for &first in &adj[&k0] {
+            if used.contains(&(k0.min(first), k0.max(first))) {
+                continue;
+            }
+            let mut chain = vec![pos[&k0]];
+            let (mut prev, mut cur) = (k0, first);
+            used.insert((prev.min(cur), prev.max(cur)));
+            let mut closed = false;
+            loop {
+                chain.push(pos[&cur]);
+                if cur == k0 {
+                    closed = true;
+                    chain.pop();
+                    break;
+                }
+                let next = adj[&cur].iter().copied().find(|&n| n != prev && !used.contains(&(cur.min(n), cur.max(n))));
+                match next {
+                    Some(n) => {
+                        used.insert((cur.min(n), cur.max(n)));
+                        prev = cur;
+                        cur = n;
+                    }
+                    None => break,
+                }
+            }
+            if chain.len() >= 2 {
+                out.push((chain, closed));
+            }
+        }
+    }
+    out
+}
+
+pub(super) fn vegas(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let plan = vegas_plan(ctx, &b);
+    draw_paint(&mut b, &plan);
+    b
+}
+
+/// Sub-samples per Vegas segment: at least 12 (opacity ramp), more for long segments so each straight piece stays
+/// short compared with the stroke width and the segment follows rounded corners smoothly. Always even.
+pub(super) fn vegas_substeps(each: f64, width: f64) -> usize {
+    let step = width.max(2.0);
+    let n = ((each / step).ceil().max(12.0) as usize).min(512);
+    // Even, so the segment's midpoint (0.5) is always one of the samples.
+    n + (n & 1)
+}
+
+fn vegas_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
+    let pr = ctx.params;
+    let (w, h) = (b.img.width as usize, b.img.height as usize);
+    let sc = b.scale;
+    let paths: Vec<(Vec<[f64; 2]>, bool)> = if pr.e("stroke") == 1 {
+        mask_px(ctx, b, pr.f("path").round() as usize).map(|(p, c, _)| vec![(p, c)]).unwrap_or_default()
+    } else {
+        let src = layer_or_self(ctx, b, "inputLayer", true, pr.e("ifLayerSizesDiffer") == 1);
+        let ch = pr.e("channel");
+        let inv = pr.b("invertInput");
+        let mut pl = Plane::from_image(&src, |px| {
+            let (c, a) = unpremul(px);
+            let v = match ch {
+                1 => c[0],
+                2 => c[1],
+                3 => c[2],
+                4 => a,
+                _ => luminance(c[0], c[1], c[2]) * a,
+            };
+            if inv { 1.0 - v } else { v }
+        });
+        let blur = pr.f("preBlur") * sc;
+        if blur > 0.05 {
+            pl = gauss_plane(&pl, blur, blur);
+        }
+        let mut cs = contours(&pl, (pr.f("threshold") / 100.0) as f32);
+        // Simplify by tolerance (drop points closer than tol × size).
+        let tol = pr.f("tolerance").max(0.0) * (w.max(h) as f64) * 0.1;
+        if tol > 0.0 {
+            for (c, _) in cs.iter_mut() {
+                let mut keep: Vec<[f64; 2]> = Vec::with_capacity(c.len());
+                for &q in c.iter() {
+                    if keep.last().is_none_or(|l: &[f64; 2]| ((l[0] - q[0]).powi(2) + (l[1] - q[1]).powi(2)).sqrt() >= tol) {
+                        keep.push(q);
+                    }
+                }
+                *c = keep;
+            }
+        }
+        cs.sort_by(|a, b| poly_length(&b.0, b.1).total_cmp(&poly_length(&a.0, a.1)));
+        if pr.e("renderMode") == 1 {
+            let sel = (pr.f("selectedContour").round().max(1.0) as usize) - 1;
+            cs.into_iter().skip(sel).take(1).collect()
+        } else {
+            cs
+        }
+    };
+    let nseg = pr.f("segments").round().clamp(1.0, 1000.0) as usize;
+    // Shorter Contours Have Fewer Segments: segment count scales with contour length.
+    let fewer = pr.e("stroke") == 0 && pr.e("shorterContoursHave") == 1;
+    let longest = paths.iter().map(|(p, c)| poly_length(p, *c)).fold(0.0, f64::max);
+    let seg_len = pr.f("length").clamp(0.0, 1.0);
+    let bunched = pr.e("segmentDistribution") == 0;
+    let rot = pr.f("rotation") / 360.0;
+    let random_phase = pr.b("randomPhase");
+    let seed = pr.f("randomSeed") as i64 as u32 ^ ctx.seed;
+    let width = (pr.f("width") * sc).max(0.1);
+    let hard = pr.f("hardness").clamp(0.0, 1.0);
+    let (o0, om, o1, mp) = (pr.f("startOpacity") as f32, pr.f("midpointOpacity") as f32, pr.f("endOpacity") as f32, pr.f("midpointPosition").clamp(0.01, 0.99));
+    let mut segs = Vec::new();
+    for (ci, (pts, closed)) in paths.iter().enumerate() {
+        let len = poly_length(pts, *closed);
+        if len <= 0.0 {
+            continue;
+        }
+        let phase = rot + if random_phase { hash1(ci as u32, 1, seed) as f64 } else { 0.0 };
+        let nseg = if fewer && longest > 0.0 { ((nseg as f64 * len / longest).round() as usize).max(1) } else { nseg };
+        let each = len / nseg as f64 * seg_len;
+        for i in 0..nseg {
+            let base = if bunched { (i as f64 + (hash1(ci as u32, i as u32 + 7, seed) as f64 - 0.5) * 0.8) / nseg as f64 } else { i as f64 / nseg as f64 };
+            let s0 = (base + phase).rem_euclid(1.0) * len;
+            // Sub-sample the segment so opacity can ramp along it.
+            let sub = vegas_substeps(each, width);
+            let mut prev: Option<[f64; 2]> = None;
+            for k in 0..=sub {
+                let f = k as f64 / sub as f64;
+                let mut s = s0 + each * f;
+                if *closed {
+                    s = s.rem_euclid(len);
+                } else if s > len {
+                    break;
+                }
+                let (q, _) = crate::util::poly_point_at(pts, *closed, s);
+                let op = if f < mp { o0 + (om - o0) * (f / mp) as f32 } else { om + (o1 - om) * ((f - mp) / (1.0 - mp)) as f32 };
+                if let Some(pv) = prev
+                    && ((pv[0] - q[0]).powi(2) + (pv[1] - q[1]).powi(2)) < (each * 0.5).powi(2) + 4.0
+                {
+                    segs.push(Seg { a: pv, b: q, r: width * 0.5, v: op.clamp(0.0, 1.0) });
+                }
+                prev = Some(q);
+            }
+        }
+    }
+    let style = match pr.e("blendMode") {
+        1 => 0,
+        2 => 3,
+        3 => 2,
+        _ => 1,
+    };
+    PaintPlan { cov: Coverage::Segs { segs, hardness: hard }, color: pr.color("color"), opacity: 1.0, style }
+}
+
+// ---------------------------------------------------------------- Write-on / Glue Gun
+
+/// Write-on draws a stroke along the animated Brush Position, as in After Effects: a dab every
+/// Brush Spacing seconds from the layer's start up to now, each one lasting Stroke Length
+/// seconds (0: for ever). The dabs' positions come from the host's parameters at their times;
+/// with Paint Time Properties ▸ Opacity or Brush Time Properties ▸ Size each dab keeps its own
+/// opacity or size, else the current ones apply to every dab. (Colour and hardness are one per
+/// stroke: the current ones.) Without a host (or dabs) the current dab draws. Deterministic.
+pub(super) fn write_on(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let plan = write_on_plan(ctx, &b);
+    draw_paint(&mut b, &plan);
+    b
+}
+
+/// The most dabs one Write-on frame draws; longer strokes lay them further apart, joined.
+const WRITE_ON_MAX_DABS: i64 = 4096;
+
+fn write_on_plan(ctx: &EffectCtx, b: &Buf) -> PaintPlan {
+    let pr = ctx.params;
+    let own_opacity = pr.e("paintTimeProperties") == 1;
+    let own_size = matches!(pr.e("brushTimeProperties"), 1 | 3);
+    let opacity = |p: &Params| (p.f("brushOpacity") / 100.0).clamp(0.0, 1.0) as f32;
+    let radius = |p: &Params| (p.f("brushSize") * b.scale * 0.5).max(0.05);
+    let dab = |p: &Params| {
+        let q = b.to_px(p.v2("brushPosition"));
+        ([q.0, q.1], radius(if own_size { p } else { pr }), if own_opacity { opacity(p) } else { 1.0 })
+    };
+    let mut segs = vec![];
+    let t = ctx.time;
+    let spacing = pr.f("brushSpacing").max(0.001);
+    let life = pr.f("strokeLength").max(0.0);
+    if let Some(host) = ctx.env.host
+        && t.is_finite()
+        && t >= 0.0
+    {
+        let start = if life > 0.0 { (t - life).max(0.0) } else { 0.0 };
+        let k0 = (start / spacing - 1e-9).ceil().max(0.0) as i64;
+        let k1 = (t / spacing + 1e-9).floor().max(0.0) as i64;
+        let n = k1.saturating_sub(k0).saturating_add(1);
+        let stride = (n / WRITE_ON_MAX_DABS).saturating_add(1).max(1);
+        let mut prev: Option<[f64; 2]> = None;
+        let mut k = k0;
+        while k <= k1 {
+            let tk = k as f64 * spacing;
+            let at = if (tk - t).abs() < 1e-9 { Some(dab(pr)) } else { host.params_at(tk).map(|p| dab(&p)) };
+            if let Some((q, r, v)) = at {
+                // Dabs laid further apart than the brush spacing are joined into a line.
+                let a = if stride > 1 { prev.unwrap_or(q) } else { q };
+                segs.push(Seg { a, b: q, r, v });
+                prev = Some(q);
+            }
+            k = k.saturating_add(stride);
+        }
+    }
+    if segs.is_empty() {
+        let (q, r, v) = dab(pr);
+        segs.push(Seg { a: q, b: q, r, v });
+    }
+    PaintPlan {
+        cov: Coverage::Segs { segs, hardness: pr.f("brushHardness") / 100.0 },
+        color: pr.color("color"),
+        opacity: if own_opacity { 1.0 } else { opacity(pr) },
+        style: pr.e("paintStyle"),
+    }
+}
diff --git a/crates/effects/src/generate3/raster.rs b/crates/effects/src/generate3/raster.rs
new file mode 100644
index 000000000..1b85818d0
--- /dev/null
+++ b/crates/effects/src/generate3/raster.rs
@@ -0,0 +1,368 @@
+use super::{Buf, EffectCtx, IndexedParallelIterator, ParallelIterator, ParallelSliceMut, Plane, Px, smoothstep};
+
+// ---------------------------------------------------------------- shared rasterisation
+
+/// A round-capped line segment in buffer pixels with radius `r` and intensity `v`.
+#[derive(Clone, Copy, Debug)]
+pub struct Seg {
+    pub a: [f64; 2],
+    pub b: [f64; 2],
+    pub r: f64,
+    pub v: f32,
+}
+
+/// Rasterise segments into a coverage plane (max-combined). `hardness` (0..1) is the fraction
+/// of the radius that is fully opaque; the rest falls off smoothly.
+pub(crate) fn raster_segs(w: usize, h: usize, segs: &[Seg], hardness: f64) -> Plane {
+    let mut out = Plane::new(w, h);
+    if w == 0 || h == 0 || segs.is_empty() {
+        return out;
+    }
+    let mut buckets: Vec<Vec<u32>> = vec![Vec::new(); h];
+    for (i, s) in segs.iter().enumerate() {
+        let pad = s.r + 1.0;
+        let y0 = (s.a[1].min(s.b[1]) - pad).floor().max(0.0) as usize;
+        let y1 = (s.a[1].max(s.b[1]) + pad).ceil().min(h as f64);
+        if y1 <= 0.0 || y0 >= h {
+            continue;
+        }
+        for row in buckets.iter_mut().take(y1 as usize).skip(y0) {
+            row.push(i as u32);
+        }
+    }
+    let hard = hardness.clamp(0.0, 1.0);
+    out.data.par_chunks_mut(w).enumerate().for_each(|(y, row)| {
+        let py = y as f64 + 0.5;
+        for &i in &buckets[y] {
+            let s = segs[i as usize];
+            let pad = s.r + 1.0;
+            let x0 = (s.a[0].min(s.b[0]) - pad).floor().max(0.0) as usize;
+            let x1 = ((s.a[0].max(s.b[0]) + pad).ceil().max(0.0) as usize).min(w);
+            let (dx, dy) = (s.b[0] - s.a[0], s.b[1] - s.a[1]);
+            let l2 = dx * dx + dy * dy;
+            let inner = s.r * hard - 0.5;
+            let outer = s.r + 0.5;
+            for (x, o) in row.iter_mut().enumerate().take(x1).skip(x0) {
+                let px = x as f64 + 0.5;
+                let t = if l2 > 1e-12 { (((px - s.a[0]) * dx + (py - s.a[1]) * dy) / l2).clamp(0.0, 1.0) } else { 0.0 };
+                let d = ((px - s.a[0] - dx * t).powi(2) + (py - s.a[1] - dy * t).powi(2)).sqrt();
+                if d >= outer {
+                    continue;
+                }
+                let c = if d <= inner { 1.0 } else { 1.0 - smoothstep(inner as f32, outer as f32, d as f32) } * s.v;
+                if c > *o {
+                    *o = c;
+                }
+            }
+        }
+    });
+    out
+}
+
+/// Segments along a polyline (buffer px).
+pub fn poly_segs(pts: &[[f64; 2]], closed: bool, r: f64, v: f32, out: &mut Vec<Seg>) {
+    let n = pts.len();
+    if n == 1 {
+        out.push(Seg { a: pts[0], b: pts[0], r, v });
+    }
+    if n < 2 {
+        return;
+    }
+    let segs = if closed { n } else { n - 1 };
+    for i in 0..segs {
+        out.push(Seg { a: pts[i], b: pts[(i + 1) % n], r, v });
+    }
+}
+
+/// Portion `[s0, s1]` (arc length) of a polyline.
+pub(crate) fn trim_poly(pts: &[[f64; 2]], closed: bool, s0: f64, s1: f64) -> Vec<[f64; 2]> {
+    let n = pts.len();
+    let mut out = Vec::new();
+    if n < 2 || s1 <= s0 {
+        return out;
+    }
+    let segs = if closed { n } else { n - 1 };
+    let mut acc = 0.0;
+    for i in 0..segs {
+        let (a, b) = (pts[i], pts[(i + 1) % n]);
+        let l = ((b[0] - a[0]).powi(2) + (b[1] - a[1]).powi(2)).sqrt();
+        let (e0, e1) = (acc, acc + l);
+        acc = e1;
+        if e1 < s0 || e0 > s1 || l <= 0.0 {
+            continue;
+        }
+        let at = |s: f64| {
+            let t = ((s - e0) / l).clamp(0.0, 1.0);
+            [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
+        };
+        let p0 = at(s0.max(e0));
+        if out.last() != Some(&p0) {
+            out.push(p0);
+        }
+        out.push(at(s1.min(e1)));
+    }
+    out
+}
+
+#[inline]
+pub(super) fn over(dst: Px, src: Px) -> Px {
+    let k = 1.0 - src[3];
+    [src[0] + dst[0] * k, src[1] + dst[1] * k, src[2] + dst[2] * k, src[3] + dst[3] * k]
+}
+
+/// Mask `idx` (1-based; 0 = none) mapped to buffer pixels.
+pub(crate) fn mask_px(ctx: &EffectCtx, b: &Buf, idx: usize) -> Option<(Vec<[f64; 2]>, bool, bool)> {
+    let m = ctx.env.masks.get(idx.checked_sub(1)?)?;
+    if m.points.is_empty() {
+        return None;
+    }
+    Some((m.points.iter().map(|&q| [q[0] * b.scale + b.offset[0], q[1] * b.scale + b.offset[1]]).collect(), m.closed, m.inverted))
+}
+
+/// All masks mapped to buffer pixels.
+pub(super) fn all_masks_px(ctx: &EffectCtx, b: &Buf) -> Vec<(Vec<[f64; 2]>, bool, bool)> {
+    (1..=ctx.env.masks.len()).filter_map(|i| mask_px(ctx, b, i)).collect()
+}
+
+/// Chaikin corner cutting (open polyline, endpoints kept).
+pub(super) fn chaikin(pts: &[[f64; 2]], iters: usize) -> Vec<[f64; 2]> {
+    let mut cur = pts.to_vec();
+    for _ in 0..iters {
+        if cur.len() < 3 {
+            return cur;
+        }
+        let mut nx = Vec::with_capacity(cur.len() * 2);
+        nx.push(cur[0]);
+        for w in cur.windows(2) {
+            let (a, b) = (w[0], w[1]);
+            nx.push([a[0] * 0.75 + b[0] * 0.25, a[1] * 0.75 + b[1] * 0.25]);
+            nx.push([a[0] * 0.25 + b[0] * 0.75, a[1] * 0.25 + b[1] * 0.75]);
+        }
+        nx.push(*cur.last().unwrap_or(&[0.0; 2]));
+        cur = nx;
+    }
+    cur
+}
+
+// ---------------------------------------------------------------- Scribble
+
+/// Scan runs (start, end along direction `d`) of the fill region on the line `n·p = s`.
+pub(super) fn scan_runs(polys: &[(Vec<[f64; 2]>, bool, bool)], fill: u32, ew: f64, d: [f64; 2], n: [f64; 2], s: f64, out: &mut Vec<(f64, f64)>) {
+    out.clear();
+    for (pts, _closed, inverted) in polys {
+        let m = pts.len();
+        if m < 2 {
+            continue;
+        }
+        // Crossings: (t along d, |sin| of crossing angle).
+        let mut xs: Vec<(f64, f64)> = Vec::new();
+        for i in 0..m {
+            let (a, b) = (pts[i], pts[(i + 1) % m]);
+            let (na, nb) = (a[0] * n[0] + a[1] * n[1] - s, b[0] * n[0] + b[1] * n[1] - s);
+            if (na > 0.0) == (nb > 0.0) {
+                continue;
+            }
+            let t = na / (na - nb);
+            let q = [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+            let (ex, ey) = (b[0] - a[0], b[1] - a[1]);
+            let el = (ex * ex + ey * ey).sqrt().max(1e-9);
+            let sin = ((ex * n[0] + ey * n[1]) / el).abs().max(0.2);
+            xs.push((q[0] * d[0] + q[1] * d[1], sin));
+        }
+        xs.sort_by(|a, b| a.0.total_cmp(&b.0));
+        // Signed area decides which side is "left".
+        let area: f64 = (0..m).map(|i| pts[i][0] * pts[(i + 1) % m][1] - pts[(i + 1) % m][0] * pts[i][1]).sum();
+        let left_is_inside = area < 0.0;
+        let mode = match fill {
+            4 => {
+                if left_is_inside {
+                    2
+                } else {
+                    3
+                }
+            }
+            5 => {
+                if left_is_inside {
+                    3
+                } else {
+                    2
+                }
+            }
+            f => f,
+        };
+        let mode = if *inverted && mode == 0 { 6 } else { mode };
+        for (k, &(t, sin)) in xs.iter().enumerate() {
+            let entering = k % 2 == 0;
+            let l = ew / sin;
+            match mode {
+                0 if entering && k + 1 < xs.len() => {
+                    out.push((t, xs[k + 1].0));
+                }
+                1 => out.push((t - l * 0.5, t + l * 0.5)),
+                2 => out.push(if entering { (t, t + l) } else { (t - l, t) }),
+                3 => out.push(if entering { (t - l, t) } else { (t, t + l) }),
+                _ => {}
+            }
+        }
+        if mode == 6 {
+            // Inverted Inside: outside of the polygon within the bounds.
+            let lo = pts.iter().map(|q| q[0] * d[0] + q[1] * d[1]).fold(f64::INFINITY, f64::min) - ew;
+            let hi = pts.iter().map(|q| q[0] * d[0] + q[1] * d[1]).fold(f64::NEG_INFINITY, f64::max) + ew;
+            let mut cur = lo;
+            for pair in xs.chunks(2) {
+                out.push((cur, pair[0].0));
+                cur = pair.get(1).map(|v| v.0).unwrap_or(hi);
+            }
+            out.push((cur, hi));
+        }
+    }
+    out.sort_by(|a, b| a.0.total_cmp(&b.0));
+    // Merge overlaps.
+    let mut merged: Vec<(f64, f64)> = Vec::with_capacity(out.len());
+    for &(a, b) in out.iter() {
+        if let Some(last) = merged.last_mut()
+            && a <= last.1
+        {
+            last.1 = last.1.max(b);
+            continue;
+        }
+        merged.push((a, b));
+    }
+    *out = merged;
+}
+
+/// End Cap and Join options (Scribble's Edge Options).
+pub(super) const END_CAPS: [&str; 3] = ["Round", "Butt", "Projecting"];
+
+pub(super) const JOINS: [&str; 3] = ["Round", "Miter", "Bevel"];
+
+/// Convex polygons whose union is the stroke of the polylines `lines` with half width `r`:
+/// one quad per segment, plus the joins (Round discs, Miter wedges up to `miter_limit` × the
+/// half width, Bevel triangles) and the caps (Round discs, Butt none, Projecting square ends).
+pub(crate) fn stroke_outline(lines: &[Vec<[f64; 2]>], r: f64, cap: u32, join: u32, miter_limit: f64) -> Vec<Vec<[f64; 2]>> {
+    let disc = |c: [f64; 2]| -> Vec<[f64; 2]> {
+        (0..16).map(|k| (k as f64 / 16.0 * std::f64::consts::TAU).sin_cos()).map(|(s, co)| [c[0] + co * r, c[1] + s * r]).collect()
+    };
+    let mut out = Vec::new();
+    for l in lines {
+        let pts: Vec<[f64; 2]> = l.iter().copied().fold(Vec::new(), |mut v, p| {
+            if v.last().is_none_or(|q: &[f64; 2]| (q[0] - p[0]).hypot(q[1] - p[1]) > 1e-9) {
+                v.push(p);
+            }
+            v
+        });
+        if pts.len() < 2 {
+            if let (Some(p), 0) = (pts.first(), cap) {
+                out.push(disc(*p));
+            }
+            continue;
+        }
+        let dir = |a: [f64; 2], b: [f64; 2]| {
+            let (dx, dy) = (b[0] - a[0], b[1] - a[1]);
+            let l = dx.hypot(dy).max(1e-12);
+            [dx / l, dy / l]
+        };
+        let n = pts.len();
+        for k in 0..n - 1 {
+            let (mut a, mut b) = (pts[k], pts[k + 1]);
+            let d = dir(a, b);
+            // Projecting caps extend the end segments by the half width.
+            if cap == 2 && k == 0 {
+                a = [a[0] - d[0] * r, a[1] - d[1] * r];
+            }
+            if cap == 2 && k == n - 2 {
+                b = [b[0] + d[0] * r, b[1] + d[1] * r];
+            }
+            let nn = [-d[1] * r, d[0] * r];
+            out.push(vec![[a[0] + nn[0], a[1] + nn[1]], [b[0] + nn[0], b[1] + nn[1]], [b[0] - nn[0], b[1] - nn[1]], [a[0] - nn[0], a[1] - nn[1]]]);
+        }
+        // Joins.
+        for k in 1..n - 1 {
+            let (p, d0, d1) = (pts[k], dir(pts[k - 1], pts[k]), dir(pts[k], pts[k + 1]));
+            let cross = d0[0] * d1[1] - d0[1] * d1[0];
+            if cross.abs() < 1e-9 && d0[0] * d1[0] + d0[1] * d1[1] > 0.0 {
+                continue;
+            }
+            if join == 0 {
+                out.push(disc(p));
+                continue;
+            }
+            // The outer side of the turn.
+            let s = if cross > 0.0 { -1.0 } else { 1.0 };
+            let o0 = [p[0] - d0[1] * r * s, p[1] + d0[0] * r * s];
+            let o1 = [p[0] - d1[1] * r * s, p[1] + d1[0] * r * s];
+            let bevel = vec![p, o0, o1];
+            if join == 1 {
+                // Miter point: where the two offset edges meet.
+                let bis = [d0[0] - d1[0], d0[1] - d1[1]];
+                let bl = bis[0].hypot(bis[1]);
+                let cos_half = ((1.0 + d0[0] * d1[0] + d0[1] * d1[1]) * 0.5).max(0.0).sqrt();
+                let len = if cos_half > 1e-6 { r / cos_half } else { f64::INFINITY };
+                if bl > 1e-9 && len <= miter_limit * r {
+                    let m = [p[0] + (o0[0] + o1[0] - 2.0 * p[0]) * 0.5, p[1] + (o0[1] + o1[1] - 2.0 * p[1]) * 0.5];
+                    let ml = (m[0] - p[0]).hypot(m[1] - p[1]).max(1e-12);
+                    let tip = [p[0] + (m[0] - p[0]) / ml * len, p[1] + (m[1] - p[1]) / ml * len];
+                    out.push(vec![p, o0, tip, o1]);
+                    continue;
+                }
+            }
+            out.push(bevel);
+        }
+        if cap == 0 {
+            out.push(disc(pts[0]));
+            out.push(disc(pts[n - 1]));
+        }
+    }
+    out
+}
+
+/// Coverage (union, 4×4 samples per pixel) of convex polygons on a `w`×`h` grid.
+pub(crate) fn raster_convex(w: usize, h: usize, polys: &[Vec<[f64; 2]>]) -> Plane {
+    let mut out = Plane::new(w, h);
+    let inside = |poly: &[[f64; 2]], x: f64, y: f64| {
+        let n = poly.len();
+        let mut sign = 0.0;
+        for i in 0..n {
+            let (a, b) = (poly[i], poly[(i + 1) % n]);
+            let c = (b[0] - a[0]) * (y - a[1]) - (b[1] - a[1]) * (x - a[0]);
+            if c.abs() < 1e-12 {
+                continue;
+            }
+            if sign == 0.0 {
+                sign = c.signum();
+            } else if c.signum() != sign {
+                return false;
+            }
+        }
+        true
+    };
+    for poly in polys {
+        if poly.len() < 3 {
+            continue;
+        }
+        let (mut x0, mut y0, mut x1, mut y1) = (f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);
+        for p in poly {
+            x0 = x0.min(p[0]);
+            y0 = y0.min(p[1]);
+            x1 = x1.max(p[0]);
+            y1 = y1.max(p[1]);
+        }
+        let (xa, xb) = (x0.floor().max(0.0) as usize, (x1.ceil().max(0.0) as usize).min(w));
+        let (ya, yb) = (y0.floor().max(0.0) as usize, (y1.ceil().max(0.0) as usize).min(h));
+        for y in ya..yb {
+            for x in xa..xb {
+                let mut hit = 0;
+                for sy in 0..4 {
+                    for sx in 0..4 {
+                        if inside(poly, x as f64 + (sx as f64 + 0.5) / 4.0, y as f64 + (sy as f64 + 0.5) / 4.0) {
+                            hit += 1;
+                        }
+                    }
+                }
+                let v = &mut out.data[y * w + x];
+                *v = v.max(hit as f32 / 16.0);
+            }
+        }
+    }
+    out
+}
diff --git a/crates/effects/src/generate3/registry.rs b/crates/effects/src/generate3/registry.rs
new file mode 100644
index 000000000..06c2b35fb
--- /dev/null
+++ b/crates/effects/src/generate3/registry.rs
@@ -0,0 +1,265 @@
+use super::audio::{audio_spectrum, audio_waveform};
+use super::common::{pct, pt, spec};
+use super::fill::{eyedropper_fill, glue_gun, paint_bucket, threads};
+use super::fractal::{FRACTAL_OVERSAMPLE, FRACTAL_PALETTES, FRACTAL_SETS, fractal};
+use super::paths::{scribble, stroke, vegas, write_on};
+use super::raster::{END_CAPS, JOINS};
+use super::{EffectSpec, ParamUi, Value, col, num, p, popup, slider};
+
+// ---------------------------------------------------------------- registry
+
+pub fn specs() -> Vec<EffectSpec> {
+    let ang = || ParamUi::Angle;
+    let check = |id: &'static str, name: &'static str, v: bool| p(id, name, Value::Bool(v), ParamUi::Checkbox);
+    let paint_style = || popup(&["On Original Image", "On Transparent", "Reveal Original Image"]);
+    let mask_idx = |id: &'static str, name: &'static str, d: f64| p(id, name, num(d), ParamUi::Mask);
+    let display = || popup(&["Digital", "Analog lines", "Analog dots"]);
+    vec![
+        spec(
+            "ec.generate.fractal",
+            "Fractal",
+            vec![
+                p("setChoice", "Set Choice", Value::Enum(0), popup(&FRACTAL_SETS)),
+                p("equation", "Equation", Value::Enum(0), popup(&["z = z^2 + c", "z = z^3 + c", "z = z^4 + c"])),
+                p("mandelbrot/mandelbrotX", "X (Real)", num(-0.74), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+                p("mandelbrot/mandelbrotY", "Y (Imaginary)", num(0.15), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+                p("mandelbrot/mandelbrotMagnification", "Magnification", num(0.0), slider(-5.0, 30.0, -5.0, 30.0, 2)),
+                p("mandelbrot/mandelbrotEscapeLimit", "Escape Limit", num(4.0), slider(1.0, 1000.0, 1.0, 100.0, 1)),
+                p("julia/juliaX", "X (Real)", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+                p("julia/juliaY", "Y (Imaginary)", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+                p("julia/juliaMagnification", "Magnification", num(0.0), slider(-5.0, 30.0, -5.0, 30.0, 2)),
+                p("julia/juliaEscapeLimit", "Escape Limit", num(4.0), slider(1.0, 1000.0, 1.0, 100.0, 1)),
+                p("postInversionOffset/postInversionX", "X Offset", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+                p("postInversionOffset/postInversionY", "Y Offset", num(0.0), slider(-2.0, 2.0, -2.0, 2.0, 4)),
+                check("fractalColor/overlay", "Overlay", false),
+                check("fractalColor/transparency", "Transparency", false),
+                p("fractalColor/palette", "Palette", Value::Enum(0), popup(&FRACTAL_PALETTES)),
+                p("fractalColor/hue", "Hue", num(0.0), ang()),
+                p("fractalColor/cycleSteps", "Cycle Steps", num(32.0), slider(1.0, 1000.0, 1.0, 256.0, 0)),
+                p("fractalColor/cycleOffset", "Cycle Offset", num(0.0), ang()),
+                check("fractalColor/edgeHighlight", "Edge Highlight", false),
+                p("highQualitySettings/samplingMethod", "Oversample Method", Value::Enum(0), popup(&FRACTAL_OVERSAMPLE)),
+                p("highQualitySettings/samplingFactor", "Oversample Factor", num(2.0), slider(1.0, 9.0, 1.0, 9.0, 0)),
+            ],
+            fractal,
+        ),
+        spec(
+            "ec.generate.scribble",
+            "Scribble",
+            vec![
+                p("scribble", "Scribble", Value::Enum(0), popup(&["Single Mask", "All Masks", "All Masks Using Modes"])),
+                mask_idx("mask", "Mask", 1.0),
+                p("fillType", "Fill Type", Value::Enum(0), popup(&["Inside", "Centered Edge", "Inside Edge", "Outside Edge", "Left Edge", "Right Edge"])),
+                p("edgeOptions/edgeWidth", "Edge Width", num(10.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
+                p("edgeOptions/endCap", "End Cap", Value::Enum(0), popup(&END_CAPS)),
+                p("edgeOptions/join", "Join", Value::Enum(0), popup(&JOINS)),
+                p("edgeOptions/miterLimit", "Miter Limit", num(4.0), slider(1.0, 100.0, 1.0, 20.0, 1)),
+                p("color", "Color", col(1.0, 0.0, 0.0), ParamUi::Color),
+                p("opacity", "Opacity", num(100.0), pct()),
+                p("angle", "Angle", num(45.0), ang()),
+                p("strokeWidth", "Stroke Width", num(2.0), slider(0.1, 50.0, 0.1, 50.0, 1)),
+                p("strokeOptions/curviness", "Curviness", num(50.0), pct()),
+                p("strokeOptions/curvinessVariation", "Curviness Variation", num(50.0), pct()),
+                p("strokeOptions/spacing", "Spacing", num(5.0), slider(0.1, 100.0, 0.1, 50.0, 1)),
+                p("strokeOptions/spacingVariation", "Spacing Variation", num(50.0), pct()),
+                p("strokeOptions/pathOverlap", "Path Overlap", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
+                p("strokeOptions/pathOverlapVariation", "Path Overlap Variation", num(50.0), pct()),
+                p("start", "Start", num(0.0), pct()),
+                p("end", "End", num(100.0), pct()),
+                p("startEndApplyTo", "Start/End Apply To", Value::Enum(0), popup(&["All Strokes", "Each Stroke"])),
+                check("fillPathsSequentially", "Fill Paths Sequentially", true),
+                p("wiggleType", "Wiggle Type", Value::Enum(1), popup(&["Static", "Jumpy", "Smooth"])),
+                p("wigglesPerSecond", "Wiggles/Second", num(5.0), slider(0.0, 100.0, 0.0, 30.0, 2)),
+                p("randomSeed", "Random Seed", num(1.0), slider(0.0, 10000.0, 0.0, 100.0, 0)),
+                p("composite", "Composite", Value::Enum(1), popup(&["On Original Image", "On Transparent", "Reveal Original Image"])),
+            ],
+            scribble,
+        ),
+        spec(
+            "ec.generate.stroke",
+            "Stroke",
+            vec![
+                mask_idx("path", "Path", 1.0),
+                check("allMasks", "All Masks", false),
+                check("strokeSequentially", "Stroke Sequentially", true),
+                p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("brushSize", "Brush Size", num(2.0), slider(0.0, 50.0, 0.0, 50.0, 1)),
+                p("brushHardness", "Brush Hardness", num(75.0), pct()),
+                p("opacity", "Opacity", num(100.0), pct()),
+                p("start", "Start", num(0.0), pct()),
+                p("end", "End", num(100.0), pct()),
+                p("spacing", "Spacing", num(15.0), slider(0.0, 100.0, 0.0, 100.0, 1)),
+                p("paintStyle", "Paint Style", Value::Enum(0), paint_style()),
+            ],
+            stroke,
+        ),
+        spec(
+            "ec.generate.vegas",
+            "Vegas",
+            vec![
+                p("stroke", "Stroke", Value::Enum(0), popup(&["Image Contours", "Mask/Path"])),
+                p("inputLayer", "Image Contours: Input Layer", Value::Layer(None), ParamUi::Layer),
+                check("invertInput", "Image Contours: Invert Input", false),
+                p("ifLayerSizesDiffer", "Image Contours: If Layer Sizes Differ", Value::Enum(0), popup(&["Center", "Stretch to Fit"])),
+                p("channel", "Image Contours: Channel", Value::Enum(0), popup(&["Intensity", "Red", "Green", "Blue", "Alpha"])),
+                p("threshold", "Image Contours: Threshold", num(50.0), pct()),
+                p("preBlur", "Image Contours: Pre-Blur", num(1.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
+                p("tolerance", "Image Contours: Tolerance", num(0.01), slider(0.0, 1.0, 0.0, 0.1, 3)),
+                p("renderMode", "Image Contours: Render", Value::Enum(0), popup(&["All Contours", "Selected Contour"])),
+                p("selectedContour", "Image Contours: Selected Contour", num(1.0), slider(1.0, 1000.0, 1.0, 20.0, 0)),
+                p("shorterContoursHave", "Image Contours: Shorter Contours Have", Value::Enum(0), popup(&["Same Number of Segments", "Fewer Segments"])),
+                mask_idx("path", "Mask/Path: Path", 1.0),
+                p("segments", "Segments: Segments", num(32.0), slider(1.0, 1000.0, 1.0, 100.0, 0)),
+                p("length", "Segments: Length", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("segmentDistribution", "Segments: Segment Distribution", Value::Enum(0), popup(&["Bunched", "Even"])),
+                p("rotation", "Segments: Rotation", num(0.0), ang()),
+                check("randomPhase", "Segments: Random Phase", false),
+                p("randomSeed", "Segments: Random Seed", num(1.0), slider(1.0, 10000.0, 1.0, 100.0, 0)),
+                p("blendMode", "Rendering: Blend Mode", Value::Enum(1), popup(&["Transparent", "Over", "Under", "Stencil"])),
+                p("color", "Rendering: Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("width", "Rendering: Width", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
+                p("hardness", "Rendering: Hardness", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("startOpacity", "Rendering: Start Opacity", num(1.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("midpointOpacity", "Rendering: Mid-point Opacity", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("midpointPosition", "Rendering: Mid-point Position", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("endOpacity", "Rendering: End Opacity", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+            ],
+            vegas,
+        ),
+        spec(
+            "ec.generate.writeon",
+            "Write-on",
+            vec![
+                p("brushPosition", "Brush Position", pt(0.5, 0.5), ParamUi::Point),
+                p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("brushSize", "Brush Size", num(6.0), slider(0.0, 50.0, 0.0, 50.0, 1)),
+                p("brushHardness", "Brush Hardness", num(75.0), pct()),
+                p("brushOpacity", "Brush Opacity", num(100.0), pct()),
+                p("strokeLength", "Stroke Length (secs)", num(0.0), slider(0.0, 30.0, 0.0, 30.0, 1)),
+                p("brushSpacing", "Brush Spacing (secs)", num(0.001), slider(0.001, 5.0, 0.001, 5.0, 3)),
+                p("paintTimeProperties", "Paint Time Properties", Value::Enum(0), popup(&["None", "Opacity", "Color"])),
+                p("brushTimeProperties", "Brush Time Properties", Value::Enum(0), popup(&["None", "Size", "Hardness", "Size & Hardness"])),
+                p("paintStyle", "Paint Style", Value::Enum(0), paint_style()),
+            ],
+            write_on,
+        ),
+        spec(
+            "ec.generate.paintbucket",
+            "Paint Bucket",
+            vec![
+                p("fillPoint", "Fill Point", pt(0.5, 0.5), ParamUi::Point),
+                p("fillSelector", "Fill Selector", Value::Enum(0), popup(&["Color & Alpha", "Straight Color", "Transparency", "Opacity", "Alpha Channel"])),
+                p("tolerance", "Tolerance", num(10.0), slider(0.0, 255.0, 0.0, 100.0, 1)),
+                check("viewThreshold", "View Threshold", false),
+                p("stroke", "Stroke", Value::Enum(0), popup(&["Antialias", "Feather", "Spread", "Choke", "Stroke"])),
+                p("featherSoftness", "Feather Softness", num(10.0), slider(0.0, 100.0, 0.0, 50.0, 1)),
+                p("spreadRadius", "Spread Radius", num(3.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
+                p("strokeWidth", "Stroke Width", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
+                p("color", "Color", col(1.0, 0.0, 0.0), ParamUi::Color),
+                p("opacity", "Opacity", num(100.0), pct()),
+                p(
+                    "blendingMode",
+                    "Blending Mode",
+                    Value::Enum(0),
+                    popup(&["Normal", "Add", "Multiply", "Screen", "Hue", "Saturation", "Color", "Luminosity", "Behind", "Fill Only"]),
+                ),
+            ],
+            paint_bucket,
+        ),
+        spec(
+            "ec.generate.eyedropperfill",
+            "Eyedropper Fill",
+            vec![
+                p("samplePoint", "Sample Point", pt(0.5, 0.5), ParamUi::Point),
+                p("sampleRadius", "Sample Radius", num(0.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
+                p("averagePixelColors", "Average Pixel Colors", Value::Enum(0), popup(&["Skip Empty", "All", "All Premultiplied", "Including Alpha"])),
+                check("maintainOriginalAlpha", "Maintain Original Alpha", false),
+                p("blendWithOriginal", "Blend With Original", num(0.0), pct()),
+            ],
+            eyedropper_fill,
+        ),
+        spec(
+            "ec.generate.ccgluegun",
+            "CC Glue Gun",
+            vec![
+                p("brushPosition", "Brush Position", pt(0.5, 0.5), ParamUi::Point),
+                p("strokeWidth", "Stroke Width", num(25.0), slider(0.0, 500.0, 0.0, 100.0, 1)),
+                p("density", "Density", num(5.0), slider(0.0, 32.0, 0.0, 32.0, 1)),
+                p("timeSpan", "Time Span (sec)", num(1.0), slider(0.0, 60.0, 0.0, 10.0, 2)),
+                p("reflection", "Reflection", num(45.0), ang()),
+                p("strength", "Strength", num(100.0), pct()),
+                p("style", "Style", Value::Enum(0), popup(&["Over Layer", "Glue Only"])),
+            ],
+            glue_gun,
+        ),
+        spec(
+            "ec.generate.ccthreads",
+            "CC Threads",
+            vec![
+                p("width", "Width", num(50.0), slider(1.0, 1000.0, 1.0, 200.0, 1)),
+                p("height", "Height", num(50.0), slider(1.0, 1000.0, 1.0, 200.0, 1)),
+                p("overlaps", "Overlaps", num(1.0), slider(1.0, 20.0, 1.0, 10.0, 0)),
+                p("direction", "Direction", num(0.0), ang()),
+                p("center", "Center", pt(0.5, 0.5), ParamUi::Point),
+                p("coverage", "Coverage", num(80.0), pct()),
+                p("shadowing", "Shadowing", num(50.0), pct()),
+                p("texture", "Texture", num(10.0), pct()),
+            ],
+            threads,
+        ),
+        spec(
+            "ec.generate.audiospectrum",
+            "Audio Spectrum",
+            vec![
+                p("audioLayer", "Audio Layer", Value::Layer(None), ParamUi::Layer),
+                p("startPoint", "Start Point", pt(0.1, 0.5), ParamUi::Point),
+                p("endPoint", "End Point", pt(0.9, 0.5), ParamUi::Point),
+                mask_idx("path", "Path", 0.0),
+                check("usePolarPath", "Use Polar Path", false),
+                p("startFrequency", "Start Frequency", num(20.0), slider(1.0, 20000.0, 1.0, 2000.0, 0)),
+                p("endFrequency", "End Frequency", num(2000.0), slider(1.0, 20000.0, 1.0, 10000.0, 0)),
+                p("frequencyBands", "Frequency bands", num(64.0), slider(1.0, 4096.0, 1.0, 256.0, 0)),
+                p("maximumHeight", "Maximum Height", num(50.0), slider(0.0, 10000.0, 0.0, 500.0, 1)),
+                p("audioDuration", "Audio Duration (milliseconds)", num(90.0), slider(1.0, 30000.0, 1.0, 1000.0, 1)),
+                p("audioOffset", "Audio Offset (milliseconds)", num(0.0), slider(-30000.0, 30000.0, -1000.0, 1000.0, 1)),
+                p("thickness", "Thickness", num(3.0), slider(0.0, 1000.0, 0.0, 50.0, 2)),
+                p("softness", "Softness", num(50.0), pct()),
+                p("insideColor", "Inside Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("outsideColor", "Outside Color", col(0.2, 0.4, 1.0), ParamUi::Color),
+                check("blendOverlappingColors", "Blend Overlapping Colors", true),
+                p("hueInterpolation", "Hue Interpolation", num(0.0), ang()),
+                check("dynamicHuePhase", "Dynamic Hue Phase", false),
+                check("colorSymmetry", "Color Symmetry", false),
+                p("displayOptions", "Display Options", Value::Enum(0), display()),
+                p("sideOptions", "Side Options", Value::Enum(0), popup(&["Side A", "Side B", "Side A & B"])),
+                check("durationAveraging", "Duration Averaging", false),
+                check("compositeOnOriginal", "Composite On Original", false),
+            ],
+            audio_spectrum,
+        ),
+        spec(
+            "ec.generate.audiowaveform",
+            "Audio Waveform",
+            vec![
+                p("audioLayer", "Audio Layer", Value::Layer(None), ParamUi::Layer),
+                p("startPoint", "Start Point", pt(0.1, 0.5), ParamUi::Point),
+                p("endPoint", "End Point", pt(0.9, 0.5), ParamUi::Point),
+                mask_idx("path", "Path", 0.0),
+                check("usePolarPath", "Use Polar Path", false),
+                p("displayedSamples", "Displayed Samples", num(200.0), slider(2.0, 4096.0, 2.0, 1000.0, 0)),
+                p("maximumHeight", "Maximum Height", num(100.0), slider(0.0, 10000.0, 0.0, 500.0, 1)),
+                p("audioDuration", "Audio Duration (milliseconds)", num(200.0), slider(1.0, 30000.0, 1.0, 1000.0, 1)),
+                p("audioOffset", "Audio Offset (milliseconds)", num(0.0), slider(-30000.0, 30000.0, -1000.0, 1000.0, 1)),
+                p("thickness", "Thickness", num(2.0), slider(0.0, 1000.0, 0.0, 50.0, 2)),
+                p("softness", "Softness", num(10.0), pct()),
+                p("randomSeed", "Random Seed (Analog)", num(1.0), slider(1.0, 10000.0, 1.0, 100.0, 0)),
+                p("insideColor", "Inside Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("outsideColor", "Outside Color", col(0.2, 0.4, 1.0), ParamUi::Color),
+                p("waveformOptions", "Waveform Options", Value::Enum(0), popup(&["Mono", "Left", "Right"])),
+                p("displayOptions", "Display Options", Value::Enum(1), display()),
+                check("compositeOnOriginal", "Composite On Original", false),
+            ],
+            audio_waveform,
+        ),
+    ]
+}
diff --git a/crates/effects/src/generate3/tests.rs b/crates/effects/src/generate3/tests.rs
new file mode 100644
index 000000000..deb0d7dda
--- /dev/null
+++ b/crates/effects/src/generate3/tests.rs
@@ -0,0 +1,439 @@
+use super::*;
+use crate::{EffectEnv, EffectHost, LayerPixels, MaskShape, Params};
+
+/// Run with point defaults scaled to the layer size.
+pub(crate) fn run_env(id: &str, set: &[(&str, Value)], img: Image, time: f64, env: EffectEnv) -> Buf {
+    let s = crate::find(id).unwrap();
+    let ls = [img.width as f64, img.height as f64];
+    let mut params = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+    for p in &s.params {
+        if let (ParamUi::Point, Value::Vec2(v)) = (&p.ui, &p.default) {
+            params.values.insert(p.id.to_string(), Value::Vec2([v[0] * ls[0], v[1] * ls[1]]));
+        }
+    }
+    for (k, v) in set {
+        assert!(params.values.contains_key(*k), "{id}: unknown {k}");
+        params.values.insert(k.to_string(), v.clone());
+    }
+    let ctx = EffectCtx { params: &params, time, layer_size: ls, seed: 3, adjustment: false, env };
+    crate::apply(s, &ctx, Buf { img, offset: [0.0, 0.0], scale: 1.0 })
+}
+
+fn run(id: &str, set: &[(&str, Value)], img: Image) -> Buf {
+    run_env(id, set, img, 0.5, EffectEnv::default())
+}
+
+fn square_mask() -> Vec<MaskShape> {
+    vec![MaskShape { name: "Mask 1".into(), points: vec![[16.0, 16.0], [48.0, 16.0], [48.0, 48.0], [16.0, 48.0]], closed: true, inverted: false }]
+}
+
+fn alpha_sum(img: &Image, x0: usize, y0: usize, x1: usize, y1: usize) -> f32 {
+    let mut s = 0.0;
+    for y in y0..y1 {
+        for x in x0..x1 {
+            s += img.data[y * img.width as usize + x][3];
+        }
+    }
+    s
+}
+
+#[test]
+fn audio_spectrum_linear_frequency_and_linear_amplitude() {
+    let host = Tone; // Tone produces 440 Hz
+    let env = EffectEnv { host: Some(&host), comp_time: 1.0, ..Default::default() };
+    let img = Image::new(200, 100);
+    let out = run_env(
+        "ec.generate.audiospectrum",
+        &[
+            ("audioLayer", Value::Layer(Some(1))),
+            ("startPoint", Value::Vec2([0.0, 50.0])),
+            ("endPoint", Value::Vec2([200.0, 50.0])),
+            ("startFrequency", num(20.0)),
+            ("endFrequency", num(2000.0)),
+            ("frequencyBands", num(100.0)),
+            ("maximumHeight", num(40.0)),
+            ("thickness", num(2.0)),
+            ("softness", num(0.0)),
+        ],
+        img,
+        1.0,
+        env,
+    );
+    // Verify 440 Hz tone produces a peak above baseline, while high frequencies have zero bar height
+    let peak_zone = alpha_sum(&out.img, 36, 10, 48, 48);
+    let high_zone = alpha_sum(&out.img, 120, 10, 150, 48);
+    let silent_zone = alpha_sum(&out.img, 170, 10, 195, 48);
+    assert!(peak_zone > 5.0, "peak zone has energy: {peak_zone}");
+    assert!(peak_zone > high_zone * 2.0, "linear peak is distinctly taller than far frequencies: {peak_zone} vs {high_zone}");
+    assert_eq!(silent_zone, 0.0, "silent end has zero height, not boosted by dB scale");
+}
+
+#[test]
+fn fractal_deterministic_and_has_inside_set() {
+    let img = Image::new(64, 48);
+    let a = run("ec.generate.fractal", &[], img.clone());
+    let b = run("ec.generate.fractal", &[], img.clone());
+    assert_eq!(a.img.data, b.img.data);
+    // The default view contains the main cardioid (black, opaque) and escaped (coloured) points.
+    assert!(a.img.data.iter().any(|p| p[3] > 0.99 && p[0] + p[1] + p[2] < 0.01));
+    assert!(a.img.data.iter().any(|p| p[0] + p[1] + p[2] > 0.3));
+    let t = run("ec.generate.fractal", &[("fractalColor/transparency", Value::Bool(true))], img);
+    assert!(t.img.data.iter().any(|p| p[3] == 0.0));
+}
+
+#[test]
+fn fractal_palettes_and_set_choices() {
+    let img = Image::new(64, 48);
+    // Solid Color: only the inside of the set is drawn; Transparency flips it.
+    let solid = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(3))], img.clone());
+    assert!(solid.img.data.iter().any(|p| p[3] == 0.0) && solid.img.data.iter().any(|p| p[3] > 0.99 && p[0] > 0.9));
+    let flipped = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(3)), ("fractalColor/transparency", Value::Bool(true))], img.clone());
+    for (a, b) in solid.img.data.iter().zip(&flipped.img.data) {
+        assert!((a[3] > 0.5) != (b[3] > 0.5) || (a[3] - 0.5).abs() < 0.49);
+    }
+    // Black And White: escaped pixels are pure black or white (away from supersampled edges).
+    let bw = run("ec.generate.fractal", &[("fractalColor/palette", Value::Enum(2)), ("highQualitySettings/samplingFactor", num(1.0))], img.clone());
+    assert!(bw.img.data.iter().all(|p| p[0] == p[1] && p[1] == p[2] && (p[0] == 0.0 || p[0] == 1.0)));
+    // Mandelbrot Over Julia depends on the Julia centre.
+    let o1 = run("ec.generate.fractal", &[("setChoice", Value::Enum(2)), ("julia/juliaX", num(0.3))], img.clone());
+    let o2 = run("ec.generate.fractal", &[("setChoice", Value::Enum(2)), ("julia/juliaX", num(-0.2))], img.clone());
+    assert_ne!(o1.img.data, o2.img.data);
+    let plain = run("ec.generate.fractal", &[("julia/juliaX", num(0.3))], img);
+    assert_ne!(o1.img.data, plain.img.data);
+}
+
+#[test]
+fn scribble_fills_mask_and_animates() {
+    let masks = square_mask();
+    let env = EffectEnv { masks: &masks, ..Default::default() };
+    let img = Image::filled(64, 64, [0.0, 0.0, 1.0, 1.0]);
+    let a = run_env("ec.generate.scribble", &[], img.clone(), 0.5, env);
+    let b = run_env("ec.generate.scribble", &[], img.clone(), 0.5, env);
+    assert_eq!(a.img.data, b.img.data);
+    let inside = alpha_sum(&a.img, 18, 18, 46, 46);
+    let outside = alpha_sum(&a.img, 0, 0, 10, 64);
+    assert!(inside > 100.0 && outside < 1.0, "{inside} {outside}");
+    let c = run_env("ec.generate.scribble", &[], img.clone(), 1.5, env);
+    assert_ne!(a.img.data, c.img.data, "jumpy wiggle changes over time");
+    let s = run_env("ec.generate.scribble", &[("wiggleType", Value::Enum(0))], img.clone(), 0.5, env);
+    let s2 = run_env("ec.generate.scribble", &[("wiggleType", Value::Enum(0))], img.clone(), 3.5, env);
+    assert_eq!(s.img.data, s2.img.data, "static wiggle is constant");
+    let half = run_env("ec.generate.scribble", &[("end", num(50.0))], img, 0.5, env);
+    assert!(alpha_sum(&half.img, 0, 0, 64, 64) < alpha_sum(&a.img, 0, 0, 64, 64));
+}
+
+#[test]
+fn scribble_edge_types() {
+    let masks = square_mask();
+    let env = EffectEnv { masks: &masks, ..Default::default() };
+    let img = Image::new(64, 64);
+    let o = run_env("ec.generate.scribble", &[("fillType", Value::Enum(3)), ("edgeOptions/edgeWidth", num(6.0))], img, 0.5, env);
+    // Outside edge: paint near the border outside, nothing in the centre.
+    assert!(alpha_sum(&o.img, 26, 26, 38, 38) < 0.5);
+    assert!(alpha_sum(&o.img, 8, 8, 16, 56) > 5.0);
+}
+
+#[test]
+fn stroke_draws_along_mask() {
+    let masks = square_mask();
+    let env = EffectEnv { masks: &masks, ..Default::default() };
+    let img = Image::new(64, 64);
+    let a = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("paintStyle", Value::Enum(1))], img.clone(), 0.0, env);
+    assert!(a.img.get(32, 16)[3] > 0.9, "on the top edge");
+    assert!(a.img.get(32, 32)[3] < 0.01, "centre empty");
+    let b = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("end", num(25.0))], img.clone(), 0.0, env);
+    assert!(b.img.get(32, 16)[3] > 0.9 && b.img.get(48, 32)[3] < 0.01, "first quarter only");
+    let d = run_env("ec.generate.stroke", &[("brushSize", num(4.0)), ("spacing", num(300.0))], img, 0.0, env);
+    assert!(alpha_sum(&d.img, 0, 0, 64, 64) < alpha_sum(&a.img, 0, 0, 64, 64), "spaced dabs");
+    // No masks: unchanged.
+    let src = Image::filled(8, 8, [0.2, 0.3, 0.4, 1.0]);
+    assert_eq!(run("ec.generate.stroke", &[], src.clone()).img.data, src.data);
+}
+
+#[test]
+fn vegas_traces_contours() {
+    let mut img = Image::new(64, 64);
+    for y in 16..48 {
+        for x in 16..48 {
+            img.set(x, y, [1.0, 1.0, 1.0, 1.0]);
+        }
+    }
+    let a =
+        run("ec.generate.vegas", &[("blendMode", Value::Enum(0)), ("length", num(1.0)), ("midpointOpacity", num(1.0)), ("endOpacity", num(1.0))], img.clone());
+    let b =
+        run("ec.generate.vegas", &[("blendMode", Value::Enum(0)), ("length", num(1.0)), ("midpointOpacity", num(1.0)), ("endOpacity", num(1.0))], img.clone());
+    assert_eq!(a.img.data, b.img.data);
+    assert!(alpha_sum(&a.img, 14, 14, 50, 50) > 50.0, "edges drawn");
+    assert!(alpha_sum(&a.img, 26, 26, 38, 38) < 0.5, "interior untouched");
+    let r = run("ec.generate.vegas", &[("blendMode", Value::Enum(0)), ("rotation", num(90.0))], img);
+    assert_ne!(r.img.data, a.img.data);
+}
+
+#[test]
+fn contours_of_square_are_closed() {
+    let mut pl = Plane::new(20, 20);
+    for y in 5..15 {
+        for x in 5..15 {
+            pl.data[y * 20 + x] = 1.0;
+        }
+    }
+    let c = contours(&pl, 0.5);
+    assert_eq!(c.len(), 1);
+    assert!(c[0].1);
+    let l = poly_length(&c[0].0, true);
+    assert!((l - 40.0).abs() < 4.0, "{l}");
+}
+
+#[test]
+fn write_on_and_glue_gun_draw_at_brush() {
+    let img = Image::new(32, 32);
+    let a = run("ec.generate.writeon", &[], img.clone());
+    assert!(a.img.get(16, 16)[3] > 0.9 && a.img.get(2, 2)[3] == 0.0);
+    assert_eq!(a.img.data, run("ec.generate.writeon", &[], img.clone()).img.data);
+    let src = Image::filled(32, 32, [0.5, 0.2, 0.1, 1.0]);
+    let g = run("ec.generate.ccgluegun", &[], src.clone());
+    assert_eq!(g.img.data, run("ec.generate.ccgluegun", &[], src.clone()).img.data);
+    assert_ne!(g.img.get(16, 16), src.get(16, 16));
+    assert_eq!(g.img.get(0, 0), src.get(0, 0));
+}
+
+/// #536: an animated Brush Position draws a stroke that stays (Stroke Length 0), expires
+/// after Stroke Length, and lays its dabs Brush Spacing seconds apart.
+#[test]
+fn write_on_accumulates_a_stroke_along_the_animated_brush() {
+    // Brush Position from [8, 16] at 0 s to [56, 16] at 1 s; red, hard, 6 px.
+    struct Brush(Vec<(&'static str, Value)>);
+    impl Brush {
+        fn at(&self, t: f64) -> Vec<(&'static str, Value)> {
+            let mut v = self.0.clone();
+            v.push(("brushPosition", Value::Vec2([8.0 + 48.0 * t.clamp(0.0, 1.0), 16.0])));
+            v
+        }
+    }
+    impl EffectHost for Brush {
+        fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {
+            None
+        }
+        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+            None
+        }
+        fn params_at(&self, t: f64) -> Option<Params> {
+            let s = crate::find("ec.generate.writeon").unwrap();
+            let mut p = Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+            for (k, v) in self.at(t) {
+                p.values.insert(k.to_string(), v);
+            }
+            Some(p)
+        }
+    }
+    let render = |extra: &[(&'static str, Value)], t: f64| {
+        let mut set = vec![("color", col(1.0, 0.0, 0.0)), ("brushSize", num(6.0)), ("brushHardness", num(100.0)), ("brushSpacing", num(0.05))];
+        set.extend(extra.iter().cloned());
+        let host = Brush(set);
+        let env = EffectEnv { host: Some(&host), ..Default::default() };
+        let at = host.at(t);
+        run_env("ec.generate.writeon", &at, Image::new(64, 32), t, env).img
+    };
+    let on = |img: &Image, x: i64| img.get(x, 16)[3] > 0.9;
+    let half = render(&[], 0.5);
+    assert!(on(&half, 8) && on(&half, 20) && on(&half, 32) && !on(&half, 44) && !on(&half, 56));
+    let end = render(&[], 1.0);
+    assert!([8, 20, 32, 44, 56].iter().all(|x| on(&end, *x)));
+    // Stroke Length 0.25 s: only the last quarter second's trail.
+    let trail = render(&[("strokeLength", num(0.25))], 1.0);
+    assert!(!on(&trail, 8) && !on(&trail, 32) && on(&trail, 48) && on(&trail, 56));
+    // Brush Spacing 0.5 s: three separate marks.
+    let spaced = render(&[("brushSpacing", num(0.5))], 1.0);
+    assert!(on(&spaced, 8) && on(&spaced, 32) && on(&spaced, 56) && !on(&spaced, 20) && !on(&spaced, 44));
+    // Paint Time Properties ▸ Opacity: each dab keeps the opacity it was laid with.
+    struct Fade;
+    impl EffectHost for Fade {
+        fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {
+            None
+        }
+        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+            None
+        }
+        fn params_at(&self, t: f64) -> Option<Params> {
+            let mut p = Brush(vec![("brushHardness", num(100.0)), ("brushSpacing", num(0.05)), ("paintTimeProperties", Value::Enum(1))]).params_at(t)?;
+            p.values.insert("brushOpacity".into(), num(if t < 0.5 { 100.0 } else { 20.0 }));
+            Some(p)
+        }
+    }
+    let p1 = Fade.params_at(1.0).unwrap();
+    let set: Vec<(&str, Value)> = p1.values.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();
+    let faded = run_env("ec.generate.writeon", &set, Image::new(64, 32), 1.0, EffectEnv { host: Some(&Fade), ..Default::default() }).img;
+    assert!(faded.get(8, 16)[3] > 0.9 && (faded.get(56, 16)[3] - 0.2).abs() < 0.05, "{:?} {:?}", faded.get(8, 16), faded.get(56, 16));
+}
+
+#[test]
+fn paint_bucket_fills_enclosed_region_only() {
+    let mut img = Image::filled(32, 32, [1.0, 1.0, 1.0, 1.0]);
+    for i in 8..24 {
+        for &(x, y) in &[(i, 8), (i, 23), (8, i), (23, i)] {
+            img.set(x, y, [0.0, 0.0, 0.0, 1.0]);
+        }
+    }
+    let out = run("ec.generate.paintbucket", &[], img.clone());
+    let inside = out.img.get(16, 16);
+    assert!(inside[0] > 0.99 && inside[1] < 0.01, "{inside:?}");
+    assert_eq!(out.img.get(2, 2), [1.0, 1.0, 1.0, 1.0], "outside untouched");
+    assert_eq!(out.img.get(8, 16), [0.0, 0.0, 0.0, 1.0], "border untouched");
+    assert_eq!(out.img.data, run("ec.generate.paintbucket", &[], img).img.data);
+}
+
+#[test]
+fn eyedropper_fill_uses_sample() {
+    let mut img = Image::filled(16, 16, [0.0, 0.0, 1.0, 1.0]);
+    img.set(8, 8, [1.0, 0.0, 0.0, 1.0]);
+    let out = run("ec.generate.eyedropperfill", &[], img.clone());
+    assert!(out.img.data.iter().all(|p| *p == [1.0, 0.0, 0.0, 1.0]));
+    let blended = run("ec.generate.eyedropperfill", &[("blendWithOriginal", num(100.0))], img.clone());
+    assert_eq!(blended.img.data, img.data);
+}
+
+#[test]
+fn threads_weave_is_deterministic_and_gappy() {
+    let src = Image::filled(64, 64, [0.4, 0.6, 0.2, 1.0]);
+    let a = run("ec.generate.ccthreads", &[("width", num(16.0)), ("height", num(16.0)), ("coverage", num(50.0))], src.clone());
+    assert_eq!(a.img.data, run("ec.generate.ccthreads", &[("width", num(16.0)), ("height", num(16.0)), ("coverage", num(50.0))], src).img.data);
+    assert!(a.img.data.iter().any(|p| p[3] == 0.0), "gaps between threads");
+    assert!(a.img.data.iter().any(|p| p[3] > 0.99), "threads");
+}
+
+struct Tone;
+impl EffectHost for Tone {
+    fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {
+        None
+    }
+    fn audio(&self, _: u64, start: f64, frames: usize, rate: u32) -> Option<Vec<f32>> {
+        Some(
+            (0..frames)
+                .flat_map(|i| {
+                    let t = start + i as f64 / rate as f64;
+                    let v = (2.0 * PI * 440.0 * t).sin() as f32 * 0.8;
+                    [v, v]
+                })
+                .collect(),
+        )
+    }
+}
+
+#[test]
+fn audio_effects_without_audio_pass_through() {
+    let src = Image::filled(16, 16, [0.3, 0.3, 0.3, 1.0]);
+    for id in ["ec.generate.audiospectrum", "ec.generate.audiowaveform"] {
+        assert_eq!(run(id, &[], src.clone()).img.data, src.data, "{id}");
+    }
+}
+
+#[test]
+fn audio_effects_draw_with_host() {
+    let host = Tone;
+    let env = EffectEnv { host: Some(&host), comp_time: 1.0, ..Default::default() };
+    let img = Image::new(96, 64);
+    for id in ["ec.generate.audiospectrum", "ec.generate.audiowaveform"] {
+        let a = run_env(id, &[("audioLayer", Value::Layer(Some(1)))], img.clone(), 1.0, env);
+        let b = run_env(id, &[("audioLayer", Value::Layer(Some(1)))], img.clone(), 1.0, env);
+        assert_eq!(a.img.data, b.img.data, "{id}");
+        assert!(alpha_sum(&a.img, 0, 0, 96, 64) > 10.0, "{id} drew nothing");
+    }
+}
+
+#[test]
+fn fft_finds_tone() {
+    let n = 256;
+    let mut re: Vec<f64> = (0..n).map(|i| (2.0 * PI * 8.0 * i as f64 / n as f64).cos()).collect();
+    let mut im = vec![0.0; n];
+    fft(&mut re, &mut im);
+    let mags: Vec<f64> = (0..n / 2).map(|k| (re[k] * re[k] + im[k] * im[k]).sqrt()).collect();
+    let peak = mags.iter().enumerate().max_by(|a, b| a.1.total_cmp(b.1)).unwrap().0;
+    assert_eq!(peak, 8);
+}
+
+#[test]
+fn stroke_outline_caps_and_joins() {
+    let line = vec![vec![[10.0, 10.0], [30.0, 10.0]]];
+    let cov = |cap: u32| raster_convex(40, 20, &stroke_outline(&line, 3.0, cap, 0, 4.0));
+    // Round caps reach 3 px past the ends (on the axis), Butt stops there, Projecting is square.
+    let (round, butt, proj) = (cov(0), cov(1), cov(2));
+    assert!(round.get(8, 10) > 0.9 && butt.get(8, 10) < 0.1 && proj.get(8, 10) > 0.9);
+    assert!(proj.get(7, 7) > 0.9 && round.get(7, 7) < 0.5, "square corner");
+    // A right-angle turn: Miter fills the outer corner, Bevel cuts it.
+    let corner = vec![vec![[5.0, 30.0], [30.0, 30.0], [30.0, 5.0]]];
+    let j = |join: u32| raster_convex(40, 40, &stroke_outline(&corner, 3.0, 1, join, 4.0));
+    let (miter, bevel) = (j(1), j(2));
+    assert!(miter.get(32, 32) > 0.9 && bevel.get(32, 32) < 0.1, "{} {}", miter.get(32, 32), bevel.get(32, 32));
+    // A tight miter limit falls back to a bevel.
+    let limited = raster_convex(40, 40, &stroke_outline(&corner, 3.0, 1, 1, 1.0));
+    assert!(limited.get(32, 32) < 0.1);
+}
+
+#[test]
+fn scribble_caps_and_start_end_apply_to() {
+    let masks = square_mask();
+    let env = EffectEnv { masks: &masks, ..Default::default() };
+    let img = Image::new(64, 64);
+    let base = [("wiggleType", Value::Enum(0)), ("strokeWidth", num(3.0))];
+    let round = run_env("ec.generate.scribble", &base, img.clone(), 0.0, env);
+    let butt = run_env(
+        "ec.generate.scribble",
+        &[base.as_slice(), &[("edgeOptions/endCap", Value::Enum(1)), ("edgeOptions/join", Value::Enum(2))]].concat(),
+        img.clone(),
+        0.0,
+        env,
+    );
+    assert_ne!(round.img.data, butt.img.data);
+    // Each Stroke: every stroke is trimmed on its own, so the half-way image has ink all over.
+    let two = vec![
+        crate::MaskShape { name: String::new(), points: vec![[4.0, 4.0], [28.0, 4.0], [28.0, 60.0], [4.0, 60.0]], closed: true, inverted: false },
+        crate::MaskShape { name: String::new(), points: vec![[36.0, 4.0], [60.0, 4.0], [60.0, 60.0], [36.0, 60.0]], closed: true, inverted: false },
+    ];
+    let env2 = EffectEnv { masks: &two, ..Default::default() };
+    let seq = [("scribble", Value::Enum(1)), ("end", num(50.0))];
+    let all = run_env("ec.generate.scribble", &[base.as_slice(), &seq].concat(), img.clone(), 0.0, env2);
+    let each = run_env("ec.generate.scribble", &[base.as_slice(), &seq, &[("startEndApplyTo", Value::Enum(1))]].concat(), img, 0.0, env2);
+    assert_ne!(all.img.data, each.img.data);
+}
+
+#[test]
+fn vegas_long_segments_are_sampled_finely() {
+    // A short segment keeps the 12 samples; a long one gets more so it bends smoothly round rounded corners.
+    assert_eq!(super::paths::vegas_substeps(10.0, 4.0), 12);
+    let n = super::paths::vegas_substeps(400.0, 4.0);
+    assert!(n > 12 && n.is_multiple_of(2), "{n}");
+    assert!(super::paths::vegas_substeps(13.0 * 4.0, 4.0).is_multiple_of(2));
+    assert!(400.0 / n as f64 <= 4.0 + 1e-9);
+    assert_eq!(super::paths::vegas_substeps(1.0e9, 4.0), 512);
+}
+
+#[test]
+fn vegas_long_segment_follows_curved_mask() {
+    // One segment as long as a round mask (radius 90 px): with only 12 straight pieces the
+    // chords cut ~3 px inside the curve, leaving gaps on the mask outline.
+    let (c, r) = (100.0, 90.0);
+    let mut points = Vec::new();
+    for i in 0..256 {
+        let a = i as f64 / 256.0 * std::f64::consts::TAU;
+        points.push([c + r * a.cos(), c + r * a.sin()]);
+    }
+    let masks = vec![MaskShape { name: "Mask 1".into(), points, closed: true, inverted: false }];
+    let env = EffectEnv { masks: &masks, ..Default::default() };
+    let set = [
+        ("stroke", Value::Enum(1)),
+        ("segments", num(1.0)),
+        ("length", num(1.0)),
+        ("segmentDistribution", Value::Enum(1)),
+        ("blendMode", Value::Enum(0)),
+        ("hardness", num(1.0)),
+        ("midpointOpacity", num(1.0)),
+        ("endOpacity", num(1.0)),
+    ];
+    let out = run_env("ec.generate.vegas", &set, Image::new(200, 200), 0.5, env);
+    for k in 0..720 {
+        let a = k as f64 / 720.0 * std::f64::consts::TAU;
+        let (x, y) = ((c + r * a.cos()).floor() as usize, (c + r * a.sin()).floor() as usize);
+        let alpha = out.img.data[y * 200 + x][3];
+        assert!(alpha > 0.5, "gap on the curve at {k}/720 turn: alpha {alpha}");
+    }
+}
diff --git a/crates/effects/src/lib.rs b/crates/effects/src/lib.rs
index cc0aad515..c865d4f96 100644
--- a/crates/effects/src/lib.rs
+++ b/crates/effects/src/lib.rs
@@ -8,6 +8,7 @@
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
+mod analysis_cache;
 pub mod audio_fx;
 mod blur2;
 mod blur3;
@@ -78,7 +79,7 @@ pub use color_fx::{
 pub use color_fx::{COLORAMA_PRESETS, ColoramaPalette};
 pub use color2::{Curve, auto_correct_settings, color_link_mode, color_link_sample, equalize_tables, luma_clip_points, shadow_highlight_amounts};
 pub use color3::OffsetCurve;
-pub use distort::transform_shutter;
+pub use distort::{transform_grow, transform_matrix_px, transform_shutter};
 pub use distort2::{MAGNIFY_MODES, bezier_grid, parse_mesh};
 pub use distort3::{RESHAPE_POINTS, ReshapeSetup, SmearSetup, cc_smear_pad, reshape_setup, smear_setup, warp_inverse_map};
 pub use distort4::liquify_mesh;
@@ -86,7 +87,10 @@ use effectcraft_keyframe::Value;
 use effectcraft_project::build::Ids;
 use effectcraft_project::{GroupKind, ParamUi, PropGroup, Property};
 pub use effectcraft_raster::{AuxChannels, Image};
-pub use misc::{INVERT_ALPHA, INVERT_CHANNELS, glow_ab_t, glow_operation};
+pub use misc::{
+    GLOW_GAIN, GLOW_KNEE, INVERT_ALPHA, INVERT_CHANNELS, glow_ab_t, glow_operation, glow_sigma, radial_wipe_sigma, radial_wipe_wedge, venetian_cover,
+    venetian_origin,
+};
 pub use sim::particle_state;
 pub use sim3::{PgBlit, PgPlan, playground_plan, playground_state};
 pub use stylize2::strobe_on;
@@ -104,7 +108,7 @@ pub use transition::place_layer;
 // effectcraft-gpu fx_noise.
 pub use keying2::{InnerOuterPlan, inner_outer_plan};
 pub use noise::remove_grain_level;
-pub use noise3::{FractalGpu, fractal_gpu};
+pub use noise3::{FractalGpu, NOISE_CELL, fractal_gpu};
 pub use stylize3::{BumpLight, bump_layer_id};
 pub use textfx::{TextLayer, text_layer};
 pub use time_fx::{PixelMotion, TimewarpPlan, TwStep, pmb_plan, posterized_time, time_frames, timewarp_crop, timewarp_plan};
@@ -113,7 +117,7 @@ pub use ocio::color_stabilizer_maps;
 // GPU effects, part B (3D Channel, Immersive Video, colour management, simulation render passes).
 pub use channel3d::{CRYPTO_LAYERS, CryptoAux, aux_point, crypto_aux_image, crypto_aux_image_with, id_color, selection_hashes};
 pub use ocio::{ColorOp, Straight, Tf, color_program};
-pub use sim::{Acc, Blob, Bubble, Post, Shape, Sprite, SpritePlan, Tint, bubble_list, drizzle_drops, mercury_blobs, sprite_plan};
+pub use sim::{Acc, Blob, Bubble, Post, Shape, Sprite, SpritePlan, Tint, bubble_list, bubble_sample_bounds, drizzle_drops, mercury_blobs, sprite_plan};
 pub use sim2::{
     CausticsSetup, FoamDisc, FoamEnv, FoamPlan, Piece, PiecePlan, PieceTex, PixelPlan, WavePlan, Waves, caustics_setup, foam_full_plan, piece_plan, pixel_plan,
     wave_world_plan,
@@ -287,15 +291,66 @@ impl Buf {
         self.offset[0] += origin[0] * self.scale;
         self.offset[1] += origin[1] * self.scale;
     }
-    /// Grow by `pad` transparent pixels on every side.
-    pub fn pad(&mut self, pad: u32) {
-        if pad == 0 {
+    /// Grow by transparent pixels: `sides` = left, top, right, bottom. Content keeps its place.
+    pub fn pad_sides(&mut self, sides: [u32; 4]) {
+        let [l, t, r, b] = sides;
+        if l == 0 && t == 0 && r == 0 && b == 0 {
             return;
         }
-        self.img = self.img.padded(pad);
-        self.offset[0] += pad as f64;
-        self.offset[1] += pad as f64;
+        let (Some(w), Some(h)) = (self.img.width.checked_add(l).and_then(|v| v.checked_add(r)), self.img.height.checked_add(t).and_then(|v| v.checked_add(b)))
+        else {
+            return;
+        };
+        let mut out = Image::new(w, h);
+        let (sw, ow) = (self.img.width as usize, w as usize);
+        for y in 0..self.img.height as usize {
+            let at = (y + t as usize) * ow + l as usize;
+            let (Some(src), Some(dst)) = (self.img.data.get(y * sw..(y + 1) * sw), out.data.get_mut(at..at + sw)) else { continue };
+            dst.copy_from_slice(src);
+        }
+        self.img = out;
+        self.offset[0] += l as f64;
+        self.offset[1] += t as f64;
     }
+    /// Grow by `left` and `top` transparent pixels on those sides only.
+    pub fn grow_left_top(&mut self, left: u32, top: u32) {
+        self.pad_sides([left, top, 0, 0]);
+    }
+    /// Give the buffer the pixel-grid phase (modulo [`GRID_ALIGN`]) that [`Buf::cover`] of
+    /// `size` would, by growing left/top only ([`align_plan`]). A downscaled layer is resampled
+    /// through a pyramid whose 2x2 blocks follow the buffer's grid, so a buffer that starts at
+    /// its content's corner instead of the cover's resamples to different pixels (#1205).
+    pub fn align(&mut self, size: [f64; 2]) {
+        if let Some((l, t)) = align_plan(self.offset, self.scale, size, self.img.width, self.img.height) {
+            self.grow_left_top(l, t);
+        }
+    }
+    /// Grow by `pad` transparent pixels on every side, within [`pad_within_budget`] and as
+    /// clamped by [`Image::effective_pad`].
+    pub fn pad(&mut self, pad: u32) {
+        let eff = self.img.effective_pad(pad_within_budget(self.img.width, self.img.height, pad));
+        if eff == 0 {
+            return;
+        }
+        self.img = self.img.padded(eff);
+        self.offset[0] += eff as f64;
+        self.offset[1] += eff as f64;
+    }
+}
+
+/// `pad` on every side of a `w` × `h` effect buffer, cut so the padded buffer stays within
+/// 16 Mpx (256 MiB of f32 RGBA) or four times its own area, whichever is larger: a small layer
+/// far from an effect's centre can't ask for gigabytes (#2261). Shared with the GPU path.
+pub fn pad_within_budget(w: u32, h: u32, pad: u32) -> u32 {
+    const MIN_BUDGET: f64 = 16_777_216.0;
+    let (w, h) = (f64::from(w), f64::from(h));
+    let budget = MIN_BUDGET.max(4.0 * w * h);
+    if (w + 2.0 * f64::from(pad)) * (h + 2.0 * f64::from(pad)) <= budget {
+        return pad;
+    }
+    // (w + 2p)(h + 2p) = budget, solved for p.
+    let p = (((w - h).powi(2) + 4.0 * budget).sqrt() - (w + h)) / 4.0;
+    (p.floor().max(0.0) as u32).min(pad)
 }
 
 /// Motion Tile's output frame for a buffer with layer origin `offset` (pixels) at `scale`:
@@ -335,6 +390,33 @@ pub fn adjustment_crop(offset: [f64; 2], canvas_offset: [f64; 2], size: (u32, u3
     Some((dx as i64, dy as i64))
 }
 
+/// Effects that grow their own buffer by what they need (blur and glow margins, Repeat Edge
+/// Pixels through [`Buf::cover`], displacement through [`cover_pad`]): a stack of only these
+/// skips the renderer's cover of the whole layer rectangle (#1205).
+pub const SKIPS_COVER: &[&str] = &["ec.blur.gaussian", "ec.blur.fastbox", "ec.stylize.glow", "ec.distort.turbulentdisplace"];
+
+/// The grid phase [`Buf::align`] keeps and the step [`cover_pad`] grows in: covers the levels
+/// of the resampling pyramid used for downscaled layers.
+pub const GRID_ALIGN: u32 = 64;
+
+/// Left/top growth giving a buffer [`cover_plan`]'s grid phase modulo [`GRID_ALIGN`]; `None`
+/// when there is nothing to add.
+pub fn align_plan(offset: [f64; 2], scale: f64, size: [f64; 2], width: u32, height: u32) -> Option<(u32, u32)> {
+    let (dx, dy, _, _) = cover_plan(offset, scale, size, width, height)?;
+    let (l, t) = (dx % GRID_ALIGN, dy % GRID_ALIGN);
+    (l != 0 || t != 0).then_some((l, t))
+}
+
+/// Padding for an effect that moves pixels up to `want` past the content (not an adjustment
+/// layer): `want`, capped at what reaches the layer rectangle, in whole [`GRID_ALIGN`] steps so
+/// the grid phase stays. 0 once the buffer covers the layer.
+pub fn cover_pad(ctx: &EffectCtx, size: [u32; 2], offset: [f64; 2], scale: f64, want: u32) -> u32 {
+    if ctx.adjustment {
+        return 0;
+    }
+    want.min(util::layer_cover_pad(ctx, size, offset, scale)).div_ceil(GRID_ALIGN) * GRID_ALIGN
+}
+
 /// Where [`Buf::cover`] would take a buffer: shift its pixels by `(dx, dy)` and resize it to
 /// `width` × `height` so it spans the `size`-layer-pixel region that starts at its offset — the
 /// whole layer rectangle, which a sized source's buffer already is. `None` when the buffer
@@ -421,6 +503,18 @@ pub trait EffectHost: Sync {
     fn params_at(&self, _layer_time: f64) -> Option<Params> {
         None
     }
+    /// Parameter `id` (a [`flatten_params`] id such as `birthRate`) of effect `effect_index` in
+    /// the layer's stack (the running effect's [`EffectEnv::effect_index`]) at another **layer
+    /// time**: CC Particle World samples its Birth Rate at every step it simulates (#1373).
+    /// `None` when unavailable.
+    fn param_at(&self, _effect_index: usize, _id: &str, _layer_time: f64) -> Option<Value> {
+        None
+    }
+    /// Parameter `id` of effect `effect_index` has one value at every time (no keyframes, no
+    /// expression), so sampling it over time can be skipped. `false` when unknown.
+    fn param_is_static(&self, _effect_index: usize, _id: &str) -> bool {
+        false
+    }
     /// A particle simulation backend (GPU particles; see [`psim`]). `None` = simulate on the
     /// CPU.
     fn particles(&self) -> Option<&dyn psim::ParticleSim> {
@@ -501,6 +595,15 @@ pub struct EffectSpec {
     pub float: bool,
 }
 
+impl EffectSpec {
+    /// True when this effect grows its own buffer (blur/glow margins, Repeat Edge
+    /// [`Buf::cover`], displacement [`cover_pad`]) so a stack of only these can skip the
+    /// renderer's full-layer cover and keep the pyramid grid phase (#1205).
+    pub fn skips_cover(&self) -> bool {
+        SKIPS_COVER.contains(&self.id)
+    }
+}
+
 pub(crate) fn p(id: &'static str, name: &'static str, default: Value, ui: ParamUi) -> ParamSpec {
     ParamSpec { id, name, default, ui }
 }
@@ -1276,6 +1379,13 @@ pub fn is_time_dependent(id: &str) -> bool {
     id.starts_with("ec.sim.") || TIME_DEPENDENT.contains(&id)
 }
 
+/// Does effect `id` read its own parameters at earlier times (the stepped particle systems sample
+/// their Birth Rate at every step, #1373)? Caches keyed on the current values can't see what an
+/// expression returned then.
+pub fn reads_param_history(id: &str) -> bool {
+    matches!(id, "ec.sim.ccparticleworld" | "ec.sim.ccparticlesystems2" | "ec.sim.ccmrmercury")
+}
+
 /// Run an effect on a buffer.
 pub fn apply(spec: &EffectSpec, ctx: &EffectCtx, buf: Buf) -> Buf {
     (spec.render)(ctx, buf)
@@ -1300,6 +1410,23 @@ pub(crate) fn run_fx(id: &str, vals: &[(&str, Value)], img: Image, time: f64, en
 mod tests {
     use super::*;
 
+    /// #2261: a 20 × 20 layer with CC Radial Fast Blur's Center far away grows to at most 16 Mpx;
+    /// big layers may still grow to four times their area, and small pads are untouched.
+    #[test]
+    fn padded_buffers_stay_within_the_budget() {
+        let area = |w: u32, h: u32, p: u32| (u64::from(w) + 2 * u64::from(p)) * (u64::from(h) + 2 * u64::from(p));
+        let far = radial_fast_pad((6500.0, 6500.0), 20, 20, 0.8);
+        assert_eq!(far, 4096, "the effect asks for its full pad");
+        let mut b = Buf { img: Image::new(20, 20), offset: [0.0; 2], scale: 1.0 };
+        b.pad(far);
+        assert!(area(20, 20, 0) < area(b.img.width, b.img.height, 0) && area(b.img.width, b.img.height, 0) <= 1 << 24, "{}x{}", b.img.width, b.img.height);
+        assert_eq!(b.offset, [f64::from((b.img.width - 20) / 2); 2], "the content keeps its place");
+        let p = pad_within_budget(3840, 2160, 4096);
+        assert!(p > 1000 && area(3840, 2160, p) <= 4 * 3840 * 2160 && area(3840, 2160, p + 1) > 4 * 3840 * 2160);
+        assert_eq!(pad_within_budget(640, 360, 200), 200);
+        assert_eq!(pad_within_budget(20, 20, 0), 0);
+    }
+
     #[test]
     fn run_fx_passthrough() {
         let img = Image::filled(4, 3, [0.5, 0.25, 0.125, 1.0]);
@@ -1307,6 +1434,20 @@ mod tests {
         assert_eq!(out.img.data, img.data);
     }
 
+    #[test]
+    fn pad_offset_follows_the_clamped_pad() {
+        // Image::padded clamps a hostile pad to keep each side within MAX_PADDED_SIDE; the offset
+        // must move by the pad actually applied, or the content drifts from its layer position.
+        let mut img = Image::new(29_990, 2);
+        img.set(0, 0, [1.0, 0.0, 0.0, 1.0]);
+        let mut buf = Buf { img, offset: [3.0, 4.0], scale: 1.0 };
+        buf.pad(u32::MAX);
+        // Width binds: (MAX_PADDED_SIDE - 29 990) / 2 = 5.
+        assert_eq!(buf.offset, [8.0, 9.0]);
+        let (x, y) = buf.to_px([-3.0, -4.0]);
+        assert_eq!(buf.img.get(x as i64, y as i64), [1.0, 0.0, 0.0, 1.0]);
+    }
+
     #[test]
     #[ignore]
     fn dump_registry() {
@@ -1491,4 +1632,24 @@ mod tests {
         assert_eq!(g.get("noiseSourceLayerSource").map(|p| p.value.clone()), Some(Value::Enum(0)));
         assert_eq!(g.props().filter(|p| p.match_id == "noiseSourceLayerSource").count(), 1);
     }
+
+    #[test]
+    fn align_plan_is_cover_shift_mod_grid() {
+        // Content inset from the layer origin: pixel 0 maps to layer (50, 30).
+        let offset = [-50.0, -30.0];
+        let scale = 1.0;
+        let size = [1920.0, 1080.0];
+        let (dx, dy, _, _) = cover_plan(offset, scale, size, 80, 40).unwrap();
+        assert_eq!((dx, dy), (50, 30));
+        assert_eq!(align_plan(offset, scale, size, 80, 40), Some((50, 30)));
+        assert_eq!(align_plan([-64.0, -128.0], 1.0, size, 80, 40), None);
+    }
+
+    #[test]
+    fn known_margin_effects_skip_cover_and_twirl_does_not() {
+        for id in SKIPS_COVER {
+            assert!(find(id).expect(id).skips_cover(), "{id}");
+        }
+        assert!(!find("ec.distort.twirl").unwrap().skips_cover());
+    }
 }
diff --git a/crates/effects/src/matte.rs b/crates/effects/src/matte.rs
index 4c42c9c39..d695a3b41 100644
--- a/crates/effects/src/matte.rs
+++ b/crates/effects/src/matte.rs
@@ -362,6 +362,22 @@ mod tests {
         assert!(a > 0.99 && c[0] > 0.5, "{c:?}");
     }
 
+    /// #2102: negative Choke Matte keeps growing the matte past -20, down to -100: a 120 px hole
+    /// in an opaque frame closes a bit more with every step.
+    #[test]
+    fn simple_choker_grows_the_matte_at_large_negative_values() {
+        let mut img = Image::filled(200, 200, [1.0, 1.0, 1.0, 1.0]);
+        for y in 40..160 {
+            for x in 40..160 {
+                img.set(x, y, [0.0; 4]);
+            }
+        }
+        let filled = |c: f64| alpha_sum(&run("ec.matte.simplechoker", &[("chokeMatte", num(c))], img.clone()));
+        let sums: Vec<f32> = [-10.0, -20.0, -40.0, -60.0].into_iter().map(filled).collect();
+        assert!(sums.windows(2).all(|w| w[1] > w[0] + 100.0), "{sums:?}");
+        assert!((filled(-100.0) - 200.0 * 200.0).abs() < 1.0, "-100 closes the hole");
+    }
+
     #[test]
     fn matte_choker_defaults_shrink() {
         let img = square();
diff --git a/crates/effects/src/migrate.rs b/crates/effects/src/migrate.rs
index b5976b761..ecea0fe19 100644
--- a/crates/effects/src/migrate.rs
+++ b/crates/effects/src/migrate.rs
@@ -344,6 +344,23 @@ pub fn upgrade_instance(spec: &EffectSpec, g: &mut PropGroup, ids: &mut Ids, lay
     *g != before
 }
 
+/// The spec id of the parameter that an instance of `spec` saved at `id` (`a/b/param`) is now:
+/// `id` itself when the spec still has it, the new id of a renamed parameter
+/// ([`PARAM_ID_ALIASES`]), or the twirl-down path of a top-level parameter that moved into a
+/// group, as [`upgrade_instance`] finds them. Returns `None` when no parameter matches.
+pub fn current_param_id(spec: &EffectSpec, id: &str) -> Option<&'static str> {
+    if let Some(ps) = spec.params.iter().find(|ps| ps.id == id) {
+        return Some(ps.id);
+    }
+    if let Some((_, _, new)) = PARAM_ID_ALIASES.iter().find(|(e, old, _)| *e == spec.id && *old == id) {
+        return Some(new);
+    }
+    if id.contains('/') {
+        return None;
+    }
+    spec.params.iter().find(|ps| ps.id.rsplit('/').next() == Some(id)).map(|ps| ps.id)
+}
+
 /// Bring an effect instance saved before project schema 2 into effect space (#227).
 ///
 /// Layers without a source rectangle (shape, text) have comp-sized effect bounds centred on
@@ -559,6 +576,21 @@ mod tests {
         assert_eq!(prop_at(&mut g, "stabilization/smoothness").unwrap().value, Value::Scalar(12.0));
     }
 
+    /// A saved parameter id maps to the parameter `upgrade_instance` moves it to.
+    #[test]
+    fn current_param_id_follows_renames_and_twirl_down_moves() {
+        let stab = find(crate::warp_stab::ID).unwrap();
+        assert_eq!(current_param_id(stab, "stabilization/smoothness"), Some("stabilization/smoothness"));
+        assert_eq!(current_param_id(stab, "smoothness"), Some("stabilization/smoothness"));
+        let ctc = find("ec.color.changetocolor").unwrap();
+        assert_eq!(current_param_id(ctc, "tolerance"), Some("toleranceGroup/hue"));
+        // Radio Waves' old Velocity is the growth speed, not the new Velocity.
+        let waves = find("ec.generate.radiowaves").unwrap();
+        assert_eq!(current_param_id(waves, "velocity"), Some("waveMotion/expansion"));
+        assert_eq!(current_param_id(stab, "noSuchParam"), None);
+        assert_eq!(current_param_id(stab, "other/smoothness"), None);
+    }
+
     #[test]
     fn card_wipe_back_layer_popup_becomes_a_layer_parameter() {
         let spec = find("ec.transition.cardwipe").unwrap();
@@ -733,7 +765,13 @@ not a stroke",
         let data = effectcraft_track::roto::RotoData {
             base: Some(0),
             span: [0, 10],
-            strokes: vec![effectcraft_track::roto::Stroke { kind: effectcraft_track::roto::StrokeKind::Fg, frame: 0, radius: 5.0, points: vec![[2.0, 2.0]] }],
+            strokes: vec![effectcraft_track::roto::Stroke {
+                kind: effectcraft_track::roto::StrokeKind::Fg,
+                frame: 0,
+                radius: 5.0,
+                points: vec![[2.0, 2.0]],
+                object: 0,
+            }],
         };
         roto.get_mut(crate::roto::STROKES).unwrap().value = Value::Str(data.to_json());
         to_effect_space(spec, &mut roto, SIZE, D, &own);
diff --git a/crates/effects/src/misc.rs b/crates/effects/src/misc.rs
index 7468c6b84..15d5d0aac 100644
--- a/crates/effects/src/misc.rs
+++ b/crates/effects/src/misc.rs
@@ -34,6 +34,9 @@ fn gaussian(ctx: &EffectCtx, mut b: Buf) -> Buf {
     let repeat = ctx.params.b("repeatEdge");
     if !repeat && !ctx.adjustment {
         b.pad((s * 3.0).ceil() as u32);
+    } else if repeat && !ctx.adjustment {
+        // The edge it repeats is the layer's, not the painted content's (#1205).
+        b.cover(ctx.layer_size);
     }
     let (sx, sy) = (s * kx, s * ky);
     // Small sigmas: integer-radius box passes would step (and do nothing below ~0.6 px), so sample the kernel (#1939).
@@ -60,6 +63,9 @@ fn box_blur(ctx: &EffectCtx, mut b: Buf) -> Buf {
     if !repeat && !ctx.adjustment {
         let reach = if frac > 0.0 { r + 1 } else { r };
         b.pad((reach * it) as u32 + 1);
+    } else if repeat && !ctx.adjustment {
+        // The edge it repeats is the layer's, not the painted content's (#1205).
+        b.cover(ctx.layer_size);
     }
     let edge = repeat || ctx.adjustment;
     let lo = effectcraft_raster::box_blur(&b.img, r * kx as usize, r * ky as usize, it, edge);
@@ -142,6 +148,28 @@ pub fn glow_ab_t(l: f32, looping: u32, loops: f32, phase: f32, mid: f32) -> f32
     t.max(0.0).powf(0.5f32.ln() / m.ln())
 }
 
+/// Glow's blur: a Gaussian of σ = 0.384 × Glow Radius. Fitted to After Effects 2026 (cases
+/// 807 and 808, Glow Radius 10 and 30 on a grey solid): the edge profile of the glow's
+/// coverage is an erfc step of that σ within 1.7/255 (it was σ = radius / 2).
+pub fn glow_sigma(radius: f64) -> f64 {
+    (radius * 0.384).max(0.5)
+}
+
+/// Glow's bright pass for the original colours, per channel of the straight colour `v`:
+/// `8 × (v − threshold + 0.0611)`, nothing below. Fitted to After Effects 2026 renders of grey
+/// 0.65 / 0.8 / 0.9 / 1, orange and light-blue solids at Threshold 40 / 60 / 80 % and Radius 10
+/// / 30 (36 channel values, exact to the 8-bit capture): the glow is linear in each channel,
+/// its gain is the same at every threshold and radius, and channels below the threshold add
+/// nothing (an orange solid glows red only).
+pub fn glow_bright_channel(v: f32, thr: f32) -> f32 {
+    (GLOW_GAIN * (v - thr + GLOW_KNEE)).max(0.0)
+}
+
+/// [`glow_bright_channel`]'s gain and threshold offset. `kernels.wgsl` repeats both as literals;
+/// the GPU test `glow_constants_match_the_cpu` checks that they are these.
+pub const GLOW_GAIN: f32 = 8.0;
+pub const GLOW_KNEE: f32 = 0.0611;
+
 /// Glow Operation options (blend modes the glow is applied with).
 pub const GLOW_OPERATIONS: [&str; 17] = [
     "Normal",
@@ -205,23 +233,31 @@ fn glow(ctx: &EffectCtx, mut b: Buf) -> Buf {
         // Glow Based On: brightness from the colours, or from the alpha channel.
         let l = if alpha_based { a } else { luminance(px[0] / a, px[1] / a, px[2] / a) };
         let k = ((l - thr) / (1.0 - thr).max(1e-3)).clamp(0.0, 1.0);
+        // Based on the colour channels, the glow's coverage is the layer's whole alpha, below
+        // the threshold too: After Effects darkens what lies under a dim layer's edge (glow_alpha).
+        let ga = if alpha_based { k * a } else { a };
         if let Some(map) = &arbitrary {
             let t = glow_ab_t(l, looping, loops, phase, mid);
             let c = map.iter().map(|cv| cv.as_ref().map_or(t, |cv| cv.eval(t))).collect::<Vec<f32>>();
-            *px = [c[0] * k * a, c[1] * k * a, c[2] * k * a, k * a];
+            *px = [c[0] * k * a, c[1] * k * a, c[2] * k * a, ga];
         } else if use_colors {
             let t = glow_ab_t(l, looping, loops, phase, mid);
             let c = [ca[0] + (cb[0] - ca[0]) * t, ca[1] + (cb[1] - ca[1]) * t, ca[2] + (cb[2] - ca[2]) * t];
-            *px = [c[0] * k * a, c[1] * k * a, c[2] * k * a, k * a];
+            *px = [c[0] * k * a, c[1] * k * a, c[2] * k * a, ga];
+        } else if alpha_based {
+            *px = [px[0] * k, px[1] * k, px[2] * k, ga];
         } else {
-            *px = px.map(|v| v * k);
+            // Original colours: each channel of the straight colour against the threshold.
+            let c = [px[0] / a, px[1] / a, px[2] / a].map(|v| glow_bright_channel(v, thr) * a);
+            *px = [c[0], c[1], c[2], ga];
         }
     });
-    let s = (radius / 2.0).max(0.5);
+    let s = glow_sigma(radius);
     let blurred = gaussian_blur(&bright, s * kx, s * ky, false);
     let mode = ctx.params.e("operation");
     b.img.data.par_iter_mut().zip(blurred.data.par_iter()).for_each(|(o, g)| {
-        let g = g.map(|v| v * intensity);
+        // Intensity scales the glow's colour; with the colour channels its coverage stays.
+        let g = [g[0] * intensity, g[1] * intensity, g[2] * intensity, if alpha_based { g[3] * intensity } else { g[3] }];
         match mode {
             // Behind: the glow shows only where the original is transparent.
             1 => {
@@ -525,22 +561,67 @@ fn linear_wipe(ctx: &EffectCtx, mut b: Buf) -> Buf {
     b
 }
 
+/// Standard normal CDF Φ (Abramowitz & Stegun 7.1.26 erf, |error| < 1.5e-7).
+fn norm_cdf(z: f64) -> f64 {
+    let x = z.abs() / std::f64::consts::SQRT_2;
+    let t = 1.0 / (1.0 + 0.327_591_1 * x);
+    let poly = t * (0.254_829_592 + t * (-0.284_496_736 + t * (1.421_413_741 + t * (-1.453_152_027 + t * 1.061_405_429))));
+    let erf = 1.0 - poly * (-x * x).exp();
+    if z >= 0.0 { 0.5 * (1.0 + erf) } else { 0.5 * (1.0 - erf) }
+}
+
+/// Radial Wipe's wiped wedge relative to the Start Angle: (first ray, span), degrees clockwise
+/// from up. Clockwise (0) wipes from the start angle on, Counterclockwise (1) back from it,
+/// Both (2) half each way.
+pub fn radial_wipe_wedge(wipe: u32, done: f64) -> (f64, f64) {
+    let span = done.clamp(0.0, 1.0) * 360.0;
+    match wipe {
+        1 => (-span, span),
+        2 => (-span / 2.0, span),
+        _ => (0.0, span),
+    }
+}
+
+/// Radial Wipe's feather: a Gaussian of σ = 0.4 × Feather pixels across both edges of the wedge
+/// (After Effects 2026, Feather 20: the edge profile is the same width in pixels at every
+/// radius, σ = 8.0 px, mean error 0.0002 over the frame).
+pub fn radial_wipe_sigma(feather: f64) -> f64 {
+    feather.max(0.0) * 0.4
+}
+
+/// Visible fraction of a pixel at `(ux, uy)` from the centre (y down) for a wiped wedge from
+/// `ray0` (absolute degrees clockwise from up) over `span` degrees: the signed distance to the
+/// wedge's nearer edge, through the feather's Gaussian.
+pub fn radial_wipe_alpha(ux: f64, uy: f64, ray0: f64, span: f64, sigma: f64) -> f64 {
+    let a = (ux.atan2(-uy).to_degrees() - ray0).rem_euclid(360.0);
+    let wiped = a < span;
+    let ray_dist = |deg: f64| {
+        let (s, c) = deg.to_radians().sin_cos();
+        // Ray direction (sin, −cos) in y-down pixels.
+        let along = ux * s - uy * c;
+        if along > 0.0 { (ux * c + uy * s).abs() } else { ux.hypot(uy) }
+    };
+    let d = ray_dist(ray0).min(ray_dist(ray0 + span));
+    let sd = if wiped { -d } else { d };
+    if sigma < 1e-3 {
+        return if wiped { 0.0 } else { 1.0 };
+    }
+    norm_cdf(sd / sigma)
+}
+
 fn radial_wipe(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let done = ctx.params.f("completion") / 100.0;
+    let done = (ctx.params.f("completion") / 100.0).clamp(0.0, 1.0);
+    if done <= 0.0 {
+        return b;
+    }
     let start = ctx.params.f("startAngle");
     let c = b.to_px(ctx.params.v2("center"));
-    let dir = ctx.params.e("wipe");
-    let feather = (ctx.params.f("feather")).max(0.01);
+    let (w0, span) = radial_wipe_wedge(ctx.params.e("wipe"), done);
+    let sigma = radial_wipe_sigma(ctx.params.f("feather")) * b.scale;
+    let full = done >= 1.0;
     b.img.rows_mut().for_each(|(y, row)| {
         for (x, px) in row.iter_mut().enumerate() {
-            let a = ((x as f64 + 0.5 - c.0).atan2(-(y as f64 + 0.5 - c.1)).to_degrees() - start).rem_euclid(360.0);
-            // Both: the wipe opens in both directions from the start angle at once.
-            let (a, edge) = match dir {
-                1 => (360.0 - a, done * 360.0),
-                2 => (a.min(360.0 - a), done * 180.0),
-                _ => (a, done * 360.0),
-            };
-            let k = ((a - edge) / feather + 0.5).clamp(0.0, 1.0) as f32;
+            let k = if full { 0.0 } else { radial_wipe_alpha(x as f64 + 0.5 - c.0, y as f64 + 0.5 - c.1, start + w0, span, sigma) as f32 };
             for ch in px.iter_mut() {
                 *ch *= k;
             }
@@ -549,16 +630,49 @@ fn radial_wipe(ctx: &EffectCtx, mut b: Buf) -> Buf {
     b
 }
 
+/// Venetian Blinds: how much of a pixel at phase `d` (0..`width`) a band of `done × width`
+/// covers, its two edges softened by a Gaussian of σ = Feather / 2 (σ in the units of `width`).
+/// Fitted to After Effects 2026 (Completion 40, Direction 30, Width 50, Feather 5 on 960 × 540
+/// and 480 × 270 layers): band from phase 0 to done × width, both edges Gaussian, within 6/255.
+pub fn venetian_cover(d: f64, width: f64, done: f64, sigma: f64) -> f64 {
+    let band = done * width;
+    if sigma < 1e-3 {
+        return if d < band { 1.0 } else { 0.0 };
+    }
+    // Wider than a few blinds the stripes blur into an even veil.
+    if sigma > 8.0 * width {
+        return done.clamp(0.0, 1.0);
+    }
+    let n = ((4.0 * sigma / width).ceil() as i64 + 1).clamp(1, 40);
+    let mut t = 0.0;
+    for k in -n..=n {
+        let u = d + k as f64 * width;
+        t += norm_cdf(u / sigma) - norm_cdf((u - band) / sigma);
+    }
+    t.clamp(0.0, 1.0)
+}
+
+/// Venetian Blinds' phase origin in layer pixels: the layer centre plus 0.6 px (fitted to the
+/// AE renders above; the stripes are measured from the layer's centre, not its corner).
+pub fn venetian_origin(layer_size: [f64; 2]) -> [f64; 2] {
+    [layer_size[0] / 2.0 + 0.6, layer_size[1] / 2.0 + 0.6]
+}
+
 fn venetian(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let done = ctx.params.f("completion") / 100.0;
+    let done = (ctx.params.f("completion") / 100.0).clamp(0.0, 1.0);
+    if done <= 0.0 {
+        return b;
+    }
     let ang = ctx.params.f("direction").to_radians();
     let width = (ctx.params.f("width") * b.scale).max(1.0);
-    let feather = (ctx.params.f("feather") * b.scale).max(0.001);
+    let sigma = ctx.params.f("feather").max(0.0) * b.scale / 2.0;
     let (dx, dy) = (ang.cos(), ang.sin());
+    let (ox, oy) = b.to_px(venetian_origin(ctx.layer_size));
     b.img.rows_mut().for_each(|(y, row)| {
+        let ry = (y as f64 + 0.5 - oy) * dy;
         for (x, px) in row.iter_mut().enumerate() {
-            let d = ((x as f64 + 0.5) * dx + (y as f64 + 0.5) * dy).rem_euclid(width);
-            let k = ((d - done * width) / feather + 0.5).clamp(0.0, 1.0) as f32;
+            let d = ((x as f64 + 0.5 - ox) * dx + ry).rem_euclid(width);
+            let k = (1.0 - venetian_cover(d, width, done, sigma)) as f32;
             for c in px.iter_mut() {
                 *c *= k;
             }
@@ -807,6 +921,189 @@ mod tests {
         img
     }
 
+    /// After Effects 2026 (cases 524, 807, 808, 809): Glow on a 50 % grey solid, which is below
+    /// the 60 % threshold, still covers a blurred copy of the layer's alpha with black, so the
+    /// red layer underneath darkens outside the edge. The halo is the same at Intensity 1 and 3
+    /// and with Composite Original On Top or Behind; its width follows Glow Radius.
+    #[test]
+    fn glow_halo_matches_after_effects() {
+        let grey = effectcraft_raster::Image::filled(200, 120, [0.5, 0.5, 0.5, 1.0]);
+        // AE's red under the halo at 0.5, 1.5, 3.5, 5.5 and 7.5 px outside the left edge
+        // (radius 10) and at 0.5, 5.5, 10.5, 20.5 px (radius 30); halo alpha = 1 − red.
+        let r10 = [(0.5, 140.0), (1.5, 165.0), (3.5, 208.0), (5.5, 234.0), (7.5, 248.0)];
+        let r30 = [(0.5, 132.0), (5.5, 173.0), (10.5, 208.0), (20.5, 245.0)];
+        for (radius, intensity, operation, profile) in [(10.0, 1.0, 1, &r10[..]), (10.0, 3.0, 1, &r10[..]), (10.0, 1.0, 0, &r10[..]), (30.0, 1.0, 1, &r30[..])]
+        {
+            let set = [
+                ("based", Value::Enum(1)),
+                ("threshold", num(60.0)),
+                ("radius", num(radius)),
+                ("intensity", num(intensity)),
+                ("operation", Value::Enum(operation)),
+            ];
+            let o = run_fx("ec.stylize.glow", &set, grey.clone(), 0.0, EffectEnv::default());
+            for &(d, red) in profile {
+                // Layer x = −d (pixel centre), mid-height; over AE's red: R = 1 − α, colour 0.
+                let (bx, by) = o.to_px([-d, 60.0]);
+                let p = o.img.get(bx.floor() as i64, by.floor() as i64);
+                let ae = 1.0 - red / 255.0;
+                assert!((p[3] - ae).abs() < 3.0 / 255.0, "radius {radius} intensity {intensity} op {operation} at {d} px: alpha {} vs AE {ae}", p[3]);
+                assert!(p[0].abs() < 1e-6, "the halo is black: {p:?}");
+            }
+        }
+    }
+
+    /// After Effects 2026, Glow at Threshold 60 %, Radius 10, Intensity 0.25 on 200 × 200
+    /// solids over red: the glow 1.5 px outside the left edge, premultiplied (the green / blue
+    /// channels of the render, where the red background adds nothing), and its alpha 0.353.
+    #[test]
+    fn glow_brightness_matches_after_effects() {
+        // (solid colour, channel, AE glow value 0..255)
+        let cases = [
+            ([0.65, 0.65, 0.65], 1, 20.0),
+            ([0.8, 0.8, 0.8], 1, 47.0),
+            ([0.9, 0.9, 0.9], 1, 65.0),
+            ([1.0, 1.0, 1.0], 1, 83.0),
+            ([1.0, 0.5, 0.0], 1, 0.0),
+            ([0.2, 0.6, 1.0], 1, 11.0),
+            ([0.2, 0.6, 1.0], 2, 83.0),
+        ];
+        for (c, ch, ae) in cases {
+            let img = effectcraft_raster::Image::filled(200, 200, [c[0], c[1], c[2], 1.0]);
+            let set = [("threshold", num(60.0)), ("radius", num(10.0)), ("intensity", num(0.25))];
+            let o = run_fx("ec.stylize.glow", &set, img, 0.0, EffectEnv::default());
+            let (bx, by) = o.to_px([-1.5, 100.0]);
+            let p = o.img.get(bx.floor() as i64, by.floor() as i64);
+            assert!((p[ch] * 255.0 - ae).abs() <= 2.5, "{c:?} channel {ch}: {} vs AE {ae}", p[ch] * 255.0);
+            assert!((p[3] - 0.353).abs() < 3.0 / 255.0, "{c:?}: alpha {}", p[3]);
+        }
+        // Intensity scales the colour linearly: white at Intensity 1 is 3.7 × its alpha.
+        let white = effectcraft_raster::Image::filled(200, 200, [1.0, 1.0, 1.0, 1.0]);
+        let o = run_fx("ec.stylize.glow", &[("threshold", num(60.0)), ("radius", num(10.0))], white, 0.0, EffectEnv::default());
+        let (bx, by) = o.to_px([-1.5, 100.0]);
+        let p = o.img.get(bx.floor() as i64, by.floor() as i64);
+        assert!((p[1] / p[3] - 3.69).abs() < 0.05, "{p:?}");
+    }
+
+    /// After Effects 2026: Radial Blur keeps the layer's edges. Zoom 20 on a flat grey 960 × 540
+    /// solid (case 713) leaves it flat and opaque to the edge (EffectCraft faded the edges toward
+    /// transparency, letting the red layer below show through); on a full-frame horizontal ramp
+    /// (case 829, centre [960, 540]) row 540 reads 2/255 at x = 2 and 253/255 at x = 1917.
+    #[test]
+    fn radial_blur_keeps_the_layer_edges_as_after_effects() {
+        let zoom = |c: [f64; 2]| [("amount", num(20.0)), ("type", Value::Enum(1)), ("center", Value::Vec2(c))];
+        let grey = effectcraft_raster::Image::filled(960, 540, [0.5, 0.5, 0.5, 1.0]);
+        let o = run_fx("ec.blur.radial", &zoom([600.0, 300.0]), grey, 0.0, EffectEnv::default());
+        for (x, y) in [(0, 270), (1, 270), (959, 270), (480, 0), (480, 539), (0, 0), (959, 539)] {
+            let p = o.img.get(x, y);
+            assert!((p[3] - 1.0).abs() < 1e-4 && (p[0] - 0.5).abs() < 1e-4, "({x}, {y}): {p:?}");
+        }
+        let mut ramp = effectcraft_raster::Image::new(1920, 1080);
+        ramp.rows_mut().for_each(|(_, row)| {
+            for (x, px) in row.iter_mut().enumerate() {
+                let v = (x as f32 + 0.5) / 1920.0;
+                *px = [v, v, v, 1.0];
+            }
+        });
+        let o = run_fx("ec.blur.radial", &zoom([960.0, 540.0]), ramp, 0.0, EffectEnv::default());
+        for (x, ae) in [(2, 2.0), (1917, 253.0)] {
+            let p = o.img.get(x, 540);
+            assert!((p[0] * 255.0 - ae).abs() <= 2.0 && (p[3] - 1.0).abs() < 1e-4, "x {x}: {p:?} vs AE {ae}");
+        }
+    }
+
+    /// After Effects 2026, Venetian Blinds Completion 40, Direction 30, Width 50, Feather 5 on
+    /// an opaque 480 × 270 layer: alpha (0..255) along row y = 135. The transparent band starts
+    /// at the layer centre's phase, both edges are Gaussian (σ = Feather / 2).
+    #[test]
+    fn venetian_blinds_match_after_effects() {
+        let img = effectcraft_raster::Image::filled(480, 270, [0.5, 0.5, 0.5, 1.0]);
+        let vals = [("completion", Value::Scalar(40.0)), ("direction", Value::Scalar(30.0)), ("width", Value::Scalar(50.0)), ("feather", Value::Scalar(5.0))];
+        let o = run_fx("ec.transition.venetian", &vals, img, 0.0, EffectEnv::default());
+        let ae = [
+            (200, 5.0),
+            (203, 47.0),
+            (206, 145.0),
+            (209, 228.0),
+            (212, 253.0),
+            (224, 255.0),
+            (236, 238.0),
+            (239, 168.0),
+            (242, 66.0),
+            (245, 10.0),
+            (251, 0.0),
+            (257, 2.0),
+            (260, 31.0),
+        ];
+        for (x, a) in ae {
+            let got = o.img.get(x, 135)[3] * 255.0;
+            assert!((got - a).abs() <= 6.0, "x {x}: alpha {got} vs AE {a}");
+        }
+        // No completion leaves the layer; full completion clears it; no feather is a hard edge.
+        let full = [("completion", Value::Scalar(100.0)), ("feather", Value::Scalar(5.0))];
+        let img = effectcraft_raster::Image::filled(40, 20, [0.5, 0.5, 0.5, 1.0]);
+        assert!(run_fx("ec.transition.venetian", &full, img.clone(), 0.0, EffectEnv::default()).img.data.iter().all(|p| p[3] < 1e-4));
+        assert_eq!(run_fx("ec.transition.venetian", &[("completion", Value::Scalar(0.0))], img.clone(), 0.0, EffectEnv::default()).img, img);
+        let hard = run_fx(
+            "ec.transition.venetian",
+            &[("completion", Value::Scalar(50.0)), ("width", Value::Scalar(10.0)), ("feather", Value::Scalar(0.0))],
+            img,
+            0.0,
+            EffectEnv::default(),
+        );
+        assert!(hard.img.data.iter().all(|p| p[3] == 0.0 || p[3] == 1.0));
+        // A feather far wider than the blinds is an even veil.
+        assert_eq!(venetian_cover(3.0, 10.0, 0.5, 1e9), 0.5);
+    }
+
+    /// After Effects 2026, Radial Wipe Completion 40, Start Angle 30, Wipe Counterclockwise,
+    /// Feather 20, centre (800, 500): visible fraction at pixel offsets from the centre on both
+    /// edges (8-bit captures of dark steps, so ±0.05).
+    #[test]
+    fn radial_wipe_feather_matches_after_effects() {
+        let img = effectcraft_raster::Image::filled(400, 300, [1.0, 1.0, 1.0, 1.0]);
+        let vals = [
+            ("completion", Value::Scalar(40.0)),
+            ("startAngle", Value::Scalar(30.0)),
+            ("center", Value::Vec2([200.0, 150.0])),
+            ("wipe", Value::Enum(1)),
+            ("feather", Value::Scalar(20.0)),
+        ];
+        let o = run_fx("ec.transition.radialwipe", &vals, img.clone(), 0.0, EffectEnv::default());
+        let ae = [
+            ((-50, 34), 0.922),
+            ((-52, 30), 0.797),
+            ((-54, 26), 0.609),
+            ((-55, 24), 0.5),
+            ((-56, 22), 0.406),
+            ((-57, 19), 0.266),
+            ((-58, 15), 0.125),
+            ((-104, 60), 0.951),
+            ((-108, 53), 0.732),
+            ((-111, 45), 0.341),
+            ((-114, 37), 0.062),
+            ((22, -56), 0.156),
+            ((26, -54), 0.312),
+            ((30, -52), 0.531),
+            ((34, -50), 0.729),
+            ((37, -47), 0.875),
+            ((53, -108), 0.177),
+            ((67, -99), 0.875),
+        ];
+        for ((dx, dy), a) in ae {
+            let got = o.img.get(200 + dx, 150 + dy)[3];
+            assert!((got - a).abs() < 0.05, "offset ({dx}, {dy}): {got} vs AE {a}");
+        }
+        // 0 % leaves the layer, 100 % clears it, Feather 0 is a hard edge.
+        let at = |c: f64, f: f64| {
+            let v = [("completion", Value::Scalar(c)), ("feather", Value::Scalar(f))];
+            run_fx("ec.transition.radialwipe", &v, img.clone(), 0.0, EffectEnv::default()).img
+        };
+        assert_eq!(at(0.0, 20.0), img);
+        assert!(at(100.0, 20.0).data.iter().all(|p| p[3] == 0.0));
+        assert!(at(50.0, 0.0).data.iter().all(|p| p[3] == 0.0 || p[3] == 1.0));
+    }
+
     #[test]
     fn glow_operation_and_arbitrary_map() {
         // Pixels addressed in layer space (Glow pads its buffer).
diff --git a/crates/effects/src/noise.rs b/crates/effects/src/noise.rs
index d39fd6528..9d21e77a7 100644
--- a/crates/effects/src/noise.rs
+++ b/crates/effects/src/noise.rs
@@ -264,25 +264,30 @@ pub(crate) fn sample_boxes(img: &Image, count: usize, size: usize) -> Vec<(usize
     }
     let low = Plane::luma(img);
     let step = (size / 2).max(1);
-    let mut cands: Vec<(f32, usize, usize)> = Vec::new();
-    for y in (0..=h - size).step_by(step) {
-        for x in (0..=w - size).step_by(step) {
-            // Variance of the picture inside the box (the flattest boxes hold the least detail).
-            let (mut s, mut sq, mut n, mut opaque) = (0.0f32, 0.0f32, 0.0f32, true);
-            for yy in y..y + size {
-                for xx in x..x + size {
-                    let v = low.data[yy * w + xx];
-                    s += v;
-                    sq += v * v;
-                    n += 1.0;
-                    opaque &= img.data[yy * w + xx][3] > 0.5;
+    // Candidate rows in parallel; the sort below is a total order (variance, y, x), so the
+    // result does not depend on the collection order.
+    let rows: Vec<usize> = (0..=h - size).step_by(step).collect();
+    let mut cands: Vec<(f32, usize, usize)> = rows
+        .par_iter()
+        .flat_map_iter(|&y| {
+            let data = low.data.as_slice();
+            let alpha = img.data.as_slice();
+            (0..=w - size).step_by(step).filter_map(move |x| {
+                // Variance of the picture inside the box (the flattest boxes hold the least detail).
+                let (mut s, mut sq, mut n, mut opaque) = (0.0f32, 0.0f32, 0.0f32, true);
+                for yy in y..y + size {
+                    for xx in x..x + size {
+                        let v = data[yy * w + xx];
+                        s += v;
+                        sq += v * v;
+                        n += 1.0;
+                        opaque &= alpha[yy * w + xx][3] > 0.5;
+                    }
                 }
-            }
-            if opaque {
-                cands.push((sq / n - (s / n).powi(2), x, y));
-            }
-        }
-    }
+                opaque.then(|| (sq / n - (s / n).powi(2), x, y))
+            })
+        })
+        .collect();
     cands.sort_by(|a, b| a.0.total_cmp(&b.0).then(a.2.cmp(&b.2)).then(a.1.cmp(&b.1)));
     cands.into_iter().take(count).map(|(_, x, y)| (x, y, size)).collect()
 }
@@ -479,16 +484,7 @@ pub(crate) fn sampling_boxes(ctx: &EffectCtx, img: &Image, scale: f64) -> Vec<(u
 
 /// The grain level (0.5..2) measured in the sample boxes of `img`.
 fn grain_level(img: &Image, boxes: &[(usize, usize, usize)]) -> f32 {
-    let mut m = vec![false; img.data.len()];
-    let w = img.width as usize;
-    for &(x, y, s) in boxes {
-        for yy in y..y + s {
-            for xx in x..x + s {
-                m[yy * w + xx] = true;
-            }
-        }
-    }
-    let st = crate::noise2::grain_stats_masked(img, Some(&m));
+    let st = crate::noise2::grain_stats_boxes(img, boxes);
     let s = (st.std[0] + st.std[1] + st.std[2]) / 3.0;
     if boxes.is_empty() { 1.0 } else { (s / 0.02).clamp(0.5, 2.0) }
 }
diff --git a/crates/effects/src/noise2.rs b/crates/effects/src/noise2.rs
index 4c22f6d8f..48d840416 100644
--- a/crates/effects/src/noise2.rs
+++ b/crates/effects/src/noise2.rs
@@ -75,6 +75,102 @@ pub(crate) fn grain_stats_masked(img: &Image, mask: Option<&[bool]>) -> GrainSta
     GrainStats { std, size: (1.0 / (1.0 - rho as f32)).clamp(0.5, 20.0) * 0.6 }
 }
 
+/// Grain statistics over sample `boxes` (in image pixels), measured from small crops around each
+/// box instead of the whole image. Empty `boxes` measures every opaque pixel, like
+/// [`grain_stats_masked`] without a mask. Overlapping boxes are deduplicated, so the sums match
+/// the masked version.
+pub(crate) fn grain_stats_boxes(img: &Image, boxes: &[(usize, usize, usize)]) -> GrainStats {
+    if boxes.is_empty() {
+        return grain_stats_masked(img, None);
+    }
+    let (w, h) = (img.width as usize, img.height as usize);
+    if w < 3 || h < 3 {
+        return GrainStats::default();
+    }
+    // The Gaussian's three box passes at sigma 1.5 have radius 1 each, so 3 px of halo make the
+    // residual exact inside a box; one more column covers the right neighbour used by the lag-1
+    // correlation.
+    const HALO: usize = 4;
+    let mut mask = vec![false; w * h];
+    for &(x, y, s) in boxes {
+        for yy in y..y.saturating_add(s).min(h) {
+            for xx in x..x.saturating_add(s).min(w) {
+                mask[yy * w + xx] = true;
+            }
+        }
+    }
+    let mut counted = vec![false; w * h];
+    let mut n = [0.0f64; 3];
+    let mut sum = [0.0f64; 3];
+    let mut sq = [0.0f64; 3];
+    let mut rho_num = 0.0f64;
+    let mut rho_den = 0.0f64;
+    let mut crop: Vec<([f32; 3], f32)> = Vec::new();
+    let mut planes: Vec<Plane> = Vec::new();
+    for &(bx, by, bs) in boxes {
+        let x0 = bx.saturating_sub(HALO);
+        let y0 = by.saturating_sub(HALO);
+        let x1 = bx.saturating_add(bs).saturating_add(HALO).min(w);
+        let y1 = by.saturating_add(bs).saturating_add(HALO).min(h);
+        if x1 <= x0 || y1 <= y0 {
+            continue;
+        }
+        let (cw, ch) = (x1 - x0, y1 - y0);
+        crop.clear();
+        crop.extend((y0..y1).flat_map(|y| (x0..x1).map(move |x| unpremul(img.data[y * w + x]))));
+        planes.clear();
+        for k in 0..3 {
+            let pl = Plane { w: cw, h: ch, data: crop.iter().map(|s| s.0[k]).collect() };
+            planes.push(gauss_plane(&pl, 1.5, 1.5));
+        }
+        for ly in 0..bs {
+            let y = by + ly;
+            if y >= h {
+                break;
+            }
+            for lx in 0..bs {
+                let x = bx + lx;
+                if x >= w {
+                    break;
+                }
+                let g = y * w + x;
+                if !mask[g] || counted[g] {
+                    continue;
+                }
+                counted[g] = true;
+                let l = (y - y0) * cw + (x - x0);
+                let (_, a) = crop[l];
+                if a <= 0.5 {
+                    continue;
+                }
+                for k in 0..3 {
+                    let hp = crop[l].0[k] - planes[k].data[l];
+                    sum[k] += hp as f64;
+                    sq[k] += (hp as f64) * (hp as f64);
+                    n[k] += 1.0;
+                }
+                if x + 1 < w && mask[g + 1] && crop[l + 1].1 > 0.5 {
+                    for k in 0..3 {
+                        let hp = crop[l].0[k] - planes[k].data[l];
+                        let hn = crop[l + 1].0[k] - planes[k].data[l + 1];
+                        rho_num += (hp * hn) as f64;
+                        rho_den += (hp * hp) as f64;
+                    }
+                }
+            }
+        }
+    }
+    let mut std = [0.0f32; 3];
+    for k in 0..3 {
+        if n[k] > 1.0 {
+            let mean = sum[k] / n[k];
+            std[k] = ((sq[k] / n[k] - mean * mean).max(0.0)).sqrt() as f32;
+        }
+    }
+    let rho = if rho_den > 1e-12 { (rho_num / rho_den).clamp(0.0, 0.95) } else { 0.0 };
+    GrainStats { std, size: (1.0 / (1.0 - rho as f32)).clamp(0.5, 20.0) * 0.6 }
+}
+
 /// Match Grain's Viewing Mode options.
 const MATCH_GRAIN_VIEWS: [&str; 5] = ["Preview", "Noise Samples", "Compensation Samples", "Blending Matte", "Final Output"];
 
@@ -86,34 +182,24 @@ fn match_grain(ctx: &EffectCtx, mut b: Buf) -> Buf {
     let view = ctx.params.e("viewingMode");
     let source = layer_or_self(ctx, &b, "noiseSourceLayer", false, false);
     let src_boxes = sampling_boxes(ctx, &source, b.scale);
-    let own_boxes = sampling_boxes(ctx, &b.img, b.scale);
     let box_col = ctx.params.get("sampling/sampleBoxColor").map(|v| v.as_color()).unwrap_or([1.0, 1.0, 0.0, 1.0]);
     if view == 1 || view == 2 {
         // Noise Samples (on the source) / Compensation Samples (on this layer).
-        let (mut img, boxes) = if view == 1 { (source, src_boxes) } else { (b.img.clone(), own_boxes) };
+        let (mut img, boxes) = if view == 1 { (source, src_boxes) } else { (b.img.clone(), sampling_boxes(ctx, &b.img, b.scale)) };
         draw_boxes(&mut img, &boxes, box_col);
         b.img = img;
         return b;
     }
-    let mask_of = |img: &Image, boxes: &[(usize, usize, usize)]| -> Option<Vec<bool>> {
-        if boxes.is_empty() {
-            return None;
-        }
-        let w = img.width as usize;
-        let mut m = vec![false; img.data.len()];
-        for &(x, y, s) in boxes {
-            for yy in y..y + s {
-                for xx in x..x + s {
-                    m[yy * w + xx] = true;
-                }
-            }
-        }
-        Some(m)
-    };
-    let src_stats = grain_stats_masked(&source, mask_of(&source, &src_boxes).as_deref());
+    let src_stats = grain_stats_boxes(&source, &src_boxes);
     let comp = (ctx.params.f("compensateForExistingNoise") / 100.0) as f32;
-    let own = if comp > 0.0 { grain_stats_masked(&b.img, mask_of(&b.img, &own_boxes).as_deref()) } else { GrainStats::default() };
-    let orig = b.img.clone();
+    // The own-layer boxes only matter for the compensation term; skip them when it is off.
+    let own = if comp > 0.0 {
+        let own_boxes = sampling_boxes(ctx, &b.img, b.scale);
+        grain_stats_boxes(&b.img, &own_boxes)
+    } else {
+        GrainStats::default()
+    };
+    let orig = (view == 0).then(|| b.img.clone());
     let look = GrainLook::from_params(ctx);
     let amp: [f32; 3] = [0, 1, 2].map(|k| {
         let s = src_stats.std[k];
@@ -147,8 +233,8 @@ fn match_grain(ctx: &EffectCtx, mut b: Buf) -> Buf {
             }
         }
     });
-    if view == 0 {
-        crate::noise::preview_compose(ctx, &mut b, &orig);
+    if let Some(orig) = &orig {
+        crate::noise::preview_compose(ctx, &mut b, orig);
     }
     b
 }
@@ -306,6 +392,63 @@ mod tests {
         img
     }
 
+    #[test]
+    fn boxed_grain_stats_match_the_masked_ones() {
+        // Noisy image with alpha holes; the boxes cover overlapping, edge-adjacent and
+        // bottom-right corner cases (clamped crops).
+        let mut img = noisy(64, 48, 0.2, 9);
+        for y in 0..img.height {
+            for x in 0..img.width {
+                if (x / 7 + y / 5) % 6 == 0 {
+                    let mut p = img.get(x as i64, y as i64);
+                    p[3] = 0.0;
+                    img.set(x, y, p);
+                }
+            }
+        }
+        let boxes = [(3usize, 4usize, 9usize), (8, 6, 9), (40, 20, 12), (39, 21, 12), (55, 39, 9)];
+        let w = img.width as usize;
+        let mut mask = vec![false; img.data.len()];
+        for &(x, y, s) in &boxes {
+            for yy in y..y + s {
+                for xx in x..x + s {
+                    mask[yy * w + xx] = true;
+                }
+            }
+        }
+        let masked = grain_stats_masked(&img, Some(&mask));
+        let boxed = grain_stats_boxes(&img, &boxes);
+        for k in 0..3 {
+            assert!((masked.std[k] - boxed.std[k]).abs() < 1e-6, "{k}: {masked:?} vs {boxed:?}");
+        }
+        assert!((masked.size - boxed.size).abs() <= 1e-7, "size: {masked:?} vs {boxed:?}");
+        // A denser grid where every box overlaps its neighbours (mask dedup across boxes).
+        let img2 = noisy(96, 64, 0.15, 21);
+        let mut boxes2 = Vec::new();
+        for gy in 0..5 {
+            for gx in 0..6 {
+                boxes2.push((gx * 11 + (gy % 3) * 4, gy * 10 + gx % 2, 12));
+            }
+        }
+        let w2 = img2.width as usize;
+        let mut mask2 = vec![false; img2.data.len()];
+        for &(x, y, s) in &boxes2 {
+            for yy in y..y + s {
+                for xx in x..x + s {
+                    mask2[yy * w2 + xx] = true;
+                }
+            }
+        }
+        let masked2 = grain_stats_masked(&img2, Some(&mask2));
+        let boxed2 = grain_stats_boxes(&img2, &boxes2);
+        for k in 0..3 {
+            assert!((masked2.std[k] - boxed2.std[k]).abs() < 1e-6, "{k}: {masked2:?} vs {boxed2:?}");
+        }
+        assert!((masked2.size - boxed2.size).abs() <= 1e-7, "size: {masked2:?} vs {boxed2:?}");
+        // No boxes measures the whole image, like no mask.
+        assert_eq!(grain_stats_boxes(&img, &[]), grain_stats(&img));
+    }
+
     #[test]
     fn match_grain_transfers_grain_strength() {
         let flat = Image::filled(48, 48, [0.5, 0.5, 0.5, 1.0]);
diff --git a/crates/effects/src/noise3.rs b/crates/effects/src/noise3.rs
index baa5fb50a..49f200553 100644
--- a/crates/effects/src/noise3.rs
+++ b/crates/effects/src/noise3.rs
@@ -60,6 +60,11 @@ pub const BLEND_NORMAL: u32 = 1;
 /// Index of "Soft Linear" in [`NOISE_TYPES`] (the default, and the GPU path's interpolation).
 pub const NOISE_SOFT_LINEAR: u32 = 2;
 
+/// Lattice cell of Fractal / Turbulent Noise in pixels per percent of Scale: After Effects 2026
+/// draws Block noise at Scale 100 in 66.67 px cells (and Soft Linear noise has the matching
+/// correlation length), not 100 px.
+pub const NOISE_CELL: f64 = 2.0 / 3.0;
+
 fn spec(id: &'static str, name: &'static str, params: Vec<ParamSpec>, render: crate::RenderFn) -> EffectSpec {
     EffectSpec { id, name, category: "Noise & Grain", params, render, gpu: false, float: true }
 }
@@ -236,7 +241,7 @@ impl Fractal {
             overflow: pr.e("overflow"),
             invert: pr.b("invert"),
             rot: rot.sin_cos(),
-            size: [(sw * b.scale).max(1.0) as f32, (sh * b.scale).max(1.0) as f32],
+            size: [(sw * NOISE_CELL * b.scale).max(1.0) as f32, (sh * NOISE_CELL * b.scale).max(1.0) as f32],
             origin: [ox as f32, oy as f32],
             center: [cx as f32, cy as f32],
             perspective: pr.b("transform/perspectiveOffset"),
@@ -333,7 +338,7 @@ impl Fractal {
 }
 
 /// Fractal / Turbulent Noise resolved for the GPU kernel (effectcraft-gpu `fx_noise`): the
-/// per-pixel constants and, per octave, the terms [`Fractal::raw`] computes before touching the
+/// per-pixel constants and, per octave, the terms `Fractal::raw` computes before touching the
 /// pixel, in the same f32 order.
 pub struct FractalGpu {
     pub kind: u32,
@@ -535,14 +540,34 @@ mod tests {
 
     #[test]
     fn noise_types_differ_and_block_is_piecewise_constant() {
-        let a = run("ec.noise.fractal", &[("noiseType", Value::Enum(0)), ("complexity", num(1.0)), ("transform/scale", num(10.0))]);
-        // Block noise: neighbours inside one 10 px cell share a value.
+        let a = run("ec.noise.fractal", &[("noiseType", Value::Enum(0)), ("complexity", num(1.0)), ("transform/scale", num(15.0))]);
+        // Block noise: neighbours inside one 10 px cell (Scale 15) share a value.
         assert_eq!(a.get(4, 4), a.get(5, 5));
         let others: Vec<Image> = (1..4).map(|t| run("ec.noise.fractal", &[("noiseType", Value::Enum(t)), ("transform/scale", num(10.0))])).collect();
         assert_ne!(others[0], others[1]);
         assert_ne!(others[1], others[2]);
     }
 
+    /// After Effects 2026 (R9): Block noise at Scale 100, Complexity 1 changes value every
+    /// 66.67 px along a row.
+    #[test]
+    fn block_noise_cells_are_two_thirds_of_scale_as_in_after_effects() {
+        let img = run_fx(
+            "ec.noise.fractal",
+            &[("noiseType", Value::Enum(0)), ("complexity", num(1.0)), ("blendingMode", Value::Enum(BLEND_NONE))],
+            Image::filled(400, 8, [0.0, 0.0, 0.0, 1.0]),
+            0.0,
+            EffectEnv::default(),
+        )
+        .img;
+        let changes: Vec<i64> = (1..400).filter(|&x| img.get(x, 4) != img.get(x - 1, 4)).collect();
+        assert!(changes.len() >= 4, "{changes:?}");
+        for w in changes.windows(2) {
+            let d = (w[1] - w[0]) as f64;
+            assert!((d - 200.0 / 3.0).abs() <= 1.0, "cell width {d}: {changes:?}");
+        }
+    }
+
     #[test]
     fn scale_width_height_apply_without_uniform_scaling() {
         let base = &[("complexity", num(1.0)), ("transform/scale", num(8.0))];
diff --git a/crates/effects/src/object_matte.rs b/crates/effects/src/object_matte.rs
index d98ec73ad..8a9750282 100644
--- a/crates/effects/src/object_matte.rs
+++ b/crates/effects/src/object_matte.rs
@@ -144,7 +144,7 @@ pub fn prompt_strokes(params: &Params, layer_size: [f64; 2], frame: i64, with_mo
     if !inside(pt) {
         return None;
     }
-    let mut out = vec![Stroke { kind: StrokeKind::Fg, frame, radius: POINT_RADIUS, points: vec![pt] }];
+    let mut out = vec![Stroke { kind: StrokeKind::Fg, frame, radius: POINT_RADIUS, points: vec![pt], object: 0 }];
     let rect = |x0: f64, y0: f64, x1: f64, y1: f64| vec![[x0, y0], [x1, y0], [x1, y1], [x0, y1], [x0, y0]];
     let boxed = b(params, "useBox").then(|| Some((v2(params, "boxTopLeft")?, v2(params, "boxBottomRight")?))).flatten();
     match boxed {
@@ -158,9 +158,9 @@ pub fn prompt_strokes(params: &Params, layer_size: [f64; 2], frame: i64, with_mo
             }
             out.push(if with_model {
                 // The model takes the box itself as its box prompt.
-                Stroke { kind: StrokeKind::Box, frame, radius: 0.0, points: vec![[x0, y0], [x1, y1]] }
+                Stroke { kind: StrokeKind::Box, frame, radius: 0.0, points: vec![[x0, y0], [x1, y1]], object: 0 }
             } else {
-                Stroke { kind: StrokeKind::Bg, frame, radius: EDGE_RADIUS, points: rect(x0, y0, x1, y1) }
+                Stroke { kind: StrokeKind::Bg, frame, radius: EDGE_RADIUS, points: rect(x0, y0, x1, y1), object: 0 }
             });
         }
         None if !with_model => {
@@ -168,7 +168,7 @@ pub fn prompt_strokes(params: &Params, layer_size: [f64; 2], frame: i64, with_mo
             if w <= 4.0 * i || h <= 4.0 * i {
                 return None;
             }
-            out.push(Stroke { kind: StrokeKind::Bg, frame, radius: EDGE_RADIUS, points: rect(i, i, w - i, h - i) });
+            out.push(Stroke { kind: StrokeKind::Bg, frame, radius: EDGE_RADIUS, points: rect(i, i, w - i, h - i), object: 0 });
         }
         None => {}
     }
@@ -191,6 +191,11 @@ pub fn roto_data(params: &Params, layer_size: [f64; 2], f: i64, with_model: bool
 /// Seed of the chain keys: what the frames are (the Input Key), the layer size, the frame rate,
 /// the mode and the model. The prompt is in each frame's key.
 pub fn seed(params: &Params, layer_size: [f64; 2], fps: f64, model: Option<&dyn MaskModel>) -> u64 {
+    seed_of(params, layer_size, fps, model.map_or(effectcraft_segment::CLASSICAL, |m| m.info().id))
+}
+
+/// [`seed`] for the model with id `model` ([`effectcraft_segment::CLASSICAL`]: no model).
+fn seed_of(params: &Params, layer_size: [f64; 2], fps: f64, model: &str) -> u64 {
     let mut h = 0xcbf2_9ce4_8422_2325;
     fnv(&mut h, ID.as_bytes());
     fnv(&mut h, s(params, INPUT_KEY).as_bytes());
@@ -198,7 +203,7 @@ pub fn seed(params: &Params, layer_size: [f64; 2], fps: f64, model: Option<&dyn
         fnv(&mut h, &v.to_bits().to_le_bytes());
     }
     fnv(&mut h, &[tracks(params) as u8]);
-    fnv(&mut h, model.map_or(effectcraft_segment::CLASSICAL, |m| m.info().id).as_bytes());
+    fnv(&mut h, model.as_bytes());
     h
 }
 
@@ -222,7 +227,7 @@ pub fn job_frames(params: &Params, limits: [i64; 2]) -> Vec<i64> {
 pub fn chain(params: &Params, layer_size: [f64; 2], fps: f64, f: i64, scale: f64, model: Option<Arc<dyn MaskModel>>) -> Option<Chain> {
     let data = roto_data(params, layer_size, f, model.is_some())?;
     let keys = data.chain_keys(seed(params, layer_size, fps, model.as_deref()));
-    Some(Chain { data: Arc::new(data), keys, opts: seg_opts(scale), refine_radius: 0.0, model })
+    Some(Chain { data: Arc::new(data), keys, opts: seg_opts(scale), refine_radius: 0.0, model, saved: None, show_object: 0 })
 }
 
 /// Frame `f`'s segmentation at full resolution, computing what is missing (the background
@@ -255,9 +260,14 @@ pub fn frame_keys(params: &Params, layer_size: [f64; 2], fps: f64, frames: &[i64
 /// What frozen mattes depend on: what the frames are (the seed: Input Key, size, rate, mode,
 /// model), the prompt, the tracked span and the matte settings.
 pub fn frozen_key(params: &Params, layer_size: [f64; 2], fps: f64, model: Option<&dyn MaskModel>) -> String {
-    let mut h = seed(params, layer_size, fps, model);
+    frozen_key_of(params, layer_size, fps, model.map_or(effectcraft_segment::CLASSICAL, |m| m.info().id))
+}
+
+/// [`frozen_key`] for the model with id `model` ([`effectcraft_segment::CLASSICAL`]: no model).
+fn frozen_key_of(params: &Params, layer_size: [f64; 2], fps: f64, model: &str) -> String {
+    let mut h = seed_of(params, layer_size, fps, model);
     let base = reference_frame(params);
-    if let Some(st) = prompt_strokes(params, layer_size, base, model.is_some()) {
+    if let Some(st) = prompt_strokes(params, layer_size, base, model != effectcraft_segment::CLASSICAL) {
         fnv(&mut h, serde_json::to_string(&st).unwrap_or_default().as_bytes());
     }
     for v in [base, reach(params)[0], reach(params)[1]] {
@@ -273,7 +283,9 @@ pub fn is_frozen(params: &Params) -> bool {
 }
 
 /// Frame `f`'s frozen matte on a `w`×`h` grid, when the instance is frozen, the mattes still
-/// match ([`frozen_key`]) and `f` is one of them.
+/// match ([`frozen_key`]) and `f` is one of them. The mattes match under the session's `model`
+/// or under the model that froze them (which this session may not have loaded, e.g. a fresh
+/// headless render): frozen mattes need no segmentation.
 pub fn frozen_alpha(params: &Params, layer_size: [f64; 2], fps: f64, f: i64, w: usize, h: usize, model: Option<&dyn MaskModel>) -> Option<Vec<f32>> {
     let j = s(params, FROZEN);
     if j.is_empty() {
@@ -281,7 +293,10 @@ pub fn frozen_alpha(params: &Params, layer_size: [f64; 2], fps: f64, f: i64, w:
     }
     let fc = frozen_cache(j)?;
     if fc.key != frozen_key(params, layer_size, fps, model) {
-        return None;
+        let ids = std::iter::once(effectcraft_segment::CLASSICAL).chain(effectcraft_segment::MODELS.iter().map(|m| m.id));
+        if !ids.into_iter().any(|id| fc.key == frozen_key_of(params, layer_size, fps, id)) {
+            return None;
+        }
     }
     let fr = fc.frames.get(&f)?;
     let [fw, fh] = fc.size;
@@ -358,20 +373,24 @@ pub enum FrameMatte {
     Outside,
 }
 
-/// The matte of layer frame `f` on the layer grid of `img` (the effect's input on that frame at
-/// `scale`), computing what is missing. `frame(g)`: the input on frame g on the same grid.
-#[allow(clippy::too_many_arguments)]
+/// The layer grid and timing used to compute one object matte.
+pub struct MatteFrame<'a> {
+    pub layer_size: [f64; 2],
+    pub fps: f64,
+    pub frame: i64,
+    pub scale: f64,
+    pub img: &'a Image,
+}
+
+/// Compute the object's alpha for one layer frame, loading other frames on the same grid as needed.
 pub fn frame_matte(
     params: &Params,
-    layer_size: [f64; 2],
-    fps: f64,
-    f: i64,
-    scale: f64,
-    img: &Image,
+    input: &MatteFrame<'_>,
     model: Option<Arc<dyn MaskModel>>,
     frame: &mut dyn FnMut(i64) -> Option<Arc<Image>>,
     cancel: &dyn Fn() -> bool,
 ) -> FrameMatte {
+    let MatteFrame { layer_size, fps, frame: f, scale, img } = *input;
     let Some(chain) = chain(params, layer_size, fps, f, scale, model) else { return FrameMatte::NoPrompt };
     if !chain.data.in_span(f) {
         return FrameMatte::Outside;
@@ -408,7 +427,7 @@ fn render(ctx: &EffectCtx, buf: Buf) -> Buf {
     if let Some(a) = frozen_alpha(ctx.params, layer_size, fps, f, w, h, model.as_deref()) {
         return compose(&buf, Some(&a), w, h, b(ctx.params, "invert"), param(ctx.params, "view").map(Value::as_enum).unwrap_or(0) == 1);
     }
-    let alpha = match frame_matte(ctx.params, layer_size, fps, f, sc, &img, model, &mut frame, &|| false) {
+    let alpha = match frame_matte(ctx.params, &MatteFrame { layer_size, fps, frame: f, scale: sc, img: &img }, model, &mut frame, &|| false) {
         FrameMatte::Alpha(a) if a.len() == w * h => Some(a),
         FrameMatte::NoPrompt => return buf,
         _ => None,
@@ -608,7 +627,11 @@ mod tests {
         assert_ne!(seed(&p, [100.0, 80.0], 25.0, Some(stub.as_ref())), seed(&p, [100.0, 80.0], 25.0, None));
         let img = frame_at(0);
         let mut frame = |g: i64| Some(Arc::new(frame_at(g)));
-        let FrameMatte::Alpha(a) = frame_matte(&p, [100.0, 80.0], 25.0, 0, 1.0, &img, Some(stub.clone()), &mut frame, &|| false) else { panic!("no matte") };
+        let FrameMatte::Alpha(a) =
+            frame_matte(&p, &MatteFrame { layer_size: [100.0, 80.0], fps: 25.0, frame: 0, scale: 1.0, img: &img }, Some(stub.clone()), &mut frame, &|| false)
+        else {
+            panic!("no matte")
+        };
         assert!(a[40 * 100 + 40] > 0.5 && a[5 * 100 + 5] < 0.5);
         assert_eq!(stub.calls.load(std::sync::atomic::Ordering::Relaxed), 1);
         assert_eq!(*stub.bbox.lock().unwrap(), None);
@@ -634,7 +657,11 @@ mod tests {
         let stub = Arc::new(Stub::default());
         let img = frame_at(0);
         let mut frame = |g: i64| Some(Arc::new(frame_at(g)));
-        let FrameMatte::Alpha(a) = frame_matte(&p, [100.0, 80.0], 25.0, 0, 1.0, &img, Some(stub.clone()), &mut frame, &|| false) else { panic!("no matte") };
+        let FrameMatte::Alpha(a) =
+            frame_matte(&p, &MatteFrame { layer_size: [100.0, 80.0], fps: 25.0, frame: 0, scale: 1.0, img: &img }, Some(stub.clone()), &mut frame, &|| false)
+        else {
+            panic!("no matte")
+        };
         assert_eq!(*stub.bbox.lock().unwrap(), Some([74.0, 54.0, 100.0, 80.0]));
         assert!(a[70 * 100 + 90] > 0.5 && a[40 * 100 + 40] < 0.5);
         // At half resolution the box is scaled with the frame (another Input Key, so the
@@ -643,7 +670,8 @@ mod tests {
         p.values.insert(INPUT_KEY.into(), Value::Str("half".into()));
         let half = effectcraft_raster::resample(&img, 50, 40);
         let mut frame = |g: i64| Some(Arc::new(effectcraft_raster::resample(&frame_at(g), 50, 40)));
-        let _ = frame_matte(&p, [100.0, 80.0], 25.0, 0, 0.5, &half, Some(stub.clone()), &mut frame, &|| false);
+        let _ =
+            frame_matte(&p, &MatteFrame { layer_size: [100.0, 80.0], fps: 25.0, frame: 0, scale: 0.5, img: &half }, Some(stub.clone()), &mut frame, &|| false);
         assert_eq!(*stub.bbox.lock().unwrap(), Some([37.0, 27.0, 50.0, 40.0]));
     }
 
@@ -692,4 +720,28 @@ mod tests {
         p.values.insert(FROZEN.into(), Value::Str(fc2.to_json()));
         assert_eq!(frozen_alpha(&p, [100.0, 80.0], 25.0, 2, 100, 80, None), None);
     }
+
+    /// Mattes frozen with a model stay usable in a session where that model is not loaded (a
+    /// fresh headless render): they are used as stored, not re-segmented with another model.
+    #[test]
+    fn frozen_mattes_survive_a_session_without_their_model() {
+        let mut p = params(&[
+            ("objectPoint", Value::Vec2([40.0, 40.0])),
+            ("useBox", Value::Bool(true)),
+            ("boxTopLeft", Value::Vec2([10.0, 10.0])),
+            ("boxBottomRight", Value::Vec2([90.0, 70.0])),
+            ("objectTracking/framesAfter", Value::Scalar(3.0)),
+        ]);
+        p.values.insert(INPUT_KEY.into(), Value::Str("frozen-model-test".into()));
+        let stub = Stub::default();
+        let alpha: Vec<f32> = (0..100 * 80).map(|i| ((i % 100) < 50) as u8 as f32).collect();
+        let mut fc = FrozenCache { key: frozen_key(&p, [100.0, 80.0], 25.0, Some(&stub)), size: [100, 80], ..Default::default() };
+        fc.frames.insert(2, roto::freeze_frame(&alpha, &[]));
+        p.values.insert(FROZEN.into(), Value::Str(fc.to_json()));
+        assert!(is_frozen(&p));
+        assert!(frozen_alpha(&p, [100.0, 80.0], 25.0, 2, 100, 80, Some(&stub)).is_some());
+        assert_eq!(frozen_alpha(&p, [100.0, 80.0], 25.0, 2, 50, 40, None).map(|a| (a[20 * 50 + 5], a[20 * 50 + 45])), Some((1.0, 0.0)));
+        let out = run(&p, 2);
+        assert!(out.data[40 * 100 + 10][3] > 0.99 && out.data[40 * 100 + 90][3] < 0.01, "the frozen matte is used");
+    }
 }
diff --git a/crates/effects/src/ocio.rs b/crates/effects/src/ocio.rs
index e84720a32..2daa9857d 100644
--- a/crates/effects/src/ocio.rs
+++ b/crates/effects/src/ocio.rs
@@ -37,1802 +37,31 @@ use crate::util::unpremul;
 use crate::utility::{Lut, parse_cube};
 use crate::{Buf, EffectCtx, EffectSpec, num, p, popup, slider};
 
-type M3 = [[f64; 3]; 3];
+mod cdl;
+mod effects;
+mod lut;
+mod program;
+mod registry;
+mod space;
 
-pub(crate) const D65: [f64; 2] = [0.3127, 0.3290];
-const ACES_WHITE: [f64; 2] = [0.32168, 0.33767];
-const AP0: [[f64; 2]; 3] = [[0.7347, 0.2653], [0.0, 1.0], [0.0001, -0.0770]];
-const AP1: [[f64; 2]; 3] = [[0.713, 0.293], [0.165, 0.830], [0.128, 0.044]];
-pub(crate) const REC709: [[f64; 2]; 3] = [[0.640, 0.330], [0.300, 0.600], [0.150, 0.060]];
-pub(crate) const REC2020: [[f64; 2]; 3] = [[0.708, 0.292], [0.170, 0.797], [0.131, 0.046]];
-pub(crate) const P3: [[f64; 2]; 3] = [[0.680, 0.320], [0.265, 0.690], [0.150, 0.060]];
-const IDENTITY: M3 = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
-
-/// Transfer functions (encoded ↔ linear).
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Tf {
-    Linear,
-    Srgb,
-    Gamma(f64),
-    AcesCct,
-    /// ACEScc (Academy S-2014-003), the pure-log grading encoding.
-    AcesCc,
-    /// SMPTE ST 2084 with 1.0 = 100 cd/m².
-    Pq,
-}
-
-/// ACEScc: the lowest code value (linear 0 and below) and the end of its toe (linear 2⁻¹⁵).
-const ACESCC_MIN: f64 = (-16.0 + 9.72) / 17.52;
-const ACESCC_TOE: f64 = (-15.0 + 9.72) / 17.52;
-
-impl Tf {
-    pub fn decode(self, v: f64) -> f64 {
-        match self {
-            Tf::Linear => v,
-            Tf::Srgb => {
-                let a = v.abs();
-                let l = if a <= 0.04045 { a / 12.92 } else { ((a + 0.055) / 1.055).powf(2.4) };
-                l.copysign(v)
-            }
-            Tf::Gamma(g) => v.abs().powf(g).copysign(v),
-            Tf::AcesCct => {
-                if v <= 0.155_251_141_552_511 {
-                    (v - 0.072_905_534_195_835_5) / 10.540_237_741_654_5
-                } else if v < (65504f64.log2() + 9.72) / 17.52 {
-                    2f64.powf(v * 17.52 - 9.72)
-                } else {
-                    65504.0
-                }
-            }
-            Tf::AcesCc => {
-                if v < ACESCC_TOE {
-                    (2f64.powf(v * 17.52 - 9.72) - 2f64.powi(-16)) * 2.0
-                } else if v < (65504f64.log2() + 9.72) / 17.52 {
-                    2f64.powf(v * 17.52 - 9.72)
-                } else {
-                    65504.0
-                }
-            }
-            Tf::Pq => {
-                let (m1, m2, c1, c2, c3) = pq_consts();
-                let e = v.max(0.0).powf(1.0 / m2);
-                let l = ((e - c1).max(0.0) / (c2 - c3 * e)).powf(1.0 / m1);
-                l * 100.0
-            }
-        }
-    }
-    pub fn encode(self, v: f64) -> f64 {
-        match self {
-            Tf::Linear => v,
-            Tf::Srgb => {
-                let a = v.abs();
-                let e = if a <= 0.003_130_8 { a * 12.92 } else { 1.055 * a.powf(1.0 / 2.4) - 0.055 };
-                e.copysign(v)
-            }
-            Tf::Gamma(g) => v.abs().powf(1.0 / g).copysign(v),
-            Tf::AcesCct => {
-                if v <= 0.007_812_5 {
-                    10.540_237_741_654_5 * v + 0.072_905_534_195_835_5
-                } else {
-                    (v.log2() + 9.72) / 17.52
-                }
-            }
-            Tf::AcesCc => {
-                if v <= 0.0 {
-                    ACESCC_MIN
-                } else if v < 2f64.powi(-15) {
-                    ((2f64.powi(-16) + v * 0.5).log2() + 9.72) / 17.52
-                } else {
-                    (v.log2() + 9.72) / 17.52
-                }
-            }
-            Tf::Pq => {
-                let (m1, m2, c1, c2, c3) = pq_consts();
-                let y = (v / 100.0).max(0.0).powf(m1);
-                ((c1 + c2 * y) / (1.0 + c3 * y)).powf(m2)
-            }
-        }
-    }
-}
-
-fn pq_consts() -> (f64, f64, f64, f64, f64) {
-    (2610.0 / 16384.0, 2523.0 / 4096.0 * 128.0, 3424.0 / 4096.0, 2413.0 / 4096.0 * 32.0, 2392.0 / 4096.0 * 32.0)
-}
-
-/// A colour space of the built-in config.
-#[derive(Clone, Copy, Debug)]
-pub struct Space {
-    pub name: &'static str,
-    /// Primaries and white (None = CIE XYZ itself).
-    pub prims: Option<([[f64; 2]; 3], [f64; 2])>,
-    pub tf: Tf,
-    /// Passes data through untouched.
-    pub raw: bool,
-}
-
-pub(crate) const fn sp(name: &'static str, prims: [[f64; 2]; 3], white: [f64; 2], tf: Tf) -> Space {
-    Space { name, prims: Some((prims, white)), tf, raw: false }
-}
-
-/// The built-in configuration's colour spaces, in popup order.
-pub(crate) const ACES2065_1: Space = sp("ACES2065-1", AP0, ACES_WHITE, Tf::Linear);
-pub(crate) const ACES_CG: Space = sp("ACEScg", AP1, ACES_WHITE, Tf::Linear);
-const ACES_CCT: Space = sp("ACEScct", AP1, ACES_WHITE, Tf::AcesCct);
-
-pub const SPACES: &[Space] = &[
-    ACES2065_1,
-    ACES_CG,
-    ACES_CCT,
-    sp("Linear Rec.709 (sRGB)", REC709, D65, Tf::Linear),
-    sp("sRGB", REC709, D65, Tf::Srgb),
-    sp("Gamma 2.4 Rec.709", REC709, D65, Tf::Gamma(2.4)),
-    sp("Linear Rec.2020", REC2020, D65, Tf::Linear),
-    sp("Gamma 2.4 Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
-    sp("Linear P3-D65", P3, D65, Tf::Linear),
-    sp("Display P3", P3, D65, Tf::Srgb),
-    Space { name: "CIE-XYZ-D65", prims: None, tf: Tf::Linear, raw: false },
-    Space { name: "Raw", prims: None, tf: Tf::Linear, raw: true },
-];
-
-pub fn space_names() -> Vec<&'static str> {
-    SPACES.iter().map(|s| s.name).collect()
-}
+pub use cdl::Cdl;
+pub(crate) use effects::CUSTOM_CONFIG_FX;
+#[cfg(test)]
+pub use effects::parse_looks;
+pub use effects::{color_stabilizer_maps, warning};
+#[cfg(test)]
+use effects::{tonemap, tonemap_inv};
+pub use lut::{FileXform, load_file};
+#[cfg(test)]
+pub use lut::{parse_file, parse_spi1d, parse_spi3d, parse_spimtx};
+pub use program::{ColorOp, Straight, color_program};
+pub use registry::specs;
+#[cfg(test)]
+use space::M3;
+pub(crate) use space::{ACES_CG, ACES2065_1, D65, P3, REC709, REC2020, sp};
+#[cfg(test)]
+pub use space::{SPACES, Xform, bradford, space_by_name};
+pub use space::{Space, Tf, matrix};
 
 #[cfg(test)]
-pub fn space_by_name(n: &str) -> Option<&'static Space> {
-    SPACES.iter().find(|s| s.name.eq_ignore_ascii_case(n))
-}
-
-/// Bradford chromatic adaptation from white `src` to white `dst` (xy).
-pub fn bradford(src: [f64; 2], dst: [f64; 2]) -> M3 {
-    if src == dst {
-        return IDENTITY;
-    }
-    const MB: M3 = [[0.8951, 0.2664, -0.1614], [-0.7502, 1.7135, 0.0367], [0.0389, -0.0685, 1.0296]];
-    let xyz = |c: [f64; 2]| [c[0] / c[1], 1.0, (1.0 - c[0] - c[1]) / c[1]];
-    let s = mul_vec(&MB, xyz(src));
-    let d = mul_vec(&MB, xyz(dst));
-    let diag = [[d[0] / s[0], 0.0, 0.0], [0.0, d[1] / s[1], 0.0], [0.0, 0.0, d[2] / s[2]]];
-    mul(&invert(&MB), &mul(&diag, &MB))
-}
-
-impl Space {
-    /// Linear RGB → XYZ D65 (Bradford-adapted when `adapt`, else the space's own white).
-    pub fn to_ref(self, adapt: bool) -> M3 {
-        match self.prims {
-            None => IDENTITY,
-            Some((p, w)) => {
-                let m = rgb_to_xyz(p, w);
-                if adapt { mul(&bradford(w, D65), &m) } else { m }
-            }
-        }
-    }
-}
-
-/// Linear-RGB matrix from space `a` to space `b`.
-pub fn matrix(a: &Space, b: &Space) -> M3 {
-    mul(&invert(&b.to_ref(true)), &a.to_ref(true))
-}
-
-/// A compiled colour-space conversion.
-#[derive(Clone, Copy, Debug)]
-pub struct Xform {
-    dec: Tf,
-    m: [[f32; 3]; 3],
-    ident: bool,
-    enc: Tf,
-}
-
-impl Xform {
-    pub fn new(a: &Space, b: &Space) -> Xform {
-        if a.raw || b.raw {
-            return Xform { dec: Tf::Linear, m: IDENTITY.map(|r| r.map(|v| v as f32)), ident: true, enc: Tf::Linear };
-        }
-        let m = matrix(a, b);
-        let ident = (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-12));
-        Xform { dec: a.tf, m: m.map(|r| r.map(|v| v as f32)), ident, enc: b.tf }
-    }
-    #[inline]
-    pub fn apply(&self, c: [f32; 3]) -> [f32; 3] {
-        let l = c.map(|v| self.dec.decode(v as f64) as f32);
-        let l = if self.ident { l } else { [0, 1, 2].map(|i| self.m[i][0] * l[0] + self.m[i][1] * l[1] + self.m[i][2] * l[2]) };
-        l.map(|v| self.enc.encode(v as f64) as f32)
-    }
-}
-
-// ---------------------------------------------------------------- ASC CDL
-
-/// An ASC Colour Decision List correction.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Cdl {
-    pub slope: [f64; 3],
-    pub offset: [f64; 3],
-    pub power: [f64; 3],
-    pub sat: f64,
-}
-
-impl Default for Cdl {
-    fn default() -> Self {
-        Cdl { slope: [1.0; 3], offset: [0.0; 3], power: [1.0; 3], sat: 1.0 }
-    }
-}
-
-const LUMA: [f64; 3] = [0.2126, 0.7152, 0.0722];
-
-impl Cdl {
-    /// Forward CDL. `clamp` = the v1.2 style (results clamped to 0..1 after SOP and saturation).
-    pub fn apply(&self, c: [f64; 3], clamp: bool) -> [f64; 3] {
-        let mut o = [0.0; 3];
-        for i in 0..3 {
-            let v = c[i] * self.slope[i] + self.offset[i];
-            o[i] = if clamp {
-                v.clamp(0.0, 1.0).powf(self.power[i])
-            } else if v >= 0.0 {
-                v.powf(self.power[i])
-            } else {
-                v
-            };
-        }
-        let l = o[0] * LUMA[0] + o[1] * LUMA[1] + o[2] * LUMA[2];
-        let o = o.map(|v| l + self.sat * (v - l));
-        if clamp { o.map(|v| v.clamp(0.0, 1.0)) } else { o }
-    }
-    /// Exact inverse of [`Cdl::apply`] (inside the clamped range).
-    pub fn invert(&self, c: [f64; 3], clamp: bool) -> [f64; 3] {
-        let c = if clamp { c.map(|v| v.clamp(0.0, 1.0)) } else { c };
-        let l = c[0] * LUMA[0] + c[1] * LUMA[1] + c[2] * LUMA[2];
-        let s = if self.sat.abs() < 1e-9 { 1e-9 } else { self.sat };
-        let o = c.map(|v| l + (v - l) / s);
-        let mut r = [0.0; 3];
-        for i in 0..3 {
-            let v = if clamp { o[i].clamp(0.0, 1.0) } else { o[i] };
-            let pw = self.power[i].max(1e-9);
-            let u = if v >= 0.0 { v.powf(1.0 / pw) } else { v };
-            let sl = if self.slope[i].abs() < 1e-9 { 1e-9 } else { self.slope[i] };
-            r[i] = (u - self.offset[i]) / sl;
-        }
-        if clamp { r.map(|v| v.clamp(0.0, 1.0)) } else { r }
-    }
-}
-
-fn tag<'a>(xml: &'a str, name: &str) -> Option<&'a str> {
-    let open = xml.find(&format!("<{name}"))?;
-    let gt = open + xml[open..].find('>')?;
-    if xml[..gt].ends_with('/') {
-        return Some("");
-    }
-    let close = xml[gt..].find(&format!("</{name}>"))? + gt;
-    Some(&xml[gt + 1..close])
-}
-
-fn nums3(s: &str) -> Option<[f64; 3]> {
-    let v: Vec<f64> = s.split_whitespace().filter_map(|t| t.parse().ok()).collect();
-    (v.len() >= 3).then(|| [v[0], v[1], v[2]])
-}
-
-fn parse_cc(block: &str) -> Cdl {
-    let mut c = Cdl::default();
-    if let Some(s) = tag(block, "Slope").and_then(nums3) {
-        c.slope = s;
-    }
-    if let Some(s) = tag(block, "Offset").and_then(nums3) {
-        c.offset = s;
-    }
-    if let Some(s) = tag(block, "Power").and_then(nums3) {
-        c.power = s;
-    }
-    if let Some(s) = tag(block, "Saturation").and_then(|t| t.trim().parse().ok()) {
-        c.sat = s;
-    }
-    c
-}
-
-/// Parse ASC CDL XML (`.cc`, `.ccc`, `.cdl`): every `<ColorCorrection>` with its `id`.
-pub fn parse_cdl_xml(xml: &str) -> Vec<(String, Cdl)> {
-    let mut out = vec![];
-    let mut rest = xml;
-    while let Some(i) = rest.find("<ColorCorrection") {
-        let after = &rest[i..];
-        let head_end = after.find('>').unwrap_or(after.len());
-        let head = &after[..head_end];
-        let id = head
-            .find("id=")
-            .and_then(|k| {
-                let q = head[k + 3..].chars().next()?;
-                let s = &head[k + 4..];
-                s.find(q).map(|e| s[..e].to_string())
-            })
-            .unwrap_or_default();
-        let end = after.find("</ColorCorrection>").map(|e| e + "</ColorCorrection>".len()).unwrap_or(after.len());
-        out.push((id, parse_cc(&after[..end])));
-        rest = &after[end..];
-    }
-    out
-}
-
-// ---------------------------------------------------------------- LUT files
-
-/// A loaded transform file.
-#[derive(Clone, Debug)]
-pub enum FileXform {
-    /// A lattice/1D LUT with an optional per-channel piecewise-linear shaper (cineSpace pre-LUT).
-    Lut { lut: Lut, shaper: Option<[Vec<(f32, f32)>; 3]> },
-    /// CDL corrections by id (in file order).
-    Cdl(Vec<(String, Cdl)>),
-    /// A matrix with offset (Sony Imageworks `.spimtx`), as a MatrixTransform's.
-    Matrix { m: [f64; 16], offset: [f64; 4] },
-}
-
-/// Parse a Sony Imageworks `.spimtx` matrix: three rows of four numbers, three matrix columns
-/// and an offset in 16-bit code values (÷ 65535).
-pub fn parse_spimtx(text: &str) -> Option<FileXform> {
-    let v: Vec<f64> = text.split_whitespace().map(|t| t.parse().ok()).collect::<Option<_>>()?;
-    if v.len() != 12 || v.iter().any(|x| !x.is_finite()) {
-        return None;
-    }
-    let mut m = [0.0; 16];
-    let mut offset = [0.0; 4];
-    for (r, row) in v.as_chunks::<4>().0.iter().enumerate() {
-        m[r * 4..r * 4 + 3].copy_from_slice(&row[..3]);
-        offset[r] = row[3] / 65535.0;
-    }
-    m[15] = 1.0;
-    Some(FileXform::Matrix { m, offset })
-}
-
-/// Parse a Sony Imageworks `.spi1d` 1D LUT: `From <min> <max>`, `Length <n>`, `Components
-/// <1 | 3>`, then `{` the values `}`.
-pub fn parse_spi1d(text: &str) -> Option<Lut> {
-    let (mut from, mut len, mut comps) = ([0.0f32, 1.0], 0usize, 1usize);
-    let mut values: Vec<f32> = vec![];
-    let mut body = false;
-    for line in text.lines().map(str::trim).filter(|l| !l.is_empty()) {
-        if body {
-            if line.starts_with('}') {
-                break;
-            }
-            for t in line.split_whitespace() {
-                values.push(t.parse().ok()?);
-            }
-            continue;
-        }
-        let mut t = line.split_whitespace();
-        match t.next()? {
-            "{" => body = true,
-            "From" => from = [t.next()?.parse().ok()?, t.next()?.parse().ok()?],
-            "Length" => len = t.next()?.parse().ok()?,
-            "Components" => comps = t.next()?.parse().ok()?,
-            _ => {}
-        }
-    }
-    // A 1D table is interpolated by index, so cap it like the lattices (2²⁴ entries).
-    if !(2..=1 << 24).contains(&len)
-        || !matches!(comps, 1 | 3)
-        || values.len() != len.checked_mul(comps)?
-        || from[1] <= from[0]
-        || from.iter().any(|v| !v.is_finite())
-    {
-        return None;
-    }
-    let d1 = values.chunks_exact(comps).map(|c| if comps == 3 { [c[0], c[1], c[2]] } else { [c[0]; 3] }).collect();
-    Some(Lut { n1: len, d1, n3: 0, d3: vec![], dmin: [from[0]; 3], dmax: [from[1]; 3] })
-}
-
-/// Parse a Sony Imageworks `.spi3d` lattice: `SPILUT 1.0`, `3 3`, the sizes, then one
-/// `r g b  R G B` line per lattice point (indices, then the colour).
-pub fn parse_spi3d(text: &str) -> Option<Lut> {
-    let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
-    if !lines.next()?.starts_with("SPILUT") {
-        return None;
-    }
-    lines.next()?;
-    let size: Vec<usize> = lines.next()?.split_whitespace().map(|t| t.parse().ok()).collect::<Option<_>>()?;
-    let n = *size.first()?;
-    if size.len() != 3 || size.iter().any(|s| *s != n) || !(2..=129).contains(&n) {
-        return None;
-    }
-    let mut d3 = vec![[0.0f32; 3]; n * n * n];
-    let mut seen = 0usize;
-    for line in lines {
-        let v: Vec<&str> = line.split_whitespace().collect();
-        let [r, g, b, cr, cg, cb] = v.as_slice() else { return None };
-        let (r, g, b): (usize, usize, usize) = (r.parse().ok()?, g.parse().ok()?, b.parse().ok()?);
-        if r >= n || g >= n || b >= n {
-            return None;
-        }
-        // Our lattice is red fastest.
-        *d3.get_mut(r + g * n + b * n * n)? = [cr.parse().ok()?, cg.parse().ok()?, cb.parse().ok()?];
-        seen += 1;
-    }
-    (seen == n * n * n).then_some(Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] })
-}
-
-/// Parse an Autodesk `.3dl` lattice (integers, blue fastest; an optional input-mesh line).
-pub fn parse_3dl(text: &str) -> Option<Lut> {
-    let mut mesh: Option<Vec<f64>> = None;
-    let mut rows: Vec<[f64; 3]> = vec![];
-    let mut out_bits: Option<u32> = None;
-    for line in text.lines() {
-        let l = line.trim();
-        if l.is_empty() || l.starts_with('#') || l.starts_with('<') {
-            continue;
-        }
-        if l.starts_with(|c: char| c.is_ascii_alphabetic()) {
-            // "Mesh <in bits> <out bits>" (Lustre header); other keywords are ignored.
-            let t: Vec<&str> = l.split_whitespace().collect();
-            if t[0].eq_ignore_ascii_case("mesh") && t.len() >= 3 {
-                out_bits = t[2].parse().ok();
-            }
-            continue;
-        }
-        let v: Vec<f64> = l.split_whitespace().filter_map(|t| t.parse().ok()).collect();
-        if v.len() > 3 && mesh.is_none() && rows.is_empty() {
-            mesh = Some(v);
-        } else if v.len() == 3 {
-            rows.push([v[0], v[1], v[2]]);
-        } else {
-            return None;
-        }
-    }
-    let is_cube = |k: usize| {
-        let n = (k as f64).cbrt().round() as usize;
-        n * n * n == k
-    };
-    // A 3-entry input mesh (3³ lattice) looks like a data row: tell them apart by the count.
-    if mesh.is_none() && !is_cube(rows.len()) && rows.len() == 28 {
-        mesh = Some(rows.remove(0).to_vec());
-    }
-    let n = match &mesh {
-        Some(m) => m.len(),
-        None => (rows.len() as f64).cbrt().round() as usize,
-    };
-    if n < 2 || rows.len() != n * n * n {
-        return None;
-    }
-    let maxv = rows.iter().flat_map(|r| r.iter()).fold(0.0f64, |m, &v| m.max(v));
-    let out_max = match out_bits {
-        Some(b) if b > 0 && b < 32 => (1u64 << b) as f64 - 1.0,
-        _ => [255.0, 1023.0, 4095.0, 65535.0].into_iter().find(|&m| maxv <= m).unwrap_or(maxv.max(1.0)),
-    };
-    // .3dl rows: red slowest, blue fastest. Our lattice is red fastest.
-    let mut d3 = vec![[0.0f32; 3]; n * n * n];
-    for (k, r) in rows.iter().enumerate() {
-        let (ri, gi, bi) = (k / (n * n), (k / n) % n, k % n);
-        d3[ri + gi * n + bi * n * n] = r.map(|v| (v / out_max) as f32);
-    }
-    Some(Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] })
-}
-
-/// Parse a cineSpace `.csp` LUT (1D or 3D, with its three pre-LUT shapers).
-pub fn parse_csp(text: &str) -> Option<(Lut, [Vec<(f32, f32)>; 3])> {
-    let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
-    if !lines.next()?.starts_with("CSPLUTV100") {
-        return None;
-    }
-    let kind = lines.next()?;
-    let mut lines = lines.peekable();
-    if lines.peek().is_some_and(|l| l.starts_with("BEGIN METADATA")) {
-        for l in lines.by_ref() {
-            if l.starts_with("END METADATA") {
-                break;
-            }
-        }
-    }
-    let nums = |l: &str| -> Option<Vec<f32>> { l.split_whitespace().map(|t| t.parse().ok()).collect() };
-    let mut shaper: [Vec<(f32, f32)>; 3] = Default::default();
-    for ch in shaper.iter_mut() {
-        let n: usize = lines.next()?.parse().ok()?;
-        let ins = nums(lines.next()?)?;
-        let outs = nums(lines.next()?)?;
-        if ins.len() != n || outs.len() != n || n < 2 {
-            return None;
-        }
-        *ch = ins.into_iter().zip(outs).collect();
-    }
-    if kind.starts_with("3D") {
-        let sz = nums(lines.next()?)?;
-        if sz.len() != 3 || sz[0] != sz[1] || sz[1] != sz[2] {
-            return None;
-        }
-        let n = sz[0] as usize;
-        let mut d3 = Vec::with_capacity(n * n * n);
-        for _ in 0..n * n * n {
-            let v = nums(lines.next()?)?;
-            if v.len() != 3 {
-                return None;
-            }
-            d3.push([v[0], v[1], v[2]]);
-        }
-        (n >= 2).then_some((Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] }, shaper))
-    } else {
-        let n: usize = lines.next()?.parse().ok()?;
-        let mut d1 = Vec::with_capacity(n);
-        for _ in 0..n {
-            let v = nums(lines.next()?)?;
-            if v.len() != 3 {
-                return None;
-            }
-            d1.push([v[0], v[1], v[2]]);
-        }
-        (n >= 2).then_some((Lut { n1: n, d1, n3: 0, d3: vec![], dmin: [0.0; 3], dmax: [1.0; 3] }, shaper))
-    }
-}
-
-fn shape(curve: &[(f32, f32)], x: f32) -> f32 {
-    if curve.len() < 2 {
-        return x;
-    }
-    let i = curve.partition_point(|p| p.0 < x).clamp(1, curve.len() - 1);
-    let (a, b) = (curve[i - 1], curve[i]);
-    let t = ((x - a.0) / (b.0 - a.0).max(1e-12)).clamp(0.0, 1.0);
-    a.1 + (b.1 - a.1) * t
-}
-
-fn shape_inv(curve: &[(f32, f32)], y: f32) -> f32 {
-    let flipped: Vec<(f32, f32)> = curve.iter().map(|&(a, b)| (b, a)).collect();
-    shape(&flipped, y)
-}
-
-/// Parse transform text by its format (detected from `ext` or the content).
-pub fn parse_file(text: &str, ext: &str) -> Option<FileXform> {
-    let ext = ext.to_ascii_lowercase();
-    if ext == "cc" || ext == "ccc" || ext == "cdl" || text.contains("<ColorCorrection") {
-        let v = parse_cdl_xml(text);
-        return (!v.is_empty()).then_some(FileXform::Cdl(v));
-    }
-    if ext == "csp" || text.trim_start().starts_with("CSPLUTV100") {
-        return parse_csp(text).map(|(lut, s)| FileXform::Lut { lut, shaper: Some(s) });
-    }
-    if ext == "spimtx" {
-        return parse_spimtx(text);
-    }
-    if ext == "spi1d" || text.trim_start().starts_with("Version") {
-        return parse_spi1d(text).map(|lut| FileXform::Lut { lut, shaper: None });
-    }
-    if ext == "spi3d" || text.trim_start().starts_with("SPILUT") {
-        return parse_spi3d(text).map(|lut| FileXform::Lut { lut, shaper: None });
-    }
-    if ext == "cube" || text.contains("LUT_3D_SIZE") || text.contains("LUT_1D_SIZE") {
-        return parse_cube(text).map(|lut| FileXform::Lut { lut, shaper: None });
-    }
-    parse_3dl(text).map(|lut| FileXform::Lut { lut, shaper: None })
-}
-
-type FileCache = Mutex<HashMap<String, Option<Arc<FileXform>>>>;
-
-/// Load (and cache) a transform from a file path or inline content.
-pub fn load_file(src: &str) -> Option<Arc<FileXform>> {
-    let src_t = src.trim();
-    if src_t.is_empty() {
-        return None;
-    }
-    static CACHE: OnceLock<FileCache> = OnceLock::new();
-    let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new()));
-    if let Ok(m) = cache.lock()
-        && let Some(v) = m.get(src)
-    {
-        return v.clone();
-    }
-    let inline = src.contains('\n');
-    let parsed = if inline {
-        parse_file(src, "")
-    } else {
-        let ext = std::path::Path::new(src_t).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("");
-        std::fs::read_to_string(src_t).ok().and_then(|t| parse_file(&t, ext))
-    }
-    .map(Arc::new);
-    if let Ok(mut m) = cache.lock() {
-        m.insert(src.to_string(), parsed.clone());
-    }
-    parsed
-}
-
-impl FileXform {
-    pub fn apply(&self, c: [f32; 3], interp: u32, inverse: bool, ccc_id: &str) -> [f32; 3] {
-        match self {
-            FileXform::Cdl(list) => {
-                let cdl = list.iter().find(|(id, _)| !ccc_id.is_empty() && id == ccc_id).or(list.first()).map(|(_, c)| *c).unwrap_or_default();
-                let c64 = c.map(|v| v as f64);
-                let o = if inverse { cdl.invert(c64, true) } else { cdl.apply(c64, true) };
-                o.map(|v| v as f32)
-            }
-            FileXform::Matrix { m, offset } => crate::ocio_config::matrix_apply(m, offset, c.map(|v| v as f64), inverse).map(|v| v as f32),
-            FileXform::Lut { lut, shaper } => {
-                let fwd = |c: [f32; 3]| {
-                    let c = match shaper {
-                        Some(s) => [shape(&s[0], c[0]), shape(&s[1], c[1]), shape(&s[2], c[2])],
-                        None => c,
-                    };
-                    lut.apply_interp(c, interp)
-                };
-                if !inverse {
-                    return fwd(c);
-                }
-                if lut.n3 == 0 {
-                    // 1D: invert each channel exactly through the (monotone) tables.
-                    let mut x = c;
-                    if lut.n1 > 1 {
-                        x = [0, 1, 2].map(|i| {
-                            let curve: Vec<(f32, f32)> =
-                                (0..lut.n1).map(|k| (lut.d1[k][i], lut.dmin[i] + (lut.dmax[i] - lut.dmin[i]) * k as f32 / (lut.n1 - 1) as f32)).collect();
-                            shape(&curve, c[i])
-                        });
-                    }
-                    if let Some(s) = shaper {
-                        x = [shape_inv(&s[0], x[0]), shape_inv(&s[1], x[1]), shape_inv(&s[2], x[2])];
-                    }
-                    return x;
-                }
-                // 3D: damped fixed-point (Newton with an identity Jacobian) from the target.
-                let mut x = c;
-                for _ in 0..40 {
-                    let y = fwd(x);
-                    let e = [c[0] - y[0], c[1] - y[1], c[2] - y[2]];
-                    if e.iter().all(|v| v.abs() < 1e-6) {
-                        break;
-                    }
-                    x = [x[0] + e[0], x[1] + e[1], x[2] + e[2]];
-                }
-                x
-            }
-        }
-    }
-}
-
-// ---------------------------------------------------------------- displays, views and looks
-
-/// Displays of the built-in config: (name, display primaries/white, encoding).
-pub const DISPLAYS: &[(&str, [[f64; 2]; 3], Tf)] =
-    &[("sRGB", REC709, Tf::Srgb), ("Rec.1886 Rec.709", REC709, Tf::Gamma(2.4)), ("Display P3", P3, Tf::Srgb), ("Rec.2100-PQ", REC2020, Tf::Pq)];
-
-pub const VIEWS: &[&str] = &["Standard", "Tone Mapped", "Raw"];
-
-/// Configuration popup: the built-in config, or a custom `.ocio` file (Config File: a path or
-/// the config's text; spaces chosen by name, see [`crate::ocio_config`]).
-pub const CONFIGS: &[&str] = &["Built-in (EffectCraft minimal)", "Custom (.ocio file)"];
-
-/// Built-in looks: CDLs applied in ACEScct.
-pub fn looks() -> Vec<(&'static str, Cdl)> {
-    let grey = 0.413_588_402_492_442_1; // ACEScct of 0.18
-    let c = |slope: [f64; 3], offset: [f64; 3], sat: f64| Cdl { slope, offset, power: [1.0; 3], sat };
-    vec![
-        ("Warm", c([1.04, 1.0, 0.94], [0.0; 3], 1.0)),
-        ("Cool", c([0.95, 1.0, 1.06], [0.0; 3], 1.0)),
-        ("High Contrast", c([1.25; 3], [grey * (1.0 - 1.25); 3], 1.0)),
-        ("Low Contrast", c([0.8; 3], [grey * (1.0 - 0.8); 3], 1.0)),
-        ("Desaturated", c([1.0; 3], [0.0; 3], 0.6)),
-        ("Vivid", c([1.0; 3], [0.0; 3], 1.3)),
-    ]
-}
-
-/// Extended Reinhard roll-off (white point 16): maps 0..∞ into 0..1, ≈ identity near 0.
-fn tonemap(v: f64) -> f64 {
-    let w2 = 256.0;
-    if v <= 0.0 { v } else { v * (1.0 + v / w2) / (1.0 + v) }
-}
-
-fn tonemap_inv(y: f64) -> f64 {
-    if y <= 0.0 {
-        return y;
-    }
-    // Solve v² / w² + v (1 − y) − y = 0.
-    let (a, b, c) = (1.0 / 256.0, 1.0 - y, -y);
-    (-b + (b * b - 4.0 * a * c).sqrt()) / (2.0 * a)
-}
-
-/// Display transform of an input-space colour (`inverse`: display code values → input space).
-pub fn display_xform(input: &Space, display: usize, view: usize, inverse: bool) -> impl Fn([f32; 3]) -> [f32; 3] + Sync {
-    let (_, prims, tf) = DISPLAYS[display.min(DISPLAYS.len() - 1)];
-    let disp = Space { name: "display", prims: Some((prims, D65)), tf: Tf::Linear, raw: false };
-    let raw = view == 2 || input.raw;
-    let m_in = Xform::new(&Space { tf: Tf::Linear, ..*input }, &disp);
-    let m_out = Xform::new(&disp, &Space { tf: Tf::Linear, ..*input });
-    let in_tf = input.tf;
-    move |c: [f32; 3]| {
-        if raw {
-            return c;
-        }
-        if !inverse {
-            let lin = c.map(|v| in_tf.decode(v as f64) as f32);
-            let d = m_in.apply(lin);
-            d.map(|v| {
-                let v = v as f64;
-                let v = if view == 1 { tonemap(v) } else { v };
-                tf.encode(v) as f32
-            })
-        } else {
-            let d = c.map(|v| {
-                let l = tf.decode(v as f64);
-                (if view == 1 { tonemap_inv(l) } else { l }) as f32
-            });
-            m_out.apply(d).map(|v| in_tf.encode(v as f64) as f32)
-        }
-    }
-}
-
-// ---------------------------------------------------------------- effects
-
-fn spec(id: &'static str, name: &'static str, cat: &'static str, params: Vec<crate::ParamSpec>, render: crate::RenderFn) -> EffectSpec {
-    EffectSpec { id, name, category: cat, params, render, gpu: false, float: true }
-}
-
-fn space_param(id: &'static str, name: &'static str, default: u32) -> crate::ParamSpec {
-    p(id, name, Value::Enum(default), popup(&space_names()))
-}
-
-fn direction() -> crate::ParamSpec {
-    p("direction", "Direction", Value::Enum(0), popup(&["Forward", "Inverse"]))
-}
-
-fn map_px(b: &mut Buf, f: impl Fn([f32; 3]) -> [f32; 3] + Sync) {
-    b.img.data.par_iter_mut().for_each(|px| {
-        let (c, a) = unpremul(*px);
-        if a <= 0.0 {
-            return;
-        }
-        let o = f(c);
-        *px = [o[0] * a, o[1] * a, o[2] * a, a];
-    });
-}
-
-fn space_at(i: u32) -> &'static Space {
-    &SPACES[(i as usize).min(SPACES.len() - 1)]
-}
-
-/// The effects that take Configuration ▸ Custom (a `.ocio` file).
-pub(crate) const CUSTOM_CONFIG_FX: [&str; 2] = ["ec.color.ociocolorspace", "ec.color.ociodisplay"];
-
-/// Effect `id`'s transform under Configuration ▸ Custom: the config's conversion from the source
-/// space to the destination space (Color Space Transform) or through a display's view (Display
-/// Transform), see [`crate::ocio_config`]. `Ok(None)` with the built-in configuration; an error
-/// (the pixels pass through) when the config can't be read or has no such colour space.
-fn custom_xf(id: &str, pr: &crate::Params) -> Result<Option<crate::ocio_config::Xf>, String> {
-    use crate::ocio_config::Xf;
-    if !CUSTOM_CONFIG_FX.contains(&id) || pr.e("config") != 1 {
-        return Ok(None);
-    }
-    let cfg = crate::ocio_config::load_config(pr.s("configFile")).map_err(|e| format!("Can't read the OCIO config: {e}"))?;
-    // A space by its typed name, else by the built-in popup's name.
-    let space = |name: &str, popup: u32| {
-        let name = if name.trim().is_empty() { space_at(popup).name } else { name.trim() };
-        cfg.space(name).ok_or_else(|| format!("The OCIO config has no color space `{name}`"))
-    };
-    let a = space(pr.s("sourceName"), pr.e("source"))?;
-    let inverse = pr.e("direction") == 1;
-    if id == "ec.color.ociodisplay" {
-        let (dn, vn) = display_view_names(pr);
-        let xf = cfg.display_path(a, dn, vn);
-        return Ok(Some(if inverse { Xf::Inverse(Box::new(xf)) } else { xf }));
-    }
-    let z = space(pr.s("destinationName"), pr.e("destination"))?;
-    // Inverse: the conversion the other way (OCIO's inverse ColorSpaceTransform).
-    Ok(Some(if inverse { cfg.path(z, a) } else { cfg.path(a, z) }))
-}
-
-/// The display and view a Display Transform names: the typed names, else the popups'.
-fn display_view_names(pr: &crate::Params) -> (&str, &str) {
-    let display = DISPLAYS.get(pr.e("display") as usize).map_or("", |d| d.0);
-    let view = VIEWS.get(pr.e("view") as usize).copied().unwrap_or("");
-    let typed = |k: &str, popup| if pr.s(k).trim().is_empty() { popup } else { pr.s(k).trim() };
-    (typed("displayName", display), typed("viewName", view))
-}
-
-/// Effect Controls' warning for effect `id`: a custom OCIO configuration that can't be read, has
-/// no such colour space, display or view, or uses transforms EffectCraft can't apply (colours
-/// pass through those steps, #410). `None` when the effect renders as asked.
-pub fn warning(id: &str, pr: &crate::Params) -> Option<String> {
-    let xf = match custom_xf(id, pr) {
-        Ok(x) => x?,
-        Err(e) => return Some(format!("{e}: the colors pass through.")),
-    };
-    let mut notes = vec![];
-    if id == "ec.color.ociodisplay"
-        && let Ok(cfg) = crate::ocio_config::load_config(pr.s("configFile"))
-    {
-        let (dn, vn) = display_view_names(pr);
-        if let Some((d, v)) = cfg.view(dn, vn)
-            && (!d.eq_ignore_ascii_case(dn) || !v.name.eq_ignore_ascii_case(vn))
-        {
-            notes.push(format!("The OCIO config has no display `{dn}` with a view `{vn}`: showing {d} / {}.", v.name));
-        }
-    }
-    let missing = xf.unsupported_list();
-    if !missing.is_empty() {
-        notes.push(format!("Not supported, the colors pass through: {}.", missing.join(", ")));
-    }
-    (!notes.is_empty()).then(|| notes.join(" "))
-}
-
-/// Configuration ▸ Custom: render through the config's transform. `false` with the built-in
-/// configuration (the caller renders it).
-fn custom_render(id: &str, ctx: &EffectCtx, b: &mut Buf) -> bool {
-    match custom_xf(id, ctx.params) {
-        Ok(None) => false,
-        Ok(Some(xf)) => {
-            map_px(b, |c| xf.apply(c.map(|v| v as f64), false).map(|v| v as f32));
-            true
-        }
-        // A config that can't be read, or an unknown space: the pixels pass through.
-        Err(_) => true,
-    }
-}
-
-fn ocio_cst(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    if custom_render("ec.color.ociocolorspace", ctx, &mut b) {
-        return b;
-    }
-    let (a, z) = (space_at(ctx.params.e("source")), space_at(ctx.params.e("destination")));
-    let (a, z) = if ctx.params.e("direction") == 1 { (z, a) } else { (a, z) };
-    if a.name == z.name {
-        return b;
-    }
-    let x = Xform::new(a, z);
-    map_px(&mut b, |c| x.apply(c));
-    b
-}
-
-fn cdl_from_params(pr: &crate::Params) -> Cdl {
-    Cdl {
-        slope: [pr.f("slopeRed"), pr.f("slopeGreen"), pr.f("slopeBlue")],
-        offset: [pr.f("offsetRed"), pr.f("offsetGreen"), pr.f("offsetBlue")],
-        power: [pr.f("powerRed").max(0.0), pr.f("powerGreen").max(0.0), pr.f("powerBlue").max(0.0)],
-        sat: pr.f("saturation").max(0.0),
-    }
-}
-
-fn ocio_cdl(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let cdl = cdl_from_params(ctx.params);
-    if cdl == Cdl::default() {
-        return b;
-    }
-    let clamp = ctx.params.e("style") == 0;
-    let inv = ctx.params.e("direction") == 1;
-    map_px(&mut b, |c| {
-        let c = c.map(|v| v as f64);
-        let o = if inv { cdl.invert(c, clamp) } else { cdl.apply(c, clamp) };
-        o.map(|v| v as f32)
-    });
-    b
-}
-
-fn ocio_display(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    if custom_render("ec.color.ociodisplay", ctx, &mut b) {
-        return b;
-    }
-    let input = space_at(ctx.params.e("source"));
-    let f = display_xform(input, ctx.params.e("display") as usize, ctx.params.e("view") as usize, ctx.params.e("direction") == 1);
-    map_px(&mut b, f);
-    b
-}
-
-fn ocio_file(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let Some(x) = load_file(ctx.params.s("file")) else { return b };
-    let interp = match ctx.params.e("interpolation") {
-        0 => 0,
-        1 => 1,
-        _ => 2,
-    };
-    let inv = ctx.params.e("direction") == 1;
-    let id = ctx.params.s("cccId").to_string();
-    map_px(&mut b, |c| x.apply(c, interp, inv, &id));
-    b
-}
-
-/// Parse a looks string: comma/space separated names, `-Name` = inverse.
-pub fn parse_looks(s: &str) -> Vec<(Cdl, bool)> {
-    let all = looks();
-    s.split([',', ':'])
-        .map(str::trim)
-        .filter(|t| !t.is_empty())
-        .filter_map(|t| {
-            let (inv, n) = match t.strip_prefix('-') {
-                Some(r) => (true, r.trim()),
-                None => (false, t.trim_start_matches('+').trim()),
-            };
-            all.iter().find(|(name, _)| name.eq_ignore_ascii_case(n)).map(|(_, c)| (*c, inv))
-        })
-        .collect()
-}
-
-fn ocio_look(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let mut list = parse_looks(ctx.params.s("looks"));
-    let pick = ctx.params.e("look");
-    if pick > 0
-        && let Some((_, c)) = looks().get(pick as usize - 1)
-    {
-        list.insert(0, (*c, false));
-    }
-    if list.is_empty() {
-        return b;
-    }
-    let (src, dst) = (space_at(ctx.params.e("source")), space_at(ctx.params.e("destination")));
-    let inv = ctx.params.e("direction") == 1;
-    let cct = &ACES_CCT;
-    let (a, z) = if inv { (dst, src) } else { (src, dst) };
-    let to_p = Xform::new(a, cct);
-    let from_p = Xform::new(cct, z);
-    if inv {
-        list.reverse();
-    }
-    map_px(&mut b, |c| {
-        let mut v = to_p.apply(c).map(|x| x as f64);
-        for (cdl, li) in &list {
-            v = if *li != inv { cdl.invert(v, false) } else { cdl.apply(v, false) };
-        }
-        from_p.apply(v.map(|x| x as f32))
-    });
-    b
-}
-
-// ---- Color Profile Converter (Utility)
-
-pub const PROFILES: &[&str] = &["Project Working Space", "sRGB IEC61966-2.1", "HDTV (Rec. 709)", "Rec. 2020", "Display P3", "ACEScg", "ACES2065-1"];
-
-fn profile(ctx: &EffectCtx, i: u32) -> (Space, bool) {
-    let ws = |cs: ColorSpace| match cs {
-        ColorSpace::Srgb => sp("sRGB", REC709, D65, Tf::Srgb),
-        ColorSpace::Rec709 => sp("Rec.709", REC709, D65, Tf::Gamma(2.4)),
-        ColorSpace::Rec2020 => sp("Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
-        ColorSpace::DisplayP3 => sp("Display P3", P3, D65, Tf::Srgb),
-        ColorSpace::AcesCg => ACES_CG,
-        ColorSpace::Aces2065 => ACES2065_1,
-        // HDR encodings are output spaces, never a working space.
-        ColorSpace::Rec2100Pq | ColorSpace::Rec2100Hlg => sp("Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
-    };
-    match i {
-        0 => (ws(ctx.env.working_space.unwrap_or(ColorSpace::Srgb)), ctx.env.working_linear),
-        1 => (ws(ColorSpace::Srgb), false),
-        2 => (ws(ColorSpace::Rec709), false),
-        3 => (ws(ColorSpace::Rec2020), false),
-        4 => (ws(ColorSpace::DisplayP3), false),
-        5 => (ACES_CG, true),
-        _ => (ACES2065_1, true),
-    }
-}
-
-/// Gamut compression for the perceptual intent: pull out-of-gamut (negative) colours toward
-/// their luminance just enough to bring every channel to ≥ 0, rolling off smoothly.
-fn compress_gamut(c: [f64; 3], luma: [f64; 3]) -> [f64; 3] {
-    let l = c[0] * luma[0] + c[1] * luma[1] + c[2] * luma[2];
-    if l <= 0.0 {
-        return c.map(|v| v.max(0.0));
-    }
-    let mn = c.iter().cloned().fold(f64::INFINITY, f64::min);
-    if mn >= 0.0 {
-        return c;
-    }
-    // Fraction of the way toward grey that reaches zero on the most negative channel.
-    let t = (l / (l - mn)).clamp(0.0, 1.0);
-    c.map(|v| l + (v - l) * t)
-}
-
-fn profile_converter(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let (inp, in_lin_default) = profile(ctx, ctx.params.e("inputProfile"));
-    let (out, out_lin_default) = profile(ctx, ctx.params.e("outputProfile"));
-    let in_lin = ctx.params.b("linearizeInputProfile") || in_lin_default && ctx.params.e("inputProfile") == 0;
-    let out_lin = ctx.params.b("linearizeOutputProfile") || out_lin_default && ctx.params.e("outputProfile") == 0;
-    let intent = ctx.params.e("intent");
-    let dec = if in_lin { Tf::Linear } else { inp.tf };
-    let enc = if out_lin { Tf::Linear } else { out.tf };
-    // Absolute colorimetric keeps the source white (no adaptation); the others adapt.
-    let m = if intent == 3 { mul(&invert(&out.to_ref(false)), &inp.to_ref(false)) } else { matrix(&inp, &out) };
-    let identity = dec == enc && (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-9));
-    if identity {
-        return b;
-    }
-    let out_luma = out.to_ref(true)[1];
-    map_px(&mut b, |c| {
-        let l = c.map(|v| dec.decode(v as f64));
-        let mut o = mul_vec(&m, l);
-        match intent {
-            0 => o = compress_gamut(o, out_luma),
-            2 => o = o.map(|v| v.max(0.0)),
-            _ => {}
-        }
-        o.map(|v| enc.encode(v) as f32)
-    });
-    b
-}
-
-// ---- Colour programs (the GPU compositor's colour-management kernels)
-
-/// One per-pixel step of a colour transform, in the order the CPU effect applies them (see
-/// [`color_program`]).
-#[derive(Clone, Debug)]
-pub enum ColorOp {
-    /// Transfer function, encoded → linear.
-    Decode(Tf),
-    /// Transfer function, linear → encoded.
-    Encode(Tf),
-    /// Linear-RGB matrix.
-    Matrix([[f32; 3]; 3]),
-    /// ASC CDL (forward or exact inverse; `clamp` = the v1.2 style).
-    Cdl { cdl: Cdl, clamp: bool, inverse: bool },
-    /// The Tone Mapped view's roll-off (or its inverse).
-    Tonemap { inverse: bool },
-    /// Color Profile Converter's perceptual gamut compression toward luminance `luma`.
-    Gamut([f64; 3]),
-    /// Negative channels to 0 (the saturation intent).
-    Max0,
-    /// A LUT (0 nearest, 1 trilinear, 2 tetrahedral) with an optional per-channel shaper, forward
-    /// or inverse (as [`FileXform::apply`]).
-    Lut { lut: Arc<Lut>, shaper: Option<Arc<[Vec<(f32, f32)>; 3]>>, interp: u32, inverse: bool },
-    /// `m × (c + pre) + post` (a custom config's MatrixTransform and RangeTransform).
-    Affine { m: [[f32; 3]; 3], pre: [f32; 3], post: [f32; 3] },
-    /// `max(c, 0) ^ p` per channel (ExponentTransform).
-    Pow([f32; 3]),
-    /// LogTransform / LogAffineTransform, forward or inverse (as `ocio_config::Xf::apply`).
-    LogAffine { base: f32, log_slope: [f32; 3], log_offset: [f32; 3], lin_slope: [f32; 3], lin_offset: [f32; 3], inverse: bool },
-    /// ExponentWithLinearTransform, forward (decode) or inverse (as
-    /// [`crate::ocio_config::moncurve`]).
-    MonCurve { gamma: [f32; 3], offset: [f32; 3], inverse: bool, mirror: bool },
-    /// Clamp each channel to `lo..=hi` (a clamping RangeTransform; ±`f32::MAX` = unbounded).
-    Clamp { lo: [f32; 3], hi: [f32; 3] },
-}
-
-/// The ops of a matrix-and-offset transform (MatrixTransform, `.spimtx`), forward or inverse
-/// (as [`crate::ocio_config::matrix_apply`]).
-fn matrix_ops(m: &[f64; 16], offset: &[f64; 4], inverse: bool, ops: &mut Vec<ColorOp>) {
-    if !inverse {
-        let m = [0, 1, 2].map(|r| [m[r * 4] as f32, m[r * 4 + 1] as f32, m[r * 4 + 2] as f32]);
-        ops.push(ColorOp::Affine { m, pre: [0.0; 3], post: [offset[0] as f32, offset[1] as f32, offset[2] as f32] });
-    } else if let Some(inv) = crate::ocio_config::mat3_inverse(m) {
-        let m = inv.map(|r| r.map(|v| v as f32));
-        ops.push(ColorOp::Affine { m, pre: [-offset[0] as f32, -offset[1] as f32, -offset[2] as f32], post: [0.0; 3] });
-    }
-}
-
-/// The ops of a LUT / CDL / matrix file transform (as [`FileXform::apply`]).
-fn file_ops(x: &FileXform, interp: u32, inverse: bool, ccc_id: &str, ops: &mut Vec<ColorOp>) {
-    match x {
-        FileXform::Cdl(list) => {
-            let cdl = list.iter().find(|(i, _)| !ccc_id.is_empty() && i == ccc_id).or(list.first()).map(|(_, c)| *c).unwrap_or_default();
-            ops.push(ColorOp::Cdl { cdl, clamp: true, inverse });
-        }
-        FileXform::Lut { lut, shaper } => {
-            ops.push(ColorOp::Lut { lut: Arc::new(lut.clone()), shaper: shaper.clone().map(Arc::new), interp, inverse });
-        }
-        FileXform::Matrix { m, offset } => matrix_ops(m, offset, inverse, ops),
-    }
-}
-
-/// The ops of a custom config's transform `x` (as `Xf::apply`).
-fn config_xf_ops(x: &crate::ocio_config::Xf, inverse: bool, ops: &mut Vec<ColorOp>) {
-    use crate::ocio_config::Xf;
-    let f3 = |v: &[f64; 3]| v.map(|x| x as f32);
-    match x {
-        Xf::Inverse(x) => config_xf_ops(x, !inverse, ops),
-        Xf::Matrix { m, offset } => matrix_ops(m, offset, inverse, ops),
-        Xf::File { xf: Some(x), interp, ccc, .. } => file_ops(x, *interp, inverse, ccc, ops),
-        Xf::ExponentLinear { gamma, offset, mirror } => ops.push(ColorOp::MonCurve { gamma: f3(gamma), offset: f3(offset), inverse, mirror: *mirror }),
-        // A BuiltinTransform's curve: forward decodes.
-        Xf::Curve(tf) => ops.push(if inverse { ColorOp::Encode(*tf) } else { ColorOp::Decode(*tf) }),
-        Xf::Named(_) => {}
-        Xf::File { xf: None, .. } | Xf::Unsupported(_) => {}
-        Xf::Exponent(e) => ops.push(ColorOp::Pow([0, 1, 2].map(|k| (if inverse { 1.0 / e[k].max(1e-9) } else { e[k] }) as f32))),
-        Xf::Log { base } => {
-            ops.push(ColorOp::LogAffine { base: *base as f32, log_slope: [1.0; 3], log_offset: [0.0; 3], lin_slope: [1.0; 3], lin_offset: [0.0; 3], inverse })
-        }
-        Xf::LogAffine { base, log_slope, log_offset, lin_slope, lin_offset } => ops.push(ColorOp::LogAffine {
-            base: *base as f32,
-            log_slope: f3(log_slope),
-            log_offset: f3(log_offset),
-            lin_slope: f3(lin_slope),
-            lin_offset: f3(lin_offset),
-            inverse,
-        }),
-        Xf::Cdl(cdl) => ops.push(ColorOp::Cdl { cdl: *cdl, clamp: true, inverse }),
-        Xf::Range(r) => {
-            let (k, off, lo, hi) = r.parts(inverse);
-            let k = k as f32;
-            ops.push(ColorOp::Affine { m: [[k, 0.0, 0.0], [0.0, k, 0.0], [0.0, 0.0, k]], pre: [0.0; 3], post: [off as f32; 3] });
-            if lo.is_finite() || hi.is_finite() {
-                let bound = |v: f64| (v as f32).clamp(-f32::MAX, f32::MAX);
-                ops.push(ColorOp::Clamp { lo: [bound(lo); 3], hi: [bound(hi); 3] });
-            }
-        }
-        Xf::Group(list) => {
-            if inverse {
-                list.iter().rev().for_each(|x| config_xf_ops(x, true, ops));
-            } else {
-                list.iter().for_each(|x| config_xf_ops(x, false, ops));
-            }
-        }
-    }
-}
-
-/// How a colour program meets premultiplied pixels.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Straight {
-    /// `unpremul` (colour 0 below alpha 1e-6); fully transparent pixels untouched (OCIO effects).
-    Unpremul,
-    /// Colour ÷ alpha; fully transparent pixels untouched (`Image::map_straight`, Apply Color LUT).
-    Divide,
-}
-
-fn xform_ops(x: &Xform, ops: &mut Vec<ColorOp>) {
-    if x.dec != Tf::Linear {
-        ops.push(ColorOp::Decode(x.dec));
-    }
-    if !x.ident {
-        ops.push(ColorOp::Matrix(x.m));
-    }
-    if x.enc != Tf::Linear {
-        ops.push(ColorOp::Encode(x.enc));
-    }
-}
-
-/// Effect `id`'s per-pixel transform as a list of [`ColorOp`]s that reproduces the CPU effect
-/// (empty = the layer passes through; custom OCIO configs compile their transforms too). `None`
-/// for another effect.
-pub fn color_program(id: &str, ctx: &EffectCtx) -> Option<(Vec<ColorOp>, Straight)> {
-    let pr = ctx.params;
-    let mut ops = vec![];
-    // Configuration ▸ Custom compiles the config's transforms (a config that can't be read, or
-    // names unknown spaces, passes the pixels through).
-    match custom_xf(id, pr) {
-        Ok(None) => {}
-        Ok(Some(xf)) => {
-            config_xf_ops(&xf, false, &mut ops);
-            return Some((ops, Straight::Unpremul));
-        }
-        Err(_) => return Some((ops, Straight::Unpremul)),
-    }
-    match id {
-        "ec.utility.applylut" => {
-            if let Some(lut) = crate::utility::load_lut(pr.s("lut")) {
-                ops.push(ColorOp::Lut { lut, shaper: None, interp: 2, inverse: false });
-            }
-            return Some((ops, Straight::Divide));
-        }
-        "ec.color.ociocolorspace" => {
-            let (a, z) = (space_at(pr.e("source")), space_at(pr.e("destination")));
-            let (a, z) = if pr.e("direction") == 1 { (z, a) } else { (a, z) };
-            if a.name != z.name {
-                xform_ops(&Xform::new(a, z), &mut ops);
-            }
-        }
-        "ec.color.ociocdl" => {
-            let cdl = cdl_from_params(pr);
-            if cdl != Cdl::default() {
-                ops.push(ColorOp::Cdl { cdl, clamp: pr.e("style") == 0, inverse: pr.e("direction") == 1 });
-            }
-        }
-        "ec.color.ociodisplay" => {
-            let input = space_at(pr.e("source"));
-            let (display, view, inverse) = (pr.e("display") as usize, pr.e("view") as usize, pr.e("direction") == 1);
-            let (_, prims, tf) = DISPLAYS[display.min(DISPLAYS.len() - 1)];
-            if view != 2 && !input.raw {
-                let disp = Space { name: "display", prims: Some((prims, D65)), tf: Tf::Linear, raw: false };
-                let lin = Space { tf: Tf::Linear, ..*input };
-                if !inverse {
-                    ops.push(ColorOp::Decode(input.tf));
-                    xform_ops(&Xform::new(&lin, &disp), &mut ops);
-                    if view == 1 {
-                        ops.push(ColorOp::Tonemap { inverse: false });
-                    }
-                    ops.push(ColorOp::Encode(tf));
-                } else {
-                    ops.push(ColorOp::Decode(tf));
-                    if view == 1 {
-                        ops.push(ColorOp::Tonemap { inverse: true });
-                    }
-                    xform_ops(&Xform::new(&disp, &lin), &mut ops);
-                    ops.push(ColorOp::Encode(input.tf));
-                }
-            }
-        }
-        "ec.color.ociofile" => {
-            if let Some(x) = load_file(pr.s("file")) {
-                let interp = match pr.e("interpolation") {
-                    0 => 0,
-                    1 => 1,
-                    _ => 2,
-                };
-                file_ops(&x, interp, pr.e("direction") == 1, pr.s("cccId"), &mut ops);
-            }
-        }
-        "ec.color.ociolook" => {
-            let mut list = parse_looks(pr.s("looks"));
-            let pick = pr.e("look");
-            if pick > 0
-                && let Some((_, c)) = looks().get(pick as usize - 1)
-            {
-                list.insert(0, (*c, false));
-            }
-            if !list.is_empty() {
-                let (src, dst) = (space_at(pr.e("source")), space_at(pr.e("destination")));
-                let inv = pr.e("direction") == 1;
-                let cct = &ACES_CCT;
-                let (a, z) = if inv { (dst, src) } else { (src, dst) };
-                if inv {
-                    list.reverse();
-                }
-                xform_ops(&Xform::new(a, cct), &mut ops);
-                for (cdl, li) in &list {
-                    ops.push(ColorOp::Cdl { cdl: *cdl, clamp: false, inverse: *li != inv });
-                }
-                xform_ops(&Xform::new(cct, z), &mut ops);
-            }
-        }
-        "ec.utility.colorprofileconverter" => {
-            let (inp, in_lin_default) = profile(ctx, pr.e("inputProfile"));
-            let (out, out_lin_default) = profile(ctx, pr.e("outputProfile"));
-            let in_lin = pr.b("linearizeInputProfile") || in_lin_default && pr.e("inputProfile") == 0;
-            let out_lin = pr.b("linearizeOutputProfile") || out_lin_default && pr.e("outputProfile") == 0;
-            let intent = pr.e("intent");
-            let dec = if in_lin { Tf::Linear } else { inp.tf };
-            let enc = if out_lin { Tf::Linear } else { out.tf };
-            let m = if intent == 3 { mul(&invert(&out.to_ref(false)), &inp.to_ref(false)) } else { matrix(&inp, &out) };
-            let identity = dec == enc && (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-9));
-            if !identity {
-                ops.push(ColorOp::Decode(dec));
-                ops.push(ColorOp::Matrix(m.map(|r| r.map(|v| v as f32))));
-                match intent {
-                    0 => ops.push(ColorOp::Gamut(out.to_ref(true)[1])),
-                    2 => ops.push(ColorOp::Max0),
-                    _ => {}
-                }
-                ops.push(ColorOp::Encode(enc));
-            }
-        }
-        _ => return None,
-    }
-    Some((ops, Straight::Unpremul))
-}
-
-// ---- Color Stabilizer
-
-/// Mean straight colour of a square (half-size `r` layer pixels) around layer point `pt`.
-fn sample_mean(b: &Buf, pt: [f64; 2], r: f64) -> [f64; 3] {
-    let (cx, cy) = b.to_px(pt);
-    let rr = (r * b.scale).max(0.5);
-    let (x0, x1) = ((cx - rr).floor().max(0.0) as i64, ((cx + rr).ceil() as i64).min(b.img.width as i64));
-    let (y0, y1) = ((cy - rr).floor().max(0.0) as i64, ((cy + rr).ceil() as i64).min(b.img.height as i64));
-    let mut acc = [0.0f64; 4];
-    for y in y0..y1 {
-        for x in x0..x1 {
-            let p = b.img.get(x, y);
-            for k in 0..4 {
-                acc[k] += p[k] as f64;
-            }
-        }
-    }
-    if acc[3] <= 1e-9 {
-        return [0.0; 3];
-    }
-    [acc[0] / acc[3], acc[1] / acc[3], acc[2] / acc[3]]
-}
-
-/// Monotone piecewise-quadratic curve through (0,0), three samples and (1,1) (linear between
-/// them is enough for a stabiliser and stays monotone).
-fn curve3(xs: [f64; 3], ys: [f64; 3], v: f64) -> f64 {
-    let mut pts = vec![(0.0, 0.0)];
-    let mut pairs: Vec<(f64, f64)> = xs.iter().cloned().zip(ys.iter().cloned()).collect();
-    pairs.sort_by(|a, b| a.0.total_cmp(&b.0));
-    for (x, y) in pairs {
-        if pts.last().is_some_and(|l| x > l.0 + 1e-4) && x < 1.0 - 1e-4 {
-            pts.push((x, y));
-        }
-    }
-    pts.push((1.0, 1.0));
-    let i = pts.partition_point(|p| p.0 < v).clamp(1, pts.len() - 1);
-    let (a, c) = (pts[i - 1], pts[i]);
-    a.1 + (c.1 - a.1) * (v - a.0) / (c.0 - a.0).max(1e-9)
-}
-
-/// Color Stabilizer's correction of buffer `b` as one piecewise-linear map per channel (points
-/// with increasing x; the end segments extend), the same maps [`color_stabilizer`] applies.
-/// `None` without a host or reference frame (the layer passes through). (The GPU effect.)
-pub fn color_stabilizer_maps(ctx: &EffectCtx, b: &Buf) -> Option<[Vec<(f64, f64)>; 3]> {
-    let reference = ctx.env.host?.self_at(ctx.params.f("referenceFrame"), ctx.env.effect_index)?;
-    let r = ctx.params.f("sampleSize").max(0.5);
-    let pts = [ctx.params.v2("blackPoint"), ctx.params.v2("midPoint"), ctx.params.v2("whitePoint")];
-    let cur = pts.map(|pt| sample_mean(b, pt, r));
-    let refv = pts.map(|pt| sample_mean(&reference, pt, r));
-    let mode = ctx.params.e("stabilize");
-    Some([0, 1, 2].map(|k| {
-        let offset = |c0: f64, r0: f64| vec![(0.0, r0 - c0), (1.0, 1.0 + r0 - c0)];
-        match mode {
-            0 => offset(cur[0][k], refv[0][k]),
-            1 => {
-                let (c0, c1, r0, r1) = (cur[0][k], cur[2][k], refv[0][k], refv[2][k]);
-                if (c1 - c0).abs() < 1e-6 {
-                    offset(c0, r0)
-                } else if c0 < c1 {
-                    vec![(c0, r0), (c1, r1)]
-                } else {
-                    vec![(c1, r1), (c0, r0)]
-                }
-            }
-            _ => {
-                let mut v = vec![(0.0, 0.0)];
-                let mut pairs: Vec<(f64, f64)> = (0..3).map(|i| (cur[i][k], refv[i][k])).collect();
-                pairs.sort_by(|a, b| a.0.total_cmp(&b.0));
-                for (x, y) in pairs {
-                    if v.last().is_some_and(|l| x > l.0 + 1e-4) && x < 1.0 - 1e-4 {
-                        v.push((x, y));
-                    }
-                }
-                v.push((1.0, 1.0));
-                v
-            }
-        }
-    }))
-}
-
-fn color_stabilizer(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let Some(host) = ctx.env.host else { return b };
-    let Some(reference) = host.self_at(ctx.params.f("referenceFrame"), ctx.env.effect_index) else { return b };
-    let r = ctx.params.f("sampleSize").max(0.5);
-    let pts = [ctx.params.v2("blackPoint"), ctx.params.v2("midPoint"), ctx.params.v2("whitePoint")];
-    let cur = pts.map(|pt| sample_mean(&b, pt, r));
-    let refv = pts.map(|pt| sample_mean(&reference, pt, r));
-    let mode = ctx.params.e("stabilize");
-    map_px(&mut b, |c| {
-        [0, 1, 2].map(|k| {
-            let v = c[k] as f64;
-            let o = match mode {
-                // Brightness: one sample (black point) — offset each channel.
-                0 => v + refv[0][k] - cur[0][k],
-                // Levels: black and white samples — linear map per channel.
-                1 => {
-                    let (c0, c1, r0, r1) = (cur[0][k], cur[2][k], refv[0][k], refv[2][k]);
-                    if (c1 - c0).abs() < 1e-6 { v + r0 - c0 } else { r0 + (v - c0) * (r1 - r0) / (c1 - c0) }
-                }
-                // Curves: three samples — a curve through them per channel.
-                _ => curve3([cur[0][k], cur[1][k], cur[2][k]], [refv[0][k], refv[1][k], refv[2][k]], v),
-            };
-            o as f32
-        })
-    });
-    b
-}
-
-fn sl(lo: f64, hi: f64, smin: f64, smax: f64) -> ParamUi {
-    slider(lo, hi, smin, smax, 3)
-}
-
-pub fn specs() -> Vec<EffectSpec> {
-    let cc = "Color Correction";
-    let srgb = SPACES.iter().position(|s| s.name == "sRGB").unwrap_or(0) as u32;
-    let lin709 = SPACES.iter().position(|s| s.name == "Linear Rec.709 (sRGB)").unwrap_or(0) as u32;
-    let acescg = SPACES.iter().position(|s| s.name == "ACEScg").unwrap_or(0) as u32;
-    let mut look_opts = vec!["None"];
-    look_opts.extend(looks().iter().map(|(n, _)| *n));
-    vec![
-        spec(
-            "ec.color.ociocdl",
-            "OCIO CDL Transform",
-            cc,
-            vec![
-                p("slopeRed", "Slope Red", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
-                p("slopeGreen", "Slope Green", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
-                p("slopeBlue", "Slope Blue", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
-                p("offsetRed", "Offset Red", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
-                p("offsetGreen", "Offset Green", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
-                p("offsetBlue", "Offset Blue", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
-                p("powerRed", "Power Red", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
-                p("powerGreen", "Power Green", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
-                p("powerBlue", "Power Blue", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
-                p("saturation", "Saturation", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
-                p("style", "Style", Value::Enum(0), popup(&["ASC CDL v1.2", "No Clamp"])),
-                direction(),
-            ],
-            ocio_cdl,
-        ),
-        spec(
-            "ec.color.ociocolorspace",
-            "OCIO Color Space Transform",
-            cc,
-            vec![
-                p("config", "Configuration", Value::Enum(0), popup(CONFIGS)),
-                p("configFile", "Config File (.ocio)", Value::Str(String::new()), crate::file_ui(&["ocio"])),
-                space_param("source", "Source", lin709),
-                p("sourceName", "Source (config name)", Value::Str(String::new()), ParamUi::Text),
-                space_param("destination", "Destination", srgb),
-                p("destinationName", "Destination (config name)", Value::Str(String::new()), ParamUi::Text),
-                direction(),
-            ],
-            ocio_cst,
-        ),
-        spec(
-            "ec.color.ociodisplay",
-            "OCIO Display Transform",
-            cc,
-            vec![
-                p("config", "Configuration", Value::Enum(0), popup(CONFIGS)),
-                p("configFile", "Config File (.ocio)", Value::Str(String::new()), crate::file_ui(&["ocio"])),
-                space_param("source", "Input Color Space", lin709),
-                p("sourceName", "Source (config name)", Value::Str(String::new()), ParamUi::Text),
-                p("display", "Display Device", Value::Enum(0), popup(&DISPLAYS.iter().map(|d| d.0).collect::<Vec<_>>())),
-                p("displayName", "Display (config name)", Value::Str(String::new()), ParamUi::Text),
-                p("view", "View Transform", Value::Enum(0), popup(VIEWS)),
-                p("viewName", "View (config name)", Value::Str(String::new()), ParamUi::Text),
-                direction(),
-            ],
-            ocio_display,
-        ),
-        // `file`: a path to a .cube/.3dl/.csp/.cc/.ccc/.cdl file, or the file's text itself.
-        spec(
-            "ec.color.ociofile",
-            "OCIO File Transform",
-            cc,
-            vec![
-                p("file", "File", Value::Str(String::new()), crate::file_ui(&["cube", "3dl", "csp", "cc", "ccc", "cdl", "spi1d", "spi3d", "spimtx"])),
-                p("cccId", "CCC ID", Value::Str(String::new()), ParamUi::Text),
-                p("interpolation", "Interpolation", Value::Enum(3), popup(&["Nearest", "Linear", "Tetrahedral", "Best"])),
-                direction(),
-            ],
-            ocio_file,
-        ),
-        spec(
-            "ec.color.ociolook",
-            "OCIO Look Transform",
-            cc,
-            vec![
-                p("config", "Configuration", Value::Enum(0), popup(&["Built-in (EffectCraft minimal)"])),
-                space_param("source", "Source", acescg),
-                space_param("destination", "Destination", acescg),
-                p("look", "Look", Value::Enum(0), popup(&look_opts)),
-                p("looks", "Looks", Value::Str(String::new()), ParamUi::Text),
-                direction(),
-            ],
-            ocio_look,
-        ),
-        spec(
-            "ec.color.colorstabilizer",
-            "Color Stabilizer",
-            cc,
-            vec![
-                // The pivot frame (After Effects' Set Frame button stores it).
-                p("referenceFrame", "Reference Frame (s)", num(0.0), slider(-100000.0, 100000.0, 0.0, 60.0, 2)),
-                p("stabilize", "Stabilize", Value::Enum(0), popup(&["Brightness", "Levels", "Curves"])),
-                p("blackPoint", "Black Point", Value::Vec2([0.25, 0.75]), ParamUi::Point),
-                p("midPoint", "Mid Point", Value::Vec2([0.5, 0.5]), ParamUi::Point),
-                p("whitePoint", "White Point", Value::Vec2([0.75, 0.25]), ParamUi::Point),
-                p("sampleSize", "Sample Size", num(5.0), slider(1.0, 100.0, 1.0, 50.0, 0)),
-            ],
-            color_stabilizer,
-        ),
-        spec(
-            "ec.utility.colorprofileconverter",
-            "Color Profile Converter",
-            "Utility",
-            vec![
-                p("inputProfile", "Input Profile", Value::Enum(0), popup(PROFILES)),
-                p("linearizeInputProfile", "Linearize Input Profile", Value::Bool(false), ParamUi::Checkbox),
-                p("outputProfile", "Output Profile", Value::Enum(1), popup(PROFILES)),
-                p("linearizeOutputProfile", "Linearize Output Profile", Value::Bool(false), ParamUi::Checkbox),
-                p("intent", "Intent", Value::Enum(1), popup(&["Perceptual", "Relative Colorimetric", "Saturation", "Absolute Colorimetric"])),
-                // Our built-in profiles share a zero black point and none is scene-referred, so
-                // these two are kept for compatibility and do not change the result.
-                p("useBlackPointCompensation", "Use Black Point Compensation", Value::Bool(true), ParamUi::Checkbox),
-                p("sceneRefCompensation", "Scene-ref. Profile Compensation", Value::Enum(2), popup(&["On", "Off", "Use Project Setting"])),
-            ],
-            profile_converter,
-        ),
-    ]
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{EffectEnv, EffectHost, Image, LayerPixels, run_fx};
-
-    fn close(a: M3, b: M3, tol: f64) {
-        for i in 0..3 {
-            for j in 0..3 {
-                assert!((a[i][j] - b[i][j]).abs() < tol, "{a:?} vs {b:?}");
-            }
-        }
-    }
-
-    #[test]
-    fn aces_matrices_match_published_values() {
-        let ap0 = space_by_name("ACES2065-1").unwrap();
-        let ap1 = space_by_name("ACEScg").unwrap();
-        // Academy S-2014-004 AP0 → AP1.
-        close(
-            matrix(ap0, ap1),
-            [
-                [1.451_439_316_1, -0.236_510_746_9, -0.214_928_569_3],
-                [-0.076_553_773_4, 1.176_229_699_8, -0.099_675_926_4],
-                [0.008_316_148_4, -0.006_032_449_8, 0.997_716_301_4],
-            ],
-            2e-4,
-        );
-        // ACEScg → linear Rec.709 with Bradford adaptation (published ACES config value).
-        let lin = space_by_name("Linear Rec.709 (sRGB)").unwrap();
-        close(matrix(ap1, lin), [[1.705_05, -0.621_79, -0.083_26], [-0.130_26, 1.140_80, -0.010_55], [-0.024_00, -0.128_97, 1.152_97]], 2e-3);
-        // White maps to white.
-        let w = mul_vec(&matrix(ap1, lin), [1.0, 1.0, 1.0]);
-        assert!(w.iter().all(|v| (v - 1.0).abs() < 1e-3), "{w:?}");
-    }
-
-    #[test]
-    fn transfer_functions_round_trip() {
-        for tf in [Tf::Srgb, Tf::Gamma(2.4), Tf::AcesCct, Tf::Pq] {
-            for v in [0.0, 0.001, 0.18, 0.5, 1.0, 4.0] {
-                let r = tf.decode(tf.encode(v));
-                assert!((r - v).abs() < 1e-6 * v.max(1.0), "{tf:?} {v} {r}");
-            }
-        }
-        // ACEScct of 18 % grey (S-2016-001).
-        assert!((Tf::AcesCct.encode(0.18) - 0.413_588).abs() < 1e-5);
-        // PQ: 100 nits (1.0) encodes to ≈ 0.508.
-        assert!((Tf::Pq.encode(1.0) - 0.508).abs() < 1e-3);
-    }
-
-    #[test]
-    fn color_space_transform_effect_round_trips() {
-        let img = Image::filled(4, 4, [0.2, 0.5, 0.7, 1.0]);
-        let srgb = SPACES.iter().position(|s| s.name == "sRGB").unwrap() as u32;
-        let cg = SPACES.iter().position(|s| s.name == "ACEScg").unwrap() as u32;
-        let a = run_fx("ec.color.ociocolorspace", &[("source", Value::Enum(srgb)), ("destination", Value::Enum(cg))], img.clone(), 0.0, EffectEnv::default());
-        assert_ne!(a.img.data, img.data);
-        let b = run_fx("ec.color.ociocolorspace", &[("source", Value::Enum(cg)), ("destination", Value::Enum(srgb))], a.img.clone(), 0.0, EffectEnv::default());
-        let c = run_fx(
-            "ec.color.ociocolorspace",
-            &[("source", Value::Enum(srgb)), ("destination", Value::Enum(cg)), ("direction", Value::Enum(1))],
-            a.img,
-            0.0,
-            EffectEnv::default(),
-        );
-        for (x, y) in b.img.data.iter().zip(&img.data).chain(c.img.data.iter().zip(&img.data)) {
-            assert!((0..4).all(|k| (x[k] - y[k]).abs() < 1e-4), "{x:?} {y:?}");
-        }
-    }
-
-    #[test]
-    fn cdl_math() {
-        let cdl = Cdl { slope: [1.2, 1.0, 0.8], offset: [0.05, 0.0, -0.02], power: [1.1, 1.0, 0.9], sat: 0.8 };
-        let c = [0.3, 0.5, 0.7];
-        // Hand computation of the v1.2 formula.
-        let sop = [(0.3f64 * 1.2 + 0.05).powf(1.1), 0.5, (0.7f64 * 0.8 - 0.02).powf(0.9)];
-        let l = sop[0] * 0.2126 + sop[1] * 0.7152 + sop[2] * 0.0722;
-        let want = sop.map(|v| l + 0.8 * (v - l));
-        let got = cdl.apply(c, true);
-        for k in 0..3 {
-            assert!((got[k] - want[k]).abs() < 1e-12);
-        }
-        let back = cdl.invert(got, true);
-        for k in 0..3 {
-            assert!((back[k] - c[k]).abs() < 1e-9);
-        }
-        // v1.2 clamps, No Clamp keeps negatives.
-        let neg = Cdl { offset: [-0.5; 3], ..Cdl::default() };
-        assert_eq!(neg.apply([0.2; 3], true), [0.0; 3]);
-        assert!((neg.apply([0.2; 3], false)[0] + 0.3).abs() < 1e-12);
-        let img = Image::filled(2, 2, [0.3, 0.5, 0.7, 1.0]);
-        let out = run_fx("ec.color.ociocdl", &[("slopeRed", num(1.2)), ("offsetRed", num(0.05)), ("powerRed", num(1.1))], img, 0.0, EffectEnv::default());
-        let r = (0.3f64 * 1.2 + 0.05).powf(1.1);
-        assert!((out.img.get(0, 0)[0] as f64 - r).abs() < 1e-5);
-    }
-
-    fn identity_lattice(n: usize, f: impl Fn([f32; 3]) -> [f32; 3]) -> Vec<[f32; 3]> {
-        let mut v = vec![];
-        for b in 0..n {
-            for g in 0..n {
-                for r in 0..n {
-                    let s = (n - 1) as f32;
-                    v.push(f([r as f32 / s, g as f32 / s, b as f32 / s]));
-                }
-            }
-        }
-        v
-    }
-
-    /// Sony Imageworks `.spi1d`, `.spi3d` and `.spimtx` (Blender's configs use them, #410), and
-    /// malformed ones rejected without panicking.
-    #[test]
-    fn spi_files_parse() {
-        let spi1d = "Version 1\nFrom 0.0 2.0\nLength 3\nComponents 1\n{\n0.0\n0.25\n1.0\n}\n";
-        let x = parse_file(spi1d, "spi1d").unwrap();
-        let o = x.apply([1.0, 0.5, 2.0], 1, false, "");
-        assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.125).abs() < 1e-6 && (o[2] - 1.0).abs() < 1e-6, "{o:?}");
-        let back = x.apply(o, 1, true, "");
-        assert!((back[0] - 1.0).abs() < 1e-5 && (back[2] - 2.0).abs() < 1e-5, "{back:?}");
-        let three = parse_spi1d("Version 1\nFrom 0 1\nLength 2\nComponents 3\n{\n0 0 0\n1 0.5 2\n}\n").unwrap();
-        assert_eq!(three.d1, vec![[0.0; 3], [1.0, 0.5, 2.0]]);
-        let mut spi3d = String::from("SPILUT 1.0\n3 3\n2 2 2\n");
-        for (r, g, b) in (0..8).map(|i| (i & 1, (i >> 1) & 1, i >> 2)) {
-            spi3d += &format!("{r} {g} {b} {} {} {}\n", r as f32 * 0.5, g, b);
-        }
-        let x = parse_file(&spi3d, "spi3d").unwrap();
-        let o = x.apply([1.0, 0.5, 0.25], 1, false, "");
-        assert!((o[0] - 0.5).abs() < 1e-6 && (o[1] - 0.5).abs() < 1e-6 && (o[2] - 0.25).abs() < 1e-6, "{o:?}");
-        let m = parse_file("2 0 0 6553.5\n0 1 0 0\n0 0 1 0\n", "spimtx").unwrap();
-        let o = m.apply([0.25, 0.5, 1.0], 1, false, "");
-        assert!((o[0] - 0.6).abs() < 1e-6 && o[1] == 0.5 && o[2] == 1.0, "{o:?}");
-        assert!((m.apply(o, 1, true, "")[0] - 0.25).abs() < 1e-6);
-        for bad in [
-            "Version 1\nFrom 0 1\nLength 99999999999\nComponents 1\n{\n0\n}\n",
-            "Version 1\nFrom 1 0\nLength 2\nComponents 1\n{\n0\n1\n}\n",
-            "Version 1\nFrom 0 1\nLength 3\nComponents 1\n{\n0\n1\n}\n",
-            "Version 1\nFrom 0 1\nLength 2\nComponents 2\n{\n0 0\n1 1\n}\n",
-        ] {
-            assert!(parse_spi1d(bad).is_none(), "{bad}");
-        }
-        assert!(parse_spi3d("SPILUT 1.0\n3 3\n4000 4000 4000\n").is_none());
-        assert!(parse_spi3d("SPILUT 1.0\n3 3\n2 2 2\n9 0 0 1 1 1\n").is_none());
-        assert!(parse_spi3d("SPILUT 1.0\n3 3\n2 2 2\n0 0 0 1 1 1\n").is_none(), "incomplete lattice");
-        assert!(parse_spimtx("1 0 0\n0 1 0\n").is_none());
-        assert!(parse_spimtx("NaN 0 0 0 0 1 0 0 0 0 1 0").is_none());
-    }
-
-    #[test]
-    fn lut_files_parse_and_interpolate() {
-        // .cube with a non-linear lattice: trilinear between lattice points.
-        let f = |c: [f32; 3]| [c[0] * c[0], c[1], 1.0 - c[2]];
-        let mut cube = String::from("LUT_3D_SIZE 3\n");
-        for r in identity_lattice(3, f) {
-            cube += &format!("{} {} {}\n", r[0], r[1], r[2]);
-        }
-        let Some(FileXform::Lut { lut, .. }) = parse_file(&cube, "cube") else { panic!() };
-        // Trilinear between 0.5 (0.25) and 1.0 (1.0) at 0.75 → 0.625.
-        let o = lut.apply_interp([0.75, 0.3, 0.2], 1);
-        assert!((o[0] - 0.625).abs() < 1e-6 && (o[1] - 0.3).abs() < 1e-6 && (o[2] - 0.8).abs() < 1e-6, "{o:?}");
-        // Nearest snaps.
-        assert_eq!(lut.apply_interp([0.74, 0.0, 0.0], 0)[0], 0.25);
-        // .3dl (blue fastest, 10-bit integers, mesh line).
-        let mut tdl = String::from("0 511 1023\n");
-        for r in 0..3 {
-            for g in 0..3 {
-                for b in 0..3 {
-                    let v = [r, g, b].map(|i| i as f64 * 511.5);
-                    tdl += &format!("{} {} {}\n", v[0].round(), v[1].round(), (1023.0 - v[2]).round());
-                }
-            }
-        }
-        let Some(FileXform::Lut { lut, .. }) = parse_file(&tdl, "3dl") else { panic!() };
-        let o = lut.apply_interp([0.25, 0.5, 0.25], 1);
-        assert!((o[0] - 0.25).abs() < 2e-3 && (o[1] - 0.5).abs() < 2e-3 && (o[2] - 0.75).abs() < 2e-3, "{o:?}");
-        // .csp with a squaring pre-LUT on red and an identity 2³ lattice.
-        let mut csp = String::from("CSPLUTV100\n3D\n\n3\n0 0.5 1\n0 0.25 1\n2\n0 1\n0 1\n2\n0 1\n0 1\n\n2 2 2\n");
-        for r in identity_lattice(2, |c| c) {
-            csp += &format!("{} {} {}\n", r[0], r[1], r[2]);
-        }
-        let x = parse_file(&csp, "csp").unwrap();
-        let o = x.apply([0.5, 0.4, 0.6], 2, false, "");
-        assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.4).abs() < 1e-6, "{o:?}");
-        let inv = x.apply(o, 2, true, "");
-        assert!((inv[0] - 0.5).abs() < 1e-4, "{inv:?}");
-        // CDL collection: pick by id.
-        let ccc = r#"<ColorCorrectionCollection><ColorCorrection id="a"><SOPNode><Slope>2 2 2</Slope><Offset>0 0 0</Offset><Power>1 1 1</Power></SOPNode></ColorCorrection>
-            <ColorCorrection id='b'><SOPNode><Slope>0.5 0.5 0.5</Slope></SOPNode><SatNode><Saturation>1</Saturation></SatNode></ColorCorrection></ColorCorrectionCollection>"#;
-        let x = parse_file(ccc, "ccc").unwrap();
-        assert!((x.apply([0.4; 3], 2, false, "b")[0] - 0.2).abs() < 1e-6);
-        assert!((x.apply([0.4; 3], 2, false, "a")[0] - 0.8).abs() < 1e-6);
-        assert!((x.apply([0.4; 3], 2, false, "")[0] - 0.8).abs() < 1e-6);
-        // Effect with inline content; inverse of a 3D lattice.
-        let img = Image::filled(2, 2, [0.6, 0.3, 0.2, 1.0]);
-        let out = run_fx("ec.color.ociofile", &[("file", Value::Str(cube.clone()))], img.clone(), 0.0, EffectEnv::default());
-        let back = run_fx("ec.color.ociofile", &[("file", Value::Str(cube)), ("direction", Value::Enum(1))], out.img, 0.0, EffectEnv::default());
-        assert!((back.img.get(0, 0)[0] - 0.6).abs() < 1e-3, "{:?}", back.img.get(0, 0));
-        assert!(parse_file("garbage", "3dl").is_none());
-    }
-
-    #[test]
-    fn display_and_look_transforms() {
-        // Linear 0.18 through the sRGB display / Standard view = sRGB encoding of 0.18.
-        let img = Image::filled(2, 2, [0.18, 0.18, 0.18, 1.0]);
-        let out = run_fx("ec.color.ociodisplay", &[], img.clone(), 0.0, EffectEnv::default());
-        assert!((out.img.get(0, 0)[0] as f64 - Tf::Srgb.encode(0.18)).abs() < 1e-5);
-        let back = run_fx("ec.color.ociodisplay", &[("direction", Value::Enum(1))], out.img, 0.0, EffectEnv::default());
-        assert!((back.img.get(0, 0)[0] - 0.18).abs() < 1e-5);
-        // Tone mapped view keeps highlights below 1.
-        let hot = Image::filled(1, 1, [8.0, 8.0, 8.0, 1.0]);
-        let tm = run_fx("ec.color.ociodisplay", &[("view", Value::Enum(1))], hot, 0.0, EffectEnv::default());
-        assert!(tm.img.get(0, 0)[0] < 1.0);
-        assert!((tonemap_inv(tonemap(3.0)) - 3.0).abs() < 1e-9);
-        // Looks: Warm raises red over blue; its inverse undoes it.
-        let grey = Image::filled(1, 1, [0.18, 0.18, 0.18, 1.0]);
-        let w = run_fx("ec.color.ociolook", &[("looks", Value::Str("Warm".into()))], grey.clone(), 0.0, EffectEnv::default());
-        let px = w.img.get(0, 0);
-        assert!(px[0] > px[2]);
-        let u = run_fx("ec.color.ociolook", &[("looks", Value::Str("-Warm".into()))], w.img, 0.0, EffectEnv::default());
-        assert!((u.img.get(0, 0)[0] - 0.18).abs() < 1e-4 && (u.img.get(0, 0)[2] - 0.18).abs() < 1e-4);
-        assert_eq!(parse_looks("Warm, -Cool, nope").len(), 2);
-    }
-
-    #[test]
-    fn profile_converter_converts_and_round_trips() {
-        let img = Image::filled(2, 2, [0.8, 0.4, 0.1, 1.0]);
-        // sRGB → Rec. 2020 (relative), then back.
-        let a = run_fx(
-            "ec.utility.colorprofileconverter",
-            &[("inputProfile", Value::Enum(1)), ("outputProfile", Value::Enum(3))],
-            img.clone(),
-            0.0,
-            EffectEnv::default(),
-        );
-        assert_ne!(a.img.data, img.data);
-        let b = run_fx(
-            "ec.utility.colorprofileconverter",
-            &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1))],
-            a.img,
-            0.0,
-            EffectEnv::default(),
-        );
-        assert!((0..3).all(|k| (b.img.get(0, 0)[k] - img.get(0, 0)[k]).abs() < 1e-4));
-        // Same profile both sides: identity. Working space defaults to sRGB.
-        let c = run_fx(
-            "ec.utility.colorprofileconverter",
-            &[("inputProfile", Value::Enum(0)), ("outputProfile", Value::Enum(1))],
-            img.clone(),
-            0.0,
-            EffectEnv::default(),
-        );
-        assert_eq!(c.img.data, img.data);
-        // Perceptual pulls out-of-gamut colours inside: saturated Rec.2020 green into sRGB.
-        let g = Image::filled(1, 1, [0.0, 1.0, 0.0, 1.0]);
-        let rel = run_fx(
-            "ec.utility.colorprofileconverter",
-            &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1))],
-            g.clone(),
-            0.0,
-            EffectEnv::default(),
-        );
-        assert!(rel.img.get(0, 0)[0] < 0.0);
-        let per = run_fx(
-            "ec.utility.colorprofileconverter",
-            &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1)), ("intent", Value::Enum(0))],
-            g,
-            0.0,
-            EffectEnv::default(),
-        );
-        assert!(per.img.get(0, 0).iter().all(|v| *v >= -1e-6));
-    }
-
-    struct RefHost(Image);
-    impl EffectHost for RefHost {
-        fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {
-            None
-        }
-        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
-            None
-        }
-        fn self_at(&self, _: f64, _: usize) -> Option<Buf> {
-            Some(Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 })
-        }
-    }
-
-    #[test]
-    fn color_stabilizer_matches_the_reference_frame() {
-        let mk = |k: f32, o: f32| {
-            let mut img = Image::new(40, 40);
-            for y in 0..40 {
-                for x in 0..40 {
-                    let v = (x as f32 / 40.0) * k + o;
-                    img.set(x, y, [v, v * 0.9, v * 0.8, 1.0]);
-                }
-            }
-            img
-        };
-        let reference = mk(1.0, 0.0);
-        let flicker = mk(0.8, 0.1);
-        let host = RefHost(reference.clone());
-        let env = EffectEnv { host: Some(&host), ..Default::default() };
-        let pts = [("blackPoint", Value::Vec2([5.0, 20.0])), ("midPoint", Value::Vec2([20.0, 20.0])), ("whitePoint", Value::Vec2([35.0, 20.0]))];
-        let mut vals: Vec<(&str, Value)> = pts.to_vec();
-        vals.push(("stabilize", Value::Enum(1)));
-        vals.push(("sampleSize", num(1.0)));
-        let out = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, env);
-        for x in [5i64, 20, 35] {
-            let (o, r) = (out.img.get(x, 20), reference.get(x, 20));
-            assert!((o[0] - r[0]).abs() < 0.01, "x {x}: {o:?} vs {r:?}");
-        }
-        // Deterministic, and a no-op without a host.
-        let again = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, env);
-        assert_eq!(out.img.data, again.img.data);
-        let none = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, EffectEnv::default());
-        assert_eq!(none.img.data, flicker.data);
-        // Brightness mode corrects an offset at the black point.
-        let lifted = mk(1.0, 0.1);
-        let mut vals2: Vec<(&str, Value)> = pts.to_vec();
-        vals2.push(("sampleSize", num(1.0)));
-        let b = run_fx("ec.color.colorstabilizer", &vals2, lifted, 0.0, env);
-        assert!((b.img.get(5, 20)[0] - reference.get(5, 20)[0]).abs() < 0.01);
-    }
-}
+mod tests;
diff --git a/crates/effects/src/ocio/cdl.rs b/crates/effects/src/ocio/cdl.rs
new file mode 100644
index 000000000..dba8c68fe
--- /dev/null
+++ b/crates/effects/src/ocio/cdl.rs
@@ -0,0 +1,115 @@
+use super::{ParamUi, slider};
+
+// ---------------------------------------------------------------- ASC CDL
+
+/// An ASC Colour Decision List correction.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Cdl {
+    pub slope: [f64; 3],
+    pub offset: [f64; 3],
+    pub power: [f64; 3],
+    pub sat: f64,
+}
+
+impl Default for Cdl {
+    fn default() -> Self {
+        Cdl { slope: [1.0; 3], offset: [0.0; 3], power: [1.0; 3], sat: 1.0 }
+    }
+}
+
+const LUMA: [f64; 3] = [0.2126, 0.7152, 0.0722];
+
+impl Cdl {
+    /// Forward CDL. `clamp` = the v1.2 style (results clamped to 0..1 after SOP and saturation).
+    pub fn apply(&self, c: [f64; 3], clamp: bool) -> [f64; 3] {
+        let mut o = [0.0; 3];
+        for i in 0..3 {
+            let v = c[i] * self.slope[i] + self.offset[i];
+            o[i] = if clamp {
+                v.clamp(0.0, 1.0).powf(self.power[i])
+            } else if v >= 0.0 {
+                v.powf(self.power[i])
+            } else {
+                v
+            };
+        }
+        let l = o[0] * LUMA[0] + o[1] * LUMA[1] + o[2] * LUMA[2];
+        let o = o.map(|v| l + self.sat * (v - l));
+        if clamp { o.map(|v| v.clamp(0.0, 1.0)) } else { o }
+    }
+    /// Exact inverse of [`Cdl::apply`] (inside the clamped range).
+    pub fn invert(&self, c: [f64; 3], clamp: bool) -> [f64; 3] {
+        let c = if clamp { c.map(|v| v.clamp(0.0, 1.0)) } else { c };
+        let l = c[0] * LUMA[0] + c[1] * LUMA[1] + c[2] * LUMA[2];
+        let s = if self.sat.abs() < 1e-9 { 1e-9 } else { self.sat };
+        let o = c.map(|v| l + (v - l) / s);
+        let mut r = [0.0; 3];
+        for i in 0..3 {
+            let v = if clamp { o[i].clamp(0.0, 1.0) } else { o[i] };
+            let pw = self.power[i].max(1e-9);
+            let u = if v >= 0.0 { v.powf(1.0 / pw) } else { v };
+            let sl = if self.slope[i].abs() < 1e-9 { 1e-9 } else { self.slope[i] };
+            r[i] = (u - self.offset[i]) / sl;
+        }
+        if clamp { r.map(|v| v.clamp(0.0, 1.0)) } else { r }
+    }
+}
+
+fn tag<'a>(xml: &'a str, name: &str) -> Option<&'a str> {
+    let open = xml.find(&format!("<{name}"))?;
+    let gt = open + xml[open..].find('>')?;
+    if xml[..gt].ends_with('/') {
+        return Some("");
+    }
+    let close = xml[gt..].find(&format!("</{name}>"))? + gt;
+    Some(&xml[gt + 1..close])
+}
+
+fn nums3(s: &str) -> Option<[f64; 3]> {
+    let v: Vec<f64> = s.split_whitespace().filter_map(|t| t.parse().ok()).collect();
+    (v.len() >= 3).then(|| [v[0], v[1], v[2]])
+}
+
+fn parse_cc(block: &str) -> Cdl {
+    let mut c = Cdl::default();
+    if let Some(s) = tag(block, "Slope").and_then(nums3) {
+        c.slope = s;
+    }
+    if let Some(s) = tag(block, "Offset").and_then(nums3) {
+        c.offset = s;
+    }
+    if let Some(s) = tag(block, "Power").and_then(nums3) {
+        c.power = s;
+    }
+    if let Some(s) = tag(block, "Saturation").and_then(|t| t.trim().parse().ok()) {
+        c.sat = s;
+    }
+    c
+}
+
+/// Parse ASC CDL XML (`.cc`, `.ccc`, `.cdl`): every `<ColorCorrection>` with its `id`.
+pub fn parse_cdl_xml(xml: &str) -> Vec<(String, Cdl)> {
+    let mut out = vec![];
+    let mut rest = xml;
+    while let Some(i) = rest.find("<ColorCorrection") {
+        let after = &rest[i..];
+        let head_end = after.find('>').unwrap_or(after.len());
+        let head = &after[..head_end];
+        let id = head
+            .find("id=")
+            .and_then(|k| {
+                let q = head[k + 3..].chars().next()?;
+                let s = &head[k + 4..];
+                s.find(q).map(|e| s[..e].to_string())
+            })
+            .unwrap_or_default();
+        let end = after.find("</ColorCorrection>").map(|e| e + "</ColorCorrection>".len()).unwrap_or(after.len());
+        out.push((id, parse_cc(&after[..end])));
+        rest = &after[end..];
+    }
+    out
+}
+
+pub(super) fn sl(lo: f64, hi: f64, smin: f64, smax: f64) -> ParamUi {
+    slider(lo, hi, smin, smax, 3)
+}
diff --git a/crates/effects/src/ocio/effects.rs b/crates/effects/src/ocio/effects.rs
new file mode 100644
index 000000000..5df24096d
--- /dev/null
+++ b/crates/effects/src/ocio/effects.rs
@@ -0,0 +1,467 @@
+use super::cdl::Cdl;
+use super::lut::load_file;
+use super::space::{ACES_CCT, ACES_CG, ACES2065_1, D65, IDENTITY, P3, REC709, REC2020, SPACES, Space, Tf, Xform, matrix, sp, space_names};
+use super::{Buf, ColorSpace, EffectCtx, EffectSpec, IntoParallelRefMutIterator, ParallelIterator, Value, invert, mul, mul_vec, p, popup, unpremul};
+
+// ---------------------------------------------------------------- displays, views and looks
+
+/// Displays of the built-in config: (name, display primaries/white, encoding).
+pub const DISPLAYS: &[(&str, [[f64; 2]; 3], Tf)] =
+    &[("sRGB", REC709, Tf::Srgb), ("Rec.1886 Rec.709", REC709, Tf::Gamma(2.4)), ("Display P3", P3, Tf::Srgb), ("Rec.2100-PQ", REC2020, Tf::Pq)];
+
+pub const VIEWS: &[&str] = &["Standard", "Tone Mapped", "Raw"];
+
+/// Configuration popup: the built-in config, or a custom `.ocio` file (Config File: a path or
+/// the config's text; spaces chosen by name, see [`crate::ocio_config`]).
+pub const CONFIGS: &[&str] = &["Built-in (EffectCraft minimal)", "Custom (.ocio file)"];
+
+/// Built-in looks: CDLs applied in ACEScct.
+pub fn looks() -> Vec<(&'static str, Cdl)> {
+    let grey = 0.413_588_402_492_442_1; // ACEScct of 0.18
+    let c = |slope: [f64; 3], offset: [f64; 3], sat: f64| Cdl { slope, offset, power: [1.0; 3], sat };
+    vec![
+        ("Warm", c([1.04, 1.0, 0.94], [0.0; 3], 1.0)),
+        ("Cool", c([0.95, 1.0, 1.06], [0.0; 3], 1.0)),
+        ("High Contrast", c([1.25; 3], [grey * (1.0 - 1.25); 3], 1.0)),
+        ("Low Contrast", c([0.8; 3], [grey * (1.0 - 0.8); 3], 1.0)),
+        ("Desaturated", c([1.0; 3], [0.0; 3], 0.6)),
+        ("Vivid", c([1.0; 3], [0.0; 3], 1.3)),
+    ]
+}
+
+/// Extended Reinhard roll-off (white point 16): maps 0..∞ into 0..1, ≈ identity near 0.
+pub(super) fn tonemap(v: f64) -> f64 {
+    let w2 = 256.0;
+    if v <= 0.0 { v } else { v * (1.0 + v / w2) / (1.0 + v) }
+}
+
+pub(super) fn tonemap_inv(y: f64) -> f64 {
+    if y <= 0.0 {
+        return y;
+    }
+    // Solve v² / w² + v (1 − y) − y = 0.
+    let (a, b, c) = (1.0 / 256.0, 1.0 - y, -y);
+    (-b + (b * b - 4.0 * a * c).sqrt()) / (2.0 * a)
+}
+
+/// Display transform of an input-space colour (`inverse`: display code values → input space).
+pub fn display_xform(input: &Space, display: usize, view: usize, inverse: bool) -> impl Fn([f32; 3]) -> [f32; 3] + Sync {
+    let (_, prims, tf) = DISPLAYS[display.min(DISPLAYS.len() - 1)];
+    let disp = Space { name: "display", prims: Some((prims, D65)), tf: Tf::Linear, raw: false };
+    let raw = view == 2 || input.raw;
+    let m_in = Xform::new(&Space { tf: Tf::Linear, ..*input }, &disp);
+    let m_out = Xform::new(&disp, &Space { tf: Tf::Linear, ..*input });
+    let in_tf = input.tf;
+    move |c: [f32; 3]| {
+        if raw {
+            return c;
+        }
+        if !inverse {
+            let lin = c.map(|v| in_tf.decode(v as f64) as f32);
+            let d = m_in.apply(lin);
+            d.map(|v| {
+                let v = v as f64;
+                let v = if view == 1 { tonemap(v) } else { v };
+                tf.encode(v) as f32
+            })
+        } else {
+            let d = c.map(|v| {
+                let l = tf.decode(v as f64);
+                (if view == 1 { tonemap_inv(l) } else { l }) as f32
+            });
+            m_out.apply(d).map(|v| in_tf.encode(v as f64) as f32)
+        }
+    }
+}
+
+// ---------------------------------------------------------------- effects
+
+pub(super) fn spec(id: &'static str, name: &'static str, cat: &'static str, params: Vec<crate::ParamSpec>, render: crate::RenderFn) -> EffectSpec {
+    EffectSpec { id, name, category: cat, params, render, gpu: false, float: true }
+}
+
+pub(super) fn space_param(id: &'static str, name: &'static str, default: u32) -> crate::ParamSpec {
+    p(id, name, Value::Enum(default), popup(&space_names()))
+}
+
+pub(super) fn direction() -> crate::ParamSpec {
+    p("direction", "Direction", Value::Enum(0), popup(&["Forward", "Inverse"]))
+}
+
+fn map_px(b: &mut Buf, f: impl Fn([f32; 3]) -> [f32; 3] + Sync) {
+    b.img.data.par_iter_mut().for_each(|px| {
+        let (c, a) = unpremul(*px);
+        if a <= 0.0 {
+            return;
+        }
+        let o = f(c);
+        *px = [o[0] * a, o[1] * a, o[2] * a, a];
+    });
+}
+
+pub(super) fn space_at(i: u32) -> &'static Space {
+    &SPACES[(i as usize).min(SPACES.len() - 1)]
+}
+
+/// The effects that take Configuration ▸ Custom (a `.ocio` file).
+pub(crate) const CUSTOM_CONFIG_FX: [&str; 2] = ["ec.color.ociocolorspace", "ec.color.ociodisplay"];
+
+/// Effect `id`'s transform under Configuration ▸ Custom: the config's conversion from the source
+/// space to the destination space (Color Space Transform) or through a display's view (Display
+/// Transform), see [`crate::ocio_config`]. `Ok(None)` with the built-in configuration; an error
+/// (the pixels pass through) when the config can't be read or has no such colour space.
+pub(super) fn custom_xf(id: &str, pr: &crate::Params) -> Result<Option<crate::ocio_config::Xf>, String> {
+    use crate::ocio_config::Xf;
+    if !CUSTOM_CONFIG_FX.contains(&id) || pr.e("config") != 1 {
+        return Ok(None);
+    }
+    let cfg = crate::ocio_config::load_config(pr.s("configFile")).map_err(|e| format!("Can't read the OCIO config: {e}"))?;
+    // A space by its typed name, else by the built-in popup's name.
+    let space = |name: &str, popup: u32| {
+        let name = if name.trim().is_empty() { space_at(popup).name } else { name.trim() };
+        cfg.space(name).ok_or_else(|| format!("The OCIO config has no color space `{name}`"))
+    };
+    let a = space(pr.s("sourceName"), pr.e("source"))?;
+    let inverse = pr.e("direction") == 1;
+    if id == "ec.color.ociodisplay" {
+        let (dn, vn) = display_view_names(pr);
+        let xf = cfg.display_path(a, dn, vn);
+        return Ok(Some(if inverse { Xf::Inverse(Box::new(xf)) } else { xf }));
+    }
+    let z = space(pr.s("destinationName"), pr.e("destination"))?;
+    // Inverse: the conversion the other way (OCIO's inverse ColorSpaceTransform).
+    Ok(Some(if inverse { cfg.path(z, a) } else { cfg.path(a, z) }))
+}
+
+/// The display and view a Display Transform names: the typed names, else the popups'.
+fn display_view_names(pr: &crate::Params) -> (&str, &str) {
+    let display = DISPLAYS.get(pr.e("display") as usize).map_or("", |d| d.0);
+    let view = VIEWS.get(pr.e("view") as usize).copied().unwrap_or("");
+    let typed = |k: &str, popup| if pr.s(k).trim().is_empty() { popup } else { pr.s(k).trim() };
+    (typed("displayName", display), typed("viewName", view))
+}
+
+/// Effect Controls' warning for effect `id`: a custom OCIO configuration that can't be read, has
+/// no such colour space, display or view, or uses transforms EffectCraft can't apply (colours
+/// pass through those steps, #410). `None` when the effect renders as asked.
+pub fn warning(id: &str, pr: &crate::Params) -> Option<String> {
+    let xf = match custom_xf(id, pr) {
+        Ok(x) => x?,
+        Err(e) => return Some(format!("{e}: the colors pass through.")),
+    };
+    let mut notes = vec![];
+    if id == "ec.color.ociodisplay"
+        && let Ok(cfg) = crate::ocio_config::load_config(pr.s("configFile"))
+    {
+        let (dn, vn) = display_view_names(pr);
+        if let Some((d, v)) = cfg.view(dn, vn)
+            && (!d.eq_ignore_ascii_case(dn) || !v.name.eq_ignore_ascii_case(vn))
+        {
+            notes.push(format!("The OCIO config has no display `{dn}` with a view `{vn}`: showing {d} / {}.", v.name));
+        }
+    }
+    let missing = xf.unsupported_list();
+    if !missing.is_empty() {
+        notes.push(format!("Not supported, the colors pass through: {}.", missing.join(", ")));
+    }
+    (!notes.is_empty()).then(|| notes.join(" "))
+}
+
+/// Configuration ▸ Custom: render through the config's transform. `false` with the built-in
+/// configuration (the caller renders it).
+fn custom_render(id: &str, ctx: &EffectCtx, b: &mut Buf) -> bool {
+    match custom_xf(id, ctx.params) {
+        Ok(None) => false,
+        Ok(Some(xf)) => {
+            map_px(b, |c| xf.apply(c.map(|v| v as f64), false).map(|v| v as f32));
+            true
+        }
+        // A config that can't be read, or an unknown space: the pixels pass through.
+        Err(_) => true,
+    }
+}
+
+pub(super) fn ocio_cst(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    if custom_render("ec.color.ociocolorspace", ctx, &mut b) {
+        return b;
+    }
+    let (a, z) = (space_at(ctx.params.e("source")), space_at(ctx.params.e("destination")));
+    let (a, z) = if ctx.params.e("direction") == 1 { (z, a) } else { (a, z) };
+    if a.name == z.name {
+        return b;
+    }
+    let x = Xform::new(a, z);
+    map_px(&mut b, |c| x.apply(c));
+    b
+}
+
+pub(super) fn cdl_from_params(pr: &crate::Params) -> Cdl {
+    Cdl {
+        slope: [pr.f("slopeRed"), pr.f("slopeGreen"), pr.f("slopeBlue")],
+        offset: [pr.f("offsetRed"), pr.f("offsetGreen"), pr.f("offsetBlue")],
+        power: [pr.f("powerRed").max(0.0), pr.f("powerGreen").max(0.0), pr.f("powerBlue").max(0.0)],
+        sat: pr.f("saturation").max(0.0),
+    }
+}
+
+pub(super) fn ocio_cdl(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let cdl = cdl_from_params(ctx.params);
+    if cdl == Cdl::default() {
+        return b;
+    }
+    let clamp = ctx.params.e("style") == 0;
+    let inv = ctx.params.e("direction") == 1;
+    map_px(&mut b, |c| {
+        let c = c.map(|v| v as f64);
+        let o = if inv { cdl.invert(c, clamp) } else { cdl.apply(c, clamp) };
+        o.map(|v| v as f32)
+    });
+    b
+}
+
+pub(super) fn ocio_display(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    if custom_render("ec.color.ociodisplay", ctx, &mut b) {
+        return b;
+    }
+    let input = space_at(ctx.params.e("source"));
+    let f = display_xform(input, ctx.params.e("display") as usize, ctx.params.e("view") as usize, ctx.params.e("direction") == 1);
+    map_px(&mut b, f);
+    b
+}
+
+pub(super) fn ocio_file(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let Some(x) = load_file(ctx.params.s("file")) else { return b };
+    let interp = match ctx.params.e("interpolation") {
+        0 => 0,
+        1 => 1,
+        _ => 2,
+    };
+    let inv = ctx.params.e("direction") == 1;
+    let id = ctx.params.s("cccId").to_string();
+    map_px(&mut b, |c| x.apply(c, interp, inv, &id));
+    b
+}
+
+/// Parse a looks string: comma/space separated names, `-Name` = inverse.
+pub fn parse_looks(s: &str) -> Vec<(Cdl, bool)> {
+    let all = looks();
+    s.split([',', ':'])
+        .map(str::trim)
+        .filter(|t| !t.is_empty())
+        .filter_map(|t| {
+            let (inv, n) = match t.strip_prefix('-') {
+                Some(r) => (true, r.trim()),
+                None => (false, t.trim_start_matches('+').trim()),
+            };
+            all.iter().find(|(name, _)| name.eq_ignore_ascii_case(n)).map(|(_, c)| (*c, inv))
+        })
+        .collect()
+}
+
+pub(super) fn ocio_look(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let mut list = parse_looks(ctx.params.s("looks"));
+    let pick = ctx.params.e("look");
+    if pick > 0
+        && let Some((_, c)) = looks().get(pick as usize - 1)
+    {
+        list.insert(0, (*c, false));
+    }
+    if list.is_empty() {
+        return b;
+    }
+    let (src, dst) = (space_at(ctx.params.e("source")), space_at(ctx.params.e("destination")));
+    let inv = ctx.params.e("direction") == 1;
+    let cct = &ACES_CCT;
+    let (a, z) = if inv { (dst, src) } else { (src, dst) };
+    let to_p = Xform::new(a, cct);
+    let from_p = Xform::new(cct, z);
+    if inv {
+        list.reverse();
+    }
+    map_px(&mut b, |c| {
+        let mut v = to_p.apply(c).map(|x| x as f64);
+        for (cdl, li) in &list {
+            v = if *li != inv { cdl.invert(v, false) } else { cdl.apply(v, false) };
+        }
+        from_p.apply(v.map(|x| x as f32))
+    });
+    b
+}
+
+// ---- Color Profile Converter (Utility)
+
+pub const PROFILES: &[&str] = &["Project Working Space", "sRGB IEC61966-2.1", "HDTV (Rec. 709)", "Rec. 2020", "Display P3", "ACEScg", "ACES2065-1"];
+
+pub(super) fn profile(ctx: &EffectCtx, i: u32) -> (Space, bool) {
+    let ws = |cs: ColorSpace| match cs {
+        ColorSpace::Srgb => sp("sRGB", REC709, D65, Tf::Srgb),
+        ColorSpace::Rec709 => sp("Rec.709", REC709, D65, Tf::Gamma(2.4)),
+        ColorSpace::Rec2020 => sp("Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
+        ColorSpace::DisplayP3 => sp("Display P3", P3, D65, Tf::Srgb),
+        ColorSpace::AcesCg => ACES_CG,
+        ColorSpace::Aces2065 => ACES2065_1,
+        // HDR encodings are output spaces, never a working space.
+        ColorSpace::Rec2100Pq | ColorSpace::Rec2100Hlg => sp("Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
+    };
+    match i {
+        0 => (ws(ctx.env.working_space.unwrap_or(ColorSpace::Srgb)), ctx.env.working_linear),
+        1 => (ws(ColorSpace::Srgb), false),
+        2 => (ws(ColorSpace::Rec709), false),
+        3 => (ws(ColorSpace::Rec2020), false),
+        4 => (ws(ColorSpace::DisplayP3), false),
+        5 => (ACES_CG, true),
+        _ => (ACES2065_1, true),
+    }
+}
+
+/// Gamut compression for the perceptual intent: pull out-of-gamut (negative) colours toward
+/// their luminance just enough to bring every channel to ≥ 0, rolling off smoothly.
+fn compress_gamut(c: [f64; 3], luma: [f64; 3]) -> [f64; 3] {
+    let l = c[0] * luma[0] + c[1] * luma[1] + c[2] * luma[2];
+    if l <= 0.0 {
+        return c.map(|v| v.max(0.0));
+    }
+    let mn = c.iter().cloned().fold(f64::INFINITY, f64::min);
+    if mn >= 0.0 {
+        return c;
+    }
+    // Fraction of the way toward grey that reaches zero on the most negative channel.
+    let t = (l / (l - mn)).clamp(0.0, 1.0);
+    c.map(|v| l + (v - l) * t)
+}
+
+pub(super) fn profile_converter(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let (inp, in_lin_default) = profile(ctx, ctx.params.e("inputProfile"));
+    let (out, out_lin_default) = profile(ctx, ctx.params.e("outputProfile"));
+    let in_lin = ctx.params.b("linearizeInputProfile") || in_lin_default && ctx.params.e("inputProfile") == 0;
+    let out_lin = ctx.params.b("linearizeOutputProfile") || out_lin_default && ctx.params.e("outputProfile") == 0;
+    let intent = ctx.params.e("intent");
+    let dec = if in_lin { Tf::Linear } else { inp.tf };
+    let enc = if out_lin { Tf::Linear } else { out.tf };
+    // Absolute colorimetric keeps the source white (no adaptation); the others adapt.
+    let m = if intent == 3 { mul(&invert(&out.to_ref(false)), &inp.to_ref(false)) } else { matrix(&inp, &out) };
+    let identity = dec == enc && (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-9));
+    if identity {
+        return b;
+    }
+    let out_luma = out.to_ref(true)[1];
+    map_px(&mut b, |c| {
+        let l = c.map(|v| dec.decode(v as f64));
+        let mut o = mul_vec(&m, l);
+        match intent {
+            0 => o = compress_gamut(o, out_luma),
+            2 => o = o.map(|v| v.max(0.0)),
+            _ => {}
+        }
+        o.map(|v| enc.encode(v) as f32)
+    });
+    b
+}
+
+// ---- Color Stabilizer
+
+/// Mean straight colour of a square (half-size `r` layer pixels) around layer point `pt`.
+fn sample_mean(b: &Buf, pt: [f64; 2], r: f64) -> [f64; 3] {
+    let (cx, cy) = b.to_px(pt);
+    let rr = (r * b.scale).max(0.5);
+    let (x0, x1) = ((cx - rr).floor().max(0.0) as i64, ((cx + rr).ceil() as i64).min(b.img.width as i64));
+    let (y0, y1) = ((cy - rr).floor().max(0.0) as i64, ((cy + rr).ceil() as i64).min(b.img.height as i64));
+    let mut acc = [0.0f64; 4];
+    for y in y0..y1 {
+        for x in x0..x1 {
+            let p = b.img.get(x, y);
+            for k in 0..4 {
+                acc[k] += p[k] as f64;
+            }
+        }
+    }
+    if acc[3] <= 1e-9 {
+        return [0.0; 3];
+    }
+    [acc[0] / acc[3], acc[1] / acc[3], acc[2] / acc[3]]
+}
+
+/// Monotone piecewise-quadratic curve through (0,0), three samples and (1,1) (linear between
+/// them is enough for a stabiliser and stays monotone).
+fn curve3(xs: [f64; 3], ys: [f64; 3], v: f64) -> f64 {
+    let mut pts = vec![(0.0, 0.0)];
+    let mut pairs: Vec<(f64, f64)> = xs.iter().cloned().zip(ys.iter().cloned()).collect();
+    pairs.sort_by(|a, b| a.0.total_cmp(&b.0));
+    for (x, y) in pairs {
+        if pts.last().is_some_and(|l| x > l.0 + 1e-4) && x < 1.0 - 1e-4 {
+            pts.push((x, y));
+        }
+    }
+    pts.push((1.0, 1.0));
+    let i = pts.partition_point(|p| p.0 < v).clamp(1, pts.len() - 1);
+    let (a, c) = (pts[i - 1], pts[i]);
+    a.1 + (c.1 - a.1) * (v - a.0) / (c.0 - a.0).max(1e-9)
+}
+
+/// Color Stabilizer's correction of buffer `b` as one piecewise-linear map per channel (points
+/// with increasing x; the end segments extend), the same maps `color_stabilizer` applies.
+/// `None` without a host or reference frame (the layer passes through). (The GPU effect.)
+pub fn color_stabilizer_maps(ctx: &EffectCtx, b: &Buf) -> Option<[Vec<(f64, f64)>; 3]> {
+    let reference = ctx.env.host?.self_at(ctx.params.f("referenceFrame"), ctx.env.effect_index)?;
+    let r = ctx.params.f("sampleSize").max(0.5);
+    let pts = [ctx.params.v2("blackPoint"), ctx.params.v2("midPoint"), ctx.params.v2("whitePoint")];
+    let cur = pts.map(|pt| sample_mean(b, pt, r));
+    let refv = pts.map(|pt| sample_mean(&reference, pt, r));
+    let mode = ctx.params.e("stabilize");
+    Some([0, 1, 2].map(|k| {
+        let offset = |c0: f64, r0: f64| vec![(0.0, r0 - c0), (1.0, 1.0 + r0 - c0)];
+        match mode {
+            0 => offset(cur[0][k], refv[0][k]),
+            1 => {
+                let (c0, c1, r0, r1) = (cur[0][k], cur[2][k], refv[0][k], refv[2][k]);
+                if (c1 - c0).abs() < 1e-6 {
+                    offset(c0, r0)
+                } else if c0 < c1 {
+                    vec![(c0, r0), (c1, r1)]
+                } else {
+                    vec![(c1, r1), (c0, r0)]
+                }
+            }
+            _ => {
+                let mut v = vec![(0.0, 0.0)];
+                let mut pairs: Vec<(f64, f64)> = (0..3).map(|i| (cur[i][k], refv[i][k])).collect();
+                pairs.sort_by(|a, b| a.0.total_cmp(&b.0));
+                for (x, y) in pairs {
+                    if v.last().is_some_and(|l| x > l.0 + 1e-4) && x < 1.0 - 1e-4 {
+                        v.push((x, y));
+                    }
+                }
+                v.push((1.0, 1.0));
+                v
+            }
+        }
+    }))
+}
+
+pub(super) fn color_stabilizer(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let Some(host) = ctx.env.host else { return b };
+    let Some(reference) = host.self_at(ctx.params.f("referenceFrame"), ctx.env.effect_index) else { return b };
+    let r = ctx.params.f("sampleSize").max(0.5);
+    let pts = [ctx.params.v2("blackPoint"), ctx.params.v2("midPoint"), ctx.params.v2("whitePoint")];
+    let cur = pts.map(|pt| sample_mean(&b, pt, r));
+    let refv = pts.map(|pt| sample_mean(&reference, pt, r));
+    let mode = ctx.params.e("stabilize");
+    map_px(&mut b, |c| {
+        [0, 1, 2].map(|k| {
+            let v = c[k] as f64;
+            let o = match mode {
+                // Brightness: one sample (black point) — offset each channel.
+                0 => v + refv[0][k] - cur[0][k],
+                // Levels: black and white samples — linear map per channel.
+                1 => {
+                    let (c0, c1, r0, r1) = (cur[0][k], cur[2][k], refv[0][k], refv[2][k]);
+                    if (c1 - c0).abs() < 1e-6 { v + r0 - c0 } else { r0 + (v - c0) * (r1 - r0) / (c1 - c0) }
+                }
+                // Curves: three samples — a curve through them per channel.
+                _ => curve3([cur[0][k], cur[1][k], cur[2][k]], [refv[0][k], refv[1][k], refv[2][k]], v),
+            };
+            o as f32
+        })
+    });
+    b
+}
diff --git a/crates/effects/src/ocio/lut.rs b/crates/effects/src/ocio/lut.rs
new file mode 100644
index 000000000..8a6481eb6
--- /dev/null
+++ b/crates/effects/src/ocio/lut.rs
@@ -0,0 +1,331 @@
+use super::cdl::{Cdl, parse_cdl_xml};
+use super::{Arc, HashMap, Lut, Mutex, OnceLock, parse_cube};
+
+// ---------------------------------------------------------------- LUT files
+
+/// A loaded transform file.
+#[derive(Clone, Debug)]
+pub enum FileXform {
+    /// A lattice/1D LUT with an optional per-channel piecewise-linear shaper (cineSpace pre-LUT).
+    Lut { lut: Lut, shaper: Option<[Vec<(f32, f32)>; 3]> },
+    /// CDL corrections by id (in file order).
+    Cdl(Vec<(String, Cdl)>),
+    /// A matrix with offset (Sony Imageworks `.spimtx`), as a MatrixTransform's.
+    Matrix { m: [f64; 16], offset: [f64; 4] },
+}
+
+/// Parse a Sony Imageworks `.spimtx` matrix: three rows of four numbers, three matrix columns
+/// and an offset in 16-bit code values (÷ 65535).
+pub fn parse_spimtx(text: &str) -> Option<FileXform> {
+    let v: Vec<f64> = text.split_whitespace().map(|t| t.parse().ok()).collect::<Option<_>>()?;
+    if v.len() != 12 || v.iter().any(|x| !x.is_finite()) {
+        return None;
+    }
+    let mut m = [0.0; 16];
+    let mut offset = [0.0; 4];
+    for (r, row) in v.as_chunks::<4>().0.iter().enumerate() {
+        m[r * 4..r * 4 + 3].copy_from_slice(&row[..3]);
+        offset[r] = row[3] / 65535.0;
+    }
+    m[15] = 1.0;
+    Some(FileXform::Matrix { m, offset })
+}
+
+/// Parse a Sony Imageworks `.spi1d` 1D LUT: `From <min> <max>`, `Length <n>`, `Components
+/// <1 | 3>`, then `{` the values `}`.
+pub fn parse_spi1d(text: &str) -> Option<Lut> {
+    let (mut from, mut len, mut comps) = ([0.0f32, 1.0], 0usize, 1usize);
+    let mut values: Vec<f32> = vec![];
+    let mut body = false;
+    for line in text.lines().map(str::trim).filter(|l| !l.is_empty()) {
+        if body {
+            if line.starts_with('}') {
+                break;
+            }
+            for t in line.split_whitespace() {
+                values.push(t.parse().ok()?);
+            }
+            continue;
+        }
+        let mut t = line.split_whitespace();
+        match t.next()? {
+            "{" => body = true,
+            "From" => from = [t.next()?.parse().ok()?, t.next()?.parse().ok()?],
+            "Length" => len = t.next()?.parse().ok()?,
+            "Components" => comps = t.next()?.parse().ok()?,
+            _ => {}
+        }
+    }
+    // A 1D table is interpolated by index, so cap it like the lattices (2²⁴ entries).
+    if !(2..=1 << 24).contains(&len)
+        || !matches!(comps, 1 | 3)
+        || values.len() != len.checked_mul(comps)?
+        || from[1] <= from[0]
+        || from.iter().any(|v| !v.is_finite())
+    {
+        return None;
+    }
+    let d1 = values.chunks_exact(comps).map(|c| if comps == 3 { [c[0], c[1], c[2]] } else { [c[0]; 3] }).collect();
+    Some(Lut { n1: len, d1, n3: 0, d3: vec![], dmin: [from[0]; 3], dmax: [from[1]; 3] })
+}
+
+/// Parse a Sony Imageworks `.spi3d` lattice: `SPILUT 1.0`, `3 3`, the sizes, then one
+/// `r g b  R G B` line per lattice point (indices, then the colour).
+pub fn parse_spi3d(text: &str) -> Option<Lut> {
+    let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
+    if !lines.next()?.starts_with("SPILUT") {
+        return None;
+    }
+    lines.next()?;
+    let size: Vec<usize> = lines.next()?.split_whitespace().map(|t| t.parse().ok()).collect::<Option<_>>()?;
+    let n = *size.first()?;
+    if size.len() != 3 || size.iter().any(|s| *s != n) || !(2..=129).contains(&n) {
+        return None;
+    }
+    let mut d3 = vec![[0.0f32; 3]; n * n * n];
+    let mut seen = 0usize;
+    for line in lines {
+        let v: Vec<&str> = line.split_whitespace().collect();
+        let [r, g, b, cr, cg, cb] = v.as_slice() else { return None };
+        let (r, g, b): (usize, usize, usize) = (r.parse().ok()?, g.parse().ok()?, b.parse().ok()?);
+        if r >= n || g >= n || b >= n {
+            return None;
+        }
+        // Our lattice is red fastest.
+        *d3.get_mut(r + g * n + b * n * n)? = [cr.parse().ok()?, cg.parse().ok()?, cb.parse().ok()?];
+        seen += 1;
+    }
+    (seen == n * n * n).then_some(Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] })
+}
+
+/// Parse an Autodesk `.3dl` lattice (integers, blue fastest; an optional input-mesh line).
+pub fn parse_3dl(text: &str) -> Option<Lut> {
+    let mut mesh: Option<Vec<f64>> = None;
+    let mut rows: Vec<[f64; 3]> = vec![];
+    let mut out_bits: Option<u32> = None;
+    for line in text.lines() {
+        let l = line.trim();
+        if l.is_empty() || l.starts_with('#') || l.starts_with('<') {
+            continue;
+        }
+        if l.starts_with(|c: char| c.is_ascii_alphabetic()) {
+            // "Mesh <in bits> <out bits>" (Lustre header); other keywords are ignored.
+            let t: Vec<&str> = l.split_whitespace().collect();
+            if t[0].eq_ignore_ascii_case("mesh") && t.len() >= 3 {
+                out_bits = t[2].parse().ok();
+            }
+            continue;
+        }
+        let v: Vec<f64> = l.split_whitespace().filter_map(|t| t.parse().ok()).collect();
+        if v.len() > 3 && mesh.is_none() && rows.is_empty() {
+            mesh = Some(v);
+        } else if v.len() == 3 {
+            rows.push([v[0], v[1], v[2]]);
+        } else {
+            return None;
+        }
+    }
+    let is_cube = |k: usize| {
+        let n = (k as f64).cbrt().round() as usize;
+        n * n * n == k
+    };
+    // A 3-entry input mesh (3³ lattice) looks like a data row: tell them apart by the count.
+    if mesh.is_none() && !is_cube(rows.len()) && rows.len() == 28 {
+        mesh = Some(rows.remove(0).to_vec());
+    }
+    let n = match &mesh {
+        Some(m) => m.len(),
+        None => (rows.len() as f64).cbrt().round() as usize,
+    };
+    if n < 2 || rows.len() != n * n * n {
+        return None;
+    }
+    let maxv = rows.iter().flat_map(|r| r.iter()).fold(0.0f64, |m, &v| m.max(v));
+    let out_max = match out_bits {
+        Some(b) if b > 0 && b < 32 => (1u64 << b) as f64 - 1.0,
+        _ => [255.0, 1023.0, 4095.0, 65535.0].into_iter().find(|&m| maxv <= m).unwrap_or(maxv.max(1.0)),
+    };
+    // .3dl rows: red slowest, blue fastest. Our lattice is red fastest.
+    let mut d3 = vec![[0.0f32; 3]; n * n * n];
+    for (k, r) in rows.iter().enumerate() {
+        let (ri, gi, bi) = (k / (n * n), (k / n) % n, k % n);
+        d3[ri + gi * n + bi * n * n] = r.map(|v| (v / out_max) as f32);
+    }
+    Some(Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] })
+}
+
+/// Parse a cineSpace `.csp` LUT (1D or 3D, with its three pre-LUT shapers).
+pub fn parse_csp(text: &str) -> Option<(Lut, [Vec<(f32, f32)>; 3])> {
+    let mut lines = text.lines().map(str::trim).filter(|l| !l.is_empty());
+    if !lines.next()?.starts_with("CSPLUTV100") {
+        return None;
+    }
+    let kind = lines.next()?;
+    let mut lines = lines.peekable();
+    if lines.peek().is_some_and(|l| l.starts_with("BEGIN METADATA")) {
+        for l in lines.by_ref() {
+            if l.starts_with("END METADATA") {
+                break;
+            }
+        }
+    }
+    let nums = |l: &str| -> Option<Vec<f32>> { l.split_whitespace().map(|t| t.parse().ok()).collect() };
+    let mut shaper: [Vec<(f32, f32)>; 3] = Default::default();
+    for ch in shaper.iter_mut() {
+        let n: usize = lines.next()?.parse().ok()?;
+        let ins = nums(lines.next()?)?;
+        let outs = nums(lines.next()?)?;
+        if ins.len() != n || outs.len() != n || n < 2 {
+            return None;
+        }
+        *ch = ins.into_iter().zip(outs).collect();
+    }
+    if kind.starts_with("3D") {
+        let sz = nums(lines.next()?)?;
+        if sz.len() != 3 || sz[0] != sz[1] || sz[1] != sz[2] {
+            return None;
+        }
+        let n = sz[0] as usize;
+        let mut d3 = Vec::with_capacity(n * n * n);
+        for _ in 0..n * n * n {
+            let v = nums(lines.next()?)?;
+            if v.len() != 3 {
+                return None;
+            }
+            d3.push([v[0], v[1], v[2]]);
+        }
+        (n >= 2).then_some((Lut { n1: 0, d1: vec![], n3: n, d3, dmin: [0.0; 3], dmax: [1.0; 3] }, shaper))
+    } else {
+        let n: usize = lines.next()?.parse().ok()?;
+        let mut d1 = Vec::with_capacity(n);
+        for _ in 0..n {
+            let v = nums(lines.next()?)?;
+            if v.len() != 3 {
+                return None;
+            }
+            d1.push([v[0], v[1], v[2]]);
+        }
+        (n >= 2).then_some((Lut { n1: n, d1, n3: 0, d3: vec![], dmin: [0.0; 3], dmax: [1.0; 3] }, shaper))
+    }
+}
+
+fn shape(curve: &[(f32, f32)], x: f32) -> f32 {
+    if curve.len() < 2 {
+        return x;
+    }
+    let i = curve.partition_point(|p| p.0 < x).clamp(1, curve.len() - 1);
+    let (a, b) = (curve[i - 1], curve[i]);
+    let t = ((x - a.0) / (b.0 - a.0).max(1e-12)).clamp(0.0, 1.0);
+    a.1 + (b.1 - a.1) * t
+}
+
+fn shape_inv(curve: &[(f32, f32)], y: f32) -> f32 {
+    let flipped: Vec<(f32, f32)> = curve.iter().map(|&(a, b)| (b, a)).collect();
+    shape(&flipped, y)
+}
+
+/// Parse transform text by its format (detected from `ext` or the content).
+pub fn parse_file(text: &str, ext: &str) -> Option<FileXform> {
+    let ext = ext.to_ascii_lowercase();
+    if ext == "cc" || ext == "ccc" || ext == "cdl" || text.contains("<ColorCorrection") {
+        let v = parse_cdl_xml(text);
+        return (!v.is_empty()).then_some(FileXform::Cdl(v));
+    }
+    if ext == "csp" || text.trim_start().starts_with("CSPLUTV100") {
+        return parse_csp(text).map(|(lut, s)| FileXform::Lut { lut, shaper: Some(s) });
+    }
+    if ext == "spimtx" {
+        return parse_spimtx(text);
+    }
+    if ext == "spi1d" || text.trim_start().starts_with("Version") {
+        return parse_spi1d(text).map(|lut| FileXform::Lut { lut, shaper: None });
+    }
+    if ext == "spi3d" || text.trim_start().starts_with("SPILUT") {
+        return parse_spi3d(text).map(|lut| FileXform::Lut { lut, shaper: None });
+    }
+    if ext == "cube" || text.contains("LUT_3D_SIZE") || text.contains("LUT_1D_SIZE") {
+        return parse_cube(text).map(|lut| FileXform::Lut { lut, shaper: None });
+    }
+    parse_3dl(text).map(|lut| FileXform::Lut { lut, shaper: None })
+}
+
+type FileCache = Mutex<HashMap<String, Option<Arc<FileXform>>>>;
+
+/// Load (and cache) a transform from a file path or inline content.
+pub fn load_file(src: &str) -> Option<Arc<FileXform>> {
+    let src_t = src.trim();
+    if src_t.is_empty() {
+        return None;
+    }
+    static CACHE: OnceLock<FileCache> = OnceLock::new();
+    let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new()));
+    if let Ok(m) = cache.lock()
+        && let Some(v) = m.get(src)
+    {
+        return v.clone();
+    }
+    let inline = src.contains('\n');
+    let parsed = if inline {
+        parse_file(src, "")
+    } else {
+        let ext = std::path::Path::new(src_t).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("");
+        std::fs::read_to_string(src_t).ok().and_then(|t| parse_file(&t, ext))
+    }
+    .map(Arc::new);
+    if let Ok(mut m) = cache.lock() {
+        m.insert(src.to_string(), parsed.clone());
+    }
+    parsed
+}
+
+impl FileXform {
+    pub fn apply(&self, c: [f32; 3], interp: u32, inverse: bool, ccc_id: &str) -> [f32; 3] {
+        match self {
+            FileXform::Cdl(list) => {
+                let cdl = list.iter().find(|(id, _)| !ccc_id.is_empty() && id == ccc_id).or(list.first()).map(|(_, c)| *c).unwrap_or_default();
+                let c64 = c.map(|v| v as f64);
+                let o = if inverse { cdl.invert(c64, true) } else { cdl.apply(c64, true) };
+                o.map(|v| v as f32)
+            }
+            FileXform::Matrix { m, offset } => crate::ocio_config::matrix_apply(m, offset, c.map(|v| v as f64), inverse).map(|v| v as f32),
+            FileXform::Lut { lut, shaper } => {
+                let fwd = |c: [f32; 3]| {
+                    let c = match shaper {
+                        Some(s) => [shape(&s[0], c[0]), shape(&s[1], c[1]), shape(&s[2], c[2])],
+                        None => c,
+                    };
+                    lut.apply_interp(c, interp)
+                };
+                if !inverse {
+                    return fwd(c);
+                }
+                if lut.n3 == 0 {
+                    // 1D: invert each channel exactly through the (monotone) tables.
+                    let mut x = c;
+                    if lut.n1 > 1 {
+                        x = [0, 1, 2].map(|i| {
+                            let curve: Vec<(f32, f32)> =
+                                (0..lut.n1).map(|k| (lut.d1[k][i], lut.dmin[i] + (lut.dmax[i] - lut.dmin[i]) * k as f32 / (lut.n1 - 1) as f32)).collect();
+                            shape(&curve, c[i])
+                        });
+                    }
+                    if let Some(s) = shaper {
+                        x = [shape_inv(&s[0], x[0]), shape_inv(&s[1], x[1]), shape_inv(&s[2], x[2])];
+                    }
+                    return x;
+                }
+                // 3D: damped fixed-point (Newton with an identity Jacobian) from the target.
+                let mut x = c;
+                for _ in 0..40 {
+                    let y = fwd(x);
+                    let e = [c[0] - y[0], c[1] - y[1], c[2] - y[2]];
+                    if e.iter().all(|v| v.abs() < 1e-6) {
+                        break;
+                    }
+                    x = [x[0] + e[0], x[1] + e[1], x[2] + e[2]];
+                }
+                x
+            }
+        }
+    }
+}
diff --git a/crates/effects/src/ocio/program.rs b/crates/effects/src/ocio/program.rs
new file mode 100644
index 000000000..a223dc7b4
--- /dev/null
+++ b/crates/effects/src/ocio/program.rs
@@ -0,0 +1,252 @@
+use super::cdl::Cdl;
+use super::effects::{DISPLAYS, cdl_from_params, custom_xf, looks, parse_looks, profile, space_at};
+use super::lut::{FileXform, load_file};
+use super::space::{ACES_CCT, D65, IDENTITY, Space, Tf, Xform, matrix};
+use super::{Arc, EffectCtx, Lut, invert, mul};
+
+// ---- Colour programs (the GPU compositor's colour-management kernels)
+
+/// One per-pixel step of a colour transform, in the order the CPU effect applies them (see
+/// [`color_program`]).
+#[derive(Clone, Debug)]
+pub enum ColorOp {
+    /// Transfer function, encoded → linear.
+    Decode(Tf),
+    /// Transfer function, linear → encoded.
+    Encode(Tf),
+    /// Linear-RGB matrix.
+    Matrix([[f32; 3]; 3]),
+    /// ASC CDL (forward or exact inverse; `clamp` = the v1.2 style).
+    Cdl { cdl: Cdl, clamp: bool, inverse: bool },
+    /// The Tone Mapped view's roll-off (or its inverse).
+    Tonemap { inverse: bool },
+    /// Color Profile Converter's perceptual gamut compression toward luminance `luma`.
+    Gamut([f64; 3]),
+    /// Negative channels to 0 (the saturation intent).
+    Max0,
+    /// A LUT (0 nearest, 1 trilinear, 2 tetrahedral) with an optional per-channel shaper, forward
+    /// or inverse (as `FileXform::apply`).
+    Lut { lut: Arc<Lut>, shaper: Option<Arc<[Vec<(f32, f32)>; 3]>>, interp: u32, inverse: bool },
+    /// `m × (c + pre) + post` (a custom config's MatrixTransform and RangeTransform).
+    Affine { m: [[f32; 3]; 3], pre: [f32; 3], post: [f32; 3] },
+    /// `max(c, 0) ^ p` per channel (ExponentTransform).
+    Pow([f32; 3]),
+    /// LogTransform / LogAffineTransform, forward or inverse (as `ocio_config::Xf::apply`).
+    LogAffine { base: f32, log_slope: [f32; 3], log_offset: [f32; 3], lin_slope: [f32; 3], lin_offset: [f32; 3], inverse: bool },
+    /// ExponentWithLinearTransform, forward (decode) or inverse (as
+    /// [`crate::ocio_config::moncurve`]).
+    MonCurve { gamma: [f32; 3], offset: [f32; 3], inverse: bool, mirror: bool },
+    /// Clamp each channel to `lo..=hi` (a clamping RangeTransform; ±`f32::MAX` = unbounded).
+    Clamp { lo: [f32; 3], hi: [f32; 3] },
+}
+
+/// The ops of a matrix-and-offset transform (MatrixTransform, `.spimtx`), forward or inverse
+/// (as [`crate::ocio_config::matrix_apply`]).
+fn matrix_ops(m: &[f64; 16], offset: &[f64; 4], inverse: bool, ops: &mut Vec<ColorOp>) {
+    if !inverse {
+        let m = [0, 1, 2].map(|r| [m[r * 4] as f32, m[r * 4 + 1] as f32, m[r * 4 + 2] as f32]);
+        ops.push(ColorOp::Affine { m, pre: [0.0; 3], post: [offset[0] as f32, offset[1] as f32, offset[2] as f32] });
+    } else if let Some(inv) = crate::ocio_config::mat3_inverse(m) {
+        let m = inv.map(|r| r.map(|v| v as f32));
+        ops.push(ColorOp::Affine { m, pre: [-offset[0] as f32, -offset[1] as f32, -offset[2] as f32], post: [0.0; 3] });
+    }
+}
+
+/// The ops of a LUT / CDL / matrix file transform (as [`FileXform::apply`]).
+fn file_ops(x: &FileXform, interp: u32, inverse: bool, ccc_id: &str, ops: &mut Vec<ColorOp>) {
+    match x {
+        FileXform::Cdl(list) => {
+            let cdl = list.iter().find(|(i, _)| !ccc_id.is_empty() && i == ccc_id).or(list.first()).map(|(_, c)| *c).unwrap_or_default();
+            ops.push(ColorOp::Cdl { cdl, clamp: true, inverse });
+        }
+        FileXform::Lut { lut, shaper } => {
+            ops.push(ColorOp::Lut { lut: Arc::new(lut.clone()), shaper: shaper.clone().map(Arc::new), interp, inverse });
+        }
+        FileXform::Matrix { m, offset } => matrix_ops(m, offset, inverse, ops),
+    }
+}
+
+/// The ops of a custom config's transform `x` (as `Xf::apply`).
+fn config_xf_ops(x: &crate::ocio_config::Xf, inverse: bool, ops: &mut Vec<ColorOp>) {
+    use crate::ocio_config::Xf;
+    let f3 = |v: &[f64; 3]| v.map(|x| x as f32);
+    match x {
+        Xf::Inverse(x) => config_xf_ops(x, !inverse, ops),
+        Xf::Matrix { m, offset } => matrix_ops(m, offset, inverse, ops),
+        Xf::File { xf: Some(x), interp, ccc, .. } => file_ops(x, *interp, inverse, ccc, ops),
+        Xf::ExponentLinear { gamma, offset, mirror } => ops.push(ColorOp::MonCurve { gamma: f3(gamma), offset: f3(offset), inverse, mirror: *mirror }),
+        // A BuiltinTransform's curve: forward decodes.
+        Xf::Curve(tf) => ops.push(if inverse { ColorOp::Encode(*tf) } else { ColorOp::Decode(*tf) }),
+        Xf::Named(_) => {}
+        Xf::File { xf: None, .. } | Xf::Unsupported(_) => {}
+        Xf::Exponent(e) => ops.push(ColorOp::Pow([0, 1, 2].map(|k| (if inverse { 1.0 / e[k].max(1e-9) } else { e[k] }) as f32))),
+        Xf::Log { base } => {
+            ops.push(ColorOp::LogAffine { base: *base as f32, log_slope: [1.0; 3], log_offset: [0.0; 3], lin_slope: [1.0; 3], lin_offset: [0.0; 3], inverse })
+        }
+        Xf::LogAffine { base, log_slope, log_offset, lin_slope, lin_offset } => ops.push(ColorOp::LogAffine {
+            base: *base as f32,
+            log_slope: f3(log_slope),
+            log_offset: f3(log_offset),
+            lin_slope: f3(lin_slope),
+            lin_offset: f3(lin_offset),
+            inverse,
+        }),
+        Xf::Cdl(cdl) => ops.push(ColorOp::Cdl { cdl: *cdl, clamp: true, inverse }),
+        Xf::Range(r) => {
+            let (k, off, lo, hi) = r.parts(inverse);
+            let k = k as f32;
+            ops.push(ColorOp::Affine { m: [[k, 0.0, 0.0], [0.0, k, 0.0], [0.0, 0.0, k]], pre: [0.0; 3], post: [off as f32; 3] });
+            if lo.is_finite() || hi.is_finite() {
+                let bound = |v: f64| (v as f32).clamp(-f32::MAX, f32::MAX);
+                ops.push(ColorOp::Clamp { lo: [bound(lo); 3], hi: [bound(hi); 3] });
+            }
+        }
+        Xf::Group(list) => {
+            if inverse {
+                list.iter().rev().for_each(|x| config_xf_ops(x, true, ops));
+            } else {
+                list.iter().for_each(|x| config_xf_ops(x, false, ops));
+            }
+        }
+    }
+}
+
+/// How a colour program meets premultiplied pixels.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Straight {
+    /// `unpremul` (colour 0 below alpha 1e-6); fully transparent pixels untouched (OCIO effects).
+    Unpremul,
+    /// Colour ÷ alpha; fully transparent pixels untouched (`Image::map_straight`, Apply Color LUT).
+    Divide,
+}
+
+fn xform_ops(x: &Xform, ops: &mut Vec<ColorOp>) {
+    if x.dec != Tf::Linear {
+        ops.push(ColorOp::Decode(x.dec));
+    }
+    if !x.ident {
+        ops.push(ColorOp::Matrix(x.m));
+    }
+    if x.enc != Tf::Linear {
+        ops.push(ColorOp::Encode(x.enc));
+    }
+}
+
+/// Effect `id`'s per-pixel transform as a list of [`ColorOp`]s that reproduces the CPU effect
+/// (empty = the layer passes through; custom OCIO configs compile their transforms too). `None`
+/// for another effect.
+pub fn color_program(id: &str, ctx: &EffectCtx) -> Option<(Vec<ColorOp>, Straight)> {
+    let pr = ctx.params;
+    let mut ops = vec![];
+    // Configuration ▸ Custom compiles the config's transforms (a config that can't be read, or
+    // names unknown spaces, passes the pixels through).
+    match custom_xf(id, pr) {
+        Ok(None) => {}
+        Ok(Some(xf)) => {
+            config_xf_ops(&xf, false, &mut ops);
+            return Some((ops, Straight::Unpremul));
+        }
+        Err(_) => return Some((ops, Straight::Unpremul)),
+    }
+    match id {
+        "ec.utility.applylut" => {
+            if let Some(lut) = crate::utility::load_lut(pr.s("lut")) {
+                ops.push(ColorOp::Lut { lut, shaper: None, interp: 2, inverse: false });
+            }
+            return Some((ops, Straight::Divide));
+        }
+        "ec.color.ociocolorspace" => {
+            let (a, z) = (space_at(pr.e("source")), space_at(pr.e("destination")));
+            let (a, z) = if pr.e("direction") == 1 { (z, a) } else { (a, z) };
+            if a.name != z.name {
+                xform_ops(&Xform::new(a, z), &mut ops);
+            }
+        }
+        "ec.color.ociocdl" => {
+            let cdl = cdl_from_params(pr);
+            if cdl != Cdl::default() {
+                ops.push(ColorOp::Cdl { cdl, clamp: pr.e("style") == 0, inverse: pr.e("direction") == 1 });
+            }
+        }
+        "ec.color.ociodisplay" => {
+            let input = space_at(pr.e("source"));
+            let (display, view, inverse) = (pr.e("display") as usize, pr.e("view") as usize, pr.e("direction") == 1);
+            let (_, prims, tf) = DISPLAYS[display.min(DISPLAYS.len() - 1)];
+            if view != 2 && !input.raw {
+                let disp = Space { name: "display", prims: Some((prims, D65)), tf: Tf::Linear, raw: false };
+                let lin = Space { tf: Tf::Linear, ..*input };
+                if !inverse {
+                    ops.push(ColorOp::Decode(input.tf));
+                    xform_ops(&Xform::new(&lin, &disp), &mut ops);
+                    if view == 1 {
+                        ops.push(ColorOp::Tonemap { inverse: false });
+                    }
+                    ops.push(ColorOp::Encode(tf));
+                } else {
+                    ops.push(ColorOp::Decode(tf));
+                    if view == 1 {
+                        ops.push(ColorOp::Tonemap { inverse: true });
+                    }
+                    xform_ops(&Xform::new(&disp, &lin), &mut ops);
+                    ops.push(ColorOp::Encode(input.tf));
+                }
+            }
+        }
+        "ec.color.ociofile" => {
+            if let Some(x) = load_file(pr.s("file")) {
+                let interp = match pr.e("interpolation") {
+                    0 => 0,
+                    1 => 1,
+                    _ => 2,
+                };
+                file_ops(&x, interp, pr.e("direction") == 1, pr.s("cccId"), &mut ops);
+            }
+        }
+        "ec.color.ociolook" => {
+            let mut list = parse_looks(pr.s("looks"));
+            let pick = pr.e("look");
+            if pick > 0
+                && let Some((_, c)) = looks().get(pick as usize - 1)
+            {
+                list.insert(0, (*c, false));
+            }
+            if !list.is_empty() {
+                let (src, dst) = (space_at(pr.e("source")), space_at(pr.e("destination")));
+                let inv = pr.e("direction") == 1;
+                let cct = &ACES_CCT;
+                let (a, z) = if inv { (dst, src) } else { (src, dst) };
+                if inv {
+                    list.reverse();
+                }
+                xform_ops(&Xform::new(a, cct), &mut ops);
+                for (cdl, li) in &list {
+                    ops.push(ColorOp::Cdl { cdl: *cdl, clamp: false, inverse: *li != inv });
+                }
+                xform_ops(&Xform::new(cct, z), &mut ops);
+            }
+        }
+        "ec.utility.colorprofileconverter" => {
+            let (inp, in_lin_default) = profile(ctx, pr.e("inputProfile"));
+            let (out, out_lin_default) = profile(ctx, pr.e("outputProfile"));
+            let in_lin = pr.b("linearizeInputProfile") || in_lin_default && pr.e("inputProfile") == 0;
+            let out_lin = pr.b("linearizeOutputProfile") || out_lin_default && pr.e("outputProfile") == 0;
+            let intent = pr.e("intent");
+            let dec = if in_lin { Tf::Linear } else { inp.tf };
+            let enc = if out_lin { Tf::Linear } else { out.tf };
+            let m = if intent == 3 { mul(&invert(&out.to_ref(false)), &inp.to_ref(false)) } else { matrix(&inp, &out) };
+            let identity = dec == enc && (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-9));
+            if !identity {
+                ops.push(ColorOp::Decode(dec));
+                ops.push(ColorOp::Matrix(m.map(|r| r.map(|v| v as f32))));
+                match intent {
+                    0 => ops.push(ColorOp::Gamut(out.to_ref(true)[1])),
+                    2 => ops.push(ColorOp::Max0),
+                    _ => {}
+                }
+                ops.push(ColorOp::Encode(enc));
+            }
+        }
+        _ => return None,
+    }
+    Some((ops, Straight::Unpremul))
+}
diff --git a/crates/effects/src/ocio/registry.rs b/crates/effects/src/ocio/registry.rs
new file mode 100644
index 000000000..cd3bd02a7
--- /dev/null
+++ b/crates/effects/src/ocio/registry.rs
@@ -0,0 +1,129 @@
+use super::cdl::sl;
+use super::effects::{
+    CONFIGS, DISPLAYS, PROFILES, VIEWS, color_stabilizer, direction, looks, ocio_cdl, ocio_cst, ocio_display, ocio_file, ocio_look, profile_converter,
+    space_param, spec,
+};
+use super::space::SPACES;
+use super::{EffectSpec, ParamUi, Value, num, p, popup, slider};
+
+pub fn specs() -> Vec<EffectSpec> {
+    let cc = "Color Correction";
+    let srgb = SPACES.iter().position(|s| s.name == "sRGB").unwrap_or(0) as u32;
+    let lin709 = SPACES.iter().position(|s| s.name == "Linear Rec.709 (sRGB)").unwrap_or(0) as u32;
+    let acescg = SPACES.iter().position(|s| s.name == "ACEScg").unwrap_or(0) as u32;
+    let mut look_opts = vec!["None"];
+    look_opts.extend(looks().iter().map(|(n, _)| *n));
+    vec![
+        spec(
+            "ec.color.ociocdl",
+            "OCIO CDL Transform",
+            cc,
+            vec![
+                p("slopeRed", "Slope Red", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+                p("slopeGreen", "Slope Green", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+                p("slopeBlue", "Slope Blue", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+                p("offsetRed", "Offset Red", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
+                p("offsetGreen", "Offset Green", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
+                p("offsetBlue", "Offset Blue", num(0.0), sl(-100.0, 100.0, -1.0, 1.0)),
+                p("powerRed", "Power Red", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+                p("powerGreen", "Power Green", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+                p("powerBlue", "Power Blue", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+                p("saturation", "Saturation", num(1.0), sl(0.0, 100.0, 0.0, 4.0)),
+                p("style", "Style", Value::Enum(0), popup(&["ASC CDL v1.2", "No Clamp"])),
+                direction(),
+            ],
+            ocio_cdl,
+        ),
+        spec(
+            "ec.color.ociocolorspace",
+            "OCIO Color Space Transform",
+            cc,
+            vec![
+                p("config", "Configuration", Value::Enum(0), popup(CONFIGS)),
+                p("configFile", "Config File (.ocio)", Value::Str(String::new()), crate::file_ui(&["ocio"])),
+                space_param("source", "Source", lin709),
+                p("sourceName", "Source (config name)", Value::Str(String::new()), ParamUi::Text),
+                space_param("destination", "Destination", srgb),
+                p("destinationName", "Destination (config name)", Value::Str(String::new()), ParamUi::Text),
+                direction(),
+            ],
+            ocio_cst,
+        ),
+        spec(
+            "ec.color.ociodisplay",
+            "OCIO Display Transform",
+            cc,
+            vec![
+                p("config", "Configuration", Value::Enum(0), popup(CONFIGS)),
+                p("configFile", "Config File (.ocio)", Value::Str(String::new()), crate::file_ui(&["ocio"])),
+                space_param("source", "Input Color Space", lin709),
+                p("sourceName", "Source (config name)", Value::Str(String::new()), ParamUi::Text),
+                p("display", "Display Device", Value::Enum(0), popup(&DISPLAYS.iter().map(|d| d.0).collect::<Vec<_>>())),
+                p("displayName", "Display (config name)", Value::Str(String::new()), ParamUi::Text),
+                p("view", "View Transform", Value::Enum(0), popup(VIEWS)),
+                p("viewName", "View (config name)", Value::Str(String::new()), ParamUi::Text),
+                direction(),
+            ],
+            ocio_display,
+        ),
+        // `file`: a path to a .cube/.3dl/.csp/.cc/.ccc/.cdl file, or the file's text itself.
+        spec(
+            "ec.color.ociofile",
+            "OCIO File Transform",
+            cc,
+            vec![
+                p("file", "File", Value::Str(String::new()), crate::file_ui(&["cube", "3dl", "csp", "cc", "ccc", "cdl", "spi1d", "spi3d", "spimtx"])),
+                p("cccId", "CCC ID", Value::Str(String::new()), ParamUi::Text),
+                p("interpolation", "Interpolation", Value::Enum(3), popup(&["Nearest", "Linear", "Tetrahedral", "Best"])),
+                direction(),
+            ],
+            ocio_file,
+        ),
+        spec(
+            "ec.color.ociolook",
+            "OCIO Look Transform",
+            cc,
+            vec![
+                p("config", "Configuration", Value::Enum(0), popup(&["Built-in (EffectCraft minimal)"])),
+                space_param("source", "Source", acescg),
+                space_param("destination", "Destination", acescg),
+                p("look", "Look", Value::Enum(0), popup(&look_opts)),
+                p("looks", "Looks", Value::Str(String::new()), ParamUi::Text),
+                direction(),
+            ],
+            ocio_look,
+        ),
+        spec(
+            "ec.color.colorstabilizer",
+            "Color Stabilizer",
+            cc,
+            vec![
+                // The pivot frame (After Effects' Set Frame button stores it).
+                p("referenceFrame", "Reference Frame (s)", num(0.0), slider(-100000.0, 100000.0, 0.0, 60.0, 2)),
+                p("stabilize", "Stabilize", Value::Enum(0), popup(&["Brightness", "Levels", "Curves"])),
+                p("blackPoint", "Black Point", Value::Vec2([0.25, 0.75]), ParamUi::Point),
+                p("midPoint", "Mid Point", Value::Vec2([0.5, 0.5]), ParamUi::Point),
+                p("whitePoint", "White Point", Value::Vec2([0.75, 0.25]), ParamUi::Point),
+                p("sampleSize", "Sample Size", num(5.0), slider(1.0, 100.0, 1.0, 50.0, 0)),
+            ],
+            color_stabilizer,
+        ),
+        spec(
+            "ec.utility.colorprofileconverter",
+            "Color Profile Converter",
+            "Utility",
+            vec![
+                p("inputProfile", "Input Profile", Value::Enum(0), popup(PROFILES)),
+                p("linearizeInputProfile", "Linearize Input Profile", Value::Bool(false), ParamUi::Checkbox),
+                p("outputProfile", "Output Profile", Value::Enum(1), popup(PROFILES)),
+                p("linearizeOutputProfile", "Linearize Output Profile", Value::Bool(false), ParamUi::Checkbox),
+                p("intent", "Intent", Value::Enum(1), popup(&["Perceptual", "Relative Colorimetric", "Saturation", "Absolute Colorimetric"])),
+                // Our built-in profiles share a zero black point and none is scene-referred, so
+                // these two are kept for compatibility and do not change the result.
+                p("useBlackPointCompensation", "Use Black Point Compensation", Value::Bool(true), ParamUi::Checkbox),
+                p("sceneRefCompensation", "Scene-ref. Profile Compensation", Value::Enum(2), popup(&["On", "Off", "Use Project Setting"])),
+            ],
+            profile_converter,
+        ),
+    ]
+}
diff --git a/crates/effects/src/ocio/space.rs b/crates/effects/src/ocio/space.rs
new file mode 100644
index 000000000..1a1d8f69b
--- /dev/null
+++ b/crates/effects/src/ocio/space.rs
@@ -0,0 +1,214 @@
+use super::{invert, mul, mul_vec, rgb_to_xyz};
+
+pub(super) type M3 = [[f64; 3]; 3];
+
+pub(crate) const D65: [f64; 2] = [0.3127, 0.3290];
+
+const ACES_WHITE: [f64; 2] = [0.32168, 0.33767];
+
+const AP0: [[f64; 2]; 3] = [[0.7347, 0.2653], [0.0, 1.0], [0.0001, -0.0770]];
+
+const AP1: [[f64; 2]; 3] = [[0.713, 0.293], [0.165, 0.830], [0.128, 0.044]];
+
+pub(crate) const REC709: [[f64; 2]; 3] = [[0.640, 0.330], [0.300, 0.600], [0.150, 0.060]];
+
+pub(crate) const REC2020: [[f64; 2]; 3] = [[0.708, 0.292], [0.170, 0.797], [0.131, 0.046]];
+
+pub(crate) const P3: [[f64; 2]; 3] = [[0.680, 0.320], [0.265, 0.690], [0.150, 0.060]];
+
+pub(super) const IDENTITY: M3 = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
+
+/// Transfer functions (encoded ↔ linear).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Tf {
+    Linear,
+    Srgb,
+    Gamma(f64),
+    AcesCct,
+    /// ACEScc (Academy S-2014-003), the pure-log grading encoding.
+    AcesCc,
+    /// SMPTE ST 2084 with 1.0 = 100 cd/m².
+    Pq,
+}
+
+/// ACEScc: the lowest code value (linear 0 and below) and the end of its toe (linear 2⁻¹⁵).
+const ACESCC_MIN: f64 = (-16.0 + 9.72) / 17.52;
+
+const ACESCC_TOE: f64 = (-15.0 + 9.72) / 17.52;
+
+impl Tf {
+    pub fn decode(self, v: f64) -> f64 {
+        match self {
+            Tf::Linear => v,
+            Tf::Srgb => {
+                let a = v.abs();
+                let l = if a <= 0.04045 { a / 12.92 } else { ((a + 0.055) / 1.055).powf(2.4) };
+                l.copysign(v)
+            }
+            Tf::Gamma(g) => v.abs().powf(g).copysign(v),
+            Tf::AcesCct => {
+                if v <= 0.155_251_141_552_511 {
+                    (v - 0.072_905_534_195_835_5) / 10.540_237_741_654_5
+                } else if v < (65504f64.log2() + 9.72) / 17.52 {
+                    2f64.powf(v * 17.52 - 9.72)
+                } else {
+                    65504.0
+                }
+            }
+            Tf::AcesCc => {
+                if v < ACESCC_TOE {
+                    (2f64.powf(v * 17.52 - 9.72) - 2f64.powi(-16)) * 2.0
+                } else if v < (65504f64.log2() + 9.72) / 17.52 {
+                    2f64.powf(v * 17.52 - 9.72)
+                } else {
+                    65504.0
+                }
+            }
+            Tf::Pq => {
+                let (m1, m2, c1, c2, c3) = pq_consts();
+                let e = v.max(0.0).powf(1.0 / m2);
+                let l = ((e - c1).max(0.0) / (c2 - c3 * e)).powf(1.0 / m1);
+                l * 100.0
+            }
+        }
+    }
+    pub fn encode(self, v: f64) -> f64 {
+        match self {
+            Tf::Linear => v,
+            Tf::Srgb => {
+                let a = v.abs();
+                let e = if a <= 0.003_130_8 { a * 12.92 } else { 1.055 * a.powf(1.0 / 2.4) - 0.055 };
+                e.copysign(v)
+            }
+            Tf::Gamma(g) => v.abs().powf(1.0 / g).copysign(v),
+            Tf::AcesCct => {
+                if v <= 0.007_812_5 {
+                    10.540_237_741_654_5 * v + 0.072_905_534_195_835_5
+                } else {
+                    (v.log2() + 9.72) / 17.52
+                }
+            }
+            Tf::AcesCc => {
+                if v <= 0.0 {
+                    ACESCC_MIN
+                } else if v < 2f64.powi(-15) {
+                    ((2f64.powi(-16) + v * 0.5).log2() + 9.72) / 17.52
+                } else {
+                    (v.log2() + 9.72) / 17.52
+                }
+            }
+            Tf::Pq => {
+                let (m1, m2, c1, c2, c3) = pq_consts();
+                let y = (v / 100.0).max(0.0).powf(m1);
+                ((c1 + c2 * y) / (1.0 + c3 * y)).powf(m2)
+            }
+        }
+    }
+}
+
+fn pq_consts() -> (f64, f64, f64, f64, f64) {
+    (2610.0 / 16384.0, 2523.0 / 4096.0 * 128.0, 3424.0 / 4096.0, 2413.0 / 4096.0 * 32.0, 2392.0 / 4096.0 * 32.0)
+}
+
+/// A colour space of the built-in config.
+#[derive(Clone, Copy, Debug)]
+pub struct Space {
+    pub name: &'static str,
+    /// Primaries and white (None = CIE XYZ itself).
+    pub prims: Option<([[f64; 2]; 3], [f64; 2])>,
+    pub tf: Tf,
+    /// Passes data through untouched.
+    pub raw: bool,
+}
+
+pub(crate) const fn sp(name: &'static str, prims: [[f64; 2]; 3], white: [f64; 2], tf: Tf) -> Space {
+    Space { name, prims: Some((prims, white)), tf, raw: false }
+}
+
+/// The built-in configuration's colour spaces, in popup order.
+pub(crate) const ACES2065_1: Space = sp("ACES2065-1", AP0, ACES_WHITE, Tf::Linear);
+
+pub(crate) const ACES_CG: Space = sp("ACEScg", AP1, ACES_WHITE, Tf::Linear);
+
+pub(super) const ACES_CCT: Space = sp("ACEScct", AP1, ACES_WHITE, Tf::AcesCct);
+
+pub const SPACES: &[Space] = &[
+    ACES2065_1,
+    ACES_CG,
+    ACES_CCT,
+    sp("Linear Rec.709 (sRGB)", REC709, D65, Tf::Linear),
+    sp("sRGB", REC709, D65, Tf::Srgb),
+    sp("Gamma 2.4 Rec.709", REC709, D65, Tf::Gamma(2.4)),
+    sp("Linear Rec.2020", REC2020, D65, Tf::Linear),
+    sp("Gamma 2.4 Rec.2020", REC2020, D65, Tf::Gamma(2.4)),
+    sp("Linear P3-D65", P3, D65, Tf::Linear),
+    sp("Display P3", P3, D65, Tf::Srgb),
+    Space { name: "CIE-XYZ-D65", prims: None, tf: Tf::Linear, raw: false },
+    Space { name: "Raw", prims: None, tf: Tf::Linear, raw: true },
+];
+
+pub fn space_names() -> Vec<&'static str> {
+    SPACES.iter().map(|s| s.name).collect()
+}
+
+#[cfg(test)]
+pub fn space_by_name(n: &str) -> Option<&'static Space> {
+    SPACES.iter().find(|s| s.name.eq_ignore_ascii_case(n))
+}
+
+/// Bradford chromatic adaptation from white `src` to white `dst` (xy).
+pub fn bradford(src: [f64; 2], dst: [f64; 2]) -> M3 {
+    if src == dst {
+        return IDENTITY;
+    }
+    const MB: M3 = [[0.8951, 0.2664, -0.1614], [-0.7502, 1.7135, 0.0367], [0.0389, -0.0685, 1.0296]];
+    let xyz = |c: [f64; 2]| [c[0] / c[1], 1.0, (1.0 - c[0] - c[1]) / c[1]];
+    let s = mul_vec(&MB, xyz(src));
+    let d = mul_vec(&MB, xyz(dst));
+    let diag = [[d[0] / s[0], 0.0, 0.0], [0.0, d[1] / s[1], 0.0], [0.0, 0.0, d[2] / s[2]]];
+    mul(&invert(&MB), &mul(&diag, &MB))
+}
+
+impl Space {
+    /// Linear RGB → XYZ D65 (Bradford-adapted when `adapt`, else the space's own white).
+    pub fn to_ref(self, adapt: bool) -> M3 {
+        match self.prims {
+            None => IDENTITY,
+            Some((p, w)) => {
+                let m = rgb_to_xyz(p, w);
+                if adapt { mul(&bradford(w, D65), &m) } else { m }
+            }
+        }
+    }
+}
+
+/// Linear-RGB matrix from space `a` to space `b`.
+pub fn matrix(a: &Space, b: &Space) -> M3 {
+    mul(&invert(&b.to_ref(true)), &a.to_ref(true))
+}
+
+/// A compiled colour-space conversion.
+#[derive(Clone, Copy, Debug)]
+pub struct Xform {
+    pub(super) dec: Tf,
+    pub(super) m: [[f32; 3]; 3],
+    pub(super) ident: bool,
+    pub(super) enc: Tf,
+}
+
+impl Xform {
+    pub fn new(a: &Space, b: &Space) -> Xform {
+        if a.raw || b.raw {
+            return Xform { dec: Tf::Linear, m: IDENTITY.map(|r| r.map(|v| v as f32)), ident: true, enc: Tf::Linear };
+        }
+        let m = matrix(a, b);
+        let ident = (0..3).all(|i| (0..3).all(|j| (m[i][j] - IDENTITY[i][j]).abs() < 1e-12));
+        Xform { dec: a.tf, m: m.map(|r| r.map(|v| v as f32)), ident, enc: b.tf }
+    }
+    #[inline]
+    pub fn apply(&self, c: [f32; 3]) -> [f32; 3] {
+        let l = c.map(|v| self.dec.decode(v as f64) as f32);
+        let l = if self.ident { l } else { [0, 1, 2].map(|i| self.m[i][0] * l[0] + self.m[i][1] * l[1] + self.m[i][2] * l[2]) };
+        l.map(|v| self.enc.encode(v as f64) as f32)
+    }
+}
diff --git a/crates/effects/src/ocio/tests.rs b/crates/effects/src/ocio/tests.rs
new file mode 100644
index 000000000..edbc6eff2
--- /dev/null
+++ b/crates/effects/src/ocio/tests.rs
@@ -0,0 +1,313 @@
+use super::*;
+use crate::{EffectEnv, EffectHost, Image, LayerPixels, run_fx};
+
+fn close(a: M3, b: M3, tol: f64) {
+    for i in 0..3 {
+        for j in 0..3 {
+            assert!((a[i][j] - b[i][j]).abs() < tol, "{a:?} vs {b:?}");
+        }
+    }
+}
+
+#[test]
+fn aces_matrices_match_published_values() {
+    let ap0 = space_by_name("ACES2065-1").unwrap();
+    let ap1 = space_by_name("ACEScg").unwrap();
+    // Academy S-2014-004 AP0 → AP1.
+    close(
+        matrix(ap0, ap1),
+        [
+            [1.451_439_316_1, -0.236_510_746_9, -0.214_928_569_3],
+            [-0.076_553_773_4, 1.176_229_699_8, -0.099_675_926_4],
+            [0.008_316_148_4, -0.006_032_449_8, 0.997_716_301_4],
+        ],
+        2e-4,
+    );
+    // ACEScg → linear Rec.709 with Bradford adaptation (published ACES config value).
+    let lin = space_by_name("Linear Rec.709 (sRGB)").unwrap();
+    close(matrix(ap1, lin), [[1.705_05, -0.621_79, -0.083_26], [-0.130_26, 1.140_80, -0.010_55], [-0.024_00, -0.128_97, 1.152_97]], 2e-3);
+    // White maps to white.
+    let w = mul_vec(&matrix(ap1, lin), [1.0, 1.0, 1.0]);
+    assert!(w.iter().all(|v| (v - 1.0).abs() < 1e-3), "{w:?}");
+}
+
+#[test]
+fn transfer_functions_round_trip() {
+    for tf in [Tf::Srgb, Tf::Gamma(2.4), Tf::AcesCct, Tf::Pq] {
+        for v in [0.0, 0.001, 0.18, 0.5, 1.0, 4.0] {
+            let r = tf.decode(tf.encode(v));
+            assert!((r - v).abs() < 1e-6 * v.max(1.0), "{tf:?} {v} {r}");
+        }
+    }
+    // ACEScct of 18 % grey (S-2016-001).
+    assert!((Tf::AcesCct.encode(0.18) - 0.413_588).abs() < 1e-5);
+    // PQ: 100 nits (1.0) encodes to ≈ 0.508.
+    assert!((Tf::Pq.encode(1.0) - 0.508).abs() < 1e-3);
+}
+
+#[test]
+fn color_space_transform_effect_round_trips() {
+    let img = Image::filled(4, 4, [0.2, 0.5, 0.7, 1.0]);
+    let srgb = SPACES.iter().position(|s| s.name == "sRGB").unwrap() as u32;
+    let cg = SPACES.iter().position(|s| s.name == "ACEScg").unwrap() as u32;
+    let a = run_fx("ec.color.ociocolorspace", &[("source", Value::Enum(srgb)), ("destination", Value::Enum(cg))], img.clone(), 0.0, EffectEnv::default());
+    assert_ne!(a.img.data, img.data);
+    let b = run_fx("ec.color.ociocolorspace", &[("source", Value::Enum(cg)), ("destination", Value::Enum(srgb))], a.img.clone(), 0.0, EffectEnv::default());
+    let c = run_fx(
+        "ec.color.ociocolorspace",
+        &[("source", Value::Enum(srgb)), ("destination", Value::Enum(cg)), ("direction", Value::Enum(1))],
+        a.img,
+        0.0,
+        EffectEnv::default(),
+    );
+    for (x, y) in b.img.data.iter().zip(&img.data).chain(c.img.data.iter().zip(&img.data)) {
+        assert!((0..4).all(|k| (x[k] - y[k]).abs() < 1e-4), "{x:?} {y:?}");
+    }
+}
+
+#[test]
+fn cdl_math() {
+    let cdl = Cdl { slope: [1.2, 1.0, 0.8], offset: [0.05, 0.0, -0.02], power: [1.1, 1.0, 0.9], sat: 0.8 };
+    let c = [0.3, 0.5, 0.7];
+    // Hand computation of the v1.2 formula.
+    let sop = [(0.3f64 * 1.2 + 0.05).powf(1.1), 0.5, (0.7f64 * 0.8 - 0.02).powf(0.9)];
+    let l = sop[0] * 0.2126 + sop[1] * 0.7152 + sop[2] * 0.0722;
+    let want = sop.map(|v| l + 0.8 * (v - l));
+    let got = cdl.apply(c, true);
+    for k in 0..3 {
+        assert!((got[k] - want[k]).abs() < 1e-12);
+    }
+    let back = cdl.invert(got, true);
+    for k in 0..3 {
+        assert!((back[k] - c[k]).abs() < 1e-9);
+    }
+    // v1.2 clamps, No Clamp keeps negatives.
+    let neg = Cdl { offset: [-0.5; 3], ..Cdl::default() };
+    assert_eq!(neg.apply([0.2; 3], true), [0.0; 3]);
+    assert!((neg.apply([0.2; 3], false)[0] + 0.3).abs() < 1e-12);
+    let img = Image::filled(2, 2, [0.3, 0.5, 0.7, 1.0]);
+    let out = run_fx("ec.color.ociocdl", &[("slopeRed", num(1.2)), ("offsetRed", num(0.05)), ("powerRed", num(1.1))], img, 0.0, EffectEnv::default());
+    let r = (0.3f64 * 1.2 + 0.05).powf(1.1);
+    assert!((out.img.get(0, 0)[0] as f64 - r).abs() < 1e-5);
+}
+
+fn identity_lattice(n: usize, f: impl Fn([f32; 3]) -> [f32; 3]) -> Vec<[f32; 3]> {
+    let mut v = vec![];
+    for b in 0..n {
+        for g in 0..n {
+            for r in 0..n {
+                let s = (n - 1) as f32;
+                v.push(f([r as f32 / s, g as f32 / s, b as f32 / s]));
+            }
+        }
+    }
+    v
+}
+
+/// Sony Imageworks `.spi1d`, `.spi3d` and `.spimtx` (Blender's configs use them, #410), and
+/// malformed ones rejected without panicking.
+#[test]
+fn spi_files_parse() {
+    let spi1d = "Version 1\nFrom 0.0 2.0\nLength 3\nComponents 1\n{\n0.0\n0.25\n1.0\n}\n";
+    let x = parse_file(spi1d, "spi1d").unwrap();
+    let o = x.apply([1.0, 0.5, 2.0], 1, false, "");
+    assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.125).abs() < 1e-6 && (o[2] - 1.0).abs() < 1e-6, "{o:?}");
+    let back = x.apply(o, 1, true, "");
+    assert!((back[0] - 1.0).abs() < 1e-5 && (back[2] - 2.0).abs() < 1e-5, "{back:?}");
+    let three = parse_spi1d("Version 1\nFrom 0 1\nLength 2\nComponents 3\n{\n0 0 0\n1 0.5 2\n}\n").unwrap();
+    assert_eq!(three.d1, vec![[0.0; 3], [1.0, 0.5, 2.0]]);
+    let mut spi3d = String::from("SPILUT 1.0\n3 3\n2 2 2\n");
+    for (r, g, b) in (0..8).map(|i| (i & 1, (i >> 1) & 1, i >> 2)) {
+        spi3d += &format!("{r} {g} {b} {} {} {}\n", r as f32 * 0.5, g, b);
+    }
+    let x = parse_file(&spi3d, "spi3d").unwrap();
+    let o = x.apply([1.0, 0.5, 0.25], 1, false, "");
+    assert!((o[0] - 0.5).abs() < 1e-6 && (o[1] - 0.5).abs() < 1e-6 && (o[2] - 0.25).abs() < 1e-6, "{o:?}");
+    let m = parse_file("2 0 0 6553.5\n0 1 0 0\n0 0 1 0\n", "spimtx").unwrap();
+    let o = m.apply([0.25, 0.5, 1.0], 1, false, "");
+    assert!((o[0] - 0.6).abs() < 1e-6 && o[1] == 0.5 && o[2] == 1.0, "{o:?}");
+    assert!((m.apply(o, 1, true, "")[0] - 0.25).abs() < 1e-6);
+    for bad in [
+        "Version 1\nFrom 0 1\nLength 99999999999\nComponents 1\n{\n0\n}\n",
+        "Version 1\nFrom 1 0\nLength 2\nComponents 1\n{\n0\n1\n}\n",
+        "Version 1\nFrom 0 1\nLength 3\nComponents 1\n{\n0\n1\n}\n",
+        "Version 1\nFrom 0 1\nLength 2\nComponents 2\n{\n0 0\n1 1\n}\n",
+    ] {
+        assert!(parse_spi1d(bad).is_none(), "{bad}");
+    }
+    assert!(parse_spi3d("SPILUT 1.0\n3 3\n4000 4000 4000\n").is_none());
+    assert!(parse_spi3d("SPILUT 1.0\n3 3\n2 2 2\n9 0 0 1 1 1\n").is_none());
+    assert!(parse_spi3d("SPILUT 1.0\n3 3\n2 2 2\n0 0 0 1 1 1\n").is_none(), "incomplete lattice");
+    assert!(parse_spimtx("1 0 0\n0 1 0\n").is_none());
+    assert!(parse_spimtx("NaN 0 0 0 0 1 0 0 0 0 1 0").is_none());
+}
+
+#[test]
+fn lut_files_parse_and_interpolate() {
+    // .cube with a non-linear lattice: trilinear between lattice points.
+    let f = |c: [f32; 3]| [c[0] * c[0], c[1], 1.0 - c[2]];
+    let mut cube = String::from("LUT_3D_SIZE 3\n");
+    for r in identity_lattice(3, f) {
+        cube += &format!("{} {} {}\n", r[0], r[1], r[2]);
+    }
+    let Some(FileXform::Lut { lut, .. }) = parse_file(&cube, "cube") else { panic!() };
+    // Trilinear between 0.5 (0.25) and 1.0 (1.0) at 0.75 → 0.625.
+    let o = lut.apply_interp([0.75, 0.3, 0.2], 1);
+    assert!((o[0] - 0.625).abs() < 1e-6 && (o[1] - 0.3).abs() < 1e-6 && (o[2] - 0.8).abs() < 1e-6, "{o:?}");
+    // Nearest snaps.
+    assert_eq!(lut.apply_interp([0.74, 0.0, 0.0], 0)[0], 0.25);
+    // .3dl (blue fastest, 10-bit integers, mesh line).
+    let mut tdl = String::from("0 511 1023\n");
+    for r in 0..3 {
+        for g in 0..3 {
+            for b in 0..3 {
+                let v = [r, g, b].map(|i| i as f64 * 511.5);
+                tdl += &format!("{} {} {}\n", v[0].round(), v[1].round(), (1023.0 - v[2]).round());
+            }
+        }
+    }
+    let Some(FileXform::Lut { lut, .. }) = parse_file(&tdl, "3dl") else { panic!() };
+    let o = lut.apply_interp([0.25, 0.5, 0.25], 1);
+    assert!((o[0] - 0.25).abs() < 2e-3 && (o[1] - 0.5).abs() < 2e-3 && (o[2] - 0.75).abs() < 2e-3, "{o:?}");
+    // .csp with a squaring pre-LUT on red and an identity 2³ lattice.
+    let mut csp = String::from("CSPLUTV100\n3D\n\n3\n0 0.5 1\n0 0.25 1\n2\n0 1\n0 1\n2\n0 1\n0 1\n\n2 2 2\n");
+    for r in identity_lattice(2, |c| c) {
+        csp += &format!("{} {} {}\n", r[0], r[1], r[2]);
+    }
+    let x = parse_file(&csp, "csp").unwrap();
+    let o = x.apply([0.5, 0.4, 0.6], 2, false, "");
+    assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.4).abs() < 1e-6, "{o:?}");
+    let inv = x.apply(o, 2, true, "");
+    assert!((inv[0] - 0.5).abs() < 1e-4, "{inv:?}");
+    // CDL collection: pick by id.
+    let ccc = r#"<ColorCorrectionCollection><ColorCorrection id="a"><SOPNode><Slope>2 2 2</Slope><Offset>0 0 0</Offset><Power>1 1 1</Power></SOPNode></ColorCorrection>
+            <ColorCorrection id='b'><SOPNode><Slope>0.5 0.5 0.5</Slope></SOPNode><SatNode><Saturation>1</Saturation></SatNode></ColorCorrection></ColorCorrectionCollection>"#;
+    let x = parse_file(ccc, "ccc").unwrap();
+    assert!((x.apply([0.4; 3], 2, false, "b")[0] - 0.2).abs() < 1e-6);
+    assert!((x.apply([0.4; 3], 2, false, "a")[0] - 0.8).abs() < 1e-6);
+    assert!((x.apply([0.4; 3], 2, false, "")[0] - 0.8).abs() < 1e-6);
+    // Effect with inline content; inverse of a 3D lattice.
+    let img = Image::filled(2, 2, [0.6, 0.3, 0.2, 1.0]);
+    let out = run_fx("ec.color.ociofile", &[("file", Value::Str(cube.clone()))], img.clone(), 0.0, EffectEnv::default());
+    let back = run_fx("ec.color.ociofile", &[("file", Value::Str(cube)), ("direction", Value::Enum(1))], out.img, 0.0, EffectEnv::default());
+    assert!((back.img.get(0, 0)[0] - 0.6).abs() < 1e-3, "{:?}", back.img.get(0, 0));
+    assert!(parse_file("garbage", "3dl").is_none());
+}
+
+#[test]
+fn display_and_look_transforms() {
+    // Linear 0.18 through the sRGB display / Standard view = sRGB encoding of 0.18.
+    let img = Image::filled(2, 2, [0.18, 0.18, 0.18, 1.0]);
+    let out = run_fx("ec.color.ociodisplay", &[], img.clone(), 0.0, EffectEnv::default());
+    assert!((out.img.get(0, 0)[0] as f64 - Tf::Srgb.encode(0.18)).abs() < 1e-5);
+    let back = run_fx("ec.color.ociodisplay", &[("direction", Value::Enum(1))], out.img, 0.0, EffectEnv::default());
+    assert!((back.img.get(0, 0)[0] - 0.18).abs() < 1e-5);
+    // Tone mapped view keeps highlights below 1.
+    let hot = Image::filled(1, 1, [8.0, 8.0, 8.0, 1.0]);
+    let tm = run_fx("ec.color.ociodisplay", &[("view", Value::Enum(1))], hot, 0.0, EffectEnv::default());
+    assert!(tm.img.get(0, 0)[0] < 1.0);
+    assert!((tonemap_inv(tonemap(3.0)) - 3.0).abs() < 1e-9);
+    // Looks: Warm raises red over blue; its inverse undoes it.
+    let grey = Image::filled(1, 1, [0.18, 0.18, 0.18, 1.0]);
+    let w = run_fx("ec.color.ociolook", &[("looks", Value::Str("Warm".into()))], grey.clone(), 0.0, EffectEnv::default());
+    let px = w.img.get(0, 0);
+    assert!(px[0] > px[2]);
+    let u = run_fx("ec.color.ociolook", &[("looks", Value::Str("-Warm".into()))], w.img, 0.0, EffectEnv::default());
+    assert!((u.img.get(0, 0)[0] - 0.18).abs() < 1e-4 && (u.img.get(0, 0)[2] - 0.18).abs() < 1e-4);
+    assert_eq!(parse_looks("Warm, -Cool, nope").len(), 2);
+}
+
+#[test]
+fn profile_converter_converts_and_round_trips() {
+    let img = Image::filled(2, 2, [0.8, 0.4, 0.1, 1.0]);
+    // sRGB → Rec. 2020 (relative), then back.
+    let a = run_fx(
+        "ec.utility.colorprofileconverter",
+        &[("inputProfile", Value::Enum(1)), ("outputProfile", Value::Enum(3))],
+        img.clone(),
+        0.0,
+        EffectEnv::default(),
+    );
+    assert_ne!(a.img.data, img.data);
+    let b =
+        run_fx("ec.utility.colorprofileconverter", &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1))], a.img, 0.0, EffectEnv::default());
+    assert!((0..3).all(|k| (b.img.get(0, 0)[k] - img.get(0, 0)[k]).abs() < 1e-4));
+    // Same profile both sides: identity. Working space defaults to sRGB.
+    let c = run_fx(
+        "ec.utility.colorprofileconverter",
+        &[("inputProfile", Value::Enum(0)), ("outputProfile", Value::Enum(1))],
+        img.clone(),
+        0.0,
+        EffectEnv::default(),
+    );
+    assert_eq!(c.img.data, img.data);
+    // Perceptual pulls out-of-gamut colours inside: saturated Rec.2020 green into sRGB.
+    let g = Image::filled(1, 1, [0.0, 1.0, 0.0, 1.0]);
+    let rel = run_fx(
+        "ec.utility.colorprofileconverter",
+        &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1))],
+        g.clone(),
+        0.0,
+        EffectEnv::default(),
+    );
+    assert!(rel.img.get(0, 0)[0] < 0.0);
+    let per = run_fx(
+        "ec.utility.colorprofileconverter",
+        &[("inputProfile", Value::Enum(3)), ("outputProfile", Value::Enum(1)), ("intent", Value::Enum(0))],
+        g,
+        0.0,
+        EffectEnv::default(),
+    );
+    assert!(per.img.get(0, 0).iter().all(|v| *v >= -1e-6));
+}
+
+struct RefHost(Image);
+impl EffectHost for RefHost {
+    fn layer(&self, _: u64, _: bool) -> Option<LayerPixels> {
+        None
+    }
+    fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+        None
+    }
+    fn self_at(&self, _: f64, _: usize) -> Option<Buf> {
+        Some(Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 })
+    }
+}
+
+#[test]
+fn color_stabilizer_matches_the_reference_frame() {
+    let mk = |k: f32, o: f32| {
+        let mut img = Image::new(40, 40);
+        for y in 0..40 {
+            for x in 0..40 {
+                let v = (x as f32 / 40.0) * k + o;
+                img.set(x, y, [v, v * 0.9, v * 0.8, 1.0]);
+            }
+        }
+        img
+    };
+    let reference = mk(1.0, 0.0);
+    let flicker = mk(0.8, 0.1);
+    let host = RefHost(reference.clone());
+    let env = EffectEnv { host: Some(&host), ..Default::default() };
+    let pts = [("blackPoint", Value::Vec2([5.0, 20.0])), ("midPoint", Value::Vec2([20.0, 20.0])), ("whitePoint", Value::Vec2([35.0, 20.0]))];
+    let mut vals: Vec<(&str, Value)> = pts.to_vec();
+    vals.push(("stabilize", Value::Enum(1)));
+    vals.push(("sampleSize", num(1.0)));
+    let out = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, env);
+    for x in [5i64, 20, 35] {
+        let (o, r) = (out.img.get(x, 20), reference.get(x, 20));
+        assert!((o[0] - r[0]).abs() < 0.01, "x {x}: {o:?} vs {r:?}");
+    }
+    // Deterministic, and a no-op without a host.
+    let again = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, env);
+    assert_eq!(out.img.data, again.img.data);
+    let none = run_fx("ec.color.colorstabilizer", &vals, flicker.clone(), 0.0, EffectEnv::default());
+    assert_eq!(none.img.data, flicker.data);
+    // Brightness mode corrects an offset at the black point.
+    let lifted = mk(1.0, 0.1);
+    let mut vals2: Vec<(&str, Value)> = pts.to_vec();
+    vals2.push(("sampleSize", num(1.0)));
+    let b = run_fx("ec.color.colorstabilizer", &vals2, lifted, 0.0, env);
+    assert!((b.img.get(5, 20)[0] - reference.get(5, 20)[0]).abs() < 0.01);
+}
diff --git a/crates/effects/src/ocio_config.rs b/crates/effects/src/ocio_config.rs
index 5ea844414..af860c2fc 100644
--- a/crates/effects/src/ocio_config.rs
+++ b/crates/effects/src/ocio_config.rs
@@ -20,7 +20,7 @@
 //! * `looks` (`name`, `process_space`, `transform`, `inverse_transform`) and look strings
 //!   (`+A, -B`, `A | B` = the first one the config has);
 //! * transforms: `MatrixTransform` (`matrix` 4×4 row-major, `offset`), `FileTransform` (the LUT,
-//!   CDL and matrix files [`super::ocio::parse_file`] reads; `interpolation`, `ccc_id`),
+//!   CDL and matrix files `super::ocio::parse_file` reads; `interpolation`, `ccc_id`),
 //!   `ExponentTransform` (`value`), `ExponentWithLinearTransform` (`gamma`, `offset`, `style:
 //!   mirror`; the power curve with a linear toe that the Academy CLF specification calls
 //!   "moncurve"), `LogTransform` (`base`), `LogAffineTransform` (`base`, `logSideSlope`,
@@ -1331,401 +1331,4 @@ pub fn load_config(src: &str) -> Result<Arc<Config>, String> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    const CONFIG: &str = r#"
-ocio_profile_version: 2
-
-name: Test Config   # a comment
-search_path: "luts:other"
-roles:
-  scene_linear: lin
-  color_timing: "log2"
-
-displays:
-  sRGB:
-    - !<View> {name: Standard, colorspace: gamma22}
-    - !<View> {name: Raw, colorspace: raw}
-
-colorspaces:
-  - !<ColorSpace>
-    name: lin
-    family: ""
-    description: |
-      The reference.
-      Linear.
-    isdata: false
-
-  - !<ColorSpace>
-    name: gamma22
-    aliases: [g22, "gamma 2.2"]
-    to_scene_reference: !<ExponentTransform> {value: [2.2, 2.2, 2.2, 1]}
-
-  - !<ColorSpace>
-    name: half
-    from_reference: !<MatrixTransform> {matrix: [0.5, 0, 0, 0,
-                                                0, 0.5, 0, 0,
-                                                0, 0, 0.5, 0,
-                                                0, 0, 0, 1], offset: [0.1, 0.1, 0.1, 0]}
-
-  - !<ColorSpace>
-    name: log2
-    from_reference: !<GroupTransform>
-      children:
-        - !<MatrixTransform> {matrix: [2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1]}
-        - !<LogTransform> {base: 2}
-
-  - !<ColorSpace>
-    name: affine
-    to_reference: !<LogAffineTransform> {base: 10, logSideSlope: 0.5, logSideOffset: 0.2, linSideSlope: 2, linSideOffset: 0.01, direction: inverse}
-
-  - !<ColorSpace>
-    name: lut
-    to_reference: !<FileTransform> {src: double.cube, interpolation: linear}
-
-  - !<ColorSpace>
-    name: raw
-    isdata: true
-
-  - !<ColorSpace>
-    name: weird
-    to_reference: !<ExposureContrastTransform> {exposure: 1}
-"#;
-
-    fn close(a: [f64; 3], b: [f64; 3], tol: f64) -> bool {
-        (0..3).all(|i| (a[i] - b[i]).abs() < tol)
-    }
-
-    fn temp_dir(name: &str) -> PathBuf {
-        let dir = std::env::temp_dir().join(format!("ec-ocio-{name}-{}", std::process::id()));
-        std::fs::create_dir_all(dir.join("luts")).unwrap();
-        dir
-    }
-
-    #[test]
-    fn yaml_subset() {
-        let y = parse_yaml("a: 1\nb:\n  - x\n  - {k: [1, 2], s: 'q: r'}\nc: !<T> {v: 3}\nd:\n- 4\n- 5\n");
-        assert_eq!(y.get("a").and_then(Yaml::str), Some("1"));
-        assert_eq!(y.get("b").unwrap().seq().len(), 2);
-        assert_eq!(y.get("b").unwrap().seq()[1].get("k").unwrap().nums(), vec![1.0, 2.0]);
-        assert_eq!(y.get("b").unwrap().seq()[1].get("s").and_then(Yaml::str), Some("q: r"));
-        assert_eq!(y.get("c").unwrap().tag(), Some("T"));
-        assert_eq!(y.get("c").unwrap().get("v").and_then(Yaml::str), Some("3"));
-        assert_eq!(y.get("d").unwrap().seq().len(), 2, "a sequence at the key's indent");
-    }
-
-    /// Hostile nesting (flow brackets and block indentation) is cut off instead of exhausting
-    /// the stack.
-    #[test]
-    fn yaml_nesting_is_bounded() {
-        let flow = format!("a: {}\nb: 1\n", "[".repeat(200_000));
-        assert!(matches!(parse_yaml(&flow), Yaml::Map(_)));
-        let block: String = (0..2_000).map(|i| format!("{}k{i}:\n", " ".repeat(i))).collect();
-        assert!(matches!(parse_yaml(&block), Yaml::Map(_)));
-        let dashes: String = (0..2_000).map(|i| format!("{}- x{i}:\n", " ".repeat(2 * i))).collect();
-        let _ = parse_yaml(&dashes);
-        assert!(Config::parse(&flow, Path::new(".")).is_err());
-    }
-
-    #[test]
-    fn parses_spaces_roles_displays_and_converts() {
-        let dir = temp_dir("basic");
-        // A 1D LUT that doubles (0..1 → 0..2).
-        std::fs::write(dir.join("luts/double.cube"), "LUT_1D_SIZE 2\nDOMAIN_MIN 0 0 0\nDOMAIN_MAX 1 1 1\n0 0 0\n2 2 2\n").unwrap();
-        let c = Config::parse(CONFIG, &dir).unwrap();
-        assert_eq!(c.name, "Test Config");
-        assert_eq!(c.search_path, vec!["luts", "other"]);
-        assert_eq!(c.space_names(), vec!["lin", "gamma22", "half", "log2", "affine", "lut", "raw", "weird"]);
-        // Roles and aliases resolve.
-        assert_eq!(c.space("scene_linear").unwrap().name, "lin");
-        assert_eq!(c.space("G22").unwrap().name, "gamma22");
-        assert_eq!(c.space("gamma 2.2").unwrap().name, "gamma22");
-        assert_eq!(c.view("sRGB", "Standard").unwrap().1.colorspace, "gamma22");
-        let sp = |n: &str| c.space(n).unwrap();
-        // gamma22 → lin: decode with the exponent.
-        let g = c.convert(sp("gamma22"), sp("lin"), [0.5, 0.25, 1.0]);
-        assert!(close(g, [0.5f64.powf(2.2), 0.25f64.powf(2.2), 1.0], 1e-9), "{g:?}");
-        // lin → gamma22: the inverse (only to_reference given).
-        let back = c.convert(sp("lin"), sp("gamma22"), g);
-        assert!(close(back, [0.5, 0.25, 1.0], 1e-9), "{back:?}");
-        // The display's view is that conversion.
-        assert!(close(c.display_path(sp("lin"), "sRGB", "Standard").apply(g, false), [0.5, 0.25, 1.0], 1e-9));
-        // lin → half: matrix and offset; and back through the inverse matrix.
-        let h = c.convert(sp("lin"), sp("half"), [0.4, 0.6, 1.0]);
-        assert!(close(h, [0.3, 0.4, 0.6], 1e-9), "{h:?}");
-        assert!(close(c.convert(sp("half"), sp("lin"), h), [0.4, 0.6, 1.0], 1e-9));
-        // lin → log2: a group (×2 then log2): 0.5 → 0; 2 → 2.
-        let l = c.convert(sp("lin"), sp("log2"), [0.5, 2.0, 4.0]);
-        assert!(close(l, [0.0, 2.0, 3.0], 1e-9), "{l:?}");
-        assert!(close(c.convert(sp("log2"), sp("lin"), l), [0.5, 2.0, 4.0], 1e-9));
-        // LogAffine (inverse direction as to_reference) round-trips.
-        let a = c.convert(sp("lin"), sp("affine"), [0.18, 0.5, 1.0]);
-        let expect = [0.18f64, 0.5, 1.0].map(|v| 0.5 * (2.0 * v + 0.01).log10() + 0.2);
-        assert!(close(a, expect, 1e-9), "{a:?} vs {expect:?}");
-        assert!(close(c.convert(sp("affine"), sp("lin"), a), [0.18, 0.5, 1.0], 1e-9));
-        // FileTransform found on the search path.
-        let f = c.convert(sp("lut"), sp("lin"), [0.25, 0.5, 0.0]);
-        assert!(close(f, [0.5, 1.0, 0.0], 1e-6), "{f:?}");
-        // Data spaces pass through; unsupported transforms are reported.
-        assert_eq!(c.convert(sp("raw"), sp("gamma22"), [0.3, 0.3, 0.3]), [0.3, 0.3, 0.3]);
-        assert_eq!(c.unsupported(), vec!["ExposureContrastTransform".to_string()]);
-        assert_eq!(c.path(sp("lin"), sp("weird")).unsupported_list(), vec!["ExposureContrastTransform".to_string()]);
-        assert!(c.path(sp("lin"), sp("half")).unsupported_list().is_empty());
-        // Loading from a file path (cached), and errors.
-        std::fs::write(dir.join("config.ocio"), CONFIG).unwrap();
-        let loaded = load_config(&dir.join("config.ocio").to_string_lossy()).unwrap();
-        assert_eq!(loaded.spaces.len(), 8);
-        assert!(load_config("/no/such/config.ocio").is_err());
-        assert!(Config::parse("just: text\n", &dir).is_err());
-    }
-
-    /// The OCIO Color Space and Display Transform effects with Configuration ▸ Custom.
-    #[test]
-    fn effects_use_a_custom_config() {
-        use effectcraft_keyframe::Value;
-        let cfg = "ocio_profile_version: 1\nroles:\n  default: lin\ndisplays:\n  Monitor:\n    - !<View> {name: Video, colorspace: g2}\ncolorspaces:\n  - !<ColorSpace>\n    name: lin\n  - !<ColorSpace>\n    name: g2\n    to_reference: !<ExponentTransform> {value: [2, 2, 2, 1]}\n";
-        let img = crate::Image::filled(2, 2, [0.5, 0.25, 1.0, 1.0]);
-        let fx = |id: &str, extra: &[(&str, Value)]| {
-            let mut v = vec![("config", Value::Enum(1)), ("configFile", Value::Str(cfg.into()))];
-            v.extend(extra.iter().cloned());
-            crate::run_fx(id, &v, img.clone(), 0.0, crate::EffectEnv::default()).img.data[0]
-        };
-        let o = fx("ec.color.ociocolorspace", &[("sourceName", Value::Str("g2".into())), ("destinationName", Value::Str("default".into()))]);
-        assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.0625).abs() < 1e-6 && (o[2] - 1.0).abs() < 1e-6, "{o:?}");
-        // Inverse direction.
-        let o = fx(
-            "ec.color.ociocolorspace",
-            &[("sourceName", Value::Str("g2".into())), ("destinationName", Value::Str("lin".into())), ("direction", Value::Enum(1))],
-        );
-        assert!((o[0] - 0.5f32.sqrt()).abs() < 1e-6, "{o:?}");
-        // Display ▸ view → its colour space.
-        let o = fx(
-            "ec.color.ociodisplay",
-            &[("sourceName", Value::Str("lin".into())), ("displayName", Value::Str("Monitor".into())), ("viewName", Value::Str("Video".into()))],
-        );
-        assert!((o[0] - 0.5f32.sqrt()).abs() < 1e-6, "{o:?}");
-        // An unreadable config leaves pixels alone.
-        let o = crate::run_fx(
-            "ec.color.ociocolorspace",
-            &[("config", Value::Enum(1)), ("configFile", Value::Str("/missing.ocio".into()))],
-            img.clone(),
-            0.0,
-            crate::EffectEnv::default(),
-        );
-        assert_eq!(o.img.data, img.data);
-    }
-
-    /// A config laid out like Blender 4.x / 5.x's (written for this test): the reference space is
-    /// CIE XYZ with the E white, the D65 spaces adapt through a `.spimtx` matrix, sRGB is a
-    /// ColorSpaceTransform plus an ExponentWithLinearTransform, the display-referred spaces meet
-    /// the scene through the default view transform, and a log space uses an
-    /// AllocationTransform.
-    fn blender_like(dir: &Path) -> Config {
-        use effectcraft_color::space::{invert, rgb_to_xyz};
-        let e_to_d65 = crate::ocio::bradford([1.0 / 3.0, 1.0 / 3.0], D65);
-        let rows = |m: [[f64; 3]; 3], sep: &str, end: &str| m.iter().map(|r| format!("{}{sep}{}{sep}{}{end}", r[0], r[1], r[2])).collect::<Vec<_>>();
-        std::fs::write(dir.join("luts/e_to_d65.spimtx"), rows(e_to_d65, " ", " 0\n").concat()).unwrap();
-        let xyz_to_709 = rows(invert(&rgb_to_xyz(REC709, D65)), ", ", ", 0").join(", ");
-        let text = format!(
-            r#"ocio_profile_version: 2.4
-search_path: luts
-roles:
-  reference: Linear CIE-XYZ E
-  scene_linear: Linear Rec.709
-  cie_xyz_d65_interchange: XYZ D65 Display
-default_view_transform: Standard
-view_transforms:
-  - !<ViewTransform>
-    name: Standard
-    from_scene_reference: !<FileTransform> {{src: e_to_d65.spimtx, interpolation: linear}}
-displays:
-  sRGB:
-    - !<View> {{name: Standard, colorspace: sRGB}}
-    - !<View> {{name: Display, view_transform: Standard, display_colorspace: sRGB Display}}
-    - !<View> {{name: Log, colorspace: Log Encoding}}
-    - !<View> {{name: Log Brighter, colorspace: Log Encoding, looks: +Brighter}}
-    - !<View> {{name: Log Darker, colorspace: Log Encoding, looks: "-Brighter, Missing"}}
-    - !<View> {{name: Raw, colorspace: Non-Color}}
-display_colorspaces:
-  - !<ColorSpace>
-    name: XYZ D65 Display
-    isdata: false
-  - !<ColorSpace>
-    name: sRGB Display
-    from_display_reference: !<GroupTransform>
-      children:
-        - !<ColorSpaceTransform> {{src: cie_xyz_d65_interchange, dst: Linear Rec.709}}
-        - !<ExponentWithLinearTransform> {{gamma: 2.4, offset: 0.055, direction: inverse}}
-colorspaces:
-  - !<ColorSpace>
-    name: Linear CIE-XYZ E
-    aliases: [Linear CIE-XYZ I-E]
-  - !<ColorSpace>
-    name: Linear CIE-XYZ D65
-    from_scene_reference: !<FileTransform> {{src: e_to_d65.spimtx, interpolation: linear}}
-  - !<ColorSpace>
-    name: Linear Rec.709
-    from_scene_reference: !<GroupTransform>
-      children:
-        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ I-E, dst: Linear CIE-XYZ D65}}
-        - !<MatrixTransform> {{matrix: [{xyz_to_709}, 0, 0, 0, 1]}}
-  - !<ColorSpace>
-    name: sRGB
-    from_scene_reference: !<GroupTransform>
-      children:
-        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Linear Rec.709}}
-        - !<ExponentWithLinearTransform> {{gamma: 2.4, offset: 0.055, direction: inverse}}
-  - !<ColorSpace>
-    name: Log Encoding
-    from_scene_reference: !<GroupTransform>
-      children:
-        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Linear Rec.709}}
-        - !<AllocationTransform> {{allocation: lg2, vars: [-12, 12]}}
-  - !<ColorSpace>
-    name: ACEScg
-    from_scene_reference: !<GroupTransform>
-      children:
-        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Linear CIE-XYZ D65}}
-        - !<BuiltinTransform> {{style: "UTILITY - ACES-AP1_to_CIE-XYZ-D65_BFD", direction: inverse}}
-  - !<ColorSpace>
-    name: Clipped
-    from_scene_reference: !<GroupTransform>
-      children:
-        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Linear Rec.709}}
-        - !<RangeTransform> {{min_in_value: 0, min_out_value: 0}}
-  - !<ColorSpace>
-    name: Graded
-    from_scene_reference: !<GroupTransform>
-      children:
-        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Linear Rec.709}}
-        - !<GradingToneTransform>
-         shadows: {{rgb: [0.2, 0.2, 0.2], master: 0.35, start: 0.4, pivot: 0.1}}
-  - !<ColorSpace>
-    name: Loop
-    from_scene_reference: !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Loop}}
-  - !<ColorSpace>
-    name: Fan
-    from_scene_reference: !<GroupTransform>
-      children:
-        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Fan}}
-        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Fan}}
-        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Fan}}
-  - !<ColorSpace>
-    name: Non-Color
-    isdata: true
-looks:
-  - !<Look>
-    name: Brighter
-    process_space: Log Encoding
-    transform: !<CDLTransform> {{offset: [0.05, 0.05, 0.05]}}
-"#
-        );
-        Config::parse(&text, dir).unwrap()
-    }
-
-    /// The sRGB encoding (IEC 61966-2-1).
-    fn srgb(v: f64) -> f64 {
-        if v <= 0.003_130_8 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 }
-    }
-
-    /// #410: with Blender's config, Linear Rec.709 → sRGB got no sRGB curve and a blue cast:
-    /// ColorSpaceTransform and ExponentWithLinearTransform passed colours through, so the
-    /// colours stayed in the E-white XYZ reference. Every route to sRGB now encodes greys to
-    /// neutral sRGB values (0.18 → 0.4614).
-    #[test]
-    fn blender_like_config_converts_linear_rec709_to_srgb() {
-        let dir = temp_dir("blender");
-        let c = blender_like(&dir);
-        assert!(c.unsupported().iter().all(|t| t == "GradingToneTransform"), "{:?}", c.unsupported());
-        let sp = |n: &str| c.space(n).unwrap();
-        let lin = sp("scene_linear");
-        let routes = [
-            ("Color Space Transform", c.path(lin, sp("sRGB"))),
-            ("display-referred sRGB", c.path(lin, sp("sRGB Display"))),
-            ("v1 view", c.display_path(lin, "sRGB", "Standard")),
-            ("v2 view", c.display_path(lin, "sRGB", "Display")),
-        ];
-        for (route, x) in &routes {
-            assert!(x.unsupported_list().is_empty(), "{route}: {:?}", x.unsupported_list());
-            for v in [0.0, 0.001, 0.18, 0.5, 1.0, 4.0] {
-                let o = x.apply([v; 3], false);
-                assert!(close(o, [srgb(v); 3], 2e-5), "{route}: {v} → {o:?}, want {}", srgb(v));
-            }
-            let red = x.apply([1.0, 0.0, 0.0], false);
-            assert!(close(red, [1.0, 0.0, 0.0], 1e-4), "{route}: red {red:?}");
-            // And back.
-            assert!(close(x.apply([srgb(0.18); 3], true), [0.18; 3], 1e-6), "{route}");
-        }
-        // AllocationTransform lg2 and a look in its process space; data passes through.
-        let log = |v: f64| (v.log2() + 12.0) / 24.0;
-        let o = c.display_path(lin, "sRGB", "Log").apply([0.18; 3], false);
-        assert!(close(o, [log(0.18); 3], 1e-6), "{o:?}");
-        let o = c.display_path(lin, "sRGB", "Log Brighter").apply([0.18; 3], false);
-        assert!(close(o, [log(0.18) + 0.05; 3], 1e-6), "{o:?}");
-        let darker = c.display_path(lin, "sRGB", "Log Darker");
-        assert!(close(darker.apply([0.18; 3], false), [log(0.18) - 0.05; 3], 1e-6));
-        assert_eq!(darker.unsupported_list(), vec!["Look `Missing` (not in the config)".to_string()]);
-        assert_eq!(c.display_path(lin, "sRGB", "Raw").apply([0.3, 2.0, -1.0], false), [0.3, 2.0, -1.0]);
-        // BuiltinTransform: the built-in config's Linear Rec.709 → ACEScg.
-        let want = crate::ocio::Xform::new(&sp_builtin("Linear Rec.709 (sRGB)"), &sp_builtin("ACEScg")).apply([1.0, 0.25, 0.0]);
-        let got = c.convert(lin, sp("ACEScg"), [1.0, 0.25, 0.0]);
-        assert!(close(got, want.map(f64::from), 1e-4), "{got:?} vs {want:?}");
-        // RangeTransform with only a minimum clamps below and shifts nothing.
-        let o = c.convert(lin, sp("Clipped"), [-0.5, 0.5, 2.0]);
-        assert!(close(o, [0.0, 0.5, 2.0], 1e-6), "{o:?}");
-        // Unsupported steps are listed (and pass through); loops stop.
-        assert_eq!(c.path(lin, sp("Graded")).unsupported_list(), vec!["GradingToneTransform".to_string()]);
-        assert!(c.path(lin, sp("Loop")).unsupported_list()[0].contains("nested"));
-        let fan = c.path(lin, sp("Fan"));
-        assert!(!fan.unsupported_list().is_empty());
-        assert!(matches!(&fan, Xf::Group(v) if v.len() <= MAX_OPS + 1));
-    }
-
-    fn sp_builtin(name: &str) -> Space {
-        *crate::ocio::SPACES.iter().find(|s| s.name == name).unwrap()
-    }
-
-    /// ExponentWithLinearTransform is the sRGB curve at gamma 2.4 / offset 0.055, continuous at
-    /// its break point and inverted exactly; mirror mirrors negatives.
-    #[test]
-    fn moncurve_matches_srgb_and_inverts() {
-        for v in [-0.2, 0.0, 0.002, 0.039, 0.0393, 0.2, 0.5, 1.0, 3.0] {
-            let lin = moncurve(v, 2.4, 0.055, false, false);
-            assert!((moncurve(lin, 2.4, 0.055, true, false) - v).abs() < 1e-12, "{v}");
-            if v >= 0.0 {
-                assert!((moncurve(srgb(v), 2.4, 0.055, false, false) - v).abs() < 2e-5, "{v}");
-            }
-        }
-        let xb = 0.055 / 1.4;
-        assert!((moncurve(xb - 1e-12, 2.4, 0.055, false, false) - moncurve(xb + 1e-12, 2.4, 0.055, false, false)).abs() < 1e-9);
-        assert_eq!(moncurve(-0.5, 2.4, 0.055, false, true), -moncurve(0.5, 2.4, 0.055, false, false));
-        assert_eq!(moncurve(-0.5, 1.0, 0.0, false, false), 0.0);
-    }
-
-    #[test]
-    fn builtin_styles() {
-        for style in ["IDENTITY", "DISPLAY - CIE-XYZ-D65_to_sRGB", "display - cie-xyz-d65_to_rec.2100-pq", "ACEScc_to_ACES2065-1", "ACEScct_to_ACES2065-1"] {
-            assert!(builtin(style).is_some(), "{style}");
-        }
-        assert!(builtin("ACES-OUTPUT - ACES2065-1_to_CIE-XYZ-D65 - SDR-VIDEO_1.0").is_none());
-        // D65 white in XYZ is display white.
-        let xyz = rgb_white_xyz();
-        for style in ["DISPLAY - CIE-XYZ-D65_to_sRGB", "DISPLAY - CIE-XYZ-D65_to_REC.1886-REC.709", "DISPLAY - CIE-XYZ-D65_to_DisplayP3"] {
-            let o = builtin(style).unwrap().apply(xyz, false);
-            assert!(close(o, [1.0; 3], 1e-6), "{style}: {o:?}");
-        }
-        // PQ: 1.0 = 100 nits → code value ≈ 0.508.
-        let pq = builtin("DISPLAY - CIE-XYZ-D65_to_REC.2100-PQ").unwrap().apply(xyz, false);
-        assert!((pq[0] - 0.508).abs() < 1e-3, "{pq:?}");
-        // ACEScc and ACEScct of 0.18 (ACES2065-1 grey stays grey).
-        for (style, code) in [("ACEScc_to_ACES2065-1", 0.413_588_402_492_442_1), ("ACEScct_to_ACES2065-1", 0.413_588_402_492_442_1)] {
-            let o = builtin(style).unwrap().apply([code; 3], false);
-            assert!(close(o, [0.18; 3], 1e-6), "{style}: {o:?}");
-        }
-    }
-
-    fn rgb_white_xyz() -> [f64; 3] {
-        [D65[0] / D65[1], 1.0, (1.0 - D65[0] - D65[1]) / D65[1]]
-    }
-}
+mod tests;
diff --git a/crates/effects/src/ocio_config/tests.rs b/crates/effects/src/ocio_config/tests.rs
new file mode 100644
index 000000000..f534fe0e2
--- /dev/null
+++ b/crates/effects/src/ocio_config/tests.rs
@@ -0,0 +1,394 @@
+use super::*;
+
+const CONFIG: &str = r#"
+ocio_profile_version: 2
+
+name: Test Config   # a comment
+search_path: "luts:other"
+roles:
+  scene_linear: lin
+  color_timing: "log2"
+
+displays:
+  sRGB:
+    - !<View> {name: Standard, colorspace: gamma22}
+    - !<View> {name: Raw, colorspace: raw}
+
+colorspaces:
+  - !<ColorSpace>
+    name: lin
+    family: ""
+    description: |
+      The reference.
+      Linear.
+    isdata: false
+
+  - !<ColorSpace>
+    name: gamma22
+    aliases: [g22, "gamma 2.2"]
+    to_scene_reference: !<ExponentTransform> {value: [2.2, 2.2, 2.2, 1]}
+
+  - !<ColorSpace>
+    name: half
+    from_reference: !<MatrixTransform> {matrix: [0.5, 0, 0, 0,
+                                                0, 0.5, 0, 0,
+                                                0, 0, 0.5, 0,
+                                                0, 0, 0, 1], offset: [0.1, 0.1, 0.1, 0]}
+
+  - !<ColorSpace>
+    name: log2
+    from_reference: !<GroupTransform>
+      children:
+        - !<MatrixTransform> {matrix: [2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1]}
+        - !<LogTransform> {base: 2}
+
+  - !<ColorSpace>
+    name: affine
+    to_reference: !<LogAffineTransform> {base: 10, logSideSlope: 0.5, logSideOffset: 0.2, linSideSlope: 2, linSideOffset: 0.01, direction: inverse}
+
+  - !<ColorSpace>
+    name: lut
+    to_reference: !<FileTransform> {src: double.cube, interpolation: linear}
+
+  - !<ColorSpace>
+    name: raw
+    isdata: true
+
+  - !<ColorSpace>
+    name: weird
+    to_reference: !<ExposureContrastTransform> {exposure: 1}
+"#;
+
+fn close(a: [f64; 3], b: [f64; 3], tol: f64) -> bool {
+    (0..3).all(|i| (a[i] - b[i]).abs() < tol)
+}
+
+fn temp_dir(name: &str) -> PathBuf {
+    let dir = std::env::temp_dir().join(format!("ec-ocio-{name}-{}", std::process::id()));
+    std::fs::create_dir_all(dir.join("luts")).unwrap();
+    dir
+}
+
+#[test]
+fn yaml_subset() {
+    let y = parse_yaml("a: 1\nb:\n  - x\n  - {k: [1, 2], s: 'q: r'}\nc: !<T> {v: 3}\nd:\n- 4\n- 5\n");
+    assert_eq!(y.get("a").and_then(Yaml::str), Some("1"));
+    assert_eq!(y.get("b").unwrap().seq().len(), 2);
+    assert_eq!(y.get("b").unwrap().seq()[1].get("k").unwrap().nums(), vec![1.0, 2.0]);
+    assert_eq!(y.get("b").unwrap().seq()[1].get("s").and_then(Yaml::str), Some("q: r"));
+    assert_eq!(y.get("c").unwrap().tag(), Some("T"));
+    assert_eq!(y.get("c").unwrap().get("v").and_then(Yaml::str), Some("3"));
+    assert_eq!(y.get("d").unwrap().seq().len(), 2, "a sequence at the key's indent");
+}
+
+/// Hostile nesting (flow brackets and block indentation) is cut off instead of exhausting
+/// the stack.
+#[test]
+fn yaml_nesting_is_bounded() {
+    let flow = format!("a: {}\nb: 1\n", "[".repeat(200_000));
+    assert!(matches!(parse_yaml(&flow), Yaml::Map(_)));
+    let block: String = (0..2_000).map(|i| format!("{}k{i}:\n", " ".repeat(i))).collect();
+    assert!(matches!(parse_yaml(&block), Yaml::Map(_)));
+    let dashes: String = (0..2_000).map(|i| format!("{}- x{i}:\n", " ".repeat(2 * i))).collect();
+    let _ = parse_yaml(&dashes);
+    assert!(Config::parse(&flow, Path::new(".")).is_err());
+}
+
+#[test]
+fn parses_spaces_roles_displays_and_converts() {
+    let dir = temp_dir("basic");
+    // A 1D LUT that doubles (0..1 → 0..2).
+    std::fs::write(dir.join("luts/double.cube"), "LUT_1D_SIZE 2\nDOMAIN_MIN 0 0 0\nDOMAIN_MAX 1 1 1\n0 0 0\n2 2 2\n").unwrap();
+    let c = Config::parse(CONFIG, &dir).unwrap();
+    assert_eq!(c.name, "Test Config");
+    assert_eq!(c.search_path, vec!["luts", "other"]);
+    assert_eq!(c.space_names(), vec!["lin", "gamma22", "half", "log2", "affine", "lut", "raw", "weird"]);
+    // Roles and aliases resolve.
+    assert_eq!(c.space("scene_linear").unwrap().name, "lin");
+    assert_eq!(c.space("G22").unwrap().name, "gamma22");
+    assert_eq!(c.space("gamma 2.2").unwrap().name, "gamma22");
+    assert_eq!(c.view("sRGB", "Standard").unwrap().1.colorspace, "gamma22");
+    let sp = |n: &str| c.space(n).unwrap();
+    // gamma22 → lin: decode with the exponent.
+    let g = c.convert(sp("gamma22"), sp("lin"), [0.5, 0.25, 1.0]);
+    assert!(close(g, [0.5f64.powf(2.2), 0.25f64.powf(2.2), 1.0], 1e-9), "{g:?}");
+    // lin → gamma22: the inverse (only to_reference given).
+    let back = c.convert(sp("lin"), sp("gamma22"), g);
+    assert!(close(back, [0.5, 0.25, 1.0], 1e-9), "{back:?}");
+    // The display's view is that conversion.
+    assert!(close(c.display_path(sp("lin"), "sRGB", "Standard").apply(g, false), [0.5, 0.25, 1.0], 1e-9));
+    // lin → half: matrix and offset; and back through the inverse matrix.
+    let h = c.convert(sp("lin"), sp("half"), [0.4, 0.6, 1.0]);
+    assert!(close(h, [0.3, 0.4, 0.6], 1e-9), "{h:?}");
+    assert!(close(c.convert(sp("half"), sp("lin"), h), [0.4, 0.6, 1.0], 1e-9));
+    // lin → log2: a group (×2 then log2): 0.5 → 0; 2 → 2.
+    let l = c.convert(sp("lin"), sp("log2"), [0.5, 2.0, 4.0]);
+    assert!(close(l, [0.0, 2.0, 3.0], 1e-9), "{l:?}");
+    assert!(close(c.convert(sp("log2"), sp("lin"), l), [0.5, 2.0, 4.0], 1e-9));
+    // LogAffine (inverse direction as to_reference) round-trips.
+    let a = c.convert(sp("lin"), sp("affine"), [0.18, 0.5, 1.0]);
+    let expect = [0.18f64, 0.5, 1.0].map(|v| 0.5 * (2.0 * v + 0.01).log10() + 0.2);
+    assert!(close(a, expect, 1e-9), "{a:?} vs {expect:?}");
+    assert!(close(c.convert(sp("affine"), sp("lin"), a), [0.18, 0.5, 1.0], 1e-9));
+    // FileTransform found on the search path.
+    let f = c.convert(sp("lut"), sp("lin"), [0.25, 0.5, 0.0]);
+    assert!(close(f, [0.5, 1.0, 0.0], 1e-6), "{f:?}");
+    // Data spaces pass through; unsupported transforms are reported.
+    assert_eq!(c.convert(sp("raw"), sp("gamma22"), [0.3, 0.3, 0.3]), [0.3, 0.3, 0.3]);
+    assert_eq!(c.unsupported(), vec!["ExposureContrastTransform".to_string()]);
+    assert_eq!(c.path(sp("lin"), sp("weird")).unsupported_list(), vec!["ExposureContrastTransform".to_string()]);
+    assert!(c.path(sp("lin"), sp("half")).unsupported_list().is_empty());
+    // Loading from a file path (cached), and errors.
+    std::fs::write(dir.join("config.ocio"), CONFIG).unwrap();
+    let loaded = load_config(&dir.join("config.ocio").to_string_lossy()).unwrap();
+    assert_eq!(loaded.spaces.len(), 8);
+    assert!(load_config("/no/such/config.ocio").is_err());
+    assert!(Config::parse("just: text\n", &dir).is_err());
+}
+
+/// The OCIO Color Space and Display Transform effects with Configuration ▸ Custom.
+#[test]
+fn effects_use_a_custom_config() {
+    use effectcraft_keyframe::Value;
+    let cfg = "ocio_profile_version: 1\nroles:\n  default: lin\ndisplays:\n  Monitor:\n    - !<View> {name: Video, colorspace: g2}\ncolorspaces:\n  - !<ColorSpace>\n    name: lin\n  - !<ColorSpace>\n    name: g2\n    to_reference: !<ExponentTransform> {value: [2, 2, 2, 1]}\n";
+    let img = crate::Image::filled(2, 2, [0.5, 0.25, 1.0, 1.0]);
+    let fx = |id: &str, extra: &[(&str, Value)]| {
+        let mut v = vec![("config", Value::Enum(1)), ("configFile", Value::Str(cfg.into()))];
+        v.extend(extra.iter().cloned());
+        crate::run_fx(id, &v, img.clone(), 0.0, crate::EffectEnv::default()).img.data[0]
+    };
+    let o = fx("ec.color.ociocolorspace", &[("sourceName", Value::Str("g2".into())), ("destinationName", Value::Str("default".into()))]);
+    assert!((o[0] - 0.25).abs() < 1e-6 && (o[1] - 0.0625).abs() < 1e-6 && (o[2] - 1.0).abs() < 1e-6, "{o:?}");
+    // Inverse direction.
+    let o =
+        fx("ec.color.ociocolorspace", &[("sourceName", Value::Str("g2".into())), ("destinationName", Value::Str("lin".into())), ("direction", Value::Enum(1))]);
+    assert!((o[0] - 0.5f32.sqrt()).abs() < 1e-6, "{o:?}");
+    // Display ▸ view → its colour space.
+    let o = fx(
+        "ec.color.ociodisplay",
+        &[("sourceName", Value::Str("lin".into())), ("displayName", Value::Str("Monitor".into())), ("viewName", Value::Str("Video".into()))],
+    );
+    assert!((o[0] - 0.5f32.sqrt()).abs() < 1e-6, "{o:?}");
+    // An unreadable config leaves pixels alone.
+    let o = crate::run_fx(
+        "ec.color.ociocolorspace",
+        &[("config", Value::Enum(1)), ("configFile", Value::Str("/missing.ocio".into()))],
+        img.clone(),
+        0.0,
+        crate::EffectEnv::default(),
+    );
+    assert_eq!(o.img.data, img.data);
+}
+
+/// A config laid out like Blender 4.x / 5.x's (written for this test): the reference space is
+/// CIE XYZ with the E white, the D65 spaces adapt through a `.spimtx` matrix, sRGB is a
+/// ColorSpaceTransform plus an ExponentWithLinearTransform, the display-referred spaces meet
+/// the scene through the default view transform, and a log space uses an
+/// AllocationTransform.
+fn blender_like(dir: &Path) -> Config {
+    use effectcraft_color::space::{invert, rgb_to_xyz};
+    let e_to_d65 = crate::ocio::bradford([1.0 / 3.0, 1.0 / 3.0], D65);
+    let rows = |m: [[f64; 3]; 3], sep: &str, end: &str| m.iter().map(|r| format!("{}{sep}{}{sep}{}{end}", r[0], r[1], r[2])).collect::<Vec<_>>();
+    std::fs::write(dir.join("luts/e_to_d65.spimtx"), rows(e_to_d65, " ", " 0\n").concat()).unwrap();
+    let xyz_to_709 = rows(invert(&rgb_to_xyz(REC709, D65)), ", ", ", 0").join(", ");
+    let text = format!(
+        r#"ocio_profile_version: 2.4
+search_path: luts
+roles:
+  reference: Linear CIE-XYZ E
+  scene_linear: Linear Rec.709
+  cie_xyz_d65_interchange: XYZ D65 Display
+default_view_transform: Standard
+view_transforms:
+  - !<ViewTransform>
+    name: Standard
+    from_scene_reference: !<FileTransform> {{src: e_to_d65.spimtx, interpolation: linear}}
+displays:
+  sRGB:
+    - !<View> {{name: Standard, colorspace: sRGB}}
+    - !<View> {{name: Display, view_transform: Standard, display_colorspace: sRGB Display}}
+    - !<View> {{name: Log, colorspace: Log Encoding}}
+    - !<View> {{name: Log Brighter, colorspace: Log Encoding, looks: +Brighter}}
+    - !<View> {{name: Log Darker, colorspace: Log Encoding, looks: "-Brighter, Missing"}}
+    - !<View> {{name: Raw, colorspace: Non-Color}}
+display_colorspaces:
+  - !<ColorSpace>
+    name: XYZ D65 Display
+    isdata: false
+  - !<ColorSpace>
+    name: sRGB Display
+    from_display_reference: !<GroupTransform>
+      children:
+        - !<ColorSpaceTransform> {{src: cie_xyz_d65_interchange, dst: Linear Rec.709}}
+        - !<ExponentWithLinearTransform> {{gamma: 2.4, offset: 0.055, direction: inverse}}
+colorspaces:
+  - !<ColorSpace>
+    name: Linear CIE-XYZ E
+    aliases: [Linear CIE-XYZ I-E]
+  - !<ColorSpace>
+    name: Linear CIE-XYZ D65
+    from_scene_reference: !<FileTransform> {{src: e_to_d65.spimtx, interpolation: linear}}
+  - !<ColorSpace>
+    name: Linear Rec.709
+    from_scene_reference: !<GroupTransform>
+      children:
+        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ I-E, dst: Linear CIE-XYZ D65}}
+        - !<MatrixTransform> {{matrix: [{xyz_to_709}, 0, 0, 0, 1]}}
+  - !<ColorSpace>
+    name: sRGB
+    from_scene_reference: !<GroupTransform>
+      children:
+        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Linear Rec.709}}
+        - !<ExponentWithLinearTransform> {{gamma: 2.4, offset: 0.055, direction: inverse}}
+  - !<ColorSpace>
+    name: Log Encoding
+    from_scene_reference: !<GroupTransform>
+      children:
+        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Linear Rec.709}}
+        - !<AllocationTransform> {{allocation: lg2, vars: [-12, 12]}}
+  - !<ColorSpace>
+    name: ACEScg
+    from_scene_reference: !<GroupTransform>
+      children:
+        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Linear CIE-XYZ D65}}
+        - !<BuiltinTransform> {{style: "UTILITY - ACES-AP1_to_CIE-XYZ-D65_BFD", direction: inverse}}
+  - !<ColorSpace>
+    name: Clipped
+    from_scene_reference: !<GroupTransform>
+      children:
+        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Linear Rec.709}}
+        - !<RangeTransform> {{min_in_value: 0, min_out_value: 0}}
+  - !<ColorSpace>
+    name: Graded
+    from_scene_reference: !<GroupTransform>
+      children:
+        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Linear Rec.709}}
+        - !<GradingToneTransform>
+         shadows: {{rgb: [0.2, 0.2, 0.2], master: 0.35, start: 0.4, pivot: 0.1}}
+  - !<ColorSpace>
+    name: Loop
+    from_scene_reference: !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Loop}}
+  - !<ColorSpace>
+    name: Fan
+    from_scene_reference: !<GroupTransform>
+      children:
+        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Fan}}
+        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Fan}}
+        - !<ColorSpaceTransform> {{src: Linear CIE-XYZ E, dst: Fan}}
+  - !<ColorSpace>
+    name: Non-Color
+    isdata: true
+looks:
+  - !<Look>
+    name: Brighter
+    process_space: Log Encoding
+    transform: !<CDLTransform> {{offset: [0.05, 0.05, 0.05]}}
+"#
+    );
+    Config::parse(&text, dir).unwrap()
+}
+
+/// The sRGB encoding (IEC 61966-2-1).
+fn srgb(v: f64) -> f64 {
+    if v <= 0.003_130_8 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 }
+}
+
+/// #410: with Blender's config, Linear Rec.709 → sRGB got no sRGB curve and a blue cast:
+/// ColorSpaceTransform and ExponentWithLinearTransform passed colours through, so the
+/// colours stayed in the E-white XYZ reference. Every route to sRGB now encodes greys to
+/// neutral sRGB values (0.18 → 0.4614).
+#[test]
+fn blender_like_config_converts_linear_rec709_to_srgb() {
+    let dir = temp_dir("blender");
+    let c = blender_like(&dir);
+    assert!(c.unsupported().iter().all(|t| t == "GradingToneTransform"), "{:?}", c.unsupported());
+    let sp = |n: &str| c.space(n).unwrap();
+    let lin = sp("scene_linear");
+    let routes = [
+        ("Color Space Transform", c.path(lin, sp("sRGB"))),
+        ("display-referred sRGB", c.path(lin, sp("sRGB Display"))),
+        ("v1 view", c.display_path(lin, "sRGB", "Standard")),
+        ("v2 view", c.display_path(lin, "sRGB", "Display")),
+    ];
+    for (route, x) in &routes {
+        assert!(x.unsupported_list().is_empty(), "{route}: {:?}", x.unsupported_list());
+        for v in [0.0, 0.001, 0.18, 0.5, 1.0, 4.0] {
+            let o = x.apply([v; 3], false);
+            assert!(close(o, [srgb(v); 3], 2e-5), "{route}: {v} → {o:?}, want {}", srgb(v));
+        }
+        let red = x.apply([1.0, 0.0, 0.0], false);
+        assert!(close(red, [1.0, 0.0, 0.0], 1e-4), "{route}: red {red:?}");
+        // And back.
+        assert!(close(x.apply([srgb(0.18); 3], true), [0.18; 3], 1e-6), "{route}");
+    }
+    // AllocationTransform lg2 and a look in its process space; data passes through.
+    let log = |v: f64| (v.log2() + 12.0) / 24.0;
+    let o = c.display_path(lin, "sRGB", "Log").apply([0.18; 3], false);
+    assert!(close(o, [log(0.18); 3], 1e-6), "{o:?}");
+    let o = c.display_path(lin, "sRGB", "Log Brighter").apply([0.18; 3], false);
+    assert!(close(o, [log(0.18) + 0.05; 3], 1e-6), "{o:?}");
+    let darker = c.display_path(lin, "sRGB", "Log Darker");
+    assert!(close(darker.apply([0.18; 3], false), [log(0.18) - 0.05; 3], 1e-6));
+    assert_eq!(darker.unsupported_list(), vec!["Look `Missing` (not in the config)".to_string()]);
+    assert_eq!(c.display_path(lin, "sRGB", "Raw").apply([0.3, 2.0, -1.0], false), [0.3, 2.0, -1.0]);
+    // BuiltinTransform: the built-in config's Linear Rec.709 → ACEScg.
+    let want = crate::ocio::Xform::new(&sp_builtin("Linear Rec.709 (sRGB)"), &sp_builtin("ACEScg")).apply([1.0, 0.25, 0.0]);
+    let got = c.convert(lin, sp("ACEScg"), [1.0, 0.25, 0.0]);
+    assert!(close(got, want.map(f64::from), 1e-4), "{got:?} vs {want:?}");
+    // RangeTransform with only a minimum clamps below and shifts nothing.
+    let o = c.convert(lin, sp("Clipped"), [-0.5, 0.5, 2.0]);
+    assert!(close(o, [0.0, 0.5, 2.0], 1e-6), "{o:?}");
+    // Unsupported steps are listed (and pass through); loops stop.
+    assert_eq!(c.path(lin, sp("Graded")).unsupported_list(), vec!["GradingToneTransform".to_string()]);
+    assert!(c.path(lin, sp("Loop")).unsupported_list()[0].contains("nested"));
+    let fan = c.path(lin, sp("Fan"));
+    assert!(!fan.unsupported_list().is_empty());
+    assert!(matches!(&fan, Xf::Group(v) if v.len() <= MAX_OPS + 1));
+}
+
+fn sp_builtin(name: &str) -> Space {
+    *crate::ocio::SPACES.iter().find(|s| s.name == name).unwrap()
+}
+
+/// ExponentWithLinearTransform is the sRGB curve at gamma 2.4 / offset 0.055, continuous at
+/// its break point and inverted exactly; mirror mirrors negatives.
+#[test]
+fn moncurve_matches_srgb_and_inverts() {
+    for v in [-0.2, 0.0, 0.002, 0.039, 0.0393, 0.2, 0.5, 1.0, 3.0] {
+        let lin = moncurve(v, 2.4, 0.055, false, false);
+        assert!((moncurve(lin, 2.4, 0.055, true, false) - v).abs() < 1e-12, "{v}");
+        if v >= 0.0 {
+            assert!((moncurve(srgb(v), 2.4, 0.055, false, false) - v).abs() < 2e-5, "{v}");
+        }
+    }
+    let xb = 0.055 / 1.4;
+    assert!((moncurve(xb - 1e-12, 2.4, 0.055, false, false) - moncurve(xb + 1e-12, 2.4, 0.055, false, false)).abs() < 1e-9);
+    assert_eq!(moncurve(-0.5, 2.4, 0.055, false, true), -moncurve(0.5, 2.4, 0.055, false, false));
+    assert_eq!(moncurve(-0.5, 1.0, 0.0, false, false), 0.0);
+}
+
+#[test]
+fn builtin_styles() {
+    for style in ["IDENTITY", "DISPLAY - CIE-XYZ-D65_to_sRGB", "display - cie-xyz-d65_to_rec.2100-pq", "ACEScc_to_ACES2065-1", "ACEScct_to_ACES2065-1"] {
+        assert!(builtin(style).is_some(), "{style}");
+    }
+    assert!(builtin("ACES-OUTPUT - ACES2065-1_to_CIE-XYZ-D65 - SDR-VIDEO_1.0").is_none());
+    // D65 white in XYZ is display white.
+    let xyz = rgb_white_xyz();
+    for style in ["DISPLAY - CIE-XYZ-D65_to_sRGB", "DISPLAY - CIE-XYZ-D65_to_REC.1886-REC.709", "DISPLAY - CIE-XYZ-D65_to_DisplayP3"] {
+        let o = builtin(style).unwrap().apply(xyz, false);
+        assert!(close(o, [1.0; 3], 1e-6), "{style}: {o:?}");
+    }
+    // PQ: 1.0 = 100 nits → code value ≈ 0.508.
+    let pq = builtin("DISPLAY - CIE-XYZ-D65_to_REC.2100-PQ").unwrap().apply(xyz, false);
+    assert!((pq[0] - 0.508).abs() < 1e-3, "{pq:?}");
+    // ACEScc and ACEScct of 0.18 (ACES2065-1 grey stays grey).
+    for (style, code) in [("ACEScc_to_ACES2065-1", 0.413_588_402_492_442_1), ("ACEScct_to_ACES2065-1", 0.413_588_402_492_442_1)] {
+        let o = builtin(style).unwrap().apply([code; 3], false);
+        assert!(close(o, [0.18; 3], 1e-6), "{style}: {o:?}");
+    }
+}
+
+fn rgb_white_xyz() -> [f64; 3] {
+    [D65[0] / D65[1], 1.0, (1.0 - D65[0] - D65[1]) / D65[1]]
+}
diff --git a/crates/effects/src/psim.rs b/crates/effects/src/psim.rs
index aabbcdce8..5716a2dcb 100644
--- a/crates/effects/src/psim.rs
+++ b/crates/effects/src/psim.rs
@@ -85,21 +85,27 @@ pub trait ParticleSim: Send + Sync {
 /// (the CPU step's `carry` arithmetic, exactly). `None` when more than `cap` would be born (the
 /// CPU drops births at its live-particle cap, which an independent simulation can't know).
 pub fn births(rate: f64, steps: u64, cap: usize) -> Option<Vec<u32>> {
-    let per = rate / SPS;
-    if per * steps as f64 > cap as f64 + 2.0 {
+    if rate / SPS * steps as f64 > cap as f64 + 2.0 {
         return None;
     }
+    births_at(steps, cap, |_| rate)
+}
+
+/// [`births`] with the rate of each step, `rate(i)` particles per second during step `i` (a
+/// keyframed Birth Rate, #1373).
+pub fn births_at(steps: u64, cap: usize, rate: impl Fn(u64) -> f64) -> Option<Vec<u32>> {
     let mut out = Vec::new();
     let mut carry = 0.0f64;
     for i in 0..steps {
-        carry += per;
+        carry += rate(i) / SPS;
         let n = carry.floor() as u32;
         carry -= n as f64;
-        for _ in 0..n {
-            out.push(i as u32);
+        if n as usize > cap.saturating_sub(out.len()) {
+            return None;
         }
+        out.extend(std::iter::repeat_n(i as u32, n as usize));
     }
-    (out.len() <= cap).then_some(out)
+    Some(out)
 }
 
 /// Steps per second of the stepped simulations.
diff --git a/crates/effects/src/puppet/mod.rs b/crates/effects/src/puppet.rs
similarity index 100%
rename from crates/effects/src/puppet/mod.rs
rename to crates/effects/src/puppet.rs
diff --git a/crates/effects/src/roto.rs b/crates/effects/src/roto.rs
index 4917cc231..fe6191714 100644
--- a/crates/effects/src/roto.rs
+++ b/crates/effects/src/roto.rs
@@ -29,9 +29,9 @@ use std::sync::{Arc, Mutex, OnceLock, RwLock, Weak};
 use effectcraft_keyframe::Value;
 use effectcraft_project::ParamUi;
 use effectcraft_raster::Image;
-use effectcraft_segment::MaskModel;
+use effectcraft_segment::{ClipFrame, MaskModel, TrackRequest};
 use effectcraft_track::roto::refine::{self, MatteParams};
-use effectcraft_track::roto::{self as rb, RotoData, SegOpts, rle};
+use effectcraft_track::roto::{self as rb, Gmm, RotoData, SegOpts, rle};
 use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 
@@ -40,12 +40,16 @@ use crate::{Buf, EffectCtx, EffectSpec, Params, num, p, popup, slider};
 
 pub use effectcraft_track::roto::{FrameSeg, Stroke, StrokeKind};
 
+mod pending;
+
 /// The effect's id.
 pub const ID: &str = "ec.matte.rotobrush";
 /// Hidden parameters.
 pub const STROKES: &str = "strokes";
 pub const INPUT_KEY: &str = "inputKey";
 pub const FROZEN: &str = "frozen";
+/// The saved tracking (see [`TrackCache`]).
+pub const TRACKED: &str = "tracked";
 
 /// Default segmentation span each side of the base frame (frames).
 pub const DEFAULT_SPAN: i64 = 20;
@@ -78,6 +82,7 @@ pub fn specs() -> Vec<EffectSpec> {
             p("rotoBrushMatte/contrast", "Contrast", num(0.0), slider(0.0, 100.0, 0.0, 100.0, 0)),
             p("rotoBrushMatte/shiftEdge", "Shift Edge", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 0)),
             p("rotoBrushMatte/reduceChatter", "Reduce Chatter", num(0.0), slider(0.0, 100.0, 0.0, 100.0, 0)),
+            p("rotoBrushMatte/object", "Show Object", num(0.0), slider(0.0, 32.0, 0.0, 32.0, 0)),
             p("refineEdgeMatte/smooth", "Smooth", num(1.0), slider(0.0, 100.0, 0.0, 10.0, 1)),
             p("refineEdgeMatte/feather", "Feather", num(0.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
             p("refineEdgeMatte/contrast", "Contrast", num(0.0), slider(0.0, 100.0, 0.0, 100.0, 0)),
@@ -95,6 +100,7 @@ pub fn specs() -> Vec<EffectSpec> {
             p(STROKES, "Strokes", Value::Str(String::new()), ParamUi::Hidden),
             p(INPUT_KEY, "Input Key", Value::Str(String::new()), ParamUi::Hidden),
             p(FROZEN, "Frozen", Value::Str(String::new()), ParamUi::Hidden),
+            p(TRACKED, "Tracked", Value::Str(String::new()), ParamUi::Hidden),
         ],
         render,
         gpu: false,
@@ -191,9 +197,15 @@ pub fn set_model(m: Option<Arc<dyn MaskModel>>) {
     }
 }
 
+/// Whether an instance with `params` segments with the model Settings chose: Roto Brush 2.0 and
+/// 3.0 do, 1.0 is the classic engine.
+pub fn uses_model(params: &Params) -> bool {
+    e(params, "version") != 0
+}
+
 /// The model an instance segments with: its version's choice of the installed one.
 pub fn model_for(params: &Params) -> Option<Arc<dyn MaskModel>> {
-    if e(params, "version") == 0 {
+    if !uses_model(params) {
         return None;
     }
     installed_model()
@@ -208,6 +220,11 @@ pub fn installed_model() -> Option<Arc<dyn MaskModel>> {
 /// Seed of the chain keys: what the frames are (the engine-maintained Input Key), the layer
 /// size, the frame rate, the segmentation settings and the model.
 pub fn seed(params: &Params, layer_size: [f64; 2], fps: f64) -> u64 {
+    seed_with(params, layer_size, fps, model_for(params).map_or(effectcraft_segment::CLASSICAL, |m| m.info().id))
+}
+
+/// [`seed`] with the segmenting model named by its id (saved tracking names the one that made it).
+fn seed_with(params: &Params, layer_size: [f64; 2], fps: f64, model: &str) -> u64 {
     let mut h = 0xcbf2_9ce4_8422_2325;
     fnv(&mut h, s(params, INPUT_KEY).as_bytes());
     for v in [
@@ -221,7 +238,7 @@ pub fn seed(params: &Params, layer_size: [f64; 2], fps: f64) -> u64 {
         fnv(&mut h, &v.to_bits().to_le_bytes());
     }
     fnv(&mut h, &[e(params, "quality") as u8, e(params, "version") as u8]);
-    fnv(&mut h, model_for(params).map_or(effectcraft_segment::CLASSICAL, |m| m.info().id).as_bytes());
+    fnv(&mut h, model.as_bytes());
     h
 }
 
@@ -298,9 +315,44 @@ fn from_store(key: u64, scale: f64) -> Option<Arc<FrameSeg>> {
     Some(seg)
 }
 
+/// Tracker results live under the chain key mixed with this, so a frame the tracker followed and
+/// one the classic engine computed never share a cache slot.
+const TRACK_SALT: u64 = 0x7472_6163_6b65_7231;
+
+fn tracked_key(key: u64) -> u64 {
+    key.rotate_left(17) ^ TRACK_SALT
+}
+
+/// Where one object's matte of a tracked frame lives (kept only when the instance has several objects).
+fn object_key(key: u64, object: u32) -> u64 {
+    tracked_key(key).wrapping_add(0x9e37_79b9_7f4a_7c15u64.wrapping_mul(u64::from(object) + 1))
+}
+
+/// How far to trust a frame the tracker followed.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct FrameTrust {
+    /// 0–1, from the tracker's own object score and mask quality.
+    pub confidence: f32,
+    /// The object is not in this frame (an empty matte).
+    pub occluded: bool,
+}
+
+fn trust_cache() -> &'static Mutex<HashMap<u64, FrameTrust>> {
+    static T: OnceLock<Mutex<HashMap<u64, FrameTrust>>> = OnceLock::new();
+    T.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+/// The tracker's confidence in the frame with chain key `key`, if the tracker followed it.
+pub fn trust(key: u64) -> Option<FrameTrust> {
+    trust_cache().lock().unwrap_or_else(|e| e.into_inner()).get(&tracked_key(key)).copied()
+}
+
 /// Drop the cached segmentations of these chain keys (every scale).
 pub fn forget(keys: impl IntoIterator<Item = u64>) {
-    let keys: std::collections::HashSet<u64> = keys.into_iter().collect();
+    let mut trusts = trust_cache().lock().unwrap_or_else(|e| e.into_inner());
+    let keys: std::collections::HashSet<u64> = keys.into_iter().flat_map(|k| [k, tracked_key(k)]).collect();
+    trusts.retain(|k, _| !keys.contains(k));
+    drop(trusts);
     let mut c = cache().lock().unwrap_or_else(|e| e.into_inner());
     let gone: Vec<(u64, u64)> = c.map.keys().filter(|k| keys.contains(&k.0)).copied().collect();
     for k in gone {
@@ -313,6 +365,7 @@ pub fn forget(keys: impl IntoIterator<Item = u64>) {
 
 /// Drop every cached segmentation (Edit ▸ Purge).
 pub fn purge() {
+    trust_cache().lock().unwrap_or_else(|e| e.into_inner()).clear();
     let mut c = cache().lock().unwrap_or_else(|e| e.into_inner());
     c.map.clear();
     c.order.clear();
@@ -333,6 +386,16 @@ pub fn layer_grid(buf: &Buf, layer_size: [f64; 2]) -> Image {
     img
 }
 
+/// What a tracking pass found.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TrackSummary {
+    pub frames: usize,
+    /// Frames where the object was absent.
+    pub occluded: usize,
+    pub min_confidence: f32,
+}
+
 /// Everything needed to compute an instance's segmentations.
 pub struct Chain {
     pub data: Arc<RotoData>,
@@ -341,13 +404,113 @@ pub struct Chain {
     pub refine_radius: f64,
     /// The trained model (Version 2.0 / 3.0 with one installed).
     pub model: Option<Arc<dyn MaskModel>>,
+    /// The saved tracking, while it applies (see [`TrackCache`]).
+    pub(crate) saved: Option<SavedTracking>,
+    /// Show Object: the matte of this object only (its id plus one; 0 shows all of them together).
+    pub show_object: u32,
 }
 
 impl Chain {
     pub fn new(params: &Params, layer_size: [f64; 2], fps: f64, scale: f64) -> Chain {
         let data = data(params);
         let keys = data.chain_keys(seed(params, layer_size, fps));
-        Chain { refine_radius: data.refine_radius(), data, keys, opts: seg_opts(params, scale), model: model_for(params) }
+        let saved = saved_for(params, &data, layer_size, fps);
+        let show_object = f(params, "rotoBrushMatte/object").round().clamp(0.0, 32.0) as u32;
+        Chain { refine_radius: data.refine_radius(), data, keys, opts: seg_opts(params, scale), model: model_for(params), saved, show_object }
+    }
+
+    /// Frame `f`'s segmentation at `scale` from the saved tracking or the caches; computes nothing.
+    pub fn cached_seg(&self, f: i64, scale: f64) -> Option<Arc<FrameSeg>> {
+        self.saved_seg(f, scale).or_else(|| self.keys.get(&f).and_then(|k| cached(*k, scale)))
+    }
+
+    /// Object `o`'s matte of frame `f` at this chain's scale (saved tracking, else this session's), when the instance
+    /// has several objects and the tracker followed them there; computes nothing.
+    pub fn object_seg(&self, f: i64, o: u32) -> Option<Arc<FrameSeg>> {
+        let sc = self.opts.scale;
+        // A frame the saved tracking has is read from it, under the keys it was made with: the model chosen now
+        // may not be the one that tracked it, and its own cache must not hold another model's matte.
+        let saved = self.saved.as_ref().filter(|t| t.cache.frames.contains_key(&f)).and_then(|t| t.keys.get(&f).map(|k| (t, *k)));
+        let k = match saved {
+            Some((_, saved_key)) => saved_key,
+            None => *self.keys.get(&f)?,
+        };
+        let ok = object_key(k, o);
+        if let Some(s) = cached(ok, sc) {
+            return Some(s);
+        }
+        let full = match cached(ok, 1.0) {
+            Some(s) => s,
+            None => {
+                let (t, _) = saved?;
+                let s = Arc::new(decode_object(&t.cache, f, o)?);
+                store(ok, 1.0, s.clone());
+                s
+            }
+        };
+        if sc == 1.0 {
+            return Some(full);
+        }
+        let s = Arc::new(downscale(&full, sc));
+        store(ok, sc, s.clone());
+        Some(s)
+    }
+
+    /// What Show Object asks for at frame `f`: `None` shows the whole matte (all objects, a single object, or a frame
+    /// the tracker did not follow); a missing object on a tracked frame shows nothing.
+    fn shown_object(&self, f: i64) -> Option<Arc<FrameSeg>> {
+        let o = self.show_object.checked_sub(1)?;
+        let objects = self.data.objects();
+        if objects.len() < 2 {
+            return None;
+        }
+        if objects.contains(&o)
+            && let Some(seg) = self.object_seg(f, o)
+        {
+            return Some(seg);
+        }
+        let sc = self.opts.scale;
+        let tracked = self.saved_seg(f, sc).or_else(|| {
+            let key = tracked_key(*self.keys.get(&f)?);
+            cached(key, sc).or_else(|| cached(key, 1.0).map(|seg| Arc::new(downscale(&seg, sc))))
+        })?;
+        Some(Arc::new(FrameSeg::empty(tracked.w, tracked.h)))
+    }
+
+    /// The tracker's trust in frame `f`: from the saved tracking, else from this session's tracking.
+    pub fn trust_at(&self, f: i64) -> Option<FrameTrust> {
+        if let Some(fr) = self.saved.as_ref().and_then(|t| t.cache.frames.get(&f)) {
+            return Some(FrameTrust { confidence: fr.c, occluded: fr.o });
+        }
+        trust(*self.keys.get(&f)?)
+    }
+
+    /// The model the saved tracking was made with, while it applies.
+    pub fn saved_model(&self) -> Option<&str> {
+        self.saved.as_ref().map(|t| t.cache.model.as_str())
+    }
+
+    /// Frame `f` of the saved tracking at `scale` (decoded once, then cached).
+    fn saved_seg(&self, f: i64, scale: f64) -> Option<Arc<FrameSeg>> {
+        let t = self.saved.as_ref()?;
+        let k = tracked_key(*t.keys.get(&f)?);
+        if let Some(s) = cached(k, scale) {
+            return Some(s);
+        }
+        let full = match cached(k, 1.0) {
+            Some(s) => s,
+            None => {
+                let s = Arc::new(decode_tracked(&t.cache, f)?);
+                store(k, 1.0, s.clone());
+                s
+            }
+        };
+        if scale == 1.0 {
+            return Some(full);
+        }
+        let s = Arc::new(downscale(&full, scale));
+        store(k, scale, s.clone());
+        Some(s)
     }
 
     /// Frame `f`'s segmentation at this chain's scale: cached, or computed from the nearest
@@ -356,37 +519,98 @@ impl Chain {
     pub fn ensure(&self, f: i64, frame: &mut dyn FnMut(i64) -> Option<Arc<Image>>, cancel: &dyn Fn() -> bool) -> Option<Arc<FrameSeg>> {
         let sc = self.opts.scale;
         let lookup = |g: i64| -> Option<Arc<FrameSeg>> {
+            // Show Object: one object's matte, where the tracker followed the objects.
+            if let Some(s) = self.shown_object(g) {
+                return Some(s);
+            }
+            // A frame the tracker followed wins over the classic engine's: the saved tracking, else
+            // this session's.
+            if let Some(s) = self.saved_seg(g, sc) {
+                return Some(s);
+            }
             let k = *self.keys.get(&g)?;
+            if let Some(s) = cached(tracked_key(k), sc) {
+                return Some(s);
+            }
             if let Some(s) = cached(k, sc).or_else(|| from_store(k, sc)) {
                 return Some(s);
             }
             if sc != 1.0 {
-                let full = cached(k, 1.0).or_else(|| from_store(k, 1.0))?;
+                let full = cached(tracked_key(k), 1.0).or_else(|| cached(k, 1.0)).or_else(|| from_store(k, 1.0))?;
                 let s = Arc::new(downscale(&full, sc));
                 store(k, sc, s.clone());
                 return Some(s);
             }
             None
         };
+        self.carry(f, None, frame, cancel, &lookup, &mut |g, seg| {
+            let k = *self.keys.get(&g)?;
+            store(k, sc, seg.clone());
+            if let Some(st) = seg_store() {
+                st.put_seg(k, sc, seg);
+            }
+            Some(())
+        })
+    }
+
+    /// [`Chain::ensure`]'s walk: the matte carried to `f` from the nearest frame towards the base that `lookup` has,
+    /// else from the root cut afresh from its strokes. `object: None` carries every stroke from the base frame (the shown
+    /// matte); `Some(o)` carries only `o`'s, from its foreground-stroked frame nearest the base on the way. `keep`
+    /// gets every frame made on the way.
+    fn carry(
+        &self,
+        f: i64,
+        object: Option<u32>,
+        frame: &mut dyn FnMut(i64) -> Option<Arc<Image>>,
+        cancel: &dyn Fn() -> bool,
+        lookup: &dyn Fn(i64) -> Option<Arc<FrameSeg>>,
+        keep: &mut dyn FnMut(i64, &Arc<FrameSeg>) -> Option<()>,
+    ) -> Option<Arc<FrameSeg>> {
+        let strokes = |g: i64| match object {
+            Some(o) => self.data.strokes_of(g, o),
+            None => self.data.strokes_at(g),
+        };
         if let Some(s) = lookup(f) {
             return Some(s);
         }
         let base = self.data.base?;
+        let root = match object {
+            Some(o) => {
+                // one pass over the strokes, not one per frame on the way
+                let on_the_way = |g: i64| (g == base || g.cmp(&base) == f.cmp(&base)) && g.abs_diff(base) <= f.abs_diff(base);
+                let fg = self.data.strokes.iter().filter(|s| s.object == o && s.kind == StrokeKind::Fg && on_the_way(s.frame));
+                fg.map(|s| s.frame).min_by_key(|g| g.abs_diff(base)).unwrap_or(f)
+            }
+            None => base,
+        };
         if !self.data.in_span(f) {
             return None;
         }
-        // Walk towards the base to the nearest available frame.
+        // A new first stroke can still have a valid tracked matte nearer the base. Look for it
+        // without reading those frames; without one, start afresh at the object's first stroke.
         let mut path = vec![f];
+        let mut untracked_len = 1;
         let mut g = f;
         let mut start: Option<Arc<FrameSeg>> = None;
-        while let Some(src) = self.data.source_of(g) {
+        while g != base
+            && let Some(src) = self.data.source_of(g)
+        {
+            if cancel() {
+                return None;
+            }
             if let Some(s) = lookup(src) {
                 start = Some(s);
                 break;
             }
             path.push(src);
+            if src == root {
+                untracked_len = path.len();
+            }
             g = src;
         }
+        if start.is_none() {
+            path.truncate(untracked_len);
+        }
         path.reverse();
         let mut prev_img: Option<Arc<Image>> = None;
         let mut cur = start;
@@ -395,8 +619,8 @@ impl Chain {
                 return None;
             }
             let img = frame(g)?;
-            let strokes = self.data.strokes_at(g);
-            let seg = match (&cur, g == base) {
+            let strokes = strokes(g);
+            let seg = match (&cur, object.is_none() && g == root) {
                 (_, true) | (None, _) => rb::segment_with(&img, &strokes, None, &self.opts, self.refine_radius, self.model.as_deref()),
                 (Some(p), false) => {
                     let src = self.data.source_of(g)?;
@@ -407,25 +631,256 @@ impl Chain {
                     if pimg.width != img.width || pimg.height != img.height {
                         return None;
                     }
-                    rb::propagate_with(&pimg, p, &img, &strokes, &self.opts, self.refine_radius, self.model.as_deref())
+                    // A tracker is too slow to prompt on every frame (its pass is `track`); the classic flow carries the rest.
+                    rb::propagate_with(&pimg, p, &img, &strokes, &self.opts, self.refine_radius, if self.has_tracker() { None } else { self.model.as_deref() })
                 }
             };
             let seg = Arc::new(seg);
-            let k = *self.keys.get(&g)?;
-            store(k, sc, seg.clone());
-            if let Some(st) = seg_store() {
-                st.put_seg(k, sc, &seg);
-            }
+            keep(g, &seg)?;
             cur = Some(seg);
             prev_img = Some(img);
         }
         cur
     }
 
-    /// Whether frame `f` is computed (at full resolution or at `scale`).
+    /// Whether frame `f` is computed (at full resolution or at `scale`): in this session's caches,
+    /// or in the tracking saved with the project, which needs no work to be used even before it has
+    /// been decoded (and whichever model Settings choose now).
     pub fn is_cached(&self, f: i64, scale: f64) -> bool {
-        self.keys.get(&f).is_some_and(|k| cached(*k, 1.0).is_some() || cached(*k, scale).is_some())
+        self.keys.get(&f).is_some_and(|k| [*k, tracked_key(*k)].iter().any(|k| cached(*k, 1.0).is_some() || cached(*k, scale).is_some()))
+            || self.saved.as_ref().is_some_and(|t| t.cache.frames.contains_key(&f) && t.keys.contains_key(&f))
     }
+
+    /// Whether the tracking saved with the project has frame `f` (and applies to this chain).
+    pub fn saved_has(&self, f: i64) -> bool {
+        self.saved.as_ref().is_some_and(|t| t.cache.frames.contains_key(&f) && t.keys.contains_key(&f))
+    }
+
+    /// Whether the chosen model can follow an object through a clip (SAM 2).
+    pub fn has_tracker(&self) -> bool {
+        self.model.as_ref().is_some_and(|m| m.tracker().is_some())
+    }
+
+    /// Explicit propagation replaces tracking made by another model. Rendering and Freeze keep
+    /// using saved mattes even when that model is unavailable, so this is only called for Propagate.
+    pub fn prepare_propagation(&mut self) {
+        if self.saved_model().is_some_and(|saved| self.model.as_ref().is_none_or(|model| model.info().id != saved)) {
+            self.saved = None;
+        }
+    }
+
+    /// Discard a failed track completely before falling back to the classic engine.
+    pub fn forget_tracking(&mut self) {
+        let mut objects = self.data.objects();
+        if let Some(saved) = &self.saved {
+            objects.extend(saved.cache.objects.keys().copied());
+            objects.sort_unstable();
+            objects.dedup();
+        }
+        let keys = self.keys.values().chain(self.saved.iter().flat_map(|saved| saved.keys.values())).copied();
+        forget(keys.flat_map(|key| std::iter::once(key).chain(objects.iter().copied().map(move |object| object_key(key, object)))));
+        self.saved = None;
+        self.model = None;
+    }
+
+    /// Follow the object through the span with the model's tracker, from the strokes on their
+    /// frames (only the frames without a tracked result yet: after a correction stroke, the frames it
+    /// changes, tracked on from the nearest prompted frame), and cache every frame's segmentation (under the tracker's keys, with its
+    /// confidence). The strokes stay hard constraints and the edges are refined at full
+    /// resolution; frames the tracker can't give are left to [`Chain::ensure`]'s classic engine.
+    /// `progress` gets the number of frames finished. `Ok(None)`: no tracker, nothing done.
+    pub fn track(
+        &self,
+        frame: &mut dyn FnMut(i64) -> Option<Arc<Image>>,
+        cancel: &dyn Fn() -> bool,
+        progress: &mut dyn FnMut(usize),
+    ) -> Result<Option<TrackSummary>, String> {
+        self.track_frames(None, frame, cancel, progress)
+    }
+
+    /// [`Chain::track`] limited to `wanted` frames (a one-direction Propagate): the window, the work and the
+    /// progress count cover only those frames of the span.
+    pub fn track_frames(
+        &self,
+        wanted: Option<&[i64]>,
+        frame: &mut dyn FnMut(i64) -> Option<Arc<Image>>,
+        cancel: &dyn Fn() -> bool,
+        progress: &mut dyn FnMut(usize),
+    ) -> Result<Option<TrackSummary>, String> {
+        self.track_with_pending_limit(wanted, frame, cancel, progress, pending::MAX_PENDING_BYTES)
+    }
+
+    fn track_with_pending_limit(
+        &self,
+        wanted: Option<&[i64]>,
+        frame: &mut dyn FnMut(i64) -> Option<Arc<Image>>,
+        cancel: &dyn Fn() -> bool,
+        progress: &mut dyn FnMut(usize),
+        max_pending_bytes: usize,
+    ) -> Result<Option<TrackSummary>, String> {
+        let Some(tracker) = self.model.as_ref().and_then(|m| m.tracker()) else { return Ok(None) };
+        let (Some(base), true) = (self.data.base, self.data.span[1] >= self.data.span[0]) else { return Err("no base frame".into()) };
+        // Frames of the span that already have a tracked result (this session's, or the saved
+        // tracking) are kept: only the rest is tracked. A correction stroke changes the keys of the
+        // frames from it on (both directions), so only those come back here.
+        let (lo_span, hi_span) = (self.data.span[0], self.data.span[1]);
+        let needed: Vec<i64> = (lo_span..=hi_span)
+            .filter(|f| wanted.is_none_or(|w| w.contains(f)))
+            .filter(|f| self.keys.get(f).is_some_and(|k| self.saved_seg(*f, self.opts.scale).is_none() && cached(tracked_key(*k), self.opts.scale).is_none()))
+            .collect();
+        let (Some(&need_lo), Some(&need_hi)) = (needed.first(), needed.last()) else {
+            return Ok(Some(TrackSummary::default()));
+        };
+        // Each object has its own prompts: a few clicks from its strokes and a box saying how far it reaches (clicks
+        // alone pick a part of the object). SAM 2 fills the box it is given, so the box surrounds the object's matte
+        // on that frame: the one shown for a lone object; with several, each object's own, carried with its own strokes
+        // as the shown one is (from its first prompted frame, or the nearest tracked or prompted frame), so a correction stroke on
+        // part of an object still boxes all of it. Those per-object mattes are not cached: their keys mean tracked results.
+        let objects = self.data.objects();
+        let several = objects.len() > 1;
+        let mut by_object: Vec<Vec<(i64, effectcraft_segment::Prompt)>> = vec![];
+        for &obj in &objects {
+            let mut prompts = vec![];
+            let mut carried: Option<(i64, Arc<FrameSeg>)> = None;
+            // from the base outwards on each side, so each carry goes on from the one before
+            let mut frames: Vec<i64> = self.data.stroke_frames().into_iter().filter(|f| self.data.in_span(*f)).collect();
+            frames.sort_by_key(|f| (*f < base, f.abs_diff(base)));
+            for f in frames {
+                let strokes = self.data.strokes_of(f, obj);
+                if !strokes.iter().any(|s| s.kind == StrokeKind::Fg) {
+                    continue;
+                }
+                let own = if several {
+                    // a later correction frame carries on from the one before it (only the last can be on its way)
+                    let lookup = |g| self.object_seg(g, obj).or_else(|| carried.as_ref().filter(|(k, _)| *k == g).map(|(_, s)| s.clone()));
+                    let own = self.carry(f, Some(obj), &mut *frame, cancel, &lookup, &mut |_, _| Some(()));
+                    carried = own.clone().map(|s| (f, s));
+                    own
+                } else {
+                    self.ensure(f, &mut *frame, cancel)
+                };
+                let matte = match own {
+                    Some(own) => own,
+                    None if cancel() => return Err("tracking cancelled".into()),
+                    None => match frame(f) {
+                        Some(img) => Arc::new(rb::segment_with(&img, &strokes, None, &self.opts, self.refine_radius, self.model.as_deref())),
+                        None => return Err(format!("cannot read Roto Brush prompt frame {f}")),
+                    },
+                };
+                let p = rb::tracker_prompt_boxed(&strokes, self.opts.scale, &matte);
+                if p.points.iter().any(|(_, fg)| *fg) {
+                    prompts.push((f, p));
+                }
+            }
+            prompts.sort_by_key(|q| q.0);
+            by_object.push(prompts);
+        }
+        // objects without a foreground prompt cannot be followed
+        let followed: Vec<(u32, Vec<(i64, effectcraft_segment::Prompt)>)> = objects.into_iter().zip(by_object).filter(|(_, p)| !p.is_empty()).collect();
+        if followed.is_empty() {
+            return Err("no foreground strokes to follow".into());
+        }
+        // The window to track: every object restarts at the nearest of its prompted frames at or before the first
+        // frame needed (a correction restarts the object there), so the window starts at the earliest restart; it
+        // ends at the last frame needed, reaching the farthest first prompt when an object's needed frames lie
+        // before its prompt.
+        let lo = followed.iter().map(|(_, p)| p.iter().map(|q| q.0).filter(|f| *f <= need_lo).max().unwrap_or(need_lo)).min().unwrap_or(need_lo);
+        let first_prompt = followed.iter().filter_map(|(_, p)| p.first().map(|q| q.0)).max().unwrap_or(need_hi);
+        let hi = need_hi.max(first_prompt);
+        let objects: Vec<u32> = followed.iter().map(|(o, _)| *o).collect();
+        let prompts: Vec<Vec<(i64, effectcraft_segment::Prompt)>> =
+            followed.into_iter().map(|(_, p)| p.into_iter().filter(|q| q.0 >= lo && q.0 <= hi).collect()).collect();
+        let req = TrackRequest { first: lo, count: (hi - lo + 1) as usize, objects: prompts };
+        let frame = std::cell::RefCell::new(frame);
+        let mut summary = TrackSummary::default();
+        // A frame is finished when every object has reported it (the objects' mattes are united).
+        let mut pending = pending::PendingMasks::new(objects.len(), max_pending_bytes);
+        let finish = |g: i64, parts: Vec<Option<effectcraft_segment::TrackedFrame>>, summary: &mut TrackSummary, progress: &mut dyn FnMut(usize)| {
+            if !wanted.is_none_or(|w| w.contains(&g)) {
+                return;
+            }
+            let (Some(key), Some(img)) = (self.keys.get(&g).copied(), (frame.borrow_mut())(g)) else { return };
+            let mut segs: Vec<(u32, effectcraft_track::roto::FrameSeg)> = vec![];
+            let (mut confidence, mut present) = (f32::INFINITY, false);
+            let mut worst = f32::INFINITY;
+            for (obj, t) in objects.iter().zip(parts) {
+                let Some(t) = t else { continue };
+                let strokes = self.data.strokes_of(g, *obj);
+                segs.push((*obj, rb::segment_tracked(&img, &strokes, t.prob, t.occluded, &self.opts, self.refine_radius)));
+                worst = worst.min(t.confidence);
+                if !t.occluded {
+                    present = true;
+                    confidence = confidence.min(t.confidence);
+                }
+            }
+            if segs.is_empty() {
+                return;
+            }
+            // a frame is occluded when every object is absent; otherwise the doubtful object sets the confidence
+            let (occluded, confidence) = (!present, if present { confidence } else { worst });
+            // with several objects each keeps its own matte too (Show Object, the per-object overlay)
+            let mut parts = Vec::with_capacity(segs.len());
+            for (obj, seg) in segs {
+                if several {
+                    store(object_key(key, obj), self.opts.scale, Arc::new(seg.clone()));
+                }
+                parts.push(seg);
+            }
+            store(tracked_key(key), self.opts.scale, Arc::new(effectcraft_track::roto::FrameSeg::union(parts)));
+            trust_cache().lock().unwrap_or_else(|e| e.into_inner()).insert(tracked_key(key), FrameTrust { confidence, occluded });
+            summary.frames += 1;
+            summary.occluded += usize::from(occluded);
+            summary.min_confidence = if summary.frames == 1 { confidence } else { summary.min_confidence.min(confidence) };
+            progress(summary.frames);
+        };
+        let pending_failed = std::cell::Cell::new(false);
+        let mut pending_error = None;
+        let result = tracker.track(
+            &req,
+            &mut |g| {
+                let img = (frame.borrow_mut())(g)?;
+                Some(Arc::new(ClipFrame { rgb: rb::rgb_of(&img), w: img.width as usize, h: img.height as usize }))
+            },
+            &|| cancel() || pending_failed.get(),
+            &mut |o, g, t| {
+                // A tracker that reports object-by-object can otherwise retain a full clip of
+                // probability maps. Stop buffering immediately, even if it ignores cancellation.
+                if pending_failed.get() {
+                    return;
+                }
+                match pending.insert(o, g, t) {
+                    Ok(Some(parts)) => finish(g, parts, &mut summary, progress),
+                    Ok(None) => {}
+                    Err(e) => {
+                        pending_error = Some(e);
+                        pending_failed.set(true);
+                    }
+                }
+            },
+        );
+        if let Some(e) = pending_error {
+            return Err(e);
+        }
+        result?;
+        // frames some object never reported (it was not followed there): united from the rest
+        for (g, parts) in pending.into_incomplete() {
+            finish(g, parts, &mut summary, progress);
+        }
+        Ok(Some(summary))
+    }
+}
+
+/// Each tracked object's matte of layer frame `f` in a multi-object instance (full resolution; computes
+/// nothing). Show Object limits it to the one chosen. Empty with fewer than two objects in the instance.
+pub fn object_mattes(params: &Params, layer_size: [f64; 2], fps: f64, f: i64) -> Vec<(u32, Arc<FrameSeg>)> {
+    let mut chain = Chain::new(params, layer_size, fps, 1.0);
+    let objects = chain.data.objects();
+    if objects.len() < 2 || !chain.data.in_span(f) {
+        return vec![];
+    }
+    let shown = chain.show_object.checked_sub(1);
+    chain.show_object = 0;
+    objects.into_iter().filter(|o| shown.is_none_or(|s| s == *o)).filter_map(|o| chain.object_seg(f, o).map(|s| (o, s))).collect()
 }
 
 /// Nearest-neighbour resampling of a segmentation to another scale.
@@ -434,7 +889,7 @@ pub fn downscale(s: &FrameSeg, scale: f64) -> FrameSeg {
     resample(s, w, h)
 }
 
-pub(crate) fn resample(s: &FrameSeg, w: usize, h: usize) -> FrameSeg {
+pub fn resample(s: &FrameSeg, w: usize, h: usize) -> FrameSeg {
     if s.w == w && s.h == h {
         return s.clone();
     }
@@ -513,6 +968,9 @@ pub fn frozen_key(params: &Params, layer_size: [f64; 2], fps: f64) -> String {
         fnv(&mut h, &k.to_le_bytes());
     }
     fnv(&mut h, format!("{:?}", matte_params(params)).as_bytes());
+    if ch.show_object != 0 {
+        fnv(&mut h, &ch.show_object.to_le_bytes());
+    }
     format!("{h:016x}")
 }
 
@@ -544,6 +1002,183 @@ fn frozen(params: &Params) -> Option<Arc<FrozenCache>> {
     Some(d)
 }
 
+// ------------------------------------------------------------------ saved tracking
+
+/// The tracker's frames of an instance, saved with the project (the hidden [`TRACKED`] parameter,
+/// as [`FrozenCache`] is). They apply while `key` matches the instance's inputs ([`tracks_key`]),
+/// whichever model Settings choose: a stroke or span change makes them stale, and the next Propagate
+/// replaces them (with the classic engine, that leaves none).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct TrackCache {
+    /// What the frames were tracked from ([`tracks_key`]).
+    pub key: String,
+    /// The tracker's model id.
+    pub model: String,
+    /// The mattes' width and height (the layer's size).
+    pub size: [usize; 2],
+    pub frames: BTreeMap<i64, TrackFrame>,
+    /// With several objects: each one's matte of every tracked frame (object id, then frame).
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub objects: BTreeMap<u32, BTreeMap<i64, ObjectFrame>>,
+}
+
+/// One object's matte and Refine Edge band of a tracked frame (RLE, base64).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct ObjectFrame {
+    pub m: String,
+    pub r: String,
+}
+
+/// One tracked frame: its matte and Refine Edge band (RLE, base64), its colour models and the
+/// tracker's trust in it.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct TrackFrame {
+    /// Matte (RLE, base64).
+    pub m: String,
+    /// Refine Edge band (RLE, base64).
+    pub r: String,
+    pub fg: Gmm,
+    pub bg: Gmm,
+    /// 0–1: the tracker's confidence.
+    pub c: f32,
+    /// The object is not in the frame.
+    pub o: bool,
+}
+
+impl TrackCache {
+    pub fn from_json(s: &str) -> Option<TrackCache> {
+        if s.trim().is_empty() {
+            return None;
+        }
+        serde_json::from_str(s).ok()
+    }
+    pub fn to_json(&self) -> String {
+        serde_json::to_string(self).unwrap_or_default()
+    }
+}
+
+/// What saved tracking depends on: the chain keys of its frames (the inputs and the model).
+pub fn tracks_key(keys: &BTreeMap<i64, u64>) -> String {
+    let mut h = 0xcbf2_9ce4_8422_2325;
+    for (f, k) in keys {
+        fnv(&mut h, &f.to_le_bytes());
+        fnv(&mut h, &k.to_le_bytes());
+    }
+    format!("{h:016x}")
+}
+
+/// The saved tracking of `params`, parsed once per content.
+fn saved_tracks(params: &Params) -> Option<Arc<TrackCache>> {
+    static C: OnceLock<Mutex<HashMap<u64, Arc<TrackCache>>>> = OnceLock::new();
+    let j = s(params, TRACKED);
+    if j.is_empty() {
+        return None;
+    }
+    let mut h = 0xcbf2_9ce4_8422_2325;
+    fnv(&mut h, j.as_bytes());
+    let c = C.get_or_init(Default::default);
+    if let Some(d) = c.lock().unwrap_or_else(|e| e.into_inner()).get(&h) {
+        return Some(d.clone());
+    }
+    let d = Arc::new(TrackCache::from_json(j)?);
+    let mut m = c.lock().unwrap_or_else(|e| e.into_inner());
+    if m.len() > 8 {
+        m.clear();
+    }
+    m.insert(h, d.clone());
+    Some(d)
+}
+
+/// A saved tracking that applies to a chain: its frames, keyed under the model that made them.
+pub(crate) struct SavedTracking {
+    cache: Arc<TrackCache>,
+    keys: BTreeMap<i64, u64>,
+}
+
+/// The saved tracking of `params` if it applies: the inputs are the instance's now. It does not depend
+/// on which model Settings choose or has loaded, so a project renders the same anywhere.
+fn saved_for(params: &Params, data: &RotoData, layer_size: [f64; 2], fps: f64) -> Option<SavedTracking> {
+    let cache = saved_tracks(params)?;
+    let keys = data.chain_keys(seed_with(params, layer_size, fps, &cache.model));
+    (tracks_key(&keys) == cache.key).then_some(SavedTracking { cache, keys })
+}
+
+/// Decode a tracked frame of saved tracking (full resolution).
+fn decode_tracked(cache: &TrackCache, f: i64) -> Option<FrameSeg> {
+    let fr = cache.frames.get(&f)?;
+    // The size comes from the project file: checked, so a corrupt one is ignored rather than overflowing.
+    let [w, h] = cache.size;
+    let n = w.checked_mul(h)?;
+    if n == 0 || n > rle::MAX_PLANE_BYTES {
+        return None;
+    }
+    let matte = rle::decode_bounded(&fr.m, n)?;
+    let refine = rle::decode_bounded(&fr.r, n)?;
+    (matte.len() == n && refine.len() == n).then(|| FrameSeg { w, h, matte, refine, fg: fr.fg.clone(), bg: fr.bg.clone() })
+}
+
+/// Object `o`'s matte of a tracked frame of saved tracking (full resolution).
+fn decode_object(cache: &TrackCache, f: i64, o: u32) -> Option<FrameSeg> {
+    let fr = cache.objects.get(&o)?.get(&f)?;
+    let [w, h] = cache.size;
+    let n = w.checked_mul(h)?;
+    if n == 0 || n > rle::MAX_PLANE_BYTES {
+        return None;
+    }
+    let matte = rle::decode_bounded(&fr.m, n)?;
+    let refine = rle::decode_bounded(&fr.r, n)?;
+    (matte.len() == n && refine.len() == n).then(|| FrameSeg { w, h, matte, refine, ..Default::default() })
+}
+
+/// The tracking a chain has just made, to save with its instance: every frame of its span that the
+/// tracker followed, at full resolution, with its trust. `None` when it followed none.
+pub fn tracks_of(ch: &Chain) -> Option<TrackCache> {
+    let model = ch.model.as_ref()?.info().id;
+    // The saved tracking applies to this chain's frames when the same model made it: what it has and this session did
+    // not track again stays (a project reopened and propagated with nothing new to track must keep its tracking).
+    let saved = ch.saved.as_ref().filter(|t| t.cache.model == model);
+    let mut size = saved.map(|t| t.cache.size);
+    let mut frames = BTreeMap::new();
+    for (f, k) in &ch.keys {
+        if let (Some(seg), Some(t)) = (cached(tracked_key(*k), 1.0), trust(*k)) {
+            size.get_or_insert([seg.w, seg.h]);
+            frames.insert(
+                *f,
+                TrackFrame { m: rle::encode(&seg.matte), r: rle::encode(&seg.refine), fg: seg.fg.clone(), bg: seg.bg.clone(), c: t.confidence, o: t.occluded },
+            );
+        } else if let Some(kept) = saved.filter(|t| t.keys.get(f) == Some(k)).and_then(|t| t.cache.frames.get(f)) {
+            frames.insert(*f, kept.clone());
+        }
+    }
+    let mut objects: BTreeMap<u32, BTreeMap<i64, ObjectFrame>> = BTreeMap::new();
+    let ids = ch.data.objects();
+    if ids.len() > 1 {
+        for (f, k) in &ch.keys {
+            if !frames.contains_key(f) {
+                continue;
+            }
+            for o in &ids {
+                if let Some(seg) = cached(object_key(*k, *o), 1.0) {
+                    objects.entry(*o).or_default().insert(*f, ObjectFrame { m: rle::encode(&seg.matte), r: rle::encode(&seg.refine) });
+                } else if let Some(kept) = saved.filter(|t| t.keys.get(f) == Some(k)).and_then(|t| t.cache.objects.get(o)).and_then(|m| m.get(f)) {
+                    objects.entry(*o).or_default().insert(*f, kept.clone());
+                }
+            }
+        }
+    }
+    let cache = TrackCache { key: tracks_key(&ch.keys), model: model.to_string(), size: size?, frames, objects };
+    (!cache.frames.is_empty()).then_some(cache)
+}
+
+/// Whether the tracking saved with `params` covers every one of `frames`: they need no model to be read.
+pub fn saved_covers(params: &Params, layer_size: [f64; 2], fps: f64, frames: &[i64]) -> bool {
+    let chain = Chain::new(params, layer_size, fps, 1.0);
+    !frames.is_empty() && frames.iter().all(|f| chain.saved_has(*f))
+}
+
 /// Encode one frame for [`FrozenCache`].
 pub fn freeze_frame(alpha: &[f32], band: &[u8]) -> FrozenFrame {
     let a: Vec<u8> = alpha.iter().map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8).collect();
@@ -634,7 +1269,7 @@ fn render(ctx: &EffectCtx, buf: Buf) -> Buf {
     let (w, h) = (img.width as usize, img.height as usize);
     let mp = matte_params(ctx.params);
     let mut rgb = rb::rgb_of(&img);
-    let map = refine::decontaminate(&mut rgb, &alpha, &band, w, h, &mp, rr * sc, sc);
+    let map = refine::decontaminate(&mut rgb, &alpha, &band, (w, h), &mp, rr * sc, sc);
     let view_map = b(ctx.params, "refineEdgeMatte/decontamination/viewDecontaminationMap");
     let (ox, oy) = (buf.offset[0].round() as i64, buf.offset[1].round() as i64);
     for y in 0..h {
@@ -731,8 +1366,8 @@ mod tests {
     #[test]
     fn renders_the_segmented_disk_on_demand() {
         let mut d = RotoData::default();
-        d.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[35.0, 40.0], [45.0, 40.0]] }, 20, [0, 24]);
-        d.add(Stroke { kind: StrokeKind::Bg, frame: 0, radius: 3.0, points: vec![[5.0, 5.0], [95.0, 5.0], [95.0, 75.0]] }, 20, [0, 24]);
+        d.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[35.0, 40.0], [45.0, 40.0]], object: 0 }, 20, [0, 24]);
+        d.add(Stroke { kind: StrokeKind::Bg, frame: 0, radius: 3.0, points: vec![[5.0, 5.0], [95.0, 5.0], [95.0, 75.0]], object: 0 }, 20, [0, 24]);
         let params = params_with(&d);
         let host = Seq;
         let run = |t: f64| {
@@ -776,6 +1411,650 @@ mod tests {
         assert!(o.data.iter().all(|p| p[3] == 0.0));
     }
 
+    /// A stand-in tracker for two objects: object 0 is the moving disk, object 1 a fixed square. It records how many
+    /// objects (and prompts per object) it was asked for.
+    struct TwoObjects(std::sync::Mutex<Vec<Vec<usize>>>);
+    impl effectcraft_segment::MaskModel for TwoObjects {
+        fn info(&self) -> &'static effectcraft_segment::ModelInfo {
+            &effectcraft_segment::SAM2_TINY
+        }
+        fn segment(&self, _: &[[f32; 3]], _: usize, _: usize, _: &effectcraft_segment::Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+            Err("no weights".into())
+        }
+        fn tracker(&self) -> Option<&dyn effectcraft_segment::ObjectTracker> {
+            Some(self)
+        }
+    }
+    impl effectcraft_segment::ObjectTracker for TwoObjects {
+        fn track(
+            &self,
+            req: &effectcraft_segment::TrackRequest,
+            frame: &mut dyn FnMut(i64) -> Option<Arc<ClipFrame>>,
+            _: &dyn Fn() -> bool,
+            out: &mut dyn FnMut(usize, i64, effectcraft_segment::TrackedFrame),
+        ) -> effectcraft_segment::Result<()> {
+            self.0.lock().unwrap().push(req.objects.iter().map(Vec::len).collect());
+            for g in req.first..req.first + req.count as i64 {
+                let img = frame(g).ok_or("no frame")?;
+                let c = [40.0 + 2.0 * g as f64, 40.0];
+                // the objects report in reverse order on odd frames: the union must not depend on it
+                let order: Vec<usize> = if g % 2 == 1 { (0..req.objects.len()).rev().collect() } else { (0..req.objects.len()).collect() };
+                for o in order {
+                    let prob = (0..img.w * img.h)
+                        .map(|i| {
+                            let (x, y) = ((i % img.w) as f64 + 0.5, (i / img.w) as f64 + 0.5);
+                            let inside = if o == 0 { (x - c[0]).hypot(y - c[1]) <= 15.0 } else { (8.0..22.0).contains(&x) && (8.0..22.0).contains(&y) };
+                            f32::from(inside)
+                        })
+                        .collect();
+                    out(o, g, effectcraft_segment::TrackedFrame { prob, w: img.w, h: img.h, confidence: if o == 0 { 0.9 } else { 0.4 }, occluded: false });
+                }
+            }
+            Ok(())
+        }
+    }
+
+    /// The ordering SAM 2 uses when objects are first prompted on different frames: each object
+    /// reports its entire span before the next. No weights or large allocations are needed.
+    #[derive(Default)]
+    struct SeparatePasses {
+        emitted: std::sync::atomic::AtomicUsize,
+        cancelled: std::sync::atomic::AtomicBool,
+    }
+
+    impl effectcraft_segment::MaskModel for SeparatePasses {
+        fn info(&self) -> &'static effectcraft_segment::ModelInfo {
+            &effectcraft_segment::SAM2_TINY
+        }
+        fn segment(&self, _: &[[f32; 3]], _: usize, _: usize, _: &effectcraft_segment::Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+            Err("no weights".into())
+        }
+        fn tracker(&self) -> Option<&dyn effectcraft_segment::ObjectTracker> {
+            Some(self)
+        }
+    }
+
+    impl effectcraft_segment::ObjectTracker for SeparatePasses {
+        fn track(
+            &self,
+            req: &effectcraft_segment::TrackRequest,
+            frames: &mut dyn FnMut(i64) -> Option<Arc<ClipFrame>>,
+            cancel: &dyn Fn() -> bool,
+            out: &mut dyn FnMut(usize, i64, effectcraft_segment::TrackedFrame),
+        ) -> effectcraft_segment::Result<()> {
+            use std::sync::atomic::Ordering::Relaxed;
+            assert_ne!(req.objects[0][0].0, req.objects[1][0].0);
+            for o in 0..req.objects.len() {
+                for g in req.first..req.first + req.count as i64 {
+                    if cancel() {
+                        self.cancelled.store(true, Relaxed);
+                        return Err("tracking cancelled".into());
+                    }
+                    let img = frames(g).ok_or("no frame")?;
+                    self.emitted.fetch_add(1, Relaxed);
+                    out(o, g, effectcraft_segment::TrackedFrame { prob: vec![0.5; img.w * img.h], w: img.w, h: img.h, confidence: 0.9, occluded: false });
+                }
+            }
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn a_single_followed_object_keeps_its_matte_in_a_multi_object_instance() {
+        for outside_span in [false, true] {
+            let mut data = RotoData::default();
+            data.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[35.0, 40.0]], object: 0 }, 2, [0, 5]);
+            data.add(Stroke { kind: StrokeKind::Fg, frame: if outside_span { 5 } else { 0 }, radius: 3.0, points: vec![[85.0, 70.0]], object: 1 }, 2, [0, 5]);
+            if !outside_span {
+                data.add(Stroke { kind: StrokeKind::Bg, frame: 0, radius: 8.0, points: vec![[85.0, 70.0]], object: 1 }, 2, [0, 5]);
+            }
+            data.span = [0, 2];
+            assert_eq!(data.objects(), [0, 1]);
+            let mut params = params_with(&data);
+            params.values.insert(INPUT_KEY.into(), Value::Str(format!("one-followed-object-{outside_span}")));
+            let mut chain = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+            chain.model = Some(Arc::new(TwoObjects(Default::default())));
+            chain.keys = data.chain_keys(seed_with(&params, [100.0, 80.0], 25.0, effectcraft_segment::SAM2_TINY.id));
+            let mut get = |f: i64| Some(Arc::new(frame(f as f64 / 25.0)));
+            assert_eq!(chain.track(&mut get, &|| false, &mut |_| {}).unwrap().unwrap().frames, 3);
+            let matte = chain.object_seg(1, 0).expect("the followed object keeps its own matte");
+            assert!(matte.area() > 0);
+            assert!(chain.object_seg(1, 1).is_none(), "the unprompted object has no invented matte");
+            chain.show_object = 1;
+            assert_eq!(chain.ensure(1, &mut get, &|| false).unwrap().matte, matte.matte);
+            let saved = tracks_of(&chain).unwrap();
+            assert_eq!(saved.objects.get(&0).unwrap().len(), 3);
+            assert!(!saved.objects.contains_key(&1));
+            params.values.insert(TRACKED.into(), Value::Str(saved.to_json()));
+            params.values.insert("rotoBrushMatte/object".into(), Value::Scalar(1.0));
+            forget(chain.keys.values().map(|key| object_key(*key, 0)));
+            let reopened = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+            assert_eq!(reopened.object_seg(1, 0).unwrap().matte, matte.matte);
+            assert_eq!(reopened.ensure(1, &mut |_| None, &|| false).unwrap().matte, matte.matte);
+            let overlays = object_mattes(&params, [100.0, 80.0], 25.0, 1);
+            assert_eq!(overlays.len(), 1);
+            assert_eq!((overlays[0].0, overlays[0].1.area()), (0, matte.area()));
+        }
+    }
+
+    /// A model that sees only the left part of the disk, and records the tracker's box prompts.
+    #[derive(Default)]
+    struct LeftPart(std::sync::Mutex<Vec<(i64, Option<[f32; 4]>)>>);
+    impl effectcraft_segment::MaskModel for LeftPart {
+        fn info(&self) -> &'static effectcraft_segment::ModelInfo {
+            &effectcraft_segment::SAM2_TINY
+        }
+        fn segment(&self, _: &[[f32; 3]], w: usize, h: usize, _: &effectcraft_segment::Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+            Ok((0..w * h).map(|i| f32::from((26..36).contains(&(i % w)) && (30..50).contains(&(i / w)))).collect())
+        }
+        fn tracker(&self) -> Option<&dyn effectcraft_segment::ObjectTracker> {
+            Some(self)
+        }
+    }
+    impl effectcraft_segment::ObjectTracker for LeftPart {
+        fn track(
+            &self,
+            req: &effectcraft_segment::TrackRequest,
+            _: &mut dyn FnMut(i64) -> Option<Arc<ClipFrame>>,
+            _: &dyn Fn() -> bool,
+            _: &mut dyn FnMut(usize, i64, effectcraft_segment::TrackedFrame),
+        ) -> effectcraft_segment::Result<()> {
+            *self.0.lock().unwrap() = req.objects.iter().flatten().map(|(f, p)| (*f, p.bbox)).collect();
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn the_tracker_box_surrounds_the_matte_shown_on_each_stroked_frame() {
+        let mut data = RotoData::default();
+        data.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[30.0, 40.0]], object: 0 }, 3, [0, 3]);
+        data.add(Stroke { kind: StrokeKind::Fg, frame: 2, radius: 3.0, points: vec![[50.0, 40.0]], object: 0 }, 3, [0, 3]);
+        data.span = [0, 3];
+        let mut params = params_with(&data);
+        params.values.insert(INPUT_KEY.into(), Value::Str("tracker-box-from-shown-matte".into()));
+        let mut chain = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+        let fake = Arc::new(LeftPart::default());
+        chain.model = Some(fake.clone());
+        chain.keys = data.chain_keys(seed_with(&params, [100.0, 80.0], 25.0, effectcraft_segment::SAM2_TINY.id));
+        let mut get = |f: i64| Some(Arc::new(frame(f as f64 / 25.0)));
+        let expected: Vec<(i64, Option<[f32; 4]>)> = [0, 2]
+            .into_iter()
+            .map(|f| (f, rb::tracker_prompt_boxed(&data.strokes_of(f, 0), 1.0, &chain.ensure(f, &mut get, &|| false).expect("a shown matte")).bbox))
+            .collect();
+        assert!(expected.iter().all(|(_, b)| b.is_some()));
+        assert!(expected[0].1.unwrap()[2] < 44.0, "the base frame shows the model's part of the disk: {expected:?}");
+        chain.track(&mut get, &|| false, &mut |_| {}).unwrap();
+        assert_eq!(*fake.0.lock().unwrap(), expected, "the base frame and the correction frame are boxed around what they show");
+    }
+
+    /// A model that cuts only a small square around each foreground click, and records every object's box prompts.
+    #[derive(Default)]
+    struct ClickSquares(std::sync::Mutex<Vec<Vec<(i64, Option<[f32; 4]>)>>>);
+    impl effectcraft_segment::MaskModel for ClickSquares {
+        fn info(&self) -> &'static effectcraft_segment::ModelInfo {
+            &effectcraft_segment::SAM2_TINY
+        }
+        fn segment(&self, _: &[[f32; 3]], w: usize, h: usize, p: &effectcraft_segment::Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+            let near = |x: f32, y: f32| p.points.iter().any(|(c, fg)| *fg && (c[0] - x).abs() <= 4.0 && (c[1] - y).abs() <= 4.0);
+            Ok((0..w * h).map(|i| f32::from(near((i % w) as f32 + 0.5, (i / w) as f32 + 0.5))).collect())
+        }
+        fn tracker(&self) -> Option<&dyn effectcraft_segment::ObjectTracker> {
+            Some(self)
+        }
+    }
+    impl effectcraft_segment::ObjectTracker for ClickSquares {
+        fn track(
+            &self,
+            req: &effectcraft_segment::TrackRequest,
+            _: &mut dyn FnMut(i64) -> Option<Arc<ClipFrame>>,
+            _: &dyn Fn() -> bool,
+            _: &mut dyn FnMut(usize, i64, effectcraft_segment::TrackedFrame),
+        ) -> effectcraft_segment::Result<()> {
+            *self.0.lock().unwrap() = req.objects.iter().map(|o| o.iter().map(|(f, p)| (*f, p.bbox)).collect()).collect();
+            Ok(())
+        }
+    }
+
+    #[test]
+    fn a_correction_stroke_on_part_of_one_of_several_objects_boxes_the_whole_object() {
+        let mut data = RotoData::default();
+        data.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[30.0, 40.0], [50.0, 40.0]], object: 0 }, 3, [0, 3]);
+        data.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[88.0, 72.0]], object: 1 }, 3, [0, 3]);
+        data.add(Stroke { kind: StrokeKind::Fg, frame: 2, radius: 2.0, points: vec![[54.0, 40.0]], object: 0 }, 3, [0, 3]);
+        data.span = [0, 3];
+        let mut params = params_with(&data);
+        params.values.insert(INPUT_KEY.into(), Value::Str("object-correction-box".into()));
+        let mut chain = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+        let fake = Arc::new(ClickSquares::default());
+        chain.model = Some(fake.clone());
+        chain.keys = data.chain_keys(seed_with(&params, [100.0, 80.0], 25.0, effectcraft_segment::SAM2_TINY.id));
+        chain.track(&mut |f| Some(Arc::new(frame(f as f64 / 25.0))), &|| false, &mut |_| {}).unwrap();
+        let boxes = fake.0.lock().unwrap().clone();
+        let box_of = |o: usize, f: i64| boxes[o].iter().find(|(g, _)| *g == f).and_then(|(_, b)| *b).expect("a box prompt");
+        let (base, correction, other) = (box_of(0, 0), box_of(0, 2), box_of(1, 0));
+        assert!(correction[0] <= base[0] + 6.0, "the correction frame boxes the object carried from frame 0 {base:?}, not only the stroke: {correction:?}");
+        assert!(correction[2] >= 54.0 && correction[2] - correction[0] >= base[2] - base[0], "the box holds the whole object and the stroke: {correction:?}");
+        assert!(correction[2] < other[0], "object 1 {other:?} stays out of object 0's box {correction:?}");
+    }
+
+    #[test]
+    fn a_correction_after_propagate_carries_each_object_on_from_its_tracked_matte() {
+        let mut data = RotoData::default();
+        data.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[30.0, 40.0]], object: 0 }, 3, [0, 3]);
+        data.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[15.0, 15.0]], object: 1 }, 3, [0, 3]);
+        data.span = [0, 3];
+        let mut params = params_with(&data);
+        params.values.insert(INPUT_KEY.into(), Value::Str("object-correction-after-propagate".into()));
+        let mut chain = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+        chain.model = Some(Arc::new(TwoObjects(Default::default())));
+        chain.keys = data.chain_keys(seed_with(&params, [100.0, 80.0], 25.0, effectcraft_segment::SAM2_TINY.id));
+        assert_eq!(chain.track(&mut |f| Some(Arc::new(frame(f as f64 / 25.0))), &|| false, &mut |_| {}).unwrap().unwrap().frames, 4);
+        data.add(Stroke { kind: StrokeKind::Fg, frame: 2, radius: 2.0, points: vec![[56.0, 40.0]], object: 0 }, 3, [0, 3]);
+        chain.data = Arc::new(data.clone());
+        chain.keys = data.chain_keys(seed_with(&params, [100.0, 80.0], 25.0, effectcraft_segment::SAM2_TINY.id));
+        let fake = Arc::new(ClickSquares::default());
+        chain.model = Some(fake.clone());
+        let mut prompt_reads = vec![];
+        let mut get = |f: i64| {
+            if fake.0.lock().unwrap().is_empty() {
+                prompt_reads.push(f);
+            }
+            Some(Arc::new(frame(f as f64 / 25.0)))
+        };
+        chain.track(&mut get, &|| false, &mut |_| {}).unwrap();
+        assert_eq!(prompt_reads, [2, 1], "frame 2 carries on from the tracked frame 1; tracked frame 0 boxes both objects as it is");
+        let boxes = fake.0.lock().unwrap().clone();
+        let correction = boxes[0].iter().find(|(g, _)| *g == 2).and_then(|(_, b)| *b).expect("a box prompt");
+        // the tracked disk carried to frame 2 spans x 29..59
+        assert!(correction[0] <= 29.0 && correction[2] >= 59.0, "the box holds the whole disk: {correction:?}");
+    }
+
+    #[test]
+    fn a_correction_before_an_objects_first_stroke_keeps_its_tracked_matte() {
+        for base in [0, 4] {
+            let first = if base == 0 { 3 } else { 1 };
+            let prior = if base == 0 { 1 } else { 3 };
+            let mut data = RotoData::default();
+            data.add(Stroke { kind: StrokeKind::Fg, frame: base, radius: 3.0, points: vec![[40.0, 40.0]], object: 0 }, 4, [0, 4]);
+            data.add(Stroke { kind: StrokeKind::Fg, frame: first, radius: 3.0, points: vec![[15.0, 15.0]], object: 1 }, 4, [0, 4]);
+            data.span = [0, 4];
+            let mut params = params_with(&data);
+            params.values.insert(INPUT_KEY.into(), Value::Str(format!("earlier-object-correction-{base}")));
+            let mut chain = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+            chain.model = Some(Arc::new(TwoObjects(Default::default())));
+            let seed = seed_with(&params, [100.0, 80.0], 25.0, effectcraft_segment::SAM2_TINY.id);
+            chain.keys = data.chain_keys(seed);
+            let image = |f: i64| {
+                let mut img = frame(f as f64 / 25.0);
+                // Match the second object's tracked square, so the carry has a real image edge.
+                for y in 8..22 {
+                    for x in 8..22 {
+                        img.set(x, y, [0.95, 0.9, 0.1, 1.0]);
+                    }
+                }
+                Arc::new(img)
+            };
+            assert_eq!(chain.track(&mut |f| Some(image(f)), &|| false, &mut |_| {}).unwrap().unwrap().frames, 5);
+            let prior_key = chain.keys[&prior];
+            assert!(chain.object_seg(prior, 1).is_some());
+            data.add(Stroke { kind: StrokeKind::Fg, frame: 2, radius: 1.0, points: vec![[19.0, 15.0]], object: 1 }, 4, [0, 4]);
+            chain.data = Arc::new(data.clone());
+            chain.keys = data.chain_keys(seed);
+            assert_eq!(chain.keys[&prior], prior_key, "the nearer tracked frame is still valid");
+            let fake = Arc::new(ClickSquares::default());
+            chain.model = Some(fake.clone());
+            let mut prompt_reads = vec![];
+            let mut get = |f: i64| {
+                if fake.0.lock().unwrap().is_empty() {
+                    prompt_reads.push(f);
+                }
+                Some(image(f))
+            };
+            chain.track(&mut get, &|| false, &mut |_| {}).unwrap();
+            assert_eq!(prompt_reads, [2, prior, first, 2], "corrections carry from the valid tracked matte in either direction");
+            let boxes = fake.0.lock().unwrap().clone();
+            let correction = boxes[1].iter().find(|(g, _)| *g == 2).and_then(|(_, b)| *b).expect("a correction box");
+            assert!(correction[0] <= 10.0 && correction[2] >= 22.0, "the box keeps the whole tracked square, not only the correction: {correction:?}");
+            assert!(correction[2] < 30.0, "the other object's disk stays outside this box: {correction:?}");
+        }
+    }
+
+    #[test]
+    fn corrections_before_the_base_carry_on_from_each_other() {
+        let mut data = RotoData::default();
+        for (frame, object) in [(3, 0), (3, 1), (2, 0), (1, 0)] {
+            data.add(Stroke { kind: StrokeKind::Fg, frame, radius: 3.0, points: vec![[35.0, 40.0]], object }, 3, [0, 3]);
+        }
+        data.span = [0, 3];
+        assert_eq!(data.base, Some(3));
+        let mut params = params_with(&data);
+        params.values.insert(INPUT_KEY.into(), Value::Str("corrections-before-the-base".into()));
+        let mut chain = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+        let fake = Arc::new(ClickSquares::default());
+        chain.model = Some(fake.clone());
+        chain.keys = data.chain_keys(seed_with(&params, [100.0, 80.0], 25.0, effectcraft_segment::SAM2_TINY.id));
+        let mut prompt_reads = vec![];
+        let mut get = |f: i64| {
+            if fake.0.lock().unwrap().is_empty() {
+                prompt_reads.push(f);
+            }
+            Some(Arc::new(frame(f as f64 / 25.0)))
+        };
+        chain.track(&mut get, &|| false, &mut |_| {}).unwrap();
+        assert_eq!(prompt_reads, [3, 2, 3, 1, 2, 3], "object 0: the base, then 2 from 3, then 1 from 2; object 1: the base");
+        let frames: Vec<Vec<i64>> = fake.0.lock().unwrap().iter().map(|o| o.iter().map(|q| q.0).collect()).collect();
+        assert_eq!(frames, [vec![1, 2, 3], vec![3]], "prompts reach the tracker in frame order");
+    }
+
+    #[test]
+    fn prompt_segmentation_reads_only_frames_with_that_objects_foreground() {
+        let mut data = RotoData::default();
+        for (kind, frame, object) in [(StrokeKind::Fg, 0, 0), (StrokeKind::Refine, 1, 0), (StrokeKind::Fg, 2, 1)] {
+            data.add(Stroke { kind, frame, radius: 3.0, points: vec![[35.0, 40.0]], object }, 2, [0, 2]);
+        }
+        data.span = [0, 2];
+        let mut params = params_with(&data);
+        params.values.insert(INPUT_KEY.into(), Value::Str("foreground-only-prompts".into()));
+        let mut chain = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+        let fake = Arc::new(TwoObjects(Default::default()));
+        chain.model = Some(fake.clone());
+        let mut prompt_reads = vec![];
+        let mut get = |f: i64| {
+            if fake.0.lock().unwrap().is_empty() {
+                prompt_reads.push(f);
+            }
+            Some(Arc::new(frame(f as f64 / 25.0)))
+        };
+        assert_eq!(chain.track(&mut get, &|| false, &mut |_| {}).unwrap().unwrap().frames, 3);
+        assert_eq!(prompt_reads, [0, 2], "shared Refine Edge and other objects' frames need no prompt graph cut");
+        assert_eq!(fake.0.lock().unwrap()[0], [1, 1]);
+    }
+
+    #[test]
+    fn separate_object_passes_cancel_at_the_pending_mask_budget() {
+        use std::sync::atomic::Ordering::Relaxed;
+        let mut d = RotoData::default();
+        for object in 0..2 {
+            d.add(Stroke { kind: StrokeKind::Fg, frame: i64::from(object), radius: 3.0, points: vec![[35.0, 40.0]], object }, 8, [0, 24]);
+        }
+        let mut params = params_with(&d);
+        params.values.insert(INPUT_KEY.into(), Value::Str("pending-budget-regression".into()));
+        let mut chain = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+        let fake = Arc::new(SeparatePasses::default());
+        chain.model = Some(fake.clone());
+        let mut get = |f: i64| Some(Arc::new(frame(f as f64 / 25.0)));
+        let mut completed = 0;
+        // Each map takes 32,000 bytes; two incomplete frames exceed this small test budget.
+        let error = chain.track_with_pending_limit(None, &mut get, &|| false, &mut |n| completed = n, 64_000).unwrap_err();
+        assert!(error.contains("pending object masks") && error.contains("memory budget"), "{error}");
+        assert!(fake.cancelled.load(Relaxed), "the model must see cancellation before allocating the rest of the clip");
+        assert_eq!(fake.emitted.load(Relaxed), 2);
+        assert_eq!(completed, 0, "partial objects are not complete tracked frames");
+    }
+
+    /// A cold chain with saved tracking and the same model keeps the saved frames when asked what to save (nothing
+    /// was tracked this session), and Show Object reads a frame the saved tracking has under its own keys.
+    #[test]
+    fn saved_tracking_is_kept_and_its_objects_stay_out_of_another_models_keys() {
+        let mut d = RotoData::default();
+        d.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[35.0, 40.0]], object: 0 }, 2, [0, 24]);
+        let mut params = params_with(&d);
+        params.values.insert(INPUT_KEY.into(), Value::Str("keep-saved-and-objects".into()));
+        let size = [100.0, 80.0];
+        let model = effectcraft_segment::SAM2_TINY.id;
+        let keys = d.chain_keys(seed_with(&params, size, 25.0, model));
+        let (matte, empty) = (vec![1u8; 100 * 80], vec![0u8; 100 * 80]);
+        let frame = TrackFrame { m: rle::encode(&matte), r: rle::encode(&empty), c: 0.9, ..Default::default() };
+        let object = ObjectFrame { m: rle::encode(&matte), r: rle::encode(&empty) };
+        let saved = TrackCache {
+            key: tracks_key(&keys),
+            model: model.into(),
+            size: [100, 80],
+            frames: keys.keys().map(|f| (*f, frame.clone())).collect(),
+            objects: [(1, keys.keys().map(|f| (*f, object.clone())).collect())].into_iter().collect(),
+        };
+        params.values.insert(TRACKED.into(), Value::Str(saved.to_json()));
+        let mut chain = Chain::new(&params, size, 25.0, 1.0);
+        chain.model = Some(Arc::new(TwoObjects(Default::default())));
+        chain.keys = keys.clone();
+        let kept = tracks_of(&chain).expect("the saved tracking is kept");
+        assert_eq!(kept.frames.keys().collect::<Vec<_>>(), saved.frames.keys().collect::<Vec<_>>());
+        assert_eq!(kept.frames.get(&1), saved.frames.get(&1));
+        // another model is chosen now: its keys differ, and the saved object matte is not stored under them
+        let other = d.chain_keys(seed_with(&params, size, 25.0, effectcraft_segment::SAM2_SMALL.id));
+        chain.keys = other.clone();
+        let seg = chain.object_seg(1, 1).expect("the saved object matte");
+        assert_eq!(seg.matte.len(), 100 * 80);
+        assert!(cached(object_key(other[&1], 1), 1.0).is_none(), "the other model's cache holds none of it");
+        for key in [keys[&1], other[&1]] {
+            for scale in [1.0, 0.5] {
+                store(tracked_key(key), scale, seg.clone());
+                store(object_key(key, 1), scale, seg.clone());
+            }
+            trust_cache().lock().unwrap().insert(tracked_key(key), FrameTrust { confidence: 0.9, occluded: false });
+        }
+        chain.forget_tracking();
+        assert!(chain.model.is_none());
+        assert!(!chain.saved_has(1));
+        for key in [keys[&1], other[&1]] {
+            for scale in [1.0, 0.5] {
+                assert!(cached(tracked_key(key), scale).is_none());
+                assert!(cached(object_key(key, 1), scale).is_none());
+            }
+            assert!(trust(key).is_none());
+        }
+        assert!(chain.ensure(1, &mut |_| None, &|| false).is_none(), "neither saved nor in-memory tracking survives fallback");
+    }
+
+    #[test]
+    fn showing_a_missing_tracked_object_never_falls_back_to_other_objects() {
+        let mut d = RotoData::default();
+        for object in 0..2 {
+            d.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 1.0, points: vec![[1.0, 1.0]], object }, 1, [0, 1]);
+        }
+        let union = Arc::new(FrameSeg { w: 4, h: 2, matte: vec![255; 8], refine: vec![0; 8], ..Default::default() });
+        for saved in [false, true] {
+            for scale in [1.0, 0.5] {
+                let mut params = params_with(&d);
+                params.values.insert("version".into(), Value::Scalar(0.0));
+                params.values.insert(INPUT_KEY.into(), Value::Str(format!("missing-object-{saved}-{scale}")));
+                let keys = d.chain_keys(seed(&params, [4.0, 2.0], 25.0));
+                if saved {
+                    let matte = rle::encode(&union.matte);
+                    let refine = rle::encode(&union.refine);
+                    let cache = TrackCache {
+                        key: tracks_key(&keys),
+                        model: effectcraft_segment::CLASSICAL.into(),
+                        size: [4, 2],
+                        frames: [(0, TrackFrame { m: matte.clone(), r: refine.clone(), ..Default::default() })].into_iter().collect(),
+                        objects: [(0, [(0, ObjectFrame { m: matte, r: refine })].into_iter().collect())].into_iter().collect(),
+                    };
+                    params.values.insert(TRACKED.into(), Value::Str(cache.to_json()));
+                } else {
+                    store(tracked_key(keys[&0]), 1.0, union.clone());
+                    store(object_key(keys[&0], 0), 1.0, union.clone());
+                }
+                let mut chain = Chain::new(&params, [4.0, 2.0], 25.0, scale);
+                let expected = downscale(&union, scale);
+                for object in [2, 7] {
+                    chain.show_object = object;
+                    let shown = chain.ensure(0, &mut |_| None, &|| false).expect("tracked frame");
+                    assert_eq!((shown.w, shown.h, shown.area()), (expected.w, expected.h, 0), "saved={saved}, scale={scale}, object={object}");
+                }
+                assert!(chain.shown_object(1).is_none(), "untracked frames keep their existing fallback");
+                for object in [0, 1] {
+                    chain.show_object = object;
+                    assert_eq!(chain.ensure(0, &mut |_| None, &|| false).unwrap().matte, expected.matte);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn saved_tracking_decoders_validate_dimensions_and_plane_lengths() {
+        let valid = rle::encode(&[255, 0, 255, 0]);
+        let mut cache = TrackCache {
+            size: [2, 2],
+            frames: [(0, TrackFrame { m: valid.clone(), r: valid.clone(), ..Default::default() })].into_iter().collect(),
+            objects: [(1, [(0, ObjectFrame { m: valid.clone(), r: valid.clone() })].into_iter().collect())].into_iter().collect(),
+            ..Default::default()
+        };
+        assert_eq!(decode_tracked(&cache, 0).unwrap().matte, [255, 0, 255, 0]);
+        assert_eq!(decode_object(&cache, 0, 1).unwrap().refine, [255, 0, 255, 0]);
+        for (size, matte, refine) in [
+            ([0, 2], rle::encode(&[]), rle::encode(&[])),
+            ([2, 0], rle::encode(&[]), rle::encode(&[])),
+            ([usize::MAX, 2], valid.clone(), valid.clone()),
+            ([rle::MAX_PLANE_BYTES + 1, 1], valid.clone(), valid.clone()),
+            ([2, 2], rle::encode(&[0; 5]), valid.clone()),
+            ([2, 2], valid.clone(), rle::encode(&[0; 5])),
+            ([2, 2], rle::encode(&[0; 3]), valid.clone()),
+            ([2, 2], valid, rle::encode(&[0; 3])),
+        ] {
+            cache.size = size;
+            cache.frames.insert(0, TrackFrame { m: matte.clone(), r: refine.clone(), ..Default::default() });
+            cache.objects.insert(1, [(0, ObjectFrame { m: matte, r: refine })].into_iter().collect());
+            assert!(decode_tracked(&cache, 0).is_none(), "tracked plane {size:?}");
+            assert!(decode_object(&cache, 0, 1).is_none(), "object plane {size:?}");
+        }
+    }
+
+    #[test]
+    fn a_one_direction_pass_tracks_and_reports_only_its_frames() {
+        let mut d = RotoData::default();
+        d.add(Stroke { kind: StrokeKind::Fg, frame: 12, radius: 3.0, points: vec![[35.0, 40.0]], object: 0 }, 12, [0, 24]);
+        let params = params_with(&d);
+        let mut chain = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+        chain.model = Some(Arc::new(TwoObjects(Default::default())));
+        let mut get = |f: i64| Some(Arc::new(frame(f as f64 / 25.0)));
+        let forward: Vec<i64> = (12..=24).collect();
+        let mut last = 0;
+        let summary = chain.track_frames(Some(&forward), &mut get, &|| false, &mut |n| last = n).unwrap().unwrap();
+        assert_eq!((summary.frames, last), (forward.len(), forward.len()), "progress never exceeds the frames asked for");
+        let _ = chain.ensure(5, &mut get, &|| false);
+        assert!(tracks_of(&chain).is_none_or(|t| t.frames.keys().all(|f| *f >= 12)), "earlier frames were not tracked");
+    }
+
+    #[test]
+    fn propagation_replaces_saved_tracking_from_a_different_model() {
+        let mut d = RotoData::default();
+        d.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[35.0, 40.0]], object: 0 }, 2, [0, 24]);
+        let mut params = params_with(&d);
+        params.values.insert(INPUT_KEY.into(), Value::Str("replace-saved-tracking-model".into()));
+        let size = [100.0, 80.0];
+        let old_model = effectcraft_segment::SAM2_SMALL.id;
+        let old_keys = d.chain_keys(seed_with(&params, size, 25.0, old_model));
+        let empty = vec![0; 100 * 80];
+        let old_frame = TrackFrame { m: rle::encode(&empty), r: rle::encode(&empty), c: 0.2, ..Default::default() };
+        let saved = TrackCache {
+            key: tracks_key(&old_keys),
+            model: old_model.into(),
+            size: [100, 80],
+            frames: old_keys.keys().map(|f| (*f, old_frame.clone())).collect(),
+            ..Default::default()
+        };
+        params.values.insert(TRACKED.into(), Value::Str(saved.to_json()));
+        let mut chain = Chain::new(&params, size, 25.0, 1.0);
+        let fake = Arc::new(TwoObjects(Default::default()));
+        chain.model = Some(fake.clone());
+        chain.keys = d.chain_keys(seed_with(&params, size, 25.0, fake.info().id));
+        let mut get = |f: i64| Some(Arc::new(frame(f as f64 / 25.0)));
+        assert_eq!(chain.saved_model(), Some(old_model));
+        assert_eq!(chain.ensure(0, &mut get, &|| false).unwrap().area(), 0, "rendering keeps the saved matte until propagation");
+        chain.prepare_propagation();
+        assert_eq!(chain.saved_model(), None);
+        assert_eq!(chain.track(&mut get, &|| false, &mut |_| {}).unwrap().unwrap().frames, 3);
+        assert_eq!(fake.0.lock().unwrap().len(), 1, "the newly selected tracker must actually run");
+        assert!(chain.ensure(0, &mut get, &|| false).unwrap().area() > 0);
+        let replacement = tracks_of(&chain).expect("new tracking is saved");
+        assert_eq!(replacement.model, effectcraft_segment::SAM2_TINY.id);
+        assert_eq!(replacement.frames.len(), 3);
+        params.values.insert(TRACKED.into(), Value::Str(replacement.to_json()));
+        let mut reopened = Chain::new(&params, size, 25.0, 1.0);
+        assert_eq!(reopened.saved_model(), Some(effectcraft_segment::SAM2_TINY.id));
+        assert!(reopened.ensure(0, &mut get, &|| false).unwrap().area() > 0, "reopening uses the replacement without loading its model");
+        reopened.model = Some(fake.clone());
+        reopened.keys = chain.keys.clone();
+        reopened.prepare_propagation();
+        assert_eq!(reopened.saved_model(), Some(effectcraft_segment::SAM2_TINY.id));
+        assert_eq!(reopened.track(&mut get, &|| false, &mut |_| {}).unwrap().unwrap().frames, 0, "matching saved tracking is reused");
+        assert_eq!(fake.0.lock().unwrap().len(), 1);
+        let mut classic = Chain::new(&params, size, 25.0, 1.0);
+        classic.model = None;
+        classic.prepare_propagation();
+        assert_eq!(classic.saved_model(), None, "Classic propagation also replaces saved model tracking");
+    }
+
+    #[test]
+    fn objects_are_followed_in_one_pass_and_their_mattes_united() {
+        let mut d = RotoData::default();
+        let stroke = |kind, points: Vec<[f64; 2]>, object| Stroke { kind, frame: 0, radius: 3.0, points, object };
+        d.add(stroke(StrokeKind::Fg, vec![[35.0, 40.0], [45.0, 40.0]], 0), 8, [0, 24]);
+        d.add(stroke(StrokeKind::Fg, vec![[12.0, 15.0], [18.0, 15.0]], 1), 8, [0, 24]);
+        d.add(stroke(StrokeKind::Bg, vec![[85.0, 70.0], [95.0, 70.0]], 0), 8, [0, 24]);
+        assert_eq!(d.objects(), vec![0, 1]);
+        // the Refine Edge strokes belong to every object; the others only to their own
+        assert_eq!(d.strokes_of(0, 1).len(), 1);
+        assert_eq!(d.strokes_of(0, 0).len(), 2);
+        let params = params_with(&d);
+        let mut chain = Chain::new(&params, [100.0, 80.0], 25.0, 1.0);
+        let fake = Arc::new(TwoObjects(Default::default()));
+        chain.model = Some(fake.clone());
+        // the clip: the moving disk and a fixed yellow square
+        let mut get = |f: i64| {
+            let mut img = frame(f as f64 / 25.0 + 0.001);
+            for y in 8..22 {
+                for x in 8..22 {
+                    img.set(x, y, [0.95, 0.9, 0.1 + ((x * 3 + y * 5) % 7) as f32 / 70.0, 1.0]);
+                }
+            }
+            Some(Arc::new(img))
+        };
+        let mut seen = 0;
+        let summary = chain.track(&mut get, &|| false, &mut |n| seen = n).unwrap().unwrap();
+        // one request for both objects; object 0 has its foreground and background prompt on the frame, object 1 its own
+        assert_eq!(fake.0.lock().unwrap().len(), 1);
+        assert_eq!(fake.0.lock().unwrap()[0], vec![1, 1]);
+        assert_eq!(summary.frames, 9);
+        assert_eq!(seen, 9);
+        // the least sure object sets the frame's confidence
+        assert!((summary.min_confidence - 0.4).abs() < 1e-6, "{}", summary.min_confidence);
+        assert_eq!(summary.occluded, 0);
+        let seg = cached(tracked_key(chain.keys[&3]), 1.0).expect("frame 3 is tracked");
+        let at = |x: usize, y: usize| seg.matte[y * 100 + x];
+        assert!(at(46, 40) != 0, "the moving disk (frame 3 centre x = 46)");
+        assert!(at(15, 15) != 0, "the fixed square");
+        assert_eq!(at(60, 70), 0, "nothing elsewhere");
+
+        // each object keeps its own matte
+        let (disk, square) = (chain.object_seg(3, 0).expect("object 0"), chain.object_seg(3, 1).expect("object 1"));
+        assert!(disk.matte[40 * 100 + 46] != 0 && disk.matte[15 * 100 + 15] == 0);
+        assert!(square.matte[15 * 100 + 15] != 0 && square.matte[40 * 100 + 46] == 0);
+        // Show Object picks one (its id plus one); an object the instance does not have shows nothing; 0 shows all
+        let mut shown = |c: &Chain| c.ensure(3, &mut get, &|| false).expect("frame 3");
+        chain.show_object = 2;
+        let one = shown(&chain);
+        assert!(one.matte[15 * 100 + 15] != 0 && one.matte[40 * 100 + 46] == 0, "only the square");
+        chain.show_object = 1;
+        let zero = shown(&chain);
+        assert!(zero.matte[40 * 100 + 46] != 0 && zero.matte[15 * 100 + 15] == 0, "only the disk");
+        chain.show_object = 7;
+        assert_eq!(shown(&chain).area(), 0, "no such object");
+        chain.show_object = 0;
+        assert!(shown(&chain).matte[15 * 100 + 15] != 0, "all together");
+
+        // the objects are saved with the tracking and come back from the project file
+        let saved = tracks_of(&chain).expect("tracking to save");
+        assert_eq!(saved.objects.keys().copied().collect::<Vec<_>>(), vec![0, 1]);
+        assert_eq!(saved.objects.get(&1).map(|f| f.len()), Some(9));
+        assert_eq!(TrackCache::from_json(&saved.to_json()), Some(saved.clone()));
+        // a tracking saved before objects existed has none
+        let old = TrackCache { objects: Default::default(), ..saved.clone() };
+        assert!(!old.to_json().contains("objects"));
+        let rt = decode_object(&saved, 3, 1).expect("decoded");
+        assert!(rt.matte[15 * 100 + 15] != 0 && rt.matte[40 * 100 + 46] == 0);
+    }
+
     /// Instances saved before the propagation controls got their own twirl-down (and motion
     /// blur / decontamination their nested ones) load with their values in the new places.
     #[test]
diff --git a/crates/effects/src/roto/pending.rs b/crates/effects/src/roto/pending.rs
new file mode 100644
index 000000000..256789ee9
--- /dev/null
+++ b/crates/effects/src/roto/pending.rs
@@ -0,0 +1,138 @@
+//! Bounded assembly of the objects a tracker reports separately for each frame.
+
+use std::collections::BTreeMap;
+use std::mem::size_of;
+
+use effectcraft_segment::TrackedFrame;
+
+/// Separate from the model's memory banks: probability maps are full-resolution and can otherwise
+/// grow with the entire clip when objects start on different frames.
+pub(super) const MAX_PENDING_BYTES: usize = 256 << 20;
+
+pub(super) struct PendingMasks {
+    frames: BTreeMap<i64, Vec<Option<TrackedFrame>>>,
+    objects: usize,
+    bytes: usize,
+    limit: usize,
+}
+
+impl PendingMasks {
+    pub(super) fn new(objects: usize, limit: usize) -> Self {
+        Self { frames: BTreeMap::new(), objects, bytes: 0, limit }
+    }
+
+    /// Probability allocation plus a conservative allowance for the map node and object slots.
+    fn frame_bytes(&self) -> usize {
+        self.objects.saturating_mul(size_of::<Option<TrackedFrame>>()).saturating_add(256)
+    }
+
+    fn mask_bytes(mask: &TrackedFrame) -> usize {
+        mask.prob.capacity().saturating_mul(size_of::<f32>())
+    }
+
+    /// Complete frames leave immediately; incomplete frames may never exceed the budget. A rejected
+    /// insertion leaves the buffer unchanged, including when it replaces an object's previous result.
+    pub(super) fn insert(&mut self, object: usize, frame: i64, mask: TrackedFrame) -> Result<Option<Vec<Option<TrackedFrame>>>, String> {
+        if object >= self.objects {
+            return Err("tracker reported an unknown object".into());
+        }
+        if self.objects == 1 {
+            return Ok(Some(vec![Some(mask)]));
+        }
+        let existing = self.frames.get(&frame);
+        let old_bytes = existing.and_then(|p| p.get(object)).and_then(Option::as_ref).map_or(0, Self::mask_bytes);
+        let added = Self::mask_bytes(&mask).saturating_add(if existing.is_none() { self.frame_bytes() } else { 0 });
+        let bytes = self.bytes.saturating_sub(old_bytes).checked_add(added);
+        let Some(bytes) = bytes.filter(|n| *n <= self.limit) else {
+            return Err(format!("pending object masks exceed their {} MiB memory budget", self.limit >> 20));
+        };
+        let parts = self.frames.entry(frame).or_insert_with(|| vec![None; self.objects]);
+        if let Some(slot) = parts.get_mut(object) {
+            *slot = Some(mask);
+        }
+        self.bytes = bytes;
+        if parts.iter().all(Option::is_some) {
+            let parts = self.frames.remove(&frame).unwrap_or_default();
+            let used = parts.iter().flatten().fold(self.frame_bytes(), |n, m| n.saturating_add(Self::mask_bytes(m)));
+            self.bytes = self.bytes.saturating_sub(used);
+            return Ok(Some(parts));
+        }
+        Ok(None)
+    }
+
+    pub(super) fn into_incomplete(self) -> BTreeMap<i64, Vec<Option<TrackedFrame>>> {
+        self.frames
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn mask(value: f32) -> TrackedFrame {
+        TrackedFrame { prob: vec![value; 16], w: 4, h: 4, confidence: value, occluded: false }
+    }
+
+    #[test]
+    fn different_start_passes_stop_before_buffering_the_whole_clip() {
+        let mut pending = PendingMasks::new(2, 2048);
+        let mut accepted = 0;
+        // SAM 2 can report all of object 0 before starting object 1. A long clip must stop
+        // at the memory limit even though no frame has received all its objects yet.
+        for frame in 0..10_000 {
+            match pending.insert(0, frame, mask(0.9)) {
+                Ok(None) => accepted += 1,
+                Ok(Some(_)) => panic!("no frame is complete yet"),
+                Err(e) => {
+                    assert!(e.contains("memory budget"), "{e}");
+                    break;
+                }
+            }
+        }
+        assert!(accepted > 0 && accepted < 10_000);
+        assert_eq!(pending.frames.len(), accepted);
+        assert!(pending.bytes <= pending.limit);
+        let before = pending.bytes;
+        assert!(pending.insert(0, 10_001, mask(0.8)).is_err());
+        assert_eq!(pending.bytes, before, "rejection must not retain the new map");
+    }
+
+    #[test]
+    fn interleaved_objects_release_the_budget_and_keep_their_masks() {
+        let mut pending = PendingMasks::new(2, 2048);
+        for frame in 0..10_000 {
+            let first = (frame % 2) as usize;
+            assert!(pending.insert(first, frame, mask(first as f32)).unwrap().is_none());
+            let parts = pending.insert(1 - first, frame, mask((1 - first) as f32)).unwrap().unwrap();
+            assert_eq!(parts[0].as_ref().unwrap().prob, vec![0.0; 16]);
+            assert_eq!(parts[1].as_ref().unwrap().prob, vec![1.0; 16]);
+            assert!(pending.frames.is_empty());
+            assert_eq!(pending.bytes, 0);
+        }
+    }
+
+    #[test]
+    fn replacements_charge_capacity_and_partial_frames_are_preserved() {
+        let mut pending = PendingMasks::new(2, 2048);
+        pending.insert(0, 7, mask(0.1)).unwrap();
+        let before = pending.bytes;
+        pending.insert(0, 7, mask(0.2)).unwrap();
+        assert_eq!(pending.bytes, before, "a duplicate replaces rather than accumulates");
+        let mut oversized = mask(0.3);
+        oversized.prob.reserve(2048);
+        assert!(pending.insert(0, 7, oversized).is_err(), "capacity, not length, owns the memory");
+        assert_eq!(pending.bytes, before);
+        let frames = pending.into_incomplete();
+        assert_eq!(frames[&7][0].as_ref().unwrap().prob, vec![0.2; 16]);
+        assert!(frames[&7][1].is_none());
+    }
+
+    #[test]
+    fn single_objects_need_no_pending_budget_and_unknown_objects_are_rejected() {
+        let mut pending = PendingMasks::new(1, 0);
+        assert!(pending.insert(0, 0, mask(0.9)).unwrap().is_some());
+        assert_eq!(pending.bytes, 0);
+        assert!(pending.insert(1, 0, mask(0.9)).is_err());
+        assert!(pending.frames.is_empty());
+    }
+}
diff --git a/crates/effects/src/sim.rs b/crates/effects/src/sim.rs
index 14146a9f4..ca5bc5126 100644
--- a/crates/effects/src/sim.rs
+++ b/crates/effects/src/sim.rs
@@ -15,2019 +15,31 @@ use effectcraft_raster::{Image, Px};
 use rayon::prelude::*;
 
 use crate::generate::value_noise;
-use crate::util::{SimCache, hash1, params_key, params_key_except, unpremul};
+use crate::util::{SimCache, hash1, params_key_except, unpremul};
 use crate::{Buf, EffectCtx, EffectSpec, col, num, p, popup, slider};
 
-pub(crate) fn spec(id: &'static str, name: &'static str, params: Vec<crate::ParamSpec>, render: crate::RenderFn) -> EffectSpec {
-    EffectSpec { id, name, category: "Simulation", params, render, gpu: false, float: true }
-}
-
-pub(crate) fn pt(x: f64, y: f64) -> Value {
-    Value::Vec2([x, y])
-}
-
-pub(crate) fn pct() -> ParamUi {
-    slider(0.0, 100.0, 0.0, 100.0, 1)
-}
-
-/// Deterministic hash → [0, 1).
-#[inline]
-pub(crate) fn h(i: u32, k: u32, seed: u32) -> f32 {
-    hash1(i, k, seed)
-}
-
-/// Signed hash → [-1, 1).
-#[inline]
-pub(crate) fn hs(i: u32, k: u32, seed: u32) -> f32 {
-    hash1(i, k, seed) * 2.0 - 1.0
-}
-
-// ------------------------------------------------------------------ band rasteriser
-
-const BAND: usize = 16;
-
-/// How rasterised items combine with what is already in the target.
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum Acc {
-    /// Premultiplied "over" (later items on top).
-    Over,
-    /// Additive (glows, light).
-    Add,
-}
-
-/// Rasterise many small items into `img` (buffer pixels). `bbox` gives an item's pixel bounds
-/// `[x0, y0, x1, y1]` (or `None` to skip), `shade` its premultiplied colour at a pixel centre.
-/// Items are bucketed into horizontal bands rendered in parallel; within a band they are drawn
-/// in slice order.
-pub(crate) fn raster<T: Sync>(
-    img: &mut Image,
-    items: &[T],
-    bbox: impl Fn(&T) -> Option<[f32; 4]> + Sync,
-    shade: impl Fn(&T, f32, f32) -> Option<Px> + Sync,
-    acc: Acc,
-) {
-    let (w, hgt) = (img.width as usize, img.height as usize);
-    if w == 0 || hgt == 0 || items.is_empty() {
-        return;
-    }
-    let nb = hgt.div_ceil(BAND);
-    let boxes: Vec<Option<[i32; 4]>> = items
-        .par_iter()
-        .map(|it| {
-            let b = bbox(it)?;
-            if !(b[0].is_finite() && b[1].is_finite() && b[2].is_finite() && b[3].is_finite()) {
-                return None;
-            }
-            let x0 = b[0].floor().max(0.0) as i32;
-            let y0 = b[1].floor().max(0.0) as i32;
-            let x1 = (b[2].ceil() as i32).min(w as i32 - 1);
-            let y1 = (b[3].ceil() as i32).min(hgt as i32 - 1);
-            if x1 < x0 || y1 < y0 || b[2] < 0.0 || b[3] < 0.0 {
-                return None;
-            }
-            Some([x0, y0, x1, y1])
-        })
-        .collect();
-    let mut buckets: Vec<Vec<u32>> = vec![Vec::new(); nb];
-    for (i, b) in boxes.iter().enumerate() {
-        if let Some(b) = b {
-            for band in (b[1] as usize / BAND)..=(b[3] as usize / BAND).min(nb - 1) {
-                buckets[band].push(i as u32);
-            }
-        }
-    }
-    img.data.par_chunks_mut(w * BAND).enumerate().for_each(|(band, chunk)| {
-        let by0 = band * BAND;
-        let rows = chunk.len() / w;
-        for &i in &buckets[band] {
-            let Some(b) = boxes[i as usize] else { continue };
-            let it = &items[i as usize];
-            let ya = (b[1] as usize).max(by0);
-            let yb = (b[3] as usize).min(by0 + rows - 1);
-            for y in ya..=yb {
-                let row = &mut chunk[(y - by0) * w..(y - by0 + 1) * w];
-                for x in b[0] as usize..=b[2] as usize {
-                    if let Some(c) = shade(it, x as f32 + 0.5, y as f32 + 0.5) {
-                        let d = &mut row[x];
-                        match acc {
-                            Acc::Over => {
-                                let k = 1.0 - c[3];
-                                *d = [c[0] + d[0] * k, c[1] + d[1] * k, c[2] + d[2] * k, c[3] + d[3] * k];
-                            }
-                            Acc::Add => {
-                                *d = [d[0] + c[0], d[1] + c[1], d[2] + c[2], (d[3] + c[3]).min(1.0)];
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    });
-}
-
-// ------------------------------------------------------------------ sprites
-
-#[derive(Clone, Copy, PartialEq, Debug)]
-pub enum Shape {
-    /// Soft round dot (Gaussian-like falloff).
-    Soft,
-    /// Hard anti-aliased disc.
-    Disc,
-    /// Lit sphere (upper-left light, specular).
-    Sphere,
-    /// Disc fading linearly to its rim.
-    Faded,
-    /// Thin ring with a highlight.
-    Bubble,
-    /// Four-point star.
-    Star,
-    /// Rotated square (angle in `rot`).
-    Square,
-    /// Triangle (angle in `rot`).
-    Tri,
-    /// Segment from (x, y) by (dx, dy), half-width `r`.
-    Line { dx: f32, dy: f32 },
-}
-
-/// A particle sprite in buffer pixels; `c` is straight colour + opacity.
-#[derive(Clone, Copy, Debug)]
-pub struct Sprite {
-    pub x: f32,
-    pub y: f32,
-    pub r: f32,
-    pub c: [f32; 4],
-    pub shape: Shape,
-    pub rot: f32,
-}
-
-impl Sprite {
-    pub(crate) fn new(x: f32, y: f32, r: f32, c: [f32; 4], shape: Shape) -> Sprite {
-        Sprite { x, y, r, c, shape, rot: 0.0 }
-    }
-}
-
-/// Where a sprite's colour comes from when it depends on the layer's pixels (resolved by
-/// [`SpritePlan::resolve`] on the CPU, per pixel by the GPU compositor). Positions are buffer
-/// pixels.
-#[derive(Clone, Copy, Debug)]
-pub enum Tint {
-    /// The sprite's own colour.
-    Fixed,
-    /// CC Rainfall's refracting drops: where the layer shows (alpha > 0), colour × (layer
-    /// colour × 0.6 + 0.5) sampled at (x, y).
-    Refract { x: f64, y: f64 },
-    /// CC Star Burst: the layer's colour at (x, y), opacity × its alpha (none where clear).
-    Source { x: f64, y: f64 },
-    /// CC Hair: the root's colour at (x, y) mixed with the hair colour (`inherit` = 1 keeps the
-    /// root's), × `shade`, + `spec`; no strand where the root's alpha is below ½.
-    Root { x: f64, y: f64, hair: [f32; 3], inherit: f32, shade: f32, spec: f32 },
-}
-
-/// How a sprite layer meets the original layer.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Post {
-    /// [`combine`] with this mode (0 Composite … 5 sprites only).
-    Combine(u32),
-    /// The sprites alone.
-    Replace,
-    /// The sprites, mixed toward the original by this fraction.
-    Lerp(f32),
-    /// The sprites over opaque black.
-    OverBlack,
-}
-
-/// What a sprite-drawing effect draws this frame: built on the CPU (closed-form or from the
-/// simulation state), rasterised by [`SpritePlan::finish`] or the GPU compositor.
-#[derive(Clone, Debug)]
-pub struct SpritePlan {
-    pub sprites: Vec<Sprite>,
-    /// Per sprite (empty = all [`Tint::Fixed`]).
-    pub tints: Vec<Tint>,
-    pub acc: Acc,
-    pub post: Post,
-}
-
-impl SpritePlan {
-    /// Resolve layer-dependent colours against the layer `src`.
-    pub fn resolve(&mut self, src: &Image) {
-        let tints = std::mem::take(&mut self.tints);
-        self.sprites.par_iter_mut().zip(tints.par_iter()).for_each(|(sp, t)| match *t {
-            Tint::Fixed => {}
-            Tint::Refract { x, y } => {
-                let (sc, sa) = unpremul(src.sample_bilinear(x, y));
-                if sa > 0.0 {
-                    let c = sp.c;
-                    sp.c = [(sc[0] * 0.6 + 0.5) * c[0], (sc[1] * 0.6 + 0.5) * c[1], (sc[2] * 0.6 + 0.5) * c[2], c[3]];
-                }
-            }
-            Tint::Source { x, y } => {
-                let (c, a) = unpremul(src.sample_bilinear(x, y));
-                sp.c = if a <= 0.0 { [0.0; 4] } else { [c[0], c[1], c[2], a * sp.c[3]] };
-            }
-            Tint::Root { x, y, hair, inherit, shade, spec } => {
-                let root = src.sample_bilinear(x, y);
-                if root[3] < 0.5 {
-                    sp.c = [0.0; 4];
-                    return;
-                }
-                let (rc, _) = unpremul(root);
-                let base: [f32; 3] = std::array::from_fn(|k| rc[k] + (hair[k] - rc[k]) * (1.0 - inherit));
-                sp.c = [base[0] * shade + spec, base[1] * shade + spec, base[2] * shade + spec, sp.c[3]];
-            }
-        });
-    }
-
-    /// Rasterise (after [`SpritePlan::resolve`]) and meet the original layer `b`.
-    pub fn finish(&self, b: Buf) -> Buf {
-        let fx = splat(b.img.width, b.img.height, &self.sprites, self.acc);
-        self.finish_with(b, fx)
-    }
-
-    /// [`finish`](Self::finish) with a prepared sprite image (the motion-blurred average of
-    /// several frames, #1195).
-    pub fn finish_with(&self, b: Buf, fx: Image) -> Buf {
-        self.post.apply(b, fx)
-    }
-}
-
-impl Post {
-    /// Meet the sprite image `fx` with the original layer `b` (see [`SpritePlan::finish`]).
-    fn apply(self, mut b: Buf, fx: Image) -> Buf {
-        b.img = match self {
-            Post::Combine(m) => combine(&b.img, &fx, m),
-            Post::Replace => fx,
-            Post::Lerp(t) => {
-                let mut o = fx;
-                o.data.par_iter_mut().zip(b.img.data.par_iter()).for_each(|(o, s0)| *o = crate::util::lerp4(*o, *s0, t));
-                o
-            }
-            Post::OverBlack => combine(&Image::filled(b.img.width, b.img.height, [0.0, 0.0, 0.0, 1.0]), &fx, 0),
-        };
-        b
-    }
-}
-
-/// The sprite plan of a sprite-drawing simulation effect for buffer geometry `b` (its pixels
-/// are not read), `None` for other effects or settings drawn otherwise (the GPU compositor's
-/// render pass).
-pub fn sprite_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option<SpritePlan> {
-    match id {
-        "ec.sim.ccrainfall" => Some(rainfall_plan(ctx, b)),
-        "ec.sim.ccsnowfall" => Some(snowfall_plan(ctx, b)),
-        "ec.sim.ccstarburst" => Some(star_burst_plan(ctx, b)),
-        "ec.sim.cchair" => crate::sim3::hair_plan(ctx, b),
-        "ec.sim.waveworld" => crate::sim2::wave_world_plan(ctx, b).and_then(|p| match p {
-            crate::sim2::WavePlan::Wire(sp) => Some(sp),
-            crate::sim2::WavePlan::Height { .. } => None,
-        }),
-        "ec.sim.foam" => crate::sim2::foam_plan(ctx, b),
-        "ec.sim.ccparticleworld" => particle_world_plan(ctx, b),
-        "ec.sim.ccparticlesystems2" => Some(particle_systems2_plan(ctx, b)),
-        _ => None,
-    }
-}
-
-fn sprite_bbox(s: &Sprite) -> Option<[f32; 4]> {
-    if s.c[3] <= 1e-5 || s.r <= 0.0 {
-        return None;
-    }
-    let r = s.r.max(0.5) + 1.0;
-    Some(match s.shape {
-        Shape::Line { dx, dy } => [s.x.min(s.x + dx) - r, s.y.min(s.y + dy) - r, s.x.max(s.x + dx) + r, s.y.max(s.y + dy) + r],
-        Shape::Star => [s.x - r * 2.0, s.y - r * 2.0, s.x + r * 2.0, s.y + r * 2.0],
-        _ => [s.x - r, s.y - r, s.x + r, s.y + r],
-    })
-}
-
-#[inline]
-fn aa(edge: f32) -> f32 {
-    (edge + 0.5).clamp(0.0, 1.0)
-}
-
-fn sprite_shade(s: &Sprite, x: f32, y: f32) -> Option<Px> {
-    // Sub-pixel sprites keep their energy: draw at radius 0.5 with reduced opacity.
-    let (r, fade) = if s.r < 0.5 { (0.5, s.r / 0.5) } else { (s.r, 1.0) };
-    let (dx, dy) = (x - s.x, y - s.y);
-    let mut rgb = [s.c[0], s.c[1], s.c[2]];
-    let cov = match s.shape {
-        Shape::Soft => {
-            let d2 = (dx * dx + dy * dy) / (r * r);
-            if d2 >= 1.0 {
-                return None;
-            }
-            let q = 1.0 - d2;
-            q * q
-        }
-        Shape::Disc => aa(r - (dx * dx + dy * dy).sqrt()),
-        Shape::Faded => {
-            let d = (dx * dx + dy * dy).sqrt() / r;
-            (1.0 - d).max(0.0).powf(1.5)
-        }
-        Shape::Sphere => {
-            let d = (dx * dx + dy * dy).sqrt();
-            let cv = aa(r - d);
-            if cv <= 0.0 {
-                return None;
-            }
-            let (nx, ny) = (dx / r, dy / r);
-            let nz = (1.0 - nx * nx - ny * ny).max(0.0).sqrt();
-            let (lx, ly, lz) = (-0.48, -0.58, 0.66);
-            let diff = (nx * lx + ny * ly + nz * lz).max(0.0);
-            let rz = 2.0 * diff * nz - lz;
-            let spec = rz.max(0.0).powi(20) * 0.6;
-            let k = 0.2 + 0.8 * diff;
-            rgb = [rgb[0] * k + spec, rgb[1] * k + spec, rgb[2] * k + spec];
-            cv
-        }
-        Shape::Bubble => {
-            let d = (dx * dx + dy * dy).sqrt() / r;
-            if d > 1.0 + 1.0 / r {
-                return None;
-            }
-            let ring = (1.0 - ((d - 0.9) / 0.12).powi(2)).max(0.0);
-            let hl = (1.0 - (((dx / r) + 0.4).powi(2) + ((dy / r) + 0.4).powi(2)) / 0.04).max(0.0);
-            (0.12 * (d <= 1.0) as u8 as f32 + ring * 0.8 + hl).min(1.0)
-        }
-        Shape::Star => {
-            let (sn, cs) = s.rot.sin_cos();
-            let (ux, uy) = ((dx * cs + dy * sn) / r, (-dx * sn + dy * cs) / r);
-            let d = (ux * ux + uy * uy).sqrt();
-            let core = (1.0 - d).max(0.0).powi(2);
-            let sx = (1.0 - ux.abs() / 2.0).max(0.0) * (1.0 - (uy.abs() * 6.0)).max(0.0);
-            let sy = (1.0 - uy.abs() / 2.0).max(0.0) * (1.0 - (ux.abs() * 6.0)).max(0.0);
-            (core + sx + sy).min(1.0)
-        }
-        Shape::Square => {
-            let (sn, cs) = s.rot.sin_cos();
-            let (ux, uy) = (dx * cs + dy * sn, -dx * sn + dy * cs);
-            let e = r * 0.75;
-            aa(e - ux.abs()) * aa(e - uy.abs())
-        }
-        Shape::Tri => {
-            let (sn, cs) = s.rot.sin_cos();
-            let (ux, uy) = (dx * cs + dy * sn, -dx * sn + dy * cs);
-            // Equilateral triangle with circumradius r: three half-planes.
-            let e = r * 0.5;
-            let mut m = f32::INFINITY;
-            for k in 0..3 {
-                let a = std::f32::consts::FRAC_PI_2 + k as f32 * std::f32::consts::TAU / 3.0;
-                let (ns, nc) = a.sin_cos();
-                m = m.min(e - (ux * nc + uy * ns));
-            }
-            aa(m)
-        }
-        Shape::Line { dx: lx, dy: ly } => {
-            let l2 = lx * lx + ly * ly;
-            let t = if l2 > 0.0 { ((dx * lx + dy * ly) / l2).clamp(0.0, 1.0) } else { 0.0 };
-            let (px, py) = (dx - lx * t, dy - ly * t);
-            aa(r - (px * px + py * py).sqrt())
-        }
-    };
-    let a = cov * s.c[3] * fade;
-    if a <= 1e-6 {
-        return None;
-    }
-    Some([rgb[0] * a, rgb[1] * a, rgb[2] * a, a])
-}
-
-/// Draw sprites into a new transparent image of `w`×`h`.
-pub(crate) fn splat(w: u32, hgt: u32, sprites: &[Sprite], acc: Acc) -> Image {
-    let mut img = Image::new(w, hgt);
-    raster(&mut img, sprites, sprite_bbox, sprite_shade, acc);
-    img
-}
-
-/// Combine an effect layer `fx` with the original `src` (both premultiplied, same size):
-/// 0 Composite (fx over src), 1 Screen, 2 Add, 3 Lighten, 4 Darken, 5 fx only.
-pub(crate) fn combine(src: &Image, fx: &Image, mode: u32) -> Image {
-    let mut out = fx.clone();
-    out.data.par_iter_mut().zip(src.data.par_iter()).for_each(|(o, s)| {
-        let f = *o;
-        *o = match mode {
-            0 => {
-                let k = 1.0 - f[3];
-                [f[0] + s[0] * k, f[1] + s[1] * k, f[2] + s[2] * k, f[3] + s[3] * k]
-            }
-            1 => [s[0] + f[0] - s[0] * f[0], s[1] + f[1] - s[1] * f[1], s[2] + f[2] - s[2] * f[2], s[3] + f[3] - s[3] * f[3]],
-            2 => [s[0] + f[0], s[1] + f[1], s[2] + f[2], (s[3] + f[3]).min(1.0)],
-            3 => [s[0].max(f[0]), s[1].max(f[1]), s[2].max(f[2]), s[3] + f[3] - s[3] * f[3]],
-            4 => {
-                let (fc, fa) = unpremul(f);
-                let m = |c: f32, k: usize| c - (c - c.min(fc[k] * s[3])) * fa;
-                [m(s[0], 0), m(s[1], 1), m(s[2], 2), s[3]]
-            }
-            _ => f,
-        };
-    });
-    out
-}
-
-// ------------------------------------------------------------------ CC Rainfall / CC Snowfall
-
-/// Shared weather layout: per-item depth factor `k` in (0, 1] (1 = nearest) from Scene Depth.
-#[inline]
-fn depth_k(z: f32, scene_depth: f32) -> f32 {
-    1.0 / (1.0 + z * scene_depth / 2500.0)
-}
-
-/// Wrap `v` into `[lo, lo + span)`.
-#[inline]
-fn wrap(v: f32, lo: f32, span: f32) -> f32 {
-    if span <= 0.0 { v } else { lo + (v - lo).rem_euclid(span) }
-}
-
-fn rainfall(ctx: &EffectCtx, b: Buf) -> Buf {
-    let mut plan = rainfall_plan(ctx, &b);
-    plan.resolve(&b.img);
-    plan.finish(b)
-}
-
-fn rainfall_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
-    let pr = ctx.params;
-    let n = pr.f("drops").clamp(0.0, 100_000.0) as u32;
-    let size = pr.f("size").max(0.0) as f32;
-    let depth = pr.f("sceneDepth").max(0.0) as f32;
-    let speed = pr.f("speed") as f32;
-    let wind = pr.f("wind") as f32;
-    let wvar = pr.f("windVariation") as f32 / 100.0;
-    let spread = pr.f("spread") as f32;
-    let color = pr.color("color");
-    let opacity = pr.f("opacity") as f32 / 100.0;
-    let mode = pr.e("transferMode");
-    let with_orig = pr.b("compositeWithOriginal");
-    let refract = pr.e("extras/appearance") == 0;
-    let off = pr.v2("extras/offset");
-    let seed = pr.f("extras/randomSeed") as u32 ^ ctx.seed.wrapping_mul(0x9e37);
-    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
-    let s = b.scale as f32;
-    let t = ctx.time as f32;
-    let (ox, oy) = (off[0] as f32 - lw * 0.5, off[1] as f32 - lh * 0.5);
-    let (sprites, tints): (Vec<Sprite>, Vec<Tint>) = (0..n)
-        .into_par_iter()
-        .map(|i| {
-            let z = h(i, 1, seed);
-            let k = depth_k(z, depth);
-            let vy = speed / 4000.0 * lh * 2.2 * k;
-            let w = wind / 1000.0 * lh * (1.0 + wvar * hs(i, 2, seed)) * k + spread * hs(i, 7, seed) * k;
-            let len = (vy * 0.04 * size.max(0.2)).max(1.0);
-            let lenx = w * 0.04 * size.max(0.2);
-            let margin = len + lenx.abs() + 4.0;
-            let y = wrap(h(i, 3, seed) * (lh + 2.0 * margin) + vy * t + oy, -margin, lh + 2.0 * margin);
-            let x = wrap(h(i, 4, seed) * (lw + 2.0 * margin) + w * t + ox, -margin, lw + 2.0 * margin);
-            let (bx, by) = b.to_px([x as f64, y as f64]);
-            let c = [color[0], color[1], color[2], opacity * (0.35 + 0.65 * k)];
-            // Refracting drops show the scene behind them, brightened and offset.
-            let tint = if refract { Tint::Refract { x: bx + 2.0 * s as f64, y: by } } else { Tint::Fixed };
-            let r = (size * 0.6 * k * s).max(0.25);
-            (Sprite::new(bx as f32, by as f32, r, c, Shape::Line { dx: -lenx * s, dy: -len * s }), tint)
-        })
-        .unzip();
-    SpritePlan { sprites, tints, acc: Acc::Over, post: weather_post(mode, with_orig) }
-}
-
-fn weather_post(mode: u32, with_orig: bool) -> Post {
-    if with_orig { Post::Combine(if mode == 1 { 3 } else { 0 }) } else { Post::Replace }
-}
-
-fn snowfall(ctx: &EffectCtx, b: Buf) -> Buf {
-    snowfall_plan(ctx, &b).finish(b)
-}
-
-fn snowfall_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
-    let pr = ctx.params;
-    let n = pr.f("flakes").clamp(0.0, 200_000.0) as u32;
-    let size = pr.f("size").max(0.0) as f32;
-    let svar = pr.f("sizeVariation") as f32 / 100.0;
-    let depth = pr.f("sceneDepth").max(0.0) as f32;
-    let speed = pr.f("speed") as f32;
-    let spvar = pr.f("speedVariation") as f32 / 100.0;
-    let wind = pr.f("wind") as f32;
-    let wvar = pr.f("windVariation") as f32 / 100.0;
-    let spread = pr.f("spread") as f32;
-    let wig = pr.f("wiggle/wiggleAmount") as f32;
-    let wigvar = pr.f("wiggle/wiggleAmountVariation") as f32 / 100.0;
-    let wfreq = pr.f("wiggle/wiggleFrequency") as f32;
-    let wfvar = pr.f("wiggle/wiggleFrequencyVariation") as f32 / 100.0;
-    let color = pr.color("color");
-    let opacity = pr.f("opacity") as f32 / 100.0;
-    let mode = pr.e("transferMode");
-    let with_orig = pr.b("compositeWithOriginal");
-    let off = pr.v2("extras/offset");
-    let seed = pr.f("extras/randomSeed") as u32 ^ ctx.seed.wrapping_mul(0x85eb);
-    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
-    let s = b.scale as f32;
-    let t = ctx.time as f32;
-    let (ox, oy) = (off[0] as f32 - lw * 0.5, off[1] as f32 - lh * 0.5);
-    let sprites: Vec<Sprite> = (0..n)
-        .into_par_iter()
-        .map(|i| {
-            let z = h(i, 1, seed);
-            let k = depth_k(z, depth);
-            let r = (size * 0.5 * k * (1.0 + svar * hs(i, 2, seed))).max(0.05);
-            let vy = speed * (lh / 600.0) * k * (1.0 + spvar * hs(i, 3, seed));
-            let vx = wind * (lh / 1200.0) * k * (1.0 + wvar * hs(i, 4, seed)) + spread * hs(i, 8, seed) * k;
-            let amp = wig * 2.0 * k * (1.0 + wigvar * hs(i, 5, seed));
-            let fr = wfreq * (1.0 + wfvar * hs(i, 6, seed));
-            let ph = h(i, 9, seed) * std::f32::consts::TAU;
-            let margin = r + amp.abs() + 2.0;
-            let y = wrap(h(i, 10, seed) * (lh + 2.0 * margin) + vy * t + oy, -margin, lh + 2.0 * margin);
-            let x = wrap(h(i, 11, seed) * (lw + 2.0 * margin) + vx * t + ox, -margin, lw + 2.0 * margin) + amp * (fr * t * std::f32::consts::TAU + ph).sin();
-            let (bx, by) = b.to_px([x as f64, y as f64]);
-            Sprite::new(bx as f32, by as f32, r * s, [color[0], color[1], color[2], opacity * (0.4 + 0.6 * k)], Shape::Soft)
-        })
-        .collect();
-    SpritePlan { sprites, tints: vec![], acc: Acc::Over, post: weather_post(mode, with_orig) }
-}
-
-// ------------------------------------------------------------------ CC Bubbles
-
-/// A CC Bubbles bubble in buffer pixels.
-#[derive(Clone, Copy, Debug)]
-pub struct Bubble {
-    pub x: f32,
-    pub y: f32,
-    pub r: f32,
-    /// Source sample centre (buffer px).
-    pub sx: f32,
-    pub sy: f32,
-}
-
-/// CC Bubbles' bubbles this frame (closed-form in time) for buffer geometry `b`.
-pub fn bubble_list(ctx: &EffectCtx, b: &Buf) -> Vec<Bubble> {
-    let pr = ctx.params;
-    let n = pr.f("bubbleAmount").clamp(0.0, 10_000.0) as u32;
-    let speed = pr.f("bubbleSpeed") as f32;
-    let wamp = pr.f("wobbleAmplitude") as f32;
-    let wfreq = pr.f("wobbleFrequency") as f32;
-    let bsize = pr.f("bubbleSize").max(0.0) as f32;
-    let seed = ctx.seed.wrapping_mul(0x27d4);
-    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
-    let s = b.scale as f32;
-    let t = ctx.time as f32;
-    let base = lw.min(lh) * 0.035 * bsize;
-    (0..n)
-        .map(|i| {
-            let r = base * (0.5 + h(i, 1, seed));
-            let travel = lh + 2.0 * r;
-            let v = speed * lh * 0.3 * (0.6 + 0.8 * h(i, 2, seed));
-            let y = lh + r - (h(i, 3, seed) * travel + v * t).rem_euclid(travel);
-            let x0 = h(i, 4, seed) * lw;
-            let x = x0 + wamp * (r / base.max(1e-3)) * (t * wfreq * std::f32::consts::TAU + h(i, 5, seed) * std::f32::consts::TAU).sin();
-            let (bx, by) = b.to_px([x as f64, y as f64]);
-            let (sx, sy) = b.to_px([x0 as f64, y as f64]);
-            Bubble { x: bx as f32, y: by as f32, r: r * s, sx: sx as f32, sy: sy as f32 }
-        })
-        .collect()
-}
-
-fn bubbles(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let pr = ctx.params;
-    let metal = pr.e("reflectionType") == 1;
-    let shading = pr.e("shadingType");
-    let list = bubble_list(ctx, &b);
-    let src = b.img.clone();
-    let mut out = Image::new(src.width, src.height);
-    raster(
-        &mut out,
-        &list,
-        |q| Some([q.x - q.r - 1.0, q.y - q.r - 1.0, q.x + q.r + 1.0, q.y + q.r + 1.0]),
-        |q, x, y| {
-            let (dx, dy) = ((x - q.x) / q.r.max(0.5), (y - q.y) / q.r.max(0.5));
-            let d2 = dx * dx + dy * dy;
-            let d = d2.sqrt();
-            let cov = aa((1.0 - d) * q.r);
-            if cov <= 0.0 {
-                return None;
-            }
-            // Liquid refracts (inverted, magnified), metal reflects (wide-angle mirror).
-            let k = if metal { 1.6 } else { -0.7 };
-            let nz = (1.0 - d2).max(0.0).sqrt();
-            let p = src.sample_bilinear((q.sx + dx * q.r * k) as f64, (q.sy + dy * q.r * k) as f64);
-            let (c, sa) = unpremul(p);
-            let mut c = if sa <= 0.0 { [0.6, 0.7, 0.8] } else { c };
-            let mut a = cov;
-            match shading {
-                1 => c = c.map(|v| v * 0.7 + 0.3 * (1.0 - nz)),
-                2 => c = c.map(|v| v * (0.5 + 0.5 * nz)),
-                3 => a *= nz.powf(0.5),
-                4 => a *= 1.0 - nz * 0.8,
-                _ => {}
-            }
-            let hl = (1.0 - ((dx + 0.35).powi(2) + (dy + 0.35).powi(2)) / 0.05).max(0.0) * 0.8;
-            let c = c.map(|v| v + hl);
-            Some([c[0] * a, c[1] * a, c[2] * a, a])
-        },
-        Acc::Over,
-    );
-    b.img = out;
-    b
-}
-
-// ------------------------------------------------------------------ CC Drizzle
-
-/// CC Drizzle's live drops this frame (buffer px: centre x, y, ring radius, amplitude);
-/// `None` = no drops yet (the layer passes through).
-pub fn drizzle_drops(ctx: &EffectCtx, b: &Buf) -> Option<Vec<[f32; 4]>> {
-    let pr = ctx.params;
-    let rate = pr.f("dripRate").max(0.0);
-    let life = pr.f("longevity").max(0.01);
-    let spreading = pr.f("spreading") as f32;
-    let height = pr.f("rippleHeight") as f32 / 100.0;
-    let seed = ctx.seed.wrapping_mul(0x165667b1);
-    let t = ctx.time;
-    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
-    let s = b.scale as f32;
-    if rate <= 0.0 || t < 0.0 {
-        return None;
-    }
-    // Drops born at k / rate with hashed positions; alive while younger than the longevity.
-    let k0 = ((t - life) * rate).floor().max(0.0) as u32;
-    let k1 = (t * rate).floor() as u32;
-    let mut drops = Vec::new();
-    for k in k0..=k1 {
-        let born = k as f64 / rate;
-        let age = (t - born) as f32;
-        if age < 0.0 || age as f64 >= life {
-            continue;
-        }
-        let (x, y) = b.to_px([(h(k, 1, seed) * lw) as f64, (h(k, 2, seed) * lh) as f64]);
-        let radius = spreading * age * lh / 400.0 * s;
-        let amp = height * (1.0 - age / life as f32) * (0.6 + 0.4 * h(k, 3, seed));
-        drops.push([x as f32, y as f32, radius, amp]);
-    }
-    Some(drops)
-}
-
-fn drizzle(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let pr = ctx.params;
-    let Some(drops) = drizzle_drops(ctx, &b) else { return b };
-    let rippling = (pr.f("rippling") / 360.0).max(0.05) as f32;
-    let disp = pr.f("displacement") as f32;
-    let li = pr.f("light/lightIntensity") as f32 / 100.0;
-    let lc = pr.color("light/lightColor");
-    let lheight = pr.f("light/lightHeight") as f32 / 100.0;
-    let ldir = (pr.f("light/lightDirection") as f32).to_radians();
-    let ambient = pr.f("shading/ambient") as f32 / 100.0;
-    let diffuse = pr.f("shading/diffuse") as f32 / 100.0;
-    let specular = pr.f("shading/specular") as f32 / 100.0;
-    let rough = pr.f("shading/roughness").max(0.001) as f32;
-    let lh = ctx.layer_size[1] as f32;
-    let s = b.scale as f32;
-    let wavelen = (lh * 0.04 * s).max(2.0) / rippling.clamp(0.25, 4.0);
-    let width = wavelen * (1.0 + rippling * 2.0);
-    let field = |x: f32, y: f32| -> f32 {
-        let mut v = 0.0;
-        for &[dx, dy, r, a] in &drops {
-            let d = ((x - dx).powi(2) + (y - dy).powi(2)).sqrt();
-            let u = (d - r) / width;
-            if u.abs() < 1.0 {
-                let env = 0.5 + 0.5 * (u * std::f32::consts::PI).cos();
-                v += a * env * ((d - r) / wavelen * std::f32::consts::TAU).cos();
-            }
-        }
-        v
-    };
-    let src = b.img.clone();
-    let (ls, lcs) = ldir.sin_cos();
-    let l = {
-        let v = [lcs, ls, lheight.max(0.05)];
-        let n = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
-        [v[0] / n, v[1] / n, v[2] / n]
-    };
-    b.img.rows_mut().for_each(|(y, row)| {
-        for (x, px) in row.iter_mut().enumerate() {
-            let (fx, fy) = (x as f32 + 0.5, y as f32 + 0.5);
-            let gx = field(fx + 1.0, fy) - field(fx - 1.0, fy);
-            let gy = field(fx, fy + 1.0) - field(fx, fy - 1.0);
-            if gx == 0.0 && gy == 0.0 {
-                continue;
-            }
-            let p = src.sample_bilinear_clamped((fx - gx * disp * s * 4.0) as f64, (fy - gy * disp * s * 4.0) as f64);
-            let n = {
-                let v = [-gx * 6.0, -gy * 6.0, 1.0];
-                let m = (v[0] * v[0] + v[1] * v[1] + 1.0).sqrt();
-                [v[0] / m, v[1] / m, v[2] / m]
-            };
-            let nl = (n[0] * l[0] + n[1] * l[1] + n[2] * l[2]).max(0.0);
-            let hz = (l[2] + 1.0) * 0.5;
-            let hv = {
-                let v = [l[0] * 0.5, l[1] * 0.5, hz];
-                let m = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
-                [v[0] / m, v[1] / m, v[2] / m]
-            };
-            let sp = (n[0] * hv[0] + n[1] * hv[1] + n[2] * hv[2]).max(0.0).powf(1.0 / rough) * specular * li;
-            let shade = 1.0 + (ambient + diffuse * nl - diffuse * l[2]) * li;
-            let a = p[3];
-            *px = [p[0] * shade + sp * lc[0] * a, p[1] * shade + sp * lc[1] * a, p[2] * shade + sp * lc[2] * a, a];
-        }
-    });
-    b
-}
-
-// ------------------------------------------------------------------ CC Star Burst
-
-fn star_burst(ctx: &EffectCtx, b: Buf) -> Buf {
-    let mut plan = star_burst_plan(ctx, &b);
-    plan.resolve(&b.img);
-    plan.finish(b)
-}
-
-fn star_burst_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
-    let pr = ctx.params;
-    let scatter = pr.f("scatter") as f32;
-    let speed = pr.f("speed") as f32;
-    let phase = pr.f("phase") as f32 / 360.0;
-    let spacing = pr.f("gridSpacing").max(1.0) as f32;
-    let size = pr.f("size") as f32 / 100.0;
-    let blend = pr.f("blendWithOriginal") as f32 / 100.0;
-    let seed = ctx.seed.wrapping_mul(0x3c6e);
-    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
-    let s = b.scale as f32;
-    let t = ctx.time as f32;
-    let nx = (lw / spacing).ceil().max(1.0) as u32;
-    let ny = (lh / spacing).ceil().max(1.0) as u32;
-    let (cx, cy) = (lw * 0.5, lh * 0.5);
-    let mut list: Vec<(f32, Sprite, Tint)> = (0..nx * ny)
-        .into_par_iter()
-        .map(|i| {
-            let (gx, gy) = ((i % nx) as f32 * spacing + spacing * 0.5, (i / nx) as f32 * spacing + spacing * 0.5);
-            let (sx, sy) = b.to_px([gx as f64, gy as f64]);
-            // Depth cycles towards the viewer: z in [0, 1), perspective 1 / (1 - 0.9 z).
-            let z = (h(i, 1, seed) + t * speed * 0.25 + phase).rem_euclid(1.0);
-            let persp = 1.0 / (1.0 - 0.9 * z);
-            let jx = hs(i, 2, seed) * scatter * 0.01 * lw * 0.5;
-            let jy = hs(i, 3, seed) * scatter * 0.01 * lh * 0.5;
-            let x = cx + (gx - cx + jx) * persp;
-            let y = cy + (gy - cy + jy) * persp;
-            let (bx, by) = b.to_px([x as f64, y as f64]);
-            let r = spacing * 0.5 * size * persp * s;
-            let fade = (z * 8.0).min(1.0) * ((1.0 - z) * 6.0).min(1.0);
-            // The layer's colour at the grid point (none where it is clear).
-            (z, Sprite::new(bx as f32, by as f32, r, [0.0, 0.0, 0.0, fade], Shape::Disc), Tint::Source { x: sx, y: sy })
-        })
-        .collect();
-    list.sort_by(|a, b| a.0.total_cmp(&b.0));
-    let (sprites, tints) = list.into_iter().map(|(_, s, t)| (s, t)).unzip();
-    SpritePlan { sprites, tints, acc: Acc::Over, post: if blend > 0.0 { Post::Lerp(blend) } else { Post::Replace } }
-}
-
-// ------------------------------------------------------------------ particle engine
-
-/// Steps per second of the stepped particle simulations.
-pub(crate) const SPS: f64 = 60.0;
-
-/// Number of whole steps reached at layer time `t`.
-pub(crate) fn steps_at(t: f64) -> u64 {
-    if t <= 0.0 { 0 } else { (t * SPS + 1e-6).floor() as u64 }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct Particle {
-    pub p: [f32; 3],
-    pub v: [f32; 3],
-    pub age: f32,
-    pub life: f32,
-    /// Per-particle random in [0, 1) (size variation, colour jitter…).
-    pub rnd: f32,
-    pub id: u32,
-}
-
-#[derive(Clone, Debug, Default)]
-pub(crate) struct PState {
-    pub parts: Vec<Particle>,
-    pub carry: f64,
-    pub next_id: u32,
-}
-
-/// Physics configuration (world units; y down).
-#[derive(Clone, Copy, Debug)]
-pub(crate) struct Phys {
-    /// Particles per second.
-    pub rate: f64,
-    pub life: f32,
-    pub producer: [f32; 3],
-    pub radius: [f32; 3],
-    pub anim: u32,
-    pub speed: f32,
-    pub gravity: [f32; 3],
-    pub resistance: f32,
-    pub axis: [f32; 3],
-    pub extra: f32,
-    pub extra_angle: f32,
-    pub seed: u32,
-    pub max: usize,
-    /// 2D systems keep z = 0.
-    pub flat: bool,
-}
-
-pub(crate) const PW_ANIMS: &[&str] =
-    &["Explosive", "Direction Axis", "Cone Axis", "Viscouse", "Twirly", "Vortex", "Fire", "Jet Sideways", "Fractal Omni", "Fractal Uni"];
-
-fn norm3(v: [f32; 3]) -> [f32; 3] {
-    let l = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
-    if l > 1e-9 { [v[0] / l, v[1] / l, v[2] / l] } else { [0.0, -1.0, 0.0] }
-}
-
-fn rand_dir(i: u32, k: u32, seed: u32, flat: bool) -> [f32; 3] {
-    if flat {
-        let a = h(i, k, seed) * std::f32::consts::TAU;
-        return [a.cos(), a.sin(), 0.0];
-    }
-    let z = hs(i, k, seed);
-    let a = h(i, k + 1, seed) * std::f32::consts::TAU;
-    let r = (1.0 - z * z).max(0.0).sqrt();
-    [r * a.cos(), r * a.sin(), z]
-}
-
-impl Phys {
-    fn spawn(&self, id: u32) -> Particle {
-        let seed = self.seed;
-        let mut p = [0.0f32; 3];
-        // Uniform in the producer ellipsoid.
-        let u = rand_dir(id, 1, seed, self.flat);
-        let rr = h(id, 3, seed).powf(if self.flat { 0.5 } else { 1.0 / 3.0 });
-        for k in 0..3 {
-            p[k] = self.producer[k] + u[k] * self.radius[k] * rr;
-        }
-        if self.flat {
-            p[2] = 0.0;
-        }
-        let ax = norm3(self.axis);
-        let jitter = rand_dir(id, 5, seed, self.flat);
-        let dir = match self.anim {
-            1 | 9 => norm3([ax[0] + jitter[0] * 0.08, ax[1] + jitter[1] * 0.08, ax[2] + jitter[2] * 0.08]),
-            2 => {
-                let k = (self.extra_angle.to_radians() * 0.5).tan().abs().min(20.0);
-                norm3([ax[0] + jitter[0] * k * h(id, 8, seed), ax[1] + jitter[1] * k * h(id, 8, seed), ax[2] + jitter[2] * k * h(id, 8, seed)])
-            }
-            5 => [jitter[0], 0.0, if self.flat { 0.0 } else { jitter[2] }],
-            6 => norm3([jitter[0] * 0.25, -1.0, jitter[2] * 0.25]),
-            7 => norm3([1.0, jitter[1] * 0.05, jitter[2] * 0.05]),
-            _ => jitter,
-        };
-        let sp = self.speed * (0.5 + 0.5 * h(id, 9, seed));
-        let mut v = [dir[0] * sp, dir[1] * sp, dir[2] * sp];
-        if self.flat {
-            v[2] = 0.0;
-        }
-        let life = self.life * (0.8 + 0.4 * h(id, 10, seed));
-        Particle { p, v, age: 0.0, life, rnd: h(id, 11, seed), id }
-    }
-
-    pub(crate) fn step(&self, st: &mut PState, step: u64) {
-        let dt = (1.0 / SPS) as f32;
-        let t = step as f32 * dt;
-        let mut drag = self.resistance;
-        if self.anim == 3 {
-            drag += 3.0 * self.extra.max(0.1);
-        }
-        let damp = (-drag * dt).exp();
-        let seed = self.seed;
-        st.parts.par_iter_mut().for_each(|q| {
-            let mut a = self.gravity;
-            match self.anim {
-                4 => {
-                    // Twirly: swirl around the vertical axis through the producer.
-                    let (dx, dz) = (q.p[0] - self.producer[0], q.p[2] - self.producer[2]);
-                    let k = 4.0 * self.extra;
-                    a[0] += -dz * k;
-                    a[2] += dx * k;
-                    if self.flat {
-                        let dy = q.p[1] - self.producer[1];
-                        a[0] += -dy * k;
-                        a[1] += dx * k;
-                    }
-                }
-                5 => {
-                    // Vortex: strong tangential + inward pull.
-                    let (dx, dy) = (q.p[0] - self.producer[0], q.p[1] - self.producer[1]);
-                    let k = 6.0 * self.extra;
-                    a[0] += -dy * k - dx * 2.0;
-                    a[1] += dx * k - dy * 2.0;
-                }
-                6 => {
-                    // Fire: buoyant, flickering turbulence.
-                    let n = value_noise(q.p[0] * 8.0, q.p[1] * 8.0, t * 3.0, seed) - 0.5;
-                    a[0] += n * 4.0 * self.extra;
-                    a[1] -= self.gravity[1] * 1.5 + 0.3 * self.extra;
-                }
-                8 | 9 => {
-                    let f = 6.0 * self.extra;
-                    a[0] += (value_noise(q.p[0] * 5.0, q.p[1] * 5.0, q.p[2] * 5.0 + t, seed) - 0.5) * f;
-                    a[1] += (value_noise(q.p[0] * 5.0 + 17.0, q.p[1] * 5.0, q.p[2] * 5.0 + t, seed) - 0.5) * f;
-                    if !self.flat {
-                        a[2] += (value_noise(q.p[0] * 5.0, q.p[1] * 5.0 + 31.0, q.p[2] * 5.0 + t, seed) - 0.5) * f;
-                    }
-                }
-                _ => {}
-            }
-            for k in 0..3 {
-                q.v[k] = (q.v[k] + a[k] * dt) * damp;
-                q.p[k] += q.v[k] * dt;
-            }
-            if self.flat {
-                q.p[2] = 0.0;
-                q.v[2] = 0.0;
-            }
-            q.age += dt;
-        });
-        st.parts.retain(|q| q.age < q.life);
-        st.carry += self.rate / SPS;
-        let n = st.carry.floor() as u32;
-        st.carry -= n as f64;
-        for _ in 0..n {
-            if st.parts.len() >= self.max {
-                break;
-            }
-            let id = st.next_id;
-            st.next_id = st.next_id.wrapping_add(1);
-            // Sub-step birth offset keeps continuous streams smooth.
-            let mut q = self.spawn(id);
-            let frac = h(id, 12, seed) * dt;
-            for k in 0..3 {
-                q.p[k] += q.v[k] * frac;
-            }
-            q.age = frac;
-            st.parts.push(q);
-        }
-    }
-}
-
-impl Phys {
-    /// The backend description (per-step and per-spawn constants evaluated here, in f32).
-    pub(crate) fn desc(&self) -> crate::psim::EngineDesc {
-        let mut drag = self.resistance;
-        if self.anim == 3 {
-            drag += 3.0 * self.extra.max(0.1);
-        }
-        let dt = (1.0 / SPS) as f32;
-        crate::psim::EngineDesc {
-            life: self.life,
-            producer: self.producer,
-            radius: self.radius,
-            anim: self.anim,
-            speed: self.speed,
-            gravity: self.gravity,
-            axis: norm3(self.axis),
-            extra: self.extra,
-            cone: (self.extra_angle.to_radians() * 0.5).tan().abs().min(20.0),
-            damp: (-drag * dt).exp(),
-            seed: self.seed,
-            flat: self.flat,
-        }
-    }
-}
-
-/// The state at layer time `ctx.time` from the host's particle backend (GPU particles), or
-/// `None` (simulate on the CPU).
-fn accelerated(ctx: &EffectCtx, key: u64, phys: &Phys) -> Option<std::sync::Arc<PState>> {
-    let backend = ctx.env.host?.particles()?;
-    let steps = steps_at(ctx.time);
-    let births = crate::psim::births(phys.rate, steps, phys.max)?;
-    let req = crate::psim::SimRequest { key, steps, births: &births, system: crate::psim::ParticleSystem::Engine(phys.desc()) };
-    let parts = backend.simulate(&req)?;
-    Some(std::sync::Arc::new(PState {
-        parts: parts.into_iter().map(|q| Particle { p: q.p, v: q.v, age: q.age, life: q.life, rnd: q.rnd, id: q.id }).collect(),
-        carry: 0.0,
-        next_id: births.len() as u32,
-    }))
-}
-
-/// The live particles of a stepped particle effect (`ec.sim.ccparticleworld`,
-/// `ec.sim.ccparticlesystems2`) at `ctx.time`: from the host's particle backend when it has
-/// one (GPU particles), else from the CPU simulation. For comparing the two.
-pub fn particle_state(id: &str, ctx: &EffectCtx) -> Option<Vec<crate::psim::SimParticle>> {
-    let (phys, cache, salt) = match id {
-        "ec.sim.ccparticleworld" => (pw_phys(ctx), &PW_CACHE, 1),
-        "ec.sim.ccparticlesystems2" => (ps2_phys(ctx), &PS2_CACHE, 2),
-        _ => return None,
-    };
-    let key = sim_key(ctx, salt);
-    let st = accelerated(ctx, key, &phys).unwrap_or_else(|| simulate(cache, key, ctx.time, &phys));
-    Some(st.parts.iter().map(|q| crate::psim::SimParticle { p: q.p, v: q.v, age: q.age, life: q.life, rnd: q.rnd, id: q.id }).collect())
-}
-
-/// The simulation cache key of a stepped particle effect: every parameter but CC Particle World's
-/// Effect Camera, which only changes how the particles are seen (animating it doesn't restart
-/// the simulation).
-fn sim_key(ctx: &EffectCtx, salt: u64) -> u64 {
-    params_key_except(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, salt, &[PW_EFFECT_CAMERA])
-}
-
-/// Run a particle system to layer time `t` through `cache`.
-pub(crate) fn simulate(cache: &SimCache<PState>, key: u64, t: f64, phys: &Phys) -> std::sync::Arc<PState> {
-    cache.run(key, steps_at(t), PState::default, |st, i| phys.step(st, i))
-}
-
-pub(crate) const PARTICLE_TYPES: &[&str] =
-    &["Line", "Shaded Sphere", "Faded Sphere", "Bubble", "Star", "Motion Polygon", "Tri-Polygon", "Cube", "Textured Square"];
-
-/// Colour/size/opacity of a particle at its age.
-fn particle_look(q: &Particle, birth: [f32; 4], death: [f32; 4], bsize: f32, dsize: f32, svar: f32, max_op: f32) -> ([f32; 4], f32) {
-    let u = (q.age / q.life.max(1e-4)).clamp(0.0, 1.0);
-    let size = (bsize + (dsize - bsize) * u) * (1.0 + svar * (q.rnd * 2.0 - 1.0));
-    let fade = (u * 20.0).min(1.0) * ((1.0 - u) * 5.0).min(1.0);
-    let c = [birth[0] + (death[0] - birth[0]) * u, birth[1] + (death[1] - birth[1]) * u, birth[2] + (death[2] - birth[2]) * u, max_op * fade];
-    (c, size.max(0.0))
-}
-
-fn type_sprite(kind: u32, x: f32, y: f32, r: f32, c: [f32; 4], vx: f32, vy: f32, rot: f32) -> Sprite {
-    let vl = (vx * vx + vy * vy).sqrt().max(1e-6);
-    let shape = match kind {
-        0 => Shape::Line { dx: -vx / vl * r * 2.0, dy: -vy / vl * r * 2.0 },
-        1 => Shape::Sphere,
-        2 => Shape::Faded,
-        3 => Shape::Bubble,
-        4 => Shape::Star,
-        5 => Shape::Line { dx: -vx * 0.05, dy: -vy * 0.05 },
-        6 => Shape::Tri,
-        _ => Shape::Square,
-    };
-    let rr = match kind {
-        0 => (r * 0.08).max(0.5),
-        5 => r * 0.5,
-        _ => r,
-    };
-    Sprite { x, y, r: rr, c, shape, rot }
-}
-
-// ------------------------------------------------------------------ CC Particle World
-
-static PW_CACHE: SimCache<PState> = SimCache::new(6);
-
-/// CC Particle World's physics.
-fn pw_phys(ctx: &EffectCtx) -> Phys {
-    let pr = ctx.params;
-    Phys {
-        rate: pr.f("birthRate").max(0.0) * 120.0,
-        life: pr.f("longevity").max(0.0) as f32,
-        producer: [pr.f("producer/producerX") as f32, pr.f("producer/producerY") as f32, pr.f("producer/producerZ") as f32],
-        radius: [pr.f("producer/radiusX").max(0.0) as f32, pr.f("producer/radiusY").max(0.0) as f32, pr.f("producer/radiusZ").max(0.0) as f32],
-        anim: pr.e("physics/animation"),
-        speed: pr.f("physics/velocity") as f32 * 0.5,
-        gravity: {
-            let g = pr.f("physics/gravity") as f32;
-            let gv =
-                [pr.f("physics/gravityVector/gravityX") as f32, pr.f("physics/gravityVector/gravityY") as f32, pr.f("physics/gravityVector/gravityZ") as f32];
-            [gv[0] * g, gv[1] * g, gv[2] * g]
-        },
-        resistance: pr.f("physics/resistance").max(0.0) as f32,
-        axis: [pr.f("physics/directionAxis/axisX") as f32, pr.f("physics/directionAxis/axisY") as f32, pr.f("physics/directionAxis/axisZ") as f32],
-        extra: pr.f("physics/extra") as f32,
-        extra_angle: pr.f("physics/extraAngle") as f32,
-        seed: (pr.f("extras/randomSeed") as u32).wrapping_mul(0x9e3779b9) ^ ctx.seed,
-        max: 40_000,
-        flat: false,
-    }
-}
-
-fn particle_world(ctx: &EffectCtx, b: Buf) -> Buf {
-    // #1195: with the comp's motion-blur shutter open, particles draw as motion trails: the
-    // sprite fields of samples across the shutter are averaged, as Transform averages its
-    // matrix samples. (The GPU compositor runs this case on the CPU: catalog::gpu_supported.)
-    if let Some((angle, phase, n)) = ctx.env.shutter.filter(|(a, _, _)| *a > 0.0) {
-        let n = (n.clamp(2, 64) as usize).max(2);
-        let fd = 1.0 / ctx.fps().max(0.001);
-        let mut acc = Image::new(b.img.width, b.img.height);
-        let mut post: Option<Post> = None;
-        for k in 0..n {
-            let t = ctx.time + (phase + angle * k as f64 / (n - 1) as f64) / 360.0 * fd;
-            let sub = EffectCtx { params: ctx.params, time: t, layer_size: ctx.layer_size, seed: ctx.seed, adjustment: ctx.adjustment, env: ctx.env };
-            if let Some(plan) = particle_world_plan(&sub, &b) {
-                let fx = splat(b.img.width, b.img.height, &plan.sprites, plan.acc);
-                acc.data.iter_mut().zip(&fx.data).for_each(|(a, o)| (0..4).for_each(|c| a[c] += o[c]));
-                post.get_or_insert(plan.post);
-            }
-        }
-        acc.data.iter_mut().for_each(|p| p.iter_mut().for_each(|v| *v /= n as f32));
-        return match post {
-            Some(p) => p.apply(b, acc),
-            None => b,
-        };
-    }
-    match particle_world_plan(ctx, &b) {
-        Some(plan) => plan.finish(b),
-        None => b,
-    }
-}
-
-/// CC Particle World's Extras ▸ Effect Camera parameters (id prefix).
-const PW_EFFECT_CAMERA: &str = "extras/effectCamera/";
-/// Effect Camera ▸ FOV's default (degrees).
-const PW_FOV: f64 = 50.0;
-
-/// What CC Particle World sees its particles through.
-enum PwCamera {
-    /// Extras ▸ Effect Camera, in world units (layer widths): `dist` from the world origin (the
-    /// layer centre) along −z, the world turned by `rot` (`None` = not turned) about the origin,
-    /// `focal` the scale at unit depth; particles nearer than `near` aren't drawn.
-    Effect { rot: Option<[[f32; 3]; 3]>, dist: f32, focal: f32, near: f32 },
-    /// The comp's active camera layer, on buffer-world points (After Effects then ignores the
-    /// Effect Camera).
-    Comp(crate::card3d::Proj),
-}
-
-/// A particle as the camera sees it: depth (larger is farther), buffer pixel, size scale `k`
-/// (buffer pixels per world unit = `k · layer width · buffer scale`) and velocity in world units
-/// on screen (× the same factor for buffer pixels).
-struct PwSeen {
-    depth: f32,
-    x: f32,
-    y: f32,
-    k: f32,
-    v: [f32; 2],
-}
-
-impl PwCamera {
-    fn new(ctx: &EffectCtx, b: &Buf) -> PwCamera {
-        let [lw, lh] = ctx.layer_size;
-        if let Some(cam) = ctx.env.host.and_then(|h| h.comp_scene()).filter(|sc| sc.camera_layer).and_then(|sc| sc.camera) {
-            let c = [b.offset[0] + lw * 0.5 * b.scale, b.offset[1] + lh * 0.5 * b.scale];
-            return PwCamera::Comp(crate::card3d::comp_proj(&cam, c, b));
-        }
-        let f = |id: &str, d: f64| ctx.params.get(&format!("{PW_EFFECT_CAMERA}{id}")).map(Value::as_f64).filter(|v| v.is_finite()).unwrap_or(d);
-        // The camera keeps the origin's plane at the scale Distance gives it as FOV changes
-        // (moving in for a wider view), so FOV sets how strong the perspective is. Distance 2
-        // shows the origin's plane at the layer's own scale.
-        let half = |fov: f64| (fov.clamp(1.0, 179.0).to_radians() * 0.5).tan();
-        let zoom = half(PW_FOV) / half(f("fov", PW_FOV));
-        let dist = f("distance", 2.0).max(0.01) * zoom;
-        let a = [f("rotationX", 0.0), f("rotationY", 0.0), f("rotationZ", 0.0)];
-        let rot = (a != [0.0; 3]).then(|| {
-            let r = crate::card3d::rot_ordered(a[0].to_radians(), a[1].to_radians(), a[2].to_radians(), 0);
-            r.map(|row| row.map(|v| v as f32))
-        });
-        PwCamera::Effect { rot, dist: dist as f32, focal: (2.0 * zoom) as f32, near: (0.025 * dist) as f32 }
-    }
-
-    /// How the camera sees world point `p` moving at `v`; `None` behind or too close to it.
-    fn see(&self, p: [f32; 3], v: [f32; 3], lw: f32, lh: f32, b: &Buf) -> Option<PwSeen> {
-        match self {
-            PwCamera::Effect { rot, dist, focal, near } => {
-                let turn = |r: &[[f32; 3]; 3], q: [f32; 3]| r.map(|row| row[0] * q[0] + row[1] * q[1] + row[2] * q[2]);
-                let (p, v) = match rot {
-                    Some(r) => (turn(r, p), turn(r, v)),
-                    None => (p, v),
-                };
-                let zc = dist + p[2];
-                if zc.is_nan() || zc <= *near {
-                    return None;
-                }
-                let k = focal / zc;
-                let (x, y) = b.to_px([(lw * 0.5 + p[0] * lw * k) as f64, (lh * 0.5 + p[1] * lw * k) as f64]);
-                Some(PwSeen { depth: zc, x: x as f32, y: y as f32, k, v: [v[0], v[1]] })
-            }
-            PwCamera::Comp(proj) => {
-                let (s, lw, lh) = (b.scale, lw as f64, lh as f64);
-                let u = lw * s;
-                let at = [b.offset[0] + lw * 0.5 * s + p[0] as f64 * u, b.offset[1] + lh * 0.5 * s + p[1] as f64 * u, p[2] as f64 * u];
-                let seen = proj.view(at, [v[0] as f64, v[1] as f64, v[2] as f64])?;
-                let k = seen.scale;
-                Some(PwSeen {
-                    depth: seen.depth as f32,
-                    x: seen.at[0] as f32,
-                    y: seen.at[1] as f32,
-                    k: k as f32,
-                    v: [(seen.vel[0] / k) as f32, (seen.vel[1] / k) as f32],
-                })
-            }
-        }
-    }
-}
-
-/// CC Particle World's sprites (far to near), `None` before anything is born.
-fn particle_world_plan(ctx: &EffectCtx, b: &Buf) -> Option<SpritePlan> {
-    let pr = ctx.params;
-    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
-    let phys = pw_phys(ctx);
-    if phys.rate <= 0.0 && ctx.time <= 0.0 {
-        return None;
-    }
-    let key = sim_key(ctx, 1);
-    let st = accelerated(ctx, key, &phys).unwrap_or_else(|| simulate(&PW_CACHE, key, ctx.time, &phys));
-    let kind = pr.e("particle/particleType");
-    let birth = pr.color("particle/birthColor");
-    let death = pr.color("particle/deathColor");
-    let (bs, ds) = (pr.f("particle/birthSize") as f32, pr.f("particle/deathSize") as f32);
-    let svar = pr.f("particle/sizeVariation") as f32 / 100.0;
-    let max_op = pr.f("particle/maxOpacity") as f32 / 100.0;
-    let s = b.scale as f32;
-    let cam = PwCamera::new(ctx, b);
-    let mut list: Vec<(f32, Sprite)> = st
-        .parts
-        .par_iter()
-        .filter_map(|q| {
-            let PwSeen { depth, x, y, k, v } = cam.see(q.p, q.v, lw, lh, b)?;
-            let (c, size) = particle_look(q, birth, death, bs, ds, svar, max_op);
-            let r = size * 0.5 * lw * k * s * 0.25;
-            let sp = type_sprite(kind, x, y, r, c, v[0] * lw * k * s, v[1] * lw * k * s, (q.id % 628) as f32 * 0.01 + q.age * 2.0);
-            Some((depth, sp))
-        })
-        .collect();
-    list.sort_by(|a, b| b.0.total_cmp(&a.0));
-    let sprites: Vec<Sprite> = list.into_iter().map(|(_, s)| s).collect();
-    Some(particle_sprites(sprites, pr.e("particle/transferMode")))
-}
-
-/// The CC particle systems' sprites with their Transfer Mode (Composite, Screen, Add, Black
-/// Background).
-fn particle_sprites(sprites: Vec<Sprite>, mode: u32) -> SpritePlan {
-    // The particles replace the layer (After Effects shows no trace of the source in any
-    // Transfer Mode, which sets how the particles meet each other).
-    SpritePlan { sprites, tints: vec![], acc: if mode == 2 { Acc::Add } else { Acc::Over }, post: Post::Replace }
-}
-
-// ------------------------------------------------------------------ CC Particle Systems II
-
-static PS2_CACHE: SimCache<PState> = SimCache::new(6);
-
-/// CC Particle Systems II's physics.
-fn ps2_phys(ctx: &EffectCtx) -> Phys {
-    let pr = ctx.params;
-    let lh = ctx.layer_size[1] as f32;
-    let unit = lh.max(1.0);
-    let pos = pr.v2("producer/position");
-    let dir = (pr.f("physics/direction") as f32).to_radians();
-    Phys {
-        rate: pr.f("birthRate").max(0.0) * 60.0,
-        life: pr.f("longevity").max(0.0) as f32,
-        producer: [pos[0] as f32 / unit, pos[1] as f32 / unit, 0.0],
-        radius: [pr.f("producer/radiusX").max(0.0) as f32 / unit, pr.f("producer/radiusY").max(0.0) as f32 / unit, 0.0],
-        anim: [0u32, 1, 2, 3, 4, 5, 6, 7, 8, 9][pr.e("physics/animation").min(9) as usize],
-        speed: pr.f("physics/velocity") as f32 * 0.25,
-        gravity: [0.0, pr.f("physics/gravity") as f32 * 0.5, 0.0],
-        resistance: pr.f("physics/resistance").max(0.0) as f32,
-        // AE angles: 0° = up, clockwise.
-        axis: [dir.sin(), -dir.cos(), 0.0],
-        extra: pr.f("physics/extra") as f32,
-        extra_angle: 45.0 * pr.f("physics/extra") as f32,
-        seed: (pr.f("randomSeed") as u32).wrapping_mul(0x85ebca6b) ^ ctx.seed,
-        max: 40_000,
-        flat: true,
-    }
-}
-
-fn particle_systems2(ctx: &EffectCtx, b: Buf) -> Buf {
-    particle_systems2_plan(ctx, &b).finish(b)
-}
-
-/// CC Particle Systems II's sprites.
-fn particle_systems2_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
-    let pr = ctx.params;
-    let lh = ctx.layer_size[1] as f32;
-    let unit = lh.max(1.0);
-    let phys = ps2_phys(ctx);
-    let key = sim_key(ctx, 2);
-    let st = accelerated(ctx, key, &phys).unwrap_or_else(|| simulate(&PS2_CACHE, key, ctx.time, &phys));
-    let kind = pr.e("particle/particleType");
-    let birth = pr.color("particle/birthColor");
-    let death = pr.color("particle/deathColor");
-    let (bs, ds) = (pr.f("particle/birthSize") as f32, pr.f("particle/deathSize") as f32);
-    let svar = pr.f("particle/sizeVariation") as f32 / 100.0;
-    let max_op = pr.f("particle/maxOpacity") as f32 / 100.0;
-    let s = b.scale as f32;
-    let sprites: Vec<Sprite> = st
-        .parts
-        .iter()
-        .map(|q| {
-            let (bx, by) = b.to_px([(q.p[0] * unit) as f64, (q.p[1] * unit) as f64]);
-            let (c, size) = particle_look(q, birth, death, bs, ds, svar, max_op);
-            let r = size * unit * 0.02 * s;
-            type_sprite(kind, bx as f32, by as f32, r, c, q.v[0] * unit * s, q.v[1] * unit * s, (q.id % 628) as f32 * 0.01 + q.age * 2.0)
-        })
-        .collect();
-    particle_sprites(sprites, pr.e("particle/transferMode"))
-}
-
-// ------------------------------------------------------------------ CC Mr. Mercury
-
-static MERCURY_CACHE: SimCache<PState> = SimCache::new(6);
-
-/// A CC Mr. Mercury blob (buffer px).
-#[derive(Clone, Copy, Debug)]
-pub struct Blob {
-    pub x: f32,
-    pub y: f32,
-    pub r: f32,
-}
-
-/// CC Mr. Mercury's blobs this frame, from its particle simulation (for buffer geometry `b`).
-pub fn mercury_blobs(ctx: &EffectCtx, b: &Buf) -> Vec<Blob> {
-    let pr = ctx.params;
-    let lh = ctx.layer_size[1] as f32;
-    let unit = lh.max(1.0);
-    let pos = pr.v2("producer");
-    let dir = (pr.f("direction") as f32).to_radians();
-    let phys = Phys {
-        rate: pr.f("birthRate").max(0.0) * 10.0,
-        life: pr.f("longevity").max(0.0) as f32,
-        producer: [pos[0] as f32 / unit, pos[1] as f32 / unit, 0.0],
-        radius: [pr.f("radiusX").max(0.0) as f32 / unit, pr.f("radiusY").max(0.0) as f32 / unit, 0.0],
-        anim: [0u32, 1, 2, 3, 4, 5, 6, 7, 8, 9][pr.e("animation").min(9) as usize],
-        speed: pr.f("velocity") as f32 * 0.3,
-        gravity: [0.0, pr.f("gravity") as f32 * 0.5, 0.0],
-        resistance: pr.f("resistance").max(0.0) as f32,
-        axis: [dir.sin(), -dir.cos(), 0.0],
-        extra: pr.f("extra") as f32,
-        extra_angle: 45.0 * pr.f("extra") as f32,
-        seed: ctx.seed.wrapping_mul(0xc2b2ae35),
-        max: 4_000,
-        flat: true,
-    };
-    let st = simulate(&MERCURY_CACHE, params_key(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, 3), ctx.time, &phys);
-    let (bs, ds) = (pr.f("blobBirthSize") as f32, pr.f("blobDeathSize") as f32);
-    let s = b.scale as f32;
-    st.parts
-        .iter()
-        .map(|q| {
-            let u = (q.age / q.life.max(1e-4)).clamp(0.0, 1.0);
-            let size = bs + (ds - bs) * u;
-            let (bx, by) = b.to_px([(q.p[0] * unit) as f64, (q.p[1] * unit) as f64]);
-            Blob { x: bx as f32, y: by as f32, r: (size * unit * 0.08 * s).max(0.0) }
-        })
-        .filter(|q| q.r > 0.1)
-        .collect()
-}
-
-fn mr_mercury(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let pr = ctx.params;
-    let blobs = mercury_blobs(ctx, &b);
-    let influence = pr.f("blobInfluence") as f32 / 100.0;
-    let s = b.scale as f32;
-    let (w, hh) = (b.img.width, b.img.height);
-    // Field and gradient accumulate additively: [f, gx, gy, _].
-    let mut field = Image::new(w, hh);
-    let infl = 1.0 + influence;
-    raster(
-        &mut field,
-        &blobs,
-        |q| {
-            let e = q.r * 2.0 * infl;
-            Some([q.x - e, q.y - e, q.x + e, q.y + e])
-        },
-        |q, x, y| {
-            let (dx, dy) = (x - q.x, y - q.y);
-            let rr = q.r * 2.0 * infl;
-            let d2 = (dx * dx + dy * dy) / (rr * rr);
-            if d2 >= 1.0 {
-                return None;
-            }
-            let k = 1.0 - d2;
-            let f = k * k * k;
-            let g = -6.0 * k * k / (rr * rr);
-            Some([f, g * dx, g * dy, 0.0])
-        },
-        Acc::Add,
-    );
-    let thr = 0.35f32;
-    let ambient = pr.f("shading/ambient") as f32 / 100.0;
-    let diffuse = pr.f("shading/diffuse") as f32 / 100.0;
-    let specular = pr.f("shading/specular") as f32 / 100.0;
-    let rough = pr.f("shading/roughness").max(0.001) as f32;
-    let metal = pr.f("shading/metal") as f32 / 100.0;
-    let li = pr.f("light/lightIntensity") as f32 / 100.0;
-    let lc = pr.color("light/lightColor");
-    let ldir = (pr.f("light/lightDirection") as f32).to_radians();
-    let lheight = pr.f("light/lightHeight") as f32 / 100.0;
-    let l = norm3([ldir.sin(), -ldir.cos(), lheight.max(0.05)]);
-    let src = b.img.clone();
-    let mut out = Image::new(w, hh);
-    out.rows_mut().for_each(|(y, row)| {
-        for (x, px) in row.iter_mut().enumerate() {
-            let fv = field.data[y * w as usize + x];
-            let f = fv[0];
-            if f <= thr * 0.8 {
-                continue;
-            }
-            let cov = ((f - thr * 0.8) / (thr * 0.4)).clamp(0.0, 1.0);
-            let n = norm3([fv[1] * 3.0, fv[2] * 3.0, 1.0 / (1.0 + f)]);
-            // Refract the layer through the blob.
-            let sp = src.sample_bilinear_clamped(x as f64 + 0.5 - n[0] as f64 * 12.0 * s as f64, y as f64 + 0.5 - n[1] as f64 * 12.0 * s as f64);
-            let (c, sa) = unpremul(sp);
-            let base = if sa > 0.0 { c } else { [0.7, 0.7, 0.75] };
-            let nl = (n[0] * l[0] + n[1] * l[1] + n[2] * l[2]).max(0.0);
-            let hv = norm3([l[0], l[1], l[2] + 1.0]);
-            let spec = (n[0] * hv[0] + n[1] * hv[1] + n[2] * hv[2]).max(0.0).powf(1.0 / rough) * specular * li;
-            let shade = ambient + diffuse * nl * li;
-            let cc: [f32; 3] = std::array::from_fn(|k| base[k] * shade + spec * (lc[k] * (1.0 - metal) + base[k] * metal));
-            *px = [cc[0] * cov, cc[1] * cov, cc[2] * cov, cov];
-        }
-    });
-    b.img = out;
-    b
-}
-
-// ------------------------------------------------------------------ specs
-
-pub fn specs() -> Vec<EffectSpec> {
-    let transfer = || popup(&["Composite", "Lighten"]);
-    vec![
-        spec(
-            "ec.sim.ccrainfall",
-            "CC Rainfall",
-            vec![
-                p("drops", "Drops", num(5000.0), slider(0.0, 100_000.0, 0.0, 20_000.0, 0)),
-                p("size", "Size", num(1.0), slider(0.0, 50.0, 0.0, 10.0, 2)),
-                p("sceneDepth", "Scene Depth", num(5000.0), slider(0.0, 20_000.0, 0.0, 10_000.0, 0)),
-                p("speed", "Speed", num(4000.0), slider(0.0, 20_000.0, 0.0, 10_000.0, 0)),
-                p("wind", "Wind", num(0.0), slider(-10_000.0, 10_000.0, -2000.0, 2000.0, 1)),
-                p("windVariation", "Variation % (Wind)", num(0.0), pct()),
-                p("spread", "Spread", num(0.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
-                p("color", "Color", col(0.8, 0.8, 0.8), ParamUi::Color),
-                p("opacity", "Opacity", num(25.0), pct()),
-                p("transferMode", "Transfer Mode", Value::Enum(1), transfer()),
-                p("compositeWithOriginal", "Composite With Original", Value::Bool(true), ParamUi::Checkbox),
-                p("extras/appearance", "Appearance", Value::Enum(0), popup(&["Refracting", "Soft Solid"])),
-                p("extras/offset", "Offset", pt(0.5, 0.5), ParamUi::Point),
-                p("extras/randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
-            ],
-            rainfall,
-        ),
-        spec(
-            "ec.sim.ccsnowfall",
-            "CC Snowfall",
-            vec![
-                p("flakes", "Flakes", num(10_000.0), slider(0.0, 200_000.0, 0.0, 50_000.0, 0)),
-                p("size", "Size", num(3.0), slider(0.0, 50.0, 0.0, 20.0, 2)),
-                p("sizeVariation", "Variation % (Size)", num(50.0), pct()),
-                p("sceneDepth", "Scene Depth", num(5000.0), slider(0.0, 20_000.0, 0.0, 10_000.0, 0)),
-                p("speed", "Speed", num(100.0), slider(0.0, 5000.0, 0.0, 1000.0, 1)),
-                p("speedVariation", "Variation % (Speed)", num(50.0), pct()),
-                p("wind", "Wind", num(25.0), slider(-5000.0, 5000.0, -500.0, 500.0, 1)),
-                p("windVariation", "Variation % (Wind)", num(50.0), pct()),
-                p("spread", "Spread", num(0.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
-                p("wiggle/wiggleAmount", "Amount", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
-                p("wiggle/wiggleAmountVariation", "Variation % (Amount)", num(50.0), pct()),
-                p("wiggle/wiggleFrequency", "Frequency", num(1.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
-                p("wiggle/wiggleFrequencyVariation", "Variation % (Frequency)", num(50.0), pct()),
-                p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("opacity", "Opacity", num(100.0), pct()),
-                p("transferMode", "Transfer Mode", Value::Enum(0), transfer()),
-                p("compositeWithOriginal", "Composite With Original", Value::Bool(true), ParamUi::Checkbox),
-                p("extras/offset", "Offset", pt(0.5, 0.5), ParamUi::Point),
-                p("extras/randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
-            ],
-            snowfall,
-        ),
-        spec(
-            "ec.sim.ccbubbles",
-            "CC Bubbles",
-            vec![
-                p("bubbleAmount", "Bubble Amount", num(100.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
-                p("bubbleSpeed", "Bubble Speed", num(0.5), slider(-10.0, 10.0, -2.0, 2.0, 2)),
-                p("wobbleAmplitude", "Wobble Amplitude", num(5.0), slider(0.0, 500.0, 0.0, 100.0, 1)),
-                p("wobbleFrequency", "Wobble Frequency", num(1.0), slider(0.0, 50.0, 0.0, 10.0, 2)),
-                p("bubbleSize", "Bubble Size", num(1.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
-                p("reflectionType", "Reflection Type", Value::Enum(0), popup(&["Liquid", "Metal"])),
-                p("shadingType", "Shading Type", Value::Enum(0), popup(&["None", "Lighten", "Darken", "Fade Inwards", "Fade Outwards"])),
-            ],
-            bubbles,
-        ),
-        spec(
-            "ec.sim.ccdrizzle",
-            "CC Drizzle",
-            vec![
-                p("dripRate", "Drip Rate", num(10.0), slider(0.0, 200.0, 0.0, 50.0, 2)),
-                p("longevity", "Longevity (sec)", num(1.0), slider(0.0, 30.0, 0.0, 5.0, 2)),
-                p("rippling", "Rippling", num(360.0), ParamUi::Angle),
-                p("displacement", "Displacement", num(5.0), slider(0.0, 100.0, 0.0, 30.0, 2)),
-                p("rippleHeight", "Ripple Height", num(30.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
-                p("spreading", "Spreading", num(100.0), slider(0.0, 1000.0, 0.0, 300.0, 1)),
-                p("light/lightIntensity", "Light Intensity", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
-                p("light/lightColor", "Light Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("light/lightHeight", "Light Height", num(25.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
-                p("light/lightDirection", "Light Direction", num(-45.0), ParamUi::Angle),
-                p("shading/ambient", "Ambient", num(0.0), slider(-200.0, 200.0, -100.0, 100.0, 1)),
-                p("shading/diffuse", "Diffuse", num(0.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
-                p("shading/specular", "Specular", num(20.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
-                p("shading/roughness", "Roughness", num(0.05), slider(0.001, 1.0, 0.001, 0.5, 3)),
-            ],
-            drizzle,
-        ),
-        spec(
-            "ec.sim.ccstarburst",
-            "CC Star Burst",
-            vec![
-                p("scatter", "Scatter", num(100.0), slider(0.0, 1000.0, 0.0, 300.0, 1)),
-                p("speed", "Speed", num(1.0), slider(-10.0, 10.0, -4.0, 4.0, 2)),
-                p("phase", "Phase", num(0.0), ParamUi::Angle),
-                p("gridSpacing", "Grid Spacing", num(2.0), slider(1.0, 100.0, 1.0, 20.0, 0)),
-                p("size", "Size", num(100.0), slider(0.0, 1000.0, 0.0, 300.0, 1)),
-                p("blendWithOriginal", "Blend w. Original", num(0.0), pct()),
-            ],
-            star_burst,
-        ),
-        spec(
-            "ec.sim.ccparticleworld",
-            "CC Particle World",
-            vec![
-                p("birthRate", "Birth Rate", num(0.5), slider(0.0, 100.0, 0.0, 10.0, 2)),
-                p("longevity", "Longevity (sec)", num(1.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
-                p("producer/producerX", "Position X", num(0.0), slider(-10.0, 10.0, -1.0, 1.0, 2)),
-                p("producer/producerY", "Position Y", num(0.0), slider(-10.0, 10.0, -1.0, 1.0, 2)),
-                p("producer/producerZ", "Position Z", num(0.0), slider(-10.0, 10.0, -1.0, 1.0, 2)),
-                p("producer/radiusX", "Radius X", num(0.025), slider(0.0, 10.0, 0.0, 1.0, 3)),
-                p("producer/radiusY", "Radius Y", num(0.025), slider(0.0, 10.0, 0.0, 1.0, 3)),
-                p("producer/radiusZ", "Radius Z", num(0.025), slider(0.0, 10.0, 0.0, 1.0, 3)),
-                p("physics/animation", "Animation", Value::Enum(0), popup(PW_ANIMS)),
-                p("physics/velocity", "Velocity", num(1.0), slider(-10.0, 10.0, 0.0, 5.0, 2)),
-                p("physics/inheritVelocity", "Inherit Velocity %", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
-                p("physics/gravity", "Gravity", num(0.5), slider(-10.0, 10.0, -2.0, 2.0, 3)),
-                p("physics/resistance", "Resistance", num(0.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
-                p("physics/extra", "Extra", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 2)),
-                p("physics/extraAngle", "Extra Angle", num(360.0), ParamUi::Angle),
-                p("physics/directionAxis/axisX", "Axis X", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
-                p("physics/directionAxis/axisY", "Axis Y", num(-1.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
-                p("physics/directionAxis/axisZ", "Axis Z", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
-                p("physics/gravityVector/gravityX", "Gravity X", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
-                p("physics/gravityVector/gravityY", "Gravity Y", num(1.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
-                p("physics/gravityVector/gravityZ", "Gravity Z", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
-                p("particle/particleType", "Particle Type", Value::Enum(0), popup(PARTICLE_TYPES)),
-                p("particle/birthSize", "Birth Size", num(0.2), slider(0.0, 10.0, 0.0, 1.0, 3)),
-                p("particle/deathSize", "Death Size", num(0.2), slider(0.0, 10.0, 0.0, 1.0, 3)),
-                p("particle/sizeVariation", "Size Variation", num(0.0), pct()),
-                p("particle/maxOpacity", "Max Opacity", num(75.0), pct()),
-                p("particle/birthColor", "Birth Color", col(1.0, 1.0, 0.0), ParamUi::Color),
-                p("particle/deathColor", "Death Color", col(0.6, 0.0, 0.0), ParamUi::Color),
-                p("particle/transferMode", "Transfer Mode", Value::Enum(0), popup(&["Composite", "Screen", "Add", "Black Matte"])),
-                p("extras/effectCamera/distance", "Distance", num(2.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
-                p("extras/effectCamera/rotationX", "Rotation X", num(0.0), ParamUi::Angle),
-                p("extras/effectCamera/rotationY", "Rotation Y", num(0.0), ParamUi::Angle),
-                p("extras/effectCamera/rotationZ", "Rotation Z", num(0.0), ParamUi::Angle),
-                p("extras/effectCamera/fov", "FOV", num(PW_FOV), slider(1.0, 179.0, 10.0, 120.0, 1)),
-                p("extras/randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
-            ],
-            particle_world,
-        ),
-        spec(
-            "ec.sim.ccparticlesystems2",
-            "CC Particle Systems II",
-            vec![
-                p("birthRate", "Birth Rate", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
-                p("longevity", "Longevity (sec)", num(1.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
-                p("producer/position", "Position", pt(0.5, 0.5), ParamUi::Point),
-                p("producer/radiusX", "Radius X", num(0.0), slider(0.0, 2000.0, 0.0, 200.0, 1)),
-                p("producer/radiusY", "Radius Y", num(0.0), slider(0.0, 2000.0, 0.0, 200.0, 1)),
-                p("physics/animation", "Animation", Value::Enum(0), popup(PW_ANIMS)),
-                p("physics/velocity", "Velocity", num(2.0), slider(-20.0, 20.0, 0.0, 10.0, 2)),
-                p("physics/inheritVelocity", "Inherit Velocity %", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
-                p("physics/gravity", "Gravity", num(1.0), slider(-20.0, 20.0, -5.0, 5.0, 2)),
-                p("physics/resistance", "Resistance", num(0.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
-                p("physics/direction", "Direction", num(0.0), ParamUi::Angle),
-                p("physics/extra", "Extra", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 2)),
-                p("particle/particleType", "Particle Type", Value::Enum(0), popup(PARTICLE_TYPES)),
-                p("particle/birthSize", "Birth Size", num(0.5), slider(0.0, 20.0, 0.0, 5.0, 2)),
-                p("particle/deathSize", "Death Size", num(1.5), slider(0.0, 20.0, 0.0, 5.0, 2)),
-                p("particle/sizeVariation", "Size Variation", num(0.0), pct()),
-                p("particle/maxOpacity", "Max Opacity", num(75.0), pct()),
-                p("particle/birthColor", "Birth Color", col(1.0, 1.0, 0.0), ParamUi::Color),
-                p("particle/deathColor", "Death Color", col(0.6, 0.0, 0.0), ParamUi::Color),
-                p("particle/transferMode", "Transfer Mode", Value::Enum(0), popup(&["Composite", "Screen", "Add", "Black Matte"])),
-                p("randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
-            ],
-            particle_systems2,
-        ),
-        spec(
-            "ec.sim.ccmrmercury",
-            "CC Mr. Mercury",
-            vec![
-                p("radiusX", "Radius X", num(50.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
-                p("radiusY", "Radius Y", num(50.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
-                p("producer", "Producer", pt(0.5, 0.5), ParamUi::Point),
-                p("direction", "Direction", num(0.0), ParamUi::Angle),
-                p("velocity", "Velocity", num(1.0), slider(-20.0, 20.0, 0.0, 5.0, 2)),
-                p("birthRate", "Birth Rate", num(1.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
-                p("longevity", "Longevity (sec)", num(2.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
-                p("gravity", "Gravity", num(0.5), slider(-20.0, 20.0, -5.0, 5.0, 2)),
-                p("resistance", "Resistance", num(0.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
-                p("extra", "Extra", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 2)),
-                p("animation", "Animation", Value::Enum(0), popup(PW_ANIMS)),
-                p("blobInfluence", "Blob Influence", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
-                p("blobBirthSize", "Blob Birth Size", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 2)),
-                p("blobDeathSize", "Blob Death Size", num(0.25), slider(0.0, 10.0, 0.0, 2.0, 2)),
-                p("light/lightIntensity", "Light Intensity", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
-                p("light/lightColor", "Light Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("light/lightHeight", "Light Height", num(50.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
-                p("light/lightDirection", "Light Direction", num(-45.0), ParamUi::Angle),
-                p("shading/ambient", "Ambient", num(0.0), slider(-200.0, 200.0, -100.0, 100.0, 1)),
-                p("shading/diffuse", "Diffuse", num(75.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
-                p("shading/specular", "Specular", num(50.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
-                p("shading/roughness", "Roughness", num(0.05), slider(0.001, 1.0, 0.001, 0.5, 3)),
-                p("shading/metal", "Metal", num(100.0), pct()),
-            ],
-            mr_mercury,
-        ),
-    ]
-}
+mod common;
+mod engine;
+mod particle_fx;
+mod registry;
+mod sprites;
+mod weather;
+
+pub(crate) use common::{h, hs, pct, pt, spec};
+pub use engine::particle_state;
+#[cfg(test)]
+use engine::{MERCURY, PS2, PW_EFFECT_CAMERA, Stepped, rate_history, sim_key, simulate_rates};
+#[cfg(test)]
+pub(crate) use engine::{PState, PW_ANIMS, Phys, simulate};
+pub(crate) use engine::{SPS, steps_at};
+pub(crate) use particle_fx::particle_world_textured;
+pub use particle_fx::{Blob, mercury_blobs};
+#[cfg(test)]
+use particle_fx::{PW_RATE, mercury_phys, ps2_phys, pw_phys};
+pub use registry::{specs, sprite_plan};
+pub use sprites::{Acc, Post, Shape, Sprite, SpritePlan, Tint};
+pub(crate) use sprites::{combine, raster, splat};
+pub use weather::{Bubble, bubble_list, bubble_sample_bounds, drizzle_drops};
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{EffectEnv, run_fx};
-
-    fn grey(w: u32, hh: u32) -> Image {
-        Image::filled(w, hh, [0.2, 0.2, 0.2, 1.0])
-    }
-
-    fn ramp(w: u32, hh: u32) -> Image {
-        let mut img = Image::new(w, hh);
-        for y in 0..hh {
-            for x in 0..w {
-                img.set(x, y, [x as f32 / w as f32, y as f32 / hh as f32, 0.4, 1.0]);
-            }
-        }
-        img
-    }
-
-    fn run(id: &str, vals: &[(&str, Value)], img: Image, t: f64) -> Image {
-        run_fx(id, vals, img, t, EffectEnv::default()).img
-    }
-
-    fn diff(a: &Image, b: &Image) -> f32 {
-        a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|k| (p[k] - q[k]).abs()).sum::<f32>()).sum()
-    }
-
-    /// Centre of mass (luminance-weighted difference from `base`), `[-1, -1]` when equal.
-    fn mass(img: &Image, base: &Image) -> [f32; 2] {
-        let (mut m, mut sx, mut sy) = (0.0, 0.0, 0.0);
-        for y in 0..img.height {
-            for x in 0..img.width {
-                let i = img.idx(x, y);
-                let d: f32 = (0..3).map(|k| (img.data[i][k] - base.data[i][k]).abs()).sum();
-                m += d;
-                sx += d * x as f32;
-                sy += d * y as f32;
-            }
-        }
-        if m > 0.0 { [sx / m, sy / m] } else { [-1.0; 2] }
-    }
-
-    /// [`mass`] in y.
-    fn mass_y(img: &Image, base: &Image) -> f32 {
-        mass(img, base)[1]
-    }
-
-    #[test]
-    fn rasteriser_over_and_add() {
-        let s = [Sprite::new(5.0, 5.0, 2.0, [1.0, 0.0, 0.0, 1.0], Shape::Disc)];
-        let img = splat(10, 40, &s, Acc::Over);
-        assert!(img.get(5, 5)[0] > 0.99 && img.get(9, 30)[3] == 0.0);
-        let two = [s[0], s[0]];
-        let add = splat(10, 40, &two, Acc::Add);
-        assert!(add.get(5, 5)[0] > 1.9);
-        // Items spanning band boundaries are drawn in every band.
-        let tall = [Sprite::new(5.0, 16.0, 6.0, [0.0, 1.0, 0.0, 1.0], Shape::Square)];
-        let t = splat(10, 40, &tall, Acc::Over);
-        assert!(t.get(5, 13)[1] > 0.9 && t.get(5, 18)[1] > 0.9);
-    }
-
-    #[test]
-    fn rainfall_deterministic_and_falls() {
-        let vals = [("drops", num(200.0)), ("opacity", num(100.0)), ("extras/appearance", Value::Enum(1)), ("color", col(1.0, 1.0, 1.0))];
-        let a = run("ec.sim.ccrainfall", &vals, grey(40, 40), 0.5);
-        let b = run("ec.sim.ccrainfall", &vals, grey(40, 40), 0.5);
-        assert_eq!(a, b);
-        assert!(diff(&a, &grey(40, 40)) > 1.0, "drops visible");
-        let none = run("ec.sim.ccrainfall", &[("drops", num(0.0))], grey(40, 40), 0.5);
-        assert_eq!(none, grey(40, 40));
-        let later = run("ec.sim.ccrainfall", &vals, grey(40, 40), 0.52);
-        assert!(diff(&a, &later) > 0.1, "rain moves");
-    }
-
-    #[test]
-    fn snowfall_deterministic_and_moves() {
-        let vals = [("flakes", num(300.0))];
-        let a = run("ec.sim.ccsnowfall", &vals, grey(40, 40), 1.0);
-        assert_eq!(a, run("ec.sim.ccsnowfall", &vals, grey(40, 40), 1.0));
-        assert!(diff(&a, &grey(40, 40)) > 1.0);
-        assert!(diff(&a, &run("ec.sim.ccsnowfall", &vals, grey(40, 40), 1.2)) > 0.1);
-        let off = run("ec.sim.ccsnowfall", &[("flakes", num(300.0)), ("compositeWithOriginal", Value::Bool(false))], grey(40, 40), 1.0);
-        assert!(off.data.iter().any(|p| p[3] == 0.0), "without original the background is transparent");
-    }
-
-    #[test]
-    fn bubbles_rise() {
-        let vals = [("bubbleAmount", num(30.0)), ("bubbleSize", num(3.0))];
-        let a = run("ec.sim.ccbubbles", &vals, ramp(40, 40), 0.3);
-        assert_eq!(a, run("ec.sim.ccbubbles", &vals, ramp(40, 40), 0.3));
-        assert!(a.data.iter().any(|p| p[3] > 0.5));
-        let none = run("ec.sim.ccbubbles", &[("bubbleAmount", num(0.0))], ramp(40, 40), 0.3);
-        assert!(none.data.iter().all(|p| p[3] == 0.0), "bubbles replace the layer");
-        // A single slow bubble moves up over a short time.
-        let one = [("bubbleAmount", num(1.0)), ("bubbleSize", num(4.0)), ("wobbleAmplitude", num(0.0)), ("bubbleSpeed", num(0.2))];
-        let blank = Image::new(40, 40);
-        let y0 = mass_y(&run("ec.sim.ccbubbles", &one, ramp(40, 40), 0.0), &blank);
-        let y1 = mass_y(&run("ec.sim.ccbubbles", &one, ramp(40, 40), 0.1), &blank);
-        assert!(y0 >= 0.0 && y1 >= 0.0 && (y1 < y0 || y0 < 8.0), "{y0} -> {y1}");
-    }
-
-    #[test]
-    fn drizzle_ripples() {
-        let a = run("ec.sim.ccdrizzle", &[], ramp(48, 48), 0.6);
-        assert_eq!(a, run("ec.sim.ccdrizzle", &[], ramp(48, 48), 0.6));
-        assert!(diff(&a, &ramp(48, 48)) > 0.1);
-        let none = run("ec.sim.ccdrizzle", &[("dripRate", num(0.0))], ramp(48, 48), 0.6);
-        assert_eq!(none, ramp(48, 48));
-    }
-
-    #[test]
-    fn star_burst_moves_stars() {
-        let a = run("ec.sim.ccstarburst", &[("gridSpacing", num(4.0))], ramp(40, 40), 0.5);
-        assert_eq!(a, run("ec.sim.ccstarburst", &[("gridSpacing", num(4.0))], ramp(40, 40), 0.5));
-        assert!(a.data.iter().any(|p| p[3] > 0.0));
-        let b = run("ec.sim.ccstarburst", &[("gridSpacing", num(4.0))], ramp(40, 40), 0.9);
-        assert!(diff(&a, &b) > 0.5);
-        let full = run("ec.sim.ccstarburst", &[("blendWithOriginal", num(100.0))], ramp(40, 40), 0.5);
-        assert!(diff(&full, &ramp(40, 40)) < 1e-3);
-    }
-
-    fn pw_vals(seed: f64) -> Vec<(&'static str, Value)> {
-        vec![
-            ("birthRate", num(1.0)),
-            ("extras/randomSeed", num(seed)),
-            ("particle/particleType", Value::Enum(2)),
-            ("particle/birthSize", num(0.3)),
-            ("particle/deathSize", num(0.3)),
-        ]
-    }
-
-    /// #1195: with the comp's shutter open, the particles smear across it: the average of the
-    /// sampled sprite fields differs from the sharp frame, touches more pixels and keeps the
-    /// alpha energy.
-    #[test]
-    fn particle_world_motion_blur_trails() {
-        let v = pw_vals(21.0);
-        let blank = Image::new(40, 40);
-        let sharp = run("ec.sim.ccparticleworld", &v, blank.clone(), 2.0);
-        let blurred = crate::run_fx(
-            "ec.sim.ccparticleworld",
-            &v,
-            blank.clone(),
-            2.0,
-            EffectEnv { frame_rate: 10.0, shutter: Some((360.0, -180.0, 8)), ..Default::default() },
-        )
-        .img;
-        assert!(sharp.data.iter().any(|p| p[3] > 0.0), "sharp frame has particles");
-        assert_ne!(sharp.data, blurred.data, "the shutter smears the particles");
-        let lit = |img: &Image| img.data.iter().filter(|p| p[3] > 0.005).count();
-        let sum = |img: &Image| img.data.iter().map(|p| p[3]).sum::<f32>();
-        assert!(lit(&blurred) > lit(&sharp), "trails light more pixels: {} vs {}", lit(&blurred), lit(&sharp));
-        let (sa, ba) = (sum(&sharp), sum(&blurred));
-        assert!((ba - sa).abs() < sa * 0.6 + 1.0, "alpha energy roughly kept: {ba} vs {sa}");
-    }
-
-    #[test]
-    fn particle_world_seek_consistent() {
-        let v = pw_vals(11.0);
-        let direct = run("ec.sim.ccparticleworld", &v, Image::new(40, 40), 2.0);
-        let v2 = pw_vals(12.0);
-        let _ = run("ec.sim.ccparticleworld", &v2, Image::new(40, 40), 1.0);
-        let stepped = run("ec.sim.ccparticleworld", &v2, Image::new(40, 40), 2.0);
-        let direct2 = run("ec.sim.ccparticleworld", &v2, Image::new(40, 40), 2.0);
-        assert_eq!(stepped, direct2);
-        assert!(direct.data.iter().any(|p| p[3] > 0.0), "particles alive");
-        // Before birth nothing is drawn.
-        let t0 = run("ec.sim.ccparticleworld", &v, Image::new(40, 40), 0.0);
-        assert!(t0.data.iter().all(|p| p[3] == 0.0));
-    }
-
-    #[test]
-    fn engine_resume_equals_from_scratch() {
-        for anim in 0..PW_ANIMS.len() as u32 {
-            let phys = Phys {
-                rate: 90.0,
-                life: 1.5,
-                producer: [0.0; 3],
-                radius: [0.05; 3],
-                anim,
-                speed: 0.5,
-                gravity: [0.0, 0.5, 0.0],
-                resistance: 0.2,
-                axis: [0.0, -1.0, 0.0],
-                extra: 1.0,
-                extra_angle: 60.0,
-                seed: 9,
-                max: 10_000,
-                flat: anim % 2 == 0,
-            };
-            let a: SimCache<PState> = SimCache::new(2);
-            let b: SimCache<PState> = SimCache::new(2);
-            let direct = simulate(&a, 1, 2.0, &phys);
-            let _ = simulate(&b, 1, 1.0, &phys);
-            let _ = simulate(&b, 1, 0.37, &phys);
-            let resumed = simulate(&b, 1, 2.0, &phys);
-            assert_eq!(direct.parts.len(), resumed.parts.len(), "anim {anim}");
-            assert!(direct.parts.iter().zip(&resumed.parts).all(|(p, q)| p.p == q.p && p.v == q.v && p.id == q.id), "anim {anim}");
-            assert!(!direct.parts.is_empty());
-        }
-    }
-
-    #[test]
-    fn particle_world_gravity_pulls_down() {
-        let base = |g: f64| {
-            vec![
-                ("birthRate", num(2.0)),
-                ("physics/velocity", num(0.2)),
-                ("physics/gravity", num(g)),
-                ("particle/particleType", Value::Enum(2)),
-                ("particle/birthSize", num(0.2)),
-                ("particle/deathSize", num(0.2)),
-                ("longevity", num(3.0)),
-            ]
-        };
-        let blank = Image::new(48, 48);
-        let up = mass_y(&run("ec.sim.ccparticleworld", &base(0.0), blank.clone(), 1.0), &blank);
-        let down = mass_y(&run("ec.sim.ccparticleworld", &base(2.0), blank.clone(), 1.0), &blank);
-        assert!(down > up + 2.0, "{up} {down}");
-    }
-
-    /// A comp whose camera is `camera` ([`crate::CompScene::camera`]); `layer`: a camera layer
-    /// (else the comp's default view).
-    struct Comp {
-        camera: [[f64; 4]; 3],
-        layer: bool,
-    }
-    impl crate::EffectHost for Comp {
-        fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
-            None
-        }
-        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
-            None
-        }
-        fn comp_scene(&self) -> Option<crate::CompScene> {
-            Some(crate::CompScene { camera: Some(self.camera), camera_layer: self.layer, light: None })
-        }
-    }
-
-    /// A camera `d` px in front of layer point `c` looking at it, moved right by `dx` px and
-    /// zoomed by `zoom` (1 = identity on the layer plane): `c + zoom·d·(p − c − dx) / (z + d)`.
-    fn cam(c: [f64; 2], d: f64, dx: f64, zoom: f64) -> [[f64; 4]; 3] {
-        let k = zoom * d;
-        [[k, 0.0, c[0], d * c[0] - k * (c[0] + dx)], [0.0, k, c[1], d * c[1] - k * c[1]], [0.0, 0.0, 1.0, d]]
-    }
-
-    fn pw_in(comp: &Comp, vals: &[(&str, Value)]) -> Image {
-        run_fx("ec.sim.ccparticleworld", vals, Image::new(48, 48), 1.0, EffectEnv { host: Some(comp), ..Default::default() }).img
-    }
-
-    fn finite(img: &Image) -> bool {
-        img.data.iter().all(|p| p.iter().all(|c| c.is_finite()))
-    }
-
-    /// #397: with a camera layer in the comp, the particles are seen through it.
-    #[test]
-    fn particle_world_follows_the_comp_camera() {
-        let v = pw_vals(3.0);
-        let blank = Image::new(48, 48);
-        let here = Comp { camera: cam([24.0, 24.0], 96.0, 0.0, 1.0), layer: true };
-        let base = pw_in(&here, &v);
-        assert!(base.data.iter().any(|p| p[3] > 0.0), "particles alive");
-        // Moving the camera right moves the particles left.
-        let moved = pw_in(&Comp { camera: cam([24.0, 24.0], 96.0, 8.0, 1.0), ..here }, &v);
-        let (a, b) = (mass(&base, &blank), mass(&moved, &blank));
-        assert!(b[0] < a[0] - 4.0 && (b[1] - a[1]).abs() < 2.0, "{a:?} -> {b:?}");
-        // Zooming in spreads them out.
-        let zoomed = pw_in(&Comp { camera: cam([24.0, 24.0], 96.0, 0.0, 2.0), ..here }, &v);
-        let cover = |i: &Image| i.data.iter().filter(|p| p[3] > 0.01).count();
-        assert!(cover(&zoomed) > cover(&base), "{} {}", cover(&zoomed), cover(&base));
-        // The Effect Camera is ignored then.
-        let mut turned = v.clone();
-        turned.push(("extras/effectCamera/rotationY", num(60.0)));
-        assert_eq!(pw_in(&here, &turned), base);
-        // The comp's default view (no camera layer) leaves it to the Effect Camera.
-        let default_view = Comp { layer: false, ..here };
-        assert_eq!(pw_in(&default_view, &v), run("ec.sim.ccparticleworld", &v, blank.clone(), 1.0));
-        // A camera facing away, or a degenerate one, draws nothing and never NaN.
-        for camera in [[[96.0, 0.0, 24.0, 0.0], [0.0, 96.0, 24.0, 0.0], [0.0, 0.0, -1.0, -96.0]], [[0.0; 4]; 3], [[f64::NAN; 4]; 3]] {
-            assert_eq!(pw_in(&Comp { camera, layer: true }, &v), blank);
-        }
-        // A camera among the particles draws the ones in front of it.
-        let inside = pw_in(&Comp { camera: cam([24.0, 24.0], 1.0, 0.0, 1.0), ..here }, &v);
-        assert!(finite(&inside));
-    }
-
-    /// Extras ▸ Effect Camera: the defaults are the fixed camera Particle World always had.
-    #[test]
-    fn particle_world_effect_camera() {
-        let v = pw_vals(5.0);
-        let base = run("ec.sim.ccparticleworld", &v, Image::new(48, 48), 1.0);
-        let with = |extra: &[(&'static str, Value)]| {
-            let mut w = v.clone();
-            w.extend_from_slice(extra);
-            run("ec.sim.ccparticleworld", &w, Image::new(48, 48), 1.0)
-        };
-        // Missing parameters (projects saved before) read as the defaults.
-        let spec = crate::find("ec.sim.ccparticleworld").unwrap();
-        let mut params = crate::Params { values: spec.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-        params.values.retain(|k, _| !k.starts_with(PW_EFFECT_CAMERA));
-        for (k, val) in &v {
-            params.values.insert(k.to_string(), val.clone());
-        }
-        let ctx = EffectCtx { params: &params, time: 1.0, layer_size: [48.0, 48.0], seed: 1, adjustment: false, env: EffectEnv::default() };
-        assert_eq!(crate::apply(spec, &ctx, Buf { img: Image::new(48, 48), offset: [0.0; 2], scale: 1.0 }).img, base);
-        assert_eq!(with(&[("extras/effectCamera/fov", num(f64::NAN))]), base);
-        // Turning or pulling back the camera changes the view.
-        let turned = with(&[("extras/effectCamera/rotationY", num(60.0))]);
-        assert!(diff(&turned, &base) > 1.0);
-        let cover = |i: &Image| i.data.iter().filter(|p| p[3] > 0.01).count();
-        let far = with(&[("extras/effectCamera/distance", num(4.0))]);
-        assert!(cover(&far) < cover(&base), "{} {}", cover(&far), cover(&base));
-        assert!(diff(&with(&[("extras/effectCamera/fov", num(120.0))]), &base) > 0.1);
-        // Extremes never panic or produce NaN.
-        for extra in [
-            ("extras/effectCamera/distance", num(0.0)),
-            ("extras/effectCamera/distance", num(-5.0)),
-            ("extras/effectCamera/fov", num(0.0)),
-            ("extras/effectCamera/fov", num(180.0)),
-            ("extras/effectCamera/rotationX", num(1e12)),
-        ] {
-            assert!(finite(&with(std::slice::from_ref(&extra))), "{extra:?}");
-        }
-        // Moving the camera doesn't restart the simulation.
-        let key = |pr: &crate::Params| {
-            sim_key(&EffectCtx { params: pr, time: 1.0, layer_size: [48.0, 48.0], seed: 1, adjustment: false, env: EffectEnv::default() }, 1)
-        };
-        let mut moved = params.clone();
-        moved.values.insert("extras/effectCamera/rotationZ".into(), num(30.0));
-        assert_eq!(key(&params), key(&moved));
-        moved.values.insert("extras/randomSeed".into(), num(9.0));
-        assert_ne!(key(&params), key(&moved));
-    }
-
-    #[test]
-    fn particle_systems2_seek_and_direction() {
-        let v = vec![
-            ("producer/position", pt(24.0, 24.0)),
-            ("birthRate", num(3.0)),
-            ("physics/gravity", num(0.0)),
-            ("physics/velocity", num(1.0)),
-            ("physics/animation", Value::Enum(1)),
-        ];
-        let _ = run("ec.sim.ccparticlesystems2", &v, Image::new(48, 48), 0.5);
-        let a = run("ec.sim.ccparticlesystems2", &v, Image::new(48, 48), 1.0);
-        let mut v2 = v.clone();
-        v2.push(("randomSeed", num(0.0)));
-        assert_eq!(a, run("ec.sim.ccparticlesystems2", &v2, Image::new(48, 48), 1.0));
-        // Direction 0° (up): particles above the producer.
-        let blank = Image::new(48, 48);
-        let y = mass_y(&a, &blank);
-        assert!((0.0..24.0).contains(&y), "{y}");
-        // The particles replace the layer: with none born it is empty.
-        let none = run("ec.sim.ccparticlesystems2", &[("birthRate", num(0.0))], grey(20, 20), 1.0);
-        assert_eq!(none, Image::new(20, 20));
-    }
-
-    /// CC Particle World and CC Particle Systems II replace their layer with the particles, in
-    /// every Transfer Mode (which only sets how particles meet each other). SceneYard frames from
-    /// After Effects 2026 show no trace of the source solid: "Task Preparation UI" (black solids
-    /// under fireworks hid a white page), "Burnout matchstick" (a red rectangle around the
-    /// flame), "Documentary Man Falling" (a black block over the light).
-    #[test]
-    fn cc_particles_replace_their_layer() {
-        let red = || {
-            let mut img = Image::new(48, 48);
-            img.data.iter_mut().for_each(|p| *p = [0.7, 0.1, 0.1, 1.0]);
-            img
-        };
-        for id in ["ec.sim.ccparticlesystems2", "ec.sim.ccparticleworld"] {
-            for mode in 0..4 {
-                let v = vec![("birthRate", num(3.0)), ("particle/transferMode", Value::Enum(mode))];
-                let _ = run(id, &v, red(), 0.5);
-                let out = run(id, &v, red(), 1.0);
-                // No source left: the corners, far from the producer, are clear.
-                for (x, y) in [(0, 0), (47, 0), (0, 47), (47, 47)] {
-                    assert!(out.get(x, y)[3] < 1e-6, "{id} mode {mode} ({x},{y}): {:?}", out.get(x, y));
-                }
-                assert!(out.data.iter().any(|p| p[3] > 0.05), "{id} mode {mode}: particles drawn");
-            }
-        }
-    }
-
-    #[test]
-    fn mercury_blobs_and_seek() {
-        let v = vec![("producer", pt(24.0, 16.0)), ("radiusX", num(5.0)), ("radiusY", num(5.0)), ("birthRate", num(3.0))];
-        let _ = run("ec.sim.ccmrmercury", &v, ramp(48, 48), 0.7);
-        let a = run("ec.sim.ccmrmercury", &v, ramp(48, 48), 1.4);
-        let mut v2 = v.clone();
-        v2.push(("shading/metal", num(100.0)));
-        let b = run("ec.sim.ccmrmercury", &v2, ramp(48, 48), 1.4);
-        assert_eq!(a, b);
-        assert!(a.data.iter().any(|p| p[3] > 0.5), "blobs visible");
-        let none = run("ec.sim.ccmrmercury", &[("birthRate", num(0.0))], ramp(48, 48), 1.4);
-        assert!(none.data.iter().all(|p| p[3] == 0.0));
-    }
-
-    #[test]
-    fn half_resolution_scales_sprites() {
-        // Downsampled buffers render the same layout at half size.
-        let s = crate::find("ec.sim.ccsnowfall").unwrap();
-        let mut params = crate::Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
-        params.values.insert("flakes".into(), num(50.0));
-        params.values.insert("offset".into(), pt(20.0, 20.0));
-        let ctx = EffectCtx { params: &params, time: 0.5, layer_size: [40.0, 40.0], seed: 1, adjustment: false, env: EffectEnv::default() };
-        let full = crate::apply(s, &ctx, Buf { img: grey(40, 40), offset: [0.0; 2], scale: 1.0 });
-        let half = crate::apply(s, &ctx, Buf { img: grey(20, 20), offset: [0.0; 2], scale: 0.5 });
-        let sum = |i: &Image| i.data.iter().map(|p| p[0]).sum::<f32>() / i.data.len() as f32;
-        assert!((sum(&full.img) - sum(&half.img)).abs() < 0.05, "{} {}", sum(&full.img), sum(&half.img));
-    }
-}
+mod tests;
diff --git a/crates/effects/src/sim/common.rs b/crates/effects/src/sim/common.rs
new file mode 100644
index 000000000..294d787f1
--- /dev/null
+++ b/crates/effects/src/sim/common.rs
@@ -0,0 +1,25 @@
+use super::{EffectSpec, ParamUi, Value, hash1, slider};
+
+pub(crate) fn spec(id: &'static str, name: &'static str, params: Vec<crate::ParamSpec>, render: crate::RenderFn) -> EffectSpec {
+    EffectSpec { id, name, category: "Simulation", params, render, gpu: false, float: true }
+}
+
+pub(crate) fn pt(x: f64, y: f64) -> Value {
+    Value::Vec2([x, y])
+}
+
+pub(crate) fn pct() -> ParamUi {
+    slider(0.0, 100.0, 0.0, 100.0, 1)
+}
+
+/// Deterministic hash → [0, 1).
+#[inline]
+pub(crate) fn h(i: u32, k: u32, seed: u32) -> f32 {
+    hash1(i, k, seed)
+}
+
+/// Signed hash → [-1, 1).
+#[inline]
+pub(crate) fn hs(i: u32, k: u32, seed: u32) -> f32 {
+    hash1(i, k, seed) * 2.0 - 1.0
+}
diff --git a/crates/effects/src/sim/engine.rs b/crates/effects/src/sim/engine.rs
new file mode 100644
index 000000000..beda8c318
--- /dev/null
+++ b/crates/effects/src/sim/engine.rs
@@ -0,0 +1,374 @@
+use super::common::{h, hs};
+use super::particle_fx::{MERCURY_CACHE, MERCURY_RATE, PS2_CACHE, PS2_RATE, PW_CACHE, PW_RATE, ps2_phys, pw_phys};
+use super::sprites::{Shape, Sprite};
+use super::{Buf, EffectCtx, Image, IntoParallelRefMutIterator, ParallelIterator, SimCache, params_key_except, value_noise};
+
+// ------------------------------------------------------------------ particle engine
+
+/// Steps per second of the stepped particle simulations.
+pub(crate) const SPS: f64 = 60.0;
+
+/// Number of whole steps reached at layer time `t`.
+pub(crate) fn steps_at(t: f64) -> u64 {
+    if t <= 0.0 { 0 } else { (t * SPS + 1e-6).floor() as u64 }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Particle {
+    pub p: [f32; 3],
+    pub v: [f32; 3],
+    pub age: f32,
+    pub life: f32,
+    /// Per-particle random in [0, 1) (size variation, colour jitter…).
+    pub rnd: f32,
+    pub id: u32,
+}
+
+#[derive(Clone, Debug, Default)]
+pub(crate) struct PState {
+    pub parts: Vec<Particle>,
+    pub carry: f64,
+    pub next_id: u32,
+    /// The birth rates of the steps so far (see [`rates_hash`]): a checkpoint is only resumed
+    /// from with the same history.
+    pub hist: u64,
+}
+
+/// `hist` after one more step at `rate` particles per second.
+fn rates_hash(hist: u64, rate: f64) -> u64 {
+    (hist ^ rate.to_bits()).wrapping_mul(0x0100_0000_01b3).rotate_left(5)
+}
+
+/// Physics configuration (world units; y down).
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Phys {
+    /// Particles per second.
+    pub rate: f64,
+    pub life: f32,
+    pub producer: [f32; 3],
+    pub radius: [f32; 3],
+    pub anim: u32,
+    pub speed: f32,
+    pub gravity: [f32; 3],
+    pub resistance: f32,
+    pub axis: [f32; 3],
+    pub extra: f32,
+    pub extra_angle: f32,
+    pub seed: u32,
+    pub max: usize,
+    /// 2D systems keep z = 0.
+    pub flat: bool,
+}
+
+pub(crate) const PW_ANIMS: &[&str] =
+    &["Explosive", "Direction Axis", "Cone Axis", "Viscouse", "Twirly", "Vortex", "Fire", "Jet Sideways", "Fractal Omni", "Fractal Uni"];
+
+pub(super) fn norm3(v: [f32; 3]) -> [f32; 3] {
+    let l = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
+    if l > 1e-9 { [v[0] / l, v[1] / l, v[2] / l] } else { [0.0, -1.0, 0.0] }
+}
+
+fn rand_dir(i: u32, k: u32, seed: u32, flat: bool) -> [f32; 3] {
+    if flat {
+        let a = h(i, k, seed) * std::f32::consts::TAU;
+        return [a.cos(), a.sin(), 0.0];
+    }
+    let z = hs(i, k, seed);
+    let a = h(i, k + 1, seed) * std::f32::consts::TAU;
+    let r = (1.0 - z * z).max(0.0).sqrt();
+    [r * a.cos(), r * a.sin(), z]
+}
+
+impl Phys {
+    fn spawn(&self, id: u32) -> Particle {
+        let seed = self.seed;
+        let mut p = [0.0f32; 3];
+        // Uniform in the producer ellipsoid.
+        let u = rand_dir(id, 1, seed, self.flat);
+        let rr = h(id, 3, seed).powf(if self.flat { 0.5 } else { 1.0 / 3.0 });
+        for k in 0..3 {
+            p[k] = self.producer[k] + u[k] * self.radius[k] * rr;
+        }
+        if self.flat {
+            p[2] = 0.0;
+        }
+        let ax = norm3(self.axis);
+        let jitter = rand_dir(id, 5, seed, self.flat);
+        let dir = match self.anim {
+            1 | 9 => norm3([ax[0] + jitter[0] * 0.08, ax[1] + jitter[1] * 0.08, ax[2] + jitter[2] * 0.08]),
+            2 => {
+                let k = (self.extra_angle.to_radians() * 0.5).tan().abs().min(20.0);
+                norm3([ax[0] + jitter[0] * k * h(id, 8, seed), ax[1] + jitter[1] * k * h(id, 8, seed), ax[2] + jitter[2] * k * h(id, 8, seed)])
+            }
+            5 => [jitter[0], 0.0, if self.flat { 0.0 } else { jitter[2] }],
+            6 => norm3([jitter[0] * 0.25, -1.0, jitter[2] * 0.25]),
+            7 => norm3([1.0, jitter[1] * 0.05, jitter[2] * 0.05]),
+            _ => jitter,
+        };
+        let sp = self.speed * (0.5 + 0.5 * h(id, 9, seed));
+        let mut v = [dir[0] * sp, dir[1] * sp, dir[2] * sp];
+        if self.flat {
+            v[2] = 0.0;
+        }
+        let life = self.life * (0.8 + 0.4 * h(id, 10, seed));
+        Particle { p, v, age: 0.0, life, rnd: h(id, 11, seed), id }
+    }
+
+    /// One step at the constant [`Phys::rate`] (the tests' reference).
+    #[cfg(test)]
+    pub(crate) fn step(&self, st: &mut PState, step: u64) {
+        self.step_at_rate(st, step, self.rate);
+    }
+
+    /// One step with `rate` particles per second born during it (rather than [`Phys::rate`]):
+    /// the rate only decides the births, particles already alive move and age as ever.
+    pub(crate) fn step_at_rate(&self, st: &mut PState, step: u64, rate: f64) {
+        let dt = (1.0 / SPS) as f32;
+        let t = step as f32 * dt;
+        let mut drag = self.resistance;
+        if self.anim == 3 {
+            drag += 3.0 * self.extra.max(0.1);
+        }
+        let damp = (-drag * dt).exp();
+        let seed = self.seed;
+        st.parts.par_iter_mut().for_each(|q| {
+            let mut a = self.gravity;
+            match self.anim {
+                4 => {
+                    // Twirly: swirl around the vertical axis through the producer.
+                    let (dx, dz) = (q.p[0] - self.producer[0], q.p[2] - self.producer[2]);
+                    let k = 4.0 * self.extra;
+                    a[0] += -dz * k;
+                    a[2] += dx * k;
+                    if self.flat {
+                        let dy = q.p[1] - self.producer[1];
+                        a[0] += -dy * k;
+                        a[1] += dx * k;
+                    }
+                }
+                5 => {
+                    // Vortex: strong tangential + inward pull.
+                    let (dx, dy) = (q.p[0] - self.producer[0], q.p[1] - self.producer[1]);
+                    let k = 6.0 * self.extra;
+                    a[0] += -dy * k - dx * 2.0;
+                    a[1] += dx * k - dy * 2.0;
+                }
+                6 => {
+                    // Fire: buoyant, flickering turbulence.
+                    let n = value_noise(q.p[0] * 8.0, q.p[1] * 8.0, t * 3.0, seed) - 0.5;
+                    a[0] += n * 4.0 * self.extra;
+                    a[1] -= self.gravity[1] * 1.5 + 0.3 * self.extra;
+                }
+                8 | 9 => {
+                    let f = 6.0 * self.extra;
+                    a[0] += (value_noise(q.p[0] * 5.0, q.p[1] * 5.0, q.p[2] * 5.0 + t, seed) - 0.5) * f;
+                    a[1] += (value_noise(q.p[0] * 5.0 + 17.0, q.p[1] * 5.0, q.p[2] * 5.0 + t, seed) - 0.5) * f;
+                    if !self.flat {
+                        a[2] += (value_noise(q.p[0] * 5.0, q.p[1] * 5.0 + 31.0, q.p[2] * 5.0 + t, seed) - 0.5) * f;
+                    }
+                }
+                _ => {}
+            }
+            for k in 0..3 {
+                q.v[k] = (q.v[k] + a[k] * dt) * damp;
+                q.p[k] += q.v[k] * dt;
+            }
+            if self.flat {
+                q.p[2] = 0.0;
+                q.v[2] = 0.0;
+            }
+            q.age += dt;
+        });
+        st.parts.retain(|q| q.age < q.life);
+        st.hist = rates_hash(st.hist, rate);
+        st.carry += rate / SPS;
+        let n = st.carry.floor() as u32;
+        st.carry -= n as f64;
+        for _ in 0..n {
+            if st.parts.len() >= self.max {
+                break;
+            }
+            let id = st.next_id;
+            st.next_id = st.next_id.wrapping_add(1);
+            // Sub-step birth offset keeps continuous streams smooth.
+            let mut q = self.spawn(id);
+            let frac = h(id, 12, seed) * dt;
+            for k in 0..3 {
+                q.p[k] += q.v[k] * frac;
+            }
+            q.age = frac;
+            st.parts.push(q);
+        }
+    }
+}
+
+impl Phys {
+    /// The backend description (per-step and per-spawn constants evaluated here, in f32).
+    pub(crate) fn desc(&self) -> crate::psim::EngineDesc {
+        let mut drag = self.resistance;
+        if self.anim == 3 {
+            drag += 3.0 * self.extra.max(0.1);
+        }
+        let dt = (1.0 / SPS) as f32;
+        crate::psim::EngineDesc {
+            life: self.life,
+            producer: self.producer,
+            radius: self.radius,
+            anim: self.anim,
+            speed: self.speed,
+            gravity: self.gravity,
+            axis: norm3(self.axis),
+            extra: self.extra,
+            cone: (self.extra_angle.to_radians() * 0.5).tan().abs().min(20.0),
+            damp: (-drag * dt).exp(),
+            seed: self.seed,
+            flat: self.flat,
+        }
+    }
+}
+
+/// The state at layer time `ctx.time` from the host's particle backend (GPU particles), or
+/// `None` (simulate on the CPU). `rates`: the birth rate of each step, when it changes over time
+/// (else [`Phys::rate`]).
+pub(super) fn accelerated(ctx: &EffectCtx, key: u64, phys: &Phys, rates: Option<&[f64]>) -> Option<std::sync::Arc<PState>> {
+    let backend = ctx.env.host?.particles()?;
+    let steps = steps_at(ctx.time);
+    let births = match rates {
+        Some(r) => crate::psim::births_at(steps, phys.max, |i| r.get(i as usize).copied().unwrap_or(0.0))?,
+        None => crate::psim::births(phys.rate, steps, phys.max)?,
+    };
+    let req = crate::psim::SimRequest { key, steps, births: &births, system: crate::psim::ParticleSystem::Engine(phys.desc()) };
+    let parts = backend.simulate(&req)?;
+    Some(std::sync::Arc::new(PState {
+        parts: parts.into_iter().map(|q| Particle { p: q.p, v: q.v, age: q.age, life: q.life, rnd: q.rnd, id: q.id }).collect(),
+        carry: 0.0,
+        next_id: births.len() as u32,
+        hist: 0,
+    }))
+}
+
+/// The birth rate (particles per second) of each step up to layer time `ctx.time`: parameter
+/// `id` × `k`, sampled where the step starts (a keyframed or expression-driven Birth Rate only
+/// decides the births of its own time, #1373). Without a host that evaluates the effect at
+/// other times, the current value for every step.
+pub(super) fn rate_history(ctx: &EffectCtx, id: &str, k: f64) -> Vec<f64> {
+    let now = ctx.params.f(id);
+    // A rate without keyframes or an expression is the same at every step.
+    let host = ctx.env.host.filter(|h| !h.param_is_static(ctx.env.effect_index, id));
+    (0..steps_at(ctx.time))
+        .map(|i| {
+            let v = host.and_then(|h| h.param_at(ctx.env.effect_index, id, i as f64 / SPS)).map_or(now, |v| v.as_f64());
+            if v.is_finite() { v.max(0.0) * k } else { 0.0 }
+        })
+        .collect()
+}
+
+/// Run a particle system through `rates` (one birth rate per step, see [`rate_history`]) with
+/// `cache`, resuming only from checkpoints reached with the same rates.
+pub(super) fn simulate_rates(cache: &SimCache<PState>, key: u64, phys: &Phys, rates: &[f64]) -> std::sync::Arc<PState> {
+    // `hist` of the state after each number of steps.
+    let mut prefix = Vec::with_capacity(rates.len() + 1);
+    prefix.push(0u64);
+    for r in rates {
+        prefix.push(rates_hash(prefix.last().copied().unwrap_or(0), *r));
+    }
+    let rate = |i: u64| rates.get(i as usize).copied().unwrap_or(0.0);
+    cache.run_where(key, rates.len() as u64, PState::default, |st, i| phys.step_at_rate(st, i, rate(i)), |s, st| prefix.get(s as usize) == Some(&st.hist))
+}
+
+/// A stepped particle system's particles at `ctx.time`, born at the Birth Rate of their own
+/// time (`birthRate` × `k` particles per second, see [`rate_history`]). The cache key is every
+/// parameter but Birth Rate (its history is checked through `PState::hist`) and those under
+/// `skip`, with `salt`. `gpu`: the host's particle backend may simulate it.
+pub(super) struct Stepped<'a> {
+    pub(super) cache: &'a SimCache<PState>,
+    pub(super) salt: u64,
+    pub(super) skip: &'a [&'a str],
+    pub(super) k: f64,
+    pub(super) gpu: bool,
+}
+
+impl Stepped<'_> {
+    pub(super) fn state(&self, ctx: &EffectCtx, phys: &Phys) -> std::sync::Arc<PState> {
+        let rates = rate_history(ctx, "birthRate", self.k);
+        let mut skip = self.skip.to_vec();
+        skip.push("birthRate");
+        let key = params_key_except(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, self.salt, &skip);
+        let gpu = if self.gpu { accelerated(ctx, key, phys, Some(&rates)) } else { None };
+        gpu.unwrap_or_else(|| simulate_rates(self.cache, key, phys, &rates))
+    }
+}
+
+/// CC Particle World.
+const PW: Stepped = Stepped { cache: &PW_CACHE, salt: 1, skip: &[PW_EFFECT_CAMERA], k: PW_RATE, gpu: true };
+/// CC Particle Systems II.
+pub(super) const PS2: Stepped = Stepped { cache: &PS2_CACHE, salt: 2, skip: &[], k: PS2_RATE, gpu: true };
+/// CC Mr. Mercury (its blobs are simulated on the CPU).
+pub(super) const MERCURY: Stepped = Stepped { cache: &MERCURY_CACHE, salt: 3, skip: &[], k: MERCURY_RATE, gpu: false };
+
+/// CC Particle World's particles at `ctx.time`, born at the Birth Rate of their own time.
+pub(super) fn pw_state(ctx: &EffectCtx, phys: &Phys) -> std::sync::Arc<PState> {
+    PW.state(ctx, phys)
+}
+
+/// The live particles of a stepped particle effect (`ec.sim.ccparticleworld`,
+/// `ec.sim.ccparticlesystems2`) at `ctx.time`: from the host's particle backend when it has
+/// one (GPU particles), else from the CPU simulation. For comparing the two.
+pub fn particle_state(id: &str, ctx: &EffectCtx) -> Option<Vec<crate::psim::SimParticle>> {
+    let st = match id {
+        "ec.sim.ccparticleworld" => pw_state(ctx, &pw_phys(ctx)),
+        "ec.sim.ccparticlesystems2" => PS2.state(ctx, &ps2_phys(ctx)),
+        _ => return None,
+    };
+    Some(st.parts.iter().map(|q| crate::psim::SimParticle { p: q.p, v: q.v, age: q.age, life: q.life, rnd: q.rnd, id: q.id }).collect())
+}
+
+/// The simulation cache key of a stepped particle effect at a constant Birth Rate (the tests'
+/// reference): every parameter but CC Particle World's Effect Camera.
+#[cfg(test)]
+pub(super) fn sim_key(ctx: &EffectCtx, salt: u64) -> u64 {
+    params_key_except(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, salt, &[PW_EFFECT_CAMERA])
+}
+
+/// Run a particle system at its constant [`Phys::rate`] to layer time `t` through `cache` (the
+/// tests' reference).
+#[cfg(test)]
+pub(crate) fn simulate(cache: &SimCache<PState>, key: u64, t: f64, phys: &Phys) -> std::sync::Arc<PState> {
+    cache.run(key, steps_at(t), PState::default, |st, i| phys.step(st, i))
+}
+
+pub(crate) const PARTICLE_TYPES: &[&str] =
+    &["Line", "Shaded Sphere", "Faded Sphere", "Bubble", "Star", "Motion Polygon", "Tri-Polygon", "Cube", "Textured Square"];
+
+/// Colour/size/opacity of a particle at its age.
+pub(super) fn particle_look(q: &Particle, birth: [f32; 4], death: [f32; 4], bsize: f32, dsize: f32, svar: f32, max_op: f32) -> ([f32; 4], f32) {
+    let u = (q.age / q.life.max(1e-4)).clamp(0.0, 1.0);
+    let size = (bsize + (dsize - bsize) * u) * (1.0 + svar * (q.rnd * 2.0 - 1.0));
+    let fade = (u * 20.0).min(1.0) * ((1.0 - u) * 5.0).min(1.0);
+    let c = [birth[0] + (death[0] - birth[0]) * u, birth[1] + (death[1] - birth[1]) * u, birth[2] + (death[2] - birth[2]) * u, max_op * fade];
+    (c, size.max(0.0))
+}
+
+pub(super) fn type_sprite(kind: u32, x: f32, y: f32, r: f32, c: [f32; 4], velocity: [f32; 2], rot: f32) -> Sprite {
+    let [vx, vy] = velocity;
+    let vl = (vx * vx + vy * vy).sqrt().max(1e-6);
+    let shape = match kind {
+        0 => Shape::Line { dx: -vx / vl * r * 2.0, dy: -vy / vl * r * 2.0 },
+        1 => Shape::Sphere,
+        2 => Shape::Faded,
+        3 => Shape::Bubble,
+        4 => Shape::Star,
+        5 => Shape::Line { dx: -vx * 0.05, dy: -vy * 0.05 },
+        6 => Shape::Tri,
+        _ => Shape::Square,
+    };
+    let rr = match kind {
+        0 => (r * 0.08).max(0.5),
+        5 => r * 0.5,
+        _ => r,
+    };
+    Sprite { x, y, r: rr, c, shape, rot }
+}
+
+/// CC Particle World's Extras ▸ Effect Camera parameters (id prefix).
+pub(super) const PW_EFFECT_CAMERA: &str = "extras/effectCamera/";
diff --git a/crates/effects/src/sim/particle_fx.rs b/crates/effects/src/sim/particle_fx.rs
new file mode 100644
index 000000000..c2f493ab5
--- /dev/null
+++ b/crates/effects/src/sim/particle_fx.rs
@@ -0,0 +1,430 @@
+use super::engine::{MERCURY, PS2, PState, PW_EFFECT_CAMERA, Phys, norm3, particle_look, pw_state, type_sprite};
+use super::sprites::{Acc, Post, Sprite, SpritePlan, aa, raster, splat, sprite_bbox};
+use super::{Buf, EffectCtx, Image, IntoParallelRefIterator, ParallelIterator, SimCache, Value, unpremul};
+
+// ------------------------------------------------------------------ CC Particle World
+
+pub(super) static PW_CACHE: SimCache<PState> = SimCache::new(6);
+
+/// Particles per second per unit of CC Particle World's Birth Rate.
+pub(super) const PW_RATE: f64 = 120.0;
+
+/// CC Particle World's physics.
+pub(super) fn pw_phys(ctx: &EffectCtx) -> Phys {
+    let pr = ctx.params;
+    Phys {
+        rate: pr.f("birthRate").max(0.0) * PW_RATE,
+        life: pr.f("longevity").max(0.0) as f32,
+        producer: [pr.f("producer/producerX") as f32, pr.f("producer/producerY") as f32, pr.f("producer/producerZ") as f32],
+        radius: [pr.f("producer/radiusX").max(0.0) as f32, pr.f("producer/radiusY").max(0.0) as f32, pr.f("producer/radiusZ").max(0.0) as f32],
+        anim: pr.e("physics/animation"),
+        speed: pr.f("physics/velocity") as f32 * 0.5,
+        gravity: {
+            let g = pr.f("physics/gravity") as f32;
+            let gv =
+                [pr.f("physics/gravityVector/gravityX") as f32, pr.f("physics/gravityVector/gravityY") as f32, pr.f("physics/gravityVector/gravityZ") as f32];
+            [gv[0] * g, gv[1] * g, gv[2] * g]
+        },
+        resistance: pr.f("physics/resistance").max(0.0) as f32,
+        axis: [pr.f("physics/directionAxis/axisX") as f32, pr.f("physics/directionAxis/axisY") as f32, pr.f("physics/directionAxis/axisZ") as f32],
+        extra: pr.f("physics/extra") as f32,
+        extra_angle: pr.f("physics/extraAngle") as f32,
+        seed: (pr.f("extras/randomSeed") as u32).wrapping_mul(0x9e3779b9) ^ ctx.seed,
+        max: 40_000,
+        flat: false,
+    }
+}
+
+/// CC Particle World's Particle Type ▸ Textured Square.
+const PW_TEXTURED_SQUARE: u32 = 8;
+/// CC Particle World's Particle ▸ Texture ▸ Texture Layer.
+pub(super) const PW_TEXTURE_LAYER: &str = "particle/texture/textureLayer";
+
+/// Whether CC Particle World draws its Texture Layer on the particles (Textured Square with a
+/// layer chosen). Only the CPU does: `catalog::gpu_supported` keeps this case off the GPU.
+pub(crate) fn particle_world_textured(ctx: &EffectCtx) -> bool {
+    ctx.params.e("particle/particleType") == PW_TEXTURED_SQUARE && ctx.params.get(PW_TEXTURE_LAYER).and_then(Value::as_layer).is_some()
+}
+
+pub(super) fn particle_world(ctx: &EffectCtx, b: Buf) -> Buf {
+    // The texture at the current comp time, shared by every shutter sample. A layer the host
+    // can't give (the effect's own layer with its effects, a reference cycle) leaves the
+    // squares in the particle colour. Authored buffers (text, shapes) span only their content:
+    // covering the whole layer keeps the clamped sampling from stretching their edge pixels.
+    let tex = particle_world_textured(ctx).then(|| ctx.layer_param(PW_TEXTURE_LAYER, true)).flatten().map(|mut t| {
+        t.buf.cover(t.size);
+        t
+    });
+    let (w, h) = (b.img.width, b.img.height);
+    let draw = |plan: &SpritePlan| match &tex {
+        Some(t) => splat_textured(w, h, &plan.sprites, plan.acc, t),
+        None => splat(w, h, &plan.sprites, plan.acc),
+    };
+    // #1195: with the comp's motion-blur shutter open, particles draw as motion trails: the
+    // sprite fields of samples across the shutter are averaged, as Transform averages its
+    // matrix samples. (The GPU compositor runs this case on the CPU: catalog::gpu_supported.)
+    if let Some((angle, phase, n)) = ctx.env.shutter.filter(|(a, _, _)| *a > 0.0) {
+        let n = (n.clamp(2, 64) as usize).max(2);
+        let fd = 1.0 / ctx.fps().max(0.001);
+        let mut acc = Image::new(w, h);
+        let mut post: Option<Post> = None;
+        for k in 0..n {
+            let t = ctx.time + (phase + angle * k as f64 / (n - 1) as f64) / 360.0 * fd;
+            let sub = EffectCtx { params: ctx.params, time: t, layer_size: ctx.layer_size, seed: ctx.seed, adjustment: ctx.adjustment, env: ctx.env };
+            if let Some(plan) = particle_world_plan(&sub, &b) {
+                let fx = draw(&plan);
+                acc.data.iter_mut().zip(&fx.data).for_each(|(a, o)| (0..4).for_each(|c| a[c] += o[c]));
+                post.get_or_insert(plan.post);
+            }
+        }
+        acc.data.iter_mut().for_each(|p| p.iter_mut().for_each(|v| *v /= n as f32));
+        return match post {
+            Some(p) => p.apply(b, acc),
+            None => b,
+        };
+    }
+    match particle_world_plan(ctx, &b) {
+        Some(plan) => {
+            let fx = draw(&plan);
+            plan.finish_with(b, fx)
+        }
+        None => b,
+    }
+}
+
+/// Draw square sprites into a new transparent image of `w`×`h`, each showing the layer `tex`
+/// stretched over the square (turned with it) at the sprite's opacity.
+fn splat_textured(w: u32, hgt: u32, sprites: &[Sprite], acc: Acc, tex: &crate::LayerPixels) -> Image {
+    let mut img = Image::new(w, hgt);
+    let (tw, th) = (tex.size[0], tex.size[1]);
+    let shade = |s: &Sprite, x: f32, y: f32| {
+        // As [`sprite_shade`]'s Square, sub-pixel sprites included.
+        let (r, fade) = if s.r < 0.5 { (0.5, s.r / 0.5) } else { (s.r, 1.0) };
+        let (sn, cs) = s.rot.sin_cos();
+        let (dx, dy) = (x - s.x, y - s.y);
+        let (ux, uy) = (dx * cs + dy * sn, -dx * sn + dy * cs);
+        let e = r * 0.75;
+        let a = aa(e - ux.abs()) * aa(e - uy.abs()) * s.c[3] * fade;
+        if a <= 1e-6 {
+            return None;
+        }
+        let (u, v) = (((ux / e + 1.0) * 0.5).clamp(0.0, 1.0) as f64, ((uy / e + 1.0) * 0.5).clamp(0.0, 1.0) as f64);
+        let (px, py) = tex.buf.to_px([u * tw, v * th]);
+        Some(tex.buf.img.sample_bilinear_clamped(px, py).map(|c| c * a))
+    };
+    raster(&mut img, sprites, sprite_bbox, shade, acc);
+    img
+}
+
+/// Effect Camera ▸ FOV's default (degrees).
+pub(super) const PW_FOV: f64 = 50.0;
+
+/// What CC Particle World sees its particles through.
+enum PwCamera {
+    /// Extras ▸ Effect Camera, in world units (layer widths): `dist` from the world origin (the
+    /// layer centre) along −z, the world turned by `rot` (`None` = not turned) about the origin,
+    /// `focal` the scale at unit depth; particles nearer than `near` aren't drawn.
+    Effect { rot: Option<[[f32; 3]; 3]>, dist: f32, focal: f32, near: f32 },
+    /// The comp's active camera layer, on buffer-world points (After Effects then ignores the
+    /// Effect Camera).
+    Comp(crate::card3d::Proj),
+}
+
+/// A particle as the camera sees it: depth (larger is farther), buffer pixel, size scale `k`
+/// (buffer pixels per world unit = `k · layer width · buffer scale`) and velocity in world units
+/// on screen (× the same factor for buffer pixels).
+struct PwSeen {
+    depth: f32,
+    x: f32,
+    y: f32,
+    k: f32,
+    v: [f32; 2],
+}
+
+impl PwCamera {
+    fn new(ctx: &EffectCtx, b: &Buf) -> PwCamera {
+        let [lw, lh] = ctx.layer_size;
+        if let Some(cam) = ctx.env.host.and_then(|h| h.comp_scene()).filter(|sc| sc.camera_layer).and_then(|sc| sc.camera) {
+            let c = [b.offset[0] + lw * 0.5 * b.scale, b.offset[1] + lh * 0.5 * b.scale];
+            return PwCamera::Comp(crate::card3d::comp_proj(&cam, c, b));
+        }
+        let f = |id: &str, d: f64| ctx.params.get(&format!("{PW_EFFECT_CAMERA}{id}")).map(Value::as_f64).filter(|v| v.is_finite()).unwrap_or(d);
+        // The camera keeps the origin's plane at the scale Distance gives it as FOV changes
+        // (moving in for a wider view), so FOV sets how strong the perspective is. Distance 2
+        // shows the origin's plane at the layer's own scale.
+        let half = |fov: f64| (fov.clamp(1.0, 179.0).to_radians() * 0.5).tan();
+        let zoom = half(PW_FOV) / half(f("fov", PW_FOV));
+        let dist = f("distance", 2.0).max(0.01) * zoom;
+        let a = [f("rotationX", 0.0), f("rotationY", 0.0), f("rotationZ", 0.0)];
+        let rot = (a != [0.0; 3]).then(|| {
+            let r = crate::card3d::rot_ordered(a[0].to_radians(), a[1].to_radians(), a[2].to_radians(), 0);
+            r.map(|row| row.map(|v| v as f32))
+        });
+        PwCamera::Effect { rot, dist: dist as f32, focal: (2.0 * zoom) as f32, near: (0.025 * dist) as f32 }
+    }
+
+    /// How the camera sees world point `p` moving at `v`; `None` behind or too close to it.
+    fn see(&self, p: [f32; 3], v: [f32; 3], lw: f32, lh: f32, b: &Buf) -> Option<PwSeen> {
+        match self {
+            PwCamera::Effect { rot, dist, focal, near } => {
+                let turn = |r: &[[f32; 3]; 3], q: [f32; 3]| r.map(|row| row[0] * q[0] + row[1] * q[1] + row[2] * q[2]);
+                let (p, v) = match rot {
+                    Some(r) => (turn(r, p), turn(r, v)),
+                    None => (p, v),
+                };
+                let zc = dist + p[2];
+                if zc.is_nan() || zc <= *near {
+                    return None;
+                }
+                let k = focal / zc;
+                let (x, y) = b.to_px([(lw * 0.5 + p[0] * lw * k) as f64, (lh * 0.5 + p[1] * lw * k) as f64]);
+                Some(PwSeen { depth: zc, x: x as f32, y: y as f32, k, v: [v[0], v[1]] })
+            }
+            PwCamera::Comp(proj) => {
+                let (s, lw, lh) = (b.scale, lw as f64, lh as f64);
+                let u = lw * s;
+                let at = [b.offset[0] + lw * 0.5 * s + p[0] as f64 * u, b.offset[1] + lh * 0.5 * s + p[1] as f64 * u, p[2] as f64 * u];
+                let seen = proj.view(at, [v[0] as f64, v[1] as f64, v[2] as f64])?;
+                let k = seen.scale;
+                Some(PwSeen {
+                    depth: seen.depth as f32,
+                    x: seen.at[0] as f32,
+                    y: seen.at[1] as f32,
+                    k: k as f32,
+                    v: [(seen.vel[0] / k) as f32, (seen.vel[1] / k) as f32],
+                })
+            }
+        }
+    }
+}
+
+/// CC Particle World's sprites (far to near), `None` before anything is born.
+pub(super) fn particle_world_plan(ctx: &EffectCtx, b: &Buf) -> Option<SpritePlan> {
+    let pr = ctx.params;
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let phys = pw_phys(ctx);
+    if phys.rate <= 0.0 && ctx.time <= 0.0 {
+        return None;
+    }
+    let st = pw_state(ctx, &phys);
+    let kind = pr.e("particle/particleType");
+    let birth = pr.color("particle/birthColor");
+    let death = pr.color("particle/deathColor");
+    let (bs, ds) = (pr.f("particle/birthSize") as f32, pr.f("particle/deathSize") as f32);
+    let svar = pr.f("particle/sizeVariation") as f32 / 100.0;
+    let max_op = pr.f("particle/maxOpacity") as f32 / 100.0;
+    let s = b.scale as f32;
+    let cam = PwCamera::new(ctx, b);
+    let mut list: Vec<(f32, Sprite)> = st
+        .parts
+        .par_iter()
+        .filter_map(|q| {
+            let PwSeen { depth, x, y, k, v } = cam.see(q.p, q.v, lw, lh, b)?;
+            let (c, size) = particle_look(q, birth, death, bs, ds, svar, max_op);
+            let r = size * 0.5 * lw * k * s * 0.25;
+            let sp = type_sprite(kind, x, y, r, c, [v[0] * lw * k * s, v[1] * lw * k * s], (q.id % 628) as f32 * 0.01 + q.age * 2.0);
+            Some((depth, sp))
+        })
+        .collect();
+    list.sort_by(|a, b| b.0.total_cmp(&a.0));
+    let sprites: Vec<Sprite> = list.into_iter().map(|(_, s)| s).collect();
+    Some(particle_sprites(sprites, pr.e("particle/transferMode")))
+}
+
+/// The CC particle systems' sprites with their Transfer Mode (Composite, Screen, Add, Black
+/// Background).
+fn particle_sprites(sprites: Vec<Sprite>, mode: u32) -> SpritePlan {
+    // The particles replace the layer (After Effects shows no trace of the source in any
+    // Transfer Mode, which sets how the particles meet each other).
+    SpritePlan { sprites, tints: vec![], acc: if mode == 2 { Acc::Add } else { Acc::Over }, post: Post::Replace }
+}
+
+// ------------------------------------------------------------------ CC Particle Systems II
+
+pub(super) static PS2_CACHE: SimCache<PState> = SimCache::new(6);
+
+/// Particles per second per unit of CC Particle Systems II's Birth Rate.
+pub(super) const PS2_RATE: f64 = 60.0;
+
+/// CC Particle Systems II's physics.
+pub(super) fn ps2_phys(ctx: &EffectCtx) -> Phys {
+    let pr = ctx.params;
+    let lh = ctx.layer_size[1] as f32;
+    let unit = lh.max(1.0);
+    let pos = pr.v2("producer/position");
+    let dir = (pr.f("physics/direction") as f32).to_radians();
+    Phys {
+        rate: pr.f("birthRate").max(0.0) * PS2_RATE,
+        life: pr.f("longevity").max(0.0) as f32,
+        producer: [pos[0] as f32 / unit, pos[1] as f32 / unit, 0.0],
+        radius: [pr.f("producer/radiusX").max(0.0) as f32 / unit, pr.f("producer/radiusY").max(0.0) as f32 / unit, 0.0],
+        anim: [0u32, 1, 2, 3, 4, 5, 6, 7, 8, 9][pr.e("physics/animation").min(9) as usize],
+        speed: pr.f("physics/velocity") as f32 * 0.25,
+        gravity: [0.0, pr.f("physics/gravity") as f32 * 0.5, 0.0],
+        resistance: pr.f("physics/resistance").max(0.0) as f32,
+        // AE angles: 0° = up, clockwise.
+        axis: [dir.sin(), -dir.cos(), 0.0],
+        extra: pr.f("physics/extra") as f32,
+        extra_angle: 45.0 * pr.f("physics/extra") as f32,
+        seed: (pr.f("randomSeed") as u32).wrapping_mul(0x85ebca6b) ^ ctx.seed,
+        max: 40_000,
+        flat: true,
+    }
+}
+
+pub(super) fn particle_systems2(ctx: &EffectCtx, b: Buf) -> Buf {
+    particle_systems2_plan(ctx, &b).finish(b)
+}
+
+/// CC Particle Systems II's sprites.
+pub(super) fn particle_systems2_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
+    let pr = ctx.params;
+    let lh = ctx.layer_size[1] as f32;
+    let unit = lh.max(1.0);
+    let st = PS2.state(ctx, &ps2_phys(ctx));
+    let kind = pr.e("particle/particleType");
+    let birth = pr.color("particle/birthColor");
+    let death = pr.color("particle/deathColor");
+    let (bs, ds) = (pr.f("particle/birthSize") as f32, pr.f("particle/deathSize") as f32);
+    let svar = pr.f("particle/sizeVariation") as f32 / 100.0;
+    let max_op = pr.f("particle/maxOpacity") as f32 / 100.0;
+    let s = b.scale as f32;
+    let sprites: Vec<Sprite> = st
+        .parts
+        .iter()
+        .map(|q| {
+            let (bx, by) = b.to_px([(q.p[0] * unit) as f64, (q.p[1] * unit) as f64]);
+            let (c, size) = particle_look(q, birth, death, bs, ds, svar, max_op);
+            let r = size * unit * 0.02 * s;
+            type_sprite(kind, bx as f32, by as f32, r, c, [q.v[0] * unit * s, q.v[1] * unit * s], (q.id % 628) as f32 * 0.01 + q.age * 2.0)
+        })
+        .collect();
+    particle_sprites(sprites, pr.e("particle/transferMode"))
+}
+
+// ------------------------------------------------------------------ CC Mr. Mercury
+
+pub(super) static MERCURY_CACHE: SimCache<PState> = SimCache::new(6);
+
+/// Blobs per second per unit of CC Mr. Mercury's Birth Rate.
+pub(super) const MERCURY_RATE: f64 = 10.0;
+
+/// A CC Mr. Mercury blob (buffer px).
+#[derive(Clone, Copy, Debug)]
+pub struct Blob {
+    pub x: f32,
+    pub y: f32,
+    pub r: f32,
+}
+
+/// CC Mr. Mercury's physics.
+pub(super) fn mercury_phys(ctx: &EffectCtx) -> Phys {
+    let pr = ctx.params;
+    let unit = (ctx.layer_size[1] as f32).max(1.0);
+    let pos = pr.v2("producer");
+    let dir = (pr.f("direction") as f32).to_radians();
+    Phys {
+        rate: pr.f("birthRate").max(0.0) * MERCURY_RATE,
+        life: pr.f("longevity").max(0.0) as f32,
+        producer: [pos[0] as f32 / unit, pos[1] as f32 / unit, 0.0],
+        radius: [pr.f("radiusX").max(0.0) as f32 / unit, pr.f("radiusY").max(0.0) as f32 / unit, 0.0],
+        anim: [0u32, 1, 2, 3, 4, 5, 6, 7, 8, 9][pr.e("animation").min(9) as usize],
+        speed: pr.f("velocity") as f32 * 0.3,
+        gravity: [0.0, pr.f("gravity") as f32 * 0.5, 0.0],
+        resistance: pr.f("resistance").max(0.0) as f32,
+        axis: [dir.sin(), -dir.cos(), 0.0],
+        extra: pr.f("extra") as f32,
+        extra_angle: 45.0 * pr.f("extra") as f32,
+        seed: ctx.seed.wrapping_mul(0xc2b2ae35),
+        max: 4_000,
+        flat: true,
+    }
+}
+
+/// CC Mr. Mercury's blobs this frame, from its particle simulation (for buffer geometry `b`).
+pub fn mercury_blobs(ctx: &EffectCtx, b: &Buf) -> Vec<Blob> {
+    let pr = ctx.params;
+    let unit = (ctx.layer_size[1] as f32).max(1.0);
+    let phys = mercury_phys(ctx);
+    let st = MERCURY.state(ctx, &phys);
+    let (bs, ds) = (pr.f("blobBirthSize") as f32, pr.f("blobDeathSize") as f32);
+    let s = b.scale as f32;
+    st.parts
+        .iter()
+        .map(|q| {
+            let u = (q.age / q.life.max(1e-4)).clamp(0.0, 1.0);
+            let size = bs + (ds - bs) * u;
+            let (bx, by) = b.to_px([(q.p[0] * unit) as f64, (q.p[1] * unit) as f64]);
+            Blob { x: bx as f32, y: by as f32, r: (size * unit * 0.08 * s).max(0.0) }
+        })
+        .filter(|q| q.r > 0.1)
+        .collect()
+}
+
+pub(super) fn mr_mercury(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let blobs = mercury_blobs(ctx, &b);
+    let influence = pr.f("blobInfluence") as f32 / 100.0;
+    let s = b.scale as f32;
+    let (w, hh) = (b.img.width, b.img.height);
+    // Field and gradient accumulate additively: [f, gx, gy, _].
+    let mut field = Image::new(w, hh);
+    let infl = 1.0 + influence;
+    raster(
+        &mut field,
+        &blobs,
+        |q| {
+            let e = q.r * 2.0 * infl;
+            Some([q.x - e, q.y - e, q.x + e, q.y + e])
+        },
+        |q, x, y| {
+            let (dx, dy) = (x - q.x, y - q.y);
+            let rr = q.r * 2.0 * infl;
+            let d2 = (dx * dx + dy * dy) / (rr * rr);
+            if d2 >= 1.0 {
+                return None;
+            }
+            let k = 1.0 - d2;
+            let f = k * k * k;
+            let g = -6.0 * k * k / (rr * rr);
+            Some([f, g * dx, g * dy, 0.0])
+        },
+        Acc::Add,
+    );
+    let thr = 0.35f32;
+    let ambient = pr.f("shading/ambient") as f32 / 100.0;
+    let diffuse = pr.f("shading/diffuse") as f32 / 100.0;
+    let specular = pr.f("shading/specular") as f32 / 100.0;
+    let rough = pr.f("shading/roughness").max(0.001) as f32;
+    let metal = pr.f("shading/metal") as f32 / 100.0;
+    let li = pr.f("light/lightIntensity") as f32 / 100.0;
+    let lc = pr.color("light/lightColor");
+    let ldir = (pr.f("light/lightDirection") as f32).to_radians();
+    let lheight = pr.f("light/lightHeight") as f32 / 100.0;
+    let l = norm3([ldir.sin(), -ldir.cos(), lheight.max(0.05)]);
+    let src = b.img.clone();
+    let mut out = Image::new(w, hh);
+    out.rows_mut().for_each(|(y, row)| {
+        for (x, px) in row.iter_mut().enumerate() {
+            let fv = field.data[y * w as usize + x];
+            let f = fv[0];
+            if f <= thr * 0.8 {
+                continue;
+            }
+            let cov = ((f - thr * 0.8) / (thr * 0.4)).clamp(0.0, 1.0);
+            let n = norm3([fv[1] * 3.0, fv[2] * 3.0, 1.0 / (1.0 + f)]);
+            // Refract the layer through the blob.
+            let sp = src.sample_bilinear_clamped(x as f64 + 0.5 - n[0] as f64 * 12.0 * s as f64, y as f64 + 0.5 - n[1] as f64 * 12.0 * s as f64);
+            let (c, sa) = unpremul(sp);
+            let base = if sa > 0.0 { c } else { [0.7, 0.7, 0.75] };
+            let nl = (n[0] * l[0] + n[1] * l[1] + n[2] * l[2]).max(0.0);
+            let hv = norm3([l[0], l[1], l[2] + 1.0]);
+            let spec = (n[0] * hv[0] + n[1] * hv[1] + n[2] * hv[2]).max(0.0).powf(1.0 / rough) * specular * li;
+            let shade = ambient + diffuse * nl * li;
+            let cc: [f32; 3] = std::array::from_fn(|k| base[k] * shade + spec * (lc[k] * (1.0 - metal) + base[k] * metal));
+            *px = [cc[0] * cov, cc[1] * cov, cc[2] * cov, cov];
+        }
+    });
+    b.img = out;
+    b
+}
diff --git a/crates/effects/src/sim/registry.rs b/crates/effects/src/sim/registry.rs
new file mode 100644
index 000000000..f55b99e27
--- /dev/null
+++ b/crates/effects/src/sim/registry.rs
@@ -0,0 +1,230 @@
+use super::common::{pct, pt, spec};
+use super::engine::{PARTICLE_TYPES, PW_ANIMS};
+use super::particle_fx::{PW_FOV, PW_TEXTURE_LAYER, mr_mercury, particle_systems2, particle_systems2_plan, particle_world, particle_world_plan};
+use super::sprites::SpritePlan;
+use super::weather::{bubbles, drizzle, rainfall, rainfall_plan, snowfall, snowfall_plan, star_burst, star_burst_plan};
+use super::{Buf, EffectCtx, EffectSpec, ParamUi, Value, col, num, p, popup, slider};
+
+/// The sprite plan of a sprite-drawing simulation effect for buffer geometry `b` (its pixels
+/// are not read), `None` for other effects or settings drawn otherwise (the GPU compositor's
+/// render pass).
+pub fn sprite_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option<SpritePlan> {
+    match id {
+        "ec.sim.ccrainfall" => Some(rainfall_plan(ctx, b)),
+        "ec.sim.ccsnowfall" => Some(snowfall_plan(ctx, b)),
+        "ec.sim.ccstarburst" => Some(star_burst_plan(ctx, b)),
+        "ec.sim.cchair" => crate::sim3::hair_plan(ctx, b),
+        "ec.sim.waveworld" => crate::sim2::wave_world_plan(ctx, b).and_then(|p| match p {
+            crate::sim2::WavePlan::Wire(sp) => Some(sp),
+            crate::sim2::WavePlan::Height { .. } => None,
+        }),
+        "ec.sim.foam" => crate::sim2::foam_plan(ctx, b),
+        "ec.sim.ccparticleworld" => particle_world_plan(ctx, b),
+        "ec.sim.ccparticlesystems2" => Some(particle_systems2_plan(ctx, b)),
+        _ => None,
+    }
+}
+
+// ------------------------------------------------------------------ specs
+
+pub fn specs() -> Vec<EffectSpec> {
+    let transfer = || popup(&["Composite", "Lighten"]);
+    vec![
+        spec(
+            "ec.sim.ccrainfall",
+            "CC Rainfall",
+            vec![
+                p("drops", "Drops", num(5000.0), slider(0.0, 100_000.0, 0.0, 20_000.0, 0)),
+                p("size", "Size", num(1.0), slider(0.0, 50.0, 0.0, 10.0, 2)),
+                p("sceneDepth", "Scene Depth", num(5000.0), slider(0.0, 20_000.0, 0.0, 10_000.0, 0)),
+                p("speed", "Speed", num(4000.0), slider(0.0, 20_000.0, 0.0, 10_000.0, 0)),
+                p("wind", "Wind", num(0.0), slider(-10_000.0, 10_000.0, -2000.0, 2000.0, 1)),
+                p("windVariation", "Variation % (Wind)", num(0.0), pct()),
+                p("spread", "Spread", num(0.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
+                p("color", "Color", col(0.8, 0.8, 0.8), ParamUi::Color),
+                p("opacity", "Opacity", num(25.0), pct()),
+                p("transferMode", "Transfer Mode", Value::Enum(1), transfer()),
+                p("compositeWithOriginal", "Composite With Original", Value::Bool(true), ParamUi::Checkbox),
+                p("extras/appearance", "Appearance", Value::Enum(0), popup(&["Refracting", "Soft Solid"])),
+                p("extras/offset", "Offset", pt(0.5, 0.5), ParamUi::Point),
+                p("extras/randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            rainfall,
+        ),
+        spec(
+            "ec.sim.ccsnowfall",
+            "CC Snowfall",
+            vec![
+                p("flakes", "Flakes", num(10_000.0), slider(0.0, 200_000.0, 0.0, 50_000.0, 0)),
+                p("size", "Size", num(3.0), slider(0.0, 50.0, 0.0, 20.0, 2)),
+                p("sizeVariation", "Variation % (Size)", num(50.0), pct()),
+                p("sceneDepth", "Scene Depth", num(5000.0), slider(0.0, 20_000.0, 0.0, 10_000.0, 0)),
+                p("speed", "Speed", num(100.0), slider(0.0, 5000.0, 0.0, 1000.0, 1)),
+                p("speedVariation", "Variation % (Speed)", num(50.0), pct()),
+                p("wind", "Wind", num(25.0), slider(-5000.0, 5000.0, -500.0, 500.0, 1)),
+                p("windVariation", "Variation % (Wind)", num(50.0), pct()),
+                p("spread", "Spread", num(0.0), slider(0.0, 1000.0, 0.0, 100.0, 1)),
+                p("wiggle/wiggleAmount", "Amount", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
+                p("wiggle/wiggleAmountVariation", "Variation % (Amount)", num(50.0), pct()),
+                p("wiggle/wiggleFrequency", "Frequency", num(1.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("wiggle/wiggleFrequencyVariation", "Variation % (Frequency)", num(50.0), pct()),
+                p("color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("opacity", "Opacity", num(100.0), pct()),
+                p("transferMode", "Transfer Mode", Value::Enum(0), transfer()),
+                p("compositeWithOriginal", "Composite With Original", Value::Bool(true), ParamUi::Checkbox),
+                p("extras/offset", "Offset", pt(0.5, 0.5), ParamUi::Point),
+                p("extras/randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            snowfall,
+        ),
+        spec(
+            "ec.sim.ccbubbles",
+            "CC Bubbles",
+            vec![
+                p("bubbleAmount", "Bubble Amount", num(100.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+                p("bubbleSpeed", "Bubble Speed", num(0.5), slider(-10.0, 10.0, -2.0, 2.0, 2)),
+                p("wobbleAmplitude", "Wobble Amplitude", num(5.0), slider(0.0, 500.0, 0.0, 100.0, 1)),
+                p("wobbleFrequency", "Wobble Frequency", num(1.0), slider(0.0, 50.0, 0.0, 10.0, 2)),
+                p("bubbleSize", "Bubble Size", num(1.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("reflectionType", "Reflection Type", Value::Enum(0), popup(&["Liquid", "Metal"])),
+                p("shadingType", "Shading Type", Value::Enum(0), popup(&["None", "Lighten", "Darken", "Fade Inwards", "Fade Outwards"])),
+            ],
+            bubbles,
+        ),
+        spec(
+            "ec.sim.ccdrizzle",
+            "CC Drizzle",
+            vec![
+                p("dripRate", "Drip Rate", num(10.0), slider(0.0, 200.0, 0.0, 50.0, 2)),
+                p("longevity", "Longevity (sec)", num(1.0), slider(0.0, 30.0, 0.0, 5.0, 2)),
+                p("rippling", "Rippling", num(360.0), ParamUi::Angle),
+                p("displacement", "Displacement", num(5.0), slider(0.0, 100.0, 0.0, 30.0, 2)),
+                p("rippleHeight", "Ripple Height", num(30.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
+                p("spreading", "Spreading", num(100.0), slider(0.0, 1000.0, 0.0, 300.0, 1)),
+                p("light/lightIntensity", "Light Intensity", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
+                p("light/lightColor", "Light Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("light/lightHeight", "Light Height", num(25.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
+                p("light/lightDirection", "Light Direction", num(-45.0), ParamUi::Angle),
+                p("shading/ambient", "Ambient", num(0.0), slider(-200.0, 200.0, -100.0, 100.0, 1)),
+                p("shading/diffuse", "Diffuse", num(0.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
+                p("shading/specular", "Specular", num(20.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
+                p("shading/roughness", "Roughness", num(0.05), slider(0.001, 1.0, 0.001, 0.5, 3)),
+            ],
+            drizzle,
+        ),
+        spec(
+            "ec.sim.ccstarburst",
+            "CC Star Burst",
+            vec![
+                p("scatter", "Scatter", num(100.0), slider(0.0, 1000.0, 0.0, 300.0, 1)),
+                p("speed", "Speed", num(1.0), slider(-10.0, 10.0, -4.0, 4.0, 2)),
+                p("phase", "Phase", num(0.0), ParamUi::Angle),
+                p("gridSpacing", "Grid Spacing", num(2.0), slider(1.0, 100.0, 1.0, 20.0, 0)),
+                p("size", "Size", num(100.0), slider(0.0, 1000.0, 0.0, 300.0, 1)),
+                p("blendWithOriginal", "Blend w. Original", num(0.0), pct()),
+            ],
+            star_burst,
+        ),
+        spec(
+            "ec.sim.ccparticleworld",
+            "CC Particle World",
+            vec![
+                p("birthRate", "Birth Rate", num(0.5), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("longevity", "Longevity (sec)", num(1.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("producer/producerX", "Position X", num(0.0), slider(-10.0, 10.0, -1.0, 1.0, 2)),
+                p("producer/producerY", "Position Y", num(0.0), slider(-10.0, 10.0, -1.0, 1.0, 2)),
+                p("producer/producerZ", "Position Z", num(0.0), slider(-10.0, 10.0, -1.0, 1.0, 2)),
+                p("producer/radiusX", "Radius X", num(0.025), slider(0.0, 10.0, 0.0, 1.0, 3)),
+                p("producer/radiusY", "Radius Y", num(0.025), slider(0.0, 10.0, 0.0, 1.0, 3)),
+                p("producer/radiusZ", "Radius Z", num(0.025), slider(0.0, 10.0, 0.0, 1.0, 3)),
+                p("physics/animation", "Animation", Value::Enum(0), popup(PW_ANIMS)),
+                p("physics/velocity", "Velocity", num(1.0), slider(-10.0, 10.0, 0.0, 5.0, 2)),
+                p("physics/inheritVelocity", "Inherit Velocity %", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
+                p("physics/gravity", "Gravity", num(0.5), slider(-10.0, 10.0, -2.0, 2.0, 3)),
+                p("physics/resistance", "Resistance", num(0.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("physics/extra", "Extra", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 2)),
+                p("physics/extraAngle", "Extra Angle", num(360.0), ParamUi::Angle),
+                p("physics/directionAxis/axisX", "Axis X", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("physics/directionAxis/axisY", "Axis Y", num(-1.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("physics/directionAxis/axisZ", "Axis Z", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("physics/gravityVector/gravityX", "Gravity X", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("physics/gravityVector/gravityY", "Gravity Y", num(1.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("physics/gravityVector/gravityZ", "Gravity Z", num(0.0), slider(-1.0, 1.0, -1.0, 1.0, 2)),
+                p("particle/particleType", "Particle Type", Value::Enum(0), popup(PARTICLE_TYPES)),
+                p(PW_TEXTURE_LAYER, "Texture Layer", Value::Layer(None), ParamUi::Layer),
+                p("particle/birthSize", "Birth Size", num(0.2), slider(0.0, 10.0, 0.0, 1.0, 3)),
+                p("particle/deathSize", "Death Size", num(0.2), slider(0.0, 10.0, 0.0, 1.0, 3)),
+                p("particle/sizeVariation", "Size Variation", num(0.0), pct()),
+                p("particle/maxOpacity", "Max Opacity", num(75.0), pct()),
+                p("particle/birthColor", "Birth Color", col(1.0, 1.0, 0.0), ParamUi::Color),
+                p("particle/deathColor", "Death Color", col(0.6, 0.0, 0.0), ParamUi::Color),
+                p("particle/transferMode", "Transfer Mode", Value::Enum(0), popup(&["Composite", "Screen", "Add", "Black Matte"])),
+                p("extras/effectCamera/distance", "Distance", num(2.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("extras/effectCamera/rotationX", "Rotation X", num(0.0), ParamUi::Angle),
+                p("extras/effectCamera/rotationY", "Rotation Y", num(0.0), ParamUi::Angle),
+                p("extras/effectCamera/rotationZ", "Rotation Z", num(0.0), ParamUi::Angle),
+                p("extras/effectCamera/fov", "FOV", num(PW_FOV), slider(1.0, 179.0, 10.0, 120.0, 1)),
+                p("extras/randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            particle_world,
+        ),
+        spec(
+            "ec.sim.ccparticlesystems2",
+            "CC Particle Systems II",
+            vec![
+                p("birthRate", "Birth Rate", num(2.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
+                p("longevity", "Longevity (sec)", num(1.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("producer/position", "Position", pt(0.5, 0.5), ParamUi::Point),
+                p("producer/radiusX", "Radius X", num(0.0), slider(0.0, 2000.0, 0.0, 200.0, 1)),
+                p("producer/radiusY", "Radius Y", num(0.0), slider(0.0, 2000.0, 0.0, 200.0, 1)),
+                p("physics/animation", "Animation", Value::Enum(0), popup(PW_ANIMS)),
+                p("physics/velocity", "Velocity", num(2.0), slider(-20.0, 20.0, 0.0, 10.0, 2)),
+                p("physics/inheritVelocity", "Inherit Velocity %", num(0.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
+                p("physics/gravity", "Gravity", num(1.0), slider(-20.0, 20.0, -5.0, 5.0, 2)),
+                p("physics/resistance", "Resistance", num(0.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("physics/direction", "Direction", num(0.0), ParamUi::Angle),
+                p("physics/extra", "Extra", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 2)),
+                p("particle/particleType", "Particle Type", Value::Enum(0), popup(PARTICLE_TYPES)),
+                p("particle/birthSize", "Birth Size", num(0.5), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("particle/deathSize", "Death Size", num(1.5), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("particle/sizeVariation", "Size Variation", num(0.0), pct()),
+                p("particle/maxOpacity", "Max Opacity", num(75.0), pct()),
+                p("particle/birthColor", "Birth Color", col(1.0, 1.0, 0.0), ParamUi::Color),
+                p("particle/deathColor", "Death Color", col(0.6, 0.0, 0.0), ParamUi::Color),
+                p("particle/transferMode", "Transfer Mode", Value::Enum(0), popup(&["Composite", "Screen", "Add", "Black Matte"])),
+                p("randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            particle_systems2,
+        ),
+        spec(
+            "ec.sim.ccmrmercury",
+            "CC Mr. Mercury",
+            vec![
+                p("radiusX", "Radius X", num(50.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
+                p("radiusY", "Radius Y", num(50.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
+                p("producer", "Producer", pt(0.5, 0.5), ParamUi::Point),
+                p("direction", "Direction", num(0.0), ParamUi::Angle),
+                p("velocity", "Velocity", num(1.0), slider(-20.0, 20.0, 0.0, 5.0, 2)),
+                p("birthRate", "Birth Rate", num(1.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("longevity", "Longevity (sec)", num(2.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("gravity", "Gravity", num(0.5), slider(-20.0, 20.0, -5.0, 5.0, 2)),
+                p("resistance", "Resistance", num(0.0), slider(0.0, 20.0, 0.0, 5.0, 2)),
+                p("extra", "Extra", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 2)),
+                p("animation", "Animation", Value::Enum(0), popup(PW_ANIMS)),
+                p("blobInfluence", "Blob Influence", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
+                p("blobBirthSize", "Blob Birth Size", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 2)),
+                p("blobDeathSize", "Blob Death Size", num(0.25), slider(0.0, 10.0, 0.0, 2.0, 2)),
+                p("light/lightIntensity", "Light Intensity", num(100.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
+                p("light/lightColor", "Light Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("light/lightHeight", "Light Height", num(50.0), slider(-100.0, 100.0, -100.0, 100.0, 1)),
+                p("light/lightDirection", "Light Direction", num(-45.0), ParamUi::Angle),
+                p("shading/ambient", "Ambient", num(0.0), slider(-200.0, 200.0, -100.0, 100.0, 1)),
+                p("shading/diffuse", "Diffuse", num(75.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
+                p("shading/specular", "Specular", num(50.0), slider(0.0, 200.0, 0.0, 100.0, 1)),
+                p("shading/roughness", "Roughness", num(0.05), slider(0.001, 1.0, 0.001, 0.5, 3)),
+                p("shading/metal", "Metal", num(100.0), pct()),
+            ],
+            mr_mercury,
+        ),
+    ]
+}
diff --git a/crates/effects/src/sim/sprites.rs b/crates/effects/src/sim/sprites.rs
new file mode 100644
index 000000000..55ba594b4
--- /dev/null
+++ b/crates/effects/src/sim/sprites.rs
@@ -0,0 +1,361 @@
+use super::{Buf, Image, IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelIterator, ParallelSliceMut, Px, unpremul};
+
+// ------------------------------------------------------------------ band rasteriser
+
+const BAND: usize = 16;
+
+/// How rasterised items combine with what is already in the target.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Acc {
+    /// Premultiplied "over" (later items on top).
+    Over,
+    /// Additive (glows, light).
+    Add,
+}
+
+/// Rasterise many small items into `img` (buffer pixels). `bbox` gives an item's pixel bounds
+/// `[x0, y0, x1, y1]` (or `None` to skip), `shade` its premultiplied colour at a pixel centre.
+/// Items are bucketed into horizontal bands rendered in parallel; within a band they are drawn
+/// in slice order.
+pub(crate) fn raster<T: Sync>(
+    img: &mut Image,
+    items: &[T],
+    bbox: impl Fn(&T) -> Option<[f32; 4]> + Sync,
+    shade: impl Fn(&T, f32, f32) -> Option<Px> + Sync,
+    acc: Acc,
+) {
+    let (w, hgt) = (img.width as usize, img.height as usize);
+    if w == 0 || hgt == 0 || items.is_empty() {
+        return;
+    }
+    let nb = hgt.div_ceil(BAND);
+    let boxes: Vec<Option<[i32; 4]>> = items
+        .par_iter()
+        .map(|it| {
+            let b = bbox(it)?;
+            if !(b[0].is_finite() && b[1].is_finite() && b[2].is_finite() && b[3].is_finite()) {
+                return None;
+            }
+            let x0 = b[0].floor().max(0.0) as i32;
+            let y0 = b[1].floor().max(0.0) as i32;
+            let x1 = (b[2].ceil() as i32).min(w as i32 - 1);
+            let y1 = (b[3].ceil() as i32).min(hgt as i32 - 1);
+            if x1 < x0 || y1 < y0 || b[2] < 0.0 || b[3] < 0.0 {
+                return None;
+            }
+            Some([x0, y0, x1, y1])
+        })
+        .collect();
+    let mut buckets: Vec<Vec<u32>> = vec![Vec::new(); nb];
+    for (i, b) in boxes.iter().enumerate() {
+        if let Some(b) = b {
+            for band in (b[1] as usize / BAND)..=(b[3] as usize / BAND).min(nb - 1) {
+                buckets[band].push(i as u32);
+            }
+        }
+    }
+    img.data.par_chunks_mut(w * BAND).enumerate().for_each(|(band, chunk)| {
+        let by0 = band * BAND;
+        let rows = chunk.len() / w;
+        for &i in &buckets[band] {
+            let Some(b) = boxes[i as usize] else { continue };
+            let it = &items[i as usize];
+            let ya = (b[1] as usize).max(by0);
+            let yb = (b[3] as usize).min(by0 + rows - 1);
+            for y in ya..=yb {
+                let row = &mut chunk[(y - by0) * w..(y - by0 + 1) * w];
+                for x in b[0] as usize..=b[2] as usize {
+                    if let Some(c) = shade(it, x as f32 + 0.5, y as f32 + 0.5) {
+                        let d = &mut row[x];
+                        match acc {
+                            Acc::Over => {
+                                let k = 1.0 - c[3];
+                                *d = [c[0] + d[0] * k, c[1] + d[1] * k, c[2] + d[2] * k, c[3] + d[3] * k];
+                            }
+                            Acc::Add => {
+                                *d = [d[0] + c[0], d[1] + c[1], d[2] + c[2], (d[3] + c[3]).min(1.0)];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    });
+}
+
+// ------------------------------------------------------------------ sprites
+
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub enum Shape {
+    /// Soft round dot (Gaussian-like falloff).
+    Soft,
+    /// Hard anti-aliased disc.
+    Disc,
+    /// Lit sphere (upper-left light, specular).
+    Sphere,
+    /// Disc fading linearly to its rim.
+    Faded,
+    /// Thin ring with a highlight.
+    Bubble,
+    /// Four-point star.
+    Star,
+    /// Rotated square (angle in `rot`).
+    Square,
+    /// Triangle (angle in `rot`).
+    Tri,
+    /// Segment from (x, y) by (dx, dy), half-width `r`.
+    Line { dx: f32, dy: f32 },
+}
+
+/// A particle sprite in buffer pixels; `c` is straight colour + opacity.
+#[derive(Clone, Copy, Debug)]
+pub struct Sprite {
+    pub x: f32,
+    pub y: f32,
+    pub r: f32,
+    pub c: [f32; 4],
+    pub shape: Shape,
+    pub rot: f32,
+}
+
+impl Sprite {
+    pub(crate) fn new(x: f32, y: f32, r: f32, c: [f32; 4], shape: Shape) -> Sprite {
+        Sprite { x, y, r, c, shape, rot: 0.0 }
+    }
+}
+
+/// Where a sprite's colour comes from when it depends on the layer's pixels (resolved by
+/// [`SpritePlan::resolve`] on the CPU, per pixel by the GPU compositor). Positions are buffer
+/// pixels.
+#[derive(Clone, Copy, Debug)]
+pub enum Tint {
+    /// The sprite's own colour.
+    Fixed,
+    /// CC Rainfall's refracting drops: where the layer shows (alpha > 0), colour × (layer
+    /// colour × 0.6 + 0.5) sampled at (x, y).
+    Refract { x: f64, y: f64 },
+    /// CC Star Burst: the layer's colour at (x, y), opacity × its alpha (none where clear).
+    Source { x: f64, y: f64 },
+    /// CC Hair: the root's colour at (x, y) mixed with the hair colour (`inherit` = 1 keeps the
+    /// root's), × `shade`, + `spec`; no strand where the root's alpha is below ½.
+    Root { x: f64, y: f64, hair: [f32; 3], inherit: f32, shade: f32, spec: f32 },
+}
+
+/// How a sprite layer meets the original layer.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Post {
+    /// `combine` with this mode (0 Composite … 5 sprites only).
+    Combine(u32),
+    /// The sprites alone.
+    Replace,
+    /// The sprites, mixed toward the original by this fraction.
+    Lerp(f32),
+    /// The sprites over opaque black.
+    OverBlack,
+}
+
+/// What a sprite-drawing effect draws this frame: built on the CPU (closed-form or from the
+/// simulation state), rasterised by [`SpritePlan::finish`] or the GPU compositor.
+#[derive(Clone, Debug)]
+pub struct SpritePlan {
+    pub sprites: Vec<Sprite>,
+    /// Per sprite (empty = all [`Tint::Fixed`]).
+    pub tints: Vec<Tint>,
+    pub acc: Acc,
+    pub post: Post,
+}
+
+impl SpritePlan {
+    /// Resolve layer-dependent colours against the layer `src`.
+    pub fn resolve(&mut self, src: &Image) {
+        let tints = std::mem::take(&mut self.tints);
+        self.sprites.par_iter_mut().zip(tints.par_iter()).for_each(|(sp, t)| match *t {
+            Tint::Fixed => {}
+            Tint::Refract { x, y } => {
+                let (sc, sa) = unpremul(src.sample_bilinear(x, y));
+                if sa > 0.0 {
+                    let c = sp.c;
+                    sp.c = [(sc[0] * 0.6 + 0.5) * c[0], (sc[1] * 0.6 + 0.5) * c[1], (sc[2] * 0.6 + 0.5) * c[2], c[3]];
+                }
+            }
+            Tint::Source { x, y } => {
+                let (c, a) = unpremul(src.sample_bilinear(x, y));
+                sp.c = if a <= 0.0 { [0.0; 4] } else { [c[0], c[1], c[2], a * sp.c[3]] };
+            }
+            Tint::Root { x, y, hair, inherit, shade, spec } => {
+                let root = src.sample_bilinear(x, y);
+                if root[3] < 0.5 {
+                    sp.c = [0.0; 4];
+                    return;
+                }
+                let (rc, _) = unpremul(root);
+                let base: [f32; 3] = std::array::from_fn(|k| rc[k] + (hair[k] - rc[k]) * (1.0 - inherit));
+                sp.c = [base[0] * shade + spec, base[1] * shade + spec, base[2] * shade + spec, sp.c[3]];
+            }
+        });
+    }
+
+    /// Rasterise (after [`SpritePlan::resolve`]) and meet the original layer `b`.
+    pub fn finish(&self, b: Buf) -> Buf {
+        let fx = splat(b.img.width, b.img.height, &self.sprites, self.acc);
+        self.finish_with(b, fx)
+    }
+
+    /// [`finish`](Self::finish) with a prepared sprite image (the motion-blurred average of
+    /// several frames, #1195).
+    pub fn finish_with(&self, b: Buf, fx: Image) -> Buf {
+        self.post.apply(b, fx)
+    }
+}
+
+impl Post {
+    /// Meet the sprite image `fx` with the original layer `b` (see [`SpritePlan::finish`]).
+    pub(super) fn apply(self, mut b: Buf, fx: Image) -> Buf {
+        b.img = match self {
+            Post::Combine(m) => combine(&b.img, &fx, m),
+            Post::Replace => fx,
+            Post::Lerp(t) => {
+                let mut o = fx;
+                o.data.par_iter_mut().zip(b.img.data.par_iter()).for_each(|(o, s0)| *o = crate::util::lerp4(*o, *s0, t));
+                o
+            }
+            Post::OverBlack => combine(&Image::filled(b.img.width, b.img.height, [0.0, 0.0, 0.0, 1.0]), &fx, 0),
+        };
+        b
+    }
+}
+
+pub(super) fn sprite_bbox(s: &Sprite) -> Option<[f32; 4]> {
+    if s.c[3] <= 1e-5 || s.r <= 0.0 {
+        return None;
+    }
+    let r = s.r.max(0.5) + 1.0;
+    Some(match s.shape {
+        Shape::Line { dx, dy } => [s.x.min(s.x + dx) - r, s.y.min(s.y + dy) - r, s.x.max(s.x + dx) + r, s.y.max(s.y + dy) + r],
+        Shape::Star => [s.x - r * 2.0, s.y - r * 2.0, s.x + r * 2.0, s.y + r * 2.0],
+        _ => [s.x - r, s.y - r, s.x + r, s.y + r],
+    })
+}
+
+#[inline]
+pub(super) fn aa(edge: f32) -> f32 {
+    (edge + 0.5).clamp(0.0, 1.0)
+}
+
+fn sprite_shade(s: &Sprite, x: f32, y: f32) -> Option<Px> {
+    // Sub-pixel sprites keep their energy: draw at radius 0.5 with reduced opacity.
+    let (r, fade) = if s.r < 0.5 { (0.5, s.r / 0.5) } else { (s.r, 1.0) };
+    let (dx, dy) = (x - s.x, y - s.y);
+    let mut rgb = [s.c[0], s.c[1], s.c[2]];
+    let cov = match s.shape {
+        Shape::Soft => {
+            let d2 = (dx * dx + dy * dy) / (r * r);
+            if d2 >= 1.0 {
+                return None;
+            }
+            let q = 1.0 - d2;
+            q * q
+        }
+        Shape::Disc => aa(r - (dx * dx + dy * dy).sqrt()),
+        Shape::Faded => {
+            let d = (dx * dx + dy * dy).sqrt() / r;
+            (1.0 - d).max(0.0).powf(1.5)
+        }
+        Shape::Sphere => {
+            let d = (dx * dx + dy * dy).sqrt();
+            let cv = aa(r - d);
+            if cv <= 0.0 {
+                return None;
+            }
+            let (nx, ny) = (dx / r, dy / r);
+            let nz = (1.0 - nx * nx - ny * ny).max(0.0).sqrt();
+            let (lx, ly, lz) = (-0.48, -0.58, 0.66);
+            let diff = (nx * lx + ny * ly + nz * lz).max(0.0);
+            let rz = 2.0 * diff * nz - lz;
+            let spec = rz.max(0.0).powi(20) * 0.6;
+            let k = 0.2 + 0.8 * diff;
+            rgb = [rgb[0] * k + spec, rgb[1] * k + spec, rgb[2] * k + spec];
+            cv
+        }
+        Shape::Bubble => {
+            let d = (dx * dx + dy * dy).sqrt() / r;
+            if d > 1.0 + 1.0 / r {
+                return None;
+            }
+            let ring = (1.0 - ((d - 0.9) / 0.12).powi(2)).max(0.0);
+            let hl = (1.0 - (((dx / r) + 0.4).powi(2) + ((dy / r) + 0.4).powi(2)) / 0.04).max(0.0);
+            (0.12 * (d <= 1.0) as u8 as f32 + ring * 0.8 + hl).min(1.0)
+        }
+        Shape::Star => {
+            let (sn, cs) = s.rot.sin_cos();
+            let (ux, uy) = ((dx * cs + dy * sn) / r, (-dx * sn + dy * cs) / r);
+            let d = (ux * ux + uy * uy).sqrt();
+            let core = (1.0 - d).max(0.0).powi(2);
+            let sx = (1.0 - ux.abs() / 2.0).max(0.0) * (1.0 - (uy.abs() * 6.0)).max(0.0);
+            let sy = (1.0 - uy.abs() / 2.0).max(0.0) * (1.0 - (ux.abs() * 6.0)).max(0.0);
+            (core + sx + sy).min(1.0)
+        }
+        Shape::Square => {
+            let (sn, cs) = s.rot.sin_cos();
+            let (ux, uy) = (dx * cs + dy * sn, -dx * sn + dy * cs);
+            let e = r * 0.75;
+            aa(e - ux.abs()) * aa(e - uy.abs())
+        }
+        Shape::Tri => {
+            let (sn, cs) = s.rot.sin_cos();
+            let (ux, uy) = (dx * cs + dy * sn, -dx * sn + dy * cs);
+            // Equilateral triangle with circumradius r: three half-planes.
+            let e = r * 0.5;
+            let mut m = f32::INFINITY;
+            for k in 0..3 {
+                let a = std::f32::consts::FRAC_PI_2 + k as f32 * std::f32::consts::TAU / 3.0;
+                let (ns, nc) = a.sin_cos();
+                m = m.min(e - (ux * nc + uy * ns));
+            }
+            aa(m)
+        }
+        Shape::Line { dx: lx, dy: ly } => {
+            let l2 = lx * lx + ly * ly;
+            let t = if l2 > 0.0 { ((dx * lx + dy * ly) / l2).clamp(0.0, 1.0) } else { 0.0 };
+            let (px, py) = (dx - lx * t, dy - ly * t);
+            aa(r - (px * px + py * py).sqrt())
+        }
+    };
+    let a = cov * s.c[3] * fade;
+    if a <= 1e-6 {
+        return None;
+    }
+    Some([rgb[0] * a, rgb[1] * a, rgb[2] * a, a])
+}
+
+/// Draw sprites into a new transparent image of `w`×`h`.
+pub(crate) fn splat(w: u32, hgt: u32, sprites: &[Sprite], acc: Acc) -> Image {
+    let mut img = Image::new(w, hgt);
+    raster(&mut img, sprites, sprite_bbox, sprite_shade, acc);
+    img
+}
+
+/// Combine an effect layer `fx` with the original `src` (both premultiplied, same size):
+/// 0 Composite (fx over src), 1 Screen, 2 Add, 3 Lighten, 4 Darken, 5 fx only.
+pub(crate) fn combine(src: &Image, fx: &Image, mode: u32) -> Image {
+    let mut out = fx.clone();
+    out.data.par_iter_mut().zip(src.data.par_iter()).for_each(|(o, s)| {
+        let f = *o;
+        *o = match mode {
+            0 => {
+                let k = 1.0 - f[3];
+                [f[0] + s[0] * k, f[1] + s[1] * k, f[2] + s[2] * k, f[3] + s[3] * k]
+            }
+            1 => [s[0] + f[0] - s[0] * f[0], s[1] + f[1] - s[1] * f[1], s[2] + f[2] - s[2] * f[2], s[3] + f[3] - s[3] * f[3]],
+            2 => [s[0] + f[0], s[1] + f[1], s[2] + f[2], (s[3] + f[3]).min(1.0)],
+            3 => [s[0].max(f[0]), s[1].max(f[1]), s[2].max(f[2]), s[3] + f[3] - s[3] * f[3]],
+            4 => {
+                let (fc, fa) = unpremul(f);
+                let m = |c: f32, k: usize| c - (c - c.min(fc[k] * s[3])) * fa;
+                [m(s[0], 0), m(s[1], 1), m(s[2], 2), s[3]]
+            }
+            _ => f,
+        };
+    });
+    out
+}
diff --git a/crates/effects/src/sim/tests.rs b/crates/effects/src/sim/tests.rs
new file mode 100644
index 000000000..4c708dae4
--- /dev/null
+++ b/crates/effects/src/sim/tests.rs
@@ -0,0 +1,828 @@
+use super::*;
+use crate::{EffectEnv, run_fx};
+
+fn grey(w: u32, hh: u32) -> Image {
+    Image::filled(w, hh, [0.2, 0.2, 0.2, 1.0])
+}
+
+fn ramp(w: u32, hh: u32) -> Image {
+    let mut img = Image::new(w, hh);
+    for y in 0..hh {
+        for x in 0..w {
+            img.set(x, y, [x as f32 / w as f32, y as f32 / hh as f32, 0.4, 1.0]);
+        }
+    }
+    img
+}
+
+fn run(id: &str, vals: &[(&str, Value)], img: Image, t: f64) -> Image {
+    run_fx(id, vals, img, t, EffectEnv::default()).img
+}
+
+fn diff(a: &Image, b: &Image) -> f32 {
+    a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|k| (p[k] - q[k]).abs()).sum::<f32>()).sum()
+}
+
+/// Centre of mass (luminance-weighted difference from `base`), `[-1, -1]` when equal.
+fn mass(img: &Image, base: &Image) -> [f32; 2] {
+    let (mut m, mut sx, mut sy) = (0.0, 0.0, 0.0);
+    for y in 0..img.height {
+        for x in 0..img.width {
+            let i = img.idx(x, y);
+            let d: f32 = (0..3).map(|k| (img.data[i][k] - base.data[i][k]).abs()).sum();
+            m += d;
+            sx += d * x as f32;
+            sy += d * y as f32;
+        }
+    }
+    if m > 0.0 { [sx / m, sy / m] } else { [-1.0; 2] }
+}
+
+/// [`mass`] in y.
+fn mass_y(img: &Image, base: &Image) -> f32 {
+    mass(img, base)[1]
+}
+
+#[test]
+fn rasteriser_over_and_add() {
+    let s = [Sprite::new(5.0, 5.0, 2.0, [1.0, 0.0, 0.0, 1.0], Shape::Disc)];
+    let img = splat(10, 40, &s, Acc::Over);
+    assert!(img.get(5, 5)[0] > 0.99 && img.get(9, 30)[3] == 0.0);
+    let two = [s[0], s[0]];
+    let add = splat(10, 40, &two, Acc::Add);
+    assert!(add.get(5, 5)[0] > 1.9);
+    // Items spanning band boundaries are drawn in every band.
+    let tall = [Sprite::new(5.0, 16.0, 6.0, [0.0, 1.0, 0.0, 1.0], Shape::Square)];
+    let t = splat(10, 40, &tall, Acc::Over);
+    assert!(t.get(5, 13)[1] > 0.9 && t.get(5, 18)[1] > 0.9);
+}
+
+#[test]
+fn rainfall_deterministic_and_falls() {
+    let vals = [("drops", num(200.0)), ("opacity", num(100.0)), ("extras/appearance", Value::Enum(1)), ("color", col(1.0, 1.0, 1.0))];
+    let a = run("ec.sim.ccrainfall", &vals, grey(40, 40), 0.5);
+    let b = run("ec.sim.ccrainfall", &vals, grey(40, 40), 0.5);
+    assert_eq!(a, b);
+    assert!(diff(&a, &grey(40, 40)) > 1.0, "drops visible");
+    let none = run("ec.sim.ccrainfall", &[("drops", num(0.0))], grey(40, 40), 0.5);
+    assert_eq!(none, grey(40, 40));
+    let later = run("ec.sim.ccrainfall", &vals, grey(40, 40), 0.52);
+    assert!(diff(&a, &later) > 0.1, "rain moves");
+}
+
+#[test]
+fn snowfall_deterministic_and_moves() {
+    let vals = [("flakes", num(300.0))];
+    let a = run("ec.sim.ccsnowfall", &vals, grey(40, 40), 1.0);
+    assert_eq!(a, run("ec.sim.ccsnowfall", &vals, grey(40, 40), 1.0));
+    assert!(diff(&a, &grey(40, 40)) > 1.0);
+    assert!(diff(&a, &run("ec.sim.ccsnowfall", &vals, grey(40, 40), 1.2)) > 0.1);
+    let off = run("ec.sim.ccsnowfall", &[("flakes", num(300.0)), ("compositeWithOriginal", Value::Bool(false))], grey(40, 40), 1.0);
+    assert!(off.data.iter().any(|p| p[3] == 0.0), "without original the background is transparent");
+}
+
+#[test]
+fn bubbles_rise() {
+    let vals = [("bubbleAmount", num(30.0)), ("bubbleSize", num(3.0))];
+    let a = run("ec.sim.ccbubbles", &vals, ramp(40, 40), 0.3);
+    assert_eq!(a, run("ec.sim.ccbubbles", &vals, ramp(40, 40), 0.3));
+    assert!(a.data.iter().any(|p| p[3] > 0.5));
+    let none = run("ec.sim.ccbubbles", &[("bubbleAmount", num(0.0))], ramp(40, 40), 0.3);
+    assert!(none.data.iter().all(|p| p[3] == 0.0), "bubbles replace the layer");
+    // A single slow bubble moves up over a short time.
+    let one = [("bubbleAmount", num(1.0)), ("bubbleSize", num(4.0)), ("wobbleAmplitude", num(0.0)), ("bubbleSpeed", num(0.2))];
+    let blank = Image::new(40, 40);
+    let y0 = mass_y(&run("ec.sim.ccbubbles", &one, ramp(40, 40), 0.0), &blank);
+    let y1 = mass_y(&run("ec.sim.ccbubbles", &one, ramp(40, 40), 0.1), &blank);
+    assert!(y0 >= 0.0 && y1 >= 0.0 && (y1 < y0 || y0 < 8.0), "{y0} -> {y1}");
+}
+
+/// #2024: bubbles near the layer's edges show its edge pixels, not the pale colour that stands
+/// in for transparent ones.
+#[test]
+fn bubbles_near_edges_show_the_layer() {
+    let blue = Image::filled(40, 40, [0.0, 0.0, 1.0, 1.0]);
+    let pale = [0, 1].map(|reflection| {
+        let vals = [("bubbleAmount", num(200.0)), ("bubbleSize", num(3.0)), ("reflectionType", Value::Enum(reflection))];
+        let a = run("ec.sim.ccbubbles", &vals, blue.clone(), 0.3);
+        assert!(a.data.iter().any(|p| p[3] > 0.5), "bubbles drawn");
+        // Blue plus the white highlight keeps blue − red = alpha; the pale colour leaves 0.2 · alpha.
+        a.data.iter().filter(|p| (p[2] - p[0] - p[3]).abs() > 1e-4).count()
+    });
+    assert_eq!(pale, [0, 0], "pale bubble pixels (liquid, metal)");
+}
+
+/// CC Bubbles on a 40 × 40 layer `img` at `scale`, in a buffer padded by 6 transparent pixels
+/// (a half-resolution preview's layout).
+fn padded_bubbles(img: Image, scale: f64, reflection: u32) -> Image {
+    let size = 40.0;
+    let s = crate::find("ec.sim.ccbubbles").unwrap();
+    let mut params = crate::Params { values: s.params.iter().map(|p| (p.id.to_string(), crate::default_value(p, [size; 2]))).collect() };
+    for (k, v) in [("bubbleAmount", num(200.0)), ("bubbleSize", num(3.0)), ("reflectionType", Value::Enum(reflection))] {
+        params.values.insert(k.into(), v);
+    }
+    let ctx = EffectCtx { params: &params, time: 0.3, layer_size: [size; 2], seed: 1, adjustment: false, env: EffectEnv::default() };
+    let mut b = Buf { img, offset: [0.0; 2], scale };
+    b.pad(6);
+    crate::apply(s, &ctx, b).img
+}
+
+/// #2024: the same when the buffer has transparent padding around the layer: samples past the
+/// layer's edges repeat its edge pixels, not the padding, and a clear hole inside the layer is
+/// still refracted as the pale colour.
+#[test]
+fn bubbles_near_padded_edges_show_the_layer() {
+    let blue = |side| Image::filled(side, side, [0.0, 0.0, 1.0, 1.0]);
+    let pale = |img: &Image| img.data.iter().filter(|p| (p[2] - p[0] - p[3]).abs() > 1e-4).count();
+    for (scale, side) in [(1.0, 40), (0.5, 20)] {
+        let counts = [0, 1].map(|reflection| {
+            let a = padded_bubbles(blue(side), scale, reflection);
+            assert!(a.data.iter().any(|p| p[3] > 0.5), "bubbles drawn");
+            pale(&a)
+        });
+        assert_eq!(counts, [0, 0], "pale bubble pixels at scale {scale} (liquid, metal)");
+    }
+    let mut holed = blue(40);
+    for y in 12..28 {
+        for x in 12..28 {
+            holed.set(x, y, [0.0; 4]);
+        }
+    }
+    assert!(pale(&padded_bubbles(holed, 1.0, 0)) > 0, "the hole refracts as the pale colour");
+}
+
+#[test]
+fn drizzle_ripples() {
+    let a = run("ec.sim.ccdrizzle", &[], ramp(48, 48), 0.6);
+    assert_eq!(a, run("ec.sim.ccdrizzle", &[], ramp(48, 48), 0.6));
+    assert!(diff(&a, &ramp(48, 48)) > 0.1);
+    let none = run("ec.sim.ccdrizzle", &[("dripRate", num(0.0))], ramp(48, 48), 0.6);
+    assert_eq!(none, ramp(48, 48));
+}
+
+#[test]
+fn star_burst_moves_stars() {
+    let a = run("ec.sim.ccstarburst", &[("gridSpacing", num(4.0))], ramp(40, 40), 0.5);
+    assert_eq!(a, run("ec.sim.ccstarburst", &[("gridSpacing", num(4.0))], ramp(40, 40), 0.5));
+    assert!(a.data.iter().any(|p| p[3] > 0.0));
+    let b = run("ec.sim.ccstarburst", &[("gridSpacing", num(4.0))], ramp(40, 40), 0.9);
+    assert!(diff(&a, &b) > 0.5);
+    let full = run("ec.sim.ccstarburst", &[("blendWithOriginal", num(100.0))], ramp(40, 40), 0.5);
+    assert!(diff(&full, &ramp(40, 40)) < 1e-3);
+}
+
+fn pw_vals(seed: f64) -> Vec<(&'static str, Value)> {
+    vec![
+        ("birthRate", num(1.0)),
+        ("extras/randomSeed", num(seed)),
+        ("particle/particleType", Value::Enum(2)),
+        ("particle/birthSize", num(0.3)),
+        ("particle/deathSize", num(0.3)),
+    ]
+}
+
+/// #1195: with the comp's shutter open, the particles smear across it: the average of the
+/// sampled sprite fields differs from the sharp frame, touches more pixels and keeps the
+/// alpha energy.
+#[test]
+fn particle_world_motion_blur_trails() {
+    let v = pw_vals(21.0);
+    let blank = Image::new(40, 40);
+    let sharp = run("ec.sim.ccparticleworld", &v, blank.clone(), 2.0);
+    let blurred = crate::run_fx(
+        "ec.sim.ccparticleworld",
+        &v,
+        blank.clone(),
+        2.0,
+        EffectEnv { frame_rate: 10.0, shutter: Some((360.0, -180.0, 8)), ..Default::default() },
+    )
+    .img;
+    assert!(sharp.data.iter().any(|p| p[3] > 0.0), "sharp frame has particles");
+    assert_ne!(sharp.data, blurred.data, "the shutter smears the particles");
+    let lit = |img: &Image| img.data.iter().filter(|p| p[3] > 0.005).count();
+    let sum = |img: &Image| img.data.iter().map(|p| p[3]).sum::<f32>();
+    assert!(lit(&blurred) > lit(&sharp), "trails light more pixels: {} vs {}", lit(&blurred), lit(&sharp));
+    let (sa, ba) = (sum(&sharp), sum(&blurred));
+    assert!((ba - sa).abs() < sa * 0.6 + 1.0, "alpha energy roughly kept: {ba} vs {sa}");
+}
+
+#[test]
+fn particle_world_seek_consistent() {
+    let v = pw_vals(11.0);
+    let direct = run("ec.sim.ccparticleworld", &v, Image::new(40, 40), 2.0);
+    let v2 = pw_vals(12.0);
+    let _ = run("ec.sim.ccparticleworld", &v2, Image::new(40, 40), 1.0);
+    let stepped = run("ec.sim.ccparticleworld", &v2, Image::new(40, 40), 2.0);
+    let direct2 = run("ec.sim.ccparticleworld", &v2, Image::new(40, 40), 2.0);
+    assert_eq!(stepped, direct2);
+    assert!(direct.data.iter().any(|p| p[3] > 0.0), "particles alive");
+    // Before birth nothing is drawn.
+    let t0 = run("ec.sim.ccparticleworld", &v, Image::new(40, 40), 0.0);
+    assert!(t0.data.iter().all(|p| p[3] == 0.0));
+}
+
+#[test]
+fn engine_resume_equals_from_scratch() {
+    for anim in 0..PW_ANIMS.len() as u32 {
+        let phys = Phys {
+            rate: 90.0,
+            life: 1.5,
+            producer: [0.0; 3],
+            radius: [0.05; 3],
+            anim,
+            speed: 0.5,
+            gravity: [0.0, 0.5, 0.0],
+            resistance: 0.2,
+            axis: [0.0, -1.0, 0.0],
+            extra: 1.0,
+            extra_angle: 60.0,
+            seed: 9,
+            max: 10_000,
+            flat: anim % 2 == 0,
+        };
+        let a: SimCache<PState> = SimCache::new(2);
+        let b: SimCache<PState> = SimCache::new(2);
+        let direct = simulate(&a, 1, 2.0, &phys);
+        let _ = simulate(&b, 1, 1.0, &phys);
+        let _ = simulate(&b, 1, 0.37, &phys);
+        let resumed = simulate(&b, 1, 2.0, &phys);
+        assert_eq!(direct.parts.len(), resumed.parts.len(), "anim {anim}");
+        assert!(direct.parts.iter().zip(&resumed.parts).all(|(p, q)| p.p == q.p && p.v == q.v && p.id == q.id), "anim {anim}");
+        assert!(!direct.parts.is_empty());
+    }
+}
+
+#[test]
+fn particle_world_gravity_pulls_down() {
+    let base = |g: f64| {
+        vec![
+            ("birthRate", num(2.0)),
+            ("physics/velocity", num(0.2)),
+            ("physics/gravity", num(g)),
+            ("particle/particleType", Value::Enum(2)),
+            ("particle/birthSize", num(0.2)),
+            ("particle/deathSize", num(0.2)),
+            ("longevity", num(3.0)),
+        ]
+    };
+    let blank = Image::new(48, 48);
+    let up = mass_y(&run("ec.sim.ccparticleworld", &base(0.0), blank.clone(), 1.0), &blank);
+    let down = mass_y(&run("ec.sim.ccparticleworld", &base(2.0), blank.clone(), 1.0), &blank);
+    assert!(down > up + 2.0, "{up} {down}");
+}
+
+/// A comp whose camera is `camera` ([`crate::CompScene::camera`]); `layer`: a camera layer
+/// (else the comp's default view).
+struct Comp {
+    camera: [[f64; 4]; 3],
+    layer: bool,
+}
+impl crate::EffectHost for Comp {
+    fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
+        None
+    }
+    fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+        None
+    }
+    fn comp_scene(&self) -> Option<crate::CompScene> {
+        Some(crate::CompScene { camera: Some(self.camera), camera_layer: self.layer, light: None })
+    }
+}
+
+/// A camera `d` px in front of layer point `c` looking at it, moved right by `dx` px and
+/// zoomed by `zoom` (1 = identity on the layer plane): `c + zoom·d·(p − c − dx) / (z + d)`.
+fn cam(c: [f64; 2], d: f64, dx: f64, zoom: f64) -> [[f64; 4]; 3] {
+    let k = zoom * d;
+    [[k, 0.0, c[0], d * c[0] - k * (c[0] + dx)], [0.0, k, c[1], d * c[1] - k * c[1]], [0.0, 0.0, 1.0, d]]
+}
+
+fn pw_in(comp: &Comp, vals: &[(&str, Value)]) -> Image {
+    run_fx("ec.sim.ccparticleworld", vals, Image::new(48, 48), 1.0, EffectEnv { host: Some(comp), ..Default::default() }).img
+}
+
+fn finite(img: &Image) -> bool {
+    img.data.iter().all(|p| p.iter().all(|c| c.is_finite()))
+}
+
+/// #397: with a camera layer in the comp, the particles are seen through it.
+#[test]
+fn particle_world_follows_the_comp_camera() {
+    let v = pw_vals(3.0);
+    let blank = Image::new(48, 48);
+    let here = Comp { camera: cam([24.0, 24.0], 96.0, 0.0, 1.0), layer: true };
+    let base = pw_in(&here, &v);
+    assert!(base.data.iter().any(|p| p[3] > 0.0), "particles alive");
+    // Moving the camera right moves the particles left.
+    let moved = pw_in(&Comp { camera: cam([24.0, 24.0], 96.0, 8.0, 1.0), ..here }, &v);
+    let (a, b) = (mass(&base, &blank), mass(&moved, &blank));
+    assert!(b[0] < a[0] - 4.0 && (b[1] - a[1]).abs() < 2.0, "{a:?} -> {b:?}");
+    // Zooming in spreads them out.
+    let zoomed = pw_in(&Comp { camera: cam([24.0, 24.0], 96.0, 0.0, 2.0), ..here }, &v);
+    let cover = |i: &Image| i.data.iter().filter(|p| p[3] > 0.01).count();
+    assert!(cover(&zoomed) > cover(&base), "{} {}", cover(&zoomed), cover(&base));
+    // The Effect Camera is ignored then.
+    let mut turned = v.clone();
+    turned.push(("extras/effectCamera/rotationY", num(60.0)));
+    assert_eq!(pw_in(&here, &turned), base);
+    // The comp's default view (no camera layer) leaves it to the Effect Camera.
+    let default_view = Comp { layer: false, ..here };
+    assert_eq!(pw_in(&default_view, &v), run("ec.sim.ccparticleworld", &v, blank.clone(), 1.0));
+    // A camera facing away, or a degenerate one, draws nothing and never NaN.
+    for camera in [[[96.0, 0.0, 24.0, 0.0], [0.0, 96.0, 24.0, 0.0], [0.0, 0.0, -1.0, -96.0]], [[0.0; 4]; 3], [[f64::NAN; 4]; 3]] {
+        assert_eq!(pw_in(&Comp { camera, layer: true }, &v), blank);
+    }
+    // A camera among the particles draws the ones in front of it.
+    let inside = pw_in(&Comp { camera: cam([24.0, 24.0], 1.0, 0.0, 1.0), ..here }, &v);
+    assert!(finite(&inside));
+}
+
+/// Extras ▸ Effect Camera: the defaults are the fixed camera Particle World always had.
+#[test]
+fn particle_world_effect_camera() {
+    let v = pw_vals(5.0);
+    let base = run("ec.sim.ccparticleworld", &v, Image::new(48, 48), 1.0);
+    let with = |extra: &[(&'static str, Value)]| {
+        let mut w = v.clone();
+        w.extend_from_slice(extra);
+        run("ec.sim.ccparticleworld", &w, Image::new(48, 48), 1.0)
+    };
+    // Missing parameters (projects saved before) read as the defaults.
+    let spec = crate::find("ec.sim.ccparticleworld").unwrap();
+    let mut params = crate::Params { values: spec.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+    params.values.retain(|k, _| !k.starts_with(PW_EFFECT_CAMERA));
+    for (k, val) in &v {
+        params.values.insert(k.to_string(), val.clone());
+    }
+    let ctx = EffectCtx { params: &params, time: 1.0, layer_size: [48.0, 48.0], seed: 1, adjustment: false, env: EffectEnv::default() };
+    assert_eq!(crate::apply(spec, &ctx, Buf { img: Image::new(48, 48), offset: [0.0; 2], scale: 1.0 }).img, base);
+    assert_eq!(with(&[("extras/effectCamera/fov", num(f64::NAN))]), base);
+    // Turning or pulling back the camera changes the view.
+    let turned = with(&[("extras/effectCamera/rotationY", num(60.0))]);
+    assert!(diff(&turned, &base) > 1.0);
+    let cover = |i: &Image| i.data.iter().filter(|p| p[3] > 0.01).count();
+    let far = with(&[("extras/effectCamera/distance", num(4.0))]);
+    assert!(cover(&far) < cover(&base), "{} {}", cover(&far), cover(&base));
+    assert!(diff(&with(&[("extras/effectCamera/fov", num(120.0))]), &base) > 0.1);
+    // Extremes never panic or produce NaN.
+    for extra in [
+        ("extras/effectCamera/distance", num(0.0)),
+        ("extras/effectCamera/distance", num(-5.0)),
+        ("extras/effectCamera/fov", num(0.0)),
+        ("extras/effectCamera/fov", num(180.0)),
+        ("extras/effectCamera/rotationX", num(1e12)),
+    ] {
+        assert!(finite(&with(std::slice::from_ref(&extra))), "{extra:?}");
+    }
+    // Moving the camera doesn't restart the simulation.
+    let key =
+        |pr: &crate::Params| sim_key(&EffectCtx { params: pr, time: 1.0, layer_size: [48.0, 48.0], seed: 1, adjustment: false, env: EffectEnv::default() }, 1);
+    let mut moved = params.clone();
+    moved.values.insert("extras/effectCamera/rotationZ".into(), num(30.0));
+    assert_eq!(key(&params), key(&moved));
+    moved.values.insert("extras/randomSeed".into(), num(9.0));
+    assert_ne!(key(&params), key(&moved));
+}
+
+/// A host whose every layer is `img`.
+struct TexHost(Image);
+impl crate::EffectHost for TexHost {
+    fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
+        let s = [self.0.width as f64, self.0.height as f64];
+        Some(crate::LayerPixels { buf: Buf { img: self.0.clone(), offset: [0.0; 2], scale: 1.0 }, size: s })
+    }
+    fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+        None
+    }
+}
+
+/// A texture whose left half is green and right half blue.
+fn two_tone_tex() -> Image {
+    let mut tex = Image::new(8, 8);
+    for y in 0..8 {
+        for x in 0..8 {
+            tex.set(x, y, if x < 4 { [0.0, 1.0, 0.0, 1.0] } else { [0.0, 0.0, 1.0, 1.0] });
+        }
+    }
+    tex
+}
+
+/// CC Particle World drawing red Textured Squares with Texture Layer `layer`.
+fn pw_textured_vals(layer: Option<u64>) -> Vec<(&'static str, Value)> {
+    vec![
+        ("birthRate", num(1.0)),
+        ("extras/randomSeed", num(4.0)),
+        ("particle/particleType", Value::Enum(8)),
+        ("particle/texture/textureLayer", Value::Layer(layer)),
+        ("particle/birthSize", num(1.0)),
+        ("particle/deathSize", num(1.0)),
+        ("particle/birthColor", col(1.0, 0.0, 0.0)),
+        ("particle/deathColor", col(1.0, 0.0, 0.0)),
+    ]
+}
+
+/// #1465: Textured Square draws the Texture Layer on each particle, not the particle colour.
+#[test]
+fn particle_world_textured_square_draws_the_texture_layer() {
+    let host = TexHost(two_tone_tex());
+    let vals = pw_textured_vals;
+    let env = EffectEnv { host: Some(&host), ..Default::default() };
+    let out = run_fx("ec.sim.ccparticleworld", &vals(Some(1)), Image::new(48, 48), 1.0, env).img;
+    let seen: Vec<_> = out.data.iter().filter(|p| p[3] > 0.05).collect();
+    assert!(!seen.is_empty(), "particles drawn");
+    assert!(seen.iter().all(|p| p[0] < 0.02 * p[3]), "no particle colour: {:?}", seen.iter().find(|p| p[0] >= 0.02 * p[3]));
+    // Both halves of the texture show: it is mapped across the square, not sampled once.
+    assert!(seen.iter().any(|p| p[1] > 2.0 * p[2]) && seen.iter().any(|p| p[2] > 2.0 * p[1]), "both texture halves");
+    // Without a texture layer the squares keep the particle colour.
+    let plain = run_fx("ec.sim.ccparticleworld", &vals(None), Image::new(48, 48), 1.0, env).img;
+    assert!(plain.data.iter().any(|p| p[3] > 0.05 && p[0] > 0.9 * p[3]));
+}
+
+/// #1465 with #1195's motion trails: with the shutter open the averaged samples still show
+/// the Texture Layer, not the particle colour.
+#[test]
+fn particle_world_textured_square_motion_trails_draw_the_texture_layer() {
+    let host = TexHost(two_tone_tex());
+    let env = EffectEnv { host: Some(&host), frame_rate: 10.0, shutter: Some((360.0, -180.0, 8)), ..Default::default() };
+    let blurred = run_fx("ec.sim.ccparticleworld", &pw_textured_vals(Some(1)), Image::new(48, 48), 1.0, env).img;
+    let sharp = run_fx("ec.sim.ccparticleworld", &pw_textured_vals(Some(1)), Image::new(48, 48), 1.0, EffectEnv { shutter: None, ..env }).img;
+    assert_ne!(sharp.data, blurred.data, "the shutter smears the particles");
+    let seen: Vec<_> = blurred.data.iter().filter(|p| p[3] > 0.02).collect();
+    assert!(!seen.is_empty(), "particles drawn");
+    assert!(seen.iter().all(|p| p[0] < 0.02 * p[3]), "no particle colour: {:?}", seen.iter().find(|p| p[0] >= 0.02 * p[3]));
+    assert!(seen.iter().any(|p| p[1] > 2.0 * p[2]) && seen.iter().any(|p| p[2] > 2.0 * p[1]), "both texture halves");
+}
+
+/// A host whose every layer is `0` as given (a buffer that may span only its content).
+struct PixelsHost(crate::LayerPixels);
+impl crate::EffectHost for PixelsHost {
+    fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
+        Some(self.0.clone())
+    }
+    fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+        None
+    }
+}
+
+/// #1465: a Texture Layer whose buffer spans only its content (text, shapes) is mapped as
+/// the whole layer, transparent around the content, not with its edge pixels stretched.
+#[test]
+fn particle_world_texture_layer_with_a_content_sized_buffer() {
+    // An 8×8 layer with a green 4×4 square in the middle: once as the full layer, once as
+    // just the square's pixels.
+    let mut full = Image::new(8, 8);
+    for y in 2..6 {
+        for x in 2..6 {
+            full.set(x, y, [0.0, 1.0, 0.0, 1.0]);
+        }
+    }
+    let content = Image::filled(4, 4, [0.0, 1.0, 0.0, 1.0]);
+    let render = |buf: Buf| {
+        let host = PixelsHost(crate::LayerPixels { buf, size: [8.0, 8.0] });
+        let env = EffectEnv { host: Some(&host), ..Default::default() };
+        run_fx("ec.sim.ccparticleworld", &pw_textured_vals(Some(1)), Image::new(48, 48), 1.0, env).img
+    };
+    let want = render(Buf { img: full, offset: [0.0; 2], scale: 1.0 });
+    let got = render(Buf { img: content, offset: [-2.0, -2.0], scale: 1.0 });
+    assert!(want.data.iter().any(|p| p[3] > 0.05), "particles drawn");
+    assert_eq!(want.data, got.data, "the content-sized buffer draws as the full layer");
+}
+
+#[test]
+fn particle_systems2_seek_and_direction() {
+    let v = vec![
+        ("producer/position", pt(24.0, 24.0)),
+        ("birthRate", num(3.0)),
+        ("physics/gravity", num(0.0)),
+        ("physics/velocity", num(1.0)),
+        ("physics/animation", Value::Enum(1)),
+    ];
+    let _ = run("ec.sim.ccparticlesystems2", &v, Image::new(48, 48), 0.5);
+    let a = run("ec.sim.ccparticlesystems2", &v, Image::new(48, 48), 1.0);
+    let mut v2 = v.clone();
+    v2.push(("randomSeed", num(0.0)));
+    assert_eq!(a, run("ec.sim.ccparticlesystems2", &v2, Image::new(48, 48), 1.0));
+    // Direction 0° (up): particles above the producer.
+    let blank = Image::new(48, 48);
+    let y = mass_y(&a, &blank);
+    assert!((0.0..24.0).contains(&y), "{y}");
+    // The particles replace the layer: with none born it is empty.
+    let none = run("ec.sim.ccparticlesystems2", &[("birthRate", num(0.0))], grey(20, 20), 1.0);
+    assert_eq!(none, Image::new(20, 20));
+}
+
+/// CC Particle World and CC Particle Systems II replace their layer with the particles, in
+/// every Transfer Mode (which only sets how particles meet each other). SceneYard frames from
+/// After Effects 2026 show no trace of the source solid: "Task Preparation UI" (black solids
+/// under fireworks hid a white page), "Burnout matchstick" (a red rectangle around the
+/// flame), "Documentary Man Falling" (a black block over the light).
+#[test]
+fn cc_particles_replace_their_layer() {
+    let red = || {
+        let mut img = Image::new(48, 48);
+        img.data.iter_mut().for_each(|p| *p = [0.7, 0.1, 0.1, 1.0]);
+        img
+    };
+    for id in ["ec.sim.ccparticlesystems2", "ec.sim.ccparticleworld"] {
+        for mode in 0..4 {
+            let v = vec![("birthRate", num(3.0)), ("particle/transferMode", Value::Enum(mode))];
+            let _ = run(id, &v, red(), 0.5);
+            let out = run(id, &v, red(), 1.0);
+            // No source left: the corners, far from the producer, are clear.
+            for (x, y) in [(0, 0), (47, 0), (0, 47), (47, 47)] {
+                assert!(out.get(x, y)[3] < 1e-6, "{id} mode {mode} ({x},{y}): {:?}", out.get(x, y));
+            }
+            assert!(out.data.iter().any(|p| p[3] > 0.05), "{id} mode {mode}: particles drawn");
+        }
+    }
+}
+
+#[test]
+fn mercury_blobs_and_seek() {
+    let v = vec![("producer", pt(24.0, 16.0)), ("radiusX", num(5.0)), ("radiusY", num(5.0)), ("birthRate", num(3.0))];
+    let _ = run("ec.sim.ccmrmercury", &v, ramp(48, 48), 0.7);
+    let a = run("ec.sim.ccmrmercury", &v, ramp(48, 48), 1.4);
+    let mut v2 = v.clone();
+    v2.push(("shading/metal", num(100.0)));
+    let b = run("ec.sim.ccmrmercury", &v2, ramp(48, 48), 1.4);
+    assert_eq!(a, b);
+    assert!(a.data.iter().any(|p| p[3] > 0.5), "blobs visible");
+    let none = run("ec.sim.ccmrmercury", &[("birthRate", num(0.0))], ramp(48, 48), 1.4);
+    assert!(none.data.iter().all(|p| p[3] == 0.0));
+}
+
+#[test]
+fn half_resolution_scales_sprites() {
+    // Downsampled buffers render the same layout at half size.
+    let s = crate::find("ec.sim.ccsnowfall").unwrap();
+    let mut params = crate::Params { values: s.params.iter().map(|p| (p.id.to_string(), p.default.clone())).collect() };
+    params.values.insert("flakes".into(), num(50.0));
+    params.values.insert("offset".into(), pt(20.0, 20.0));
+    let ctx = EffectCtx { params: &params, time: 0.5, layer_size: [40.0, 40.0], seed: 1, adjustment: false, env: EffectEnv::default() };
+    let full = crate::apply(s, &ctx, Buf { img: grey(40, 40), offset: [0.0; 2], scale: 1.0 });
+    let half = crate::apply(s, &ctx, Buf { img: grey(20, 20), offset: [0.0; 2], scale: 0.5 });
+    let sum = |i: &Image| i.data.iter().map(|p| p[0]).sum::<f32>() / i.data.len() as f32;
+    assert!((sum(&full.img) - sum(&half.img)).abs() < 0.05, "{} {}", sum(&full.img), sum(&half.img));
+}
+
+// ---------------------------------------------------------- Birth Rate over time (#1373)
+
+/// A host that evaluates effect `index`'s Birth Rate at other layer times as `rate(t)`.
+struct Rate {
+    index: usize,
+    rate: fn(f64) -> f64,
+}
+impl crate::EffectHost for Rate {
+    fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
+        None
+    }
+    fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+        None
+    }
+    fn param_at(&self, effect_index: usize, id: &str, t: f64) -> Option<Value> {
+        (effect_index == self.index && id == "birthRate").then(|| num((self.rate)(t)))
+    }
+}
+
+/// Birth Rate 3 until 0.5 s, then 0 (the issue's one-shot burst).
+fn burst(t: f64) -> f64 {
+    if t < 0.5 { 3.0 } else { 0.0 }
+}
+
+/// The same burst, cut at 0.25 s (an earlier key moved).
+fn short_burst(t: f64) -> f64 {
+    if t < 0.25 { 3.0 } else { 0.0 }
+}
+
+/// Birth Rate falling linearly from 3 at 0 s to 0 at 0.5 s.
+fn falling(t: f64) -> f64 {
+    (3.0 * (1.0 - t / 0.5)).max(0.0)
+}
+
+/// CC Particle World's parameters: random seed `seed`, Birth Rate `now` (its value at the
+/// rendered time), Longevity 1 s.
+fn pw_params(seed: f64, now: f64) -> crate::Params {
+    let spec = crate::find("ec.sim.ccparticleworld").unwrap();
+    let mut p = crate::Params { values: spec.params.iter().map(|ps| (ps.id.to_string(), crate::default_value(ps, [100.0, 100.0]))).collect() };
+    for (k, v) in [("birthRate", num(now)), ("extras/randomSeed", num(seed)), ("longevity", num(1.0))] {
+        p.values.insert(k.to_string(), v);
+    }
+    p
+}
+
+fn pw_ctx<'a>(p: &'a crate::Params, t: f64, host: Option<&'a Rate>, index: usize) -> EffectCtx<'a> {
+    let env = EffectEnv { host: host.map(|h| h as &dyn crate::EffectHost), effect_index: index, ..Default::default() };
+    EffectCtx { params: p, time: t, layer_size: [100.0, 100.0], seed: 1, adjustment: false, env }
+}
+
+/// The live particles at layer time `t` with Birth Rate `now` there and `host`'s history.
+fn pw_at(seed: f64, now: f64, t: f64, host: Option<&Rate>) -> Vec<crate::psim::SimParticle> {
+    let p = pw_params(seed, now);
+    particle_state("ec.sim.ccparticleworld", &pw_ctx(&p, t, host, host.map_or(0, |h| h.index))).unwrap()
+}
+
+/// The same, simulated from layer time 0 with a cache of its own (the reference).
+fn pw_fresh(seed: f64, now: f64, t: f64, host: &Rate) -> Vec<crate::psim::SimParticle> {
+    let p = pw_params(seed, now);
+    let ctx = pw_ctx(&p, t, Some(host), host.index);
+    let key = params_key_except(&ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, 1, &[PW_EFFECT_CAMERA, "birthRate"]);
+    let st = simulate_rates(&SimCache::new(1), key, &pw_phys(&ctx), &rate_history(&ctx, "birthRate", PW_RATE));
+    st.parts.iter().map(|q| crate::psim::SimParticle { p: q.p, v: q.v, age: q.age, life: q.life, rnd: q.rnd, id: q.id }).collect()
+}
+
+/// Particles born in the first `t` seconds of `rate`.
+fn born_by(rate: fn(f64) -> f64, t: f64) -> usize {
+    crate::psim::births_at(steps_at(t), 40_000, |i| rate(i as f64 / SPS) * PW_RATE).unwrap().len()
+}
+
+/// #1373: Birth Rate only decides the births of its own time. After a burst stops, the
+/// particles born in it live on (moving and ageing) until their Longevity runs out, rather
+/// than vanishing because the rate is now 0.
+#[test]
+fn a_burst_lives_on_after_birth_rate_drops_to_zero() {
+    let host = Rate { index: 2, rate: burst };
+    // During the burst: as a constant Birth Rate of 3.
+    assert_eq!(pw_at(101.0, 3.0, 0.4, Some(&host)), pw_at(101.0, 3.0, 0.4, None));
+    // After it: the burst's particles, none newer.
+    let late = pw_at(101.0, 0.0, 0.9, Some(&host));
+    let n = born_by(burst, 0.5);
+    assert!(late.len() > n / 2 && late.iter().all(|q| (q.id as usize) < n), "{} live of {n} born", late.len());
+    assert!(pw_at(101.0, 0.0, 0.9, None).is_empty(), "a constant Birth Rate of 0 never bore any");
+    // They keep moving.
+    let early = pw_at(101.0, 0.0, 0.7, Some(&host));
+    let q0 = early.iter().find(|q| q.id == late[0].id).unwrap();
+    assert!(q0.p != late[0].p && late[0].age > q0.age + 0.19, "{q0:?} -> {:?}", late[0]);
+    // Longevity 1 s (± 20 %): all gone by 1.8 s.
+    assert!(pw_at(101.0, 0.0, 1.8, Some(&host)).is_empty());
+    // The effect asks for its own index: another effect's history isn't its own.
+    let p = pw_params(101.0, 0.0);
+    assert!(particle_state("ec.sim.ccparticleworld", &pw_ctx(&p, 0.9, Some(&host), 0)).unwrap().is_empty());
+}
+
+/// A Birth Rate ramping down isn't simulated as if its current value had always applied.
+#[test]
+fn a_ramped_birth_rate_bears_what_each_moment_asked_for() {
+    let host = Rate { index: 0, rate: falling };
+    let ramped = pw_at(102.0, falling(0.25), 0.25, Some(&host));
+    let constant = pw_at(102.0, falling(0.25), 0.25, None);
+    assert_eq!(ramped.len(), born_by(falling, 0.25), "every particle born so far is alive");
+    assert_eq!(constant.len(), born_by(|_| 1.5, 0.25));
+    assert!(ramped.len() > constant.len() + 10, "{} vs {}", ramped.len(), constant.len());
+}
+
+/// Seeking backward, forward and to the same time again gives the state simulated from 0.
+#[test]
+fn seeking_through_a_birth_rate_history_matches_simulating_from_zero() {
+    let host = Rate { index: 0, rate: burst };
+    for t in [1.4, 0.6, 0.9, 0.3, 0.9, 1.1] {
+        let now = burst(t);
+        assert_eq!(pw_at(103.0, now, t, Some(&host)), pw_fresh(103.0, now, t, &host), "at {t}");
+    }
+}
+
+/// The simulation cache key leaves Birth Rate out (so an animated rate keeps its checkpoints),
+/// but a checkpoint is only resumed with the history that reached it: after an earlier key
+/// moves, the same current rate (0) gives the new history's particles.
+#[test]
+fn an_earlier_birth_rate_change_is_not_served_from_stale_checkpoints() {
+    let (long, short) = (Rate { index: 0, rate: burst }, Rate { index: 0, rate: short_burst });
+    let a = pw_at(104.0, 0.0, 0.9, Some(&long));
+    let b = pw_at(104.0, 0.0, 0.9, Some(&short));
+    assert_eq!(b, pw_fresh(104.0, 0.0, 0.9, &short));
+    assert!(b.len() < a.len() && !b.is_empty(), "{} vs {}", b.len(), a.len());
+    assert_eq!(pw_at(104.0, 0.0, 1.0, Some(&long)), pw_fresh(104.0, 0.0, 1.0, &long));
+}
+
+/// A constant Birth Rate gives exactly the particles it did before the history was sampled.
+#[test]
+fn a_constant_birth_rate_is_unchanged() {
+    let host = Rate { index: 0, rate: |_| 2.0 };
+    let p = pw_params(105.0, 2.0);
+    let ctx = pw_ctx(&p, 1.3, None, 0);
+    let phys = pw_phys(&ctx);
+    let before = simulate(&SimCache::new(1), sim_key(&ctx, 1), 1.3, &phys);
+    let now = pw_at(105.0, 2.0, 1.3, Some(&host));
+    assert_eq!(now.len(), before.parts.len());
+    assert!(now.iter().zip(&before.parts).all(|(a, b)| a.id == b.id && a.p == b.p && a.v == b.v && a.age == b.age));
+    assert_eq!(crate::psim::births_at(78, 40_000, |_| phys.rate), crate::psim::births(phys.rate, 78, 40_000));
+}
+
+/// The GPU's birth schedule for a rate history is the CPU's: the ids born are the ids the
+/// CPU simulation numbers.
+#[test]
+fn the_birth_schedule_follows_the_rate_history() {
+    let host = Rate { index: 0, rate: falling };
+    let p = pw_params(106.0, 0.0);
+    let ctx = pw_ctx(&p, 0.7, Some(&host), 0);
+    let rates = rate_history(&ctx, "birthRate", PW_RATE);
+    let st = simulate_rates(&SimCache::new(1), 9, &pw_phys(&ctx), &rates);
+    let births = crate::psim::births_at(rates.len() as u64, 40_000, |i| rates[i as usize]).unwrap();
+    assert_eq!(st.next_id as usize, births.len());
+    assert!(births.iter().all(|&b| f64::from(b) / SPS < 0.5), "nothing born once the ramp reaches 0");
+}
+
+// ------------------------- CC Particle Systems II and CC Mr. Mercury's Birth Rate over time
+
+/// A stepped particle effect: its id, physics and simulation.
+struct System {
+    id: &'static str,
+    phys: fn(&EffectCtx) -> Phys,
+    stepped: Stepped<'static>,
+}
+
+const SYSTEMS: [System; 2] =
+    [System { id: "ec.sim.ccparticlesystems2", phys: ps2_phys, stepped: PS2 }, System { id: "ec.sim.ccmrmercury", phys: mercury_phys, stepped: MERCURY }];
+
+/// `id`'s parameters with Birth Rate `now` and Longevity 1 s.
+fn sys_params(id: &str, now: f64) -> crate::Params {
+    let spec = crate::find(id).unwrap();
+    let mut p = crate::Params { values: spec.params.iter().map(|ps| (ps.id.to_string(), crate::default_value(ps, [100.0, 100.0]))).collect() };
+    for (k, v) in [("birthRate", num(now)), ("longevity", num(1.0))] {
+        assert!(p.values.contains_key(k), "{id}: no {k}");
+        p.values.insert(k.to_string(), v);
+    }
+    p
+}
+
+/// The context at layer time `t` (`seed` keeps each test's simulations apart).
+fn sys_ctx<'a>(p: &'a crate::Params, t: f64, host: Option<&'a Rate>, seed: u32) -> EffectCtx<'a> {
+    let env = EffectEnv { host: host.map(|h| h as &dyn crate::EffectHost), effect_index: host.map_or(0, |h| h.index), ..Default::default() };
+    EffectCtx { params: p, time: t, layer_size: [100.0, 100.0], seed, adjustment: false, env }
+}
+
+/// The live particles (id, position, age) of `sys` at `t` through its simulation.
+fn sys_at(sys: &System, seed: u32, now: f64, t: f64, host: Option<&Rate>) -> Vec<(u32, [f32; 3], f32)> {
+    let p = sys_params(sys.id, now);
+    let ctx = sys_ctx(&p, t, host, seed);
+    sys.stepped.state(&ctx, &(sys.phys)(&ctx)).parts.iter().map(|q| (q.id, q.p, q.age)).collect()
+}
+
+/// The same, simulated from layer time 0 with a cache of its own (the reference).
+fn sys_fresh(sys: &System, seed: u32, now: f64, t: f64, host: &Rate) -> Vec<(u32, [f32; 3], f32)> {
+    let p = sys_params(sys.id, now);
+    let ctx = sys_ctx(&p, t, Some(host), seed);
+    let mut skip = sys.stepped.skip.to_vec();
+    skip.push("birthRate");
+    let key = params_key_except(&ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, sys.stepped.salt, &skip);
+    let st = simulate_rates(&SimCache::new(1), key, &(sys.phys)(&ctx), &rate_history(&ctx, "birthRate", sys.stepped.k));
+    st.parts.iter().map(|q| (q.id, q.p, q.age)).collect()
+}
+
+/// What `sys` draws at `t`: CC Particle Systems II's particles, CC Mr. Mercury's blobs.
+fn sys_drawn(sys: &System, seed: u32, now: f64, t: f64, host: Option<&Rate>) -> usize {
+    let p = sys_params(sys.id, now);
+    let ctx = sys_ctx(&p, t, host, seed);
+    match sys.id {
+        "ec.sim.ccmrmercury" => mercury_blobs(&ctx, &Buf { img: Image::new(100, 100), offset: [0.0; 2], scale: 1.0 }).len(),
+        id => particle_state(id, &ctx).unwrap().len(),
+    }
+}
+
+/// #1373 for CC Particle Systems II and CC Mr. Mercury: a burst lives on after Birth Rate
+/// drops to 0 (what they draw too), moving and ageing, and is gone after its Longevity.
+#[test]
+fn particle_systems_ii_and_mr_mercury_keep_a_burst_after_birth_rate_drops() {
+    let host = Rate { index: 1, rate: burst };
+    for sys in &SYSTEMS {
+        let born = crate::psim::births_at(steps_at(0.5), 40_000, |i| burst(i as f64 / SPS) * sys.stepped.k).unwrap().len();
+        assert_eq!(sys_at(sys, 201, 3.0, 0.4, Some(&host)), sys_at(sys, 201, 3.0, 0.4, None), "{}: during the burst", sys.id);
+        let late = sys_at(sys, 201, 0.0, 0.9, Some(&host));
+        assert!(late.len() > born / 2 && late.iter().all(|q| (q.0 as usize) < born), "{}: {} live of {born}", sys.id, late.len());
+        assert!(sys_drawn(sys, 201, 0.0, 0.9, Some(&host)) > 0, "{}: drawn", sys.id);
+        assert_eq!(sys_drawn(sys, 201, 0.0, 0.9, None), 0, "{}: a constant 0 bore none", sys.id);
+        let early = sys_at(sys, 201, 0.0, 0.7, Some(&host));
+        let q0 = early.iter().find(|q| q.0 == late[0].0).unwrap();
+        assert!(q0.1 != late[0].1 && late[0].2 > q0.2 + 0.19, "{}: {q0:?} -> {:?}", sys.id, late[0]);
+        assert!(sys_at(sys, 201, 0.0, 1.8, Some(&host)).is_empty(), "{}: gone after Longevity", sys.id);
+    }
+}
+
+/// Seeking matches a simulation from 0, and moving an earlier key (same current rate, same
+/// cache key) isn't served from the old history's checkpoints.
+#[test]
+fn particle_systems_ii_and_mr_mercury_seek_and_drop_stale_checkpoints() {
+    let (long, short) = (Rate { index: 0, rate: burst }, Rate { index: 0, rate: short_burst });
+    for sys in &SYSTEMS {
+        for t in [1.4, 0.6, 0.9, 0.3, 0.9, 1.1] {
+            let now = burst(t);
+            assert_eq!(sys_at(sys, 202, now, t, Some(&long)), sys_fresh(sys, 202, now, t, &long), "{} at {t}", sys.id);
+        }
+        let b = sys_at(sys, 202, 0.0, 0.9, Some(&short));
+        assert_eq!(b, sys_fresh(sys, 202, 0.0, 0.9, &short), "{}: the moved key", sys.id);
+        assert!(!b.is_empty() && b.len() < sys_at(sys, 202, 0.0, 0.9, Some(&long)).len(), "{}", sys.id);
+    }
+}
+
+/// A constant Birth Rate gives exactly the particles the constant-rate simulation did.
+#[test]
+fn particle_systems_ii_and_mr_mercury_are_unchanged_at_a_constant_rate() {
+    let host = Rate { index: 0, rate: |_| 2.0 };
+    for sys in &SYSTEMS {
+        let p = sys_params(sys.id, 2.0);
+        let ctx = sys_ctx(&p, 1.3, None, 203);
+        let before = simulate(&SimCache::new(1), 1, 1.3, &(sys.phys)(&ctx));
+        let before: Vec<_> = before.parts.iter().map(|q| (q.id, q.p, q.age)).collect();
+        assert!(!before.is_empty());
+        assert_eq!(sys_at(sys, 203, 2.0, 1.3, Some(&host)), before, "{}: keyed to a constant", sys.id);
+        assert_eq!(sys_at(sys, 203, 2.0, 1.3, None), before, "{}: no host", sys.id);
+    }
+}
diff --git a/crates/effects/src/sim/weather.rs b/crates/effects/src/sim/weather.rs
new file mode 100644
index 000000000..347ab4939
--- /dev/null
+++ b/crates/effects/src/sim/weather.rs
@@ -0,0 +1,364 @@
+use super::common::{h, hs};
+use super::sprites::{Acc, Post, Shape, Sprite, SpritePlan, Tint, aa, raster};
+use super::{Buf, EffectCtx, Image, IntoParallelIterator, ParallelIterator, unpremul};
+use crate::util::layer_rect_at;
+
+// ------------------------------------------------------------------ CC Rainfall / CC Snowfall
+
+/// Shared weather layout: per-item depth factor `k` in (0, 1] (1 = nearest) from Scene Depth.
+#[inline]
+fn depth_k(z: f32, scene_depth: f32) -> f32 {
+    1.0 / (1.0 + z * scene_depth / 2500.0)
+}
+
+/// Wrap `v` into `[lo, lo + span)`.
+#[inline]
+fn wrap(v: f32, lo: f32, span: f32) -> f32 {
+    if span <= 0.0 { v } else { lo + (v - lo).rem_euclid(span) }
+}
+
+pub(super) fn rainfall(ctx: &EffectCtx, b: Buf) -> Buf {
+    let mut plan = rainfall_plan(ctx, &b);
+    plan.resolve(&b.img);
+    plan.finish(b)
+}
+
+pub(super) fn rainfall_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
+    let pr = ctx.params;
+    let n = pr.f("drops").clamp(0.0, 100_000.0) as u32;
+    let size = pr.f("size").max(0.0) as f32;
+    let depth = pr.f("sceneDepth").max(0.0) as f32;
+    let speed = pr.f("speed") as f32;
+    let wind = pr.f("wind") as f32;
+    let wvar = pr.f("windVariation") as f32 / 100.0;
+    let spread = pr.f("spread") as f32;
+    let color = pr.color("color");
+    let opacity = pr.f("opacity") as f32 / 100.0;
+    let mode = pr.e("transferMode");
+    let with_orig = pr.b("compositeWithOriginal");
+    let refract = pr.e("extras/appearance") == 0;
+    let off = pr.v2("extras/offset");
+    let seed = pr.f("extras/randomSeed") as u32 ^ ctx.seed.wrapping_mul(0x9e37);
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    let t = ctx.time as f32;
+    let (ox, oy) = (off[0] as f32 - lw * 0.5, off[1] as f32 - lh * 0.5);
+    let (sprites, tints): (Vec<Sprite>, Vec<Tint>) = (0..n)
+        .into_par_iter()
+        .map(|i| {
+            let z = h(i, 1, seed);
+            let k = depth_k(z, depth);
+            let vy = speed / 4000.0 * lh * 2.2 * k;
+            let w = wind / 1000.0 * lh * (1.0 + wvar * hs(i, 2, seed)) * k + spread * hs(i, 7, seed) * k;
+            let len = (vy * 0.04 * size.max(0.2)).max(1.0);
+            let lenx = w * 0.04 * size.max(0.2);
+            let margin = len + lenx.abs() + 4.0;
+            let y = wrap(h(i, 3, seed) * (lh + 2.0 * margin) + vy * t + oy, -margin, lh + 2.0 * margin);
+            let x = wrap(h(i, 4, seed) * (lw + 2.0 * margin) + w * t + ox, -margin, lw + 2.0 * margin);
+            let (bx, by) = b.to_px([x as f64, y as f64]);
+            let c = [color[0], color[1], color[2], opacity * (0.35 + 0.65 * k)];
+            // Refracting drops show the scene behind them, brightened and offset.
+            let tint = if refract { Tint::Refract { x: bx + 2.0 * s as f64, y: by } } else { Tint::Fixed };
+            let r = (size * 0.6 * k * s).max(0.25);
+            (Sprite::new(bx as f32, by as f32, r, c, Shape::Line { dx: -lenx * s, dy: -len * s }), tint)
+        })
+        .unzip();
+    SpritePlan { sprites, tints, acc: Acc::Over, post: weather_post(mode, with_orig) }
+}
+
+fn weather_post(mode: u32, with_orig: bool) -> Post {
+    if with_orig { Post::Combine(if mode == 1 { 3 } else { 0 }) } else { Post::Replace }
+}
+
+pub(super) fn snowfall(ctx: &EffectCtx, b: Buf) -> Buf {
+    snowfall_plan(ctx, &b).finish(b)
+}
+
+pub(super) fn snowfall_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
+    let pr = ctx.params;
+    let n = pr.f("flakes").clamp(0.0, 200_000.0) as u32;
+    let size = pr.f("size").max(0.0) as f32;
+    let svar = pr.f("sizeVariation") as f32 / 100.0;
+    let depth = pr.f("sceneDepth").max(0.0) as f32;
+    let speed = pr.f("speed") as f32;
+    let spvar = pr.f("speedVariation") as f32 / 100.0;
+    let wind = pr.f("wind") as f32;
+    let wvar = pr.f("windVariation") as f32 / 100.0;
+    let spread = pr.f("spread") as f32;
+    let wig = pr.f("wiggle/wiggleAmount") as f32;
+    let wigvar = pr.f("wiggle/wiggleAmountVariation") as f32 / 100.0;
+    let wfreq = pr.f("wiggle/wiggleFrequency") as f32;
+    let wfvar = pr.f("wiggle/wiggleFrequencyVariation") as f32 / 100.0;
+    let color = pr.color("color");
+    let opacity = pr.f("opacity") as f32 / 100.0;
+    let mode = pr.e("transferMode");
+    let with_orig = pr.b("compositeWithOriginal");
+    let off = pr.v2("extras/offset");
+    let seed = pr.f("extras/randomSeed") as u32 ^ ctx.seed.wrapping_mul(0x85eb);
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    let t = ctx.time as f32;
+    let (ox, oy) = (off[0] as f32 - lw * 0.5, off[1] as f32 - lh * 0.5);
+    let sprites: Vec<Sprite> = (0..n)
+        .into_par_iter()
+        .map(|i| {
+            let z = h(i, 1, seed);
+            let k = depth_k(z, depth);
+            let r = (size * 0.5 * k * (1.0 + svar * hs(i, 2, seed))).max(0.05);
+            let vy = speed * (lh / 600.0) * k * (1.0 + spvar * hs(i, 3, seed));
+            let vx = wind * (lh / 1200.0) * k * (1.0 + wvar * hs(i, 4, seed)) + spread * hs(i, 8, seed) * k;
+            let amp = wig * 2.0 * k * (1.0 + wigvar * hs(i, 5, seed));
+            let fr = wfreq * (1.0 + wfvar * hs(i, 6, seed));
+            let ph = h(i, 9, seed) * std::f32::consts::TAU;
+            let margin = r + amp.abs() + 2.0;
+            let y = wrap(h(i, 10, seed) * (lh + 2.0 * margin) + vy * t + oy, -margin, lh + 2.0 * margin);
+            let x = wrap(h(i, 11, seed) * (lw + 2.0 * margin) + vx * t + ox, -margin, lw + 2.0 * margin) + amp * (fr * t * std::f32::consts::TAU + ph).sin();
+            let (bx, by) = b.to_px([x as f64, y as f64]);
+            Sprite::new(bx as f32, by as f32, r * s, [color[0], color[1], color[2], opacity * (0.4 + 0.6 * k)], Shape::Soft)
+        })
+        .collect();
+    SpritePlan { sprites, tints: vec![], acc: Acc::Over, post: weather_post(mode, with_orig) }
+}
+
+// ------------------------------------------------------------------ CC Bubbles
+
+/// A CC Bubbles bubble in buffer pixels.
+#[derive(Clone, Copy, Debug)]
+pub struct Bubble {
+    pub x: f32,
+    pub y: f32,
+    pub r: f32,
+    /// Source sample centre (buffer px).
+    pub sx: f32,
+    pub sy: f32,
+}
+
+/// CC Bubbles' bubbles this frame (closed-form in time) for buffer geometry `b`.
+pub fn bubble_list(ctx: &EffectCtx, b: &Buf) -> Vec<Bubble> {
+    let pr = ctx.params;
+    let n = pr.f("bubbleAmount").clamp(0.0, 10_000.0) as u32;
+    let speed = pr.f("bubbleSpeed") as f32;
+    let wamp = pr.f("wobbleAmplitude") as f32;
+    let wfreq = pr.f("wobbleFrequency") as f32;
+    let bsize = pr.f("bubbleSize").max(0.0) as f32;
+    let seed = ctx.seed.wrapping_mul(0x27d4);
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    let t = ctx.time as f32;
+    let base = lw.min(lh) * 0.035 * bsize;
+    (0..n)
+        .map(|i| {
+            let r = base * (0.5 + h(i, 1, seed));
+            let travel = lh + 2.0 * r;
+            let v = speed * lh * 0.3 * (0.6 + 0.8 * h(i, 2, seed));
+            let y = lh + r - (h(i, 3, seed) * travel + v * t).rem_euclid(travel);
+            let x0 = h(i, 4, seed) * lw;
+            let x = x0 + wamp * (r / base.max(1e-3)) * (t * wfreq * std::f32::consts::TAU + h(i, 5, seed) * std::f32::consts::TAU).sin();
+            let (bx, by) = b.to_px([x as f64, y as f64]);
+            let (sx, sy) = b.to_px([x0 as f64, y as f64]);
+            Bubble { x: bx as f32, y: by as f32, r: r * s, sx: sx as f32, sy: sy as f32 }
+        })
+        .collect()
+}
+
+/// CC Bubbles' refraction sample bounds in the pixels of a buffer with `offset` and `scale`: the
+/// layer rectangle's first and last pixel centres (x0, y0, x1, y1). Samples clamped to them repeat
+/// the layer's edge pixels instead of reaching transparent padding around it (#2024).
+pub fn bubble_sample_bounds(ctx: &EffectCtx, offset: [f64; 2], scale: f64) -> [f32; 4] {
+    let (lx, ly, lw, lh) = layer_rect_at(ctx, offset, scale);
+    let (x0, y0) = (lx + 0.5, ly + 0.5);
+    [x0 as f32, y0 as f32, (lx + lw - 0.5).max(x0) as f32, (ly + lh - 0.5).max(y0) as f32]
+}
+
+pub(super) fn bubbles(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let metal = pr.e("reflectionType") == 1;
+    let shading = pr.e("shadingType");
+    let list = bubble_list(ctx, &b);
+    let [x0, y0, x1, y1] = bubble_sample_bounds(ctx, b.offset, b.scale);
+    let src = b.img.clone();
+    let mut out = Image::new(src.width, src.height);
+    raster(
+        &mut out,
+        &list,
+        |q| Some([q.x - q.r - 1.0, q.y - q.r - 1.0, q.x + q.r + 1.0, q.y + q.r + 1.0]),
+        |q, x, y| {
+            let (dx, dy) = ((x - q.x) / q.r.max(0.5), (y - q.y) / q.r.max(0.5));
+            let d2 = dx * dx + dy * dy;
+            let d = d2.sqrt();
+            let cov = aa((1.0 - d) * q.r);
+            if cov <= 0.0 {
+                return None;
+            }
+            // Liquid refracts (inverted, magnified), metal reflects (wide-angle mirror).
+            let k = if metal { 1.6 } else { -0.7 };
+            let nz = (1.0 - d2).max(0.0).sqrt();
+            let (sx, sy) = ((q.sx + dx * q.r * k).max(x0).min(x1), (q.sy + dy * q.r * k).max(y0).min(y1));
+            let p = src.sample_bilinear_clamped(sx as f64, sy as f64);
+            let (c, sa) = unpremul(p);
+            let mut c = if sa <= 0.0 { [0.6, 0.7, 0.8] } else { c };
+            let mut a = cov;
+            match shading {
+                1 => c = c.map(|v| v * 0.7 + 0.3 * (1.0 - nz)),
+                2 => c = c.map(|v| v * (0.5 + 0.5 * nz)),
+                3 => a *= nz.powf(0.5),
+                4 => a *= 1.0 - nz * 0.8,
+                _ => {}
+            }
+            let hl = (1.0 - ((dx + 0.35).powi(2) + (dy + 0.35).powi(2)) / 0.05).max(0.0) * 0.8;
+            let c = c.map(|v| v + hl);
+            Some([c[0] * a, c[1] * a, c[2] * a, a])
+        },
+        Acc::Over,
+    );
+    b.img = out;
+    b
+}
+
+// ------------------------------------------------------------------ CC Drizzle
+
+/// CC Drizzle's live drops this frame (buffer px: centre x, y, ring radius, amplitude);
+/// `None` = no drops yet (the layer passes through).
+pub fn drizzle_drops(ctx: &EffectCtx, b: &Buf) -> Option<Vec<[f32; 4]>> {
+    let pr = ctx.params;
+    let rate = pr.f("dripRate").max(0.0);
+    let life = pr.f("longevity").max(0.01);
+    let spreading = pr.f("spreading") as f32;
+    let height = pr.f("rippleHeight") as f32 / 100.0;
+    let seed = ctx.seed.wrapping_mul(0x165667b1);
+    let t = ctx.time;
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    if rate <= 0.0 || t < 0.0 {
+        return None;
+    }
+    // Drops born at k / rate with hashed positions; alive while younger than the longevity.
+    let k0 = ((t - life) * rate).floor().max(0.0) as u32;
+    let k1 = (t * rate).floor() as u32;
+    let mut drops = Vec::new();
+    for k in k0..=k1 {
+        let born = k as f64 / rate;
+        let age = (t - born) as f32;
+        if age < 0.0 || age as f64 >= life {
+            continue;
+        }
+        let (x, y) = b.to_px([(h(k, 1, seed) * lw) as f64, (h(k, 2, seed) * lh) as f64]);
+        let radius = spreading * age * lh / 400.0 * s;
+        let amp = height * (1.0 - age / life as f32) * (0.6 + 0.4 * h(k, 3, seed));
+        drops.push([x as f32, y as f32, radius, amp]);
+    }
+    Some(drops)
+}
+
+pub(super) fn drizzle(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let pr = ctx.params;
+    let Some(drops) = drizzle_drops(ctx, &b) else { return b };
+    let rippling = (pr.f("rippling") / 360.0).max(0.05) as f32;
+    let disp = pr.f("displacement") as f32;
+    let li = pr.f("light/lightIntensity") as f32 / 100.0;
+    let lc = pr.color("light/lightColor");
+    let lheight = pr.f("light/lightHeight") as f32 / 100.0;
+    let ldir = (pr.f("light/lightDirection") as f32).to_radians();
+    let ambient = pr.f("shading/ambient") as f32 / 100.0;
+    let diffuse = pr.f("shading/diffuse") as f32 / 100.0;
+    let specular = pr.f("shading/specular") as f32 / 100.0;
+    let rough = pr.f("shading/roughness").max(0.001) as f32;
+    let lh = ctx.layer_size[1] as f32;
+    let s = b.scale as f32;
+    let wavelen = (lh * 0.04 * s).max(2.0) / rippling.clamp(0.25, 4.0);
+    let width = wavelen * (1.0 + rippling * 2.0);
+    let field = |x: f32, y: f32| -> f32 {
+        let mut v = 0.0;
+        for &[dx, dy, r, a] in &drops {
+            let d = ((x - dx).powi(2) + (y - dy).powi(2)).sqrt();
+            let u = (d - r) / width;
+            if u.abs() < 1.0 {
+                let env = 0.5 + 0.5 * (u * std::f32::consts::PI).cos();
+                v += a * env * ((d - r) / wavelen * std::f32::consts::TAU).cos();
+            }
+        }
+        v
+    };
+    let src = b.img.clone();
+    let (ls, lcs) = ldir.sin_cos();
+    let l = {
+        let v = [lcs, ls, lheight.max(0.05)];
+        let n = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
+        [v[0] / n, v[1] / n, v[2] / n]
+    };
+    b.img.rows_mut().for_each(|(y, row)| {
+        for (x, px) in row.iter_mut().enumerate() {
+            let (fx, fy) = (x as f32 + 0.5, y as f32 + 0.5);
+            let gx = field(fx + 1.0, fy) - field(fx - 1.0, fy);
+            let gy = field(fx, fy + 1.0) - field(fx, fy - 1.0);
+            if gx == 0.0 && gy == 0.0 {
+                continue;
+            }
+            let p = src.sample_bilinear_clamped((fx - gx * disp * s * 4.0) as f64, (fy - gy * disp * s * 4.0) as f64);
+            let n = {
+                let v = [-gx * 6.0, -gy * 6.0, 1.0];
+                let m = (v[0] * v[0] + v[1] * v[1] + 1.0).sqrt();
+                [v[0] / m, v[1] / m, v[2] / m]
+            };
+            let nl = (n[0] * l[0] + n[1] * l[1] + n[2] * l[2]).max(0.0);
+            let hz = (l[2] + 1.0) * 0.5;
+            let hv = {
+                let v = [l[0] * 0.5, l[1] * 0.5, hz];
+                let m = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
+                [v[0] / m, v[1] / m, v[2] / m]
+            };
+            let sp = (n[0] * hv[0] + n[1] * hv[1] + n[2] * hv[2]).max(0.0).powf(1.0 / rough) * specular * li;
+            let shade = 1.0 + (ambient + diffuse * nl - diffuse * l[2]) * li;
+            let a = p[3];
+            *px = [p[0] * shade + sp * lc[0] * a, p[1] * shade + sp * lc[1] * a, p[2] * shade + sp * lc[2] * a, a];
+        }
+    });
+    b
+}
+
+// ------------------------------------------------------------------ CC Star Burst
+
+pub(super) fn star_burst(ctx: &EffectCtx, b: Buf) -> Buf {
+    let mut plan = star_burst_plan(ctx, &b);
+    plan.resolve(&b.img);
+    plan.finish(b)
+}
+
+pub(super) fn star_burst_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
+    let pr = ctx.params;
+    let scatter = pr.f("scatter") as f32;
+    let speed = pr.f("speed") as f32;
+    let phase = pr.f("phase") as f32 / 360.0;
+    let spacing = pr.f("gridSpacing").max(1.0) as f32;
+    let size = pr.f("size") as f32 / 100.0;
+    let blend = pr.f("blendWithOriginal") as f32 / 100.0;
+    let seed = ctx.seed.wrapping_mul(0x3c6e);
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    let t = ctx.time as f32;
+    let nx = (lw / spacing).ceil().max(1.0) as u32;
+    let ny = (lh / spacing).ceil().max(1.0) as u32;
+    let (cx, cy) = (lw * 0.5, lh * 0.5);
+    let mut list: Vec<(f32, Sprite, Tint)> = (0..nx * ny)
+        .into_par_iter()
+        .map(|i| {
+            let (gx, gy) = ((i % nx) as f32 * spacing + spacing * 0.5, (i / nx) as f32 * spacing + spacing * 0.5);
+            let (sx, sy) = b.to_px([gx as f64, gy as f64]);
+            // Depth cycles towards the viewer: z in [0, 1), perspective 1 / (1 - 0.9 z).
+            let z = (h(i, 1, seed) + t * speed * 0.25 + phase).rem_euclid(1.0);
+            let persp = 1.0 / (1.0 - 0.9 * z);
+            let jx = hs(i, 2, seed) * scatter * 0.01 * lw * 0.5;
+            let jy = hs(i, 3, seed) * scatter * 0.01 * lh * 0.5;
+            let x = cx + (gx - cx + jx) * persp;
+            let y = cy + (gy - cy + jy) * persp;
+            let (bx, by) = b.to_px([x as f64, y as f64]);
+            let r = spacing * 0.5 * size * persp * s;
+            let fade = (z * 8.0).min(1.0) * ((1.0 - z) * 6.0).min(1.0);
+            // The layer's colour at the grid point (none where it is clear).
+            (z, Sprite::new(bx as f32, by as f32, r, [0.0, 0.0, 0.0, fade], Shape::Disc), Tint::Source { x: sx, y: sy })
+        })
+        .collect();
+    list.sort_by(|a, b| a.0.total_cmp(&b.0));
+    let (sprites, tints) = list.into_iter().map(|(_, s, t)| (s, t)).unzip();
+    SpritePlan { sprites, tints, acc: Acc::Over, post: if blend > 0.0 { Post::Lerp(blend) } else { Post::Replace } }
+}
diff --git a/crates/effects/src/sim2.rs b/crates/effects/src/sim2.rs
index cf7322bda..497b60f16 100644
--- a/crates/effects/src/sim2.rs
+++ b/crates/effects/src/sim2.rs
@@ -16,2683 +16,28 @@ use crate::sim::{Acc, Post, Shape, Sprite, SpritePlan, h, hs, pct, pt, raster, s
 use crate::util::{Plane, SimCache, gauss_plane, layer_or_self, params_key, unpremul};
 use crate::{Buf, EffectCtx, EffectSpec, col, num, p, popup, slider};
 
-// ------------------------------------------------------------------ 3D pieces
-
-pub(crate) type M3 = [[f64; 3]; 3];
-
-fn mat_mul(a: &M3, b: &M3) -> M3 {
-    std::array::from_fn(|i| std::array::from_fn(|j| (0..3).map(|k| a[i][k] * b[k][j]).sum()))
-}
-
-/// Rotation from Euler angles (radians), applied X then Y then Z.
-fn rot_xyz(x: f64, y: f64, z: f64) -> M3 {
-    let (sx, cx) = x.sin_cos();
-    let (sy, cy) = y.sin_cos();
-    let (sz, cz) = z.sin_cos();
-    let rx = [[1.0, 0.0, 0.0], [0.0, cx, -sx], [0.0, sx, cx]];
-    let ry = [[cy, 0.0, sy], [0.0, 1.0, 0.0], [-sy, 0.0, cy]];
-    let rz = [[cz, -sz, 0.0], [sz, cz, 0.0], [0.0, 0.0, 1.0]];
-    mat_mul(&rz, &mat_mul(&ry, &rx))
-}
-
-/// Rotation by `angle` about unit `axis` (Rodrigues).
-pub(crate) fn rot_axis(axis: [f64; 3], angle: f64) -> M3 {
-    let l = (axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]).sqrt();
-    if l < 1e-12 || angle == 0.0 {
-        return [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
-    }
-    let (x, y, z) = (axis[0] / l, axis[1] / l, axis[2] / l);
-    let (s, c) = angle.sin_cos();
-    let t = 1.0 - c;
-    [
-        [t * x * x + c, t * x * y - s * z, t * x * z + s * y],
-        [t * x * y + s * z, t * y * y + c, t * y * z - s * x],
-        [t * x * z - s * y, t * y * z + s * x, t * z * z + c],
-    ]
-}
-
-fn inv3(m: &M3) -> Option<M3> {
-    let det = m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
-        + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
-    if det.abs() < 1e-12 {
-        return None;
-    }
-    let d = 1.0 / det;
-    Some([
-        [(m[1][1] * m[2][2] - m[1][2] * m[2][1]) * d, (m[0][2] * m[2][1] - m[0][1] * m[2][2]) * d, (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * d],
-        [(m[1][2] * m[2][0] - m[1][0] * m[2][2]) * d, (m[0][0] * m[2][2] - m[0][2] * m[2][0]) * d, (m[0][2] * m[1][0] - m[0][0] * m[1][2]) * d],
-        [(m[1][0] * m[2][1] - m[1][1] * m[2][0]) * d, (m[0][1] * m[2][0] - m[0][0] * m[2][1]) * d, (m[0][0] * m[1][1] - m[0][1] * m[1][0]) * d],
-    ])
-}
-
-/// Perspective camera looking down +z at the layer plane z = 0, `d` pixels away, centred on
-/// `c` (buffer pixels): screen = c + (P - c) · d / (d + z).
-#[derive(Clone, Copy)]
-struct Cam {
-    c: [f64; 2],
-    d: f64,
-}
-
-impl Cam {
-    fn proj(self) -> Proj {
-        Proj::simple(self.c, self.d)
-    }
-}
-
-/// A planar textured piece ready to draw.
-#[derive(Clone, Copy, Debug)]
-pub struct Piece {
-    /// Screen (buffer px, homogeneous) → piece-local (a, b, w).
-    pub inv: [[f64; 3]; 3],
-    /// Rest centre of the piece in texture pixels.
-    pub c0: [f32; 2],
-    /// Convex polygon (texture pixels), counter-clockwise in y-down space.
-    pub poly: [[f32; 2]; 6],
-    pub n: u8,
-    pub bbox: [f32; 4],
-    pub shade: f32,
-    /// Lighting: colour multiplier and additive specular highlight.
-    pub tint: [f32; 3],
-    pub spec: [f32; 3],
-    pub alpha: f32,
-    /// Flat straight colour instead of the texture.
-    pub flat: Option<[f32; 3]>,
-    /// Facing away from the camera (draw the back texture).
-    pub back: bool,
-    /// Back faces sample their texture mirrored about the piece centre: 0 no, 1 vertically
-    /// (flipped about the X axis), 2 horizontally (about the Y axis).
-    pub back_mirror: u8,
-    depth: f64,
-}
-
-/// A piece texture: the layer itself or another image (buffer-aligned).
-#[derive(Clone, Debug)]
-pub enum PieceTex {
-    Layer,
-    Image(Image),
-}
-
-/// What a piece-drawing effect (Card Dance, Shatter, Card Wipe) draws this frame: pieces sorted
-/// far to near over a transparent frame, textured by `front` (and `back` for pieces facing
-/// away; none = they take `front`).
-#[derive(Clone, Debug)]
-pub struct PiecePlan {
-    pub pieces: Vec<Piece>,
-    pub front: PieceTex,
-    pub back: Option<PieceTex>,
-}
-
-impl PiecePlan {
-    /// Rasterise over a transparent frame of the layer `b`'s size.
-    pub fn finish(&self, mut b: Buf) -> Buf {
-        let mut out = Image::new(b.img.width, b.img.height);
-        let front = match &self.front {
-            PieceTex::Layer => &b.img,
-            PieceTex::Image(i) => i,
-        };
-        let back = self.back.as_ref().map(|t| match t {
-            PieceTex::Layer => &b.img,
-            PieceTex::Image(i) => i,
-        });
-        draw_pieces(&mut out, &self.pieces, front, back);
-        b.img = out;
-        b
-    }
-}
-
-/// The piece plan of Card Dance, Shatter (Rendered view) or Card Wipe for layer `b` (its pixels
-/// may be read: gradient maps and textures default to the layer), `None` for other effects or
-/// views drawn otherwise.
-pub fn piece_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option<PiecePlan> {
-    match id {
-        "ec.sim.carddance" => Some(card_dance_plan(ctx, b)),
-        "ec.sim.shatter" if ctx.params.e("view") == 0 => match shatter_impl(ctx, b) {
-            ShatterPlan::Pieces(plan) => Some(plan),
-            ShatterPlan::Wire(_) => None,
-        },
-        "ec.transition.cardwipe" => crate::transition::card_wipe_plan(ctx, b),
-        _ => None,
-    }
-}
-
-impl Piece {
-    /// Place polygon `poly` (texture px, around rest centre `c0`) with rotation `r` and its
-    /// centre at 3D `pos` (buffer px; z away from the camera), seen through `cam`.
-    pub(crate) fn new(poly: &[[f32; 2]], c0: [f32; 2], r: &M3, pos: [f64; 3], cam: impl Into<Proj>) -> Option<Piece> {
-        let cam: Proj = cam.into();
-        let n = poly.len().min(6);
-        if n < 3 {
-            return None;
-        }
-        let m = &cam.m;
-        let row = |i: usize| -> [f64; 3] {
-            [
-                m[i][0] * r[0][0] + m[i][1] * r[1][0] + m[i][2] * r[2][0],
-                m[i][0] * r[0][1] + m[i][1] * r[1][1] + m[i][2] * r[2][1],
-                m[i][0] * pos[0] + m[i][1] * pos[1] + m[i][2] * pos[2] + m[i][3],
-            ]
-        };
-        let hm: M3 = [row(0), row(1), row(2)];
-        let mut bb = [f32::INFINITY, f32::INFINITY, f32::NEG_INFINITY, f32::NEG_INFINITY];
-        for v in &poly[..n] {
-            let (a, b) = ((v[0] - c0[0]) as f64, (v[1] - c0[1]) as f64);
-            let w = hm[2][0] * a + hm[2][1] * b + hm[2][2];
-            if w < cam.near {
-                return None;
-            }
-            let sx = ((hm[0][0] * a + hm[0][1] * b + hm[0][2]) / w) as f32;
-            let sy = ((hm[1][0] * a + hm[1][1] * b + hm[1][2]) / w) as f32;
-            bb = [bb[0].min(sx), bb[1].min(sy), bb[2].max(sx), bb[3].max(sy)];
-        }
-        let inv = inv3(&hm)?;
-        let mut pp = [[0.0f32; 2]; 6];
-        pp[..n].copy_from_slice(&poly[..n]);
-        // Normalise winding so "inside" is cross >= 0 for every edge.
-        let area: f32 = (0..n).map(|i| pp[i][0] * pp[(i + 1) % n][1] - pp[(i + 1) % n][0] * pp[i][1]).sum();
-        if area < 0.0 {
-            pp[..n].reverse();
-        }
-        // The front faces -z at rest; it faces the camera when its normal points at the eye.
-        let eye = cam.eye();
-        let nrm = [-r[0][2], -r[1][2], -r[2][2]];
-        let to_eye = [eye[0] - pos[0], eye[1] - pos[1], eye[2] - pos[2]];
-        let facing = nrm[0] * to_eye[0] + nrm[1] * to_eye[1] + nrm[2] * to_eye[2];
-        let depth = hm[2][2];
-        Some(Piece {
-            inv,
-            c0,
-            poly: pp,
-            n: n as u8,
-            bbox: [bb[0] - 1.0, bb[1] - 1.0, bb[2] + 1.0, bb[3] + 1.0],
-            shade: 1.0,
-            tint: [1.0; 3],
-            spec: [0.0; 3],
-            alpha: 1.0,
-            flat: None,
-            back: facing < 0.0,
-            back_mirror: 0,
-            depth,
-        })
-    }
-
-    /// Lambert factor of the piece normal against a light shining along +z.
-    fn facing(r: &M3) -> f32 {
-        r[2][2].abs() as f32
-    }
-
-    /// Light the piece (rotation `r`, centre `pos`) with Lighting / Material.
-    pub(crate) fn light(&mut self, l: &Lighting, r: &M3, pos: [f64; 3], eye: [f64; 3]) {
-        let (t, s) = l.shade([-r[0][2], -r[1][2], -r[2][2]], pos, eye);
-        self.tint = t;
-        self.spec = s;
-    }
-}
-
-impl From<Cam> for Proj {
-    fn from(c: Cam) -> Proj {
-        c.proj()
-    }
-}
-
-/// Draw pieces (already sorted far → near) over `out`.
-pub(crate) fn draw_pieces(out: &mut Image, pieces: &[Piece], front: &Image, back: Option<&Image>) {
-    raster(
-        out,
-        pieces,
-        |q| Some(q.bbox),
-        |q, x, y| {
-            let (xf, yf) = (x as f64, y as f64);
-            let m = &q.inv;
-            let w = m[2][0] * xf + m[2][1] * yf + m[2][2];
-            if w.abs() < 1e-12 {
-                return None;
-            }
-            let u = ((m[0][0] * xf + m[0][1] * yf + m[0][2]) / w) as f32 + q.c0[0];
-            let v = ((m[1][0] * xf + m[1][1] * yf + m[1][2]) / w) as f32 + q.c0[1];
-            let n = q.n as usize;
-            let mut md = f32::INFINITY;
-            for i in 0..n {
-                let a = q.poly[i];
-                let b = q.poly[(i + 1) % n];
-                let (ex, ey) = (b[0] - a[0], b[1] - a[1]);
-                let l = (ex * ex + ey * ey).sqrt().max(1e-6);
-                md = md.min((ex * (v - a[1]) - ey * (u - a[0])) / l);
-            }
-            // Coverage extends half a pixel past the edge so abutting pieces leave no seams.
-            let cov = (md + 1.0).clamp(0.0, 1.0);
-            if cov <= 0.0 {
-                return None;
-            }
-            let (c, a) = match q.flat {
-                Some(c) => (c, 1.0),
-                None => {
-                    let tex = if q.back { back.unwrap_or(front) } else { front };
-                    let (u, v) = match (q.back, q.back_mirror) {
-                        (true, 1) => (u, 2.0 * q.c0[1] - v),
-                        (true, 2) => (2.0 * q.c0[0] - u, v),
-                        _ => (u, v),
-                    };
-                    unpremul(tex.sample_bilinear(u as f64, v as f64))
-                }
-            };
-            let a = a * cov * q.alpha;
-            if a <= 1e-6 {
-                return None;
-            }
-            let k = q.shade;
-            let o: [f32; 3] = std::array::from_fn(|i| c[i] * k * q.tint[i] + q.spec[i]);
-            Some([o[0] * a, o[1] * a, o[2] * a, a])
-        },
-        Acc::Over,
-    );
-}
-
-pub(crate) fn sort_far_first(pieces: &mut [Piece]) {
-    pieces.sort_by(|a, b| b.depth.total_cmp(&a.depth));
-}
-
-// ------------------------------------------------------------------ CC Ball Action
-
-fn ball_action(ctx: &EffectCtx, b: Buf) -> Buf {
-    ball_action_plan(ctx, &b).finish(b)
-}
-
-/// CC Ball Action's balls (far to near), coloured by the layer's pixels.
-fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
-    let pr = ctx.params;
-    let scatter = pr.f("scatter") as f32;
-    let axis = pr.e("rotationAxis");
-    let rot = pr.f("rotation").to_radians();
-    let twist_prop = pr.e("twistProperty");
-    let twist = pr.f("twistAngle").to_radians();
-    let spacing = pr.f("gridSpacing").max(1.0) as f32;
-    let size = pr.f("ballSize") as f32 / 100.0;
-    let instab = pr.f("instabilityState").to_radians() as f32;
-    let seed = ctx.seed.wrapping_mul(0x2545f491);
-    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
-    let s = b.scale as f32;
-    let nx = (lw / spacing).ceil().max(1.0) as u32;
-    let ny = (lh / spacing).ceil().max(1.0) as u32;
-    let d = 2.0 * lw.max(lh) as f64;
-    let (cx, cy) = (lw as f64 * 0.5, lh as f64 * 0.5);
-    let src = &b.img;
-    let ax: [f64; 3] = match axis {
-        0 => [1.0, 0.0, 0.0],
-        1 => [0.0, 1.0, 0.0],
-        2 => [0.0, 0.0, 1.0],
-        3 => [1.0, 1.0, 0.0],
-        4 => [1.0, 0.0, 1.0],
-        5 => [0.0, 1.0, 1.0],
-        _ => [1.0, 1.0, 1.0],
-    };
-    let maxr = ((lw * lw + lh * lh).sqrt() * 0.5).max(1.0);
-    let mut balls: Vec<(f64, Sprite)> = (0..nx * ny)
-        .into_par_iter()
-        .filter_map(|i| {
-            let gx = (i % nx) as f32 * spacing + spacing * 0.5;
-            let gy = (i / nx) as f32 * spacing + spacing * 0.5;
-            let (sx, sy) = b.to_px([gx as f64, gy as f64]);
-            let (c, a) = unpremul(src.sample_bilinear(sx, sy));
-            if a <= 0.0 || size <= 0.0 {
-                return None;
-            }
-            let tp = match twist_prop {
-                0 => gx / lw.max(1.0),
-                1 => gy / lh.max(1.0),
-                2 => ((gx - cx as f32).hypot(gy - cy as f32)) / maxr,
-                _ => crate::util::rgb3([c[0], c[1], c[2], 0.0]).iter().sum::<f32>() / 3.0,
-            } as f64;
-            let ang = rot + twist * tp;
-            // Scatter: random 3D offsets whose direction drifts with the instability state.
-            let ph = h(i, 1, seed) * std::f32::consts::TAU + instab;
-            let sc = scatter * h(i, 2, seed);
-            let off = [(sc * ph.cos()) as f64, (sc * ph.sin()) as f64, (scatter * hs(i, 3, seed)) as f64];
-            let p0 = [gx as f64 - cx + off[0], gy as f64 - cy + off[1], off[2]];
-            let m = rot_axis(ax, ang);
-            let q: [f64; 3] = std::array::from_fn(|k| m[k][0] * p0[0] + m[k][1] * p0[1] + m[k][2] * p0[2]);
-            if d + q[2] <= d * 0.05 {
-                return None;
-            }
-            let persp = d / (d + q[2]);
-            let (bx, by) = b.to_px([cx + q[0] * persp, cy + q[1] * persp]);
-            let r = spacing * 0.5 * size * persp as f32 * s;
-            Some((q[2], Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], a], Shape::Sphere)))
-        })
-        .collect();
-    balls.sort_by(|a, b| b.0.total_cmp(&a.0));
-    let sprites: Vec<Sprite> = balls.into_iter().map(|(_, s)| s).collect();
-    SpritePlan { sprites, tints: vec![], acc: Acc::Over, post: Post::Replace }
-}
-
-// ------------------------------------------------------------------ CC Pixel Polly
-
-fn pixel_polly(ctx: &EffectCtx, b: Buf) -> Buf {
-    match pixel_polly_plan(ctx, &b) {
-        Some(plan) => plan.finish(b),
-        None => b,
-    }
-}
-
-/// CC Pixel Polly's pieces, `None` before Start Time (the layer as is).
-fn pixel_polly_plan(ctx: &EffectCtx, b: &Buf) -> Option<PiecePlan> {
-    let pr = ctx.params;
-    let t = ctx.time - pr.f("startTime");
-    if t <= 0.0 {
-        return None;
-    }
-    let force = pr.f("force");
-    let gravity = pr.f("gravity");
-    let spin = pr.f("spinning").to_radians();
-    let fc = pr.v2("forceCenter");
-    let dir_rand = pr.f("directionRandomness") / 100.0;
-    let spd_rand = pr.f("speedRandomness") / 100.0;
-    let g = pr.f("gridSpacing").max(1.0);
-    let object = pr.e("object");
-    let depth_sort = pr.b("enableDepthSort");
-    let seed = ctx.seed.wrapping_mul(0x632be5ab);
-    let [lw, lh] = ctx.layer_size;
-    let s = b.scale;
-    let cam = Cam { c: [b.offset[0] + lw * 0.5 * s, b.offset[1] + lh * 0.5 * s], d: 2.0 * lw.max(lh) * s };
-    let nx = (lw / g).ceil().max(1.0) as u32;
-    let ny = (lh / g).ceil().max(1.0) as u32;
-    let tri = object <= 1;
-    let textured = object == 1 || object == 3;
-    let maxd = lw.max(lh);
-    let src = &b.img;
-    let per = if tri { 2 } else { 1 };
-    let mut pieces: Vec<Piece> = (0..nx * ny * per)
-        .into_par_iter()
-        .filter_map(|i| {
-            let cell = i / per;
-            let (x0, y0) = ((cell % nx) as f64 * g, (cell / nx) as f64 * g);
-            let poly: Vec<[f64; 2]> = if !tri {
-                vec![[x0, y0], [x0 + g, y0], [x0 + g, y0 + g], [x0, y0 + g]]
-            } else if i % 2 == 0 {
-                vec![[x0, y0], [x0 + g, y0], [x0, y0 + g]]
-            } else {
-                vec![[x0 + g, y0], [x0 + g, y0 + g], [x0, y0 + g]]
-            };
-            let c = [poly.iter().map(|v| v[0]).sum::<f64>() / poly.len() as f64, poly.iter().map(|v| v[1]).sum::<f64>() / poly.len() as f64];
-            let (dx, dy) = (c[0] - fc[0], c[1] - fc[1]);
-            let dist = (dx * dx + dy * dy).sqrt().max(1e-6);
-            let ang = dy.atan2(dx) + dir_rand * std::f64::consts::PI * hs(i, 1, seed) as f64;
-            let speed = force / 100.0 * 0.6 * maxd / (1.0 + dist / (0.5 * maxd)) * (1.0 + spd_rand * hs(i, 2, seed) as f64);
-            let vz = -speed * 0.5 * h(i, 3, seed) as f64;
-            let pos = [c[0] + ang.cos() * speed * t, c[1] + ang.sin() * speed * t + 0.5 * gravity * 0.5 * lh * t * t, vz * t];
-            let axis = [hs(i, 4, seed) as f64, hs(i, 5, seed) as f64, hs(i, 6, seed) as f64];
-            let r = rot_axis(axis, t * (std::f64::consts::PI * h(i, 7, seed) as f64 + spin));
-            let tex: Vec<[f32; 2]> = poly.iter().map(|v| [(v[0] * s + b.offset[0]) as f32, (v[1] * s + b.offset[1]) as f32]).collect();
-            let c0 = [(c[0] * s + b.offset[0]) as f32, (c[1] * s + b.offset[1]) as f32];
-            let posb = [pos[0] * s + b.offset[0], pos[1] * s + b.offset[1], pos[2] * s];
-            let mut pc = Piece::new(&tex, c0, &r, posb, cam)?;
-            pc.shade = 0.35 + 0.65 * Piece::facing(&r);
-            if !textured {
-                let (cc, a) = unpremul(src.sample_bilinear(c0[0] as f64, c0[1] as f64));
-                if a <= 0.0 {
-                    return None;
-                }
-                pc.flat = Some(cc);
-                pc.alpha = a;
-            }
-            Some(pc)
-        })
-        .collect();
-    if depth_sort {
-        sort_far_first(&mut pieces);
-    }
-    Some(PiecePlan { pieces, front: PieceTex::Layer, back: None })
-}
-
-// ------------------------------------------------------------------ CC Scatterize
-
-fn scatterize(ctx: &EffectCtx, b: Buf) -> Buf {
-    match scatterize_plan(ctx, &b) {
-        Some(plan) => plan.finish(b),
-        None => b,
-    }
-}
-
-/// CC Scatterize's pixel dots, `None` when nothing moves (the layer as is).
-fn scatterize_plan(ctx: &EffectCtx, b: &Buf) -> Option<SpritePlan> {
-    let pr = ctx.params;
-    let scatter = pr.f("scatter") as f32;
-    let right = pr.f("rightTwist").to_radians();
-    let left = pr.f("leftTwist").to_radians();
-    if scatter == 0.0 && right == 0.0 && left == 0.0 {
-        return None;
-    }
-    let add = pr.e("transferMode") == 1;
-    let seed = ctx.seed.wrapping_mul(0x7feb352d);
-    let s = b.scale;
-    let (w, hh) = (b.img.width, b.img.height);
-    let (cx, cy) = (b.offset[0] + ctx.layer_size[0] * 0.5 * s, b.offset[1] + ctx.layer_size[1] * 0.5 * s);
-    let half = (ctx.layer_size[0] * 0.5 * s).max(1.0);
-    let d = 2.0 * ctx.layer_size[0].max(ctx.layer_size[1]) * s;
-    let src = &b.img;
-    let sprites: Vec<Sprite> = (0..w * hh)
-        .into_par_iter()
-        .filter_map(|i| {
-            let px = src.data[i as usize];
-            if px[3] <= 0.0 {
-                return None;
-            }
-            let (x, y) = ((i % w) as f64 + 0.5, (i / w) as f64 + 0.5);
-            // Twist about the horizontal axis through the centre, growing towards each side.
-            let k = ((x - cx) / half).abs().min(1.0);
-            let ang = if x < cx { left } else { right } * k;
-            let (sa, ca) = ang.sin_cos();
-            let (yy, zz) = ((y - cy) * ca, (y - cy) * sa);
-            let persp = d / (d + zz).max(d * 0.05);
-            let jx = hs(i, 1, seed) * scatter * s as f32;
-            let jy = hs(i, 2, seed) * scatter * s as f32;
-            let sx = cx + (x - cx) * persp + jx as f64;
-            let sy = cy + yy * persp + jy as f64;
-            let (c, a) = unpremul(px);
-            Some(Sprite::new(sx as f32, sy as f32, 0.6 * persp as f32, [c[0], c[1], c[2], a], Shape::Disc))
-        })
-        .collect();
-    Some(SpritePlan { sprites, tints: vec![], acc: if add { Acc::Add } else { Acc::Over }, post: Post::Replace })
-}
-
-/// What a particle effect that reads the layer's pixels draws this frame (CC Ball Action, CC
-/// Pixel Polly, CC Scatterize, Shatter's wireframe views), for layer `b`; `None` for other
-/// effects or a frame showing the layer as is.
-pub enum PixelPlan {
-    Sprites(SpritePlan),
-    Pieces(PiecePlan),
-}
-
-/// The [`PixelPlan`] of effect `id` for layer `b` (its pixels are read).
-pub fn pixel_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option<PixelPlan> {
-    match id {
-        "ec.sim.ccballaction" => Some(PixelPlan::Sprites(ball_action_plan(ctx, b))),
-        "ec.sim.ccpixelpolly" => pixel_polly_plan(ctx, b).map(PixelPlan::Pieces),
-        "ec.sim.ccscatterize" => scatterize_plan(ctx, b).map(PixelPlan::Sprites),
-        "ec.sim.shatter" => Some(match shatter_impl(ctx, b) {
-            ShatterPlan::Pieces(plan) => PixelPlan::Pieces(plan),
-            ShatterPlan::Wire(plan) => PixelPlan::Sprites(plan),
-        }),
-        _ => None,
-    }
-}
-
-// ------------------------------------------------------------------ Card Dance
-
-const CD_SOURCES: &[&str] = &["None", "Intensity 1", "Red 1", "Green 1", "Blue 1", "Alpha 1", "Intensity 2", "Red 2", "Green 2", "Blue 2", "Alpha 2"];
-/// (param id prefix, twirl-down group match id) per transformed card property.
-const CD_PROPS: [(&str, &str); 8] = [
-    ("xPos", "xPosition"),
-    ("yPos", "yPosition"),
-    ("zPos", "zPosition"),
-    ("xRot", "xRotation"),
-    ("yRot", "yRotation"),
-    ("zRot", "zRotation"),
-    ("xScale", "xScale"),
-    ("yScale", "yScale"),
-];
-
-fn card_source(src: u32, g1: [f32; 4], g2: [f32; 4]) -> f32 {
-    let (c1, a1) = unpremul(g1);
-    let (c2, a2) = unpremul(g2);
-    let lum = |c: [f32; 3]| effectcraft_color::luminance(c[0], c[1], c[2]);
-    match src {
-        1 => lum(c1),
-        2 => c1[0],
-        3 => c1[1],
-        4 => c1[2],
-        5 => a1,
-        6 => lum(c2),
-        7 => c2[0],
-        8 => c2[1],
-        9 => c2[2],
-        10 => a2,
-        _ => 0.0,
-    }
-}
-
-fn card_dance(ctx: &EffectCtx, b: Buf) -> Buf {
-    card_dance_plan(ctx, &b).finish(b)
-}
-
-fn card_dance_plan(ctx: &EffectCtx, b: &Buf) -> PiecePlan {
-    let pr = ctx.params;
-    let rows = pr.f("rows").clamp(1.0, 1000.0) as u32;
-    let cols = if pr.e("rowsColumns") == 1 { rows } else { pr.f("columns").clamp(1.0, 1000.0) as u32 };
-    let g1 = layer_or_self(ctx, b, "gradientLayer1", true, true);
-    let g2 = layer_or_self(ctx, b, "gradientLayer2", true, true);
-    let back = ctx.layer_param("backLayer", true).map(|o| crate::util::fit_layer(ctx, b, &o, true));
-    let [lw, lh] = ctx.layer_size;
-    let s = b.scale;
-    let (cw, ch) = (lw / cols as f64, lh / rows as f64);
-    let cam = crate::card3d::projection(ctx, b);
-    let eye = cam.eye();
-    let light = Lighting::from(ctx, b);
-    let props: Vec<(u32, f64, f64)> =
-        CD_PROPS.iter().map(|(id, g)| (pr.e(&format!("{g}/{id}Source")), pr.f(&format!("{g}/{id}Multiplier")), pr.f(&format!("{g}/{id}Offset")))).collect();
-    let mut pieces: Vec<Piece> = (0..rows * cols)
-        .into_par_iter()
-        .filter_map(|i| {
-            let (cx0, cy0) = ((i % cols) as f64 * cw, (i / cols) as f64 * ch);
-            let c = [cx0 + cw * 0.5, cy0 + ch * 0.5];
-            let (bx, by) = (c[0] * s + b.offset[0], c[1] * s + b.offset[1]);
-            let (gp1, gp2) = (g1.sample_bilinear(bx, by), g2.sample_bilinear(bx, by));
-            let val = |k: usize| {
-                let (sr, m, o) = props[k];
-                o + m * card_source(sr, gp1, gp2) as f64
-            };
-            let (sx, sy) = (val(6), val(7));
-            let r = rot_xyz(val(3).to_radians(), val(4).to_radians(), val(5).to_radians());
-            let rs: M3 = std::array::from_fn(|k| [r[k][0] * sx, r[k][1] * sy, r[k][2]]);
-            let pos = [bx + val(0) * cw * s, by + val(1) * ch * s, val(2) * cw.max(ch) * s];
-            let (tx0, ty0) = ((cx0 * s + b.offset[0]) as f32, (cy0 * s + b.offset[1]) as f32);
-            let (tw, th) = ((cw * s) as f32, (ch * s) as f32);
-            let poly = [[tx0, ty0], [tx0 + tw, ty0], [tx0 + tw, ty0 + th], [tx0, ty0 + th]];
-            let mut pc = Piece::new(&poly, [bx as f32, by as f32], &rs, pos, cam)?;
-            pc.light(&light, &r, pos, eye);
-            Some(pc)
-        })
-        .collect();
-    sort_far_first(&mut pieces);
-    PiecePlan { pieces, front: PieceTex::Layer, back: back.map(PieceTex::Image) }
-}
-
-// ------------------------------------------------------------------ Shatter
-
-/// Shatter's Pattern options; the last, Custom, takes its pieces from Custom Shatter Map.
-const SHATTER_PATTERNS: &[&str] = &["Bricks", "Glass", "Hexagons", "Squares", "Triangles", "Custom"];
-
-/// Pattern cells (polygons in pattern space, before rotation) covering `[x0, x1]×[y0, y1]`.
-fn pattern_cells(kind: u32, cell: f64, x0: f64, y0: f64, x1: f64, y1: f64, seed: u32) -> Vec<Vec<[f64; 2]>> {
-    let mut out = Vec::new();
-    let i0 = (x0 / cell).floor() as i64 - 1;
-    let i1 = (x1 / cell).ceil() as i64 + 1;
-    let j0 = (y0 / cell).floor() as i64 - 1;
-    let j1 = (y1 / cell).ceil() as i64 + 1;
-    match kind {
-        0 => {
-            let bh = cell * 0.5;
-            let r0 = (y0 / bh).floor() as i64 - 1;
-            let r1 = (y1 / bh).ceil() as i64 + 1;
-            for r in r0..=r1 {
-                let sh = if r.rem_euclid(2) == 1 { cell * 0.5 } else { 0.0 };
-                for i in i0..=i1 {
-                    let (x, y) = (i as f64 * cell + sh, r as f64 * bh);
-                    out.push(vec![[x, y], [x + cell, y], [x + cell, y + bh], [x, y + bh]]);
-                }
-            }
-        }
-        1 => {
-            // Jittered lattice split into triangles along a random diagonal.
-            let jit = |i: i64, j: i64| -> [f64; 2] {
-                let (a, b) = (i as u32, j as u32);
-                [i as f64 * cell + hs(a, b.wrapping_add(17), seed) as f64 * cell * 0.35, j as f64 * cell + hs(a, b.wrapping_add(91), seed) as f64 * cell * 0.35]
-            };
-            for j in j0..=j1 {
-                for i in i0..=i1 {
-                    let (p00, p10, p11, p01) = (jit(i, j), jit(i + 1, j), jit(i + 1, j + 1), jit(i, j + 1));
-                    if h(i as u32, j as u32, seed ^ 0x55) < 0.5 {
-                        out.push(vec![p00, p10, p11]);
-                        out.push(vec![p00, p11, p01]);
-                    } else {
-                        out.push(vec![p00, p10, p01]);
-                        out.push(vec![p10, p11, p01]);
-                    }
-                }
-            }
-        }
-        2 => {
-            let r = cell / 3f64.sqrt();
-            let dx = 1.5 * r;
-            let dy = 3f64.sqrt() * r;
-            let c0 = (x0 / dx).floor() as i64 - 1;
-            let c1 = (x1 / dx).ceil() as i64 + 1;
-            let rr0 = (y0 / dy).floor() as i64 - 1;
-            let rr1 = (y1 / dy).ceil() as i64 + 1;
-            for ci in c0..=c1 {
-                for rj in rr0..=rr1 {
-                    let cx = ci as f64 * dx;
-                    let cy = (rj as f64 + if ci.rem_euclid(2) == 1 { 0.5 } else { 0.0 }) * dy;
-                    out.push(
-                        (0..6)
-                            .map(|k| {
-                                let a = k as f64 * std::f64::consts::PI / 3.0;
-                                [cx + r * a.cos(), cy + r * a.sin()]
-                            })
-                            .collect(),
-                    );
-                }
-            }
-        }
-        3 => {
-            for j in j0..=j1 {
-                for i in i0..=i1 {
-                    let (x, y) = (i as f64 * cell, j as f64 * cell);
-                    out.push(vec![[x, y], [x + cell, y], [x + cell, y + cell], [x, y + cell]]);
-                }
-            }
-        }
-        _ => {
-            for j in j0..=j1 {
-                for i in i0..=i1 {
-                    let (x, y) = (i as f64 * cell, j as f64 * cell);
-                    if (i + j).rem_euclid(2) == 0 {
-                        out.push(vec![[x, y], [x + cell, y], [x, y + cell]]);
-                        out.push(vec![[x + cell, y], [x + cell, y + cell], [x, y + cell]]);
-                    } else {
-                        out.push(vec![[x, y], [x + cell, y], [x + cell, y + cell]]);
-                        out.push(vec![[x, y], [x + cell, y + cell], [x, y + cell]]);
-                    }
-                }
-            }
-        }
-    }
-    out
-}
-
-/// `∫0^t e^{-ks} ds` and `∫0^t ∫0^u e^{-ks} ds du` (drag-damped ballistic factors).
-fn drag_factors(k: f64, t: f64) -> (f64, f64) {
-    if k < 1e-6 {
-        (t, 0.5 * t * t)
-    } else {
-        let e = (-k * t).exp();
-        ((1.0 - e) / k, t / k - (1.0 - e) / (k * k))
-    }
-}
-/// Shatter's Front / Side / Back Mode options.
-const SHATTER_TEXTURE_MODES: [&str; 3] = ["Color", "Layer", "Tinted Layer"];
-
-/// One face's texture: a flat colour, a layer, or a layer tinted by the Textures colour.
-struct Face {
-    mode: u32,
-    img: Option<Image>,
-}
-
-impl Face {
-    fn from(ctx: &EffectCtx, b: &Buf, mode: &str, layer: &str, default_mode: u32) -> Face {
-        let mode = ctx.params.get(mode).map(|v| v.as_enum()).unwrap_or(default_mode);
-        // A face layer of None is the effect's own layer.
-        let img = (mode != 0).then(|| layer_or_self(ctx, b, layer, true, true));
-        Face { mode, img }
-    }
-}
-
-/// Group key of a Custom Shatter Map colour (pieces of one colour break as one).
-fn map_key(c: [f32; 4]) -> u32 {
-    let (c, a) = unpremul(c);
-    if a < 0.5 {
-        return u32::MAX;
-    }
-    let q = |v: f32| ((v.clamp(0.0, 1.0) * 15.0).round() as u32) & 15;
-    q(c[0]) << 8 | q(c[1]) << 4 | q(c[2])
-}
-
-fn shatter(ctx: &EffectCtx, b: Buf) -> Buf {
-    match shatter_impl(ctx, &b) {
-        ShatterPlan::Pieces(plan) => plan.finish(b),
-        ShatterPlan::Wire(plan) => plan.finish(b),
-    }
-}
-
-/// What Shatter draws: the pieces (Rendered view) or the wireframe lines.
-enum ShatterPlan {
-    Pieces(PiecePlan),
-    Wire(SpritePlan),
-}
-
-fn shatter_impl(ctx: &EffectCtx, b: &Buf) -> ShatterPlan {
-    let pr = ctx.params;
-    let view = pr.e("view");
-    let render = pr.e("render");
-    let kind = pr.e("shape/pattern");
-    let custom = kind as usize == SHATTER_PATTERNS.len() - 1;
-    let reps = pr.f("shape/repetitions").clamp(1.0, 500.0);
-    let dir = pr.f("shape/direction").to_radians();
-    let origin = pr.v2("shape/origin");
-    let forces = [
-        (pr.v2("force1/force1Position"), pr.f("force1/force1Depth"), pr.f("force1/force1Radius"), pr.f("force1/force1Strength")),
-        (pr.v2("force2/force2Position"), pr.f("force2/force2Depth"), pr.f("force2/force2Radius"), pr.f("force2/force2Strength")),
-    ];
-    let rot_speed = pr.f("physics/rotationSpeed");
-    let tumble = pr.e("physics/tumbleAxis");
-    let randomness = pr.f("physics/randomness");
-    let k = pr.f("physics/viscosity").max(0.0) * 5.0;
-    let mass_var = pr.f("physics/massVariance") / 100.0;
-    let gravity = pr.f("physics/gravity");
-    let gdir = pr.f("physics/gravityDirection").to_radians();
-    let ginc = pr.f("physics/gravityInclination").to_radians();
-    let seed = (pr.f("randomSeed") as u32).wrapping_mul(0x9e3779b1) ^ ctx.seed;
-    let [lw, lh] = ctx.layer_size;
-    let s = b.scale;
-    let t = ctx.time.max(0.0);
-    let unit = lw * 0.1;
-    let cell = lw / reps;
-    let extrude = pr.f("shape/extrusionDepth").max(0.0) * cell * s;
-    let cam = crate::card3d::projection(ctx, b);
-    let eye = cam.eye();
-    let light = Lighting::from(ctx, b);
-    // Gradient: with a gradient layer only pieces at least as bright as 1 − Shatter Threshold
-    // (Invert Gradient: as dark) break.
-    let gradient = ctx.layer_param("gradient/gradientLayer", true).map(|o| crate::util::fit_layer(ctx, b, &o, true));
-    let threshold = pr.get("gradient/shatterThreshold").map(Value::as_f64).unwrap_or(0.0) / 100.0;
-    let invert_gradient = pr.b("gradient/invertGradient");
-    // Textures.
-    let tex_color = pr.get("textures/color").map(|v| v.as_color()).unwrap_or([1.0; 4]);
-    let tex_opacity = pr.get("textures/opacity").map(Value::as_f64).unwrap_or(1.0).clamp(0.0, 1.0) as f32;
-    let front = Face::from(ctx, b, "textures/frontMode", "textures/frontLayer", 1);
-    let side = Face::from(ctx, b, "textures/sideMode", "textures/sideLayer", 0);
-    let backf = Face::from(ctx, b, "textures/backMode", "textures/backLayer", 1);
-    let custom_map = custom.then(|| layer_or_self(ctx, b, "shape/customShatterMap", true, true));
-    let white_fixed = pr.b("shape/whiteTilesFixed");
-    let (sd, cd) = dir.sin_cos();
-    let to_layer = |q: [f64; 2]| [origin[0] + q[0] * cd - q[1] * sd, origin[1] + q[0] * sd + q[1] * cd];
-    // Pattern-space bounds of the layer rectangle.
-    let corners = [[0.0, 0.0], [lw, 0.0], [lw, lh], [0.0, lh]].map(|c: [f64; 2]| {
-        let (dx, dy) = (c[0] - origin[0], c[1] - origin[1]);
-        [dx * cd + dy * sd, -dx * sd + dy * cd]
-    });
-    let (px0, px1) = (corners.iter().map(|c| c[0]).fold(f64::INFINITY, f64::min), corners.iter().map(|c| c[0]).fold(f64::NEG_INFINITY, f64::max));
-    let (py0, py1) = (corners.iter().map(|c| c[1]).fold(f64::INFINITY, f64::min), corners.iter().map(|c| c[1]).fold(f64::NEG_INFINITY, f64::max));
-    // Custom Shatter Map: square cells grouped by the map's colour.
-    let cells = pattern_cells(if custom { 3 } else { kind }, cell, px0, py0, px1, py1, seed);
-    let polys: Vec<Vec<[f64; 2]>> = cells.iter().map(|poly| poly.iter().map(|&q| to_layer(q)).collect()).collect();
-    let centre = |lp: &[[f64; 2]]| [lp.iter().map(|v| v[0]).sum::<f64>() / lp.len() as f64, lp.iter().map(|v| v[1]).sum::<f64>() / lp.len() as f64];
-    let keys: Vec<u32> = match &custom_map {
-        Some(m) => polys
-            .iter()
-            .map(|lp| {
-                let c = centre(lp);
-                map_key(m.sample_bilinear(c[0] * s + b.offset[0], c[1] * s + b.offset[1]))
-            })
-            .collect(),
-        None => (0..polys.len() as u32).collect(),
-    };
-    // Group centres (custom map) — each group moves as one rigid piece.
-    let mut groups: std::collections::HashMap<u32, ([f64; 2], f64)> = std::collections::HashMap::new();
-    for (lp, &key) in polys.iter().zip(&keys) {
-        let c = centre(lp);
-        let e = groups.entry(key).or_insert(([0.0; 2], 0.0));
-        e.0[0] += c[0];
-        e.0[1] += c[1];
-        e.1 += 1.0;
-    }
-    let g3 = [gdir.sin() * ginc.cos() * gravity * unit, -gdir.cos() * ginc.cos() * gravity * unit, ginc.sin() * gravity * unit];
-    let mut pieces: Vec<Piece> = polys
-        .par_iter()
-        .zip(keys.par_iter())
-        .flat_map_iter(|(lp, &key)| {
-            let mut out: Vec<Piece> = vec![];
-            let (mnx, mxx) = (lp.iter().map(|v| v[0]).fold(f64::INFINITY, f64::min), lp.iter().map(|v| v[0]).fold(f64::NEG_INFINITY, f64::max));
-            let (mny, mxy) = (lp.iter().map(|v| v[1]).fold(f64::INFINITY, f64::min), lp.iter().map(|v| v[1]).fold(f64::NEG_INFINITY, f64::max));
-            if mxx < 0.0 || mxy < 0.0 || mnx > lw || mny > lh || key == u32::MAX {
-                return out.into_iter();
-            }
-            let pc_c = centre(lp);
-            let (gsum, gn) = groups[&key];
-            let gc = [gsum[0] / gn, gsum[1] / gn];
-            let i = key;
-            // Broken when inside a force sphere (centred `depth` in front of the layer).
-            let mut v = [0.0f64; 3];
-            let mut broken = false;
-            for (fp, fd, fr, fs) in forces {
-                let rad = fr * lw;
-                if rad <= 0.0 {
-                    continue;
-                }
-                let dv = [gc[0] - fp[0], gc[1] - fp[1], fd * lw];
-                let dist = (dv[0] * dv[0] + dv[1] * dv[1] + dv[2] * dv[2]).sqrt();
-                if dist < rad {
-                    broken = true;
-                    let f = fs * (1.0 - dist / rad) * unit / dist.max(1e-6);
-                    for q in 0..3 {
-                        v[q] += dv[q] * f;
-                    }
-                }
-            }
-            if broken && let Some(g) = &gradient {
-                let (c, _) = unpremul(g.sample_bilinear(gc[0] * s + b.offset[0], gc[1] * s + b.offset[1]));
-                let mut l = effectcraft_color::luminance(c[0], c[1], c[2]).clamp(0.0, 1.0) as f64;
-                if invert_gradient {
-                    l = 1.0 - l;
-                }
-                broken = threshold > 0.0 && l >= 1.0 - threshold;
-            }
-            if broken && custom && white_fixed && key == 0xfff {
-                broken = false;
-            }
-            if (broken && render == 1) || (!broken && render == 2) {
-                return out.into_iter();
-            }
-            let mut gpos = [gc[0], gc[1], 0.0];
-            let mut r = rot_axis([1.0, 0.0, 0.0], 0.0);
-            let moving = broken && t > 0.0;
-            if moving {
-                let mass = 1.0 + mass_var * hs(i, 1, seed) as f64;
-                for q in 0..3 {
-                    v[q] = v[q] / mass + randomness * unit * hs(i, 2 + q as u32, seed) as f64 * 2.0;
-                }
-                let (f1, f2) = drag_factors(k, t);
-                for q in 0..3 {
-                    gpos[q] += v[q] * f1 + g3[q] * f2;
-                }
-                let axis = match tumble {
-                    1 => [0.0, 0.0, 0.0],
-                    2 => [1.0, 0.0, 0.0],
-                    3 => [0.0, 1.0, 0.0],
-                    4 => [0.0, 0.0, 1.0],
-                    5 => [hs(i, 6, seed) as f64, hs(i, 7, seed) as f64, 0.0],
-                    6 => [hs(i, 6, seed) as f64, 0.0, hs(i, 8, seed) as f64],
-                    7 => [0.0, hs(i, 7, seed) as f64, hs(i, 8, seed) as f64],
-                    _ => [hs(i, 6, seed) as f64, hs(i, 7, seed) as f64, hs(i, 8, seed) as f64],
-                };
-                let speed = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt() / unit;
-                let omega = rot_speed * std::f64::consts::TAU * (0.5 + h(i, 9, seed) as f64) * speed.min(10.0);
-                r = rot_axis(axis, omega * f1);
-            }
-            // The piece's centre: its offset from the group centre, rotated with the group.
-            let off = [pc_c[0] - gc[0], pc_c[1] - gc[1], 0.0];
-            let pos: [f64; 3] = std::array::from_fn(|q| gpos[q] + (0..3).map(|k| r[q][k] * off[k]).sum::<f64>());
-            let tex: Vec<[f32; 2]> = lp.iter().map(|v| [(v[0] * s + b.offset[0]) as f32, (v[1] * s + b.offset[1]) as f32]).collect();
-            let c0 = [(pc_c[0] * s + b.offset[0]) as f32, (pc_c[1] * s + b.offset[1]) as f32];
-            let posb = [pos[0] * s + b.offset[0], pos[1] * s + b.offset[1], pos[2] * s];
-            let Some(mut pc) = Piece::new(&tex, c0, &r, posb, cam) else { return out.into_iter() };
-            pc.light(&light, &r, posb, eye);
-            pc.alpha = tex_opacity;
-            let face = if pc.back { &backf } else { &front };
-            if face.mode == 0 {
-                pc.flat = Some([tex_color[0], tex_color[1], tex_color[2]]);
-            } else if face.mode == 2 {
-                pc.tint = std::array::from_fn(|q| pc.tint[q] * tex_color[q]);
-            }
-            // Extrusion: the sides of a moving piece, from its front outline back by the depth.
-            if moving && extrude > 0.0 {
-                let nb = [r[0][2], r[1][2], r[2][2]];
-                let n = tex.len();
-                for e in 0..n {
-                    let (a, bv) = (tex[e], tex[(e + 1) % n]);
-                    let ed = [(bv[0] - a[0]) as f64, (bv[1] - a[1]) as f64];
-                    let len = (ed[0] * ed[0] + ed[1] * ed[1]).sqrt();
-                    if len < 1e-6 {
-                        continue;
-                    }
-                    let ew: [f64; 3] = std::array::from_fn(|q| (r[q][0] * ed[0] + r[q][1] * ed[1]) / len);
-                    let third = [ew[1] * nb[2] - ew[2] * nb[1], ew[2] * nb[0] - ew[0] * nb[2], ew[0] * nb[1] - ew[1] * nb[0]];
-                    let rs: M3 = std::array::from_fn(|q| [ew[q], nb[q], third[q]]);
-                    // Side centre in world: edge midpoint (world) plus half the depth backwards.
-                    let mid = [((a[0] + bv[0]) * 0.5 - c0[0]) as f64, ((a[1] + bv[1]) * 0.5 - c0[1]) as f64];
-                    let mw: [f64; 3] = std::array::from_fn(|q| posb[q] + r[q][0] * mid[0] + r[q][1] * mid[1] + nb[q] * extrude * 0.5);
-                    let (hl, hd) = ((len * 0.5) as f32, (extrude * 0.5) as f32);
-                    let cs = [(a[0] + bv[0]) * 0.5, (a[1] + bv[1]) * 0.5];
-                    let quad = [[cs[0] - hl, cs[1] - hd], [cs[0] + hl, cs[1] - hd], [cs[0] + hl, cs[1] + hd], [cs[0] - hl, cs[1] + hd]];
-                    if let Some(mut sp) = Piece::new(&quad, cs, &rs, mw, cam) {
-                        sp.light(&light, &rs, mw, eye);
-                        sp.alpha = tex_opacity;
-                        let colour = match (&side.img, side.mode) {
-                            (Some(img), m) if m != 0 => {
-                                let (c, _) = unpremul(img.sample_bilinear(cs[0] as f64, cs[1] as f64));
-                                if m == 2 { std::array::from_fn(|q| c[q] * tex_color[q]) } else { c }
-                            }
-                            _ => [tex_color[0], tex_color[1], tex_color[2]],
-                        };
-                        sp.flat = Some(colour);
-                        out.push(sp);
-                    }
-                }
-            }
-            out.push(pc);
-            out.into_iter()
-        })
-        .collect();
-    sort_far_first(&mut pieces);
-    if view == 0 {
-        let tex = |i: &Option<Image>| i.clone().map(PieceTex::Image);
-        let front_t = tex(&front.img).unwrap_or(PieceTex::Layer);
-        let back_t = tex(&backf.img).unwrap_or_else(|| front_t.clone());
-        return ShatterPlan::Pieces(PiecePlan { pieces, front: front_t, back: Some(back_t) });
-    }
-    {
-        // Wireframes: piece outlines (front view: at rest; otherwise animated), plus forces.
-        let animated = view == 2 || view == 4;
-        let mut lines = Vec::new();
-        for pc in &pieces {
-            let n = pc.n as usize;
-            let pts: Vec<[f32; 2]> = if animated {
-                let fw = inv3(&pc.inv);
-                match fw {
-                    Some(m) => pc.poly[..n]
-                        .iter()
-                        .map(|v| {
-                            let (a, bb) = ((v[0] - pc.c0[0]) as f64, (v[1] - pc.c0[1]) as f64);
-                            let w = m[2][0] * a + m[2][1] * bb + m[2][2];
-                            [((m[0][0] * a + m[0][1] * bb + m[0][2]) / w) as f32, ((m[1][0] * a + m[1][1] * bb + m[1][2]) / w) as f32]
-                        })
-                        .collect(),
-                    None => continue,
-                }
-            } else {
-                pc.poly[..n].to_vec()
-            };
-            for e in 0..n {
-                let (a, c) = (pts[e], pts[(e + 1) % n]);
-                lines.push(Sprite::new(a[0], a[1], 0.5, [0.75, 0.85, 1.0, 1.0], Shape::Line { dx: c[0] - a[0], dy: c[1] - a[1] }));
-            }
-        }
-        if view >= 3 {
-            for (fp, _, fr, _) in forces {
-                let (fx, fy) = b.to_px(fp);
-                let rad = fr * lw * s;
-                for k in 0..64 {
-                    let (a0, a1) = (k as f64 / 64.0 * std::f64::consts::TAU, (k + 1) as f64 / 64.0 * std::f64::consts::TAU);
-                    let (x0, y0) = (fx + rad * a0.cos(), fy + rad * a0.sin());
-                    let (x1, y1) = (fx + rad * a1.cos(), fy + rad * a1.sin());
-                    lines.push(Sprite::new(x0 as f32, y0 as f32, 0.5, [1.0, 0.3, 0.3, 1.0], Shape::Line { dx: (x1 - x0) as f32, dy: (y1 - y0) as f32 }));
-                }
-            }
-        }
-        ShatterPlan::Wire(SpritePlan { sprites: lines, tints: vec![], acc: Acc::Over, post: Post::Replace })
-    }
-}
-
-// ------------------------------------------------------------------ Caustics
-
-/// Sample with repeat mode: 0 Once (transparent outside), 1 Tiled, 2 Reflected.
-fn sample_repeat(img: &Image, x: f64, y: f64, mode: u32) -> Px {
-    let (w, hh) = (img.width as f64, img.height as f64);
-    match mode {
-        1 => img.sample_bilinear_clamped(x.rem_euclid(w), y.rem_euclid(hh)),
-        2 => {
-            let m = |v: f64, n: f64| {
-                let r = v.rem_euclid(2.0 * n);
-                if r > n { 2.0 * n - r } else { r }
-            };
-            img.sample_bilinear_clamped(m(x, w), m(y, hh))
-        }
-        _ => img.sample_bilinear(x, y),
-    }
-}
-
-/// Everything Caustics' per-pixel pass needs, prepared on the CPU (the other layers it reads
-/// and the parameter conversions); the layer's own pixels are not read.
-pub struct CausticsSetup {
-    /// The Bottom layer fitted to the buffer, `None` = the layer itself.
-    pub bottom: Option<Image>,
-    /// Gaussian σ (buffer px) blurring the bottom (transparent edges), 0 = none.
-    pub bottom_sigma: f64,
-    /// The water surface's height field (smoothed luminance), `None` = flat.
-    pub height: Option<Plane>,
-    /// The Sky layer fitted to the buffer.
-    pub sky: Option<Image>,
-    pub scaling: f64,
-    pub repeat: u32,
-    pub wave_h: f64,
-    /// Displacement per unit of height gradient.
-    pub k: f64,
-    /// Layer centre (buffer px).
-    pub cx: f64,
-    pub cy: f64,
-    /// Layer width (buffer px).
-    pub lw: f64,
-    pub surf: [f32; 4],
-    pub surf_op: f32,
-    pub cstr: f32,
-    pub lc: [f32; 4],
-    pub li: f32,
-    /// Light position (buffer px) and height (layer widths); `point` = from the position to
-    /// each pixel, else one direction from above the layer centre.
-    pub lx: f64,
-    pub ly: f64,
-    pub lheight: f64,
-    pub point: bool,
-    pub ambient: f32,
-    pub diffuse: f32,
-    pub specular: f32,
-    pub sharp: f32,
-    pub sky_scaling: f64,
-    pub sky_repeat: u32,
-    pub sky_int: f32,
-    pub convergence: f64,
-}
-
-/// Caustics' setup for layer geometry `b` (see [`CausticsSetup`]).
-pub fn caustics_setup(ctx: &EffectCtx, b: &Buf) -> CausticsSetup {
-    let pr = ctx.params;
-    let s = b.scale;
-    let bottom = ctx.layer_param("bottom/bottom", true).map(|o| crate::util::fit_layer(ctx, b, &o, pr.e("bottom/bottomSizeDiffers") == 1));
-    let blur = pr.f("bottom/blur") * s;
-    let wave_h = pr.f("water/waveHeight");
-    let smoothing = pr.f("water/smoothing") * s;
-    let depth = pr.f("water/waterDepth");
-    let ior = pr.f("water/refractiveIndex").max(1.0);
-    let lpos = pr.v2("lighting/lightPosition");
-    // Height field of the water surface (luminance of the chosen layer; none = flat).
-    let height = ctx.layer_param("water/waterSurface", true).map(|o| {
-        let img = crate::util::fit_layer(ctx, b, &o, true);
-        let pl = Plane::luma(&img);
-        if smoothing > 0.05 { gauss_plane(&pl, smoothing * 0.5, smoothing * 0.5) } else { pl }
-    });
-    let lw = ctx.layer_size[0] * s;
-    let k = wave_h * depth * (1.0 - 1.0 / ior) * lw * 2.0;
-    let (cx, cy) = (b.offset[0] + ctx.layer_size[0] * 0.5 * s, b.offset[1] + ctx.layer_size[1] * 0.5 * s);
-    let (lx, ly) = b.to_px(lpos);
-    let (lc, li, lheight) = (pr.color("lighting/lightColor"), pr.f("lighting/lightIntensity") as f32, pr.f("lighting/lightHeight").max(0.01));
-    // Light Type: Distant Source (one direction, from the light position above the layer
-    // centre), Point Source (from the light position to each pixel) or First Comp Light.
-    let light_type = pr.e("lighting/lightType");
-    let comp_light = if light_type == 2 { ctx.env.host.and_then(|h| h.comp_scene()).and_then(|sc| sc.light) } else { None };
-    let (lc, li, lx, ly, lheight, point) = match (light_type, comp_light) {
-        (2, Some(l)) => {
-            let c = [l.color[0], l.color[1], l.color[2], 1.0];
-            // Comp space: z away from the viewer; the light above the water is at −z.
-            let (px, py) = (l.pos[0] * s + b.offset[0], l.pos[1] * s + b.offset[1]);
-            (c, li, px, py, (-l.pos[2] / ctx.layer_size[0].max(1.0)).max(0.01), l.kind == 1)
-        }
-        (2, None) => (lc, 0.0, lx, ly, lheight, false),
-        (1, _) => (lc, li, lx, ly, lheight, true),
-        _ => (lc, li, lx, ly, lheight, false),
-    };
-    // Sky: the layer the water surface reflects (Surface Opacity 1 = a mirror of it).
-    let sky = ctx.layer_param("sky/sky", true).map(|o| crate::util::fit_layer(ctx, b, &o, pr.e("sky/skySizeDiffers") == 1));
-    CausticsSetup {
-        bottom,
-        bottom_sigma: if blur > 0.05 { blur * 0.5 } else { 0.0 },
-        height,
-        sky,
-        scaling: pr.f("bottom/scaling").max(0.01),
-        repeat: pr.e("bottom/repeatMode"),
-        wave_h,
-        k,
-        cx,
-        cy,
-        lw,
-        surf: pr.color("water/surfaceColor"),
-        surf_op: pr.f("water/surfaceOpacity") as f32,
-        cstr: pr.f("water/causticsStrength") as f32,
-        lc,
-        li,
-        lx,
-        ly,
-        lheight,
-        point,
-        ambient: pr.f("lighting/ambientLight") as f32,
-        diffuse: pr.f("material/diffuse") as f32,
-        specular: pr.f("material/specular") as f32,
-        sharp: pr.f("material/highlightSharpness").max(1.0) as f32,
-        sky_scaling: pr.get("sky/scaling").map(Value::as_f64).unwrap_or(1.0).max(0.01),
-        sky_repeat: pr.e("sky/repeatMode"),
-        sky_int: pr.get("sky/intensity").map(Value::as_f64).unwrap_or(0.3) as f32,
-        convergence: pr.get("sky/convergence").map(Value::as_f64).unwrap_or(0.5).clamp(0.0, 1.0),
-    }
-}
-
-fn caustics(ctx: &EffectCtx, mut b: Buf) -> Buf {
-    let st = caustics_setup(ctx, &b);
-    let mut bottom = st.bottom.clone().unwrap_or_else(|| b.img.clone());
-    if st.bottom_sigma > 0.0 {
-        bottom = effectcraft_raster::gaussian_blur(&bottom, st.bottom_sigma, st.bottom_sigma, false);
-    }
-    let CausticsSetup {
-        scaling,
-        repeat,
-        wave_h,
-        k,
-        cx,
-        cy,
-        lw,
-        surf,
-        surf_op,
-        cstr,
-        lc,
-        li,
-        lx,
-        ly,
-        lheight,
-        point,
-        ambient,
-        diffuse,
-        specular,
-        sharp,
-        sky_scaling,
-        sky_repeat,
-        sky_int,
-        convergence,
-        ..
-    } = st;
-    let (height, sky) = (&st.height, &st.sky);
-    let (w, hh) = (b.img.width as usize, b.img.height as usize);
-    let norm3 = |v: [f64; 3]| {
-        let n = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt().max(1e-12);
-        [(v[0] / n) as f32, (v[1] / n) as f32, (v[2] / n) as f32]
-    };
-    let lv_at = |x: f64, y: f64| {
-        if point {
-            norm3([(lx - x) / lw.max(1.0), (ly - y) / lw.max(1.0), lheight])
-        } else {
-            norm3([(lx - cx) / lw.max(1.0), (ly - cy) / lw.max(1.0), lheight])
-        }
-    };
-    let grad = |x: usize, y: usize| -> (f64, f64) {
-        match height {
-            Some(pl) => {
-                let gx = (pl.get_clamped(x as i64 + 1, y as i64) - pl.get_clamped(x as i64 - 1, y as i64)) as f64 * 0.5;
-                let gy = (pl.get_clamped(x as i64, y as i64 + 1) - pl.get_clamped(x as i64, y as i64 - 1)) as f64 * 0.5;
-                (gx, gy)
-            }
-            None => (0.0, 0.0),
-        }
-    };
-    // Displacement and its Jacobian (caustic focusing) per pixel.
-    let disp: Vec<(f64, f64)> = (0..w * hh)
-        .into_par_iter()
-        .map(|i| {
-            let (gx, gy) = grad(i % w, i / w);
-            (-gx * k, -gy * k)
-        })
-        .collect();
-    b.img.rows_mut().for_each(|(y, row)| {
-        for (x, px) in row.iter_mut().enumerate() {
-            let i = y * w + x;
-            let (dx, dy) = disp[i];
-            let d = |xx: usize, yy: usize| disp[yy.min(hh - 1) * w + xx.min(w - 1)];
-            let (dxr, _) = d(x + 1, y);
-            let (_, dyd) = d(x, y + 1);
-            let (dxl, _) = d(x.saturating_sub(1), y);
-            let (_, dyu) = d(x, y.saturating_sub(1));
-            let jac = (1.0 + (dxr - dxl) * 0.5) * (1.0 + (dyd - dyu) * 0.5);
-            let focus = ((1.0 / jac.abs().max(0.2)) as f32 - 1.0).clamp(-1.0, 4.0);
-            let sx = cx + (x as f64 + 0.5 + dx - cx) / scaling;
-            let sy = cy + (y as f64 + 0.5 + dy - cy) / scaling;
-            let p = sample_repeat(&bottom, sx, sy, repeat);
-            let (c, a) = unpremul(p);
-            let (gx, gy) = grad(x, y);
-            let n = {
-                let v = [-gx * wave_h * 20.0, -gy * wave_h * 20.0, 1.0];
-                let m = (v[0] * v[0] + v[1] * v[1] + 1.0).sqrt();
-                [(v[0] / m) as f32, (v[1] / m) as f32, (v[2] / m) as f32]
-            };
-            let lv = lv_at(x as f64 + 0.5, y as f64 + 0.5);
-            let nl = (n[0] * lv[0] + n[1] * lv[1] + n[2] * lv[2]).max(0.0);
-            let hv = {
-                let v = [lv[0], lv[1], lv[2] + 1.0];
-                let m = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
-                [v[0] / m, v[1] / m, v[2] / m]
-            };
-            let spec = (n[0] * hv[0] + n[1] * hv[1] + n[2] * hv[2]).max(0.0).powf(sharp) * specular * li;
-            let light = ambient + diffuse * li * nl + cstr * focus * li;
-            // The surface: its colour lit like the water, or the sky it reflects (sampled along
-            // the surface normal; Convergence pulls the reflection towards the pixel itself).
-            let surface: [f32; 3] = match &sky {
-                Some(sk) => {
-                    let reach = (1.0 - convergence) * lw * 0.5;
-                    let (rx, ry) = (x as f64 + 0.5 + n[0] as f64 * reach, y as f64 + 0.5 + n[1] as f64 * reach);
-                    let (rx, ry) = (cx + (rx - cx) / sky_scaling, cy + (ry - cy) / sky_scaling);
-                    let (sc, _) = unpremul(sample_repeat(sk, rx, ry, sky_repeat));
-                    std::array::from_fn(|q| sc[q] * sky_int * 3.0 * surf[q])
-                }
-                None => std::array::from_fn(|q| surf[q] * (ambient + diffuse * li * nl)),
-            };
-            let cc: [f32; 3] = std::array::from_fn(|q| {
-                let base = c[q] * light * lc[q];
-                base * (1.0 - surf_op) + surface[q] * surf_op + spec * lc[q]
-            });
-            let a = (a + surf_op * (1.0 - a)).min(1.0);
-            *px = [cc[0] * a, cc[1] * a, cc[2] * a, a];
-        }
-    });
-    b
-}
-
-// ------------------------------------------------------------------ Wave World
-
-/// Wave World's simulated surface: an `nx` × `ny` grid of heights `u` and velocities `v`.
-#[derive(Clone, Debug)]
-pub struct Waves {
-    pub nx: usize,
-    pub ny: usize,
-    pub u: Vec<f32>,
-    pub v: Vec<f32>,
-}
-
-struct Producer {
-    ring: bool,
-    pos: [f32; 2],
-    len: f32,
-    width: f32,
-    angle: f32,
-    amp: f32,
-    freq: f32,
-    phase: f32,
-}
-
-impl Producer {
-    /// Weight of a grid point (layer-fraction coordinates, x in widths, y in widths).
-    fn weight(&self, x: f32, y: f32) -> f32 {
-        let (dx, dy) = (x - self.pos[0], y - self.pos[1]);
-        let (sa, ca) = self.angle.sin_cos();
-        let (u, v) = (dx * ca + dy * sa, -dx * sa + dy * ca);
-        let d = if self.ring {
-            let (a, bb) = ((self.len * 0.5).max(1e-3), (self.width * 0.5).max(1e-3));
-            ((u / a).powi(2) + (v / bb).powi(2)).sqrt()
-        } else {
-            let l = (self.len * 0.5).max(1e-3);
-            let wd = (self.width * 0.5).max(1e-3);
-            (u.abs() / l).max(v.abs() / wd)
-        };
-        (1.0 - d).clamp(0.0, 1.0).min(1.0)
-    }
-}
-
-static WAVE_CACHE: SimCache<Waves> = SimCache::new(4);
-
-/// What Wave World draws: the Height Map view of the simulated surface (grid heights and,
-/// with a ground layer, water depths per grid point), or the wireframe preview's lines.
-pub enum WavePlan {
-    Height { st: std::sync::Arc<Waves>, depth: Option<Vec<f32>> },
-    Wire(crate::sim::SpritePlan),
-}
-
-fn wave_world(ctx: &EffectCtx, b: Buf) -> Buf {
-    match wave_world_impl(ctx, &b, false) {
-        Ok(img) => Buf { img, ..b },
-        Err(WavePlan::Wire(plan)) => plan.finish(b),
-        Err(WavePlan::Height { .. }) => b,
-    }
-}
-
-/// Wave World's simulation state for the frame, as a [`WavePlan`] (its pixels are not read).
-pub fn wave_world_plan(ctx: &EffectCtx, b: &Buf) -> Option<WavePlan> {
-    wave_world_impl(ctx, b, true).err()
-}
-
-fn wave_world_impl(ctx: &EffectCtx, b: &Buf, plan_only: bool) -> Result<Image, WavePlan> {
-    let pr = ctx.params;
-    let [lw, lh] = ctx.layer_size;
-    let res = pr.f("simulation/gridResolution").clamp(1.0, 400.0) as usize;
-    let res = if pr.b("simulation/gridResDownsamples") { ((res as f64) * b.scale).round().max(1.0) as usize } else { res };
-    let nx = res.max(2) + 1;
-    let ny = ((res as f64 * lh / lw.max(1.0)).round() as usize).max(2) + 1;
-    let speed = pr.f("simulation/waveSpeed").max(0.0) as f32;
-    let damping = pr.f("simulation/damping").max(0.0) as f32;
-    let reflect = pr.e("simulation/reflectEdges");
-    let preroll = pr.f("simulation/preRoll").max(0.0);
-    let prods: Vec<Producer> = [1, 2]
-        .iter()
-        .map(|k| {
-            let pos = pr.v2(&format!("producer{k}/producer{k}Position"));
-            Producer {
-                ring: pr.e(&format!("producer{k}/producer{k}Type")) == 0,
-                pos: [(pos[0] / lw.max(1.0)) as f32, (pos[1] / lw.max(1.0)) as f32],
-                len: pr.f(&format!("producer{k}/producer{k}Length")) as f32,
-                width: pr.f(&format!("producer{k}/producer{k}Width")) as f32,
-                angle: (pr.f(&format!("producer{k}/producer{k}Angle")) as f32).to_radians(),
-                amp: pr.f(&format!("producer{k}/producer{k}Amplitude")) as f32,
-                freq: pr.f(&format!("producer{k}/producer{k}Frequency")) as f32,
-                phase: (pr.f(&format!("producer{k}/producer{k}Phase")) as f32).to_radians(),
-            }
-        })
-        .collect();
-    let sps = crate::sim::SPS as f32;
-    // Wave speed in layer widths per second → cells per second; sub-steps keep it stable.
-    let cps = speed * (nx - 1) as f32;
-    let sub = ((cps * 2.0 / sps).ceil() as usize).clamp(1, 64);
-    let dt = 1.0 / (sps * sub as f32);
-    let cell = 1.0 / (nx - 1) as f32;
-    let weights: Vec<Vec<f32>> = prods.iter().map(|p| (0..nx * ny).map(|i| p.weight((i % nx) as f32 * cell, (i / nx) as f32 * cell)).collect()).collect();
-    // Ground: the ground layer's first frame, its luminance an elevation (× Steepness). Where
-    // it rises above Height the grid is dry (a wall the waves reflect from); shallow water
-    // slows the waves by Wave Strength.
-    let ground = pr.get("ground/ground").and_then(Value::as_layer).and_then(|id| {
-        let host = ctx.env.host?;
-        host.layer_at(id, ctx.env.comp_time - ctx.time, true)
-    });
-    let steep = pr.get("ground/steepness").map(Value::as_f64).unwrap_or(0.25) as f32;
-    let level = pr.get("ground/height").map(Value::as_f64).unwrap_or(0.25) as f32;
-    let wave_strength = pr.f("ground/waveStrength").clamp(0.0, 1.0) as f32;
-    // Water depth per grid point (None without ground: deep everywhere).
-    let depth: Option<Vec<f32>> = ground.as_ref().map(|lp| {
-        let (gw, gh) = (lp.size[0].max(1.0), lp.size[1].max(1.0));
-        (0..nx * ny)
-            .map(|i| {
-                let (fx, fy) = ((i % nx) as f64 / (nx - 1) as f64, (i / nx) as f64 / (ny - 1) as f64);
-                let (c, a) = unpremul(lp.buf.img.sample_bilinear_clamped(fx * gw * lp.buf.scale + lp.buf.offset[0], fy * gh * lp.buf.scale + lp.buf.offset[1]));
-                level - steep * effectcraft_color::luminance(c[0], c[1], c[2]) * a
-            })
-            .collect()
-    });
-    let speed_k: Vec<f32> = match &depth {
-        Some(d) => d.iter().map(|&v| if v <= 0.0 { 0.0 } else { 1.0 - wave_strength * (1.0 - (v / level.max(1e-3)).clamp(0.0, 1.0).sqrt()) }).collect(),
-        None => vec![1.0; nx * ny],
-    };
-    let mut key =
-        params_key(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: if pr.b("simulation/gridResDownsamples") { b.scale } else { 1.0 } }, 4);
-    if let Some(d) = &depth {
-        key ^= d.iter().fold(0u64, |a, v| a.rotate_left(3) ^ v.to_bits() as u64);
-    }
-    let steps = crate::sim::steps_at(ctx.time + preroll);
-    let st = WAVE_CACHE.run(
-        key,
-        steps,
-        || Waves { nx, ny, u: vec![0.0; nx * ny], v: vec![0.0; nx * ny] },
-        |w, step| {
-            for k in 0..sub {
-                let t = (step as f32 + k as f32 / sub as f32) / sps - preroll as f32;
-                let c2 = cps * cps;
-                let mut acc = vec![0.0f32; nx * ny];
-                for y in 0..ny {
-                    for x in 0..nx {
-                        let i = y * nx + x;
-                        let g = |xx: usize, yy: usize| w.u[yy * nx + xx];
-                        let l = g(x.saturating_sub(1), y) + g((x + 1).min(nx - 1), y) + g(x, y.saturating_sub(1)) + g(x, (y + 1).min(ny - 1)) - 4.0 * w.u[i];
-                        acc[i] = c2 * speed_k[i] * speed_k[i] * l - damping * 4.0 * w.v[i];
-                    }
-                }
-                for i in 0..nx * ny {
-                    w.v[i] += acc[i] * dt;
-                    w.u[i] += w.v[i] * dt;
-                }
-                // Producers drive the surface.
-                for (p, wt) in prods.iter().zip(&weights) {
-                    if p.amp == 0.0 {
-                        continue;
-                    }
-                    let target = p.amp * (std::f32::consts::TAU * p.freq * t + p.phase).sin();
-                    for i in 0..nx * ny {
-                        if wt[i] > 0.0 {
-                            w.u[i] += (target - w.u[i]) * wt[i];
-                            w.v[i] *= 1.0 - wt[i];
-                        }
-                    }
-                }
-                // Dry ground holds the surface flat.
-                for i in 0..nx * ny {
-                    if speed_k[i] <= 0.0 {
-                        w.u[i] = 0.0;
-                        w.v[i] = 0.0;
-                    }
-                }
-                // Edges: reflective ones mirror; the others absorb in a thin sponge layer.
-                let refl = |side: u32| reflect == 5 || reflect == side;
-                let sponge = 4usize.min(nx / 4).max(1);
-                for y in 0..ny {
-                    for x in 0..nx {
-                        let i = y * nx + x;
-                        let mut f = 1.0f32;
-                        if !refl(1) && x < sponge {
-                            f = f.min(x as f32 / sponge as f32);
-                        }
-                        if !refl(3) && nx - 1 - x < sponge {
-                            f = f.min((nx - 1 - x) as f32 / sponge as f32);
-                        }
-                        if !refl(2) && y < sponge {
-                            f = f.min(y as f32 / sponge as f32);
-                        }
-                        if !refl(4) && ny - 1 - y < sponge {
-                            f = f.min((ny - 1 - y) as f32 / sponge as f32);
-                        }
-                        if f < 1.0 {
-                            let k = 0.85 + 0.15 * f;
-                            w.u[i] *= k;
-                            w.v[i] *= k;
-                        }
-                    }
-                }
-            }
-        },
-    );
-    let s = b.scale;
-    let (bw, bh) = (b.img.width, b.img.height);
-    let sample = |x: f64, y: f64| -> f32 {
-        let gx = (x / lw.max(1.0) * (st.nx - 1) as f64).clamp(0.0, (st.nx - 1) as f64);
-        let gy = (y / lw.max(1.0) * (st.nx - 1) as f64).clamp(0.0, (st.ny - 1) as f64);
-        let (x0, y0) = (gx.floor() as usize, gy.floor() as usize);
-        let (x1, y1) = ((x0 + 1).min(st.nx - 1), (y0 + 1).min(st.ny - 1));
-        let (tx, ty) = ((gx - x0 as f64) as f32, (gy - y0 as f64) as f32);
-        let g = |xx: usize, yy: usize| st.u[yy * st.nx + xx];
-        let a = g(x0, y0) + (g(x1, y0) - g(x0, y0)) * tx;
-        let c = g(x0, y1) + (g(x1, y1) - g(x0, y1)) * tx;
-        a + (c - a) * ty
-    };
-    if plan_only && pr.e("view") == 1 {
-        return Err(WavePlan::Height { st, depth });
-    }
-    if pr.e("view") == 1 {
-        let mut img = Image::new(bw, bh);
-        let bright = pr.f("heightMapControls/brightness") as f32;
-        let contrast = pr.f("heightMapControls/contrast") as f32;
-        let gamma = pr.f("heightMapControls/gamma").max(0.01) as f32;
-        let alpha = 1.0 - pr.f("heightMapControls/transparency") as f32;
-        let dry_transparent = pr.e("heightMapControls/renderDryAreasAs") == 1;
-        let dry_at = |x: f64, y: f64| -> bool {
-            let Some(d) = &depth else { return false };
-            let gx = (x / lw.max(1.0) * (st.nx - 1) as f64).round().clamp(0.0, (st.nx - 1) as f64) as usize;
-            let gy = (y / lw.max(1.0) * (st.nx - 1) as f64).round().clamp(0.0, (st.ny - 1) as f64) as usize;
-            d[gy * st.nx + gx] <= 0.0
-        };
-        img.rows_mut().for_each(|(y, row)| {
-            for (x, px) in row.iter_mut().enumerate() {
-                let lx = (x as f64 + 0.5 - b.offset[0]) / s;
-                let ly = (y as f64 + 0.5 - b.offset[1]) / s;
-                let v = (bright + contrast * sample(lx, ly)).clamp(0.0, 1.0).powf(1.0 / gamma);
-                let al = if dry_transparent && dry_at(lx, ly) { 0.0 } else { alpha };
-                *px = [v * al, v * al, v * al, al];
-            }
-        });
-        Ok(img)
-    } else {
-        // Wireframe preview: the grid turned by Horizontal Rotation about the vertical axis,
-        // tilted by Vertical Rotation, heights scaled by Vertical Scale.
-        let hr = pr.f("wireframeControls/horizontalRotation").to_radians();
-        let vr = pr.get("wireframeControls/verticalRotation").map(Value::as_f64).unwrap_or(53.0).to_radians();
-        let vs = pr.get("wireframeControls/verticalScale").map(Value::as_f64).unwrap_or(0.5);
-        let (sh, ch) = hr.sin_cos();
-        let (sv, cv) = vr.sin_cos();
-        let to = |x: usize, y: usize| -> [f32; 2] {
-            // Grid point relative to the layer centre (layer px), height in layer px.
-            let gx = x as f64 / (st.nx - 1) as f64 * lw - lw * 0.5;
-            let gy = y as f64 / (st.nx - 1) as f64 * lw - (st.ny - 1) as f64 / (st.nx - 1) as f64 * lw * 0.5;
-            let hgt = st.u[y * st.nx + x] as f64 * vs * lh * 0.5;
-            let (rx, ry) = (gx * ch - gy * sh, gx * sh + gy * ch);
-            let (px, py) = b.to_px([lw * 0.5 + rx, lh * 0.5 + ry * cv - hgt * sv]);
-            [px as f32, py as f32]
-        };
-        let mut lines = Vec::new();
-        for y in 0..st.ny {
-            for x in 0..st.nx {
-                let a = to(x, y);
-                if x + 1 < st.nx {
-                    let c = to(x + 1, y);
-                    lines.push(Sprite::new(a[0], a[1], 0.4, [0.4, 0.9, 0.4, 1.0], Shape::Line { dx: c[0] - a[0], dy: c[1] - a[1] }));
-                }
-                if y + 1 < st.ny {
-                    let c = to(x, y + 1);
-                    lines.push(Sprite::new(a[0], a[1], 0.4, [0.4, 0.9, 0.4, 1.0], Shape::Line { dx: c[0] - a[0], dy: c[1] - a[1] }));
-                }
-            }
-        }
-        let plan = crate::sim::SpritePlan { sprites: lines, tints: vec![], acc: Acc::Over, post: crate::sim::Post::OverBlack };
-        if plan_only {
-            return Err(WavePlan::Wire(plan));
-        }
-        Ok(plan.finish(Buf { img: Image::new(bw, bh), offset: b.offset, scale: b.scale }).img)
-    }
-}
-
-// ------------------------------------------------------------------ Foam
-
-#[derive(Clone, Debug)]
-struct FoamBubble {
-    p: [f32; 2],
-    v: [f32; 2],
-    age: f32,
-    size: f32,
-    /// Spin (radians) for Physical Orientation.
-    spin: f32,
-    id: u32,
-}
-
-#[derive(Clone, Debug, Default)]
-struct FoamState {
-    b: Vec<FoamBubble>,
-    carry: f32,
-    next: u32,
-}
-
-static FOAM_CACHE: SimCache<FoamState> = SimCache::new(4);
-
-/// Foam steps once per frame at 30 frames per second.
-const FOAM_FPS: f64 = 30.0;
-
-/// Foam's Bubble Texture options (the last uses Bubble Texture Layer).
-const FOAM_TEXTURES: [&str; 6] = ["Default Bubble", "Spit", "Bubblegum", "Dishwater", "Milky", "User Defined"];
-
-/// Age (in simulation steps) at which bubble `id` pops: its lifespan, shortened at random for
-/// frail bubbles (`frailty` 0 = every bubble reaches `lifespan`, 1 = uniformly early).
-fn foam_pop_age(id: u32, lifespan: f32, frailty: f32, seed: u32) -> f32 {
-    lifespan * (1.0 - frailty * (hs(id, 11, seed) * 0.5 + 0.5))
-}
-
-/// Foam: bubbles born in the producer rectangle grow to their size, drift with the wind,
-/// turbulence and the Flow Map (bubbles run downhill on its luminance), repel and stick to each
-/// other, wobble, and pop at the end of their (Strength-shortened) lifespan, pushing their
-/// neighbours away at Pop Velocity. Rendered bubbles use a built-in texture or the Bubble
-/// Texture Layer, oriented by Bubble Orientation, and reflect the Environment Map.
-fn foam(ctx: &EffectCtx, b: Buf) -> Buf {
-    foam_full_plan(ctx, &b).finish(b)
-}
-
-/// Foam's bubbles as sprites, `None` when it draws more than sprites (a User Defined bubble
-/// texture, an Environment Map reflection or the Draft + Flow Map view's flow map).
-pub(crate) fn foam_plan(ctx: &EffectCtx, b: &Buf) -> Option<crate::sim::SpritePlan> {
-    let plan = foam_full_plan(ctx, b);
-    (plan.user.is_none() && plan.env.is_none() && plan.flow.is_none()).then_some(plan.sprites)
-}
-
-/// A bubble disc filled by Foam's User Defined texture (buffer px; `rot` radians).
-#[derive(Clone, Copy, Debug)]
-pub struct FoamDisc {
-    pub x: f64,
-    pub y: f64,
-    pub r: f32,
-    pub rot: f32,
-    pub fade: f32,
-}
-
-/// Foam's Environment Map reflection: the map fitted to the buffer, Reflection Convergence and
-/// Strength, and the bubble discs reflecting it (`rot` and `fade` unused).
-pub struct FoamEnv {
-    pub img: Image,
-    pub conv: f64,
-    pub strength: f32,
-    pub discs: Vec<FoamDisc>,
-}
-
-/// What Foam draws this frame over a transparent frame of the layer's size: the bubble sprites,
-/// then the User Defined texture's discs, the Environment Map's reflections and (Draft + Flow
-/// Map) the flow map under it all, each [`foam_disc`]-composited in bubble order.
-pub struct FoamPlan {
-    pub sprites: crate::sim::SpritePlan,
-    pub user: Option<(crate::LayerPixels, Vec<FoamDisc>)>,
-    pub env: Option<FoamEnv>,
-    /// The flow map fitted to the buffer.
-    pub flow: Option<Image>,
-}
-
-impl FoamPlan {
-    pub fn finish(&self, b: Buf) -> Buf {
-        let mut out = splat(b.img.width, b.img.height, &self.sprites.sprites, self.sprites.acc);
-        // User Defined: the texture layer fills each bubble's disc.
-        if let Some((tex, discs)) = &self.user {
-            for d in discs {
-                let (rot, fade) = (d.rot, d.fade);
-                foam_disc(&mut out, d.x, d.y, d.r as f64, |u, v| {
-                    // u, v in −1..1 across the bubble, rotated into the texture.
-                    let (sr, cr) = rot.sin_cos();
-                    let (tu, tv) = (u as f32 * cr + v as f32 * sr, -u as f32 * sr + v as f32 * cr);
-                    let (x, y) = ((tu as f64 * 0.5 + 0.5) * tex.size[0], (tv as f64 * 0.5 + 0.5) * tex.size[1]);
-                    let px = tex.buf.img.sample_bilinear(x * tex.buf.scale + tex.buf.offset[0], y * tex.buf.scale + tex.buf.offset[1]);
-                    px.map(|c| c * fade)
-                });
-            }
-        }
-        // Environment Map: each bubble reflects the map along its sphere normal (Reflection
-        // Convergence pulls the reflection towards the bubble's own spot of the map).
-        if let Some(env) = &self.env {
-            let (conv, strength) = (env.conv, env.strength);
-            let (w, h) = (b.img.width as f64, b.img.height as f64);
-            for d in &env.discs {
-                let (bx, by) = (d.x, d.y);
-                foam_disc(&mut out, bx, by, d.r as f64, |u, v| {
-                    // Sphere normal; the reflection looks across the whole map, or (convergence 1)
-                    // just behind the bubble.
-                    let (ex, ey) =
-                        if conv >= 1.0 { (bx, by) } else { (bx * conv + (u * 0.5 + 0.5) * w * (1.0 - conv), by * conv + (v * 0.5 + 0.5) * h * (1.0 - conv)) };
-                    let e = env.img.sample_bilinear(ex, ey);
-                    let rim = ((u * u + v * v) as f32).min(1.0);
-                    let k = strength * (0.3 + 0.7 * rim);
-                    [e[0] * k, e[1] * k, e[2] * k, 0.0]
-                });
-            }
-        }
-        // Draft + Flow Map shows the flow map under the bubbles.
-        if let Some(fm) = &self.flow {
-            out.data.par_iter_mut().zip(fm.data.par_iter()).for_each(|(o, f)| {
-                let k = 1.0 - o[3];
-                for c in 0..4 {
-                    o[c] += f[c] * 0.5 * k;
-                }
-            });
-        }
-        Buf { img: out, ..b }
-    }
-}
-
-/// Foam's [`FoamPlan`] for layer geometry `b` (its size; its pixels are not read).
-pub fn foam_full_plan(ctx: &EffectCtx, b: &Buf) -> FoamPlan {
-    let pr = ctx.params;
-    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
-    let unit = lw * 0.01;
-    let prod = pr.v2("producer/producerPoint");
-    let (psx, psy) = (pr.f("producer/producerXSize") as f32 * lw, pr.f("producer/producerYSize") as f32 * lh);
-    let porient = (pr.f("producer/producerOrientation") as f32).to_radians();
-    let rate = pr.f("producer/productionRate").max(0.0) as f32;
-    let size = pr.f("bubbles/size").max(0.0) as f32;
-    let size_var = pr.f("bubbles/sizeVariance") as f32;
-    let lifespan = pr.f("bubbles/lifespan").max(1.0) as f32;
-    let growth = pr.f("bubbles/growthSpeed").max(0.0001) as f32;
-    // Strength: weaker bubbles tend to pop before their lifespan (at 20 or more every bubble
-    // lives the full lifespan); each bubble gets its own pop age.
-    let frailty = 1.0 - (pr.f("bubbles/strength") as f32 / 20.0).clamp(0.0, 1.0);
-    let init_speed = pr.f("physics/initialSpeed") as f32;
-    let init_dir = (pr.f("physics/initialDirection") as f32).to_radians();
-    let wind = pr.f("physics/windSpeed") as f32;
-    let wind_dir = (pr.f("physics/windDirection") as f32).to_radians();
-    let turb = pr.f("physics/turbulence") as f32;
-    let wobble = pr.f("physics/wobbleAmount").max(0.0) as f32;
-    let repulsion = pr.f("physics/repulsion") as f32;
-    let pop_velocity = pr.f("physics/popVelocity") as f32;
-    let viscosity = pr.f("physics/viscosity").clamp(0.0, 1.0) as f32;
-    let sticky = pr.f("physics/stickiness").clamp(0.0, 1.0) as f32;
-    let universe = pr.f("universeSize").max(0.01) as f32;
-    let seed = (pr.f("randomSeed") as u32).wrapping_mul(0x68e31da4) ^ ctx.seed;
-    let wvec = [wind_dir.sin() * wind * unit, -wind_dir.cos() * wind * unit];
-    // Flow Map: the map layer's first frame, its luminance a height field (Fits the layer or
-    // the whole universe).
-    let flow = pr.get("flowMap/flowMap").and_then(Value::as_layer).and_then(|id| {
-        let host = ctx.env.host?;
-        let me = pr.get(&crate::layer_source_id("flowMap/flowMap")).is_none_or(|v| v.as_enum() != 0);
-        host.layer_at(id, ctx.env.comp_time - ctx.time, me)
-    });
-    let steep = pr.f("flowMap/flowMapSteepness") as f32;
-    let fits_universe = pr.e("flowMap/flowMapFits") == 1;
-    let substeps = match pr.e("flowMap/simulationQuality") {
-        1 => 2,
-        2 => 4,
-        _ => 1,
-    };
-    let height = flow.as_ref().map(|lp| {
-        let img = &lp.buf.img;
-        let pl = Plane::from_image(img, |px| {
-            let (c, a) = unpremul(px);
-            effectcraft_color::luminance(c[0], c[1], c[2]) * a
-        });
-        (pl, lp.buf.scale, lp.buf.offset, lp.size)
-    });
-    let (ux0, uy0) = (-(universe - 1.0) * 0.5 * lw, -(universe - 1.0) * 0.5 * lh);
-    let (ux1, uy1) = (lw - ux0, lh - uy0);
-    // Height at a layer point (0..1).
-    let h_at = |x: f32, y: f32| -> f32 {
-        let Some((pl, s, off, size)) = &height else { return 0.0 };
-        let (fx, fy) = if fits_universe { ((x - ux0) / (ux1 - ux0), (y - uy0) / (uy1 - uy0)) } else { (x / lw, y / lh) };
-        pl.sample(fx as f64 * size[0] * s + off[0], fy as f64 * size[1] * s + off[1])
-    };
-    let mut key = params_key(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, 5);
-    if let Some((pl, ..)) = &height {
-        key ^= pl.data.iter().step_by(5).fold(0u64, |a, v| a.rotate_left(3) ^ v.to_bits() as u64);
-    }
-    let steps = if ctx.time <= 0.0 { 0 } else { (ctx.time * FOAM_FPS + 1e-6).floor() as u64 };
-    let rad = |q: &FoamBubble| q.size * unit * 3.0 * (q.age * growth).min(1.0);
-    let st = FOAM_CACHE.run(key, steps, FoamState::default, |st, step| {
-        let t = step as f32 / FOAM_FPS as f32;
-        // Births.
-        st.carry += rate;
-        let n = st.carry.floor() as u32;
-        st.carry -= n as f32;
-        for _ in 0..n {
-            if st.b.len() >= 3000 {
-                break;
-            }
-            let id = st.next;
-            st.next = st.next.wrapping_add(1);
-            let (ux, uy) = (hs(id, 1, seed) * 0.5 * psx, hs(id, 2, seed) * 0.5 * psy);
-            let (so, co) = porient.sin_cos();
-            let p = [prod[0] as f32 + ux * co - uy * so, prod[1] as f32 + ux * so + uy * co];
-            let v = [init_dir.sin() * init_speed * unit, -init_dir.cos() * init_speed * unit];
-            let sz = (size * (1.0 + size_var * hs(id, 3, seed))).max(0.01);
-            st.b.push(FoamBubble { p, v, age: 0.0, size: sz, spin: hs(id, 12, seed) * std::f32::consts::PI, id });
-        }
-        for _ in 0..substeps {
-            let k = 1.0 / substeps as f32;
-            // Forces: drift towards the wind, turbulence, viscosity, the flow map's slope.
-            for q in st.b.iter_mut() {
-                let n1 = value_noise(q.p[0] / (lw * 0.15), q.p[1] / (lw * 0.15), t * 0.5, seed) - 0.5;
-                let n2 = value_noise(q.p[0] / (lw * 0.15) + 19.0, q.p[1] / (lw * 0.15), t * 0.5, seed) - 0.5;
-                for c in 0..2 {
-                    q.v[c] += (wvec[c] - q.v[c]) * 0.1 * k;
-                    q.v[c] *= 1.0 - viscosity * 0.5 * k;
-                }
-                q.v[0] += n1 * turb * unit * k;
-                q.v[1] += n2 * turb * unit * k;
-                if height.is_some() && steep != 0.0 {
-                    let e = unit.max(1.0);
-                    let gx = (h_at(q.p[0] + e, q.p[1]) - h_at(q.p[0] - e, q.p[1])) / (2.0 * e);
-                    let gy = (h_at(q.p[0], q.p[1] + e) - h_at(q.p[0], q.p[1] - e)) / (2.0 * e);
-                    // Downhill: from light (high) to dark (low).
-                    q.v[0] -= gx * steep * lw * 0.5 * k;
-                    q.v[1] -= gy * steep * lw * 0.5 * k;
-                }
-                // Physical Orientation: bubbles roll with their sideways motion.
-                q.spin += q.v[0] / (rad(q).max(0.5)) * k;
-            }
-            // Repulsion between overlapping bubbles (grid hashed, deterministic order).
-            if repulsion > 0.0 && st.b.len() > 1 {
-                let maxr = st.b.iter().map(rad).fold(0.0f32, f32::max).max(1.0);
-                let cs = maxr * 2.0;
-                let mut grid: std::collections::HashMap<(i32, i32), Vec<usize>> = std::collections::HashMap::new();
-                for (i, q) in st.b.iter().enumerate() {
-                    grid.entry(((q.p[0] / cs).floor() as i32, (q.p[1] / cs).floor() as i32)).or_default().push(i);
-                }
-                let mut push = vec![[0.0f32; 2]; st.b.len()];
-                for (i, q) in st.b.iter().enumerate() {
-                    let (gx, gy) = ((q.p[0] / cs).floor() as i32, (q.p[1] / cs).floor() as i32);
-                    for dy in -1..=1 {
-                        for dx in -1..=1 {
-                            let Some(list) = grid.get(&(gx + dx, gy + dy)) else { continue };
-                            for &j in list {
-                                if j <= i {
-                                    continue;
-                                }
-                                let o = &st.b[j];
-                                let (ddx, ddy) = (o.p[0] - q.p[0], o.p[1] - q.p[1]);
-                                let d = (ddx * ddx + ddy * ddy).sqrt().max(1e-4);
-                                let overlap = rad(q) + rad(o) - d;
-                                if overlap > 0.0 {
-                                    let f = overlap * 0.5 * repulsion.min(4.0) * (1.0 - sticky * 0.5) / d * k;
-                                    push[i][0] -= ddx * f;
-                                    push[i][1] -= ddy * f;
-                                    push[j][0] += ddx * f;
-                                    push[j][1] += ddy * f;
-                                }
-                            }
-                        }
-                    }
-                }
-                for (q, d) in st.b.iter_mut().zip(&push) {
-                    q.p[0] += d[0].clamp(-maxr, maxr);
-                    q.p[1] += d[1].clamp(-maxr, maxr);
-                }
-            }
-            for q in st.b.iter_mut() {
-                q.p[0] += q.v[0] * k;
-                q.p[1] += q.v[1] * k;
-            }
-        }
-        for q in st.b.iter_mut() {
-            q.age += 1.0;
-        }
-        // Pops: bubbles past their pop age burst, pushing their neighbours away.
-        let popped: Vec<([f32; 2], f32)> = st.b.iter().filter(|q| q.age >= foam_pop_age(q.id, lifespan, frailty, seed)).map(|q| (q.p, rad(q))).collect();
-        if pop_velocity != 0.0 {
-            for (pp, pr_) in &popped {
-                let reach = (pr_ * 3.0).max(unit);
-                for q in st.b.iter_mut() {
-                    let (dx, dy) = (q.p[0] - pp[0], q.p[1] - pp[1]);
-                    let d = (dx * dx + dy * dy).sqrt();
-                    if d > 1e-4 && d < reach {
-                        let f = pop_velocity * unit * (1.0 - d / reach) / d;
-                        q.v[0] += dx * f;
-                        q.v[1] += dy * f;
-                    }
-                }
-            }
-        }
-        st.b.retain(|q| q.age < foam_pop_age(q.id, lifespan, frailty, seed) && q.p[0] > ux0 && q.p[0] < ux1 && q.p[1] > uy0 && q.p[1] < uy1);
-    });
-    let view = pr.e("view");
-    let zoom = pr.f("zoom").max(0.01) as f32;
-    let zoom_producer = pr.b("producer/zoomProducerPoint");
-    let texture = pr.e("rendering/bubbleTexture");
-    let orient = pr.e("rendering/bubbleOrientation");
-    let blend = pr.e("rendering/blendMode");
-    let s = b.scale as f32;
-    // Zoom centres on the layer, or on the producer with Zoom Producer Point.
-    let (cx, cy) = if zoom_producer { (prod[0] as f32, prod[1] as f32) } else { (lw * 0.5, lh * 0.5) };
-    let mut order: Vec<&FoamBubble> = st.b.iter().collect();
-    if blend == 2 {
-        // Solid New on Top: oldest first.
-        order.sort_by(|a, c| c.age.total_cmp(&a.age).then(a.id.cmp(&c.id)));
-    } else if blend == 1 {
-        order.sort_by(|a, c| a.age.total_cmp(&c.age).then(a.id.cmp(&c.id)));
-    }
-    // Where a bubble is drawn: buffer centre, radius, rotation (radians).
-    let place = |q: &FoamBubble| {
-        let wob = if wobble > 0.0 { 1.0 + wobble * 0.15 * ((q.age * 0.35) + hs(q.id, 13, seed) * 6.0).sin() } else { 1.0 };
-        let r = rad(q) * wob * zoom * s;
-        let (bx, by) = b.to_px([(cx + (q.p[0] - cx) * zoom) as f64, (cy + (q.p[1] - cy) * zoom) as f64]);
-        let rot = match orient {
-            1 => q.spin,
-            2 => q.v[1].atan2(q.v[0]),
-            _ => 0.0,
-        };
-        (bx, by, r, rot)
-    };
-    let user_tex = (view == 2 && texture == 5).then(|| ctx.layer_param("rendering/bubbleTextureLayer", true)).flatten();
-    let sprites: Vec<Sprite> = order
-        .iter()
-        .filter(|_| user_tex.is_none())
-        .map(|q| {
-            let (bx, by, r, rot) = place(q);
-            let fade = ((foam_pop_age(q.id, lifespan, frailty, seed) - q.age) / 5.0).clamp(0.0, 1.0);
-            // Draft and Draft + Flow Map show the wireframe-style bubbles.
-            let mut sp = if view != 2 {
-                Sprite::new(bx as f32, by as f32, r, [0.55, 0.75, 1.0, fade], Shape::Bubble)
-            } else {
-                let (c, shape) = match texture {
-                    1 => ([0.95, 0.95, 0.92], Shape::Faded),
-                    2 => ([1.0, 0.6, 0.8], Shape::Bubble),
-                    3 => ([0.8, 0.85, 0.75], Shape::Bubble),
-                    4 => ([0.97, 0.97, 0.95], Shape::Sphere),
-                    _ => ([1.0, 1.0, 1.0], Shape::Bubble),
-                };
-                Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], fade], shape)
-            };
-            sp.rot = rot;
-            sp
-        })
-        .collect();
-    let acc = if blend == 0 && view == 2 { Acc::Add } else { Acc::Over };
-    let disc = |q: &&FoamBubble| {
-        let (x, y, r, rot) = place(q);
-        let fade = ((foam_pop_age(q.id, lifespan, frailty, seed) - q.age) / 5.0).clamp(0.0, 1.0);
-        FoamDisc { x, y, r, rot, fade }
-    };
-    let user = user_tex.map(|tex| (tex, order.iter().map(disc).collect()));
-    let strength = pr.f("rendering/reflectionStrength").clamp(0.0, 1.0) as f32;
-    let env = if view == 2
-        && strength > 0.0
-        && let Some(env) = ctx.layer_param("rendering/environmentMap", true)
-    {
-        Some(FoamEnv {
-            img: crate::util::fit_layer(ctx, b, &env, true),
-            conv: pr.f("rendering/reflectionConvergence").clamp(0.0, 1.0),
-            strength,
-            discs: order.iter().map(disc).collect(),
-        })
-    } else {
-        None
-    };
-    let flow = if view == 1
-        && let Some(lp) = &flow
-    {
-        Some(crate::util::fit_layer(ctx, b, lp, true))
-    } else {
-        None
-    };
-    FoamPlan { sprites: crate::sim::SpritePlan { sprites, tints: vec![], acc, post: crate::sim::Post::Replace }, user, env, flow }
-}
-
-/// Add `f(u, v)` (premultiplied; u, v ∈ −1..1 across the disc) over the disc of radius `r` at
-/// (`x`, `y`) with anti-aliased edges ("over" for opaque texels, additive for alpha 0).
-fn foam_disc(out: &mut Image, x: f64, y: f64, r: f64, f: impl Fn(f64, f64) -> Px) {
-    if r <= 0.0 {
-        return;
-    }
-    let (x0, x1) = ((x - r - 1.0).floor().max(0.0) as i64, (x + r + 1.0).ceil().min(out.width as f64) as i64);
-    let (y0, y1) = ((y - r - 1.0).floor().max(0.0) as i64, (y + r + 1.0).ceil().min(out.height as f64) as i64);
-    for py in y0..y1 {
-        for px in x0..x1 {
-            let (u, v) = ((px as f64 + 0.5 - x) / r, (py as f64 + 0.5 - y) / r);
-            let d = (u * u + v * v).sqrt();
-            let cov = ((1.0 - d) * r + 0.5).clamp(0.0, 1.0) as f32;
-            if cov <= 0.0 {
-                continue;
-            }
-            let s = f(u.clamp(-1.0, 1.0), v.clamp(-1.0, 1.0)).map(|c| c * cov);
-            let o = out.get(px, py);
-            let k = 1.0 - s[3];
-            out.set(px as u32, py as u32, [s[0] + o[0] * k, s[1] + o[1] * k, s[2] + o[2] * k, (s[3] + o[3] * k).min(1.0)]);
-        }
-    }
-}
-
-// ------------------------------------------------------------------ specs
-
-fn producer_params(k: u32, amp: f64, pos: (f64, f64)) -> Vec<crate::ParamSpec> {
-    let ids: [&'static str; 8] = match k {
-        1 => [
-            "producer1/producer1Type",
-            "producer1/producer1Position",
-            "producer1/producer1Length",
-            "producer1/producer1Width",
-            "producer1/producer1Angle",
-            "producer1/producer1Amplitude",
-            "producer1/producer1Frequency",
-            "producer1/producer1Phase",
-        ],
-        _ => [
-            "producer2/producer2Type",
-            "producer2/producer2Position",
-            "producer2/producer2Length",
-            "producer2/producer2Width",
-            "producer2/producer2Angle",
-            "producer2/producer2Amplitude",
-            "producer2/producer2Frequency",
-            "producer2/producer2Phase",
-        ],
-    };
-    vec![
-        p(ids[0], "Type", Value::Enum(0), popup(&["Ring", "Line"])),
-        p(ids[1], "Position", pt(pos.0, pos.1), ParamUi::Point),
-        p(ids[2], "Height/Length", num(0.1), slider(0.0, 2.0, 0.0, 1.0, 3)),
-        p(ids[3], "Width", num(0.1), slider(0.0, 2.0, 0.0, 1.0, 3)),
-        p(ids[4], "Angle", num(0.0), ParamUi::Angle),
-        p(ids[5], "Amplitude", num(amp), slider(-5.0, 5.0, -1.0, 1.0, 3)),
-        p(ids[6], "Frequency", num(1.0), slider(0.0, 30.0, 0.0, 5.0, 3)),
-        p(ids[7], "Phase", num(0.0), ParamUi::Angle),
-    ]
-}
-
-fn card_dance_params() -> Vec<crate::ParamSpec> {
-    let mut v = vec![
-        p("rowsColumns", "Rows & Columns", Value::Enum(0), popup(&["Independent", "Columns Follows Rows"])),
-        p("rows", "Rows", num(10.0), slider(1.0, 1000.0, 1.0, 100.0, 0)),
-        p("columns", "Columns", num(10.0), slider(1.0, 1000.0, 1.0, 100.0, 0)),
-        p("backLayer", "Back Layer", Value::Layer(None), ParamUi::Layer),
-        p("gradientLayer1", "Gradient Layer 1", Value::Layer(None), ParamUi::Layer),
-        p("gradientLayer2", "Gradient Layer 2", Value::Layer(None), ParamUi::Layer),
-    ];
-    let names: [[&'static str; 4]; 8] = [
-        ["xPosition/xPosSource", "xPosition/xPosMultiplier", "xPosition/xPosOffset", "X Position"],
-        ["yPosition/yPosSource", "yPosition/yPosMultiplier", "yPosition/yPosOffset", "Y Position"],
-        ["zPosition/zPosSource", "zPosition/zPosMultiplier", "zPosition/zPosOffset", "Z Position"],
-        ["xRotation/xRotSource", "xRotation/xRotMultiplier", "xRotation/xRotOffset", "X Rotation"],
-        ["yRotation/yRotSource", "yRotation/yRotMultiplier", "yRotation/yRotOffset", "Y Rotation"],
-        ["zRotation/zRotSource", "zRotation/zRotMultiplier", "zRotation/zRotOffset", "Z Rotation"],
-        ["xScale/xScaleSource", "xScale/xScaleMultiplier", "xScale/xScaleOffset", "X Scale"],
-        ["yScale/yScaleSource", "yScale/yScaleMultiplier", "yScale/yScaleOffset", "Y Scale"],
-    ];
-    debug_assert_eq!(names.len(), CD_PROPS.len());
-    for (i, n) in names.iter().enumerate() {
-        let rot = (3..6).contains(&i);
-        let scale = i >= 6;
-        let (lo, hi) = if rot { (-3600.0, 3600.0) } else { (-100.0, 100.0) };
-        v.push(p(n[0], "Source", Value::Enum(0), popup(CD_SOURCES)));
-        v.push(p(n[1], "Multiplier", num(0.0), slider(lo, hi, if rot { -360.0 } else { -10.0 }, if rot { 360.0 } else { 10.0 }, 2)));
-        v.push(p(n[2], "Offset", num(if scale { 1.0 } else { 0.0 }), slider(lo, hi, if rot { -360.0 } else { -10.0 }, if rot { 360.0 } else { 10.0 }, 2)));
-    }
-    v.extend(crate::card3d::camera_params(2.0));
-    v.extend(crate::card3d::lighting_params(1.0, 0.25));
-    v.extend(crate::card3d::material_params(0.75));
-    v
-}
-
-pub fn specs() -> Vec<EffectSpec> {
-    vec![
-        spec(
-            "ec.sim.ccballaction",
-            "CC Ball Action",
-            vec![
-                p("scatter", "Scatter", num(0.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
-                p("rotationAxis", "Rotation Axis", Value::Enum(0), popup(&["X Axis", "Y Axis", "Z Axis", "XY Axis", "XZ Axis", "YZ Axis", "XYZ Axis"])),
-                p("rotation", "Rotation", num(0.0), ParamUi::Angle),
-                p("twistProperty", "Twist Property", Value::Enum(0), popup(&["X Axis", "Y Axis", "Radius", "Brightness"])),
-                p("twistAngle", "Twist Angle", num(0.0), ParamUi::Angle),
-                p("gridSpacing", "Grid Spacing", num(4.0), slider(1.0, 200.0, 1.0, 50.0, 0)),
-                p("ballSize", "Ball Size", num(40.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
-                p("instabilityState", "Instability State", num(0.0), ParamUi::Angle),
-            ],
-            ball_action,
-        ),
-        spec(
-            "ec.sim.ccpixelpolly",
-            "CC Pixel Polly",
-            vec![
-                p("force", "Force", num(100.0), slider(-1000.0, 1000.0, -300.0, 300.0, 1)),
-                p("gravity", "Gravity", num(1.0), slider(-20.0, 20.0, -5.0, 5.0, 2)),
-                p("spinning", "Spinning", num(0.0), ParamUi::Angle),
-                p("forceCenter", "Force Center", pt(0.5, 0.5), ParamUi::Point),
-                p("directionRandomness", "Direction Randomness", num(10.0), pct()),
-                p("speedRandomness", "Speed Randomness", num(10.0), pct()),
-                p("gridSpacing", "Grid Spacing", num(10.0), slider(1.0, 500.0, 2.0, 100.0, 0)),
-                p("object", "Object", Value::Enum(0), popup(&["Polygon", "Textured Polygon", "Square", "Textured Square"])),
-                p("enableDepthSort", "Enable Depth Sort", Value::Bool(true), ParamUi::Checkbox),
-                p("startTime", "Start Time (sec)", num(0.0), slider(-1000.0, 1000.0, 0.0, 10.0, 2)),
-            ],
-            pixel_polly,
-        ),
-        spec(
-            "ec.sim.ccscatterize",
-            "CC Scatterize",
-            vec![
-                p("scatter", "Scatter", num(0.0), slider(0.0, 1000.0, 0.0, 200.0, 1)),
-                p("rightTwist", "Right Twist", num(0.0), ParamUi::Angle),
-                p("leftTwist", "Left Twist", num(0.0), ParamUi::Angle),
-                p("transferMode", "Transfer Mode", Value::Enum(0), popup(&["Composite", "Add"])),
-            ],
-            scatterize,
-        ),
-        spec("ec.sim.carddance", "Card Dance", card_dance_params(), card_dance),
-        spec(
-            "ec.sim.caustics",
-            "Caustics",
-            vec![
-                p("bottom/bottom", "Bottom", Value::Layer(None), ParamUi::Layer),
-                p("bottom/scaling", "Scaling", num(1.0), slider(0.01, 10.0, 0.1, 3.0, 3)),
-                p("bottom/repeatMode", "Repeat Mode", Value::Enum(2), popup(&["Once", "Tiled", "Reflected"])),
-                p("bottom/bottomSizeDiffers", "If Layer Size Differs", Value::Enum(1), popup(&["Center", "Stretch to Fit"])),
-                p("bottom/blur", "Blur", num(0.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
-                p("water/waterSurface", "Water Surface", Value::Layer(None), ParamUi::Layer),
-                p("water/waveHeight", "Wave Height", num(0.2), slider(-1.0, 1.0, -1.0, 1.0, 3)),
-                p("water/smoothing", "Smoothing", num(5.0), slider(0.0, 100.0, 0.0, 50.0, 1)),
-                p("water/waterDepth", "Water Depth", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("water/refractiveIndex", "Refractive Index", num(1.2), slider(1.0, 3.0, 1.0, 2.0, 3)),
-                p("water/surfaceColor", "Surface Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("water/surfaceOpacity", "Surface Opacity", num(0.3), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("water/causticsStrength", "Caustics Strength", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("sky/sky", "Sky", Value::Layer(None), ParamUi::Layer),
-                p("sky/scaling", "Scaling", num(1.0), slider(0.01, 10.0, 0.1, 3.0, 3)),
-                p("sky/repeatMode", "Repeat Mode", Value::Enum(2), popup(&["Once", "Tiled", "Reflected"])),
-                p("sky/skySizeDiffers", "If Layer Size Differs", Value::Enum(1), popup(&["Center", "Stretch to Fit"])),
-                p("sky/intensity", "Intensity", num(0.3), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("sky/convergence", "Convergence", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("lighting/lightType", "Light Type", Value::Enum(0), popup(&crate::card3d::LIGHT_TYPES)),
-                p("lighting/lightIntensity", "Light Intensity", num(1.0), slider(0.0, 4.0, 0.0, 2.0, 2)),
-                p("lighting/lightColor", "Light Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("lighting/lightPosition", "Light Position", pt(0.0, 0.0), ParamUi::Point),
-                p("lighting/lightHeight", "Light Height", num(1.0), slider(0.0, 10.0, 0.0, 4.0, 2)),
-                p("lighting/ambientLight", "Ambient Light", num(0.35), slider(0.0, 2.0, 0.0, 1.0, 2)),
-                p("material/diffuse", "Diffuse Reflection", num(0.75), slider(0.0, 2.0, 0.0, 1.0, 2)),
-                p("material/specular", "Specular Reflection", num(0.2), slider(0.0, 2.0, 0.0, 1.0, 2)),
-                p("material/highlightSharpness", "Highlight Sharpness", num(15.0), slider(1.0, 100.0, 1.0, 100.0, 1)),
-            ],
-            caustics,
-        ),
-        spec(
-            "ec.sim.waveworld",
-            "Wave World",
-            {
-                let mut v = vec![
-                    p("view", "View", Value::Enum(0), popup(&["Wireframe Preview", "Height Map"])),
-                    p("wireframeControls/horizontalRotation", "Horizontal Rotation", num(0.0), ParamUi::Angle),
-                    p("wireframeControls/verticalRotation", "Vertical Rotation", num(53.0), slider(0.0, 90.0, 0.0, 90.0, 1)),
-                    p("wireframeControls/verticalScale", "Vertical Scale", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 3)),
-                    p("heightMapControls/brightness", "Brightness", num(0.5), slider(-1.0, 2.0, 0.0, 1.0, 3)),
-                    p("heightMapControls/contrast", "Contrast", num(0.75), slider(0.0, 4.0, 0.0, 2.0, 3)),
-                    p("heightMapControls/gamma", "Gamma Adjustment", num(1.0), slider(0.01, 10.0, 0.2, 5.0, 3)),
-                    p("heightMapControls/renderDryAreasAs", "Render Dry Areas As", Value::Enum(0), popup(&["Solid", "Transparent"])),
-                    p("heightMapControls/transparency", "Transparency", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                    p("simulation/gridResolution", "Grid Resolution", num(60.0), slider(1.0, 400.0, 1.0, 200.0, 0)),
-                    p("simulation/gridResDownsamples", "Grid Res Downsamples", Value::Bool(false), ParamUi::Checkbox),
-                    p("simulation/waveSpeed", "Wave Speed", num(0.2), slider(0.0, 5.0, 0.0, 1.0, 3)),
-                    p("simulation/damping", "Damping", num(0.05), slider(0.0, 5.0, 0.0, 1.0, 3)),
-                    p("simulation/reflectEdges", "Reflect Edges", Value::Enum(0), popup(&["None", "Left", "Top", "Right", "Bottom", "All"])),
-                    p("simulation/preRoll", "Pre-roll (seconds)", num(0.0), slider(0.0, 30.0, 0.0, 10.0, 2)),
-                    p("ground/ground", "Ground", Value::Layer(None), ParamUi::Layer),
-                    p("ground/steepness", "Steepness", num(0.25), slider(0.0, 2.0, 0.0, 1.0, 3)),
-                    p("ground/height", "Height", num(0.25), slider(0.0, 2.0, 0.0, 1.0, 3)),
-                    p("ground/waveStrength", "Wave Strength", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                ];
-                v.extend(producer_params(1, 0.5, (0.5, 0.5)));
-                v.extend(producer_params(2, 0.0, (0.25, 0.25)));
-                v
-            },
-            wave_world,
-        ),
-        spec(
-            "ec.sim.shatter",
-            "Shatter",
-            vec![
-                p(
-                    "view",
-                    "View",
-                    Value::Enum(1),
-                    popup(&["Rendered", "Wireframe Front View", "Wireframe", "Wireframe Front View + Forces", "Wireframe + Forces"]),
-                ),
-                p("render", "Render", Value::Enum(0), popup(&["All", "Layer", "Pieces"])),
-                p("shape/pattern", "Pattern", Value::Enum(0), popup(SHATTER_PATTERNS)),
-                p("shape/repetitions", "Repetitions", num(10.0), slider(1.0, 500.0, 1.0, 100.0, 2)),
-                p("shape/direction", "Direction", num(0.0), ParamUi::Angle),
-                p("shape/origin", "Origin", pt(0.5, 0.5), ParamUi::Point),
-                p("shape/customShatterMap", "Custom Shatter Map", Value::Layer(None), ParamUi::Layer),
-                p("shape/whiteTilesFixed", "White Tiles Fixed", Value::Bool(false), ParamUi::Checkbox),
-                p("shape/extrusionDepth", "Extrusion Depth", num(0.05), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("force1/force1Position", "Position", pt(0.5, 0.5), ParamUi::Point),
-                p("force1/force1Depth", "Depth", num(0.1), slider(-1.0, 1.0, -1.0, 1.0, 3)),
-                p("force1/force1Radius", "Radius", num(0.4), slider(0.0, 4.0, 0.0, 2.0, 3)),
-                p("force1/force1Strength", "Strength", num(5.0), slider(-20.0, 20.0, -10.0, 10.0, 2)),
-                p("force2/force2Position", "Position", pt(0.25, 0.25), ParamUi::Point),
-                p("force2/force2Depth", "Depth", num(0.1), slider(-1.0, 1.0, -1.0, 1.0, 3)),
-                p("force2/force2Radius", "Radius", num(0.0), slider(0.0, 4.0, 0.0, 2.0, 3)),
-                p("force2/force2Strength", "Strength", num(5.0), slider(-20.0, 20.0, -10.0, 10.0, 2)),
-                p("physics/rotationSpeed", "Rotation Speed", num(0.2), slider(0.0, 5.0, 0.0, 1.0, 3)),
-                p("physics/tumbleAxis", "Tumble Axis", Value::Enum(0), popup(&["Free", "None", "X", "Y", "Z", "XY", "XZ", "YZ"])),
-                p("physics/randomness", "Randomness", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("physics/viscosity", "Viscosity", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("physics/massVariance", "Mass Variance", num(30.0), pct()),
-                p("physics/gravity", "Gravity", num(3.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
-                p("physics/gravityDirection", "Gravity Direction", num(180.0), ParamUi::Angle),
-                p("physics/gravityInclination", "Gravity Inclination", num(0.0), slider(-90.0, 90.0, -90.0, 90.0, 1)),
-                p("gradient/shatterThreshold", "Shatter Threshold", num(0.0), slider(0.0, 100.0, 0.0, 100.0, 1)),
-                p("gradient/gradientLayer", "Gradient Layer", Value::Layer(None), ParamUi::Layer),
-                p("gradient/invertGradient", "Invert Gradient", Value::Bool(false), ParamUi::Checkbox),
-                p("textures/color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
-                p("textures/opacity", "Opacity", num(1.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("textures/frontMode", "Front Mode", Value::Enum(1), popup(&SHATTER_TEXTURE_MODES)),
-                p("textures/sideMode", "Side Mode", Value::Enum(0), popup(&SHATTER_TEXTURE_MODES)),
-                p("textures/backMode", "Back Mode", Value::Enum(1), popup(&SHATTER_TEXTURE_MODES)),
-                p("textures/frontLayer", "Front Layer", Value::Layer(None), ParamUi::Layer),
-                p("textures/sideLayer", "Side Layer", Value::Layer(None), ParamUi::Layer),
-                p("textures/backLayer", "Back Layer", Value::Layer(None), ParamUi::Layer),
-            ]
-            .into_iter()
-            .chain(crate::card3d::camera_params(4.0))
-            .chain(crate::card3d::lighting_params(1.0, 0.25))
-            .chain(crate::card3d::material_params(0.75))
-            .chain([p("randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0))])
-            .collect(),
-            shatter,
-        ),
-        spec(
-            "ec.sim.foam",
-            "Foam",
-            vec![
-                p("view", "View", Value::Enum(0), popup(&["Draft", "Draft + Flow Map", "Rendered"])),
-                p("producer/producerPoint", "Producer Point", pt(0.5, 0.5), ParamUi::Point),
-                p("producer/producerXSize", "Producer X Size", num(0.05), slider(0.0, 2.0, 0.0, 1.0, 3)),
-                p("producer/producerYSize", "Producer Y Size", num(0.05), slider(0.0, 2.0, 0.0, 1.0, 3)),
-                p("producer/producerOrientation", "Producer Orientation", num(0.0), ParamUi::Angle),
-                p("producer/zoomProducerPoint", "Zoom Producer Point", Value::Bool(false), ParamUi::Checkbox),
-                p("producer/productionRate", "Production Rate", num(1.0), slider(0.0, 50.0, 0.0, 10.0, 3)),
-                p("bubbles/size", "Size", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 3)),
-                p("bubbles/sizeVariance", "Size Variance", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("bubbles/lifespan", "Lifespan", num(300.0), slider(1.0, 30_000.0, 1.0, 1000.0, 1)),
-                p("bubbles/growthSpeed", "Bubble Growth Speed", num(0.1), slider(0.0001, 10.0, 0.0001, 1.0, 3)),
-                p("bubbles/strength", "Strength", num(10.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
-                p("physics/initialSpeed", "Initial Speed", num(0.0), slider(-100.0, 100.0, -10.0, 10.0, 3)),
-                p("physics/initialDirection", "Initial Direction", num(0.0), ParamUi::Angle),
-                p("physics/windSpeed", "Wind Speed", num(0.5), slider(-100.0, 100.0, -10.0, 10.0, 3)),
-                p("physics/windDirection", "Wind Direction", num(90.0), ParamUi::Angle),
-                p("physics/turbulence", "Turbulence", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 3)),
-                p("physics/wobbleAmount", "Wobble Amount", num(0.05), slider(0.0, 10.0, 0.0, 2.0, 3)),
-                p("physics/repulsion", "Repulsion", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 3)),
-                p("physics/popVelocity", "Pop Velocity", num(1.0), slider(-100.0, 100.0, -10.0, 10.0, 3)),
-                p("physics/viscosity", "Viscosity", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("physics/stickiness", "Stickiness", num(0.75), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("zoom", "Zoom", num(1.0), slider(0.01, 50.0, 0.1, 5.0, 3)),
-                p("universeSize", "Universe Size", num(1.0), slider(0.01, 10.0, 0.5, 3.0, 3)),
-                p("rendering/blendMode", "Blend Mode", Value::Enum(0), popup(&["Transparent", "Solid Old on Top", "Solid New on Top"])),
-                p("rendering/bubbleTexture", "Bubble Texture", Value::Enum(0), popup(&FOAM_TEXTURES)),
-                p("rendering/bubbleTextureLayer", "Bubble Texture Layer", Value::Layer(None), ParamUi::Layer),
-                p("rendering/bubbleOrientation", "Bubble Orientation", Value::Enum(0), popup(&["Fixed", "Physical Orientation", "Bubble Velocity"])),
-                p("rendering/environmentMap", "Environment Map", Value::Layer(None), ParamUi::Layer),
-                p("rendering/reflectionStrength", "Reflection Strength", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("rendering/reflectionConvergence", "Reflection Convergence", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
-                p("flowMap/flowMap", "Flow Map", Value::Layer(None), ParamUi::Layer),
-                p("flowMap/flowMapSteepness", "Flow Map Steepness", num(0.05), slider(-100.0, 100.0, -1.0, 1.0, 3)),
-                p("flowMap/flowMapFits", "Flow Map Fits", Value::Enum(0), popup(&["Background", "Universe"])),
-                p("flowMap/simulationQuality", "Simulation Quality", Value::Enum(0), popup(&["Normal", "High", "Intense"])),
-                p("randomSeed", "Random Seed", num(1.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
-            ],
-            foam,
-        ),
-    ]
-}
+mod foam;
+mod pieces;
+mod pixels;
+mod registry;
+mod shatter;
+mod surfaces;
+
+pub(crate) use foam::foam_plan;
+#[cfg(test)]
+use foam::foam_pop_age;
+pub use foam::{FoamDisc, FoamEnv, FoamPlan, foam_full_plan};
+#[cfg(test)]
+use pieces::Cam;
+#[cfg(test)]
+pub(crate) use pieces::draw_pieces;
+pub use pieces::{Piece, PiecePlan, PieceTex, piece_plan};
+pub(crate) use pieces::{rot_axis, sort_far_first};
+pub use pixels::{PixelPlan, pixel_plan};
+pub use registry::specs;
+#[cfg(test)]
+use shatter::SHATTER_PATTERNS;
+pub use surfaces::{CausticsSetup, WavePlan, Waves, caustics_setup, wave_world_plan};
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{EffectEnv, run_fx};
-
-    fn ramp(w: u32, hh: u32) -> Image {
-        let mut img = Image::new(w, hh);
-        for y in 0..hh {
-            for x in 0..w {
-                img.set(x, y, [x as f32 / w as f32, y as f32 / hh as f32, 0.4, 1.0]);
-            }
-        }
-        img
-    }
-
-    fn run(id: &str, vals: &[(&str, Value)], img: Image, t: f64) -> Image {
-        run_fx(id, vals, img, t, EffectEnv::default()).img
-    }
-
-    fn max_diff(a: &Image, b: &Image) -> f32 {
-        a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|k| (p[k] - q[k]).abs()).fold(0.0, f32::max)).fold(0.0, f32::max)
-    }
-
-    fn sum_diff(a: &Image, b: &Image) -> f32 {
-        a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|k| (p[k] - q[k]).abs()).sum::<f32>()).sum()
-    }
-
-    #[test]
-    fn piece_at_rest_is_identity() {
-        let src = ramp(16, 16);
-        let cam = Cam { c: [8.0, 8.0], d: 64.0 };
-        let id = rot_axis([1.0, 0.0, 0.0], 0.0);
-        let pc = Piece::new(&[[0.0, 0.0], [16.0, 0.0], [16.0, 16.0], [0.0, 16.0]], [8.0, 8.0], &id, [8.0, 8.0, 0.0], cam).unwrap();
-        let mut out = Image::new(16, 16);
-        draw_pieces(&mut out, &[pc], &src, None);
-        assert!(max_diff(&out, &src) < 1e-4);
-    }
-
-    #[test]
-    fn ball_action_draws_balls() {
-        let v = [("ballSize", num(80.0))];
-        let a = run("ec.sim.ccballaction", &v, ramp(32, 32), 0.0);
-        assert_eq!(a, run("ec.sim.ccballaction", &v, ramp(32, 32), 0.0));
-        assert!(a.data.iter().any(|p| p[3] > 0.9) && a.data.iter().any(|p| p[3] == 0.0), "balls with gaps");
-        let none = run("ec.sim.ccballaction", &[("ballSize", num(0.0))], ramp(32, 32), 0.0);
-        assert!(none.data.iter().all(|p| p[3] == 0.0));
-        let sc = run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("scatter", num(20.0))], ramp(32, 32), 0.0);
-        assert!(sum_diff(&a, &sc) > 1.0);
-    }
-
-    #[test]
-    fn pixel_polly_breaks_after_start() {
-        let v = [("forceCenter", pt(16.0, 16.0)), ("gridSpacing", num(4.0))];
-        let before = run("ec.sim.ccpixelpolly", &v, ramp(32, 32), 0.0);
-        assert_eq!(before, ramp(32, 32), "intact before the start time");
-        let a = run("ec.sim.ccpixelpolly", &v, ramp(32, 32), 0.5);
-        assert_eq!(a, run("ec.sim.ccpixelpolly", &v, ramp(32, 32), 0.5));
-        assert!(sum_diff(&a, &ramp(32, 32)) > 10.0);
-        let tex = run("ec.sim.ccpixelpolly", &[("forceCenter", pt(16.0, 16.0)), ("gridSpacing", num(4.0)), ("object", Value::Enum(3))], ramp(32, 32), 0.5);
-        assert!(sum_diff(&a, &tex) > 0.1);
-    }
-
-    #[test]
-    fn scatterize_identity_and_scatter() {
-        assert_eq!(run("ec.sim.ccscatterize", &[], ramp(24, 24), 0.0), ramp(24, 24));
-        let a = run("ec.sim.ccscatterize", &[("scatter", num(5.0))], ramp(24, 24), 0.0);
-        assert_eq!(a, run("ec.sim.ccscatterize", &[("scatter", num(5.0))], ramp(24, 24), 0.0));
-        assert!(sum_diff(&a, &ramp(24, 24)) > 1.0);
-        let tw = run("ec.sim.ccscatterize", &[("leftTwist", num(80.0)), ("rightTwist", num(80.0))], ramp(24, 24), 0.0);
-        assert!(sum_diff(&tw, &ramp(24, 24)) > 1.0);
-    }
-
-    #[test]
-    fn card_dance_identity_and_rotation() {
-        let src = ramp(30, 20);
-        let a = run("ec.sim.carddance", &[], src.clone(), 0.0);
-        assert!(max_diff(&a, &src) < 0.02, "flat cards reproduce the layer: {}", max_diff(&a, &src));
-        let r = run("ec.sim.carddance", &[("yRotation/yRotSource", Value::Enum(1)), ("yRotation/yRotMultiplier", num(90.0))], src.clone(), 0.0);
-        assert_eq!(r, run("ec.sim.carddance", &[("yRotation/yRotSource", Value::Enum(1)), ("yRotation/yRotMultiplier", num(90.0))], src.clone(), 0.0));
-        assert!(sum_diff(&r, &src) > 5.0);
-        let z = run("ec.sim.carddance", &[("zPosition/zPosOffset", num(-1.0))], src.clone(), 0.0);
-        assert!(sum_diff(&z, &src) > 5.0, "cards pulled towards the camera grow");
-    }
-
-    #[test]
-    fn shatter_at_rest_then_breaks() {
-        let v = [("view", Value::Enum(0)), ("force1/force1Position", pt(16.0, 16.0)), ("shape/origin", pt(16.0, 16.0))];
-        let src = ramp(32, 32);
-        let t0 = run("ec.sim.shatter", &v, src.clone(), 0.0);
-        assert!(max_diff(&t0, &src) < 0.03, "{}", max_diff(&t0, &src));
-        let t1 = run("ec.sim.shatter", &v, src.clone(), 0.5);
-        assert_eq!(t1, run("ec.sim.shatter", &v, src.clone(), 0.5));
-        assert!(sum_diff(&t1, &src) > 10.0);
-        for pat in 0..SHATTER_PATTERNS.len() as u32 {
-            let vv =
-                [("view", Value::Enum(0)), ("shape/pattern", Value::Enum(pat)), ("force1/force1Position", pt(16.0, 16.0)), ("shape/origin", pt(16.0, 16.0))];
-            let r = run("ec.sim.shatter", &vv, src.clone(), 0.0);
-            assert!(max_diff(&r, &src) < 0.05, "pattern {pat} tiles the layer: {}", max_diff(&r, &src));
-        }
-        let wire = run("ec.sim.shatter", &[("shape/repetitions", num(3.0))], src.clone(), 0.0);
-        assert!(wire.data.iter().any(|p| p[3] > 0.5) && wire.data.iter().any(|p| p[3] == 0.0));
-        let layer_only =
-            run("ec.sim.shatter", &[("view", Value::Enum(0)), ("render", Value::Enum(1)), ("force1/force1Position", pt(16.0, 16.0))], src.clone(), 0.5);
-        assert!(layer_only.get(16, 16)[3] == 0.0, "broken centre removed");
-    }
-
-    #[test]
-    fn caustics_flat_water() {
-        let src = ramp(24, 24);
-        let a = run(
-            "ec.sim.caustics",
-            &[
-                ("water/surfaceOpacity", num(0.0)),
-                ("lighting/ambientLight", num(0.0)),
-                ("material/diffuse", num(1.0)),
-                ("lighting/lightHeight", num(1000.0)),
-                ("material/specular", num(0.0)),
-            ],
-            src.clone(),
-            0.0,
-        );
-        assert!(max_diff(&a, &src) < 0.01, "flat water, light overhead = bottom: {}", max_diff(&a, &src));
-        let b = run("ec.sim.caustics", &[], src.clone(), 0.0);
-        assert_eq!(b, run("ec.sim.caustics", &[], src.clone(), 0.0));
-        assert!(sum_diff(&b, &src) > 0.1);
-    }
-
-    #[test]
-    fn caustics_sky_and_light_types() {
-        let src = Image::filled(32, 32, [0.5, 0.5, 0.5, 1.0]);
-        let env = EffectEnv { host: Some(&FoamHost), ..Default::default() };
-        let run_h = |vals: &[(&str, Value)]| run_fx("ec.sim.caustics", vals, src.clone(), 0.0, env).img;
-        // A mirror-like surface shows the (green) sky.
-        let mirror = [("water/surfaceOpacity", num(1.0)), ("sky/sky", Value::Layer(Some(2))), ("sky/intensity", num(1.0))];
-        let p = run_h(&mirror).get(16, 16);
-        assert!(p[1] > p[0] + 0.3 && p[1] > p[2] + 0.3, "{p:?}");
-        // Point Source lights pixels by their own direction to the light: the image is no
-        // longer uniform; Distant Source lights the flat water evenly.
-        let lit = |t: u32| {
-            run_h(&[
-                ("lighting/lightType", Value::Enum(t)),
-                ("lighting/lightPosition", pt(0.0, 0.0)),
-                ("lighting/lightHeight", num(0.2)),
-                ("water/surfaceOpacity", num(0.0)),
-            ])
-        };
-        let (distant, point) = (lit(0), lit(1));
-        assert!((distant.get(2, 2)[0] - distant.get(30, 30)[0]).abs() < 1e-5);
-        assert!(point.get(2, 2)[0] > point.get(30, 30)[0] + 0.02, "{:?} {:?}", point.get(2, 2), point.get(30, 30));
-        // First Comp Light without a comp light: ambient only.
-        let none = run_h(&[("lighting/lightType", Value::Enum(2)), ("water/surfaceOpacity", num(0.0))]);
-        assert!(none.get(16, 16)[0] < distant.get(16, 16)[0]);
-    }
-
-    #[test]
-    fn wave_world_wireframe_controls_ground_and_dry_areas() {
-        let base = [("producer1/producer1Position", pt(8.0, 16.0)), ("simulation/gridResolution", num(24.0))];
-        let wire = |extra: &[(&str, Value)]| run("ec.sim.waveworld", &[base.as_slice(), extra].concat(), Image::new(32, 32), 0.5);
-        assert_ne!(wire(&[]), wire(&[("wireframeControls/horizontalRotation", num(40.0))]));
-        assert_ne!(wire(&[]), wire(&[("wireframeControls/verticalScale", num(3.0))]));
-        // Ground (left dark, right light): the light side rises above the water and is dry.
-        let env = EffectEnv { host: Some(&FoamHost), ..Default::default() };
-        let hm = |extra: &[(&str, Value)]| {
-            let mut v: Vec<(&str, Value)> = base.to_vec();
-            v.extend([("view", Value::Enum(1)), ("ground/ground", Value::Layer(Some(1))), ("ground/steepness", num(0.5)), ("ground/height", num(0.25))]);
-            v.extend_from_slice(extra);
-            run_fx("ec.sim.waveworld", &v, Image::new(32, 32), 1.0, env).img
-        };
-        let solid = hm(&[]);
-        let clear = hm(&[("heightMapControls/renderDryAreasAs", Value::Enum(1))]);
-        assert!(solid.get(30, 16)[3] > 0.99 && clear.get(30, 16)[3] == 0.0);
-        assert!(clear.get(4, 16)[3] > 0.99, "wet side stays");
-        // Dry ground stays flat: mid grey (brightness 0.5) there.
-        assert!((solid.get(30, 16)[0] - 0.5).abs() < 1e-4);
-        // Wave Strength slows waves over shallow water: the surface differs.
-        assert_ne!(hm(&[]), hm(&[("ground/waveStrength", num(1.0))]));
-    }
-
-    #[test]
-    fn wave_world_seek_and_waves() {
-        let v = vec![("view", Value::Enum(1)), ("producer1/producer1Position", pt(16.0, 16.0)), ("simulation/gridResolution", num(24.0))];
-        let _ = run("ec.sim.waveworld", &v, Image::new(32, 32), 0.5);
-        let a = run("ec.sim.waveworld", &v, Image::new(32, 32), 1.0);
-        let mut v2 = v.clone();
-        v2.push(("heightMapControls/transparency", num(0.0)));
-        assert_eq!(a, run("ec.sim.waveworld", &v2, Image::new(32, 32), 1.0));
-        // Waves spread: some pixels differ from the flat-water grey.
-        assert!(a.data.iter().any(|p| (p[0] - 0.5).abs() > 0.05), "waves");
-        let flat = run("ec.sim.waveworld", &[("view", Value::Enum(1)), ("producer1/producer1Amplitude", num(0.0))], Image::new(32, 32), 1.0);
-        assert!(flat.data.iter().all(|p| (p[0] - 0.5).abs() < 1e-5));
-        let wire =
-            run("ec.sim.waveworld", &[("producer1/producer1Position", pt(16.0, 16.0)), ("simulation/gridResolution", num(10.0))], Image::new(32, 32), 0.3);
-        assert!(wire.data.iter().any(|p| p[1] > 0.3));
-    }
-
-    #[test]
-    fn wave_world_steps_match_direct() {
-        // Fresh caches: resumed simulation equals simulation from scratch.
-        let v = vec![
-            ("view", Value::Enum(1)),
-            ("producer1/producer1Position", pt(16.0, 16.0)),
-            ("simulation/gridResolution", num(20.0)),
-            ("simulation/damping", num(0.07)),
-        ];
-        let a = run("ec.sim.waveworld", &v, Image::new(32, 32), 1.3);
-        let mut v2 = v.clone();
-        v2.push(("simulation/damping", num(0.07000001)));
-        // Different key: computed from scratch at 1.3 directly vs via 0.4 (both fresh keys).
-        let _ = run("ec.sim.waveworld", &v2, Image::new(32, 32), 0.4);
-        let b = run("ec.sim.waveworld", &v2, Image::new(32, 32), 1.3);
-        assert!(max_diff(&a, &b) < 1e-3, "{}", max_diff(&a, &b));
-    }
-
-    #[test]
-    fn foam_bubbles_drift_and_seek() {
-        let v = vec![("producer/producerPoint", pt(16.0, 16.0)), ("view", Value::Enum(2)), ("producer/productionRate", num(2.0))];
-        let none = run("ec.sim.foam", &v, Image::new(32, 32), 0.0);
-        assert!(none.data.iter().all(|p| p[3] == 0.0));
-        let _ = run("ec.sim.foam", &v, Image::new(32, 32), 0.6);
-        let a = run("ec.sim.foam", &v, Image::new(32, 32), 1.2);
-        let mut v2 = v.clone();
-        v2.push(("randomSeed", num(1.0)));
-        assert_eq!(a, run("ec.sim.foam", &v2, Image::new(32, 32), 1.2));
-        assert!(a.data.iter().any(|p| p[3] > 0.05), "bubbles");
-        let draft = run("ec.sim.foam", &[("producer/producerPoint", pt(16.0, 16.0)), ("producer/productionRate", num(2.0))], Image::new(32, 32), 1.0);
-        assert!(draft.data.iter().any(|p| p[3] > 0.05));
-    }
-
-    #[test]
-    fn foam_strength_controls_early_popping() {
-        // Strong bubbles all live their full lifespan; weak ones pop at random earlier.
-        assert_eq!(foam_pop_age(7, 300.0, 0.0, 1), 300.0);
-        let early = (0..200).filter(|&id| foam_pop_age(id, 300.0, 1.0, 1) < 150.0).count();
-        assert!(early > 60 && early < 140, "{early}");
-        let count = |strength: f64| {
-            let v = vec![
-                ("producer/producerPoint", pt(16.0, 16.0)),
-                ("producer/productionRate", num(3.0)),
-                ("bubbles/lifespan", num(40.0)),
-                ("bubbles/strength", num(strength)),
-                ("physics/windSpeed", num(0.0)),
-            ];
-            run("ec.sim.foam", &v, Image::new(32, 32), 1.5).data.iter().map(|p| p[3]).sum::<f32>()
-        };
-        assert!(count(0.0) < count(20.0) * 0.9, "{} vs {}", count(0.0), count(20.0));
-    }
-
-    /// A host with a comp camera (identity, or tilted) and a first comp light.
-    struct Scene {
-        camera: Option<[[f64; 4]; 3]>,
-        light: Option<crate::CompLight>,
-        layer: Option<Image>,
-    }
-    impl crate::EffectHost for Scene {
-        fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
-            let img = self.layer.clone()?;
-            let size = [img.width as f64, img.height as f64];
-            Some(crate::LayerPixels { buf: Buf { img, offset: [0.0; 2], scale: 1.0 }, size })
-        }
-        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
-            None
-        }
-        fn comp_scene(&self) -> Option<crate::CompScene> {
-            Some(crate::CompScene { camera: self.camera, camera_layer: true, light: self.light })
-        }
-    }
-
-    fn run_env(id: &str, vals: &[(&str, Value)], img: Image, t: f64, host: &Scene) -> Image {
-        run_fx(id, vals, img, t, EffectEnv { host: Some(host), ..Default::default() }).img
-    }
-
-    #[test]
-    fn card_dance_camera_systems() {
-        let src = ramp(40, 30);
-        // Camera Position: rotating the camera changes the view; zero rotation is the layer.
-        let r = run("ec.sim.carddance", &[("cameraPosition/yRotation", num(30.0))], src.clone(), 0.0);
-        assert!(sum_diff(&r, &src) > 10.0);
-        let order = run("ec.sim.carddance", &[("cameraPosition/yRotation", num(30.0)), ("cameraPosition/xRotation", num(30.0))], src.clone(), 0.0);
-        let order2 = run(
-            "ec.sim.carddance",
-            &[("cameraPosition/yRotation", num(30.0)), ("cameraPosition/xRotation", num(30.0)), ("cameraPosition/transformOrder", Value::Enum(5))],
-            src.clone(),
-            0.0,
-        );
-        assert!(sum_diff(&order, &order2) > 1.0, "Transform Order matters");
-        // X, Y Position moves the view: the layer shifts by the offset.
-        let moved = run("ec.sim.carddance", &[("cameraPosition/xyPosition", pt(30.0, 15.0))], src.clone(), 0.0);
-        assert!((moved.get(25, 10)[0] - src.get(15, 10)[0]).abs() < 0.03, "{:?} {:?}", moved.get(25, 10), src.get(15, 10));
-        // Corner Pins: the layer's corners land on the pins.
-        let pins = [
-            ("cameraSystem", Value::Enum(1)),
-            ("cornerPins/upperLeftCorner", pt(10.0, 5.0)),
-            ("cornerPins/upperRightCorner", pt(30.0, 5.0)),
-            ("cornerPins/lowerLeftCorner", pt(10.0, 25.0)),
-            ("cornerPins/lowerRightCorner", pt(30.0, 25.0)),
-        ];
-        let cp = run("ec.sim.carddance", &pins, src.clone(), 0.0);
-        assert_eq!(cp.get(3, 3)[3], 0.0, "outside the pinned quad");
-        assert!(cp.get(20, 15)[3] > 0.99);
-        assert!((cp.get(20, 15)[0] - src.get(20, 15)[0]).abs() < 0.05, "centre maps to centre");
-        // Comp Camera: the identity camera reproduces the layer; a camera that doubles x moves it.
-        let ident = Scene { camera: Some([[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.002, 1.0]]), light: None, layer: None };
-        let cc = run_env("ec.sim.carddance", &[("cameraSystem", Value::Enum(2))], src.clone(), 0.0, &ident);
-        assert!(max_diff(&cc, &src) < 0.02, "{}", max_diff(&cc, &src));
-        let half = Scene { camera: Some([[0.5, 0.0, 0.0, 0.0], [0.0, 0.5, 0.0, 0.0], [0.0, 0.0, 0.002, 1.0]]), ..ident };
-        let cc = run_env("ec.sim.carddance", &[("cameraSystem", Value::Enum(2))], src.clone(), 0.0, &half);
-        assert_eq!(cc.get(35, 25)[3], 0.0, "half-size view leaves the far corner empty");
-    }
-
-    #[test]
-    fn card_dance_lighting_and_material() {
-        let src = Image::filled(40, 30, [0.5, 0.5, 0.5, 1.0]);
-        let tilt = [("rows", num(1.0)), ("columns", num(1.0)), ("yRotation/yRotSource", Value::Enum(0)), ("yRotation/yRotOffset", num(60.0))];
-        let lit = |extra: &[(&str, Value)]| {
-            let mut v: Vec<(&str, Value)> = tilt.to_vec();
-            v.extend_from_slice(extra);
-            run("ec.sim.carddance", &v, src.clone(), 0.0).get(20, 15)
-        };
-        let base = lit(&[]);
-        // Tilted cards facing away from a frontal light get darker than flat ones.
-        assert!(base[0] < 0.45, "{base:?}");
-        // Light colour tints; intensity brightens; ambient alone lights evenly.
-        let red = lit(&[("lighting/lightColor", col(1.0, 0.0, 0.0))]);
-        assert!(red[0] > red[1] + 0.05);
-        assert!(lit(&[("lighting/lightIntensity", num(2.0))])[0] > base[0]);
-        let amb = lit(&[("lighting/ambientLight", num(1.0)), ("material/diffuse", num(0.0))]);
-        assert!((amb[0] - 0.5).abs() < 1e-3);
-        // A light placed to the side (Point Source) changes the shading of the tilted card.
-        let side = lit(&[("lighting/lightType", Value::Enum(1)), ("lighting/lightPosition", pt(200.0, 15.0)), ("lighting/lightDepth", num(0.2))]);
-        assert!((side[0] - base[0]).abs() > 0.02, "{side:?} vs {base:?}");
-        // Specular adds a highlight on flat, frontally lit cards.
-        let flat = run("ec.sim.carddance", &[("material/specular", num(0.5))], src.clone(), 0.0).get(20, 15);
-        assert!(flat[0] > 0.9, "{flat:?}");
-        // First Comp Light: no light in the comp → ambient only; a light from the host is used.
-        let none = Scene { camera: None, light: None, layer: None };
-        let a = run_env("ec.sim.carddance", &[("lighting/lightType", Value::Enum(2))], src.clone(), 0.0, &none).get(20, 15);
-        assert!((a[0] - 0.5 * (0.25 + 0.75)).abs() < 1e-3, "{a:?}");
-        let blue = Scene { light: Some(crate::CompLight { pos: [20.0, 15.0, -100.0], dir: [0.0, 0.0, 1.0], color: [0.0, 0.0, 1.0], kind: 0 }), ..none };
-        let a = run_env("ec.sim.carddance", &[("lighting/lightType", Value::Enum(2))], src.clone(), 0.0, &blue).get(20, 15);
-        assert!(a[2] > a[0] + 0.2, "{a:?}");
-    }
-
-    #[test]
-    fn shatter_custom_map_gradient_textures_and_extrusion() {
-        let src = ramp(32, 32);
-        let base = [("view", Value::Enum(0)), ("force1/force1Position", pt(16.0, 16.0)), ("force1/force1Radius", num(2.0)), ("shape/origin", pt(16.0, 16.0))];
-        let with = |extra: &[(&str, Value)], t: f64, host: Option<&Scene>| {
-            let mut v: Vec<(&str, Value)> = base.to_vec();
-            v.extend_from_slice(extra);
-            match host {
-                Some(h) => run_env("ec.sim.shatter", &v, src.clone(), t, h),
-                None => run("ec.sim.shatter", &v, src.clone(), t),
-            }
-        };
-        // Custom Shatter Map: a map white on the left and black on the right; with White Tiles
-        // Fixed the left half stays put while the right half breaks away.
-        let mut map = Image::new(32, 32);
-        for y in 0..32 {
-            for x in 0..32 {
-                map.set(x, y, if x < 16 { [1.0; 4] } else { [0.0, 0.0, 0.0, 1.0] });
-            }
-        }
-        let host = Scene { camera: None, light: None, layer: Some(map) };
-        let custom = [("shape/pattern", Value::Enum(5)), ("shape/customShatterMap", Value::Layer(Some(1))), ("shape/whiteTilesFixed", Value::Bool(true))];
-        let at_rest = with(&custom, 0.0, Some(&host));
-        assert!(max_diff(&at_rest, &src) < 0.05, "custom pieces tile the layer: {}", max_diff(&at_rest, &src));
-        let broke = with(&custom, 1.0, Some(&host));
-        assert!(max_diff_region(&broke, &src, 0..12) < 0.05, "white tiles fixed");
-        assert!(sum_diff_region(&broke, &src, 20..32) > 5.0, "black group moved");
-        // Gradient: a black gradient layer with threshold 50 % keeps everything together.
-        let black = Scene { camera: None, light: None, layer: Some(Image::filled(32, 32, [0.0, 0.0, 0.0, 1.0])) };
-        let g = with(&[("gradient/gradientLayer", Value::Layer(Some(1))), ("gradient/shatterThreshold", num(50.0))], 1.0, Some(&black));
-        assert!(max_diff(&g, &src) < 0.05);
-        let gi = with(
-            &[("gradient/gradientLayer", Value::Layer(Some(1))), ("gradient/shatterThreshold", num(50.0)), ("gradient/invertGradient", Value::Bool(true))],
-            1.0,
-            Some(&black),
-        );
-        assert!(sum_diff(&gi, &src) > 10.0);
-        // Textures: Front Mode Color paints the pieces flat; Opacity fades them.
-        let flat = with(&[("textures/frontMode", Value::Enum(0)), ("textures/color", col(0.0, 1.0, 0.0))], 0.0, None);
-        let p = flat.get(16, 16);
-        assert!(p[1] > 0.95 && p[0] < 0.05, "{p:?}");
-        let half = with(&[("textures/opacity", num(0.5)), ("shape/repetitions", num(2.0))], 0.0, None);
-        assert!((half.get(8, 4)[3] - 0.5).abs() < 0.02, "{:?}", half.get(8, 4));
-        // Extrusion: thicker pieces cover more once they tumble.
-        let cover = |d: f64| {
-            with(&[("shape/extrusionDepth", num(d)), ("textures/sideMode", Value::Enum(0)), ("textures/color", col(1.0, 1.0, 1.0))], 0.6, None)
-                .data
-                .iter()
-                .map(|p| p[3])
-                .sum::<f32>()
-        };
-        assert!(cover(1.0) > cover(0.0) + 1.0, "{} vs {}", cover(1.0), cover(0.0));
-        // Deterministic and seek-consistent.
-        assert_eq!(with(&custom, 0.7, Some(&host)), with(&custom, 0.7, Some(&host)));
-    }
-
-    fn max_diff_region(a: &Image, b: &Image, xs: std::ops::Range<u32>) -> f32 {
-        let mut m = 0.0f32;
-        for y in 0..a.height {
-            for x in xs.clone() {
-                let (p, q) = (a.get(x as i64, y as i64), b.get(x as i64, y as i64));
-                m = (0..4).map(|k| (p[k] - q[k]).abs()).fold(m, f32::max);
-            }
-        }
-        m
-    }
-
-    fn sum_diff_region(a: &Image, b: &Image, xs: std::ops::Range<u32>) -> f32 {
-        let mut s = 0.0;
-        for y in 0..a.height {
-            for x in xs.clone() {
-                let (p, q) = (a.get(x as i64, y as i64), b.get(x as i64, y as i64));
-                s += (0..4).map(|k| (p[k] - q[k]).abs()).sum::<f32>();
-            }
-        }
-        s
-    }
-
-    /// Layer 1 = a left-dark, right-light ramp; layer 2 = solid green.
-    struct FoamHost;
-    impl crate::EffectHost for FoamHost {
-        fn layer(&self, id: u64, _: bool) -> Option<crate::LayerPixels> {
-            let img = if id == 1 { ramp(32, 32) } else { Image::filled(32, 32, [0.0, 1.0, 0.0, 1.0]) };
-            Some(crate::LayerPixels { buf: Buf { img, offset: [0.0; 2], scale: 1.0 }, size: [32.0, 32.0] })
-        }
-        fn layer_at(&self, id: u64, _: f64, me: bool) -> Option<crate::LayerPixels> {
-            self.layer(id, me)
-        }
-        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
-            None
-        }
-    }
-
-    #[test]
-    fn foam_flow_map_pop_velocity_wobble_textures_and_reflection() {
-        let base = vec![
-            ("producer/producerPoint", pt(16.0, 16.0)),
-            ("producer/productionRate", num(2.0)),
-            ("physics/windSpeed", num(0.0)),
-            ("physics/turbulence", num(0.0)),
-            ("view", Value::Enum(2)),
-        ];
-        let with = |extra: &[(&str, Value)], t: f64| {
-            let mut v = base.clone();
-            v.extend_from_slice(extra);
-            run_fx("ec.sim.foam", &v, Image::new(32, 32), t, EffectEnv { host: Some(&FoamHost), ..Default::default() }).img
-        };
-        let cx = |img: &Image| {
-            let (mut s, mut n) = (0.0, 0.0);
-            for y in 0..32 {
-                for x in 0..32 {
-                    let a = img.get(x, y)[3];
-                    s += a * x as f32;
-                    n += a;
-                }
-            }
-            s / n.max(1e-6)
-        };
-        // Flow map: bubbles run downhill (towards the dark left side).
-        let still = with(&[], 1.0);
-        let flowing = with(&[("flowMap/flowMap", Value::Layer(Some(1))), ("flowMap/flowMapSteepness", num(1.0))], 1.0);
-        assert!(cx(&flowing) < cx(&still) - 1.0, "{} vs {}", cx(&flowing), cx(&still));
-        let hq =
-            with(&[("flowMap/flowMap", Value::Layer(Some(1))), ("flowMap/flowMapSteepness", num(1.0)), ("flowMap/simulationQuality", Value::Enum(2))], 1.0);
-        assert_eq!(
-            hq,
-            with(&[("flowMap/flowMap", Value::Layer(Some(1))), ("flowMap/flowMapSteepness", num(1.0)), ("flowMap/simulationQuality", Value::Enum(2))], 1.0)
-        );
-        // Pop velocity scatters the survivors when short-lived bubbles pop.
-        let short = [("bubbles/lifespan", num(8.0)), ("bubbles/strength", num(0.0))];
-        let a = with(&[short.as_slice(), &[("physics/popVelocity", num(0.0))]].concat(), 1.0);
-        let b2 = with(&[short.as_slice(), &[("physics/popVelocity", num(20.0))]].concat(), 1.0);
-        assert_ne!(a, b2);
-        // Wobble changes the drawn bubbles.
-        assert_ne!(with(&[("physics/wobbleAmount", num(0.0))], 1.0), with(&[("physics/wobbleAmount", num(3.0))], 1.0));
-        // User Defined texture: bubbles show the texture layer (green).
-        let tex = with(&[("rendering/bubbleTexture", Value::Enum(5)), ("rendering/bubbleTextureLayer", Value::Layer(Some(2)))], 1.0);
-        assert!(tex.data.iter().any(|p| p[1] > 0.5 && p[0] < 0.1));
-        // Environment map: reflections tint the bubbles.
-        let refl = with(&[("rendering/environmentMap", Value::Layer(Some(2))), ("rendering/reflectionStrength", num(1.0))], 1.0);
-        let g = |i: &Image| i.data.iter().map(|p| p[1] - p[0]).sum::<f32>();
-        assert!(g(&refl) > g(&still) + 1.0);
-        // Zoom Producer Point zooms about the producer instead of the layer centre.
-        let off = [("producer/producerPoint", pt(8.0, 8.0)), ("zoom", num(2.0))];
-        let z1 = with(&off, 1.0);
-        let z2 = with(&[off.as_slice(), &[("producer/zoomProducerPoint", Value::Bool(true))]].concat(), 1.0);
-        assert!((cx(&z2) - 8.0).abs() < 2.0 && cx(&z1) < 4.0, "{} vs {}", cx(&z2), cx(&z1));
-    }
-}
+mod tests;
diff --git a/crates/effects/src/sim2/foam.rs b/crates/effects/src/sim2/foam.rs
new file mode 100644
index 000000000..fc187d191
--- /dev/null
+++ b/crates/effects/src/sim2/foam.rs
@@ -0,0 +1,411 @@
+use super::{
+    Acc, Buf, EffectCtx, Image, IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelIterator, Plane, Px, Shape, SimCache,
+    Sprite, Value, hs, params_key, splat, unpremul, value_noise,
+};
+
+// ------------------------------------------------------------------ Foam
+
+#[derive(Clone, Debug)]
+struct FoamBubble {
+    p: [f32; 2],
+    v: [f32; 2],
+    age: f32,
+    size: f32,
+    /// Spin (radians) for Physical Orientation.
+    spin: f32,
+    id: u32,
+}
+
+#[derive(Clone, Debug, Default)]
+struct FoamState {
+    b: Vec<FoamBubble>,
+    carry: f32,
+    next: u32,
+}
+
+static FOAM_CACHE: SimCache<FoamState> = SimCache::new(4);
+
+/// Foam steps once per frame at 30 frames per second.
+const FOAM_FPS: f64 = 30.0;
+
+/// Foam's Bubble Texture options (the last uses Bubble Texture Layer).
+pub(super) const FOAM_TEXTURES: [&str; 6] = ["Default Bubble", "Spit", "Bubblegum", "Dishwater", "Milky", "User Defined"];
+
+/// Age (in simulation steps) at which bubble `id` pops: its lifespan, shortened at random for
+/// frail bubbles (`frailty` 0 = every bubble reaches `lifespan`, 1 = uniformly early).
+pub(super) fn foam_pop_age(id: u32, lifespan: f32, frailty: f32, seed: u32) -> f32 {
+    lifespan * (1.0 - frailty * (hs(id, 11, seed) * 0.5 + 0.5))
+}
+
+/// Foam: bubbles born in the producer rectangle grow to their size, drift with the wind,
+/// turbulence and the Flow Map (bubbles run downhill on its luminance), repel and stick to each
+/// other, wobble, and pop at the end of their (Strength-shortened) lifespan, pushing their
+/// neighbours away at Pop Velocity. Rendered bubbles use a built-in texture or the Bubble
+/// Texture Layer, oriented by Bubble Orientation, and reflect the Environment Map.
+pub(super) fn foam(ctx: &EffectCtx, b: Buf) -> Buf {
+    foam_full_plan(ctx, &b).finish(b)
+}
+
+/// Foam's bubbles as sprites, `None` when it draws more than sprites (a User Defined bubble
+/// texture, an Environment Map reflection or the Draft + Flow Map view's flow map).
+pub(crate) fn foam_plan(ctx: &EffectCtx, b: &Buf) -> Option<crate::sim::SpritePlan> {
+    let plan = foam_full_plan(ctx, b);
+    (plan.user.is_none() && plan.env.is_none() && plan.flow.is_none()).then_some(plan.sprites)
+}
+
+/// A bubble disc filled by Foam's User Defined texture (buffer px; `rot` radians).
+#[derive(Clone, Copy, Debug)]
+pub struct FoamDisc {
+    pub x: f64,
+    pub y: f64,
+    pub r: f32,
+    pub rot: f32,
+    pub fade: f32,
+}
+
+/// Foam's Environment Map reflection: the map fitted to the buffer, Reflection Convergence and
+/// Strength, and the bubble discs reflecting it (`rot` and `fade` unused).
+pub struct FoamEnv {
+    pub img: Image,
+    pub conv: f64,
+    pub strength: f32,
+    pub discs: Vec<FoamDisc>,
+}
+
+/// What Foam draws this frame over a transparent frame of the layer's size: the bubble sprites,
+/// then the User Defined texture's discs, the Environment Map's reflections and (Draft + Flow
+/// Map) the flow map under it all, each `foam_disc`-composited in bubble order.
+pub struct FoamPlan {
+    pub sprites: crate::sim::SpritePlan,
+    pub user: Option<(crate::LayerPixels, Vec<FoamDisc>)>,
+    pub env: Option<FoamEnv>,
+    /// The flow map fitted to the buffer.
+    pub flow: Option<Image>,
+}
+
+impl FoamPlan {
+    pub fn finish(&self, b: Buf) -> Buf {
+        let mut out = splat(b.img.width, b.img.height, &self.sprites.sprites, self.sprites.acc);
+        // User Defined: the texture layer fills each bubble's disc.
+        if let Some((tex, discs)) = &self.user {
+            for d in discs {
+                let (rot, fade) = (d.rot, d.fade);
+                foam_disc(&mut out, d.x, d.y, d.r as f64, |u, v| {
+                    // u, v in −1..1 across the bubble, rotated into the texture.
+                    let (sr, cr) = rot.sin_cos();
+                    let (tu, tv) = (u as f32 * cr + v as f32 * sr, -u as f32 * sr + v as f32 * cr);
+                    let (x, y) = ((tu as f64 * 0.5 + 0.5) * tex.size[0], (tv as f64 * 0.5 + 0.5) * tex.size[1]);
+                    let px = tex.buf.img.sample_bilinear(x * tex.buf.scale + tex.buf.offset[0], y * tex.buf.scale + tex.buf.offset[1]);
+                    px.map(|c| c * fade)
+                });
+            }
+        }
+        // Environment Map: each bubble reflects the map along its sphere normal (Reflection
+        // Convergence pulls the reflection towards the bubble's own spot of the map).
+        if let Some(env) = &self.env {
+            let (conv, strength) = (env.conv, env.strength);
+            let (w, h) = (b.img.width as f64, b.img.height as f64);
+            for d in &env.discs {
+                let (bx, by) = (d.x, d.y);
+                foam_disc(&mut out, bx, by, d.r as f64, |u, v| {
+                    // Sphere normal; the reflection looks across the whole map, or (convergence 1)
+                    // just behind the bubble.
+                    let (ex, ey) =
+                        if conv >= 1.0 { (bx, by) } else { (bx * conv + (u * 0.5 + 0.5) * w * (1.0 - conv), by * conv + (v * 0.5 + 0.5) * h * (1.0 - conv)) };
+                    let e = env.img.sample_bilinear(ex, ey);
+                    let rim = ((u * u + v * v) as f32).min(1.0);
+                    let k = strength * (0.3 + 0.7 * rim);
+                    [e[0] * k, e[1] * k, e[2] * k, 0.0]
+                });
+            }
+        }
+        // Draft + Flow Map shows the flow map under the bubbles.
+        if let Some(fm) = &self.flow {
+            out.data.par_iter_mut().zip(fm.data.par_iter()).for_each(|(o, f)| {
+                let k = 1.0 - o[3];
+                for c in 0..4 {
+                    o[c] += f[c] * 0.5 * k;
+                }
+            });
+        }
+        Buf { img: out, ..b }
+    }
+}
+
+/// Foam's [`FoamPlan`] for layer geometry `b` (its size; its pixels are not read).
+pub fn foam_full_plan(ctx: &EffectCtx, b: &Buf) -> FoamPlan {
+    let pr = ctx.params;
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let unit = lw * 0.01;
+    let prod = pr.v2("producer/producerPoint");
+    let (psx, psy) = (pr.f("producer/producerXSize") as f32 * lw, pr.f("producer/producerYSize") as f32 * lh);
+    let porient = (pr.f("producer/producerOrientation") as f32).to_radians();
+    let rate = pr.f("producer/productionRate").max(0.0) as f32;
+    let size = pr.f("bubbles/size").max(0.0) as f32;
+    let size_var = pr.f("bubbles/sizeVariance") as f32;
+    let lifespan = pr.f("bubbles/lifespan").max(1.0) as f32;
+    let growth = pr.f("bubbles/growthSpeed").max(0.0001) as f32;
+    // Strength: weaker bubbles tend to pop before their lifespan (at 20 or more every bubble
+    // lives the full lifespan); each bubble gets its own pop age.
+    let frailty = 1.0 - (pr.f("bubbles/strength") as f32 / 20.0).clamp(0.0, 1.0);
+    let init_speed = pr.f("physics/initialSpeed") as f32;
+    let init_dir = (pr.f("physics/initialDirection") as f32).to_radians();
+    let wind = pr.f("physics/windSpeed") as f32;
+    let wind_dir = (pr.f("physics/windDirection") as f32).to_radians();
+    let turb = pr.f("physics/turbulence") as f32;
+    let wobble = pr.f("physics/wobbleAmount").max(0.0) as f32;
+    let repulsion = pr.f("physics/repulsion") as f32;
+    let pop_velocity = pr.f("physics/popVelocity") as f32;
+    let viscosity = pr.f("physics/viscosity").clamp(0.0, 1.0) as f32;
+    let sticky = pr.f("physics/stickiness").clamp(0.0, 1.0) as f32;
+    let universe = pr.f("universeSize").max(0.01) as f32;
+    let seed = (pr.f("randomSeed") as u32).wrapping_mul(0x68e31da4) ^ ctx.seed;
+    let wvec = [wind_dir.sin() * wind * unit, -wind_dir.cos() * wind * unit];
+    // Flow Map: the map layer's first frame, its luminance a height field (Fits the layer or
+    // the whole universe).
+    let flow = pr.get("flowMap/flowMap").and_then(Value::as_layer).and_then(|id| {
+        let host = ctx.env.host?;
+        let me = pr.get(&crate::layer_source_id("flowMap/flowMap")).is_none_or(|v| v.as_enum() != 0);
+        host.layer_at(id, ctx.env.comp_time - ctx.time, me)
+    });
+    let steep = pr.f("flowMap/flowMapSteepness") as f32;
+    let fits_universe = pr.e("flowMap/flowMapFits") == 1;
+    let substeps = match pr.e("flowMap/simulationQuality") {
+        1 => 2,
+        2 => 4,
+        _ => 1,
+    };
+    let height = flow.as_ref().map(|lp| {
+        let img = &lp.buf.img;
+        let pl = Plane::from_image(img, |px| {
+            let (c, a) = unpremul(px);
+            effectcraft_color::luminance(c[0], c[1], c[2]) * a
+        });
+        (pl, lp.buf.scale, lp.buf.offset, lp.size)
+    });
+    let (ux0, uy0) = (-(universe - 1.0) * 0.5 * lw, -(universe - 1.0) * 0.5 * lh);
+    let (ux1, uy1) = (lw - ux0, lh - uy0);
+    // Height at a layer point (0..1).
+    let h_at = |x: f32, y: f32| -> f32 {
+        let Some((pl, s, off, size)) = &height else { return 0.0 };
+        let (fx, fy) = if fits_universe { ((x - ux0) / (ux1 - ux0), (y - uy0) / (uy1 - uy0)) } else { (x / lw, y / lh) };
+        pl.sample(fx as f64 * size[0] * s + off[0], fy as f64 * size[1] * s + off[1])
+    };
+    let mut key = params_key(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: 1.0 }, 5);
+    if let Some((pl, ..)) = &height {
+        key ^= pl.data.iter().step_by(5).fold(0u64, |a, v| a.rotate_left(3) ^ v.to_bits() as u64);
+    }
+    let steps = if ctx.time <= 0.0 { 0 } else { (ctx.time * FOAM_FPS + 1e-6).floor() as u64 };
+    let rad = |q: &FoamBubble| q.size * unit * 3.0 * (q.age * growth).min(1.0);
+    let st = FOAM_CACHE.run(key, steps, FoamState::default, |st, step| {
+        let t = step as f32 / FOAM_FPS as f32;
+        // Births.
+        st.carry += rate;
+        let n = st.carry.floor() as u32;
+        st.carry -= n as f32;
+        for _ in 0..n {
+            if st.b.len() >= 3000 {
+                break;
+            }
+            let id = st.next;
+            st.next = st.next.wrapping_add(1);
+            let (ux, uy) = (hs(id, 1, seed) * 0.5 * psx, hs(id, 2, seed) * 0.5 * psy);
+            let (so, co) = porient.sin_cos();
+            let p = [prod[0] as f32 + ux * co - uy * so, prod[1] as f32 + ux * so + uy * co];
+            let v = [init_dir.sin() * init_speed * unit, -init_dir.cos() * init_speed * unit];
+            let sz = (size * (1.0 + size_var * hs(id, 3, seed))).max(0.01);
+            st.b.push(FoamBubble { p, v, age: 0.0, size: sz, spin: hs(id, 12, seed) * std::f32::consts::PI, id });
+        }
+        for _ in 0..substeps {
+            let k = 1.0 / substeps as f32;
+            // Forces: drift towards the wind, turbulence, viscosity, the flow map's slope.
+            for q in st.b.iter_mut() {
+                let n1 = value_noise(q.p[0] / (lw * 0.15), q.p[1] / (lw * 0.15), t * 0.5, seed) - 0.5;
+                let n2 = value_noise(q.p[0] / (lw * 0.15) + 19.0, q.p[1] / (lw * 0.15), t * 0.5, seed) - 0.5;
+                for c in 0..2 {
+                    q.v[c] += (wvec[c] - q.v[c]) * 0.1 * k;
+                    q.v[c] *= 1.0 - viscosity * 0.5 * k;
+                }
+                q.v[0] += n1 * turb * unit * k;
+                q.v[1] += n2 * turb * unit * k;
+                if height.is_some() && steep != 0.0 {
+                    let e = unit.max(1.0);
+                    let gx = (h_at(q.p[0] + e, q.p[1]) - h_at(q.p[0] - e, q.p[1])) / (2.0 * e);
+                    let gy = (h_at(q.p[0], q.p[1] + e) - h_at(q.p[0], q.p[1] - e)) / (2.0 * e);
+                    // Downhill: from light (high) to dark (low).
+                    q.v[0] -= gx * steep * lw * 0.5 * k;
+                    q.v[1] -= gy * steep * lw * 0.5 * k;
+                }
+                // Physical Orientation: bubbles roll with their sideways motion.
+                q.spin += q.v[0] / (rad(q).max(0.5)) * k;
+            }
+            // Repulsion between overlapping bubbles (grid hashed, deterministic order).
+            if repulsion > 0.0 && st.b.len() > 1 {
+                let maxr = st.b.iter().map(rad).fold(0.0f32, f32::max).max(1.0);
+                let cs = maxr * 2.0;
+                let mut grid: std::collections::HashMap<(i32, i32), Vec<usize>> = std::collections::HashMap::new();
+                for (i, q) in st.b.iter().enumerate() {
+                    grid.entry(((q.p[0] / cs).floor() as i32, (q.p[1] / cs).floor() as i32)).or_default().push(i);
+                }
+                let mut push = vec![[0.0f32; 2]; st.b.len()];
+                for (i, q) in st.b.iter().enumerate() {
+                    let (gx, gy) = ((q.p[0] / cs).floor() as i32, (q.p[1] / cs).floor() as i32);
+                    for dy in -1..=1 {
+                        for dx in -1..=1 {
+                            let Some(list) = grid.get(&(gx + dx, gy + dy)) else { continue };
+                            for &j in list {
+                                if j <= i {
+                                    continue;
+                                }
+                                let o = &st.b[j];
+                                let (ddx, ddy) = (o.p[0] - q.p[0], o.p[1] - q.p[1]);
+                                let d = (ddx * ddx + ddy * ddy).sqrt().max(1e-4);
+                                let overlap = rad(q) + rad(o) - d;
+                                if overlap > 0.0 {
+                                    let f = overlap * 0.5 * repulsion.min(4.0) * (1.0 - sticky * 0.5) / d * k;
+                                    push[i][0] -= ddx * f;
+                                    push[i][1] -= ddy * f;
+                                    push[j][0] += ddx * f;
+                                    push[j][1] += ddy * f;
+                                }
+                            }
+                        }
+                    }
+                }
+                for (q, d) in st.b.iter_mut().zip(&push) {
+                    q.p[0] += d[0].clamp(-maxr, maxr);
+                    q.p[1] += d[1].clamp(-maxr, maxr);
+                }
+            }
+            for q in st.b.iter_mut() {
+                q.p[0] += q.v[0] * k;
+                q.p[1] += q.v[1] * k;
+            }
+        }
+        for q in st.b.iter_mut() {
+            q.age += 1.0;
+        }
+        // Pops: bubbles past their pop age burst, pushing their neighbours away.
+        let popped: Vec<([f32; 2], f32)> = st.b.iter().filter(|q| q.age >= foam_pop_age(q.id, lifespan, frailty, seed)).map(|q| (q.p, rad(q))).collect();
+        if pop_velocity != 0.0 {
+            for (pp, pr_) in &popped {
+                let reach = (pr_ * 3.0).max(unit);
+                for q in st.b.iter_mut() {
+                    let (dx, dy) = (q.p[0] - pp[0], q.p[1] - pp[1]);
+                    let d = (dx * dx + dy * dy).sqrt();
+                    if d > 1e-4 && d < reach {
+                        let f = pop_velocity * unit * (1.0 - d / reach) / d;
+                        q.v[0] += dx * f;
+                        q.v[1] += dy * f;
+                    }
+                }
+            }
+        }
+        st.b.retain(|q| q.age < foam_pop_age(q.id, lifespan, frailty, seed) && q.p[0] > ux0 && q.p[0] < ux1 && q.p[1] > uy0 && q.p[1] < uy1);
+    });
+    let view = pr.e("view");
+    let zoom = pr.f("zoom").max(0.01) as f32;
+    let zoom_producer = pr.b("producer/zoomProducerPoint");
+    let texture = pr.e("rendering/bubbleTexture");
+    let orient = pr.e("rendering/bubbleOrientation");
+    let blend = pr.e("rendering/blendMode");
+    let s = b.scale as f32;
+    // Zoom centres on the layer, or on the producer with Zoom Producer Point.
+    let (cx, cy) = if zoom_producer { (prod[0] as f32, prod[1] as f32) } else { (lw * 0.5, lh * 0.5) };
+    let mut order: Vec<&FoamBubble> = st.b.iter().collect();
+    if blend == 2 {
+        // Solid New on Top: oldest first.
+        order.sort_by(|a, c| c.age.total_cmp(&a.age).then(a.id.cmp(&c.id)));
+    } else if blend == 1 {
+        order.sort_by(|a, c| a.age.total_cmp(&c.age).then(a.id.cmp(&c.id)));
+    }
+    // Where a bubble is drawn: buffer centre, radius, rotation (radians).
+    let place = |q: &FoamBubble| {
+        let wob = if wobble > 0.0 { 1.0 + wobble * 0.15 * ((q.age * 0.35) + hs(q.id, 13, seed) * 6.0).sin() } else { 1.0 };
+        let r = rad(q) * wob * zoom * s;
+        let (bx, by) = b.to_px([(cx + (q.p[0] - cx) * zoom) as f64, (cy + (q.p[1] - cy) * zoom) as f64]);
+        let rot = match orient {
+            1 => q.spin,
+            2 => q.v[1].atan2(q.v[0]),
+            _ => 0.0,
+        };
+        (bx, by, r, rot)
+    };
+    let user_tex = (view == 2 && texture == 5).then(|| ctx.layer_param("rendering/bubbleTextureLayer", true)).flatten();
+    let sprites: Vec<Sprite> = order
+        .iter()
+        .filter(|_| user_tex.is_none())
+        .map(|q| {
+            let (bx, by, r, rot) = place(q);
+            let fade = ((foam_pop_age(q.id, lifespan, frailty, seed) - q.age) / 5.0).clamp(0.0, 1.0);
+            // Draft and Draft + Flow Map show the wireframe-style bubbles.
+            let mut sp = if view != 2 {
+                Sprite::new(bx as f32, by as f32, r, [0.55, 0.75, 1.0, fade], Shape::Bubble)
+            } else {
+                let (c, shape) = match texture {
+                    1 => ([0.95, 0.95, 0.92], Shape::Faded),
+                    2 => ([1.0, 0.6, 0.8], Shape::Bubble),
+                    3 => ([0.8, 0.85, 0.75], Shape::Bubble),
+                    4 => ([0.97, 0.97, 0.95], Shape::Sphere),
+                    _ => ([1.0, 1.0, 1.0], Shape::Bubble),
+                };
+                Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], fade], shape)
+            };
+            sp.rot = rot;
+            sp
+        })
+        .collect();
+    let acc = if blend == 0 && view == 2 { Acc::Add } else { Acc::Over };
+    let disc = |q: &&FoamBubble| {
+        let (x, y, r, rot) = place(q);
+        let fade = ((foam_pop_age(q.id, lifespan, frailty, seed) - q.age) / 5.0).clamp(0.0, 1.0);
+        FoamDisc { x, y, r, rot, fade }
+    };
+    let user = user_tex.map(|tex| (tex, order.iter().map(disc).collect()));
+    let strength = pr.f("rendering/reflectionStrength").clamp(0.0, 1.0) as f32;
+    let env = if view == 2
+        && strength > 0.0
+        && let Some(env) = ctx.layer_param("rendering/environmentMap", true)
+    {
+        Some(FoamEnv {
+            img: crate::util::fit_layer(ctx, b, &env, true),
+            conv: pr.f("rendering/reflectionConvergence").clamp(0.0, 1.0),
+            strength,
+            discs: order.iter().map(disc).collect(),
+        })
+    } else {
+        None
+    };
+    let flow = if view == 1
+        && let Some(lp) = &flow
+    {
+        Some(crate::util::fit_layer(ctx, b, lp, true))
+    } else {
+        None
+    };
+    FoamPlan { sprites: crate::sim::SpritePlan { sprites, tints: vec![], acc, post: crate::sim::Post::Replace }, user, env, flow }
+}
+
+/// Add `f(u, v)` (premultiplied; u, v ∈ −1..1 across the disc) over the disc of radius `r` at
+/// (`x`, `y`) with anti-aliased edges ("over" for opaque texels, additive for alpha 0).
+fn foam_disc(out: &mut Image, x: f64, y: f64, r: f64, f: impl Fn(f64, f64) -> Px) {
+    if r <= 0.0 {
+        return;
+    }
+    let (x0, x1) = ((x - r - 1.0).floor().max(0.0) as i64, (x + r + 1.0).ceil().min(out.width as f64) as i64);
+    let (y0, y1) = ((y - r - 1.0).floor().max(0.0) as i64, (y + r + 1.0).ceil().min(out.height as f64) as i64);
+    for py in y0..y1 {
+        for px in x0..x1 {
+            let (u, v) = ((px as f64 + 0.5 - x) / r, (py as f64 + 0.5 - y) / r);
+            let d = (u * u + v * v).sqrt();
+            let cov = ((1.0 - d) * r + 0.5).clamp(0.0, 1.0) as f32;
+            if cov <= 0.0 {
+                continue;
+            }
+            let s = f(u.clamp(-1.0, 1.0), v.clamp(-1.0, 1.0)).map(|c| c * cov);
+            let o = out.get(px, py);
+            let k = 1.0 - s[3];
+            out.set(px as u32, py as u32, [s[0] + o[0] * k, s[1] + o[1] * k, s[2] + o[2] * k, (s[3] + o[3] * k).min(1.0)]);
+        }
+    }
+}
diff --git a/crates/effects/src/sim2/pieces.rs b/crates/effects/src/sim2/pieces.rs
new file mode 100644
index 000000000..bff5943c0
--- /dev/null
+++ b/crates/effects/src/sim2/pieces.rs
@@ -0,0 +1,277 @@
+use super::shatter::{ShatterPlan, card_dance_plan, shatter_impl};
+use super::{Acc, Buf, EffectCtx, Image, Lighting, Proj, raster, unpremul};
+
+// ------------------------------------------------------------------ 3D pieces
+
+pub(crate) type M3 = [[f64; 3]; 3];
+
+fn mat_mul(a: &M3, b: &M3) -> M3 {
+    std::array::from_fn(|i| std::array::from_fn(|j| (0..3).map(|k| a[i][k] * b[k][j]).sum()))
+}
+
+/// Rotation from Euler angles (radians), applied X then Y then Z.
+pub(super) fn rot_xyz(x: f64, y: f64, z: f64) -> M3 {
+    let (sx, cx) = x.sin_cos();
+    let (sy, cy) = y.sin_cos();
+    let (sz, cz) = z.sin_cos();
+    let rx = [[1.0, 0.0, 0.0], [0.0, cx, -sx], [0.0, sx, cx]];
+    let ry = [[cy, 0.0, sy], [0.0, 1.0, 0.0], [-sy, 0.0, cy]];
+    let rz = [[cz, -sz, 0.0], [sz, cz, 0.0], [0.0, 0.0, 1.0]];
+    mat_mul(&rz, &mat_mul(&ry, &rx))
+}
+
+/// Rotation by `angle` about unit `axis` (Rodrigues).
+pub(crate) fn rot_axis(axis: [f64; 3], angle: f64) -> M3 {
+    let l = (axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]).sqrt();
+    if l < 1e-12 || angle == 0.0 {
+        return [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];
+    }
+    let (x, y, z) = (axis[0] / l, axis[1] / l, axis[2] / l);
+    let (s, c) = angle.sin_cos();
+    let t = 1.0 - c;
+    [
+        [t * x * x + c, t * x * y - s * z, t * x * z + s * y],
+        [t * x * y + s * z, t * y * y + c, t * y * z - s * x],
+        [t * x * z - s * y, t * y * z + s * x, t * z * z + c],
+    ]
+}
+
+pub(super) fn inv3(m: &M3) -> Option<M3> {
+    let det = m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
+        + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
+    if det.abs() < 1e-12 {
+        return None;
+    }
+    let d = 1.0 / det;
+    Some([
+        [(m[1][1] * m[2][2] - m[1][2] * m[2][1]) * d, (m[0][2] * m[2][1] - m[0][1] * m[2][2]) * d, (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * d],
+        [(m[1][2] * m[2][0] - m[1][0] * m[2][2]) * d, (m[0][0] * m[2][2] - m[0][2] * m[2][0]) * d, (m[0][2] * m[1][0] - m[0][0] * m[1][2]) * d],
+        [(m[1][0] * m[2][1] - m[1][1] * m[2][0]) * d, (m[0][1] * m[2][0] - m[0][0] * m[2][1]) * d, (m[0][0] * m[1][1] - m[0][1] * m[1][0]) * d],
+    ])
+}
+
+/// Perspective camera looking down +z at the layer plane z = 0, `d` pixels away, centred on
+/// `c` (buffer pixels): screen = c + (P - c) · d / (d + z).
+#[derive(Clone, Copy)]
+pub(super) struct Cam {
+    pub(super) c: [f64; 2],
+    pub(super) d: f64,
+}
+
+impl Cam {
+    fn proj(self) -> Proj {
+        Proj::simple(self.c, self.d)
+    }
+}
+
+/// A planar textured piece ready to draw.
+#[derive(Clone, Copy, Debug)]
+pub struct Piece {
+    /// Screen (buffer px, homogeneous) → piece-local (a, b, w).
+    pub inv: [[f64; 3]; 3],
+    /// Rest centre of the piece in texture pixels.
+    pub c0: [f32; 2],
+    /// Convex polygon (texture pixels), counter-clockwise in y-down space.
+    pub poly: [[f32; 2]; 6],
+    pub n: u8,
+    pub bbox: [f32; 4],
+    pub shade: f32,
+    /// Lighting: colour multiplier and additive specular highlight.
+    pub tint: [f32; 3],
+    pub spec: [f32; 3],
+    pub alpha: f32,
+    /// Flat straight colour instead of the texture.
+    pub flat: Option<[f32; 3]>,
+    /// Facing away from the camera (draw the back texture).
+    pub back: bool,
+    /// Back faces sample their texture mirrored about the piece centre: 0 no, 1 vertically
+    /// (flipped about the X axis), 2 horizontally (about the Y axis).
+    pub back_mirror: u8,
+    depth: f64,
+}
+
+/// A piece texture: the layer itself or another image (buffer-aligned).
+#[derive(Clone, Debug)]
+pub enum PieceTex {
+    Layer,
+    Image(Image),
+}
+
+/// What a piece-drawing effect (Card Dance, Shatter, Card Wipe) draws this frame: pieces sorted
+/// far to near over a transparent frame, textured by `front` (and `back` for pieces facing
+/// away; none = they take `front`).
+#[derive(Clone, Debug)]
+pub struct PiecePlan {
+    pub pieces: Vec<Piece>,
+    pub front: PieceTex,
+    pub back: Option<PieceTex>,
+}
+
+impl PiecePlan {
+    /// Rasterise over a transparent frame of the layer `b`'s size.
+    pub fn finish(&self, mut b: Buf) -> Buf {
+        let mut out = Image::new(b.img.width, b.img.height);
+        let front = match &self.front {
+            PieceTex::Layer => &b.img,
+            PieceTex::Image(i) => i,
+        };
+        let back = self.back.as_ref().map(|t| match t {
+            PieceTex::Layer => &b.img,
+            PieceTex::Image(i) => i,
+        });
+        draw_pieces(&mut out, &self.pieces, front, back);
+        b.img = out;
+        b
+    }
+}
+
+/// The piece plan of Card Dance, Shatter (Rendered view) or Card Wipe for layer `b` (its pixels
+/// may be read: gradient maps and textures default to the layer), `None` for other effects or
+/// views drawn otherwise.
+pub fn piece_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option<PiecePlan> {
+    match id {
+        "ec.sim.carddance" => Some(card_dance_plan(ctx, b)),
+        "ec.sim.shatter" if ctx.params.e("view") == 0 => match shatter_impl(ctx, b) {
+            ShatterPlan::Pieces(plan) => Some(plan),
+            ShatterPlan::Wire(_) => None,
+        },
+        "ec.transition.cardwipe" => crate::transition::card_wipe_plan(ctx, b),
+        _ => None,
+    }
+}
+
+impl Piece {
+    /// Place polygon `poly` (texture px, around rest centre `c0`) with rotation `r` and its
+    /// centre at 3D `pos` (buffer px; z away from the camera), seen through `cam`.
+    pub(crate) fn new(poly: &[[f32; 2]], c0: [f32; 2], r: &M3, pos: [f64; 3], cam: impl Into<Proj>) -> Option<Piece> {
+        let cam: Proj = cam.into();
+        let n = poly.len().min(6);
+        if n < 3 {
+            return None;
+        }
+        let m = &cam.m;
+        let row = |i: usize| -> [f64; 3] {
+            [
+                m[i][0] * r[0][0] + m[i][1] * r[1][0] + m[i][2] * r[2][0],
+                m[i][0] * r[0][1] + m[i][1] * r[1][1] + m[i][2] * r[2][1],
+                m[i][0] * pos[0] + m[i][1] * pos[1] + m[i][2] * pos[2] + m[i][3],
+            ]
+        };
+        let hm: M3 = [row(0), row(1), row(2)];
+        let mut bb = [f32::INFINITY, f32::INFINITY, f32::NEG_INFINITY, f32::NEG_INFINITY];
+        for v in &poly[..n] {
+            let (a, b) = ((v[0] - c0[0]) as f64, (v[1] - c0[1]) as f64);
+            let w = hm[2][0] * a + hm[2][1] * b + hm[2][2];
+            if w < cam.near {
+                return None;
+            }
+            let sx = ((hm[0][0] * a + hm[0][1] * b + hm[0][2]) / w) as f32;
+            let sy = ((hm[1][0] * a + hm[1][1] * b + hm[1][2]) / w) as f32;
+            bb = [bb[0].min(sx), bb[1].min(sy), bb[2].max(sx), bb[3].max(sy)];
+        }
+        let inv = inv3(&hm)?;
+        let mut pp = [[0.0f32; 2]; 6];
+        pp[..n].copy_from_slice(&poly[..n]);
+        // Normalise winding so "inside" is cross >= 0 for every edge.
+        let area: f32 = (0..n).map(|i| pp[i][0] * pp[(i + 1) % n][1] - pp[(i + 1) % n][0] * pp[i][1]).sum();
+        if area < 0.0 {
+            pp[..n].reverse();
+        }
+        // The front faces -z at rest; it faces the camera when its normal points at the eye.
+        let eye = cam.eye();
+        let nrm = [-r[0][2], -r[1][2], -r[2][2]];
+        let to_eye = [eye[0] - pos[0], eye[1] - pos[1], eye[2] - pos[2]];
+        let facing = nrm[0] * to_eye[0] + nrm[1] * to_eye[1] + nrm[2] * to_eye[2];
+        let depth = hm[2][2];
+        Some(Piece {
+            inv,
+            c0,
+            poly: pp,
+            n: n as u8,
+            bbox: [bb[0] - 1.0, bb[1] - 1.0, bb[2] + 1.0, bb[3] + 1.0],
+            shade: 1.0,
+            tint: [1.0; 3],
+            spec: [0.0; 3],
+            alpha: 1.0,
+            flat: None,
+            back: facing < 0.0,
+            back_mirror: 0,
+            depth,
+        })
+    }
+
+    /// Lambert factor of the piece normal against a light shining along +z.
+    pub(super) fn facing(r: &M3) -> f32 {
+        r[2][2].abs() as f32
+    }
+
+    /// Light the piece (rotation `r`, centre `pos`) with Lighting / Material.
+    pub(crate) fn light(&mut self, l: &Lighting, r: &M3, pos: [f64; 3], eye: [f64; 3]) {
+        let (t, s) = l.shade([-r[0][2], -r[1][2], -r[2][2]], pos, eye);
+        self.tint = t;
+        self.spec = s;
+    }
+}
+
+impl From<Cam> for Proj {
+    fn from(c: Cam) -> Proj {
+        c.proj()
+    }
+}
+
+/// Draw pieces (already sorted far → near) over `out`.
+pub(crate) fn draw_pieces(out: &mut Image, pieces: &[Piece], front: &Image, back: Option<&Image>) {
+    raster(
+        out,
+        pieces,
+        |q| Some(q.bbox),
+        |q, x, y| {
+            let (xf, yf) = (x as f64, y as f64);
+            let m = &q.inv;
+            let w = m[2][0] * xf + m[2][1] * yf + m[2][2];
+            if w.abs() < 1e-12 {
+                return None;
+            }
+            let u = ((m[0][0] * xf + m[0][1] * yf + m[0][2]) / w) as f32 + q.c0[0];
+            let v = ((m[1][0] * xf + m[1][1] * yf + m[1][2]) / w) as f32 + q.c0[1];
+            let n = q.n as usize;
+            let mut md = f32::INFINITY;
+            for i in 0..n {
+                let a = q.poly[i];
+                let b = q.poly[(i + 1) % n];
+                let (ex, ey) = (b[0] - a[0], b[1] - a[1]);
+                let l = (ex * ex + ey * ey).sqrt().max(1e-6);
+                md = md.min((ex * (v - a[1]) - ey * (u - a[0])) / l);
+            }
+            // Coverage extends half a pixel past the edge so abutting pieces leave no seams.
+            let cov = (md + 1.0).clamp(0.0, 1.0);
+            if cov <= 0.0 {
+                return None;
+            }
+            let (c, a) = match q.flat {
+                Some(c) => (c, 1.0),
+                None => {
+                    let tex = if q.back { back.unwrap_or(front) } else { front };
+                    let (u, v) = match (q.back, q.back_mirror) {
+                        (true, 1) => (u, 2.0 * q.c0[1] - v),
+                        (true, 2) => (2.0 * q.c0[0] - u, v),
+                        _ => (u, v),
+                    };
+                    unpremul(tex.sample_bilinear(u as f64, v as f64))
+                }
+            };
+            let a = a * cov * q.alpha;
+            if a <= 1e-6 {
+                return None;
+            }
+            let k = q.shade;
+            let o: [f32; 3] = std::array::from_fn(|i| c[i] * k * q.tint[i] + q.spec[i]);
+            Some([o[0] * a, o[1] * a, o[2] * a, a])
+        },
+        Acc::Over,
+    );
+}
+
+pub(crate) fn sort_far_first(pieces: &mut [Piece]) {
+    pieces.sort_by(|a, b| b.depth.total_cmp(&a.depth));
+}
diff --git a/crates/effects/src/sim2/pixels.rs b/crates/effects/src/sim2/pixels.rs
new file mode 100644
index 000000000..2cda428db
--- /dev/null
+++ b/crates/effects/src/sim2/pixels.rs
@@ -0,0 +1,228 @@
+use super::pieces::{Cam, Piece, PiecePlan, PieceTex, rot_axis, sort_far_first};
+use super::shatter::{ShatterPlan, shatter_impl};
+use super::{Acc, Buf, EffectCtx, IntoParallelIterator, ParallelIterator, Post, Shape, Sprite, SpritePlan, h, hs, unpremul};
+
+// ------------------------------------------------------------------ CC Ball Action
+
+pub(super) fn ball_action(ctx: &EffectCtx, b: Buf) -> Buf {
+    ball_action_plan(ctx, &b).finish(b)
+}
+
+/// CC Ball Action's balls (far to near), coloured by the layer's pixels.
+fn ball_action_plan(ctx: &EffectCtx, b: &Buf) -> SpritePlan {
+    let pr = ctx.params;
+    let scatter = pr.f("scatter") as f32;
+    let axis = pr.e("rotationAxis");
+    let rot = pr.f("rotation").to_radians();
+    let twist_prop = pr.e("twistProperty");
+    let twist = pr.f("twistAngle").to_radians();
+    let spacing = pr.f("gridSpacing").max(1.0) as f32;
+    let size = pr.f("ballSize") as f32 / 100.0;
+    let instab = pr.f("instabilityState").to_radians() as f32;
+    let seed = ctx.seed.wrapping_mul(0x2545f491);
+    let (lw, lh) = (ctx.layer_size[0] as f32, ctx.layer_size[1] as f32);
+    let s = b.scale as f32;
+    let nx = (lw / spacing).ceil().max(1.0) as u32;
+    let ny = (lh / spacing).ceil().max(1.0) as u32;
+    let d = 2.0 * lw.max(lh) as f64;
+    let (cx, cy) = (lw as f64 * 0.5, lh as f64 * 0.5);
+    let src = &b.img;
+    let ax: [f64; 3] = match axis {
+        0 => [1.0, 0.0, 0.0],
+        1 => [0.0, 1.0, 0.0],
+        2 => [0.0, 0.0, 1.0],
+        3 => [1.0, 1.0, 0.0],
+        4 => [1.0, 0.0, 1.0],
+        5 => [0.0, 1.0, 1.0],
+        _ => [1.0, 1.0, 1.0],
+    };
+    let maxr = ((lw * lw + lh * lh).sqrt() * 0.5).max(1.0);
+    let mut balls: Vec<(f64, Sprite)> = (0..nx * ny)
+        .into_par_iter()
+        .filter_map(|i| {
+            let gx = (i % nx) as f32 * spacing + spacing * 0.5;
+            let gy = (i / nx) as f32 * spacing + spacing * 0.5;
+            let (sx, sy) = b.to_px([gx as f64, gy as f64]);
+            let (c, a) = unpremul(src.sample_bilinear(sx, sy));
+            if a <= 0.0 || size <= 0.0 {
+                return None;
+            }
+            let tp = match twist_prop {
+                0 => gx / lw.max(1.0),
+                1 => gy / lh.max(1.0),
+                2 => ((gx - cx as f32).hypot(gy - cy as f32)) / maxr,
+                _ => crate::util::rgb3([c[0], c[1], c[2], 0.0]).iter().sum::<f32>() / 3.0,
+            } as f64;
+            let ang = rot + twist * tp;
+            // Scatter: random 3D offsets whose direction drifts with the instability state.
+            let ph = h(i, 1, seed) * std::f32::consts::TAU + instab;
+            let sc = scatter * h(i, 2, seed);
+            let off = [(sc * ph.cos()) as f64, (sc * ph.sin()) as f64, (scatter * hs(i, 3, seed)) as f64];
+            let p0 = [gx as f64 - cx + off[0], gy as f64 - cy + off[1], off[2]];
+            let m = rot_axis(ax, ang);
+            let q: [f64; 3] = std::array::from_fn(|k| m[k][0] * p0[0] + m[k][1] * p0[1] + m[k][2] * p0[2]);
+            if d + q[2] <= d * 0.05 {
+                return None;
+            }
+            let persp = d / (d + q[2]);
+            let (bx, by) = b.to_px([cx + q[0] * persp, cy + q[1] * persp]);
+            let r = spacing * 0.5 * size * persp as f32 * s;
+            Some((q[2], Sprite::new(bx as f32, by as f32, r, [c[0], c[1], c[2], a], Shape::Sphere)))
+        })
+        .collect();
+    balls.sort_by(|a, b| b.0.total_cmp(&a.0));
+    let sprites: Vec<Sprite> = balls.into_iter().map(|(_, s)| s).collect();
+    SpritePlan { sprites, tints: vec![], acc: Acc::Over, post: Post::Replace }
+}
+
+// ------------------------------------------------------------------ CC Pixel Polly
+
+pub(super) fn pixel_polly(ctx: &EffectCtx, b: Buf) -> Buf {
+    match pixel_polly_plan(ctx, &b) {
+        Some(plan) => plan.finish(b),
+        None => b,
+    }
+}
+
+/// CC Pixel Polly's pieces, `None` before Start Time (the layer as is).
+fn pixel_polly_plan(ctx: &EffectCtx, b: &Buf) -> Option<PiecePlan> {
+    let pr = ctx.params;
+    let t = ctx.time - pr.f("startTime");
+    if t <= 0.0 {
+        return None;
+    }
+    let force = pr.f("force");
+    let gravity = pr.f("gravity");
+    let spin = pr.f("spinning").to_radians();
+    let fc = pr.v2("forceCenter");
+    let dir_rand = pr.f("directionRandomness") / 100.0;
+    let spd_rand = pr.f("speedRandomness") / 100.0;
+    let g = pr.f("gridSpacing").max(1.0);
+    let object = pr.e("object");
+    let depth_sort = pr.b("enableDepthSort");
+    let seed = ctx.seed.wrapping_mul(0x632be5ab);
+    let [lw, lh] = ctx.layer_size;
+    let s = b.scale;
+    let cam = Cam { c: [b.offset[0] + lw * 0.5 * s, b.offset[1] + lh * 0.5 * s], d: 2.0 * lw.max(lh) * s };
+    let nx = (lw / g).ceil().max(1.0) as u32;
+    let ny = (lh / g).ceil().max(1.0) as u32;
+    let tri = object <= 1;
+    let textured = object == 1 || object == 3;
+    let maxd = lw.max(lh);
+    let src = &b.img;
+    let per = if tri { 2 } else { 1 };
+    let mut pieces: Vec<Piece> = (0..nx * ny * per)
+        .into_par_iter()
+        .filter_map(|i| {
+            let cell = i / per;
+            let (x0, y0) = ((cell % nx) as f64 * g, (cell / nx) as f64 * g);
+            let poly: Vec<[f64; 2]> = if !tri {
+                vec![[x0, y0], [x0 + g, y0], [x0 + g, y0 + g], [x0, y0 + g]]
+            } else if i % 2 == 0 {
+                vec![[x0, y0], [x0 + g, y0], [x0, y0 + g]]
+            } else {
+                vec![[x0 + g, y0], [x0 + g, y0 + g], [x0, y0 + g]]
+            };
+            let c = [poly.iter().map(|v| v[0]).sum::<f64>() / poly.len() as f64, poly.iter().map(|v| v[1]).sum::<f64>() / poly.len() as f64];
+            let (dx, dy) = (c[0] - fc[0], c[1] - fc[1]);
+            let dist = (dx * dx + dy * dy).sqrt().max(1e-6);
+            let ang = dy.atan2(dx) + dir_rand * std::f64::consts::PI * hs(i, 1, seed) as f64;
+            let speed = force / 100.0 * 0.6 * maxd / (1.0 + dist / (0.5 * maxd)) * (1.0 + spd_rand * hs(i, 2, seed) as f64);
+            let vz = -speed * 0.5 * h(i, 3, seed) as f64;
+            let pos = [c[0] + ang.cos() * speed * t, c[1] + ang.sin() * speed * t + 0.5 * gravity * 0.5 * lh * t * t, vz * t];
+            let axis = [hs(i, 4, seed) as f64, hs(i, 5, seed) as f64, hs(i, 6, seed) as f64];
+            let r = rot_axis(axis, t * (std::f64::consts::PI * h(i, 7, seed) as f64 + spin));
+            let tex: Vec<[f32; 2]> = poly.iter().map(|v| [(v[0] * s + b.offset[0]) as f32, (v[1] * s + b.offset[1]) as f32]).collect();
+            let c0 = [(c[0] * s + b.offset[0]) as f32, (c[1] * s + b.offset[1]) as f32];
+            let posb = [pos[0] * s + b.offset[0], pos[1] * s + b.offset[1], pos[2] * s];
+            let mut pc = Piece::new(&tex, c0, &r, posb, cam)?;
+            pc.shade = 0.35 + 0.65 * Piece::facing(&r);
+            if !textured {
+                let (cc, a) = unpremul(src.sample_bilinear(c0[0] as f64, c0[1] as f64));
+                if a <= 0.0 {
+                    return None;
+                }
+                pc.flat = Some(cc);
+                pc.alpha = a;
+            }
+            Some(pc)
+        })
+        .collect();
+    if depth_sort {
+        sort_far_first(&mut pieces);
+    }
+    Some(PiecePlan { pieces, front: PieceTex::Layer, back: None })
+}
+
+// ------------------------------------------------------------------ CC Scatterize
+
+pub(super) fn scatterize(ctx: &EffectCtx, b: Buf) -> Buf {
+    match scatterize_plan(ctx, &b) {
+        Some(plan) => plan.finish(b),
+        None => b,
+    }
+}
+
+/// CC Scatterize's pixel dots, `None` when nothing moves (the layer as is).
+fn scatterize_plan(ctx: &EffectCtx, b: &Buf) -> Option<SpritePlan> {
+    let pr = ctx.params;
+    let scatter = pr.f("scatter") as f32;
+    let right = pr.f("rightTwist").to_radians();
+    let left = pr.f("leftTwist").to_radians();
+    if scatter == 0.0 && right == 0.0 && left == 0.0 {
+        return None;
+    }
+    let add = pr.e("transferMode") == 1;
+    let seed = ctx.seed.wrapping_mul(0x7feb352d);
+    let s = b.scale;
+    let (w, hh) = (b.img.width, b.img.height);
+    let (cx, cy) = (b.offset[0] + ctx.layer_size[0] * 0.5 * s, b.offset[1] + ctx.layer_size[1] * 0.5 * s);
+    let half = (ctx.layer_size[0] * 0.5 * s).max(1.0);
+    let d = 2.0 * ctx.layer_size[0].max(ctx.layer_size[1]) * s;
+    let src = &b.img;
+    let sprites: Vec<Sprite> = (0..w * hh)
+        .into_par_iter()
+        .filter_map(|i| {
+            let px = src.data[i as usize];
+            if px[3] <= 0.0 {
+                return None;
+            }
+            let (x, y) = ((i % w) as f64 + 0.5, (i / w) as f64 + 0.5);
+            // Twist about the horizontal axis through the centre, growing towards each side.
+            let k = ((x - cx) / half).abs().min(1.0);
+            let ang = if x < cx { left } else { right } * k;
+            let (sa, ca) = ang.sin_cos();
+            let (yy, zz) = ((y - cy) * ca, (y - cy) * sa);
+            let persp = d / (d + zz).max(d * 0.05);
+            let jx = hs(i, 1, seed) * scatter * s as f32;
+            let jy = hs(i, 2, seed) * scatter * s as f32;
+            let sx = cx + (x - cx) * persp + jx as f64;
+            let sy = cy + yy * persp + jy as f64;
+            let (c, a) = unpremul(px);
+            Some(Sprite::new(sx as f32, sy as f32, 0.6 * persp as f32, [c[0], c[1], c[2], a], Shape::Disc))
+        })
+        .collect();
+    Some(SpritePlan { sprites, tints: vec![], acc: if add { Acc::Add } else { Acc::Over }, post: Post::Replace })
+}
+
+/// What a particle effect that reads the layer's pixels draws this frame (CC Ball Action, CC
+/// Pixel Polly, CC Scatterize, Shatter's wireframe views), for layer `b`; `None` for other
+/// effects or a frame showing the layer as is.
+pub enum PixelPlan {
+    Sprites(SpritePlan),
+    Pieces(PiecePlan),
+}
+
+/// The [`PixelPlan`] of effect `id` for layer `b` (its pixels are read).
+pub fn pixel_plan(id: &str, ctx: &EffectCtx, b: &Buf) -> Option<PixelPlan> {
+    match id {
+        "ec.sim.ccballaction" => Some(PixelPlan::Sprites(ball_action_plan(ctx, b))),
+        "ec.sim.ccpixelpolly" => pixel_polly_plan(ctx, b).map(PixelPlan::Pieces),
+        "ec.sim.ccscatterize" => scatterize_plan(ctx, b).map(PixelPlan::Sprites),
+        "ec.sim.shatter" => Some(match shatter_impl(ctx, b) {
+            ShatterPlan::Pieces(plan) => PixelPlan::Pieces(plan),
+            ShatterPlan::Wire(plan) => PixelPlan::Sprites(plan),
+        }),
+        _ => None,
+    }
+}
diff --git a/crates/effects/src/sim2/registry.rs b/crates/effects/src/sim2/registry.rs
new file mode 100644
index 000000000..333916a16
--- /dev/null
+++ b/crates/effects/src/sim2/registry.rs
@@ -0,0 +1,288 @@
+use super::foam::{FOAM_TEXTURES, foam};
+use super::pixels::{ball_action, pixel_polly, scatterize};
+use super::shatter::{CD_PROPS, CD_SOURCES, SHATTER_PATTERNS, SHATTER_TEXTURE_MODES, card_dance, shatter};
+use super::surfaces::{caustics, wave_world};
+use super::{EffectSpec, ParamUi, Value, col, num, p, pct, popup, pt, slider, spec};
+
+// ------------------------------------------------------------------ specs
+
+fn producer_params(k: u32, amp: f64, pos: (f64, f64)) -> Vec<crate::ParamSpec> {
+    let ids: [&'static str; 8] = match k {
+        1 => [
+            "producer1/producer1Type",
+            "producer1/producer1Position",
+            "producer1/producer1Length",
+            "producer1/producer1Width",
+            "producer1/producer1Angle",
+            "producer1/producer1Amplitude",
+            "producer1/producer1Frequency",
+            "producer1/producer1Phase",
+        ],
+        _ => [
+            "producer2/producer2Type",
+            "producer2/producer2Position",
+            "producer2/producer2Length",
+            "producer2/producer2Width",
+            "producer2/producer2Angle",
+            "producer2/producer2Amplitude",
+            "producer2/producer2Frequency",
+            "producer2/producer2Phase",
+        ],
+    };
+    vec![
+        p(ids[0], "Type", Value::Enum(0), popup(&["Ring", "Line"])),
+        p(ids[1], "Position", pt(pos.0, pos.1), ParamUi::Point),
+        p(ids[2], "Height/Length", num(0.1), slider(0.0, 2.0, 0.0, 1.0, 3)),
+        p(ids[3], "Width", num(0.1), slider(0.0, 2.0, 0.0, 1.0, 3)),
+        p(ids[4], "Angle", num(0.0), ParamUi::Angle),
+        p(ids[5], "Amplitude", num(amp), slider(-5.0, 5.0, -1.0, 1.0, 3)),
+        p(ids[6], "Frequency", num(1.0), slider(0.0, 30.0, 0.0, 5.0, 3)),
+        p(ids[7], "Phase", num(0.0), ParamUi::Angle),
+    ]
+}
+
+fn card_dance_params() -> Vec<crate::ParamSpec> {
+    let mut v = vec![
+        p("rowsColumns", "Rows & Columns", Value::Enum(0), popup(&["Independent", "Columns Follows Rows"])),
+        p("rows", "Rows", num(10.0), slider(1.0, 1000.0, 1.0, 100.0, 0)),
+        p("columns", "Columns", num(10.0), slider(1.0, 1000.0, 1.0, 100.0, 0)),
+        p("backLayer", "Back Layer", Value::Layer(None), ParamUi::Layer),
+        p("gradientLayer1", "Gradient Layer 1", Value::Layer(None), ParamUi::Layer),
+        p("gradientLayer2", "Gradient Layer 2", Value::Layer(None), ParamUi::Layer),
+    ];
+    let names: [[&'static str; 4]; 8] = [
+        ["xPosition/xPosSource", "xPosition/xPosMultiplier", "xPosition/xPosOffset", "X Position"],
+        ["yPosition/yPosSource", "yPosition/yPosMultiplier", "yPosition/yPosOffset", "Y Position"],
+        ["zPosition/zPosSource", "zPosition/zPosMultiplier", "zPosition/zPosOffset", "Z Position"],
+        ["xRotation/xRotSource", "xRotation/xRotMultiplier", "xRotation/xRotOffset", "X Rotation"],
+        ["yRotation/yRotSource", "yRotation/yRotMultiplier", "yRotation/yRotOffset", "Y Rotation"],
+        ["zRotation/zRotSource", "zRotation/zRotMultiplier", "zRotation/zRotOffset", "Z Rotation"],
+        ["xScale/xScaleSource", "xScale/xScaleMultiplier", "xScale/xScaleOffset", "X Scale"],
+        ["yScale/yScaleSource", "yScale/yScaleMultiplier", "yScale/yScaleOffset", "Y Scale"],
+    ];
+    debug_assert_eq!(names.len(), CD_PROPS.len());
+    for (i, n) in names.iter().enumerate() {
+        let rot = (3..6).contains(&i);
+        let scale = i >= 6;
+        let (lo, hi) = if rot { (-3600.0, 3600.0) } else { (-100.0, 100.0) };
+        v.push(p(n[0], "Source", Value::Enum(0), popup(CD_SOURCES)));
+        v.push(p(n[1], "Multiplier", num(0.0), slider(lo, hi, if rot { -360.0 } else { -10.0 }, if rot { 360.0 } else { 10.0 }, 2)));
+        v.push(p(n[2], "Offset", num(if scale { 1.0 } else { 0.0 }), slider(lo, hi, if rot { -360.0 } else { -10.0 }, if rot { 360.0 } else { 10.0 }, 2)));
+    }
+    v.extend(crate::card3d::camera_params(2.0));
+    v.extend(crate::card3d::lighting_params(1.0, 0.25));
+    v.extend(crate::card3d::material_params(0.75));
+    v
+}
+
+pub fn specs() -> Vec<EffectSpec> {
+    vec![
+        spec(
+            "ec.sim.ccballaction",
+            "CC Ball Action",
+            vec![
+                p("scatter", "Scatter", num(0.0), slider(0.0, 2000.0, 0.0, 300.0, 1)),
+                p("rotationAxis", "Rotation Axis", Value::Enum(0), popup(&["X Axis", "Y Axis", "Z Axis", "XY Axis", "XZ Axis", "YZ Axis", "XYZ Axis"])),
+                p("rotation", "Rotation", num(0.0), ParamUi::Angle),
+                p("twistProperty", "Twist Property", Value::Enum(0), popup(&["X Axis", "Y Axis", "Radius", "Brightness"])),
+                p("twistAngle", "Twist Angle", num(0.0), ParamUi::Angle),
+                p("gridSpacing", "Grid Spacing", num(4.0), slider(1.0, 200.0, 1.0, 50.0, 0)),
+                p("ballSize", "Ball Size", num(40.0), slider(0.0, 400.0, 0.0, 200.0, 1)),
+                p("instabilityState", "Instability State", num(0.0), ParamUi::Angle),
+            ],
+            ball_action,
+        ),
+        spec(
+            "ec.sim.ccpixelpolly",
+            "CC Pixel Polly",
+            vec![
+                p("force", "Force", num(100.0), slider(-1000.0, 1000.0, -300.0, 300.0, 1)),
+                p("gravity", "Gravity", num(1.0), slider(-20.0, 20.0, -5.0, 5.0, 2)),
+                p("spinning", "Spinning", num(0.0), ParamUi::Angle),
+                p("forceCenter", "Force Center", pt(0.5, 0.5), ParamUi::Point),
+                p("directionRandomness", "Direction Randomness", num(10.0), pct()),
+                p("speedRandomness", "Speed Randomness", num(10.0), pct()),
+                p("gridSpacing", "Grid Spacing", num(10.0), slider(1.0, 500.0, 2.0, 100.0, 0)),
+                p("object", "Object", Value::Enum(0), popup(&["Polygon", "Textured Polygon", "Square", "Textured Square"])),
+                p("enableDepthSort", "Enable Depth Sort", Value::Bool(true), ParamUi::Checkbox),
+                p("startTime", "Start Time (sec)", num(0.0), slider(-1000.0, 1000.0, 0.0, 10.0, 2)),
+            ],
+            pixel_polly,
+        ),
+        spec(
+            "ec.sim.ccscatterize",
+            "CC Scatterize",
+            vec![
+                p("scatter", "Scatter", num(0.0), slider(0.0, 1000.0, 0.0, 200.0, 1)),
+                p("rightTwist", "Right Twist", num(0.0), ParamUi::Angle),
+                p("leftTwist", "Left Twist", num(0.0), ParamUi::Angle),
+                p("transferMode", "Transfer Mode", Value::Enum(0), popup(&["Composite", "Add"])),
+            ],
+            scatterize,
+        ),
+        spec("ec.sim.carddance", "Card Dance", card_dance_params(), card_dance),
+        spec(
+            "ec.sim.caustics",
+            "Caustics",
+            vec![
+                p("bottom/bottom", "Bottom", Value::Layer(None), ParamUi::Layer),
+                p("bottom/scaling", "Scaling", num(1.0), slider(0.01, 10.0, 0.1, 3.0, 3)),
+                p("bottom/repeatMode", "Repeat Mode", Value::Enum(2), popup(&["Once", "Tiled", "Reflected"])),
+                p("bottom/bottomSizeDiffers", "If Layer Size Differs", Value::Enum(1), popup(&["Center", "Stretch to Fit"])),
+                p("bottom/blur", "Blur", num(0.0), slider(0.0, 100.0, 0.0, 20.0, 1)),
+                p("water/waterSurface", "Water Surface", Value::Layer(None), ParamUi::Layer),
+                p("water/waveHeight", "Wave Height", num(0.2), slider(-1.0, 1.0, -1.0, 1.0, 3)),
+                p("water/smoothing", "Smoothing", num(5.0), slider(0.0, 100.0, 0.0, 50.0, 1)),
+                p("water/waterDepth", "Water Depth", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("water/refractiveIndex", "Refractive Index", num(1.2), slider(1.0, 3.0, 1.0, 2.0, 3)),
+                p("water/surfaceColor", "Surface Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("water/surfaceOpacity", "Surface Opacity", num(0.3), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("water/causticsStrength", "Caustics Strength", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("sky/sky", "Sky", Value::Layer(None), ParamUi::Layer),
+                p("sky/scaling", "Scaling", num(1.0), slider(0.01, 10.0, 0.1, 3.0, 3)),
+                p("sky/repeatMode", "Repeat Mode", Value::Enum(2), popup(&["Once", "Tiled", "Reflected"])),
+                p("sky/skySizeDiffers", "If Layer Size Differs", Value::Enum(1), popup(&["Center", "Stretch to Fit"])),
+                p("sky/intensity", "Intensity", num(0.3), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("sky/convergence", "Convergence", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("lighting/lightType", "Light Type", Value::Enum(0), popup(&crate::card3d::LIGHT_TYPES)),
+                p("lighting/lightIntensity", "Light Intensity", num(1.0), slider(0.0, 4.0, 0.0, 2.0, 2)),
+                p("lighting/lightColor", "Light Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("lighting/lightPosition", "Light Position", pt(0.0, 0.0), ParamUi::Point),
+                p("lighting/lightHeight", "Light Height", num(1.0), slider(0.0, 10.0, 0.0, 4.0, 2)),
+                p("lighting/ambientLight", "Ambient Light", num(0.35), slider(0.0, 2.0, 0.0, 1.0, 2)),
+                p("material/diffuse", "Diffuse Reflection", num(0.75), slider(0.0, 2.0, 0.0, 1.0, 2)),
+                p("material/specular", "Specular Reflection", num(0.2), slider(0.0, 2.0, 0.0, 1.0, 2)),
+                p("material/highlightSharpness", "Highlight Sharpness", num(15.0), slider(1.0, 100.0, 1.0, 100.0, 1)),
+            ],
+            caustics,
+        ),
+        spec(
+            "ec.sim.waveworld",
+            "Wave World",
+            {
+                let mut v = vec![
+                    p("view", "View", Value::Enum(0), popup(&["Wireframe Preview", "Height Map"])),
+                    p("wireframeControls/horizontalRotation", "Horizontal Rotation", num(0.0), ParamUi::Angle),
+                    p("wireframeControls/verticalRotation", "Vertical Rotation", num(53.0), slider(0.0, 90.0, 0.0, 90.0, 1)),
+                    p("wireframeControls/verticalScale", "Vertical Scale", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 3)),
+                    p("heightMapControls/brightness", "Brightness", num(0.5), slider(-1.0, 2.0, 0.0, 1.0, 3)),
+                    p("heightMapControls/contrast", "Contrast", num(0.75), slider(0.0, 4.0, 0.0, 2.0, 3)),
+                    p("heightMapControls/gamma", "Gamma Adjustment", num(1.0), slider(0.01, 10.0, 0.2, 5.0, 3)),
+                    p("heightMapControls/renderDryAreasAs", "Render Dry Areas As", Value::Enum(0), popup(&["Solid", "Transparent"])),
+                    p("heightMapControls/transparency", "Transparency", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                    p("simulation/gridResolution", "Grid Resolution", num(60.0), slider(1.0, 400.0, 1.0, 200.0, 0)),
+                    p("simulation/gridResDownsamples", "Grid Res Downsamples", Value::Bool(false), ParamUi::Checkbox),
+                    p("simulation/waveSpeed", "Wave Speed", num(0.2), slider(0.0, 5.0, 0.0, 1.0, 3)),
+                    p("simulation/damping", "Damping", num(0.05), slider(0.0, 5.0, 0.0, 1.0, 3)),
+                    p("simulation/reflectEdges", "Reflect Edges", Value::Enum(0), popup(&["None", "Left", "Top", "Right", "Bottom", "All"])),
+                    p("simulation/preRoll", "Pre-roll (seconds)", num(0.0), slider(0.0, 30.0, 0.0, 10.0, 2)),
+                    p("ground/ground", "Ground", Value::Layer(None), ParamUi::Layer),
+                    p("ground/steepness", "Steepness", num(0.25), slider(0.0, 2.0, 0.0, 1.0, 3)),
+                    p("ground/height", "Height", num(0.25), slider(0.0, 2.0, 0.0, 1.0, 3)),
+                    p("ground/waveStrength", "Wave Strength", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                ];
+                v.extend(producer_params(1, 0.5, (0.5, 0.5)));
+                v.extend(producer_params(2, 0.0, (0.25, 0.25)));
+                v
+            },
+            wave_world,
+        ),
+        spec(
+            "ec.sim.shatter",
+            "Shatter",
+            vec![
+                p(
+                    "view",
+                    "View",
+                    Value::Enum(1),
+                    popup(&["Rendered", "Wireframe Front View", "Wireframe", "Wireframe Front View + Forces", "Wireframe + Forces"]),
+                ),
+                p("render", "Render", Value::Enum(0), popup(&["All", "Layer", "Pieces"])),
+                p("shape/pattern", "Pattern", Value::Enum(0), popup(SHATTER_PATTERNS)),
+                p("shape/repetitions", "Repetitions", num(10.0), slider(1.0, 500.0, 1.0, 100.0, 2)),
+                p("shape/direction", "Direction", num(0.0), ParamUi::Angle),
+                p("shape/origin", "Origin", pt(0.5, 0.5), ParamUi::Point),
+                p("shape/customShatterMap", "Custom Shatter Map", Value::Layer(None), ParamUi::Layer),
+                p("shape/whiteTilesFixed", "White Tiles Fixed", Value::Bool(false), ParamUi::Checkbox),
+                p("shape/extrusionDepth", "Extrusion Depth", num(0.05), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("force1/force1Position", "Position", pt(0.5, 0.5), ParamUi::Point),
+                p("force1/force1Depth", "Depth", num(0.1), slider(-1.0, 1.0, -1.0, 1.0, 3)),
+                p("force1/force1Radius", "Radius", num(0.4), slider(0.0, 4.0, 0.0, 2.0, 3)),
+                p("force1/force1Strength", "Strength", num(5.0), slider(-20.0, 20.0, -10.0, 10.0, 2)),
+                p("force2/force2Position", "Position", pt(0.25, 0.25), ParamUi::Point),
+                p("force2/force2Depth", "Depth", num(0.1), slider(-1.0, 1.0, -1.0, 1.0, 3)),
+                p("force2/force2Radius", "Radius", num(0.0), slider(0.0, 4.0, 0.0, 2.0, 3)),
+                p("force2/force2Strength", "Strength", num(5.0), slider(-20.0, 20.0, -10.0, 10.0, 2)),
+                p("physics/rotationSpeed", "Rotation Speed", num(0.2), slider(0.0, 5.0, 0.0, 1.0, 3)),
+                p("physics/tumbleAxis", "Tumble Axis", Value::Enum(0), popup(&["Free", "None", "X", "Y", "Z", "XY", "XZ", "YZ"])),
+                p("physics/randomness", "Randomness", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("physics/viscosity", "Viscosity", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("physics/massVariance", "Mass Variance", num(30.0), pct()),
+                p("physics/gravity", "Gravity", num(3.0), slider(0.0, 100.0, 0.0, 10.0, 2)),
+                p("physics/gravityDirection", "Gravity Direction", num(180.0), ParamUi::Angle),
+                p("physics/gravityInclination", "Gravity Inclination", num(0.0), slider(-90.0, 90.0, -90.0, 90.0, 1)),
+                p("gradient/shatterThreshold", "Shatter Threshold", num(0.0), slider(0.0, 100.0, 0.0, 100.0, 1)),
+                p("gradient/gradientLayer", "Gradient Layer", Value::Layer(None), ParamUi::Layer),
+                p("gradient/invertGradient", "Invert Gradient", Value::Bool(false), ParamUi::Checkbox),
+                p("textures/color", "Color", col(1.0, 1.0, 1.0), ParamUi::Color),
+                p("textures/opacity", "Opacity", num(1.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("textures/frontMode", "Front Mode", Value::Enum(1), popup(&SHATTER_TEXTURE_MODES)),
+                p("textures/sideMode", "Side Mode", Value::Enum(0), popup(&SHATTER_TEXTURE_MODES)),
+                p("textures/backMode", "Back Mode", Value::Enum(1), popup(&SHATTER_TEXTURE_MODES)),
+                p("textures/frontLayer", "Front Layer", Value::Layer(None), ParamUi::Layer),
+                p("textures/sideLayer", "Side Layer", Value::Layer(None), ParamUi::Layer),
+                p("textures/backLayer", "Back Layer", Value::Layer(None), ParamUi::Layer),
+            ]
+            .into_iter()
+            .chain(crate::card3d::camera_params(4.0))
+            .chain(crate::card3d::lighting_params(1.0, 0.25))
+            .chain(crate::card3d::material_params(0.75))
+            .chain([p("randomSeed", "Random Seed", num(0.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0))])
+            .collect(),
+            shatter,
+        ),
+        spec(
+            "ec.sim.foam",
+            "Foam",
+            vec![
+                p("view", "View", Value::Enum(0), popup(&["Draft", "Draft + Flow Map", "Rendered"])),
+                p("producer/producerPoint", "Producer Point", pt(0.5, 0.5), ParamUi::Point),
+                p("producer/producerXSize", "Producer X Size", num(0.05), slider(0.0, 2.0, 0.0, 1.0, 3)),
+                p("producer/producerYSize", "Producer Y Size", num(0.05), slider(0.0, 2.0, 0.0, 1.0, 3)),
+                p("producer/producerOrientation", "Producer Orientation", num(0.0), ParamUi::Angle),
+                p("producer/zoomProducerPoint", "Zoom Producer Point", Value::Bool(false), ParamUi::Checkbox),
+                p("producer/productionRate", "Production Rate", num(1.0), slider(0.0, 50.0, 0.0, 10.0, 3)),
+                p("bubbles/size", "Size", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 3)),
+                p("bubbles/sizeVariance", "Size Variance", num(0.5), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("bubbles/lifespan", "Lifespan", num(300.0), slider(1.0, 30_000.0, 1.0, 1000.0, 1)),
+                p("bubbles/growthSpeed", "Bubble Growth Speed", num(0.1), slider(0.0001, 10.0, 0.0001, 1.0, 3)),
+                p("bubbles/strength", "Strength", num(10.0), slider(0.0, 100.0, 0.0, 20.0, 2)),
+                p("physics/initialSpeed", "Initial Speed", num(0.0), slider(-100.0, 100.0, -10.0, 10.0, 3)),
+                p("physics/initialDirection", "Initial Direction", num(0.0), ParamUi::Angle),
+                p("physics/windSpeed", "Wind Speed", num(0.5), slider(-100.0, 100.0, -10.0, 10.0, 3)),
+                p("physics/windDirection", "Wind Direction", num(90.0), ParamUi::Angle),
+                p("physics/turbulence", "Turbulence", num(0.5), slider(0.0, 10.0, 0.0, 2.0, 3)),
+                p("physics/wobbleAmount", "Wobble Amount", num(0.05), slider(0.0, 10.0, 0.0, 2.0, 3)),
+                p("physics/repulsion", "Repulsion", num(1.0), slider(0.0, 10.0, 0.0, 2.0, 3)),
+                p("physics/popVelocity", "Pop Velocity", num(1.0), slider(-100.0, 100.0, -10.0, 10.0, 3)),
+                p("physics/viscosity", "Viscosity", num(0.1), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("physics/stickiness", "Stickiness", num(0.75), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("zoom", "Zoom", num(1.0), slider(0.01, 50.0, 0.1, 5.0, 3)),
+                p("universeSize", "Universe Size", num(1.0), slider(0.01, 10.0, 0.5, 3.0, 3)),
+                p("rendering/blendMode", "Blend Mode", Value::Enum(0), popup(&["Transparent", "Solid Old on Top", "Solid New on Top"])),
+                p("rendering/bubbleTexture", "Bubble Texture", Value::Enum(0), popup(&FOAM_TEXTURES)),
+                p("rendering/bubbleTextureLayer", "Bubble Texture Layer", Value::Layer(None), ParamUi::Layer),
+                p("rendering/bubbleOrientation", "Bubble Orientation", Value::Enum(0), popup(&["Fixed", "Physical Orientation", "Bubble Velocity"])),
+                p("rendering/environmentMap", "Environment Map", Value::Layer(None), ParamUi::Layer),
+                p("rendering/reflectionStrength", "Reflection Strength", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("rendering/reflectionConvergence", "Reflection Convergence", num(0.0), slider(0.0, 1.0, 0.0, 1.0, 3)),
+                p("flowMap/flowMap", "Flow Map", Value::Layer(None), ParamUi::Layer),
+                p("flowMap/flowMapSteepness", "Flow Map Steepness", num(0.05), slider(-100.0, 100.0, -1.0, 1.0, 3)),
+                p("flowMap/flowMapFits", "Flow Map Fits", Value::Enum(0), popup(&["Background", "Universe"])),
+                p("flowMap/simulationQuality", "Simulation Quality", Value::Enum(0), popup(&["Normal", "High", "Intense"])),
+                p("randomSeed", "Random Seed", num(1.0), slider(0.0, 10_000.0, 0.0, 1000.0, 0)),
+            ],
+            foam,
+        ),
+    ]
+}
diff --git a/crates/effects/src/sim2/shatter.rs b/crates/effects/src/sim2/shatter.rs
new file mode 100644
index 000000000..844fbb4b3
--- /dev/null
+++ b/crates/effects/src/sim2/shatter.rs
@@ -0,0 +1,484 @@
+use super::pieces::{M3, Piece, PiecePlan, PieceTex, inv3, rot_axis, rot_xyz, sort_far_first};
+use super::{
+    Acc, Buf, EffectCtx, Image, IndexedParallelIterator, IntoParallelIterator, IntoParallelRefIterator, Lighting, ParallelIterator, Post, Shape, Sprite,
+    SpritePlan, Value, h, hs, layer_or_self, unpremul,
+};
+
+// ------------------------------------------------------------------ Card Dance
+
+pub(super) const CD_SOURCES: &[&str] =
+    &["None", "Intensity 1", "Red 1", "Green 1", "Blue 1", "Alpha 1", "Intensity 2", "Red 2", "Green 2", "Blue 2", "Alpha 2"];
+
+/// (param id prefix, twirl-down group match id) per transformed card property.
+pub(super) const CD_PROPS: [(&str, &str); 8] = [
+    ("xPos", "xPosition"),
+    ("yPos", "yPosition"),
+    ("zPos", "zPosition"),
+    ("xRot", "xRotation"),
+    ("yRot", "yRotation"),
+    ("zRot", "zRotation"),
+    ("xScale", "xScale"),
+    ("yScale", "yScale"),
+];
+
+fn card_source(src: u32, g1: [f32; 4], g2: [f32; 4]) -> f32 {
+    let (c1, a1) = unpremul(g1);
+    let (c2, a2) = unpremul(g2);
+    let lum = |c: [f32; 3]| effectcraft_color::luminance(c[0], c[1], c[2]);
+    match src {
+        1 => lum(c1),
+        2 => c1[0],
+        3 => c1[1],
+        4 => c1[2],
+        5 => a1,
+        6 => lum(c2),
+        7 => c2[0],
+        8 => c2[1],
+        9 => c2[2],
+        10 => a2,
+        _ => 0.0,
+    }
+}
+
+pub(super) fn card_dance(ctx: &EffectCtx, b: Buf) -> Buf {
+    card_dance_plan(ctx, &b).finish(b)
+}
+
+pub(super) fn card_dance_plan(ctx: &EffectCtx, b: &Buf) -> PiecePlan {
+    let pr = ctx.params;
+    let rows = pr.f("rows").clamp(1.0, 1000.0) as u32;
+    let cols = if pr.e("rowsColumns") == 1 { rows } else { pr.f("columns").clamp(1.0, 1000.0) as u32 };
+    let g1 = layer_or_self(ctx, b, "gradientLayer1", true, true);
+    let g2 = layer_or_self(ctx, b, "gradientLayer2", true, true);
+    let back = ctx.layer_param("backLayer", true).map(|o| crate::util::fit_layer(ctx, b, &o, true));
+    let [lw, lh] = ctx.layer_size;
+    let s = b.scale;
+    let (cw, ch) = (lw / cols as f64, lh / rows as f64);
+    let cam = crate::card3d::projection(ctx, b);
+    let eye = cam.eye();
+    let light = Lighting::from(ctx, b);
+    let props: Vec<(u32, f64, f64)> =
+        CD_PROPS.iter().map(|(id, g)| (pr.e(&format!("{g}/{id}Source")), pr.f(&format!("{g}/{id}Multiplier")), pr.f(&format!("{g}/{id}Offset")))).collect();
+    let mut pieces: Vec<Piece> = (0..rows * cols)
+        .into_par_iter()
+        .filter_map(|i| {
+            let (cx0, cy0) = ((i % cols) as f64 * cw, (i / cols) as f64 * ch);
+            let c = [cx0 + cw * 0.5, cy0 + ch * 0.5];
+            let (bx, by) = (c[0] * s + b.offset[0], c[1] * s + b.offset[1]);
+            let (gp1, gp2) = (g1.sample_bilinear(bx, by), g2.sample_bilinear(bx, by));
+            let val = |k: usize| {
+                let (sr, m, o) = props[k];
+                o + m * card_source(sr, gp1, gp2) as f64
+            };
+            let (sx, sy) = (val(6), val(7));
+            let r = rot_xyz(val(3).to_radians(), val(4).to_radians(), val(5).to_radians());
+            let rs: M3 = std::array::from_fn(|k| [r[k][0] * sx, r[k][1] * sy, r[k][2]]);
+            let pos = [bx + val(0) * cw * s, by + val(1) * ch * s, val(2) * cw.max(ch) * s];
+            let (tx0, ty0) = ((cx0 * s + b.offset[0]) as f32, (cy0 * s + b.offset[1]) as f32);
+            let (tw, th) = ((cw * s) as f32, (ch * s) as f32);
+            let poly = [[tx0, ty0], [tx0 + tw, ty0], [tx0 + tw, ty0 + th], [tx0, ty0 + th]];
+            let mut pc = Piece::new(&poly, [bx as f32, by as f32], &rs, pos, cam)?;
+            pc.light(&light, &r, pos, eye);
+            Some(pc)
+        })
+        .collect();
+    sort_far_first(&mut pieces);
+    PiecePlan { pieces, front: PieceTex::Layer, back: back.map(PieceTex::Image) }
+}
+
+// ------------------------------------------------------------------ Shatter
+
+/// Shatter's Pattern options; the last, Custom, takes its pieces from Custom Shatter Map.
+pub(super) const SHATTER_PATTERNS: &[&str] = &["Bricks", "Glass", "Hexagons", "Squares", "Triangles", "Custom"];
+
+/// Pattern cells (polygons in pattern space, before rotation) covering `[x0, x1]×[y0, y1]`.
+fn pattern_cells(kind: u32, cell: f64, x0: f64, y0: f64, x1: f64, y1: f64, seed: u32) -> Vec<Vec<[f64; 2]>> {
+    let mut out = Vec::new();
+    let i0 = (x0 / cell).floor() as i64 - 1;
+    let i1 = (x1 / cell).ceil() as i64 + 1;
+    let j0 = (y0 / cell).floor() as i64 - 1;
+    let j1 = (y1 / cell).ceil() as i64 + 1;
+    match kind {
+        0 => {
+            let bh = cell * 0.5;
+            let r0 = (y0 / bh).floor() as i64 - 1;
+            let r1 = (y1 / bh).ceil() as i64 + 1;
+            for r in r0..=r1 {
+                let sh = if r.rem_euclid(2) == 1 { cell * 0.5 } else { 0.0 };
+                for i in i0..=i1 {
+                    let (x, y) = (i as f64 * cell + sh, r as f64 * bh);
+                    out.push(vec![[x, y], [x + cell, y], [x + cell, y + bh], [x, y + bh]]);
+                }
+            }
+        }
+        1 => {
+            // Jittered lattice split into triangles along a random diagonal.
+            let jit = |i: i64, j: i64| -> [f64; 2] {
+                let (a, b) = (i as u32, j as u32);
+                [i as f64 * cell + hs(a, b.wrapping_add(17), seed) as f64 * cell * 0.35, j as f64 * cell + hs(a, b.wrapping_add(91), seed) as f64 * cell * 0.35]
+            };
+            for j in j0..=j1 {
+                for i in i0..=i1 {
+                    let (p00, p10, p11, p01) = (jit(i, j), jit(i + 1, j), jit(i + 1, j + 1), jit(i, j + 1));
+                    if h(i as u32, j as u32, seed ^ 0x55) < 0.5 {
+                        out.push(vec![p00, p10, p11]);
+                        out.push(vec![p00, p11, p01]);
+                    } else {
+                        out.push(vec![p00, p10, p01]);
+                        out.push(vec![p10, p11, p01]);
+                    }
+                }
+            }
+        }
+        2 => {
+            let r = cell / 3f64.sqrt();
+            let dx = 1.5 * r;
+            let dy = 3f64.sqrt() * r;
+            let c0 = (x0 / dx).floor() as i64 - 1;
+            let c1 = (x1 / dx).ceil() as i64 + 1;
+            let rr0 = (y0 / dy).floor() as i64 - 1;
+            let rr1 = (y1 / dy).ceil() as i64 + 1;
+            for ci in c0..=c1 {
+                for rj in rr0..=rr1 {
+                    let cx = ci as f64 * dx;
+                    let cy = (rj as f64 + if ci.rem_euclid(2) == 1 { 0.5 } else { 0.0 }) * dy;
+                    out.push(
+                        (0..6)
+                            .map(|k| {
+                                let a = k as f64 * std::f64::consts::PI / 3.0;
+                                [cx + r * a.cos(), cy + r * a.sin()]
+                            })
+                            .collect(),
+                    );
+                }
+            }
+        }
+        3 => {
+            for j in j0..=j1 {
+                for i in i0..=i1 {
+                    let (x, y) = (i as f64 * cell, j as f64 * cell);
+                    out.push(vec![[x, y], [x + cell, y], [x + cell, y + cell], [x, y + cell]]);
+                }
+            }
+        }
+        _ => {
+            for j in j0..=j1 {
+                for i in i0..=i1 {
+                    let (x, y) = (i as f64 * cell, j as f64 * cell);
+                    if (i + j).rem_euclid(2) == 0 {
+                        out.push(vec![[x, y], [x + cell, y], [x, y + cell]]);
+                        out.push(vec![[x + cell, y], [x + cell, y + cell], [x, y + cell]]);
+                    } else {
+                        out.push(vec![[x, y], [x + cell, y], [x + cell, y + cell]]);
+                        out.push(vec![[x, y], [x + cell, y + cell], [x, y + cell]]);
+                    }
+                }
+            }
+        }
+    }
+    out
+}
+
+/// `∫0^t e^{-ks} ds` and `∫0^t ∫0^u e^{-ks} ds du` (drag-damped ballistic factors).
+fn drag_factors(k: f64, t: f64) -> (f64, f64) {
+    if k < 1e-6 {
+        (t, 0.5 * t * t)
+    } else {
+        let e = (-k * t).exp();
+        ((1.0 - e) / k, t / k - (1.0 - e) / (k * k))
+    }
+}
+
+/// Shatter's Front / Side / Back Mode options.
+pub(super) const SHATTER_TEXTURE_MODES: [&str; 3] = ["Color", "Layer", "Tinted Layer"];
+
+/// One face's texture: a flat colour, a layer, or a layer tinted by the Textures colour.
+struct Face {
+    mode: u32,
+    img: Option<Image>,
+}
+
+impl Face {
+    fn from(ctx: &EffectCtx, b: &Buf, mode: &str, layer: &str, default_mode: u32) -> Face {
+        let mode = ctx.params.get(mode).map(|v| v.as_enum()).unwrap_or(default_mode);
+        // A face layer of None is the effect's own layer.
+        let img = (mode != 0).then(|| layer_or_self(ctx, b, layer, true, true));
+        Face { mode, img }
+    }
+}
+
+/// Group key of a Custom Shatter Map colour (pieces of one colour break as one).
+fn map_key(c: [f32; 4]) -> u32 {
+    let (c, a) = unpremul(c);
+    if a < 0.5 {
+        return u32::MAX;
+    }
+    let q = |v: f32| ((v.clamp(0.0, 1.0) * 15.0).round() as u32) & 15;
+    q(c[0]) << 8 | q(c[1]) << 4 | q(c[2])
+}
+
+pub(super) fn shatter(ctx: &EffectCtx, b: Buf) -> Buf {
+    match shatter_impl(ctx, &b) {
+        ShatterPlan::Pieces(plan) => plan.finish(b),
+        ShatterPlan::Wire(plan) => plan.finish(b),
+    }
+}
+
+/// What Shatter draws: the pieces (Rendered view) or the wireframe lines.
+pub(super) enum ShatterPlan {
+    Pieces(PiecePlan),
+    Wire(SpritePlan),
+}
+
+pub(super) fn shatter_impl(ctx: &EffectCtx, b: &Buf) -> ShatterPlan {
+    let pr = ctx.params;
+    let view = pr.e("view");
+    let render = pr.e("render");
+    let kind = pr.e("shape/pattern");
+    let custom = kind as usize == SHATTER_PATTERNS.len() - 1;
+    let reps = pr.f("shape/repetitions").clamp(1.0, 500.0);
+    let dir = pr.f("shape/direction").to_radians();
+    let origin = pr.v2("shape/origin");
+    let forces = [
+        (pr.v2("force1/force1Position"), pr.f("force1/force1Depth"), pr.f("force1/force1Radius"), pr.f("force1/force1Strength")),
+        (pr.v2("force2/force2Position"), pr.f("force2/force2Depth"), pr.f("force2/force2Radius"), pr.f("force2/force2Strength")),
+    ];
+    let rot_speed = pr.f("physics/rotationSpeed");
+    let tumble = pr.e("physics/tumbleAxis");
+    let randomness = pr.f("physics/randomness");
+    let k = pr.f("physics/viscosity").max(0.0) * 5.0;
+    let mass_var = pr.f("physics/massVariance") / 100.0;
+    let gravity = pr.f("physics/gravity");
+    let gdir = pr.f("physics/gravityDirection").to_radians();
+    let ginc = pr.f("physics/gravityInclination").to_radians();
+    let seed = (pr.f("randomSeed") as u32).wrapping_mul(0x9e3779b1) ^ ctx.seed;
+    let [lw, lh] = ctx.layer_size;
+    let s = b.scale;
+    let t = ctx.time.max(0.0);
+    let unit = lw * 0.1;
+    let cell = lw / reps;
+    let extrude = pr.f("shape/extrusionDepth").max(0.0) * cell * s;
+    let cam = crate::card3d::projection(ctx, b);
+    let eye = cam.eye();
+    let light = Lighting::from(ctx, b);
+    // Gradient: with a gradient layer only pieces at least as bright as 1 − Shatter Threshold
+    // (Invert Gradient: as dark) break.
+    let gradient = ctx.layer_param("gradient/gradientLayer", true).map(|o| crate::util::fit_layer(ctx, b, &o, true));
+    let threshold = pr.get("gradient/shatterThreshold").map(Value::as_f64).unwrap_or(0.0) / 100.0;
+    let invert_gradient = pr.b("gradient/invertGradient");
+    // Textures.
+    let tex_color = pr.get("textures/color").map(|v| v.as_color()).unwrap_or([1.0; 4]);
+    let tex_opacity = pr.get("textures/opacity").map(Value::as_f64).unwrap_or(1.0).clamp(0.0, 1.0) as f32;
+    let front = Face::from(ctx, b, "textures/frontMode", "textures/frontLayer", 1);
+    let side = Face::from(ctx, b, "textures/sideMode", "textures/sideLayer", 0);
+    let backf = Face::from(ctx, b, "textures/backMode", "textures/backLayer", 1);
+    let custom_map = custom.then(|| layer_or_self(ctx, b, "shape/customShatterMap", true, true));
+    let white_fixed = pr.b("shape/whiteTilesFixed");
+    let (sd, cd) = dir.sin_cos();
+    let to_layer = |q: [f64; 2]| [origin[0] + q[0] * cd - q[1] * sd, origin[1] + q[0] * sd + q[1] * cd];
+    // Pattern-space bounds of the layer rectangle.
+    let corners = [[0.0, 0.0], [lw, 0.0], [lw, lh], [0.0, lh]].map(|c: [f64; 2]| {
+        let (dx, dy) = (c[0] - origin[0], c[1] - origin[1]);
+        [dx * cd + dy * sd, -dx * sd + dy * cd]
+    });
+    let (px0, px1) = (corners.iter().map(|c| c[0]).fold(f64::INFINITY, f64::min), corners.iter().map(|c| c[0]).fold(f64::NEG_INFINITY, f64::max));
+    let (py0, py1) = (corners.iter().map(|c| c[1]).fold(f64::INFINITY, f64::min), corners.iter().map(|c| c[1]).fold(f64::NEG_INFINITY, f64::max));
+    // Custom Shatter Map: square cells grouped by the map's colour.
+    let cells = pattern_cells(if custom { 3 } else { kind }, cell, px0, py0, px1, py1, seed);
+    let polys: Vec<Vec<[f64; 2]>> = cells.iter().map(|poly| poly.iter().map(|&q| to_layer(q)).collect()).collect();
+    let centre = |lp: &[[f64; 2]]| [lp.iter().map(|v| v[0]).sum::<f64>() / lp.len() as f64, lp.iter().map(|v| v[1]).sum::<f64>() / lp.len() as f64];
+    let keys: Vec<u32> = match &custom_map {
+        Some(m) => polys
+            .iter()
+            .map(|lp| {
+                let c = centre(lp);
+                map_key(m.sample_bilinear(c[0] * s + b.offset[0], c[1] * s + b.offset[1]))
+            })
+            .collect(),
+        None => (0..polys.len() as u32).collect(),
+    };
+    // Group centres (custom map) — each group moves as one rigid piece.
+    let mut groups: std::collections::HashMap<u32, ([f64; 2], f64)> = std::collections::HashMap::new();
+    for (lp, &key) in polys.iter().zip(&keys) {
+        let c = centre(lp);
+        let e = groups.entry(key).or_insert(([0.0; 2], 0.0));
+        e.0[0] += c[0];
+        e.0[1] += c[1];
+        e.1 += 1.0;
+    }
+    let g3 = [gdir.sin() * ginc.cos() * gravity * unit, -gdir.cos() * ginc.cos() * gravity * unit, ginc.sin() * gravity * unit];
+    let mut pieces: Vec<Piece> = polys
+        .par_iter()
+        .zip(keys.par_iter())
+        .flat_map_iter(|(lp, &key)| {
+            let mut out: Vec<Piece> = vec![];
+            let (mnx, mxx) = (lp.iter().map(|v| v[0]).fold(f64::INFINITY, f64::min), lp.iter().map(|v| v[0]).fold(f64::NEG_INFINITY, f64::max));
+            let (mny, mxy) = (lp.iter().map(|v| v[1]).fold(f64::INFINITY, f64::min), lp.iter().map(|v| v[1]).fold(f64::NEG_INFINITY, f64::max));
+            if mxx < 0.0 || mxy < 0.0 || mnx > lw || mny > lh || key == u32::MAX {
+                return out.into_iter();
+            }
+            let pc_c = centre(lp);
+            let (gsum, gn) = groups[&key];
+            let gc = [gsum[0] / gn, gsum[1] / gn];
+            let i = key;
+            // Broken when inside a force sphere (centred `depth` in front of the layer).
+            let mut v = [0.0f64; 3];
+            let mut broken = false;
+            for (fp, fd, fr, fs) in forces {
+                let rad = fr * lw;
+                if rad <= 0.0 {
+                    continue;
+                }
+                let dv = [gc[0] - fp[0], gc[1] - fp[1], fd * lw];
+                let dist = (dv[0] * dv[0] + dv[1] * dv[1] + dv[2] * dv[2]).sqrt();
+                if dist < rad {
+                    broken = true;
+                    let f = fs * (1.0 - dist / rad) * unit / dist.max(1e-6);
+                    for q in 0..3 {
+                        v[q] += dv[q] * f;
+                    }
+                }
+            }
+            if broken && let Some(g) = &gradient {
+                let (c, _) = unpremul(g.sample_bilinear(gc[0] * s + b.offset[0], gc[1] * s + b.offset[1]));
+                let mut l = effectcraft_color::luminance(c[0], c[1], c[2]).clamp(0.0, 1.0) as f64;
+                if invert_gradient {
+                    l = 1.0 - l;
+                }
+                broken = threshold > 0.0 && l >= 1.0 - threshold;
+            }
+            if broken && custom && white_fixed && key == 0xfff {
+                broken = false;
+            }
+            if (broken && render == 1) || (!broken && render == 2) {
+                return out.into_iter();
+            }
+            let mut gpos = [gc[0], gc[1], 0.0];
+            let mut r = rot_axis([1.0, 0.0, 0.0], 0.0);
+            let moving = broken && t > 0.0;
+            if moving {
+                let mass = 1.0 + mass_var * hs(i, 1, seed) as f64;
+                for q in 0..3 {
+                    v[q] = v[q] / mass + randomness * unit * hs(i, 2 + q as u32, seed) as f64 * 2.0;
+                }
+                let (f1, f2) = drag_factors(k, t);
+                for q in 0..3 {
+                    gpos[q] += v[q] * f1 + g3[q] * f2;
+                }
+                let axis = match tumble {
+                    1 => [0.0, 0.0, 0.0],
+                    2 => [1.0, 0.0, 0.0],
+                    3 => [0.0, 1.0, 0.0],
+                    4 => [0.0, 0.0, 1.0],
+                    5 => [hs(i, 6, seed) as f64, hs(i, 7, seed) as f64, 0.0],
+                    6 => [hs(i, 6, seed) as f64, 0.0, hs(i, 8, seed) as f64],
+                    7 => [0.0, hs(i, 7, seed) as f64, hs(i, 8, seed) as f64],
+                    _ => [hs(i, 6, seed) as f64, hs(i, 7, seed) as f64, hs(i, 8, seed) as f64],
+                };
+                let speed = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt() / unit;
+                let omega = rot_speed * std::f64::consts::TAU * (0.5 + h(i, 9, seed) as f64) * speed.min(10.0);
+                r = rot_axis(axis, omega * f1);
+            }
+            // The piece's centre: its offset from the group centre, rotated with the group.
+            let off = [pc_c[0] - gc[0], pc_c[1] - gc[1], 0.0];
+            let pos: [f64; 3] = std::array::from_fn(|q| gpos[q] + (0..3).map(|k| r[q][k] * off[k]).sum::<f64>());
+            let tex: Vec<[f32; 2]> = lp.iter().map(|v| [(v[0] * s + b.offset[0]) as f32, (v[1] * s + b.offset[1]) as f32]).collect();
+            let c0 = [(pc_c[0] * s + b.offset[0]) as f32, (pc_c[1] * s + b.offset[1]) as f32];
+            let posb = [pos[0] * s + b.offset[0], pos[1] * s + b.offset[1], pos[2] * s];
+            let Some(mut pc) = Piece::new(&tex, c0, &r, posb, cam) else { return out.into_iter() };
+            pc.light(&light, &r, posb, eye);
+            pc.alpha = tex_opacity;
+            let face = if pc.back { &backf } else { &front };
+            if face.mode == 0 {
+                pc.flat = Some([tex_color[0], tex_color[1], tex_color[2]]);
+            } else if face.mode == 2 {
+                pc.tint = std::array::from_fn(|q| pc.tint[q] * tex_color[q]);
+            }
+            // Extrusion: the sides of a moving piece, from its front outline back by the depth.
+            if moving && extrude > 0.0 {
+                let nb = [r[0][2], r[1][2], r[2][2]];
+                let n = tex.len();
+                for e in 0..n {
+                    let (a, bv) = (tex[e], tex[(e + 1) % n]);
+                    let ed = [(bv[0] - a[0]) as f64, (bv[1] - a[1]) as f64];
+                    let len = (ed[0] * ed[0] + ed[1] * ed[1]).sqrt();
+                    if len < 1e-6 {
+                        continue;
+                    }
+                    let ew: [f64; 3] = std::array::from_fn(|q| (r[q][0] * ed[0] + r[q][1] * ed[1]) / len);
+                    let third = [ew[1] * nb[2] - ew[2] * nb[1], ew[2] * nb[0] - ew[0] * nb[2], ew[0] * nb[1] - ew[1] * nb[0]];
+                    let rs: M3 = std::array::from_fn(|q| [ew[q], nb[q], third[q]]);
+                    // Side centre in world: edge midpoint (world) plus half the depth backwards.
+                    let mid = [((a[0] + bv[0]) * 0.5 - c0[0]) as f64, ((a[1] + bv[1]) * 0.5 - c0[1]) as f64];
+                    let mw: [f64; 3] = std::array::from_fn(|q| posb[q] + r[q][0] * mid[0] + r[q][1] * mid[1] + nb[q] * extrude * 0.5);
+                    let (hl, hd) = ((len * 0.5) as f32, (extrude * 0.5) as f32);
+                    let cs = [(a[0] + bv[0]) * 0.5, (a[1] + bv[1]) * 0.5];
+                    let quad = [[cs[0] - hl, cs[1] - hd], [cs[0] + hl, cs[1] - hd], [cs[0] + hl, cs[1] + hd], [cs[0] - hl, cs[1] + hd]];
+                    if let Some(mut sp) = Piece::new(&quad, cs, &rs, mw, cam) {
+                        sp.light(&light, &rs, mw, eye);
+                        sp.alpha = tex_opacity;
+                        let colour = match (&side.img, side.mode) {
+                            (Some(img), m) if m != 0 => {
+                                let (c, _) = unpremul(img.sample_bilinear(cs[0] as f64, cs[1] as f64));
+                                if m == 2 { std::array::from_fn(|q| c[q] * tex_color[q]) } else { c }
+                            }
+                            _ => [tex_color[0], tex_color[1], tex_color[2]],
+                        };
+                        sp.flat = Some(colour);
+                        out.push(sp);
+                    }
+                }
+            }
+            out.push(pc);
+            out.into_iter()
+        })
+        .collect();
+    sort_far_first(&mut pieces);
+    if view == 0 {
+        let tex = |i: &Option<Image>| i.clone().map(PieceTex::Image);
+        let front_t = tex(&front.img).unwrap_or(PieceTex::Layer);
+        let back_t = tex(&backf.img).unwrap_or_else(|| front_t.clone());
+        return ShatterPlan::Pieces(PiecePlan { pieces, front: front_t, back: Some(back_t) });
+    }
+    {
+        // Wireframes: piece outlines (front view: at rest; otherwise animated), plus forces.
+        let animated = view == 2 || view == 4;
+        let mut lines = Vec::new();
+        for pc in &pieces {
+            let n = pc.n as usize;
+            let pts: Vec<[f32; 2]> = if animated {
+                let fw = inv3(&pc.inv);
+                match fw {
+                    Some(m) => pc.poly[..n]
+                        .iter()
+                        .map(|v| {
+                            let (a, bb) = ((v[0] - pc.c0[0]) as f64, (v[1] - pc.c0[1]) as f64);
+                            let w = m[2][0] * a + m[2][1] * bb + m[2][2];
+                            [((m[0][0] * a + m[0][1] * bb + m[0][2]) / w) as f32, ((m[1][0] * a + m[1][1] * bb + m[1][2]) / w) as f32]
+                        })
+                        .collect(),
+                    None => continue,
+                }
+            } else {
+                pc.poly[..n].to_vec()
+            };
+            for e in 0..n {
+                let (a, c) = (pts[e], pts[(e + 1) % n]);
+                lines.push(Sprite::new(a[0], a[1], 0.5, [0.75, 0.85, 1.0, 1.0], Shape::Line { dx: c[0] - a[0], dy: c[1] - a[1] }));
+            }
+        }
+        if view >= 3 {
+            for (fp, _, fr, _) in forces {
+                let (fx, fy) = b.to_px(fp);
+                let rad = fr * lw * s;
+                for k in 0..64 {
+                    let (a0, a1) = (k as f64 / 64.0 * std::f64::consts::TAU, (k + 1) as f64 / 64.0 * std::f64::consts::TAU);
+                    let (x0, y0) = (fx + rad * a0.cos(), fy + rad * a0.sin());
+                    let (x1, y1) = (fx + rad * a1.cos(), fy + rad * a1.sin());
+                    lines.push(Sprite::new(x0 as f32, y0 as f32, 0.5, [1.0, 0.3, 0.3, 1.0], Shape::Line { dx: (x1 - x0) as f32, dy: (y1 - y0) as f32 }));
+                }
+            }
+        }
+        ShatterPlan::Wire(SpritePlan { sprites: lines, tints: vec![], acc: Acc::Over, post: Post::Replace })
+    }
+}
diff --git a/crates/effects/src/sim2/surfaces.rs b/crates/effects/src/sim2/surfaces.rs
new file mode 100644
index 000000000..7c3c032f0
--- /dev/null
+++ b/crates/effects/src/sim2/surfaces.rs
@@ -0,0 +1,524 @@
+use super::{Acc, Buf, EffectCtx, Image, IntoParallelIterator, ParallelIterator, Plane, Px, Shape, SimCache, Sprite, Value, gauss_plane, params_key, unpremul};
+
+// ------------------------------------------------------------------ Caustics
+
+/// Sample with repeat mode: 0 Once (transparent outside), 1 Tiled, 2 Reflected.
+fn sample_repeat(img: &Image, x: f64, y: f64, mode: u32) -> Px {
+    let (w, hh) = (img.width as f64, img.height as f64);
+    match mode {
+        1 => img.sample_bilinear_clamped(x.rem_euclid(w), y.rem_euclid(hh)),
+        2 => {
+            let m = |v: f64, n: f64| {
+                let r = v.rem_euclid(2.0 * n);
+                if r > n { 2.0 * n - r } else { r }
+            };
+            img.sample_bilinear_clamped(m(x, w), m(y, hh))
+        }
+        _ => img.sample_bilinear(x, y),
+    }
+}
+
+/// Everything Caustics' per-pixel pass needs, prepared on the CPU (the other layers it reads
+/// and the parameter conversions); the layer's own pixels are not read.
+pub struct CausticsSetup {
+    /// The Bottom layer fitted to the buffer, `None` = the layer itself.
+    pub bottom: Option<Image>,
+    /// Gaussian σ (buffer px) blurring the bottom (transparent edges), 0 = none.
+    pub bottom_sigma: f64,
+    /// The water surface's height field (smoothed luminance), `None` = flat.
+    pub height: Option<Plane>,
+    /// The Sky layer fitted to the buffer.
+    pub sky: Option<Image>,
+    pub scaling: f64,
+    pub repeat: u32,
+    pub wave_h: f64,
+    /// Displacement per unit of height gradient.
+    pub k: f64,
+    /// Layer centre (buffer px).
+    pub cx: f64,
+    pub cy: f64,
+    /// Layer width (buffer px).
+    pub lw: f64,
+    pub surf: [f32; 4],
+    pub surf_op: f32,
+    pub cstr: f32,
+    pub lc: [f32; 4],
+    pub li: f32,
+    /// Light position (buffer px) and height (layer widths); `point` = from the position to
+    /// each pixel, else one direction from above the layer centre.
+    pub lx: f64,
+    pub ly: f64,
+    pub lheight: f64,
+    pub point: bool,
+    pub ambient: f32,
+    pub diffuse: f32,
+    pub specular: f32,
+    pub sharp: f32,
+    pub sky_scaling: f64,
+    pub sky_repeat: u32,
+    pub sky_int: f32,
+    pub convergence: f64,
+}
+
+/// Caustics' setup for layer geometry `b` (see [`CausticsSetup`]).
+pub fn caustics_setup(ctx: &EffectCtx, b: &Buf) -> CausticsSetup {
+    let pr = ctx.params;
+    let s = b.scale;
+    let bottom = ctx.layer_param("bottom/bottom", true).map(|o| crate::util::fit_layer(ctx, b, &o, pr.e("bottom/bottomSizeDiffers") == 1));
+    let blur = pr.f("bottom/blur") * s;
+    let wave_h = pr.f("water/waveHeight");
+    let smoothing = pr.f("water/smoothing") * s;
+    let depth = pr.f("water/waterDepth");
+    let ior = pr.f("water/refractiveIndex").max(1.0);
+    let lpos = pr.v2("lighting/lightPosition");
+    // Height field of the water surface (luminance of the chosen layer; none = flat).
+    let height = ctx.layer_param("water/waterSurface", true).map(|o| {
+        let img = crate::util::fit_layer(ctx, b, &o, true);
+        let pl = Plane::luma(&img);
+        if smoothing > 0.05 { gauss_plane(&pl, smoothing * 0.5, smoothing * 0.5) } else { pl }
+    });
+    let lw = ctx.layer_size[0] * s;
+    let k = wave_h * depth * (1.0 - 1.0 / ior) * lw * 2.0;
+    let (cx, cy) = (b.offset[0] + ctx.layer_size[0] * 0.5 * s, b.offset[1] + ctx.layer_size[1] * 0.5 * s);
+    let (lx, ly) = b.to_px(lpos);
+    let (lc, li, lheight) = (pr.color("lighting/lightColor"), pr.f("lighting/lightIntensity") as f32, pr.f("lighting/lightHeight").max(0.01));
+    // Light Type: Distant Source (one direction, from the light position above the layer
+    // centre), Point Source (from the light position to each pixel) or First Comp Light.
+    let light_type = pr.e("lighting/lightType");
+    let comp_light = if light_type == 2 { ctx.env.host.and_then(|h| h.comp_scene()).and_then(|sc| sc.light) } else { None };
+    let (lc, li, lx, ly, lheight, point) = match (light_type, comp_light) {
+        (2, Some(l)) => {
+            let c = [l.color[0], l.color[1], l.color[2], 1.0];
+            // Comp space: z away from the viewer; the light above the water is at −z.
+            let (px, py) = (l.pos[0] * s + b.offset[0], l.pos[1] * s + b.offset[1]);
+            (c, li, px, py, (-l.pos[2] / ctx.layer_size[0].max(1.0)).max(0.01), l.kind == 1)
+        }
+        (2, None) => (lc, 0.0, lx, ly, lheight, false),
+        (1, _) => (lc, li, lx, ly, lheight, true),
+        _ => (lc, li, lx, ly, lheight, false),
+    };
+    // Sky: the layer the water surface reflects (Surface Opacity 1 = a mirror of it).
+    let sky = ctx.layer_param("sky/sky", true).map(|o| crate::util::fit_layer(ctx, b, &o, pr.e("sky/skySizeDiffers") == 1));
+    CausticsSetup {
+        bottom,
+        bottom_sigma: if blur > 0.05 { blur * 0.5 } else { 0.0 },
+        height,
+        sky,
+        scaling: pr.f("bottom/scaling").max(0.01),
+        repeat: pr.e("bottom/repeatMode"),
+        wave_h,
+        k,
+        cx,
+        cy,
+        lw,
+        surf: pr.color("water/surfaceColor"),
+        surf_op: pr.f("water/surfaceOpacity") as f32,
+        cstr: pr.f("water/causticsStrength") as f32,
+        lc,
+        li,
+        lx,
+        ly,
+        lheight,
+        point,
+        ambient: pr.f("lighting/ambientLight") as f32,
+        diffuse: pr.f("material/diffuse") as f32,
+        specular: pr.f("material/specular") as f32,
+        sharp: pr.f("material/highlightSharpness").max(1.0) as f32,
+        sky_scaling: pr.get("sky/scaling").map(Value::as_f64).unwrap_or(1.0).max(0.01),
+        sky_repeat: pr.e("sky/repeatMode"),
+        sky_int: pr.get("sky/intensity").map(Value::as_f64).unwrap_or(0.3) as f32,
+        convergence: pr.get("sky/convergence").map(Value::as_f64).unwrap_or(0.5).clamp(0.0, 1.0),
+    }
+}
+
+pub(super) fn caustics(ctx: &EffectCtx, mut b: Buf) -> Buf {
+    let st = caustics_setup(ctx, &b);
+    let mut bottom = st.bottom.clone().unwrap_or_else(|| b.img.clone());
+    if st.bottom_sigma > 0.0 {
+        bottom = effectcraft_raster::gaussian_blur(&bottom, st.bottom_sigma, st.bottom_sigma, false);
+    }
+    let CausticsSetup {
+        scaling,
+        repeat,
+        wave_h,
+        k,
+        cx,
+        cy,
+        lw,
+        surf,
+        surf_op,
+        cstr,
+        lc,
+        li,
+        lx,
+        ly,
+        lheight,
+        point,
+        ambient,
+        diffuse,
+        specular,
+        sharp,
+        sky_scaling,
+        sky_repeat,
+        sky_int,
+        convergence,
+        ..
+    } = st;
+    let (height, sky) = (&st.height, &st.sky);
+    let (w, hh) = (b.img.width as usize, b.img.height as usize);
+    let norm3 = |v: [f64; 3]| {
+        let n = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt().max(1e-12);
+        [(v[0] / n) as f32, (v[1] / n) as f32, (v[2] / n) as f32]
+    };
+    let lv_at = |x: f64, y: f64| {
+        if point {
+            norm3([(lx - x) / lw.max(1.0), (ly - y) / lw.max(1.0), lheight])
+        } else {
+            norm3([(lx - cx) / lw.max(1.0), (ly - cy) / lw.max(1.0), lheight])
+        }
+    };
+    let grad = |x: usize, y: usize| -> (f64, f64) {
+        match height {
+            Some(pl) => {
+                let gx = (pl.get_clamped(x as i64 + 1, y as i64) - pl.get_clamped(x as i64 - 1, y as i64)) as f64 * 0.5;
+                let gy = (pl.get_clamped(x as i64, y as i64 + 1) - pl.get_clamped(x as i64, y as i64 - 1)) as f64 * 0.5;
+                (gx, gy)
+            }
+            None => (0.0, 0.0),
+        }
+    };
+    // Displacement and its Jacobian (caustic focusing) per pixel.
+    let disp: Vec<(f64, f64)> = (0..w * hh)
+        .into_par_iter()
+        .map(|i| {
+            let (gx, gy) = grad(i % w, i / w);
+            (-gx * k, -gy * k)
+        })
+        .collect();
+    b.img.rows_mut().for_each(|(y, row)| {
+        for (x, px) in row.iter_mut().enumerate() {
+            let i = y * w + x;
+            let (dx, dy) = disp[i];
+            let d = |xx: usize, yy: usize| disp[yy.min(hh - 1) * w + xx.min(w - 1)];
+            let (dxr, _) = d(x + 1, y);
+            let (_, dyd) = d(x, y + 1);
+            let (dxl, _) = d(x.saturating_sub(1), y);
+            let (_, dyu) = d(x, y.saturating_sub(1));
+            let jac = (1.0 + (dxr - dxl) * 0.5) * (1.0 + (dyd - dyu) * 0.5);
+            let focus = ((1.0 / jac.abs().max(0.2)) as f32 - 1.0).clamp(-1.0, 4.0);
+            let sx = cx + (x as f64 + 0.5 + dx - cx) / scaling;
+            let sy = cy + (y as f64 + 0.5 + dy - cy) / scaling;
+            let p = sample_repeat(&bottom, sx, sy, repeat);
+            let (c, a) = unpremul(p);
+            let (gx, gy) = grad(x, y);
+            let n = {
+                let v = [-gx * wave_h * 20.0, -gy * wave_h * 20.0, 1.0];
+                let m = (v[0] * v[0] + v[1] * v[1] + 1.0).sqrt();
+                [(v[0] / m) as f32, (v[1] / m) as f32, (v[2] / m) as f32]
+            };
+            let lv = lv_at(x as f64 + 0.5, y as f64 + 0.5);
+            let nl = (n[0] * lv[0] + n[1] * lv[1] + n[2] * lv[2]).max(0.0);
+            let hv = {
+                let v = [lv[0], lv[1], lv[2] + 1.0];
+                let m = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
+                [v[0] / m, v[1] / m, v[2] / m]
+            };
+            let spec = (n[0] * hv[0] + n[1] * hv[1] + n[2] * hv[2]).max(0.0).powf(sharp) * specular * li;
+            let light = ambient + diffuse * li * nl + cstr * focus * li;
+            // The surface: its colour lit like the water, or the sky it reflects (sampled along
+            // the surface normal; Convergence pulls the reflection towards the pixel itself).
+            let surface: [f32; 3] = match &sky {
+                Some(sk) => {
+                    let reach = (1.0 - convergence) * lw * 0.5;
+                    let (rx, ry) = (x as f64 + 0.5 + n[0] as f64 * reach, y as f64 + 0.5 + n[1] as f64 * reach);
+                    let (rx, ry) = (cx + (rx - cx) / sky_scaling, cy + (ry - cy) / sky_scaling);
+                    let (sc, _) = unpremul(sample_repeat(sk, rx, ry, sky_repeat));
+                    std::array::from_fn(|q| sc[q] * sky_int * 3.0 * surf[q])
+                }
+                None => std::array::from_fn(|q| surf[q] * (ambient + diffuse * li * nl)),
+            };
+            let cc: [f32; 3] = std::array::from_fn(|q| {
+                let base = c[q] * light * lc[q];
+                base * (1.0 - surf_op) + surface[q] * surf_op + spec * lc[q]
+            });
+            let a = (a + surf_op * (1.0 - a)).min(1.0);
+            *px = [cc[0] * a, cc[1] * a, cc[2] * a, a];
+        }
+    });
+    b
+}
+
+// ------------------------------------------------------------------ Wave World
+
+/// Wave World's simulated surface: an `nx` × `ny` grid of heights `u` and velocities `v`.
+#[derive(Clone, Debug)]
+pub struct Waves {
+    pub nx: usize,
+    pub ny: usize,
+    pub u: Vec<f32>,
+    pub v: Vec<f32>,
+}
+
+struct Producer {
+    ring: bool,
+    pos: [f32; 2],
+    len: f32,
+    width: f32,
+    angle: f32,
+    amp: f32,
+    freq: f32,
+    phase: f32,
+}
+
+impl Producer {
+    /// Weight of a grid point (layer-fraction coordinates, x in widths, y in widths).
+    fn weight(&self, x: f32, y: f32) -> f32 {
+        let (dx, dy) = (x - self.pos[0], y - self.pos[1]);
+        let (sa, ca) = self.angle.sin_cos();
+        let (u, v) = (dx * ca + dy * sa, -dx * sa + dy * ca);
+        let d = if self.ring {
+            let (a, bb) = ((self.len * 0.5).max(1e-3), (self.width * 0.5).max(1e-3));
+            ((u / a).powi(2) + (v / bb).powi(2)).sqrt()
+        } else {
+            let l = (self.len * 0.5).max(1e-3);
+            let wd = (self.width * 0.5).max(1e-3);
+            (u.abs() / l).max(v.abs() / wd)
+        };
+        (1.0 - d).clamp(0.0, 1.0).min(1.0)
+    }
+}
+
+static WAVE_CACHE: SimCache<Waves> = SimCache::new(4);
+
+/// What Wave World draws: the Height Map view of the simulated surface (grid heights and,
+/// with a ground layer, water depths per grid point), or the wireframe preview's lines.
+pub enum WavePlan {
+    Height { st: std::sync::Arc<Waves>, depth: Option<Vec<f32>> },
+    Wire(crate::sim::SpritePlan),
+}
+
+pub(super) fn wave_world(ctx: &EffectCtx, b: Buf) -> Buf {
+    match wave_world_impl(ctx, &b, false) {
+        Ok(img) => Buf { img, ..b },
+        Err(WavePlan::Wire(plan)) => plan.finish(b),
+        Err(WavePlan::Height { .. }) => b,
+    }
+}
+
+/// Wave World's simulation state for the frame, as a [`WavePlan`] (its pixels are not read).
+pub fn wave_world_plan(ctx: &EffectCtx, b: &Buf) -> Option<WavePlan> {
+    wave_world_impl(ctx, b, true).err()
+}
+
+fn wave_world_impl(ctx: &EffectCtx, b: &Buf, plan_only: bool) -> Result<Image, WavePlan> {
+    let pr = ctx.params;
+    let [lw, lh] = ctx.layer_size;
+    let res = pr.f("simulation/gridResolution").clamp(1.0, 400.0) as usize;
+    let res = if pr.b("simulation/gridResDownsamples") { ((res as f64) * b.scale).round().max(1.0) as usize } else { res };
+    let nx = res.max(2) + 1;
+    let ny = ((res as f64 * lh / lw.max(1.0)).round() as usize).max(2) + 1;
+    let speed = pr.f("simulation/waveSpeed").max(0.0) as f32;
+    let damping = pr.f("simulation/damping").max(0.0) as f32;
+    let reflect = pr.e("simulation/reflectEdges");
+    let preroll = pr.f("simulation/preRoll").max(0.0);
+    let prods: Vec<Producer> = [1, 2]
+        .iter()
+        .map(|k| {
+            let pos = pr.v2(&format!("producer{k}/producer{k}Position"));
+            Producer {
+                ring: pr.e(&format!("producer{k}/producer{k}Type")) == 0,
+                pos: [(pos[0] / lw.max(1.0)) as f32, (pos[1] / lw.max(1.0)) as f32],
+                len: pr.f(&format!("producer{k}/producer{k}Length")) as f32,
+                width: pr.f(&format!("producer{k}/producer{k}Width")) as f32,
+                angle: (pr.f(&format!("producer{k}/producer{k}Angle")) as f32).to_radians(),
+                amp: pr.f(&format!("producer{k}/producer{k}Amplitude")) as f32,
+                freq: pr.f(&format!("producer{k}/producer{k}Frequency")) as f32,
+                phase: (pr.f(&format!("producer{k}/producer{k}Phase")) as f32).to_radians(),
+            }
+        })
+        .collect();
+    let sps = crate::sim::SPS as f32;
+    // Wave speed in layer widths per second → cells per second; sub-steps keep it stable.
+    let cps = speed * (nx - 1) as f32;
+    let sub = ((cps * 2.0 / sps).ceil() as usize).clamp(1, 64);
+    let dt = 1.0 / (sps * sub as f32);
+    let cell = 1.0 / (nx - 1) as f32;
+    let weights: Vec<Vec<f32>> = prods.iter().map(|p| (0..nx * ny).map(|i| p.weight((i % nx) as f32 * cell, (i / nx) as f32 * cell)).collect()).collect();
+    // Ground: the ground layer's first frame, its luminance an elevation (× Steepness). Where
+    // it rises above Height the grid is dry (a wall the waves reflect from); shallow water
+    // slows the waves by Wave Strength.
+    let ground = pr.get("ground/ground").and_then(Value::as_layer).and_then(|id| {
+        let host = ctx.env.host?;
+        host.layer_at(id, ctx.env.comp_time - ctx.time, true)
+    });
+    let steep = pr.get("ground/steepness").map(Value::as_f64).unwrap_or(0.25) as f32;
+    let level = pr.get("ground/height").map(Value::as_f64).unwrap_or(0.25) as f32;
+    let wave_strength = pr.f("ground/waveStrength").clamp(0.0, 1.0) as f32;
+    // Water depth per grid point (None without ground: deep everywhere).
+    let depth: Option<Vec<f32>> = ground.as_ref().map(|lp| {
+        let (gw, gh) = (lp.size[0].max(1.0), lp.size[1].max(1.0));
+        (0..nx * ny)
+            .map(|i| {
+                let (fx, fy) = ((i % nx) as f64 / (nx - 1) as f64, (i / nx) as f64 / (ny - 1) as f64);
+                let (c, a) = unpremul(lp.buf.img.sample_bilinear_clamped(fx * gw * lp.buf.scale + lp.buf.offset[0], fy * gh * lp.buf.scale + lp.buf.offset[1]));
+                level - steep * effectcraft_color::luminance(c[0], c[1], c[2]) * a
+            })
+            .collect()
+    });
+    let speed_k: Vec<f32> = match &depth {
+        Some(d) => d.iter().map(|&v| if v <= 0.0 { 0.0 } else { 1.0 - wave_strength * (1.0 - (v / level.max(1e-3)).clamp(0.0, 1.0).sqrt()) }).collect(),
+        None => vec![1.0; nx * ny],
+    };
+    let mut key =
+        params_key(ctx, &Buf { img: Image::new(0, 0), offset: [0.0; 2], scale: if pr.b("simulation/gridResDownsamples") { b.scale } else { 1.0 } }, 4);
+    if let Some(d) = &depth {
+        key ^= d.iter().fold(0u64, |a, v| a.rotate_left(3) ^ v.to_bits() as u64);
+    }
+    let steps = crate::sim::steps_at(ctx.time + preroll);
+    let st = WAVE_CACHE.run(
+        key,
+        steps,
+        || Waves { nx, ny, u: vec![0.0; nx * ny], v: vec![0.0; nx * ny] },
+        |w, step| {
+            for k in 0..sub {
+                let t = (step as f32 + k as f32 / sub as f32) / sps - preroll as f32;
+                let c2 = cps * cps;
+                let mut acc = vec![0.0f32; nx * ny];
+                for y in 0..ny {
+                    for x in 0..nx {
+                        let i = y * nx + x;
+                        let g = |xx: usize, yy: usize| w.u[yy * nx + xx];
+                        let l = g(x.saturating_sub(1), y) + g((x + 1).min(nx - 1), y) + g(x, y.saturating_sub(1)) + g(x, (y + 1).min(ny - 1)) - 4.0 * w.u[i];
+                        acc[i] = c2 * speed_k[i] * speed_k[i] * l - damping * 4.0 * w.v[i];
+                    }
+                }
+                for i in 0..nx * ny {
+                    w.v[i] += acc[i] * dt;
+                    w.u[i] += w.v[i] * dt;
+                }
+                // Producers drive the surface.
+                for (p, wt) in prods.iter().zip(&weights) {
+                    if p.amp == 0.0 {
+                        continue;
+                    }
+                    let target = p.amp * (std::f32::consts::TAU * p.freq * t + p.phase).sin();
+                    for i in 0..nx * ny {
+                        if wt[i] > 0.0 {
+                            w.u[i] += (target - w.u[i]) * wt[i];
+                            w.v[i] *= 1.0 - wt[i];
+                        }
+                    }
+                }
+                // Dry ground holds the surface flat.
+                for i in 0..nx * ny {
+                    if speed_k[i] <= 0.0 {
+                        w.u[i] = 0.0;
+                        w.v[i] = 0.0;
+                    }
+                }
+                // Edges: reflective ones mirror; the others absorb in a thin sponge layer.
+                let refl = |side: u32| reflect == 5 || reflect == side;
+                let sponge = 4usize.min(nx / 4).max(1);
+                for y in 0..ny {
+                    for x in 0..nx {
+                        let i = y * nx + x;
+                        let mut f = 1.0f32;
+                        if !refl(1) && x < sponge {
+                            f = f.min(x as f32 / sponge as f32);
+                        }
+                        if !refl(3) && nx - 1 - x < sponge {
+                            f = f.min((nx - 1 - x) as f32 / sponge as f32);
+                        }
+                        if !refl(2) && y < sponge {
+                            f = f.min(y as f32 / sponge as f32);
+                        }
+                        if !refl(4) && ny - 1 - y < sponge {
+                            f = f.min((ny - 1 - y) as f32 / sponge as f32);
+                        }
+                        if f < 1.0 {
+                            let k = 0.85 + 0.15 * f;
+                            w.u[i] *= k;
+                            w.v[i] *= k;
+                        }
+                    }
+                }
+            }
+        },
+    );
+    let s = b.scale;
+    let (bw, bh) = (b.img.width, b.img.height);
+    let sample = |x: f64, y: f64| -> f32 {
+        let gx = (x / lw.max(1.0) * (st.nx - 1) as f64).clamp(0.0, (st.nx - 1) as f64);
+        let gy = (y / lw.max(1.0) * (st.nx - 1) as f64).clamp(0.0, (st.ny - 1) as f64);
+        let (x0, y0) = (gx.floor() as usize, gy.floor() as usize);
+        let (x1, y1) = ((x0 + 1).min(st.nx - 1), (y0 + 1).min(st.ny - 1));
+        let (tx, ty) = ((gx - x0 as f64) as f32, (gy - y0 as f64) as f32);
+        let g = |xx: usize, yy: usize| st.u[yy * st.nx + xx];
+        let a = g(x0, y0) + (g(x1, y0) - g(x0, y0)) * tx;
+        let c = g(x0, y1) + (g(x1, y1) - g(x0, y1)) * tx;
+        a + (c - a) * ty
+    };
+    if plan_only && pr.e("view") == 1 {
+        return Err(WavePlan::Height { st, depth });
+    }
+    if pr.e("view") == 1 {
+        let mut img = Image::new(bw, bh);
+        let bright = pr.f("heightMapControls/brightness") as f32;
+        let contrast = pr.f("heightMapControls/contrast") as f32;
+        let gamma = pr.f("heightMapControls/gamma").max(0.01) as f32;
+        let alpha = 1.0 - pr.f("heightMapControls/transparency") as f32;
+        let dry_transparent = pr.e("heightMapControls/renderDryAreasAs") == 1;
+        let dry_at = |x: f64, y: f64| -> bool {
+            let Some(d) = &depth else { return false };
+            let gx = (x / lw.max(1.0) * (st.nx - 1) as f64).round().clamp(0.0, (st.nx - 1) as f64) as usize;
+            let gy = (y / lw.max(1.0) * (st.nx - 1) as f64).round().clamp(0.0, (st.ny - 1) as f64) as usize;
+            d[gy * st.nx + gx] <= 0.0
+        };
+        img.rows_mut().for_each(|(y, row)| {
+            for (x, px) in row.iter_mut().enumerate() {
+                let lx = (x as f64 + 0.5 - b.offset[0]) / s;
+                let ly = (y as f64 + 0.5 - b.offset[1]) / s;
+                let v = (bright + contrast * sample(lx, ly)).clamp(0.0, 1.0).powf(1.0 / gamma);
+                let al = if dry_transparent && dry_at(lx, ly) { 0.0 } else { alpha };
+                *px = [v * al, v * al, v * al, al];
+            }
+        });
+        Ok(img)
+    } else {
+        // Wireframe preview: the grid turned by Horizontal Rotation about the vertical axis,
+        // tilted by Vertical Rotation, heights scaled by Vertical Scale.
+        let hr = pr.f("wireframeControls/horizontalRotation").to_radians();
+        let vr = pr.get("wireframeControls/verticalRotation").map(Value::as_f64).unwrap_or(53.0).to_radians();
+        let vs = pr.get("wireframeControls/verticalScale").map(Value::as_f64).unwrap_or(0.5);
+        let (sh, ch) = hr.sin_cos();
+        let (sv, cv) = vr.sin_cos();
+        let to = |x: usize, y: usize| -> [f32; 2] {
+            // Grid point relative to the layer centre (layer px), height in layer px.
+            let gx = x as f64 / (st.nx - 1) as f64 * lw - lw * 0.5;
+            let gy = y as f64 / (st.nx - 1) as f64 * lw - (st.ny - 1) as f64 / (st.nx - 1) as f64 * lw * 0.5;
+            let hgt = st.u[y * st.nx + x] as f64 * vs * lh * 0.5;
+            let (rx, ry) = (gx * ch - gy * sh, gx * sh + gy * ch);
+            let (px, py) = b.to_px([lw * 0.5 + rx, lh * 0.5 + ry * cv - hgt * sv]);
+            [px as f32, py as f32]
+        };
+        let mut lines = Vec::new();
+        for y in 0..st.ny {
+            for x in 0..st.nx {
+                let a = to(x, y);
+                if x + 1 < st.nx {
+                    let c = to(x + 1, y);
+                    lines.push(Sprite::new(a[0], a[1], 0.4, [0.4, 0.9, 0.4, 1.0], Shape::Line { dx: c[0] - a[0], dy: c[1] - a[1] }));
+                }
+                if y + 1 < st.ny {
+                    let c = to(x, y + 1);
+                    lines.push(Sprite::new(a[0], a[1], 0.4, [0.4, 0.9, 0.4, 1.0], Shape::Line { dx: c[0] - a[0], dy: c[1] - a[1] }));
+                }
+            }
+        }
+        let plan = crate::sim::SpritePlan { sprites: lines, tints: vec![], acc: Acc::Over, post: crate::sim::Post::OverBlack };
+        if plan_only {
+            return Err(WavePlan::Wire(plan));
+        }
+        Ok(plan.finish(Buf { img: Image::new(bw, bh), offset: b.offset, scale: b.scale }).img)
+    }
+}
diff --git a/crates/effects/src/sim2/tests.rs b/crates/effects/src/sim2/tests.rs
new file mode 100644
index 000000000..2ef35b122
--- /dev/null
+++ b/crates/effects/src/sim2/tests.rs
@@ -0,0 +1,485 @@
+use super::*;
+use crate::{EffectEnv, run_fx};
+
+fn ramp(w: u32, hh: u32) -> Image {
+    let mut img = Image::new(w, hh);
+    for y in 0..hh {
+        for x in 0..w {
+            img.set(x, y, [x as f32 / w as f32, y as f32 / hh as f32, 0.4, 1.0]);
+        }
+    }
+    img
+}
+
+fn run(id: &str, vals: &[(&str, Value)], img: Image, t: f64) -> Image {
+    run_fx(id, vals, img, t, EffectEnv::default()).img
+}
+
+fn max_diff(a: &Image, b: &Image) -> f32 {
+    a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|k| (p[k] - q[k]).abs()).fold(0.0, f32::max)).fold(0.0, f32::max)
+}
+
+fn sum_diff(a: &Image, b: &Image) -> f32 {
+    a.data.iter().zip(&b.data).map(|(p, q)| (0..4).map(|k| (p[k] - q[k]).abs()).sum::<f32>()).sum()
+}
+
+#[test]
+fn piece_at_rest_is_identity() {
+    let src = ramp(16, 16);
+    let cam = Cam { c: [8.0, 8.0], d: 64.0 };
+    let id = rot_axis([1.0, 0.0, 0.0], 0.0);
+    let pc = Piece::new(&[[0.0, 0.0], [16.0, 0.0], [16.0, 16.0], [0.0, 16.0]], [8.0, 8.0], &id, [8.0, 8.0, 0.0], cam).unwrap();
+    let mut out = Image::new(16, 16);
+    draw_pieces(&mut out, &[pc], &src, None);
+    assert!(max_diff(&out, &src) < 1e-4);
+}
+
+#[test]
+fn ball_action_draws_balls() {
+    let v = [("ballSize", num(80.0))];
+    let a = run("ec.sim.ccballaction", &v, ramp(32, 32), 0.0);
+    assert_eq!(a, run("ec.sim.ccballaction", &v, ramp(32, 32), 0.0));
+    assert!(a.data.iter().any(|p| p[3] > 0.9) && a.data.iter().any(|p| p[3] == 0.0), "balls with gaps");
+    let none = run("ec.sim.ccballaction", &[("ballSize", num(0.0))], ramp(32, 32), 0.0);
+    assert!(none.data.iter().all(|p| p[3] == 0.0));
+    let sc = run("ec.sim.ccballaction", &[("ballSize", num(80.0)), ("scatter", num(20.0))], ramp(32, 32), 0.0);
+    assert!(sum_diff(&a, &sc) > 1.0);
+}
+
+#[test]
+fn pixel_polly_breaks_after_start() {
+    let v = [("forceCenter", pt(16.0, 16.0)), ("gridSpacing", num(4.0))];
+    let before = run("ec.sim.ccpixelpolly", &v, ramp(32, 32), 0.0);
+    assert_eq!(before, ramp(32, 32), "intact before the start time");
+    let a = run("ec.sim.ccpixelpolly", &v, ramp(32, 32), 0.5);
+    assert_eq!(a, run("ec.sim.ccpixelpolly", &v, ramp(32, 32), 0.5));
+    assert!(sum_diff(&a, &ramp(32, 32)) > 10.0);
+    let tex = run("ec.sim.ccpixelpolly", &[("forceCenter", pt(16.0, 16.0)), ("gridSpacing", num(4.0)), ("object", Value::Enum(3))], ramp(32, 32), 0.5);
+    assert!(sum_diff(&a, &tex) > 0.1);
+}
+
+#[test]
+fn scatterize_identity_and_scatter() {
+    assert_eq!(run("ec.sim.ccscatterize", &[], ramp(24, 24), 0.0), ramp(24, 24));
+    let a = run("ec.sim.ccscatterize", &[("scatter", num(5.0))], ramp(24, 24), 0.0);
+    assert_eq!(a, run("ec.sim.ccscatterize", &[("scatter", num(5.0))], ramp(24, 24), 0.0));
+    assert!(sum_diff(&a, &ramp(24, 24)) > 1.0);
+    let tw = run("ec.sim.ccscatterize", &[("leftTwist", num(80.0)), ("rightTwist", num(80.0))], ramp(24, 24), 0.0);
+    assert!(sum_diff(&tw, &ramp(24, 24)) > 1.0);
+}
+
+#[test]
+fn card_dance_identity_and_rotation() {
+    let src = ramp(30, 20);
+    let a = run("ec.sim.carddance", &[], src.clone(), 0.0);
+    assert!(max_diff(&a, &src) < 0.02, "flat cards reproduce the layer: {}", max_diff(&a, &src));
+    let r = run("ec.sim.carddance", &[("yRotation/yRotSource", Value::Enum(1)), ("yRotation/yRotMultiplier", num(90.0))], src.clone(), 0.0);
+    assert_eq!(r, run("ec.sim.carddance", &[("yRotation/yRotSource", Value::Enum(1)), ("yRotation/yRotMultiplier", num(90.0))], src.clone(), 0.0));
+    assert!(sum_diff(&r, &src) > 5.0);
+    let z = run("ec.sim.carddance", &[("zPosition/zPosOffset", num(-1.0))], src.clone(), 0.0);
+    assert!(sum_diff(&z, &src) > 5.0, "cards pulled towards the camera grow");
+}
+
+#[test]
+fn shatter_at_rest_then_breaks() {
+    let v = [("view", Value::Enum(0)), ("force1/force1Position", pt(16.0, 16.0)), ("shape/origin", pt(16.0, 16.0))];
+    let src = ramp(32, 32);
+    let t0 = run("ec.sim.shatter", &v, src.clone(), 0.0);
+    assert!(max_diff(&t0, &src) < 0.03, "{}", max_diff(&t0, &src));
+    let t1 = run("ec.sim.shatter", &v, src.clone(), 0.5);
+    assert_eq!(t1, run("ec.sim.shatter", &v, src.clone(), 0.5));
+    assert!(sum_diff(&t1, &src) > 10.0);
+    for pat in 0..SHATTER_PATTERNS.len() as u32 {
+        let vv = [("view", Value::Enum(0)), ("shape/pattern", Value::Enum(pat)), ("force1/force1Position", pt(16.0, 16.0)), ("shape/origin", pt(16.0, 16.0))];
+        let r = run("ec.sim.shatter", &vv, src.clone(), 0.0);
+        assert!(max_diff(&r, &src) < 0.05, "pattern {pat} tiles the layer: {}", max_diff(&r, &src));
+    }
+    let wire = run("ec.sim.shatter", &[("shape/repetitions", num(3.0))], src.clone(), 0.0);
+    assert!(wire.data.iter().any(|p| p[3] > 0.5) && wire.data.iter().any(|p| p[3] == 0.0));
+    let layer_only =
+        run("ec.sim.shatter", &[("view", Value::Enum(0)), ("render", Value::Enum(1)), ("force1/force1Position", pt(16.0, 16.0))], src.clone(), 0.5);
+    assert!(layer_only.get(16, 16)[3] == 0.0, "broken centre removed");
+}
+
+#[test]
+fn caustics_flat_water() {
+    let src = ramp(24, 24);
+    let a = run(
+        "ec.sim.caustics",
+        &[
+            ("water/surfaceOpacity", num(0.0)),
+            ("lighting/ambientLight", num(0.0)),
+            ("material/diffuse", num(1.0)),
+            ("lighting/lightHeight", num(1000.0)),
+            ("material/specular", num(0.0)),
+        ],
+        src.clone(),
+        0.0,
+    );
+    assert!(max_diff(&a, &src) < 0.01, "flat water, light overhead = bottom: {}", max_diff(&a, &src));
+    let b = run("ec.sim.caustics", &[], src.clone(), 0.0);
+    assert_eq!(b, run("ec.sim.caustics", &[], src.clone(), 0.0));
+    assert!(sum_diff(&b, &src) > 0.1);
+}
+
+#[test]
+fn caustics_sky_and_light_types() {
+    let src = Image::filled(32, 32, [0.5, 0.5, 0.5, 1.0]);
+    let env = EffectEnv { host: Some(&FoamHost), ..Default::default() };
+    let run_h = |vals: &[(&str, Value)]| run_fx("ec.sim.caustics", vals, src.clone(), 0.0, env).img;
+    // A mirror-like surface shows the (green) sky.
+    let mirror = [("water/surfaceOpacity", num(1.0)), ("sky/sky", Value::Layer(Some(2))), ("sky/intensity", num(1.0))];
+    let p = run_h(&mirror).get(16, 16);
+    assert!(p[1] > p[0] + 0.3 && p[1] > p[2] + 0.3, "{p:?}");
+    // Point Source lights pixels by their own direction to the light: the image is no
+    // longer uniform; Distant Source lights the flat water evenly.
+    let lit = |t: u32| {
+        run_h(&[
+            ("lighting/lightType", Value::Enum(t)),
+            ("lighting/lightPosition", pt(0.0, 0.0)),
+            ("lighting/lightHeight", num(0.2)),
+            ("water/surfaceOpacity", num(0.0)),
+        ])
+    };
+    let (distant, point) = (lit(0), lit(1));
+    assert!((distant.get(2, 2)[0] - distant.get(30, 30)[0]).abs() < 1e-5);
+    assert!(point.get(2, 2)[0] > point.get(30, 30)[0] + 0.02, "{:?} {:?}", point.get(2, 2), point.get(30, 30));
+    // First Comp Light without a comp light: ambient only.
+    let none = run_h(&[("lighting/lightType", Value::Enum(2)), ("water/surfaceOpacity", num(0.0))]);
+    assert!(none.get(16, 16)[0] < distant.get(16, 16)[0]);
+}
+
+#[test]
+fn wave_world_wireframe_controls_ground_and_dry_areas() {
+    let base = [("producer1/producer1Position", pt(8.0, 16.0)), ("simulation/gridResolution", num(24.0))];
+    let wire = |extra: &[(&str, Value)]| run("ec.sim.waveworld", &[base.as_slice(), extra].concat(), Image::new(32, 32), 0.5);
+    assert_ne!(wire(&[]), wire(&[("wireframeControls/horizontalRotation", num(40.0))]));
+    assert_ne!(wire(&[]), wire(&[("wireframeControls/verticalScale", num(3.0))]));
+    // Ground (left dark, right light): the light side rises above the water and is dry.
+    let env = EffectEnv { host: Some(&FoamHost), ..Default::default() };
+    let hm = |extra: &[(&str, Value)]| {
+        let mut v: Vec<(&str, Value)> = base.to_vec();
+        v.extend([("view", Value::Enum(1)), ("ground/ground", Value::Layer(Some(1))), ("ground/steepness", num(0.5)), ("ground/height", num(0.25))]);
+        v.extend_from_slice(extra);
+        run_fx("ec.sim.waveworld", &v, Image::new(32, 32), 1.0, env).img
+    };
+    let solid = hm(&[]);
+    let clear = hm(&[("heightMapControls/renderDryAreasAs", Value::Enum(1))]);
+    assert!(solid.get(30, 16)[3] > 0.99 && clear.get(30, 16)[3] == 0.0);
+    assert!(clear.get(4, 16)[3] > 0.99, "wet side stays");
+    // Dry ground stays flat: mid grey (brightness 0.5) there.
+    assert!((solid.get(30, 16)[0] - 0.5).abs() < 1e-4);
+    // Wave Strength slows waves over shallow water: the surface differs.
+    assert_ne!(hm(&[]), hm(&[("ground/waveStrength", num(1.0))]));
+}
+
+#[test]
+fn wave_world_seek_and_waves() {
+    let v = vec![("view", Value::Enum(1)), ("producer1/producer1Position", pt(16.0, 16.0)), ("simulation/gridResolution", num(24.0))];
+    let _ = run("ec.sim.waveworld", &v, Image::new(32, 32), 0.5);
+    let a = run("ec.sim.waveworld", &v, Image::new(32, 32), 1.0);
+    let mut v2 = v.clone();
+    v2.push(("heightMapControls/transparency", num(0.0)));
+    assert_eq!(a, run("ec.sim.waveworld", &v2, Image::new(32, 32), 1.0));
+    // Waves spread: some pixels differ from the flat-water grey.
+    assert!(a.data.iter().any(|p| (p[0] - 0.5).abs() > 0.05), "waves");
+    let flat = run("ec.sim.waveworld", &[("view", Value::Enum(1)), ("producer1/producer1Amplitude", num(0.0))], Image::new(32, 32), 1.0);
+    assert!(flat.data.iter().all(|p| (p[0] - 0.5).abs() < 1e-5));
+    let wire = run("ec.sim.waveworld", &[("producer1/producer1Position", pt(16.0, 16.0)), ("simulation/gridResolution", num(10.0))], Image::new(32, 32), 0.3);
+    assert!(wire.data.iter().any(|p| p[1] > 0.3));
+}
+
+#[test]
+fn wave_world_steps_match_direct() {
+    // Fresh caches: resumed simulation equals simulation from scratch.
+    let v = vec![
+        ("view", Value::Enum(1)),
+        ("producer1/producer1Position", pt(16.0, 16.0)),
+        ("simulation/gridResolution", num(20.0)),
+        ("simulation/damping", num(0.07)),
+    ];
+    let a = run("ec.sim.waveworld", &v, Image::new(32, 32), 1.3);
+    let mut v2 = v.clone();
+    v2.push(("simulation/damping", num(0.07000001)));
+    // Different key: computed from scratch at 1.3 directly vs via 0.4 (both fresh keys).
+    let _ = run("ec.sim.waveworld", &v2, Image::new(32, 32), 0.4);
+    let b = run("ec.sim.waveworld", &v2, Image::new(32, 32), 1.3);
+    assert!(max_diff(&a, &b) < 1e-3, "{}", max_diff(&a, &b));
+}
+
+#[test]
+fn foam_bubbles_drift_and_seek() {
+    let v = vec![("producer/producerPoint", pt(16.0, 16.0)), ("view", Value::Enum(2)), ("producer/productionRate", num(2.0))];
+    let none = run("ec.sim.foam", &v, Image::new(32, 32), 0.0);
+    assert!(none.data.iter().all(|p| p[3] == 0.0));
+    let _ = run("ec.sim.foam", &v, Image::new(32, 32), 0.6);
+    let a = run("ec.sim.foam", &v, Image::new(32, 32), 1.2);
+    let mut v2 = v.clone();
+    v2.push(("randomSeed", num(1.0)));
+    assert_eq!(a, run("ec.sim.foam", &v2, Image::new(32, 32), 1.2));
+    assert!(a.data.iter().any(|p| p[3] > 0.05), "bubbles");
+    let draft = run("ec.sim.foam", &[("producer/producerPoint", pt(16.0, 16.0)), ("producer/productionRate", num(2.0))], Image::new(32, 32), 1.0);
+    assert!(draft.data.iter().any(|p| p[3] > 0.05));
+}
+
+#[test]
+fn foam_strength_controls_early_popping() {
+    // Strong bubbles all live their full lifespan; weak ones pop at random earlier.
+    assert_eq!(foam_pop_age(7, 300.0, 0.0, 1), 300.0);
+    let early = (0..200).filter(|&id| foam_pop_age(id, 300.0, 1.0, 1) < 150.0).count();
+    assert!(early > 60 && early < 140, "{early}");
+    let count = |strength: f64| {
+        let v = vec![
+            ("producer/producerPoint", pt(16.0, 16.0)),
+            ("producer/productionRate", num(3.0)),
+            ("bubbles/lifespan", num(40.0)),
+            ("bubbles/strength", num(strength)),
+            ("physics/windSpeed", num(0.0)),
+        ];
+        run("ec.sim.foam", &v, Image::new(32, 32), 1.5).data.iter().map(|p| p[3]).sum::<f32>()
+    };
+    assert!(count(0.0) < count(20.0) * 0.9, "{} vs {}", count(0.0), count(20.0));
+}
+
+/// A host with a comp camera (identity, or tilted) and a first comp light.
+struct Scene {
+    camera: Option<[[f64; 4]; 3]>,
+    light: Option<crate::CompLight>,
+    layer: Option<Image>,
+}
+impl crate::EffectHost for Scene {
+    fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
+        let img = self.layer.clone()?;
+        let size = [img.width as f64, img.height as f64];
+        Some(crate::LayerPixels { buf: Buf { img, offset: [0.0; 2], scale: 1.0 }, size })
+    }
+    fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+        None
+    }
+    fn comp_scene(&self) -> Option<crate::CompScene> {
+        Some(crate::CompScene { camera: self.camera, camera_layer: true, light: self.light })
+    }
+}
+
+fn run_env(id: &str, vals: &[(&str, Value)], img: Image, t: f64, host: &Scene) -> Image {
+    run_fx(id, vals, img, t, EffectEnv { host: Some(host), ..Default::default() }).img
+}
+
+#[test]
+fn card_dance_camera_systems() {
+    let src = ramp(40, 30);
+    // Camera Position: rotating the camera changes the view; zero rotation is the layer.
+    let r = run("ec.sim.carddance", &[("cameraPosition/yRotation", num(30.0))], src.clone(), 0.0);
+    assert!(sum_diff(&r, &src) > 10.0);
+    let order = run("ec.sim.carddance", &[("cameraPosition/yRotation", num(30.0)), ("cameraPosition/xRotation", num(30.0))], src.clone(), 0.0);
+    let order2 = run(
+        "ec.sim.carddance",
+        &[("cameraPosition/yRotation", num(30.0)), ("cameraPosition/xRotation", num(30.0)), ("cameraPosition/transformOrder", Value::Enum(5))],
+        src.clone(),
+        0.0,
+    );
+    assert!(sum_diff(&order, &order2) > 1.0, "Transform Order matters");
+    // X, Y Position moves the view: the layer shifts by the offset.
+    let moved = run("ec.sim.carddance", &[("cameraPosition/xyPosition", pt(30.0, 15.0))], src.clone(), 0.0);
+    assert!((moved.get(25, 10)[0] - src.get(15, 10)[0]).abs() < 0.03, "{:?} {:?}", moved.get(25, 10), src.get(15, 10));
+    // Corner Pins: the layer's corners land on the pins.
+    let pins = [
+        ("cameraSystem", Value::Enum(1)),
+        ("cornerPins/upperLeftCorner", pt(10.0, 5.0)),
+        ("cornerPins/upperRightCorner", pt(30.0, 5.0)),
+        ("cornerPins/lowerLeftCorner", pt(10.0, 25.0)),
+        ("cornerPins/lowerRightCorner", pt(30.0, 25.0)),
+    ];
+    let cp = run("ec.sim.carddance", &pins, src.clone(), 0.0);
+    assert_eq!(cp.get(3, 3)[3], 0.0, "outside the pinned quad");
+    assert!(cp.get(20, 15)[3] > 0.99);
+    assert!((cp.get(20, 15)[0] - src.get(20, 15)[0]).abs() < 0.05, "centre maps to centre");
+    // Comp Camera: the identity camera reproduces the layer; a camera that doubles x moves it.
+    let ident = Scene { camera: Some([[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.002, 1.0]]), light: None, layer: None };
+    let cc = run_env("ec.sim.carddance", &[("cameraSystem", Value::Enum(2))], src.clone(), 0.0, &ident);
+    assert!(max_diff(&cc, &src) < 0.02, "{}", max_diff(&cc, &src));
+    let half = Scene { camera: Some([[0.5, 0.0, 0.0, 0.0], [0.0, 0.5, 0.0, 0.0], [0.0, 0.0, 0.002, 1.0]]), ..ident };
+    let cc = run_env("ec.sim.carddance", &[("cameraSystem", Value::Enum(2))], src.clone(), 0.0, &half);
+    assert_eq!(cc.get(35, 25)[3], 0.0, "half-size view leaves the far corner empty");
+}
+
+#[test]
+fn card_dance_lighting_and_material() {
+    let src = Image::filled(40, 30, [0.5, 0.5, 0.5, 1.0]);
+    let tilt = [("rows", num(1.0)), ("columns", num(1.0)), ("yRotation/yRotSource", Value::Enum(0)), ("yRotation/yRotOffset", num(60.0))];
+    let lit = |extra: &[(&str, Value)]| {
+        let mut v: Vec<(&str, Value)> = tilt.to_vec();
+        v.extend_from_slice(extra);
+        run("ec.sim.carddance", &v, src.clone(), 0.0).get(20, 15)
+    };
+    let base = lit(&[]);
+    // Tilted cards facing away from a frontal light get darker than flat ones.
+    assert!(base[0] < 0.45, "{base:?}");
+    // Light colour tints; intensity brightens; ambient alone lights evenly.
+    let red = lit(&[("lighting/lightColor", col(1.0, 0.0, 0.0))]);
+    assert!(red[0] > red[1] + 0.05);
+    assert!(lit(&[("lighting/lightIntensity", num(2.0))])[0] > base[0]);
+    let amb = lit(&[("lighting/ambientLight", num(1.0)), ("material/diffuse", num(0.0))]);
+    assert!((amb[0] - 0.5).abs() < 1e-3);
+    // A light placed to the side (Point Source) changes the shading of the tilted card.
+    let side = lit(&[("lighting/lightType", Value::Enum(1)), ("lighting/lightPosition", pt(200.0, 15.0)), ("lighting/lightDepth", num(0.2))]);
+    assert!((side[0] - base[0]).abs() > 0.02, "{side:?} vs {base:?}");
+    // Specular adds a highlight on flat, frontally lit cards.
+    let flat = run("ec.sim.carddance", &[("material/specular", num(0.5))], src.clone(), 0.0).get(20, 15);
+    assert!(flat[0] > 0.9, "{flat:?}");
+    // First Comp Light: no light in the comp → ambient only; a light from the host is used.
+    let none = Scene { camera: None, light: None, layer: None };
+    let a = run_env("ec.sim.carddance", &[("lighting/lightType", Value::Enum(2))], src.clone(), 0.0, &none).get(20, 15);
+    assert!((a[0] - 0.5 * (0.25 + 0.75)).abs() < 1e-3, "{a:?}");
+    let blue = Scene { light: Some(crate::CompLight { pos: [20.0, 15.0, -100.0], dir: [0.0, 0.0, 1.0], color: [0.0, 0.0, 1.0], kind: 0 }), ..none };
+    let a = run_env("ec.sim.carddance", &[("lighting/lightType", Value::Enum(2))], src.clone(), 0.0, &blue).get(20, 15);
+    assert!(a[2] > a[0] + 0.2, "{a:?}");
+}
+
+#[test]
+fn shatter_custom_map_gradient_textures_and_extrusion() {
+    let src = ramp(32, 32);
+    let base = [("view", Value::Enum(0)), ("force1/force1Position", pt(16.0, 16.0)), ("force1/force1Radius", num(2.0)), ("shape/origin", pt(16.0, 16.0))];
+    let with = |extra: &[(&str, Value)], t: f64, host: Option<&Scene>| {
+        let mut v: Vec<(&str, Value)> = base.to_vec();
+        v.extend_from_slice(extra);
+        match host {
+            Some(h) => run_env("ec.sim.shatter", &v, src.clone(), t, h),
+            None => run("ec.sim.shatter", &v, src.clone(), t),
+        }
+    };
+    // Custom Shatter Map: a map white on the left and black on the right; with White Tiles
+    // Fixed the left half stays put while the right half breaks away.
+    let mut map = Image::new(32, 32);
+    for y in 0..32 {
+        for x in 0..32 {
+            map.set(x, y, if x < 16 { [1.0; 4] } else { [0.0, 0.0, 0.0, 1.0] });
+        }
+    }
+    let host = Scene { camera: None, light: None, layer: Some(map) };
+    let custom = [("shape/pattern", Value::Enum(5)), ("shape/customShatterMap", Value::Layer(Some(1))), ("shape/whiteTilesFixed", Value::Bool(true))];
+    let at_rest = with(&custom, 0.0, Some(&host));
+    assert!(max_diff(&at_rest, &src) < 0.05, "custom pieces tile the layer: {}", max_diff(&at_rest, &src));
+    let broke = with(&custom, 1.0, Some(&host));
+    assert!(max_diff_region(&broke, &src, 0..12) < 0.05, "white tiles fixed");
+    assert!(sum_diff_region(&broke, &src, 20..32) > 5.0, "black group moved");
+    // Gradient: a black gradient layer with threshold 50 % keeps everything together.
+    let black = Scene { camera: None, light: None, layer: Some(Image::filled(32, 32, [0.0, 0.0, 0.0, 1.0])) };
+    let g = with(&[("gradient/gradientLayer", Value::Layer(Some(1))), ("gradient/shatterThreshold", num(50.0))], 1.0, Some(&black));
+    assert!(max_diff(&g, &src) < 0.05);
+    let gi = with(
+        &[("gradient/gradientLayer", Value::Layer(Some(1))), ("gradient/shatterThreshold", num(50.0)), ("gradient/invertGradient", Value::Bool(true))],
+        1.0,
+        Some(&black),
+    );
+    assert!(sum_diff(&gi, &src) > 10.0);
+    // Textures: Front Mode Color paints the pieces flat; Opacity fades them.
+    let flat = with(&[("textures/frontMode", Value::Enum(0)), ("textures/color", col(0.0, 1.0, 0.0))], 0.0, None);
+    let p = flat.get(16, 16);
+    assert!(p[1] > 0.95 && p[0] < 0.05, "{p:?}");
+    let half = with(&[("textures/opacity", num(0.5)), ("shape/repetitions", num(2.0))], 0.0, None);
+    assert!((half.get(8, 4)[3] - 0.5).abs() < 0.02, "{:?}", half.get(8, 4));
+    // Extrusion: thicker pieces cover more once they tumble.
+    let cover = |d: f64| {
+        with(&[("shape/extrusionDepth", num(d)), ("textures/sideMode", Value::Enum(0)), ("textures/color", col(1.0, 1.0, 1.0))], 0.6, None)
+            .data
+            .iter()
+            .map(|p| p[3])
+            .sum::<f32>()
+    };
+    assert!(cover(1.0) > cover(0.0) + 1.0, "{} vs {}", cover(1.0), cover(0.0));
+    // Deterministic and seek-consistent.
+    assert_eq!(with(&custom, 0.7, Some(&host)), with(&custom, 0.7, Some(&host)));
+}
+
+fn max_diff_region(a: &Image, b: &Image, xs: std::ops::Range<u32>) -> f32 {
+    let mut m = 0.0f32;
+    for y in 0..a.height {
+        for x in xs.clone() {
+            let (p, q) = (a.get(x as i64, y as i64), b.get(x as i64, y as i64));
+            m = (0..4).map(|k| (p[k] - q[k]).abs()).fold(m, f32::max);
+        }
+    }
+    m
+}
+
+fn sum_diff_region(a: &Image, b: &Image, xs: std::ops::Range<u32>) -> f32 {
+    let mut s = 0.0;
+    for y in 0..a.height {
+        for x in xs.clone() {
+            let (p, q) = (a.get(x as i64, y as i64), b.get(x as i64, y as i64));
+            s += (0..4).map(|k| (p[k] - q[k]).abs()).sum::<f32>();
+        }
+    }
+    s
+}
+
+/// Layer 1 = a left-dark, right-light ramp; layer 2 = solid green.
+struct FoamHost;
+impl crate::EffectHost for FoamHost {
+    fn layer(&self, id: u64, _: bool) -> Option<crate::LayerPixels> {
+        let img = if id == 1 { ramp(32, 32) } else { Image::filled(32, 32, [0.0, 1.0, 0.0, 1.0]) };
+        Some(crate::LayerPixels { buf: Buf { img, offset: [0.0; 2], scale: 1.0 }, size: [32.0, 32.0] })
+    }
+    fn layer_at(&self, id: u64, _: f64, me: bool) -> Option<crate::LayerPixels> {
+        self.layer(id, me)
+    }
+    fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+        None
+    }
+}
+
+#[test]
+fn foam_flow_map_pop_velocity_wobble_textures_and_reflection() {
+    let base = vec![
+        ("producer/producerPoint", pt(16.0, 16.0)),
+        ("producer/productionRate", num(2.0)),
+        ("physics/windSpeed", num(0.0)),
+        ("physics/turbulence", num(0.0)),
+        ("view", Value::Enum(2)),
+    ];
+    let with = |extra: &[(&str, Value)], t: f64| {
+        let mut v = base.clone();
+        v.extend_from_slice(extra);
+        run_fx("ec.sim.foam", &v, Image::new(32, 32), t, EffectEnv { host: Some(&FoamHost), ..Default::default() }).img
+    };
+    let cx = |img: &Image| {
+        let (mut s, mut n) = (0.0, 0.0);
+        for y in 0..32 {
+            for x in 0..32 {
+                let a = img.get(x, y)[3];
+                s += a * x as f32;
+                n += a;
+            }
+        }
+        s / n.max(1e-6)
+    };
+    // Flow map: bubbles run downhill (towards the dark left side).
+    let still = with(&[], 1.0);
+    let flowing = with(&[("flowMap/flowMap", Value::Layer(Some(1))), ("flowMap/flowMapSteepness", num(1.0))], 1.0);
+    assert!(cx(&flowing) < cx(&still) - 1.0, "{} vs {}", cx(&flowing), cx(&still));
+    let hq = with(&[("flowMap/flowMap", Value::Layer(Some(1))), ("flowMap/flowMapSteepness", num(1.0)), ("flowMap/simulationQuality", Value::Enum(2))], 1.0);
+    assert_eq!(
+        hq,
+        with(&[("flowMap/flowMap", Value::Layer(Some(1))), ("flowMap/flowMapSteepness", num(1.0)), ("flowMap/simulationQuality", Value::Enum(2))], 1.0)
+    );
+    // Pop velocity scatters the survivors when short-lived bubbles pop.
+    let short = [("bubbles/lifespan", num(8.0)), ("bubbles/strength", num(0.0))];
+    let a = with(&[short.as_slice(), &[("physics/popVelocity", num(0.0))]].concat(), 1.0);
+    let b2 = with(&[short.as_slice(), &[("physics/popVelocity", num(20.0))]].concat(), 1.0);
+    assert_ne!(a, b2);
+    // Wobble changes the drawn bubbles.
+    assert_ne!(with(&[("physics/wobbleAmount", num(0.0))], 1.0), with(&[("physics/wobbleAmount", num(3.0))], 1.0));
+    // User Defined texture: bubbles show the texture layer (green).
+    let tex = with(&[("rendering/bubbleTexture", Value::Enum(5)), ("rendering/bubbleTextureLayer", Value::Layer(Some(2)))], 1.0);
+    assert!(tex.data.iter().any(|p| p[1] > 0.5 && p[0] < 0.1));
+    // Environment map: reflections tint the bubbles.
+    let refl = with(&[("rendering/environmentMap", Value::Layer(Some(2))), ("rendering/reflectionStrength", num(1.0))], 1.0);
+    let g = |i: &Image| i.data.iter().map(|p| p[1] - p[0]).sum::<f32>();
+    assert!(g(&refl) > g(&still) + 1.0);
+    // Zoom Producer Point zooms about the producer instead of the layer centre.
+    let off = [("producer/producerPoint", pt(8.0, 8.0)), ("zoom", num(2.0))];
+    let z1 = with(&off, 1.0);
+    let z2 = with(&[off.as_slice(), &[("producer/zoomProducerPoint", Value::Bool(true))]].concat(), 1.0);
+    assert!((cx(&z2) - 8.0).abs() < 2.0 && cx(&z1) < 4.0, "{} vs {}", cx(&z2), cx(&z1));
+}
diff --git a/crates/effects/src/sim3.rs b/crates/effects/src/sim3.rs
index 35c758faa..88a16d981 100644
--- a/crates/effects/src/sim3.rs
+++ b/crates/effects/src/sim3.rs
@@ -575,7 +575,8 @@ fn mapper_from(ctx: &EffectCtx, group: &str, ephemeral: bool) -> Option<Mapper>
 
 /// Draw a map layer frame as a particle: centred on (x, y) buffer px, rotated `angle` degrees
 /// and scaled, over `out`.
-fn blit_layer(out: &mut Image, lp: &crate::LayerPixels, x: f64, y: f64, angle: f64, scale: [f64; 2], buf_scale: f64, alpha: f32) {
+fn blit_layer(out: &mut Image, lp: &crate::LayerPixels, position: [f64; 2], angle: f64, scale: [f64; 2], buf_scale: f64, alpha: f32) {
+    let [x, y] = position;
     let (w, h) = (lp.size[0] * scale[0].abs() * buf_scale, lp.size[1] * scale[1].abs() * buf_scale);
     let r = (w * w + h * h).sqrt() * 0.5 + 1.0;
     let (x0, x1) = ((x - r).floor().max(0.0) as i64, (x + r).ceil().min(out.width as f64) as i64);
@@ -925,7 +926,7 @@ impl PgPlan {
     pub fn finish(&self, mut b: Buf) -> Buf {
         let mut fx = splat(b.img.width, b.img.height, &self.sprites.sprites, self.sprites.acc);
         for q in &self.blits {
-            blit_layer(&mut fx, &self.frames[q.frame], q.x, q.y, q.angle, q.scale, b.scale, q.alpha);
+            blit_layer(&mut fx, &self.frames[q.frame], [q.x, q.y], q.angle, q.scale, b.scale, q.alpha);
         }
         // Particles replace the layer's own pixels.
         b.img = combine(&b.img, &fx, 5);
@@ -1176,379 +1177,4 @@ pub fn specs() -> Vec<EffectSpec> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{EffectEnv, MaskShape, run_fx};
-
-    fn run(vals: &[(&str, Value)], t: f64) -> Image {
-        run_fx("ec.sim.particleplayground", vals, Image::filled(80, 60, [0.2, 0.2, 0.2, 1.0]), t, EffectEnv::default()).img
-    }
-
-    fn cannon(t: f64) -> Image {
-        run(&[("cannon/cannonPosition", Value::Vec2([40.0, 50.0])), ("cannon/velocity", num(60.0)), ("gravity/gravityForce", num(30.0))], t)
-    }
-
-    #[test]
-    fn cannon_stream_is_seek_consistent() {
-        let a = cannon(1.0);
-        // Particles replace the layer: some coverage, mostly transparent, red.
-        let cov: f32 = a.data.iter().map(|p| p[3]).sum();
-        assert!(cov > 5.0, "{cov}");
-        assert!(a.data.iter().any(|p| p[3] > 0.5 && p[0] > 0.5 && p[1] < 0.1));
-        // Seek back and forth: the same frame every time.
-        let _ = cannon(2.0);
-        let b = cannon(1.0);
-        assert_eq!(a.data, b.data);
-        let c = cannon(0.5);
-        assert_ne!(a.data, c.data);
-        // Nothing has been fired at time 0.
-        let z = cannon(0.0);
-        assert!(z.data.iter().all(|p| p[3] == 0.0));
-    }
-
-    #[test]
-    fn grid_falls_with_gravity_and_bounces_off_a_wall() {
-        let grid = |t: f64, env: EffectEnv| {
-            run_fx(
-                "ec.sim.particleplayground",
-                &[
-                    ("cannonEnabled", Value::Bool(false)),
-                    ("grid/gridPosition", Value::Vec2([40.0, 10.0])),
-                    ("grid/gridWidth", num(40.0)),
-                    ("grid/gridHeight", num(0.0)),
-                    ("grid/particlesAcross", num(5.0)),
-                    ("grid/particlesDown", num(1.0)),
-                    ("gravity/gravityForce", num(100.0)),
-                    ("wall/wallBoundary", num(1.0)),
-                ],
-                Image::new(80, 60),
-                t,
-                env,
-            )
-            .img
-        };
-        // Alpha-weighted mean height of the particles.
-        let row_of = |img: &Image| {
-            let (mut s, mut n) = (0.0f64, 0.0f64);
-            for y in 0..60 {
-                for x in 0..80 {
-                    let a = img.get(x, y)[3] as f64;
-                    s += (y as f64 + 0.5) * a;
-                    n += a;
-                }
-            }
-            (s / n.max(1e-9)).round() as i64
-        };
-        let t0 = grid(0.0, EffectEnv::default());
-        let t1 = grid(0.5, EffectEnv::default());
-        assert_eq!(row_of(&t0), 10);
-        // ½ g t² = 12.5 px.
-        assert!((row_of(&t1) - 22).abs() <= 2, "{}", row_of(&t1));
-        // A wall (mask 1) whose floor is at y = 15 keeps them above it.
-        let masks = [MaskShape { name: "w".into(), points: vec![[0.0, 0.0], [80.0, 0.0], [80.0, 15.0], [0.0, 15.0]], closed: true, inverted: false }];
-        let env = EffectEnv { masks: &masks, ..Default::default() };
-        let w = grid(1.5, env);
-        assert!(row_of(&w) <= 16, "{}", row_of(&w));
-    }
-
-    #[test]
-    fn repel_spreads_particles() {
-        let spread = |force: f64| {
-            let img = run(
-                &[
-                    ("cannonEnabled", Value::Bool(false)),
-                    ("grid/gridPosition", Value::Vec2([40.0, 30.0])),
-                    ("grid/gridWidth", num(6.0)),
-                    ("grid/gridHeight", num(6.0)),
-                    ("grid/particlesAcross", num(3.0)),
-                    ("grid/particlesDown", num(3.0)),
-                    ("gravity/gravityForce", num(0.0)),
-                    ("repel/repelForce", num(force)),
-                    ("repel/repelForceRadius", num(20.0)),
-                ],
-                0.5,
-            );
-            let (mut x0, mut x1) = (80, 0);
-            for y in 0..60 {
-                for x in 0..80 {
-                    if img.get(x, y)[3] > 0.3 {
-                        x0 = x0.min(x);
-                        x1 = x1.max(x);
-                    }
-                }
-            }
-            x1 - x0
-        };
-        assert!(spread(0.2) > spread(0.0) + 4, "{} vs {}", spread(0.2), spread(0.0));
-    }
-
-    #[test]
-    fn property_mapper_and_layer_map_read_layers() {
-        // Without a host, the layer-based features are inert (deterministic output).
-        let a = run(
-            &[
-                ("persistentPropertyMapper/mapRedTo", Value::Enum(8)),
-                ("persistentPropertyMapper/redMin", num(-50.0)),
-                ("persistentPropertyMapper/redMax", num(50.0)),
-            ],
-            0.7,
-        );
-        let b = run(
-            &[
-                ("persistentPropertyMapper/mapRedTo", Value::Enum(8)),
-                ("persistentPropertyMapper/redMin", num(-50.0)),
-                ("persistentPropertyMapper/redMax", num(50.0)),
-            ],
-            0.7,
-        );
-        assert_eq!(a.data, b.data);
-        let st =
-            Pg { persistent: Some(mapper(Image::filled(4, 4, [1.0, 0.0, 0.5, 1.0]), [(15, 0, 0.0, 120.0), (0, 0, 0.0, 1.0), (9, 0, 0.0, 2.0)])), ..bare(1) };
-        let mut s = PgState::default();
-        s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
-        st.step(&mut s);
-        // Red 1 → X speed 120 px/s; blue 0.5 → scale 1.
-        assert!((s.parts[0].v[0] - 120.0).abs() < 1e-3);
-        assert!((s.parts[0].scale[0] - 1.0).abs() < 1e-3);
-    }
-
-    /// A Pg with nothing switched on.
-    fn bare(seed: u32) -> Pg {
-        Pg {
-            cannon: false,
-            pos: [0.0; 2],
-            barrel_angle: 0.0,
-            barrel_radius: 0.0,
-            rate: 0.0,
-            dir_spread: 0.0,
-            vel: 0.0,
-            vel_spread: 0.0,
-            color: [1.0; 4],
-            radius: 2.0,
-            cannon_text: vec![],
-            pex_radius: 0.0,
-            pex_dispersion: 0.0,
-            pex_affects: Affects::default(),
-            gravity: [0.0; 2],
-            grav_spread: 0.0,
-            grav_affects: Affects::default(),
-            repel: 0.0,
-            repel_radius: 0.0,
-            repel_affects: Affects::default(),
-            wall: None,
-            wall_affects: Affects::default(),
-            persistent: None,
-            ephemeral: None,
-            seed,
-            bounds: [-1e6, -1e6, 1e6, 1e6],
-        }
-    }
-
-    fn mapper(img: Image, chans: [(u32, u32, f32, f32); 3]) -> Mapper {
-        Mapper { map: MapImg { img, k: [1.0; 2], o: [0.0; 2] }, chans, affects: Affects::default() }
-    }
-
-    #[test]
-    fn barrel_radius_square_or_disc() {
-        let pg = |r: f32| Pg { cannon: true, barrel_radius: r, ..bare(3) };
-        let (sq, disc) = (pg(10.0), pg(-10.0));
-        let mut corner = false;
-        for id in 0..400 {
-            let a = sq.spawn(id).p;
-            assert!(a[0].abs() <= 10.0 && a[1].abs() <= 10.0);
-            // A square barrel fills its corners (both offsets in use, not a line).
-            corner |= a[0].abs() > 7.5 && a[1].abs() > 7.5;
-            let b = disc.spawn(id).p;
-            assert!(b[0].hypot(b[1]) <= 10.0 + 1e-4);
-        }
-        assert!(corner);
-        // Radius 0: every particle starts at the cannon position.
-        assert_eq!(pg(0.0).spawn(5).p, [0.0, 0.0]);
-    }
-
-    #[test]
-    fn mapper_drives_position_and_opacity_in_ae_order() {
-        let st =
-            Pg { persistent: Some(mapper(Image::filled(4, 4, [1.0, 0.5, 0.25, 1.0]), [(12, 0, 0.0, 30.0), (20, 0, 0.0, 1.0), (4, 0, 0.0, 1.0)])), ..bare(1) };
-        assert_eq!(MAP_TARGETS[12], "X");
-        assert_eq!(MAP_TARGETS[20], "Opacity");
-        assert_eq!(MAP_TARGETS[26], "Scale Speed");
-        let mut s = PgState::default();
-        s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
-        st.step(&mut s);
-        assert!((s.parts[0].p[0] - 30.0).abs() < 1e-3, "{:?}", s.parts[0].p);
-        assert!((s.parts[0].c[3] - 0.5).abs() < 1e-3);
-        assert!((s.parts[0].friction - 0.25).abs() < 1e-3);
-    }
-
-    #[test]
-    fn ephemeral_mapper_holds_for_one_step_with_operators() {
-        // Ephemeral X Speed = 60 px/s (Set): the particle moves, but keeps no velocity.
-        let st = Pg { ephemeral: Some(mapper(Image::filled(4, 4, [1.0, 1.0, 1.0, 1.0]), [(15, 0, 0.0, 60.0), (0, 0, 0.0, 1.0), (0, 0, 0.0, 1.0)])), ..bare(1) };
-        let mut s = PgState::default();
-        s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
-        st.step(&mut s);
-        assert!((s.parts[0].p[0] - 2.0).abs() < 1e-4, "{:?}", s.parts[0].p);
-        assert!(s.parts[0].v[0].abs() < 1e-4);
-        // Operators: Add / Multiply / Max on the particle's own value.
-        let op = |o: u32, cur: f32| {
-            let m = mapper(Image::filled(4, 4, [1.0, 1.0, 1.0, 1.0]), [(21, o, 0.0, 3.0), (0, 0, 0.0, 1.0), (0, 0, 0.0, 1.0)]);
-            let mut q = PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID);
-            q.mass = cur;
-            m.apply(&mut q);
-            q.mass
-        };
-        assert_eq!(MAP_OPERATORS[1], "Add");
-        assert!((op(1, 2.0) - 5.0).abs() < 1e-5);
-        assert!((op(4, 2.0) - 6.0).abs() < 1e-5);
-        assert!((op(6, 5.0) - 5.0).abs() < 1e-5);
-        assert!((op(2, 5.0) - 2.0).abs() < 1e-5, "Difference");
-    }
-
-    #[test]
-    fn affects_select_by_source_age_and_characters() {
-        let mut q = PgParticle::new([0.0; 2], [0.0; 2], [1.0; 4], 2.0, 0, SRC_CANNON);
-        let a = Affects { from: 2, ..Default::default() };
-        assert_eq!(a.weight(&q), 0.0, "grid only");
-        q.src = SRC_GRID;
-        assert_eq!(a.weight(&q), 1.0);
-        let older = Affects { age: 1.0, ..Default::default() };
-        q.age = 0.5;
-        assert_eq!(older.weight(&q), 0.0);
-        q.age = 1.5;
-        assert_eq!(older.weight(&q), 1.0);
-        let younger = Affects { age: -1.0, feather: 1.0, ..Default::default() };
-        q.age = 1.0;
-        assert!((younger.weight(&q) - 0.5).abs() < 1e-5, "feathered");
-        let chars = Affects { chars: vec!['A', 'B'], ..Default::default() };
-        q.ch = 'B' as u32;
-        assert_eq!(chars.weight(&q), 1.0);
-        q.ch = 'C' as u32;
-        assert_eq!(chars.weight(&q), 0.0);
-        // Gravity restricted to the cannon leaves grid particles in place.
-        let st = Pg { gravity: [0.0, 100.0], grav_affects: Affects { from: 1, ..Default::default() }, ..bare(1) };
-        let mut s = PgState::default();
-        s.parts.push(PgParticle::new([5.0, 5.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
-        s.parts.push(PgParticle::new([5.0, 5.0], [0.0; 2], [1.0; 4], 2.0, 1, SRC_CANNON));
-        for _ in 0..10 {
-            st.step(&mut s);
-        }
-        assert_eq!(s.parts[0].p, [5.0, 5.0]);
-        assert!(s.parts[1].p[1] > 5.0);
-    }
-
-    #[test]
-    fn particle_exploder_bursts_big_particles() {
-        let st = Pg { pex_radius: 2.0, pex_dispersion: 30.0, ..bare(1) };
-        let mut s = PgState::default();
-        s.parts.push(PgParticle::new([50.0, 50.0], [0.0; 2], [1.0; 4], 6.0, 0, SRC_GRID));
-        s.next_id = 1;
-        st.step(&mut s);
-        assert_eq!(s.parts.len(), 9, "(6/2)² new particles");
-        assert!(s.parts.iter().all(|q| q.r == 2.0 && q.src == SRC_PARTICLE_EXPLODER));
-        st.step(&mut s);
-        assert_eq!(s.parts.len(), 9, "new particles do not burst again");
-        // Lifespan from a mapper removes particles once they are older.
-        let life = Pg { persistent: Some(mapper(Image::filled(4, 4, [1.0; 4]), [(22, 0, 0.0, 0.05), (0, 0, 0.0, 1.0), (0, 0, 0.0, 1.0)])), ..bare(1) };
-        let mut s = PgState::default();
-        s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
-        for _ in 0..2 {
-            life.step(&mut s);
-        }
-        assert_eq!(s.parts.len(), 1);
-        for _ in 0..3 {
-            life.step(&mut s);
-        }
-        assert!(s.parts.is_empty());
-    }
-
-    #[test]
-    fn text_particles_draw_characters() {
-        let grid = |text: &str| {
-            run(
-                &[
-                    ("cannonEnabled", Value::Bool(false)),
-                    ("grid/gridPosition", Value::Vec2([40.0, 30.0])),
-                    ("grid/gridWidth", num(40.0)),
-                    ("grid/gridHeight", num(0.0)),
-                    ("grid/particlesAcross", num(3.0)),
-                    ("grid/particlesDown", num(1.0)),
-                    ("grid/gridParticleRadius", num(16.0)),
-                    ("gravity/gravityForce", num(0.0)),
-                    ("options/gridText", Value::Str(text.into())),
-                ],
-                0.1,
-            )
-        };
-        let dots = grid("");
-        let text = grid("I-O");
-        assert_ne!(dots.data, text.data);
-        // "I" is a vertical bar: ink above and below the grid point, not a round dot.
-        assert!(text.get(20, 26)[3] > 0.3 && text.get(20, 34)[3] > 0.3, "{:?}", text.get(20, 26));
-        // A space leaves its grid point empty.
-        let gap = grid("I O");
-        assert!(gap.get(40, 30)[3] < 0.05);
-        // Cannon text: particles carry the characters in order.
-        let pg = Pg { cannon_text: vec!['A', 'B'], ..bare(1) };
-        assert_eq!(pg.spawn(0).ch, 'A' as u32);
-        assert_eq!(pg.spawn(3).ch, 'B' as u32);
-    }
-
-    #[test]
-    fn layer_map_shows_the_map_layer_at_its_time_offset() {
-        /// A 6×6 map layer whose colour encodes the comp time it was fetched at.
-        struct Clock;
-        impl crate::EffectHost for Clock {
-            fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
-                None
-            }
-            fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
-                None
-            }
-            fn layer_at(&self, _: u64, t: f64, _: bool) -> Option<crate::LayerPixels> {
-                let v = (t as f32 / 4.0).clamp(0.0, 1.0);
-                Some(crate::LayerPixels { buf: Buf { img: Image::filled(6, 6, [v, 0.0, 1.0 - v, 1.0]), offset: [0.0; 2], scale: 1.0 }, size: [6.0, 6.0] })
-            }
-        }
-        let render = |kind: u32, offset: f64| {
-            let vals = [
-                ("cannonEnabled", Value::Bool(false)),
-                ("grid/gridPosition", Value::Vec2([40.0, 30.0])),
-                ("grid/particlesAcross", num(1.0)),
-                ("grid/particlesDown", num(1.0)),
-                ("gravity/gravityForce", num(0.0)),
-                ("layerMap/layerMapLayer", Value::Layer(Some(9))),
-                ("layerMap/timeOffsetType", Value::Enum(kind)),
-                ("layerMap/timeOffset", num(offset)),
-            ];
-            let env = EffectEnv { host: Some(&Clock), comp_time: 1.0, frame_rate: 10.0, ..Default::default() };
-            run_fx("ec.sim.particleplayground", &vals, Image::filled(80, 60, [0.2, 0.2, 0.2, 1.0]), 1.0, env).img
-        };
-        // The particle is a 6×6 copy of the map layer.
-        let rel = render(0, 1.0);
-        assert!(rel.get(40, 30)[3] > 0.99 && rel.get(46, 30)[3] < 0.01);
-        assert!((rel.get(40, 30)[0] - 0.5).abs() < 1e-3, "relative: now + 1 s = 2 s");
-        let abs = render(1, 3.0);
-        assert!((abs.get(40, 30)[0] - 0.75).abs() < 1e-3, "absolute: 3 s");
-    }
-
-    #[test]
-    fn cc_hair_grows_from_opaque_pixels() {
-        let mut img = Image::new(60, 60);
-        for y in 20..40 {
-            for x in 20..40 {
-                img.set(x, y, [0.8, 0.6, 0.4, 1.0]);
-            }
-        }
-        let out = run_fx("ec.sim.cchair", &[("length", num(12.0)), ("density", num(300.0))], img.clone(), 0.0, EffectEnv::default());
-        // Hair reaches beyond the square (above it: hair leans up, then droops).
-        let outside: f32 = (0..60).flat_map(|x| (0..20).map(move |y| (x, y))).map(|(x, y)| out.img.get(x, y)[3]).sum();
-        assert!(outside > 1.0, "{outside}");
-        // Nothing grows from transparent areas far away.
-        assert_eq!(out.img.get(2, 58)[3], 0.0);
-        let again = run_fx("ec.sim.cchair", &[("length", num(12.0)), ("density", num(300.0))], img.clone(), 3.0, EffectEnv::default());
-        assert_eq!(out.img.data, again.img.data);
-        let none = run_fx("ec.sim.cchair", &[("length", num(0.0))], img.clone(), 0.0, EffectEnv::default());
-        assert_eq!(none.img.data, img.data);
-    }
-}
+mod tests;
diff --git a/crates/effects/src/sim3/tests.rs b/crates/effects/src/sim3/tests.rs
new file mode 100644
index 000000000..ffce0ae6d
--- /dev/null
+++ b/crates/effects/src/sim3/tests.rs
@@ -0,0 +1,372 @@
+use super::*;
+use crate::{EffectEnv, MaskShape, run_fx};
+
+fn run(vals: &[(&str, Value)], t: f64) -> Image {
+    run_fx("ec.sim.particleplayground", vals, Image::filled(80, 60, [0.2, 0.2, 0.2, 1.0]), t, EffectEnv::default()).img
+}
+
+fn cannon(t: f64) -> Image {
+    run(&[("cannon/cannonPosition", Value::Vec2([40.0, 50.0])), ("cannon/velocity", num(60.0)), ("gravity/gravityForce", num(30.0))], t)
+}
+
+#[test]
+fn cannon_stream_is_seek_consistent() {
+    let a = cannon(1.0);
+    // Particles replace the layer: some coverage, mostly transparent, red.
+    let cov: f32 = a.data.iter().map(|p| p[3]).sum();
+    assert!(cov > 5.0, "{cov}");
+    assert!(a.data.iter().any(|p| p[3] > 0.5 && p[0] > 0.5 && p[1] < 0.1));
+    // Seek back and forth: the same frame every time.
+    let _ = cannon(2.0);
+    let b = cannon(1.0);
+    assert_eq!(a.data, b.data);
+    let c = cannon(0.5);
+    assert_ne!(a.data, c.data);
+    // Nothing has been fired at time 0.
+    let z = cannon(0.0);
+    assert!(z.data.iter().all(|p| p[3] == 0.0));
+}
+
+#[test]
+fn grid_falls_with_gravity_and_bounces_off_a_wall() {
+    let grid = |t: f64, env: EffectEnv| {
+        run_fx(
+            "ec.sim.particleplayground",
+            &[
+                ("cannonEnabled", Value::Bool(false)),
+                ("grid/gridPosition", Value::Vec2([40.0, 10.0])),
+                ("grid/gridWidth", num(40.0)),
+                ("grid/gridHeight", num(0.0)),
+                ("grid/particlesAcross", num(5.0)),
+                ("grid/particlesDown", num(1.0)),
+                ("gravity/gravityForce", num(100.0)),
+                ("wall/wallBoundary", num(1.0)),
+            ],
+            Image::new(80, 60),
+            t,
+            env,
+        )
+        .img
+    };
+    // Alpha-weighted mean height of the particles.
+    let row_of = |img: &Image| {
+        let (mut s, mut n) = (0.0f64, 0.0f64);
+        for y in 0..60 {
+            for x in 0..80 {
+                let a = img.get(x, y)[3] as f64;
+                s += (y as f64 + 0.5) * a;
+                n += a;
+            }
+        }
+        (s / n.max(1e-9)).round() as i64
+    };
+    let t0 = grid(0.0, EffectEnv::default());
+    let t1 = grid(0.5, EffectEnv::default());
+    assert_eq!(row_of(&t0), 10);
+    // ½ g t² = 12.5 px.
+    assert!((row_of(&t1) - 22).abs() <= 2, "{}", row_of(&t1));
+    // A wall (mask 1) whose floor is at y = 15 keeps them above it.
+    let masks = [MaskShape { name: "w".into(), points: vec![[0.0, 0.0], [80.0, 0.0], [80.0, 15.0], [0.0, 15.0]], closed: true, inverted: false }];
+    let env = EffectEnv { masks: &masks, ..Default::default() };
+    let w = grid(1.5, env);
+    assert!(row_of(&w) <= 16, "{}", row_of(&w));
+}
+
+#[test]
+fn repel_spreads_particles() {
+    let spread = |force: f64| {
+        let img = run(
+            &[
+                ("cannonEnabled", Value::Bool(false)),
+                ("grid/gridPosition", Value::Vec2([40.0, 30.0])),
+                ("grid/gridWidth", num(6.0)),
+                ("grid/gridHeight", num(6.0)),
+                ("grid/particlesAcross", num(3.0)),
+                ("grid/particlesDown", num(3.0)),
+                ("gravity/gravityForce", num(0.0)),
+                ("repel/repelForce", num(force)),
+                ("repel/repelForceRadius", num(20.0)),
+            ],
+            0.5,
+        );
+        let (mut x0, mut x1) = (80, 0);
+        for y in 0..60 {
+            for x in 0..80 {
+                if img.get(x, y)[3] > 0.3 {
+                    x0 = x0.min(x);
+                    x1 = x1.max(x);
+                }
+            }
+        }
+        x1 - x0
+    };
+    assert!(spread(0.2) > spread(0.0) + 4, "{} vs {}", spread(0.2), spread(0.0));
+}
+
+#[test]
+fn property_mapper_and_layer_map_read_layers() {
+    // Without a host, the layer-based features are inert (deterministic output).
+    let a = run(
+        &[
+            ("persistentPropertyMapper/mapRedTo", Value::Enum(8)),
+            ("persistentPropertyMapper/redMin", num(-50.0)),
+            ("persistentPropertyMapper/redMax", num(50.0)),
+        ],
+        0.7,
+    );
+    let b = run(
+        &[
+            ("persistentPropertyMapper/mapRedTo", Value::Enum(8)),
+            ("persistentPropertyMapper/redMin", num(-50.0)),
+            ("persistentPropertyMapper/redMax", num(50.0)),
+        ],
+        0.7,
+    );
+    assert_eq!(a.data, b.data);
+    let st = Pg { persistent: Some(mapper(Image::filled(4, 4, [1.0, 0.0, 0.5, 1.0]), [(15, 0, 0.0, 120.0), (0, 0, 0.0, 1.0), (9, 0, 0.0, 2.0)])), ..bare(1) };
+    let mut s = PgState::default();
+    s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
+    st.step(&mut s);
+    // Red 1 → X speed 120 px/s; blue 0.5 → scale 1.
+    assert!((s.parts[0].v[0] - 120.0).abs() < 1e-3);
+    assert!((s.parts[0].scale[0] - 1.0).abs() < 1e-3);
+}
+
+/// A Pg with nothing switched on.
+fn bare(seed: u32) -> Pg {
+    Pg {
+        cannon: false,
+        pos: [0.0; 2],
+        barrel_angle: 0.0,
+        barrel_radius: 0.0,
+        rate: 0.0,
+        dir_spread: 0.0,
+        vel: 0.0,
+        vel_spread: 0.0,
+        color: [1.0; 4],
+        radius: 2.0,
+        cannon_text: vec![],
+        pex_radius: 0.0,
+        pex_dispersion: 0.0,
+        pex_affects: Affects::default(),
+        gravity: [0.0; 2],
+        grav_spread: 0.0,
+        grav_affects: Affects::default(),
+        repel: 0.0,
+        repel_radius: 0.0,
+        repel_affects: Affects::default(),
+        wall: None,
+        wall_affects: Affects::default(),
+        persistent: None,
+        ephemeral: None,
+        seed,
+        bounds: [-1e6, -1e6, 1e6, 1e6],
+    }
+}
+
+fn mapper(img: Image, chans: [(u32, u32, f32, f32); 3]) -> Mapper {
+    Mapper { map: MapImg { img, k: [1.0; 2], o: [0.0; 2] }, chans, affects: Affects::default() }
+}
+
+#[test]
+fn barrel_radius_square_or_disc() {
+    let pg = |r: f32| Pg { cannon: true, barrel_radius: r, ..bare(3) };
+    let (sq, disc) = (pg(10.0), pg(-10.0));
+    let mut corner = false;
+    for id in 0..400 {
+        let a = sq.spawn(id).p;
+        assert!(a[0].abs() <= 10.0 && a[1].abs() <= 10.0);
+        // A square barrel fills its corners (both offsets in use, not a line).
+        corner |= a[0].abs() > 7.5 && a[1].abs() > 7.5;
+        let b = disc.spawn(id).p;
+        assert!(b[0].hypot(b[1]) <= 10.0 + 1e-4);
+    }
+    assert!(corner);
+    // Radius 0: every particle starts at the cannon position.
+    assert_eq!(pg(0.0).spawn(5).p, [0.0, 0.0]);
+}
+
+#[test]
+fn mapper_drives_position_and_opacity_in_ae_order() {
+    let st = Pg { persistent: Some(mapper(Image::filled(4, 4, [1.0, 0.5, 0.25, 1.0]), [(12, 0, 0.0, 30.0), (20, 0, 0.0, 1.0), (4, 0, 0.0, 1.0)])), ..bare(1) };
+    assert_eq!(MAP_TARGETS[12], "X");
+    assert_eq!(MAP_TARGETS[20], "Opacity");
+    assert_eq!(MAP_TARGETS[26], "Scale Speed");
+    let mut s = PgState::default();
+    s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
+    st.step(&mut s);
+    assert!((s.parts[0].p[0] - 30.0).abs() < 1e-3, "{:?}", s.parts[0].p);
+    assert!((s.parts[0].c[3] - 0.5).abs() < 1e-3);
+    assert!((s.parts[0].friction - 0.25).abs() < 1e-3);
+}
+
+#[test]
+fn ephemeral_mapper_holds_for_one_step_with_operators() {
+    // Ephemeral X Speed = 60 px/s (Set): the particle moves, but keeps no velocity.
+    let st = Pg { ephemeral: Some(mapper(Image::filled(4, 4, [1.0, 1.0, 1.0, 1.0]), [(15, 0, 0.0, 60.0), (0, 0, 0.0, 1.0), (0, 0, 0.0, 1.0)])), ..bare(1) };
+    let mut s = PgState::default();
+    s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
+    st.step(&mut s);
+    assert!((s.parts[0].p[0] - 2.0).abs() < 1e-4, "{:?}", s.parts[0].p);
+    assert!(s.parts[0].v[0].abs() < 1e-4);
+    // Operators: Add / Multiply / Max on the particle's own value.
+    let op = |o: u32, cur: f32| {
+        let m = mapper(Image::filled(4, 4, [1.0, 1.0, 1.0, 1.0]), [(21, o, 0.0, 3.0), (0, 0, 0.0, 1.0), (0, 0, 0.0, 1.0)]);
+        let mut q = PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID);
+        q.mass = cur;
+        m.apply(&mut q);
+        q.mass
+    };
+    assert_eq!(MAP_OPERATORS[1], "Add");
+    assert!((op(1, 2.0) - 5.0).abs() < 1e-5);
+    assert!((op(4, 2.0) - 6.0).abs() < 1e-5);
+    assert!((op(6, 5.0) - 5.0).abs() < 1e-5);
+    assert!((op(2, 5.0) - 2.0).abs() < 1e-5, "Difference");
+}
+
+#[test]
+fn affects_select_by_source_age_and_characters() {
+    let mut q = PgParticle::new([0.0; 2], [0.0; 2], [1.0; 4], 2.0, 0, SRC_CANNON);
+    let a = Affects { from: 2, ..Default::default() };
+    assert_eq!(a.weight(&q), 0.0, "grid only");
+    q.src = SRC_GRID;
+    assert_eq!(a.weight(&q), 1.0);
+    let older = Affects { age: 1.0, ..Default::default() };
+    q.age = 0.5;
+    assert_eq!(older.weight(&q), 0.0);
+    q.age = 1.5;
+    assert_eq!(older.weight(&q), 1.0);
+    let younger = Affects { age: -1.0, feather: 1.0, ..Default::default() };
+    q.age = 1.0;
+    assert!((younger.weight(&q) - 0.5).abs() < 1e-5, "feathered");
+    let chars = Affects { chars: vec!['A', 'B'], ..Default::default() };
+    q.ch = 'B' as u32;
+    assert_eq!(chars.weight(&q), 1.0);
+    q.ch = 'C' as u32;
+    assert_eq!(chars.weight(&q), 0.0);
+    // Gravity restricted to the cannon leaves grid particles in place.
+    let st = Pg { gravity: [0.0, 100.0], grav_affects: Affects { from: 1, ..Default::default() }, ..bare(1) };
+    let mut s = PgState::default();
+    s.parts.push(PgParticle::new([5.0, 5.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
+    s.parts.push(PgParticle::new([5.0, 5.0], [0.0; 2], [1.0; 4], 2.0, 1, SRC_CANNON));
+    for _ in 0..10 {
+        st.step(&mut s);
+    }
+    assert_eq!(s.parts[0].p, [5.0, 5.0]);
+    assert!(s.parts[1].p[1] > 5.0);
+}
+
+#[test]
+fn particle_exploder_bursts_big_particles() {
+    let st = Pg { pex_radius: 2.0, pex_dispersion: 30.0, ..bare(1) };
+    let mut s = PgState::default();
+    s.parts.push(PgParticle::new([50.0, 50.0], [0.0; 2], [1.0; 4], 6.0, 0, SRC_GRID));
+    s.next_id = 1;
+    st.step(&mut s);
+    assert_eq!(s.parts.len(), 9, "(6/2)² new particles");
+    assert!(s.parts.iter().all(|q| q.r == 2.0 && q.src == SRC_PARTICLE_EXPLODER));
+    st.step(&mut s);
+    assert_eq!(s.parts.len(), 9, "new particles do not burst again");
+    // Lifespan from a mapper removes particles once they are older.
+    let life = Pg { persistent: Some(mapper(Image::filled(4, 4, [1.0; 4]), [(22, 0, 0.0, 0.05), (0, 0, 0.0, 1.0), (0, 0, 0.0, 1.0)])), ..bare(1) };
+    let mut s = PgState::default();
+    s.parts.push(PgParticle::new([1.0, 1.0], [0.0; 2], [1.0; 4], 2.0, 0, SRC_GRID));
+    for _ in 0..2 {
+        life.step(&mut s);
+    }
+    assert_eq!(s.parts.len(), 1);
+    for _ in 0..3 {
+        life.step(&mut s);
+    }
+    assert!(s.parts.is_empty());
+}
+
+#[test]
+fn text_particles_draw_characters() {
+    let grid = |text: &str| {
+        run(
+            &[
+                ("cannonEnabled", Value::Bool(false)),
+                ("grid/gridPosition", Value::Vec2([40.0, 30.0])),
+                ("grid/gridWidth", num(40.0)),
+                ("grid/gridHeight", num(0.0)),
+                ("grid/particlesAcross", num(3.0)),
+                ("grid/particlesDown", num(1.0)),
+                ("grid/gridParticleRadius", num(16.0)),
+                ("gravity/gravityForce", num(0.0)),
+                ("options/gridText", Value::Str(text.into())),
+            ],
+            0.1,
+        )
+    };
+    let dots = grid("");
+    let text = grid("I-O");
+    assert_ne!(dots.data, text.data);
+    // "I" is a vertical bar: ink above and below the grid point, not a round dot.
+    assert!(text.get(20, 26)[3] > 0.3 && text.get(20, 34)[3] > 0.3, "{:?}", text.get(20, 26));
+    // A space leaves its grid point empty.
+    let gap = grid("I O");
+    assert!(gap.get(40, 30)[3] < 0.05);
+    // Cannon text: particles carry the characters in order.
+    let pg = Pg { cannon_text: vec!['A', 'B'], ..bare(1) };
+    assert_eq!(pg.spawn(0).ch, 'A' as u32);
+    assert_eq!(pg.spawn(3).ch, 'B' as u32);
+}
+
+#[test]
+fn layer_map_shows_the_map_layer_at_its_time_offset() {
+    /// A 6×6 map layer whose colour encodes the comp time it was fetched at.
+    struct Clock;
+    impl crate::EffectHost for Clock {
+        fn layer(&self, _: u64, _: bool) -> Option<crate::LayerPixels> {
+            None
+        }
+        fn audio(&self, _: u64, _: f64, _: usize, _: u32) -> Option<Vec<f32>> {
+            None
+        }
+        fn layer_at(&self, _: u64, t: f64, _: bool) -> Option<crate::LayerPixels> {
+            let v = (t as f32 / 4.0).clamp(0.0, 1.0);
+            Some(crate::LayerPixels { buf: Buf { img: Image::filled(6, 6, [v, 0.0, 1.0 - v, 1.0]), offset: [0.0; 2], scale: 1.0 }, size: [6.0, 6.0] })
+        }
+    }
+    let render = |kind: u32, offset: f64| {
+        let vals = [
+            ("cannonEnabled", Value::Bool(false)),
+            ("grid/gridPosition", Value::Vec2([40.0, 30.0])),
+            ("grid/particlesAcross", num(1.0)),
+            ("grid/particlesDown", num(1.0)),
+            ("gravity/gravityForce", num(0.0)),
+            ("layerMap/layerMapLayer", Value::Layer(Some(9))),
+            ("layerMap/timeOffsetType", Value::Enum(kind)),
+            ("layerMap/timeOffset", num(offset)),
+        ];
+        let env = EffectEnv { host: Some(&Clock), comp_time: 1.0, frame_rate: 10.0, ..Default::default() };
+        run_fx("ec.sim.particleplayground", &vals, Image::filled(80, 60, [0.2, 0.2, 0.2, 1.0]), 1.0, env).img
+    };
+    // The particle is a 6×6 copy of the map layer.
+    let rel = render(0, 1.0);
+    assert!(rel.get(40, 30)[3] > 0.99 && rel.get(46, 30)[3] < 0.01);
+    assert!((rel.get(40, 30)[0] - 0.5).abs() < 1e-3, "relative: now + 1 s = 2 s");
+    let abs = render(1, 3.0);
+    assert!((abs.get(40, 30)[0] - 0.75).abs() < 1e-3, "absolute: 3 s");
+}
+
+#[test]
+fn cc_hair_grows_from_opaque_pixels() {
+    let mut img = Image::new(60, 60);
+    for y in 20..40 {
+        for x in 20..40 {
+            img.set(x, y, [0.8, 0.6, 0.4, 1.0]);
+        }
+    }
+    let out = run_fx("ec.sim.cchair", &[("length", num(12.0)), ("density", num(300.0))], img.clone(), 0.0, EffectEnv::default());
+    // Hair reaches beyond the square (above it: hair leans up, then droops).
+    let outside: f32 = (0..60).flat_map(|x| (0..20).map(move |y| (x, y))).map(|(x, y)| out.img.get(x, y)[3]).sum();
+    assert!(outside > 1.0, "{outside}");
+    // Nothing grows from transparent areas far away.
+    assert_eq!(out.img.get(2, 58)[3], 0.0);
+    let again = run_fx("ec.sim.cchair", &[("length", num(12.0)), ("density", num(300.0))], img.clone(), 3.0, EffectEnv::default());
+    assert_eq!(out.img.data, again.img.data);
+    let none = run_fx("ec.sim.cchair", &[("length", num(0.0))], img.clone(), 0.0, EffectEnv::default());
+    assert_eq!(none.img.data, img.data);
+}
diff --git a/crates/effects/src/stylize3.rs b/crates/effects/src/stylize3.rs
index 403c325cd..e28f9a4fa 100644
--- a/crates/effects/src/stylize3.rs
+++ b/crates/effects/src/stylize3.rs
@@ -351,7 +351,7 @@ fn hex_cell(x: f64, y: f64, r: f64) -> ((f64, f64), (i64, i64)) {
     let rr = (2.0 / 3.0 * y) / r;
     // Cube rounding.
     let (cx, cz) = (q, rr);
-    let cy = -cx - cz;
+    let cy = (-3f64.sqrt() / 3.0 * x - y / 3.0) / r;
     let (mut rx, ry, mut rz) = (cx.round(), cy.round(), cz.round());
     let (dx, dy, dz) = ((rx - cx).abs(), (ry - cy).abs(), (rz - cz).abs());
     if dx > dy && dx > dz {
diff --git a/crates/effects/src/util.rs b/crates/effects/src/util.rs
index ae55d095d..9c81dab10 100644
--- a/crates/effects/src/util.rs
+++ b/crates/effects/src/util.rs
@@ -6,6 +6,10 @@ use effectcraft_color::{luminance, rgb_to_hsl};
 use effectcraft_raster::{Image, Px};
 use rayon::prelude::*;
 
+/// Below this many pixels, `Plane::transpose` and `Plane::map_rows` run on the calling thread:
+/// the rayon dispatch costs more than the work on small crops (the Match Grain sample boxes).
+const PAR_MIN: usize = 4096;
+
 /// A single-channel `f32` image (row-major).
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct Plane {
@@ -62,6 +66,15 @@ impl Plane {
     pub fn transpose(&self) -> Plane {
         let (w, h) = (self.w, self.h);
         let mut out = Plane::new(h, w);
+        if w.saturating_mul(h) < PAR_MIN {
+            // Small planes: the rayon dispatch costs more than the copy itself.
+            for (x, col) in out.data.chunks_mut(h.max(1)).enumerate() {
+                for y in 0..h {
+                    col[y] = self.data[y * w + x];
+                }
+            }
+            return out;
+        }
         out.data.par_chunks_mut(h.max(1)).enumerate().for_each(|(x, col)| {
             for y in 0..h {
                 col[y] = self.data[y * w + x];
@@ -75,6 +88,11 @@ impl Plane {
         if self.w == 0 {
             return out;
         }
+        if self.w.saturating_mul(self.h) < PAR_MIN {
+            // Small planes: the rayon dispatch costs more than the rows themselves.
+            out.data.chunks_mut(self.w).zip(self.data.chunks(self.w)).for_each(|(o, s)| f(s, o));
+            return out;
+        }
         out.data.par_chunks_mut(self.w).zip(self.data.par_chunks(self.w)).for_each(|(o, s)| f(s, o));
         out
     }
@@ -534,14 +552,29 @@ impl<S: Clone> SimCache<S> {
 
     /// State after `target` steps. `init` builds step 0; `step(state, i)` advances from step
     /// `i` to `i + 1`.
-    pub fn run(&self, key: u64, target: u64, init: impl FnOnce() -> S, mut step: impl FnMut(&mut S, u64)) -> std::sync::Arc<S> {
+    pub fn run(&self, key: u64, target: u64, init: impl FnOnce() -> S, step: impl FnMut(&mut S, u64)) -> std::sync::Arc<S> {
+        self.run_where(key, target, init, step, |_, _| true)
+    }
+
+    /// [`SimCache::run`] for a simulation whose steps also depend on inputs outside `key` (a
+    /// parameter's values over time): a checkpoint after `s` steps is only resumed from when
+    /// `valid(s, state)` says it was reached with the same inputs. Fresh checkpoints replace
+    /// those at the same step.
+    pub fn run_where(
+        &self,
+        key: u64,
+        target: u64,
+        init: impl FnOnce() -> S,
+        mut step: impl FnMut(&mut S, u64),
+        valid: impl Fn(u64, &S) -> bool,
+    ) -> std::sync::Arc<S> {
         use std::sync::Arc;
         let start = {
             let mut g = self.inner.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
             let tick = g.iter().map(|e| e.used).max().unwrap_or(0) + 1;
             g.iter_mut().find(|e| e.key == key).and_then(|e| {
                 e.used = tick;
-                e.checkpoints.iter().filter(|(s, _)| *s <= target).max_by_key(|(s, _)| *s).map(|(s, st)| (*s, st.clone()))
+                e.checkpoints.iter().filter(|(s, st)| *s <= target && valid(*s, st)).max_by_key(|(s, _)| *s).map(|(s, st)| (*s, st.clone()))
             })
         };
         let had_start = start.is_some();
@@ -579,9 +612,8 @@ impl<S: Clone> SimCache<S> {
         let e = &mut g[idx];
         e.used = tick;
         for (s, st) in fresh {
-            if !e.checkpoints.iter().any(|(c, _)| *c == s) {
-                e.checkpoints.push((s, st));
-            }
+            e.checkpoints.retain(|(c, _)| *c != s);
+            e.checkpoints.push((s, st));
         }
         // Keep memory bounded: drop unaligned (exact-target) checkpoints first, then thin.
         if e.checkpoints.len() > 256 {
diff --git a/crates/effects/src/utility.rs b/crates/effects/src/utility.rs
index 1d3b3ee4a..e41b42e99 100644
--- a/crates/effects/src/utility.rs
+++ b/crates/effects/src/utility.rs
@@ -100,17 +100,11 @@ impl Cineon {
     fn knee(&self) -> f32 {
         1.0 - (self.rolloff / 100.0).clamp(0.0, 0.99)
     }
-    /// Normalised code value (code / 1023) → linear.
+    /// Normalized code value (code / 1023) → linear, raised to `1.7 / gamma`
+    /// ([`effectcraft_project::cineon_log_to_lin`], which Interpret Footage ▸ Cineon Settings
+    /// also uses with `1 / gamma`).
     pub fn log_to_lin(&self, v: f32) -> f32 {
-        let off = self.offset();
-        let code = v * 1023.0;
-        let mut lin = (10f32.powf((code - self.white) * 0.002 / 0.6) - off) / (1.0 - off).max(1e-6);
-        lin = lin.max(0.0).powf(1.7 / self.gamma.max(0.01));
-        let k = self.knee();
-        if k < 1.0 && lin > k {
-            let w = 1.0 - k;
-            lin = k + w * (1.0 - (-(lin - k) / w).exp());
-        }
+        let lin = effectcraft_project::cineon_log_to_lin(v, self.black, self.white, 1.7, self.gamma, self.rolloff);
         self.ib + (self.iw - self.ib) * lin
     }
     /// Linear → normalised code value.
@@ -495,6 +489,87 @@ mod tests {
         assert!(c.log_to_lin(95.0 / 1023.0).abs() < 1e-4);
     }
 
+    /// Interpret Footage ▸ Cineon Settings and the Cineon Converter's Log to Linear give the same
+    /// values for the same points and Highlight Rolloff when the converter's Gamma is 1.7 times
+    /// Cineon Settings' Gamma: the converter's default 1.7 and Cineon Settings' Gamma 1 both give
+    /// linear light (code 400 is 0.10251).
+    #[test]
+    fn cineon_converter_matches_interpret_footage() {
+        let codes = [0.0f32, 95.0, 250.0, 400.0, 560.0, 685.0, 800.0, 1023.0];
+        for (gamma, rolloff) in [(1.0, 20.0), (1.0, 0.0), (1.7, 50.0), (2.4, 50.0)] {
+            let mut img = Image::new(codes.len() as u32, 1);
+            for (x, code) in codes.iter().enumerate() {
+                let v = code / 1023.0;
+                img.set(x as u32, 0, [v, v, v, 1.0]);
+            }
+            let vals = [("conversionType", Value::Enum(1)), ("gamma", num(gamma * 1.7)), ("highlightRolloff", num(rolloff))];
+            let out = run("ec.utility.cineon", &vals, img);
+            let settings = effectcraft_project::CineonSettings { log_conversion: true, gamma: gamma as f32, rolloff: rolloff as f32, ..Default::default() };
+            for (x, code) in codes.iter().enumerate() {
+                let footage = settings.convert(code / 1023.0);
+                let effect = out.img.data[x][0];
+                assert!((footage - effect).abs() < 1e-6, "gamma {gamma}, rolloff {rolloff}, code {code}: {footage} vs {effect}");
+            }
+        }
+        let linear = effectcraft_project::CineonSettings { gamma: 1.0, rolloff: 0.0, ..Default::default() };
+        assert!((linear.convert(400.0 / 1023.0) - 0.10251).abs() < 1e-4);
+    }
+
+    /// The Cineon Converter gives the same values as before Cineon Settings shared its
+    /// log-to-linear function, at the default Gamma (1.7) and at Gamma 2.4, for all three
+    /// conversion types.
+    #[test]
+    fn cineon_converter_output_is_unchanged() {
+        fn log_to_lin(v: f32, gamma: f32, rolloff: f32, black: f32, white: f32) -> f32 {
+            let off = 10f32.powf((black - white) * 0.002 / 0.6);
+            let mut lin = (10f32.powf((v * 1023.0 - white) * 0.002 / 0.6) - off) / (1.0 - off).max(1e-6);
+            lin = lin.max(0.0).powf(1.7 / gamma.max(0.01));
+            let k = 1.0 - (rolloff / 100.0).clamp(0.0, 0.99);
+            if k < 1.0 && lin > k {
+                let w = 1.0 - k;
+                lin = k + w * (1.0 - (-(lin - k) / w).exp());
+            }
+            lin
+        }
+        fn lin_to_log(v: f32, gamma: f32, rolloff: f32, black: f32, white: f32) -> f32 {
+            let off = 10f32.powf((black - white) * 0.002 / 0.6);
+            let mut lin = v;
+            let k = 1.0 - (rolloff / 100.0).clamp(0.0, 0.99);
+            if k < 1.0 && lin > k {
+                let w = 1.0 - k;
+                lin = k - w * (1.0 - (lin - k) / w).max(1e-6).ln();
+            }
+            lin = lin.max(0.0).powf(gamma.max(0.01) / 1.7);
+            (white + (lin * (1.0 - off) + off).max(1e-9).log10() * 0.6 / 0.002) / 1023.0
+        }
+        let codes = [0.0f32, 95.0, 250.0, 400.0, 560.0, 685.0, 800.0, 1023.0];
+        for gamma in [None, Some(2.4)] {
+            for kind in 0..3 {
+                let mut img = Image::new(codes.len() as u32, 1);
+                for (x, code) in codes.iter().enumerate() {
+                    let v = code / 1023.0;
+                    img.set(x as u32, 0, [v, v, v, 1.0]);
+                }
+                let mut vals = vec![("conversionType", Value::Enum(kind))];
+                if let Some(g) = gamma {
+                    vals.push(("gamma", num(g)));
+                }
+                let out = run("ec.utility.cineon", &vals, img);
+                let g = gamma.unwrap_or(1.7) as f32;
+                for (x, code) in codes.iter().enumerate() {
+                    let v = code / 1023.0;
+                    let want = match kind {
+                        0 => lin_to_log(v, g, 20.0, 95.0, 685.0),
+                        1 => log_to_lin(v, g, 20.0, 95.0, 685.0),
+                        _ => lin_to_log(log_to_lin(v, g, 20.0, 95.0, 685.0), 1.7, 20.0, 95.0, 685.0),
+                    };
+                    let got = out.img.data[x][0];
+                    assert!((want - got).abs() < 1e-6, "gamma {g}, type {kind}, code {code}: {want} vs {got}");
+                }
+            }
+        }
+    }
+
     #[test]
     fn hdr_compression_behaviour() {
         let mut img = Image::new(2, 1);
diff --git a/crates/effects/src/warp_stab.rs b/crates/effects/src/warp_stab.rs
index f850bdcf3..8d9fe6f0e 100644
--- a/crates/effects/src/warp_stab.rs
+++ b/crates/effects/src/warp_stab.rs
@@ -152,15 +152,6 @@ pub fn settings(params: &Params, fps: f64) -> StabSettings {
     }
 }
 
-fn fnv(bytes: &[u8]) -> u64 {
-    let mut h: u64 = 0xcbf2_9ce4_8422_2325;
-    for b in bytes {
-        h ^= *b as u64;
-        h = h.wrapping_mul(0x0100_0000_01b3);
-    }
-    h
-}
-
 struct KeyHasher(u64);
 impl Hasher for KeyHasher {
     fn finish(&self) -> u64 {
@@ -183,24 +174,12 @@ fn settings_key(s: &StabSettings) -> u64 {
     h.finish()
 }
 
-type AnalysisCache = Mutex<HashMap<u64, Arc<WarpAnalysis>>>;
 type PlanCache = Mutex<HashMap<(u64, u64), Arc<Plan>>>;
 
-/// Parsed analyses by content hash (parsing a long clip's JSON every frame would dominate).
+/// Parsed analyses and their content keys; cache hits compare source text without rehashing.
 fn analysis_cached(json: &str) -> Option<(u64, Arc<WarpAnalysis>)> {
-    static C: OnceLock<AnalysisCache> = OnceLock::new();
-    let key = fnv(json.as_bytes());
-    let c = C.get_or_init(Default::default);
-    if let Some(a) = c.lock().unwrap_or_else(std::sync::PoisonError::into_inner).get(&key) {
-        return Some((key, a.clone()));
-    }
-    let a = Arc::new(WarpAnalysis::from_json(json)?);
-    let mut m = c.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
-    if m.len() > 8 {
-        m.clear();
-    }
-    m.insert(key, a.clone());
-    Some((key, a))
+    static C: crate::analysis_cache::AnalysisCache<WarpAnalysis> = crate::analysis_cache::AnalysisCache::new();
+    C.get(json, WarpAnalysis::from_json)
 }
 
 fn plans() -> &'static PlanCache {
@@ -223,6 +202,19 @@ fn plan_cached(akey: u64, a: &WarpAnalysis, s: &StabSettings) -> Arc<Plan> {
     p
 }
 
+/// Validate and cache the default stabilization plan after analysis. Use the serialized
+/// analysis so the cached plan has exactly the same inputs as the first render, including
+/// any floating-point round trip through JSON. Other settings still get their own plan.
+pub fn prepare_default_plan(json: &str) -> bool {
+    let Some((key, a)) = analysis_cached(json) else { return false };
+    if a.is_empty() {
+        return false;
+    }
+    let fps = if a.frame_duration > 0.0 { 1.0 / a.frame_duration } else { 30.0 };
+    let p = plan_cached(key, &a, &StabSettings { fps, ..Default::default() });
+    p.warps.len() == a.frames.len() && p.warps.iter().all(|h| h.0.iter().flatten().all(|v| v.is_finite()))
+}
+
 /// The stored analysis of an instance (`None` when not analysed).
 pub fn analysis(params: &Params) -> Option<Arc<WarpAnalysis>> {
     let j = s(params, ANALYSIS);
@@ -453,7 +445,7 @@ fn render(ctx: &EffectCtx, buf: Buf) -> Buf {
     });
     let need = need_m.into_inner().unwrap_or_else(std::sync::PoisonError::into_inner);
     if synth && need.iter().any(|w| *w > 0.0) {
-        synthesize(ctx, &a, k, &src_of, &crop, sc, &mut out, &need);
+        synthesize(ctx, &a, k, &SynthesisGrid { src_of: &src_of, crop: &crop, scale: sc }, &mut out, &need);
     }
     if b(ctx.params, "advanced/showTrackPoints") {
         let r = (2.5 * f(ctx.params, "advanced/trackPointSize") / 100.0 * sc).max(0.5);
@@ -465,19 +457,16 @@ fn render(ctx: &EffectCtx, buf: Buf) -> Buf {
     Buf { img: out, offset: [0.0; 2], scale: sc }
 }
 
-/// Fill the pixels flagged in `need` (weight = how much synthesized content they take) from
-/// neighbouring frames, nearest first.
-#[allow(clippy::too_many_arguments)]
-fn synthesize(
-    ctx: &EffectCtx,
-    a: &WarpAnalysis,
-    k: usize,
-    src_of: &(dyn Fn([f64; 2]) -> [f64; 2] + Sync),
-    crop: &[f64; 4],
-    sc: f64,
-    out: &mut Image,
-    need: &[f32],
-) {
+/// Maps an output sample into the uncropped source grid shared by neighbouring frames.
+struct SynthesisGrid<'a> {
+    src_of: &'a (dyn Fn([f64; 2]) -> [f64; 2] + Sync),
+    crop: &'a [f64; 4],
+    scale: f64,
+}
+
+/// Fill the pixels flagged in `need` from neighbouring frames, nearest first.
+fn synthesize(ctx: &EffectCtx, a: &WarpAnalysis, k: usize, grid: &SynthesisGrid<'_>, out: &mut Image, need: &[f32]) {
+    let SynthesisGrid { src_of, crop, scale: sc } = *grid;
     let Some(host) = ctx.env.host else { return };
     let n = a.frames.len();
     let range = ((f(ctx.params, "advanced/synthesizeInputRange").max(0.0) / a.frame_duration.max(1e-6)).round() as usize).min(60);
@@ -534,6 +523,7 @@ fn dot(img: &mut Image, c: [f64; 2], r: f64, col: Px) {
 mod tests {
     use super::*;
     use crate::EffectEnv;
+    use crate::analysis_cache::fnv;
     use effectcraft_track::stabilize::FrameMotion;
 
     fn analysis_json(n: usize, w: f64, h: f64, shift: impl Fn(usize) -> [f64; 2]) -> String {
@@ -604,6 +594,61 @@ mod tests {
         assert_eq!(render(&ctx, Buf { img: img.clone(), offset: [0.0; 2], scale: 1.0 }).img.data, img.data);
     }
 
+    #[test]
+    fn prepared_default_plan_preserves_first_render_and_is_reused() {
+        let json = analysis_json(25, 64.0, 48.0, |k| [((k * 7) % 5) as f64 - 2.0, k as f64 * 0.1]);
+        let mut a = WarpAnalysis::from_json(&json).unwrap();
+        a.start = 0.012345678901234567;
+        a.tracks = (0..24)
+            .map(|id| effectcraft_track::camtrack::Track2D {
+                id,
+                start: 0,
+                pts: (0..25).map(|k| [8.0 + (id % 6) as f32 * 8.0 + ((k * 7) % 5) as f32, 8.0 + (id / 6) as f32 * 8.0 + k as f32 * 0.1]).collect(),
+            })
+            .collect();
+        let json = a.to_json();
+        let ps = params(&json, 2, 0);
+        let ctx = EffectCtx { params: &ps, time: a.start, layer_size: a.size, seed: 1, adjustment: false, env: EffectEnv::default() };
+        let input = Buf { img: frame([30.0, 22.0]), offset: [0.0; 2], scale: 1.0 };
+        // Original flow: validate, discard the plan, then render from the stored analysis.
+        let _discarded = plan(&a, &StabSettings { fps: 25.0, ..Default::default() });
+        let before = render(&ctx, input.clone());
+        let key = (fnv(json.as_bytes()), settings_key(&settings(&ps, 25.0)));
+        plans().lock().unwrap().remove(&key);
+        assert!(prepare_default_plan(&json));
+        let prepared = plans().lock().unwrap().get(&key).unwrap().clone();
+        assert!(!prepared.meshes.is_empty(), "exercise the Subspace Warp plan");
+        let after = render(&ctx, input);
+        let (_, _, rendered) = plan_at(&ps, a.start).unwrap();
+        assert!(Arc::ptr_eq(&prepared, &rendered));
+        assert_eq!(before.offset, after.offset);
+        assert_eq!(before.scale.to_bits(), after.scale.to_bits());
+        for (a, b) in before.img.data.iter().flatten().zip(after.img.data.iter().flatten()) {
+            assert_eq!(a.to_bits(), b.to_bits());
+        }
+        assert!(!prepare_default_plan("invalid"));
+        assert!(!prepare_default_plan(&WarpAnalysis::default().to_json()));
+    }
+
+    #[test]
+    fn changing_analysis_changes_the_plan_key() {
+        let json = analysis_json(10, 64.0, 48.0, |k| [k as f64 * 0.1, 0.0]);
+        let mut ps = params(&json, 2, 0);
+        let before = summary_key(&ps).unwrap();
+        assert_eq!(before[0], fnv(json.as_bytes()));
+        let mut a = WarpAnalysis::from_json(&json).unwrap();
+        a.start = 1.0;
+        ps.values.insert(ANALYSIS.into(), Value::Str(a.to_json()));
+        let after = summary_key(&ps).unwrap();
+        assert_ne!(before[0], after[0]);
+        assert_eq!(before[1], after[1]);
+        assert_eq!(*analysis(&ps).unwrap(), a);
+        ps.values.insert(ANALYSIS.into(), Value::Str(json));
+        assert_eq!(summary_key(&ps).unwrap(), before);
+        ps.values.insert(ANALYSIS.into(), Value::Str(String::new()));
+        assert!(analysis(&ps).is_none());
+    }
+
     #[test]
     fn nested_param_lookup() {
         let mut p = Params::default();
diff --git a/crates/effects/tests/it/sim_golden.rs b/crates/effects/tests/it/sim_golden.rs
index 2a3a7c724..388790901 100644
--- a/crates/effects/tests/it/sim_golden.rs
+++ b/crates/effects/tests/it/sim_golden.rs
@@ -433,26 +433,26 @@ const GOLDEN: &[(&str, u64)] = &[
     ("ec.sim.ccstarburst/1/32bpc/t1.5", 0x5c39f8b1bd0e9e43),
     ("ec.sim.ccstarburst/1/32bpc/t0.8", 0xdf20aa9dcf4b3e22),
     ("ec.sim.ccstarburst/1/32bpc/t2.2", 0x4fa441737bfcb64d),
-    ("ec.sim.ccbubbles/0/8bpc/t0.5", 0xdcd187e75eeb2fae),
-    ("ec.sim.ccbubbles/0/8bpc/t1.5", 0x835ca088747736ed),
-    ("ec.sim.ccbubbles/0/8bpc/t0.8", 0x5cbb1a6fbb77b41d),
-    ("ec.sim.ccbubbles/0/8bpc/t2.2", 0x3b168068f5bfa533),
-    ("ec.sim.ccbubbles/0/32bpc/t0.5", 0x524b84d14edd77e2),
-    ("ec.sim.ccbubbles/0/32bpc/t1.5", 0xfd7a17f0d40f2a27),
-    ("ec.sim.ccbubbles/0/32bpc/t0.8", 0x70dd2b2b4ff0f7ce),
-    ("ec.sim.ccbubbles/0/32bpc/t2.2", 0xae21dd5cc2c2c07c),
-    ("ec.sim.ccbubbles/0/8bpc/half/t0.5", 0x931b4ca707604220),
-    ("ec.sim.ccbubbles/0/8bpc/half/t1.5", 0x21c25d4555abebe9),
-    ("ec.sim.ccbubbles/0/8bpc/half/t0.8", 0x7e05972683359632),
-    ("ec.sim.ccbubbles/0/8bpc/half/t2.2", 0xadc4f7219dab4921),
-    ("ec.sim.ccbubbles/1/8bpc/t0.5", 0x89d27a2fe2011067),
-    ("ec.sim.ccbubbles/1/8bpc/t1.5", 0x2bbfee897bf5bf6e),
-    ("ec.sim.ccbubbles/1/8bpc/t0.8", 0x26cc704e7b06fffc),
-    ("ec.sim.ccbubbles/1/8bpc/t2.2", 0x959d331545d96479),
-    ("ec.sim.ccbubbles/1/32bpc/t0.5", 0xaf486cebfcbf4641),
-    ("ec.sim.ccbubbles/1/32bpc/t1.5", 0xe150e9fdb558036f),
-    ("ec.sim.ccbubbles/1/32bpc/t0.8", 0x6395f3967cb24284),
-    ("ec.sim.ccbubbles/1/32bpc/t2.2", 0x68a55894d86ffb9e),
+    ("ec.sim.ccbubbles/0/8bpc/t0.5", 0x6cb63df0c062fdf4),
+    ("ec.sim.ccbubbles/0/8bpc/t1.5", 0x5bb1350114234ac3),
+    ("ec.sim.ccbubbles/0/8bpc/t0.8", 0xaa824d49f12c4156),
+    ("ec.sim.ccbubbles/0/8bpc/t2.2", 0x3528577358c4fc90),
+    ("ec.sim.ccbubbles/0/32bpc/t0.5", 0xdcd8e71222c13a9a),
+    ("ec.sim.ccbubbles/0/32bpc/t1.5", 0xd09565e124d8f5db),
+    ("ec.sim.ccbubbles/0/32bpc/t0.8", 0x91242f8e1fd0ad84),
+    ("ec.sim.ccbubbles/0/32bpc/t2.2", 0x1f9782131e62149d),
+    ("ec.sim.ccbubbles/0/8bpc/half/t0.5", 0x020755e48bdf8f43),
+    ("ec.sim.ccbubbles/0/8bpc/half/t1.5", 0x4aac0f1332e6001e),
+    ("ec.sim.ccbubbles/0/8bpc/half/t0.8", 0xdc2ab5e04c4a95a2),
+    ("ec.sim.ccbubbles/0/8bpc/half/t2.2", 0x30f78adc5d1dd715),
+    ("ec.sim.ccbubbles/1/8bpc/t0.5", 0x2f5415c679ff0980),
+    ("ec.sim.ccbubbles/1/8bpc/t1.5", 0xfcfc354dcd22e6d0),
+    ("ec.sim.ccbubbles/1/8bpc/t0.8", 0xdf90fd57c217019c),
+    ("ec.sim.ccbubbles/1/8bpc/t2.2", 0xd365c88c12219802),
+    ("ec.sim.ccbubbles/1/32bpc/t0.5", 0x50f20497f40bb46d),
+    ("ec.sim.ccbubbles/1/32bpc/t1.5", 0x74760599ffba220a),
+    ("ec.sim.ccbubbles/1/32bpc/t0.8", 0x028de52900ed8618),
+    ("ec.sim.ccbubbles/1/32bpc/t2.2", 0xaf0e21d9a7f625fe),
     ("ec.sim.ccdrizzle/0/8bpc/t0.5", 0x2bdfbc17d92b65b5),
     ("ec.sim.ccdrizzle/0/8bpc/t1.5", 0x8c354c46f99e35d3),
     ("ec.sim.ccdrizzle/0/8bpc/t0.8", 0x891f331ba47ee557),
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index 7104bc1cc..826346987 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -39,3 +39,9 @@ rayon = { workspace = true }
 image = { workspace = true }
 web-time = { workspace = true }
 exr = { workspace = true }
+
+# Native file identity and SAM 2 inference; browsers keep the built-in engines.
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+same-file = { workspace = true }
+tempfile = { workspace = true }
+effectcraft-sam2 = { workspace = true }
diff --git a/crates/engine/presets/behaviors.json b/crates/engine/presets/behaviors.json
new file mode 100644
index 000000000..71e87db52
--- /dev/null
+++ b/crates/engine/presets/behaviors.json
@@ -0,0 +1,248 @@
+{
+  "format": "effectcraft.animationPresets/1",
+  "notes": "Original EffectCraft behavior presets (MIT OR Apache-2.0), written from scratch. Each one drives a transform property or opacity with a time-based expression built on the property's own value, so the motion runs for the layer's whole duration and still follows the property's keyframes. Apply to any layer; no effects are added.",
+  "presets": [
+    {
+      "id": "wiggleSoft",
+      "name": "Soft Wiggle",
+      "category": "Behaviors",
+      "description": "The layer wanders gently around its position.",
+      "layer": {
+        "expr": {
+          "transform/position": "var w = wiggle(1.2, 30); [w[0], w[1]]"
+        }
+      }
+    },
+    {
+      "id": "shake",
+      "name": "Shake",
+      "category": "Behaviors",
+      "description": "A fast, tight shake of the layer's position.",
+      "layer": {
+        "expr": {
+          "transform/position": "var w = wiggle(14, 12); [w[0], w[1]]"
+        }
+      }
+    },
+    {
+      "id": "floatUpDown",
+      "name": "Float",
+      "category": "Behaviors",
+      "description": "The layer bobs up and down like it floats on water.",
+      "layer": {
+        "expr": {
+          "transform/position": "[value[0]+(0), value[1]+(Math.sin(time*2)*18)]"
+        }
+      }
+    },
+    {
+      "id": "sway",
+      "name": "Sway",
+      "category": "Behaviors",
+      "description": "The layer sways left and right.",
+      "layer": {
+        "expr": {
+          "transform/position": "[value[0]+(Math.sin(time*1.6)*40), value[1]+(0)]"
+        }
+      }
+    },
+    {
+      "id": "orbit",
+      "name": "Orbit",
+      "category": "Behaviors",
+      "description": "The layer travels round a circle around its position.",
+      "layer": {
+        "expr": {
+          "transform/position": "[value[0]+(Math.cos(time*2)*80), value[1]+(Math.sin(time*2)*80)]"
+        }
+      }
+    },
+    {
+      "id": "figureEight",
+      "name": "Figure Eight",
+      "category": "Behaviors",
+      "description": "The layer traces a figure eight around its position.",
+      "layer": {
+        "expr": {
+          "transform/position": "[value[0]+(Math.sin(time*1.5)*100), value[1]+(Math.sin(time*3)*45)]"
+        }
+      }
+    },
+    {
+      "id": "bouncingBall",
+      "name": "Bouncing Ball",
+      "category": "Behaviors",
+      "description": "The layer bounces up from its position again and again.",
+      "layer": {
+        "expr": {
+          "transform/position": "[value[0]+(0), value[1]+(-Math.abs(Math.sin(time*3.2))*140)]"
+        }
+      }
+    },
+    {
+      "id": "driftRight",
+      "name": "Drift Right",
+      "category": "Behaviors",
+      "description": "The layer drifts steadily to the right.",
+      "layer": {
+        "expr": {
+          "transform/position": "[value[0]+(time*40), value[1]+(0)]"
+        }
+      }
+    },
+    {
+      "id": "driftDiagonal",
+      "name": "Drift Diagonal",
+      "category": "Behaviors",
+      "description": "The layer drifts slowly down and to the right.",
+      "layer": {
+        "expr": {
+          "transform/position": "[value[0]+(time*30), value[1]+(time*18)]"
+        }
+      }
+    },
+    {
+      "id": "pendulum",
+      "name": "Pendulum",
+      "category": "Behaviors",
+      "description": "The layer swings like a pendulum.",
+      "layer": {
+        "expr": {
+          "transform/rotation": "value + Math.sin(time*2.4)*25"
+        }
+      }
+    },
+    {
+      "id": "wobble",
+      "name": "Wobble",
+      "category": "Behaviors",
+      "description": "The layer rotates with an irregular wobble.",
+      "layer": {
+        "expr": {
+          "transform/rotation": "wiggle(2, 10)"
+        }
+      }
+    },
+    {
+      "id": "spinSlow",
+      "name": "Spin Slow",
+      "category": "Behaviors",
+      "description": "The layer rotates once every ten seconds.",
+      "layer": {
+        "expr": {
+          "transform/rotation": "value + time*36"
+        }
+      }
+    },
+    {
+      "id": "spinFast",
+      "name": "Spin Fast",
+      "category": "Behaviors",
+      "description": "The layer rotates twice a second.",
+      "layer": {
+        "expr": {
+          "transform/rotation": "value + time*720"
+        }
+      }
+    },
+    {
+      "id": "pulse",
+      "name": "Pulse",
+      "category": "Behaviors",
+      "description": "The layer swells and shrinks smoothly.",
+      "layer": {
+        "expr": {
+          "transform/scale": "[value[0]*(1+0.12*Math.sin(time*4)), value[1]*(1+0.12*Math.sin(time*4))]"
+        }
+      }
+    },
+    {
+      "id": "heartbeat",
+      "name": "Heartbeat",
+      "category": "Behaviors",
+      "description": "Two quick beats, then a rest, repeating every second.",
+      "layer": {
+        "expr": {
+          "transform/scale": "var t = time % 1; var b = t < 0.3 ? Math.sin(t/0.3*Math.PI) : (t < 0.6 ? 0.7*Math.sin((t-0.3)/0.3*Math.PI) : 0); var k = 1 + 0.2*b; [value[0]*k, value[1]*k]"
+        }
+      }
+    },
+    {
+      "id": "breathe",
+      "name": "Breathe",
+      "category": "Behaviors",
+      "description": "The layer slowly grows and settles back.",
+      "layer": {
+        "expr": {
+          "transform/scale": "[value[0]*(1+0.06*Math.sin(time*1.1)), value[1]*(1+0.06*Math.sin(time*1.1))]"
+        }
+      }
+    },
+    {
+      "id": "rubberBand",
+      "name": "Rubber Band",
+      "category": "Behaviors",
+      "description": "Width and height stretch against each other.",
+      "layer": {
+        "expr": {
+          "transform/scale": "[value[0]*(1+0.15*Math.sin(time*5)), value[1]*(1-0.15*Math.sin(time*5))]"
+        }
+      }
+    },
+    {
+      "id": "jitterScale",
+      "name": "Jitter Scale",
+      "category": "Behaviors",
+      "description": "The layer's size jitters randomly.",
+      "layer": {
+        "expr": {
+          "transform/scale": "var w = wiggle(8, 6); [w[0], w[1]]"
+        }
+      }
+    },
+    {
+      "id": "blink",
+      "name": "Blink",
+      "category": "Behaviors",
+      "description": "The layer switches on and off twice a second.",
+      "layer": {
+        "expr": {
+          "transform/opacity": "(Math.floor(time*4) % 2 === 0) ? value : 0"
+        }
+      }
+    },
+    {
+      "id": "strobe",
+      "name": "Strobe",
+      "category": "Behaviors",
+      "description": "The layer flashes on for a few frames each beat.",
+      "layer": {
+        "expr": {
+          "transform/opacity": "((time*6) % 1 < 0.25) ? value : 0"
+        }
+      }
+    },
+    {
+      "id": "flicker",
+      "name": "Flicker",
+      "category": "Behaviors",
+      "description": "The layer's opacity flickers like a failing lamp.",
+      "layer": {
+        "expr": {
+          "transform/opacity": "var w = wiggle(14, 45); Math.max(0, Math.min(100, w))"
+        }
+      }
+    },
+    {
+      "id": "fadePulse",
+      "name": "Fade Pulse",
+      "category": "Behaviors",
+      "description": "Opacity breathes between full and a third.",
+      "layer": {
+        "expr": {
+          "transform/opacity": "value*(0.67+0.33*Math.sin(time*2.5))"
+        }
+      }
+    }
+  ]
+}
diff --git a/crates/engine/presets/behaviors.json.attribution b/crates/engine/presets/behaviors.json.attribution
new file mode 100644
index 000000000..7c71c62e8
--- /dev/null
+++ b/crates/engine/presets/behaviors.json.attribution
@@ -0,0 +1,7 @@
+asset:        behaviors.json
+title:        EffectCraft Behaviors animation presets (Soft Wiggle, Shake, Float, Sway, Orbit, Figure Eight, Bouncing Ball, Drift Right, Drift Diagonal, Pendulum, Wobble, Spin Slow, Spin Fast, Pulse, Heartbeat, Breathe, Rubber Band, Jitter Scale, Blink, Strobe, Flicker, Fade Pulse)
+author:       EffectCraft contributors
+source:       original work
+license:      MIT OR Apache-2.0
+added:        2026-10-15 by vangel76 (Claude Code agent, gap 7, #1510)
+notes:        Expressions and values written from scratch for EffectCraft on its own transform properties and expression engine; not derived from any Adobe preset (.ffx) or its values.
diff --git a/crates/engine/presets/text_animators.json b/crates/engine/presets/text_animators.json
index 20e142268..e82707a52 100644
--- a/crates/engine/presets/text_animators.json
+++ b/crates/engine/presets/text_animators.json
@@ -77,7 +77,7 @@
           "name": "Tracking In",
           "properties": { "tracking": 0, "opacity": 100 },
           "keys": {
-            "tracking": [[0, 400], [1.6, 0]],
+            "tracking": [[0, 40], [1.6, 0]],
             "opacity": [[0, 0], [0.8, 100]]
           },
           "ease": true,
diff --git a/crates/engine/src/analysis.rs b/crates/engine/src/analysis.rs
new file mode 100644
index 000000000..fa2b8b4ec
--- /dev/null
+++ b/crates/engine/src/analysis.rs
@@ -0,0 +1,6 @@
+pub mod camera_track;
+pub mod mask_track;
+pub mod models;
+pub mod roto;
+pub mod tracking;
+pub mod warp;
diff --git a/crates/engine/src/camera_track.rs b/crates/engine/src/analysis/camera_track.rs
similarity index 99%
rename from crates/engine/src/camera_track.rs
rename to crates/engine/src/analysis/camera_track.rs
index adc5aee69..29961f533 100644
--- a/crates/engine/src/camera_track.rs
+++ b/crates/engine/src/analysis/camera_track.rs
@@ -7,7 +7,7 @@
 //! camera"). When only the solve settings changed (Shot Type, Angle of View, Solve Method,
 //! deleted points) the stored tracks are re-solved without re-tracking. Results are written into
 //! the effect's hidden parameters as one undo step; edits that change the layer's frames clear
-//! them and queue the effect again ([`invalidate`], run after every edit), like After Effects.
+//! them and queue the effect again (`invalidate`, run after every edit), like After Effects.
 //!
 //! Composition space: the solve's canonical frame maps to comp world by
 //! [`CameraSolve::world`] with the zoom of the first solved frame (focal length × the layer's
diff --git a/crates/engine/src/mask_track.rs b/crates/engine/src/analysis/mask_track.rs
similarity index 100%
rename from crates/engine/src/mask_track.rs
rename to crates/engine/src/analysis/mask_track.rs
diff --git a/crates/engine/src/analysis/models.rs b/crates/engine/src/analysis/models.rs
new file mode 100644
index 000000000..63550545a
--- /dev/null
+++ b/crates/engine/src/analysis/models.rs
@@ -0,0 +1,1010 @@
+//! Trained models (Settings ▸ Roto Brush and Settings ▸ Face Tracking; `roto.model*` and
+//! `face.model*` commands): which models the registry offers (`effectcraft_segment::MODELS`, all
+//! open source), which are installed (in the `models` folder), installing one from a file or
+//! downloading the official weights (verified against the registry's SHA-256 either way, and kept
+//! with a notice naming their authors and licence), choosing one per task, and loading it in the
+//! background: into the Roto Brush effect (`effects::roto::set_model`) or the face tracker
+//! ([`Models::face`]).
+//!
+//! Weights are never bundled: the install stays small and nothing is fetched unless asked for.
+//! Downloads use the system's `curl` (shipped with Windows 10+, macOS and most Linux systems),
+//! so no networking code is linked into EffectCraft; without it, the file can be downloaded in a
+//! browser and installed with Install from File. The browser build uses the built-in engines
+//! only, for now.
+
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use effectcraft_segment::face::FaceModel;
+use effectcraft_segment::{self as seg, Loaded, ModelInfo, Task};
+use serde_json::{Value, json};
+use web_time::Instant;
+
+use crate::commands::{CommandSpec, always, b_p, bad, str_p};
+use crate::{EngineError, Result, Session, cmd, query};
+
+/// What a task's background worker reports.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Status {
+    /// What is happening now ("Downloading MobileSAM…").
+    pub busy: Option<String>,
+    /// Model whose load/download owns this lane, for selection-specific waits.
+    pub busy_model: Option<&'static str>,
+    /// The model in use.
+    pub active: Option<String>,
+    /// The last failure, for the Settings page.
+    pub error: Option<String>,
+    /// Model whose operation failed, so Roto status does not report another model's download.
+    pub error_model: Option<&'static str>,
+    /// Failure of the selected model's load; downloads cannot block or retry that load.
+    pub load_error: Option<String>,
+    /// A finished job's message and whether it failed, for a toast (taken by
+    /// [`Session::poll_models`]).
+    pub done: Option<(String, bool)>,
+    /// Counts selection and selected-weight changes: an older load is stale and its model is discarded.
+    pub generation: u64,
+}
+
+/// The session's trained models: per task, the worker's status; and the face model in use.
+#[derive(Default)]
+pub struct Models {
+    roto: Arc<Mutex<Status>>,
+    face: Arc<Mutex<Status>>,
+    face_model: FaceSlot,
+}
+
+impl Models {
+    fn lane(&self, task: Task) -> &Arc<Mutex<Status>> {
+        match task {
+            Task::Mask => &self.roto,
+            Task::Face => &self.face,
+        }
+    }
+
+    pub fn status(&self, task: Task) -> Status {
+        self.lane(task).lock().map(|s| s.clone()).unwrap_or_default()
+    }
+
+    /// The face model face tracking uses (`None`: the classic tracker).
+    pub fn face(&self) -> Option<Arc<dyn FaceModel>> {
+        self.face_model.lock().ok().and_then(|m| m.clone())
+    }
+
+    /// Activate a model that finished loading for the choice counted as `generation`; `false` (and the model is
+    /// dropped) when the choice changed meanwhile.
+    #[cfg(test)]
+    pub(crate) fn set_active_if_current(&self, task: Task, model: Loaded, generation: u64) -> bool {
+        activate_if_current(self.lane(task), &self.face_model, task, model, generation)
+    }
+
+    pub(crate) fn set_active(&self, task: Task, model: Option<Loaded>) {
+        activate(self.lane(task), &self.face_model, task, model);
+    }
+}
+
+type FaceSlot = Arc<Mutex<Option<Arc<dyn FaceModel>>>>;
+
+/// Put a loaded model to use (or drop `task`'s): Roto Brush's lives in the effect, the face
+/// tracker's in `face`.
+fn activate(lane: &Arc<Mutex<Status>>, face: &FaceSlot, task: Task, model: Option<Loaded>) {
+    let id = model.as_ref().map(|m| match m {
+        Loaded::Mask(m) => m.info().id.to_string(),
+        Loaded::Face(m) => m.info().id.to_string(),
+    });
+    match (task, model) {
+        (Task::Mask, Some(Loaded::Mask(m))) => crate::effects::roto::set_model(Some(m)),
+        (Task::Mask, _) => crate::effects::roto::set_model(None),
+        (Task::Face, m) => {
+            if let Ok(mut slot) = face.lock() {
+                *slot = match m {
+                    Some(Loaded::Face(f)) => Some(f),
+                    _ => None,
+                };
+            }
+        }
+    }
+    set(lane, |s| s.active = id);
+}
+
+/// [`activate`] a freshly loaded model unless the choice changed since the load started (`generation`); whether it
+/// was activated. The check and the activation happen under the lane's lock, so a selection can't slip between them.
+fn activate_if_current(lane: &Arc<Mutex<Status>>, face: &FaceSlot, task: Task, model: Loaded, generation: u64) -> bool {
+    let Ok(mut s) = lane.lock() else { return false };
+    if s.generation != generation {
+        return false;
+    }
+    let id = match &model {
+        Loaded::Mask(m) => m.info().id.to_string(),
+        Loaded::Face(m) => m.info().id.to_string(),
+    };
+    match (task, model) {
+        (Task::Mask, Loaded::Mask(m)) => crate::effects::roto::set_model(Some(m)),
+        (Task::Face, Loaded::Face(f)) => {
+            if let Ok(mut slot) = face.lock() {
+                *slot = Some(f);
+            }
+        }
+        _ => return false,
+    }
+    s.active = Some(id);
+    true
+}
+
+fn set(status: &Arc<Mutex<Status>>, f: impl FnOnce(&mut Status)) {
+    if let Ok(mut s) = status.lock() {
+        f(&mut s);
+    }
+}
+
+/// How a task shows in Settings, toasts and the command list.
+struct Kind {
+    /// Command prefix and settings key section.
+    prefix: &'static str,
+    label: &'static str,
+    classic_name: &'static str,
+    classic_description: &'static str,
+}
+
+const ROTO: Kind = Kind {
+    prefix: "roto",
+    label: "Roto Brush",
+    classic_name: "Classic (graph cut)",
+    classic_description: "Built in: colour models and graph cuts, propagated by optical flow. Always available.",
+};
+
+const FACE: Kind = Kind {
+    prefix: "face",
+    label: "Face Tracking",
+    classic_name: "Classic (shape model)",
+    classic_description: "Built in: a skin colour model, facial feature shapes and a fitted face shape model. Best on front-facing, evenly lit faces. Always available.",
+};
+
+fn kind(task: Task) -> &'static Kind {
+    match task {
+        Task::Mask => &ROTO,
+        Task::Face => &FACE,
+    }
+}
+
+/// How long a Roto Brush model may sit unused before its memory is freed.
+const ROTO_MODEL_IDLE: Duration = Duration::from_secs(600);
+
+/// How long a job that needs the Roto Brush model waits for it to load (or download) before it
+/// gives up. A worker that never reports back must not hang the command.
+const ROTO_MODEL_WAIT: Duration = Duration::from_secs(600);
+
+impl Session {
+    /// The folder installed models live in: the host's, else `models` next to the settings.
+    pub fn models_dir(&self) -> Option<PathBuf> {
+        self.models_dir.clone().or_else(|| Some(self.config.as_ref()?.dir()?.join("models")))
+    }
+
+    /// Where `m` is installed, if it is (a file of the published size).
+    pub fn model_path(&self, m: &ModelInfo) -> Option<PathBuf> {
+        let p = self.models_dir()?.join(m.file_name);
+        std::fs::metadata(&p).ok().filter(|md| md.len() == m.size).map(|_| p)
+    }
+
+    /// The model chosen for `task` (Settings).
+    pub fn chosen_model(&self, task: Task) -> &str {
+        match task {
+            Task::Mask => &self.prefs.roto.model,
+            Task::Face => &self.prefs.face.model,
+        }
+    }
+
+    fn choose_model(&mut self, task: Task, id: &str) {
+        let slot = match task {
+            Task::Mask => &mut self.prefs.roto.model,
+            Task::Face => &mut self.prefs.face.model,
+        };
+        let changed = slot != id;
+        if changed {
+            *slot = id.to_string();
+        }
+        set(self.models.lane(task), |s| {
+            // A load still running for the previous choice must not activate or report an error.
+            if changed {
+                s.generation = s.generation.wrapping_add(1);
+            }
+            // Selecting the same model explicitly retries a failed load.
+            s.error = None;
+            s.error_model = None;
+            s.load_error = None;
+        });
+    }
+
+    /// Load (or drop) the models Settings chooses; called whenever settings change.
+    pub fn apply_models(&mut self) {
+        for task in [Task::Mask, Task::Face] {
+            self.apply_model(task, false);
+        }
+    }
+
+    /// Load (or drop) `task`'s chosen model; `wait`: before returning (scripts and agents).
+    fn apply_model(&mut self, task: Task, wait: bool) {
+        let want = self.chosen_model(task).to_string();
+        let lane = self.models.lane(task).clone();
+        let st = self.models.status(task);
+        let info = seg::info(&want).filter(|m| m.task == task);
+        let Some(info) = info else {
+            if st.active.is_some() {
+                self.models.set_active(task, None);
+            }
+            return;
+        };
+        if st.active.as_deref() == Some(info.id) || st.busy.is_some() || st.load_error.is_some() {
+            return;
+        }
+        let Some(path) = self.model_path(info) else {
+            self.models.set_active(task, None);
+            return;
+        };
+        let (face_slot, label) = (self.models.face_model.clone(), kind(task).label);
+        let generation = st.generation;
+        spawn(&lane, label, format!("Loading {}…", info.name), wait, Some(generation), info.id, move |status| {
+            let m = load_file(&path, info.id)?;
+            // the choice changed while this loaded: drop the model, `poll_models` loads the new choice
+            if !activate_if_current(status, &face_slot, task, m, generation) {
+                return Ok(String::new());
+            }
+            Ok(format!("{label}: {} loaded", info.name))
+        });
+    }
+
+    /// The Roto Brush model in use (`None`: the classic engine).
+    pub fn models_roto_active(&self) -> Option<String> {
+        self.models.status(Task::Mask).active
+    }
+
+    /// Only installing the chosen model is a retry of that model's failed load.
+    fn retry_installed_model(&mut self, task: Task, id: &str, wait: bool) -> std::result::Result<bool, String> {
+        if self.chosen_model(task) != id {
+            return Ok(false);
+        }
+        set(self.models.lane(task), |s| {
+            s.error = None;
+            s.error_model = None;
+            s.load_error = None;
+            // A load that read the old file must not report failure after these weights replaced it.
+            s.generation = s.generation.wrapping_add(1);
+        });
+        if self.models.status(task).active.as_deref() == Some(id) {
+            return Ok(true);
+        }
+        if wait {
+            self.wait_model_worker(task, id)?;
+        }
+        self.apply_model(task, wait);
+        if wait {
+            let status = self.models.status(task);
+            if status.active.as_deref() != Some(id) {
+                return Err(status.load_error.unwrap_or_else(|| format!("{id} is not loaded: try again when the model worker is ready")));
+            }
+        }
+        Ok(true)
+    }
+
+    fn wait_model_worker(&self, task: Task, id: &str) -> std::result::Result<(), String> {
+        let started = Instant::now();
+        loop {
+            let status = self.models.status(task);
+            let Some(operation) = status.busy else { return Ok(()) };
+            if status.busy_model != Some(id) {
+                return Err(format!("{id} cannot load while another model operation is running ({operation}): try again when it is ready"));
+            }
+            if started.elapsed() >= ROTO_MODEL_WAIT {
+                return Err(format!("{} is still loading after {} minutes", self.chosen_model(task), ROTO_MODEL_WAIT.as_secs() / 60));
+            }
+            std::thread::sleep(Duration::from_millis(5));
+        }
+    }
+
+    /// The Roto Brush model Settings chose, when it is one (not the classic engine).
+    fn roto_model_info(&self) -> Option<&'static ModelInfo> {
+        seg::info(self.chosen_model(Task::Mask)).filter(|m| m.task == Task::Mask)
+    }
+
+    /// Whether the chosen Roto Brush model is still loading or downloading.
+    pub fn roto_model_loading(&self) -> bool {
+        let status = self.models.status(Task::Mask);
+        let chosen = self.chosen_model(Task::Mask);
+        status.active.as_deref() != Some(chosen) && status.busy.is_some() && status.busy_model == Some(chosen)
+    }
+
+    /// The Roto Brush model Settings chose and its state (`roto.status`).
+    pub fn roto_model(&self) -> Value {
+        let st = self.models.status(Task::Mask);
+        json!({
+            "selected": self.chosen_model(Task::Mask),
+            "installed": self.roto_model_info().is_none_or(|m| self.model_path(m).is_some()),
+            "active": st.active,
+            "loading": self.roto_model_loading(),
+            "error": st.load_error.or(st.error.filter(|_| st.error_model == Some(self.chosen_model(Task::Mask)))),
+        })
+    }
+
+    /// What `roto.status` says when the chosen model is not the one in use for this layer (`None`:
+    /// nothing to say). `uses_model`: the layer segments with a model at all (Roto Brush 1.0 does not).
+    pub fn roto_model_notice(&self, uses_model: bool) -> Option<String> {
+        let info = self.roto_model_info()?;
+        if !uses_model {
+            return Some(format!("{} is selected, but this layer is Roto Brush 1.0: it segments with the classic engine", info.name));
+        }
+        let st = self.models.status(Task::Mask);
+        if st.active.as_deref() == Some(info.id) {
+            None
+        } else if self.model_path(info).is_none() {
+            Some(format!("{} is selected but not installed: propagate refuses until it is installed or Classic is chosen", info.name))
+        } else if let Some(e) = st.load_error {
+            Some(format!("{} is selected but failed to load ({e}): propagate refuses until it is selected again", info.name))
+        } else {
+            Some(format!("{} is selected but not loaded yet: propagate loads it first with wait: true, and refuses without it", info.name))
+        }
+    }
+
+    /// What `roto.status` says when the saved tracking applies but Settings choose another model (`None`:
+    /// they agree, or nothing is saved).
+    pub fn saved_tracking_notice(&self, saved: Option<&str>) -> Option<String> {
+        let saved = saved?;
+        let chosen = self.chosen_model(Task::Mask);
+        if saved == chosen {
+            return None;
+        }
+        let name = |id: &str| seg::info(id).map_or(ROTO.classic_name, |m| m.name);
+        Some(format!("The saved tracking was made with {}; {} is chosen: Propagate again to replace it", name(saved), name(chosen)))
+    }
+
+    /// Make sure the Roto Brush model Settings chose is in use before a job that segments with it
+    /// starts, so the job never runs on the classic engine without saying so. With `wait`, a load
+    /// under way is waited for and one not started is loaded here; without it, a model that is not
+    /// ready is refused (and starts loading). A model that is not installed, or failed to load, is
+    /// refused either way. The classic engine needs nothing.
+    pub fn ensure_roto_model(&mut self, wait: bool) -> std::result::Result<(), String> {
+        let Some(info) = self.roto_model_info() else { return Ok(()) };
+        if self.models.status(Task::Mask).active.as_deref() == Some(info.id) {
+            return Ok(());
+        }
+        // A download or load under way (from Settings, or `select` without `wait`) finishes first.
+        // Nothing is in flight in the browser build, so this never sleeps there.
+        if wait {
+            self.wait_model_worker(Task::Mask, info.id)?;
+        }
+        if self.model_path(info).is_none() {
+            if self.models.status(Task::Mask).busy.is_some() {
+                return Err(format!("{} is still downloading: try again when it is ready, or pass wait: true", info.name));
+            }
+            return Err(format!("{} is selected for Roto Brush but not installed: install or download it, or choose {}", info.name, ROTO.classic_name));
+        }
+        let st = self.models.status(Task::Mask);
+        if st.active.as_deref() != Some(info.id) && st.busy.is_none() && st.load_error.is_none() {
+            self.apply_model(Task::Mask, wait);
+        }
+        let st = self.models.status(Task::Mask);
+        if st.active.as_deref() == Some(info.id) {
+            return Ok(());
+        }
+        if let Some(e) = st.load_error {
+            return Err(format!("{} failed to load: {e}", info.name));
+        }
+        Err(format!("{} is still loading: try again when it is ready, or pass wait: true", info.name))
+    }
+
+    /// Free a Roto Brush model that has been idle for [`ROTO_MODEL_IDLE`] (and is not under a job). The
+    /// choice stays: it loads again when a job or a stroke needs it.
+    fn unload_idle_roto_model(&mut self) {
+        if self.is_roto_running() || self.models.status(Task::Mask).busy.is_some() {
+            return;
+        }
+        let Some(m) = crate::effects::roto::installed_model() else { return };
+        if m.idle_secs().is_some_and(|s| s >= ROTO_MODEL_IDLE.as_secs_f64()) {
+            let name = m.info().name;
+            drop(m);
+            self.models.set_active(Task::Mask, None);
+            self.events.push(crate::Event::Toast {
+                message: format!("{name} unloaded after {} minutes idle; it loads again when it is used", ROTO_MODEL_IDLE.as_secs() / 60),
+                error: false,
+            });
+        }
+    }
+
+    /// Start loading the chosen Roto Brush model again if it was unloaded for being idle (before a stroke uses it).
+    /// The load runs on the model worker, so the stroke is never blocked on it (the classic engine segments it
+    /// meanwhile and `poll_models` installs the model when it arrives), and a model that already failed to load is
+    /// not retried on every stroke: choosing it again clears the error.
+    pub fn reload_roto_model(&mut self) {
+        let chosen = self.chosen_model(Task::Mask).to_string();
+        let st = self.models.status(Task::Mask);
+        if chosen != seg::CLASSICAL && st.active.is_none() && st.busy.is_none() && st.load_error.is_none() {
+            self.apply_model(Task::Mask, false);
+        }
+    }
+
+    /// Finish what the model workers did: a toast, and loading a model that just arrived.
+    pub fn poll_models(&mut self) {
+        self.unload_idle_roto_model();
+        for task in [Task::Mask, Task::Face] {
+            let done = self.models.lane(task).lock().ok().and_then(|mut s| s.done.take());
+            if let Some((message, error)) = done {
+                // a discarded (stale) load has no message
+                if !message.is_empty() {
+                    self.events.push(crate::Event::Toast { message, error });
+                }
+                self.apply_model(task, false);
+            }
+        }
+    }
+}
+
+fn load_file(path: &Path, id: &str) -> std::result::Result<Loaded, String> {
+    let bytes = std::fs::read(path).map_err(|e| format!("cannot read {}: {e}", path.display()))?;
+    // SAM 2 runs on candle and is native only; every other model loads through the registry.
+    #[cfg(not(target_arch = "wasm32"))]
+    if effectcraft_sam2::mask::SIZES.iter().any(|m| m.id == id) {
+        return effectcraft_sam2::mask::load(&bytes).map(|m| Loaded::Mask(m));
+    }
+    seg::load(id, &bytes)
+}
+
+/// Run `job` on a worker thread (`wait`: right here), reporting through `status` (desktop; the
+/// browser build has no trained models yet).
+fn spawn(
+    status: &Arc<Mutex<Status>>,
+    label: &'static str,
+    what: String,
+    wait: bool,
+    generation: Option<u64>,
+    model: &'static str,
+    job: impl FnOnce(&Arc<Mutex<Status>>) -> std::result::Result<String, String> + Send + 'static,
+) {
+    if cfg!(target_arch = "wasm32") {
+        set(status, |s| {
+            let message = "trained models are available in the desktop app".to_string();
+            if generation.is_some() {
+                s.load_error = Some(message.clone());
+            }
+            s.error = Some(message);
+            s.error_model = Some(model);
+        });
+        return;
+    }
+    set(status, |s| {
+        s.busy = Some(what);
+        s.busy_model = Some(model);
+        s.error = None;
+        s.error_model = None;
+    });
+    let st = status.clone();
+    let run = move || {
+        let r = job(&st);
+        set(&st, |s| {
+            s.busy = None;
+            s.busy_model = None;
+            if generation.is_some_and(|g| g != s.generation) {
+                // Keep a completion marker so polling starts the newly selected model.
+                s.done = Some((String::new(), false));
+                return;
+            }
+            match r {
+                Ok(msg) => s.done = Some((msg, false)),
+                Err(e) => {
+                    s.done = Some((format!("{label} model: {e}"), true));
+                    if generation.is_some() {
+                        s.load_error = Some(e.clone());
+                    }
+                    s.error = Some(e);
+                    s.error_model = Some(model);
+                }
+            }
+        });
+    };
+    if wait {
+        run();
+    } else if let Err(e) = std::thread::Builder::new().name("ec-model".into()).spawn(run) {
+        set(status, |s| {
+            s.busy = None;
+            s.busy_model = None;
+            let message = format!("cannot start: {e}");
+            if generation.is_some() {
+                s.load_error = Some(message.clone());
+            }
+            s.error = Some(message);
+            s.error_model = Some(model);
+        });
+    }
+}
+
+/// The notice kept next to `m`'s weights.
+fn notice_path(dir: &Path, m: &ModelInfo) -> PathBuf {
+    dir.join(format!("{}.NOTICE.txt", m.file_name))
+}
+
+/// Copy verified weights into the models folder (atomically), with their notice.
+fn install_bytes(dir: &Path, m: &ModelInfo, bytes: &[u8]) -> std::result::Result<PathBuf, String> {
+    if bytes.len() as u64 != m.size || seg::sha256::hex(bytes) != m.sha256 {
+        return Err(format!("this is not the published {} file (size or SHA-256 differs)", m.name));
+    }
+    use crate::config::FileOps;
+    let path = dir.join(m.file_name);
+    let files = crate::config::StdFiles;
+    files.write(&path, bytes).map_err(|e| format!("cannot write {}: {e}", path.display()))?;
+    files.write(&notice_path(dir, m), seg::notice(m).as_bytes()).map_err(|e| format!("cannot write the notice: {e}"))?;
+    Ok(path)
+}
+
+fn models_for_platform(task: Task, wasm: bool) -> impl Iterator<Item = &'static ModelInfo> {
+    seg::models(task).filter(move |m| !wasm || !m.id.starts_with("sam2.1-hiera-"))
+}
+
+fn target_models(task: Task) -> impl Iterator<Item = &'static ModelInfo> {
+    models_for_platform(task, cfg!(target_arch = "wasm32"))
+}
+
+fn model_p(p: &Value, cmd: &str, task: Task) -> Result<&'static ModelInfo> {
+    let id = str_p(p, "id").ok_or_else(|| bad(cmd, "missing `id`"))?;
+    target_models(task).find(|m| m.id == id).ok_or_else(|| bad(cmd, format!("unknown model `{id}` (see {}.models)", kind(task).prefix)))
+}
+
+fn list(s: &mut Session, task: Task) -> Result<Value> {
+    let k = kind(task);
+    let st = s.models.status(task);
+    let chosen = s.chosen_model(task).to_string();
+    let mut v = vec![json!({
+        "id": seg::CLASSICAL,
+        "name": k.classic_name,
+        "description": k.classic_description,
+        "licence": "MIT OR Apache-2.0",
+        "installed": true,
+        "selected": chosen == seg::CLASSICAL,
+        "active": st.active.is_none(),
+    })];
+    for m in target_models(task) {
+        #[cfg(not(target_arch = "wasm32"))]
+        let (recommended, hint) = (effectcraft_sam2::mask::recommended().id == m.id, effectcraft_sam2::mask::hint(m.id));
+        #[cfg(target_arch = "wasm32")]
+        let (recommended, hint) = (false, None::<String>);
+        v.push(json!({
+            "recommended": recommended,
+            "hint": hint,
+            "id": m.id,
+            "name": m.name,
+            "description": m.description,
+            "authors": m.authors,
+            "licence": m.licence,
+            "licenceUrl": m.licence_url,
+            "homepage": m.homepage,
+            "url": m.url,
+            "source": m.source,
+            "sourceFile": m.source.rsplit('/').next().unwrap_or(m.file_name),
+            "size": m.size,
+            "sha256": m.sha256,
+            "installed": s.model_path(m).is_some(),
+            "selected": chosen == m.id,
+            "active": st.active.as_deref() == Some(m.id),
+        }));
+    }
+    Ok(json!({"models": v, "busy": st.busy, "error": st.error, "folder": s.models_dir().map(|d| d.display().to_string())}))
+}
+
+/// After a `wait`: the job's failure, as the command's.
+fn waited(s: &Session, task: Task, cmd: &str) -> Result<()> {
+    match s.models.status(task).error {
+        Some(e) => Err(bad(cmd, e)),
+        None => Ok(()),
+    }
+}
+
+fn select(s: &mut Session, p: &Value, task: Task) -> Result<Value> {
+    let cmd = format!("{}.model.select", kind(task).prefix);
+    let id = str_p(p, "id").ok_or_else(|| bad(&cmd, "missing `id`"))?;
+    if id != seg::CLASSICAL {
+        model_p(p, &cmd, task)?;
+    }
+    let wait = b_p(p, "wait").unwrap_or(false);
+    if wait && id != seg::CLASSICAL && s.models.status(task).active.as_deref() != Some(id) {
+        s.wait_model_worker(task, id).map_err(|error| bad(&cmd, error))?;
+    }
+    s.choose_model(task, id);
+    if wait {
+        s.apply_model(task, true);
+        waited(s, task, &cmd)?;
+    }
+    s.save_prefs();
+    s.prefs_changed();
+    Ok(json!({"model": id, "active": s.models.status(task).active}))
+}
+
+fn install(s: &mut Session, p: &Value, task: Task) -> Result<Value> {
+    let cmd = format!("{}.model.install", kind(task).prefix);
+    let path = str_p(p, "path").ok_or_else(|| bad(&cmd, "missing `path` (the downloaded weights file)"))?;
+    let dir = s.models_dir().ok_or_else(|| bad(&cmd, "no settings folder to install into"))?;
+    let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("cannot read {path}: {e}")))?;
+    // Which model it is: the one asked for, or the one whose checksum it has.
+    let m = match str_p(p, "id") {
+        Some(_) => model_p(p, &cmd, task)?,
+        None => {
+            let h = seg::sha256::hex(&bytes);
+            target_models(task)
+                .find(|m| m.sha256 == h)
+                .ok_or_else(|| bad(&cmd, "this file is not a supported published model in the registry (SHA-256 differs)"))?
+        }
+    };
+    let dest = install_bytes(&dir, m, &bytes).map_err(|e| bad(&cmd, e))?;
+    let wait = b_p(p, "wait").unwrap_or(false);
+    s.retry_installed_model(task, m.id, wait).map_err(|error| bad(&cmd, error))?;
+    Ok(json!({"id": m.id, "path": dest.display().to_string()}))
+}
+
+fn download(s: &mut Session, p: &Value, task: Task) -> Result<Value> {
+    let k = kind(task);
+    let cmd = format!("{}.model.download", k.prefix);
+    let m = model_p(p, &cmd, task)?;
+    if m.url.is_empty() {
+        return Err(bad(&cmd, format!("{} has no app download available: use Install from File with the SHA-256-verified weights", m.name)));
+    }
+    let dir = s.models_dir().ok_or_else(|| bad(&cmd, "no settings folder to install into"))?;
+    if s.models.status(task).busy.is_some() {
+        return Err(bad(&cmd, "a model is already downloading or loading"));
+    }
+    let size = if m.size >= 10_000_000 { format!("{} MB", m.size / 1_000_000) } else { format!("{:.1} MB", m.size as f64 / 1e6) };
+    let wait = b_p(p, "wait").unwrap_or(false);
+    spawn(s.models.lane(task), k.label, format!("Downloading {} ({size})…", m.name), wait, None, m.id, move |_| {
+        std::fs::create_dir_all(&dir).map_err(|e| format!("cannot create {}: {e}", dir.display()))?;
+        let tmp = dir.join(format!("{}.part", m.file_name));
+        let out = std::process::Command::new("curl")
+            .args(["-fsSL", "--retry", "2", "--connect-timeout", "20", "-o"])
+            .arg(&tmp)
+            .arg(m.url)
+            .output()
+            .map_err(|e| format!("downloading needs curl ({e}); or download {} in a browser and use Install from File", m.url))?;
+        if !out.status.success() {
+            let _ = std::fs::remove_file(&tmp);
+            return Err(format!("download failed: {}", String::from_utf8_lossy(&out.stderr).trim()));
+        }
+        let bytes = std::fs::read(&tmp).map_err(|e| format!("cannot read the download: {e}"))?;
+        let _ = std::fs::remove_file(&tmp);
+        install_bytes(&dir, m, &bytes)?;
+        Ok(format!("{}: {} downloaded and verified", k.label, m.name))
+    });
+    if wait {
+        waited(s, task, &cmd)?;
+        s.apply_model(task, true);
+        waited(s, task, &cmd)?;
+        return Ok(json!({"id": m.id, "installed": true}));
+    }
+    Ok(json!({"id": m.id, "downloading": true}))
+}
+
+fn remove(s: &mut Session, p: &Value, task: Task) -> Result<Value> {
+    let m = model_p(p, &format!("{}.model.remove", kind(task).prefix), task)?;
+    let Some(path) = s.model_path(m) else { return Ok(json!({"removed": false})) };
+    if s.models.status(task).active.as_deref() == Some(m.id) {
+        s.models.set_active(task, None);
+    }
+    std::fs::remove_file(&path).map_err(|e| EngineError::Other(format!("cannot remove {}: {e}", path.display())))?;
+    if let Some(dir) = path.parent() {
+        let _ = std::fs::remove_file(notice_path(dir, m));
+    }
+    Ok(json!({"removed": true}))
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        query!("roto.models", "Roto Brush Models", "{}", |s, _| list(s, Task::Mask)),
+        cmd!(
+            "roto.model.select",
+            "Use Roto Brush Model",
+            [],
+            None,
+            "{id: classical|mobilesam|sam2.1-hiera-tiny|sam2.1-hiera-small|sam2.1-hiera-base-plus|sam2.1-hiera-large, wait?} (Roto Brush 2.0 / 3.0 use it; wait: loaded before returning)",
+            always,
+            |s, p| select(s, p, Task::Mask)
+        ),
+        cmd!(
+            "roto.model.install",
+            "Install Roto Brush Model",
+            [],
+            None,
+            "{path: weights file, id?, wait?} — verified against the registry's SHA-256",
+            always,
+            |s, p| install(s, p, Task::Mask)
+        ),
+        cmd!(
+            "roto.model.download",
+            "Download Roto Brush Model",
+            [],
+            None,
+            "{id, wait?} — the official weights, verified (desktop; uses the system curl)",
+            always,
+            |s, p| download(s, p, Task::Mask)
+        ),
+        cmd!("roto.model.remove", "Remove Roto Brush Model", [], None, "{id}", always, |s, p| remove(s, p, Task::Mask)),
+        query!("face.models", "Face Tracking Models", "{}", |s, _| list(s, Task::Face)),
+        cmd!(
+            "face.model.select",
+            "Use Face Tracking Model",
+            [],
+            None,
+            "{id: classical|mediapipe-face, wait?} (face tracking uses it; wait: loaded before returning)",
+            always,
+            |s, p| select(s, p, Task::Face)
+        ),
+        cmd!(
+            "face.model.install",
+            "Install Face Tracking Model",
+            [],
+            None,
+            "{path: model file, id?, wait?} — verified against the registry's SHA-256",
+            always,
+            |s, p| install(s, p, Task::Face)
+        ),
+        cmd!(
+            "face.model.download",
+            "Download Face Tracking Model",
+            [],
+            None,
+            "{id, wait?} — the official model, verified (desktop; uses the system curl)",
+            always,
+            |s, p| download(s, p, Task::Face)
+        ),
+        cmd!("face.model.remove", "Remove Face Tracking Model", [], None, "{id}", always, |s, p| remove(s, p, Task::Face)),
+    ]
+}
+
+#[cfg(test)]
+mod availability_tests {
+    use super::*;
+
+    /// SAM 2 cannot start a network operation; file installation still verifies the published hash.
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn sam2_is_install_from_file_only() {
+        let mut session = Session::default();
+        let listed = session.execute("roto.models", json!({})).unwrap();
+        for model in [seg::SAM2_TINY, seg::SAM2_SMALL, seg::SAM2_BASE_PLUS, seg::SAM2_LARGE] {
+            let error = session.execute("roto.model.download", json!({"id": model.id})).unwrap_err();
+            assert!(error.to_string().contains("Install from File"));
+            assert!(session.models.status(Task::Mask).busy.is_none());
+            assert!(install_bytes(Path::new("unused"), &model, b"invalid weights").unwrap_err().contains("SHA-256 differs"));
+            let row = listed["models"].as_array().unwrap().iter().find(|row| row["id"] == model.id).unwrap();
+            assert_eq!(row["source"], model.source);
+            assert_eq!(row["sourceFile"], "model.safetensors");
+        }
+    }
+
+    /// A waiting selection cannot claim completion while unrelated work prevents its model loading.
+    #[test]
+    fn waiting_selection_refuses_an_unrelated_worker_unless_the_model_is_active() {
+        crate::tests::roto::hold_roto_cache_test_lock();
+        for active in [false, true] {
+            let mut session = Session::default();
+            session.choose_model(Task::Mask, if active { "mobilesam" } else { seg::CLASSICAL });
+            set(session.models.lane(Task::Mask), |status| {
+                status.active = active.then(|| "mobilesam".into());
+                status.busy = Some("Downloading SAM 2".into());
+                status.busy_model = Some("sam2.1-hiera-tiny");
+            });
+            let result = session.execute("roto.model.select", json!({"id": "mobilesam", "wait": true}));
+            if active {
+                assert_eq!(result.unwrap()["active"], "mobilesam");
+            } else {
+                assert!(result.unwrap_err().to_string().contains("another model operation"));
+                assert_eq!(session.chosen_model(Task::Mask), seg::CLASSICAL, "a refused selection must not change settings");
+            }
+            assert!(session.models.status(Task::Mask).busy.is_some());
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn stale_model_worker_completions_do_not_poison_the_current_choice() {
+        for failure in [false, true] {
+            let lane = Arc::new(Mutex::new(Status::default()));
+            spawn(&lane, "Roto Brush", "Loading old choice".into(), true, Some(0), "mobilesam", move |status| {
+                set(status, |s| s.generation += 1);
+                if failure { Err("old choice failed".into()) } else { Ok("old choice loaded".into()) }
+            });
+            let status = lane.lock().unwrap();
+            assert!(status.busy.is_none());
+            assert!(status.error.is_none(), "an obsolete worker must not block the current model");
+            assert!(status.load_error.is_none());
+            assert_eq!(status.done, Some((String::new(), false)), "polling must still retry the current choice");
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn current_load_and_download_failures_remain_actionable() {
+        for generation in [Some(0), None] {
+            let lane = Arc::new(Mutex::new(Status::default()));
+            spawn(&lane, "Roto Brush", "Working".into(), true, generation, "mobilesam", move |status| {
+                if generation.is_none() {
+                    set(status, |s| s.generation += 1);
+                }
+                Err("current operation failed".into())
+            });
+            let status = lane.lock().unwrap();
+            assert!(status.busy.is_none());
+            assert_eq!(status.error.as_deref(), Some("current operation failed"));
+            assert_eq!(status.load_error.as_deref(), generation.map(|_| "current operation failed"));
+            assert_eq!(status.done, Some(("Roto Brush model: current operation failed".into(), true)));
+        }
+    }
+
+    #[test]
+    fn choosing_a_model_clears_its_previous_load_error_even_on_retry() {
+        let mut session = Session::default();
+        for id in ["mobilesam", "mobilesam", seg::CLASSICAL] {
+            let previous = session.chosen_model(Task::Mask).to_string();
+            let generation = session.models.status(Task::Mask).generation;
+            set(session.models.lane(Task::Mask), |s| {
+                s.error = Some("previous load failed".into());
+                s.load_error = s.error.clone();
+            });
+            session.choose_model(Task::Mask, id);
+            let status = session.models.status(Task::Mask);
+            assert!(status.error.is_none());
+            assert!(status.load_error.is_none());
+            assert_eq!(status.generation, generation + u64::from(previous != id));
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn selected_active_model_is_ready_despite_an_unrelated_download_error() {
+        let dir = std::env::temp_dir().join(format!("ec-model-ready-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let info = seg::info("mobilesam").unwrap();
+        let file = std::fs::File::create(dir.join(info.file_name)).unwrap();
+        file.set_len(info.size).unwrap();
+        drop(file);
+        let mut session = Session { models_dir: Some(dir.clone()), ..Default::default() };
+        session.choose_model(Task::Mask, info.id);
+        set(session.models.lane(Task::Mask), |s| {
+            s.active = Some(info.id.into());
+            s.error = Some("another model could not be downloaded".into());
+        });
+        assert_eq!(session.ensure_roto_model(false), Ok(()));
+        assert!(session.roto_model()["error"].is_null());
+        set(session.models.lane(Task::Mask), |status| {
+            status.error_model = Some("mobilesam");
+            status.error = Some("selected model download failed".into());
+        });
+        assert_eq!(session.roto_model()["error"], "selected model download failed");
+        std::fs::remove_dir_all(dir).unwrap();
+    }
+
+    #[test]
+    fn an_active_model_and_selected_install_do_not_wait_for_other_downloads() {
+        crate::tests::roto::hold_roto_cache_test_lock();
+        let mut session = Session::default();
+        session.choose_model(Task::Mask, "mobilesam");
+        set(session.models.lane(Task::Mask), |status| {
+            status.active = Some("mobilesam".into());
+            status.busy = Some("Downloading SAM 2".into());
+            status.busy_model = Some("sam2.1-hiera-tiny");
+        });
+        assert_eq!(session.ensure_roto_model(true), Ok(()));
+        assert_eq!(session.retry_installed_model(Task::Mask, "mobilesam", true), Ok(true));
+        let status = session.models.status(Task::Mask);
+        assert!(status.busy.is_some(), "the unrelated operation must still be running");
+        assert!(!session.roto_model_loading());
+        assert_eq!(session.roto_model()["loading"], false);
+    }
+
+    #[test]
+    fn waiting_on_an_inactive_model_refuses_unrelated_work_without_waiting() {
+        crate::tests::roto::hold_roto_cache_test_lock();
+        let mut session = Session::default();
+        session.choose_model(Task::Mask, "mobilesam");
+        set(session.models.lane(Task::Mask), |status| {
+            status.busy = Some("Downloading SAM 2".into());
+            status.busy_model = Some("sam2.1-hiera-tiny");
+        });
+        assert!(session.ensure_roto_model(true).unwrap_err().contains("another model operation"));
+        assert!(session.retry_installed_model(Task::Mask, "mobilesam", true).unwrap_err().contains("another model operation"));
+        assert!(session.models.status(Task::Mask).busy.is_some());
+        assert!(!session.roto_model_loading());
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn downloads_do_not_block_an_inactive_model_or_retry_a_failed_load() {
+        crate::tests::roto::hold_roto_cache_test_lock();
+        let dir = std::env::temp_dir().join(format!("ec-model-download-state-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let info = seg::info("mobilesam").unwrap();
+        std::fs::File::create(dir.join(info.file_name)).unwrap().set_len(info.size).unwrap();
+        let mut session = Session { models_dir: Some(dir.clone()), ..Default::default() };
+        session.choose_model(Task::Mask, info.id);
+        let lane = session.models.lane(Task::Mask).clone();
+        spawn(&lane, "Roto Brush", "Downloading another model".into(), true, None, "sam2.1-hiera-tiny", |_| Err("download failed".into()));
+        assert_eq!(session.models.status(Task::Mask).error.as_deref(), Some("download failed"));
+        assert!(session.models.status(Task::Mask).load_error.is_none());
+        let error = session.ensure_roto_model(true).unwrap_err();
+        assert!(!error.contains("download failed"), "the installed model must be loaded despite a download failure");
+        let failure = session.models.status(Task::Mask).load_error;
+        assert!(failure.is_some(), "the synthetic weights were actually loaded and rejected");
+        for download_failed in [true, false] {
+            spawn(&lane, "Roto Brush", "Downloading another model".into(), true, None, "sam2.1-hiera-tiny", move |_| {
+                if download_failed { Err("download failed".into()) } else { Ok("downloaded".into()) }
+            });
+            session.poll_models();
+            session.reload_roto_model();
+            let status = session.models.status(Task::Mask);
+            assert_eq!(status.load_error, failure, "a download must not clear the selected model's load failure");
+            assert!(status.busy.is_none(), "polling and strokes must not retry a failed model");
+            assert!(session.ensure_roto_model(true).unwrap_err().contains(failure.as_deref().unwrap()));
+            assert!(session.roto_model_notice(true).unwrap().contains(failure.as_deref().unwrap()));
+        }
+        crate::effects::roto::set_model(None);
+        std::fs::remove_dir_all(dir).unwrap();
+    }
+
+    #[test]
+    fn installing_an_unselected_model_keeps_the_selected_models_load_failure() {
+        crate::tests::roto::hold_roto_cache_test_lock();
+        let mut session = Session::default();
+        session.choose_model(Task::Mask, "mobilesam");
+        set(session.models.lane(Task::Mask), |s| {
+            s.error = Some("selected model failed".into());
+            s.load_error = s.error.clone();
+        });
+        let before = session.models.status(Task::Mask);
+        for wait in [false, true] {
+            assert!(!session.retry_installed_model(Task::Mask, "sam2.1-hiera-tiny", wait).unwrap());
+            assert_eq!(session.models.status(Task::Mask), before);
+        }
+        // Installing the selected weights is an explicit retry, even if the installed path
+        // has since gone away (no load is started from this session's missing model folder).
+        assert!(session.retry_installed_model(Task::Mask, "mobilesam", false).unwrap());
+        assert!(session.models.status(Task::Mask).load_error.is_none());
+        assert!(session.models.status(Task::Mask).error.is_none());
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[test]
+    fn installing_selected_weights_with_wait_finishes_the_replacement_load() {
+        crate::tests::roto::hold_roto_cache_test_lock();
+        let dir = std::env::temp_dir().join(format!("ec-model-install-running-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let info = seg::info("mobilesam").unwrap();
+        std::fs::File::create(dir.join(info.file_name)).unwrap().set_len(info.size).unwrap();
+        let mut session = Session { models_dir: Some(dir.clone()), ..Default::default() };
+        session.choose_model(Task::Mask, info.id);
+        let generation = session.models.status(Task::Mask).generation;
+        let lane = session.models.lane(Task::Mask).clone();
+        spawn(&lane, "Roto Brush", "Loading the previous file".into(), false, Some(generation), info.id, move |status| {
+            let started = Instant::now();
+            while status.lock().unwrap().generation == generation {
+                if started.elapsed() > Duration::from_secs(3) {
+                    return Err("test did not start the replacement".into());
+                }
+                std::thread::sleep(Duration::from_millis(1));
+            }
+            Err("previous file failed".into())
+        });
+        assert!(session.retry_installed_model(Task::Mask, info.id, true).unwrap_err().contains("SHA-256"));
+        let status = session.models.status(Task::Mask);
+        assert!(status.busy.is_none());
+        assert!(
+            status.load_error.as_ref().is_some_and(|error| error.contains("SHA-256")),
+            "wait must finish loading the replacement weights and report their actual validation error"
+        );
+        assert_ne!(status.error.as_deref(), Some("previous file failed"));
+        crate::effects::roto::set_model(None);
+        std::fs::remove_dir_all(dir).unwrap();
+    }
+
+    #[test]
+    fn browser_models_exclude_native_trackers_and_keep_portable_models() {
+        let browser: Vec<_> = models_for_platform(Task::Mask, true).map(|m| m.id).collect();
+        assert_eq!(browser, ["mobilesam"]);
+        let desktop: Vec<_> = models_for_platform(Task::Mask, false).map(|m| m.id).collect();
+        assert_eq!(desktop, ["mobilesam", "sam2.1-hiera-tiny", "sam2.1-hiera-small", "sam2.1-hiera-base-plus", "sam2.1-hiera-large"]);
+        for wasm in [false, true] {
+            assert_eq!(models_for_platform(Task::Face, wasm).map(|m| m.id).collect::<Vec<_>>(), ["mediapipe-face"]);
+        }
+    }
+}
diff --git a/crates/engine/src/roto.rs b/crates/engine/src/analysis/roto.rs
similarity index 81%
rename from crates/engine/src/roto.rs
rename to crates/engine/src/analysis/roto.rs
index 49f53d39b..67b0afc68 100644
--- a/crates/engine/src/roto.rs
+++ b/crates/engine/src/analysis/roto.rs
@@ -6,7 +6,7 @@
 //! `wait`; in the browser the background is a Web Worker whose segmentations stream back,
 //! [`crate::offload`]), frame by frame outward from the base frame, rendering the effect's input
 //! (`Renderer::layer_input`, source → masks → the effects above it). `roto.freeze` runs the same
-//! pass and stores the final mattes in the effect (one undo step). [`sync`], run after every
+//! pass and stores the final mattes in the effect (one undo step). `sync`, run after every
 //! edit, keeps each instance's hidden Input Key equal to a signature of what its frames are made
 //! of (the layer's source and timing, its masks and the effects above it) and drops frozen
 //! mattes made from other frames.
@@ -22,7 +22,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 
 use effectcraft_effects::object_matte as om;
-use effectcraft_effects::roto::{self as fx, FROZEN, FrozenCache, INPUT_KEY};
+use effectcraft_effects::roto::{self as fx, FROZEN, FrozenCache, INPUT_KEY, TRACKED};
 use effectcraft_effects::{Params, flatten_params};
 use effectcraft_keyframe::Value;
 use effectcraft_project::{GroupKind, ItemId, ItemKind, Layer, LayerId, Project, PropGroup, Uid};
@@ -51,6 +51,9 @@ pub struct RotoOptions {
     pub boundary_color: [f64; 3],
     /// Start propagating in the background after each stroke.
     pub auto_propagate: bool,
+    /// The object new strokes belong to (0 is the first). With a tracker every object is followed on its own
+    /// and their mattes are united; the classic engine treats all foreground strokes as one object.
+    pub object: u32,
 }
 
 impl Default for RotoOptions {
@@ -63,10 +66,14 @@ impl Default for RotoOptions {
             overlay_opacity: 50.0,
             boundary_color: [1.0, 0.25, 0.75],
             auto_propagate: true,
+            object: 0,
         }
     }
 }
 
+/// The highest object id (SAM 2 follows up to 32 objects in one pass).
+pub const MAX_OBJECT_ID: u32 = 31;
+
 pub const VIEWS: [&str; 4] = ["alphaBoundary", "alpha", "alphaOverlay", "none"];
 
 /// What a job does.
@@ -112,6 +119,10 @@ pub struct RotoProgress {
     pub error: Option<String>,
     /// The job works on an Object Matte (else a Roto Brush & Refine Edge).
     pub object_matte: bool,
+    /// What the model's tracker found, when one followed the object (SAM 2).
+    pub tracked: Option<fx::TrackSummary>,
+    /// Why the tracker was not used, when a tracking model was chosen but the classic engine ran.
+    pub tracker_note: Option<String>,
 }
 
 impl RotoProgress {
@@ -131,6 +142,8 @@ pub struct RotoShared {
     pub cancel: AtomicBool,
     pub state: Mutex<RotoProgress>,
     frozen: Mutex<Option<FrozenCache>>,
+    /// The tracker's frames, as the saved tracking (JSON) to store with the instance.
+    saved: Mutex<Option<String>>,
 }
 
 pub struct RotoJob {
@@ -249,6 +262,7 @@ pub(crate) fn sync(before: &Project, after: &mut Project) -> Vec<(ItemId, LayerI
             set_str(g, INPUT_KEY, key);
             if had {
                 set_str(g, FROZEN, String::new());
+                set_str(g, TRACKED, String::new());
             }
         }
     }
@@ -279,7 +293,7 @@ pub(crate) fn params_at(p: &Project, cid: ItemId, layer: &Layer, g: &PropGroup,
 }
 
 /// The layer's source size (layer pixels).
-pub(crate) fn layer_size(p: &Project, comp: &effectcraft_project::Comp, layer: &Layer) -> [f64; 2] {
+pub fn layer_size(p: &Project, comp: &effectcraft_project::Comp, layer: &Layer) -> [f64; 2] {
     effectcraft_render::effect_bounds(p, comp, layer).0
 }
 
@@ -432,10 +446,49 @@ async fn run_work(w: Work, shared: &RotoShared) {
         s.object_matte = w.object_matte;
     }
     let cancel = || shared.cancel.load(Ordering::Relaxed);
-    let chain = fx::Chain::new(&w.params, w.size, w.fps, 1.0);
+    let mut chain = fx::Chain::new(&w.params, w.size, w.fps, 1.0);
+    if w.task == RotoTask::Propagate && !w.object_matte {
+        chain.prepare_propagation();
+    }
     let model = fx::installed_model();
     let key = if w.object_matte { om::frozen_key(&w.params, w.size, w.fps, model.as_deref()) } else { fx::frozen_key(&w.params, w.size, w.fps) };
     let mut frozen = FrozenCache { key, ..Default::default() };
+    // A tracking model (SAM 2) follows the object through the whole span in one pass; the loop
+    // below then finds every frame cached. Without one (or if it fails) nothing changes: the
+    // classic engine runs frame by frame.
+    if w.task == RotoTask::Propagate && !w.object_matte && chain.has_tracker() {
+        let mut get = |g: i64| src.get(g);
+        let mut report = |n: usize| {
+            let mut s = lock(&shared.state);
+            s.done = n as u64;
+            s.elapsed = t0.elapsed().as_secs_f64();
+            s.fps = if s.elapsed > 0.0 { s.done as f64 / s.elapsed } else { 0.0 };
+            crate::offload::report(s.done, s.total);
+        };
+        let result = chain.track_frames(Some(&w.frames), &mut get, &cancel, &mut report);
+        if cancel() {
+            let mut s = lock(&shared.state);
+            s.cancelled = true;
+            s.finished = true;
+            return;
+        }
+        // The frames it followed replace the saved tracking (see `poll_roto_job`): none if it failed.
+        *lock(&shared.saved) = Some(match &result {
+            Ok(_) => fx::tracks_of(&chain).map(|t| t.to_json()).unwrap_or_default(),
+            Err(_) => String::new(),
+        });
+        if result.is_err() {
+            chain.forget_tracking();
+        }
+        let mut s = lock(&shared.state);
+        match result {
+            Ok(summary) => s.tracked = summary,
+            Err(e) => s.tracker_note = Some(format!("tracker unavailable, classic engine used: {e}")),
+        }
+    } else if w.task == RotoTask::Propagate && !w.object_matte {
+        // With the classic engine, Propagate leaves no saved tracking behind.
+        *lock(&shared.saved) = Some(String::new());
+    }
     for (k, f) in w.frames.iter().enumerate() {
         if cancel() {
             let mut s = lock(&shared.state);
@@ -450,7 +503,18 @@ async fn run_work(w: Work, shared: &RotoShared) {
             (RotoTask::Propagate, true) => om::ensure(&w.params, w.size, w.fps, *f, model.clone(), &mut get, &cancel).is_some(),
             (RotoTask::Freeze, true) => {
                 let img = get(*f);
-                match img.map(|img| (om::frame_matte(&w.params, w.size, w.fps, *f, 1.0, &img, model.clone(), &mut get, &cancel), img)) {
+                match img.map(|img| {
+                    (
+                        om::frame_matte(
+                            &w.params,
+                            &om::MatteFrame { layer_size: w.size, fps: w.fps, frame: *f, scale: 1.0, img: &img },
+                            model.clone(),
+                            &mut get,
+                            &cancel,
+                        ),
+                        img,
+                    )
+                }) {
                     Some((om::FrameMatte::Alpha(a), img)) => {
                         frozen.size = [img.width as usize, img.height as usize];
                         frozen.frames.insert(*f, fx::freeze_frame(&a, &[]));
@@ -581,9 +645,37 @@ impl Session {
         }
     }
 
+    /// Whether the tracking saved with Roto Brush `effect` covers every frame a Freeze would write.
+    fn freeze_is_saved(&self, comp: ItemId, layer: LayerId, effect: Uid) -> bool {
+        let Some(c) = self.project.comp(comp) else { return false };
+        let Some(l) = c.layer(layer) else { return false };
+        let Some(g) = l.effects().and_then(|f| f.groups().find(|g| g.uid == effect)).filter(|g| is_roto(g)) else { return false };
+        let pstat = params_static(g);
+        let d = fx::data(&pstat);
+        if d.is_empty() {
+            return false;
+        }
+        let t = comp_time_of(c, l, d.base.unwrap_or(0));
+        let params = params_at(&self.project, comp, l, g, t, self.expr.as_deref());
+        fx::saved_covers(&params, layer_size(&self.project, c, l), c.frame_rate.as_f64(), &job_frames(&d, Direction::Both))
+    }
+
+    /// Whether `effect` on `layer` segments with the model Settings chose: Object Matte always,
+    /// Roto Brush unless it is version 1.0 (the classic engine).
+    pub(crate) fn uses_roto_model(&self, comp: ItemId, layer: LayerId, effect: Uid) -> bool {
+        let g = self.project.comp(comp).and_then(|c| c.layer(layer)).and_then(|l| l.effects()).and_then(|f| f.groups().find(|g| g.uid == effect));
+        g.is_some_and(|g| is_object_matte(g) || fx::uses_model(&params_static(g)))
+    }
+
     /// Start propagating (or freezing) Roto Brush `effect` on `layer`. `wait`: block until done
     /// (wasm32 always does). Returns the number of frames.
     pub fn start_roto(&mut self, comp: ItemId, layer: LayerId, effect: Uid, task: RotoTask, dir: Direction, wait: bool) -> Result<usize, String> {
+        // The model must be in use before the job starts: otherwise it would run on the classic
+        // engine without saying so.
+        // A Freeze whose frames all have saved tracking reads them without the model.
+        if self.uses_roto_model(comp, layer, effect) && !(task == RotoTask::Freeze && self.freeze_is_saved(comp, layer, effect)) {
+            self.ensure_roto_model(wait)?;
+        }
         if self.is_roto_running() {
             if !wait {
                 return Err("a Roto Brush job is already running".into());
@@ -686,6 +778,17 @@ impl Session {
         Ok(n)
     }
 
+    /// Save the tracker's frames in the instance, unless its strokes changed while it tracked. No undo
+    /// step: the frames are a cache of the strokes and the span (a stale copy is ignored).
+    fn save_tracks(&mut self, cid: ItemId, lid: LayerId, uid: Uid, strokes: &str, json: String) {
+        let p = Arc::make_mut(&mut self.project);
+        if let Some(g) = p.comp_mut(cid).and_then(|c| c.layer_mut(lid)).and_then(|l| l.props.find_group_mut(uid))
+            && guard_of(g) == strokes
+        {
+            set_str(g, TRACKED, json);
+        }
+    }
+
     /// Finish a done job: Freeze writes the frozen mattes (one undo step).
     fn poll_roto_job(&mut self) -> bool {
         let Some(job) = &self.roto_job else { return false };
@@ -712,6 +815,10 @@ impl Session {
             RotoTask::Propagate => {
                 let verb = if job.object_matte { "tracked" } else { "propagated" };
                 self.events.push(Event::Toast { message: format!("{name}: {verb} {} frame(s) in {:.1} s", st.done, st.elapsed), error: false });
+                // The frames the tracker followed are saved with the instance.
+                if let Some(json) = lock(&job.shared.saved).take() {
+                    self.save_tracks(job.comp, job.layer, job.effect, &job.strokes, json);
+                }
                 // Rendered frames depend on the cache: redraw.
                 self.bump();
             }
@@ -746,17 +853,39 @@ impl Session {
     pub fn poll_roto(&mut self, auto: bool) -> bool {
         self.poll_models();
         let changed = self.poll_roto_job();
-        if auto && self.roto_job.is_none() && self.offloaded_roto().is_none() && self.state.roto.auto_propagate {
+        // Edited instances stay pending while the model they will segment with is still loading.
+        let loading = self.roto_model_loading();
+        if auto && self.roto_job.is_none() && self.offloaded_roto().is_none() && self.state.roto.auto_propagate && !loading {
             while let Some((c, l, e)) = self.roto_pending.first().copied() {
                 self.roto_pending.remove(0);
-                if self.start_roto(c, l, e, RotoTask::Propagate, Direction::Both, false).is_ok() {
-                    return true;
+                match self.start_roto(c, l, e, RotoTask::Propagate, Direction::Both, false) {
+                    Ok(_) => return true,
+                    Err(message) => self.events.push(Event::Toast { message, error: true }),
                 }
             }
         }
         changed
     }
 
+    /// How far to trust the frames a tracker followed (SAM 2), by layer frame: its confidence and
+    /// whether the object was absent. Frames the classic engine made have no entry.
+    pub fn roto_trust(&self, comp: ItemId, layer: LayerId, effect: Uid) -> BTreeMap<i64, fx::FrameTrust> {
+        let mut out = BTreeMap::new();
+        let Some(c) = self.project.comp(comp) else { return out };
+        let Some(l) = c.layer(layer) else { return out };
+        let Some(g) = l.props.find_group(effect) else { return out };
+        if is_object_matte(g) {
+            return out;
+        }
+        let ch = fx::Chain::new(&params_static(g), layer_size(&self.project, c, l), c.frame_rate.as_f64(), 1.0);
+        for f in ch.keys.keys() {
+            if let Some(t) = ch.trust_at(*f) {
+                out.insert(*f, t);
+            }
+        }
+        out
+    }
+
     /// The computed frames of an instance (full resolution), by layer frame.
     pub fn roto_computed(&self, comp: ItemId, layer: LayerId, effect: Uid) -> BTreeMap<i64, bool> {
         let mut out = BTreeMap::new();
diff --git a/crates/engine/src/tracking.rs b/crates/engine/src/analysis/tracking.rs
similarity index 99%
rename from crates/engine/src/tracking.rs
rename to crates/engine/src/analysis/tracking.rs
index 434cdd8af..221b28602 100644
--- a/crates/engine/src/tracking.rs
+++ b/crates/engine/src/analysis/tracking.rs
@@ -197,7 +197,8 @@ pub(crate) struct Work {
 }
 
 /// The layer's source frame at comp time `t` at 100 % (layer pixels + offset = image pixels).
-/// Footage at its native size is used straight from the footage source (no copy).
+/// Footage at its native size is used straight from the footage source (no copy unless its
+/// Cineon Settings convert it).
 pub(crate) fn source_frame(
     r: &Renderer,
     project: &Project,
@@ -207,7 +208,7 @@ pub(crate) fn source_frame(
     t: Tick,
     expr: Option<&dyn ExprHost>,
 ) -> Option<(Arc<Image>, [f64; 2])> {
-    let ctx = EvalCtx { project, comp_id: cid, comp, time: t, expr, footage: None };
+    let ctx = EvalCtx { project, comp_id: cid, comp, time: t, expr, footage: None, property_overrides: &[], media_overrides: &[] };
     if let effectcraft_project::LayerSource::Footage { item } = &layer.source
         && let Some(effectcraft_project::ItemKind::Footage(f)) = project.item(*item).map(|i| &i.kind)
         && f.has_video
@@ -215,7 +216,7 @@ pub(crate) fn source_frame(
         && img.width == f.width
         && img.height == f.height
     {
-        return Some((img, [0.0; 2]));
+        return Some((effectcraft_render::cineon_frame(img, f), [0.0; 2]));
     }
     let buf = r.layer_source(&ctx, layer)?;
     if (buf.scale - 1.0).abs() > 1e-9 && buf.scale > 0.0 {
diff --git a/crates/engine/src/warp.rs b/crates/engine/src/analysis/warp.rs
similarity index 96%
rename from crates/engine/src/warp.rs
rename to crates/engine/src/analysis/warp.rs
index 7928a5cab..71ee45ee6 100644
--- a/crates/engine/src/warp.rs
+++ b/crates/engine/src/analysis/warp.rs
@@ -4,10 +4,10 @@
 //! the Warp Stabilizer, `Renderer::layer_input`) for every frame between the layer's In and Out
 //! points on a background thread, and feeds the frames to `effectcraft_track::stabilize`'s
 //! analyzer (step 1 of 2, "Analyzing in background"); step 2 ("Stabilizing") derives the
-//! stabilization plan once to validate the result. When the job finishes, the analysis is
+//! stabilization plan once to validate and cache the result. When the job finishes, the analysis is
 //! written into the effect's hidden Analysis parameter as one undo step, together with a key of
 //! what it was made from (the layer's source, In/Out, start, stretch and Time Remap). Edits that
-//! change those clear the analysis ([`invalidate`], run after every edit) and queue the effect
+//! change those clear the analysis (`invalidate`, run after every edit) and queue the effect
 //! for re-analysis, which frontends start with [`Session::poll_warp`] (After Effects re-analyses
 //! automatically too).
 
@@ -21,7 +21,7 @@ use effectcraft_project::{GroupKind, ItemId, ItemKind, Layer, LayerId, LayerSour
 use effectcraft_raster::Image;
 use effectcraft_render::{EvalCtx, ExprHost, FootageSource, LayerCache, Renderer};
 use effectcraft_time::Tick;
-use effectcraft_track::stabilize::{AnalyzeOpts, Analyzer, StabSettings, WarpAnalysis};
+use effectcraft_track::stabilize::{AnalyzeOpts, Analyzer, WarpAnalysis};
 use serde::Serialize;
 
 use crate::tracking::lock;
@@ -245,9 +245,8 @@ async fn run_work(w: WarpWork, shared: &WarpShared) {
     let lt0 = layer.layer_time(w.times[0]).seconds();
     let fd = if w.times.len() > 1 { layer.layer_time(w.times[1]).seconds() - lt0 } else { comp.frame_duration().seconds() };
     let a = an.finish(lt0, fd);
-    // Step 2: derive a plan once (validates the motion and warms nothing else up).
-    let plan = effectcraft_track::stabilize::plan(&a, &StabSettings { fps: if fd > 0.0 { 1.0 / fd } else { 30.0 }, ..Default::default() });
-    if plan.warps.len() != a.frames.len() || plan.warps.iter().any(|h| h.0.iter().flatten().any(|v| !v.is_finite())) {
+    // Plan from the stored JSON, exactly as rendering does, and retain it for the first render.
+    if !warp_stab::prepare_default_plan(&a.to_json()) {
         return fail("the stabilization could not be computed");
     }
     *lock(&shared.result) = Some(a);
diff --git a/crates/engine/src/background.rs b/crates/engine/src/background.rs
new file mode 100644
index 000000000..d4d404d95
--- /dev/null
+++ b/crates/engine/src/background.rs
@@ -0,0 +1,3 @@
+pub mod jobs;
+pub mod offload;
+pub mod remote;
diff --git a/crates/engine/src/jobs.rs b/crates/engine/src/background/jobs.rs
similarity index 100%
rename from crates/engine/src/jobs.rs
rename to crates/engine/src/background/jobs.rs
diff --git a/crates/engine/src/offload.rs b/crates/engine/src/background/offload.rs
similarity index 72%
rename from crates/engine/src/offload.rs
rename to crates/engine/src/background/offload.rs
index 135822d57..23cff4da6 100644
--- a/crates/engine/src/offload.rs
+++ b/crates/engine/src/background/offload.rs
@@ -992,317 +992,4 @@ pub(crate) fn merge_group(base: &PropGroup, live: &PropGroup, result: &PropGroup
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn round<T: Serialize + for<'de> Deserialize<'de>>(v: &T) -> String {
-        let a = serde_json::to_string(v).unwrap();
-        let back: T = serde_json::from_str(&a).unwrap();
-        let b = serde_json::to_string(&back).unwrap();
-        assert_eq!(a, b);
-        a
-    }
-
-    /// A group with properties `a` (uid 2) and `b` (uid 3) and a sub-group (uid 4) holding `c`
-    /// (uid 5).
-    fn group() -> PropGroup {
-        use effectcraft_keyframe::Value as KV;
-        use effectcraft_project::{Node, Property};
-        let mut sub = PropGroup::new(4, "sub", "Sub");
-        sub.children.push(Node::Prop(Property::new(5, "c", "C", KV::Scalar(0.0))));
-        let mut g = PropGroup::new(1, "fx", "Effect");
-        g.children.push(Node::Prop(Property::new(2, "a", "A", KV::Scalar(0.0))));
-        g.children.push(Node::Prop(Property::new(3, "b", "B", KV::Scalar(0.0))));
-        g.children.push(Node::Group(sub));
-        g
-    }
-
-    fn set(g: &mut PropGroup, uid: Uid, v: f64) {
-        g.find_mut(uid).unwrap().value = effectcraft_keyframe::Value::Scalar(v);
-    }
-
-    fn get(g: &PropGroup, uid: Uid) -> f64 {
-        match g.find(uid).unwrap().value {
-            effectcraft_keyframe::Value::Scalar(v) => v,
-            ref v => panic!("{v:?}"),
-        }
-    }
-
-    #[test]
-    fn analysis_results_merge_with_edits_made_meanwhile() {
-        use effectcraft_project::Node;
-        let base = group();
-        // The user changes `a` and switches the effect off; the analysis writes `b` and `c`.
-        let mut live = base.clone();
-        set(&mut live, 2, 1.0);
-        live.enabled = false;
-        let mut result = base.clone();
-        set(&mut result, 3, 2.0);
-        set(&mut result, 5, 3.0);
-        let m = merge_group(&base, &live, &result).unwrap();
-        assert_eq!((get(&m, 2), get(&m, 3), get(&m, 5), m.enabled), (1.0, 2.0, 3.0, false));
-        // Unchanged on either side: the other side wins whole.
-        assert_eq!(merge_group(&base, &base, &result).unwrap(), result);
-        assert_eq!(merge_group(&base, &live, &base).unwrap(), live);
-        // Both changed `b`, differently: a conflict (nothing is applied). The same way: fine.
-        let mut both = live.clone();
-        set(&mut both, 3, 9.0);
-        assert!(merge_group(&base, &both, &result).is_none());
-        set(&mut both, 3, 2.0);
-        assert_eq!(get(&merge_group(&base, &both, &result).unwrap(), 3), 2.0);
-        // The analysis adds a child (a result group) while the user edits `a`: both kept.
-        let mut added = result.clone();
-        added.children.push(Node::Group(PropGroup::new(6, "out", "Output")));
-        let m = merge_group(&base, &live, &added).unwrap();
-        assert!(m.find_group(6).is_some() && get(&m, 2) == 1.0);
-        // The analysis drops the sub-group the user didn't touch: dropped.
-        let mut dropped = result.clone();
-        dropped.children.retain(|n| !matches!(n, Node::Group(g) if g.uid == 4));
-        let m = merge_group(&base, &live, &dropped).unwrap();
-        assert!(m.find_group(4).is_none() && get(&m, 2) == 1.0);
-        // …but if the user changed something in it, that's a conflict.
-        let mut touched = live.clone();
-        set(&mut touched, 5, 7.0);
-        assert!(merge_group(&base, &touched, &dropped).is_none());
-    }
-
-    #[test]
-    fn protocol_round_trips() {
-        let mut s = Session::default();
-        s.execute("file.openDemoProject", serde_json::json!({})).unwrap();
-        let comp = s.active_comp_id().unwrap();
-        s.execute("renderQueue.add", serde_json::json!({})).unwrap();
-        let item = s.project.render_queue[0].clone();
-        let reqs = [
-            WorkerJob::Render { items: vec![vec![(item.clone(), "/out.gif".into())]] },
-            WorkerJob::Warp { comp, layer: LayerId(3), effect: 9 },
-            WorkerJob::WarpPlan { comp, layer: LayerId(3), effect: 9, time: Tick::from_seconds_f64(0.5) },
-            WorkerJob::RotoFreeze { comp, layer: LayerId(3), effect: 9 },
-            WorkerJob::Camera { comp, layer: LayerId(3), effect: 9 },
-            WorkerJob::RotoPropagate { comp, layer: LayerId(3), effect: 9, direction: crate::roto::Direction::Forward },
-            WorkerJob::Track {
-                comp,
-                layer: LayerId(1),
-                tracker: 4,
-                direction: crate::tracking::Direction::Backward,
-                settings: TrackerSettings::default(),
-                points: vec![PointValues {
-                    uid: 5,
-                    spec: effectcraft_track::PointSpec { center: [1.0, 2.0], feature_size: [3.0, 4.0], search_offset: [0.5, 0.0], search_size: [9.0, 9.0] },
-                    attach_offset: [0.25, -1.0],
-                }],
-                times: vec![Tick::ZERO, Tick::from_seconds_f64(0.5)],
-            },
-            WorkerJob::MaskTrack {
-                comp,
-                layer: LayerId(2),
-                mask: 7,
-                direction: crate::tracking::Direction::Forward,
-                path: ShapePath::ellipse([10.0, 20.0], 5.0, 6.0),
-                method: MaskMethod::Perspective,
-                times: vec![Tick::from_seconds_f64(1.0)],
-            },
-            WorkerJob::ContentFill {
-                plan: Box::new(crate::commands::content_fill::FillPlan {
-                    comp,
-                    layer: LayerId(2),
-                    name: "Clip".into(),
-                    width: 4,
-                    height: 3,
-                    times: vec![Tick::ZERO],
-                    method: "object".into(),
-                    lighting: 0.5,
-                    expand: 1,
-                    reference: Some((LayerId(1), Tick::ZERO)),
-                    dir: "/Fill/Clip_Fill_1".into(),
-                }),
-            },
-        ];
-        for job in reqs {
-            let kind = job.kind();
-            let req = WorkerRequest { id: 42, project: s.project.to_json(), files: footage_files(&s.project), job };
-            let t = round(&req);
-            assert!(t.contains("\"kind\":"), "{kind:?}");
-            let back: WorkerRequest = serde_json::from_str(&t).unwrap();
-            assert_eq!(back.job.kind(), kind);
-            assert_eq!(Project::from_json(&back.project).unwrap(), *s.project);
-        }
-        let g = s.active_comp().unwrap().layers[0].props.clone();
-        for r in [
-            WorkerReply::Render { state: JobState { current: Some(3), done: 4, total: 10, items_total: 1, ..Default::default() } },
-            WorkerReply::Item { update: ItemUpdate::Started { id: 3, unix: 1_700_000_000 } },
-            WorkerReply::Item { update: ItemUpdate::Finished { id: 3, status: RenderStatus::Failed("x".into()), seconds: 1.5, output: Some("/a.gif".into()) } },
-            WorkerReply::Progress { done: 1, total: 2 },
-            WorkerReply::WarpPlan {
-                key: [1, u64::MAX],
-                summary: Box::new(effectcraft_effects::warp_stab::PlanSummary {
-                    warps: vec![[[1.0, 0.0, 2.5], [0.0, 1.0, -1.0], [0.0, 0.0, 1.0]]],
-                    auto_scale: 1.08,
-                    crop: Some([1.0, 2.0, 300.0, 200.0]),
-                    valid_fraction: 0.9,
-                }),
-            },
-            WorkerReply::Group { comp, layer: LayerId(1), group: Box::new(g), message: "ok".into() },
-            WorkerReply::Segs { segs: vec![SegData::new(5, &effectcraft_track::roto::FrameSeg::empty(4, 3))] },
-            WorkerReply::Fill {
-                plan: Box::new(crate::commands::content_fill::FillPlan {
-                    comp,
-                    layer: LayerId(2),
-                    name: "Clip".into(),
-                    width: 4,
-                    height: 3,
-                    times: vec![Tick::ZERO],
-                    method: "object".into(),
-                    lighting: 0.5,
-                    expand: 1,
-                    reference: Some((LayerId(1), Tick::ZERO)),
-                    dir: "/Fill/Clip_Fill_1".into(),
-                }),
-                files: vec!["/Fill/Clip_Fill_1/fill_00000.png".into()],
-            },
-            WorkerReply::Failed { error: "boom".into() },
-            WorkerReply::Done,
-        ] {
-            let t = round(&r);
-            assert!(t.starts_with("{\"type\":"), "{t}");
-        }
-    }
-
-    /// An [`Offload`] that runs the job right away in a second session, through JSON (what a
-    /// Web Worker does, minus the threads).
-    struct Inline;
-    impl Offload for Inline {
-        fn start(&self, req: WorkerRequest, inbox: Arc<Inbox>) -> Result<(), String> {
-            let req: WorkerRequest = serde_json::from_str(&serde_json::to_string(&req).unwrap()).unwrap();
-            let mut w = Session { exporter: Some(Arc::new(crate::rq_tests::MockExporter { log: Default::default() })), ..Default::default() };
-            let post: Post = Rc::new(move |r| inbox.push(serde_json::from_str(&serde_json::to_string(&r).unwrap()).unwrap()));
-            run_request(&mut w, req, &post);
-            Ok(())
-        }
-        fn cancel(&self, _: u64) {}
-    }
-
-    #[test]
-    fn render_runs_through_the_offload() {
-        let mut s = Session {
-            exporter: Some(Arc::new(crate::rq_tests::MockExporter { log: Default::default() })),
-            offload: Some(Arc::new(Inline)),
-            ..Default::default()
-        };
-        s.execute("file.openDemoProject", serde_json::json!({})).unwrap();
-        s.execute("renderQueue.add", serde_json::json!({"output": "/x.gif"})).unwrap();
-        let ids = s.start_render(false).unwrap();
-        // (the inline offload has replied already; replies are applied when polled)
-        s.poll_render();
-        assert!(s.render_job.is_none());
-        let it = s.project.render_queue.iter().find(|i| i.id == ids[0]).unwrap();
-        assert_eq!(it.status, RenderStatus::Done, "{:?}", it.status);
-        assert!(it.last_output.as_deref().is_some_and(|o| o.ends_with("x.gif")));
-        // `wait` renders inline.
-        s.execute("renderQueue.add", serde_json::json!({"output": "/y.gif"})).unwrap();
-        s.start_render(true).unwrap();
-        assert!(s.render_job.is_none() || s.render_job.as_ref().unwrap().remote.is_none());
-    }
-
-    /// Runs jobs in a session sharing `footage` (the synthetic clip of the tracking tests).
-    struct InlineWith(Arc<dyn effectcraft_render::FootageSource>);
-    impl Offload for InlineWith {
-        fn start(&self, req: WorkerRequest, inbox: Arc<Inbox>) -> Result<(), String> {
-            let req: WorkerRequest = serde_json::from_str(&serde_json::to_string(&req).unwrap()).unwrap();
-            let mut w = Session { footage: self.0.clone(), ..Default::default() };
-            let post: Post = Rc::new(move |r| inbox.push(serde_json::from_str(&serde_json::to_string(&r).unwrap()).unwrap()));
-            run_request(&mut w, req, &post);
-            Ok(())
-        }
-        fn cancel(&self, _: u64) {}
-    }
-
-    /// Never replies (a job still running); records cancellations.
-    #[derive(Default)]
-    struct Hanging(Mutex<Vec<u64>>);
-    impl Offload for Hanging {
-        fn start(&self, _: WorkerRequest, _: Arc<Inbox>) -> Result<(), String> {
-            Ok(())
-        }
-        fn cancel(&self, id: u64) {
-            self.0.lock().unwrap().push(id);
-        }
-    }
-
-    fn pose(f: u32) -> ([f64; 2], f64, f64) {
-        ([150.0 + 2.0 * f as f64, 110.0 + 1.0 * f as f64], 0.0, 1.0)
-    }
-
-    #[test]
-    fn track_analysis_runs_through_the_offload_as_one_undo_step() {
-        let (mut s, clip, _) = crate::tests_track::setup(crate::tests_track::patch_frames(pose));
-        s.offload = Some(Arc::new(InlineWith(s.footage.clone())));
-        s.execute("track.motion", serde_json::json!({})).unwrap();
-        s.execute("track.setPoint", serde_json::json!({"point": 1, "center": pose(0).0, "featureSize": [36, 36], "searchSize": [80, 80]})).unwrap();
-        let undo = s.history.undo.len();
-        s.execute("track.analyze", serde_json::json!({"direction": "forward"})).unwrap();
-        assert!(s.is_tracking() && s.track_job.is_none(), "offloaded, not on a thread");
-        assert!(s.track_progress().is_some());
-        assert!(s.poll_offload());
-        assert!(!s.is_tracking() && s.offloaded.is_empty());
-        let l = s.active_comp().unwrap().layer(clip).unwrap();
-        let tp = l.trackers().next().unwrap().0.track_points().next().unwrap().clone();
-        let fc = tp.get("featureCenter").unwrap();
-        assert_eq!(fc.keys.len(), 25);
-        let v = fc.value_at(crate::tests_track::frame_time(12)).as_vec2();
-        assert!((v[0] - pose(12).0[0]).abs() < 0.3 && (v[1] - pose(12).0[1]).abs() < 0.3, "{v:?}");
-        assert_eq!(s.history.undo.len(), undo + 1);
-        assert_eq!(s.history.undo.last().unwrap().0, "Analyze Track");
-        assert!(s.events.iter().any(|e| matches!(e, Event::Toast { message, error: false } if message.starts_with("Tracked"))));
-        assert!(s.undo());
-        let l = s.active_comp().unwrap().layer(clip).unwrap();
-        assert!(l.trackers().next().unwrap().0.track_points().next().unwrap().get("featureCenter").unwrap().keys.is_empty());
-        // `wait` runs inline.
-        s.redo();
-        s.execute("track.analyze", serde_json::json!({"direction": "forward", "wait": true})).ok();
-        assert!(s.offloaded.is_empty());
-    }
-
-    #[test]
-    fn cancelling_offloaded_jobs() {
-        let (mut s, _, _) = crate::tests_track::setup(crate::tests_track::patch_frames(pose));
-        let off = Arc::new(Hanging::default());
-        s.offload = Some(off.clone());
-        s.exporter = Some(Arc::new(crate::rq_tests::MockExporter { log: Default::default() }));
-        // Analysis: stopping drops the job, nothing is written.
-        s.execute("track.motion", serde_json::json!({})).unwrap();
-        let rev = s.revision;
-        s.execute("track.analyze", serde_json::json!({})).unwrap();
-        assert!(s.is_tracking());
-        assert!(s.execute("track.analyze", serde_json::json!({})).is_err(), "one at a time");
-        assert!(s.stop_track());
-        s.poll_offload();
-        assert!(!s.is_tracking());
-        assert_eq!(off.0.lock().unwrap().len(), 1);
-        assert!(s.events.iter().any(|e| matches!(e, Event::Toast { message, .. } if message.contains("stopped"))));
-        assert!(s.revision > rev);
-        // Render: the queued items become User Stopped.
-        s.execute("renderQueue.add", serde_json::json!({"output": "/a.gif"})).unwrap();
-        let ids = s.start_render(false).unwrap();
-        assert!(s.is_rendering());
-        assert!(s.stop_render());
-        s.poll_render();
-        assert!(!s.is_rendering());
-        assert_eq!(off.0.lock().unwrap().len(), 2);
-        let it = s.project.render_queue.iter().find(|i| i.id == ids[0]).unwrap();
-        assert_eq!(it.status, RenderStatus::UserStopped);
-    }
-
-    #[test]
-    fn progress_hook_is_scoped() {
-        report(1, 2); // no hook: nothing happens
-        let seen = Rc::new(RefCell::new(vec![]));
-        let s2 = seen.clone();
-        effectcraft_render::passes::block_on(with_hook(Box::new(move |d, t| s2.borrow_mut().push((d, t))), async {
-            report(1, 3);
-            report(2, 3);
-        }));
-        report(3, 3);
-        assert_eq!(*seen.borrow(), vec![(1, 3), (2, 3)]);
-    }
-}
+mod tests;
diff --git a/crates/engine/src/background/offload/tests.rs b/crates/engine/src/background/offload/tests.rs
new file mode 100644
index 000000000..c08623189
--- /dev/null
+++ b/crates/engine/src/background/offload/tests.rs
@@ -0,0 +1,309 @@
+use super::*;
+
+fn round<T: Serialize + for<'de> Deserialize<'de>>(v: &T) -> String {
+    let a = serde_json::to_string(v).unwrap();
+    let back: T = serde_json::from_str(&a).unwrap();
+    let b = serde_json::to_string(&back).unwrap();
+    assert_eq!(a, b);
+    a
+}
+
+/// A group with properties `a` (uid 2) and `b` (uid 3) and a sub-group (uid 4) holding `c`
+/// (uid 5).
+fn group() -> PropGroup {
+    use effectcraft_keyframe::Value as KV;
+    use effectcraft_project::{Node, Property};
+    let mut sub = PropGroup::new(4, "sub", "Sub");
+    sub.children.push(Node::Prop(Property::new(5, "c", "C", KV::Scalar(0.0))));
+    let mut g = PropGroup::new(1, "fx", "Effect");
+    g.children.push(Node::Prop(Property::new(2, "a", "A", KV::Scalar(0.0))));
+    g.children.push(Node::Prop(Property::new(3, "b", "B", KV::Scalar(0.0))));
+    g.children.push(Node::Group(sub));
+    g
+}
+
+fn set(g: &mut PropGroup, uid: Uid, v: f64) {
+    g.find_mut(uid).unwrap().value = effectcraft_keyframe::Value::Scalar(v);
+}
+
+fn get(g: &PropGroup, uid: Uid) -> f64 {
+    match g.find(uid).unwrap().value {
+        effectcraft_keyframe::Value::Scalar(v) => v,
+        ref v => panic!("{v:?}"),
+    }
+}
+
+#[test]
+fn analysis_results_merge_with_edits_made_meanwhile() {
+    use effectcraft_project::Node;
+    let base = group();
+    // The user changes `a` and switches the effect off; the analysis writes `b` and `c`.
+    let mut live = base.clone();
+    set(&mut live, 2, 1.0);
+    live.enabled = false;
+    let mut result = base.clone();
+    set(&mut result, 3, 2.0);
+    set(&mut result, 5, 3.0);
+    let m = merge_group(&base, &live, &result).unwrap();
+    assert_eq!((get(&m, 2), get(&m, 3), get(&m, 5), m.enabled), (1.0, 2.0, 3.0, false));
+    // Unchanged on either side: the other side wins whole.
+    assert_eq!(merge_group(&base, &base, &result).unwrap(), result);
+    assert_eq!(merge_group(&base, &live, &base).unwrap(), live);
+    // Both changed `b`, differently: a conflict (nothing is applied). The same way: fine.
+    let mut both = live.clone();
+    set(&mut both, 3, 9.0);
+    assert!(merge_group(&base, &both, &result).is_none());
+    set(&mut both, 3, 2.0);
+    assert_eq!(get(&merge_group(&base, &both, &result).unwrap(), 3), 2.0);
+    // The analysis adds a child (a result group) while the user edits `a`: both kept.
+    let mut added = result.clone();
+    added.children.push(Node::Group(PropGroup::new(6, "out", "Output")));
+    let m = merge_group(&base, &live, &added).unwrap();
+    assert!(m.find_group(6).is_some() && get(&m, 2) == 1.0);
+    // The analysis drops the sub-group the user didn't touch: dropped.
+    let mut dropped = result.clone();
+    dropped.children.retain(|n| !matches!(n, Node::Group(g) if g.uid == 4));
+    let m = merge_group(&base, &live, &dropped).unwrap();
+    assert!(m.find_group(4).is_none() && get(&m, 2) == 1.0);
+    // …but if the user changed something in it, that's a conflict.
+    let mut touched = live.clone();
+    set(&mut touched, 5, 7.0);
+    assert!(merge_group(&base, &touched, &dropped).is_none());
+}
+
+#[test]
+fn protocol_round_trips() {
+    let mut s = Session::default();
+    s.execute("file.openDemoProject", serde_json::json!({})).unwrap();
+    let comp = s.active_comp_id().unwrap();
+    s.execute("renderQueue.add", serde_json::json!({})).unwrap();
+    let item = s.project.render_queue[0].clone();
+    let reqs = [
+        WorkerJob::Render { items: vec![vec![(item.clone(), "/out.gif".into())]] },
+        WorkerJob::Warp { comp, layer: LayerId(3), effect: 9 },
+        WorkerJob::WarpPlan { comp, layer: LayerId(3), effect: 9, time: Tick::from_seconds_f64(0.5) },
+        WorkerJob::RotoFreeze { comp, layer: LayerId(3), effect: 9 },
+        WorkerJob::Camera { comp, layer: LayerId(3), effect: 9 },
+        WorkerJob::RotoPropagate { comp, layer: LayerId(3), effect: 9, direction: crate::roto::Direction::Forward },
+        WorkerJob::Track {
+            comp,
+            layer: LayerId(1),
+            tracker: 4,
+            direction: crate::tracking::Direction::Backward,
+            settings: TrackerSettings::default(),
+            points: vec![PointValues {
+                uid: 5,
+                spec: effectcraft_track::PointSpec { center: [1.0, 2.0], feature_size: [3.0, 4.0], search_offset: [0.5, 0.0], search_size: [9.0, 9.0] },
+                attach_offset: [0.25, -1.0],
+            }],
+            times: vec![Tick::ZERO, Tick::from_seconds_f64(0.5)],
+        },
+        WorkerJob::MaskTrack {
+            comp,
+            layer: LayerId(2),
+            mask: 7,
+            direction: crate::tracking::Direction::Forward,
+            path: ShapePath::ellipse([10.0, 20.0], 5.0, 6.0),
+            method: MaskMethod::Perspective,
+            times: vec![Tick::from_seconds_f64(1.0)],
+        },
+        WorkerJob::ContentFill {
+            plan: Box::new(crate::commands::content_fill::FillPlan {
+                comp,
+                layer: LayerId(2),
+                name: "Clip".into(),
+                width: 4,
+                height: 3,
+                times: vec![Tick::ZERO],
+                method: "object".into(),
+                lighting: 0.5,
+                expand: 1,
+                reference: Some((LayerId(1), Tick::ZERO)),
+                dir: "/Fill/Clip_Fill_1".into(),
+            }),
+        },
+    ];
+    for job in reqs {
+        let kind = job.kind();
+        let req = WorkerRequest { id: 42, project: s.project.to_json(), files: footage_files(&s.project), job };
+        let t = round(&req);
+        assert!(t.contains("\"kind\":"), "{kind:?}");
+        let back: WorkerRequest = serde_json::from_str(&t).unwrap();
+        assert_eq!(back.job.kind(), kind);
+        assert_eq!(Project::from_json(&back.project).unwrap(), *s.project);
+    }
+    let g = s.active_comp().unwrap().layers[0].props.clone();
+    for r in [
+        WorkerReply::Render { state: JobState { current: Some(3), done: 4, total: 10, items_total: 1, ..Default::default() } },
+        WorkerReply::Item { update: ItemUpdate::Started { id: 3, unix: 1_700_000_000 } },
+        WorkerReply::Item { update: ItemUpdate::Finished { id: 3, status: RenderStatus::Failed("x".into()), seconds: 1.5, output: Some("/a.gif".into()) } },
+        WorkerReply::Progress { done: 1, total: 2 },
+        WorkerReply::WarpPlan {
+            key: [1, u64::MAX],
+            summary: Box::new(effectcraft_effects::warp_stab::PlanSummary {
+                warps: vec![[[1.0, 0.0, 2.5], [0.0, 1.0, -1.0], [0.0, 0.0, 1.0]]],
+                auto_scale: 1.08,
+                crop: Some([1.0, 2.0, 300.0, 200.0]),
+                valid_fraction: 0.9,
+            }),
+        },
+        WorkerReply::Group { comp, layer: LayerId(1), group: Box::new(g), message: "ok".into() },
+        WorkerReply::Segs { segs: vec![SegData::new(5, &effectcraft_track::roto::FrameSeg::empty(4, 3))] },
+        WorkerReply::Fill {
+            plan: Box::new(crate::commands::content_fill::FillPlan {
+                comp,
+                layer: LayerId(2),
+                name: "Clip".into(),
+                width: 4,
+                height: 3,
+                times: vec![Tick::ZERO],
+                method: "object".into(),
+                lighting: 0.5,
+                expand: 1,
+                reference: Some((LayerId(1), Tick::ZERO)),
+                dir: "/Fill/Clip_Fill_1".into(),
+            }),
+            files: vec!["/Fill/Clip_Fill_1/fill_00000.png".into()],
+        },
+        WorkerReply::Failed { error: "boom".into() },
+        WorkerReply::Done,
+    ] {
+        let t = round(&r);
+        assert!(t.starts_with("{\"type\":"), "{t}");
+    }
+}
+
+/// An [`Offload`] that runs the job right away in a second session, through JSON (what a
+/// Web Worker does, minus the threads).
+struct Inline;
+impl Offload for Inline {
+    fn start(&self, req: WorkerRequest, inbox: Arc<Inbox>) -> Result<(), String> {
+        let req: WorkerRequest = serde_json::from_str(&serde_json::to_string(&req).unwrap()).unwrap();
+        let mut w = Session { exporter: Some(Arc::new(crate::rq_tests::MockExporter { log: Default::default() })), ..Default::default() };
+        let post: Post = Rc::new(move |r| inbox.push(serde_json::from_str(&serde_json::to_string(&r).unwrap()).unwrap()));
+        run_request(&mut w, req, &post);
+        Ok(())
+    }
+    fn cancel(&self, _: u64) {}
+}
+
+#[test]
+fn render_runs_through_the_offload() {
+    let mut s =
+        Session { exporter: Some(Arc::new(crate::rq_tests::MockExporter { log: Default::default() })), offload: Some(Arc::new(Inline)), ..Default::default() };
+    s.execute("file.openDemoProject", serde_json::json!({})).unwrap();
+    s.execute("renderQueue.add", serde_json::json!({"output": "/x.gif"})).unwrap();
+    let ids = s.start_render(false).unwrap();
+    // (the inline offload has replied already; replies are applied when polled)
+    s.poll_render();
+    assert!(s.render_job.is_none());
+    let it = s.project.render_queue.iter().find(|i| i.id == ids[0]).unwrap();
+    assert_eq!(it.status, RenderStatus::Done, "{:?}", it.status);
+    assert!(it.last_output.as_deref().is_some_and(|o| o.ends_with("x.gif")));
+    // `wait` renders inline.
+    s.execute("renderQueue.add", serde_json::json!({"output": "/y.gif"})).unwrap();
+    s.start_render(true).unwrap();
+    assert!(s.render_job.is_none() || s.render_job.as_ref().unwrap().remote.is_none());
+}
+
+/// Runs jobs in a session sharing `footage` (the synthetic clip of the tracking tests).
+struct InlineWith(Arc<dyn effectcraft_render::FootageSource>);
+impl Offload for InlineWith {
+    fn start(&self, req: WorkerRequest, inbox: Arc<Inbox>) -> Result<(), String> {
+        let req: WorkerRequest = serde_json::from_str(&serde_json::to_string(&req).unwrap()).unwrap();
+        let mut w = Session { footage: self.0.clone(), ..Default::default() };
+        let post: Post = Rc::new(move |r| inbox.push(serde_json::from_str(&serde_json::to_string(&r).unwrap()).unwrap()));
+        run_request(&mut w, req, &post);
+        Ok(())
+    }
+    fn cancel(&self, _: u64) {}
+}
+
+/// Never replies (a job still running); records cancellations.
+#[derive(Default)]
+struct Hanging(Mutex<Vec<u64>>);
+impl Offload for Hanging {
+    fn start(&self, _: WorkerRequest, _: Arc<Inbox>) -> Result<(), String> {
+        Ok(())
+    }
+    fn cancel(&self, id: u64) {
+        self.0.lock().unwrap().push(id);
+    }
+}
+
+fn pose(f: u32) -> ([f64; 2], f64, f64) {
+    ([150.0 + 2.0 * f as f64, 110.0 + 1.0 * f as f64], 0.0, 1.0)
+}
+
+#[test]
+fn track_analysis_runs_through_the_offload_as_one_undo_step() {
+    let (mut s, clip, _) = crate::tests::track::setup(crate::tests::track::patch_frames(pose));
+    s.offload = Some(Arc::new(InlineWith(s.footage.clone())));
+    s.execute("track.motion", serde_json::json!({})).unwrap();
+    s.execute("track.setPoint", serde_json::json!({"point": 1, "center": pose(0).0, "featureSize": [36, 36], "searchSize": [80, 80]})).unwrap();
+    let undo = s.history.undo.len();
+    s.execute("track.analyze", serde_json::json!({"direction": "forward"})).unwrap();
+    assert!(s.is_tracking() && s.track_job.is_none(), "offloaded, not on a thread");
+    assert!(s.track_progress().is_some());
+    assert!(s.poll_offload());
+    assert!(!s.is_tracking() && s.offloaded.is_empty());
+    let l = s.active_comp().unwrap().layer(clip).unwrap();
+    let tp = l.trackers().next().unwrap().0.track_points().next().unwrap().clone();
+    let fc = tp.get("featureCenter").unwrap();
+    assert_eq!(fc.keys.len(), 25);
+    let v = fc.value_at(crate::tests::track::frame_time(12)).as_vec2();
+    assert!((v[0] - pose(12).0[0]).abs() < 0.3 && (v[1] - pose(12).0[1]).abs() < 0.3, "{v:?}");
+    assert_eq!(s.history.undo.len(), undo + 1);
+    assert_eq!(s.history.undo.last().unwrap().0, "Analyze Track");
+    assert!(s.events.iter().any(|e| matches!(e, Event::Toast { message, error: false } if message.starts_with("Tracked"))));
+    assert!(s.undo());
+    let l = s.active_comp().unwrap().layer(clip).unwrap();
+    assert!(l.trackers().next().unwrap().0.track_points().next().unwrap().get("featureCenter").unwrap().keys.is_empty());
+    // `wait` runs inline.
+    s.redo();
+    s.execute("track.analyze", serde_json::json!({"direction": "forward", "wait": true})).ok();
+    assert!(s.offloaded.is_empty());
+}
+
+#[test]
+fn cancelling_offloaded_jobs() {
+    let (mut s, _, _) = crate::tests::track::setup(crate::tests::track::patch_frames(pose));
+    let off = Arc::new(Hanging::default());
+    s.offload = Some(off.clone());
+    s.exporter = Some(Arc::new(crate::rq_tests::MockExporter { log: Default::default() }));
+    // Analysis: stopping drops the job, nothing is written.
+    s.execute("track.motion", serde_json::json!({})).unwrap();
+    let rev = s.revision;
+    s.execute("track.analyze", serde_json::json!({})).unwrap();
+    assert!(s.is_tracking());
+    assert!(s.execute("track.analyze", serde_json::json!({})).is_err(), "one at a time");
+    assert!(s.stop_track());
+    s.poll_offload();
+    assert!(!s.is_tracking());
+    assert_eq!(off.0.lock().unwrap().len(), 1);
+    assert!(s.events.iter().any(|e| matches!(e, Event::Toast { message, .. } if message.contains("stopped"))));
+    assert!(s.revision > rev);
+    // Render: the queued items become User Stopped.
+    s.execute("renderQueue.add", serde_json::json!({"output": "/a.gif"})).unwrap();
+    let ids = s.start_render(false).unwrap();
+    assert!(s.is_rendering());
+    assert!(s.stop_render());
+    s.poll_render();
+    assert!(!s.is_rendering());
+    assert_eq!(off.0.lock().unwrap().len(), 2);
+    let it = s.project.render_queue.iter().find(|i| i.id == ids[0]).unwrap();
+    assert_eq!(it.status, RenderStatus::UserStopped);
+}
+
+#[test]
+fn progress_hook_is_scoped() {
+    report(1, 2); // no hook: nothing happens
+    let seen = Rc::new(RefCell::new(vec![]));
+    let s2 = seen.clone();
+    effectcraft_render::passes::block_on(with_hook(Box::new(move |d, t| s2.borrow_mut().push((d, t))), async {
+        report(1, 3);
+        report(2, 3);
+    }));
+    report(3, 3);
+    assert_eq!(*seen.borrow(), vec![(1, 3), (2, 3)]);
+}
diff --git a/crates/engine/src/remote.rs b/crates/engine/src/background/remote.rs
similarity index 54%
rename from crates/engine/src/remote.rs
rename to crates/engine/src/background/remote.rs
index 7d592abe2..6539ac767 100644
--- a/crates/engine/src/remote.rs
+++ b/crates/engine/src/background/remote.rs
@@ -9,7 +9,7 @@
 //!   added, changed or removed; arrays element-wise when their length is unchanged, else
 //!   replaced). Lossless (unlike JSON Merge Patch, `null` values survive).
 //! - [`Mirror`] (page side): what the worker holds; turns the next project revision into a
-//!   [`FrameMsg::Sync`] (a full project the first time, a diff afterwards).
+//!   [`FrameMsg::Project`] the first time and [`FrameMsg::Patch`] for subsequent diffs.
 //! - [`FrameServer`] (worker side): applies syncs, relayed Roto Brush segmentations and render
 //!   requests, and renders frames as premultiplied RGBA8 ([`rgba8_premultiplied`]).
 //!
@@ -301,7 +301,7 @@ impl FrameServer {
     }
 
     /// Identity of virtual footage files, used when native metadata cannot describe the path.
-    /// Called from [`FrameServer::load`], not from the UI thread's cache lookup.
+    /// Called from `FrameServer::load`, not from the UI thread's cache lookup.
     pub fn set_virtual_id(&mut self, id: Option<Arc<dyn Fn(&str) -> Option<(u64, u64)> + Send + Sync>>) {
         self.virtual_id = id;
     }
@@ -472,331 +472,4 @@ impl FrameServer {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::Session;
-    use serde_json::json;
-
-    fn round<T: Serialize + for<'de> Deserialize<'de>>(v: &T) -> T {
-        serde_json::from_str(&serde_json::to_string(v).unwrap()).unwrap()
-    }
-
-    #[test]
-    fn diff_and_patch_round_trip() {
-        let a = json!({"a": 1, "b": [1, 2, {"c": null}], "d": {"e": "x", "f": [1]}, "g": null});
-        let b = json!({"a": 2, "b": [1, 3, {"c": 4}], "d": {"f": [1, 2]}, "g": null, "h": {"i": null}});
-        let ops = diff(&a, &b);
-        assert!(!ops.is_empty());
-        let mut x = a.clone();
-        patch(&mut x, &round(&ops)).unwrap();
-        assert_eq!(x, b);
-        // Removal and the reverse direction.
-        let mut y = b.clone();
-        patch(&mut y, &diff(&b, &a)).unwrap();
-        assert_eq!(y, a);
-        assert!(diff(&a, &a).is_empty());
-        // A whole-document change.
-        let mut z = json!(1);
-        patch(&mut z, &diff(&json!(1), &json!([1]))).unwrap();
-        assert_eq!(z, json!([1]));
-        // A patch for another document fails cleanly.
-        assert!(patch(&mut json!(3), &diff(&a, &b)).is_err());
-    }
-
-    fn server(s: &Session) -> FrameServer {
-        FrameServer::new(s.footage.clone(), s.expr.clone())
-    }
-
-    /// Pixels the page itself would render.
-    fn local(s: &Session, comp: ItemId, t: Tick, opts: RenderOpts) -> Vec<u8> {
-        let mut r = Renderer::new(&s.project, s.footage.as_ref(), opts);
-        r.expr = s.expr.as_deref();
-        rgba8_premultiplied(&r.comp_frame(comp, t))
-    }
-
-    /// Layer buffers through the disk store: a worker's slow buffers queue up as entries; the
-    /// page plans what another worker fetches before its frame (recent misses on disk); that
-    /// worker's mid-render lookups find them and the pixels match.
-    #[test]
-    fn layer_buffers_go_through_the_disk_store() {
-        use effectcraft_render::disk_cache::{DiskIndex, Kind, LayerPrefetch};
-        let mut s = Session::default();
-        s.execute("file.openDemoProject", json!({})).unwrap();
-        let comp = s.active_comp_id().unwrap();
-        let opts = RenderOpts { scale: 0.25, ..Default::default() };
-        let t = Tick::from_seconds_f64(1.0);
-        let req = |id: u64, layers: bool, prefetch: Vec<String>| {
-            round(&FrameMsg::Render { id, revision: s.revision, comp, time: t, opts: Box::new(opts), disk: None, layers, prefetch })
-        };
-        let worker = || {
-            let mut w = server(&s);
-            let store = Arc::new(PrefetchStore::new(64 << 20).with_min_ms(0));
-            w.set_layer_store(Some(store.clone()));
-            let mut m = Mirror::default();
-            assert!(w.handle(round(&m.sync(s.revision, &s.project).unwrap())).is_empty());
-            (w, store)
-        };
-        let unhex = |v: &[String]| v.iter().map(|k| u128::from_str_radix(k, 16).unwrap()).collect::<Vec<u128>>();
-        // Worker A: everything misses; its buffers queue up for the disk.
-        let (mut a, store_a) = worker();
-        let out = a.handle(req(1, true, vec![]));
-        let (FrameReply::Frame { layer_misses, layer_hits, .. }, Some(px_a)) = &out[0] else { panic!("{:?}", out[0].0) };
-        assert!(!layer_misses.is_empty() && layer_hits.is_empty());
-        let writes = store_a.take_writes();
-        assert!(!writes.is_empty());
-        assert!(writes.iter().all(|(k, _)| (*k >> 64) as u64 == a.salt()), "keys are salted per project");
-        let mut index = DiskIndex::default();
-        let mut disk = std::collections::HashMap::new();
-        for (k, e) in writes {
-            index.insert(Kind::Layer, k, e.len() as u64);
-            disk.insert(k, e);
-        }
-        index.insert(Kind::Frame, 1, 10);
-        // The page: recent misses that are on disk, most recent first.
-        let mut plan = LayerPrefetch::default();
-        plan.note_misses(unhex(layer_misses));
-        let keys = plan.plan(&index, 64);
-        assert!(!keys.is_empty() && keys.len() <= index.len());
-        // Worker B fetches them before its first frame: its lookups hit.
-        let (mut b, store_b) = worker();
-        for k in &keys {
-            assert!(store_b.provide(*k, &disk[k]));
-        }
-        assert!(!store_b.provide(1, b"damaged"));
-        let out = b.handle(req(1, true, keys.iter().map(|k| format!("{k:032x}")).collect()));
-        let (FrameReply::Frame { layer_misses: mb, layer_hits: hb, .. }, Some(px_b)) = &out[0] else { panic!("{:?}", out[0].0) };
-        assert_eq!(unhex(hb).len(), keys.len(), "every fetched buffer was used");
-        assert!(mb.len() < layer_misses.len());
-        assert_eq!(px_a, px_b);
-        assert_eq!(*px_b, local(&s, comp, t, opts));
-        // Nothing new to write: what B rendered itself was rendered by A too.
-        assert!(store_b.take_writes().iter().all(|(k, _)| disk.contains_key(k)));
-        // Without `layers` the store is not consulted.
-        let (mut c, store_c) = worker();
-        c.handle(req(1, false, vec![]));
-        assert!(store_c.take_misses().is_empty() && store_c.take_writes().is_empty());
-        // Purge empties the store.
-        b.handle(round(&FrameMsg::Purge));
-        assert!(!store_b.has(keys[0]));
-        // LRU across frames and layers in the shared index: a touched layer outlives the frame.
-        index.touch(Kind::Layer, keys[0]);
-        let order = index.lru_order();
-        assert_eq!(order.last(), Some(&(Kind::Layer, keys[0])));
-        assert!(order.iter().position(|e| *e == (Kind::Frame, 1)).unwrap() < order.len() - 1);
-    }
-
-    #[test]
-    fn replica_follows_edits_through_diffs_and_renders_the_same_frames() {
-        let mut s = Session::default();
-        s.execute("file.openDemoProject", json!({})).unwrap();
-        let comp = s.active_comp_id().unwrap();
-        let opts = RenderOpts { scale: 0.25, guides: true, ..Default::default() };
-        let mut m = Mirror::default();
-        let mut w = server(&s);
-        let send = |m: FrameMsg, w: &mut FrameServer| w.handle(round(&m));
-        // First sync: the whole project.
-        let first = m.sync(s.revision, &s.project).unwrap();
-        assert!(matches!(first, FrameMsg::Project { .. }));
-        assert!(send(first, &mut w).is_empty());
-        assert!(m.sync(s.revision, &s.project).is_none(), "nothing new");
-        let t = Tick::from_seconds_f64(1.0);
-        let render = |w: &mut FrameServer, rev: u64, id: u64| {
-            w.handle(round(&FrameMsg::Render { id, revision: rev, comp, time: t, opts: Box::new(opts), disk: None, layers: false, prefetch: vec![] }))
-        };
-        let out = render(&mut w, s.revision, 1);
-        let (FrameReply::Frame { id, width, height, .. }, Some(px)) = &out[0] else { panic!("{:?}", out[0].0) };
-        assert_eq!((*id, *width as usize * *height as usize * 4), (1, px.len()));
-        assert_eq!(*px, local(&s, comp, t, opts));
-        // An edit travels as a small diff; the replica renders the edited frame.
-        s.execute("layer.newSolid", json!({"color": "#ff8800", "name": "Orange"})).unwrap();
-        let msg = m.sync(s.revision, &s.project).unwrap();
-        let FrameMsg::Patch { ops, .. } = &msg else { panic!("expected a patch") };
-        assert!(!ops.is_empty() && serde_json::to_string(ops).unwrap().len() < s.project.to_json().len() / 2);
-        assert!(send(msg, &mut w).is_empty());
-        assert_eq!(**w.project().unwrap(), *s.project);
-        let out = render(&mut w, s.revision, 2);
-        assert_eq!(out[0].1.as_deref(), Some(&local(&s, comp, t, opts)[..]));
-        // A request for another revision is refused as stale.
-        let out = render(&mut w, s.revision + 7, 3);
-        assert!(matches!(out[0].0, FrameReply::Failed { id: 3, stale: true, .. }));
-        // A patch from the wrong base asks for a resync; the mirror then sends the project.
-        let bad = FrameMsg::Patch { from: 999, revision: 1000, ops: vec![] };
-        assert!(matches!(send(bad, &mut w)[0].0, FrameReply::Resync { .. }));
-        m.reset();
-        assert!(matches!(m.sync(s.revision, &s.project), Some(FrameMsg::Project { .. })));
-    }
-
-    #[test]
-    fn frame_messages_round_trip() {
-        for m in [
-            FrameMsg::Purge,
-            FrameMsg::Segs { segs: vec![SegData { key: 7, data: "AAAA".into() }] },
-            FrameMsg::Render {
-                id: 3,
-                revision: 4,
-                comp: ItemId(2),
-                time: Tick::from_seconds_f64(0.5),
-                opts: Box::new(RenderOpts { scale: 0.5, draft: true, roi: Some([1.0, 2.0, 3.0, 4.0]), ..Default::default() }),
-                disk: Some(format!("{:032x}", 0xabcdu128)),
-                layers: true,
-                prefetch: vec![format!("{:032x}", 7u128)],
-            },
-        ] {
-            let a = serde_json::to_string(&m).unwrap();
-            assert_eq!(serde_json::to_string(&round(&m)).unwrap(), a);
-            assert!(a.starts_with("{\"type\":"), "{a}");
-        }
-        for r in [
-            FrameReply::Frame { id: 1, width: 2, height: 3, ms: 4.5, passes: 2, gpu: true, layer_misses: vec!["0a".into()], layer_hits: vec![] },
-            FrameReply::Stored { key: "00ff".into(), bytes: 9, layer: false },
-            FrameReply::Stored { key: "00fe".into(), bytes: 8, layer: true },
-            FrameReply::Info { gpu: Some("Adapter (BrowserWebGpu)".into()), error: None },
-            FrameReply::Failed { id: 1, error: "x".into(), stale: true },
-            FrameReply::Resync { error: "y".into() },
-        ] {
-            assert_eq!(round(&r), r);
-        }
-    }
-
-    /// An accelerator with deferred readbacks: a GPU effect chain is "read back" one
-    /// [`Deferred::settle`] after it was first asked for (computed with the CPU effects, so the
-    /// finished frame equals the CPU render); until then it misses and returns its input.
-    #[derive(Default)]
-    struct Deferred {
-        ready: std::sync::Mutex<std::collections::HashSet<u64>>,
-        asked: std::sync::Mutex<std::collections::HashSet<u64>>,
-        gate: Arc<std::sync::atomic::AtomicBool>,
-        chains: std::sync::atomic::AtomicUsize,
-        auto: effectcraft_render::AutoPick,
-    }
-
-    impl Deferred {
-        fn settle(&self) {
-            let asked: Vec<u64> = self.asked.lock().unwrap().drain().collect();
-            self.ready.lock().unwrap().extend(asked);
-        }
-    }
-
-    impl Accelerator for Deferred {
-        fn name(&self) -> String {
-            "deferred".into()
-        }
-        fn comp_frame(&self, _: &Renderer, _: ItemId, _: Tick) -> Option<Image> {
-            None
-        }
-        fn supports_effect(&self, id: &str) -> bool {
-            effectcraft_effects::GPU_EFFECTS.contains(&id)
-        }
-        fn effects(&self, chain: &[effectcraft_render::FxStep], buf: &effectcraft_effects::Buf, levels: Option<f32>) -> Option<effectcraft_effects::Buf> {
-            use std::hash::{Hash, Hasher};
-            let mut h = std::collections::hash_map::DefaultHasher::new();
-            for s in chain {
-                s.spec.id.hash(&mut h);
-                s.ctx.time.to_bits().hash(&mut h);
-            }
-            (buf.img.width, buf.img.height).hash(&mut h);
-            for p in &buf.img.data {
-                for c in p {
-                    c.to_bits().hash(&mut h);
-                }
-            }
-            let key = h.finish();
-            if !self.ready.lock().unwrap().contains(&key) {
-                self.asked.lock().unwrap().insert(key);
-                self.gate.store(true, std::sync::atomic::Ordering::Relaxed);
-                return Some(buf.clone());
-            }
-            self.chains.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-            let mut b = buf.clone();
-            for s in chain {
-                b = effectcraft_effects::apply(s.spec, &s.ctx, b);
-                if let Some(l) = levels {
-                    effectcraft_render::color::quantize(&mut b.img, l);
-                }
-            }
-            Some(b)
-        }
-        fn auto_pick(&self) -> Option<&effectcraft_render::AutoPick> {
-            Some(&self.auto)
-        }
-        fn frame_begin(&self) {
-            self.ready.lock().unwrap().clear();
-        }
-        fn pass_begin(&self) {
-            self.gate.store(false, std::sync::atomic::Ordering::Relaxed);
-        }
-        fn pass_missed(&self) -> bool {
-            self.gate.load(std::sync::atomic::Ordering::Relaxed)
-        }
-        fn miss_gate(&self) -> Option<Arc<std::sync::atomic::AtomicBool>> {
-            Some(self.gate.clone())
-        }
-    }
-
-    #[test]
-    fn deferred_readbacks_render_in_passes() {
-        let mut s = Session::default();
-        s.execute("file.openDemoProject", json!({})).unwrap();
-        let comp = s.active_comp_id().unwrap();
-        s.execute("layer.newSolid", json!({"color": "#3388ff", "name": "Blue", "width": 200, "height": 120})).unwrap();
-        s.execute("effect.apply", json!({"effect": "ec.blur.gaussian"})).unwrap();
-        s.execute("effect.apply", json!({"effect": "ec.stylize.glow"})).unwrap();
-        s.execute("layer.newSolid", json!({"color": "#ffcc00", "name": "Yellow", "width": 80, "height": 80})).unwrap();
-        s.execute("effect.apply", json!({"effect": "ec.color.levels"})).unwrap();
-        let opts = RenderOpts { scale: 0.25, backend: Backend::Gpu, ..Default::default() };
-        let t = Tick::from_seconds_f64(1.0);
-        let mut w = server(&s);
-        let acc = Arc::new(Deferred::default());
-        w.set_accel(Some(acc.clone()));
-        let mut m = Mirror::default();
-        w.handle(round(&m.sync(s.revision, &s.project).unwrap()));
-        let req = |id| round(&FrameMsg::Render { id, revision: s.revision, comp, time: t, opts: Box::new(opts), disk: None, layers: false, prefetch: vec![] });
-        assert!(w.handle(req(1)).is_empty() && w.waiting(), "the first pass misses");
-        let mut out = vec![];
-        for _ in 0..10 {
-            acc.settle();
-            out = w.resume();
-            if !w.waiting() {
-                break;
-            }
-        }
-        let (FrameReply::Frame { id: 1, passes, gpu: true, .. }, Some(px)) = &out[0] else { panic!("{:?}", out.first().map(|o| &o.0)) };
-        assert!(*passes >= 2, "{passes}");
-        assert!(acc.chains.load(std::sync::atomic::Ordering::Relaxed) >= 2);
-        // The same pixels as the CPU: no placeholder survived, in the frame or the layer cache.
-        assert_eq!(*px, local(&s, comp, t, RenderOpts { backend: Backend::Cpu, ..opts }));
-        let out = w.handle(req(2));
-        let out = if out.is_empty() {
-            acc.settle();
-            w.resume()
-        } else {
-            out
-        };
-        assert_eq!(out[0].1.as_deref(), Some(&px[..]));
-        // CPU requests never touch the accelerator; Auto times whole frames.
-        let cpu = RenderOpts { backend: Backend::Cpu, ..opts };
-        let out =
-            w.handle(round(&FrameMsg::Render { id: 3, revision: s.revision, comp, time: t, opts: Box::new(cpu), disk: None, layers: false, prefetch: vec![] }));
-        assert!(matches!(out[0].0, FrameReply::Frame { id: 3, passes: 1, gpu: false, .. }));
-        for id in 4..12 {
-            let auto = RenderOpts { backend: Backend::Auto, ..opts };
-            let mut out = w.handle(round(&FrameMsg::Render {
-                id,
-                revision: s.revision,
-                comp,
-                time: t,
-                opts: Box::new(auto),
-                disk: None,
-                layers: false,
-                prefetch: vec![],
-            }));
-            while w.waiting() {
-                acc.settle();
-                out = w.resume();
-            }
-            assert_eq!(out[0].1.as_deref(), Some(&px[..]), "frame {id}");
-        }
-        let st = acc.auto.stats(effectcraft_render::AutoKey::new(comp, opts.scale, false)).unwrap();
-        assert!(st.cpu_frames > 0 && st.gpu_frames > 0, "{st:?}");
-    }
-}
+mod tests;
diff --git a/crates/engine/src/background/remote/tests.rs b/crates/engine/src/background/remote/tests.rs
new file mode 100644
index 000000000..85f7a1807
--- /dev/null
+++ b/crates/engine/src/background/remote/tests.rs
@@ -0,0 +1,318 @@
+use super::*;
+use crate::Session;
+use serde_json::json;
+
+fn round<T: Serialize + for<'de> Deserialize<'de>>(v: &T) -> T {
+    serde_json::from_str(&serde_json::to_string(v).unwrap()).unwrap()
+}
+
+#[test]
+fn diff_and_patch_round_trip() {
+    let a = json!({"a": 1, "b": [1, 2, {"c": null}], "d": {"e": "x", "f": [1]}, "g": null});
+    let b = json!({"a": 2, "b": [1, 3, {"c": 4}], "d": {"f": [1, 2]}, "g": null, "h": {"i": null}});
+    let ops = diff(&a, &b);
+    assert!(!ops.is_empty());
+    let mut x = a.clone();
+    patch(&mut x, &round(&ops)).unwrap();
+    assert_eq!(x, b);
+    // Removal and the reverse direction.
+    let mut y = b.clone();
+    patch(&mut y, &diff(&b, &a)).unwrap();
+    assert_eq!(y, a);
+    assert!(diff(&a, &a).is_empty());
+    // A whole-document change.
+    let mut z = json!(1);
+    patch(&mut z, &diff(&json!(1), &json!([1]))).unwrap();
+    assert_eq!(z, json!([1]));
+    // A patch for another document fails cleanly.
+    assert!(patch(&mut json!(3), &diff(&a, &b)).is_err());
+}
+
+fn server(s: &Session) -> FrameServer {
+    FrameServer::new(s.footage.clone(), s.expr.clone())
+}
+
+/// Pixels the page itself would render.
+fn local(s: &Session, comp: ItemId, t: Tick, opts: RenderOpts) -> Vec<u8> {
+    let mut r = Renderer::new(&s.project, s.footage.as_ref(), opts);
+    r.expr = s.expr.as_deref();
+    rgba8_premultiplied(&r.comp_frame(comp, t))
+}
+
+/// Layer buffers through the disk store: a worker's slow buffers queue up as entries; the
+/// page plans what another worker fetches before its frame (recent misses on disk); that
+/// worker's mid-render lookups find them and the pixels match.
+#[test]
+fn layer_buffers_go_through_the_disk_store() {
+    use effectcraft_render::disk_cache::{DiskIndex, Kind, LayerPrefetch};
+    let mut s = Session::default();
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    let comp = s.active_comp_id().unwrap();
+    let opts = RenderOpts { scale: 0.25, ..Default::default() };
+    let t = Tick::from_seconds_f64(1.0);
+    let req = |id: u64, layers: bool, prefetch: Vec<String>| {
+        round(&FrameMsg::Render { id, revision: s.revision, comp, time: t, opts: Box::new(opts), disk: None, layers, prefetch })
+    };
+    let worker = || {
+        let mut w = server(&s);
+        let store = Arc::new(PrefetchStore::new(64 << 20).with_min_ms(0));
+        w.set_layer_store(Some(store.clone()));
+        let mut m = Mirror::default();
+        assert!(w.handle(round(&m.sync(s.revision, &s.project).unwrap())).is_empty());
+        (w, store)
+    };
+    let unhex = |v: &[String]| v.iter().map(|k| u128::from_str_radix(k, 16).unwrap()).collect::<Vec<u128>>();
+    // Worker A: everything misses; its buffers queue up for the disk.
+    let (mut a, store_a) = worker();
+    let out = a.handle(req(1, true, vec![]));
+    let (FrameReply::Frame { layer_misses, layer_hits, .. }, Some(px_a)) = &out[0] else { panic!("{:?}", out[0].0) };
+    assert!(!layer_misses.is_empty() && layer_hits.is_empty());
+    let writes = store_a.take_writes();
+    assert!(!writes.is_empty());
+    assert!(writes.iter().all(|(k, _)| (*k >> 64) as u64 == a.salt()), "keys are salted per project");
+    let mut index = DiskIndex::default();
+    let mut disk = std::collections::HashMap::new();
+    for (k, e) in writes {
+        index.insert(Kind::Layer, k, e.len() as u64);
+        disk.insert(k, e);
+    }
+    index.insert(Kind::Frame, 1, 10);
+    // The page: recent misses that are on disk, most recent first.
+    let mut plan = LayerPrefetch::default();
+    plan.note_misses(unhex(layer_misses));
+    let keys = plan.plan(&index, 64);
+    assert!(!keys.is_empty() && keys.len() <= index.len());
+    // Worker B fetches them before its first frame: its lookups hit.
+    let (mut b, store_b) = worker();
+    for k in &keys {
+        assert!(store_b.provide(*k, &disk[k]));
+    }
+    assert!(!store_b.provide(1, b"damaged"));
+    let out = b.handle(req(1, true, keys.iter().map(|k| format!("{k:032x}")).collect()));
+    let (FrameReply::Frame { layer_misses: mb, layer_hits: hb, .. }, Some(px_b)) = &out[0] else { panic!("{:?}", out[0].0) };
+    assert_eq!(unhex(hb).len(), keys.len(), "every fetched buffer was used");
+    assert!(mb.len() < layer_misses.len());
+    assert_eq!(px_a, px_b);
+    assert_eq!(*px_b, local(&s, comp, t, opts));
+    // Nothing new to write: what B rendered itself was rendered by A too.
+    assert!(store_b.take_writes().iter().all(|(k, _)| disk.contains_key(k)));
+    // Without `layers` the store is not consulted.
+    let (mut c, store_c) = worker();
+    c.handle(req(1, false, vec![]));
+    assert!(store_c.take_misses().is_empty() && store_c.take_writes().is_empty());
+    // Purge empties the store.
+    b.handle(round(&FrameMsg::Purge));
+    assert!(!store_b.has(keys[0]));
+    // LRU across frames and layers in the shared index: a touched layer outlives the frame.
+    index.touch(Kind::Layer, keys[0]);
+    let order = index.lru_order();
+    assert_eq!(order.last(), Some(&(Kind::Layer, keys[0])));
+    assert!(order.iter().position(|e| *e == (Kind::Frame, 1)).unwrap() < order.len() - 1);
+}
+
+#[test]
+fn replica_follows_edits_through_diffs_and_renders_the_same_frames() {
+    let mut s = Session::default();
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    let comp = s.active_comp_id().unwrap();
+    let opts = RenderOpts { scale: 0.25, guides: true, ..Default::default() };
+    let mut m = Mirror::default();
+    let mut w = server(&s);
+    let send = |m: FrameMsg, w: &mut FrameServer| w.handle(round(&m));
+    // First sync: the whole project.
+    let first = m.sync(s.revision, &s.project).unwrap();
+    assert!(matches!(first, FrameMsg::Project { .. }));
+    assert!(send(first, &mut w).is_empty());
+    assert!(m.sync(s.revision, &s.project).is_none(), "nothing new");
+    let t = Tick::from_seconds_f64(1.0);
+    let render = |w: &mut FrameServer, rev: u64, id: u64| {
+        w.handle(round(&FrameMsg::Render { id, revision: rev, comp, time: t, opts: Box::new(opts), disk: None, layers: false, prefetch: vec![] }))
+    };
+    let out = render(&mut w, s.revision, 1);
+    let (FrameReply::Frame { id, width, height, .. }, Some(px)) = &out[0] else { panic!("{:?}", out[0].0) };
+    assert_eq!((*id, *width as usize * *height as usize * 4), (1, px.len()));
+    assert_eq!(*px, local(&s, comp, t, opts));
+    // An edit travels as a small diff; the replica renders the edited frame.
+    s.execute("layer.newSolid", json!({"color": "#ff8800", "name": "Orange"})).unwrap();
+    let msg = m.sync(s.revision, &s.project).unwrap();
+    let FrameMsg::Patch { ops, .. } = &msg else { panic!("expected a patch") };
+    assert!(!ops.is_empty() && serde_json::to_string(ops).unwrap().len() < s.project.to_json().len() / 2);
+    assert!(send(msg, &mut w).is_empty());
+    assert_eq!(**w.project().unwrap(), *s.project);
+    let out = render(&mut w, s.revision, 2);
+    assert_eq!(out[0].1.as_deref(), Some(&local(&s, comp, t, opts)[..]));
+    // A request for another revision is refused as stale.
+    let out = render(&mut w, s.revision + 7, 3);
+    assert!(matches!(out[0].0, FrameReply::Failed { id: 3, stale: true, .. }));
+    // A patch from the wrong base asks for a resync; the mirror then sends the project.
+    let bad = FrameMsg::Patch { from: 999, revision: 1000, ops: vec![] };
+    assert!(matches!(send(bad, &mut w)[0].0, FrameReply::Resync { .. }));
+    m.reset();
+    assert!(matches!(m.sync(s.revision, &s.project), Some(FrameMsg::Project { .. })));
+}
+
+#[test]
+fn frame_messages_round_trip() {
+    for m in [
+        FrameMsg::Purge,
+        FrameMsg::Segs { segs: vec![SegData { key: 7, data: "AAAA".into() }] },
+        FrameMsg::Render {
+            id: 3,
+            revision: 4,
+            comp: ItemId(2),
+            time: Tick::from_seconds_f64(0.5),
+            opts: Box::new(RenderOpts { scale: 0.5, draft: true, roi: Some([1.0, 2.0, 3.0, 4.0]), ..Default::default() }),
+            disk: Some(format!("{:032x}", 0xabcdu128)),
+            layers: true,
+            prefetch: vec![format!("{:032x}", 7u128)],
+        },
+    ] {
+        let a = serde_json::to_string(&m).unwrap();
+        assert_eq!(serde_json::to_string(&round(&m)).unwrap(), a);
+        assert!(a.starts_with("{\"type\":"), "{a}");
+    }
+    for r in [
+        FrameReply::Frame { id: 1, width: 2, height: 3, ms: 4.5, passes: 2, gpu: true, layer_misses: vec!["0a".into()], layer_hits: vec![] },
+        FrameReply::Stored { key: "00ff".into(), bytes: 9, layer: false },
+        FrameReply::Stored { key: "00fe".into(), bytes: 8, layer: true },
+        FrameReply::Info { gpu: Some("Adapter (BrowserWebGpu)".into()), error: None },
+        FrameReply::Failed { id: 1, error: "x".into(), stale: true },
+        FrameReply::Resync { error: "y".into() },
+    ] {
+        assert_eq!(round(&r), r);
+    }
+}
+
+/// An accelerator with deferred readbacks: a GPU effect chain is "read back" one
+/// [`Deferred::settle`] after it was first asked for (computed with the CPU effects, so the
+/// finished frame equals the CPU render); until then it misses and returns its input.
+#[derive(Default)]
+struct Deferred {
+    ready: std::sync::Mutex<std::collections::HashSet<u64>>,
+    asked: std::sync::Mutex<std::collections::HashSet<u64>>,
+    gate: Arc<std::sync::atomic::AtomicBool>,
+    chains: std::sync::atomic::AtomicUsize,
+    auto: effectcraft_render::AutoPick,
+}
+
+impl Deferred {
+    fn settle(&self) {
+        let asked: Vec<u64> = self.asked.lock().unwrap().drain().collect();
+        self.ready.lock().unwrap().extend(asked);
+    }
+}
+
+impl Accelerator for Deferred {
+    fn name(&self) -> String {
+        "deferred".into()
+    }
+    fn comp_frame(&self, _: &Renderer, _: ItemId, _: Tick) -> Option<Image> {
+        None
+    }
+    fn supports_effect(&self, id: &str) -> bool {
+        effectcraft_effects::GPU_EFFECTS.contains(&id)
+    }
+    fn effects(&self, chain: &[effectcraft_render::FxStep], buf: &effectcraft_effects::Buf, levels: Option<f32>) -> Option<effectcraft_effects::Buf> {
+        use std::hash::{Hash, Hasher};
+        let mut h = std::collections::hash_map::DefaultHasher::new();
+        for s in chain {
+            s.spec.id.hash(&mut h);
+            s.ctx.time.to_bits().hash(&mut h);
+        }
+        (buf.img.width, buf.img.height).hash(&mut h);
+        for p in &buf.img.data {
+            for c in p {
+                c.to_bits().hash(&mut h);
+            }
+        }
+        let key = h.finish();
+        if !self.ready.lock().unwrap().contains(&key) {
+            self.asked.lock().unwrap().insert(key);
+            self.gate.store(true, std::sync::atomic::Ordering::Relaxed);
+            return Some(buf.clone());
+        }
+        self.chains.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        let mut b = buf.clone();
+        for s in chain {
+            b = effectcraft_effects::apply(s.spec, &s.ctx, b);
+            if let Some(l) = levels {
+                effectcraft_render::color::quantize(&mut b.img, l);
+            }
+        }
+        Some(b)
+    }
+    fn auto_pick(&self) -> Option<&effectcraft_render::AutoPick> {
+        Some(&self.auto)
+    }
+    fn frame_begin(&self) {
+        self.ready.lock().unwrap().clear();
+    }
+    fn pass_begin(&self) {
+        self.gate.store(false, std::sync::atomic::Ordering::Relaxed);
+    }
+    fn pass_missed(&self) -> bool {
+        self.gate.load(std::sync::atomic::Ordering::Relaxed)
+    }
+    fn miss_gate(&self) -> Option<Arc<std::sync::atomic::AtomicBool>> {
+        Some(self.gate.clone())
+    }
+}
+
+#[test]
+fn deferred_readbacks_render_in_passes() {
+    let mut s = Session::default();
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    let comp = s.active_comp_id().unwrap();
+    s.execute("layer.newSolid", json!({"color": "#3388ff", "name": "Blue", "width": 200, "height": 120})).unwrap();
+    s.execute("effect.apply", json!({"effect": "ec.blur.gaussian"})).unwrap();
+    s.execute("effect.apply", json!({"effect": "ec.stylize.glow"})).unwrap();
+    s.execute("layer.newSolid", json!({"color": "#ffcc00", "name": "Yellow", "width": 80, "height": 80})).unwrap();
+    s.execute("effect.apply", json!({"effect": "ec.color.levels"})).unwrap();
+    let opts = RenderOpts { scale: 0.25, backend: Backend::Gpu, ..Default::default() };
+    let t = Tick::from_seconds_f64(1.0);
+    let mut w = server(&s);
+    let acc = Arc::new(Deferred::default());
+    w.set_accel(Some(acc.clone()));
+    let mut m = Mirror::default();
+    w.handle(round(&m.sync(s.revision, &s.project).unwrap()));
+    let req = |id| round(&FrameMsg::Render { id, revision: s.revision, comp, time: t, opts: Box::new(opts), disk: None, layers: false, prefetch: vec![] });
+    assert!(w.handle(req(1)).is_empty() && w.waiting(), "the first pass misses");
+    let mut out = vec![];
+    for _ in 0..10 {
+        acc.settle();
+        out = w.resume();
+        if !w.waiting() {
+            break;
+        }
+    }
+    let (FrameReply::Frame { id: 1, passes, gpu: true, .. }, Some(px)) = &out[0] else { panic!("{:?}", out.first().map(|o| &o.0)) };
+    assert!(*passes >= 2, "{passes}");
+    assert!(acc.chains.load(std::sync::atomic::Ordering::Relaxed) >= 2);
+    // The same pixels as the CPU: no placeholder survived, in the frame or the layer cache.
+    assert_eq!(*px, local(&s, comp, t, RenderOpts { backend: Backend::Cpu, ..opts }));
+    let out = w.handle(req(2));
+    let out = if out.is_empty() {
+        acc.settle();
+        w.resume()
+    } else {
+        out
+    };
+    assert_eq!(out[0].1.as_deref(), Some(&px[..]));
+    // CPU requests never touch the accelerator; Auto times whole frames.
+    let cpu = RenderOpts { backend: Backend::Cpu, ..opts };
+    let out =
+        w.handle(round(&FrameMsg::Render { id: 3, revision: s.revision, comp, time: t, opts: Box::new(cpu), disk: None, layers: false, prefetch: vec![] }));
+    assert!(matches!(out[0].0, FrameReply::Frame { id: 3, passes: 1, gpu: false, .. }));
+    for id in 4..12 {
+        let auto = RenderOpts { backend: Backend::Auto, ..opts };
+        let mut out =
+            w.handle(round(&FrameMsg::Render { id, revision: s.revision, comp, time: t, opts: Box::new(auto), disk: None, layers: false, prefetch: vec![] }));
+        while w.waiting() {
+            acc.settle();
+            out = w.resume();
+        }
+        assert_eq!(out[0].1.as_deref(), Some(&px[..]), "frame {id}");
+    }
+    let st = acc.auto.stats(effectcraft_render::AutoKey::new(comp, opts.scale, false)).unwrap();
+    assert!(st.cpu_frames > 0 && st.gpu_frames > 0, "{st:?}");
+}
diff --git a/crates/engine/src/cmd.rs b/crates/engine/src/cmd.rs
new file mode 100644
index 000000000..1168c431b
--- /dev/null
+++ b/crates/engine/src/cmd.rs
@@ -0,0 +1,297 @@
+//! The command registry. Ids follow After Effects' menu structure; every menu item, panel button,
+//! shortcut and viewer/timeline gesture maps to one of these.
+
+mod align;
+mod align_data;
+mod anim;
+mod anim_presets;
+pub mod anim_tools;
+mod animation;
+pub(crate) mod app_more;
+mod autotrace;
+mod batch;
+mod blender;
+mod camera_cmds;
+mod comp;
+pub(crate) mod comp_more;
+pub mod content_fill;
+mod create;
+mod edit;
+mod effect;
+pub use effect::CryptoProbeJob;
+pub(crate) use effect::{CryptoProbeSlot, crypto_probe_job, crypto_probe_ready, keep_crypto_probe, kept_crypto_probe};
+pub mod essential;
+pub mod expr_tools;
+mod file;
+pub(crate) mod file_more;
+mod focus;
+pub mod footage_panel;
+pub(crate) mod frame_export;
+mod frontend;
+mod help;
+mod import_project;
+mod key_labels;
+mod key_transform;
+mod keys_more;
+mod layer;
+mod layer_menu;
+mod layer_time;
+pub(crate) mod link;
+mod liquify;
+mod lottie;
+pub mod markers;
+mod mask;
+pub mod mask_interp;
+pub(crate) mod model3d;
+mod nav_more;
+pub mod paint;
+pub mod panels_cmds;
+pub(crate) mod path_nulls;
+mod paths;
+mod project_items;
+pub(crate) mod prop;
+mod prop_groups;
+mod proxy;
+pub mod puppet;
+mod query;
+mod quick_offset;
+mod relink;
+pub(crate) mod relink_moved;
+mod render_queue;
+pub(crate) mod rig3d;
+pub mod roto_cmds;
+mod scene_detect;
+pub mod scripts;
+mod settings;
+pub mod shape_stroke;
+pub mod shape_tool;
+mod stubs;
+mod styles;
+mod text_anim;
+pub mod text_edit;
+mod three_d;
+pub mod time;
+mod timeline;
+mod track;
+mod view;
+pub mod viewer_cmds;
+pub(crate) mod vpe;
+pub(crate) mod vr_editor;
+mod warp_cmds;
+pub(crate) mod watch_folder;
+#[cfg(test)]
+pub(crate) use app_more::report_text as report_text_for_tests;
+pub(crate) use app_more::view_command;
+#[cfg(test)]
+pub(crate) use file::open as open_for_tests;
+#[cfg(test)]
+pub(crate) use keys_more::amplitudes as amplitudes_for_tests;
+#[cfg(test)]
+pub(crate) use mask::split_segment as split_segment_for_tests;
+
+use std::sync::OnceLock;
+
+use effectcraft_project::{Comp, ItemId, Layer, LayerId};
+use effectcraft_time::Tick;
+use serde_json::Value;
+
+use crate::{EngineError, Result, Session};
+
+pub type Run = fn(&mut Session, &Value) -> Result<Value>;
+pub type Enabled = fn(&Session) -> std::result::Result<(), String>;
+
+/// Metadata + implementation for one command.
+pub struct CommandSpec {
+    pub id: &'static str,
+    pub label: &'static str,
+    /// Menu placement, e.g. `["Layer", "New"]`. Empty = not in menus.
+    pub menu: &'static [&'static str],
+    /// Default shortcut (egui-style names, `Cmd` = ⌘ on macOS / Ctrl elsewhere).
+    pub shortcut: Option<&'static str>,
+    /// Further default shortcuts (the menus and tooltips show `shortcut`).
+    pub alt_shortcuts: &'static [&'static str],
+    /// Parameter description for agents and the MCP schema.
+    pub params: &'static str,
+    pub enabled: Enabled,
+    pub run: Run,
+    /// Record in the journal (false for pure queries).
+    pub journal: bool,
+}
+
+#[macro_export]
+macro_rules! cmd {
+    // Several default shortcuts: `["PageDown", "Cmd+ArrowRight"]`.
+    ($id:literal, $label:literal, [$($m:literal),*], [$sc:literal, $($alt:literal),+], $params:literal, $en:expr, $run:expr) => {
+        $crate::commands::CommandSpec { alt_shortcuts: &[$($alt),+], ..$crate::cmd!($id, $label, [$($m),*], Some($sc), $params, $en, $run) }
+    };
+    ($id:literal, $label:literal, [$($m:literal),*], $sc:expr, $params:literal, $en:expr, $run:expr) => {
+        $crate::commands::CommandSpec {
+            id: $id,
+            label: $label,
+            menu: &[$($m),*],
+            shortcut: $sc,
+            alt_shortcuts: &[],
+            params: $params,
+            enabled: $en,
+            run: $run,
+            journal: true,
+        }
+    };
+}
+#[macro_export]
+macro_rules! query {
+    ($id:literal, $label:literal, $params:literal, $run:expr) => {
+        $crate::commands::CommandSpec {
+            id: $id,
+            label: $label,
+            menu: &[],
+            shortcut: None,
+            alt_shortcuts: &[],
+            params: $params,
+            enabled: $crate::commands::always,
+            run: $run,
+            journal: false,
+        }
+    };
+}
+
+mod enabled;
+mod params;
+mod schema;
+
+use super::commands;
+pub use enabled::always;
+pub(crate) use enabled::{has_comp, has_keys, has_layers, has_project_selection, not_yet, not_yet_run};
+pub use params::match_path_of;
+pub(crate) use params::{
+    b_p, bad, comp_id, f_p, frontend, layer_mut, layer_p, layers_or, layers_p, merge_p, popup_options, resolve_effect_path, resolve_layer, selectable,
+    selected_leaf_props, str_p, time_p, unlocked, visible_p,
+};
+pub use schema::{accepted_params, check_params, params_schema};
+
+pub fn command_specs() -> &'static [CommandSpec] {
+    static SPECS: OnceLock<Vec<CommandSpec>> = OnceLock::new();
+    SPECS.get_or_init(|| {
+        let mut v = Vec::new();
+        v.extend(file::specs());
+        v.extend(crate::models::specs());
+        v.extend(edit::specs());
+        v.extend(comp::specs());
+        v.extend(layer::specs());
+        v.extend(styles::specs());
+        v.extend(three_d::specs());
+        v.extend(model3d::specs());
+        v.extend(rig3d::specs());
+        v.extend(text_anim::specs());
+        v.extend(text_edit::specs());
+        v.extend(layer_time::specs());
+        v.extend(prop::specs());
+        v.extend(prop_groups::specs());
+        v.extend(project_items::specs());
+        v.extend(anim::specs());
+        v.extend(anim_tools::specs());
+        v.extend(link::specs());
+        v.extend(markers::specs());
+        v.extend(mask::specs());
+        v.extend(paths::specs());
+        v.extend(effect::specs());
+        v.extend(time::specs());
+        v.extend(nav_more::specs());
+        v.extend(render_queue::specs());
+        v.extend(help::specs());
+        v.extend(query::specs());
+        v.extend(batch::specs());
+        v.extend(layer_menu::specs());
+        v.extend(create::specs());
+        v.extend(animation::specs());
+        v.extend(anim_presets::specs());
+        v.extend(view::specs());
+        v.extend(viewer_cmds::specs());
+        v.extend(shape_stroke::specs());
+        v.extend(shape_tool::specs());
+        v.extend(focus::specs());
+        v.extend(key_labels::specs());
+        v.extend(key_transform::specs());
+        v.extend(quick_offset::specs());
+        v.extend(file_more::specs());
+        v.extend(relink::specs());
+        v.extend(relink_moved::specs());
+        v.extend(lottie::specs());
+        v.extend(import_project::specs());
+        v.extend(timeline::specs());
+        v.extend(comp_more::specs());
+        v.extend(frame_export::specs());
+        v.extend(watch_folder::specs());
+        v.extend(vpe::specs());
+        v.extend(path_nulls::specs());
+        v.extend(vr_editor::specs());
+        v.extend(frontend::specs());
+        v.extend(track::specs());
+        v.extend(mask_interp::specs());
+        v.extend(warp_cmds::specs());
+        v.extend(camera_cmds::specs());
+        v.extend(roto_cmds::specs());
+        v.extend(paint::specs());
+        v.extend(puppet::specs());
+        v.extend(liquify::specs());
+        v.extend(settings::specs());
+        v.extend(app_more::specs());
+        v.extend(keys_more::specs());
+        v.extend(essential::specs());
+        v.extend(expr_tools::specs());
+        v.extend(proxy::specs());
+        v.extend(scripts::specs());
+        v.extend(panels_cmds::specs());
+        v.extend(footage_panel::specs());
+        v.extend(autotrace::specs());
+        v.extend(scene_detect::specs());
+        v.extend(align_data::specs());
+        v.extend(align::specs());
+        v.extend(content_fill::specs());
+        v.extend(stubs::specs());
+        v.extend(crate::storage::specs());
+        v.extend(crate::learn::specs());
+        v.extend(crate::templates::specs());
+        v.extend(crate::preview::specs());
+        v
+    })
+}
+
+/// Set `footage` as the proxy of `item` (File ▸ Create Proxy's post-render action).
+pub(crate) fn proxy_set(s: &mut Session, item: ItemId, footage: effectcraft_project::Footage) -> Result<()> {
+    proxy::set_proxy_footage(s, &[item], footage)
+}
+
+/// (id, name) of the text animation presets.
+pub fn text_preset_list() -> Vec<(String, String)> {
+    text_anim::preset_names()
+}
+
+/// (id, name, category) of the built-in animation presets (Transitions…).
+pub fn builtin_preset_list() -> Vec<(String, String, String)> {
+    anim_presets::preset_names()
+}
+
+pub fn find(id: &str) -> Option<&'static CommandSpec> {
+    // Every command execution looks its spec up: index the ~2,000 ids once.
+    static INDEX: OnceLock<std::collections::HashMap<&'static str, usize>> = OnceLock::new();
+    let index = INDEX.get_or_init(|| {
+        let mut m = std::collections::HashMap::new();
+        for (i, c) in command_specs().iter().enumerate() {
+            m.entry(c.id).or_insert(i);
+        }
+        m
+    });
+    index.get(id).map(|&i| &command_specs()[i])
+}
+
+/// Font families available to text layers (bundled + scanned system fonts).
+/// Text animation presets: (id, name), for menus.
+pub fn text_presets() -> Vec<(String, String)> {
+    commands::text_preset_list()
+}
+
+/// Built-in animation presets (Effects & Presets ▸ * Animation Presets): (id, name, category).
+pub fn animation_presets() -> Vec<(String, String, String)> {
+    commands::builtin_preset_list()
+}
diff --git a/crates/engine/src/commands/align.rs b/crates/engine/src/cmd/align.rs
similarity index 100%
rename from crates/engine/src/commands/align.rs
rename to crates/engine/src/cmd/align.rs
diff --git a/crates/engine/src/commands/align_data.rs b/crates/engine/src/cmd/align_data.rs
similarity index 96%
rename from crates/engine/src/commands/align_data.rs
rename to crates/engine/src/cmd/align_data.rs
index 38d9e7841..99ed3d113 100644
--- a/crates/engine/src/commands/align_data.rs
+++ b/crates/engine/src/cmd/align_data.rs
@@ -72,9 +72,9 @@ pub fn parse_stamp(v: &Value, fps: f64) -> Option<Stamp> {
             }
             // ISO 8601: date [T| ] time [zone].
             if s.len() >= 10 && s.as_bytes()[4] == b'-' && s.as_bytes()[7] == b'-' {
-                let (y, m, d) = (s[0..4].parse::<i64>().ok()?, s[5..7].parse::<i64>().ok()?, s[8..10].parse::<i64>().ok()?);
+                let (y, m, d) = (s.get(0..4)?.parse::<i64>().ok()?, s.get(5..7)?.parse::<i64>().ok()?, s.get(8..10)?.parse::<i64>().ok()?);
                 let mut secs = days_from_civil(y, m, d)? as f64 * 86_400.0;
-                let rest = s[10..].trim_start_matches(['T', 't', ' ']);
+                let rest = s.get(10..)?.trim_start_matches(['T', 't', ' ']);
                 if !rest.is_empty() {
                     // Zone: Z or ±hh:mm / ±hhmm.
                     let (time, zone) = match rest.find(['Z', 'z', '+']).or_else(|| rest.rfind('-')) {
@@ -229,6 +229,12 @@ pub fn specs() -> Vec<CommandSpec> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn multibyte_date_is_rejected() {
+        assert_eq!(parse_stamp(&json!("2026-05-0é"), 25.0), None);
+        assert_eq!(parse_stamp(&json!("2026-05-01é"), 25.0), None);
+    }
+
     #[test]
     fn parses_timestamps() {
         let p = |v: Value| parse_stamp(&v, 25.0).unwrap();
diff --git a/crates/engine/src/commands/anim.rs b/crates/engine/src/cmd/anim.rs
similarity index 93%
rename from crates/engine/src/commands/anim.rs
rename to crates/engine/src/cmd/anim.rs
index 325845115..e23fc736f 100644
--- a/crates/engine/src/commands/anim.rs
+++ b/crates/engine/src/cmd/anim.rs
@@ -45,6 +45,7 @@ fn copy(s: &mut Session, _: &Value) -> Result<Value> {
         clip.push(KeyClip { layer: lid, path, keys });
     }
     let n: usize = clip.iter().map(|c| c.keys.len()).sum();
+    s.state.keyframe_text = crate::keyframe_text::text(&s.project, comp, &s.state.selected_keys, &[]);
     s.state.key_clipboard = clip;
     s.state.clip_is_keys = true;
     Ok(json!(n))
@@ -55,6 +56,10 @@ fn compatible(a: &Property, b: &effectcraft_keyframe::Value) -> bool {
     a.value.kind_name() == b.kind_name() && a.value.components().len() == b.components().len()
 }
 
+pub(crate) fn locked_selection(comp: &effectcraft_project::Comp, selected: &[KeyRef]) -> Vec<KeyRef> {
+    selected.iter().filter(|k| comp.layer(k.layer).is_some_and(|l| l.switches.locked)).copied().collect()
+}
+
 /// Paste copied keyframes at the current time into the target layers' properties.
 fn paste(s: &mut Session, p: &Value) -> Result<Value> {
     let clip = s.state.key_clipboard.clone();
@@ -89,6 +94,9 @@ fn paste(s: &mut Session, p: &Value) -> Result<Value> {
     let mut plan: Vec<(LayerId, Uid, usize)> = vec![];
     for (ti, lid) in targets.iter().enumerate() {
         let Some(l) = comp.layer(*lid) else { continue };
+        if l.switches.locked {
+            continue;
+        }
         for (ci, c) in clip.iter().enumerate() {
             if paired && sources.get(ti) != Some(&c.layer) {
                 continue;
@@ -110,11 +118,12 @@ fn paste(s: &mut Session, p: &Value) -> Result<Value> {
         }
     }
     if plan.is_empty() {
-        return Err(bad("keys.paste", "no compatible property to paste into (select a property of the same type)"));
+        return Err(bad("keys.paste", "no compatible unlocked property to paste into (unlock the target or select a property of the same type)"));
     }
     s.edit("Paste Keyframes", merge_p(p), |proj, st| {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        let mut sel = vec![];
+        let mut sel = locked_selection(comp, &st.selected_keys);
+        let retained = sel.len();
         for (lid, uid, ci) in &plan {
             let Some(l) = comp.layer_mut(*lid) else { continue };
             let times: Vec<Tick> = clip[*ci].keys.iter().map(|k| l.layer_time(t + k.time)).collect();
@@ -136,8 +145,9 @@ fn paste(s: &mut Session, p: &Value) -> Result<Value> {
             }
             retime_roving(&mut pr.keys, pr.spatial);
         }
+        let pasted = sel.len().saturating_sub(retained);
         st.selected_keys = sel;
-        Ok(json!(st.selected_keys.len()))
+        Ok(json!(pasted))
     })
 }
 
@@ -175,6 +185,9 @@ pub(super) fn paste_path(s: &mut Session, p: &Value, (cid, lid, uid): (ItemId, L
     let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
     let t = time_p(s, p, Some(comp));
     let target = comp.layer(lid).ok_or(EngineError::NoComp)?;
+    if target.switches.locked {
+        return Err(bad("keys.paste", "the target layer is locked"));
+    }
     let mut order: Vec<usize> = (0..path.vertices.len()).collect();
     if path.closed && !order.is_empty() {
         order.push(0);
@@ -202,6 +215,9 @@ pub(super) fn paste_path(s: &mut Session, p: &Value, (cid, lid, uid): (ItemId, L
         })
         .collect();
     s.edit("Paste Keyframes", merge_p(p), |proj, st| {
+        let comp = proj.comp(cid).ok_or(EngineError::NoComp)?;
+        let mut selected = locked_selection(comp, &st.selected_keys);
+        let retained = selected.len();
         let l = super::layer_mut(proj, cid, lid)?;
         let pr = l.props.find_mut(uid).ok_or_else(|| bad("keys.paste", "no property"))?;
         let mut sel = vec![];
@@ -216,8 +232,10 @@ pub(super) fn paste_path(s: &mut Session, p: &Value, (cid, lid, uid): (ItemId, L
         // Re-timing keeps the keys' order, so the pasted keys are found again by index.
         let pasted: Vec<usize> = pr.keys.iter().enumerate().filter(|(_, k)| sel.contains(&k.time)).map(|(i, _)| i).collect();
         retime_roving(&mut pr.keys, pr.spatial);
-        st.selected_keys = pasted.iter().filter_map(|&i| pr.keys.get(i)).map(|k| KeyRef { layer: lid, prop: uid, time: k.time }).collect();
-        Ok(json!(st.selected_keys.len()))
+        selected.extend(pasted.iter().filter_map(|&i| pr.keys.get(i)).map(|k| KeyRef { layer: lid, prop: uid, time: k.time }));
+        let count = selected.len().saturating_sub(retained);
+        st.selected_keys = selected;
+        Ok(json!(count))
     })
 }
 
@@ -296,6 +314,9 @@ fn set_key(s: &mut Session, p: &Value) -> Result<Value> {
     let base = KeyTimeBase::from_params(p, "keys.set")?;
     let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
     let layer = comp.layer(lid).ok_or(EngineError::NoComp)?;
+    if layer.switches.locked {
+        return Err(bad("keys.set", "the layer is locked"));
+    }
     let t = key_time(layer, comp.frame_rate, p, "time", base, "keys.set", false)?.ok_or_else(|| bad("keys.set", "missing `time` (layer time by default)"))?;
     let new_t = key_time(layer, comp.frame_rate, p, "newTime", base, "keys.set", true)?;
     let value = p.get("value").cloned();
@@ -349,6 +370,9 @@ fn set_ease(s: &mut Session, p: &Value) -> Result<Value> {
     let influence = f_p(p, "influence").map(|v| (v / 100.0).clamp(0.001, 1.0));
     s.edit("Keyframe Velocity", merge_p(p), |proj, _| {
         let l = super::layer_mut(proj, cid, lid)?;
+        if l.switches.locked {
+            return Err(bad("keys.setEase", "the layer is locked"));
+        }
         let pr = l.props.find_mut(uid).ok_or_else(|| bad("keys.setEase", "no property"))?;
         let i = nearest_key(&pr.keys, t).ok_or_else(|| bad("keys.setEase", "no keyframes"))?;
         let spatial = pr.spatial;
@@ -495,7 +519,13 @@ fn time_reverse(s: &mut Session, _: &Value) -> Result<Value> {
         }
         let mut new_sel = vec![];
         for ((lid, uid), times) in groups {
-            let Some(pr) = comp.layer_mut(lid).and_then(|l| l.props.find_mut(uid)) else { continue };
+            let Some(layer) = comp.layer_mut(lid) else { continue };
+            // A locked layer's keys stay as they are, and stay selected.
+            if layer.switches.locked {
+                new_sel.extend(times.iter().map(|time| KeyRef { layer: lid, prop: uid, time: *time }));
+                continue;
+            }
+            let Some(pr) = layer.props.find_mut(uid) else { continue };
             let (mut picked, rest): (Vec<Keyframe>, Vec<Keyframe>) = pr.keys.drain(..).partition(|k| times.contains(&k.time));
             effectcraft_keyframe::time_reverse(&mut picked);
             new_sel.extend(picked.iter().map(|k| KeyRef { layer: lid, prop: uid, time: k.time }));
diff --git a/crates/engine/src/commands/anim_presets.rs b/crates/engine/src/cmd/anim_presets.rs
similarity index 95%
rename from crates/engine/src/commands/anim_presets.rs
rename to crates/engine/src/cmd/anim_presets.rs
index fc3f95143..88022a0e3 100644
--- a/crates/engine/src/commands/anim_presets.rs
+++ b/crates/engine/src/cmd/anim_presets.rs
@@ -1,6 +1,7 @@
 //! EffectCraft's own animation preset library (Effects & Presets ▸ * Animation Presets): the
 //! Transitions category (original presets built on our Transition effects and layer opacity) and
-//! the Backgrounds category (generators, noise and colour effects driven by expressions).
+//! the Backgrounds category (generators, noise and colour effects driven by expressions) and the
+//! Behaviors category (transform and opacity driven by expressions, no effects).
 //!
 //! Each preset adds effects (with values and keyframes) and/or keys layer properties, starting
 //! at the current time, on every selected layer. The library is data
@@ -26,13 +27,17 @@ pub const TRANSITIONS_JSON: &str = include_str!("../../presets/transitions.json"
 /// The original background presets (`presets/backgrounds.json`).
 pub const BACKGROUNDS_JSON: &str = include_str!("../../presets/backgrounds.json");
 
+/// The original behavior presets (`presets/behaviors.json`): expression-driven motion on a layer's
+/// transform and opacity, no effects.
+pub const BEHAVIORS_JSON: &str = include_str!("../../presets/behaviors.json");
+
 /// Keys per animated property, so a hostile inline preset can't allocate without bound.
 const MAX_KEYS: usize = 256;
 /// Longest expression text an inline preset may carry.
 const MAX_EXPR: usize = 4096;
 
 fn presets() -> Vec<Value> {
-    [TRANSITIONS_JSON, BACKGROUNDS_JSON]
+    [TRANSITIONS_JSON, BACKGROUNDS_JSON, BEHAVIORS_JSON]
         .iter()
         .flat_map(|src| serde_json::from_str::<Value>(src).ok().and_then(|v| v.get("presets").and_then(Value::as_array).cloned()).unwrap_or_default())
         .collect()
diff --git a/crates/engine/src/commands/anim_tools.rs b/crates/engine/src/cmd/anim_tools.rs
similarity index 98%
rename from crates/engine/src/commands/anim_tools.rs
rename to crates/engine/src/cmd/anim_tools.rs
index 06e0d341b..33ee39ae2 100644
--- a/crates/engine/src/commands/anim_tools.rs
+++ b/crates/engine/src/cmd/anim_tools.rs
@@ -213,7 +213,8 @@ fn sample_curve(
 
 fn grouped_selection(s: &Session) -> std::collections::BTreeMap<(LayerId, Uid), Vec<Tick>> {
     let mut g: std::collections::BTreeMap<(LayerId, Uid), Vec<Tick>> = Default::default();
-    for k in &s.state.selected_keys {
+    let Some(comp) = s.active_comp() else { return g };
+    for k in super::prop::editable_keys(comp, &s.state.selected_keys) {
         g.entry((k.layer, k.prop)).or_default().push(k.time);
     }
     for v in g.values_mut() {
@@ -273,7 +274,7 @@ fn run_on_selection(
     s.edit(label, None, |proj, st| {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
         let fr = comp.frame_rate;
-        let mut sel = vec![];
+        let mut sel = super::anim::locked_selection(comp, &st.selected_keys);
         for ((lid, uid), times) in groups {
             let Some(l) = comp.layer_mut(lid) else { continue };
             let lc = l.clone();
diff --git a/crates/engine/src/commands/animation.rs b/crates/engine/src/cmd/animation.rs
similarity index 84%
rename from crates/engine/src/commands/animation.rs
rename to crates/engine/src/cmd/animation.rs
index 1bdf3fed7..2c2f23f1a 100644
--- a/crates/engine/src/commands/animation.rs
+++ b/crates/engine/src/cmd/animation.rs
@@ -10,11 +10,16 @@ use effectcraft_project::{GroupKind, Layer, LayerId, LayerSource, Node, Project,
 use effectcraft_time::Tick;
 use serde_json::{Value, json};
 
+use super::effect::{effect_time_error, retime_effect};
 use super::{CommandSpec, bad, frontend, has_comp, has_keys, has_layers, layer_mut, layers_p, match_path_of, resolve_effect_path, selected_leaf_props, str_p};
 use crate::{EngineError, KeyRef, Result, Session, cmd};
 
 /// Preset file format version tag (`*.ecpreset`, JSON).
 pub const PRESET_TAG: &str = "effectcraftAnimationPreset";
+/// The preset format version that `anim.savePreset` writes.
+pub const PRESET_VERSION: u64 = 2;
+/// The first preset version that stores effect keys relative to the earliest key (#1971).
+const RELATIVE_EFFECT_KEYS: u64 = 2;
 
 fn has_selected_props(s: &Session) -> std::result::Result<(), String> {
     has_comp(s)?;
@@ -45,13 +50,27 @@ fn selected_effects(s: &Session) -> Vec<(LayerId, PropGroup)> {
         .collect()
 }
 
+/// The earliest key anywhere in `groups`, nested controls included.
+fn earliest_key<'a>(groups: impl IntoIterator<Item = &'a PropGroup>) -> Option<Tick> {
+    let mut first: Option<Tick> = None;
+    for g in groups {
+        g.walk("", &mut |_, pr| {
+            if let Some(t) = pr.keys.iter().map(|k| k.time).min() {
+                first = Some(first.map_or(t, |f| f.min(t)));
+            }
+        });
+    }
+    first
+}
+
 // ---------------------------------------------------------------- presets
 
 fn save_preset(s: &mut Session, p: &Value) -> Result<Value> {
     let path = str_p(p, "path").ok_or_else(|| bad("anim.savePreset", "missing `path`"))?.to_string();
+    s.refuse_export(&path)?;
     let comp = s.active_comp().ok_or(EngineError::NoComp)?;
     let t = s.time();
-    let effects: Vec<(LayerId, PropGroup)> = selected_effects(s);
+    let mut effects: Vec<(LayerId, PropGroup)> = selected_effects(s);
     let effect_uids: Vec<Uid> = effects.iter().map(|(_, g)| g.uid).collect();
     let mut props = vec![];
     for (lid, uid) in selected_leaf_props(s) {
@@ -67,7 +86,11 @@ fn save_preset(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad("anim.savePreset", "select properties or effects to save"));
     }
     // Key times are stored relative to the earliest key so the preset applies at the CTI.
-    let first = props.iter().flat_map(|(_, _, pr)| pr.keys.iter().map(|k| k.time)).min().unwrap_or(Tick::ZERO);
+    let first =
+        props.iter().flat_map(|(_, _, pr)| pr.keys.iter().map(|k| k.time)).chain(earliest_key(effects.iter().map(|(_, g)| g))).min().unwrap_or(Tick::ZERO);
+    for (_, g) in &mut effects {
+        retime_effect(g, 1.0, "anim.savePreset", |t| Ok(Tick(t.0.checked_sub(first.0).ok_or_else(|| effect_time_error("anim.savePreset"))?)))?;
+    }
     let props_json: Vec<Value> = props
         .iter()
         .map(|(_, mp, pr)| {
@@ -82,12 +105,27 @@ fn save_preset(s: &mut Session, p: &Value) -> Result<Value> {
     let name = str_p(p, "name")
         .map(str::to_string)
         .unwrap_or_else(|| std::path::Path::new(&path).file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_default());
-    let doc = json!({PRESET_TAG: 1, "name": name, "properties": props_json, "effects": fx_json});
+    let doc = json!({PRESET_TAG: PRESET_VERSION, "name": name, "properties": props_json, "effects": fx_json});
     let text = serde_json::to_string_pretty(&doc).unwrap_or_default();
-    s.services.write_file(&path, text.as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+    s.write_output(&path, text.as_bytes())?;
     Ok(json!({"path": path, "properties": props.len(), "effects": effects.len()}))
 }
 
+/// Rewrite an effect property path in a preset (`effects/<effect id>[#n]/<param>`) to the current
+/// parameter id when it names a parameter that the effect has since renamed or moved into a
+/// twirl-down group. Any other path comes back unchanged.
+fn upgrade_effect_path(path: &str) -> String {
+    let Some((seg, tail)) = path.strip_prefix("effects/").and_then(|r| r.split_once('/')) else { return path.to_string() };
+    let effect = match seg.rsplit_once('#') {
+        Some((m, n)) if !m.is_empty() && n.parse::<usize>().is_ok() => m,
+        _ => seg,
+    };
+    match effectcraft_effects::find(effect).and_then(|spec| effectcraft_effects::migrate::current_param_id(spec, tail)) {
+        Some(id) if id != tail => format!("effects/{seg}/{id}"),
+        _ => path.to_string(),
+    }
+}
+
 fn apply_preset(s: &mut Session, p: &Value) -> Result<Value> {
     let doc: Value = match (p.get("preset"), str_p(p, "path")) {
         (Some(v), _) => v.clone(),
@@ -110,14 +148,22 @@ fn apply_preset(s: &mut Session, p: &Value) -> Result<Value> {
         s.save_prefs();
         s.prefs_revision += 1;
     }
-    let effects: Vec<PropGroup> =
+    let mut effects: Vec<PropGroup> =
         doc["effects"].as_array().map(|a| a.iter().filter_map(|v| serde_json::from_value(v.clone()).ok()).collect()).unwrap_or_default();
+    // Older presets stored effect keys at the source layer's times.
+    if doc[PRESET_TAG].as_u64().unwrap_or(1) < RELATIVE_EFFECT_KEYS
+        && let Some(first) = earliest_key(&effects)
+    {
+        for g in &mut effects {
+            retime_effect(g, 1.0, "anim.applyPreset", |t| Ok(Tick(t.0.checked_sub(first.0).ok_or_else(|| effect_time_error("anim.applyPreset"))?)))?;
+        }
+    }
     let props: Vec<(String, Property)> = doc["properties"]
         .as_array()
         .map(|a| {
             a.iter()
                 .filter_map(|v| {
-                    let path = v["path"].as_str()?.to_string();
+                    let path = upgrade_effect_path(v["path"].as_str()?);
                     let value: KV = serde_json::from_value(v["value"].clone()).ok()?;
                     let keys: Vec<Keyframe> = serde_json::from_value(v["keys"].clone()).unwrap_or_default();
                     let expr = serde_json::from_value(v["expression"].clone()).ok().flatten();
@@ -130,16 +176,30 @@ fn apply_preset(s: &mut Session, p: &Value) -> Result<Value> {
         })
         .unwrap_or_default();
     let t = s.time();
+    // Effect bounds per layer size the point defaults of parameters added since the preset was saved.
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let sizes: BTreeMap<LayerId, [f64; 2]> =
+        ids.iter().filter_map(|lid| comp.layer(*lid).map(|l| (*lid, effectcraft_render::effect_bounds(&s.project, comp, l).0))).collect();
     let mut applied = 0;
     let mut skipped = vec![];
     s.edit("Apply Animation Preset", None, |proj, _| {
         let mut next = proj.next_id;
         for lid in &ids {
+            let size = sizes.get(lid).copied().unwrap_or([100.0, 100.0]);
             let l = layer_mut(proj, cid, *lid)?;
             let lt = l.layer_time(t);
             if let Some(fx) = l.props.sub_mut("effects") {
                 for g in &effects {
                     let mut g = g.clone();
+                    // Effects saved by an earlier version get the upgrade a project gets on open.
+                    let spec = match &g.kind {
+                        GroupKind::Effect { effect } => effectcraft_effects::find(effect),
+                        _ => None,
+                    };
+                    if let Some(spec) = spec {
+                        effectcraft_effects::migrate::upgrade_instance(spec, &mut g, &mut Ids(&mut next), size);
+                    }
+                    retime_effect(&mut g, 1.0, "anim.applyPreset", |t| Ok(Tick(t.0.checked_add(lt.0).ok_or_else(|| effect_time_error("anim.applyPreset"))?)))?;
                     g.reassign_uids(&mut next);
                     next += 1;
                     fx.children.push(Node::Group(g));
@@ -184,7 +244,7 @@ fn add_keyframe(s: &mut Session, _: &Value) -> Result<Value> {
     }
     let cid = s.active_comp_id().ok_or(EngineError::NoComp)?;
     let t = s.time();
-    let n = s.edit("Add Keyframe", None, |proj, _| {
+    let n = s.edit("Add Keyframe", None, |proj, state| {
         let mut n = 0;
         for (lid, uid) in &targets {
             let l = layer_mut(proj, cid, *lid)?;
@@ -200,6 +260,9 @@ fn add_keyframe(s: &mut Session, _: &Value) -> Result<Value> {
                 pr.set_value_at(lt, v);
             }
             n += 1;
+            if pr.match_id == "type" {
+                super::prop::sync_polystar_property(proj, state, cid, *lid, *uid, t)?;
+            }
         }
         Ok(n)
     })?;
@@ -209,7 +272,8 @@ fn add_keyframe(s: &mut Session, _: &Value) -> Result<Value> {
 /// Selected keys grouped by (layer, property).
 fn keys_by_prop(s: &Session) -> BTreeMap<(LayerId, Uid), Vec<Tick>> {
     let mut m: BTreeMap<(LayerId, Uid), Vec<Tick>> = BTreeMap::new();
-    for k in &s.state.selected_keys {
+    let Some(comp) = s.active_comp() else { return m };
+    for k in super::prop::editable_keys(comp, &s.state.selected_keys) {
         m.entry((k.layer, k.prop)).or_default().push(k.time);
     }
     m
diff --git a/crates/engine/src/commands/app_more.rs b/crates/engine/src/cmd/app_more.rs
similarity index 98%
rename from crates/engine/src/commands/app_more.rs
rename to crates/engine/src/cmd/app_more.rs
index b95dd4375..ea4230852 100644
--- a/crates/engine/src/commands/app_more.rs
+++ b/crates/engine/src/cmd/app_more.rs
@@ -152,8 +152,9 @@ fn clear_recent_presets(s: &mut Session, _: &Value) -> Result<Value> {
 
 fn save_copy_xml(s: &mut Session, p: &Value) -> Result<Value> {
     let path = str_p(p, "path").ok_or_else(|| bad("file.saveCopyAsXml", "missing `path` (.ecprojx)"))?;
-    let xml = crate::xml_project::to_xml(&s.project.to_file_json_with_view(&s.saved_view())?).map_err(EngineError::Other)?;
-    s.services.write_file(path, xml.as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+    s.refuse_export(path)?;
+    let xml = crate::xml_project::to_xml(&s.project.to_file_json_with_view(&s.saved_view(), false)?).map_err(EngineError::Other)?;
+    s.write_output(path, xml.as_bytes())?;
     s.toast(format!("Saved an XML copy to {path}"));
     Ok(json!({"path": path, "bytes": xml.len()}))
 }
@@ -240,7 +241,7 @@ fn replace_with_precomp(s: &mut Session, p: &Value) -> Result<Value> {
             let ids: Vec<ItemId> = proj.items.keys().copied().filter(|c| *c != comp).collect();
             for cid in ids {
                 if let Some(c) = proj.comp_mut(cid) {
-                    for l in c.layers.iter_mut().filter(|l| is_user(l)) {
+                    for l in c.layers.iter_mut_where(|l| is_user(l)) {
                         l.source = LayerSource::Comp { item: comp };
                         n += 1;
                     }
@@ -354,7 +355,7 @@ fn assign_view_shortcut(s: &mut Session, p: &Value) -> Result<Value> {
     reassign(s, view_command(cur), &slot, "view.assign3dShortcut")
 }
 
-/// Window ▸ Assign Shortcut to "<workspace>" Workspace: Shift+F10, Shift+F11 or Shift+F12.
+/// Window ▸ Assign Shortcut to `"<workspace>"` Workspace: Shift+F10, Shift+F11 or Shift+F12.
 /// The frontend fills in the current workspace.
 fn assign_workspace_shortcut(s: &mut Session, p: &Value) -> Result<Value> {
     let slot = slot_p(p, "window.assignWorkspaceShortcut", true)?;
@@ -668,6 +669,9 @@ fn extract_cubemap(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(r)
 }
 
+/// The specs for the commands in this module: history steps, recent footage and presets, Save
+/// a Copy As XML, footage replacement and Execute File, 3D-view and workspace shortcuts,
+/// logging and the system report, VR environment/cubemap creation and System Information.
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!("edit.history", "History", [], None, "{steps?: n (undo n steps), redo?: n}", has_history, history),
diff --git a/crates/engine/src/commands/autotrace.rs b/crates/engine/src/cmd/autotrace.rs
similarity index 86%
rename from crates/engine/src/commands/autotrace.rs
rename to crates/engine/src/cmd/autotrace.rs
index 7f33fcdf7..8dabfd013 100644
--- a/crates/engine/src/commands/autotrace.rs
+++ b/crates/engine/src/cmd/autotrace.rs
@@ -64,8 +64,9 @@ fn trace_frame(img: &Image, offset: [f64; 2], ch: Channel, invert: bool, blur: f
     let mut out = trace(&field, img.width as usize, img.height as usize, o);
     for t in &mut out {
         for v in &mut t.path.vertices {
-            v[0] += offset[0];
-            v[1] += offset[1];
+            // Source buffers are layer pixels + offset: subtract it to get back to layer space.
+            v[0] -= offset[0];
+            v[1] -= offset[1];
         }
     }
     out
@@ -211,3 +212,33 @@ pub fn specs() -> Vec<CommandSpec> {
         run
     )]
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn trace_frame_converts_image_pixels_back_to_layer_space() {
+        // A synthetic cropped source avoids any dependency on installed fonts.
+        let mut img = Image::new(32, 32);
+        for y in 8..24 {
+            for x in 8..24 {
+                img.set(x, y, [1.0; 4]);
+            }
+        }
+        let opts = TraceOpts { corner_roundness: 0.0, ..Default::default() };
+        for offset in [[0.0, 0.0], [2.0, 58.0], [-12.5, 7.25]] {
+            let outlines = trace_frame(&img, offset, Channel::Alpha, false, 0.0, &opts);
+            assert_eq!(outlines.len(), 1);
+            let vertices = &outlines[0].path.vertices;
+            for axis in 0..2 {
+                // image = layer + offset, so the known image bounds map back
+                // to [8 - offset, 24 - offset] in layer space.
+                let lo = vertices.iter().map(|v| v[axis]).fold(f64::INFINITY, f64::min);
+                let hi = vertices.iter().map(|v| v[axis]).fold(f64::NEG_INFINITY, f64::max);
+                assert!((lo - (8.0 - offset[axis])).abs() < 0.01, "{offset:?}: {lo}");
+                assert!((hi - (24.0 - offset[axis])).abs() < 0.01, "{offset:?}: {hi}");
+            }
+        }
+    }
+}
diff --git a/crates/engine/src/commands/batch.rs b/crates/engine/src/cmd/batch.rs
similarity index 77%
rename from crates/engine/src/commands/batch.rs
rename to crates/engine/src/cmd/batch.rs
index e1fc37140..5931fe09d 100644
--- a/crates/engine/src/commands/batch.rs
+++ b/crates/engine/src/cmd/batch.rs
@@ -9,8 +9,9 @@ use serde_json::{Value, json};
 use super::{CommandSpec, always, bad, str_p};
 use crate::{EngineError, Result, Session};
 
-/// Commands that can't run inside a batch (they replace the project or nest batches).
-const NOT_IN_BATCH: &[&str] = &["engine.batch", "file.runScript", "script.run"];
+/// Commands that can't run inside a batch (they nest batches), besides the commands that run
+/// scripts ([`super::scripts::RUNS_SCRIPTS`]).
+const NOT_IN_BATCH: &[&str] = &["engine.batch"];
 
 /// Resolve a `$N` / `$N.key.0.key` reference against the results so far.
 fn reference(s: &str, results: &[Value]) -> Option<Result<Value>> {
@@ -51,6 +52,17 @@ fn substitute(v: &Value, results: &[Value]) -> Result<Value> {
     })
 }
 
+/// `engine.batch`: runs `steps` (`[{command|id, params?}]`) as engine commands, substituting
+/// `$N` / `$N.key.0` strings in each step's params with earlier results, and returns
+/// `{steps, results}`.
+///
+/// `engine.batch`, `file.runScript` and `script.run` are refused inside a batch. Successful
+/// steps are folded into one undo step named `label` (default "Batch"). With the default
+/// `atomic: true`, a failing step restores the project, history and editor state, drops the
+/// events the batch published, sanitizes the editor against the failing intermediate state (so
+/// no pre-batch IME token is revived) and keeps the higher process IME revision; with
+/// `atomic: false` the steps before the failure stay applied. Either way the error names the
+/// failing step and command.
 fn batch(s: &mut Session, p: &Value) -> Result<Value> {
     let steps = p.get("steps").and_then(Value::as_array).ok_or_else(|| bad("engine.batch", "missing `steps`: [{command, params?}, …]"))?.clone();
     let label = str_p(p, "label").unwrap_or("Batch").to_string();
@@ -67,7 +79,7 @@ fn batch(s: &mut Session, p: &Value) -> Result<Value> {
                 .or_else(|| step.get("id"))
                 .and_then(Value::as_str)
                 .ok_or_else(|| bad("engine.batch", "each step needs `command` (a command id)"))?;
-            if NOT_IN_BATCH.contains(&id) {
+            if NOT_IN_BATCH.contains(&id) || super::scripts::RUNS_SCRIPTS.contains(&id) {
                 return Err(bad("engine.batch", format!("`{id}` can't run inside a batch")));
             }
             let params = substitute(step.get("params").unwrap_or(&json!({})), results)?;
@@ -138,6 +150,32 @@ mod tests {
 
     use crate::Session;
 
+    /// Failed atomic steps discard their UI events while preserving events queued beforehand.
+    #[test]
+    fn atomic_batch_event_rollback_preserves_prior_events() {
+        for atomic in [true, false] {
+            let mut s = Session::default();
+            s.execute("comp.new", json!({"name": "First", "width": 100, "height": 100})).unwrap();
+            let first = s.active_comp_id().unwrap();
+            s.execute("comp.new", json!({"name": "Second", "width": 100, "height": 100})).unwrap();
+            let second = s.active_comp_id().unwrap();
+            s.drain_events();
+            s.execute("comp.open", json!({"comp": first.0})).unwrap();
+            let result = s.execute_checked(
+                "engine.batch",
+                json!({"atomic": atomic, "steps": [
+                    {"command": "comp.open", "params": {"comp": second.0}},
+                    {"command": "no.suchCommand", "params": {}}
+                ]}),
+            );
+            assert!(result.is_err());
+            assert_eq!(s.active_comp_id(), Some(if atomic { first } else { second }));
+            let opened: Vec<_> =
+                s.drain_events().into_iter().filter_map(|event| if let crate::Event::OpenComp(id) = event { Some(id) } else { None }).collect();
+            assert_eq!(opened, if atomic { vec![first] } else { vec![first, second] });
+        }
+    }
+
     #[test]
     fn batch_refs_one_undo_step_and_rollback() {
         let mut s = Session::default();
diff --git a/crates/engine/src/cmd/blender.rs b/crates/engine/src/cmd/blender.rs
new file mode 100644
index 000000000..e6c678101
--- /dev/null
+++ b/crates/engine/src/cmd/blender.rs
@@ -0,0 +1,295 @@
+//! Camera-solve interchange through Blender's public Python API. The generated script is
+//! original MIT OR Apache-2.0 code; no Blender implementation is read or embedded.
+
+use std::path::Path;
+
+use effectcraft_effects::camera_tracker as ct;
+use effectcraft_project::{Footage, FootageKind, ItemId, ItemKind, Layer, LayerId, LayerSource, Uid};
+use effectcraft_render::EvalCtx;
+use effectcraft_time::Tick;
+use effectcraft_track::camtrack::{CameraSolve, linalg};
+use serde_json::{Value, json};
+
+mod validate;
+
+use super::{b_p, bad, f_p, str_p};
+use crate::{EngineError, Result, Session};
+
+const CMD: &str = "camera.exportBlender";
+const MAX_FRAMES: usize = 100_000;
+const MAX_POINTS: usize = 100_000;
+const MAX_JSON: usize = 64 * 1024 * 1024;
+const MAX_FRAME: i64 = 1_048_574;
+
+fn number(p: &Value, key: &str, default: f64, min: f64, max: f64) -> Result<f64> {
+    let v = match p.get(key) {
+        None => default,
+        Some(_) => f_p(p, key).ok_or_else(|| bad(CMD, format!("{key}: expected a number")))?,
+    };
+    if !v.is_finite() || !(min..=max).contains(&v) {
+        return Err(bad(CMD, format!("{key}: expected {min}..{max}")));
+    }
+    Ok(v)
+}
+
+fn finite(values: impl IntoIterator<Item = f64>) -> Result<()> {
+    if values.into_iter().any(|v| !v.is_finite() || v.abs() > 1e12) {
+        return Err(bad(CMD, "invalid or excessive numeric camera/scene data; re-analyze the tracker"));
+    }
+    Ok(())
+}
+
+/// Right-handed EffectCraft world (right, down, forward) → Blender (right, forward, up).
+fn position(p: [f64; 3], scale: f64) -> [f64; 3] {
+    [p[0] * scale, p[2] * scale, -p[1] * scale]
+}
+
+fn media_path(s: &Session, path: &str) -> Result<String> {
+    if path.is_empty() || path.contains('\0') {
+        return Err(bad(CMD, "the source footage has no valid file path; relink it before exporting"));
+    }
+    let path = Path::new(path);
+    if path.is_absolute() || cfg!(target_arch = "wasm32") {
+        return Ok(path.to_string_lossy().into_owned());
+    }
+    let cwd = std::env::current_dir().map_err(|e| bad(CMD, format!("cannot resolve footage path: {e}")))?;
+    let base = s.path.as_deref().and_then(|p| Path::new(p).parent()).map(|p| cwd.join(p)).unwrap_or(cwd);
+    Ok(base.join(path).to_string_lossy().into_owned())
+}
+
+pub(super) fn export(s: &mut Session, p: &Value, cid: ItemId, lid: LayerId, uid: Uid) -> Result<Value> {
+    if s.running_for_script() && !s.prefs.scripting.allow_scripts_write_files {
+        return Err(bad(CMD, "scripts can't export files unless Settings ▸ Scripting & Expressions ▸ Allow Scripts to Write Files and Access Network is on"));
+    }
+    let options = Options::parse(p)?;
+    let Options { path, sensor, units, start, include_points } = options;
+    if s.camera_target().is_some_and(|(c, l, u)| (c, l, u) == (cid, lid, uid)) && s.is_camera_analyzing() || s.camera_pending.contains(&(cid, lid, uid)) {
+        return Err(bad(CMD, "wait for this tracker's analysis to finish before exporting"));
+    }
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let layer = comp.layer(lid).ok_or_else(|| bad(CMD, "tracked layer missing"))?;
+    let g = layer.props.find_group(uid).ok_or_else(|| bad(CMD, "tracker missing"))?;
+    for name in [ct::SOLVE, ct::TRACKS] {
+        if g.prop(name).is_some_and(|p| matches!(&p.value, effectcraft_keyframe::Value::Str(v) if v.len() > MAX_JSON)) {
+            return Err(bad(CMD, "tracking data exceeds the 64 MiB export limit"));
+        }
+    }
+    let params = crate::camera_track::static_params(g);
+    let solve = ct::solve(&params).ok_or_else(|| bad(CMD, "the camera is not solved yet; analyze the tracker first"))?;
+    let (lo, end) = validate::timing(comp, layer, &solve, start)?;
+    let Source { footage, path: source_path, fps: source_fps, count: source_count } = source(s, layer, &solve, path)?;
+    validate::geometry(&solve, sensor)?;
+    let camera = params
+        .get(ct::CAMERA)
+        .map(|v| v.as_f64())
+        .filter(|v| v.is_finite() && *v > 0.0 && *v <= u64::MAX as f64)
+        .and_then(|id| comp.layer(LayerId(id as u64)))
+        .filter(|l| l.is_camera());
+    let warnings = scene_warnings(camera, &solve, footage);
+    let ctx = EvalCtx { expr: s.expr.as_deref(), ..EvalCtx::new(&s.project, cid, comp, lo) };
+    let (frames, world) = bake_frames(&ctx, layer, &solve, camera, &options, footage, source_count)?;
+    let mut points = Vec::new();
+    for point in &solve.points {
+        finite(point.pos.into_iter().chain([point.error as f64]))?;
+        if point.first > point.last || point.last as usize >= solve.frames.len() {
+            return Err(bad(CMD, "invalid solved point frame range; re-analyze the tracker"));
+        }
+        let location = position(world.apply(point.pos), units);
+        finite(location)?;
+        if include_points {
+            points.push(json!({"id": point.id, "location": location, "error": point.error,
+                "first": start.saturating_add(point.first as i64), "last": start.saturating_add(point.last as i64)}));
+        }
+    }
+    let tracks = ct::tracks(&params);
+    if tracks.as_ref().is_some_and(|t| t.tracks.len() > MAX_POINTS || t.tracks.iter().any(|t| t.pts.len() > MAX_FRAMES)) {
+        return Err(bad(CMD, "2D tracks exceed export limits"));
+    }
+    let markers: Vec<Value> = comp
+        .markers
+        .iter()
+        .filter_map(|m| {
+            let frame = start.saturating_add(comp.frame_rate.frame_at(m.time).saturating_sub(comp.frame_rate.frame_at(lo)));
+            if (start..=end).contains(&frame) { Some(json!({"name": m.comment, "frame": frame})) } else { None }
+        })
+        .collect();
+    let payload = json!({"version": 1, "name": format!("{} — {}", s.project.item(cid).map(|i| i.name.as_str()).unwrap_or("Shot"), layer.name),
+        "resolution": solve.size, "fpsNumerator": comp.frame_rate.num, "fpsDenominator": comp.frame_rate.den,
+        "startFrame": start, "endFrame": end, "sensorWidth": sensor, "unitScale": units,
+        "media": {"path": source_path, "kind": if footage.kind == FootageKind::Still {"FILE"} else {"MOVIE"},
+            "fps": source_fps, "nativeRate": footage.native_rate, "pixelAspect": footage.pixel_aspect, "timecode": footage.start_timecode,
+            "frameCount": source_count, "loopCount": footage.loop_count},
+        "frames": frames, "points": points, "markers": markers, "ground": solve.ground.is_some(),
+        "groundSize": world.s * units, "shutter": comp.shutter_angle / 360.0, "shutterPhase": comp.shutter_phase,
+        "solve": solve, "tracks": if include_points { tracks.as_deref() } else { None },
+        "warnings": warnings});
+    let data = serde_json::to_string(&payload).map_err(|e| bad(CMD, format!("cannot serialize scene: {e}")))?;
+    if data.len() > MAX_JSON {
+        return Err(bad(CMD, "scene exceeds the 64 MiB script limit; disable includePoints or split the shot"));
+    }
+    let quoted = serde_json::to_string(&data).map_err(|e| bad(CMD, format!("cannot encode scene: {e}")))?;
+    let script = include_str!("blender_scene.py").replace("__EFFECTCRAFT_DATA__", &quoted);
+    s.services.write_file(path, script.as_bytes()).map_err(|e| bad(CMD, format!("cannot write {path}: {e}")))?;
+    Ok(json!({"path": path, "bytes": script.len(), "frames": frames.len(), "points": points.len(), "warnings": warnings}))
+}
+
+struct Options<'a> {
+    path: &'a str,
+    sensor: f64,
+    units: f64,
+    start: i64,
+    include_points: bool,
+}
+
+impl<'a> Options<'a> {
+    fn parse(p: &'a Value) -> Result<Self> {
+        let path = str_p(p, "path").filter(|p| !p.is_empty() && !p.contains('\0')).ok_or_else(|| bad(CMD, "missing `path` (.py)"))?;
+        if !Path::new(path).extension().is_some_and(|e| e.eq_ignore_ascii_case("py")) {
+            return Err(bad(CMD, "the export path must end in .py"));
+        }
+        let sensor = number(p, "sensorWidth", 36.0, 1.0, 1000.0)?;
+        let units = number(p, "unitScale", 0.01, 0.000_001, 1000.0)?;
+        let start = match p.get("startFrame") {
+            None => 1,
+            Some(v) => v.as_i64().filter(|n| (1..=MAX_FRAME).contains(n)).ok_or_else(|| bad(CMD, "startFrame: expected a positive Blender frame number"))?,
+        };
+        let include_points = match p.get("includePoints") {
+            Some(v) if !v.is_boolean() => return Err(bad(CMD, "includePoints: expected a boolean")),
+            _ => b_p(p, "includePoints").unwrap_or(true),
+        };
+        Ok(Self { path, sensor, units, start, include_points })
+    }
+}
+
+struct Source<'a> {
+    footage: &'a Footage,
+    path: String,
+    fps: f64,
+    count: i64,
+}
+
+fn source<'a>(s: &'a Session, layer: &Layer, solve: &CameraSolve, path: &str) -> Result<Source<'a>> {
+    let footage = match layer.source {
+        LayerSource::Footage { item } => s.project.item(item).and_then(|i| match &i.kind {
+            ItemKind::Footage(f) => Some(f),
+            _ => None,
+        }),
+        _ => None,
+    }
+    .filter(|f| f.has_video && matches!(f.kind, FootageKind::Video | FootageKind::Still));
+    let footage = footage
+        .ok_or_else(|| bad(CMD, "Blender background export needs a video or still-footage layer; render precomps/sequences to a video and track that video"))?;
+    let source_path = media_path(s, &footage.path)?;
+    if Path::new(path) == Path::new(&source_path) {
+        return Err(bad(CMD, "the export path must differ from the source footage"));
+    }
+    if footage.width as f64 != solve.size[0] || footage.height as f64 != solve.size[1] {
+        return Err(bad(CMD, "the analysis image differs from the original footage dimensions; render the tracker's input to a video and track that video"));
+    }
+    let source_fps = footage.frame_rate.as_f64();
+    if footage.frame_rate.num <= 0 || footage.frame_rate.den <= 0 || !source_fps.is_finite() || source_fps <= 0.0 {
+        return Err(bad(CMD, "invalid source footage frame rate"));
+    }
+    // Same frame selection as the media pool: interpreted FPS, rounded per-loop frame count,
+    // clamp to the total loop range, then wrap. Native FPS does not change the frame index.
+    let divisor = (effectcraft_time::TICKS_PER_SECOND as i128).saturating_mul(footage.frame_rate.den as i128);
+    let source_count = (footage.duration.0 as i128).saturating_mul(footage.frame_rate.num as i128).saturating_add(divisor / 2) / divisor;
+    let source_count = if footage.kind == FootageKind::Still { 1 } else { source_count };
+    if !(1..=MAX_FRAME as i128).contains(&source_count) {
+        return Err(bad(CMD, "invalid footage duration or footage exceeds Blender's frame range; trim/render the source video first"));
+    }
+    let source_count = source_count as i64;
+    Ok(Source { footage, path: source_path, fps: source_fps, count: source_count })
+}
+
+fn scene_warnings(camera: Option<&Layer>, solve: &CameraSolve, footage: &Footage) -> Vec<String> {
+    let mut warnings = vec![
+        "Sensor width is assumed (36 mm by default); monocular tracking cannot recover physical sensor size or absolute scene scale.".to_string(),
+        "The original footage is referenced, not embedded or rendered: masks and effects before the tracker are not baked. Relink the video if moving this script.".to_string(),
+    ];
+    if camera.is_none() {
+        warnings
+            .push("No linked tracker camera: focus uses the default scene depth, DOF is off; optical focus cannot be recovered from feature tracks.".into());
+    } else {
+        warnings.push("Focus/iris settings are sampled from the linked camera; pose and lens come from the tracker solve. Blender's physical DOF is an approximation of EffectCraft's blur model.".into());
+    }
+    if solve.distortion.is_some_and(|d| !d.is_none()) {
+        warnings.push("Radial distortion is preserved as metadata (Brown k1/k2, half-diagonal normalization), not applied to Blender's pinhole camera. Use an undistorted plate for exact alignment.".into());
+    }
+    if (footage.pixel_aspect - 1.0).abs() > 1e-6 {
+        warnings.push("The tracker solves square pixels: export uses square pixels; original footage pixel aspect is retained in metadata.".into());
+    }
+    warnings
+}
+
+/// Bake the solved camera and the linked camera's optical settings at exact composition ticks.
+fn bake_frames(
+    ctx0: &EvalCtx<'_>,
+    layer: &Layer,
+    solve: &CameraSolve,
+    camera: Option<&Layer>,
+    options: &Options<'_>,
+    footage: &Footage,
+    source_count: i64,
+) -> Result<(Vec<Value>, linalg::Similarity)> {
+    let comp = ctx0.comp;
+    let lo = ctx0.time;
+    let fd = comp.frame_duration();
+    let sensor = options.sensor;
+    let units = options.units;
+    let start = options.start;
+    let first = solve.frames.first().ok_or_else(|| bad(CMD, "the camera solve is empty"))?;
+    let m = ctx0.world_matrix(layer).0;
+    let layer_scale = m[0][0].hypot(m[1][0]);
+    finite([layer_scale])?;
+    if layer_scale <= 1e-9 {
+        return Err(bad(CMD, "the tracked layer has zero scale"));
+    }
+    let world = solve.world([comp.width as f64, comp.height as f64], first.focal * layer_scale);
+    finite([world.s * units])?;
+    let mut frames = Vec::with_capacity(solve.frames.len());
+    for (i, frame) in solve.frames.iter().enumerate() {
+        let time = Tick(lo.0.saturating_add(fd.0.saturating_mul(i as i64)));
+        let ctx = ctx0.at(time);
+        let pose = linalg::mm(&world.r, &linalg::mt(&frame.r()));
+        let right = position(linalg::mv(&pose, [1.0, 0.0, 0.0]), 1.0);
+        let up = position(linalg::mv(&pose, [0.0, -1.0, 0.0]), 1.0);
+        let back = position(linalg::mv(&pose, [0.0, 0.0, -1.0]), 1.0);
+        let location = position(world.apply(frame.center), units);
+        let lens = frame.focal * sensor / solve.size[0];
+        let opts = camera.and_then(|l| l.props.sub("cameraOptions").map(|g| (l, g)));
+        let value = |key: &str, fallback: f64| opts.map(|(l, g)| ctx.f(l, g, key, fallback)).unwrap_or(fallback);
+        let focus = value("focusDistance", world.s) * units;
+        let aperture = value("aperture", 0.0);
+        let zoom = value("zoom", frame.focal * layer_scale);
+        // Match Camera Settings' f-stop conversion: focal_for_zoom uses a 36 mm film width,
+        // and the aperture UI is mm scaled by comp_width / 1920 (not a world-space diameter).
+        let aperture_mm = aperture * 1920.0 / comp.width as f64;
+        let fstop = if aperture_mm > 0.0 { (zoom * 36.0 / comp.width as f64) / aperture_mm } else { 2.8 };
+        let rotation = value("irisRotation", 0.0).to_radians();
+        let ratio = value("irisAspectRatio", 1.0);
+        let shape = opts.map(|(l, g)| ctx.e(l, g, "irisShape")).unwrap_or(0);
+        let blades = match shape {
+            0 => 4,
+            1..=8 => shape.saturating_add(2),
+            _ => return Err(bad(CMD, "invalid iris shape")),
+        };
+        let dof = opts.is_some_and(|(l, g)| ctx.b(l, g, "dof")) && aperture > 0.0 && value("blurLevel", 100.0) > 0.0;
+        let source_time = ctx.source_time(layer);
+        let source_frame = if footage.kind == FootageKind::Still {
+            0
+        } else {
+            footage.frame_rate.frame_at(source_time).clamp(0, source_count.saturating_mul(footage.loop_count.max(1) as i64).saturating_sub(1)) % source_count
+        };
+        finite(location.into_iter().chain([focus, aperture, zoom, fstop, rotation, ratio, value("blurLevel", 100.0), value("irisRoundness", 0.0)]))?;
+        if focus <= 0.0 || !(0.01..=100.0).contains(&ratio) || !(0.01..=1e6).contains(&fstop) {
+            return Err(bad(CMD, "focus, f-stop or iris aspect is outside Blender's supported range"));
+        }
+        frames.push(json!({"frame": start + i as i64, "timeTicks": time.0, "sourceFrame": source_frame,
+            "location": location, "rotation": [right, up, back], "lens": lens, "focus": focus, "dof": dof,
+            "fstop": fstop, "blades": blades, "irisRotation": rotation, "irisRatio": ratio,
+            "sourceAperture": aperture, "sourceZoom": zoom,
+            "blurLevel": value("blurLevel", 100.0), "irisRoundness": value("irisRoundness", 0.0)}));
+    }
+    Ok((frames, world))
+}
diff --git a/crates/engine/src/cmd/blender/validate.rs b/crates/engine/src/cmd/blender/validate.rs
new file mode 100644
index 000000000..a9454861f
--- /dev/null
+++ b/crates/engine/src/cmd/blender/validate.rs
@@ -0,0 +1,71 @@
+//! Validate solved geometry and its correspondence to the current layer timing.
+
+use effectcraft_project::{Comp, Layer};
+use effectcraft_time::Tick;
+use effectcraft_track::camtrack::{CameraSolve, linalg};
+
+use super::{CMD, MAX_FRAME, MAX_FRAMES, MAX_POINTS, bad, finite};
+use crate::Result;
+
+pub(super) fn timing(comp: &Comp, layer: &Layer, solve: &CameraSolve, start: i64) -> Result<(Tick, i64)> {
+    if solve.frames.len() > MAX_FRAMES || solve.points.len() > MAX_POINTS {
+        return Err(bad(CMD, "export is limited to 100,000 frames and 100,000 points; split the shot"));
+    }
+    if solve.size.iter().any(|v| !v.is_finite() || *v < 4.0 || *v > 65_536.0 || v.fract() != 0.0) {
+        return Err(bad(CMD, "invalid tracking resolution (expected 4..65536 whole pixels)"));
+    }
+    let fps = comp.frame_rate.as_f64();
+    if comp.frame_rate.num <= 0 || comp.frame_rate.den <= 0 || !fps.is_finite() || !(1.0..=1000.0).contains(&fps) {
+        return Err(bad(CMD, "invalid composition frame rate (expected 1..1000 fps)"));
+    }
+    let end = start
+        .checked_add(solve.frames.len() as i64)
+        .and_then(|n| n.checked_sub(1))
+        .filter(|n| *n <= MAX_FRAME)
+        .ok_or_else(|| bad(CMD, "the baked animation exceeds Blender's frame range"))?;
+    finite([solve.start, solve.frame_duration, solve.average_error, layer.stretch, comp.shutter_angle, comp.shutter_phase])?;
+    if layer.stretch == 0.0 || comp.width == 0 || comp.height == 0 {
+        return Err(bad(CMD, "invalid composition dimensions or zero layer stretch"));
+    }
+    let lo = comp.frame_rate.snap_nearest(layer.in_point.max(Tick::ZERO));
+    let hi = layer.out_point.min(comp.duration);
+    let fd = comp.frame_duration();
+    if fd.0 <= 0 || lo >= hi {
+        return Err(bad(CMD, "the tracked layer has no active frames"));
+    }
+    let expected = ((hi.0 as i128 - lo.0 as i128 + fd.0 as i128 - 1) / fd.0 as i128) as u128;
+    if expected != solve.frames.len() as u128 {
+        return Err(bad(CMD, "the solve no longer matches the layer's frame range; re-analyze the tracker"));
+    }
+    let dt = (layer.layer_time(lo + fd) - layer.layer_time(lo)).seconds();
+    if (solve.start - layer.layer_time(lo).seconds()).abs() > 1e-6 || solve.frames.len() > 1 && (solve.frame_duration - dt).abs() > 1e-6 {
+        return Err(bad(CMD, "the solve no longer matches the layer's timing; re-analyze the tracker"));
+    }
+    Ok((lo, end))
+}
+
+pub(super) fn geometry(solve: &CameraSolve, sensor: f64) -> Result<()> {
+    for frame in &solve.frames {
+        finite(frame.rot.into_iter().chain(frame.center).chain([frame.focal]))?;
+        if !frame.solved || frame.focal <= 0.0 {
+            return Err(bad(CMD, "the solve contains unsolved frames or invalid focal lengths; re-analyze the tracker"));
+        }
+        let mm = sensor * frame.focal / solve.size[0];
+        if !(1.0..=5000.0).contains(&mm) {
+            return Err(bad(CMD, "lens outside Blender's 1..5000 mm range; choose another sensorWidth"));
+        }
+    }
+    if let Some(ground) = &solve.ground {
+        finite(ground.origin.into_iter().chain(ground.normal).chain(ground.x_axis))?;
+        if (linalg::norm(ground.normal) - 1.0).abs() > 1e-4
+            || (linalg::norm(ground.x_axis) - 1.0).abs() > 1e-4
+            || linalg::dot(ground.normal, ground.x_axis).abs() > 1e-4
+        {
+            return Err(bad(CMD, "invalid ground-plane basis; set the ground plane again"));
+        }
+    }
+    if let Some(d) = &solve.distortion {
+        finite([d.k1, d.k2, d.radius])?;
+    }
+    Ok(())
+}
diff --git a/crates/engine/src/cmd/blender_scene.py b/crates/engine/src/cmd/blender_scene.py
new file mode 100644
index 000000000..0a9700a00
--- /dev/null
+++ b/crates/engine/src/cmd/blender_scene.py
@@ -0,0 +1,204 @@
+# EffectCraft camera tracker → Blender, original code under MIT OR Apache-2.0.
+# Run in Blender's Scripting workspace (Open, Run Script), or:
+# blender --background --python "Tracked Scene.py"
+# Creates a NEW scene; existing scenes and objects are preserved. Save the .blend yourself.
+# Public API types: bpy.types.Camera, bpy.types.ImageUser
+import json
+import math
+import os
+
+import bpy
+from mathutils import Matrix
+
+DATA = json.loads(__EFFECTCRAFT_DATA__)
+
+
+def _curves(owner):
+    """Blender 4.0–4.3 legacy actions and 4.4+/5.x layered actions."""
+    anim = owner.animation_data
+    if anim is None or anim.action is None:
+        return
+    action = anim.action
+    if getattr(action, "is_action_layered", False):
+        for layer in action.layers:
+            for strip in layer.strips:
+                if strip.type == 'KEYFRAME':
+                    bag = strip.channelbag(anim.action_slot)
+                    if bag is not None:
+                        yield from bag.fcurves
+    else:
+        yield from action.fcurves
+
+
+def _interpolation(owner):
+    for curve in _curves(owner):
+        # Footage indices and discrete switches must never interpolate between frames.
+        stepped = ("frame_offset" in curve.data_path or "use_dof" in curve.data_path
+                   or "aperture_blades" in curve.data_path)
+        for key in curve.keyframe_points:
+            key.interpolation = 'CONSTANT' if stepped else 'LINEAR'
+
+
+def _media_path():
+    original = DATA["media"]["path"]
+    candidates = [original]
+    # When sharing, place the video alongside the script or the .blend and run again.
+    script_path = globals().get("__file__", "")
+    if script_path:
+        candidates.append(os.path.join(os.path.dirname(os.path.abspath(script_path)),
+                                       os.path.basename(original)))
+    if bpy.data.filepath:
+        candidates.append(os.path.join(os.path.dirname(bpy.data.filepath),
+                                       os.path.basename(original)))
+    return next((p for p in candidates if os.path.isfile(p)), None)
+
+
+def import_scene():
+    if bpy.app.version < (4, 0, 0):
+        raise RuntimeError("EffectCraft scene import requires Blender 4.0 or newer")
+    scene = bpy.data.scenes.new(DATA["name"])
+    scene.frame_start = DATA["startFrame"]
+    scene.frame_end = DATA["endFrame"]
+    fps = DATA["fpsNumerator"] / DATA["fpsDenominator"]
+    scene.render.fps = max(1, round(fps))
+    scene.render.fps_base = scene.render.fps / fps
+    scene.render.resolution_x, scene.render.resolution_y = map(int, DATA["resolution"])
+    scene.render.resolution_percentage = 100
+    # The tracker assumes square pixels, regardless of the source's interpretation metadata.
+    scene.render.pixel_aspect_x = scene.render.pixel_aspect_y = 1.0
+    scene.render.film_transparent = True
+    scene.render.motion_blur_shutter = max(0.0, min(2.0, DATA["shutter"]))
+    scene.unit_settings.system = 'METRIC'
+    scene.unit_settings.scale_length = 1.0
+    scene["effectcraft_unit_scale"] = DATA["unitScale"]
+    scene["effectcraft_scale_is_arbitrary"] = True
+    scene["effectcraft_shutter_phase_degrees"] = DATA["shutterPhase"]
+
+    collection = bpy.data.collections.new("EffectCraft Tracking")
+    scene.collection.children.link(collection)
+    camera_data = bpy.data.cameras.new("3D Tracker Camera")
+    camera = bpy.data.objects.new("3D Tracker Camera", camera_data)
+    collection.objects.link(camera)
+    scene.camera = camera
+    camera.rotation_mode = 'QUATERNION'
+    camera_data.type = 'PERSP'
+    camera_data.sensor_fit = 'HORIZONTAL'
+    camera_data.sensor_width = DATA["sensorWidth"]
+    camera_data.sensor_height = (DATA["sensorWidth"] * DATA["resolution"][1]
+                                 / DATA["resolution"][0])
+    camera_data.show_background_images = True
+    camera_data.show_limits = True
+    extent = max([DATA["groundSize"], 1.0]
+                 + [math.dist(p["location"], f["location"])
+                    for p in DATA["points"][::max(1, len(DATA["points"]) // 100)]
+                    for f in DATA["frames"][::max(1, len(DATA["frames"]) // 10)]])
+    camera_data.clip_start = max(0.00001, min(0.1, extent / 10000.0))
+    camera_data.clip_end = max(1000.0, extent * 10.0)
+
+    previous = None
+    for sample in DATA["frames"]:
+        frame = sample["frame"]
+        camera.location = sample["location"]
+        # Exported right/up/back vectors are COLUMNS of Blender's local → world basis.
+        quaternion = Matrix(sample["rotation"]).transposed().to_quaternion()
+        if previous is not None and previous.dot(quaternion) < 0:
+            quaternion.negate()
+        camera.rotation_quaternion = quaternion
+        previous = quaternion.copy()
+        camera.keyframe_insert(data_path="location", frame=frame)
+        camera.keyframe_insert(data_path="rotation_quaternion", frame=frame)
+        camera_data.lens = sample["lens"]
+        camera_data.keyframe_insert(data_path="lens", frame=frame)
+        camera_data.dof.use_dof = sample["dof"]
+        camera_data.dof.focus_distance = sample["focus"]
+        camera_data.dof.aperture_fstop = sample["fstop"]
+        camera_data.dof.aperture_blades = sample["blades"]
+        camera_data.dof.aperture_rotation = (sample["irisRotation"] + math.pi) % math.tau - math.pi
+        camera_data.dof.aperture_ratio = sample["irisRatio"]
+        for prop in ("use_dof", "focus_distance", "aperture_fstop", "aperture_blades",
+                     "aperture_rotation", "aperture_ratio"):
+            camera_data.keyframe_insert(data_path="dof." + prop, frame=frame)
+
+    path = _media_path()
+    if path is not None:
+        try:
+            image = bpy.data.images.load(path, check_existing=False)
+            image.source = DATA["media"]["kind"]
+            background = camera_data.background_images.new()
+            background.source = 'IMAGE'
+            background.image = image
+            background.alpha = 1.0
+            background.display_depth = 'BACK'
+            background.frame_method = 'STRETCH'
+            user = background.image_user
+            user.use_auto_refresh = True
+            user.use_cyclic = False
+            user.frame_start = DATA["startFrame"]
+            user.frame_duration = max(1, min(1048574, image.frame_duration))
+            if image.source == 'MOVIE':
+                for sample in DATA["frames"]:
+                    # Blender uses 1-based image frames; sourceFrame is 0-based.
+                    user.frame_offset = sample["sourceFrame"] - (sample["frame"] - user.frame_start)
+                    camera_data.keyframe_insert(
+                        data_path="background_images[0].image_user.frame_offset",
+                        frame=sample["frame"])
+        except (RuntimeError, ValueError, OSError) as error:
+            DATA["warnings"].append("Blender could not load the background video: " + str(error))
+    else:
+        DATA["warnings"].append("Video not found: " + DATA["media"]["path"]
+                                + ". Place it beside this script or relink the camera background.")
+
+    if DATA["points"]:
+        mesh = bpy.data.meshes.new("Solved Track Points")
+        mesh.from_pydata([p["location"] for p in DATA["points"]], [], [])
+        mesh.update()
+        cloud = bpy.data.objects.new("Solved Track Points", mesh)
+        collection.objects.link(cloud)
+        cloud.show_in_front = True
+        cloud.hide_render = True
+        for name, kind, key in (("track_id", 'INT', "id"), ("reprojection_error", 'FLOAT', "error"),
+                                ("first_frame", 'INT', "first"), ("last_frame", 'INT', "last")):
+            attr = mesh.attributes.new(name=name, type=kind, domain='POINT')
+            for dest, point in zip(attr.data, DATA["points"]):
+                # Track IDs are u32 in EffectCraft; keep the full IDs in the JSON text too.
+                dest.value = point[key] if kind == 'FLOAT' else min(2147483647, point[key])
+
+    if DATA["ground"]:
+        size = DATA["groundSize"]
+        mesh = bpy.data.meshes.new("Solved Ground Plane")
+        mesh.from_pydata([(-size, -size, 0), (size, -size, 0),
+                          (size, size, 0), (-size, size, 0)], [], [(0, 1, 2, 3)])
+        mesh.update()
+        ground = bpy.data.objects.new("Solved Ground Plane", mesh)
+        collection.objects.link(ground)
+        ground.display_type = 'WIRE'
+        ground.hide_render = True
+    for marker in DATA["markers"]:
+        scene.timeline_markers.new(marker["name"], frame=marker["frame"])
+
+    _interpolation(camera)
+    _interpolation(camera_data)
+    metadata = bpy.data.texts.new("EffectCraft Tracking Metadata.json")
+    metadata.write(json.dumps(DATA, ensure_ascii=False, indent=2))
+    scene["effectcraft_metadata_text"] = metadata.name
+    camera_data["effectcraft_average_error_pixels"] = DATA["solve"]["averageError"]
+    camera_data["effectcraft_solve_method"] = DATA["solve"]["methodUsed"]
+    camera_data["effectcraft_focus_source"] = "See warnings in " + metadata.name
+    distortion = DATA["solve"].get("distortion")
+    if distortion:
+        for key in ("k1", "k2", "radius"):
+            camera_data["effectcraft_distortion_" + key] = distortion[key]
+    if bpy.context.window is not None:
+        bpy.context.window.scene = scene
+        for area in bpy.context.window.screen.areas:
+            if area.type == 'VIEW_3D':
+                area.spaces.active.region_3d.view_perspective = 'CAMERA'
+    scene.frame_set(scene.frame_start)
+    for warning in DATA["warnings"]:
+        print("EffectCraft: " + warning)
+    print("EffectCraft: imported", len(DATA["frames"]), "baked camera frames into", scene.name)
+    return scene
+
+
+if __name__ == "__main__":
+    EFFECTCRAFT_SCENE = import_scene()
diff --git a/crates/engine/src/commands/camera_cmds.rs b/crates/engine/src/cmd/camera_cmds.rs
similarity index 98%
rename from crates/engine/src/commands/camera_cmds.rs
rename to crates/engine/src/cmd/camera_cmds.rs
index 68cd14fb9..e717d51cc 100644
--- a/crates/engine/src/commands/camera_cmds.rs
+++ b/crates/engine/src/cmd/camera_cmds.rs
@@ -42,11 +42,25 @@ pub fn specs() -> Vec<CommandSpec> {
             create_from_solve
         ),
         cmd!("camera.create", "Create Camera", [], None, "{layer?, effect?}", has_comp, |s, p| create_from_solve(s, &with_kind(p, "camera"))),
+        cmd!(
+            "camera.exportBlender",
+            "Export Scene to Blender...",
+            [],
+            None,
+            "{path: .py, comp?, layer?, effect?, sensorWidth?: mm (default 36), unitScale?: Blender units per comp pixel (default 0.01), startFrame?: positive integer (default 1), includePoints?: true}",
+            has_comp,
+            export_blender
+        ),
         cmd!("camera.setGroundPlane", "Set Ground Plane and Origin", [], None, "{points?: [id] (default: selected), layer?, effect?}", has_comp, set_ground),
         cmd!("camera.deletePoints", "Delete Selected Points", [], None, "{points?: [id] (default: selected), layer?, effect?, wait?}", has_comp, delete_points),
     ]
 }
 
+fn export_blender(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, lid, uid) = ct_p(s, p, "camera.exportBlender")?;
+    super::blender::export(s, p, cid, lid, uid)
+}
+
 fn with_kind(p: &Value, kind: &str) -> Value {
     let mut q = p.clone();
     if !q.is_object() {
diff --git a/crates/engine/src/commands/comp.rs b/crates/engine/src/cmd/comp.rs
similarity index 95%
rename from crates/engine/src/commands/comp.rs
rename to crates/engine/src/cmd/comp.rs
index 6648a7426..8f44ebd3d 100644
--- a/crates/engine/src/commands/comp.rs
+++ b/crates/engine/src/cmd/comp.rs
@@ -35,7 +35,7 @@ fn apply_settings(c: &mut Comp, p: &Value) {
         let dx = (c.width as f64 - ow as f64) * (a % 3) as f64 / 2.0;
         let dy = (c.height as f64 - oh as f64) * (a / 3) as f64 / 2.0;
         if dx != 0.0 || dy != 0.0 {
-            for l in c.layers.iter_mut().filter(|l| l.parent.is_none()) {
+            for l in c.layers.iter_mut_where(|l| l.parent.is_none()) {
                 if let Some(tr) = l.transform_mut() {
                     super::layer::offset_position(tr, dx, dy);
                 }
@@ -272,6 +272,20 @@ fn poster(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(Value::Null)
 }
 
+fn delete_all_markers(s: &mut Session, p: &Value) -> Result<Value> {
+    let cid = comp_id(s, p)?;
+    s.edit("Delete All Markers", None, |proj, _| {
+        proj.comp_mut(cid).ok_or(EngineError::NoComp)?.markers.clear();
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+fn has_comp_markers(s: &Session) -> std::result::Result<(), String> {
+    let c = s.active_comp().ok_or("no composition")?;
+    if !c.markers.is_empty() { Ok(()) } else { Err("the composition has no markers".into()) }
+}
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!(
@@ -299,5 +313,6 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("comp.workArea", "Set Work Area", [], None, "{start?, end?, set?: begin|end (at CTI)}", has_comp, work_area),
         cmd!("comp.setSwitch", "Composition Switch", [], None, "{switch: hideShy|motionBlur|frameBlending|draft3d, value?}", has_comp, comp_switch),
         cmd!("comp.addMarker", "Add Marker", [], Some("Num*"), "{time?, comment?}", has_comp, add_marker),
+        cmd!("comp.deleteAllMarkers", "Delete All Markers", [], None, "{comp?}", has_comp_markers, delete_all_markers),
     ]
 }
diff --git a/crates/engine/src/commands/comp_more.rs b/crates/engine/src/cmd/comp_more.rs
similarity index 57%
rename from crates/engine/src/commands/comp_more.rs
rename to crates/engine/src/cmd/comp_more.rs
index d6de320ec..8b8340e78 100644
--- a/crates/engine/src/commands/comp_more.rs
+++ b/crates/engine/src/cmd/comp_more.rs
@@ -1,11 +1,11 @@
-//! Composition menu, part two: crop to region of interest / layer bounds, Save Frame As ▸ File,
-//! Copy Frame to Clipboard, Responsive Design — Time.
+//! Composition menu, part two: crop to region of interest / layer bounds, Scale Composition, Save
+//! Frame As ▸ File, Copy Frame to Clipboard, Responsive Design — Time.
 
 use effectcraft_project::Marker;
 use effectcraft_time::Tick;
 use serde_json::{Value, json};
 
-use super::{CommandSpec, always, bad, comp_id, f_p, has_comp, has_layers, layers_p, str_p};
+use super::{CommandSpec, always, b_p, bad, comp_id, f_p, has_comp, has_layers, layers_p, str_p};
 use crate::prefs::CompPreset;
 use crate::{EngineError, Result, Session, cmd, query};
 
@@ -25,7 +25,7 @@ fn crop(s: &mut Session, cid: effectcraft_project::ItemId, r: [f64; 4], label: &
         let (old_w, old_h) = (c.width, c.height);
         c.width = w;
         c.height = h;
-        for l in c.layers.iter_mut().filter(|l| l.parent.is_none()) {
+        for l in c.layers.iter_mut_where(|l| l.parent.is_none()) {
             if let Some(tr) = l.transform_mut() {
                 super::layer::offset_position(tr, -x, -y);
             }
@@ -71,6 +71,164 @@ fn crop_to_layers(s: &mut Session, p: &Value) -> Result<Value> {
     crop(s, cid, [x0, y0, b[2].ceil() - x0, b[3].ceil() - y0], "Crop Comp to Selected Layer(s) Bounds")
 }
 
+/// Multiply a property's value, every key, its spatial tangents and its speeds by `f`.
+fn scale_prop(pr: &mut effectcraft_project::Property, f: f64) {
+    use effectcraft_keyframe::Value as KV;
+    let mul = |v: &KV| match v {
+        KV::Scalar(x) => KV::Scalar(x * f),
+        KV::Vec2(a) => KV::Vec2(a.map(|x| x * f)),
+        KV::Vec3(a) => KV::Vec3(a.map(|x| x * f)),
+        other => other.clone(),
+    };
+    pr.value = mul(&pr.value);
+    for k in &mut pr.keys {
+        k.value = mul(&k.value);
+        k.spatial_in = k.spatial_in.map(|x| x * f);
+        k.spatial_out = k.spatial_out.map(|x| x * f);
+        for e in k.in_ease.iter_mut().chain(&mut k.out_ease) {
+            e.speed *= f;
+        }
+    }
+}
+
+/// Multiply only the Z of a 3D value (and of its keys and spatial tangents) by `f`. Speeds follow:
+/// a spatial side's speed by how much the path's direction there stretches, so the ease keeps
+/// its shape; a per-dimension one (Scale) by `f` for Z only.
+fn scale_prop_z(pr: &mut effectcraft_project::Property, f: f64) {
+    use effectcraft_keyframe::Value as KV;
+    let stretch = |v: [f64; 3]| {
+        let n = v[0].hypot(v[1]).hypot(v[2]);
+        if n > 1e-12 && n.is_finite() { v[0].hypot(v[1]).hypot(v[2] * f) / n } else { 1.0 }
+    };
+    let pos = |k: &effectcraft_project::Keyframe| k.value.as_vec3();
+    let sub = |a: [f64; 3], b: [f64; 3]| [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+    let is_zero = |v: [f64; 3]| v.iter().all(|x| x.abs() <= 1e-12);
+    // Read every side's direction before anything changes (auto tangents come from the neighbours).
+    let sides: Vec<(f64, f64)> = (0..pr.keys.len())
+        .map(|i| {
+            let (tin, tout) = effectcraft_keyframe::spatial_tangents(&pr.keys, i);
+            let here = pr.keys.get(i).map(pos).unwrap_or_default();
+            let chord = |j: Option<usize>| j.and_then(|j| pr.keys.get(j)).map(|k| sub(pos(k), here)).unwrap_or_default();
+            let tin = if is_zero(tin) { chord(i.checked_sub(1)) } else { tin };
+            let tout = if is_zero(tout) { chord(Some(i + 1)) } else { tout };
+            (stretch(tin), stretch(tout))
+        })
+        .collect();
+    let spatial = pr.spatial;
+    let mul = |v: &mut KV| {
+        if let KV::Vec3(a) = v {
+            a[2] *= f;
+        }
+    };
+    mul(&mut pr.value);
+    for (k, (s_in, s_out)) in pr.keys.iter_mut().zip(sides) {
+        mul(&mut k.value);
+        k.spatial_in[2] *= f;
+        k.spatial_out[2] *= f;
+        if spatial {
+            k.in_ease.iter_mut().for_each(|e| e.speed *= s_in);
+            k.out_ease.iter_mut().for_each(|e| e.speed *= s_out);
+        } else {
+            // A shorter list lends its first ease to Z (`effective_ease`): give Z its own.
+            for list in [&mut k.in_ease, &mut k.out_ease] {
+                if let Some(&first) = list.first() {
+                    list.resize(list.len().max(3), first);
+                }
+                if let Some(e) = list.get_mut(2) {
+                    e.speed *= f;
+                }
+            }
+        }
+    }
+}
+
+/// Scale Composition (After Effects ships it as File ▸ Scripts ▸ Scale Composition.jsx): the comp
+/// and its contents grow or shrink by one factor, keys included, in one undo step. Layers whose
+/// parent has a Scale follow that parent; everything else scales its Position (and Point of
+/// Interest) and Scale. Anchor Point, masks, shapes and effects live in layer space and follow the
+/// layer's Scale. Cameras scale their Zoom so 3D layers keep their place in the frame; a 2D parent
+/// carries no depth, so its 3D children scale their Z themselves.
+fn scale_comp(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "comp.scale";
+    let cid = comp_id(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let (ow, oh) = (f64::from(comp.width), f64::from(comp.height));
+    // The three are alternatives: with two, one would be ignored without a word.
+    if ["factor", "width", "height"].iter().filter(|k| f_p(p, k).is_some()).count() > 1 {
+        return Err(bad(C, "pass only one of `factor`, `width` or `height`"));
+    }
+    let f = match (f_p(p, "factor"), f_p(p, "width"), f_p(p, "height")) {
+        (Some(f), ..) => f,
+        (None, Some(w), _) => w / ow,
+        (None, None, Some(h)) => h / oh,
+        _ => return Err(bad(C, "pass `factor`, `width` or `height`")),
+    };
+    let (w, h) = ((ow * f).round(), (oh * f).round());
+    let max = f64::from(effectcraft_project::limits::MAX_SIZE);
+    if !f.is_finite() || f <= 0.0 || !(4.0..=max).contains(&w) || !(4.0..=max).contains(&h) {
+        return Err(bad(C, format!("the composition would be {w}×{h}: width and height run from 4 to 30,000 px")));
+    }
+    let (w, h) = (w as u32, h as u32);
+    let active = s.active_comp_id() == Some(cid);
+    s.edit("Scale Composition", None, |proj, st| {
+        let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        // An ancestor's Scale carries its descendants (X and Y only when that ancestor is 2D),
+        // through cameras and lights too: the renderer applies every ancestor's transform.
+        let chain: std::collections::HashMap<_, _> =
+            c.layers.iter().map(|l| (l.id, (l.transform().is_some_and(|tr| tr.get("scale").is_some()), l.is_3d(), l.parent))).collect();
+        // (X and Y carried, Z carried); bounded, as parent chains in a file can loop.
+        let carried = |mut cur: Option<effectcraft_project::LayerId>| {
+            let (mut xy, mut z) = (false, false);
+            for _ in 0..64 {
+                let Some(&(has_scale, three_d, up)) = cur.and_then(|id| chain.get(&id)) else { break };
+                xy |= has_scale;
+                z |= has_scale && three_d;
+                cur = up;
+            }
+            (xy, z)
+        };
+        for l in &mut c.layers {
+            let (xy_carried, z_carried) = carried(l.parent);
+            let three_d = l.is_3d();
+            let Some(tr) = l.transform_mut() else { continue };
+            if !xy_carried {
+                for name in ["position", "positionX", "positionY", "positionZ", "poi", "scale"] {
+                    if let Some(pr) = tr.get_mut(name) {
+                        scale_prop(pr, f);
+                    }
+                }
+            } else if three_d && !z_carried {
+                if let Some(pr) = tr.get_mut("positionZ") {
+                    scale_prop(pr, f);
+                }
+                for name in ["position", "poi", "scale"] {
+                    if let Some(pr) = tr.get_mut(name) {
+                        scale_prop_z(pr, f);
+                    }
+                }
+            }
+            if let Some(cam) = l.props.sub_mut("cameraOptions") {
+                for name in ["zoom", "focusDistance", "aperture"] {
+                    if let Some(pr) = cam.get_mut(name) {
+                        scale_prop(pr, f);
+                    }
+                }
+            }
+        }
+        // Percentage guides keep their percent.
+        for g in c.guides.iter_mut().filter(|g| !g.percent) {
+            g.position *= f;
+        }
+        c.width = w;
+        c.height = h;
+        if active && let Some(r) = &mut st.region_of_interest {
+            *r = r.map(|v| v * f);
+        }
+        Ok(())
+    })?;
+    Ok(json!({"width": w, "height": h, "factor": f}))
+}
+
 /// Encode straight 8-bit RGBA as PNG.
 pub(crate) fn encode_png(rgba: &[u8], w: u32, h: u32) -> std::result::Result<Vec<u8>, String> {
     use image::ImageEncoder;
@@ -82,7 +240,7 @@ pub(crate) fn encode_png(rgba: &[u8], w: u32, h: u32) -> std::result::Result<Vec
 /// Save Frame As ▸ File with `queue`: a Render Queue item for the current frame, from the Frame
 /// Default templates (Edit ▸ Templates).
 fn queue_frame(s: &mut Session, p: &Value) -> Result<Value> {
-    use effectcraft_project::render_queue::{RenderQueueItem, TimeSpan};
+    use effectcraft_project::render_queue::{Channels, RenderQueueItem, TimeSpan};
     use effectcraft_project::render_templates::TemplateSlot;
     let cid = comp_id(s, p)?;
     let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
@@ -91,10 +249,16 @@ fn queue_frame(s: &mut Session, p: &Value) -> Result<Value> {
     it.settings = s.project.render_templates.default_render_settings(TemplateSlot::Still);
     it.settings.time_span = TimeSpan::Custom { start: t, end: t + comp.frame_duration() };
     it.output = s.project.render_templates.default_output_module(TemplateSlot::Still);
+    if b_p(p, "transparent") == Some(false) {
+        it.output.channels = Channels::Rgb;
+    }
     if let Some(path) = str_p(p, "path") {
         it.output.output = path.to_string();
-    } else if !it.output.format.is_sequence() {
-        it.output.output = "[compName]_frame.[fileExtension]".into();
+    } else {
+        if !it.output.format.is_sequence() {
+            it.output.output = "[compName]_frame.[fileExtension]".into();
+        }
+        s.avoid_sources(&mut it);
     }
     let id = s.edit("Save Frame As", None, |proj, _| {
         it.id = proj.render_queue.iter().map(|i| i.id).max().unwrap_or(0) + 1;
@@ -107,19 +271,20 @@ fn queue_frame(s: &mut Session, p: &Value) -> Result<Value> {
 }
 
 fn save_frame(s: &mut Session, p: &Value) -> Result<Value> {
-    if p.get("queue").and_then(Value::as_bool) == Some(true) {
+    if b_p(p, "queue") == Some(true) {
         return queue_frame(s, p);
     }
     let path = str_p(p, "path").ok_or_else(|| bad("comp.saveFrameAs", "missing `path` (.png)"))?.to_string();
+    s.refuse_export(&path)?;
     let cid = comp_id(s, p)?;
     let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
     let t = f_p(p, "time").map(Tick::from_seconds_f64).unwrap_or(s.time());
     let scale = f_p(p, "scale").unwrap_or(1.0).clamp(0.01, 4.0);
     let bg = comp.background;
     let img = s.render(cid, t, effectcraft_render::RenderOpts { scale, backend: effectcraft_render::Backend::Auto, ..Default::default() });
-    let rgba = img.to_rgba8_over(bg);
+    let rgba = if b_p(p, "transparent") == Some(false) { img.to_rgba8_over(bg) } else { img.to_rgba8() };
     let png = encode_png(&rgba, img.width, img.height).map_err(|e| EngineError::Other(format!("PNG encoding failed: {e}")))?;
-    s.services.write_file(&path, &png).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+    s.write_output(&path, &png)?;
     s.toast(format!("Saved frame to {path}"));
     Ok(json!({"path": path, "width": img.width, "height": img.height, "time": t.seconds()}))
 }
@@ -230,12 +395,21 @@ pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!("comp.cropToRegionOfInterest", "Crop Comp to Region of Interest", ["Composition"], None, "{comp?}", has_roi, crop_to_roi),
         cmd!("comp.cropToLayerBounds", "Crop Comp to Selected Layer(s) Bounds", ["Composition"], None, "{layers?}", has_layers, crop_to_layers),
+        cmd!(
+            "comp.scale",
+            "Scale Composition",
+            [],
+            None,
+            "{comp?, factor? (2 = twice the size) | width? | height? (the other side keeps the aspect ratio)}",
+            has_comp,
+            scale_comp
+        ),
         cmd!(
             "comp.saveFrameAs",
             "File...",
             ["Composition", "Save Frame As"],
             Some("Cmd+Alt+S"),
-            "{path (.png; with queue: an output path or template), time?, scale?, queue?: bool (add a Render Queue item from the Frame Default templates instead of writing now)}",
+            "{path (.png; with queue: an output path or template), time?, scale?, queue?: bool (add a Render Queue item from the Frame Default templates instead of writing now), transparent?: bool (default true)}",
             has_comp,
             save_frame
         ),
diff --git a/crates/engine/src/commands/content_fill.rs b/crates/engine/src/cmd/content_fill.rs
similarity index 91%
rename from crates/engine/src/commands/content_fill.rs
rename to crates/engine/src/cmd/content_fill.rs
index 650df5e73..d96be073d 100644
--- a/crates/engine/src/commands/content_fill.rs
+++ b/crates/engine/src/cmd/content_fill.rs
@@ -170,6 +170,21 @@ pub struct FillPlan {
     pub dir: String,
 }
 
+/// The fill holds every frame as float RGBA (16 bytes a pixel), its hole mask (1) and the filled
+/// copy (16) until it finishes (#1789): when even that is more than `available`, the error to
+/// report up front, instead of running out of memory partway through.
+fn memory_shortfall(frames: usize, w: u32, h: u32, available: u64) -> Option<String> {
+    let need = (frames as u64).saturating_mul(u64::from(w)).saturating_mul(u64::from(h)).saturating_mul(33);
+    (need > available).then(|| {
+        let gb = |b: u64| b as f64 / 1e9;
+        format!(
+            "Content-Aware Fill of {frames} frames at {w}×{h} needs at least {:.1} GB of memory, and {:.1} GB is free: fill a shorter range (set the work area and choose Work Area) or close other applications",
+            gb(need),
+            gb(available)
+        )
+    })
+}
+
 /// Run a fill: the layer's frames (rendered in passes with a job worker's GPU), the fill, the
 /// PNG sequence written into `plan.dir` (`Services::store_file`). Returns the files.
 #[allow(clippy::too_many_arguments)]
@@ -275,6 +290,9 @@ fn generate(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let (fa, fb) = (fr.frame_at(fr.snap_nearest(a)), fr.frame_at(b - Tick(1)));
     let times: Vec<Tick> = (fa..=fb).map(|f| fr.tick_of(f)).collect();
+    if let Some(e) = crate::sysinfo::memory().and_then(|m| memory_shortfall(times.len(), w, h, m.available)) {
+        return Err(bad(c, e));
+    }
     let opts = FillOpts {
         method: FillMethod::from_name(&st.method).unwrap_or_default(),
         lighting: lighting(&st.lighting_correction).unwrap_or(0.0),
@@ -424,3 +442,18 @@ pub fn specs() -> Vec<CommandSpec> {
         },
     ]
 }
+
+#[cfg(test)]
+mod tests {
+    use super::memory_shortfall;
+
+    /// #1789: 10 s of 1080p30 (300 frames) needs at least 20 GB, which 4 GB free can't hold.
+    #[test]
+    fn a_fill_that_cannot_fit_in_memory_is_refused_up_front() {
+        let e = memory_shortfall(300, 1920, 1080, 4_000_000_000).expect("refused");
+        assert!(e.contains("300 frames") && e.contains("Work Area"), "{e}");
+        assert_eq!(memory_shortfall(30, 1920, 1080, 4_000_000_000), None, "a second of it fits");
+        // Hostile sizes saturate instead of overflowing.
+        assert!(memory_shortfall(usize::MAX, u32::MAX, u32::MAX, u64::MAX - 1).is_some());
+    }
+}
diff --git a/crates/engine/src/commands/create.rs b/crates/engine/src/cmd/create.rs
similarity index 71%
rename from crates/engine/src/commands/create.rs
rename to crates/engine/src/cmd/create.rs
index 850d38ada..6c4b02c87 100644
--- a/crates/engine/src/commands/create.rs
+++ b/crates/engine/src/cmd/create.rs
@@ -1,14 +1,17 @@
 //! Layer ▸ Create: Convert to Editable Text (Photoshop type layers), Create Shapes from Text,
-//! Create Masks from Text and Create Shapes from Vector Layer (SVG footage).
+//! Create Masks from Text, Create Shapes from Vector Layer (SVG footage) and Create 3D Layer
+//! Instance (a 2D copy of a 3D model layer that 2D effects can be applied to).
 
 use effectcraft_color::Label;
+use effectcraft_keyframe::Value as KV;
+use effectcraft_project::build::{self, Ids};
 use effectcraft_project::{ItemKind, LayerSource, Solid};
 use serde_json::{Value, json};
 
 use super::{CommandSpec, bad, has_layers, layers_p, str_p};
 use crate::{EngineError, Result, Session, cmd};
 
-const OPS: &str = "editableText|shapesFromText|masksFromText|shapesFromVector";
+const OPS: &str = "editableText|shapesFromText|masksFromText|shapesFromVector|instance3d";
 
 fn create(s: &mut Session, p: &Value) -> Result<Value> {
     let op = str_p(p, "op").ok_or_else(|| bad("layer.create", format!("missing `op` ({OPS})")))?;
@@ -19,6 +22,69 @@ fn create(s: &mut Session, p: &Value) -> Result<Value> {
     let time = s.time();
     let mut created = vec![];
     let mut skipped = vec![];
+    // All the selected models in one edit: one undo (or redo) removes (or restores) every
+    // instance at once, as one command in the History panel.
+    if op == "instance3d" {
+        // After Effects' Create 3D Layer Instance (Layer ▸ Create): 3D model layers take
+        // no masks or effects, so a comp-sized solid goes at the top of the layer stack
+        // with a 3D Layer Instance effect referencing the model — a 2D copy of its render,
+        // through the comp's camera, that 2D effects can be applied to. The model is switched
+        // off, as After Effects does (back on to keep its shadow).
+        let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
+        let mut eligible = vec![];
+        for lid in &lids {
+            match comp.layer(*lid) {
+                Some(src) if src.source.is_model() => eligible.push((*lid, src.clone())),
+                Some(src) => skipped.push(format!("{}: not a 3D model layer", src.name)),
+                None => {}
+            }
+        }
+        if !eligible.is_empty() {
+            let ids = s.edit("Create 3D Layer Instance", None, |proj, st| {
+                let mut ids = vec![];
+                for (lid, src) in &eligible {
+                    let name = proj.comp(cid).ok_or(EngineError::NoComp)?.unique_layer_name(&format!("{} Instance", src.name));
+                    let folder = proj.folder_named("Solids").unwrap_or_else(|| proj.add_item("Solids", Label::Yellow, None, ItemKind::Folder));
+                    let sid = proj.add_item(
+                        &name,
+                        src.label,
+                        Some(folder),
+                        ItemKind::Solid(Solid { color: [1.0, 1.0, 1.0], width: comp.width, height: comp.height, pixel_aspect: 1.0 }),
+                    );
+                    let mut l = build::layer(proj, &comp, &name, LayerSource::Solid { item: sid }, (comp.width, comp.height), None);
+                    // A soloed source keeps its Solo switch with video off, and any_solo hides
+                    // the non-soloed copy: the copy takes the Solo over to stay visible.
+                    l.switches.solo = src.switches.solo;
+                    // A 3D Layer Instance effect referencing the 3D layer: the solid shows its
+                    // render (the 2D copy).
+                    let fx = effectcraft_effects::find("ec.3d.instance3d").ok_or_else(|| bad("layer.create", "the 3D Layer Instance effect is missing"))?;
+                    let mut g = effectcraft_effects::instantiate(fx, &mut Ids(&mut proj.next_id), fx.name, [comp.width as f64, comp.height as f64]);
+                    if let Some(pr) = g.get_mut("layer") {
+                        pr.value = KV::Layer(Some(lid.0));
+                    }
+                    if let Some(fxg) = l.props.sub_mut("effects") {
+                        fxg.children.push(g.into());
+                    }
+                    // The model is switched off (After Effects turns the referenced layer off);
+                    // the copies go at the top of the stack, selected.
+                    let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+                    if let Some(m) = c.layers.iter_mut().find(|x| x.id == *lid) {
+                        m.switches.video = false;
+                    }
+                    let id = l.id;
+                    c.layers.insert(0, l);
+                    ids.push(id);
+                }
+                st.selected_layers = ids.clone();
+                Ok(ids)
+            })?;
+            created.extend(ids.iter().map(|i| i.0));
+        }
+        if created.is_empty() && !skipped.is_empty() {
+            return Err(bad("layer.create", skipped.join("; ")));
+        }
+        return Ok(json!({"layers": created, "skipped": skipped}));
+    }
     for lid in lids {
         let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
         let Some(src) = comp.layer(lid).cloned() else { continue };
@@ -198,5 +264,5 @@ fn insert_above(
 }
 
 pub fn specs() -> Vec<CommandSpec> {
-    vec![cmd!("layer.create", "Create", [], None, "{op: editableText|shapesFromText|masksFromText|shapesFromVector, layers?}", has_layers, create)]
+    vec![cmd!("layer.create", "Create", [], None, "{op: editableText|shapesFromText|masksFromText|shapesFromVector|instance3d, layers?}", has_layers, create)]
 }
diff --git a/crates/engine/src/commands/edit.rs b/crates/engine/src/cmd/edit.rs
similarity index 88%
rename from crates/engine/src/commands/edit.rs
rename to crates/engine/src/cmd/edit.rs
index 6a8194395..8a5068e8f 100644
--- a/crates/engine/src/commands/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -2,11 +2,11 @@
 
 use effectcraft_color::Label;
 use effectcraft_keyframe::Value as KV;
-use effectcraft_project::{Comp, Expression, ItemKind, Layer, LayerId, LayerSource, TrackMatte};
+use effectcraft_project::{Comp, Expression, ItemId, ItemKind, Layer, LayerId, LayerSource, TrackMatte};
 use effectcraft_time::Tick;
 use serde_json::{Value, json};
 
-use super::{CommandSpec, has_comp, has_layers, layers_p, match_path_of, selected_leaf_props, str_p};
+use super::{CommandSpec, has_comp, has_layers, layers_or, layers_p, match_path_of, selected_leaf_props, str_p};
 use crate::{EngineError, KeyRef, LinkClip, Result, Session, cmd};
 
 fn can_undo(s: &Session) -> std::result::Result<(), String> {
@@ -25,6 +25,7 @@ fn has_clip(s: &Session) -> std::result::Result<(), String> {
         && s.state.key_clipboard.is_empty()
         && s.state.effect_clipboard.is_empty()
         && s.state.contents_clipboard.is_empty()
+        && s.state.mask_clipboard.is_empty()
         && s.state.link_clipboard.is_none()
         && s.state.value_clipboard.is_empty()
     {
@@ -74,9 +75,9 @@ fn select_all(s: &mut Session, _: &Value) -> Result<Value> {
     Ok(json!(s.state.selected_layers.len()))
 }
 fn deselect_all(s: &mut Session, _: &Value) -> Result<Value> {
-    // A deselected layer never keeps an open text edit: commit the edit first, exactly as
-    // `text.endEdit` (an empty Type-tool layer included), so every route — menu, shortcut,
-    // script, MCP — leaves one final state.
+    // A deselected layer never keeps an open text edit: commit it first, exactly as `text.endEdit`,
+    // so every route — menu, shortcut, script, MCP — leaves one final state. An empty Type-tool
+    // layer survives, as it does in After Effects.
     super::text_edit::end_edit(s, &Value::Null)?;
     s.state.selected_layers.clear();
     s.state.selected_props.clear();
@@ -90,7 +91,7 @@ fn deselect_all(s: &mut Session, _: &Value) -> Result<Value> {
 fn relink_copies(comp: &mut Comp, map: &[(LayerId, LayerId)]) {
     let present: Vec<LayerId> = comp.layers.iter().map(|l| l.id).collect();
     let link = |id: LayerId| map.iter().find(|(o, _)| *o == id).map(|(_, c)| *c).or(present.contains(&id).then_some(id));
-    for l in comp.layers.iter_mut().filter(|l| map.iter().any(|(_, c)| *c == l.id)) {
+    for l in comp.layers.iter_mut_where(|l| map.iter().any(|(_, c)| *c == l.id)) {
         l.parent = l.parent.and_then(link);
         l.track_matte = l.track_matte.and_then(|m| link(m.layer).map(|layer| TrackMatte { layer, ..m }));
     }
@@ -104,9 +105,16 @@ pub(crate) fn reid(layer: &mut Layer, next: &mut u64) {
     *next += 1;
 }
 
+/// `edit.duplicate`: copies the targets in place. Without `layers` the targets are, in order:
+/// during a text edit the edited layer (the edit is committed first, as `text.endEdit` does),
+/// else the selected effects, shape items or text animators, else the selected layers. Layer
+/// copies are selected and their ids returned; the other paths return their delegated result.
 fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
-    // Effects selected → duplicate them (Edit ▸ Duplicate in Effect Controls).
-    if p.get("layers").is_none() {
+    let editing = s.state.text_edit.is_some();
+    // Effects selected → duplicate them (Edit ▸ Duplicate in Effect Controls). An open text edit
+    // comes first, as it does for Clear: opening the editor keeps the property selection, but
+    // while typing, Duplicate means the edited layer, not an effect or item selected before.
+    if p.get("layers").is_none() && !editing {
         let fx = super::effect::selected_effects(s);
         if !fx.is_empty() {
             let mut out = vec![];
@@ -126,7 +134,17 @@ fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
             return super::prop_groups::duplicate_contents(s, &items);
         }
     }
-    let (cid, ids) = layers_p(s, p)?;
+    // A deselected layer never keeps an open text edit (#2226): the copies take the selection, so
+    // commit an open edit first, exactly as `text.endEdit` and Deselect All do — one call on the
+    // command path so every route (menu, shortcut, palette, MCP, script) ends the edit and leaves
+    // the same final state. Unnamed, the target is the edited layer even when an engine route
+    // selected another one meanwhile.
+    let edited = s.state.text_edit.as_ref().map(|e| e.layer);
+    super::text_edit::end_edit(s, &Value::Null)?;
+    let (cid, ids) = match edited {
+        Some(layer) => layers_or(s, p, &[layer])?,
+        None => layers_p(s, p)?,
+    };
     let new = s.edit("Duplicate", None, |proj, st| {
         let mut next = proj.next_id;
         let comp = proj.comp_mut(cid).ok_or(crate::EngineError::NoComp)?;
@@ -143,52 +161,86 @@ fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
         }
         relink_copies(comp, &map);
         proj.next_id = next;
-        st.selected_layers = created.clone();
+        // The property, keyframe and mask-vertex selection the edit kept belongs to the originals;
+        // left in place, the next Duplicate or Clear would act on it, not on the copies. So during
+        // an edit the copies take the selection the way a click on them would.
+        if editing {
+            super::layer::select_only(st, created.clone());
+        } else {
+            st.selected_layers = created.clone();
+        }
         Ok(created)
     })?;
     Ok(json!(new.iter().map(|l| l.0).collect::<Vec<_>>()))
 }
 
+/// `edit.clear`: delegates to `text.delete` while editing text (deleting the selection or
+/// preceding character/word), then handles selected Time Remap (turning remapping off), keyframes, loose mask
+/// vertices, puppet pins, effects, masks/shape items/text animators/trackers, and finally the
+/// selected (or given) unlocked layers. Layer and selected-property-group paths return the number
+/// removed; text, Time Remap, keyframe, loose-vertex, puppet-pin and effect paths return their
+/// delegated command's result.
+///
+/// Layer removal also unparents surviving children in place, clears track mattes that pointed
+/// at a removed layer and rewrites layer-reference values and keys to `None` in the same undo
+/// step; the text-edit session is then sanitized so a removed layer's editor is not reused.
 fn delete(s: &mut Session, p: &Value) -> Result<Value> {
-    if s.state.text_edit.is_some() && p.get("layers").is_none() {
-        return s.execute("text.delete", json!({}));
+    if let Some(done) = delete_selection(s, p)? {
+        return Ok(done);
+    }
+    let (cid, ids) = layers_p(s, p)?;
+    let ids = super::unlocked(s, cid, ids, "edit.clear")?;
+    clear_layers(s, cid, &ids)?;
+    // A removed layer may have been the edited one: end that session before another command
+    // can reuse it. Undo restores a layer as a new editor, never by reviving the old IME session.
+    s.sanitize_state();
+    Ok(json!(ids.len()))
+}
+
+/// Deletes the selected things that are not layers. `None` when the layers are deleted
+/// instead (nothing else is selected, or the command names its layers).
+fn delete_selection(s: &mut Session, p: &Value) -> Result<Option<Value>> {
+    let no_layers = p.get("layers").is_none();
+    if s.state.text_edit.is_some() && no_layers {
+        return Ok(Some(s.execute("text.delete", json!({}))?));
     }
     // Time Remap selected (its name, which selects all its keys) → time remapping off, not the
     // layer (After Effects).
-    if p.get("layers").is_none() {
+    if no_layers {
         let remapped = super::layer_time::selected_time_remap(s);
         if !remapped.is_empty() {
-            return super::layer_time::disable_time_remap(s, &remapped);
+            return Ok(Some(super::layer_time::disable_time_remap(s, &remapped)?));
         }
     }
     // Keyframes selected → delete keys; mask vertices → delete them; else layers.
-    if !s.state.selected_keys.is_empty() && p.get("layers").is_none() {
-        return s.execute("keys.delete", json!({}));
+    if !s.state.selected_keys.is_empty() && no_layers {
+        return Ok(Some(s.execute("keys.delete", json!({}))?));
     }
     // (Points selected with their mask, which selecting a mask does: the mask goes, below.)
     let comp = s.active_comp();
     let loose = s.state.selected_vertices.iter().any(|v| {
         !s.state.selected_props.contains(&(v.layer, v.mask)) && comp.and_then(|c| c.layer(v.layer)).is_some_and(|l| l.props.find_group(v.mask).is_some())
     });
-    if loose && p.get("layers").is_none() {
-        return s.execute("mask.deleteVertices", json!({}));
+    if loose && no_layers {
+        return Ok(Some(s.execute("mask.deleteVertices", json!({}))?));
     }
     // Puppet pins selected → delete the pins (not their layer).
-    if p.get("layers").is_none() && !super::puppet::selected_pins(s).is_empty() {
-        return s.execute("puppet.removePin", json!({}));
+    if no_layers && !super::puppet::selected_pins(s).is_empty() {
+        return Ok(Some(s.execute("puppet.removePin", json!({}))?));
     }
     // Effects selected → remove them.
-    if p.get("layers").is_none() && !super::effect::selected_effects(s).is_empty() {
-        return s.execute("effect.remove", json!({}));
+    if no_layers && !super::effect::selected_effects(s).is_empty() {
+        return Ok(Some(s.execute("effect.remove", json!({}))?));
     }
     // Masks, shape items, text animators or trackers selected → remove them.
-    if p.get("layers").is_none()
-        && let Some(n) = super::prop_groups::remove_selected(s)?
-    {
-        return Ok(n);
+    if no_layers && let Some(n) = super::prop_groups::remove_selected(s)? {
+        return Ok(Some(n));
     }
-    let (cid, ids) = layers_p(s, p)?;
-    let ids = super::unlocked(s, cid, ids, "edit.clear")?;
+    Ok(None)
+}
+
+/// Removes layers `ids` from comp `cid` in one undoable step, and clears what referred to them.
+fn clear_layers(s: &mut Session, cid: ItemId, ids: &[LayerId]) -> Result<()> {
     // Children of deleted layers are unparented where they are (like After Effects).
     let comp = s.project.comp(cid).ok_or(crate::EngineError::NoComp)?;
     let orphans: Vec<LayerId> = comp.layers.iter().filter(|l| !ids.contains(&l.id) && l.parent.is_some_and(|p| ids.contains(&p))).map(|l| l.id).collect();
@@ -226,11 +278,7 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
         st.selected_props.clear();
         st.selected_keys.clear();
         Ok(())
-    })?;
-    // A removed layer may have been the edited one: end that session before another command
-    // can reuse it. Undo restores a layer as a new editor, never by reviving the old IME session.
-    s.sanitize_state();
-    Ok(json!(ids.len()))
+    })
 }
 
 fn clear_clipboards(s: &mut Session) {
@@ -238,8 +286,10 @@ fn clear_clipboards(s: &mut Session) {
     s.state.key_clipboard.clear();
     s.state.effect_clipboard.clear();
     s.state.contents_clipboard.clear();
+    s.state.mask_clipboard.clear();
     s.state.link_clipboard = None;
     s.state.value_clipboard.clear();
+    s.state.keyframe_text = None;
     s.state.clip_is_keys = false;
 }
 
@@ -263,6 +313,16 @@ fn copy(s: &mut Session, p: &Value) -> Result<Value> {
     if p.get("layers").is_none() && !super::effect::selected_effects(s).is_empty() {
         return s.execute("effect.copy", json!({}));
     }
+    // Masks selected → copy them (not their layer), for Paste onto other layers (#2091), unless
+    // a layer is named explicitly.
+    if p.get("layers").is_none() && p.get("layer").is_none_or(Value::is_null) {
+        let masks = super::prop_groups::copy_masks(s);
+        if !masks.is_empty() {
+            clear_clipboards(s);
+            s.state.mask_clipboard = masks;
+            return Ok(json!({"masks": s.state.mask_clipboard.len()}));
+        }
+    }
     // Shape items selected in a shape layer's Contents → copy them (not their layer).
     if p.get("layers").is_none() {
         let items = super::prop_groups::copy_contents(s);
@@ -306,10 +366,12 @@ fn copy_properties(s: &mut Session) -> Result<Option<Value>> {
     }
     let mut keys = s.state.selected_keys.clone();
     let mut values = vec![];
+    let mut statics = vec![];
     for (lid, uid) in &leaves {
         let Some(l) = comp.layer(*lid) else { continue };
         let Some(pr) = l.props.find(*uid) else { continue };
         if pr.keys.is_empty() {
+            statics.push((*lid, *uid));
             if let Some(path) = l.props.match_path_of(*uid)
                 && !values.iter().any(|(p, _)| *p == path)
             {
@@ -319,6 +381,7 @@ fn copy_properties(s: &mut Session) -> Result<Option<Value>> {
             keys.extend(pr.keys.iter().map(|k| KeyRef { layer: *lid, prop: *uid, time: k.time }));
         }
     }
+    let text = crate::keyframe_text::text(&s.project, comp, &keys, &statics);
     clear_clipboards(s);
     let mut n = 0;
     if !keys.is_empty() {
@@ -327,6 +390,7 @@ fn copy_properties(s: &mut Session) -> Result<Option<Value>> {
         s.state.selected_keys = selected;
         n = r?.as_u64().unwrap_or(0);
     }
+    s.state.keyframe_text = text;
     let v = values.len();
     s.state.value_clipboard = values;
     // Keys alone answer as `keys.copy` does (their count).
@@ -545,6 +609,9 @@ fn paste(s: &mut Session, p: &Value) -> Result<Value> {
     if !s.state.contents_clipboard.is_empty() {
         return super::prop_groups::paste_contents(s, p);
     }
+    if !s.state.mask_clipboard.is_empty() {
+        return super::prop_groups::paste_masks(s, p);
+    }
     let cid = super::comp_id(s, p)?;
     let clip = s.state.clipboard.clone();
     let new = s.edit("Paste", None, |proj, st| {
@@ -652,7 +719,7 @@ fn label(s: &mut Session, p: &Value) -> Result<Value> {
             }
         }
         if let Some(comp) = proj.comp_mut(cid) {
-            for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+            for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
                 l.label = lab;
             }
         }
@@ -824,10 +891,12 @@ pub(crate) fn disk_stats(s: &mut Session, _: &Value) -> Result<Value> {
         "layers": dc.keys(effectcraft_render::disk_cache::Kind::Layer).len(),
         "bytes": st.bytes,
         "maxBytes": st.max_bytes,
+        "limitBytes": st.limit_bytes,
         "hits": st.hits,
         "misses": st.misses,
         "writes": st.writes,
         "evictions": st.evictions,
+        "failed": st.failed,
     }))
 }
 
@@ -933,7 +1002,15 @@ pub fn specs() -> Vec<CommandSpec> {
             paste_reversed
         ),
         cmd!("edit.clear", "Clear", ["Edit"], Some("Delete"), "{layers?}", layers_or_keys, delete),
-        cmd!("edit.duplicate", "Duplicate", ["Edit"], Some("Cmd+D"), "{layers?} (effects or shape items when they are selected)", has_layers, duplicate),
+        cmd!(
+            "edit.duplicate",
+            "Duplicate",
+            ["Edit"],
+            Some("Cmd+D"),
+            "{layers?} (without layers: during a text edit the edited layer, else the selected effects, shape items or text animators, else the selected layers)",
+            layers_or_text_edit,
+            duplicate
+        ),
         cmd!("edit.splitLayer", "Split Layer", ["Edit"], Some("Cmd+Shift+D"), "{layers?}", has_layers, split),
         cmd!("edit.liftWorkArea", "Lift Work Area", ["Edit"], None, "{layers?}", has_comp, lift),
         cmd!("edit.extractWorkArea", "Extract Work Area", ["Edit"], None, "{layers?}", has_comp, extract),
@@ -1003,6 +1080,11 @@ fn layers_or_keys(s: &Session) -> std::result::Result<(), String> {
     if !s.state.selected_keys.is_empty() || !s.state.selected_vertices.is_empty() { super::has_comp(s) } else { has_layers(s) }
 }
 
+/// Duplicate's unnamed target: the edited layer during a text edit, else the selection.
+fn layers_or_text_edit(s: &Session) -> std::result::Result<(), String> {
+    if s.state.text_edit.is_some() { super::has_comp(s) } else { has_layers(s) }
+}
+
 fn always_ok(_: &Session) -> std::result::Result<(), String> {
     Ok(())
 }
diff --git a/crates/engine/src/commands/effect.rs b/crates/engine/src/cmd/effect.rs
similarity index 69%
rename from crates/engine/src/commands/effect.rs
rename to crates/engine/src/cmd/effect.rs
index 4f263b6fb..f41ba3f9c 100644
--- a/crates/engine/src/commands/effect.rs
+++ b/crates/engine/src/cmd/effect.rs
@@ -136,7 +136,16 @@ fn warning(s: &mut Session, p: &Value) -> Result<Value> {
     let layer = comp.layer(lid).ok_or(EngineError::NoComp)?;
     let g = layer.effects().and_then(|fx| fx.groups().find(|g| g.uid == uid)).ok_or_else(|| bad(cmd, "no such effect"))?;
     let t = super::time_p(s, p, Some(comp));
-    let ctx = effectcraft_render::EvalCtx { project: &s.project, comp_id: cid, comp, time: t, expr: s.expr.as_deref(), footage: None };
+    let ctx = effectcraft_render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time: t,
+        expr: s.expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     Ok(json!({"effect": uid, "warning": effectcraft_effects::warning(g, &mut |pr| ctx.value(layer, pr))}))
 }
 
@@ -160,7 +169,16 @@ fn pick_color(s: &mut Session, p: &Value) -> Result<Value> {
     .filter(|pr| pr.ui == effectcraft_project::ParamUi::Color)
     .ok_or_else(|| bad(cmd, "not a colour parameter of this effect"))?;
     let t = super::time_p(s, p, Some(comp));
-    let ctx = effectcraft_render::EvalCtx { project: &s.project, comp_id: cid, comp, time: t, expr: s.expr.as_deref(), footage: None };
+    let ctx = effectcraft_render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time: t,
+        expr: s.expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let mut r = effectcraft_render::Renderer::new(&s.project, &*s.footage, effectcraft_render::RenderOpts::default());
     r.expr = s.expr.as_deref();
     r.cache = Some(&s.layer_cache);
@@ -190,6 +208,7 @@ fn pick_color(s: &mut Session, p: &Value) -> Result<Value> {
 /// Cryptomatte layer, with the aux channels (for the manifest) and the effect's Selection.
 struct CryptoHit {
     at: (effectcraft_project::ItemId, LayerId, Tick),
+    probe: std::sync::Arc<CryptoProbe>,
     aux: std::sync::Arc<effectcraft_raster::AuxChannels>,
     layer: String,
     hash: u32,
@@ -210,13 +229,144 @@ impl CryptoHit {
     }
 }
 
-/// The ID under `{x, y}` (effect space, which is layer space on footage and precomp layers) for
-/// the Cryptomatte effect `{layer?, effect?}`, from the aux channels its render reads. The point
-/// snaps to the centre of the pixel the effect's input buffer samples in a render at `scale`
-/// (the viewer's resolution).
-fn crypto_hit(s: &Session, p: &Value, cmd: &str) -> Result<Option<CryptoHit>> {
+/// What a pick at one frame needs besides the point: the aux channels the Cryptomatte effect
+/// reads, its layer, and the effect's input buffer grid (scale, offset). Building it can render
+/// (a precomp's ID pass, the effects before the Cryptomatte effect); a point lookup in it is a
+/// few array reads. The session keeps the last one (see [`Session::crypto_probe_job`]).
+pub struct CryptoProbe {
+    key: ProbeKey,
+    grid: std::result::Result<ProbeGrid, String>,
+}
+
+#[derive(Clone)]
+struct ProbeGrid {
+    aux: std::sync::Arc<effectcraft_raster::AuxChannels>,
+    layer: String,
+    scale: f64,
+    offset: [f64; 2],
+}
+
+/// What a probe depends on: the project revision, the effect (and its index), the frame, the
+/// scale and the render prefs ([`Session::render_opts`]: nested switches, draft shadows).
+#[derive(Clone, Copy, PartialEq, Debug)]
+struct ProbeKey {
+    revision: u64,
+    at: (effectcraft_project::ItemId, LayerId, Uid, usize),
+    frame: ProbeFrame,
+    scale: f64,
+    prefs: (bool, bool),
+}
+
+/// The frame a probe reads. On footage whose masks and effects up to the Cryptomatte effect
+/// don't change over time, its source frame: a still has one, held or remapped frames share
+/// theirs. Otherwise the comp time.
+#[derive(Clone, Copy, PartialEq, Debug)]
+enum ProbeFrame {
+    Source(i64),
+    Comp(Tick),
+}
+
+/// The session's kept probe, and the generation of the latest request: a build stores its
+/// result only while no newer request or edit came since.
+#[derive(Default)]
+pub struct CryptoProbeSlot {
+    probe: Option<std::sync::Arc<CryptoProbe>>,
+    want: Option<ProbeKey>,
+    generation: u64,
+    /// Jobs run (each on its thread), and those that built (not cancelled before they began).
+    jobs: u64,
+    builds: u64,
+}
+
+impl CryptoProbeSlot {
+    /// Drop the kept probe and cancel builds in flight.
+    pub(crate) fn clear(&mut self) {
+        (self.probe, self.want) = (None, None);
+        self.generation += 1;
+    }
+    pub(crate) fn kept(&self) -> bool {
+        self.probe.is_some()
+    }
+    pub(crate) fn builds(&self) -> (u64, u64) {
+        (self.jobs, self.builds)
+    }
+}
+
+/// A probe built off the UI thread into the session's slot.
+pub type CryptoProbeJob = Box<dyn FnOnce() + Send>;
+
+const NO_CRYPTO: &str = "this layer has no Cryptomatte channels (a multi-layer OpenEXR with Cryptomatte, or a 3D precomp)";
+
+impl CryptoProbe {
+    /// `None` when `live` turns false between its stages (a newer request or an edit since):
+    /// a cancelled build stops early and lets go of what it read.
+    fn build(r: &effectcraft_render::Renderer, key: ProbeKey, time: Tick, live: &dyn Fn() -> bool) -> Option<CryptoProbe> {
+        let (cid, lid, _, pos) = key.at;
+        let build = || -> std::result::Result<Option<ProbeGrid>, String> {
+            let comp = r.project.comp(cid).ok_or("no composition")?;
+            let layer = comp.layer(lid).ok_or("no such layer")?;
+            let g = layer.effects().and_then(|fx| fx.groups().nth(pos)).ok_or("no such effect")?;
+            let ctx = effectcraft_render::EvalCtx {
+                project: r.project,
+                comp_id: cid,
+                comp,
+                time,
+                expr: r.expr,
+                footage: None,
+                property_overrides: &[],
+                media_overrides: &[],
+            };
+            let params = effectcraft_effects::flatten_params(g, &mut |pr| ctx.value(layer, pr));
+            let want = effectcraft_effects::CRYPTO_LAYERS.get(params.e("layer") as usize).copied().unwrap_or("CryptoAsset");
+            let aux = r.layer_aux(&ctx, layer).ok_or(NO_CRYPTO)?;
+            if !live() {
+                return Ok(None);
+            }
+            let layer_name = aux.resolve_crypto_layer(want).ok_or(NO_CRYPTO)?;
+            // The grid of the effect's input buffer (footage keeps native pixels from 3/4 scale
+            // up, proxies have their own size, earlier effects can pad it), rendered and cached.
+            if !live() {
+                return Ok(None);
+            }
+            let b = r.layer_input(&ctx, layer, pos).ok_or("this layer has no pixels")?;
+            Ok(Some(ProbeGrid { aux, layer: layer_name, scale: b.scale, offset: b.offset }))
+        };
+        // On another thread no command guard runs: a panic becomes the probe's error.
+        let grid = crate::guard::guarded("Reading the Cryptomatte IDs", || Ok(build())).unwrap_or_else(|e| Err(e.to_string()));
+        Some(CryptoProbe { key, grid: grid.transpose()? })
+    }
+}
+
+/// Whether a property in `g` other than `skip` changes over time (keyframes or an expression).
+fn moves(g: &PropGroup, skip: Option<Uid>) -> bool {
+    g.children.iter().any(|c| match c {
+        effectcraft_project::Node::Prop(p) => Some(p.uid) != skip && (p.is_animated() || p.has_expression()),
+        effectcraft_project::Node::Group(g) => moves(g, skip),
+    })
+}
+
+/// [`ProbeFrame`] of the effect at index `pos` of `layer`.
+fn probe_frame(ctx: &effectcraft_render::EvalCtx, layer: &Layer, pos: usize) -> ProbeFrame {
+    let comp = ProbeFrame::Comp(ctx.time);
+    let effectcraft_project::LayerSource::Footage { item } = layer.source else { return comp };
+    let Some(effectcraft_project::ItemKind::Footage(f)) = ctx.project.item(item).map(|i| &i.kind) else { return comp };
+    let fx = layer.effects().into_iter().flat_map(|fx| fx.groups().take(pos + 1));
+    let time_fx = |g: &PropGroup| matches!(&g.kind, GroupKind::Effect { effect } if effect.starts_with("ec.time."));
+    let still = f.kind == effectcraft_project::FootageKind::Still;
+    let blend = !still && ctx.comp.enable_frame_blending && layer.switches.frame_blend != effectcraft_project::FrameBlend::Off;
+    // The Cryptomatte effect's own Selection isn't read by the probe: animated, it keeps it.
+    let own = |i: usize, g: &PropGroup| if i == pos { g.prop("selection").map(|p| p.uid) } else { None };
+    if blend || layer.masks().is_some_and(|m| moves(m, None)) || fx.enumerate().any(|(i, g)| moves(g, own(i, g)) || time_fx(g)) {
+        return comp;
+    }
+    ProbeFrame::Source(if still { 0 } else { effectcraft_render::frame_position(ctx.source_time(layer), f.frame_rate).0 })
+}
+
+/// The Cryptomatte effect `{layer?, effect?, scale?, time?}` names: its probe key, the comp
+/// time, its layer, group and Selection property.
+#[allow(clippy::type_complexity)]
+fn probe_key<'a>(s: &'a Session, p: &Value, cmd: &str) -> Result<(ProbeKey, Tick, &'a Layer, &'a PropGroup, &'a effectcraft_project::Property)> {
     let (cid, lid, fx_uid) = find_fx(s, p, cmd)?;
-    let (Some(x), Some(y)) = (f_p(p, "x"), f_p(p, "y")) else { return Err(bad(cmd, "missing `x` / `y` (layer pixels)")) };
     let scale = f_p(p, "scale").unwrap_or(1.0);
     if !(scale.is_finite() && scale > 0.0 && scale <= 1.0) {
         return Err(bad(cmd, "`scale` is the preview's resolution factor, above 0 and at most 1"));
@@ -227,30 +377,193 @@ fn crypto_hit(s: &Session, p: &Value, cmd: &str) -> Result<Option<CryptoHit>> {
     let pos = fx.groups().position(|g| g.uid == fx_uid).ok_or_else(|| bad(cmd, "no such effect"))?;
     let g = fx.groups().nth(pos).ok_or_else(|| bad(cmd, "no such effect"))?;
     let prop = g.prop("selection").filter(|_| g.match_id == "ec.3d.cryptomatte").ok_or_else(|| bad(cmd, "not a Cryptomatte effect"))?;
-    let t = super::time_p(s, p, Some(comp));
-    let ctx = effectcraft_render::EvalCtx { project: &s.project, comp_id: cid, comp, time: t, expr: s.expr.as_deref(), footage: None };
-    let params = effectcraft_effects::flatten_params(g, &mut |pr| ctx.value(layer, pr));
-    let r = s.renderer(effectcraft_render::RenderOpts { scale, ..Default::default() });
-    let aux = r.layer_aux(&ctx, layer);
-    let want = effectcraft_effects::CRYPTO_LAYERS.get(params.e("layer") as usize).copied().unwrap_or("CryptoAsset");
-    let Some((aux, layer_name)) = aux.and_then(|a| a.resolve_crypto_layer(want).map(|l| (a, l))) else {
-        return Err(bad(cmd, "this layer has no Cryptomatte channels (a multi-layer OpenEXR with Cryptomatte, or a 3D precomp)"));
+    let time = super::time_p(s, p, Some(comp));
+    let ctx = effectcraft_render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time,
+        expr: s.expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
     };
-    // The grid of the effect's input buffer (footage keeps native pixels from 3/4 scale up,
-    // proxies have their own size, earlier effects can pad it), rendered and cached.
-    let b = r.layer_input(&ctx, layer, pos).ok_or_else(|| bad(cmd, "this layer has no pixels"))?;
+    let frame = probe_frame(&ctx, layer, pos);
+    let o = s.render_opts(Default::default());
+    let prefs = (o.nested_switches, o.draft_shadows);
+    Ok((ProbeKey { revision: s.revision, at: (cid, lid, fx_uid, pos), frame, scale, prefs }, time, layer, g, prop))
+}
+
+/// The kept probe if it answers for the current revision, for [`keep_crypto_probe`] (taken
+/// before an undo, redo or history jump).
+pub(crate) fn kept_crypto_probe(s: &Session) -> Option<std::sync::Arc<CryptoProbe>> {
+    s.crypto_probe.lock().ok()?.probe.clone().filter(|p| p.key.revision == s.revision)
+}
+
+/// After an undo, redo or history jump from `before` (which dropped the probe): `kept`, the
+/// probe from before, still answers when only Cryptomatte Selections changed, which the probe
+/// doesn't read (undoing a pick, as the pick itself keeps it).
+pub(crate) fn keep_crypto_probe(s: &Session, kept: Option<std::sync::Arc<CryptoProbe>>, before: &effectcraft_project::Project) {
+    let Some(p) = kept else { return };
+    if !only_crypto_selections_differ(before, &s.project) {
+        return;
+    }
+    if let Ok(mut slot) = s.crypto_probe.lock()
+        && slot.probe.is_none()
+    {
+        slot.probe = Some(std::sync::Arc::new(CryptoProbe { key: ProbeKey { revision: s.revision, ..p.key }, grid: p.grid.clone() }));
+    }
+}
+
+/// Whether projects `a` and `b` differ at most in the Selections of Cryptomatte effects.
+fn only_crypto_selections_differ(a: &effectcraft_project::Project, b: &effectcraft_project::Project) -> bool {
+    let mut x = a.clone();
+    for (cid, it) in x.items.iter_mut() {
+        let effectcraft_project::ItemKind::Comp(c) = &mut it.kind else { continue };
+        let sels: Vec<(LayerId, Uid)> = c
+            .layers
+            .iter()
+            .flat_map(|l| {
+                l.effects()
+                    .into_iter()
+                    .flat_map(|fx| fx.groups())
+                    .filter(|g| g.match_id == "ec.3d.cryptomatte")
+                    .filter_map(move |g| g.get("selection").map(|p| (l.id, p.uid)))
+            })
+            .collect();
+        if sels.is_empty() {
+            continue;
+        }
+        let Some(bc) = b.comp(*cid) else { return false };
+        let c = std::sync::Arc::make_mut(c);
+        for (lid, uid) in sels {
+            let Some(src) = bc.layer(lid).and_then(|l| l.props.find(uid)) else { return false };
+            if let Some(dst) = c.layer_mut(lid).and_then(|l| l.props.find_mut(uid)) {
+                *dst = src.clone();
+            }
+        }
+    }
+    x.same_content(b)
+}
+
+/// The session's probe when it has `key`'s.
+fn cached_probe(s: &Session, key: ProbeKey) -> Option<std::sync::Arc<CryptoProbe>> {
+    s.crypto_probe.lock().ok()?.probe.clone().filter(|p| p.key == key)
+}
+
+/// [`Session::crypto_probe_ready`].
+pub(crate) fn crypto_probe_ready(s: &Session, p: &Value) -> Result<bool> {
+    let (key, ..) = probe_key(s, p, "effect.cryptomatteAt")?;
+    Ok(cached_probe(s, key).is_some())
+}
+
+/// [`Session::crypto_probe_job`].
+pub(crate) fn crypto_probe_job(s: &Session, p: &Value) -> Result<Option<CryptoProbeJob>> {
+    let (key, time, ..) = probe_key(s, p, "effect.cryptomatteAt")?;
+    let generation = {
+        let mut slot = s.crypto_probe.lock().map_err(|_| EngineError::Other("the Cryptomatte probe is unavailable".into()))?;
+        if slot.probe.as_ref().is_some_and(|p| p.key == key) {
+            return Ok(None);
+        }
+        // A request for another probe cancels the one in flight.
+        if slot.want != Some(key) {
+            (slot.want, slot.generation) = (Some(key), slot.generation + 1);
+        }
+        slot.generation
+    };
+    let (project, footage, expr, cache, accel, slot) =
+        (s.project.clone(), s.footage.clone(), s.expr.clone(), s.layer_cache.clone(), s.accel.clone(), s.crypto_probe.clone());
+    let opts = s.render_opts(effectcraft_render::RenderOpts { scale: key.scale, ..Default::default() });
+    // The slot while this is still the newest request.
+    fn current(slot: &std::sync::Mutex<CryptoProbeSlot>, generation: u64) -> Option<std::sync::MutexGuard<'_, CryptoProbeSlot>> {
+        slot.lock().ok().filter(|s| s.generation == generation)
+    }
+    Ok(Some(Box::new(move || {
+        match slot.lock() {
+            Ok(mut s) if s.generation == generation => (s.jobs, s.builds) = (s.jobs + 1, s.builds + 1),
+            Ok(mut s) => return s.jobs += 1,
+            Err(_) => return,
+        }
+        let mut r = effectcraft_render::Renderer::new(&project, footage.as_ref(), opts);
+        r.expr = expr.as_deref();
+        r.cache = Some(&cache);
+        r.accel = accel.as_deref();
+        // Checked between its stages too: a superseded build stops at the next one.
+        let Some(probe) = CryptoProbe::build(&r, key, time, &|| current(&slot, generation).is_some()) else { return };
+        let probe = std::sync::Arc::new(probe);
+        // Only the newest request's result, and never over a newer probe.
+        if let Some(mut s) = current(&slot, generation)
+            && s.probe.as_ref().is_none_or(|p| p.key.revision <= key.revision)
+        {
+            s.probe = Some(probe);
+        }
+    })))
+}
+
+/// What a pick finds at a point.
+enum Hit {
+    /// `probeOnly` and the probe isn't built yet.
+    Pending,
+    Nothing,
+    Id(CryptoHit),
+}
+
+/// The ID under `{x, y}` (effect space, which is layer space on footage and precomp layers) for
+/// the Cryptomatte effect `{layer?, effect?}`, from the aux channels its render reads. The point
+/// snaps to the centre of the pixel the effect's input buffer samples in a render at `scale`
+/// (the viewer's resolution). Without a kept probe it builds one, unless `probeOnly`.
+fn crypto_hit(s: &Session, p: &Value, cmd: &str) -> Result<Hit> {
+    let (key, time, layer, g, prop) = probe_key(s, p, cmd)?;
+    let (Some(x), Some(y)) = (f_p(p, "x"), f_p(p, "y")) else { return Err(bad(cmd, "missing `x` / `y` (layer pixels)")) };
+    let probe = match cached_probe(s, key) {
+        Some(probe) => probe,
+        None if b_p(p, "probeOnly").unwrap_or(false) => return Ok(Hit::Pending),
+        None => {
+            let r = s.renderer(effectcraft_render::RenderOpts { scale: key.scale, ..Default::default() });
+            if let Ok(mut slot) = s.crypto_probe.lock() {
+                slot.clear();
+                slot.builds += 1;
+            }
+            // (Never cancelled here: nothing else runs on this thread.)
+            let Some(probe) = CryptoProbe::build(&r, key, time, &|| true).map(std::sync::Arc::new) else { return Ok(Hit::Pending) };
+            if let Ok(mut slot) = s.crypto_probe.lock() {
+                slot.probe = Some(probe.clone());
+            }
+            probe
+        }
+    };
+    let b = probe.grid.as_ref().map_err(|e| bad(cmd, e.clone()))?;
     let (bs, o) = (b.scale, b.offset);
     // The centre of its pixel under the point, at the aux point the effect reads there.
     let [ax, ay] = effectcraft_effects::aux_point(bs, o, [(x * bs + o[0]).floor() + 0.5, (y * bs + o[1]).floor() + 0.5]);
-    let Some(hash) = aux.index_at(ax, ay).and_then(|i| aux.crypto_id_at(&layer_name, i)) else { return Ok(None) };
-    let (selection, driven) = (params.s("selection").to_string(), prop.expr.as_ref().is_some_and(|e| e.enabled));
-    Ok(Some(CryptoHit { at: (cid, lid, t), aux, layer: layer_name, hash, selection, prop: prop.uid, driven }))
+    let Some(hash) = b.aux.index_at(ax, ay).and_then(|i| b.aux.crypto_id_at(&b.layer, i)) else { return Ok(Hit::Nothing) };
+    let (cid, lid, ..) = key.at;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let ctx = effectcraft_render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time,
+        expr: s.expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
+    let selection = effectcraft_effects::flatten_params(g, &mut |pr| ctx.value(layer, pr)).s("selection").to_string();
+    let driven = prop.expr.as_ref().is_some_and(|e| e.enabled);
+    let (aux, layer_name) = (b.aux.clone(), b.layer.clone());
+    Ok(Hit::Id(CryptoHit { at: (cid, lid, time), probe: probe.clone(), aux, layer: layer_name, hash, selection, prop: prop.uid, driven }))
 }
 
 /// `effect.cryptomatteAt`: the ID under a point, for the viewer's hover hint. The first call per
-/// frame renders the effect's input to learn its pixel grid (cached afterwards).
+/// frame renders the effect's input to learn its pixel grid (kept afterwards); with `probeOnly`
+/// it answers `{pending: true}` instead.
 fn crypto_at(s: &mut Session, p: &Value) -> Result<Value> {
-    Ok(crypto_hit(s, p, "effect.cryptomatteAt")?.map_or(Value::Null, |h| h.reply(&h.selection)))
+    Ok(match crypto_hit(s, p, "effect.cryptomatteAt")? {
+        Hit::Pending => json!({"pending": true}),
+        Hit::Nothing => Value::Null,
+        Hit::Id(h) => h.reply(&h.selection),
+    })
 }
 
 /// The Cryptomatte eyedropper: replace the effect's Selection with the ID under a point, add it
@@ -264,7 +577,11 @@ fn pick_crypto(s: &mut Session, p: &Value) -> Result<Value> {
         "remove" => PickMode::Remove,
         m => return Err(bad(cmd, format!("unknown `mode` {m:?} (replace, add or remove)"))),
     };
-    let h = crypto_hit(s, p, cmd)?.ok_or_else(|| bad(cmd, "no Cryptomatte ID there (empty or outside the layer)"))?;
+    let h = match crypto_hit(s, p, cmd)? {
+        Hit::Id(h) => h,
+        Hit::Pending => return Ok(json!({"pending": true, "changed": false})),
+        Hit::Nothing => return Err(bad(cmd, "no Cryptomatte ID there (empty or outside the layer)")),
+    };
     if h.driven {
         return Err(bad(cmd, "the Selection is driven by an expression; disable it to pick"));
     }
@@ -274,6 +591,19 @@ fn pick_crypto(s: &mut Session, p: &Value) -> Result<Value> {
     if changed {
         let (cid, lid, t) = h.at;
         s.execute("prop.set", json!({"comp": cid.0, "layer": lid.0, "prop": h.prop, "value": sel, "time": t.seconds(), "timeBase": "comp"}))?;
+        // The step says what made it (Edit ▸ Undo Pick Cryptomatte, the History panel), not
+        // "Change Property" like any other edit. (A changed Selection is always a new step.)
+        if let Some(step) = s.history.undo.last_mut() {
+            step.0 = "Pick Cryptomatte".into();
+        }
+        // Only the Selection changed, which the probe doesn't read: the next hover keeps it.
+        // (The edit dropped it; a probe built since is newer.)
+        if let Ok(mut slot) = s.crypto_probe.lock()
+            && slot.probe.is_none()
+        {
+            let key = ProbeKey { revision: s.revision, ..h.probe.key };
+            slot.probe = Some(std::sync::Arc::new(CryptoProbe { key, grid: h.probe.grid.clone() }));
+        }
     }
     let mut out = h.reply(&sel);
     out["selection"] = json!(sel);
@@ -415,7 +745,7 @@ fn effects_p(s: &Session, p: &Value, cmd: &str) -> Result<Vec<(LayerId, Uid)>> {
     Ok(sel)
 }
 
-fn effect_time_error(cmd: &str) -> EngineError {
+pub(crate) fn effect_time_error(cmd: &str) -> EngineError {
     bad(cmd, "an effect keyframe converts outside the supported time range")
 }
 
@@ -451,7 +781,7 @@ fn effect_time(layer: &Layer, time: Tick, to_comp: bool, cmd: &str) -> Result<Ti
 
 /// Change the key time coordinate system throughout an effect, including nested controls.
 /// Ease speeds are per second in that coordinate system; reversed time swaps the key sides.
-fn retime_effect(group: &mut PropGroup, scale: f64, cmd: &str, mut time: impl FnMut(Tick) -> Result<Tick>) -> Result<()> {
+pub(crate) fn retime_effect(group: &mut PropGroup, scale: f64, cmd: &str, mut time: impl FnMut(Tick) -> Result<Tick>) -> Result<()> {
     let mut result = Ok(());
     group.walk_mut(&mut |pr| {
         if result.is_err() {
@@ -519,7 +849,9 @@ fn copy(s: &mut Session, p: &Value) -> Result<Value> {
     }
     s.state.clipboard.clear();
     s.state.key_clipboard.clear();
+    s.state.keyframe_text = None;
     s.state.contents_clipboard.clear();
+    s.state.mask_clipboard.clear();
     s.state.link_clipboard = None;
     s.state.clip_is_keys = false;
     let n = groups.len();
@@ -669,8 +1001,7 @@ fn list(_: &mut Session, p: &Value) -> Result<Value> {
                 let mut out = json!({"id": p.id, "name": p.name, "type": p.default.kind_name(), "default": p.default.to_json()});
                 match &p.ui {
                     effectcraft_project::ParamUi::Popup { options } => {
-                        // Engine/MCP popup values are zero-based; JSX exposes one-based values.
-                        out["options"] = json!(options.iter().enumerate().map(|(value, label)| json!({"value": value, "label": label})).collect::<Vec<_>>());
+                        out["options"] = super::popup_options(options);
                     }
                     effectcraft_project::ParamUi::Slider { min, max, slider_min, slider_max, decimals } => {
                         out["min"] = json!(min);
@@ -732,14 +1063,14 @@ pub fn specs() -> Vec<CommandSpec> {
             "Pick Cryptomatte",
             [],
             None,
-            "{layer?, effect?: index|uid|name, x, y (effect space), mode?: replace|add|remove (default replace), scale? (preview resolution, default 1), time?} → {name, hash, layer, selection, changed, selected} — edits the Cryptomatte effect's Selection with the ID under the point",
+            "{layer?, effect?: index|uid|name, x, y (effect space), mode?: replace|add|remove (default replace), scale? (preview resolution, default 1), time?, probeOnly?} → {name, hash, layer, selection, changed, selected} | {pending} — edits the Cryptomatte effect's Selection with the ID under the point",
             has_layers,
             pick_crypto
         ),
         crate::query!(
             "effect.cryptomatteAt",
             "Cryptomatte At",
-            "{layer?, effect?: index|uid|name, x, y (effect space), scale?, time?} → {name, hash, layer, selected} | null — the Cryptomatte ID under the point",
+            "{layer?, effect?: index|uid|name, x, y (effect space), scale?, time?, probeOnly?: bool (don't build the probe)} → {name, hash, layer, selected} | {pending} | null — the Cryptomatte ID under the point",
             crypto_at
         ),
         cmd!("effect.applyLast", "Last Effect", ["Effect"], Some("Cmd+Alt+Shift+E"), "{layers?}", has_layers, last),
diff --git a/crates/engine/src/cmd/enabled.rs b/crates/engine/src/cmd/enabled.rs
new file mode 100644
index 000000000..fb28b60c4
--- /dev/null
+++ b/crates/engine/src/cmd/enabled.rs
@@ -0,0 +1,38 @@
+use super::{EngineError, Result, Session, Value};
+
+// ---------- enablement ----------
+
+pub fn always(_: &Session) -> std::result::Result<(), String> {
+    Ok(())
+}
+
+pub(crate) fn has_comp(s: &Session) -> std::result::Result<(), String> {
+    s.active_comp().map(|_| ()).ok_or_else(|| "no composition is open".into())
+}
+
+pub(crate) fn has_layers(s: &Session) -> std::result::Result<(), String> {
+    has_comp(s)?;
+    if s.state.selected_layers.is_empty() { Err("select a layer first".into()) } else { Ok(()) }
+}
+
+pub(crate) fn has_keys(s: &Session) -> std::result::Result<(), String> {
+    has_comp(s)?;
+    if s.state.selected_keys.is_empty() { Err("select keyframes first".into()) } else { Ok(()) }
+}
+
+pub(crate) fn has_project_selection(s: &Session) -> std::result::Result<(), String> {
+    if s.state.project_selection.is_empty() { Err("select an item in the Project panel first".into()) } else { Ok(()) }
+}
+
+/// Disabled-command enablement (menu entries whose implementation lands with another milestone;
+/// none are left, kept for future stubs).
+#[allow(dead_code)]
+pub(crate) fn not_yet(_: &Session) -> std::result::Result<(), String> {
+    Err("not available yet in EffectCraft".into())
+}
+
+/// `run` of a not-yet-available command.
+#[allow(dead_code)]
+pub(crate) fn not_yet_run(_: &mut Session, _: &Value) -> Result<Value> {
+    Err(EngineError::Other("not available yet in EffectCraft".into()))
+}
diff --git a/crates/engine/src/commands/essential.rs b/crates/engine/src/cmd/essential.rs
similarity index 99%
rename from crates/engine/src/commands/essential.rs
rename to crates/engine/src/cmd/essential.rs
index cb6702660..419bd7316 100644
--- a/crates/engine/src/commands/essential.rs
+++ b/crates/engine/src/cmd/essential.rs
@@ -807,6 +807,7 @@ fn export_template(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "essential.exportTemplate";
     let cid = eg_comp(s, p)?;
     let path = str_p(p, "path").ok_or_else(|| bad(C, "missing `path` (.ectemplate)"))?.to_string();
+    s.refuse_export(&path)?;
     let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
     let eg = comp.essential.clone().filter(|e| !e.controls.is_empty()).ok_or_else(|| bad(C, "the composition has no Essential Graphics controls"))?;
     let comp_name = s.project.item(cid).map(|i| i.name.clone()).unwrap_or_default();
@@ -868,7 +869,7 @@ fn export_template(s: &mut Session, p: &Value) -> Result<Value> {
     entries.insert(0, ("project.ecproj".into(), sub.to_json().into_bytes()));
     entries.insert(0, ("manifest.json".into(), serde_json::to_vec_pretty(&manifest).unwrap_or_default()));
     let bytes = effectcraft_lottie::zip::store(&entries);
-    s.services.write_file(&path, &bytes).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+    s.write_output(&path, &bytes)?;
     s.toast(format!("Exported template “{name}” to {path}"));
     Ok(json!({"path": path, "name": name, "bytes": bytes.len(), "controls": eg.flat().len(), "items": deps.len()}))
 }
diff --git a/crates/engine/src/commands/expr_tools.rs b/crates/engine/src/cmd/expr_tools.rs
similarity index 98%
rename from crates/engine/src/commands/expr_tools.rs
rename to crates/engine/src/cmd/expr_tools.rs
index fae74a5b5..cb39077af 100644
--- a/crates/engine/src/commands/expr_tools.rs
+++ b/crates/engine/src/cmd/expr_tools.rs
@@ -163,6 +163,8 @@ pub fn language_menu() -> Vec<(&'static str, Vec<(&'static str, &'static str)>)>
                 ("easeIn(t, tMin, tMax, value1, value2)", "easeIn(t, tMin, tMax, value1, value2)"),
                 ("easeOut(t, value1, value2)", "easeOut(t, value1, value2)"),
                 ("easeOut(t, tMin, tMax, value1, value2)", "easeOut(t, tMin, tMax, value1, value2)"),
+                ("bezier(t, value1, value2, [x1, y1, x2, y2])", "bezier(t, value1, value2, [x1, y1, x2, y2])"),
+                ("bezier(t, tMin, tMax, value1, value2, [x1, y1, x2, y2])", "bezier(t, tMin, tMax, value1, value2, [x1, y1, x2, y2])"),
             ],
         ),
         (
diff --git a/crates/engine/src/commands/file.rs b/crates/engine/src/cmd/file.rs
similarity index 90%
rename from crates/engine/src/commands/file.rs
rename to crates/engine/src/cmd/file.rs
index b3922c7d6..e1f58a1cc 100644
--- a/crates/engine/src/commands/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -87,7 +87,8 @@ pub(crate) fn open(s: &mut Session, p: &Value) -> Result<Value> {
 /// project opened from an XML copy saves as XML again). Fails, writing nothing, when the project
 /// wouldn't read back.
 pub(crate) fn file_text(s: &Session, path: &str) -> Result<String> {
-    let json = s.project.to_file_json_with_view(&s.saved_view())?;
+    let compact = s.prefs.project.compact_project_files && !crate::xml_project::is_xml_path(path);
+    let json = s.project.to_file_json_with_view(&s.saved_view(), compact)?;
     if crate::xml_project::is_xml_path(path) { crate::xml_project::to_xml(&json).map_err(EngineError::Other) } else { Ok(json) }
 }
 
@@ -124,7 +125,8 @@ fn revert(s: &mut Session, _: &Value) -> Result<Value> {
 }
 
 /// File ▸ Import; with `addToComp` (files dropped on the Timeline or the Composition viewer) they
-/// also become layers of the active comp ([`add_to_comp`]).
+/// also become layers of the active comp ([`add_to_comp`]); with `newComp` (the empty viewer's
+/// New Composition From Footage) they become one new composition instead ([`new_comp`]).
 ///
 /// With `background` (files dropped on the window or picked in the Import dialog) the files are
 /// probed on a background thread, so decoding a slow video doesn't freeze the app: the job shows
@@ -174,10 +176,10 @@ fn import_cmd(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(r)
 }
 
-/// After an import (its result `r`): with `addToComp`, the new items become layers of `target`;
-/// what couldn't be added joins the result's errors.
+/// After an import (its result `r`): with `newComp`, the new items become one new composition;
+/// otherwise with `addToComp`, layers of `target`. What couldn't be added joins the result's errors.
 fn finish_import(s: &mut Session, r: &mut Value, target: Option<ItemId>, p: &Value) {
-    let errors = add_to_comp(s, r, target, p);
+    let errors = if b_p(p, "newComp").unwrap_or(false) { new_comp(s, r) } else { add_to_comp(s, r, target, p) };
     if !errors.is_empty()
         && let Some(e) = r.get_mut("errors").and_then(Value::as_array_mut)
     {
@@ -191,18 +193,7 @@ fn finish_import(s: &mut Session, r: &mut Value, target: Option<ItemId>, p: &Val
 /// Project panel) and the other footage. `target` stays open. Returns what couldn't be added.
 pub(crate) fn add_to_comp(s: &mut Session, r: &Value, target: Option<ItemId>, p: &Value) -> Vec<String> {
     let Some(cid) = target.filter(|_| p.get("addToComp").and_then(Value::as_bool).unwrap_or(false)) else { return vec![] };
-    let ids = |k: &str| r.get(k).and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_u64).collect::<Vec<u64>>();
-    let comps = ids("comps");
-    let in_comps: std::collections::HashSet<u64> = comps
-        .iter()
-        .filter_map(|c| s.project.comp(ItemId(*c)))
-        .flat_map(|c| c.layers.iter())
-        .filter_map(|l| match l.source {
-            LayerSource::Footage { item } | LayerSource::Comp { item } | LayerSource::Solid { item } => Some(item.0),
-            _ => None,
-        })
-        .collect();
-    let add: Vec<u64> = comps.iter().copied().chain(ids("items").into_iter().filter(|i| !in_comps.contains(i))).collect();
+    let add = imported(s, r);
     let mut errors = vec![];
     for (k, item) in add.into_iter().enumerate() {
         let mut params = json!({"comp": cid.0, "item": item, "time": p.get("time"), "position": p.get("position")});
@@ -219,6 +210,55 @@ pub(crate) fn add_to_comp(s: &mut Session, r: &Value, target: Option<ItemId>, p:
     errors
 }
 
+/// What an import (its result `r`) made that belongs in a comp: the comps of layered files
+/// (their layers' footage, in their precomps too, stays in the Project panel), then the other items,
+/// without those comps again or the files' folders.
+fn imported(s: &Session, r: &Value) -> Vec<u64> {
+    let ids = |k: &str| r.get(k).and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_u64).collect::<Vec<u64>>();
+    let comps = ids("comps");
+    let mut in_comps = std::collections::HashSet::new();
+    let mut todo = comps.clone();
+    while let Some(c) = todo.pop() {
+        for l in s.project.comp(ItemId(c)).into_iter().flat_map(|c| c.layers.iter()) {
+            match l.source {
+                LayerSource::Comp { item } if in_comps.insert(item.0) => todo.push(item.0),
+                LayerSource::Footage { item } | LayerSource::Solid { item } => {
+                    in_comps.insert(item.0);
+                }
+                _ => {}
+            }
+        }
+    }
+    let rest = ids("items").into_iter().filter(|i| !in_comps.contains(i) && !comps.contains(i) && !s.project.item(ItemId(*i)).is_some_and(|it| it.is_folder()));
+    comps.iter().copied().chain(rest).collect()
+}
+
+/// With `newComp`, make one composition of the footage and solids an import (its result `r`)
+/// made, as New Comp from Selection does with `single` (first item on top, its settings). A comp
+/// the import made (a layered file) already is the composition, so it stays out, as does data
+/// footage; none left, no new comp. Returns what went wrong.
+fn new_comp(s: &mut Session, r: &Value) -> Vec<String> {
+    let items: Vec<ItemId> = imported(s, r)
+        .into_iter()
+        .map(ItemId)
+        .filter(|i| {
+            s.project.item(*i).is_some_and(|it| match &it.kind {
+                ItemKind::Footage(f) => f.kind != FootageKind::Data,
+                ItemKind::Solid(_) => true,
+                ItemKind::Comp(_) | ItemKind::Folder => false,
+            })
+        })
+        .collect();
+    if items.is_empty() {
+        return vec![];
+    }
+    s.state.project_selection = items;
+    match s.execute("file.newCompFromSelection", json!({"single": true})) {
+        Ok(_) => vec![],
+        Err(e) => vec![e.to_string()],
+    }
+}
+
 /// File ▸ Import, all in one go (scripts and commands built on it); see [`import_cmd`].
 pub(crate) fn import(s: &mut Session, p: &Value) -> Result<Value> {
     let pending = prepare_import(s, p)?;
@@ -745,7 +785,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "File...",
             ["File", "Import"],
             Some("Cmd+I"),
-            "{paths: [string] (files or folders), sequence?: bool (the Sequence checkbox: true imports numbered stills of one run as one image sequence, one picked file bringing its whole run and several picked files that range; default: a numbered still brings its run, except dropped files (drag), which import as stills as in After Effects; folders' runs import as sequences; false imports stills and a folder's files individually), alphabetical?: bool (Force Alphabetical Order: every image of that type in the folder, by name), frameRate?: fps (image sequences; default Settings ▸ Import ▸ Sequence Footage), importAs?: footage|composition|compositionLayerSizes (Photoshop, PDF, Illustrator and EPS files), layer?: name|index (footage of one Photoshop layer), page?: number from 1 (PDF / Illustrator page), drag?: bool (dropped files: Settings ▸ Import ▸ Default Drag Import As; files import as stills unless sequence), addToComp?: bool (also add them to the active comp, at time?, index?, position? as in layer.addItem), background?: bool (probe the files in a background job, jobs.list / jobs.wait; returns {job})}",
+            "{paths: [string] (files or folders), sequence?: bool (the Sequence checkbox: true imports numbered stills of one run as one image sequence, one picked file bringing its whole run and several picked files that range; default false: picked or dropped files import as stills, as in After Effects; folders' runs import as sequences; false imports stills and a folder's files individually), alphabetical?: bool (Force Alphabetical Order: every image of that type in the folder, by name), frameRate?: fps (image sequences; default Settings ▸ Import ▸ Sequence Footage), importAs?: footage|composition|compositionLayerSizes (Photoshop, PDF, Illustrator and EPS files), layer?: name|index (footage of one Photoshop layer), page?: number from 1 (PDF / Illustrator page), drag?: bool (dropped files: Settings ▸ Import ▸ Default Drag Import As; files import as stills unless sequence), addToComp?: bool (also add them to the active comp, at time?, index?, position? as in layer.addItem), newComp?: bool (make one new composition of the footage and solids imported, as file.newCompFromSelection with single; a layered file imported as a composition is that composition and gets no other; takes precedence over addToComp), background?: bool (probe the files in a background job, jobs.list / jobs.wait; returns {job})}",
             always,
             import_cmd
         ),
diff --git a/crates/engine/src/commands/file_more.rs b/crates/engine/src/cmd/file_more.rs
similarity index 77%
rename from crates/engine/src/commands/file_more.rs
rename to crates/engine/src/cmd/file_more.rs
index 74a86e1d8..168529c47 100644
--- a/crates/engine/src/commands/file_more.rs
+++ b/crates/engine/src/cmd/file_more.rs
@@ -5,13 +5,13 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use effectcraft_color::Label;
-use effectcraft_project::{AlphaMode, Comp, Footage, FootageKind, ItemId, ItemKind, LayerSource, Project, Solid, limits};
+use effectcraft_project::{AlphaMode, CineonSettings, CineonUnits, Comp, Footage, FootageKind, ItemId, ItemKind, LayerSource, Project, Solid, limits};
 use effectcraft_time::{FrameRate, Tick};
 use serde_json::{Value, json};
 
 use super::{CommandSpec, always, b_p, bad, f_p, has_comp, has_project_selection, str_p};
 use crate::sequence::SequenceOptions;
-use crate::{EngineError, Result, Session, cmd};
+use crate::{EngineError, Result, Session, cmd, query};
 
 fn has_footage_selection(s: &Session) -> std::result::Result<(), String> {
     if selected_footage(s).is_empty() { Err("select footage in the Project panel".into()) } else { Ok(()) }
@@ -78,11 +78,19 @@ fn close_project(s: &mut Session, _: &Value) -> Result<Value> {
 
 fn save_copy(s: &mut Session, p: &Value) -> Result<Value> {
     let path = str_p(p, "path").ok_or_else(|| bad("file.saveCopy", "missing `path`"))?;
+    s.refuse_export(path)?;
     let json = super::file::file_text(s, path)?;
-    s.services.write_file(path, json.as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+    s.write_output(path, json.as_bytes())?;
     Ok(json!({"path": path, "bytes": json.len()}))
 }
 
+/// `file.checkOutput {path}`: the commands that write to a path never replace footage, a proxy
+/// or the project file; this says beforehand, for callers that write the file themselves.
+fn check_output(s: &mut Session, p: &Value) -> Result<Value> {
+    let path = str_p(p, "path").ok_or_else(|| bad("file.checkOutput", "missing `path`"))?;
+    Ok(s.output_status(path))
+}
+
 fn rate_of(p: &Value) -> FrameRate {
     f_p(p, "frameRate").map(|f| limits::frame_rate(FrameRate::from_f64(f), FrameRate::FPS_29_97)).unwrap_or(FrameRate::FPS_29_97)
 }
@@ -376,41 +384,6 @@ fn find_missing(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn collect_files(s: &mut Session, p: &Value) -> Result<Value> {
     let folder = str_p(p, "folder").ok_or_else(|| bad("file.collectFiles", "missing `folder`"))?.trim_end_matches('/').to_string();
-    // Collect Files makes its folder (and the footage folder inside it).
-    #[cfg(not(target_arch = "wasm32"))]
-    std::fs::create_dir_all(format!("{folder}/(Footage)")).map_err(|e| EngineError::Other(format!("cannot create {folder}: {e}")))?;
-    let mut proj = (*s.project).clone();
-    let mut copied = 0;
-    let mut errors = vec![];
-    let mut used_names = BTreeSet::new();
-    for it in proj.items.values_mut() {
-        let ItemKind::Footage(f) = &mut it.kind else { continue };
-        if f.path.is_empty() {
-            continue;
-        }
-        let files: Vec<String> = if f.sequence.is_empty() { vec![f.path.clone()] } else { f.sequence.clone() };
-        let mut new_paths = vec![];
-        for src in &files {
-            let mut name = std::path::Path::new(src).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "footage".into());
-            let mut k = 2;
-            while !used_names.insert(name.clone()) {
-                name = format!("{k}_{name}");
-                k += 1;
-            }
-            let dst = format!("{folder}/(Footage)/{name}");
-            match s.services.read_file(src).and_then(|bytes| s.services.write_file(&dst, &bytes)) {
-                Ok(()) => copied += 1,
-                Err(e) => errors.push(format!("{src}: {e}")),
-            }
-            new_paths.push(dst);
-        }
-        if f.sequence.is_empty() {
-            f.path = new_paths.remove(0);
-        } else {
-            f.path = new_paths.first().cloned().unwrap_or_default();
-            f.sequence = new_paths;
-        }
-    }
     let stem = s
         .path
         .as_deref()
@@ -418,7 +391,67 @@ fn collect_files(s: &mut Session, p: &Value) -> Result<Value> {
         .map(|n| n.to_string_lossy().to_string())
         .unwrap_or_else(|| "Untitled Project".into());
     let out = format!("{folder}/{stem}.ecproj");
-    s.services.write_file(&out, proj.to_json().as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {out}: {e}")))?;
+    // Where every copy goes, before anything is made: a copy never lands on a file the project
+    // reads (other footage, a proxy, the project file itself), and then nothing is written.
+    let protected = s.protected_files();
+    let mut used_names = BTreeSet::new();
+    let mut plan: Vec<(ItemId, Vec<(String, String)>)> = vec![];
+    for it in s.project.items.values() {
+        let ItemKind::Footage(f) = &it.kind else { continue };
+        if f.path.is_empty() {
+            continue;
+        }
+        let files: Vec<&String> = if f.sequence.is_empty() { vec![&f.path] } else { f.sequence.iter().collect() };
+        let mut pairs = vec![];
+        for src in files {
+            let mut name = std::path::Path::new(src).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "footage".into());
+            let mut k = 2;
+            while !used_names.insert(name.clone()) {
+                name = format!("{k}_{name}");
+                k += 1;
+            }
+            let dst = format!("{folder}/(Footage)/{name}");
+            // A file that is already where its copy goes stays (it is not copied onto itself).
+            if !crate::output_guard::same_file(std::path::Path::new(src), std::path::Path::new(&dst))
+                && let Some(source) = protected.find(std::path::Path::new(&dst))
+            {
+                return Err(EngineError::Other(format!("Nothing was collected. {}", source.refusal(&dst, crate::output_guard::Use::Export))));
+            }
+            pairs.push((src.clone(), dst));
+        }
+        plan.push((it.id, pairs));
+    }
+    if let Some(source) = protected.find(std::path::Path::new(&out)) {
+        return Err(EngineError::Other(format!("Nothing was collected. {}", source.refusal(&out, crate::output_guard::Use::Export))));
+    }
+    // Collect Files makes its folder (and the footage folder inside it).
+    #[cfg(not(target_arch = "wasm32"))]
+    std::fs::create_dir_all(format!("{folder}/(Footage)")).map_err(|e| EngineError::Other(format!("cannot create {folder}: {e}")))?;
+    let mut proj = (*s.project).clone();
+    let mut copied = 0;
+    let mut errors = vec![];
+    for (id, pairs) in plan {
+        let mut new_paths = vec![];
+        for (src, dst) in &pairs {
+            if crate::output_guard::same_file(std::path::Path::new(src), std::path::Path::new(dst)) {
+                copied += 1;
+            } else {
+                match s.services.read_file(src).and_then(|bytes| s.write_output_with(&protected, dst, &bytes).map_err(std::io::Error::other)) {
+                    Ok(()) => copied += 1,
+                    Err(e) => errors.push(format!("{src}: {e}")),
+                }
+            }
+            new_paths.push(dst.clone());
+        }
+        let Some(ItemKind::Footage(f)) = proj.items.get_mut(&id).map(|it| &mut it.kind) else { continue };
+        if f.sequence.is_empty() {
+            f.path = new_paths.pop().unwrap_or_default();
+        } else {
+            f.path = new_paths.first().cloned().unwrap_or_default();
+            f.sequence = new_paths;
+        }
+    }
+    s.write_output_with(&protected, &out, proj.to_json().as_bytes())?;
     s.toast(format!("Collected {copied} file(s) into {folder}"));
     Ok(json!({"project": out, "copied": copied, "errors": errors}))
 }
@@ -430,6 +463,20 @@ fn collect_files(s: &mut Session, p: &Value) -> Result<Value> {
 /// array or JSON lines of `{"command": id, "params": {…}}` (also accepts the control channel's
 /// `{"method": "engine.execute", "params": {"id", "params"}}`).
 fn run_script(s: &mut Session, p: &Value) -> Result<Value> {
+    // File ▸ Scripts ▸ Recent Script Files ▸ <script> (0 is the most recent).
+    if let Some(i) = p.get("recent") {
+        let i = i.as_u64().ok_or_else(|| bad("file.runScript", format!("`recent` must be an index, not {i}")))?;
+        let script = match s.prefs.recent_scripts.get(usize::try_from(i).unwrap_or(usize::MAX)) {
+            Some(x) => x.clone(),
+            None if s.prefs.recent_scripts.is_empty() => return Err(bad("file.runScript", "no recent script files")),
+            None => return Err(bad("file.runScript", format!("no recent script file #{i}"))),
+        };
+        let q = match script {
+            crate::prefs::RecentScript::Path(path) => json!({"path": path}),
+            crate::prefs::RecentScript::Name(name) => json!({"name": name}),
+        };
+        return run_script(s, &q);
+    }
     // File ▸ Scripts ▸ <installed or sample script>.
     if let Some(name) = str_p(p, "name")
         && p.get("path").is_none()
@@ -446,15 +493,22 @@ fn run_script(s: &mut Session, p: &Value) -> Result<Value> {
             return Err(bad("file.runScript", JSXBIN));
         }
         let bytes = s.services.read_file(path).map_err(|e| EngineError::Other(format!("cannot read {path}: {e}")))?;
+        let full = s.services.full_path(path);
         let code = String::from_utf8_lossy(&bytes).to_string();
         let name = std::path::Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| path.to_string());
         let out = run_js(s, &code, path, false)?;
-        return report_js(s, &name, out);
+        let result = report_js(s, &name, out)?;
+        if let Some(full) = full {
+            remember_script(s, crate::prefs::RecentScript::Path(full));
+        }
+        return Ok(result);
     }
+    let mut script_path = None;
     let steps: Vec<Value> = match (p.get("steps"), str_p(p, "path")) {
         (Some(Value::Array(a)), _) => a.clone(),
         (_, Some(path)) => {
             let bytes = s.services.read_file(path).map_err(|e| EngineError::Other(format!("cannot read {path}: {e}")))?;
+            script_path = s.services.full_path(path);
             let text = String::from_utf8_lossy(&bytes).to_string();
             match serde_json::from_str::<Value>(&text) {
                 Ok(Value::Array(a)) => a,
@@ -480,16 +534,26 @@ fn run_script(s: &mut Session, p: &Value) -> Result<Value> {
             }
             _ => return Err(bad("file.runScript", format!("step {}: needs `command`", i + 1))),
         };
-        if id == "file.runScript" || id == "script.run" {
+        if super::scripts::RUNS_SCRIPTS.contains(&id.as_str()) {
             return Err(bad("file.runScript", "scripts can't run scripts"));
         }
         let r = if from_file { s.execute_for_script(&id, params) } else { s.execute(&id, params) };
         let r = r.map_err(|e| EngineError::Other(format!("step {} ({id}): {e}", i + 1)))?;
         results.push(r);
     }
+    if let Some(path) = script_path {
+        remember_script(s, crate::prefs::RecentScript::Path(path));
+    }
     Ok(json!({"steps": results.len(), "results": results}))
 }
 
+/// Remember a script that runs for File ▸ Scripts ▸ Recent Script Files.
+pub(super) fn remember_script(s: &mut Session, script: crate::prefs::RecentScript) {
+    s.prefs.push_recent_script(script);
+    s.save_prefs();
+    s.prefs_revision += 1;
+}
+
 /// `.jsx` / `.js` (and `.jsxbin`, rejected) are JavaScript; `.json` / `.jsonl` / other files are
 /// command scripts.
 fn is_js_script(path: &str) -> bool {
@@ -505,7 +569,7 @@ fn is_jsxbin(name: &str) -> bool {
 }
 
 /// A script error becomes a toast and a command error.
-fn report_js(s: &mut Session, name: &str, out: Value) -> Result<Value> {
+pub(crate) fn report_js(s: &mut Session, name: &str, out: Value) -> Result<Value> {
     if let Some(e) = out.get("error").filter(|e| !e.is_null()) {
         let line = e.get("line").and_then(Value::as_u64).map(|l| format!(" (line {l})")).unwrap_or_default();
         let msg = e.get("message").and_then(Value::as_str).unwrap_or("script error");
@@ -521,6 +585,13 @@ pub(crate) fn run_js_named(s: &mut Session, code: &str, name: &str) -> Result<Va
     report_js(s, name, out)
 }
 
+/// Run the code of the script file at `path` (its `#include`s and `$.fileName` use that path),
+/// reported under its file name `name` (Startup and Shutdown scripts).
+pub(crate) fn run_js_file(s: &mut Session, code: &str, path: &str, name: &str) -> Result<Value> {
+    let out = run_js(s, code, path, false)?;
+    report_js(s, name, out)
+}
+
 /// Run JavaScript through the session's scripting engine.
 fn run_js(s: &mut Session, code: &str, name: &str, console: bool) -> Result<Value> {
     let runner = s.script.ok_or_else(|| EngineError::Other("JavaScript scripting is not available in this build".into()))?;
@@ -563,6 +634,131 @@ pub(crate) struct Interpretation {
     preserve_rgb: Option<bool>,
     /// Start Timecode.
     start: Option<StartTimecode>,
+    /// Cineon Settings (DPX and Cineon footage).
+    cineon: CineonEdit,
+}
+
+/// Interpret Footage ▸ Cineon Settings parsed from command parameters (every field optional).
+#[derive(Clone, Debug, Default)]
+struct CineonEdit {
+    /// Logarithmic Conversion.
+    log: Option<bool>,
+    units: Option<CineonUnits>,
+    /// The units the Converted Black and White Points are given in (`pointUnits`, else `cineonUnits`,
+    /// else the footage's own Units).
+    point_units: Option<CineonUnits>,
+    converted_black: Option<f64>,
+    converted_white: Option<f64>,
+    /// 10 Bit Black and White Points.
+    black: Option<f64>,
+    white: Option<f64>,
+    gamma: Option<f64>,
+    rolloff: Option<f64>,
+}
+
+impl CineonEdit {
+    fn parse(p: &Value, cmd: &str) -> Result<CineonEdit> {
+        let units = |key: &str| -> Result<Option<CineonUnits>> {
+            match str_p(p, key) {
+                None => Ok(None),
+                Some(u) => CineonUnits::parse(u).map(Some).ok_or_else(|| bad(cmd, format!("{key}: 10bit|8bit|float, not `{u}`"))),
+            }
+        };
+        let num = |key: &str, lo: f64, hi: f64| -> Result<Option<f64>> {
+            match p.get(key) {
+                None | Some(Value::Null) => Ok(None),
+                Some(v) => v
+                    .as_f64()
+                    .filter(|x| x.is_finite() && (lo..=hi).contains(x))
+                    .map(Some)
+                    .ok_or_else(|| bad(cmd, format!("{key}: a number from {lo} to {hi}"))),
+            }
+        };
+        let units_now = units("cineonUnits")?;
+        Ok(CineonEdit {
+            log: b_p(p, "logConversion"),
+            units: units_now,
+            point_units: units("pointUnits")?.or(units_now),
+            // Range-checked once their units are known (`settings_for`).
+            converted_black: num("convertedBlack", f64::MIN, f64::MAX)?,
+            converted_white: num("convertedWhite", f64::MIN, f64::MAX)?,
+            black: num("tenBitBlack", 0.0, 1023.0)?,
+            white: num("tenBitWhite", 0.0, 1023.0)?,
+            gamma: num("currentGamma", 0.1, 10.0)?,
+            rolloff: num("highlightRolloff", 0.0, 100.0)?,
+        })
+    }
+
+    fn is_empty(&self) -> bool {
+        self.log.is_none()
+            && self.units.is_none()
+            && self.converted_black.is_none()
+            && self.converted_white.is_none()
+            && self.black.is_none()
+            && self.white.is_none()
+            && self.gamma.is_none()
+            && self.rolloff.is_none()
+    }
+
+    /// Footage `f`'s Cineon Settings after this edit; `None` when nothing changes them (no Cineon
+    /// parameters, or `f` is not a DPX or Cineon file).
+    fn settings_for(&self, f: &Footage, cmd: &str) -> Result<Option<CineonSettings>> {
+        if self.is_empty() || !f.is_cineon_file() {
+            return Ok(None);
+        }
+        let mut c = f.cineon;
+        let units = self.point_units.unwrap_or(c.units);
+        let point = |v: f64| -> Result<f32> {
+            let ten = units.to_ten_bit(v);
+            let max = units.from_ten_bit(f64::from(CineonSettings::MAX));
+            if (0.0..=f64::from(CineonSettings::MAX)).contains(&ten) {
+                Ok(ten as f32)
+            } else {
+                Err(bad(cmd, format!("converted points: 0 to {max} in {} units", units.label())))
+            }
+        };
+        if let Some(v) = self.converted_black {
+            c.converted_black = point(v)?;
+        }
+        if let Some(v) = self.converted_white {
+            c.converted_white = point(v)?;
+        }
+        if let Some(v) = self.log {
+            c.log_conversion = v;
+        }
+        if let Some(u) = self.units {
+            c.units = u;
+        }
+        if let Some(v) = self.black {
+            c.black = v as f32;
+        }
+        if let Some(v) = self.white {
+            c.white = v as f32;
+        }
+        if let Some(v) = self.gamma {
+            c.gamma = v as f32;
+        }
+        if let Some(v) = self.rolloff {
+            c.rolloff = v as f32;
+        }
+        if c.black >= c.white {
+            return Err(bad(cmd, "the 10 Bit Black Point must be below the 10 Bit White Point"));
+        }
+        Ok(Some(c))
+    }
+}
+
+/// Footage `f`'s Cineon Settings as commands report them (`null` for files they don't apply to).
+fn cineon_json(f: &Footage) -> Value {
+    if !f.is_cineon_file() {
+        return Value::Null;
+    }
+    let c = &f.cineon;
+    json!({
+        "logConversion": c.log_conversion, "units": c.units.id(),
+        "convertedBlack": c.units.from_ten_bit(f64::from(c.converted_black)), "convertedWhite": c.units.from_ten_bit(f64::from(c.converted_white)),
+        "tenBitBlack": c.black, "tenBitWhite": c.white, "currentGamma": c.gamma, "highlightRolloff": c.rolloff,
+    })
 }
 
 /// Interpret Footage ▸ Start Timecode.
@@ -656,9 +852,23 @@ impl Interpretation {
                 v.as_f64().filter(|x| x.is_finite() && (0.0..=StartTimecode::MAX as f64).contains(x)).map(|x| x.round() as i64).ok_or_else(start_err)?,
             )),
         };
+        it.cineon = CineonEdit::parse(p, cmd)?;
         Ok(it)
     }
 
+    /// Check the Cineon Settings this interpretation gives each of `footage`: an error names a
+    /// value out of range, or Cineon parameters when none of the footage is DPX or Cineon.
+    pub(crate) fn check<'a>(&self, footage: impl IntoIterator<Item = &'a Footage>, cmd: &str) -> Result<()> {
+        if self.cineon.is_empty() {
+            return Ok(());
+        }
+        let mut any = false;
+        for f in footage {
+            any |= self.cineon.settings_for(f, cmd)?.is_some();
+        }
+        if any { Ok(()) } else { Err(bad(cmd, "Cineon Settings apply to DPX and Cineon footage only")) }
+    }
+
     pub(crate) fn apply(&self, f: &mut Footage, guessed: Option<(AlphaMode, [f32; 3])>) {
         let before = f.frame_rate;
         self.apply_settings(f, guessed);
@@ -718,6 +928,10 @@ impl Interpretation {
         if let Some(v) = self.preserve_rgb {
             f.preserve_rgb = v;
         }
+        // Checked before the edit (`Interpretation::check`).
+        if let Ok(Some(c)) = self.cineon.settings_for(f, "file.interpretFootage") {
+            f.cineon = c;
+        }
         // After the frame rate: timecode is read at the footage's rate.
         if let Some(start) = self.start.as_ref().and_then(|t| t.frame(f.frame_rate)) {
             f.start_timecode = start;
@@ -764,6 +978,11 @@ fn interpret(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad("file.interpretFootage", "select footage"));
     }
     let it = Interpretation::parse(p, "file.interpretFootage")?;
+    let footage = items.iter().filter_map(|i| match s.project.item(*i).map(|x| &x.kind) {
+        Some(ItemKind::Footage(f)) => Some(f),
+        _ => None,
+    });
+    it.check(footage, "file.interpretFootage")?;
     let guesses: Vec<Option<(AlphaMode, [f32; 3])>> = items
         .iter()
         .map(|i| match (it.guess, s.project.item(*i).map(|x| &x.kind)) {
@@ -799,7 +1018,7 @@ fn interpret(s: &mut Session, p: &Value) -> Result<Value> {
                 "item": i.0, "alpha": format!("{:?}", f.alpha), "matteColor": f.premul_color, "invertAlpha": f.invert_alpha,
                 "fields": f.fields.label(), "pixelAspect": f.pixel_aspect, "loop": f.loop_count, "frameRate": f.frame_rate.as_f64(),
                 "linearLight": f.linear_light, "preserveRgb": f.preserve_rgb, "startTimecode": f.timecode(0), "overrideStart": f.start_timecode.is_some(),
-                "frames": f.sequence_frames(),
+                "frames": f.sequence_frames(), "cineon": cineon_json(f),
             })),
             _ => None,
         })
@@ -830,6 +1049,9 @@ fn apply_interpretation(s: &mut Session, p: &Value) -> Result<Value> {
                 f.linear_light = src.linear_light;
                 f.preserve_rgb = src.preserve_rgb;
                 f.color_profile = src.color_profile;
+                if f.is_cineon_file() && src.is_cineon_file() {
+                    f.cineon = src.cineon;
+                }
                 if src.native_rate.is_some() {
                     if f.native_rate.is_none() {
                         f.native_rate = Some(f.frame_rate);
@@ -847,10 +1069,34 @@ fn replace_footage(s: &mut Session, p: &Value) -> Result<Value> {
     let path = str_p(p, "path").ok_or_else(|| bad("file.replaceFootage", "missing `path`"))?.to_string();
     let item = *items_p(s, p).first().ok_or_else(|| bad("file.replaceFootage", "select footage"))?;
     let importer = s.importer.clone().ok_or_else(|| EngineError::Other("media import is not available in this build".into()))?;
-    // A numbered still brings its image sequence, as on import (`sequence: false` for one frame).
-    let opts = SequenceOptions::from_params(p);
+    // Replacing a still keeps it a still; replacing a sequence keeps bringing the new file's run.
+    // `sequence`/`alphabetical` override that (#2073).
+    let previous = match s.project.item(item).map(|it| &it.kind) {
+        Some(ItemKind::Footage(f)) if f.kind == FootageKind::Sequence => (true, true, f.alphabetical),
+        _ => (false, false, false),
+    };
+    // Only `sequence` decides whether the item keeps its kind; `alphabetical` is a sequence
+    // modifier, not a request to make one.
+    let inherited = b_p(p, "sequence").is_none();
+    let mut opts = SequenceOptions::from_params(p);
+    if inherited {
+        (opts.sequence, opts.folders) = (previous.0, previous.1);
+        if previous.0 && b_p(p, "alphabetical").is_none() {
+            opts.alphabetical = previous.2;
+        }
+    }
     let src = crate::sequence::source_of(s.services.as_ref(), &path, opts);
-    let f = crate::sequence::probe(importer.as_ref(), &src, s.sequence_rate()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
+    let mut f = crate::sequence::probe(importer.as_ref(), &src, s.sequence_rate()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
+    // A single-file source comes back as a still; an inherited sequence kind keeps it a
+    // one-frame sequence, so a later default replacement still brings numbered runs (#2073).
+    if inherited && previous.0 && matches!(src, crate::sequence::Source::File(_)) && f.kind == FootageKind::Still {
+        f.kind = FootageKind::Sequence;
+        f.sequence = vec![f.path.clone()];
+        f.alphabetical = opts.alphabetical;
+        f.frame_rate = s.sequence_rate();
+        f.native_rate = None;
+        f.sync_sequence_duration();
+    }
     let name = src.name();
     // Replacing a missing file relinks the other missing files that moved with it (as After Effects
     // does when you locate one).
@@ -960,6 +1206,12 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("file.close", "Close", ["File"], Some("Cmd+W"), "{comp?}", has_comp, close),
         cmd!("file.closeProject", "Close Project", ["File"], None, "{}", always, close_project),
         cmd!("file.saveCopy", "Save a Copy...", ["File", "Save As"], None, "{path}", always, save_copy),
+        query!(
+            "file.checkOutput",
+            "Check Output File",
+            "{path} → {path, blocked, source?: footage|proxy|project, reason?}: whether an export may be written to path (it may not replace a file the project reads)",
+            check_output
+        ),
         cmd!("file.importMultiple", "Multiple Files...", ["File", "Import"], Some("Cmd+Alt+I"), "{paths: [string]}", always, |s, p| s
             .execute("file.import", p.clone())),
         cmd!(
@@ -1017,7 +1269,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Run Script File...",
             ["File", "Scripts"],
             None,
-            "{path (.jsx/.js JavaScript, or a .jsonl/.json command script) | name (an installed or sample script, see file.scripts.list) | steps: [{command, params}]}",
+            "{path (.jsx/.js JavaScript, or a .jsonl/.json command script) | name (an installed or sample script, see file.scripts.list) | recent: index (File ▸ Scripts ▸ Recent Script Files, 0 = the most recent) | steps: [{command, params}]}",
             always,
             run_script
         ),
@@ -1035,7 +1287,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Main...",
             ["File", "Interpret Footage"],
             Some("Cmd+Alt+G"),
-            "{items?, frameRate?: fps|\"file\", alpha?: straight|premultiplied|ignore|guess, guessAlpha?, matteColor?, invertAlpha?, loop?, pixelAspect?, fields?: off|upper|lower, colorProfile?: srgb|rec709|rec2020|p3|auto, linearLight?, preserveRgb? (the file's values unconverted), overrideStart?: bool (false: Use Source File Timecode), startTimecode?: timecode|frame (Override Start)}",
+            "{items?|item?, frameRate?: fps|\"file\", alpha?: straight|premultiplied|ignore|guess, guessAlpha?, matteColor?|premulColor?, invertAlpha?, loop?, pixelAspect?, fields?: off|upper|lower, colorProfile?: srgb|rec709|rec2020|p3|auto, linearLight?, preserveRgb? (the file's values unconverted), overrideStart?: bool (false: Use Source File Timecode), startTimecode?: timecode|frame (Override Start), logConversion? (Cineon Settings of DPX and Cineon files), cineonUnits?: 10bit|8bit|float, convertedBlack?, convertedWhite?, pointUnits?: 10bit|8bit|float (the units of convertedBlack and convertedWhite; default cineonUnits, else the footage's Units), tenBitBlack?, tenBitWhite? (0..1023), currentGamma? (0.1..10), highlightRolloff? (0..100)}",
             has_footage_selection,
             interpret
         ),
@@ -1053,7 +1305,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Apply Interpretation",
             ["File", "Interpret Footage"],
             Some("Cmd+Alt+V"),
-            "{items?}",
+            "{items?|item?}",
             has_interpretation,
             apply_interpretation
         ),
@@ -1062,7 +1314,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "File...",
             ["File", "Replace Footage"],
             Some("Cmd+H"),
-            "{path, item?, sequence?: bool (default true: a numbered still brings its image sequence), alphabetical?: bool}",
+            "{path, item?, sequence?: bool (a numbered still brings its image sequence; default: the item keeps its kind, so a still stays a still and a sequence stays a sequence), alphabetical?: bool}",
             has_footage_selection,
             replace_footage
         ),
@@ -1084,7 +1336,7 @@ pub fn specs() -> Vec<CommandSpec> {
             has_footage_selection,
             replace_with_solid
         ),
-        cmd!("file.reloadFootage", "Reload Footage", ["File"], Some("Cmd+Alt+L"), "{items?}", has_footage_selection, reload),
+        cmd!("file.reloadFootage", "Reload Footage", ["File"], Some("Cmd+Alt+L"), "{items?|item?}", has_footage_selection, reload),
         cmd!("file.revealInFinder", "Reveal in Finder", ["File"], None, "{item?}", has_footage_selection, reveal_in_finder),
     ]
 }
diff --git a/crates/engine/src/commands/focus.rs b/crates/engine/src/cmd/focus.rs
similarity index 93%
rename from crates/engine/src/commands/focus.rs
rename to crates/engine/src/cmd/focus.rs
index 013672a38..356ce1a07 100644
--- a/crates/engine/src/commands/focus.rs
+++ b/crates/engine/src/cmd/focus.rs
@@ -78,6 +78,12 @@ fn set_to_layer(s: &mut Session, p: &Value) -> Result<Value> {
     let c = "camera.setFocusToLayer";
     let (cid, cam, target) = refs(s, p, c, true)?;
     let d = focus_depth(s, cid, cam, target.ok_or_else(|| bad(c, "no layer"))?).ok_or_else(|| bad(c, "can't evaluate the layers"))?;
+    // Only a finite depth can be stored: JSON has no infinity or NaN, so the project could no
+    // longer be saved. Extreme but finite positions can still produce one, and `d <= 0.0` is
+    // false for NaN.
+    if !d.is_finite() {
+        return Err(bad(c, "can't measure the distance to the layer (the camera or layer position is out of range)"));
+    }
     if d <= 0.0 {
         return Err(bad(c, "the layer is behind the camera"));
     }
diff --git a/crates/engine/src/commands/footage_panel.rs b/crates/engine/src/cmd/footage_panel.rs
similarity index 96%
rename from crates/engine/src/commands/footage_panel.rs
rename to crates/engine/src/cmd/footage_panel.rs
index 1bd0d2236..2ec9f4be2 100644
--- a/crates/engine/src/commands/footage_panel.rs
+++ b/crates/engine/src/cmd/footage_panel.rs
@@ -56,6 +56,12 @@ pub fn timecode(item: Option<&effectcraft_project::Item>, fr: effectcraft_time::
     }
 }
 
+/// The frame the Footage panel shows: footage `f` at source time `t`, with its Cineon Settings
+/// applied.
+pub fn frame(s: &Session, item: ItemId, f: &effectcraft_project::Footage, t: Tick) -> Option<std::sync::Arc<effectcraft_raster::Image>> {
+    s.footage.frame(item, f, t).map(|img| effectcraft_render::cineon_frame(img, f))
+}
+
 fn source_time(s: &Session, p: &Value, item: ItemId) -> Option<Tick> {
     let (_, fr) = source_timing(s, item);
     if let Some(t) = f_p(p, "time") {
@@ -207,10 +213,7 @@ fn info(s: &mut Session, _: &Value) -> Result<Value> {
     let item = s.project.item(v.item);
     let name = item.map(|i| i.name.clone()).unwrap_or_default();
     let frame = fr.frame_at(v.time);
-    let problem = match item.map(|i| &i.kind) {
-        Some(ItemKind::Footage(f)) => s.footage.problem(f),
-        _ => None,
-    };
+    let problem = item.and_then(|i| s.footage.item_problem(i));
     Ok(
         json!({"item": v.item.0, "name": name, "time": v.time.seconds(), "frame": frame, "timecode": timecode(item, fr, frame), "in": v.in_point.map(|t| t.seconds()), "out": v.out_point.map(|t| t.seconds()), "duration": dur.map(|d| d.seconds()), "frameRate": fr.as_f64(), "problem": problem}),
     )
diff --git a/crates/engine/src/commands/frame_export.rs b/crates/engine/src/cmd/frame_export.rs
similarity index 97%
rename from crates/engine/src/commands/frame_export.rs
rename to crates/engine/src/cmd/frame_export.rs
index baad9b6ef..d8b49159c 100644
--- a/crates/engine/src/commands/frame_export.rs
+++ b/crates/engine/src/cmd/frame_export.rs
@@ -195,6 +195,7 @@ pub fn layered_exr(s: &Session, cid: ItemId, t: Tick, scale: f64) -> Result<(Vec
 
 fn frame_args(s: &Session, p: &Value, cmd: &str, ext: &str) -> Result<(String, ItemId, Tick, f64)> {
     let path = str_p(p, "path").ok_or_else(|| bad(cmd, format!("missing `path` (.{ext})")))?.to_string();
+    s.refuse_export(&path)?;
     let cid = comp_id(s, p)?;
     let t = f_p(p, "time").map(Tick::from_seconds_f64).unwrap_or(s.time());
     let scale = f_p(p, "scale").unwrap_or(1.0).clamp(0.01, 4.0);
@@ -204,7 +205,7 @@ fn frame_args(s: &Session, p: &Value, cmd: &str, ext: &str) -> Result<(String, I
 fn save_psd(s: &mut Session, p: &Value) -> Result<Value> {
     let (path, cid, t, scale) = frame_args(s, p, "comp.saveFrameAsPsd", "psd")?;
     let (bytes, n, w, h) = layered_psd(s, cid, t, scale)?;
-    s.services.write_file(&path, &bytes).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+    s.write_output(&path, &bytes)?;
     s.toast(format!("Saved {n} layers to {path}"));
     Ok(json!({"path": path, "layers": n, "width": w, "height": h, "time": t.seconds()}))
 }
@@ -212,7 +213,7 @@ fn save_psd(s: &mut Session, p: &Value) -> Result<Value> {
 fn save_exr(s: &mut Session, p: &Value) -> Result<Value> {
     let (path, cid, t, scale) = frame_args(s, p, "comp.saveFrameAsExr", "exr")?;
     let (bytes, channels, w, h) = layered_exr(s, cid, t, scale)?;
-    s.services.write_file(&path, &bytes).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+    s.write_output(&path, &bytes)?;
     s.toast(format!("Saved a multi-layer EXR to {path}"));
     Ok(json!({"path": path, "channels": channels, "width": w, "height": h, "time": t.seconds()}))
 }
diff --git a/crates/engine/src/commands/frontend.rs b/crates/engine/src/cmd/frontend.rs
similarity index 100%
rename from crates/engine/src/commands/frontend.rs
rename to crates/engine/src/cmd/frontend.rs
diff --git a/crates/engine/src/commands/help.rs b/crates/engine/src/cmd/help.rs
similarity index 93%
rename from crates/engine/src/commands/help.rs
rename to crates/engine/src/cmd/help.rs
index c6f315f30..996817ce3 100644
--- a/crates/engine/src/commands/help.rs
+++ b/crates/engine/src/cmd/help.rs
@@ -20,7 +20,8 @@ fn sibling(s: &mut Session, p: &Value) -> Result<Value> {
 fn docs(s: &mut Session, p: &Value) -> Result<Value> {
     let page = match str_p(p, "page").unwrap_or("help") {
         "scripting" => "docs/control-protocol.md",
-        "expressions" => "docs/expressions.md",
+        // The reader-facing expression reference is not written yet: the closest page is the parity notes.
+        "expressions" => "docs/scripting-parity.md",
         "effects" => "docs/effects.md",
         "agents" => "docs/agents.md",
         _ => "README.md",
diff --git a/crates/engine/src/commands/import_project.rs b/crates/engine/src/cmd/import_project.rs
similarity index 100%
rename from crates/engine/src/commands/import_project.rs
rename to crates/engine/src/cmd/import_project.rs
diff --git a/crates/engine/src/commands/key_labels.rs b/crates/engine/src/cmd/key_labels.rs
similarity index 100%
rename from crates/engine/src/commands/key_labels.rs
rename to crates/engine/src/cmd/key_labels.rs
diff --git a/crates/engine/src/commands/key_transform.rs b/crates/engine/src/cmd/key_transform.rs
similarity index 96%
rename from crates/engine/src/commands/key_transform.rs
rename to crates/engine/src/cmd/key_transform.rs
index b78439266..397db4de5 100644
--- a/crates/engine/src/commands/key_transform.rs
+++ b/crates/engine/src/cmd/key_transform.rs
@@ -72,6 +72,10 @@ fn transform(s: &mut Session, p: &Value) -> Result<Value> {
         let mut new_sel = vec![];
         for ((lid, uid), times) in groups {
             let Some(layer) = comp.layer_mut(lid) else { continue };
+            if layer.switches.locked {
+                new_sel.extend(times.into_iter().map(|time| KeyRef { layer: lid, prop: uid, time }));
+                continue;
+            }
             let (start, stretch) = (layer.start_time, layer.stretch);
             let to_comp = |lt: Tick| if (stretch - 100.0).abs() < 1e-9 { start + lt } else { start + Tick((lt.0 as f64 * stretch / 100.0) as i64) };
             let to_layer = |ct: Tick| {
@@ -122,6 +126,9 @@ fn spatial_tangents(s: &mut Session, p: &Value) -> Result<Value> {
     let brk = b_p(p, "break").unwrap_or(false);
     s.edit("Edit Spatial Tangents", merge_p(p), |proj, _| {
         let l = super::layer_mut(proj, cid, lid)?;
+        if l.switches.locked {
+            return Err(bad("keys.setSpatialTangents", "the layer is locked"));
+        }
         let pr = l.props.find_mut(uid).ok_or_else(|| bad("keys.setSpatialTangents", "no property"))?;
         if !pr.spatial {
             return Err(bad("keys.setSpatialTangents", "not a spatial property"));
diff --git a/crates/engine/src/commands/keys_more.rs b/crates/engine/src/cmd/keys_more.rs
similarity index 99%
rename from crates/engine/src/commands/keys_more.rs
rename to crates/engine/src/cmd/keys_more.rs
index c7785d08c..4edef885a 100644
--- a/crates/engine/src/commands/keys_more.rs
+++ b/crates/engine/src/cmd/keys_more.rs
@@ -37,6 +37,8 @@ pub(crate) fn label_keys(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad("keys.label", "select keyframes first"));
     }
     let cid = comp_id(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let keys = super::prop::editable_keys(comp, &keys);
     let n = s.edit("Keyframe Label", None, |proj, _| {
         let mut n = 0;
         for k in &keys {
diff --git a/crates/engine/src/cmd/layer.rs b/crates/engine/src/cmd/layer.rs
new file mode 100644
index 000000000..4b6527f67
--- /dev/null
+++ b/crates/engine/src/cmd/layer.rs
@@ -0,0 +1,221 @@
+//! Layer menu.
+
+use effectcraft_color::{BlendMode, Label};
+use effectcraft_keyframe::{Justify, TextDoc, Value as KV};
+use effectcraft_project::build::{self, Ids};
+use effectcraft_project::{
+    Comp, FootageKind, FrameBlend, GroupKind, ItemId, ItemKind, Layer, LayerId, LayerSource, MaskMode, MatteKind, Node, Project, PropGroup, Quality, Solid,
+    TrackMatte, limits,
+};
+use effectcraft_time::Tick;
+use serde_json::{Value, json};
+
+use super::{CommandSpec, b_p, bad, comp_id, f_p, has_comp, has_layers, layer_mut, layer_p, layers_p, merge_p, resolve_layer, str_p, unlocked};
+use crate::{EngineError, Result, Session, cmd};
+
+mod contents;
+mod create;
+mod parent;
+mod replace;
+mod select;
+mod switches;
+mod timing;
+mod transform;
+
+use contents::{add_mask, add_shape_item, mask_props, set_text};
+use create::{add_item, new_adjustment, new_null, new_shape, new_solid, new_text};
+pub(crate) use create::{color_p, index_p, insert_layer, insert_layer_at, place, position_p};
+pub(crate) use parent::parent_fixes;
+use parent::set_parent;
+use replace::{has_replace_source, replace_source};
+pub(crate) use select::select_only;
+use select::{select, select_next, select_prev, select_step};
+use switches::{blend, rename, set_comment, set_switch, track_matte};
+use timing::{arrange, move_frames, precompose, slip, timing};
+use transform::{has_layer_settings, layer_settings, transform_op};
+pub(crate) use transform::{offset_position, transform_default, update_position};
+
+/// `p` with `key` set.
+fn with(p: &Value, key: &str, v: Value) -> Value {
+    let mut p = if p.is_object() { p.clone() } else { json!({}) };
+    p[key] = v;
+    p
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        cmd!(
+            "layer.newText",
+            "Text",
+            ["Layer", "New"],
+            Some("Cmd+Alt+Shift+T"),
+            "{text?, name? (layer name; default the text), position? [x,y], box? [x,y,w,h] (paragraph text, comp space), vertical?, edit? (start editing), font?, style?, size?, fill?, stroke?, applyFill?, applyStroke?, strokeWidth?, tracking?, leading?, baselineShift?, hScale?, vScale?, tsume?, fauxBold?, fauxItalic?, allCaps?, smallCaps?, baseline?, superscript?, subscript?, kerning?, ligatures?, justify?, indentLeft?, indentRight?, indentFirst?, spaceBefore?, spaceAfter?, direction?, composer?, hangingPunctuation?, strokeOverFill?, lineJoin?} (attributes as layer.setText)",
+            has_comp,
+            new_text
+        ),
+        cmd!("layer.newSolid", "Solid...", ["Layer", "New"], Some("Cmd+Y"), "{name?, color? #hex|[r,g,b], width?, height?, pixelAspect?}", has_comp, new_solid),
+        cmd!("layer.newNull", "Null Object", ["Layer", "New"], Some("Cmd+Alt+Shift+Y"), "{name?}", has_comp, new_null),
+        cmd!(
+            "layer.newShape",
+            "Shape Layer",
+            ["Layer", "New"],
+            None,
+            "{kind?: rect|rounded|ellipse|star|polygon|none, name?, size?, fill?, fillType?, fillBlend?, fillOpacity?, stroke?, strokeType?, strokeBlend?, strokeOpacity?, strokeWidth?, position?}",
+            has_comp,
+            new_shape
+        ),
+        cmd!("layer.newAdjustment", "Adjustment Layer", ["Layer", "New"], Some("Cmd+Alt+Y"), "{name?}", has_comp, new_adjustment),
+        cmd!(
+            "layer.settings",
+            "Layer Settings...",
+            ["Layer"],
+            Some("Cmd+Shift+Y"),
+            "{layer?, name?, color?, width?, height?, pixelAspect?, affectAll?: bool (default true; false gives this layer its own copy of a solid other layers use)} → {layer, solid?}",
+            has_layer_settings,
+            layer_settings
+        ),
+        cmd!(
+            "layer.addItem",
+            "Add Footage to Comp",
+            ["File"],
+            Some("Cmd+/"),
+            "{item: id|name, time? (s, where the layer starts), index? (1-based stack position; default above the selected layer), position? ([x, y] comp px; default the centre), duration? (s, for a still), in? (s, the In point in comp time; default the start), out? (s, the Out point; default the end of the footage or the comp; in must be before out), anchor? ([x, y] layer px; default the centre)}",
+            has_comp,
+            add_item
+        ),
+        cmd!(
+            "layer.replaceSource",
+            "Replace Layer Source",
+            [],
+            Some("Cmd+Alt+/"),
+            "{comp?, layers?, layer?, item?: id|name (default the Project panel selection), fixExpressions?: bool (accepted for After Effects compatibility)} → {layers, item}",
+            has_replace_source,
+            replace_source
+        ),
+        cmd!("layer.select", "Select Layers", [], None, "{layers: [id|name|#n], add?, toggle?}", has_comp, select),
+        cmd!("layer.selectNext", "Select Next Layer", [], Some("Cmd+ArrowDown"), "{add?}", has_comp, select_next),
+        cmd!("layer.selectPrevious", "Select Previous Layer", [], Some("Cmd+ArrowUp"), "{add?}", has_comp, select_prev),
+        cmd!("layer.extendSelectionNext", "Extend Selection to Next Layer", [], Some("Cmd+Shift+ArrowDown"), "{}", has_comp, |s, _| select_step(
+            s,
+            &json!({"add": true}),
+            1
+        )),
+        cmd!("layer.extendSelectionPrevious", "Extend Selection to Previous Layer", [], Some("Cmd+Shift+ArrowUp"), "{}", has_comp, |s, _| select_step(
+            s,
+            &json!({"add": true}),
+            -1
+        )),
+        cmd!(
+            "layer.setSwitch",
+            "Layer Switch",
+            [],
+            None,
+            "{layers?, switch: video|audio|solo|lock|shy|collapse|quality|fx|frameBlend|motionBlur|adjustment|threeD|guide|preserveTransparency, value?, merge?, others? (the named layers alone: the other layers get the opposite state, or come back)}",
+            has_layers,
+            set_switch
+        ),
+        cmd!("layer.rename", "Rename", [], Some("Enter"), "{layer?, name}", has_layers, rename),
+        cmd!("layer.setComment", "Layer Comment", [], None, "{layers?, comment}", has_layers, set_comment),
+        cmd!("layer.setBlendMode", "Blending Mode", [], None, "{layers?, mode?: Normal|Multiply|Screen|…, step?: ±1}", has_layers, blend),
+        cmd!(
+            "layer.setTrackMatte",
+            "Track Matte",
+            [],
+            None,
+            "{layers? | layer?, matte: layer|null, kind?: alpha|alphaInverted|luma|lumaInverted|preserve}",
+            has_layers,
+            track_matte
+        ),
+        cmd!("layer.setParent", "Parent", [], None, "{layers?, parent: layer|null, compensate?: bool}", has_layers, set_parent),
+        cmd!(
+            "layer.timing",
+            "Layer Timing",
+            [],
+            None,
+            "{layers?, op?: moveInToTime|moveOutToTime|moveInToStart|moveOutToEnd|trimInToTime|trimOutToTime, delta?, start?, in?, out?, inDelta?, outDelta? (seconds, per layer), merge?}",
+            has_layers,
+            timing
+        ),
+        cmd!("layer.moveInToStart", "Move Layer In Point to Beginning of Comp", [], Some("Alt+Home"), "{layers?}", has_layers, |s, p| timing(
+            s,
+            &with(p, "op", json!("moveInToStart"))
+        )),
+        cmd!("layer.moveOutToEnd", "Move Layer Out Point to End of Comp", [], Some("Alt+End"), "{layers?}", has_layers, |s, p| timing(
+            s,
+            &with(p, "op", json!("moveOutToEnd"))
+        )),
+        cmd!("layer.moveEarlier", "Move Layers 1 Frame Earlier", [], Some("Alt+PageUp"), "{layers?}", has_layers, |s, p| move_frames(s, p, -1)),
+        cmd!("layer.moveLater", "Move Layers 1 Frame Later", [], Some("Alt+PageDown"), "{layers?}", has_layers, |s, p| move_frames(s, p, 1)),
+        cmd!("layer.moveEarlier10", "Move Layers 10 Frames Earlier", [], Some("Alt+Shift+PageUp"), "{layers?}", has_layers, |s, p| move_frames(s, p, -10)),
+        cmd!("layer.moveLater10", "Move Layers 10 Frames Later", [], Some("Alt+Shift+PageDown"), "{layers?}", has_layers, |s, p| move_frames(s, p, 10)),
+        cmd!(
+            "layer.slip",
+            "Slip Edit",
+            [],
+            None,
+            "{layers?, delta? (seconds) | frames?, merge?} → {requested, slipped: [{layer, delta, clamped}]}",
+            has_layers,
+            slip
+        ),
+        cmd!("layer.slipBack", "Slip Edit 1 Frame Earlier", [], None, "{layers?}", has_layers, |s, p| {
+            let mut p = p.clone();
+            p["frames"] = json!(-1);
+            slip(s, &p)
+        }),
+        cmd!("layer.slipForward", "Slip Edit 1 Frame Later", [], None, "{layers?}", has_layers, |s, p| {
+            let mut p = p.clone();
+            p["frames"] = json!(1);
+            slip(s, &p)
+        }),
+        cmd!("layer.arrange", "Arrange", ["Layer", "Arrange"], None, "{layers?, to: front|forward|backward|back, index?, above?: layer}", has_layers, arrange),
+        cmd!(
+            "layer.precompose",
+            "Pre-compose...",
+            ["Layer"],
+            Some("Cmd+Shift+C"),
+            "{layers?, name?, mode?: move|leave, adjustDuration?, open?}",
+            has_layers,
+            precompose
+        ),
+        cmd!(
+            "layer.addMask",
+            "New Mask",
+            ["Layer", "Mask"],
+            Some("Cmd+Shift+N"),
+            "{layer?, shape?: rect|ellipse|rounded|polygon|star, rect? [x,y,w,h] (layer space; a polygon or star fits its width), mode?}",
+            has_layers,
+            add_mask
+        ),
+        cmd!("layer.setMask", "Mask Mode", [], None, "{layer?, mask: index|uid|name, mode?, inverted?}", has_layers, mask_props),
+        cmd!(
+            "layer.addShapeItem",
+            "Add (Shape)",
+            [],
+            None,
+            "{layer?, kind: group|rect|ellipse|star|polygon|path|fill|stroke|gfill|gstroke|trim|repeater|round|offset|pucker|twist|zigzag|wiggle|wiggler|merge|frontColor|bevelColor|sideColor|backColor, group?: uid|path} → {uid, path} (frontColor…backColor: the group's Front / Bevel / Side / Back item, which colours that surface of every extruded paint in the group in Advanced 3D)",
+            has_layers,
+            add_shape_item
+        ),
+        cmd!(
+            "layer.setText",
+            "Edit Text",
+            [],
+            None,
+            "{layer?, range?: [start, end] (characters; default all), text?, font?, style?, size?, fill?, stroke?, applyFill?, applyStroke?, strokeWidth?, tracking?, leading?: px|\"auto\", baselineShift? px, hScale? %, vScale? %, tsume? %, fauxBold?, fauxItalic?, allCaps?, smallCaps?, baseline?: normal|superscript|subscript, superscript?, subscript?, kerning?: metrics|optical|number, ligatures?, discretionaryLigatures? (OpenType), contextualAlternates?, stylisticAlternates?, stylisticSets?: [1–20], ss01?, ss02?, ss03?, ss04?, ss05?, ss06?, ss07?, ss08?, ss09?, ss10?, ss11?, ss12?, ss13?, ss14?, ss15?, ss16?, ss17?, ss18?, ss19?, ss20?, swash?, titling?, ordinals?, fractions?, allSmallCaps?, figureStyle?: default|lining|oldStyle, figureWidth?: default|proportional|tabular, figures?, variations?: {tag: value} (variable font axes; null resets), justify?: left|center|right|justifyLeft|justifyCenter|justifyRight|justifyAll, indentLeft?, indentRight?, indentFirst?, spaceBefore?, spaceAfter?, direction?: ltr|rtl, composer?: everyLine|singleLine, hangingPunctuation?, strokeOverFill?, lineJoin?: miter|round|bevel, box?: [x,y,w,h]|null (layer space), vertical?}",
+            has_layers,
+            set_text
+        ),
+        cmd!(
+            "layer.transform",
+            "Transform",
+            ["Layer", "Transform"],
+            None,
+            "{layers?, op: reset|center|fit|fitWidth|fitHeight|flipH|flipV}",
+            has_layers,
+            transform_op
+        ),
+    ]
+}
+
+#[allow(dead_code)]
+fn unused(_: &Comp) {}
diff --git a/crates/engine/src/cmd/layer/contents.rs b/crates/engine/src/cmd/layer/contents.rs
new file mode 100644
index 000000000..d8824fc9e
--- /dev/null
+++ b/crates/engine/src/cmd/layer/contents.rs
@@ -0,0 +1,208 @@
+use super::create::{apply_text_params, text_range_p};
+use super::{
+    EngineError, GroupKind, Ids, ItemId, KV, LayerId, MaskMode, Node, Project, PropGroup, Result, Session, TextDoc, Value, b_p, bad, build, json, layer_mut,
+    layer_p, merge_p, str_p,
+};
+
+pub(super) fn add_mask(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, lid) = layer_p(s, p, "layer.addMask")?;
+    let layer = s.project.comp(cid).and_then(|c| c.layer(lid)).ok_or(EngineError::NoComp)?.clone();
+    let (w, h) = effectcraft_render::source_size(&s.project, &layer);
+    let (w, h) = if w == 0 { (400.0, 300.0) } else { (w as f64, h as f64) };
+    let shape = str_p(p, "shape").unwrap_or("rect");
+    let r = p.get("rect").and_then(Value::as_array).map(|a| [0, 1, 2, 3].map(|i| a.get(i).and_then(Value::as_f64).unwrap_or(0.0)));
+    let (cx, cy, rw, rh) = match r {
+        Some([x, y, rw, rh]) => (x + rw / 2.0, y + rh / 2.0, rw, rh),
+        None => (if w > 0.0 { w / 2.0 } else { 0.0 }, h / 2.0, w * 0.6, h * 0.6),
+    };
+    // The shape tools' masks: rectangle, ellipse, rounded rectangle, polygon or star.
+    let path = crate::cmd::shape_tool::mask_path(shape, [cx, cy], [rw, rh])
+        .ok_or_else(|| bad("layer.addMask", format!("unknown shape `{shape}`; one of rect, ellipse, rounded, polygon, star")))?;
+    let mode = str_p(p, "mode").and_then(MaskMode::from_name).unwrap_or(MaskMode::Add);
+    let cycle = s.prefs.appearance.cycle_mask_colors;
+    let uid = s.edit("New Mask", None, |proj, _| {
+        let mut next = proj.next_id;
+        let l = layer_mut(proj, cid, lid)?;
+        let masks = l.props.sub_mut("masks").ok_or_else(|| bad("layer.addMask", "this layer can't have masks"))?;
+        let n = masks.children.len();
+        let g = build::mask(&mut Ids(&mut next), &format!("Mask {}", n + 1), path, mode, crate::prefs::mask_color(cycle, n));
+        let uid = g.uid;
+        masks.children.push(g.into());
+        proj.next_id = next;
+        Ok(uid)
+    })?;
+    Ok(json!({"mask": uid}))
+}
+
+pub(super) fn mask_props(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, lid) = layer_p(s, p, "layer.setMask")?;
+    let target = p.get("mask").cloned().unwrap_or(json!(1));
+    let mode = str_p(p, "mode").and_then(MaskMode::from_name);
+    let inverted = b_p(p, "inverted");
+    s.edit("Mask Settings", None, |proj, _| {
+        let l = layer_mut(proj, cid, lid)?;
+        let masks = l.props.sub_mut("masks").ok_or_else(|| bad("layer.setMask", "the layer has no masks (add one with layer.addMask)"))?;
+        let g = match &target {
+            Value::Number(n) => {
+                let n = n.as_u64().unwrap_or(1);
+                if let Some(i) = masks.children.iter().position(|c| c.uid() == n) {
+                    masks.children[i].as_group_mut()
+                } else {
+                    masks.children.get_mut(n.saturating_sub(1) as usize).and_then(|c| c.as_group_mut())
+                }
+            }
+            Value::String(name) => masks.children.iter_mut().find(|c| c.name() == name).and_then(|c| c.as_group_mut()),
+            _ => None,
+        }
+        .ok_or_else(|| bad("layer.setMask", "no such mask"))?;
+        if let GroupKind::Mask { mode: m, inverted: inv, .. } = &mut g.kind {
+            if let Some(mm) = mode {
+                *m = mm;
+            }
+            if let Some(i) = inverted {
+                *inv = i;
+            }
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+pub(super) fn add_shape_item(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, lid) = layer_p(s, p, "layer.addShapeItem")?;
+    let kind = str_p(p, "kind").ok_or_else(|| bad("layer.addShapeItem", "missing `kind`"))?.to_string();
+    // `group`: a uid or a property path (`contents/group`).
+    let group_uid = match p.get("group") {
+        Some(Value::String(path)) => Some(
+            s.project
+                .comp(cid)
+                .and_then(|c| c.layer(lid))
+                .and_then(|l| l.props.group(path))
+                .map(|g| g.uid)
+                .ok_or_else(|| bad("layer.addShapeItem", format!("no group `{path}`")))?,
+        ),
+        v => v.and_then(Value::as_u64),
+    };
+    let uid = s.edit("Add Shape Item", None, |proj, _| {
+        let mut next = proj.next_id;
+        let mut ids = Ids(&mut next);
+        // Front / Bevel / Side / Back ▸ property: into the group's surface item (one per group).
+        if let Some((surface, prop)) = build::shape_surface_kind(&kind) {
+            let target = shape_item_target(proj, cid, lid, group_uid)?;
+            let item = match target.children.iter().position(|c| matches!(c, Node::Group(g) if g.match_id == surface)) {
+                Some(i) => i,
+                None => {
+                    let g = build::shape_surface(&mut ids, surface).ok_or_else(|| bad("layer.addShapeItem", format!("unknown kind `{kind}`")))?;
+                    target.children.push(g.into());
+                    target.children.len() - 1
+                }
+            };
+            let Some(Node::Group(g)) = target.children.get_mut(item) else { return Err(bad("layer.addShapeItem", "no such group")) };
+            if g.get(prop).is_none() {
+                let p = build::shape_surface_prop(&mut ids, prop).ok_or_else(|| bad("layer.addShapeItem", format!("unknown kind `{kind}`")))?;
+                g.children.push(p.into());
+            }
+            let uid = g.uid;
+            proj.next_id = next;
+            return Ok(uid);
+        }
+        let g = match kind.as_str() {
+            "group" => build::shape_group(&mut ids, "Group 1", vec![]),
+            "rect" | "rectangle" => build::shape_rect(&mut ids, [200.0, 200.0], [0.0, 0.0], 0.0),
+            "ellipse" => build::shape_ellipse(&mut ids, [200.0, 200.0], [0.0, 0.0]),
+            "star" => build::shape_star(&mut ids, true, 5.0, [0.0, 0.0], 100.0, 50.0),
+            "polygon" => build::shape_star(&mut ids, false, 5.0, [0.0, 0.0], 100.0, 0.0),
+            "fill" => build::shape_fill(&mut ids, [1.0, 0.0, 0.0, 1.0]),
+            "stroke" => build::shape_stroke(&mut ids, [1.0, 1.0, 1.0, 1.0], 2.0),
+            "path" => build::shape_path(&mut ids, Default::default()),
+            "gfill" | "gradientFill" => build::shape_gradient_fill(&mut ids, false, [-100.0, 0.0], [100.0, 0.0], Default::default()),
+            "gstroke" | "gradientStroke" => build::shape_gradient_stroke(&mut ids, false, [-100.0, 0.0], [100.0, 0.0], Default::default(), 2.0),
+            "trim" | "trimPaths" => build::shape_trim(&mut ids, 0.0, 100.0, 0.0),
+            "repeater" => build::shape_repeater(&mut ids, 3.0, [100.0, 0.0]),
+            k => build::shape_simple_op(&mut ids, k).ok_or_else(|| bad("layer.addShapeItem", format!("unknown kind `{k}`")))?,
+        };
+        let uid = g.uid;
+        proj.next_id = next;
+        shape_item_target(proj, cid, lid, group_uid)?.children.push(g.into());
+        Ok(uid)
+    })?;
+    // The new item's property path, ready for prop.set / add_keyframe (`contents/trim#2/end`).
+    let path = s.project.comp(cid).and_then(|c| c.layer(lid)).and_then(|l| l.props.match_path_of(uid));
+    Ok(json!({"uid": uid, "path": path}))
+}
+
+/// The contents a new shape item goes into: the shape group `group_uid` (its Contents), else the
+/// layer's Contents.
+fn shape_item_target(proj: &mut Project, cid: ItemId, lid: LayerId, group_uid: Option<u64>) -> Result<&mut PropGroup> {
+    let l = layer_mut(proj, cid, lid)?;
+    let contents = l.props.sub_mut("contents").ok_or_else(|| bad("layer.addShapeItem", "not a shape layer"))?;
+    Ok(match group_uid {
+        Some(u) => contents
+            .find_group_mut(u)
+            .and_then(|g| if g.match_id == "contents" { Some(g) } else { g.sub_mut("contents") })
+            .ok_or_else(|| bad("layer.addShapeItem", "no such group"))?,
+        None => contents,
+    })
+}
+
+/// `layer.setText`: sets a text layer's Source Text and/or character attributes at the CTI.
+///
+/// A `font` name is also added to the recent fonts and the preferences saved. With an empty
+/// `range` and no `text`, while that layer is being edited and its document is non-empty,
+/// recognised character attributes are also staged in the pending insertion style without
+/// changing existing characters. Paragraph/document attributes still apply through the edit;
+/// the session is bumped whenever this branch runs. Document changes use [`Session::edit`],
+/// merged by `merge_p`. With `text` given, a layer whose name is empty or starts with `Text`
+/// takes the new first line (up to 40 characters) when that line is non-empty. Replies `null`.
+pub(super) fn set_text(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, lid) = layer_p(s, p, "layer.setText")?;
+    // The Character panel's recent fonts (Settings ▸ Type ▸ Number of Recent Fonts to Display).
+    if let Some(f) = str_p(p, "font") {
+        s.prefs.push_recent_font(f);
+        s.save_prefs();
+    }
+    let t = s.time();
+    let range = text_range_p(p);
+    // Character attributes with only a caret (no selected text) set the insertion style.
+    if let Some(r) = range.clone().filter(|r| r.is_empty() && str_p(p, "text").is_none())
+        && s.state.text_edit.as_ref().is_some_and(|e| e.layer == lid)
+        && let Some(doc) = crate::cmd::text_edit::layer_doc(s, lid)
+        && doc.char_len() > 0
+        && let Some(obj) = p.as_object()
+        && let Some(e) = s.state.text_edit.as_mut()
+    {
+        let mut st = e.pending.clone().unwrap_or_else(|| doc.insertion_style(r.start));
+        let mut any = false;
+        for (k, v) in obj {
+            any |= effectcraft_keyframe::text_doc::apply_char_attr(&mut st, k, v).map_err(|m| bad("layer.setText", m))?;
+        }
+        if any {
+            e.pending = Some(st);
+        }
+        s.bump();
+    }
+    // A changed Source Text is handled by `Session::edit`: its boundary clamps the selection and
+    // starts a new IME epoch only when the CTI document actually changed, so an identical text
+    // write stays a no-op and keeps the editor's owner.
+    s.edit("Edit Text", merge_p(p), |proj, _| {
+        let l = layer_mut(proj, cid, lid)?;
+        let lt = l.layer_time(t);
+        let pr = l.props.prop_mut("text/sourceText").ok_or_else(|| bad("layer.setText", "not a text layer"))?;
+        let mut doc = match pr.value_at(lt) {
+            KV::Text(d) => *d,
+            KV::Str(t) => TextDoc::plain(&t),
+            _ => TextDoc::default(),
+        };
+        apply_text_params("layer.setText", p, &mut doc, range.clone())?;
+        pr.set_value_at(lt, KV::Text(Box::new(doc.clone())));
+        if let Some(first) = doc.text.lines().next()
+            && str_p(p, "text").is_some()
+            && !first.is_empty()
+            && (l.name.starts_with("Text") || l.name.is_empty())
+        {
+            l.name = first.chars().take(40).collect();
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
diff --git a/crates/engine/src/cmd/layer/create.rs b/crates/engine/src/cmd/layer/create.rs
new file mode 100644
index 000000000..621ae866b
--- /dev/null
+++ b/crates/engine/src/cmd/layer/create.rs
@@ -0,0 +1,377 @@
+use super::{
+    EngineError, Ids, ItemId, ItemKind, Justify, KV, Label, Layer, LayerId, LayerSource, Project, Result, Session, Solid, TextDoc, Tick, Value, b_p, bad,
+    build, comp_id, f_p, json, limits, str_p,
+};
+
+pub(crate) fn color_p(p: &Value, k: &str) -> Option<[f32; 3]> {
+    match p.get(k)? {
+        Value::String(s) => effectcraft_color::Rgba::from_hex(s).map(|c| [c.r, c.g, c.b]),
+        Value::Array(a) => {
+            let g = |i: usize| a.get(i).and_then(Value::as_f64).unwrap_or(0.0) as f32;
+            Some([g(0), g(1), g(2)])
+        }
+        _ => None,
+    }
+}
+
+/// Insert a new layer above the selection (or at the top) and select it.
+pub(crate) fn insert_layer(proj: &mut Project, st: &mut crate::EditorState, cid: ItemId, layer: Layer) -> Result<LayerId> {
+    insert_layer_at(proj, st, cid, layer, None)
+}
+
+/// `index`: an `index` parameter, the layer's 1-based place in the stack (1 = top; past the
+/// bottom = the bottom), as 0-based.
+pub(crate) fn index_p(p: &Value, cmd: &str) -> Result<Option<usize>> {
+    match p.get("index") {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => {
+            v.as_u64().filter(|i| *i >= 1).map(|i| Some(usize::try_from(i - 1).unwrap_or(usize::MAX))).ok_or_else(|| bad(cmd, "index: 1-based stack position"))
+        }
+    }
+}
+
+/// A `position` parameter: `[x, y]` in comp pixels (finite).
+pub(crate) fn position_p(p: &Value, cmd: &str) -> Result<Option<[f64; 2]>> {
+    match p.get("position") {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => v
+            .as_array()
+            .and_then(|a| Some([a.first()?.as_f64()?, a.get(1)?.as_f64()?]))
+            .filter(|c| c.iter().all(|x| x.is_finite()))
+            .map(Some)
+            .ok_or_else(|| bad(cmd, "position: [x, y] in comp pixels")),
+    }
+}
+
+/// Put a new layer's Position at `pos` (comp pixels).
+pub(crate) fn place(l: &mut Layer, pos: Option<[f64; 2]>) {
+    if let Some([x, y]) = pos
+        && let Some(pr) = l.props.prop_mut("transform/position")
+    {
+        let z = match pr.value {
+            KV::Vec3(v) => v[2],
+            _ => 0.0,
+        };
+        pr.value = KV::Vec3([x, y, z]);
+    }
+}
+
+/// [`insert_layer`] at stack position `at` (0 = top) instead of above the selected layer.
+pub(crate) fn insert_layer_at(proj: &mut Project, st: &mut crate::EditorState, cid: ItemId, mut layer: Layer, at: Option<usize>) -> Result<LayerId> {
+    // Text and shape layers in Advanced 3D comps get Geometry Options (extrusion, bevels).
+    if proj.comp(cid).is_some_and(|c| c.renderer == effectcraft_project::Renderer::Advanced3D) {
+        crate::cmd::model3d::add_geometry_options(&mut proj.next_id, &mut layer);
+    }
+    let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+    let at = match at {
+        Some(i) => i.min(comp.layers.len()),
+        None => st.selected_layers.first().and_then(|id| comp.layers.iter().position(|l| l.id == *id)).unwrap_or(0),
+    };
+    let id = layer.id;
+    comp.layers.insert(at, layer);
+    st.selected_layers = vec![id];
+    st.selected_props.clear();
+    st.selected_keys.clear();
+    Ok(id)
+}
+
+fn solids_folder(proj: &mut Project) -> ItemId {
+    proj.folder_named("Solids").unwrap_or_else(|| proj.add_item("Solids", Label::Yellow, None, ItemKind::Folder))
+}
+
+fn new_solid_like(s: &mut Session, p: &Value, adjustment: bool) -> Result<Value> {
+    let cid = comp_id(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
+    let color = color_p(p, "color").unwrap_or(if adjustment { [1.0, 1.0, 1.0] } else { [0.85, 0.2, 0.2] });
+    // 1 to 30,000 px a side (#788): the layer is sized from the same numbers as its solid.
+    let w = p.get("width").and_then(Value::as_u64).map(limits::size).unwrap_or(comp.width);
+    let h = p.get("height").and_then(Value::as_u64).map(limits::size).unwrap_or(comp.height);
+    let pixel_aspect = pixel_aspect_p(p)?.unwrap_or(comp.pixel_aspect);
+    let default_name = if adjustment { "Adjustment Layer 1".to_string() } else { "Solid 1".to_string() };
+    let name = str_p(p, "name").map(str::to_string).unwrap_or(default_name);
+    let id = s.edit(if adjustment { "New Adjustment Layer" } else { "New Solid" }, None, |proj, st| {
+        let folder = solids_folder(proj);
+        let sid = proj.add_item(&name, Label::Red, Some(folder), ItemKind::Solid(Solid { color, width: w, height: h, pixel_aspect }));
+        let mut l = build::layer(proj, &comp, &name, LayerSource::Solid { item: sid }, (w, h), None);
+        if adjustment {
+            l.switches.adjustment = true;
+            l.label = Label::Purple;
+        }
+        insert_layer(proj, st, cid, l)
+    })?;
+    Ok(json!({"layer": id.0}))
+}
+
+/// `pixelAspect` (a positive number), when given.
+pub(super) fn pixel_aspect_p(p: &Value) -> Result<Option<f64>> {
+    match p.get("pixelAspect").and_then(Value::as_f64) {
+        Some(v) if !(v.is_finite() && v > 0.0) => Err(bad("layer.settings", "`pixelAspect` must be a positive number")),
+        v => Ok(v.map(limits::pixel_aspect)),
+    }
+}
+
+pub(super) fn new_solid(s: &mut Session, p: &Value) -> Result<Value> {
+    new_solid_like(s, p, false)
+}
+
+pub(super) fn new_adjustment(s: &mut Session, p: &Value) -> Result<Value> {
+    new_solid_like(s, p, true)
+}
+
+/// Parameters of `layer.setText` / `layer.newText` that aren't text attributes.
+const NOT_ATTRS: &[&str] = &["layer", "layers", "comp", "merge", "text", "range", "position", "edit"];
+
+/// Apply `layer.setText` keys to `d`: `text` replaces characters `r` (or everything), then each
+/// character / paragraph / document attribute applies to `r` (or everything).
+pub(super) fn apply_text_params(cmd: &str, p: &Value, d: &mut TextDoc, r: Option<std::ops::Range<usize>>) -> Result<()> {
+    let mut r = r;
+    if let Some(t) = str_p(p, "text") {
+        match r.clone() {
+            Some(rr) => {
+                d.replace_range(rr.clone(), t, None);
+                r = Some(rr.start..rr.start + t.chars().count());
+            }
+            None => d.set_text(t),
+        }
+    }
+    let Some(obj) = p.as_object() else { return Ok(()) };
+    for (k, v) in obj {
+        if NOT_ATTRS.contains(&k.as_str()) {
+            continue;
+        }
+        if !d.set_attr(k, v, r.clone()).map_err(|e| bad(cmd, e))? {
+            return Err(bad(cmd, format!("unknown text attribute {k}")));
+        }
+    }
+    Ok(())
+}
+
+pub(super) fn text_range_p(p: &Value) -> Option<std::ops::Range<usize>> {
+    let a = p.get("range")?.as_array()?;
+    let g = |i: usize| a.get(i).and_then(Value::as_u64).map(|x| x as usize);
+    let (x, y) = (g(0)?, g(1).or(g(0))?);
+    Some(x.min(y)..x.max(y))
+}
+
+/// `layer.newText`: adds a Text layer to the comp at the CTI and returns `{layer}`.
+///
+/// The document starts as centre-justified "Text", with the optional text parameters applied.
+/// With `box` `[x, y, w, h]`, `(x, y)` is the paragraph box's top-left in comp space. Its width
+/// and height are `w.abs().max(1.0)` and `h.abs().max(1.0)`; the layer position is the box centre.
+/// It is left justified unless `justify` is given. The layer is named by `name`, else the first 40
+/// characters of the first text line, else "Text". `edit: true` also opens a new editing
+/// session with anchor `0` and the caret after the text, selecting all initial text so the next
+/// insertion replaces it. The session has `created: true`; leaving it empty keeps the layer, as After Effects does.
+pub(super) fn new_text(s: &mut Session, p: &Value) -> Result<Value> {
+    let cid = comp_id(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
+    let mut doc = TextDoc { text: "Text".into(), justify: Justify::Center, ..Default::default() };
+    // A paragraph box given in comp space: the layer sits at its centre.
+    let bx = p.get("box").and_then(Value::as_array).map(|a| [0, 1, 2, 3].map(|i| a.get(i).and_then(Value::as_f64).unwrap_or(0.0)));
+    let mut q = p.clone();
+    if let Some(o) = q.as_object_mut() {
+        o.remove("box");
+        o.remove("name");
+    }
+    let layer_name = str_p(p, "name").map(str::to_string);
+    apply_text_params("layer.newText", &q, &mut doc, None)?;
+    let mut pos = position_p(p, "layer.newText")?;
+    if let Some([x, y, w, h]) = bx {
+        let (w, h) = (w.abs().max(1.0), h.abs().max(1.0));
+        doc.box_size = Some([w, h]);
+        doc.box_pos = [-w / 2.0, -h / 2.0];
+        pos = Some([x + w / 2.0, y + h / 2.0]);
+        if p.get("justify").is_none() {
+            doc.set_attr("justify", &json!("left"), None).map_err(|e| bad("layer.newText", e))?;
+        }
+    }
+    let edit = b_p(p, "edit").unwrap_or(false);
+    let id = s.edit("New Text Layer", None, |proj, st| {
+        let name: String = layer_name.clone().unwrap_or_else(|| doc.text.lines().next().unwrap_or("").chars().take(40).collect());
+        let mut l = build::layer(proj, &comp, if name.is_empty() { "Text" } else { &name }, LayerSource::Text, (comp.width, comp.height), None);
+        if let Some(pr) = l.props.prop_mut("text/sourceText") {
+            pr.value = KV::Text(Box::new(doc.clone()));
+        }
+        if let Some(pos) = pos
+            && let Some(pr) = l.props.prop_mut("transform/position")
+        {
+            pr.value = KV::Vec3([pos[0], pos[1], 0.0]);
+        }
+        let n = doc.char_len();
+        let id = insert_layer(proj, st, cid, l)?;
+        if edit {
+            st.text_edit = Some(crate::cmd::text_edit::TextEdit {
+                layer: id,
+                anchor: 0,
+                caret: n,
+                created: true,
+                session: crate::cmd::text_edit::next_edit_session(),
+                ..Default::default()
+            });
+        }
+        Ok(id)
+    })?;
+    Ok(json!({"layer": id.0}))
+}
+
+pub(super) fn new_shape(s: &mut Session, p: &Value) -> Result<Value> {
+    let cid = comp_id(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
+    let kind = str_p(p, "kind").unwrap_or("none").to_string();
+    let size = p
+        .get("size")
+        .and_then(Value::as_array)
+        .map(|a| [a.first().and_then(Value::as_f64).unwrap_or(200.0), a.get(1).and_then(Value::as_f64).unwrap_or(200.0)])
+        .unwrap_or([300.0, 300.0]);
+    // A fill, and a stroke only with a width (not the Tools bar's paint).
+    let paint = crate::cmd::shape_tool::paint_p(p, &Default::default(), "layer.newShape")?;
+    let pos = p
+        .get("position")
+        .and_then(|v| v.as_array())
+        .map(|a| [a.first().and_then(Value::as_f64).unwrap_or(0.0), a.get(1).and_then(Value::as_f64).unwrap_or(0.0)]);
+    let name = str_p(p, "name").unwrap_or("Shape Layer 1").to_string();
+    let id = s.edit("New Shape Layer", None, |proj, st| {
+        let lid = crate::cmd::shape_tool::new_shape_layer(proj, st, &comp, cid, Some(&name), pos)?;
+        let mut next = proj.next_id;
+        let g = crate::cmd::shape_tool::shape_group(&mut Ids(&mut next), &kind, size, &paint);
+        proj.next_id = next;
+        if let Some(g) = g {
+            crate::cmd::shape_tool::add_to_contents(proj, cid, lid, g, [0.0, 0.0], "layer.newShape")?;
+        }
+        Ok(lid)
+    })?;
+    Ok(json!({"layer": id.0}))
+}
+
+fn new_simple(s: &mut Session, p: &Value, src: LayerSource, name: &str, label: &str) -> Result<Value> {
+    let cid = comp_id(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
+    let name = str_p(p, "name").unwrap_or(name).to_string();
+    let id = s.edit(label, None, |proj, st| {
+        let l = build::layer(proj, &comp, &name, src, (comp.width, comp.height), None);
+        insert_layer(proj, st, cid, l)
+    })?;
+    Ok(json!({"layer": id.0}))
+}
+
+pub(super) fn new_null(s: &mut Session, p: &Value) -> Result<Value> {
+    new_simple(s, p, LayerSource::Null, "Null 1", "New Null Object")
+}
+
+/// Largest `in` / `out` (s) and `anchor` coordinate (px) a command accepts.
+const MAX_PLACEMENT: f64 = 1.0e6;
+
+/// An `in` / `out` parameter: comp time in seconds, finite and within `0..=MAX_PLACEMENT`.
+fn time_param(p: &Value, key: &str, cmd: &str) -> Result<Option<Tick>> {
+    match p.get(key) {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => v
+            .as_f64()
+            .filter(|t| t.is_finite() && (0.0..=MAX_PLACEMENT).contains(t))
+            .map(|t| Some(Tick::from_seconds_f64(t)))
+            .ok_or_else(|| bad(cmd, format!("{key}: seconds in the composition, 0 to {MAX_PLACEMENT}"))),
+    }
+}
+
+/// An `anchor` parameter: `[x, y]` in layer pixels (finite, within `MAX_PLACEMENT`).
+fn anchor_param(p: &Value, cmd: &str) -> Result<Option<[f64; 2]>> {
+    match p.get("anchor") {
+        None | Some(Value::Null) => Ok(None),
+        Some(v) => v
+            .as_array()
+            .filter(|a| a.len() == 2)
+            .and_then(|a| Some([a.first()?.as_f64()?, a.get(1)?.as_f64()?]))
+            .filter(|c| c.iter().all(|x| x.is_finite() && x.abs() <= MAX_PLACEMENT))
+            .map(Some)
+            .ok_or_else(|| bad(cmd, "anchor: [x, y] in layer pixels")),
+    }
+}
+
+/// Put a new layer's Anchor Point at `pos` (layer pixels), keeping its z.
+fn set_anchor(l: &mut Layer, pos: Option<[f64; 2]>) {
+    if let Some([x, y]) = pos
+        && let Some(pr) = l.props.prop_mut("transform/anchor")
+    {
+        let z = match pr.value {
+            KV::Vec3(v) => v[2],
+            _ => 0.0,
+        };
+        pr.value = KV::Vec3([x, y, z]);
+    }
+}
+
+pub(super) fn add_item(s: &mut Session, p: &Value) -> Result<Value> {
+    let cid = comp_id(s, p)?;
+    let item = match p.get("item") {
+        Some(Value::Number(n)) => ItemId(n.as_u64().unwrap_or(0)),
+        Some(Value::String(name)) => s.project.find_by_name(name).map(|i| i.id).ok_or_else(|| bad("layer.addItem", format!("no item `{name}`")))?,
+        _ => *s.state.project_selection.first().ok_or_else(|| bad("layer.addItem", "missing `item`"))?,
+    };
+    if s.project.comp_contains(item, cid) {
+        return Err(bad("layer.addItem", "a composition can't contain itself"));
+    }
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
+    let it = s.project.item(item).ok_or_else(|| bad("layer.addItem", "no such item"))?.clone();
+    let (in_p, out_p) = (time_param(p, "in", "layer.addItem")?, time_param(p, "out", "layer.addItem")?);
+    if let (Some(i), Some(o)) = (in_p, out_p)
+        && i >= o
+    {
+        return Err(bad("layer.addItem", "in must be before out"));
+    }
+    let anchor = anchor_param(p, "layer.addItem")?;
+    let (src, size, dur) = match &it.kind {
+        ItemKind::Comp(c) => (LayerSource::Comp { item }, (c.width, c.height), Some(c.duration)),
+        ItemKind::Footage(f) if f.kind == effectcraft_project::FootageKind::Still => {
+            // `duration`, else Settings ▸ Import ▸ Still Footage: length of the composition or a
+            // duration.
+            let d = f_p(p, "duration")
+                .filter(|d| d.is_finite() && *d > 0.0)
+                .or((s.prefs.import.still_footage == "seconds").then_some(s.prefs.import.still_seconds))
+                .map(Tick::from_seconds_f64);
+            (LayerSource::Footage { item }, (f.width, f.height), d)
+        }
+        ItemKind::Footage(f) if f.kind == effectcraft_project::FootageKind::Data => {
+            return Err(bad("layer.addItem", "data files can't be layers; read them in expressions with footage(\"name\").sourceData"));
+        }
+        ItemKind::Footage(f) if f.kind == effectcraft_project::FootageKind::Model => {
+            if in_p.is_some() || out_p.is_some() || anchor.is_some() {
+                return Err(bad("layer.addItem", "in, out and anchor aren't supported for 3D models"));
+            }
+            return crate::cmd::model3d::new_model(
+                s,
+                &serde_json::json!({"comp": cid.0, "item": item.0, "time": f_p(p, "time"), "index": p.get("index"), "position": p.get("position")}),
+            );
+        }
+        ItemKind::Footage(f) => (LayerSource::Footage { item }, (f.width, f.height), Some(f.looped_duration())),
+        ItemKind::Solid(so) => (LayerSource::Solid { item }, (so.width, so.height), None),
+        ItemKind::Folder => return Err(bad("layer.addItem", "folders can't be layers")),
+    };
+    let index = index_p(p, "layer.addItem")?;
+    let position = position_p(p, "layer.addItem")?;
+    let fr = comp.frame_rate;
+    // Settings ▸ General ▸ Create Layers at Composition Start Time (off: at the current time).
+    let default_start = if s.prefs.general.create_layers_at_comp_start || s.active_comp_id() != Some(cid) { Tick::ZERO } else { s.time() };
+    let start = fr.snap_nearest(f_p(p, "time").map(Tick::from_seconds_f64).unwrap_or(default_start));
+    let id = s.edit("Add Footage to Comp", None, |proj, st| {
+        let mut l = build::layer(proj, &comp, &it.name, src, size, dur);
+        l.start_time = start;
+        l.in_point = start;
+        // Footage and precomps keep their full length past the comp's end (After Effects); items
+        // without a duration (solids, comp-length stills) end with the comp.
+        let end = dur.map_or((start + comp.duration).min(comp.duration), |d| start + d);
+        l.out_point = fr.snap_nearest(end).max(start + fr.frame_duration());
+        // `in` / `out` are comp times like `layer.timing`'s; each keeps at least one frame.
+        let fd = fr.frame_duration();
+        // In first, as `layer.timing` does, so an `out` before the layer's start still lands.
+        if let Some(i) = in_p {
+            l.in_point = fr.snap_nearest(i).min(l.out_point - fd);
+        }
+        if let Some(o) = out_p {
+            l.out_point = fr.snap_nearest(o).max(l.in_point + fd);
+        }
+        place(&mut l, position);
+        set_anchor(&mut l, anchor);
+        insert_layer_at(proj, st, cid, l, index)
+    })?;
+    Ok(json!({"layer": id.0}))
+}
diff --git a/crates/engine/src/cmd/layer/parent.rs b/crates/engine/src/cmd/layer/parent.rs
new file mode 100644
index 000000000..870d22f5f
--- /dev/null
+++ b/crates/engine/src/cmd/layer/parent.rs
@@ -0,0 +1,656 @@
+use super::{Comp, EngineError, ItemId, KV, Layer, LayerId, PropGroup, Result, Session, Tick, Value, b_p, bad, layers_p, resolve_layer, unlocked};
+
+/// Re-express a layer in its new parent space without moving its anchor.
+pub(crate) struct ParentFix {
+    pub layer: LayerId,
+    /// Maps Position from the old parent's space into the new one's.
+    m: effectcraft_geom::Mat3,
+    /// Added to Rotation.
+    rotation: f64,
+    /// Multiply Scale.
+    scale: [f64; 2],
+    /// 3D AV layers retain their world-space anchor, including Z. Cameras and lights also
+    /// re-express their Point of Interest.
+    position_3d: Option<effectcraft_geom::Mat4>,
+    /// A uniform relative parent transform re-expresses static Orientation and Scale.
+    pose_3d: Option<Pose3d>,
+}
+
+/// A uniform relative parent transform, as it applies to a 3D layer's Orientation and Scale.
+#[derive(Clone, Copy)]
+struct Pose3d {
+    /// Rotation that Orientation is re-expressed under: `Orientation' = correction * Orientation`.
+    correction: effectcraft_geom::Mat4,
+    /// Uniform scale factor, multiplied into Scale (negative for a mirrored parent).
+    factor: f64,
+}
+
+impl ParentFix {
+    /// Re-express the layer's Position, Rotation and Scale (every key) in the new parent's space.
+    pub fn apply(&self, l: &mut Layer) {
+        let Some(tr) = l.props.sub_mut("transform") else { return };
+        if let Some(m) = self.position_3d {
+            // Spatial Position speed measures distance along its path. Its parent-space
+            // unit changes even when the child's Orientation cannot be re-expressed.
+            let position_speed = uniform_rotation(m).map(|(_, factor)| factor.abs());
+            let map_position = |v: &KV| {
+                let q = m.apply(effectcraft_geom::Vec3::from(v.as_vec3()));
+                KV::Vec3([q.x, q.y, q.z])
+            };
+            // Read all separated axes before writing any of them.
+            let names = ["positionX", "positionY", "positionZ"];
+            if tr.get("positionX").is_some() {
+                let axes = names.map(|name| tr.get(name).cloned());
+                let current = axes.each_ref().map(|pr| pr.as_ref().map(|pr| pr.value.as_f64()).unwrap_or(0.0));
+                let q = m.apply(effectcraft_geom::Vec3::from(current));
+                for (i, name) in names.into_iter().enumerate() {
+                    if let Some(pr) = tr.get_mut(name) {
+                        pr.value = KV::Scalar([q.x, q.y, q.z].get(i).copied().unwrap_or(0.0));
+                        for key in &mut pr.keys {
+                            let p = axes.each_ref().map(|axis| axis.as_ref().map(|axis| axis.value_at(key.time).as_f64()).unwrap_or(0.0));
+                            let q = m.apply(effectcraft_geom::Vec3::from(p));
+                            key.value = KV::Scalar([q.x, q.y, q.z].get(i).copied().unwrap_or(0.0));
+                        }
+                    }
+                }
+            }
+            // Position and a camera's or light's Point of Interest are both points in the parent's space.
+            let map_point = |pr: &mut effectcraft_project::Property| {
+                pr.value = map_position(&pr.value);
+                for key in &mut pr.keys {
+                    key.value = map_position(&key.value);
+                    // Spatial tangents are vectors, so the parent's translation is excluded.
+                    for tangent in [&mut key.spatial_in, &mut key.spatial_out] {
+                        let v = m.apply_vec(effectcraft_geom::Vec3::from(*tangent));
+                        *tangent = [v.x, v.y, v.z];
+                    }
+                }
+                if let Some(factor) = position_speed
+                    .filter(|_| pr.spatial)
+                    .filter(|factor| pr.keys.iter().flat_map(|key| key.in_ease.iter().chain(&key.out_ease)).all(|ease| (ease.speed * *factor).is_finite()))
+                {
+                    for key in &mut pr.keys {
+                        for ease in key.in_ease.iter_mut().chain(&mut key.out_ease) {
+                            ease.speed *= factor;
+                        }
+                    }
+                }
+            };
+            if let Some(pr) = tr.get_mut("position") {
+                map_point(pr);
+            }
+            if let Some(pr) = tr.get_mut("poi") {
+                map_point(pr);
+            }
+            if let Some(pose) = self.pose_3d {
+                if let Some(pr) = tr.get_mut("orientation") {
+                    reexpress_orientation(pose.correction, pr);
+                }
+                if let Some(pr) = tr.get_mut("scale") {
+                    let factor = pose.factor;
+                    let scaled = |value: &KV| KV::Vec3(value.as_vec3().map(|v| v * factor));
+                    pr.value = scaled(&pr.value);
+                    for key in &mut pr.keys {
+                        key.value = scaled(&key.value);
+                        // Scale's temporal speeds use the same units as its values.
+                        for ease in key.in_ease.iter_mut().chain(&mut key.out_ease) {
+                            ease.speed *= factor;
+                        }
+                    }
+                }
+            }
+            return;
+        }
+        let map = |pr: &mut effectcraft_project::Property, f: &dyn Fn(&KV) -> KV| {
+            pr.value = f(&pr.value);
+            for key in &mut pr.keys {
+                key.value = f(&key.value);
+            }
+        };
+        let m = self.m;
+        if tr.get("positionX").is_some() {
+            // Separated dimensions: X and Y move together, key by key at the same times.
+            // Everything is read before anything is written.
+            let [x, y] = [tr.get("positionX"), tr.get("positionY")].map(|p| p.map(|p| p.value.as_f64()).unwrap_or(0.0));
+            let q = m.apply(effectcraft_geom::vec2(x, y));
+            let keys_x: Vec<(Tick, f64)> = tr.get("positionX").map(|p| p.keys.iter().map(|k| (k.time, k.value.as_f64())).collect()).unwrap_or_default();
+            let keys_y: Vec<(Tick, f64)> = tr.get("positionY").map(|p| p.keys.iter().map(|k| (k.time, k.value.as_f64())).collect()).unwrap_or_default();
+            let at = |keys: &[(Tick, f64)], name: &str, t: Tick, tr: &PropGroup| {
+                keys.iter().find(|k| k.0 == t).map(|k| k.1).unwrap_or_else(|| tr.get(name).map(|p| p.value_at(t).as_f64()).unwrap_or(0.0))
+            };
+            let (xs, ys): (Vec<f64>, Vec<f64>) = (
+                keys_x.iter().map(|&(t, x)| m.apply(effectcraft_geom::vec2(x, at(&keys_y, "positionY", t, tr))).x).collect(),
+                keys_y.iter().map(|&(t, y)| m.apply(effectcraft_geom::vec2(at(&keys_x, "positionX", t, tr), y)).y).collect(),
+            );
+            for (name, value, vals) in [("positionX", q.x, xs), ("positionY", q.y, ys)] {
+                if let Some(pr) = tr.get_mut(name) {
+                    pr.value = KV::Scalar(value);
+                    for (k, v) in pr.keys.iter_mut().zip(vals) {
+                        k.value = KV::Scalar(v);
+                    }
+                }
+            }
+        } else if let Some(pr) = tr.get_mut("position") {
+            map(pr, &|v| {
+                let c = v.as_vec3();
+                let q = m.apply(effectcraft_geom::vec2(c[0], c[1]));
+                KV::Vec3([q.x, q.y, c[2]])
+            });
+        }
+        let (dr, k) = (self.rotation, self.scale);
+        if let Some(pr) = tr.get_mut("rotation") {
+            map(pr, &|v| KV::Scalar(v.as_f64() + dr));
+        }
+        if let Some(pr) = tr.get_mut("scale") {
+            map(pr, &|v| {
+                let c = v.as_vec3();
+                KV::Vec3([c[0] * k[0], c[1] * k[1], c[2]])
+            });
+        }
+    }
+}
+
+/// The rotation and signed scale factor of a uniform parent transform's linear part (negative for a
+/// mirrored parent). `None` for a non-uniform or degenerate transform.
+fn uniform_rotation(m: effectcraft_geom::Mat4) -> Option<(effectcraft_geom::Mat4, f64)> {
+    use effectcraft_geom::{Mat4, vec3};
+    let a = m.0;
+    let columns = [vec3(a[0][0], a[1][0], a[2][0]), vec3(a[0][1], a[1][1], a[2][1]), vec3(a[0][2], a[1][2], a[2][2])];
+    let magnitude = columns[0].x.hypot(columns[0].y).hypot(columns[0].z);
+    if !magnitude.is_finite() || magnitude <= 0.0 {
+        return None;
+    }
+    let c = columns.map(|c| c / magnitude);
+    if c.iter().any(|c| (c.dot(*c) - 1.0).abs() > 1e-9) || c[0].dot(c[1]).abs() > 1e-9 || c[0].dot(c[2]).abs() > 1e-9 || c[1].dot(c[2]).abs() > 1e-9 {
+        return None;
+    }
+    let cross = vec3(c[1].y * c[2].z - c[1].z * c[2].y, c[1].z * c[2].x - c[1].x * c[2].z, c[1].x * c[2].y - c[1].y * c[2].x);
+    let factor = if c[0].dot(cross) < 0.0 { -magnitude } else { magnitude };
+    let mut rotation = Mat4::IDENTITY;
+    for row in 0..3 {
+        for col in 0..3 {
+            rotation.0[row][col] = a[row][col] / factor;
+        }
+    }
+    Some((rotation, factor))
+}
+
+/// The turn (degrees) of a rotation about Z alone, or `None` for any other rotation.
+fn z_only_turn(correction: effectcraft_geom::Mat4) -> Option<f64> {
+    let m = correction.0;
+    let about_z = [m[0][2], m[1][2], m[2][0], m[2][1]].iter().all(|v| v.abs() < 1e-9) && (m[2][2] - 1.0).abs() < 1e-9;
+    about_z.then(|| m[1][0].atan2(m[0][0]).to_degrees())
+}
+
+/// ZYX Euler angles in degrees of a row-major rotation (`Rz * Ry * Rx`), safe at gimbal lock.
+fn euler_zyx(r: [[f64; 4]; 4]) -> [f64; 3] {
+    // atan2 rather than asin: near ±90 degrees asin loses precision, while cos(y) stays exact.
+    let cy = r[0][0].hypot(r[1][0]);
+    let y = (-r[2][0]).atan2(cy);
+    let (x, z) = if cy > 1e-9 { (r[2][1].atan2(r[2][2]), r[1][0].atan2(r[0][0])) } else { ((-r[1][2]).atan2(r[1][1]), 0.0) };
+    [x.to_degrees(), y.to_degrees(), z.to_degrees()]
+}
+
+/// The equivalent ZYX Euler triple nearest `reference`: each axis moved by whole turns, or the
+/// `(x + 180, 180 - y, z + 180)` form when that is nearer.
+fn nearest_euler(euler: [f64; 3], reference: [f64; 3]) -> [f64; 3] {
+    let near = |v: [f64; 3]| -> [f64; 3] { std::array::from_fn(|i| v[i] + ((reference[i] - v[i]) / 360.0).round() * 360.0) };
+    let natural = near(euler);
+    let flipped = near([euler[0] + 180.0, 180.0 - euler[1], euler[2] + 180.0]);
+    let distance = |v: [f64; 3]| v.iter().zip(reference.iter()).map(|(a, b)| (a - b).powi(2)).sum::<f64>();
+    if distance(flipped) < distance(natural) { flipped } else { natural }
+}
+
+/// The Euler Orientation of `correction * Orientation(o)`, in the form nearest `reference`.
+fn reexpress_euler(correction: effectcraft_geom::Mat4, o: [f64; 3], reference: [f64; 3]) -> [f64; 3] {
+    let world = correction * effectcraft_geom::Mat4::orientation(effectcraft_geom::Vec3::from(o));
+    nearest_euler(euler_zyx(world.0), reference)
+}
+
+/// Largest angle (degrees) a baked Orientation may drift from the exact rotation between its keys.
+const BAKE_TOLERANCE_DEGREES: f64 = 0.05;
+/// How many times a segment may be halved while baking, and the most keys a property may end up with.
+const BAKE_MAX_DEPTH: u32 = 10;
+const BAKE_MAX_KEYS: usize = 4096;
+
+/// The angle (degrees) between two rotations.
+fn rotation_angle(a: effectcraft_geom::Mat4, b: effectcraft_geom::Mat4) -> f64 {
+    let trace: f64 = (0..3).flat_map(|i| (0..3).map(move |j| (i, j))).map(|(i, j)| a.0[i][j] * b.0[i][j]).sum();
+    ((trace - 1.0) / 2.0).clamp(-1.0, 1.0).acos().to_degrees()
+}
+
+/// Adds keys between `(ta, ea)` and `(tb, eb)` (already converted) wherever the straight Euler blend
+/// between them drifts from `correction * Orientation(authored)` by more than the tolerance. `out`
+/// never grows past `budget` keys: what the whole property may still add, not what one segment may.
+fn bake_between(
+    correction: effectcraft_geom::Mat4,
+    authored: &effectcraft_project::Property,
+    (ta, ea): (Tick, [f64; 3]),
+    (tb, eb): (Tick, [f64; 3]),
+    depth: u32,
+    budget: usize,
+    out: &mut Vec<effectcraft_keyframe::Keyframe>,
+) {
+    use effectcraft_geom::{Mat4, Vec3};
+    if depth == 0 || tb.0 - ta.0 < 2 || out.len() >= budget {
+        return;
+    }
+    let tm = Tick(ta.0 + (tb.0 - ta.0) / 2);
+    let blend = [(ea[0] + eb[0]) / 2.0, (ea[1] + eb[1]) / 2.0, (ea[2] + eb[2]) / 2.0];
+    let exact = correction * Mat4::orientation(Vec3::from(authored.value_at(tm).as_vec3()));
+    // Symmetric easing crosses the straight blend at its midpoint. Check both sides too before
+    // accepting a segment whose original easing will be replaced with a linear blend.
+    let quarter = (tb.0 - ta.0) / 4;
+    if [Tick(ta.0 + quarter), tm, Tick(tb.0 - quarter)].into_iter().all(|t| {
+        let u = (t.0 - ta.0) as f64 / (tb.0 - ta.0) as f64;
+        let linear = std::array::from_fn(|i| ea[i] + (eb[i] - ea[i]) * u);
+        let target = correction * Mat4::orientation(Vec3::from(authored.value_at(t).as_vec3()));
+        rotation_angle(Mat4::orientation(Vec3::from(linear)), target) <= BAKE_TOLERANCE_DEGREES
+    }) {
+        return;
+    }
+    let em = nearest_euler(euler_zyx(exact.0), blend);
+    bake_between(correction, authored, (ta, ea), (tm, em), depth - 1, budget, out);
+    if out.len() >= budget {
+        return;
+    }
+    out.push(effectcraft_keyframe::Keyframe::new(tm, KV::Vec3(em)));
+    bake_between(correction, authored, (tm, em), (tb, eb), depth - 1, budget, out);
+}
+
+/// Re-expresses Orientation as `correction * Orientation`. A Z-only correction shifts Z exactly in the
+/// value and every key. For any other correction a static value is converted directly; keys are
+/// converted, and keys are added between them wherever the Euler blend between two keys would drift
+/// from the exact rotation (the segments become linear, with the original easing baked in).
+fn reexpress_orientation(correction: effectcraft_geom::Mat4, pr: &mut effectcraft_project::Property) {
+    if let Some(turn) = z_only_turn(correction) {
+        // No turn (an identity correction) leaves every authored value as it is.
+        if turn.abs() <= 1e-12 {
+            return;
+        }
+        let shift = |value: &KV| {
+            let [x, y, z] = value.as_vec3();
+            KV::Vec3([x, y, z + turn])
+        };
+        pr.value = shift(&pr.value);
+        for key in &mut pr.keys {
+            key.value = shift(&key.value);
+        }
+        return;
+    }
+    let value = pr.value.as_vec3();
+    pr.value = KV::Vec3(reexpress_euler(correction, value, value));
+    if pr.keys.is_empty() {
+        return;
+    }
+    let authored = pr.clone();
+    // Each key keeps the authored change from the previous key on top of its converted value.
+    let mut converted: Vec<[f64; 3]> = vec![];
+    let mut prev: Option<([f64; 3], [f64; 3])> = None;
+    for key in &authored.keys {
+        let o = key.value.as_vec3();
+        let reference = match prev {
+            Some((before, after)) => [after[0] + o[0] - before[0], after[1] + o[1] - before[1], after[2] + o[2] - before[2]],
+            None => o,
+        };
+        let n = reexpress_euler(correction, o, reference);
+        converted.push(n);
+        prev = Some((o, n));
+    }
+    use effectcraft_keyframe::Interp;
+    let mut keys: Vec<effectcraft_keyframe::Keyframe> = vec![];
+    let mut after_baked_segment = false;
+    for (i, key) in authored.keys.iter().enumerate() {
+        let mut k = key.clone();
+        k.value = KV::Vec3(converted[i]);
+        if after_baked_segment {
+            k.in_interp = Interp::Linear;
+            k.in_ease.clear();
+            k.auto_bezier = false;
+            k.continuous = false;
+        }
+        after_baked_segment = false;
+        let segment = authored.keys.get(i + 1).filter(|_| key.out_interp != Interp::Hold);
+        let mut between = vec![];
+        if let Some(next) = segment {
+            // What the whole property may still add: the keys it will have already (the ones written
+            // and the authored ones still to come) count against the cap.
+            let budget = BAKE_MAX_KEYS.saturating_sub(keys.len() + authored.keys.len() - i);
+            bake_between(correction, &authored, (key.time, converted[i]), (next.time, converted[i + 1]), BAKE_MAX_DEPTH, budget, &mut between);
+            // With the cap reached the segment can't be checked or subdivided: it keeps its authored easing between
+            // the converted keys, rather than becoming a straight blend that was never checked against the original.
+            if between.len() >= budget {
+                between.clear();
+            // An eased segment, or one that gained keys, becomes a run of straight blends.
+            } else if !between.is_empty() || key.out_interp != Interp::Linear || next.in_interp != Interp::Linear {
+                k.out_interp = Interp::Linear;
+                k.out_ease.clear();
+                k.auto_bezier = false;
+                k.continuous = false;
+                after_baked_segment = true;
+            }
+        }
+        keys.push(k);
+        keys.extend(between);
+    }
+    pr.keys = keys;
+}
+
+/// Correction for a two-node rig's Orientation: after a uniform parent change its aim is
+/// `rotation * aim`, so the roll is re-expressed against that aim. `None` for a degenerate aim.
+fn aim_correction(rotation: effectcraft_geom::Mat4, aim: [f64; 3]) -> Option<effectcraft_geom::Mat4> {
+    use effectcraft_geom::vec3;
+    use effectcraft_render::three_d::camera::basis_rotation;
+    let [x, y, z] = aim;
+    let length = (x * x + y * y + z * z).sqrt();
+    if !length.is_finite() || length <= 1e-9 {
+        return None;
+    }
+    let dir = vec3(x / length, y / length, z / length);
+    let turned = rotation.apply_vec(dir);
+    // A view along the up axis has no roll to keep, and its basis is undefined.
+    if 1.0 - dir.y * dir.y < 1e-12 || 1.0 - turned.y * turned.y < 1e-12 {
+        return None;
+    }
+    let up = vec3(0.0, 1.0, 0.0);
+    Some(basis_rotation(turned, up).transpose() * rotation * basis_rotation(dir, up))
+}
+
+/// A parent change retains 2D transforms and the world-space anchor of 3D layers (Position,
+/// and Point of Interest for two-node cameras and lights). Position is
+/// re-expressed in the new parent's space (`None`: the composition), evaluated at the current
+/// time.
+pub(crate) fn parent_fixes(s: &Session, cid: ItemId, ids: &[LayerId], parent: Option<LayerId>) -> Vec<ParentFix> {
+    let Some(comp) = s.project.comp(cid) else { return vec![] };
+    let ectx = effectcraft_render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time: s.time(),
+        expr: s.expr.as_deref(),
+        footage: Some(s.footage.as_ref()),
+        property_overrides: &[],
+        media_overrides: &[],
+    };
+    let space = |id: Option<LayerId>| -> effectcraft_geom::Mat3 {
+        id.and_then(|i| comp.layer(i)).filter(|l| !l.is_3d()).map(|l| ectx.layer_to_comp(l).0).unwrap_or(effectcraft_geom::Mat3::IDENTITY)
+    };
+    let decompose = |m: &effectcraft_geom::Mat3| {
+        let a = m.0;
+        let sx = (a[0][0] * a[0][0] + a[1][0] * a[1][0]).sqrt();
+        let det = a[0][0] * a[1][1] - a[0][1] * a[1][0];
+        (a[1][0].atan2(a[0][0]).to_degrees(), sx, if sx > 1e-12 { det / sx } else { 0.0 })
+    };
+    let new_m = space(parent);
+    let Some(inv) = new_m.inverse() else { return vec![] };
+    let (rn, sxn, syn) = decompose(&new_m);
+    let mut fixes: Vec<_> = comp
+        .layers
+        .iter()
+        .filter(|l| ids.contains(&l.id) && !l.is_3d() && l.parent != parent)
+        .map(|l| {
+            let old_m = space(l.parent);
+            let (ro, sxo, syo) = decompose(&old_m);
+            let scale = [if sxn.abs() > 1e-12 { sxo / sxn } else { 1.0 }, if syn.abs() > 1e-12 { syo / syn } else { 1.0 }];
+            ParentFix { layer: l.id, m: inv * old_m, rotation: ro - rn, scale, position_3d: None, pose_3d: None }
+        })
+        .collect();
+    let space_3d = |id: Option<LayerId>| {
+        id.and_then(|id| comp.layer(id)).map_or(effectcraft_geom::Mat4::IDENTITY, |layer| {
+            // Parent transforms do not inherit the parent's source pixel-aspect stretch.
+            let world = ectx.world_matrix(layer);
+            let par = ectx.par_ratio(layer);
+            let a = layer.transform().map(|tr| ectx.v3(layer, tr, "anchor", [0.0; 3])).unwrap_or([0.0; 3]);
+            let anchor = effectcraft_geom::vec3(a[0], a[1], if layer.is_3d() { a[2] } else { 0.0 });
+            world
+                * effectcraft_geom::Mat4::translate(anchor)
+                * effectcraft_geom::Mat4::scale(effectcraft_geom::vec3(1.0 / par, 1.0, 1.0))
+                * effectcraft_geom::Mat4::translate(-anchor)
+        })
+    };
+    if let Some(inv) = space_3d(parent).inverse().filter(|m| m.0.iter().flatten().all(|v| v.is_finite())) {
+        for layer in comp.layers.iter().filter(|l| ids.contains(&l.id) && l.is_3d() && l.parent != parent) {
+            let m = inv * space_3d(layer.parent);
+            // A one-node camera or light has no Scale to carry a mirror, and its frame (forward and
+            // down) would come out reversed: compensate none of it, so Position and Orientation stay
+            // as authored instead of half-following the parent.
+            let rig = layer.is_camera() || layer.is_light();
+            if rig && !effectcraft_render::three_d::camera::is_two_node(layer) && uniform_rotation(m).is_some_and(|(_, factor)| factor <= 0.0) {
+                continue;
+            }
+            if m.0.iter().flatten().all(|v| v.is_finite()) {
+                let pose_3d = layer.transform().and_then(|tr| {
+                    let orientation = tr.get("orientation")?;
+                    // Cameras and lights have no Scale; their Orientation is re-expressed alone.
+                    let scale = tr.get("scale");
+                    // Expression-driven values stay authored. Auto-orient replaces Orientation, except
+                    // a two-node rig, whose roll is re-expressed against its new aim.
+                    let two_node = (layer.is_camera() || layer.is_light()) && effectcraft_render::three_d::camera::is_two_node(layer);
+                    if orientation.expr.is_some()
+                        || scale.is_some_and(|scale| scale.expr.is_some())
+                        || (layer.auto_orient != effectcraft_project::AutoOrient::Off && !two_node)
+                    {
+                        return None;
+                    }
+                    let (rotation, factor) = uniform_rotation(m)?;
+                    let correction = if two_node {
+                        // A mirrored parent flips the aim, which this correction does not model.
+                        if factor <= 0.0 {
+                            return None;
+                        }
+                        let (w, h) = (comp.width as f64, comp.height as f64);
+                        let pos = ectx.v3(layer, tr, "position", [w / 2.0, h / 2.0, -1000.0]);
+                        let poi = ectx.v3(layer, tr, "poi", [w / 2.0, h / 2.0, 0.0]);
+                        aim_correction(rotation, [poi[0] - pos[0], poi[1] - pos[1], poi[2] - pos[2]])?
+                    } else {
+                        rotation
+                    };
+                    let orientation_finite = std::iter::once(&orientation.value)
+                        .chain(orientation.keys.iter().map(|key| &key.value))
+                        .all(|value| value.as_vec3().iter().all(|v| v.is_finite()));
+                    if !correction.0.iter().flatten().all(|v| v.is_finite()) || !orientation_finite {
+                        return None;
+                    }
+                    if let Some(scale) = scale {
+                        let values_finite = std::iter::once(&scale.value)
+                            .chain(scale.keys.iter().map(|key| &key.value))
+                            .all(|value| value.as_vec3().iter().all(|v| (v * factor).is_finite()));
+                        let speeds_finite = scale.keys.iter().all(|key| key.in_ease.iter().chain(&key.out_ease).all(|ease| (ease.speed * factor).is_finite()));
+                        if !values_finite || !speeds_finite {
+                            return None;
+                        }
+                    }
+                    Some(Pose3d { correction, factor })
+                });
+                fixes.push(ParentFix { layer: layer.id, m: effectcraft_geom::Mat3::IDENTITY, rotation: 0.0, scale: [1.0; 2], position_3d: Some(m), pose_3d });
+            }
+        }
+    }
+    fixes
+}
+
+/// Validate the proposed ancestor chain before any authored edit, including when compensation
+/// is disabled. Bound both unique ancestors and linear lookup/selection work on loaded graphs.
+fn check_parent_chain(comp: &Comp, ids: &[LayerId], parent: Option<LayerId>, max_visits: usize, max_work: usize) -> Result<()> {
+    let mut seen = std::collections::HashSet::new();
+    let mut work = 0usize;
+    let mut cur = parent;
+    while let Some(id) = cur {
+        if seen.len() >= max_visits {
+            return Err(bad("layer.setParent", "parent chain exceeds the safety visit limit"));
+        }
+        if !seen.insert(id) {
+            return Err(bad("layer.setParent", "parent chain contains an existing cycle"));
+        }
+        for selected in ids {
+            if work >= max_work {
+                return Err(bad("layer.setParent", "parent chain exceeds the safety work limit"));
+            }
+            work += 1;
+            if *selected == id {
+                return Err(bad("layer.setParent", "parenting would create a cycle"));
+            }
+        }
+        let mut ancestor = None;
+        for layer in &comp.layers {
+            if work >= max_work {
+                return Err(bad("layer.setParent", "parent chain exceeds the safety work limit"));
+            }
+            work += 1;
+            if layer.id == id {
+                ancestor = Some(layer);
+                break;
+            }
+        }
+        let layer = ancestor.ok_or_else(|| bad("layer.setParent", "parent chain refers to a missing layer"))?;
+        cur = layer.parent;
+    }
+    Ok(())
+}
+
+pub(super) fn set_parent(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, ids) = layers_p(s, p)?;
+    // Locked layers keep their parent (several at once: the others are parented).
+    let ids = unlocked(s, cid, ids, "layer.setParent")?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let parent = match p.get("parent") {
+        None | Some(Value::Null) => None,
+        Some(v) => Some(resolve_layer(comp, v).ok_or_else(|| bad("layer.setParent", "no such parent layer"))?),
+    };
+    // A loaded cycle need not include a selected child. Validate before compensation or edit;
+    // do not impose the renderer's 64-ancestor truncation as a new ordinary hierarchy limit.
+    check_parent_chain(comp, &ids, parent, 4096, 1_048_576)?;
+    // Like AE's pick-whip, parenting keeps the layer where it is: its transform is re-expressed
+    // in the new parent's space (Position, Rotation, Scale), unless `compensate: false`.
+    let compensate = b_p(p, "compensate").unwrap_or(true);
+    let fixes = if compensate { parent_fixes(s, cid, &ids, parent) } else { vec![] };
+    s.edit("Parent", None, |proj, _| {
+        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
+            l.parent = parent;
+            if let Some(f) = fixes.iter().find(|f| f.layer == l.id) {
+                f.apply(l);
+            }
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+#[cfg(test)]
+mod parent_chain_tests {
+    use super::super::json;
+    use super::*;
+    use std::sync::Arc;
+
+    fn fixture() -> (Session, u64, u64, u64) {
+        let mut s = Session::default();
+        s.execute("comp.new", json!({"name":"Parent safety","width":16,"height":16,"duration":1})).unwrap();
+        let a = s.execute("layer.newSolid", json!({"name":"A"})).unwrap()["layer"].as_u64().unwrap();
+        let b = s.execute("layer.newSolid", json!({"name":"B"})).unwrap()["layer"].as_u64().unwrap();
+        let c = s.execute("layer.newSolid", json!({"name":"C"})).unwrap()["layer"].as_u64().unwrap();
+        for id in [a, b, c] {
+            s.execute("prop.set", json!({"layer":id,"path":"transform/anchor","value":[0,0,0]})).unwrap();
+        }
+        s.execute("prop.set", json!({"layer":a,"path":"transform/position","value":[100,200,0]})).unwrap();
+        s.execute("prop.set", json!({"layer":c,"path":"transform/position","value":[10,20,0]})).unwrap();
+        s.history.undo.clear();
+        (s, a, b, c)
+    }
+    fn malformed_parent(s: &mut Session, child: u64, parent: u64) {
+        let cid = s.active_comp_id().unwrap();
+        Arc::make_mut(&mut s.project).comp_mut(cid).unwrap().layer_mut(LayerId(child)).unwrap().parent = Some(LayerId(parent));
+    }
+    fn assert_atomic_error(s: &mut Session, child: u64, parent: u64, compensate: bool, message: &str) {
+        let before = s.project.clone();
+        let revision = s.revision;
+        let undo = s.history.undo.len();
+        let err = s.execute("layer.setParent", json!({"layers":[child],"parent":parent,"compensate":compensate})).unwrap_err();
+        assert!(err.to_string().contains(message), "{err}");
+        assert!(Arc::ptr_eq(&before, &s.project));
+        assert_eq!(s.revision, revision);
+        assert_eq!(s.history.undo.len(), undo);
+    }
+    #[test]
+    fn loaded_cycle_excluding_selected_child_is_rejected_atomically() {
+        for compensate in [true, false] {
+            let (mut s, a, b, c) = fixture();
+            // Simulate a malformed loaded project. Never execute this on the unguarded baseline.
+            malformed_parent(&mut s, a, b);
+            malformed_parent(&mut s, b, a);
+            assert_atomic_error(&mut s, c, a, compensate, "existing cycle");
+        }
+    }
+    #[test]
+    fn dangling_loaded_parent_is_rejected_atomically() {
+        for compensate in [true, false] {
+            let (mut s, a, _, c) = fixture();
+            malformed_parent(&mut s, a, u64::MAX);
+            assert_atomic_error(&mut s, c, a, compensate, "missing layer");
+        }
+    }
+    #[test]
+    fn selected_descendant_and_direct_self_are_rejected() {
+        let (mut s, a, _, c) = fixture();
+        assert_atomic_error(&mut s, c, c, false, "create a cycle");
+        s.execute("layer.setParent", json!({"layers":[a],"parent":c,"compensate":false})).unwrap();
+        assert_atomic_error(&mut s, c, a, true, "create a cycle");
+    }
+    #[test]
+    fn ordinary_parent_and_unparent_keep_explicit_false_and_undo_semantics() {
+        for compensate in [true, false] {
+            let (mut s, a, _, c) = fixture();
+            let old = s.project.clone();
+            let world = |s: &Session| {
+                let cid = s.active_comp_id().unwrap();
+                let comp = s.active_comp().unwrap();
+                let ctx = effectcraft_render::EvalCtx::new(&s.project, cid, comp, s.time());
+                ctx.world_matrix(comp.layer(LayerId(c)).unwrap()).apply(effectcraft_geom::Vec3::ZERO)
+            };
+            let before = world(&s);
+            s.execute("layer.setParent", json!({"layers":[c],"parent":a,"compensate":compensate})).unwrap();
+            let expected = if compensate { before } else { before + effectcraft_geom::vec3(100.0, 200.0, 0.0) };
+            assert!((world(&s) - expected).length() < 1e-9);
+            assert_eq!(s.active_comp().unwrap().layer(LayerId(c)).unwrap().parent, Some(LayerId(a)));
+            assert_eq!(s.history.undo.len(), 1);
+            let parented = s.project.clone();
+            assert!(s.undo());
+            assert!(Arc::ptr_eq(&s.project, &old));
+            assert!(s.redo());
+            assert!(Arc::ptr_eq(&s.project, &parented));
+            s.execute("layer.setParent", json!({"layers":[c],"parent":null,"compensate":compensate})).unwrap();
+            assert_eq!(s.active_comp().unwrap().layer(LayerId(c)).unwrap().parent, None);
+            assert!(s.undo());
+            assert!(Arc::ptr_eq(&s.project, &parented));
+        }
+    }
+    #[test]
+    fn ancestor_and_lookup_work_budgets_fail_closed() {
+        let (mut s, a, b, c) = fixture();
+        malformed_parent(&mut s, a, b);
+        let comp = s.active_comp().unwrap();
+        // New solids are inserted above the selection: C,B,A. Walking A->B scans
+        // three then two layers, and compares the one selected child twice: seven work units.
+        assert_eq!(comp.layers.iter().map(|l| l.id).collect::<Vec<_>>(), vec![LayerId(c), LayerId(b), LayerId(a)]);
+        assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 7).is_ok());
+        assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 6).unwrap_err().to_string().contains("work limit"));
+        assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 256).is_ok());
+        assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 1, 256).unwrap_err().to_string().contains("visit limit"));
+        assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 1).unwrap_err().to_string().contains("work limit"));
+        assert!(check_parent_chain(comp, &[LayerId(c)], None, 0, 0).is_ok(), "unparenting does not traverse ancestors");
+    }
+
+    #[test]
+    fn well_formed_chain_beyond_renderer_depth_is_not_unnecessarily_rejected() {
+        let (s, _, _, c) = fixture();
+        let mut comp = s.active_comp().unwrap().clone();
+        let template = comp.layers.first().unwrap().clone();
+        for n in 0..80 {
+            let mut layer = template.clone();
+            layer.id = LayerId(10_000 + n);
+            layer.parent = (n < 79).then_some(LayerId(10_001 + n));
+            comp.layers.push(layer);
+        }
+        assert!(check_parent_chain(&comp, &[LayerId(c)], Some(LayerId(10_000)), 4096, 1_048_576).is_ok());
+    }
+}
diff --git a/crates/engine/src/cmd/layer/replace.rs b/crates/engine/src/cmd/layer/replace.rs
new file mode 100644
index 000000000..80e5be807
--- /dev/null
+++ b/crates/engine/src/cmd/layer/replace.rs
@@ -0,0 +1,101 @@
+use super::{
+    EngineError, FootageKind, Ids, ItemId, ItemKind, Layer, LayerSource, Project, Result, Session, Value, bad, build, has_comp, json, layer_mut, layers_p,
+    unlocked,
+};
+
+/// A layer whose source is an item (footage, precomposition or solid), as in After Effects'
+/// Replace Source. Text, shape, null, camera, light and 3D model layers have no AVItem source to
+/// replace.
+fn replaceable_layer(l: &Layer) -> bool {
+    matches!(l.source, LayerSource::Footage { .. } | LayerSource::Comp { .. } | LayerSource::Solid { .. })
+}
+
+/// The source a Project item gives a layer, or why it can't replace one.
+fn replacement_source(item: ItemId, it: &effectcraft_project::Item) -> Result<LayerSource> {
+    const CMD: &str = "layer.replaceSource";
+    match &it.kind {
+        ItemKind::Comp(_) => Ok(LayerSource::Comp { item }),
+        ItemKind::Footage(f) if f.kind == FootageKind::Data => {
+            Err(bad(CMD, "data files can't be layer sources; read them in expressions with footage(\"name\").sourceData"))
+        }
+        ItemKind::Footage(f) if f.kind == FootageKind::Model => Err(bad(CMD, "3D model items can't replace a 2D layer source; add them as 3D layers")),
+        ItemKind::Footage(_) => Ok(LayerSource::Footage { item }),
+        ItemKind::Solid(_) => Ok(LayerSource::Solid { item }),
+        ItemKind::Folder => Err(bad(CMD, "folders can't be layer sources")),
+    }
+}
+
+/// Whether a source brings audio properties (precompositions always can; footage when it has an
+/// audio stream).
+fn source_has_audio(project: &Project, source: &LayerSource) -> bool {
+    match source {
+        LayerSource::Comp { .. } => true,
+        LayerSource::Footage { item } => project.item(*item).is_some_and(|i| matches!(&i.kind, ItemKind::Footage(f) if f.has_audio)),
+        _ => false,
+    }
+}
+
+pub(super) fn has_replace_source(s: &Session) -> std::result::Result<(), String> {
+    has_comp(s)?;
+    let c = s.active_comp().ok_or("no composition")?;
+    if !s.state.selected_layers.iter().filter_map(|l| c.layer(*l)).any(replaceable_layer) {
+        return Err("select a footage, composition or solid layer".into());
+    }
+    if s.state.project_selection.is_empty() {
+        return Err("select a footage item, a composition or a solid in the Project panel".into());
+    }
+    Ok(())
+}
+
+/// Replace the source of the selected (or `layers`) AV layers with a Project item, as After
+/// Effects' Alt-drag and Ctrl+Alt+/ do. The layer keeps every property: name, timing, transforms,
+/// keyframes, expressions, effects, masks, switches, parenting and track matte. Only its source
+/// changes; precompositions bring their Essential Properties group through `sync_project`, and a
+/// source with audio adds an Audio group when the layer has none.
+pub(super) fn replace_source(s: &mut Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "layer.replaceSource";
+    let (cid, ids) = layers_p(s, p)?;
+    let ids = unlocked(s, cid, ids, CMD)?;
+    if ids.is_empty() {
+        return Err(bad(CMD, "select a layer first"));
+    }
+    let item = match p.get("item") {
+        Some(Value::Number(n)) => ItemId(n.as_u64().ok_or_else(|| bad(CMD, "item: a project item id"))?),
+        Some(Value::String(name)) => s.project.find_by_name(name).map(|i| i.id).ok_or_else(|| bad(CMD, format!("no item `{name}`")))?,
+        _ => *s.state.project_selection.first().ok_or_else(|| bad(CMD, "select a footage item, a composition or a solid in the Project panel"))?,
+    };
+    let it = s.project.item(item).ok_or_else(|| bad(CMD, format!("no item {}", item.0)))?;
+    let source = replacement_source(item, it)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    for lid in &ids {
+        let l = comp.layer(*lid).ok_or_else(|| bad(CMD, "no such layer"))?;
+        if !replaceable_layer(l) {
+            return Err(bad(CMD, format!("“{}” has no source item to replace", l.name)));
+        }
+    }
+    if let LayerSource::Comp { item: new } = &source
+        && s.project.comp_contains(*new, cid)
+    {
+        return Err(bad(CMD, "a composition can't contain itself"));
+    }
+    let has_audio = source_has_audio(&s.project, &source);
+    let source_for_edit = source.clone();
+    s.edit("Replace Layer Source", None, |proj, _| {
+        for lid in &ids {
+            let needs_audio = has_audio && proj.comp(cid).and_then(|c| c.layer(*lid)).is_some_and(|l| l.props.sub("audio").is_none());
+            let audio = if needs_audio {
+                let mut next = Ids(&mut proj.next_id);
+                Some(build::audio(&mut next))
+            } else {
+                None
+            };
+            let l = layer_mut(proj, cid, *lid)?;
+            l.source = source_for_edit.clone();
+            if let Some(audio) = audio {
+                l.props.children.push(audio.into());
+            }
+        }
+        Ok(())
+    })?;
+    Ok(json!({"layers": ids.iter().map(|l| l.0).collect::<Vec<_>>(), "item": item.0}))
+}
diff --git a/crates/engine/src/cmd/layer/select.rs b/crates/engine/src/cmd/layer/select.rs
new file mode 100644
index 000000000..efe038a0a
--- /dev/null
+++ b/crates/engine/src/cmd/layer/select.rs
@@ -0,0 +1,79 @@
+use super::{EngineError, LayerId, Result, Session, Value, b_p, comp_id, json, resolve_layer};
+
+pub(super) fn select(s: &mut Session, p: &Value) -> Result<Value> {
+    let cid = comp_id(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let ids: Vec<LayerId> = match p.get("layers").or(p.get("layer")) {
+        Some(Value::Array(a)) => a.iter().filter_map(|v| resolve_layer(comp, v)).collect(),
+        Some(v) => resolve_layer(comp, v).into_iter().collect(),
+        None => vec![],
+    };
+    let add = b_p(p, "add").unwrap_or(false);
+    let toggle = b_p(p, "toggle").unwrap_or(false);
+    if toggle {
+        for id in ids {
+            if let Some(i) = s.state.selected_layers.iter().position(|l| *l == id) {
+                s.state.selected_layers.remove(i);
+            } else {
+                s.state.selected_layers.push(id);
+            }
+        }
+    } else if add {
+        for id in ids {
+            if !s.state.selected_layers.contains(&id) {
+                s.state.selected_layers.push(id);
+            }
+        }
+    } else {
+        select_only(&mut s.state, ids);
+    }
+    Ok(json!(s.state.selected_layers.iter().map(|l| l.0).collect::<Vec<_>>()))
+}
+
+/// Make `ids` the whole layer selection, as a plain click on them does: no property or keyframe
+/// stays selected, and mask vertices stay selected only on layers that are still selected.
+pub(crate) fn select_only(st: &mut crate::EditorState, ids: Vec<LayerId>) {
+    st.selected_layers = ids;
+    st.selected_props.clear();
+    st.selected_keys.clear();
+    let keep = st.selected_layers.clone();
+    st.selected_vertices.retain(|v| keep.contains(&v.layer));
+}
+
+pub(super) fn select_step(s: &mut Session, p: &Value, dir: i64) -> Result<Value> {
+    let comp = s.active_comp().ok_or(EngineError::NoComp)?;
+    if comp.layers.is_empty() {
+        return Ok(Value::Null);
+    }
+    let cur = s.state.selected_layers.first().and_then(|id| comp.layers.iter().position(|l| l.id == *id));
+    let n = comp.layers.len() as i64;
+    // The next layer that can be selected (locked and hidden shy layers are stepped over); at
+    // the end of the stack the selection stays.
+    let start = match cur {
+        Some(i) => i as i64 + dir,
+        None if dir > 0 => 0,
+        None => n - 1,
+    };
+    let next = std::iter::successors(Some(start), |i| Some(i + dir))
+        .take_while(|i| (0..n).contains(i))
+        .find(|i| crate::cmd::selectable(comp, &comp.layers[*i as usize]));
+    let Some(i) = next.or(cur.map(|i| i as i64)) else { return Ok(Value::Null) };
+    let id = comp.layers[i as usize].id;
+    let add = b_p(p, "add").unwrap_or(false);
+    if add {
+        if !s.state.selected_layers.contains(&id) {
+            s.state.selected_layers.insert(0, id);
+        }
+    } else {
+        s.state.selected_layers = vec![id];
+    }
+    Ok(json!(id.0))
+}
+
+pub(super) fn select_next(s: &mut Session, p: &Value) -> Result<Value> {
+    select_step(s, p, 1)
+}
+
+pub(super) fn select_prev(s: &mut Session, p: &Value) -> Result<Value> {
+    select_step(s, p, -1)
+}
diff --git a/crates/engine/src/cmd/layer/switches.rs b/crates/engine/src/cmd/layer/switches.rs
new file mode 100644
index 000000000..366c1eeb1
--- /dev/null
+++ b/crates/engine/src/cmd/layer/switches.rs
@@ -0,0 +1,302 @@
+use super::{
+    BlendMode, EngineError, FrameBlend, ItemId, KV, Layer, LayerId, MatteKind, Quality, Result, Session, TrackMatte, Value, b_p, bad, json, layer_mut, layer_p,
+    layers_p, merge_p, resolve_layer, str_p, unlocked,
+};
+
+pub(super) fn set_switch(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, ids) = layers_p(s, p)?;
+    let name = str_p(p, "switch").ok_or_else(|| bad("layer.setSwitch", "missing `switch`"))?.to_string();
+    let v = b_p(p, "value");
+    let label = format!("Layer Switch ({name})");
+    if b_p(p, "others") == Some(true) {
+        return set_switch_others(s, cid, &ids, &name, v, &label);
+    }
+    // `merge`: a switch dragged over several layers in the Timeline is one undo step.
+    let r = s.edit(&label, merge_p(p), |proj, _| {
+        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        let mut last = false;
+        // Toggle relative to the first layer so a multi-selection ends up consistent.
+        let first = comp.layers.iter().find(|l| ids.contains(&l.id)).map(|l| switch_value(l, &name)).unwrap_or(Some(false));
+        let Some(first) = first else { return Err(bad("layer.setSwitch", format!("unknown switch `{name}`"))) };
+        let target = v.unwrap_or(!first);
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
+            set_switch_value(l, &name, target);
+            last = target;
+        }
+        Ok(last)
+    })?;
+    Ok(json!(r))
+}
+
+/// `layer.setSwitch {others: true}` (Alt-click on an A/V feature in the Timeline): the named
+/// layers stand alone, shown / heard / soloed / unlocked while every other layer the switch
+/// applies to is the opposite; when they already do, the other layers come back. `value` sets
+/// the other layers directly.
+fn set_switch_others(s: &mut Session, cid: ItemId, ids: &[LayerId], name: &str, value: Option<bool>, label: &str) -> Result<Value> {
+    let r = s.edit(label, None, |proj, _| {
+        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        // The state that sets a layer apart: unlocked for Lock, on for the rest.
+        let active = !matches!(name, "lock" | "locked");
+        // Track mattes keep their video off by design.
+        let mattes: Vec<LayerId> =
+            if matches!(name, "video" | "eye") { comp.layers.iter().filter_map(|l| l.track_matte.map(|m| m.layer)).collect() } else { Vec::new() };
+        let applies = |l: &Layer| match name {
+            "audio" => l.props.sub("audio").is_some(),
+            "lock" | "locked" => true,
+            // Every layer has a Video switch (it hides a null's outline in the viewer and turns a
+            // camera or light off), as the Timeline's eye cell shows; track mattes keep theirs off
+            // by design.
+            "video" | "eye" => !mattes.contains(&l.id),
+            _ => l.source.is_av() && !mattes.contains(&l.id),
+        };
+        let mut alone = true;
+        for l in comp.layers.iter().filter(|l| applies(l)) {
+            let Some(on) = switch_value(l, name) else { return Err(bad("layer.setSwitch", format!("unknown switch `{name}`"))) };
+            alone &= on == (ids.contains(&l.id) == active);
+        }
+        let others = value.unwrap_or(alone == active);
+        for l in comp.layers.iter_mut_where(|l| applies(l)) {
+            let v = if ids.contains(&l.id) { active } else { others };
+            set_switch_value(l, name, v);
+        }
+        Ok(others)
+    })?;
+    Ok(json!(r))
+}
+
+fn switch_value(l: &Layer, name: &str) -> Option<bool> {
+    let sw = &l.switches;
+    Some(match name {
+        "video" | "eye" => sw.video,
+        "audio" => sw.audio,
+        "solo" => sw.solo,
+        "lock" | "locked" => sw.locked,
+        "shy" => sw.shy,
+        "collapse" => sw.collapse,
+        "quality" => sw.quality == Quality::Best,
+        "fx" | "effects" => sw.effects,
+        "frameBlend" => sw.frame_blend != FrameBlend::Off,
+        "motionBlur" => sw.motion_blur,
+        "adjustment" => sw.adjustment,
+        "threeD" | "3d" | "3D" => sw.three_d,
+        "guide" => sw.guide,
+        "preserveTransparency" => l.preserve_transparency,
+        _ => return None,
+    })
+}
+
+fn set_switch_value(l: &mut Layer, name: &str, v: bool) {
+    let sw = &mut l.switches;
+    match name {
+        "video" | "eye" => sw.video = v,
+        "audio" => sw.audio = v,
+        "solo" => sw.solo = v,
+        "lock" | "locked" => sw.locked = v,
+        "shy" => sw.shy = v,
+        "collapse" => sw.collapse = v,
+        "quality" => sw.quality = if v { Quality::Best } else { Quality::Draft },
+        "fx" | "effects" => sw.effects = v,
+        "frameBlend" => sw.frame_blend = if v { FrameBlend::FrameMix } else { FrameBlend::Off },
+        "motionBlur" => sw.motion_blur = v,
+        "adjustment" => sw.adjustment = v,
+        "threeD" | "3d" | "3D" => {
+            if sw.three_d && !v {
+                drop_3d_values(l);
+            }
+            l.switches.three_d = v;
+        }
+        "guide" => sw.guide = v,
+        "preserveTransparency" => l.preserve_transparency = v,
+        _ => {}
+    }
+}
+
+/// Turning the 3D switch off discards Z values, Orientation and X/Y Rotation (as in AE).
+fn drop_3d_values(l: &mut Layer) {
+    let Some(tr) = l.transform_mut() else { return };
+    for (m, keep) in [("position", 0.0), ("anchor", 0.0), ("scale", 100.0)] {
+        if let Some(pr) = tr.get_mut(m) {
+            let flat = |v: &mut KV| {
+                if let KV::Vec3(a) = v {
+                    a[2] = keep;
+                }
+            };
+            flat(&mut pr.value);
+            for k in &mut pr.keys {
+                flat(&mut k.value);
+            }
+        }
+    }
+    for (m, zero) in [("orientation", KV::Vec3([0.0; 3])), ("rotationX", KV::Scalar(0.0)), ("rotationY", KV::Scalar(0.0))] {
+        if let Some(pr) = tr.get_mut(m) {
+            pr.keys.clear();
+            pr.expr = None;
+            pr.value = zero;
+        }
+    }
+}
+
+pub(super) fn rename(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, lid) = layer_p(s, p, "layer.rename")?;
+    let name = str_p(p, "name").ok_or_else(|| bad("layer.rename", "missing `name`"))?.to_string();
+    s.edit("Rename Layer", None, |proj, _| {
+        layer_mut(proj, cid, lid)?.name = name.clone();
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+/// The Timeline's Comment column.
+pub(super) fn set_comment(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, ids) = layers_p(s, p)?;
+    let text = str_p(p, "comment").ok_or_else(|| bad("layer.setComment", "missing `comment`"))?.to_string();
+    s.edit("Layer Comment", None, |proj, _| {
+        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
+            l.comment = text.clone();
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+pub(super) fn blend(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, ids) = layers_p(s, p)?;
+    let mode = str_p(p, "mode").and_then(BlendMode::from_name);
+    let step = p.get("step").and_then(Value::as_i64).unwrap_or(0);
+    if mode.is_none() && step == 0 {
+        return Err(bad("layer.setBlendMode", "need `mode` (e.g. Multiply) or `step` ±1"));
+    }
+    s.edit("Blending Mode", None, |proj, _| {
+        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
+            l.blend_mode = match mode {
+                Some(m) => m,
+                None if step > 0 => l.blend_mode.next(),
+                None => l.blend_mode.previous(),
+            };
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+/// `layer.setTrackMatte`: `layers` (or `layer`, else the first selected layer; locked ones left
+/// as they are) use `matte` as their track matte (none when null), in one undo step. `kind` sets the mode; `preserve` keeps
+/// each layer's own (Alpha for a layer without a matte), so changing the matte of several layers
+/// at once keeps their modes.
+pub(super) fn track_matte(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, ids) = match p.get("layers") {
+        Some(_) => layers_p(s, p)?,
+        None => layer_p(s, p, "layer.setTrackMatte").map(|(c, l)| (c, vec![l]))?,
+    };
+    // Locked layers keep their matte (several at once: the others get it).
+    let ids = unlocked(s, cid, ids, "layer.setTrackMatte")?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let matte = match p.get("matte") {
+        None | Some(Value::Null) => None,
+        Some(v) => Some(resolve_layer(comp, v).ok_or_else(|| bad("layer.setTrackMatte", "no such matte layer"))?),
+    };
+    if ids.is_empty() {
+        return Err(bad("layer.setTrackMatte", "no layers"));
+    }
+    if matte.is_some_and(|m| ids.contains(&m)) {
+        return Err(bad("layer.setTrackMatte", "a layer can't be its own matte"));
+    }
+    // None: each layer keeps its own mode.
+    let kind = match str_p(p, "kind").map(|k| k.to_ascii_lowercase().replace([' ', '_', '-'], "")) {
+        Some(k) if k == "preserve" => None,
+        Some(k) => Some(match k.as_str() {
+            "alphainverted" | "alphainv" => MatteKind::AlphaInverted,
+            "luma" => MatteKind::Luma,
+            "lumainverted" | "lumainv" => MatteKind::LumaInverted,
+            _ => MatteKind::Alpha,
+        }),
+        None => Some(MatteKind::Alpha),
+    };
+    s.edit("Track Matte", None, |proj, _| {
+        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        if let Some(ml) = matte.and_then(|m| comp.layer_mut(m)) {
+            ml.switches.video = false;
+        }
+        for lid in &ids {
+            let l = comp.layer_mut(*lid).ok_or(EngineError::NoComp)?;
+            let kind = kind.unwrap_or_else(|| l.track_matte.map(|m| m.kind).unwrap_or_default());
+            l.track_matte = matte.map(|layer| TrackMatte { layer, kind });
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+#[cfg(test)]
+mod track_matte_batch_tests {
+    use super::*;
+    use std::sync::Arc;
+
+    fn matte_of(s: &Session, id: u64) -> Option<(u64, MatteKind)> {
+        s.active_comp().unwrap().layer(LayerId(id)).unwrap().track_matte.map(|m| (m.layer.0, m.kind))
+    }
+
+    /// #1260: several layers take one matte layer at once, in one undo step; `kind: "preserve"`
+    /// keeps each one's mode; refused calls change nothing; one `layer` still works.
+    #[test]
+    fn several_layers_take_one_matte_and_keep_their_modes() {
+        let mut s = Session::default();
+        s.execute("comp.new", json!({"name":"Mattes","width":16,"height":16,"duration":1})).unwrap();
+        let [a, b, c, x, y] = ["A", "B", "C", "X", "Y"].map(|n| s.execute("layer.newSolid", json!({"name": n})).unwrap()["layer"].as_u64().unwrap());
+        s.execute("layer.setTrackMatte", json!({"layer": a, "matte": x, "kind": "luma"})).unwrap();
+        s.execute("layer.setTrackMatte", json!({"layer": b, "matte": x})).unwrap();
+        assert_eq!((matte_of(&s, a), matte_of(&s, b)), (Some((x, MatteKind::Luma)), Some((x, MatteKind::Alpha))), "one layer, as before");
+        let (before, undo) = (s.project.clone(), s.history.undo.len());
+        s.execute("layer.setTrackMatte", json!({"layers": [a, b, c], "matte": y, "kind": "preserve"})).unwrap();
+        assert_eq!(
+            [matte_of(&s, a), matte_of(&s, b), matte_of(&s, c)],
+            [Some((y, MatteKind::Luma)), Some((y, MatteKind::Alpha)), Some((y, MatteKind::Alpha))],
+            "each keeps its mode (Alpha without one)"
+        );
+        assert!(!s.active_comp().unwrap().layer(LayerId(y)).unwrap().switches.video, "the matte is hidden");
+        assert_eq!(s.history.undo.len(), undo + 1, "one undo step");
+        s.execute("edit.undo", json!({})).unwrap();
+        assert!(s.project.same_content(&before));
+        // Refused: a layer as its own matte, an unknown layer, no layers. Nothing changes.
+        for p in [
+            json!({"layers": [a, y], "matte": y}),
+            json!({"layers": [a, 9999], "matte": y}),
+            json!({"layers": [], "matte": y}),
+            json!({"layers": [a], "matte": 9999}),
+        ] {
+            let (project, revision) = (s.project.clone(), s.revision);
+            assert!(s.execute("layer.setTrackMatte", p.clone()).is_err(), "{p}");
+            assert!(Arc::ptr_eq(&project, &s.project) && s.revision == revision, "{p} changed nothing");
+        }
+        s.execute("layer.setTrackMatte", json!({"layers": [a, b], "matte": null})).unwrap();
+        assert_eq!((matte_of(&s, a), matte_of(&s, b)), (None, None), "both lose it");
+    }
+
+    /// Locked layers keep their parent and matte when they are among several (the others change),
+    /// and alone they are an error that changes nothing.
+    #[test]
+    fn locked_layers_keep_their_parent_and_matte() {
+        let mut s = Session::default();
+        s.execute("comp.new", json!({"name":"Locks","width":16,"height":16,"duration":1})).unwrap();
+        let [a, b, p, m] = ["A", "B", "P", "M"].map(|n| s.execute("layer.newSolid", json!({"name": n})).unwrap()["layer"].as_u64().unwrap());
+        s.execute("layer.setSwitch", json!({"layers": [b], "switch": "lock", "value": true})).unwrap();
+        let layer = |s: &Session, id: u64| s.active_comp().unwrap().layer(LayerId(id)).unwrap().clone();
+        s.execute("layer.setParent", json!({"layers": [a, b], "parent": p})).unwrap();
+        s.execute("layer.setTrackMatte", json!({"layers": [a, b], "matte": m, "kind": "preserve"})).unwrap();
+        s.execute("layer.trackMatte", json!({"layers": [a, b], "op": "luma"})).unwrap();
+        assert_eq!((layer(&s, a).parent, matte_of(&s, a)), (Some(LayerId(p)), Some((m, MatteKind::Luma))));
+        assert_eq!((layer(&s, b).parent, matte_of(&s, b)), (None, None), "the locked layer is left as it was");
+        for (cmd, p) in [
+            ("layer.setParent", json!({"layers": [b], "parent": p})),
+            ("layer.setTrackMatte", json!({"layers": [b], "matte": m})),
+            ("layer.trackMatte", json!({"layers": [b], "op": "alpha"})),
+        ] {
+            let (project, revision) = (s.project.clone(), s.revision);
+            let err = s.execute(cmd, p).unwrap_err();
+            assert!(err.to_string().contains("is locked"), "{cmd}: {err}");
+            assert!(Arc::ptr_eq(&project, &s.project) && s.revision == revision, "{cmd} changed nothing");
+        }
+    }
+}
diff --git a/crates/engine/src/cmd/layer/timing.rs b/crates/engine/src/cmd/layer/timing.rs
new file mode 100644
index 000000000..650544d17
--- /dev/null
+++ b/crates/engine/src/cmd/layer/timing.rs
@@ -0,0 +1,292 @@
+use super::{
+    EngineError, ItemKind, Label, Layer, LayerId, LayerSource, Result, Session, Tick, Value, b_p, bad, build, f_p, json, layer_mut, layers_p, merge_p,
+    resolve_layer, str_p, unlocked, with,
+};
+
+pub(super) fn timing(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, ids) = layers_p(s, p)?;
+    let t = s.time();
+    let op = str_p(p, "op").unwrap_or("set").to_string();
+    // Layer times stay on frame boundaries of the comp (as in AE).
+    let fr = s.project.comp(cid).ok_or(EngineError::NoComp)?.frame_rate;
+    let snap = |k: &str| f_p(p, k).map(|v| fr.snap_nearest(Tick::from_seconds_f64(v)));
+    let (delta, start, inp, outp) = (snap("delta"), snap("start"), snap("in"), snap("out"));
+    // Relative trims: each layer moves its own in/out point by the same amount, so dragging an
+    // edge of several selected layers trims them all together (as in AE).
+    let (in_delta, out_delta) = (snap("inDelta"), snap("outDelta"));
+    s.edit("Layer Timing", merge_p(p), |proj, _| {
+        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        let fd = comp.frame_duration();
+        let comp_dur = comp.duration;
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
+            let shift = |l: &mut Layer, d: Tick| {
+                l.start_time += d;
+                l.in_point += d;
+                l.out_point += d;
+            };
+            match op.as_str() {
+                "moveInToTime" => {
+                    let d = t - l.in_point;
+                    shift(l, d);
+                }
+                "moveOutToTime" => {
+                    let d = t - l.out_point;
+                    shift(l, d);
+                }
+                "moveInToStart" => {
+                    let d = Tick::ZERO - l.in_point;
+                    shift(l, d);
+                }
+                "moveOutToEnd" => {
+                    let d = comp_dur - l.out_point;
+                    shift(l, d);
+                }
+                "trimInToTime" => l.in_point = t.min(l.out_point - fd),
+                // Alt+]: the Out edge lands one frame after the playhead, so its frame stays the
+                // layer's last visible one (as in After Effects), never before the In point.
+                "trimOutToTime" => l.out_point = t.max(l.in_point) + fd,
+                _ => {
+                    if let Some(d) = delta {
+                        shift(l, d);
+                    }
+                    if let Some(st) = start {
+                        let d = st - l.start_time;
+                        shift(l, d);
+                    }
+                    if let Some(i) = inp {
+                        l.in_point = i.min(l.out_point - fd);
+                    }
+                    if let Some(o) = outp {
+                        l.out_point = o.max(l.in_point + fd);
+                    }
+                    // Stops at the comp start/end (a point already past it doesn't jump onto
+                    // it), keeping at least one frame of layer.
+                    if let Some(d) = in_delta {
+                        l.in_point = (l.in_point + d).max(Tick::ZERO.min(l.in_point)).min(l.out_point - fd);
+                    }
+                    if let Some(d) = out_delta {
+                        l.out_point = (l.out_point + d).min(comp_dur.max(l.out_point)).max(l.in_point + fd);
+                    }
+                }
+            }
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+/// Move the layers `frames` frames in time (Alt+Page Up / Page Down, with Shift ten frames).
+pub(super) fn move_frames(s: &mut Session, p: &Value, frames: i64) -> Result<Value> {
+    let (cid, _) = layers_p(s, p)?;
+    let delta = s.project.comp(cid).ok_or(EngineError::NoComp)?.frame_rate.tick_of(frames).seconds();
+    timing(s, &with(p, "delta", json!(delta)))
+}
+
+/// Slip edit: move a layer's source (footage or precomp) under its fixed in and out points, like
+/// dragging the source-duration bar in After Effects. `delta` in seconds or `frames`; positive
+/// moves the source later. Clamped so the source still covers the in–out span: the result gives
+/// the `requested` shift and, per layer, the `delta` applied and whether it was `clamped` (#2371).
+/// Keyframes and layer markers are in layer time, so they travel with the source.
+pub(super) fn slip(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, ids) = layers_p(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let fr = comp.frame_rate;
+    let delta = match (p.get("frames").and_then(Value::as_i64), f_p(p, "delta")) {
+        (Some(f), _) => fr.tick_of(f),
+        (None, Some(d)) => fr.snap_nearest(Tick::from_seconds_f64(d)),
+        _ => return Err(bad("layer.slip", "delta (seconds) or frames required")),
+    };
+    // Allowed shift per layer: the source span [lo, hi] in comp time must keep covering in..out.
+    let mut shifts: Vec<(LayerId, Tick)> = Vec::new();
+    for l in comp.layers.iter().filter(|l| ids.contains(&l.id)) {
+        if l.props.get("timeRemap").is_some() {
+            continue;
+        }
+        let dur = match &l.source {
+            LayerSource::Footage { item } => match s.project.item(*item).map(|i| &i.kind) {
+                Some(ItemKind::Footage(f)) if f.kind != effectcraft_project::FootageKind::Still => Some(f.looped_duration()),
+                _ => None,
+            },
+            LayerSource::Comp { item } => s.project.comp(*item).map(|c| c.duration),
+            _ => None,
+        };
+        let Some(dur) = dur else { continue };
+        let (a, b) = (l.comp_time(Tick::ZERO), l.comp_time(dur));
+        let (lo, hi) = (a.min(b), a.max(b));
+        let (min_d, max_d) = (l.out_point - hi, l.in_point - lo);
+        if min_d > max_d {
+            continue;
+        }
+        shifts.push((l.id, delta.max(min_d).min(max_d)));
+    }
+    if shifts.is_empty() {
+        return Err(bad("layer.slip", "select a footage or precomp layer (without time remapping)"));
+    }
+    s.edit("Slip Edit", merge_p(p), |proj, _| {
+        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        for (id, d) in &shifts {
+            if let Some(l) = comp.layer_mut(*id) {
+                l.start_time += *d;
+            }
+        }
+        Ok(())
+    })?;
+    Ok(json!({
+        "requested": delta.seconds(),
+        "slipped": shifts.iter().map(|(id, d)| json!({"layer": id.0, "delta": d.seconds(), "clamped": *d != delta})).collect::<Vec<_>>(),
+    }))
+}
+
+pub(super) fn arrange(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, ids) = layers_p(s, p)?;
+    let ids = unlocked(s, cid, ids, "layer.arrange")?;
+    let how = str_p(p, "to").unwrap_or("front").to_string();
+    let index = p.get("index").and_then(Value::as_u64).map(|i| i as usize);
+    // `above`: put the layers right above that one (the timeline's drag to reorder).
+    let above = match p.get("above") {
+        Some(v) => {
+            let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+            let a = resolve_layer(comp, v).ok_or_else(|| bad("layer.arrange", "no such layer for `above`"))?;
+            if ids.contains(&a) {
+                return Err(bad("layer.arrange", "`above` must be a layer that isn't being moved"));
+            }
+            Some(a)
+        }
+        None => None,
+    };
+    s.edit("Arrange Layers", None, |proj, _| {
+        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        // Bring Forward / Send Backward move each layer one step past the next layer that isn't
+        // moving (a run of selected layers moves as one; one already at the end stays).
+        if above.is_none() && index.is_none() && matches!(how.as_str(), "forward" | "backward") {
+            let picked = |l: &Layer| ids.contains(&l.id);
+            let n = comp.layers.len();
+            if how == "forward" {
+                for i in 1..n {
+                    if picked(&comp.layers[i]) && !picked(&comp.layers[i - 1]) {
+                        let run_end = (i..n).find(|j| !picked(&comp.layers[*j])).unwrap_or(n);
+                        comp.layers.rotate_range_left(i - 1..run_end, 1);
+                    }
+                }
+            } else {
+                for i in (0..n.saturating_sub(1)).rev() {
+                    if picked(&comp.layers[i]) && !picked(&comp.layers[i + 1]) {
+                        let run_start = (0..=i).rev().find(|j| !picked(&comp.layers[*j])).map_or(0, |j| j + 1);
+                        comp.layers.rotate_range_right(run_start..=i + 1, 1);
+                    }
+                }
+            }
+            return Ok(());
+        }
+        let mut picked: Vec<Layer> = Vec::new();
+        comp.layers.retain(|l| {
+            if ids.contains(&l.id) {
+                picked.push(l.clone());
+                false
+            } else {
+                true
+            }
+        });
+        let at = match (how.as_str(), index) {
+            _ if above.is_some() => comp.layers.iter().position(|l| Some(l.id) == above).unwrap_or(comp.layers.len()),
+            (_, Some(i)) => i.saturating_sub(1).min(comp.layers.len()),
+            ("back", _) => comp.layers.len(),
+            _ => 0,
+        };
+        for (k, l) in picked.into_iter().enumerate() {
+            comp.layers.insert((at + k).min(comp.layers.len()), l);
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+/// Layer ▸ Pre-compose. `mode: move` (default; "Move all attributes into the new composition")
+/// nests the selected layers as they are; `mode: leave` ("Leave all attributes in", one footage,
+/// solid or precomp layer) nests only the layer's source, sized to it, and keeps the layer's
+/// transform, masks, effects and timing in the current comp. `adjustDuration` (move) trims the
+/// new comp to the selected layers' span; `open` opens the new comp.
+pub(super) fn precompose(s: &mut Session, p: &Value) -> Result<Value> {
+    let c = "layer.precompose";
+    let (cid, ids) = layers_p(s, p)?;
+    if ids.is_empty() {
+        return Err(bad(c, "no layers"));
+    }
+    let name = str_p(p, "name").unwrap_or("Pre-comp 1").to_string();
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
+    let leave = match str_p(p, "mode").unwrap_or("move") {
+        "move" => false,
+        "leave" => true,
+        x => return Err(bad(c, format!("mode: move|leave, got `{x}`"))),
+    };
+    let adjust = b_p(p, "adjustDuration").unwrap_or(false);
+    if leave {
+        let [lid] = ids[..] else { return Err(bad(c, "\"Leave all attributes\" needs exactly one layer")) };
+        let layer = comp.layer(lid).ok_or(EngineError::NoComp)?.clone();
+        let Some(src_item) = layer.source.item() else {
+            return Err(bad(c, "\"Leave all attributes\" is available for footage, solid and precomp layers only"));
+        };
+        let (w, h) = effectcraft_render::source_size(&s.project, &layer);
+        let (w, h) = if w == 0 || h == 0 { (comp.width, comp.height) } else { (w, h) };
+        let dur = match s.project.item(src_item).map(|i| &i.kind) {
+            Some(ItemKind::Comp(nc)) => nc.duration,
+            Some(ItemKind::Footage(f)) if f.duration > Tick(0) => f.duration,
+            _ => comp.duration,
+        };
+        let new = s.edit("Pre-compose", None, |proj, st| {
+            let mut inner = comp.nested_like(w, h, dur);
+            let mut il = build::layer(proj, &inner, &layer.name, layer.source.clone(), (w, h), Some(dur));
+            il.name = layer.name.clone();
+            inner.layers.push(il);
+            let iid = proj.add_item(&name, Label::Sandstone, None, ItemKind::Comp(inner.into()));
+            let l = layer_mut(proj, cid, lid)?;
+            l.source = LayerSource::Comp { item: iid };
+            l.name = name.clone();
+            st.selected_layers = vec![lid];
+            Ok((iid, lid))
+        })?;
+        if b_p(p, "open").unwrap_or(false) {
+            s.open_comp(new.0);
+        }
+        return Ok(json!({"comp": new.0.0, "layer": new.1.0}));
+    }
+    let span = {
+        let sel: Vec<&effectcraft_project::Layer> = comp.layers.iter().filter(|l| ids.contains(&l.id)).collect();
+        let a = sel.iter().map(|l| l.in_point).min().unwrap_or(Tick(0)).max(Tick(0));
+        let b = sel.iter().map(|l| l.out_point).max().unwrap_or(comp.duration).min(comp.duration);
+        (a, b)
+    };
+    let (offset, dur) = if adjust && span.1 > span.0 { (span.0, span.1 - span.0) } else { (Tick(0), comp.duration) };
+    let new = s.edit("Pre-compose", None, |proj, st| {
+        let mut inner = comp.nested_like(comp.width, comp.height, dur);
+        inner.layers = comp.layers.iter().filter(|l| ids.contains(&l.id)).cloned().collect();
+        for l in &mut inner.layers {
+            if l.parent.is_some_and(|p| !ids.contains(&p)) {
+                l.parent = None;
+            }
+            if l.track_matte.is_some_and(|m| !ids.contains(&m.layer)) {
+                l.track_matte = None;
+            }
+            l.start_time -= offset;
+            l.in_point -= offset;
+            l.out_point -= offset;
+        }
+        let iid = proj.add_item(&name, Label::Sandstone, None, ItemKind::Comp(inner.into()));
+        let mut l = build::layer(proj, &comp, &name, LayerSource::Comp { item: iid }, (comp.width, comp.height), Some(dur));
+        l.name = name.clone();
+        l.start_time = offset;
+        l.in_point = offset;
+        l.out_point = offset + dur;
+        let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+        let at = c.layers.iter().position(|l| ids.contains(&l.id)).unwrap_or(0);
+        c.layers.retain(|l| !ids.contains(&l.id));
+        let lid = l.id;
+        c.layers.insert(at.min(c.layers.len()), l);
+        st.selected_layers = vec![lid];
+        Ok((iid, lid))
+    })?;
+    if b_p(p, "open").unwrap_or(false) {
+        s.open_comp(new.0);
+    }
+    Ok(json!({"comp": new.0.0, "layer": new.1.0}))
+}
diff --git a/crates/engine/src/cmd/layer/transform.rs b/crates/engine/src/cmd/layer/transform.rs
new file mode 100644
index 000000000..eb0f610f9
--- /dev/null
+++ b/crates/engine/src/cmd/layer/transform.rs
@@ -0,0 +1,223 @@
+use super::create::{color_p, pixel_aspect_p};
+use super::{
+    EngineError, ItemKind, KV, LayerId, LayerSource, PropGroup, Result, Session, Tick, Value, bad, has_layers, json, layer_mut, layer_p, layers_p, limits,
+    str_p, unlocked,
+};
+
+/// Move Position by `(dx, dy)`, including every key. Separated dimensions move X and Y as well
+/// as the combined property the channels were split from.
+pub(crate) fn offset_position(tr: &mut PropGroup, dx: f64, dy: f64) {
+    if dx == 0.0 && dy == 0.0 {
+        return;
+    }
+    if tr.get("positionX").is_some() {
+        for (name, d) in [("positionX", dx), ("positionY", dy)] {
+            if let Some(pr) = tr.get_mut(name) {
+                pr.value = KV::Scalar(pr.value.as_f64() + d);
+                for k in &mut pr.keys {
+                    k.value = KV::Scalar(k.value.as_f64() + d);
+                }
+            }
+        }
+    }
+    if let Some(pr) = tr.get_mut("position") {
+        let shift = |v: &KV| match v {
+            KV::Vec2(a) => KV::Vec2([a[0] + dx, a[1] + dy]),
+            other => {
+                let a = other.as_vec3();
+                KV::Vec3([a[0] + dx, a[1] + dy, a[2]])
+            }
+        };
+        pr.value = shift(&pr.value);
+        for k in &mut pr.keys {
+            k.value = shift(&k.value);
+        }
+    }
+}
+
+/// Set a layer's Position at layer time `lt` to `f(current)`: X/Y/Z Position when its dimensions
+/// are separated.
+pub(crate) fn update_position(tr: &mut PropGroup, lt: Tick, f: impl Fn([f64; 3]) -> [f64; 3]) {
+    const SEPARATE: [&str; 3] = ["positionX", "positionY", "positionZ"];
+    if tr.get("positionX").is_some() {
+        let v = f(SEPARATE.map(|m| tr.get(m).map(|p| p.value_at(lt).as_f64()).unwrap_or(0.0)));
+        for (m, x) in SEPARATE.iter().zip(v) {
+            if let Some(pr) = tr.get_mut(m) {
+                pr.set_value_at(lt, KV::Scalar(x));
+            }
+        }
+    } else if let Some(pr) = tr.get_mut("position") {
+        let v = f(pr.value_at(lt).as_vec3());
+        pr.set_value_at(lt, KV::Vec3(v));
+    }
+}
+
+/// A Transform property's default (Reset) by match id: the anchor at the centre of the source
+/// (`w`×`h`), the position at the comp's (`cw`×`ch`), 100% scale and opacity, no rotation.
+pub(crate) fn transform_default(m: &str, (w, h): (f64, f64), (cw, ch): (f64, f64)) -> Option<KV> {
+    Some(match m {
+        "anchor" => KV::Vec3([w / 2.0, h / 2.0, 0.0]),
+        "position" => KV::Vec3([cw / 2.0, ch / 2.0, 0.0]),
+        "positionX" => KV::Scalar(cw / 2.0),
+        "positionY" => KV::Scalar(ch / 2.0),
+        "positionZ" | "rotation" | "rotationX" | "rotationY" => KV::Scalar(0.0),
+        "scale" => KV::Vec3([100.0; 3]),
+        "orientation" => KV::Vec3([0.0; 3]),
+        "opacity" => KV::Scalar(100.0),
+        _ => return None,
+    })
+}
+
+pub(super) fn transform_op(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, ids) = layers_p(s, p)?;
+    let ids = unlocked(s, cid, ids, "layer.transform")?;
+    let op = str_p(p, "op").unwrap_or("reset").to_string();
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
+    let t = s.time();
+    // A shape or text layer has no source item, so source_size is (0, 0): the fit ops size it by
+    // its painted bounds at the current time instead, and anchor at the bounds' centre — content
+    // bounds live in layer space, where a shape is centred on the origin and text sits above its
+    // baseline, so (w/2, h/2) would push it off-centre (#2198). Reset and the other ops keep the
+    // source size.
+    let ectx = effectcraft_render::EvalCtx {
+        expr: s.expr.as_deref(),
+        footage: Some(s.footage.as_ref()),
+        ..effectcraft_render::EvalCtx::new(&s.project, cid, &comp, t)
+    };
+    let fitting = matches!(op.as_str(), "fit" | "fitWidth" | "fitHeight");
+    let sizes: Vec<(LayerId, [f64; 2], [f64; 2])> = comp
+        .layers
+        .iter()
+        .filter(|l| ids.contains(&l.id))
+        .map(|l| {
+            let (w, h) = effectcraft_render::source_size(&s.project, l);
+            if fitting && (w == 0 || h == 0) {
+                match effectcraft_render::content_bounds(&ectx, l).filter(|b| b.iter().all(|v| v.is_finite()) && b[2] > b[0] && b[3] > b[1]) {
+                    Some(b) => (l.id, [b[2] - b[0], b[3] - b[1]], [(b[0] + b[2]) / 2.0, (b[1] + b[3]) / 2.0]),
+                    None => (l.id, [0.0; 2], [0.0; 2]),
+                }
+            } else {
+                (l.id, [w as f64, h as f64], [w as f64 / 2.0, h as f64 / 2.0])
+            }
+        })
+        .collect();
+    s.edit("Transform", None, |proj, _| {
+        for (lid, size, anchor) in &sizes {
+            let l = layer_mut(proj, cid, *lid)?;
+            let lt = l.layer_time(t);
+            let (cw, ch) = (comp.width as f64, comp.height as f64);
+            let (w, h) = (size[0], size[1]);
+            let Some(tr) = l.transform_mut() else { continue };
+            let set = |tr: &mut PropGroup, m: &str, v: KV| {
+                if let Some(pr) = tr.get_mut(m) {
+                    pr.set_value_at(lt, v);
+                }
+            };
+            match op.as_str() {
+                "reset" => {
+                    for m in ["anchor", "scale", "rotation", "rotationX", "rotationY", "orientation", "opacity"] {
+                        if let Some(v) = transform_default(m, (w, h), (cw, ch)) {
+                            set(tr, m, v);
+                        }
+                    }
+                    update_position(tr, lt, |_| [cw / 2.0, ch / 2.0, 0.0]);
+                }
+                // Centred in the frame; a 3D layer keeps its depth.
+                "center" => update_position(tr, lt, |p| [cw / 2.0, ch / 2.0, p[2]]),
+                "fit" | "fitWidth" | "fitHeight" if w > 0.0 && h > 0.0 => {
+                    let (sx, sy) = match op.as_str() {
+                        "fitWidth" => (cw / w, cw / w),
+                        "fitHeight" => (ch / h, ch / h),
+                        _ => (cw / w, ch / h),
+                    };
+                    // A tiny shape's bounds can overflow the scale; refuse rather than write infinity.
+                    if !(sx * 100.0).is_finite() || !(sy * 100.0).is_finite() {
+                        return Err(EngineError::Other(format!("layer {} is too small to fit to the composition", lid.0)));
+                    }
+                    let z = |m: &str, d: f64| tr.get(m).map(|p| p.value_at(lt).as_vec3()[2]).unwrap_or(d);
+                    let (sz, az) = (z("scale", 100.0), z("anchor", 0.0));
+                    set(tr, "scale", KV::Vec3([sx * 100.0, sy * 100.0, sz]));
+                    update_position(tr, lt, |p| [cw / 2.0, ch / 2.0, p[2]]);
+                    set(tr, "anchor", KV::Vec3([anchor[0], anchor[1], az]));
+                }
+                "flipH" | "flipV" => {
+                    let cur = tr.get("scale").map(|p| p.value_at(lt).as_vec3()).unwrap_or([100.0; 3]);
+                    let v = if op == "flipH" { [-cur[0], cur[1], cur[2]] } else { [cur[0], -cur[1], cur[2]] };
+                    set(tr, "scale", KV::Vec3(v));
+                }
+                _ => {}
+            }
+        }
+        Ok(())
+    })?;
+    Ok(Value::Null)
+}
+
+/// Layer ▸ Layer Settings: cameras and lights open their own settings; solids (and adjustment
+/// layers, which are solids) edit their Solid Settings. With `affectAll: false`, a solid other
+/// layers also use is copied into a new solid for this layer instead of being changed for all of
+/// them (After Effects' "Affect all layers that use this solid"). `name` renames the layer and
+/// its solid.
+pub(super) fn layer_settings(s: &mut Session, p: &Value) -> Result<Value> {
+    let (cid, lid) = layer_p(s, p, "layer.settings")?;
+    // Cameras and lights open their own settings (Camera Settings / Light Settings).
+    match s.project.comp(cid).and_then(|c| c.layer(lid)).map(|l| l.source.clone()) {
+        Some(LayerSource::Camera) => return s.execute("layer.cameraSettings", with_layer(p, lid)),
+        Some(LayerSource::Light { .. }) => return s.execute("layer.lightSettings", with_layer(p, lid)),
+        _ => {}
+    }
+    let color = color_p(p, "color");
+    let w = p.get("width").and_then(Value::as_u64).map(limits::size);
+    let h = p.get("height").and_then(Value::as_u64).map(limits::size);
+    let pixel_aspect = pixel_aspect_p(p)?;
+    let name = str_p(p, "name").map(str::trim).filter(|n| !n.is_empty()).map(str::to_string);
+    let affect_all = p.get("affectAll").and_then(Value::as_bool).unwrap_or(true);
+    let solid = s.edit("Layer Settings", None, |proj, _| {
+        let src = layer_mut(proj, cid, lid)?.source.clone();
+        if let Some(n) = &name {
+            layer_mut(proj, cid, lid)?.name = n.clone();
+        }
+        let LayerSource::Solid { item } = src else { return Ok(None) };
+        let shared = proj.comps().flat_map(|(_, c)| &c.layers).filter(|l| l.source == src).count() > 1;
+        let target = if shared && !affect_all {
+            // This layer gets its own copy of the solid.
+            let it = proj.item(item).ok_or_else(|| bad("layer.settings", "the layer's solid is missing"))?.clone();
+            let copy = proj.add_item(name.as_deref().unwrap_or(&it.name), it.label, it.parent, it.kind);
+            layer_mut(proj, cid, lid)?.source = LayerSource::Solid { item: copy };
+            copy
+        } else {
+            item
+        };
+        let it = proj.item_mut(target).ok_or_else(|| bad("layer.settings", "the layer's solid is missing"))?;
+        if let Some(n) = &name {
+            it.name = n.clone();
+        }
+        if let ItemKind::Solid(so) = &mut it.kind {
+            so.color = color.unwrap_or(so.color);
+            so.width = w.unwrap_or(so.width);
+            so.height = h.unwrap_or(so.height);
+            so.pixel_aspect = pixel_aspect.unwrap_or(so.pixel_aspect);
+        }
+        Ok(Some(target))
+    })?;
+    Ok(match solid {
+        Some(item) => json!({"layer": lid.0, "solid": item.0}),
+        None => json!({"layer": lid.0}),
+    })
+}
+
+/// Layer Settings applies to solids (and adjustment layers), nulls, cameras and lights.
+pub(super) fn has_layer_settings(s: &Session) -> std::result::Result<(), String> {
+    has_layers(s)?;
+    let l = s.active_comp().zip(s.state.selected_layers.first()).and_then(|(c, l)| c.layer(*l)).ok_or("select a layer first")?;
+    match l.source {
+        LayerSource::Solid { .. } | LayerSource::Null | LayerSource::Camera | LayerSource::Light { .. } => Ok(()),
+        _ => Err("this kind of layer has no settings".into()),
+    }
+}
+
+fn with_layer(p: &Value, lid: LayerId) -> Value {
+    let mut p = if p.is_object() { p.clone() } else { json!({}) };
+    p["layer"] = json!(lid.0);
+    p
+}
diff --git a/crates/engine/src/commands/layer_menu.rs b/crates/engine/src/cmd/layer_menu.rs
similarity index 98%
rename from crates/engine/src/commands/layer_menu.rs
rename to crates/engine/src/cmd/layer_menu.rs
index 33d17bb4f..e0c4efc72 100644
--- a/crates/engine/src/commands/layer_menu.rs
+++ b/crates/engine/src/cmd/layer_menu.rs
@@ -61,7 +61,7 @@ fn quality(s: &mut Session, p: &Value) -> Result<Value> {
         q => return Err(bad("layer.quality", format!("quality must be best|draft|wireframe, not `{q}`"))),
     };
     s.edit("Layer Quality", None, |proj, _| {
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.switches.quality = q;
         }
         Ok(())
@@ -84,7 +84,7 @@ fn sampling(s: &mut Session, p: &Value) -> Result<Value> {
         q => q,
     };
     s.edit("Layer Sampling", None, |proj, _| {
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.switches.sampling = q;
         }
         Ok(())
@@ -101,7 +101,7 @@ fn frame_blending(s: &mut Session, p: &Value) -> Result<Value> {
         m => return Err(bad("layer.frameBlending", format!("mode must be off|frameMix|pixelMotion, not `{m}`"))),
     };
     s.edit("Frame Blending", None, |proj, _| {
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.switches.frame_blend = m;
         }
         Ok(())
@@ -116,7 +116,7 @@ fn hide_other_video(s: &mut Session, p: &Value) -> Result<Value> {
     s.edit("Hide Other Video", None, |proj, _| {
         // Every layer has a Video switch (nulls, cameras and lights included, as the Timeline's
         // eye cell shows): the selection stays shown.
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| !ids.contains(&l.id)) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| !ids.contains(&l.id)) {
             l.switches.video = false;
         }
         Ok(())
@@ -130,7 +130,7 @@ fn show_all_video(s: &mut Session, p: &Value) -> Result<Value> {
         let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
         // Track mattes stay hidden (their video switch is off by design).
         let mattes: Vec<LayerId> = c.layers.iter().filter_map(|l| l.track_matte.map(|m| m.layer)).collect();
-        for l in c.layers.iter_mut().filter(|l| !mattes.contains(&l.id)) {
+        for l in c.layers.iter_mut_where(|l| !mattes.contains(&l.id)) {
             l.switches.video = true;
         }
         Ok(())
@@ -154,7 +154,7 @@ fn expressions(s: &mut Session, p: &Value) -> Result<Value> {
     let on = b_p(p, "enabled").unwrap_or(true);
     let n = s.edit(if on { "Enable Expressions" } else { "Disable Expressions" }, None, |proj, _| {
         let mut n = 0;
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.props.walk_mut(&mut |pr| {
                 if let Some(e) = &mut pr.expr {
                     e.enabled = on;
@@ -586,7 +586,7 @@ fn markers_lock(s: &mut Session, p: &Value) -> Result<Value> {
     let r = s.edit("Lock Markers", None, |proj, _| {
         let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
         let target = v.unwrap_or_else(|| !c.layers.iter().find(|l| ids.contains(&l.id)).is_some_and(|l| l.markers_locked));
-        for l in c.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in c.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             l.markers_locked = target;
         }
         Ok(target)
@@ -597,7 +597,7 @@ fn markers_lock(s: &mut Session, p: &Value) -> Result<Value> {
 fn delete_all_markers(s: &mut Session, p: &Value) -> Result<Value> {
     let (cid, ids) = layers_p(s, p)?;
     s.edit("Delete All Markers", None, |proj, _| {
-        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id) && !l.markers_locked) {
+        for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut_where(|l| ids.contains(&l.id) && !l.markers_locked) {
             l.markers.clear();
         }
         Ok(())
@@ -609,6 +609,7 @@ fn delete_all_markers(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn track_matte_op(s: &mut Session, p: &Value) -> Result<Value> {
     let (cid, ids) = layers_p(s, p)?;
+    let ids = super::unlocked(s, cid, ids, "layer.trackMatte")?;
     let op = str_p(p, "op").ok_or_else(|| bad("layer.trackMatte", "missing `op`"))?.to_string();
     let kind = match op.as_str() {
         "alpha" => Some(MatteKind::Alpha),
diff --git a/crates/engine/src/commands/layer_time.rs b/crates/engine/src/cmd/layer_time.rs
similarity index 96%
rename from crates/engine/src/commands/layer_time.rs
rename to crates/engine/src/cmd/layer_time.rs
index d98bfdea7..4ecf725ec 100644
--- a/crates/engine/src/commands/layer_time.rs
+++ b/crates/engine/src/cmd/layer_time.rs
@@ -34,7 +34,7 @@ fn time_stretch(s: &mut Session, p: &Value) -> Result<Value> {
     let fd = comp_rate.frame_duration();
     s.edit(if reverse { "Time-Reverse Layer" } else { "Time Stretch" }, None, |proj, _| {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             let old = l.stretch;
             if reverse {
                 // Keep the in/out points; play the visible span backwards.
@@ -109,7 +109,7 @@ fn enable_time_remap(s: &mut Session, p: &Value) -> Result<Value> {
         let mut next = proj.next_id;
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
         let mut on = false;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id) && remappable(l)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id) && remappable(l)) {
             let has = l.props.get("timeRemap").is_some();
             let target = want.unwrap_or(!has);
             on |= target;
@@ -185,7 +185,16 @@ fn freeze(s: &mut Session, p: &Value, last: bool) -> Result<Value> {
         return Err(bad("layer.freezeFrame", "freezing needs a footage or composition layer"));
     }
     // What each layer shows now (honouring an existing remap) — evaluated before the edit.
-    let ectx = effectcraft_render::EvalCtx { project: &s.project, comp_id: cid, comp, time: cti, expr: s.expr.as_deref(), footage: Some(s.footage.as_ref()) };
+    let ectx = effectcraft_render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time: cti,
+        expr: s.expr.as_deref(),
+        footage: Some(s.footage.as_ref()),
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let now: Vec<(effectcraft_project::LayerId, f64)> = comp
         .layers
         .iter()
diff --git a/crates/engine/src/commands/link.rs b/crates/engine/src/cmd/link.rs
similarity index 80%
rename from crates/engine/src/commands/link.rs
rename to crates/engine/src/cmd/link.rs
index 2eeb7c5a0..66145f17e 100644
--- a/crates/engine/src/commands/link.rs
+++ b/crates/engine/src/cmd/link.rs
@@ -102,11 +102,39 @@ fn quote(s: &str) -> String {
 
 /// The AE expression reference to property `uid` of `target` as seen from a property of `from`.
 pub(crate) fn reference(comp: &Comp, from: &Layer, target: &Layer, uid: Uid, compact: bool) -> Option<String> {
+    reference_with(comp, from, target, uid, compact, false)
+}
+
+/// [`reference`], with the properties inside an effect selected by their index (`by_index`, an
+/// Alt pick whip in After Effects): `effect("Color Control")(1)` rather than `("Color")`. The
+/// effect keeps its name. An index is the property's place among its group's children, as an
+/// expression's `(1)` reads it: it follows a renamed parameter, not one moved to another place.
+pub(crate) fn reference_with(comp: &Comp, from: &Layer, target: &Layer, uid: Uid, compact: bool, by_index: bool) -> Option<String> {
     let chain = target.props.node_chain(uid)?;
+    // Each node's one-based index among its group's children, and whether it lies inside an
+    // effect (below the effect itself): those are selected by index with `by_index`.
+    let mut parent = &target.props;
+    let mut depth_in_effects: Option<usize> = None;
+    let mut by_number: Vec<Option<usize>> = vec![];
+    for n in &chain {
+        let at = parent.children.iter().position(|c| c.uid() == n.uid()).map(|i| i + 1);
+        by_number.push(at.filter(|_| by_index && depth_in_effects.is_some_and(|d| d >= 1)));
+        depth_in_effects = match depth_in_effects {
+            Some(d) => Some(d + 1),
+            None => (n.match_id() == "effects").then_some(0),
+        };
+        if let Node::Group(g) = n {
+            parent = g;
+        }
+    }
+    let selector = |i: usize, label: &str| match by_number.get(i).copied().flatten() {
+        Some(at) => format!("({at})"),
+        None => format!("({})", quote(label)),
+    };
     let mut parts: Vec<String> = vec![];
     let mut pending: Option<&str> = None;
     let mut in_effect = false;
-    for n in chain {
+    for (i, n) in chain.iter().copied().enumerate() {
         if let Some(f) = pending.take() {
             parts.push(format!("{f}({})", quote(n.name())));
             in_effect |= f == "effect";
@@ -119,7 +147,7 @@ pub(crate) fn reference(comp: &Comp, from: &Layer, target: &Layer, uid: Uid, com
             (Node::Group(_), "transform") if !in_effect => parts.push("transform".into()),
             (Node::Group(_), "text") if !in_effect => parts.push("text".into()),
             (Node::Prop(_), "sourceText") => parts.push("sourceText".into()),
-            _ if in_effect => parts.push(format!("({})", quote(n.name()))),
+            _ if in_effect => parts.push(selector(i, n.name())),
             _ => parts.push(camel(n.name())),
         }
     }
@@ -127,10 +155,9 @@ pub(crate) fn reference(comp: &Comp, from: &Layer, target: &Layer, uid: Uid, com
     let _ = comp;
     if !compact {
         // Match names: language-independent, like After Effects with Compact English off.
-        let chain = target.props.node_chain(uid)?;
         let mut out = if from.id == target.id { "thisLayer".to_string() } else { format!("thisComp.layer({})", quote(&target.name)) };
-        for n in chain {
-            out.push_str(&format!("({})", quote(n.match_id())));
+        for (i, n) in chain.iter().copied().enumerate() {
+            out.push_str(&selector(i, n.match_id()));
         }
         return Some(out);
     }
@@ -161,7 +188,9 @@ fn pick_whip(s: &mut Session, p: &Value) -> Result<Value> {
     let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
     let from = comp.layer(lid).ok_or(EngineError::NoComp)?;
     let target = comp.layer(tl).ok_or(EngineError::NoComp)?;
-    let r = reference(comp, from, target, tu, s.prefs.general.expression_pick_whip_compact).ok_or_else(|| bad("prop.pickWhip", "no such target property"))?;
+    let by_index = b_p(p, "byIndex").unwrap_or(false);
+    let r = reference_with(comp, from, target, tu, s.prefs.general.expression_pick_whip_compact, by_index)
+        .ok_or_else(|| bad("prop.pickWhip", "no such target property"))?;
     let (me, them) = (from.props.find(uid).ok_or(EngineError::NoComp)?, target.props.find(tu).ok_or(EngineError::NoComp)?);
     let (dm, dt) = (dims(from, me), dims(target, them));
     // Dropped on one of the target's values: that dimension (`position[0]`), as in After Effects.
@@ -206,7 +235,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Pick Whip (Link Property)",
             [],
             None,
-            "{layer?, path|prop, target: {layer, path|prop, dimension?}, expression?, range?: [start, end]} → sets an AE reference expression (`dimension`: one of the target's values, `position[0]`; with `expression`: inserts it there, replacing the characters in `range`, default the end)",
+            "{layer?, path|prop, target: {layer, path|prop, dimension?}, expression?, range?: [start, end], byIndex?: bool} → sets an AE reference expression (`dimension`: one of the target's values, `position[0]`; with `expression`: inserts it there, replacing the characters in `range`, default the end; `byIndex`: an effect's properties by their index, `effect(\"Color Control\")(1)`, as an Alt pick whip does)",
             has_layers,
             pick_whip
         ),
diff --git a/crates/engine/src/commands/liquify.rs b/crates/engine/src/cmd/liquify.rs
similarity index 100%
rename from crates/engine/src/commands/liquify.rs
rename to crates/engine/src/cmd/liquify.rs
diff --git a/crates/engine/src/commands/lottie.rs b/crates/engine/src/cmd/lottie.rs
similarity index 96%
rename from crates/engine/src/commands/lottie.rs
rename to crates/engine/src/cmd/lottie.rs
index 03a99b994..288d2e56e 100644
--- a/crates/engine/src/commands/lottie.rs
+++ b/crates/engine/src/cmd/lottie.rs
@@ -8,6 +8,7 @@ use crate::{EngineError, Result, Session, cmd};
 
 fn export_lottie(s: &mut Session, p: &Value) -> Result<Value> {
     let path = str_p(p, "path").ok_or_else(|| bad("file.exportLottie", "missing `path`"))?.to_string();
+    s.refuse_export(&path)?;
     let cid = comp_id(s, p)?;
     let opts = ExportOptions { include_expressions: b_p(p, "includeExpressions").unwrap_or(false), text_as_shapes: b_p(p, "textAsShapes").unwrap_or(false) };
     let services = s.services.clone();
@@ -20,7 +21,7 @@ fn export_lottie(s: &mut Session, p: &Value) -> Result<Value> {
     } else {
         res.to_string_compact().into_bytes()
     };
-    s.services.write_file(&path, &bytes).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+    s.write_output(&path, &bytes)?;
     let n = res.warnings.len();
     s.toast(if n == 0 { format!("Exported Lottie to {path}") } else { format!("Exported Lottie to {path} ({n} warning{})", if n == 1 { "" } else { "s" }) });
     Ok(json!({"path": path, "bytes": bytes.len(), "warnings": res.warnings}))
diff --git a/crates/engine/src/commands/markers.rs b/crates/engine/src/cmd/markers.rs
similarity index 94%
rename from crates/engine/src/commands/markers.rs
rename to crates/engine/src/cmd/markers.rs
index 4c979619e..3530eaa4b 100644
--- a/crates/engine/src/commands/markers.rs
+++ b/crates/engine/src/cmd/markers.rs
@@ -296,8 +296,9 @@ fn convert(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(Value::Null)
 }
 
-/// Layer ▸ Markers ▸ Update Markers From Source: copy a precomp's composition markers onto the
-/// layer (layer time is the nested comp's time), skipping ones already there.
+/// Layer ▸ Markers ▸ Update Markers From Source: copy a precomp's composition markers, or the
+/// markers a footage file carries (a WAV's cue points), onto the layer (layer time is the source's
+/// time), skipping ones already there.
 fn update_from_source(s: &mut Session, p: &Value) -> Result<Value> {
     let (cid, ids) = layers_p(s, p)?;
     let src: Vec<(LayerId, Vec<Marker>)> = {
@@ -307,13 +308,17 @@ fn update_from_source(s: &mut Session, p: &Value) -> Result<Value> {
                 let l = comp.layer(*id)?;
                 match &l.source {
                     LayerSource::Comp { item } => Some((*id, s.project.comp(*item)?.markers.clone())),
+                    LayerSource::Footage { item } => match &s.project.item(*item)?.kind {
+                        effectcraft_project::ItemKind::Footage(f) => Some((*id, f.markers.clone())),
+                        _ => None,
+                    },
                     _ => None,
                 }
             })
             .collect()
     };
     if src.is_empty() {
-        return Err(bad("layer.updateMarkersFromSource", "select a precomposition layer"));
+        return Err(bad("layer.updateMarkersFromSource", "select a precomposition or footage layer"));
     }
     let n = s.edit("Update Markers From Source", None, |proj, _| {
         let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
@@ -323,8 +328,11 @@ fn update_from_source(s: &mut Session, p: &Value) -> Result<Value> {
             if l.markers_locked {
                 continue;
             }
+            // One set of the times already on the layer: a file with thousands of markers must not
+            // scan the layer's list for each of them.
+            let mut times: std::collections::HashSet<_> = l.markers.iter().map(|x| x.time).collect();
             for m in ms {
-                if !l.markers.iter().any(|x| x.time == m.time) {
+                if times.insert(m.time) {
                     l.markers.push(m.clone());
                     n += 1;
                 }
@@ -339,10 +347,10 @@ fn update_from_source(s: &mut Session, p: &Value) -> Result<Value> {
 fn has_precomp_layer(s: &Session) -> std::result::Result<(), String> {
     has_layers(s)?;
     let c = s.active_comp().ok_or("no composition")?;
-    if s.state.selected_layers.iter().filter_map(|l| c.layer(*l)).any(|l| matches!(l.source, LayerSource::Comp { .. })) {
+    if s.state.selected_layers.iter().filter_map(|l| c.layer(*l)).any(|l| matches!(l.source, LayerSource::Comp { .. } | LayerSource::Footage { .. })) {
         Ok(())
     } else {
-        Err("select a precomposition layer".into())
+        Err("select a precomposition or footage layer".into())
     }
 }
 
diff --git a/crates/engine/src/commands/mask.rs b/crates/engine/src/cmd/mask.rs
similarity index 100%
rename from crates/engine/src/commands/mask.rs
rename to crates/engine/src/cmd/mask.rs
diff --git a/crates/engine/src/commands/mask_interp.rs b/crates/engine/src/cmd/mask_interp.rs
similarity index 97%
rename from crates/engine/src/commands/mask_interp.rs
rename to crates/engine/src/cmd/mask_interp.rs
index 982468c8e..ed7ed5190 100644
--- a/crates/engine/src/commands/mask_interp.rs
+++ b/crates/engine/src/cmd/mask_interp.rs
@@ -289,6 +289,7 @@ fn extract_face(s: &mut Session, p: &Value) -> Result<Value> {
         clip.push(crate::KeyClip { layer: lid, path, keys });
     }
     s.state.key_clipboard = clip;
+    s.state.keyframe_text = None;
     s.state.clip_is_keys = true;
     // The same data as text (tab-separated, one row per frame) for other applications.
     let mut text = String::from("EffectCraft Face Measurements\n\nFrame\tTime");
@@ -437,20 +438,22 @@ fn interpolate(s: &mut Session, p: &Value) -> Result<Value> {
     // The layer: given, else the layer of selected Mask Path keys, else the selection.
     let cid = super::comp_id(s, p)?;
     let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let selected = super::prop::editable_keys(comp, &s.state.selected_keys);
     let lid = match p.get("layer") {
         Some(v) => super::resolve_layer(comp, v).ok_or_else(|| bad(CMD, format!("no layer {v}")))?,
-        None => match s.state.selected_keys.iter().find(|k| comp.layer(k.layer).is_some_and(|l| l.masks().is_some_and(|m| m.find(k.prop).is_some()))) {
+        None => match selected.iter().find(|k| comp.layer(k.layer).is_some_and(|l| l.masks().is_some_and(|m| m.find(k.prop).is_some()))) {
             Some(k) => k.layer,
             None => layer_p(s, p, CMD)?.1,
         },
     };
     let layer = comp.layer(lid).ok_or(EngineError::NoComp)?;
+    if !super::prop::key_layer_editable(comp, lid) {
+        return Err(bad(CMD, "the layer is locked"));
+    }
     let masks = layer.masks().ok_or_else(|| bad(CMD, "the layer has no masks"))?;
     let uid = match p.get("mask") {
         Some(_) => mask_uid(s, layer, p),
-        None => s
-            .state
-            .selected_keys
+        None => selected
             .iter()
             .filter(|k| k.layer == lid)
             .find_map(|k| masks.groups().find(|g| g.get("path").is_some_and(|pr| pr.uid == k.prop)).map(|g| g.uid))
@@ -465,7 +468,7 @@ fn interpolate(s: &mut Session, p: &Value) -> Result<Value> {
             let ts: Vec<Tick> = a.iter().filter_map(Value::as_f64).map(|t| layer.layer_time(comp.frame_rate.snap_nearest(Tick::from_seconds_f64(t)))).collect();
             ts.into_iter().filter_map(|t| path_prop.keys.iter().find(|k| (k.time.0 - t.0).abs() <= comp.frame_duration().0 / 2).map(|k| k.time)).collect()
         }
-        None => s.state.selected_keys.iter().filter(|k| k.layer == lid && k.prop == path_prop.uid).map(|k| k.time).collect(),
+        None => selected.iter().filter(|k| k.layer == lid && k.prop == path_prop.uid).map(|k| k.time).collect(),
     };
     times.sort();
     times.dedup();
diff --git a/crates/engine/src/commands/model3d.rs b/crates/engine/src/cmd/model3d.rs
similarity index 96%
rename from crates/engine/src/commands/model3d.rs
rename to crates/engine/src/cmd/model3d.rs
index 28b7274ef..2cc4d34e6 100644
--- a/crates/engine/src/commands/model3d.rs
+++ b/crates/engine/src/cmd/model3d.rs
@@ -64,6 +64,12 @@ fn comp_renderer(s: &mut Session, p: &Value) -> Result<Value> {
     if r == Renderer::Classic3D && s.project.comp(cid).is_some_and(|c| c.layers.iter().any(|l| l.source.is_model())) {
         s.toast("Classic 3D doesn't draw 3D model layers: they show with the Advanced 3D renderer");
     }
+    if r == Renderer::Classic3D {
+        let env = |l: &Layer| matches!(l.source, LayerSource::Light { kind: effectcraft_project::LightKind::Environment });
+        if s.project.comp(cid).is_some_and(|c| c.layers.iter().any(env)) {
+            s.toast("Classic 3D doesn't light Environment light layers: they light with the Advanced 3D renderer");
+        }
+    }
     Ok(json!({"renderer": renderer_id(r)}))
 }
 
@@ -77,7 +83,7 @@ fn renderer_id(r: Renderer) -> &'static str {
 /// Only the Advanced 3D renderer draws model and primitive layers, so adding one switches a
 /// Classic 3D comp to it, like After Effects (inside the adding edit: one undo step). Whether
 /// the renderer changed.
-fn use_advanced_3d(proj: &mut effectcraft_project::Project, cid: ItemId) -> Result<bool> {
+pub(crate) fn use_advanced_3d(proj: &mut effectcraft_project::Project, cid: ItemId) -> Result<bool> {
     let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
     let switched = c.renderer != Renderer::Advanced3D;
     c.renderer = Renderer::Advanced3D;
@@ -86,10 +92,10 @@ fn use_advanced_3d(proj: &mut effectcraft_project::Project, cid: ItemId) -> Resu
 }
 
 /// Tell the user when [`use_advanced_3d`] changed the comp's renderer.
-fn report_switch(s: &mut Session, cid: ItemId, switched: bool) {
+pub(crate) fn report_switch(s: &mut Session, cid: ItemId, switched: bool, why: &str) {
     if switched {
         let name = s.project.item(cid).map_or("the composition", |i| i.name.as_str()).to_string();
-        s.toast(format!("\"{name}\" now uses the Advanced 3D renderer, which draws 3D models"));
+        s.toast(format!("\"{name}\" now uses the Advanced 3D renderer, {why}"));
     }
 }
 
@@ -156,7 +162,7 @@ pub(crate) fn new_model(s: &mut Session, p: &Value) -> Result<Value> {
         let id = insert_layer_at(proj, st, cid, l, index)?;
         Ok((id, use_advanced_3d(proj, cid)?))
     })?;
-    report_switch(s, cid, switched);
+    report_switch(s, cid, switched, "which draws 3D models");
     Ok(json!({"layer": id.0, "item": item.0, "advanced3d": true}))
 }
 
@@ -226,7 +232,7 @@ fn new_primitive(s: &mut Session, p: &Value) -> Result<Value> {
         let id = insert_layer(proj, st, cid, l)?;
         Ok((id, use_advanced_3d(proj, cid)?))
     })?;
-    report_switch(s, cid, switched);
+    report_switch(s, cid, switched, "which draws 3D models");
     Ok(json!({"layer": id.0, "kind": kind.label(), "advanced3d": true}))
 }
 
diff --git a/crates/engine/src/commands/nav_more.rs b/crates/engine/src/cmd/nav_more.rs
similarity index 92%
rename from crates/engine/src/commands/nav_more.rs
rename to crates/engine/src/cmd/nav_more.rs
index d008d1ef6..18165bf48 100644
--- a/crates/engine/src/commands/nav_more.rs
+++ b/crates/engine/src/cmd/nav_more.rs
@@ -39,6 +39,18 @@ fn deselect_keys(s: &mut Session, _: &Value) -> Result<Value> {
     Ok(Value::Null)
 }
 
+impl Session {
+    /// The selected mask (its group, or a property inside it) of a selected layer, the first
+    /// one: (layer, mask group).
+    pub fn selected_mask(&self) -> Option<(effectcraft_project::LayerId, effectcraft_project::Uid)> {
+        let comp = self.active_comp()?;
+        self.state.selected_props.iter().find_map(|(lid, uid)| {
+            let masks = comp.layer(*lid)?.masks()?;
+            masks.groups().find(|g| g.uid == *uid || g.find_group(*uid).is_some() || g.find(*uid).is_some()).map(|g| (*lid, g.uid))
+        })
+    }
+}
+
 /// Alt+` / Alt+Shift+`: select the next (previous) mask of the layer, wrapping around; the first
 /// (last) one when none is selected.
 fn step_mask(s: &mut Session, p: &Value, dir: i64) -> Result<Value> {
diff --git a/crates/engine/src/commands/paint.rs b/crates/engine/src/cmd/paint.rs
similarity index 100%
rename from crates/engine/src/commands/paint.rs
rename to crates/engine/src/cmd/paint.rs
diff --git a/crates/engine/src/commands/panels_cmds.rs b/crates/engine/src/cmd/panels_cmds.rs
similarity index 100%
rename from crates/engine/src/commands/panels_cmds.rs
rename to crates/engine/src/cmd/panels_cmds.rs
diff --git a/crates/engine/src/cmd/params.rs b/crates/engine/src/cmd/params.rs
new file mode 100644
index 000000000..2929d3347
--- /dev/null
+++ b/crates/engine/src/cmd/params.rs
@@ -0,0 +1,210 @@
+use super::{Comp, EngineError, ItemId, Layer, LayerId, Result, Session, Tick, Value};
+
+/// Hand a frontend-only command to the UI ([`crate::Event::Frontend`]).
+pub(crate) fn frontend(s: &mut Session, id: &str, p: &Value) -> Result<Value> {
+    s.events.push(crate::Event::Frontend { command: id.to_string(), params: p.clone() });
+    Ok(serde_json::json!({"frontend": id}))
+}
+
+/// Match path of a node (`transform/position`, `effects/#2/blurriness` style with `match#n`
+/// occurrences) so it can be found again on another layer.
+pub fn match_path_of(g: &effectcraft_project::PropGroup, uid: effectcraft_project::Uid) -> Option<String> {
+    for c in &g.children {
+        let nth = g.children.iter().take_while(|x| !std::ptr::eq(*x, c)).filter(|x| x.match_id() == c.match_id()).count() + 1;
+        let seg = if nth == 1 { c.match_id().to_string() } else { format!("{}#{nth}", c.match_id()) };
+        if c.uid() == uid {
+            return Some(seg);
+        }
+        if let effectcraft_project::Node::Group(sub) = c
+            && let Some(rest) = match_path_of(sub, uid)
+        {
+            return Some(format!("{seg}/{rest}"));
+        }
+    }
+    None
+}
+
+/// Turn `effects/<match name>[#n]/<property>` (as [`match_path_of`] writes it) into a uid path on
+/// `l`. Path parsing splits on `.`, which would cut a match name like `ec.control.slider` apart.
+/// Any other path, or an effect that is not on the layer, comes back unchanged.
+pub(crate) fn resolve_effect_path(l: &Layer, path: &str) -> String {
+    let Some((seg, tail)) = path.strip_prefix("effects/").and_then(|r| r.split_once('/')) else { return path.to_string() };
+    let (match_id, nth) = match seg.rsplit_once('#') {
+        Some((m, n)) if !m.is_empty() => match n.parse::<usize>() {
+            Ok(n) if n >= 1 => (m, n),
+            _ => (seg, 1),
+        },
+        _ => (seg, 1),
+    };
+    match l.effects().and_then(|fx| fx.groups().filter(|g| g.match_id == match_id).nth(nth - 1)) {
+        Some(g) => format!("effects/@{}/{tail}", g.uid),
+        None => path.to_string(),
+    }
+}
+
+/// Selected properties (leaves) of the active comp as (layer, uid); selected groups expand to
+/// their properties.
+pub(crate) fn selected_leaf_props(s: &Session) -> Vec<(LayerId, effectcraft_project::Uid)> {
+    let Some(comp) = s.active_comp() else { return vec![] };
+    let mut out = vec![];
+    for (lid, uid) in &s.state.selected_props {
+        let Some(l) = comp.layer(*lid) else { continue };
+        if l.props.find(*uid).is_some() {
+            out.push((*lid, *uid));
+        } else if let Some(g) = l.props.find_group(*uid) {
+            g.walk("", &mut |_, p| out.push((*lid, p.uid)));
+        }
+    }
+    out
+}
+
+/// A popup's `[{value, label}]`, as `effect.list`, `prop.get` and `layer.tree` report it.
+/// Engine/MCP popup values are zero-based; JSX exposes one-based values.
+pub(crate) fn popup_options(options: &[String]) -> Value {
+    serde_json::json!(options.iter().enumerate().map(|(value, label)| serde_json::json!({"value": value, "label": label})).collect::<Vec<_>>())
+}
+
+// ---------- params ----------
+
+pub(crate) fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
+    EngineError::BadParams { cmd: cmd.into(), msg: msg.into() }
+}
+
+pub(crate) fn str_p<'a>(p: &'a Value, k: &str) -> Option<&'a str> {
+    p.get(k).and_then(Value::as_str)
+}
+
+pub(crate) fn f_p(p: &Value, k: &str) -> Option<f64> {
+    p.get(k).and_then(Value::as_f64)
+}
+
+pub(crate) fn b_p(p: &Value, k: &str) -> Option<bool> {
+    p.get(k).and_then(Value::as_bool)
+}
+
+pub(crate) fn merge_p(p: &Value) -> Option<&str> {
+    str_p(p, "merge")
+}
+
+/// `comp`: item id or name (an all-digit string that names no comp is taken as an id, as MCP
+/// clients often send numbers as strings); default the active comp.
+pub(crate) fn comp_id(s: &Session, p: &Value) -> Result<ItemId> {
+    let missing = |v: &Value| EngineError::NoSuchComp(v.to_string());
+    match p.get("comp") {
+        Some(v @ Value::Number(n)) => n.as_u64().map(ItemId).filter(|id| s.project.comp(*id).is_some()).ok_or_else(|| missing(v)),
+        Some(v @ Value::String(name)) => s
+            .project
+            .items
+            .values()
+            .find(|i| &i.name == name && i.as_comp().is_some())
+            .map(|i| i.id)
+            .or_else(|| digits_id(name).map(ItemId).filter(|id| s.project.comp(*id).is_some()))
+            .ok_or_else(|| missing(v)),
+        _ => s.active_comp_id().ok_or(EngineError::NoComp),
+    }
+}
+
+/// An all-ASCII-digit string as a number (`"98"` -> 98); anything else (names, `#n`, signs) is `None`.
+fn digits_id(s: &str) -> Option<u64> {
+    if s.is_empty() || !s.bytes().all(|b| b.is_ascii_digit()) {
+        return None;
+    }
+    s.parse().ok()
+}
+
+/// Resolve a layer reference: id (number), `#n` / index (1-based), or name. An all-digit string
+/// that names no layer is resolved as the number it spells.
+pub(crate) fn resolve_layer(comp: &Comp, v: &Value) -> Option<LayerId> {
+    match v {
+        Value::Number(n) => {
+            let id = n.as_u64()?;
+            if comp.layer(LayerId(id)).is_some() { Some(LayerId(id)) } else { comp.layers.get((id as usize).checked_sub(1)?).map(|l| l.id) }
+        }
+        Value::String(s) => {
+            if let Some(i) = s.strip_prefix('#').and_then(|i| i.parse::<usize>().ok()) {
+                return comp.layers.get(i.checked_sub(1)?).map(|l| l.id);
+            }
+            comp.layers.iter().find(|l| &l.name == s).map(|l| l.id).or_else(|| digits_id(s).and_then(|id| resolve_layer(comp, &Value::from(id))))
+        }
+        _ => None,
+    }
+}
+
+/// `layer` param or the first selected layer.
+pub(crate) fn layer_p(s: &Session, p: &Value, cmd: &str) -> Result<(ItemId, LayerId)> {
+    let cid = comp_id(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    if let Some(v) = p.get("layer") {
+        return resolve_layer(comp, v).map(|l| (cid, l)).ok_or_else(|| bad(cmd, format!("no layer {v}")));
+    }
+    s.state
+        .selected_layers
+        .first()
+        .copied()
+        .filter(|l| comp.layer(*l).is_some())
+        .map(|l| (cid, l))
+        .ok_or_else(|| bad(cmd, "no `layer` given and no layer selected"))
+}
+
+/// `layers` param (array) or the selection.
+pub(crate) fn layers_p(s: &Session, p: &Value) -> Result<(ItemId, Vec<LayerId>)> {
+    layers_or(s, p, &s.state.selected_layers)
+}
+
+/// `layers` param (array), else `layer`, else those of `fallback` still in the comp.
+pub(crate) fn layers_or(s: &Session, p: &Value, fallback: &[LayerId]) -> Result<(ItemId, Vec<LayerId>)> {
+    let cid = comp_id(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    // Explicit references that match no layer are an error (agents otherwise get a silent no-op).
+    let resolve =
+        |v: &Value| resolve_layer(comp, v).ok_or_else(|| EngineError::Other(format!("no layer {v} (use a layer id, \"#n\" or a name from comp.info)")));
+    if let Some(Value::Array(a)) = p.get("layers") {
+        return Ok((cid, a.iter().map(resolve).collect::<Result<_>>()?));
+    }
+    if let Some(v) = p.get("layer").filter(|v| !v.is_null()) {
+        return Ok((cid, vec![resolve(v)?]));
+    }
+    Ok((cid, fallback.iter().copied().filter(|l| comp.layer(*l).is_some()).collect()))
+}
+
+/// Whether a layer can be picked by the user (Select All, Ctrl+Up/Down, a Timeline click): not
+/// locked, and not hidden by the composition's Hide Shy Layers.
+pub(crate) fn selectable(comp: &Comp, l: &Layer) -> bool {
+    !(l.switches.locked || (comp.hide_shy && l.switches.shy))
+}
+
+/// The layers of `ids` a command may edit: locked layers are left alone, as in After Effects.
+/// An error when every one of them is locked.
+pub(crate) fn unlocked(s: &Session, cid: ItemId, ids: Vec<LayerId>, cmd: &str) -> Result<Vec<LayerId>> {
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let locked = |id: &LayerId| comp.layer(*id).is_some_and(|l| l.switches.locked);
+    match ids.iter().find(|id| locked(id)) {
+        Some(first) if ids.iter().all(locked) => {
+            let name = comp.layer(*first).map(|l| l.name.clone()).unwrap_or_default();
+            Err(bad(cmd, format!("“{name}” is locked (Layer ▸ Switches ▸ Unlock All Layers)")))
+        }
+        _ => Ok(ids.into_iter().filter(|id| !locked(id)).collect()),
+    }
+}
+
+/// `visible: [{layer, prop}]`: the properties the Timeline shows (J / K and Select All
+/// Keyframes use only those, as in After Effects). `None` when not given.
+pub(crate) fn visible_p(p: &Value) -> Option<Vec<(LayerId, effectcraft_project::Uid)>> {
+    let a = p.get("visible")?.as_array()?;
+    Some(a.iter().filter_map(|v| Some((LayerId(v.get("layer")?.as_u64()?), v.get("prop")?.as_u64()?))).collect())
+}
+
+/// `time` (seconds) or `frame` param, else the CTI.
+pub(crate) fn time_p(s: &Session, p: &Value, comp: Option<&Comp>) -> Tick {
+    if let Some(t) = f_p(p, "time") {
+        return Tick::from_seconds_f64(t);
+    }
+    if let (Some(f), Some(c)) = (p.get("frame").and_then(Value::as_i64), comp) {
+        return c.frame_rate.tick_of(f);
+    }
+    s.time()
+}
+
+pub(crate) fn layer_mut(p: &mut effectcraft_project::Project, cid: ItemId, lid: LayerId) -> Result<&mut Layer> {
+    p.comp_mut(cid).ok_or(EngineError::NoComp)?.layer_mut(lid).ok_or(EngineError::Project(effectcraft_project::ProjectError::NoLayer(lid)))
+}
diff --git a/crates/engine/src/commands/path_nulls.rs b/crates/engine/src/cmd/path_nulls.rs
similarity index 96%
rename from crates/engine/src/commands/path_nulls.rs
rename to crates/engine/src/cmd/path_nulls.rs
index bb74ee77c..93d71cd67 100644
--- a/crates/engine/src/commands/path_nulls.rs
+++ b/crates/engine/src/cmd/path_nulls.rs
@@ -78,7 +78,16 @@ fn info(s: &Session, cid: ItemId, lid: LayerId, uid: Uid, cmd: &str) -> Result<P
     let layer = comp.layer(lid).ok_or(EngineError::NoComp)?;
     let pr = layer.props.find(uid).ok_or_else(|| bad(cmd, "no such property"))?;
     let t = s.time();
-    let ctx = effectcraft_render::EvalCtx { project: &s.project, comp_id: cid, comp, time: t, expr: s.expr.as_deref(), footage: Some(s.footage.as_ref()) };
+    let ctx = effectcraft_render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time: t,
+        expr: s.expr.as_deref(),
+        footage: Some(s.footage.as_ref()),
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let KV::Path(path) = ctx.value(layer, pr) else { return Err(bad(cmd, "that property is not a path")) };
     if path.vertices.is_empty() {
         return Err(bad(cmd, "the path has no vertices"));
@@ -147,8 +156,16 @@ fn pin_targets(s: &Session, p: &Value, cmd: &str) -> Result<Option<(ItemId, Vec<
     };
     let cid = pins.first().map(|x| x.0).ok_or_else(|| bad(cmd, "no puppet pins"))?;
     let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
-    let ctx =
-        effectcraft_render::EvalCtx { project: &s.project, comp_id: cid, comp, time: s.time(), expr: s.expr.as_deref(), footage: Some(s.footage.as_ref()) };
+    let ctx = effectcraft_render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time: s.time(),
+        expr: s.expr.as_deref(),
+        footage: Some(s.footage.as_ref()),
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let mut out = vec![];
     for (_, lid, uid) in pins {
         let Some(layer) = comp.layer(lid) else { continue };
diff --git a/crates/engine/src/commands/paths.rs b/crates/engine/src/cmd/paths.rs
similarity index 88%
rename from crates/engine/src/commands/paths.rs
rename to crates/engine/src/cmd/paths.rs
index 96767d967..8364f67ec 100644
--- a/crates/engine/src/commands/paths.rs
+++ b/crates/engine/src/cmd/paths.rs
@@ -5,10 +5,11 @@
 use effectcraft_keyframe::{ShapePath, Value as KV};
 use effectcraft_project::build::{self, Ids};
 use effectcraft_project::{FeatherFalloff, GroupKind, ItemId, LayerId, LayerSource, MaskMotionBlur, Node, PropGroup, Uid};
+use effectcraft_render::EvalCtx;
 use serde_json::{Value, json};
 
 use super::layer_menu::target_masks;
-use super::{CommandSpec, b_p, bad, f_p, has_comp, has_layers, layer_mut, layer_p, str_p};
+use super::{CommandSpec, b_p, bad, f_p, has_comp, has_layers, layer_mut, layer_p, merge_p, str_p};
 use crate::{EngineError, Result, Session, VertexRef, cmd};
 
 // ---------------------------------------------------------------- RotoBezier
@@ -111,26 +112,38 @@ fn roto_bezier(s: &mut Session, p: &Value) -> Result<Value> {
 /// The parametric shape paths that Convert To Bezier Path replaces with an editable path.
 const PARAMETRIC: [&str; 3] = ["rect", "ellipse", "star"];
 
-/// The path a parametric shape group draws, in the group's own space, read at `lt`. This is the
-/// geometry the renderer builds from the same values (`render::shapes::collect`), so the converted
-/// path is the shape that was on screen rather than an approximation of it; the defaults match
-/// that code for a property a group doesn't carry (a polygon has no inner radius or roundness).
-fn parametric_path(g: &PropGroup, lt: effectcraft_time::Tick) -> Option<ShapePath> {
-    let f = |id: &str, d: f64| g.prop(id).map_or(d, |pr| pr.value_at(lt).as_f64());
-    let v2 = |id: &str, d: [f64; 2]| g.prop(id).map_or(d, |pr| pr.value_at(lt).as_vec2());
+/// The path a parametric shape group draws, in the group's own space. This is the geometry the
+/// renderer builds from the same values (`render::shapes::collect`), expressions included, so the
+/// converted path is the shape that was on screen rather than an approximation of it; the defaults
+/// match that code for a property a group doesn't carry (a polygon has no inner radius or
+/// roundness).
+fn parametric_path(ctx: &EvalCtx, layer: &effectcraft_project::Layer, g: &PropGroup) -> Option<ShapePath> {
+    let f = |id: &str, d: f64| ctx.f(layer, g, id, d);
+    let v2 = |id: &str, d: [f64; 2]| ctx.v2(layer, g, id, d);
     let path = match g.match_id.as_str() {
-        "rect" => effectcraft_path::rect(v2("size", [100.0; 2]), v2("position", [0.0; 2]), f("roundness", 0.0)),
+        "rect" => {
+            let (size, pos) = (v2("size", [100.0; 2]), v2("position", [0.0; 2]));
+            if ctx.b(layer, g, "perCorner") {
+                effectcraft_path::rect_radii(
+                    size,
+                    pos,
+                    [f("topLeftRoundness", 0.0), f("topRightRoundness", 0.0), f("bottomRightRoundness", 0.0), f("bottomLeftRoundness", 0.0)],
+                )
+            } else {
+                effectcraft_path::rect(size, pos, f("roundness", 0.0))
+            }
+        }
         "ellipse" => effectcraft_path::ellipse(v2("size", [100.0; 2]), v2("position", [0.0; 2])),
-        "star" => effectcraft_path::polystar(
-            g.prop("type").map_or(0, |pr| pr.value_at(lt).as_enum()) == 0,
-            f("points", 5.0),
-            v2("position", [0.0; 2]),
-            f("rotation", 0.0),
-            f("innerRadius", 50.0),
-            f("outerRadius", 100.0),
-            f("innerRoundness", 0.0),
-            f("outerRoundness", 0.0),
-        ),
+        "star" => effectcraft_path::polystar(effectcraft_path::Polystar {
+            star: ctx.e(layer, g, "type") == 0,
+            points: f("points", 5.0),
+            pos: v2("position", [0.0; 2]),
+            rotation: f("rotation", 0.0),
+            inner: f("innerRadius", 50.0),
+            outer: f("outerRadius", 100.0),
+            inner_round: f("innerRoundness", 0.0),
+            outer_round: f("outerRoundness", 0.0),
+        }),
         _ => return None,
     };
     // A closed parametric shape is one subpath; anything else would not be this shape.
@@ -160,28 +173,38 @@ fn convert_to_bezier(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let t = s.time();
     let n = shapes.len();
+    // Read the geometry before editing, with the same expression-aware context the renderer
+    // uses: an expression-driven corner radius, size or position must convert to what is on
+    // screen, not to the property's underlying value.
+    let prepared = {
+        let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+        let ctx = EvalCtx { expr: s.expr.as_deref(), ..EvalCtx::new(&s.project, cid, comp, t) };
+        let mut prepared = Vec::new();
+        for (lid, uid) in &shapes {
+            let Some(l) = comp.layer(*lid) else { continue };
+            let Some(old) = l.props.sub("contents").and_then(|c| c.find_group(*uid)) else { continue };
+            let Some(path) = parametric_path(&ctx, l, old) else { continue };
+            // Path Direction is the shape's own, not a default: reversing is a separate command.
+            prepared.push((*lid, *uid, path, ctx.e(l, old, "direction"), old.enabled));
+        }
+        prepared
+    };
     let made = s.edit("Convert To Bezier Path", None, |proj, st| {
         let mut next = proj.next_id;
         let mut made = Vec::new();
-        for (lid, uid) in &shapes {
-            let l = layer_mut(proj, cid, *lid)?;
-            let lt = l.layer_time(t);
+        for (lid, uid, path, direction, enabled) in prepared {
+            let l = layer_mut(proj, cid, lid)?;
             let contents = l.props.sub_mut("contents").ok_or_else(|| bad("path.convertToBezier", "not a shape layer"))?;
-            let Some(old) = contents.find_group(*uid) else { continue };
-            let Some(path) = parametric_path(old, lt) else { continue };
-            // Path Direction is the shape's own, not a default: reversing is a separate command.
-            let direction = old.prop("direction").map_or(0, |pr| pr.value_at(lt).as_enum());
-            let enabled = old.enabled;
             let mut g = build::shape_path(&mut Ids(&mut next), path);
             if let Some(pr) = g.prop_mut("direction") {
                 pr.value = KV::Enum(direction);
             }
             g.enabled = enabled;
             let new_uid = g.uid;
-            let parent = contents.parent_of_mut(*uid).ok_or_else(|| bad("path.convertToBezier", "no such shape item"))?;
-            let Some(at) = parent.children.iter().position(|c| c.uid() == *uid) else { continue };
+            let parent = contents.parent_of_mut(uid).ok_or_else(|| bad("path.convertToBezier", "no such shape item"))?;
+            let Some(at) = parent.children.iter().position(|c| c.uid() == uid) else { continue };
             parent.children[at] = Node::Group(g);
-            made.push((*lid, new_uid));
+            made.push((lid, new_uid));
         }
         proj.next_id = next;
         // The new paths are what is selected, so the vertices can be edited straight away.
@@ -308,7 +331,7 @@ fn free_transform(s: &mut Session, p: &Value) -> Result<Value> {
         let y = v[1] * scale[1];
         [x * c - y * sn, x * sn + y * c]
     };
-    let n = s.edit("Free Transform Points", None, |proj, _| {
+    let n = s.edit("Free Transform Points", merge_p(p), |proj, _| {
         let mut n = 0;
         for (lid, uid) in &targets {
             let l = layer_mut(proj, cid, *lid)?;
@@ -360,7 +383,7 @@ fn free_transform(s: &mut Session, p: &Value) -> Result<Value> {
 
 const SHAPE_ITEMS: &[&str] = &[
     "group", "rect", "ellipse", "star", "path", "fill", "stroke", "gfill", "gstroke", "trim", "repeater", "round", "offset", "pucker", "twist", "zigzag",
-    "wiggle", "merge", "front", "bevel", "side", "back",
+    "wiggle", "wiggler", "merge", "front", "bevel", "side", "back",
 ];
 
 /// Selected shape items (contents entries) of shape layers: (layer, uid).
@@ -542,7 +565,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Free Transform Points",
             ["Layer", "Mask and Shape Path"],
             None,
-            "{layer?, mask?, scale?: % | [x%, y%], rotation?: deg, offset?: [dx, dy], anchor?: [x, y]}",
+            "{layer?, mask?, scale?: % | [x%, y%], rotation?: deg, offset?: [dx, dy], anchor?: [x, y], merge?: string}",
             has_layers,
             free_transform
         ),
diff --git a/crates/engine/src/commands/project_items.rs b/crates/engine/src/cmd/project_items.rs
similarity index 100%
rename from crates/engine/src/commands/project_items.rs
rename to crates/engine/src/cmd/project_items.rs
diff --git a/crates/engine/src/commands/prop.rs b/crates/engine/src/cmd/prop.rs
similarity index 90%
rename from crates/engine/src/commands/prop.rs
rename to crates/engine/src/cmd/prop.rs
index 00232967e..b4432dd2f 100644
--- a/crates/engine/src/commands/prop.rs
+++ b/crates/engine/src/cmd/prop.rs
@@ -48,7 +48,6 @@ fn with_prop<T>(
     let t = s.time_of(cid);
     let linear = s.prefs.general.default_spatial_linear;
     s.edit(label, merge, |proj, state| {
-        let mut next = proj.next_id;
         let l = layer_mut(proj, cid, lid)?;
         let lt = l.layer_time(t);
         let pr = l.props.find_mut(uid).ok_or_else(|| bad("prop", "property vanished"))?;
@@ -64,17 +63,37 @@ fn with_prop<T>(
             }
         }
         if pr.match_id == "type" {
-            let removed = sync_polystar_type(l, uid, lt, &mut next)?;
-            if !removed.is_empty() {
-                state.selected_props.retain(|(layer, prop)| *layer != lid || !removed.contains(prop));
-                state.selected_keys.retain(|key| key.layer != lid || !removed.contains(&key.prop));
-            }
+            sync_polystar_property(proj, state, cid, lid, uid, t)?;
         }
-        proj.next_id = next;
         Ok(r)
     })
 }
 
+/// Keep Polystar controls and their selection references in the property's edit transaction.
+pub(super) fn sync_polystar_property(
+    proj: &mut effectcraft_project::Project,
+    state: &mut crate::EditorState,
+    cid: ItemId,
+    lid: LayerId,
+    uid: Uid,
+    time: Tick,
+) -> Result<()> {
+    let mut next = proj.next_id;
+    let layer = layer_mut(proj, cid, lid)?;
+    let removed = sync_polystar_type(layer, uid, layer.layer_time(time), &mut next)?;
+    if !removed.is_empty() {
+        if state.active_comp == Some(cid) {
+            state.selected_props.retain(|(layer, prop)| *layer != lid || !removed.contains(prop));
+            state.selected_keys.retain(|key| key.layer != lid || !removed.contains(&key.prop));
+        } else if let Some(selection) = state.comp_selections.get_mut(&cid) {
+            selection.props.retain(|(layer, prop)| *layer != lid || !removed.contains(prop));
+            selection.keys.retain(|key| key.layer != lid || !removed.contains(&key.prop));
+        }
+    }
+    proj.next_id = next;
+    Ok(())
+}
+
 /// A static Polygon has no inner controls; switching to Star creates them in schema order
 /// with AE's switch defaults (#1685). Animated/expression-driven types need the controls at
 /// every time, including when the current value is Polygon.
@@ -228,7 +247,8 @@ fn property_reply(p: &Value, layer: &Layer, pr: &Property, time: Tick, value: Va
 /// property (by match path, `transform/position`, `effects/<effect>#n/<param>`) of every other
 /// selected, unlocked layer of the comp whose value is of the same kind, as (layer, uid). Empty
 /// when `selected` is not set or the edited layer isn't selected. After Effects applies a value
-/// edit, the stopwatch and the keyframe button to all selected layers (#355, #491).
+/// edit, the stopwatch and the keyframe button to all selected layers (#355, #491). A parameter
+/// of a selected Puppet pin also reaches the same parameter of the other selected pins (#1751).
 fn selected_twins(s: &Session, p: &Value, cmd: &str) -> Result<Vec<(LayerId, Uid)>> {
     if b_p(p, "selected") != Some(true) {
         return Ok(vec![]);
@@ -241,14 +261,31 @@ fn selected_twins(s: &Session, p: &Value, cmd: &str) -> Result<Vec<(LayerId, Uid
         return Ok(vec![]);
     }
     let kind = (pr.value.kind_name(), pr.value.components().len());
-    Ok(s.state
+    let same_kind = |q: &&Property| (q.value.kind_name(), q.value.components().len()) == kind;
+    let mut twins: Vec<(LayerId, Uid)> = s
+        .state
         .selected_layers
         .iter()
         .filter(|o| **o != lid)
         .filter_map(|o| comp.layer(*o))
         .filter(|l| !l.switches.locked)
-        .filter_map(|l| l.props.prop(&path).filter(|q| (q.value.kind_name(), q.value.components().len()) == kind).map(|q| (l.id, q.uid)))
-        .collect())
+        .filter_map(|l| l.props.prop(&path).filter(same_kind).map(|q| (l.id, q.uid)))
+        .collect();
+    // A parameter of a selected Puppet pin: the same parameter of every other selected pin, on
+    // this layer too, so several pins move or key together (#1751).
+    let pin = super::puppet::layer_pins(layer).find(|g| g.props().any(|q| q.uid == uid)).map(|g| g.uid);
+    if let Some(pin) = pin
+        && s.state.selected_props.contains(&(lid, pin))
+    {
+        for (ol, ou) in &s.state.selected_props {
+            let Some(other) = comp.layer(*ol).filter(|l| !l.switches.locked) else { continue };
+            let Some(q) = super::puppet::layer_pins(other).find(|g| g.uid == *ou).and_then(|g| g.get(&pr.match_id)).filter(same_kind) else { continue };
+            if (*ol, q.uid) != (lid, uid) && !twins.contains(&(*ol, q.uid)) {
+                twins.push((*ol, q.uid));
+            }
+        }
+    }
+    Ok(twins)
 }
 
 /// `p` aimed at property `uid` of layer `lid` instead.
@@ -267,8 +304,13 @@ fn twin_params(p: &Value, lid: LayerId, uid: Uid) -> Value {
 /// The value of property `uid` of `lid` at the CTI as numbers (Position with Separate
 /// Dimensions: its X / Y / Z Position).
 fn current_components(s: &Session, cid: ItemId, lid: LayerId, uid: Uid) -> Option<Vec<f64>> {
+    components_at(s, cid, lid, uid, None)
+}
+
+/// [`current_components`] at layer time `at` (the CTI when `None`).
+fn components_at(s: &Session, cid: ItemId, lid: LayerId, uid: Uid, at: Option<Tick>) -> Option<Vec<f64>> {
     let l = s.project.comp(cid)?.layer(lid)?;
-    let lt = l.layer_time(s.time_of(cid));
+    let lt = at.unwrap_or_else(|| l.layer_time(s.time_of(cid)));
     if let Some(tr) = l.transform()
         && tr.get("position").is_some_and(|q| q.uid == uid)
         && tr.get("positionX").is_some()
@@ -300,7 +342,9 @@ pub(crate) fn proportional_share(index: usize, count: usize) -> f64 {
 /// `prop.set`; with `selected`, also on the other selected layers: the same value, or with
 /// `offset` (a scrub) the same change from each layer's own value. A typed value with `dims`
 /// (the components edited, e.g. `[2]` for Z) sets only those components on the other layers,
-/// which keep the rest of their own value (#1434). With `offset` and
+/// which keep the rest of their own value (#1434); `follow` components move on each layer by the
+/// change its first typed component takes (linked Audio Levels keep each layer's balance, #2485).
+/// With `offset` and
 /// `proportional` (Proportional Scrubbing) each layer takes [`proportional_share`] of the change
 /// by its place in the selection order, the scrubbed layer too. One undo step (with `merge`,
 /// one that a continuing scrub keeps folding into).
@@ -325,10 +369,19 @@ fn set_selected(s: &mut Session, p: &Value) -> Result<Value> {
         (None, Some(a), Some(_)) if !scalar => Some(a.iter().filter_map(Value::as_u64).filter_map(|d| usize::try_from(d).ok()).collect()),
         _ => None,
     };
+    let follow: Vec<usize> =
+        p.get("follow").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_u64).filter_map(|d| usize::try_from(d).ok()).collect();
+    // Each layer's own value where `set` writes it (a `time` other than the CTI keys there).
     let typed = |s: &Session, q: &mut Value, olid: LayerId, ouid: Uid| {
         if let (Some(dims), Some(n)) = (&dims, &new)
-            && let Some(mut c) = current_components(s, cid, olid, ouid)
+            && let Some(mut c) = components_at(s, cid, olid, ouid, snapped_key_time(s, cid, olid, q, "prop.set").ok().flatten())
         {
+            let change = dims.first().and_then(|&d| Some(n.get(d)? - c.get(d)?)).unwrap_or(0.0);
+            for &d in &follow {
+                if let Some(slot) = c.get_mut(d) {
+                    *slot += change;
+                }
+            }
             for &d in dims {
                 if let (Some(slot), Some(v)) = (c.get_mut(d), n.get(d)) {
                     *slot = *v;
@@ -491,6 +544,9 @@ fn get(s: &mut Session, p: &Value) -> Result<Value> {
         "time": t.seconds(), "value": raw.to_json(), "animated": !pr.keys.is_empty(),
         "keys": keys, "expression": pr.expr.as_ref().map(|e| e.text.clone()),
     });
+    if let Some(o) = l.popup_options(pr) {
+        out["options"] = super::popup_options(&o);
+    }
     // With an expression, `value` is the keyframed (pre-expression) value; also report what the
     // expression makes of it (what renders), or why it fails. A disabled one renders `value`; one
     // disabled by its syntax error (prop.setExpression) reports that error.
@@ -661,12 +717,21 @@ fn set_expr(s: &mut Session, p: &Value) -> Result<Value> {
             s.project.comp(*cid).and_then(|c| c.layer(*lid).and_then(|l| super::link::reference(c, l, l, *uid, true))).unwrap_or_else(|| "value".into())
         })
         .collect();
-    let results = s.edit("Expression", merge_p(p), |proj, _| {
+    let times: Vec<_> = targets.iter().map(|(cid, _, _)| s.time_of(*cid)).collect();
+    let results = s.edit("Expression", merge_p(p), |proj, state| {
         let mut out = vec![];
-        for ((cid, lid, uid), def) in targets.iter().zip(&defs) {
+        let mut changed_types = vec![];
+        for (((cid, lid, uid), def), time) in targets.iter().zip(&defs).zip(&times) {
             let pr = layer_mut(proj, *cid, *lid)?.props.find_mut(*uid).ok_or_else(|| bad(C, "property vanished"))?;
             apply_expr(pr, &text, enabled, def);
             out.push(json!(pr.expr.as_ref().map(|e| e.text.clone())));
+            if pr.match_id == "type" {
+                changed_types.push((*cid, *lid, *uid, *time));
+            }
+        }
+        // All selected targets must be edited before a Type change can remove inner controls.
+        for (cid, lid, uid, time) in changed_types {
+            sync_polystar_property(proj, state, cid, lid, uid, time)?;
         }
         Ok(out)
     })?;
@@ -729,6 +794,8 @@ fn select_prop(s: &mut Session, p: &Value) -> Result<Value> {
     if !add {
         s.state.selected_props.clear();
         s.state.selected_vertices.clear();
+        // Groups (masks, effects) have no keys of their own: don't leave the old selection's behind.
+        s.state.selected_keys.clear();
     }
     if !s.state.selected_layers.contains(&lid) {
         s.state.selected_layers = vec![lid];
@@ -746,9 +813,6 @@ fn select_prop(s: &mut Session, p: &Value) -> Result<Value> {
         && let Some(pr) = s.active_comp().and_then(|c| c.layer(lid)).and_then(|l| l.props.find(uid))
     {
         let keys: Vec<KeyRef> = pr.keys.iter().map(|k| KeyRef { layer: lid, prop: uid, time: k.time }).collect();
-        if !add {
-            s.state.selected_keys.clear();
-        }
         s.state.selected_keys.extend(keys);
     }
     Ok(Value::Null)
@@ -883,6 +947,15 @@ fn select_keys(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(out)
 }
 
+/// References that can be edited, including explicit key lists supplied by commands.
+pub(crate) fn editable_keys(comp: &effectcraft_project::Comp, selected: &[KeyRef]) -> Vec<KeyRef> {
+    selected.iter().filter(|key| key_layer_editable(comp, key.layer)).copied().collect()
+}
+
+pub(crate) fn key_layer_editable(comp: &effectcraft_project::Comp, layer: LayerId) -> bool {
+    comp.layer(layer).is_some_and(|layer| !layer.switches.locked)
+}
+
 /// Apply `f` to every selected key; keeps the selection pointing at moved keys.
 pub(crate) fn edit_keys(s: &mut Session, label: &str, merge: Option<&str>, f: impl Fn(&mut Vec<Keyframe>, usize, &mut Tick) -> bool) -> Result<Value> {
     let cid = s.active_comp_id().ok_or(EngineError::NoComp)?;
@@ -895,7 +968,16 @@ pub(crate) fn edit_keys(s: &mut Session, label: &str, merge: Option<&str>, f: im
             groups.entry((k.layer, k.prop)).or_default().push(k.time);
         }
         for ((lid, uid), times) in groups {
-            let Some(pr) = comp.layer_mut(lid).and_then(|l| l.props.find_mut(uid)) else { continue };
+            let Some(layer) = comp.layer_mut(lid) else { continue };
+            // A locked layer's keys stay as they are, and stay selected.
+            if layer.switches.locked {
+                for time in times {
+                    let r = KeyRef { layer: lid, prop: uid, time };
+                    remapped.insert(r, r);
+                }
+                continue;
+            }
+            let Some(pr) = layer.props.find_mut(uid) else { continue };
             // Process each stored key once, in an order that avoids collisions when moving.
             let mut idx: Vec<(usize, Tick)> = times.iter().filter_map(|t| key_at(&pr.keys, *t).map(|i| (i, *t))).collect();
             idx.sort_by_key(|x| x.0);
@@ -1042,10 +1124,16 @@ fn move_keys(s: &mut Session, p: &Value) -> Result<Value> {
 fn delete_keys(s: &mut Session, _: &Value) -> Result<Value> {
     let cid = s.active_comp_id().ok_or(EngineError::NoComp)?;
     let sel = s.state.selected_keys.clone();
+    let time = s.time();
     s.edit("Delete Keyframes", None, |proj, st| {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
         let mut removed = 0usize;
+        let mut changed = std::collections::BTreeSet::new();
         for k in &sel {
+            // A layer locked after its keys were selected keeps them (the selection stays too).
+            if comp.layer(k.layer).is_some_and(|l| l.switches.locked) {
+                continue;
+            }
             if let Some(pr) = comp.layer_mut(k.layer).and_then(|l| l.props.find_mut(k.prop))
                 && let Some(i) = key_at(&pr.keys, k.time)
             {
@@ -1054,9 +1142,15 @@ fn delete_keys(s: &mut Session, _: &Value) -> Result<Value> {
                 }
                 pr.keys.remove(i);
                 removed += 1;
+                if pr.match_id == "type" {
+                    changed.insert((k.layer, k.prop));
+                }
             }
         }
-        st.selected_keys.clear();
+        st.selected_keys.retain(|k| comp.layer(k.layer).is_some_and(|l| l.switches.locked));
+        for (layer, prop) in changed {
+            sync_polystar_property(proj, st, cid, layer, prop, time)?;
+        }
         // The keys actually removed: a selected key that is gone (or listed twice) isn't counted,
         // so a caller can tell that a delete changed nothing.
         Ok(json!(removed))
@@ -1189,6 +1283,15 @@ fn toggle_hold(s: &mut Session, _: &Value) -> Result<Value> {
     })
 }
 
+fn set_muted(s: &mut Session, p: &Value) -> Result<Value> {
+    let muted = b_p(p, "muted").unwrap_or(true);
+    let label = if muted { "Mute Keyframes" } else { "Unmute Keyframes" };
+    edit_keys(s, label, None, move |keys, i, _| {
+        keys[i].muted = muted;
+        false
+    })
+}
+
 /// A number or a per-dimension array of numbers.
 fn nums_p(p: &Value, k: &str, scale: f64) -> Option<Vec<f64>> {
     match p.get(k)? {
@@ -1285,8 +1388,16 @@ fn convert_one_expr(s: &mut Session, cid: ItemId, lid: LayerId, uid: Uid) -> Res
     let fd = comp.frame_duration();
     let mut t = layer.in_point;
     while t < layer.out_point {
-        let ctx =
-            effectcraft_render::EvalCtx { project: &s.project, comp_id: cid, comp: &comp, time: t, expr: s.expr.as_deref(), footage: Some(s.footage.as_ref()) };
+        let ctx = effectcraft_render::EvalCtx {
+            project: &s.project,
+            comp_id: cid,
+            comp: &comp,
+            time: t,
+            expr: s.expr.as_deref(),
+            footage: Some(s.footage.as_ref()),
+            property_overrides: &[],
+            media_overrides: &[],
+        };
         keys.push(Keyframe::new(layer.layer_time(t), ctx.value(&layer, &pr)));
         t += fd;
     }
@@ -1310,7 +1421,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Set Property Value",
             [],
             None,
-            "{layer?, path|prop, value, time? (layer s by default), timeBase?: layer|comp, merge?, selected? (also the other selected layers), offset? (them by the same change), proportional? (with offset: Proportional Scrubbing, each layer by its share in selection order, the first none, the last all), dims? (with selected, a typed value: the components edited, e.g. [2] for Z; the other layers keep the rest of their own value)}",
+            "{layer?, path|prop, value, time? (layer s by default), timeBase?: layer|comp, merge?, selected? (also the other selected layers), offset? (them by the same change), proportional? (with offset: Proportional Scrubbing, each layer by its share in selection order, the first none, the last all), dims? (with selected, a typed value: the components edited, e.g. [2] for Z; the other layers keep the rest of their own value), follow? (with dims: components that move on each other layer by the change its first typed component takes)}",
             has_layers,
             set_selected
         ),
@@ -1373,6 +1484,7 @@ pub fn specs() -> Vec<CommandSpec> {
             &json!({"which": "out"})
         )),
         cmd!("keys.toggleHold", "Toggle Hold Keyframe", ["Animation"], Some("Cmd+Alt+H"), "{}", has_keys, toggle_hold),
+        cmd!("keys.setMuted", "Mute Keyframes", ["Animation"], None, "{muted?: bool (default true)}", has_keys, set_muted),
         cmd!(
             "keys.interpolation",
             "Keyframe Interpolation...",
diff --git a/crates/engine/src/commands/prop_groups.rs b/crates/engine/src/cmd/prop_groups.rs
similarity index 84%
rename from crates/engine/src/commands/prop_groups.rs
rename to crates/engine/src/cmd/prop_groups.rs
index 6f7d74aef..b3e9baf14 100644
--- a/crates/engine/src/commands/prop_groups.rs
+++ b/crates/engine/src/cmd/prop_groups.rs
@@ -135,6 +135,61 @@ pub(crate) fn copy_contents(s: &Session) -> Vec<PropGroup> {
     selected_contents(s).into_iter().filter_map(|(lid, uid)| c.layer(lid)?.props.find_group(uid).cloned()).collect()
 }
 
+/// Masks selected on the active comp's layers, top to bottom (#2091).
+pub(crate) fn selected_masks(s: &Session) -> Vec<(LayerId, Uid)> {
+    let Some(c) = s.active_comp().filter(|_| !s.state.selected_props.is_empty()) else { return vec![] };
+    c.layers
+        .iter()
+        .flat_map(|l| {
+            let masks = l.masks().into_iter().flat_map(|m| m.groups());
+            masks.filter(|m| s.state.selected_props.contains(&(l.id, m.uid))).map(|m| (l.id, m.uid))
+        })
+        .collect()
+}
+
+/// Copies of the selected masks (Edit ▸ Copy), top to bottom.
+pub(crate) fn copy_masks(s: &Session) -> Vec<PropGroup> {
+    let Some(c) = s.active_comp() else { return vec![] };
+    selected_masks(s).into_iter().filter_map(|(lid, uid)| c.layer(lid)?.props.find_group(uid).cloned()).collect()
+}
+
+/// Edit ▸ Paste with masks on the clipboard: each is added, with a unique name, below the masks of
+/// every selected unlocked layer that can have masks, and the copies are selected (#2091).
+pub(crate) fn paste_masks(s: &mut Session, p: &Value) -> Result<Value> {
+    let c = "edit.paste";
+    let clip = s.state.mask_clipboard.clone();
+    let (cid, ids) = layers_p(s, p)?;
+    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+    let targets: Vec<LayerId> = ids.into_iter().filter(|l| comp.layer(*l).is_some_and(|l| l.masks().is_some() && !l.switches.locked)).collect();
+    if targets.is_empty() {
+        return Err(bad(c, "select an unlocked layer that can have masks to paste masks into"));
+    }
+    let label = match clip.as_slice() {
+        [g] => format!("Paste {}", g.name),
+        _ => "Paste".to_string(),
+    };
+    let pasted = s.edit(&label, None, |proj, st| {
+        let mut next = proj.next_id;
+        let mut out = vec![];
+        for lid in &targets {
+            let masks = layer_mut(proj, cid, *lid)?.props.sub_mut("masks").ok_or_else(|| bad(c, "the layer can't have masks"))?;
+            for g in &clip {
+                let mut g = g.clone();
+                g.reassign_uids(&mut next);
+                g.name = super::effect::unique_name(masks, &g.name);
+                out.push((*lid, g.uid));
+                masks.children.push(g.into());
+            }
+        }
+        proj.next_id = next + 1;
+        st.selected_props = out.clone();
+        // The source mask's points (selected with it) must not outlive its selection.
+        st.selected_vertices.clear();
+        Ok(out)
+    })?;
+    Ok(json!({"masks": pasted.iter().map(|(_, u)| *u).collect::<Vec<_>>()}))
+}
+
 /// Edit ▸ Cut's removal of the selected shape items (once copied).
 pub(crate) fn cut_contents(s: &mut Session, items: &[(LayerId, Uid)]) -> Result<Value> {
     let cid = s.active_comp_id().ok_or(EngineError::NoComp)?;
diff --git a/crates/engine/src/commands/proxy.rs b/crates/engine/src/cmd/proxy.rs
similarity index 94%
rename from crates/engine/src/commands/proxy.rs
rename to crates/engine/src/cmd/proxy.rs
index b7d644b94..58b147e89 100644
--- a/crates/engine/src/commands/proxy.rs
+++ b/crates/engine/src/cmd/proxy.rs
@@ -117,6 +117,7 @@ fn interpret_proxy(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad(C, "the selected items have no proxy"));
     }
     let it = super::file_more::Interpretation::parse(p, C)?;
+    it.check(items.iter().filter_map(|i| s.project.item(*i).and_then(|x| x.proxy.as_ref()).map(|px| &px.footage)), C)?;
     let guesses: Vec<_> = items
         .iter()
         .map(|i| {
@@ -190,6 +191,8 @@ fn create_proxy(s: &mut Session, p: &Value) -> Result<Value> {
     it.output.channels = Channels::Rgba;
     if let Some(o) = str_p(p, "path").or(str_p(p, "output")) {
         it.output.output = o.to_string();
+    } else {
+        s.avoid_sources(&mut it);
     }
     it.post_render = PostRenderAction::SetProxy;
     let id = s.edit("Create Proxy", None, |proj, _| {
@@ -229,7 +232,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Proxy...",
             ["File", "Interpret Footage"],
             None,
-            "{items?|item?, alpha?, matteColor?, invertAlpha?, frameRate?, loop?, pixelAspect?, fields?, colorProfile?, linearLight?}",
+            "{items?|item?, alpha?, guessAlpha?, matteColor?|premulColor?, invertAlpha?, frameRate?, loop?, pixelAspect?, fields?, colorProfile?, linearLight?, preserveRgb?, overrideStart?, startTimecode? (as file.interpretFootage), logConversion?, cineonUnits?, convertedBlack?, convertedWhite?, pointUnits?, tenBitBlack?, tenBitWhite?, currentGamma?, highlightRolloff? (Cineon Settings of DPX and Cineon proxies)}",
             has_proxy,
             interpret_proxy
         ),
diff --git a/crates/engine/src/commands/puppet.rs b/crates/engine/src/cmd/puppet.rs
similarity index 99%
rename from crates/engine/src/commands/puppet.rs
rename to crates/engine/src/cmd/puppet.rs
index 320e1d415..1d080e773 100644
--- a/crates/engine/src/commands/puppet.rs
+++ b/crates/engine/src/cmd/puppet.rs
@@ -38,7 +38,8 @@ pub fn puppet_eval(s: &Session, cid: ItemId, lid: LayerId, fx_uid: Uid, t: Tick)
     let fx = layer.effects()?;
     let index = fx.groups().position(|g| g.uid == fx_uid)?;
     let g = fx.groups().nth(index)?;
-    let ctx = EvalCtx { project: &s.project, comp_id: cid, comp, time: t, expr: s.expr.as_deref(), footage: None };
+    let ctx =
+        EvalCtx { project: &s.project, comp_id: cid, comp, time: t, expr: s.expr.as_deref(), footage: None, property_overrides: &[], media_overrides: &[] };
     let mut r = Renderer::new(&s.project, &*s.footage, RenderOpts::default());
     r.expr = s.expr.as_deref();
     r.cache = Some(&s.layer_cache);
diff --git a/crates/engine/src/commands/query.rs b/crates/engine/src/cmd/query.rs
similarity index 96%
rename from crates/engine/src/commands/query.rs
rename to crates/engine/src/cmd/query.rs
index 2ea8048fa..b80c9cffb 100644
--- a/crates/engine/src/commands/query.rs
+++ b/crates/engine/src/cmd/query.rs
@@ -46,11 +46,9 @@ fn summary(s: &mut Session, _: &Value) -> Result<Value> {
                 o["layers"] = json!(c.layers.len());
                 o["frameRate"] = json!(c.frame_rate.as_f64());
             }
-            // Footage that shows no picture although its file is there (a codec or profile the
-            // decoders lack): why, so an agent can tell the user.
-            if let ItemKind::Footage(f) = &i.kind
-                && let Some(why) = s.footage.problem(f)
-            {
+            // Footage (or the proxy in use) that shows no picture although its file is there (a
+            // codec or profile the decoders lack): why, so an agent can tell the user.
+            if let Some(why) = s.footage.item_problem(i) {
                 o["problem"] = json!(why);
             }
             o
@@ -129,6 +127,9 @@ fn group_json(g: &PropGroup, path: &str, l: &Layer, t: effectcraft_time::Tick, d
                         if let Some(e) = &p.expr {
                             o["expression"] = json!(e.text);
                         }
+                        if let Some(opts) = l.popup_options(p) {
+                            o["options"] = super::popup_options(&opts);
+                        }
                         o
                     }
                     Node::Group(g) => group_json(g, &cpath, l, t, depth + 1, max_depth),
diff --git a/crates/engine/src/commands/quick_offset.rs b/crates/engine/src/cmd/quick_offset.rs
similarity index 100%
rename from crates/engine/src/commands/quick_offset.rs
rename to crates/engine/src/cmd/quick_offset.rs
diff --git a/crates/engine/src/commands/relink.rs b/crates/engine/src/cmd/relink.rs
similarity index 100%
rename from crates/engine/src/commands/relink.rs
rename to crates/engine/src/cmd/relink.rs
diff --git a/crates/engine/src/commands/relink_moved.rs b/crates/engine/src/cmd/relink_moved.rs
similarity index 100%
rename from crates/engine/src/commands/relink_moved.rs
rename to crates/engine/src/cmd/relink_moved.rs
diff --git a/crates/engine/src/commands/render_queue.rs b/crates/engine/src/cmd/render_queue.rs
similarity index 93%
rename from crates/engine/src/commands/render_queue.rs
rename to crates/engine/src/cmd/render_queue.rs
index 09a7c7d2f..a3934c537 100644
--- a/crates/engine/src/commands/render_queue.rs
+++ b/crates/engine/src/cmd/render_queue.rs
@@ -203,25 +203,10 @@ fn apply_om_template(om: &mut OutputModule, t: &OutputModule) {
 }
 
 /// The `format` parameter's values.
-const FORMATS: &str = "format: h264|hevc|av1|prores|uncompressed|webm|png|jpeg|tiff|exr|gif|wav|aiff";
+const FORMATS: &str = "format: h264|hevc|av1|prores|uncompressed|webm|png|jpeg|tiff|exr|tga|gif|wav|aiff";
 
-/// Apply Output Module parameters (`template` first). `roi`: the viewer's region of interest
-/// (captured by `crop.useRoi`).
-fn apply_output(om: &mut OutputModule, templates: &RenderTemplates, roi: Option<[f64; 4]>, p: &Value, cmd: &str) -> Result<bool> {
-    let mut any = false;
-    if let Some(t) = str_p(p, "template") {
-        let t = templates.output_module(t).ok_or_else(|| bad(cmd, format!("no Output Module template “{t}”")))?;
-        apply_om_template(om, &t);
-        any = true;
-    }
-    let before = om.clone();
-    if let Some(f) = str_p(p, "format") {
-        let f = OutputFormat::from_name(f).ok_or_else(|| bad(cmd, FORMATS))?;
-        om.set_format(f);
-    }
-    // Before Channels: the WebM codec decides whether alpha can be written, so an explicit
-    // `channels: rgba` with `webmCodec: av1` is refused rather than dropped (#166).
-    any |= apply_codec_options(om, p, cmd)?;
+/// `channels` (refusing RGBA where the format has no alpha) and `color`/`alphaMode`.
+fn apply_channels_and_alpha(om: &mut OutputModule, p: &Value, cmd: &str) -> Result<()> {
     if let Some(c) = str_p(p, "channels") {
         om.channels = match c.to_ascii_lowercase().replace([' ', '+'], "").as_str() {
             "rgb" => Channels::Rgb,
@@ -244,21 +229,11 @@ fn apply_output(om: &mut OutputModule, templates: &RenderTemplates, roi: Option<
             _ => return Err(bad(cmd, "color: straight|premultiplied")),
         };
     }
-    if let Some(q) = f_p(p, "quality") {
-        om.quality = q.clamp(1.0, 100.0) as u8;
-    }
-    if let Some(b) = f_p(p, "bitrate") {
-        om.bitrate_kbps = b.clamp(50.0, 500_000.0) as u32;
-    }
-    if let Some(b) = b_p(p, "webmBitrate") {
-        om.webm_bitrate = b;
-    }
-    if let Some(k) = p.get("keyframeInterval").and_then(Value::as_u64) {
-        om.keyframe_interval = k.min(100_000) as u32;
-    }
-    if let Some(pp) = str_p(p, "proresProfile") {
-        om.prores_profile = ProResProfile::from_name(pp).ok_or_else(|| bad(cmd, "proresProfile: proxy|lt|standard|hq|4444|4444xq"))?;
-    }
+    Ok(())
+}
+
+/// `crop` plus the flat dialog keys (`cropTop`… and `resizeWidth`/`resizeHeight`).
+fn apply_crop(om: &mut OutputModule, roi: Option<[f64; 4]>, p: &Value, cmd: &str) -> Result<()> {
     match p.get("crop") {
         Some(Value::Bool(b)) => om.crop.enabled = *b,
         Some(Value::Object(c)) => {
@@ -298,6 +273,11 @@ fn apply_output(om: &mut OutputModule, templates: &RenderTemplates, roi: Option<
             om.resize.enabled = true;
         }
     }
+    Ok(())
+}
+
+/// `resize` (bool or object).
+fn apply_resize(om: &mut OutputModule, p: &Value, cmd: &str) -> Result<()> {
     match p.get("resize") {
         Some(Value::Bool(b)) => om.resize.enabled = *b,
         Some(Value::Object(r)) => {
@@ -328,6 +308,44 @@ fn apply_output(om: &mut OutputModule, templates: &RenderTemplates, roi: Option<
         Some(Value::Null) | None => {}
         Some(_) => return Err(bad(cmd, "resize: bool or {enabled?, preset?, width?, height?, lockAspect?, quality?: low|high}")),
     }
+    Ok(())
+}
+
+/// Apply Output Module parameters (`template` first). `roi`: the viewer's region of interest
+/// (captured by `crop.useRoi`).
+fn apply_output(om: &mut OutputModule, templates: &RenderTemplates, roi: Option<[f64; 4]>, p: &Value, cmd: &str) -> Result<bool> {
+    let mut any = false;
+    if let Some(t) = str_p(p, "template") {
+        let t = templates.output_module(t).ok_or_else(|| bad(cmd, format!("no Output Module template “{t}”")))?;
+        apply_om_template(om, &t);
+        any = true;
+    }
+    let before = om.clone();
+    if let Some(f) = str_p(p, "format") {
+        let f = OutputFormat::from_name(f).ok_or_else(|| bad(cmd, FORMATS))?;
+        om.set_format(f);
+    }
+    // Before Channels: the WebM codec decides whether alpha can be written, so an explicit
+    // `channels: rgba` with `webmCodec: av1` is refused rather than dropped (#166).
+    any |= apply_codec_options(om, p, cmd)?;
+    apply_channels_and_alpha(om, p, cmd)?;
+    if let Some(q) = f_p(p, "quality") {
+        om.quality = q.clamp(1.0, 100.0) as u8;
+    }
+    if let Some(b) = f_p(p, "bitrate") {
+        om.bitrate_kbps = b.clamp(50.0, 500_000.0) as u32;
+    }
+    if let Some(b) = b_p(p, "webmBitrate") {
+        om.webm_bitrate = b;
+    }
+    if let Some(k) = p.get("keyframeInterval").and_then(Value::as_u64) {
+        om.keyframe_interval = k.min(100_000) as u32;
+    }
+    if let Some(pp) = str_p(p, "proresProfile") {
+        om.prores_profile = ProResProfile::from_name(pp).ok_or_else(|| bad(cmd, "proresProfile: proxy|lt|standard|hq|4444|4444xq"))?;
+    }
+    apply_crop(om, roi, p, cmd)?;
+    apply_resize(om, p, cmd)?;
     if let Some(a) = p.get("audio") {
         om.audio = match a {
             Value::Bool(true) => AudioOutput::On,
@@ -532,6 +550,9 @@ fn add(s: &mut Session, p: &Value) -> Result<Value> {
         object.remove("template");
     }
     apply_output(&mut it.output, &templates, s.state.region_of_interest, &output_params, "renderQueue.add")?;
+    if str_p(p, "output").or(str_p(p, "path")).is_none() {
+        s.avoid_sources(&mut it);
+    }
     if let Some(l) = enum_p(p, "log", "renderQueue.add", RenderLog::parse, "errorsOnly|plusSettings|plusPerFrameInfo")? {
         it.log = l;
     }
@@ -601,7 +622,7 @@ fn set_output_module(s: &mut Session, p: &Value) -> Result<Value> {
         let (w, h) = item.settings.output_size(comp);
         let mut crop_only = om.clone();
         crop_only.resize.enabled = false;
-        let (cw, ch) = crop_only.frame_size(w, h, item.settings.resolution.clamp(0.01, 4.0));
+        let (cw, ch) = crop_only.frame_size(w, h, item.settings.effective_scale(comp));
         om.resize.width = ((om.resize.height as f64 * cw as f64 / ch as f64).round() as u32).clamp(1, 30_000);
     }
     let post = match str_p(p, "postRenderAction") {
@@ -678,8 +699,18 @@ fn render(s: &mut Session, p: &Value) -> Result<Value> {
     {
         log::warn!("{e}");
     }
+    let queued: std::collections::HashSet<u64> = s.project.render_queue.iter().filter(|i| i.is_queued()).map(|i| i.id).collect();
     let ids = s.start_render(wait).map_err(EngineError::Other)?;
-    let items: Vec<Value> = s.project.render_queue.iter().enumerate().filter(|(_, i)| ids.contains(&i.id)).map(|(k, i)| item_json(s, i, k)).collect();
+    // Source refusals fail before the exporter starts. Report them just like encoding
+    // failures, so CLI/MCP callers do not mistake a partly refused queue for full success.
+    let items: Vec<Value> = s
+        .project
+        .render_queue
+        .iter()
+        .enumerate()
+        .filter(|(_, i)| ids.contains(&i.id) || (queued.contains(&i.id) && matches!(i.status, RenderStatus::Failed(_))))
+        .map(|(k, i)| item_json(s, i, k))
+        .collect();
     Ok(json!({"rendering": s.is_rendering(), "items": items}))
 }
 
@@ -770,6 +801,9 @@ fn pre_render(s: &mut Session, p: &Value) -> Result<Value> {
     it.output = templates.default_output_module(TemplateSlot::PreRender);
     it.output.output = "[compName]_prerender.[fileExtension]".into();
     apply_output(&mut it.output, &templates, s.state.region_of_interest, p, "render.preRender")?;
+    if str_p(p, "output").or(str_p(p, "path")).is_none() {
+        s.avoid_sources(&mut it);
+    }
     it.post_render = PostRenderAction::ImportAndReplace;
     let id = s.edit("Pre-render", None, |proj, _| {
         it.id = proj.render_queue.iter().map(|i| i.id).max().unwrap_or(0) + 1;
@@ -795,6 +829,9 @@ fn save_current_preview(s: &mut Session, p: &Value) -> Result<Value> {
     let mut item = RenderQueueItem::new(0, cid);
     item.output = OutputModule::for_format(format);
     item.output.output = path.clone();
+    if let Some(refusal) = s.check_outputs(&[vec![(item.clone(), path.clone())]]).first() {
+        return Err(EngineError::Other(refusal.reason.clone()));
+    }
     let job = crate::ExportJob {
         project: &s.project,
         footage: s.footage.as_ref(),
@@ -999,7 +1036,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Add to Render Queue",
             ["Composition"],
             ["Cmd+M", "Cmd+Shift+/"],
-            "{comp?: id|name, template?: Render Settings template, format?: h264|hevc|av1|prores|uncompressed|webm|png|jpeg|tiff|exr|gif|wav|aiff, output?: path|template, log?: errorsOnly|plusSettings|plusPerFrameInfo, quality?: best|draft|1-100 (jpeg, webm), resolution?: full|half|third|quarter|scale, proxyUse?, effects?, solo?, guideLayers?, colorDepth?, frameBlending?, fieldRender?, pulldown?, motionBlur?, timeSpan?: workArea|comp|custom, start?: s, end?: s, duration?: s, frameRate?: fps|null, skipExisting?: bool, storageOverflow?: bool, channels?: rgb|rgba|alpha, color?, bitrate?: kbps, webmBitrate?, keyframeInterval?, proresProfile?, profile?, level?, rateControl?, webmCodec?, audioBitrate?, opusApplication?, crop?, resize?, includeProjectLink?, audio?: auto|on|off, sampleRate?, audioChannels?, audioFormat?, loop?: bool (values as in setRenderSettings / setOutputModule)}",
+            "{comp?: id|name, template?: Render Settings template, format?: h264|hevc|av1|prores|uncompressed|webm|png|jpeg|tiff|exr|tga|gif|wav|aiff, output?: path|template, log?: errorsOnly|plusSettings|plusPerFrameInfo, quality?: best|draft|1-100 (jpeg, webm), resolution?: full|half|third|quarter|scale, proxyUse?, effects?, solo?, guideLayers?, colorDepth?, frameBlending?, fieldRender?, pulldown?, motionBlur?, timeSpan?: workArea|comp|custom, start?: s, end?: s, duration?: s, frameRate?: fps|null, skipExisting?: bool, storageOverflow?: bool, channels?: rgb|rgba|alpha, color?, bitrate?: kbps, webmBitrate?, keyframeInterval?, proresProfile?, profile?, level?, rateControl?, webmCodec?, audioBitrate?, opusApplication?, crop?, resize?, includeProjectLink?, audio?: auto|on|off, sampleRate?, audioChannels?, audioFormat?, loop?: bool (values as in setRenderSettings / setOutputModule)}",
             can_add,
             add
         ),
@@ -1019,7 +1056,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Output Module Settings...",
             [],
             None,
-            "{item?|index?, module?: n (1 = first), template?: name, format?: h264|hevc|av1|prores|uncompressed|webm|png|jpeg|tiff|exr|gif|wav|aiff, channels?: rgb|rgba|alpha, color?: straight|premultiplied, quality?: 1-100, bitrate?: kbps, webmBitrate?: bool, keyframeInterval?: frames (0 = auto), proresProfile?: proxy|lt|standard|hq|4444|4444xq, profile?: main|main10 (HEVC/AV1), level?: auto|4.1, rateControl?: bitrate|quality, webmCodec?: vp9|av1, audioBitrate?: Opus kbps, opusApplication?: audio|voice, crop?: bool|{useRoi?, roi?, top?, left?, bottom?, right?}, cropTop?, cropLeft?, cropBottom?, cropRight?, resize?: bool|{preset?, width?, height?, lockAspect?, quality?: low|high}, resizeWidth?, resizeHeight?, postRenderAction?: none|import|importAndReplace|setProxy, includeProjectLink?: bool, audio?: auto|on|off, sampleRate?, audioChannels?: mono|stereo, audioFormat?: 16|24|32, loop?: bool, output?}",
+            "{item?|index?, module?: n (1 = first), template?: name, format?: h264|hevc|av1|prores|uncompressed|webm|png|jpeg|tiff|exr|tga|gif|wav|aiff, channels?: rgb|rgba|alpha, color?: straight|premultiplied, quality?: 1-100, bitrate?: kbps, webmBitrate?: bool, keyframeInterval?: frames (0 = auto), proresProfile?: proxy|lt|standard|hq|4444|4444xq, profile?: main|main10 (HEVC/AV1), level?: auto|4.1, rateControl?: bitrate|quality, webmCodec?: vp9|av1, audioBitrate?: Opus kbps, opusApplication?: audio|voice, crop?: bool|{useRoi?, roi?, top?, left?, bottom?, right?}, cropTop?, cropLeft?, cropBottom?, cropRight?, resize?: bool|{preset?, width?, height?, lockAspect?, quality?: low|high}, resizeWidth?, resizeHeight?, postRenderAction?: none|import|importAndReplace|setProxy, includeProjectLink?: bool, audio?: auto|on|off, sampleRate?, audioChannels?: mono|stereo, audioFormat?: 16|24|32, loop?: bool, output?}",
             has_items,
             set_output_module
         ),
diff --git a/crates/engine/src/commands/rig3d.rs b/crates/engine/src/cmd/rig3d.rs
similarity index 98%
rename from crates/engine/src/commands/rig3d.rs
rename to crates/engine/src/cmd/rig3d.rs
index f034fa641..dbcaa3c3c 100644
--- a/crates/engine/src/commands/rig3d.rs
+++ b/crates/engine/src/cmd/rig3d.rs
@@ -48,7 +48,16 @@ impl Env {
         Env { time: s.time_of(cid), expr: s.expr.clone(), footage: s.footage.clone() }
     }
     fn ctx<'a>(&'a self, proj: &'a Project, cid: ItemId, comp: &'a Comp) -> EvalCtx<'a> {
-        EvalCtx { project: proj, comp_id: cid, comp, time: self.time, expr: self.expr.as_deref(), footage: Some(self.footage.as_ref()) }
+        EvalCtx {
+            project: proj,
+            comp_id: cid,
+            comp,
+            time: self.time,
+            expr: self.expr.as_deref(),
+            footage: Some(self.footage.as_ref()),
+            property_overrides: &[],
+            media_overrides: &[],
+        }
     }
 }
 
@@ -268,7 +277,7 @@ fn stereo_rig(s: &mut Session, p: &Value) -> Result<Value> {
             set_expr(&mut cam, "cameraOptions/zoom", ze);
             cam.auto_orient = AutoOrient::TowardsPointOfInterest;
             let comp = proj.comp_mut(eid).ok_or(EngineError::NoComp)?;
-            comp.layers = vec![cam, nest];
+            comp.layers = vec![cam, nest].into();
             eye_comps.push(eid);
         }
         // The output comp: both eyes through 3D Glasses.
@@ -291,7 +300,7 @@ fn stereo_rig(s: &mut Session, p: &Value) -> Result<Value> {
             fxg.children.push(g.into());
         }
         let (lid, rid) = (left.id, right.id);
-        proj.comp_mut(oid).ok_or(EngineError::NoComp)?.layers = vec![left, right];
+        proj.comp_mut(oid).ok_or(EngineError::NoComp)?.layers = vec![left, right].into();
         st.project_selection = vec![oid];
         Ok(json!({
             "controls": ctl_id.0,
diff --git a/crates/engine/src/commands/roto_cmds.rs b/crates/engine/src/cmd/roto_cmds.rs
similarity index 90%
rename from crates/engine/src/commands/roto_cmds.rs
rename to crates/engine/src/cmd/roto_cmds.rs
index a6d389ca1..792c60019 100644
--- a/crates/engine/src/commands/roto_cmds.rs
+++ b/crates/engine/src/cmd/roto_cmds.rs
@@ -27,7 +27,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Roto Brush Stroke",
             [],
             None,
-            "{layer?, kind?: fg|bg|refine|refineErase, points: [[x, y], …] (layer pixels), frame? (layer frame; default current), radius? (layer px; default the tool's diameter / 2), effect?}",
+            "{layer?, kind?: fg|bg|refine|refineErase, points: [[x, y], …] (layer pixels), frame? (layer frame; default current), radius? (layer px; default the tool's diameter / 2), effect?, object? (0–31; default the current object: with a tracker each object is followed on its own and the mattes are united)}",
             has_comp,
             stroke
         ),
@@ -43,14 +43,22 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!("roto.span", "Set Segmentation Span", [], None, "{layer?, effect?, start?, end? (layer frames)}", has_comp, span),
         cmd!("roto.freeze", "Freeze", [], None, "{layer?, effect?, wait?}", has_comp, freeze),
         cmd!("roto.unfreeze", "Unfreeze", [], None, "{layer?, effect?}", has_comp, unfreeze),
-        cmd!("roto.clearStrokes", "Remove Roto Brush Strokes", [], None, "{layer?, effect?, frame? (only this layer frame), kind?}", has_comp, clear_strokes),
+        cmd!(
+            "roto.clearStrokes",
+            "Remove Roto Brush Strokes",
+            [],
+            None,
+            "{layer?, effect?, frame? (only this layer frame), kind?, object? (only this object's strokes)}",
+            has_comp,
+            clear_strokes
+        ),
         cmd!("roto.cancel", "Stop Roto Brush", [], None, "{}", is_running, |s, _| Ok(json!({"stopped": s.stop_roto()}))),
         cmd!(
             "roto.options",
             "Roto Brush Options",
             [],
             None,
-            "{diameter?, refineDiameter?, view?: alphaBoundary|alpha|alphaOverlay|none, overlayColor?: [r,g,b], overlayOpacity?, boundaryColor?: [r,g,b], autoPropagate?}",
+            "{diameter?, refineDiameter?, view?: alphaBoundary|alpha|alphaOverlay|none, overlayColor?: [r,g,b], overlayOpacity?, boundaryColor?: [r,g,b], autoPropagate?, object? (the object new strokes belong to, 0–31)}",
             always,
             options
         ),
@@ -196,6 +204,8 @@ fn points_p(p: &Value, cmd: &str) -> Result<Vec<[f64; 2]>> {
 
 fn stroke(s: &mut Session, p: &Value) -> Result<Value> {
     let cmd = "roto.stroke";
+    // A model unloaded for being idle comes back before the stroke is segmented with it.
+    s.reload_roto_model();
     let (cid, lid) = match roto_p(s, p, cmd) {
         Ok((c, l, _)) => (c, l),
         Err(_) => layer_p(s, p, cmd)?,
@@ -230,7 +240,8 @@ fn stroke(s: &mut Session, p: &Value) -> Result<Value> {
     if existing.is_none() && !kind.is_segmentation() {
         return Err(bad(cmd, "draw a foreground stroke with the Roto Brush tool first"));
     }
-    let st = Stroke { kind, frame, radius, points };
+    let object = f_p(p, "object").map_or(s.state.roto.object, |v| v.clamp(0.0, rt::MAX_OBJECT_ID as f64).round() as u32);
+    let st = Stroke { kind, frame, radius, points, object };
     let label = if kind.is_segmentation() { "Roto Brush Stroke" } else { "Refine Edge Stroke" };
     let (uid, d) = s.edit(label, None, |proj, _| {
         let mut next = proj.next_id;
@@ -261,7 +272,7 @@ fn stroke(s: &mut Session, p: &Value) -> Result<Value> {
         s.state.selected_layers = vec![lid];
     }
     Ok(json!({
-        "layer": lid.0, "effect": uid, "frame": frame, "kind": kind, "radius": radius,
+        "layer": lid.0, "effect": uid, "frame": frame, "kind": kind, "radius": radius, "object": object,
         "base": d.base, "span": d.span, "strokes": d.strokes.len(),
     }))
 }
@@ -367,8 +378,20 @@ fn clear_strokes(s: &mut Session, p: &Value) -> Result<Value> {
         Some(k) => Some(StrokeKind::from_name(k).ok_or_else(|| bad(cmd, format!("unknown kind `{k}`")))?),
         None => None,
     };
+    let object = match p.get("object") {
+        None => None,
+        Some(value) => {
+            let value = value
+                .as_f64()
+                .filter(|v| v.is_finite() && (0.0..=rt::MAX_OBJECT_ID as f64).contains(v))
+                .ok_or_else(|| bad(cmd, format!("`object` is 0–{}", rt::MAX_OBJECT_ID)))?;
+            Some(value.round() as u32)
+        }
+    };
     let n0 = d.strokes.len();
-    d.strokes.retain(|st| !(frame.is_none_or(|f| st.frame == f) && kind.is_none_or(|k| st.kind == k)));
+    d.strokes.retain(|st| {
+        !(frame.is_none_or(|f| st.frame == f) && kind.is_none_or(|k| st.kind == k) && object.is_none_or(|o| st.kind.is_segmentation() && st.object == o))
+    });
     if d.strokes.iter().all(|s| !s.kind.is_segmentation()) {
         d.base = None;
     } else if d.base.is_some_and(|b| !d.strokes.iter().any(|s| s.frame == b && s.kind.is_segmentation())) {
@@ -410,6 +433,9 @@ fn options(s: &mut Session, p: &Value) -> Result<Value> {
     if let Some(b) = b_p(p, "autoPropagate") {
         o.auto_propagate = b;
     }
+    if let Some(v) = f_p(p, "object") {
+        o.object = v.clamp(0.0, rt::MAX_OBJECT_ID as f64).round() as u32;
+    }
     s.state.roto = o.clone();
     Ok(serde_json::to_value(o).unwrap_or(Value::Null))
 }
@@ -428,9 +454,13 @@ fn status(s: &mut Session, p: &Value) -> Result<Value> {
     out["base"] = json!(d.base);
     out["span"] = json!(d.span);
     out["strokes"] = json!(d.strokes.len());
+    out["objects"] = json!(d.objects().iter().map(|o| json!({"id": o, "strokes": d.strokes.iter().filter(|s| s.object == *o).count()})).collect::<Vec<_>>());
+    out["currentObject"] = json!(s.state.roto.object);
     out["strokeFrames"] = json!(d.stroke_frames());
     out["frozen"] = json!(frozen_of(&g));
     out["pending"] = json!(s.roto_pending.contains(&(cid, lid, uid)));
+    // The model Settings chose and whether this layer segments with it (propagate refuses or waits otherwise).
+    out["model"] = s.roto_model();
     out["limits"] = json!(rt::frame_limits(&comp, &layer));
     let frame = frame_p(s, p, cid, &layer);
     out["frame"] = json!(frame);
@@ -441,7 +471,7 @@ fn status(s: &mut Session, p: &Value) -> Result<Value> {
         let fps = comp.frame_rate.as_f64();
         let ps = params_static(&g);
         let chain = fx::Chain::new(&ps, size, fps, 1.0);
-        let seg = match chain.keys.get(&frame).and_then(|k| fx::cached(*k, 1.0)) {
+        let seg = match chain.cached_seg(frame, 1.0) {
             Some(sg) => Some(sg),
             None if compute => {
                 let index = layer.effects().and_then(|f| f.groups().position(|x| x.uid == uid)).unwrap_or(0);
@@ -463,6 +493,28 @@ fn status(s: &mut Session, p: &Value) -> Result<Value> {
             }
         }
     }
+    // Where each frame's matte came from, and how far to trust it: frames a tracker followed
+    // report its confidence and whether the object was absent; frames the model segmented on
+    // their own report "model"; the rest came from the classic engine.
+    {
+        let size = rt::layer_size(&s.project, &comp, &layer);
+        let chain = fx::Chain::new(&params_static(&g), size, comp.frame_rate.as_f64(), 1.0);
+        let tracked: serde_json::Map<String, Value> = chain
+            .keys
+            .keys()
+            .filter_map(|f| chain.trust_at(*f).map(|t| (f.to_string(), json!({"confidence": t.confidence, "occluded": t.occluded}))))
+            .collect();
+        out["tracker"] = json!({"model": s.models_roto_active(), "device": fx::installed_model().and_then(|m| m.device_name()), "saved": chain.saved_model(), "frames": tracked});
+        let notice = s.roto_model_notice(s.uses_roto_model(cid, lid, uid)).or_else(|| s.saved_tracking_notice(chain.saved_model()));
+        out["notice"] = json!(notice);
+        out["source"] = json!(if tracked.contains_key(&frame.to_string()) {
+            "tracker"
+        } else if chain.model.is_some() {
+            "model"
+        } else {
+            "classical"
+        });
+    }
     let computed = s.roto_computed(cid, lid, uid);
     out["computed"] = json!(computed.iter().filter(|(_, c)| **c).map(|(f, _)| *f).collect::<Vec<_>>());
     Ok(out)
diff --git a/crates/engine/src/commands/scene_detect.rs b/crates/engine/src/cmd/scene_detect.rs
similarity index 100%
rename from crates/engine/src/commands/scene_detect.rs
rename to crates/engine/src/cmd/scene_detect.rs
diff --git a/crates/engine/src/cmd/schema.rs b/crates/engine/src/cmd/schema.rs
new file mode 100644
index 000000000..c74ab277e
--- /dev/null
+++ b/crates/engine/src/cmd/schema.rs
@@ -0,0 +1,119 @@
+use super::params::bad;
+use super::{CommandSpec, Result, Value};
+
+// ---------- parameter validation (agents) ----------
+
+/// Top-level keys accepted by a params doc such as `{layers: [id|name|#n], add?, toggle?}` or
+/// `{time? (s) | frame? | timecode?}`; `None` when the doc isn't a `{…}` key list.
+pub fn accepted_params(doc: &str) -> Option<Vec<String>> {
+    let body = doc.trim().strip_prefix('{')?;
+    // Top-level pieces up to the matching close brace, split at `,` and `|`; `:` starts a value.
+    let (mut keys, mut cur, mut depth, mut in_value) = (Vec::new(), String::new(), 0i32, false);
+    let push = |cur: &mut String, keys: &mut Vec<String>| {
+        let k: String = cur.trim().chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '_').collect();
+        if !k.is_empty() && !keys.contains(&k) {
+            keys.push(k);
+        }
+        cur.clear();
+    };
+    for c in body.chars() {
+        match c {
+            '{' | '[' | '(' => depth += 1,
+            ']' | ')' => depth -= 1,
+            '}' if depth == 0 => {
+                push(&mut cur, &mut keys);
+                return Some(keys);
+            }
+            '}' => depth -= 1,
+            ',' if depth == 0 => {
+                push(&mut cur, &mut keys);
+                in_value = false;
+            }
+            '|' if depth == 0 && !in_value => push(&mut cur, &mut keys),
+            ':' if depth == 0 => {
+                push(&mut cur, &mut keys);
+                in_value = true;
+            }
+            _ if depth == 0 && !in_value => cur.push(c),
+            _ => {}
+        }
+    }
+    None
+}
+
+/// Top-level pieces of a params doc (split at depth-0 commas), e.g. `{layer?, path|prop, value}`
+/// → `["layer?", "path|prop", "value"]`.
+fn doc_pieces(doc: &str) -> Option<Vec<String>> {
+    let body = doc.trim().strip_prefix('{')?;
+    let (mut out, mut cur, mut depth) = (Vec::new(), String::new(), 0i32);
+    for c in body.chars() {
+        match c {
+            '{' | '[' | '(' => depth += 1,
+            ']' | ')' => depth -= 1,
+            '}' if depth == 0 => {
+                if !cur.trim().is_empty() {
+                    out.push(cur.trim().to_string());
+                }
+                return Some(out);
+            }
+            '}' => depth -= 1,
+            ',' if depth == 0 => {
+                if !cur.trim().is_empty() {
+                    out.push(cur.trim().to_string());
+                }
+                cur.clear();
+                continue;
+            }
+            _ => {}
+        }
+        cur.push(c);
+    }
+    None
+}
+
+/// The JSON Schema of a command's parameters, derived from its params doc: one property per
+/// accepted key (described by its piece of the doc), no others. MCP `describe_command` and
+/// `list_commands {schemas: true}` serve it.
+pub fn params_schema(spec: &CommandSpec) -> Value {
+    let mut props = serde_json::Map::new();
+    let mut required = vec![];
+    for piece in doc_pieces(spec.params).unwrap_or_default() {
+        let keys = accepted_params(&format!("{{{piece}}}")).unwrap_or_default();
+        let alternatives = keys.len() > 1;
+        for k in keys {
+            // `key?` is optional; so is any key with alternatives (`path|prop`).
+            let optional = alternatives || piece.contains(&format!("{k}?"));
+            if !optional && !required.contains(&k) {
+                required.push(k.clone());
+            }
+            props.insert(k, serde_json::json!({"description": piece}));
+        }
+    }
+    serde_json::json!({
+        "type": "object",
+        "description": spec.params,
+        "properties": props,
+        "required": required,
+        "additionalProperties": accepted_params(spec.params).is_none(),
+    })
+}
+
+/// Keys every command understands (comp targeting, gesture merging) and accepted aliases.
+const ALWAYS_OK: &[&str] = &["comp", "merge"];
+
+const ALIASES: &[(&str, &str)] = &[("layers", "layer"), ("layer", "layers"), ("time", "frame"), ("frameRate", "fps"), ("properties", "property")];
+
+/// Reject unknown top-level parameters (typos, guessed names) with the list of accepted keys.
+pub fn check_params(spec: &CommandSpec, params: &Value) -> Result<()> {
+    let (Some(obj), Some(accepted)) = (params.as_object(), accepted_params(spec.params)) else { return Ok(()) };
+    let ok = |k: &str| ALWAYS_OK.contains(&k) || accepted.iter().any(|a| a == k || ALIASES.iter().any(|(doc, alias)| doc == a && *alias == k));
+    let unknown: Vec<&str> = obj.keys().map(String::as_str).filter(|k| !ok(k)).collect();
+    if unknown.is_empty() {
+        return Ok(());
+    }
+    let list = if accepted.is_empty() { "none".to_string() } else { accepted.join(", ") };
+    Err(bad(
+        spec.id,
+        format!("unknown parameter(s) {}; accepted: {list} (doc: {})", unknown.iter().map(|k| format!("`{k}`")).collect::<Vec<_>>().join(", "), spec.params),
+    ))
+}
diff --git a/crates/engine/src/cmd/scripts.rs b/crates/engine/src/cmd/scripts.rs
new file mode 100644
index 000000000..8c14e03ec
--- /dev/null
+++ b/crates/engine/src/cmd/scripts.rs
@@ -0,0 +1,1134 @@
+//! File ▸ Scripts and ScriptUI.
+//!
+//! * **Installed scripts** live in the settings store under `Scripts/` (File ▸ Scripts ▸ Install
+//!   Script File…) and `Scripts/ScriptUI Panels/` (Install ScriptUI Panel…), next to the
+//!   settings on the desktop, so dropping `.jsx` files in those folders works too. File ▸ Scripts
+//!   lists them with the bundled sample scripts and extensions ([`BUNDLED`]) and runs them by name; ScriptUI
+//!   panels appear at the bottom of the Window menu and open as dockable panels
+//!   (`window.scriptPanel`), running with `this` = the panel as in After Effects. A subfolder of
+//!   either folder (one level) is a submenu named after it; its scripts are named `Folder/File.jsx`.
+//! * **Startup and Shutdown scripts** in `Scripts/Startup/` and `Scripts/Shutdown/` run by
+//!   themselves, in alphabetical order: at launch (`file.runStartupScripts`) and as EffectCraft
+//!   quits, after the project is closed (`file.runShutdownScripts`).
+//! * **ScriptUI windows** (`scriptui.*`): list the open script windows, read their control
+//!   trees, click buttons and set values like a user, close them (see [`crate::scriptui`]).
+//! * **Script settings** (`script.settings.*`): After Effects' `app.settings`, string values by
+//!   section and key that last between runs ([`SCRIPT_SETTINGS_FILE`]).
+
+use std::collections::BTreeMap;
+
+use serde::Serialize;
+use serde_json::{Value, json};
+
+use super::{CommandSpec, always, bad, str_p};
+use crate::{EngineError, Event, Result, Session, cmd, scriptui};
+
+/// The settings-store folders of installed scripts.
+pub const SCRIPTS_DIR: &str = "Scripts";
+pub const PANELS_DIR: &str = "Scripts/ScriptUI Panels";
+/// The settings-store folders whose scripts run at launch and as EffectCraft quits.
+pub const STARTUP_DIR: &str = "Scripts/Startup";
+pub const SHUTDOWN_DIR: &str = "Scripts/Shutdown";
+/// Commands that run script files or script code (a ScriptUI panel runs its script when it
+/// opens). Scripts and batches can't run them, and confined automation sessions refuse them.
+pub const RUNS_SCRIPTS: &[&str] =
+    &["script.run", "file.runScript", "file.runStartupScripts", "file.runShutdownScripts", "window.scriptPanel", "window.restoreScriptPanels"];
+/// Largest script file the Startup and Shutdown folders run (bytes), as `#include` and
+/// `$.evalFile` allow.
+const MAX_SCRIPT_BYTES: usize = 16 << 20;
+/// Modal dialogs a Shutdown script may open one after another; each closes as if canceled.
+const MAX_SHUTDOWN_DIALOGS: usize = 64;
+/// [`PANELS_DIR`]'s name in [`SCRIPTS_DIR`]: it holds the panels, so it is not a folder of scripts.
+const PANELS_FOLDER: &str = "ScriptUI Panels";
+/// Subfolders of Scripts that hold scripts the app runs itself (panels; launch and quit, as in
+/// After Effects): never listed as File ▸ Scripts submenus.
+const RESERVED_FOLDERS: [&str; 3] = [PANELS_FOLDER, "Startup", "Shutdown"];
+/// The ScriptUI panels open when EffectCraft last quit (settings store), reopened at launch.
+pub const OPEN_PANELS_FILE: &str = "scriptui_panels.json";
+/// Scripts' `app.settings` in the settings store: `{section: {key: value}}`, as After Effects
+/// keeps them in its preferences.
+pub const SCRIPT_SETTINGS_FILE: &str = "script_settings.json";
+/// User presets of the core Ease Presets panel of v0.6.0 (#254) and where the Ease Presets
+/// ScriptUI panel that replaced it keeps them: (file, section, key). The file's text moves there
+/// unchanged (the panel reads the same JSON) the first time settings load.
+const LEGACY_EASE_PRESETS: (&str, &str, &str) = ("ease_presets.json", "Ease Presets", "userPresets");
+/// Longest section, key and value a script may store (characters / bytes).
+const MAX_SETTING_NAME: usize = 256;
+const MAX_SETTING_VALUE: usize = 1 << 20;
+
+/// Scripts' `app.settings`: values by section and key.
+pub type ScriptSettings = BTreeMap<String, BTreeMap<String, String>>;
+
+/// Load scripts' settings from the settings store (a corrupt file gives none), moving user ease
+/// presets saved before Ease Presets became a ScriptUI panel into its section.
+pub(crate) fn load_script_settings(s: &mut Session) {
+    let Some(cfg) = s.config.clone() else { return };
+    s.script_settings = cfg
+        .read(SCRIPT_SETTINGS_FILE)
+        .and_then(|t| serde_json::from_str(&t).map_err(|e| log::warn!("{SCRIPT_SETTINGS_FILE} is not valid ({e}); scripts start without their settings")).ok())
+        .unwrap_or_default();
+    let (file, section, key) = LEGACY_EASE_PRESETS;
+    if let Some(text) = cfg.read(file)
+        && !s.script_settings.get(section).is_some_and(|m| m.contains_key(key))
+    {
+        s.script_settings.entry(section.into()).or_default().insert(key.into(), text);
+        if let Err(e) = store_script_settings(s) {
+            log::warn!("cannot move {file} into the Ease Presets panel's settings: {e}");
+        }
+    }
+}
+
+fn store_script_settings(s: &Session) -> Result<()> {
+    let Some(cfg) = &s.config else { return Ok(()) };
+    let text = serde_json::to_string_pretty(&s.script_settings).map_err(|e| EngineError::Other(format!("script settings: {e}")))?;
+    cfg.write(SCRIPT_SETTINGS_FILE, &text).map_err(|e| EngineError::Other(format!("cannot save script settings: {e}")))
+}
+
+fn setting_name<'a>(p: &'a Value, k: &str, c: &str) -> Result<&'a str> {
+    let v = str_p(p, k).ok_or_else(|| bad(c, format!("missing `{k}`")))?;
+    if v.chars().count() > MAX_SETTING_NAME {
+        return Err(bad(c, format!("`{k}` is longer than {MAX_SETTING_NAME} characters")));
+    }
+    Ok(v)
+}
+
+/// `script.settings.get {section, key}` → `{have, value}` (`value` "" when there is none).
+fn settings_get(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "script.settings.get";
+    let (section, key) = (setting_name(p, "section", C)?, setting_name(p, "key", C)?);
+    let v = s.script_settings.get(section).and_then(|m| m.get(key));
+    Ok(json!({"have": v.is_some(), "value": v.cloned().unwrap_or_default()}))
+}
+
+/// `script.settings.save {section, key, value}`: kept in the settings store.
+fn settings_save(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "script.settings.save";
+    let (section, key) = (setting_name(p, "section", C)?, setting_name(p, "key", C)?);
+    let value = match p.get("value") {
+        Some(Value::String(v)) => v.clone(),
+        Some(v) if !v.is_null() => v.to_string(),
+        _ => return Err(bad(C, "missing `value`")),
+    };
+    if value.len() > MAX_SETTING_VALUE {
+        return Err(bad(C, format!("`value` is larger than {MAX_SETTING_VALUE} bytes")));
+    }
+    s.script_settings.entry(section.into()).or_default().insert(key.into(), value);
+    store_script_settings(s)?;
+    Ok(Value::Null)
+}
+
+/// Scripts that ship with EffectCraft (original work): (file name, ScriptUI panel, source, code).
+/// `sample`s show how to script EffectCraft; `extension`s (in `extensions/`) are optional tools
+/// built on the public scripting API, outside the core, like third-party scripts in After Effects.
+pub const BUNDLED: &[(&str, bool, &str, &str)] = &[
+    ("Create Null at Selected Layers.jsx", false, "sample", include_str!("../../scripts/Create Null at Selected Layers.jsx")),
+    ("Rename Layers.jsx", false, "sample", include_str!("../../scripts/Rename Layers.jsx")),
+    ("Render Queue Batch.jsx", false, "sample", include_str!("../../scripts/Render Queue Batch.jsx")),
+    ("Sort Layers by In Point.jsx", false, "sample", include_str!("../../scripts/Sort Layers by In Point.jsx")),
+    ("Layer Tools.jsx", true, "sample", include_str!("../../scripts/ScriptUI Panels/Layer Tools.jsx")),
+    ("Ease Presets.jsx", true, "extension", include_str!("../../../../extensions/scriptui-panels/Ease Presets.jsx")),
+];
+
+/// A script File ▸ Scripts (or the Window menu, for panels) offers.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct ScriptEntry {
+    /// File name (`Rename Layers.jsx`), or `Folder/File.jsx` in a subfolder: what commands take.
+    pub name: String,
+    /// In the ScriptUI Panels folder: opens as a dockable panel.
+    pub panel: bool,
+    /// `installed`, `sample` or `extension` (bundled, see [`BUNDLED`]).
+    pub source: &'static str,
+}
+
+/// Whether `name` ends in `.jsx` or `.js` (any letter case).
+fn is_script(name: &str) -> bool {
+    let l = name.to_ascii_lowercase();
+    l.ends_with(".jsx") || l.ends_with(".js")
+}
+
+/// Whether `name` can name an installed script: a file name, or `Folder/File` for one in a
+/// subfolder of a Scripts folder (one level, and not one of [`RESERVED_FOLDERS`]: `ScriptUI
+/// Panels/…`, `Startup/…`, `Shutdown/…`). Each part is a bare name, never a path (names are joined onto the Scripts folders of
+/// the settings store, which takes them as relative paths), and on Windows none of the names
+/// [`windows_unsafe_name`] lists.
+fn is_script_name(name: &str) -> bool {
+    let part = |n: &str| is_bare_name(n) && !(cfg!(windows) && windows_unsafe_name(n));
+    match name.split_once('/') {
+        Some((folder, file)) => part(folder) && part(file) && !RESERVED_FOLDERS.iter().any(|r| folder.eq_ignore_ascii_case(r)),
+        None => part(name),
+    }
+}
+
+/// One path component on every platform: not empty, `.` or `..`, and without `/`, `\` or NUL.
+pub(crate) fn is_bare_name(name: &str) -> bool {
+    !name.is_empty() && name != "." && name != ".." && !name.contains(['/', '\\', '\0'])
+}
+
+/// Names that are not ordinary file names on Windows (elsewhere they are): with `:` (a drive or a
+/// stream), ending in `.` or a space (Windows drops them), or a device name, which names a device
+/// in any folder and with any extension (`con.jsx`): `CON`, `PRN`, `AUX`, `NUL`, `CONIN$`,
+/// `CONOUT$`, `COM0`–`COM9` and `LPT0`–`LPT9` (also with `¹²³`).
+pub(crate) fn windows_unsafe_name(name: &str) -> bool {
+    let stem = name.split('.').next().unwrap_or_default().trim_end_matches(' ').to_ascii_uppercase();
+    let port = |p: &str| {
+        let mut n = stem.strip_prefix(p).unwrap_or_default().chars();
+        matches!((n.next(), n.next()), (Some('0'..='9' | '¹' | '²' | '³'), None))
+    };
+    let device = matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL" | "CONIN$" | "CONOUT$") || port("COM") || port("LPT");
+    name.contains(':') || name.ends_with(['.', ' ']) || device
+}
+
+/// Installed scripts and panels, then the bundled ones not shadowed by an installed one, by name.
+pub fn scripts(s: &Session) -> Vec<ScriptEntry> {
+    let mut v: Vec<ScriptEntry> = vec![];
+    if let Some(cfg) = &s.config {
+        for (dir, panel) in [(SCRIPTS_DIR, false), (PANELS_DIR, true)] {
+            // The folder itself, then each subfolder, whose scripts are named `Folder/File.jsx`.
+            let subfolders = cfg.list_dirs(dir).into_iter().map(|f| (format!("{dir}/{f}"), format!("{f}/")));
+            for (folder, prefix) in std::iter::once((dir.to_string(), String::new())).chain(subfolders) {
+                let names = cfg.list(&folder).into_iter().map(|n| format!("{prefix}{n}"));
+                for n in names.filter(|n| is_script(n) && is_script_name(n)) {
+                    v.push(ScriptEntry { name: n, panel, source: "installed" });
+                }
+            }
+        }
+    }
+    for (name, panel, source, _) in BUNDLED {
+        if !v.iter().any(|e| e.name == *name && e.panel == *panel) {
+            v.push(ScriptEntry { name: name.to_string(), panel: *panel, source });
+        }
+    }
+    v.sort_by(|a, b| a.panel.cmp(&b.panel).then(a.name.to_lowercase().cmp(&b.name.to_lowercase())));
+    v
+}
+
+/// The code of an installed or bundled script / panel.
+pub fn script_code(s: &Session, name: &str, panel: Option<bool>) -> Option<(bool, String)> {
+    if !is_script(name) || !is_script_name(name) {
+        return None;
+    }
+    if let Some(cfg) = &s.config {
+        for (dir, is_panel) in [(SCRIPTS_DIR, false), (PANELS_DIR, true)] {
+            if panel.is_some_and(|p| p != is_panel) {
+                continue;
+            }
+            if let Some(code) = cfg.read(&format!("{dir}/{name}")) {
+                return Some((is_panel, code));
+            }
+        }
+    }
+    BUNDLED.iter().find(|(n, p, ..)| *n == name && panel.is_none_or(|w| w == *p)).map(|(_, p, _, c)| (*p, c.to_string()))
+}
+
+fn install(s: &mut Session, p: &Value, panel: bool) -> Result<Value> {
+    let c = if panel { "file.installScriptUIPanel" } else { "file.installScript" };
+    let path = str_p(p, "path").ok_or_else(|| bad(c, "missing `path` (a .jsx / .js script)"))?;
+    let name = std::path::Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();
+    if !is_script(&name) {
+        return Err(bad(c, "scripts are .jsx or .js files (.jsxbin is not supported)"));
+    }
+    // A name it could not be run or uninstalled by (`\` is a file-name character on Unix).
+    if !is_script_name(&name) {
+        return Err(bad(c, format!("`{name}` is not a script file name")));
+    }
+    let bytes = s.services.read_file(path).map_err(|e| EngineError::Other(format!("cannot read {path}: {e}")))?;
+    let code = String::from_utf8(bytes).map_err(|_| bad(c, "the script is not UTF-8 text"))?;
+    let cfg = s.config.clone().ok_or_else(|| EngineError::Other("this session has no settings folder to install scripts into".into()))?;
+    let dir = if panel { PANELS_DIR } else { SCRIPTS_DIR };
+    cfg.write(&format!("{dir}/{name}"), &code).map_err(|e| EngineError::Other(format!("cannot install {name}: {e}")))?;
+    s.scripts_changed();
+    // After Effects asks for a restart; our menus pick it up at once.
+    s.toast(if panel {
+        format!("Installed ScriptUI panel {name}: find it at the bottom of the Window menu")
+    } else {
+        format!("Installed script {name}: find it in File ▸ Scripts")
+    });
+    Ok(json!({"name": name, "panel": panel}))
+}
+
+fn list(s: &mut Session, _: &Value) -> Result<Value> {
+    Ok(json!(scripts(s)))
+}
+
+/// `file.uninstallScript {name}`: delete an installed script or panel at the top of the Scripts
+/// folders.
+fn uninstall(s: &mut Session, p: &Value) -> Result<Value> {
+    let c = "file.uninstallScript";
+    let name = str_p(p, "name").ok_or_else(|| bad(c, "missing `name`"))?;
+    if !is_script(name) || !is_script_name(name) {
+        return Err(bad(c, format!("`{name}` is not a script file name")));
+    }
+    // A subfolder can be a link to files outside the settings folder (an extension's own
+    // folder), so only what Install puts at the top is removed, never a file through a folder.
+    if name.contains('/') {
+        return Err(bad(c, format!("`{name}` is in a subfolder: delete it there yourself (only scripts at the top of the Scripts folders are uninstalled)")));
+    }
+    let cfg = s.config.clone().ok_or_else(|| bad(c, "no settings folder"))?;
+    let mut removed = false;
+    for dir in [SCRIPTS_DIR, PANELS_DIR] {
+        let key = format!("{dir}/{name}");
+        if cfg.read(&key).is_some() {
+            cfg.remove(&key).map_err(|e| EngineError::Other(e.to_string()))?;
+            removed = true;
+        }
+    }
+    s.scripts_changed();
+    if removed { Ok(json!({"removed": name})) } else { Err(bad(c, format!("`{name}` is not installed"))) }
+}
+
+/// Run an installed or bundled script by name (File ▸ Scripts ▸ `<name>`). A ScriptUI panel run
+/// this way gets `this` = a floating palette-like panel window. A script listed under File ▸
+/// Scripts runs before a panel of the same name.
+pub(crate) fn run_named(s: &mut Session, name: &str) -> Result<Value> {
+    let found = script_code(s, name, Some(false)).or_else(|| script_code(s, name, None));
+    let (panel, code) = found.ok_or_else(|| bad("file.runScript", format!("no installed or bundled script `{name}`")))?;
+    if panel {
+        return open_panel(s, &json!({"name": name}));
+    }
+    let result = super::file_more::run_js_named(s, &code, name)?;
+    super::file_more::remember_script(s, crate::prefs::RecentScript::Name(name.to_string()));
+    Ok(result)
+}
+
+/// The code a ScriptUI panel runs with: `this` is a dockable Panel titled after the script.
+pub fn panel_wrapper(title: &str, code: &str) -> String {
+    // On one line, so line numbers in errors stay those of the file.
+    format!("(function () {{ {code}\n}}).call(__uiDockPanel({}));", Value::String(title.to_string()))
+}
+
+/// The ScriptUI panels open now (script names).
+pub(crate) fn open_panel_names(s: &Session) -> Vec<String> {
+    s.script_ui.windows.iter().filter(|w| w.kind == scriptui::WindowKind::Panel).map(|w| w.script.clone()).collect()
+}
+
+/// The panels open when EffectCraft last quit (`{"open": [names]}`); a missing or unreadable
+/// file is none.
+fn remembered_panels(s: &Session) -> Vec<String> {
+    let text = s.config.as_ref().and_then(|c| c.read(OPEN_PANELS_FILE)).unwrap_or_default();
+    let doc: Value = serde_json::from_str(&text).unwrap_or(Value::Null);
+    doc.get("open").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_str).filter(|n| is_script(n)).map(str::to_string).collect()
+}
+
+/// Change the remembered panels with `f` (written only when it changed). The list is kept so
+/// the next launch reopens them, as After Effects reopens the panels of its workspace; quitting
+/// leaves it as it is.
+fn edit_remembered_panels(s: &Session, f: impl FnOnce(&mut Vec<String>)) {
+    let Some(cfg) = &s.config else { return };
+    let before = remembered_panels(s);
+    let mut list = before.clone();
+    f(&mut list);
+    if list != before
+        && let Err(e) = cfg.write(OPEN_PANELS_FILE, &json!({"open": list}).to_string())
+    {
+        log::warn!("cannot remember the open ScriptUI panels: {e}");
+    }
+}
+
+/// Forget the panels of `before` (open before a script window event) that are closed now.
+pub(crate) fn forget_closed_panels(s: &Session, before: &[String]) {
+    let now = open_panel_names(s);
+    let closed: Vec<&String> = before.iter().filter(|n| !now.contains(n)).collect();
+    if !closed.is_empty() {
+        edit_remembered_panels(s, |l| l.retain(|n| !closed.contains(&n)));
+    }
+}
+
+/// `window.restoreScriptPanels`: open the ScriptUI panels that were open when EffectCraft last
+/// quit (frontends call it once at launch). Panels whose script is gone or fails are reported
+/// and forgotten; the others still open.
+fn restore_panels(s: &mut Session, _: &Value) -> Result<Value> {
+    let (mut opened, mut failed) = (vec![], vec![]);
+    for name in remembered_panels(s) {
+        let r = match script_code(s, &name, Some(true)) {
+            Some(_) => open_panel(s, &json!({"name": name})).map_err(|e| e.to_string()),
+            None => Err("no such ScriptUI panel".to_string()),
+        };
+        match r {
+            Ok(_) => opened.push(name),
+            Err(error) => {
+                edit_remembered_panels(s, |l| l.retain(|n| *n != name));
+                failed.push(json!({"name": name, "error": error}));
+            }
+        }
+    }
+    Ok(json!({"opened": opened, "failed": failed}))
+}
+
+/// Run the scripts in `dir` of the settings store one after another, in alphabetical order (case
+/// ignored), as After Effects runs its Startup and Shutdown folders. A script that fails is
+/// reported in a toast and the log and listed in `failed`; the next one still runs. A script waiting in a
+/// modal dialog is listed in `waiting` and goes on when the dialog closes; the next one runs
+/// meanwhile. With `quitting`, no window is left to show a dialog in, so each dialog closes as
+/// if canceled (`show()` returns 2) and the script runs on.
+fn run_folder(s: &mut Session, dir: &str, quitting: bool) -> Value {
+    let mut names: Vec<String> = s.config.as_ref().map(|c| c.list(dir)).unwrap_or_default().into_iter().filter(|n| is_script(n) && is_script_name(n)).collect();
+    names.sort_by(|a, b| a.to_lowercase().cmp(&b.to_lowercase()).then_with(|| a.cmp(b)));
+    let (mut ran, mut waiting, mut failed) = (vec![], vec![], vec![]);
+    for name in names {
+        let code = match s.config.as_ref().map(|c| c.read_bounded(&format!("{dir}/{name}"), MAX_SCRIPT_BYTES)) {
+            Some(Ok(Some(code))) => code,
+            read => {
+                let why = match read {
+                    Some(Err(e)) => format!(": {e}"),
+                    _ => String::new(),
+                };
+                let error = format!("{name}: cannot read the script{why}");
+                log::warn!("{dir}: {error}");
+                s.events.push(Event::Toast { message: error.clone(), error: true });
+                failed.push(json!({"name": name, "error": error}));
+                continue;
+            }
+        };
+        let is_waiting = |r: &Result<Value>| r.as_ref().is_ok_and(|v| v.get("waiting").and_then(Value::as_bool) == Some(true));
+        // In a settings folder on disk, the script runs as its file, so `#include`, `$.fileName`
+        // and `$.evalFile` find the files beside it.
+        let path = s.config.as_ref().and_then(|c| c.dir()).map(|d| d.join(dir).join(&name).to_string_lossy().into_owned()).unwrap_or_else(|| name.clone());
+        // Windows open before this script runs belong to other scripts, perhaps of the same name.
+        let before: Vec<u32> = s.script_ui.windows.iter().map(|w| w.id).collect();
+        let hosts_before = s.script_ui.task_hosts.clone();
+        let mut r = super::file_more::run_js_file(s, &code, &path, &name);
+        if !quitting {
+            // The Startup script's context: the one that scheduled tasks or holds the windows it
+            // opened (a task scheduled after its dialog closes runs there too).
+            let tasks = s.script_ui.task_hosts.iter().filter(|h| !hosts_before.contains(h)).copied();
+            let windows = s.script_ui.windows.iter().filter(|w| !before.contains(&w.id)).map(|w| w.host);
+            let hosts: Vec<u32> = tasks.chain(windows).collect();
+            for h in hosts {
+                if !s.script_ui.startup_hosts.contains(&h) {
+                    s.script_ui.startup_hosts.push(h);
+                }
+            }
+        }
+        let mut closed = 0;
+        while quitting && closed < MAX_SHUTDOWN_DIALOGS && is_waiting(&r) {
+            let Some(id) = s.script_ui.windows.iter().rev().find(|w| w.modal && w.script == path && !before.contains(&w.id)).map(|w| w.id) else { break };
+            // report_js reports an error the script throws after its dialog closes, as it does for an
+            // error in the script's first run.
+            r = scriptui::close(s, &json!({"window": id})).and_then(|out| super::file_more::report_js(s, &name, out));
+            closed += 1;
+        }
+        match r {
+            Ok(_) if is_waiting(&r) => waiting.push(name),
+            Ok(_) => ran.push(name),
+            Err(e) => {
+                // Also in the log: no frame draws a Shutdown script's toast.
+                log::warn!("{dir}: {e}");
+                failed.push(json!({"name": name, "error": e.to_string()}));
+            }
+        }
+    }
+    json!({"ran": ran, "waiting": waiting, "failed": failed})
+}
+
+/// `file.runStartupScripts`: run the scripts in `Scripts/Startup` (frontends call it once at
+/// launch, before a project opens).
+fn run_startup(s: &mut Session, _: &Value) -> Result<Value> {
+    Ok(run_folder(s, STARTUP_DIR, false))
+}
+
+/// `file.runShutdownScripts`: close the project, then run the scripts in `Scripts/Shutdown`
+/// (frontends call it as the app quits, after the unsaved-changes prompt).
+fn run_shutdown(s: &mut Session, _: &Value) -> Result<Value> {
+    s.replace_project(effectcraft_project::Project::default(), None);
+    Ok(run_folder(s, SHUTDOWN_DIR, true))
+}
+
+/// Window ▸ `<ScriptUI panel>`: run the panel script (or bring its panel forward).
+fn open_panel(s: &mut Session, p: &Value) -> Result<Value> {
+    let c = "window.scriptPanel";
+    let name = str_p(p, "name").ok_or_else(|| bad(c, "missing `name` (a script in the ScriptUI Panels folder)"))?.to_string();
+    let file = name.rsplit_once('/').map_or(name.as_str(), |(_, f)| f);
+    let title = file.trim_end_matches(".jsx").trim_end_matches(".js").to_string();
+    if let Some(w) = s.script_ui.windows.iter().find(|w| w.kind == scriptui::WindowKind::Panel && w.script == name) {
+        let id = w.id;
+        s.events.push(Event::Frontend { command: c.into(), params: json!({"window": id}) });
+        return Ok(json!({"window": id, "open": true}));
+    }
+    // Only panels: a script opened as one would be remembered, then forgotten at the next launch.
+    let (_, code) = script_code(s, &name, Some(true)).ok_or_else(|| bad(c, format!("no ScriptUI panel `{name}`")))?;
+    let out = super::file_more::run_js_named(s, &panel_wrapper(&title, &code), &name)?;
+    let id = s.script_ui.windows.iter().rev().find(|w| w.kind == scriptui::WindowKind::Panel && w.script == name).map(|w| w.id);
+    if let Some(id) = id {
+        s.events.push(Event::Frontend { command: c.into(), params: json!({"window": id}) });
+    }
+    if id.is_some() {
+        edit_remembered_panels(s, |l| {
+            if !l.contains(&name) {
+                l.push(name.clone());
+            }
+        });
+    }
+    Ok(json!({"window": id, "result": out}))
+}
+
+/// The commands of File ▸ Scripts, ScriptUI panels and windows, and script settings.
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        cmd!(
+            "file.installScript",
+            "Install Script File...",
+            ["File", "Scripts"],
+            None,
+            "{path (.jsx / .js)} → copies it to the Scripts folder; it appears in File ▸ Scripts",
+            always,
+            |s, p| install(s, p, false)
+        ),
+        cmd!(
+            "file.installScriptUIPanel",
+            "Install ScriptUI Panel...",
+            ["File", "Scripts"],
+            None,
+            "{path (.jsx / .js)} → copies it to the ScriptUI Panels folder; it appears in the Window menu",
+            always,
+            |s, p| install(s, p, true)
+        ),
+        cmd!(
+            "file.uninstallScript",
+            "Uninstall Script",
+            [],
+            None,
+            "{name (a script at the top of a Scripts folder, not `Folder/File.jsx`)}",
+            always,
+            uninstall
+        ),
+        crate::query!("file.scripts.list", "List Scripts", "{} → [{name (`Folder/File.jsx` in a subfolder), panel, source: installed|sample|extension}]", list),
+        cmd!(
+            "window.scriptPanel",
+            "ScriptUI Panel",
+            [],
+            None,
+            "{name (a script in the ScriptUI Panels folder, e.g. `Layer Tools.jsx`, or `Folder/Panel.jsx` in a subfolder)} → opens it as a dockable panel",
+            always,
+            open_panel
+        ),
+        cmd!(
+            "window.restoreScriptPanels",
+            "Restore ScriptUI Panels",
+            [],
+            None,
+            "{} → reopens the ScriptUI panels open when EffectCraft last quit (frontends call it at launch) → {opened: [name], failed: [{name, error}]}",
+            always,
+            restore_panels
+        ),
+        cmd!(
+            "file.runStartupScripts",
+            "Run Startup Scripts",
+            [],
+            None,
+            "{} → runs the scripts in Scripts/Startup in alphabetical order (frontends call it at launch) → {ran: [name], waiting: [name] (in a modal dialog), failed: [{name, error}]}",
+            always,
+            run_startup
+        ),
+        cmd!(
+            "file.runShutdownScripts",
+            "Run Shutdown Scripts",
+            [],
+            None,
+            "{} → closes the project, then runs the scripts in Scripts/Shutdown in alphabetical order (frontends call it as the app quits; their modal dialogs close as if canceled) → {ran: [name], waiting: [name], failed: [{name, error}]}",
+            always,
+            run_shutdown
+        ),
+        crate::query!("script.settings.get", "Get Script Setting", "{section, key} → {have, value} (app.settings.haveSetting / getSetting)", settings_get),
+        cmd!(
+            "script.settings.save",
+            "Save Script Setting",
+            [],
+            None,
+            "{section, key, value (text)} → kept in the settings store (app.settings.saveSetting)",
+            always,
+            settings_save
+        ),
+        cmd!(
+            "script.runTasks",
+            "Run Scheduled Script Tasks",
+            [],
+            None,
+            "{} → runs the app.scheduleTask tasks that are due (frontends do it every frame) → {ran, output, errors, next (ms until the next task, or null)}",
+            always,
+            scriptui::run_tasks
+        ),
+        crate::query!("scriptui.list", "List Script Windows", "{} → [{window, title, kind: dialog|palette|window|panel, script, modal, size}]", scriptui::list),
+        crate::query!(
+            "scriptui.get",
+            "Script Window Controls",
+            "{window?: id | title} → {id, title, kind, root: {id, type, name, text, value, checked, items, selection, bounds, enabled, draw (onDraw paint list), children…}}",
+            scriptui::get
+        ),
+        cmd!(
+            "scriptui.click",
+            "Click Script Window Control",
+            [],
+            None,
+            "{window?: id | title, widget: id | \"#id\" | properties.name | text} (buttons, checkboxes, radio buttons, tabs)",
+            always,
+            scriptui::click
+        ),
+        cmd!(
+            "scriptui.set",
+            "Set Script Window Control",
+            [],
+            None,
+            "{window?, widget, value: text | number | bool | item index | item text, changing?: bool (a live update: each keystroke / slider step; fires onChanging only)} (edit text, sliders, checkboxes, lists) → fires onChanging / onChange",
+            always,
+            scriptui::set
+        ),
+        cmd!(
+            "scriptui.mouse",
+            "Mouse Event on Script Window Control",
+            [],
+            None,
+            "{window?, widget, type: mousedown | mouseup | mousemove | mouseover | mouseout | click (default), x?, y? (relative to the control; default its centre), button? (0 left, 1 middle, 2 right), buttons? (held: 1 left, 2 right, 4 middle), detail? (click count), screenX?, screenY?, altKey?, ctrlKey?, metaKey?, shiftKey?} → the script's addEventListener listeners on the control and its containers receive a MouseEvent",
+            always,
+            scriptui::mouse
+        ),
+        cmd!(
+            "scriptui.resize",
+            "Resize Script Window",
+            [],
+            None,
+            "{window?, size: [width, height] (pixels)} → the window takes the size, lays itself out again and its onResizing / onResize run (a docked ScriptUI panel gets its dock's size)",
+            always,
+            scriptui::resize
+        ),
+        cmd!(
+            "scriptui.close",
+            "Close Script Window",
+            [],
+            None,
+            "{window?, result? (a dialog's show() returns it; default 2 = Cancel)}",
+            always,
+            scriptui::close
+        ),
+    ]
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+    use std::sync::Arc;
+
+    use serde_json::{Value, json};
+
+    use super::{BUNDLED, PANELS_DIR, SCRIPTS_DIR, is_bare_name, is_script, is_script_name, script_code, windows_unsafe_name};
+    use crate::config::DirConfig;
+    use crate::{EngineError, Result, ScriptRequest, Session};
+
+    /// Stands in for the JavaScript runtime: reports the code it was asked to run.
+    fn echo(_: &mut Session, r: &ScriptRequest) -> Value {
+        json!({"ran": r.code})
+    }
+
+    /// A session whose settings store is a fresh `<root>/settings/` (with both Scripts folders, as
+    /// after installing a script and a panel), next to a script `<root>/outside.jsx`.
+    fn session_in_tmp(name: &str) -> (Session, PathBuf) {
+        use std::sync::atomic::{AtomicU32, Ordering};
+        static N: AtomicU32 = AtomicU32::new(0);
+        let root = std::env::temp_dir().join(format!("ec-scripts-{}-{}-{name}", std::process::id(), N.fetch_add(1, Ordering::Relaxed)));
+        let _ = std::fs::remove_dir_all(&root);
+        std::fs::create_dir_all(root.join("settings").join(PANELS_DIR)).unwrap();
+        std::fs::write(root.join("outside.jsx"), "outside").unwrap();
+        let s = Session { config: Some(Arc::new(DirConfig::new(root.join("settings")))), script: Some(echo), ..Default::default() };
+        (s, root)
+    }
+
+    fn bad_params(r: &Result<Value>) -> bool {
+        matches!(r, Err(EngineError::BadParams { .. }))
+    }
+
+    /// Paths, refused on every platform.
+    const PATHS: [&str; 10] = ["", ".", "..", "../x.jsx", "a/b.jsx", "/abs/x.jsx", "a\\b.jsx", "..\\x.jsx", "C:\\x.jsx", "a\0.jsx"];
+    /// Ordinary file names except on Windows.
+    const WINDOWS_ONLY: [&str; 8] = ["Step 1: Setup.jsx", "In:Out.jsx", "C:x.jsx", "x.jsx.", "x.jsx ", "Aux.Tools.jsx", "con.jsx", "COM1.jsx"];
+
+    #[test]
+    fn bare_names_are_one_path_component() {
+        for name in ["Rename Layers.jsx", "..jsx", "a..b.js", "Äpfel ✓.jsx"].into_iter().chain(WINDOWS_ONLY) {
+            assert!(is_bare_name(name), "{name:?}");
+        }
+        for name in PATHS {
+            assert!(!is_bare_name(name), "{name:?}");
+        }
+    }
+
+    #[test]
+    fn windows_unsafe_names_are_drives_streams_trailing_dots_and_devices() {
+        let devices = ["CON", "Con.tar.jsx", "CON .jsx", "PRN.js", "aux.jsx", "NUL.jsx", "CONIN$.jsx", "conout$.js"];
+        let ports = ["COM0.jsx", "com9.js", "LPT0.jsx", "lpt9.jsx", "COM¹.jsx", "LPT³.js"];
+        for name in WINDOWS_ONLY.into_iter().chain(devices).chain(ports) {
+            assert!(windows_unsafe_name(name), "{name:?}");
+        }
+        let fine = ["console.jsx", "Concert.jsx", "NULL.jsx", "CONIN.jsx", "COM10.jsx", "LPT.jsx", "x .jsx", "..jsx"];
+        for name in BUNDLED.iter().map(|b| b.0).chain(fine) {
+            assert!(!windows_unsafe_name(name), "{name:?}");
+        }
+    }
+
+    /// Bundled and ordinary script file names are accepted; paths are not.
+    #[test]
+    fn script_names_are_bare_file_names() {
+        let more = ["..jsx", "a..b.js", "Äpfel ✓.jsx", "console.jsx", "Concert.jsx", "NULL.jsx", "COM10.jsx", "LPT.jsx"];
+        for name in BUNDLED.iter().map(|b| b.0).chain(more) {
+            assert!(is_script(name) && is_script_name(name), "{name}");
+        }
+        // `a/b.jsx` is a script in a folder (see below).
+        for name in PATHS.into_iter().filter(|n| *n != "a/b.jsx") {
+            assert!(!is_script_name(name), "{name:?}");
+        }
+        for name in WINDOWS_ONLY {
+            assert_eq!(is_script_name(name), !cfg!(windows), "{name:?}");
+        }
+        // Install refuses a file name the script could not then be run or uninstalled by.
+        #[cfg(unix)]
+        {
+            let (mut s, root) = session_in_tmp("odd-name");
+            let odd = root.join("a\\b.jsx");
+            std::fs::write(&odd, "x").unwrap();
+            assert!(bad_params(&s.execute("file.installScript", json!({"path": odd.to_string_lossy()}))));
+            assert!(!root.join("settings").join(SCRIPTS_DIR).join("a\\b.jsx").exists());
+            let _ = std::fs::remove_dir_all(&root);
+        }
+    }
+
+    /// `Folder/File.jsx` is accepted; deeper, upward, absolute and `\` names are not.
+    #[test]
+    fn script_names_may_have_one_folder() {
+        for name in ["Motion Kit/Animate.jsx", "a/b.jsx", "Äpfel/✓.js", "..jsx/x.jsx"] {
+            assert!(is_script_name(name), "{name:?}");
+        }
+        // Deeper, up, absolute, an empty part, a `\` path, and the panels' own folder in `Scripts`.
+        let refused = ["a/b/c.jsx", "../x.jsx", "a/../x.jsx", "./x.jsx", "a/..", "/x.jsx", "a//x.jsx", "a/", "a\\b.jsx", "a/b\\c.jsx", "a\0/x.jsx"];
+        for name in refused.into_iter().chain(["ScriptUI Panels/x.jsx", "scriptui panels/x.jsx"]) {
+            assert!(!is_script_name(name), "{name:?}");
+        }
+        for name in ["In:Out/x.jsx", "con/x.jsx", "x/COM1.jsx", "x./y.jsx"] {
+            assert_eq!(is_script_name(name), !cfg!(windows), "{name:?}");
+        }
+    }
+
+    /// Writes `code` to `rel` in the settings folder of [`session_in_tmp`]'s `root`.
+    fn put(root: &std::path::Path, rel: &str, code: &str) {
+        let p = root.join("settings").join(rel);
+        std::fs::create_dir_all(p.parent().unwrap()).unwrap();
+        std::fs::write(p, code).unwrap();
+    }
+
+    /// Every script command takes `Folder/File.jsx` names and refuses names outside one folder level.
+    #[test]
+    fn scripts_in_a_subfolder_are_listed_run_and_opened_as_folder_and_file() {
+        let (mut s, root) = session_in_tmp("folders");
+        put(&root, "Scripts/Tools/Hello.jsx", "hello");
+        put(&root, "Scripts/ScriptUI Panels/Motion Kit/Animate.jsx", "animate");
+        put(&root, "Scripts/ScriptUI Panels/Top.jsx", "top");
+        // Two folders deep: neither listed nor run.
+        put(&root, "Scripts/a/b/c.jsx", "too deep");
+        put(&root, "Scripts/ScriptUI Panels/Motion Kit/sub/Deep.jsx", "too deep");
+        let list = s.execute("file.scripts.list", json!({})).unwrap();
+        let installed: Vec<(&str, bool)> =
+            list.as_array().unwrap().iter().filter(|e| e["source"] == "installed").map(|e| (e["name"].as_str().unwrap(), e["panel"] == true)).collect();
+        assert_eq!(installed, [("Tools/Hello.jsx", false), ("Motion Kit/Animate.jsx", true), ("Top.jsx", true)]);
+        assert_eq!(s.execute("file.runScript", json!({"name": "Tools/Hello.jsx"})).unwrap()["ran"], "hello");
+        // A panel in a folder is titled after its file.
+        let r = s.execute("window.scriptPanel", json!({"name": "Motion Kit/Animate.jsx"})).unwrap();
+        let ran = r["result"]["ran"].as_str().unwrap_or_default();
+        assert!(ran.contains("animate") && ran.contains(r#"__uiDockPanel("Animate")"#), "{r}");
+        assert_eq!(script_code(&s, "Motion Kit/Animate.jsx", Some(true)), Some((true, "animate".to_string())));
+        // A script that is not a panel doesn't open as one.
+        for name in ["Tools/Hello.jsx", "Rename Layers.jsx"] {
+            assert!(bad_params(&s.execute("window.scriptPanel", json!({"name": name}))), "{name}");
+        }
+        for name in [
+            "../x.jsx",
+            "a/b/c.jsx",
+            "a\\b.jsx",
+            "Motion Kit/sub/Deep.jsx",
+            "ScriptUI Panels/Top.jsx",
+            "Startup/Run.jsx",
+            "shutdown/Run.jsx",
+            "Tools/../../../outside.jsx",
+        ] {
+            assert_eq!(script_code(&s, name, None), None, "{name:?}");
+            for c in ["file.runScript", "window.scriptPanel", "file.uninstallScript"] {
+                let r = s.execute(c, json!({"name": name}));
+                assert!(bad_params(&r), "{c} `{name}`: {r:?}");
+            }
+        }
+        assert!(["Scripts/a/b/c.jsx", "Scripts/ScriptUI Panels/Top.jsx"].iter().all(|p| root.join("settings").join(p).is_file()));
+        assert!(root.join("outside.jsx").is_file());
+        // Uninstall removes only scripts at the top; one in a folder is deleted there by hand.
+        for name in ["Tools/Hello.jsx", "Motion Kit/Animate.jsx"] {
+            assert!(bad_params(&s.execute("file.uninstallScript", json!({"name": name}))), "{name}");
+        }
+        assert!(["Scripts/Tools/Hello.jsx", "Scripts/ScriptUI Panels/Motion Kit/Animate.jsx"].iter().all(|p| root.join("settings").join(p).is_file()));
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    /// A subfolder can be a link to an extension's own folder, outside the settings folder: its
+    /// scripts are listed and run from there, but uninstall never deletes through it.
+    #[cfg(unix)]
+    #[test]
+    fn uninstall_never_deletes_through_a_linked_subfolder() {
+        let (mut s, root) = session_in_tmp("linked");
+        std::fs::create_dir_all(root.join("extension")).unwrap();
+        std::fs::write(root.join("extension").join("Animate.jsx"), "animate").unwrap();
+        std::os::unix::fs::symlink(root.join("extension"), root.join("settings").join(PANELS_DIR).join("Motion Kit")).unwrap();
+        let list = s.execute("file.scripts.list", json!({})).unwrap();
+        assert!(list.as_array().unwrap().iter().any(|e| e["name"] == "Motion Kit/Animate.jsx" && e["panel"] == true), "{list}");
+        assert_eq!(script_code(&s, "Motion Kit/Animate.jsx", Some(true)), Some((true, "animate".to_string())));
+        let r = s.execute("file.uninstallScript", json!({"name": "Motion Kit/Animate.jsx"}));
+        assert!(bad_params(&r), "{r:?}");
+        assert!(root.join("extension").join("Animate.jsx").is_file(), "the extension's own file was deleted");
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    /// Window ▸ Motion Kit ▸ Animate.jsx: a subfolder is a submenu named after it, where the folder
+    /// sorts; the entries outside folders stay as they were.
+    #[test]
+    fn a_subfolder_is_a_submenu() {
+        use crate::menus::{MenuNode, dynamic, dynamic_nodes};
+        let (s, root) = session_in_tmp("submenus");
+        put(&root, "Scripts/ScriptUI Panels/Motion Kit/Animate.jsx", "");
+        put(&root, "Scripts/ScriptUI Panels/Motion Kit/Rig.jsx", "");
+        put(&root, "Scripts/ScriptUI Panels/Top.jsx", "");
+        put(&root, "Scripts/Tools/Hello.jsx", "");
+        let cx = Default::default();
+        let item =
+            |label: &str, command: &str, name: &str| json!({"type": "item", "label": label, "command": command, "params": {"name": name}, "shortcut": null});
+        let menus = [
+            (
+                "scriptPanels",
+                json!({"type": "submenu", "label": "Motion Kit", "children": [
+                    item("Animate.jsx", "window.scriptPanel", "Motion Kit/Animate.jsx"),
+                    item("Rig.jsx", "window.scriptPanel", "Motion Kit/Rig.jsx"),
+                ]}),
+            ),
+            ("scripts", json!({"type": "submenu", "label": "Tools", "children": [item("Hello.jsx", "file.runScript", "Tools/Hello.jsx")]})),
+        ];
+        for (menu, folder) in menus {
+            let (nodes, _) = dynamic_nodes(&s, menu, &cx);
+            let (entries, _) = dynamic(&s, menu, &cx);
+            let items: Vec<_> = nodes.iter().filter_map(|n| if let MenuNode::Item(e) = n { Some(e) } else { None }).collect();
+            assert_eq!(items, entries.iter().filter(|e| !e.label.contains('/')).collect::<Vec<_>>(), "{menu}");
+            let folders: Vec<Value> = nodes.iter().filter(|n| matches!(n, MenuNode::Submenu { .. })).map(|n| serde_json::to_value(n).unwrap()).collect();
+            assert_eq!(folders, [folder], "{menu}");
+        }
+        let (panels, _) = dynamic_nodes(&s, "scriptPanels", &cx);
+        let labels: Vec<&str> = panels
+            .iter()
+            .filter_map(|n| match n {
+                MenuNode::Item(e) => Some(e.label.as_str()),
+                MenuNode::Submenu { label, .. } => Some(label),
+                _ => None,
+            })
+            .collect();
+        assert_eq!(labels, ["Ease Presets.jsx", "Layer Tools.jsx", "Motion Kit", "Top.jsx"]);
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    #[test]
+    fn uninstall_takes_a_script_name_not_a_path() {
+        let (mut s, root) = session_in_tmp("uninstall");
+        let (outside, prefs) = (root.join("outside.jsx"), root.join("settings").join("prefs.json"));
+        std::fs::write(&prefs, "{}").unwrap();
+        // From `Scripts/`, `../../outside.jsx` is the script next to the settings folder and
+        // `../prefs.json` a settings file; an absolute path is not a script name either.
+        for name in ["../../outside.jsx".to_string(), "../prefs.json".into(), outside.to_string_lossy().into_owned()] {
+            let r = s.execute("file.uninstallScript", json!({"name": name}));
+            assert!(outside.is_file() && prefs.is_file(), "`{name}` deleted a file outside the Scripts folders: {r:?}");
+            assert!(bad_params(&r), "`{name}`: {r:?}");
+        }
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    #[test]
+    fn scripts_run_by_name_come_from_the_scripts_folders() {
+        let (mut s, root) = session_in_tmp("run");
+        // `Scripts/../../outside.jsx` and `Scripts/ScriptUI Panels/../../../outside.jsx` are the
+        // script next to the settings folder.
+        let r = s.execute("file.runScript", json!({"name": "../../outside.jsx"}));
+        assert!(bad_params(&r), "{r:?}");
+        let r = s.execute("window.scriptPanel", json!({"name": "../../../outside.jsx"}));
+        assert!(bad_params(&r), "{r:?}");
+        assert_eq!(script_code(&s, "../../outside.jsx", None), None);
+        assert_eq!(script_code(&s, "../../../outside.jsx", Some(true)), None);
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    /// File ▸ Scripts ▸ Recent Script Files: the ten scripts run last, newest first, kept in the
+    /// settings; Cmd+Alt+Shift+D runs the first one again.
+    #[test]
+    fn recent_script_files_run_again() {
+        use crate::prefs::{MAX_RECENT_SCRIPTS, PREFS_FILE, Prefs, RecentScript};
+        let (mut s, root) = session_in_tmp("recent");
+        assert_eq!(crate::menus::dynamic(&s, "recentScripts", &Default::default()), (vec![], Some("No Recent Script Files")));
+        assert!(bad_params(&s.execute("file.runScript", json!({"recent": 0}))));
+        assert_eq!(s.shortcuts().shortcut_of("file.runScript", &json!({"recent": 0})), Some("Cmd+Alt+Shift+D"));
+        let tool = root.join("Tool.jsx");
+        std::fs::write(&tool, "tool").unwrap();
+        let tool = tool.to_string_lossy().into_owned();
+        s.execute("file.runScript", json!({"path": tool})).unwrap();
+        s.execute("file.runScript", json!({"name": "Rename Layers.jsx"})).unwrap();
+        // A ScriptUI panel opened from File ▸ Scripts is not a recent script file.
+        std::fs::write(root.join("settings").join(PANELS_DIR).join("Panel.jsx"), "panel").unwrap();
+        s.execute("file.runScript", json!({"name": "Panel.jsx"})).unwrap();
+        let (path, name) = (RecentScript::Path(tool.clone()), RecentScript::Name("Rename Layers.jsx".into()));
+        assert_eq!(s.prefs.recent_scripts, [name.clone(), path.clone()]);
+        let (e, _) = crate::menus::dynamic(&s, "recentScripts", &Default::default());
+        assert_eq!(e.iter().map(|e| e.label.as_str()).collect::<Vec<_>>(), ["Rename Layers.jsx", "Tool.jsx"]);
+        assert_eq!((e[1].command.as_str(), &e[1].params), ("file.runScript", &json!({"recent": 1})));
+        // Running one again runs that file and moves it to the top.
+        assert_eq!(s.execute("file.runScript", json!({"recent": 1})).unwrap()["ran"], "tool");
+        assert_eq!(s.prefs.recent_scripts, [path.clone(), name.clone()]);
+        let sample = BUNDLED.iter().find(|b| b.0 == "Rename Layers.jsx").unwrap().3;
+        assert_eq!(s.execute("file.runScript", json!({"recent": 1})).unwrap()["ran"], sample);
+        assert!(bad_params(&s.execute("file.runScript", json!({"recent": 2}))));
+        assert!(bad_params(&s.execute("file.runScript", json!({"recent": "Tool.jsx"}))));
+        // A file named like a bundled script runs again as that file.
+        let local = root.join("Rename Layers.jsx");
+        std::fs::write(&local, "local").unwrap();
+        s.execute("file.runScript", json!({"path": local.to_string_lossy()})).unwrap();
+        assert_eq!(s.execute("file.runScript", json!({"recent": 0})).unwrap()["ran"], "local");
+        assert_eq!(s.execute("file.runScript", json!({"recent": 1})).unwrap()["ran"], sample);
+        // Ten at most, saved with the settings.
+        let mut last = String::new();
+        for i in 0..MAX_RECENT_SCRIPTS + 2 {
+            let f = root.join(format!("Step {i}.jsonl"));
+            std::fs::write(&f, "").unwrap();
+            last = f.to_string_lossy().into_owned();
+            s.execute("file.runScript", json!({"path": last})).unwrap();
+        }
+        assert_eq!(s.prefs.recent_scripts.len(), MAX_RECENT_SCRIPTS);
+        assert_eq!(s.prefs.recent_scripts[0], RecentScript::Path(last));
+        let saved = std::fs::read_to_string(root.join("settings").join(PREFS_FILE)).unwrap();
+        assert_eq!(Prefs::from_json(&saved).recent_scripts, s.prefs.recent_scripts);
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    #[test]
+    fn recent_script_history_uses_the_selected_script() {
+        let (mut s, root) = session_in_tmp("recent-panel-collision");
+        let name = "Rename Layers.jsx";
+        std::fs::write(root.join("settings").join(PANELS_DIR).join(name), "panel").unwrap();
+        assert!(super::scripts(&s).iter().any(|entry| entry.name == name && !entry.panel));
+        assert!(script_code(&s, name, None).unwrap().0);
+        let sample = BUNDLED.iter().find(|b| b.0 == name).unwrap().3;
+        assert_eq!(s.execute("file.runScript", json!({"name": name})).unwrap()["ran"], sample);
+        assert!(super::open_panel_names(&s).is_empty(), "the listed script runs instead of the panel");
+        assert_eq!(s.prefs.recent_scripts, [crate::prefs::RecentScript::Name(name.to_string())]);
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn recent_script_history_keeps_successful_entries_when_scripts_fail() {
+        fn fail_or_echo(_: &mut Session, request: &ScriptRequest) -> Value {
+            if request.code == "fail" { json!({"error": {"message": "script failed"}}) } else { json!({"ran": request.code}) }
+        }
+        let (mut s, root) = session_in_tmp("recent-failed");
+        s.script = Some(fail_or_echo);
+        let good = root.join("good.jsonl");
+        std::fs::write(&good, "[]").unwrap();
+        s.execute("file.runScript", json!({"path": good})).unwrap();
+        let remembered = s.prefs.recent_scripts.clone();
+        for (name, code) in [("parse.jsonl", "{"), ("step.jsonl", r#"{"command":"does.not.exist"}"#), ("missing-command.jsonl", "{}"), ("runtime.jsx", "fail")]
+        {
+            let path = root.join(name);
+            std::fs::write(&path, code).unwrap();
+            assert!(s.execute("file.runScript", json!({"path": path})).is_err(), "{name}");
+            assert_eq!(s.prefs.recent_scripts, remembered, "{name}");
+        }
+        std::fs::write(root.join("settings").join(SCRIPTS_DIR).join("Failed.jsx"), "fail").unwrap();
+        assert!(s.execute("file.runScript", json!({"name": "Failed.jsx"})).is_err());
+        assert_eq!(s.prefs.recent_scripts, remembered);
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    /// Reads relative paths from a working directory that a test can change.
+    struct InFolder(std::sync::Mutex<PathBuf>);
+
+    impl InFolder {
+        fn at(&self, path: &str) -> PathBuf {
+            self.0.lock().unwrap().join(path)
+        }
+    }
+
+    impl crate::Services for InFolder {
+        fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>> {
+            std::fs::read(self.at(path))
+        }
+        fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
+            std::fs::write(self.at(path), data)
+        }
+        fn full_path(&self, path: &str) -> Option<String> {
+            Some(self.at(path).to_string_lossy().into_owned())
+        }
+    }
+
+    /// Reads from a folder but can't make paths absolute.
+    struct NoFullPath(PathBuf);
+
+    impl crate::Services for NoFullPath {
+        fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>> {
+            std::fs::read(self.0.join(path))
+        }
+        fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
+            std::fs::write(self.0.join(path), data)
+        }
+        fn full_path(&self, _path: &str) -> Option<String> {
+            None
+        }
+    }
+
+    /// A script whose path can't be made absolute still runs, and Recent Script Files does not
+    /// keep its relative path.
+    #[test]
+    fn unresolved_script_paths_are_not_remembered() {
+        let (mut s, root) = session_in_tmp("recent-unresolved");
+        std::fs::write(root.join("Tool.jsx"), "a").unwrap();
+        std::fs::write(root.join("steps.jsonl"), "[]").unwrap();
+        s.services = Arc::new(NoFullPath(root.clone()));
+        assert_eq!(s.execute("file.runScript", json!({"path": "Tool.jsx"})).unwrap()["ran"], "a");
+        s.execute("file.runScript", json!({"path": "steps.jsonl"})).unwrap();
+        assert!(s.prefs.recent_scripts.is_empty(), "{:?}", s.prefs.recent_scripts);
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    /// A script run from a relative path runs the same file again from Recent Script Files after
+    /// the working directory changes, and two scripts with the same file name show their paths.
+    #[test]
+    fn recent_script_files_keep_the_file_that_ran() {
+        let (mut s, root) = session_in_tmp("recent-relative");
+        let (a, b) = (root.join("a"), root.join("b"));
+        for (dir, code) in [(&a, "a"), (&b, "b")] {
+            std::fs::create_dir_all(dir).unwrap();
+            std::fs::write(dir.join("Tool.jsx"), code).unwrap();
+        }
+        let services = Arc::new(InFolder(std::sync::Mutex::new(a.clone())));
+        s.services = services.clone();
+        assert_eq!(s.execute("file.runScript", json!({"path": "Tool.jsx"})).unwrap()["ran"], "a");
+        *services.0.lock().unwrap() = b.clone();
+        assert_eq!(s.execute("file.runScript", json!({"recent": 0})).unwrap()["ran"], "a");
+        let (e, _) = crate::menus::dynamic(&s, "recentScripts", &Default::default());
+        assert_eq!(e.iter().map(|e| e.label.as_str()).collect::<Vec<_>>(), ["Tool.jsx"]);
+        assert_eq!(s.execute("file.runScript", json!({"path": "Tool.jsx"})).unwrap()["ran"], "b");
+        let (e, _) = crate::menus::dynamic(&s, "recentScripts", &Default::default());
+        let (a, b) = (a.join("Tool.jsx").to_string_lossy().into_owned(), b.join("Tool.jsx").to_string_lossy().into_owned());
+        assert_eq!(e.iter().map(|e| e.label.as_str()).collect::<Vec<_>>(), [b.as_str(), a.as_str()]);
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    /// Native script paths are kept absolute.
+    #[test]
+    fn native_full_paths_are_absolute() {
+        use crate::Services;
+        assert!(crate::FsServices.full_path("Tool.jsx").is_some_and(|p| std::path::Path::new(&p).is_absolute()));
+    }
+
+    #[test]
+    fn only_scripts_are_read_or_removed() {
+        // A settings file in the Scripts folder that is not a script (.jsx / .js).
+        let (mut s, root) = session_in_tmp("not-a-script");
+        let notes = root.join("settings").join(SCRIPTS_DIR).join("notes.txt");
+        std::fs::write(&notes, "notes").unwrap();
+        assert_eq!(script_code(&s, "notes.txt", None), None);
+        let r = s.execute("file.uninstallScript", json!({"name": "notes.txt"}));
+        assert!(notes.is_file() && bad_params(&r), "{r:?}");
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    /// On Unix `\` is a file-name character: a script dropped into the folder under such a name is
+    /// not offered, as it could not be run or uninstalled. Names only Windows refuses stay.
+    #[cfg(unix)]
+    #[test]
+    fn listing_skips_names_run_and_uninstall_refuse() {
+        let (mut s, root) = session_in_tmp("odd-names");
+        let scripts = root.join("settings").join(SCRIPTS_DIR);
+        std::fs::write(scripts.join("a\\b.jsx"), "x").unwrap();
+        std::fs::write(scripts.join("In:Out.jsx"), "in-out").unwrap();
+        let list = s.execute("file.scripts.list", json!({})).unwrap();
+        let listed = |n: &str| list.as_array().unwrap().iter().any(|e| e["name"] == n);
+        assert!(!listed("a\\b.jsx") && listed("In:Out.jsx"), "{list}");
+        assert_eq!(script_code(&s, "a\\b.jsx", None), None);
+        assert_eq!(script_code(&s, "In:Out.jsx", None), Some((false, "in-out".to_string())));
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    #[test]
+    fn install_run_and_uninstall_by_name() {
+        let (mut s, root) = session_in_tmp("install");
+        let file = root.join("Hello.jsx");
+        std::fs::write(&file, "hello").unwrap();
+        s.execute("file.installScript", json!({"path": file.to_string_lossy()})).unwrap();
+        s.execute("file.installScriptUIPanel", json!({"path": file.to_string_lossy()})).unwrap();
+        let installed = [root.join("settings").join(SCRIPTS_DIR).join("Hello.jsx"), root.join("settings").join(PANELS_DIR).join("Hello.jsx")];
+        assert!(installed.iter().all(|p| p.is_file()));
+        assert_eq!(s.execute("file.runScript", json!({"name": "Hello.jsx"})).unwrap()["ran"], "hello");
+        let r = s.execute("window.scriptPanel", json!({"name": "Hello.jsx"})).unwrap();
+        assert!(r["result"]["ran"].as_str().is_some_and(|c| c.contains("hello")), "{r}");
+        // The bundled samples still run by name.
+        let sample = BUNDLED.iter().find(|b| b.0 == "Rename Layers.jsx").unwrap().3;
+        assert_eq!(s.execute("file.runScript", json!({"name": "Rename Layers.jsx"})).unwrap()["ran"], sample);
+        s.execute("file.uninstallScript", json!({"name": "Hello.jsx"})).unwrap();
+        assert!(installed.iter().all(|p| !p.exists()));
+        assert!(bad_params(&s.execute("file.uninstallScript", json!({"name": "Hello.jsx"}))), "no longer installed");
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    /// Edit ▸ Keyboard Shortcuts lists the scripts File ▸ Scripts lists (not ScriptUI panels),
+    /// as soon as one is installed and until it is uninstalled; a key given to one is saved with
+    /// the preset.
+    #[test]
+    fn file_scripts_entries_take_keyboard_shortcuts() {
+        use crate::shortcuts::{Keymaps, SHORTCUTS_FILE, binding_key};
+        let (mut s, root) = session_in_tmp("shortcuts");
+        let (script, panel) = (root.join("Hello.jsx"), root.join("Hello Panel.jsx"));
+        std::fs::write(&script, "hello").unwrap();
+        std::fs::write(&panel, "panel").unwrap();
+        let listed = |s: &Session, name: &str| {
+            s.shortcuts().find(&binding_key("file.runScript", &json!({"name": name}))).map(|b| (b.label.clone(), b.path.join(" ▸ "), b.defaults.clone()))
+        };
+        assert_eq!(listed(&s, "Rename Layers.jsx"), Some(("Rename Layers.jsx".into(), "File ▸ Scripts".into(), vec![])), "the bundled samples");
+        assert_eq!(listed(&s, "Hello.jsx"), None);
+        s.execute("file.installScript", json!({"path": script.to_string_lossy()})).unwrap();
+        s.execute("file.installScriptUIPanel", json!({"path": panel.to_string_lossy()})).unwrap();
+        assert_eq!(listed(&s, "Hello.jsx"), Some(("Hello.jsx".into(), "File ▸ Scripts".into(), vec![])));
+        assert_eq!(listed(&s, "Hello Panel.jsx"), None, "panels are in the Window menu");
+        let r = s.execute("shortcuts.set", json!({"command": "file.runScript", "params": {"name": "Hello.jsx"}, "keys": "Cmd+Alt+Shift+F7"})).unwrap();
+        let key = binding_key("file.runScript", &json!({"name": "Hello.jsx"}));
+        assert_eq!((&r["command"], &r["keys"]), (&json!(key), &json!(["Cmd+Alt+Shift+F7"])), "{r}");
+        assert_eq!(s.shortcuts().shortcut_of("file.runScript", &json!({"name": "Hello.jsx"})), Some("Cmd+Alt+Shift+F7"));
+        let saved = Keymaps::from_json(&std::fs::read_to_string(root.join("settings").join(SHORTCUTS_FILE)).unwrap());
+        assert_eq!(saved.active_preset().and_then(|p| p.overrides.get(&key)), Some(&vec!["Cmd+Alt+Shift+F7".to_string()]));
+        s.execute("file.uninstallScript", json!({"name": "Hello.jsx"})).unwrap();
+        assert_eq!(listed(&s, "Hello.jsx"), None);
+        let _ = std::fs::remove_dir_all(&root);
+    }
+
+    /// `shortcuts.list` and `shortcuts.set` see a script copied into the Scripts folder by hand
+    /// after the shortcut table was built; a script the folder doesn't hold (never there, or
+    /// removed by hand) can't take a key, and Run Script File… keeps its own keys.
+    #[test]
+    fn shortcut_commands_find_scripts_copied_into_the_folder() {
+        let (mut s, root) = session_in_tmp("copied");
+        assert!(s.shortcuts().find("file.runScript").is_some(), "the table is built");
+        std::fs::create_dir_all(root.join("settings").join(SCRIPTS_DIR)).unwrap();
+        std::fs::write(root.join("settings").join(SCRIPTS_DIR).join("Copied.jsx"), "copied").unwrap();
+        let list = s.execute("shortcuts.list", json!({"query": "copied.jsx"})).unwrap();
+        assert_eq!(list["count"], 1, "{list}");
+        let r = s.execute("shortcuts.set", json!({"command": "file.runScript", "params": {"name": "Copied.jsx"}, "keys": "Cmd+Alt+Shift+F7"})).unwrap();
+        assert_eq!(r["command"], r#"file.runScript {"name":"Copied.jsx"}"#, "{r}");
+        let r = s.execute("shortcuts.set", json!({"command": "file.runScript", "params": {"name": "Missing.jsx"}, "keys": "Cmd+Alt+Shift+F8"}));
+        assert!(bad_params(&r), "{r:?}");
+        // The binding-key form finds a script copied in since the last lookup, too.
+        std::fs::write(root.join("settings").join(SCRIPTS_DIR).join("Second.jsx"), "second").unwrap();
+        let r = s.execute("shortcuts.set", json!({"command": r#"file.runScript {"name":"Second.jsx"}"#, "keys": "Cmd+Alt+Shift+F10"})).unwrap();
+        assert_eq!(r["command"], r#"file.runScript {"name":"Second.jsx"}"#, "{r}");
+        // Removed by hand: no longer in the folder.
+        std::fs::remove_file(root.join("settings").join(SCRIPTS_DIR).join("Copied.jsx")).unwrap();
+        std::fs::remove_file(root.join("settings").join(SCRIPTS_DIR).join("Second.jsx")).unwrap();
+        let r = s.execute("shortcuts.set", json!({"command": r#"file.runScript {"name":"Second.jsx"}"#, "keys": "Cmd+Alt+Shift+F11"}));
+        assert!(bad_params(&r), "{r:?}");
+        let r = s.execute("shortcuts.set", json!({"command": "file.runScript", "params": {"name": "Copied.jsx"}, "keys": "Cmd+Alt+Shift+F9"}));
+        assert!(bad_params(&r), "{r:?}");
+        assert_eq!(s.shortcuts().shortcut_of("file.runScript", &Value::Null), None, "Run Script File… has no key");
+        let _ = std::fs::remove_dir_all(&root);
+    }
+}
diff --git a/crates/engine/src/commands/settings.rs b/crates/engine/src/cmd/settings.rs
similarity index 93%
rename from crates/engine/src/commands/settings.rs
rename to crates/engine/src/cmd/settings.rs
index a6621c3f4..3673a9550 100644
--- a/crates/engine/src/commands/settings.rs
+++ b/crates/engine/src/cmd/settings.rs
@@ -73,13 +73,21 @@ fn prefs_pages(_: &mut Session, _: &Value) -> Result<Value> {
 
 // ---------------------------------------------------------------- shortcuts
 
-/// The bindable named by `command` (+ `params`), or by a binding key (`app.settings {...}`).
-fn bindable(s: &Session, p: &Value, cmd: &str) -> Result<crate::shortcuts::Bindable> {
+/// The bindable named by `command` (+ `params`), or by a binding key (`app.settings {...}`). A
+/// File ▸ Scripts entry (`file.runScript {"name": …}`) is looked up in File ▸ Scripts' list as it
+/// is now (the Scripts folder and the bundled scripts), and a script it doesn't list is an error,
+/// not Run Script File….
+fn bindable(s: &mut Session, p: &Value, cmd: &str) -> Result<crate::shortcuts::Bindable> {
     let c = str_p(p, "command").ok_or_else(|| bad(cmd, "missing `command`"))?;
     let params = p.get("params").cloned().unwrap_or(Value::Null);
-    let t = s.shortcuts();
     let key = binding_key(c, &params);
-    t.find(&key).or_else(|| t.find(c)).cloned().ok_or_else(|| bad(cmd, format!("`{key}` can't have a shortcut (see shortcuts.list)")))
+    let script = (c == "file.runScript" && params.get("name").is_some()) || c.starts_with("file.runScript {");
+    if script {
+        s.scripts_changed();
+    }
+    let t = s.shortcuts();
+    let found = if script { t.find(&key) } else { t.find(&key).or_else(|| t.find(c)) };
+    found.cloned().ok_or_else(|| bad(cmd, format!("`{key}` can't have a shortcut (see shortcuts.list)")))
 }
 
 fn keys_param(p: &Value, cmd: &str) -> Result<Vec<String>> {
@@ -93,6 +101,8 @@ fn keys_param(p: &Value, cmd: &str) -> Result<Vec<String>> {
 }
 
 fn sc_list(s: &mut Session, p: &Value) -> Result<Value> {
+    // Scripts copied into the Scripts folder since the table was built are listed too.
+    s.scripts_changed();
     let q = str_p(p, "query").unwrap_or("").to_lowercase();
     let assigned = p.get("assigned").and_then(Value::as_bool).unwrap_or(false);
     let keys_q = str_p(p, "keys").and_then(normalize);
@@ -185,7 +195,7 @@ fn sc_export(s: &mut Session, p: &Value) -> Result<Value> {
     let doc = s.keymaps.export(str_p(p, "preset")).map_err(|e| bad("shortcuts.export", e))?;
     if let Some(path) = str_p(p, "path") {
         let text = serde_json::to_string_pretty(&doc).unwrap_or_default();
-        s.services.write_file(path, text.as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+        s.write_output(path, text.as_bytes())?;
         return Ok(json!({"path": path, "preset": doc["name"]}));
     }
     Ok(doc)
diff --git a/crates/engine/src/commands/shape_stroke.rs b/crates/engine/src/cmd/shape_stroke.rs
similarity index 98%
rename from crates/engine/src/commands/shape_stroke.rs
rename to crates/engine/src/cmd/shape_stroke.rs
index ecd3ed8e0..6bb09654b 100644
--- a/crates/engine/src/commands/shape_stroke.rs
+++ b/crates/engine/src/cmd/shape_stroke.rs
@@ -205,7 +205,8 @@ const PATHS: [&str; 4] = ["rect", "ellipse", "star", "path"];
 pub(crate) const MAX_DEPTH: usize = 64;
 
 /// The first Fill colour, Stroke colour and Stroke Width in `layer`'s contents at layer time
-/// `lt` (what the toolbar shows for a selected shape layer).
+/// `lt` (what the toolbar shows for a selected shape layer). Width comes from the first Stroke
+/// or Gradient Stroke, independently of the first solid stroke's colour.
 pub fn first_paint(layer: &Layer, lt: Tick) -> (Option<[f64; 4]>, Option<[f64; 4]>, Option<f64>) {
     let (mut fill, mut stroke, mut width) = (None, None, None);
     if let Some(c) = layer.props.sub("contents") {
@@ -216,10 +217,12 @@ pub fn first_paint(layer: &Layer, lt: Tick) -> (Option<[f64; 4]>, Option<[f64; 4
                 "fill" if fill.is_none() => fill = at("color").map(rgba),
                 "stroke" if stroke.is_none() => {
                     stroke = at("color").map(rgba);
-                    width = at("width").map(|v| v.as_f64());
                 }
                 _ => {}
             }
+            if width.is_none() && is_stroke(g) {
+                width = at("width").map(|v| v.as_f64());
+            }
         });
     }
     (fill, stroke, width)
diff --git a/crates/engine/src/commands/shape_tool.rs b/crates/engine/src/cmd/shape_tool.rs
similarity index 96%
rename from crates/engine/src/commands/shape_tool.rs
rename to crates/engine/src/cmd/shape_tool.rs
index a48c32b7f..3323d61d6 100644
--- a/crates/engine/src/commands/shape_tool.rs
+++ b/crates/engine/src/cmd/shape_tool.rs
@@ -180,16 +180,17 @@ fn rgba(c: [f32; 3]) -> [f64; 4] {
     [c[0] as f64, c[1] as f64, c[2] as f64, 1.0]
 }
 
-/// The Rounded Rectangle tool's corner roundness for `size`.
-fn roundness(size: [f64; 2]) -> f64 {
-    size[0].min(size[1]) * 0.15
+/// The Rounded Rectangle tool's corner roundness: a fixed default, as in After Effects
+/// (it does not grow with the drawn size).
+fn roundness() -> f64 {
+    20.0
 }
 
 /// The Polygon and Star tools' Polystar for `size`: (star, points, outer radius, inner radius).
 fn polystar_of(kind: &str, size: [f64; 2]) -> Option<(bool, f64, f64, f64)> {
     match kind {
         "star" => Some((true, 5.0, size[0] / 2.0, size[0] / 4.0)),
-        "polygon" => Some((false, 6.0, size[0] / 2.0, 0.0)),
+        "polygon" => Some((false, 5.0, size[0] / 2.0, 0.0)),
         _ => None,
     }
 }
@@ -199,7 +200,7 @@ fn polystar_of(kind: &str, size: [f64; 2]) -> Option<(bool, f64, f64, f64)> {
 pub(crate) fn shape_group(ids: &mut Ids, kind: &str, size: [f64; 2], paint: &ShapeTool) -> Option<PropGroup> {
     let (path, gname) = match kind {
         "rect" | "rectangle" => (build::shape_rect(ids, size, [0.0, 0.0], 0.0), "Rectangle 1"),
-        "rounded" | "roundedRect" => (build::shape_rect(ids, size, [0.0, 0.0], roundness(size)), "Rectangle 1"),
+        "rounded" | "roundedRect" => (build::shape_rect(ids, size, [0.0, 0.0], roundness()), "Rectangle 1"),
         "ellipse" => (build::shape_ellipse(ids, size, [0.0, 0.0]), "Ellipse 1"),
         k => {
             let (star, points, outer, inner) = polystar_of(k, size)?;
@@ -218,10 +219,19 @@ pub fn mask_path(kind: &str, centre: [f64; 2], size: [f64; 2]) -> Option<ShapePa
     let bez = match kind {
         "rect" | "rectangle" => return Some(ShapePath::rect(centre, size[0], size[1])),
         "ellipse" => return Some(ShapePath::ellipse(centre, size[0], size[1])),
-        "rounded" | "roundedRect" => effectcraft_path::rect(size, centre, roundness(size)),
+        "rounded" | "roundedRect" => effectcraft_path::rect(size, centre, roundness()),
         k => {
             let (star, points, outer, inner) = polystar_of(k, size)?;
-            effectcraft_path::polystar(star, points, centre, 0.0, inner, outer, 0.0, 0.0)
+            effectcraft_path::polystar(effectcraft_path::Polystar {
+                star,
+                points,
+                pos: centre,
+                rotation: 0.0,
+                inner,
+                outer,
+                inner_round: 0.0,
+                outer_round: 0.0,
+            })
         }
     };
     effectcraft_path::from_kurbo(&bez).into_iter().next()
diff --git a/crates/engine/src/commands/stubs.rs b/crates/engine/src/cmd/stubs.rs
similarity index 100%
rename from crates/engine/src/commands/stubs.rs
rename to crates/engine/src/cmd/stubs.rs
diff --git a/crates/engine/src/commands/styles.rs b/crates/engine/src/cmd/styles.rs
similarity index 91%
rename from crates/engine/src/commands/styles.rs
rename to crates/engine/src/cmd/styles.rs
index 82bbf5eba..4fcbcc83e 100644
--- a/crates/engine/src/commands/styles.rs
+++ b/crates/engine/src/cmd/styles.rs
@@ -25,13 +25,23 @@ fn add_styles(s: &mut Session, p: &Value, cmd: &str, styles: &[&str], enabled: b
     if ids.is_empty() {
         return Err(bad(cmd, "no layer that takes layer styles (footage, solid, precomp, text or shape layer)"));
     }
-    let uids = s.edit(label, None, |proj, state| {
+    let uids = s.edit(label, super::merge_p(p), |proj, state| {
         let gl = proj.comp(cid).ok_or(EngineError::NoComp)?.global_light.clone();
         let mut out = vec![];
         let mut sel = vec![];
         for lid in &ids {
             let mut next = proj.next_id;
             let l = layer_mut(proj, cid, *lid)?;
+            // No style: Blending Options alone (the Layer Style dialog's first change on a layer
+            // without styles).
+            if styles.is_empty() {
+                let uid = st::add_blending_options(l, &mut Ids(&mut next), &gl).ok_or_else(|| bad(cmd, "no Blending Options"))?;
+                if let Some(g) = l.props.sub_mut(GROUP) {
+                    g.enabled = true;
+                }
+                out.push(json!({"layer": lid.0, "style": st::BLENDING, "uid": uid}));
+                sel.push((*lid, uid));
+            }
             for id in styles {
                 let had = l.layer_styles().and_then(|g| g.sub(id)).is_some();
                 let uid = st::add_style(l, &mut Ids(&mut next), id, &gl, enabled).ok_or_else(|| bad(cmd, format!("unknown style `{id}`")))?;
@@ -58,6 +68,9 @@ fn add_styles(s: &mut Session, p: &Value, cmd: &str, styles: &[&str], enabled: b
 
 fn add(s: &mut Session, p: &Value) -> Result<Value> {
     let name = str_p(p, "style").ok_or_else(|| bad("layer.style.add", "missing `style` (e.g. dropShadow or \"Drop Shadow\")"))?;
+    if name.eq_ignore_ascii_case(st::BLENDING) || name.eq_ignore_ascii_case("Blending Options") {
+        return add_styles(s, p, "layer.style.add", &[], true, "Blending Options");
+    }
     let id = st::style_id(name)
         .ok_or_else(|| bad("layer.style.add", format!("unknown style `{name}`; one of {}", STYLES.iter().map(|s| s.0).collect::<Vec<_>>().join(", "))))?;
     let label = STYLES.iter().find(|s| s.0 == id).map(|s| s.1).unwrap_or(id);
@@ -139,8 +152,9 @@ fn remove(s: &mut Session, p: &Value) -> Result<Value> {
                 return Err(bad("layer.style.remove", "Blending Options can't be removed"));
             }
             g.children.retain(|c| c.uid() != uid);
-            // The last style gone removes the Layer Styles group, as in AE.
-            if g.children.iter().all(|c| c.match_id() == st::BLENDING) {
+            // The last style gone removes the Layer Styles group, as in AE, unless its Blending
+            // Options were changed (they can be edited with no style since #1389).
+            if g.children.iter().all(|c| c.match_id() == st::BLENDING) && g.sub(st::BLENDING).is_none_or(st::blending_is_default) {
                 l.props.children.retain(|c| c.match_id() != GROUP);
             }
         }
@@ -224,7 +238,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Add Layer Style",
             [],
             None,
-            "{style: dropShadow|innerShadow|outerGlow|innerGlow|bevelEmboss|satin|colorOverlay|gradientOverlay|stroke (or display name), layers?}",
+            "{style: dropShadow|innerShadow|outerGlow|innerGlow|bevelEmboss|satin|colorOverlay|gradientOverlay|stroke (or display name), or blendingOptions (the Layer Styles group with Blending Options only), layers?, merge?}",
             has_layers,
             add
         ),
diff --git a/crates/engine/src/commands/text_anim.rs b/crates/engine/src/cmd/text_anim.rs
similarity index 98%
rename from crates/engine/src/commands/text_anim.rs
rename to crates/engine/src/cmd/text_anim.rs
index 92ab23f17..296dc4c37 100644
--- a/crates/engine/src/commands/text_anim.rs
+++ b/crates/engine/src/cmd/text_anim.rs
@@ -142,6 +142,7 @@ fn add_animator_prop(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let layer = s.project.comp(cid).and_then(|c| c.layer(lid)).cloned().ok_or_else(|| bad(C, "no layer"))?;
     let auid = animator_uid(s, &layer, p, C)?;
+    let mut index = 0;
     s.edit("Add Text Animator Property", None, |proj, _| {
         let mut next = proj.next_id;
         let mut ids = Ids(&mut next);
@@ -151,10 +152,13 @@ fn add_animator_prop(s: &mut Session, p: &Value) -> Result<Value> {
         for k in &kinds {
             add_props(&mut ids, anim, k, three);
         }
+        // The requested property's 1-based position in the Properties group. A companion (such as
+        // Tracking Type) is added before it, so the first new child is not always the one asked for.
+        index = kinds.first().and_then(|k| anim.sub("properties")?.children.iter().position(|n| n.match_id() == k.as_str())).map_or(0, |i| i + 1);
         proj.next_id = next;
         Ok(())
     })?;
-    Ok(json!({"animator": auid}))
+    Ok(json!({"animator": auid, "index": index}))
 }
 
 pub(crate) fn add_selector(s: &mut Session, p: &Value) -> Result<Value> {
diff --git a/crates/engine/src/commands/text_edit.rs b/crates/engine/src/cmd/text_edit.rs
similarity index 96%
rename from crates/engine/src/commands/text_edit.rs
rename to crates/engine/src/cmd/text_edit.rs
index 9de40c588..cdb650486 100644
--- a/crates/engine/src/commands/text_edit.rs
+++ b/crates/engine/src/cmd/text_edit.rs
@@ -14,6 +14,8 @@ use serde_json::{Value, json};
 /// never reuses a live IME context). Exhaustion wraps; it cannot panic.
 static NEXT_EDIT_SESSION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
 
+/// Takes the next session token: returns the counter's current value and increments it, so
+/// successive tokens differ until the process-wide `u64` counter wraps.
 pub(super) fn next_edit_session() -> u64 {
     NEXT_EDIT_SESSION.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
 }
@@ -27,10 +29,14 @@ pub(super) fn next_edit_session() -> u64 {
 /// receipt rather than claiming a mutation with a reused revision.
 static NEXT_IME_REVISION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
 
+/// Allocates a fresh process-wide IME revision, or `None` once the counter has nowhere left
+/// to advance; callers keep their existing stamp rather than reuse one.
 pub(crate) fn next_ime_revision() -> Option<u64> {
     allocate_ime_revision(&NEXT_IME_REVISION)
 }
 
+/// Takes the next value of `counter` with a compare-exchange loop: `Some(current + 1)` after
+/// storing it, or `None` without storing when the counter is already `u64::MAX`.
 fn allocate_ime_revision(counter: &std::sync::atomic::AtomicU64) -> Option<u64> {
     use std::sync::atomic::Ordering::Relaxed;
     let mut current = counter.load(Relaxed);
@@ -65,7 +71,8 @@ pub struct TextEdit {
     /// Character panel changes made with only a caret: the style the next typed text takes.
     #[serde(default)]
     pub pending: Option<CharStyle>,
-    /// The layer was made by a Type tool click; leaving it empty deletes it.
+    /// The layer was made by a Type tool click. Kept when left empty, as After Effects does, so this
+    /// only records how the edit began.
     #[serde(default)]
     pub created: bool,
     /// Line position kept by repeated up / down moves (layout space).
@@ -85,6 +92,8 @@ pub struct TextEdit {
 }
 
 impl Default for TextEdit {
+    /// An empty, uncreated editing session on layer `0` with no selection, pending style or goal
+    /// column, and a fresh process-wide session token.
     fn default() -> Self {
         Self { layer: LayerId(0), anchor: 0, caret: 0, pending: None, created: false, goal_x: None, session: next_edit_session() }
     }
@@ -364,18 +373,14 @@ fn edit(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(state_json(s))
 }
 
-/// `text.endEdit`: stop editing (a Type-tool layer left empty is deleted).
+/// `text.endEdit`: stop editing.
+///
+/// A Type-tool layer the user clicked away from without typing is **kept**: After Effects leaves it in
+/// the timeline as `<空白のテキストレイヤー>`, and the layer came from the user's click rather than from a
+/// mistake to clean up. Deleting it took away something they could still type into.
 pub(crate) fn end_edit(s: &mut Session, _: &Value) -> Result<Value> {
-    let Some(e) = s.state.text_edit.take() else { return Ok(Value::Null) };
-    if e.created && layer_doc(s, e.layer).is_some_and(|d| d.text.is_empty()) {
-        let cid = s.active_comp_id().ok_or(EngineError::NoComp)?;
-        s.edit("Delete Empty Text Layer", None, |proj, st| {
-            if let Some(c) = proj.comp_mut(cid) {
-                c.layers.retain(|l| l.id != e.layer);
-            }
-            st.selected_layers.retain(|l| *l != e.layer);
-            Ok(())
-        })?;
+    if s.state.text_edit.take().is_none() {
+        return Ok(Value::Null);
     }
     s.bump();
     Ok(Value::Null)
@@ -909,6 +914,8 @@ fn editing(s: &Session) -> std::result::Result<(), String> {
     if s.state.text_edit.is_some() { Ok(()) } else { Err("not editing text".into()) }
 }
 
+/// The command specs of this module: the `text.*` editing, selection and caret commands and
+/// the two `edit.pasteText*` commands, each with its parameter shape and enablement predicate.
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         cmd!(
diff --git a/crates/engine/src/commands/three_d.rs b/crates/engine/src/cmd/three_d.rs
similarity index 93%
rename from crates/engine/src/commands/three_d.rs
rename to crates/engine/src/cmd/three_d.rs
index e143690d3..f7b1c3e08 100644
--- a/crates/engine/src/commands/three_d.rs
+++ b/crates/engine/src/cmd/three_d.rs
@@ -12,6 +12,7 @@ use effectcraft_time::Tick;
 use serde_json::{Value, json};
 
 use super::layer::{color_p, insert_layer};
+use super::model3d::{report_switch, use_advanced_3d};
 use super::{CommandSpec, b_p, bad, comp_id, f_p, has_comp, layer_mut, layer_p, merge_p, str_p, time_p};
 use crate::{EngineError, Result, Session, cmd, query};
 
@@ -227,12 +228,17 @@ fn new_light(s: &mut Session, p: &Value) -> Result<Value> {
     };
     let name = str_p(p, "name").unwrap_or("Light 1").to_string();
     let t = time_p(s, p, Some(&comp));
-    let id = s.edit("New Light", None, |proj, st| {
+    // Only the Advanced 3D renderer lights with Environment lights, so adding one switches a
+    // Classic 3D comp to it, like After Effects (inside the adding edit: one undo step).
+    let env = kind == LightKind::Environment;
+    let (id, switched) = s.edit("New Light", None, |proj, st| {
         let mut l = build::layer(proj, &comp, &name, LayerSource::Light { kind }, (comp.width, comp.height), None);
         apply_light(&mut l, p, t, "layer.newLight")?;
-        insert_layer(proj, st, cid, l)
+        let id = insert_layer(proj, st, cid, l)?;
+        Ok((id, if env { use_advanced_3d(proj, cid)? } else { false }))
     })?;
-    Ok(json!({"layer": id.0}))
+    report_switch(s, cid, switched, "which Environment lights need to light the scene");
+    Ok(json!({"layer": id.0, "advanced3d": env}))
 }
 
 fn light_settings(s: &mut Session, p: &Value) -> Result<Value> {
@@ -248,7 +254,7 @@ fn light_settings(s: &mut Session, p: &Value) -> Result<Value> {
         ),
         None => None,
     };
-    s.edit("Light Settings", None, |proj, _| {
+    let switched = s.edit("Light Settings", None, |proj, _| {
         let old = proj.comp(cid).and_then(|c| c.layer(lid)).cloned().ok_or(EngineError::NoComp)?;
         let mut l = old.clone();
         if let Some(k) = kind
@@ -288,9 +294,14 @@ fn light_settings(s: &mut Session, p: &Value) -> Result<Value> {
             l.name = n.clone();
         }
         apply_light(&mut l, p, t, "layer.lightSettings")?;
+        // A light that becomes an Environment light switches a Classic 3D comp to Advanced 3D,
+        // like adding one does; editing one that already is leaves the renderer to the user.
+        let was_env = matches!(old.source, LayerSource::Light { kind: LightKind::Environment });
+        let is_env = matches!(l.source, LayerSource::Light { kind: LightKind::Environment });
         *layer_mut(proj, cid, lid)? = l;
-        Ok(())
+        Ok(if !was_env && is_env { use_advanced_3d(proj, cid)? } else { false })
     })?;
+    report_switch(s, cid, switched, "which Environment lights need to light the scene");
     Ok(Value::Null)
 }
 
@@ -413,7 +424,8 @@ fn get_3d(s: &mut Session, p: &Value) -> Result<Value> {
     let (w, h) = (comp.width as f64, comp.height as f64);
     let vs = s.state.views3d.get(&cid).cloned().unwrap_or_default();
     let t = s.state.times.get(&cid).copied().unwrap_or(Tick::ZERO);
-    let ctx = EvalCtx { project: &s.project, comp_id: cid, comp, time: t, expr: s.expr.as_deref(), footage: None };
+    let ctx =
+        EvalCtx { project: &s.project, comp_id: cid, comp, time: t, expr: s.expr.as_deref(), footage: None, property_overrides: &[], media_overrides: &[] };
     let cam = vs.override_camera(w, h).unwrap_or_else(|| camera::active_camera(&ctx));
     let f = cam.forward();
     let lights: Vec<Value> = comp
@@ -532,7 +544,7 @@ fn auto_orient(s: &mut Session, p: &Value) -> Result<Value> {
     };
     s.edit("Auto-Orient", None, |proj, _| {
         let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+        for l in comp.layers.iter_mut_where(|l| ids.contains(&l.id)) {
             let rig = l.is_camera() || l.is_light();
             let ok = match mode {
                 AutoOrient::Off | AutoOrient::AlongPath => true,
@@ -555,7 +567,8 @@ fn auto_orient(s: &mut Session, p: &Value) -> Result<Value> {
 /// through each layer's world matrix; cameras and lights contribute their position).
 fn layer_points(s: &Session, cid: ItemId, ids: &[LayerId], t: Tick) -> Vec<Vec3> {
     let Some(comp) = s.project.comp(cid) else { return vec![] };
-    let ctx = EvalCtx { project: &s.project, comp_id: cid, comp, time: t, expr: s.expr.as_deref(), footage: None };
+    let ctx =
+        EvalCtx { project: &s.project, comp_id: cid, comp, time: t, expr: s.expr.as_deref(), footage: None, property_overrides: &[], media_overrides: &[] };
     let mut out = vec![];
     for l in comp.layers.iter().filter(|l| ids.contains(&l.id)) {
         let m = ctx.world_matrix(l);
@@ -681,7 +694,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Light...",
             ["Layer", "New"],
             Some("Cmd+Alt+Shift+L"),
-            "{kind?: Parallel|Spot|Point|Ambient|Environment (default Spot; Environment lights and reflects from an equirectangular image layer: prop.set its lightOptions/source to that layer's id, or leave it empty for the comp's Environment Layer, see layer.environment), name?, color?, intensity?, coneAngle?, coneFeather?, falloff?: None|Smooth|Inverse Square Clamped, radius?, falloffDistance?, castsShadows?, shadowDarkness?, shadowDiffusion?, position? [x,y,z], poi? [x,y,z]}",
+            "{kind?: Parallel|Spot|Point|Ambient|Environment (default Spot; Environment lights and reflects from an equirectangular image layer: prop.set its lightOptions/source to that layer's id, or leave it empty for the comp's Environment Layer or a flat default environment of its colour and intensity, see layer.environment; an Environment light switches a Classic 3D comp to Advanced 3D), name?, color?, intensity?, coneAngle?, coneFeather?, falloff?: None|Smooth|Inverse Square Clamped, radius?, falloffDistance?, castsShadows?, shadowDarkness?, shadowDiffusion?, position? [x,y,z], poi? [x,y,z]}",
             has_comp,
             new_light
         ),
@@ -708,7 +721,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Light Settings...",
             [],
             None,
-            "{layer?, name?, kind?: Parallel|Spot|Point|Ambient|Environment, color?, intensity?, coneAngle?, coneFeather?, falloff?, radius?, falloffDistance?, castsShadows?, shadowDarkness?, shadowDiffusion?, position?, poi?}",
+            "{layer?, name?, kind?: Parallel|Spot|Point|Ambient|Environment (changing to Environment switches a Classic 3D comp to Advanced 3D), color?, intensity?, coneAngle?, coneFeather?, falloff?, radius?, falloffDistance?, castsShadows?, shadowDarkness?, shadowDiffusion?, position?, poi?}",
             has_comp,
             light_settings
         ),
diff --git a/crates/engine/src/commands/time.rs b/crates/engine/src/cmd/time.rs
similarity index 100%
rename from crates/engine/src/commands/time.rs
rename to crates/engine/src/cmd/time.rs
diff --git a/crates/engine/src/commands/timeline.rs b/crates/engine/src/cmd/timeline.rs
similarity index 66%
rename from crates/engine/src/commands/timeline.rs
rename to crates/engine/src/cmd/timeline.rs
index 633e73c5a..fbc11654f 100644
--- a/crates/engine/src/commands/timeline.rs
+++ b/crates/engine/src/cmd/timeline.rs
@@ -5,14 +5,18 @@
 //! The native `.prproj` format has no public specification and is not read or written.
 
 use std::collections::HashMap;
+use std::sync::Arc;
 
 use effectcraft_interchange::{ExportOptions, ImportOptions, PrecompMode, PrerenderMode, Prerendered, TimelineFormat};
 use effectcraft_project::render_queue::{AudioOutput, Channels, OutputFormat, OutputModule, ProResProfile, RenderQueueItem, TimeSpan};
 use effectcraft_project::{ItemId, LayerId, LayerSource, Project};
 use serde_json::{Value, json};
 
-use super::{CommandSpec, always, bad, comp_id, f_p, has_comp, str_p};
-use crate::{EngineError, Result, Session, cmd};
+use super::{CommandSpec, always, b_p, bad, comp_id, f_p, has_comp, str_p};
+use crate::jobs::TaskCtl;
+use crate::{EngineError, Exporter, Result, Session, cmd};
+
+mod staging;
 
 fn format_p(p: &Value, cmd: &str) -> Result<Option<TimelineFormat>> {
     match str_p(p, "format") {
@@ -95,18 +99,35 @@ fn isolate(project: &Project, cid: ItemId, lid: LayerId) -> Option<Project> {
     Some(q)
 }
 
-/// Render one layer to ProRes 4444 with alpha over its in–out span.
-fn prerender(s: &Session, cid: ItemId, lid: LayerId, path: &str) -> std::result::Result<Prerendered, String> {
-    let exporter = s.exporter.clone().ok_or("export is not available in this build")?;
+/// What a pre-render needs from the session, so it can run on a background thread.
+struct PrerenderCx {
+    protected: crate::output_guard::Protected,
+    exporter: Option<Arc<dyn Exporter>>,
+    footage: Arc<dyn effectcraft_render::FootageSource>,
+    expr: Option<Arc<dyn effectcraft_render::ExprHost>>,
+    accel: Option<Arc<dyn effectcraft_render::Accelerator>>,
+    nested_switches: bool,
+}
+
+/// Render one layer to ProRes 4444 with alpha over its in–out span; `progress` as the exporter's.
+fn prerender(
+    cx: &PrerenderCx,
+    project: &Project,
+    cid: ItemId,
+    lid: LayerId,
+    path: &str,
+    progress: &mut dyn FnMut(u64, u64) -> bool,
+) -> std::result::Result<Prerendered, String> {
+    let exporter = cx.exporter.as_ref().ok_or("export is not available in this build")?;
     if !exporter.formats().contains(&OutputFormat::ProRes) {
         return Err("ProRes export is not available in this build".into());
     }
-    let comp = s.project.comp(cid).ok_or("no composition")?;
+    let comp = project.comp(cid).ok_or("no composition")?;
     let l = comp.layer(lid).ok_or("no layer")?;
     let fd = comp.frame_duration();
     let start = comp.frame_rate.snap(l.in_point.max(effectcraft_time::Tick::ZERO));
     let end = l.out_point.min(comp.duration).max(start + fd);
-    let q = isolate(&s.project, cid, lid).ok_or("no composition")?;
+    let q = isolate(project, cid, lid).ok_or("no composition")?;
     let mut item = RenderQueueItem::new(0, cid);
     item.settings.time_span = TimeSpan::Custom { start, end };
     item.output = OutputModule::for_format(OutputFormat::ProRes);
@@ -116,16 +137,16 @@ fn prerender(s: &Session, cid: ItemId, lid: LayerId, path: &str) -> std::result:
     item.output.output = path.to_string();
     let job = crate::ExportJob {
         project: &q,
-        footage: s.footage.as_ref(),
-        expr: s.expr.as_deref(),
-        accel: s.accel.as_deref(),
+        footage: cx.footage.as_ref(),
+        expr: cx.expr.as_deref(),
+        accel: cx.accel.as_deref(),
         item: &item,
         path,
         storage: None,
         label: format!("Pre-render {}", l.name),
-        nested_switches: s.prefs.general.switches_affect_nested_comps,
+        nested_switches: cx.nested_switches,
     };
-    let r = exporter.export(&job, &mut |_, _| true)?;
+    let r = exporter.export(&job, progress)?;
     Ok(Prerendered { path: r.path, width: comp.width, height: comp.height, frame_rate: comp.frame_rate, duration: end - start })
 }
 
@@ -139,6 +160,7 @@ fn export_timeline(s: &mut Session, p: &Value) -> Result<Value> {
         }
         path = format!("{path}.{}", format.extension());
     }
+    s.refuse_export(&path)?;
     let cid = comp_id(s, p)?;
     let prerender_mode = match str_p(p, "prerender") {
         None => match p.get("prerender").and_then(Value::as_bool) {
@@ -157,33 +179,86 @@ fn export_timeline(s: &mut Session, p: &Value) -> Result<Value> {
     let stem = fp.file_stem().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "Timeline".into());
     let relative_to = Some(dir.to_string_lossy().to_string()).filter(|d| !d.is_empty());
     let opts = ExportOptions { format, prerender: prerender_mode, precomps, relative_to };
-    // Pre-render what the timeline can't represent.
+    let project = s.project.clone();
+    let cx = PrerenderCx {
+        protected: crate::output_guard::Protected::of(s),
+        exporter: s.exporter.clone(),
+        footage: s.footage.clone(),
+        expr: s.expr.clone(),
+        accel: s.accel.clone(),
+        nested_switches: s.prefs.general.switches_affect_nested_comps,
+    };
+    // The pre-renders can take minutes: with `background` (the export dialog) they run as a job
+    // in Window ▸ Progress instead of with the window waiting (#2269).
+    let wait = !b_p(p, "background").unwrap_or(false);
+    s.spawn_task("exportTimeline", format!("Export {}", format.label()), wait, move |ctl| {
+        let (bytes, mut result, staged) = export_timeline_work(&cx, &project, cid, &opts, &dir, &stem, ctl)?;
+        if let Some(source) = cx.protected.find(std::path::Path::new(&path)) {
+            return Err(source.refusal(&path, crate::output_guard::Use::Export));
+        }
+        result["path"] = json!(path);
+        result["toast"] = json!(match format {
+            TimelineFormat::Fcp7Xml => format!("Exported {path} (Final Cut Pro XML; import it in Premiere Pro with File ▸ Import)"),
+            _ => format!("Exported {path} ({})", format.label()),
+        });
+        Ok(Box::new(move |s: &mut Session| {
+            s.refuse_export(&path)?;
+            staging::commit(staged, s)?;
+            s.write_output(&path, &bytes)?;
+            Ok(result)
+        }))
+    })
+}
+
+/// Pre-render what the timeline can't represent, then build the timeline: its bytes and the
+/// command's result (without `path`).
+fn export_timeline_work(
+    cx: &PrerenderCx,
+    project: &Project,
+    cid: ItemId,
+    opts: &ExportOptions,
+    dir: &std::path::Path,
+    stem: &str,
+    ctl: &TaskCtl,
+) -> std::result::Result<(Vec<u8>, Value, Vec<staging::Movie>), String> {
     let mut pre: HashMap<(ItemId, LayerId), Prerendered> = HashMap::new();
     let mut rendered = vec![];
     let mut errors = vec![];
-    for (c, l) in effectcraft_interchange::plan_prerender(&s.project, cid, &opts) {
-        let comp_name = s.project.item(c).map(|i| i.name.clone()).unwrap_or_default();
-        let layer_name = s.project.comp(c).and_then(|cc| cc.layer(l)).map(|x| x.name.clone()).unwrap_or_default();
+    let mut staged = vec![];
+    let plan = effectcraft_interchange::plan_prerender(project, cid, opts);
+    if plan.len() > staging::MAX_MOVIES {
+        return Err(format!("too many pre-render movies (limit {})", staging::MAX_MOVIES));
+    }
+    let n = plan.len() as u64;
+    for (i, (c, l)) in (0u64..).zip(plan) {
+        let comp_name = project.item(c).map(|it| it.name.clone()).unwrap_or_default();
+        let layer_name = project.comp(c).and_then(|cc| cc.layer(l)).map(|x| x.name.clone()).unwrap_or_default();
+        ctl.message(format!("Pre-render {layer_name}"));
         let file = dir.join(format!("{stem}_{}_{}_{}.mov", safe(&comp_name), safe(&layer_name), l.0)).to_string_lossy().to_string();
-        match prerender(s, c, l, &file) {
-            Ok(r) => {
+        // The movies are outputs too: never over footage, a proxy or the project file.
+        if let Some(source) = cx.protected.find(std::path::Path::new(&file)) {
+            errors.push(format!("{comp_name} ▸ {layer_name}: {}", source.refusal(&file, crate::output_guard::Use::Export)));
+            continue;
+        }
+        // Progress over all the layers, each one's frames a share of it.
+        let mut progress = |done: u64, total: u64| ctl.progress(i * 1000 + done.saturating_mul(1000) / total.max(1), n * 1000);
+        let movie = staging::Movie::new(&file)?;
+        match prerender(cx, project, c, l, &movie.path, &mut progress) {
+            Ok(mut r) => {
+                r.path = file;
                 rendered.push(r.path.clone());
                 pre.insert((c, l), r);
+                staged.push(movie);
             }
+            Err(_) if ctl.cancelled() => return Err(crate::render_queue::CANCELLED.into()),
             Err(e) => errors.push(format!("{comp_name} ▸ {layer_name}: {e}")),
         }
     }
-    let out = effectcraft_interchange::export(&s.project, cid, &opts, &pre).map_err(|e| EngineError::Other(e.to_string()))?;
-    s.services.write_file(&path, &out.bytes).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+    let out = effectcraft_interchange::export(project, cid, opts, &pre).map_err(|e| e.to_string())?;
     let mut warnings = out.warnings.clone();
     warnings.extend(errors.iter().map(|e| format!("pre-render failed: {e}")));
-    s.toast(match format {
-        TimelineFormat::Fcp7Xml => format!("Exported {path} (Final Cut Pro XML; import it in Premiere Pro with File ▸ Import)"),
-        _ => format!("Exported {path} ({})", format.label()),
-    });
-    Ok(json!({
-        "path": path,
-        "format": format.id(),
+    let result = json!({
+        "format": opts.format.id(),
         "bytes": out.bytes.len(),
         "sequences": out.sequences,
         "videoTracks": out.video_tracks,
@@ -191,7 +266,8 @@ fn export_timeline(s: &mut Session, p: &Value) -> Result<Value> {
         "clips": out.clips,
         "prerendered": rendered,
         "warnings": warnings,
-    }))
+    });
+    Ok((out.bytes, result, staged))
 }
 
 /// The formats, for agents and the export dialog.
@@ -220,7 +296,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Adobe Premiere Pro Project...",
             ["File", "Export"],
             None,
-            "{comp?, path (Final Cut Pro XML .xml for Premiere Pro or .fcpxml .otio .edl .aaf .omf), format?: xml|fcpxml|otio|edl|aaf|omf, prerender?: none|unsupported|all, precomps?: nest|prerender}",
+            "{comp?, path (Final Cut Pro XML .xml for Premiere Pro or .fcpxml .otio .edl .aaf .omf), format?: xml|fcpxml|otio|edl|aaf|omf, prerender?: none|unsupported|all, precomps?: nest|prerender, background?: bool (pre-render and write as a job, jobs.list / jobs.wait; returns {job})}",
             has_comp,
             export_timeline
         ),
diff --git a/crates/engine/src/cmd/timeline/staging.rs b/crates/engine/src/cmd/timeline/staging.rs
new file mode 100644
index 000000000..026b1200a
--- /dev/null
+++ b/crates/engine/src/cmd/timeline/staging.rs
@@ -0,0 +1,89 @@
+//! Native pre-render files stay private until the app can check the current project.
+
+#[cfg(not(target_arch = "wasm32"))]
+use crate::EngineError;
+use crate::Session;
+
+pub(super) const MAX_MOVIES: usize = 4096;
+
+pub(super) struct Movie {
+    pub path: String,
+    #[cfg(not(target_arch = "wasm32"))]
+    directory: tempfile::TempDir,
+    #[cfg(not(target_arch = "wasm32"))]
+    destination: std::path::PathBuf,
+}
+
+impl Movie {
+    pub fn new(path: &str) -> Result<Self, String> {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            let path = std::path::Path::new(path);
+            let parent = path.parent().filter(|p| !p.as_os_str().is_empty()).unwrap_or(std::path::Path::new("."));
+            std::fs::create_dir_all(parent).map_err(|e| format!("cannot create pre-render folder {}: {e}", parent.display()))?;
+            let directory =
+                tempfile::Builder::new().prefix(".effectcraft-prerender-").tempdir_in(parent).map_err(|e| format!("cannot stage pre-render: {e}"))?;
+            let name = path.file_name().ok_or_else(|| format!("pre-render has no file name: {}", path.display()))?;
+            let staged = directory.path().join(name).to_string_lossy().into_owned();
+            Ok(Self { path: staged, directory, destination: parent.to_path_buf() })
+        }
+        #[cfg(target_arch = "wasm32")]
+        {
+            // spawn_task is synchronous on WASM, so session mutations cannot interleave.
+            Ok(Self { path: path.to_string() })
+        }
+    }
+}
+
+pub(super) fn commit(movies: Vec<Movie>, session: &Session) -> crate::Result<()> {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        const FILES_PER_MOVIE: usize = 8;
+        if movies.len() > MAX_MOVIES {
+            return Err(EngineError::Other("too many staged pre-render movies".into()));
+        }
+        let mut files = Vec::new();
+        let mut path_bytes = 0usize;
+        for movie in &movies {
+            let entries = std::fs::read_dir(movie.directory.path()).map_err(|e| EngineError::Other(format!("cannot read staged pre-render: {e}")))?;
+            for (index, entry) in entries.take(FILES_PER_MOVIE + 1).enumerate() {
+                if index == FILES_PER_MOVIE {
+                    return Err(EngineError::Other("too many files in a staged pre-render".into()));
+                }
+                let entry = entry.map_err(|e| EngineError::Other(format!("cannot read staged pre-render entry: {e}")))?;
+                let kind = entry.file_type().map_err(|e| EngineError::Other(format!("cannot inspect staged pre-render: {e}")))?;
+                if !kind.is_file() {
+                    return Err(EngineError::Other("a staged pre-render contains an unexpected directory or link".into()));
+                }
+                let source = entry.path();
+                let destination = movie.destination.join(entry.file_name());
+                path_bytes = path_bytes.saturating_add(source.as_os_str().len()).saturating_add(destination.as_os_str().len());
+                if path_bytes > 16 * 1024 * 1024 {
+                    return Err(EngineError::Other("staged pre-render paths exceed the 16 MiB limit".into()));
+                }
+                files.push((source, destination));
+            }
+        }
+        // If a user imported a private staging file, leave the staging folders intact.
+        let protected = session.protected_files();
+        if let Some((source, _)) = files.iter().find(|(source, _)| protected.find(source).is_some()) {
+            let source = source.display().to_string();
+            for movie in movies {
+                let _kept = movie.directory.keep();
+            }
+            return Err(EngineError::Other(format!("staged pre-render {source} is now used by the project; its temporary folder was kept")));
+        }
+        // Preflight every destination before replacing any output, including render logs.
+        for (_, destination) in &files {
+            if let Some(found) = protected.find(destination) {
+                return Err(EngineError::Other(found.refusal(&destination.to_string_lossy(), crate::output_guard::Use::Export)));
+            }
+        }
+        for (source, destination) in files {
+            std::fs::rename(&source, &destination).map_err(|e| EngineError::Other(format!("cannot publish pre-render {}: {e}", destination.display())))?;
+        }
+    }
+    #[cfg(target_arch = "wasm32")]
+    let _ = (movies, session);
+    Ok(())
+}
diff --git a/crates/engine/src/commands/track.rs b/crates/engine/src/cmd/track.rs
similarity index 100%
rename from crates/engine/src/commands/track.rs
rename to crates/engine/src/cmd/track.rs
diff --git a/crates/engine/src/commands/view.rs b/crates/engine/src/cmd/view.rs
similarity index 98%
rename from crates/engine/src/commands/view.rs
rename to crates/engine/src/cmd/view.rs
index a36c53933..115da8667 100644
--- a/crates/engine/src/commands/view.rs
+++ b/crates/engine/src/cmd/view.rs
@@ -83,10 +83,11 @@ fn clear_guides(s: &mut Session, p: &Value) -> Result<Value> {
 
 fn export_guides(s: &mut Session, p: &Value) -> Result<Value> {
     let path = str_p(p, "path").ok_or_else(|| bad("view.exportGuides", "missing `path`"))?;
+    s.refuse_export(path)?;
     let comp = s.project.comp(comp_id(s, p)?).ok_or(EngineError::NoComp)?;
     let doc = json!({"effectcraftGuides": 1, "width": comp.width, "height": comp.height, "guides": comp.guides});
     let text = serde_json::to_string_pretty(&doc).unwrap_or_default();
-    s.services.write_file(path, text.as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+    s.write_output(path, text.as_bytes())?;
     Ok(json!({"path": path, "guides": comp.guides.len()}))
 }
 
diff --git a/crates/engine/src/commands/viewer_cmds.rs b/crates/engine/src/cmd/viewer_cmds.rs
similarity index 100%
rename from crates/engine/src/commands/viewer_cmds.rs
rename to crates/engine/src/cmd/viewer_cmds.rs
diff --git a/crates/engine/src/commands/vpe.rs b/crates/engine/src/cmd/vpe.rs
similarity index 100%
rename from crates/engine/src/commands/vpe.rs
rename to crates/engine/src/cmd/vpe.rs
diff --git a/crates/engine/src/commands/vr_editor.rs b/crates/engine/src/cmd/vr_editor.rs
similarity index 100%
rename from crates/engine/src/commands/vr_editor.rs
rename to crates/engine/src/cmd/vr_editor.rs
diff --git a/crates/engine/src/commands/warp_cmds.rs b/crates/engine/src/cmd/warp_cmds.rs
similarity index 100%
rename from crates/engine/src/commands/warp_cmds.rs
rename to crates/engine/src/cmd/warp_cmds.rs
diff --git a/crates/engine/src/commands/watch_folder.rs b/crates/engine/src/cmd/watch_folder.rs
similarity index 100%
rename from crates/engine/src/commands/watch_folder.rs
rename to crates/engine/src/cmd/watch_folder.rs
diff --git a/crates/engine/src/commands/layer.rs b/crates/engine/src/commands/layer.rs
deleted file mode 100644
index 8ff43f32e..000000000
--- a/crates/engine/src/commands/layer.rs
+++ /dev/null
@@ -1,1984 +0,0 @@
-//! Layer menu.
-
-use effectcraft_color::{BlendMode, Label};
-use effectcraft_keyframe::{Justify, TextDoc, Value as KV};
-use effectcraft_project::build::{self, Ids};
-use effectcraft_project::{
-    Comp, FootageKind, FrameBlend, GroupKind, ItemId, ItemKind, Layer, LayerId, LayerSource, MaskMode, MatteKind, Node, Project, PropGroup, Quality, Solid,
-    TrackMatte, limits,
-};
-use effectcraft_time::Tick;
-use serde_json::{Value, json};
-
-use super::{CommandSpec, b_p, bad, comp_id, f_p, has_comp, has_layers, layer_mut, layer_p, layers_p, merge_p, resolve_layer, str_p, unlocked};
-use crate::{EngineError, Result, Session, cmd};
-
-pub(crate) fn color_p(p: &Value, k: &str) -> Option<[f32; 3]> {
-    match p.get(k)? {
-        Value::String(s) => effectcraft_color::Rgba::from_hex(s).map(|c| [c.r, c.g, c.b]),
-        Value::Array(a) => {
-            let g = |i: usize| a.get(i).and_then(Value::as_f64).unwrap_or(0.0) as f32;
-            Some([g(0), g(1), g(2)])
-        }
-        _ => None,
-    }
-}
-
-/// Insert a new layer above the selection (or at the top) and select it.
-pub(crate) fn insert_layer(proj: &mut Project, st: &mut crate::EditorState, cid: ItemId, layer: Layer) -> Result<LayerId> {
-    insert_layer_at(proj, st, cid, layer, None)
-}
-
-/// `index`: an `index` parameter, the layer's 1-based place in the stack (1 = top; past the
-/// bottom = the bottom), as 0-based.
-pub(crate) fn index_p(p: &Value, cmd: &str) -> Result<Option<usize>> {
-    match p.get("index") {
-        None | Some(Value::Null) => Ok(None),
-        Some(v) => {
-            v.as_u64().filter(|i| *i >= 1).map(|i| Some(usize::try_from(i - 1).unwrap_or(usize::MAX))).ok_or_else(|| bad(cmd, "index: 1-based stack position"))
-        }
-    }
-}
-
-/// A `position` parameter: `[x, y]` in comp pixels (finite).
-pub(crate) fn position_p(p: &Value, cmd: &str) -> Result<Option<[f64; 2]>> {
-    match p.get("position") {
-        None | Some(Value::Null) => Ok(None),
-        Some(v) => v
-            .as_array()
-            .and_then(|a| Some([a.first()?.as_f64()?, a.get(1)?.as_f64()?]))
-            .filter(|c| c.iter().all(|x| x.is_finite()))
-            .map(Some)
-            .ok_or_else(|| bad(cmd, "position: [x, y] in comp pixels")),
-    }
-}
-
-/// Put a new layer's Position at `pos` (comp pixels).
-pub(crate) fn place(l: &mut Layer, pos: Option<[f64; 2]>) {
-    if let Some([x, y]) = pos
-        && let Some(pr) = l.props.prop_mut("transform/position")
-    {
-        let z = match pr.value {
-            KV::Vec3(v) => v[2],
-            _ => 0.0,
-        };
-        pr.value = KV::Vec3([x, y, z]);
-    }
-}
-
-/// [`insert_layer`] at stack position `at` (0 = top) instead of above the selected layer.
-pub(crate) fn insert_layer_at(proj: &mut Project, st: &mut crate::EditorState, cid: ItemId, mut layer: Layer, at: Option<usize>) -> Result<LayerId> {
-    // Text and shape layers in Advanced 3D comps get Geometry Options (extrusion, bevels).
-    if proj.comp(cid).is_some_and(|c| c.renderer == effectcraft_project::Renderer::Advanced3D) {
-        super::model3d::add_geometry_options(&mut proj.next_id, &mut layer);
-    }
-    let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-    let at = match at {
-        Some(i) => i.min(comp.layers.len()),
-        None => st.selected_layers.first().and_then(|id| comp.layers.iter().position(|l| l.id == *id)).unwrap_or(0),
-    };
-    let id = layer.id;
-    comp.layers.insert(at, layer);
-    st.selected_layers = vec![id];
-    st.selected_props.clear();
-    st.selected_keys.clear();
-    Ok(id)
-}
-
-fn solids_folder(proj: &mut Project) -> ItemId {
-    proj.folder_named("Solids").unwrap_or_else(|| proj.add_item("Solids", Label::Yellow, None, ItemKind::Folder))
-}
-
-fn new_solid_like(s: &mut Session, p: &Value, adjustment: bool) -> Result<Value> {
-    let cid = comp_id(s, p)?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
-    let color = color_p(p, "color").unwrap_or(if adjustment { [1.0, 1.0, 1.0] } else { [0.85, 0.2, 0.2] });
-    // 1 to 30,000 px a side (#788): the layer is sized from the same numbers as its solid.
-    let w = p.get("width").and_then(Value::as_u64).map(limits::size).unwrap_or(comp.width);
-    let h = p.get("height").and_then(Value::as_u64).map(limits::size).unwrap_or(comp.height);
-    let pixel_aspect = pixel_aspect_p(p)?.unwrap_or(comp.pixel_aspect);
-    let default_name = if adjustment { "Adjustment Layer 1".to_string() } else { "Solid 1".to_string() };
-    let name = str_p(p, "name").map(str::to_string).unwrap_or(default_name);
-    let id = s.edit(if adjustment { "New Adjustment Layer" } else { "New Solid" }, None, |proj, st| {
-        let folder = solids_folder(proj);
-        let sid = proj.add_item(&name, Label::Red, Some(folder), ItemKind::Solid(Solid { color, width: w, height: h, pixel_aspect }));
-        let mut l = build::layer(proj, &comp, &name, LayerSource::Solid { item: sid }, (w, h), None);
-        if adjustment {
-            l.switches.adjustment = true;
-            l.label = Label::Purple;
-        }
-        insert_layer(proj, st, cid, l)
-    })?;
-    Ok(json!({"layer": id.0}))
-}
-
-/// `pixelAspect` (a positive number), when given.
-fn pixel_aspect_p(p: &Value) -> Result<Option<f64>> {
-    match p.get("pixelAspect").and_then(Value::as_f64) {
-        Some(v) if !(v.is_finite() && v > 0.0) => Err(bad("layer.settings", "`pixelAspect` must be a positive number")),
-        v => Ok(v.map(limits::pixel_aspect)),
-    }
-}
-
-fn new_solid(s: &mut Session, p: &Value) -> Result<Value> {
-    new_solid_like(s, p, false)
-}
-fn new_adjustment(s: &mut Session, p: &Value) -> Result<Value> {
-    new_solid_like(s, p, true)
-}
-
-/// Parameters of `layer.setText` / `layer.newText` that aren't text attributes.
-const NOT_ATTRS: &[&str] = &["layer", "layers", "comp", "merge", "text", "range", "position", "edit"];
-
-/// Apply `layer.setText` keys to `d`: `text` replaces characters `r` (or everything), then each
-/// character / paragraph / document attribute applies to `r` (or everything).
-fn apply_text_params(cmd: &str, p: &Value, d: &mut TextDoc, r: Option<std::ops::Range<usize>>) -> Result<()> {
-    let mut r = r;
-    if let Some(t) = str_p(p, "text") {
-        match r.clone() {
-            Some(rr) => {
-                d.replace_range(rr.clone(), t, None);
-                r = Some(rr.start..rr.start + t.chars().count());
-            }
-            None => d.set_text(t),
-        }
-    }
-    let Some(obj) = p.as_object() else { return Ok(()) };
-    for (k, v) in obj {
-        if NOT_ATTRS.contains(&k.as_str()) {
-            continue;
-        }
-        if !d.set_attr(k, v, r.clone()).map_err(|e| bad(cmd, e))? {
-            return Err(bad(cmd, format!("unknown text attribute {k}")));
-        }
-    }
-    Ok(())
-}
-
-fn text_range_p(p: &Value) -> Option<std::ops::Range<usize>> {
-    let a = p.get("range")?.as_array()?;
-    let g = |i: usize| a.get(i).and_then(Value::as_u64).map(|x| x as usize);
-    let (x, y) = (g(0)?, g(1).or(g(0))?);
-    Some(x.min(y)..x.max(y))
-}
-
-fn new_text(s: &mut Session, p: &Value) -> Result<Value> {
-    let cid = comp_id(s, p)?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
-    let mut doc = TextDoc { text: "Text".into(), justify: Justify::Center, ..Default::default() };
-    // A paragraph box given in comp space: the layer sits at its centre.
-    let bx = p.get("box").and_then(Value::as_array).map(|a| [0, 1, 2, 3].map(|i| a.get(i).and_then(Value::as_f64).unwrap_or(0.0)));
-    let mut q = p.clone();
-    if let Some(o) = q.as_object_mut() {
-        o.remove("box");
-        o.remove("name");
-    }
-    let layer_name = str_p(p, "name").map(str::to_string);
-    apply_text_params("layer.newText", &q, &mut doc, None)?;
-    let mut pos = position_p(p, "layer.newText")?;
-    if let Some([x, y, w, h]) = bx {
-        let (w, h) = (w.abs().max(1.0), h.abs().max(1.0));
-        doc.box_size = Some([w, h]);
-        doc.box_pos = [-w / 2.0, -h / 2.0];
-        pos = Some([x + w / 2.0, y + h / 2.0]);
-        if p.get("justify").is_none() {
-            doc.set_attr("justify", &json!("left"), None).map_err(|e| bad("layer.newText", e))?;
-        }
-    }
-    let edit = b_p(p, "edit").unwrap_or(false);
-    let id = s.edit("New Text Layer", None, |proj, st| {
-        let name: String = layer_name.clone().unwrap_or_else(|| doc.text.lines().next().unwrap_or("").chars().take(40).collect());
-        let mut l = build::layer(proj, &comp, if name.is_empty() { "Text" } else { &name }, LayerSource::Text, (comp.width, comp.height), None);
-        if let Some(pr) = l.props.prop_mut("text/sourceText") {
-            pr.value = KV::Text(Box::new(doc.clone()));
-        }
-        if let Some(pos) = pos
-            && let Some(pr) = l.props.prop_mut("transform/position")
-        {
-            pr.value = KV::Vec3([pos[0], pos[1], 0.0]);
-        }
-        let n = doc.char_len();
-        let id = insert_layer(proj, st, cid, l)?;
-        if edit {
-            st.text_edit = Some(super::text_edit::TextEdit {
-                layer: id,
-                anchor: 0,
-                caret: n,
-                created: true,
-                session: super::text_edit::next_edit_session(),
-                ..Default::default()
-            });
-        }
-        Ok(id)
-    })?;
-    Ok(json!({"layer": id.0}))
-}
-
-fn new_shape(s: &mut Session, p: &Value) -> Result<Value> {
-    let cid = comp_id(s, p)?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
-    let kind = str_p(p, "kind").unwrap_or("none").to_string();
-    let size = p
-        .get("size")
-        .and_then(Value::as_array)
-        .map(|a| [a.first().and_then(Value::as_f64).unwrap_or(200.0), a.get(1).and_then(Value::as_f64).unwrap_or(200.0)])
-        .unwrap_or([300.0, 300.0]);
-    // A fill, and a stroke only with a width (not the Tools bar's paint).
-    let paint = super::shape_tool::paint_p(p, &Default::default(), "layer.newShape")?;
-    let pos = p
-        .get("position")
-        .and_then(|v| v.as_array())
-        .map(|a| [a.first().and_then(Value::as_f64).unwrap_or(0.0), a.get(1).and_then(Value::as_f64).unwrap_or(0.0)]);
-    let name = str_p(p, "name").unwrap_or("Shape Layer 1").to_string();
-    let id = s.edit("New Shape Layer", None, |proj, st| {
-        let lid = super::shape_tool::new_shape_layer(proj, st, &comp, cid, Some(&name), pos)?;
-        let mut next = proj.next_id;
-        let g = super::shape_tool::shape_group(&mut Ids(&mut next), &kind, size, &paint);
-        proj.next_id = next;
-        if let Some(g) = g {
-            super::shape_tool::add_to_contents(proj, cid, lid, g, [0.0, 0.0], "layer.newShape")?;
-        }
-        Ok(lid)
-    })?;
-    Ok(json!({"layer": id.0}))
-}
-
-fn new_simple(s: &mut Session, p: &Value, src: LayerSource, name: &str, label: &str) -> Result<Value> {
-    let cid = comp_id(s, p)?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
-    let name = str_p(p, "name").unwrap_or(name).to_string();
-    let id = s.edit(label, None, |proj, st| {
-        let l = build::layer(proj, &comp, &name, src, (comp.width, comp.height), None);
-        insert_layer(proj, st, cid, l)
-    })?;
-    Ok(json!({"layer": id.0}))
-}
-
-fn new_null(s: &mut Session, p: &Value) -> Result<Value> {
-    new_simple(s, p, LayerSource::Null, "Null 1", "New Null Object")
-}
-
-fn add_item(s: &mut Session, p: &Value) -> Result<Value> {
-    let cid = comp_id(s, p)?;
-    let item = match p.get("item") {
-        Some(Value::Number(n)) => ItemId(n.as_u64().unwrap_or(0)),
-        Some(Value::String(name)) => s.project.find_by_name(name).map(|i| i.id).ok_or_else(|| bad("layer.addItem", format!("no item `{name}`")))?,
-        _ => *s.state.project_selection.first().ok_or_else(|| bad("layer.addItem", "missing `item`"))?,
-    };
-    if s.project.comp_contains(item, cid) {
-        return Err(bad("layer.addItem", "a composition can't contain itself"));
-    }
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
-    let it = s.project.item(item).ok_or_else(|| bad("layer.addItem", "no such item"))?.clone();
-    let (src, size, dur) = match &it.kind {
-        ItemKind::Comp(c) => (LayerSource::Comp { item }, (c.width, c.height), Some(c.duration)),
-        ItemKind::Footage(f) if f.kind == effectcraft_project::FootageKind::Still => {
-            // `duration`, else Settings ▸ Import ▸ Still Footage: length of the composition or a
-            // duration.
-            let d = f_p(p, "duration")
-                .filter(|d| d.is_finite() && *d > 0.0)
-                .or((s.prefs.import.still_footage == "seconds").then_some(s.prefs.import.still_seconds))
-                .map(Tick::from_seconds_f64);
-            (LayerSource::Footage { item }, (f.width, f.height), d)
-        }
-        ItemKind::Footage(f) if f.kind == effectcraft_project::FootageKind::Data => {
-            return Err(bad("layer.addItem", "data files can't be layers; read them in expressions with footage(\"name\").sourceData"));
-        }
-        ItemKind::Footage(f) if f.kind == effectcraft_project::FootageKind::Model => {
-            return super::model3d::new_model(
-                s,
-                &serde_json::json!({"comp": cid.0, "item": item.0, "time": f_p(p, "time"), "index": p.get("index"), "position": p.get("position")}),
-            );
-        }
-        ItemKind::Footage(f) => (LayerSource::Footage { item }, (f.width, f.height), Some(f.looped_duration())),
-        ItemKind::Solid(so) => (LayerSource::Solid { item }, (so.width, so.height), None),
-        ItemKind::Folder => return Err(bad("layer.addItem", "folders can't be layers")),
-    };
-    let index = index_p(p, "layer.addItem")?;
-    let position = position_p(p, "layer.addItem")?;
-    let fr = comp.frame_rate;
-    // Settings ▸ General ▸ Create Layers at Composition Start Time (off: at the current time).
-    let default_start = if s.prefs.general.create_layers_at_comp_start || s.active_comp_id() != Some(cid) { Tick::ZERO } else { s.time() };
-    let start = fr.snap_nearest(f_p(p, "time").map(Tick::from_seconds_f64).unwrap_or(default_start));
-    let id = s.edit("Add Footage to Comp", None, |proj, st| {
-        let mut l = build::layer(proj, &comp, &it.name, src, size, dur);
-        l.start_time = start;
-        l.in_point = start;
-        // Footage and precomps keep their full length past the comp's end (After Effects); items
-        // without a duration (solids, comp-length stills) end with the comp.
-        let end = dur.map_or((start + comp.duration).min(comp.duration), |d| start + d);
-        l.out_point = fr.snap_nearest(end).max(start + fr.frame_duration());
-        place(&mut l, position);
-        insert_layer_at(proj, st, cid, l, index)
-    })?;
-    Ok(json!({"layer": id.0}))
-}
-
-/// A layer whose source is an item (footage, precomposition or solid), as in After Effects'
-/// Replace Source. Text, shape, null, camera, light and 3D model layers have no AVItem source to
-/// replace.
-fn replaceable_layer(l: &Layer) -> bool {
-    matches!(l.source, LayerSource::Footage { .. } | LayerSource::Comp { .. } | LayerSource::Solid { .. })
-}
-
-/// The source a Project item gives a layer, or why it can't replace one.
-fn replacement_source(item: ItemId, it: &effectcraft_project::Item) -> Result<LayerSource> {
-    const CMD: &str = "layer.replaceSource";
-    match &it.kind {
-        ItemKind::Comp(_) => Ok(LayerSource::Comp { item }),
-        ItemKind::Footage(f) if f.kind == FootageKind::Data => {
-            Err(bad(CMD, "data files can't be layer sources; read them in expressions with footage(\"name\").sourceData"))
-        }
-        ItemKind::Footage(f) if f.kind == FootageKind::Model => Err(bad(CMD, "3D model items can't replace a 2D layer source; add them as 3D layers")),
-        ItemKind::Footage(_) => Ok(LayerSource::Footage { item }),
-        ItemKind::Solid(_) => Ok(LayerSource::Solid { item }),
-        ItemKind::Folder => Err(bad(CMD, "folders can't be layer sources")),
-    }
-}
-
-/// Whether a source brings audio properties (precompositions always can; footage when it has an
-/// audio stream).
-fn source_has_audio(project: &Project, source: &LayerSource) -> bool {
-    match source {
-        LayerSource::Comp { .. } => true,
-        LayerSource::Footage { item } => project.item(*item).is_some_and(|i| matches!(&i.kind, ItemKind::Footage(f) if f.has_audio)),
-        _ => false,
-    }
-}
-
-fn has_replace_source(s: &Session) -> std::result::Result<(), String> {
-    has_comp(s)?;
-    let c = s.active_comp().ok_or("no composition")?;
-    if !s.state.selected_layers.iter().filter_map(|l| c.layer(*l)).any(replaceable_layer) {
-        return Err("select a footage, composition or solid layer".into());
-    }
-    if s.state.project_selection.is_empty() {
-        return Err("select a footage item, a composition or a solid in the Project panel".into());
-    }
-    Ok(())
-}
-
-/// Replace the source of the selected (or `layers`) AV layers with a Project item, as After
-/// Effects' Alt-drag and Ctrl+Alt+/ do. The layer keeps every property: name, timing, transforms,
-/// keyframes, expressions, effects, masks, switches, parenting and track matte. Only its source
-/// changes; precompositions bring their Essential Properties group through `sync_project`, and a
-/// source with audio adds an Audio group when the layer has none.
-fn replace_source(s: &mut Session, p: &Value) -> Result<Value> {
-    const CMD: &str = "layer.replaceSource";
-    let (cid, ids) = layers_p(s, p)?;
-    let ids = unlocked(s, cid, ids, CMD)?;
-    if ids.is_empty() {
-        return Err(bad(CMD, "select a layer first"));
-    }
-    let item = match p.get("item") {
-        Some(Value::Number(n)) => ItemId(n.as_u64().ok_or_else(|| bad(CMD, "item: a project item id"))?),
-        Some(Value::String(name)) => s.project.find_by_name(name).map(|i| i.id).ok_or_else(|| bad(CMD, format!("no item `{name}`")))?,
-        _ => *s.state.project_selection.first().ok_or_else(|| bad(CMD, "select a footage item, a composition or a solid in the Project panel"))?,
-    };
-    let it = s.project.item(item).ok_or_else(|| bad(CMD, format!("no item {}", item.0)))?;
-    let source = replacement_source(item, it)?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
-    for lid in &ids {
-        let l = comp.layer(*lid).ok_or_else(|| bad(CMD, "no such layer"))?;
-        if !replaceable_layer(l) {
-            return Err(bad(CMD, format!("“{}” has no source item to replace", l.name)));
-        }
-    }
-    if let LayerSource::Comp { item: new } = &source
-        && s.project.comp_contains(*new, cid)
-    {
-        return Err(bad(CMD, "a composition can't contain itself"));
-    }
-    let has_audio = source_has_audio(&s.project, &source);
-    let source_for_edit = source.clone();
-    s.edit("Replace Layer Source", None, |proj, _| {
-        for lid in &ids {
-            let needs_audio = has_audio && proj.comp(cid).and_then(|c| c.layer(*lid)).is_some_and(|l| l.props.sub("audio").is_none());
-            let audio = if needs_audio {
-                let mut next = Ids(&mut proj.next_id);
-                Some(build::audio(&mut next))
-            } else {
-                None
-            };
-            let l = layer_mut(proj, cid, *lid)?;
-            l.source = source_for_edit.clone();
-            if let Some(audio) = audio {
-                l.props.children.push(audio.into());
-            }
-        }
-        Ok(())
-    })?;
-    Ok(json!({"layers": ids.iter().map(|l| l.0).collect::<Vec<_>>(), "item": item.0}))
-}
-
-fn select(s: &mut Session, p: &Value) -> Result<Value> {
-    let cid = comp_id(s, p)?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
-    let ids: Vec<LayerId> = match p.get("layers").or(p.get("layer")) {
-        Some(Value::Array(a)) => a.iter().filter_map(|v| resolve_layer(comp, v)).collect(),
-        Some(v) => resolve_layer(comp, v).into_iter().collect(),
-        None => vec![],
-    };
-    let add = b_p(p, "add").unwrap_or(false);
-    let toggle = b_p(p, "toggle").unwrap_or(false);
-    if toggle {
-        for id in ids {
-            if let Some(i) = s.state.selected_layers.iter().position(|l| *l == id) {
-                s.state.selected_layers.remove(i);
-            } else {
-                s.state.selected_layers.push(id);
-            }
-        }
-    } else if add {
-        for id in ids {
-            if !s.state.selected_layers.contains(&id) {
-                s.state.selected_layers.push(id);
-            }
-        }
-    } else {
-        s.state.selected_layers = ids;
-        s.state.selected_props.clear();
-        s.state.selected_keys.clear();
-        let keep = s.state.selected_layers.clone();
-        s.state.selected_vertices.retain(|v| keep.contains(&v.layer));
-    }
-    Ok(json!(s.state.selected_layers.iter().map(|l| l.0).collect::<Vec<_>>()))
-}
-
-fn select_step(s: &mut Session, p: &Value, dir: i64) -> Result<Value> {
-    let comp = s.active_comp().ok_or(EngineError::NoComp)?;
-    if comp.layers.is_empty() {
-        return Ok(Value::Null);
-    }
-    let cur = s.state.selected_layers.first().and_then(|id| comp.layers.iter().position(|l| l.id == *id));
-    let n = comp.layers.len() as i64;
-    // The next layer that can be selected (locked and hidden shy layers are stepped over); at
-    // the end of the stack the selection stays.
-    let start = match cur {
-        Some(i) => i as i64 + dir,
-        None if dir > 0 => 0,
-        None => n - 1,
-    };
-    let next =
-        std::iter::successors(Some(start), |i| Some(i + dir)).take_while(|i| (0..n).contains(i)).find(|i| super::selectable(comp, &comp.layers[*i as usize]));
-    let Some(i) = next.or(cur.map(|i| i as i64)) else { return Ok(Value::Null) };
-    let id = comp.layers[i as usize].id;
-    let add = b_p(p, "add").unwrap_or(false);
-    if add {
-        if !s.state.selected_layers.contains(&id) {
-            s.state.selected_layers.insert(0, id);
-        }
-    } else {
-        s.state.selected_layers = vec![id];
-    }
-    Ok(json!(id.0))
-}
-
-fn select_next(s: &mut Session, p: &Value) -> Result<Value> {
-    select_step(s, p, 1)
-}
-fn select_prev(s: &mut Session, p: &Value) -> Result<Value> {
-    select_step(s, p, -1)
-}
-
-fn set_switch(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, ids) = layers_p(s, p)?;
-    let name = str_p(p, "switch").ok_or_else(|| bad("layer.setSwitch", "missing `switch`"))?.to_string();
-    let v = b_p(p, "value");
-    let label = format!("Layer Switch ({name})");
-    if b_p(p, "others") == Some(true) {
-        return set_switch_others(s, cid, &ids, &name, v, &label);
-    }
-    // `merge`: a switch dragged over several layers in the Timeline is one undo step.
-    let r = s.edit(&label, merge_p(p), |proj, _| {
-        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        let mut last = false;
-        // Toggle relative to the first layer so a multi-selection ends up consistent.
-        let first = comp.layers.iter().find(|l| ids.contains(&l.id)).map(|l| switch_value(l, &name)).unwrap_or(Some(false));
-        let Some(first) = first else { return Err(bad("layer.setSwitch", format!("unknown switch `{name}`"))) };
-        let target = v.unwrap_or(!first);
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
-            set_switch_value(l, &name, target);
-            last = target;
-        }
-        Ok(last)
-    })?;
-    Ok(json!(r))
-}
-
-/// `layer.setSwitch {others: true}` (Alt-click on an A/V feature in the Timeline): the named
-/// layers stand alone, shown / heard / soloed / unlocked while every other layer the switch
-/// applies to is the opposite; when they already do, the other layers come back. `value` sets
-/// the other layers directly.
-fn set_switch_others(s: &mut Session, cid: ItemId, ids: &[LayerId], name: &str, value: Option<bool>, label: &str) -> Result<Value> {
-    let r = s.edit(label, None, |proj, _| {
-        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        // The state that sets a layer apart: unlocked for Lock, on for the rest.
-        let active = !matches!(name, "lock" | "locked");
-        // Track mattes keep their video off by design.
-        let mattes: Vec<LayerId> =
-            if matches!(name, "video" | "eye") { comp.layers.iter().filter_map(|l| l.track_matte.map(|m| m.layer)).collect() } else { Vec::new() };
-        let applies = |l: &Layer| match name {
-            "audio" => l.props.sub("audio").is_some(),
-            "lock" | "locked" => true,
-            // Every layer has a Video switch (it hides a null's outline in the viewer and turns a
-            // camera or light off), as the Timeline's eye cell shows; track mattes keep theirs off
-            // by design.
-            "video" | "eye" => !mattes.contains(&l.id),
-            _ => l.source.is_av() && !mattes.contains(&l.id),
-        };
-        let mut alone = true;
-        for l in comp.layers.iter().filter(|l| applies(l)) {
-            let Some(on) = switch_value(l, name) else { return Err(bad("layer.setSwitch", format!("unknown switch `{name}`"))) };
-            alone &= on == (ids.contains(&l.id) == active);
-        }
-        let others = value.unwrap_or(alone == active);
-        for l in comp.layers.iter_mut().filter(|l| applies(l)) {
-            let v = if ids.contains(&l.id) { active } else { others };
-            set_switch_value(l, name, v);
-        }
-        Ok(others)
-    })?;
-    Ok(json!(r))
-}
-
-fn switch_value(l: &Layer, name: &str) -> Option<bool> {
-    let sw = &l.switches;
-    Some(match name {
-        "video" | "eye" => sw.video,
-        "audio" => sw.audio,
-        "solo" => sw.solo,
-        "lock" | "locked" => sw.locked,
-        "shy" => sw.shy,
-        "collapse" => sw.collapse,
-        "quality" => sw.quality == Quality::Best,
-        "fx" | "effects" => sw.effects,
-        "frameBlend" => sw.frame_blend != FrameBlend::Off,
-        "motionBlur" => sw.motion_blur,
-        "adjustment" => sw.adjustment,
-        "threeD" | "3d" | "3D" => sw.three_d,
-        "guide" => sw.guide,
-        "preserveTransparency" => l.preserve_transparency,
-        _ => return None,
-    })
-}
-
-fn set_switch_value(l: &mut Layer, name: &str, v: bool) {
-    let sw = &mut l.switches;
-    match name {
-        "video" | "eye" => sw.video = v,
-        "audio" => sw.audio = v,
-        "solo" => sw.solo = v,
-        "lock" | "locked" => sw.locked = v,
-        "shy" => sw.shy = v,
-        "collapse" => sw.collapse = v,
-        "quality" => sw.quality = if v { Quality::Best } else { Quality::Draft },
-        "fx" | "effects" => sw.effects = v,
-        "frameBlend" => sw.frame_blend = if v { FrameBlend::FrameMix } else { FrameBlend::Off },
-        "motionBlur" => sw.motion_blur = v,
-        "adjustment" => sw.adjustment = v,
-        "threeD" | "3d" | "3D" => {
-            if sw.three_d && !v {
-                drop_3d_values(l);
-            }
-            l.switches.three_d = v;
-        }
-        "guide" => sw.guide = v,
-        "preserveTransparency" => l.preserve_transparency = v,
-        _ => {}
-    }
-}
-
-/// Turning the 3D switch off discards Z values, Orientation and X/Y Rotation (as in AE).
-fn drop_3d_values(l: &mut Layer) {
-    let Some(tr) = l.transform_mut() else { return };
-    for (m, keep) in [("position", 0.0), ("anchor", 0.0), ("scale", 100.0)] {
-        if let Some(pr) = tr.get_mut(m) {
-            let flat = |v: &mut KV| {
-                if let KV::Vec3(a) = v {
-                    a[2] = keep;
-                }
-            };
-            flat(&mut pr.value);
-            for k in &mut pr.keys {
-                flat(&mut k.value);
-            }
-        }
-    }
-    for (m, zero) in [("orientation", KV::Vec3([0.0; 3])), ("rotationX", KV::Scalar(0.0)), ("rotationY", KV::Scalar(0.0))] {
-        if let Some(pr) = tr.get_mut(m) {
-            pr.keys.clear();
-            pr.expr = None;
-            pr.value = zero;
-        }
-    }
-}
-
-fn rename(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, lid) = layer_p(s, p, "layer.rename")?;
-    let name = str_p(p, "name").ok_or_else(|| bad("layer.rename", "missing `name`"))?.to_string();
-    s.edit("Rename Layer", None, |proj, _| {
-        layer_mut(proj, cid, lid)?.name = name.clone();
-        Ok(())
-    })?;
-    Ok(Value::Null)
-}
-
-/// The Timeline's Comment column.
-fn set_comment(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, ids) = layers_p(s, p)?;
-    let text = str_p(p, "comment").ok_or_else(|| bad("layer.setComment", "missing `comment`"))?.to_string();
-    s.edit("Layer Comment", None, |proj, _| {
-        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
-            l.comment = text.clone();
-        }
-        Ok(())
-    })?;
-    Ok(Value::Null)
-}
-
-fn blend(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, ids) = layers_p(s, p)?;
-    let mode = str_p(p, "mode").and_then(BlendMode::from_name);
-    let step = p.get("step").and_then(Value::as_i64).unwrap_or(0);
-    if mode.is_none() && step == 0 {
-        return Err(bad("layer.setBlendMode", "need `mode` (e.g. Multiply) or `step` ±1"));
-    }
-    s.edit("Blending Mode", None, |proj, _| {
-        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
-            l.blend_mode = match mode {
-                Some(m) => m,
-                None if step > 0 => l.blend_mode.next(),
-                None => l.blend_mode.previous(),
-            };
-        }
-        Ok(())
-    })?;
-    Ok(Value::Null)
-}
-
-fn track_matte(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, lid) = layer_p(s, p, "layer.setTrackMatte")?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
-    let matte = match p.get("matte") {
-        None | Some(Value::Null) => None,
-        Some(v) => Some(resolve_layer(comp, v).ok_or_else(|| bad("layer.setTrackMatte", "no such matte layer"))?),
-    };
-    let kind = str_p(p, "kind")
-        .map(|k| match k.to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
-            "alphainverted" | "alphainv" => MatteKind::AlphaInverted,
-            "luma" => MatteKind::Luma,
-            "lumainverted" | "lumainv" => MatteKind::LumaInverted,
-            _ => MatteKind::Alpha,
-        })
-        .unwrap_or(MatteKind::Alpha);
-    s.edit("Track Matte", None, |proj, _| {
-        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        if let Some(m) = matte {
-            if m == lid {
-                return Err(bad("layer.setTrackMatte", "a layer can't be its own matte"));
-            }
-            if let Some(ml) = comp.layer_mut(m) {
-                ml.switches.video = false;
-            }
-        }
-        comp.layer_mut(lid).ok_or(EngineError::NoComp)?.track_matte = matte.map(|layer| TrackMatte { layer, kind });
-        Ok(())
-    })?;
-    Ok(Value::Null)
-}
-
-/// Re-express a layer in its new parent space without moving its anchor.
-pub(crate) struct ParentFix {
-    pub layer: LayerId,
-    /// Maps Position from the old parent's space into the new one's.
-    m: effectcraft_geom::Mat3,
-    /// Added to Rotation.
-    rotation: f64,
-    /// Multiply Scale.
-    scale: [f64; 2],
-    /// 3D AV layers retain their world-space anchor, including Z.
-    position_3d: Option<effectcraft_geom::Mat4>,
-    /// A uniform relative parent transform can preserve static Orientation and Scale.
-    pose_3d: Option<([f64; 3], f64)>,
-}
-
-impl ParentFix {
-    /// Re-express the layer's Position, Rotation and Scale (every key) in the new parent's space.
-    pub fn apply(&self, l: &mut Layer) {
-        let Some(tr) = l.props.sub_mut("transform") else { return };
-        if let Some(m) = self.position_3d {
-            // Spatial Position speed measures distance along its path. Its parent-space
-            // unit changes even when the child's Orientation cannot be re-expressed.
-            let position_speed = uniform_parent_pose(m, [0.0; 3]).map(|(_, factor)| factor.abs());
-            let map_position = |v: &KV| {
-                let q = m.apply(effectcraft_geom::Vec3::from(v.as_vec3()));
-                KV::Vec3([q.x, q.y, q.z])
-            };
-            // Read all separated axes before writing any of them.
-            let names = ["positionX", "positionY", "positionZ"];
-            if tr.get("positionX").is_some() {
-                let axes = names.map(|name| tr.get(name).cloned());
-                let current = axes.each_ref().map(|pr| pr.as_ref().map(|pr| pr.value.as_f64()).unwrap_or(0.0));
-                let q = m.apply(effectcraft_geom::Vec3::from(current));
-                for (i, name) in names.into_iter().enumerate() {
-                    if let Some(pr) = tr.get_mut(name) {
-                        pr.value = KV::Scalar([q.x, q.y, q.z].get(i).copied().unwrap_or(0.0));
-                        for key in &mut pr.keys {
-                            let p = axes.each_ref().map(|axis| axis.as_ref().map(|axis| axis.value_at(key.time).as_f64()).unwrap_or(0.0));
-                            let q = m.apply(effectcraft_geom::Vec3::from(p));
-                            key.value = KV::Scalar([q.x, q.y, q.z].get(i).copied().unwrap_or(0.0));
-                        }
-                    }
-                }
-            }
-            if let Some(pr) = tr.get_mut("position") {
-                pr.value = map_position(&pr.value);
-                for key in &mut pr.keys {
-                    key.value = map_position(&key.value);
-                    // Spatial tangents are vectors, so the parent's translation is excluded.
-                    for tangent in [&mut key.spatial_in, &mut key.spatial_out] {
-                        let v = m.apply_vec(effectcraft_geom::Vec3::from(*tangent));
-                        *tangent = [v.x, v.y, v.z];
-                    }
-                }
-                if let Some(factor) = position_speed
-                    .filter(|_| pr.spatial)
-                    .filter(|factor| pr.keys.iter().flat_map(|key| key.in_ease.iter().chain(&key.out_ease)).all(|ease| (ease.speed * *factor).is_finite()))
-                {
-                    for key in &mut pr.keys {
-                        for ease in key.in_ease.iter_mut().chain(&mut key.out_ease) {
-                            ease.speed *= factor;
-                        }
-                    }
-                }
-            }
-            // Cameras and lights aim with Point of Interest: move it by the same parent-space
-            // change, so a two-node rig keeps its world frame (#1010, #1020).
-            if let Some(pr) = tr.get_mut("poi") {
-                pr.value = map_position(&pr.value);
-                for key in &mut pr.keys {
-                    key.value = map_position(&key.value);
-                    for tangent in [&mut key.spatial_in, &mut key.spatial_out] {
-                        let v = m.apply_vec(effectcraft_geom::Vec3::from(*tangent));
-                        *tangent = [v.x, v.y, v.z];
-                    }
-                }
-                if let Some(factor) = position_speed
-                    .filter(|_| pr.spatial)
-                    .filter(|factor| pr.keys.iter().flat_map(|key| key.in_ease.iter().chain(&key.out_ease)).all(|ease| (ease.speed * *factor).is_finite()))
-                {
-                    for key in &mut pr.keys {
-                        for ease in key.in_ease.iter_mut().chain(&mut key.out_ease) {
-                            ease.speed *= factor;
-                        }
-                    }
-                }
-            }
-            if let Some((orientation, factor)) = self.pose_3d {
-                if let Some(pr) = tr.get_mut("orientation") {
-                    pr.value = KV::Vec3(orientation);
-                }
-                if let Some(pr) = tr.get_mut("scale") {
-                    let scaled = |value: &KV| KV::Vec3(value.as_vec3().map(|v| v * factor));
-                    pr.value = scaled(&pr.value);
-                    for key in &mut pr.keys {
-                        key.value = scaled(&key.value);
-                        // Scale's temporal speeds use the same units as its values.
-                        for ease in key.in_ease.iter_mut().chain(&mut key.out_ease) {
-                            ease.speed *= factor;
-                        }
-                    }
-                }
-            }
-            return;
-        }
-        let map = |pr: &mut effectcraft_project::Property, f: &dyn Fn(&KV) -> KV| {
-            pr.value = f(&pr.value);
-            for key in &mut pr.keys {
-                key.value = f(&key.value);
-            }
-        };
-        let m = self.m;
-        if tr.get("positionX").is_some() {
-            // Separated dimensions: X and Y move together, key by key at the same times.
-            // Everything is read before anything is written.
-            let [x, y] = [tr.get("positionX"), tr.get("positionY")].map(|p| p.map(|p| p.value.as_f64()).unwrap_or(0.0));
-            let q = m.apply(effectcraft_geom::vec2(x, y));
-            let keys_x: Vec<(Tick, f64)> = tr.get("positionX").map(|p| p.keys.iter().map(|k| (k.time, k.value.as_f64())).collect()).unwrap_or_default();
-            let keys_y: Vec<(Tick, f64)> = tr.get("positionY").map(|p| p.keys.iter().map(|k| (k.time, k.value.as_f64())).collect()).unwrap_or_default();
-            let at = |keys: &[(Tick, f64)], name: &str, t: Tick, tr: &PropGroup| {
-                keys.iter().find(|k| k.0 == t).map(|k| k.1).unwrap_or_else(|| tr.get(name).map(|p| p.value_at(t).as_f64()).unwrap_or(0.0))
-            };
-            let (xs, ys): (Vec<f64>, Vec<f64>) = (
-                keys_x.iter().map(|&(t, x)| m.apply(effectcraft_geom::vec2(x, at(&keys_y, "positionY", t, tr))).x).collect(),
-                keys_y.iter().map(|&(t, y)| m.apply(effectcraft_geom::vec2(at(&keys_x, "positionX", t, tr), y)).y).collect(),
-            );
-            for (name, value, vals) in [("positionX", q.x, xs), ("positionY", q.y, ys)] {
-                if let Some(pr) = tr.get_mut(name) {
-                    pr.value = KV::Scalar(value);
-                    for (k, v) in pr.keys.iter_mut().zip(vals) {
-                        k.value = KV::Scalar(v);
-                    }
-                }
-            }
-        } else if let Some(pr) = tr.get_mut("position") {
-            map(pr, &|v| {
-                let c = v.as_vec3();
-                let q = m.apply(effectcraft_geom::vec2(c[0], c[1]));
-                KV::Vec3([q.x, q.y, c[2]])
-            });
-        }
-        let (dr, k) = (self.rotation, self.scale);
-        if let Some(pr) = tr.get_mut("rotation") {
-            map(pr, &|v| KV::Scalar(v.as_f64() + dr));
-        }
-        if let Some(pr) = tr.get_mut("scale") {
-            map(pr, &|v| {
-                let c = v.as_vec3();
-                KV::Vec3([c[0] * k[0], c[1] * k[1], c[2]])
-            });
-        }
-    }
-}
-
-/// A uniform factor commutes with authored axis Rotation and Scale; prepend its orthogonal
-/// rotation to static Orientation using the existing Rz * Ry * Rx order.
-fn uniform_parent_pose(m: effectcraft_geom::Mat4, orientation: [f64; 3]) -> Option<([f64; 3], f64)> {
-    use effectcraft_geom::{Mat4, Vec3, vec3};
-    if !orientation.iter().all(|v| v.is_finite()) {
-        return None;
-    }
-    let a = m.0;
-    let columns = [vec3(a[0][0], a[1][0], a[2][0]), vec3(a[0][1], a[1][1], a[2][1]), vec3(a[0][2], a[1][2], a[2][2])];
-    let magnitude = columns[0].x.hypot(columns[0].y).hypot(columns[0].z);
-    if !magnitude.is_finite() || magnitude <= 0.0 {
-        return None;
-    }
-    let c = columns.map(|c| c / magnitude);
-    if c.iter().any(|c| (c.dot(*c) - 1.0).abs() > 1e-9) || c[0].dot(c[1]).abs() > 1e-9 || c[0].dot(c[2]).abs() > 1e-9 || c[1].dot(c[2]).abs() > 1e-9 {
-        return None;
-    }
-    let cross = vec3(c[1].y * c[2].z - c[1].z * c[2].y, c[1].z * c[2].x - c[1].x * c[2].z, c[1].x * c[2].y - c[1].y * c[2].x);
-    let factor = if c[0].dot(cross) < 0.0 { -magnitude } else { magnitude };
-    let mut rotation = Mat4::IDENTITY;
-    for row in 0..3 {
-        for col in 0..3 {
-            rotation.0[row][col] = a[row][col] / factor;
-        }
-    }
-    if (0..3).all(|row| (0..3).all(|col| (rotation.0[row][col] - if row == col { 1.0 } else { 0.0 }).abs() < 1e-12)) {
-        return Some((orientation, factor));
-    }
-    let r = (rotation * Mat4::orientation(Vec3::from(orientation))).0;
-    // atan2 rather than asin: near ±90 degrees asin loses precision, while cos(y) stays exact.
-    let cy = r[0][0].hypot(r[1][0]);
-    let y = (-r[2][0]).atan2(cy);
-    let (x, z) = if cy > 1e-9 { (r[2][1].atan2(r[2][2]), r[1][0].atan2(r[0][0])) } else { ((-r[1][2]).atan2(r[1][1]), 0.0) };
-    Some(([x.to_degrees(), y.to_degrees(), z.to_degrees()], factor))
-}
-
-/// A parent change retains 2D transforms and the world-space anchor of 3D layers (Position,
-/// and Point of Interest for two-node cameras and lights). Position is
-/// re-expressed in the new parent's space (`None`: the composition), evaluated at the current
-/// time.
-pub(crate) fn parent_fixes(s: &Session, cid: ItemId, ids: &[LayerId], parent: Option<LayerId>) -> Vec<ParentFix> {
-    let Some(comp) = s.project.comp(cid) else { return vec![] };
-    let ectx =
-        effectcraft_render::EvalCtx { project: &s.project, comp_id: cid, comp, time: s.time(), expr: s.expr.as_deref(), footage: Some(s.footage.as_ref()) };
-    let space = |id: Option<LayerId>| -> effectcraft_geom::Mat3 {
-        id.and_then(|i| comp.layer(i)).filter(|l| !l.is_3d()).map(|l| ectx.layer_to_comp(l).0).unwrap_or(effectcraft_geom::Mat3::IDENTITY)
-    };
-    let decompose = |m: &effectcraft_geom::Mat3| {
-        let a = m.0;
-        let sx = (a[0][0] * a[0][0] + a[1][0] * a[1][0]).sqrt();
-        let det = a[0][0] * a[1][1] - a[0][1] * a[1][0];
-        (a[1][0].atan2(a[0][0]).to_degrees(), sx, if sx > 1e-12 { det / sx } else { 0.0 })
-    };
-    let new_m = space(parent);
-    let Some(inv) = new_m.inverse() else { return vec![] };
-    let (rn, sxn, syn) = decompose(&new_m);
-    let mut fixes: Vec<_> = comp
-        .layers
-        .iter()
-        .filter(|l| ids.contains(&l.id) && !l.is_3d() && l.parent != parent)
-        .map(|l| {
-            let old_m = space(l.parent);
-            let (ro, sxo, syo) = decompose(&old_m);
-            let scale = [if sxn.abs() > 1e-12 { sxo / sxn } else { 1.0 }, if syn.abs() > 1e-12 { syo / syn } else { 1.0 }];
-            ParentFix { layer: l.id, m: inv * old_m, rotation: ro - rn, scale, position_3d: None, pose_3d: None }
-        })
-        .collect();
-    let space_3d = |id: Option<LayerId>| {
-        id.and_then(|id| comp.layer(id)).map_or(effectcraft_geom::Mat4::IDENTITY, |layer| {
-            // Parent transforms do not inherit the parent's source pixel-aspect stretch.
-            let world = ectx.world_matrix(layer);
-            let par = ectx.par_ratio(layer);
-            let a = layer.transform().map(|tr| ectx.v3(layer, tr, "anchor", [0.0; 3])).unwrap_or([0.0; 3]);
-            let anchor = effectcraft_geom::vec3(a[0], a[1], if layer.is_3d() { a[2] } else { 0.0 });
-            world
-                * effectcraft_geom::Mat4::translate(anchor)
-                * effectcraft_geom::Mat4::scale(effectcraft_geom::vec3(1.0 / par, 1.0, 1.0))
-                * effectcraft_geom::Mat4::translate(-anchor)
-        })
-    };
-    if let Some(inv) = space_3d(parent).inverse().filter(|m| m.0.iter().flatten().all(|v| v.is_finite())) {
-        // Cameras and lights compensate like 3D layers (Position, and Point of Interest for
-        // two-node rigs), so parenting keeps the world frame (#1010, #1020). They have no
-        // Scale, so `pose_3d` below stays `None` and Orientation is kept as authored.
-        for layer in comp.layers.iter().filter(|l| ids.contains(&l.id) && l.is_3d() && l.parent != parent) {
-            let m = inv * space_3d(layer.parent);
-            if m.0.iter().flatten().all(|v| v.is_finite()) {
-                let pose_3d = layer.transform().and_then(|tr| {
-                    let orientation = tr.get("orientation")?;
-                    let scale = tr.get("scale")?;
-                    // Animated Euler Orientation and auto-orient cannot be re-expressed by
-                    // prepending a constant Euler value. Expression-driven values stay authored.
-                    if !orientation.keys.is_empty()
-                        || orientation.expr.is_some()
-                        || scale.expr.is_some()
-                        || layer.auto_orient != effectcraft_project::AutoOrient::Off
-                    {
-                        return None;
-                    }
-                    let pose = uniform_parent_pose(m, orientation.value.as_vec3())?;
-                    let factor = pose.1;
-                    let values_finite = std::iter::once(&scale.value)
-                        .chain(scale.keys.iter().map(|key| &key.value))
-                        .all(|value| value.as_vec3().iter().all(|v| (v * factor).is_finite()));
-                    let speeds_finite = scale.keys.iter().flat_map(|key| key.in_ease.iter().chain(&key.out_ease)).all(|ease| (ease.speed * factor).is_finite());
-                    (values_finite && speeds_finite).then_some(pose)
-                });
-                fixes.push(ParentFix { layer: layer.id, m: effectcraft_geom::Mat3::IDENTITY, rotation: 0.0, scale: [1.0; 2], position_3d: Some(m), pose_3d });
-            }
-        }
-    }
-    fixes
-}
-
-/// Validate the proposed ancestor chain before any authored edit, including when compensation
-/// is disabled. Bound both unique ancestors and linear lookup/selection work on loaded graphs.
-fn check_parent_chain(comp: &Comp, ids: &[LayerId], parent: Option<LayerId>, max_visits: usize, max_work: usize) -> Result<()> {
-    let mut seen = std::collections::HashSet::new();
-    let mut work = 0usize;
-    let mut cur = parent;
-    while let Some(id) = cur {
-        if seen.len() >= max_visits {
-            return Err(bad("layer.setParent", "parent chain exceeds the safety visit limit"));
-        }
-        if !seen.insert(id) {
-            return Err(bad("layer.setParent", "parent chain contains an existing cycle"));
-        }
-        for selected in ids {
-            if work >= max_work {
-                return Err(bad("layer.setParent", "parent chain exceeds the safety work limit"));
-            }
-            work += 1;
-            if *selected == id {
-                return Err(bad("layer.setParent", "parenting would create a cycle"));
-            }
-        }
-        let mut ancestor = None;
-        for layer in &comp.layers {
-            if work >= max_work {
-                return Err(bad("layer.setParent", "parent chain exceeds the safety work limit"));
-            }
-            work += 1;
-            if layer.id == id {
-                ancestor = Some(layer);
-                break;
-            }
-        }
-        let layer = ancestor.ok_or_else(|| bad("layer.setParent", "parent chain refers to a missing layer"))?;
-        cur = layer.parent;
-    }
-    Ok(())
-}
-
-fn set_parent(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, ids) = layers_p(s, p)?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
-    let parent = match p.get("parent") {
-        None | Some(Value::Null) => None,
-        Some(v) => Some(resolve_layer(comp, v).ok_or_else(|| bad("layer.setParent", "no such parent layer"))?),
-    };
-    // A loaded cycle need not include a selected child. Validate before compensation or edit;
-    // do not impose the renderer's 64-ancestor truncation as a new ordinary hierarchy limit.
-    check_parent_chain(comp, &ids, parent, 4096, 1_048_576)?;
-    // Like AE's pick-whip, parenting keeps the layer where it is: its transform is re-expressed
-    // in the new parent's space (Position, Rotation, Scale), unless `compensate: false`.
-    let compensate = b_p(p, "compensate").unwrap_or(true);
-    let fixes = if compensate { parent_fixes(s, cid, &ids, parent) } else { vec![] };
-    s.edit("Parent", None, |proj, _| {
-        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
-            l.parent = parent;
-            if let Some(f) = fixes.iter().find(|f| f.layer == l.id) {
-                f.apply(l);
-            }
-        }
-        Ok(())
-    })?;
-    Ok(Value::Null)
-}
-
-fn timing(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, ids) = layers_p(s, p)?;
-    let t = s.time();
-    let op = str_p(p, "op").unwrap_or("set").to_string();
-    // Layer times stay on frame boundaries of the comp (as in AE).
-    let fr = s.project.comp(cid).ok_or(EngineError::NoComp)?.frame_rate;
-    let snap = |k: &str| f_p(p, k).map(|v| fr.snap_nearest(Tick::from_seconds_f64(v)));
-    let (delta, start, inp, outp) = (snap("delta"), snap("start"), snap("in"), snap("out"));
-    // Relative trims: each layer moves its own in/out point by the same amount, so dragging an
-    // edge of several selected layers trims them all together (as in AE).
-    let (in_delta, out_delta) = (snap("inDelta"), snap("outDelta"));
-    s.edit("Layer Timing", merge_p(p), |proj, _| {
-        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        let fd = comp.frame_duration();
-        let comp_dur = comp.duration;
-        for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
-            let shift = |l: &mut Layer, d: Tick| {
-                l.start_time += d;
-                l.in_point += d;
-                l.out_point += d;
-            };
-            match op.as_str() {
-                "moveInToTime" => {
-                    let d = t - l.in_point;
-                    shift(l, d);
-                }
-                "moveOutToTime" => {
-                    let d = t - l.out_point;
-                    shift(l, d);
-                }
-                "moveInToStart" => {
-                    let d = Tick::ZERO - l.in_point;
-                    shift(l, d);
-                }
-                "moveOutToEnd" => {
-                    let d = comp_dur - l.out_point;
-                    shift(l, d);
-                }
-                "trimInToTime" => l.in_point = t.min(l.out_point - fd),
-                "trimOutToTime" => l.out_point = t.max(l.in_point + fd),
-                _ => {
-                    if let Some(d) = delta {
-                        shift(l, d);
-                    }
-                    if let Some(st) = start {
-                        let d = st - l.start_time;
-                        shift(l, d);
-                    }
-                    if let Some(i) = inp {
-                        l.in_point = i.min(l.out_point - fd);
-                    }
-                    if let Some(o) = outp {
-                        l.out_point = o.max(l.in_point + fd);
-                    }
-                    // Stops at the comp start/end (a point already past it doesn't jump onto
-                    // it), keeping at least one frame of layer.
-                    if let Some(d) = in_delta {
-                        l.in_point = (l.in_point + d).max(Tick::ZERO.min(l.in_point)).min(l.out_point - fd);
-                    }
-                    if let Some(d) = out_delta {
-                        l.out_point = (l.out_point + d).min(comp_dur.max(l.out_point)).max(l.in_point + fd);
-                    }
-                }
-            }
-        }
-        Ok(())
-    })?;
-    Ok(Value::Null)
-}
-
-/// `p` with `key` set.
-fn with(p: &Value, key: &str, v: Value) -> Value {
-    let mut p = if p.is_object() { p.clone() } else { json!({}) };
-    p[key] = v;
-    p
-}
-
-/// Move the layers `frames` frames in time (Alt+Page Up / Page Down, with Shift ten frames).
-fn move_frames(s: &mut Session, p: &Value, frames: i64) -> Result<Value> {
-    let (cid, _) = layers_p(s, p)?;
-    let delta = s.project.comp(cid).ok_or(EngineError::NoComp)?.frame_rate.tick_of(frames).seconds();
-    timing(s, &with(p, "delta", json!(delta)))
-}
-
-/// Slip edit: move a layer's source (footage or precomp) under its fixed in and out points, like
-/// dragging the source-duration bar in After Effects. `delta` in seconds or `frames`; positive
-/// moves the source later. Clamped so the source still covers the in–out span. Keyframes and
-/// layer markers are in layer time, so they travel with the source.
-fn slip(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, ids) = layers_p(s, p)?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
-    let fr = comp.frame_rate;
-    let delta = match (p.get("frames").and_then(Value::as_i64), f_p(p, "delta")) {
-        (Some(f), _) => fr.tick_of(f),
-        (None, Some(d)) => fr.snap_nearest(Tick::from_seconds_f64(d)),
-        _ => return Err(bad("layer.slip", "delta (seconds) or frames required")),
-    };
-    // Allowed shift per layer: the source span [lo, hi] in comp time must keep covering in..out.
-    let mut shifts: Vec<(LayerId, Tick)> = Vec::new();
-    for l in comp.layers.iter().filter(|l| ids.contains(&l.id)) {
-        if l.props.get("timeRemap").is_some() {
-            continue;
-        }
-        let dur = match &l.source {
-            LayerSource::Footage { item } => match s.project.item(*item).map(|i| &i.kind) {
-                Some(ItemKind::Footage(f)) if f.kind != effectcraft_project::FootageKind::Still => Some(f.looped_duration()),
-                _ => None,
-            },
-            LayerSource::Comp { item } => s.project.comp(*item).map(|c| c.duration),
-            _ => None,
-        };
-        let Some(dur) = dur else { continue };
-        let (a, b) = (l.comp_time(Tick::ZERO), l.comp_time(dur));
-        let (lo, hi) = (a.min(b), a.max(b));
-        let (min_d, max_d) = (l.out_point - hi, l.in_point - lo);
-        if min_d > max_d {
-            continue;
-        }
-        shifts.push((l.id, delta.max(min_d).min(max_d)));
-    }
-    if shifts.is_empty() {
-        return Err(bad("layer.slip", "select a footage or precomp layer (without time remapping)"));
-    }
-    s.edit("Slip Edit", merge_p(p), |proj, _| {
-        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        for (id, d) in &shifts {
-            if let Some(l) = comp.layer_mut(*id) {
-                l.start_time += *d;
-            }
-        }
-        Ok(())
-    })?;
-    Ok(json!({"slipped": shifts.iter().map(|(id, d)| json!({"layer": id.0, "delta": d.seconds()})).collect::<Vec<_>>()}))
-}
-
-fn arrange(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, ids) = layers_p(s, p)?;
-    let ids = unlocked(s, cid, ids, "layer.arrange")?;
-    let how = str_p(p, "to").unwrap_or("front").to_string();
-    let index = p.get("index").and_then(Value::as_u64).map(|i| i as usize);
-    // `above`: put the layers right above that one (the timeline's drag to reorder).
-    let above = match p.get("above") {
-        Some(v) => {
-            let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
-            let a = resolve_layer(comp, v).ok_or_else(|| bad("layer.arrange", "no such layer for `above`"))?;
-            if ids.contains(&a) {
-                return Err(bad("layer.arrange", "`above` must be a layer that isn't being moved"));
-            }
-            Some(a)
-        }
-        None => None,
-    };
-    s.edit("Arrange Layers", None, |proj, _| {
-        let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        // Bring Forward / Send Backward move each layer one step past the next layer that isn't
-        // moving (a run of selected layers moves as one; one already at the end stays).
-        if above.is_none() && index.is_none() && matches!(how.as_str(), "forward" | "backward") {
-            let picked = |l: &Layer| ids.contains(&l.id);
-            let n = comp.layers.len();
-            if how == "forward" {
-                for i in 1..n {
-                    if picked(&comp.layers[i]) && !picked(&comp.layers[i - 1]) {
-                        let run_end = (i..n).find(|j| !picked(&comp.layers[*j])).unwrap_or(n);
-                        comp.layers[i - 1..run_end].rotate_left(1);
-                    }
-                }
-            } else {
-                for i in (0..n.saturating_sub(1)).rev() {
-                    if picked(&comp.layers[i]) && !picked(&comp.layers[i + 1]) {
-                        let run_start = (0..=i).rev().find(|j| !picked(&comp.layers[*j])).map_or(0, |j| j + 1);
-                        comp.layers[run_start..=i + 1].rotate_right(1);
-                    }
-                }
-            }
-            return Ok(());
-        }
-        let mut picked: Vec<Layer> = Vec::new();
-        comp.layers.retain(|l| {
-            if ids.contains(&l.id) {
-                picked.push(l.clone());
-                false
-            } else {
-                true
-            }
-        });
-        let at = match (how.as_str(), index) {
-            _ if above.is_some() => comp.layers.iter().position(|l| Some(l.id) == above).unwrap_or(comp.layers.len()),
-            (_, Some(i)) => i.saturating_sub(1).min(comp.layers.len()),
-            ("back", _) => comp.layers.len(),
-            _ => 0,
-        };
-        for (k, l) in picked.into_iter().enumerate() {
-            comp.layers.insert((at + k).min(comp.layers.len()), l);
-        }
-        Ok(())
-    })?;
-    Ok(Value::Null)
-}
-
-/// Layer ▸ Pre-compose. `mode: move` (default; "Move all attributes into the new composition")
-/// nests the selected layers as they are; `mode: leave` ("Leave all attributes in", one footage,
-/// solid or precomp layer) nests only the layer's source, sized to it, and keeps the layer's
-/// transform, masks, effects and timing in the current comp. `adjustDuration` (move) trims the
-/// new comp to the selected layers' span; `open` opens the new comp.
-fn precompose(s: &mut Session, p: &Value) -> Result<Value> {
-    let c = "layer.precompose";
-    let (cid, ids) = layers_p(s, p)?;
-    if ids.is_empty() {
-        return Err(bad(c, "no layers"));
-    }
-    let name = str_p(p, "name").unwrap_or("Pre-comp 1").to_string();
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
-    let leave = match str_p(p, "mode").unwrap_or("move") {
-        "move" => false,
-        "leave" => true,
-        x => return Err(bad(c, format!("mode: move|leave, got `{x}`"))),
-    };
-    let adjust = b_p(p, "adjustDuration").unwrap_or(false);
-    if leave {
-        let [lid] = ids[..] else { return Err(bad(c, "\"Leave all attributes\" needs exactly one layer")) };
-        let layer = comp.layer(lid).ok_or(EngineError::NoComp)?.clone();
-        let Some(src_item) = layer.source.item() else {
-            return Err(bad(c, "\"Leave all attributes\" is available for footage, solid and precomp layers only"));
-        };
-        let (w, h) = effectcraft_render::source_size(&s.project, &layer);
-        let (w, h) = if w == 0 || h == 0 { (comp.width, comp.height) } else { (w, h) };
-        let dur = match s.project.item(src_item).map(|i| &i.kind) {
-            Some(ItemKind::Comp(nc)) => nc.duration,
-            Some(ItemKind::Footage(f)) if f.duration > Tick(0) => f.duration,
-            _ => comp.duration,
-        };
-        let new = s.edit("Pre-compose", None, |proj, st| {
-            let mut inner = comp.nested_like(w, h, dur);
-            let mut il = build::layer(proj, &inner, &layer.name, layer.source.clone(), (w, h), Some(dur));
-            il.name = layer.name.clone();
-            inner.layers.push(il);
-            let iid = proj.add_item(&name, Label::Sandstone, None, ItemKind::Comp(inner.into()));
-            let l = layer_mut(proj, cid, lid)?;
-            l.source = LayerSource::Comp { item: iid };
-            l.name = name.clone();
-            st.selected_layers = vec![lid];
-            Ok((iid, lid))
-        })?;
-        if b_p(p, "open").unwrap_or(false) {
-            s.open_comp(new.0);
-        }
-        return Ok(json!({"comp": new.0.0, "layer": new.1.0}));
-    }
-    let span = {
-        let sel: Vec<&effectcraft_project::Layer> = comp.layers.iter().filter(|l| ids.contains(&l.id)).collect();
-        let a = sel.iter().map(|l| l.in_point).min().unwrap_or(Tick(0)).max(Tick(0));
-        let b = sel.iter().map(|l| l.out_point).max().unwrap_or(comp.duration).min(comp.duration);
-        (a, b)
-    };
-    let (offset, dur) = if adjust && span.1 > span.0 { (span.0, span.1 - span.0) } else { (Tick(0), comp.duration) };
-    let new = s.edit("Pre-compose", None, |proj, st| {
-        let mut inner = comp.nested_like(comp.width, comp.height, dur);
-        inner.layers = comp.layers.iter().filter(|l| ids.contains(&l.id)).cloned().collect();
-        for l in &mut inner.layers {
-            if l.parent.is_some_and(|p| !ids.contains(&p)) {
-                l.parent = None;
-            }
-            if l.track_matte.is_some_and(|m| !ids.contains(&m.layer)) {
-                l.track_matte = None;
-            }
-            l.start_time -= offset;
-            l.in_point -= offset;
-            l.out_point -= offset;
-        }
-        let iid = proj.add_item(&name, Label::Sandstone, None, ItemKind::Comp(inner.into()));
-        let mut l = build::layer(proj, &comp, &name, LayerSource::Comp { item: iid }, (comp.width, comp.height), Some(dur));
-        l.name = name.clone();
-        l.start_time = offset;
-        l.in_point = offset;
-        l.out_point = offset + dur;
-        let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
-        let at = c.layers.iter().position(|l| ids.contains(&l.id)).unwrap_or(0);
-        c.layers.retain(|l| !ids.contains(&l.id));
-        let lid = l.id;
-        c.layers.insert(at.min(c.layers.len()), l);
-        st.selected_layers = vec![lid];
-        Ok((iid, lid))
-    })?;
-    if b_p(p, "open").unwrap_or(false) {
-        s.open_comp(new.0);
-    }
-    Ok(json!({"comp": new.0.0, "layer": new.1.0}))
-}
-
-fn add_mask(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, lid) = layer_p(s, p, "layer.addMask")?;
-    let layer = s.project.comp(cid).and_then(|c| c.layer(lid)).ok_or(EngineError::NoComp)?.clone();
-    let (w, h) = effectcraft_render::source_size(&s.project, &layer);
-    let (w, h) = if w == 0 { (400.0, 300.0) } else { (w as f64, h as f64) };
-    let shape = str_p(p, "shape").unwrap_or("rect");
-    let r = p.get("rect").and_then(Value::as_array).map(|a| [0, 1, 2, 3].map(|i| a.get(i).and_then(Value::as_f64).unwrap_or(0.0)));
-    let (cx, cy, rw, rh) = match r {
-        Some([x, y, rw, rh]) => (x + rw / 2.0, y + rh / 2.0, rw, rh),
-        None => (if w > 0.0 { w / 2.0 } else { 0.0 }, h / 2.0, w * 0.6, h * 0.6),
-    };
-    // The shape tools' masks: rectangle, ellipse, rounded rectangle, polygon or star.
-    let path = super::shape_tool::mask_path(shape, [cx, cy], [rw, rh])
-        .ok_or_else(|| bad("layer.addMask", format!("unknown shape `{shape}`; one of rect, ellipse, rounded, polygon, star")))?;
-    let mode = str_p(p, "mode").and_then(MaskMode::from_name).unwrap_or(MaskMode::Add);
-    let cycle = s.prefs.appearance.cycle_mask_colors;
-    let uid = s.edit("New Mask", None, |proj, _| {
-        let mut next = proj.next_id;
-        let l = layer_mut(proj, cid, lid)?;
-        let masks = l.props.sub_mut("masks").ok_or_else(|| bad("layer.addMask", "this layer can't have masks"))?;
-        let n = masks.children.len();
-        let g = build::mask(&mut Ids(&mut next), &format!("Mask {}", n + 1), path, mode, crate::prefs::mask_color(cycle, n));
-        let uid = g.uid;
-        masks.children.push(g.into());
-        proj.next_id = next;
-        Ok(uid)
-    })?;
-    Ok(json!({"mask": uid}))
-}
-
-fn mask_props(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, lid) = layer_p(s, p, "layer.setMask")?;
-    let target = p.get("mask").cloned().unwrap_or(json!(1));
-    let mode = str_p(p, "mode").and_then(MaskMode::from_name);
-    let inverted = b_p(p, "inverted");
-    s.edit("Mask Settings", None, |proj, _| {
-        let l = layer_mut(proj, cid, lid)?;
-        let masks = l.props.sub_mut("masks").ok_or_else(|| bad("layer.setMask", "the layer has no masks (add one with layer.addMask)"))?;
-        let g = match &target {
-            Value::Number(n) => {
-                let n = n.as_u64().unwrap_or(1);
-                if let Some(i) = masks.children.iter().position(|c| c.uid() == n) {
-                    masks.children[i].as_group_mut()
-                } else {
-                    masks.children.get_mut(n.saturating_sub(1) as usize).and_then(|c| c.as_group_mut())
-                }
-            }
-            Value::String(name) => masks.children.iter_mut().find(|c| c.name() == name).and_then(|c| c.as_group_mut()),
-            _ => None,
-        }
-        .ok_or_else(|| bad("layer.setMask", "no such mask"))?;
-        if let GroupKind::Mask { mode: m, inverted: inv, .. } = &mut g.kind {
-            if let Some(mm) = mode {
-                *m = mm;
-            }
-            if let Some(i) = inverted {
-                *inv = i;
-            }
-        }
-        Ok(())
-    })?;
-    Ok(Value::Null)
-}
-
-fn add_shape_item(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, lid) = layer_p(s, p, "layer.addShapeItem")?;
-    let kind = str_p(p, "kind").ok_or_else(|| bad("layer.addShapeItem", "missing `kind`"))?.to_string();
-    // `group`: a uid or a property path (`contents/group`).
-    let group_uid = match p.get("group") {
-        Some(Value::String(path)) => Some(
-            s.project
-                .comp(cid)
-                .and_then(|c| c.layer(lid))
-                .and_then(|l| l.props.group(path))
-                .map(|g| g.uid)
-                .ok_or_else(|| bad("layer.addShapeItem", format!("no group `{path}`")))?,
-        ),
-        v => v.and_then(Value::as_u64),
-    };
-    let uid = s.edit("Add Shape Item", None, |proj, _| {
-        let mut next = proj.next_id;
-        let mut ids = Ids(&mut next);
-        // Front / Bevel / Side / Back ▸ property: into the group's surface item (one per group).
-        if let Some((surface, prop)) = build::shape_surface_kind(&kind) {
-            let target = shape_item_target(proj, cid, lid, group_uid)?;
-            let item = match target.children.iter().position(|c| matches!(c, Node::Group(g) if g.match_id == surface)) {
-                Some(i) => i,
-                None => {
-                    let g = build::shape_surface(&mut ids, surface).ok_or_else(|| bad("layer.addShapeItem", format!("unknown kind `{kind}`")))?;
-                    target.children.push(g.into());
-                    target.children.len() - 1
-                }
-            };
-            let Some(Node::Group(g)) = target.children.get_mut(item) else { return Err(bad("layer.addShapeItem", "no such group")) };
-            if g.get(prop).is_none() {
-                let p = build::shape_surface_prop(&mut ids, prop).ok_or_else(|| bad("layer.addShapeItem", format!("unknown kind `{kind}`")))?;
-                g.children.push(p.into());
-            }
-            let uid = g.uid;
-            proj.next_id = next;
-            return Ok(uid);
-        }
-        let g = match kind.as_str() {
-            "group" => build::shape_group(&mut ids, "Group 1", vec![]),
-            "rect" | "rectangle" => build::shape_rect(&mut ids, [200.0, 200.0], [0.0, 0.0], 0.0),
-            "ellipse" => build::shape_ellipse(&mut ids, [200.0, 200.0], [0.0, 0.0]),
-            "star" => build::shape_star(&mut ids, true, 5.0, [0.0, 0.0], 100.0, 50.0),
-            "polygon" => build::shape_star(&mut ids, false, 5.0, [0.0, 0.0], 100.0, 0.0),
-            "fill" => build::shape_fill(&mut ids, [1.0, 0.0, 0.0, 1.0]),
-            "stroke" => build::shape_stroke(&mut ids, [1.0, 1.0, 1.0, 1.0], 2.0),
-            "path" => build::shape_path(&mut ids, Default::default()),
-            "gfill" | "gradientFill" => build::shape_gradient_fill(&mut ids, false, [-100.0, 0.0], [100.0, 0.0], Default::default()),
-            "gstroke" | "gradientStroke" => build::shape_gradient_stroke(&mut ids, false, [-100.0, 0.0], [100.0, 0.0], Default::default(), 2.0),
-            "trim" | "trimPaths" => build::shape_trim(&mut ids, 0.0, 100.0, 0.0),
-            "repeater" => build::shape_repeater(&mut ids, 3.0, [100.0, 0.0]),
-            k => build::shape_simple_op(&mut ids, k).ok_or_else(|| bad("layer.addShapeItem", format!("unknown kind `{k}`")))?,
-        };
-        let uid = g.uid;
-        proj.next_id = next;
-        shape_item_target(proj, cid, lid, group_uid)?.children.push(g.into());
-        Ok(uid)
-    })?;
-    // The new item's property path, ready for prop.set / add_keyframe (`contents/trim#2/end`).
-    let path = s.project.comp(cid).and_then(|c| c.layer(lid)).and_then(|l| l.props.match_path_of(uid));
-    Ok(json!({"uid": uid, "path": path}))
-}
-
-/// The contents a new shape item goes into: the shape group `group_uid` (its Contents), else the
-/// layer's Contents.
-fn shape_item_target(proj: &mut Project, cid: ItemId, lid: LayerId, group_uid: Option<u64>) -> Result<&mut PropGroup> {
-    let l = layer_mut(proj, cid, lid)?;
-    let contents = l.props.sub_mut("contents").ok_or_else(|| bad("layer.addShapeItem", "not a shape layer"))?;
-    Ok(match group_uid {
-        Some(u) => contents
-            .find_group_mut(u)
-            .and_then(|g| if g.match_id == "contents" { Some(g) } else { g.sub_mut("contents") })
-            .ok_or_else(|| bad("layer.addShapeItem", "no such group"))?,
-        None => contents,
-    })
-}
-
-fn set_text(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, lid) = layer_p(s, p, "layer.setText")?;
-    // The Character panel's recent fonts (Settings ▸ Type ▸ Number of Recent Fonts to Display).
-    if let Some(f) = str_p(p, "font") {
-        s.prefs.push_recent_font(f);
-        s.save_prefs();
-    }
-    let t = s.time();
-    let range = text_range_p(p);
-    // Character attributes with only a caret (no selected text) set the insertion style.
-    if let Some(r) = range.clone().filter(|r| r.is_empty() && str_p(p, "text").is_none())
-        && s.state.text_edit.as_ref().is_some_and(|e| e.layer == lid)
-        && let Some(doc) = super::text_edit::layer_doc(s, lid)
-        && doc.char_len() > 0
-        && let Some(obj) = p.as_object()
-        && let Some(e) = s.state.text_edit.as_mut()
-    {
-        let mut st = e.pending.clone().unwrap_or_else(|| doc.insertion_style(r.start));
-        let mut any = false;
-        for (k, v) in obj {
-            any |= effectcraft_keyframe::text_doc::apply_char_attr(&mut st, k, v).map_err(|m| bad("layer.setText", m))?;
-        }
-        if any {
-            e.pending = Some(st);
-        }
-        s.bump();
-    }
-    // A changed Source Text is handled by `Session::edit`: its boundary clamps the selection and
-    // starts a new IME epoch only when the CTI document actually changed, so an identical text
-    // write stays a no-op and keeps the editor's owner.
-    s.edit("Edit Text", merge_p(p), |proj, _| {
-        let l = layer_mut(proj, cid, lid)?;
-        let lt = l.layer_time(t);
-        let pr = l.props.prop_mut("text/sourceText").ok_or_else(|| bad("layer.setText", "not a text layer"))?;
-        let mut doc = match pr.value_at(lt) {
-            KV::Text(d) => *d,
-            KV::Str(t) => TextDoc::plain(&t),
-            _ => TextDoc::default(),
-        };
-        apply_text_params("layer.setText", p, &mut doc, range.clone())?;
-        pr.set_value_at(lt, KV::Text(Box::new(doc.clone())));
-        if let Some(first) = doc.text.lines().next()
-            && str_p(p, "text").is_some()
-            && !first.is_empty()
-            && (l.name.starts_with("Text") || l.name.is_empty())
-        {
-            l.name = first.chars().take(40).collect();
-        }
-        Ok(())
-    })?;
-    Ok(Value::Null)
-}
-
-/// Move Position by `(dx, dy)`, including every key. Separated dimensions move X and Y as well
-/// as the combined property the channels were split from.
-pub(crate) fn offset_position(tr: &mut PropGroup, dx: f64, dy: f64) {
-    if dx == 0.0 && dy == 0.0 {
-        return;
-    }
-    if tr.get("positionX").is_some() {
-        for (name, d) in [("positionX", dx), ("positionY", dy)] {
-            if let Some(pr) = tr.get_mut(name) {
-                pr.value = KV::Scalar(pr.value.as_f64() + d);
-                for k in &mut pr.keys {
-                    k.value = KV::Scalar(k.value.as_f64() + d);
-                }
-            }
-        }
-    }
-    if let Some(pr) = tr.get_mut("position") {
-        let shift = |v: &KV| match v {
-            KV::Vec2(a) => KV::Vec2([a[0] + dx, a[1] + dy]),
-            other => {
-                let a = other.as_vec3();
-                KV::Vec3([a[0] + dx, a[1] + dy, a[2]])
-            }
-        };
-        pr.value = shift(&pr.value);
-        for k in &mut pr.keys {
-            k.value = shift(&k.value);
-        }
-    }
-}
-
-/// Set a layer's Position at layer time `lt` to `f(current)`: X/Y/Z Position when its dimensions
-/// are separated.
-pub(crate) fn update_position(tr: &mut PropGroup, lt: Tick, f: impl Fn([f64; 3]) -> [f64; 3]) {
-    const SEPARATE: [&str; 3] = ["positionX", "positionY", "positionZ"];
-    if tr.get("positionX").is_some() {
-        let v = f(SEPARATE.map(|m| tr.get(m).map(|p| p.value_at(lt).as_f64()).unwrap_or(0.0)));
-        for (m, x) in SEPARATE.iter().zip(v) {
-            if let Some(pr) = tr.get_mut(m) {
-                pr.set_value_at(lt, KV::Scalar(x));
-            }
-        }
-    } else if let Some(pr) = tr.get_mut("position") {
-        let v = f(pr.value_at(lt).as_vec3());
-        pr.set_value_at(lt, KV::Vec3(v));
-    }
-}
-
-/// A Transform property's default (Reset) by match id: the anchor at the centre of the source
-/// (`w`×`h`), the position at the comp's (`cw`×`ch`), 100% scale and opacity, no rotation.
-pub(crate) fn transform_default(m: &str, (w, h): (f64, f64), (cw, ch): (f64, f64)) -> Option<KV> {
-    Some(match m {
-        "anchor" => KV::Vec3([w / 2.0, h / 2.0, 0.0]),
-        "position" => KV::Vec3([cw / 2.0, ch / 2.0, 0.0]),
-        "positionX" => KV::Scalar(cw / 2.0),
-        "positionY" => KV::Scalar(ch / 2.0),
-        "positionZ" | "rotation" | "rotationX" | "rotationY" => KV::Scalar(0.0),
-        "scale" => KV::Vec3([100.0; 3]),
-        "orientation" => KV::Vec3([0.0; 3]),
-        "opacity" => KV::Scalar(100.0),
-        _ => return None,
-    })
-}
-
-fn transform_op(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, ids) = layers_p(s, p)?;
-    let ids = unlocked(s, cid, ids, "layer.transform")?;
-    let op = str_p(p, "op").unwrap_or("reset").to_string();
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?.clone();
-    let t = s.time();
-    let sizes: Vec<(LayerId, (u32, u32))> =
-        comp.layers.iter().filter(|l| ids.contains(&l.id)).map(|l| (l.id, effectcraft_render::source_size(&s.project, l))).collect();
-    s.edit("Transform", None, |proj, _| {
-        for (lid, (w, h)) in &sizes {
-            let l = layer_mut(proj, cid, *lid)?;
-            let lt = l.layer_time(t);
-            let (cw, ch) = (comp.width as f64, comp.height as f64);
-            let (w, h) = (*w as f64, *h as f64);
-            let Some(tr) = l.transform_mut() else { continue };
-            let set = |tr: &mut PropGroup, m: &str, v: KV| {
-                if let Some(pr) = tr.get_mut(m) {
-                    pr.set_value_at(lt, v);
-                }
-            };
-            match op.as_str() {
-                "reset" => {
-                    for m in ["anchor", "scale", "rotation", "rotationX", "rotationY", "orientation", "opacity"] {
-                        if let Some(v) = transform_default(m, (w, h), (cw, ch)) {
-                            set(tr, m, v);
-                        }
-                    }
-                    update_position(tr, lt, |_| [cw / 2.0, ch / 2.0, 0.0]);
-                }
-                // Centred in the frame; a 3D layer keeps its depth.
-                "center" => update_position(tr, lt, |p| [cw / 2.0, ch / 2.0, p[2]]),
-                "fit" | "fitWidth" | "fitHeight" if w > 0.0 && h > 0.0 => {
-                    let (sx, sy) = match op.as_str() {
-                        "fitWidth" => (cw / w, cw / w),
-                        "fitHeight" => (ch / h, ch / h),
-                        _ => (cw / w, ch / h),
-                    };
-                    let z = |m: &str, d: f64| tr.get(m).map(|p| p.value_at(lt).as_vec3()[2]).unwrap_or(d);
-                    let (sz, az) = (z("scale", 100.0), z("anchor", 0.0));
-                    set(tr, "scale", KV::Vec3([sx * 100.0, sy * 100.0, sz]));
-                    update_position(tr, lt, |p| [cw / 2.0, ch / 2.0, p[2]]);
-                    set(tr, "anchor", KV::Vec3([w / 2.0, h / 2.0, az]));
-                }
-                "flipH" | "flipV" => {
-                    let cur = tr.get("scale").map(|p| p.value_at(lt).as_vec3()).unwrap_or([100.0; 3]);
-                    let v = if op == "flipH" { [-cur[0], cur[1], cur[2]] } else { [cur[0], -cur[1], cur[2]] };
-                    set(tr, "scale", KV::Vec3(v));
-                }
-                _ => {}
-            }
-        }
-        Ok(())
-    })?;
-    Ok(Value::Null)
-}
-
-/// Layer ▸ Layer Settings: cameras and lights open their own settings; solids (and adjustment
-/// layers, which are solids) edit their Solid Settings. With `affectAll: false`, a solid other
-/// layers also use is copied into a new solid for this layer instead of being changed for all of
-/// them (After Effects' "Affect all layers that use this solid"). `name` renames the layer and
-/// its solid.
-fn layer_settings(s: &mut Session, p: &Value) -> Result<Value> {
-    let (cid, lid) = layer_p(s, p, "layer.settings")?;
-    // Cameras and lights open their own settings (Camera Settings / Light Settings).
-    match s.project.comp(cid).and_then(|c| c.layer(lid)).map(|l| l.source.clone()) {
-        Some(LayerSource::Camera) => return s.execute("layer.cameraSettings", with_layer(p, lid)),
-        Some(LayerSource::Light { .. }) => return s.execute("layer.lightSettings", with_layer(p, lid)),
-        _ => {}
-    }
-    let color = color_p(p, "color");
-    let w = p.get("width").and_then(Value::as_u64).map(limits::size);
-    let h = p.get("height").and_then(Value::as_u64).map(limits::size);
-    let pixel_aspect = pixel_aspect_p(p)?;
-    let name = str_p(p, "name").map(str::trim).filter(|n| !n.is_empty()).map(str::to_string);
-    let affect_all = p.get("affectAll").and_then(Value::as_bool).unwrap_or(true);
-    let solid = s.edit("Layer Settings", None, |proj, _| {
-        let src = layer_mut(proj, cid, lid)?.source.clone();
-        if let Some(n) = &name {
-            layer_mut(proj, cid, lid)?.name = n.clone();
-        }
-        let LayerSource::Solid { item } = src else { return Ok(None) };
-        let shared = proj.comps().flat_map(|(_, c)| &c.layers).filter(|l| l.source == src).count() > 1;
-        let target = if shared && !affect_all {
-            // This layer gets its own copy of the solid.
-            let it = proj.item(item).ok_or_else(|| bad("layer.settings", "the layer's solid is missing"))?.clone();
-            let copy = proj.add_item(name.as_deref().unwrap_or(&it.name), it.label, it.parent, it.kind);
-            layer_mut(proj, cid, lid)?.source = LayerSource::Solid { item: copy };
-            copy
-        } else {
-            item
-        };
-        let it = proj.item_mut(target).ok_or_else(|| bad("layer.settings", "the layer's solid is missing"))?;
-        if let Some(n) = &name {
-            it.name = n.clone();
-        }
-        if let ItemKind::Solid(so) = &mut it.kind {
-            so.color = color.unwrap_or(so.color);
-            so.width = w.unwrap_or(so.width);
-            so.height = h.unwrap_or(so.height);
-            so.pixel_aspect = pixel_aspect.unwrap_or(so.pixel_aspect);
-        }
-        Ok(Some(target))
-    })?;
-    Ok(match solid {
-        Some(item) => json!({"layer": lid.0, "solid": item.0}),
-        None => json!({"layer": lid.0}),
-    })
-}
-
-/// Layer Settings applies to solids (and adjustment layers), nulls, cameras and lights.
-fn has_layer_settings(s: &Session) -> std::result::Result<(), String> {
-    has_layers(s)?;
-    let l = s.active_comp().zip(s.state.selected_layers.first()).and_then(|(c, l)| c.layer(*l)).ok_or("select a layer first")?;
-    match l.source {
-        LayerSource::Solid { .. } | LayerSource::Null | LayerSource::Camera | LayerSource::Light { .. } => Ok(()),
-        _ => Err("this kind of layer has no settings".into()),
-    }
-}
-
-fn with_layer(p: &Value, lid: LayerId) -> Value {
-    let mut p = if p.is_object() { p.clone() } else { json!({}) };
-    p["layer"] = json!(lid.0);
-    p
-}
-
-pub fn specs() -> Vec<CommandSpec> {
-    vec![
-        cmd!(
-            "layer.newText",
-            "Text",
-            ["Layer", "New"],
-            Some("Cmd+Alt+Shift+T"),
-            "{text?, name? (layer name; default the text), position? [x,y], box? [x,y,w,h] (paragraph text, comp space), vertical?, edit? (start editing), font?, style?, size?, fill?, stroke?, applyFill?, applyStroke?, strokeWidth?, tracking?, leading?, baselineShift?, hScale?, vScale?, tsume?, fauxBold?, fauxItalic?, allCaps?, smallCaps?, baseline?, superscript?, subscript?, kerning?, ligatures?, justify?, indentLeft?, indentRight?, indentFirst?, spaceBefore?, spaceAfter?, direction?, composer?, hangingPunctuation?, strokeOverFill?} (attributes as layer.setText)",
-            has_comp,
-            new_text
-        ),
-        cmd!("layer.newSolid", "Solid...", ["Layer", "New"], Some("Cmd+Y"), "{name?, color? #hex|[r,g,b], width?, height?, pixelAspect?}", has_comp, new_solid),
-        cmd!("layer.newNull", "Null Object", ["Layer", "New"], Some("Cmd+Alt+Shift+Y"), "{name?}", has_comp, new_null),
-        cmd!(
-            "layer.newShape",
-            "Shape Layer",
-            ["Layer", "New"],
-            None,
-            "{kind?: rect|rounded|ellipse|star|polygon|none, name?, size?, fill?, fillType?, fillBlend?, fillOpacity?, stroke?, strokeType?, strokeBlend?, strokeOpacity?, strokeWidth?, position?}",
-            has_comp,
-            new_shape
-        ),
-        cmd!("layer.newAdjustment", "Adjustment Layer", ["Layer", "New"], Some("Cmd+Alt+Y"), "{name?}", has_comp, new_adjustment),
-        cmd!(
-            "layer.settings",
-            "Layer Settings...",
-            ["Layer"],
-            Some("Cmd+Shift+Y"),
-            "{layer?, name?, color?, width?, height?, pixelAspect?, affectAll?: bool (default true; false gives this layer its own copy of a solid other layers use)} → {layer, solid?}",
-            has_layer_settings,
-            layer_settings
-        ),
-        cmd!(
-            "layer.addItem",
-            "Add Footage to Comp",
-            ["File"],
-            Some("Cmd+/"),
-            "{item: id|name, time? (s, the In point), index? (1-based stack position; default above the selected layer), position? ([x, y] comp px; default the centre), duration? (s, for a still)}",
-            has_comp,
-            add_item
-        ),
-        cmd!(
-            "layer.replaceSource",
-            "Replace Layer Source",
-            [],
-            Some("Cmd+Alt+/"),
-            "{comp?, layers?, layer?, item?: id|name (default the Project panel selection), fixExpressions?: bool (accepted for After Effects compatibility)} → {layers, item}",
-            has_replace_source,
-            replace_source
-        ),
-        cmd!("layer.select", "Select Layers", [], None, "{layers: [id|name|#n], add?, toggle?}", has_comp, select),
-        cmd!("layer.selectNext", "Select Next Layer", [], Some("Cmd+ArrowDown"), "{add?}", has_comp, select_next),
-        cmd!("layer.selectPrevious", "Select Previous Layer", [], Some("Cmd+ArrowUp"), "{add?}", has_comp, select_prev),
-        cmd!("layer.extendSelectionNext", "Extend Selection to Next Layer", [], Some("Cmd+Shift+ArrowDown"), "{}", has_comp, |s, _| select_step(
-            s,
-            &json!({"add": true}),
-            1
-        )),
-        cmd!("layer.extendSelectionPrevious", "Extend Selection to Previous Layer", [], Some("Cmd+Shift+ArrowUp"), "{}", has_comp, |s, _| select_step(
-            s,
-            &json!({"add": true}),
-            -1
-        )),
-        cmd!(
-            "layer.setSwitch",
-            "Layer Switch",
-            [],
-            None,
-            "{layers?, switch: video|audio|solo|lock|shy|collapse|quality|fx|frameBlend|motionBlur|adjustment|threeD|guide|preserveTransparency, value?, merge?, others? (the named layers alone: the other layers get the opposite state, or come back)}",
-            has_layers,
-            set_switch
-        ),
-        cmd!("layer.rename", "Rename", [], Some("Enter"), "{layer?, name}", has_layers, rename),
-        cmd!("layer.setComment", "Layer Comment", [], None, "{layers?, comment}", has_layers, set_comment),
-        cmd!("layer.setBlendMode", "Blending Mode", [], None, "{layers?, mode?: Normal|Multiply|Screen|…, step?: ±1}", has_layers, blend),
-        cmd!(
-            "layer.setTrackMatte",
-            "Track Matte",
-            [],
-            None,
-            "{layer?, matte: layer|null, kind?: alpha|alphaInverted|luma|lumaInverted}",
-            has_layers,
-            track_matte
-        ),
-        cmd!("layer.setParent", "Parent", [], None, "{layers?, parent: layer|null, compensate?: bool}", has_layers, set_parent),
-        cmd!(
-            "layer.timing",
-            "Layer Timing",
-            [],
-            None,
-            "{layers?, op?: moveInToTime|moveOutToTime|moveInToStart|moveOutToEnd|trimInToTime|trimOutToTime, delta?, start?, in?, out?, inDelta?, outDelta? (seconds, per layer), merge?}",
-            has_layers,
-            timing
-        ),
-        cmd!("layer.moveInToStart", "Move Layer In Point to Beginning of Comp", [], Some("Alt+Home"), "{layers?}", has_layers, |s, p| timing(
-            s,
-            &with(p, "op", json!("moveInToStart"))
-        )),
-        cmd!("layer.moveOutToEnd", "Move Layer Out Point to End of Comp", [], Some("Alt+End"), "{layers?}", has_layers, |s, p| timing(
-            s,
-            &with(p, "op", json!("moveOutToEnd"))
-        )),
-        cmd!("layer.moveEarlier", "Move Layers 1 Frame Earlier", [], Some("Alt+PageUp"), "{layers?}", has_layers, |s, p| move_frames(s, p, -1)),
-        cmd!("layer.moveLater", "Move Layers 1 Frame Later", [], Some("Alt+PageDown"), "{layers?}", has_layers, |s, p| move_frames(s, p, 1)),
-        cmd!("layer.moveEarlier10", "Move Layers 10 Frames Earlier", [], Some("Alt+Shift+PageUp"), "{layers?}", has_layers, |s, p| move_frames(s, p, -10)),
-        cmd!("layer.moveLater10", "Move Layers 10 Frames Later", [], Some("Alt+Shift+PageDown"), "{layers?}", has_layers, |s, p| move_frames(s, p, 10)),
-        cmd!("layer.slip", "Slip Edit", [], None, "{layers?, delta? (seconds) | frames?, merge?}", has_layers, slip),
-        cmd!("layer.slipBack", "Slip Edit 1 Frame Earlier", [], None, "{layers?}", has_layers, |s, p| {
-            let mut p = p.clone();
-            p["frames"] = json!(-1);
-            slip(s, &p)
-        }),
-        cmd!("layer.slipForward", "Slip Edit 1 Frame Later", [], None, "{layers?}", has_layers, |s, p| {
-            let mut p = p.clone();
-            p["frames"] = json!(1);
-            slip(s, &p)
-        }),
-        cmd!("layer.arrange", "Arrange", ["Layer", "Arrange"], None, "{layers?, to: front|forward|backward|back, index?, above?: layer}", has_layers, arrange),
-        cmd!(
-            "layer.precompose",
-            "Pre-compose...",
-            ["Layer"],
-            Some("Cmd+Shift+C"),
-            "{layers?, name?, mode?: move|leave, adjustDuration?, open?}",
-            has_layers,
-            precompose
-        ),
-        cmd!(
-            "layer.addMask",
-            "New Mask",
-            ["Layer", "Mask"],
-            Some("Cmd+Shift+N"),
-            "{layer?, shape?: rect|ellipse|rounded|polygon|star, rect? [x,y,w,h] (layer space; a polygon or star fits its width), mode?}",
-            has_layers,
-            add_mask
-        ),
-        cmd!("layer.setMask", "Mask Mode", [], None, "{layer?, mask: index|uid|name, mode?, inverted?}", has_layers, mask_props),
-        cmd!(
-            "layer.addShapeItem",
-            "Add (Shape)",
-            [],
-            None,
-            "{layer?, kind: group|rect|ellipse|star|polygon|path|fill|stroke|gfill|gstroke|trim|repeater|round|offset|pucker|twist|zigzag|wiggle|merge|frontColor|bevelColor|sideColor|backColor, group?: uid|path} → {uid, path} (frontColor…backColor: the group's Front / Bevel / Side / Back item, which colours that surface of every extruded paint in the group in Advanced 3D)",
-            has_layers,
-            add_shape_item
-        ),
-        cmd!(
-            "layer.setText",
-            "Edit Text",
-            [],
-            None,
-            "{layer?, range?: [start, end] (characters; default all), text?, font?, style?, size?, fill?, stroke?, applyFill?, applyStroke?, strokeWidth?, tracking?, leading?: px|\"auto\", baselineShift? px, hScale? %, vScale? %, tsume? %, fauxBold?, fauxItalic?, allCaps?, smallCaps?, baseline?: normal|superscript|subscript, superscript?, subscript?, kerning?: metrics|optical|number, ligatures?, discretionaryLigatures? (OpenType), contextualAlternates?, stylisticAlternates?, stylisticSets?: [1–20], ss01?, ss02?, ss03?, ss04?, ss05?, ss06?, ss07?, ss08?, ss09?, ss10?, ss11?, ss12?, ss13?, ss14?, ss15?, ss16?, ss17?, ss18?, ss19?, ss20?, swash?, titling?, ordinals?, fractions?, allSmallCaps?, figureStyle?: default|lining|oldStyle, figureWidth?: default|proportional|tabular, figures?, variations?: {tag: value} (variable font axes; null resets), justify?: left|center|right|justifyLeft|justifyCenter|justifyRight|justifyAll, indentLeft?, indentRight?, indentFirst?, spaceBefore?, spaceAfter?, direction?: ltr|rtl, composer?: everyLine|singleLine, hangingPunctuation?, strokeOverFill?, box?: [x,y,w,h]|null (layer space), vertical?}",
-            has_layers,
-            set_text
-        ),
-        cmd!(
-            "layer.transform",
-            "Transform",
-            ["Layer", "Transform"],
-            None,
-            "{layers?, op: reset|center|fit|fitWidth|fitHeight|flipH|flipV}",
-            has_layers,
-            transform_op
-        ),
-    ]
-}
-
-#[allow(dead_code)]
-fn unused(_: &Comp) {}
-
-#[cfg(test)]
-mod parent_chain_tests {
-    use super::*;
-    use std::sync::Arc;
-
-    fn fixture() -> (Session, u64, u64, u64) {
-        let mut s = Session::default();
-        s.execute("comp.new", json!({"name":"Parent safety","width":16,"height":16,"duration":1})).unwrap();
-        let a = s.execute("layer.newSolid", json!({"name":"A"})).unwrap()["layer"].as_u64().unwrap();
-        let b = s.execute("layer.newSolid", json!({"name":"B"})).unwrap()["layer"].as_u64().unwrap();
-        let c = s.execute("layer.newSolid", json!({"name":"C"})).unwrap()["layer"].as_u64().unwrap();
-        for id in [a, b, c] {
-            s.execute("prop.set", json!({"layer":id,"path":"transform/anchor","value":[0,0,0]})).unwrap();
-        }
-        s.execute("prop.set", json!({"layer":a,"path":"transform/position","value":[100,200,0]})).unwrap();
-        s.execute("prop.set", json!({"layer":c,"path":"transform/position","value":[10,20,0]})).unwrap();
-        s.history.undo.clear();
-        (s, a, b, c)
-    }
-    fn malformed_parent(s: &mut Session, child: u64, parent: u64) {
-        let cid = s.active_comp_id().unwrap();
-        Arc::make_mut(&mut s.project).comp_mut(cid).unwrap().layer_mut(LayerId(child)).unwrap().parent = Some(LayerId(parent));
-    }
-    fn assert_atomic_error(s: &mut Session, child: u64, parent: u64, compensate: bool, message: &str) {
-        let before = s.project.clone();
-        let revision = s.revision;
-        let undo = s.history.undo.len();
-        let err = s.execute("layer.setParent", json!({"layers":[child],"parent":parent,"compensate":compensate})).unwrap_err();
-        assert!(err.to_string().contains(message), "{err}");
-        assert!(Arc::ptr_eq(&before, &s.project));
-        assert_eq!(s.revision, revision);
-        assert_eq!(s.history.undo.len(), undo);
-    }
-    #[test]
-    fn loaded_cycle_excluding_selected_child_is_rejected_atomically() {
-        for compensate in [true, false] {
-            let (mut s, a, b, c) = fixture();
-            // Simulate a malformed loaded project. Never execute this on the unguarded baseline.
-            malformed_parent(&mut s, a, b);
-            malformed_parent(&mut s, b, a);
-            assert_atomic_error(&mut s, c, a, compensate, "existing cycle");
-        }
-    }
-    #[test]
-    fn dangling_loaded_parent_is_rejected_atomically() {
-        for compensate in [true, false] {
-            let (mut s, a, _, c) = fixture();
-            malformed_parent(&mut s, a, u64::MAX);
-            assert_atomic_error(&mut s, c, a, compensate, "missing layer");
-        }
-    }
-    #[test]
-    fn selected_descendant_and_direct_self_are_rejected() {
-        let (mut s, a, _, c) = fixture();
-        assert_atomic_error(&mut s, c, c, false, "create a cycle");
-        s.execute("layer.setParent", json!({"layers":[a],"parent":c,"compensate":false})).unwrap();
-        assert_atomic_error(&mut s, c, a, true, "create a cycle");
-    }
-    #[test]
-    fn ordinary_parent_and_unparent_keep_explicit_false_and_undo_semantics() {
-        for compensate in [true, false] {
-            let (mut s, a, _, c) = fixture();
-            let old = s.project.clone();
-            let world = |s: &Session| {
-                let cid = s.active_comp_id().unwrap();
-                let comp = s.active_comp().unwrap();
-                let ctx = effectcraft_render::EvalCtx::new(&s.project, cid, comp, s.time());
-                ctx.world_matrix(comp.layer(LayerId(c)).unwrap()).apply(effectcraft_geom::Vec3::ZERO)
-            };
-            let before = world(&s);
-            s.execute("layer.setParent", json!({"layers":[c],"parent":a,"compensate":compensate})).unwrap();
-            let expected = if compensate { before } else { before + effectcraft_geom::vec3(100.0, 200.0, 0.0) };
-            assert!((world(&s) - expected).length() < 1e-9);
-            assert_eq!(s.active_comp().unwrap().layer(LayerId(c)).unwrap().parent, Some(LayerId(a)));
-            assert_eq!(s.history.undo.len(), 1);
-            let parented = s.project.clone();
-            assert!(s.undo());
-            assert!(Arc::ptr_eq(&s.project, &old));
-            assert!(s.redo());
-            assert!(Arc::ptr_eq(&s.project, &parented));
-            s.execute("layer.setParent", json!({"layers":[c],"parent":null,"compensate":compensate})).unwrap();
-            assert_eq!(s.active_comp().unwrap().layer(LayerId(c)).unwrap().parent, None);
-            assert!(s.undo());
-            assert!(Arc::ptr_eq(&s.project, &parented));
-        }
-    }
-    #[test]
-    fn ancestor_and_lookup_work_budgets_fail_closed() {
-        let (mut s, a, b, c) = fixture();
-        malformed_parent(&mut s, a, b);
-        let comp = s.active_comp().unwrap();
-        // New solids are inserted above the selection: C,B,A. Walking A->B scans
-        // three then two layers, and compares the one selected child twice: seven work units.
-        assert_eq!(comp.layers.iter().map(|l| l.id).collect::<Vec<_>>(), vec![LayerId(c), LayerId(b), LayerId(a)]);
-        assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 7).is_ok());
-        assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 6).unwrap_err().to_string().contains("work limit"));
-        assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 256).is_ok());
-        assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 1, 256).unwrap_err().to_string().contains("visit limit"));
-        assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 1).unwrap_err().to_string().contains("work limit"));
-        assert!(check_parent_chain(comp, &[LayerId(c)], None, 0, 0).is_ok(), "unparenting does not traverse ancestors");
-    }
-
-    #[test]
-    fn well_formed_chain_beyond_renderer_depth_is_not_unnecessarily_rejected() {
-        let (s, _, _, c) = fixture();
-        let mut comp = s.active_comp().unwrap().clone();
-        let template = comp.layers.first().unwrap().clone();
-        for n in 0..80 {
-            let mut layer = template.clone();
-            layer.id = LayerId(10_000 + n);
-            layer.parent = (n < 79).then_some(LayerId(10_001 + n));
-            comp.layers.push(layer);
-        }
-        assert!(check_parent_chain(&comp, &[LayerId(c)], Some(LayerId(10_000)), 4096, 1_048_576).is_ok());
-    }
-}
diff --git a/crates/engine/src/commands/mod.rs b/crates/engine/src/commands/mod.rs
deleted file mode 100644
index 23388594b..000000000
--- a/crates/engine/src/commands/mod.rs
+++ /dev/null
@@ -1,613 +0,0 @@
-//! The command registry. Ids follow After Effects' menu structure; every menu item, panel button,
-//! shortcut and viewer/timeline gesture maps to one of these.
-
-mod align;
-mod align_data;
-mod anim;
-mod anim_presets;
-pub mod anim_tools;
-mod animation;
-pub(crate) mod app_more;
-mod autotrace;
-mod batch;
-mod camera_cmds;
-mod comp;
-pub(crate) mod comp_more;
-pub mod content_fill;
-mod create;
-mod edit;
-mod effect;
-pub mod essential;
-pub mod expr_tools;
-mod file;
-pub(crate) mod file_more;
-mod focus;
-pub mod footage_panel;
-pub(crate) mod frame_export;
-mod frontend;
-mod help;
-mod import_project;
-mod key_labels;
-mod key_transform;
-mod keys_more;
-mod layer;
-mod layer_menu;
-mod layer_time;
-pub(crate) mod link;
-mod liquify;
-mod lottie;
-pub mod markers;
-mod mask;
-pub mod mask_interp;
-pub(crate) mod model3d;
-mod nav_more;
-pub mod paint;
-pub mod panels_cmds;
-pub(crate) mod path_nulls;
-mod paths;
-mod project_items;
-pub(crate) mod prop;
-mod prop_groups;
-mod proxy;
-pub mod puppet;
-mod query;
-mod quick_offset;
-mod relink;
-pub(crate) mod relink_moved;
-mod render_queue;
-pub(crate) mod rig3d;
-pub mod roto_cmds;
-mod scene_detect;
-pub mod scripts;
-mod settings;
-pub mod shape_stroke;
-pub mod shape_tool;
-mod stubs;
-mod styles;
-mod text_anim;
-pub mod text_edit;
-mod three_d;
-pub mod time;
-mod timeline;
-mod track;
-mod view;
-pub mod viewer_cmds;
-pub(crate) mod vpe;
-pub(crate) mod vr_editor;
-mod warp_cmds;
-pub(crate) mod watch_folder;
-#[cfg(test)]
-pub(crate) use app_more::report_text as report_text_for_tests;
-pub(crate) use app_more::view_command;
-#[cfg(test)]
-pub(crate) use file::open as open_for_tests;
-#[cfg(test)]
-pub(crate) use keys_more::amplitudes as amplitudes_for_tests;
-#[cfg(test)]
-pub(crate) use mask::split_segment as split_segment_for_tests;
-
-use std::sync::OnceLock;
-
-use effectcraft_project::{Comp, ItemId, Layer, LayerId};
-use effectcraft_time::Tick;
-use serde_json::Value;
-
-use crate::{EngineError, Result, Session};
-
-pub type Run = fn(&mut Session, &Value) -> Result<Value>;
-pub type Enabled = fn(&Session) -> std::result::Result<(), String>;
-
-/// Metadata + implementation for one command.
-pub struct CommandSpec {
-    pub id: &'static str,
-    pub label: &'static str,
-    /// Menu placement, e.g. `["Layer", "New"]`. Empty = not in menus.
-    pub menu: &'static [&'static str],
-    /// Default shortcut (egui-style names, `Cmd` = ⌘ on macOS / Ctrl elsewhere).
-    pub shortcut: Option<&'static str>,
-    /// Further default shortcuts (the menus and tooltips show `shortcut`).
-    pub alt_shortcuts: &'static [&'static str],
-    /// Parameter description for agents and the MCP schema.
-    pub params: &'static str,
-    pub enabled: Enabled,
-    pub run: Run,
-    /// Record in the journal (false for pure queries).
-    pub journal: bool,
-}
-
-#[macro_export]
-macro_rules! cmd {
-    // Several default shortcuts: `["PageDown", "Cmd+ArrowRight"]`.
-    ($id:literal, $label:literal, [$($m:literal),*], [$sc:literal, $($alt:literal),+], $params:literal, $en:expr, $run:expr) => {
-        $crate::commands::CommandSpec { alt_shortcuts: &[$($alt),+], ..$crate::cmd!($id, $label, [$($m),*], Some($sc), $params, $en, $run) }
-    };
-    ($id:literal, $label:literal, [$($m:literal),*], $sc:expr, $params:literal, $en:expr, $run:expr) => {
-        $crate::commands::CommandSpec {
-            id: $id,
-            label: $label,
-            menu: &[$($m),*],
-            shortcut: $sc,
-            alt_shortcuts: &[],
-            params: $params,
-            enabled: $en,
-            run: $run,
-            journal: true,
-        }
-    };
-}
-#[macro_export]
-macro_rules! query {
-    ($id:literal, $label:literal, $params:literal, $run:expr) => {
-        $crate::commands::CommandSpec {
-            id: $id,
-            label: $label,
-            menu: &[],
-            shortcut: None,
-            alt_shortcuts: &[],
-            params: $params,
-            enabled: $crate::commands::always,
-            run: $run,
-            journal: false,
-        }
-    };
-}
-
-pub fn command_specs() -> &'static [CommandSpec] {
-    static SPECS: OnceLock<Vec<CommandSpec>> = OnceLock::new();
-    SPECS.get_or_init(|| {
-        let mut v = Vec::new();
-        v.extend(file::specs());
-        v.extend(crate::models::specs());
-        v.extend(edit::specs());
-        v.extend(comp::specs());
-        v.extend(layer::specs());
-        v.extend(styles::specs());
-        v.extend(three_d::specs());
-        v.extend(model3d::specs());
-        v.extend(rig3d::specs());
-        v.extend(text_anim::specs());
-        v.extend(text_edit::specs());
-        v.extend(layer_time::specs());
-        v.extend(prop::specs());
-        v.extend(prop_groups::specs());
-        v.extend(project_items::specs());
-        v.extend(anim::specs());
-        v.extend(anim_tools::specs());
-        v.extend(link::specs());
-        v.extend(markers::specs());
-        v.extend(mask::specs());
-        v.extend(paths::specs());
-        v.extend(effect::specs());
-        v.extend(time::specs());
-        v.extend(nav_more::specs());
-        v.extend(render_queue::specs());
-        v.extend(help::specs());
-        v.extend(query::specs());
-        v.extend(batch::specs());
-        v.extend(layer_menu::specs());
-        v.extend(create::specs());
-        v.extend(animation::specs());
-        v.extend(anim_presets::specs());
-        v.extend(view::specs());
-        v.extend(viewer_cmds::specs());
-        v.extend(shape_stroke::specs());
-        v.extend(shape_tool::specs());
-        v.extend(focus::specs());
-        v.extend(key_labels::specs());
-        v.extend(key_transform::specs());
-        v.extend(quick_offset::specs());
-        v.extend(file_more::specs());
-        v.extend(relink::specs());
-        v.extend(relink_moved::specs());
-        v.extend(lottie::specs());
-        v.extend(import_project::specs());
-        v.extend(timeline::specs());
-        v.extend(comp_more::specs());
-        v.extend(frame_export::specs());
-        v.extend(watch_folder::specs());
-        v.extend(vpe::specs());
-        v.extend(path_nulls::specs());
-        v.extend(vr_editor::specs());
-        v.extend(frontend::specs());
-        v.extend(track::specs());
-        v.extend(mask_interp::specs());
-        v.extend(warp_cmds::specs());
-        v.extend(camera_cmds::specs());
-        v.extend(roto_cmds::specs());
-        v.extend(paint::specs());
-        v.extend(puppet::specs());
-        v.extend(liquify::specs());
-        v.extend(settings::specs());
-        v.extend(app_more::specs());
-        v.extend(keys_more::specs());
-        v.extend(essential::specs());
-        v.extend(expr_tools::specs());
-        v.extend(proxy::specs());
-        v.extend(scripts::specs());
-        v.extend(panels_cmds::specs());
-        v.extend(footage_panel::specs());
-        v.extend(autotrace::specs());
-        v.extend(scene_detect::specs());
-        v.extend(align_data::specs());
-        v.extend(align::specs());
-        v.extend(content_fill::specs());
-        v.extend(stubs::specs());
-        v.extend(crate::storage::specs());
-        v.extend(crate::learn::specs());
-        v.extend(crate::templates::specs());
-        v.extend(crate::preview::specs());
-        v
-    })
-}
-
-/// Set `footage` as the proxy of `item` (File ▸ Create Proxy's post-render action).
-pub(crate) fn proxy_set(s: &mut Session, item: ItemId, footage: effectcraft_project::Footage) -> Result<()> {
-    proxy::set_proxy_footage(s, &[item], footage)
-}
-
-/// (id, name) of the text animation presets.
-pub fn text_preset_list() -> Vec<(String, String)> {
-    text_anim::preset_names()
-}
-
-/// (id, name, category) of the built-in animation presets (Transitions…).
-pub fn builtin_preset_list() -> Vec<(String, String, String)> {
-    anim_presets::preset_names()
-}
-
-pub fn find(id: &str) -> Option<&'static CommandSpec> {
-    // Every command execution looks its spec up: index the ~2,000 ids once.
-    static INDEX: OnceLock<std::collections::HashMap<&'static str, usize>> = OnceLock::new();
-    let index = INDEX.get_or_init(|| {
-        let mut m = std::collections::HashMap::new();
-        for (i, c) in command_specs().iter().enumerate() {
-            m.entry(c.id).or_insert(i);
-        }
-        m
-    });
-    index.get(id).map(|&i| &command_specs()[i])
-}
-
-// ---------- parameter validation (agents) ----------
-
-/// Top-level keys accepted by a params doc such as `{layers: [id|name|#n], add?, toggle?}` or
-/// `{time? (s) | frame? | timecode?}`; `None` when the doc isn't a `{…}` key list.
-pub fn accepted_params(doc: &str) -> Option<Vec<String>> {
-    let body = doc.trim().strip_prefix('{')?;
-    // Top-level pieces up to the matching close brace, split at `,` and `|`; `:` starts a value.
-    let (mut keys, mut cur, mut depth, mut in_value) = (Vec::new(), String::new(), 0i32, false);
-    let push = |cur: &mut String, keys: &mut Vec<String>| {
-        let k: String = cur.trim().chars().take_while(|c| c.is_ascii_alphanumeric() || *c == '_').collect();
-        if !k.is_empty() && !keys.contains(&k) {
-            keys.push(k);
-        }
-        cur.clear();
-    };
-    for c in body.chars() {
-        match c {
-            '{' | '[' | '(' => depth += 1,
-            ']' | ')' => depth -= 1,
-            '}' if depth == 0 => {
-                push(&mut cur, &mut keys);
-                return Some(keys);
-            }
-            '}' => depth -= 1,
-            ',' if depth == 0 => {
-                push(&mut cur, &mut keys);
-                in_value = false;
-            }
-            '|' if depth == 0 && !in_value => push(&mut cur, &mut keys),
-            ':' if depth == 0 => {
-                push(&mut cur, &mut keys);
-                in_value = true;
-            }
-            _ if depth == 0 && !in_value => cur.push(c),
-            _ => {}
-        }
-    }
-    None
-}
-
-/// Top-level pieces of a params doc (split at depth-0 commas), e.g. `{layer?, path|prop, value}`
-/// → `["layer?", "path|prop", "value"]`.
-fn doc_pieces(doc: &str) -> Option<Vec<String>> {
-    let body = doc.trim().strip_prefix('{')?;
-    let (mut out, mut cur, mut depth) = (Vec::new(), String::new(), 0i32);
-    for c in body.chars() {
-        match c {
-            '{' | '[' | '(' => depth += 1,
-            ']' | ')' => depth -= 1,
-            '}' if depth == 0 => {
-                if !cur.trim().is_empty() {
-                    out.push(cur.trim().to_string());
-                }
-                return Some(out);
-            }
-            '}' => depth -= 1,
-            ',' if depth == 0 => {
-                if !cur.trim().is_empty() {
-                    out.push(cur.trim().to_string());
-                }
-                cur.clear();
-                continue;
-            }
-            _ => {}
-        }
-        cur.push(c);
-    }
-    None
-}
-
-/// The JSON Schema of a command's parameters, derived from its params doc: one property per
-/// accepted key (described by its piece of the doc), no others. MCP `describe_command` and
-/// `list_commands {schemas: true}` serve it.
-pub fn params_schema(spec: &CommandSpec) -> Value {
-    let mut props = serde_json::Map::new();
-    let mut required = vec![];
-    for piece in doc_pieces(spec.params).unwrap_or_default() {
-        let keys = accepted_params(&format!("{{{piece}}}")).unwrap_or_default();
-        let alternatives = keys.len() > 1;
-        for k in keys {
-            // `key?` is optional; so is any key with alternatives (`path|prop`).
-            let optional = alternatives || piece.contains(&format!("{k}?"));
-            if !optional && !required.contains(&k) {
-                required.push(k.clone());
-            }
-            props.insert(k, serde_json::json!({"description": piece}));
-        }
-    }
-    serde_json::json!({
-        "type": "object",
-        "description": spec.params,
-        "properties": props,
-        "required": required,
-        "additionalProperties": accepted_params(spec.params).is_none(),
-    })
-}
-
-/// Keys every command understands (comp targeting, gesture merging) and accepted aliases.
-const ALWAYS_OK: &[&str] = &["comp", "merge"];
-const ALIASES: &[(&str, &str)] = &[("layers", "layer"), ("layer", "layers"), ("time", "frame"), ("frameRate", "fps"), ("properties", "property")];
-
-/// Reject unknown top-level parameters (typos, guessed names) with the list of accepted keys.
-pub fn check_params(spec: &CommandSpec, params: &Value) -> Result<()> {
-    let (Some(obj), Some(accepted)) = (params.as_object(), accepted_params(spec.params)) else { return Ok(()) };
-    let ok = |k: &str| ALWAYS_OK.contains(&k) || accepted.iter().any(|a| a == k || ALIASES.iter().any(|(doc, alias)| doc == a && *alias == k));
-    let unknown: Vec<&str> = obj.keys().map(String::as_str).filter(|k| !ok(k)).collect();
-    if unknown.is_empty() {
-        return Ok(());
-    }
-    let list = if accepted.is_empty() { "none".to_string() } else { accepted.join(", ") };
-    Err(bad(
-        spec.id,
-        format!("unknown parameter(s) {}; accepted: {list} (doc: {})", unknown.iter().map(|k| format!("`{k}`")).collect::<Vec<_>>().join(", "), spec.params),
-    ))
-}
-
-// ---------- enablement ----------
-
-pub fn always(_: &Session) -> std::result::Result<(), String> {
-    Ok(())
-}
-pub(crate) fn has_comp(s: &Session) -> std::result::Result<(), String> {
-    s.active_comp().map(|_| ()).ok_or_else(|| "no composition is open".into())
-}
-pub(crate) fn has_layers(s: &Session) -> std::result::Result<(), String> {
-    has_comp(s)?;
-    if s.state.selected_layers.is_empty() { Err("select a layer first".into()) } else { Ok(()) }
-}
-pub(crate) fn has_keys(s: &Session) -> std::result::Result<(), String> {
-    has_comp(s)?;
-    if s.state.selected_keys.is_empty() { Err("select keyframes first".into()) } else { Ok(()) }
-}
-
-pub(crate) fn has_project_selection(s: &Session) -> std::result::Result<(), String> {
-    if s.state.project_selection.is_empty() { Err("select an item in the Project panel first".into()) } else { Ok(()) }
-}
-
-/// Disabled-command enablement (menu entries whose implementation lands with another milestone;
-/// none are left, kept for future stubs).
-#[allow(dead_code)]
-pub(crate) fn not_yet(_: &Session) -> std::result::Result<(), String> {
-    Err("not available yet in EffectCraft".into())
-}
-
-/// `run` of a not-yet-available command.
-#[allow(dead_code)]
-pub(crate) fn not_yet_run(_: &mut Session, _: &Value) -> Result<Value> {
-    Err(EngineError::Other("not available yet in EffectCraft".into()))
-}
-
-/// Hand a frontend-only command to the UI ([`crate::Event::Frontend`]).
-pub(crate) fn frontend(s: &mut Session, id: &str, p: &Value) -> Result<Value> {
-    s.events.push(crate::Event::Frontend { command: id.to_string(), params: p.clone() });
-    Ok(serde_json::json!({"frontend": id}))
-}
-
-/// Match path of a node (`transform/position`, `effects/#2/blurriness` style with `match#n`
-/// occurrences) so it can be found again on another layer.
-pub fn match_path_of(g: &effectcraft_project::PropGroup, uid: effectcraft_project::Uid) -> Option<String> {
-    for c in &g.children {
-        let nth = g.children.iter().take_while(|x| !std::ptr::eq(*x, c)).filter(|x| x.match_id() == c.match_id()).count() + 1;
-        let seg = if nth == 1 { c.match_id().to_string() } else { format!("{}#{nth}", c.match_id()) };
-        if c.uid() == uid {
-            return Some(seg);
-        }
-        if let effectcraft_project::Node::Group(sub) = c
-            && let Some(rest) = match_path_of(sub, uid)
-        {
-            return Some(format!("{seg}/{rest}"));
-        }
-    }
-    None
-}
-
-/// Turn `effects/<match name>[#n]/<property>` (as [`match_path_of`] writes it) into a uid path on
-/// `l`. Path parsing splits on `.`, which would cut a match name like `ec.control.slider` apart.
-/// Any other path, or an effect that is not on the layer, comes back unchanged.
-pub(crate) fn resolve_effect_path(l: &Layer, path: &str) -> String {
-    let Some((seg, tail)) = path.strip_prefix("effects/").and_then(|r| r.split_once('/')) else { return path.to_string() };
-    let (match_id, nth) = match seg.rsplit_once('#') {
-        Some((m, n)) if !m.is_empty() => match n.parse::<usize>() {
-            Ok(n) if n >= 1 => (m, n),
-            _ => (seg, 1),
-        },
-        _ => (seg, 1),
-    };
-    match l.effects().and_then(|fx| fx.groups().filter(|g| g.match_id == match_id).nth(nth - 1)) {
-        Some(g) => format!("effects/@{}/{tail}", g.uid),
-        None => path.to_string(),
-    }
-}
-
-/// Selected properties (leaves) of the active comp as (layer, uid); selected groups expand to
-/// their properties.
-pub(crate) fn selected_leaf_props(s: &Session) -> Vec<(LayerId, effectcraft_project::Uid)> {
-    let Some(comp) = s.active_comp() else { return vec![] };
-    let mut out = vec![];
-    for (lid, uid) in &s.state.selected_props {
-        let Some(l) = comp.layer(*lid) else { continue };
-        if l.props.find(*uid).is_some() {
-            out.push((*lid, *uid));
-        } else if let Some(g) = l.props.find_group(*uid) {
-            g.walk("", &mut |_, p| out.push((*lid, p.uid)));
-        }
-    }
-    out
-}
-
-// ---------- params ----------
-
-pub(crate) fn bad(cmd: &str, msg: impl Into<String>) -> EngineError {
-    EngineError::BadParams { cmd: cmd.into(), msg: msg.into() }
-}
-pub(crate) fn str_p<'a>(p: &'a Value, k: &str) -> Option<&'a str> {
-    p.get(k).and_then(Value::as_str)
-}
-pub(crate) fn f_p(p: &Value, k: &str) -> Option<f64> {
-    p.get(k).and_then(Value::as_f64)
-}
-pub(crate) fn b_p(p: &Value, k: &str) -> Option<bool> {
-    p.get(k).and_then(Value::as_bool)
-}
-pub(crate) fn merge_p(p: &Value) -> Option<&str> {
-    str_p(p, "merge")
-}
-
-/// `comp`: item id or name (an all-digit string that names no comp is taken as an id, as MCP
-/// clients often send numbers as strings); default the active comp.
-pub(crate) fn comp_id(s: &Session, p: &Value) -> Result<ItemId> {
-    let missing = |v: &Value| EngineError::NoSuchComp(v.to_string());
-    match p.get("comp") {
-        Some(v @ Value::Number(n)) => n.as_u64().map(ItemId).filter(|id| s.project.comp(*id).is_some()).ok_or_else(|| missing(v)),
-        Some(v @ Value::String(name)) => s
-            .project
-            .items
-            .values()
-            .find(|i| &i.name == name && i.as_comp().is_some())
-            .map(|i| i.id)
-            .or_else(|| digits_id(name).map(ItemId).filter(|id| s.project.comp(*id).is_some()))
-            .ok_or_else(|| missing(v)),
-        _ => s.active_comp_id().ok_or(EngineError::NoComp),
-    }
-}
-
-/// An all-ASCII-digit string as a number (`"98"` -> 98); anything else (names, `#n`, signs) is `None`.
-fn digits_id(s: &str) -> Option<u64> {
-    if s.is_empty() || !s.bytes().all(|b| b.is_ascii_digit()) {
-        return None;
-    }
-    s.parse().ok()
-}
-
-/// Resolve a layer reference: id (number), `#n` / index (1-based), or name. An all-digit string
-/// that names no layer is resolved as the number it spells.
-pub(crate) fn resolve_layer(comp: &Comp, v: &Value) -> Option<LayerId> {
-    match v {
-        Value::Number(n) => {
-            let id = n.as_u64()?;
-            if comp.layer(LayerId(id)).is_some() { Some(LayerId(id)) } else { comp.layers.get((id as usize).checked_sub(1)?).map(|l| l.id) }
-        }
-        Value::String(s) => {
-            if let Some(i) = s.strip_prefix('#').and_then(|i| i.parse::<usize>().ok()) {
-                return comp.layers.get(i.checked_sub(1)?).map(|l| l.id);
-            }
-            comp.layers.iter().find(|l| &l.name == s).map(|l| l.id).or_else(|| digits_id(s).and_then(|id| resolve_layer(comp, &Value::from(id))))
-        }
-        _ => None,
-    }
-}
-
-/// `layer` param or the first selected layer.
-pub(crate) fn layer_p(s: &Session, p: &Value, cmd: &str) -> Result<(ItemId, LayerId)> {
-    let cid = comp_id(s, p)?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
-    if let Some(v) = p.get("layer") {
-        return resolve_layer(comp, v).map(|l| (cid, l)).ok_or_else(|| bad(cmd, format!("no layer {v}")));
-    }
-    s.state
-        .selected_layers
-        .first()
-        .copied()
-        .filter(|l| comp.layer(*l).is_some())
-        .map(|l| (cid, l))
-        .ok_or_else(|| bad(cmd, "no `layer` given and no layer selected"))
-}
-
-/// `layers` param (array) or the selection.
-pub(crate) fn layers_p(s: &Session, p: &Value) -> Result<(ItemId, Vec<LayerId>)> {
-    let cid = comp_id(s, p)?;
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
-    // Explicit references that match no layer are an error (agents otherwise get a silent no-op).
-    let resolve =
-        |v: &Value| resolve_layer(comp, v).ok_or_else(|| EngineError::Other(format!("no layer {v} (use a layer id, \"#n\" or a name from comp.info)")));
-    if let Some(Value::Array(a)) = p.get("layers") {
-        return Ok((cid, a.iter().map(resolve).collect::<Result<_>>()?));
-    }
-    if let Some(v) = p.get("layer").filter(|v| !v.is_null()) {
-        return Ok((cid, vec![resolve(v)?]));
-    }
-    Ok((cid, s.state.selected_layers.iter().copied().filter(|l| comp.layer(*l).is_some()).collect()))
-}
-
-/// Whether a layer can be picked by the user (Select All, Ctrl+Up/Down, a Timeline click): not
-/// locked, and not hidden by the composition's Hide Shy Layers.
-pub(crate) fn selectable(comp: &Comp, l: &Layer) -> bool {
-    !(l.switches.locked || (comp.hide_shy && l.switches.shy))
-}
-
-/// The layers of `ids` a command may edit: locked layers are left alone, as in After Effects.
-/// An error when every one of them is locked.
-pub(crate) fn unlocked(s: &Session, cid: ItemId, ids: Vec<LayerId>, cmd: &str) -> Result<Vec<LayerId>> {
-    let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
-    let locked = |id: &LayerId| comp.layer(*id).is_some_and(|l| l.switches.locked);
-    match ids.iter().find(|id| locked(id)) {
-        Some(first) if ids.iter().all(locked) => {
-            let name = comp.layer(*first).map(|l| l.name.clone()).unwrap_or_default();
-            Err(bad(cmd, format!("“{name}” is locked (Layer ▸ Switches ▸ Unlock All Layers)")))
-        }
-        _ => Ok(ids.into_iter().filter(|id| !locked(id)).collect()),
-    }
-}
-
-/// `visible: [{layer, prop}]`: the properties the Timeline shows (J / K and Select All
-/// Keyframes use only those, as in After Effects). `None` when not given.
-pub(crate) fn visible_p(p: &Value) -> Option<Vec<(LayerId, effectcraft_project::Uid)>> {
-    let a = p.get("visible")?.as_array()?;
-    Some(a.iter().filter_map(|v| Some((LayerId(v.get("layer")?.as_u64()?), v.get("prop")?.as_u64()?))).collect())
-}
-
-/// `time` (seconds) or `frame` param, else the CTI.
-pub(crate) fn time_p(s: &Session, p: &Value, comp: Option<&Comp>) -> Tick {
-    if let Some(t) = f_p(p, "time") {
-        return Tick::from_seconds_f64(t);
-    }
-    if let (Some(f), Some(c)) = (p.get("frame").and_then(Value::as_i64), comp) {
-        return c.frame_rate.tick_of(f);
-    }
-    s.time()
-}
-
-pub(crate) fn layer_mut(p: &mut effectcraft_project::Project, cid: ItemId, lid: LayerId) -> Result<&mut Layer> {
-    p.comp_mut(cid).ok_or(EngineError::NoComp)?.layer_mut(lid).ok_or(EngineError::Project(effectcraft_project::ProjectError::NoLayer(lid)))
-}
diff --git a/crates/engine/src/commands/scripts.rs b/crates/engine/src/commands/scripts.rs
deleted file mode 100644
index 24049459c..000000000
--- a/crates/engine/src/commands/scripts.rs
+++ /dev/null
@@ -1,605 +0,0 @@
-//! File ▸ Scripts and ScriptUI.
-//!
-//! * **Installed scripts** live in the settings store under `Scripts/` (File ▸ Scripts ▸ Install
-//!   Script File…) and `Scripts/ScriptUI Panels/` (Install ScriptUI Panel…), next to the
-//!   settings on the desktop, so dropping `.jsx` files in those folders works too. File ▸ Scripts
-//!   lists them with the bundled sample scripts and extensions ([`BUNDLED`]) and runs them by name; ScriptUI
-//!   panels appear at the bottom of the Window menu and open as dockable panels
-//!   (`window.scriptPanel`), running with `this` = the panel as in After Effects.
-//! * **ScriptUI windows** (`scriptui.*`): list the open script windows, read their control
-//!   trees, click buttons and set values like a user, close them (see [`crate::scriptui`]).
-//! * **Script settings** (`script.settings.*`): After Effects' `app.settings`, string values by
-//!   section and key that last between runs ([`SCRIPT_SETTINGS_FILE`]).
-
-use std::collections::BTreeMap;
-
-use serde::Serialize;
-use serde_json::{Value, json};
-
-use super::{CommandSpec, always, bad, str_p};
-use crate::{EngineError, Event, Result, Session, cmd, scriptui};
-
-/// The settings-store folders of installed scripts.
-pub const SCRIPTS_DIR: &str = "Scripts";
-pub const PANELS_DIR: &str = "Scripts/ScriptUI Panels";
-/// The ScriptUI panels open when EffectCraft last quit (settings store), reopened at launch.
-pub const OPEN_PANELS_FILE: &str = "scriptui_panels.json";
-/// Scripts' `app.settings` in the settings store: `{section: {key: value}}`, as After Effects
-/// keeps them in its preferences.
-pub const SCRIPT_SETTINGS_FILE: &str = "script_settings.json";
-/// User presets of the core Ease Presets panel of v0.6.0 (#254) and where the Ease Presets
-/// ScriptUI panel that replaced it keeps them: (file, section, key). The file's text moves there
-/// unchanged (the panel reads the same JSON) the first time settings load.
-const LEGACY_EASE_PRESETS: (&str, &str, &str) = ("ease_presets.json", "Ease Presets", "userPresets");
-/// Longest section, key and value a script may store (characters / bytes).
-const MAX_SETTING_NAME: usize = 256;
-const MAX_SETTING_VALUE: usize = 1 << 20;
-
-/// Scripts' `app.settings`: values by section and key.
-pub type ScriptSettings = BTreeMap<String, BTreeMap<String, String>>;
-
-/// Load scripts' settings from the settings store (a corrupt file gives none), moving user ease
-/// presets saved before Ease Presets became a ScriptUI panel into its section.
-pub(crate) fn load_script_settings(s: &mut Session) {
-    let Some(cfg) = s.config.clone() else { return };
-    s.script_settings = cfg
-        .read(SCRIPT_SETTINGS_FILE)
-        .and_then(|t| serde_json::from_str(&t).map_err(|e| log::warn!("{SCRIPT_SETTINGS_FILE} is not valid ({e}); scripts start without their settings")).ok())
-        .unwrap_or_default();
-    let (file, section, key) = LEGACY_EASE_PRESETS;
-    if let Some(text) = cfg.read(file)
-        && !s.script_settings.get(section).is_some_and(|m| m.contains_key(key))
-    {
-        s.script_settings.entry(section.into()).or_default().insert(key.into(), text);
-        if let Err(e) = store_script_settings(s) {
-            log::warn!("cannot move {file} into the Ease Presets panel's settings: {e}");
-        }
-    }
-}
-
-fn store_script_settings(s: &Session) -> Result<()> {
-    let Some(cfg) = &s.config else { return Ok(()) };
-    let text = serde_json::to_string_pretty(&s.script_settings).map_err(|e| EngineError::Other(format!("script settings: {e}")))?;
-    cfg.write(SCRIPT_SETTINGS_FILE, &text).map_err(|e| EngineError::Other(format!("cannot save script settings: {e}")))
-}
-
-fn setting_name<'a>(p: &'a Value, k: &str, c: &str) -> Result<&'a str> {
-    let v = str_p(p, k).ok_or_else(|| bad(c, format!("missing `{k}`")))?;
-    if v.chars().count() > MAX_SETTING_NAME {
-        return Err(bad(c, format!("`{k}` is longer than {MAX_SETTING_NAME} characters")));
-    }
-    Ok(v)
-}
-
-/// `script.settings.get {section, key}` → `{have, value}` (`value` "" when there is none).
-fn settings_get(s: &mut Session, p: &Value) -> Result<Value> {
-    const C: &str = "script.settings.get";
-    let (section, key) = (setting_name(p, "section", C)?, setting_name(p, "key", C)?);
-    let v = s.script_settings.get(section).and_then(|m| m.get(key));
-    Ok(json!({"have": v.is_some(), "value": v.cloned().unwrap_or_default()}))
-}
-
-/// `script.settings.save {section, key, value}`: kept in the settings store.
-fn settings_save(s: &mut Session, p: &Value) -> Result<Value> {
-    const C: &str = "script.settings.save";
-    let (section, key) = (setting_name(p, "section", C)?, setting_name(p, "key", C)?);
-    let value = match p.get("value") {
-        Some(Value::String(v)) => v.clone(),
-        Some(v) if !v.is_null() => v.to_string(),
-        _ => return Err(bad(C, "missing `value`")),
-    };
-    if value.len() > MAX_SETTING_VALUE {
-        return Err(bad(C, format!("`value` is larger than {MAX_SETTING_VALUE} bytes")));
-    }
-    s.script_settings.entry(section.into()).or_default().insert(key.into(), value);
-    store_script_settings(s)?;
-    Ok(Value::Null)
-}
-
-/// Scripts that ship with EffectCraft (original work): (file name, ScriptUI panel, source, code).
-/// `sample`s show how to script EffectCraft; `extension`s (in `extensions/`) are optional tools
-/// built on the public scripting API, outside the core, like third-party scripts in After Effects.
-pub const BUNDLED: &[(&str, bool, &str, &str)] = &[
-    ("Create Null at Selected Layers.jsx", false, "sample", include_str!("../../scripts/Create Null at Selected Layers.jsx")),
-    ("Rename Layers.jsx", false, "sample", include_str!("../../scripts/Rename Layers.jsx")),
-    ("Render Queue Batch.jsx", false, "sample", include_str!("../../scripts/Render Queue Batch.jsx")),
-    ("Sort Layers by In Point.jsx", false, "sample", include_str!("../../scripts/Sort Layers by In Point.jsx")),
-    ("Layer Tools.jsx", true, "sample", include_str!("../../scripts/ScriptUI Panels/Layer Tools.jsx")),
-    ("Ease Presets.jsx", true, "extension", include_str!("../../../../extensions/scriptui-panels/Ease Presets.jsx")),
-];
-
-/// A script File ▸ Scripts (or the Window menu, for panels) offers.
-#[derive(Clone, Debug, PartialEq, Serialize)]
-pub struct ScriptEntry {
-    /// File name (`Rename Layers.jsx`): what the menus show and commands take.
-    pub name: String,
-    /// In the ScriptUI Panels folder: opens as a dockable panel.
-    pub panel: bool,
-    /// `installed`, `sample` or `extension` (bundled, see [`BUNDLED`]).
-    pub source: &'static str,
-}
-
-fn is_script(name: &str) -> bool {
-    let l = name.to_ascii_lowercase();
-    l.ends_with(".jsx") || l.ends_with(".js")
-}
-
-/// Whether `name` can name an installed script: a bare file name, never a path (names are joined
-/// onto the Scripts folders of the settings store, which takes them as relative paths), and on
-/// Windows none of the names [`windows_unsafe_name`] lists.
-fn is_script_name(name: &str) -> bool {
-    is_bare_name(name) && !(cfg!(windows) && windows_unsafe_name(name))
-}
-
-/// One path component on every platform: not empty, `.` or `..`, and without `/`, `\` or NUL.
-pub(crate) fn is_bare_name(name: &str) -> bool {
-    !name.is_empty() && name != "." && name != ".." && !name.contains(['/', '\\', '\0'])
-}
-
-/// Names that are not ordinary file names on Windows (elsewhere they are): with `:` (a drive or a
-/// stream), ending in `.` or a space (Windows drops them), or a device name, which names a device
-/// in any folder and with any extension (`con.jsx`): `CON`, `PRN`, `AUX`, `NUL`, `CONIN$`,
-/// `CONOUT$`, `COM0`–`COM9` and `LPT0`–`LPT9` (also with `¹²³`).
-pub(crate) fn windows_unsafe_name(name: &str) -> bool {
-    let stem = name.split('.').next().unwrap_or_default().trim_end_matches(' ').to_ascii_uppercase();
-    let port = |p: &str| {
-        let mut n = stem.strip_prefix(p).unwrap_or_default().chars();
-        matches!((n.next(), n.next()), (Some('0'..='9' | '¹' | '²' | '³'), None))
-    };
-    let device = matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL" | "CONIN$" | "CONOUT$") || port("COM") || port("LPT");
-    name.contains(':') || name.ends_with(['.', ' ']) || device
-}
-
-/// Installed scripts and panels, then the bundled ones not shadowed by an installed one, by name.
-pub fn scripts(s: &Session) -> Vec<ScriptEntry> {
-    let mut v: Vec<ScriptEntry> = vec![];
-    if let Some(cfg) = &s.config {
-        for (dir, panel) in [(SCRIPTS_DIR, false), (PANELS_DIR, true)] {
-            for n in cfg.list(dir).into_iter().filter(|n| is_script(n) && is_script_name(n)) {
-                v.push(ScriptEntry { name: n, panel, source: "installed" });
-            }
-        }
-    }
-    for (name, panel, source, _) in BUNDLED {
-        if !v.iter().any(|e| e.name == *name && e.panel == *panel) {
-            v.push(ScriptEntry { name: name.to_string(), panel: *panel, source });
-        }
-    }
-    v.sort_by(|a, b| a.panel.cmp(&b.panel).then(a.name.to_lowercase().cmp(&b.name.to_lowercase())));
-    v
-}
-
-/// The code of an installed or bundled script / panel.
-pub fn script_code(s: &Session, name: &str, panel: Option<bool>) -> Option<(bool, String)> {
-    if !is_script(name) || !is_script_name(name) {
-        return None;
-    }
-    if let Some(cfg) = &s.config {
-        for (dir, is_panel) in [(SCRIPTS_DIR, false), (PANELS_DIR, true)] {
-            if panel.is_some_and(|p| p != is_panel) {
-                continue;
-            }
-            if let Some(code) = cfg.read(&format!("{dir}/{name}")) {
-                return Some((is_panel, code));
-            }
-        }
-    }
-    BUNDLED.iter().find(|(n, p, ..)| *n == name && panel.is_none_or(|w| w == *p)).map(|(_, p, _, c)| (*p, c.to_string()))
-}
-
-fn install(s: &mut Session, p: &Value, panel: bool) -> Result<Value> {
-    let c = if panel { "file.installScriptUIPanel" } else { "file.installScript" };
-    let path = str_p(p, "path").ok_or_else(|| bad(c, "missing `path` (a .jsx / .js script)"))?;
-    let name = std::path::Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();
-    if !is_script(&name) {
-        return Err(bad(c, "scripts are .jsx or .js files (.jsxbin is not supported)"));
-    }
-    // A name it could not be run or uninstalled by (`\` is a file-name character on Unix).
-    if !is_script_name(&name) {
-        return Err(bad(c, format!("`{name}` is not a script file name")));
-    }
-    let bytes = s.services.read_file(path).map_err(|e| EngineError::Other(format!("cannot read {path}: {e}")))?;
-    let code = String::from_utf8(bytes).map_err(|_| bad(c, "the script is not UTF-8 text"))?;
-    let cfg = s.config.clone().ok_or_else(|| EngineError::Other("this session has no settings folder to install scripts into".into()))?;
-    let dir = if panel { PANELS_DIR } else { SCRIPTS_DIR };
-    cfg.write(&format!("{dir}/{name}"), &code).map_err(|e| EngineError::Other(format!("cannot install {name}: {e}")))?;
-    // After Effects asks for a restart; our menus pick it up at once.
-    s.toast(if panel {
-        format!("Installed ScriptUI panel {name}: find it at the bottom of the Window menu")
-    } else {
-        format!("Installed script {name}: find it in File ▸ Scripts")
-    });
-    Ok(json!({"name": name, "panel": panel}))
-}
-
-fn list(s: &mut Session, _: &Value) -> Result<Value> {
-    Ok(json!(scripts(s)))
-}
-
-fn uninstall(s: &mut Session, p: &Value) -> Result<Value> {
-    let c = "file.uninstallScript";
-    let name = str_p(p, "name").ok_or_else(|| bad(c, "missing `name`"))?;
-    if !is_script(name) || !is_script_name(name) {
-        return Err(bad(c, format!("`{name}` is not a script file name")));
-    }
-    let cfg = s.config.clone().ok_or_else(|| bad(c, "no settings folder"))?;
-    let mut removed = false;
-    for dir in [SCRIPTS_DIR, PANELS_DIR] {
-        let key = format!("{dir}/{name}");
-        if cfg.read(&key).is_some() {
-            cfg.remove(&key).map_err(|e| EngineError::Other(e.to_string()))?;
-            removed = true;
-        }
-    }
-    if removed { Ok(json!({"removed": name})) } else { Err(bad(c, format!("`{name}` is not installed"))) }
-}
-
-/// Run an installed or bundled script by name (File ▸ Scripts ▸ <name>). A ScriptUI panel run
-/// this way gets `this` = a floating palette-like panel window.
-pub(crate) fn run_named(s: &mut Session, name: &str) -> Result<Value> {
-    let (panel, code) = script_code(s, name, None).ok_or_else(|| bad("file.runScript", format!("no installed or bundled script `{name}`")))?;
-    if panel {
-        return open_panel(s, &json!({"name": name}));
-    }
-    super::file_more::run_js_named(s, &code, name)
-}
-
-/// The code a ScriptUI panel runs with: `this` is a dockable Panel titled after the script.
-pub fn panel_wrapper(title: &str, code: &str) -> String {
-    // On one line, so line numbers in errors stay those of the file.
-    format!("(function () {{ {code}\n}}).call(__uiDockPanel({}));", Value::String(title.to_string()))
-}
-
-/// The ScriptUI panels open now (script names).
-pub(crate) fn open_panel_names(s: &Session) -> Vec<String> {
-    s.script_ui.windows.iter().filter(|w| w.kind == scriptui::WindowKind::Panel).map(|w| w.script.clone()).collect()
-}
-
-/// The panels open when EffectCraft last quit (`{"open": [names]}`); a missing or unreadable
-/// file is none.
-fn remembered_panels(s: &Session) -> Vec<String> {
-    let text = s.config.as_ref().and_then(|c| c.read(OPEN_PANELS_FILE)).unwrap_or_default();
-    let doc: Value = serde_json::from_str(&text).unwrap_or(Value::Null);
-    doc.get("open").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_str).filter(|n| is_script(n)).map(str::to_string).collect()
-}
-
-/// Change the remembered panels with `f` (written only when it changed). The list is kept so
-/// the next launch reopens them, as After Effects reopens the panels of its workspace; quitting
-/// leaves it as it is.
-fn edit_remembered_panels(s: &Session, f: impl FnOnce(&mut Vec<String>)) {
-    let Some(cfg) = &s.config else { return };
-    let before = remembered_panels(s);
-    let mut list = before.clone();
-    f(&mut list);
-    if list != before
-        && let Err(e) = cfg.write(OPEN_PANELS_FILE, &json!({"open": list}).to_string())
-    {
-        log::warn!("cannot remember the open ScriptUI panels: {e}");
-    }
-}
-
-/// Forget the panels of `before` (open before a script window event) that are closed now.
-pub(crate) fn forget_closed_panels(s: &Session, before: &[String]) {
-    let now = open_panel_names(s);
-    let closed: Vec<&String> = before.iter().filter(|n| !now.contains(n)).collect();
-    if !closed.is_empty() {
-        edit_remembered_panels(s, |l| l.retain(|n| !closed.contains(&n)));
-    }
-}
-
-/// `window.restoreScriptPanels`: open the ScriptUI panels that were open when EffectCraft last
-/// quit (frontends call it once at launch). Panels whose script is gone or fails are reported
-/// and forgotten; the others still open.
-fn restore_panels(s: &mut Session, _: &Value) -> Result<Value> {
-    let (mut opened, mut failed) = (vec![], vec![]);
-    for name in remembered_panels(s) {
-        let r = match script_code(s, &name, Some(true)) {
-            Some(_) => open_panel(s, &json!({"name": name})).map_err(|e| e.to_string()),
-            None => Err("no such ScriptUI panel".to_string()),
-        };
-        match r {
-            Ok(_) => opened.push(name),
-            Err(error) => {
-                edit_remembered_panels(s, |l| l.retain(|n| *n != name));
-                failed.push(json!({"name": name, "error": error}));
-            }
-        }
-    }
-    Ok(json!({"opened": opened, "failed": failed}))
-}
-
-/// Window ▸ <ScriptUI panel>: run the panel script (or bring its panel forward).
-fn open_panel(s: &mut Session, p: &Value) -> Result<Value> {
-    let c = "window.scriptPanel";
-    let name = str_p(p, "name").ok_or_else(|| bad(c, "missing `name` (a script in the ScriptUI Panels folder)"))?.to_string();
-    let title = name.trim_end_matches(".jsx").trim_end_matches(".js").to_string();
-    if let Some(w) = s.script_ui.windows.iter().find(|w| w.kind == scriptui::WindowKind::Panel && w.script == name) {
-        let id = w.id;
-        s.events.push(Event::Frontend { command: c.into(), params: json!({"window": id}) });
-        return Ok(json!({"window": id, "open": true}));
-    }
-    let (_, code) = script_code(s, &name, Some(true)).or_else(|| script_code(s, &name, None)).ok_or_else(|| bad(c, format!("no ScriptUI panel `{name}`")))?;
-    let out = super::file_more::run_js_named(s, &panel_wrapper(&title, &code), &name)?;
-    let id = s.script_ui.windows.iter().rev().find(|w| w.kind == scriptui::WindowKind::Panel && w.script == name).map(|w| w.id);
-    if let Some(id) = id {
-        s.events.push(Event::Frontend { command: c.into(), params: json!({"window": id}) });
-    }
-    if id.is_some() {
-        edit_remembered_panels(s, |l| {
-            if !l.contains(&name) {
-                l.push(name.clone());
-            }
-        });
-    }
-    Ok(json!({"window": id, "result": out}))
-}
-
-pub fn specs() -> Vec<CommandSpec> {
-    vec![
-        cmd!(
-            "file.installScript",
-            "Install Script File...",
-            ["File", "Scripts"],
-            None,
-            "{path (.jsx / .js)} → copies it to the Scripts folder; it appears in File ▸ Scripts",
-            always,
-            |s, p| install(s, p, false)
-        ),
-        cmd!(
-            "file.installScriptUIPanel",
-            "Install ScriptUI Panel...",
-            ["File", "Scripts"],
-            None,
-            "{path (.jsx / .js)} → copies it to the ScriptUI Panels folder; it appears in the Window menu",
-            always,
-            |s, p| install(s, p, true)
-        ),
-        cmd!("file.uninstallScript", "Uninstall Script", [], None, "{name}", always, uninstall),
-        crate::query!("file.scripts.list", "List Scripts", "{} → [{name, panel, source: installed|sample|extension}]", list),
-        cmd!(
-            "window.scriptPanel",
-            "ScriptUI Panel",
-            [],
-            None,
-            "{name (a script in the ScriptUI Panels folder, e.g. `Layer Tools.jsx`)} → opens it as a dockable panel",
-            always,
-            open_panel
-        ),
-        cmd!(
-            "window.restoreScriptPanels",
-            "Restore ScriptUI Panels",
-            [],
-            None,
-            "{} → reopens the ScriptUI panels open when EffectCraft last quit (frontends call it at launch) → {opened: [name], failed: [{name, error}]}",
-            always,
-            restore_panels
-        ),
-        crate::query!("script.settings.get", "Get Script Setting", "{section, key} → {have, value} (app.settings.haveSetting / getSetting)", settings_get),
-        cmd!(
-            "script.settings.save",
-            "Save Script Setting",
-            [],
-            None,
-            "{section, key, value (text)} → kept in the settings store (app.settings.saveSetting)",
-            always,
-            settings_save
-        ),
-        cmd!(
-            "script.runTasks",
-            "Run Scheduled Script Tasks",
-            [],
-            None,
-            "{} → runs the app.scheduleTask tasks that are due (frontends do it every frame) → {ran, output, errors, next (ms until the next task, or null)}",
-            always,
-            scriptui::run_tasks
-        ),
-        crate::query!("scriptui.list", "List Script Windows", "{} → [{window, title, kind: dialog|palette|window|panel, script, modal, size}]", scriptui::list),
-        crate::query!(
-            "scriptui.get",
-            "Script Window Controls",
-            "{window?: id | title} → {id, title, kind, root: {id, type, name, text, value, checked, items, selection, bounds, enabled, draw (onDraw paint list), children…}}",
-            scriptui::get
-        ),
-        cmd!(
-            "scriptui.click",
-            "Click Script Window Control",
-            [],
-            None,
-            "{window?: id | title, widget: id | \"#id\" | properties.name | text} (buttons, checkboxes, radio buttons, tabs)",
-            always,
-            scriptui::click
-        ),
-        cmd!(
-            "scriptui.set",
-            "Set Script Window Control",
-            [],
-            None,
-            "{window?, widget, value: text | number | bool | item index | item text, changing?: bool (a live update: each keystroke / slider step; fires onChanging only)} (edit text, sliders, checkboxes, lists) → fires onChanging / onChange",
-            always,
-            scriptui::set
-        ),
-        cmd!(
-            "scriptui.mouse",
-            "Mouse Event on Script Window Control",
-            [],
-            None,
-            "{window?, widget, type: mousedown | mouseup | mousemove | mouseover | mouseout | click (default), x?, y? (relative to the control; default its centre), button? (0 left, 1 middle, 2 right), detail? (click count), screenX?, screenY?, altKey?, ctrlKey?, metaKey?, shiftKey?} → the script's addEventListener listeners on the control and its containers receive a MouseEvent",
-            always,
-            scriptui::mouse
-        ),
-        cmd!(
-            "scriptui.close",
-            "Close Script Window",
-            [],
-            None,
-            "{window?, result? (a dialog's show() returns it; default 2 = Cancel)}",
-            always,
-            scriptui::close
-        ),
-    ]
-}
-
-#[cfg(test)]
-mod tests {
-    use std::path::PathBuf;
-    use std::sync::Arc;
-
-    use serde_json::{Value, json};
-
-    use super::{BUNDLED, PANELS_DIR, SCRIPTS_DIR, is_bare_name, is_script, is_script_name, script_code, windows_unsafe_name};
-    use crate::config::DirConfig;
-    use crate::{EngineError, Result, ScriptRequest, Session};
-
-    /// Stands in for the JavaScript runtime: reports the code it was asked to run.
-    fn echo(_: &mut Session, r: &ScriptRequest) -> Value {
-        json!({"ran": r.code})
-    }
-
-    /// A session whose settings store is a fresh `<root>/settings/` (with both Scripts folders, as
-    /// after installing a script and a panel), next to a script `<root>/outside.jsx`.
-    fn session_in_tmp(name: &str) -> (Session, PathBuf) {
-        use std::sync::atomic::{AtomicU32, Ordering};
-        static N: AtomicU32 = AtomicU32::new(0);
-        let root = std::env::temp_dir().join(format!("ec-scripts-{}-{}-{name}", std::process::id(), N.fetch_add(1, Ordering::Relaxed)));
-        let _ = std::fs::remove_dir_all(&root);
-        std::fs::create_dir_all(root.join("settings").join(PANELS_DIR)).unwrap();
-        std::fs::write(root.join("outside.jsx"), "outside").unwrap();
-        let s = Session { config: Some(Arc::new(DirConfig::new(root.join("settings")))), script: Some(echo), ..Default::default() };
-        (s, root)
-    }
-
-    fn bad_params(r: &Result<Value>) -> bool {
-        matches!(r, Err(EngineError::BadParams { .. }))
-    }
-
-    /// Paths, refused on every platform.
-    const PATHS: [&str; 10] = ["", ".", "..", "../x.jsx", "a/b.jsx", "/abs/x.jsx", "a\\b.jsx", "..\\x.jsx", "C:\\x.jsx", "a\0.jsx"];
-    /// Ordinary file names except on Windows.
-    const WINDOWS_ONLY: [&str; 8] = ["Step 1: Setup.jsx", "In:Out.jsx", "C:x.jsx", "x.jsx.", "x.jsx ", "Aux.Tools.jsx", "con.jsx", "COM1.jsx"];
-
-    #[test]
-    fn bare_names_are_one_path_component() {
-        for name in ["Rename Layers.jsx", "..jsx", "a..b.js", "Äpfel ✓.jsx"].into_iter().chain(WINDOWS_ONLY) {
-            assert!(is_bare_name(name), "{name:?}");
-        }
-        for name in PATHS {
-            assert!(!is_bare_name(name), "{name:?}");
-        }
-    }
-
-    #[test]
-    fn windows_unsafe_names_are_drives_streams_trailing_dots_and_devices() {
-        let devices = ["CON", "Con.tar.jsx", "CON .jsx", "PRN.js", "aux.jsx", "NUL.jsx", "CONIN$.jsx", "conout$.js"];
-        let ports = ["COM0.jsx", "com9.js", "LPT0.jsx", "lpt9.jsx", "COM¹.jsx", "LPT³.js"];
-        for name in WINDOWS_ONLY.into_iter().chain(devices).chain(ports) {
-            assert!(windows_unsafe_name(name), "{name:?}");
-        }
-        let fine = ["console.jsx", "Concert.jsx", "NULL.jsx", "CONIN.jsx", "COM10.jsx", "LPT.jsx", "x .jsx", "..jsx"];
-        for name in BUNDLED.iter().map(|b| b.0).chain(fine) {
-            assert!(!windows_unsafe_name(name), "{name:?}");
-        }
-    }
-
-    #[test]
-    fn script_names_are_bare_file_names() {
-        let more = ["..jsx", "a..b.js", "Äpfel ✓.jsx", "console.jsx", "Concert.jsx", "NULL.jsx", "COM10.jsx", "LPT.jsx"];
-        for name in BUNDLED.iter().map(|b| b.0).chain(more) {
-            assert!(is_script(name) && is_script_name(name), "{name}");
-        }
-        for name in PATHS {
-            assert!(!is_script_name(name), "{name:?}");
-        }
-        for name in WINDOWS_ONLY {
-            assert_eq!(is_script_name(name), !cfg!(windows), "{name:?}");
-        }
-        // Install refuses a file name the script could not then be run or uninstalled by.
-        #[cfg(unix)]
-        {
-            let (mut s, root) = session_in_tmp("odd-name");
-            let odd = root.join("a\\b.jsx");
-            std::fs::write(&odd, "x").unwrap();
-            assert!(bad_params(&s.execute("file.installScript", json!({"path": odd.to_string_lossy()}))));
-            assert!(!root.join("settings").join(SCRIPTS_DIR).join("a\\b.jsx").exists());
-            let _ = std::fs::remove_dir_all(&root);
-        }
-    }
-
-    #[test]
-    fn uninstall_takes_a_script_name_not_a_path() {
-        let (mut s, root) = session_in_tmp("uninstall");
-        let (outside, prefs) = (root.join("outside.jsx"), root.join("settings").join("prefs.json"));
-        std::fs::write(&prefs, "{}").unwrap();
-        // From `Scripts/`, `../../outside.jsx` is the script next to the settings folder and
-        // `../prefs.json` a settings file; an absolute path is not a script name either.
-        for name in ["../../outside.jsx".to_string(), "../prefs.json".into(), outside.to_string_lossy().into_owned()] {
-            let r = s.execute("file.uninstallScript", json!({"name": name}));
-            assert!(outside.is_file() && prefs.is_file(), "`{name}` deleted a file outside the Scripts folders: {r:?}");
-            assert!(bad_params(&r), "`{name}`: {r:?}");
-        }
-        let _ = std::fs::remove_dir_all(&root);
-    }
-
-    #[test]
-    fn scripts_run_by_name_come_from_the_scripts_folders() {
-        let (mut s, root) = session_in_tmp("run");
-        // `Scripts/../../outside.jsx` and `Scripts/ScriptUI Panels/../../../outside.jsx` are the
-        // script next to the settings folder.
-        let r = s.execute("file.runScript", json!({"name": "../../outside.jsx"}));
-        assert!(bad_params(&r), "{r:?}");
-        let r = s.execute("window.scriptPanel", json!({"name": "../../../outside.jsx"}));
-        assert!(bad_params(&r), "{r:?}");
-        assert_eq!(script_code(&s, "../../outside.jsx", None), None);
-        assert_eq!(script_code(&s, "../../../outside.jsx", Some(true)), None);
-        let _ = std::fs::remove_dir_all(&root);
-    }
-
-    #[test]
-    fn only_scripts_are_read_or_removed() {
-        // A settings file in the Scripts folder that is not a script (.jsx / .js).
-        let (mut s, root) = session_in_tmp("not-a-script");
-        let notes = root.join("settings").join(SCRIPTS_DIR).join("notes.txt");
-        std::fs::write(&notes, "notes").unwrap();
-        assert_eq!(script_code(&s, "notes.txt", None), None);
-        let r = s.execute("file.uninstallScript", json!({"name": "notes.txt"}));
-        assert!(notes.is_file() && bad_params(&r), "{r:?}");
-        let _ = std::fs::remove_dir_all(&root);
-    }
-
-    /// On Unix `\` is a file-name character: a script dropped into the folder under such a name is
-    /// not offered, as it could not be run or uninstalled. Names only Windows refuses stay.
-    #[cfg(unix)]
-    #[test]
-    fn listing_skips_names_run_and_uninstall_refuse() {
-        let (mut s, root) = session_in_tmp("odd-names");
-        let scripts = root.join("settings").join(SCRIPTS_DIR);
-        std::fs::write(scripts.join("a\\b.jsx"), "x").unwrap();
-        std::fs::write(scripts.join("In:Out.jsx"), "in-out").unwrap();
-        let list = s.execute("file.scripts.list", json!({})).unwrap();
-        let listed = |n: &str| list.as_array().unwrap().iter().any(|e| e["name"] == n);
-        assert!(!listed("a\\b.jsx") && listed("In:Out.jsx"), "{list}");
-        assert_eq!(script_code(&s, "a\\b.jsx", None), None);
-        assert_eq!(script_code(&s, "In:Out.jsx", None), Some((false, "in-out".to_string())));
-        let _ = std::fs::remove_dir_all(&root);
-    }
-
-    #[test]
-    fn install_run_and_uninstall_by_name() {
-        let (mut s, root) = session_in_tmp("install");
-        let file = root.join("Hello.jsx");
-        std::fs::write(&file, "hello").unwrap();
-        s.execute("file.installScript", json!({"path": file.to_string_lossy()})).unwrap();
-        s.execute("file.installScriptUIPanel", json!({"path": file.to_string_lossy()})).unwrap();
-        let installed = [root.join("settings").join(SCRIPTS_DIR).join("Hello.jsx"), root.join("settings").join(PANELS_DIR).join("Hello.jsx")];
-        assert!(installed.iter().all(|p| p.is_file()));
-        assert_eq!(s.execute("file.runScript", json!({"name": "Hello.jsx"})).unwrap()["ran"], "hello");
-        let r = s.execute("window.scriptPanel", json!({"name": "Hello.jsx"})).unwrap();
-        assert!(r["result"]["ran"].as_str().is_some_and(|c| c.contains("hello")), "{r}");
-        // The bundled samples still run by name.
-        let sample = BUNDLED.iter().find(|b| b.0 == "Rename Layers.jsx").unwrap().3;
-        assert_eq!(s.execute("file.runScript", json!({"name": "Rename Layers.jsx"})).unwrap()["ran"], sample);
-        s.execute("file.uninstallScript", json!({"name": "Hello.jsx"})).unwrap();
-        assert!(installed.iter().all(|p| !p.exists()));
-        assert!(bad_params(&s.execute("file.uninstallScript", json!({"name": "Hello.jsx"}))), "no longer installed");
-        let _ = std::fs::remove_dir_all(&root);
-    }
-}
diff --git a/crates/engine/src/doc_state.rs b/crates/engine/src/doc_state.rs
new file mode 100644
index 000000000..7b4889dba
--- /dev/null
+++ b/crates/engine/src/doc_state.rs
@@ -0,0 +1,204 @@
+use super::{Deserialize, ItemId, Layer, LayerId, Serialize, Tick, Uid, commands, mask_track, media_browser, roto, viewer};
+
+/// A keyframe reference: layer, property uid, key time (layer time).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct KeyRef {
+    pub layer: LayerId,
+    pub prop: Uid,
+    pub time: Tick,
+}
+
+/// A keyframe drag in progress (`keys.move` steps sharing a merge key): the selection it
+/// started from and the total offset so far, so every step is applied to the keys as they were
+/// before the drag. A key passed over on the way is never overwritten; only the drop position
+/// counts, as in After Effects.
+#[derive(Clone, Debug)]
+pub struct KeyMove {
+    pub merge: String,
+    pub from: Vec<KeyRef>,
+    pub total: Tick,
+}
+
+/// Keyframes of one property on the keyframe clipboard.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct KeyClip {
+    pub layer: LayerId,
+    /// Match-id path relative to the layer (`transform/position`), portable between layers.
+    pub path: String,
+    /// Keys with times relative to the earliest copied key (layer time).
+    pub keys: Vec<effectcraft_keyframe::Keyframe>,
+}
+
+/// A selected mask vertex: layer, mask group uid, vertex index.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct VertexRef {
+    pub layer: LayerId,
+    pub mask: Uid,
+    pub index: usize,
+}
+
+/// One composition's selection. The active comp's copy lives in [`EditorState::selected_layers`]
+/// (and the property, key, and vertex lists); every other comp keeps its own here (#1001).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct CompSelection {
+    pub layers: Vec<LayerId>,
+    pub props: Vec<(LayerId, Uid)>,
+    pub keys: Vec<KeyRef>,
+    pub vertices: Vec<VertexRef>,
+}
+
+impl CompSelection {
+    pub(crate) fn is_empty(&self) -> bool {
+        self.layers.is_empty() && self.props.is_empty() && self.keys.is_empty() && self.vertices.is_empty()
+    }
+}
+
+/// Editing state that commands depend on (headless-relevant, serde for agents).
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct EditorState {
+    pub active_comp: Option<ItemId>,
+    /// Open compositions (viewer/timeline tabs), in tab order.
+    pub open_comps: Vec<ItemId>,
+    /// Compositions that were active before the current one, most recent first (Shift+Esc).
+    #[serde(default)]
+    pub recent_comps: Vec<ItemId>,
+    /// Current time per comp (the CTI).
+    pub times: std::collections::BTreeMap<ItemId, Tick>,
+    /// Layer selection of the active comp. Other comps' selections are in [`Self::comp_selections`].
+    pub selected_layers: Vec<LayerId>,
+    /// Selections of comps that are not active, keyed by comp id (#1001).
+    #[serde(default)]
+    pub comp_selections: std::collections::BTreeMap<ItemId, CompSelection>,
+    /// Selected properties / groups (by uid) of selected layers.
+    pub selected_props: Vec<(LayerId, Uid)>,
+    pub selected_keys: Vec<KeyRef>,
+    pub project_selection: Vec<ItemId>,
+    /// Layer clipboard (serialized layers) and keyframe clipboard.
+    #[serde(skip)]
+    pub clipboard: Vec<Layer>,
+    /// Copied keyframes (times relative to the earliest copied key).
+    #[serde(skip)]
+    pub key_clipboard: Vec<KeyClip>,
+    /// The last copy was keyframes (Paste pastes keys at the CTI).
+    #[serde(skip)]
+    pub clip_is_keys: bool,
+    /// Values of selected unanimated properties (match path, value), copied with Edit ▸ Copy;
+    /// Paste sets the same properties of the selected layers.
+    #[serde(skip)]
+    pub value_clipboard: Vec<(String, effectcraft_keyframe::Value)>,
+    /// The copied keyframes and values as After Effects keyframe text (one layer's Transform
+    /// properties), for the system clipboard.
+    #[serde(skip)]
+    pub keyframe_text: Option<String>,
+    /// Copied effect instances, with comp-time key offsets from the earliest copied key.
+    /// Paste adds them to the selected layers at the destination comp's CTI.
+    #[serde(skip)]
+    pub effect_clipboard: Vec<effectcraft_project::PropGroup>,
+    /// Copied shape items (Edit ▸ Copy with groups, paths, paints or path operations selected in
+    /// a shape layer's Contents); Paste adds them to the selected shape layers.
+    #[serde(skip)]
+    pub contents_clipboard: Vec<effectcraft_project::PropGroup>,
+    /// Copied masks (Edit ▸ Copy with masks selected); Paste adds them to the selected layers.
+    #[serde(skip)]
+    pub mask_clipboard: Vec<effectcraft_project::PropGroup>,
+    /// Selected mask vertices (viewer Selection tool / pen).
+    #[serde(default)]
+    pub selected_vertices: Vec<VertexRef>,
+    pub snapping: bool,
+    /// Tools bar ▸ Snapping options (which features snap, Snap Edges Extended).
+    #[serde(default)]
+    pub snap_features: viewer::SnapFeatures,
+    /// Last applied effect id (Effect ▸ last effect).
+    pub last_effect: Option<String>,
+    /// Viewer region of interest `[x, y, w, h]` in comp pixels (Composition ▸ Crop Comp to Region
+    /// of Interest).
+    #[serde(default)]
+    pub region_of_interest: Option<[f64; 4]>,
+    /// Property-link clipboard (Edit ▸ Copy with Property Links / Copy Expression Only).
+    #[serde(skip)]
+    pub link_clipboard: Option<LinkClip>,
+    /// File ▸ Interpret Footage ▸ Remember Interpretation.
+    #[serde(skip)]
+    pub interpretation: Option<effectcraft_project::Footage>,
+    /// Viewer 3D view per comp (Active Camera / Front / … / Custom View 3 and edited view cameras).
+    #[serde(default)]
+    pub views3d: std::collections::BTreeMap<ItemId, effectcraft_render::three_d::Views3D>,
+    /// Tracker panel ▸ Current Track: (tracked layer, tracker group uid) in the active comp.
+    #[serde(default)]
+    pub current_track: Option<(LayerId, Uid)>,
+    /// Tracker panel ▸ Method in mask mode (Track Mask).
+    #[serde(default)]
+    pub mask_track_method: mask_track::MaskMethod,
+    /// 3D Camera Tracker: the selected track points (ids) in the viewer.
+    #[serde(default)]
+    pub camera_points: Vec<u32>,
+    /// Mask Interpolation panel options.
+    #[serde(default)]
+    pub mask_interp: commands::mask_interp::MaskInterpOptions,
+    /// Paint and Brushes panel options (Brush, Clone Stamp and Eraser tools).
+    #[serde(default)]
+    pub paint: commands::paint::PaintOptions,
+    /// Roto Brush and Refine Edge tool options.
+    #[serde(default)]
+    pub roto: roto::RotoOptions,
+    /// Puppet tool options for new meshes.
+    #[serde(default)]
+    pub puppet: commands::puppet::PuppetOptions,
+    /// The shape tools' and the Pen's options (Tool Creates Shape / Mask, Fill and Stroke).
+    #[serde(default)]
+    pub shape_tool: commands::shape_tool::ShapeTool,
+    /// View ▸ Switch View Layout: 1, 2 or 4 views side by side in the Composition viewer.
+    #[serde(default = "one_view")]
+    pub view_layout: u8,
+    /// View ▸ Switch View Layout ▸ Share View Options (grid, guides… in every view).
+    #[serde(default)]
+    pub share_view_options: bool,
+    /// Layer ▸ Mask ▸ Hide Locked Masks (viewer outlines).
+    #[serde(default)]
+    pub hide_locked_masks: bool,
+    /// On-canvas text editing (Type tool): the edited layer, selection and insertion style.
+    #[serde(default)]
+    pub text_edit: Option<commands::text_edit::TextEdit>,
+    /// Text copied while editing (with its formatting), for Paste / Paste Text Formatting Only.
+    #[serde(skip)]
+    pub text_clipboard: Option<effectcraft_keyframe::TextDoc>,
+    /// Composition viewer display options (Show Channel, exposure, snapshot, Fast Previews).
+    #[serde(default)]
+    pub viewer: commands::viewer_cmds::ViewOptions,
+    /// Essential Graphics panel ▸ Primary composition (`None` = the active comp).
+    #[serde(default)]
+    pub essential_primary: Option<ItemId>,
+    /// Essential Graphics panel ▸ Solo Supported Properties (the timeline shows only properties
+    /// Essential Graphics can expose).
+    #[serde(default)]
+    pub essential_solo: bool,
+    /// File ▸ Watch Folder: the folder being watched for projects to render (frontends call
+    /// `file.watchFolder.poll` periodically while it is set).
+    #[serde(default)]
+    pub watch_folder: Option<String>,
+    /// The Footage panel: the footage shown, its time and In/Out marks (source time).
+    #[serde(default)]
+    pub footage_panel: Option<commands::footage_panel::FootageView>,
+    /// Media Browser: the folder shown and the favourites.
+    #[serde(default)]
+    pub media_browser: media_browser::BrowserState,
+    /// Content-Aware Fill panel settings.
+    #[serde(default)]
+    pub content_fill: commands::content_fill::FillSettings,
+    /// View ▸ Split with New Locked Viewer: the second viewer's comp and 3D view.
+    #[serde(default)]
+    pub locked_viewer: Option<commands::viewer_cmds::LockedViewer>,
+}
+
+fn one_view() -> u8 {
+    1
+}
+
+/// What Copy with Property Links / Copy Expression Only put on the clipboard.
+#[derive(Clone, Debug, PartialEq)]
+pub enum LinkClip {
+    /// Expressions that link back to the source properties: (match path, expression text).
+    Links { relative: bool, links: Vec<(String, String)> },
+    /// Expressions only: (match path, expression).
+    Expressions(Vec<(String, effectcraft_project::Expression)>),
+}
diff --git a/crates/engine/src/error.rs b/crates/engine/src/error.rs
new file mode 100644
index 000000000..75e9e4467
--- /dev/null
+++ b/crates/engine/src/error.rs
@@ -0,0 +1,20 @@
+#[derive(Debug, thiserror::Error)]
+pub enum EngineError {
+    #[error("unknown command `{0}`")]
+    UnknownCommand(String),
+    #[error("command `{0}` is not available right now: {1}")]
+    Disabled(String, String),
+    #[error("invalid parameters for `{cmd}`: {msg}")]
+    BadParams { cmd: String, msg: String },
+    #[error("no active composition")]
+    NoComp,
+    /// A `comp` reference (name or id) that names no composition.
+    #[error("no composition {0}")]
+    NoSuchComp(String),
+    #[error("{0}")]
+    Project(#[from] effectcraft_project::ProjectError),
+    #[error("{0}")]
+    Other(String),
+}
+
+pub type Result<T> = std::result::Result<T, EngineError>;
diff --git a/crates/engine/src/event.rs b/crates/engine/src/event.rs
new file mode 100644
index 000000000..e1f5e0535
--- /dev/null
+++ b/crates/engine/src/event.rs
@@ -0,0 +1,32 @@
+use super::{ItemId, Serialize, Value};
+
+/// Events for frontends (drained each frame).
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub enum Event {
+    ProjectChanged {
+        revision: u64,
+    },
+    Toast {
+        message: String,
+        error: bool,
+    },
+    OpenComp(ItemId),
+    OpenUrl(String),
+    /// A frontend-only command (viewer zoom, panels, dialogs…) ran: the UI performs it. Headless
+    /// sessions ignore these.
+    Frontend {
+        command: String,
+        params: Value,
+    },
+    /// Drop cached frames / renders (Edit ▸ Purge).
+    PurgeCaches,
+    /// Put an image on the system clipboard (Composition ▸ Copy Frame to Clipboard): `rgba` is
+    /// `width` × `height` straight-alpha RGBA8 rows. Headless sessions ignore it; the pixels are
+    /// not serialized.
+    CopyImage {
+        width: u32,
+        height: u32,
+        #[serde(skip)]
+        rgba: Vec<u8>,
+    },
+}
diff --git a/crates/engine/src/fonts.rs b/crates/engine/src/fonts.rs
new file mode 100644
index 000000000..6b06d6f5b
--- /dev/null
+++ b/crates/engine/src/fonts.rs
@@ -0,0 +1,92 @@
+use super::prefs;
+
+pub fn text_families() -> Vec<String> {
+    effectcraft_text::families().into_iter().map(|(f, _)| f).collect()
+}
+
+/// The styles a family offers (its own faces, in weight order), for the style menus. A family
+/// that isn't installed offers the usual styles, which resolve to Inter's.
+pub fn font_styles(family: &str) -> Vec<String> {
+    effectcraft_text::families()
+        .into_iter()
+        .find(|(f, _)| f.eq_ignore_ascii_case(family))
+        .map(|(_, st)| st)
+        .filter(|st| !st.is_empty())
+        .unwrap_or_else(|| ["Regular", "Medium", "SemiBold", "Bold", "Italic"].iter().map(|s| s.to_string()).collect())
+}
+
+/// The OpenType feature tags (GSUB / GPOS) of the face a family + style resolves to.
+pub fn font_features(family: &str, style: &str) -> Vec<String> {
+    effectcraft_text::fonts::face(effectcraft_text::resolve(family, style).face).features()
+}
+
+/// One row of the Character panel's font menu.
+#[derive(Clone, Debug, PartialEq)]
+pub struct FontRow {
+    /// The family to apply (empty for the separator after the recent fonts).
+    pub family: String,
+    /// What the menu shows: the English family name, or the font's own-language name when
+    /// Settings ▸ Type ▸ Show Font Names in English is off.
+    pub display: String,
+    pub recent: bool,
+    /// A variable font (the menu's Variable Fonts filter keeps only these).
+    pub variable: bool,
+}
+
+/// Outline polylines of "Sample" set in `family` at `size` px (baseline at y = 0, y down), for
+/// the font menu's preview (Settings ▸ Type ▸ Show Font Preview).
+pub fn font_preview(family: &str, size: f64) -> Vec<Vec<[f32; 2]>> {
+    use kurbo::PathEl;
+    let st = effectcraft_keyframe::text_doc::CharStyle { font: family.to_string(), size, ..Default::default() };
+    let mut out = vec![];
+    let mut x = 0.0;
+    for ch in "Sample".chars() {
+        let (path, adv) = effectcraft_text::char_glyph_style(&st, ch);
+        let mut cur: Vec<[f32; 2]> = vec![];
+        let pt = |p: kurbo::Point| [(p.x + x) as f32, p.y as f32];
+        kurbo::flatten(&path, 0.2, |el| match el {
+            PathEl::MoveTo(p) => {
+                if cur.len() > 1 {
+                    out.push(std::mem::take(&mut cur));
+                }
+                cur = vec![pt(p)];
+            }
+            PathEl::LineTo(p) => cur.push(pt(p)),
+            PathEl::ClosePath => {
+                if let Some(f) = cur.first().copied() {
+                    cur.push(f);
+                }
+                if cur.len() > 1 {
+                    out.push(std::mem::take(&mut cur));
+                }
+            }
+            _ => {}
+        });
+        if cur.len() > 1 {
+            out.push(cur);
+        }
+        x += adv;
+    }
+    out
+}
+
+/// The Character panel's font menu: the recent fonts (Settings ▸ Type ▸ Number of Recent Fonts
+/// to Display), a separator, then every family. Each row says whether the family is variable,
+/// for the menu's Variable Fonts filter.
+pub fn font_menu(prefs: &prefs::Prefs) -> Vec<FontRow> {
+    let all = text_families();
+    let native = if prefs.type_.font_names_in_english { Default::default() } else { effectcraft_text::fonts::native_families() };
+    let variable = effectcraft_text::fonts::variable_families();
+    let row = |f: &String, recent: bool| FontRow {
+        family: f.clone(),
+        display: native.get(f).cloned().unwrap_or_else(|| f.clone()),
+        recent,
+        variable: variable.contains(f),
+    };
+    let mut out: Vec<FontRow> = prefs.recent_fonts_shown().iter().filter(|f| all.contains(f)).map(|f| row(f, true)).collect();
+    if !out.is_empty() {
+        out.push(FontRow { family: String::new(), display: "-".into(), recent: false, variable: false });
+    }
+    out.extend(all.iter().map(|f| row(f, false)));
+    out
+}
diff --git a/crates/engine/src/footage.rs b/crates/engine/src/footage.rs
new file mode 100644
index 000000000..21e67d8be
--- /dev/null
+++ b/crates/engine/src/footage.rs
@@ -0,0 +1,6 @@
+pub mod doc_path;
+pub mod footage_check;
+pub mod footage_reload;
+pub mod media_browser;
+pub mod media_cache;
+pub mod sequence;
diff --git a/crates/engine/src/doc_path.rs b/crates/engine/src/footage/doc_path.rs
similarity index 98%
rename from crates/engine/src/doc_path.rs
rename to crates/engine/src/footage/doc_path.rs
index 00d6c33f1..7161b6177 100644
--- a/crates/engine/src/doc_path.rs
+++ b/crates/engine/src/footage/doc_path.rs
@@ -3,7 +3,7 @@
 //! document's folder, and only local files, or files on the network share the document itself is
 //! on, are followed (see `craft_docpath`).
 //!
-//! Loading a document resolves its footage paths once ([`resolve_footage`]): followed paths are
+//! Loading a document resolves its footage paths once (`resolve_footage`): followed paths are
 //! replaced by the resolved path, and an item with a refused path is marked missing, so the media
 //! layer never reads it. The session then remembers which paths came from which document
 //! ([`StoredPaths`]); the footage check, the changed-on-disk scan, Reload Footage, Relink, Edit
diff --git a/crates/engine/src/doc_path/tests.rs b/crates/engine/src/footage/doc_path/tests.rs
similarity index 100%
rename from crates/engine/src/doc_path/tests.rs
rename to crates/engine/src/footage/doc_path/tests.rs
diff --git a/crates/engine/src/footage_check.rs b/crates/engine/src/footage/footage_check.rs
similarity index 100%
rename from crates/engine/src/footage_check.rs
rename to crates/engine/src/footage/footage_check.rs
diff --git a/crates/engine/src/footage/footage_reload.rs b/crates/engine/src/footage/footage_reload.rs
new file mode 100644
index 000000000..16d7c1d5d
--- /dev/null
+++ b/crates/engine/src/footage/footage_reload.rs
@@ -0,0 +1,523 @@
+//! Footage that changed on disk: File ▸ Reload Footage (Cmd+Alt+L) and Settings ▸ Import ▸
+//! Reload Footage Changed on Disk.
+//!
+//! Reloading re-reads what the file decides (its size, a movie's duration, streams and frame
+//! rate, the codec, a data file's text) and keeps what the project decided: the Photoshop layer
+//! or PDF page an item shows and its interpretation (alpha, conformed frame rate, pixel aspect,
+//! fields, colour). A Photoshop layer is found again by name when layers were added or removed
+//! around it. The media layer then forgets the file and the layer cache is emptied, so the next
+//! render reads the new pixels.
+//!
+//! The automatic part compares each footage file's size and modification time with what they
+//! were when the file was last seen. The desktop app keeps a [`Watcher`]: a worker thread that
+//! stamps the files every two seconds while the window is in front (every ten seconds while it
+//! is not, and at once when it comes back to the front) and wakes the interface only when a stamp
+//! changed, so a file on a slow network share never holds up the interface and an idle app never
+//! redraws for footage that didn't change; `footage.reloadChanged` takes the stamps on the spot
+//! (CLI, agents, tests). Like the footage check after File ▸ Open, an automatic reload records
+//! the state of the disk: it is not an undo step and doesn't modify the project.
+
+use std::collections::BTreeSet;
+use std::sync::mpsc::{Receiver, RecvTimeoutError, Sender};
+use std::sync::{Arc, Mutex, PoisonError};
+use std::time::Duration;
+
+use effectcraft_project::{Footage, FootageKind, ItemId, ItemKind, SourceLayer};
+use serde_json::{Value, json};
+
+use crate::{Services, Session};
+
+/// A file's size and modification time (see [`crate::Services::stamp`]).
+pub type Stamp = (u64, u128);
+
+/// The stamps of a set of files, in path order.
+pub type Stamps = Vec<(String, Option<Stamp>)>;
+
+/// The files footage items read: each item's file and every frame of an image sequence. Image
+/// sequences count only with Automatically Reload Footage set to All Footage (After Effects'
+/// default, Non-Sequence Footage, leaves them alone: thousands of frames on a share add up).
+/// Items with a stored path that is not followed ([`crate::doc_path`]) are not watched.
+pub fn watched(s: &Session) -> BTreeSet<String> {
+    let sequences = s.prefs.import.auto_reload_footage == "all";
+    let mut paths = BTreeSet::new();
+    for it in s.project.items.values() {
+        if let ItemKind::Footage(f) = &it.kind {
+            if (!f.sequence.is_empty() && !sequences) || s.stored_paths.check(f).is_err() {
+                continue;
+            }
+            if !f.path.is_empty() {
+                paths.insert(f.path.clone());
+            }
+            paths.extend(f.sequence.iter().cloned());
+        }
+    }
+    paths
+}
+
+/// Size and position in the stack of Photoshop layer `l` in the file at `path` now: the layer
+/// at its recorded index when the name still matches, else the first layer with its name.
+fn psd_layer(s: &Session, path: &str, l: &SourceLayer) -> Option<(u32, Option<(u32, u32)>)> {
+    let psd = effectcraft_psd::Psd::parse(s.services.read_file(path).ok()?).ok()?;
+    let found = psd.layers.get(l.index as usize).filter(|x| x.name == l.name).or_else(|| psd.layers.iter().find(|x| x.name == l.name))?;
+    let size = (!found.rect.is_empty()).then(|| (found.rect.width(), found.rect.height()));
+    Some((u32::try_from(found.index).ok()?, size))
+}
+
+fn vector_size(s: &Session, f: &Footage) -> Option<(u32, u32)> {
+    let bytes = s.services.read_file(&f.path).ok()?;
+    let doc = crate::vector::vector_doc(&f.path, &bytes, f.layer.as_ref(), f.page)?.ok()?;
+    (!doc.root.children.is_empty()).then(|| doc.pixel_size())
+}
+
+/// Footage `f` as its file is now, given the importer's fresh look at the file (`probed`).
+fn refreshed(s: &Session, f: &Footage, probed: Footage) -> Footage {
+    let mut nf = f.clone();
+    nf.missing = false;
+    // An image sequence picks up frames added to (or removed from) its run; its frame rate and
+    // order are the interpretation's.
+    if f.kind == FootageKind::Sequence {
+        if probed.kind == FootageKind::Sequence {
+            (nf.sequence, nf.width, nf.height) = (probed.sequence, probed.width, probed.height);
+            nf.sync_sequence_duration();
+        }
+        return nf;
+    }
+    nf.codec = probed.codec;
+    nf.has_video = probed.has_video;
+    nf.has_audio = probed.has_audio;
+    // The markers the file carries now (a WAV's cue points), for Update Markers From Source.
+    nf.markers = probed.markers;
+    if matches!(f.kind, FootageKind::Video | FootageKind::Audio) {
+        nf.duration = probed.duration;
+        // Interpret Footage ▸ Conform to frame rate stays; the file's own rate is refreshed.
+        match f.native_rate {
+            Some(_) => nf.native_rate = Some(probed.native_rate.unwrap_or(probed.frame_rate)),
+            None => nf.frame_rate = probed.frame_rate,
+        }
+    }
+    if f.kind == FootageKind::Data {
+        nf.data = probed.data;
+    }
+    let (mut w, mut h) = (probed.width, probed.height);
+    match &f.layer {
+        // A smart object's size is its embedded file's, recorded at import.
+        Some(l) if l.embedded.is_some() => (w, h) = (f.width, f.height),
+        Some(_) if crate::vector::is_vector(f) => (w, h) = vector_size(s, f).unwrap_or((f.width, f.height)),
+        Some(l) => match psd_layer(s, &f.path, l) {
+            Some((index, size)) => {
+                if let Some(nl) = nf.layer.as_mut() {
+                    nl.index = index;
+                }
+                // Retain Layer Sizes: the layer's own bounds; otherwise the document's.
+                if l.layer_size {
+                    (w, h) = size.unwrap_or((f.width, f.height));
+                }
+            }
+            // The layer is gone from the file: keep the item as it was.
+            None => (w, h) = (f.width, f.height),
+        },
+        // A later page of a PDF: the probe measures the first page.
+        None if f.page != 0 => (w, h) = (f.width, f.height),
+        None => {}
+    }
+    (nf.width, nf.height) = (w, h);
+    nf
+}
+
+/// Reload footage items `ids` from their files (File ▸ Reload Footage): an undo step; items
+/// whose file can't be read are marked missing. Returns how many items were reloaded.
+pub fn reload_items(s: &mut Session, ids: &[ItemId]) -> crate::Result<usize> {
+    Ok(reload(s, ids, true)?.0)
+}
+
+/// Reload items `ids`. `undoable` makes it an edit; otherwise it records the disk without
+/// modifying the project, and an item whose file can't be read now (another app is still
+/// writing it) is left as it was. Returns the number reloaded and the files that couldn't be read
+/// (only without `undoable`).
+fn reload(s: &mut Session, ids: &[ItemId], undoable: bool) -> crate::Result<(usize, BTreeSet<String>)> {
+    let Some(importer) = s.importer.clone() else {
+        return Err(crate::EngineError::Other("media import is not available in this build".into()));
+    };
+    let mut updates = vec![];
+    let mut paths = BTreeSet::new();
+    let mut failed = BTreeSet::new();
+    for i in ids {
+        if let Some(ItemKind::Footage(f)) = s.project.item(*i).map(|x| &x.kind) {
+            // A sequence is probed the way it imports by default, so its run is found again; any
+            // other item is its one file, not the run a numbered still sits in (#2074). A path
+            // that is not followed is not read.
+            let probed = s
+                .stored_paths
+                .check(f)
+                .map_err(|(p, why)| crate::doc_path::refusal(&p, why))
+                .and_then(|_| if f.kind == FootageKind::Sequence { s.probe_footage(&f.path) } else { importer.probe(&f.path) });
+            let nf = match probed {
+                Ok(p) => refreshed(s, f, p),
+                Err(_) if undoable => Footage { missing: true, ..f.clone() },
+                Err(_) => {
+                    failed.insert(f.path.clone());
+                    continue;
+                }
+            };
+            paths.insert(f.path.clone());
+            paths.extend(f.sequence.iter().chain(&nf.sequence).cloned());
+            updates.push((*i, nf));
+        }
+    }
+    let n = updates.len();
+    apply_reloads(s, updates, undoable)?;
+    forget(s, &paths);
+    Ok((n, failed))
+}
+
+/// Puts reloaded footage into the project: an undoable edit, or (not undoable) a disk change
+/// that leaves the project's dirty state as it was.
+fn apply_reloads(s: &mut Session, updates: Vec<(ItemId, Footage)>, undoable: bool) -> crate::Result<()> {
+    if undoable {
+        s.edit("Reload Footage", None, |proj, _| {
+            for (i, f) in updates {
+                if let Some(it) = proj.item_mut(i) {
+                    it.kind = ItemKind::Footage(f);
+                }
+            }
+            Ok(())
+        })?;
+    } else {
+        let p = Arc::make_mut(&mut s.project);
+        let mut changed = false;
+        for (i, f) in updates {
+            if let Some(it) = p.item_mut(i)
+                && !matches!(&it.kind, ItemKind::Footage(cur) if *cur == f)
+            {
+                it.kind = ItemKind::Footage(f);
+                changed = true;
+            }
+        }
+        if changed {
+            let dirty = s.is_dirty();
+            s.bump();
+            if !dirty {
+                // Only the disk changed: the project isn't modified.
+                s.mark_saved();
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Make the media layer and the layer cache let go of `paths`, so renders read them again.
+fn forget(s: &mut Session, paths: &BTreeSet<String>) {
+    for p in paths {
+        s.footage.forget(p);
+    }
+    s.layer_cache.clear();
+    // Reloaded files may keep their footage settings but not their size and time.
+    s.refresh_disk_salt(true);
+    s.events.push(crate::Event::PurgeCaches);
+}
+
+/// Compare fresh stamps of the watched files with the ones last seen. A file seen for the first
+/// time is only remembered; one whose stamp moved is reloaded: the items reading it get their
+/// size and duration from it again and its pixels are read again. A file that can't be stamped
+/// right now (an app saving by delete and rename) keeps its last stamp, and one that can't be
+/// read (still being written) is tried again once it changes again; missing files are left to
+/// the footage check. Returns `{files, reloaded}`.
+pub fn apply_stamps(s: &mut Session, now: Vec<(String, Option<Stamp>)>) -> crate::Result<Value> {
+    let before = std::mem::take(&mut s.footage_stamps);
+    let mut changed = BTreeSet::new();
+    // Only what is watched now is remembered (files no longer used are dropped).
+    for (path, stamp) in now {
+        match (before.get(&path), stamp) {
+            (Some(old), None) => {
+                s.footage_stamps.insert(path, *old);
+            }
+            (old, Some(stamp)) => {
+                if old.is_some_and(|o| *o != stamp) {
+                    changed.insert(path.clone());
+                }
+                s.footage_stamps.insert(path, stamp);
+            }
+            (None, None) => {}
+        }
+    }
+    if changed.is_empty() {
+        return Ok(json!({"files": 0, "reloaded": 0}));
+    }
+    let ids: Vec<ItemId> = s.project.items.values().filter(|i| matches!(&i.kind, ItemKind::Footage(f) if changed.contains(&f.path))).map(|i| i.id).collect();
+    let (reloaded, failed) = if ids.is_empty() { (0, BTreeSet::new()) } else { reload(s, &ids, false)? };
+    // Not readable (still being written, or not a file the importer reads): its new stamp is kept,
+    // so it is tried again once it changes again, not on every look.
+    for p in &failed {
+        changed.remove(p);
+    }
+    if changed.is_empty() {
+        return Ok(json!({"files": 0, "reloaded": 0}));
+    }
+    // Changed frames of image sequences (their items keep their metadata).
+    forget(s, &changed);
+    let files = changed.len();
+    s.toast(if reloaded > 0 {
+        format!("Reloaded {reloaded} footage item(s) changed on disk")
+    } else {
+        format!("Reloaded {files} footage file(s) changed on disk")
+    });
+    Ok(json!({"files": files, "reloaded": reloaded}))
+}
+
+/// `footage.reloadChanged`: stamp the watched files now and reload the ones that changed.
+pub(crate) fn command(s: &mut Session, _: &Value) -> crate::Result<Value> {
+    let services = s.services.clone();
+    let now = watched(s).into_iter().map(|p| (p.clone(), services.stamp(&p))).collect();
+    apply_stamps(s, now)
+}
+
+/// How often the watched files are stamped while the window is in front.
+pub const FOCUSED_INTERVAL: Duration = Duration::from_secs(2);
+/// How often they are stamped while another app has the front: a file saved there is noticed
+/// as soon as the window comes back, so this only covers a second screen.
+pub const UNFOCUSED_INTERVAL: Duration = Duration::from_secs(10);
+
+enum Watch {
+    Paths(BTreeSet<String>),
+    Focused(bool),
+}
+
+/// The desktop app's footage watcher: a worker thread that stamps the watched files and hands
+/// the stamps over ([`Watcher::take`]) only when one of them changed since it last looked,
+/// waking the interface through the callback given to [`Watcher::start`]. The interface tells it
+/// what to watch and whether the window is in front; nothing watched means the thread sleeps.
+/// Dropping the watcher ends the thread.
+pub struct Watcher {
+    tx: Sender<Watch>,
+    result: Arc<Mutex<Option<Stamps>>>,
+    paths: BTreeSet<String>,
+    focused: Option<bool>,
+}
+
+impl Watcher {
+    /// Start the worker, stamping through `services`; `wake` runs on the worker whenever new
+    /// stamps are ready to [`Watcher::take`]. `None` where there are no threads (the web app,
+    /// whose footage lives in browser storage) or one couldn't be started.
+    pub fn start(services: Arc<dyn Services>, wake: impl Fn() + Send + Sync + 'static) -> Option<Watcher> {
+        Self::start_with(services, wake, FOCUSED_INTERVAL, UNFOCUSED_INTERVAL)
+    }
+
+    /// [`Watcher::start`] with its own stamping intervals (tests).
+    pub fn start_with(services: Arc<dyn Services>, wake: impl Fn() + Send + Sync + 'static, focused: Duration, unfocused: Duration) -> Option<Watcher> {
+        if cfg!(target_arch = "wasm32") {
+            return None;
+        }
+        let (tx, rx) = std::sync::mpsc::channel();
+        let result: Arc<Mutex<Option<Stamps>>> = Arc::default();
+        let out = Arc::clone(&result);
+        std::thread::Builder::new().name("footage-watch".into()).spawn(move || watch(&rx, &*services, &out, &wake, focused, unfocused)).ok()?;
+        Some(Watcher { tx, result, paths: BTreeSet::new(), focused: None })
+    }
+
+    /// The files to watch ([`watched`]); a changed set is stamped at once.
+    pub fn set_watched(&mut self, paths: BTreeSet<String>) {
+        if paths != self.paths {
+            self.paths = paths.clone();
+            let _ = self.tx.send(Watch::Paths(paths));
+        }
+    }
+
+    /// Whether the window is in front; coming back to the front stamps the files at once.
+    pub fn set_focused(&mut self, focused: bool) {
+        if self.focused != Some(focused) {
+            self.focused = Some(focused);
+            let _ = self.tx.send(Watch::Focused(focused));
+        }
+    }
+
+    /// Stamps the worker found changed (or the first ones for a new set of files), once; for
+    /// [`apply_stamps`]. `None` while nothing changed.
+    pub fn take(&self) -> Option<Stamps> {
+        self.result.lock().unwrap_or_else(PoisonError::into_inner).take()
+    }
+}
+
+/// The watcher's worker: wait for a message or the interval, stamp, report only changes.
+fn watch(
+    rx: &Receiver<Watch>,
+    services: &dyn Services,
+    out: &Mutex<Option<Stamps>>,
+    wake: &(dyn Fn() + Send + Sync),
+    focused_every: Duration,
+    unfocused_every: Duration,
+) {
+    let mut paths = BTreeSet::new();
+    let mut focused = true;
+    let mut last: Option<Stamps> = None;
+    loop {
+        let msg = if paths.is_empty() {
+            rx.recv().map_err(|_| RecvTimeoutError::Disconnected)
+        } else {
+            rx.recv_timeout(if focused { focused_every } else { unfocused_every })
+        };
+        match msg {
+            Ok(Watch::Paths(p)) => {
+                paths = p;
+                // A new set is reported whole, so the session forgets files no longer watched.
+                last = None;
+            }
+            Ok(Watch::Focused(f)) => {
+                let regained = f && !focused;
+                focused = f;
+                if !regained {
+                    continue;
+                }
+            }
+            Err(RecvTimeoutError::Timeout) => {}
+            Err(RecvTimeoutError::Disconnected) => return,
+        }
+        if paths.is_empty() {
+            continue;
+        }
+        let stamps: Stamps = paths.iter().map(|p| (p.clone(), services.stamp(p))).collect();
+        if last.as_ref() != Some(&stamps) {
+            last = Some(stamps.clone());
+            *out.lock().unwrap_or_else(PoisonError::into_inner) = Some(stamps);
+            wake();
+        }
+    }
+}
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod watcher_tests {
+    use std::collections::HashMap;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    use super::*;
+
+    /// Files whose stamps the test sets; counts how often they were stamped.
+    #[derive(Default)]
+    struct Disk {
+        stamps: Mutex<HashMap<String, Stamp>>,
+        looks: AtomicUsize,
+    }
+    impl Disk {
+        fn set(&self, path: &str, stamp: Stamp) {
+            self.stamps.lock().unwrap_or_else(PoisonError::into_inner).insert(path.into(), stamp);
+        }
+    }
+    impl Services for Disk {
+        fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>> {
+            Err(std::io::Error::new(std::io::ErrorKind::NotFound, path.to_string()))
+        }
+        fn write_file(&self, _: &str, _: &[u8]) -> std::io::Result<()> {
+            Err(std::io::Error::other("read-only"))
+        }
+        fn stamp(&self, path: &str) -> Option<Stamp> {
+            self.looks.fetch_add(1, Ordering::SeqCst);
+            self.stamps.lock().unwrap_or_else(PoisonError::into_inner).get(path).copied()
+        }
+    }
+
+    const TICK: Duration = Duration::from_millis(20);
+    const LONG: Duration = Duration::from_secs(60);
+
+    fn wait_for(w: &Watcher, wakes: &AtomicUsize, n: usize) -> Stamps {
+        let t0 = std::time::Instant::now();
+        loop {
+            if wakes.load(Ordering::SeqCst) >= n
+                && let Some(s) = w.take()
+            {
+                return s;
+            }
+            assert!(t0.elapsed() < Duration::from_secs(10), "no report {n} within 10 s");
+            std::thread::sleep(Duration::from_millis(5));
+        }
+    }
+
+    /// Wait (at most 10 s) until `ready`: a slow machine's worker gets there late, never early.
+    fn wait_until(what: &str, mut ready: impl FnMut() -> bool) {
+        let t0 = std::time::Instant::now();
+        while !ready() {
+            assert!(t0.elapsed() < Duration::from_secs(10), "{what} within 10 s");
+            std::thread::sleep(Duration::from_millis(5));
+        }
+    }
+
+    fn start(disk: &Arc<Disk>, focused: Duration, unfocused: Duration) -> Option<(Watcher, Arc<AtomicUsize>)> {
+        let wakes = Arc::new(AtomicUsize::new(0));
+        let counter = Arc::clone(&wakes);
+        let w = Watcher::start_with(
+            Arc::clone(disk) as Arc<dyn Services>,
+            move || {
+                counter.fetch_add(1, Ordering::SeqCst);
+            },
+            focused,
+            unfocused,
+        )?;
+        Some((w, wakes))
+    }
+
+    /// The interface is woken for the first stamps of a set and for every change, and for
+    /// nothing else: an unchanged file polled many times is no wakeup at all.
+    #[test]
+    fn the_watcher_wakes_the_interface_only_when_a_stamp_changes() {
+        let disk = Arc::new(Disk::default());
+        disk.set("/a.psd", (10, 1));
+        let (mut w, wakes) = start(&disk, TICK, LONG).unwrap();
+        w.set_focused(true);
+        w.set_watched(["/a.psd".to_string()].into());
+        assert_eq!(wait_for(&w, &wakes, 1), vec![("/a.psd".to_string(), Some((10, 1)))]);
+        let looked = disk.looks.load(Ordering::SeqCst);
+        wait_until("it keeps stamping while the window is in front", || disk.looks.load(Ordering::SeqCst) > looked + 3);
+        assert_eq!(wakes.load(Ordering::SeqCst), 1, "an unchanged file is no wakeup");
+        assert!(w.take().is_none());
+        disk.set("/a.psd", (12, 2));
+        assert_eq!(wait_for(&w, &wakes, 2), vec![("/a.psd".to_string(), Some((12, 2)))]);
+        assert_eq!(wakes.load(Ordering::SeqCst), 2);
+    }
+
+    /// Behind another app the files are stamped only at the slow interval; the window coming
+    /// back to the front stamps them at once.
+    #[test]
+    fn behind_another_app_the_watcher_rests_until_the_window_is_back() {
+        let disk = Arc::new(Disk::default());
+        disk.set("/b.psd", (1, 1));
+        let (mut w, wakes) = start(&disk, TICK, LONG).unwrap();
+        w.set_focused(false);
+        w.set_watched(["/b.psd".to_string()].into());
+        wait_for(&w, &wakes, 1);
+        let looked = disk.looks.load(Ordering::SeqCst);
+        disk.set("/b.psd", (2, 2));
+        std::thread::sleep(TICK * 15);
+        assert_eq!(disk.looks.load(Ordering::SeqCst), looked, "no stamping at the front interval while behind");
+        assert_eq!(wakes.load(Ordering::SeqCst), 1);
+        w.set_focused(true);
+        assert_eq!(wait_for(&w, &wakes, 2), vec![("/b.psd".to_string(), Some((2, 2)))]);
+    }
+
+    /// Nothing to watch: the worker sleeps, stamping nothing; a new set is stamped at once and
+    /// reported whole, and dropping the watcher ends the worker.
+    #[test]
+    fn nothing_watched_is_nothing_stamped_and_a_new_set_is_reported_whole() {
+        let disk = Arc::new(Disk::default());
+        disk.set("/c.psd", (1, 1));
+        disk.set("/d.psd", (2, 2));
+        let (mut w, wakes) = start(&disk, TICK, TICK).unwrap();
+        w.set_focused(true);
+        std::thread::sleep(TICK * 10);
+        assert_eq!(disk.looks.load(Ordering::SeqCst), 0);
+        w.set_watched(["/c.psd".to_string(), "/d.psd".to_string()].into());
+        assert_eq!(wait_for(&w, &wakes, 1), vec![("/c.psd".to_string(), Some((1, 1))), ("/d.psd".to_string(), Some((2, 2)))]);
+        w.set_watched(["/d.psd".to_string()].into());
+        assert_eq!(wait_for(&w, &wakes, 2), vec![("/d.psd".to_string(), Some((2, 2)))], "the set is reported whole, so the session forgets /c.psd");
+        w.set_watched(BTreeSet::new());
+        // The worker may already be past its wait with the old set: that one round of stamps
+        // (one file) can still come, and nothing after it.
+        let looked = disk.looks.load(Ordering::SeqCst);
+        std::thread::sleep(TICK * 10);
+        assert!(disk.looks.load(Ordering::SeqCst) <= looked + 1, "nothing watched, nothing stamped");
+        let result = Arc::downgrade(&w.result);
+        drop(w);
+        let t0 = std::time::Instant::now();
+        while result.upgrade().is_some() {
+            assert!(t0.elapsed() < Duration::from_secs(5), "the worker is still running");
+            std::thread::sleep(Duration::from_millis(5));
+        }
+    }
+}
diff --git a/crates/engine/src/media_browser.rs b/crates/engine/src/footage/media_browser.rs
similarity index 97%
rename from crates/engine/src/media_browser.rs
rename to crates/engine/src/footage/media_browser.rs
index c0e20be71..2c40fcf20 100644
--- a/crates/engine/src/media_browser.rs
+++ b/crates/engine/src/footage/media_browser.rs
@@ -197,7 +197,6 @@ fn sort_entries(entries: &mut [Entry]) {
     entries.sort_by_cached_key(|e| (!e.is_dir, e.name.to_lowercase()));
 }
 
-const VIDEO: &[&str] = &["mp4", "m4v", "mov", "webm", "mkv", "avi", "mxf", "gif"];
 const IMAGE: &[&str] = &["png", "jpg", "jpeg", "tif", "tiff", "exr", "bmp", "webp", "psd", "psb", "svg", "tga", "dpx", "cin", "hdr"];
 const AUDIO: &[&str] = &["wav", "aif", "aiff", "mp3", "m4a", "aac", "flac", "ogg", "opus"];
 const DATA: &[&str] = &["json", "csv", "tsv", "mgjson"];
@@ -207,7 +206,8 @@ const MODEL: &[&str] = &["gltf", "glb", "obj", "stl", "fbx"];
 pub fn kind_of(path: &str) -> Option<&'static str> {
     let ext = std::path::Path::new(path).extension()?.to_str()?.to_ascii_lowercase();
     let e = ext.as_str();
-    if VIDEO.contains(&e) {
+    // (An animated GIF plays as a movie.)
+    if e == "gif" || effectcraft_project::VIDEO_EXTENSIONS.contains(&e) {
         Some("video")
     } else if IMAGE.contains(&e) {
         Some("image")
@@ -431,6 +431,15 @@ mod tests {
         std::fs::remove_dir_all(&dir).unwrap();
     }
 
+    /// Every movie type the importer reads lists as video, as an animated GIF does.
+    #[test]
+    fn movies_list_as_video() {
+        for ext in effectcraft_project::VIDEO_EXTENSIONS.iter().chain(&["gif"]) {
+            assert_eq!(kind_of(&format!("/clips/A.{}", ext.to_uppercase())), Some("video"), "{ext}");
+        }
+        assert_eq!(kind_of("/clips/capture.avi"), Some("video"));
+    }
+
     #[test]
     fn virtual_tree_lists_like_a_folder() {
         let mut t = VirtualTree::default();
diff --git a/crates/engine/src/media_cache.rs b/crates/engine/src/footage/media_cache.rs
similarity index 100%
rename from crates/engine/src/media_cache.rs
rename to crates/engine/src/footage/media_cache.rs
diff --git a/crates/engine/src/sequence.rs b/crates/engine/src/footage/sequence.rs
similarity index 97%
rename from crates/engine/src/sequence.rs
rename to crates/engine/src/footage/sequence.rs
index c98aba1d3..fc2dab2b0 100644
--- a/crates/engine/src/sequence.rs
+++ b/crates/engine/src/footage/sequence.rs
@@ -20,7 +20,7 @@ use crate::{Importer, Services};
 /// How an import treats numbered stills.
 #[derive(Clone, Copy, Debug)]
 pub struct SequenceOptions {
-    /// The "<format> Sequence" checkbox: picked numbered stills of one run import as a sequence.
+    /// The `"<format> Sequence"` checkbox: picked numbered stills of one run import as a sequence.
     pub sequence: bool,
     /// The numbered stills inside a picked or dropped folder import as sequences.
     pub folders: bool,
@@ -44,15 +44,14 @@ impl SequenceOptions {
 
     /// `file.import`'s options. Dropped files (`drag: true`) import as stills, as in After
     /// Effects, while a folder's numbered stills import as sequences unless `sequence: false`
-    /// (Alt-drag of a folder). The Import dialog passes its "<format> Sequence" checkbox (off
-    /// unless ticked) as `sequence`. Without `sequence` or `drag` (scripts, agents) a numbered
-    /// still brings its run, as it always has.
+    /// (Alt-drag of a folder). The Import dialog passes its `"<format> Sequence"` checkbox (off
+    /// unless ticked) as `sequence`. Without `sequence` (scripts, agents) a numbered still imports
+    /// as itself, as `ImportOptions.sequence` defaults to false in After Effects (#2018).
     pub fn for_import(p: &serde_json::Value) -> SequenceOptions {
         let flag = |k: &str| p.get(k).and_then(serde_json::Value::as_bool);
         let (sequence, alphabetical) = (flag("sequence"), flag("alphabetical").unwrap_or(false));
-        let dropped = flag("drag").unwrap_or(false);
         // Force Alphabetical Order is part of the Sequence option.
-        SequenceOptions { sequence: sequence.unwrap_or(alphabetical || !dropped), folders: sequence.unwrap_or(true), alphabetical }
+        SequenceOptions { sequence: sequence.unwrap_or(alphabetical), folders: sequence.unwrap_or(true), alphabetical }
     }
 }
 
diff --git a/crates/engine/src/footage_reload.rs b/crates/engine/src/footage_reload.rs
deleted file mode 100644
index 9b3c135a8..000000000
--- a/crates/engine/src/footage_reload.rs
+++ /dev/null
@@ -1,288 +0,0 @@
-//! Footage that changed on disk: File ▸ Reload Footage (Cmd+Alt+L) and Settings ▸ Import ▸
-//! Reload Footage Changed on Disk.
-//!
-//! Reloading re-reads what the file decides (its size, a movie's duration, streams and frame
-//! rate, the codec, a data file's text) and keeps what the project decided: the Photoshop layer
-//! or PDF page an item shows and its interpretation (alpha, conformed frame rate, pixel aspect,
-//! fields, colour). A Photoshop layer is found again by name when layers were added or removed
-//! around it. The media layer then forgets the file and the layer cache is emptied, so the next
-//! render reads the new pixels.
-//!
-//! The automatic part compares each footage file's size and modification time with what they
-//! were when the file was last seen. The desktop app takes those stamps every two seconds (and
-//! when its window comes back to the front) on a worker thread, so a file on a slow network share
-//! never holds up the interface ([`start_scan`], [`poll_scan`]); `footage.reloadChanged` takes them
-//! on the spot (CLI, agents, tests). Like the footage check after File ▸ Open, an automatic reload
-//! records the state of the disk: it is not an undo step and doesn't modify the project.
-
-use std::collections::BTreeSet;
-use std::sync::{Arc, Mutex};
-
-use effectcraft_project::{Footage, FootageKind, ItemId, ItemKind, SourceLayer};
-use serde_json::{Value, json};
-
-use crate::Session;
-
-/// A file's size and modification time (see [`crate::Services::stamp`]).
-pub type Stamp = (u64, u128);
-
-/// Stamps taken on a worker thread, waiting for [`poll_scan`].
-pub type Scan = Arc<Mutex<Option<Vec<(String, Option<Stamp>)>>>>;
-
-/// The files footage items read: each item's file and every frame of an image sequence. Image
-/// sequences count only with Automatically Reload Footage set to All Footage (After Effects'
-/// default, Non-Sequence Footage, leaves them alone: thousands of frames on a share add up).
-/// Items with a stored path that is not followed ([`crate::doc_path`]) are not watched.
-fn watched(s: &Session) -> BTreeSet<String> {
-    let sequences = s.prefs.import.auto_reload_footage == "all";
-    let mut paths = BTreeSet::new();
-    for it in s.project.items.values() {
-        if let ItemKind::Footage(f) = &it.kind {
-            if (!f.sequence.is_empty() && !sequences) || s.stored_paths.check(f).is_err() {
-                continue;
-            }
-            if !f.path.is_empty() {
-                paths.insert(f.path.clone());
-            }
-            paths.extend(f.sequence.iter().cloned());
-        }
-    }
-    paths
-}
-
-/// Size and position in the stack of Photoshop layer `l` in the file at `path` now: the layer
-/// at its recorded index when the name still matches, else the first layer with its name.
-fn psd_layer(s: &Session, path: &str, l: &SourceLayer) -> Option<(u32, Option<(u32, u32)>)> {
-    let psd = effectcraft_psd::Psd::parse(s.services.read_file(path).ok()?).ok()?;
-    let found = psd.layers.get(l.index as usize).filter(|x| x.name == l.name).or_else(|| psd.layers.iter().find(|x| x.name == l.name))?;
-    let size = (!found.rect.is_empty()).then(|| (found.rect.width(), found.rect.height()));
-    Some((u32::try_from(found.index).ok()?, size))
-}
-
-fn vector_size(s: &Session, f: &Footage) -> Option<(u32, u32)> {
-    let bytes = s.services.read_file(&f.path).ok()?;
-    let doc = crate::vector::vector_doc(&f.path, &bytes, f.layer.as_ref(), f.page)?.ok()?;
-    (!doc.root.children.is_empty()).then(|| doc.pixel_size())
-}
-
-/// Footage `f` as its file is now, given the importer's fresh look at the file (`probed`).
-fn refreshed(s: &Session, f: &Footage, probed: Footage) -> Footage {
-    let mut nf = f.clone();
-    nf.missing = false;
-    // An image sequence picks up frames added to (or removed from) its run; its frame rate and
-    // order are the interpretation's.
-    if f.kind == FootageKind::Sequence {
-        if probed.kind == FootageKind::Sequence {
-            (nf.sequence, nf.width, nf.height) = (probed.sequence, probed.width, probed.height);
-            nf.sync_sequence_duration();
-        }
-        return nf;
-    }
-    nf.codec = probed.codec;
-    nf.has_video = probed.has_video;
-    nf.has_audio = probed.has_audio;
-    if matches!(f.kind, FootageKind::Video | FootageKind::Audio) {
-        nf.duration = probed.duration;
-        // Interpret Footage ▸ Conform to frame rate stays; the file's own rate is refreshed.
-        match f.native_rate {
-            Some(_) => nf.native_rate = Some(probed.native_rate.unwrap_or(probed.frame_rate)),
-            None => nf.frame_rate = probed.frame_rate,
-        }
-    }
-    if f.kind == FootageKind::Data {
-        nf.data = probed.data;
-    }
-    let (mut w, mut h) = (probed.width, probed.height);
-    match &f.layer {
-        // A smart object's size is its embedded file's, recorded at import.
-        Some(l) if l.embedded.is_some() => (w, h) = (f.width, f.height),
-        Some(_) if crate::vector::is_vector(f) => (w, h) = vector_size(s, f).unwrap_or((f.width, f.height)),
-        Some(l) => match psd_layer(s, &f.path, l) {
-            Some((index, size)) => {
-                if let Some(nl) = nf.layer.as_mut() {
-                    nl.index = index;
-                }
-                // Retain Layer Sizes: the layer's own bounds; otherwise the document's.
-                if l.layer_size {
-                    (w, h) = size.unwrap_or((f.width, f.height));
-                }
-            }
-            // The layer is gone from the file: keep the item as it was.
-            None => (w, h) = (f.width, f.height),
-        },
-        // A later page of a PDF: the probe measures the first page.
-        None if f.page != 0 => (w, h) = (f.width, f.height),
-        None => {}
-    }
-    (nf.width, nf.height) = (w, h);
-    nf
-}
-
-/// Reload footage items `ids` from their files (File ▸ Reload Footage): an undo step; items
-/// whose file can't be read are marked missing. Returns how many items were reloaded.
-pub fn reload_items(s: &mut Session, ids: &[ItemId]) -> crate::Result<usize> {
-    Ok(reload(s, ids, true)?.0)
-}
-
-/// Reload items `ids`. `undoable` makes it an edit; otherwise it records the disk without
-/// modifying the project, and an item whose file can't be read now (another app is still
-/// writing it) is left as it was. Returns the number reloaded and the files that couldn't be read
-/// (only without `undoable`).
-fn reload(s: &mut Session, ids: &[ItemId], undoable: bool) -> crate::Result<(usize, BTreeSet<String>)> {
-    let Some(importer) = s.importer.clone() else {
-        return Err(crate::EngineError::Other("media import is not available in this build".into()));
-    };
-    let mut updates = vec![];
-    let mut paths = BTreeSet::new();
-    let mut failed = BTreeSet::new();
-    for i in ids {
-        if let Some(ItemKind::Footage(f)) = s.project.item(*i).map(|x| &x.kind) {
-            // A sequence is probed the way it imports by default, so its run is found again; any
-            // other item is its one file, not the run a numbered still sits in (#2074). A path
-            // that is not followed is not read.
-            let probed = s
-                .stored_paths
-                .check(f)
-                .map_err(|(p, why)| crate::doc_path::refusal(&p, why))
-                .and_then(|_| if f.kind == FootageKind::Sequence { s.probe_footage(&f.path) } else { importer.probe(&f.path) });
-            let nf = match probed {
-                Ok(p) => refreshed(s, f, p),
-                Err(_) if undoable => Footage { missing: true, ..f.clone() },
-                Err(_) => {
-                    failed.insert(f.path.clone());
-                    continue;
-                }
-            };
-            paths.insert(f.path.clone());
-            paths.extend(f.sequence.iter().chain(&nf.sequence).cloned());
-            updates.push((*i, nf));
-        }
-    }
-    let n = updates.len();
-    if undoable {
-        s.edit("Reload Footage", None, |proj, _| {
-            for (i, f) in updates {
-                if let Some(it) = proj.item_mut(i) {
-                    it.kind = ItemKind::Footage(f);
-                }
-            }
-            Ok(())
-        })?;
-    } else {
-        let p = Arc::make_mut(&mut s.project);
-        let mut changed = false;
-        for (i, f) in updates {
-            if let Some(it) = p.item_mut(i)
-                && !matches!(&it.kind, ItemKind::Footage(cur) if *cur == f)
-            {
-                it.kind = ItemKind::Footage(f);
-                changed = true;
-            }
-        }
-        if changed {
-            let dirty = s.is_dirty();
-            s.bump();
-            if !dirty {
-                // Only the disk changed: the project isn't modified.
-                s.mark_saved();
-            }
-        }
-    }
-    forget(s, &paths);
-    Ok((n, failed))
-}
-
-/// Make the media layer and the layer cache let go of `paths`, so renders read them again.
-fn forget(s: &mut Session, paths: &BTreeSet<String>) {
-    for p in paths {
-        s.footage.forget(p);
-    }
-    s.layer_cache.clear();
-    // Reloaded files may keep their footage settings but not their size and time.
-    s.refresh_disk_salt(true);
-    s.events.push(crate::Event::PurgeCaches);
-}
-
-/// Compare fresh stamps of the watched files with the ones last seen. A file seen for the first
-/// time is only remembered; one whose stamp moved is reloaded: the items reading it get their
-/// size and duration from it again and its pixels are read again. A file that can't be stamped
-/// right now (an app saving by delete and rename) keeps its last stamp, and one that can't be
-/// read (still being written) is tried again once it changes again; missing files are left to
-/// the footage check. Returns `{files, reloaded}`.
-pub fn apply_stamps(s: &mut Session, now: Vec<(String, Option<Stamp>)>) -> crate::Result<Value> {
-    let before = std::mem::take(&mut s.footage_stamps);
-    let mut changed = BTreeSet::new();
-    // Only what is watched now is remembered (files no longer used are dropped).
-    for (path, stamp) in now {
-        match (before.get(&path), stamp) {
-            (Some(old), None) => {
-                s.footage_stamps.insert(path, *old);
-            }
-            (old, Some(stamp)) => {
-                if old.is_some_and(|o| *o != stamp) {
-                    changed.insert(path.clone());
-                }
-                s.footage_stamps.insert(path, stamp);
-            }
-            (None, None) => {}
-        }
-    }
-    if changed.is_empty() {
-        return Ok(json!({"files": 0, "reloaded": 0}));
-    }
-    let ids: Vec<ItemId> = s.project.items.values().filter(|i| matches!(&i.kind, ItemKind::Footage(f) if changed.contains(&f.path))).map(|i| i.id).collect();
-    let (reloaded, failed) = if ids.is_empty() { (0, BTreeSet::new()) } else { reload(s, &ids, false)? };
-    // Not readable (still being written, or not a file the importer reads): its new stamp is kept,
-    // so it is tried again once it changes again, not on every look.
-    for p in &failed {
-        changed.remove(p);
-    }
-    if changed.is_empty() {
-        return Ok(json!({"files": 0, "reloaded": 0}));
-    }
-    // Changed frames of image sequences (their items keep their metadata).
-    forget(s, &changed);
-    let files = changed.len();
-    s.toast(if reloaded > 0 {
-        format!("Reloaded {reloaded} footage item(s) changed on disk")
-    } else {
-        format!("Reloaded {files} footage file(s) changed on disk")
-    });
-    Ok(json!({"files": files, "reloaded": reloaded}))
-}
-
-/// `footage.reloadChanged`: stamp the watched files now and reload the ones that changed.
-pub(crate) fn command(s: &mut Session, _: &Value) -> crate::Result<Value> {
-    let services = s.services.clone();
-    let now = watched(s).into_iter().map(|p| (p.clone(), services.stamp(&p))).collect();
-    apply_stamps(s, now)
-}
-
-/// Start stamping the watched files on a worker thread, unless a scan is still running (or the
-/// build has no threads: the web app, whose footage lives in browser storage).
-pub fn start_scan(s: &mut Session) {
-    if s.footage_scan.is_some() || cfg!(target_arch = "wasm32") {
-        return;
-    }
-    let paths = watched(s);
-    if paths.is_empty() {
-        return;
-    }
-    let services = s.services.clone();
-    let slot: Scan = Arc::default();
-    let out = slot.clone();
-    let spawned = std::thread::Builder::new().name("footage-watch".into()).spawn(move || {
-        let stamps = paths.into_iter().map(|p| (p.clone(), services.stamp(&p))).collect();
-        *out.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(stamps);
-    });
-    if spawned.is_ok() {
-        s.footage_scan = Some(slot);
-    }
-}
-
-/// Apply a finished scan (`None` while there is none, or it is still running).
-pub fn poll_scan(s: &mut Session) -> Option<crate::Result<Value>> {
-    let stamps = s.footage_scan.as_ref()?.lock().unwrap_or_else(std::sync::PoisonError::into_inner).take()?;
-    s.footage_scan = None;
-    Some(apply_stamps(s, stamps))
-}
diff --git a/crates/engine/src/history.rs b/crates/engine/src/history.rs
index d9577285b..ae314d65d 100644
--- a/crates/engine/src/history.rs
+++ b/crates/engine/src/history.rs
@@ -314,6 +314,9 @@ impl Session {
         }
         // Every state off the new line goes into branches: a chain per first child, the other
         // children starting branches of their own.
+        /// Adds to `out` one [`Branch`] for the off-line subtree at `start`: it follows the first
+        /// child that is not on the new history line, and records every other such child as a further
+        /// branch from the state it forked at (`parent`).
         fn chain(a: &Arena, start: usize, parent: usize, in_new: &[bool], out: &mut Vec<Branch>) {
             let mut steps = vec![];
             let mut n = start;
@@ -342,6 +345,7 @@ impl Session {
         let undo: Vec<(String, Arc<Project>)> = (0..k).map(|i| (a.label[new_line[i + 1]].clone(), a.state[new_line[i]].clone())).collect();
         let redo: Vec<(String, Arc<Project>)> = new_line[k + 1..].iter().rev().map(|&i| (a.label[i].clone(), a.state[i].clone())).collect();
         let edited = crate::commands::text_edit::active_editor_snapshot(self);
+        let probe = crate::commands::kept_crypto_probe(self);
         let cur = std::mem::replace(&mut self.project, a.state[target].clone());
         self.keep_view_settings(&cur);
         self.history.undo = undo;
@@ -350,6 +354,7 @@ impl Session {
         self.history.merge_key = None;
         self.sanitize_after_replacement(edited.as_ref());
         self.bump();
+        crate::commands::keep_crypto_probe(self, probe, &cur);
         true
     }
 }
diff --git a/crates/engine/src/home.rs b/crates/engine/src/home.rs
new file mode 100644
index 000000000..183461aa4
--- /dev/null
+++ b/crates/engine/src/home.rs
@@ -0,0 +1,4 @@
+pub mod demo;
+pub mod learn;
+pub mod links;
+pub mod templates;
diff --git a/crates/engine/src/demo.rs b/crates/engine/src/home/demo.rs
similarity index 94%
rename from crates/engine/src/demo.rs
rename to crates/engine/src/home/demo.rs
index df07f5204..7503178fa 100644
--- a/crates/engine/src/demo.rs
+++ b/crates/engine/src/home/demo.rs
@@ -121,7 +121,7 @@ fn lower_third(p: &mut Project) -> Comp {
         [440.0, 914.0],
     );
     anim(&mut title, "transform/opacity", keys(&[(0.4, Value::Scalar(0.0)), (0.9, Value::Scalar(100.0))]));
-    c.layers = vec![title, bar];
+    c.layers = vec![title, bar].into();
     c
 }
 
@@ -130,8 +130,20 @@ fn solid_sized(p: &mut Project, comp: &Comp, folder: ItemId, name: &str, color:
     build::layer(p, comp, name, LayerSource::Solid { item: sid }, (w, h), None)
 }
 
+/// What `card` draws: name, gradient end colors (hex), size, position and Y rotation.
+#[derive(Clone, Copy)]
+struct CardSpec<'a> {
+    name: &'a str,
+    a: &'a str,
+    b: &'a str,
+    size: (u32, u32),
+    pos: [f64; 3],
+    rot_y: f64,
+}
+
 /// A 3D card: a solid with a diagonal gradient and a thin border grid.
-fn card(p: &mut Project, comp: &Comp, folder: ItemId, name: &str, a: &str, b: &str, size: (u32, u32), pos: [f64; 3], rot_y: f64) -> Layer {
+fn card(p: &mut Project, comp: &Comp, folder: ItemId, spec: &CardSpec) -> Layer {
+    let CardSpec { name, a, b, size, pos, rot_y } = *spec;
     let mut l = solid_sized(p, comp, folder, name, [1.0, 1.0, 1.0], size.0, size.1);
     let (w, h) = (size.0 as f64, size.1 as f64);
     effect(
@@ -192,11 +204,11 @@ fn showcase_3d(p: &mut Project, solids: ItemId) -> Comp {
     set(&mut floor, "materialOptions/specularIntensity", Value::Scalar(10.0));
 
     // Cards at different depths and angles; the centre pair intersects.
-    let left = card(p, &c, solids, "Card Blue", "#2E7BF0", "#7A4DFF", (520, 340), [520.0, 560.0, 120.0], 28.0);
-    let right = card(p, &c, solids, "Card Coral", "#FF6A5C", "#FFB347", (520, 340), [1420.0, 560.0, 260.0], -32.0);
-    let mut x1 = card(p, &c, solids, "Cross A", "#1FD1A5", "#2E7BF0", (460, 460), [960.0, 470.0, 520.0], 40.0);
+    let left = card(p, &c, solids, &CardSpec { name: "Card Blue", a: "#2E7BF0", b: "#7A4DFF", size: (520, 340), pos: [520.0, 560.0, 120.0], rot_y: 28.0 });
+    let right = card(p, &c, solids, &CardSpec { name: "Card Coral", a: "#FF6A5C", b: "#FFB347", size: (520, 340), pos: [1420.0, 560.0, 260.0], rot_y: -32.0 });
+    let mut x1 = card(p, &c, solids, &CardSpec { name: "Cross A", a: "#1FD1A5", b: "#2E7BF0", size: (460, 460), pos: [960.0, 470.0, 520.0], rot_y: 40.0 });
     set(&mut x1, "materialOptions/lightTransmission", Value::Scalar(30.0));
-    let x2 = card(p, &c, solids, "Cross B", "#F0E14A", "#FF6A5C", (460, 460), [960.0, 470.0, 520.0], -40.0);
+    let x2 = card(p, &c, solids, &CardSpec { name: "Cross B", a: "#F0E14A", b: "#FF6A5C", size: (460, 460), pos: [960.0, 470.0, 520.0], rot_y: -40.0 });
     // Hero title in 3D space, gently turning.
     let mut title = text_layer(
         p,
@@ -258,7 +270,7 @@ fn showcase_3d(p: &mut Project, solids: ItemId) -> Comp {
     );
     anim(&mut caption, "transform/opacity", keys(&[(0.3, Value::Scalar(0.0)), (1.2, Value::Scalar(100.0))]));
 
-    c.layers = vec![caption, cam, key, fill, title, left, right, x1, x2, floor];
+    c.layers = vec![caption, cam, key, fill, title, left, right, x1, x2, floor].into();
     c
 }
 
@@ -451,7 +463,7 @@ pub fn demo_project() -> Project {
     lower.out_point = t(9.5);
 
     // Stack: top first.
-    comp.layers = vec![lower, title, sub, line, burst, rings, null, bg];
+    comp.layers = vec![lower, title, sub, line, burst, rings, null, bg].into();
     for l in &mut comp.layers {
         if l.name == "Controller" {
             l.switches.video = false;
diff --git a/crates/engine/src/learn.rs b/crates/engine/src/home/learn.rs
similarity index 100%
rename from crates/engine/src/learn.rs
rename to crates/engine/src/home/learn.rs
diff --git a/crates/engine/src/links.rs b/crates/engine/src/home/links.rs
similarity index 100%
rename from crates/engine/src/links.rs
rename to crates/engine/src/home/links.rs
diff --git a/crates/engine/src/templates.rs b/crates/engine/src/home/templates.rs
similarity index 92%
rename from crates/engine/src/templates.rs
rename to crates/engine/src/home/templates.rs
index 500308b72..0b15baaf5 100644
--- a/crates/engine/src/templates.rs
+++ b/crates/engine/src/home/templates.rs
@@ -645,6 +645,21 @@ fn base_name(path: &str) -> String {
     path.rsplit(['/', '\\']).next().filter(|n| !n.is_empty()).unwrap_or("footage").to_string()
 }
 
+/// A template entry's name, made safe to write inside a folder: a template is a file like any
+/// other and can name its entries anything. Nothing a platform reads as a separator, a drive or
+/// the folder above survives, and a name that leaves nothing usable becomes `footage` (#2123).
+fn safe_file_name(name: &str) -> String {
+    let name: String = name.chars().map(|c| if matches!(c, '/' | '\\' | ':' | '\0') { '_' } else { c }).collect();
+    // `.` and `..`, and names of dots and spaces alone (Windows drops the trailing ones).
+    if name.trim_matches(['.', ' ']).is_empty() { "footage".to_string() } else { name }
+}
+
+/// What two entry names must differ by to be sure of two files: a filesystem may ignore case, and
+/// Win32 ignores trailing dots and spaces.
+fn same_file_key(name: &str) -> String {
+    name.trim_end_matches(['.', ' ']).to_lowercase()
+}
+
 /// What [`embed_footage`] did.
 #[derive(Default)]
 struct Embedded {
@@ -738,9 +753,21 @@ fn extract_footage(s: &Session, proj: &mut Project, entries: &[(String, Vec<u8>)
     let mut used = std::collections::HashSet::new();
     for (k, v) in entries.iter().filter(|(k, _)| k.starts_with("media/")) {
         // `media/<item>/<file>` → one folder; a name another item took gets the item's id.
-        let file = base_name(k);
-        let item = k.trim_start_matches("media/").split('/').next().unwrap_or("0");
-        let name = if used.insert(file.clone()) { file } else { format!("{item}-{file}") };
+        let file = safe_file_name(&base_name(k));
+        // The item's id, and only that: it is written as one ([`embed_footage`]), but a template
+        // from elsewhere can hold anything there, and `..\` in it walks out of `dir` on Windows.
+        let item = k.trim_start_matches("media/").split('/').next().filter(|i| i.bytes().all(|b| b.is_ascii_digit())).unwrap_or("0");
+        // A name another entry has taken gets the item's id, and a number if that is taken too:
+        // the names an entry can ask for are not distinct, and two files must not become one.
+        // They are compared the way a filesystem might: `CLIP.png` is `clip.png` on a
+        // case-insensitive volume (Windows and macOS as they come), and Win32 drops a trailing
+        // dot or space, so `a.png.` is `a.png` there. The name written stays as it is.
+        let mut name = file.clone();
+        let mut n = 0usize;
+        while !used.insert(same_file_key(&name)) {
+            n += 1;
+            name = if n == 1 { format!("{item}-{file}") } else { format!("{item}-{n}-{file}") };
+        }
         let out = format!("{dir}/{name}");
         s.services.store_file(&out, v).map_err(|e| EngineError::Other(format!("cannot write {out}: {e}")))?;
         if let Some(imp) = &s.importer {
@@ -970,6 +997,57 @@ mod tests {
         assert_eq!(l.iter().find(|t| t.id == "lower-third").unwrap().controls, ["Name", "Title", "Bar Color"]);
     }
 
+    /// #2123: a template holds its footage as `media/<item id>/<file>` entries, but a template
+    /// from anywhere else can name them anything — and `..\\`, which only this platform reads as
+    /// a plain character, is a separator on Windows, so a second entry with a base name already
+    /// taken wrote `<dir>/..\\..\\..\\Startup\\x-evil.bat`. Whatever an entry is called, the file
+    /// lands in the footage folder.
+    #[test]
+    fn extracted_footage_stays_in_its_folder() {
+        let s = Session::default();
+        let mut proj = effectcraft_project::Project::default();
+        let dir = std::env::temp_dir().join(format!("ec-templates-media-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        let ds = dir.to_string_lossy().into_owned();
+        let entry = |k: &str| (k.to_string(), b"x".to_vec());
+        let entries = [
+            entry("media/0/clip.mp4"),
+            // The base name is taken, so this one's "item id" is used — and it is not one.
+            entry("media/..\\..\\..\\Startup\\x/clip.mp4"),
+            entry("media/1/C:evil.bat"),
+            // Three that collide once the first is made safe: each still gets its own file.
+            entry("media/1/a:b.png"),
+            entry("media/2/a_b.png"),
+            entry("media/3/2-a_b.png"),
+            // The same file on a case-insensitive volume, and on Windows, which drops the dot.
+            entry("media/4/clip.png"),
+            entry("media/5/CLIP.png"),
+            entry("media/6/a.png"),
+            entry("media/7/a.png."),
+        ];
+        let written = extract_footage(&s, &mut proj, &entries, &ds).unwrap();
+        assert_eq!(written.len(), entries.len());
+        for w in &written {
+            let name = w.strip_prefix(&format!("{ds}/")).unwrap_or_else(|| panic!("{w} is outside {ds}"));
+            assert!(!name.contains(['/', '\\', ':']), "{w}");
+            assert!(!name.trim_matches(['.', ' ']).is_empty(), "{w}");
+        }
+        // One file each, all of them in the folder, none overwritten by the next.
+        assert_eq!(written.iter().collect::<std::collections::BTreeSet<_>>().len(), entries.len(), "{written:?}");
+        assert_eq!(std::fs::read_dir(&dir).map(|d| d.count()).unwrap_or(0), entries.len());
+        let _ = std::fs::remove_dir_all(&dir);
+        // And the names that would leave nothing to write.
+        for n in ["..", ".", " .. ", "...", ""] {
+            assert_eq!(safe_file_name(n), "footage", "{n:?}");
+        }
+        assert_eq!(safe_file_name("clip.mp4"), "clip.mp4");
+        assert_eq!(safe_file_name(".hidden.mp4"), ".hidden.mp4");
+        assert_eq!(safe_file_name("a/b\\c:d"), "a_b_c_d");
+        // Names a filesystem may not tell apart (only the case half of this shows on macOS).
+        assert_eq!(same_file_key("A.PNG. "), same_file_key("a.png"));
+        assert_ne!(same_file_key("a.png"), same_file_key("b.png"));
+    }
+
     #[test]
     fn create_opens_an_untitled_copy() {
         let mut s = Session::default();
diff --git a/crates/engine/src/interchange.rs b/crates/engine/src/interchange.rs
new file mode 100644
index 000000000..3b166b83e
--- /dev/null
+++ b/crates/engine/src/interchange.rs
@@ -0,0 +1,5 @@
+pub(crate) mod keyframe_text;
+pub(crate) mod keyframe_text_effects;
+pub mod psd_import;
+pub mod vector;
+pub mod xml_project;
diff --git a/crates/engine/src/interchange/keyframe_text.rs b/crates/engine/src/interchange/keyframe_text.rs
new file mode 100644
index 000000000..5f8ba9441
--- /dev/null
+++ b/crates/engine/src/interchange/keyframe_text.rs
@@ -0,0 +1,348 @@
+//! Copied keyframes as After Effects keyframe text, for the system clipboard (#1908). Other
+//! applications read this tab-separated format (AE2Blend brings it into Blender). Like After
+//! Effects it covers one layer: its copied properties, keyframed ones as one row per key (frame
+//! number in comp time, then the value) and static ones as a single row with no frame. Easing
+//! and tangents aren't part of the format; EffectCraft's own paste keeps them.
+
+use effectcraft_project::{AutoOrient, Comp, GroupKind, ItemKind, Layer, LayerId, LayerSource, Node, ParamUi, Project, PropGroup, Property, Uid};
+
+use crate::{KeyRef, keyframe_text_effects};
+
+/// Transform properties with the unit their columns are labelled with and, for vectors, the
+/// third component a 2D layer shows. X / Y / Z Position (Separate Dimensions) have no unit.
+const TRANSFORM: &[(&str, &str, Option<f64>)] = &[
+    ("poi", "pixels", Some(0.0)),
+    ("anchor", "pixels", Some(0.0)),
+    ("position", "pixels", Some(0.0)),
+    ("positionX", "", None),
+    ("positionY", "", None),
+    ("positionZ", "", None),
+    ("scale", "percent", Some(100.0)),
+    ("orientation", "degrees", None),
+    ("rotationX", "degrees", None),
+    ("rotationY", "degrees", None),
+    ("rotation", "degrees", None),
+    ("opacity", "percent", None),
+];
+
+/// How a copied property is written: its block's header line, column labels and values.
+struct Channel {
+    header: String,
+    labels: Vec<String>,
+    values: Values,
+}
+
+/// How a property's value becomes the numbers in a row.
+#[derive(Clone, Copy)]
+enum Values {
+    Plain,
+    /// A 2D layer's Transform vector: the third component is the one the layer shows (it may
+    /// keep another from pasted 3D keys).
+    Flat(f64),
+    /// RGBA 0–1 as alpha, red, green, blue 0–255.
+    Argb,
+    /// A popup's 0-based choice as After Effects' 1-based one.
+    OneBased,
+    Scale(f64),
+}
+
+impl Values {
+    fn row(self, mut v: Vec<f64>) -> Vec<f64> {
+        match (self, v.as_slice()) {
+            (Values::Flat(z), _) => {
+                if let Some(c) = v.get_mut(2) {
+                    *c = z;
+                }
+                v
+            }
+            (Values::Argb, [r, g, b, a]) => [a, r, g, b].map(|c| c * 255.0).to_vec(),
+            (Values::OneBased, _) => v.into_iter().map(|c| c + 1.0).collect(),
+            (Values::Scale(s), _) => v.into_iter().map(|c| c * s).collect(),
+            _ => v,
+        }
+    }
+}
+
+/// The text for copied keys (layer times) and unanimated properties. `None` unless they all come
+/// from one layer and at least one property can be written.
+pub(crate) fn text(project: &Project, comp: &Comp, keys: &[KeyRef], statics: &[(LayerId, Uid)]) -> Option<String> {
+    let lid = keys.first().map(|k| k.layer).or_else(|| statics.first().map(|s| s.0))?;
+    if keys.iter().any(|k| k.layer != lid) || statics.iter().any(|s| s.0 != lid) {
+        return None;
+    }
+    let layer = comp.layer(lid)?;
+    let fps = comp.frame_rate.as_f64();
+    let mut blocks = String::new();
+    layer.props.walk("", &mut |_, pr| {
+        let mut times: Vec<_> = keys.iter().filter(|k| k.prop == pr.uid).map(|k| k.time).collect();
+        times.sort();
+        times.dedup();
+        let rows: Vec<(String, Vec<f64>)> = if !times.is_empty() {
+            let frame = |t| num(layer.comp_time(t).seconds() * fps);
+            times.into_iter().filter_map(|t| Some((frame(t), pr.keys.iter().find(|k| k.time == t)?.value.components()))).collect()
+        } else if statics.iter().any(|s| s.1 == pr.uid) {
+            vec![(String::new(), pr.value.components())]
+        } else {
+            return;
+        };
+        let Some(ch) = channel(layer, pr).filter(|ch| !ch.labels.is_empty()) else { return };
+        if rows.iter().any(|(_, v)| v.is_empty()) {
+            return;
+        }
+        blocks.push_str(&format!("{}\n\tFrame\t{}\t\n", ch.header, ch.labels.join("\t")));
+        for (frame, values) in rows {
+            let values: Vec<String> = ch.values.row(values).into_iter().map(num).collect();
+            blocks.push_str(&format!("\t{frame}\t{}\t\n", values.join("\t")));
+        }
+        blocks.push('\n');
+    });
+    if blocks.is_empty() {
+        return None;
+    }
+    // After Effects writes a text layer's source as 1 × 1. Other layers without a source of
+    // their own (shapes, cameras) take the comp's size, and all of them its pixel aspect.
+    let (w, h) = match (&layer.source, effectcraft_render::eval::source_size(project, layer)) {
+        (LayerSource::Text, _) => (1, 1),
+        (_, (0, 0)) => (comp.width, comp.height),
+        (_, size) => size,
+    };
+    let par = match layer.source {
+        LayerSource::Footage { item } | LayerSource::Solid { item } | LayerSource::Comp { item } => match project.item(item).map(|i| &i.kind) {
+            Some(ItemKind::Footage(f)) => f.pixel_aspect,
+            Some(ItemKind::Solid(s)) => s.pixel_aspect,
+            Some(ItemKind::Comp(c)) => c.pixel_aspect,
+            _ => comp.pixel_aspect,
+        },
+        _ => comp.pixel_aspect,
+    };
+    // The layout of current After Effects: a `Layer` line before the layer's properties (parsers
+    // such as ae-keyframes reject properties without one), and a tab after every column.
+    Some(format!(
+        "Adobe After Effects 9.0 Keyframe Data\n\n\tUnits Per Second\t{}\n\tSource Width\t{w}\n\tSource Height\t{h}\n\tSource Pixel Aspect Ratio\t{}\n\tComp Pixel Aspect Ratio\t{}\n\nLayer\n{blocks}\nEnd of Keyframe Data\n",
+        num(fps),
+        num(par),
+        num(comp.pixel_aspect)
+    ))
+}
+
+/// How the layer's property `pr` is written, by where it sits in the layer: `None` for
+/// properties the text doesn't carry.
+fn channel(layer: &Layer, pr: &Property) -> Option<Channel> {
+    let chain = layer.props.node_chain(pr.uid)?;
+    match chain.first().and_then(|n| n.as_group()).map(|g| g.match_id.as_str()) {
+        None if pr.match_id == "timeRemap" => Some(Channel { header: "Time Remap".into(), labels: labels("seconds", 1), values: Values::Plain }),
+        Some("transform") => transform(layer, pr),
+        Some("effects") => effect(&chain, pr),
+        Some("masks" | "text" | "contents" | "cameraOptions" | "lightOptions" | "materialOptions") => nested(&chain, pr),
+        _ => None,
+    }
+}
+
+/// Indexed groups by match id, with the kind After Effects names them by: it writes them by kind
+/// and place (`Mask #2`, `Group #1`), not by name.
+const INSTANCES: &[(&str, &str)] = &[
+    ("mask", "Mask"),
+    ("animator", "Animator"),
+    ("rangeSelector", "Range Selector"),
+    ("wigglySelector", "Wiggly Selector"),
+    ("expressionSelector", "Expression Selector"),
+    ("group", "Group"),
+    ("rect", "Rectangle Path"),
+    ("ellipse", "Ellipse Path"),
+    ("star", "Polystar Path"),
+    ("path", "Path"),
+    ("fill", "Fill"),
+    ("stroke", "Stroke"),
+    ("gfill", "Gradient Fill"),
+    ("gstroke", "Gradient Stroke"),
+    ("trim", "Trim Paths"),
+    ("repeater", "Repeater"),
+    ("round", "Round Corners"),
+    ("offset", "Offset Paths"),
+    ("pucker", "Pucker & Bloat"),
+    ("twist", "Twist"),
+    ("zigzag", "Zig Zag"),
+    ("wiggle", "Wiggle Paths"),
+    ("merge", "Merge Paths"),
+];
+
+/// A property under Masks, Text, Contents or Camera / Light / Material Options: the group's
+/// name, then each group down to the property. Instances go by kind and place, and a text
+/// selector's own properties carry their place too (`Start #1`).
+fn nested(chain: &[&Node], pr: &Property) -> Option<Channel> {
+    let groups: Vec<&PropGroup> = chain.iter().filter_map(|n| n.as_group()).collect();
+    let parent = groups.last()?;
+    let (labels, values) = columns(&parent.match_id, &pr.match_id, pr, false)?;
+    let mut header = groups.first()?.name.clone();
+    for pair in groups.windows(2) {
+        let [outer, g] = pair else { continue };
+        match INSTANCES.iter().find(|(id, _)| *id == g.match_id).filter(|_| g.is_instance()) {
+            Some((_, kind)) => header.push_str(&format!("\t{kind} #{}", place(outer, g.uid)?)),
+            None => header.push_str(&format!("\t{}", g.name)),
+        }
+    }
+    if parent.match_id.ends_with("Selector") {
+        header.push_str(&format!("\t{} #{}", pr.name, place(parent, pr.uid)?));
+    } else {
+        header.push_str(&format!("\t{}", pr.name));
+    }
+    Some(Channel { header, labels, values })
+}
+
+/// An effect property: `Effects`, the effect's name (not a custom one) and place on the layer,
+/// then the property's name and After Effects index. Properties in twirl-down groups are
+/// written without their group, as After Effects does.
+fn effect(chain: &[&Node], pr: &Property) -> Option<Channel> {
+    let [Node::Group(effects), Node::Group(fx), ..] = chain else { return None };
+    let GroupKind::Effect { effect } = &fx.kind else { return None };
+    let name = effectcraft_effects::find(effect).map_or(fx.name.as_str(), |spec| spec.name);
+    let path: String = chain.iter().skip(2).filter_map(|n| n.as_group()).map(|g| format!("{}/", g.match_id)).chain([pr.match_id.clone()]).collect();
+    let (labels, values) = columns(effect, &path, pr, true)?;
+    let header = format!("Effects\t{name} #{}\t{} #{}", place(effects, fx.uid)?, pr.name, effect_index(effect, fx, pr.uid)?);
+    Some(Channel { header, labels, values })
+}
+
+/// After Effects' index of an effect property: the effect's hidden input layer is #1, and a
+/// twirl-down group takes an index where it opens and another where it closes. The hidden
+/// source choice EffectCraft keeps beside a layer parameter has none. Where After Effects
+/// numbers a parameter otherwise ([`keyframe_text_effects::INDICES`]), counting goes on from it.
+fn effect_index(effect: &str, fx: &PropGroup, uid: Uid) -> Option<usize> {
+    fn count(effect: &str, g: &PropGroup, prefix: &str, uid: Uid, n: &mut usize) -> bool {
+        for c in &g.children {
+            match c {
+                Node::Prop(p) if is_layer_source(g, p) => {}
+                Node::Prop(p) => {
+                    let path = format!("{prefix}{}", p.match_id);
+                    *n = keyframe_text_effects::INDICES.iter().find(|(e, q, _)| *e == effect && *q == path).map_or(*n + 1, |a| a.2);
+                    if p.uid == uid {
+                        return true;
+                    }
+                }
+                Node::Group(sub) => {
+                    *n += 1;
+                    if count(effect, sub, &format!("{prefix}{}/", sub.match_id), uid, n) {
+                        return true;
+                    }
+                    *n += 1;
+                }
+            }
+        }
+        false
+    }
+    let mut n = 1;
+    count(effect, fx, "", uid, &mut n).then_some(n)
+}
+
+fn is_layer_source(g: &PropGroup, p: &Property) -> bool {
+    p.ui == ParamUi::Hidden && g.props().any(|l| l.ui == ParamUi::Layer && effectcraft_effects::layer_source_id(&l.match_id) == p.match_id)
+}
+
+/// 1-based position of a child in its group.
+fn place(group: &PropGroup, uid: Uid) -> Option<usize> {
+    group.children.iter().position(|c| c.uid() == uid).map(|i| i + 1)
+}
+
+/// How After Effects writes a property differently from what its editor suggests ([`by_ui`]).
+#[derive(Clone, Copy)]
+enum Exception {
+    /// Not written.
+    Skip,
+    Unit(&'static str),
+    Values(Values),
+}
+
+/// Properties After Effects writes differently from what their editor suggests, by the effect
+/// or group they're directly in and their match id.
+const EXCEPTIONS: &[(&str, &str, Exception)] = &[
+    // Path Options' Path picks a mask, which After Effects doesn't write.
+    ("pathOptions", "path", Exception::Skip),
+    ("mask", "feather", Exception::Unit("pixels")),
+    ("mask", "expansion", Exception::Unit("pixels")),
+    ("cameraOptions", "zoom", Exception::Unit("pixels")),
+    ("cameraOptions", "focusDistance", Exception::Unit("pixels")),
+    ("cameraOptions", "aperture", Exception::Unit("pixels")),
+    ("cameraOptions", "highlightGain", Exception::Unit("")),
+    ("cameraOptions", "highlightSaturation", Exception::Unit("")),
+    // After Effects keeps the threshold as 0–1.
+    ("cameraOptions", "highlightThreshold", Exception::Values(Values::Scale(1.0 / 255.0))),
+    ("lightOptions", "shadowDiffusion", Exception::Unit("pixels")),
+    // Off, On, Only: written from 0.
+    ("materialOptions", "castsShadows", Exception::Values(Values::Plain)),
+    ("materialOptions", "acceptsShadows", Exception::Values(Values::Plain)),
+];
+
+/// Column labels and values for a property in `scope`, the effect (by id) or group (by match
+/// id) it's directly in, at `path` there (an effect property's groups, then its match id): [`by_ui`]
+/// unless [`EXCEPTIONS`] or, in effects, [`keyframe_text_effects::UNITS`] say otherwise.
+fn columns(scope: &str, path: &str, pr: &Property, in_effect: bool) -> Option<(Vec<String>, Values)> {
+    let (by_editor, values) = by_ui(pr, in_effect)?;
+    let exception = EXCEPTIONS.iter().find(|(s, id, _)| *s == scope && *id == path).map(|e| e.2);
+    let effect_unit = || keyframe_text_effects::UNITS.iter().find(|(e, p, _)| in_effect && *e == scope && *p == path).map(|u| Exception::Unit(u.2));
+    Some(match exception.or_else(effect_unit) {
+        None => (by_editor, values),
+        Some(Exception::Skip) => return None,
+        Some(Exception::Unit(unit)) => (labels(unit, pr.value.dims()), values),
+        Some(Exception::Values(values)) => (by_editor, values),
+    })
+}
+
+/// Column labels and values for a property, by how it's edited. After Effects labels most 0–100
+/// sliders (opacities) as percent, and ±100 ones too outside effects (text selector amounts),
+/// and other sliders, checkboxes and popups with no unit. [`keyframe_text_effects::UNITS`] lists
+/// the effect parameters After Effects labels otherwise.
+fn by_ui(pr: &Property, in_effect: bool) -> Option<(Vec<String>, Values)> {
+    let dims = pr.value.dims();
+    Some(match &pr.ui {
+        ParamUi::Color => (["alpha ", "red ", "green ", "blue "].map(String::from).to_vec(), Values::Argb),
+        ParamUi::Popup { .. } => (labels("", dims), Values::OneBased),
+        ParamUi::Slider { min, max, .. } if *max == 100.0 && (*min == 0.0 || (*min == -100.0 && !in_effect)) => (labels("percent", dims), Values::Plain),
+        ParamUi::Percent => (labels("percent", dims), Values::Plain),
+        ParamUi::Angle => (labels("degrees", dims), Values::Plain),
+        ParamUi::Point | ParamUi::Point3 => (labels("pixels", dims), Values::Plain),
+        ParamUi::Number | ParamUi::Slider { .. } | ParamUi::Pixels | ParamUi::Checkbox => (labels("", dims), Values::Plain),
+        _ => return None,
+    })
+}
+
+fn transform(layer: &Layer, pr: &Property) -> Option<Channel> {
+    let (id, unit, z) = TRANSFORM.iter().find(|(id, ..)| *id == pr.match_id)?;
+    if !active(layer, id) || (pr.three_d_only && !layer.is_3d()) {
+        return None;
+    }
+    // After Effects labels only the first of Orientation's three columns, and names Z Rotation
+    // plain Rotation (as AE2Blend expects).
+    let labels = if *id == "orientation" { vec![format!("X {unit}")] } else { labels(unit, pr.value.dims()) };
+    let values = match z {
+        Some(z) if !layer.is_3d() => Values::Flat(*z),
+        _ => Values::Plain,
+    };
+    Some(Channel { header: format!("Transform\t{}", pr.name), labels, values })
+}
+
+/// Column labels: the unit, or one per axis (`X pixels`, `Y pixels`; `X ` with no unit, as After
+/// Effects writes a shape's Size).
+fn labels(unit: &str, dims: usize) -> Vec<String> {
+    match dims {
+        0 => vec![],
+        1 => vec![unit.to_string()],
+        _ => ["X", "Y", "Z"].iter().take(dims).map(|axis| format!("{axis} {unit}")).collect(),
+    }
+}
+
+/// Whether the layer uses this Transform property: one-node cameras (and lights not aimed at
+/// it) have no Point of Interest, and Separate Dimensions replaces Position with X / Y / Z
+/// Position.
+fn active(layer: &Layer, id: &str) -> bool {
+    match id {
+        "poi" => !(layer.is_camera() || layer.is_light()) || layer.auto_orient == AutoOrient::TowardsPointOfInterest,
+        "position" => layer.transform().is_none_or(|tr| tr.get("positionX").is_none()),
+        _ => true,
+    }
+}
+
+/// A number with at most three decimals and no trailing zeros (`23.976`, `960`, `-0.5`).
+fn num(v: f64) -> String {
+    let s = format!("{:.3}", if v.is_finite() { v } else { 0.0 });
+    let s = s.trim_end_matches('0').trim_end_matches('.');
+    if s == "-0" { "0".into() } else { s.into() }
+}
diff --git a/crates/engine/src/interchange/keyframe_text_effects.rs b/crates/engine/src/interchange/keyframe_text_effects.rs
new file mode 100644
index 000000000..83f5b6c20
--- /dev/null
+++ b/crates/engine/src/interchange/keyframe_text_effects.rs
@@ -0,0 +1,386 @@
+//! After Effects' index and unit for effect parameters where they differ from what
+//! [`crate::keyframe_text`]'s rules give, as After Effects 2019 writes them in its keyframe text.
+//! After Effects keeps an effect's parameter indices for good (projects store them), so they
+//! hold for later versions. Parameters After Effects lacks, or names differently and keeps
+//! elsewhere, aren't listed.
+
+/// Effect id, parameter path in the effect (its groups' match ids, then its own) and After
+/// Effects' index for it; the parameters after it count on from there. After Effects numbers
+/// legacy parameters it hides, so its indices skip ahead.
+pub(crate) const INDICES: &[(&str, &str, usize)] = &[
+    ("ec.3d.channelextract", "clampOutput", 6),
+    ("ec.3d.channelextract", "antialias", 5),
+    ("ec.3d.extractor", "blackPoint", 4),
+    ("ec.audio.parametriceq", "band1Enable", 3),
+    ("ec.blur.radial", "amount", 3),
+    ("ec.color.cccolorneutralizer", "midtonesUnbalance", 8),
+    ("ec.color.cccolorneutralizer", "highlightsUnbalance", 14),
+    ("ec.color.cccolorneutralizer", "pinning", 20),
+    ("ec.color.cckernel", "k1", 3),
+    ("ec.color.cckernel", "k4", 8),
+    ("ec.color.cckernel", "k7", 13),
+    ("ec.color.cckernel", "scale", 17),
+    ("ec.color.cckernel", "absolute", 18),
+    ("ec.color.colorstabilizer", "stabilize", 2),
+    ("ec.color.huesaturation", "hue", 4),
+    ("ec.color.huesaturation", "colorize", 7),
+    ("ec.color.levels", "inBlack", 4),
+    ("ec.color.levelsic", "rgb/rgbInBlack", 5),
+    ("ec.color.lumetri", "highDynamicRange", 3),
+    ("ec.color.lumetri", "basicCorrection/inputLut", 8),
+    ("ec.color.lumetri", "basicCorrection/whiteBalance/temperature", 12),
+    ("ec.color.lumetri", "basicCorrection/tone/hdrSpecular", 22),
+    ("ec.color.lumetri", "basicCorrection/saturation", 26),
+    ("ec.color.lumetri", "creative/look", 32),
+    ("ec.color.lumetri", "creative/lookIntensity", 33),
+    ("ec.color.lumetri", "creative/adjustments/tintBalance", 40),
+    ("ec.color.lumetri", "hslSecondary/key/showMask", 83),
+    ("ec.color.lumetri", "hslSecondary/refine/denoise", 90),
+    ("ec.color.lumetri", "hslSecondary/correction/temperature", 96),
+    ("ec.color.lumetri", "vignette/vignetteAmount", 105),
+    ("ec.color.selectivecolor", "details/reds/redsCyan", 10),
+    ("ec.color.videolimiter", "compressionBeforeClipping", 3),
+    ("ec.distort.ccflomotion", "knot1", 3),
+    ("ec.distort.ccpowerpin", "expandTop", 9),
+    ("ec.distort.upscale", "scale", 4),
+    ("ec.distort.puppet", "refinement", 3),
+    ("ec.control.stereo3d", "configuration", 3),
+    ("ec.control.stereo3d", "convergenceOf", 8),
+    ("ec.generate.advancedlightning", "turbulence", 17),
+    ("ec.generate.advancedlightning", "alphaObstacle", 16),
+    ("ec.generate.advancedlightning", "compositeOnOriginal", 21),
+    ("ec.generate.ccgluegun", "style", 9),
+    ("ec.generate.cclightburst", "setColor", 7),
+    ("ec.generate.cclightrays", "colorFromSource", 8),
+    ("ec.generate.cclightrays", "color", 10),
+    ("ec.generate.circle", "feather/feather", 7),
+    ("ec.generate.paintbucket", "color", 9),
+    ("ec.vr.blur", "frameLayout", 3),
+    ("ec.vr.blur", "blurriness", 6),
+    ("ec.vr.chromaticaberrations", "frameLayout", 3),
+    ("ec.vr.chromaticaberrations", "aberrationRed", 7),
+    ("ec.vr.colorgradients", "frameLayout", 3),
+    ("ec.vr.colorgradients", "point1", 10),
+    ("ec.vr.colorgradients", "point2", 12),
+    ("ec.vr.colorgradients", "point3", 14),
+    ("ec.vr.colorgradients", "point4", 16),
+    ("ec.vr.colorgradients", "point5", 18),
+    ("ec.vr.colorgradients", "blend", 7),
+    ("ec.vr.colorgradients", "opacity", 27),
+    ("ec.vr.denoise", "frameLayout", 3),
+    ("ec.vr.denoise", "noiseType", 6),
+    ("ec.vr.digitalglitch", "frameLayout", 3),
+    ("ec.vr.digitalglitch", "masterAmplitude", 9),
+    ("ec.vr.digitalglitch", "distortionRate", 16),
+    ("ec.vr.digitalglitch", "distortionComplexity", 15),
+    ("ec.vr.digitalglitch", "distortionEvolution", 17),
+    ("ec.vr.digitalglitch", "colorDistortion", 11),
+    ("ec.vr.digitalglitch", "randomSeed", 39),
+    ("ec.vr.fractalnoise", "frameLayout", 3),
+    ("ec.vr.fractalnoise", "fractalType", 6),
+    ("ec.vr.fractalnoise", "randomSeed", 25),
+    ("ec.vr.glow", "frameLayout", 3),
+    ("ec.vr.glow", "luminanceThreshold", 6),
+    ("ec.vr.planetosphere", "frameLayout", 3),
+    ("ec.vr.planetosphere", "scale", 6),
+    ("ec.vr.planetosphere", "feather", 8),
+    ("ec.vr.planetosphere", "tilt", 15),
+    ("ec.vr.rotatesphere", "frameLayout", 3),
+    ("ec.vr.rotatesphere", "invertRotation", 9),
+    ("ec.vr.rotatesphere", "tilt", 6),
+    ("ec.vr.sharpen", "frameLayout", 3),
+    ("ec.vr.sharpen", "sharpenAmount", 6),
+    ("ec.key.colordifference", "view", 3),
+    ("ec.key.colorrange", "fuzziness", 3),
+    ("ec.key.extract", "channel", 3),
+    ("ec.key.linearcolor", "view", 3),
+    ("ec.matte.refinehard", "feather", 2),
+    ("ec.matte.refinehard", "reduceChatter", 5),
+    ("ec.matte.refinehard", "decontaminationAmount", 14),
+    ("ec.matte.refinesoft", "reduceChatter", 10),
+    ("ec.matte.rotobrush", "rotoBrushPropagation/searchRadius", 3),
+    ("ec.matte.rotobrush", "rotoBrushMatte/feather", 13),
+    ("ec.matte.rotobrush", "refineEdgeMatte/smooth", 22),
+    ("ec.matte.rotobrush", "refineEdgeMatte/reduceChatter", 27),
+    ("ec.matte.rotobrush", "refineEdgeMatte/useMotionBlur", 29),
+    ("ec.noise.noisealpha", "noiseOptions/cycleNoise", 8),
+    ("ec.obsolete.basictext", "position", 2),
+    ("ec.key.spill", "suppression", 3),
+    ("ec.perspective.cameratracker", "shotType", 4),
+    ("ec.perspective.cameratracker", "advanced/solveMethod", 12),
+    ("ec.perspective.cameratracker", "advanced/detailedAnalysis", 17),
+    ("ec.perspective.cameratracker", "advanced/autoDeletePoints", 18),
+    ("ec.perspective.cccylinder", "rotationX", 9),
+    ("ec.perspective.cccylinder", "render", 13),
+    ("ec.perspective.cccylinder", "lightIntensity", 15),
+    ("ec.perspective.cccylinder", "ambient", 21),
+    ("ec.sim.ccdrizzle", "light/lightIntensity", 10),
+    ("ec.sim.ccdrizzle", "light/lightHeight", 13),
+    ("ec.sim.ccdrizzle", "light/lightDirection", 15),
+    ("ec.sim.ccmrmercury", "blobBirthSize", 15),
+    ("ec.sim.ccmrmercury", "light/lightIntensity", 19),
+    ("ec.sim.ccmrmercury", "light/lightHeight", 22),
+    ("ec.sim.ccmrmercury", "light/lightDirection", 24),
+    ("ec.sim.ccparticlesystems2", "particle/maxOpacity", 24),
+    ("ec.sim.ccparticlesystems2", "particle/birthColor", 27),
+    ("ec.sim.ccrainfall", "transferMode", 16),
+    ("ec.sim.ccrainfall", "extras/randomSeed", 23),
+    ("ec.sim.ccsnowfall", "color", 19),
+    ("ec.sim.ccsnowfall", "transferMode", 26),
+    ("ec.sim.ccsnowfall", "extras/randomSeed", 32),
+    ("ec.stylize.ccblockload", "startCleared", 4),
+    ("ec.stylize.cchextile", "rotate", 6),
+    ("ec.stylize.glow", "colorLooping", 9),
+    ("ec.text.timecode", "timeUnits", 5),
+    ("ec.text.timecode", "textPosition", 9),
+    ("ec.utility.facemeasurements", "headOrientationX", 9),
+    ("ec.utility.facemeasurements", "rightEyebrowRaise", 20),
+    ("ec.utility.facemeasurements", "mouthOffsetX", 26),
+    ("ec.utility.facetrackpoints", "leftEyebrowInner", 10),
+    ("ec.utility.facetrackpoints", "leftEyebrowMiddle", 12),
+    ("ec.utility.facetrackpoints", "leftEyebrowOuter", 14),
+    ("ec.utility.facetrackpoints", "rightEyebrowInner", 24),
+    ("ec.utility.facetrackpoints", "rightEyebrowMiddle", 26),
+    ("ec.utility.facetrackpoints", "rightEyebrowOuter", 28),
+    ("ec.utility.facetrackpoints", "leftEyeInner", 15),
+    ("ec.utility.facetrackpoints", "leftEyeOuter", 21),
+    ("ec.utility.facetrackpoints", "leftPupil", 20),
+    ("ec.utility.facetrackpoints", "rightEyeInner", 29),
+    ("ec.utility.facetrackpoints", "rightEyeOuter", 35),
+    ("ec.utility.facetrackpoints", "rightPupil", 34),
+    ("ec.utility.facetrackpoints", "noseTip", 41),
+    ("ec.utility.facetrackpoints", "leftNostril", 44),
+    ("ec.utility.facetrackpoints", "rightNostril", 46),
+    ("ec.utility.facetrackpoints", "mouthLeft", 49),
+    ("ec.utility.facetrackpoints", "mouthRight", 55),
+    ("ec.utility.facetrackpoints", "mouthTop", 52),
+    ("ec.utility.facetrackpoints", "mouthBottom", 58),
+    ("ec.utility.facetrackpoints", "chin", 84),
+];
+
+/// Effect id, parameter path and the unit After Effects labels the parameter's columns with.
+pub(crate) const UNITS: &[(&str, &str, &str)] = &[
+    ("ec.3d.depthoffield", "focalBias", ""),
+    ("ec.3d.idmatte", "feather", ""),
+    ("ec.audio.flangechorus", "voiceSeparationTime", ""),
+    ("ec.audio.flangechorus", "voicePhaseChange", ""),
+    ("ec.audio.modulator", "modulationRate", ""),
+    ("ec.audio.parametriceq", "band1BoostCut", "percent"),
+    ("ec.audio.parametriceq", "band2BoostCut", "percent"),
+    ("ec.audio.parametriceq", "band3BoostCut", "percent"),
+    ("ec.audio.stereomixer", "leftLevel", "percent"),
+    ("ec.audio.stereomixer", "rightLevel", "percent"),
+    ("ec.audio.stereomixer", "leftPan", "percent"),
+    ("ec.audio.stereomixer", "rightPan", "percent"),
+    ("ec.blur.bilateral", "threshold", ""),
+    ("ec.blur.ccradial", "amount", "pixels"),
+    ("ec.blur.ccradialfast", "amount", ""),
+    ("ec.blur.camerashakedeblur", "strength", "percent"),
+    ("ec.blur.radial", "amount", ""),
+    ("ec.blur.smart", "radius", ""),
+    ("ec.blur.smart", "threshold", ""),
+    ("ec.color.autocolor", "blackClip", "percent"),
+    ("ec.color.autocolor", "whiteClip", "percent"),
+    ("ec.color.autocontrast", "blackClip", "percent"),
+    ("ec.color.autocontrast", "whiteClip", "percent"),
+    ("ec.color.autolevels", "blackClip", "percent"),
+    ("ec.color.autolevels", "whiteClip", "percent"),
+    ("ec.color.brightnesscontrast", "contrast", "pixels"),
+    ("ec.color.cccolorneutralizer", "pinning", ""),
+    ("ec.color.cccolorneutralizer", "blendWOriginal", ""),
+    ("ec.color.changecolor", "lightnessTransform", "pixels"),
+    ("ec.color.changecolor", "saturationTransform", "pixels"),
+    ("ec.color.colorbalance", "shadowRed", "pixels"),
+    ("ec.color.colorbalance", "shadowGreen", "pixels"),
+    ("ec.color.colorbalance", "shadowBlue", "pixels"),
+    ("ec.color.colorbalance", "midRed", "pixels"),
+    ("ec.color.colorbalance", "midGreen", "pixels"),
+    ("ec.color.colorbalance", "midBlue", "pixels"),
+    ("ec.color.colorbalance", "hiRed", "pixels"),
+    ("ec.color.colorbalance", "hiGreen", "pixels"),
+    ("ec.color.colorbalance", "hiBlue", "pixels"),
+    ("ec.color.colorbalancehls", "lightness", "pixels"),
+    ("ec.color.colorbalancehls", "saturation", "pixels"),
+    ("ec.color.colorstabilizer", "sampleSize", "percent"),
+    ("ec.color.gammapedestalgain", "blackStretch", "percent"),
+    ("ec.color.huesaturation", "saturation", "pixels"),
+    ("ec.color.huesaturation", "lightness", "pixels"),
+    ("ec.color.huesaturation", "colorizeSaturation", ""),
+    ("ec.color.huesaturation", "colorizeLightness", "pixels"),
+    ("ec.color.lumetri", "creative/adjustments/fadedFilm", ""),
+    ("ec.color.lumetri", "hslSecondary/refine/denoise", ""),
+    ("ec.color.lumetri", "hslSecondary/refine/blur", ""),
+    ("ec.color.lumetri", "vignette/vignetteMidpoint", ""),
+    ("ec.color.lumetri", "vignette/vignetteFeather", ""),
+    ("ec.color.psarbitrarymap", "phase", "degrees"),
+    ("ec.color.selectivecolor", "details/reds/redsCyan", "percent"),
+    ("ec.color.selectivecolor", "details/reds/redsMagenta", "percent"),
+    ("ec.color.selectivecolor", "details/reds/redsYellow", "percent"),
+    ("ec.color.selectivecolor", "details/reds/redsBlack", "percent"),
+    ("ec.color.selectivecolor", "details/yellows/yellowsCyan", "percent"),
+    ("ec.color.selectivecolor", "details/yellows/yellowsMagenta", "percent"),
+    ("ec.color.selectivecolor", "details/yellows/yellowsYellow", "percent"),
+    ("ec.color.selectivecolor", "details/yellows/yellowsBlack", "percent"),
+    ("ec.color.selectivecolor", "details/greens/greensCyan", "percent"),
+    ("ec.color.selectivecolor", "details/greens/greensMagenta", "percent"),
+    ("ec.color.selectivecolor", "details/greens/greensYellow", "percent"),
+    ("ec.color.selectivecolor", "details/greens/greensBlack", "percent"),
+    ("ec.color.selectivecolor", "details/cyans/cyansCyan", "percent"),
+    ("ec.color.selectivecolor", "details/cyans/cyansMagenta", "percent"),
+    ("ec.color.selectivecolor", "details/cyans/cyansYellow", "percent"),
+    ("ec.color.selectivecolor", "details/cyans/cyansBlack", "percent"),
+    ("ec.color.selectivecolor", "details/blues/bluesCyan", "percent"),
+    ("ec.color.selectivecolor", "details/blues/bluesMagenta", "percent"),
+    ("ec.color.selectivecolor", "details/blues/bluesYellow", "percent"),
+    ("ec.color.selectivecolor", "details/blues/bluesBlack", "percent"),
+    ("ec.color.selectivecolor", "details/magentas/magentasCyan", "percent"),
+    ("ec.color.selectivecolor", "details/magentas/magentasMagenta", "percent"),
+    ("ec.color.selectivecolor", "details/magentas/magentasYellow", "percent"),
+    ("ec.color.selectivecolor", "details/magentas/magentasBlack", "percent"),
+    ("ec.color.selectivecolor", "details/whites/whitesCyan", "percent"),
+    ("ec.color.selectivecolor", "details/whites/whitesMagenta", "percent"),
+    ("ec.color.selectivecolor", "details/whites/whitesYellow", "percent"),
+    ("ec.color.selectivecolor", "details/whites/whitesBlack", "percent"),
+    ("ec.color.selectivecolor", "details/neutrals/neutralsCyan", "percent"),
+    ("ec.color.selectivecolor", "details/neutrals/neutralsMagenta", "percent"),
+    ("ec.color.selectivecolor", "details/neutrals/neutralsYellow", "percent"),
+    ("ec.color.selectivecolor", "details/neutrals/neutralsBlack", "percent"),
+    ("ec.color.selectivecolor", "details/blacks/blacksCyan", "percent"),
+    ("ec.color.selectivecolor", "details/blacks/blacksMagenta", "percent"),
+    ("ec.color.selectivecolor", "details/blacks/blacksYellow", "percent"),
+    ("ec.color.selectivecolor", "details/blacks/blacksBlack", "percent"),
+    ("ec.color.shadowhighlight", "shadowAmount", ""),
+    ("ec.color.shadowhighlight", "highlightAmount", ""),
+    ("ec.color.shadowhighlight", "moreOptions/shadowTonalWidth", ""),
+    ("ec.color.shadowhighlight", "moreOptions/highlightTonalWidth", ""),
+    ("ec.color.shadowhighlight", "moreOptions/blackClip", "percent"),
+    ("ec.color.shadowhighlight", "moreOptions/whiteClip", "percent"),
+    ("ec.distort.bulge", "height", "pixels"),
+    ("ec.distort.bulge", "taperRadius", ""),
+    ("ec.distort.ccbendit", "bend", "pixels"),
+    ("ec.distort.ccbender", "amount", "pixels"),
+    ("ec.distort.ccgriddler", "tileSize", "percent"),
+    ("ec.distort.cctiler", "scale", "percent"),
+    ("ec.distort.upscale", "scale", "percent"),
+    ("ec.distort.magnify", "magnification", "pixels"),
+    ("ec.distort.magnify", "size", "percent"),
+    ("ec.distort.puppet", "refinement", ""),
+    ("ec.distort.ripple", "radius", ""),
+    ("ec.distort.ripple", "speed", "percent"),
+    ("ec.distort.transform", "opacity", ""),
+    ("ec.distort.turbulentdisplace", "complexity", "percent"),
+    ("ec.distort.twirl", "radius", ""),
+    ("ec.distort.wavewarp", "width", "percent"),
+    ("ec.distort.wavewarp", "speed", "pixels"),
+    ("ec.generate.fourcolor", "blend", "percent"),
+    ("ec.generate.advancedlightning", "coreSettings/coreRadius", ""),
+    ("ec.generate.advancedlightning", "glowSettings/glowRadius", "percent"),
+    ("ec.generate.advancedlightning", "alphaObstacle", "pixels"),
+    ("ec.generate.ccgluegun", "reflection", ""),
+    ("ec.generate.cclightburst", "rayLength", ""),
+    ("ec.generate.cclightsweep", "edgeThickness", ""),
+    ("ec.generate.ccthreads", "coverage", ""),
+    ("ec.generate.ccthreads", "shadowing", ""),
+    ("ec.generate.ccthreads", "texture", ""),
+    ("ec.generate.checkerboard", "width", "percent"),
+    ("ec.generate.checkerboard", "height", "percent"),
+    ("ec.generate.grid", "width", "percent"),
+    ("ec.generate.grid", "height", "percent"),
+    ("ec.generate.lensflare", "flareBrightness", "percent"),
+    ("ec.vr.chromaticaberrations", "falloff", ""),
+    ("ec.vr.denoise", "noiseLevel", ""),
+    ("ec.vr.digitalglitch", "colorDistortion", ""),
+    ("ec.vr.fractalnoise", "subSettings/subInfluence", ""),
+    ("ec.vr.glow", "luminanceThreshold", ""),
+    ("ec.vr.planetosphere", "feather", ""),
+    ("ec.vr.sharpen", "sharpenAmount", ""),
+    ("ec.key.advancedspill", "suppression", "percent"),
+    ("ec.key.advancedspill", "ultraSettings/tolerance", ""),
+    ("ec.key.advancedspill", "ultraSettings/desaturate", ""),
+    ("ec.key.advancedspill", "ultraSettings/spillRange", ""),
+    ("ec.key.advancedspill", "ultraSettings/spillColorCorrection", ""),
+    ("ec.key.advancedspill", "ultraSettings/lumaCorrection", ""),
+    ("ec.key.ccsimplewireremoval", "thickness", ""),
+    ("ec.key.keycleaner", "additionalEdgeRadius", ""),
+    ("ec.key.keycleaner", "alphaContrast", "percent"),
+    ("ec.matte.refinehard", "feather", ""),
+    ("ec.matte.refinehard", "increaseDecontaminationRadius", ""),
+    ("ec.matte.refinesoft", "smooth", ""),
+    ("ec.matte.refinesoft", "feather", ""),
+    ("ec.matte.refinesoft", "shiftEdge", "percent"),
+    ("ec.matte.refinesoft", "decontamination/increaseDecontaminationRadius", ""),
+    ("ec.matte.rotobrush", "rotoBrushPropagation/searchRadius", ""),
+    ("ec.matte.rotobrush", "rotoBrushMatte/feather", ""),
+    ("ec.matte.rotobrush", "rotoBrushMatte/shiftEdge", "percent"),
+    ("ec.matte.rotobrush", "refineEdgeMatte/smooth", ""),
+    ("ec.matte.rotobrush", "refineEdgeMatte/feather", ""),
+    ("ec.matte.rotobrush", "refineEdgeMatte/shiftEdge", "percent"),
+    ("ec.matte.rotobrush", "refineEdgeMatte/decontamination/increaseDecontaminationRadius", ""),
+    ("ec.matte.simplechoker", "chokeMatte", "pixels"),
+    ("ec.noise.fractal", "transform/scale", "percent"),
+    ("ec.noise.fractal", "transform/scaleWidth", "percent"),
+    ("ec.noise.fractal", "transform/scaleHeight", "percent"),
+    ("ec.noise.fractal", "complexity", "percent"),
+    ("ec.noise.fractal", "subSettings/subInfluence", ""),
+    ("ec.noise.turbulent", "transform/scale", "percent"),
+    ("ec.noise.turbulent", "transform/scaleWidth", "percent"),
+    ("ec.noise.turbulent", "transform/scaleHeight", "percent"),
+    ("ec.noise.turbulent", "complexity", "percent"),
+    ("ec.noise.turbulent", "subSettings/subInfluence", ""),
+    ("ec.key.colorkey", "edgeFeather", ""),
+    ("ec.obsolete.lightning", "branchAngle", ""),
+    ("ec.key.luma", "edgeFeather", ""),
+    ("ec.blur.reduceflicker", "softness", ""),
+    ("ec.perspective.cameratracker", "trackPointSize", "percent"),
+    ("ec.perspective.cameratracker", "targetSize", "percent"),
+    ("ec.perspective.cccylinder", "lightHeight", "pixels"),
+    ("ec.sim.ccbubbles", "bubbleSize", "percent"),
+    ("ec.sim.ccdrizzle", "displacement", ""),
+    ("ec.sim.ccdrizzle", "light/lightHeight", "pixels"),
+    ("ec.sim.ccmrmercury", "longevity", ""),
+    ("ec.sim.ccmrmercury", "blobInfluence", "percent"),
+    ("ec.sim.ccmrmercury", "light/lightHeight", "pixels"),
+    ("ec.sim.ccmrmercury", "shading/metal", ""),
+    ("ec.sim.ccparticlesystems2", "birthRate", ""),
+    ("ec.sim.ccparticlesystems2", "longevity", ""),
+    ("ec.sim.ccparticlesystems2", "physics/gravity", "pixels"),
+    ("ec.sim.ccrainfall", "windVariation", ""),
+    ("ec.sim.ccrainfall", "opacity", ""),
+    ("ec.sim.ccsnowfall", "sizeVariation", ""),
+    ("ec.sim.ccsnowfall", "speedVariation", ""),
+    ("ec.sim.ccsnowfall", "windVariation", ""),
+    ("ec.sim.ccsnowfall", "wiggle/wiggleAmount", ""),
+    ("ec.sim.ccsnowfall", "wiggle/wiggleAmountVariation", ""),
+    ("ec.sim.ccsnowfall", "wiggle/wiggleFrequencyVariation", ""),
+    ("ec.sim.ccsnowfall", "opacity", ""),
+    ("ec.sim.ccstarburst", "speed", "percent"),
+    ("ec.sim.ccstarburst", "size", "pixels"),
+    ("ec.stylize.ccblockload", "completion", ""),
+    ("ec.stylize.ccburnfilm", "burn", ""),
+    ("ec.stylize.cchextile", "smearing", ""),
+    ("ec.stylize.cckaleida", "size", "percent"),
+    ("ec.stylize.ccvignette", "pinHighlights", ""),
+    ("ec.stylize.cartoon", "detailThreshold", ""),
+    ("ec.stylize.cartoon", "fill/shadingSmoothness", ""),
+    ("ec.stylize.cartoon", "edge/edgeSoftness", ""),
+    ("ec.stylize.cartoon", "advanced/edgeBlackLevel", ""),
+    ("ec.stylize.glow", "colorLoops", "percent"),
+    ("ec.stylize.roughenedges", "stretch", "pixels"),
+    ("ec.time.pixelmotionblur", "vectorDetail", ""),
+    ("ec.transition.blockdissolve", "blockWidth", "percent"),
+    ("ec.transition.blockdissolve", "blockHeight", "percent"),
+    ("ec.transition.ccgridwipe", "border", "pixels"),
+    ("ec.transition.ccgridwipe", "tiles", "percent"),
+    ("ec.transition.cclinesweep", "completion", ""),
+    ("ec.transition.ccscalewipe", "stretch", "pixels"),
+    ("ec.transition.venetian", "width", "percent"),
+    ("ec.transition.venetian", "feather", ""),
+    ("ec.utility.cineon", "highlightRolloff", ""),
+    ("ec.utility.facemeasurements", "headOrientationX", "degrees"),
+    ("ec.utility.facemeasurements", "headOrientationY", "degrees"),
+    ("ec.utility.facemeasurements", "headOrientationZ", "degrees"),
+    ("ec.utility.facemeasurements", "leftEyebrowRaise", "percent"),
+    ("ec.utility.facemeasurements", "rightEyebrowRaise", "percent"),
+    ("ec.utility.facemeasurements", "mouthOffsetX", "percent"),
+    ("ec.utility.facemeasurements", "mouthOffsetY", "percent"),
+];
diff --git a/crates/engine/src/psd_import.rs b/crates/engine/src/interchange/psd_import.rs
similarity index 100%
rename from crates/engine/src/psd_import.rs
rename to crates/engine/src/interchange/psd_import.rs
diff --git a/crates/engine/src/vector.rs b/crates/engine/src/interchange/vector.rs
similarity index 99%
rename from crates/engine/src/vector.rs
rename to crates/engine/src/interchange/vector.rs
index 3c349a7df..324d3a82a 100644
--- a/crates/engine/src/vector.rs
+++ b/crates/engine/src/interchange/vector.rs
@@ -160,7 +160,7 @@ fn clipped_items(ids: &mut Ids, s: &effectcraft_svg::Shape, m: Affine, clips: &[
 /// Blend Mode). Top of the paint order first.
 ///
 /// Clipping groups (PDF / Illustrator clipping masks): shapes inside them are intersected with
-/// the clip paths through Merge Paths ▸ Intersect (see [`clipped_items`]). Clips enclosing the
+/// the clip paths through Merge Paths ▸ Intersect (see `clipped_items`). Clips enclosing the
 /// whole document are layer masks instead ([`vector_clip_masks`], used by
 /// [`shapes_from_vector`]). Images are skipped (Layer ▸ Create makes them footage layers, see
 /// [`split_at_images`]); soft masks are not converted.
diff --git a/crates/engine/src/xml_project.rs b/crates/engine/src/interchange/xml_project.rs
similarity index 100%
rename from crates/engine/src/xml_project.rs
rename to crates/engine/src/interchange/xml_project.rs
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 83024dd81..0cc9a7189 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -10,45 +10,21 @@
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
-pub mod autosave;
-pub mod camera_track;
-pub mod commands;
-pub mod config;
-pub mod demo;
-pub mod doc_path;
-pub mod footage_check;
-pub mod footage_reload;
-pub mod guard;
+mod analysis;
+mod background;
+pub mod cmd;
+mod footage;
 pub mod history;
-pub mod jobs;
-pub mod learn;
-pub mod links;
-pub mod logging;
-pub mod mask_track;
-pub mod media_browser;
-pub mod media_cache;
+mod home;
+mod interchange;
 pub mod menus;
-pub mod models;
-pub mod offload;
-pub mod perf;
-pub mod prefs;
+mod output_guard;
 pub mod preview;
-pub mod psd_import;
-pub mod remote;
 pub mod render_queue;
-pub mod roto;
 pub mod scriptui;
-pub mod sequence;
-mod session_settings;
-pub mod shortcuts;
-pub mod storage;
-pub mod sysinfo;
-pub mod templates;
-pub mod tracking;
-pub mod vector;
+mod settings;
+mod system;
 pub mod viewer;
-pub mod warp;
-pub mod xml_project;
 
 use std::sync::Arc;
 
@@ -59,7 +35,17 @@ use effectcraft_time::Tick;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-pub use commands::{CommandSpec, command_specs, find as find_command};
+pub use analysis::camera_track;
+pub use analysis::mask_track;
+pub use analysis::models;
+pub use analysis::roto;
+pub use analysis::tracking;
+pub use analysis::warp;
+pub use background::jobs;
+pub use background::offload;
+pub use background::remote;
+pub use cmd as commands;
+pub use cmd::{CommandSpec, command_specs, find as find_command};
 pub use effectcraft_color as color;
 pub use effectcraft_effects as effects;
 pub use effectcraft_geom as geom;
@@ -71,324 +57,46 @@ pub use effectcraft_segment as segment;
 pub use effectcraft_text as text;
 pub use effectcraft_time as time;
 pub use effectcraft_track as track;
+pub use footage::doc_path;
+pub use footage::footage_check;
+pub use footage::footage_reload;
+pub use footage::media_browser;
+pub use footage::media_cache;
+pub use footage::sequence;
 pub use history::{Branch, History, HistoryNode};
+pub use home::demo;
+pub use home::learn;
+pub use home::links;
+pub use home::templates;
+pub use interchange::psd_import;
+pub use interchange::vector;
+pub use interchange::xml_project;
+use interchange::{keyframe_text, keyframe_text_effects};
 pub use render_queue::{ExportJob, ExportResult, Exporter, JobState};
+pub use settings::autosave;
+pub use settings::config;
+pub use settings::prefs;
+pub use settings::shortcuts;
+pub use system::guard;
+pub use system::logging;
+pub use system::perf;
+pub use system::storage;
+pub use system::sysinfo;
 
-#[derive(Debug, thiserror::Error)]
-pub enum EngineError {
-    #[error("unknown command `{0}`")]
-    UnknownCommand(String),
-    #[error("command `{0}` is not available right now: {1}")]
-    Disabled(String, String),
-    #[error("invalid parameters for `{cmd}`: {msg}")]
-    BadParams { cmd: String, msg: String },
-    #[error("no active composition")]
-    NoComp,
-    /// A `comp` reference (name or id) that names no composition.
-    #[error("no composition {0}")]
-    NoSuchComp(String),
-    #[error("{0}")]
-    Project(#[from] effectcraft_project::ProjectError),
-    #[error("{0}")]
-    Other(String),
-}
+mod doc_state;
+mod error;
+mod event;
+mod fonts;
+mod services;
+mod session;
 
-pub type Result<T> = std::result::Result<T, EngineError>;
-
-/// Host services (file access) injected by the frontend.
-pub trait Services: Send + Sync {
-    fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>>;
-    fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()>;
-    /// Whether a file exists (the background footage check after open).
-    fn exists(&self, path: &str) -> bool {
-        std::path::Path::new(path).exists()
-    }
-    /// A file's size and modification time (nanoseconds since 1970), to notice that it changed
-    /// on disk (Settings ▸ Import ▸ Reload Footage Changed on Disk); `None` when it can't be read.
-    fn stamp(&self, path: &str) -> Option<(u64, u128)> {
-        let meta = std::fs::metadata(path).ok()?;
-        let modified = meta.modified().ok()?.duration_since(std::time::UNIX_EPOCH).ok()?;
-        Some((meta.len(), modified.as_nanos()))
-    }
-    /// Keep a file the app made for itself (footage extracted from a template): like
-    /// [`Services::write_file`], creating its folder, but never offered as a download (web: it
-    /// goes to browser storage only).
-    fn store_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
-        if let Some(d) = std::path::Path::new(path).parent().filter(|d| !d.as_os_str().is_empty()) {
-            let _ = std::fs::create_dir_all(d);
-        }
-        self.write_file(path, data)
-    }
-    /// The files in folder `dir` (full paths; no folders, no hidden files), for image-sequence
-    /// detection on import. Empty when it can't be read.
-    fn list_dir(&self, dir: &str) -> Vec<String> {
-        let Ok(rd) = std::fs::read_dir(if dir.is_empty() { "." } else { dir }) else { return vec![] };
-        rd.filter_map(|e| e.ok())
-            .filter(|e| e.file_type().is_ok_and(|t| t.is_file()) && !e.file_name().to_string_lossy().starts_with('.'))
-            .map(|e| e.path().to_string_lossy().to_string())
-            .collect()
-    }
-    /// Whether `path` is a folder (dropped or picked folders import their files).
-    fn is_dir(&self, path: &str) -> bool {
-        std::path::Path::new(path).is_dir()
-    }
-}
-
-/// Native filesystem.
-pub struct FsServices;
-impl Services for FsServices {
-    fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>> {
-        std::fs::read(path)
-    }
-    fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
-        config::atomic_write(std::path::Path::new(path), data)
-    }
-}
-
-/// Imports media files into the project (implemented by the media layer).
-pub trait Importer: Send + Sync {
-    /// Probe one file and return footage metadata. Image sequences are the engine's
-    /// ([`sequence`]): it groups numbered stills and probes their first file here.
-    fn probe(&self, path: &str) -> std::result::Result<effectcraft_project::Footage, String>;
-    /// A footage file's bytes are now at `path` (extracted from a template): hosts whose media
-    /// layer reads from memory (the browser) register them; file-based ones need nothing.
-    fn register(&self, _path: &str, _data: &[u8]) {}
-    /// An image sequence's other frames (its first was probed) are footage now: hosts whose
-    /// media layer reads from memory (the browser) register them; file-based ones need nothing.
-    fn add_frames(&self, _paths: &[String]) {}
-}
-
-/// A keyframe reference: layer, property uid, key time (layer time).
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub struct KeyRef {
-    pub layer: LayerId,
-    pub prop: Uid,
-    pub time: Tick,
-}
-
-/// A keyframe drag in progress (`keys.move` steps sharing a merge key): the selection it
-/// started from and the total offset so far, so every step is applied to the keys as they were
-/// before the drag. A key passed over on the way is never overwritten; only the drop position
-/// counts, as in After Effects.
-#[derive(Clone, Debug)]
-pub struct KeyMove {
-    pub merge: String,
-    pub from: Vec<KeyRef>,
-    pub total: Tick,
-}
-
-/// Keyframes of one property on the keyframe clipboard.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct KeyClip {
-    pub layer: LayerId,
-    /// Match-id path relative to the layer (`transform/position`), portable between layers.
-    pub path: String,
-    /// Keys with times relative to the earliest copied key (layer time).
-    pub keys: Vec<effectcraft_keyframe::Keyframe>,
-}
-
-/// A selected mask vertex: layer, mask group uid, vertex index.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub struct VertexRef {
-    pub layer: LayerId,
-    pub mask: Uid,
-    pub index: usize,
-}
-
-/// One composition's selection. The active comp's copy lives in [`EditorState::selected_layers`]
-/// (and the property, key, and vertex lists); every other comp keeps its own here (#1001).
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-pub struct CompSelection {
-    pub layers: Vec<LayerId>,
-    pub props: Vec<(LayerId, Uid)>,
-    pub keys: Vec<KeyRef>,
-    pub vertices: Vec<VertexRef>,
-}
-
-impl CompSelection {
-    fn is_empty(&self) -> bool {
-        self.layers.is_empty() && self.props.is_empty() && self.keys.is_empty() && self.vertices.is_empty()
-    }
-}
-
-/// Editing state that commands depend on (headless-relevant, serde for agents).
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
-pub struct EditorState {
-    pub active_comp: Option<ItemId>,
-    /// Open compositions (viewer/timeline tabs), in tab order.
-    pub open_comps: Vec<ItemId>,
-    /// Compositions that were active before the current one, most recent first (Shift+Esc).
-    #[serde(default)]
-    pub recent_comps: Vec<ItemId>,
-    /// Current time per comp (the CTI).
-    pub times: std::collections::BTreeMap<ItemId, Tick>,
-    /// Layer selection of the active comp. Other comps' selections are in [`Self::comp_selections`].
-    pub selected_layers: Vec<LayerId>,
-    /// Selections of comps that are not active, keyed by comp id (#1001).
-    #[serde(default)]
-    pub comp_selections: std::collections::BTreeMap<ItemId, CompSelection>,
-    /// Selected properties / groups (by uid) of selected layers.
-    pub selected_props: Vec<(LayerId, Uid)>,
-    pub selected_keys: Vec<KeyRef>,
-    pub project_selection: Vec<ItemId>,
-    /// Layer clipboard (serialized layers) and keyframe clipboard.
-    #[serde(skip)]
-    pub clipboard: Vec<Layer>,
-    /// Copied keyframes (times relative to the earliest copied key).
-    #[serde(skip)]
-    pub key_clipboard: Vec<KeyClip>,
-    /// The last copy was keyframes (Paste pastes keys at the CTI).
-    #[serde(skip)]
-    pub clip_is_keys: bool,
-    /// Values of selected unanimated properties (match path, value), copied with Edit ▸ Copy;
-    /// Paste sets the same properties of the selected layers.
-    #[serde(skip)]
-    pub value_clipboard: Vec<(String, effectcraft_keyframe::Value)>,
-    /// Copied effect instances, with comp-time key offsets from the earliest copied key.
-    /// Paste adds them to the selected layers at the destination comp's CTI.
-    #[serde(skip)]
-    pub effect_clipboard: Vec<effectcraft_project::PropGroup>,
-    /// Copied shape items (Edit ▸ Copy with groups, paths, paints or path operations selected in
-    /// a shape layer's Contents); Paste adds them to the selected shape layers.
-    #[serde(skip)]
-    pub contents_clipboard: Vec<effectcraft_project::PropGroup>,
-    /// Selected mask vertices (viewer Selection tool / pen).
-    #[serde(default)]
-    pub selected_vertices: Vec<VertexRef>,
-    pub snapping: bool,
-    /// Tools bar ▸ Snapping options (which features snap, Snap Edges Extended).
-    #[serde(default)]
-    pub snap_features: viewer::SnapFeatures,
-    /// Last applied effect id (Effect ▸ last effect).
-    pub last_effect: Option<String>,
-    /// Viewer region of interest `[x, y, w, h]` in comp pixels (Composition ▸ Crop Comp to Region
-    /// of Interest).
-    #[serde(default)]
-    pub region_of_interest: Option<[f64; 4]>,
-    /// Property-link clipboard (Edit ▸ Copy with Property Links / Copy Expression Only).
-    #[serde(skip)]
-    pub link_clipboard: Option<LinkClip>,
-    /// File ▸ Interpret Footage ▸ Remember Interpretation.
-    #[serde(skip)]
-    pub interpretation: Option<effectcraft_project::Footage>,
-    /// Viewer 3D view per comp (Active Camera / Front / … / Custom View 3 and edited view cameras).
-    #[serde(default)]
-    pub views3d: std::collections::BTreeMap<ItemId, effectcraft_render::three_d::Views3D>,
-    /// Tracker panel ▸ Current Track: (tracked layer, tracker group uid) in the active comp.
-    #[serde(default)]
-    pub current_track: Option<(LayerId, Uid)>,
-    /// Tracker panel ▸ Method in mask mode (Track Mask).
-    #[serde(default)]
-    pub mask_track_method: mask_track::MaskMethod,
-    /// 3D Camera Tracker: the selected track points (ids) in the viewer.
-    #[serde(default)]
-    pub camera_points: Vec<u32>,
-    /// Mask Interpolation panel options.
-    #[serde(default)]
-    pub mask_interp: commands::mask_interp::MaskInterpOptions,
-    /// Paint and Brushes panel options (Brush, Clone Stamp and Eraser tools).
-    #[serde(default)]
-    pub paint: commands::paint::PaintOptions,
-    /// Roto Brush and Refine Edge tool options.
-    #[serde(default)]
-    pub roto: roto::RotoOptions,
-    /// Puppet tool options for new meshes.
-    #[serde(default)]
-    pub puppet: commands::puppet::PuppetOptions,
-    /// The shape tools' and the Pen's options (Tool Creates Shape / Mask, Fill and Stroke).
-    #[serde(default)]
-    pub shape_tool: commands::shape_tool::ShapeTool,
-    /// View ▸ Switch View Layout: 1, 2 or 4 views side by side in the Composition viewer.
-    #[serde(default = "one_view")]
-    pub view_layout: u8,
-    /// View ▸ Switch View Layout ▸ Share View Options (grid, guides… in every view).
-    #[serde(default)]
-    pub share_view_options: bool,
-    /// Layer ▸ Mask ▸ Hide Locked Masks (viewer outlines).
-    #[serde(default)]
-    pub hide_locked_masks: bool,
-    /// On-canvas text editing (Type tool): the edited layer, selection and insertion style.
-    #[serde(default)]
-    pub text_edit: Option<commands::text_edit::TextEdit>,
-    /// Text copied while editing (with its formatting), for Paste / Paste Text Formatting Only.
-    #[serde(skip)]
-    pub text_clipboard: Option<effectcraft_keyframe::TextDoc>,
-    /// Composition viewer display options (Show Channel, exposure, snapshot, Fast Previews).
-    #[serde(default)]
-    pub viewer: commands::viewer_cmds::ViewOptions,
-    /// Essential Graphics panel ▸ Primary composition (`None` = the active comp).
-    #[serde(default)]
-    pub essential_primary: Option<ItemId>,
-    /// Essential Graphics panel ▸ Solo Supported Properties (the timeline shows only properties
-    /// Essential Graphics can expose).
-    #[serde(default)]
-    pub essential_solo: bool,
-    /// File ▸ Watch Folder: the folder being watched for projects to render (frontends call
-    /// `file.watchFolder.poll` periodically while it is set).
-    #[serde(default)]
-    pub watch_folder: Option<String>,
-    /// The Footage panel: the footage shown, its time and In/Out marks (source time).
-    #[serde(default)]
-    pub footage_panel: Option<commands::footage_panel::FootageView>,
-    /// Media Browser: the folder shown and the favourites.
-    #[serde(default)]
-    pub media_browser: media_browser::BrowserState,
-    /// Content-Aware Fill panel settings.
-    #[serde(default)]
-    pub content_fill: commands::content_fill::FillSettings,
-    /// View ▸ Split with New Locked Viewer: the second viewer's comp and 3D view.
-    #[serde(default)]
-    pub locked_viewer: Option<commands::viewer_cmds::LockedViewer>,
-}
-
-fn one_view() -> u8 {
-    1
-}
-
-/// `t` as a current time of `comp`: a frame within its duration.
-fn comp_frame_at(comp: &Comp, t: Tick) -> Tick {
-    comp.frame_rate.snap_nearest(t.min(comp.duration - comp.frame_duration()).max(Tick::ZERO))
-}
-
-/// What Copy with Property Links / Copy Expression Only put on the clipboard.
-#[derive(Clone, Debug, PartialEq)]
-pub enum LinkClip {
-    /// Expressions that link back to the source properties: (match path, expression text).
-    Links { relative: bool, links: Vec<(String, String)> },
-    /// Expressions only: (match path, expression).
-    Expressions(Vec<(String, effectcraft_project::Expression)>),
-}
-
-/// Events for frontends (drained each frame).
-#[derive(Clone, Debug, PartialEq, Serialize)]
-pub enum Event {
-    ProjectChanged {
-        revision: u64,
-    },
-    Toast {
-        message: String,
-        error: bool,
-    },
-    OpenComp(ItemId),
-    OpenUrl(String),
-    /// A frontend-only command (viewer zoom, panels, dialogs…) ran: the UI performs it. Headless
-    /// sessions ignore these.
-    Frontend {
-        command: String,
-        params: Value,
-    },
-    /// Drop cached frames / renders (Edit ▸ Purge).
-    PurgeCaches,
-    /// Put an image on the system clipboard (Composition ▸ Copy Frame to Clipboard): `rgba` is
-    /// `width` × `height` straight-alpha RGBA8 rows. Headless sessions ignore it; the pixels are
-    /// not serialized.
-    CopyImage {
-        width: u32,
-        height: u32,
-        #[serde(skip)]
-        rgba: Vec<u8>,
-    },
-}
+pub use cmd::{animation_presets, text_presets};
+pub use doc_state::{CompSelection, EditorState, KeyClip, KeyMove, KeyRef, LinkClip, VertexRef};
+pub use error::{EngineError, Result};
+pub use event::Event;
+pub use fonts::{FontRow, font_features, font_menu, font_preview, font_styles, text_families};
+pub use services::{FsServices, Importer, Services};
+pub use session::upgrade_effects;
 
 pub struct Session {
     pub project: Arc<Project>,
@@ -456,6 +164,10 @@ pub struct Session {
     pub journal: Vec<(String, Value)>,
     /// Processed-layer pixels reused across frames and edits (content-keyed, never stale).
     pub layer_cache: Arc<LayerCache>,
+    /// The last Cryptomatte pick probe (see [`Session::crypto_probe_job`]). Public only so that
+    /// other crates can build a `Session { .. }`; its type is crate-private.
+    #[doc(hidden)]
+    pub crypto_probe: Arc<std::sync::Mutex<commands::CryptoProbeSlot>>,
     /// The persistent disk cache (Settings ▸ Media & Disk Cache), when enabled.
     pub disk_cache: Option<Arc<effectcraft_render::disk_cache::DiskCache>>,
     /// Settings (Preferences).
@@ -496,6 +208,8 @@ pub struct Session {
     pub key_move: Option<KeyMove>,
     /// Reads the system's memory in the background for [`Session::memory_tick`].
     pub memory_watch: sysinfo::MemoryWatch,
+    /// Reads the disk cache's free disk space in the background for [`Session::memory_tick`].
+    pub disk_watch: sysinfo::DiskWatch,
     /// Switches Affect Nested Comps as last applied (a change empties the layer cache).
     pub applied_nested_switches: Option<bool>,
     /// Runs renders and analyses off the UI thread where there are no threads (the web app's
@@ -528,8 +242,6 @@ pub struct Session {
     /// Each footage file's size and modification time when last seen (Settings ▸ Import ▸
     /// Reload Footage Changed on Disk, [`footage_reload`]).
     pub footage_stamps: std::collections::HashMap<String, footage_reload::Stamp>,
-    /// The stamps being taken on a worker thread ([`footage_reload::start_scan`]).
-    pub footage_scan: Option<footage_reload::Scan>,
     /// The disk cache's footage salt and the footage it was taken for ([`Session::refresh_disk_salt`]).
     pub disk_salt: Option<(u64, u64)>,
     /// How many script-issued commands are running ([`Session::execute_for_script`]): while one
@@ -564,6 +276,10 @@ pub type ScriptRunner = fn(&mut Session, &ScriptRequest) -> Value;
 pub type PluginLoader = fn(&[u8], &str) -> std::result::Result<Value, String>;
 
 impl Default for Session {
+    /// A new unsaved session: a default project that is both current and saved, no path, no
+    /// active jobs, the plain `FsServices`/`NoFootage` defaults, default preferences and keymaps,
+    /// empty history, events and journal, and a fresh process-wide IME stamp (`u64::MAX` when the
+    /// allocator is exhausted).
     fn default() -> Self {
         let project = Arc::new(Project::default());
         Session {
@@ -600,6 +316,7 @@ impl Default for Session {
             events: vec![],
             journal: vec![],
             layer_cache: Arc::new(LayerCache::default()),
+            crypto_probe: Default::default(),
             disk_cache: None,
             prefs: prefs::Prefs::default(),
             prefs_revision: 0,
@@ -617,6 +334,7 @@ impl Default for Session {
             sys_memory: None,
             key_move: None,
             memory_watch: Default::default(),
+            disk_watch: Default::default(),
             applied_nested_switches: None,
             offload: None,
             offloaded: vec![],
@@ -632,935 +350,12 @@ impl Default for Session {
             stored_paths: Default::default(),
             footage_stamps: Default::default(),
             disk_salt: None,
-            footage_scan: None,
             script_calls: ScriptCalls::default(),
         }
     }
 }
 
-impl Session {
-    pub fn new() -> Session {
-        Session::default()
-    }
-
-    /// 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 let Err(why) = (spec.enabled)(self) {
-            // Explicit targets (agents, scripts) don't need a UI selection.
-            let explicit = (["layer", "layers", "prop", "keys"].iter().any(|k| params.get(k).is_some()) && commands::has_comp(self).is_ok())
-                || ["item", "items"].iter().any(|k| params.get(k).is_some())
-                // An explicit composition (the enablement looks at the active one).
-                || params.get("comp").is_some_and(|c| !c.is_null() && self.resolve_comp(Some(c)).is_ok());
-            if !explicit {
-                return Err(EngineError::Disabled(id.to_string(), why));
-            }
-        }
-        // Last-resort guard: a panicking command reports an error instead of crashing the app.
-        let r = guard::guarded(&format!("command `{id}`"), || (spec.run)(self, &params))?;
-        self.learn_observe(id, &params);
-        if spec.journal {
-            self.journal.push((id.to_string(), params));
-            if self.journal.len() > 10_000 {
-                self.journal.drain(..1000);
-            }
-        }
-        Ok(r)
-    }
-
-    /// [`Session::execute`] for agents and scripts (MCP, CLI, control channel): unknown top-level
-    /// parameters are rejected with the accepted keys instead of being silently ignored.
-    pub fn execute_checked(&mut self, id: &str, params: Value) -> Result<Value> {
-        let spec = commands::find(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
-        commands::check_params(spec, &params)?;
-        self.execute(id, params)
-    }
-
-    /// [`Session::execute`] for a command a script asked for (the JavaScript engine's
-    /// `app.run`, ScriptUI callbacks…). The command and everything it runs count as the script's:
-    /// it may not change the settings that limit scripts (Settings ▸ Scripting & Expressions ▸
-    /// Application Scripting), which only the user can, from the UI, CLI or control channel.
-    pub fn execute_for_script(&mut self, id: &str, params: Value) -> Result<Value> {
-        self.script_calls.0 = self.script_calls.0.saturating_add(1);
-        let r = self.execute(id, params);
-        self.script_calls.0 = self.script_calls.0.saturating_sub(1);
-        r
-    }
-
-    /// Whether the command running was issued by a script ([`Session::execute_for_script`]).
-    pub fn running_for_script(&self) -> bool {
-        self.script_calls.0 > 0
-    }
-
-    pub fn is_enabled(&self, id: &str) -> bool {
-        commands::find(id).is_some_and(|c| (c.enabled)(self).is_ok())
-    }
-
-    /// Apply an undoable edit. `merge`: consecutive edits with the same key fold into one step.
-    ///
-    /// Every edit is an external boundary for the on-canvas text editor: if it replaced the
-    /// document the editor is showing, the selection is clamped and the editor gets a fresh IME
-    /// epoch. The editor's own typing goes through `edit_text_doc`, which owns that
-    /// document and must not treat its own keystrokes as a replacement.
-    pub fn edit<T>(&mut self, label: &str, merge: Option<&str>, f: impl FnOnce(&mut Project, &mut EditorState) -> Result<T>) -> Result<T> {
-        let edited = commands::text_edit::active_editor_snapshot(self);
-        let out = self.edit_inner(label, merge, f)?;
-        commands::text_edit::after_external_change(self, edited.as_ref());
-        Ok(out)
-    }
-
-    /// [`Session::edit`] for the on-canvas editor's own text changes. Its document is the one
-    /// the editor owns, so a change here is typing, not a replacement behind the IME's back.
-    pub(crate) fn edit_text_doc<T>(&mut self, label: &str, merge: Option<&str>, f: impl FnOnce(&mut Project, &mut EditorState) -> Result<T>) -> Result<T> {
-        self.edit_inner(label, merge, f)
-    }
-
-    fn edit_inner<T>(&mut self, label: &str, merge: Option<&str>, f: impl FnOnce(&mut Project, &mut EditorState) -> Result<T>) -> Result<T> {
-        let before = self.project.clone();
-        let mut p = (*self.project).clone();
-        let mut st = self.state.clone();
-        let r = f(&mut p, &mut st)?;
-        // Layer styles: one Global Light per comp, whichever layer edited it.
-        effectcraft_project::styles::sync_global_light(&before, &mut p);
-        // Essential Properties of precomp layers follow their comps' Essential Graphics.
-        effectcraft_project::essential::sync_project(&before, &mut p);
-        // Warp Stabilizer analyses made from other frames are cleared (and queued again).
-        for w in warp::invalidate(&before, &mut p) {
-            if !self.warp_pending.contains(&w) {
-                self.warp_pending.push(w);
-            }
-        }
-        // So are 3D Camera Tracker tracks (and solves made with other settings).
-        for w in camera_track::invalidate(&before, &mut p) {
-            if !self.camera_pending.contains(&w) {
-                self.camera_pending.push(w);
-            }
-        }
-        // Roto Brush Input Keys follow the frames; edited instances propagate again.
-        for r in roto::sync(&before, &mut p) {
-            if !self.roto_pending.contains(&r) {
-                self.roto_pending.push(r);
-            }
-        }
-        // Nothing changed (a value set to what it already was): no undo step, not modified.
-        if p.same_content(&before) {
-            self.state = st;
-            return Ok(r);
-        }
-        let same = merge.is_some() && merge.map(str::to_string) == self.history.merge_key;
-        if !same {
-            // Undone steps aren't lost: they stay in the History panel as a branch.
-            let levels = self.prefs.general.undo_levels.max(1) as usize;
-            self.history.record(label, before, levels);
-        } else {
-            self.history.abandon_redo(&before);
-        }
-        self.history.merge_key = merge.map(str::to_string);
-        self.project = Arc::new(p);
-        self.state = st;
-        self.bump();
-        Ok(r)
-    }
-
-    /// Note a change to the on-canvas editor's committed text or session.
-    ///
-    /// Frontends compare this with [`commands::text_edit::ime_stamp_revision`]; an unrelated
-    /// project change must not advance it.
-    pub(crate) fn note_text_edit_change(&mut self) {
-        // Checked process-wide allocation: a stamp is never wrapped or reused. On exhaustion
-        // keep the previous value; an unavailable before/after pair then compares equal and
-        // earns no receipt instead of accepting a stale revision.
-        if let Some(revision) = commands::text_edit::next_ime_revision() {
-            self.ime_revision = self.ime_revision.max(revision);
-        }
-    }
-
-    pub fn bump(&mut self) {
-        self.revision += 1;
-        // Back at the saved state (undo, redo, a history jump or a rolled-back batch).
-        if Arc::ptr_eq(&self.project, &self.saved_project) {
-            self.saved_revision = self.revision;
-        }
-        self.refresh_disk_salt(false);
-        self.events.push(Event::ProjectChanged { revision: self.revision });
-    }
-
-    /// Salt the disk cache's layer keys with the project's footage files
-    /// ([`effectcraft_render::disk_cache::footage_salt`]). Taking it reads the size and time of
-    /// every file, every frame of an image sequence included, so it is taken again only when the
-    /// footage items changed, or with `force` (a project opened, footage reloaded, the disk cache
-    /// attached), not at every edit: with a few large sequences that cost each keystroke in a
-    /// text field over half a second (#1926).
-    pub fn refresh_disk_salt(&mut self, force: bool) -> Option<u64> {
-        use std::hash::{Hash, Hasher};
-        if self.disk_cache.is_none() {
-            self.disk_salt = None;
-            return None;
-        }
-        let mut h = std::collections::hash_map::DefaultHasher::new();
-        for (id, it) in &self.project.items {
-            if let effectcraft_project::ItemKind::Footage(f) = &it.kind {
-                id.hash(&mut h);
-                format!("{f:?}").hash(&mut h);
-            }
-        }
-        let footage = h.finish();
-        if let Some((seen, salt)) = self.disk_salt
-            && seen == footage
-            && !force
-        {
-            return Some(salt);
-        }
-        let salt = effectcraft_render::disk_cache::footage_salt(&self.project);
-        self.disk_salt = Some((footage, salt));
-        self.layer_cache.set_disk_salt(salt);
-        Some(salt)
-    }
-
-    /// Set a comp's Resolution. As in After Effects it is saved with the project (which becomes
-    /// modified) but is no undo step, and it changes no pixels: the comp's cached frames stay
-    /// valid ([`effectcraft_project::Comp::same_pixels`]).
-    pub fn set_resolution(&mut self, comp: ItemId, r: effectcraft_project::Resolution) -> Result<()> {
-        if self.project.comp(comp).ok_or(EngineError::NoComp)?.resolution == r {
-            return Ok(());
-        }
-        Arc::make_mut(&mut self.project).comp_mut(comp).ok_or(EngineError::NoComp)?.resolution = r;
-        self.bump();
-        Ok(())
-    }
-
-    /// Keep what lives outside the undo history (each comp's Resolution) as it is in `from`, the
-    /// project before undo, redo or a history jump restored another state.
-    pub(crate) fn keep_view_settings(&mut self, from: &Project) {
-        let keep: Vec<(ItemId, effectcraft_project::Resolution)> =
-            self.project.comps().filter_map(|(id, c)| from.comp(*id).map(|f| (*id, f.resolution)).filter(|(_, r)| *r != c.resolution)).collect();
-        if keep.is_empty() {
-            return;
-        }
-        let p = Arc::make_mut(&mut self.project);
-        for (id, r) in keep {
-            if let Some(c) = p.comp_mut(id) {
-                c.resolution = r;
-            }
-        }
-    }
-
-    pub fn undo(&mut self) -> bool {
-        let Some((label, p)) = self.history.undo.pop() else { return false };
-        let edited = commands::text_edit::active_editor_snapshot(self);
-        let cur = std::mem::replace(&mut self.project, p);
-        self.keep_view_settings(&cur);
-        self.history.redo.push((label, cur));
-        self.history.merge_key = None;
-        self.sanitize_after_replacement(edited.as_ref());
-        self.bump();
-        true
-    }
-
-    pub fn redo(&mut self) -> bool {
-        let Some((label, p)) = self.history.redo.pop() else { return false };
-        let edited = commands::text_edit::active_editor_snapshot(self);
-        let cur = std::mem::replace(&mut self.project, p);
-        self.keep_view_settings(&cur);
-        self.history.undo.push((label, cur));
-        self.history.merge_key = None;
-        self.sanitize_after_replacement(edited.as_ref());
-        self.bump();
-        true
-    }
-
-    /// Keep selections valid after the project was replaced by another state (undo, redo, a
-    /// history jump, a rollback): the same layer id can name a different document, so the
-    /// on-canvas editor gets a fresh IME epoch only when its own document changed.
-    ///
-    /// Normally `before` is [`commands::text_edit::active_editor_snapshot`] taken from the
-    /// state this call is about to replace. Atomic batch rollback is the exception: it has
-    /// already restored the pre-batch state and passes the snapshot of the failing intermediate
-    /// state, so a transient restart or component switch inside the batch still rejects reviving
-    /// the old composition. A restored state that still has the same composition, layer and
-    /// editor session and shows byte/style-equivalent text (an opacity or other property undo)
-    /// keeps the editor's owner and selection; a different document, comp, layer or session clamps the
-    /// selection and starts a new epoch. A closed editor stays closed, and a fallback comp's
-    /// matching layer id never inherits the old comp's session. `None` means no editor was open
-    /// when the snapshot was taken; if one is open after the replacement it is treated as an
-    /// unverified document replacement, so it never inherits an old composition.
-    pub fn sanitize_after_replacement(&mut self, before: Option<&commands::text_edit::EditorSnapshot>) {
-        self.sanitize_state();
-        commands::text_edit::after_replacement(self, before);
-    }
-
-    /// Drop selections that no longer exist. Each comp keeps its own selection (#1001); a layer id
-    /// counts only inside the comp that owns it, so the active comp never sees another comp's layers.
-    pub fn sanitize_state(&mut self) {
-        let p = self.project.clone();
-        self.state.open_comps.retain(|c| p.comp(*c).is_some());
-        self.state.comp_selections.retain(|cid, sel| {
-            let Some(c) = p.comp(*cid) else { return false };
-            let ids: Vec<LayerId> = c.layers.iter().map(|l| l.id).collect();
-            sel.layers.retain(|l| ids.contains(l));
-            sel.props.retain(|(l, _)| ids.contains(l));
-            sel.keys.retain(|k| ids.contains(&k.layer));
-            sel.vertices.retain(|v| ids.contains(&v.layer));
-            !sel.is_empty()
-        });
-        if self.state.active_comp.is_some_and(|c| p.comp(c).is_none()) {
-            self.clear_live_selection();
-            // A matching layer id in the fallback comp is not the document being edited.
-            self.state.text_edit = None;
-            self.state.active_comp = self.state.open_comps.first().copied();
-            if let Some(id) = self.state.active_comp {
-                self.recall_selection(id);
-            }
-        }
-        if let Some(c) = self.active_comp() {
-            let ids: Vec<LayerId> = c.layers.iter().map(|l| l.id).collect();
-            self.state.selected_layers.retain(|l| ids.contains(l));
-            self.state.selected_props.retain(|(l, _)| ids.contains(l));
-            self.state.selected_keys.retain(|k| ids.contains(&k.layer));
-            self.state.selected_vertices.retain(|v| ids.contains(&v.layer));
-        }
-        if let Some((l, t)) = self.state.current_track
-            && self.active_comp().and_then(|c| c.layer(l)).and_then(|l| l.tracker(t)).is_none()
-        {
-            self.state.current_track = None;
-        }
-        self.state.project_selection.retain(|i| p.item(*i).is_some());
-        commands::text_edit::sanitize(self);
-    }
-
-    pub fn is_dirty(&self) -> bool {
-        self.revision != self.saved_revision
-    }
-
-    /// The project as it is now is the saved one (after opening or saving it).
-    pub fn mark_saved(&mut self) {
-        self.saved_project = self.project.clone();
-        self.saved_revision = self.revision;
-    }
-
-    /// The project has changes its file doesn't (a session restored with unsaved changes): it
-    /// stays modified until it is saved, whatever is undone.
-    pub fn mark_unsaved(&mut self) {
-        self.saved_project = Arc::new(Project::default());
-        self.bump();
-    }
-
-    pub fn active_comp(&self) -> Option<&Comp> {
-        self.project.comp(self.state.active_comp?)
-    }
-    /// [`Session::active_comp`] as a shared snapshot (an `Arc` clone, not a deep copy).
-    pub fn active_comp_arc(&self) -> Option<std::sync::Arc<Comp>> {
-        self.project.comp_arc(self.state.active_comp?)
-    }
-    pub fn active_comp_id(&self) -> Option<ItemId> {
-        self.state.active_comp.filter(|c| self.project.comp(*c).is_some())
-    }
-
-    /// Current time of a comp.
-    pub fn time_of(&self, comp: ItemId) -> Tick {
-        self.state.times.get(&comp).copied().unwrap_or(Tick::ZERO)
-    }
-
-    /// Current time of the active comp.
-    pub fn time(&self) -> Tick {
-        self.state.active_comp.and_then(|c| self.state.times.get(&c).copied()).unwrap_or(Tick::ZERO)
-    }
-
-    /// Move the active comp's current time.
-    ///
-    /// Time is an external boundary for the on-canvas text editor too: an animated Source Text
-    /// can show a different document at another time. The document is snapshotted only while an
-    /// editor is open, so playback with no text editor does no text copying.
-    pub fn set_time(&mut self, t: Tick) {
-        if let Some(c) = self.state.active_comp {
-            let t = self.project.comp(c).map_or(t, |comp| comp_frame_at(comp, t));
-            let edited = commands::text_edit::active_editor_snapshot(self);
-            self.state.times.insert(c, t);
-            if self.prefs.general.sync_time_related_items {
-                // Direct call: this `set_time` owns the editor snapshot for both time changes,
-                // so a synced move does not take a second snapshot or start a second epoch.
-                self.sync_related_times_inner(c, t);
-            }
-            commands::text_edit::after_external_change(self, edited.as_ref());
-        }
-    }
-
-    /// Settings ▸ General ▸ Synchronize Time of All Related Items: moving the current time of
-    /// `comp` moves the current time of the comps nested in it (through their precomp layers'
-    /// timing) and of the comps it is nested in, so every related viewer shows the same moment.
-    pub fn sync_related_times(&mut self, comp: ItemId, t: Tick) {
-        // Moving a related comp can move the active one, so the editor's document is checked
-        // here too; the snapshot is skipped entirely when no text editor is open.
-        let edited = commands::text_edit::active_editor_snapshot(self);
-        self.sync_related_times_inner(comp, t);
-        commands::text_edit::after_external_change(self, edited.as_ref());
-    }
-
-    fn sync_related_times_inner(&mut self, comp: ItemId, t: Tick) {
-        let mut seen = std::collections::BTreeSet::from([comp]);
-        let mut todo = vec![(comp, t)];
-        let mut found = vec![];
-        while let Some((cid, ct)) = todo.pop() {
-            if cid != comp {
-                found.push((cid, ct));
-            }
-            let Some(c) = self.project.comp(cid) else { continue };
-            // Down: the comps this one nests.
-            for l in &c.layers {
-                if let effectcraft_project::LayerSource::Comp { item } = &l.source
-                    && seen.insert(*item)
-                {
-                    todo.push((*item, l.layer_time(ct)));
-                }
-            }
-            // Up: the comps nesting this one.
-            for iid in self.project.items.keys() {
-                if let Some(pc) = self.project.comp(*iid)
-                    && let Some(l) = pc.layers.iter().find(|l| matches!(&l.source, effectcraft_project::LayerSource::Comp { item } if *item == cid))
-                    && seen.insert(*iid)
-                {
-                    todo.push((*iid, l.comp_time(ct)));
-                }
-            }
-        }
-        for (cid, ct) in found {
-            if let Some(c) = self.project.comp(cid) {
-                let ct = c.frame_rate.snap_nearest(ct.clamp(Tick::ZERO, (c.duration - c.frame_duration()).max(Tick::ZERO)));
-                self.state.times.insert(cid, ct);
-            }
-        }
-    }
-
-    /// Make `id` the active comp, parking the previous comp's selection and restoring this one's.
-    pub fn activate_comp(&mut self, id: ItemId) {
-        if self.project.comp(id).is_none() || self.state.active_comp == Some(id) {
-            return;
-        }
-        self.remember_selection();
-        self.state.active_comp = Some(id);
-        self.recall_selection(id);
-        self.state.current_track = None;
-        // A text-edit session belongs to the comp that owned it. Switching comps ends it; even
-        // a same-numbered layer in the new comp must not inherit the old IME composition.
-        self.state.text_edit = None;
-    }
-
-    /// Leave no comp active, keeping the one that was active in [`EditorState::comp_selections`].
-    pub fn activate_comp_none(&mut self) {
-        self.remember_selection();
-        self.state.active_comp = None;
-        self.clear_live_selection();
-        self.state.current_track = None;
-        self.state.text_edit = None;
-    }
-
-    fn remember_selection(&mut self) {
-        let Some(id) = self.state.active_comp else { return };
-        let sel = CompSelection {
-            layers: self.state.selected_layers.clone(),
-            props: self.state.selected_props.clone(),
-            keys: self.state.selected_keys.clone(),
-            vertices: self.state.selected_vertices.clone(),
-        };
-        if sel.is_empty() {
-            self.state.comp_selections.remove(&id);
-        } else {
-            self.state.comp_selections.insert(id, sel);
-        }
-    }
-
-    fn recall_selection(&mut self, id: ItemId) {
-        match self.state.comp_selections.remove(&id) {
-            Some(sel) => {
-                self.state.selected_layers = sel.layers;
-                self.state.selected_props = sel.props;
-                self.state.selected_keys = sel.keys;
-                self.state.selected_vertices = sel.vertices;
-            }
-            None => self.clear_live_selection(),
-        }
-    }
-
-    fn clear_live_selection(&mut self) {
-        self.state.selected_layers.clear();
-        self.state.selected_props.clear();
-        self.state.selected_keys.clear();
-        self.state.selected_vertices.clear();
-    }
-
-    /// Open a comp in the viewer/timeline and make it active.
-    pub fn open_comp(&mut self, id: ItemId) {
-        if self.project.comp(id).is_none() {
-            return;
-        }
-        if !self.state.open_comps.contains(&id) {
-            self.state.open_comps.push(id);
-        }
-        if self.state.active_comp != Some(id) {
-            let previous = self.state.active_comp;
-            self.state.recent_comps.retain(|c| *c != id && Some(*c) != previous);
-            if let Some(previous) = previous {
-                self.state.recent_comps.insert(0, previous);
-                self.state.recent_comps.truncate(32);
-            }
-        }
-        self.activate_comp(id);
-        self.events.push(Event::OpenComp(id));
-    }
-
-    /// The open compositions and their current times, as a project file records them
-    /// ([`effectcraft_project::SavedView`]).
-    pub fn saved_view(&self) -> effectcraft_project::SavedView {
-        let comp_times = self.state.times.iter().filter(|(id, _)| self.project.comp(**id).is_some()).map(|(id, t)| (*id, *t)).collect();
-        effectcraft_project::SavedView { active_comp: self.state.active_comp, open_comps: self.state.open_comps.clone(), comp_times }
-    }
-
-    /// Reopen the compositions a project file was saved with (#748), each at its saved current
-    /// time (#1714). Ids that no longer name a comp are skipped; with none left the project stays
-    /// on the comp [`Session::replace_project`] opened (its first), as files from before the view
-    /// was saved do.
-    pub fn restore_view(&mut self, view: &effectcraft_project::SavedView) {
-        for (id, t) in &view.comp_times {
-            if let Some(comp) = self.project.comp(*id) {
-                let t = comp_frame_at(comp, *t);
-                self.state.times.insert(*id, t);
-            }
-        }
-        let mut open: Vec<ItemId> = Vec::new();
-        for id in view.open_comps.iter().copied().filter(|id| self.project.comp(*id).is_some()) {
-            if !open.contains(&id) {
-                open.push(id);
-            }
-        }
-        let Some(active) = view.active_comp.filter(|id| self.project.comp(*id).is_some()).or_else(|| open.first().copied()) else { return };
-        self.state.open_comps = open;
-        self.open_comp(active);
-    }
-
-    pub fn toast(&mut self, msg: impl Into<String>) {
-        self.events.push(Event::Toast { message: msg.into(), error: false });
-    }
-
-    pub fn drain_events(&mut self) -> Vec<Event> {
-        std::mem::take(&mut self.events)
-    }
-
-    /// The 3D view camera of a comp's viewer (None = the active camera).
-    pub fn view_camera(&self, comp: ItemId) -> Option<effectcraft_render::three_d::CameraState> {
-        let c = self.project.comp(comp)?;
-        if !c.has_3d() {
-            return None;
-        }
-        self.state.views3d.get(&comp)?.override_camera(c.width as f64, c.height as f64)
-    }
-
-    /// Render a comp frame with the session's footage + expression hosts.
-    pub fn render(&self, comp: ItemId, t: Tick, opts: RenderOpts) -> Image {
-        self.renderer(opts).comp_frame(comp, t)
-    }
-
-    /// The renderer [`Session::render`] uses: the session's footage, expressions, layer cache and
-    /// accelerator, and the render prefs (nested switches, draft shadows) over `opts`.
-    pub fn renderer(&self, opts: RenderOpts) -> Renderer<'_> {
-        let opts = RenderOpts { nested_switches: self.prefs.general.switches_affect_nested_comps, draft_shadows: self.prefs.three_d.realtime_shadows, ..opts };
-        let mut r = Renderer::new(&self.project, self.footage.as_ref(), opts);
-        r.expr = self.expr.as_deref();
-        r.cache = Some(&self.layer_cache);
-        r.accel = self.accel.as_deref();
-        r
-    }
-
-    /// Resolve a comp reference (item id number or name; `None`/null = the active comp).
-    pub fn resolve_comp(&self, comp: Option<&Value>) -> Result<ItemId> {
-        let p = match comp {
-            Some(v) if !v.is_null() => serde_json::json!({ "comp": v }),
-            _ => serde_json::json!({}),
-        };
-        commands::comp_id(self, &p)
-    }
-
-    /// Render a comp frame (comp time `t`) as opaque 8-bit RGBA over the comp background, scaled
-    /// so the longest side is at most `max_side` pixels (0 = full size). Returns (width, height, rgba).
-    pub fn render_rgba8(&self, comp: ItemId, t: Tick, max_side: u32) -> Result<(u32, u32, Vec<u8>)> {
-        let c = self.project.comp(comp).ok_or(EngineError::NoComp)?;
-        let long = c.width.max(c.height).max(1) as f64;
-        let scale = if max_side == 0 { 1.0 } else { (max_side as f64 / long).min(1.0) };
-        let img = self.render(comp, t, RenderOpts { scale, backend: effectcraft_render::Backend::Auto, ..Default::default() });
-        Ok((img.width, img.height, img.to_rgba8_over(c.background)))
-    }
-
-    /// A Project panel thumbnail of an item (a comp at `t`, footage at its first frame), longest
-    /// side at most `max_side`, as a job that owns everything it reads: frontends run it off the
-    /// UI thread (a big comp takes far longer than a frame). `None` for items without pixels.
-    pub fn thumbnail_job(&self, item: ItemId, t: Tick, max_side: u32) -> Option<ThumbnailJob> {
-        let it = self.project.item(item)?;
-        let footage = self.footage.clone();
-        match &it.kind {
-            effectcraft_project::ItemKind::Comp(c) => {
-                let (project, expr, cache) = (self.project.clone(), self.expr.clone(), self.layer_cache.clone());
-                let long = c.width.max(c.height).max(1) as f64;
-                let scale = if max_side == 0 { 1.0 } else { (max_side as f64 / long).min(1.0) };
-                let opts = RenderOpts {
-                    scale,
-                    nested_switches: self.prefs.general.switches_affect_nested_comps,
-                    draft_shadows: self.prefs.three_d.realtime_shadows,
-                    ..Default::default()
-                };
-                let bg = c.background;
-                Some(Box::new(move || {
-                    let mut r = Renderer::new(&project, footage.as_ref(), opts);
-                    r.expr = expr.as_deref();
-                    r.cache = Some(&cache);
-                    let img = r.comp_frame(item, t);
-                    Some((img.width, img.height, img.to_rgba8_over(bg)))
-                }))
-            }
-            effectcraft_project::ItemKind::Footage(f) if f.has_video => {
-                let f = f.clone();
-                Some(Box::new(move || {
-                    let img = footage.frame(item, &f, Tick(0))?;
-                    // Point-sample down to at most `max_side` on the long side.
-                    let step = (img.width.max(img.height) as f32 / max_side.max(1) as f32).ceil().max(1.0) as u32;
-                    let (w, h) = (img.width.div_ceil(step), img.height.div_ceil(step));
-                    let full = img.to_rgba8();
-                    let mut px = Vec::with_capacity((w * h * 4) as usize);
-                    for y in 0..h {
-                        for x in 0..w {
-                            let i = (((y * step) * img.width + x * step) * 4) as usize;
-                            px.extend_from_slice(&full[i..i + 4]);
-                        }
-                    }
-                    Some((w, h, px))
-                }))
-            }
-            _ => None,
-        }
-    }
-
-    /// [`Session::render_rgba8`], or with `transparent` the frame's own straight alpha (what a
-    /// render with RGB + Alpha channels writes) instead of compositing over the background.
-    pub fn render_rgba8_alpha(&self, comp: ItemId, t: Tick, max_side: u32, transparent: bool) -> Result<(u32, u32, Vec<u8>)> {
-        if !transparent {
-            return self.render_rgba8(comp, t, max_side);
-        }
-        let c = self.project.comp(comp).ok_or(EngineError::NoComp)?;
-        let long = c.width.max(c.height).max(1) as f64;
-        let scale = if max_side == 0 { 1.0 } else { (max_side as f64 / long).min(1.0) };
-        let img = self.render(comp, t, RenderOpts { scale, backend: effectcraft_render::Backend::Auto, ..Default::default() });
-        Ok((img.width, img.height, img.to_rgba8()))
-    }
-
-    /// Make the media layer and the layer cache let go of what they decoded from `footage`'s
-    /// files (it keys frames by path, so an overwritten file would keep showing its old pixels).
-    pub(crate) fn forget_decoded(&self, footage: &effectcraft_project::Footage) {
-        for p in std::iter::once(&footage.path).chain(&footage.sequence) {
-            self.footage.forget(p);
-        }
-        self.layer_cache.clear();
-    }
-
-    /// Replace the whole project (open/new), resetting history and state.
-    pub fn replace_project(&mut self, mut p: Project, path: Option<String>) {
-        if self.stop_render()
-            && let Some(mut job) = self.render_job.take()
-        {
-            // Let the worker notice the cancel; its updates refer to the old project.
-            job.wait();
-        }
-        self.render_job = None;
-        self.stored_paths = Default::default();
-        self.stop_track();
-        self.track_job = None;
-        self.stop_mask_track();
-        self.mask_job = None;
-        self.stop_warp();
-        self.warp_job = None;
-        self.warp_pending.clear();
-        self.stop_camera();
-        self.camera_job = None;
-        self.camera_pending.clear();
-        self.stop_roto();
-        self.roto_job = None;
-        self.roto_pending.clear();
-        self.drop_tasks();
-        self.script_ui.project_epoch = self.script_ui.project_epoch.wrapping_add(1);
-        p.fix_next_id();
-        upgrade_effects(&mut p);
-        // The media layer keys decoded frames by path: files of the new project may have changed
-        // since an earlier project decoded them (#1070).
-        for it in p.items.values() {
-            if let effectcraft_project::ItemKind::Footage(f) = &it.kind {
-                self.forget_decoded(f);
-            }
-        }
-        self.layer_cache.clear();
-        self.project = Arc::new(p);
-        // Its files may have changed since they were last stamped.
-        self.disk_salt = None;
-        self.history = History::default();
-        self.state = EditorState { snapping: true, view_layout: 1, ..Default::default() };
-        self.path = path;
-        self.bump();
-        self.mark_saved();
-        let first = self.project.comps().next().map(|(id, _)| *id);
-        if let Some(c) = first {
-            self.open_comp(c);
-        }
-    }
-}
-
-/// Bring effect instances saved by earlier versions up to date with the effect registry
-/// (renamed / regrouped / added parameters, reordered popups; see
-/// [`effectcraft_effects::migrate`]), and a project from before
-/// [`effectcraft_project::SCHEMA_EFFECT_SPACE`] into effect space
-/// ([`effectcraft_effects::migrate::to_effect_space`]). Stamps the current schema.
-pub fn upgrade_effects(p: &mut Project) {
-    let to_effect_space = p.schema < effectcraft_project::SCHEMA_EFFECT_SPACE;
-    // Effect bounds per layer: (size, top-left in layer coordinates).
-    let mut bounds = std::collections::HashMap::new();
-    for (cid, c) in p.comps() {
-        for l in &c.layers {
-            bounds.insert((*cid, l.id), effectcraft_render::effect_bounds(p, c, l));
-        }
-    }
-    let mut next = p.next_id;
-    for (cid, it) in p.items.iter_mut() {
-        let effectcraft_project::ItemKind::Comp(c) = &mut it.kind else { continue };
-        for l in &mut std::sync::Arc::make_mut(c).layers {
-            let (size, origin) = bounds.get(&(*cid, l.id)).copied().unwrap_or(([100.0, 100.0], [0.0; 2]));
-            // Effect space starts at the bounds' top-left: positions move by minus that corner.
-            // Adjustment layers run their effects on the comp below as it is: nothing moves.
-            let shift = |o: [f64; 2]| [-o[0], -o[1]];
-            let d = if l.switches.adjustment { [0.0; 2] } else { shift(origin) };
-            let clone_d = |src: Option<u64>| match src {
-                Some(id) => bounds.get(&(*cid, effectcraft_project::LayerId(id))).map_or([0.0; 2], |b| shift(b.1)),
-                None => d,
-            };
-            let Some(fx) = l.props.sub_mut("effects") else { continue };
-            for n in &mut fx.children {
-                let effectcraft_project::Node::Group(g) = n else { continue };
-                let effectcraft_project::GroupKind::Effect { effect } = &g.kind else { continue };
-                if let Some(spec) = effectcraft_effects::find(effect) {
-                    effectcraft_effects::migrate::upgrade_instance(spec, g, &mut effectcraft_project::build::Ids(&mut next), size);
-                    if to_effect_space {
-                        effectcraft_effects::migrate::to_effect_space(spec, g, size, d, &clone_d);
-                    }
-                }
-            }
-        }
-    }
-    p.next_id = next;
-    p.schema = effectcraft_project::SCHEMA_VERSION;
-}
-
 #[cfg(test)]
 mod rq_tests;
 #[cfg(test)]
 mod tests;
-#[cfg(test)]
-mod tests_3d;
-#[cfg(test)]
-mod tests_anim_presets;
-#[cfg(test)]
-mod tests_anim_tools;
-#[cfg(test)]
-mod tests_camera_track;
-#[cfg(test)]
-mod tests_codec_options;
-#[cfg(test)]
-mod tests_color_view;
-#[cfg(test)]
-mod tests_crypto_pick;
-#[cfg(test)]
-mod tests_delete_keys;
-#[cfg(test)]
-mod tests_disk_cache;
-#[cfg(test)]
-mod tests_effects;
-#[cfg(test)]
-mod tests_essential;
-#[cfg(test)]
-mod tests_essential_more;
-#[cfg(test)]
-mod tests_face;
-#[cfg(test)]
-mod tests_fidelity;
-#[cfg(test)]
-mod tests_frame_export;
-#[cfg(test)]
-mod tests_fuzz_open;
-#[cfg(test)]
-mod tests_import_project;
-#[cfg(test)]
-mod tests_key_metadata_order;
-#[cfg(test)]
-mod tests_keylight;
-#[cfg(test)]
-mod tests_limits;
-#[cfg(test)]
-mod tests_lottie;
-#[cfg(test)]
-mod tests_m137;
-#[cfg(test)]
-mod tests_m145;
-#[cfg(test)]
-mod tests_markers;
-#[cfg(test)]
-mod tests_mask_warp;
-#[cfg(test)]
-mod tests_menu_cmds;
-#[cfg(test)]
-mod tests_model3d;
-#[cfg(test)]
-mod tests_motion_blur_depth;
-#[cfg(test)]
-mod tests_project_items;
-#[cfg(test)]
-mod tests_proxy;
-#[cfg(test)]
-mod tests_quick_offset;
-#[cfg(test)]
-mod tests_replace_source;
-#[cfg(test)]
-mod tests_rig3d;
-#[cfg(test)]
-mod tests_sequence;
-#[cfg(test)]
-mod tests_settings;
-#[cfg(test)]
-mod tests_shortcut_cmds;
-#[cfg(test)]
-mod tests_stubs;
-#[cfg(test)]
-mod tests_styles;
-#[cfg(test)]
-mod tests_tail;
-#[cfg(test)]
-mod tests_text;
-#[cfg(test)]
-mod tests_text_edit;
-#[cfg(test)]
-mod tests_timeline;
-#[cfg(test)]
-mod tests_timeline_interchange;
-#[cfg(test)]
-mod tests_track;
-#[cfg(test)]
-mod tests_vector_import;
-#[cfg(test)]
-mod tests_viewer;
-
-/// Font families available to text layers (bundled + scanned system fonts).
-/// Text animation presets: (id, name), for menus.
-pub fn text_presets() -> Vec<(String, String)> {
-    commands::text_preset_list()
-}
-
-/// Built-in animation presets (Effects & Presets ▸ * Animation Presets): (id, name, category).
-pub fn animation_presets() -> Vec<(String, String, String)> {
-    commands::builtin_preset_list()
-}
-
-pub fn text_families() -> Vec<String> {
-    effectcraft_text::families().into_iter().map(|(f, _)| f).collect()
-}
-
-/// The styles a family offers (its own faces, in weight order), for the style menus. A family
-/// that isn't installed offers the usual styles, which resolve to Inter's.
-pub fn font_styles(family: &str) -> Vec<String> {
-    effectcraft_text::families()
-        .into_iter()
-        .find(|(f, _)| f.eq_ignore_ascii_case(family))
-        .map(|(_, st)| st)
-        .filter(|st| !st.is_empty())
-        .unwrap_or_else(|| ["Regular", "Medium", "SemiBold", "Bold", "Italic"].iter().map(|s| s.to_string()).collect())
-}
-
-/// The OpenType feature tags (GSUB / GPOS) of the face a family + style resolves to.
-pub fn font_features(family: &str, style: &str) -> Vec<String> {
-    effectcraft_text::fonts::face(effectcraft_text::resolve(family, style).face).features()
-}
-
-/// One row of the Character panel's font menu.
-#[derive(Clone, Debug, PartialEq)]
-pub struct FontRow {
-    /// The family to apply (empty for the separator after the recent fonts).
-    pub family: String,
-    /// What the menu shows: the English family name, or the font's own-language name when
-    /// Settings ▸ Type ▸ Show Font Names in English is off.
-    pub display: String,
-    pub recent: bool,
-    /// A variable font (the menu's Variable Fonts filter keeps only these).
-    pub variable: bool,
-}
-
-/// Outline polylines of "Sample" set in `family` at `size` px (baseline at y = 0, y down), for
-/// the font menu's preview (Settings ▸ Type ▸ Show Font Preview).
-pub fn font_preview(family: &str, size: f64) -> Vec<Vec<[f32; 2]>> {
-    use kurbo::PathEl;
-    let st = effectcraft_keyframe::text_doc::CharStyle { font: family.to_string(), size, ..Default::default() };
-    let mut out = vec![];
-    let mut x = 0.0;
-    for ch in "Sample".chars() {
-        let (path, adv) = effectcraft_text::char_glyph_style(&st, ch);
-        let mut cur: Vec<[f32; 2]> = vec![];
-        let pt = |p: kurbo::Point| [(p.x + x) as f32, p.y as f32];
-        kurbo::flatten(&path, 0.2, |el| match el {
-            PathEl::MoveTo(p) => {
-                if cur.len() > 1 {
-                    out.push(std::mem::take(&mut cur));
-                }
-                cur = vec![pt(p)];
-            }
-            PathEl::LineTo(p) => cur.push(pt(p)),
-            PathEl::ClosePath => {
-                if let Some(f) = cur.first().copied() {
-                    cur.push(f);
-                }
-                if cur.len() > 1 {
-                    out.push(std::mem::take(&mut cur));
-                }
-            }
-            _ => {}
-        });
-        if cur.len() > 1 {
-            out.push(cur);
-        }
-        x += adv;
-    }
-    out
-}
-
-/// The Character panel's font menu: the recent fonts (Settings ▸ Type ▸ Number of Recent Fonts
-/// to Display), a separator, then every family. Each row says whether the family is variable,
-/// for the menu's Variable Fonts filter.
-pub fn font_menu(prefs: &prefs::Prefs) -> Vec<FontRow> {
-    let all = text_families();
-    let native = if prefs.type_.font_names_in_english { Default::default() } else { effectcraft_text::fonts::native_families() };
-    let variable = effectcraft_text::fonts::variable_families();
-    let row = |f: &String, recent: bool| FontRow {
-        family: f.clone(),
-        display: native.get(f).cloned().unwrap_or_else(|| f.clone()),
-        recent,
-        variable: variable.contains(f),
-    };
-    let mut out: Vec<FontRow> = prefs.recent_fonts_shown().iter().filter(|f| all.contains(f)).map(|f| row(f, true)).collect();
-    if !out.is_empty() {
-        out.push(FontRow { family: String::new(), display: "-".into(), recent: false, variable: false });
-    }
-    out.extend(all.iter().map(|f| row(f, false)));
-    out
-}
-#[cfg(test)]
-mod tests_history;
-#[cfg(test)]
-mod tests_models;
-#[cfg(test)]
-mod tests_paint;
-#[cfg(test)]
-mod tests_panels;
-#[cfg(test)]
-mod tests_roto;
-
-#[cfg(test)]
-mod tests_key_time;
diff --git a/crates/engine/src/menus.rs b/crates/engine/src/menus.rs
index aa2e4ffe1..a7418ae58 100644
--- a/crates/engine/src/menus.rs
+++ b/crates/engine/src/menus.rs
@@ -61,6 +61,12 @@ fn file_name(p: &str) -> String {
     std::path::Path::new(p).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| p.to_string())
 }
 
+/// The labels of a recent-files list: `names[i]`, or the whole of `full[i]` when another entry
+/// has the same name, so entries for two files named `Tool.jsx` tell them apart.
+fn distinct_labels(names: Vec<String>, full: &[String]) -> Vec<String> {
+    names.iter().zip(full).map(|(n, f)| if names.iter().filter(|m| *m == n).count() > 1 { f.clone() } else { n.clone() }).collect()
+}
+
 fn dyn_entry(label: String, command: &str, params: Value) -> MenuEntry {
     MenuEntry { label, command: command.into(), params, shortcut: None, alt_shortcuts: vec![] }
 }
@@ -72,26 +78,35 @@ fn holder_of(s: &Session, keys: &str) -> Option<String> {
 }
 
 /// The entries of a `@dynamic:<name>` node, and the disabled placeholder shown when there are
-/// none: `recentProjects`, `recentFootage`, `recentPresets`, `history` (undo steps, newest
+/// none: `recentProjects`, `recentFootage`, `recentPresets`, `recentScripts` (File ▸ Scripts ▸
+/// Recent Script Files), `history` (undo steps, newest
 /// first), `view3dShortcuts`, `workspaceShortcuts`, `savedWorkspaces` (Window ▸ Workspace) and
 /// `openViewers` (open compositions other than the active one), `scripts` (File ▸ Scripts) and
-/// `scriptPanels` (ScriptUI panels).
+/// `scriptPanels` (ScriptUI panels; a script in a subfolder is labelled `Folder/File.jsx` here,
+/// and [`dynamic_nodes`] puts it in the folder's submenu).
 pub fn dynamic(s: &Session, name: &str, cx: &DynCtx) -> (Vec<MenuEntry>, Option<&'static str>) {
     use serde_json::json;
     let indexed = |list: &[String], cmd: &str, stem: bool| -> Vec<MenuEntry> {
-        list.iter()
-            .enumerate()
-            .map(|(i, p)| {
-                let n =
-                    if stem { std::path::Path::new(p).file_stem().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| p.clone()) } else { file_name(p) };
-                dyn_entry(n, cmd, json!({"index": i}))
-            })
-            .collect()
+        let names = list
+            .iter()
+            .map(
+                |p| if stem { std::path::Path::new(p).file_stem().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| p.clone()) } else { file_name(p) },
+            )
+            .collect();
+        distinct_labels(names, list).into_iter().enumerate().map(|(i, n)| dyn_entry(n, cmd, json!({"index": i}))).collect()
     };
     match name {
         "recentProjects" => (indexed(&s.prefs.recent_projects, "file.openRecent", false), Some("No Recent Projects")),
         "recentFootage" => (indexed(&s.prefs.recent_footage, "file.importRecent", false), Some("No Recent Footage")),
         "recentPresets" => (indexed(&s.prefs.recent_presets, "anim.applyRecentPreset", true), Some("No Recent Presets")),
+        "recentScripts" => {
+            let full: Vec<String> = s.prefs.recent_scripts.iter().map(|r| r.text().to_string()).collect();
+            let names = full.iter().map(|p| file_name(p)).collect();
+            (
+                distinct_labels(names, &full).into_iter().enumerate().map(|(i, n)| dyn_entry(n, "file.runScript", json!({"recent": i}))).collect(),
+                Some("No Recent Script Files"),
+            )
+        }
         "history" => (
             s.history.undo.iter().rev().enumerate().map(|(i, (l, _))| dyn_entry(format!("Undo {l}"), "edit.history", json!({"steps": i + 1}))).collect(),
             Some("No History"),
@@ -153,6 +168,31 @@ pub fn dynamic(s: &Session, name: &str, cx: &DynCtx) -> (Vec<MenuEntry>, Option<
     }
 }
 
+/// [`dynamic`] as menu nodes, which is what frontends draw: scripts and panels in a subfolder
+/// (`Motion Kit/Animate.jsx`) go into a submenu named after the folder (`Motion Kit ▸
+/// Animate.jsx`), placed where the folder sorts among the other entries.
+pub fn dynamic_nodes(s: &Session, name: &str, cx: &DynCtx) -> (Vec<MenuNode>, Option<&'static str>) {
+    let (entries, empty) = dynamic(s, name, cx);
+    let scripts = matches!(name, "scripts" | "scriptPanels");
+    let mut out: Vec<MenuNode> = vec![];
+    for mut e in entries {
+        let Some((folder, file)) = e.label.split_once('/').filter(|_| scripts).map(|(d, f)| (d.to_string(), f.to_string())) else {
+            out.push(MenuNode::Item(e));
+            continue;
+        };
+        e.label = file;
+        let open = out.iter_mut().find_map(|n| match n {
+            MenuNode::Submenu { label, children } if *label == folder => Some(children),
+            _ => None,
+        });
+        match open {
+            Some(children) => children.push(MenuNode::Item(e)),
+            None => out.push(MenuNode::Submenu { label: folder, children: vec![MenuNode::Item(e)] }),
+        }
+    }
+    (out, empty)
+}
+
 /// Display label of a submenu (the "Assign Shortcut to …" submenus name the current view or
 /// workspace, like After Effects).
 pub fn submenu_label(s: &Session, label: &str, cx: &DynCtx) -> String {
@@ -576,6 +616,8 @@ File
     Install Script File... | file.installScript
     Install ScriptUI Panel... | file.installScriptUIPanel
     Run Script File... | file.runScript
+    Recent Script Files
+      @dynamic:recentScripts
   ---
   Create Proxy
     Still... | file.createProxy {"kind":"still"}
@@ -994,6 +1036,8 @@ Animation
   ---
   Add Keyframe | anim.addKeyframe
   Toggle Hold Keyframe | keys.toggleHold
+  Mute Keyframes | keys.setMuted
+  Unmute Keyframes | keys.setMuted {"muted":false}
   Keyframe Interpolation... | keys.interpolation
   Keyframe Velocity... | keys.velocity
   Keyframe Assistant
diff --git a/crates/engine/src/models.rs b/crates/engine/src/models.rs
deleted file mode 100644
index b4ddab00d..000000000
--- a/crates/engine/src/models.rs
+++ /dev/null
@@ -1,463 +0,0 @@
-//! Trained models (Settings ▸ Roto Brush and Settings ▸ Face Tracking; `roto.model*` and
-//! `face.model*` commands): which models the registry offers (`effectcraft_segment::MODELS`, all
-//! open source), which are installed (in the `models` folder), installing one from a file or
-//! downloading the official weights (verified against the registry's SHA-256 either way, and kept
-//! with a notice naming their authors and licence), choosing one per task, and loading it in the
-//! background: into the Roto Brush effect (`effects::roto::set_model`) or the face tracker
-//! ([`Models::face`]).
-//!
-//! Weights are never bundled: the install stays small and nothing is fetched unless asked for.
-//! Downloads use the system's `curl` (shipped with Windows 10+, macOS and most Linux systems),
-//! so no networking code is linked into EffectCraft; without it, the file can be downloaded in a
-//! browser and installed with Install from File. The browser build uses the built-in engines
-//! only, for now.
-
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex};
-
-use effectcraft_segment::face::FaceModel;
-use effectcraft_segment::{self as seg, Loaded, ModelInfo, Task};
-use serde_json::{Value, json};
-
-use crate::commands::{CommandSpec, always, b_p, bad, str_p};
-use crate::{EngineError, Result, Session, cmd, query};
-
-/// What a task's background worker reports.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Status {
-    /// What is happening now ("Downloading MobileSAM…").
-    pub busy: Option<String>,
-    /// The model in use.
-    pub active: Option<String>,
-    /// The last failure, for the Settings page.
-    pub error: Option<String>,
-    /// A finished job's message and whether it failed, for a toast (taken by
-    /// [`Session::poll_models`]).
-    pub done: Option<(String, bool)>,
-}
-
-/// The session's trained models: per task, the worker's status; and the face model in use.
-#[derive(Default)]
-pub struct Models {
-    roto: Arc<Mutex<Status>>,
-    face: Arc<Mutex<Status>>,
-    face_model: FaceSlot,
-}
-
-impl Models {
-    fn lane(&self, task: Task) -> &Arc<Mutex<Status>> {
-        match task {
-            Task::Mask => &self.roto,
-            Task::Face => &self.face,
-        }
-    }
-
-    pub fn status(&self, task: Task) -> Status {
-        self.lane(task).lock().map(|s| s.clone()).unwrap_or_default()
-    }
-
-    /// The face model face tracking uses (`None`: the classic tracker).
-    pub fn face(&self) -> Option<Arc<dyn FaceModel>> {
-        self.face_model.lock().ok().and_then(|m| m.clone())
-    }
-
-    fn set_active(&self, task: Task, model: Option<Loaded>) {
-        activate(self.lane(task), &self.face_model, task, model);
-    }
-}
-
-type FaceSlot = Arc<Mutex<Option<Arc<dyn FaceModel>>>>;
-
-/// Put a loaded model to use (or drop `task`'s): Roto Brush's lives in the effect, the face
-/// tracker's in `face`.
-fn activate(lane: &Arc<Mutex<Status>>, face: &FaceSlot, task: Task, model: Option<Loaded>) {
-    let id = model.as_ref().map(|m| match m {
-        Loaded::Mask(m) => m.info().id.to_string(),
-        Loaded::Face(m) => m.info().id.to_string(),
-    });
-    match (task, model) {
-        (Task::Mask, Some(Loaded::Mask(m))) => crate::effects::roto::set_model(Some(m)),
-        (Task::Mask, _) => crate::effects::roto::set_model(None),
-        (Task::Face, m) => {
-            if let Ok(mut slot) = face.lock() {
-                *slot = match m {
-                    Some(Loaded::Face(f)) => Some(f),
-                    _ => None,
-                };
-            }
-        }
-    }
-    set(lane, |s| s.active = id);
-}
-
-fn set(status: &Arc<Mutex<Status>>, f: impl FnOnce(&mut Status)) {
-    if let Ok(mut s) = status.lock() {
-        f(&mut s);
-    }
-}
-
-/// How a task shows in Settings, toasts and the command list.
-struct Kind {
-    /// Command prefix and settings key section.
-    prefix: &'static str,
-    label: &'static str,
-    classic_name: &'static str,
-    classic_description: &'static str,
-}
-
-const ROTO: Kind = Kind {
-    prefix: "roto",
-    label: "Roto Brush",
-    classic_name: "Classic (graph cut)",
-    classic_description: "Built in: colour models and graph cuts, propagated by optical flow. Always available.",
-};
-
-const FACE: Kind = Kind {
-    prefix: "face",
-    label: "Face Tracking",
-    classic_name: "Classic (shape model)",
-    classic_description: "Built in: a skin colour model, facial feature shapes and a fitted face shape model. Best on front-facing, evenly lit faces. Always available.",
-};
-
-fn kind(task: Task) -> &'static Kind {
-    match task {
-        Task::Mask => &ROTO,
-        Task::Face => &FACE,
-    }
-}
-
-impl Session {
-    /// The folder installed models live in: the host's, else `models` next to the settings.
-    pub fn models_dir(&self) -> Option<PathBuf> {
-        self.models_dir.clone().or_else(|| Some(self.config.as_ref()?.dir()?.join("models")))
-    }
-
-    /// Where `m` is installed, if it is (a file of the published size).
-    pub fn model_path(&self, m: &ModelInfo) -> Option<PathBuf> {
-        let p = self.models_dir()?.join(m.file_name);
-        std::fs::metadata(&p).ok().filter(|md| md.len() == m.size).map(|_| p)
-    }
-
-    /// The model chosen for `task` (Settings).
-    pub fn chosen_model(&self, task: Task) -> &str {
-        match task {
-            Task::Mask => &self.prefs.roto.model,
-            Task::Face => &self.prefs.face.model,
-        }
-    }
-
-    fn choose_model(&mut self, task: Task, id: &str) {
-        let slot = match task {
-            Task::Mask => &mut self.prefs.roto.model,
-            Task::Face => &mut self.prefs.face.model,
-        };
-        *slot = id.to_string();
-    }
-
-    /// Load (or drop) the models Settings chooses; called whenever settings change.
-    pub fn apply_models(&mut self) {
-        for task in [Task::Mask, Task::Face] {
-            self.apply_model(task, false);
-        }
-    }
-
-    /// Load (or drop) `task`'s chosen model; `wait`: before returning (scripts and agents).
-    fn apply_model(&mut self, task: Task, wait: bool) {
-        let want = self.chosen_model(task).to_string();
-        let lane = self.models.lane(task).clone();
-        let st = self.models.status(task);
-        let info = seg::info(&want).filter(|m| m.task == task);
-        let Some(info) = info else {
-            if st.active.is_some() {
-                self.models.set_active(task, None);
-            }
-            return;
-        };
-        if st.active.as_deref() == Some(info.id) || st.busy.is_some() {
-            return;
-        }
-        let Some(path) = self.model_path(info) else {
-            self.models.set_active(task, None);
-            return;
-        };
-        let (face_slot, label) = (self.models.face_model.clone(), kind(task).label);
-        spawn(&lane, label, format!("Loading {}…", info.name), wait, move |status| {
-            let m = load_file(&path, info.id)?;
-            activate(status, &face_slot, task, Some(m));
-            Ok(format!("{label}: {} loaded", info.name))
-        });
-    }
-
-    /// Finish what the model workers did: a toast, and loading a model that just arrived.
-    pub fn poll_models(&mut self) {
-        for task in [Task::Mask, Task::Face] {
-            let done = self.models.lane(task).lock().ok().and_then(|mut s| s.done.take());
-            if let Some((message, error)) = done {
-                self.events.push(crate::Event::Toast { message, error });
-                self.apply_model(task, false);
-            }
-        }
-    }
-}
-
-fn load_file(path: &Path, id: &str) -> std::result::Result<Loaded, String> {
-    let bytes = std::fs::read(path).map_err(|e| format!("cannot read {}: {e}", path.display()))?;
-    seg::load(id, &bytes)
-}
-
-/// Run `job` on a worker thread (`wait`: right here), reporting through `status` (desktop; the
-/// browser build has no trained models yet).
-fn spawn(
-    status: &Arc<Mutex<Status>>,
-    label: &'static str,
-    what: String,
-    wait: bool,
-    job: impl FnOnce(&Arc<Mutex<Status>>) -> std::result::Result<String, String> + Send + 'static,
-) {
-    if cfg!(target_arch = "wasm32") {
-        set(status, |s| s.error = Some("trained models are available in the desktop app".into()));
-        return;
-    }
-    set(status, |s| {
-        s.busy = Some(what);
-        s.error = None;
-    });
-    let st = status.clone();
-    let run = move || {
-        let r = job(&st);
-        set(&st, |s| {
-            s.busy = None;
-            match r {
-                Ok(msg) => s.done = Some((msg, false)),
-                Err(e) => {
-                    s.done = Some((format!("{label} model: {e}"), true));
-                    s.error = Some(e);
-                }
-            }
-        });
-    };
-    if wait {
-        run();
-    } else if let Err(e) = std::thread::Builder::new().name("ec-model".into()).spawn(run) {
-        set(status, |s| {
-            s.busy = None;
-            s.error = Some(format!("cannot start: {e}"));
-        });
-    }
-}
-
-/// The notice kept next to `m`'s weights.
-fn notice_path(dir: &Path, m: &ModelInfo) -> PathBuf {
-    dir.join(format!("{}.NOTICE.txt", m.file_name))
-}
-
-/// Copy verified weights into the models folder (atomically), with their notice.
-fn install_bytes(dir: &Path, m: &ModelInfo, bytes: &[u8]) -> std::result::Result<PathBuf, String> {
-    if bytes.len() as u64 != m.size || seg::sha256::hex(bytes) != m.sha256 {
-        return Err(format!("this is not the published {} file (size or SHA-256 differs)", m.name));
-    }
-    use crate::config::FileOps;
-    let path = dir.join(m.file_name);
-    let files = crate::config::StdFiles;
-    files.write(&path, bytes).map_err(|e| format!("cannot write {}: {e}", path.display()))?;
-    files.write(&notice_path(dir, m), seg::notice(m).as_bytes()).map_err(|e| format!("cannot write the notice: {e}"))?;
-    Ok(path)
-}
-
-fn model_p(p: &Value, cmd: &str, task: Task) -> Result<&'static ModelInfo> {
-    let id = str_p(p, "id").ok_or_else(|| bad(cmd, "missing `id`"))?;
-    seg::info(id).filter(|m| m.task == task).ok_or_else(|| bad(cmd, format!("unknown model `{id}` (see {}.models)", kind(task).prefix)))
-}
-
-fn list(s: &mut Session, task: Task) -> Result<Value> {
-    let k = kind(task);
-    let st = s.models.status(task);
-    let chosen = s.chosen_model(task).to_string();
-    let mut v = vec![json!({
-        "id": seg::CLASSICAL,
-        "name": k.classic_name,
-        "description": k.classic_description,
-        "licence": "MIT OR Apache-2.0",
-        "installed": true,
-        "selected": chosen == seg::CLASSICAL,
-        "active": st.active.is_none(),
-    })];
-    for m in seg::models(task) {
-        v.push(json!({
-            "id": m.id,
-            "name": m.name,
-            "description": m.description,
-            "authors": m.authors,
-            "licence": m.licence,
-            "licenceUrl": m.licence_url,
-            "homepage": m.homepage,
-            "url": m.url,
-            "size": m.size,
-            "sha256": m.sha256,
-            "installed": s.model_path(m).is_some(),
-            "selected": chosen == m.id,
-            "active": st.active.as_deref() == Some(m.id),
-        }));
-    }
-    Ok(json!({"models": v, "busy": st.busy, "error": st.error, "folder": s.models_dir().map(|d| d.display().to_string())}))
-}
-
-/// After a `wait`: the job's failure, as the command's.
-fn waited(s: &Session, task: Task, cmd: &str) -> Result<()> {
-    match s.models.status(task).error {
-        Some(e) => Err(bad(cmd, e)),
-        None => Ok(()),
-    }
-}
-
-fn select(s: &mut Session, p: &Value, task: Task) -> Result<Value> {
-    let cmd = format!("{}.model.select", kind(task).prefix);
-    let id = str_p(p, "id").ok_or_else(|| bad(&cmd, "missing `id`"))?;
-    if id != seg::CLASSICAL {
-        model_p(p, &cmd, task)?;
-    }
-    let wait = b_p(p, "wait").unwrap_or(false);
-    s.choose_model(task, id);
-    if wait {
-        s.apply_model(task, true);
-        waited(s, task, &cmd)?;
-    }
-    s.save_prefs();
-    s.prefs_changed();
-    Ok(json!({"model": id, "active": s.models.status(task).active}))
-}
-
-fn install(s: &mut Session, p: &Value, task: Task) -> Result<Value> {
-    let cmd = format!("{}.model.install", kind(task).prefix);
-    let path = str_p(p, "path").ok_or_else(|| bad(&cmd, "missing `path` (the downloaded weights file)"))?;
-    let dir = s.models_dir().ok_or_else(|| bad(&cmd, "no settings folder to install into"))?;
-    let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("cannot read {path}: {e}")))?;
-    // Which model it is: the one asked for, or the one whose checksum it has.
-    let m = match str_p(p, "id") {
-        Some(_) => model_p(p, &cmd, task)?,
-        None => {
-            let h = seg::sha256::hex(&bytes);
-            seg::models(task).find(|m| m.sha256 == h).ok_or_else(|| bad(&cmd, "this file is not a published model in the registry (SHA-256 differs)"))?
-        }
-    };
-    let dest = install_bytes(&dir, m, &bytes).map_err(|e| bad(&cmd, e))?;
-    let wait = b_p(p, "wait").unwrap_or(false);
-    s.apply_model(task, wait);
-    if wait {
-        waited(s, task, &cmd)?;
-    }
-    Ok(json!({"id": m.id, "path": dest.display().to_string()}))
-}
-
-fn download(s: &mut Session, p: &Value, task: Task) -> Result<Value> {
-    let k = kind(task);
-    let cmd = format!("{}.model.download", k.prefix);
-    let m = model_p(p, &cmd, task)?;
-    let dir = s.models_dir().ok_or_else(|| bad(&cmd, "no settings folder to install into"))?;
-    if s.models.status(task).busy.is_some() {
-        return Err(bad(&cmd, "a model is already downloading or loading"));
-    }
-    let size = if m.size >= 10_000_000 { format!("{} MB", m.size / 1_000_000) } else { format!("{:.1} MB", m.size as f64 / 1e6) };
-    let wait = b_p(p, "wait").unwrap_or(false);
-    spawn(s.models.lane(task), k.label, format!("Downloading {} ({size})…", m.name), wait, move |_| {
-        std::fs::create_dir_all(&dir).map_err(|e| format!("cannot create {}: {e}", dir.display()))?;
-        let tmp = dir.join(format!("{}.part", m.file_name));
-        let out = std::process::Command::new("curl")
-            .args(["-fsSL", "--retry", "2", "--connect-timeout", "20", "-o"])
-            .arg(&tmp)
-            .arg(m.url)
-            .output()
-            .map_err(|e| format!("downloading needs curl ({e}); or download {} in a browser and use Install from File", m.url))?;
-        if !out.status.success() {
-            let _ = std::fs::remove_file(&tmp);
-            return Err(format!("download failed: {}", String::from_utf8_lossy(&out.stderr).trim()));
-        }
-        let bytes = std::fs::read(&tmp).map_err(|e| format!("cannot read the download: {e}"))?;
-        let _ = std::fs::remove_file(&tmp);
-        install_bytes(&dir, m, &bytes)?;
-        Ok(format!("{}: {} downloaded and verified", k.label, m.name))
-    });
-    if wait {
-        waited(s, task, &cmd)?;
-        s.apply_model(task, true);
-        waited(s, task, &cmd)?;
-        return Ok(json!({"id": m.id, "installed": true}));
-    }
-    Ok(json!({"id": m.id, "downloading": true}))
-}
-
-fn remove(s: &mut Session, p: &Value, task: Task) -> Result<Value> {
-    let m = model_p(p, &format!("{}.model.remove", kind(task).prefix), task)?;
-    let Some(path) = s.model_path(m) else { return Ok(json!({"removed": false})) };
-    if s.models.status(task).active.as_deref() == Some(m.id) {
-        s.models.set_active(task, None);
-    }
-    std::fs::remove_file(&path).map_err(|e| EngineError::Other(format!("cannot remove {}: {e}", path.display())))?;
-    if let Some(dir) = path.parent() {
-        let _ = std::fs::remove_file(notice_path(dir, m));
-    }
-    Ok(json!({"removed": true}))
-}
-
-pub fn specs() -> Vec<CommandSpec> {
-    vec![
-        query!("roto.models", "Roto Brush Models", "{}", |s, _| list(s, Task::Mask)),
-        cmd!(
-            "roto.model.select",
-            "Use Roto Brush Model",
-            [],
-            None,
-            "{id: classical|mobilesam, wait?} (Roto Brush 2.0 / 3.0 use it; wait: loaded before returning)",
-            always,
-            |s, p| select(s, p, Task::Mask)
-        ),
-        cmd!(
-            "roto.model.install",
-            "Install Roto Brush Model",
-            [],
-            None,
-            "{path: weights file, id?, wait?} — verified against the registry's SHA-256",
-            always,
-            |s, p| install(s, p, Task::Mask)
-        ),
-        cmd!(
-            "roto.model.download",
-            "Download Roto Brush Model",
-            [],
-            None,
-            "{id, wait?} — the official weights, verified (desktop; uses the system curl)",
-            always,
-            |s, p| download(s, p, Task::Mask)
-        ),
-        cmd!("roto.model.remove", "Remove Roto Brush Model", [], None, "{id}", always, |s, p| remove(s, p, Task::Mask)),
-        query!("face.models", "Face Tracking Models", "{}", |s, _| list(s, Task::Face)),
-        cmd!(
-            "face.model.select",
-            "Use Face Tracking Model",
-            [],
-            None,
-            "{id: classical|mediapipe-face, wait?} (face tracking uses it; wait: loaded before returning)",
-            always,
-            |s, p| select(s, p, Task::Face)
-        ),
-        cmd!(
-            "face.model.install",
-            "Install Face Tracking Model",
-            [],
-            None,
-            "{path: model file, id?, wait?} — verified against the registry's SHA-256",
-            always,
-            |s, p| install(s, p, Task::Face)
-        ),
-        cmd!(
-            "face.model.download",
-            "Download Face Tracking Model",
-            [],
-            None,
-            "{id, wait?} — the official model, verified (desktop; uses the system curl)",
-            always,
-            |s, p| download(s, p, Task::Face)
-        ),
-        cmd!("face.model.remove", "Remove Face Tracking Model", [], None, "{id}", always, |s, p| remove(s, p, Task::Face)),
-    ]
-}
diff --git a/crates/engine/src/output_guard.rs b/crates/engine/src/output_guard.rs
new file mode 100644
index 000000000..46c4356ed
--- /dev/null
+++ b/crates/engine/src/output_guard.rs
@@ -0,0 +1,1028 @@
+//! Protect files the project reads from render outputs (#1743).
+//!
+//! This guard is independent of replacement consent and export staging: it never authorizes
+//! overwriting ordinary outputs or opens a second confirmation flow. Those belong to the
+//! exporter. Existing aliases are compared by native file identity, including hard links.
+//! Missing sources remain protected by their normalized path. Checks happen before dispatch;
+//! filesystem changes between the check and the write require exporter-side revalidation.
+//!
+//! The commands that write to a path they are given (Save Frame As, Export Lottie, Save a Copy,
+//! Collect Files, Export Timeline…) never replace one of those files either, with no flag:
+//! they write through [`Session::write_output`], the one place that checks. Save and Save As
+//! write the project's own file and do not.
+//!
+//! Nor does a render write one file twice. When two outputs of one job name the same file (two
+//! items with one Output To, a duplicated item, output modules or segments that meet), the one
+//! rendered later replaces what the earlier one just wrote, and nothing is on disk to say so when
+//! the job starts. [`Session::duplicate_outputs`] lists them and the whole render is refused before
+//! anything is written: no answer makes a render replacing its own output right. A numbered sequence is compared by the frames
+//! it writes: two items of one pattern clash only where their frames do, and an item that skips
+//! existing frames leaves the earlier one's alone. A new item's default output name steps aside
+//! the same way it does for footage ([`Session::avoid_sources`]).
+//!
+
+use std::collections::{HashMap, HashSet};
+#[cfg(not(target_arch = "wasm32"))]
+use std::path::Component;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use effectcraft_project::render_queue::{RenderQueueItem, log_path, numbered_template, sequence_frame, sequence_parts, sequence_path};
+use effectcraft_project::{Footage, ItemKind};
+use serde_json::{Value, json};
+
+use crate::Session;
+
+/// Volumes on Windows and macOS ignore case unless they were set up not to.
+const IGNORES_CASE: bool = cfg!(any(windows, target_os = "macos"));
+
+/// How many frames are looked at one by one for a sequence whose folder cannot be read at once
+/// (its frame number is in a folder's name).
+const PROBE_LIMIT: u64 = 100_000;
+
+/// How far a default output name is numbered (`_1` … `_1000`) before it is left to the check at
+/// render time.
+const MAX_NUMBER: u32 = 1_000;
+
+/// What a file is written for, which words a refusal.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum Use {
+    /// A Render Queue output (or a preview render): the fix is Output To.
+    Render,
+    /// Anything else written to a path: a frame, an export, a copy.
+    Export,
+}
+
+/// Stands for the frame number in the name a numbered sequence is compared by: a character no
+/// file is named with.
+const FRAME: char = '\u{e000}';
+
+/// What reads a file the project depends on.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum Source {
+    /// A footage item, by name.
+    Footage(Arc<str>),
+    /// An item's proxy, by the item's name.
+    Proxy(Arc<str>),
+    /// The project file.
+    Project,
+}
+
+impl Source {
+    /// `footage`, `proxy` or `project`: the `source` of a blocked output.
+    pub(crate) fn kind(&self) -> &'static str {
+        match self {
+            Source::Footage(_) => "footage",
+            Source::Proxy(_) => "proxy",
+            Source::Project => "project",
+        }
+    }
+
+    /// Why `path`, a file this reads, cannot be written for `used`.
+    pub(crate) fn refusal(&self, path: &str, used: Use) -> String {
+        match (used, self) {
+            (Use::Render, Source::Footage(name)) => {
+                format!("{path} is the footage “{name}” of this project, and a render never replaces footage; choose another Output To")
+            }
+            (Use::Render, Source::Proxy(name)) => format!("{path} is the proxy of “{name}”, and a render never replaces a proxy; choose another Output To"),
+            (Use::Render, Source::Project) => format!("{path} is this project's own file, and a render never replaces it; choose another Output To"),
+            (Use::Export, Source::Footage(name)) => {
+                format!("{path} is the footage “{name}” of this project, and footage is never written over; choose another file")
+            }
+            (Use::Export, Source::Proxy(name)) => format!("{path} is the proxy of “{name}”, and a proxy is never written over; choose another file"),
+            (Use::Export, Source::Project) => format!("{path} is this project's own file, which only Save writes; choose another file"),
+        }
+    }
+}
+
+/// The files the project reads: footage (every frame of a sequence), proxies and the project file.
+#[derive(Default)]
+pub(crate) struct Protected {
+    files: Vec<(PathBuf, Source)>,
+    by_path: HashMap<String, usize>,
+    /// Hashes of native identities, built once. Handles are closed after indexing so long
+    /// sequences do not exhaust the process's file descriptors. Hash hits are verified with
+    /// native handle equality; a hash collision cannot make another file a protected source.
+    #[cfg(not(target_arch = "wasm32"))]
+    by_identity: std::sync::OnceLock<HashMap<u64, Vec<usize>>>,
+    #[cfg(all(test, not(target_arch = "wasm32")))]
+    identity_reads: std::sync::atomic::AtomicUsize,
+}
+
+impl Protected {
+    pub(crate) fn of(s: &Session) -> Protected {
+        let mut found = Protected::default();
+        for item in s.project.items.values() {
+            let name: Arc<str> = item.name.as_str().into();
+            if let ItemKind::Footage(f) = &item.kind {
+                found.add_footage(s, f, &Source::Footage(name.clone()));
+            }
+            if let Some(proxy) = &item.proxy {
+                found.add_footage(s, &proxy.footage, &Source::Proxy(name));
+            }
+        }
+        if let Some(path) = s.path.as_deref().filter(|p| !p.is_empty()) {
+            found.add(PathBuf::from(path), Source::Project);
+        }
+        found
+    }
+
+    fn add_footage(&mut self, s: &Session, f: &Footage, source: &Source) {
+        for stored in std::iter::once(&f.path).chain(&f.sequence).filter(|p| !p.is_empty()) {
+            // The file the media layer opens for the path the project stores.
+            let path = s.stored_path(stored).unwrap_or_else(|_| PathBuf::from(stored));
+            self.add(path, source.clone());
+        }
+    }
+
+    fn add(&mut self, path: PathBuf, source: Source) {
+        self.by_path.entry(key(&path)).or_insert(self.files.len());
+        self.files.push((path, source));
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.files.is_empty()
+    }
+
+    /// The source at this normalized path or native file identity. A new output only needs
+    /// its path lookup and one failed filesystem probe; existing outputs build the index once.
+    pub(crate) fn find(&self, path: &Path) -> Option<&Source> {
+        self.by_path.get(&key(path)).and_then(|i| self.files.get(*i)).map(|(_, source)| source).or_else(|| self.alias_of(path))
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    fn handle(&self, path: &Path) -> Option<same_file::Handle> {
+        #[cfg(test)]
+        self.identity_reads.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        // Opening a FIFO can wait for a writer. Only regular files can be protected media;
+        // preserve the old size-indexed lookup's exclusion of special files and directories.
+        if !std::fs::metadata(path).ok()?.is_file() {
+            return None;
+        }
+        same_file::Handle::from_path(path).ok()
+    }
+
+    /// Hashes narrow the search, while native handle equality also checks any hash collisions.
+    #[cfg(not(target_arch = "wasm32"))]
+    fn alias_of(&self, path: &Path) -> Option<&Source> {
+        let output = self.handle(path)?;
+        let indexed = self.by_identity.get_or_init(|| {
+            let mut ids: HashMap<u64, Vec<usize>> = HashMap::new();
+            for (i, (known, _)) in self.files.iter().enumerate() {
+                if let Some(handle) = self.handle(known) {
+                    ids.entry(identity_hash(&handle)).or_default().push(i);
+                }
+            }
+            ids
+        });
+        indexed.get(&identity_hash(&output))?.iter().find_map(|i| {
+            let (known, source) = self.files.get(*i)?;
+            (self.handle(known)? == output).then_some(source)
+        })
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    fn alias_of(&self, _: &Path) -> Option<&Source> {
+        None
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn identity_hash(handle: &same_file::Handle) -> u64 {
+    use std::hash::{Hash, Hasher};
+    let mut hash = std::collections::hash_map::DefaultHasher::new();
+    handle.hash(&mut hash);
+    hash.finish()
+}
+
+/// What an existing regular file is known by on its volume (links and hard links to one file give one),
+/// `None` when it does not exist, is not a regular file, or the volume has no such identity.
+fn identity(path: &Path) -> Option<String> {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        // Opening a FIFO can wait for a writer: only regular files are looked at.
+        if !std::fs::metadata(path).ok()?.is_file() {
+            return None;
+        }
+        same_file::Handle::from_path(path).ok().map(|handle| identity_hash(&handle).to_string())
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        let _ = path;
+        None
+    }
+}
+
+/// `path` made absolute, with `.` and `..` resolved by name alone (no file is looked at).
+#[cfg(not(target_arch = "wasm32"))]
+fn lexical(path: &Path) -> PathBuf {
+    let absolute = std::path::absolute(path).unwrap_or_else(|_| path.to_path_buf());
+    let mut out = PathBuf::new();
+    for part in absolute.components() {
+        match part {
+            Component::CurDir => {}
+            Component::ParentDir => match out.components().next_back() {
+                Some(Component::Normal(_)) => {
+                    out.pop();
+                }
+                Some(Component::RootDir | Component::Prefix(_)) => {}
+                _ => out.push(".."),
+            },
+            other => out.push(other.as_os_str()),
+        }
+    }
+    out
+}
+
+/// The name a path is compared by: absolute, resolved by name, without case where volumes ignore it.
+#[cfg(not(target_arch = "wasm32"))]
+fn key(path: &Path) -> String {
+    let parts: Vec<String> = lexical(path).components().map(|c| c.as_os_str().to_string_lossy().into_owned()).collect();
+    fold(&parts.join("/"))
+}
+
+#[cfg(target_arch = "wasm32")]
+fn key(path: &Path) -> String {
+    browser_key(path)
+}
+
+/// Match the browser file table: one optional leading slash, with literal case and dot segments.
+#[cfg(any(target_arch = "wasm32", test))]
+fn browser_key(path: &Path) -> String {
+    let path = path.to_string_lossy();
+    if path.starts_with('/') { path.into_owned() } else { format!("/{path}") }
+}
+
+fn fold(name: &str) -> String {
+    if IGNORES_CASE { name.to_lowercase() } else { name.to_string() }
+}
+
+/// Whether two paths are one file: the same name once resolved, or the same file on disk.
+pub(crate) fn same_file(a: &Path, b: &Path) -> bool {
+    if key(a) == key(b) {
+        return true;
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    return same_file::is_same_file(a, b).unwrap_or(false);
+    #[cfg(target_arch = "wasm32")]
+    false
+}
+
+/// Whether a file (or a link, even one leading nowhere) is at `path`.
+fn exists(path: &str) -> bool {
+    std::fs::symlink_metadata(path).is_ok_and(|m| !m.is_dir())
+}
+
+/// The files of a numbered sequence (`count` frames from `first`) that are on disk: its folder is
+/// read once, not asked about frame by frame.
+fn frames_on_disk(path: &str, first: i64, count: u64) -> Result<Vec<PathBuf>, String> {
+    let last = first.saturating_add(i64::try_from(count).unwrap_or(i64::MAX));
+    let p = Path::new(path);
+    let dir = p.parent().filter(|d| !d.as_os_str().is_empty()).unwrap_or(Path::new("."));
+    let name = p.file_name().map(|n| n.to_string_lossy().into_owned());
+    let Some(name) = name.filter(|_| !dir.to_string_lossy().contains('#')) else {
+        // The frame number is in a folder's name: every frame has a folder of its own.
+        if count > PROBE_LIMIT {
+            return Err(format!(
+                "cannot safely check {count} output frames with a number in a folder name (limit {PROBE_LIMIT}); choose a fixed output folder or a shorter range"
+            ));
+        }
+        return Ok((0..count)
+            .map(|k| sequence_path(path, first.saturating_add(i64::try_from(k).unwrap_or(i64::MAX))))
+            .filter(|frame| exists(frame))
+            .map(PathBuf::from)
+            .collect());
+    };
+    let pattern = fold(&name);
+    let entries = match std::fs::read_dir(dir) {
+        Ok(entries) => entries,
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()),
+        Err(e) => return Err(format!("cannot check render output folder {}: {e}", dir.display())),
+    };
+    Ok(entries
+        .filter_map(Result::ok)
+        .filter(|e| sequence_frame(&pattern, &fold(&e.file_name().to_string_lossy())).is_some_and(|frame| (first..last).contains(&frame)))
+        .filter(|e| !e.file_type().is_ok_and(|t| t.is_dir()))
+        .map(|e| e.path())
+        .collect())
+}
+
+/// What an output writes, as far as a clash with another output goes.
+#[derive(Clone, Debug, PartialEq)]
+enum Target {
+    /// One file: known by its name and, when it exists, by what it is on its volume.
+    File { key: String, identity: Option<String> },
+    /// The numbered files `first..end` of a sequence: `key` is its pattern, with the width the
+    /// frame numbers are padded to.
+    Frames { key: String, width: usize, first: i64, end: i64 },
+}
+
+impl Target {
+    /// The file at `path`. `by_identity` also looks up what it is on its volume (a link to it
+    /// is it); that asks the file system, so it is left out where only names matter.
+    fn file(path: &Path, by_identity: bool) -> Target {
+        let identity = if by_identity { identity(path) } else { None };
+        Target::File { key: key(path), identity }
+    }
+
+    /// The `count` files of the sequence `path` (its frame-number pattern) from frame `first`.
+    fn frames(path: &str, first: i64, count: u64) -> Target {
+        let (before, width, after) = sequence_parts(path);
+        let key = key(Path::new(&format!("{before}{FRAME}{after}")));
+        Target::Frames { key, width, first, end: first.saturating_add(i64::try_from(count).unwrap_or(i64::MAX)) }
+    }
+}
+
+/// One output of a job.
+#[derive(Clone, Debug)]
+struct Write {
+    /// The queue item (`0`: one that is not in the queue yet).
+    item: u64,
+    /// The output path (a sequence's has its frame-number pattern).
+    path: String,
+    target: Target,
+    /// Skip Existing Files: a frame that is there already is left alone.
+    skips: bool,
+}
+
+/// What an output rendered later writes over.
+struct Clash<'a> {
+    /// The earlier output that writes it.
+    earlier: &'a Write,
+    /// How many files, and the first of them (its frame number, for a sequence).
+    files: u64,
+    first: i64,
+}
+
+/// The outputs of a job in the order they render, to find the one that writes what an earlier
+/// one does.
+#[derive(Default)]
+struct Writes {
+    all: Vec<Write>,
+    path_bytes: usize,
+    /// The first output to write a file, by name.
+    files: HashMap<String, usize>,
+    /// ... and by what the file is on its volume.
+    identities: HashMap<String, usize>,
+}
+
+/// The common range whose formatted numbers agree. Once the number (including a minus sign)
+/// fills the larger padding width, different widths produce the same file name.
+fn common_frames(first: i64, end: i64, from: i64, to: i64, width: usize, other_width: usize) -> Option<(u64, i64)> {
+    let (start, end) = (first.max(from), end.min(to));
+    let count = |a: i64, b: i64| u64::try_from(b.saturating_sub(a)).unwrap_or(0);
+    if width == other_width {
+        return (end > start).then(|| (count(start, end), start));
+    }
+    let width = width.max(other_width);
+    let power = |digits: usize| u32::try_from(digits).ok().and_then(|digits| 10i64.checked_pow(digits));
+    let negative = power(width.saturating_sub(2)).map(|n| end.min((-n).saturating_add(1))).filter(|to| *to > start);
+    let positive = power(width.saturating_sub(1)).map(|n| start.max(n)).filter(|from| *from < end);
+    let files = negative.map_or(0, |to| count(start, to)).saturating_add(positive.map_or(0, |from| count(from, end)));
+    (files > 0).then(|| (files, if negative.is_some() { start } else { positive.unwrap_or(start) }))
+}
+
+impl Writes {
+    fn is_empty(&self) -> bool {
+        self.all.is_empty()
+    }
+
+    /// The earliest output `later`, rendered after all of these, writes over.
+    fn clash(&self, later: &Write) -> Option<Clash<'_>> {
+        match &later.target {
+            Target::File { key, identity } => {
+                if let Some(at) = self.files.get(key).or_else(|| identity.as_ref().and_then(|id| self.identities.get(id))) {
+                    return Some(Clash { earlier: self.all.get(*at)?, files: 1, first: 0 });
+                }
+                self.all.iter().find_map(|earlier| {
+                    let Target::Frames { first, end, .. } = earlier.target else { return None };
+                    let frame = sequence_frame(&crate::output_guard::key(Path::new(&earlier.path)), key)?;
+                    (first..end).contains(&frame).then_some(Clash { earlier, files: 1, first: frame })
+                })
+            }
+            // A frame that is there already is left alone, so a later output that skips existing
+            // frames replaces none of an earlier one's.
+            Target::Frames { .. } if later.skips => None,
+            Target::Frames { key, width, first, end } => self.all.iter().find_map(|earlier| {
+                let (files, start) = match &earlier.target {
+                    Target::Frames { key: other, width: other_width, first: from, end: to } if key == other => {
+                        common_frames(*first, *end, *from, *to, *width, *other_width)?
+                    }
+                    Target::File { key, .. } => {
+                        let frame = sequence_frame(&crate::output_guard::key(Path::new(&later.path)), key)?;
+                        if !(*first..*end).contains(&frame) {
+                            return None;
+                        }
+                        (1, frame)
+                    }
+                    _ => return None,
+                };
+                Some(Clash { earlier, files, first: start })
+            }),
+        }
+    }
+
+    fn push(&mut self, write: Write) -> Result<(), String> {
+        let path_bytes = self.path_bytes.saturating_add(write.path.len());
+        if self.all.len() >= 65_536 || path_bytes > 16 * 1024 * 1024 {
+            return Err("render output plan exceeds 65536 paths or 16 MiB of path names; split the queue".into());
+        }
+        self.path_bytes = path_bytes;
+        let at = self.all.len();
+        match &write.target {
+            Target::File { key, identity } => {
+                self.files.entry(key.clone()).or_insert(at);
+                if let Some(identity) = identity {
+                    self.identities.entry(identity.clone()).or_insert(at);
+                }
+            }
+            Target::Frames { .. } => {}
+        }
+        self.all.push(write);
+        Ok(())
+    }
+}
+
+/// A queue item refused before any of its output modules are dispatched.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct Refused {
+    pub item: u64,
+    pub reason: String,
+}
+
+/// An output that would write a file an earlier output of the same job writes.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct DuplicateOutput {
+    /// The queue item that would write over it (the later one), its place in the queue (1-based)
+    /// and its composition.
+    pub item: u64,
+    pub index: usize,
+    pub comp: String,
+    /// The file: a sequence's pattern, or the frame when it is one.
+    pub path: String,
+    /// How many files the two outputs have in common.
+    pub files: u64,
+    pub sequence: bool,
+    /// The queue item whose output is written first, and its place and composition.
+    pub with: u64,
+    pub with_index: usize,
+    pub with_comp: String,
+}
+
+impl DuplicateOutput {
+    /// Why the render is refused, naming the two items.
+    pub(crate) fn reason(&self) -> String {
+        let label = |index: usize, comp: &str| format!("#{index} “{comp}”");
+        let what = if self.sequence && self.files != 1 { format!("{} frames of {}", self.files, self.path) } else { self.path.clone() };
+        let rule = "and a render never writes one file twice; choose another Output To for one of them";
+        if self.item == self.with {
+            format!("{} would write {what} twice (two of its output modules), {rule}", label(self.index, &self.comp))
+        } else {
+            format!("{} and {} would both write {what}, {rule}", label(self.with_index, &self.with_comp), label(self.index, &self.comp))
+        }
+    }
+}
+
+/// Why a render is refused when outputs of the job write one file twice: it would replace its own output.
+pub(crate) fn duplicate_refusal(duplicates: &[DuplicateOutput]) -> Option<String> {
+    let first = duplicates.first()?;
+    let more = match duplicates.len().saturating_sub(1) {
+        0 => String::new(),
+        1 => "; 1 more output would write a file twice too".into(),
+        n => format!("; {n} more outputs would write a file twice too"),
+    };
+    Some(format!("{}. Nothing was rendered{more}", first.reason()))
+}
+
+impl Session {
+    /// The files the project reads.
+    pub(crate) fn protected_files(&self) -> Protected {
+        Protected::of(self)
+    }
+
+    /// What reads the file at `path`, if the project does.
+    fn blocking(&self, path: &str) -> Option<Source> {
+        self.protected_files().find(Path::new(path)).cloned()
+    }
+
+    /// `Err` when `path` is a file the project reads (footage, a proxy, the project file) and so
+    /// is not for an export to replace. For callers that write the file themselves; call it
+    /// before the work, not after it.
+    pub fn refuse_export(&self, path: &str) -> crate::Result<()> {
+        match self.blocking(path) {
+            Some(source) => Err(crate::EngineError::Other(source.refusal(path, Use::Export))),
+            None => Ok(()),
+        }
+    }
+
+    /// Write `bytes` to `path` through the host's services, unless the project reads the file
+    /// there ([`Session::refuse_export`]). Every command that writes to a path it is given
+    /// writes through this; Save and Save As (the project's own file) do not.
+    pub fn write_output(&self, path: &str, bytes: &[u8]) -> crate::Result<()> {
+        self.write_output_with(&self.protected_files(), path, bytes)
+    }
+
+    /// [`Session::write_output`] against files already found ([`Session::protected_files`]),
+    /// for a command that writes many.
+    pub(crate) fn write_output_with(&self, protected: &Protected, path: &str, bytes: &[u8]) -> crate::Result<()> {
+        if let Some(source) = protected.find(Path::new(path)) {
+            return Err(crate::EngineError::Other(source.refusal(path, Use::Export)));
+        }
+        self.services.write_file(path, bytes).map_err(|e| crate::EngineError::Other(format!("cannot write {path}: {e}")))
+    }
+
+    /// `file.checkOutput`'s reply for `path`.
+    pub(crate) fn output_status(&self, path: &str) -> Value {
+        match self.blocking(path) {
+            Some(source) => json!({"path": path, "blocked": true, "source": source.kind(), "reason": source.refusal(path, Use::Export)}),
+            None => json!({"path": path, "blocked": false}),
+        }
+    }
+
+    /// Reject protected outputs and ranges that cannot be checked completely. Ordinary-file
+    /// replacement consent is left to the exporter, independently of this source guard.
+    pub(crate) fn check_outputs(&self, items: &[Vec<(RenderQueueItem, String)>]) -> Vec<Refused> {
+        if cfg!(target_arch = "wasm32") {
+            return Vec::new();
+        }
+        let protected = self.protected_files();
+        let mut seen = HashSet::new();
+        let mut refused = Vec::new();
+        for (item, path) in items.iter().flatten() {
+            if seen.contains(&item.id) {
+                continue;
+            }
+            let reason = match self.write_paths(item, path) {
+                Ok(paths) => paths.iter().find_map(|path| match self.check_output(&protected, item, path) {
+                    Ok(reason) => reason,
+                    Err(reason) => Some(reason),
+                }),
+                Err(reason) => Some(reason),
+            };
+            if let Some(reason) = reason {
+                seen.insert(item.id);
+                refused.push(Refused { item: item.id, reason });
+            }
+        }
+        refused
+    }
+
+    /// What the job writes more than once. An item in `refused` writes nothing, so it takes no part.
+    pub(crate) fn duplicate_outputs(&self, items: &[Vec<(RenderQueueItem, String)>], refused: &[Refused]) -> Result<Vec<DuplicateOutput>, String> {
+        let skip: HashSet<u64> = refused.iter().map(|r| r.item).collect();
+        let mut writes = Writes::default();
+        let mut duplicates = Vec::new();
+        for (m, path) in items.iter().flatten().filter(|(m, _)| !skip.contains(&m.id)) {
+            let paths = self.write_paths(m, path)?;
+            // Alternative destinations of one output cannot collide with themselves.
+            for path in &paths {
+                let write = self.write_of(m, path, true);
+                if let Some(clash) = writes.clash(&write) {
+                    duplicates.push(self.duplicate_of(&write, &clash));
+                    break;
+                }
+            }
+            for path in paths {
+                writes.push(self.write_of(m, &path, true))?;
+            }
+        }
+        Ok(duplicates)
+    }
+
+    /// Every possible destination, since quota decisions can change during rendering.
+    fn write_paths<'a>(&self, item: &RenderQueueItem, path: &'a str) -> Result<Vec<std::borrow::Cow<'a, str>>, String> {
+        let overflow = &self.project.render_prefs.overflow_folders;
+        const PATH_BYTES: usize = 1024 * 1024;
+        if path.len() > PATH_BYTES {
+            return Err("render output destinations exceed 1 MiB of path names".into());
+        }
+        let mut paths = vec![std::borrow::Cow::Borrowed(path)];
+        let mut bytes = path.len();
+        if item.settings.storage_overflow && self.storage_quota.is_some() {
+            if overflow.len() > 256 {
+                return Err("render output planning supports at most 256 storage overflow folders".into());
+            }
+            if let Some(name) = Path::new(path).file_name() {
+                for folder in overflow {
+                    if bytes.saturating_add(folder.len()).saturating_add(name.len()).saturating_add(1) > PATH_BYTES {
+                        return Err("render output destinations exceed 1 MiB of path names".into());
+                    }
+                    let destination = Path::new(folder).join(name).to_string_lossy().into_owned();
+                    bytes = bytes.saturating_add(destination.len());
+                    if bytes > PATH_BYTES {
+                        return Err("render output destinations exceed 1 MiB of path names".into());
+                    }
+                    paths.push(std::borrow::Cow::Owned(destination));
+                }
+            }
+        }
+        Ok(paths)
+    }
+
+    /// What `path`, an output of `m`, writes. `by_identity`: see [`Target::file`].
+    fn write_of(&self, m: &RenderQueueItem, path: &str, by_identity: bool) -> Write {
+        let target = if m.output.format.is_sequence() {
+            let (first, count) = self.project.comp(m.comp).map_or((0, 0), |c| (m.settings.first_frame(c), m.settings.frame_count(c)));
+            Target::frames(path, first, count)
+        } else {
+            Target::file(Path::new(path), by_identity)
+        };
+        let skips = m.settings.skip_existing && self.exporter.as_ref().is_some_and(|exporter| exporter.supports_skip_existing(&m.settings));
+        Write { item: m.id, path: path.to_string(), target, skips }
+    }
+
+    /// The report of `later` writing over `clash`.
+    fn duplicate_of(&self, later: &Write, clash: &Clash) -> DuplicateOutput {
+        // Where a queue item stands, and what it renders.
+        let place = |id: u64| {
+            let index = self.project.render_queue.iter().position(|i| i.id == id);
+            let comp = index.and_then(|k| self.project.render_queue.get(k)).and_then(|i| self.project.item(i.comp)).map(|i| i.name.clone());
+            (index.map_or(0, |k| k + 1), comp.unwrap_or_default())
+        };
+        let sequence = matches!(later.target, Target::Frames { .. });
+        // One shared frame is named by its file, more by the pattern.
+        let path = if sequence && clash.files == 1 { sequence_path(&later.path, clash.first) } else { later.path.clone() };
+        let (index, comp) = place(later.item);
+        let (with_index, with_comp) = place(clash.earlier.item);
+        DuplicateOutput { item: later.item, index, comp, path, files: clash.files, sequence, with: clash.earlier.item, with_index, with_comp }
+    }
+
+    fn check_output(&self, protected: &Protected, item: &RenderQueueItem, path: &str) -> Result<Option<String>, String> {
+        if protected.is_empty() {
+            return Ok(None);
+        }
+        let sequence = item.output.format.is_sequence();
+        // Skip Existing Files leaves existing frames untouched, but not the render log.
+        let frames = if sequence && !item.settings.skip_existing {
+            match self.project.comp(item.comp) {
+                Some(comp) => frames_on_disk(path, item.settings.first_frame(comp), item.settings.frame_count(comp))?,
+                None => Vec::new(),
+            }
+        } else {
+            Vec::new()
+        };
+        let log = log_path(path);
+        let movie = (!sequence).then_some(Path::new(path));
+        Ok(frames
+            .iter()
+            .map(PathBuf::as_path)
+            .chain(movie)
+            .chain(Some(Path::new(&log)))
+            .find_map(|path| protected.find(path).map(|source| source.refusal(&path.to_string_lossy(), Use::Render))))
+    }
+
+    /// A new item's default output must not be a file the project reads, nor one another item of
+    /// the queue writes (any of its output modules, whether or not it is ticked): `[compName]_1`,
+    /// `[compName]_2`… take its place, as After Effects numbers a second item of the same
+    /// composition. An output nothing is in the way of keeps the composition's own name; the name
+    /// is stored in the item, so it stays as it is when the item it avoided goes away. One the
+    /// caller chose is not touched: rendering it is refused instead ([`Session::duplicate_outputs`]).
+    pub(crate) fn avoid_sources(&self, item: &mut RenderQueueItem) {
+        // Native source protection stays with its filesystem guard; virtual web outputs still
+        // need distinct queue names because the browser stores completed files by path.
+        let protected = if cfg!(target_arch = "wasm32") { Protected::default() } else { self.protected_files() };
+        let Ok(queue) = self.queue_writes() else { return };
+        if protected.is_empty() && queue.is_empty() {
+            return;
+        }
+        let template = item.output.output.clone();
+        for n in 0..=MAX_NUMBER {
+            item.output.output = if n == 0 { template.clone() } else { numbered_template(&template, n) };
+            let Ok(outputs) = self.outputs_of(item, None) else { break };
+            let mut in_the_way = false;
+            for (module, path) in &outputs {
+                let Ok(paths) = self.write_paths(module, path) else {
+                    item.output.output = template;
+                    return;
+                };
+                for destination in &paths {
+                    match self.check_output(&protected, module, destination) {
+                        Ok(Some(_)) => in_the_way = true,
+                        Err(_) => {
+                            item.output.output = template;
+                            return;
+                        }
+                        Ok(None) => {}
+                    }
+                }
+                in_the_way |= paths.iter().any(|path| queue.clash(&self.write_of(module, path, false)).is_some());
+            }
+            if !in_the_way {
+                return;
+            }
+        }
+        item.output.output = template;
+    }
+
+    /// What the items of the queue write (by name: a new item is not compared with what is on
+    /// disk).
+    fn queue_writes(&self) -> Result<Writes, String> {
+        let mut writes = Writes::default();
+        for outputs in self.project.render_queue.iter().filter_map(|it| self.outputs_of(it, None).ok()) {
+            for (m, path) in &outputs {
+                for path in self.write_paths(m, path)? {
+                    writes.push(self.write_of(m, &path, false))?;
+                }
+            }
+        }
+        Ok(writes)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    /// Portable path checks protect virtual outputs too; they do not need native file identity.
+    #[test]
+    fn duplicate_queue_paths_are_reported_without_native_files() {
+        let mut s = Session::default();
+        s.execute("comp.new", json!({"name": "Main", "width": 16, "height": 16})).unwrap();
+        for _ in 0..2 {
+            s.execute("renderQueue.add", json!({"format": "h264", "output": "/virtual/shared.mp4"})).unwrap();
+        }
+        let (outputs, _) = s.queued_outputs(&effectcraft_project::render_queue::OutputFormat::ALL);
+        let duplicates = s.duplicate_outputs(&outputs, &[]).unwrap();
+        assert_eq!(duplicates.len(), 1);
+        assert!(duplicates[0].path.ends_with("shared.mp4"));
+        let refused = [Refused { item: duplicates[0].item, reason: "already refused".into() }];
+        assert!(s.duplicate_outputs(&outputs, &refused).unwrap().is_empty());
+    }
+
+    /// An output of queue item `item` that is a file, known by its name alone.
+    fn movie(item: u64, path: &str) -> Write {
+        Write { item, path: path.into(), target: Target::file(Path::new(path), false), skips: false }
+    }
+
+    /// An output of queue item `item` that is `count` frames of a sequence from frame `first`.
+    fn frames(item: u64, pattern: &str, first: i64, count: u64) -> Write {
+        Write { item, path: pattern.into(), target: Target::frames(pattern, first, count), skips: false }
+    }
+
+    fn job_of(writes: impl IntoIterator<Item = Write>) -> Writes {
+        let mut job = Writes::default();
+        for write in writes {
+            job.push(write).unwrap();
+        }
+        job
+    }
+
+    #[test]
+    fn browser_output_names_match_the_virtual_file_table() {
+        assert_eq!(browser_key(Path::new("renders/a.png")), browser_key(Path::new("/renders/a.png")));
+        assert_ne!(browser_key(Path::new("renders/A.png")), browser_key(Path::new("renders/a.png")));
+        assert_ne!(browser_key(Path::new("renders/../a.png")), browser_key(Path::new("a.png")));
+        assert_ne!(browser_key(Path::new("//a.png")), browser_key(Path::new("/a.png")));
+    }
+
+    #[test]
+    fn output_plan_path_budget_returns_an_error() {
+        let mut job = Writes::default();
+        let path = "x".repeat(1024 * 1024);
+        for _ in 0..16 {
+            job.push(movie(1, &path)).unwrap();
+        }
+        assert!(job.push(movie(2, "one-too-many")).is_err());
+        assert_eq!(job.all.len(), 16);
+    }
+
+    /// The item an output replaces a file of, how many files, and the first.
+    fn clash(job: &Writes, later: &Write) -> Option<(u64, u64, i64)> {
+        job.clash(later).map(|c| (c.earlier.item, c.files, c.first))
+    }
+
+    #[test]
+    fn a_file_is_replaced_by_the_output_that_has_its_name() {
+        let job = job_of([movie(1, "out/a.mp4"), movie(2, "out/b.mp4"), movie(3, "out/b.mp4")]);
+        assert_eq!(clash(&job, &movie(9, "out/a.mp4")), Some((1, 1, 0)));
+        assert_eq!(clash(&job, &movie(9, "out/b.mp4")), Some((2, 1, 0)), "the first to write it is named");
+        assert_eq!(clash(&job, &movie(9, "out/x/../a.mp4")), Some((1, 1, 0)), "dot segments are resolved");
+        assert_eq!(clash(&job, &movie(9, "out/c.mp4")), None);
+        assert_eq!(clash(&job, &movie(9, "other/a.mp4")), None);
+        assert_eq!(clash(&job, &frames(9, "out/a.mp4", 0, 5)), None, "a sequence is not a movie");
+        assert!(Writes::default().is_empty() && !job.is_empty());
+    }
+
+    #[test]
+    fn two_names_of_one_file_on_disk_are_one_file() {
+        let on_disk = |item: u64, name: &str, id: Option<&str>| Write {
+            item,
+            path: name.into(),
+            target: Target::File { key: name.into(), identity: id.map(String::from) },
+            skips: false,
+        };
+        let job = job_of([on_disk(1, "/a/link.mp4", Some("7:1")), on_disk(2, "/a/nothing-yet.mp4", None)]);
+        assert_eq!(clash(&job, &on_disk(9, "/b/real.mp4", Some("7:1"))), Some((1, 1, 0)));
+        assert_eq!(clash(&job, &on_disk(9, "/b/real.mp4", Some("7:2"))), None);
+        assert_eq!(clash(&job, &on_disk(9, "/b/real.mp4", None)), None, "a file that is not there has no identity");
+        assert_eq!(clash(&job, &on_disk(9, "/a/nothing-yet.mp4", None)), Some((2, 1, 0)), "its name is all there is");
+    }
+
+    #[test]
+    fn sequences_clash_where_their_frames_do() {
+        let job = job_of([frames(1, "a_[#####].png", 0, 5)]); // frames 0-4
+        assert_eq!(clash(&job, &frames(2, "a_[#####].png", 5, 5)), None, "the five after it");
+        assert_eq!(clash(&job, &frames(2, "a_[#####].png", -3, 3)), None, "the three before it");
+        assert_eq!(clash(&job, &frames(2, "a_[#####].png", 4, 5)), Some((1, 1, 4)), "frame 4 only");
+        assert_eq!(clash(&job, &frames(2, "a_[#####].png", 2, 1)), Some((1, 1, 2)));
+        assert_eq!(clash(&job, &frames(2, "a_[#####].png", 1, 2)), Some((1, 2, 1)));
+        assert_eq!(clash(&job, &frames(2, "a_[#####].png", -3, 100)), Some((1, 5, 0)), "all five");
+        // The first of several that overlap is the one named.
+        let job = job_of([frames(1, "a_[#####].png", 0, 3), frames(2, "a_[#####].png", 3, 3)]);
+        assert_eq!(clash(&job, &frames(9, "a_[#####].png", 2, 3)), Some((1, 1, 2)));
+        assert_eq!(clash(&job, &frames(9, "a_[#####].png", 3, 3)), Some((2, 3, 3)));
+    }
+
+    #[test]
+    fn sequences_of_other_names_do_not_clash() {
+        let job = job_of([frames(1, "out/a_[#####].png", 0, 5)]);
+        for other in ["out/b_[#####].png", "out/a_[####].png", "out/a_[#####].jpg", "elsewhere/a_[#####].png", "out/a[#####].png", "out/a_[#####]/x.png"] {
+            assert_eq!(clash(&job, &frames(2, other, 0, 5)), None, "{other}");
+        }
+        // One name, however it is spelled: the run with or without brackets, none at all, dot segments.
+        for same in ["out/a_[#####].png", "out/a_#####.png", "out/a.png", "out/b/../a_[#####].png"] {
+            assert_eq!(clash(&job, &frames(2, same, 0, 5)), Some((1, 5, 0)), "{same}");
+        }
+        // A frame number that starts a folder's name is not a file name's.
+        let job = job_of([frames(1, "out/[##].png", 0, 5)]);
+        assert_eq!(clash(&job, &frames(2, "out[##].png", 0, 5)), None);
+        assert_eq!(clash(&job, &frames(2, "out/[##].png", 0, 5)), Some((1, 5, 0)));
+    }
+
+    #[test]
+    fn padding_widths_can_name_the_same_frame_and_files_can_name_sequence_frames() {
+        let job = job_of([frames(1, "out/a_[####].png", 9999, 3)]);
+        assert_eq!(clash(&job, &frames(2, "out/a_[#####].png", 9999, 3)), Some((1, 2, 10000)));
+        let job = job_of([frames(1, "out/a_[##].png", -12, 15)]);
+        assert_eq!(clash(&job, &frames(2, "out/a_[###].png", -12, 15)), Some((1, 3, -12)));
+        let job = job_of([frames(1, "out/a_[#####].png", 0, 5)]);
+        assert_eq!(clash(&job, &movie(2, "out/a_00002.png")), Some((1, 1, 2)));
+        let job = job_of([movie(1, "out/a_00002.png")]);
+        assert_eq!(clash(&job, &frames(2, "out/a_[#####].png", 0, 5)), Some((1, 1, 2)));
+        let mut skipping = frames(2, "out/a_[#####].png", 0, 5);
+        skipping.skips = true;
+        assert_eq!(clash(&job, &skipping), None);
+    }
+
+    /// Skip Existing Files leaves a frame that is there alone: it matters for the output that
+    /// comes second, and for sequences only.
+    #[test]
+    fn an_output_that_skips_existing_frames_replaces_none() {
+        let skipping = |mut write: Write| {
+            write.skips = true;
+            write
+        };
+        let job_of_one = job_of([frames(1, "a_[#####].png", 0, 5)]);
+        assert_eq!(clash(&job_of_one, &skipping(frames(2, "a_[#####].png", 0, 5))), None);
+        let job_of_one = job_of([skipping(frames(1, "a_[#####].png", 0, 5))]);
+        assert_eq!(clash(&job_of_one, &frames(2, "a_[#####].png", 3, 5)), Some((1, 2, 3)), "the earlier one's frames are replaced");
+        let job_of_one = job_of([movie(1, "a.mp4")]);
+        assert_eq!(clash(&job_of_one, &skipping(movie(2, "a.mp4"))), Some((1, 1, 0)), "a movie is written whole");
+    }
+
+    #[test]
+    fn frame_numbers_beyond_what_a_project_holds_do_not_panic() {
+        let top = i64::MAX - 1;
+        let job = job_of([frames(1, "a_[#####].png", top, u64::MAX), frames(2, "a_[#####].png", i64::MIN, u64::MAX)]);
+        assert_eq!(clash(&job, &frames(9, "a_[#####].png", top, u64::MAX)), Some((1, 1, top)));
+        assert_eq!(clash(&job, &frames(9, "a_[#####].png", -5, 3)), Some((2, 3, -5)));
+        assert_eq!(clash(&job, &frames(9, "a_[#####].png", 0, 5)), None, "between the two");
+        assert_eq!(clash(&job, &frames(9, "a_[#####].png", i64::MAX, 0)), None, "nothing written");
+        assert_eq!(clash(&job, &frames(9, "a_[#####].png", i64::MIN, 0)), None);
+    }
+
+    #[test]
+    fn the_reason_names_both_items_and_what_they_write() {
+        let both = DuplicateOutput {
+            item: 7,
+            index: 3,
+            comp: "Main".into(),
+            path: "/o/Main.mp4".into(),
+            files: 1,
+            sequence: false,
+            with: 4,
+            with_index: 1,
+            with_comp: "Intro".into(),
+        };
+        assert_eq!(
+            both.reason(),
+            "#1 “Intro” and #3 “Main” would both write /o/Main.mp4, and a render never writes one file twice; choose another Output To for one of them"
+        );
+        let sequence = DuplicateOutput { sequence: true, files: 12, path: "/o/Main_[#####].png".into(), ..both.clone() };
+        assert!(sequence.reason().contains("would both write 12 frames of /o/Main_[#####].png,"), "{}", sequence.reason());
+        let one = DuplicateOutput { files: 1, path: "/o/Main_00004.png".into(), ..sequence };
+        assert!(one.reason().contains("would both write /o/Main_00004.png,"), "{}", one.reason());
+        let itself = DuplicateOutput { with: 7, with_index: 3, with_comp: "Main".into(), ..both.clone() };
+        assert!(itself.reason().starts_with("#3 “Main” would write /o/Main.mp4 twice (two of its output modules), and a render never"), "{}", itself.reason());
+
+        let mut found = vec![];
+        assert_eq!(duplicate_refusal(&found), None);
+        found.push(both.clone());
+        assert_eq!(duplicate_refusal(&found), Some(format!("{}. Nothing was rendered", both.reason())));
+        found.push(both.clone());
+        assert!(duplicate_refusal(&found).is_some_and(|r| r.ends_with("Nothing was rendered; 1 more output would write a file twice too")));
+        found.push(both);
+        assert!(duplicate_refusal(&found).is_some_and(|r| r.ends_with("Nothing was rendered; 2 more outputs would write a file twice too")));
+    }
+
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))]
+    fn unrelated_same_size_frames_are_indexed_once() {
+        let dir = std::env::temp_dir().join(format!("effectcraft-identity-index-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        let mut protected = Protected::default();
+        for i in 0..128 {
+            let source = dir.join(format!("source{i}")).join("plate.png");
+            let output = dir.join(format!("output{i}")).join("plate.png");
+            for path in [&source, &output] {
+                std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+                std::fs::write(path, b"same-size frame").unwrap();
+            }
+            protected.add(source, Source::Footage(format!("plate{i}").into()));
+        }
+        for i in 0..128 {
+            assert!(protected.find(&dir.join(format!("output{i}")).join("plate.png")).is_none());
+        }
+        assert_eq!(protected.identity_reads.load(std::sync::atomic::Ordering::Relaxed), 256, "one source-index pass plus one lookup per output");
+        let alias = dir.join("renamed.png");
+        std::fs::hard_link(dir.join("source64").join("plate.png"), &alias).unwrap();
+        assert_eq!(protected.find(&alias), Some(&Source::Footage("plate64".into())));
+        assert_eq!(protected.identity_reads.load(std::sync::atomic::Ordering::Relaxed), 258, "native equality verifies a matching identity");
+        std::fs::remove_dir_all(dir).unwrap();
+    }
+
+    #[test]
+    fn folder_numbered_sequences_are_never_partially_checked() {
+        let pattern = std::env::temp_dir().join("frames[######]").join("plate.png").to_string_lossy().into_owned();
+        let error = frames_on_disk(&pattern, 0, PROBE_LIMIT + 1).unwrap_err();
+        assert!(error.contains("cannot safely check") && error.contains("100000"), "{error}");
+        assert!(frames_on_disk(&pattern, 0, u64::MAX).is_err());
+    }
+
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))]
+    fn non_file_outputs_do_not_build_the_identity_index() {
+        let protected = Protected::default();
+        assert!(protected.find(&std::env::temp_dir()).is_none());
+        assert!(protected.by_identity.get().is_none());
+    }
+
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))]
+    fn paths_compare_by_name_once_resolved() {
+        let here = std::env::current_dir().unwrap();
+        assert_eq!(key(Path::new("a/b/../c.mp4")), key(Path::new("a/c.mp4")));
+        assert_eq!(key(Path::new("./a/c.mp4")), key(&here.join("a/c.mp4")));
+        assert_ne!(key(Path::new("a/c.mp4")), key(Path::new("b/c.mp4")));
+        assert_eq!(key(Path::new(&format!("{}x", "../".repeat(64)))), key(Path::new(&format!("{}x", "../".repeat(80)))), "past the root stays at the root");
+        assert_eq!(IGNORES_CASE, key(Path::new("A/C.MP4")) == key(Path::new("a/c.mp4")));
+    }
+
+    #[test]
+    fn a_file_is_the_same_file_under_every_spelling_the_volume_allows() {
+        let dir = std::env::temp_dir().join(format!("effectcraft-output-guard-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(dir.join("sub")).unwrap();
+        std::fs::write(dir.join("clip.mov"), b"x").unwrap();
+        std::fs::write(dir.join("other.mov"), b"y").unwrap();
+        assert!(same_file(&dir.join("clip.mov"), &dir.join("sub").join("..").join("clip.mov")));
+        assert!(!same_file(&dir.join("clip.mov"), &dir.join("other.mov")));
+        // Nothing there yet: only the name decides.
+        assert!(same_file(&dir.join("gone.mov"), &dir.join("sub").join("..").join("gone.mov")));
+        assert!(!same_file(&dir.join("gone.mov"), &dir.join("clip.mov")));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn a_sequences_folder_is_read_once_for_its_frames() {
+        let dir = std::env::temp_dir().join(format!("effectcraft-output-frames-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(dir.join("a_00003.png")).unwrap(); // a folder is not a frame
+        for name in ["a_00001.png", "a_00002.png", "a_0004.png", "a_00004.jpg", "b_00002.png", "a_00009.png"] {
+            std::fs::write(dir.join(name), b"x").unwrap();
+        }
+        let pattern = dir.join("a_[#####].png").to_string_lossy().into_owned();
+        let names = |frames: Vec<PathBuf>| {
+            let mut names: Vec<String> = frames.iter().filter_map(|f| f.file_name()).map(|n| n.to_string_lossy().into_owned()).collect();
+            names.sort();
+            names
+        };
+        assert_eq!(
+            names(frames_on_disk(&pattern, 0, 5).unwrap()),
+            ["a_00001.png", "a_00002.png"],
+            "frames 0-4: not the 4-digit one, the jpg, the folder or frame 9"
+        );
+        assert_eq!(names(frames_on_disk(&pattern, 2, 1).unwrap()), ["a_00002.png"]);
+        assert_eq!(names(frames_on_disk(&pattern, 9, 100).unwrap()), ["a_00009.png"]);
+        assert_eq!(names(frames_on_disk(&pattern, 0, u64::MAX).unwrap()), ["a_00001.png", "a_00002.png", "a_00009.png"], "a hostile frame count is not walked");
+        // A frame number in a folder's name: each frame has its own folder.
+        std::fs::create_dir_all(dir.join("f02")).unwrap();
+        std::fs::write(dir.join("f02").join("x.png"), b"x").unwrap();
+        let in_folder = dir.join("f[##]").join("x.png").to_string_lossy().into_owned();
+        assert_eq!(names(frames_on_disk(&in_folder, 0, 4).unwrap()), ["x.png"]);
+        // A folder that is not there holds nothing.
+        assert!(frames_on_disk(&dir.join("none").join("a_[#####].png").to_string_lossy(), 0, 5).unwrap().is_empty());
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}
diff --git a/crates/engine/src/prefs.rs b/crates/engine/src/prefs.rs
deleted file mode 100644
index 30b806683..000000000
--- a/crates/engine/src/prefs.rs
+++ /dev/null
@@ -1,1518 +0,0 @@
-//! Settings (After Effects' Preferences): a versioned serde model, addressed by dotted keys
-//! (`general.undoLevels`, `autoSave.intervalMinutes`, `labels.3.name`), plus the page schema the
-//! Settings dialog and agents (`prefs.pages`) are built from.
-//!
-//! Settings are stored as JSON (`prefs.json`) through the session's [`crate::config::ConfigStore`].
-//! Loading is forgiving: missing keys take their defaults, unknown keys (written by a newer
-//! version) are kept and written back, and older layouts are migrated ([`migrate`]).
-//!
-//! Every setting in [`pages`] says whether it already changes behaviour (`live`). Settings that
-//! don't yet are still shown (After Effects parity of the dialog) and are listed in
-//! `docs/preferences.md`; a test keeps that list in step with the schema.
-
-use std::collections::BTreeMap;
-
-use effectcraft_color::Label;
-use effectcraft_time::Tick;
-use serde::{Deserialize, Serialize};
-use serde_json::{Map, Value, json};
-
-/// Current settings layout version.
-pub const PREFS_VERSION: u32 = 2;
-/// Settings file name in the config store.
-pub const PREFS_FILE: &str = "prefs.json";
-
-/// Settings ▸ General ▸ Language: (label, `general.language` value).
-pub const LANGUAGES: &[(&str, &str)] = &[
-    ("Match System", "system"),
-    ("English", "en"),
-    // Alphabetical by the language's own name after English; Cyrillic, Georgian, then CJK names
-    // follow the Latin ones.
-    ("Čeština", "cs"),
-    ("Deutsch", "de"),
-    ("Español", "es"),
-    ("Français", "fr"),
-    ("Português (Brasil)", "pt-br"),
-    ("Русский", "ru"),
-    ("Українська", "uk"),
-    ("ქართული", "ka"),
-    ("日本語", "ja"),
-    ("简体中文", "zh-hans"),
-    ("繁體中文", "zh-hant"),
-];
-
-/// Settings ▸ Startup & Repair ▸ Window Graphics: (label, `startup.windowGraphics` value).
-pub const WINDOW_GRAPHICS: &[(&str, &str)] = &[("Automatic", "auto"), ("OpenGL (compatibility)", "gl")];
-
-/// Settings ▸ Appearance ▸ Appearance Mode: (label, `appearance.appearanceMode` value). Auto
-/// follows the operating system's light or dark appearance.
-pub const APPEARANCE_MODES: &[(&str, &str)] = &[("Sync with System", "auto"), ("Dark", "dark"), ("Light", "light")];
-
-/// The dark family of themes: (label, `appearance.darkTheme` value).
-pub const DARK_THEMES: &[(&str, &str)] = &[("Dark", "dark"), ("Darker", "darker")];
-
-/// The light family of themes: (label, `appearance.lightTheme` value).
-pub const LIGHT_THEMES: &[(&str, &str)] = &[("Light", "light")];
-
-/// Every theme (the legacy single-theme `appearance.theme`).
-pub const THEMES: &[(&str, &str)] = &[("Dark", "dark"), ("Darker", "darker"), ("Light", "light")];
-
-/// The settings whose value must be one of their choices.
-fn choices(key: &str) -> Option<&'static [(&'static str, &'static str)]> {
-    match key {
-        "general.language" => Some(LANGUAGES),
-        "startup.windowGraphics" => Some(WINDOW_GRAPHICS),
-        "appearance.appearanceMode" => Some(APPEARANCE_MODES),
-        "appearance.darkTheme" => Some(DARK_THEMES),
-        "appearance.lightTheme" => Some(LIGHT_THEMES),
-        "appearance.theme" => Some(THEMES),
-        _ => None,
-    }
-}
-
-fn is_choice(choices: &[(&str, &str)], v: &str) -> bool {
-    choices.iter().any(|(_, c)| *c == v)
-}
-
-/// Unknown keys inside a page, kept so a newer version's settings survive a round trip.
-type Extra = BTreeMap<String, Value>;
-
-macro_rules! page {
-    ($(#[$m:meta])* $name:ident { $($(#[$fm:meta])* $f:ident : $t:ty = $d:expr),* $(,)? }) => {
-        $(#[$m])*
-        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-        #[serde(default, rename_all = "camelCase")]
-        pub struct $name {
-            $($(#[$fm])* pub $f: $t,)*
-            #[serde(flatten)]
-            pub extra: Extra,
-        }
-        impl Default for $name {
-            fn default() -> Self {
-                $name { $($f: $d,)* extra: Extra::new() }
-            }
-        }
-    };
-}
-
-page!(General {
-    /// Interface language: `system` (the operating system's, where EffectCraft has it, else
-    /// English), or a language code from `LANGUAGES`.
-    language: String = "system".into(),
-    /// Levels of Undo (1–99).
-    undo_levels: u32 = 32,
-    /// Path Point and Handle Size (px).
-    path_point_size: u32 = 5,
-    show_tool_tips: bool = true,
-    /// Create New Layers at Composition Start Time (off: at the current time).
-    create_layers_at_comp_start: bool = true,
-    switches_affect_nested_comps: bool = true,
-    /// Default Spatial Interpolation to Linear.
-    default_spatial_linear: bool = false,
-    preserve_constant_vertex_count: bool = true,
-    /// Synchronize Time of All Related Items.
-    sync_time_related_items: bool = true,
-    expression_pick_whip_compact: bool = true,
-    /// Create Split Layers Above Original Layer (After Effects' default).
-    create_split_layers_above: bool = true,
-    use_system_color_picker: bool = false,
-    /// Number of projects in File ▸ Open Recent.
-    recent_items: u32 = 10,
-});
-
-page!(Startup {
-    show_home_on_launch: bool = true,
-    show_home_on_open_project: bool = false,
-    /// After a crash, offer to open the most recent auto-save.
-    offer_crash_recovery: bool = true,
-    /// What the desktop window draws with, from the next launch: `auto` (the platform's best
-    /// graphics API) or `gl` (OpenGL, for drivers that crash with the others). A launch that
-    /// stops as its window opens switches it to `gl` (#243).
-    window_graphics: String = "auto".into(),
-});
-
-page!(ProjectPrefs {
-    /// Open a template project for File ▸ New ▸ New Project.
-    use_template: bool = false,
-    template_path: String = String::new(),
-});
-
-page!(AutoSave {
-    enabled: bool = true,
-    interval_minutes: u32 = 20,
-    max_versions: u32 = 5,
-    /// `nextToProject` (an "EffectCraft Auto-Save" folder beside the project) or `custom`.
-    location: String = "nextToProject".into(),
-    folder: String = String::new(),
-    save_on_render_start: bool = false,
-});
-
-page!(CompositionPrefs {
-    /// Motion path: `all`, `none`, `seconds`, `keyframes`.
-    motion_path: String = "keyframes".into(),
-    motion_path_seconds: f64 = 15.0,
-    motion_path_keyframes: u32 = 15,
-    show_rendering_progress: bool = true,
-    hardware_accelerate_panels: bool = true,
-});
-
-page!(Previews {
-    /// Largest downsampling while playing back: `1/2`, `1/4`, `1/8`.
-    adaptive_resolution_limit: String = "1/8".into(),
-    show_internal_wireframes: bool = false,
-    cache_frames_when_idle: bool = false,
-    fast_previews: bool = false,
-    /// `faster` or `moreAccurate`.
-    zoom_quality: String = "moreAccurate".into(),
-    show_gpu_info: bool = false,
-    /// The monitor's colour space for View ▸ Use Display Color Management: `srgb` or `p3`.
-    display_profile: String = "srgb".into(),
-});
-
-page!(Appearance {
-    /// The single theme before appearance modes (`dark`, `darker` or `light`), kept for older
-    /// settings files and automation: setting it picks its family's mode and theme. While the mode
-    /// is Dark or Light it mirrors the theme in use.
-    theme: String = "dark".into(),
-    /// `auto` (follow the operating system), `dark` or `light`. New installs stay Dark.
-    appearance_mode: String = "dark".into(),
-    /// The theme used in dark appearance: `dark` or `darker`.
-    dark_theme: String = "dark".into(),
-    /// The theme used in light appearance: `light`.
-    light_theme: String = "light".into(),
-    /// Theme shortcuts in the appearance context menu.
-    favorite_themes: Vec<String> = Vec::new(),
-    /// User interface brightness, -1 (darker) … 1 (lighter).
-    brightness: f64 = 0.0,
-    /// The size of the whole interface in percent (75–200), on top of the display's own scale.
-    ui_scale: u32 = 100,
-    use_label_color_for_handles: bool = true,
-    use_label_color_for_tabs: bool = true,
-    cycle_mask_colors: bool = true,
-    use_gradients: bool = true,
-    /// macOS: draw the menu bar inside the window instead of the system menu bar.
-    in_window_menu_bar_mac: bool = false,
-});
-
-page!(Grids {
-    grid_color: String = "#7a9cff".into(),
-    grid_spacing: f64 = 100.0,
-    grid_subdivisions: u32 = 4,
-    /// `lines`, `dashed` or `dots`.
-    grid_style: String = "lines".into(),
-    proportional_horizontal: u32 = 4,
-    proportional_vertical: u32 = 4,
-    guide_color: String = "#3cc8f0".into(),
-    guide_style: String = "lines".into(),
-    action_safe: f64 = 10.0,
-    title_safe: f64 = 20.0,
-});
-
-page!(TypePrefs {
-    /// `latin` or `southAsian` (South Asian and Middle Eastern).
-    text_engine: String = "latin".into(),
-    font_preview: bool = true,
-    recent_fonts: u32 = 10,
-    font_names_in_english: bool = false,
-});
-
-page!(Import {
-    /// Still footage duration: `compLength` or `seconds`.
-    still_footage: String = "compLength".into(),
-    still_seconds: f64 = 5.0,
-    sequence_fps: f64 = 30.0,
-    report_missing_frames: bool = true,
-    /// Automatically Reload Footage whose file another app changed (size or modification time),
-    /// checked every two seconds and when the window comes back to the front: `off`,
-    /// `nonSequence` (the default, as in After Effects: image sequences are left alone) or `all`.
-    auto_reload_footage: String = "nonSequence".into(),
-    /// Interpret unlabeled alpha as: `ask`, `guess`, `ignore`, `straight`, `premultiplied`.
-    unlabeled_alpha: String = "ask".into(),
-    /// Default drag import as: `footage`, `comp`, `compLayerSizes`.
-    drag_import_as: String = "footage".into(),
-});
-
-page!(Export {
-    default_output_folder: String = String::new(),
-    segment_sequences: bool = false,
-    segment_sequence_files: u32 = 700,
-    segment_movies: bool = false,
-    segment_movie_mb: u32 = 1024,
-    append_bits_to_name: bool = false,
-});
-
-page!(Audio {
-    /// Output device name (empty = the system default).
-    output_device: String = String::new(),
-    /// Output mapping: device channel for the left / right output (1-based).
-    output_left: u32 = 1,
-    output_right: u32 = 2,
-    preview_sample_rate: u32 = 48_000,
-});
-
-page!(Disk {
-    disk_cache_enabled: bool = true,
-    disk_cache_max_gb: u32 = 100,
-    disk_cache_folder: String = String::new(),
-    media_cache_folder: String = String::new(),
-    conformed_media_folder: String = String::new(),
-});
-
-page!(Memory {
-    ram_reserved_gb: u32 = 6,
-    /// Processed-layer cache budget (MB).
-    layer_cache_mb: u32 = 1024,
-    /// Decoded footage frame cache budget (MB).
-    media_cache_mb: u32 = 1024,
-    /// RAM preview (viewer frame) cache budget (MB).
-    preview_cache_mb: u32 = 3072,
-    reduce_cache_when_low: bool = true,
-});
-
-page!(Video {
-    enable_output: bool = false,
-    device: String = String::new(),
-    output_during_playback: bool = true,
-    mirror_on_monitor: bool = true,
-    disable_when_background: bool = false,
-});
-
-page!(ThreeD {
-    /// Default 3D renderer for new compositions: `classic` or `advanced`.
-    default_renderer: String = "classic".into(),
-    show_reference_axes: bool = true,
-    extended_viewer: bool = false,
-    realtime_shadows: bool = true,
-});
-
-page!(
-    /// Settings ▸ Roto Brush.
-    RotoPrefs {
-        /// The segmentation model Roto Brush 2.0 / 3.0 use: `classical` (built in) or a model id
-        /// from `effectcraft_segment::MODELS` (once installed).
-        model: String = "classical".into(),
-    }
-);
-
-page!(
-    /// Settings ▸ Face Tracking.
-    FacePrefs {
-        /// The model Track Mask ▸ Face Tracking uses: `classical` (built in) or a model id from
-        /// `effectcraft_segment::MODELS` (once installed).
-        model: String = "classical".into(),
-    }
-);
-
-page!(Scripting {
-    allow_scripts_write_files: bool = false,
-    warn_executing_files: bool = true,
-    enable_js_debugger: bool = false,
-    editor_font_size: u32 = 13,
-    syntax_highlighting: bool = true,
-    line_numbers: bool = true,
-    auto_complete: bool = true,
-    bracket_matching: bool = true,
-    word_wrap: bool = false,
-    error_banner: bool = true,
-});
-
-impl Scripting {
-    /// Whether `other` grants scripts the same as this: Application Scripting (file and network
-    /// access, the warning before executing files, the debugger). Scripts can't change these
-    /// ([`crate::Session::execute_for_script`]): a script could otherwise give itself the
-    /// access the user withheld.
-    pub fn same_permissions(&self, other: &Scripting) -> bool {
-        self.allow_scripts_write_files == other.allow_scripts_write_files
-            && self.warn_executing_files == other.warn_executing_files
-            && self.enable_js_debugger == other.enable_js_debugger
-    }
-
-    /// Take `from`'s Application Scripting settings (see [`Scripting::same_permissions`]).
-    pub fn keep_permissions(&mut self, from: &Scripting) {
-        self.allow_scripts_write_files = from.allow_scripts_write_files;
-        self.warn_executing_files = from.warn_executing_files;
-        self.enable_js_debugger = from.enable_js_debugger;
-    }
-}
-
-/// One editable label: name and `#rrggbb` colour.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct LabelPref {
-    pub name: String,
-    pub color: String,
-}
-
-/// A Composition Settings preset the user saved (Composition Settings ▸ Preset ▸ Save): the
-/// frame size, pixel aspect and frame rate, as in After Effects' own presets.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CompPreset {
-    pub name: String,
-    pub width: u32,
-    pub height: u32,
-    pub pixel_aspect: f64,
-    pub frame_rate: f64,
-}
-
-impl CompPreset {
-    /// Longest preset name kept.
-    pub const MAX_NAME: usize = 128;
-
-    /// Values a composition accepts (a hand-edited settings file can hold anything).
-    pub fn is_valid(&self) -> bool {
-        let size = 4..=30000;
-        !self.name.trim().is_empty()
-            && self.name.chars().count() <= Self::MAX_NAME
-            && size.contains(&self.width)
-            && size.contains(&self.height)
-            && self.pixel_aspect.is_finite()
-            && (0.01..=100.0).contains(&self.pixel_aspect)
-            && self.frame_rate.is_finite()
-            && (1.0..=999.0).contains(&self.frame_rate)
-    }
-}
-
-/// Saved composition presets, skipping entries that don't parse instead of losing the list.
-fn lenient_comp_presets<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<CompPreset>, D::Error> {
-    let v = Vec::<Value>::deserialize(d)?;
-    Ok(v.into_iter().filter_map(|x| serde_json::from_value(x).ok()).collect())
-}
-
-fn default_labels() -> Vec<LabelPref> {
-    Label::ALL.iter().skip(1).map(|l| LabelPref { name: l.name().to_string(), color: hex(l.rgb()) }).collect()
-}
-
-fn hex([r, g, b]: [u8; 3]) -> String {
-    format!("#{r:02x}{g:02x}{b:02x}")
-}
-
-fn parse_hex(s: &str) -> Option<[u8; 3]> {
-    let h = s.trim().trim_start_matches('#');
-    if h.len() != 6 {
-        return None;
-    }
-    let p = |i: usize| u8::from_str_radix(h.get(i..i + 2)?, 16).ok();
-    Some([p(0)?, p(2)?, p(4)?])
-}
-
-/// All settings.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(default, rename_all = "camelCase")]
-pub struct Prefs {
-    pub version: u32,
-    pub general: General,
-    pub startup: Startup,
-    pub project: ProjectPrefs,
-    pub auto_save: AutoSave,
-    pub composition: CompositionPrefs,
-    pub previews: Previews,
-    pub appearance: Appearance,
-    pub grids: Grids,
-    /// The 16 labels (Red … Dark Green), in order.
-    pub labels: Vec<LabelPref>,
-    #[serde(rename = "type")]
-    pub type_: TypePrefs,
-    pub import: Import,
-    pub export: Export,
-    pub audio: Audio,
-    pub disk: Disk,
-    pub memory: Memory,
-    pub video: Video,
-    #[serde(rename = "threeD")]
-    pub three_d: ThreeD,
-    pub scripting: Scripting,
-    pub roto: RotoPrefs,
-    pub face: FacePrefs,
-    /// File ▸ Open Recent, newest first.
-    pub recent_projects: Vec<String>,
-    /// File ▸ Import Recent Footage, newest first.
-    pub recent_footage: Vec<String>,
-    /// Animation ▸ Recent Animation Presets (`.ecpreset` paths or built-in preset ids), newest
-    /// first.
-    pub recent_presets: Vec<String>,
-    /// Character panel: recently used font families, newest first.
-    pub recent_fonts: Vec<String>,
-    /// Effects & Presets: the starred effects' ids, in the order starred.
-    pub effects_favorites: Vec<String>,
-    /// Preview panel: every shortcut's options.
-    pub preview: crate::preview::PreviewSettings,
-    /// View ▸ Simulate Output ▸ My Custom RGB.
-    pub custom_rgb: crate::viewer::CustomRgb,
-    /// Composition Settings presets the user saved, in the order saved.
-    #[serde(deserialize_with = "lenient_comp_presets")]
-    pub comp_presets: Vec<CompPreset>,
-    /// Top-level keys this version doesn't know (kept for newer versions).
-    #[serde(flatten)]
-    pub extra: Extra,
-}
-
-impl Default for Prefs {
-    fn default() -> Self {
-        Prefs {
-            version: PREFS_VERSION,
-            general: General::default(),
-            startup: Startup::default(),
-            project: ProjectPrefs::default(),
-            auto_save: AutoSave::default(),
-            composition: CompositionPrefs::default(),
-            previews: Previews::default(),
-            appearance: Appearance::default(),
-            grids: Grids::default(),
-            labels: default_labels(),
-            type_: TypePrefs::default(),
-            import: Import::default(),
-            export: Export::default(),
-            audio: Audio::default(),
-            disk: Disk::default(),
-            memory: Memory::default(),
-            video: Video::default(),
-            three_d: ThreeD::default(),
-            scripting: Scripting::default(),
-            roto: RotoPrefs::default(),
-            face: FacePrefs::default(),
-            recent_projects: vec![],
-            recent_footage: vec![],
-            recent_presets: vec![],
-            recent_fonts: vec![],
-            effects_favorites: vec![],
-            preview: crate::preview::PreviewSettings::default(),
-            custom_rgb: crate::viewer::CustomRgb::default(),
-            comp_presets: vec![],
-            extra: Extra::new(),
-        }
-    }
-}
-
-/// Bring an older settings document up to [`PREFS_VERSION`].
-///
-/// - version 0/1 (early builds) kept a flat object: `undoLevels`, `autoSaveEnabled`,
-///   `autoSaveMinutes`, `autoSaveVersions`, `labelNames` (array) and `theme` at the top level.
-pub fn migrate(mut v: Value) -> Value {
-    let Some(obj) = v.as_object_mut() else { return json!({}) };
-    let version = obj.get("version").and_then(Value::as_u64).unwrap_or(0);
-    if version < 2 {
-        let moved = |from: &str, page: &str, key: &str, obj: &mut Map<String, Value>| {
-            if let Some(x) = obj.remove(from) {
-                let p = obj.entry(page.to_string()).or_insert_with(|| json!({}));
-                if let Some(p) = p.as_object_mut() {
-                    p.entry(key.to_string()).or_insert(x);
-                }
-            }
-        };
-        moved("undoLevels", "general", "undoLevels", obj);
-        moved("autoSaveEnabled", "autoSave", "enabled", obj);
-        moved("autoSaveMinutes", "autoSave", "intervalMinutes", obj);
-        moved("autoSaveVersions", "autoSave", "maxVersions", obj);
-        moved("theme", "appearance", "theme", obj);
-        if let Some(Value::Array(names)) = obj.remove("labelNames") {
-            let mut labels = default_labels();
-            for (l, n) in labels.iter_mut().zip(names) {
-                if let Some(n) = n.as_str() {
-                    l.name = n.to_string();
-                }
-            }
-            obj.insert("labels".into(), serde_json::to_value(labels).unwrap_or_default());
-        }
-    }
-    // Settings saved before appearance modes had one theme: keep showing it, as a fixed Dark or
-    // Light mode, instead of switching established users to Auto.
-    if let Some(a) = obj.get_mut("appearance").and_then(Value::as_object_mut)
-        && !a.contains_key("appearanceMode")
-        && let Some(theme) = a.get("theme").and_then(Value::as_str).map(str::to_string)
-        && let Some((mode, slot)) = theme_family(&theme)
-    {
-        a.insert("appearanceMode".into(), json!(mode));
-        a.insert(slot.into(), json!(theme));
-    }
-    obj.insert("version".into(), json!(PREFS_VERSION));
-    v
-}
-
-/// The appearance mode and the per-mode setting a theme belongs to (`darker` → (`dark`,
-/// `darkTheme`)); `None` for an unknown theme.
-pub fn theme_family(theme: &str) -> Option<(&'static str, &'static str)> {
-    if is_choice(DARK_THEMES, theme) {
-        Some(("dark", "darkTheme"))
-    } else if is_choice(LIGHT_THEMES, theme) {
-        Some(("light", "lightTheme"))
-    } else {
-        None
-    }
-}
-
-impl Appearance {
-    /// Show the legacy single `theme`: fix the mode to its family and remember it as that
-    /// family's theme. An unknown theme changes nothing.
-    pub fn select_theme(&mut self) {
-        match theme_family(&self.theme) {
-            Some((mode, "darkTheme")) => {
-                self.appearance_mode = mode.into();
-                self.dark_theme = self.theme.clone();
-            }
-            Some((mode, _)) => {
-                self.appearance_mode = mode.into();
-                self.light_theme = self.theme.clone();
-            }
-            None => {}
-        }
-    }
-
-    /// The theme to show: the light or dark family's choice by the mode; Auto follows `system_light`
-    /// (`None` = the system said nothing: dark).
-    pub fn resolved_theme(&self, system_light: Option<bool>) -> &str {
-        let light = match self.appearance_mode.as_str() {
-            "light" => true,
-            "auto" => system_light == Some(true),
-            _ => false,
-        };
-        if light { &self.light_theme } else { &self.dark_theme }
-    }
-}
-
-impl Prefs {
-    /// Parse a settings document (migrating older layouts; unknown keys are kept, bad values
-    /// fall back to defaults).
-    pub fn from_json(text: &str) -> Prefs {
-        let v: Value = serde_json::from_str(text).unwrap_or_else(|_| json!({}));
-        let v = migrate(v);
-        let mut p: Prefs = match serde_json::from_value(v.clone()) {
-            Ok(p) => p,
-            // One bad value shouldn't lose everything: take each page that parses.
-            Err(_) => {
-                let mut base = serde_json::to_value(Prefs::default()).unwrap_or_default();
-                if let (Some(b), Some(o)) = (base.as_object_mut(), v.as_object()) {
-                    for (k, x) in o {
-                        let mut trial = b.clone();
-                        trial.insert(k.clone(), x.clone());
-                        if serde_json::from_value::<Prefs>(Value::Object(trial)).is_ok() {
-                            b.insert(k.clone(), x.clone());
-                        }
-                    }
-                }
-                serde_json::from_value(base).unwrap_or_default()
-            }
-        };
-        p.normalize();
-        p
-    }
-
-    pub fn to_json(&self) -> String {
-        serde_json::to_string_pretty(self).unwrap_or_default()
-    }
-
-    /// Clamp values into their valid ranges and fill missing labels.
-    pub fn normalize(&mut self) {
-        self.version = PREFS_VERSION;
-        self.comp_presets.retain(CompPreset::is_valid);
-        let mut seen = std::collections::HashSet::new();
-        self.effects_favorites.retain(|id| !id.is_empty() && seen.insert(id.clone()));
-        self.effects_favorites.truncate(MAX_EFFECTS_FAVORITES);
-        if !is_choice(WINDOW_GRAPHICS, &self.startup.window_graphics) {
-            self.startup.window_graphics = Startup::default().window_graphics;
-        }
-        let g = &mut self.general;
-        if !is_choice(LANGUAGES, &g.language) {
-            g.language = General::default().language;
-        }
-        g.undo_levels = g.undo_levels.clamp(1, 99);
-        g.path_point_size = g.path_point_size.clamp(3, 20);
-        g.recent_items = g.recent_items.clamp(1, 30);
-        let a = &mut self.auto_save;
-        a.interval_minutes = a.interval_minutes.clamp(1, 240);
-        a.max_versions = a.max_versions.clamp(1, 99);
-        let ap = &mut self.appearance;
-        let mut seen = std::collections::BTreeSet::new();
-        ap.favorite_themes.retain(|id| is_choice(THEMES, id) && seen.insert(id.clone()));
-        if !is_choice(APPEARANCE_MODES, &ap.appearance_mode) {
-            ap.appearance_mode = Appearance::default().appearance_mode;
-        }
-        if !is_choice(DARK_THEMES, &ap.dark_theme) {
-            ap.dark_theme = Appearance::default().dark_theme;
-        }
-        if !is_choice(LIGHT_THEMES, &ap.light_theme) {
-            ap.light_theme = Appearance::default().light_theme;
-        }
-        // The legacy single theme mirrors the theme a fixed mode shows (Auto depends on the
-        // system, so it keeps the last one).
-        match ap.appearance_mode.as_str() {
-            "dark" => ap.theme = ap.dark_theme.clone(),
-            "light" => ap.theme = ap.light_theme.clone(),
-            _ if !is_choice(THEMES, &ap.theme) => ap.theme = ap.dark_theme.clone(),
-            _ => {}
-        }
-        self.appearance.brightness = self.appearance.brightness.clamp(-1.0, 1.0);
-        self.appearance.ui_scale = self.appearance.ui_scale.clamp(75, 200);
-        let defaults = default_labels();
-        self.labels.truncate(defaults.len());
-        for d in defaults.iter().skip(self.labels.len()) {
-            self.labels.push(d.clone());
-        }
-        for (l, d) in self.labels.iter_mut().zip(&defaults) {
-            if parse_hex(&l.color).is_none() {
-                l.color = d.color.clone();
-            }
-        }
-        let m = &mut self.memory;
-        m.layer_cache_mb = m.layer_cache_mb.clamp(64, 1 << 20);
-        m.media_cache_mb = m.media_cache_mb.clamp(64, 1 << 20);
-        m.preview_cache_mb = m.preview_cache_mb.clamp(64, 1 << 20);
-        self.grids.grid_spacing = self.grids.grid_spacing.clamp(1.0, 10_000.0);
-        let n = self.general.recent_items as usize;
-        self.recent_projects.truncate(n);
-    }
-
-    /// The value at a dotted key (`general.undoLevels`, `labels.3.color`); `""` = everything.
-    pub fn get(&self, key: &str) -> Option<Value> {
-        let v = serde_json::to_value(self).ok()?;
-        if key.is_empty() {
-            return Some(v);
-        }
-        let ptr = format!("/{}", key.replace('.', "/"));
-        v.pointer(&ptr).cloned()
-    }
-
-    /// Set the value at a dotted key. The key must exist and the value must have its type.
-    pub fn set(&mut self, key: &str, value: Value) -> Result<(), String> {
-        if let Some(c) = choices(key)
-            && !value.as_str().is_some_and(|v| is_choice(c, v))
-        {
-            let all: Vec<&str> = c.iter().map(|(_, v)| *v).collect();
-            return Err(format!("`{key}` expects one of {}", all.join(", ")));
-        }
-        let favorites = if key == "appearance.favoriteThemes" {
-            Some(&value)
-        } else if key == "appearance" {
-            value.get("favoriteThemes")
-        } else {
-            None
-        };
-        if let Some(favorites) = favorites {
-            let values = favorites.as_array().ok_or("favorite themes must be a list")?;
-            let mut seen = std::collections::BTreeSet::new();
-            for value in values {
-                let id = value.as_str().ok_or("favorite theme must be a string")?;
-                if !is_choice(THEMES, id) || !seen.insert(id) {
-                    return Err("unknown or duplicate favorite theme".into());
-                }
-            }
-        }
-        // Older clients set the single theme (by key, or inside the page object): it still picks
-        // a visible theme, fixing the mode to its family.
-        let legacy_theme = key == "appearance.theme" || (key == "appearance" && value.get("theme").is_some() && value.get("appearanceMode").is_none());
-        let mut v = serde_json::to_value(&*self).map_err(|e| e.to_string())?;
-        let ptr = format!("/{}", key.replace('.', "/"));
-        let slot = v.pointer_mut(&ptr).ok_or_else(|| format!("unknown setting `{key}`"))?;
-        let value = coerce(slot, value).ok_or_else(|| format!("`{key}` expects a {}", kind_name(slot)))?;
-        *slot = value;
-        let mut next: Prefs = serde_json::from_value(v).map_err(|e| format!("`{key}`: {e}"))?;
-        let (a, b) = (&self.appearance, &next.appearance);
-        let only_theme_changed = a.theme != b.theme && a.appearance_mode == b.appearance_mode && a.dark_theme == b.dark_theme && a.light_theme == b.light_theme;
-        if legacy_theme || only_theme_changed {
-            next.appearance.select_theme();
-        }
-        next.normalize();
-        *self = next;
-        Ok(())
-    }
-
-    /// Reset one page (`general`, `labels`, `autoSave`…) or everything (`None`). Open Recent and
-    /// the saved composition presets are kept.
-    pub fn reset(&mut self, page: Option<&str>) -> Result<(), String> {
-        let d = Prefs::default();
-        let Some(page) = page else {
-            *self = Prefs {
-                recent_projects: std::mem::take(&mut self.recent_projects),
-                recent_footage: std::mem::take(&mut self.recent_footage),
-                recent_presets: std::mem::take(&mut self.recent_presets),
-                recent_fonts: std::mem::take(&mut self.recent_fonts),
-                effects_favorites: std::mem::take(&mut self.effects_favorites),
-                preview: std::mem::take(&mut self.preview),
-                comp_presets: std::mem::take(&mut self.comp_presets),
-                ..d
-            };
-            return Ok(());
-        };
-        let keys: Vec<&str> = match page {
-            "project" => vec!["project", "autoSave"],
-            p => vec![section_key(p).ok_or_else(|| format!("unknown settings page `{p}`"))?],
-        };
-        let dv = serde_json::to_value(&d).map_err(|e| e.to_string())?;
-        for k in keys {
-            if let Some(x) = dv.get(k) {
-                self.set(k, x.clone())?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Display name of a label (Labels settings).
-    pub fn label_name(&self, l: Label) -> String {
-        match label_index(l) {
-            Some(i) => self.labels.get(i).map(|p| p.name.clone()).unwrap_or_else(|| l.name().to_string()),
-            None => l.name().to_string(),
-        }
-    }
-
-    /// sRGB colour of a label (Labels settings).
-    pub fn label_rgb(&self, l: Label) -> [u8; 3] {
-        label_index(l).and_then(|i| self.labels.get(i)).and_then(|p| parse_hex(&p.color)).unwrap_or(l.rgb())
-    }
-
-    /// A label by its built-in name or its (renamed) display name.
-    pub fn label_from_name(&self, s: &str) -> Option<Label> {
-        Label::from_name(s).or_else(|| Label::ALL.iter().skip(1).copied().find(|l| self.label_name(*l).eq_ignore_ascii_case(s)))
-    }
-
-    /// Remember a project in File ▸ Open Recent.
-    pub fn push_recent(&mut self, path: &str) {
-        self.recent_projects.retain(|p| p != path);
-        self.recent_projects.insert(0, path.to_string());
-        self.recent_projects.truncate(self.general.recent_items as usize);
-    }
-
-    /// Layer / media / preview cache budgets in bytes.
-    pub fn layer_cache_bytes(&self) -> usize {
-        (self.memory.layer_cache_mb as usize) << 20
-    }
-    pub fn media_cache_bytes(&self) -> usize {
-        (self.memory.media_cache_mb as usize) << 20
-    }
-    pub fn preview_cache_bytes(&self) -> usize {
-        (self.memory.preview_cache_mb as usize) << 20
-    }
-
-    /// The adaptive resolution limit as a render-scale floor (1/2 → 0.5).
-    pub fn adaptive_limit(&self) -> f64 {
-        match self.previews.adaptive_resolution_limit.as_str() {
-            "1/2" => 0.5,
-            "1/4" => 0.25,
-            _ => 0.125,
-        }
-    }
-
-    /// The Memory & CPU cache budgets in effect: the configured layer / footage / preview
-    /// budgets, scaled down so together they leave **RAM Reserved for Other Applications** free,
-    /// and halved while the system is low on memory when **Reduce Cache Size When System Is Low
-    /// on Memory** is on. `mem` = the system's memory (`None` = unknown: configured budgets).
-    /// In the browser the layer and footage caches also stay within [`WEB_LAYER_CACHE`] and
-    /// [`WEB_MEDIA_CACHE`].
-    pub fn cache_budgets(&self, mem: Option<crate::sysinfo::SysMemory>) -> CacheBudgets {
-        self.cache_budgets_in(mem, cfg!(target_arch = "wasm32"))
-    }
-
-    /// [`Prefs::cache_budgets`], in the browser's memory (`web`) or not.
-    pub(crate) fn cache_budgets_in(&self, mem: Option<crate::sysinfo::SysMemory>, web: bool) -> CacheBudgets {
-        let (mut l, mut m, mut p) = (self.layer_cache_bytes() as u64, self.media_cache_bytes() as u64, self.preview_cache_bytes() as u64);
-        if web {
-            (l, m) = (l.min(WEB_LAYER_CACHE), m.min(WEB_MEDIA_CACHE));
-        }
-        let floor = 64u64 << 20;
-        let mut capped = false;
-        let mut reduced = false;
-        if let Some(mem) = mem.filter(|m| m.total > 0) {
-            let reserved = (self.memory.ram_reserved_gb as u64) << 30;
-            let cap = mem.total.saturating_sub(reserved).max(3 * floor);
-            let sum = l + m + p;
-            if sum > cap {
-                let k = cap as f64 / sum as f64;
-                (l, m, p) = ((l as f64 * k) as u64, (m as f64 * k) as u64, (p as f64 * k) as u64);
-                capped = true;
-            }
-            if self.memory.reduce_cache_when_low && mem.is_low() {
-                (l, m, p) = (l / 2, m / 2, p / 2);
-                reduced = true;
-            }
-        }
-        CacheBudgets { layer: l.max(floor) as usize, media: m.max(floor) as usize, preview: p.max(floor) as usize, capped, reduced }
-    }
-
-    /// Composition ▸ Motion Path: the layer-time span of a motion path to draw around `now`
-    /// (layer time), for keyframes at `keys` (sorted). `None` = No Motion Path.
-    pub fn motion_path_span(&self, keys: &[Tick], now: Tick) -> Option<(Tick, Tick)> {
-        let (first, last) = (*keys.first()?, *keys.last()?);
-        let c = &self.composition;
-        match c.motion_path.as_str() {
-            "none" => None,
-            "seconds" => {
-                let half = Tick::from_seconds_f64(c.motion_path_seconds.max(0.0) / 2.0);
-                let (a, b) = ((now - half).max(first), (now + half).min(last));
-                (a < b).then_some((a, b))
-            }
-            "keyframes" => {
-                let n = (c.motion_path_keyframes.max(1) as usize).min(keys.len());
-                if n < 2 {
-                    return None;
-                }
-                // The n keyframes centred on the current time.
-                let at = keys.partition_point(|k| *k < now);
-                let start = at.saturating_sub(n / 2).min(keys.len() - n);
-                Some((keys[start], keys[start + n - 1]))
-            }
-            _ => Some((first, last)),
-        }
-    }
-
-    /// Previews ▸ Viewer Zoom Quality: smooth (bilinear) scaling of the viewer image, or nearest
-    /// neighbour ("Faster").
-    pub fn viewer_zoom_smooth(&self) -> bool {
-        self.previews.zoom_quality != "faster"
-    }
-
-    /// Import ▸ Interpret Unlabeled Alpha As, for footage whose file has an alpha channel that
-    /// doesn't state how it is stored. `None` = Ask User (keep straight and open Interpret
-    /// Footage); `guess` takes premultiplied for movies (codecs with alpha are usually written
-    /// premultiplied) and straight for stills.
-    pub fn unlabeled_alpha(&self, movie: bool) -> Option<effectcraft_project::AlphaMode> {
-        use effectcraft_project::AlphaMode::*;
-        Some(match self.import.unlabeled_alpha.as_str() {
-            "ignore" => Ignore,
-            "straight" => Straight,
-            "premultiplied" => Premultiplied,
-            "guess" if movie => Premultiplied,
-            "guess" => Straight,
-            _ => return None,
-        })
-    }
-
-    /// Import ▸ Default Drag Import As, as `file.import`'s `importAs`.
-    pub fn drag_import_as(&self) -> &'static str {
-        match self.import.drag_import_as.as_str() {
-            "comp" => "composition",
-            "compLayerSizes" => "compositionLayerSizes",
-            _ => "footage",
-        }
-    }
-
-    /// Export ▸ Append Bit Depth to File Name: `Comp 1.png` → `Comp 1_16bpc.png` (sequence frame
-    /// runs and folders are kept).
-    pub fn output_name(&self, path: &str, bits: u32) -> String {
-        if !self.export.append_bits_to_name {
-            return path.to_string();
-        }
-        let p = std::path::Path::new(path);
-        let (Some(stem), dir) = (p.file_stem().map(|s| s.to_string_lossy().to_string()), p.parent()) else { return path.to_string() };
-        let tag = format!("_{bits}bpc");
-        if stem.ends_with(&tag) {
-            return path.to_string();
-        }
-        let name = match p.extension() {
-            Some(e) => format!("{stem}{tag}.{}", e.to_string_lossy()),
-            None => format!("{stem}{tag}"),
-        };
-        match dir.filter(|d| !d.as_os_str().is_empty()) {
-            Some(d) => d.join(name).to_string_lossy().to_string(),
-            None => name,
-        }
-    }
-
-    /// Export ▸ Segment Sequences / Segment Movie Files: how many frames go in each segment of an
-    /// output of `frames` frames (`None` = one file / folder). Sequences split every Files per
-    /// Segment frames; movies every Segment Size MB at the output's data rate
-    /// (`bytes_per_frame`, estimated from the format's bitrate).
-    pub fn segment_frames(&self, frames: u64, sequence: bool, bytes_per_frame: f64) -> Option<u64> {
-        let e = &self.export;
-        let per = if sequence {
-            e.segment_sequences.then_some(e.segment_sequence_files.max(1) as u64)?
-        } else {
-            if !e.segment_movies || bytes_per_frame <= 0.0 {
-                return None;
-            }
-            (((e.segment_movie_mb.max(1) as f64) * 1_048_576.0 / bytes_per_frame).floor() as u64).max(1)
-        };
-        (per < frames).then_some(per)
-    }
-
-    /// Remember a font in the Character panel's recent fonts (Type ▸ Number of Recent Fonts).
-    pub fn push_recent_font(&mut self, family: &str) {
-        push_mru(&mut self.recent_fonts, family, 30);
-    }
-
-    /// Is effect `id` starred in Effects & Presets?
-    pub fn is_effect_favorite(&self, id: &str) -> bool {
-        self.effects_favorites.iter().any(|f| f == id)
-    }
-
-    /// Star effect `id` in Effects & Presets, or un-star it; true when it is starred now.
-    pub fn toggle_effect_favorite(&mut self, id: &str) -> bool {
-        if self.is_effect_favorite(id) {
-            self.effects_favorites.retain(|f| f != id);
-            false
-        } else {
-            self.effects_favorites.push(id.to_string());
-            self.effects_favorites.truncate(MAX_EFFECTS_FAVORITES);
-            self.is_effect_favorite(id)
-        }
-    }
-
-    /// The recent fonts the Character panel shows (at most Number of Recent Fonts to Display).
-    pub fn recent_fonts_shown(&self) -> &[String] {
-        let n = (self.type_.recent_fonts as usize).min(self.recent_fonts.len());
-        &self.recent_fonts[..n]
-    }
-
-    /// Remember imported footage for File ▸ Import Recent Footage.
-    pub fn push_recent_footage(&mut self, path: &str) {
-        push_mru(&mut self.recent_footage, path, self.general.recent_items as usize);
-    }
-
-    /// Remember an applied animation preset for Animation ▸ Recent Animation Presets.
-    pub fn push_recent_preset(&mut self, path: &str) {
-        push_mru(&mut self.recent_presets, path, self.general.recent_items as usize);
-    }
-}
-
-/// Most effects Effects & Presets keeps starred (a hand-edited settings file can hold more).
-const MAX_EFFECTS_FAVORITES: usize = 1000;
-
-fn push_mru(list: &mut Vec<String>, v: &str, max: usize) {
-    list.retain(|x| x != v);
-    list.insert(0, v.to_string());
-    list.truncate(max.max(1));
-}
-
-/// The most the layer cache holds in the browser. A wasm32 page addresses at most 4 GiB, which
-/// these caches share with the app and with the decoders' own decoded frames (FilmCraft keeps
-/// up to 384 MB per open movie): with the desktop's 1 GB defaults, eight stacked 1080p clips ran
-/// the page out of memory a few seconds into playback.
-pub const WEB_LAYER_CACHE: u64 = 512 << 20;
-
-/// The most the footage frame cache holds in the browser (see [`WEB_LAYER_CACHE`]).
-pub const WEB_MEDIA_CACHE: u64 = 256 << 20;
-
-/// Effective cache budgets in bytes (see [`Prefs::cache_budgets`]).
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
-pub struct CacheBudgets {
-    pub layer: usize,
-    pub media: usize,
-    pub preview: usize,
-    /// Scaled down to leave the reserved RAM free.
-    pub capped: bool,
-    /// Halved because the system is low on memory.
-    pub reduced: bool,
-}
-
-/// Colour of the `k`-th mask of a layer: Appearance ▸ Cycle Mask Colors cycles through the mask
-/// colours, otherwise every new mask takes the first one.
-pub fn mask_color(cycle: bool, k: usize) -> [u8; 3] {
-    use effectcraft_project::build::MASK_COLORS;
-    if cycle { MASK_COLORS[k % MASK_COLORS.len()] } else { MASK_COLORS[0] }
-}
-
-fn label_index(l: Label) -> Option<usize> {
-    Label::ALL.iter().position(|x| *x == l).and_then(|i| i.checked_sub(1))
-}
-
-/// Settings key of a page id (`3d` → `threeD`).
-pub fn section_key(page: &str) -> Option<&'static str> {
-    Some(match page {
-        "general" => "general",
-        "startup" => "startup",
-        "project" => "project",
-        "autoSave" | "autosave" => "autoSave",
-        "composition" | "display" => "composition",
-        "previews" => "previews",
-        "appearance" => "appearance",
-        "grids" => "grids",
-        "labels" => "labels",
-        "type" => "type",
-        "import" => "import",
-        "export" => "export",
-        "audio" => "audio",
-        "disk" => "disk",
-        "memory" => "memory",
-        "video" => "video",
-        "3d" | "threeD" => "threeD",
-        "scripting" => "scripting",
-        "roto" => "roto",
-        "face" => "face",
-        _ => return None,
-    })
-}
-
-/// Settings page id for a page name, including older After Effects page names
-/// (Auto-Save → Project, Media & Disk Cache → Disk, Memory & Performance → Memory & CPU…).
-pub fn page_id(name: &str) -> Option<&'static str> {
-    let n = name.to_ascii_lowercase().replace([' ', '&', '-', '_'], "");
-    let id = match n.as_str() {
-        "general" => "general",
-        "startup" | "startuprepair" => "startup",
-        "project" | "autosave" | "newproject" => "project",
-        "composition" | "display" => "composition",
-        "previews" | "preview" => "previews",
-        "appearance" => "appearance",
-        "grids" | "gridsguides" => "grids",
-        "labels" => "labels",
-        "type" => "type",
-        "import" => "import",
-        "export" | "output" => "export",
-        "audio" | "audiohardware" | "audiooutputmapping" => "audio",
-        "disk" | "mediadiskcache" | "mediacache" => "disk",
-        "memory" | "memorycpu" | "memoryperformance" => "memory",
-        "video" | "videopreview" => "video",
-        "3d" | "threed" => "3d",
-        "scripting" | "scriptingexpressions" => "scripting",
-        "roto" | "rotobrush" | "models" => "roto",
-        "face" | "facetracking" => "face",
-        _ => return None,
-    };
-    Some(id)
-}
-
-fn kind_name(v: &Value) -> &'static str {
-    match v {
-        Value::Bool(_) => "boolean",
-        Value::Number(_) => "number",
-        Value::String(_) => "string",
-        Value::Array(_) => "list",
-        Value::Object(_) => "object",
-        Value::Null => "value",
-    }
-}
-
-/// `value` converted to the type of `slot` (numbers from strings, booleans from 0/1…).
-fn coerce(slot: &Value, value: Value) -> Option<Value> {
-    Some(match (slot, value) {
-        (Value::Bool(_), Value::Bool(b)) => json!(b),
-        (Value::Bool(_), Value::Number(n)) => json!(n.as_f64()? != 0.0),
-        (Value::Bool(_), Value::String(s)) => json!(matches!(s.as_str(), "true" | "on" | "1" | "yes")),
-        (Value::Number(cur), v) => {
-            let f = match &v {
-                Value::Number(n) => n.as_f64()?,
-                Value::String(s) => s.trim().parse().ok()?,
-                _ => return None,
-            };
-            if cur.is_u64() || cur.is_i64() { json!(f.round().max(0.0) as u64) } else { json!(f) }
-        }
-        (Value::String(_), Value::String(s)) => json!(s),
-        (Value::String(_), Value::Number(n)) => json!(n.to_string()),
-        (Value::Array(_), v @ Value::Array(_)) => v,
-        (Value::Object(_), v @ Value::Object(_)) => v,
-        _ => return None,
-    })
-}
-
-// ---------------------------------------------------------------- schema (Settings dialog)
-
-/// What a setting row edits.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Kind {
-    Bool,
-    /// Integer with range and unit.
-    Int(i64, i64, &'static str),
-    /// Number with range and unit.
-    Float(f64, f64, &'static str),
-    /// One of (label, value).
-    Choice(&'static [(&'static str, &'static str)]),
-    Text,
-    /// A folder or file path (text + Choose…).
-    Path,
-    /// `#rrggbb`.
-    Color,
-    /// UI brightness slider.
-    Slider(f64, f64),
-}
-
-/// One row of a settings page.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Item {
-    Section(&'static str),
-    Setting {
-        key: &'static str,
-        label: &'static str,
-        kind: Kind,
-        /// Changes behaviour today (false = shown for parity, listed in docs/preferences.md).
-        live: bool,
-    },
-    /// A button running a command (`params` is JSON).
-    Button {
-        label: &'static str,
-        command: &'static str,
-        params: &'static str,
-    },
-    /// The 16 label names and colours.
-    Labels,
-    /// Output device picker (device list from the host).
-    AudioDevices {
-        key: &'static str,
-    },
-    /// Read-only information line.
-    Note(&'static str),
-    /// The browser's storage manager (web app only, `storage.*`): usage and quota, persistent
-    /// storage, Clear buttons. Not shown where there is no browser storage.
-    BrowserStorage,
-    /// A task's trained models (`roto.models`, `face.models`): authors, licence, size, install,
-    /// choose.
-    Models(effectcraft_segment::Task),
-}
-
-/// One page of the Settings dialog.
-#[derive(Clone, Debug)]
-pub struct Page {
-    pub id: &'static str,
-    pub title: &'static str,
-    pub items: Vec<Item>,
-}
-
-const fn s(key: &'static str, label: &'static str, kind: Kind, live: bool) -> Item {
-    Item::Setting { key, label, kind, live }
-}
-
-const B: Kind = Kind::Bool;
-const ON_OFF_RES: &[(&str, &str)] = &[("1/2", "1/2"), ("1/4", "1/4"), ("1/8", "1/8")];
-const STYLES: &[(&str, &str)] = &[("Lines", "lines"), ("Dashed Lines", "dashed"), ("Dots", "dots")];
-
-/// The Settings pages in After Effects 2026 order.
-pub fn pages() -> Vec<Page> {
-    use Item::*;
-    vec![
-        Page {
-            id: "general",
-            title: "General",
-            items: vec![
-                s("general.language", "Language", Kind::Choice(LANGUAGES), true),
-                s("general.undoLevels", "Levels of Undo", Kind::Int(1, 99, ""), true),
-                s("general.pathPointSize", "Path Point and Handle Size", Kind::Int(3, 20, "px"), true),
-                s("general.recentItems", "Recent Projects Shown", Kind::Int(1, 30, ""), true),
-                Section("Options"),
-                s("general.showToolTips", "Show Tool Tips", B, true),
-                s("general.createLayersAtCompStart", "Create Layers at Composition Start Time", B, true),
-                s("general.switchesAffectNestedComps", "Switches Affect Nested Comps", B, true),
-                s("general.defaultSpatialLinear", "Default Spatial Interpolation to Linear", B, true),
-                s("general.preserveConstantVertexCount", "Preserve Constant Vertex and Feather Point Count when Editing Masks", B, true),
-                s("general.syncTimeRelatedItems", "Synchronize Time of All Related Items", B, true),
-                s("general.expressionPickWhipCompact", "Expression Pick Whip Writes Compact English", B, true),
-                s("general.createSplitLayersAbove", "Create Split Layers Above Original Layer", B, true),
-                s("general.useSystemColorPicker", "Use System Color Picker", B, false),
-                Note("EffectCraft always uses its own colour picker (the same on every platform and the web)."),
-            ],
-        },
-        Page {
-            id: "startup",
-            title: "Startup & Repair",
-            items: vec![
-                s("startup.showHomeOnLaunch", "Show Home Screen When Launching", B, true),
-                s("startup.showHomeOnOpenProject", "Show Home Screen When Opening a Project", B, true),
-                s("startup.offerCrashRecovery", "Offer to Open the Latest Auto-Save After a Crash", B, true),
-                s("startup.windowGraphics", "Window Graphics", Kind::Choice(WINDOW_GRAPHICS), true),
-                Note(
-                    "Window Graphics applies from the next launch. When the graphics driver stops EffectCraft as its window opens, the next launch switches to OpenGL.",
-                ),
-                Section("Repair"),
-                Button { label: "Reset Settings", command: "prefs.reset", params: "{}" },
-                Button { label: "Reset Keyboard Shortcuts", command: "shortcuts.reset", params: "{}" },
-                Button { label: "Empty Disk Cache", command: "edit.purge", params: r#"{"what":"disk"}"# },
-            ],
-        },
-        Page {
-            id: "project",
-            title: "Project",
-            items: vec![
-                Section("New Project"),
-                s("project.useTemplate", "New Project Loads Template", B, true),
-                s("project.templatePath", "Template Project", Kind::Path, true),
-                Section("Auto-Save"),
-                s("autoSave.enabled", "Automatically Save Projects", B, true),
-                s("autoSave.intervalMinutes", "Save Every", Kind::Int(1, 240, "Minutes"), true),
-                s("autoSave.maxVersions", "Maximum Project Versions", Kind::Int(1, 99, ""), true),
-                s("autoSave.location", "Auto-Save Location", Kind::Choice(&[("Next to Project", "nextToProject"), ("Custom Location", "custom")]), true),
-                s("autoSave.folder", "Custom Location", Kind::Path, true),
-                s("autoSave.saveOnRenderStart", "Save When Starting Render Queue", B, true),
-                Button { label: "Save Now", command: "file.autoSave", params: "{}" },
-            ],
-        },
-        Page {
-            id: "composition",
-            title: "Composition",
-            items: vec![
-                Section("Motion Path"),
-                s(
-                    "composition.motionPath",
-                    "Motion Path",
-                    Kind::Choice(&[
-                        ("All Keyframes", "all"),
-                        ("No Motion Path", "none"),
-                        ("No More Than (Seconds)", "seconds"),
-                        ("No More Than (Keyframes)", "keyframes"),
-                    ]),
-                    true,
-                ),
-                s("composition.motionPathSeconds", "Seconds", Kind::Float(0.0, 3600.0, "s"), true),
-                s("composition.motionPathKeyframes", "Keyframes", Kind::Int(1, 10_000, ""), true),
-                Section("Display"),
-                s("composition.showRenderingProgress", "Show Rendering Progress in Info Panel and Flowchart", B, true),
-                s("composition.hardwareAcceleratePanels", "Hardware Accelerate Composition, Layer and Footage Panels", B, false),
-                Note("Panels are always drawn by the GPU (wgpu)."),
-            ],
-        },
-        Page {
-            id: "previews",
-            title: "Previews",
-            items: vec![
-                s("previews.adaptiveResolutionLimit", "Adaptive Resolution Limit", Kind::Choice(ON_OFF_RES), true),
-                s("previews.showInternalWireframes", "Show Internal Wireframes", B, true),
-                s("previews.cacheFramesWhenIdle", "Cache Frames When Idle", B, true),
-                s("previews.fastPreviews", "Fast Previews (Draft 3D, Faster Effects)", B, true),
-                s("previews.zoomQuality", "Viewer Zoom Quality", Kind::Choice(&[("Faster", "faster"), ("More Accurate", "moreAccurate")]), true),
-                s("previews.displayProfile", "Display Color Space", Kind::Choice(&[("sRGB", "srgb"), ("Display P3", "p3")]), true),
-                Button { label: "GPU Information...", command: "app.gpuInfo", params: "{}" },
-            ],
-        },
-        Page {
-            id: "appearance",
-            title: "Appearance",
-            items: vec![
-                s("appearance.appearanceMode", "Appearance Mode", Kind::Choice(APPEARANCE_MODES), true),
-                s("appearance.lightTheme", "Light Theme", Kind::Choice(LIGHT_THEMES), true),
-                s("appearance.darkTheme", "Dark Theme", Kind::Choice(DARK_THEMES), true),
-                s("appearance.brightness", "Brightness", Kind::Slider(-1.0, 1.0), true),
-                s("appearance.uiScale", "UI Scale", Kind::Int(75, 200, "%"), true),
-                Section("Labels and Colors"),
-                s("appearance.useLabelColorForHandles", "Use Label Color for Layer Handles and Paths", B, true),
-                s("appearance.useLabelColorForTabs", "Use Label Color for Related Tabs", B, true),
-                s("appearance.cycleMaskColors", "Cycle Mask Colors", B, true),
-                s("appearance.useGradients", "Use Gradients", B, true),
-                Section("Menu Bar"),
-                s("appearance.inWindowMenuBarMac", "Use In-Window Menu Bar on macOS", B, true),
-            ],
-        },
-        Page {
-            id: "grids",
-            title: "Grids & Guides",
-            items: vec![
-                Section("Grid"),
-                s("grids.gridColor", "Color", Kind::Color, true),
-                s("grids.gridSpacing", "Gridline Every", Kind::Float(1.0, 10_000.0, "px"), true),
-                s("grids.gridSubdivisions", "Subdivisions", Kind::Int(1, 100, ""), true),
-                s("grids.gridStyle", "Style", Kind::Choice(STYLES), true),
-                Section("Proportional Grid"),
-                s("grids.proportionalHorizontal", "Horizontal", Kind::Int(1, 100, ""), true),
-                s("grids.proportionalVertical", "Vertical", Kind::Int(1, 100, ""), true),
-                Section("Guides"),
-                s("grids.guideColor", "Color", Kind::Color, true),
-                s("grids.guideStyle", "Style", Kind::Choice(STYLES), true),
-                Section("Safe Margins"),
-                s("grids.actionSafe", "Action-safe", Kind::Float(0.0, 50.0, "%"), true),
-                s("grids.titleSafe", "Title-safe", Kind::Float(0.0, 50.0, "%"), true),
-            ],
-        },
-        Page { id: "labels", title: "Labels", items: vec![Labels] },
-        Page {
-            id: "type",
-            title: "Type",
-            items: vec![
-                s("type.textEngine", "Text Engine", Kind::Choice(&[("Latin", "latin"), ("South Asian and Middle Eastern", "southAsian")]), true),
-                s("type.fontPreview", "Show Font Preview", B, true),
-                s("type.recentFonts", "Number of Recent Fonts to Display", Kind::Int(0, 30, ""), true),
-                s("type.fontNamesInEnglish", "Show Font Names in English", B, true),
-            ],
-        },
-        Page {
-            id: "import",
-            title: "Import",
-            items: vec![
-                s("import.stillFootage", "Still Footage", Kind::Choice(&[("Length of Composition", "compLength"), ("Duration (Seconds)", "seconds")]), true),
-                s("import.stillSeconds", "Still Duration", Kind::Float(0.04, 86_400.0, "s"), true),
-                s("import.sequenceFps", "Sequence Footage", Kind::Float(1.0, 999.0, "frames per second"), true),
-                s("import.reportMissingFrames", "Report Missing Frames", B, true),
-                s(
-                    "import.autoReloadFootage",
-                    "Automatically Reload Footage",
-                    Kind::Choice(&[("Off", "off"), ("Non-Sequence Footage", "nonSequence"), ("All Footage", "all")]),
-                    true,
-                ),
-                s(
-                    "import.unlabeledAlpha",
-                    "Interpret Unlabeled Alpha As",
-                    Kind::Choice(&[
-                        ("Ask User", "ask"),
-                        ("Guess", "guess"),
-                        ("Ignore", "ignore"),
-                        ("Straight", "straight"),
-                        ("Premultiplied", "premultiplied"),
-                    ]),
-                    true,
-                ),
-                s(
-                    "import.dragImportAs",
-                    "Default Drag Import As",
-                    Kind::Choice(&[("Footage", "footage"), ("Composition", "comp"), ("Composition - Retain Layer Sizes", "compLayerSizes")]),
-                    true,
-                ),
-            ],
-        },
-        Page {
-            id: "export",
-            title: "Export",
-            items: vec![
-                s("export.defaultOutputFolder", "Default Output Folder", Kind::Path, true),
-                s("export.segmentSequences", "Segment Sequences", B, true),
-                s("export.segmentSequenceFiles", "Files per Segment", Kind::Int(1, 100_000, "files"), true),
-                s("export.segmentMovies", "Segment Movie Files", B, true),
-                s("export.segmentMovieMb", "Segment Size", Kind::Int(1, 1_000_000, "MB"), true),
-                s("export.appendBitsToName", "Append Bit Depth to File Name", B, true),
-            ],
-        },
-        Page {
-            id: "audio",
-            title: "Audio",
-            items: vec![
-                Section("Audio Hardware"),
-                AudioDevices { key: "audio.outputDevice" },
-                s("audio.previewSampleRate", "Preview Sample Rate", Kind::Int(8_000, 192_000, "Hz"), true),
-                Section("Audio Output Mapping"),
-                s("audio.outputLeft", "Left", Kind::Int(1, 64, "channel"), true),
-                s("audio.outputRight", "Right", Kind::Int(1, 64, "channel"), true),
-            ],
-        },
-        Page {
-            id: "disk",
-            title: "Disk",
-            items: vec![
-                Section("Disk Cache"),
-                s("disk.diskCacheEnabled", "Enable Disk Cache", B, true),
-                s("disk.diskCacheMaxGb", "Maximum Disk Cache Size", Kind::Int(1, 100_000, "GB"), true),
-                s("disk.diskCacheFolder", "Disk Cache Folder", Kind::Path, true),
-                Button { label: "Empty Disk Cache", command: "edit.purge", params: r#"{"what":"disk"}"# },
-                BrowserStorage,
-                Section("Media Cache"),
-                s("disk.mediaCacheFolder", "Database and Cache Folder", Kind::Path, true),
-                s("disk.conformedMediaFolder", "Conformed Audio Folder", Kind::Path, true),
-            ],
-        },
-        Page {
-            id: "memory",
-            title: "Memory & CPU",
-            items: vec![
-                s("memory.ramReservedGb", "RAM Reserved for Other Applications", Kind::Int(0, 1024, "GB"), true),
-                Section("Cache Budgets"),
-                s("memory.layerCacheMb", "Layer Cache", Kind::Int(64, 1 << 20, "MB"), true),
-                s("memory.mediaCacheMb", "Footage Frame Cache", Kind::Int(64, 1 << 20, "MB"), true),
-                s("memory.previewCacheMb", "Preview (RAM) Cache", Kind::Int(64, 1 << 20, "MB"), true),
-                s("memory.reduceCacheWhenLow", "Reduce Cache Size When System Is Low on Memory", B, true),
-            ],
-        },
-        Page {
-            id: "video",
-            title: "Video",
-            items: vec![
-                s("video.enableOutput", "Enable Video Preview Output", B, true),
-                s("video.device", "Video Device", Kind::Choice(&[("Floating Window", ""), ("Full Screen", "fullscreen")]), true),
-                s("video.outputDuringPlayback", "Video Output During Playback", B, true),
-                s("video.mirrorOnMonitor", "Mirror on Computer Monitor", B, true),
-                s("video.disableWhenBackground", "Disable Video Output When in Background", B, true),
-            ],
-        },
-        Page {
-            id: "3d",
-            title: "3D",
-            items: vec![
-                s("threeD.defaultRenderer", "Default 3D Renderer", Kind::Choice(&[("Classic 3D", "classic"), ("Advanced 3D", "advanced")]), true),
-                s("threeD.showReferenceAxes", "Show 3D Reference Axes", B, true),
-                s("threeD.extendedViewer", "Extended Viewer", B, true),
-                s("threeD.realtimeShadows", "Realtime Shadows in Draft", B, true),
-            ],
-        },
-        Page {
-            id: "scripting",
-            title: "Scripting & Expressions",
-            items: vec![
-                Section("Application Scripting"),
-                s("scripting.allowScriptsWriteFiles", "Allow Scripts to Write Files and Access Network", B, true),
-                s("scripting.warnExecutingFiles", "Warn User When Executing Files", B, true),
-                s("scripting.enableJsDebugger", "Enable JavaScript Debugger", B, false),
-                Section("Expressions Editor"),
-                s("scripting.editorFontSize", "Font Size", Kind::Int(8, 40, "pt"), true),
-                s("scripting.syntaxHighlighting", "Syntax Highlighting", B, true),
-                s("scripting.lineNumbers", "Line Numbers", B, true),
-                s("scripting.autoComplete", "Auto-complete", B, true),
-                s("scripting.bracketMatching", "Bracket Matching", B, true),
-                s("scripting.wordWrap", "Word Wrap", B, true),
-                s("scripting.errorBanner", "Show Expression Error Banner", B, true),
-                Note("Expressions use the JavaScript engine. Script errors report their file and line in the Script Console; there is no step debugger."),
-            ],
-        },
-        Page {
-            id: "roto",
-            title: "Roto Brush",
-            items: vec![
-                Section("Segmentation Model"),
-                Note(
-                    "Roto Brush 2.0 and 3.0 use the model chosen here (Version 1.0 always uses the classic engine). Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
-                ),
-                Models(effectcraft_segment::Task::Mask),
-            ],
-        },
-        Page {
-            id: "face",
-            title: "Face Tracking",
-            items: vec![
-                Section("Face Model"),
-                Note(
-                    "Face tracking in the Tracker panel (Outline Only and Detailed Features) uses the model chosen here. Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
-                ),
-                Models(effectcraft_segment::Task::Face),
-            ],
-        },
-    ]
-}
-
-/// Keys of every setting that doesn't change behaviour yet (the TODO list in
-/// `docs/preferences.md`).
-pub fn todo_keys() -> Vec<&'static str> {
-    pages()
-        .into_iter()
-        .flat_map(|p| p.items)
-        .filter_map(|i| match i {
-            Item::Setting { key, live: false, .. } => Some(key),
-            _ => None,
-        })
-        .collect()
-}
-
-/// The schema as JSON (for `prefs.pages`).
-pub fn pages_json() -> Value {
-    let kind = |k: &Kind| -> Value {
-        match k {
-            Kind::Bool => json!({"type": "bool"}),
-            Kind::Int(a, b, u) => json!({"type": "int", "min": a, "max": b, "unit": u}),
-            Kind::Float(a, b, u) => json!({"type": "number", "min": a, "max": b, "unit": u}),
-            Kind::Choice(o) => json!({"type": "choice", "options": o.iter().map(|(l, v)| json!({"label": l, "value": v})).collect::<Vec<_>>()}),
-            Kind::Text => json!({"type": "text"}),
-            Kind::Path => json!({"type": "path"}),
-            Kind::Color => json!({"type": "color"}),
-            Kind::Slider(a, b) => json!({"type": "slider", "min": a, "max": b}),
-        }
-    };
-    let pages: Vec<Value> = pages()
-        .iter()
-        .map(|p| {
-            let items: Vec<Value> = p
-                .items
-                .iter()
-                .map(|i| match i {
-                    Item::Section(t) => json!({"section": t}),
-                    Item::Setting { key, label, kind: k, live } => {
-                        let mut o = kind(k);
-                        o["key"] = json!(key);
-                        o["label"] = json!(label);
-                        o["live"] = json!(live);
-                        o
-                    }
-                    Item::Button { label, command, params } => {
-                        json!({"button": label, "command": command, "params": serde_json::from_str::<Value>(params).unwrap_or_default()})
-                    }
-                    Item::Labels => json!({"labels": "labels.N.name / labels.N.color (N = 0..15)"}),
-                    Item::AudioDevices { key } => json!({"type": "device", "key": key, "label": "Default Output"}),
-                    Item::Note(t) => json!({"note": t}),
-                    Item::BrowserStorage => json!({"browserStorage": "storage.info / storage.persist / storage.clear (web app)"}),
-                    Item::Models(task) => {
-                        let p = if *task == effectcraft_segment::Task::Face { "face" } else { "roto" };
-                        json!({"models": format!("{p}.models / {p}.model.select / {p}.model.download / {p}.model.install / {p}.model.remove"), "key": format!("{p}.model")})
-                    }
-                })
-                .collect();
-            json!({"id": p.id, "title": p.title, "items": items})
-        })
-        .collect();
-    json!(pages)
-}
diff --git a/crates/engine/src/render_queue.rs b/crates/engine/src/render_queue.rs
index 27e9a7dce..41474ceef 100644
--- a/crates/engine/src/render_queue.rs
+++ b/crates/engine/src/render_queue.rs
@@ -57,6 +57,12 @@ pub struct ExportResult {
 pub trait Exporter: Send + Sync {
     /// Formats this build can write.
     fn formats(&self) -> Vec<OutputFormat>;
+    /// Whether Skip Existing Files preserves sequence frames written by earlier items. Exporters
+    /// without an existence check (such as memory sinks) must keep the conservative default.
+    /// The check must cover the final destination for these settings, including any overflow.
+    fn supports_skip_existing(&self, _settings: &effectcraft_project::render_queue::RenderSettings) -> bool {
+        false
+    }
     /// Render and write one item (blocking). `progress(done, total)` returns `false` to cancel;
     /// a cancelled export removes the files it opened for that output and returns `Err("cancelled")`.
     /// Completed earlier queue items and unrelated files must be preserved.
@@ -208,6 +214,16 @@ pub fn bytes_per_frame(om: &OutputModule, w: u32, h: u32, fps: f64) -> f64 {
             let bpp = if om.channels == effectcraft_project::render_queue::Channels::Rgba { 4 } else { 3 };
             ((w as u64 * bpp).next_multiple_of(2) * h as u64) as f64
         }
+        // An 18-byte header and 24-bit BGR, 32-bit BGRA or 8-bit grey (Alpha) pixels, uncompressed.
+        OutputFormat::TargaSequence => {
+            use effectcraft_project::render_queue::Channels;
+            let bpp = match om.channels {
+                Channels::Rgb => 3,
+                Channels::Rgba => 4,
+                Channels::Alpha => 1,
+            };
+            (18 + w as u64 * h as u64 * bpp) as f64
+        }
         OutputFormat::WebM => mbps(8.0) * px / fps,
         OutputFormat::Gif => w as f64 * h as f64 * 0.5,
         OutputFormat::Wav | OutputFormat::Aiff => om.audio_sample_rate as f64 * 4.0 / fps,
@@ -432,10 +448,46 @@ impl Session {
         self.render_job.as_ref().map(|j| j.shared.snapshot())
     }
 
-    /// Start rendering every queued item. `wait`: block until done (otherwise a background thread
-    /// renders, or the [`Session::offload`] worker; call [`Session::poll_render`] regularly).
-    /// Returns the ids being rendered. Without threads or an offload (wasm32) the render always
-    /// runs to completion before this returns.
+    /// The (item, resolved output path) of each output of `it`: one per output module and, with
+    /// Segment Sequences / Segment Movie Files, per segment. `formats`: the ones that can be
+    /// written (`None`: all). Fails with the status the item gets instead.
+    pub(crate) fn outputs_of(&self, it: &RenderQueueItem, formats: Option<&[OutputFormat]>) -> Result<Vec<(RenderQueueItem, String)>, RenderStatus> {
+        let mut modules = vec![];
+        for om in it.output_modules() {
+            let mut m = it.clone();
+            m.output = om.clone();
+            match self.resolve_output(&m) {
+                Some(p) if formats.is_none_or(|f| f.contains(&om.format)) => {
+                    // Settings ▸ Export: Append Bit Depth to File Name, Segment Sequences /
+                    // Movie Files.
+                    let bits = output_bits(om.format, self.project.settings.bit_depth);
+                    let p = self.prefs.output_name(&p, bits);
+                    modules.extend(self.segments(&m, &p));
+                }
+                Some(_) => return Err(RenderStatus::Failed(format!("{} export is not available", om.format.label()))),
+                None if self.project.comp(it.comp).is_none() => return Err(RenderStatus::Failed("composition missing".into())),
+                None => return Err(RenderStatus::NeedsOutput),
+            }
+        }
+        Ok(modules)
+    }
+
+    /// What the next Render would write: for each queued item its [`Session::outputs_of`], and
+    /// the status of each queued item that has none.
+    pub(crate) fn queued_outputs(&self, formats: &[OutputFormat]) -> (Vec<Vec<(RenderQueueItem, String)>>, Vec<(u64, RenderStatus)>) {
+        let (mut items, mut problems) = (Vec::new(), Vec::new());
+        for it in self.project.render_queue.iter().filter(|i| i.is_queued()) {
+            match self.outputs_of(it, Some(formats)) {
+                Ok(modules) => items.push(modules),
+                Err(status) => problems.push((it.id, status)),
+            }
+        }
+        (items, problems)
+    }
+
+    /// Start rendering every queued item, refusing outputs that replace footage, proxies or
+    /// the project file. Other existing outputs keep the exporter's usual replacement policy.
+    /// `wait`: block until done, otherwise render in the background and poll regularly.
     pub fn start_render(&mut self, wait: bool) -> Result<Vec<u64>, String> {
         let offload = self.offload.clone().filter(|_| !wait);
         let wait = wait || (cfg!(target_arch = "wasm32") && offload.is_none());
@@ -445,46 +497,38 @@ impl Session {
         self.poll_render();
         let exporter = self.exporter.clone().ok_or("export is not available in this build")?;
         let formats = exporter.formats();
-        let mut items = Vec::new();
-        let mut needs_output = Vec::new();
-        for it in self.project.render_queue.iter().filter(|i| i.is_queued()) {
-            let mut modules = vec![];
-            let mut problem = None;
-            for om in it.output_modules() {
-                let mut m = it.clone();
-                m.output = om.clone();
-                match self.resolve_output(&m) {
-                    Some(p) if formats.contains(&om.format) => {
-                        // Settings ▸ Export: Append Bit Depth to File Name, Segment Sequences /
-                        // Movie Files.
-                        let bits = output_bits(om.format, self.project.settings.bit_depth);
-                        let p = self.prefs.output_name(&p, bits);
-                        modules.extend(self.segments(&m, &p));
-                    }
-                    Some(_) => problem = Some(RenderStatus::Failed(format!("{} export is not available", om.format.label()))),
-                    None if self.project.comp(it.comp).is_none() => problem = Some(RenderStatus::Failed("composition missing".into())),
-                    None => problem = Some(RenderStatus::NeedsOutput),
-                }
-                if problem.is_some() {
-                    break;
-                }
-            }
-            match problem {
-                Some(st) => needs_output.push((it.id, st)),
-                None => items.push(modules),
-            }
+        let (mut items, mut problems) = self.queued_outputs(&formats);
+        let refused = self.check_outputs(&items);
+        // Two outputs of this job on one file: the render would replace its own output, so it is
+        // refused before anything is written (the items refused above take no part).
+        if let Some(refusal) = crate::output_guard::duplicate_refusal(&self.duplicate_outputs(&items, &refused)?) {
+            return Err(refusal);
         }
-        if !needs_output.is_empty() {
+        items.retain(|modules| modules.first().is_none_or(|(it, _)| !refused.iter().any(|r| r.item == it.id)));
+        problems.extend(refused.iter().map(|r| (r.item, RenderStatus::Failed(r.reason.clone()))));
+        if !problems.is_empty() {
             let p = Arc::make_mut(&mut self.project);
-            for (id, st) in needs_output {
+            for (id, st) in problems {
                 if let Some(i) = p.render_queue.iter_mut().find(|i| i.id == id) {
                     i.status = st;
                 }
             }
             self.bump();
         }
+        if let Some(first) = refused.first() {
+            let message = if refused.len() == 1 {
+                format!("Not rendered: {}", first.reason)
+            } else {
+                format!("{} items were not rendered; first: {}", refused.len(), first.reason)
+            };
+            self.events.push(Event::Toast { message, error: true });
+        }
         if items.is_empty() {
-            return Err("nothing is queued: add a composition (Composition ▸ Add to Render Queue) and tick Render".into());
+            return Err(match refused.as_slice() {
+                [] => "nothing is queued: add a composition (Composition ▸ Add to Render Queue) and tick Render".into(),
+                [only] => only.reason.clone(),
+                [first, ..] => format!("{} items would replace files the project reads; first: {}", refused.len(), first.reason),
+            });
         }
         let ids: Vec<u64> = items.iter().filter_map(|m| m.first().map(|(i, _)| i.id)).collect();
         if let Some(off) = offload {
@@ -676,7 +720,7 @@ impl Session {
                         continue;
                     }
                     if let Some(c) = proj.comp_mut(cid) {
-                        for l in c.layers.iter_mut().filter(|l| matches!(l.source, LayerSource::Comp { item } if item == comp)) {
+                        for l in c.layers.iter_mut_where(|l| matches!(l.source, LayerSource::Comp { item } if item == comp)) {
                             l.source = LayerSource::Footage { item: fid };
                         }
                     }
diff --git a/crates/engine/src/rq_tests.rs b/crates/engine/src/rq_tests.rs
index 81a187226..d6bb96831 100644
--- a/crates/engine/src/rq_tests.rs
+++ b/crates/engine/src/rq_tests.rs
@@ -67,11 +67,11 @@ fn add_configure_render() {
     let r = s.execute("renderQueue.setOutputModule", json!({"item": id, "format": "png", "channels": "rgba"})).unwrap();
     assert!(r["outputPath"].as_str().unwrap().ends_with("_[#####].png"), "{r}");
     assert!(s.execute("renderQueue.setOutputModule", json!({"item": id, "format": "jpeg", "channels": "rgba"})).is_err());
-    let r = s.execute("renderQueue.setOutput", json!({"item": id, "path": crate::tests_stubs::tmp_out("rq/out.mov")})).unwrap();
+    let r = s.execute("renderQueue.setOutput", json!({"item": id, "path": crate::tests::stubs::tmp_out("rq/out.mov")})).unwrap();
     assert_eq!(r["output"]["format"], "ProRes", "Output To with .mov switches to ProRes");
-    assert_eq!(std::path::Path::new(r["outputPath"].as_str().unwrap()), std::path::PathBuf::from(crate::tests_stubs::tmp_out("rq/out.mov")));
+    assert_eq!(std::path::Path::new(r["outputPath"].as_str().unwrap()), std::path::PathBuf::from(crate::tests::stubs::tmp_out("rq/out.mov")));
     // A second item that fails, a third that is unqueued.
-    let b = s.execute("renderQueue.add", json!({"format": "gif", "output": crate::tests_stubs::tmp_out("rq/fail.gif")})).unwrap();
+    let b = s.execute("renderQueue.add", json!({"format": "gif", "output": crate::tests::stubs::tmp_out("rq/fail.gif")})).unwrap();
     let c = s.execute("renderQueue.add", json!({"output": "/tmp/rq/skip.mp4"})).unwrap();
     s.execute("renderQueue.setRender", json!({"item": c["item"], "render": false})).unwrap();
     assert_eq!(s.project.render_queue[2].status.label(), "Unqueued");
@@ -79,12 +79,12 @@ fn add_configure_render() {
     assert_eq!(r["items"].as_array().unwrap().len(), 2);
     assert_eq!(
         ex.log.lock().unwrap().iter().map(std::path::PathBuf::from).collect::<Vec<_>>(),
-        [std::path::PathBuf::from(crate::tests_stubs::tmp_out("rq/out.mov")), std::path::PathBuf::from(crate::tests_stubs::tmp_out("rq/fail.gif"))]
+        [std::path::PathBuf::from(crate::tests::stubs::tmp_out("rq/out.mov")), std::path::PathBuf::from(crate::tests::stubs::tmp_out("rq/fail.gif"))]
     );
     let q = &s.project.render_queue;
     assert_eq!(q[0].status.label(), "Done");
     assert!(q[0].started.is_some() && q[0].render_time.is_some());
-    assert_eq!(std::path::Path::new(q[0].last_output.as_deref().unwrap()), std::path::PathBuf::from(crate::tests_stubs::tmp_out("rq/out.mov")));
+    assert_eq!(std::path::Path::new(q[0].last_output.as_deref().unwrap()), std::path::PathBuf::from(crate::tests::stubs::tmp_out("rq/out.mov")));
     assert_eq!(q[1].status, RenderStatus::Failed("boom".into()));
     assert_eq!(q[2].status.label(), "Unqueued");
     let events = s.drain_events();
@@ -116,6 +116,25 @@ fn persists_in_project_file() {
     assert!(effectcraft_project::Project::from_json(&old).unwrap().render_queue.is_empty());
 }
 
+#[test]
+fn targa_sequence_output_module() {
+    let (mut s, _) = rq_session();
+    let a = s.execute("renderQueue.add", json!({"format": "tga", "output": "/out/[compName]_[#####].tga", "channels": "rgba"})).unwrap();
+    let om = &s.project.render_queue[0].output;
+    assert_eq!((format!("{:?}", om.format), om.channels.label()), ("TargaSequence".to_string(), "RGB + Alpha"));
+    assert!(a["outputPath"].as_str().unwrap().ends_with("_[#####].tga"), "{a}");
+    // Uncompressed: an 18-byte header and 4 bytes a pixel with alpha, 3 without.
+    assert_eq!(crate::render_queue::bytes_per_frame(om, 7, 4, 10.0), 18.0 + 7.0 * 4.0 * 4.0);
+    s.execute("renderQueue.setOutputModule", json!({"index": 1, "channels": "rgb"})).unwrap();
+    assert_eq!(crate::render_queue::bytes_per_frame(&s.project.render_queue[0].output, 7, 4, 10.0), 18.0 + 7.0 * 4.0 * 3.0);
+    let f = s.execute("renderQueue.formats", json!({})).unwrap();
+    let tga = f["formats"].as_array().unwrap().iter().find(|f| f["id"] == "TargaSequence").cloned();
+    assert_eq!(
+        tga,
+        Some(json!({"id": "TargaSequence", "label": "Targa Sequence", "extension": "tga", "sequence": true, "alpha": true, "audio": false, "available": true}))
+    );
+}
+
 #[test]
 fn failure_toast_names_the_first_reason() {
     struct Failing;
@@ -130,8 +149,8 @@ fn failure_toast_names_the_first_reason() {
     }
     let mut s = demo();
     s.exporter = Some(Arc::new(Failing));
-    s.execute("renderQueue.add", json!({"format": "gif", "output": crate::tests_stubs::tmp_out("rq/first.gif")})).unwrap();
-    s.execute("renderQueue.add", json!({"format": "gif", "output": crate::tests_stubs::tmp_out("rq/second.gif")})).unwrap();
+    s.execute("renderQueue.add", json!({"format": "gif", "output": crate::tests::stubs::tmp_out("rq/first.gif")})).unwrap();
+    s.execute("renderQueue.add", json!({"format": "gif", "output": crate::tests::stubs::tmp_out("rq/second.gif")})).unwrap();
     s.execute("renderQueue.render", json!({})).unwrap();
     let events = s.drain_events();
     let toast = events.iter().find_map(|e| if let Event::Toast { message, error: true } = e { Some(message.as_str()) } else { None });
@@ -186,7 +205,7 @@ fn without_exporter() {
     s.execute("renderQueue.add", json!({})).unwrap();
     assert!(!s.is_enabled("renderQueue.render"));
     let f = s.execute("renderQueue.formats", json!({})).unwrap();
-    assert_eq!(f["formats"].as_array().unwrap().len(), 13);
+    assert_eq!(f["formats"].as_array().unwrap().len(), 14);
     assert_eq!(f["formats"][0]["available"], false);
 }
 
diff --git a/crates/engine/src/scriptui.rs b/crates/engine/src/scriptui.rs
index 6d218a7bb..2c211e77a 100644
--- a/crates/engine/src/scriptui.rs
+++ b/crates/engine/src/scriptui.rs
@@ -402,12 +402,16 @@ pub struct ScriptUi {
     #[serde(skip)]
     pub tasks: Option<ScriptTaskRunner>,
     /// Bumped whenever the project is closed or replaced (New / Open / Close Project): repeating
-    /// tasks of scripts without an open window stop then.
+    /// tasks of scripts without an open window stop then, except those of Startup scripts.
     #[serde(skip)]
     pub project_epoch: u64,
     /// The script contexts of this session with scheduled tasks (kept by the scripting engine).
     #[serde(skip)]
     pub task_hosts: Vec<u32>,
+    /// The script contexts of Startup scripts: their tasks go on when the project is closed or
+    /// replaced, until EffectCraft quits.
+    #[serde(skip)]
+    pub startup_hosts: Vec<u32>,
 }
 
 impl ScriptUi {
@@ -755,6 +759,7 @@ pub(crate) fn mouse(s: &mut Session, p: &Value) -> Result<Value> {
         "screenX": num("screenX", -FAR, FAR, 0.0),
         "screenY": num("screenY", -FAR, FAR, 0.0),
         "button": num("button", 0.0, 2.0, 0.0).round(),
+        "buttons": num("buttons", 0.0, 7.0, 0.0).round(),
         "detail": num("detail", 0.0, 1000.0, clicks).round(),
         "altKey": flag("altKey"),
         "ctrlKey": flag("ctrlKey"),
@@ -764,6 +769,17 @@ pub(crate) fn mouse(s: &mut Session, p: &Value) -> Result<Value> {
     dispatch(s, ScriptUiEvent { window, widget, kind: (*ty).to_string(), value })
 }
 
+/// `scriptui.resize`: the host gave the window a new size (a docked panel's dock, #2585): the
+/// script's window takes it, lays itself out again and gets `onResizing` / `onResize`.
+pub(crate) fn resize(s: &mut Session, p: &Value) -> Result<Value> {
+    let c = "scriptui.resize";
+    let window = window_p(s, p, c)?;
+    let size = p.get("size").and_then(Value::as_array).ok_or_else(|| crate::commands::bad(c, "missing `size` [width, height]"))?;
+    let side = |i: usize| size.get(i).and_then(Value::as_f64).filter(|v| v.is_finite()).map(|v| v.round().clamp(1.0, 16384.0));
+    let (Some(w), Some(h)) = (side(0), side(1)) else { return Err(crate::commands::bad(c, "`size` must be [width, height] in pixels")) };
+    dispatch(s, ScriptUiEvent { window, widget: 0, kind: "resize".into(), value: json!([w, h]) })
+}
+
 /// `scriptui.close`: close a window (a dialog's `show()` returns `result`, default 2 = Cancel).
 pub(crate) fn close(s: &mut Session, p: &Value) -> Result<Value> {
     let window = window_p(s, p, "scriptui.close")?;
diff --git a/crates/engine/src/services.rs b/crates/engine/src/services.rs
new file mode 100644
index 000000000..2d425a4e6
--- /dev/null
+++ b/crates/engine/src/services.rs
@@ -0,0 +1,102 @@
+use super::config;
+
+/// Host services (file access) injected by the frontend.
+pub trait Services: Send + Sync {
+    fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>>;
+    fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()>;
+    /// Whether a file exists (the background footage check after open).
+    fn exists(&self, path: &str) -> bool {
+        std::path::Path::new(path).exists()
+    }
+    /// A file's size and modification time (nanoseconds since 1970), to notice that it changed
+    /// on disk (Settings ▸ Import ▸ Reload Footage Changed on Disk); `None` when it can't be read.
+    fn stamp(&self, path: &str) -> Option<(u64, u128)> {
+        let meta = std::fs::metadata(path).ok()?;
+        let modified = meta.modified().ok()?.duration_since(std::time::UNIX_EPOCH).ok()?;
+        Some((meta.len(), modified.as_nanos()))
+    }
+    /// Keep a file the app made for itself (footage extracted from a template): like
+    /// [`Services::write_file`], creating its folder, but never offered as a download (web: it
+    /// goes to browser storage only).
+    fn store_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
+        if let Some(d) = std::path::Path::new(path).parent().filter(|d| !d.as_os_str().is_empty()) {
+            let _ = std::fs::create_dir_all(d);
+        }
+        self.write_file(path, data)
+    }
+    /// The files in folder `dir` (full paths; no folders, no hidden files), for image-sequence
+    /// detection on import. Empty when it can't be read.
+    fn list_dir(&self, dir: &str) -> Vec<String> {
+        let Ok(rd) = std::fs::read_dir(if dir.is_empty() { "." } else { dir }) else { return vec![] };
+        rd.filter_map(|e| e.ok())
+            .filter(|e| e.file_type().is_ok_and(|t| t.is_file()) && !e.file_name().to_string_lossy().starts_with('.'))
+            .map(|e| e.path().to_string_lossy().to_string())
+            .collect()
+    }
+    /// Whether `path` is a folder (dropped or picked folders import their files).
+    fn is_dir(&self, path: &str) -> bool {
+        std::path::Path::new(path).is_dir()
+    }
+    /// `path` as a list of recent files keeps it (File ▸ Scripts ▸ Recent Script Files): a
+    /// relative path is made absolute against the working directory, so it opens the same file
+    /// after the working directory changes. `None` when the path can't be made absolute (the
+    /// working directory can't be read); the script is then not added to the list.
+    fn full_path(&self, path: &str) -> Option<String> {
+        std::path::absolute(path).ok().map(|p| p.to_string_lossy().into_owned())
+    }
+}
+
+/// Native filesystem.
+pub struct FsServices;
+
+impl Services for FsServices {
+    /// Refuses what isn't a regular file: a project can name `/dev/zero` or a FIFO, and reading
+    /// those never ends (#2134).
+    fn read_file(&self, path: &str) -> std::io::Result<Vec<u8>> {
+        use std::io::Read;
+        let mut file = std::fs::File::open(path)?;
+        let meta = file.metadata()?;
+        if !meta.is_file() {
+            return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, format!("{path} is not a file")));
+        }
+        let mut bytes = Vec::new();
+        // A sparse file can claim far more than memory: an error, not an abort.
+        bytes.try_reserve_exact(usize::try_from(meta.len()).unwrap_or(usize::MAX)).map_err(|e| std::io::Error::new(std::io::ErrorKind::OutOfMemory, e))?;
+        file.read_to_end(&mut bytes)?;
+        Ok(bytes)
+    }
+    fn write_file(&self, path: &str, data: &[u8]) -> std::io::Result<()> {
+        config::atomic_write(std::path::Path::new(path), data)
+    }
+}
+
+/// Imports media files into the project (implemented by the media layer).
+pub trait Importer: Send + Sync {
+    /// Probe one file and return footage metadata. Image sequences are the engine's
+    /// ([`sequence`]): it groups numbered stills and probes their first file here.
+    fn probe(&self, path: &str) -> std::result::Result<effectcraft_project::Footage, String>;
+    /// A footage file's bytes are now at `path` (extracted from a template): hosts whose media
+    /// layer reads from memory (the browser) register them; file-based ones need nothing.
+    fn register(&self, _path: &str, _data: &[u8]) {}
+    /// An image sequence's other frames (its first was probed) are footage now: hosts whose
+    /// media layer reads from memory (the browser) register them; file-based ones need nothing.
+    fn add_frames(&self, _paths: &[String]) {}
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{FsServices, Services};
+
+    /// #2134: a project can name a folder, `/dev/zero` or a FIFO; reading those is an error.
+    #[test]
+    fn fs_services_read_only_regular_files() {
+        let dir = std::env::temp_dir();
+        assert!(FsServices.read_file(&dir.to_string_lossy()).is_err());
+        #[cfg(unix)]
+        assert!(FsServices.read_file("/dev/zero").is_err());
+        let f = dir.join(format!("ec-services-read-{}.txt", std::process::id()));
+        std::fs::write(&f, b"data").unwrap();
+        assert_eq!(FsServices.read_file(&f.to_string_lossy()).unwrap(), b"data");
+        let _ = std::fs::remove_file(f);
+    }
+}
diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs
new file mode 100644
index 000000000..18b0ff4cf
--- /dev/null
+++ b/crates/engine/src/session.rs
@@ -0,0 +1,13 @@
+use super::doc_state::{CompSelection, EditorState};
+use super::error::{EngineError, Result};
+use super::event::Event;
+use super::{
+    Arc, Comp, History, Image, ItemId, LayerId, Project, RenderOpts, Renderer, Session, ThumbnailJob, Tick, Value, camera_track, commands, guard, roto, warp,
+};
+
+mod comps;
+mod dispatch;
+mod edit;
+mod render;
+
+pub use edit::upgrade_effects;
diff --git a/crates/engine/src/session/comps.rs b/crates/engine/src/session/comps.rs
new file mode 100644
index 000000000..4fda6628c
--- /dev/null
+++ b/crates/engine/src/session/comps.rs
@@ -0,0 +1,286 @@
+use super::{Comp, CompSelection, Event, ItemId, LayerId, Result, Session, Tick, Value, commands};
+
+/// `t` as a current time of `comp`: a frame within its duration.
+fn comp_frame_at(comp: &Comp, t: Tick) -> Tick {
+    comp.frame_rate.snap_nearest(t.min(comp.duration - comp.frame_duration()).max(Tick::ZERO))
+}
+
+impl Session {
+    /// Keep selections valid after the project was replaced by another state (undo, redo, a
+    /// history jump, a rollback): the same layer id can name a different document, so the
+    /// on-canvas editor gets a fresh IME epoch only when its own document changed.
+    ///
+    /// Normally `before` is [`commands::text_edit::active_editor_snapshot`] taken from the
+    /// state this call is about to replace. Atomic batch rollback is the exception: it has
+    /// already restored the pre-batch state and passes the snapshot of the failing intermediate
+    /// state, so a transient restart or component switch inside the batch still rejects reviving
+    /// the old composition. A restored state that still has the same composition, layer and
+    /// editor session and shows byte/style-equivalent text (an opacity or other property undo)
+    /// keeps the editor's owner and selection; a different document, comp, layer or session clamps the
+    /// selection and starts a new epoch. A closed editor stays closed, and a fallback comp's
+    /// matching layer id never inherits the old comp's session. `None` means no editor was open
+    /// when the snapshot was taken; if one is open after the replacement it is treated as an
+    /// unverified document replacement, so it never inherits an old composition.
+    pub fn sanitize_after_replacement(&mut self, before: Option<&commands::text_edit::EditorSnapshot>) {
+        self.sanitize_state();
+        commands::text_edit::after_replacement(self, before);
+    }
+
+    /// Drop selections that no longer exist. Each comp keeps its own selection (#1001); a layer id
+    /// counts only inside the comp that owns it, so the active comp never sees another comp's layers.
+    /// Validate property UIDs too: undo can remove a control and rewind the allocator, so keeping
+    /// its selection could silently select a different property when the UID is reused. Group
+    /// selections remain valid even though groups are not leaf properties.
+    pub fn sanitize_state(&mut self) {
+        let p = self.project.clone();
+        self.state.open_comps.retain(|c| p.comp(*c).is_some());
+        self.state.comp_selections.retain(|cid, sel| {
+            let Some(c) = p.comp(*cid) else { return false };
+            let ids: Vec<LayerId> = c.layers.iter().map(|l| l.id).collect();
+            sel.layers.retain(|l| ids.contains(l));
+            sel.props.retain(|(lid, uid)| c.layer(*lid).is_some_and(|l| l.props.find(*uid).is_some() || l.props.find_group(*uid).is_some()));
+            sel.keys.retain(|k| c.layer(k.layer).is_some_and(|l| l.props.find(k.prop).is_some()));
+            sel.vertices.retain(|v| ids.contains(&v.layer));
+            !sel.is_empty()
+        });
+        if self.state.active_comp.is_some_and(|c| p.comp(c).is_none()) {
+            self.clear_live_selection();
+            // A matching layer id in the fallback comp is not the document being edited.
+            self.state.text_edit = None;
+            self.state.active_comp = self.state.open_comps.first().copied();
+            if let Some(id) = self.state.active_comp {
+                self.recall_selection(id);
+            }
+        }
+        if let Some(c) = self.state.active_comp.and_then(|cid| p.comp(cid)) {
+            let ids: Vec<LayerId> = c.layers.iter().map(|l| l.id).collect();
+            self.state.selected_layers.retain(|l| ids.contains(l));
+            self.state.selected_props.retain(|(lid, uid)| c.layer(*lid).is_some_and(|l| l.props.find(*uid).is_some() || l.props.find_group(*uid).is_some()));
+            self.state.selected_keys.retain(|k| c.layer(k.layer).is_some_and(|l| l.props.find(k.prop).is_some()));
+            self.state.selected_vertices.retain(|v| ids.contains(&v.layer));
+        }
+        if let Some((l, t)) = self.state.current_track
+            && self.active_comp().and_then(|c| c.layer(l)).and_then(|l| l.tracker(t)).is_none()
+        {
+            self.state.current_track = None;
+        }
+        self.state.project_selection.retain(|i| p.item(*i).is_some());
+        commands::text_edit::sanitize(self);
+    }
+
+    pub fn active_comp(&self) -> Option<&Comp> {
+        self.project.comp(self.state.active_comp?)
+    }
+
+    /// [`Session::active_comp`] as a shared snapshot (an `Arc` clone, not a deep copy).
+    pub fn active_comp_arc(&self) -> Option<std::sync::Arc<Comp>> {
+        self.project.comp_arc(self.state.active_comp?)
+    }
+
+    pub fn active_comp_id(&self) -> Option<ItemId> {
+        self.state.active_comp.filter(|c| self.project.comp(*c).is_some())
+    }
+
+    /// Current time of a comp.
+    pub fn time_of(&self, comp: ItemId) -> Tick {
+        self.state.times.get(&comp).copied().unwrap_or(Tick::ZERO)
+    }
+
+    /// Current time of the active comp.
+    pub fn time(&self) -> Tick {
+        self.state.active_comp.and_then(|c| self.state.times.get(&c).copied()).unwrap_or(Tick::ZERO)
+    }
+
+    /// Move the active comp's current time.
+    ///
+    /// Time is an external boundary for the on-canvas text editor too: an animated Source Text
+    /// can show a different document at another time. The document is snapshotted only while an
+    /// editor is open, so playback with no text editor does no text copying.
+    pub fn set_time(&mut self, t: Tick) {
+        if let Some(c) = self.state.active_comp {
+            let t = self.project.comp(c).map_or(t, |comp| comp_frame_at(comp, t));
+            let edited = commands::text_edit::active_editor_snapshot(self);
+            self.state.times.insert(c, t);
+            if self.prefs.general.sync_time_related_items {
+                // Direct call: this `set_time` owns the editor snapshot for both time changes,
+                // so a synced move does not take a second snapshot or start a second epoch.
+                self.sync_related_times_inner(c, t);
+            }
+            commands::text_edit::after_external_change(self, edited.as_ref());
+        }
+    }
+
+    /// Settings ▸ General ▸ Synchronize Time of All Related Items: moving the current time of
+    /// `comp` moves the current time of the comps nested in it (through their precomp layers'
+    /// timing) and of the comps it is nested in, so every related viewer shows the same moment.
+    pub fn sync_related_times(&mut self, comp: ItemId, t: Tick) {
+        // Moving a related comp can move the active one, so the editor's document is checked
+        // here too; the snapshot is skipped entirely when no text editor is open.
+        let edited = commands::text_edit::active_editor_snapshot(self);
+        self.sync_related_times_inner(comp, t);
+        commands::text_edit::after_external_change(self, edited.as_ref());
+    }
+
+    /// Sets the time of every comp related to `comp` through precomp layers: down into the comps
+    /// it nests (through each layer's timing) and up into the comps nesting it. A seen-set keeps
+    /// cycles and diamonds finite; each found time is clamped to its comp's last frame, snapped to
+    /// the nearest frame and stored in `state.times`. The caller owns the text-editor boundary.
+    fn sync_related_times_inner(&mut self, comp: ItemId, t: Tick) {
+        let mut seen = std::collections::BTreeSet::from([comp]);
+        let mut todo = vec![(comp, t)];
+        let mut found = vec![];
+        while let Some((cid, ct)) = todo.pop() {
+            if cid != comp {
+                found.push((cid, ct));
+            }
+            let Some(c) = self.project.comp(cid) else { continue };
+            // Down: the comps this one nests.
+            for l in &c.layers {
+                if let effectcraft_project::LayerSource::Comp { item } = &l.source
+                    && seen.insert(*item)
+                {
+                    todo.push((*item, l.layer_time(ct)));
+                }
+            }
+            // Up: the comps nesting this one.
+            for iid in self.project.items.keys() {
+                if let Some(pc) = self.project.comp(*iid)
+                    && let Some(l) = pc.layers.iter().find(|l| matches!(&l.source, effectcraft_project::LayerSource::Comp { item } if *item == cid))
+                    && seen.insert(*iid)
+                {
+                    todo.push((*iid, l.comp_time(ct)));
+                }
+            }
+        }
+        for (cid, ct) in found {
+            if let Some(c) = self.project.comp(cid) {
+                let ct = c.frame_rate.snap_nearest(ct.clamp(Tick::ZERO, (c.duration - c.frame_duration()).max(Tick::ZERO)));
+                self.state.times.insert(cid, ct);
+            }
+        }
+    }
+
+    /// Make `id` the active comp, parking the previous comp's selection and restoring this one's.
+    pub fn activate_comp(&mut self, id: ItemId) {
+        if self.project.comp(id).is_none() || self.state.active_comp == Some(id) {
+            return;
+        }
+        self.remember_selection();
+        self.state.active_comp = Some(id);
+        self.recall_selection(id);
+        self.state.current_track = None;
+        // A text-edit session belongs to the comp that owned it. Switching comps ends it; even
+        // a same-numbered layer in the new comp must not inherit the old IME composition.
+        self.state.text_edit = None;
+    }
+
+    /// Leave no comp active, keeping the one that was active in [`EditorState::comp_selections`].
+    pub fn activate_comp_none(&mut self) {
+        self.remember_selection();
+        self.state.active_comp = None;
+        self.clear_live_selection();
+        self.state.current_track = None;
+        self.state.text_edit = None;
+    }
+
+    fn remember_selection(&mut self) {
+        let Some(id) = self.state.active_comp else { return };
+        let sel = CompSelection {
+            layers: self.state.selected_layers.clone(),
+            props: self.state.selected_props.clone(),
+            keys: self.state.selected_keys.clone(),
+            vertices: self.state.selected_vertices.clone(),
+        };
+        if sel.is_empty() {
+            self.state.comp_selections.remove(&id);
+        } else {
+            self.state.comp_selections.insert(id, sel);
+        }
+    }
+
+    fn recall_selection(&mut self, id: ItemId) {
+        match self.state.comp_selections.remove(&id) {
+            Some(sel) => {
+                self.state.selected_layers = sel.layers;
+                self.state.selected_props = sel.props;
+                self.state.selected_keys = sel.keys;
+                self.state.selected_vertices = sel.vertices;
+            }
+            None => self.clear_live_selection(),
+        }
+    }
+
+    fn clear_live_selection(&mut self) {
+        self.state.selected_layers.clear();
+        self.state.selected_props.clear();
+        self.state.selected_keys.clear();
+        self.state.selected_vertices.clear();
+    }
+
+    /// Open a comp in the viewer/timeline and make it active.
+    pub fn open_comp(&mut self, id: ItemId) {
+        if self.project.comp(id).is_none() {
+            return;
+        }
+        if !self.state.open_comps.contains(&id) {
+            self.state.open_comps.push(id);
+        }
+        if self.state.active_comp != Some(id) {
+            let previous = self.state.active_comp;
+            self.state.recent_comps.retain(|c| *c != id && Some(*c) != previous);
+            if let Some(previous) = previous {
+                self.state.recent_comps.insert(0, previous);
+                self.state.recent_comps.truncate(32);
+            }
+        }
+        self.activate_comp(id);
+        self.events.push(Event::OpenComp(id));
+    }
+
+    /// The open compositions and their current times, as a project file records them
+    /// ([`effectcraft_project::SavedView`]).
+    pub fn saved_view(&self) -> effectcraft_project::SavedView {
+        let comp_times = self.state.times.iter().filter(|(id, _)| self.project.comp(**id).is_some()).map(|(id, t)| (*id, *t)).collect();
+        effectcraft_project::SavedView { active_comp: self.state.active_comp, open_comps: self.state.open_comps.clone(), comp_times }
+    }
+
+    /// Reopen the compositions a project file was saved with (#748), each at its saved current
+    /// time (#1714). Ids that no longer name a comp are skipped; with none left the project stays
+    /// on the comp [`Session::replace_project`] opened (its first), as files from before the view
+    /// was saved do.
+    pub fn restore_view(&mut self, view: &effectcraft_project::SavedView) {
+        for (id, t) in &view.comp_times {
+            if let Some(comp) = self.project.comp(*id) {
+                let t = comp_frame_at(comp, *t);
+                self.state.times.insert(*id, t);
+            }
+        }
+        let mut open: Vec<ItemId> = Vec::new();
+        for id in view.open_comps.iter().copied().filter(|id| self.project.comp(*id).is_some()) {
+            if !open.contains(&id) {
+                open.push(id);
+            }
+        }
+        let Some(active) = view.active_comp.filter(|id| self.project.comp(*id).is_some()).or_else(|| open.first().copied()) else { return };
+        self.state.open_comps = open;
+        self.open_comp(active);
+    }
+
+    /// The 3D view camera of a comp's viewer (None = the active camera).
+    pub fn view_camera(&self, comp: ItemId) -> Option<effectcraft_render::three_d::CameraState> {
+        let c = self.project.comp(comp)?;
+        if !c.has_3d() {
+            return None;
+        }
+        self.state.views3d.get(&comp)?.override_camera(c.width as f64, c.height as f64)
+    }
+
+    /// Resolve a comp reference (item id number or name; `None`/null = the active comp).
+    pub fn resolve_comp(&self, comp: Option<&Value>) -> Result<ItemId> {
+        let p = match comp {
+            Some(v) if !v.is_null() => serde_json::json!({ "comp": v }),
+            _ => serde_json::json!({}),
+        };
+        commands::comp_id(self, &p)
+    }
+}
diff --git a/crates/engine/src/session/dispatch.rs b/crates/engine/src/session/dispatch.rs
new file mode 100644
index 000000000..36c7f0a51
--- /dev/null
+++ b/crates/engine/src/session/dispatch.rs
@@ -0,0 +1,70 @@
+use super::{EngineError, Event, Result, Session, Value, commands, guard};
+
+impl Session {
+    pub fn new() -> Session {
+        Session::default()
+    }
+
+    /// 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 let Err(why) = (spec.enabled)(self) {
+            // Explicit targets (agents, scripts) don't need a UI selection.
+            let explicit = (["layer", "layers", "prop", "keys"].iter().any(|k| params.get(k).is_some()) && commands::has_comp(self).is_ok())
+                || ["item", "items"].iter().any(|k| params.get(k).is_some())
+                // An explicit composition (the enablement looks at the active one).
+                || params.get("comp").is_some_and(|c| !c.is_null() && self.resolve_comp(Some(c)).is_ok());
+            if !explicit {
+                return Err(EngineError::Disabled(id.to_string(), why));
+            }
+        }
+        // Last-resort guard: a panicking command reports an error instead of crashing the app.
+        let r = guard::guarded(&format!("command `{id}`"), || (spec.run)(self, &params))?;
+        self.learn_observe(id, &params);
+        if spec.journal {
+            self.journal.push((id.to_string(), params));
+            if self.journal.len() > 10_000 {
+                self.journal.drain(..1000);
+            }
+        }
+        Ok(r)
+    }
+
+    /// [`Session::execute`] for agents and scripts (MCP, CLI, control channel): unknown top-level
+    /// parameters are rejected with the accepted keys instead of being silently ignored.
+    pub fn execute_checked(&mut self, id: &str, params: Value) -> Result<Value> {
+        let spec = commands::find(id).ok_or_else(|| EngineError::UnknownCommand(id.to_string()))?;
+        commands::check_params(spec, &params)?;
+        self.execute(id, params)
+    }
+
+    /// [`Session::execute`] for a command a script asked for (the JavaScript engine's
+    /// `app.run`, ScriptUI callbacks…). The command and everything it runs count as the script's:
+    /// it may not change the settings that limit scripts (Settings ▸ Scripting & Expressions ▸
+    /// Application Scripting), which only the user can, from the UI, CLI or control channel.
+    pub fn execute_for_script(&mut self, id: &str, params: Value) -> Result<Value> {
+        self.script_calls.0 = self.script_calls.0.saturating_add(1);
+        let r = self.execute(id, params);
+        self.script_calls.0 = self.script_calls.0.saturating_sub(1);
+        r
+    }
+
+    /// Whether the command running was issued by a script ([`Session::execute_for_script`]).
+    pub fn running_for_script(&self) -> bool {
+        self.script_calls.0 > 0
+    }
+
+    /// Whether `id` names a known command whose `enabled` predicate returns `Ok` for this session;
+    /// an unknown id or a predicate error reads as disabled.
+    pub fn is_enabled(&self, id: &str) -> bool {
+        commands::find(id).is_some_and(|c| (c.enabled)(self).is_ok())
+    }
+
+    pub fn toast(&mut self, msg: impl Into<String>) {
+        self.events.push(Event::Toast { message: msg.into(), error: false });
+    }
+
+    pub fn drain_events(&mut self) -> Vec<Event> {
+        std::mem::take(&mut self.events)
+    }
+}
diff --git a/crates/engine/src/session/edit.rs b/crates/engine/src/session/edit.rs
new file mode 100644
index 000000000..c2590abc3
--- /dev/null
+++ b/crates/engine/src/session/edit.rs
@@ -0,0 +1,314 @@
+use super::{Arc, EditorState, EngineError, Event, History, ItemId, Project, Result, Session, camera_track, commands, roto, warp};
+
+impl Session {
+    /// Apply an undoable edit. `merge`: consecutive edits with the same key fold into one step.
+    ///
+    /// Every edit is an external boundary for the on-canvas text editor: if it replaced the
+    /// document the editor is showing, the selection is clamped and the editor gets a fresh IME
+    /// epoch. The editor's own typing goes through `edit_text_doc`, which owns that
+    /// document and must not treat its own keystrokes as a replacement.
+    pub fn edit<T>(&mut self, label: &str, merge: Option<&str>, f: impl FnOnce(&mut Project, &mut EditorState) -> Result<T>) -> Result<T> {
+        let edited = commands::text_edit::active_editor_snapshot(self);
+        let out = self.edit_inner(label, merge, f)?;
+        commands::text_edit::after_external_change(self, edited.as_ref());
+        Ok(out)
+    }
+
+    /// [`Session::edit`] for the on-canvas editor's own text changes. Its document is the one
+    /// the editor owns, so a change here is typing, not a replacement behind the IME's back.
+    pub(crate) fn edit_text_doc<T>(&mut self, label: &str, merge: Option<&str>, f: impl FnOnce(&mut Project, &mut EditorState) -> Result<T>) -> Result<T> {
+        self.edit_inner(label, merge, f)
+    }
+
+    /// The shared body of [`Session::edit`] and [`Session::edit_text_doc`].
+    ///
+    /// Runs `f` on a clone of the project and editor state, then synchronizes derived data (global
+    /// light and Essential Graphics), queues invalidated Warp Stabilizer/camera-tracker work and
+    /// Roto Brush instances needing re-propagation in the `*_pending` lists. If the clone has the same
+    /// content the project and history are left as they were (only editor-state changes from `f`
+    /// are kept) and no revision is bumped; otherwise the previous project is recorded as an
+    /// undo step under `label`, unless it merges with the current merge key (then the redo branch
+    /// is dropped). An `Err` from `f` propagates with the session unchanged.
+    fn edit_inner<T>(&mut self, label: &str, merge: Option<&str>, f: impl FnOnce(&mut Project, &mut EditorState) -> Result<T>) -> Result<T> {
+        let before = self.project.clone();
+        let mut p = (*self.project).clone();
+        let mut st = self.state.clone();
+        let r = f(&mut p, &mut st)?;
+        // Layer styles: one Global Light per comp, whichever layer edited it.
+        effectcraft_project::styles::sync_global_light(&before, &mut p);
+        // Essential Properties of precomp layers follow their comps' Essential Graphics.
+        effectcraft_project::essential::sync_project(&before, &mut p);
+        // Warp Stabilizer analyses made from other frames are cleared (and queued again).
+        for w in warp::invalidate(&before, &mut p) {
+            if !self.warp_pending.contains(&w) {
+                self.warp_pending.push(w);
+            }
+        }
+        // So are 3D Camera Tracker tracks (and solves made with other settings).
+        for w in camera_track::invalidate(&before, &mut p) {
+            if !self.camera_pending.contains(&w) {
+                self.camera_pending.push(w);
+            }
+        }
+        // Roto Brush Input Keys follow the frames; edited instances propagate again.
+        for r in roto::sync(&before, &mut p) {
+            if !self.roto_pending.contains(&r) {
+                self.roto_pending.push(r);
+            }
+        }
+        // Nothing changed (a value set to what it already was): no undo step, not modified.
+        if p.same_content(&before) {
+            self.state = st;
+            return Ok(r);
+        }
+        let same = merge.is_some() && merge.map(str::to_string) == self.history.merge_key;
+        if !same {
+            // Undone steps aren't lost: they stay in the History panel as a branch.
+            let levels = self.prefs.general.undo_levels.max(1) as usize;
+            self.history.record(label, before, levels);
+        } else {
+            self.history.abandon_redo(&before);
+        }
+        self.history.merge_key = merge.map(str::to_string);
+        self.project = Arc::new(p);
+        self.state = st;
+        self.bump();
+        Ok(r)
+    }
+
+    /// Note a change to the on-canvas editor's committed text or session.
+    ///
+    /// Frontends compare this with [`commands::text_edit::ime_stamp_revision`]; an unrelated
+    /// project change must not advance it.
+    pub(crate) fn note_text_edit_change(&mut self) {
+        // Checked process-wide allocation: a stamp is never wrapped or reused. On exhaustion
+        // keep the previous value; an unavailable before/after pair then compares equal and
+        // earns no receipt instead of accepting a stale revision.
+        if let Some(revision) = commands::text_edit::next_ime_revision() {
+            self.ime_revision = self.ime_revision.max(revision);
+        }
+    }
+
+    pub fn bump(&mut self) {
+        self.revision += 1;
+        // A Cryptomatte probe is keyed by the revision: an older one never answers again.
+        self.drop_crypto_probe();
+        // Back at the saved state (undo, redo, a history jump or a rolled-back batch).
+        if Arc::ptr_eq(&self.project, &self.saved_project) {
+            self.saved_revision = self.revision;
+        }
+        self.refresh_disk_salt(false);
+        self.events.push(Event::ProjectChanged { revision: self.revision });
+    }
+
+    /// Salt the disk cache's layer keys with the project's footage files
+    /// ([`effectcraft_render::disk_cache::footage_salt`]). Taking it reads the size and time of
+    /// every file, every frame of an image sequence included, so it is taken again only when the
+    /// footage items changed, or with `force` (a project opened, footage reloaded, the disk cache
+    /// attached), not at every edit: with a few large sequences that cost each keystroke in a
+    /// text field over half a second (#1926).
+    pub fn refresh_disk_salt(&mut self, force: bool) -> Option<u64> {
+        use std::hash::{Hash, Hasher};
+        if self.disk_cache.is_none() {
+            self.disk_salt = None;
+            return None;
+        }
+        let mut h = std::collections::hash_map::DefaultHasher::new();
+        for (id, it) in &self.project.items {
+            if let effectcraft_project::ItemKind::Footage(f) = &it.kind {
+                id.hash(&mut h);
+                format!("{f:?}").hash(&mut h);
+            }
+        }
+        let footage = h.finish();
+        if let Some((seen, salt)) = self.disk_salt
+            && seen == footage
+            && !force
+        {
+            return Some(salt);
+        }
+        let salt = effectcraft_render::disk_cache::footage_salt(&self.project);
+        self.disk_salt = Some((footage, salt));
+        self.layer_cache.set_disk_salt(salt);
+        Some(salt)
+    }
+
+    /// Set a comp's Resolution. As in After Effects it is saved with the project (which becomes
+    /// modified) but is no undo step, and it changes no pixels: the comp's cached frames stay
+    /// valid ([`effectcraft_project::Comp::same_pixels`]).
+    pub fn set_resolution(&mut self, comp: ItemId, r: effectcraft_project::Resolution) -> Result<()> {
+        if self.project.comp(comp).ok_or(EngineError::NoComp)?.resolution == r {
+            return Ok(());
+        }
+        Arc::make_mut(&mut self.project).comp_mut(comp).ok_or(EngineError::NoComp)?.resolution = r;
+        self.bump();
+        Ok(())
+    }
+
+    /// Keep what lives outside the undo history (each comp's Resolution) as it is in `from`, the
+    /// project before undo, redo or a history jump restored another state.
+    pub(crate) fn keep_view_settings(&mut self, from: &Project) {
+        let keep: Vec<(ItemId, effectcraft_project::Resolution)> =
+            self.project.comps().filter_map(|(id, c)| from.comp(*id).map(|f| (*id, f.resolution)).filter(|(_, r)| *r != c.resolution)).collect();
+        if keep.is_empty() {
+            return;
+        }
+        let p = Arc::make_mut(&mut self.project);
+        for (id, r) in keep {
+            if let Some(c) = p.comp_mut(id) {
+                c.resolution = r;
+            }
+        }
+    }
+
+    /// Undoes one step: the current project goes onto the redo stack, per-comp Resolution is kept
+    /// as it was, the merge key is cleared, selections are sanitized for the replaced state (the
+    /// on-canvas editor gets a new IME epoch only when its own document changed) and the session is
+    /// bumped. Returns `false`, changing nothing, when there is nothing to undo.
+    pub fn undo(&mut self) -> bool {
+        let Some((label, p)) = self.history.undo.pop() else { return false };
+        let edited = commands::text_edit::active_editor_snapshot(self);
+        let probe = commands::kept_crypto_probe(self);
+        let cur = std::mem::replace(&mut self.project, p);
+        self.keep_view_settings(&cur);
+        self.history.merge_key = None;
+        self.sanitize_after_replacement(edited.as_ref());
+        self.bump();
+        commands::keep_crypto_probe(self, probe, &cur);
+        self.history.redo.push((label, cur));
+        true
+    }
+
+    /// Redoes one step: the current project goes back onto the undo stack, per-comp Resolution is
+    /// kept, the merge key is cleared, selections are sanitized for the replaced state (a changed
+    /// text document starts a new IME epoch) and the session is bumped. Returns `false`, changing
+    /// nothing, when there is nothing to redo.
+    pub fn redo(&mut self) -> bool {
+        let Some((label, p)) = self.history.redo.pop() else { return false };
+        let edited = commands::text_edit::active_editor_snapshot(self);
+        let probe = commands::kept_crypto_probe(self);
+        let cur = std::mem::replace(&mut self.project, p);
+        self.keep_view_settings(&cur);
+        self.history.merge_key = None;
+        self.sanitize_after_replacement(edited.as_ref());
+        self.bump();
+        commands::keep_crypto_probe(self, probe, &cur);
+        self.history.undo.push((label, cur));
+        true
+    }
+
+    pub fn is_dirty(&self) -> bool {
+        self.revision != self.saved_revision
+    }
+
+    /// The project as it is now is the saved one (after opening or saving it).
+    pub fn mark_saved(&mut self) {
+        self.saved_project = self.project.clone();
+        self.saved_revision = self.revision;
+    }
+
+    /// The project has changes its file doesn't (a session restored with unsaved changes): it
+    /// stays modified until it is saved, whatever is undone.
+    pub fn mark_unsaved(&mut self) {
+        self.saved_project = Arc::new(Project::default());
+        self.bump();
+    }
+
+    /// Replace the whole project (open/new), resetting history and state.
+    pub fn replace_project(&mut self, mut p: Project, path: Option<String>) {
+        if self.stop_render()
+            && let Some(mut job) = self.render_job.take()
+        {
+            // Let the worker notice the cancel; its updates refer to the old project.
+            job.wait();
+        }
+        self.render_job = None;
+        self.stored_paths = Default::default();
+        self.stop_track();
+        self.track_job = None;
+        self.stop_mask_track();
+        self.mask_job = None;
+        self.stop_warp();
+        self.warp_job = None;
+        self.warp_pending.clear();
+        self.stop_camera();
+        self.camera_job = None;
+        self.camera_pending.clear();
+        self.stop_roto();
+        self.roto_job = None;
+        self.roto_pending.clear();
+        self.drop_tasks();
+        self.script_ui.project_epoch = self.script_ui.project_epoch.wrapping_add(1);
+        p.fix_next_id();
+        upgrade_effects(&mut p);
+        // The media layer keys decoded frames by path: files of the new project may have changed
+        // since an earlier project decoded them (#1070).
+        for it in p.items.values() {
+            if let effectcraft_project::ItemKind::Footage(f) = &it.kind {
+                self.forget_decoded(f);
+            }
+        }
+        self.layer_cache.clear();
+        self.project = Arc::new(p);
+        // Its files may have changed since they were last stamped.
+        self.disk_salt = None;
+        self.history = History::default();
+        self.state = EditorState { snapping: true, view_layout: 1, ..Default::default() };
+        self.path = path;
+        self.bump();
+        self.mark_saved();
+        let first = self.project.comps().next().map(|(id, _)| *id);
+        if let Some(c) = first {
+            self.open_comp(c);
+        }
+    }
+}
+
+/// Bring effect instances saved by earlier versions up to date with the effect registry
+/// (renamed / regrouped / added parameters, reordered popups; see
+/// [`effectcraft_effects::migrate`]), and a project from before
+/// [`effectcraft_project::SCHEMA_EFFECT_SPACE`] into effect space
+/// ([`effectcraft_effects::migrate::to_effect_space`]). Shape path operations get the
+/// properties added since ([`effectcraft_project::build::upgrade_shape_contents`]). Stamps the
+/// current schema.
+pub fn upgrade_effects(p: &mut Project) {
+    let to_effect_space = p.schema < effectcraft_project::SCHEMA_EFFECT_SPACE;
+    // Effect bounds per layer: (size, top-left in layer coordinates).
+    let mut bounds = std::collections::HashMap::new();
+    for (cid, c) in p.comps() {
+        for l in &c.layers {
+            bounds.insert((*cid, l.id), effectcraft_render::effect_bounds(p, c, l));
+        }
+    }
+    let mut next = p.next_id;
+    for (cid, it) in p.items.iter_mut() {
+        let effectcraft_project::ItemKind::Comp(c) = &mut it.kind else { continue };
+        for l in &mut std::sync::Arc::make_mut(c).layers {
+            let (size, origin) = bounds.get(&(*cid, l.id)).copied().unwrap_or(([100.0, 100.0], [0.0; 2]));
+            // Effect space starts at the bounds' top-left: positions move by minus that corner.
+            // Adjustment layers run their effects on the comp below as it is: nothing moves.
+            let shift = |o: [f64; 2]| [-o[0], -o[1]];
+            let d = if l.switches.adjustment { [0.0; 2] } else { shift(origin) };
+            let clone_d = |src: Option<u64>| match src {
+                Some(id) => bounds.get(&(*cid, effectcraft_project::LayerId(id))).map_or([0.0; 2], |b| shift(b.1)),
+                None => d,
+            };
+            if let Some(contents) = l.props.sub_mut("contents") {
+                effectcraft_project::build::upgrade_shape_contents(&mut effectcraft_project::build::Ids(&mut next), contents);
+            }
+            let Some(fx) = l.props.sub_mut("effects") else { continue };
+            for n in &mut fx.children {
+                let effectcraft_project::Node::Group(g) = n else { continue };
+                let effectcraft_project::GroupKind::Effect { effect } = &g.kind else { continue };
+                if let Some(spec) = effectcraft_effects::find(effect) {
+                    effectcraft_effects::migrate::upgrade_instance(spec, g, &mut effectcraft_project::build::Ids(&mut next), size);
+                    if to_effect_space {
+                        effectcraft_effects::migrate::to_effect_space(spec, g, size, d, &clone_d);
+                    }
+                }
+            }
+        }
+    }
+    p.next_id = next;
+    p.schema = effectcraft_project::SCHEMA_VERSION;
+}
diff --git a/crates/engine/src/session/render.rs b/crates/engine/src/session/render.rs
new file mode 100644
index 000000000..86127a510
--- /dev/null
+++ b/crates/engine/src/session/render.rs
@@ -0,0 +1,140 @@
+use super::{EngineError, Image, ItemId, RenderOpts, Renderer, Result, Session, ThumbnailJob, Tick, Value, commands};
+
+impl Session {
+    /// Render a comp frame with the session's footage + expression hosts.
+    pub fn render(&self, comp: ItemId, t: Tick, opts: RenderOpts) -> Image {
+        self.renderer(opts).comp_frame(comp, t)
+    }
+
+    /// The renderer [`Session::render`] uses: the session's footage, expressions, layer cache and
+    /// accelerator, and the render prefs (nested switches, draft shadows) over `opts`.
+    pub fn renderer(&self, opts: RenderOpts) -> Renderer<'_> {
+        let mut r = Renderer::new(&self.project, self.footage.as_ref(), self.render_opts(opts));
+        r.expr = self.expr.as_deref();
+        r.cache = Some(&self.layer_cache);
+        r.accel = self.accel.as_deref();
+        r
+    }
+
+    /// `opts` with the render prefs (nested switches, draft shadows), as [`Session::renderer`].
+    pub fn render_opts(&self, opts: RenderOpts) -> RenderOpts {
+        RenderOpts { nested_switches: self.prefs.general.switches_affect_nested_comps, draft_shadows: self.prefs.three_d.realtime_shadows, ..opts }
+    }
+
+    /// Whether `effect.cryptomatteAt` with params `p` answers from the kept probe (a few array
+    /// reads; `probeOnly` queries answer `pending` until then). Changes nothing: ask it every
+    /// frame, and start [`Session::crypto_probe_job`] only when a build will actually run.
+    pub fn crypto_probe_ready(&self, p: &Value) -> Result<bool> {
+        commands::crypto_probe_ready(self, p)
+    }
+
+    /// For the Cryptomatte eyedropper: `None` when `effect.cryptomatteAt` with params `p` answers
+    /// from the kept probe, else a job that builds that probe (it may render a precomp's ID pass)
+    /// off the UI thread, for the next query to use. Asking for a job supersedes a build in
+    /// flight for another probe (it then stores nothing): ask only to run it.
+    pub fn crypto_probe_job(&self, p: &Value) -> Result<Option<commands::CryptoProbeJob>> {
+        commands::crypto_probe_job(self, p)
+    }
+
+    /// Let go of the kept Cryptomatte probe (and its aux channels), and cancel a build in
+    /// flight: the eyedropper was disarmed. Edits, footage changes and Open / New do it too.
+    pub fn drop_crypto_probe(&self) {
+        if let Ok(mut slot) = self.crypto_probe.lock() {
+            slot.clear();
+        }
+    }
+
+    /// Whether a Cryptomatte probe is kept, and how many were built so far (for tests).
+    #[doc(hidden)]
+    pub fn crypto_probe_stats(&self) -> (bool, u64) {
+        self.crypto_probe.lock().map_or((false, 0), |s| (s.kept(), s.builds().1))
+    }
+
+    /// How many probe jobs ran so far, built or cancelled before they began (for tests: each
+    /// is a thread in the eyedropper).
+    #[doc(hidden)]
+    pub fn crypto_probe_jobs(&self) -> u64 {
+        self.crypto_probe.lock().map_or(0, |s| s.builds().0)
+    }
+
+    /// Render a comp frame (comp time `t`) as opaque 8-bit RGBA over the comp background, scaled
+    /// so the longest side is at most `max_side` pixels (0 = full size). Returns (width, height, rgba).
+    pub fn render_rgba8(&self, comp: ItemId, t: Tick, max_side: u32) -> Result<(u32, u32, Vec<u8>)> {
+        let c = self.project.comp(comp).ok_or(EngineError::NoComp)?;
+        let long = c.width.max(c.height).max(1) as f64;
+        let scale = if max_side == 0 { 1.0 } else { (max_side as f64 / long).min(1.0) };
+        let img = self.render(comp, t, RenderOpts { scale, backend: effectcraft_render::Backend::Auto, ..Default::default() });
+        Ok((img.width, img.height, img.to_rgba8_over(c.background)))
+    }
+
+    /// A Project panel thumbnail of an item (a comp at `t`, footage at its first frame), longest
+    /// side at most `max_side`, as a job that owns everything it reads: frontends run it off the
+    /// UI thread (a big comp takes far longer than a frame). `None` for items without pixels.
+    pub fn thumbnail_job(&self, item: ItemId, t: Tick, max_side: u32) -> Option<ThumbnailJob> {
+        let it = self.project.item(item)?;
+        let footage = self.footage.clone();
+        match &it.kind {
+            effectcraft_project::ItemKind::Comp(c) => {
+                let (project, expr, cache) = (self.project.clone(), self.expr.clone(), self.layer_cache.clone());
+                let long = c.width.max(c.height).max(1) as f64;
+                let scale = if max_side == 0 { 1.0 } else { (max_side as f64 / long).min(1.0) };
+                let opts = RenderOpts {
+                    scale,
+                    nested_switches: self.prefs.general.switches_affect_nested_comps,
+                    draft_shadows: self.prefs.three_d.realtime_shadows,
+                    ..Default::default()
+                };
+                let bg = c.background;
+                Some(Box::new(move || {
+                    let mut r = Renderer::new(&project, footage.as_ref(), opts);
+                    r.expr = expr.as_deref();
+                    r.cache = Some(&cache);
+                    let img = r.comp_frame(item, t);
+                    Some((img.width, img.height, img.to_rgba8_over(bg)))
+                }))
+            }
+            effectcraft_project::ItemKind::Footage(f) if f.has_video => {
+                let f = f.clone();
+                Some(Box::new(move || {
+                    let img = effectcraft_render::cineon_frame(footage.frame(item, &f, Tick(0))?, &f);
+                    // Point-sample down to at most `max_side` on the long side.
+                    let step = (img.width.max(img.height) as f32 / max_side.max(1) as f32).ceil().max(1.0) as u32;
+                    let (w, h) = (img.width.div_ceil(step), img.height.div_ceil(step));
+                    let full = img.to_rgba8();
+                    let mut px = Vec::with_capacity((w * h * 4) as usize);
+                    for y in 0..h {
+                        for x in 0..w {
+                            let i = (((y * step) * img.width + x * step) * 4) as usize;
+                            px.extend_from_slice(&full[i..i + 4]);
+                        }
+                    }
+                    Some((w, h, px))
+                }))
+            }
+            _ => None,
+        }
+    }
+
+    /// [`Session::render_rgba8`], or with `transparent` the frame's own straight alpha (what a
+    /// render with RGB + Alpha channels writes) instead of compositing over the background.
+    pub fn render_rgba8_alpha(&self, comp: ItemId, t: Tick, max_side: u32, transparent: bool) -> Result<(u32, u32, Vec<u8>)> {
+        if !transparent {
+            return self.render_rgba8(comp, t, max_side);
+        }
+        let c = self.project.comp(comp).ok_or(EngineError::NoComp)?;
+        let long = c.width.max(c.height).max(1) as f64;
+        let scale = if max_side == 0 { 1.0 } else { (max_side as f64 / long).min(1.0) };
+        let img = self.render(comp, t, RenderOpts { scale, backend: effectcraft_render::Backend::Auto, ..Default::default() });
+        Ok((img.width, img.height, img.to_rgba8()))
+    }
+
+    /// Make the media layer and the layer cache let go of what they decoded from `footage`'s
+    /// files (it keys frames by path, so an overwritten file would keep showing its old pixels).
+    pub(crate) fn forget_decoded(&self, footage: &effectcraft_project::Footage) {
+        for p in std::iter::once(&footage.path).chain(&footage.sequence) {
+            self.footage.forget(p);
+        }
+        self.layer_cache.clear();
+        self.drop_crypto_probe();
+    }
+}
diff --git a/crates/engine/src/settings.rs b/crates/engine/src/settings.rs
new file mode 100644
index 000000000..5981d4591
--- /dev/null
+++ b/crates/engine/src/settings.rs
@@ -0,0 +1,5 @@
+pub mod autosave;
+pub mod config;
+pub mod prefs;
+pub(super) mod session_settings;
+pub mod shortcuts;
diff --git a/crates/engine/src/autosave.rs b/crates/engine/src/settings/autosave.rs
similarity index 99%
rename from crates/engine/src/autosave.rs
rename to crates/engine/src/settings/autosave.rs
index 37127ac56..e70e819fd 100644
--- a/crates/engine/src/autosave.rs
+++ b/crates/engine/src/settings/autosave.rs
@@ -143,7 +143,7 @@ pub fn write(prefs: &Prefs, project: Option<&str>, fallback: Option<&Path>, last
     write_in(&StdFiles, prefs, project, fallback, last_slot, json)
 }
 
-/// [`write`] through `fs`.
+/// [`write()`] through `fs`.
 pub fn write_in(
     fs: &dyn FileOps,
     prefs: &Prefs,
diff --git a/crates/engine/src/config.rs b/crates/engine/src/settings/config.rs
similarity index 88%
rename from crates/engine/src/config.rs
rename to crates/engine/src/settings/config.rs
index 00e7377b7..17d7c940a 100644
--- a/crates/engine/src/config.rs
+++ b/crates/engine/src/settings/config.rs
@@ -24,7 +24,9 @@ pub trait ConfigStore: Send + Sync {
         }
         Ok(text)
     }
+    /// Write entry `name`, replacing any earlier text.
     fn write(&self, name: &str, data: &str) -> std::io::Result<()>;
+    /// Remove entry `name`; a missing entry is no error.
     fn remove(&self, name: &str) -> std::io::Result<()>;
     /// Names of the entries directly in `dir` (a `/`-separated name prefix such as `Scripts`),
     /// sorted. Stores that can't list return nothing.
@@ -32,6 +34,11 @@ pub trait ConfigStore: Send + Sync {
         let _ = dir;
         vec![]
     }
+    /// Names of the folders directly in `dir`, sorted, like [`ConfigStore::list`].
+    fn list_dirs(&self, dir: &str) -> Vec<String> {
+        let _ = dir;
+        vec![]
+    }
     /// The folder next to the configuration (default Auto-Save folder for untitled projects),
     /// in the namespace of [`ConfigStore::files`]; `None` when there is none.
     fn dir(&self) -> Option<PathBuf> {
@@ -107,6 +114,15 @@ impl ConfigStore for MemoryConfig {
         let Ok(m) = self.files.lock() else { return vec![] };
         m.keys().filter_map(|k| k.strip_prefix(&pre)).filter(|n| !n.is_empty() && !n.contains('/')).map(str::to_string).collect()
     }
+    /// The first name part of the keys under `dir/`.
+    fn list_dirs(&self, dir: &str) -> Vec<String> {
+        let pre = format!("{}/", dir.trim_end_matches('/'));
+        let Ok(m) = self.files.lock() else { return vec![] };
+        let mut v: Vec<String> = m.keys().filter_map(|k| k.strip_prefix(&pre)?.split_once('/')).map(|(d, _)| d.to_string()).filter(|d| !d.is_empty()).collect();
+        v.sort();
+        v.dedup();
+        v
+    }
 }
 
 /// Files in one directory, written atomically.
@@ -153,6 +169,13 @@ impl ConfigStore for DirConfig {
         v.sort();
         v
     }
+    /// The folders in `dir`, following links like [`ConfigStore::list`] does for files.
+    fn list_dirs(&self, dir: &str) -> Vec<String> {
+        let Ok(rd) = std::fs::read_dir(self.dir.join(dir)) else { return vec![] };
+        let mut v: Vec<String> = rd.flatten().filter(|e| e.path().is_dir()).map(|e| e.file_name().to_string_lossy().to_string()).collect();
+        v.sort();
+        v
+    }
     fn remove(&self, name: &str) -> std::io::Result<()> {
         match std::fs::remove_file(self.dir.join(name)) {
             Err(e) if e.kind() != std::io::ErrorKind::NotFound => Err(e),
diff --git a/crates/engine/src/settings/prefs.rs b/crates/engine/src/settings/prefs.rs
new file mode 100644
index 000000000..94c90c3a3
--- /dev/null
+++ b/crates/engine/src/settings/prefs.rs
@@ -0,0 +1,132 @@
+//! Settings (After Effects' Preferences): a versioned serde model, addressed by dotted keys
+//! (`general.undoLevels`, `autoSave.intervalMinutes`, `labels.3.name`), plus the page schema the
+//! Settings dialog and agents (`prefs.pages`) are built from.
+//!
+//! Settings are stored as JSON (`prefs.json`) through the session's [`crate::config::ConfigStore`].
+//! Loading is forgiving: missing keys take their defaults, unknown keys (written by a newer
+//! version) are kept and written back, and older layouts are migrated ([`migrate`]).
+//!
+//! Every setting in [`pages`] says whether it already changes behaviour (`live`). Settings that
+//! don't yet are still shown (After Effects parity of the dialog) and are listed in
+//! `docs/preferences.md`; a test keeps that list in step with the schema.
+
+use std::collections::BTreeMap;
+
+use effectcraft_color::Label;
+use effectcraft_time::Tick;
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value, json};
+
+mod choices;
+mod dialog;
+mod document;
+mod queries;
+mod recent;
+mod sections;
+
+pub use choices::{APPEARANCE_MODES, DARK_THEMES, LANGUAGES, LIGHT_THEMES, THEMES, WINDOW_GRAPHICS, theme_family};
+pub use dialog::{Item, Kind, Page, pages, pages_json, todo_keys};
+pub use document::{migrate, page_id, section_key};
+pub use queries::{CacheBudgets, WEB_LAYER_CACHE, WEB_MEDIA_CACHE, mask_color};
+pub use recent::{MAX_RECENT_SCRIPTS, RecentScript};
+pub use sections::{
+    Appearance, Audio, AutoSave, CompPreset, CompositionPrefs, Disk, Export, FacePrefs, General, Grids, Import, LabelPref, Memory, Previews, ProjectPrefs,
+    RotoPrefs, Scripting, Startup, ThreeD, TypePrefs, Video,
+};
+use sections::{Extra, default_labels, lenient_comp_presets};
+
+/// Current settings layout version.
+pub const PREFS_VERSION: u32 = 4;
+/// Settings file name in the config store.
+pub const PREFS_FILE: &str = "prefs.json";
+
+/// All settings.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct Prefs {
+    pub version: u32,
+    pub general: General,
+    pub startup: Startup,
+    pub project: ProjectPrefs,
+    pub auto_save: AutoSave,
+    pub composition: CompositionPrefs,
+    pub previews: Previews,
+    pub appearance: Appearance,
+    pub grids: Grids,
+    /// The 16 labels (Red … Dark Green), in order.
+    pub labels: Vec<LabelPref>,
+    #[serde(rename = "type")]
+    pub type_: TypePrefs,
+    pub import: Import,
+    pub export: Export,
+    pub audio: Audio,
+    pub disk: Disk,
+    pub memory: Memory,
+    pub video: Video,
+    #[serde(rename = "threeD")]
+    pub three_d: ThreeD,
+    pub scripting: Scripting,
+    pub roto: RotoPrefs,
+    pub face: FacePrefs,
+    /// File ▸ Open Recent, newest first.
+    pub recent_projects: Vec<String>,
+    /// File ▸ Import Recent Footage, newest first.
+    pub recent_footage: Vec<String>,
+    /// Animation ▸ Recent Animation Presets (`.ecpreset` paths or built-in preset ids), newest
+    /// first.
+    pub recent_presets: Vec<String>,
+    /// File ▸ Scripts ▸ Recent Script Files, newest first, at most [`MAX_RECENT_SCRIPTS`].
+    pub recent_scripts: Vec<RecentScript>,
+    /// Character panel: recently used font families, newest first.
+    pub recent_fonts: Vec<String>,
+    /// Effects & Presets: the starred effects' ids, in the order starred.
+    pub effects_favorites: Vec<String>,
+    /// Preview panel: every shortcut's options.
+    pub preview: crate::preview::PreviewSettings,
+    /// View ▸ Simulate Output ▸ My Custom RGB.
+    pub custom_rgb: crate::viewer::CustomRgb,
+    /// Composition Settings presets the user saved, in the order saved.
+    #[serde(deserialize_with = "lenient_comp_presets")]
+    pub comp_presets: Vec<CompPreset>,
+    /// Top-level keys this version doesn't know (kept for newer versions).
+    #[serde(flatten)]
+    pub extra: Extra,
+}
+
+impl Default for Prefs {
+    fn default() -> Self {
+        Prefs {
+            version: PREFS_VERSION,
+            general: General::default(),
+            startup: Startup::default(),
+            project: ProjectPrefs::default(),
+            auto_save: AutoSave::default(),
+            composition: CompositionPrefs::default(),
+            previews: Previews::default(),
+            appearance: Appearance::default(),
+            grids: Grids::default(),
+            labels: default_labels(),
+            type_: TypePrefs::default(),
+            import: Import::default(),
+            export: Export::default(),
+            audio: Audio::default(),
+            disk: Disk::default(),
+            memory: Memory::default(),
+            video: Video::default(),
+            three_d: ThreeD::default(),
+            scripting: Scripting::default(),
+            roto: RotoPrefs::default(),
+            face: FacePrefs::default(),
+            recent_projects: vec![],
+            recent_footage: vec![],
+            recent_presets: vec![],
+            recent_scripts: vec![],
+            recent_fonts: vec![],
+            effects_favorites: vec![],
+            preview: crate::preview::PreviewSettings::default(),
+            custom_rgb: crate::viewer::CustomRgb::default(),
+            comp_presets: vec![],
+            extra: Extra::new(),
+        }
+    }
+}
diff --git a/crates/engine/src/settings/prefs/choices.rs b/crates/engine/src/settings/prefs/choices.rs
new file mode 100644
index 000000000..20f7a482e
--- /dev/null
+++ b/crates/engine/src/settings/prefs/choices.rs
@@ -0,0 +1,65 @@
+/// Settings ▸ General ▸ Language: (label, `general.language` value).
+pub const LANGUAGES: &[(&str, &str)] = &[
+    ("Match System", "system"),
+    ("English", "en"),
+    // Alphabetical by the language's own name after English; Cyrillic, Georgian, then CJK names
+    // follow the Latin ones.
+    ("Čeština", "cs"),
+    ("Deutsch", "de"),
+    ("Español", "es"),
+    ("Français", "fr"),
+    ("Polski", "pl"),
+    ("Português (Brasil)", "pt-br"),
+    ("Svenska", "sv"),
+    ("Русский", "ru"),
+    ("Українська", "uk"),
+    ("ქართული", "ka"),
+    ("日本語", "ja"),
+    ("简体中文", "zh-hans"),
+    ("繁體中文", "zh-hant"),
+];
+
+/// Settings ▸ Startup & Repair ▸ Window Graphics: (label, `startup.windowGraphics` value).
+pub const WINDOW_GRAPHICS: &[(&str, &str)] = &[("Automatic", "auto"), ("OpenGL (compatibility)", "gl")];
+
+/// Settings ▸ Appearance ▸ Appearance Mode: (label, `appearance.appearanceMode` value). Auto
+/// follows the operating system's light or dark appearance.
+pub const APPEARANCE_MODES: &[(&str, &str)] = &[("Sync with System", "auto"), ("Dark", "dark"), ("Light", "light")];
+
+/// The dark family of themes: (label, `appearance.darkTheme` value).
+pub const DARK_THEMES: &[(&str, &str)] = &[("Dark", "dark"), ("Darker", "darker")];
+
+/// The light family of themes: (label, `appearance.lightTheme` value).
+pub const LIGHT_THEMES: &[(&str, &str)] = &[("Light", "light")];
+
+/// Every theme (the legacy single-theme `appearance.theme`).
+pub const THEMES: &[(&str, &str)] = &[("Dark", "dark"), ("Darker", "darker"), ("Light", "light")];
+
+/// The settings whose value must be one of their choices.
+pub(super) fn choices(key: &str) -> Option<&'static [(&'static str, &'static str)]> {
+    match key {
+        "general.language" => Some(LANGUAGES),
+        "startup.windowGraphics" => Some(WINDOW_GRAPHICS),
+        "appearance.appearanceMode" => Some(APPEARANCE_MODES),
+        "appearance.darkTheme" => Some(DARK_THEMES),
+        "appearance.lightTheme" => Some(LIGHT_THEMES),
+        "appearance.theme" => Some(THEMES),
+        _ => None,
+    }
+}
+
+pub(super) fn is_choice(choices: &[(&str, &str)], v: &str) -> bool {
+    choices.iter().any(|(_, c)| *c == v)
+}
+
+/// The appearance mode and the per-mode setting a theme belongs to (`darker` → (`dark`,
+/// `darkTheme`)); `None` for an unknown theme.
+pub fn theme_family(theme: &str) -> Option<(&'static str, &'static str)> {
+    if is_choice(DARK_THEMES, theme) {
+        Some(("dark", "darkTheme"))
+    } else if is_choice(LIGHT_THEMES, theme) {
+        Some(("light", "lightTheme"))
+    } else {
+        None
+    }
+}
diff --git a/crates/engine/src/settings/prefs/dialog.rs b/crates/engine/src/settings/prefs/dialog.rs
new file mode 100644
index 000000000..c4ff1d546
--- /dev/null
+++ b/crates/engine/src/settings/prefs/dialog.rs
@@ -0,0 +1,436 @@
+use super::choices::{APPEARANCE_MODES, DARK_THEMES, LANGUAGES, LIGHT_THEMES, WINDOW_GRAPHICS};
+use super::{Value, json};
+
+// ---------------------------------------------------------------- schema (Settings dialog)
+
+/// What a setting row edits.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Kind {
+    Bool,
+    /// Integer with range and unit.
+    Int(i64, i64, &'static str),
+    /// Number with range and unit.
+    Float(f64, f64, &'static str),
+    /// One of (label, value).
+    Choice(&'static [(&'static str, &'static str)]),
+    Text,
+    /// A folder or file path (text + Choose…).
+    Path,
+    /// `#rrggbb`.
+    Color,
+    /// UI brightness slider.
+    Slider(f64, f64),
+}
+
+/// One row of a settings page.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Item {
+    Section(&'static str),
+    Setting {
+        key: &'static str,
+        label: &'static str,
+        kind: Kind,
+        /// Changes behaviour today (false = shown for parity, listed in docs/preferences.md).
+        live: bool,
+    },
+    /// A button running a command (`params` is JSON).
+    Button {
+        label: &'static str,
+        command: &'static str,
+        params: &'static str,
+    },
+    /// The 16 label names and colours.
+    Labels,
+    /// Output device picker (device list from the host).
+    AudioDevices {
+        key: &'static str,
+    },
+    /// Read-only information line.
+    Note(&'static str),
+    /// The browser's storage manager (web app only, `storage.*`): usage and quota, persistent
+    /// storage, Clear buttons. Not shown where there is no browser storage.
+    BrowserStorage,
+    /// A task's trained models (`roto.models`, `face.models`): authors, licence, size, install,
+    /// choose.
+    Models(effectcraft_segment::Task),
+}
+
+/// One page of the Settings dialog.
+#[derive(Clone, Debug)]
+pub struct Page {
+    pub id: &'static str,
+    pub title: &'static str,
+    pub items: Vec<Item>,
+}
+
+const fn s(key: &'static str, label: &'static str, kind: Kind, live: bool) -> Item {
+    Item::Setting { key, label, kind, live }
+}
+
+const B: Kind = Kind::Bool;
+
+const ON_OFF_RES: &[(&str, &str)] = &[("1/2", "1/2"), ("1/4", "1/4"), ("1/8", "1/8")];
+
+const STYLES: &[(&str, &str)] = &[("Lines", "lines"), ("Dashed Lines", "dashed"), ("Dots", "dots")];
+
+/// The Settings pages in After Effects 2026 order.
+pub fn pages() -> Vec<Page> {
+    use Item::*;
+    vec![
+        Page {
+            id: "general",
+            title: "General",
+            items: vec![
+                s("general.language", "Language", Kind::Choice(LANGUAGES), true),
+                s("general.undoLevels", "Levels of Undo", Kind::Int(1, 99, ""), true),
+                s("general.pathPointSize", "Path Point and Handle Size", Kind::Int(3, 20, "px"), true),
+                s("general.recentItems", "Recent Projects Shown", Kind::Int(1, 30, ""), true),
+                Section("Options"),
+                s("general.showToolTips", "Show Tool Tips", B, true),
+                s("general.viewerWheelScrubbing", "Scrub Composition Frames with Mouse Wheel", B, true),
+                s("general.createLayersAtCompStart", "Create Layers at Composition Start Time", B, true),
+                s("general.switchesAffectNestedComps", "Switches Affect Nested Comps", B, true),
+                s("general.defaultSpatialLinear", "Default Spatial Interpolation to Linear", B, true),
+                s("general.preserveConstantVertexCount", "Preserve Constant Vertex and Feather Point Count when Editing Masks", B, true),
+                s("general.syncTimeRelatedItems", "Synchronize Time of All Related Items", B, true),
+                s("general.expressionPickWhipCompact", "Expression Pick Whip Writes Compact English", B, true),
+                s("general.createSplitLayersAbove", "Create Split Layers Above Original Layer", B, true),
+                s("general.useSystemColorPicker", "Use System Color Picker", B, false),
+                Note("EffectCraft always uses its own colour picker (the same on every platform and the web)."),
+            ],
+        },
+        Page {
+            id: "startup",
+            title: "Startup & Repair",
+            items: vec![
+                s("startup.showHomeOnLaunch", "Show Home Screen When Launching", B, true),
+                s("startup.showHomeOnOpenProject", "Show Home Screen When Opening a Project", B, true),
+                s("startup.offerCrashRecovery", "Offer to Open the Latest Auto-Save After a Crash", B, true),
+                s("startup.windowGraphics", "Window Graphics", Kind::Choice(WINDOW_GRAPHICS), true),
+                Note(
+                    "Window Graphics applies from the next launch. When the graphics driver stops EffectCraft as its window opens, the next launch switches to OpenGL.",
+                ),
+                Section("Repair"),
+                Button { label: "Reset Settings", command: "prefs.reset", params: "{}" },
+                Button { label: "Reset Keyboard Shortcuts", command: "shortcuts.reset", params: "{}" },
+                Button { label: "Empty Disk Cache", command: "edit.purge", params: r#"{"what":"disk"}"# },
+            ],
+        },
+        Page {
+            id: "project",
+            title: "Project",
+            items: vec![
+                Section("New Project"),
+                s("project.useTemplate", "New Project Loads Template", B, true),
+                s("project.templatePath", "Template Project", Kind::Path, true),
+                Section("Project Files"),
+                s("project.compactProjectFiles", "Save Compact Project Files", B, true),
+                Note(
+                    "Saves .ecproj files as compact JSON on one line: smaller and faster to save and open, but hard to read or diff in version control. Off, they are indented, one value per line.",
+                ),
+                Section("Auto-Save"),
+                s("autoSave.enabled", "Automatically Save Projects", B, true),
+                s("autoSave.intervalMinutes", "Save Every", Kind::Int(1, 240, "Minutes"), true),
+                s("autoSave.maxVersions", "Maximum Project Versions", Kind::Int(1, 99, ""), true),
+                s("autoSave.location", "Auto-Save Location", Kind::Choice(&[("Next to Project", "nextToProject"), ("Custom Location", "custom")]), true),
+                s("autoSave.folder", "Custom Location", Kind::Path, true),
+                s("autoSave.saveOnRenderStart", "Save When Starting Render Queue", B, true),
+                Button { label: "Save Now", command: "file.autoSave", params: "{}" },
+            ],
+        },
+        Page {
+            id: "composition",
+            title: "Composition",
+            items: vec![
+                Section("Motion Path"),
+                s(
+                    "composition.motionPath",
+                    "Motion Path",
+                    Kind::Choice(&[
+                        ("All Keyframes", "all"),
+                        ("No Motion Path", "none"),
+                        ("No More Than (Seconds)", "seconds"),
+                        ("No More Than (Keyframes)", "keyframes"),
+                    ]),
+                    true,
+                ),
+                s("composition.motionPathSeconds", "Seconds", Kind::Float(0.0, 3600.0, "s"), true),
+                s("composition.motionPathKeyframes", "Keyframes", Kind::Int(1, 10_000, ""), true),
+                Section("Display"),
+                s("composition.showRenderingProgress", "Show Rendering Progress in Info Panel and Flowchart", B, true),
+                s("composition.hardwareAcceleratePanels", "Hardware Accelerate Composition, Layer and Footage Panels", B, false),
+                Note("Panels are always drawn by the GPU (wgpu)."),
+            ],
+        },
+        Page {
+            id: "previews",
+            title: "Previews",
+            items: vec![
+                s("previews.adaptiveResolutionLimit", "Adaptive Resolution Limit", Kind::Choice(ON_OFF_RES), true),
+                s("previews.showInternalWireframes", "Show Internal Wireframes", B, true),
+                s("previews.cacheFramesWhenIdle", "Cache Frames When Idle", B, true),
+                s("previews.fastPreviews", "Fast Previews (Draft 3D, Faster Effects)", B, true),
+                s("previews.zoomQuality", "Viewer Zoom Quality", Kind::Choice(&[("Faster", "faster"), ("More Accurate", "moreAccurate")]), true),
+                s("previews.displayProfile", "Display Color Space", Kind::Choice(&[("sRGB", "srgb"), ("Display P3", "p3")]), true),
+                Button { label: "GPU Information...", command: "app.gpuInfo", params: "{}" },
+            ],
+        },
+        Page {
+            id: "appearance",
+            title: "Appearance",
+            items: vec![
+                s("appearance.appearanceMode", "Appearance Mode", Kind::Choice(APPEARANCE_MODES), true),
+                s("appearance.lightTheme", "Light Theme", Kind::Choice(LIGHT_THEMES), true),
+                s("appearance.darkTheme", "Dark Theme", Kind::Choice(DARK_THEMES), true),
+                s("appearance.brightness", "Brightness", Kind::Slider(-1.0, 1.0), true),
+                s("appearance.uiScale", "UI Scale", Kind::Int(75, 200, "%"), true),
+                Section("Labels and Colors"),
+                s("appearance.useLabelColorForHandles", "Use Label Color for Layer Handles and Paths", B, true),
+                s("appearance.useLabelColorForTabs", "Use Label Color for Related Tabs", B, true),
+                s("appearance.cycleMaskColors", "Cycle Mask Colors", B, true),
+                s("appearance.useGradients", "Use Gradients", B, true),
+                Section("Menu Bar"),
+                s("appearance.inWindowMenuBarMac", "Use In-Window Menu Bar on macOS", B, true),
+            ],
+        },
+        Page {
+            id: "grids",
+            title: "Grids & Guides",
+            items: vec![
+                Section("Grid"),
+                s("grids.gridColor", "Color", Kind::Color, true),
+                s("grids.gridSpacing", "Gridline Every", Kind::Float(1.0, 10_000.0, "px"), true),
+                s("grids.gridSubdivisions", "Subdivisions", Kind::Int(1, 100, ""), true),
+                s("grids.gridStyle", "Style", Kind::Choice(STYLES), true),
+                Section("Proportional Grid"),
+                s("grids.proportionalHorizontal", "Horizontal", Kind::Int(1, 100, ""), true),
+                s("grids.proportionalVertical", "Vertical", Kind::Int(1, 100, ""), true),
+                Section("Guides"),
+                s("grids.guideColor", "Color", Kind::Color, true),
+                s("grids.guideStyle", "Style", Kind::Choice(STYLES), true),
+                Section("Safe Margins"),
+                s("grids.actionSafe", "Action-safe", Kind::Float(0.0, 50.0, "%"), true),
+                s("grids.titleSafe", "Title-safe", Kind::Float(0.0, 50.0, "%"), true),
+            ],
+        },
+        Page { id: "labels", title: "Labels", items: vec![Labels] },
+        Page {
+            id: "type",
+            title: "Type",
+            items: vec![
+                s("type.textEngine", "Text Engine", Kind::Choice(&[("Latin", "latin"), ("South Asian and Middle Eastern", "southAsian")]), true),
+                s("type.fontPreview", "Show Font Preview", B, true),
+                s("type.recentFonts", "Number of Recent Fonts to Display", Kind::Int(0, 30, ""), true),
+                s("type.fontNamesInEnglish", "Show Font Names in English", B, true),
+            ],
+        },
+        Page {
+            id: "import",
+            title: "Import",
+            items: vec![
+                s("import.stillFootage", "Still Footage", Kind::Choice(&[("Length of Composition", "compLength"), ("Duration (Seconds)", "seconds")]), true),
+                s("import.stillSeconds", "Still Duration", Kind::Float(0.04, 86_400.0, "s"), true),
+                s("import.sequenceFps", "Sequence Footage", Kind::Float(1.0, 999.0, "frames per second"), true),
+                s("import.reportMissingFrames", "Report Missing Frames", B, true),
+                s(
+                    "import.autoReloadFootage",
+                    "Automatically Reload Footage",
+                    Kind::Choice(&[("Off", "off"), ("Non-Sequence Footage", "nonSequence"), ("All Footage", "all")]),
+                    true,
+                ),
+                s(
+                    "import.unlabeledAlpha",
+                    "Interpret Unlabeled Alpha As",
+                    Kind::Choice(&[
+                        ("Ask User", "ask"),
+                        ("Guess", "guess"),
+                        ("Ignore", "ignore"),
+                        ("Straight", "straight"),
+                        ("Premultiplied", "premultiplied"),
+                    ]),
+                    true,
+                ),
+                s(
+                    "import.dragImportAs",
+                    "Default Drag Import As",
+                    Kind::Choice(&[("Footage", "footage"), ("Composition", "comp"), ("Composition - Retain Layer Sizes", "compLayerSizes")]),
+                    true,
+                ),
+            ],
+        },
+        Page {
+            id: "export",
+            title: "Export",
+            items: vec![
+                s("export.defaultOutputFolder", "Default Output Folder", Kind::Path, true),
+                s("export.segmentSequences", "Segment Sequences", B, true),
+                s("export.segmentSequenceFiles", "Files per Segment", Kind::Int(1, 100_000, "files"), true),
+                s("export.segmentMovies", "Segment Movie Files", B, true),
+                s("export.segmentMovieMb", "Segment Size", Kind::Int(1, 1_000_000, "MB"), true),
+                s("export.appendBitsToName", "Append Bit Depth to File Name", B, true),
+            ],
+        },
+        Page {
+            id: "audio",
+            title: "Audio",
+            items: vec![
+                Section("Audio Hardware"),
+                AudioDevices { key: "audio.outputDevice" },
+                s("audio.previewSampleRate", "Preview Sample Rate", Kind::Int(8_000, 192_000, "Hz"), true),
+                Section("Audio Output Mapping"),
+                s("audio.outputLeft", "Left", Kind::Int(1, 64, "channel"), true),
+                s("audio.outputRight", "Right", Kind::Int(1, 64, "channel"), true),
+            ],
+        },
+        Page {
+            id: "disk",
+            title: "Disk",
+            items: vec![
+                Section("Disk Cache"),
+                s("disk.diskCacheEnabled", "Enable Disk Cache", B, true),
+                s("disk.diskCacheMaxGb", "Maximum Disk Cache Size", Kind::Int(1, 100_000, "GB"), true),
+                s("disk.diskCacheFolder", "Disk Cache Folder", Kind::Path, true),
+                Button { label: "Empty Disk Cache", command: "edit.purge", params: r#"{"what":"disk"}"# },
+                BrowserStorage,
+                Section("Media Cache"),
+                s("disk.mediaCacheFolder", "Database and Cache Folder", Kind::Path, true),
+                s("disk.conformedMediaFolder", "Conformed Audio Folder", Kind::Path, true),
+            ],
+        },
+        Page {
+            id: "memory",
+            title: "Memory & CPU",
+            items: vec![
+                s("memory.ramReservedGb", "RAM Reserved for Other Applications", Kind::Int(0, 1024, "GB"), true),
+                Section("Cache Budgets"),
+                s("memory.layerCacheMb", "Layer Cache", Kind::Int(64, 1 << 20, "MB"), true),
+                s("memory.mediaCacheMb", "Footage Frame Cache", Kind::Int(64, 1 << 20, "MB"), true),
+                s("memory.previewCacheMb", "Preview (RAM) Cache", Kind::Int(64, 1 << 20, "MB"), true),
+                s("memory.reduceCacheWhenLow", "Reduce Cache Size When System Is Low on Memory", B, true),
+            ],
+        },
+        Page {
+            id: "video",
+            title: "Video",
+            items: vec![
+                s("video.enableOutput", "Enable Video Preview Output", B, true),
+                s("video.device", "Video Device", Kind::Choice(&[("Floating Window", ""), ("Full Screen", "fullscreen")]), true),
+                s("video.outputDuringPlayback", "Video Output During Playback", B, true),
+                s("video.mirrorOnMonitor", "Mirror on Computer Monitor", B, true),
+                s("video.disableWhenBackground", "Disable Video Output When in Background", B, true),
+            ],
+        },
+        Page {
+            id: "3d",
+            title: "3D",
+            items: vec![
+                s("threeD.defaultRenderer", "Default 3D Renderer", Kind::Choice(&[("Classic 3D", "classic"), ("Advanced 3D", "advanced")]), true),
+                s("threeD.showReferenceAxes", "Show 3D Reference Axes", B, true),
+                s("threeD.extendedViewer", "Extended Viewer", B, true),
+                s("threeD.realtimeShadows", "Realtime Shadows in Draft", B, true),
+            ],
+        },
+        Page {
+            id: "scripting",
+            title: "Scripting & Expressions",
+            items: vec![
+                Section("Application Scripting"),
+                s("scripting.allowScriptsWriteFiles", "Allow Scripts to Write Files and Access Network", B, true),
+                s("scripting.warnExecutingFiles", "Warn User When Executing Files", B, true),
+                s("scripting.enableJsDebugger", "Enable JavaScript Debugger", B, false),
+                Section("Expressions Editor"),
+                s("scripting.editorFontSize", "Font Size", Kind::Int(8, 40, "pt"), true),
+                s("scripting.syntaxHighlighting", "Syntax Highlighting", B, true),
+                s("scripting.lineNumbers", "Line Numbers", B, true),
+                s("scripting.autoComplete", "Auto-complete", B, true),
+                s("scripting.bracketMatching", "Bracket Matching", B, true),
+                s("scripting.wordWrap", "Word Wrap", B, true),
+                s("scripting.errorBanner", "Show Expression Error Banner", B, true),
+                Note("Expressions use the JavaScript engine. Script errors report their file and line in the Script Console; there is no step debugger."),
+            ],
+        },
+        Page {
+            id: "roto",
+            title: "Roto Brush",
+            items: vec![
+                Section("Segmentation Model"),
+                Note(
+                    "Roto Brush 2.0 and 3.0 use the model chosen here (Version 1.0 always uses the classic engine). Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
+                ),
+                Models(effectcraft_segment::Task::Mask),
+            ],
+        },
+        Page {
+            id: "face",
+            title: "Face Tracking",
+            items: vec![
+                Section("Face Model"),
+                Note(
+                    "Face tracking in the Tracker panel (Outline Only and Detailed Features) uses the model chosen here. Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
+                ),
+                Models(effectcraft_segment::Task::Face),
+            ],
+        },
+    ]
+}
+
+/// Keys of every setting that doesn't change behaviour yet (the TODO list in
+/// `docs/preferences.md`).
+pub fn todo_keys() -> Vec<&'static str> {
+    pages()
+        .into_iter()
+        .flat_map(|p| p.items)
+        .filter_map(|i| match i {
+            Item::Setting { key, live: false, .. } => Some(key),
+            _ => None,
+        })
+        .collect()
+}
+
+/// The schema as JSON (for `prefs.pages`).
+pub fn pages_json() -> Value {
+    let kind = |k: &Kind| -> Value {
+        match k {
+            Kind::Bool => json!({"type": "bool"}),
+            Kind::Int(a, b, u) => json!({"type": "int", "min": a, "max": b, "unit": u}),
+            Kind::Float(a, b, u) => json!({"type": "number", "min": a, "max": b, "unit": u}),
+            Kind::Choice(o) => json!({"type": "choice", "options": o.iter().map(|(l, v)| json!({"label": l, "value": v})).collect::<Vec<_>>()}),
+            Kind::Text => json!({"type": "text"}),
+            Kind::Path => json!({"type": "path"}),
+            Kind::Color => json!({"type": "color"}),
+            Kind::Slider(a, b) => json!({"type": "slider", "min": a, "max": b}),
+        }
+    };
+    let pages: Vec<Value> = pages()
+        .iter()
+        .map(|p| {
+            let items: Vec<Value> = p
+                .items
+                .iter()
+                .map(|i| match i {
+                    Item::Section(t) => json!({"section": t}),
+                    Item::Setting { key, label, kind: k, live } => {
+                        let mut o = kind(k);
+                        o["key"] = json!(key);
+                        o["label"] = json!(label);
+                        o["live"] = json!(live);
+                        o
+                    }
+                    Item::Button { label, command, params } => {
+                        json!({"button": label, "command": command, "params": serde_json::from_str::<Value>(params).unwrap_or_default()})
+                    }
+                    Item::Labels => json!({"labels": "labels.N.name / labels.N.color (N = 0..15)"}),
+                    Item::AudioDevices { key } => json!({"type": "device", "key": key, "label": "Default Output"}),
+                    Item::Note(t) => json!({"note": t}),
+                    Item::BrowserStorage => json!({"browserStorage": "storage.info / storage.persist / storage.clear (web app)"}),
+                    Item::Models(task) => {
+                        let p = if *task == effectcraft_segment::Task::Face { "face" } else { "roto" };
+                        json!({"models": format!("{p}.models / {p}.model.select / {p}.model.download / {p}.model.install / {p}.model.remove"), "key": format!("{p}.model")})
+                    }
+                })
+                .collect();
+            json!({"id": p.id, "title": p.title, "items": items})
+        })
+        .collect();
+    json!(pages)
+}
diff --git a/crates/engine/src/settings/prefs/document.rs b/crates/engine/src/settings/prefs/document.rs
new file mode 100644
index 000000000..1f68c4a06
--- /dev/null
+++ b/crates/engine/src/settings/prefs/document.rs
@@ -0,0 +1,333 @@
+use super::choices::{APPEARANCE_MODES, DARK_THEMES, LANGUAGES, LIGHT_THEMES, THEMES, WINDOW_GRAPHICS, choices, is_choice, theme_family};
+use super::recent::{MAX_EFFECTS_FAVORITES, MAX_RECENT_SCRIPTS};
+use super::sections::{CompPreset, default_labels, parse_hex};
+use super::{Appearance, General, Map, PREFS_VERSION, Prefs, Startup, Value, json};
+
+/// Bring an older settings document up to [`PREFS_VERSION`].
+///
+/// - version 0/1 (early builds) kept a flat object: `undoLevels`, `autoSaveEnabled`,
+///   `autoSaveMinutes`, `autoSaveVersions`, `labelNames` (array) and `theme` at the top level.
+/// - version 2 defaulted the disk cache to 100 GB, more than most laptops have free; the stored
+///   old default becomes the new one (a size the user chose is kept).
+/// - version 3 and earlier could still hold `createSplitLayersAbove: false`, the default before
+///   #2083 (every save kept it); it becomes After Effects' default, above (#2545).
+pub fn migrate(mut v: Value) -> Value {
+    let Some(obj) = v.as_object_mut() else { return json!({}) };
+    let version = obj.get("version").and_then(Value::as_u64).unwrap_or(0);
+    if version < 2 {
+        let moved = |from: &str, page: &str, key: &str, obj: &mut Map<String, Value>| {
+            if let Some(x) = obj.remove(from) {
+                let p = obj.entry(page.to_string()).or_insert_with(|| json!({}));
+                if let Some(p) = p.as_object_mut() {
+                    p.entry(key.to_string()).or_insert(x);
+                }
+            }
+        };
+        moved("undoLevels", "general", "undoLevels", obj);
+        moved("autoSaveEnabled", "autoSave", "enabled", obj);
+        moved("autoSaveMinutes", "autoSave", "intervalMinutes", obj);
+        moved("autoSaveVersions", "autoSave", "maxVersions", obj);
+        moved("theme", "appearance", "theme", obj);
+        if let Some(Value::Array(names)) = obj.remove("labelNames") {
+            let mut labels = default_labels();
+            for (l, n) in labels.iter_mut().zip(names) {
+                if let Some(n) = n.as_str() {
+                    l.name = n.to_string();
+                }
+            }
+            obj.insert("labels".into(), serde_json::to_value(labels).unwrap_or_default());
+        }
+    }
+    if version < 3
+        && let Some(d) = obj.get_mut("disk").and_then(Value::as_object_mut)
+        && d.get("diskCacheMaxGb").and_then(Value::as_u64) == Some(100)
+    {
+        d.insert("diskCacheMaxGb".into(), json!(20));
+    }
+    if version < 4
+        && let Some(g) = obj.get_mut("general").and_then(Value::as_object_mut)
+        && g.get("createSplitLayersAbove") == Some(&json!(false))
+    {
+        g.insert("createSplitLayersAbove".into(), json!(true));
+    }
+    // Settings saved before appearance modes had one theme: keep showing it, as a fixed Dark or
+    // Light mode, instead of switching established users to Auto.
+    if let Some(a) = obj.get_mut("appearance").and_then(Value::as_object_mut)
+        && !a.contains_key("appearanceMode")
+        && let Some(theme) = a.get("theme").and_then(Value::as_str).map(str::to_string)
+        && let Some((mode, slot)) = theme_family(&theme)
+    {
+        a.insert("appearanceMode".into(), json!(mode));
+        a.insert(slot.into(), json!(theme));
+    }
+    obj.insert("version".into(), json!(PREFS_VERSION));
+    v
+}
+
+impl Prefs {
+    /// Parse a settings document (migrating older layouts; unknown keys are kept, bad values
+    /// fall back to defaults).
+    pub fn from_json(text: &str) -> Prefs {
+        let v: Value = serde_json::from_str(text).unwrap_or_else(|_| json!({}));
+        let v = migrate(v);
+        let mut p: Prefs = match serde_json::from_value(v.clone()) {
+            Ok(p) => p,
+            // One bad value shouldn't lose everything: take each page that parses.
+            Err(_) => {
+                let mut base = serde_json::to_value(Prefs::default()).unwrap_or_default();
+                if let (Some(b), Some(o)) = (base.as_object_mut(), v.as_object()) {
+                    for (k, x) in o {
+                        let mut trial = b.clone();
+                        trial.insert(k.clone(), x.clone());
+                        if serde_json::from_value::<Prefs>(Value::Object(trial)).is_ok() {
+                            b.insert(k.clone(), x.clone());
+                        }
+                    }
+                }
+                serde_json::from_value(base).unwrap_or_default()
+            }
+        };
+        p.normalize();
+        p
+    }
+
+    pub fn to_json(&self) -> String {
+        serde_json::to_string_pretty(self).unwrap_or_default()
+    }
+
+    /// Clamp values into their valid ranges and fill missing labels.
+    pub fn normalize(&mut self) {
+        self.version = PREFS_VERSION;
+        self.comp_presets.retain(CompPreset::is_valid);
+        let mut seen = std::collections::HashSet::new();
+        self.effects_favorites.retain(|id| !id.is_empty() && seen.insert(id.clone()));
+        self.effects_favorites.truncate(MAX_EFFECTS_FAVORITES);
+        if !is_choice(WINDOW_GRAPHICS, &self.startup.window_graphics) {
+            self.startup.window_graphics = Startup::default().window_graphics;
+        }
+        let g = &mut self.general;
+        if !is_choice(LANGUAGES, &g.language) {
+            g.language = General::default().language;
+        }
+        g.undo_levels = g.undo_levels.clamp(1, 99);
+        g.path_point_size = g.path_point_size.clamp(3, 20);
+        g.recent_items = g.recent_items.clamp(1, 30);
+        let a = &mut self.auto_save;
+        a.interval_minutes = a.interval_minutes.clamp(1, 240);
+        a.max_versions = a.max_versions.clamp(1, 99);
+        let ap = &mut self.appearance;
+        let mut seen = std::collections::BTreeSet::new();
+        ap.favorite_themes.retain(|id| is_choice(THEMES, id) && seen.insert(id.clone()));
+        if !is_choice(APPEARANCE_MODES, &ap.appearance_mode) {
+            ap.appearance_mode = Appearance::default().appearance_mode;
+        }
+        if !is_choice(DARK_THEMES, &ap.dark_theme) {
+            ap.dark_theme = Appearance::default().dark_theme;
+        }
+        if !is_choice(LIGHT_THEMES, &ap.light_theme) {
+            ap.light_theme = Appearance::default().light_theme;
+        }
+        // The legacy single theme mirrors the theme a fixed mode shows (Auto depends on the
+        // system, so it keeps the last one).
+        match ap.appearance_mode.as_str() {
+            "dark" => ap.theme = ap.dark_theme.clone(),
+            "light" => ap.theme = ap.light_theme.clone(),
+            _ if !is_choice(THEMES, &ap.theme) => ap.theme = ap.dark_theme.clone(),
+            _ => {}
+        }
+        self.appearance.brightness = self.appearance.brightness.clamp(-1.0, 1.0);
+        self.appearance.ui_scale = self.appearance.ui_scale.clamp(75, 200);
+        let defaults = default_labels();
+        self.labels.truncate(defaults.len());
+        for d in defaults.iter().skip(self.labels.len()) {
+            self.labels.push(d.clone());
+        }
+        for (l, d) in self.labels.iter_mut().zip(&defaults) {
+            if parse_hex(&l.color).is_none() {
+                l.color = d.color.clone();
+            }
+        }
+        let m = &mut self.memory;
+        m.layer_cache_mb = m.layer_cache_mb.clamp(64, 1 << 20);
+        m.media_cache_mb = m.media_cache_mb.clamp(64, 1 << 20);
+        m.preview_cache_mb = m.preview_cache_mb.clamp(64, 1 << 20);
+        self.grids.grid_spacing = self.grids.grid_spacing.clamp(1.0, 10_000.0);
+        let n = self.general.recent_items as usize;
+        self.recent_projects.truncate(n);
+        self.recent_scripts.truncate(MAX_RECENT_SCRIPTS);
+    }
+
+    /// The value at a dotted key (`general.undoLevels`, `labels.3.color`); `""` = everything.
+    pub fn get(&self, key: &str) -> Option<Value> {
+        let v = serde_json::to_value(self).ok()?;
+        if key.is_empty() {
+            return Some(v);
+        }
+        let ptr = format!("/{}", key.replace('.', "/"));
+        v.pointer(&ptr).cloned()
+    }
+
+    /// Set the value at a dotted key. The key must exist and the value must have its type.
+    pub fn set(&mut self, key: &str, value: Value) -> Result<(), String> {
+        if let Some(c) = choices(key)
+            && !value.as_str().is_some_and(|v| is_choice(c, v))
+        {
+            let all: Vec<&str> = c.iter().map(|(_, v)| *v).collect();
+            return Err(format!("`{key}` expects one of {}", all.join(", ")));
+        }
+        let favorites = if key == "appearance.favoriteThemes" {
+            Some(&value)
+        } else if key == "appearance" {
+            value.get("favoriteThemes")
+        } else {
+            None
+        };
+        if let Some(favorites) = favorites {
+            let values = favorites.as_array().ok_or("favorite themes must be a list")?;
+            let mut seen = std::collections::BTreeSet::new();
+            for value in values {
+                let id = value.as_str().ok_or("favorite theme must be a string")?;
+                if !is_choice(THEMES, id) || !seen.insert(id) {
+                    return Err("unknown or duplicate favorite theme".into());
+                }
+            }
+        }
+        // Older clients set the single theme (by key, or inside the page object): it still picks
+        // a visible theme, fixing the mode to its family.
+        let legacy_theme = key == "appearance.theme" || (key == "appearance" && value.get("theme").is_some() && value.get("appearanceMode").is_none());
+        let mut v = serde_json::to_value(&*self).map_err(|e| e.to_string())?;
+        let ptr = format!("/{}", key.replace('.', "/"));
+        let slot = v.pointer_mut(&ptr).ok_or_else(|| format!("unknown setting `{key}`"))?;
+        let value = coerce(slot, value).ok_or_else(|| format!("`{key}` expects a {}", kind_name(slot)))?;
+        *slot = value;
+        let mut next: Prefs = serde_json::from_value(v).map_err(|e| format!("`{key}`: {e}"))?;
+        let (a, b) = (&self.appearance, &next.appearance);
+        let only_theme_changed = a.theme != b.theme && a.appearance_mode == b.appearance_mode && a.dark_theme == b.dark_theme && a.light_theme == b.light_theme;
+        if legacy_theme || only_theme_changed {
+            next.appearance.select_theme();
+        }
+        next.normalize();
+        *self = next;
+        Ok(())
+    }
+
+    /// Reset one page (`general`, `labels`, `autoSave`…) or everything (`None`). Open Recent and
+    /// the saved composition presets are kept.
+    pub fn reset(&mut self, page: Option<&str>) -> Result<(), String> {
+        let d = Prefs::default();
+        let Some(page) = page else {
+            *self = Prefs {
+                recent_projects: std::mem::take(&mut self.recent_projects),
+                recent_footage: std::mem::take(&mut self.recent_footage),
+                recent_presets: std::mem::take(&mut self.recent_presets),
+                recent_scripts: std::mem::take(&mut self.recent_scripts),
+                recent_fonts: std::mem::take(&mut self.recent_fonts),
+                effects_favorites: std::mem::take(&mut self.effects_favorites),
+                preview: std::mem::take(&mut self.preview),
+                comp_presets: std::mem::take(&mut self.comp_presets),
+                ..d
+            };
+            return Ok(());
+        };
+        let keys: Vec<&str> = match page {
+            "project" => vec!["project", "autoSave"],
+            p => vec![section_key(p).ok_or_else(|| format!("unknown settings page `{p}`"))?],
+        };
+        let dv = serde_json::to_value(&d).map_err(|e| e.to_string())?;
+        for k in keys {
+            if let Some(x) = dv.get(k) {
+                self.set(k, x.clone())?;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Settings key of a page id (`3d` → `threeD`).
+pub fn section_key(page: &str) -> Option<&'static str> {
+    Some(match page {
+        "general" => "general",
+        "startup" => "startup",
+        "project" => "project",
+        "autoSave" | "autosave" => "autoSave",
+        "composition" | "display" => "composition",
+        "previews" => "previews",
+        "appearance" => "appearance",
+        "grids" => "grids",
+        "labels" => "labels",
+        "type" => "type",
+        "import" => "import",
+        "export" => "export",
+        "audio" => "audio",
+        "disk" => "disk",
+        "memory" => "memory",
+        "video" => "video",
+        "3d" | "threeD" => "threeD",
+        "scripting" => "scripting",
+        "roto" => "roto",
+        "face" => "face",
+        _ => return None,
+    })
+}
+
+/// Settings page id for a page name, including older After Effects page names
+/// (Auto-Save → Project, Media & Disk Cache → Disk, Memory & Performance → Memory & CPU…).
+pub fn page_id(name: &str) -> Option<&'static str> {
+    let n = name.to_ascii_lowercase().replace([' ', '&', '-', '_'], "");
+    let id = match n.as_str() {
+        "general" => "general",
+        "startup" | "startuprepair" => "startup",
+        "project" | "autosave" | "newproject" => "project",
+        "composition" | "display" => "composition",
+        "previews" | "preview" => "previews",
+        "appearance" => "appearance",
+        "grids" | "gridsguides" => "grids",
+        "labels" => "labels",
+        "type" => "type",
+        "import" => "import",
+        "export" | "output" => "export",
+        "audio" | "audiohardware" | "audiooutputmapping" => "audio",
+        "disk" | "mediadiskcache" | "mediacache" => "disk",
+        "memory" | "memorycpu" | "memoryperformance" => "memory",
+        "video" | "videopreview" => "video",
+        "3d" | "threed" => "3d",
+        "scripting" | "scriptingexpressions" => "scripting",
+        "roto" | "rotobrush" | "models" => "roto",
+        "face" | "facetracking" => "face",
+        _ => return None,
+    };
+    Some(id)
+}
+
+fn kind_name(v: &Value) -> &'static str {
+    match v {
+        Value::Bool(_) => "boolean",
+        Value::Number(_) => "number",
+        Value::String(_) => "string",
+        Value::Array(_) => "list",
+        Value::Object(_) => "object",
+        Value::Null => "value",
+    }
+}
+
+/// `value` converted to the type of `slot` (numbers from strings, booleans from 0/1…).
+fn coerce(slot: &Value, value: Value) -> Option<Value> {
+    Some(match (slot, value) {
+        (Value::Bool(_), Value::Bool(b)) => json!(b),
+        (Value::Bool(_), Value::Number(n)) => json!(n.as_f64()? != 0.0),
+        (Value::Bool(_), Value::String(s)) => json!(matches!(s.as_str(), "true" | "on" | "1" | "yes")),
+        (Value::Number(cur), v) => {
+            let f = match &v {
+                Value::Number(n) => n.as_f64()?,
+                Value::String(s) => s.trim().parse().ok()?,
+                _ => return None,
+            };
+            if cur.is_u64() || cur.is_i64() { json!(f.round().max(0.0) as u64) } else { json!(f) }
+        }
+        (Value::String(_), Value::String(s)) => json!(s),
+        (Value::String(_), Value::Number(n)) => json!(n.to_string()),
+        (Value::Array(_), v @ Value::Array(_)) => v,
+        (Value::Object(_), v @ Value::Object(_)) => v,
+        _ => return None,
+    })
+}
diff --git a/crates/engine/src/settings/prefs/queries.rs b/crates/engine/src/settings/prefs/queries.rs
new file mode 100644
index 000000000..74be30f8f
--- /dev/null
+++ b/crates/engine/src/settings/prefs/queries.rs
@@ -0,0 +1,208 @@
+use super::sections::parse_hex;
+use super::{Label, Prefs, Serialize, Tick};
+
+impl Prefs {
+    /// Display name of a label (Labels settings).
+    pub fn label_name(&self, l: Label) -> String {
+        match label_index(l) {
+            Some(i) => self.labels.get(i).map(|p| p.name.clone()).unwrap_or_else(|| l.name().to_string()),
+            None => l.name().to_string(),
+        }
+    }
+
+    /// sRGB colour of a label (Labels settings).
+    pub fn label_rgb(&self, l: Label) -> [u8; 3] {
+        label_index(l).and_then(|i| self.labels.get(i)).and_then(|p| parse_hex(&p.color)).unwrap_or(l.rgb())
+    }
+
+    /// A label by its built-in name or its (renamed) display name.
+    pub fn label_from_name(&self, s: &str) -> Option<Label> {
+        Label::from_name(s).or_else(|| Label::ALL.iter().skip(1).copied().find(|l| self.label_name(*l).eq_ignore_ascii_case(s)))
+    }
+
+    /// Layer / media / preview cache budgets in bytes.
+    pub fn layer_cache_bytes(&self) -> usize {
+        (self.memory.layer_cache_mb as usize) << 20
+    }
+
+    pub fn media_cache_bytes(&self) -> usize {
+        (self.memory.media_cache_mb as usize) << 20
+    }
+
+    pub fn preview_cache_bytes(&self) -> usize {
+        (self.memory.preview_cache_mb as usize) << 20
+    }
+
+    /// The adaptive resolution limit as a render-scale floor (1/2 → 0.5).
+    pub fn adaptive_limit(&self) -> f64 {
+        match self.previews.adaptive_resolution_limit.as_str() {
+            "1/2" => 0.5,
+            "1/4" => 0.25,
+            _ => 0.125,
+        }
+    }
+
+    /// The Memory & CPU cache budgets in effect: the configured layer / footage / preview
+    /// budgets, scaled down so together they leave **RAM Reserved for Other Applications** free,
+    /// and halved while the system is low on memory when **Reduce Cache Size When System Is Low
+    /// on Memory** is on. `mem` = the system's memory (`None` = unknown: configured budgets).
+    /// In the browser the layer and footage caches also stay within [`WEB_LAYER_CACHE`] and
+    /// [`WEB_MEDIA_CACHE`].
+    pub fn cache_budgets(&self, mem: Option<crate::sysinfo::SysMemory>) -> CacheBudgets {
+        self.cache_budgets_in(mem, cfg!(target_arch = "wasm32"))
+    }
+
+    /// [`Prefs::cache_budgets`], in the browser's memory (`web`) or not.
+    pub(crate) fn cache_budgets_in(&self, mem: Option<crate::sysinfo::SysMemory>, web: bool) -> CacheBudgets {
+        let (mut l, mut m, mut p) = (self.layer_cache_bytes() as u64, self.media_cache_bytes() as u64, self.preview_cache_bytes() as u64);
+        if web {
+            (l, m) = (l.min(WEB_LAYER_CACHE), m.min(WEB_MEDIA_CACHE));
+        }
+        let floor = 64u64 << 20;
+        let mut capped = false;
+        let mut reduced = false;
+        if let Some(mem) = mem.filter(|m| m.total > 0) {
+            let reserved = (self.memory.ram_reserved_gb as u64) << 30;
+            let cap = mem.total.saturating_sub(reserved).max(3 * floor);
+            let sum = l + m + p;
+            if sum > cap {
+                let k = cap as f64 / sum as f64;
+                (l, m, p) = ((l as f64 * k) as u64, (m as f64 * k) as u64, (p as f64 * k) as u64);
+                capped = true;
+            }
+            if self.memory.reduce_cache_when_low && mem.is_low() {
+                (l, m, p) = (l / 2, m / 2, p / 2);
+                reduced = true;
+            }
+        }
+        CacheBudgets { layer: l.max(floor) as usize, media: m.max(floor) as usize, preview: p.max(floor) as usize, capped, reduced }
+    }
+
+    /// Composition ▸ Motion Path: the layer-time span of a motion path to draw around `now`
+    /// (layer time), for keyframes at `keys` (sorted). `None` = No Motion Path.
+    pub fn motion_path_span(&self, keys: &[Tick], now: Tick) -> Option<(Tick, Tick)> {
+        let (first, last) = (*keys.first()?, *keys.last()?);
+        let c = &self.composition;
+        match c.motion_path.as_str() {
+            "none" => None,
+            "seconds" => {
+                let half = Tick::from_seconds_f64(c.motion_path_seconds.max(0.0) / 2.0);
+                let (a, b) = ((now - half).max(first), (now + half).min(last));
+                (a < b).then_some((a, b))
+            }
+            "keyframes" => {
+                let n = (c.motion_path_keyframes.max(1) as usize).min(keys.len());
+                if n < 2 {
+                    return None;
+                }
+                // The n keyframes centred on the current time.
+                let at = keys.partition_point(|k| *k < now);
+                let start = at.saturating_sub(n / 2).min(keys.len() - n);
+                Some((keys[start], keys[start + n - 1]))
+            }
+            _ => Some((first, last)),
+        }
+    }
+
+    /// Previews ▸ Viewer Zoom Quality: smooth (bilinear) scaling of the viewer image, or nearest
+    /// neighbour ("Faster").
+    pub fn viewer_zoom_smooth(&self) -> bool {
+        self.previews.zoom_quality != "faster"
+    }
+
+    /// Import ▸ Interpret Unlabeled Alpha As, for footage whose file has an alpha channel that
+    /// doesn't state how it is stored. `None` = Ask User (keep straight and open Interpret
+    /// Footage); `guess` takes premultiplied for movies (codecs with alpha are usually written
+    /// premultiplied) and straight for stills.
+    pub fn unlabeled_alpha(&self, movie: bool) -> Option<effectcraft_project::AlphaMode> {
+        use effectcraft_project::AlphaMode::*;
+        Some(match self.import.unlabeled_alpha.as_str() {
+            "ignore" => Ignore,
+            "straight" => Straight,
+            "premultiplied" => Premultiplied,
+            "guess" if movie => Premultiplied,
+            "guess" => Straight,
+            _ => return None,
+        })
+    }
+
+    /// Import ▸ Default Drag Import As, as `file.import`'s `importAs`.
+    pub fn drag_import_as(&self) -> &'static str {
+        match self.import.drag_import_as.as_str() {
+            "comp" => "composition",
+            "compLayerSizes" => "compositionLayerSizes",
+            _ => "footage",
+        }
+    }
+
+    /// Export ▸ Append Bit Depth to File Name: `Comp 1.png` → `Comp 1_16bpc.png` (sequence frame
+    /// runs and folders are kept).
+    pub fn output_name(&self, path: &str, bits: u32) -> String {
+        if !self.export.append_bits_to_name {
+            return path.to_string();
+        }
+        let p = std::path::Path::new(path);
+        let (Some(stem), dir) = (p.file_stem().map(|s| s.to_string_lossy().to_string()), p.parent()) else { return path.to_string() };
+        let tag = format!("_{bits}bpc");
+        if stem.ends_with(&tag) {
+            return path.to_string();
+        }
+        let name = match p.extension() {
+            Some(e) => format!("{stem}{tag}.{}", e.to_string_lossy()),
+            None => format!("{stem}{tag}"),
+        };
+        match dir.filter(|d| !d.as_os_str().is_empty()) {
+            Some(d) => d.join(name).to_string_lossy().to_string(),
+            None => name,
+        }
+    }
+
+    /// Export ▸ Segment Sequences / Segment Movie Files: how many frames go in each segment of an
+    /// output of `frames` frames (`None` = one file / folder). Sequences split every Files per
+    /// Segment frames; movies every Segment Size MB at the output's data rate
+    /// (`bytes_per_frame`, estimated from the format's bitrate).
+    pub fn segment_frames(&self, frames: u64, sequence: bool, bytes_per_frame: f64) -> Option<u64> {
+        let e = &self.export;
+        let per = if sequence {
+            e.segment_sequences.then_some(e.segment_sequence_files.max(1) as u64)?
+        } else {
+            if !e.segment_movies || bytes_per_frame <= 0.0 {
+                return None;
+            }
+            (((e.segment_movie_mb.max(1) as f64) * 1_048_576.0 / bytes_per_frame).floor() as u64).max(1)
+        };
+        (per < frames).then_some(per)
+    }
+}
+
+/// The most the layer cache holds in the browser. A wasm32 page addresses at most 4 GiB, which
+/// these caches share with the app and with the decoders' own decoded frames (FilmCraft keeps
+/// up to 384 MB per open movie): with the desktop's 1 GB defaults, eight stacked 1080p clips ran
+/// the page out of memory a few seconds into playback.
+pub const WEB_LAYER_CACHE: u64 = 512 << 20;
+
+/// The most the footage frame cache holds in the browser (see [`WEB_LAYER_CACHE`]).
+pub const WEB_MEDIA_CACHE: u64 = 256 << 20;
+
+/// Effective cache budgets in bytes (see [`Prefs::cache_budgets`]).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
+pub struct CacheBudgets {
+    pub layer: usize,
+    pub media: usize,
+    pub preview: usize,
+    /// Scaled down to leave the reserved RAM free.
+    pub capped: bool,
+    /// Halved because the system is low on memory.
+    pub reduced: bool,
+}
+
+/// Colour of the `k`-th mask of a layer: Appearance ▸ Cycle Mask Colors cycles through the mask
+/// colours, otherwise every new mask takes the first one.
+pub fn mask_color(cycle: bool, k: usize) -> [u8; 3] {
+    use effectcraft_project::build::MASK_COLORS;
+    if cycle { MASK_COLORS[k % MASK_COLORS.len()] } else { MASK_COLORS[0] }
+}
+
+fn label_index(l: Label) -> Option<usize> {
+    Label::ALL.iter().position(|x| *x == l).and_then(|i| i.checked_sub(1))
+}
diff --git a/crates/engine/src/settings/prefs/recent.rs b/crates/engine/src/settings/prefs/recent.rs
new file mode 100644
index 000000000..2b12499f4
--- /dev/null
+++ b/crates/engine/src/settings/prefs/recent.rs
@@ -0,0 +1,87 @@
+use serde::{Deserialize, Serialize};
+
+use super::Prefs;
+
+impl Prefs {
+    /// Remember a project in File ▸ Open Recent.
+    pub fn push_recent(&mut self, path: &str) {
+        self.recent_projects.retain(|p| p != path);
+        self.recent_projects.insert(0, path.to_string());
+        self.recent_projects.truncate(self.general.recent_items as usize);
+    }
+
+    /// Remember a font in the Character panel's recent fonts (Type ▸ Number of Recent Fonts).
+    pub fn push_recent_font(&mut self, family: &str) {
+        push_mru(&mut self.recent_fonts, family, 30);
+    }
+
+    /// Is effect `id` starred in Effects & Presets?
+    pub fn is_effect_favorite(&self, id: &str) -> bool {
+        self.effects_favorites.iter().any(|f| f == id)
+    }
+
+    /// Star effect `id` in Effects & Presets, or un-star it; true when it is starred now.
+    pub fn toggle_effect_favorite(&mut self, id: &str) -> bool {
+        if self.is_effect_favorite(id) {
+            self.effects_favorites.retain(|f| f != id);
+            false
+        } else {
+            self.effects_favorites.push(id.to_string());
+            self.effects_favorites.truncate(MAX_EFFECTS_FAVORITES);
+            self.is_effect_favorite(id)
+        }
+    }
+
+    /// The recent fonts the Character panel shows (at most Number of Recent Fonts to Display).
+    pub fn recent_fonts_shown(&self) -> &[String] {
+        let n = (self.type_.recent_fonts as usize).min(self.recent_fonts.len());
+        &self.recent_fonts[..n]
+    }
+
+    /// Remember imported footage for File ▸ Import Recent Footage.
+    pub fn push_recent_footage(&mut self, path: &str) {
+        push_mru(&mut self.recent_footage, path, self.general.recent_items as usize);
+    }
+
+    /// Remember an applied animation preset for Animation ▸ Recent Animation Presets.
+    pub fn push_recent_preset(&mut self, path: &str) {
+        push_mru(&mut self.recent_presets, path, self.general.recent_items as usize);
+    }
+
+    /// Remember a script that ran for File ▸ Scripts ▸ Recent Script Files.
+    pub fn push_recent_script(&mut self, script: RecentScript) {
+        self.recent_scripts.retain(|x| *x != script);
+        self.recent_scripts.insert(0, script);
+        self.recent_scripts.truncate(MAX_RECENT_SCRIPTS);
+    }
+}
+
+/// Most scripts File ▸ Scripts ▸ Recent Script Files lists.
+pub const MAX_RECENT_SCRIPTS: usize = 10;
+
+/// A File ▸ Scripts ▸ Recent Script Files entry, stored as the `file.runScript` parameter that
+/// ran it: `{"path": …}` for a script file, `{"name": …}` for an installed or bundled script.
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum RecentScript {
+    Path(String),
+    Name(String),
+}
+
+impl RecentScript {
+    /// The file's path or the script's name.
+    pub fn text(&self) -> &str {
+        match self {
+            RecentScript::Path(s) | RecentScript::Name(s) => s,
+        }
+    }
+}
+
+/// Most effects Effects & Presets keeps starred (a hand-edited settings file can hold more).
+pub(super) const MAX_EFFECTS_FAVORITES: usize = 1000;
+
+fn push_mru(list: &mut Vec<String>, v: &str, max: usize) {
+    list.retain(|x| x != v);
+    list.insert(0, v.to_string());
+    list.truncate(max.max(1));
+}
diff --git a/crates/engine/src/settings/prefs/sections.rs b/crates/engine/src/settings/prefs/sections.rs
new file mode 100644
index 000000000..ac2fab1cc
--- /dev/null
+++ b/crates/engine/src/settings/prefs/sections.rs
@@ -0,0 +1,359 @@
+use super::choices::theme_family;
+use super::{BTreeMap, Deserialize, Label, Serialize, Value};
+
+/// Unknown keys inside a page, kept so a newer version's settings survive a round trip.
+pub(super) type Extra = BTreeMap<String, Value>;
+
+macro_rules! page {
+    ($(#[$m:meta])* $name:ident { $($(#[$fm:meta])* $f:ident : $t:ty = $d:expr),* $(,)? }) => {
+        $(#[$m])*
+        #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+        #[serde(default, rename_all = "camelCase")]
+        pub struct $name {
+            $($(#[$fm])* pub $f: $t,)*
+            #[serde(flatten)]
+            pub extra: Extra,
+        }
+        impl Default for $name {
+            fn default() -> Self {
+                $name { $($f: $d,)* extra: Extra::new() }
+            }
+        }
+    };
+}
+
+page!(General {
+    /// Interface language: `system` (the operating system's, where EffectCraft has it, else
+    /// English), or a language code from `LANGUAGES`.
+    language: String = "system".into(),
+    /// Levels of Undo (1–99).
+    undo_levels: u32 = 32,
+    /// Path Point and Handle Size (px).
+    path_point_size: u32 = 5,
+    show_tool_tips: bool = true,
+    /// Step frames with an unmodified mouse wheel over the Composition viewer.
+    /// Off: the wheel zooms, which is what current After Effects does.
+    viewer_wheel_scrubbing: bool = false,
+    /// Create New Layers at Composition Start Time (off: at the current time).
+    create_layers_at_comp_start: bool = true,
+    switches_affect_nested_comps: bool = true,
+    /// Default Spatial Interpolation to Linear.
+    default_spatial_linear: bool = false,
+    preserve_constant_vertex_count: bool = true,
+    /// Synchronize Time of All Related Items.
+    sync_time_related_items: bool = true,
+    expression_pick_whip_compact: bool = true,
+    /// Create Split Layers Above Original Layer (After Effects' default).
+    create_split_layers_above: bool = true,
+    use_system_color_picker: bool = false,
+    /// Number of projects in File ▸ Open Recent.
+    recent_items: u32 = 10,
+});
+
+page!(Startup {
+    show_home_on_launch: bool = true,
+    show_home_on_open_project: bool = false,
+    /// After a crash, offer to open the most recent auto-save.
+    offer_crash_recovery: bool = true,
+    /// What the desktop window draws with, from the next launch: `auto` (the platform's best
+    /// graphics API) or `gl` (OpenGL, for drivers that crash with the others). A launch that
+    /// stops as its window opens switches it to `gl` (#243).
+    window_graphics: String = "auto".into(),
+});
+
+page!(ProjectPrefs {
+    /// Open a template project for File ▸ New ▸ New Project.
+    use_template: bool = false,
+    template_path: String = String::new(),
+    /// Write `.ecproj` files as compact JSON on one line (smaller, faster to save and open). Off:
+    /// indented, one value per line, so they read and diff cleanly in version control.
+    compact_project_files: bool = false,
+});
+
+page!(AutoSave {
+    enabled: bool = true,
+    interval_minutes: u32 = 20,
+    max_versions: u32 = 5,
+    /// `nextToProject` (an "EffectCraft Auto-Save" folder beside the project) or `custom`.
+    location: String = "nextToProject".into(),
+    folder: String = String::new(),
+    save_on_render_start: bool = false,
+});
+
+page!(CompositionPrefs {
+    /// Motion path: `all`, `none`, `seconds`, `keyframes`.
+    motion_path: String = "keyframes".into(),
+    motion_path_seconds: f64 = 15.0,
+    motion_path_keyframes: u32 = 15,
+    show_rendering_progress: bool = true,
+    hardware_accelerate_panels: bool = true,
+});
+
+page!(Previews {
+    /// Largest downsampling while playing back: `1/2`, `1/4`, `1/8`.
+    adaptive_resolution_limit: String = "1/8".into(),
+    show_internal_wireframes: bool = false,
+    cache_frames_when_idle: bool = false,
+    fast_previews: bool = false,
+    /// `faster` or `moreAccurate`.
+    zoom_quality: String = "moreAccurate".into(),
+    show_gpu_info: bool = false,
+    /// The monitor's colour space for View ▸ Use Display Color Management: `srgb` or `p3`.
+    display_profile: String = "srgb".into(),
+});
+
+page!(Appearance {
+    /// The single theme before appearance modes (`dark`, `darker` or `light`), kept for older
+    /// settings files and automation: setting it picks its family's mode and theme. While the mode
+    /// is Dark or Light it mirrors the theme in use.
+    theme: String = "dark".into(),
+    /// `auto` (follow the operating system), `dark` or `light`. New installs stay Dark.
+    appearance_mode: String = "dark".into(),
+    /// The theme used in dark appearance: `dark` or `darker`.
+    dark_theme: String = "dark".into(),
+    /// The theme used in light appearance: `light`.
+    light_theme: String = "light".into(),
+    /// Theme shortcuts in the appearance context menu.
+    favorite_themes: Vec<String> = Vec::new(),
+    /// User interface brightness, -1 (darker) … 1 (lighter).
+    brightness: f64 = 0.0,
+    /// The size of the whole interface in percent (75–200), on top of the display's own scale.
+    ui_scale: u32 = 100,
+    use_label_color_for_handles: bool = true,
+    use_label_color_for_tabs: bool = true,
+    cycle_mask_colors: bool = true,
+    use_gradients: bool = true,
+    /// macOS: draw the menu bar inside the window instead of the system menu bar.
+    in_window_menu_bar_mac: bool = false,
+});
+
+page!(Grids {
+    grid_color: String = "#7a9cff".into(),
+    grid_spacing: f64 = 100.0,
+    grid_subdivisions: u32 = 4,
+    /// `lines`, `dashed` or `dots`.
+    grid_style: String = "lines".into(),
+    proportional_horizontal: u32 = 4,
+    proportional_vertical: u32 = 4,
+    guide_color: String = "#3cc8f0".into(),
+    guide_style: String = "lines".into(),
+    action_safe: f64 = 10.0,
+    title_safe: f64 = 20.0,
+});
+
+page!(TypePrefs {
+    /// `latin` or `southAsian` (South Asian and Middle Eastern).
+    text_engine: String = "latin".into(),
+    font_preview: bool = true,
+    recent_fonts: u32 = 10,
+    font_names_in_english: bool = false,
+});
+
+page!(Import {
+    /// Still footage duration: `compLength` or `seconds`.
+    still_footage: String = "compLength".into(),
+    still_seconds: f64 = 5.0,
+    sequence_fps: f64 = 30.0,
+    report_missing_frames: bool = true,
+    /// Automatically Reload Footage whose file another app changed (size or modification time),
+    /// checked every two seconds while the window is in front, every ten seconds while it is
+    /// not, and when it comes back to the front: `off`,
+    /// `nonSequence` (the default, as in After Effects: image sequences are left alone) or `all`.
+    auto_reload_footage: String = "nonSequence".into(),
+    /// Interpret unlabeled alpha as: `ask`, `guess`, `ignore`, `straight`, `premultiplied`.
+    unlabeled_alpha: String = "ask".into(),
+    /// Default drag import as: `footage`, `comp`, `compLayerSizes`.
+    drag_import_as: String = "footage".into(),
+});
+
+page!(Export {
+    default_output_folder: String = String::new(),
+    segment_sequences: bool = false,
+    segment_sequence_files: u32 = 700,
+    segment_movies: bool = false,
+    segment_movie_mb: u32 = 1024,
+    append_bits_to_name: bool = false,
+});
+
+page!(Audio {
+    /// Output device name (empty = the system default).
+    output_device: String = String::new(),
+    /// Output mapping: device channel for the left / right output (1-based).
+    output_left: u32 = 1,
+    output_right: u32 = 2,
+    preview_sample_rate: u32 = 48_000,
+});
+
+page!(Disk {
+    disk_cache_enabled: bool = true,
+    disk_cache_max_gb: u32 = 20,
+    disk_cache_folder: String = String::new(),
+    media_cache_folder: String = String::new(),
+    conformed_media_folder: String = String::new(),
+});
+
+page!(Memory {
+    ram_reserved_gb: u32 = 6,
+    /// Processed-layer cache budget (MB).
+    layer_cache_mb: u32 = 1024,
+    /// Decoded footage frame cache budget (MB).
+    media_cache_mb: u32 = 1024,
+    /// RAM preview (viewer frame) cache budget (MB).
+    preview_cache_mb: u32 = 3072,
+    reduce_cache_when_low: bool = true,
+});
+
+page!(Video {
+    enable_output: bool = false,
+    device: String = String::new(),
+    output_during_playback: bool = true,
+    mirror_on_monitor: bool = true,
+    disable_when_background: bool = false,
+});
+
+page!(ThreeD {
+    /// Default 3D renderer for new compositions: `classic` or `advanced`.
+    default_renderer: String = "classic".into(),
+    show_reference_axes: bool = true,
+    extended_viewer: bool = false,
+    realtime_shadows: bool = true,
+});
+
+page!(
+    /// Settings ▸ Roto Brush.
+    RotoPrefs {
+        /// The segmentation model Roto Brush 2.0 / 3.0 use: `classical` (built in) or a model id
+        /// from `effectcraft_segment::MODELS` (once installed).
+        model: String = "classical".into(),
+    }
+);
+
+page!(
+    /// Settings ▸ Face Tracking.
+    FacePrefs {
+        /// The model Track Mask ▸ Face Tracking uses: `classical` (built in) or a model id from
+        /// `effectcraft_segment::MODELS` (once installed).
+        model: String = "classical".into(),
+    }
+);
+
+page!(Scripting {
+    allow_scripts_write_files: bool = false,
+    warn_executing_files: bool = true,
+    enable_js_debugger: bool = false,
+    editor_font_size: u32 = 13,
+    syntax_highlighting: bool = true,
+    line_numbers: bool = true,
+    auto_complete: bool = true,
+    bracket_matching: bool = true,
+    word_wrap: bool = false,
+    error_banner: bool = true,
+});
+
+impl Scripting {
+    /// Whether `other` grants scripts the same as this: Application Scripting (file and network
+    /// access, the warning before executing files, the debugger). Scripts can't change these
+    /// ([`crate::Session::execute_for_script`]): a script could otherwise give itself the
+    /// access the user withheld.
+    pub fn same_permissions(&self, other: &Scripting) -> bool {
+        self.allow_scripts_write_files == other.allow_scripts_write_files
+            && self.warn_executing_files == other.warn_executing_files
+            && self.enable_js_debugger == other.enable_js_debugger
+    }
+
+    /// Take `from`'s Application Scripting settings (see [`Scripting::same_permissions`]).
+    pub fn keep_permissions(&mut self, from: &Scripting) {
+        self.allow_scripts_write_files = from.allow_scripts_write_files;
+        self.warn_executing_files = from.warn_executing_files;
+        self.enable_js_debugger = from.enable_js_debugger;
+    }
+}
+
+/// One editable label: name and `#rrggbb` colour.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LabelPref {
+    pub name: String,
+    pub color: String,
+}
+
+/// A Composition Settings preset the user saved (Composition Settings ▸ Preset ▸ Save): the
+/// frame size, pixel aspect and frame rate, as in After Effects' own presets.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CompPreset {
+    pub name: String,
+    pub width: u32,
+    pub height: u32,
+    pub pixel_aspect: f64,
+    pub frame_rate: f64,
+}
+
+impl CompPreset {
+    /// Longest preset name kept.
+    pub const MAX_NAME: usize = 128;
+
+    /// Values a composition accepts (a hand-edited settings file can hold anything).
+    pub fn is_valid(&self) -> bool {
+        let size = 4..=30000;
+        !self.name.trim().is_empty()
+            && self.name.chars().count() <= Self::MAX_NAME
+            && size.contains(&self.width)
+            && size.contains(&self.height)
+            && self.pixel_aspect.is_finite()
+            && (0.01..=100.0).contains(&self.pixel_aspect)
+            && self.frame_rate.is_finite()
+            && (1.0..=999.0).contains(&self.frame_rate)
+    }
+}
+
+/// Saved composition presets, skipping entries that don't parse instead of losing the list.
+pub(super) fn lenient_comp_presets<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<CompPreset>, D::Error> {
+    let v = Vec::<Value>::deserialize(d)?;
+    Ok(v.into_iter().filter_map(|x| serde_json::from_value(x).ok()).collect())
+}
+
+pub(super) fn default_labels() -> Vec<LabelPref> {
+    Label::ALL.iter().skip(1).map(|l| LabelPref { name: l.name().to_string(), color: hex(l.rgb()) }).collect()
+}
+
+fn hex([r, g, b]: [u8; 3]) -> String {
+    format!("#{r:02x}{g:02x}{b:02x}")
+}
+
+pub(super) fn parse_hex(s: &str) -> Option<[u8; 3]> {
+    let h = s.trim().trim_start_matches('#');
+    if h.len() != 6 {
+        return None;
+    }
+    let p = |i: usize| u8::from_str_radix(h.get(i..i + 2)?, 16).ok();
+    Some([p(0)?, p(2)?, p(4)?])
+}
+
+impl Appearance {
+    /// Show the legacy single `theme`: fix the mode to its family and remember it as that
+    /// family's theme. An unknown theme changes nothing.
+    pub fn select_theme(&mut self) {
+        match theme_family(&self.theme) {
+            Some((mode, "darkTheme")) => {
+                self.appearance_mode = mode.into();
+                self.dark_theme = self.theme.clone();
+            }
+            Some((mode, _)) => {
+                self.appearance_mode = mode.into();
+                self.light_theme = self.theme.clone();
+            }
+            None => {}
+        }
+    }
+
+    /// The theme to show: the light or dark family's choice by the mode; Auto follows `system_light`
+    /// (`None` = the system said nothing: dark).
+    pub fn resolved_theme(&self, system_light: Option<bool>) -> &str {
+        let light = match self.appearance_mode.as_str() {
+            "light" => true,
+            "auto" => system_light == Some(true),
+            _ => false,
+        };
+        if light { &self.light_theme } else { &self.dark_theme }
+    }
+}
diff --git a/crates/engine/src/session_settings.rs b/crates/engine/src/settings/session_settings.rs
similarity index 89%
rename from crates/engine/src/session_settings.rs
rename to crates/engine/src/settings/session_settings.rs
index a56d1849b..4fe47e0ef 100644
--- a/crates/engine/src/session_settings.rs
+++ b/crates/engine/src/settings/session_settings.rs
@@ -82,7 +82,9 @@ impl Session {
     /// Take the latest reading of the system's memory and start the next one in the background
     /// (desktop frontends call this every few seconds; it never waits for the system), then
     /// re-apply the cache budgets when the reading changes them. Returns the effective budgets.
+    /// The disk cache's free disk space is read the same way (it keeps a reserve free).
     pub fn memory_tick(&mut self) -> crate::prefs::CacheBudgets {
+        self.poll_disk_space();
         let before = self.prefs.cache_budgets(self.sys_memory);
         self.sys_memory = self.memory_watch.latest().or(self.sys_memory);
         self.memory_watch.poll();
@@ -98,6 +100,19 @@ impl Session {
         after
     }
 
+    /// Read the disk cache's free disk space in the background and apply it there (the reserve
+    /// it keeps free): the free space and the cache's size are taken at the same moment, and the
+    /// reader holds its own cache, so a reading never reaches another folder's.
+    fn poll_disk_space(&mut self) {
+        if let Some(dc) = &self.disk_cache {
+            let dc = dc.clone();
+            self.disk_watch.poll_with("ec-disk-space", move || {
+                dc.set_disk_space(crate::sysinfo::disk_space(dc.folder()));
+                Some(())
+            });
+        }
+    }
+
     /// Apply Settings ▸ Media & Disk Cache ▸ Disk Cache: open (or close) the persistent cache
     /// and attach it to the layer cache. Without a folder setting the platform cache folder is
     /// used, but only by frontends with a settings store (headless sessions stay off disk).
@@ -113,6 +128,7 @@ impl Session {
         // (no file system in the browser: the disk cache stays off there)
         let Some(folder) = folder.filter(|_| d.disk_cache_enabled && !cfg!(target_arch = "wasm32")) else {
             self.disk_cache = None;
+            self.disk_watch = Default::default();
             self.layer_cache.set_disk(None);
             return;
         };
@@ -120,23 +136,31 @@ impl Session {
         // opens a disk cache (often the platform folder, through a settings store) would take
         // over the store of a roto test running beside it. Serialise them with the roto tests.
         #[cfg(test)]
-        crate::tests_roto::hold_roto_cache_test_lock();
+        crate::tests::roto::hold_roto_cache_test_lock();
         let dc = match &self.disk_cache {
             Some(c) if c.folder() == folder.as_path() => {
                 c.set_max_bytes(max);
                 c.clone()
             }
+            // A new folder: the free-space reading was for the old one (a reader still running
+            // holds the old watcher's state, so it can't write into the new one).
             _ => match DiskCache::open(&folder, max) {
-                Ok(c) => c,
+                Ok(c) => {
+                    self.disk_watch = Default::default();
+                    c
+                }
                 Err(e) => {
                     log::warn!("disk cache at {}: {e}", folder.display());
                     self.disk_cache = None;
+                    self.disk_watch = Default::default();
                     self.layer_cache.set_disk(None);
                     return;
                 }
             },
         };
         self.disk_cache = Some(dc.clone());
+        // The reserve applies from the start (a new folder's watcher is idle).
+        self.poll_disk_space();
         let salt = self.refresh_disk_salt(true).unwrap_or_default();
         self.layer_cache.set_disk(Some((dc.clone(), salt)));
         // Roto Brush / Object Matte segmentations persist there too (held weakly: switching the
@@ -171,9 +195,19 @@ impl Session {
         self.shortcut_table = std::sync::OnceLock::new();
     }
 
-    /// The active shortcut preset resolved against every bindable command.
+    /// The scripts in the Scripts folder changed: list File ▸ Scripts' entries again in the
+    /// shortcut table.
+    pub fn scripts_changed(&mut self) {
+        self.shortcut_table = std::sync::OnceLock::new();
+    }
+
+    /// The active shortcut preset resolved against every bindable command, File ▸ Scripts'
+    /// entries included.
     pub fn shortcuts(&self) -> &ShortcutTable {
-        self.shortcut_table.get_or_init(|| ShortcutTable::build(&self.keymaps, &self.ui_commands))
+        self.shortcut_table.get_or_init(|| {
+            let scripts: Vec<String> = crate::commands::scripts::scripts(self).into_iter().filter(|e| !e.panel).map(|e| e.name).collect();
+            ShortcutTable::build_with_scripts(&self.keymaps, &self.ui_commands, &scripts)
+        })
     }
 
     /// Remember a project in File ▸ Open Recent and in the crash-recovery sentinel.
diff --git a/crates/engine/src/shortcuts.rs b/crates/engine/src/settings/shortcuts.rs
similarity index 67%
rename from crates/engine/src/shortcuts.rs
rename to crates/engine/src/settings/shortcuts.rs
index 3d4ab3661..44e2261a2 100644
--- a/crates/engine/src/shortcuts.rs
+++ b/crates/engine/src/settings/shortcuts.rs
@@ -1,6 +1,7 @@
 //! Keyboard shortcut presets (Edit ▸ Keyboard Shortcuts).
 //!
-//! Every menu entry, registry command and frontend command is *bindable*: it has a binding key
+//! Every menu entry, registry command and frontend command, and every script File ▸ Scripts
+//! lists, is *bindable*: it has a binding key
 //! (the command id, plus its bound parameters for entries such as `app.settings
 //! {"page":"general"}`), a scope (application-wide or a panel) and default keys. The built-in
 //! preset "EffectCraft Default" is After Effects' default keyboard layout and is read-only; custom
@@ -8,6 +9,11 @@
 //! (as After Effects asks you to "Save As" a custom set). The shortcut dispatcher and the menus
 //! read the active preset through [`ShortcutTable`].
 //!
+//! Scopes, narrowest first: a *context* ([`CONTEXT_SCOPES`]: a state of the app such as editing
+//! text; its shortcuts work only while it is active), a *panel* (`Project`, `Timeline`,
+//! `RenderQueue`…: the panel with the keyboard) and the application. One chord can be bound once
+//! per scope; the narrowest active scope runs it ([`scope_rank`]).
+//!
 //! Shortcut text is `Ctrl+Cmd+Alt+Shift+Key` (`Cmd` is ⌘ on macOS and Ctrl elsewhere).
 
 use std::collections::{BTreeMap, HashMap};
@@ -28,6 +34,97 @@ pub struct UiCommand {
     pub id: String,
     pub label: String,
     pub shortcut: Option<String>,
+    /// Its scope; none: from its id (`timeline.*` → Timeline, `view.*` → Composition).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub scope: Option<String>,
+}
+
+/// Scopes that are a state of the app rather than a panel: editing text in the viewer, a paint
+/// tool active, a mask selected, a camera tool active.
+pub const CONTEXT_SCOPES: &[&str] = &["TextEditing", "Paint", "Mask", "Camera"];
+
+/// Engine commands and menu entries whose shortcuts belong to one panel or context (binding key
+/// → scope). Every other one is application-wide; frontend commands state their own.
+const SCOPES: &[(&str, &str)] = &[
+    ("file.rememberInterpretation", "Project"),
+    ("file.applyInterpretation", "Project"),
+    ("project.deleteWithoutConfirmation", "Project"),
+    ("renderQueue.duplicate", "RenderQueue"),
+];
+
+/// Scope of an engine command or menu entry from its binding key.
+pub fn scope_of(key: &str) -> &'static str {
+    SCOPES.iter().find(|(k, _)| *k == key).map_or(APP_SCOPE, |(_, s)| s)
+}
+
+pub fn is_context(scope: &str) -> bool {
+    CONTEXT_SCOPES.contains(&scope)
+}
+
+/// The Timeline and the Composition panel show the same composition and share their shortcuts:
+/// the layer keys work with either one focused.
+pub fn panels_share(a: &str, b: &str) -> bool {
+    matches!((a, b), ("Timeline", "Composition") | ("Composition", "Timeline"))
+}
+
+/// A scope as shown to people (`RenderQueue` → `Render Queue`).
+pub fn scope_label(scope: &str) -> String {
+    let mut out = String::with_capacity(scope.len() + 2);
+    for (i, c) in scope.chars().enumerate() {
+        if i > 0 && c.is_uppercase() {
+            out.push(' ');
+        }
+        out.push(c);
+    }
+    out
+}
+
+/// How strongly a binding in `scope` claims a chord while the panel `focused` has the keyboard
+/// and `contexts` are active: lower wins, `None` doesn't run at all. An active context, then the
+/// focused panel, then the panel sharing its shortcuts, then the application. A shortcut of
+/// another panel still runs when nothing nearer claims the chord (the reveal keys work from the
+/// Effect Controls panel too); a context's shortcuts never run outside it. Two other panels (or
+/// two active contexts) can claim a chord at the same rank: [`pick`] runs neither.
+pub fn scope_rank(scope: &str, focused: &str, contexts: &[&str]) -> Option<u8> {
+    if is_context(scope) {
+        return contexts.contains(&scope).then_some(0);
+    }
+    Some(if scope == focused {
+        1
+    } else if panels_share(scope, focused) {
+        2
+    } else if scope == APP_SCOPE {
+        3
+    } else {
+        4
+    })
+}
+
+/// Which of the bindings matching one key press runs: `candidates` are (scope, physical,
+/// binding), in the dispatcher's order. The narrowest scope ([`scope_rank`]) wins; at the same
+/// rank an explicit physical-key binding wins, then the first one. `Err`: the best candidates
+/// belong to different scopes of the same rank (two other panels, or two active contexts), so
+/// none of them runs; it lists those scopes.
+pub fn pick<'a, T>(candidates: impl IntoIterator<Item = (&'a str, bool, T)>, focused: &str, contexts: &[&str]) -> Result<Option<T>, Vec<String>> {
+    let mut best: Option<((u8, bool), &str, T)> = None;
+    let mut tied: Vec<String> = vec![];
+    for (scope, physical, b) in candidates {
+        let Some(rank) = scope_rank(scope, focused, contexts) else { continue };
+        let at = (rank, !physical);
+        match &best {
+            Some((r, s, _)) if *r < at || (*r == at && *s == scope) => {}
+            Some((r, _, _)) if *r == at => {
+                if !tied.iter().any(|t| t == scope) {
+                    tied.push(scope.to_string());
+                }
+            }
+            _ => {
+                tied = vec![scope.to_string()];
+                best = Some((at, scope, b));
+            }
+        }
+    }
+    if tied.len() > 1 { Err(tied) } else { Ok(best.map(|(.., b)| b)) }
 }
 
 /// One thing a shortcut can run.
@@ -94,17 +191,32 @@ pub fn bindables(ui: &[UiCommand]) -> Vec<Bindable> {
             e.shortcut.as_deref().into_iter().chain(e.alt_shortcuts.iter().map(String::as_str)).chain(alt.iter().copied()).filter_map(normalize).collect();
         push(
             Bindable {
+                scope: scope_of(&key).into(),
                 key,
                 command: e.command.clone(),
                 params: e.params.clone(),
                 label: e.label.clone(),
                 path: path.clone(),
-                scope: APP_SCOPE.into(),
                 defaults,
             },
             &mut out,
         );
     }
+    // File ▸ Scripts ▸ Recent Script Files lists its scripts at run time; the first one, the most
+    // recent, has a key.
+    let recent = json!({"recent": 0});
+    push(
+        Bindable {
+            key: binding_key("file.runScript", &recent),
+            command: "file.runScript".into(),
+            params: recent,
+            label: "Run Most Recent Script File".into(),
+            path: vec!["File".into(), "Scripts".into(), "Recent Script Files".into()],
+            scope: APP_SCOPE.into(),
+            defaults: normalize("Cmd+Alt+Shift+D").into_iter().collect(),
+        },
+        &mut out,
+    );
     for c in crate::command_specs() {
         if !c.journal || entries.iter().any(|(_, e)| e.command == c.id) {
             continue;
@@ -117,22 +229,22 @@ pub fn bindables(ui: &[UiCommand]) -> Vec<Bindable> {
                 params: Value::Null,
                 label: c.label.to_string(),
                 path: vec!["Commands".into()],
-                scope: APP_SCOPE.into(),
+                scope: scope_of(c.id).into(),
                 defaults,
             },
             &mut out,
         );
     }
     for c in ui {
-        let scope = ui_scope(&c.id);
-        let cat = if scope == APP_SCOPE { "Tools & Panels" } else { scope };
+        let scope = c.scope.as_deref().unwrap_or_else(|| ui_scope(&c.id));
+        let cat = if scope == APP_SCOPE { "Tools & Panels".to_string() } else { scope_label(scope) };
         push(
             Bindable {
                 key: c.id.clone(),
                 command: c.id.clone(),
                 params: Value::Null,
                 label: c.label.clone(),
-                path: vec![cat.into()],
+                path: vec![cat],
                 scope: scope.into(),
                 defaults: c.shortcut.as_deref().and_then(normalize).into_iter().collect(),
             },
@@ -142,6 +254,27 @@ pub fn bindables(ui: &[UiCommand]) -> Vec<Bindable> {
     out
 }
 
+/// The File ▸ Scripts entries of the scripts `names` (file names, as the menu lists them), with
+/// no default keys. A key is bound to the script's name, so it stays with that script when
+/// scripts are added to or removed from the folder.
+pub fn script_bindables(names: &[String]) -> Vec<Bindable> {
+    names
+        .iter()
+        .map(|n| {
+            let params = json!({"name": n});
+            Bindable {
+                key: binding_key("file.runScript", &params),
+                command: "file.runScript".into(),
+                params,
+                label: n.clone(),
+                path: vec!["File".into(), "Scripts".into()],
+                scope: APP_SCOPE.into(),
+                defaults: vec![],
+            }
+        })
+        .collect()
+}
+
 /// Canonical shortcut text (`cmd+shift+k`, `Shift+Cmd+K`, `⌘⇧K` → `Cmd+Shift+K`); `None` if it
 /// has no key.
 pub fn normalize(s: &str) -> Option<String> {
@@ -253,10 +386,16 @@ pub struct Conflict {
     pub key: String,
     pub label: String,
     pub scope: String,
+    /// The two are in different scopes, so both keep working: the narrower one runs while its
+    /// panel or context is active and the other one everywhere else. `false`: the same scope,
+    /// where only one of them can run.
+    pub overrides: bool,
 }
 
+/// Whether shortcuts of these scopes can be active at once. Two different panels can't, except
+/// the pair sharing theirs; a context can be active in any panel.
 fn scopes_overlap(a: &str, b: &str) -> bool {
-    a == b || a == APP_SCOPE || b == APP_SCOPE
+    a == b || a == APP_SCOPE || b == APP_SCOPE || panels_share(a, b) || is_context(a) || is_context(b)
 }
 
 impl Keymaps {
@@ -421,7 +560,16 @@ pub struct ShortcutTable {
 
 impl ShortcutTable {
     pub fn build(maps: &Keymaps, ui: &[UiCommand]) -> ShortcutTable {
-        let bindables = bindables(ui);
+        Self::build_with_scripts(maps, ui, &[])
+    }
+
+    /// [`ShortcutTable::build`] with the File ▸ Scripts entries of the scripts `scripts`, listed
+    /// after the other File ▸ Scripts entries.
+    pub fn build_with_scripts(maps: &Keymaps, ui: &[UiCommand], scripts: &[String]) -> ShortcutTable {
+        let mut bindables = bindables(ui);
+        let at = bindables.iter().rposition(|b| b.path.starts_with(&["File".to_string(), "Scripts".to_string()])).map_or(bindables.len(), |i| i + 1);
+        let new: Vec<Bindable> = script_bindables(scripts).into_iter().filter(|s| !bindables.iter().any(|b| b.key == s.key)).collect();
+        bindables.splice(at..at, new);
         let keys = bindables.iter().map(|b| (b.key.clone(), maps.keys_of(b))).collect();
         ShortcutTable { bindables, keys }
     }
@@ -446,11 +594,19 @@ impl ShortcutTable {
         self.bindings()
             .into_iter()
             .filter(|(k, o)| *k == keys && o.key != b.key && scopes_overlap(&o.scope, &b.scope))
-            .map(|(k, o)| Conflict { keys: k.to_string(), key: o.key.clone(), label: o.label.clone(), scope: o.scope.clone() })
+            .map(|(k, o)| Conflict {
+                keys: k.to_string(),
+                key: o.key.clone(),
+                label: o.label.clone(),
+                scope: o.scope.clone(),
+                overrides: o.scope != b.scope && !(is_context(&o.scope) && is_context(&b.scope)),
+            })
             .collect()
     }
 
-    /// Every pair of commands sharing keys in an overlapping scope.
+    /// Every pair of commands sharing keys in the same scope, or in two contexts (which can be
+    /// active at once): only one of the two can run, or neither ([`pick`]). (Other pairs in
+    /// different scopes are intended, see [`Conflict::overrides`].)
     pub fn all_conflicts(&self) -> Vec<(String, Conflict)> {
         let mut by_keys: BTreeMap<&str, Vec<&Bindable>> = BTreeMap::new();
         for (k, b) in self.bindings() {
@@ -462,8 +618,11 @@ impl ShortcutTable {
         for (k, bs) in by_keys {
             for (i, a) in bs.iter().enumerate() {
                 for b in &bs[i + 1..] {
-                    if scopes_overlap(&a.scope, &b.scope) {
-                        out.push((a.key.clone(), Conflict { keys: k.to_string(), key: b.key.clone(), label: b.label.clone(), scope: b.scope.clone() }));
+                    if a.scope == b.scope || (is_context(&a.scope) && is_context(&b.scope)) {
+                        out.push((
+                            a.key.clone(),
+                            Conflict { keys: k.to_string(), key: b.key.clone(), label: b.label.clone(), scope: b.scope.clone(), overrides: false },
+                        ));
                     }
                 }
             }
diff --git a/crates/engine/src/system.rs b/crates/engine/src/system.rs
new file mode 100644
index 000000000..d292e1232
--- /dev/null
+++ b/crates/engine/src/system.rs
@@ -0,0 +1,5 @@
+pub mod guard;
+pub mod logging;
+pub mod perf;
+pub mod storage;
+pub mod sysinfo;
diff --git a/crates/engine/src/guard.rs b/crates/engine/src/system/guard.rs
similarity index 100%
rename from crates/engine/src/guard.rs
rename to crates/engine/src/system/guard.rs
diff --git a/crates/engine/src/logging.rs b/crates/engine/src/system/logging.rs
similarity index 91%
rename from crates/engine/src/logging.rs
rename to crates/engine/src/system/logging.rs
index ec5785f7e..857a3e90d 100644
--- a/crates/engine/src/logging.rs
+++ b/crates/engine/src/system/logging.rs
@@ -5,15 +5,15 @@
 //! terminal, so that file is what a bug report can attach. The last few hundred warnings and
 //! errors are also kept in memory for the System Compatibility Report.
 //!
-//! Levels: `info` for EffectCraft's own crates, `warn` for everything else (wgpu and naga are
-//! chatty). `RUST_LOG` replaces that (a level such as `debug`, or per target:
+//! Levels by default ([`DEFAULT_FILTER`]): `info` for EffectCraft's own crates, `warn` for
+//! everything else (wgpu and naga are chatty). `RUST_LOG` replaces that (a level such as `debug`, or per target:
 //! `effectcraft=debug,wgpu=warn`).
 //!
 //! Help ▸ Enable Logging ([`set_enabled`], the `help.enableLogging` command) additionally appends
 //! every EffectCraft record to `Logs/EffectCraft Log.txt`, across launches.
 //!
-//! Frontends call [`install`] once at startup and the desktop app [`attach_session_log`] once the
-//! settings folder is known; records logged before that are kept (up to [`MAX_PENDING`]) and
+//! Frontends call [`install`] (or [`install_with`] for another default, as the CLI does with `warn`)
+//! once at startup and the desktop app [`attach_session_log`] once the settings folder is known; records logged before that are kept (up to [`MAX_PENDING`]) and
 //! written first. Writing never panics: a file that can't be created or written leaves standard
 //! error as the only sink. Never log the control-channel token.
 
@@ -131,11 +131,21 @@ fn format_line(ts: &str, level: log::Level, thread: &str, target: &str, message:
 
 /// Install the logger (once; later calls and other installed loggers are left alone).
 pub fn install() {
+    install_with(DEFAULT_FILTER);
+}
+
+/// The directive string: `RUST_LOG` when it is set and nonblank, otherwise `default`.
+fn filter_spec<'a>(rust_log: Option<&'a str>, default: &'a str) -> &'a str {
+    rust_log.filter(|s| !s.trim().is_empty()).unwrap_or(default)
+}
+
+/// [`install`] with `default` as the filter when `RUST_LOG` is unset or empty.
+pub fn install_with(default: &str) {
     static LOGGER: Logger = Logger;
     if log::set_logger(&LOGGER).is_ok() {
         let filter = FILTER.get_or_init(|| {
-            let spec = std::env::var("RUST_LOG").ok().filter(|s| !s.trim().is_empty());
-            parse_filter(spec.as_deref().unwrap_or(DEFAULT_FILTER))
+            let spec = std::env::var("RUST_LOG").ok();
+            parse_filter(filter_spec(spec.as_deref(), default))
         });
         log::set_max_level(filter.iter().map(|d| d.1).fold(LevelFilter::Info, Ord::max));
     }
@@ -357,6 +367,21 @@ mod tests {
         assert_eq!(level_for(&f, "naga"), LevelFilter::Warn);
     }
 
+    /// The CLI's default (`warn`): warnings from every crate, no info chatter on stderr,
+    /// while a nonblank `RUST_LOG` overrides `default`.
+    #[test]
+    fn the_cli_filter_shows_only_warnings() {
+        assert_eq!(filter_spec(None, "warn"), "warn");
+        assert_eq!(filter_spec(Some("  "), "warn"), "warn");
+        assert_eq!(filter_spec(Some("info"), "warn"), "info");
+        let f = parse_filter(filter_spec(None, "warn"));
+        assert_eq!(level_for(&f, "effectcraft_gpu::context"), LevelFilter::Warn);
+        assert_eq!(level_for(&f, "effectcraft_engine::render_queue"), LevelFilter::Warn);
+        assert_eq!(level_for(&f, "wgpu_core::device"), LevelFilter::Warn);
+        let over = parse_filter(filter_spec(Some("info"), "warn"));
+        assert_eq!(level_for(&over, "effectcraft_gpu::context"), LevelFilter::Info);
+    }
+
     #[test]
     fn timestamps_are_utc_with_milliseconds() {
         assert_eq!(timestamp(0), "1970-01-01T00:00:00.000Z");
diff --git a/crates/engine/src/perf.rs b/crates/engine/src/system/perf.rs
similarity index 99%
rename from crates/engine/src/perf.rs
rename to crates/engine/src/system/perf.rs
index ab1723d9f..929726c95 100644
--- a/crates/engine/src/perf.rs
+++ b/crates/engine/src/system/perf.rs
@@ -180,7 +180,7 @@ pub fn large_project(spec: &LargeSpec) -> Project {
             *n += 1;
             layers.push(l);
         }
-        comp.layers = layers;
+        comp.layers = layers.into();
     };
     let others = spec.comps.saturating_sub(1);
     let depth = spec.nest_depth.min(others);
@@ -215,7 +215,7 @@ pub fn large_project(spec: &LargeSpec) -> Project {
         n += 1;
         layers.push(l);
     }
-    main.layers = layers;
+    main.layers = layers.into();
     p.add_item("Main", crate::color::Label::None, None, ItemKind::Comp(Arc::new(main)));
     // `Main` must be the first comp `replace_project` opens: give it the smallest id.
     let main_id = p.items.values().find(|i| i.name == "Main").map(|i| i.id).expect("main");
diff --git a/crates/engine/src/storage.rs b/crates/engine/src/system/storage.rs
similarity index 100%
rename from crates/engine/src/storage.rs
rename to crates/engine/src/system/storage.rs
diff --git a/crates/engine/src/sysinfo.rs b/crates/engine/src/system/sysinfo.rs
similarity index 60%
rename from crates/engine/src/sysinfo.rs
rename to crates/engine/src/system/sysinfo.rs
index de39974da..bfb471e92 100644
--- a/crates/engine/src/sysinfo.rs
+++ b/crates/engine/src/system/sysinfo.rs
@@ -1,11 +1,12 @@
 //! Host information for Settings ▸ Memory & CPU (RAM reserved for other applications, reducing
-//! caches when the system is low on memory) and Help ▸ System Compatibility Report.
+//! caches when the system is low on memory), the disk cache's free-space reserve and Help ▸
+//! System Compatibility Report.
 //!
 //! Pure Rust and dependency-free: the values come from the operating system's own reporting
-//! (`/proc/meminfo` on Linux, `sysctl`/`vm_stat` on macOS, `wmic`/PowerShell on Windows). Every
-//! query may fail (sandboxes, the web): callers treat `None` as "unknown" and keep their
-//! configured budgets. The periodic reading behind the cache budgets runs on a background
-//! thread ([`MemoryWatch`]): on Windows it starts PowerShell, which takes about a second.
+//! (`/proc/meminfo` on Linux, `sysctl`/`vm_stat` on macOS, `df` on Unix, `wmic`/PowerShell on
+//! Windows). Every query may fail (sandboxes, the web): callers treat `None` as "unknown" and
+//! keep their configured budgets. The periodic readings behind the cache budgets run on a
+//! background thread ([`Watch`]): on Windows they start PowerShell, which takes about a second.
 
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, PoisonError};
@@ -27,47 +28,74 @@ impl SysMemory {
     }
 }
 
-/// The system's memory, read in the background: [`MemoryWatch::poll`] starts a reading (unless
-/// one is running) and [`MemoryWatch::latest`] returns the last one without waiting.
-#[derive(Clone, Default)]
-pub struct MemoryWatch {
-    latest: Arc<Mutex<Option<SysMemory>>>,
+/// A system value read in the background: [`Watch::poll_with`] starts a reading (unless one is
+/// running) and [`Watch::latest`] returns the last one without waiting.
+#[derive(Clone)]
+pub struct Watch<T> {
+    latest: Arc<Mutex<Option<T>>>,
     busy: Arc<AtomicBool>,
 }
 
-impl MemoryWatch {
-    /// Start a new reading in the background (no threads on the web: read inline, it is
-    /// unknown there anyway).
-    pub fn poll(&self) {
+impl<T> Default for Watch<T> {
+    fn default() -> Self {
+        Watch { latest: Arc::new(Mutex::new(None)), busy: Arc::new(AtomicBool::new(false)) }
+    }
+}
+
+/// The system's memory ([`memory`]).
+pub type MemoryWatch = Watch<SysMemory>;
+/// The disk cache's free-space reading ([`disk_space`]): the reader applies it to its cache
+/// itself, so only the busy guard is used.
+pub type DiskWatch = Watch<()>;
+
+impl<T: Copy + Send + 'static> Watch<T> {
+    /// Start a new reading in the background on a thread called `name` (no threads on the web:
+    /// read inline, it is unknown there anyway).
+    pub fn poll_with(&self, name: &str, read: impl FnOnce() -> Option<T> + Send + 'static) {
         if self.busy.swap(true, Ordering::AcqRel) {
             return;
         }
         let (latest, busy) = (self.latest.clone(), self.busy.clone());
         let read = move || {
-            if let Some(m) = memory() {
-                *latest.lock().unwrap_or_else(PoisonError::into_inner) = Some(m);
-            }
+            // A failed reading clears the last one: a stale value is worse than none.
+            *latest.lock().unwrap_or_else(PoisonError::into_inner) = read();
             busy.store(false, Ordering::Release);
         };
         #[cfg(not(target_arch = "wasm32"))]
-        if std::thread::Builder::new().name("ec-memory".into()).spawn(read).is_err() {
+        if std::thread::Builder::new().name(name.into()).spawn(read).is_err() {
             self.busy.store(false, Ordering::Release);
         }
         #[cfg(target_arch = "wasm32")]
-        read();
+        {
+            let _ = name;
+            read();
+        }
     }
 
-    /// The last reading (`None` until one finished).
-    pub fn latest(&self) -> Option<SysMemory> {
+    /// The last reading (`None` until one finished or when the last one failed).
+    pub fn latest(&self) -> Option<T> {
         *self.latest.lock().unwrap_or_else(PoisonError::into_inner)
     }
 }
 
+impl MemoryWatch {
+    /// Start a new reading of the system's memory in the background.
+    pub fn poll(&self) {
+        self.poll_with("ec-memory", memory);
+    }
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(dead_code)]
 fn run(cmd: &str, args: &[&str]) -> Option<String> {
+    run_env(cmd, args, &[])
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[allow(dead_code)]
+fn run_env(cmd: &str, args: &[&str], env: &[(&str, &std::ffi::OsStr)]) -> Option<String> {
     let mut c = std::process::Command::new(cmd);
-    c.args(args);
+    c.args(args).envs(env.iter().copied());
     // A console program started from the windowed app would flash a console window.
     #[cfg(target_os = "windows")]
     std::os::windows::process::CommandExt::creation_flags(&mut c, 0x0800_0000); // CREATE_NO_WINDOW
@@ -139,6 +167,46 @@ pub fn memory() -> Option<SysMemory> {
     None
 }
 
+/// Parse `df -Pk` output: the disk's total and available bytes.
+pub fn parse_df(text: &str) -> Option<(u64, u64)> {
+    let line = text.lines().skip(1).find(|l| !l.trim().is_empty())?;
+    let f: Vec<&str> = line.split_whitespace().collect();
+    // A full disk into its root-reserved blocks reports negative numbers (Linux): none free.
+    let num = |v: &str| match v.strip_prefix('-') {
+        Some(d) => d.parse::<u64>().ok().map(|_| 0),
+        None => v.parse::<u64>().ok(),
+    };
+    // Size, used, available and capacity follow the device name (which may contain spaces).
+    let i = (0..f.len().saturating_sub(3))
+        .find(|&i| f.get(i + 3).is_some_and(|c| c.ends_with('%')) && f.get(i..i + 3).is_some_and(|n| n.iter().all(|v| num(v).is_some())))?;
+    let kb = |j: usize| f.get(j).and_then(|v| num(v)).map(|v| v.saturating_mul(1024));
+    Some((kb(i)?, kb(i + 2)?))
+}
+
+/// Total and available bytes of the disk holding `path`, when the system reports them.
+pub fn disk_space(path: &std::path::Path) -> Option<(u64, u64)> {
+    #[cfg(any(target_os = "linux", target_os = "macos", target_os = "freebsd"))]
+    {
+        return parse_df(&run("df", &["-Pk", &path.to_string_lossy()])?);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        // The path goes through the environment: no quoting.
+        let text = run_env(
+            "powershell",
+            &["-NoProfile", "-Command", "$d=[IO.DriveInfo]::new($env:EC_DISK_PATH); \"$($d.TotalSize) $($d.AvailableFreeSpace)\""],
+            &[("EC_DISK_PATH", path.as_os_str())],
+        )?;
+        let mut it = text.split_whitespace().filter_map(|v| v.parse::<u64>().ok());
+        return Some((it.next()?, it.next()?));
+    }
+    #[allow(unreachable_code)]
+    {
+        let _ = path;
+        None
+    }
+}
+
 /// CPU model name.
 pub fn cpu_name() -> Option<String> {
     #[cfg(target_os = "linux")]
@@ -225,6 +293,42 @@ mod tests {
         assert_eq!(m.available, 1000);
     }
 
+    #[test]
+    fn a_failed_reading_clears_the_last_one() {
+        let w = Watch::<u64>::default();
+        let wait = || {
+            for _ in 0..500 {
+                if !w.busy.load(Ordering::Acquire) {
+                    return;
+                }
+                std::thread::sleep(std::time::Duration::from_millis(2));
+            }
+            panic!("the reading never finished");
+        };
+        w.poll_with("ec-test", || Some(7));
+        wait();
+        assert_eq!(w.latest(), Some(7));
+        w.poll_with("ec-test", || None);
+        wait();
+        assert_eq!(w.latest(), None);
+    }
+
+    #[test]
+    fn parses_df() {
+        let linux = "Filesystem     1024-blocks      Used Available Capacity Mounted on\n/dev/nvme0n1p2   488281250 123456789 364824461      26% /\n";
+        assert_eq!(parse_df(linux), Some((488_281_250 * 1024, 364_824_461 * 1024)));
+        // macOS: a device name with spaces and a mount point with spaces.
+        let mac = "Filesystem 1024-blocks Used Available Capacity  Mounted on\nmap auto_home 0 0 0 100% /System/Volumes/Data/home\n";
+        assert_eq!(parse_df(mac), Some((0, 0)));
+        let spaced = "Filesystem 1024-blocks Used Available Capacity Mounted on\n//nas/My Share 1000 400 600 40% /Volumes/My Share\n";
+        assert_eq!(parse_df(spaced), Some((1000 * 1024, 600 * 1024)));
+        // A full disk into its reserved blocks: nothing available.
+        let full = "Filesystem 1024-blocks Used Available Capacity Mounted on\n/dev/sda2 1000 1010 -10 101% /\n";
+        assert_eq!(parse_df(full), Some((1000 * 1024, 0)));
+        assert_eq!(parse_df("Filesystem 1024-blocks\n"), None);
+        assert_eq!(parse_df(""), None);
+    }
+
     #[test]
     fn parses_proc_meminfo_and_vm_stat() {
         let m = parse_meminfo("MemTotal:       16000000 kB\nMemFree:  1000 kB\nMemAvailable:    8000000 kB\n").unwrap();
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index b3f0602b3..013d2f24c 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -1,735 +1,61 @@
-use serde_json::json;
-
-use crate::Session;
-
-fn demo() -> Session {
-    let mut s = Session::default();
-    s.execute("file.openDemoProject", json!({})).unwrap();
-    s
-}
-
-#[test]
-fn demo_opens_and_renders() {
-    let s = demo();
-    let cid = s.active_comp_id().unwrap();
-    let img = s.render(cid, s.time(), effectcraft_render::RenderOpts { scale: 0.25, ..Default::default() });
-    assert_eq!((img.width, img.height), (480, 270));
-    let lit = img.data.iter().filter(|p| p[3] > 0.99).count();
-    assert!(lit > 100_000, "{lit}");
-}
-
-/// The session's layer cache never changes pixels: scrubbing the demo (including back and
-/// forth, and across an edit made through a command) matches cache-less renders exactly.
-#[test]
-fn demo_layer_cache_is_transparent() {
-    let mut s = demo();
-    let cid = s.active_comp_id().unwrap();
-    let opts = effectcraft_render::RenderOpts { scale: 0.25, ..Default::default() };
-    let uncached = |s: &Session, t: f64| {
-        let mut r = effectcraft_render::Renderer::new(&s.project, s.footage.as_ref(), opts);
-        r.expr = s.expr.as_deref();
-        r.comp_frame(cid, effectcraft_time::Tick::from_seconds_f64(t))
-    };
-    let check = |s: &Session, t: f64| {
-        let a = s.render(cid, effectcraft_time::Tick::from_seconds_f64(t), opts);
-        let b = uncached(s, t);
-        assert!(a.data.iter().zip(&b.data).all(|(p, q)| (0..4).all(|c| (p[c] - q[c]).abs() < 1e-6)), "t={t}");
-    };
-    for t in [0.5, 1.0, 3.0, 3.0334, 6.0, 3.0, 0.5] {
-        check(&s, t);
-    }
-    assert!(s.layer_cache.stats().hits > 0);
-    // Edit the title's glow through the command layer, then scrub again.
-    let title = s.project.comp(cid).unwrap().layers.iter().find(|l| l.name == "EFFECTCRAFT").map(|l| l.id.0).unwrap();
-    s.execute("prop.set", json!({"layer": title, "path": "effects/#1/radius", "value": 5.0})).unwrap();
-    for t in [3.0, 0.5] {
-        check(&s, t);
-    }
-}
-
-/// `layer.addItem` puts the layer at `index` (1-based) in the stack and starts it at `time`, as a
-/// drop in the Timeline does (#89).
-#[test]
-fn add_item_at_a_stack_index_and_time() {
-    let mut s = Session::default();
-    let clip = s.execute("comp.new", json!({"name": "Clip", "width": 16, "height": 16, "frameRate": 30, "duration": 1})).unwrap()["comp"].as_u64().unwrap();
-    s.execute("comp.new", json!({"name": "Main", "width": 32, "height": 32, "frameRate": 30, "duration": 4})).unwrap();
-    for name in ["C", "B", "A"] {
-        s.execute("layer.newSolid", json!({"name": name})).unwrap();
-    }
-    let names = |s: &Session| s.active_comp().unwrap().layers.iter().map(|l| l.name.clone()).collect::<Vec<_>>();
-    s.execute("layer.addItem", json!({"item": clip, "index": 2, "time": 1.01})).unwrap();
-    assert_eq!(names(&s), ["A", "Clip", "B", "C"]);
-    let l = &s.active_comp().unwrap().layers[1];
-    assert_eq!(l.in_point, effectcraft_time::Tick::from_seconds_f64(1.0), "on the nearest frame");
-    // Past the bottom: the bottom.
-    s.execute("layer.addItem", json!({"item": clip, "index": 99})).unwrap();
-    assert_eq!(names(&s).last().map(String::as_str), Some("Clip 2"));
-    assert!(s.execute("layer.addItem", json!({"item": clip, "index": 0})).is_err(), "1-based");
-}
-
-/// Files dropped on the Timeline or the Composition viewer (`file.import {addToComp}`) become
-/// layers of the comp that was active, one under the other, where they were dropped (#85, #89).
-#[test]
-fn imported_files_go_into_the_comp_where_they_were_dropped() {
-    use effectcraft_project::{Footage, FootageKind};
-    struct Probe;
-    impl crate::Importer for Probe {
-        fn probe(&self, path: &str) -> Result<Footage, String> {
-            Ok(Footage { path: path.into(), kind: FootageKind::Still, width: 64, height: 32, has_video: true, ..Default::default() })
-        }
-    }
-    let mut s = Session { importer: Some(std::sync::Arc::new(Probe)), ..Default::default() };
-    s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "frameRate": 30, "duration": 4})).unwrap();
-    s.execute("layer.newSolid", json!({"name": "Bg"})).unwrap();
-    let params = json!({"paths": ["/drop/a.png", "/drop/b.png"], "addToComp": true, "position": [40.0, 50.0], "index": 1, "time": 1.0});
-    s.execute("file.import", params).unwrap();
-    let comp = s.active_comp().unwrap();
-    assert_eq!(comp.layers.iter().map(|l| l.name.as_str()).collect::<Vec<_>>(), ["a.png", "b.png", "Bg"]);
-    for l in &comp.layers[..2] {
-        assert_eq!(l.props.prop("transform/position").map(|p| p.value.clone()), Some(effectcraft_keyframe::Value::Vec3([40.0, 50.0, 0.0])));
-        assert_eq!(l.in_point, effectcraft_time::Tick::from_seconds_f64(1.0));
-    }
-    // Without `addToComp` they only import.
-    s.execute("file.import", json!({"paths": ["/drop/c.png"]})).unwrap();
-    assert_eq!(s.active_comp().unwrap().layers.len(), 3);
-    assert!(s.execute("layer.addItem", json!({"item": "a.png", "position": [1.0]})).is_err(), "position needs x and y");
-}
-
-/// #270: files dropped or picked in the Import dialog (`file.import {background}`) are probed in
-/// a background job that says which file it is reading and how many are left; then they arrive
-/// in one undo step, all selected, with a count. The same file imported again arrives again.
-#[test]
-fn background_imports_report_progress_and_select_what_arrived() {
-    use effectcraft_project::{Footage, FootageKind, ItemId};
-    use std::sync::Arc;
-    use std::sync::atomic::{AtomicUsize, Ordering};
-    /// Probes file k once `allow` > k (a slow video; 5 s at most, so an import that waits for it
-    /// fails the test instead of hanging it); `.xyz` files fail.
-    struct Gated {
-        started: AtomicUsize,
-        allow: Arc<AtomicUsize>,
-    }
-    impl crate::Importer for Gated {
-        fn probe(&self, path: &str) -> Result<Footage, String> {
-            let k = self.started.fetch_add(1, Ordering::SeqCst);
-            let until = std::time::Instant::now() + std::time::Duration::from_secs(5);
-            while self.allow.load(Ordering::SeqCst) <= k && std::time::Instant::now() < until {
-                std::thread::sleep(std::time::Duration::from_millis(1));
-            }
-            if path.ends_with(".xyz") {
-                return Err("unsupported file".into());
-            }
-            Ok(Footage { path: path.into(), kind: FootageKind::Still, width: 64, height: 32, has_video: true, ..Default::default() })
-        }
-    }
-    let allow = Arc::new(AtomicUsize::new(1));
-    let mut s = Session { importer: Some(Arc::new(Gated { started: AtomicUsize::new(0), allow: allow.clone() })), ..Default::default() };
-    s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "frameRate": 30, "duration": 4})).unwrap();
-    let undo = s.history.undo.len();
-    let r = s.execute("file.import", json!({"paths": ["/drop/a.png", "/drop/b.png", "/drop/a.png"], "background": true})).unwrap();
-    let job = r["job"].as_str().unwrap().to_string();
-    // The first file is through; the second is being read.
-    let running = |s: &mut Session| s.execute("jobs.list", json!({})).unwrap()["running"].as_array().unwrap().clone();
-    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
-    while running(&mut s)[0]["done"] != json!(1) && std::time::Instant::now() < deadline {
-        std::thread::sleep(std::time::Duration::from_millis(2));
-    }
-    let row = running(&mut s)[0].clone();
-    assert_eq!(row["id"], json!(job));
-    assert_eq!(row["label"], json!("Importing 3 files"));
-    assert_eq!(row["message"], json!("b.png (2 of 3)"));
-    assert_eq!((row["done"].as_u64(), row["total"].as_u64()), (Some(1), Some(3)));
-    assert!(s.project.items.values().all(|i| i.name != "a.png"), "nothing is added before the import finishes");
-    allow.store(usize::MAX, Ordering::SeqCst);
-    s.execute("jobs.wait", json!({})).unwrap();
-    let names = |s: &Session, ids: &[ItemId]| ids.iter().map(|i| s.project.item(*i).unwrap().name.clone()).collect::<Vec<_>>();
-    assert_eq!(names(&s, &s.state.project_selection), ["a.png", "b.png", "a.png"], "everything imported is selected, the same file twice too");
-    assert_eq!(s.history.undo.len(), undo + 1, "one undo step");
-    let rec = s.job_log.last().unwrap();
-    assert_eq!((rec.status.as_str(), rec.message.as_str()), ("done", "Imported 3 items"));
-    assert!(s.drain_events().iter().any(|e| matches!(e, crate::Event::Toast { message, .. } if message == "Imported 3 items")));
-    // Dropped on the viewer: they become layers too; a file that can't be read is reported.
-    s.execute("file.import", json!({"paths": ["/drop/c.png", "/drop/d.xyz"], "background": true, "addToComp": true, "position": [10.0, 20.0]})).unwrap();
-    s.execute("jobs.wait", json!({})).unwrap();
-    assert_eq!(s.active_comp().unwrap().layers.iter().map(|l| l.name.as_str()).collect::<Vec<_>>(), ["c.png"]);
-    assert_eq!(s.job_log.last().unwrap().message, "Imported 1 item. /drop/d.xyz: unsupported file");
-    // Agents and scripts import at once by default.
-    let r = s.execute("file.import", json!({"paths": ["/drop/e.png"]})).unwrap();
-    assert_eq!(r["items"].as_array().map(Vec::len), Some(1));
-}
-
-/// Audio, Lock and Shy don't change pixels: toggling them keeps the cached layers (#103).
-#[test]
-fn audio_lock_and_shy_keep_cached_layers() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"name": "C", "width": 160, "height": 90, "frameRate": 30, "duration": 1})).unwrap();
-    s.execute("layer.newSolid", json!({"color": "#3080ff", "width": 80, "height": 40})).unwrap();
-    s.execute("effect.apply", json!({"layer": "#1", "effect": "Gaussian Blur"})).unwrap();
-    s.execute("prop.set", json!({"layer": "#1", "path": "effects/#1/blurriness", "value": 12})).unwrap();
-    let cid = s.active_comp_id().unwrap();
-    let t = s.time();
-    s.render(cid, t, Default::default());
-    let before = s.layer_cache.stats();
-    for sw in ["audio", "lock", "shy"] {
-        s.execute("layer.setSwitch", json!({"layers": ["#1"], "switch": sw, "value": sw != "audio"})).unwrap();
-    }
-    s.render(cid, t, Default::default());
-    let after = s.layer_cache.stats();
-    assert_eq!(after.misses, before.misses, "no layer rendered again");
-    assert!(after.hits > before.hits);
-}
-
-#[test]
-fn every_command_has_unique_id_and_runs_or_reports() {
-    let mut ids = std::collections::HashSet::new();
-    for c in crate::command_specs() {
-        assert!(ids.insert(c.id), "duplicate {}", c.id);
-    }
-    assert!(ids.len() >= 90, "{}", ids.len());
-}
-
-#[test]
-fn layer_workflow_with_undo() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"name": "Test", "width": 640, "height": 360, "frameRate": 30, "duration": 4})).unwrap();
-    let r = s.execute("layer.newSolid", json!({"color": "#336699"})).unwrap();
-    let lid = r["layer"].as_u64().unwrap();
-    s.execute("prop.set", json!({"layer": lid, "path": "transform/opacity", "value": 50})).unwrap();
-    let tree = s.execute("layer.tree", json!({"layer": lid})).unwrap();
-    assert!(tree.to_string().contains("\"value\":50.0"));
-    s.execute("prop.toggleAnimation", json!({"layer": lid, "path": "transform/position"})).unwrap();
-    s.execute("time.set", json!({"time": 2.0})).unwrap();
-    s.execute("prop.set", json!({"layer": lid, "path": "transform/position", "value": [100, 100]})).unwrap();
-    let comp = s.active_comp().unwrap();
-    let pos = comp.layers[0].props.prop("transform/position").unwrap();
-    assert_eq!(pos.keys.len(), 2);
-    s.execute("prop.select", json!({"layer": lid, "path": "transform/position"})).unwrap();
-    assert_eq!(s.state.selected_keys.len(), 2);
-    s.execute("keys.easyEase", json!({})).unwrap();
-    s.execute("keys.move", json!({"delta": 0.5})).unwrap();
-    let pos = s.active_comp().unwrap().layers[0].props.prop("transform/position").unwrap().clone();
-    assert!((pos.keys[0].time.seconds() - 0.5).abs() < 0.02);
-    assert_eq!(pos.keys[0].out_interp, effectcraft_keyframe::Interp::Bezier);
-    // undo back to before the move
-    s.execute("edit.undo", json!({})).unwrap();
-    let pos = s.active_comp().unwrap().layers[0].props.prop("transform/position").unwrap().clone();
-    assert!(pos.keys[0].time.seconds().abs() < 0.02);
-    s.execute("effect.apply", json!({"layer": lid, "effect": "Gaussian Blur"})).unwrap();
-    s.execute("prop.set", json!({"layer": lid, "path": "effects/#1/blurriness", "value": 12})).unwrap();
-    // Applying selects the new effect (Edit ▸ Duplicate would duplicate it); select the layer.
-    s.execute("layer.select", json!({"layers": [lid]})).unwrap();
-    s.execute("edit.duplicate", json!({})).unwrap();
-    assert_eq!(s.active_comp().unwrap().layers.len(), 2);
-    s.execute("layer.precompose", json!({"layers": [1, 2], "name": "Pre"})).unwrap();
-    assert_eq!(s.active_comp().unwrap().layers.len(), 1);
-}
-
-#[test]
-fn text_shape_mask_matte_parent() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"width": 800, "height": 450, "duration": 3})).unwrap();
-    let t = s.execute("layer.newText", json!({"text": "Hello", "size": 90})).unwrap()["layer"].as_u64().unwrap();
-    s.execute("layer.addTextAnimator", json!({"layer": t, "properties": ["position", "opacity"]})).unwrap();
-    let sh = s.execute("layer.newShape", json!({"kind": "star", "fill": "#ffcc00"})).unwrap()["layer"].as_u64().unwrap();
-    s.execute("layer.addShapeItem", json!({"layer": sh, "kind": "trim"})).unwrap();
-    s.execute("layer.addMask", json!({"layer": sh, "shape": "ellipse"})).unwrap();
-    s.execute("layer.setMask", json!({"layer": sh, "mask": 1, "mode": "Subtract", "inverted": true})).unwrap();
-    s.execute("layer.setTrackMatte", json!({"layer": sh, "matte": t, "kind": "luma"})).unwrap();
-    s.execute("layer.setParent", json!({"layers": [sh], "parent": t})).unwrap();
-    assert!(s.execute("layer.setParent", json!({"layers": [t], "parent": sh})).is_err());
-    s.execute("layer.setBlendMode", json!({"layers": [sh], "mode": "Screen"})).unwrap();
-    s.execute("layer.setSwitch", json!({"layers": [sh], "switch": "threeD"})).unwrap();
-    let cid = s.active_comp_id().unwrap();
-    let _ = s.render(cid, s.time(), Default::default());
-    let info = s.execute("comp.info", json!({})).unwrap();
-    assert_eq!(info["layers"].as_array().unwrap().len(), 2);
-}
-
-/// The toolbar's Fill / Stroke change a selected shape layer's paint (#205): a shape drawn
-/// without a stroke gets one, later edits change it, and the Contents "Add:" items (#206) include
-/// an empty Path and a Gradient Stroke that render.
-#[test]
-fn toolbar_fill_and_stroke_paint_selected_shape_layers() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"width": 400, "height": 300, "duration": 2})).unwrap();
-    let sh = s.execute("layer.newShape", json!({"kind": "rect", "fill": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
-    let paint = |s: &mut Session| s.execute("shape.fillStroke", json!({})).unwrap();
-    assert_eq!(paint(&mut s)["stroke"], serde_json::Value::Null, "drawn without a stroke");
-    s.execute("shape.fillStroke", json!({"stroke": "#00ff00", "strokeWidth": 6})).unwrap();
-    let p = paint(&mut s);
-    assert_eq!((p["stroke"][1].as_f64(), p["strokeWidth"].as_f64()), (Some(1.0), Some(6.0)), "{p}");
-    s.execute("shape.fillStroke", json!({"fill": "#0000ff", "strokeWidth": 3})).unwrap();
-    let p = paint(&mut s);
-    assert_eq!((p["fill"][2].as_f64(), p["strokeWidth"].as_f64()), (Some(1.0), Some(3.0)), "{p}");
-    // One stroke, before the fill (paths, stroke, fill), and each change is one undo step.
-    let l = s.active_comp().unwrap().layer(effectcraft_project::LayerId(sh)).unwrap().clone();
-    let group = l.props.group("contents/group").unwrap();
-    let order: Vec<&str> = group.sub("contents").unwrap().groups().map(|g| g.match_id.as_str()).collect();
-    assert_eq!(order, ["rect", "stroke", "fill"]);
-    s.execute("edit.undo", json!({})).unwrap();
-    assert_eq!(paint(&mut s)["strokeWidth"].as_f64(), Some(6.0));
-    // Only shape layers.
-    s.execute("layer.newSolid", json!({"color": "#808080"})).unwrap();
-    assert!(s.execute("shape.fillStroke", json!({"fill": "#ffffff"})).is_err());
-    for kind in ["path", "gstroke"] {
-        let r = s.execute("layer.addShapeItem", json!({"layer": sh, "kind": kind})).unwrap();
-        assert!(r["path"].as_str().is_some_and(|p| p.starts_with("contents/")), "{r}");
-    }
-    let cid = s.active_comp_id().unwrap();
-    let _ = s.render(cid, s.time(), Default::default());
-}
-
-/// The toolbar's Fill Options / Stroke Options change a selected shape layer's paint kind (#732):
-/// None switches the fill off, a gradient turns the Fill into a Gradient Fill that keeps its
-/// opacity, Solid Color turns it back, and a Stroke kind adds a stroke where there is none.
-#[test]
-fn toolbar_fill_and_stroke_kinds_change_selected_shape_layers() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"width": 400, "height": 300, "duration": 2})).unwrap();
-    let sh = s.execute("layer.newShape", json!({"kind": "rect", "fill": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
-    let items = |s: &Session| -> Vec<(String, bool)> {
-        let l = s.active_comp().unwrap().layer(effectcraft_project::LayerId(sh)).unwrap();
-        l.props.group("contents/group/contents").unwrap().groups().map(|g| (g.match_id.clone(), g.enabled)).collect()
-    };
-    let kinds = |s: &mut Session| {
-        let p = s.execute("shape.fillStroke", json!({})).unwrap();
-        (p["fillType"].as_str().unwrap().to_string(), p["strokeType"].as_str().unwrap().to_string())
-    };
-    assert_eq!(kinds(&mut s), ("solid".into(), "none".into()));
-    let cid = s.active_comp_id().unwrap();
-    let centre = |s: &Session| s.render(cid, s.time(), Default::default()).get(200, 150);
-    let red = centre(&s);
-    // None switches the fill off: nothing is drawn, and the item stays.
-    s.execute("shape.fillStroke", json!({"fillType": "none"})).unwrap();
-    assert_eq!(items(&s), [("rect".into(), true), ("fill".into(), false)]);
-    assert_eq!(kinds(&mut s).0, "none");
-    assert_ne!(centre(&s), red, "the fill is off");
-    // A radial gradient: the Fill becomes a Gradient Fill (switched on) that keeps its opacity.
-    s.execute("shape.fillStroke", json!({"fillType": "solid", "fill": "#ff0000"})).unwrap();
-    assert_eq!(centre(&s), red);
-    let opacity = |s: &Session, m: &str| {
-        let l = s.active_comp().unwrap().layer(effectcraft_project::LayerId(sh)).unwrap();
-        l.props.group(&format!("contents/group/contents/{m}")).unwrap().get("opacity").unwrap().value.as_f64()
-    };
-    s.execute("prop.set", json!({"layer": sh, "path": "contents/group/contents/fill/opacity", "value": 40})).unwrap();
-    s.execute("shape.fillStroke", json!({"fillType": "radial"})).unwrap();
-    assert_eq!(items(&s), [("rect".into(), true), ("gfill".into(), true)]);
-    assert_eq!((kinds(&mut s).0.as_str(), opacity(&s, "gfill")), ("radial", 40.0));
-    s.execute("shape.fillStroke", json!({"fillType": "linear"})).unwrap();
-    assert_eq!(kinds(&mut s).0, "linear");
-    s.execute("shape.fillStroke", json!({"fillType": "solid", "fill": "#00ff00"})).unwrap();
-    assert_eq!(items(&s), [("rect".into(), true), ("fill".into(), true)]);
-    assert_eq!(opacity(&s, "fill"), 40.0);
-    // A Stroke kind adds a stroke (before the fill); None switches it off again; undo is per step.
-    s.execute("shape.fillStroke", json!({"strokeType": "linear"})).unwrap();
-    assert_eq!(items(&s), [("rect".into(), true), ("gstroke".into(), true), ("fill".into(), true)]);
-    s.execute("shape.fillStroke", json!({"strokeType": "none"})).unwrap();
-    assert_eq!(kinds(&mut s), ("solid".into(), "none".into()));
-    s.execute("edit.undo", json!({})).unwrap();
-    assert_eq!(kinds(&mut s), ("solid".into(), "linear".into()));
-    assert!(s.execute("shape.fillStroke", json!({"fillType": "plaid"})).is_err());
-}
-
-/// Selecting a mask in the Timeline (its row or its Mask Path) selects all of its points, so the
-/// viewer drags the whole mask (#203); a shape's Path item works the same way.
-#[test]
-fn selecting_a_mask_selects_its_points() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"width": 400, "height": 300, "duration": 2})).unwrap();
-    let l = s.execute("layer.newSolid", json!({"color": "#808080"})).unwrap()["layer"].as_u64().unwrap();
-    let m1 = s.execute("layer.addMask", json!({"layer": l, "shape": "rect"})).unwrap()["mask"].as_u64().unwrap();
-    let m2 = s.execute("layer.addMask", json!({"layer": l, "shape": "ellipse"})).unwrap()["mask"].as_u64().unwrap();
-    let points = |s: &Session, m: u64| s.state.selected_vertices.iter().filter(|v| v.mask == m).count();
-    s.execute("prop.select", json!({"layer": l, "prop": m1, "selectKeys": false})).unwrap();
-    assert_eq!((points(&s, m1), s.state.selected_vertices.len()), (4, 4));
-    // Mask Path selects them too; Shift-adding another mask keeps the first.
-    let path = s.active_comp().unwrap().layer(effectcraft_project::LayerId(l)).unwrap().props.find_group(m2).unwrap().get("path").unwrap().uid;
-    s.execute("prop.select", json!({"layer": l, "prop": path, "add": true})).unwrap();
-    assert_eq!((points(&s, m1), points(&s, m2)), (4, 4));
-    // Another mask replaces them; another property deselects them.
-    s.execute("prop.select", json!({"layer": l, "prop": m2})).unwrap();
-    assert_eq!((points(&s, m1), points(&s, m2)), (0, 4));
-    // Delete removes the selected mask (not only its points).
-    s.execute("edit.clear", json!({})).unwrap();
-    let masks = |s: &Session| s.active_comp().unwrap().layer(effectcraft_project::LayerId(l)).unwrap().masks().unwrap().children.len();
-    assert_eq!(masks(&s), 1);
-    s.execute("prop.select", json!({"layer": l, "path": "transform/opacity"})).unwrap();
-    assert!(s.state.selected_vertices.is_empty());
-    let sh = s.execute("layer.newShape", json!({"kind": "star"})).unwrap()["layer"].as_u64().unwrap();
-    let star = s.execute("layer.addShapeItem", json!({"layer": sh, "kind": "path"})).unwrap()["uid"].as_u64().unwrap();
-    s.execute("prop.select", json!({"layer": sh, "prop": star})).unwrap();
-    assert_eq!(s.state.selected_vertices.len(), 0, "an empty Path has no points");
-}
-
-#[test]
-fn save_and_open_roundtrip() {
-    let mut s = demo();
-    let dir = std::env::temp_dir().join(format!("ec-test-{}", std::process::id()));
-    std::fs::create_dir_all(&dir).unwrap();
-    let path = dir.join("demo.ecproj").to_string_lossy().to_string();
-    s.execute("file.saveAs", json!({"path": path})).unwrap();
-    let before = s.project.clone();
-    let mut s2 = Session::default();
-    s2.execute("file.open", json!({"path": path})).unwrap();
-    assert_eq!(*before, *s2.project);
-    let _ = std::fs::remove_dir_all(dir);
-}
-
-#[test]
-fn help_links_emit_urls() {
-    let mut s = Session::default();
-    let r = s.execute("help.discord", json!({})).unwrap();
-    assert_eq!(r["url"], "https://discord.gg/artcraft");
-    assert!(s.drain_events().iter().any(|e| matches!(e, crate::Event::OpenUrl(u) if u.contains("discord"))));
-    assert_eq!(s.execute("help.github", json!({})).unwrap()["url"], "https://github.com/storytold/effectcraft");
-}
-
-#[test]
-fn time_navigation() {
-    let mut s = demo();
-    s.execute("time.start", json!({})).unwrap();
-    let r = s.execute("time.nextKey", json!({})).unwrap();
-    assert!(r["time"].as_f64().unwrap() > 0.0);
-    s.execute("time.set", json!({"frame": 45})).unwrap();
-    assert_eq!(s.execute("time.step", json!({"frames": 5})).unwrap()["frame"], 50);
-}
-
-#[test]
-fn time_navigation_per_property() {
-    let mut s = demo();
-    // An animated property and the comp times of its keys.
-    let comp = s.active_comp().unwrap().clone();
-    let mut found = None;
-    for l in &comp.layers {
-        l.props.walk("", &mut |_, pr| {
-            if found.is_none() && pr.keys.len() >= 2 {
-                found = Some((pr.uid, pr.keys.iter().map(|k| l.comp_time(k.time)).collect::<Vec<_>>()));
-            }
-        });
-    }
-    let (uid, times) = found.expect("demo has an animated property");
-    s.set_time(effectcraft_time::Tick::ZERO);
-    let half = comp.frame_duration().0 / 2;
-    let expect = times.iter().copied().filter(|t| t.0 > half).min().unwrap();
-    s.execute("time.go", json!({"to": "nextKey", "prop": uid})).unwrap();
-    let snap = |t| comp.frame_rate.snap(t);
-    assert_eq!(s.time(), snap(expect));
-    // Going back from past the last key lands on the last key.
-    s.set_time(comp.duration);
-    s.execute("time.go", json!({"to": "prevKey", "prop": uid})).unwrap();
-    assert_eq!(s.time(), snap(*times.iter().max().unwrap()));
-}
-
-#[test]
-fn set_text_paragraph_fill_and_leading() {
-    use effectcraft_keyframe::{Justify, Value as KValue};
-    let mut s = demo();
-    let t = s.execute("layer.newText", json!({"text": "Hi"})).unwrap()["layer"].as_u64().unwrap();
-    let doc = |s: &Session| {
-        let l = s.active_comp().unwrap().layer(crate::project::LayerId(t)).unwrap().clone();
-        match &l.props.prop("text/sourceText").unwrap().value {
-            KValue::Text(d) => (**d).clone(),
-            v => panic!("{v:?}"),
-        }
-    };
-    for (key, j) in [
-        ("justifyLeft", Justify::JustifyLastLeft),
-        ("justifyCenter", Justify::JustifyLastCenter),
-        ("justifyRight", Justify::JustifyLastRight),
-        ("justifyAll", Justify::JustifyAll),
-        ("center", Justify::Center),
-    ] {
-        s.execute("layer.setText", json!({"layer": t, "justify": key})).unwrap();
-        assert_eq!(doc(&s).justify, j, "{key}");
-    }
-    s.execute("layer.setText", json!({"layer": t, "leading": 50, "applyFill": false, "applyStroke": true})).unwrap();
-    let d = doc(&s);
-    assert_eq!((d.leading, d.apply_fill, d.apply_stroke), (Some(50.0), false, true));
-    s.execute("layer.setText", json!({"layer": t, "leading": "auto"})).unwrap();
-    assert_eq!(doc(&s).leading, None);
-    s.execute("layer.setText", json!({"layer": t, "hScale": 120, "vScale": 80, "baselineShift": 4, "smallCaps": true, "strokeOverFill": true})).unwrap();
-    let d = doc(&s);
-    assert_eq!((d.h_scale, d.v_scale, d.baseline_shift, d.small_caps, d.stroke_over_fill), (120.0, 80.0, 4.0, true, true));
-}
-
-#[test]
-fn property_groups_report_actionable_errors() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"name": "T"})).unwrap();
-    let l = s.execute("layer.newText", json!({"text": "Hi"})).unwrap()["layer"].as_u64().unwrap();
-    let uid = s.active_comp().unwrap().layer(crate::project::LayerId(l)).unwrap().props.group("text/pathOptions").unwrap().uid;
-    for selector in [json!({"path": "text"}), json!({"path": "text/pathOptions"}), json!({"path": format!("@{uid}")}), json!({"prop": uid})] {
-        let mut params = selector;
-        params["layer"] = json!(l);
-        for cmd in ["prop.get", "prop.set"] {
-            let err = s.execute(cmd, params.clone()).unwrap_err().to_string();
-            assert!(err.contains("is a property group"), "{cmd}: {err}");
-            assert!(err.contains("get_layer"), "{cmd}: {err}");
-        }
-    }
-    assert!(s.execute("prop.get", json!({"layer": l, "path": "text/sourceText"})).is_ok());
-    let err = s.execute("prop.get", json!({"layer": l, "path": "missing"})).unwrap_err().to_string();
-    assert!(err.contains("no property `missing`"), "{err}");
-}
-
-#[test]
-fn prop_get_and_render_rgba8() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"name": "T", "width": 320, "height": 180, "duration": 2.0, "frameRate": 30})).unwrap();
-    let l = s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
-    s.execute("prop.addKey", json!({"layer": l, "path": "transform/position", "time": 0.0, "value": [0, 0]})).unwrap();
-    s.execute("prop.addKey", json!({"layer": l, "path": "transform/position", "time": 1.0, "value": [100, 50]})).unwrap();
-    let v = s.execute("prop.get", json!({"layer": l, "path": "transform/position", "time": 1.0})).unwrap();
-    assert_eq!(v["animated"], true);
-    assert_eq!(v["keys"].as_array().unwrap().len(), 2);
-    assert_eq!(v["value"][0].as_f64().unwrap(), 100.0);
-    let cid = s.resolve_comp(Some(&json!("T"))).unwrap();
-    let (w, h, rgba) = s.render_rgba8(cid, effectcraft_time::Tick::ZERO, 160).unwrap();
-    assert_eq!((w, h), (160, 90));
-    assert_eq!(rgba.len(), (w * h * 4) as usize);
-}
-
-#[test]
-fn params_docs_parse() {
-    use crate::commands::accepted_params;
-    let k = |d: &str| accepted_params(d).unwrap();
-    assert_eq!(k("{layers: [id|name|#n], add?, toggle?}"), ["layers", "add", "toggle"]);
-    assert_eq!(k("{time? (s) | frame? | timecode?}"), ["time", "frame", "timecode"]);
-    assert_eq!(k("{interpolation?|in?|out?: linear|bezier|hold, autoBezier?}"), ["interpolation", "in", "out", "autoBezier"]);
-    assert_eq!(k("{keys: [{layer, prop, time}], add?}"), ["keys", "add"]);
-    assert_eq!(k("{label: Red|Yellow|Aqua|…, layers?}"), ["label", "layers"]);
-    assert_eq!(k("{name?, background? [r,g,b]|#hex, open?}"), ["name", "background", "open"]);
-    assert!(k("{}").is_empty());
-    assert!(accepted_params("free text").is_none());
-    // Every registered command documents its params as a parseable key list.
-    for c in crate::command_specs() {
-        assert!(accepted_params(c.params).is_some(), "{}: {}", c.id, c.params);
-    }
-}
-
-#[test]
-fn execute_checked_rejects_unknown_params() {
-    let mut s = demo();
-    let e = s.execute_checked("layer.select", json!({"index": 2})).unwrap_err().to_string();
-    assert!(e.contains("`index`") && e.contains("layers, add, toggle"), "{e}");
-    s.execute_checked("layer.select", json!({"layers": ["#2"]})).unwrap();
-    assert_eq!(s.state.selected_layers.len(), 1);
-    // Aliases and always-accepted keys.
-    s.execute_checked("layer.select", json!({"layer": "#1", "comp": s.active_comp_id().unwrap().0})).unwrap();
-    s.execute_checked("time.set", json!({"frame": 3})).unwrap();
-    assert!(s.execute_checked("edit.undo", json!({"steps": 2})).is_err());
-    // Non-object params are not validated; the unchecked path stays lenient.
-    s.execute("layer.select", json!({"layers": ["#1"], "index": 2})).unwrap();
-}
-
-#[test]
-fn layer_tree_paths_resolve() {
-    let mut s = demo();
-    s.execute("effect.apply", json!({"layer": 1, "effect": "Gaussian Blur"})).unwrap();
-    let comp = s.execute("comp.info", json!({})).unwrap();
-    let mut checked = 0;
-    for l in comp["layers"].as_array().unwrap() {
-        let tree = s.execute("layer.tree", json!({"layer": l["id"]})).unwrap();
-        let mut stack = vec![tree["properties"].clone()];
-        while let Some(n) = stack.pop() {
-            if let Some(ch) = n["children"].as_array() {
-                stack.extend(ch.iter().cloned());
-                continue;
-            }
-            let path = n["path"].as_str().unwrap();
-            let got = s.execute("prop.get", json!({"layer": l["id"], "path": path})).unwrap();
-            assert_eq!(got["uid"], n["uid"], "path {path} on layer {}", l["name"]);
-            checked += 1;
-        }
-    }
-    assert!(checked > 20, "{checked}");
-}
-
-#[test]
-fn comp_settings_anchor_start_timecode_renderer() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"name": "A", "width": 100, "height": 100, "duration": 2.0})).unwrap();
-    let l = s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
-    s.execute("prop.addKey", json!({"layer": l, "path": "transform/position", "time": 0.0, "value": [10, 20]})).unwrap();
-    let pos = |s: &Session| {
-        let pr = s.active_comp().unwrap().layer(crate::project::LayerId(l)).unwrap().props.prop("transform/position").unwrap().clone();
-        pr.keys[0].value.components()
-    };
-    // Center anchor: grow by 100x50 → shift by half.
-    s.execute("comp.settings", json!({"width": 200, "height": 150})).unwrap();
-    assert_eq!(pos(&s)[..2], [60.0, 45.0]);
-    // Top-left anchor: no shift. Bottom-right: full shift.
-    s.execute("comp.settings", json!({"width": 300, "anchor": 0})).unwrap();
-    assert_eq!(pos(&s)[..2], [60.0, 45.0]);
-    s.execute("comp.settings", json!({"width": 200, "height": 100, "anchor": 8})).unwrap();
-    assert_eq!(pos(&s)[..2], [-40.0, -5.0]);
-    s.execute("comp.settings", json!({"startTimecode": "0:00:01:00", "renderer": "advanced3D"})).unwrap();
-    let c = s.active_comp().unwrap();
-    assert_eq!(c.display_start, c.frame_rate.tick_of(30));
-    assert_eq!(c.renderer, crate::project::Renderer::Advanced3D);
-}
-
-/// `advanced3D` is a value of `renderer`, not a key: comp.new / comp.settings don't advertise it
-/// in their schemas and reject it as unknown instead of ignoring it (#177).
-#[test]
-fn renderer_values_are_not_parameter_keys() {
-    let mut s = Session::default();
-    for (id, p) in [("comp.new", json!({"name": "A"})), ("comp.settings", json!({}))] {
-        let spec = crate::command_specs().iter().find(|c| c.id == id).unwrap();
-        let keys = crate::commands::accepted_params(spec.params).unwrap();
-        assert!(keys.contains(&"renderer".to_string()) && !keys.contains(&"advanced3D".to_string()), "{id}: {keys:?}");
-        let mut bad = p.clone();
-        bad["advanced3D"] = json!(true);
-        let e = s.execute_checked(id, bad).unwrap_err().to_string();
-        assert!(e.contains("unknown parameter(s) `advanced3D`"), "{id}: {e}");
-        let mut good = p;
-        good["renderer"] = json!("advanced3D");
-        s.execute_checked(id, good).unwrap();
-        assert_eq!(s.active_comp().unwrap().renderer, crate::project::Renderer::Advanced3D, "{id}");
-        s.execute("comp.renderer", json!({"renderer": "classic3d"})).unwrap();
-    }
-}
-
-#[test]
-fn comp_rejects_zero_and_negative_frame_rates() {
-    let mut s = Session::default();
-    for fps in [0.0, -30.0, 0.0001] {
-        assert!(s.execute("comp.new", json!({"frameRate": fps})).is_err(), "{fps}");
-    }
-    s.execute("comp.new", json!({"frameRate": 30, "duration": 1})).unwrap();
-    assert!(s.execute("comp.settings", json!({"frameRate": 0})).is_err());
-    assert_eq!(s.active_comp().unwrap().frame_rate, crate::time::FrameRate::FPS_30);
-}
-
-#[test]
-fn render_queue_add_accepts_documented_settings_when_checked() {
-    let mut s = demo();
-    let r = s.execute_checked(
-        "renderQueue.add",
-        json!({"format": "gif", "output": "/tmp/x.gif", "resolution": "quarter", "timeSpan": "custom", "start": 0.0, "end": 0.5, "quality": "draft", "loop": true}),
-    );
-    // Without an exporter the add itself still succeeds (rendering is what needs one).
-    assert!(r.is_ok(), "{r:?}");
-    assert!(s.execute_checked("renderQueue.add", json!({"bogus": 1})).is_err());
-}
-
-#[test]
-fn new_text_rejects_malformed_positions_without_creating_a_layer() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"name": "C", "width": 64, "height": 64, "duration": 1})).unwrap();
-    for position in [json!([]), json!([10]), json!(["x", 20]), json!([null, 20])] {
-        let err = s.execute("layer.newText", json!({"text": "Hello", "position": position})).unwrap_err();
-        assert!(err.to_string().contains("position: [x, y]"), "{err}");
-        assert!(s.active_comp().unwrap().layers.is_empty());
-    }
-    s.execute("layer.newText", json!({"name": "Valid", "text": "Hello", "position": [10, 20]})).unwrap();
-    assert_eq!(s.active_comp().unwrap().layers[0].props.prop("transform/position").unwrap().value, effectcraft_keyframe::Value::Vec3([10.0, 20.0, 0.0]));
-    s.execute("layer.newText", json!({"text": "No explicit position"})).unwrap();
-    assert_eq!(s.active_comp().unwrap().layers.len(), 2);
-}
-
-/// The active comp and the open comp tabs are saved with the project and restored on open (#748).
-#[test]
-fn reopening_a_project_restores_its_active_comp() {
-    use effectcraft_project::ItemId;
-    let dir = std::env::temp_dir().join(format!("ec-test-748-{}", std::process::id()));
-    std::fs::create_dir_all(&dir).unwrap();
-    let path = dir.join("view.ecproj").to_string_lossy().to_string();
-    let mut s = Session::default();
-    let a = s.execute("comp.new", json!({"name": "CompA"})).unwrap()["comp"].as_u64().unwrap();
-    let b = s.execute("comp.new", json!({"name": "CompB"})).unwrap()["comp"].as_u64().unwrap();
-    let c = s.execute("comp.new", json!({"name": "CompC"})).unwrap()["comp"].as_u64().unwrap();
-    s.execute("comp.open", json!({"comp": "CompB"})).unwrap();
-    s.state.open_comps.retain(|id| id.0 != c);
-    s.execute("file.saveAs", json!({"path": path})).unwrap();
-    let mut s2 = Session::default();
-    s2.execute("file.open", json!({"path": path})).unwrap();
-    assert_eq!(s2.state.active_comp, Some(ItemId(b)));
-    assert_eq!(s2.state.open_comps, vec![ItemId(a), ItemId(b)]);
-    assert!(!s2.is_dirty());
-
-    // A file from before the view was saved opens on its first comp, as it always did.
-    let text = std::fs::read_to_string(&path).unwrap();
-    let mut old: serde_json::Value = serde_json::from_str(&text).unwrap();
-    let obj = old.as_object_mut().unwrap();
-    obj.remove("activeComp");
-    obj.remove("openComps");
-    std::fs::write(&path, serde_json::to_string_pretty(&old).unwrap()).unwrap();
-    let mut s3 = Session::default();
-    s3.execute("file.open", json!({"path": path})).unwrap();
-    assert_eq!((s3.state.active_comp, s3.state.open_comps.clone()), (Some(ItemId(a)), vec![ItemId(a)]));
-
-    // Ids that no longer name a comp (edited by hand, or written by another tool) fall back.
-    obj_set(&mut old, json!(999), json!([999, b, "x"]));
-    std::fs::write(&path, serde_json::to_string_pretty(&old).unwrap()).unwrap();
-    let mut s4 = Session::default();
-    s4.execute("file.open", json!({"path": path})).unwrap();
-    assert_eq!((s4.state.active_comp, s4.state.open_comps.clone()), (Some(ItemId(b)), vec![ItemId(b)]));
-    obj_set(&mut old, json!(999), json!([]));
-    std::fs::write(&path, serde_json::to_string_pretty(&old).unwrap()).unwrap();
-    let mut s5 = Session::default();
-    s5.execute("file.open", json!({"path": path})).unwrap();
-    assert_eq!((s5.state.active_comp, s5.state.open_comps.clone()), (Some(ItemId(a)), vec![ItemId(a)]));
-
-    // XML copies carry it too.
-    let xml = dir.join("view.ecprojx").to_string_lossy().to_string();
-    s.execute("file.saveAs", json!({"path": xml})).unwrap();
-    let mut s6 = Session::default();
-    s6.execute("file.open", json!({"path": xml})).unwrap();
-    assert_eq!(s6.state.active_comp, Some(ItemId(b)));
-    let _ = std::fs::remove_dir_all(dir);
-
-    fn obj_set(v: &mut serde_json::Value, active: serde_json::Value, open: serde_json::Value) {
-        let o = v.as_object_mut().unwrap();
-        o.insert("activeComp".into(), active);
-        o.insert("openComps".into(), open);
-    }
-}
-
-/// Layer times are saved as exact ticks and read back unchanged, and each comp reopens at the
-/// current time it was saved at, not at 0, where a layer starting later shows nothing (#1714).
-#[test]
-fn reopening_a_project_restores_layer_times_and_current_time() {
-    use effectcraft_project::ItemId;
-    use effectcraft_time::{FrameRate, Tick};
-    let dir = std::env::temp_dir().join(format!("ec-test-1714-{}", std::process::id()));
-    std::fs::create_dir_all(&dir).unwrap();
-    let path = dir.join("times.ecproj").to_string_lossy().to_string();
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"name": "C", "width": 108, "height": 192, "duration": 60})).unwrap();
-    s.execute("layer.newSolid", json!({"name": "crown"})).unwrap();
-    let cid = s.active_comp_id().unwrap();
-    let comp = std::sync::Arc::make_mut(&mut s.project).comp_mut(cid).unwrap();
-    comp.frame_rate = FrameRate::FPS_59_94;
-    // The layer from the issue: 34f, 315f and 3033f at 59.94 fps.
-    let l = comp.layers.first_mut().unwrap();
-    (l.start_time, l.in_point, l.out_point) = (Tick(144_086_342_400), Tick(1_334_917_584_000), Tick(12_853_349_308_800));
-    s.execute("time.set", json!({"time": 6.0})).unwrap();
-    let t = s.time();
-    // A second comp keeps its own time.
-    let b = ItemId(s.execute("comp.new", json!({"name": "B"})).unwrap()["comp"].as_u64().unwrap());
-    s.execute("time.set", json!({"time": 2.0})).unwrap();
-    let tb = s.time();
-    s.execute("comp.open", json!({"comp": "C"})).unwrap();
-    s.execute("file.saveAs", json!({"path": path})).unwrap();
-
-    let mut s2 = Session::default();
-    s2.execute("file.open", json!({"path": path})).unwrap();
-    let l = s2.project.comp(cid).unwrap().layers.first().unwrap();
-    assert_eq!((l.start_time, l.in_point, l.out_point), (Tick(144_086_342_400), Tick(1_334_917_584_000), Tick(12_853_349_308_800)));
-    assert_eq!((s2.time(), s2.state.times.get(&b).copied()), (t, Some(tb)));
-    assert!(l.in_point <= s2.time() && s2.time() < l.out_point, "the layer shows at the reopened time");
-    assert!(!s2.is_dirty());
-
-    // Hand-edited times past the end or before the start land on the last or first frame.
-    let mut file: serde_json::Value = serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
-    file["compTimes"] = json!({cid.0.to_string(): i64::MAX, b.0.to_string(): -5});
-    std::fs::write(&path, file.to_string()).unwrap();
-    let mut s3 = Session::default();
-    s3.execute("file.open", json!({"path": path})).unwrap();
-    let c = s3.project.comp(cid).unwrap();
-    assert_eq!(s3.time(), c.frame_rate.snap_nearest(c.duration - c.frame_duration()));
-    assert_eq!(s3.time(), c.frame_rate.snap_nearest(c.duration - c.frame_duration()));
-    assert_eq!(s3.state.times.get(&b).copied(), Some(Tick::ZERO));
-}
+mod add_item_options;
+mod anim_presets;
+mod anim_tools;
+mod blender;
+mod camera_track;
+mod codec_options;
+mod color_view;
+mod crypto_pick;
+mod delete_keys;
+mod disk_cache;
+mod effects;
+mod essential;
+mod essential_more;
+mod export_overwrite;
+mod face;
+mod fidelity;
+mod frame_export;
+mod fuzz_open;
+mod history;
+mod import_project;
+mod instance3d;
+mod key_metadata_order;
+mod key_time;
+mod keyframe_text;
+mod keylight;
+mod limits;
+mod lottie;
+mod m137;
+mod m145;
+mod markers;
+mod mask_warp;
+mod menu_cmds;
+mod model3d;
+mod models;
+mod motion_blur_depth;
+mod paint;
+mod panels;
+mod project_items;
+mod proxy;
+mod quick_offset;
+mod render_overwrite;
+mod replace_source;
+mod rig3d;
+pub(crate) mod roto;
+mod scale_comp;
+mod sequence;
+mod session;
+mod settings;
+mod shared_layers;
+mod shortcut_cmds;
+pub(crate) mod stubs;
+mod styles;
+mod tail;
+mod text;
+mod text_edit;
+mod three_d;
+mod timeline;
+mod timeline_interchange;
+pub(crate) mod track;
+mod vector_import;
+mod viewer;
diff --git a/crates/engine/src/tests/add_item_options.rs b/crates/engine/src/tests/add_item_options.rs
new file mode 100644
index 000000000..b21e863b0
--- /dev/null
+++ b/crates/engine/src/tests/add_item_options.rs
@@ -0,0 +1,93 @@
+//! `layer.addItem {in, out, anchor}` (#2026): place a layer's In / Out points and Anchor Point in
+//! the same call, so one command does what addItem + layer.timing + prop.set did.
+
+use effectcraft_project::{Layer, LayerId, LayerSource};
+use effectcraft_time::Tick;
+use serde_json::{Value, json};
+
+use crate::Session;
+
+/// A 10 s, 30 fps comp with a 100 x 50 solid item; returns the session, the item id and the solid's first layer.
+fn setup() -> (Session, u64, u64) {
+    let mut s = Session::default();
+    s.execute_checked("comp.new", json!({"width": 640, "height": 360, "frameRate": 30, "duration": 10})).unwrap();
+    let l = s.execute_checked("layer.newSolid", json!({"name": "S", "color": "#fff", "width": 100, "height": 50})).unwrap()["layer"].as_u64().unwrap();
+    let item = match &s.active_comp().unwrap().layer(LayerId(l)).unwrap().source {
+        LayerSource::Solid { item } => item.0,
+        other => panic!("not a solid: {other:?}"),
+    };
+    (s, item, l)
+}
+
+fn layer(s: &Session, id: u64) -> &Layer {
+    s.active_comp().unwrap().layer(LayerId(id)).unwrap()
+}
+
+fn anchor(s: &Session, id: u64) -> [f64; 3] {
+    layer(s, id).props.prop("transform/anchor").unwrap().value.as_vec3()
+}
+
+fn secs(t: Tick) -> f64 {
+    t.seconds()
+}
+
+#[test]
+fn in_out_and_anchor_in_one_call() {
+    let (mut s, item, _) = setup();
+    let id = s.execute_checked("layer.addItem", json!({"item": item, "time": 1.0, "in": 2.0, "out": 4.0, "anchor": [10.0, 20.0]})).unwrap()["layer"]
+        .as_u64()
+        .unwrap();
+    let l = layer(&s, id);
+    assert_eq!((secs(l.start_time), secs(l.in_point), secs(l.out_point)), (1.0, 2.0, 4.0));
+    assert_eq!(anchor(&s, id)[..2], [10.0, 20.0]);
+}
+
+#[test]
+fn only_in_or_only_out_keeps_the_other_default() {
+    let (mut s, item, _) = setup();
+    let a = s.execute_checked("layer.addItem", json!({"item": item, "in": 3.0})).unwrap()["layer"].as_u64().unwrap();
+    assert_eq!((secs(layer(&s, a).in_point), secs(layer(&s, a).out_point)), (3.0, 10.0));
+    let b = s.execute_checked("layer.addItem", json!({"item": item, "out": 5.0})).unwrap()["layer"].as_u64().unwrap();
+    assert_eq!((secs(layer(&s, b).in_point), secs(layer(&s, b).out_point)), (0.0, 5.0));
+}
+
+#[test]
+fn omitted_params_keep_the_default_placement() {
+    let (mut s, item, first) = setup();
+    let before = anchor(&s, first);
+    let id = s.execute_checked("layer.addItem", json!({"item": item})).unwrap()["layer"].as_u64().unwrap();
+    let l = layer(&s, id);
+    assert_eq!((secs(l.in_point), secs(l.out_point)), (0.0, 10.0));
+    assert_eq!(anchor(&s, id), before);
+}
+
+#[test]
+fn invalid_values_are_errors_and_change_nothing() {
+    let (mut s, item, _) = setup();
+    let n = s.active_comp().unwrap().layers.len();
+    let bad: [Value; 8] = [
+        json!({"in": 5.0, "out": 5.0}),
+        json!({"in": 6.0, "out": 2.0}),
+        json!({"in": -1.0}),
+        json!({"in": "soon"}),
+        json!({"out": 1e300}),
+        json!({"anchor": [1.0]}),
+        json!({"anchor": [1.0, "x"]}),
+        json!({"anchor": [1e300, 0.0]}),
+    ];
+    for extra in bad {
+        let mut p = json!({"item": item});
+        p.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
+        assert!(s.execute("layer.addItem", p.clone()).is_err(), "{p}");
+    }
+    assert_eq!(s.active_comp().unwrap().layers.len(), n);
+}
+
+/// `in` applies before `out` (as `layer.timing`), so a range before the layer's start lands as asked.
+#[test]
+fn in_and_out_before_the_start_land_and_a_three_value_anchor_is_refused() {
+    let (mut s, item, _) = setup();
+    let id = s.execute_checked("layer.addItem", json!({"item": item, "time": 5.0, "in": 1.0, "out": 2.0})).unwrap()["layer"].as_u64().unwrap();
+    assert_eq!((secs(layer(&s, id).in_point), secs(layer(&s, id).out_point)), (1.0, 2.0));
+    assert!(s.execute_checked("layer.addItem", json!({"item": item, "anchor": [1.0, 2.0, 3.0]})).is_err());
+}
diff --git a/crates/engine/src/tests_anim_presets.rs b/crates/engine/src/tests/anim_presets.rs
similarity index 80%
rename from crates/engine/src/tests_anim_presets.rs
rename to crates/engine/src/tests/anim_presets.rs
index b9f529c45..4d8b79e3f 100644
--- a/crates/engine/src/tests_anim_presets.rs
+++ b/crates/engine/src/tests/anim_presets.rs
@@ -78,7 +78,7 @@ fn transition_preset_by_name_and_bad_input() {
 #[test]
 fn preset_catalogue_is_unique_and_categorised() {
     let all = crate::animation_presets();
-    let known = ["Transitions", "Backgrounds"];
+    let known = ["Transitions", "Backgrounds", "Behaviors"];
     let mut ids = std::collections::HashSet::new();
     let mut names = std::collections::HashSet::new();
     for (id, name, cat) in &all {
@@ -90,7 +90,7 @@ fn preset_catalogue_is_unique_and_categorised() {
         assert!(!ids.contains(&id.to_lowercase()) && !names.contains(&name.to_lowercase()), "text preset {id} clashes");
     }
     let n = |c: &str| all.iter().filter(|(_, _, k)| k == c).count();
-    assert!(n("Backgrounds") >= 15 && n("Transitions") >= 20);
+    assert!(n("Backgrounds") >= 15 && n("Transitions") >= 20 && n("Behaviors") >= 20);
 }
 
 #[test]
@@ -126,3 +126,34 @@ fn preset_expressions_and_point_fractions() {
     assert_eq!(ramp.prop("end").unwrap().value, effectcraft_keyframe::Value::Vec2([80.0, 90.0]));
     assert_eq!(ramp.prop("startColor").unwrap().keys.len(), 2);
 }
+
+/// #1510: Behaviors presets add no effects; each puts an enabled expression on a transform
+/// property, and undo removes it again.
+#[test]
+fn every_behavior_preset_applies_and_undoes() {
+    let (mut s, solid) = session();
+    let list = s.execute("anim.builtinPresets", json!({"category": "Behaviors"})).unwrap();
+    let list = list.as_array().unwrap().clone();
+    assert!(list.len() >= 20, "{}", list.len());
+    let driven = |s: &Session| {
+        let l = &s.active_comp().unwrap().layers[0];
+        ["transform/position", "transform/scale", "transform/rotation", "transform/opacity"]
+            .iter()
+            .filter(|p| l.props.prop(p).is_some_and(|pr| pr.has_expression()))
+            .copied()
+            .collect::<Vec<_>>()
+    };
+    for p in &list {
+        let id = p["id"].as_str().unwrap();
+        let r = s.execute("anim.applyBuiltinPreset", json!({"layers": [solid], "preset": id})).unwrap();
+        assert_eq!(r["skipped"], json!([]), "{id}: every path and expression applies");
+        assert_eq!(r["effects"], json!([]), "{id}: behaviors add no effects");
+        let applied = driven(&s);
+        assert_eq!(applied.len(), 1, "{id}: exactly one property is driven");
+        s.execute("edit.undo", json!({})).unwrap();
+        assert!(driven(&s).is_empty(), "{id}: undo removes the expression");
+        s.execute("edit.redo", json!({})).unwrap();
+        assert_eq!(driven(&s), applied, "{id}: redo restores the expression");
+        s.execute("edit.undo", json!({})).unwrap();
+    }
+}
diff --git a/crates/engine/src/tests_anim_tools.rs b/crates/engine/src/tests/anim_tools.rs
similarity index 61%
rename from crates/engine/src/tests_anim_tools.rs
rename to crates/engine/src/tests/anim_tools.rs
index 69b6afa06..96b861972 100644
--- a/crates/engine/src/tests_anim_tools.rs
+++ b/crates/engine/src/tests/anim_tools.rs
@@ -3,12 +3,86 @@
 use effectcraft_keyframe::evaluate;
 use serde_json::json;
 
-use crate::tests_timeline::{animate, prop, setup};
+use crate::tests::timeline::{animate, prop, setup};
 
 fn select(s: &mut crate::Session, layer: u64, path: &str) {
     s.execute("prop.select", json!({"layer": layer, "path": path})).unwrap();
 }
 
+fn selection_command_skips_locked_keys(command: &str, path: &str, values: [serde_json::Value; 3], mut params: serde_json::Value) {
+    let (mut s, locked) = setup();
+    let unlocked = s.execute("layer.newSolid", json!({"name": "Editable", "width": 100, "height": 100})).unwrap()["layer"].as_u64().unwrap();
+    for layer in [locked, unlocked] {
+        animate(&mut s, layer, path, &[(0.0, values[0].clone()), (0.5, values[1].clone()), (1.0, values[2].clone())]);
+    }
+    let before = prop(&s, locked, path).keys;
+    let selected: Vec<_> = [locked, unlocked]
+        .into_iter()
+        .flat_map(|layer| {
+            let pr = prop(&s, layer, path);
+            pr.keys.into_iter().map(move |key| crate::KeyRef { layer: effectcraft_project::LayerId(layer), prop: pr.uid, time: key.time })
+        })
+        .collect();
+    s.execute("layer.setSwitch", json!({"layers": [locked], "switch": "locked", "value": true})).unwrap();
+    s.state.selected_keys = selected.clone();
+    if params.get("keys").is_some() {
+        params["keys"] = serde_json::to_value(&selected).unwrap();
+    }
+    s.execute_checked(command, params.clone()).unwrap();
+    assert_eq!(prop(&s, locked, path).keys, before, "{command} changed a locked layer");
+    let after = prop(&s, unlocked, path).keys;
+    assert_ne!(after, before, "{command} must still edit unlocked keys");
+    let after_selection = s.state.selected_keys.clone();
+    assert!(selected.iter().filter(|k| k.layer.0 == locked).all(|key| after_selection.contains(key)));
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(prop(&s, unlocked, path).keys, before);
+    assert!(selected.iter().filter(|key| key.layer.0 == locked).all(|key| s.state.selected_keys.contains(key)));
+    s.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(prop(&s, unlocked, path).keys, after);
+    assert_eq!(s.state.selected_keys, after_selection);
+    // All-locked input must preserve the selection and document as well.
+    s.state.selected_keys.retain(|k| k.layer.0 == locked);
+    if params.get("keys").is_some() {
+        params["keys"] = serde_json::to_value(&s.state.selected_keys).unwrap();
+    }
+    let locked_selection = s.state.selected_keys.clone();
+    let project = serde_json::to_value(&*s.project).unwrap();
+    let _ = s.execute_checked(command, params);
+    assert_eq!(serde_json::to_value(&*s.project).unwrap(), project);
+    assert_eq!(s.state.selected_keys, locked_selection);
+}
+
+#[test]
+fn wiggler_preserves_locked_keys_in_mixed_selection() {
+    selection_command_skips_locked_keys(
+        "keys.wiggle",
+        "transform/opacity",
+        [json!(10), json!(90), json!(20)],
+        json!({"apply": "temporal", "frequency": 8, "magnitude": 10}),
+    );
+}
+
+#[test]
+fn smoother_preserves_locked_keys_in_mixed_selection() {
+    selection_command_skips_locked_keys("keys.smooth", "transform/opacity", [json!(10), json!(50), json!(90)], json!({"tolerance": 1}));
+}
+
+#[test]
+fn exponential_scale_preserves_locked_keys_in_mixed_selection() {
+    selection_command_skips_locked_keys(
+        "keys.exponentialScale",
+        "transform/scale",
+        [json!([100, 100, 100]), json!([150, 150, 150]), json!([400, 400, 400])],
+        json!({}),
+    );
+}
+
+#[test]
+fn edit_label_preserves_locked_keys_in_mixed_selection() {
+    selection_command_skips_locked_keys("edit.label", "transform/opacity", [json!(10), json!(50), json!(90)], json!({"label": "Red"}));
+    selection_command_skips_locked_keys("edit.label", "transform/opacity", [json!(10), json!(50), json!(90)], json!({"label": "Red", "keys": true}));
+}
+
 #[test]
 fn wiggle_adds_keys_at_frequency_within_magnitude() {
     let (mut s, l) = setup();
diff --git a/crates/engine/src/tests/blender.rs b/crates/engine/src/tests/blender.rs
new file mode 100644
index 000000000..84e939055
--- /dev/null
+++ b/crates/engine/src/tests/blender.rs
@@ -0,0 +1,261 @@
+//! Synthetic camera interchange: projection, timing, DOF and hostile inputs. Optional public
+//! Blender-API oracle: EFFECTCRAFT_BLENDER=/path/to/blender cargo test -p effectcraft-engine tests::blender -- --nocapture.
+
+use effectcraft_effects::camera_tracker as ct;
+use effectcraft_keyframe::Value as KV;
+use effectcraft_project::{Footage, FootageKind, ItemKind, LayerId, LayerSource, build};
+use effectcraft_time::{FrameRate, Tick};
+use effectcraft_track::camtrack::{CameraSolve, Distortion, Ground, ShotType, SolveMethod, SolvedFrame, SolvedPoint};
+use serde_json::{Value, json};
+
+use crate::Session;
+
+fn path(name: &str) -> String {
+    let dir = std::env::temp_dir().join(format!("effectcraft-blender-tests-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    dir.join(name).to_string_lossy().into_owned()
+}
+
+fn fixture(ground: bool) -> (Session, LayerId, u64) {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Shot '\\ — câmera", "width": 640, "height": 360, "duration": 6})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let rate = FrameRate::new(30000, 1001);
+    let lid = s
+        .edit("fixture", None, |p, _| {
+            p.comp_mut(cid).unwrap().frame_rate = rate;
+            let item = p.add_item(
+                "Plate",
+                Default::default(),
+                None,
+                ItemKind::Footage(Footage {
+                    path: std::env::var("EFFECTCRAFT_BLENDER_PLATE").unwrap_or_else(|_| path("plate '\\ — vídeo.mp4")),
+                    width: 640,
+                    height: 360,
+                    frame_rate: FrameRate::FPS_30,
+                    duration: Tick::from_seconds_f64(6.0),
+                    kind: FootageKind::Video,
+                    has_video: true,
+                    ..Default::default()
+                }),
+            );
+            let comp = p.comp(cid).unwrap().clone();
+            let mut layer = build::layer(p, &comp, "Tracked Video", LayerSource::Footage { item }, (640, 360), None);
+            layer.in_point = rate.tick_of(60);
+            layer.out_point = rate.tick_of(63);
+            layer.start_time = rate.tick_of(30);
+            layer.stretch = 200.0;
+            let id = layer.id;
+            p.comp_mut(cid).unwrap().layers.push(layer);
+            Ok(id)
+        })
+        .unwrap();
+    let uid = s.execute("effect.apply", json!({"effect": ct::ID, "layers": [lid.0]})).unwrap()["effects"][0].as_u64().unwrap();
+    let solve = CameraSolve {
+        version: 1,
+        size: [640.0, 360.0],
+        start: rate.tick_of(30).seconds() / 2.0,
+        frame_duration: rate.frame_duration().seconds() / 2.0,
+        shot: ShotType::VariableZoom,
+        method_used: SolveMethod::Typical,
+        average_error: 0.12,
+        frames: (0..3)
+            .map(|i| SolvedFrame {
+                rot: [0.02 * i as f64, -0.03 * i as f64, 0.01 * i as f64],
+                center: [0.1 * i as f64, -0.01 * i as f64, 0.02 * i as f64],
+                focal: 600.0 + i as f64 * 25.0,
+                solved: true,
+            })
+            .collect(),
+        points: vec![
+            SolvedPoint { id: 7, pos: [0.1, 0.2, 2.0], error: 0.13, first: 0, last: 2 },
+            SolvedPoint { id: 9, pos: [-0.3, -0.1, 1.2], error: 0.11, first: 0, last: 1 },
+        ],
+        ground: ground.then_some(Ground { origin: [0.1, 0.2, 2.0], normal: [0.0, -1.0, 0.0], x_axis: [1.0, 0.0, 0.0] }),
+        distortion: ground.then_some(Distortion { k1: 0.01, k2: -0.002, radius: 320.0_f64.hypot(180.0) }),
+    };
+    // Directly install a deterministic solve; no analysis or decoder is needed by these tests.
+    s.execute("prop.set", json!({"layer": lid.0, "path": "effects/#1/solve", "value": solve.to_json()})).unwrap();
+    s.camera_pending.clear();
+    s.execute("layer.select", json!({"layers": [lid.0]})).unwrap();
+    (s, lid, uid)
+}
+
+fn data(script: &str) -> Value {
+    let line = script.lines().find_map(|l| l.strip_prefix("DATA = json.loads(")).unwrap().strip_suffix(')').unwrap();
+    let encoded: String = serde_json::from_str(line).unwrap();
+    serde_json::from_str(&encoded).unwrap()
+}
+
+#[test]
+fn blender_export_bakes_projection_focus_and_retimed_background() {
+    let (mut s, lid, uid) = fixture(true);
+    let result = s.execute("camera.create", json!({"layer": lid.0, "effect": uid})).unwrap();
+    let camera = result["camera"].as_u64().unwrap();
+    s.execute("layer.cameraSettings", json!({"layer": camera, "focusDistance": 800.0, "dof": true, "fStop": 4.0, "lockToZoom": false})).unwrap();
+    for (frame, value) in [(60, 800.0), (62, 1000.0)] {
+        let time = FrameRate::new(30000, 1001).tick_of(frame).seconds();
+        s.execute("prop.addKey", json!({"layer": camera, "path": "cameraOptions/focusDistance", "time": time, "value": value})).unwrap();
+    }
+    let camera_layer = s.active_comp().unwrap().layer(LayerId(camera)).unwrap();
+    assert!(camera_layer.props.prop("cameraOptions/dof").unwrap().value.as_bool());
+    let output = path("oracle-scene.py");
+    let before = s.project.to_json();
+    let r = s.execute_checked("camera.exportBlender", json!({"layer": lid.0, "effect": uid, "path": output, "startFrame": 101})).unwrap();
+    assert_eq!(s.project.to_json(), before, "export must not edit the document");
+    assert_eq!(r["frames"], 3);
+    assert_eq!(r["points"], 2);
+    let script = std::fs::read_to_string(&output).unwrap();
+    let d = data(&script);
+    assert_eq!(d["resolution"], json!([640.0, 360.0]));
+    assert_eq!(d["fpsNumerator"], 30000);
+    assert_eq!(d["fpsDenominator"], 1001);
+    assert_eq!(d["frames"][0]["sourceFrame"], 15, "trim + 200% stretch, not scene frame 101");
+    assert_eq!(d["frames"][2]["sourceFrame"], 16);
+    assert_eq!(d["frames"][0]["focus"], 8.0);
+    assert_eq!(d["frames"][2]["focus"], 10.0);
+    assert_eq!(d["frames"][0]["dof"], true);
+    assert!((d["frames"][0]["fstop"].as_f64().unwrap() - 4.0).abs() < 1e-6);
+    assert_eq!(d["frames"][0]["lens"], 33.75);
+    assert_eq!(d["frames"][2]["lens"], 36.5625);
+    assert_eq!(d["ground"], true);
+    assert_eq!(d["solve"]["distortion"]["k1"], 0.01);
+    assert_eq!(d["points"][0]["location"][2], 0.0, "ground point lies on Blender XY plane");
+
+    // Execute the actual exported artifact in a separately installed Blender, when requested.
+    if let Ok(blender) = std::env::var("EFFECTCRAFT_BLENDER") {
+        let oracle = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/blender_scene_oracle.py");
+        let output = std::process::Command::new(blender)
+            .args(["--background", "--factory-startup", "--python-exit-code", "1", "--python"])
+            .arg(oracle)
+            .arg("--")
+            .arg(&output)
+            .output()
+            .unwrap();
+        assert!(output.status.success(), "Blender oracle failed:\n{}\n{}", String::from_utf8_lossy(&output.stdout), String::from_utf8_lossy(&output.stderr));
+        assert!(String::from_utf8_lossy(&output.stdout).contains("EFFECTCRAFT_BLENDER_ORACLE_OK"));
+    }
+}
+
+#[test]
+fn blender_export_bakes_reverse_time_remap_and_footage_loops() {
+    let (mut s, lid, _) = fixture(false);
+    let cid = s.active_comp_id().unwrap();
+    let rate = FrameRate::new(30000, 1001);
+    s.edit("retimed fixture", None, |p, _| {
+        let layer = p.comp(cid).unwrap().layer(lid).unwrap();
+        let item = layer.source.item().unwrap();
+        let keys = [(60, 8.0), (61, 6.0), (62, -1.0)]
+            .map(|(frame, time)| effectcraft_keyframe::Keyframe::new(layer.layer_time(rate.tick_of(frame)), KV::Scalar(time)));
+        let mut remap = build::Ids(&mut p.next_id).prop("timeRemap", "Time Remap", KV::Scalar(8.0));
+        remap.keys = keys.to_vec();
+        p.comp_mut(cid).unwrap().layer_mut(lid).unwrap().props.children.push(remap.into());
+        if let ItemKind::Footage(f) = &mut p.item_mut(item).unwrap().kind {
+            f.loop_count = 2;
+        }
+        Ok(())
+    })
+    .unwrap();
+    let output = path("remap.py");
+    s.execute_checked("camera.exportBlender", json!({"layer": lid.0, "path": output})).unwrap();
+    let d = data(&std::fs::read_to_string(output).unwrap());
+    let indices: Vec<i64> = d["frames"].as_array().unwrap().iter().map(|f| f["sourceFrame"].as_i64().unwrap()).collect();
+    assert_eq!(indices, vec![60, 0, 0], "reverse remap wraps the 6-second video and clamps negative source time, as the media pool does");
+}
+
+#[test]
+fn blender_export_defaults_and_script_escaping() {
+    let (mut s, lid, _) = fixture(false);
+    let output = path("escaped.py");
+    let r = s
+        .execute_checked("camera.exportBlender", json!({"layer": lid.0, "path": output, "includePoints": false, "sensorWidth": 24.0, "unitScale": 0.1}))
+        .unwrap();
+    assert_eq!(r["points"], 0);
+    let script = std::fs::read_to_string(&output).unwrap();
+    let d = data(&script);
+    assert!(d["name"].as_str().unwrap().contains("'\\ — câmera"));
+    assert_eq!(d["frames"][0]["lens"], 22.5);
+    assert_eq!(d["frames"][0]["dof"], false);
+    assert!(r["warnings"].as_array().unwrap().iter().any(|w| w.as_str().unwrap().contains("cannot be recovered")));
+    match std::process::Command::new("python3").args(["-c", "import ast,sys; ast.parse(open(sys.argv[1], encoding='utf-8').read())", &output]).status() {
+        Ok(status) => assert!(status.success(), "generated script must parse even with quoted/Unicode paths"),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => eprintln!("Python AST oracle skipped: python3 is not installed"),
+        Err(e) => panic!("Python AST oracle failed: {e}"),
+    }
+}
+
+#[test]
+fn blender_export_rejects_invalid_arguments_and_write_failures() {
+    let (mut s, lid, _) = fixture(false);
+    for params in [
+        json!({"sensorWidth": 0}),
+        json!({"sensorWidth": "wide"}),
+        json!({"unitScale": -1}),
+        json!({"startFrame": -1}),
+        json!({"startFrame": 1.5}),
+        json!({"startFrame": 1048574}),
+        json!({"includePoints": "yes"}),
+        json!({"bogus": true}),
+        json!({"path": path("bad.blend")}),
+    ] {
+        let mut p = json!({"layer": lid.0, "path": path("invalid.py")});
+        p.as_object_mut().unwrap().extend(params.as_object().unwrap().clone());
+        assert!(s.execute_checked("camera.exportBlender", p.clone()).is_err(), "must reject {p}");
+    }
+    let blocker = path("blocker");
+    std::fs::write(&blocker, b"not a directory").unwrap();
+    let p = format!("{blocker}/scene.py");
+    assert!(s.execute_checked("camera.exportBlender", json!({"layer": lid.0, "path": p})).unwrap_err().to_string().contains("cannot write"));
+}
+
+#[test]
+fn blender_export_rejects_malformed_solves_without_panicking() {
+    for variant in ["empty", "unsolved", "zero-focal", "bad-ground", "huge-resolution", "mismatched-range"] {
+        let (mut s, lid, uid) = fixture(false);
+        let cid = s.active_comp_id().unwrap();
+        let mut solve = ct::solve(&crate::camera_track::static_params(s.active_comp().unwrap().layer(lid).unwrap().props.find_group(uid).unwrap()))
+            .unwrap()
+            .as_ref()
+            .clone();
+        match variant {
+            "empty" => solve.frames.clear(),
+            "unsolved" => solve.frames[0].solved = false,
+            "zero-focal" => solve.frames[0].focal = 0.0,
+            "bad-ground" => solve.ground = Some(Ground::default()),
+            "huge-resolution" => solve.size[0] = 1e10,
+            _ => {
+                solve.frames.pop();
+            }
+        }
+        s.edit("corrupt solve", None, |p, _| {
+            p.comp_mut(cid).unwrap().layer_mut(lid).unwrap().props.find_group_mut(uid).unwrap().prop_mut(ct::SOLVE).unwrap().value = KV::Str(solve.to_json());
+            Ok(())
+        })
+        .unwrap();
+        s.camera_pending.clear();
+        let result = s.execute_checked("camera.exportBlender", json!({"layer": lid.0, "path": path("corrupt.py")}));
+        assert!(result.is_err(), "must reject {variant}");
+    }
+}
+
+#[test]
+fn blender_export_respects_script_write_permission() {
+    let (mut s, lid, _) = fixture(false);
+    let output = path("script-permissions.py");
+    let params = json!({"layer": lid.0, "path": output});
+    for (from_script, allowed) in [(true, false), (true, true), (false, false), (false, true)] {
+        std::fs::write(&output, b"existing file").unwrap();
+        s.prefs.scripting.allow_scripts_write_files = allowed;
+        let result =
+            if from_script { s.execute_for_script("camera.exportBlender", params.clone()) } else { s.execute_checked("camera.exportBlender", params.clone()) };
+        assert!(!s.running_for_script(), "script origin must be restored after success or error");
+        let contents = std::fs::read_to_string(&output).unwrap();
+        if from_script && !allowed {
+            assert!(result.unwrap_err().to_string().contains("Allow Scripts to Write Files"));
+            assert_eq!(contents, "existing file", "blocked scripts must not replace an existing file");
+        } else {
+            assert_eq!(result.unwrap()["frames"], 3);
+            assert!(contents.contains("def import_scene():"));
+        }
+    }
+}
diff --git a/crates/engine/src/tests_camera_track.rs b/crates/engine/src/tests/camera_track.rs
similarity index 87%
rename from crates/engine/src/tests_camera_track.rs
rename to crates/engine/src/tests/camera_track.rs
index 5bd5539c1..3ca8578a9 100644
--- a/crates/engine/src/tests_camera_track.rs
+++ b/crates/engine/src/tests/camera_track.rs
@@ -3,7 +3,7 @@
 
 use effectcraft_effects::camera_tracker as ct;
 use effectcraft_geom::vec3;
-use effectcraft_project::LayerId;
+use effectcraft_project::{Comp, Layer, LayerId, PropGroup};
 use effectcraft_raster::Image;
 use effectcraft_render::EvalCtx;
 use effectcraft_render::three_d::camera::active_camera;
@@ -11,7 +11,8 @@ use effectcraft_track::camtrack::linalg::{self, M3, V3};
 use serde_json::{Value, json};
 
 use crate::Session;
-use crate::tests_track::{H, W, frame_time, setup, texture};
+use crate::camera_track::Placed;
+use crate::tests::track::{H, W, frame_time, setup, texture};
 
 const F: f64 = 260.0;
 
@@ -77,10 +78,9 @@ fn status(s: &mut Session) -> Value {
     s.execute("camera.solveStatus", json!({})).unwrap()
 }
 
-#[test]
-fn track_camera_solves_and_creates_layers_on_the_plane() {
-    let (mut s, clip) = tracked(json!({}));
-    let st = status(&mut s);
+/// Solved with a sane error and focal length; returns the Camera Tracker effect group.
+fn assert_solved(s: &mut Session, clip: LayerId) -> PropGroup {
+    let st = status(s);
     assert_eq!(st["solved"], true, "{st}");
     let err = st["averageError"].as_f64().unwrap();
     assert!(err < 0.5, "average error {err}");
@@ -90,9 +90,12 @@ fn track_camera_solves_and_creates_layers_on_the_plane() {
     // Method Used / Average Error are reported in the effect.
     let g = s.active_comp().unwrap().layer(clip).unwrap().effects().unwrap().groups().next().unwrap().clone();
     assert!(matches!(g.prop(ct::METHOD_USED).map(|p| &p.value), Some(effectcraft_keyframe::Value::Str(m)) if !m.is_empty()));
+    g
+}
 
-    // Pick floor points on frame 12 (their 3D positions lie on y = 1.5 in the true scene: the
-    // ones seen below the horizon at the bottom of the frame).
+/// Pick floor points on frame 12 (their 3D positions lie on y = 1.5 in the true scene: the
+/// ones seen below the horizon at the bottom of the frame).
+fn select_floor_points(s: &mut Session) -> Vec<u64> {
     s.execute("time.set", json!({"time": frame_time(12).seconds()})).unwrap();
     let pts = s.execute("camera.points", json!({})).unwrap();
     let list = pts["points"].as_array().unwrap();
@@ -101,32 +104,19 @@ fn track_camera_solves_and_creates_layers_on_the_plane() {
     assert!(floor.len() >= 3, "{floor:?}");
     s.execute("camera.selectPoints", json!({"points": floor})).unwrap();
     assert_eq!(s.state.camera_points.len(), floor.len());
+    floor
+}
 
-    // Create Solid and Camera: one undo step, camera + solid.
-    let r = s.execute_checked("camera.createFromSolve", json!({"kind": "solid"})).unwrap();
-    let cam = LayerId(r["camera"].as_u64().unwrap());
-    let solid = LayerId(r["layers"][0].as_u64().unwrap());
-    let comp = s.active_comp().unwrap().clone();
-    assert!(comp.layer(cam).unwrap().is_camera());
-    assert_eq!(comp.layer(cam).unwrap().name, "3D Tracker Camera");
-    assert_eq!(comp.layers[0].id, cam);
-    let sl = comp.layer(solid).unwrap();
-    assert!(sl.switches.three_d);
-    assert!(sl.name.starts_with("Track Solid"));
-    // The camera is keyed on every frame.
-    assert_eq!(comp.layer(cam).unwrap().props.prop("transform/position").unwrap().keys.len(), 25);
-
-    // Every solved point projects through the created camera exactly where the solve puts it,
-    // and onto its tracked position (the footage fills the comp, so layer pixels are comp
-    // pixels): within 1 px for 95 % of the observations (the rest are the solve's outliers:
-    // features on occlusion edges), 0.5 px on average.
+/// Every solved point projects through the created camera exactly where the solve puts it,
+/// and onto its tracked position (the footage fills the comp, so layer pixels are comp
+/// pixels): within 1 px for 95 % of the observations (the rest are the solve's outliers:
+/// features on occlusion edges), 0.5 px on average.
+fn assert_reprojection(s: &Session, comp: &Comp, pl: &Placed, g: &PropGroup) {
     let cid = s.active_comp_id().unwrap();
-    let uid = g.uid;
-    let pl = crate::camera_track::placed(&s.project, cid, clip, uid).unwrap();
-    let tracks = ct::tracks(&crate::camera_track::static_params(&g)).unwrap();
+    let tracks = ct::tracks(&crate::camera_track::static_params(g)).unwrap();
     let mut errs = vec![];
     for k in [0u32, 6, 12, 18, 24] {
-        let ctx = EvalCtx::new(&s.project, cid, &comp, frame_time(k));
+        let ctx = EvalCtx::new(&s.project, cid, comp, frame_time(k));
         let camst = active_camera(&ctx);
         for sp in pl.solve.visible(k as usize) {
             let Some(obs) = tracks.track(sp.id).and_then(|t| t.at(k)) else { continue };
@@ -142,34 +132,31 @@ fn track_camera_solves_and_creates_layers_on_the_plane() {
     let p95 = errs[errs.len() * 95 / 100];
     let mean = errs.iter().sum::<f64>() / errs.len() as f64;
     assert!(p95 < 1.0 && mean < 0.5, "p95 {p95} px, mean {mean} px");
+}
 
-    // The solid lies on the selected points' plane.
+/// The solid lies on the selected points' plane and faces the camera.
+fn assert_solid_on_plane(s: &Session, comp: &Comp, sl: &Layer, pl: &Placed, size: f64) {
+    let cid = s.active_comp_id().unwrap();
     let tr = sl.props.sub("transform").unwrap();
     let pos = tr.get("position").unwrap().value.as_vec3();
     let ori = tr.get("orientation").unwrap().value.as_vec3();
     let normal = linalg::mv(&linalg::from_euler_xyz(ori), [0.0, 0.0, -1.0]);
-    let size = r["target"]["size"].as_f64().unwrap();
     for id in &s.state.camera_points {
         let w = pl.to_world(pl.solve.point(*id).unwrap().pos);
         let d = linalg::dot(linalg::sub(w, pos), normal).abs();
         assert!(d < 0.05 * size.max(1.0) + 1.0, "point {id} is {d} px off the plane");
     }
-    // The solid faces the camera.
-    let ctx = EvalCtx::new(&s.project, cid, &comp, frame_time(12));
+    let ctx = EvalCtx::new(&s.project, cid, comp, frame_time(12));
     let eye = active_camera(&ctx).eye;
     assert!(linalg::dot(normal, linalg::sub([eye.x, eye.y, eye.z], pos)) > 0.0);
+}
 
-    // Undo removes both layers; redo brings them back.
-    let before = comp.layers.len();
-    assert!(s.undo());
-    assert_eq!(s.active_comp().unwrap().layers.len(), before - 2);
-    assert!(s.redo());
-    assert_eq!(s.active_comp().unwrap().layers.len(), before);
-
-    // A second create reuses the camera: Create Multiple Nulls and Camera.
+/// A second create reuses the camera (Create Multiple Nulls and Camera), then Text and
+/// Shadow Catcher (+ light).
+fn assert_create_kinds(s: &mut Session, cam: LayerId, n_floor: usize) {
     let r = s.execute_checked("camera.createFromSolve", json!({"kind": "null", "multiple": true})).unwrap();
     assert_eq!(r["camera"].as_u64().unwrap(), cam.0);
-    assert_eq!(r["layers"].as_array().unwrap().len(), floor.len());
+    assert_eq!(r["layers"].as_array().unwrap().len(), n_floor);
     // Text and Shadow Catcher (+ light).
     let r = s.execute_checked("camera.createFromSolve", json!({"kind": "text"})).unwrap();
     assert_eq!(r["layers"].as_array().unwrap().len(), 1);
@@ -180,11 +167,12 @@ fn track_camera_solves_and_creates_layers_on_the_plane() {
     assert_eq!(comp.layer(ids[0]).unwrap().props.prop("materialOptions/acceptsShadows").unwrap().value.as_enum(), 2);
     assert!(comp.layer(ids[1]).unwrap().is_light());
     assert!(s.execute_checked("camera.createFromSolve", json!({"kind": "teapot"})).is_err());
+}
 
-    // Set Ground Plane and Origin: the target becomes the origin; a null created there sits at
-    // (0, 0, 0) lying on the X-Z plane (its front facing up, −y).
+/// Set Ground Plane and Origin, then an explicit target.
+fn assert_ground_and_target(s: &mut Session) {
     s.execute_checked("camera.setGroundPlane", json!({})).unwrap();
-    assert_eq!(status(&mut s)["groundPlane"], true);
+    assert_eq!(status(s)["groundPlane"], true);
     let r = s.execute_checked("camera.createFromSolve", json!({"kind": "null"})).unwrap();
     let null = LayerId(r["layers"][0].as_u64().unwrap());
     let tr = s.active_comp().unwrap().layer(null).unwrap().props.sub("transform").unwrap().clone();
@@ -203,6 +191,44 @@ fn track_camera_solves_and_creates_layers_on_the_plane() {
     assert!(linalg::norm(linalg::sub(pos, [10.0, 0.0, 20.0])) < 1e-6, "{pos:?}");
     let front = linalg::mv(&linalg::from_euler_xyz(tr.get("orientation").unwrap().value.as_vec3()), [0.0, 0.0, -1.0]);
     assert!(linalg::norm(linalg::sub(front, [0.0, 0.0, -1.0])) < 1e-6, "{front:?}");
+}
+
+#[test]
+fn track_camera_solves_and_creates_layers_on_the_plane() {
+    let (mut s, clip) = tracked(json!({}));
+    let g = assert_solved(&mut s, clip);
+    let floor = select_floor_points(&mut s);
+
+    // Create Solid and Camera: one undo step, camera + solid.
+    let r = s.execute_checked("camera.createFromSolve", json!({"kind": "solid"})).unwrap();
+    let cam = LayerId(r["camera"].as_u64().unwrap());
+    let solid = LayerId(r["layers"][0].as_u64().unwrap());
+    let comp = s.active_comp().unwrap().clone();
+    assert!(comp.layer(cam).unwrap().is_camera());
+    assert_eq!(comp.layer(cam).unwrap().name, "3D Tracker Camera");
+    assert_eq!(comp.layers[0].id, cam);
+    let sl = comp.layer(solid).unwrap();
+    assert!(sl.switches.three_d);
+    assert!(sl.name.starts_with("Track Solid"));
+    // The camera is keyed on every frame.
+    assert_eq!(comp.layer(cam).unwrap().props.prop("transform/position").unwrap().keys.len(), 25);
+
+    let cid = s.active_comp_id().unwrap();
+    let uid = g.uid;
+    let pl = crate::camera_track::placed(&s.project, cid, clip, uid).unwrap();
+    assert_reprojection(&s, &comp, &pl, &g);
+    assert_solid_on_plane(&s, &comp, sl, &pl, r["target"]["size"].as_f64().unwrap());
+
+    // Undo removes both layers; redo brings them back.
+    let before = comp.layers.len();
+    assert!(s.undo());
+    assert_eq!(s.active_comp().unwrap().layers.len(), before - 2);
+    assert!(s.redo());
+    assert_eq!(s.active_comp().unwrap().layers.len(), before);
+
+    assert_create_kinds(&mut s, cam, floor.len());
+
+    assert_ground_and_target(&mut s);
 
     // Serde keeps the analysis.
     let back = effectcraft_project::Project::from_json(&s.project.to_json()).unwrap();
diff --git a/crates/engine/src/tests_codec_options.rs b/crates/engine/src/tests/codec_options.rs
similarity index 100%
rename from crates/engine/src/tests_codec_options.rs
rename to crates/engine/src/tests/codec_options.rs
diff --git a/crates/engine/src/tests_color_view.rs b/crates/engine/src/tests/color_view.rs
similarity index 100%
rename from crates/engine/src/tests_color_view.rs
rename to crates/engine/src/tests/color_view.rs
diff --git a/crates/engine/src/tests/crypto_pick.rs b/crates/engine/src/tests/crypto_pick.rs
new file mode 100644
index 000000000..2e61f57a1
--- /dev/null
+++ b/crates/engine/src/tests/crypto_pick.rs
@@ -0,0 +1,796 @@
+//! `effect.pickCryptomatte` / `effect.cryptomatteAt` (#473): the Cryptomatte eyedropper reads the
+//! aux channels the effect renders from (footage at its source time, a 3D precomp's generated
+//! pass) and edits the Selection text in one undo step.
+
+use std::sync::Arc;
+
+use effectcraft_project::{Footage, FootageKind, ItemId};
+use effectcraft_raster::channels3d::{crypto_float, crypto_hash};
+use effectcraft_raster::{AuxChannels, Image};
+use effectcraft_time::{FrameRate, Tick};
+use serde_json::{Value, json};
+
+use crate::Session;
+use crate::render::FootageSource;
+
+const COMMA: &str = "Green, \"Glossy\"";
+
+/// 8 × 4 footage with a 16 × 8 Cryptomatte (two aux pixels per layer pixel). Layer pixels in x:
+/// 0-1 `left` (0.6) over `right` (0.4); 2-3 `left` (0.3) under the comma name (0.7), ranks out of
+/// order; 4-5 `star*`; 6 an ID missing from the manifest; 7 a 0.5 / 0.5 tie of `left` and
+/// `right`. Rows 3+ are empty. From 1 s of source time `late` replaces columns 0-1.
+struct Crypto;
+
+fn aux_at(t: Tick) -> AuxChannels {
+    let (w, h) = (16usize, 8usize);
+    let mut planes = vec![vec![0.0f32; w * h]; 4];
+    for (i, x) in (0..w * h).map(|i| (i, i % w)).filter(|(i, _)| i / w < 6) {
+        let late = if t >= Tick::from_seconds_f64(1.0) { "late" } else { "left" };
+        let (a, ca, b, cb) = match x {
+            0..4 => (late, 0.6, "right", 0.4),
+            4..8 => ("left", 0.3, COMMA, 0.7),
+            8..12 => ("star*", 1.0, "", 0.0),
+            12..14 => ("ghost", 1.0, "", 0.0),
+            _ => ("left", 0.5, "right", 0.5),
+        };
+        for (k, v) in [crypto_float(crypto_hash(a)), ca, crypto_float(crypto_hash(b)), cb].into_iter().enumerate() {
+            planes[k][i] = v;
+        }
+    }
+    let mut aux = AuxChannels::new(w as u32, h as u32, 1.0);
+    for (k, c) in ["R", "G", "B", "A"].iter().enumerate() {
+        aux.channels.push((format!("CryptoObject00.{c}"), planes[k].clone()));
+    }
+    aux.manifests = vec![("CryptoObject".into(), ["left", "right", "late", COMMA, "star*"].iter().map(|n| (n.to_string(), crypto_hash(n))).collect())];
+    aux
+}
+
+impl FootageSource for Crypto {
+    fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
+        Some(Arc::new(Image::new(f.width, f.height)))
+    }
+    fn aux(&self, _: ItemId, _: &Footage, t: Tick) -> Option<Arc<AuxChannels>> {
+        Some(Arc::new(aux_at(t)))
+    }
+}
+
+struct Probe;
+impl crate::Importer for Probe {
+    fn probe(&self, path: &str) -> Result<Footage, String> {
+        let duration = Tick::from_seconds_f64(2.0);
+        // A half-size proxy of the EXR.
+        let (width, height) = if path.contains("proxy") { (4, 2) } else { (8, 4) };
+        Ok(Footage {
+            path: path.into(),
+            kind: FootageKind::Video,
+            width,
+            height,
+            has_video: true,
+            frame_rate: FrameRate::from_f64(24.0),
+            duration,
+            ..Default::default()
+        })
+    }
+}
+
+fn session() -> Session {
+    let mut s = Session { footage: Arc::new(Crypto), importer: Some(Arc::new(Probe)), ..Default::default() };
+    let item = s.execute("file.import", json!({"paths": ["/renders/crypto.exr"]})).unwrap()["items"][0].clone();
+    s.execute("comp.new", json!({"name": "C", "width": 8, "height": 4, "frameRate": 24, "duration": 2})).unwrap();
+    s.execute("layer.addItem", json!({"item": item})).unwrap();
+    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
+    s
+}
+
+fn pick(s: &mut Session, x: f64, mode: &str) -> Value {
+    s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": x, "y": 1.5, "mode": mode})).unwrap()
+}
+
+fn selection(s: &Session) -> String {
+    let l = &s.active_comp().unwrap().layers[0];
+    let g = l.effects().unwrap().groups().next().unwrap();
+    match &g.prop("selection").unwrap().value {
+        effectcraft_keyframe::Value::Str(t) => t.clone(),
+        v => panic!("{v:?}"),
+    }
+}
+
+#[test]
+fn picks_replace_add_and_remove_in_one_undo_step_each() {
+    let mut s = session();
+    let steps = s.history.undo.len();
+    let r = pick(&mut s, 0.5, "replace");
+    assert_eq!((r["name"].as_str(), r["selection"].as_str(), r["changed"].as_bool()), (Some("left"), Some("left"), Some(true)), "{r}");
+    assert_eq!(r["hash"], format!("{:08x}", crypto_hash("left")));
+    assert_eq!(s.history.undo.len(), steps + 1);
+    // The highest coverage wins even when it is not rank 0; the name is quoted.
+    assert_eq!(pick(&mut s, 2.5, "add")["selection"], r#"left, "Green, \"Glossy\"""#);
+    // Adding it again changes nothing and leaves no undo step.
+    let again = pick(&mut s, 3.5, "add");
+    assert_eq!((again["changed"].as_bool(), s.history.undo.len()), (Some(false), steps + 2));
+    // A `*` name and an unnamed ID go in as hashes; a tie goes to rank 0.
+    pick(&mut s, 4.5, "add");
+    assert_eq!(pick(&mut s, 6.5, "add")["selection"], format!(r#"left, "Green, \"Glossy\"", <{:08x}>, <{:08x}>"#, crypto_hash("star*"), crypto_hash("ghost")));
+    assert_eq!(s.execute("effect.cryptomatteAt", json!({"effect": 1, "x": 7.5, "y": 0.5})).unwrap()["name"], "left");
+    let r = pick(&mut s, 0.0, "remove");
+    assert_eq!(r["selection"], format!(r#""Green, \"Glossy\"", <{:08x}>, <{:08x}>"#, crypto_hash("star*"), crypto_hash("ghost")));
+    assert_eq!(r["selected"], false);
+    // The text parses back to exactly the picked IDs.
+    let manifest = aux_at(Tick::ZERO).manifests[0].1.clone();
+    let got = effectcraft_effects::selection_hashes(&selection(&s), Some(&manifest));
+    assert_eq!(got, [COMMA, "star*", "ghost"].map(crypto_hash));
+    assert_eq!(s.history.undo.len(), steps + 5);
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(selection(&s).starts_with("left, "), "{}", selection(&s));
+    pick(&mut s, 2.0, "replace");
+    assert_eq!(selection(&s), r#""Green, \"Glossy\"""#);
+    // The same selection with other spacing: no change, no undo step.
+    s.execute_checked("prop.set", json!({"path": "effects/#1/selection", "value": " \"Green, \\\"Glossy\\\"\" "})).unwrap();
+    let n = s.history.undo.len();
+    assert_eq!((pick(&mut s, 2.0, "replace")["changed"].as_bool(), s.history.undo.len()), (Some(false), n));
+}
+
+#[test]
+fn bad_points_layers_and_modes_are_errors_and_change_nothing() {
+    let mut s = session();
+    let at = |s: &mut Session, x: f64, y: f64| s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": x, "y": y}));
+    for (x, y) in [(-0.1, 1.0), (8.0, 1.0), (1.0, 4.0), (1.0, 3.5), (1e300, -1e300)] {
+        assert!(at(&mut s, x, y).is_err(), "{x},{y}");
+        assert_eq!(s.execute("effect.cryptomatteAt", json!({"effect": 1, "x": x, "y": y})).unwrap(), Value::Null);
+    }
+    assert!(s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 1, "y": 1, "mode": "toggle"})).is_err());
+    assert!(s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 1})).is_err());
+    for scale in [0.0, -1.0, 2.0] {
+        assert!(s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 1, "y": 1, "scale": scale})).is_err(), "{scale}");
+    }
+    s.execute_checked("effect.apply", json!({"effect": "Gaussian Blur"})).unwrap();
+    assert!(s.execute_checked("effect.pickCryptomatte", json!({"effect": 2, "x": 1, "y": 1})).is_err(), "not a Cryptomatte effect");
+    assert_eq!(selection(&s), "");
+    // A layer without aux channels.
+    s.execute("layer.newSolid", json!({"name": "S"})).unwrap();
+    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
+    let e = s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 1, "y": 1})).unwrap_err().to_string();
+    assert!(e.contains("no Cryptomatte channels"), "{e}");
+    // An expression-driven Selection would ignore the edit.
+    let mut s = session();
+    s.execute_checked("prop.setExpression", json!({"path": "effects/#1/selection", "expression": "\"right\""})).unwrap();
+    assert!(s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 1, "y": 1})).is_err());
+    assert_eq!(s.execute("effect.cryptomatteAt", json!({"effect": 1, "x": 1, "y": 1})).unwrap()["selected"], false);
+}
+
+/// The pick reads the frame the render shows: Time Remap's source time, not the layer time.
+#[test]
+fn time_remap_picks_the_shown_source_frame() {
+    let mut s = session();
+    assert_eq!(pick(&mut s, 0.5, "replace")["name"], "left");
+    s.execute_checked("layer.enableTimeRemap", json!({})).unwrap();
+    s.execute_checked("prop.set", json!({"path": "timeRemap", "value": 1.5})).unwrap();
+    assert_eq!(pick(&mut s, 0.5, "replace")["name"], "late");
+}
+
+/// A precomp of a 3D comp: the generated CryptoObject pass names its layers.
+#[test]
+fn picks_on_a_precomp_of_a_3d_comp() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Outer", "width": 40, "height": 20, "frameRate": 24, "duration": 1})).unwrap();
+    let l = s.execute("layer.newSolid", json!({"name": "Red, Ball", "width": 40, "height": 20})).unwrap()["layer"].clone();
+    s.execute("layer.setSwitch", json!({"layers": [l], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.precompose", json!({"layers": [l], "name": "Inner"})).unwrap();
+    s.execute("layer.select", json!({"layers": [s.active_comp().unwrap().layers[0].id.0]})).ok();
+    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
+    let r = s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 20, "y": 10})).unwrap();
+    assert_eq!((r["name"].as_str(), r["selection"].as_str()), (Some("Red, Ball"), Some("\"Red, Ball\"")), "{r}");
+}
+
+/// The matte the rendered Cryptomatte effect gives the picked ID at the buffer pixel under
+/// `{x, y}`: the pick has to name the ID the effect's own input buffer samples there.
+fn rendered_matte_of_pick(s: &mut Session, x: f64, y: f64, scale: f64) -> (String, f32) {
+    let r = s.execute_checked("effect.pickCryptomatte", json!({"effect": "Cryptomatte", "x": x, "y": y, "scale": scale, "mode": "replace"})).unwrap();
+    let fx = s.active_comp().unwrap().layers[0].effects().unwrap().groups().position(|g| g.match_id == "ec.3d.cryptomatte").unwrap() + 1;
+    s.execute_checked("prop.set", json!({"path": format!("effects/#{fx}/matteOnly"), "value": true})).unwrap();
+    let (cid, comp) = (s.active_comp_id().unwrap(), s.active_comp().unwrap());
+    let layer = &comp.layers[0];
+    let ctx = effectcraft_render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time: Tick::ZERO,
+        expr: None,
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
+    let buf = s.renderer(effectcraft_render::RenderOpts { scale, ..Default::default() }).content_buf(&ctx, layer).unwrap();
+    let (px, py) = buf.to_px([x, y]);
+    let m = buf.img.get(px.floor() as i64, py.floor() as i64)[0];
+    (r["name"].as_str().unwrap_or("?").to_string(), m)
+}
+
+/// Between 3/4 and full resolution footage keeps its native pixels: at 0.8 the effect samples
+/// layer pixel 2 (the comma name, 0.7) at x = 2.2, not the 0.8-grid pixel snapped back to 1.
+#[test]
+fn pick_at_scale_0_8_matches_the_native_buffer_the_effect_renders() {
+    let mut s = session();
+    let (name, m) = rendered_matte_of_pick(&mut s, 2.2, 1.5, 0.8);
+    assert!(m >= 0.5, "picked {name:?}, but the render gives it matte {m} there");
+    assert_eq!(name, COMMA);
+}
+
+/// A half-size proxy renders a buffer at 0.5 layer pixels per pixel even at full resolution:
+/// x = 6.5 lies in buffer pixel 3, which samples layer x = 7 (the `left` / `right` tie).
+#[test]
+fn pick_on_a_proxy_matches_the_proxy_sized_buffer() {
+    let mut s = session();
+    let item = *s.project.items.iter().find(|(_, i)| matches!(i.kind, effectcraft_project::ItemKind::Footage(_))).unwrap().0;
+    s.execute("file.setProxy", json!({"item": item.0, "path": "/renders/crypto_proxy.exr"})).unwrap();
+    let (name, m) = rendered_matte_of_pick(&mut s, 6.5, 1.5, 1.0);
+    assert!(m >= 0.5, "picked {name:?}, but the render gives it matte {m} there");
+    assert_eq!(name, "left");
+}
+
+/// 1920-px footage with `left` up to x = 120 and `right` after it, and a 104-px proxy.
+struct Edge;
+impl FootageSource for Edge {
+    fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
+        Some(Arc::new(Image::new(f.width, f.height)))
+    }
+    fn aux(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<AuxChannels>> {
+        let (w, h) = (1920usize, 40usize);
+        let mut aux = AuxChannels::new(w as u32, h as u32, 1.0);
+        let ids = (0..w * h).map(|i| crypto_float(crypto_hash(if i % w < 120 { "left" } else { "right" }))).collect();
+        aux.channels = vec![("CryptoObject00.R".into(), ids), ("CryptoObject00.G".into(), vec![1.0; w * h])];
+        aux.manifests = vec![("CryptoObject".into(), ["left", "right"].iter().map(|n| (n.to_string(), crypto_hash(n))).collect())];
+        Some(Arc::new(aux))
+    }
+}
+
+/// Proxy buffer pixel 6's centre maps to layer x = 6.5 / (104 / 1920): 120.0 by division, but
+/// 119.99999999999999 by the reciprocal the effect multiplies with. The pick must agree.
+#[test]
+fn pick_maps_pixel_centres_bit_exactly_as_the_effect() {
+    let mut s = Session { footage: Arc::new(Edge), ..Default::default() };
+    let at = |path: &str, width| Footage {
+        path: path.into(),
+        kind: FootageKind::Video,
+        width,
+        height: 40,
+        has_video: true,
+        frame_rate: FrameRate::from_f64(24.0),
+        duration: Tick::from_seconds_f64(2.0),
+        ..Default::default()
+    };
+    s.importer = Some(Arc::new(EdgeProbe(at("/renders/edge.exr", 1920), at("/renders/edge_proxy.exr", 104))));
+    let item = s.execute("file.import", json!({"paths": ["/renders/edge.exr"]})).unwrap()["items"][0].clone();
+    s.execute("comp.new", json!({"name": "C", "width": 1920, "height": 40, "frameRate": 24, "duration": 2})).unwrap();
+    s.execute("layer.addItem", json!({"item": item})).unwrap();
+    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
+    s.execute("file.setProxy", json!({"item": item, "path": "/renders/edge_proxy.exr"})).unwrap();
+    let (name, m) = rendered_matte_of_pick(&mut s, 118.0, 5.0, 1.0);
+    assert_eq!((name.as_str(), m), ("left", 1.0));
+}
+
+struct EdgeProbe(Footage, Footage);
+impl crate::Importer for EdgeProbe {
+    fn probe(&self, path: &str) -> Result<Footage, String> {
+        Ok(if path.contains("proxy") { self.1.clone() } else { self.0.clone() })
+    }
+}
+
+/// Footage whose decoded frames are `num / den` of the probed size (a file re-rendered at another
+/// resolution, a relinked file): the render stretches them over the layer.
+struct OffNominal(u32, u32);
+impl FootageSource for OffNominal {
+    fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
+        Some(Arc::new(Image::new(f.width * self.0 / self.1, f.height * self.0 / self.1)))
+    }
+    fn aux(&self, _: ItemId, _: &Footage, t: Tick) -> Option<Arc<AuxChannels>> {
+        Some(Arc::new(aux_at(t)))
+    }
+}
+
+/// Points along rows `ys` where the picked ID isn't lit in the rendered matte under the point.
+fn mismatches(s: &mut Session, scales: &[f64], xs: impl Iterator<Item = f64> + Clone, ys: &[f64]) -> Vec<String> {
+    let mut bad = vec![];
+    for &scale in scales {
+        for (x, &y) in ys.iter().flat_map(|y| xs.clone().map(move |x| (x, y))) {
+            if s.execute("effect.cryptomatteAt", json!({"effect": "Cryptomatte", "x": x, "y": y, "scale": scale})).unwrap().is_null() {
+                continue;
+            }
+            let (name, m) = rendered_matte_of_pick(s, x, y, scale);
+            if m < 0.5 {
+                bad.push(format!("scale {scale} ({x:.2}, {y}): picked {name:?}, matte {m}"));
+            }
+        }
+    }
+    bad
+}
+
+const PREVIEW_SCALES: [f64; 7] = [1.0, 0.8, 0.75, 0.74, 0.5, 0.33, 0.25];
+
+/// The pick follows the decoded frame's real size, not the footage's nominal one.
+#[test]
+fn pick_matches_the_render_when_frames_decode_off_nominal_size() {
+    for (num, den) in [(2, 1), (1, 2), (3, 4)] {
+        let mut s = Session { footage: Arc::new(OffNominal(num, den)), importer: Some(Arc::new(Probe)), ..Default::default() };
+        let item = s.execute("file.import", json!({"paths": ["/renders/crypto.exr"]})).unwrap()["items"][0].clone();
+        s.execute("comp.new", json!({"name": "C", "width": 8, "height": 4, "frameRate": 24, "duration": 2})).unwrap();
+        s.execute("layer.addItem", json!({"item": item})).unwrap();
+        s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
+        let bad = mismatches(&mut s, &PREVIEW_SCALES, (0..80).map(|i| i as f64 * 0.1 + 0.05), &[0.3, 1.7, 2.6]);
+        assert!(bad.is_empty(), "decode {num}/{den}: {} mismatches:\n{}", bad.len(), bad.join("\n"));
+    }
+}
+
+/// A precomp of a 3D comp, with and without Preserve Resolution (drawn at full size below full
+/// resolution), behind a disabled effect: the pick names the ID the rendered matte shows.
+#[test]
+fn pick_matches_the_render_on_precomps_with_and_without_preserve_resolution() {
+    for preserve in [false, true] {
+        let mut s = Session::default();
+        s.execute("comp.new", json!({"name": "Outer", "width": 40, "height": 20, "frameRate": 24, "duration": 2})).unwrap();
+        let a = s.execute("layer.newSolid", json!({"name": "A", "width": 40, "height": 20})).unwrap()["layer"].clone();
+        let b = s.execute("layer.newSolid", json!({"name": "B", "width": 7, "height": 20})).unwrap()["layer"].clone();
+        s.execute_checked("prop.set", json!({"layer": b, "path": "transform/position", "value": [3.5, 10, -10]})).unwrap();
+        s.execute("layer.setSwitch", json!({"layers": [a, b], "switch": "threeD", "value": true})).unwrap();
+        s.execute("layer.precompose", json!({"layers": [a, b], "name": "Inner"})).unwrap();
+        let inner = *s.project.items.iter().find(|(_, i)| i.name == "Inner").unwrap().0;
+        s.execute_checked("comp.settings", json!({"comp": inner.0, "preserveResolution": preserve})).unwrap();
+        s.execute("layer.select", json!({"layers": [s.active_comp().unwrap().layers[0].id.0]})).ok();
+        s.execute_checked("effect.apply", json!({"effect": "Gaussian Blur"})).unwrap();
+        s.execute_checked("effect.toggle", json!({"effect": 1, "value": false})).unwrap();
+        s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
+        let bad = mismatches(&mut s, &PREVIEW_SCALES, (0..93).map(|i| i as f64 * 0.15 + 0.05), &[10.0]);
+        assert!(bad.is_empty(), "preserve {preserve}: {} mismatches:\n{}", bad.len(), bad.join("\n"));
+    }
+}
+
+/// `w` × `h` footage whose Cryptomatte has an ID per 37 × 29 px cell (`c<col>_<row>`, all in the
+/// manifest), one aux pixel per layer pixel. Built once, as the media pool keeps decoded aux.
+struct Cells(u32, u32, std::sync::OnceLock<Arc<AuxChannels>>);
+impl Cells {
+    fn name(x: usize, y: usize) -> String {
+        format!("c{}_{}", x / 37, y / 29)
+    }
+}
+impl FootageSource for Cells {
+    fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
+        Some(Arc::new(Image::new(f.width, f.height)))
+    }
+    fn aux(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<AuxChannels>> {
+        Some(self.2.get_or_init(|| Arc::new(self.build())).clone())
+    }
+}
+impl Cells {
+    fn build(&self) -> AuxChannels {
+        let (w, h) = (self.0 as usize, self.1 as usize);
+        let ids = (0..w * h).map(|i| crypto_float(crypto_hash(&Cells::name(i % w, i / w)))).collect();
+        let mut aux = AuxChannels::new(w as u32, h as u32, 1.0);
+        aux.channels = vec![("CryptoObject00.R".into(), ids), ("CryptoObject00.G".into(), vec![1.0; w * h])];
+        let names = (0..w.div_ceil(37)).flat_map(|x| (0..h.div_ceil(29)).map(move |y| Cells::name(x * 37, y * 29)));
+        aux.manifests = vec![("CryptoObject".into(), names.map(|n| (n.clone(), crypto_hash(&n))).collect())];
+        aux
+    }
+}
+
+struct CellsProbe(u32, u32);
+impl crate::Importer for CellsProbe {
+    fn probe(&self, path: &str) -> Result<Footage, String> {
+        // `…_proxy` is a half-size proxy (rounded up); `…still…` a still image.
+        let (width, height) = if path.contains("proxy") { (self.0.div_ceil(2), self.1.div_ceil(2)) } else { (self.0, self.1) };
+        let (frame_rate, duration) = (FrameRate::from_f64(24.0), Tick::from_seconds_f64(2.0));
+        let kind = if path.contains("still") { FootageKind::Still } else { FootageKind::Video };
+        Ok(Footage { path: path.into(), kind, width, height, has_video: true, frame_rate, duration, ..Default::default() })
+    }
+}
+
+fn cells_session(w: u32, h: u32, blur: bool) -> Session {
+    cells_session_at(w, h, blur, "/renders/cells.exr")
+}
+
+fn cells_session_at(w: u32, h: u32, blur: bool, path: &str) -> Session {
+    let mut s = Session { footage: Arc::new(Cells(w, h, Default::default())), importer: Some(Arc::new(CellsProbe(w, h))), ..Default::default() };
+    let item = s.execute("file.import", json!({"paths": [path]})).unwrap()["items"][0].clone();
+    s.execute("comp.new", json!({"name": "C", "width": w, "height": h, "frameRate": 24, "duration": 2})).unwrap();
+    s.execute("layer.addItem", json!({"item": item})).unwrap();
+    if blur {
+        s.execute_checked("effect.apply", json!({"effect": "Gaussian Blur"})).unwrap();
+        s.execute_checked("prop.set", json!({"path": "effects/#1/blurriness", "value": 40.0})).unwrap();
+    }
+    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
+    s
+}
+
+/// Hover latency of `effect.cryptomatteAt` (dev profile): the first call after the viewer's frame
+/// and the next ones, on footage (1080p, 4K, 4K behind a blur) and a 1080p 3D precomp. Run with
+/// `--ignored --nocapture`; it measures, it doesn't assert.
+#[test]
+#[ignore]
+fn hover_latency() {
+    let mut cases: Vec<(&str, Session)> = vec![
+        ("footage 1920x1080", cells_session(1920, 1080, false)),
+        ("footage 3840x2160", cells_session(3840, 2160, false)),
+        ("footage 3840x2160 + blur 40", cells_session(3840, 2160, true)),
+    ];
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Outer", "width": 1920, "height": 1080, "frameRate": 24, "duration": 2})).unwrap();
+    let a = s.execute("layer.newSolid", json!({"name": "A", "width": 1920, "height": 1080})).unwrap()["layer"].clone();
+    let b = s.execute("layer.newSolid", json!({"name": "B", "width": 400, "height": 1080})).unwrap()["layer"].clone();
+    s.execute("layer.setSwitch", json!({"layers": [a, b], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.precompose", json!({"layers": [a, b], "name": "Inner"})).unwrap();
+    s.execute("layer.select", json!({"layers": [s.active_comp().unwrap().layers[0].id.0]})).ok();
+    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
+    cases.push(("3D precomp 1920x1080", s));
+    for (name, mut s) in cases {
+        let cid = s.active_comp_id().unwrap();
+        let _ = s.render(cid, Tick::ZERO, effectcraft_render::RenderOpts::default());
+        let ms: Vec<String> = (0..6)
+            .map(|i| {
+                let t0 = std::time::Instant::now();
+                let r = s.execute("effect.cryptomatteAt", json!({"effect": "Cryptomatte", "x": 100.0 + 40.0 * i as f64, "y": 500.0})).unwrap();
+                assert!(!r.is_null(), "{name}");
+                format!("{:.3}", t0.elapsed().as_secs_f64() * 1e3)
+            })
+            .collect();
+        eprintln!("HOVER {name}: first {} ms, then {} ms", ms[0], ms[1..].join(" / "));
+    }
+}
+
+/// The hover's probe: built off the thread that asks, kept while only the Selection changes,
+/// rebuilt when anything it reads changes, and a job finished for an older state is not used.
+#[test]
+fn hover_probe_is_built_by_a_job_kept_across_picks_and_dropped_on_other_edits() {
+    let mut s = session();
+    let q = json!({"effect": 1, "x": 0.5, "y": 1.5});
+    let job = s.crypto_probe_job(&q).unwrap().expect("nothing built yet");
+    std::thread::spawn(job).join().unwrap();
+    assert!(s.crypto_probe_job(&q).unwrap().is_none(), "built");
+    assert_eq!(s.execute("effect.cryptomatteAt", q.clone()).unwrap()["name"], "left");
+    // Another scale or time is another probe.
+    assert!(s.crypto_probe_job(&json!({"effect": 1, "x": 0.5, "y": 1.5, "scale": 0.5})).unwrap().is_some());
+    assert!(s.crypto_probe_job(&json!({"effect": 1, "x": 0.5, "y": 1.5, "time": 1.0})).unwrap().is_some());
+    // A pick edits only the Selection: the probe stays.
+    pick(&mut s, 0.5, "replace");
+    assert!(s.crypto_probe_job(&q).unwrap().is_none(), "kept across the pick");
+    assert_eq!(s.execute("effect.cryptomatteAt", q.clone()).unwrap()["selected"], true);
+    // Other edits rebuild it, and the answer follows them.
+    s.execute_checked("layer.enableTimeRemap", json!({})).unwrap();
+    s.execute_checked("prop.set", json!({"path": "timeRemap", "value": 1.5})).unwrap();
+    let stale = s.crypto_probe_job(&q).unwrap().expect("time remap changed it");
+    assert_eq!(s.execute("effect.cryptomatteAt", q.clone()).unwrap()["name"], "late");
+    // A job that finishes after the next edit doesn't answer for it.
+    s.execute_checked("prop.set", json!({"path": "timeRemap", "value": 0.5})).unwrap();
+    stale();
+    assert!(s.crypto_probe_job(&q).unwrap().is_some(), "stale job result is not used");
+    assert_eq!(s.execute("effect.cryptomatteAt", q.clone()).unwrap()["name"], "left");
+    // Errors are kept too, and still errors.
+    s.execute("layer.newSolid", json!({"name": "S"})).unwrap();
+    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
+    let solid = json!({"effect": 1, "x": 1, "y": 1});
+    s.crypto_probe_job(&solid).unwrap().expect("solid")();
+    assert!(s.crypto_probe_job(&solid).unwrap().is_none());
+    assert!(s.execute("effect.cryptomatteAt", solid).unwrap_err().to_string().contains("no Cryptomatte channels"));
+}
+
+/// Picks on 1080p, 4K and odd-sized footage, at the viewer's resolutions and on a half-size proxy,
+/// name the ID the rendered matte shows under the point (points next to cell edges).
+#[test]
+fn picks_match_the_render_at_1080p_4k_odd_sizes_and_on_proxies() {
+    for (w, h) in [(1920, 1080), (3840, 2160), (1919, 1079)] {
+        let mut s = cells_session(w, h, false);
+        let (wl, hl) = (f64::from(w), f64::from(h));
+        let xs = [36.6, 37.2, 0.4, wl / 2.0 + 0.3, wl - 0.6, wl - 37.4];
+        let ys = [28.7, 29.1, hl - 0.5, hl / 3.0];
+        let mut bad = mismatches(&mut s, &[1.0, 0.5, 0.33, 0.25], xs.iter().copied(), &ys);
+        let item = *s.project.items.iter().find(|(_, i)| matches!(i.kind, effectcraft_project::ItemKind::Footage(_))).unwrap().0;
+        s.execute("file.setProxy", json!({"item": item.0, "path": "/renders/cells_proxy.exr"})).unwrap();
+        bad.extend(mismatches(&mut s, &[1.0, 0.5, 0.33, 0.25], xs.iter().copied(), &ys).into_iter().map(|b| format!("proxy {b}")));
+        assert!(bad.is_empty(), "{w}x{h}: {} mismatches:\n{}", bad.len(), bad.join("\n"));
+    }
+}
+
+/// The kept probe, and the aux channels it holds, go when the eyedropper is disarmed, when its
+/// layer or effect is deleted, on Open / New, and when its footage changes.
+#[test]
+fn hover_probe_is_released_on_disarm_delete_open_and_footage_changes() {
+    let q = json!({"effect": "Cryptomatte", "x": 100.0, "y": 100.0});
+    let ends: [(&str, fn(&mut Session)); 5] = [
+        ("disarm", |s| s.drop_crypto_probe()),
+        ("layer delete", |s| {
+            let lid = s.active_comp().unwrap().layers[0].id.0;
+            s.execute_checked("edit.clear", json!({"layers": [lid]})).unwrap();
+        }),
+        ("effect delete", |s| {
+            s.execute_checked("effect.remove", json!({"effect": "Cryptomatte"})).unwrap();
+        }),
+        ("open / new", |s| s.replace_project(effectcraft_project::Project::default(), None)),
+        ("footage change", |s| {
+            let f = s.project.items.values().find_map(|i| match &i.kind {
+                effectcraft_project::ItemKind::Footage(f) => Some(f.clone()),
+                _ => None,
+            });
+            s.forget_decoded(&f.unwrap());
+        }),
+    ];
+    for (what, end) in ends {
+        let mut s = cells_session(640, 360, false);
+        let aux = s.footage.aux(ItemId(0), &Footage::default(), Tick::ZERO).unwrap();
+        let unpinned = Arc::strong_count(&aux);
+        assert!(!s.execute("effect.cryptomatteAt", q.clone()).unwrap().is_null());
+        assert!(s.crypto_probe_stats().0 && Arc::strong_count(&aux) > unpinned, "{what}: kept");
+        end(&mut s);
+        assert!(!s.crypto_probe_stats().0, "{what}: the probe is gone");
+        assert_eq!(Arc::strong_count(&aux), unpinned, "{what}: its aux channels are let go");
+    }
+}
+
+/// A probe is keyed by the frame it reads: on a still, or footage held by Time Remap, every comp
+/// time shares one; each footage frame has its own, and so does each comp time once something
+/// before the Cryptomatte effect is animated.
+#[test]
+fn hover_probe_is_keyed_by_the_source_frame() {
+    let builds = |s: &mut Session, times: &[f64]| -> Vec<u64> {
+        let b = s.crypto_probe_stats().1;
+        times
+            .iter()
+            .map(|t| {
+                let r = s.execute("effect.cryptomatteAt", json!({"effect": "Cryptomatte", "x": 40.0, "y": 30.0, "time": t})).unwrap();
+                assert_eq!(r["name"], "c1_1");
+                s.crypto_probe_stats().1 - b
+            })
+            .collect()
+    };
+    let f = 1.0 / 24.0;
+    let mut s = cells_session_at(320, 180, false, "/renders/still.exr");
+    assert_eq!(builds(&mut s, &[0.0, f, 0.5, 1.9]), [1, 1, 1, 1], "a still: one probe");
+    let mut s = cells_session(320, 180, false);
+    assert_eq!(builds(&mut s, &[0.0, f * 0.4, f, f * 1.5, 0.0]), [1, 1, 2, 2, 3], "footage: a probe per frame");
+    s.execute_checked("layer.enableTimeRemap", json!({})).unwrap();
+    s.execute_checked("prop.toggleAnimation", json!({"path": "timeRemap", "value": false})).unwrap();
+    s.execute_checked("prop.set", json!({"path": "timeRemap", "value": 0.5})).unwrap();
+    assert_eq!(builds(&mut s, &[0.0, f, 1.2]), [1, 1, 1], "held by Time Remap: one source frame");
+    let mut s = cells_session_at(320, 180, true, "/renders/still.exr");
+    assert_eq!(builds(&mut s, &[0.0, f]), [1, 1], "a still blur");
+    s.execute_checked("prop.addKey", json!({"path": "effects/#1/blurriness", "time": 0.0, "value": 2.0})).unwrap();
+    s.execute_checked("prop.addKey", json!({"path": "effects/#1/blurriness", "time": 1.0, "value": 6.0})).unwrap();
+    assert_eq!(builds(&mut s, &[0.0, f, f]), [1, 2, 2], "an animated blur before it: per comp time");
+}
+
+/// Probes of two Cryptomatte effects (on two footage layers) at the same revision and frame
+/// don't answer for each other.
+#[test]
+fn hover_probes_are_per_layer_and_effect() {
+    /// `…late…` files have the IDs [`Crypto`] has from 1 s.
+    struct ByFile;
+    impl FootageSource for ByFile {
+        fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
+            Some(Arc::new(Image::new(f.width, f.height)))
+        }
+        fn aux(&self, _: ItemId, f: &Footage, t: Tick) -> Option<Arc<AuxChannels>> {
+            Some(Arc::new(aux_at(if f.path.contains("late") { Tick::from_seconds_f64(1.0) } else { t })))
+        }
+    }
+    let mut s = Session { footage: Arc::new(ByFile), importer: Some(Arc::new(Probe)), ..Default::default() };
+    let items = s.execute("file.import", json!({"paths": ["/renders/crypto.exr", "/renders/late.exr"]})).unwrap()["items"].clone();
+    s.execute("comp.new", json!({"name": "C", "width": 8, "height": 4, "frameRate": 24, "duration": 2})).unwrap();
+    let layers: Vec<Value> = (0..2).map(|i| s.execute("layer.addItem", json!({"item": items[i]})).unwrap()["layer"].clone()).collect();
+    for l in &layers {
+        s.execute_checked("effect.apply", json!({"layers": [l], "effect": "Cryptomatte"})).unwrap();
+    }
+    let on = |l: &Value| json!({"layer": l, "effect": 1, "x": 0.5, "y": 1.5});
+    for (l, want) in [(&layers[0], "left"), (&layers[1], "late"), (&layers[0], "left")] {
+        assert_eq!(s.execute("effect.cryptomatteAt", on(l)).unwrap()["name"], want);
+    }
+}
+
+/// [`Crypto`]'s IDs, counting the reads, and holding them while `hold` is set (a build caught
+/// in the middle).
+#[derive(Default)]
+struct Gate {
+    reads: std::sync::atomic::AtomicUsize,
+    hold: std::sync::atomic::AtomicBool,
+    entered: std::sync::atomic::AtomicBool,
+    /// Picture frames read (the effect's input render).
+    frames: std::sync::atomic::AtomicUsize,
+}
+impl FootageSource for Gate {
+    fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
+        self.frames.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        Some(Arc::new(Image::new(f.width, f.height)))
+    }
+    fn aux(&self, _: ItemId, _: &Footage, t: Tick) -> Option<Arc<AuxChannels>> {
+        use std::sync::atomic::Ordering::SeqCst;
+        self.reads.fetch_add(1, SeqCst);
+        self.entered.store(true, SeqCst);
+        while self.hold.load(SeqCst) {
+            std::thread::sleep(std::time::Duration::from_millis(1));
+        }
+        Some(Arc::new(aux_at(t)))
+    }
+}
+
+/// Only the newest request's build is kept: a job that finishes late doesn't evict a newer probe,
+/// a job superseded before it runs doesn't build, one superseded (or outdated by an edit) while
+/// it builds stores nothing, and `probeOnly` never builds on the asking thread.
+#[test]
+fn hover_probe_builds_store_only_the_newest_and_never_build_for_probe_only() {
+    use std::sync::atomic::Ordering::SeqCst;
+    let gate = Arc::new(Gate::default());
+    let mut s = session();
+    s.footage = gate.clone();
+    let at = |t: f64| json!({"effect": 1, "x": 0.5, "y": 1.5, "time": t});
+    let reads = || gate.reads.load(SeqCst);
+    // A late job for another frame doesn't evict the probe built since.
+    let job0 = s.crypto_probe_job(&at(0.0)).unwrap().unwrap();
+    s.execute("effect.cryptomatteAt", at(1.0)).unwrap();
+    assert!(s.crypto_probe_job(&at(1.0)).unwrap().is_none());
+    job0();
+    assert!(s.crypto_probe_job(&at(1.0)).unwrap().is_none(), "the late job evicted the newer probe");
+    // A request for another probe cancels the earlier job: it doesn't even build.
+    let (old, new) = (s.crypto_probe_job(&at(0.5)).unwrap().unwrap(), s.crypto_probe_job(&at(0.25)).unwrap().unwrap());
+    let before = reads();
+    old();
+    assert_eq!(reads(), before, "a superseded job doesn't build");
+    new();
+    assert!(reads() > before);
+    assert!(s.crypto_probe_job(&at(0.25)).unwrap().is_none(), "the newest request's probe is kept");
+    // The same request again doesn't cancel the job in flight.
+    let (a, b) = (s.crypto_probe_job(&at(1.5)).unwrap().unwrap(), s.crypto_probe_job(&at(1.5)).unwrap().unwrap());
+    a();
+    drop(b);
+    assert!(s.crypto_probe_job(&at(1.5)).unwrap().is_none());
+    // Superseded, or outdated by an edit, while it builds: it stores nothing.
+    for edit in [false, true] {
+        let job = s.crypto_probe_job(&at(0.75)).unwrap().unwrap();
+        gate.hold.store(true, SeqCst);
+        gate.entered.store(false, SeqCst);
+        let run = std::thread::spawn(job);
+        while !gate.entered.load(SeqCst) {
+            std::thread::sleep(std::time::Duration::from_millis(1));
+        }
+        if edit {
+            s.execute_checked("prop.set", json!({"path": "effects/#1/matteOnly", "value": true})).unwrap();
+        } else {
+            drop(s.crypto_probe_job(&at(0.8)).unwrap());
+        }
+        gate.hold.store(false, SeqCst);
+        run.join().unwrap();
+        let stored = if edit { s.crypto_probe_stats().0 } else { s.crypto_probe_job(&at(0.75)).unwrap().is_none() };
+        assert!(!stored, "edit {edit}: the outdated build was stored");
+    }
+    // `probeOnly`: pending without a probe, and nothing built.
+    let before = reads();
+    let mut q = at(0.0);
+    q["probeOnly"] = json!(true);
+    assert_eq!(s.execute("effect.cryptomatteAt", q.clone()).unwrap(), json!({"pending": true}));
+    q["mode"] = json!("add");
+    assert_eq!(s.execute("effect.pickCryptomatte", q.clone()).unwrap()["pending"], true);
+    assert_eq!(reads(), before, "nothing built for probeOnly");
+    s.crypto_probe_job(&q).unwrap().unwrap()();
+    assert_eq!(s.execute("effect.pickCryptomatte", q.clone()).unwrap()["selection"], "left");
+}
+
+/// A build cancelled while it reads the IDs (a newer request, disarming, an edit, another
+/// project) stops before it renders the effect's input, so the next build isn't kept waiting.
+#[test]
+fn a_cancelled_build_stops_before_rendering_its_input() {
+    use std::sync::atomic::Ordering::SeqCst;
+    let cancels: [(&str, fn(&mut Session)); 4] = [
+        ("newer request", |s| drop(s.crypto_probe_job(&json!({"effect": 1, "x": 0.5, "y": 1.5, "time": 1.5})).unwrap())),
+        ("disarm", |s| s.drop_crypto_probe()),
+        ("edit", |s| drop(s.execute_checked("prop.set", json!({"path": "effects/#1/matteOnly", "value": true})).unwrap())),
+        ("project switch", |s| s.replace_project(effectcraft_project::Project::default(), None)),
+    ];
+    for (what, cancel) in [("not cancelled", None), ("newer request", Some(0)), ("disarm", Some(1)), ("edit", Some(2)), ("project switch", Some(3))] {
+        let gate = Arc::new(Gate::default());
+        let mut s = session();
+        s.footage = gate.clone();
+        let job = s.crypto_probe_job(&json!({"effect": 1, "x": 0.5, "y": 1.5, "time": 0.5})).unwrap().unwrap();
+        gate.hold.store(true, SeqCst);
+        let run = std::thread::spawn(job);
+        while !gate.entered.load(SeqCst) {
+            std::thread::sleep(std::time::Duration::from_millis(1));
+        }
+        if let Some(k) = cancel {
+            cancels[k].1(&mut s);
+        }
+        gate.hold.store(false, SeqCst);
+        run.join().unwrap();
+        let rendered = gate.frames.load(SeqCst) > 0;
+        assert_eq!(rendered, cancel.is_none(), "{what}: the input was rendered: {rendered}");
+    }
+}
+
+/// The probe doesn't read the Cryptomatte effect's own Selection: keyframed, a still keeps one
+/// probe for every comp time (an animated effect before it still makes one per time).
+#[test]
+fn an_animated_selection_keeps_one_probe_on_a_still() {
+    let mut s = cells_session_at(320, 180, false, "/renders/still.exr");
+    for (t, v) in [(0.0, "c1_1"), (1.0, "c2_2")] {
+        s.execute_checked("prop.addKey", json!({"path": "effects/#1/selection", "time": t, "value": v})).unwrap();
+    }
+    let b = s.crypto_probe_stats().1;
+    for t in [0.0, 1.0 / 24.0, 0.5, 1.5] {
+        assert_eq!(s.execute("effect.cryptomatteAt", json!({"effect": "Cryptomatte", "x": 40.0, "y": 30.0, "time": t})).unwrap()["name"], "c1_1");
+    }
+    assert_eq!(s.crypto_probe_stats().1 - b, 1, "one probe for the still");
+}
+
+/// A panic while a probe is built on another thread becomes the probe's error: the job returns,
+/// the hover reports it, and it isn't retried for that frame.
+#[test]
+fn a_panicking_probe_build_becomes_an_error() {
+    struct Broken;
+    impl FootageSource for Broken {
+        fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
+            Some(Arc::new(Image::new(f.width, f.height)))
+        }
+        fn aux(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<AuxChannels>> {
+            panic!("a broken EXR reader")
+        }
+    }
+    let mut s = Session { footage: Arc::new(Broken), importer: Some(Arc::new(Probe)), ..Default::default() };
+    let item = s.execute("file.import", json!({"paths": ["/renders/crypto.exr"]})).unwrap()["items"][0].clone();
+    s.execute("comp.new", json!({"name": "C", "width": 8, "height": 4, "frameRate": 24, "duration": 2})).unwrap();
+    s.execute("layer.addItem", json!({"item": item})).unwrap();
+    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
+    let q = json!({"effect": 1, "x": 0.5, "y": 1.5, "probeOnly": true});
+    let job = s.crypto_probe_job(&q).unwrap().unwrap();
+    assert!(std::thread::spawn(job).join().is_ok(), "the job caught the panic");
+    assert!(s.crypto_probe_job(&q).unwrap().is_none(), "the error is kept");
+    let e = s.execute("effect.cryptomatteAt", q).unwrap_err().to_string();
+    assert!(e.contains("Reading the Cryptomatte IDs failed") && e.contains("a broken EXR reader"), "{e}");
+}
+
+/// Asking whether the probe is built changes nothing: asked for other frames while a build runs
+/// (the eyedropper's hover while a click waits), it doesn't cancel that build.
+#[test]
+fn asking_whether_a_probe_is_ready_cancels_no_build() {
+    let s = session();
+    let at = |t: f64| json!({"effect": 1, "x": 0.5, "y": 1.5, "time": t, "probeOnly": true});
+    let job = s.crypto_probe_job(&at(0.0)).unwrap().unwrap();
+    for t in [1.0, 0.5, 1.0, 0.25] {
+        assert!(!s.crypto_probe_ready(&at(t)).unwrap());
+    }
+    job();
+    assert!(s.crypto_probe_ready(&at(0.0)).unwrap(), "the build was cancelled");
+    assert!(s.crypto_probe_job(&at(0.0)).unwrap().is_none());
+}
+
+/// The probe renders with the render prefs (nested switches, draft shadows): changing them asks
+/// for a new one.
+#[test]
+fn a_render_prefs_change_asks_for_a_new_probe() {
+    let mut s = session();
+    let q = json!({"effect": 1, "x": 0.5, "y": 1.5});
+    s.crypto_probe_job(&q).unwrap().unwrap()();
+    assert!(s.crypto_probe_ready(&q).unwrap());
+    s.prefs.three_d.realtime_shadows = !s.prefs.three_d.realtime_shadows;
+    assert!(!s.crypto_probe_ready(&q).unwrap(), "draft shadows changed");
+    s.crypto_probe_job(&q).unwrap().unwrap()();
+    s.prefs.general.switches_affect_nested_comps = !s.prefs.general.switches_affect_nested_comps;
+    assert!(!s.crypto_probe_ready(&q).unwrap(), "nested switches changed");
+}
+
+/// A pick is an undo step named for it, and undoing, redoing or jumping over picks keeps the
+/// probe (only the Selection changed); undoing any other edit doesn't.
+#[test]
+fn undoing_picks_keeps_the_probe_and_the_step_says_pick() {
+    let mut s = session();
+    let q = json!({"effect": 1, "x": 0.5, "y": 1.5, "probeOnly": true});
+    s.crypto_probe_job(&q).unwrap().unwrap()();
+    let before = crate::history::state_id(&s.project);
+    pick(&mut s, 0.5, "replace");
+    assert_eq!(s.history.undo.last().unwrap().0, "Pick Cryptomatte");
+    pick(&mut s, 4.5, "add");
+    for (what, cmd) in [("undo", "edit.undo"), ("undo", "edit.undo"), ("redo", "edit.redo")] {
+        s.execute_checked(cmd, json!({})).unwrap();
+        assert!(s.crypto_probe_ready(&q).unwrap(), "{what} {}: probe dropped", selection(&s));
+    }
+    assert_eq!(s.execute("effect.cryptomatteAt", q.clone()).unwrap()["selected"], true);
+    assert!(s.goto_history(&before) && selection(&s).is_empty());
+    assert!(s.crypto_probe_ready(&q).unwrap(), "history jump: probe dropped");
+    s.execute_checked("prop.set", json!({"path": "transform/opacity", "value": 50})).unwrap();
+    s.crypto_probe_job(&q).unwrap().unwrap()();
+    s.execute_checked("edit.undo", json!({})).unwrap();
+    assert!(!s.crypto_probe_ready(&q).unwrap(), "an undone opacity change needs a new probe");
+}
diff --git a/crates/engine/src/tests/delete_keys.rs b/crates/engine/src/tests/delete_keys.rs
new file mode 100644
index 000000000..ec6ec888e
--- /dev/null
+++ b/crates/engine/src/tests/delete_keys.rs
@@ -0,0 +1,249 @@
+//! `keys.delete` reports the keys it removed, not the keys it was asked to remove.
+
+use effectcraft_project::LayerId;
+use serde_json::json;
+
+use crate::{KeyRef, Session};
+
+fn setup() -> (Session, u64, u64) {
+    let mut s = Session::default();
+    s.execute_checked("comp.new", json!({"width": 64, "height": 64, "frameRate": 30, "duration": 4})).unwrap();
+    let layer = s.execute_checked("layer.newSolid", json!({"name": "Box", "color": "#fff"})).unwrap()["layer"].as_u64().unwrap();
+    for t in 0..3 {
+        s.execute_checked("prop.addKey", json!({"layer": layer, "path": "transform/opacity", "time": t, "value": t * 25})).unwrap();
+    }
+    let prop = s.active_comp().unwrap().layer(LayerId(layer)).unwrap().props.prop("transform/opacity").unwrap().uid;
+    (s, layer, prop)
+}
+
+fn keys_of(s: &Session, layer: u64, prop: u64) -> Vec<KeyRef> {
+    let keys = &s.active_comp().unwrap().layer(LayerId(layer)).unwrap().props.find(prop).unwrap().keys;
+    keys.iter().map(|k| KeyRef { layer: LayerId(layer), prop, time: k.time }).collect()
+}
+
+#[test]
+fn delete_keys_counts_only_the_keys_it_removed() {
+    let (mut s, layer, prop) = setup();
+    let keys = keys_of(&s, layer, prop);
+    assert_eq!(keys.len(), 3);
+    // Two real keys, one of them listed twice, and a key of a property that does not exist.
+    let missing = KeyRef { layer: LayerId(layer), prop: u64::MAX, time: keys[1].time };
+    s.state.selected_keys = vec![keys[0], keys[2], keys[0], missing];
+    let removed = s.execute_checked("keys.delete", json!({})).unwrap();
+    assert_eq!(removed, json!(2));
+    assert_eq!(keys_of(&s, layer, prop), vec![keys[1]]);
+}
+
+#[test]
+fn delete_keys_reports_zero_when_no_selected_key_exists() {
+    let (mut s, layer, prop) = setup();
+    let keys = keys_of(&s, layer, prop);
+    s.state.selected_keys = vec![KeyRef { layer: LayerId(layer), prop: u64::MAX, time: keys[0].time }];
+    let removed = s.execute_checked("keys.delete", json!({})).unwrap();
+    assert_eq!(removed, json!(0));
+    assert_eq!(keys_of(&s, layer, prop), keys);
+}
+
+/// A layer locked after its keys were selected keeps them: Delete and Edit Value leave them alone.
+#[test]
+fn a_locked_layers_keys_cannot_be_deleted_or_edited() {
+    let (mut s, layer, prop) = setup();
+    let keys = keys_of(&s, layer, prop);
+    s.state.selected_keys = keys.clone();
+    s.execute_checked("layer.setSwitch", json!({"layers": [layer], "switch": "locked", "value": true})).unwrap();
+    let removed = s.execute_checked("keys.delete", json!({})).unwrap();
+    assert_eq!(removed, json!(0));
+    assert_eq!(keys_of(&s, layer, prop), keys);
+    assert_eq!(s.state.selected_keys, keys, "the selection stays");
+    let e = s.execute("keys.set", json!({"layer": layer, "prop": prop, "time": 0, "value": 90})).unwrap_err().to_string();
+    assert!(e.contains("locked"), "{e}");
+    let value = s.active_comp().unwrap().layer(LayerId(layer)).unwrap().props.find(prop).unwrap().keys[0].value.as_f64();
+    assert_eq!(value, 0.0);
+    // Unlocked again, both work.
+    s.execute_checked("layer.setSwitch", json!({"layers": [layer], "switch": "locked", "value": false})).unwrap();
+    s.execute_checked("keys.set", json!({"layer": layer, "prop": prop, "time": 0, "value": 90})).unwrap();
+    assert_eq!(s.execute_checked("keys.delete", json!({})).unwrap(), json!(3));
+}
+
+/// Easy Ease, Toggle Hold and Time-Reverse leave a locked layer's keys as they are and keep them
+/// selected; unlocked, they change them.
+#[test]
+fn selection_based_key_edits_skip_a_locked_layer() {
+    let (mut s, layer, prop) = setup();
+    let keys = keys_of(&s, layer, prop);
+    let stored = |s: &Session| s.active_comp().unwrap().layer(LayerId(layer)).unwrap().props.find(prop).unwrap().keys.clone();
+    let before = stored(&s);
+    s.state.selected_keys = keys.clone();
+    s.execute_checked("layer.setSwitch", json!({"layers": [layer], "switch": "locked", "value": true})).unwrap();
+    for command in ["keys.easyEase", "keys.toggleHold", "keys.timeReverse"] {
+        s.execute_checked(command, json!({})).unwrap();
+        assert_eq!(stored(&s), before, "{command} changed a locked layer's keys");
+        assert_eq!(s.state.selected_keys, keys, "{command} dropped the selection of a locked layer's keys");
+    }
+    s.execute_checked("layer.setSwitch", json!({"layers": [layer], "switch": "locked", "value": false})).unwrap();
+    s.execute_checked("keys.easyEase", json!({})).unwrap();
+    assert_ne!(stored(&s), before, "unlocked, Easy Ease changes the keys");
+}
+
+#[test]
+fn spatial_handles_cannot_edit_a_locked_layer() {
+    let (mut s, layer, _) = setup();
+    for (time, value) in [(0, [10, 20, 0]), (1, [80, 60, 0])] {
+        s.execute("prop.addKey", json!({"layer": layer, "path": "transform/position", "time": time, "value": value})).unwrap();
+    }
+    let prop = s.active_comp().unwrap().layer(LayerId(layer)).unwrap().props.prop("transform/position").unwrap().uid;
+    s.execute("keys.select", json!({"keys": [{"layer": layer, "prop": prop, "time": 0}]})).unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [layer], "switch": "locked", "value": true})).unwrap();
+    let before = s.project.to_json();
+    let selected = s.state.selected_keys.clone();
+    let undo_len = s.history.undo.len();
+    let params = json!({"layer": layer, "prop": prop, "time": 0, "out": [15, 25, 0]});
+    let error = s.execute("keys.setSpatialTangents", params.clone()).unwrap_err().to_string();
+    assert!(error.contains("locked"), "{error}");
+    assert_eq!(s.project.to_json(), before);
+    assert_eq!(s.state.selected_keys, selected);
+    assert_eq!(s.history.undo.len(), undo_len);
+    s.execute("layer.setSwitch", json!({"layers": [layer], "switch": "locked", "value": false})).unwrap();
+    let unlocked = s.project.to_json();
+    s.execute("keys.setSpatialTangents", params).unwrap();
+    let edited = s.project.to_json();
+    assert_ne!(edited, unlocked);
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(s.project.to_json(), unlocked);
+    s.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(s.project.to_json(), edited);
+}
+
+#[test]
+fn pasting_keys_or_motion_paths_cannot_edit_locked_targets() {
+    for path_clip in [false, true] {
+        for explicit in [false, true] {
+            let (mut s, layer, opacity) = setup();
+            let target_path = if path_clip { "transform/position" } else { "transform/opacity" };
+            let source = if path_clip {
+                s.execute("mask.new", json!({"layer": layer, "vertices": [[0, 0], [20, 10], [40, 0]], "closed": false})).unwrap();
+                s.execute("prop.toggleAnimation", json!({"layer": layer, "path": "masks/#1/path"})).unwrap();
+                s.active_comp().unwrap().layer(LayerId(layer)).unwrap().props.prop("masks/#1/path").unwrap().uid
+            } else {
+                opacity
+            };
+            s.execute("keys.select", json!({"keys": [{"layer": layer, "prop": source, "time": 0}]})).unwrap();
+            s.execute("keys.copy", json!({})).unwrap();
+            s.execute("prop.select", json!({"layer": layer, "path": target_path})).unwrap();
+            s.execute("time.set", json!({"time": 3})).unwrap();
+            s.execute("layer.setSwitch", json!({"layers": [layer], "switch": "locked", "value": true})).unwrap();
+            let params = if explicit { json!({"layer": layer, "path": target_path}) } else { json!({}) };
+            let before = s.project.to_json();
+            let selected = s.state.selected_keys.clone();
+            let undo_len = s.history.undo.len();
+            let result = s.execute("keys.paste", params.clone());
+            assert!(result.is_err(), "path={path_clip}, explicit={explicit}: {result:?}");
+            assert_eq!(s.project.to_json(), before);
+            assert_eq!(s.state.selected_keys, selected);
+            assert_eq!(s.history.undo.len(), undo_len);
+            s.execute("layer.setSwitch", json!({"layers": [layer], "switch": "locked", "value": false})).unwrap();
+            let unlocked = s.project.to_json();
+            s.execute("keys.paste", params).unwrap();
+            let pasted = s.project.to_json();
+            assert_ne!(pasted, unlocked);
+            s.execute("edit.undo", json!({})).unwrap();
+            assert_eq!(s.project.to_json(), unlocked);
+            s.execute("edit.redo", json!({})).unwrap();
+            assert_eq!(s.project.to_json(), pasted);
+        }
+    }
+}
+
+#[test]
+fn key_paste_skips_locked_targets_without_changing_layer_pairing() {
+    let (mut s, locked, locked_prop) = setup();
+    let other = s.execute("layer.newSolid", json!({"name": "Other", "color": "#fff"})).unwrap()["layer"].as_u64().unwrap();
+    for (time, value) in [(0, 100), (1, 80), (2, 60)] {
+        s.execute("prop.addKey", json!({"layer": other, "path": "transform/opacity", "time": time, "value": value})).unwrap();
+    }
+    let other_prop = s.active_comp().unwrap().layer(LayerId(other)).unwrap().props.prop("transform/opacity").unwrap().uid;
+    let locked_keys = keys_of(&s, locked, locked_prop);
+    s.state.selected_keys = locked_keys.iter().chain(keys_of(&s, other, other_prop).iter()).copied().collect();
+    s.execute("keys.copy", json!({})).unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [locked], "switch": "locked", "value": true})).unwrap();
+    s.execute("time.set", json!({"time": 3})).unwrap();
+    let before = s.project.to_json();
+    assert_eq!(s.execute("keys.paste", json!({"layers": [locked, other]})).unwrap(), json!(3), "only newly pasted keys are counted");
+    assert_eq!(keys_of(&s, locked, locked_prop), locked_keys);
+    assert!(locked_keys.iter().all(|k| s.state.selected_keys.contains(k)));
+    assert_eq!(s.state.selected_keys.len(), 6);
+    let keys = &s.active_comp().unwrap().layer(LayerId(other)).unwrap().props.find(other_prop).unwrap().keys;
+    assert_eq!(keys.iter().filter(|k| k.time.seconds() >= 3.0).map(|k| k.value.as_f64()).collect::<Vec<_>>(), [100.0, 80.0, 60.0]);
+    let pasted = s.project.to_json();
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(s.project.to_json(), before);
+    s.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(s.project.to_json(), pasted);
+}
+
+#[test]
+fn motion_path_paste_preserves_locked_source_selection() {
+    for explicit in [false, true] {
+        let (mut s, source, _) = setup();
+        s.execute("mask.new", json!({"layer": source, "vertices": [[0, 0], [20, 10], [40, 0]], "closed": false})).unwrap();
+        s.execute("prop.toggleAnimation", json!({"layer": source, "path": "masks/#1/path"})).unwrap();
+        let uid = s.active_comp().unwrap().layer(LayerId(source)).unwrap().props.prop("masks/#1/path").unwrap().uid;
+        s.execute("keys.select", json!({"keys": [{"layer": source, "prop": uid, "time": 0}]})).unwrap();
+        s.execute("keys.copy", json!({})).unwrap();
+        let locked_keys = s.state.selected_keys.clone();
+        let target = s.execute("layer.newSolid", json!({"name": "Target", "color": "#fff"})).unwrap()["layer"].as_u64().unwrap();
+        s.execute("prop.select", json!({"layer": target, "path": "transform/position"})).unwrap();
+        s.execute("layer.setSwitch", json!({"layers": [source], "switch": "locked", "value": true})).unwrap();
+        s.state.selected_keys = locked_keys.clone();
+        let params = if explicit { json!({"layer": target, "path": "transform/position"}) } else { json!({}) };
+        let before = s.project.to_json();
+        assert_eq!(s.execute("keys.paste", params).unwrap(), json!(3));
+        assert!(locked_keys.iter().all(|k| s.state.selected_keys.contains(k)));
+        assert_eq!(s.state.selected_keys.len(), 4);
+        assert_eq!(s.state.selected_keys.iter().filter(|k| k.layer == LayerId(target)).count(), 3);
+        let pasted = s.project.to_json();
+        s.execute("edit.undo", json!({})).unwrap();
+        assert_eq!(s.project.to_json(), before);
+        s.execute("edit.redo", json!({})).unwrap();
+        assert_eq!(s.project.to_json(), pasted);
+    }
+}
+
+#[test]
+fn key_transform_preserves_locked_keys_in_a_mixed_selection() {
+    let (mut s, locked, locked_prop) = setup();
+    let unlocked = s.execute("layer.newSolid", json!({"name": "Unlocked", "color": "#fff"})).unwrap()["layer"].as_u64().unwrap();
+    for t in 0..3 {
+        s.execute("prop.addKey", json!({"layer": unlocked, "path": "transform/opacity", "time": t, "value": t * 25})).unwrap();
+    }
+    let unlocked_prop = s.active_comp().unwrap().layer(LayerId(unlocked)).unwrap().props.prop("transform/opacity").unwrap().uid;
+    let locked_keys = keys_of(&s, locked, locked_prop);
+    s.state.selected_keys = locked_keys.iter().chain(keys_of(&s, unlocked, unlocked_prop).iter()).copied().collect();
+    s.execute("layer.setSwitch", json!({"layers": [locked], "switch": "locked", "value": true})).unwrap();
+    let stored = |s: &Session, layer, prop| s.active_comp().unwrap().layer(LayerId(layer)).unwrap().props.find(prop).unwrap().keys.clone();
+    let before = stored(&s, locked, locked_prop);
+    let undo = s.history.undo.len();
+    for offset in [0.5, 1.0] {
+        s.execute("keys.transform", json!({"timeOffset": offset, "valueOffset": offset * 10.0, "merge": "mixed-transform", "fromStart": true})).unwrap();
+        assert_eq!(stored(&s, locked, locked_prop), before);
+        assert_eq!(s.state.selected_keys.len(), 6);
+        assert!(locked_keys.iter().all(|k| s.state.selected_keys.contains(k)), "locked selections stay at their original times");
+        assert!(keys_of(&s, unlocked, unlocked_prop).iter().all(|k| s.state.selected_keys.contains(k)), "unlocked selections follow the keys");
+        let moved = stored(&s, unlocked, unlocked_prop);
+        for (i, key) in moved.iter().enumerate() {
+            assert_eq!(key.time.seconds(), i as f64 + offset);
+            assert_eq!(key.value.as_f64(), i as f64 * 25.0 + offset * 10.0);
+        }
+    }
+    assert_eq!(s.history.undo.len(), undo + 1, "one merged drag");
+    let after = stored(&s, unlocked, unlocked_prop);
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(stored(&s, locked, locked_prop), before);
+    assert_eq!(stored(&s, unlocked, unlocked_prop), before);
+    s.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(stored(&s, locked, locked_prop), before);
+    assert_eq!(stored(&s, unlocked, unlocked_prop), after);
+    s.execute("layer.setSwitch", json!({"layers": [locked], "switch": "locked", "value": false})).unwrap();
+    s.execute("keys.transform", json!({"timeOffset": 0.5, "valueOffset": 10})).unwrap();
+    assert_ne!(stored(&s, locked, locked_prop), before, "unlocking makes the keys editable again");
+}
diff --git a/crates/engine/src/tests_disk_cache.rs b/crates/engine/src/tests/disk_cache.rs
similarity index 63%
rename from crates/engine/src/tests_disk_cache.rs
rename to crates/engine/src/tests/disk_cache.rs
index 3091964ad..41497dd4b 100644
--- a/crates/engine/src/tests_disk_cache.rs
+++ b/crates/engine/src/tests/disk_cache.rs
@@ -30,12 +30,12 @@ fn project(s: &mut Session) -> effectcraft_project::ItemId {
 
 #[test]
 fn disk_cache_settings_persistence_and_invalidation() {
-    crate::tests_roto::hold_roto_cache_test_lock();
+    crate::tests::roto::hold_roto_cache_test_lock();
     let dir = folder("persist");
     let mut s = session(&dir);
     let st = s.execute_checked("cache.diskStats", json!({})).unwrap();
     assert_eq!(st["enabled"], json!(true));
-    assert_eq!(st["maxBytes"], json!(100u64 << 30));
+    assert_eq!(st["maxBytes"], json!(20u64 << 30));
     let cid = project(&mut s);
     let t = s.time();
     let first = s.render(cid, t, RenderOpts::default());
@@ -136,3 +136,62 @@ fn footage_changes_change_the_salt() {
     assert_ne!(k3, k2);
     assert_ne!(set_proxy(&mut s, false), k3);
 }
+
+/// Marker edits keep the disk key (the sound of a playing preview must not wait for frames to
+/// render again, #1083); an expression that reads markers makes them count.
+#[test]
+fn markers_keep_the_content_key_unless_an_expression_reads_them() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "M", "width": 8, "height": 8, "frameRate": 30, "duration": 2})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let l = s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
+    let key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, cid);
+    let k0 = key(&s);
+    s.execute("comp.addMarker", json!({"time": 0.5, "comment": "beat"})).unwrap();
+    s.execute("markers.set", json!({"layer": l, "new": true, "time": 0.25})).unwrap();
+    assert_eq!(key(&s), k0, "markers");
+    s.execute("prop.setExpression", json!({"layer": l, "path": "transform/opacity", "expression": "thisComp.marker.numKeys"})).unwrap();
+    let k1 = key(&s);
+    assert_ne!(k1, k0);
+    s.execute("comp.addMarker", json!({"time": 1.0})).unwrap();
+    assert_ne!(key(&s), k1, "a marker read by an expression");
+}
+
+/// A comp marker alone (no layer marker beside it) keeps the key too.
+#[test]
+fn a_lone_comp_marker_keeps_the_content_key() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "M", "width": 8, "height": 8, "frameRate": 30, "duration": 2})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
+    let key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, cid);
+    let k0 = key(&s);
+    s.execute("comp.addMarker", json!({"time": 0.5, "comment": "beat"})).unwrap();
+    assert_eq!(key(&s), k0);
+}
+
+/// A protected marker with a duration retimes a stretched precomp layer (Responsive Design), so
+/// changing it changes the key of the comp that nests it; a plain marker beside it does not.
+#[test]
+fn protected_markers_with_a_duration_change_the_content_key() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Inner", "width": 8, "height": 8, "frameRate": 30, "duration": 4})).unwrap();
+    let inner = s.active_comp_id().unwrap();
+    s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
+    s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "frameRate": 30, "duration": 10})).unwrap();
+    let outer = s.active_comp_id().unwrap();
+    let l = s.execute("layer.addItem", json!({"item": inner.0})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.select", json!({"layers": [l]})).unwrap();
+    s.execute("layer.timeStretch", json!({"percent": 200})).unwrap();
+    let key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, outer);
+    let k0 = key(&s);
+    s.execute("comp.addMarker", json!({"comp": inner.0, "time": 2.0, "comment": "beat"})).unwrap();
+    assert_eq!(key(&s), k0, "a plain marker");
+    s.execute("comp.addMarker", json!({"comp": inner.0, "time": 1.0})).unwrap();
+    let index = s.project.comp(inner).unwrap().markers.iter().position(|m| m.time.seconds() == 1.0).unwrap();
+    s.execute("markers.set", json!({"comp": inner.0, "index": index, "duration": 1.0, "protected": true})).unwrap();
+    let k1 = key(&s);
+    assert_ne!(k1, k0, "a protected marker with a duration");
+    s.execute("markers.set", json!({"comp": inner.0, "index": index, "duration": 2.0})).unwrap();
+    assert_ne!(key(&s), k1, "its duration");
+}
diff --git a/crates/engine/src/tests_effects.rs b/crates/engine/src/tests/effects.rs
similarity index 86%
rename from crates/engine/src/tests_effects.rs
rename to crates/engine/src/tests/effects.rs
index 1ea57f4cf..4b3b0188e 100644
--- a/crates/engine/src/tests_effects.rs
+++ b/crates/engine/src/tests/effects.rs
@@ -550,7 +550,7 @@ fn opening_an_old_project_upgrades_effect_instances() {
             effectcraft_project::ItemKind::Comp(c) => c,
             _ => panic!("not a composition"),
         });
-        let l = comp.layers.iter_mut().find(|l| l.id == LayerId(a)).unwrap();
+        let l = comp.layers.find_mut(|l| l.id == LayerId(a)).unwrap();
         for n in &mut l.props.sub_mut("effects").unwrap().children {
             let Node::Group(g) = n else { continue };
             if g.match_id == "ec.blur.gaussian" {
@@ -772,6 +772,132 @@ fn preset_round_trips_effect_properties_by_match_name() {
     }
 }
 
+/// An animation preset saved by an earlier version gets the upgrade a project gets on open: a
+/// Change to Color saved with its single Tolerance applies with the Tolerance group, that value
+/// as its Hue and the added parameters at their legacy defaults, and a lone property saved at the
+/// old id applies to the new one.
+#[test]
+fn applying_an_old_preset_upgrades_its_effects_and_property_paths() {
+    let (mut s, a, b) = comp_with_two_solids();
+    apply(&mut s, a, "Change to Color");
+    let mut old = layer(&s, a).effects().unwrap().groups().next().unwrap().clone();
+    old.children.retain(|c| c.match_id() != "toleranceGroup");
+    old.children.push(effectcraft_project::Property::new(0, "tolerance", "Tolerance", KV::Scalar(12.0)).into());
+    let preset = json!({"effectcraftAnimationPreset": 1, "name": "old", "properties": [], "effects": [old]});
+    let r = s.execute("anim.applyPreset", json!({"preset": preset, "layers": [b]})).unwrap();
+    assert_eq!(r["applied"], 1, "{r}");
+    let l = layer(&s, b);
+    let g = l.effects().unwrap().groups().next().unwrap();
+    assert!(g.get("tolerance").is_none(), "the old Tolerance is still there");
+    let tol = g.sub("toleranceGroup").expect("no Tolerance group");
+    assert_eq!(tol.get("hue").unwrap().value, KV::Scalar(12.0));
+    assert_eq!(tol.get("lightness").unwrap().value, KV::Scalar(100.0));
+    assert_eq!(tol.get("saturation").unwrap().value, KV::Scalar(100.0));
+    let path = "effects/ec.color.changetocolor/tolerance";
+    let preset = json!({"effectcraftAnimationPreset": 1, "name": "old", "properties": [{"path": path, "value": KV::Scalar(30.0), "keys": []}], "effects": []});
+    let r = s.execute("anim.applyPreset", json!({"preset": preset, "layers": [a]})).unwrap();
+    assert_eq!(r["applied"], 1, "{r}");
+    assert_eq!(r["skipped"], json!([]), "{r}");
+    let l = layer(&s, a);
+    let hue = l.effects().unwrap().groups().next().unwrap().sub("toleranceGroup").unwrap().get("hue").unwrap().value.clone();
+    assert_eq!(hue, KV::Scalar(30.0));
+}
+
+/// Save the selected effects and properties as a preset, then apply it to `target` at `at`.
+fn save_and_apply_preset(s: &mut Session, name: &str, selected: Vec<(LayerId, u64)>, target: u64, at: f64) -> serde_json::Value {
+    let path = std::env::temp_dir().join(format!("ec-1971-{name}-{}.ecpreset", std::process::id())).to_string_lossy().to_string();
+    s.state.selected_props = selected;
+    s.execute("anim.savePreset", json!({"path": path})).unwrap();
+    s.execute("time.set", json!({"time": at})).unwrap();
+    let r = s.execute("anim.applyPreset", json!({"path": path, "layers": [target]}));
+    let _ = std::fs::remove_file(&path);
+    r.unwrap()
+}
+
+/// The comp times of the keys at `path` on `lid`'s `n`th effect (0-based), or on the layer when
+/// `n` is `None`.
+fn key_times(s: &Session, lid: u64, n: Option<usize>, path: &str) -> Vec<f64> {
+    let l = layer(s, lid);
+    let group = match n {
+        Some(n) => l.effects().unwrap().groups().nth(n).unwrap().clone(),
+        None => l.props.clone(),
+    };
+    group.prop(path).unwrap().keys.iter().map(|k| l.comp_time(k.time).seconds()).collect()
+}
+
+/// #1971: a saved effect's keys start at the playhead of the layer it's applied to, as a saved
+/// property's do, nested controls included, an effect without keys still applies, and the whole
+/// apply is one undo step.
+#[test]
+fn preset_effect_keys_start_at_the_playhead() {
+    let (mut s, a, b) = comp_with_two_solids();
+    let blur = apply(&mut s, a, "Gaussian Blur");
+    let fractal = apply(&mut s, a, "Fractal");
+    let slider = apply(&mut s, a, "Slider Control");
+    animate_effect(&mut s, a, blur, "blurriness", &[(5.0, 10.0), (5.5, 30.0), (6.0, 10.0)]);
+    animate_effect(&mut s, a, fractal, "mandelbrot/mandelbrotX", &[(5.5, 1.25), (7.0, 2.5)]);
+    let before = layer(&s, b);
+    let undo = s.history.undo.len();
+    let r = save_and_apply_preset(&mut s, "effects", vec![(LayerId(a), blur), (LayerId(a), fractal), (LayerId(a), slider)], b, 0.5);
+    assert_eq!(r["applied"], 3, "{r}");
+    assert_eq!(key_times(&s, b, Some(0), "blurriness"), vec![0.5, 1.0, 1.5]);
+    assert_eq!(key_times(&s, b, Some(1), "mandelbrot/mandelbrotX"), vec![1.0, 2.5]);
+    assert_eq!(s.history.undo.len(), undo + 1, "the whole apply is one undo step");
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(layer(&s, b), before);
+}
+
+/// #1971: effects and properties saved together keep their relative timing: the earliest key of
+/// either starts at the playhead.
+#[test]
+fn preset_effects_and_properties_share_one_anchor() {
+    let (mut s, a, b) = comp_with_two_solids();
+    let blur = apply(&mut s, a, "Gaussian Blur");
+    animate_effect(&mut s, a, blur, "blurriness", &[(5.0, 10.0), (6.0, 30.0)]);
+    for (time, value) in [(4.0, -12.0), (7.0, 12.0)] {
+        s.execute("prop.addKey", json!({"layer": a, "path": "transform/rotation", "time": time, "timeBase": "comp", "value": value})).unwrap();
+    }
+    let rotation = layer(&s, a).props.prop("transform/rotation").unwrap().uid;
+    save_and_apply_preset(&mut s, "mixed", vec![(LayerId(a), blur), (LayerId(a), rotation)], b, 1.0);
+    assert_eq!(key_times(&s, b, None, "transform/rotation"), vec![1.0, 4.0]);
+    assert_eq!(key_times(&s, b, Some(0), "blurriness"), vec![2.0, 3.0]);
+}
+
+/// #1971: on a stretched layer a saved effect's keys land where a saved property's keys do.
+#[test]
+fn preset_effect_keys_follow_a_stretched_layer_like_properties() {
+    let (mut s, a, b) = comp_with_two_solids();
+    let blur = apply(&mut s, a, "Gaussian Blur");
+    animate_effect(&mut s, a, blur, "blurriness", &[(5.0, 10.0), (6.0, 30.0)]);
+    for (time, value) in [(5.0, -12.0), (6.0, 12.0)] {
+        s.execute("prop.addKey", json!({"layer": a, "path": "transform/rotation", "time": time, "timeBase": "comp", "value": value})).unwrap();
+    }
+    let rotation = layer(&s, a).props.prop("transform/rotation").unwrap().uid;
+    set_layer_clock(&mut s, b, 1.0, 200.0);
+    save_and_apply_preset(&mut s, "stretched", vec![(LayerId(a), blur), (LayerId(a), rotation)], b, 2.0);
+    let property = key_times(&s, b, None, "transform/rotation");
+    assert_eq!(property.first(), Some(&2.0), "the property's keys start at the playhead");
+    assert_eq!(key_times(&s, b, Some(0), "blurriness"), property, "and the effect's keys land with them");
+}
+
+/// #1971: a preset saved before effect keys were stored relative to the earliest key (version 1)
+/// has its effects' keys at the source layer's times; they also start at the playhead.
+#[test]
+fn old_preset_effect_keys_start_at_the_playhead() {
+    let (mut s, a, b) = comp_with_two_solids();
+    let blur = apply(&mut s, a, "Gaussian Blur");
+    animate_effect(&mut s, a, blur, "blurriness", &[(5.0, 10.0), (6.0, 30.0)]);
+    let old = json!({
+        "effectcraftAnimationPreset": 1,
+        "name": "shake",
+        "properties": [],
+        "effects": [serde_json::to_value(effect_group(&s, a, blur)).unwrap()],
+    });
+    s.execute("time.set", json!({"time": 0.5})).unwrap();
+    s.execute("anim.applyPreset", json!({"preset": old, "layers": [b]})).unwrap();
+    assert_eq!(key_times(&s, b, Some(0), "blurriness"), vec![0.5, 1.5]);
+}
+
 /// #2064: `prop.addKey` accepts the `effects/<match name>[#n]/<property>` path that
 /// `essential.list` reports.
 #[test]
diff --git a/crates/engine/src/tests_essential.rs b/crates/engine/src/tests/essential.rs
similarity index 75%
rename from crates/engine/src/tests_essential.rs
rename to crates/engine/src/tests/essential.rs
index 191416b9d..db5bf0751 100644
--- a/crates/engine/src/tests_essential.rs
+++ b/crates/engine/src/tests/essential.rs
@@ -367,6 +367,128 @@ fn media_replacement_swaps_footage_per_instance() {
     assert!(center(&s, main)[0] > 0.99);
 }
 
+/// #1747: a collapsed precomp with an Essential Property override must keep drawing its nested
+/// layers past the precomp's frame instead of falling back to a flattened, clipped frame.
+#[test]
+fn collapsed_precomp_applies_property_overrides_without_clipping() {
+    struct AddY;
+    impl effectcraft_render::ExprHost for AddY {
+        fn eval(
+            &self,
+            _: &effectcraft_render::EvalCtx,
+            _: &effectcraft_project::Layer,
+            _: &effectcraft_project::Property,
+            value: &effectcraft_keyframe::Value,
+        ) -> Result<effectcraft_keyframe::Value, String> {
+            Ok(match value {
+                effectcraft_keyframe::Value::Vec3([x, y, z]) => effectcraft_keyframe::Value::Vec3([*x, y + 100.0, *z]),
+                _ => value.clone(),
+            })
+        }
+    }
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Inner", "width": 400, "height": 300, "frameRate": 30, "duration": 2})).unwrap();
+    let inner = s.active_comp_id().unwrap();
+    let box_ = s.execute("layer.newSolid", json!({"name": "Box", "color": "#ffffff", "width": 100, "height": 100})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": box_, "path": "transform/position", "value": [200, 50, 0]})).unwrap();
+    // The source property's expression still runs after the instance override.
+    s.execute("prop.setExpression", json!({"layer": box_, "path": "transform/position", "expression": "value + [0, 100, 0]"})).unwrap();
+    let position = s.execute("essential.addProperty", json!({"layer": box_, "path": "transform/position"})).unwrap()["controls"][0].as_u64().unwrap();
+    s.execute("comp.new", json!({"name": "Outer", "width": 400, "height": 600, "frameRate": 30, "duration": 2})).unwrap();
+    let outer = s.active_comp_id().unwrap();
+    let instance = s.execute("layer.addItem", json!({"item": inner.0})).unwrap()["layer"].as_u64().unwrap();
+    let other = s.execute("layer.addItem", json!({"item": inner.0})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [instance, other], "switch": "collapse", "value": true})).unwrap();
+    s.expr = Some(std::sync::Arc::new(AddY));
+    s.execute("layer.select", json!({"layers": [instance]})).unwrap();
+    s.execute("essential.set", json!({"layer": instance, "control": position, "value": [200, -120, 0]})).unwrap();
+    s.execute("layer.select", json!({"layers": [other]})).unwrap();
+    s.execute("essential.set", json!({"layer": other, "control": position, "value": [200, 220, 0]})).unwrap();
+    let img = s.render(outer, Tick::ZERO, RenderOpts::default());
+    // The expression adds 100 px: the overrides give inner y = -20 and 320. The first maps to
+    // outer y = 130 (the precomp is centred at 300) and its 100 px box spans 80..179, 70 px above
+    // the instance's frame (150..449), where a flattened precomp would stop. The second maps to
+    // 470 and spans 420..519, past the bottom.
+    assert!(img.get(200, 100)[3] > 0.99, "the override draws above the nested frame: {:?}", img.get(200, 100));
+    assert!(img.get(200, 90)[3] > 0.99, "the box reaches the top of its overridden bounds");
+    assert!(img.get(200, 500)[3] > 0.99, "the other instance keeps its own override: {:?}", img.get(200, 500));
+    assert!(img.get(200, 200)[3] < 0.01, "nothing is left between the instances");
+}
+
+/// #1747: two collapsed instances of the same comp keep their own source-affecting property
+/// overrides in the layer cache (the nested layers' ids and static values are identical).
+#[test]
+fn collapsed_instances_keep_distinct_property_overrides_in_the_cache() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Card", "width": 64, "height": 64, "frameRate": 30, "duration": 2})).unwrap();
+    let card = s.active_comp_id().unwrap();
+    let solid = s.execute("layer.newSolid", json!({"name": "BG", "color": "#ffffff", "width": 64, "height": 64})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("effect.apply", json!({"layer": solid, "effect": "Fill"})).unwrap();
+    let color = s.execute("essential.addProperty", json!({"layer": solid, "path": "effects/#1/color"})).unwrap()["controls"][0].as_u64().unwrap();
+    s.execute("comp.new", json!({"name": "Main", "width": 200, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
+    let main = s.active_comp_id().unwrap();
+    let a = s.execute("layer.addItem", json!({"item": card.0})).unwrap()["layer"].as_u64().unwrap();
+    let b = s.execute("layer.addItem", json!({"item": card.0})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [a, b], "switch": "collapse", "value": true})).unwrap();
+    s.execute("prop.set", json!({"layer": a, "path": "transform/position", "value": [60, 50, 0]})).unwrap();
+    s.execute("prop.set", json!({"layer": b, "path": "transform/position", "value": [140, 50, 0]})).unwrap();
+    s.execute("layer.select", json!({"layers": [a]})).unwrap();
+    s.execute("essential.set", json!({"layer": a, "control": color, "value": [1.0, 0.0, 0.0, 1.0]})).unwrap();
+    s.execute("layer.select", json!({"layers": [b]})).unwrap();
+    s.execute("essential.set", json!({"layer": b, "control": color, "value": [0.0, 0.0, 1.0, 1.0]})).unwrap();
+    let img = s.render(main, Tick::ZERO, RenderOpts::default());
+    let left = img.get(60, 50);
+    let right = img.get(140, 50);
+    assert!(left[0] > 0.99 && left[2] < 0.01, "left instance is red: {left:?}");
+    assert!(right[2] > 0.99 && right[0] < 0.01, "right instance is blue: {right:?}");
+}
+
+/// #1747 with Media Replacement: the replacement footage and the position override both apply
+/// while the precomp stays collapsed, so the box is blue and still draws above the frame.
+#[test]
+fn collapsed_precomp_applies_media_replacement_without_clipping() {
+    struct Colors;
+    impl crate::render::FootageSource for Colors {
+        fn frame(&self, _: ItemId, f: &effectcraft_project::Footage, _: Tick) -> Option<std::sync::Arc<effectcraft_raster::Image>> {
+            let c = if f.path.contains("blue") { [0.0, 0.0, 1.0, 1.0] } else { [1.0, 0.0, 0.0, 1.0] };
+            Some(std::sync::Arc::new(effectcraft_raster::Image::filled(100, 100, c)))
+        }
+    }
+    let mut s = Session { footage: std::sync::Arc::new(Colors), ..Default::default() };
+    let footage = |path: &str| effectcraft_project::Footage {
+        path: path.into(),
+        kind: effectcraft_project::FootageKind::Still,
+        width: 100,
+        height: 100,
+        has_video: true,
+        ..Default::default()
+    };
+    let (red, blue) = s
+        .edit("test", None, |proj, _| {
+            let red = proj.add_item("red.png", Default::default(), None, effectcraft_project::ItemKind::Footage(footage("red.png")));
+            let blue = proj.add_item("blue.png", Default::default(), None, effectcraft_project::ItemKind::Footage(footage("blue.png")));
+            Ok((red, blue))
+        })
+        .unwrap();
+    s.execute("comp.new", json!({"name": "Inner", "width": 400, "height": 300, "frameRate": 30, "duration": 2})).unwrap();
+    let inner = s.active_comp_id().unwrap();
+    let clip = s.execute("layer.addItem", json!({"item": red.0})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": clip, "path": "transform/position", "value": [200, 50, 0]})).unwrap();
+    let media = s.execute("essential.addMedia", json!({"layer": clip})).unwrap()["control"].as_u64().unwrap();
+    let position = s.execute("essential.addProperty", json!({"layer": clip, "path": "transform/position"})).unwrap()["controls"][0].as_u64().unwrap();
+    s.execute("comp.new", json!({"name": "Outer", "width": 400, "height": 600, "frameRate": 30, "duration": 2})).unwrap();
+    let outer = s.active_comp_id().unwrap();
+    let instance = s.execute("layer.addItem", json!({"item": inner.0})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [instance], "switch": "collapse", "value": true})).unwrap();
+    s.execute("layer.select", json!({"layers": [instance]})).unwrap();
+    s.execute("essential.set", json!({"layer": instance, "control": position, "value": [200, -20, 0]})).unwrap();
+    s.execute("essential.set", json!({"layer": instance, "control": media, "item": blue.0})).unwrap();
+    let img = s.render(outer, Tick::ZERO, RenderOpts::default());
+    let above = img.get(200, 100);
+    assert!(above[2] > 0.99 && above[0] < 0.01, "the replacement media is blue above the frame: {above:?}");
+    assert!(img.get(200, 200)[3] < 0.01, "the collapsed box is not clipped at the nested frame");
+}
+
 /// Responsive Design — Time: stretching a precomp keeps its protected regions at their
 /// original speed; the unprotected parts absorb the stretch.
 #[test]
diff --git a/crates/engine/src/tests_essential_more.rs b/crates/engine/src/tests/essential_more.rs
similarity index 72%
rename from crates/engine/src/tests_essential_more.rs
rename to crates/engine/src/tests/essential_more.rs
index a8d8dc808..ea4aa42e5 100644
--- a/crates/engine/src/tests_essential_more.rs
+++ b/crates/engine/src/tests/essential_more.rs
@@ -2,6 +2,7 @@
 
 use effectcraft_keyframe::Value as KV;
 use effectcraft_project::essential::{self, ControlType};
+use effectcraft_time::Tick;
 use serde_json::json;
 
 use crate::{Event, Session};
@@ -102,3 +103,33 @@ fn open_in_essential_graphics_sets_the_primary_comp() {
     );
     assert_eq!(s.execute("essential.list", json!({})).unwrap()["name"], "A");
 }
+
+/// #1747: through a collapsed precomp, a Text override and a Font override of the same Source
+/// Text both apply: the Font merges into the overridden text, as `essential::with_overrides`
+/// does on the flattened path, instead of one entry replacing the other.
+#[test]
+fn collapsed_instance_merges_text_and_font_overrides() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Title", "width": 64, "height": 64, "frameRate": 30, "duration": 1})).unwrap();
+    let title = s.active_comp_id().unwrap();
+    let text = s.execute("layer.newText", json!({"text": "Hello"})).unwrap()["layer"].as_u64().unwrap();
+    let body = s.execute("essential.addProperty", json!({"layer": text, "path": "text/sourceText"})).unwrap()["controls"][0].as_u64().unwrap();
+    let font = s.execute("essential.addProperty", json!({"layer": text, "path": "text/sourceText", "as": "font"})).unwrap()["controls"][0].as_u64().unwrap();
+    s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "frameRate": 30, "duration": 1})).unwrap();
+    let main = s.active_comp_id().unwrap();
+    let inst = s.execute("layer.addItem", json!({"item": title.0})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [inst], "switch": "collapse", "value": true})).unwrap();
+    s.execute("essential.set", json!({"layer": inst, "control": body, "value": "Bye"})).unwrap();
+    s.execute("essential.set", json!({"layer": inst, "control": font, "value": {"font": "Serif Test", "size": 40}})).unwrap();
+    // Evaluate the nested text in the collapsed instance's context, as the renderer does.
+    let r = effectcraft_render::Renderer::new(&s.project, &*s.footage, crate::render::RenderOpts::default());
+    let ctx = effectcraft_render::EvalCtx::new(&s.project, main, s.project.comp(main).unwrap(), Tick::ZERO);
+    let layer = ctx.comp.layer(effectcraft_project::LayerId(inst)).unwrap();
+    let collapsed = r.collapsed(&ctx, layer).expect("the instance collapses");
+    let (_, nctx) = r.collapse_into(&ctx, layer, &collapsed, 1.0).expect("a nested context");
+    let src = nctx.comp.layer(effectcraft_project::LayerId(text)).unwrap();
+    match nctx.value(src, src.props.prop("text/sourceText").unwrap()) {
+        KV::Text(d) => assert_eq!((d.text.as_str(), d.font.as_str(), d.size), ("Bye", "Serif Test", 40.0)),
+        o => panic!("{o:?}"),
+    }
+}
diff --git a/crates/engine/src/tests/export_overwrite.rs b/crates/engine/src/tests/export_overwrite.rs
new file mode 100644
index 000000000..5cc65b1d5
--- /dev/null
+++ b/crates/engine/src/tests/export_overwrite.rs
@@ -0,0 +1,333 @@
+//! The commands that write to a path they are given leave a file the project reads alone (#1743,
+//! beyond the Render Queue): footage, a proxy, a frame of an imported image sequence and the
+//! project file are refused with nothing changed, and any other path is written. Save and Save As
+//! write the project's own file and are not among them.
+
+use std::sync::Arc;
+
+use effectcraft_project::{Footage, FootageKind, ItemId, Proxy};
+use serde_json::{Value, json};
+
+use super::render_overwrite::{Fixture, SOURCE};
+
+/// Footage that is a file named `path`.
+fn video(path: String) -> Footage {
+    Footage { path, kind: FootageKind::Video, has_video: true, ..Default::default() }
+}
+
+/// `item` gets the file `file` of the project's folder as its proxy.
+fn give_proxy(f: &mut Fixture, item: ItemId, file: &str) {
+    f.write(file, SOURCE);
+    let footage = video(f.text(file));
+    Arc::make_mut(&mut f.s.project).item_mut(item).unwrap().proxy = Some(Box::new(Proxy { footage, enabled: true }));
+}
+
+/// A project, saved as `Project.ecproj`, that reads `clip.<ext>` (footage) with `proxy.<ext>` as
+/// its proxy and the frames `shot_00000.<ext>` to `shot_00004.<ext>` of an image sequence, all
+/// holding `SOURCE`. Its composition `Main` holds a red solid.
+fn reading(name: &str, ext: &str) -> Fixture {
+    let mut f = Fixture::new(name);
+    let clip = f.footage(&format!("clip.{ext}"));
+    give_proxy(&mut f, clip, &format!("proxy.{ext}"));
+    f.sequence_as("shot", ext, 0..5);
+    f.comp("Main");
+    f.s.execute("layer.newSolid", json!({"name": "Red", "color": "#ff0000"})).unwrap();
+    f
+}
+
+/// The names in `dir`, sorted.
+fn listing(dir: &std::path::Path) -> Vec<String> {
+    let mut names: Vec<String> = std::fs::read_dir(dir).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
+    names.sort();
+    names
+}
+
+/// A command that writes to a path.
+struct Case {
+    command: &'static str,
+    /// The extension of a path for it.
+    ext: &'static str,
+    /// What it needs beyond a composition holding a solid.
+    setup: fn(&mut Fixture),
+    /// Its parameters for `path`.
+    params: fn(&str) -> Value,
+}
+
+fn nothing(_: &mut Fixture) {}
+
+/// The first layer of the active composition.
+fn first_layer(f: &Fixture) -> u64 {
+    f.s.active_comp().unwrap().layers[0].id.0
+}
+
+/// The composition shows one control, for `essential.exportTemplate`.
+fn expose_opacity(f: &mut Fixture) {
+    let layer = first_layer(f);
+    f.s.execute("essential.addProperty", json!({"layer": layer, "path": "transform/opacity"})).unwrap();
+}
+
+/// A property is selected, for `anim.savePreset`.
+fn select_opacity(f: &mut Fixture) {
+    let layer = first_layer(f);
+    f.s.execute("prop.select", json!({"layer": layer, "path": "transform/opacity"})).unwrap();
+}
+
+/// The composition has a guide, for `view.exportGuides`.
+fn add_guide(f: &mut Fixture) {
+    f.s.execute("view.addGuide", json!({"orientation": "vertical"})).unwrap();
+}
+
+/// Run `case` on every file the project reads: each is refused, the project's folder is as it was
+/// and nothing was rendered; then on a free path, where it writes.
+fn never_replaces_what_the_project_reads(case: &Case) {
+    let ext = case.ext;
+    let mut f = reading(&format!("{}-{ext}", case.command), ext);
+    (case.setup)(&mut f);
+    let mut reads = vec![(format!("clip.{ext}"), "footage"), (format!("proxy.{ext}"), "proxy"), (format!("shot_00002.{ext}"), "footage")];
+    // (A timeline export adds its extension to `Project.ecproj`: it has a test of its own.)
+    if case.command != "file.exportTimeline" {
+        reads.push(("Project.ecproj".to_string(), "project"));
+    }
+    let before: Vec<Vec<u8>> = reads.iter().map(|(file, _)| f.read(file)).collect();
+    let listed = listing(&f.dir);
+    for ((file, source), bytes) in reads.iter().zip(&before) {
+        let path = f.text(file);
+        let e = f.s.execute(case.command, (case.params)(&path)).expect_err(&format!("{} wrote over {file}", case.command)).to_string();
+        assert!(e.contains(file.as_str()) && e.contains(source), "{}: {file}: {e}", case.command);
+        assert_eq!(&f.read(file), bytes, "{}: {file} is as it was", case.command);
+    }
+    assert_eq!(listing(&f.dir), listed, "{}: refusing changed nothing in the folder", case.command);
+    assert!(f.exported().is_empty(), "{}: nothing was rendered for it", case.command);
+
+    let free = format!("out.{ext}");
+    f.s.execute(case.command, (case.params)(&f.text(&free))).unwrap_or_else(|e| panic!("{}: {e}", case.command));
+    assert_ne!(f.read(&free), SOURCE, "{}: wrote its file", case.command);
+    for ((file, _), bytes) in reads.iter().zip(&before) {
+        assert_eq!(&f.read(file), bytes, "{}: {file} is still as it was", case.command);
+    }
+}
+
+macro_rules! never_replaces {
+    ($name:ident, $command:literal, $ext:literal, $setup:expr) => {
+        #[test]
+        fn $name() {
+            never_replaces_what_the_project_reads(&Case { command: $command, ext: $ext, setup: $setup, params: |path| json!({"path": path}) });
+        }
+    };
+}
+
+never_replaces!(save_frame_as_png, "comp.saveFrameAs", "png", nothing);
+never_replaces!(save_frame_as_photoshop_layers, "comp.saveFrameAsPsd", "psd", nothing);
+never_replaces!(save_frame_as_proexr, "comp.saveFrameAsExr", "exr", nothing);
+never_replaces!(export_lottie_json, "file.exportLottie", "json", nothing);
+never_replaces!(export_lottie_dotlottie, "file.exportLottie", "lottie", nothing);
+never_replaces!(save_a_copy, "file.saveCopy", "ecproj", nothing);
+never_replaces!(save_a_copy_as_xml, "file.saveCopyAsXml", "ecprojx", nothing);
+never_replaces!(export_timeline, "file.exportTimeline", "xml", nothing);
+never_replaces!(export_template, "essential.exportTemplate", "ectemplate", expose_opacity);
+never_replaces!(save_animation_preset, "anim.savePreset", "ecpreset", select_opacity);
+never_replaces!(export_guides, "view.exportGuides", "json", add_guide);
+never_replaces!(export_shortcuts, "shortcuts.export", "json", nothing);
+
+// ---------------------------------------------------------------- Collect Files
+
+/// A project reading the footage `in/<file>`, with an empty `out/(Footage)` where Collect Files
+/// would put its copy.
+fn collecting(name: &str, file: &str) -> Fixture {
+    let mut f = Fixture::new(name);
+    std::fs::create_dir_all(f.path("in")).unwrap();
+    std::fs::create_dir_all(f.path("out/(Footage)")).unwrap();
+    f.footage(&format!("in/{file}"));
+    f
+}
+
+/// Collect Files into the project folder's `out`.
+fn collect(f: &mut Fixture) -> crate::Result<Value> {
+    let folder = f.text("out");
+    f.s.execute("file.collectFiles", json!({"folder": folder}))
+}
+
+/// `there`, the place the copy of the footage `in/<original>` would go, is something the project
+/// reads (`source`): Collect Files is refused before it copies or writes anything.
+fn collect_is_refused(mut f: Fixture, original: &str, there: &str, source: &str) {
+    f.write(there, b"NOT TO BE REPLACED");
+    let listed = listing(&f.path("out/(Footage)"));
+    let e = collect(&mut f).unwrap_err().to_string();
+    assert!(e.contains(original) && e.contains(source), "{e}");
+    assert_eq!(f.read(there), b"NOT TO BE REPLACED", "the file the project reads is as it was");
+    assert_eq!(f.read(&format!("in/{original}")), SOURCE, "the original is as it was");
+    assert!(!f.path("out/Project.ecproj").exists(), "the collected project was not written");
+    assert_eq!(listing(&f.path("out/(Footage)")), listed, "nothing else was copied");
+}
+
+#[test]
+fn collect_files_does_not_copy_over_other_footage() {
+    let mut f = collecting("collect-footage", "a.mov");
+    f.footage("out/(Footage)/a.mov");
+    collect_is_refused(f, "a.mov", "out/(Footage)/a.mov", "footage");
+}
+
+#[test]
+fn collect_files_does_not_copy_over_a_proxy() {
+    let mut f = collecting("collect-proxy", "a.mov");
+    let a = f.s.project.items.keys().next().copied().unwrap();
+    give_proxy(&mut f, a, "out/(Footage)/a.mov");
+    collect_is_refused(f, "a.mov", "out/(Footage)/a.mov", "proxy");
+}
+
+#[test]
+fn collect_files_does_not_copy_over_a_sequence_frame() {
+    let mut f = collecting("collect-frame", "shot_00002.png");
+    f.sequence_as("out/(Footage)/shot", "png", 0..5);
+    collect_is_refused(f, "shot_00002.png", "out/(Footage)/shot_00002.png", "footage");
+}
+
+/// Collecting into the project's own folder would write the collected copy over the project.
+#[test]
+fn collect_files_does_not_write_over_the_project_file() {
+    let mut f = collecting("collect-project", "a.mov");
+    let project = f.read("Project.ecproj");
+    let folder = f.dir.to_string_lossy().into_owned();
+    let e = f.s.execute("file.collectFiles", json!({"folder": folder})).unwrap_err().to_string();
+    assert!(e.contains("Project.ecproj") && e.contains("project"), "{e}");
+    assert_eq!(f.read("Project.ecproj"), project, "the project file is as it was");
+    assert!(!f.path("(Footage)").exists(), "no folder was made, nothing was copied");
+}
+
+#[test]
+fn collect_files_copies_into_a_free_folder() {
+    let mut f = collecting("collect-free", "a.mov");
+    let r = collect(&mut f).unwrap();
+    assert_eq!((r["copied"].as_u64(), &r["errors"]), (Some(1), &json!([])), "{r}");
+    assert_eq!(f.read("out/(Footage)/a.mov"), SOURCE);
+    assert_eq!(f.read("in/a.mov"), SOURCE, "the original stays");
+    assert!(f.path("out/Project.ecproj").exists());
+}
+
+/// Footage that is where its copy would go is already collected: it is not copied onto itself.
+#[test]
+fn collect_files_leaves_footage_that_is_already_in_the_folder() {
+    let mut f = collecting("collect-in-place", "a.mov");
+    f.footage("out/(Footage)/c.mov");
+    f.write("out/(Footage)/c.mov", b"ALREADY COLLECTED");
+    let r = collect(&mut f).unwrap();
+    assert_eq!((r["copied"].as_u64(), &r["errors"]), (Some(2), &json!([])), "{r}");
+    assert_eq!(f.read("out/(Footage)/c.mov"), b"ALREADY COLLECTED");
+    assert_eq!(f.read("out/(Footage)/a.mov"), SOURCE);
+}
+
+// ---------------------------------------------------------------- the rest
+
+/// The movies a timeline export renders beside it are written like any other output.
+#[test]
+fn a_timeline_export_does_not_pre_render_over_footage() {
+    for background in [false, true] {
+        let mut f = Fixture::new(&format!("timeline-prerender-{background}"));
+        f.comp("Main");
+        f.s.execute("layer.newSolid", json!({"name": "Red", "color": "#ff0000"})).unwrap();
+        // OpenTimelineIO has no solids: the solid is rendered to a movie beside the document.
+        let params = json!({"path": f.text("Main.otio"), "prerender": "unsupported", "background": background});
+        let run = |s: &mut crate::Session, params: Value| {
+            let result = s.execute("file.exportTimeline", params).unwrap();
+            if background {
+                assert!(result["job"].is_string(), "{result}");
+                s.wait_jobs();
+                let done = s.job_log.last().unwrap();
+                assert_eq!(done.status, "done", "{}", done.message);
+                done.result.clone()
+            } else {
+                result
+            }
+        };
+        let r = run(&mut f.s, params.clone());
+        let movies = f.exported();
+        assert_eq!(movies.len(), 1, "{r}");
+        assert_eq!(r["prerendered"].as_array().map(Vec::len), Some(1), "{r}");
+        // That movie is footage now.
+        let movie = std::path::Path::new(&movies[0]).file_name().unwrap().to_string_lossy().into_owned();
+        f.footage(&movie);
+        let r = run(&mut f.s, params);
+        assert_eq!(f.read(&movie), SOURCE, "the footage is as it was");
+        assert_eq!(f.exported().len(), 1, "no second render was started");
+        assert_eq!(r["prerendered"], json!([]), "{r}");
+        let warnings = r["warnings"].as_array().unwrap().iter().filter_map(Value::as_str).collect::<Vec<_>>().join("\n");
+        assert!(warnings.contains(&movie) && warnings.contains("footage"), "the export says why: {r}");
+    }
+}
+
+/// `file.checkOutput` answers before anything is written. Its reply describes current state;
+/// callers still need a guarded write in the owning session, as CLI/MCP frame saves use.
+#[test]
+fn check_output_names_the_files_an_export_may_not_use() {
+    let mut f = reading("check-output", "png");
+    for (file, source) in [("clip.png", "footage"), ("proxy.png", "proxy"), ("shot_00003.png", "footage"), ("Project.ecproj", "project")] {
+        let r = f.s.execute("file.checkOutput", json!({"path": f.text(file)})).unwrap();
+        assert_eq!((r["blocked"].as_bool(), r["source"].as_str()), (Some(true), Some(source)), "{file}: {r}");
+        assert!(r["reason"].as_str().unwrap().contains(file), "{file}: {r}");
+        assert_eq!(r["path"], json!(f.text(file)), "{r}");
+    }
+    let r = f.s.execute("file.checkOutput", json!({"path": f.text("free.png")})).unwrap();
+    assert_eq!((r["blocked"].as_bool(), r["source"].is_null()), (Some(false), true), "{r}");
+    assert!(f.s.execute("file.checkOutput", json!({})).is_err(), "a path is needed");
+    assert!(!f.path("free.png").exists(), "it only looks");
+}
+
+/// A project saved under a timeline's name is not overwritten by the timeline.
+#[test]
+fn a_timeline_export_does_not_write_over_the_project_file() {
+    let mut f = Fixture::new("timeline-project");
+    f.comp("Main");
+    f.s.execute("file.saveAs", json!({"path": f.text("Edit.xml")})).unwrap();
+    let saved = f.read("Edit.xml");
+    let e = f.s.execute("file.exportTimeline", json!({"path": f.text("Edit.xml")})).unwrap_err().to_string();
+    assert!(e.contains("Edit.xml") && e.contains("project"), "{e}");
+    assert_eq!(f.read("Edit.xml"), saved);
+}
+
+#[test]
+fn a_background_timeline_export_rechecks_its_document_before_completion() {
+    let mut f = Fixture::new("timeline-current-project");
+    f.comp("Main");
+    let path = f.text("Pending.xml");
+    let job = f.s.execute("file.exportTimeline", json!({"path": path, "background": true, "prerender": "none"})).unwrap();
+    assert!(job["job"].is_string());
+    // The app may save the project while a background export is waiting to finish.
+    f.s.execute("file.saveAs", json!({"path": path})).unwrap();
+    let saved = f.read("Pending.xml");
+    f.s.wait_jobs();
+    let done = f.s.job_log.last().unwrap();
+    assert_eq!(done.status, "failed", "the destination became the project: {}", done.message);
+    assert!(done.message.contains("project"));
+    assert_eq!(f.read("Pending.xml"), saved);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn background_pre_render_movies_are_checked_again_before_publication() {
+    for source in ["footage", "project"] {
+        let mut f = Fixture::new(&format!("timeline-staged-{source}"));
+        f.comp("Main");
+        f.s.execute("layer.newSolid", json!({"name": "Red"})).unwrap();
+        let params = json!({"path": f.text("Main.otio"), "prerender": "unsupported"});
+        let first = f.s.execute("file.exportTimeline", params.clone()).unwrap();
+        let movie = first["prerendered"][0].as_str().unwrap().to_string();
+        let filename = std::path::Path::new(&movie).file_name().unwrap().to_string_lossy().into_owned();
+        let document = f.read("Main.otio");
+        let mut background = params;
+        background["background"] = json!(true);
+        f.s.execute("file.exportTimeline", background).unwrap();
+        if source == "footage" {
+            f.footage(&filename);
+        } else {
+            f.s.execute("file.saveAs", json!({"path": movie})).unwrap();
+        }
+        let protected = f.read(&filename);
+        f.s.wait_jobs();
+        let done = f.s.job_log.last().unwrap();
+        assert_eq!(done.status, "failed", "{}", done.message);
+        assert!(done.message.contains(source), "{}", done.message);
+        assert_eq!(f.read(&filename), protected);
+        assert_eq!(f.read("Main.otio"), document);
+        assert!(listing(&f.dir).iter().all(|name| !name.starts_with(".effectcraft-prerender-")));
+    }
+}
diff --git a/crates/engine/src/tests_face.rs b/crates/engine/src/tests/face.rs
similarity index 99%
rename from crates/engine/src/tests_face.rs
rename to crates/engine/src/tests/face.rs
index 9e713ff8b..2a45da98f 100644
--- a/crates/engine/src/tests_face.rs
+++ b/crates/engine/src/tests/face.rs
@@ -6,7 +6,7 @@ use effectcraft_track::face::{FaceParams, LANDMARKS, MEASUREMENTS, render_synthe
 use serde_json::json;
 
 use crate::mask_track::MaskMethod;
-use crate::tests_track::{H, W, frame_time, setup};
+use crate::tests::track::{H, W, frame_time, setup};
 
 fn face(f: u32) -> FaceParams {
     let t = f as f64;
diff --git a/crates/engine/src/tests_fidelity.rs b/crates/engine/src/tests/fidelity.rs
similarity index 93%
rename from crates/engine/src/tests_fidelity.rs
rename to crates/engine/src/tests/fidelity.rs
index ebe375601..4fd8a68b8 100644
--- a/crates/engine/src/tests_fidelity.rs
+++ b/crates/engine/src/tests/fidelity.rs
@@ -58,7 +58,8 @@ fn slip_moves_the_source_under_fixed_in_and_out() {
     let before = get(&s);
     assert_eq!((before.start_time, before.in_point.seconds(), before.out_point.seconds()), (Tick::ZERO, 1.0, 3.0));
     // Slip the source 0.5 s later: in/out stay, the source (start) moves.
-    s.execute("layer.slip", json!({"layers": [id], "delta": 0.5})).unwrap();
+    let r = s.execute("layer.slip", json!({"layers": [id], "delta": 0.5})).unwrap();
+    assert_eq!(r["slipped"][0]["clamped"], json!(false));
     let l = get(&s);
     assert_eq!((l.start_time.seconds(), l.in_point, l.out_point), (0.5, before.in_point, before.out_point));
     // The source time at comp 2 s is now 1.5 s.
@@ -67,6 +68,8 @@ fn slip_moves_the_source_under_fixed_in_and_out() {
     let r = s.execute("layer.slip", json!({"layers": [id], "delta": 5.0})).unwrap();
     assert_eq!(get(&s).start_time.seconds(), 1.0);
     assert_eq!(r["slipped"][0]["delta"], json!(0.5));
+    // The response says the 5 s asked for was cut short (#2371).
+    assert_eq!((r["requested"].clone(), r["slipped"][0]["clamped"].clone()), (json!(5.0), json!(true)));
     // Slip by a frame.
     s.execute("layer.slipBack", json!({"layers": [id]})).unwrap();
     assert!((get(&s).start_time.seconds() - (1.0 - 1.0 / 30.0)).abs() < 1e-9);
diff --git a/crates/engine/src/tests_frame_export.rs b/crates/engine/src/tests/frame_export.rs
similarity index 69%
rename from crates/engine/src/tests_frame_export.rs
rename to crates/engine/src/tests/frame_export.rs
index a45c5d444..a8dc938fb 100644
--- a/crates/engine/src/tests_frame_export.rs
+++ b/crates/engine/src/tests/frame_export.rs
@@ -164,3 +164,69 @@ fn copy_frame_hands_the_rendered_frame_to_the_frontend() {
     assert!(Session::default().execute("comp.copyFrame", json!({})).is_err());
     assert!(crate::menus::entries().iter().any(|(path, e)| e.command == "comp.copyFrame" && path.first().map(String::as_str) == Some("Composition")));
 }
+
+#[test]
+fn save_frame_as_png_preserves_alpha_channel() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "AlphaComp", "width": 32, "height": 32, "frameRate": 24, "duration": 1})).unwrap();
+    let red = s.execute("layer.newSolid", json!({"name": "Red", "color": "#ff0000", "width": 16, "height": 16})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": red, "path": "transform/position", "value": [8, 8, 0]})).unwrap();
+    let dir = out_dir("frame-png-alpha");
+    let path = dir.join("alpha.png").to_string_lossy().to_string();
+
+    s.execute("comp.saveFrameAs", json!({"path": path})).unwrap();
+    let img = image::load_from_memory(&std::fs::read(&path).unwrap()).unwrap().to_rgba8();
+    assert_eq!((img.width(), img.height()), (32, 32));
+    let solid_px = img.get_pixel(8, 8);
+    assert_eq!(solid_px[3], 255, "solid region must be opaque: {solid_px:?}");
+    assert_eq!(solid_px[0], 255);
+    let empty_px = img.get_pixel(24, 24);
+    assert_eq!(empty_px[3], 0, "outside solid region must have alpha 0: {empty_px:?}");
+
+    let flat_path = dir.join("flat.png").to_string_lossy().to_string();
+    s.execute_checked("comp.saveFrameAs", json!({"path": flat_path, "transparent": false})).unwrap();
+    let flat_img = image::load_from_memory(&std::fs::read(&flat_path).unwrap()).unwrap().to_rgba8();
+    let flat_empty_px = flat_img.get_pixel(24, 24);
+    assert_eq!(flat_empty_px[3], 255, "transparent: false must composite over background: {flat_empty_px:?}");
+}
+
+#[test]
+fn save_frame_as_queued_respects_frame_default_template() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Comp", "width": 32, "height": 32, "frameRate": 24, "duration": 1})).unwrap();
+
+    // Default Still template is "PNG Sequence" (Channels::Rgb)
+    let r = s.execute_checked("comp.saveFrameAs", json!({"queue": true})).unwrap();
+    assert_eq!(r["queued"], true);
+    let it = s.project.render_queue.last().unwrap();
+    assert_eq!(it.output.name, "PNG Sequence");
+    assert_eq!(it.output.channels, effectcraft_project::render_queue::Channels::Rgb);
+
+    // Test undo and redo of queuing a frame
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(s.project.render_queue.is_empty());
+    s.execute("edit.redo", json!({})).unwrap();
+    let it = s.project.render_queue.last().unwrap();
+    assert_eq!(it.output.name, "PNG Sequence");
+
+    // Explicit transparent: false forces Channels::Rgb
+    s.execute_checked("comp.saveFrameAs", json!({"queue": true, "transparent": false})).unwrap();
+    let it = s.project.render_queue.last().unwrap();
+    assert_eq!(it.output.channels, effectcraft_project::render_queue::Channels::Rgb);
+
+    // When Frame Default is set to an RGBA template, it is respected
+    s.execute_checked("renderQueue.setTemplateDefault", json!({"kind": "outputModule", "slot": "still", "name": "PNG Sequence with Alpha"})).unwrap();
+    s.execute_checked("comp.saveFrameAs", json!({"queue": true})).unwrap();
+    let it = s.project.render_queue.last().unwrap();
+    assert_eq!(it.output.name, "PNG Sequence with Alpha");
+    assert_eq!(it.output.channels, effectcraft_project::render_queue::Channels::Rgba);
+
+    // Passing transparent: false forces Channels::Rgb even with an RGBA template
+    s.execute_checked("comp.saveFrameAs", json!({"queue": true, "transparent": false})).unwrap();
+    let it = s.project.render_queue.last().unwrap();
+    assert_eq!(it.output.channels, effectcraft_project::render_queue::Channels::Rgb);
+
+    // With JPEG Sequence as Frame Default (non-alpha format), queue succeeds without error
+    s.execute_checked("renderQueue.setTemplateDefault", json!({"kind": "outputModule", "slot": "still", "name": "JPEG Sequence"})).unwrap();
+    assert!(s.execute_checked("comp.saveFrameAs", json!({"queue": true})).is_ok());
+}
diff --git a/crates/engine/src/tests_fuzz_open.rs b/crates/engine/src/tests/fuzz_open.rs
similarity index 100%
rename from crates/engine/src/tests_fuzz_open.rs
rename to crates/engine/src/tests/fuzz_open.rs
diff --git a/crates/engine/src/tests_history.rs b/crates/engine/src/tests/history.rs
similarity index 100%
rename from crates/engine/src/tests_history.rs
rename to crates/engine/src/tests/history.rs
diff --git a/crates/engine/src/tests_import_project.rs b/crates/engine/src/tests/import_project.rs
similarity index 100%
rename from crates/engine/src/tests_import_project.rs
rename to crates/engine/src/tests/import_project.rs
diff --git a/crates/engine/src/tests/instance3d.rs b/crates/engine/src/tests/instance3d.rs
new file mode 100644
index 000000000..48f4b7730
--- /dev/null
+++ b/crates/engine/src/tests/instance3d.rs
@@ -0,0 +1,257 @@
+//! Create 3D Layer Instance (Layer ▸ Create): a comp-sized solid at the top of the layer stack
+//! with a 3D Layer Instance effect referencing the selected 3D model layer — a 2D copy of its
+//! render that 2D effects can be applied to (behaviour, pixels, undo/redo, serde).
+
+use std::sync::Arc;
+
+use effectcraft_keyframe::Value as KV;
+use effectcraft_project::{Footage, FootageKind, GroupKind, ItemId, Layer, LayerId, Project};
+use effectcraft_render::{FootageSource, RenderOpts};
+use effectcraft_time::{FrameRate, Tick};
+use serde_json::json;
+
+use crate::{Importer, Session};
+
+fn session() -> Session {
+    let mut s = Session { footage: Arc::new(DiskModels), importer: Some(Arc::new(ModelImporter)), ..Default::default() };
+    s.execute("comp.new", json!({"name": "Scene", "width": 640, "height": 360, "frameRate": 30, "duration": 2})).unwrap();
+    s
+}
+
+fn cid(s: &Session) -> ItemId {
+    s.active_comp_id().unwrap()
+}
+
+fn layer_in(s: &Session, comp: ItemId, id: u64) -> Layer {
+    s.project.comp(comp).unwrap().layer(LayerId(id)).unwrap().clone()
+}
+
+fn px(img: &effectcraft_raster::Image, x: u32, y: u32) -> [f32; 4] {
+    img.data[(y * img.width + x) as usize]
+}
+
+fn close(a: &effectcraft_raster::Image, b: &effectcraft_raster::Image, tol: f32) -> bool {
+    a.data.iter().zip(b.data.iter()).all(|(p, q)| p.iter().zip(q.iter()).all(|(x, y)| (x - y).abs() <= tol))
+}
+
+struct DiskModels;
+
+impl FootageSource for DiskModels {
+    fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<effectcraft_raster::Image>> {
+        None
+    }
+    fn model(&self, _: ItemId, f: &Footage) -> Option<Arc<effectcraft_model::Model>> {
+        let bytes = std::fs::read(&f.path).ok()?;
+        effectcraft_model::load(&f.path, &bytes, &|_| None).ok().map(Arc::new)
+    }
+}
+
+struct ModelImporter;
+
+impl Importer for ModelImporter {
+    fn probe(&self, path: &str) -> Result<Footage, String> {
+        effectcraft_model::format_of(path).ok_or("not a model")?;
+        Ok(Footage { path: path.into(), kind: FootageKind::Model, frame_rate: FrameRate::FPS_30, codec: "glTF".into(), ..Default::default() })
+    }
+}
+
+/// A red triangle in the Z = 0 plane (buffer embedded as a data URI).
+const TRIANGLE: &str = r#"{
+  "asset": {"version": "2.0"},
+  "scenes": [{"nodes": [0]}],
+  "nodes": [{"mesh": 0}],
+  "meshes": [{"primitives": [{"attributes": {"POSITION": 0, "NORMAL": 1}, "material": 0}]}],
+  "materials": [{"pbrMetallicRoughness": {"baseColorFactor": [1.0, 0.0, 0.0, 1.0]}}],
+  "buffers": [{"byteLength": 72, "uri": "data:application/octet-stream;base64,AACAvwAAgL8AAAAAAACAPwAAgL8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/"}],
+  "bufferViews": [
+    {"buffer": 0, "byteOffset": 0, "byteLength": 36},
+    {"buffer": 0, "byteOffset": 36, "byteLength": 36}
+  ],
+  "accessors": [
+    {"bufferView": 0, "componentType": 5126, "type": "VEC3", "count": 3, "min": [-1.0, -1.0, 0.0], "max": [1.0, 1.0, 0.0]},
+    {"bufferView": 1, "componentType": 5126, "type": "VEC3", "count": 3}
+  ]
+}"#;
+
+fn triangle_model(s: &mut Session) -> u64 {
+    let dir = std::env::temp_dir().join(format!("ec-instance3d-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("Triangle.gltf");
+    std::fs::write(&path, TRIANGLE).unwrap();
+    s.execute("layer.newModel", json!({"path": path.to_string_lossy(), "name": "Triangle"})).unwrap()["layer"].as_u64().unwrap()
+}
+
+#[test]
+fn instance3d_creates_a_2d_copy_of_the_model() {
+    let mut s = session();
+    let model = triangle_model(&mut s);
+    // The model renders through the comp's camera.
+    let before = s.render(cid(&s), Tick::ZERO, RenderOpts::default());
+    assert!(px(&before, 320, 180)[3] > 0.9, "the model covers the centre: {:?}", px(&before, 320, 180));
+    assert!(px(&before, 4, 4)[3] < 0.1, "the comp is transparent around it: {:?}", px(&before, 4, 4));
+    // Create 3D Layer Instance.
+    s.execute("layer.select", json!({"layers": [model]})).unwrap();
+    let r = s.execute("layer.create", json!({"op": "instance3d"})).unwrap();
+    let solid = r["layers"][0].as_u64().unwrap();
+    let comp = cid(&s);
+    let l = layer_in(&s, comp, solid);
+    assert_eq!(l.name, "Triangle Instance");
+    assert_eq!(s.active_comp().unwrap().layers[0].id.0, solid, "at the top of the layer stack");
+    // A 3D Layer Instance effect referencing the 3D layer.
+    let g = l.effects().unwrap().groups().next().unwrap().clone();
+    assert!(matches!(&g.kind, GroupKind::Effect { effect } if effect == "ec.3d.instance3d"), "{:?}", g.kind);
+    assert_eq!(g.get("layer").unwrap().value, KV::Layer(Some(model)));
+    // The model is switched off, the copy selected.
+    assert!(!layer_in(&s, comp, model).switches.video, "the referenced 3D layer is off, as After Effects does");
+    assert_eq!(s.state.selected_layers, vec![LayerId(solid)]);
+    // The comp renders the same through the copy: a 2D copy of the 3D layer, transparent
+    // around it.
+    let after = s.render(comp, Tick::ZERO, RenderOpts::default());
+    assert!(close(&before, &after, 2e-2), "the copy shows the model:\n{:?}\n{:?}", px(&before, 320, 180), px(&after, 320, 180));
+    assert!(px(&after, 320, 180)[3] > 0.9 && px(&after, 4, 4)[3] < 0.1, "{:?} {:?}", px(&after, 320, 180), px(&after, 4, 4));
+    // Undo removes the copy and switches the model back on; redo returns it.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(s.active_comp().unwrap().layer(LayerId(solid)).is_none());
+    assert!(layer_in(&s, comp, model).switches.video);
+    s.execute("edit.redo", json!({})).unwrap();
+    assert!(s.active_comp().unwrap().layer(LayerId(solid)).is_some());
+    assert!(!layer_in(&s, comp, model).switches.video);
+    // Serde round-trips the layer parameter.
+    let j = serde_json::to_string(&*s.project).unwrap();
+    let back: Project = serde_json::from_str(&j).unwrap();
+    assert_eq!(back, *s.project);
+    // 2D effects can be applied to the copy (the model layer itself takes none): Fill in blue
+    // recolours the triangle.
+    s.execute("effect.apply", json!({"layer": solid, "effect": "ec.generate.fill"})).unwrap();
+    s.execute("prop.set", json!({"layer": solid, "path": "effects/#2/color", "value": [0.0, 0.0, 1.0, 1.0]})).unwrap();
+    let with_fx = s.render(comp, Tick::ZERO, RenderOpts::default());
+    let p = px(&with_fx, 320, 180);
+    assert!(p[2] > 0.9 && p[0] < 0.1, "the fill recolours the copy: {p:?}");
+}
+
+#[test]
+fn instance3d_also_takes_3d_primitives() {
+    let mut s = session();
+    let prim = s.execute("layer.new3dPrimitive", json!({"kind": "cube", "width": 200, "height": 200, "depth": 200})).unwrap()["layer"].as_u64().unwrap();
+    let before = s.render(cid(&s), Tick::ZERO, RenderOpts::default());
+    let r = s.execute("layer.create", json!({"op": "instance3d", "layers": [prim]})).unwrap();
+    let solid = r["layers"][0].as_u64().unwrap();
+    let l = layer_in(&s, cid(&s), solid);
+    assert_eq!(l.name, "Cube Instance");
+    assert!(!layer_in(&s, cid(&s), prim).switches.video);
+    let after = s.render(cid(&s), Tick::ZERO, RenderOpts::default());
+    assert!(close(&before, &after, 2e-2), "the copy shows the cube");
+}
+
+#[test]
+fn instance3d_needs_a_3d_layer() {
+    let mut s = session();
+    let solid = s.execute("layer.newSolid", json!({"color": "#808080", "width": 100, "height": 100})).unwrap()["layer"].as_u64().unwrap();
+    let err = s.execute_checked("layer.create", json!({"op": "instance3d", "layers": [solid]}));
+    assert!(err.is_err());
+    let text = s.execute("layer.newText", json!({"text": "hi"})).unwrap()["layer"].as_u64().unwrap();
+    assert!(s.execute_checked("layer.create", json!({"op": "instance3d", "layers": [text]})).is_err());
+    // A 3D-switched text layer is not a model layer either (it has 2D pixels of its own).
+    s.execute("layer.setSwitch", json!({"layers": [text], "switch": "threeD", "value": true})).unwrap();
+    assert!(s.execute_checked("layer.create", json!({"op": "instance3d", "layers": [text]})).is_err());
+}
+
+#[test]
+fn instance3d_creates_every_selected_copy_in_one_undo() {
+    let mut s = session();
+    let a = s.execute("layer.new3dPrimitive", json!({"kind": "cube", "width": 120, "height": 120, "depth": 120})).unwrap()["layer"].as_u64().unwrap();
+    let b = s.execute("layer.new3dPrimitive", json!({"kind": "cube", "width": 120, "height": 120, "depth": 120})).unwrap()["layer"].as_u64().unwrap();
+    let r = s.execute("layer.create", json!({"op": "instance3d", "layers": [a, b]})).unwrap();
+    let copies = r["layers"].as_array().unwrap();
+    assert_eq!(copies.len(), 2);
+    let (ia, ib) = (copies[0].as_u64().unwrap(), copies[1].as_u64().unwrap());
+    let comp = cid(&s);
+    assert_ne!(ia, ib);
+    assert_ne!(layer_in(&s, comp, ia).name, layer_in(&s, comp, ib).name, "each copy has a name of its own");
+    // Both sources are off, both copies selected, above their sources in the stack.
+    assert!(!layer_in(&s, comp, a).switches.video && !layer_in(&s, comp, b).switches.video);
+    let mut sel = s.state.selected_layers.clone();
+    let mut want = vec![LayerId(ia), LayerId(ib)];
+    sel.sort_by_key(|l| l.0);
+    want.sort_by_key(|l| l.0);
+    assert_eq!(sel, want);
+    let c = s.active_comp().unwrap();
+    let pos = |id: u64| c.layers.iter().position(|l| l.id.0 == id).unwrap();
+    assert!(pos(ia) < pos(a) && pos(ib) < pos(b), "the copies sit above their sources");
+    // One undo removes both copies and switches both models back on; one redo returns them.
+    s.execute("edit.undo", json!({})).unwrap();
+    let c = s.active_comp().unwrap();
+    assert!(c.layer(LayerId(ia)).is_none() && c.layer(LayerId(ib)).is_none(), "one undo removes every instance");
+    assert!(layer_in(&s, comp, a).switches.video && layer_in(&s, comp, b).switches.video);
+    s.execute("edit.redo", json!({})).unwrap();
+    let c = s.active_comp().unwrap();
+    assert!(c.layer(LayerId(ia)).is_some() && c.layer(LayerId(ib)).is_some(), "one redo returns every instance");
+    assert!(!layer_in(&s, comp, a).switches.video && !layer_in(&s, comp, b).switches.video);
+}
+
+#[test]
+fn instance3d_in_a_mixed_selection_only_takes_the_models() {
+    let mut s = session();
+    let model = triangle_model(&mut s);
+    let solid = s.execute("layer.newSolid", json!({"color": "#808080", "width": 100, "height": 100})).unwrap()["layer"].as_u64().unwrap();
+    let r = s.execute("layer.create", json!({"op": "instance3d", "layers": [model, solid]})).unwrap();
+    let copies = r["layers"].as_array().unwrap();
+    assert_eq!(copies.len(), 1, "only the model gets a copy: {r}");
+    let copy = copies[0].as_u64().unwrap();
+    let comp = cid(&s);
+    assert!(!layer_in(&s, comp, model).switches.video, "the model is switched off");
+    assert!(layer_in(&s, comp, solid).switches.video, "the plain solid is untouched");
+    let skipped = r["skipped"].as_array().unwrap();
+    assert_eq!(skipped.len(), 1);
+    assert!(skipped[0].as_str().unwrap().contains("not a 3D model layer"), "{skipped:?}");
+    // The copy references the model, not the solid.
+    let l = layer_in(&s, comp, copy);
+    let g = l.effects().unwrap().groups().next().unwrap().clone();
+    assert_eq!(g.get("layer").unwrap().value, KV::Layer(Some(model)));
+}
+
+#[test]
+fn instance3d_shows_nothing_outside_the_source_layer_range() {
+    let mut s = session();
+    let model = triangle_model(&mut s);
+    // The model's range ends at 1 s; the comp runs to 2 s.
+    let comp = cid(&s);
+    s.edit("trim", None, |p, _| {
+        p.comp_mut(comp).unwrap().layer_mut(LayerId(model)).unwrap().out_point = Tick::from_seconds_f64(1.0);
+        Ok(())
+    })
+    .unwrap();
+    s.execute("layer.select", json!({"layers": [model]})).unwrap();
+    let r = s.execute("layer.create", json!({"op": "instance3d"})).unwrap();
+    let _copy = r["layers"][0].as_u64().unwrap();
+    // Inside the model's range the copy shows it, transparent around it.
+    let inside = s.render(comp, Tick::from_seconds_f64(0.5), RenderOpts::default());
+    assert!(px(&inside, 320, 180)[3] > 0.9, "the copy shows the model: {:?}", px(&inside, 320, 180));
+    // After its out point the source has nothing to read: the copy is transparent.
+    let outside = s.render(comp, Tick::from_seconds_f64(1.5), RenderOpts::default());
+    assert!(outside.data.iter().all(|p| p[3] < 1e-3), "transparent after the source's out point: {:?}", px(&outside, 320, 180));
+}
+
+#[test]
+fn instance3d_keeps_the_copy_visible_when_the_source_is_soloed() {
+    let mut s = session();
+    let model = triangle_model(&mut s);
+    let comp = cid(&s);
+    // Solo the model, then create the instance: any_solo hides non-soloed layers and the
+    // source's video goes off, so the copy has to take the Solo over.
+    s.edit("solo", None, |p, _| {
+        p.comp_mut(comp).unwrap().layer_mut(LayerId(model)).unwrap().switches.solo = true;
+        Ok(())
+    })
+    .unwrap();
+    let before = s.render(comp, Tick::ZERO, RenderOpts::default());
+    assert!(px(&before, 320, 180)[3] > 0.9, "the soloed model shows: {:?}", px(&before, 320, 180));
+    s.execute("layer.select", json!({"layers": [model]})).unwrap();
+    let r = s.execute("layer.create", json!({"op": "instance3d"})).unwrap();
+    let solid = r["layers"][0].as_u64().unwrap();
+    assert!(layer_in(&s, comp, solid).switches.solo, "the copy takes the source's Solo switch");
+    assert!(!layer_in(&s, comp, model).switches.video, "the source keeps its video off");
+    let after = s.render(comp, Tick::ZERO, RenderOpts::default());
+    assert!(px(&after, 320, 180)[3] > 0.9, "the soloed copy shows the model: {:?}", px(&after, 320, 180));
+    assert!(close(&before, &after, 2e-2), "the comp renders the same through the copy:\n{:?}\n{:?}", px(&before, 320, 180), px(&after, 320, 180));
+}
diff --git a/crates/engine/src/tests_key_metadata_order.rs b/crates/engine/src/tests/key_metadata_order.rs
similarity index 100%
rename from crates/engine/src/tests_key_metadata_order.rs
rename to crates/engine/src/tests/key_metadata_order.rs
diff --git a/crates/engine/src/tests_key_time.rs b/crates/engine/src/tests/key_time.rs
similarity index 99%
rename from crates/engine/src/tests_key_time.rs
rename to crates/engine/src/tests/key_time.rs
index d42d6d4a0..b5ec3a159 100644
--- a/crates/engine/src/tests_key_time.rs
+++ b/crates/engine/src/tests/key_time.rs
@@ -4,7 +4,7 @@ use effectcraft_project::LayerId;
 use effectcraft_time::Tick;
 use serde_json::{Value, json};
 
-use crate::{Session, tests_timeline::prop};
+use crate::{Session, tests::timeline::prop};
 
 fn offset_layer(start: f64, stretch: f64) -> (Session, u64) {
     let mut s = Session::default();
diff --git a/crates/engine/src/tests/keyframe_text.rs b/crates/engine/src/tests/keyframe_text.rs
new file mode 100644
index 000000000..30d3b436e
--- /dev/null
+++ b/crates/engine/src/tests/keyframe_text.rs
@@ -0,0 +1,482 @@
+//! Copied keyframes as After Effects keyframe text for other applications (#1908).
+
+use effectcraft_project::{LayerId, Uid};
+use effectcraft_time::Tick;
+use serde_json::json;
+
+use crate::{KeyRef, Session};
+
+/// A 1920×1080 23.976 fps comp with a 200×100 solid.
+fn session() -> (Session, LayerId) {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Main", "width": 1920, "height": 1080, "frameRate": 23.976, "duration": 10})).unwrap();
+    let id = s.execute("layer.newSolid", json!({"color": "#ff0000", "width": 200, "height": 100})).unwrap()["layer"].as_u64().unwrap();
+    (s, LayerId(id))
+}
+
+fn frame(s: &Session, n: i64) -> Tick {
+    Tick(s.active_comp().unwrap().frame_rate.frame_duration().0 * n)
+}
+
+fn uid(s: &Session, lid: LayerId, path: &str) -> Uid {
+    s.active_comp().unwrap().layer(lid).unwrap().props.prop(path).unwrap().uid
+}
+
+fn edit_layer(s: &mut Session, lid: LayerId, f: impl FnOnce(&mut effectcraft_project::Layer)) {
+    let cid = s.active_comp_id().unwrap();
+    f(std::sync::Arc::make_mut(&mut s.project).comp_mut(cid).unwrap().layer_mut(lid).unwrap());
+}
+
+fn add_key(s: &mut Session, lid: LayerId, path: &str, time: Tick, value: serde_json::Value) {
+    s.execute("prop.addKey", json!({"layer": lid.0, "path": path, "time": time.seconds(), "value": value})).unwrap();
+}
+
+#[test]
+fn copied_keys_are_after_effects_text_in_comp_frames() {
+    let (mut s, l) = session();
+    // The layer starts 10 frames in: its keys at layer frames 2, 5 and 9 are comp frames 12, 15 and 19.
+    let start = frame(&s, 10);
+    edit_layer(&mut s, l, |l| l.start_time = start);
+    for (n, v) in [(2, [960.0, 540.0]), (5, [1000.5, 520.25]), (9, [1100.0, 500.0])] {
+        let t = frame(&s, n);
+        add_key(&mut s, l, "transform/position", t, json!(v));
+    }
+    let t = frame(&s, 5);
+    add_key(&mut s, l, "transform/rotation", t, json!(-45));
+    let (position, rotation) = (uid(&s, l, "transform/position"), uid(&s, l, "transform/rotation"));
+    // A subset: two of the three Position keys and the Rotation key.
+    s.state.selected_keys = [(position, 2), (position, 9), (rotation, 5)].map(|(prop, n)| KeyRef { layer: l, prop, time: frame(&s, n) }).to_vec();
+    s.execute("keys.copy", json!({})).unwrap();
+    assert_eq!(
+        s.state.keyframe_text.as_deref(),
+        Some(
+            "Adobe After Effects 9.0 Keyframe Data\n\n\tUnits Per Second\t23.976\n\tSource Width\t200\n\tSource Height\t100\n\tSource Pixel Aspect Ratio\t1\n\tComp Pixel Aspect Ratio\t1\n\n\
+             Layer\n\
+             Transform\tPosition\n\tFrame\tX pixels\tY pixels\tZ pixels\t\n\t12\t960\t540\t0\t\n\t19\t1100\t500\t0\t\n\n\
+             Transform\tRotation\n\tFrame\tdegrees\t\n\t15\t-45\t\n\n\
+             \n\
+             End of Keyframe Data\n"
+        )
+    );
+    // The internal clipboard still has the keys themselves, relative to the earliest.
+    let times: Vec<Vec<Tick>> = s.state.key_clipboard.iter().map(|c| c.keys.iter().map(|k| k.time).collect()).collect();
+    assert_eq!(times, [vec![Tick::ZERO, frame(&s, 7)], vec![frame(&s, 3)]]);
+}
+
+#[test]
+fn a_stretched_layer_writes_the_frames_its_keys_show_at() {
+    let (mut s, l) = session();
+    edit_layer(&mut s, l, |l| l.stretch = 200.0);
+    let t = frame(&s, 6);
+    add_key(&mut s, l, "transform/opacity", Tick::ZERO, json!(0));
+    add_key(&mut s, l, "transform/opacity", t, json!(100));
+    s.execute("prop.select", json!({"layer": l.0, "path": "transform/opacity"})).unwrap();
+    s.execute("edit.copy", json!({})).unwrap();
+    let text = s.state.keyframe_text.clone().unwrap();
+    assert!(text.contains("Transform\tOpacity\n\tFrame\tpercent\t\n\t0\t0\t\n\t12\t100\t\n\n"), "{text}");
+}
+
+#[test]
+fn copied_static_values_have_no_frame() {
+    let (mut s, l) = session();
+    s.execute("prop.set", json!({"layer": l.0, "path": "transform/position", "value": [100, 200]})).unwrap();
+    s.execute("prop.select", json!({"layer": l.0, "path": "transform/position"})).unwrap();
+    s.execute("edit.copy", json!({})).unwrap();
+    let text = s.state.keyframe_text.clone().unwrap();
+    assert!(text.contains("Transform\tPosition\n\tFrame\tX pixels\tY pixels\tZ pixels\t\n\t\t100\t200\t0\t\n\n"), "{text}");
+    assert_eq!(s.state.value_clipboard.len(), 1, "the internal clipboard keeps the value");
+}
+
+#[test]
+fn a_copied_transform_group_lists_what_the_layer_shows() {
+    let (mut s, l) = session();
+    let t = frame(&s, 24);
+    add_key(&mut s, l, "transform/scale", Tick::ZERO, json!([50, 50, 100]));
+    add_key(&mut s, l, "transform/scale", t, json!([150, 150, 100]));
+    let transform = s.active_comp().unwrap().layer(l).unwrap().props.sub("transform").unwrap().uid;
+    s.execute("prop.select", json!({"layer": l.0, "prop": transform, "selectKeys": false})).unwrap();
+    s.execute("edit.copy", json!({})).unwrap();
+    let text = s.state.keyframe_text.clone().unwrap();
+    let names: Vec<&str> = text.lines().filter_map(|line| line.strip_prefix("Transform\t")).collect();
+    assert_eq!(names, ["Anchor Point", "Position", "Scale", "Rotation", "Opacity"], "a 2D layer has no Orientation or X / Y Rotation");
+    assert!(text.contains("\tFrame\tX percent\tY percent\tZ percent\t\n\t0\t50\t50\t100\t\n\t24\t150\t150\t100\t\n"), "{text}");
+    // 3D: Orientation and X / Y Rotation. Z Rotation stays Rotation, and Orientation's three
+    // values sit under one label, as After Effects writes them.
+    edit_layer(&mut s, l, |l| l.switches.three_d = true);
+    s.execute("prop.select", json!({"layer": l.0, "prop": transform, "selectKeys": false})).unwrap();
+    s.execute("edit.copy", json!({})).unwrap();
+    let text = s.state.keyframe_text.clone().unwrap();
+    let names: Vec<&str> = text.lines().filter_map(|line| line.strip_prefix("Transform\t")).collect();
+    assert_eq!(names, ["Anchor Point", "Position", "Scale", "Orientation", "X Rotation", "Y Rotation", "Rotation", "Opacity"]);
+    assert!(text.contains("Transform\tOrientation\n\tFrame\tX degrees\t\n\t\t0\t0\t0\t\n"), "{text}");
+}
+
+fn copy_transform(s: &mut Session, lid: LayerId) -> String {
+    let transform = s.active_comp().unwrap().layer(lid).unwrap().props.sub("transform").unwrap().uid;
+    s.execute("prop.select", json!({"layer": lid.0, "prop": transform, "selectKeys": false})).unwrap();
+    s.execute("edit.copy", json!({})).unwrap();
+    s.state.keyframe_text.clone().unwrap()
+}
+
+fn names(text: &str) -> Vec<&str> {
+    text.lines().filter_map(|line| line.strip_prefix("Transform\t")).collect()
+}
+
+#[test]
+fn properties_the_layer_does_not_use_are_left_out() {
+    // Separate Dimensions: the old Position no longer moves the layer.
+    let (mut s, l) = session();
+    s.execute("prop.set", json!({"layer": l.0, "path": "transform/position", "value": [100, 200]})).unwrap();
+    s.execute("prop.separateDimensions", json!({"layer": l.0, "value": true})).unwrap();
+    s.execute("prop.set", json!({"layer": l.0, "path": "transform/positionX", "value": 321})).unwrap();
+    let text = copy_transform(&mut s, l);
+    assert!(!names(&text).contains(&"Position"), "{text}");
+    // A one-node camera has no Point of Interest; a two-node one does.
+    let cam = LayerId(s.execute("layer.newCamera", json!({"type": "oneNode"})).unwrap()["layer"].as_u64().unwrap());
+    let text = copy_transform(&mut s, cam);
+    assert!(!names(&text).contains(&"Point of Interest"), "{text}");
+    s.execute("layer.cameraSettings", json!({"layer": cam.0, "type": "twoNode"})).unwrap();
+    let text = copy_transform(&mut s, cam);
+    assert!(names(&text).contains(&"Point of Interest"), "{text}");
+}
+
+#[test]
+fn separated_position_writes_x_y_and_z_position() {
+    let (mut s, l) = session();
+    s.execute("prop.separateDimensions", json!({"layer": l.0, "value": true})).unwrap();
+    let t = frame(&s, 12);
+    add_key(&mut s, l, "transform/positionX", Tick::ZERO, json!(100));
+    add_key(&mut s, l, "transform/positionX", t, json!(321));
+    s.execute("prop.set", json!({"layer": l.0, "path": "transform/positionY", "value": 200})).unwrap();
+    let text = copy_transform(&mut s, l);
+    // After Effects labels their single column with no unit.
+    assert!(text.contains("Transform\tX Position\n\tFrame\t\t\n\t0\t100\t\n\t12\t321\t\n\nTransform\tY Position\n\tFrame\t\t\n\t\t200\t\n\n"), "{text}");
+    assert!(!names(&text).contains(&"Z Position"), "a 2D layer has no Z Position: {text}");
+    edit_layer(&mut s, l, |l| l.switches.three_d = true);
+    let text = copy_transform(&mut s, l);
+    assert!(text.contains("Transform\tZ Position\n\tFrame\t\t\n\t\t0\t\n"), "{text}");
+}
+
+#[test]
+fn time_remap_writes_source_seconds_at_comp_frames() {
+    let (mut s, l) = session();
+    let r = s.execute("layer.precompose", json!({"layers": [l.0], "name": "Inner"})).unwrap();
+    let l = LayerId(r["layer"].as_u64().unwrap());
+    s.execute("layer.select", json!({"layers": [l.0]})).unwrap();
+    s.execute("layer.enableTimeRemap", json!({})).unwrap();
+    let start = frame(&s, 10);
+    edit_layer(&mut s, l, |l| l.start_time = start);
+    let t = frame(&s, 6);
+    add_key(&mut s, l, "timeRemap", t, json!(2.5));
+    s.execute("prop.select", json!({"layer": l.0, "path": "timeRemap"})).unwrap();
+    s.execute("edit.copy", json!({})).unwrap();
+    let text = s.state.keyframe_text.clone().unwrap();
+    // As After Effects writes it: the key at layer frame 6 of a layer starting at frame 10 is at 16.
+    assert!(text.contains("Layer\nTime Remap\n\tFrame\tseconds\t\n\t10\t0\t\n\t16\t2.5\t\n"), "{text}");
+}
+
+/// Selects the layer's properties at `paths` and copies them.
+fn copy_props(s: &mut Session, lid: LayerId, paths: &[&str]) -> String {
+    for (i, path) in paths.iter().enumerate() {
+        s.execute("prop.select", json!({"layer": lid.0, "path": path, "add": i > 0, "selectKeys": false})).unwrap();
+    }
+    s.execute("edit.copy", json!({})).unwrap();
+    s.state.keyframe_text.clone().unwrap()
+}
+
+#[test]
+fn effect_properties_are_written_as_after_effects_does() {
+    // The blocks After Effects 2019 wrote for the same effects and values (2019 has no Dropdown
+    // Menu Control: that block follows its other popups, written 1-based with no unit).
+    let (mut s, l) = session();
+    for fx in ["Fill", "Checkbox Control", "Dropdown Menu Control", "Slider Control", "Point Control"] {
+        s.execute("effect.apply", json!({"layer": l.0, "effect": fx})).unwrap();
+    }
+    let t = frame(&s, 12);
+    add_key(&mut s, l, "effects/#1/color", Tick::ZERO, json!([1, 0.5, 0.25, 1]));
+    add_key(&mut s, l, "effects/#1/color", t, json!([0, 0, 1, 1]));
+    add_key(&mut s, l, "effects/#2/checkbox", Tick::ZERO, json!(true));
+    add_key(&mut s, l, "effects/#2/checkbox", t, json!(false));
+    s.execute("prop.set", json!({"layer": l.0, "path": "effects/#3/menu", "value": 1})).unwrap();
+    s.execute("prop.set", json!({"layer": l.0, "path": "effects/#4/slider", "value": 20.5})).unwrap();
+    s.execute("prop.set", json!({"layer": l.0, "path": "effects/#5/point", "value": [10, 20]})).unwrap();
+    // After Effects writes a renamed effect under the effect's own name.
+    let slider = s.active_comp().unwrap().layer(l).unwrap().props.group("effects/#4").unwrap().uid;
+    s.execute("prop.renameGroup", json!({"layer": l.0, "prop": slider, "name": "My Slider"})).unwrap();
+    let text = copy_props(&mut s, l, &["effects/#1/color", "effects/#2/checkbox", "effects/#3/menu", "effects/#4/slider", "effects/#5/point"]);
+    assert!(
+        text.contains(
+            "Layer\n\
+             Effects\tFill #1\tColor #4\n\tFrame\talpha \tred \tgreen \tblue \t\n\t0\t255\t255\t127.5\t63.75\t\n\t12\t255\t0\t0\t255\t\n\n\
+             Effects\tCheckbox Control #2\tCheckbox #2\n\tFrame\t\t\n\t0\t1\t\n\t12\t0\t\n\n\
+             Effects\tDropdown Menu Control #3\tMenu #2\n\tFrame\t\t\n\t\t2\t\n\n\
+             Effects\tSlider Control #4\tSlider #2\n\tFrame\t\t\n\t\t20.5\t\n\n\
+             Effects\tPoint Control #5\tPoint #2\n\tFrame\tX pixels\tY pixels\t\n\t\t10\t20\t\n\n"
+        ),
+        "{text}"
+    );
+}
+
+#[test]
+fn effect_properties_have_after_effects_indices() {
+    // After Effects 2019 numbered Fractal Noise's Rotation (in the Transform group) #9,
+    // Complexity (after it) #17, Evolution #25, and Opacity (after Evolution Options) #31: a
+    // group takes an index where it opens and closes, and its properties are written without
+    // it. Set Matte's Use For Matte is #3: the layer parameter before it has no extra index for
+    // its source choice.
+    let (mut s, l) = session();
+    for fx in ["Fractal Noise", "Set Matte"] {
+        s.execute("effect.apply", json!({"layer": l.0, "effect": fx})).unwrap();
+    }
+    let text = copy_props(
+        &mut s,
+        l,
+        &[
+            "effects/#1/transform/rotation",
+            "effects/#1/complexity",
+            "effects/#1/evolution",
+            "effects/#1/opacity",
+            "effects/#1/blendingMode",
+            "effects/#2/takeMatteFrom",
+        ],
+    );
+    for header in [
+        "Effects\tFractal Noise #1\tRotation #9\n",
+        "Effects\tFractal Noise #1\tComplexity #17\n",
+        "Effects\tFractal Noise #1\tEvolution #25\n",
+        "Effects\tFractal Noise #1\tOpacity #31\n",
+        "Effects\tFractal Noise #1\tBlending Mode #32\n",
+        "Effects\tSet Matte #2\tUse For Matte #3\n",
+    ] {
+        assert!(text.contains(header), "{header}in\n{text}");
+    }
+}
+
+#[test]
+fn effect_parameters_after_effects_numbers_or_labels_otherwise_follow_it() {
+    // After Effects 2019: Radial Blur counts a hidden parameter before Amount, which has no
+    // unit; 3D Channel Extract lists Anti-alias before Clamp Output; Selective Color's per-color
+    // sliders start at #10 and are percent.
+    let (mut s, l) = session();
+    for fx in ["Radial Blur", "3D Channel Extract", "Selective Color"] {
+        s.execute("effect.apply", json!({"layer": l.0, "effect": fx})).unwrap();
+    }
+    let text = copy_props(
+        &mut s,
+        l,
+        &["effects/#1/amount", "effects/#1/center", "effects/#2/antialias", "effects/#2/invertDepthMap", "effects/#3/details/reds/redsCyan"],
+    );
+    for block in [
+        "Effects\tRadial Blur #1\tAmount #3\n\tFrame\t\t\n",
+        "Effects\tRadial Blur #1\tCenter #4\n\tFrame\tX pixels\tY pixels\t\n",
+        "Effects\t3D Channel Extract #2\tAnti-alias #5\n\tFrame\t\t\n",
+        "Effects\t3D Channel Extract #2\tInvert Depth Map #7\n\tFrame\t\t\n",
+        "Effects\tSelective Color #3\tReds Cyan #10\n\tFrame\tpercent\t\n",
+    ] {
+        assert!(text.contains(block), "{block}in\n{text}");
+    }
+}
+
+#[test]
+fn mask_properties_are_written_as_after_effects_does() {
+    // The blocks After Effects 2019 wrote for the same masks and values: masks go by place, not
+    // name, and Mask Path is left out.
+    let (mut s, l) = session();
+    for _ in 0..2 {
+        s.execute("mask.new", json!({"layer": l.0, "vertices": [[0, 0], [100, 0], [100, 100]], "closed": true})).unwrap();
+    }
+    let t = frame(&s, 12);
+    for (prop, a, b) in [("feather", json!([5, 5]), json!([10, 20])), ("opacity", json!(50), json!(75)), ("expansion", json!(3), json!(-4))] {
+        add_key(&mut s, l, &format!("masks/#1/{prop}"), Tick::ZERO, a);
+        add_key(&mut s, l, &format!("masks/#1/{prop}"), t, b);
+    }
+    s.execute("prop.set", json!({"layer": l.0, "path": "masks/#2/feather", "value": [7, 8]})).unwrap();
+    let second = s.active_comp().unwrap().layer(l).unwrap().props.group("masks/#2").unwrap().uid;
+    s.execute("prop.renameGroup", json!({"layer": l.0, "prop": second, "name": "Renamed Mask"})).unwrap();
+    let text = copy_props(&mut s, l, &["masks/#1/path", "masks/#1/feather", "masks/#1/opacity", "masks/#1/expansion", "masks/#2/feather"]);
+    assert!(
+        text.contains(
+            "Layer\n\
+             Masks\tMask #1\tMask Feather\n\tFrame\tX pixels\tY pixels\t\n\t0\t5\t5\t\n\t12\t10\t20\t\n\n\
+             Masks\tMask #1\tMask Opacity\n\tFrame\tpercent\t\n\t0\t50\t\n\t12\t75\t\n\n\
+             Masks\tMask #1\tMask Expansion\n\tFrame\tpixels\t\n\t0\t3\t\n\t12\t-4\t\n\n\
+             Masks\tMask #2\tMask Feather\n\tFrame\tX pixels\tY pixels\t\n\t\t7\t8\t\n\n\
+             \nEnd of Keyframe Data\n"
+        ),
+        "{text}"
+    );
+}
+
+#[test]
+fn text_properties_are_written_as_after_effects_does() {
+    // The blocks After Effects 2019 wrote for the same text properties and values.
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 1920, "height": 1080, "frameRate": 23.976})).unwrap();
+    let l = LayerId(s.execute("layer.newText", json!({"text": "Hello"})).unwrap()["layer"].as_u64().unwrap());
+    s.execute("layer.addTextAnimator", json!({"properties": ["position", "fillColor"]})).unwrap();
+    s.execute("layer.addTextAnimator", json!({"properties": ["opacity"]})).unwrap();
+    let second = s.active_comp().unwrap().layer(l).unwrap().props.group("text/animators/#2").unwrap().uid;
+    s.execute("prop.renameGroup", json!({"layer": l.0, "prop": second, "name": "Fade"})).unwrap();
+    let t = frame(&s, 12);
+    add_key(&mut s, l, "text/sourceText", Tick::ZERO, json!("Hello"));
+    add_key(&mut s, l, "text/pathOptions/firstMargin", Tick::ZERO, json!(0));
+    add_key(&mut s, l, "text/pathOptions/firstMargin", t, json!(50));
+    add_key(&mut s, l, "text/animators/#1/selectors/#1/start", Tick::ZERO, json!(0));
+    add_key(&mut s, l, "text/animators/#1/selectors/#1/start", t, json!(100));
+    add_key(&mut s, l, "text/animators/#1/properties/position", Tick::ZERO, json!([0, 0, 0]));
+    add_key(&mut s, l, "text/animators/#1/properties/position", t, json!([10, -20, 0]));
+    for (path, v) in [
+        ("text/animators/#1/selectors/#1/end", json!(80)),
+        ("text/animators/#1/selectors/#1/offset", json!(-10)),
+        ("text/animators/#1/properties/fillColor", json!([1, 0, 0, 1])),
+        ("text/moreOptions/groupingAlignment", json!([10, -20])),
+    ] {
+        s.execute("prop.set", json!({"layer": l.0, "path": path, "value": v})).unwrap();
+    }
+    let text = copy_props(
+        &mut s,
+        l,
+        &[
+            "text/sourceText",
+            "text/pathOptions/firstMargin",
+            "text/animators/#1/selectors/#1/start",
+            "text/animators/#1/selectors/#1/end",
+            "text/animators/#1/selectors/#1/offset",
+            "text/animators/#1/selectors/#1/advanced/amount",
+            "text/animators/#1/properties/position",
+            "text/animators/#1/properties/fillColor",
+            "text/animators/#2/properties/opacity",
+            "text/moreOptions/groupingAlignment",
+        ],
+    );
+    for block in [
+        "Text\tPath Options\tFirst Margin\n\tFrame\t\t\n\t0\t0\t\n\t12\t50\t\n\n",
+        "Text\tAnimators\tAnimator #1\tSelectors\tRange Selector #1\tStart #1\n\tFrame\tpercent\t\n\t0\t0\t\n\t12\t100\t\n\n",
+        "Text\tAnimators\tAnimator #1\tSelectors\tRange Selector #1\tEnd #2\n\tFrame\tpercent\t\n\t\t80\t\n\n",
+        "Text\tAnimators\tAnimator #1\tSelectors\tRange Selector #1\tOffset #3\n\tFrame\tpercent\t\n\t\t-10\t\n\n",
+        "Text\tAnimators\tAnimator #1\tProperties\tPosition\n\tFrame\tX pixels\tY pixels\tZ pixels\t\n\t0\t0\t0\t0\t\n\t12\t10\t-20\t0\t\n\n",
+        "Text\tAnimators\tAnimator #1\tProperties\tFill Color\n\tFrame\talpha \tred \tgreen \tblue \t\n\t\t255\t255\t0\t0\t\n\n",
+        "Text\tAnimators\tAnimator #2\tProperties\tOpacity\n\tFrame\tpercent\t\n\t\t100\t\n\n",
+        "Text\tAnimators\tAnimator #1\tSelectors\tRange Selector #1\tAdvanced\tAmount\n\tFrame\tpercent\t\n\t\t100\t\n\n",
+        "Text\tMore Options\tGrouping Alignment\n\tFrame\tX percent\tY percent\t\n\t\t10\t-20\t\n\n",
+    ] {
+        assert!(text.contains(block), "{block}\nin\n{text}");
+    }
+    assert!(!text.contains("Source Text"), "{text}");
+}
+
+#[test]
+fn a_2d_layer_writes_the_z_it_shows() {
+    // Keys pasted from a 3D layer keep their Z on a 2D one, which ignores it.
+    let (mut s, l) = session();
+    let src = LayerId(s.execute("layer.newSolid", json!({"color": "#00ff00", "width": 200, "height": 100})).unwrap()["layer"].as_u64().unwrap());
+    edit_layer(&mut s, src, |l| l.switches.three_d = true);
+    add_key(&mut s, src, "transform/position", Tick::ZERO, json!([100, 200, 300]));
+    add_key(&mut s, src, "transform/scale", Tick::ZERO, json!([50, 60, 70]));
+    s.state.selected_keys = ["transform/position", "transform/scale"].map(|p| KeyRef { layer: src, prop: uid(&s, src, p), time: Tick::ZERO }).to_vec();
+    s.execute("keys.copy", json!({})).unwrap();
+    s.execute("keys.paste", json!({"layers": [l.0], "time": 0})).unwrap();
+    let pasted = s.active_comp().unwrap().layer(l).unwrap().props.prop("transform/position").unwrap().keys[0].value.components();
+    assert_eq!(pasted, [100.0, 200.0, 300.0], "the 2D layer keeps the pasted Z");
+    s.state.selected_keys = ["transform/position", "transform/scale"].map(|p| KeyRef { layer: l, prop: uid(&s, l, p), time: Tick::ZERO }).to_vec();
+    s.execute("keys.copy", json!({})).unwrap();
+    let text = s.state.keyframe_text.clone().unwrap();
+    assert!(text.contains("Transform\tPosition\n\tFrame\tX pixels\tY pixels\tZ pixels\t\n\t0\t100\t200\t0\t\n"), "{text}");
+    assert!(text.contains("Transform\tScale\n\tFrame\tX percent\tY percent\tZ percent\t\n\t0\t50\t60\t100\t\n"), "{text}");
+}
+
+#[test]
+fn the_header_has_the_source_pixel_aspect() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 1920, "height": 1080, "frameRate": 24, "pixelAspect": 1.2})).unwrap();
+    let solid = LayerId(s.execute("layer.newSolid", json!({"width": 200, "height": 100, "pixelAspect": 1.5})).unwrap()["layer"].as_u64().unwrap());
+    let text = copy_transform(&mut s, solid);
+    assert!(text.contains("\tSource Pixel Aspect Ratio\t1.5\n\tComp Pixel Aspect Ratio\t1.2\n"), "{text}");
+    // A text layer: 1 × 1, as After Effects 2019 wrote it, with the comp's pixel aspect.
+    let t = LayerId(s.execute("layer.newText", json!({"text": "Hi"})).unwrap()["layer"].as_u64().unwrap());
+    let text = copy_transform(&mut s, t);
+    assert!(text.contains("\tSource Width\t1\n\tSource Height\t1\n\tSource Pixel Aspect Ratio\t1.2\n"), "{text}");
+    // A shape layer has no source of its own: the comp's size.
+    let shape = LayerId(s.execute("layer.newShape", json!({})).unwrap()["layer"].as_u64().unwrap());
+    let text = copy_transform(&mut s, shape);
+    assert!(text.contains("\tSource Width\t1920\n\tSource Height\t1080\n"), "{text}");
+}
+
+#[test]
+fn keys_from_two_layers_have_no_text() {
+    let (mut s, a) = session();
+    let b = LayerId(s.execute("layer.newSolid", json!({"color": "#00ff00", "width": 200, "height": 100})).unwrap()["layer"].as_u64().unwrap());
+    for l in [a, b] {
+        add_key(&mut s, l, "transform/opacity", Tick::ZERO, json!(50));
+    }
+    s.state.selected_keys = [a, b].map(|l| KeyRef { layer: l, prop: uid(&s, l, "transform/opacity"), time: Tick::ZERO }).to_vec();
+    s.execute("keys.copy", json!({})).unwrap();
+    assert_eq!(s.state.keyframe_text, None, "After Effects copies one layer's keys as text");
+    assert_eq!(s.state.key_clipboard.len(), 2, "EffectCraft's own clipboard has both");
+    // A copied layer leaves no text behind.
+    s.state.selected_keys = vec![KeyRef { layer: a, prop: uid(&s, a, "transform/opacity"), time: Tick::ZERO }];
+    s.execute("keys.copy", json!({})).unwrap();
+    assert!(s.state.keyframe_text.is_some());
+    s.state.selected_keys.clear();
+    s.execute("edit.copy", json!({"layers": [a.0]})).unwrap();
+    assert_eq!(s.state.keyframe_text, None);
+}
+
+#[test]
+fn shape_contents_are_written_as_after_effects_does() {
+    // Headers and labels After Effects 2019 wrote for the same shape items: items go by kind and
+    // place in their group, and a Size has no unit (`X `).
+    let (mut s, _) = session();
+    let sh = LayerId(s.execute("layer.newShape", json!({"kind": "none"})).unwrap()["layer"].as_u64().unwrap());
+    for (kind, group) in [("group", None), ("rectangle", Some("contents/#1")), ("fill", Some("contents/#1")), ("star", None), ("repeater", None)] {
+        let mut p = json!({"layer": sh.0, "kind": kind});
+        if let Some(g) = group {
+            p["group"] = json!(g);
+        }
+        s.execute("layer.addShapeItem", p).unwrap();
+    }
+    let text = copy_props(
+        &mut s,
+        sh,
+        &[
+            "contents/#1/contents/#1/size",
+            "contents/#1/contents/#2/color",
+            "contents/#1/transform/position",
+            "contents/#2/points",
+            "contents/#3/transform/startOpacity",
+        ],
+    );
+    for block in [
+        "Contents\tGroup #1\tContents\tRectangle Path #1\tSize\n\tFrame\tX \tY \t\n",
+        "Contents\tGroup #1\tContents\tFill #2\tColor\n\tFrame\talpha \tred \tgreen \tblue \t\n",
+        "Contents\tGroup #1\tTransform\tPosition\n\tFrame\tX pixels\tY pixels\t\n",
+        "Contents\tPolystar Path #2\tPoints\n\tFrame\t\t\n",
+        "Contents\tRepeater #3\tTransform\tStart Opacity\n\tFrame\tpercent\t\n",
+    ] {
+        assert!(text.contains(block), "{block}in\n{text}");
+    }
+}
+
+#[test]
+fn camera_light_and_material_options_are_written_as_after_effects_does() {
+    // Blocks After Effects 2019 wrote for these options, defaults included: Zoom and Shadow
+    // Diffusion in pixels, Highlight Threshold on 0–1, and the material's shadow choices from 0.
+    let (mut s, l) = session();
+    let cam = LayerId(s.execute("layer.newCamera", json!({})).unwrap()["layer"].as_u64().unwrap());
+    let text = copy_props(&mut s, cam, &["cameraOptions/zoom", "cameraOptions/highlightThreshold"]);
+    assert!(text.contains("Camera Options\tZoom\n\tFrame\tpixels\t\n"), "{text}");
+    assert!(text.contains("Camera Options\tHighlight Threshold\n\tFrame\t\t\n\t\t1\t\n"), "{text}");
+    let light = LayerId(s.execute("layer.newLight", json!({"type": "spot"})).unwrap()["layer"].as_u64().unwrap());
+    let text = copy_props(&mut s, light, &["lightOptions/intensity", "lightOptions/shadowDiffusion"]);
+    assert!(text.contains("Light Options\tIntensity\n\tFrame\tpercent\t\n\t\t100\t\n"), "{text}");
+    assert!(text.contains("Light Options\tShadow Diffusion\n\tFrame\tpixels\t\n\t\t0\t\n"), "{text}");
+    edit_layer(&mut s, l, |l| l.switches.three_d = true);
+    let text = copy_props(&mut s, l, &["materialOptions/castsShadows", "materialOptions/acceptsShadows", "materialOptions/diffuse"]);
+    for block in [
+        "Material Options\tCasts Shadows\n\tFrame\t\t\n\t\t0\t\n",
+        "Material Options\tAccepts Shadows\n\tFrame\t\t\n\t\t1\t\n",
+        "Material Options\tDiffuse\n\tFrame\tpercent\t\n\t\t50\t\n",
+    ] {
+        assert!(text.contains(block), "{block}in\n{text}");
+    }
+}
diff --git a/crates/engine/src/tests_keylight.rs b/crates/engine/src/tests/keylight.rs
similarity index 100%
rename from crates/engine/src/tests_keylight.rs
rename to crates/engine/src/tests/keylight.rs
diff --git a/crates/engine/src/tests_limits.rs b/crates/engine/src/tests/limits.rs
similarity index 100%
rename from crates/engine/src/tests_limits.rs
rename to crates/engine/src/tests/limits.rs
diff --git a/crates/engine/src/tests_lottie.rs b/crates/engine/src/tests/lottie.rs
similarity index 100%
rename from crates/engine/src/tests_lottie.rs
rename to crates/engine/src/tests/lottie.rs
diff --git a/crates/engine/src/tests_m137.rs b/crates/engine/src/tests/m137.rs
similarity index 100%
rename from crates/engine/src/tests_m137.rs
rename to crates/engine/src/tests/m137.rs
diff --git a/crates/engine/src/tests_m145.rs b/crates/engine/src/tests/m145.rs
similarity index 99%
rename from crates/engine/src/tests_m145.rs
rename to crates/engine/src/tests/m145.rs
index 68b897617..831a05ead 100644
--- a/crates/engine/src/tests_m145.rs
+++ b/crates/engine/src/tests/m145.rs
@@ -345,7 +345,7 @@ fn render_queue_uses_default_folder_bit_depth_names_and_segments() {
 fn every_wired_setting_is_live_and_display_only_ones_are_documented() {
     let todo = crate::prefs::todo_keys();
     assert_eq!(todo, ["general.useSystemColorPicker", "composition.hardwareAcceleratePanels", "scripting.enableJsDebugger"]);
-    let docs = include_str!("../../../docs/preferences.md");
+    let docs = include_str!("../../../../docs/preferences.md");
     assert!(docs.contains("### Display-only settings"));
     assert!(!docs.contains("Not wired yet"));
 }
@@ -708,6 +708,11 @@ fn dynamic_menus_and_window_viewer_labels() {
     s.prefs.push_recent("/p/One.ecproj");
     let (e, _) = crate::menus::dynamic(&s, "recentProjects", &Default::default());
     assert_eq!((e[0].label.as_str(), e[0].command.as_str()), ("One.ecproj", "file.openRecent"));
+    // Two projects with the same file name show their paths.
+    s.prefs.push_recent("/q/One.ecproj");
+    s.prefs.push_recent("/p/Two.ecproj");
+    let (e, _) = crate::menus::dynamic(&s, "recentProjects", &Default::default());
+    assert_eq!(e.iter().map(|e| e.label.as_str()).collect::<Vec<_>>(), ["Two.ecproj", "/q/One.ecproj", "/p/One.ecproj"]);
     assert_eq!(crate::menus::dynamic(&s, "history", &Default::default()).0.len(), s.history.undo.len());
     let a = solid(&mut s, "#ff0000");
     s.state.selected_layers = vec![LayerId(a)];
diff --git a/crates/engine/src/tests_markers.rs b/crates/engine/src/tests/markers.rs
similarity index 94%
rename from crates/engine/src/tests_markers.rs
rename to crates/engine/src/tests/markers.rs
index afe4b9890..40049d6e7 100644
--- a/crates/engine/src/tests_markers.rs
+++ b/crates/engine/src/tests/markers.rs
@@ -3,7 +3,7 @@
 
 use serde_json::json;
 
-use crate::tests_timeline::setup;
+use crate::tests::timeline::setup;
 
 #[test]
 fn comp_marker_dialog_fields_and_undo() {
@@ -194,3 +194,17 @@ fn layer_add_marker_without_selection_adds_comp_marker() {
     assert!((comp.markers[0].time.seconds() - 1.5).abs() < 1e-9);
     assert_eq!(comp.markers[0].comment, "timeline marker");
 }
+
+#[test]
+fn comp_delete_all_markers_with_undo() {
+    let (mut s, _) = setup();
+    s.execute("comp.addMarker", json!({"time": 1.0, "comment": "m1"})).unwrap();
+    s.execute("comp.addMarker", json!({"time": 2.0, "comment": "m2"})).unwrap();
+    assert_eq!(s.active_comp().unwrap().markers.len(), 2);
+    s.execute("comp.deleteAllMarkers", json!({})).unwrap();
+    assert!(s.active_comp().unwrap().markers.is_empty());
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(s.active_comp().unwrap().markers.len(), 2);
+    s.execute("edit.redo", json!({})).unwrap();
+    assert!(s.active_comp().unwrap().markers.is_empty());
+}
diff --git a/crates/engine/src/tests_mask_warp.rs b/crates/engine/src/tests/mask_warp.rs
similarity index 90%
rename from crates/engine/src/tests_mask_warp.rs
rename to crates/engine/src/tests/mask_warp.rs
index 137feb1cb..5387fe562 100644
--- a/crates/engine/src/tests_mask_warp.rs
+++ b/crates/engine/src/tests/mask_warp.rs
@@ -11,7 +11,7 @@ use effectcraft_track::Homography;
 use serde_json::json;
 
 use crate::Session;
-use crate::tests_track::{FPS, H, W, frame_time, patch_frames, rotating_pose, setup, texture};
+use crate::tests::track::{FPS, H, W, frame_time, patch_frames, rotating_pose, setup, texture};
 
 fn pose_h(f: u32) -> Homography {
     let (c, rot, sc) = rotating_pose(f);
@@ -184,6 +184,51 @@ fn mask_interpolation_creates_matching_keys() {
     assert!(s.execute_checked("mask.interpolate", json!({"matchingMethod": "magic", "times": [0, 0.8], "layer": clip.0})).is_err());
 }
 
+#[test]
+fn mask_interpolation_skips_locked_selection_and_rejects_explicit_locked_targets() {
+    let (mut s, locked, _) = setup(patch_frames(rotating_pose));
+    let unlocked = effectcraft_project::LayerId(s.execute("layer.newSolid", json!({"width": 100, "height": 100})).unwrap()["layer"].as_u64().unwrap());
+    let a = ShapePath::rect([20.0, 20.0], 10.0, 10.0);
+    let b = ShapePath::rect([40.0, 30.0], 20.0, 20.0);
+    let cid = s.active_comp_id().unwrap();
+    let mut selected = vec![];
+    let mut masks = vec![];
+    for layer in [locked, unlocked] {
+        let uid = new_mask(&mut s, layer, &a);
+        masks.push(uid);
+        s.edit("keys", None, |project, _| {
+            let pr = project.comp_mut(cid).unwrap().layer_mut(layer).unwrap().props.find_group_mut(uid).unwrap().get_mut("path").unwrap();
+            pr.keys = vec![Keyframe::new(frame_time(0), KV::Path(a.clone())), Keyframe::new(frame_time(20), KV::Path(b.clone()))];
+            selected.extend(pr.keys.iter().map(|key| crate::KeyRef { layer, prop: pr.uid, time: key.time }));
+            Ok(())
+        })
+        .unwrap();
+    }
+    s.execute("layer.setSwitch", json!({"layers": [locked.0], "switch": "locked", "value": true})).unwrap();
+    s.state.selected_keys = selected.clone();
+    let before = mask_path(&s, locked, masks[0]).keys;
+    let options = serde_json::to_value(&s.state.mask_interp).unwrap();
+    let project = serde_json::to_value(&*s.project).unwrap();
+    let error = s.execute_checked("mask.interpolate", json!({"layer": locked.0, "mask": masks[0], "times": [0.0, 0.8], "quality": 75})).unwrap_err();
+    assert!(error.to_string().contains("locked"), "{error}");
+    assert_eq!(serde_json::to_value(&*s.project).unwrap(), project);
+    assert_eq!(serde_json::to_value(&s.state.mask_interp).unwrap(), options);
+    assert_eq!(s.state.selected_keys, selected);
+    s.execute_checked("mask.interpolate", json!({})).unwrap();
+    assert_eq!(mask_path(&s, locked, masks[0]).keys, before);
+    assert_eq!(mask_path(&s, unlocked, masks[1]).keys.len(), 21);
+    assert_eq!(s.state.selected_keys, selected);
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(mask_path(&s, unlocked, masks[1]).keys.len(), 2);
+    s.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(mask_path(&s, unlocked, masks[1]).keys.len(), 21);
+    s.state.selected_keys.retain(|key| key.layer == locked);
+    let selection = s.state.selected_keys.clone();
+    assert!(s.execute_checked("mask.interpolate", json!({})).is_err());
+    assert_eq!(mask_path(&s, locked, masks[0]).keys, before);
+    assert_eq!(s.state.selected_keys, selection);
+}
+
 // ---------------------------------------------------------------- Warp Stabilizer
 
 /// Camera offset on frame `f`: a slow pan plus jitter.
@@ -239,6 +284,28 @@ fn set_param(s: &mut Session, layer: LayerId, path: &str, v: serde_json::Value)
     s.execute("prop.set", json!({"layer": layer.0, "path": format!("effects/#1/{path}"), "value": v})).unwrap();
 }
 
+/// Stabilize, Crop, Auto-scale (the default) hides the borders; Crop leaves an opaque centre.
+fn assert_crop_framing(s: &mut Session, clip: LayerId) {
+    set_param(s, clip, "borders/framing", json!(2));
+    let st = s.execute("warp.status", json!({})).unwrap();
+    assert!(st["autoScale"].as_f64().unwrap() > 100.5, "{st}");
+    for f in 0..25 {
+        assert_eq!(transparent(&render(s, f)), 0, "frame {f}");
+    }
+    set_param(s, clip, "borders/framing", json!(1));
+    let st = s.execute("warp.status", json!({})).unwrap();
+    let crop: [f64; 4] = serde_json::from_value(st["crop"].clone()).unwrap();
+    for f in [0, 9, 24] {
+        let img = render(s, f);
+        for y in (crop[1].ceil() as u32 + 1)..(crop[3].floor() as u32 - 1) {
+            for x in (crop[0].ceil() as u32 + 1)..(crop[2].floor() as u32 - 1) {
+                assert!(img.get(x as i64, y as i64)[3] > 0.99, "frame {f} ({x}, {y})");
+            }
+        }
+        assert!(img.get(0, 0)[3] < 0.01);
+    }
+}
+
 #[test]
 fn warp_stabilizer_analyzes_and_stabilizes() {
     let (mut s, clip, solid) = setup(shaky);
@@ -289,25 +356,7 @@ fn warp_stabilizer_analyzes_and_stabilizes() {
     }
     set_param(&mut s, clip, "stabilization/result", json!(0));
 
-    // Stabilize, Crop, Auto-scale (the default) hides the borders; Crop leaves an opaque centre.
-    set_param(&mut s, clip, "borders/framing", json!(2));
-    let st = s.execute("warp.status", json!({})).unwrap();
-    assert!(st["autoScale"].as_f64().unwrap() > 100.5, "{st}");
-    for f in 0..25 {
-        assert_eq!(transparent(&render(&s, f)), 0, "frame {f}");
-    }
-    set_param(&mut s, clip, "borders/framing", json!(1));
-    let st = s.execute("warp.status", json!({})).unwrap();
-    let crop: [f64; 4] = serde_json::from_value(st["crop"].clone()).unwrap();
-    for f in [0, 9, 24] {
-        let img = render(&s, f);
-        for y in (crop[1].ceil() as u32 + 1)..(crop[3].floor() as u32 - 1) {
-            for x in (crop[0].ceil() as u32 + 1)..(crop[2].floor() as u32 - 1) {
-                assert!(img.get(x as i64, y as i64)[3] > 0.99, "frame {f} ({x}, {y})");
-            }
-        }
-        assert!(img.get(0, 0)[3] < 0.01);
-    }
+    assert_crop_framing(&mut s, clip);
     // Synthesize Edges fills most of the borders from neighbouring frames.
     set_param(&mut s, clip, "borders/framing", json!(3));
     let synth: usize = (0..25).map(|f| transparent(&render(&s, f))).sum();
diff --git a/crates/engine/src/tests_menu_cmds.rs b/crates/engine/src/tests/menu_cmds.rs
similarity index 90%
rename from crates/engine/src/tests_menu_cmds.rs
rename to crates/engine/src/tests/menu_cmds.rs
index 5131bf3f4..d30fc156a 100644
--- a/crates/engine/src/tests_menu_cmds.rs
+++ b/crates/engine/src/tests/menu_cmds.rs
@@ -641,7 +641,7 @@ fn work_area_stays_ordered_when_the_start_passes_the_end() {
 
 #[test]
 fn label_group_purge_and_edit_original() {
-    crate::tests_roto::hold_roto_cache_test_lock();
+    crate::tests::roto::hold_roto_cache_test_lock();
     let mut s = comp();
     let a = solid(&mut s, "#ff0000");
     let b = solid(&mut s, "#00ff00");
@@ -1103,6 +1103,66 @@ fn transform_commands_keep_depth_and_follow_separated_dimensions() {
     assert_eq!(pos(&s, b)[..2], [200.0, 100.0], "the 200×100 solid's centre");
 }
 
+/// The layer's painted bounds mapped to comp space — what the viewer shows.
+fn seen_bounds(s: &Session, lid: u64) -> [f64; 4] {
+    let cid = s.active_comp_id().unwrap();
+    let comp = s.project.comp(cid).unwrap().clone();
+    let layer = comp.layer(effectcraft_project::LayerId(lid)).unwrap();
+    let ectx = effectcraft_render::EvalCtx::new(&s.project, cid, &comp, s.time());
+    let b = effectcraft_render::content_bounds(&ectx, layer).expect("painted bounds");
+    let m = ectx.layer_to_comp(layer).0;
+    let corners = [[b[0], b[1]], [b[2], b[1]], [b[2], b[3]], [b[0], b[3]]];
+    let pts: Vec<[f64; 2]> = corners
+        .iter()
+        .map(|p| {
+            let q = m.apply(effectcraft_geom::vec2(p[0], p[1]));
+            [q.x, q.y]
+        })
+        .collect();
+    let (mut x0, mut y0, mut x1, mut y1) = (f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);
+    for p in &pts {
+        x0 = x0.min(p[0]);
+        y0 = y0.min(p[1]);
+        x1 = x1.max(p[0]);
+        y1 = y1.max(p[1]);
+    }
+    [x0, y0, x1, y1]
+}
+
+#[test]
+fn fit_to_comp_fills_the_comp_with_shape_and_text_bounds() {
+    let mut s = comp();
+    let close = |x: f64, y: f64| (x - y).abs() < 1e-6;
+    // A shape or text layer has no source item: fit sizes it by its painted bounds, anchored at
+    // the bounds' centre, so what the viewer shows fills the frame (#2198).
+    let a = s.execute("layer.newShape", json!({"kind": "rect", "size": [180, 80]})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.transform", json!({"layers": [a], "op": "fit"})).unwrap();
+    let seen = seen_bounds(&s, a);
+    assert!(close(seen[0], 0.0) && close(seen[1], 0.0) && close(seen[2], 640.0) && close(seen[3], 360.0), "the rect's painted bounds fill the comp: {seen:?}");
+
+    let t = s.execute("layer.newText", json!({"text": "Title", "size": 80})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.transform", json!({"layers": [t], "op": "fit"})).unwrap();
+    let seen = seen_bounds(&s, t);
+    assert!(close(seen[0], 0.0) && close(seen[1], 0.0) && close(seen[2], 640.0) && close(seen[3], 360.0), "the text's painted bounds fill the comp: {seen:?}");
+
+    // fitWidth spans the comp's width and centres vertically.
+    for lid in [a, t] {
+        s.execute("layer.transform", json!({"layers": [lid], "op": "fitWidth"})).unwrap();
+        let seen = seen_bounds(&s, lid);
+        assert!(close(seen[0], 0.0) && close(seen[2], 640.0), "fitWidth spans the comp width: {seen:?}");
+        assert!(close((seen[1] + seen[3]) / 2.0, 180.0), "fitWidth centres vertically: {seen:?}");
+    }
+}
+
+#[test]
+fn fit_to_comp_refuses_a_scale_that_overflows() {
+    let mut s = comp();
+    let a = s.execute("layer.newShape", json!({"kind": "rect", "size": [1e-305, 80]})).unwrap()["layer"].as_u64().unwrap();
+    let before = s.project.clone();
+    assert!(s.execute("layer.transform", json!({"layers": [a], "op": "fit"})).is_err(), "an infinite scale is refused");
+    assert_eq!(s.project, before, "nothing was written");
+}
+
 #[test]
 fn duplicated_and_pasted_layers_keep_their_links() {
     let mut s = comp();
@@ -1423,6 +1483,68 @@ fn key_selection_toggles_and_skips_locked_layers_and_hold_restores_bezier() {
     assert!(s.state.selected_keys.is_empty());
 }
 
+#[test]
+fn muting_keys_skips_them_in_the_timeline_value_and_undoes() {
+    let mut s = comp();
+    let a = solid(&mut s, "#ff0000");
+    for (t, v) in [(0.0, 0.0), (1.0, 100.0), (2.0, 300.0)] {
+        s.execute("prop.addKey", json!({"layer": a, "path": "transform/opacity", "time": t, "value": v})).unwrap();
+    }
+    let value_at = |s: &Session, t: f64| layer(s, a).props.prop("transform/opacity").unwrap().value_at(Tick::from_seconds_f64(t)).as_f64();
+    let select = |s: &mut Session| s.execute("keys.select", json!({"keys": [{"layer": a, "path": "transform/opacity", "time": 1.0}]})).unwrap();
+    select(&mut s);
+    let before = value_at(&s, 0.5);
+    s.execute("keys.setMuted", json!({"muted": true})).unwrap();
+    assert!(layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+    // The muted key no longer bends the 0 → 300 segment.
+    assert!((value_at(&s, 0.5) - 75.0).abs() < 1e-6);
+    assert!((value_at(&s, 1.5) - 225.0).abs() < 1e-6);
+    s.undo();
+    assert!(!layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+    assert!((value_at(&s, 0.5) - before).abs() < 1e-6);
+    // The same command unmutes.
+    select(&mut s);
+    s.execute("keys.setMuted", json!({"muted": true})).unwrap();
+    s.execute("keys.setMuted", json!({"muted": false})).unwrap();
+    assert!(!layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+}
+
+/// Both Animation-menu rows mute and unmute through `Session::execute`, and undo/redo work.
+#[test]
+fn mute_and_unmute_keyframes_menu_rows_work_and_undo() {
+    fn rows(nodes: &[crate::menus::MenuNode], out: &mut Vec<(String, Value)>) {
+        for n in nodes {
+            match n {
+                crate::menus::MenuNode::Item(e) if e.command == "keys.setMuted" => out.push((e.label.clone(), e.params.clone())),
+                crate::menus::MenuNode::Submenu { children, .. } => rows(children, out),
+                _ => {}
+            }
+        }
+    }
+    let mut menu = vec![];
+    rows(&crate::menus::parse(crate::menus::TREE, false).unwrap(), &mut menu);
+    assert_eq!(menu.iter().map(|(l, _)| l.as_str()).collect::<Vec<_>>(), ["Mute Keyframes", "Unmute Keyframes"], "{menu:?}");
+
+    let mut s = comp();
+    let a = solid(&mut s, "#ff0000");
+    for (t, v) in [(0.0, 0.0), (1.0, 100.0)] {
+        s.execute("prop.addKey", json!({"layer": a, "path": "transform/opacity", "time": t, "value": v})).unwrap();
+    }
+    let muted = |s: &Session| layer(s, a).props.prop("transform/opacity").unwrap().keys[1].muted;
+    s.execute("keys.select", json!({"keys": [{"layer": a, "path": "transform/opacity", "time": 1.0}]})).unwrap();
+    let run = |s: &mut Session, params: &Value| {
+        s.execute("keys.setMuted", if params.is_null() { json!({}) } else { params.clone() }).unwrap();
+    };
+    run(&mut s, &menu[0].1);
+    assert!(muted(&s));
+    s.undo();
+    assert!(!muted(&s));
+    s.redo();
+    assert!(muted(&s));
+    run(&mut s, &menu[1].1);
+    assert!(!muted(&s));
+}
+
 #[test]
 fn transform_drags_apply_their_whole_offset_to_the_keys_they_started_with() {
     let mut s = comp();
@@ -1821,3 +1943,95 @@ fn old_guides_load_as_pixel_guides_and_percent_round_trips() {
     // A zero-sized comp never divides by zero.
     assert!(g.px(0, 0).is_finite());
 }
+
+#[test]
+fn copy_paste_masks_between_layers() {
+    let mut s = comp();
+    let a = solid(&mut s, "#ff0000");
+    let b = solid(&mut s, "#00ff00");
+    let n = s.active_comp().unwrap().layers.len();
+    s.execute("layer.select", json!({"layers": [a]})).unwrap();
+    s.execute("layer.addMask", json!({})).unwrap();
+    s.execute("layer.addMask", json!({"shape": "ellipse"})).unwrap();
+    let names = |s: &Session, id: u64| layer(s, id).masks().unwrap().groups().map(|m| m.name.clone()).collect::<Vec<_>>();
+    let uids = |s: &Session, id: u64| layer(s, id).masks().unwrap().groups().map(|m| m.uid).collect::<Vec<_>>();
+    let first = uids(&s, a)[0];
+    s.execute("prop.select", json!({"layer": a, "prop": first})).unwrap();
+    // Copy the mask: it is the mask that is copied, not its layer.
+    assert_eq!(s.execute("edit.copy", json!({})).unwrap()["masks"], json!(1));
+    assert!(s.state.clipboard.is_empty(), "not the layer");
+    assert!(s.is_enabled("edit.paste"));
+    s.execute("layer.select", json!({"layers": [b]})).unwrap();
+    let r = s.execute("edit.paste", json!({})).unwrap();
+    assert_eq!(s.active_comp().unwrap().layers.len(), n, "no new layer");
+    assert_eq!(names(&s, b), ["Mask 1"]);
+    let pasted = r["masks"][0].as_u64().unwrap();
+    assert_eq!(uids(&s, b), [pasted]);
+    assert_ne!(pasted, first);
+    assert_eq!(s.state.selected_props, vec![(effectcraft_project::LayerId(b), pasted)]);
+    assert_eq!(names(&s, a), ["Mask 1", "Mask 2"], "the source keeps its masks");
+    // Pasting again onto the same layer keeps names unique.
+    s.execute("edit.paste", json!({})).unwrap();
+    assert_eq!(names(&s, b), ["Mask 1", "Mask 2"]);
+    // One undo step per paste.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(names(&s, b), ["Mask 1"]);
+}
+
+#[test]
+fn paste_masks_skips_locked_layers() {
+    let mut s = comp();
+    let a = solid(&mut s, "#ff0000");
+    let b = solid(&mut s, "#00ff00");
+    s.execute("layer.select", json!({"layers": [a]})).unwrap();
+    s.execute("layer.addMask", json!({})).unwrap();
+    let mask = layer(&s, a).masks().unwrap().groups().next().unwrap().uid;
+    s.execute("prop.select", json!({"layer": a, "prop": mask})).unwrap();
+    s.execute("edit.copy", json!({})).unwrap();
+    s.execute("layer.select", json!({"layers": [b]})).unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [b], "switch": "lock", "value": true})).unwrap();
+    assert!(s.execute("edit.paste", json!({})).is_err());
+    assert_eq!(layer(&s, b).masks().unwrap().groups().count(), 0);
+}
+
+#[test]
+fn copy_with_an_explicit_layer_ignores_the_selected_mask() {
+    let mut s = comp();
+    let a = solid(&mut s, "#ff0000");
+    s.execute("layer.select", json!({"layers": [a]})).unwrap();
+    s.execute("layer.addMask", json!({})).unwrap();
+    let mask = layer(&s, a).masks().unwrap().groups().next().unwrap().uid;
+    s.execute("prop.select", json!({"layer": a, "prop": mask})).unwrap();
+    s.execute("edit.copy", json!({"layer": a})).unwrap();
+    assert_eq!(s.state.clipboard.len(), 1, "the named layer is copied");
+    assert!(s.state.mask_clipboard.is_empty());
+}
+
+#[test]
+fn selecting_a_mask_drops_stale_key_selection_so_copy_copies_the_mask() {
+    let mut s = comp();
+    let a = solid(&mut s, "#ff0000");
+    s.execute("layer.select", json!({"layers": [a]})).unwrap();
+    s.execute("layer.addMask", json!({})).unwrap();
+    let mask = layer(&s, a).masks().unwrap().groups().next().unwrap().uid;
+    s.state.selected_keys = vec![crate::KeyRef { layer: effectcraft_project::LayerId(a), prop: 1, time: Default::default() }];
+    s.execute("prop.select", json!({"layer": a, "prop": mask})).unwrap();
+    assert!(s.state.selected_keys.is_empty());
+    assert_eq!(s.execute("edit.copy", json!({})).unwrap()["masks"], json!(1));
+}
+
+#[test]
+fn pasting_a_mask_onto_its_own_layer_drops_the_source_vertex_selection() {
+    let mut s = comp();
+    let a = solid(&mut s, "#ff0000");
+    s.execute("layer.select", json!({"layers": [a]})).unwrap();
+    s.execute("layer.addMask", json!({})).unwrap();
+    let mask = layer(&s, a).masks().unwrap().groups().next().unwrap().uid;
+    s.execute("prop.select", json!({"layer": a, "prop": mask})).unwrap();
+    assert!(!s.state.selected_vertices.is_empty());
+    s.execute("edit.copy", json!({})).unwrap();
+    s.execute("edit.paste", json!({})).unwrap();
+    assert!(s.state.selected_vertices.is_empty());
+    s.execute("edit.clear", json!({})).unwrap();
+    assert_eq!(layer(&s, a).masks().unwrap().groups().count(), 1, "the pasted mask goes, the source stays");
+}
diff --git a/crates/engine/src/tests_model3d.rs b/crates/engine/src/tests/model3d.rs
similarity index 100%
rename from crates/engine/src/tests_model3d.rs
rename to crates/engine/src/tests/model3d.rs
diff --git a/crates/engine/src/tests/models.rs b/crates/engine/src/tests/models.rs
new file mode 100644
index 000000000..e1baab2d8
--- /dev/null
+++ b/crates/engine/src/tests/models.rs
@@ -0,0 +1,282 @@
+//! Settings ▸ Roto Brush and Settings ▸ Face Tracking: the model registry, choosing, installing
+//! (verified, with its notice) and loading trained models.
+
+use std::sync::Arc;
+
+use effectcraft_segment::Task;
+use serde_json::json;
+
+use crate::Session;
+use crate::config::{ConfigStore, DirConfig};
+
+fn session(tag: &str) -> (Session, std::path::PathBuf) {
+    let d = std::env::temp_dir().join(format!("ec-models-{tag}-{}", std::process::id()));
+    let store: Arc<dyn ConfigStore> = Arc::new(DirConfig::new(d.join("config")));
+    (Session { config: Some(store), ..Default::default() }, d)
+}
+
+#[test]
+fn model_list_and_direct_selection_agree_on_target_availability() {
+    super::roto::hold_roto_cache_test_lock();
+    let mut s = Session::default();
+    let list = s.execute_checked("roto.models", json!({})).unwrap();
+    let models = list["models"].as_array().unwrap();
+    for id in ["sam2.1-hiera-tiny", "sam2.1-hiera-small", "sam2.1-hiera-base-plus", "sam2.1-hiera-large"] {
+        let chosen = s.chosen_model(Task::Mask).to_string();
+        let generation = s.models.status(Task::Mask).generation;
+        let selected = s.execute_checked("roto.model.select", json!({"id": id}));
+        if cfg!(target_arch = "wasm32") {
+            assert!(!models.iter().any(|m| m["id"] == id));
+            assert!(selected.is_err());
+            assert_eq!(s.chosen_model(Task::Mask), chosen);
+            assert_eq!(s.models.status(Task::Mask).generation, generation, "rejection must not alter model state");
+        } else {
+            assert!(models.iter().any(|m| m["id"] == id));
+            selected.unwrap();
+            assert_eq!(s.chosen_model(Task::Mask), id);
+        }
+    }
+    s.execute_checked("roto.model.select", json!({"id": "classical"})).unwrap();
+    assert_eq!(s.chosen_model(Task::Mask), "classical");
+    assert!(models.iter().any(|m| m["id"] == "mobilesam"));
+}
+
+/// Poll until `task`'s model is in use (or a few seconds pass).
+fn wait_loaded(s: &mut Session, task: Task) {
+    for _ in 0..400 {
+        s.poll_models();
+        if s.models.status(task).active.is_some() {
+            return;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(20));
+    }
+}
+
+#[test]
+fn models_are_listed_chosen_and_verified() {
+    crate::tests::roto::hold_roto_cache_test_lock();
+    let (mut s, d) = session("list");
+    std::fs::create_dir_all(&d).unwrap();
+    let bogus = d.join("bogus.bin");
+    std::fs::write(&bogus, b"not the weights").unwrap();
+    for (prefix, model, task) in [("roto", "mobilesam", Task::Mask), ("face", "mediapipe-face", Task::Face)] {
+        let list = s.execute_checked(&format!("{prefix}.models"), json!({})).unwrap();
+        let ids: Vec<&str> = list["models"].as_array().unwrap().iter().map(|m| m["id"].as_str().unwrap()).collect();
+        // Roto Brush also offers SAM 2.1 in four sizes (video trackers; see crates/sam2).
+        let expect: Vec<&str> = if task == Task::Mask && !cfg!(target_arch = "wasm32") {
+            vec!["classical", model, "sam2.1-hiera-tiny", "sam2.1-hiera-small", "sam2.1-hiera-base-plus", "sam2.1-hiera-large"]
+        } else {
+            vec!["classical", model]
+        };
+        assert_eq!(ids, expect);
+        let m = &list["models"][1];
+        assert_eq!((m["licence"].as_str(), m["installed"].as_bool()), (Some("Apache-2.0"), Some(false)));
+        assert!(m["url"].as_str().unwrap().starts_with("https://") && !m["authors"].as_str().unwrap().is_empty());
+        // Unknown ids, the other task's models and files that aren't the published weights are
+        // refused.
+        let other = if task == Task::Mask { "mediapipe-face" } else { "mobilesam" };
+        for id in ["nope", other] {
+            assert!(s.execute_checked(&format!("{prefix}.model.select"), json!({"id": id})).is_err(), "{prefix} {id}");
+        }
+        let path = bogus.to_string_lossy();
+        let e = s.execute_checked(&format!("{prefix}.model.install"), json!({"path": path})).unwrap_err().to_string();
+        assert!(e.contains("SHA-256"), "{e}");
+        assert!(s.execute_checked(&format!("{prefix}.model.install"), json!({"path": path, "id": model})).is_err());
+        // Choosing a model that isn't installed keeps the classic engine.
+        s.execute_checked(&format!("{prefix}.model.select"), json!({"id": model})).unwrap();
+        assert_eq!(s.chosen_model(task), model);
+        assert!(s.models.status(task).active.is_none());
+        assert!(crate::prefs::pages().iter().any(|p| p.id == prefix));
+    }
+    assert!(s.models.face().is_none());
+    assert_eq!(crate::prefs::page_id("Face Tracking"), Some("face"));
+    // With the real weights (EFFECTCRAFT_MOBILESAM=path/to/mobile_sam.pt): install, load, use.
+    if let Ok(path) = std::env::var("EFFECTCRAFT_MOBILESAM") {
+        s.execute_checked("roto.model.install", json!({"path": path})).unwrap();
+        wait_loaded(&mut s, Task::Mask);
+        assert_eq!(s.models.status(Task::Mask).active.as_deref(), Some("mobilesam"));
+        // Roto Brush 3.0 (the default version) now segments with it.
+        let params = crate::effects::Params { values: [("version".to_string(), effectcraft_keyframe::Value::Enum(2))].into_iter().collect() };
+        assert_eq!(crate::effects::roto::model_for(&params).map(|m| m.info().id), Some("mobilesam"));
+        s.execute_checked("roto.model.select", json!({"id": "classical"})).unwrap();
+        assert!(crate::effects::roto::model_for(&params).is_none());
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    verify_installed_sam2_sizes(&mut s);
+    // EFFECTCRAFT_FACE_LANDMARKER=path/to/face_landmarker.task: installed with its notice,
+    // loaded for face tracking, dropped when the classic tracker is chosen, removed.
+    if let Ok(path) = std::env::var("EFFECTCRAFT_FACE_LANDMARKER") {
+        let r = s.execute_checked("face.model.install", json!({"path": path})).unwrap();
+        assert_eq!(r["id"], "mediapipe-face");
+        let dir = s.models_dir().unwrap();
+        let notice = std::fs::read_to_string(dir.join("face_landmarker.task.NOTICE.txt")).unwrap();
+        assert!(notice.contains("Google LLC") && notice.contains("Apache-2.0"), "{notice}");
+        wait_loaded(&mut s, Task::Face);
+        assert_eq!(s.models.face().map(|m| m.info().id), Some("mediapipe-face"));
+        s.execute_checked("face.model.select", json!({"id": "classical"})).unwrap();
+        assert!(s.models.face().is_none());
+        assert_eq!(s.execute_checked("face.model.remove", json!({"id": "mediapipe-face"})).unwrap()["removed"], true);
+        assert!(!dir.join("face_landmarker.task").exists() && !dir.join("face_landmarker.task.NOTICE.txt").exists());
+    }
+    let _ = std::fs::remove_dir_all(d);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn verify_installed_sam2_sizes(s: &mut Session) {
+    // The SAM 2.1 sizes, each from its own file (EFFECTCRAFT_SAM2, _SAM2_SMALL, _SAM2_BASE_PLUS, _SAM2_LARGE =
+    // path/to/model.safetensors of facebook/sam2.1-hiera-*): installed with its notice, loaded (verified, native
+    // only) and used by Roto Brush 3.0, then dropped and removed.
+    for (var, id) in [
+        ("EFFECTCRAFT_SAM2", "sam2.1-hiera-tiny"),
+        ("EFFECTCRAFT_SAM2_SMALL", "sam2.1-hiera-small"),
+        ("EFFECTCRAFT_SAM2_BASE_PLUS", "sam2.1-hiera-base-plus"),
+        ("EFFECTCRAFT_SAM2_LARGE", "sam2.1-hiera-large"),
+    ] {
+        let Ok(path) = std::env::var(var) else { continue };
+        let r = s.execute_checked("roto.model.install", json!({"path": path})).unwrap();
+        assert_eq!(r["id"], id, "{var}");
+        let dir = s.models_dir().unwrap();
+        let notice = std::fs::read_to_string(dir.join(format!("{id}.safetensors.NOTICE.txt"))).unwrap();
+        assert!(notice.contains("Meta AI") && notice.contains("Apache-2.0"), "{notice}");
+        s.execute_checked("roto.model.select", json!({"id": id})).unwrap();
+        wait_loaded(s, Task::Mask);
+        assert_eq!(s.models.status(Task::Mask).active.as_deref(), Some(id), "{var}");
+        let params = crate::effects::Params { values: [("version".to_string(), effectcraft_keyframe::Value::Enum(2))].into_iter().collect() };
+        assert_eq!(crate::effects::roto::model_for(&params).map(|m| m.info().id), Some(id));
+        // the list says it is installed, and exactly one size is recommended
+        let list = s.execute_checked("roto.models", json!({})).unwrap();
+        let entry = list["models"].as_array().unwrap().iter().find(|m| m["id"] == id).unwrap();
+        assert_eq!(entry["installed"], true);
+        assert_eq!(list["models"].as_array().unwrap().iter().filter(|m| m["recommended"] == true).count(), 1);
+        s.execute_checked("roto.model.select", json!({"id": "classical"})).unwrap();
+        assert!(crate::effects::roto::model_for(&params).is_none());
+        assert_eq!(s.execute_checked("roto.model.remove", json!({"id": id})).unwrap()["removed"], true);
+        assert!(!dir.join(format!("{id}.safetensors")).exists(), "{id} removed");
+    }
+}
+
+/// A Roto Brush model that has been idle for ten minutes is unloaded (the choice stays), one in use is not,
+/// and a model that does not track use is never unloaded.
+#[test]
+fn an_idle_roto_model_is_unloaded() {
+    use effectcraft_segment::{Loaded, MaskModel, ModelInfo, Prompt};
+    struct Fake(Option<f64>);
+    impl MaskModel for Fake {
+        fn info(&self) -> &'static ModelInfo {
+            &effectcraft_segment::SAM2_TINY
+        }
+        fn segment(&self, _: &[[f32; 3]], _: usize, _: usize, _: &Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+            Err("no weights".into())
+        }
+        fn idle_secs(&self) -> Option<f64> {
+            self.0
+        }
+    }
+    crate::tests::roto::hold_roto_cache_test_lock();
+    let (mut s, d) = session("idle");
+    for (idle, unloaded) in [(Some(5.0), false), (None, false), (Some(601.0), true)] {
+        let m: Arc<dyn MaskModel> = Arc::new(Fake(idle));
+        s.models.set_active(Task::Mask, Some(Loaded::Mask(m)));
+        assert_eq!(s.models.status(Task::Mask).active.as_deref(), Some("sam2.1-hiera-tiny"));
+        s.poll_models();
+        assert_eq!(s.models.status(Task::Mask).active.is_none(), unloaded, "idle {idle:?}");
+        assert_eq!(crate::effects::roto::installed_model().is_none(), unloaded, "the effect's model follows");
+        if unloaded {
+            assert!(s.events.iter().any(|e| matches!(e, crate::Event::Toast { message, .. } if message.contains("unloaded after 10 minutes"))));
+        }
+    }
+    // the choice survives, and with the classic engine chosen reloading does nothing
+    s.reload_roto_model();
+    assert!(s.models.status(Task::Mask).active.is_none());
+    crate::effects::roto::set_model(None);
+    let _ = std::fs::remove_dir_all(d);
+}
+
+/// A model that finishes loading after the choice changed is dropped, not activated.
+#[test]
+fn a_load_for_an_old_choice_does_not_activate() {
+    use effectcraft_segment::{Loaded, MaskModel, ModelInfo, Prompt};
+    struct Fake;
+    impl MaskModel for Fake {
+        fn info(&self) -> &'static ModelInfo {
+            &effectcraft_segment::SAM2_TINY
+        }
+        fn segment(&self, _: &[[f32; 3]], _: usize, _: usize, _: &Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+            Err("no weights".into())
+        }
+    }
+    super::roto::hold_roto_cache_test_lock();
+    let (mut s, d) = session("stale-load");
+    let started = s.models.status(Task::Mask).generation;
+    // the user picks another engine while the load runs
+    s.execute_checked("roto.model.select", json!({"id": "classical"})).unwrap();
+    s.execute_checked("roto.model.select", json!({"id": "sam2.1-hiera-tiny"})).unwrap();
+    assert_ne!(s.models.status(Task::Mask).generation, started, "a changed choice is counted");
+    let m: Arc<dyn MaskModel> = Arc::new(Fake);
+    assert!(!s.models.set_active_if_current(Task::Mask, Loaded::Mask(m.clone()), started), "the stale load is dropped");
+    assert!(s.models.status(Task::Mask).active.is_none() && crate::effects::roto::installed_model().is_none());
+    let now = s.models.status(Task::Mask).generation;
+    assert!(s.models.set_active_if_current(Task::Mask, Loaded::Mask(m), now), "a load for the current choice activates");
+    assert_eq!(s.models.status(Task::Mask).active.as_deref(), Some("sam2.1-hiera-tiny"));
+    crate::effects::roto::set_model(None);
+    let _ = std::fs::remove_dir_all(d);
+}
+
+/// A stroke reloading an unloaded model never waits for the load and never retries one that already failed.
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn reloading_for_a_stroke_does_not_block_or_retry_a_failed_load() {
+    super::roto::hold_roto_cache_test_lock();
+    let (mut s, d) = session("reload-failed");
+    let info = effectcraft_segment::info("mobilesam").unwrap();
+    let dir = s.models_dir().unwrap();
+    std::fs::create_dir_all(&dir).unwrap();
+    // the right size, the wrong content: found as installed, then fails to load
+    std::fs::File::create(dir.join(info.file_name)).unwrap().set_len(info.size).unwrap();
+    s.execute_checked("roto.model.select", json!({"id": "mobilesam"})).unwrap();
+    let t0 = std::time::Instant::now();
+    while s.models.status(Task::Mask).busy.is_some() && t0.elapsed().as_secs() < 30 {
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    let failed = s.models.status(Task::Mask).error;
+    assert!(failed.is_some(), "the unreadable file fails to load");
+    s.reload_roto_model();
+    let st = s.models.status(Task::Mask);
+    assert!(st.busy.is_none(), "a failed model is not loaded again by every stroke");
+    assert_eq!(st.error, failed);
+    s.poll_models();
+    let st = s.models.status(Task::Mask);
+    assert_eq!(st.error, failed, "polling must keep the actionable error until an explicit retry");
+    assert!(st.busy.is_none(), "a failed load must not restart on every poll");
+    // an unloaded, not failed model loads on the worker: the call returns with the load still pending or done
+    s.execute_checked("roto.model.select", json!({"id": "classical"})).unwrap();
+    crate::effects::roto::set_model(None);
+    let _ = std::fs::remove_dir_all(d);
+}
+
+/// With `EFFECTCRAFT_DOWNLOAD_SIZE=mobilesam` (or another downloadable registry id): the in-app
+/// download verifies and loads the file. SAM 2 must refuse until a storytold mirror is available.
+/// Skipped without the variable: downloadable entries need the network and large files.
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn downloading_a_size_installs_and_loads_it() {
+    let Ok(id) = std::env::var("EFFECTCRAFT_DOWNLOAD_SIZE") else { return };
+    crate::tests::roto::hold_roto_cache_test_lock();
+    let (mut s, d) = session("download");
+    let info = effectcraft_segment::info(&id).unwrap();
+    if info.url.is_empty() {
+        assert!(s.execute_checked("roto.model.download", json!({"id": id, "wait": true})).unwrap_err().to_string().contains("Install from File"));
+        return;
+    }
+    let r = s.execute_checked("roto.model.download", json!({"id": id, "wait": true})).unwrap();
+    assert_eq!(r["id"], id.as_str(), "{r}");
+    let dir = s.models_dir().unwrap();
+    let file = dir.join(info.file_name);
+    assert_eq!(std::fs::metadata(&file).unwrap().len(), info.size, "the whole file arrived");
+    assert!(dir.join(format!("{}.NOTICE.txt", info.file_name)).exists());
+    assert!(!dir.join(format!("{}.part", info.file_name)).exists(), "no partial file is left");
+    s.execute_checked("roto.model.select", json!({"id": id})).unwrap();
+    wait_loaded(&mut s, Task::Mask);
+    assert_eq!(s.models.status(Task::Mask).active.as_deref(), Some(id.as_str()));
+    let _ = std::fs::remove_dir_all(d);
+}
diff --git a/crates/engine/src/tests_motion_blur_depth.rs b/crates/engine/src/tests/motion_blur_depth.rs
similarity index 100%
rename from crates/engine/src/tests_motion_blur_depth.rs
rename to crates/engine/src/tests/motion_blur_depth.rs
diff --git a/crates/engine/src/tests_paint.rs b/crates/engine/src/tests/paint.rs
similarity index 91%
rename from crates/engine/src/tests_paint.rs
rename to crates/engine/src/tests/paint.rs
index db831ca96..3659ce0c4 100644
--- a/crates/engine/src/tests_paint.rs
+++ b/crates/engine/src/tests/paint.rs
@@ -308,6 +308,45 @@ fn puppet_select_all_takes_the_pin_kind_and_several_pins_record_together() {
     assert!(s.execute("puppet.recordPin", json!({"layer": id, "pin": a, "pins": [st], "samples": samples})).is_err());
 }
 
+/// Editing a parameter of one of several selected pins edits the same parameter of the others,
+/// in one undo step; unselected pins keep theirs (#1751).
+#[test]
+fn editing_one_selected_pin_edits_the_other_selected_pins() {
+    let (mut s, id) = setup();
+    let pin = |s: &mut Session, x: i64| s.execute("puppet.addPin", json!({"layer": id, "position": [x, 30]})).unwrap()["pin"].as_u64().unwrap();
+    let (a, b, c) = (pin(&mut s, 10), pin(&mut s, 50), pin(&mut s, 90));
+    let position = |s: &Session, pin: u64| layer(s, id).props.find_group(pin).unwrap().get("position").unwrap().clone();
+    let (pa, pb) = (position(&s, a).uid, position(&s, b).uid);
+    let at = |s: &Session, pin: u64| position(s, pin).value_at(Tick::ZERO).components();
+    s.execute("prop.select", json!({"layer": id, "prop": a, "selectKeys": false})).unwrap();
+    s.execute("prop.select", json!({"layer": id, "prop": b, "selectKeys": false, "add": true})).unwrap();
+
+    // A typed value lands on both selected pins, and one Undo takes it back.
+    let steps = s.history.undo.len();
+    s.execute("prop.set", json!({"layer": id, "prop": pa, "value": [20, 40], "selected": true})).unwrap();
+    assert_eq!((at(&s, a), at(&s, b), at(&s, c)), (vec![20.0, 40.0], vec![20.0, 40.0], vec![90.0, 30.0]));
+    assert_eq!(s.history.undo.len(), steps + 1, "one undo step");
+    s.undo();
+    assert_eq!((at(&s, a), at(&s, b)), (vec![10.0, 30.0], vec![50.0, 30.0]));
+
+    // A scrub moves each selected pin by the same change from its own value.
+    s.execute("prop.set", json!({"layer": id, "prop": pb, "value": [55, 25], "selected": true, "offset": true})).unwrap();
+    assert_eq!((at(&s, a), at(&s, b), at(&s, c)), (vec![15.0, 25.0], vec![55.0, 25.0], vec![90.0, 30.0]));
+
+    // The stopwatch follows on both (a new pin starts keyed, so the toggle turns it off).
+    let animated = |s: &Session| [a, b, c].map(|p| position(s, p).is_animated());
+    assert_eq!(animated(&s), [true; 3]);
+    s.execute("prop.toggleAnimation", json!({"layer": id, "prop": pa, "selected": true})).unwrap();
+    assert_eq!(animated(&s), [false, false, true]);
+
+    // Without `selected`, or with only one pin selected, the edit stays on its own pin.
+    s.execute("prop.set", json!({"layer": id, "prop": pa, "value": [0, 0]})).unwrap();
+    assert_eq!(at(&s, b), vec![55.0, 25.0]);
+    s.execute("prop.select", json!({"layer": id, "prop": a, "selectKeys": false})).unwrap();
+    s.execute("prop.set", json!({"layer": id, "prop": pa, "value": [5, 5], "selected": true})).unwrap();
+    assert_eq!(at(&s, b), vec![55.0, 25.0]);
+}
+
 fn expr_of(s: &Session, layer: u64, uid: u64) -> String {
     let l = layer_of(s, layer);
     l.props.find(uid).and_then(|p| p.expr.as_ref()).map(|e| e.text.clone()).unwrap_or_default()
diff --git a/crates/engine/src/tests_panels.rs b/crates/engine/src/tests/panels.rs
similarity index 92%
rename from crates/engine/src/tests_panels.rs
rename to crates/engine/src/tests/panels.rs
index b442d7c3a..622088745 100644
--- a/crates/engine/src/tests_panels.rs
+++ b/crates/engine/src/tests/panels.rs
@@ -672,3 +672,47 @@ fn footage_that_cannot_be_decoded_reports_why() {
     s.execute("footage.open", json!({"item": item.0})).unwrap();
     assert_eq!(s.execute("footage.info", json!({})).unwrap()["problem"], it["problem"]);
 }
+
+/// A proxy in use that can't be decoded leaves its item without a picture although the item's
+/// own file is fine: `project.summary` and `footage.info` give the proxy's reason, said to be the
+/// proxy's, for footage and compositions alike, and nothing once Use Proxy is off.
+#[test]
+fn a_proxy_in_use_that_cannot_be_decoded_reports_why() {
+    struct BrokenProxies;
+    impl FootageSource for BrokenProxies {
+        fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
+            None
+        }
+        fn problem(&self, f: &Footage) -> Option<String> {
+            f.path.ends_with(".avi").then(|| format!("{} isn't supported by the built-in decoder", f.codec))
+        }
+    }
+    let mut s = Session { footage: Arc::new(BrokenProxies), ..Default::default() };
+    let comp = s.execute("comp.new", json!({"name": "C", "width": 64, "height": 36, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
+    let still = Footage { kind: FootageKind::Still, path: "a.png".into(), width: 64, height: 36, has_video: true, ..Default::default() };
+    let item = std::sync::Arc::make_mut(&mut s.project).add_item("Plate", Default::default(), None, ItemKind::Footage(still));
+    let proxy = Footage {
+        kind: FootageKind::Video,
+        path: "plate.avi".into(),
+        codec: "MPEG-4 Part 2".into(),
+        width: 32,
+        height: 18,
+        has_video: true,
+        ..Default::default()
+    };
+    let want = json!("Proxy: MPEG-4 Part 2 isn't supported by the built-in decoder");
+    let problem = |s: &mut Session, id: u64| {
+        let sum = s.execute("project.summary", json!({})).unwrap();
+        sum["items"].as_array().unwrap().iter().find(|i| i["id"] == json!(id)).unwrap().get("problem").cloned()
+    };
+    for id in [item.0, comp] {
+        let p = std::sync::Arc::make_mut(&mut s.project);
+        p.items.get_mut(&ItemId(id)).unwrap().proxy = Some(Box::new(effectcraft_project::Proxy { footage: proxy.clone(), enabled: true }));
+        assert_eq!(problem(&mut s, id), Some(want.clone()), "item {id}");
+        std::sync::Arc::make_mut(&mut s.project).items.get_mut(&ItemId(id)).unwrap().proxy.as_mut().unwrap().enabled = false;
+        assert_eq!(problem(&mut s, id), None, "item {id}: its own file shows, and is fine");
+    }
+    std::sync::Arc::make_mut(&mut s.project).items.get_mut(&item).unwrap().proxy.as_mut().unwrap().enabled = true;
+    s.execute("footage.open", json!({"item": item.0})).unwrap();
+    assert_eq!(s.execute("footage.info", json!({})).unwrap()["problem"], want);
+}
diff --git a/crates/engine/src/tests_project_items.rs b/crates/engine/src/tests/project_items.rs
similarity index 100%
rename from crates/engine/src/tests_project_items.rs
rename to crates/engine/src/tests/project_items.rs
diff --git a/crates/engine/src/tests/proxy.rs b/crates/engine/src/tests/proxy.rs
new file mode 100644
index 000000000..40927b8b8
--- /dev/null
+++ b/crates/engine/src/tests/proxy.rs
@@ -0,0 +1,566 @@
+//! Proxies (Set Proxy, Use Proxy, Proxy Use render settings, comp proxies, Create Proxy) and
+//! Interpret Footage (fields, pixel aspect, alpha guess / invert, linear light, Cineon Settings),
+//! rendered through a synthetic footage source.
+
+use std::sync::Arc;
+
+use effectcraft_project::render_queue::ProxyUse;
+use effectcraft_project::{AlphaMode, Footage, FootageKind, ItemId, ItemKind};
+use effectcraft_raster::Image;
+use effectcraft_time::{FrameRate, Tick};
+use serde_json::json;
+
+use crate::Session;
+use crate::render::{FootageSource, RenderOpts};
+
+/// Files by name: `red16.png` (16×16 red), `blue8.png` (8×8 blue), `lines.mov` (interlaced:
+/// even rows red, odd rows blue; 4×4, 10 fps), `flash.mov` (10×10, 10 fps: red, then blue from
+/// the second frame), `matte_black.png` / `matte_white.png` (a
+/// semi-transparent green premultiplied against black / white, read as straight), `half.png`
+/// (white at 25 % alpha), `wide.png` (10×10 white).
+struct Synthetic;
+
+fn file_px(path: &str, x: u32, y: u32) -> [f32; 4] {
+    let name = std::path::Path::new(path).file_name().and_then(std::ffi::OsStr::to_str).unwrap_or("");
+    match name {
+        "red16.png" => [1.0, 0.0, 0.0, 1.0],
+        "blue8.png" => [0.0, 0.0, 1.0, 1.0],
+        "lines.mov" => {
+            if y.is_multiple_of(2) {
+                [1.0, 0.0, 0.0, 1.0]
+            } else {
+                [0.0, 0.0, 1.0, 1.0]
+            }
+        }
+        // Straight interpretation of a file whose colour is green·a + matte·(1 − a), a = 0.5.
+        "matte_black.png" => [0.0, 0.5, 0.0, 0.5],
+        "matte_white.png" => [0.5, 1.0, 0.5, 0.5],
+        "half.png" => [1.0, 1.0, 1.0, 0.25],
+        // A log film scan: code values 95, 685, 400 and 1023 across, as the DPX reader hands
+        // them out (code / 1023).
+        "scan.dpx" | "plate.dpx" => {
+            let v = [95.0, 685.0, 400.0, 1023.0][x.min(3) as usize] / 1023.0;
+            [v, v, v, 1.0]
+        }
+        _ => {
+            let _ = x;
+            [1.0, 1.0, 1.0, 1.0]
+        }
+    }
+}
+
+fn size_of(path: &str) -> (u32, u32) {
+    match std::path::Path::new(path).file_name().and_then(std::ffi::OsStr::to_str).unwrap_or("") {
+        "red16.png" => (16, 16),
+        "blue8.png" => (8, 8),
+        "lines.mov" | "matte_black.png" | "matte_white.png" | "half.png" | "scan.dpx" | "plate.dpx" => (4, 4),
+        _ => (10, 10),
+    }
+}
+
+impl FootageSource for Synthetic {
+    fn frame(&self, _: ItemId, f: &Footage, t: Tick) -> Option<Arc<Image>> {
+        let (w, h) = size_of(&f.path);
+        let mut img = Image::new(w, h);
+        // `flash.mov` is red for its first frame and blue from its second (0.1 s) on.
+        if f.path.ends_with("flash.mov") {
+            let c = if t.seconds() >= 0.1 - 1e-9 { [0.0, 0.0, 1.0, 1.0] } else { [1.0, 0.0, 0.0, 1.0] };
+            return Some(Arc::new(Image::filled(w, h, c)));
+        }
+        for y in 0..h {
+            for x in 0..w {
+                // Decoders hand out premultiplied pixels (straight file colour × alpha).
+                let mut p = file_px(&f.path, x, y);
+                // A log scan sequence: code 95 on even frames, 685 on odd ones.
+                if f.path.ends_with("frames.dpx") {
+                    let v = if f.frame_rate.frame_at(t) % 2 == 0 { 95.0 } else { 685.0 } / 1023.0;
+                    p = [v, v, v, 1.0];
+                }
+                img.set(x, y, [p[0] * p[3], p[1] * p[3], p[2] * p[3], p[3]]);
+            }
+        }
+        Some(Arc::new(img))
+    }
+}
+
+struct Probe;
+impl crate::Importer for Probe {
+    fn probe(&self, path: &str) -> Result<Footage, String> {
+        let (w, h) = size_of(path);
+        let video = path.ends_with(".mov") || path.ends_with("frames.dpx");
+        Ok(Footage {
+            path: path.into(),
+            kind: if video { FootageKind::Video } else { FootageKind::Still },
+            width: w,
+            height: h,
+            has_video: true,
+            frame_rate: FrameRate::from_f64(10.0),
+            duration: Tick::from_seconds_f64(if video { 2.0 } else { 0.0 }),
+            ..Default::default()
+        })
+    }
+}
+
+fn session() -> Session {
+    Session { footage: Arc::new(Synthetic), importer: Some(Arc::new(Probe)), ..Default::default() }
+}
+
+fn import(s: &mut Session, path: &str) -> ItemId {
+    ItemId(s.execute("file.import", json!({"paths": [path]})).unwrap()["items"][0].as_u64().unwrap())
+}
+
+fn px(s: &Session, comp: ItemId, t: f64, opts: RenderOpts, x: i64, y: i64) -> [f32; 4] {
+    s.render(comp, Tick::from_seconds_f64(t), opts).get(x, y)
+}
+
+fn red(p: [f32; 4]) -> bool {
+    p[0] > 0.99 && p[2] < 0.01 && p[3] > 0.99
+}
+fn blue(p: [f32; 4]) -> bool {
+    p[2] > 0.99 && p[0] < 0.01 && p[3] > 0.99
+}
+
+#[test]
+fn footage_proxy_follows_use_proxy_and_proxy_use() {
+    let mut s = session();
+    let full = import(&mut s, "/m/red16.png");
+    s.execute("comp.new", json!({"name": "C", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
+    let c = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": full.0})).unwrap();
+    let o = RenderOpts::default();
+    assert!(red(px(&s, c, 0.0, o, 8, 8)));
+    s.execute("file.setProxy", json!({"item": full.0, "path": "/m/blue8.png"})).unwrap();
+    // The 8×8 proxy fills the 16×16 footage frame.
+    for (x, y) in [(1, 1), (8, 8), (14, 14)] {
+        assert!(blue(px(&s, c, 0.0, o, x, y)), "proxy at {x},{y}");
+    }
+    assert!(s.project.item(full).unwrap().proxy.as_ref().unwrap().enabled);
+    // Render Settings ▸ Proxy Use.
+    assert!(red(px(&s, c, 0.0, RenderOpts { proxy: ProxyUse::UseNone, ..o }, 8, 8)));
+    assert!(red(px(&s, c, 0.0, RenderOpts { proxy: ProxyUse::UseCompOnly, ..o }, 8, 8)));
+    // Use Proxy off: the viewer shows the source, Use All Proxies still uses it.
+    s.execute("file.useProxy", json!({"item": full.0})).unwrap();
+    assert!(!s.project.item(full).unwrap().proxy.as_ref().unwrap().enabled);
+    assert!(red(px(&s, c, 0.0, o, 8, 8)));
+    assert!(blue(px(&s, c, 0.0, RenderOpts { proxy: ProxyUse::UseAll, ..o }, 8, 8)));
+    // Undo / Set Proxy ▸ None.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(blue(px(&s, c, 0.0, o, 8, 8)));
+    s.execute("file.setProxyNone", json!({"item": full.0})).unwrap();
+    assert!(s.project.item(full).unwrap().proxy.is_none());
+    assert!(red(px(&s, c, 0.0, RenderOpts { proxy: ProxyUse::UseAll, ..o }, 8, 8)));
+    // Render queue items carry Proxy Use (Best Settings: none).
+    let r = s.execute("renderQueue.add", json!({"proxyUse": "all"})).unwrap();
+    assert_eq!(s.project.render_queue[0].settings.proxy_use, ProxyUse::UseAll, "{r}");
+    assert_eq!(effectcraft_project::render_queue::RenderSettings::default().proxy_use, ProxyUse::UseNone);
+}
+
+#[test]
+fn comp_proxy_and_create_proxy() {
+    let mut s = session();
+    s.execute("comp.new", json!({"name": "Inner", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
+    let inner = s.active_comp_id().unwrap();
+    s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
+    s.execute("comp.new", json!({"name": "Outer", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
+    let outer = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": inner.0})).unwrap();
+    let o = RenderOpts::default();
+    assert!(red(px(&s, outer, 0.0, o, 8, 8)));
+    s.execute("file.setProxy", json!({"item": inner.0, "path": "/m/blue8.png"})).unwrap();
+    assert!(blue(px(&s, outer, 0.0, o, 14, 1)));
+    assert!(blue(px(&s, outer, 0.0, RenderOpts { proxy: ProxyUse::UseCompOnly, ..o }, 8, 8)));
+    assert!(red(px(&s, outer, 0.0, RenderOpts { proxy: ProxyUse::UseNone, ..o }, 8, 8)));
+    s.execute("file.setProxyNone", json!({"item": inner.0})).unwrap();
+    // Create Proxy queues a half-resolution render whose post-render action sets the proxy.
+    s.state.project_selection = vec![inner];
+    let r = s.execute("file.createProxy", json!({"kind": "still"})).unwrap();
+    let it = s.project.render_queue.last().unwrap().clone();
+    assert_eq!(it.comp, inner);
+    assert_eq!(it.post_render, effectcraft_project::render_queue::PostRenderAction::SetProxy);
+    assert_eq!(it.settings.resolution, 0.5);
+    assert!(r["output"].as_str().unwrap().contains("Inner_proxy_"), "{r}");
+    let m = s.execute("file.createProxy", json!({"kind": "movie", "comp": inner.0})).unwrap();
+    assert!(m["output"].as_str().unwrap().ends_with("Inner_proxy.mov"), "{m}");
+    // The post-render action (what a finished render runs) attaches the file.
+    let id = it.id;
+    s.post_render_action(id, "/m/blue8.png").unwrap();
+    assert_eq!(s.project.item(inner).unwrap().proxy.as_ref().unwrap().footage.path, "/m/blue8.png");
+    assert!(blue(px(&s, outer, 0.0, o, 8, 8)));
+}
+
+/// Outer (4×4, 20 fps) holding a layer of Inner (4×4, 10 fps, a red solid): (inner, outer).
+fn nested(s: &mut Session) -> (ItemId, ItemId) {
+    s.execute("comp.new", json!({"name": "Inner", "width": 4, "height": 4, "frameRate": 10, "duration": 2})).unwrap();
+    let inner = s.active_comp_id().unwrap();
+    s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
+    s.execute("comp.new", json!({"name": "Outer", "width": 4, "height": 4, "frameRate": 20, "duration": 2})).unwrap();
+    let outer = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": inner.0})).unwrap();
+    (inner, outer)
+}
+
+/// Interpret Footage ▸ Proxy's Invert Alpha and Interpret As Linear Light change what a
+/// composition proxy draws, as they do for the same file used as footage.
+#[test]
+fn comp_proxy_draws_with_its_interpretation() {
+    let mut s = session();
+    let (inner, outer) = nested(&mut s);
+    let o = RenderOpts::default();
+    // Invert Alpha: the 25 % proxy covers 75 %.
+    s.execute("file.setProxy", json!({"item": inner.0, "path": "/m/half.png"})).unwrap();
+    s.execute("file.interpretProxy", json!({"item": inner.0, "alpha": "straight", "invertAlpha": true})).unwrap();
+    let p = px(&s, outer, 0.0, o, 1, 1);
+    assert!((p[3] - 0.75).abs() < 0.01, "{p:?}");
+    // Interpret As Linear Light: the proxy draws as the file does as footage with that setting.
+    let f = import(&mut s, "/m/matte_black.png");
+    s.execute("file.interpretFootage", json!({"item": f.0, "linearLight": true})).unwrap();
+    s.execute("comp.new", json!({"name": "Ref", "width": 4, "height": 4, "frameRate": 20, "duration": 2})).unwrap();
+    let r = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": f.0})).unwrap();
+    let want = px(&s, r, 0.0, o, 1, 1);
+    assert!(want[1] / want[3] > 0.7, "linear light re-encodes the 0.5 green: {want:?}");
+    s.execute("file.setProxy", json!({"item": inner.0, "path": "/m/matte_black.png"})).unwrap();
+    s.execute("file.interpretProxy", json!({"item": inner.0, "linearLight": true})).unwrap();
+    let p = px(&s, outer, 0.0, o, 1, 1);
+    assert!((0..4).all(|i| (p[i] - want[i]).abs() < 1e-3), "{p:?} != {want:?}");
+}
+
+/// Interpret Footage ▸ Proxy ▸ Separate Fields: a composition proxy shows one field per frame
+/// at twice the rate, as footage does.
+#[test]
+fn comp_proxy_separates_fields() {
+    let mut s = session();
+    let (inner, outer) = nested(&mut s);
+    let o = RenderOpts::default();
+    s.execute("file.setProxy", json!({"item": inner.0, "path": "/m/lines.mov"})).unwrap();
+    assert!(red(px(&s, outer, 0.05, o, 1, 0)) && blue(px(&s, outer, 0.05, o, 1, 1)), "progressive");
+    s.execute("file.interpretProxy", json!({"item": inner.0, "fields": "upper"})).unwrap();
+    // At 0.05 s the lower field (odd rows, blue) is shown, with the even rows interpolated.
+    for y in 0..3 {
+        assert!(blue(px(&s, outer, 0.05, o, 1, y)), "lower field at row {y}");
+    }
+}
+
+/// Frame Blending on a precomp layer blends the frames of the composition's proxy.
+#[test]
+fn comp_proxy_frames_blend() {
+    let mut s = session();
+    let (inner, outer) = nested(&mut s);
+    let o = RenderOpts::default();
+    s.execute("file.setProxy", json!({"item": inner.0, "path": "/m/flash.mov"})).unwrap();
+    assert!(red(px(&s, outer, 0.05, o, 1, 1)));
+    s.execute("layer.frameBlending", json!({"mode": "frameMix"})).unwrap();
+    s.execute("comp.setSwitch", json!({"switch": "frameBlending", "value": true})).unwrap();
+    // Halfway between the red first frame and the blue second one.
+    let p = px(&s, outer, 0.05, o, 1, 1);
+    assert!((p[0] - 0.5).abs() < 0.05 && (p[2] - 0.5).abs() < 0.05 && p[3] > 0.99, "{p:?}");
+    assert!(blue(px(&s, outer, 0.1, o, 1, 1)));
+}
+
+#[test]
+fn comp_proxy_frame_blend_cache_tracks_alpha_interpretation() {
+    struct Interpreted(std::sync::atomic::AtomicUsize);
+    impl FootageSource for Interpreted {
+        fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
+            self.0.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+            let pixel = match f.alpha {
+                AlphaMode::Straight => [0.4, 0.2, 0.1, 0.5],
+                AlphaMode::Premultiplied => [f.premul_color[0] * 0.5, 0.1, 0.0, 0.5],
+                AlphaMode::Ignore => [0.8, 0.4, 0.2, 1.0],
+            };
+            Some(Arc::new(Image::filled(4, 4, pixel)))
+        }
+    }
+    for mode in ["frameMix", "pixelMotion"] {
+        let mut s = session();
+        let footage = Arc::new(Interpreted(std::sync::atomic::AtomicUsize::new(0)));
+        s.footage = footage.clone();
+        let (inner, outer) = nested(&mut s);
+        s.execute("file.setProxy", json!({"item": inner.0, "path": "/m/alpha.mov"})).unwrap();
+        s.execute("file.interpretProxy", json!({"item": inner.0, "alpha": "straight"})).unwrap();
+        s.execute("layer.frameBlending", json!({"mode": mode})).unwrap();
+        s.execute("comp.setSwitch", json!({"switch": "frameBlending", "value": true})).unwrap();
+        let opts = RenderOpts::default();
+        let first = px(&s, outer, 0.05, opts, 1, 1);
+        let calls = footage.0.load(std::sync::atomic::Ordering::Relaxed);
+        assert_eq!(px(&s, outer, 0.05, opts, 1, 1), first);
+        assert_eq!(footage.0.load(std::sync::atomic::Ordering::Relaxed), calls);
+        for params in [
+            json!({"item": inner.0, "alpha": "ignore"}),
+            json!({"item": inner.0, "alpha": "premultiplied", "premulColor": [0.0, 0.0, 0.0]}),
+            json!({"item": inner.0, "alpha": "premultiplied", "premulColor": [1.0, 0.0, 0.0]}),
+        ] {
+            s.execute("file.interpretProxy", params.clone()).unwrap();
+            let mut fresh = s.renderer(opts);
+            fresh.cache = None;
+            let want = fresh.comp_frame(outer, Tick::from_seconds_f64(0.05)).get(1, 1);
+            let actual = px(&s, outer, 0.05, opts, 1, 1);
+            assert_eq!(actual, want, "{mode} after {params}");
+        }
+    }
+}
+
+#[test]
+fn interpret_proxy_settings_apply_to_the_proxy() {
+    let mut s = session();
+    let full = import(&mut s, "/m/red16.png");
+    s.execute("file.setProxy", json!({"item": full.0, "path": "/m/half.png"})).unwrap();
+    s.execute("file.interpretProxy", json!({"item": full.0, "alpha": "ignore", "invertAlpha": true})).unwrap();
+    let px = s.project.item(full).unwrap().proxy.clone().unwrap();
+    assert_eq!(px.footage.alpha, AlphaMode::Ignore);
+    assert!(px.footage.invert_alpha);
+    let f = match &s.project.item(full).unwrap().kind {
+        ItemKind::Footage(f) => f.clone(),
+        _ => panic!("not footage"),
+    };
+    assert_eq!(f.alpha, AlphaMode::Straight, "the main footage keeps its interpretation");
+}
+
+/// Agents and the control channel run commands through `execute_checked`, which refuses keys a
+/// params doc does not list. The Interpret Footage commands list every key they read.
+#[test]
+fn interpret_commands_accept_their_keys_when_checked() {
+    let mut s = session();
+    let mov = import(&mut s, "/m/lines.mov");
+    let b = import(&mut s, "/m/red16.png");
+    s.execute("file.setProxy", json!({"item": mov.0, "path": "/m/lines.mov"})).unwrap();
+    s.execute("file.setProxy", json!({"item": b.0, "path": "/m/matte_black.png"})).unwrap();
+    s.execute_checked("file.interpretProxy", json!({"item": mov.0, "preserveRgb": true, "overrideStart": true, "startTimecode": 25})).unwrap();
+    let px = s.project.item(mov).unwrap().proxy.clone().unwrap().footage;
+    assert!(px.preserve_rgb);
+    assert_eq!(px.start_timecode, Some(25));
+    s.execute_checked("file.interpretProxy", json!({"item": mov.0, "overrideStart": false})).unwrap();
+    assert_eq!(s.project.item(mov).unwrap().proxy.as_ref().unwrap().footage.start_timecode, None);
+    s.execute_checked("file.interpretProxy", json!({"item": b.0, "guessAlpha": true})).unwrap();
+    assert_eq!(s.project.item(b).unwrap().proxy.as_ref().unwrap().footage.alpha, AlphaMode::Premultiplied);
+    s.execute_checked("file.interpretProxy", json!({"item": b.0, "premulColor": [1.0, 0.0, 0.0]})).unwrap();
+    assert_eq!(s.project.item(b).unwrap().proxy.as_ref().unwrap().footage.premul_color, [1.0, 0.0, 0.0]);
+    // `item` names one footage item, as `items` names several.
+    s.execute_checked("file.interpretFootage", json!({"item": b.0, "invertAlpha": true, "premulColor": [0.0, 1.0, 0.0]})).unwrap();
+    s.execute_checked("file.rememberInterpretation", json!({"item": b.0})).unwrap();
+    s.execute_checked("file.applyInterpretation", json!({"item": mov.0})).unwrap();
+    let f = match &s.project.item(mov).unwrap().kind {
+        ItemKind::Footage(f) => f.clone(),
+        _ => panic!("not footage"),
+    };
+    assert!(f.invert_alpha);
+    assert_eq!(f.premul_color, [0.0, 1.0, 0.0]);
+    assert_eq!(s.execute_checked("file.reloadFootage", json!({"item": mov.0})).unwrap()["reloaded"], 1);
+}
+
+/// Separate Fields: each field becomes a frame at twice the frame rate, the other field's lines
+/// interpolated; the dominant field comes first.
+#[test]
+fn separate_fields_make_frames_from_fields() {
+    let mut s = session();
+    let mov = import(&mut s, "/m/lines.mov");
+    s.execute("comp.new", json!({"name": "C", "width": 4, "height": 4, "frameRate": 20, "duration": 1})).unwrap();
+    let c = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": mov.0})).unwrap();
+    let o = RenderOpts::default();
+    // Progressive: alternating rows.
+    assert!(red(px(&s, c, 0.0, o, 1, 0)) && blue(px(&s, c, 0.0, o, 1, 1)));
+    s.execute("file.interpretFootage", json!({"item": mov.0, "fields": "upper"})).unwrap();
+    // Field 1 (upper = even rows, red) then field 2 (odd rows, blue), each 1/20 s.
+    for y in 0..3 {
+        assert!(red(px(&s, c, 0.0, o, 1, y)), "upper field at row {y}");
+        assert!(blue(px(&s, c, 0.05, o, 1, y + 1)), "lower field at row {}", y + 1);
+    }
+    s.execute("file.interpretFootage", json!({"item": mov.0, "fields": "lower"})).unwrap();
+    assert!(blue(px(&s, c, 0.0, o, 1, 2)));
+    assert!(red(px(&s, c, 0.05, o, 1, 1)));
+    let r = s.execute("file.interpretFootage", json!({"item": mov.0, "fields": "off"})).unwrap();
+    assert_eq!(r["items"][0]["fields"], "Off");
+}
+
+/// Non-square pixels: a 10×10 footage with pixel aspect 2 covers 20×10 comp pixels.
+#[test]
+fn pixel_aspect_stretches_footage_in_the_comp() {
+    let mut s = session();
+    let w = import(&mut s, "/m/wide.png");
+    s.execute("comp.new", json!({"name": "C", "width": 40, "height": 20, "frameRate": 10, "duration": 1})).unwrap();
+    let c = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": w.0})).unwrap();
+    let o = RenderOpts::default();
+    let covered = |s: &Session| s.render(c, Tick::ZERO, o).data.iter().filter(|p| p[3] > 0.5).count();
+    assert_eq!(covered(&s), 100);
+    s.execute("file.interpretFootage", json!({"item": w.0, "pixelAspect": 2.0})).unwrap();
+    assert_eq!(covered(&s), 200);
+    // Centered on the comp: x 10..30 (edge pixels are filtered).
+    assert!(px(&s, c, 0.0, o, 11, 10)[3] > 0.99 && px(&s, c, 0.0, o, 28, 10)[3] > 0.99);
+    assert!(px(&s, c, 0.0, o, 8, 10)[3] < 0.01 && px(&s, c, 0.0, o, 31, 10)[3] < 0.01);
+    // A comp with the same pixel aspect shows the footage 1:1.
+    s.execute("comp.settings", json!({"pixelAspect": 2.0})).unwrap();
+    assert_eq!(covered(&s), 100);
+}
+
+/// Alpha ▸ Guess: premultiplied files are recognised with their matte colour; Invert Alpha
+/// and Interpret As Linear Light change the decoded pixels.
+#[test]
+fn guess_alpha_invert_and_linear_light() {
+    let mut s = session();
+    let b = import(&mut s, "/m/matte_black.png");
+    let w = import(&mut s, "/m/matte_white.png");
+    let h = import(&mut s, "/m/half.png");
+    let foot = |s: &Session, i: ItemId| match &s.project.item(i).unwrap().kind {
+        ItemKind::Footage(f) => f.clone(),
+        _ => panic!("not footage"),
+    };
+    s.execute("file.interpretFootage", json!({"items": [b.0, w.0, h.0], "alpha": "guess"})).unwrap();
+    assert_eq!(foot(&s, b).alpha, AlphaMode::Premultiplied);
+    assert_eq!(foot(&s, b).premul_color, [0.0; 3]);
+    assert_eq!(foot(&s, w).alpha, AlphaMode::Premultiplied);
+    assert_eq!(foot(&s, w).premul_color, [1.0; 3]);
+    // White at 25 %: not explained by a black matte (1 > 0.25) but it is by white… either way
+    // the guess is consistent with the pixels.
+    assert!(matches!(foot(&s, h).alpha, AlphaMode::Straight | AlphaMode::Premultiplied));
+    // An explicit matte colour.
+    s.execute("file.interpretFootage", json!({"item": b.0, "alpha": "premultiplied", "matteColor": "#808080"})).unwrap();
+    assert!((foot(&s, b).premul_color[0] - 128.0 / 255.0).abs() < 1e-3);
+    // Invert Alpha: 25 % → 75 %.
+    s.execute("file.interpretFootage", json!({"item": h.0, "alpha": "straight", "invertAlpha": true})).unwrap();
+    s.execute("comp.new", json!({"name": "C", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+    let c = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": h.0})).unwrap();
+    let p = px(&s, c, 0.0, RenderOpts::default(), 1, 1);
+    assert!((p[3] - 0.75).abs() < 0.01 && p[0] > 0.7, "{p:?}");
+    // Interpret As Linear Light keeps alpha and re-encodes the colour.
+    s.execute("file.interpretFootage", json!({"item": h.0, "invertAlpha": false, "linearLight": true})).unwrap();
+    let p = px(&s, c, 0.0, RenderOpts::default(), 1, 1);
+    assert!((p[3] - 0.25).abs() < 0.01, "{p:?}");
+    // Remember / Apply Interpretation carries the new settings.
+    s.state.project_selection = vec![h];
+    s.execute("file.rememberInterpretation", json!({"item": h.0})).unwrap();
+    s.execute("file.applyInterpretation", json!({"items": [w.0]})).unwrap();
+    assert!(foot(&s, w).linear_light);
+    // Color ▸ Preserve RGB (#411) is set, rendered and carried by Apply Interpretation.
+    let out = s.execute("file.interpretFootage", json!({"item": h.0, "preserveRgb": true})).unwrap();
+    assert_eq!(out["items"][0]["preserveRgb"], true);
+    let p = px(&s, c, 0.0, RenderOpts::default(), 1, 1);
+    assert!((p[0] - 0.25).abs() < 0.01, "white at 25 %, unconverted: {p:?}");
+    s.execute("file.rememberInterpretation", json!({"item": h.0})).unwrap();
+    s.execute("file.applyInterpretation", json!({"items": [w.0]})).unwrap();
+    assert!(foot(&s, w).preserve_rgb);
+}
+
+/// Color ▸ Cineon Settings: Logarithmic Conversion turns a DPX file's log code values into the
+/// Current Gamma between the converted points (off, they show as stored); the converted points
+/// are read and reported in the chosen Units; out-of-range values and footage that is not DPX
+/// or Cineon are refused; Remember / Apply Interpretation and undo carry the settings.
+#[test]
+fn cineon_settings_convert_dpx_code_values() {
+    let mut s = session();
+    let d = import(&mut s, "/m/scan.dpx");
+    let other = import(&mut s, "/m/plate.dpx");
+    let png = import(&mut s, "/m/red16.png");
+    let foot = |s: &Session, i: ItemId| match &s.project.item(i).unwrap().kind {
+        ItemKind::Footage(f) => f.clone(),
+        _ => panic!("not footage"),
+    };
+    s.execute("comp.new", json!({"name": "C", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+    let c = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": d.0})).unwrap();
+    let at = |s: &Session, x: i64| px(s, c, 0.0, RenderOpts::default(), x, 0)[0];
+    let near = |a: f32, b: f32| (a - b).abs() < 1.5 / 255.0;
+    // Off: the code values as stored.
+    assert!(near(at(&s, 2), 400.0 / 1023.0), "{}", at(&s, 2));
+    // The checked path (control channel, MCP) accepts every Cineon parameter the doc lists.
+    let out = s.execute_checked("file.interpretFootage", json!({"items": [d.0], "logConversion": true, "highlightRolloff": 0})).unwrap();
+    assert_eq!(out["items"][0]["cineon"]["logConversion"], true, "{out}");
+    assert!(near(at(&s, 0), 0.0) && near(at(&s, 1), 1.0), "{} {}", at(&s, 0), at(&s, 1));
+    assert!(near(at(&s, 2), 0.26190), "code 400 at gamma 1.7: {}", at(&s, 2));
+    s.execute("file.interpretFootage", json!({"item": d.0, "currentGamma": 1})).unwrap();
+    assert!(near(at(&s, 2), 0.10251), "code 400 in linear light: {}", at(&s, 2));
+    // Converted points, in 8-bit units.
+    let out = s
+        .execute_checked("file.interpretFootage", json!({"items": [d.0], "cineonUnits": "8bit", "convertedBlack": 16, "convertedWhite": 235, "currentGamma": 1, "tenBitBlack": 95, "tenBitWhite": 685}))
+        .unwrap();
+    assert_eq!(out["items"][0]["cineon"]["units"], "8bit");
+    assert!((out["items"][0]["cineon"]["convertedWhite"].as_f64().unwrap() - 235.0).abs() < 1e-3, "{out}");
+    assert!(near(at(&s, 0), 16.0 / 255.0) && near(at(&s, 1), 235.0 / 255.0), "{} {}", at(&s, 0), at(&s, 1));
+    // The form sends the points in the units it showed them in (`pointUnits`) with a new Units.
+    s.execute_checked("file.interpretFootage", json!({"items": [d.0], "pointUnits": "8bit", "cineonUnits": "float", "convertedWhite": 255})).unwrap();
+    let f = foot(&s, d);
+    assert_eq!(f.cineon.units, effectcraft_project::CineonUnits::Float);
+    assert!((f.cineon.converted_white - 1023.0).abs() < 1e-3, "{:?}", f.cineon);
+    // Refused: a black point at or above the white point, values out of range, and footage
+    // that is not DPX or Cineon. Nothing changes.
+    let before = foot(&s, d).cineon;
+    for bad in [
+        json!({"item": d.0, "tenBitBlack": 700}),
+        json!({"item": d.0, "tenBitWhite": 2000}),
+        json!({"item": d.0, "currentGamma": 0}),
+        json!({"item": d.0, "highlightRolloff": -1}),
+        json!({"item": d.0, "convertedWhite": 1.5}),
+        json!({"item": d.0, "cineonUnits": "12bit"}),
+        json!({"item": png.0, "logConversion": true}),
+    ] {
+        assert!(s.execute("file.interpretFootage", bad.clone()).is_err(), "{bad}");
+    }
+    assert_eq!(foot(&s, d).cineon, before);
+    assert!(foot(&s, png).cineon == effectcraft_project::CineonSettings::default());
+    // With DPX and other footage selected, only the DPX file takes the settings.
+    s.execute("file.interpretFootage", json!({"items": [png.0, other.0], "logConversion": true})).unwrap();
+    assert!(foot(&s, other).cineon.log_conversion && !foot(&s, png).cineon.log_conversion);
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(!foot(&s, other).cineon.log_conversion);
+    // Remember / Apply Interpretation.
+    s.state.project_selection = vec![d];
+    s.execute("file.rememberInterpretation", json!({"item": d.0})).unwrap();
+    s.execute("file.applyInterpretation", json!({"items": [other.0, png.0]})).unwrap();
+    assert_eq!(foot(&s, other).cineon, before);
+    assert_eq!(foot(&s, png).cineon, effectcraft_project::CineonSettings::default());
+    // Off again: as stored.
+    s.execute("file.interpretFootage", json!({"item": d.0, "logConversion": false})).unwrap();
+    assert!(near(at(&s, 2), 400.0 / 1023.0), "{}", at(&s, 2));
+    // Frame Mix blends converted frames: halfway between code 95 (black) and 685 (white) at
+    // Current Gamma 1 is 0.5, not the conversion of the blended code values.
+    let seq = import(&mut s, "/m/frames.dpx");
+    s.execute("file.interpretFootage", json!({"item": seq.0, "logConversion": true, "currentGamma": 1, "highlightRolloff": 0})).unwrap();
+    s.execute("comp.new", json!({"name": "Blend", "width": 10, "height": 10, "frameRate": 20, "duration": 1})).unwrap();
+    let bc = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": seq.0})).unwrap();
+    s.execute("layer.frameBlending", json!({"mode": "frameMix"})).unwrap();
+    let mid = px(&s, bc, 0.05, RenderOpts::default(), 5, 5)[0];
+    assert!(near(mid, 0.5), "frame-mixed log frames: {mid}");
+    // A DPX proxy of a composition: Interpret Proxy's settings convert it where it stands in.
+    s.execute("comp.new", json!({"name": "Inner", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+    let inner = s.active_comp_id().unwrap();
+    s.execute("comp.new", json!({"name": "Outer", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+    let outer = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": inner.0})).unwrap();
+    s.execute("file.setProxy", json!({"item": inner.0, "path": "/m/scan.dpx"})).unwrap();
+    let proxied = |s: &Session, x: i64| px(s, outer, 0.0, RenderOpts::default(), x, 0)[0];
+    assert!(near(proxied(&s, 1), 685.0 / 1023.0), "{}", proxied(&s, 1));
+    s.execute_checked("file.interpretProxy", json!({"items": [inner.0], "logConversion": true, "highlightRolloff": 0})).unwrap();
+    assert!(near(proxied(&s, 0), 0.0) && near(proxied(&s, 1), 1.0), "{} {}", proxied(&s, 0), proxied(&s, 1));
+}
+
+/// The Footage panel, the Project panel thumbnail and the tracker's source frames show DPX
+/// footage with its Cineon Settings, as a composition renders it.
+#[test]
+fn cineon_settings_apply_to_footage_panel_thumbnail_and_tracking() {
+    let mut s = session();
+    let d = import(&mut s, "/m/scan.dpx");
+    s.execute("comp.new", json!({"name": "C", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
+    let c = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": d.0})).unwrap();
+    s.execute("file.interpretFootage", json!({"item": d.0, "logConversion": true, "highlightRolloff": 0})).unwrap();
+    let near = |a: f32, b: f32| (a - b).abs() < 1.5 / 255.0;
+    let rendered = px(&s, c, 0.0, RenderOpts::default(), 2, 0)[0];
+    assert!(near(rendered, 0.26190), "code 400 at gamma 1.7: {rendered}");
+    let f = match &s.project.item(d).unwrap().kind {
+        ItemKind::Footage(f) => f.clone(),
+        _ => panic!("not footage"),
+    };
+    let panel = crate::commands::footage_panel::frame(&s, d, &f, Tick::ZERO).unwrap().get(2, 0)[0];
+    assert!(near(panel, rendered), "Footage panel: {panel}");
+    let (w, _, rgba) = (s.thumbnail_job(d, Tick::ZERO, 64).unwrap())().unwrap();
+    assert_eq!(w, 4);
+    let thumb = rgba[8] as f32 / 255.0;
+    assert!(near(thumb, rendered), "Project panel thumbnail: {thumb}");
+    let comp = s.project.comp(c).unwrap();
+    let r = crate::render::Renderer::new(&s.project, s.footage.as_ref(), RenderOpts::default());
+    let (img, _) = crate::tracking::source_frame(&r, &s.project, c, comp, &comp.layers[0], Tick::ZERO, None).unwrap();
+    assert!(near(img.get(2, 0)[0], rendered), "tracker source frame: {}", img.get(2, 0)[0]);
+}
diff --git a/crates/engine/src/tests_quick_offset.rs b/crates/engine/src/tests/quick_offset.rs
similarity index 100%
rename from crates/engine/src/tests_quick_offset.rs
rename to crates/engine/src/tests/quick_offset.rs
diff --git a/crates/engine/src/tests/render_overwrite.rs b/crates/engine/src/tests/render_overwrite.rs
new file mode 100644
index 000000000..7ed21f739
--- /dev/null
+++ b/crates/engine/src/tests/render_overwrite.rs
@@ -0,0 +1,1042 @@
+//! Rendering never replaces a file the project reads (#1743). Ordinary-file replacement
+//! behavior stays with the exporter and its confirmation API. Two items of one job never write
+//! the same file either.
+
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+
+use effectcraft_color::Label;
+use effectcraft_project::render_queue::{OutputFormat, RenderStatus, sequence_path};
+use effectcraft_project::{Footage, FootageKind, ItemId, ItemKind};
+use effectcraft_time::Tick;
+use serde_json::{Value, json};
+
+use crate::{ExportJob, ExportResult, Exporter, Session};
+
+pub(crate) const SOURCE: &[u8] = b"SOURCE FOOTAGE";
+const EARLIER: &[u8] = b"AN EARLIER RENDER";
+const RENDERED: &[u8] = b"RENDERED";
+
+/// An exporter that writes like the real one: `RENDERED` at the job's path, or at the path of
+/// every frame for a sequence (leaving the frames that exist alone when the item skips them).
+#[derive(Default)]
+struct Writer {
+    jobs: Mutex<Vec<String>>,
+}
+
+impl Exporter for Writer {
+    fn formats(&self) -> Vec<OutputFormat> {
+        OutputFormat::ALL.to_vec()
+    }
+    fn supports_skip_existing(&self, _: &effectcraft_project::render_queue::RenderSettings) -> bool {
+        true
+    }
+    fn export(&self, job: &ExportJob, _: &mut dyn FnMut(u64, u64) -> bool) -> Result<ExportResult, String> {
+        self.jobs.lock().unwrap().push(job.path.to_string());
+        let comp = job.project.comp(job.item.comp).ok_or("no comp")?;
+        let paths: Vec<String> = if job.item.output.format.is_sequence() {
+            let first = job.item.settings.first_frame(comp);
+            (0..job.item.settings.frame_count(comp)).map(|k| sequence_path(job.path, first + k as i64)).collect()
+        } else {
+            vec![job.path.to_string()]
+        };
+        for path in &paths {
+            if job.item.settings.skip_existing && Path::new(path).exists() {
+                continue;
+            }
+            if let Some(dir) = Path::new(path).parent() {
+                std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;
+            }
+            std::fs::write(path, RENDERED).map_err(|e| e.to_string())?;
+        }
+        Ok(ExportResult { path: paths.first().cloned().unwrap_or_default(), ..Default::default() })
+    }
+}
+
+/// A session whose project is saved in a fresh folder (the footage goes there too), with an
+/// exporter that writes real files.
+pub(crate) struct Fixture {
+    pub(crate) s: Session,
+    writer: Arc<Writer>,
+    pub(crate) dir: PathBuf,
+}
+
+impl Fixture {
+    pub(crate) fn new(name: &str) -> Fixture {
+        let dir = std::env::temp_dir().join("effectcraft-render-overwrite").join(format!("{}-{name}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let mut s = Session::default();
+        let writer = Arc::new(Writer::default());
+        s.exporter = Some(writer.clone());
+        s.execute("file.saveAs", json!({"path": dir.join("Project.ecproj").to_string_lossy()})).unwrap();
+        Fixture { s, writer, dir }
+    }
+
+    pub(crate) fn path(&self, file: &str) -> PathBuf {
+        self.dir.join(file)
+    }
+
+    pub(crate) fn text(&self, file: &str) -> String {
+        self.path(file).to_string_lossy().into_owned()
+    }
+
+    pub(crate) fn read(&self, file: &str) -> Vec<u8> {
+        std::fs::read(self.path(file)).unwrap()
+    }
+
+    pub(crate) fn write(&self, file: &str, bytes: &[u8]) {
+        std::fs::write(self.path(file), bytes).unwrap();
+    }
+
+    /// A video file in the project's folder, imported.
+    pub(crate) fn footage(&mut self, file: &str) -> ItemId {
+        self.write(file, SOURCE);
+        let f = Footage {
+            path: self.text(file),
+            kind: FootageKind::Video,
+            width: 64,
+            height: 36,
+            has_video: true,
+            duration: Tick::from_seconds_f64(1.0),
+            ..Default::default()
+        };
+        Arc::make_mut(&mut self.s.project).add_item(file, Label::None, None, ItemKind::Footage(f))
+    }
+
+    /// Numbered stills in the project's folder, imported as one image sequence.
+    fn sequence(&mut self, name: &str, frames: std::ops::Range<u32>) -> ItemId {
+        self.sequence_as(name, "png", frames)
+    }
+
+    /// [`Fixture::sequence`] of files with extension `ext`.
+    pub(crate) fn sequence_as(&mut self, name: &str, ext: &str, frames: std::ops::Range<u32>) -> ItemId {
+        let files: Vec<String> = frames
+            .map(|n| {
+                let file = format!("{name}_{n:05}.{ext}");
+                self.write(&file, SOURCE);
+                self.text(&file)
+            })
+            .collect();
+        let f = Footage {
+            path: files[0].clone(),
+            kind: FootageKind::Sequence,
+            sequence: files,
+            width: 16,
+            height: 16,
+            has_video: true,
+            duration: Tick::from_seconds_f64(0.5),
+            ..Default::default()
+        };
+        Arc::make_mut(&mut self.s.project).add_item(&format!("{name}_[00000-00004].{ext}"), Label::None, None, ItemKind::Footage(f))
+    }
+
+    /// A five-frame composition.
+    pub(crate) fn comp(&mut self, name: &str) {
+        self.s.execute("comp.new", json!({"name": name, "width": 16, "height": 16, "frameRate": 10, "duration": 0.5})).unwrap();
+    }
+
+    /// The output path of queue item `index` (0-based).
+    fn output(&self, index: usize) -> PathBuf {
+        PathBuf::from(self.s.resolve_output(&self.s.project.render_queue[index]).unwrap())
+    }
+
+    /// The paths the exporter was started for.
+    pub(crate) fn exported(&self) -> Vec<String> {
+        self.writer.jobs.lock().unwrap().clone()
+    }
+
+    fn render(&mut self, params: Value) -> crate::Result<Value> {
+        self.s.execute("renderQueue.render", params)
+    }
+}
+
+impl Drop for Fixture {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.dir);
+    }
+}
+
+fn link(target: &Path, link: &Path) -> std::io::Result<()> {
+    #[cfg(unix)]
+    return std::os::unix::fs::symlink(target, link);
+    #[cfg(windows)]
+    return std::os::windows::fs::symlink_file(target, link);
+    #[cfg(not(any(unix, windows)))]
+    {
+        let _ = (target, link);
+        Err(std::io::ErrorKind::Unsupported.into())
+    }
+}
+
+/// A folder that leads to `target`: a symbolic link, or on Windows, where that takes a privilege
+/// most accounts lack, a junction.
+fn link_dir(target: &Path, link: &Path) -> std::io::Result<()> {
+    #[cfg(unix)]
+    return std::os::unix::fs::symlink(target, link);
+    #[cfg(windows)]
+    return std::os::windows::fs::symlink_dir(target, link).or_else(|_| {
+        let made = std::process::Command::new("cmd").args(["/C", "mklink", "/J"]).arg(link).arg(target).output()?;
+        if made.status.success() { Ok(()) } else { Err(std::io::Error::other(String::from_utf8_lossy(&made.stdout).into_owned())) }
+    });
+    #[cfg(not(any(unix, windows)))]
+    {
+        let _ = (target, link);
+        Err(std::io::ErrorKind::Unsupported.into())
+    }
+}
+
+/// The report: save a new project beside `footage.mp4`, import it, make a composition from it
+/// (it is named after the file), add that to the Render Queue and click Render. The composition's
+/// default output is `<project folder>/footage.mp4`, the footage itself.
+#[test]
+fn a_comp_made_from_footage_does_not_render_over_it() {
+    let mut f = Fixture::new("comp-from-footage");
+    let footage = f.footage("footage.mp4");
+    f.s.state.project_selection = vec![footage];
+    f.s.execute("file.newCompFromSelection", json!({"addToRenderQueue": true})).unwrap();
+    assert_eq!(f.s.project.render_queue.len(), 1);
+    f.render(json!({})).unwrap();
+    assert_eq!(f.read("footage.mp4"), SOURCE, "the footage is still the footage");
+    assert_eq!(f.s.project.render_queue[0].status, RenderStatus::Done);
+    // The default name stepped aside: the render sits next to it.
+    assert_eq!(f.output(0), f.path("footage_1.mp4"));
+    assert_eq!(f.read("footage_1.mp4"), RENDERED);
+    // Another item for the same composition takes the next free number.
+    f.s.execute("renderQueue.add", json!({})).unwrap();
+    assert_eq!(f.output(1), f.path("footage_2.mp4"));
+}
+
+#[test]
+fn an_output_that_is_the_footage_is_refused_with_or_without_overwrite() {
+    for (n, params) in [json!({}), json!({"overwrite": true})].into_iter().enumerate() {
+        let mut f = Fixture::new(&format!("explicit-footage-{n}"));
+        f.footage("clip.mov");
+        f.comp("Main");
+        let clip = f.text("clip.mov");
+        f.s.execute("renderQueue.add", json!({"format": "prores", "output": clip})).unwrap();
+        let e = f.render(params).unwrap_err().to_string();
+        assert!(e.contains("clip.mov") && e.contains("footage"), "{e}");
+        assert_eq!(f.read("clip.mov"), SOURCE);
+        assert!(f.exported().is_empty(), "the exporter was not started");
+        let RenderStatus::Failed(why) = &f.s.project.render_queue[0].status else { panic!("{:?}", f.s.project.render_queue[0].status) };
+        assert!(why.contains("clip.mov"), "{why}");
+    }
+}
+
+/// An item that would replace the footage fails on its own; the rest of the queue renders.
+#[test]
+fn the_rest_of_the_queue_renders_when_one_item_would_replace_footage() {
+    let mut f = Fixture::new("one-refused");
+    f.footage("clip.mov");
+    f.comp("Main");
+    let clip = f.text("clip.mov");
+    f.s.execute("renderQueue.add", json!({"format": "prores", "output": clip})).unwrap();
+    let ok = f.text("main.mp4");
+    f.s.execute("renderQueue.add", json!({"output": ok})).unwrap();
+    let r = f.render(json!({})).unwrap();
+    assert_eq!(f.read("clip.mov"), SOURCE);
+    assert_eq!(f.read("main.mp4"), RENDERED);
+    assert!(matches!(f.s.project.render_queue[0].status, RenderStatus::Failed(_)));
+    assert_eq!(f.s.project.render_queue[1].status, RenderStatus::Done);
+    assert!(r["items"].as_array().unwrap().iter().any(|i| i["status"].get("Failed").is_some()), "the reply includes the refused item: {r}");
+    assert!(r["items"].as_array().unwrap().iter().any(|i| i["status"] == "Done"), "{r}");
+}
+
+#[test]
+fn the_project_file_is_never_an_output() {
+    let mut f = Fixture::new("project-file");
+    // A project saved under a name a movie could have.
+    let name = f.text("final.mp4");
+    f.s.execute("file.saveAs", json!({"path": name})).unwrap();
+    f.comp("final");
+    f.s.execute("renderQueue.add", json!({})).unwrap();
+    assert_eq!(f.output(0), f.path("final_1.mp4"), "the default name moves aside");
+    f.s.execute("renderQueue.remove", json!({"index": 1})).unwrap();
+    f.s.execute("renderQueue.add", json!({"output": name})).unwrap();
+    let e = f.render(json!({"overwrite": true})).unwrap_err().to_string();
+    assert!(e.contains("final.mp4") && e.contains("project"), "{e}");
+    assert!(std::fs::read_to_string(f.path("final.mp4")).unwrap().contains("\"schema\""), "the project file is still a project");
+}
+
+#[test]
+fn a_proxy_is_not_an_output_either() {
+    let mut f = Fixture::new("proxy");
+    f.footage("clip.mov");
+    f.write("proxy.mov", SOURCE);
+    f.comp("Main");
+    let proxy = Footage { path: f.text("proxy.mov"), kind: FootageKind::Video, has_video: true, ..Default::default() };
+    let comp = f.s.active_comp_id().unwrap();
+    Arc::make_mut(&mut f.s.project).item_mut(comp).unwrap().proxy = Some(Box::new(effectcraft_project::Proxy { footage: proxy, enabled: true }));
+    let target = f.text("proxy.mov");
+    f.s.execute("renderQueue.add", json!({"format": "prores", "output": target})).unwrap();
+    let e = f.render(json!({"overwrite": true})).unwrap_err().to_string();
+    assert!(e.contains("proxy"), "{e}");
+    assert_eq!(f.read("proxy.mov"), SOURCE);
+}
+
+/// Recreating a default proxy writes a new file and attaches it, without replacing the proxy
+/// the project is currently reading. Explicitly choosing that protected path is still refused.
+#[test]
+fn creating_a_proxy_again_chooses_a_new_default_and_attaches_it() {
+    struct Probe;
+    impl crate::Importer for Probe {
+        fn probe(&self, path: &str) -> Result<Footage, String> {
+            if !Path::new(path).is_file() {
+                return Err("proxy file missing".into());
+            }
+            Ok(Footage {
+                path: path.into(),
+                kind: if path.ends_with(".png") { FootageKind::Still } else { FootageKind::Video },
+                width: 16,
+                height: 16,
+                has_video: true,
+                ..Default::default()
+            })
+        }
+    }
+    for kind in ["movie", "still"] {
+        let mut f = Fixture::new(&format!("recreate-proxy-{kind}"));
+        f.s.importer = Some(Arc::new(Probe));
+        f.comp("Main");
+        let comp = f.s.active_comp_id().unwrap();
+        f.s.execute("file.createProxy", json!({"kind": kind})).unwrap();
+        f.render(json!({})).unwrap();
+        let first = f.s.project.item(comp).unwrap().proxy.as_ref().unwrap().footage.path.clone();
+        assert_eq!(std::fs::read(&first).unwrap(), RENDERED);
+
+        f.s.execute("file.createProxy", json!({"kind": kind})).unwrap();
+        f.render(json!({})).unwrap();
+        let second = f.s.project.item(comp).unwrap().proxy.as_ref().unwrap().footage.path.clone();
+        assert_ne!(second, first, "the replacement proxy gets its own file");
+        assert_eq!(std::fs::read(&second).unwrap(), RENDERED);
+        assert_eq!(std::fs::read(&first).unwrap(), RENDERED);
+        assert_eq!(f.exported().len(), 2);
+
+        // For a still proxy, an explicit output is the sequence pattern, not its first
+        // rendered frame (a bare PNG name would have another frame number appended).
+        let protected_output = f.output(1);
+        f.s.execute("file.createProxy", json!({"kind": kind, "path": protected_output})).unwrap();
+        let error = f.render(json!({})).unwrap_err().to_string();
+        assert!(error.contains("never replaces a proxy"), "{error}");
+        assert_eq!(f.exported().len(), 2);
+    }
+}
+
+/// A pre-render becomes imported footage. Its old output stays protected even from the
+/// same queue item; issuing Pre-render again supplies a fresh default output instead.
+#[test]
+fn refreshing_a_pre_render_uses_a_new_default_without_exempting_imported_footage() {
+    struct Probe;
+    impl crate::Importer for Probe {
+        fn probe(&self, path: &str) -> Result<Footage, String> {
+            if !Path::new(path).is_file() {
+                return Err("pre-render missing".into());
+            }
+            Ok(Footage { path: path.into(), kind: FootageKind::Video, width: 16, height: 16, has_video: true, ..Default::default() })
+        }
+    }
+    let mut f = Fixture::new("refresh-pre-render");
+    f.s.importer = Some(Arc::new(Probe));
+    f.comp("Main");
+    f.s.execute("render.preRender", json!({"format": "gif"})).unwrap();
+    let first = f.output(0);
+    f.render(json!({})).unwrap();
+    f.s.execute("renderQueue.setRender", json!({"index": 1, "render": true})).unwrap();
+    let error = f.render(json!({})).unwrap_err().to_string();
+    assert!(error.contains("footage"), "{error}");
+    assert_eq!(std::fs::read(&first).unwrap(), RENDERED);
+    assert_eq!(f.exported().len(), 1);
+    f.s.execute("renderQueue.setRender", json!({"index": 1, "render": false})).unwrap();
+    f.s.execute("render.preRender", json!({"format": "gif"})).unwrap();
+    let second = f.output(1);
+    assert_ne!(first, second);
+    f.render(json!({})).unwrap();
+    assert_eq!(std::fs::read(first).unwrap(), RENDERED);
+    assert_eq!(std::fs::read(second).unwrap(), RENDERED);
+    assert_eq!(f.exported().len(), 2);
+}
+
+/// Exercise the engine's import and project serialization paths, rather than injecting a
+/// Footage item directly. The importer reads dimensions from a real, generated PNG.
+#[test]
+fn imported_footage_stays_protected_after_the_project_is_reopened() {
+    struct PngProbe;
+    impl crate::Importer for PngProbe {
+        fn probe(&self, path: &str) -> Result<Footage, String> {
+            let (width, height) = image::image_dimensions(path).map_err(|e| e.to_string())?;
+            Ok(Footage { path: path.into(), kind: FootageKind::Still, width, height, has_video: true, ..Default::default() })
+        }
+    }
+    let mut f = Fixture::new("import-reopen");
+    f.s.importer = Some(Arc::new(PngProbe));
+    let path = f.path("plate_00002.png");
+    image::RgbaImage::from_pixel(4, 4, image::Rgba([40, 80, 120, 255])).save(&path).unwrap();
+    let original = std::fs::read(&path).unwrap();
+    let result = f.s.execute("file.import", json!({"paths": [path]})).unwrap();
+    assert_eq!(result["items"].as_array().unwrap().len(), 1);
+    f.comp("Main");
+    f.s.execute("renderQueue.add", json!({"format": "png", "output": f.text("plate_[#####].png")})).unwrap();
+    f.s.execute("file.save", json!({})).unwrap();
+    f.s.execute("file.open", json!({"path": f.text("Project.ecproj")})).unwrap();
+    let error = f.render(json!({})).unwrap_err().to_string();
+    assert!(error.contains("plate_00002.png") && error.contains("footage"), "{error}");
+    assert_eq!(std::fs::read(&path).unwrap(), original);
+    assert!(f.exported().is_empty());
+}
+
+#[test]
+fn a_protected_frame_past_the_probe_limit_is_not_rendered() {
+    struct LastFrame(PathBuf);
+    impl Exporter for LastFrame {
+        fn formats(&self) -> Vec<OutputFormat> {
+            vec![OutputFormat::PngSequence]
+        }
+        fn export(&self, _: &ExportJob, _: &mut dyn FnMut(u64, u64) -> bool) -> Result<ExportResult, String> {
+            // A synthetic exporter writes only the vulnerable late frame, so a broken guard
+            // can be reproduced without creating 100,001 output directories.
+            std::fs::write(&self.0, RENDERED).map_err(|e| e.to_string())?;
+            Ok(ExportResult { path: self.0.to_string_lossy().into_owned(), ..Default::default() })
+        }
+    }
+    let mut f = Fixture::new("late-frame");
+    std::fs::create_dir_all(f.path("f100000")).unwrap();
+    f.footage("f100000/plate.png");
+    f.comp("Main");
+    f.s.execute("comp.settings", json!({"duration": 10000.1})).unwrap();
+    f.s.exporter = Some(Arc::new(LastFrame(f.path("f100000/plate.png"))));
+    f.s.execute("renderQueue.add", json!({"format": "png", "output": f.text("f[######]/plate.png")})).unwrap();
+    let error = f.render(json!({})).unwrap_err().to_string();
+    assert!(error.contains("cannot safely check"), "{error}");
+    assert_eq!(f.read("f100000/plate.png"), SOURCE);
+}
+
+/// A numbered sequence is footage frame by frame: one colliding frame is enough, and nothing of
+/// the item is rendered.
+#[test]
+fn a_sequence_never_replaces_one_of_its_footage_frames() {
+    let mut f = Fixture::new("sequence");
+    f.sequence("shot", 0..5);
+    f.comp("shot");
+    // The default name steps aside as a whole: shot_1_00000.png …
+    f.s.execute("renderQueue.add", json!({"format": "png"})).unwrap();
+    assert_eq!(f.output(0), f.path("shot_1_[#####].png"));
+    f.render(json!({})).unwrap();
+    for n in 0..5 {
+        assert_eq!(f.read(&format!("shot_{n:05}.png")), SOURCE, "frame {n}");
+        assert_eq!(f.read(&format!("shot_1_{n:05}.png")), RENDERED, "frame {n}");
+    }
+
+    // Named by hand, one frame of five is a footage file.
+    let mut f = Fixture::new("sequence-one-frame");
+    f.write("shot_00002.png", SOURCE);
+    let still = Footage { path: f.text("shot_00002.png"), kind: FootageKind::Still, width: 16, height: 16, has_video: true, ..Default::default() };
+    Arc::make_mut(&mut f.s.project).add_item("shot_00002.png", Label::None, None, ItemKind::Footage(still));
+    f.comp("shot");
+    let pattern = f.text("shot_[#####].png");
+    f.s.execute("renderQueue.add", json!({"format": "png", "output": pattern})).unwrap();
+    let e = f.render(json!({"overwrite": true})).unwrap_err().to_string();
+    assert!(e.contains("shot_00002.png"), "{e}");
+    assert_eq!(f.read("shot_00002.png"), SOURCE);
+    assert!(!f.path("shot_00000.png").exists(), "the frames before it were not rendered either");
+    assert!(f.exported().is_empty());
+}
+
+#[test]
+fn ordinary_existing_outputs_keep_the_exporters_replacement_policy() {
+    let mut f = Fixture::new("earlier-render");
+    f.comp("Main");
+    f.s.execute("renderQueue.add", json!({"output": f.text("render.mp4")})).unwrap();
+    f.write("render.mp4", EARLIER);
+    f.render(json!({})).unwrap();
+    assert_eq!(f.read("render.mp4"), RENDERED);
+    assert_eq!(f.s.project.render_queue[0].status, RenderStatus::Done);
+}
+
+#[test]
+fn a_render_with_nothing_in_the_way_needs_no_flag() {
+    let mut f = Fixture::new("free");
+    f.comp("Main");
+    f.s.execute("renderQueue.add", json!({})).unwrap();
+    assert_eq!(f.output(0), f.path("Main.mp4"), "no footage in the way: the comp's own name");
+    f.render(json!({})).unwrap();
+    assert_eq!(f.read("Main.mp4"), RENDERED);
+}
+
+/// Skip Existing Files leaves the frames that exist alone, so they need no answer.
+#[test]
+fn a_sequence_that_skips_existing_frames_needs_no_flag() {
+    let mut f = Fixture::new("skip-existing");
+    f.comp("Main");
+    let pattern = f.text("render_[#####].png");
+    f.s.execute("renderQueue.add", json!({"format": "png", "output": pattern, "skipExisting": true})).unwrap();
+    for n in 0..3 {
+        f.write(&format!("render_{n:05}.png"), EARLIER);
+    }
+    f.render(json!({})).unwrap();
+    assert_eq!(f.read("render_00002.png"), EARLIER);
+    assert_eq!(f.read("render_00003.png"), RENDERED);
+    // Ordinary files still follow the exporter's replacement policy when skipping is off.
+    f.s.execute("renderQueue.setRenderSettings", json!({"index": 1, "skipExisting": false})).unwrap();
+    f.render(json!({})).unwrap();
+    assert_eq!(f.read("render_00002.png"), RENDERED);
+}
+
+/// A link is another name for the file it points to.
+#[test]
+fn a_link_to_the_footage_is_the_footage() {
+    let mut f = Fixture::new("link");
+    f.footage("clip.mov");
+    f.comp("Main");
+    let alias = f.path("render.mov");
+    if link(&f.path("clip.mov"), &alias).is_err() {
+        eprintln!("this account cannot make symbolic links: skipped");
+        return;
+    }
+    f.s.execute("renderQueue.add", json!({"format": "prores", "output": f.text("render.mov")})).unwrap();
+    let e = f.render(json!({"overwrite": true})).unwrap_err().to_string();
+    assert!(e.contains("render.mov") && e.contains("footage"), "{e}");
+    assert_eq!(f.read("clip.mov"), SOURCE);
+    assert!(std::fs::symlink_metadata(&alias).unwrap().file_type().is_symlink(), "the link was not replaced either");
+}
+
+/// A hard link to the footage under another name is the same file on disk: replacing it would truncate the footage.
+#[test]
+fn a_hard_link_to_the_footage_is_the_footage() {
+    let mut f = Fixture::new("hardlink");
+    f.footage("clip.mov");
+    f.comp("Main");
+    if std::fs::hard_link(f.path("clip.mov"), f.path("render.mov")).is_err() {
+        eprintln!("this volume cannot make hard links: skipped");
+        return;
+    }
+    f.s.execute("renderQueue.add", json!({"format": "prores", "output": f.text("render.mov")})).unwrap();
+    // not even with overwrite
+    let e = f.render(json!({"overwrite": true})).unwrap_err().to_string();
+    assert!(e.contains("render.mov") && e.contains("footage"), "{e}");
+    assert_eq!(f.read("clip.mov"), SOURCE);
+    assert_eq!(f.read("render.mov"), SOURCE, "the other name still leads to the footage");
+    assert!(f.exported().is_empty(), "nothing was rendered");
+}
+
+/// A copy of the footage has its size and bytes, but it is another file: an earlier render may replace it.
+#[test]
+fn a_copy_of_the_footage_is_not_the_footage() {
+    let mut f = Fixture::new("copy");
+    f.footage("clip.mov");
+    f.comp("Main");
+    std::fs::copy(f.path("clip.mov"), f.path("copy.mov")).unwrap();
+    f.s.execute("renderQueue.add", json!({"format": "prores", "output": f.text("copy.mov")})).unwrap();
+    f.render(json!({})).unwrap();
+    assert_eq!(f.read("copy.mov"), RENDERED);
+    assert_eq!(f.read("clip.mov"), SOURCE, "the footage is as it was");
+}
+
+/// Footage imported through a linked folder is the same file as the one in the real folder.
+#[test]
+fn footage_reached_through_a_linked_folder_is_still_footage() {
+    let mut f = Fixture::new("linked-folder");
+    std::fs::create_dir_all(f.path("real")).unwrap();
+    std::fs::write(f.path("real").join("clip.mov"), SOURCE).unwrap();
+    if link_dir(&f.path("real"), &f.path("linked")).is_err() {
+        eprintln!("this account cannot link folders: skipped");
+        return;
+    }
+    let via_link =
+        Footage { path: f.path("linked").join("clip.mov").to_string_lossy().into_owned(), kind: FootageKind::Video, has_video: true, ..Default::default() };
+    Arc::make_mut(&mut f.s.project).add_item("clip.mov", Label::None, None, ItemKind::Footage(via_link));
+    f.comp("Main");
+    f.s.execute("renderQueue.add", json!({"format": "prores", "output": f.path("real").join("clip.mov").to_string_lossy()})).unwrap();
+    let e = f.render(json!({"overwrite": true})).unwrap_err().to_string();
+    assert!(e.contains("footage"), "{e}");
+    assert_eq!(std::fs::read(f.path("real").join("clip.mov")).unwrap(), SOURCE);
+}
+
+/// Where the volume ignores case, `CLIP.MOV` is `clip.mov`.
+#[test]
+fn another_spelling_of_the_footage_name_is_the_footage_where_the_volume_ignores_case() {
+    let mut f = Fixture::new("case");
+    f.footage("clip.mov");
+    f.comp("Main");
+    if !f.path("CLIP.MOV").exists() {
+        eprintln!("this volume tells the two names apart: skipped");
+        return;
+    }
+    let shouting = f.text("CLIP.MOV");
+    f.s.execute("renderQueue.add", json!({"format": "prores", "output": shouting})).unwrap();
+    let e = f.render(json!({"overwrite": true})).unwrap_err().to_string();
+    assert!(e.contains("footage"), "{e}");
+    assert_eq!(f.read("clip.mov"), SOURCE);
+}
+
+#[test]
+fn save_current_preview_never_replaces_footage() {
+    let mut f = Fixture::new("preview");
+    f.footage("clip.mov");
+    f.comp("Main");
+    let clip = f.text("clip.mov");
+    let e = f.s.execute("render.saveCurrentPreview", json!({"path": clip})).unwrap_err().to_string();
+    assert!(e.contains("clip.mov") && e.contains("footage"), "{e}");
+    assert_eq!(f.read("clip.mov"), SOURCE);
+    assert!(f.exported().is_empty());
+    // Anywhere else it renders.
+    let elsewhere = f.text("preview.mp4");
+    f.s.execute("render.saveCurrentPreview", json!({"path": elsewhere})).unwrap();
+    assert_eq!(f.read("preview.mp4"), RENDERED);
+}
+
+#[test]
+fn save_current_preview_checks_sequence_frames_as_well_as_the_pattern() {
+    let mut f = Fixture::new("preview-sequence");
+    f.sequence("plate", 0..5);
+    f.comp("Main");
+    let error = f.s.execute("render.saveCurrentPreview", json!({"path": f.text("plate_[#####].png")})).unwrap_err().to_string();
+    assert!(error.contains("plate_000") && error.contains("footage"), "{error}");
+    for frame in 0..5 {
+        assert_eq!(f.read(&format!("plate_{frame:05}.png")), SOURCE);
+    }
+    assert!(f.exported().is_empty());
+}
+
+/// A watched folder renders unattended; delete the status file to render a project again.
+#[test]
+fn a_watched_folder_still_renders_a_project_again_over_its_outputs() {
+    let mut f = Fixture::new("watch");
+    f.comp("Main");
+    let out = f.text("Main.mp4");
+    f.s.execute("renderQueue.add", json!({"output": out})).unwrap();
+    f.s.execute("file.save", json!({})).unwrap();
+    f.write("Main.mp4", EARLIER);
+    let folder = f.dir.to_string_lossy().into_owned();
+    let done = crate::commands::watch_folder::poll(&mut f.s, &folder).unwrap();
+    assert_eq!(done.len(), 1, "{done:?}");
+    assert_eq!(done[0]["state"], "done", "{:?}", done[0]);
+    assert_eq!(f.read("Main.mp4"), RENDERED);
+}
+
+// ------------------------------------------------------------ one file, two items of one job
+//
+// Nothing is on disk when a job starts, so the check for files that exist said nothing about two
+// queue items that resolve to one output: the item rendered last replaced the file of the one
+// before it, inside the same job.
+
+impl Fixture {
+    /// The output path of every queue item, in queue order.
+    fn outputs(&self) -> Vec<PathBuf> {
+        (0..self.s.project.render_queue.len()).map(|i| self.output(i)).collect()
+    }
+
+    fn add(&mut self, params: Value) {
+        self.s.execute("renderQueue.add", params).unwrap();
+    }
+
+    /// What the queue would write twice, in the shape the tests read: `{"duplicates": [...]}`.
+    fn check(&mut self) -> Value {
+        let formats = self.s.exporter.as_ref().map(|e| e.formats()).unwrap_or_default();
+        let (items, _) = self.s.queued_outputs(&formats);
+        let refused = self.s.check_outputs(&items);
+        let duplicates: Vec<Value> = self
+            .s
+            .duplicate_outputs(&items, &refused)
+            .unwrap()
+            .iter()
+            .map(|d| {
+                json!({
+                    "item": d.item, "index": d.index, "comp": d.comp, "path": d.path, "files": d.files, "sequence": d.sequence,
+                    "with": {"item": d.with, "index": d.with_index, "comp": d.with_comp}, "reason": d.reason(),
+                })
+            })
+            .collect();
+        json!({"duplicates": duplicates})
+    }
+
+    /// What `check` lists under `duplicates`: for each, the place in the queue of the item that
+    /// would write over a file, the place of the item that wrote it first, and how many files.
+    fn clashes(&mut self) -> Vec<(u64, u64, u64)> {
+        let found = self.check();
+        let list = found["duplicates"].as_array().unwrap_or_else(|| panic!("checkOutputs lists no duplicates: {found}"));
+        list.iter().map(|d| (d["index"].as_u64().unwrap_or(0), d["with"]["index"].as_u64().unwrap_or(0), d["files"].as_u64().unwrap_or(0))).collect()
+    }
+}
+
+/// A PNG sequence of `pattern` for the composition's seconds `start..end`.
+fn span(pattern: &str, start: f64, end: f64) -> Value {
+    json!({"format": "png", "output": pattern, "timeSpan": "custom", "start": start, "end": end})
+}
+
+fn with_overflow(f: &mut Fixture) {
+    struct Room;
+    impl effectcraft_project::render_queue::StorageQuota for Room {
+        fn has_room(&self, _: &str, _: u64) -> bool {
+            true
+        }
+    }
+    f.s.storage_quota = Some(Arc::new(Room));
+    std::fs::create_dir_all(f.path("overflow")).unwrap();
+    Arc::make_mut(&mut f.s.project).render_prefs.overflow_folders = vec![f.text("overflow")];
+}
+
+#[test]
+fn default_names_avoid_possible_storage_overflow_collisions() {
+    let mut f = Fixture::new("overflow-default");
+    f.comp("Main");
+    with_overflow(&mut f);
+    f.add(json!({"output": f.text("other/Main.mp4"), "storageOverflow": true}));
+    f.add(json!({"storageOverflow": true}));
+    assert_eq!(f.output(1), f.path("Main_1.mp4"));
+    assert!(f.clashes().is_empty());
+}
+
+#[test]
+fn possible_storage_overflow_destinations_cannot_replace_footage() {
+    let mut f = Fixture::new("overflow-footage");
+    f.comp("Main");
+    with_overflow(&mut f);
+    f.footage("overflow/Main.mp4");
+    f.add(json!({"output": f.text("other/Main.mp4"), "storageOverflow": true}));
+    let error = f.render(json!({})).unwrap_err().to_string();
+    assert!(error.contains("footage") && error.contains("Main.mp4"), "{error}");
+    assert!(f.exported().is_empty());
+    assert_eq!(f.read("overflow/Main.mp4"), SOURCE);
+}
+
+#[test]
+fn default_names_avoid_protected_storage_overflow_destinations() {
+    let mut f = Fixture::new("overflow-protected-default");
+    f.comp("Main");
+    with_overflow(&mut f);
+    f.footage("overflow/Main.mp4");
+    f.add(json!({"storageOverflow": true}));
+    assert_eq!(f.output(0), f.path("Main_1.mp4"));
+    f.render(json!({})).unwrap();
+    assert_eq!(f.exported().len(), 1);
+    assert_eq!(f.read("overflow/Main.mp4"), SOURCE);
+}
+
+/// After Effects numbers the second item of one composition (`Comp 1_1.mov`). A default output
+/// name that another item of the queue already has is numbered the same way.
+#[test]
+fn a_second_default_item_for_one_comp_gets_the_next_free_name() {
+    let mut f = Fixture::new("second-default");
+    f.comp("Main");
+    for _ in 0..3 {
+        f.add(json!({}));
+    }
+    assert_eq!(f.outputs(), [f.path("Main.mp4"), f.path("Main_1.mp4"), f.path("Main_2.mp4")]);
+    // The name is stored in the item: taking the first one out renames nothing, and the name it
+    // frees is the next default.
+    f.s.execute("renderQueue.remove", json!({"index": 1})).unwrap();
+    assert_eq!(f.outputs(), [f.path("Main_1.mp4"), f.path("Main_2.mp4")]);
+    f.add(json!({}));
+    assert_eq!(f.output(2), f.path("Main.mp4"));
+    assert!(f.clashes().is_empty());
+    f.render(json!({})).unwrap();
+    for file in ["Main.mp4", "Main_1.mp4", "Main_2.mp4"] {
+        assert_eq!(f.read(file), RENDERED, "{file}");
+    }
+    assert_eq!(f.exported().len(), 3);
+}
+
+#[test]
+fn only_outputs_that_name_one_file_are_numbered() {
+    let mut f = Fixture::new("same-file-only");
+    f.comp("Main");
+    f.add(json!({"format": "h264"}));
+    f.add(json!({"format": "prores"}));
+    f.add(json!({"format": "hevc"})); // H.264 and HEVC both write .mp4
+    f.add(json!({"format": "png"}));
+    f.add(json!({"format": "png"})); // the same five frames of the same sequence
+    assert_eq!(f.outputs(), [f.path("Main.mp4"), f.path("Main.mov"), f.path("Main_1.mp4"), f.path("Main_[#####].png"), f.path("Main_1_[#####].png")]);
+    assert!(f.clashes().is_empty());
+}
+
+#[test]
+fn a_default_name_avoids_every_output_module_of_the_other_items() {
+    let mut f = Fixture::new("modules");
+    f.comp("Main");
+    f.add(json!({}));
+    // The item's second module is named Main_2.mp4, so that it does not clash with its first.
+    let item = f.s.execute("render.addOutputModule", json!({})).unwrap();
+    assert_eq!(Path::new(item["extraOutputs"][0]["outputPath"].as_str().unwrap()), f.path("Main_2.mp4"), "{item}");
+    f.add(json!({}));
+    f.add(json!({}));
+    assert_eq!(f.output(1), f.path("Main_1.mp4"));
+    assert_eq!(f.output(2), f.path("Main_3.mp4"), "Main_2.mp4 is the first item's second module");
+    assert!(f.clashes().is_empty());
+}
+
+#[test]
+fn a_name_the_caller_gave_is_never_numbered() {
+    let mut f = Fixture::new("named");
+    f.comp("Main");
+    let out = f.text("final.mp4");
+    f.add(json!({"output": out}));
+    f.add(json!({"output": out}));
+    f.add(json!({"path": out}));
+    assert_eq!(f.outputs(), vec![f.path("final.mp4"); 3]);
+    assert!(f.s.project.render_queue.iter().all(|i| i.output.output == out), "the names stored in the items are the ones given");
+    // Rendering them is what is refused (below): items 2 and 3 each clash with item 1.
+    assert_eq!(f.clashes(), [(2, 1, 1), (3, 1, 1)]);
+}
+
+#[test]
+fn a_pre_render_numbers_its_default_name_too() {
+    let mut f = Fixture::new("pre-render");
+    f.comp("Main");
+    f.s.execute("render.preRender", json!({})).unwrap();
+    f.s.execute("render.preRender", json!({})).unwrap();
+    f.s.execute("render.preRender", json!({"output": f.text("mine.mov")})).unwrap();
+    f.s.execute("render.preRender", json!({"output": f.text("mine.mov")})).unwrap();
+    assert_eq!(f.outputs(), [f.path("Main_prerender.mov"), f.path("Main_prerender_1.mov"), f.path("mine.mov"), f.path("mine.mov")]);
+}
+
+/// File ▸ Create Proxy queues a render with a default name of its own too.
+#[test]
+fn create_proxy_numbers_its_default_name_too() {
+    let mut f = Fixture::new("proxy-names");
+    f.comp("Main");
+    f.s.execute("file.createProxy", json!({"kind": "movie"})).unwrap();
+    f.s.execute("file.createProxy", json!({"kind": "movie"})).unwrap();
+    f.s.execute("file.createProxy", json!({"kind": "movie", "output": f.text("mine.mov")})).unwrap();
+    f.s.execute("file.createProxy", json!({"kind": "movie", "output": f.text("mine.mov")})).unwrap();
+    assert_eq!(f.outputs(), [f.path("Main_proxy.mov"), f.path("Main_proxy_1.mov"), f.path("mine.mov"), f.path("mine.mov")]);
+}
+
+/// Save Frame As ▸ File… with `queue`: every file of a sequence has its frame number in its name,
+/// so two frames of one composition share no file, and the same frame twice does.
+#[test]
+fn queued_frames_number_their_default_names_only_when_they_are_the_same_frame() {
+    let mut f = Fixture::new("frames");
+    f.comp("Main");
+    for time in [0.0, 0.2, 0.0] {
+        f.s.execute("comp.saveFrameAs", json!({"queue": true, "time": time})).unwrap();
+    }
+    assert_eq!(f.outputs(), [f.path("Main_[#####].png"), f.path("Main_[#####].png"), f.path("Main_1_[#####].png")]);
+    assert!(f.clashes().is_empty());
+    f.render(json!({})).unwrap();
+    for file in ["Main_00000.png", "Main_00002.png", "Main_1_00000.png"] {
+        assert_eq!(f.read(file), RENDERED, "{file}");
+    }
+}
+
+/// The report: two queue items forced to one path (the same Output To) replaced each other's file
+/// inside one job. The render is refused before anything is written, whatever `overwrite` says:
+/// that flag is for files that exist, and this is the render replacing its own output.
+#[test]
+fn two_items_forced_to_one_file_are_reported_and_the_render_is_refused() {
+    let mut f = Fixture::new("one-file");
+    f.comp("Main");
+    let out = f.text("render.mp4");
+    f.add(json!({"output": out}));
+    f.add(json!({"output": out}));
+    let found = f.check();
+    let list = found["duplicates"].as_array().unwrap_or_else(|| panic!("checkOutputs lists no duplicates: {found}"));
+    assert_eq!(list.len(), 1, "{found}");
+    let d = &list[0];
+    let (first, second) = (f.s.project.render_queue[0].id, f.s.project.render_queue[1].id);
+    assert_eq!((d["item"].as_u64(), d["index"].as_u64(), d["comp"].as_str()), (Some(second), Some(2), Some("Main")), "{found}");
+    assert_eq!((d["with"]["item"].as_u64(), d["with"]["index"].as_u64(), d["with"]["comp"].as_str()), (Some(first), Some(1), Some("Main")), "{found}");
+    assert_eq!((d["files"].as_u64(), d["sequence"].as_bool()), (Some(1), Some(false)), "{found}");
+    assert_eq!(Path::new(d["path"].as_str().unwrap_or_default()), f.path("render.mp4"), "{found}");
+    let why = d["reason"].as_str().unwrap_or_default();
+    assert!(why.contains("#1") && why.contains("#2") && why.contains("render.mp4") && why.contains("Output To"), "{found}");
+
+    let queue = f.s.project.render_queue.clone();
+    let e = f.render(json!({})).unwrap_err().to_string();
+    assert!(e.contains("#1") && e.contains("#2") && e.contains("render.mp4") && e.contains("Nothing was rendered"), "{e}");
+    assert!(!f.path("render.mp4").exists());
+    assert!(f.exported().is_empty(), "the exporter was not started");
+    assert_eq!(f.s.project.render_queue, queue, "a refused render changes nothing in the queue");
+
+    // A file that exists as well does not change that: replacing it would not help.
+    f.write("render.mp4", EARLIER);
+    let found = f.check();
+    assert_eq!(found["duplicates"].as_array().map(Vec::len), Some(1), "{found}");
+    let e = f.render(json!({})).unwrap_err().to_string();
+    assert!(e.contains("#2") && e.contains("Nothing was rendered"), "{e}");
+    assert_eq!(f.read("render.mp4"), EARLIER);
+
+    // Another Output To for one of them, and both render.
+    f.s.execute("renderQueue.setOutput", json!({"index": 2, "path": f.text("second.mp4")})).unwrap();
+    assert!(f.clashes().is_empty());
+    f.render(json!({})).unwrap();
+    assert_eq!((f.read("render.mp4"), f.read("second.mp4")), (RENDERED.to_vec(), RENDERED.to_vec()));
+}
+
+/// `renderQueue.duplicate` copies the item as it is, output included: it is reported until one of
+/// the two gets another Output To (or is turned off).
+#[test]
+fn a_duplicated_item_is_a_copy_and_clashes_until_one_of_them_changes() {
+    let mut f = Fixture::new("duplicate");
+    f.comp("Main");
+    f.add(json!({}));
+    f.s.execute("renderQueue.duplicate", json!({"index": 1})).unwrap();
+    assert_eq!(f.outputs(), [f.path("Main.mp4"), f.path("Main.mp4")], "a duplicate is a copy, its output included");
+    assert_eq!(f.clashes(), [(2, 1, 1)]);
+    let e = f.render(json!({})).unwrap_err().to_string();
+    assert!(e.contains("#1") && e.contains("#2") && e.contains("Main.mp4"), "{e}");
+    assert!(f.exported().is_empty());
+    // Turned off, the copy is not part of the job.
+    f.s.execute("renderQueue.setRender", json!({"index": 2, "render": false})).unwrap();
+    assert!(f.clashes().is_empty());
+    f.render(json!({})).unwrap();
+    assert_eq!(f.read("Main.mp4"), RENDERED);
+    assert_eq!(f.exported().len(), 1);
+}
+
+/// Only the items of the job are compared: an earlier job's file is a file that exists, and
+/// replacing it is up to `overwrite`.
+#[test]
+fn an_item_that_is_not_in_the_job_does_not_clash() {
+    let mut f = Fixture::new("not-in-job");
+    f.comp("Main");
+    let out = f.text("render.mp4");
+    f.add(json!({"output": out}));
+    f.add(json!({"output": out}));
+    f.s.execute("renderQueue.setRender", json!({"index": 2, "render": false})).unwrap();
+    f.render(json!({})).unwrap(); // item 1 renders alone
+    f.s.execute("renderQueue.setRender", json!({"index": 2, "render": true})).unwrap();
+    assert!(f.clashes().is_empty(), "item 1 is done and is not in this job");
+    // item 2 now replaces the file item 1 wrote in the earlier job: an ordinary file, left to the exporter
+    f.render(json!({})).unwrap();
+}
+
+#[test]
+fn another_spelling_of_one_file_is_one_file_where_the_volume_ignores_case() {
+    let mut f = Fixture::new("spellings");
+    f.comp("Main");
+    f.write("probe.txt", b"x");
+    if !f.path("PROBE.TXT").exists() {
+        eprintln!("this volume tells the two names apart: skipped");
+        return;
+    }
+    f.add(json!({"output": f.text("Render.mp4")}));
+    f.add(json!({"output": f.text("render.MP4")}));
+    f.add(json!({"output": f.dir.join("sub").join("..").join("RENDER.mp4").to_string_lossy()}));
+    f.add(json!({"output": f.text("other.mp4")}));
+    assert_eq!(f.clashes(), [(2, 1, 1), (3, 1, 1)]);
+}
+
+/// A sequence writes one file per frame: two items of one pattern clash on the frames they share,
+/// and not at all when their frames differ.
+#[test]
+fn sequences_clash_only_on_the_frames_they_both_write() {
+    let mut f = Fixture::new("sequence-halves");
+    f.comp("Main");
+    let pattern = f.text("seq_[#####].png");
+    f.add(span(&pattern, 0.0, 0.2)); // frames 0-1
+    f.add(span(&pattern, 0.2, 0.5)); // frames 2-4
+    assert!(f.clashes().is_empty());
+    f.render(json!({})).unwrap();
+    for n in 0..5 {
+        assert_eq!(f.read(&format!("seq_{n:05}.png")), RENDERED, "frame {n}");
+    }
+
+    let mut f = Fixture::new("sequence-overlap");
+    f.comp("Main");
+    let pattern = f.text("seq_[#####].png");
+    f.add(span(&pattern, 0.0, 0.2));
+    f.add(span(&pattern, 0.2, 0.5));
+    f.add(span(&pattern, 0.3, 0.5)); // frames 3-4 again
+    assert_eq!(f.clashes(), [(3, 2, 2)]);
+    let found = f.check();
+    assert_eq!(found["duplicates"][0]["sequence"], true, "{found}");
+    let e = f.render(json!({"overwrite": true})).unwrap_err().to_string();
+    assert!(e.contains("#2") && e.contains("#3") && e.contains("2 frames") && e.contains("seq_[#####].png"), "{e}");
+    assert!(!f.path("seq_00000.png").exists(), "the frames before the clash were not rendered either");
+    assert!(f.exported().is_empty());
+}
+
+#[test]
+fn differently_padded_sequences_cannot_replace_the_same_frames() {
+    let mut f = Fixture::new("padding-width-clash");
+    f.s.execute("comp.new", json!({"name": "Main", "width": 16, "height": 16, "frameRate": 10, "duration": 2})).unwrap();
+    f.add(span(&f.text("seq_[#].png"), 0.9, 1.2));
+    f.add(span(&f.text("seq_[##].png"), 0.9, 1.2));
+    assert_eq!(f.clashes(), [(2, 1, 2)]);
+    assert!(f.render(json!({})).is_err());
+    assert!(f.exported().is_empty());
+}
+
+/// Skip Existing Files leaves a frame alone when it is there: the item that skips and comes second
+/// writes only what the first did not. The item that skips and comes first is written over.
+#[test]
+fn a_later_item_that_skips_existing_frames_leaves_the_earlier_ones_alone() {
+    let mut f = Fixture::new("skip-later");
+    f.comp("Main");
+    let pattern = f.text("seq_[#####].png");
+    f.add(json!({"format": "png", "output": pattern}));
+    f.add(json!({"format": "png", "output": pattern, "skipExisting": true}));
+    assert!(f.clashes().is_empty());
+    f.render(json!({})).unwrap();
+    assert_eq!(f.read("seq_00004.png"), RENDERED);
+
+    let mut f = Fixture::new("skip-earlier");
+    f.comp("Main");
+    let pattern = f.text("seq_[#####].png");
+    f.add(json!({"format": "png", "output": pattern, "skipExisting": true}));
+    f.add(json!({"format": "png", "output": pattern}));
+    assert_eq!(f.clashes(), [(2, 1, 5)]);
+}
+
+#[test]
+fn two_output_modules_of_one_item_cannot_share_a_file() {
+    let mut f = Fixture::new("two-modules");
+    f.comp("Main");
+    let out = f.text("render.mp4");
+    f.add(json!({"output": out}));
+    f.s.execute("render.addOutputModule", json!({"output": out})).unwrap();
+    assert_eq!(f.clashes(), [(1, 1, 1)]);
+    let e = f.render(json!({})).unwrap_err().to_string();
+    assert!(e.contains("#1") && e.contains("twice"), "{e}");
+    assert!(f.exported().is_empty());
+}
+
+/// Settings ▸ Export ▸ Segment Sequences puts each item's frames in numbered folders: default
+/// names keep two items' folders apart, and items given one name clash segment by segment.
+#[test]
+fn segmented_sequences_clash_segment_by_segment() {
+    let mut f = Fixture::new("segments");
+    f.comp("Main");
+    f.s.prefs.export.segment_sequences = true;
+    f.s.prefs.export.segment_sequence_files = 2; // five frames: segments of 2, 2 and 1
+    f.add(json!({"format": "png"}));
+    f.add(json!({"format": "png"}));
+    assert_eq!(f.output(1), f.path("Main_1_[#####].png"));
+    assert!(f.clashes().is_empty());
+    f.render(json!({})).unwrap();
+    assert_eq!(f.read("Main_001/Main_00000.png"), RENDERED);
+    assert_eq!(f.read("Main_1_003/Main_1_00004.png"), RENDERED);
+
+    let mut f = Fixture::new("segments-named");
+    f.comp("Main");
+    f.s.prefs.export.segment_sequences = true;
+    f.s.prefs.export.segment_sequence_files = 2;
+    let pattern = f.text("seg_[#####].png");
+    f.add(json!({"format": "png", "output": pattern}));
+    f.add(json!({"format": "png", "output": pattern}));
+    assert_eq!(f.clashes(), [(2, 1, 2), (2, 1, 2), (2, 1, 1)]);
+    let e = f.render(json!({})).unwrap_err().to_string();
+    assert!(e.contains("2 more"), "the first clash is named, the rest counted: {e}");
+    assert!(f.exported().is_empty());
+}
+
+/// An item that is refused for the file it would replace does not write anything, so it cannot
+/// clash with another item.
+#[test]
+fn items_refused_for_footage_are_not_compared_with_each_other() {
+    let mut f = Fixture::new("refused-pair");
+    f.footage("clip.mov");
+    f.comp("Main");
+    let clip = f.text("clip.mov");
+    f.add(json!({"format": "prores", "output": clip}));
+    f.add(json!({"format": "prores", "output": clip}));
+    f.add(json!({"output": f.text("ok.mp4")}));
+    let found = f.check();
+    assert_eq!(found["duplicates"].as_array().map(Vec::len), Some(0), "{found}");
+    let r = f.render(json!({})).unwrap();
+    let failed = r["items"].as_array().unwrap().iter().filter(|i| i["status"].get("Failed").is_some()).count();
+    assert_eq!(failed, 2, "both items on the footage are refused: {r}");
+    assert_eq!(f.read("clip.mov"), SOURCE);
+    assert_eq!(f.read("ok.mp4"), RENDERED);
+}
diff --git a/crates/engine/src/tests_replace_source.rs b/crates/engine/src/tests/replace_source.rs
similarity index 100%
rename from crates/engine/src/tests_replace_source.rs
rename to crates/engine/src/tests/replace_source.rs
diff --git a/crates/engine/src/tests_rig3d.rs b/crates/engine/src/tests/rig3d.rs
similarity index 55%
rename from crates/engine/src/tests_rig3d.rs
rename to crates/engine/src/tests/rig3d.rs
index d3b965107..cf2518447 100644
--- a/crates/engine/src/tests_rig3d.rs
+++ b/crates/engine/src/tests/rig3d.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use effectcraft_geom::{Vec3, vec3};
 use effectcraft_keyframe::Value as KV;
 use effectcraft_project::{Footage, FootageKind, GroupKind, ItemId, Layer, LayerId, LayerSource, LightKind, Project};
-use effectcraft_render::three_d::camera::layer_frame;
+use effectcraft_render::three_d::camera::{is_two_node, layer_frame};
 use effectcraft_render::{EvalCtx, FootageSource, RenderOpts};
 use effectcraft_time::{FrameRate, Tick};
 use serde_json::{Value, json};
@@ -40,7 +40,7 @@ fn close3(a: [f64; 3], b: [f64; 3], tol: f64) -> bool {
 fn frame(s: &Session, id: u64) -> (Vec3, Vec3) {
     let c = cid(s);
     let comp = s.project.comp(c).unwrap();
-    let ctx = EvalCtx { project: &s.project, comp_id: c, comp, time: Tick::ZERO, expr: None, footage: None };
+    let ctx = EvalCtx { project: &s.project, comp_id: c, comp, time: Tick::ZERO, expr: None, footage: None, property_overrides: &[], media_overrides: &[] };
     let (e, f, _) = layer_frame(&ctx, comp.layer(LayerId(id)).unwrap());
     (e, f)
 }
@@ -49,6 +49,50 @@ fn camera(s: &mut Session) -> u64 {
     s.execute("layer.newCamera", json!({"name": "Cam", "position": [320, 180, -800], "poi": [320, 180, 0], "zoom": 900})).unwrap()["layer"].as_u64().unwrap()
 }
 
+/// Controls on a hidden null in the source comp.
+fn assert_stereo_controls(ctl: &Layer) {
+    assert_eq!(ctl.name, "Stereo 3D Controls");
+    assert!(!ctl.switches.video);
+    let fx = ctl.effects().unwrap().groups().next().unwrap().clone();
+    assert!(matches!(&fx.kind, GroupKind::Effect { effect } if effect == effectcraft_effects::controls::STEREO_CONTROLS));
+    assert_eq!(fx.get("sceneDepth").unwrap().value, KV::Scalar(4.0));
+}
+
+/// An eye comp: an eye camera (two-node, linked by expressions) at `x` and the collapsed source comp.
+fn assert_eye_comp(s: &Session, src: ItemId, ec: ItemId, name: &str, x: f64) {
+    assert_eq!(s.project.item(ec).unwrap().name, name);
+    let c = s.project.comp(ec).unwrap();
+    assert_eq!((c.width, c.height), (640, 360));
+    assert_eq!(c.layers.len(), 2);
+    let cam = &c.layers[0];
+    assert!(cam.is_camera() && effectcraft_render::three_d::camera::is_two_node(cam));
+    assert!(close3(v3(cam, "transform/position"), [x, 180.0, -800.0], 1e-6), "{:?}", v3(cam, "transform/position"));
+    // Parallel eyes (no convergence): each looks straight ahead.
+    assert!(close3(v3(cam, "transform/poi"), [x, 180.0, 0.0], 1e-6), "{:?}", v3(cam, "transform/poi"));
+    assert_eq!(cam.props.prop("cameraOptions/zoom").unwrap().value, KV::Scalar(900.0));
+    for p in ["transform/position", "transform/poi", "cameraOptions/zoom"] {
+        let e = cam.props.prop(p).unwrap().expr.clone().unwrap();
+        assert!(e.text.contains("comp(\"Scene\")") && e.text.contains("Cam"), "{p}: {}", e.text);
+    }
+    let nest = &c.layers[1];
+    assert_eq!(nest.source, LayerSource::Comp { item: src });
+    assert!(nest.switches.collapse && nest.switches.three_d);
+}
+
+/// The stereo comp: left eye on top with 3D Glasses fed by both eyes; right eye hidden.
+fn assert_stereo_comp(s: &Session, r: &serde_json::Value) {
+    let oc = ItemId(r["stereoComp"].as_u64().unwrap());
+    let out = s.project.comp(oc).unwrap();
+    assert_eq!(s.project.item(oc).unwrap().name, "Scene Stereo 3D");
+    let (l, rr) = (r["leftLayer"].as_u64().unwrap(), r["rightLayer"].as_u64().unwrap());
+    assert_eq!(out.layers[0].id.0, l);
+    assert!(!out.layers[1].switches.video);
+    let g = out.layers[0].effects().unwrap().groups().next().unwrap().clone();
+    assert!(matches!(&g.kind, GroupKind::Effect { effect } if effect == "ec.perspective.3dglasses"));
+    assert_eq!(g.get("leftView").unwrap().value, KV::Layer(Some(l)));
+    assert_eq!(g.get("rightView").unwrap().value, KV::Layer(Some(rr)));
+}
+
 #[test]
 fn stereo_rig_builds_eye_comps_and_glasses() {
     let mut s = session();
@@ -58,46 +102,12 @@ fn stereo_rig_builds_eye_comps_and_glasses() {
     let r = s.execute("camera.stereoRig", json!({"sceneDepth": 4})).unwrap();
     assert_eq!(s.project.items.len(), items_before + 3, "left, right and stereo comps");
     assert_eq!(r["master"].as_u64(), Some(cam));
-    // Controls on a hidden null in the source comp.
-    let ctl = layer_in(&s, src, r["controls"].as_u64().unwrap());
-    assert_eq!(ctl.name, "Stereo 3D Controls");
-    assert!(!ctl.switches.video);
-    let fx = ctl.effects().unwrap().groups().next().unwrap().clone();
-    assert!(matches!(&fx.kind, GroupKind::Effect { effect } if effect == effectcraft_effects::controls::STEREO_CONTROLS));
-    assert_eq!(fx.get("sceneDepth").unwrap().value, KV::Scalar(4.0));
-    // Eye comps: an eye camera (two-node, linked by expressions) and the collapsed source comp.
+    assert_stereo_controls(&layer_in(&s, src, r["controls"].as_u64().unwrap()));
     let d = 0.04 * 640.0;
     for (key, name, x) in [("leftComp", "Scene Left Eye", 320.0 - d / 2.0), ("rightComp", "Scene Right Eye", 320.0 + d / 2.0)] {
-        let ec = ItemId(r[key].as_u64().unwrap());
-        assert_eq!(s.project.item(ec).unwrap().name, name);
-        let c = s.project.comp(ec).unwrap();
-        assert_eq!((c.width, c.height), (640, 360));
-        assert_eq!(c.layers.len(), 2);
-        let cam = &c.layers[0];
-        assert!(cam.is_camera() && effectcraft_render::three_d::camera::is_two_node(cam));
-        assert!(close3(v3(cam, "transform/position"), [x, 180.0, -800.0], 1e-6), "{:?}", v3(cam, "transform/position"));
-        // Parallel eyes (no convergence): each looks straight ahead.
-        assert!(close3(v3(cam, "transform/poi"), [x, 180.0, 0.0], 1e-6), "{:?}", v3(cam, "transform/poi"));
-        assert_eq!(cam.props.prop("cameraOptions/zoom").unwrap().value, KV::Scalar(900.0));
-        for p in ["transform/position", "transform/poi", "cameraOptions/zoom"] {
-            let e = cam.props.prop(p).unwrap().expr.clone().unwrap();
-            assert!(e.text.contains("comp(\"Scene\")") && e.text.contains("Cam"), "{p}: {}", e.text);
-        }
-        let nest = &c.layers[1];
-        assert_eq!(nest.source, LayerSource::Comp { item: src });
-        assert!(nest.switches.collapse && nest.switches.three_d);
+        assert_eye_comp(&s, src, ItemId(r[key].as_u64().unwrap()), name, x);
     }
-    // The stereo comp: left eye on top with 3D Glasses fed by both eyes; right eye hidden.
-    let oc = ItemId(r["stereoComp"].as_u64().unwrap());
-    let out = s.project.comp(oc).unwrap();
-    assert_eq!(s.project.item(oc).unwrap().name, "Scene Stereo 3D");
-    let (l, rr) = (r["leftLayer"].as_u64().unwrap(), r["rightLayer"].as_u64().unwrap());
-    assert_eq!(out.layers[0].id.0, l);
-    assert!(!out.layers[1].switches.video);
-    let g = out.layers[0].effects().unwrap().groups().next().unwrap().clone();
-    assert!(matches!(&g.kind, GroupKind::Effect { effect } if effect == "ec.perspective.3dglasses"));
-    assert_eq!(g.get("leftView").unwrap().value, KV::Layer(Some(l)));
-    assert_eq!(g.get("rightView").unwrap().value, KV::Layer(Some(rr)));
+    assert_stereo_comp(&s, &r);
     // One undo step; redo; serde.
     let json = serde_json::to_string(&*s.project).unwrap();
     let back: Project = serde_json::from_str(&json).unwrap();
@@ -207,8 +217,189 @@ fn control_light_with_camera_follows_and_releases() {
     assert!(s.execute("light.controlWithCamera", json!({"layers": [cam]})).is_err());
 }
 
+/// Parenting keeps a camera where it is (After Effects' Parent & Link): Position and Point of
+/// Interest are re-expressed in the null's space, so the frame does not move.
+#[test]
+fn parented_camera_keeps_its_frame_under_an_offset_null() {
+    let mut s = session();
+    let cam = camera(&mut s);
+    let (eye0, f0) = frame(&s, cam);
+    let nul = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/position", "value": [100, 60, 0]})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [cam], "parent": nul})).unwrap();
+    let (eye1, f1) = frame(&s, cam);
+    assert!((eye1 - eye0).length() < 1e-6 && (f1 - f0).length() < 1e-6, "{eye0:?} {eye1:?}");
+    // The null's origin is Position minus its default anchor (50, 50): (50, 10) in the comp.
+    let c = layer_in(&s, cid(&s), cam);
+    assert!(close3(v3(&c, "transform/position"), [270.0, 170.0, -800.0], 1e-6), "{:?}", v3(&c, "transform/position"));
+    assert!(close3(v3(&c, "transform/poi"), [270.0, 170.0, 0.0], 1e-6), "{:?}", v3(&c, "transform/poi"));
+    // Moving the null carries the camera and keeps its aim.
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/position", "value": [140, 90, 0]})).unwrap();
+    let (eye2, f2) = frame(&s, cam);
+    assert!((eye2 - (eye0 + vec3(40.0, 30.0, 0.0))).length() < 1e-6, "{eye2:?}");
+    assert!((f2 - f0).length() < 1e-6, "{f2:?}");
+}
+
+/// World (eye, forward, down) of a layer in the active comp at time `t`.
+fn frame_at(s: &Session, id: u64, t: Tick) -> (Vec3, Vec3, Vec3) {
+    let c = cid(s);
+    let comp = s.project.comp(c).unwrap();
+    let ctx = EvalCtx { project: &s.project, comp_id: c, comp, time: t, expr: None, footage: None, property_overrides: &[], media_overrides: &[] };
+    layer_frame(&ctx, comp.layer(LayerId(id)).unwrap())
+}
+
+/// Whether two frames agree on eye, forward and down.
+fn frames_match(a: (Vec3, Vec3, Vec3), b: (Vec3, Vec3, Vec3)) -> bool {
+    (a.0 - b.0).length() < 1e-6 && (a.1 - b.1).length() < 1e-6 && (a.2 - b.2).length() < 1e-6
+}
+
+/// A 3D null off-centre in the comp, with an Orientation and a Z rotation.
+fn rotated_null(s: &mut Session, orientation: [f64; 3], turn: f64) -> u64 {
+    let nul = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [nul], "switch": "threeD", "value": true})).unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/position", "value": [100, 60, 40]})).unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/orientation", "value": orientation})).unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/rotation", "value": turn})).unwrap();
+    nul
+}
+
+/// A two-node camera under a rotated null keeps its eye, aim and roll: its Orientation is
+/// re-expressed against the new aim, so Up does not drift.
+#[test]
+fn two_node_camera_under_rotated_null_keeps_its_roll() {
+    let mut s = session();
+    let cam = camera(&mut s);
+    s.execute("prop.set", json!({"layer": cam, "path": "transform/rotation", "value": 25})).unwrap();
+    assert!(is_two_node(&layer_in(&s, cid(&s), cam)));
+    let before = frame_at(&s, cam, Tick::ZERO);
+    let nul = rotated_null(&mut s, [20.0, -35.0, 60.0], 30.0);
+    s.execute("layer.setParent", json!({"layers": [cam], "parent": nul})).unwrap();
+    let after = frame_at(&s, cam, Tick::ZERO);
+    assert!(frames_match(before, after), "{before:?} {after:?}");
+}
+
+#[test]
+fn parented_point_light_keeps_its_direction_under_a_rotated_null() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": light, "path": "transform/orientation", "value": [30, 0, 0]})).unwrap();
+    let (eye0, f0) = frame(&s, light);
+    let nul = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/position", "value": [100, 60, 0]})).unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/rotation", "value": 30})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+    let (eye1, f1) = frame(&s, light);
+    assert!((eye1 - eye0).length() < 1e-6 && (f1 - f0).length() < 1e-6, "{eye0:?} {eye1:?} {f0:?} {f1:?}");
+}
+
+/// Keyed Orientation under a Z-only turn is shifted exactly, so the light keeps its direction at
+/// every time, between the keys too.
+#[test]
+fn keyed_orientation_under_a_z_turn_keeps_the_direction_at_every_time() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.0, json!([5.0, 18.0, 14.0]))] {
+        s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": time, "value": value})).unwrap();
+    }
+    let times = [0.0, 0.25, 0.5, 0.75, 1.0].map(Tick::from_seconds_f64);
+    let before = times.map(|t| frame_at(&s, light, t));
+    let nul = rotated_null(&mut s, [0.0, 0.0, 0.0], 30.0);
+    s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+    for (t, b) in times.into_iter().zip(before) {
+        assert!(frames_match(b, frame_at(&s, light, t)), "a Z-only turn keeps the light's direction");
+    }
+}
+
+/// Under a tilted null the keys alone cannot follow (Euler angles are blended between them), so keys are
+/// added between them: the light keeps its direction within a small angle at every time.
+#[test]
+fn keyed_orientation_under_a_tilted_null_follows_between_the_keys() {
+    {
+        let mut s = session();
+        let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+        for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.5, json!([50.0, 118.0, 74.0]))] {
+            s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": time, "value": value})).unwrap();
+        }
+        let times = [0.0, 0.2, 0.5, 0.9, 1.3, 1.5].map(Tick::from_seconds_f64);
+        let before = times.map(|t| frame_at(&s, light, t));
+        let nul = rotated_null(&mut s, [20.0, -35.0, 60.0], 30.0);
+        s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+        for (t, b) in times.into_iter().zip(before) {
+            let a = frame_at(&s, light, t);
+            // 0.05 degrees is about 9e-4 of a radian on a unit vector.
+            assert!((a.0 - b.0).length() < 1e-6 && (a.1 - b.1).length() < 2e-3, "at {t:?}: {:?} vs {:?}", a.1, b.1);
+        }
+        assert!(layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().keys.len() > 2, "keys were added between the two");
+    }
+}
+
+/// A one-node light parented under a mirrored null (Z scale -100%) keeps the Position and
+/// Orientation it was authored with: it has no Scale to carry the mirror, so none of it is
+/// compensated rather than reversing its frame (a half-compensated light would point backwards).
+#[test]
+fn one_node_light_under_a_mirrored_null_keeps_its_authored_values() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": light, "path": "transform/orientation", "value": [30, 0, 0]})).unwrap();
+    let before = layer_in(&s, cid(&s), light);
+    let nul = rotated_null(&mut s, [0.0, 0.0, 0.0], 0.0);
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/scale", "value": [100, 100, -100]})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+    let after = layer_in(&s, cid(&s), light);
+    assert_eq!(after.parent, Some(LayerId(nul)));
+    assert_eq!(v3(&after, "transform/position"), v3(&before, "transform/position"));
+    assert_eq!(v3(&after, "transform/orientation"), v3(&before, "transform/orientation"));
+}
+
+/// The cap on keys added by baking is for the whole Orientation property, not for each segment:
+/// many strongly eased segments under a tilted parent stay within it.
+#[test]
+fn baked_orientation_keys_are_capped_across_the_whole_property() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    let count = 120;
+    for i in 0..count {
+        let swing = if i % 2 == 0 { json!([0.0, 0.0, 0.0]) } else { json!([170.0, 60.0, 120.0]) };
+        s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": i as f64 * 0.05, "value": swing})).unwrap();
+    }
+    let uid = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().uid;
+    let keys: Vec<_> = (0..count).map(|i| json!({"layer": light, "prop": uid, "time": i as f64 * 0.05})).collect();
+    s.execute("keys.select", json!({"keys": keys})).unwrap();
+    s.execute("keys.easyEase", json!({})).unwrap();
+    let nul = rotated_null(&mut s, [20.0, -35.0, 60.0], 30.0);
+    s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+    let n = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().keys.len();
+    assert!(n <= 4096, "{n} keys: the cap is for the property, not per segment");
+    // the segments the cap left unchecked keep their authored easing instead of turning into straight blends
+    let orientation = layer_in(&s, cid(&s), light);
+    let keys = &orientation.props.prop("transform/orientation").unwrap().keys;
+    let last = keys.iter().rev().nth(1).expect("the penultimate key");
+    assert_ne!(last.out_interp, effectcraft_keyframe::Interp::Linear, "the last segment keeps its authored easing");
+}
+
 // ---------------------------------------------------------------- from 3D model
 
+/// Easy Ease agrees with a straight blend at the midpoint, but not at the quarter points.
+#[test]
+fn eased_orientation_under_x_parent_keeps_motion_between_keys() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    for (time, value) in [(0.0, json!([0.0, 0.0, 0.0])), (1.0, json!([90.0, 0.0, 0.0]))] {
+        s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": time, "value": value})).unwrap();
+    }
+    let uid = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().uid;
+    s.execute("keys.select", json!({"keys": [{"layer": light, "prop": uid, "time": 0.0}, {"layer": light, "prop": uid, "time": 1.0}]})).unwrap();
+    s.execute("keys.easyEase", json!({})).unwrap();
+    let times: Vec<_> = (0..=100).map(|i| Tick::from_seconds_f64(i as f64 / 100.0)).collect();
+    let before: Vec<_> = times.iter().map(|t| frame_at(&s, light, *t)).collect();
+    let parent = rotated_null(&mut s, [30.0, 0.0, 0.0], 0.0);
+    s.execute("layer.setParent", json!({"layers": [light], "parent": parent})).unwrap();
+    for (t, b) in times.into_iter().zip(before) {
+        let a = frame_at(&s, light, t);
+        assert!((a.0 - b.0).length() < 1e-6 && (a.1 - b.1).length() < 1e-3, "at {t:?}: {:?} vs {:?}", a.1, b.1);
+    }
+}
+
 struct DiskModels;
 
 impl FootageSource for DiskModels {
diff --git a/crates/engine/src/tests_roto.rs b/crates/engine/src/tests/roto.rs
similarity index 52%
rename from crates/engine/src/tests_roto.rs
rename to crates/engine/src/tests/roto.rs
index 33500b4ec..99c155265 100644
--- a/crates/engine/src/tests_roto.rs
+++ b/crates/engine/src/tests/roto.rs
@@ -8,7 +8,7 @@ use effectcraft_track::roto::rle;
 use serde_json::{Value, json};
 
 use crate::Session;
-use crate::tests_track::{H, W, frame_time, setup};
+use crate::tests::track::{H, W, frame_time, setup};
 
 /// Keep cache/model mutation tests from clearing segmentations under another fixture.
 /// Libtest runs each test on its own thread; the guard lives until that thread exits.
@@ -164,6 +164,33 @@ fn alpha_at(s: &Session, f: u32) -> Vec<f32> {
     img.data.iter().map(|p| p[3]).collect()
 }
 
+/// Green, then Alt (red) over part of the object, then green there again: the last stroke wins,
+/// in the render and through Undo / Redo (#1646).
+#[test]
+fn roto_brush_strokes_correct_earlier_ones() {
+    let (mut s, clip, _) = painted(center, "disk-1646.mov");
+    let c = center(0);
+    let spot = [c[0], c[1] + 25.0];
+    let i = spot[1] as usize * W as usize + spot[0] as usize;
+    let paint = |s: &mut Session, kind: &str| {
+        s.execute_checked(
+            "roto.stroke",
+            json!({"layer": clip.0, "kind": kind, "points": line([spot[0] - 6.0, spot[1]], [spot[0] + 6.0, spot[1]]), "radius": 7}),
+        )
+        .unwrap();
+    };
+    assert!(alpha_at(&s, 0)[i] > 0.5, "the spot starts inside the matte");
+    paint(&mut s, "bg");
+    assert!(alpha_at(&s, 0)[i] < 0.5, "Alt removes it");
+    paint(&mut s, "fg");
+    assert!(alpha_at(&s, 0)[i] > 0.5, "green over the Alt stroke restores it");
+    assert!(iou_at(&mut s, clip, 0, c) > 0.95);
+    assert!(s.undo());
+    assert!(alpha_at(&s, 0)[i] < 0.5, "undo brings the removal back");
+    assert!(s.redo());
+    assert!(alpha_at(&s, 0)[i] > 0.5, "redo restores it again");
+}
+
 #[test]
 fn roto_brush_segments_and_propagates() {
     let (mut s, clip, uid) = painted(center, "disk-a.mov");
@@ -641,3 +668,494 @@ fn object_matte_mattes_persist_in_the_disk_cache() {
     assert!(om::ensure(&moved, size, 25.0, 0, None, &mut |_| None, &|| false).is_none());
     let _ = std::fs::remove_dir_all(&dir);
 }
+
+/// SAM 2 tracks the clip end to end (needs the real weights: `EFFECTCRAFT_SAM2=path/to/model.safetensors`).
+/// Every frame comes from the tracker with a confidence, the mattes are right, and nothing changes
+/// once the model is deselected.
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn sam2_tracks_the_clip_through_roto_propagate() {
+    let Ok(weights) = std::env::var("EFFECTCRAFT_SAM2") else { return };
+    let dir = std::env::temp_dir().join(format!("ec-roto-sam2-{}", std::process::id()));
+    hold_roto_cache_test_lock();
+    let (mut s, clip, _) = painted(center, "disk-sam2.mov");
+    s.models_dir = Some(dir.join("models"));
+    std::fs::create_dir_all(dir.join("models")).unwrap();
+    s.execute_checked("roto.model.install", json!({"path": weights})).unwrap();
+    s.execute_checked("roto.model.select", json!({"id": "sam2.1-hiera-tiny", "wait": true})).unwrap();
+    assert_eq!(s.models.status(effectcraft_segment::Task::Mask).active.as_deref(), Some("sam2.1-hiera-tiny"));
+    let r = s.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "both", "wait": true})).unwrap();
+    assert_eq!(r["frames"], 21, "{r}");
+    let mut worst: f64 = 1.0;
+    for f in 0..=20 {
+        let j = iou_at(&mut s, clip, f, center(f));
+        let st = s.execute("roto.status", json!({"layer": clip.0, "frame": f})).unwrap();
+        eprintln!("frame {f}: IoU {j:.3}, {:?}", st["tracker"]["frames"][f.to_string()]);
+        worst = worst.min(j);
+    }
+    assert!(worst > 0.9, "worst IoU over the span with SAM 2: {worst}");
+    let st = s.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(st["source"], "tracker", "{st}");
+    let frames = st["tracker"]["frames"].as_object().unwrap();
+    assert_eq!(frames.len(), 21);
+    assert!(frames.values().all(|t| t["occluded"] == false && t["confidence"].as_f64().unwrap() > 0.3), "{frames:?}");
+    assert_eq!(st["tracker"]["model"], "sam2.1-hiera-tiny");
+    // Settings choose the classic engine: the saved tracking stays until a Propagate replaces it.
+    s.execute_checked("roto.model.select", json!({"id": "classical", "wait": true})).unwrap();
+    let st = s.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(st["source"], "tracker", "{st}");
+    assert!(st["notice"].as_str().unwrap().contains("Propagate again"), "{st}");
+    assert_eq!(st["computed"].as_array().unwrap().len(), 21, "still computed under another model: {st}");
+    // A classic Propagate: its own segmentation, no tracker data.
+    s.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "both", "wait": true})).unwrap();
+    let st = s.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(st["source"], "classical", "{st}");
+    assert_eq!(st["tracker"]["frames"].as_object().unwrap().len(), 0);
+    let _ = std::fs::remove_dir_all(dir);
+}
+
+/// Choosing a model that is not installed must not fall back to the classic engine silently:
+/// propagate refuses and `roto.status` says why. Choosing the classic engine runs it again.
+#[test]
+fn a_selected_model_that_is_not_installed_refuses_to_propagate() {
+    hold_roto_cache_test_lock();
+    let (mut s, clip, _) = painted(center, "disk-not-installed.mov");
+    s.models_dir = Some(std::env::temp_dir().join(format!("ec-roto-none-{}", std::process::id())));
+    s.execute_checked("roto.model.select", json!({"id": "sam2.1-hiera-tiny"})).unwrap();
+    let st = s.execute("roto.status", json!({"layer": clip.0})).unwrap();
+    assert_eq!(st["model"]["selected"], "sam2.1-hiera-tiny", "{st}");
+    assert_eq!(st["model"]["installed"], false, "{st}");
+    assert!(st["notice"].as_str().unwrap().contains("not installed"), "{st}");
+    let e = s.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "both", "wait": true})).unwrap_err().to_string();
+    assert!(e.contains("not installed"), "{e}");
+    assert_eq!(s.execute("roto.status", json!({"layer": clip.0, "frame": 10})).unwrap()["source"], "classical");
+    s.execute_checked("roto.model.select", json!({"id": "classical"})).unwrap();
+    let r = s.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "both", "wait": true})).unwrap();
+    assert_eq!(r["frames"], 21, "{r}");
+    assert!(s.execute("roto.status", json!({"layer": clip.0})).unwrap()["notice"].is_null());
+}
+
+/// Selecting SAM 2 without `wait` and propagating at once: propagate loads the model first, so the
+/// tracker (not the classic engine) does the work. Needs EFFECTCRAFT_SAM2 like the test above.
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn sam2_selected_without_wait_is_loaded_before_propagate() {
+    let Ok(weights) = std::env::var("EFFECTCRAFT_SAM2") else { return };
+    hold_roto_cache_test_lock();
+    let dir = std::env::temp_dir().join(format!("ec-roto-sam2-wait-{}", std::process::id()));
+    let (mut s, clip, _) = painted(center, "disk-sam2-wait.mov");
+    s.models_dir = Some(dir.join("models"));
+    std::fs::create_dir_all(dir.join("models")).unwrap();
+    s.execute_checked("roto.model.install", json!({"path": weights})).unwrap();
+    s.execute_checked("roto.model.select", json!({"id": "sam2.1-hiera-tiny"})).unwrap();
+    let r = s.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "both", "wait": true})).unwrap();
+    assert_eq!(r["frames"], 21, "{r}");
+    let st = s.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(st["source"], "tracker", "{st}");
+    assert_eq!(st["tracker"]["model"], "sam2.1-hiera-tiny");
+    assert!(st["notice"].is_null(), "{st}");
+    let _ = std::fs::remove_dir_all(dir);
+}
+
+/// A tracker that follows the disc exactly: its true mask on every frame of the request. A stand-in
+/// for SAM 2, so the saved tracking can be tested without the weights.
+struct Exact;
+
+impl effectcraft_segment::MaskModel for Exact {
+    fn info(&self) -> &'static effectcraft_segment::ModelInfo {
+        &effectcraft_segment::SAM2_TINY
+    }
+    fn segment(&self, _: &[[f32; 3]], _: usize, _: usize, _: &effectcraft_segment::Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+        Err("no weights".into())
+    }
+    fn tracker(&self) -> Option<&dyn effectcraft_segment::ObjectTracker> {
+        Some(self)
+    }
+}
+
+impl effectcraft_segment::ObjectTracker for Exact {
+    fn track(
+        &self,
+        req: &effectcraft_segment::TrackRequest,
+        frame: &mut dyn FnMut(i64) -> Option<std::sync::Arc<effectcraft_segment::ClipFrame>>,
+        _: &dyn Fn() -> bool,
+        out: &mut dyn FnMut(usize, i64, effectcraft_segment::TrackedFrame),
+    ) -> effectcraft_segment::Result<()> {
+        for g in req.first..req.first + req.count as i64 {
+            let Some(img) = frame(g) else { return Err(format!("no frame {g}")) };
+            let c = center(g as u32);
+            let prob = (0..img.w * img.h)
+                .map(|i| ((((i % img.w) as f64 + 0.5 - c[0]).hypot((i / img.w) as f64 + 0.5 - c[1])) <= R) as u8 as f32)
+                .collect::<Vec<f32>>();
+            out(0, g, effectcraft_segment::TrackedFrame { prob, w: img.w, h: img.h, confidence: 0.99, occluded: false });
+        }
+        Ok(())
+    }
+}
+
+/// Saved tracking is part of the project: written with the instance, it applies when the project
+/// opens, with or without the model loaded, and Settings choosing the classic engine leaves it in place
+/// until a Propagate replaces it.
+#[test]
+fn saved_tracking_is_kept_in_the_project_and_applies_when_it_reopens() {
+    let sam2 = "sam2.1-hiera-tiny";
+    let (s, clip, uid, path) = saved_project("saved");
+    // Reopened with SAM 2 chosen but not loaded (none is installed here): the saved frames apply.
+    forget(&s, clip, uid);
+    let mut s2 = Session::default();
+    s2.execute_checked("file.open", json!({"path": path})).unwrap();
+    s2.execute_checked("roto.model.select", json!({"id": sam2})).unwrap();
+    let st = s2.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(st["source"], "tracker", "{st}");
+    assert_eq!(st["tracker"]["saved"], sam2, "{st}");
+    assert_eq!(st["tracker"]["frames"].as_object().unwrap().len(), 21, "{st}");
+    // The span bar's "computed" frames include the saved ones before anything has been decoded.
+    assert_eq!(st["computed"].as_array().unwrap().len(), 21, "{st}");
+    let j = iou_at(&mut s2, clip, 12, center(12));
+    assert!(j > 0.9, "IoU of a saved frame: {j}");
+    // The render path (Chain::ensure) reads the same frame.
+    let comp = s2.active_comp().unwrap();
+    let l = comp.layer(clip).unwrap();
+    let g = l.props.find_group(uid).unwrap();
+    let size = crate::roto::layer_size(&s2.project, comp, l);
+    let ch = effectcraft_effects::roto::Chain::new(&crate::roto::params_static(g), size, comp.frame_rate.as_f64(), 1.0);
+    let seg = ch.ensure(12, &mut |_| None, &|| false).expect("the render path reads the saved frame");
+    let truth = rle::decode(&gt(center(12))).unwrap();
+    let inter = seg.matte.iter().zip(&truth).filter(|(a, b)| **a != 0 && **b != 0).count();
+    let uni = seg.matte.iter().zip(&truth).filter(|(a, b)| **a != 0 || **b != 0).count();
+    assert!(inter as f64 / uni as f64 > 0.9, "the render path's frame: IoU {}", inter as f64 / uni as f64);
+    // Settings choose the classic engine: the saved frames still apply, and the notice says so.
+    s2.execute_checked("roto.model.select", json!({"id": "classical"})).unwrap();
+    let st = s2.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(st["source"], "tracker", "{st}");
+    assert!(st["notice"].as_str().unwrap().contains("Propagate again"), "{st}");
+    // A classic Propagate replaces the saved tracking with nothing.
+    // The synthetic source is not a file on disk; give the reopened session its provider before
+    // asking it to recompute frames. The checks above intentionally rendered without that provider.
+    s2.footage = s.footage.clone();
+    s2.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "both", "wait": true})).unwrap();
+    let st = s2.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(st["source"], "classical", "{st}");
+    assert!(st["tracker"]["saved"].is_null() && st["notice"].is_null(), "{st}");
+    let _ = std::fs::remove_dir_all(std::path::Path::new(&path).parent().unwrap());
+}
+
+/// A reopened project propagated again with the same model and nothing new to track keeps the tracking it has: the
+/// saved frames are not replaced by an empty one, so a later reopen still finds them.
+#[test]
+fn propagating_with_nothing_new_keeps_the_saved_tracking() {
+    let (s, clip, uid, path) = saved_project("keep-saved");
+    forget(&s, clip, uid);
+    let mut s2 = Session::default();
+    s2.execute_checked("file.open", json!({"path": path})).unwrap();
+    s2.footage = s.footage.clone();
+    effectcraft_effects::roto::set_model(Some(std::sync::Arc::new(Exact)));
+    let result = s2.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "both", "wait": true}));
+    effectcraft_effects::roto::set_model(None);
+    result.unwrap();
+    let st = s2.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(st["tracker"]["saved"], "sam2.1-hiera-tiny", "{st}");
+    assert_eq!(st["tracker"]["frames"].as_object().unwrap().len(), 21, "{st}");
+    // and it is still in the file after saving and reopening
+    s2.execute_checked("file.save", json!({})).unwrap();
+    let mut s3 = Session::default();
+    s3.execute_checked("file.open", json!({"path": path})).unwrap();
+    let st = s3.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(st["tracker"]["frames"].as_object().unwrap().len(), 21, "{st}");
+    let _ = std::fs::remove_dir_all(std::path::Path::new(&path).parent().unwrap());
+}
+
+/// Freeze reads saved tracking without its model: choosing a model that is not installed does not stop it when
+/// the saved frames cover every frame it freezes.
+#[test]
+fn freeze_uses_complete_saved_tracking_without_the_model() {
+    let (s, clip, uid, path) = saved_project("freeze-saved");
+    forget(&s, clip, uid);
+    let mut s2 = Session::default();
+    s2.execute_checked("file.open", json!({"path": path})).unwrap();
+    s2.footage = s.footage.clone();
+    s2.execute_checked("roto.model.select", json!({"id": "sam2.1-hiera-tiny"})).unwrap();
+    s2.execute_checked("roto.freeze", json!({"layer": clip.0, "wait": true})).unwrap();
+    let _ = std::fs::remove_dir_all(std::path::Path::new(&path).parent().unwrap());
+}
+
+/// Propagate replaces a fully saved span when a different tracking model is active.
+#[test]
+fn propagating_saved_tracking_uses_the_new_model() {
+    struct OtherModel;
+    impl effectcraft_segment::MaskModel for OtherModel {
+        fn info(&self) -> &'static effectcraft_segment::ModelInfo {
+            &effectcraft_segment::SAM2_SMALL
+        }
+        fn segment(&self, _: &[[f32; 3]], _: usize, _: usize, _: &effectcraft_segment::Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+            Err("no weights".into())
+        }
+        fn tracker(&self) -> Option<&dyn effectcraft_segment::ObjectTracker> {
+            Some(&Exact)
+        }
+    }
+    let (mut s, clip, _uid, path) = saved_project("model-switch");
+    effectcraft_effects::roto::set_model(Some(std::sync::Arc::new(OtherModel)));
+    let result = s.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "both", "wait": true}));
+    effectcraft_effects::roto::set_model(None);
+    result.unwrap();
+    let status = s.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(status["tracker"]["saved"], "sam2.1-hiera-small", "{status}");
+    assert_eq!(status["tracker"]["frames"].as_object().unwrap().len(), 21, "{status}");
+    let _ = std::fs::remove_dir_all(std::path::Path::new(&path).parent().unwrap());
+}
+
+/// A tracked clip saved to a project file: the session that tracked it, its layer and instance, and the
+/// file.
+fn saved_project(name: &str) -> (Session, LayerId, u64, String) {
+    let (mut s, clip, uid) = painted(center, &format!("disk-{name}.mov"));
+    effectcraft_effects::roto::set_model(Some(std::sync::Arc::new(Exact)));
+    let r = s.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "both", "wait": true}));
+    effectcraft_effects::roto::set_model(None);
+    assert_eq!(r.unwrap()["frames"], 21);
+    let dir = std::env::temp_dir().join(format!("ec-roto-{name}-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("tracked.ecproj").to_string_lossy().to_string();
+    s.execute_checked("file.saveAs", json!({"path": path})).unwrap();
+    let saved = std::fs::read_to_string(&path).unwrap();
+    assert!(saved.contains("sam2.1-hiera-tiny"), "the project file carries the tracking and the model that made it");
+    (s, clip, uid, path)
+}
+
+/// A stroke change makes the saved tracking stale: the instance is classical until the next Propagate.
+#[test]
+fn a_stroke_change_makes_the_saved_tracking_stale() {
+    let (_s, clip, _uid, path) = saved_project("stale");
+    let mut s2 = Session::default();
+    s2.execute_checked("file.open", json!({"path": path})).unwrap();
+    s2.execute_checked("roto.model.select", json!({"id": "sam2.1-hiera-tiny"})).unwrap();
+    assert_eq!(s2.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap()["source"], "tracker");
+    s2.execute_checked("roto.stroke", json!({"layer": clip.0, "kind": "bg", "points": line([10.0, 10.0], [60.0, 12.0]), "radius": 4})).unwrap();
+    let st = s2.execute("roto.status", json!({"layer": clip.0, "frame": 12})).unwrap();
+    assert_eq!(st["source"], "classical", "{st}");
+    assert_eq!(st["tracker"]["frames"].as_object().unwrap().len(), 0, "{st}");
+    let _ = std::fs::remove_dir_all(std::path::Path::new(&path).parent().unwrap());
+}
+
+/// A tracker that emits a completed frame before failing must leave only classic results behind.
+#[test]
+fn a_partially_failing_tracker_falls_back_to_the_classic_engine() {
+    use effectcraft_segment::{ClipFrame, MaskModel, ModelInfo, ObjectTracker, Prompt, TrackRequest, TrackedFrame};
+    use std::sync::Arc;
+    struct Broken;
+    impl MaskModel for Broken {
+        fn info(&self) -> &'static ModelInfo {
+            &effectcraft_segment::SAM2_TINY
+        }
+        fn segment(&self, _: &[[f32; 3]], _: usize, _: usize, _: &Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+            Err("no weights".into())
+        }
+        fn tracker(&self) -> Option<&dyn ObjectTracker> {
+            Some(self)
+        }
+    }
+    impl ObjectTracker for Broken {
+        fn track(
+            &self,
+            req: &TrackRequest,
+            frame: &mut dyn FnMut(i64) -> Option<Arc<ClipFrame>>,
+            _: &dyn Fn() -> bool,
+            out: &mut dyn FnMut(usize, i64, TrackedFrame),
+        ) -> effectcraft_segment::Result<()> {
+            let img = frame(req.first).ok_or("missing test frame")?;
+            for object in 0..req.objects.len() {
+                out(object, req.first, TrackedFrame { prob: vec![1.0; img.w * img.h], w: img.w, h: img.h, confidence: 0.9, occluded: false });
+            }
+            Err("the tracker broke after emitting a frame".into())
+        }
+    }
+    hold_roto_cache_test_lock();
+    let (mut s, clip, uid) = painted(center, "disk-partially-broken-tracker.mov");
+    s.execute_checked("roto.stroke", json!({"layer": clip.0, "object": 1, "points": [center(0)], "radius": 4})).unwrap();
+    effectcraft_effects::roto::set_model(Some(Arc::new(Broken)));
+    let r = s.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "both", "wait": true}));
+    let st = s.execute("roto.status", json!({"layer": clip.0, "frame": 0}));
+    let comp = s.active_comp().unwrap();
+    let layer = comp.layer(clip).unwrap();
+    let params = crate::roto::params_static(layer.props.find_group(uid).unwrap());
+    let size = crate::roto::layer_size(&s.project, comp, layer);
+    let mut chain = effectcraft_effects::roto::Chain::new(&params, size, comp.frame_rate.as_f64(), 1.0);
+    let index = layer.effects().unwrap().groups().position(|g| g.uid == uid).unwrap();
+    let mut source =
+        crate::roto::FrameSource::new(&s.project, s.footage.as_ref(), s.expr.as_deref(), &s.layer_cache, s.active_comp_id().unwrap(), comp, layer, index, size);
+    let mut get = |f: i64| source.get(f);
+    let actual: Option<Vec<_>> = (0..=20).map(|f| chain.ensure(f, &mut get, &|| false)).collect();
+    let retained_object = chain.object_seg(0, 0).is_some() || chain.object_seg(0, 1).is_some();
+    let retained_trust = chain.trust_at(0);
+    // Build the reference only after capturing the fallback, with no model or cached union.
+    effectcraft_effects::roto::forget(chain.keys.values().copied());
+    chain.model = None;
+    let expected: Option<Vec<_>> = (0..=20).map(|f| chain.ensure(f, &mut get, &|| false)).collect();
+    effectcraft_effects::roto::set_model(None);
+    let r = r.unwrap();
+    assert_eq!(r["frames"], 21, "{r}");
+    let st = st.unwrap();
+    assert_ne!(st["source"], "tracker", "{st}");
+    assert_eq!(st["tracker"]["frames"].as_object().unwrap().len(), 0);
+    assert!(!retained_object, "partial per-object mattes must be discarded");
+    assert_eq!(retained_trust, None, "partial tracker confidence must be discarded");
+    for (frame, (actual, expected)) in actual.unwrap().into_iter().zip(expected.unwrap()).enumerate() {
+        assert!(actual == expected, "fallback frame {frame} differs from the classic engine");
+    }
+}
+
+/// Without a tracking model the Roto Brush chain is exactly the classic engine: every frame
+/// equals a direct call of `segment_with` / `propagate_with` (no model), bit for bit.
+#[test]
+fn without_a_tracker_the_chain_is_exactly_the_classic_engine() {
+    use effectcraft_track::roto as rb;
+    use std::sync::Arc;
+    let (s, clip, uid) = painted(center, "disk-bitexact.mov");
+    forget(&s, clip, uid);
+    let comp = s.active_comp().unwrap();
+    let l = comp.layer(clip).unwrap();
+    let g = l.props.find_group(uid).unwrap();
+    let size = crate::roto::layer_size(&s.project, comp, l);
+    let chain = effectcraft_effects::roto::Chain::new(&crate::roto::params_static(g), size, comp.frame_rate.as_f64(), 1.0);
+    assert!(!chain.has_tracker());
+    let img = |f: i64| Arc::new(draw(center(f as u32)));
+    let mut prev: Option<(Arc<Image>, rb::FrameSeg)> = None;
+    for f in 0..=5i64 {
+        let got = chain.ensure(f, &mut |g| Some(img(g)), &|| false).unwrap();
+        let cur = img(f);
+        let strokes = chain.data.strokes_at(f);
+        let want = match &prev {
+            None => rb::segment_with(&cur, &strokes, None, &chain.opts, chain.refine_radius, None),
+            Some((pi, ps)) => rb::propagate_with(pi, ps, &cur, &strokes, &chain.opts, chain.refine_radius, None),
+        };
+        assert_eq!(*got, want, "frame {f} differs from the classic engine");
+        prev = Some((cur, want));
+    }
+    forget(&s, clip, uid);
+}
+
+/// Records the windows it is asked to track, and follows the disc exactly like [`Exact`].
+#[derive(Default)]
+struct Recorder {
+    requests: std::sync::Mutex<Vec<(i64, usize, Vec<i64>)>>,
+}
+
+impl effectcraft_segment::MaskModel for Recorder {
+    fn info(&self) -> &'static effectcraft_segment::ModelInfo {
+        &effectcraft_segment::SAM2_TINY
+    }
+    fn segment(&self, _: &[[f32; 3]], _: usize, _: usize, _: &effectcraft_segment::Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+        Err("no weights".into())
+    }
+    fn tracker(&self) -> Option<&dyn effectcraft_segment::ObjectTracker> {
+        Some(self)
+    }
+}
+
+impl effectcraft_segment::ObjectTracker for Recorder {
+    fn track(
+        &self,
+        req: &effectcraft_segment::TrackRequest,
+        frame: &mut dyn FnMut(i64) -> Option<std::sync::Arc<effectcraft_segment::ClipFrame>>,
+        cancel: &dyn Fn() -> bool,
+        out: &mut dyn FnMut(usize, i64, effectcraft_segment::TrackedFrame),
+    ) -> effectcraft_segment::Result<()> {
+        let prompted = req.objects.iter().flatten().map(|(f, _)| *f).collect();
+        self.requests.lock().unwrap().push((req.first, req.count, prompted));
+        effectcraft_segment::ObjectTracker::track(&Exact, req, frame, cancel, out)
+    }
+}
+
+/// A correction stroke re-tracks only what it changes: the frames from it on, restarted at the
+/// corrected frame; the frames before it keep their tracked results.
+#[test]
+fn a_correction_re_tracks_only_the_frames_it_changes() {
+    let (mut s, clip, uid) = painted(center, "disk-retrack.mov");
+    let cid = s.active_comp_id().unwrap();
+    assert!(s.roto_trust(cid, clip, uid).is_empty(), "no tracker data before tracking");
+    let rec = std::sync::Arc::new(Recorder::default());
+    effectcraft_effects::roto::set_model(Some(rec.clone()));
+    let run = |s: &mut Session| s.execute_checked("roto.propagate", json!({"layer": clip.0, "direction": "forward", "wait": true}));
+    let first = run(&mut s);
+    assert_eq!(rec.requests.lock().unwrap().as_slice(), [(0, 21, vec![0])], "the first pass tracks the whole span");
+    first.unwrap();
+    // Nothing changed: nothing to track.
+    run(&mut s).unwrap();
+    assert_eq!(rec.requests.lock().unwrap().len(), 1, "an unchanged span is not tracked again");
+    // A correction on frame 8: the frames from 8 on are tracked again, restarting at frame 8.
+    let c = center(8);
+    s.execute_checked("roto.stroke", json!({"layer": clip.0, "frame": 8, "points": line([c[0] - 20.0, c[1]], [c[0] + 20.0, c[1]]), "radius": 6})).unwrap();
+    let again = run(&mut s);
+    let reqs = rec.requests.lock().unwrap().clone();
+    effectcraft_effects::roto::set_model(None);
+    again.unwrap();
+    assert_eq!(reqs.len(), 2);
+    assert_eq!(reqs[1], (8, 13, vec![8]), "the window runs from the corrected frame to the end of the span");
+    // The frames before the correction are still the first pass's, the rest the second's.
+    let st = s.execute("roto.status", json!({"layer": clip.0, "frame": 3})).unwrap();
+    assert_eq!(st["source"], "tracker", "{st}");
+    assert_eq!(st["tracker"]["frames"].as_object().unwrap().len(), 21, "{st}");
+    // The span bar's data: the tracker's confidence for every tracked frame.
+    let trust = s.roto_trust(cid, clip, uid);
+    assert_eq!(trust.len(), 21);
+    assert!(trust.values().all(|t| t.confidence > 0.9 && !t.occluded));
+}
+
+#[test]
+fn strokes_belong_to_the_current_object() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 64, "height": 64, "frameRate": 25, "duration": 1})).unwrap();
+    let layer = s.execute("layer.newSolid", json!({"width": 64, "height": 64})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("roto.stroke", json!({"layer": layer, "points": [[10, 10]], "radius": 4})).unwrap();
+    // the current object is an option shared by the tool and the commands
+    s.execute("roto.options", json!({"object": 1})).unwrap();
+    s.execute("roto.stroke", json!({"layer": layer, "points": [[50, 50]], "radius": 4})).unwrap();
+    s.execute("roto.stroke", json!({"layer": layer, "kind": "bg", "points": [[30, 30]], "radius": 4})).unwrap();
+    // an explicit object wins over the option, and is clamped to the supported range
+    s.execute("roto.stroke", json!({"layer": layer, "points": [[20, 50]], "radius": 4, "object": 99})).unwrap();
+    let st = s.execute("roto.status", json!({"layer": layer})).unwrap();
+    assert_eq!(st["currentObject"], 1);
+    assert_eq!(st["objects"], json!([{"id": 0, "strokes": 1}, {"id": 1, "strokes": 2}, {"id": 31, "strokes": 1}]));
+    // removing one object's strokes leaves the others
+    let r = s.execute("roto.clearStrokes", json!({"layer": layer, "object": 1})).unwrap();
+    assert_eq!(r["removed"], 2);
+    let st = s.execute("roto.status", json!({"layer": layer})).unwrap();
+    assert_eq!(st["objects"], json!([{"id": 0, "strokes": 1}, {"id": 31, "strokes": 1}]));
+    // the object survives a save and a load
+    let json = s.project.to_json();
+    assert!(json.contains("\\\"object\\\":31"), "the project file carries the object");
+}
+
+#[test]
+fn clearing_one_object_keeps_shared_refine_edge_strokes() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 64, "height": 64, "duration": 1})).unwrap();
+    let layer = s.execute("layer.newSolid", json!({})).unwrap()["layer"].as_u64().unwrap();
+    for (object, kind) in [(0, "fg"), (0, "bg"), (0, "refine"), (0, "refineErase"), (1, "fg")] {
+        s.execute("roto.stroke", json!({"layer": layer, "object": object, "kind": kind, "points": [[20, 20]], "radius": 4})).unwrap();
+    }
+    let before = s.project.to_json();
+    let result = s.execute("roto.clearStrokes", json!({"layer": layer, "object": 0})).unwrap();
+    assert_eq!(result["removed"], 2, "only the object's foreground/background strokes are owned by it");
+    assert_eq!(result["strokes"], 3);
+    assert!(s.undo());
+    assert_eq!(s.project.to_json(), before);
+    for kind in ["refine", "refineErase"] {
+        let result = s.execute("roto.clearStrokes", json!({"layer": layer, "kind": kind})).unwrap();
+        assert_eq!(result["removed"], 1, "explicitly clearing shared {kind} still works");
+    }
+}
+
+#[test]
+fn clearing_strokes_rejects_invalid_object_filters_without_editing() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 64, "height": 64, "duration": 1})).unwrap();
+    let layer = s.execute("layer.newSolid", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("roto.stroke", json!({"layer": layer, "points": [[20, 20]], "radius": 4})).unwrap();
+    let before = s.project.to_json();
+    for object in [json!(-1), json!(-0.1), json!(32), json!(1e30), json!(null), json!("0")] {
+        let result = s.execute("roto.clearStrokes", json!({"layer": layer, "object": object}));
+        assert!(result.is_err(), "invalid object {object} must not delete object zero: {result:?}");
+        assert_eq!(s.project.to_json(), before);
+    }
+}
diff --git a/crates/engine/src/tests/scale_comp.rs b/crates/engine/src/tests/scale_comp.rs
new file mode 100644
index 000000000..752ce9fe5
--- /dev/null
+++ b/crates/engine/src/tests/scale_comp.rs
@@ -0,0 +1,287 @@
+//! Scale Composition (`comp.scale`, #2208): the comp and everything in it grow or shrink by one
+//! factor, so the frame looks the same at the new size.
+
+use effectcraft_project::{Layer, LayerId};
+use effectcraft_time::Tick;
+use serde_json::json;
+
+use crate::{EngineError, Session};
+
+fn comp(w: u32, h: u32) -> Session {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Main", "width": w, "height": h, "frameRate": 10, "duration": 2})).unwrap();
+    s
+}
+
+fn solid(s: &mut Session, color: &str, w: u32, h: u32) -> u64 {
+    s.execute("layer.newSolid", json!({"color": color, "width": w, "height": h})).unwrap()["layer"].as_u64().unwrap()
+}
+
+fn layer(s: &Session, id: u64) -> Layer {
+    s.active_comp().unwrap().layer(LayerId(id)).unwrap().clone()
+}
+
+fn v3(s: &Session, id: u64, path: &str, t: f64) -> [f64; 3] {
+    layer(s, id).props.prop(path).unwrap().value_at(Tick::from_seconds_f64(t)).as_vec3()
+}
+
+/// Opaque pixels of `color_channel` (0 = red, 1 = green) at `t`: (x0, y0, x1, y1, count).
+fn bounds(s: &Session, t: f64, channel: usize) -> (i64, i64, i64, i64, u32) {
+    let img = s.render(s.active_comp_id().unwrap(), Tick::from_seconds_f64(t), Default::default());
+    let (mut x0, mut y0, mut x1, mut y1, mut n) = (i64::MAX, i64::MAX, i64::MIN, i64::MIN, 0);
+    for y in 0..img.height as i64 {
+        for x in 0..img.width as i64 {
+            let p = img.get(x, y);
+            if p[3] > 0.5 && p[channel] > 0.5 {
+                n += 1;
+                (x0, y0, x1, y1) = (x0.min(x), y0.min(y), x1.max(x), y1.max(y));
+            }
+        }
+    }
+    (x0, y0, x1, y1, n)
+}
+
+/// Twice as large on every side, from a pixel-exact frame.
+fn doubled(b: (i64, i64, i64, i64, u32)) -> (i64, i64, i64, i64, u32) {
+    (b.0 * 2, b.1 * 2, b.2 * 2 + 1, b.3 * 2 + 1, b.4 * 4)
+}
+
+#[test]
+fn scale_comp_doubles_the_frame_with_keys_and_parented_layers() {
+    let mut s = comp(200, 100);
+    // A red solid moving right (two Position keys), and a green solid parented to a null.
+    let red = solid(&mut s, "#ff0000", 20, 10);
+    s.execute("prop.addKey", json!({"layer": red, "path": "transform/position", "time": 0, "value": [30, 20]})).unwrap();
+    s.execute("prop.addKey", json!({"layer": red, "path": "transform/position", "time": 1, "value": [70, 20]})).unwrap();
+    let green = solid(&mut s, "#00ff00", 10, 10);
+    let rig = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": rig, "path": "transform/position", "value": [150, 60]})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [green], "parent": rig})).unwrap();
+    s.execute("prop.set", json!({"layer": green, "path": "transform/position", "value": [10, 15]})).unwrap();
+    let before = s.project.clone();
+    let (red0, red1, green0) = (bounds(&s, 0.0, 0), bounds(&s, 1.0, 0), bounds(&s, 0.0, 1));
+    assert_eq!(red0, (20, 15, 39, 24, 200));
+
+    let r = s.execute("comp.scale", json!({"factor": 2})).unwrap();
+    assert_eq!((r["width"].as_u64(), r["height"].as_u64()), (Some(400), Some(200)));
+    let c = s.active_comp().unwrap();
+    assert_eq!((c.width, c.height), (400, 200));
+    // Every key moves, not only the value at the current time.
+    assert_eq!(bounds(&s, 0.0, 0), doubled(red0));
+    assert_eq!(bounds(&s, 1.0, 0), doubled(red1));
+    assert_eq!(v3(&s, red, "transform/scale", 1.0), [200.0; 3]);
+    // The child keeps its own transform: its scaled parent carries it.
+    assert_eq!(bounds(&s, 0.0, 1), doubled(green0));
+    assert_eq!(v3(&s, green, "transform/position", 0.0)[..2], [10.0, 15.0]);
+    assert_eq!(v3(&s, green, "transform/scale", 0.0), [100.0; 3]);
+    let after = s.project.clone();
+
+    // One undo step, and one redo step.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(s.project == before, "undo restores the comp and every layer");
+    s.execute("edit.redo", json!({})).unwrap();
+    assert!(s.project == after, "redo scales the comp and every layer again");
+}
+
+#[test]
+fn scale_comp_to_a_width_keeps_the_aspect_and_scales_cameras_3d_and_guides() {
+    let mut s = comp(640, 360);
+    let card = solid(&mut s, "#ff0000", 100, 100);
+    s.execute("layer.setSwitch", json!({"layers": [card], "switch": "threeD", "value": true})).unwrap();
+    s.execute("prop.set", json!({"layer": card, "path": "transform/position", "value": [100, 50, 200]})).unwrap();
+    let cam = s.execute("layer.newCamera", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("view.addGuide", json!({"orientation": "vertical", "position": 160})).unwrap();
+    s.execute("view.addGuide", json!({"orientation": "horizontal", "position": 25, "percent": true})).unwrap();
+    let zoom = |s: &Session| layer(s, cam).props.prop("cameraOptions/zoom").unwrap().value.as_f64();
+    let (zoom0, cam0, poi0) = (zoom(&s), v3(&s, cam, "transform/position", 0.0), v3(&s, cam, "transform/poi", 0.0));
+    let seen0 = bounds(&s, 0.0, 0);
+    s.execute("view.setRegionOfInterest", json!({"rect": [10, 20, 70, 70]})).unwrap();
+
+    let r = s.execute("comp.scale", json!({"width": 960})).unwrap();
+    assert_eq!((r["width"].as_u64(), r["height"].as_u64(), r["factor"].as_f64()), (Some(960), Some(540), Some(1.5)));
+    assert_eq!(v3(&s, card, "transform/position", 0.0), [150.0, 75.0, 300.0]);
+    assert_eq!(v3(&s, card, "transform/scale", 0.0), [150.0; 3]);
+    assert!((zoom(&s) - zoom0 * 1.5).abs() < 1e-9, "the camera sees the same frame");
+    assert_eq!(v3(&s, cam, "transform/position", 0.0), cam0.map(|v| v * 1.5));
+    assert_eq!(v3(&s, cam, "transform/poi", 0.0), poi0.map(|v| v * 1.5));
+    // Through the camera the card covers the same part of the frame.
+    let seen = bounds(&s, 0.0, 0);
+    let near = |a: i64, b: i64| (a as f64 - b as f64 * 1.5).abs() <= 2.0;
+    assert!(near(seen.0, seen0.0) && near(seen.1, seen0.1) && near(seen.2, seen0.2) && near(seen.3, seen0.3), "{seen0:?} → {seen:?}");
+    let c = s.active_comp().unwrap();
+    assert_eq!(c.guides[0].px(c.width, c.height), 240.0);
+    assert_eq!(c.guides[1].position, 25.0, "a percentage guide keeps its percent");
+    assert_eq!(s.state.region_of_interest, Some([15.0, 30.0, 105.0, 105.0]), "the region of interest covers the same part");
+
+    // A height alone works the same way.
+    let r = s.execute("comp.scale", json!({"height": 270})).unwrap();
+    assert_eq!((r["width"].as_u64(), r["height"].as_u64()), (Some(480), Some(270)));
+}
+
+#[test]
+fn scale_comp_scales_depth_under_a_2d_parent_and_children_of_a_camera() {
+    let mut s = comp(200, 100);
+    let cam = s.execute("layer.newCamera", json!({})).unwrap()["layer"].as_u64().unwrap();
+    // A 3D card under a 2D null: the null's Scale carries X and Y but not Z.
+    let card = solid(&mut s, "#ff0000", 20, 10);
+    let rig = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": rig, "path": "transform/position", "value": [100, 50]})).unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [card], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [card], "parent": rig})).unwrap();
+    s.execute("prop.set", json!({"layer": card, "path": "transform/position", "value": [-40, 0, 500]})).unwrap();
+    // A 3D card parented to the camera, in front of it.
+    let held = solid(&mut s, "#00ff00", 10, 10);
+    s.execute("layer.setSwitch", json!({"layers": [held], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [held], "parent": cam})).unwrap();
+    s.execute("prop.set", json!({"layer": held, "path": "transform/position", "value": [30, 0, 500]})).unwrap();
+    let (card0, held0) = (bounds(&s, 0.0, 0), bounds(&s, 0.0, 1));
+    let (held_pos0, held_scale0) = (v3(&s, held, "transform/position", 0.0), v3(&s, held, "transform/scale", 0.0));
+    assert!(card0.4 > 0 && held0.4 > 0, "both cards are in view: {card0:?} {held0:?}");
+
+    s.execute("comp.scale", json!({"factor": 2})).unwrap();
+    let near = |a: (i64, i64, i64, i64, u32), b: (i64, i64, i64, i64, u32)| {
+        [(a.0, b.0 * 2), (a.1, b.1 * 2), (a.2, b.2 * 2 + 1), (a.3, b.3 * 2 + 1)].iter().all(|&(x, y)| (x - y).abs() <= 2)
+    };
+    let (card1, held1) = (bounds(&s, 0.0, 0), bounds(&s, 0.0, 1));
+    assert!(near(card1, card0), "the card under the 2D null doubles: {card0:?} → {card1:?}");
+    assert_eq!(v3(&s, card, "transform/position", 0.0), [-40.0, 0.0, 1000.0]);
+    assert!(near(held1, held0), "the card held by the camera doubles: {held0:?} → {held1:?}");
+    assert_eq!(v3(&s, held, "transform/position", 0.0), held_pos0.map(|v| v * 2.0));
+    assert_eq!(v3(&s, held, "transform/scale", 0.0), held_scale0.map(|v| v * 2.0));
+}
+
+#[test]
+fn scale_comp_keeps_the_ease_of_depth_moves_under_a_2d_parent() {
+    let mut s = comp(200, 100);
+    let card = solid(&mut s, "#ff0000", 20, 10);
+    let rig = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [card], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [card], "parent": rig})).unwrap();
+    s.execute("prop.addKey", json!({"layer": card, "path": "transform/position", "time": 0, "value": [0, 0, 0]})).unwrap();
+    s.execute("prop.addKey", json!({"layer": card, "path": "transform/position", "time": 1, "value": [0, 0, 100]})).unwrap();
+    s.execute("keys.setEase", json!({"layer": card, "path": "transform/position", "time": 0, "side": "out", "speed": 100, "influence": 50})).unwrap();
+    s.execute("prop.addKey", json!({"layer": card, "path": "transform/scale", "time": 0, "value": [100, 100, 100]})).unwrap();
+    s.execute("prop.addKey", json!({"layer": card, "path": "transform/scale", "time": 1, "value": [100, 100, 300]})).unwrap();
+    s.execute("keys.setEase", json!({"layer": card, "path": "transform/scale", "time": 0, "side": "out", "speed": 300, "influence": 50})).unwrap();
+    let (pos0, scale0) = (v3(&s, card, "transform/position", 0.25), v3(&s, card, "transform/scale", 0.25));
+
+    s.execute("comp.scale", json!({"factor": 2})).unwrap();
+    // Twice the distance in the same time: the same ease, every frame twice as deep.
+    let (pos, scale) = (v3(&s, card, "transform/position", 0.25), v3(&s, card, "transform/scale", 0.25));
+    assert!((pos[2] - pos0[2] * 2.0).abs() < 1e-6, "{pos0:?} → {pos:?}");
+    assert!((scale[2] - scale0[2] * 2.0).abs() < 1e-6, "{scale0:?} → {scale:?}");
+    assert_eq!(scale[..2], scale0[..2]);
+}
+
+#[test]
+fn scale_comp_gives_z_its_own_speed_when_a_scale_key_has_one_ease() {
+    let mut s = comp(200, 100);
+    let card = solid(&mut s, "#ff0000", 20, 10);
+    let rig = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [card], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [card], "parent": rig})).unwrap();
+    s.execute("prop.addKey", json!({"layer": card, "path": "transform/scale", "time": 0, "value": [100, 100, 100]})).unwrap();
+    s.execute("prop.addKey", json!({"layer": card, "path": "transform/scale", "time": 1, "value": [100, 100, 300]})).unwrap();
+    s.execute("keys.setEase", json!({"layer": card, "path": "transform/scale", "time": 0, "side": "out", "speed": 300, "influence": 50})).unwrap();
+    // One ease for every dimension, as a project file may store it.
+    let cid = s.active_comp_id().unwrap();
+    let key =
+        &mut std::sync::Arc::make_mut(&mut s.project).comp_mut(cid).unwrap().layer_mut(LayerId(card)).unwrap().props.prop_mut("transform/scale").unwrap().keys
+            [0];
+    key.out_ease.truncate(1);
+    let scale0 = v3(&s, card, "transform/scale", 0.25);
+
+    s.execute("comp.scale", json!({"factor": 2})).unwrap();
+    let scale = v3(&s, card, "transform/scale", 0.25);
+    assert!((scale[2] - scale0[2] * 2.0).abs() < 1e-6, "{scale0:?} → {scale:?}");
+    assert_eq!(scale[..2], scale0[..2], "X and Y keep the shared ease");
+}
+
+#[test]
+fn scale_comp_scales_depth_once_through_a_3d_grandparent() {
+    let mut s = comp(200, 100);
+    s.execute("layer.newCamera", json!({})).unwrap();
+    // card (3D) → A (2D null) → B (3D null): B's Scale already carries the depth.
+    let card = solid(&mut s, "#ff0000", 20, 10);
+    let a = s.execute("layer.newNull", json!({"name": "A"})).unwrap()["layer"].as_u64().unwrap();
+    let b = s.execute("layer.newNull", json!({"name": "B"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [card, b], "switch": "threeD", "value": true})).unwrap();
+    s.execute("prop.set", json!({"layer": b, "path": "transform/position", "value": [100, 50, 0]})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [a], "parent": b})).unwrap();
+    s.execute("prop.set", json!({"layer": a, "path": "transform/position", "value": [0, 0]})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [card], "parent": a})).unwrap();
+    s.execute("prop.set", json!({"layer": card, "path": "transform/position", "value": [-40, 0, 500]})).unwrap();
+    let card0 = bounds(&s, 0.0, 0);
+    assert!(card0.4 > 0, "the card is in view");
+
+    s.execute("comp.scale", json!({"factor": 2})).unwrap();
+    assert_eq!(v3(&s, card, "transform/position", 0.0), [-40.0, 0.0, 500.0]);
+    let card1 = bounds(&s, 0.0, 0);
+    let near =
+        [(card1.0, card0.0 * 2), (card1.1, card0.1 * 2), (card1.2, card0.2 * 2 + 1), (card1.3, card0.3 * 2 + 1)].iter().all(|&(x, y)| (x - y).abs() <= 2);
+    assert!(near, "{card0:?} → {card1:?}");
+}
+
+#[test]
+fn scale_comp_scales_once_through_a_camera_under_a_scaled_null() {
+    let mut s = comp(200, 100);
+    // solid → camera → B (3D null): B's Scale reaches the solid through the camera.
+    let cam = s.execute("layer.newCamera", json!({})).unwrap()["layer"].as_u64().unwrap();
+    let b = s.execute("layer.newNull", json!({"name": "B"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [b], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [cam], "parent": b})).unwrap();
+    let held = solid(&mut s, "#00ff00", 10, 10);
+    s.execute("layer.setSwitch", json!({"layers": [held], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [held], "parent": cam})).unwrap();
+    s.execute("prop.set", json!({"layer": held, "path": "transform/position", "value": [30, 0, 500]})).unwrap();
+    let held0 = bounds(&s, 0.0, 1);
+    assert!(held0.4 > 0, "the solid is in view: {held0:?}");
+
+    s.execute("comp.scale", json!({"factor": 2})).unwrap();
+    assert_eq!(v3(&s, held, "transform/position", 0.0), [30.0, 0.0, 500.0]);
+    assert_eq!(v3(&s, held, "transform/scale", 0.0), [100.0; 3]);
+    let held1 = bounds(&s, 0.0, 1);
+    let near =
+        [(held1.0, held0.0 * 2), (held1.1, held0.1 * 2), (held1.2, held0.2 * 2 + 1), (held1.3, held0.3 * 2 + 1)].iter().all(|&(x, y)| (x - y).abs() <= 2);
+    assert!(near, "{held0:?} → {held1:?}");
+}
+
+#[test]
+fn scale_comp_scales_the_point_of_interest_depth_of_a_camera_under_a_2d_null() {
+    let mut s = comp(200, 100);
+    let cam = s.execute("layer.newCamera", json!({})).unwrap()["layer"].as_u64().unwrap();
+    let rig = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setParent", json!({"layers": [cam], "parent": rig})).unwrap();
+    s.execute("prop.set", json!({"layer": cam, "path": "transform/position", "value": [10, 20, -1000]})).unwrap();
+    s.execute("prop.set", json!({"layer": cam, "path": "transform/poi", "value": [10, 20, 200]})).unwrap();
+
+    s.execute("comp.scale", json!({"factor": 2})).unwrap();
+    // The 2D null carries X and Y; the camera's own Z doubles at both ends, so it looks the same way.
+    assert_eq!(v3(&s, cam, "transform/position", 0.0), [10.0, 20.0, -2000.0]);
+    assert_eq!(v3(&s, cam, "transform/poi", 0.0), [10.0, 20.0, 400.0]);
+}
+
+#[test]
+fn scale_comp_refuses_a_bad_factor_and_changes_nothing() {
+    let mut s = comp(640, 360);
+    solid(&mut s, "#ff0000", 100, 100);
+    let before = s.project.clone();
+    let cases = [
+        (json!({}), "pass `factor`"),
+        (json!({"factor": 0}), "4 to 30,000 px"),
+        (json!({"factor": -2}), "4 to 30,000 px"),
+        (json!({"width": 0}), "4 to 30,000 px"),
+        (json!({"factor": 100}), "4 to 30,000 px"),
+        (json!({"factor": 0.001}), "4 to 30,000 px"),
+        (json!({"factor": 2, "width": 960}), "only one of"),
+        (json!({"width": 960, "height": 360}), "only one of"),
+    ];
+    for (p, why) in cases {
+        match s.execute("comp.scale", p.clone()) {
+            Err(EngineError::BadParams { cmd, msg }) => assert!(cmd == "comp.scale" && msg.contains(why), "{p}: {msg}"),
+            other => panic!("{p} is refused as bad parameters, got {other:?}"),
+        }
+        assert!(s.project == before, "{p} leaves the project alone");
+    }
+    s.execute("comp.scale", json!({"factor": 1})).unwrap();
+}
diff --git a/crates/engine/src/tests_sequence.rs b/crates/engine/src/tests/sequence.rs
similarity index 81%
rename from crates/engine/src/tests_sequence.rs
rename to crates/engine/src/tests/sequence.rs
index 3e81961ce..cf6968e3f 100644
--- a/crates/engine/src/tests_sequence.rs
+++ b/crates/engine/src/tests/sequence.rs
@@ -104,10 +104,11 @@ fn numbered_stills_import_as_stills_by_default() {
     let r = s.execute("file.import", json!({"paths": [dir.clone()], "drag": true})).unwrap();
     let (name, f) = footage(&s, &r["items"][0]);
     assert_eq!((name.as_str(), f.kind), ("shot_[0001-0005].png", FootageKind::Sequence));
-    // Scripts and agents naming one frame without `sequence` still get its run.
-    let r = s.execute("file.import", json!({"paths": [at(&dir, "shot_0003.png")]})).unwrap();
-    let (_, f) = footage(&s, &r["items"][0]);
-    assert_eq!(f.kind, FootageKind::Sequence);
+    // #2018: scripts and agents naming one frame without `sequence` get that still, as
+    // `ImportOptions.sequence` defaults to false in After Effects.
+    let r = s.execute("file.import", json!({"paths": [at(&dir, "shot_0005.png")]})).unwrap();
+    let (name, f) = footage(&s, &r["items"][0]);
+    assert_eq!((name.as_str(), f.kind), ("shot_0005.png", FootageKind::Still));
 }
 
 #[test]
@@ -181,14 +182,58 @@ fn interpret_footage_start_timecode_relabels_source_time() {
 }
 
 #[test]
-fn replace_footage_and_reload_keep_sequences() {
+fn replace_footage_keeps_a_still_a_still() {
     let dir = folder(&RUN);
     let mut s = session();
     let item = s.execute("file.import", json!({"paths": [at(&dir, "shot_0001.png")], "sequence": false})).unwrap()["items"][0].clone();
     s.state.project_selection = vec![ItemId(item.as_u64().unwrap())];
+    // Replacing with a numbered still does not silently turn the item into a sequence (#2073).
     s.execute("file.replaceFootage", json!({"path": at(&dir, "shot_0004.png")})).unwrap();
     let (name, f) = footage(&s, &item);
-    assert_eq!((name.as_str(), f.sequence.len()), ("shot_[0001-0005].png", 4));
+    assert_eq!((name.as_str(), f.kind), ("shot_0004.png", FootageKind::Still));
+    // JSON null is unspecified, not "on": the still stays a still.
+    s.execute("file.replaceFootage", json!({"path": at(&dir, "shot_0004.png"), "sequence": null})).unwrap();
+    let (name, f) = footage(&s, &item);
+    assert_eq!((name.as_str(), f.kind), ("shot_0004.png", FootageKind::Still));
+    // Alphabetical is a sequence modifier, not a request to make one.
+    s.execute("file.replaceFootage", json!({"path": at(&dir, "shot_0004.png"), "alphabetical": true})).unwrap();
+    let (name, f) = footage(&s, &item);
+    assert_eq!((name.as_str(), f.kind), ("shot_0004.png", FootageKind::Still));
+    // Asking for the run still brings it.
+    s.execute("file.replaceFootage", json!({"path": at(&dir, "shot_0004.png"), "sequence": true})).unwrap();
+    let (name, f) = footage(&s, &item);
+    assert_eq!((name.as_str(), f.kind, f.sequence.len()), ("shot_[0001-0005].png", FootageKind::Sequence, 4));
+}
+
+#[test]
+fn replace_footage_keeps_a_one_frame_run_a_sequence() {
+    let dir = folder(&["shot_0001.png", "shot_0002.png", "solo_0007.png", "cover.png"]);
+    let mut s = session();
+    let item = s.execute("file.import", json!({"paths": [at(&dir, "shot_0001.png")], "sequence": true})).unwrap()["items"][0].clone();
+    s.state.project_selection = vec![ItemId(item.as_u64().unwrap())];
+    // A numbered file with no other frame in its run is still the replacement for a sequence.
+    s.execute("file.replaceFootage", json!({"path": at(&dir, "solo_0007.png")})).unwrap();
+    let (name, f) = footage(&s, &item);
+    assert_eq!((name.as_str(), f.kind, f.sequence.len()), ("solo_0007.png", FootageKind::Sequence, 1));
+    // A single-file source keeps the sequence kind too.
+    s.execute("file.replaceFootage", json!({"path": at(&dir, "cover.png")})).unwrap();
+    let (name, f) = footage(&s, &item);
+    assert_eq!((name.as_str(), f.kind, f.sequence.len()), ("cover.png", FootageKind::Sequence, 1));
+    // An explicit `sequence: false` still asks for one frame.
+    s.execute("file.replaceFootage", json!({"path": at(&dir, "cover.png"), "sequence": false})).unwrap();
+    let (_, f) = footage(&s, &item);
+    assert_eq!((f.kind, f.sequence.len()), (FootageKind::Still, 0));
+}
+
+#[test]
+fn replace_footage_and_reload_keep_sequences() {
+    let dir = folder(&RUN);
+    let mut s = session();
+    let item = s.execute("file.import", json!({"paths": [at(&dir, "shot_0001.png")], "sequence": true})).unwrap()["items"][0].clone();
+    s.state.project_selection = vec![ItemId(item.as_u64().unwrap())];
+    s.execute("file.replaceFootage", json!({"path": at(&dir, "shot_0004.png")})).unwrap();
+    let (name, f) = footage(&s, &item);
+    assert_eq!((name.as_str(), f.kind, f.sequence.len()), ("shot_[0001-0005].png", FootageKind::Sequence, 4));
     // Reload finds a new frame and keeps the interpretation.
     s.execute("file.interpretFootage", json!({"items": [item], "frameRate": 12, "startTimecode": 2})).unwrap();
     std::fs::write(at(&dir, "shot_0003.png"), b"").unwrap();
diff --git a/crates/engine/src/tests/session.rs b/crates/engine/src/tests/session.rs
new file mode 100644
index 000000000..b253640e7
--- /dev/null
+++ b/crates/engine/src/tests/session.rs
@@ -0,0 +1,863 @@
+use serde_json::json;
+
+use crate::Session;
+
+fn demo() -> Session {
+    let mut s = Session::default();
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    s
+}
+
+#[test]
+fn demo_opens_and_renders() {
+    let s = demo();
+    let cid = s.active_comp_id().unwrap();
+    let img = s.render(cid, s.time(), effectcraft_render::RenderOpts { scale: 0.25, ..Default::default() });
+    assert_eq!((img.width, img.height), (480, 270));
+    let lit = img.data.iter().filter(|p| p[3] > 0.99).count();
+    assert!(lit > 100_000, "{lit}");
+}
+
+/// The session's layer cache never changes pixels: scrubbing the demo (including back and
+/// forth, and across an edit made through a command) matches cache-less renders exactly.
+#[test]
+fn demo_layer_cache_is_transparent() {
+    let mut s = demo();
+    let cid = s.active_comp_id().unwrap();
+    let opts = effectcraft_render::RenderOpts { scale: 0.25, ..Default::default() };
+    let uncached = |s: &Session, t: f64| {
+        let mut r = effectcraft_render::Renderer::new(&s.project, s.footage.as_ref(), opts);
+        r.expr = s.expr.as_deref();
+        r.comp_frame(cid, effectcraft_time::Tick::from_seconds_f64(t))
+    };
+    let check = |s: &Session, t: f64| {
+        let a = s.render(cid, effectcraft_time::Tick::from_seconds_f64(t), opts);
+        let b = uncached(s, t);
+        assert!(a.data.iter().zip(&b.data).all(|(p, q)| (0..4).all(|c| (p[c] - q[c]).abs() < 1e-6)), "t={t}");
+    };
+    for t in [0.5, 1.0, 3.0, 3.0334, 6.0, 3.0, 0.5] {
+        check(&s, t);
+    }
+    assert!(s.layer_cache.stats().hits > 0);
+    // Edit the title's glow through the command layer, then scrub again.
+    let title = s.project.comp(cid).unwrap().layers.iter().find(|l| l.name == "EFFECTCRAFT").map(|l| l.id.0).unwrap();
+    s.execute("prop.set", json!({"layer": title, "path": "effects/#1/radius", "value": 5.0})).unwrap();
+    for t in [3.0, 0.5] {
+        check(&s, t);
+    }
+}
+
+/// `layer.addItem` puts the layer at `index` (1-based) in the stack and starts it at `time`, as a
+/// drop in the Timeline does (#89).
+#[test]
+fn add_item_at_a_stack_index_and_time() {
+    let mut s = Session::default();
+    let clip = s.execute("comp.new", json!({"name": "Clip", "width": 16, "height": 16, "frameRate": 30, "duration": 1})).unwrap()["comp"].as_u64().unwrap();
+    s.execute("comp.new", json!({"name": "Main", "width": 32, "height": 32, "frameRate": 30, "duration": 4})).unwrap();
+    for name in ["C", "B", "A"] {
+        s.execute("layer.newSolid", json!({"name": name})).unwrap();
+    }
+    let names = |s: &Session| s.active_comp().unwrap().layers.iter().map(|l| l.name.clone()).collect::<Vec<_>>();
+    s.execute("layer.addItem", json!({"item": clip, "index": 2, "time": 1.01})).unwrap();
+    assert_eq!(names(&s), ["A", "Clip", "B", "C"]);
+    let l = &s.active_comp().unwrap().layers[1];
+    assert_eq!(l.in_point, effectcraft_time::Tick::from_seconds_f64(1.0), "on the nearest frame");
+    // Past the bottom: the bottom.
+    s.execute("layer.addItem", json!({"item": clip, "index": 99})).unwrap();
+    assert_eq!(names(&s).last().map(String::as_str), Some("Clip 2"));
+    assert!(s.execute("layer.addItem", json!({"item": clip, "index": 0})).is_err(), "1-based");
+}
+
+/// Files dropped on the Timeline or the Composition viewer (`file.import {addToComp}`) become
+/// layers of the comp that was active, one under the other, where they were dropped (#85, #89).
+#[test]
+fn imported_files_go_into_the_comp_where_they_were_dropped() {
+    use effectcraft_project::{Footage, FootageKind};
+    struct Probe;
+    impl crate::Importer for Probe {
+        fn probe(&self, path: &str) -> Result<Footage, String> {
+            Ok(Footage { path: path.into(), kind: FootageKind::Still, width: 64, height: 32, has_video: true, ..Default::default() })
+        }
+    }
+    let mut s = Session { importer: Some(std::sync::Arc::new(Probe)), ..Default::default() };
+    s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "frameRate": 30, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Bg"})).unwrap();
+    let params = json!({"paths": ["/drop/a.png", "/drop/b.png"], "addToComp": true, "position": [40.0, 50.0], "index": 1, "time": 1.0});
+    s.execute("file.import", params).unwrap();
+    let comp = s.active_comp().unwrap();
+    assert_eq!(comp.layers.iter().map(|l| l.name.as_str()).collect::<Vec<_>>(), ["a.png", "b.png", "Bg"]);
+    for l in comp.layers.iter().take(2) {
+        assert_eq!(l.props.prop("transform/position").map(|p| p.value.clone()), Some(effectcraft_keyframe::Value::Vec3([40.0, 50.0, 0.0])));
+        assert_eq!(l.in_point, effectcraft_time::Tick::from_seconds_f64(1.0));
+    }
+    // Without `addToComp` they only import.
+    s.execute("file.import", json!({"paths": ["/drop/c.png"]})).unwrap();
+    assert_eq!(s.active_comp().unwrap().layers.len(), 3);
+    assert!(s.execute("layer.addItem", json!({"item": "a.png", "position": [1.0]})).is_err(), "position needs x and y");
+}
+
+/// #270: files dropped or picked in the Import dialog (`file.import {background}`) are probed in
+/// a background job that says which file it is reading and how many are left; then they arrive
+/// in one undo step, all selected, with a count. The same file imported again arrives again.
+#[test]
+fn background_imports_report_progress_and_select_what_arrived() {
+    use effectcraft_project::{Footage, FootageKind, ItemId};
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    /// Probes file k once `allow` > k (a slow video; 5 s at most, so an import that waits for it
+    /// fails the test instead of hanging it); `.xyz` files fail.
+    struct Gated {
+        started: AtomicUsize,
+        allow: Arc<AtomicUsize>,
+    }
+    impl crate::Importer for Gated {
+        fn probe(&self, path: &str) -> Result<Footage, String> {
+            let k = self.started.fetch_add(1, Ordering::SeqCst);
+            let until = std::time::Instant::now() + std::time::Duration::from_secs(5);
+            while self.allow.load(Ordering::SeqCst) <= k && std::time::Instant::now() < until {
+                std::thread::sleep(std::time::Duration::from_millis(1));
+            }
+            if path.ends_with(".xyz") {
+                return Err("unsupported file".into());
+            }
+            Ok(Footage { path: path.into(), kind: FootageKind::Still, width: 64, height: 32, has_video: true, ..Default::default() })
+        }
+    }
+    let allow = Arc::new(AtomicUsize::new(1));
+    let mut s = Session { importer: Some(Arc::new(Gated { started: AtomicUsize::new(0), allow: allow.clone() })), ..Default::default() };
+    s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "frameRate": 30, "duration": 4})).unwrap();
+    let undo = s.history.undo.len();
+    let r = s.execute("file.import", json!({"paths": ["/drop/a.png", "/drop/b.png", "/drop/a.png"], "background": true})).unwrap();
+    let job = r["job"].as_str().unwrap().to_string();
+    // The first file is through; the second is being read.
+    let running = |s: &mut Session| s.execute("jobs.list", json!({})).unwrap()["running"].as_array().unwrap().clone();
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
+    while running(&mut s)[0]["done"] != json!(1) && std::time::Instant::now() < deadline {
+        std::thread::sleep(std::time::Duration::from_millis(2));
+    }
+    let row = running(&mut s)[0].clone();
+    assert_eq!(row["id"], json!(job));
+    assert_eq!(row["label"], json!("Importing 3 files"));
+    assert_eq!(row["message"], json!("b.png (2 of 3)"));
+    assert_eq!((row["done"].as_u64(), row["total"].as_u64()), (Some(1), Some(3)));
+    assert!(s.project.items.values().all(|i| i.name != "a.png"), "nothing is added before the import finishes");
+    allow.store(usize::MAX, Ordering::SeqCst);
+    s.execute("jobs.wait", json!({})).unwrap();
+    let names = |s: &Session, ids: &[ItemId]| ids.iter().map(|i| s.project.item(*i).unwrap().name.clone()).collect::<Vec<_>>();
+    assert_eq!(names(&s, &s.state.project_selection), ["a.png", "b.png", "a.png"], "everything imported is selected, the same file twice too");
+    assert_eq!(s.history.undo.len(), undo + 1, "one undo step");
+    let rec = s.job_log.last().unwrap();
+    assert_eq!((rec.status.as_str(), rec.message.as_str()), ("done", "Imported 3 items"));
+    assert!(s.drain_events().iter().any(|e| matches!(e, crate::Event::Toast { message, .. } if message == "Imported 3 items")));
+    // Dropped on the viewer: they become layers too; a file that can't be read is reported.
+    s.execute("file.import", json!({"paths": ["/drop/c.png", "/drop/d.xyz"], "background": true, "addToComp": true, "position": [10.0, 20.0]})).unwrap();
+    s.execute("jobs.wait", json!({})).unwrap();
+    assert_eq!(s.active_comp().unwrap().layers.iter().map(|l| l.name.as_str()).collect::<Vec<_>>(), ["c.png"]);
+    assert_eq!(s.job_log.last().unwrap().message, "Imported 1 item. /drop/d.xyz: unsupported file");
+    // Agents and scripts import at once by default.
+    let r = s.execute("file.import", json!({"paths": ["/drop/e.png"]})).unwrap();
+    assert_eq!(r["items"].as_array().map(Vec::len), Some(1));
+}
+
+/// #2573: New Composition From Footage (`file.import {newComp}`) makes one composition of what
+/// the import made, first file on top, at once or when the background job lands; an import that
+/// made nothing makes no comp.
+#[test]
+fn new_comp_from_footage_makes_a_comp_of_what_was_imported() {
+    use effectcraft_project::{Footage, FootageKind, ItemKind};
+    struct Probe;
+    impl crate::Importer for Probe {
+        fn probe(&self, path: &str) -> Result<Footage, String> {
+            if path.ends_with(".xyz") {
+                return Err("unsupported file".into());
+            }
+            Ok(Footage { path: path.into(), kind: FootageKind::Still, width: 64, height: 32, has_video: true, ..Default::default() })
+        }
+    }
+    let mut s = Session { importer: Some(std::sync::Arc::new(Probe)), ..Default::default() };
+    let comps = |s: &Session| s.project.items.values().filter(|i| matches!(i.kind, ItemKind::Comp(_))).count();
+    let layers = |s: &Session| s.active_comp().unwrap().layers.iter().map(|l| l.name.clone()).collect::<Vec<_>>();
+    // At once.
+    s.execute("file.import", json!({"paths": ["/drop/a.png", "/drop/b.xyz"], "newComp": true})).unwrap();
+    assert_eq!(comps(&s), 1);
+    assert_eq!(layers(&s), ["a.png"]);
+    assert_eq!((s.active_comp().unwrap().width, s.active_comp().unwrap().height), (64, 32));
+    // In the background: the job's own items, whatever is selected or active meanwhile; it takes
+    // precedence over `addToComp`.
+    s.execute("file.import", json!({"paths": ["/drop/c.png", "/drop/d.png"], "background": true, "newComp": true, "addToComp": true})).unwrap();
+    s.state.project_selection.clear();
+    s.execute("jobs.wait", json!({})).unwrap();
+    assert_eq!(comps(&s), 2);
+    assert_eq!(layers(&s), ["c.png", "d.png"]);
+    // Nothing imported: no comp, and the failure is reported.
+    s.execute("file.import", json!({"paths": ["/drop/e.xyz"], "background": true, "newComp": true})).unwrap();
+    s.execute("jobs.wait", json!({})).unwrap();
+    assert_eq!(comps(&s), 2);
+    assert!(s.job_log.last().unwrap().message.contains("unsupported file"));
+    let r = s.execute("file.import", json!({"paths": ["/drop/f.xyz"], "newComp": true})).unwrap();
+    assert_eq!(comps(&s), 2);
+    assert_eq!(r["errors"].as_array().map(Vec::len), Some(1));
+}
+
+/// Audio, Lock and Shy don't change pixels: toggling them keeps the cached layers (#103).
+#[test]
+fn audio_lock_and_shy_keep_cached_layers() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "C", "width": 160, "height": 90, "frameRate": 30, "duration": 1})).unwrap();
+    s.execute("layer.newSolid", json!({"color": "#3080ff", "width": 80, "height": 40})).unwrap();
+    s.execute("effect.apply", json!({"layer": "#1", "effect": "Gaussian Blur"})).unwrap();
+    s.execute("prop.set", json!({"layer": "#1", "path": "effects/#1/blurriness", "value": 12})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let t = s.time();
+    s.render(cid, t, Default::default());
+    let before = s.layer_cache.stats();
+    for sw in ["audio", "lock", "shy"] {
+        s.execute("layer.setSwitch", json!({"layers": ["#1"], "switch": sw, "value": sw != "audio"})).unwrap();
+    }
+    s.render(cid, t, Default::default());
+    let after = s.layer_cache.stats();
+    assert_eq!(after.misses, before.misses, "no layer rendered again");
+    assert!(after.hits > before.hits);
+}
+
+#[test]
+fn every_command_has_unique_id_and_runs_or_reports() {
+    let mut ids = std::collections::HashSet::new();
+    for c in crate::command_specs() {
+        assert!(ids.insert(c.id), "duplicate {}", c.id);
+    }
+    assert!(ids.len() >= 90, "{}", ids.len());
+}
+
+#[test]
+fn layer_workflow_with_undo() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Test", "width": 640, "height": 360, "frameRate": 30, "duration": 4})).unwrap();
+    let r = s.execute("layer.newSolid", json!({"color": "#336699"})).unwrap();
+    let lid = r["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": lid, "path": "transform/opacity", "value": 50})).unwrap();
+    let tree = s.execute("layer.tree", json!({"layer": lid})).unwrap();
+    assert!(tree.to_string().contains("\"value\":50.0"));
+    s.execute("prop.toggleAnimation", json!({"layer": lid, "path": "transform/position"})).unwrap();
+    s.execute("time.set", json!({"time": 2.0})).unwrap();
+    s.execute("prop.set", json!({"layer": lid, "path": "transform/position", "value": [100, 100]})).unwrap();
+    let comp = s.active_comp().unwrap();
+    let pos = comp.layers[0].props.prop("transform/position").unwrap();
+    assert_eq!(pos.keys.len(), 2);
+    s.execute("prop.select", json!({"layer": lid, "path": "transform/position"})).unwrap();
+    assert_eq!(s.state.selected_keys.len(), 2);
+    s.execute("keys.easyEase", json!({})).unwrap();
+    s.execute("keys.move", json!({"delta": 0.5})).unwrap();
+    let pos = s.active_comp().unwrap().layers[0].props.prop("transform/position").unwrap().clone();
+    assert!((pos.keys[0].time.seconds() - 0.5).abs() < 0.02);
+    assert_eq!(pos.keys[0].out_interp, effectcraft_keyframe::Interp::Bezier);
+    // undo back to before the move
+    s.execute("edit.undo", json!({})).unwrap();
+    let pos = s.active_comp().unwrap().layers[0].props.prop("transform/position").unwrap().clone();
+    assert!(pos.keys[0].time.seconds().abs() < 0.02);
+    s.execute("effect.apply", json!({"layer": lid, "effect": "Gaussian Blur"})).unwrap();
+    s.execute("prop.set", json!({"layer": lid, "path": "effects/#1/blurriness", "value": 12})).unwrap();
+    // Applying selects the new effect (Edit ▸ Duplicate would duplicate it); select the layer.
+    s.execute("layer.select", json!({"layers": [lid]})).unwrap();
+    s.execute("edit.duplicate", json!({})).unwrap();
+    assert_eq!(s.active_comp().unwrap().layers.len(), 2);
+    s.execute("layer.precompose", json!({"layers": [1, 2], "name": "Pre"})).unwrap();
+    assert_eq!(s.active_comp().unwrap().layers.len(), 1);
+}
+
+#[test]
+fn text_shape_mask_matte_parent() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 800, "height": 450, "duration": 3})).unwrap();
+    let t = s.execute("layer.newText", json!({"text": "Hello", "size": 90})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.addTextAnimator", json!({"layer": t, "properties": ["position", "opacity"]})).unwrap();
+    let sh = s.execute("layer.newShape", json!({"kind": "star", "fill": "#ffcc00"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.addShapeItem", json!({"layer": sh, "kind": "trim"})).unwrap();
+    s.execute("layer.addMask", json!({"layer": sh, "shape": "ellipse"})).unwrap();
+    s.execute("layer.setMask", json!({"layer": sh, "mask": 1, "mode": "Subtract", "inverted": true})).unwrap();
+    s.execute("layer.setTrackMatte", json!({"layer": sh, "matte": t, "kind": "luma"})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [sh], "parent": t})).unwrap();
+    assert!(s.execute("layer.setParent", json!({"layers": [t], "parent": sh})).is_err());
+    s.execute("layer.setBlendMode", json!({"layers": [sh], "mode": "Screen"})).unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [sh], "switch": "threeD"})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let _ = s.render(cid, s.time(), Default::default());
+    let info = s.execute("comp.info", json!({})).unwrap();
+    assert_eq!(info["layers"].as_array().unwrap().len(), 2);
+}
+
+/// The toolbar's Fill / Stroke change a selected shape layer's paint (#205): a shape drawn
+/// without a stroke gets one, later edits change it, and the Contents "Add:" items (#206) include
+/// an empty Path and a Gradient Stroke that render.
+#[test]
+fn toolbar_fill_and_stroke_paint_selected_shape_layers() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 400, "height": 300, "duration": 2})).unwrap();
+    let sh = s.execute("layer.newShape", json!({"kind": "rect", "fill": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
+    let paint = |s: &mut Session| s.execute("shape.fillStroke", json!({})).unwrap();
+    assert_eq!(paint(&mut s)["stroke"], serde_json::Value::Null, "drawn without a stroke");
+    s.execute("shape.fillStroke", json!({"stroke": "#00ff00", "strokeWidth": 6})).unwrap();
+    let p = paint(&mut s);
+    assert_eq!((p["stroke"][1].as_f64(), p["strokeWidth"].as_f64()), (Some(1.0), Some(6.0)), "{p}");
+    s.execute("shape.fillStroke", json!({"fill": "#0000ff", "strokeWidth": 3})).unwrap();
+    let p = paint(&mut s);
+    assert_eq!((p["fill"][2].as_f64(), p["strokeWidth"].as_f64()), (Some(1.0), Some(3.0)), "{p}");
+    // One stroke, before the fill (paths, stroke, fill), and each change is one undo step.
+    let l = s.active_comp().unwrap().layer(effectcraft_project::LayerId(sh)).unwrap().clone();
+    let group = l.props.group("contents/group").unwrap();
+    let order: Vec<&str> = group.sub("contents").unwrap().groups().map(|g| g.match_id.as_str()).collect();
+    assert_eq!(order, ["rect", "stroke", "fill"]);
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(paint(&mut s)["strokeWidth"].as_f64(), Some(6.0));
+    // Only shape layers.
+    s.execute("layer.newSolid", json!({"color": "#808080"})).unwrap();
+    assert!(s.execute("shape.fillStroke", json!({"fill": "#ffffff"})).is_err());
+    for kind in ["path", "gstroke"] {
+        let r = s.execute("layer.addShapeItem", json!({"layer": sh, "kind": kind})).unwrap();
+        assert!(r["path"].as_str().is_some_and(|p| p.starts_with("contents/")), "{r}");
+    }
+    let cid = s.active_comp_id().unwrap();
+    let _ = s.render(cid, s.time(), Default::default());
+}
+
+/// The toolbar/query width follows the selected solid or gradient stroke, including animation.
+#[test]
+fn shape_toolbar_reads_solid_and_gradient_stroke_widths_at_the_current_time() {
+    for kind in ["solid", "linear", "radial"] {
+        for (stretch, expected) in [(100.0, 17.0), (200.0, 13.0)] {
+            let mut s = Session::default();
+            s.execute("comp.new", json!({"width": 400, "height": 300, "duration": 2})).unwrap();
+            let layer = s.execute("layer.newShape", json!({"kind": "rect"})).unwrap()["layer"].as_u64().unwrap();
+            s.execute("layer.timeStretch", json!({"layer": layer, "percent": stretch})).unwrap();
+            let configured = s.execute("shape.fillStroke", json!({"fill": false, "strokeType": kind, "strokeWidth": 9})).unwrap();
+            assert_eq!(configured["strokeWidth"].as_f64(), Some(9.0), "configured {kind} stroke");
+            let group = if kind == "solid" { "stroke" } else { "gstroke" };
+            let path = format!("contents/group/contents/{group}/width");
+            for (time, width) in [(0, 9), (1, 17)] {
+                s.execute("prop.addKey", json!({"layer": layer, "path": path, "time": time, "timeBase": "layer", "value": width})).unwrap();
+            }
+            s.set_time(effectcraft_time::Tick::from_seconds_f64(1.0));
+            let displayed = s.execute("shape.fillStroke", json!({})).unwrap();
+            assert_eq!(displayed["strokeWidth"].as_f64(), Some(expected), "animated {kind} stroke at {stretch}% stretch");
+        }
+    }
+}
+
+/// A later solid stroke supplies color without overwriting the first gradient stroke's width.
+#[test]
+fn shape_toolbar_keeps_the_first_gradient_width_with_a_later_solid_stroke() {
+    for kind in ["linear", "radial"] {
+        let mut s = Session::default();
+        s.execute("comp.new", json!({"width": 400, "height": 300, "duration": 2})).unwrap();
+        let layer = s.execute("layer.newShape", json!({"kind": "rect"})).unwrap()["layer"].as_u64().unwrap();
+        s.execute("shape.fillStroke", json!({"strokeType": kind, "strokeWidth": 9})).unwrap();
+        s.execute("layer.addShapeItem", json!({"layer": layer, "group": "contents/group", "kind": "stroke"})).unwrap();
+        for (field, value) in [("color", json!([0.0, 1.0, 0.0, 1.0])), ("width", json!(99))] {
+            s.execute("prop.set", json!({"layer": layer, "path": format!("contents/group/contents/stroke/{field}"), "value": value})).unwrap();
+        }
+        for (time, width) in [(0, 9), (1, 17)] {
+            s.execute("prop.addKey", json!({"layer": layer, "path": "contents/group/contents/gstroke/width", "time": time, "value": width})).unwrap();
+        }
+        for (time, width) in [(0.0, 9.0), (1.0, 17.0)] {
+            s.set_time(effectcraft_time::Tick::from_seconds_f64(time));
+            let displayed = s.execute("shape.fillStroke", json!({})).unwrap();
+            assert_eq!(displayed["strokeWidth"].as_f64(), Some(width));
+            assert_eq!(displayed["stroke"], json!([0.0, 1.0, 0.0, 1.0]));
+        }
+    }
+}
+
+/// A Wiggle Paths saved without Spatial Phase gets the property, at 0°, after Temporal Phase when
+/// the project opens.
+#[test]
+fn opening_a_wiggle_paths_without_spatial_phase_adds_it() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 400, "height": 300, "duration": 2})).unwrap();
+    let sh = s.execute("layer.newShape", json!({"kind": "rect", "fill": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
+    let uid = s.execute("layer.addShapeItem", json!({"layer": sh, "kind": "wiggle"})).unwrap()["uid"].as_u64().unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let mut old = effectcraft_project::Project::from_json(&s.project.to_file_json().unwrap()).unwrap();
+    let l = old.comp_mut(cid).unwrap().layer_mut(effectcraft_project::LayerId(sh)).unwrap();
+    let g = l.props.find_group_mut(uid).unwrap();
+    g.children.retain(|c| c.match_id() != "spatialPhase");
+    assert_eq!(g.children.len(), 7);
+    let next = old.next_id;
+    s.replace_project(old, None);
+    let l = s.active_comp().unwrap().layer(effectcraft_project::LayerId(sh)).unwrap().clone();
+    let g = l.props.find_group(uid).unwrap();
+    let ids: Vec<&str> = g.children.iter().map(|c| c.match_id()).collect();
+    assert_eq!(ids, ["size", "detail", "points", "speed", "correlation", "phase", "spatialPhase", "seed"]);
+    let sp = g.get("spatialPhase").unwrap();
+    assert_eq!((sp.name.as_str(), &sp.value), ("Spatial Phase", &effectcraft_keyframe::Value::Scalar(0.0)));
+    assert!(sp.uid >= next && s.project.next_id > sp.uid, "a fresh uid: {} (next {next})", sp.uid);
+}
+
+/// The toolbar's Fill Options / Stroke Options change a selected shape layer's paint kind (#732):
+/// None switches the fill off, a gradient turns the Fill into a Gradient Fill that keeps its
+/// opacity, Solid Color turns it back, and a Stroke kind adds a stroke where there is none.
+#[test]
+fn toolbar_fill_and_stroke_kinds_change_selected_shape_layers() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 400, "height": 300, "duration": 2})).unwrap();
+    let sh = s.execute("layer.newShape", json!({"kind": "rect", "fill": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
+    let items = |s: &Session| -> Vec<(String, bool)> {
+        let l = s.active_comp().unwrap().layer(effectcraft_project::LayerId(sh)).unwrap();
+        l.props.group("contents/group/contents").unwrap().groups().map(|g| (g.match_id.clone(), g.enabled)).collect()
+    };
+    let kinds = |s: &mut Session| {
+        let p = s.execute("shape.fillStroke", json!({})).unwrap();
+        (p["fillType"].as_str().unwrap().to_string(), p["strokeType"].as_str().unwrap().to_string())
+    };
+    assert_eq!(kinds(&mut s), ("solid".into(), "none".into()));
+    let cid = s.active_comp_id().unwrap();
+    let centre = |s: &Session| s.render(cid, s.time(), Default::default()).get(200, 150);
+    let red = centre(&s);
+    // None switches the fill off: nothing is drawn, and the item stays.
+    s.execute("shape.fillStroke", json!({"fillType": "none"})).unwrap();
+    assert_eq!(items(&s), [("rect".into(), true), ("fill".into(), false)]);
+    assert_eq!(kinds(&mut s).0, "none");
+    assert_ne!(centre(&s), red, "the fill is off");
+    // A radial gradient: the Fill becomes a Gradient Fill (switched on) that keeps its opacity.
+    s.execute("shape.fillStroke", json!({"fillType": "solid", "fill": "#ff0000"})).unwrap();
+    assert_eq!(centre(&s), red);
+    let opacity = |s: &Session, m: &str| {
+        let l = s.active_comp().unwrap().layer(effectcraft_project::LayerId(sh)).unwrap();
+        l.props.group(&format!("contents/group/contents/{m}")).unwrap().get("opacity").unwrap().value.as_f64()
+    };
+    s.execute("prop.set", json!({"layer": sh, "path": "contents/group/contents/fill/opacity", "value": 40})).unwrap();
+    s.execute("shape.fillStroke", json!({"fillType": "radial"})).unwrap();
+    assert_eq!(items(&s), [("rect".into(), true), ("gfill".into(), true)]);
+    assert_eq!((kinds(&mut s).0.as_str(), opacity(&s, "gfill")), ("radial", 40.0));
+    s.execute("shape.fillStroke", json!({"fillType": "linear"})).unwrap();
+    assert_eq!(kinds(&mut s).0, "linear");
+    s.execute("shape.fillStroke", json!({"fillType": "solid", "fill": "#00ff00"})).unwrap();
+    assert_eq!(items(&s), [("rect".into(), true), ("fill".into(), true)]);
+    assert_eq!(opacity(&s, "fill"), 40.0);
+    // A Stroke kind adds a stroke (before the fill); None switches it off again; undo is per step.
+    s.execute("shape.fillStroke", json!({"strokeType": "linear"})).unwrap();
+    assert_eq!(items(&s), [("rect".into(), true), ("gstroke".into(), true), ("fill".into(), true)]);
+    s.execute("shape.fillStroke", json!({"strokeType": "none"})).unwrap();
+    assert_eq!(kinds(&mut s), ("solid".into(), "none".into()));
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(kinds(&mut s), ("solid".into(), "linear".into()));
+    assert!(s.execute("shape.fillStroke", json!({"fillType": "plaid"})).is_err());
+}
+
+/// Selecting a mask in the Timeline (its row or its Mask Path) selects all of its points, so the
+/// viewer drags the whole mask (#203); a shape's Path item works the same way.
+#[test]
+fn selecting_a_mask_selects_its_points() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 400, "height": 300, "duration": 2})).unwrap();
+    let l = s.execute("layer.newSolid", json!({"color": "#808080"})).unwrap()["layer"].as_u64().unwrap();
+    let m1 = s.execute("layer.addMask", json!({"layer": l, "shape": "rect"})).unwrap()["mask"].as_u64().unwrap();
+    let m2 = s.execute("layer.addMask", json!({"layer": l, "shape": "ellipse"})).unwrap()["mask"].as_u64().unwrap();
+    let points = |s: &Session, m: u64| s.state.selected_vertices.iter().filter(|v| v.mask == m).count();
+    s.execute("prop.select", json!({"layer": l, "prop": m1, "selectKeys": false})).unwrap();
+    assert_eq!((points(&s, m1), s.state.selected_vertices.len()), (4, 4));
+    // Mask Path selects them too; Shift-adding another mask keeps the first.
+    let path = s.active_comp().unwrap().layer(effectcraft_project::LayerId(l)).unwrap().props.find_group(m2).unwrap().get("path").unwrap().uid;
+    s.execute("prop.select", json!({"layer": l, "prop": path, "add": true})).unwrap();
+    assert_eq!((points(&s, m1), points(&s, m2)), (4, 4));
+    // Another mask replaces them; another property deselects them.
+    s.execute("prop.select", json!({"layer": l, "prop": m2})).unwrap();
+    assert_eq!((points(&s, m1), points(&s, m2)), (0, 4));
+    // Delete removes the selected mask (not only its points).
+    s.execute("edit.clear", json!({})).unwrap();
+    let masks = |s: &Session| s.active_comp().unwrap().layer(effectcraft_project::LayerId(l)).unwrap().masks().unwrap().children.len();
+    assert_eq!(masks(&s), 1);
+    s.execute("prop.select", json!({"layer": l, "path": "transform/opacity"})).unwrap();
+    assert!(s.state.selected_vertices.is_empty());
+    let sh = s.execute("layer.newShape", json!({"kind": "star"})).unwrap()["layer"].as_u64().unwrap();
+    let star = s.execute("layer.addShapeItem", json!({"layer": sh, "kind": "path"})).unwrap()["uid"].as_u64().unwrap();
+    s.execute("prop.select", json!({"layer": sh, "prop": star})).unwrap();
+    assert_eq!(s.state.selected_vertices.len(), 0, "an empty Path has no points");
+}
+
+#[test]
+fn save_and_open_roundtrip() {
+    let mut s = demo();
+    let dir = std::env::temp_dir().join(format!("ec-test-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("demo.ecproj").to_string_lossy().to_string();
+    s.execute("file.saveAs", json!({"path": path})).unwrap();
+    let before = s.project.clone();
+    let mut s2 = Session::default();
+    s2.execute("file.open", json!({"path": path})).unwrap();
+    assert_eq!(*before, *s2.project);
+    let _ = std::fs::remove_dir_all(dir);
+}
+
+#[test]
+fn help_links_emit_urls() {
+    let mut s = Session::default();
+    let r = s.execute("help.discord", json!({})).unwrap();
+    assert_eq!(r["url"], "https://discord.gg/artcraft");
+    assert!(s.drain_events().iter().any(|e| matches!(e, crate::Event::OpenUrl(u) if u.contains("discord"))));
+    assert_eq!(s.execute("help.github", json!({})).unwrap()["url"], "https://github.com/storytold/effectcraft");
+}
+
+/// Every Help ▸ documentation page opens a file that is in the repository (#2696: Expression Reference opened a 404).
+#[test]
+fn help_docs_pages_exist_in_the_repository() {
+    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
+    for page in [None, Some("help"), Some("scripting"), Some("expressions"), Some("effects"), Some("agents")] {
+        let mut s = Session::default();
+        let params = page.map_or_else(|| json!({}), |p| json!({"page": p}));
+        let url = s.execute("help.docs", params).unwrap()["url"].as_str().unwrap().to_owned();
+        let path = url.strip_prefix("https://github.com/storytold/effectcraft/blob/main/").unwrap_or_else(|| panic!("{page:?}: {url}"));
+        assert!(root.join(path).is_file(), "{page:?} opens {url}, which is not in the repository");
+    }
+}
+
+#[test]
+fn time_navigation() {
+    let mut s = demo();
+    s.execute("time.start", json!({})).unwrap();
+    let r = s.execute("time.nextKey", json!({})).unwrap();
+    assert!(r["time"].as_f64().unwrap() > 0.0);
+    s.execute("time.set", json!({"frame": 45})).unwrap();
+    assert_eq!(s.execute("time.step", json!({"frames": 5})).unwrap()["frame"], 50);
+}
+
+#[test]
+fn time_navigation_per_property() {
+    let mut s = demo();
+    // An animated property and the comp times of its keys.
+    let comp = s.active_comp().unwrap().clone();
+    let mut found = None;
+    for l in &comp.layers {
+        l.props.walk("", &mut |_, pr| {
+            if found.is_none() && pr.keys.len() >= 2 {
+                found = Some((pr.uid, pr.keys.iter().map(|k| l.comp_time(k.time)).collect::<Vec<_>>()));
+            }
+        });
+    }
+    let (uid, times) = found.expect("demo has an animated property");
+    s.set_time(effectcraft_time::Tick::ZERO);
+    let half = comp.frame_duration().0 / 2;
+    let expect = times.iter().copied().filter(|t| t.0 > half).min().unwrap();
+    s.execute("time.go", json!({"to": "nextKey", "prop": uid})).unwrap();
+    let snap = |t| comp.frame_rate.snap(t);
+    assert_eq!(s.time(), snap(expect));
+    // Going back from past the last key lands on the last key.
+    s.set_time(comp.duration);
+    s.execute("time.go", json!({"to": "prevKey", "prop": uid})).unwrap();
+    assert_eq!(s.time(), snap(*times.iter().max().unwrap()));
+}
+
+#[test]
+fn set_text_paragraph_fill_and_leading() {
+    use effectcraft_keyframe::{Justify, Value as KValue};
+    let mut s = demo();
+    let t = s.execute("layer.newText", json!({"text": "Hi"})).unwrap()["layer"].as_u64().unwrap();
+    let doc = |s: &Session| {
+        let l = s.active_comp().unwrap().layer(crate::project::LayerId(t)).unwrap().clone();
+        match &l.props.prop("text/sourceText").unwrap().value {
+            KValue::Text(d) => (**d).clone(),
+            v => panic!("{v:?}"),
+        }
+    };
+    for (key, j) in [
+        ("justifyLeft", Justify::JustifyLastLeft),
+        ("justifyCenter", Justify::JustifyLastCenter),
+        ("justifyRight", Justify::JustifyLastRight),
+        ("justifyAll", Justify::JustifyAll),
+        ("center", Justify::Center),
+    ] {
+        s.execute("layer.setText", json!({"layer": t, "justify": key})).unwrap();
+        assert_eq!(doc(&s).justify, j, "{key}");
+    }
+    s.execute("layer.setText", json!({"layer": t, "leading": 50, "applyFill": false, "applyStroke": true})).unwrap();
+    let d = doc(&s);
+    assert_eq!((d.leading, d.apply_fill, d.apply_stroke), (Some(50.0), false, true));
+    s.execute("layer.setText", json!({"layer": t, "leading": "auto"})).unwrap();
+    assert_eq!(doc(&s).leading, None);
+    s.execute("layer.setText", json!({"layer": t, "hScale": 120, "vScale": 80, "baselineShift": 4, "smallCaps": true, "strokeOverFill": true})).unwrap();
+    let d = doc(&s);
+    assert_eq!((d.h_scale, d.v_scale, d.baseline_shift, d.small_caps, d.stroke_over_fill), (120.0, 80.0, 4.0, true, true));
+    s.execute("layer.setText", json!({"layer": t, "lineJoin": "bevel"})).unwrap();
+    assert_eq!(doc(&s).line_join, effectcraft_keyframe::LineJoin::Bevel);
+    assert!(s.execute("layer.setText", json!({"layer": t, "lineJoin": "square"})).is_err());
+}
+
+#[test]
+fn property_groups_report_actionable_errors() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "T"})).unwrap();
+    let l = s.execute("layer.newText", json!({"text": "Hi"})).unwrap()["layer"].as_u64().unwrap();
+    let uid = s.active_comp().unwrap().layer(crate::project::LayerId(l)).unwrap().props.group("text/pathOptions").unwrap().uid;
+    for selector in [json!({"path": "text"}), json!({"path": "text/pathOptions"}), json!({"path": format!("@{uid}")}), json!({"prop": uid})] {
+        let mut params = selector;
+        params["layer"] = json!(l);
+        for cmd in ["prop.get", "prop.set"] {
+            let err = s.execute(cmd, params.clone()).unwrap_err().to_string();
+            assert!(err.contains("is a property group"), "{cmd}: {err}");
+            assert!(err.contains("get_layer"), "{cmd}: {err}");
+        }
+    }
+    assert!(s.execute("prop.get", json!({"layer": l, "path": "text/sourceText"})).is_ok());
+    let err = s.execute("prop.get", json!({"layer": l, "path": "missing"})).unwrap_err().to_string();
+    assert!(err.contains("no property `missing`"), "{err}");
+}
+
+#[test]
+fn prop_get_and_render_rgba8() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "T", "width": 320, "height": 180, "duration": 2.0, "frameRate": 30})).unwrap();
+    let l = s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.addKey", json!({"layer": l, "path": "transform/position", "time": 0.0, "value": [0, 0]})).unwrap();
+    s.execute("prop.addKey", json!({"layer": l, "path": "transform/position", "time": 1.0, "value": [100, 50]})).unwrap();
+    let v = s.execute("prop.get", json!({"layer": l, "path": "transform/position", "time": 1.0})).unwrap();
+    assert_eq!(v["animated"], true);
+    assert_eq!(v["keys"].as_array().unwrap().len(), 2);
+    assert_eq!(v["value"][0].as_f64().unwrap(), 100.0);
+    let cid = s.resolve_comp(Some(&json!("T"))).unwrap();
+    let (w, h, rgba) = s.render_rgba8(cid, effectcraft_time::Tick::ZERO, 160).unwrap();
+    assert_eq!((w, h), (160, 90));
+    assert_eq!(rgba.len(), (w * h * 4) as usize);
+}
+
+#[test]
+fn params_docs_parse() {
+    use crate::commands::accepted_params;
+    let k = |d: &str| accepted_params(d).unwrap();
+    assert_eq!(k("{layers: [id|name|#n], add?, toggle?}"), ["layers", "add", "toggle"]);
+    assert_eq!(k("{time? (s) | frame? | timecode?}"), ["time", "frame", "timecode"]);
+    assert_eq!(k("{interpolation?|in?|out?: linear|bezier|hold, autoBezier?}"), ["interpolation", "in", "out", "autoBezier"]);
+    assert_eq!(k("{keys: [{layer, prop, time}], add?}"), ["keys", "add"]);
+    assert_eq!(k("{label: Red|Yellow|Aqua|…, layers?}"), ["label", "layers"]);
+    assert_eq!(k("{name?, background? [r,g,b]|#hex, open?}"), ["name", "background", "open"]);
+    assert!(k("{}").is_empty());
+    assert!(accepted_params("free text").is_none());
+    // Every registered command documents its params as a parseable key list.
+    for c in crate::command_specs() {
+        assert!(accepted_params(c.params).is_some(), "{}: {}", c.id, c.params);
+    }
+}
+
+#[test]
+fn execute_checked_rejects_unknown_params() {
+    let mut s = demo();
+    let e = s.execute_checked("layer.select", json!({"index": 2})).unwrap_err().to_string();
+    assert!(e.contains("`index`") && e.contains("layers, add, toggle"), "{e}");
+    s.execute_checked("layer.select", json!({"layers": ["#2"]})).unwrap();
+    assert_eq!(s.state.selected_layers.len(), 1);
+    // Aliases and always-accepted keys.
+    s.execute_checked("layer.select", json!({"layer": "#1", "comp": s.active_comp_id().unwrap().0})).unwrap();
+    s.execute_checked("time.set", json!({"frame": 3})).unwrap();
+    assert!(s.execute_checked("edit.undo", json!({"steps": 2})).is_err());
+    // Non-object params are not validated; the unchecked path stays lenient.
+    s.execute("layer.select", json!({"layers": ["#1"], "index": 2})).unwrap();
+}
+
+#[test]
+fn layer_tree_paths_resolve() {
+    let mut s = demo();
+    s.execute("effect.apply", json!({"layer": 1, "effect": "Gaussian Blur"})).unwrap();
+    let comp = s.execute("comp.info", json!({})).unwrap();
+    let mut checked = 0;
+    for l in comp["layers"].as_array().unwrap() {
+        let tree = s.execute("layer.tree", json!({"layer": l["id"]})).unwrap();
+        let mut stack = vec![tree["properties"].clone()];
+        while let Some(n) = stack.pop() {
+            if let Some(ch) = n["children"].as_array() {
+                stack.extend(ch.iter().cloned());
+                continue;
+            }
+            let path = n["path"].as_str().unwrap();
+            let got = s.execute("prop.get", json!({"layer": l["id"], "path": path})).unwrap();
+            assert_eq!(got["uid"], n["uid"], "path {path} on layer {}", l["name"]);
+            checked += 1;
+        }
+    }
+    assert!(checked > 20, "{checked}");
+}
+
+#[test]
+fn comp_settings_anchor_start_timecode_renderer() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "A", "width": 100, "height": 100, "duration": 2.0})).unwrap();
+    let l = s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.addKey", json!({"layer": l, "path": "transform/position", "time": 0.0, "value": [10, 20]})).unwrap();
+    let pos = |s: &Session| {
+        let pr = s.active_comp().unwrap().layer(crate::project::LayerId(l)).unwrap().props.prop("transform/position").unwrap().clone();
+        pr.keys[0].value.components()
+    };
+    // Center anchor: grow by 100x50 → shift by half.
+    s.execute("comp.settings", json!({"width": 200, "height": 150})).unwrap();
+    assert_eq!(pos(&s)[..2], [60.0, 45.0]);
+    // Top-left anchor: no shift. Bottom-right: full shift.
+    s.execute("comp.settings", json!({"width": 300, "anchor": 0})).unwrap();
+    assert_eq!(pos(&s)[..2], [60.0, 45.0]);
+    s.execute("comp.settings", json!({"width": 200, "height": 100, "anchor": 8})).unwrap();
+    assert_eq!(pos(&s)[..2], [-40.0, -5.0]);
+    s.execute("comp.settings", json!({"startTimecode": "0:00:01:00", "renderer": "advanced3D"})).unwrap();
+    let c = s.active_comp().unwrap();
+    assert_eq!(c.display_start, c.frame_rate.tick_of(30));
+    assert_eq!(c.renderer, crate::project::Renderer::Advanced3D);
+}
+
+/// `advanced3D` is a value of `renderer`, not a key: comp.new / comp.settings don't advertise it
+/// in their schemas and reject it as unknown instead of ignoring it (#177).
+#[test]
+fn renderer_values_are_not_parameter_keys() {
+    let mut s = Session::default();
+    for (id, p) in [("comp.new", json!({"name": "A"})), ("comp.settings", json!({}))] {
+        let spec = crate::command_specs().iter().find(|c| c.id == id).unwrap();
+        let keys = crate::commands::accepted_params(spec.params).unwrap();
+        assert!(keys.contains(&"renderer".to_string()) && !keys.contains(&"advanced3D".to_string()), "{id}: {keys:?}");
+        let mut bad = p.clone();
+        bad["advanced3D"] = json!(true);
+        let e = s.execute_checked(id, bad).unwrap_err().to_string();
+        assert!(e.contains("unknown parameter(s) `advanced3D`"), "{id}: {e}");
+        let mut good = p;
+        good["renderer"] = json!("advanced3D");
+        s.execute_checked(id, good).unwrap();
+        assert_eq!(s.active_comp().unwrap().renderer, crate::project::Renderer::Advanced3D, "{id}");
+        s.execute("comp.renderer", json!({"renderer": "classic3d"})).unwrap();
+    }
+}
+
+#[test]
+fn comp_rejects_zero_and_negative_frame_rates() {
+    let mut s = Session::default();
+    for fps in [0.0, -30.0, 0.0001] {
+        assert!(s.execute("comp.new", json!({"frameRate": fps})).is_err(), "{fps}");
+    }
+    s.execute("comp.new", json!({"frameRate": 30, "duration": 1})).unwrap();
+    assert!(s.execute("comp.settings", json!({"frameRate": 0})).is_err());
+    assert_eq!(s.active_comp().unwrap().frame_rate, crate::time::FrameRate::FPS_30);
+}
+
+#[test]
+fn render_queue_add_accepts_documented_settings_when_checked() {
+    let mut s = demo();
+    let r = s.execute_checked(
+        "renderQueue.add",
+        json!({"format": "gif", "output": "/tmp/x.gif", "resolution": "quarter", "timeSpan": "custom", "start": 0.0, "end": 0.5, "quality": "draft", "loop": true}),
+    );
+    // Without an exporter the add itself still succeeds (rendering is what needs one).
+    assert!(r.is_ok(), "{r:?}");
+    assert!(s.execute_checked("renderQueue.add", json!({"bogus": 1})).is_err());
+}
+
+#[test]
+fn new_text_rejects_malformed_positions_without_creating_a_layer() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "C", "width": 64, "height": 64, "duration": 1})).unwrap();
+    for position in [json!([]), json!([10]), json!(["x", 20]), json!([null, 20])] {
+        let err = s.execute("layer.newText", json!({"text": "Hello", "position": position})).unwrap_err();
+        assert!(err.to_string().contains("position: [x, y]"), "{err}");
+        assert!(s.active_comp().unwrap().layers.is_empty());
+    }
+    s.execute("layer.newText", json!({"name": "Valid", "text": "Hello", "position": [10, 20]})).unwrap();
+    assert_eq!(s.active_comp().unwrap().layers[0].props.prop("transform/position").unwrap().value, effectcraft_keyframe::Value::Vec3([10.0, 20.0, 0.0]));
+    s.execute("layer.newText", json!({"text": "No explicit position"})).unwrap();
+    assert_eq!(s.active_comp().unwrap().layers.len(), 2);
+}
+
+/// The active comp and the open comp tabs are saved with the project and restored on open (#748).
+#[test]
+fn reopening_a_project_restores_its_active_comp() {
+    use effectcraft_project::ItemId;
+    let dir = std::env::temp_dir().join(format!("ec-test-748-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("view.ecproj").to_string_lossy().to_string();
+    let mut s = Session::default();
+    let a = s.execute("comp.new", json!({"name": "CompA"})).unwrap()["comp"].as_u64().unwrap();
+    let b = s.execute("comp.new", json!({"name": "CompB"})).unwrap()["comp"].as_u64().unwrap();
+    let c = s.execute("comp.new", json!({"name": "CompC"})).unwrap()["comp"].as_u64().unwrap();
+    s.execute("comp.open", json!({"comp": "CompB"})).unwrap();
+    s.state.open_comps.retain(|id| id.0 != c);
+    s.execute("file.saveAs", json!({"path": path})).unwrap();
+    let mut s2 = Session::default();
+    s2.execute("file.open", json!({"path": path})).unwrap();
+    assert_eq!(s2.state.active_comp, Some(ItemId(b)));
+    assert_eq!(s2.state.open_comps, vec![ItemId(a), ItemId(b)]);
+    assert!(!s2.is_dirty());
+
+    // A file from before the view was saved opens on its first comp, as it always did.
+    let text = std::fs::read_to_string(&path).unwrap();
+    let mut old: serde_json::Value = serde_json::from_str(&text).unwrap();
+    let obj = old.as_object_mut().unwrap();
+    obj.remove("activeComp");
+    obj.remove("openComps");
+    std::fs::write(&path, serde_json::to_string_pretty(&old).unwrap()).unwrap();
+    let mut s3 = Session::default();
+    s3.execute("file.open", json!({"path": path})).unwrap();
+    assert_eq!((s3.state.active_comp, s3.state.open_comps.clone()), (Some(ItemId(a)), vec![ItemId(a)]));
+
+    // Ids that no longer name a comp (edited by hand, or written by another tool) fall back.
+    obj_set(&mut old, json!(999), json!([999, b, "x"]));
+    std::fs::write(&path, serde_json::to_string_pretty(&old).unwrap()).unwrap();
+    let mut s4 = Session::default();
+    s4.execute("file.open", json!({"path": path})).unwrap();
+    assert_eq!((s4.state.active_comp, s4.state.open_comps.clone()), (Some(ItemId(b)), vec![ItemId(b)]));
+    obj_set(&mut old, json!(999), json!([]));
+    std::fs::write(&path, serde_json::to_string_pretty(&old).unwrap()).unwrap();
+    let mut s5 = Session::default();
+    s5.execute("file.open", json!({"path": path})).unwrap();
+    assert_eq!((s5.state.active_comp, s5.state.open_comps.clone()), (Some(ItemId(a)), vec![ItemId(a)]));
+
+    // XML copies carry it too.
+    let xml = dir.join("view.ecprojx").to_string_lossy().to_string();
+    s.execute("file.saveAs", json!({"path": xml})).unwrap();
+    let mut s6 = Session::default();
+    s6.execute("file.open", json!({"path": xml})).unwrap();
+    assert_eq!(s6.state.active_comp, Some(ItemId(b)));
+    let _ = std::fs::remove_dir_all(dir);
+
+    fn obj_set(v: &mut serde_json::Value, active: serde_json::Value, open: serde_json::Value) {
+        let o = v.as_object_mut().unwrap();
+        o.insert("activeComp".into(), active);
+        o.insert("openComps".into(), open);
+    }
+}
+
+/// Layer times are saved as exact ticks and read back unchanged, and each comp reopens at the
+/// current time it was saved at, not at 0, where a layer starting later shows nothing (#1714).
+#[test]
+fn reopening_a_project_restores_layer_times_and_current_time() {
+    use effectcraft_project::ItemId;
+    use effectcraft_time::{FrameRate, Tick};
+    let dir = std::env::temp_dir().join(format!("ec-test-1714-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("times.ecproj").to_string_lossy().to_string();
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "C", "width": 108, "height": 192, "duration": 60})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "crown"})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let comp = std::sync::Arc::make_mut(&mut s.project).comp_mut(cid).unwrap();
+    comp.frame_rate = FrameRate::FPS_59_94;
+    // The layer from the issue: 34f, 315f and 3033f at 59.94 fps.
+    let l = comp.layers.first_mut().unwrap();
+    (l.start_time, l.in_point, l.out_point) = (Tick(144_086_342_400), Tick(1_334_917_584_000), Tick(12_853_349_308_800));
+    s.execute("time.set", json!({"time": 6.0})).unwrap();
+    let t = s.time();
+    // A second comp keeps its own time.
+    let b = ItemId(s.execute("comp.new", json!({"name": "B"})).unwrap()["comp"].as_u64().unwrap());
+    s.execute("time.set", json!({"time": 2.0})).unwrap();
+    let tb = s.time();
+    s.execute("comp.open", json!({"comp": "C"})).unwrap();
+    s.execute("file.saveAs", json!({"path": path})).unwrap();
+
+    let mut s2 = Session::default();
+    s2.execute("file.open", json!({"path": path})).unwrap();
+    let l = s2.project.comp(cid).unwrap().layers.first().unwrap();
+    assert_eq!((l.start_time, l.in_point, l.out_point), (Tick(144_086_342_400), Tick(1_334_917_584_000), Tick(12_853_349_308_800)));
+    assert_eq!((s2.time(), s2.state.times.get(&b).copied()), (t, Some(tb)));
+    assert!(l.in_point <= s2.time() && s2.time() < l.out_point, "the layer shows at the reopened time");
+    assert!(!s2.is_dirty());
+
+    // Hand-edited times past the end or before the start land on the last or first frame.
+    let mut file: serde_json::Value = serde_json::from_str(&std::fs::read_to_string(&path).unwrap()).unwrap();
+    file["compTimes"] = json!({cid.0.to_string(): i64::MAX, b.0.to_string(): -5});
+    std::fs::write(&path, file.to_string()).unwrap();
+    let mut s3 = Session::default();
+    s3.execute("file.open", json!({"path": path})).unwrap();
+    let c = s3.project.comp(cid).unwrap();
+    assert_eq!(s3.time(), c.frame_rate.snap_nearest(c.duration - c.frame_duration()));
+    assert_eq!(s3.time(), c.frame_rate.snap_nearest(c.duration - c.frame_duration()));
+    assert_eq!(s3.state.times.get(&b).copied(), Some(Tick::ZERO));
+}
diff --git a/crates/engine/src/tests_settings.rs b/crates/engine/src/tests/settings.rs
similarity index 89%
rename from crates/engine/src/tests_settings.rs
rename to crates/engine/src/tests/settings.rs
index c35d4f3a4..5e38c90a3 100644
--- a/crates/engine/src/tests_settings.rs
+++ b/crates/engine/src/tests/settings.rs
@@ -71,6 +71,23 @@ fn prefs_migrate_old_layout_and_keep_unknown_keys() {
     assert_eq!(Prefs::from_json("not json"), Prefs::default());
 }
 
+#[test]
+fn prefs_migrate_old_disk_cache_default() {
+    // The old 100 GB default becomes 20 GB; a size the user chose stays (#2551).
+    assert_eq!(Prefs::from_json(r#"{"version": 2, "disk": {"diskCacheMaxGb": 100}}"#).disk.disk_cache_max_gb, 20);
+    assert_eq!(Prefs::from_json(r#"{"version": 2, "disk": {"diskCacheMaxGb": 50}}"#).disk.disk_cache_max_gb, 50);
+    assert_eq!(Prefs::from_json(r#"{"version": 3, "disk": {"diskCacheMaxGb": 100}}"#).disk.disk_cache_max_gb, 100);
+}
+
+#[test]
+fn prefs_migrate_old_split_layers_default() {
+    // Settings saved before #2083 kept "below"; they move to After Effects' "above" once (#2545).
+    let above = |doc: &str| Prefs::from_json(doc).general.create_split_layers_above;
+    assert!(above(r#"{"version": 3, "general": {"createSplitLayersAbove": false}}"#));
+    assert!(above(r#"{"version": 2, "general": {"createSplitLayersAbove": false}}"#));
+    assert!(!above(r#"{"version": 4, "general": {"createSplitLayersAbove": false}}"#), "a choice made since stays");
+}
+
 #[test]
 fn prefs_set_validates_keys_types_and_ranges() {
     let mut p = Prefs::default();
@@ -181,7 +198,7 @@ fn every_schema_key_exists_and_docs_list_the_todo_settings() {
             assert!(ids.contains(&page), "{path:?} opens unknown page {page}");
         }
     }
-    let docs = include_str!("../../../docs/preferences.md");
+    let docs = include_str!("../../../../docs/preferences.md");
     for k in crate::prefs::todo_keys() {
         assert!(docs.contains(&format!("`{k}`")), "docs/preferences.md must list the not-yet-wired setting `{k}`");
     }
@@ -381,6 +398,23 @@ fn new_project_template_and_default_renderer() {
     let _ = std::fs::remove_dir_all(d);
 }
 
+#[test]
+fn project_files_are_indented_unless_compact_is_on() {
+    let d = tmp("compact-project-files");
+    let path = d.join("p.ecproj");
+    let mut s = session_with_comp();
+    s.execute("file.saveAs", json!({"path": path.to_string_lossy()})).unwrap();
+    let pretty = std::fs::read_to_string(&path).unwrap();
+    assert!(pretty.starts_with("{\n  \"savedBy\""), "indented by default");
+    s.execute("prefs.set", json!({"key": "project.compactProjectFiles", "value": true})).unwrap();
+    s.execute("file.saveAs", json!({"path": path.to_string_lossy()})).unwrap();
+    let compact = std::fs::read_to_string(&path).unwrap();
+    assert!(!compact.contains('\n'), "one line when Save Compact Project Files is on");
+    let open = |text: &str| effectcraft_project::Project::from_json(text).unwrap();
+    assert_eq!(open(&compact), open(&pretty), "both read back as the same project");
+    let _ = std::fs::remove_dir_all(d);
+}
+
 // ---------------------------------------------------------------- shortcuts
 
 #[test]
@@ -563,8 +597,8 @@ fn shortcut_presets_duplicate_rename_delete_export_import() {
 fn frontend_commands_are_bindable_with_panel_scope() {
     let mut s = Session::default();
     s.set_ui_commands(vec![
-        crate::shortcuts::UiCommand { id: "timeline.zoomIn".into(), label: "Zoom In Time".into(), shortcut: Some("=".into()) },
-        crate::shortcuts::UiCommand { id: "tool.hand".into(), label: "Hand Tool".into(), shortcut: Some("H".into()) },
+        crate::shortcuts::UiCommand { id: "timeline.zoomIn".into(), label: "Zoom In Time".into(), shortcut: Some("=".into()), scope: None },
+        crate::shortcuts::UiCommand { id: "tool.hand".into(), label: "Hand Tool".into(), shortcut: Some("H".into()), scope: None },
     ]);
     let b = s.shortcuts().find("timeline.zoomIn").unwrap().clone();
     assert_eq!(b.scope, "Timeline");
@@ -572,6 +606,49 @@ fn frontend_commands_are_bindable_with_panel_scope() {
     // A panel shortcut conflicts with an application shortcut on the same keys.
     let c = s.shortcuts().conflicts(&b, "H");
     assert!(c.iter().any(|c| c.key == "tool.hand"));
+    // A registry command that only the Project panel runs is scoped to it.
+    assert_eq!(s.shortcuts().find("project.deleteWithoutConfirmation").unwrap().scope, "Project");
+}
+
+/// The binding that runs a key press: the narrowest scope; a physical binding at the same rank;
+/// nothing when two other panels (or two active contexts) claim it at the same rank.
+#[test]
+fn shortcut_dispatch_picks_the_narrowest_scope_deterministically() {
+    use crate::shortcuts::pick;
+    // Two unrelated panels, neither focused: neither runs, in either order.
+    let both = [("Project", false, "delete"), ("RenderQueue", false, "duplicate")];
+    assert_eq!(pick(both, "Timeline", &[]), Err(vec!["Project".to_string(), "RenderQueue".into()]));
+    assert_eq!(pick([both[1], both[0]], "Timeline", &[]), Err(vec!["RenderQueue".to_string(), "Project".into()]));
+    // The focused one of them wins.
+    assert_eq!(pick(both, "RenderQueue", &[]), Ok(Some("duplicate")));
+    // A single other panel's shortcut runs when nothing nearer claims the chord.
+    assert_eq!(pick([("Project", false, "delete")], "Timeline", &[]), Ok(Some("delete")));
+    // An application binding beats an unrelated panel's binding, also a physical one.
+    assert_eq!(pick([("RenderQueue", true, "duplicate"), ("Application", false, "app")], "Timeline", &[]), Ok(Some("app")));
+    // At the same rank a physical binding wins, in either order.
+    assert_eq!(pick([("Application", false, "logical"), ("Application", true, "physical")], "Timeline", &[]), Ok(Some("physical")));
+    assert_eq!(pick([("Application", true, "physical"), ("Application", false, "logical")], "Timeline", &[]), Ok(Some("physical")));
+    // A Composition binding runs in the Composition panel over the application's.
+    assert_eq!(pick([("Application", false, "app"), ("Composition", false, "comp")], "Composition", &[]), Ok(Some("comp")));
+    // Two active contexts tie; an inactive one doesn't run.
+    assert_eq!(pick([("Mask", false, "mask"), ("Paint", false, "paint")], "Composition", &["Paint", "Mask"]), Err(vec!["Mask".to_string(), "Paint".into()]));
+    assert_eq!(pick([("Mask", false, "mask"), ("Paint", false, "paint")], "Composition", &["Paint"]), Ok(Some("paint")));
+    // The same scope twice (a reported conflict): the first one.
+    assert_eq!(pick([("Timeline", false, "a"), ("Timeline", false, "b")], "Timeline", &[]), Ok(Some("a")));
+}
+
+/// Two contexts can be active at once, so their shortcuts on the same keys conflict.
+#[test]
+fn context_shortcuts_on_the_same_keys_conflict() {
+    let mut s = Session::default();
+    s.set_ui_commands(vec![
+        crate::shortcuts::UiCommand { id: "test.mask".into(), label: "Mask".into(), shortcut: Some("F9".into()), scope: Some("Mask".into()) },
+        crate::shortcuts::UiCommand { id: "test.paint".into(), label: "Paint".into(), shortcut: Some("F9".into()), scope: Some("Paint".into()) },
+    ]);
+    let t = s.shortcuts();
+    assert!(t.all_conflicts().iter().any(|(a, c)| a == "test.mask" && c.key == "test.paint" && !c.overrides), "{:?}", t.all_conflicts());
+    let b = t.find("test.mask").unwrap();
+    assert!(t.conflicts(b, "F9").iter().any(|c| c.key == "test.paint" && !c.overrides));
 }
 
 // ---------------------------------------------------------------- auto-save / recovery
@@ -1064,6 +1141,14 @@ fn interface_language_is_validated_persisted_and_backward_compatible() {
     cs.load_settings();
     assert_eq!(cs.prefs.general.language, "cs");
     assert_eq!(Prefs::from_json(r#"{"general":{"language":"cs"}}"#).general.language, "cs");
+    // Polish, likewise.
+    assert!(crate::prefs::LANGUAGES.contains(&("Polski", "pl")));
+    s.execute("prefs.set", json!({"key": "general.language", "value": "pl"})).unwrap();
+    assert_eq!(s.execute("prefs.get", json!({"key": "general.language"})).unwrap(), json!("pl"));
+    let mut pl = Session { config: Some(store.clone()), ..Default::default() };
+    pl.load_settings();
+    assert_eq!(pl.prefs.general.language, "pl");
+    assert_eq!(Prefs::from_json(r#"{"general":{"language":"pl"}}"#).general.language, "pl");
     // Georgian too.
     assert!(crate::prefs::LANGUAGES.contains(&("ქართული", "ka")));
     s.execute("prefs.set", json!({"key": "general.language", "value": "ka"})).unwrap();
@@ -1081,6 +1166,23 @@ fn interface_language_is_validated_persisted_and_backward_compatible() {
     assert_eq!(Prefs::from_json(r#"{"general":{"language":"en"}}"#).general.language, "en", "a chosen language stays");
 }
 
+/// Swedish is stored as `sv` rather than a locale tag, and persists like every other catalog.
+#[test]
+fn swedish_interface_language_is_validated_and_persisted() {
+    let store = Arc::new(MemoryConfig::default());
+    let mut s = Session { config: Some(store.clone()), ..Default::default() };
+    assert!(crate::prefs::LANGUAGES.contains(&("Svenska", "sv")));
+    for value in ["sv-SE", "sv_SE", "SV"] {
+        assert!(s.execute("prefs.set", json!({"key": "general.language", "value": value})).is_err(), "{value}");
+    }
+    s.execute("prefs.set", json!({"key": "general.language", "value": "sv"})).unwrap();
+    assert_eq!(s.execute("prefs.get", json!({"key": "general.language"})).unwrap(), json!("sv"));
+    let mut sv = Session { config: Some(store), ..Default::default() };
+    sv.load_settings();
+    assert_eq!(sv.prefs.general.language, "sv");
+    assert_eq!(Prefs::from_json(r#"{"general":{"language":"sv"}}"#).general.language, "sv");
+}
+
 #[test]
 fn unicode_label_colors_fall_back_without_panicking() {
     use effectcraft_color::Label;
diff --git a/crates/engine/src/tests/shared_layers.rs b/crates/engine/src/tests/shared_layers.rs
new file mode 100644
index 000000000..275fdd624
--- /dev/null
+++ b/crates/engine/src/tests/shared_layers.rs
@@ -0,0 +1,42 @@
+//! An edit copies only the layer it changes: the others stay shared with the undo state, so an
+//! edit's cost doesn't grow with the size of the comp (scripts setting many keys went quadratic).
+
+use std::sync::Arc;
+
+use serde_json::json;
+
+use crate::Session;
+
+#[test]
+fn a_key_on_one_layer_leaves_the_other_layers_shared_with_undo() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Big", "duration": 10, "frameRate": 30})).unwrap();
+    let ids: Vec<u64> = (0..20).map(|i| s.execute("layer.newNull", json!({"name": format!("N{i}")})).unwrap()["layer"].as_u64().unwrap()).collect();
+    let cid = s.active_comp_id().unwrap();
+    let before = s.project.clone();
+    s.execute("prop.addKey", json!({"layer": ids[7], "path": "transform/position", "time": 1.0, "value": [5, 5]})).unwrap();
+    let (old, new) = (before.comp(cid).unwrap(), s.project.comp(cid).unwrap());
+    assert_eq!(old.layers.len(), new.layers.len());
+    let edited = new.layers.iter().position(|l| l.id.0 == ids[7]).unwrap();
+    for i in 0..new.layers.len() {
+        assert_eq!(new.layers.same_at(&old.layers, i), i != edited, "layer {i} shared: {}", new.layers.same_at(&old.layers, i));
+    }
+    // Undo brings back the very same state, and the edited layer is the only one that differed.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(Arc::ptr_eq(&s.project, &before));
+}
+
+#[test]
+fn layers_save_and_load_as_a_plain_list() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Round trip", "duration": 5, "frameRate": 25})).unwrap();
+    for i in 0..3 {
+        s.execute("layer.newNull", json!({"name": format!("N{i}")})).unwrap();
+    }
+    let cid = s.active_comp_id().unwrap();
+    let comp = s.project.comp(cid).unwrap();
+    let text = serde_json::to_value(&comp.layers).unwrap();
+    assert_eq!(text.as_array().map(Vec::len), Some(3), "a JSON array of layers, as before");
+    let back: effectcraft_project::Layers = serde_json::from_value(text).unwrap();
+    assert_eq!(&back, &comp.layers);
+}
diff --git a/crates/engine/src/tests_shortcut_cmds.rs b/crates/engine/src/tests/shortcut_cmds.rs
similarity index 88%
rename from crates/engine/src/tests_shortcut_cmds.rs
rename to crates/engine/src/tests/shortcut_cmds.rs
index dd306ef93..c11885db1 100644
--- a/crates/engine/src/tests_shortcut_cmds.rs
+++ b/crates/engine/src/tests/shortcut_cmds.rs
@@ -184,6 +184,28 @@ fn in_and_out_points_stretch_to_the_current_time() {
     assert!(s.execute("layer.timeStretch", json!({"to": "middle"})).is_err());
 }
 
+#[test]
+fn trimming_out_to_the_playhead_keeps_its_frame_visible() {
+    let (mut s, ids) = session([(1.0, 9.0); 3]);
+    let frame = 1.0 / 30.0;
+    // Alt+] at 4 s: the Out edge lands one frame after the playhead, so 4 s is the layer's last
+    // visible frame — it must not be cut away at the playhead (as in After Effects).
+    s.execute("time.set", json!({"time": 4.0})).unwrap();
+    s.execute("layer.timing", json!({"layers": [ids[0]], "op": "trimOutToTime"})).unwrap();
+    assert!((span(&s, ids[0]).1 - (4.0 + frame)).abs() < 1e-9, "{:?}", span(&s, ids[0]));
+    // Alt+[ at 2 s: the playhead's frame becomes the layer's first visible one.
+    s.execute("time.set", json!({"time": 2.0})).unwrap();
+    s.execute("layer.timing", json!({"layers": [ids[1]], "op": "trimInToTime"})).unwrap();
+    assert!((span(&s, ids[1]).0 - 2.0).abs() < 1e-9, "{:?}", span(&s, ids[1]));
+    // Trimmed before the In point, the Out point keeps one frame of layer.
+    s.execute("time.set", json!({"time": 0.5})).unwrap();
+    s.execute("layer.timing", json!({"layers": [ids[2]], "op": "trimOutToTime"})).unwrap();
+    assert!((span(&s, ids[2]).1 - (1.0 + frame)).abs() < 1e-9, "{:?}", span(&s, ids[2]));
+    // One undo step back to the original span.
+    assert!(s.undo());
+    assert!((span(&s, ids[2]).1 - 9.0).abs() < 1e-9);
+}
+
 #[test]
 fn masks_are_stepped_through_and_wrap() {
     let (mut s, ids) = session([(0.0, 10.0); 3]);
diff --git a/crates/engine/src/tests_stubs.rs b/crates/engine/src/tests/stubs.rs
similarity index 88%
rename from crates/engine/src/tests_stubs.rs
rename to crates/engine/src/tests/stubs.rs
index 84321ee7e..087a4ae1a 100644
--- a/crates/engine/src/tests_stubs.rs
+++ b/crates/engine/src/tests/stubs.rs
@@ -519,9 +519,10 @@ fn convert_to_bezier_turns_a_parametric_shape_into_an_editable_path() {
     };
     let radius = |v: [f64; 2]| v[0].hypot(v[1]);
 
-    // A 120 x 80 rectangle is its four corners, joined by straight edges.
+    // A 120 x 80 rectangle is its four corners, joined by straight edges, from the top-right
+    // corner clockwise as After Effects draws it.
     let (mut s, l, was, rect) = convert(json!({"kind": "rect", "size": [120, 80]}));
-    assert_eq!(rect.vertices, vec![[-60.0, -40.0], [60.0, -40.0], [60.0, 40.0], [-60.0, 40.0]]);
+    assert_eq!(rect.vertices, vec![[60.0, -40.0], [60.0, 40.0], [-60.0, 40.0], [-60.0, -40.0]]);
     assert!(rect.in_tangents.iter().chain(&rect.out_tangents).all(|t| *t == [0.0, 0.0]), "straight edges: {rect:?}");
     // Undo brings the parametric shape back.
     s.execute("edit.undo", json!({})).unwrap();
@@ -583,3 +584,86 @@ fn convert_to_bezier_reads_the_shape_as_it_is_set() {
     let mid = |v: &[f64]| (v.iter().copied().fold(f64::MAX, f64::min) + v.iter().copied().fold(f64::MIN, f64::max)) / 2.0;
     assert!((mid(&xs) - 10.0).abs() < 1e-6 && (mid(&ys) - 5.0).abs() < 1e-6, "centred on the position: {:?} {:?}", mid(&xs), mid(&ys));
 }
+
+/// #1896: Convert To Bezier Path reads Per-Corner Roundness, not just the uniform Roundness, so
+/// the editable path is the shape that was on screen.
+#[test]
+fn convert_to_bezier_honours_per_corner_roundness() {
+    let mut s = comp();
+    let l = s.execute("layer.newShape", json!({"kind": "rect", "size": [120, 80]})).unwrap()["layer"].as_u64().unwrap();
+    let (uid, _) = first_shape(&s, l);
+    let uid_of = |s: &Session, id: &str| layer(s, l).props.sub("contents").unwrap().find_group(uid).unwrap().get(id).unwrap().uid;
+    let per_corner = uid_of(&s, "perCorner");
+    let top_left = uid_of(&s, "topLeftRoundness");
+    let bottom_right = uid_of(&s, "bottomRightRoundness");
+    for (u, v) in [(per_corner, json!(true)), (top_left, json!(20.0)), (bottom_right, json!(10.0))] {
+        s.execute("prop.set", json!({"layer": l, "path": format!("@{u}"), "value": v})).unwrap();
+    }
+
+    s.state.selected_props = vec![(LayerId(l), uid)];
+    s.execute("path.convertToBezier", json!({})).unwrap();
+    let (new_uid, now) = first_shape(&s, l);
+    assert_eq!(now, "path");
+    let path = shape_path_of(&s, l, new_uid);
+    let expected = effectcraft_path::from_kurbo(&effectcraft_path::rect_radii([120.0, 80.0], [0.0, 0.0], [20.0, 0.0, 10.0, 0.0])).into_iter().next().unwrap();
+    assert_eq!(path, expected, "the converted path has the per-corner geometry");
+}
+
+/// #1896: Convert To Bezier Path evaluates the shape's expressions, so an expression-driven
+/// Per-Corner checkbox and radius convert to the geometry on screen.
+#[test]
+fn convert_to_bezier_evaluates_corner_expressions() {
+    struct Corners;
+    impl effectcraft_render::ExprHost for Corners {
+        fn eval(
+            &self,
+            _: &effectcraft_render::EvalCtx,
+            _: &effectcraft_project::Layer,
+            prop: &effectcraft_project::Property,
+            value: &KV,
+        ) -> std::result::Result<KV, String> {
+            Ok(match prop.match_id.as_str() {
+                "perCorner" => KV::Bool(true),
+                "topLeftRoundness" => KV::Scalar(20.0),
+                _ => value.clone(),
+            })
+        }
+    }
+
+    let mut s = comp();
+    s.expr = Some(Arc::new(Corners));
+    let l = s.execute("layer.newShape", json!({"kind": "rect", "size": [120, 80]})).unwrap()["layer"].as_u64().unwrap();
+    let (uid, _) = first_shape(&s, l);
+    let uid_of = |s: &Session, id: &str| layer(s, l).props.sub("contents").unwrap().find_group(uid).unwrap().get(id).unwrap().uid;
+    for (id, expression) in [("perCorner", "true"), ("topLeftRoundness", "20")] {
+        let u = uid_of(&s, id);
+        s.execute("prop.setExpression", json!({"layer": l, "path": format!("@{u}"), "expression": expression})).unwrap();
+    }
+
+    s.state.selected_props = vec![(LayerId(l), uid)];
+    s.execute("path.convertToBezier", json!({})).unwrap();
+    let (new_uid, now) = first_shape(&s, l);
+    assert_eq!(now, "path");
+    let path = shape_path_of(&s, l, new_uid);
+    let expected = effectcraft_path::from_kurbo(&effectcraft_path::rect_radii([120.0, 80.0], [0.0, 0.0], [20.0, 0.0, 0.0, 0.0])).into_iter().next().unwrap();
+    assert_eq!(path, expected, "the expression-evaluated corner is converted");
+}
+
+/// #2201: a viewer drag on the free-transform box sends one `path.freeTransform` per frame with a
+/// shared merge key; one undo must revert the whole drag, not the last frame.
+#[test]
+fn free_transform_drag_undoes_in_one_step() {
+    let mut s = comp();
+    let (l, m) = masked(&mut s);
+    s.state.selected_vertices.clear();
+    let before = mask_path(&s, l, m);
+    for k in [90, 90, 90, 90] {
+        s.execute("path.freeTransform", json!({"layer": l, "scale": k, "merge": "viewer-drag-1"})).unwrap();
+    }
+    let after = mask_path(&s, l, m);
+    assert_ne!(after, before);
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(mask_path(&s, l, m), before, "one undo reverts the whole drag");
+    s.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(mask_path(&s, l, m), after, "redo restores the whole drag");
+}
diff --git a/crates/engine/src/tests_styles.rs b/crates/engine/src/tests/styles.rs
similarity index 66%
rename from crates/engine/src/tests_styles.rs
rename to crates/engine/src/tests/styles.rs
index e589241fb..1aef9e825 100644
--- a/crates/engine/src/tests_styles.rs
+++ b/crates/engine/src/tests/styles.rs
@@ -117,3 +117,51 @@ fn styles_render_and_round_trip() {
     assert_eq!(back, *s.project);
     assert_eq!(back.comp(cid).unwrap().global_light.angle.value.as_f64(), 33.0);
 }
+
+/// #1389: Blending Options on a layer with no styles. `layer.style.add` with `blendingOptions`
+/// creates the Layer Styles group with Blending Options only; with the same merge key as the
+/// value set right after it, both are one undo step, and undoing it leaves no group behind.
+#[test]
+fn blending_options_alone_create_the_group_in_one_undo_step() {
+    let (mut s, a, b) = session();
+    let undo = s.history.undo.len();
+    let r = s.execute("layer.style.add", json!({"layers": [a], "style": "blendingOptions", "merge": "bo"})).unwrap();
+    assert_eq!(r["styles"][0]["style"], "blendingOptions", "{r}");
+    let layer = s.active_comp().unwrap().layer(effectcraft_project::LayerId(a)).unwrap().clone();
+    let g = layer.layer_styles().expect("the group is created");
+    assert!(g.sub("blendingOptions").is_some());
+    assert!(styles_of(&s, a).is_empty(), "no style is added with it");
+    s.execute("prop.set", json!({"layer": a, "path": "layerStyles/blendingOptions/advancedBlending/fillOpacity", "value": 40, "merge": "bo"})).unwrap();
+    s.execute("prop.set", json!({"layer": a, "path": "layerStyles/blendingOptions/advancedBlending/fillOpacity", "value": 30, "merge": "bo"})).unwrap();
+    assert_eq!(s.history.undo.len(), undo + 1, "creating the group and setting the value are one step");
+    // The other layer is untouched, and Global Light is the comp's.
+    assert!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(b)).unwrap().layer_styles().is_none());
+    let gl = s.execute("prop.get", json!({"layer": a, "path": "layerStyles/blendingOptions/globalLightAngle"})).unwrap();
+    assert!(gl.to_string().contains("120"), "{gl}");
+    s.execute("edit.undo", json!({})).unwrap();
+    assert!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(a)).unwrap().layer_styles().is_none(), "one undo removes the group");
+    // By display name too.
+    s.execute("layer.style.add", json!({"layers": [a], "style": "Blending Options"})).unwrap();
+    assert!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(a)).unwrap().layer_styles().is_some());
+}
+
+/// Removing the last style keeps a Layer Styles group whose Blending Options were changed (a
+/// group with Blending Options only is a state of its own since #1389); at their defaults the
+/// group goes, as before.
+#[test]
+fn removing_the_last_style_keeps_changed_blending_options() {
+    let (mut s, a, b) = session();
+    let fill = "layerStyles/blendingOptions/advancedBlending/fillOpacity";
+    s.execute("layer.style.add", json!({"layers": [a], "style": "blendingOptions"})).unwrap();
+    s.execute("prop.set", json!({"layer": a, "path": fill, "value": 40})).unwrap();
+    s.execute("layer.style.dropShadow", json!({"layers": [a]})).unwrap();
+    s.execute("layer.style.remove", json!({"layer": a, "style": "dropShadow"})).unwrap();
+    let v = s.execute("prop.get", json!({"layer": a, "path": fill})).unwrap();
+    assert_eq!(v["value"].as_f64(), Some(40.0), "{v}");
+    assert!(styles_of(&s, a).is_empty());
+    // At the defaults (here on the other layer, through the same command) the group goes.
+    s.execute("layer.style.add", json!({"layers": [b], "style": "blendingOptions"})).unwrap();
+    s.execute("layer.style.dropShadow", json!({"layers": [b]})).unwrap();
+    s.execute("layer.style.remove", json!({"layer": b, "style": "dropShadow"})).unwrap();
+    assert!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(b)).unwrap().layer_styles().is_none());
+}
diff --git a/crates/engine/src/tests_tail.rs b/crates/engine/src/tests/tail.rs
similarity index 83%
rename from crates/engine/src/tests_tail.rs
rename to crates/engine/src/tests/tail.rs
index 2710365eb..90cfd1bfc 100644
--- a/crates/engine/src/tests_tail.rs
+++ b/crates/engine/src/tests/tail.rs
@@ -421,6 +421,70 @@ fn camera_focus_commands_undo_and_serde() {
     assert!(s.execute("camera.linkFocusToPoi", json!({})).is_ok());
 }
 
+/// Set Focus Distance to Layer: degenerate targets (behind the camera, exactly at it) are clean
+/// errors, and a depth-of-field frame renders right after the command.
+#[test]
+fn camera_set_focus_to_layer_degenerate_targets_and_dof_frame() {
+    let mut s = comp(400, 300);
+    let t = s.execute("layer.newSolid", json!({"color": "#ffffff", "width": 50, "height": 50})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [t], "switch": "threeD", "value": true})).unwrap();
+    let cam = s.execute("layer.newCamera", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": cam, "path": "transform/position", "value": [200, 150, -500]})).unwrap();
+    s.execute("prop.set", json!({"layer": cam, "path": "cameraOptions/dof", "value": true})).unwrap();
+    s.execute("layer.select", json!({"layers": [cam, t]})).unwrap();
+    // Behind the camera (which now sits at z = −500 looking towards +z).
+    s.execute("layer.setTransform", json!({"layer": t, "prop": "position", "value": [200, 150, -1000]})).unwrap();
+    let e = s.execute("camera.setFocusToLayer", json!({})).unwrap_err().to_string();
+    assert!(e.contains("behind the camera"), "{e}");
+    // Exactly at the camera: depth 0, still a clean error.
+    s.execute("layer.setTransform", json!({"layer": t, "prop": "position", "value": [200, 150, -500]})).unwrap();
+    assert!(s.execute("camera.setFocusToLayer", json!({})).is_err());
+    // In front: the command works, and the depth-of-field frame renders with finite pixels.
+    s.execute("layer.setTransform", json!({"layer": t, "prop": "position", "value": [200, 150, 400]})).unwrap();
+    let d = s.execute("camera.setFocusToLayer", json!({})).unwrap()["focusDistance"].as_f64().unwrap();
+    assert!((d - 900.0).abs() < 1e-6, "{d}");
+    // An out-of-focus 3D layer, which must visibly blur, and a 0%-scaled one, whose pixels cover
+    // ~0 screen pixels and so turn an ordinary defocus into a radius of ~1e9 buffer pixels.
+    s.execute("prop.set", json!({"layer": cam, "path": "cameraOptions/aperture", "value": 120})).unwrap();
+    let blur = s.execute("layer.newSolid", json!({"color": "#00ff00", "width": 60, "height": 60})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [blur], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.setTransform", json!({"layer": blur, "prop": "position", "value": [200, 150, 1200]})).unwrap();
+    let invis = s.execute("layer.newSolid", json!({"color": "#ff0000", "width": 40, "height": 40})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [invis], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.setTransform", json!({"layer": invis, "prop": "position", "value": [200, 150, 1600]})).unwrap();
+    s.execute("layer.setTransform", json!({"layer": invis, "prop": "scale", "value": [0.0, 0.0, 0.0]})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let img = s.render(cid, effectcraft_time::Tick::ZERO, Default::default());
+    assert!(img.data.iter().all(|p| p.iter().all(|c| c.is_finite())), "non-finite pixels after setFocusToLayer");
+    // The DoF frame actually blurred (not a no-op blur): the same frame with DoF off differs.
+    s.execute("prop.set", json!({"layer": cam, "path": "cameraOptions/dof", "value": false})).unwrap();
+    let plain = s.render(cid, effectcraft_time::Tick::ZERO, Default::default());
+    assert_ne!(img.data, plain.data, "the out-of-focus layer should have blurred");
+}
+
+/// Set Focus Distance to Layer fails cleanly on a depth that isn't finite. Every stored number
+/// here is finite, but their difference overflows f64 to infinity; JSON has no infinity, so
+/// storing it would leave a project that can't be saved.
+#[test]
+fn camera_set_focus_to_layer_rejects_non_finite_depth() {
+    let mut s = comp(400, 300);
+    let t = s.execute("layer.newSolid", json!({"color": "#ffffff", "width": 50, "height": 50})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [t], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.setTransform", json!({"layer": t, "prop": "position", "value": [200.0, 150.0, 1e308]})).unwrap();
+    let cam = s.execute("layer.newCamera", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setTransform", json!({"layer": cam, "prop": "position", "value": [200.0, 150.0, -1e308]})).unwrap();
+    s.execute("layer.select", json!({"layers": [cam, t]})).unwrap();
+    let before = s.execute("prop.get", json!({"layer": cam, "path": "cameraOptions/focusDistance"})).unwrap()["value"].as_f64().unwrap();
+    let e = s.execute("camera.setFocusToLayer", json!({})).unwrap_err().to_string();
+    assert!(e.contains("out of range"), "{e}");
+    let after = s.execute("prop.get", json!({"layer": cam, "path": "cameraOptions/focusDistance"})).unwrap()["value"].as_f64().unwrap();
+    assert!((after - before).abs() < 1e-9, "a non-finite focus distance was written: {after}");
+    // The project still round-trips through serde (a stored infinity would come back as null).
+    let back = roundtrip(&s);
+    let f = back.comp(s.active_comp_id().unwrap()).unwrap().layer(LayerId(cam)).unwrap().props.prop("cameraOptions/focusDistance").unwrap().value.as_f64();
+    assert!((f - before).abs() < 1e-9, "serde focus distance: {f}");
+}
+
 /// An id sent as a string (`"98"`, as MCP clients often do) resolves as an id when no name matches.
 #[test]
 fn numeric_string_resolves_as_id() {
diff --git a/crates/engine/src/tests_text.rs b/crates/engine/src/tests/text.rs
similarity index 99%
rename from crates/engine/src/tests_text.rs
rename to crates/engine/src/tests/text.rs
index 84f88fd33..3980c7bb5 100644
--- a/crates/engine/src/tests_text.rs
+++ b/crates/engine/src/tests/text.rs
@@ -198,7 +198,7 @@ fn cached_text_presets_keep_the_catalog_and_application_independent() {
 #[ignore = "warm text-preset listing benchmark"]
 fn text_preset_listing_benchmark() {
     let old = || {
-        let v: serde_json::Value = serde_json::from_str(include_str!("../presets/text_animators.json")).unwrap();
+        let v: serde_json::Value = serde_json::from_str(include_str!("../../presets/text_animators.json")).unwrap();
         let presets = v["presets"].as_array().unwrap().clone();
         presets.iter().map(|p| (p["id"].as_str().unwrap().to_string(), p["name"].as_str().unwrap().to_string())).collect::<Vec<_>>()
     };
diff --git a/crates/engine/src/tests_text_edit.rs b/crates/engine/src/tests/text_edit.rs
similarity index 81%
rename from crates/engine/src/tests_text_edit.rs
rename to crates/engine/src/tests/text_edit.rs
index 17d0345d8..eb1de6f89 100644
--- a/crates/engine/src/tests_text_edit.rs
+++ b/crates/engine/src/tests/text_edit.rs
@@ -7,6 +7,7 @@ use serde_json::json;
 
 use crate::Session;
 use crate::commands::text_edit::{MAX_IME_TEXT_BYTES, ime_stamp_revision, ime_surrounding, layer_doc};
+use crate::tests::three_d::layer_count;
 
 fn session(text: &str) -> (Session, u64) {
     let mut s = Session::default();
@@ -199,6 +200,20 @@ fn typing_deleting_and_caret_movement() {
     assert!(s.state.text_edit.is_none());
 }
 
+/// Duplicating during a text edit moves the selection to the copy: the edit on the original ends
+/// (#2226), as in After Effects — typing must not keep editing an unselected layer.
+#[test]
+fn duplicate_during_a_text_edit_ends_the_edit() {
+    let (mut s, t) = session("Hello");
+    s.execute("text.edit", json!({"layer": t, "caret": 5})).unwrap();
+    let copy = s.execute("edit.duplicate", json!({"layers": [t]})).unwrap()[0].as_u64().unwrap();
+    assert_ne!(copy, t, "the duplicate is created");
+    assert_eq!(s.state.selected_layers, vec![effectcraft_project::LayerId(copy)], "the copy is selected");
+    assert!(s.state.text_edit.is_none(), "the edit ended with the selection move (#2226)");
+    assert_eq!(doc(&s, t).text, "Hello", "the original keeps its text");
+    assert_eq!(doc(&s, copy).text, "Hello", "and the copy carries it");
+}
+
 #[test]
 fn caret_style_applies_to_the_next_typed_text() {
     let (mut s, t) = session("ab");
@@ -260,25 +275,25 @@ fn clipboard_and_paste_formatting() {
 }
 
 #[test]
-fn type_tool_layers_point_box_and_empty_cleanup() {
+fn type_tool_layers_point_box_and_empty_layer_is_kept() {
     let mut s = Session::default();
     s.execute("comp.new", json!({"name": "C", "width": 640, "height": 360, "duration": 4})).unwrap();
     let t = s.execute("layer.newText", json!({"text": "", "position": [100, 200], "justify": "left", "edit": true})).unwrap()["layer"].as_u64().unwrap();
     assert_eq!(s.state.text_edit.as_ref().map(|e| e.layer.0), Some(t));
-    // Leaving an untouched Type-tool layer deletes it.
+    // Leaving an untouched Type-tool layer keeps it, as After Effects does.
     s.execute("text.endEdit", json!({})).unwrap();
-    assert!(s.active_comp().unwrap().layers.is_empty());
+    assert_eq!(s.active_comp().unwrap().layers.len(), 1, "an empty Type-tool layer is kept, as in AE");
     let b = s.execute("layer.newText", json!({"text": "", "box": [40, 50, 300, 120], "edit": true})).unwrap()["layer"].as_u64().unwrap();
     s.execute("text.insert", json!({"text": "Boxed"})).unwrap();
     let d = doc(&s, b);
     assert_eq!(d.box_size, Some([300.0, 120.0]));
     assert_eq!(d.box_pos, [-150.0, -60.0]);
-    let l = s.active_comp().unwrap().layers[0].clone();
+    let l = s.active_comp().unwrap().layers.iter().find(|l| l.id.0 == b).expect("the boxed layer").clone();
     assert_eq!(l.name, "Boxed", "named after its text");
     let pos = l.props.prop("transform/position").unwrap().value.as_vec3();
     assert_eq!([pos[0], pos[1]], [190.0, 110.0]);
     s.execute("text.endEdit", json!({})).unwrap();
-    assert_eq!(s.active_comp().unwrap().layers.len(), 1);
+    assert_eq!(s.active_comp().unwrap().layers.len(), 2, "both text layers stay, the empty one included");
     // Resizing the box (layer space) is an attribute too.
     s.execute("layer.setText", json!({"layer": b, "box": [-100, -60, 200, 120]})).unwrap();
     assert_eq!(doc(&s, b).box_size, Some([200.0, 120.0]));
@@ -928,11 +943,19 @@ fn fonts_lists_bundled_and_installed_families() {
     let r = s.execute("text.fonts", json!({"query": "noto ser", "rescan": true})).unwrap();
     assert_eq!(r["families"][0]["family"], "Noto Serif");
     // The bundled face is Regular; the OS can also provide Bold, Italic, or other faces.
-    // Compare against the independent directory inventory rather than assuming an empty OS.
-    let mut expected_styles = std::collections::BTreeSet::from(["Regular".to_string()]);
-    expected_styles.extend(installed.iter().filter(|face| face.family.eq_ignore_ascii_case("Noto Serif")).map(|face| face.style.clone()));
+    // Model `add_source()` on the independent directory inventory: a system face whose family
+    // and primary style duplicate an earlier face is skipped, with its named instances.
+    let mut expected_styles = std::collections::BTreeSet::from(["regular".to_string()]);
+    let mut retained = std::collections::BTreeSet::from([("noto serif".to_string(), "regular".to_string())]);
+    for face in installed.iter().filter(|face| face.family.eq_ignore_ascii_case("Noto Serif")) {
+        if retained.insert((face.family.to_ascii_lowercase(), face.style.to_ascii_lowercase())) {
+            expected_styles.insert(face.style.to_ascii_lowercase());
+            expected_styles.extend(face.instances.iter().map(|i| i.style.to_ascii_lowercase()));
+        }
+    }
     let styles: Vec<String> = r["families"][0]["styles"].as_array().unwrap().iter().map(|style| style.as_str().unwrap().to_string()).collect();
-    assert_eq!(styles.iter().cloned().collect::<std::collections::BTreeSet<_>>(), expected_styles);
+    // `families()` keeps the first spelling of a style that differs only in case.
+    assert_eq!(styles.iter().map(|style| style.to_ascii_lowercase()).collect::<std::collections::BTreeSet<_>>(), expected_styles);
     assert_eq!(styles.len(), expected_styles.len(), "style menu has no duplicates");
     assert!(r["families"].as_array().unwrap().iter().all(|f| f["family"].as_str().unwrap().to_lowercase().contains("noto ser")));
     // The style menus offer a family's own styles.
@@ -1202,19 +1225,195 @@ fn deselect_all_ends_the_open_edit() {
 }
 
 #[test]
-fn deselect_all_discards_an_empty_type_tool_layer() {
+fn deselect_all_keeps_an_empty_type_tool_layer() {
     let (mut s, _keep) = session("Hello");
     let new = s.execute("layer.newText", json!({"text": "", "position": [80.0, 80.0], "edit": true})).unwrap()["layer"].as_u64().unwrap();
     assert!(
         s.state.text_edit.as_ref().is_some_and(|e| e.created && e.layer == effectcraft_project::LayerId(new)),
         "the Type tool opens the edit on its new, empty layer"
     );
-    let count = |s: &Session| s.active_comp().map_or(0, |c| c.layers.len());
-    let before = count(&s);
+    let before = layer_count(&s);
     s.execute("edit.deselectAll", json!({})).unwrap();
     assert!(s.state.text_edit.is_none());
     assert!(s.state.selected_layers.is_empty());
-    assert_eq!(count(&s), before - 1, "a Type-tool layer left empty is removed, as text.endEdit does");
+    assert_eq!(layer_count(&s), before, "an empty Type-tool layer is kept, as in After Effects");
+}
+
+#[test]
+fn duplicate_ends_an_edit_on_already_committed_text() {
+    // The engine route (MCP, control channel, script) with text that was committed before the
+    // edit opened and nothing typed inside it: the edit still ends and the copy is selected.
+    let (mut s, t) = editing("Hello", 5);
+    let copy = s.execute("edit.duplicate", json!({})).unwrap()[0].as_u64().unwrap();
+    assert!(s.state.text_edit.is_none(), "the open edit ends on a direct edit.duplicate");
+    assert_eq!(s.state.selected_layers, vec![effectcraft_project::LayerId(copy)], "and the copy is selected");
+    assert_eq!(doc(&s, t).text, "Hello", "the committed text is kept on the original");
+    assert_eq!(doc(&s, copy).text, "Hello", "and carried by the copy");
     s.execute("edit.undo", json!({})).unwrap();
-    assert_eq!(count(&s), before, "that removal is one undo step of its own, as on text.endEdit");
+    assert_eq!(layer_count(&s), 1, "undo removes the copy");
+    assert!(s.state.text_edit.is_none(), "undo does not reopen the edit");
+}
+
+#[test]
+fn duplicate_during_an_edit_copies_the_layer_not_a_selected_property_group() {
+    use effectcraft_project::LayerId;
+    // Opening the editor by command, as a Type-tool click does, keeps the property selection, so
+    // an effect, shape item or text animator can still be selected while the user types.
+    for what in ["effect", "shape item", "text animator"] {
+        let (mut s, t) = session("Hello");
+        let (owner, path) = match what {
+            "effect" => {
+                s.execute("effect.apply", json!({"layers": [t], "effect": "Gaussian Blur"})).unwrap();
+                (t, "effects")
+            }
+            "shape item" => (s.execute("layer.newShape", json!({"kind": "rect"})).unwrap()["layer"].as_u64().unwrap(), "contents"),
+            _ => {
+                s.execute("layer.addTextAnimator", json!({"layer": t, "properties": ["opacity"]})).unwrap();
+                (t, "text/animators")
+            }
+        };
+        let items =
+            |s: &Session| s.active_comp().unwrap().layer(LayerId(owner)).unwrap().props.group(path).unwrap().groups().map(|g| g.uid).collect::<Vec<_>>();
+        let item = items(&s)[0];
+        let n = items(&s).len();
+        let before = layer_count(&s);
+        s.execute("prop.select", json!({"layer": owner, "prop": item})).unwrap();
+        begin_edit_at(&mut s, t, 5);
+        let r = s.execute("edit.duplicate", json!({})).unwrap();
+        assert!(s.state.text_edit.is_none(), "{what}: Duplicate ends the open edit");
+        assert_eq!(items(&s).len(), n, "{what}: the selected {what} is not duplicated");
+        assert_eq!(layer_count(&s), before + 1, "{what}: the edited layer is");
+        assert_eq!(s.state.selected_layers, vec![LayerId(r[0].as_u64().unwrap())], "{what}: and its copy is selected");
+        // The selection the edit passed over goes with it: the next Duplicate copies the selected
+        // copy rather than reaching back to the original's {what}.
+        s.execute("edit.duplicate", json!({})).unwrap();
+        assert_eq!(items(&s).len(), n, "{what}: a second Duplicate leaves the original's {what} alone");
+        assert_eq!(layer_count(&s), before + 2, "{what}: and copies the copy");
+        // With no edit open, the selected item keeps its precedence over the layers.
+        s.execute("prop.select", json!({"layer": owner, "prop": item})).unwrap();
+        s.execute("edit.duplicate", json!({})).unwrap();
+        assert_eq!(items(&s).len(), n + 1, "{what}: outside an edit Duplicate copies the selected {what}");
+        assert_eq!(layer_count(&s), before + 2, "{what}: and no layer");
+    }
+}
+
+#[test]
+fn duplicate_during_an_edit_leaves_no_key_or_vertex_selected_on_the_original() {
+    use effectcraft_project::LayerId;
+    // Opening the editor keeps the keyframe and mask-vertex selection too. Once the copy takes the
+    // selection, Clear deletes the copy, not a key or a vertex of the original.
+    for what in ["keyframe", "mask vertex"] {
+        let (mut s, t) = session("Hello");
+        let mask = match what {
+            "keyframe" => {
+                for time in [0.0, 1.0] {
+                    s.execute("prop.addKey", json!({"layer": t, "path": "transform/opacity", "time": time, "value": 50})).unwrap();
+                }
+                s.execute("keys.select", json!({"keys": [{"layer": t, "path": "transform/opacity", "time": 0.0}]})).unwrap();
+                None
+            }
+            // The Pen leaves the new mask's last vertex selected.
+            _ => Some(s.execute("mask.new", json!({"layer": t, "vertices": [[0, 0], [40, 0], [40, 40]], "closed": true})).unwrap()["mask"].as_u64().unwrap()),
+        };
+        let original = |s: &Session| {
+            let l = s.active_comp().unwrap().layer(LayerId(t)).unwrap();
+            match mask {
+                None => l.props.prop("transform/opacity").unwrap().keys.len(),
+                Some(m) => l.props.find_group(m).unwrap().get("path").unwrap().value.as_path().unwrap().vertices.len(),
+            }
+        };
+        let (n, before) = (original(&s), layer_count(&s));
+        begin_edit_at(&mut s, t, 5);
+        let copy = s.execute("edit.duplicate", json!({})).unwrap()[0].as_u64().unwrap();
+        assert_eq!(s.state.selected_layers, vec![LayerId(copy)], "{what}: the copy is selected");
+        s.execute("edit.clear", json!({})).unwrap();
+        assert_eq!(layer_count(&s), before, "{what}: Clear deletes the selected copy");
+        assert_eq!(original(&s), n, "{what}: and leaves the original's {what} alone");
+    }
+}
+
+#[test]
+fn duplicate_during_an_edit_copies_the_edited_layer_after_another_is_selected() {
+    use effectcraft_project::LayerId;
+    // An engine route (MCP, control channel, script) can select another layer while the edit
+    // stays open. The implicit Duplicate still means the edited layer, as Clear does; a named
+    // target keeps its meaning.
+    let (mut s, t) = session("Hello");
+    let other = s.execute("layer.newText", json!({"text": "Other"})).unwrap()["layer"].as_u64().unwrap();
+    begin_edit_at(&mut s, t, 5);
+    s.execute("layer.select", json!({"layer": other})).unwrap();
+    assert!(s.state.text_edit.as_ref().is_some_and(|e| e.layer == LayerId(t)), "selecting another layer leaves the edit open");
+    let before = layer_count(&s);
+    let copy = s.execute("edit.duplicate", json!({})).unwrap()[0].as_u64().unwrap();
+    assert!(s.state.text_edit.is_none(), "Duplicate ends the open edit");
+    assert_eq!(layer_count(&s), before + 1, "one layer is copied");
+    assert_eq!(doc(&s, copy).text, "Hello", "the edited layer is copied, not the newly selected one");
+    assert_eq!(s.state.selected_layers, vec![LayerId(copy)], "and its copy is selected");
+    // Null parameters name no layer, as everywhere else layers are read.
+    for unnamed in [json!({"layers": null}), json!({"layer": null})] {
+        begin_edit_at(&mut s, t, 5);
+        s.execute("layer.select", json!({"layer": other})).unwrap();
+        let copy = s.execute("edit.duplicate", unnamed.clone()).unwrap()[0].as_u64().unwrap();
+        assert_eq!(doc(&s, copy).text, "Hello", "{unnamed}: the edited layer is copied");
+    }
+    begin_edit_at(&mut s, t, 5);
+    let named = s.execute("edit.duplicate", json!({"layer": other})).unwrap()[0].as_u64().unwrap();
+    assert_eq!(doc(&s, named).text, "Other", "a named layer is copied as named");
+}
+
+#[test]
+fn duplicate_during_an_edit_with_nothing_selected_copies_the_edited_layer() {
+    use effectcraft_project::LayerId;
+    // An engine route can also clear the selection while the edit stays open. Duplicate stays
+    // available, since its unnamed target is the edited layer, not the selection.
+    let (mut s, _) = editing("Hello", 5);
+    s.execute("layer.select", json!({"layers": []})).unwrap();
+    assert!(s.state.selected_layers.is_empty() && s.state.text_edit.is_some(), "the edit is open with nothing selected");
+    let copy = s.execute("edit.duplicate", json!({})).unwrap()[0].as_u64().unwrap();
+    assert!(s.state.text_edit.is_none(), "Duplicate ends the open edit");
+    assert_eq!(doc(&s, copy).text, "Hello", "and copies the edited layer");
+    assert_eq!(s.state.selected_layers, vec![LayerId(copy)], "which is selected");
+    // With no edit open, nothing selected still means nothing to duplicate.
+    s.execute("layer.select", json!({"layers": []})).unwrap();
+    let before = layer_count(&s);
+    assert!(s.execute("edit.duplicate", json!({})).is_err(), "outside an edit Duplicate needs a selection");
+    assert_eq!(layer_count(&s), before, "and copies nothing");
+}
+
+#[test]
+fn duplicate_ends_the_open_edit_and_selects_the_copy() {
+    let (mut s, t) = editing("Hello", 5);
+    s.execute("text.insert", json!({"text": "!"})).unwrap();
+    assert_eq!(doc(&s, t).text, "Hello!");
+    let copy = s.execute("edit.duplicate", json!({})).unwrap()[0].as_u64().unwrap();
+    // A deselected layer never keeps an open text edit: Duplicate commits the edit through the
+    // same route as text.endEdit before the selection moves, so every route (menu, shortcut,
+    // palette, MCP, script) leaves one final state.
+    assert!(s.state.text_edit.is_none(), "Duplicate ends the open text edit, as Deselect All does");
+    assert_eq!(s.state.selected_layers, vec![effectcraft_project::LayerId(copy)], "and selects the copy");
+    assert_eq!(doc(&s, t).text, "Hello!", "the original keeps the typed text");
+    assert_eq!(doc(&s, copy).text, "Hello!", "the copy carries it too");
+    // The edit ending is no undoable step of its own (as with text.endEdit): undo takes the
+    // duplicate, it does not reopen the edit or undo the typing.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(layer_count(&s), 1, "undo removed the copy");
+    assert_eq!(doc(&s, t).text, "Hello!", "the typed text stays committed");
+    assert!(s.state.text_edit.is_none(), "undo does not reopen the edit");
+    // With no open edit Duplicate is untouched by all of this: same behavior, no extra steps.
+    s.execute("edit.duplicate", json!({"layers": [t]})).unwrap();
+    assert_eq!(layer_count(&s), 2, "a plain duplicate still duplicates");
+    assert!(s.state.text_edit.is_none());
+}
+
+#[test]
+fn duplicate_of_an_empty_type_tool_layer_ends_the_edit_and_copies_it() {
+    use effectcraft_project::LayerId;
+    let (mut s, _keep) = session("Hello");
+    let new = s.execute("layer.newText", json!({"text": "", "position": [80.0, 80.0], "edit": true})).unwrap()["layer"].as_u64().unwrap();
+    assert!(s.state.text_edit.as_ref().is_some_and(|e| e.created && e.layer == LayerId(new)), "the Type tool opens the edit on its new, empty layer");
+    let before = layer_count(&s);
+    let copy = s.execute("edit.duplicate", json!({})).unwrap()[0].as_u64().unwrap();
+    assert!(s.state.text_edit.is_none(), "the edit ends the way text.endEdit ends it");
+    assert_eq!(layer_count(&s), before + 1, "the empty layer is kept, as text.endEdit keeps it, and copied");
+    assert_eq!(s.state.selected_layers, vec![LayerId(copy)], "and the copy is selected");
 }
diff --git a/crates/engine/src/tests_3d.rs b/crates/engine/src/tests/three_d.rs
similarity index 74%
rename from crates/engine/src/tests_3d.rs
rename to crates/engine/src/tests/three_d.rs
index 07a48af1c..5b5af594d 100644
--- a/crates/engine/src/tests_3d.rs
+++ b/crates/engine/src/tests/three_d.rs
@@ -1,6 +1,6 @@
 //! 3D commands: cameras, lights, views, camera tools (with undo/redo), and the 3D demo comp.
 
-use effectcraft_project::{AutoOrient, LayerSource, LightKind};
+use effectcraft_project::{AutoOrient, LayerSource, LightKind, Renderer};
 use effectcraft_render::three_d::View3D;
 use serde_json::json;
 
@@ -26,7 +26,8 @@ fn auto_orient_command() {
     assert!(!effectcraft_render::three_d::camera::is_two_node(&s.active_comp().unwrap().layers[0]));
 }
 
-fn layer_count(s: &Session) -> usize {
+/// Layers in the active comp.
+pub(crate) fn layer_count(s: &Session) -> usize {
     s.active_comp().unwrap().layers.len()
 }
 
@@ -148,6 +149,85 @@ fn deleting_a_source_layer_clears_the_reference() {
     assert!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(sky)).is_some());
 }
 
+/// #2436: only the Advanced 3D renderer lights with Environment lights, and new comps are
+/// Classic 3D, so one had no visible effect. Adding one (or changing a light into one) switches
+/// the comp to Advanced 3D (in the same undo step, with a toast), as After Effects does.
+#[test]
+fn environment_lights_switch_classic_comps_to_advanced_3d() {
+    let toasts = |s: &mut Session| -> Vec<String> {
+        s.drain_events().into_iter().filter_map(|e| if let crate::Event::Toast { message, .. } = e { Some(message) } else { None }).collect()
+    };
+    let mut s = session();
+    let text = s.execute("layer.newText", json!({"text": "Hi"})).unwrap()["layer"].as_u64().unwrap();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D);
+    toasts(&mut s);
+    let r = s.execute("layer.newLight", json!({"kind": "Environment"})).unwrap();
+    assert_eq!(r["advanced3d"], true);
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Advanced3D);
+    // As with Composition Settings: the text layer gets Geometry Options.
+    assert!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(text)).unwrap().props.sub("geometryOptions").is_some());
+    assert!(toasts(&mut s).iter().any(|m| m.contains("Advanced 3D")));
+    // A second Environment light leaves the comp (and the user) alone.
+    s.execute("layer.newLight", json!({"kind": "Environment"})).unwrap();
+    assert!(toasts(&mut s).is_empty());
+    // Undoing the creations takes the lights and the switch back together.
+    s.undo();
+    s.undo();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D);
+    assert_eq!(layer_count(&s), 1);
+    // Changing a light to Environment switches too, and undoes with the type.
+    let spot = s.execute("layer.newLight", json!({"kind": "Spot"})).unwrap()["layer"].as_u64().unwrap();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D);
+    s.execute("layer.lightSettings", json!({"layer": spot, "kind": "Environment"})).unwrap();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Advanced3D);
+    s.undo();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D);
+    assert_eq!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(spot)).unwrap().source, LayerSource::Light { kind: LightKind::Spot });
+    // Other light types never switch it.
+    s.execute("layer.newLight", json!({"kind": "Point"})).unwrap();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D);
+    // Switching back to Classic 3D with an Environment light in the comp explains itself.
+    let env = s.execute("layer.newLight", json!({"kind": "Environment"})).unwrap()["layer"].as_u64().unwrap();
+    toasts(&mut s);
+    s.execute("comp.renderer", json!({"renderer": "classic3d"})).unwrap();
+    assert!(toasts(&mut s).iter().any(|m| m.contains("Environment light")), "the Classic 3D limit is explained");
+    // Editing that Environment light (no type change) leaves the renderer the user chose.
+    s.execute("layer.lightSettings", json!({"layer": env, "intensity": 80})).unwrap();
+    assert_eq!(s.active_comp().unwrap().renderer, Renderer::Classic3D, "an ordinary edit doesn't re-switch");
+    assert!(toasts(&mut s).is_empty(), "and doesn't toast either");
+}
+
+/// An Environment light takes Casts Shadows (with Shadow Darkness and Diffusion) like every
+/// other light — the Light Settings dialog offers them for all types but Ambient — and keeps no
+/// Falloff, which an environment light shining from every direction has no use for (#2436).
+#[test]
+fn environment_light_takes_shadow_options_but_no_falloff() {
+    let mut s = session();
+    let env = s.execute("layer.newLight", json!({"kind": "Environment", "castsShadows": true, "shadowDarkness": 60, "shadowDiffusion": 12})).unwrap()["layer"]
+        .as_u64()
+        .unwrap();
+    assert!(prop(&s, env, "lightOptions/castsShadows").as_bool());
+    assert_eq!(prop(&s, env, "lightOptions/shadowDarkness").as_f64(), 60.0);
+    assert_eq!(prop(&s, env, "lightOptions/shadowDiffusion").as_f64(), 12.0);
+    assert!(
+        s.active_comp().unwrap().layer(effectcraft_project::LayerId(env)).unwrap().props.prop("lightOptions/falloff").is_none(),
+        "an environment light has no Falloff"
+    );
+    // The shadow values carry over when the type changes, both ways.
+    s.execute("layer.lightSettings", json!({"layer": env, "kind": "Spot", "coneAngle": 70})).unwrap();
+    assert!(prop(&s, env, "lightOptions/castsShadows").as_bool());
+    assert_eq!(prop(&s, env, "lightOptions/shadowDarkness").as_f64(), 60.0);
+    assert_eq!(prop(&s, env, "lightOptions/coneAngle").as_f64(), 70.0);
+    s.execute("layer.lightSettings", json!({"layer": env, "kind": "Environment"})).unwrap();
+    assert!(prop(&s, env, "lightOptions/castsShadows").as_bool());
+    assert_eq!(prop(&s, env, "lightOptions/source").as_layer(), None, "back to Environment: it has a Source again");
+    s.undo();
+    assert!(
+        s.active_comp().unwrap().layer(effectcraft_project::LayerId(env)).unwrap().props.prop("lightOptions/coneAngle").is_some(),
+        "back to Spot: it has a Cone Angle again"
+    );
+}
+
 #[test]
 fn three_d_switch_undo_redo() {
     let mut s = session();
diff --git a/crates/engine/src/tests_timeline.rs b/crates/engine/src/tests/timeline.rs
similarity index 90%
rename from crates/engine/src/tests_timeline.rs
rename to crates/engine/src/tests/timeline.rs
index 33dac7795..55475eef3 100644
--- a/crates/engine/src/tests_timeline.rs
+++ b/crates/engine/src/tests/timeline.rs
@@ -298,6 +298,25 @@ fn interpolation_dialog_temporal_spatial_and_roving() {
     assert_ne!(prop(&s, l, "transform/position").keys[0].out_interp, Interp::Hold);
 }
 
+/// Editing another key's value or time keeps the roving key at its share of the path (#1284: the
+/// roving key went back to where it was after edits to other keys).
+#[test]
+fn roving_key_follows_value_and_time_edits_to_other_keys() {
+    let (mut s, l) = setup();
+    animate(&mut s, l, "transform/position", &[(0.0, json!([0, 0])), (0.3, json!([300, 0])), (2.0, json!([400, 0]))]);
+    let uid = prop(&s, l, "transform/position").uid;
+    s.execute("keys.select", json!({"keys": [{"layer": l, "prop": uid, "time": 0.3}]})).unwrap();
+    s.execute("keys.interpolation", json!({"roving": true})).unwrap();
+    let roving_at = |s: &Session| prop(s, l, "transform/position").keys[1].time.seconds();
+    assert!((roving_at(&s) - 1.5).abs() < 0.01, "start: {}", roving_at(&s));
+    // The last key's value moves to 800 px: the path is 300 + 500 px, so the roving key is at 300 / 800.
+    s.execute("keys.set", json!({"layer": l, "path": "transform/position", "time": 2.0, "value": [800, 0]})).unwrap();
+    assert!((roving_at(&s) - 0.75).abs() < 0.02, "value edit: {}", roving_at(&s));
+    // The last key moves to 3 s: the same 300 / 800 share of 3 s.
+    s.execute("keys.set", json!({"layer": l, "path": "transform/position", "time": 2.0, "newTime": 3.0})).unwrap();
+    assert!((roving_at(&s) - 1.125).abs() < 0.02, "time edit: {}", roving_at(&s));
+}
+
 #[test]
 fn graph_editor_key_and_handle_edits() {
     let (mut s, l) = setup();
@@ -325,6 +344,34 @@ fn graph_editor_key_and_handle_edits() {
     assert_eq!(prop(&s, l, "transform/opacity").keys[0].out_interp, Interp::Linear);
 }
 
+#[test]
+fn graph_editor_ease_edits_reject_a_locked_layer() {
+    let (mut s, l) = setup();
+    animate(&mut s, l, "transform/opacity", &[(0.0, json!(0)), (1.0, json!(100)), (2.0, json!(0))]);
+    select_prop_keys(&mut s, l, "transform/opacity");
+    s.execute("layer.setSwitch", json!({"layers": [l], "switch": "locked", "value": true})).unwrap();
+    let before = prop(&s, l, "transform/opacity");
+    let selected = s.state.selected_keys.clone();
+    let undo = s.history.undo.len();
+    for side in ["in", "out"] {
+        let error =
+            s.execute("keys.setEase", json!({"layer": l, "path": "transform/opacity", "time": 1.0, "side": side, "speed": 200, "influence": 60})).unwrap_err();
+        assert!(error.to_string().contains("locked"), "{error}");
+        assert_eq!(prop(&s, l, "transform/opacity").keys, before.keys);
+        assert_eq!(s.state.selected_keys, selected);
+        assert_eq!(s.history.undo.len(), undo);
+    }
+    s.execute("layer.setSwitch", json!({"layers": [l], "switch": "locked", "value": false})).unwrap();
+    s.execute("keys.setEase", json!({"layer": l, "path": "transform/opacity", "time": 1.0, "side": "out", "speed": 200, "influence": 60})).unwrap();
+    let after = prop(&s, l, "transform/opacity");
+    assert_eq!(after.keys[1].out_interp, Interp::Bezier);
+    assert_eq!(after.keys[1].out_ease[0].speed, 200.0);
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(prop(&s, l, "transform/opacity").keys, before.keys);
+    s.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(prop(&s, l, "transform/opacity").keys, after.keys);
+}
+
 #[test]
 fn convert_expression_to_keyframes_on_a_reversed_layer_keeps_values() {
     let (mut s, l) = setup();
@@ -765,6 +812,59 @@ fn pick_whip_generates_ae_reference_expressions() {
     assert!(s.execute("prop.pickWhip", json!({"layer": l, "path": "transform/opacity", "target": {"layer": l, "path": "transform/opacity"}})).is_err());
 }
 
+/// #1072: an Alt pick whip (`byIndex`) selects an effect's properties by their index,
+/// `effect("Color Control")(1)`, its place among its group's children (nested groups too). The
+/// effect keeps its name; other properties, dimensions, insertion into an expression and match
+/// names (Compact English off) work as before. (`effectcraft-host`'s `pick_whip` tests check the
+/// references read the right values.)
+#[test]
+fn pick_whip_by_index_selects_effect_properties_by_their_index() {
+    let (mut s, l) = setup();
+    let o = s.execute("layer.newSolid", json!({"name": "Other", "color": "#00ff00"})).unwrap()["layer"].as_u64().unwrap();
+    for fx in ["Color Control", "Fractal Noise", "Point Control"] {
+        s.execute("effect.apply", json!({"layer": o, "effect": fx})).unwrap();
+    }
+    // Fractal Noise ▸ Transform ▸ Scale, by its places in the property tree.
+    let fx = s.active_comp().unwrap().layer(effectcraft_project::LayerId(o)).unwrap().props.sub("effects").unwrap().groups().nth(1).unwrap().clone();
+    let group = fx.children.iter().position(|c| c.match_id() == "transform").unwrap() + 1;
+    let scale = fx.sub("transform").unwrap().children.iter().position(|c| c.match_id() == "scale").unwrap() + 1;
+    let whip = |s: &mut Session, path: &str, target: Value, extra: Value| {
+        let mut p = json!({"layer": l, "path": path, "target": target, "byIndex": true});
+        p.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
+        s.execute("prop.pickWhip", p).unwrap()
+    };
+    let other = "thisComp.layer(\"Other\")";
+    let undo = s.history.undo.len();
+    assert_eq!(
+        whip(&mut s, "transform/rotation", json!({"layer": o, "path": "effects/#1/color"}), json!({})),
+        json!(format!("{other}.effect(\"Color Control\")(1)[0]")),
+        "a colour into one value: its first"
+    );
+    assert_eq!(s.history.undo.len(), undo + 1, "one undo step");
+    let nested = format!("{other}.effect(\"Fractal Noise\")({group})({scale})");
+    assert_eq!(whip(&mut s, "transform/rotation", json!({"layer": o, "path": "effects/#2/transform/scale"}), json!({})), json!(nested));
+    assert_eq!(
+        whip(&mut s, "transform/opacity", json!({"layer": o, "path": "effects/#3/point", "dimension": 1}), json!({})),
+        json!(format!("{other}.effect(\"Point Control\")(1)[1]"))
+    );
+    assert_eq!(
+        whip(&mut s, "transform/rotation", json!({"layer": o, "path": "effects/#2/transform/scale"}), json!({"expression": "1 + ", "range": [4, 4]})),
+        json!(format!("1 + {nested}")),
+        "inserted at the cursor"
+    );
+    assert_eq!(
+        whip(&mut s, "transform/opacity", json!({"layer": o, "path": "transform/opacity"}), json!({})),
+        json!(format!("{other}.transform.opacity")),
+        "only an effect's properties go by index"
+    );
+    // Match names (Compact English off): the effect by its match name, its properties by index.
+    s.execute("prefs.set", json!({"key": "general.expressionPickWhipCompact", "value": false})).unwrap();
+    let e = whip(&mut s, "transform/rotation", json!({"layer": o, "path": "effects/#2/transform/scale"}), json!({}));
+    assert!(e.as_str().unwrap().ends_with(&format!("({group})({scale})")), "{e}");
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(prop(&s, l, "transform/rotation").expr.unwrap().text, format!("1 + {nested}"), "one undo per pick");
+}
+
 /// #407: Reset without a value gives a property its own default (a Transform property's, an
 /// effect parameter's) besides removing its keyframes and expression.
 #[test]
@@ -1430,3 +1530,29 @@ fn a_typed_component_applies_only_that_component_to_the_selected_layers() {
     s.execute("prop.set", json!({"layer": a, "prop": uid, "value": [1.0, 2.0, 3.0], "selected": true})).unwrap();
     assert_eq!(pos(&s, c), vec![1.0, 2.0, 3.0]);
 }
+
+/// #2485: linked Audio Levels typed with several layers selected: each takes the typed Left, and
+/// its Right moves by its own change, so every layer keeps its own stereo balance.
+#[test]
+fn a_typed_component_moves_its_follow_components_by_each_layers_own_change() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Sound", "width": 64, "height": 36, "duration": 4})).unwrap();
+    s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "duration": 4})).unwrap();
+    let a = s.execute("layer.addItem", json!({"item": "Sound"})).unwrap()["layer"].as_u64().unwrap();
+    let b = s.execute("layer.addItem", json!({"item": "Sound"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": a, "path": "audio/levels", "value": [-6.0, -12.0]})).unwrap();
+    s.execute("prop.set", json!({"layer": b, "path": "audio/levels", "value": [-20.0, -30.0]})).unwrap();
+    s.execute("layer.select", json!({"layers": [a, b]})).unwrap();
+    let uid = prop(&s, a, "audio/levels").uid;
+    let undo = s.history.undo.len();
+    s.execute_checked("prop.set", json!({"layer": a, "prop": uid, "value": [-3.0, -9.0], "selected": true, "dims": [0], "follow": [1]})).unwrap();
+    assert_eq!(prop(&s, a, "audio/levels").value.components(), vec![-3.0, -9.0]);
+    assert_eq!(prop(&s, b, "audio/levels").value.components(), vec![-3.0, -13.0], "B rises 17 dB on both channels");
+    assert_eq!(s.history.undo.len(), undo + 1, "one undo step");
+
+    // Keyed at a time other than the CTI: B's change is measured on its key there.
+    animate(&mut s, b, "audio/levels", &[(0.0, json!([-20.0, -30.0])), (1.0, json!([-10.0, -40.0]))]);
+    s.execute("prop.set", json!({"layer": a, "prop": uid, "value": [-4.0, -10.0], "time": 1.0, "selected": true, "dims": [0], "follow": [1]})).unwrap();
+    let keys: Vec<Vec<f64>> = prop(&s, b, "audio/levels").keys.iter().map(|k| k.value.components()).collect();
+    assert_eq!(keys, vec![vec![-20.0, -30.0], vec![-4.0, -34.0]], "B's 1 s key rises 6 dB on both channels");
+}
diff --git a/crates/engine/src/tests_timeline_interchange.rs b/crates/engine/src/tests/timeline_interchange.rs
similarity index 88%
rename from crates/engine/src/tests_timeline_interchange.rs
rename to crates/engine/src/tests/timeline_interchange.rs
index 45be0f7a1..0ebfa2316 100644
--- a/crates/engine/src/tests_timeline_interchange.rs
+++ b/crates/engine/src/tests/timeline_interchange.rs
@@ -52,6 +52,14 @@ fn export_and_reimport_timeline_commands() {
     let r = s.execute_checked("file.exportTimeline", json!({"comp": main, "path": tmp("NoExt"), "format": "otio", "prerender": "none"})).unwrap();
     assert!(r["path"].as_str().unwrap().ends_with("NoExt.otio"));
     assert!(s.execute_checked("file.exportTimeline", json!({"path": tmp("x.xml"), "prerender": "sometimes"})).is_err());
+    // In the background (the export dialog, #2269): a job, then the same file and result.
+    let path = tmp("Background.xml");
+    let r = s.execute_checked("file.exportTimeline", json!({"comp": main, "path": path, "background": true})).unwrap();
+    assert!(r["job"].is_string(), "{r}");
+    s.wait_jobs();
+    let done = s.job_log.last().unwrap();
+    assert_eq!((done.status.as_str(), done.result["path"].as_str()), ("done", Some(path.as_str())));
+    assert!(std::fs::read_to_string(&path).unwrap().contains("<xmeml"));
     assert!(s.execute_checked("file.importTimeline", json!({"path": "/nope/a.prproj"})).is_err());
     let formats = s.execute("file.timelineFormats", json!({})).unwrap();
     assert_eq!(formats.as_array().unwrap().len(), 6);
diff --git a/crates/engine/src/tests_track.rs b/crates/engine/src/tests/track.rs
similarity index 100%
rename from crates/engine/src/tests_track.rs
rename to crates/engine/src/tests/track.rs
diff --git a/crates/engine/src/tests_vector_import.rs b/crates/engine/src/tests/vector_import.rs
similarity index 86%
rename from crates/engine/src/tests_vector_import.rs
rename to crates/engine/src/tests/vector_import.rs
index 63513b910..10c07c2ad 100644
--- a/crates/engine/src/tests_vector_import.rs
+++ b/crates/engine/src/tests/vector_import.rs
@@ -2,7 +2,7 @@
 
 use effectcraft_color::BlendMode;
 use effectcraft_keyframe::Value as KV;
-use effectcraft_project::{ItemKind, LayerSource, MaskMode};
+use effectcraft_project::{Comp, ItemKind, Layer, LayerSource, MaskMode};
 use effectcraft_psd::write::*;
 use effectcraft_psd::{DValue, Descriptor, Rect};
 use serde_json::json;
@@ -74,22 +74,8 @@ pub(crate) fn sample_psd() -> Vec<u8> {
     write(&d)
 }
 
-#[test]
-fn psd_imports_as_composition() {
-    let path = tmp("sample.psd");
-    std::fs::write(&path, sample_psd()).unwrap();
-    let mut s = Session::default();
-    let r = s.execute_checked("file.import", json!({"paths": [path], "importAs": "composition"})).unwrap();
-    assert_eq!(r["errors"], json!([]), "{r}");
-    let cid = effectcraft_project::ItemId(r["comps"][0].as_u64().unwrap());
-    assert_eq!(s.state.active_comp, Some(cid));
-    assert_eq!(s.project.item(cid).unwrap().name, "sample");
-    let c = s.project.comp(cid).unwrap().clone();
-    assert_eq!((c.width, c.height), (120, 80));
-    let names: Vec<&str> = c.layers.iter().map(|l| l.name.as_str()).collect();
-    assert_eq!(names, ["Title", "Hue Shift", "Vector Masked", "Clipped", "Base", "Group A", "Background"]);
-    // Text layer: editable text, positioned at the type origin.
-    let title = &c.layers[0];
+/// Text layer: editable text, positioned at the type origin.
+fn assert_title_layer(title: &Layer) {
     assert!(matches!(title.source, LayerSource::Text));
     let Some(KV::Text(doc)) = title.props.prop("text/sourceText").map(|p| p.value.clone()) else { panic!("text") };
     assert_eq!(doc.text, "Hello PSD");
@@ -97,14 +83,18 @@ fn psd_imports_as_composition() {
     assert_eq!(doc.font, "Inter");
     assert_eq!(doc.style, "Bold");
     assert_eq!(title.props.prop("transform/position").unwrap().value.as_vec2(), [8.0, 70.0]);
-    // Adjustment layer with Hue/Saturation.
-    let hue = &c.layers[1];
+}
+
+/// Adjustment layer with Hue/Saturation.
+fn assert_hue_layer(hue: &Layer) {
     assert!(hue.switches.adjustment);
     let fx = hue.effects().unwrap().groups().next().unwrap();
     assert_eq!(fx.get("hue").unwrap().value.as_f64(), 40.0);
     assert_eq!(fx.get("saturation").unwrap().value.as_f64(), 10.0);
-    // Vector mask → mask; Stroke style.
-    let vm = &c.layers[2];
+}
+
+/// Vector mask → mask; Stroke style.
+fn assert_vector_mask_layer(vm: &Layer) {
     let m = vm.masks().unwrap().groups().next().unwrap();
     assert!(matches!(m.kind, effectcraft_project::GroupKind::Mask { mode: MaskMode::Add, .. }));
     let Some(KV::Path(p)) = m.get("path").map(|p| p.value.clone()) else { panic!("mask path") };
@@ -113,19 +103,23 @@ fn psd_imports_as_composition() {
     let st = vm.props.group("layerStyles/stroke").unwrap();
     assert_eq!(st.get("size").unwrap().value.as_f64(), 2.0);
     assert_eq!(st.get("position").unwrap().value, KV::Enum(1));
-    // Clipped → preserve transparency; opacity and blend mode.
+}
+
+/// Clipped → preserve transparency (opacity, blend mode); drop shadow.
+fn assert_clipped_and_shadow(c: &Comp) {
     let clipped = &c.layers[3];
     assert!(clipped.preserve_transparency);
     assert_eq!(clipped.blend_mode, BlendMode::Screen);
     assert!((clipped.props.prop("transform/opacity").unwrap().value.as_f64() - 128.0 / 255.0 * 100.0).abs() < 1e-9);
-    // Drop shadow.
     let ds = c.layers[4].props.group("layerStyles/dropShadow").unwrap();
     assert_eq!(ds.get("distance").unwrap().value.as_f64(), 9.0);
     assert_eq!(ds.get("angle").unwrap().value.as_f64(), 45.0);
     assert_eq!(ds.get("useGlobalLight").unwrap().value, KV::Bool(false));
     assert_eq!(ds.get("opacity").unwrap().value.as_f64(), 60.0);
-    // Group → collapsed precomp (pass through) with its layers.
-    let g = &c.layers[5];
+}
+
+/// Group → collapsed precomp (pass through) with its layers; footage items name their Photoshop layer.
+fn assert_group_precomp(s: &Session, g: &Layer) {
     assert!(g.switches.collapse);
     let LayerSource::Comp { item } = g.source else { panic!("precomp") };
     let inner = s.project.comp(item).unwrap();
@@ -140,11 +134,63 @@ fn psd_imports_as_composition() {
     assert_eq!((sl.name.as_str(), sl.layer_size), ("Masked Square", false));
     assert_eq!((f.width, f.height), (120, 80));
     assert_eq!(s.project.item(item).unwrap().name, "Masked Square/sample.psd");
+}
+
+#[test]
+fn psd_imports_as_composition() {
+    let path = tmp("sample.psd");
+    std::fs::write(&path, sample_psd()).unwrap();
+    let mut s = Session::default();
+    let r = s.execute_checked("file.import", json!({"paths": [path], "importAs": "composition"})).unwrap();
+    assert_eq!(r["errors"], json!([]), "{r}");
+    let cid = effectcraft_project::ItemId(r["comps"][0].as_u64().unwrap());
+    assert_eq!(s.state.active_comp, Some(cid));
+    assert_eq!(s.project.item(cid).unwrap().name, "sample");
+    let c = s.project.comp(cid).unwrap().clone();
+    assert_eq!((c.width, c.height), (120, 80));
+    let names: Vec<&str> = c.layers.iter().map(|l| l.name.as_str()).collect();
+    assert_eq!(names, ["Title", "Hue Shift", "Vector Masked", "Clipped", "Base", "Group A", "Background"]);
+    assert_title_layer(&c.layers[0]);
+    assert_hue_layer(&c.layers[1]);
+    assert_vector_mask_layer(&c.layers[2]);
+    assert_clipped_and_shadow(&c);
+    assert_group_precomp(&s, &c.layers[5]);
     // One undo step removes everything.
     s.execute("edit.undo", json!({})).unwrap();
     assert!(s.project.comp(cid).is_none());
 }
 
+/// #2573: New Composition From Footage on a Photoshop file imported as a composition opens that
+/// composition; it isn't wrapped in another.
+#[test]
+fn psd_imported_as_composition_with_new_comp_is_the_new_comp() {
+    let path = tmp("newcomp.psd");
+    std::fs::write(&path, sample_psd()).unwrap();
+    let mut s = Session::default();
+    let r = s.execute_checked("file.import", json!({"paths": [path], "importAs": "composition", "newComp": true})).unwrap();
+    assert_eq!(r["errors"], json!([]), "{r}");
+    let cid = effectcraft_project::ItemId(r["comps"][0].as_u64().unwrap());
+    assert_eq!(s.state.active_comp, Some(cid));
+    let roots = s.project.items.values().filter(|i| matches!(i.kind, ItemKind::Comp(_)) && i.name.starts_with("newcomp")).count();
+    assert_eq!(roots, 1, "no wrapper comp");
+}
+
+/// A Photoshop file imported as a composition and dropped on the Timeline (`addToComp`) adds
+/// its composition once, not its folder too.
+#[test]
+fn psd_imported_as_composition_into_a_comp_adds_one_layer() {
+    let path = tmp("dropped.psd");
+    std::fs::write(&path, sample_psd()).unwrap();
+    let mut s = Session::default();
+    let main = s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "frameRate": 30, "duration": 4})).unwrap()["comp"].as_u64().unwrap();
+    let r = s.execute_checked("file.import", json!({"paths": [path], "importAs": "composition", "addToComp": true})).unwrap();
+    assert_eq!(r["errors"], json!([]), "{r}");
+    let psd = r["comps"][0].as_u64().unwrap();
+    let layers = &s.project.comp(effectcraft_project::ItemId(main)).unwrap().layers;
+    assert_eq!(layers.len(), 1, "{layers:?}");
+    assert!(matches!(layers[0].source, LayerSource::Comp { item } if item.0 == psd));
+}
+
 #[test]
 fn psd_retain_layer_sizes() {
     let path = tmp("retain.psd");
diff --git a/crates/engine/src/tests_viewer.rs b/crates/engine/src/tests/viewer.rs
similarity index 81%
rename from crates/engine/src/tests_viewer.rs
rename to crates/engine/src/tests/viewer.rs
index 5ed0848b9..ef2bd8acc 100644
--- a/crates/engine/src/tests_viewer.rs
+++ b/crates/engine/src/tests/viewer.rs
@@ -419,7 +419,7 @@ fn shape_tool_options_paint_new_shapes() {
 fn masks_of_every_shape_tool_kind() {
     let mut s = comp();
     let sol = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
-    for (kind, n) in [("rect", 4), ("ellipse", 4), ("rounded", 8), ("polygon", 6), ("star", 10)] {
+    for (kind, n) in [("rect", 4), ("ellipse", 4), ("rounded", 8), ("polygon", 5), ("star", 10)] {
         let m = s.execute("layer.addMask", json!({"layer": sol, "shape": kind, "rect": [100, 100, 80, 80]})).unwrap()["mask"].as_u64().unwrap();
         let path = layer(&s, sol).props.find_group(m).unwrap().get("path").unwrap().value.as_path().unwrap().clone();
         assert!(path.closed, "{kind}");
@@ -697,3 +697,166 @@ fn polystar_animated_type_keeps_the_inner_controls_needed_by_other_frames() {
     assert_eq!(star.get("type").unwrap().value_at(Tick::from_seconds_f64(1.0)), KV::Enum(1));
     assert_eq!(star.get("innerRadius").unwrap().value, KV::Scalar(27.0));
 }
+
+#[test]
+fn polystar_expression_routes_synchronize_controls_in_the_same_undo_step() {
+    for explicit in [false, true] {
+        let mut s = comp();
+        let lid = s.execute("layer.newShape", json!({"kind": "polygon"})).unwrap()["layer"].as_u64().unwrap();
+        let group = |s: &Session| layer(s, lid).props.group("contents/group/contents/star").unwrap().clone();
+        let before = group(&s);
+        let uid = before.get("type").unwrap().uid;
+        s.state.selected_props = vec![(LayerId(lid), uid)];
+        let params = if explicit { json!({"layer": lid, "prop": uid, "expression": "1"}) } else { json!({"expression": "1"}) };
+        s.execute("prop.setExpression", params).unwrap();
+        let animated = group(&s);
+        assert!(animated.get("innerRadius").is_some() && animated.get("innerRoundness").is_some());
+        assert!(s.undo());
+        assert_eq!(group(&s), before);
+        assert!(s.redo());
+        assert_eq!(group(&s), animated);
+        let inner = animated.get("innerRadius").unwrap().uid;
+        s.state.selected_props = vec![(LayerId(lid), inner)];
+        s.execute("prop.setExpression", json!({"layer": lid, "prop": uid, "expression": ""})).unwrap();
+        assert!(group(&s).get("innerRadius").is_none());
+        assert!(s.state.selected_props.is_empty());
+        assert!(s.undo());
+        assert_eq!(group(&s), animated);
+        assert!(s.redo());
+        assert!(group(&s).get("innerRadius").is_none());
+    }
+}
+
+#[test]
+fn polystar_animation_menu_adds_inner_controls_and_undoes() {
+    let mut s = comp();
+    let lid = s.execute("layer.newShape", json!({"kind": "polygon"})).unwrap()["layer"].as_u64().unwrap();
+    let group = |s: &Session| layer(s, lid).props.group("contents/group/contents/star").unwrap().clone();
+    let before = group(&s);
+    s.state.selected_props = vec![(LayerId(lid), before.get("type").unwrap().uid)];
+    s.execute("anim.addKeyframe", json!({})).unwrap();
+    let animated = group(&s);
+    assert_eq!(animated.get("type").unwrap().keys.len(), 1);
+    assert!(animated.get("innerRadius").is_some() && animated.get("innerRoundness").is_some());
+    assert!(s.undo());
+    assert_eq!(group(&s), before);
+    assert!(s.redo());
+    assert_eq!(group(&s), animated);
+}
+
+#[test]
+fn deleting_the_last_polystar_type_key_removes_stale_controls_and_selection() {
+    for command in ["keys.delete", "edit.clear"] {
+        let mut s = comp();
+        let lid = s.execute("layer.newShape", json!({"kind": "polygon"})).unwrap()["layer"].as_u64().unwrap();
+        let group = |s: &Session| layer(s, lid).props.group("contents/group/contents/star").unwrap().clone();
+        let type_uid = group(&s).get("type").unwrap().uid;
+        s.execute("prop.addKey", json!({"layer": lid, "prop": type_uid, "time": 0, "value": 1})).unwrap();
+        let animated = group(&s);
+        let inner = animated.get("innerRadius").unwrap().uid;
+        s.state.selected_props = vec![(LayerId(lid), inner)];
+        s.state.selected_keys = vec![crate::KeyRef { layer: LayerId(lid), prop: type_uid, time: Tick::ZERO }];
+        s.execute(command, json!({})).unwrap();
+        let polygon = group(&s);
+        assert!(polygon.get("innerRadius").is_none() && polygon.get("innerRoundness").is_none());
+        assert!(s.state.selected_props.is_empty() && s.state.selected_keys.is_empty());
+        assert!(s.undo());
+        assert_eq!(group(&s), animated);
+        assert!(s.redo());
+        assert_eq!(group(&s), polygon);
+    }
+}
+
+#[test]
+fn polystar_sync_cleans_the_edited_compositions_parked_selection() {
+    let mut s = comp();
+    let first = s.active_comp_id().unwrap();
+    let lid = s.execute("layer.newShape", json!({"kind": "polygon"})).unwrap()["layer"].as_u64().unwrap();
+    let path = "contents/group/contents/star";
+    let type_uid = layer(&s, lid).props.group(path).unwrap().get("type").unwrap().uid;
+    s.execute("prop.addKey", json!({"layer": lid, "prop": type_uid, "time": 0, "value": 1})).unwrap();
+    let before = layer(&s, lid).props.group(path).unwrap().clone();
+    let inner = before.get("innerRadius").unwrap().uid;
+    s.state.selected_props = vec![(LayerId(lid), inner)];
+    s.state.selected_keys = vec![crate::KeyRef { layer: LayerId(lid), prop: inner, time: Tick::ZERO }];
+    s.execute("comp.new", json!({"width": 100, "height": 100, "duration": 2})).unwrap();
+    let second = s.active_comp_id().unwrap();
+    let other = s.execute("layer.newSolid", json!({})).unwrap()["layer"].as_u64().unwrap();
+    let other_prop = layer(&s, other).props.prop("transform/rotation").unwrap().uid;
+    s.execute("prop.addKey", json!({"layer": other, "prop": other_prop, "time": 0, "value": 15})).unwrap();
+    s.state.selected_props = vec![(LayerId(other), other_prop)];
+    s.state.selected_keys = vec![crate::KeyRef { layer: LayerId(other), prop: other_prop, time: Tick::ZERO }];
+    let live = (s.state.selected_props.clone(), s.state.selected_keys.clone());
+    s.execute("prop.toggleAnimation", json!({"comp": first.0, "layer": lid, "prop": type_uid, "value": false})).unwrap();
+    assert_eq!(s.active_comp_id(), Some(second));
+    assert_eq!((s.state.selected_props.clone(), s.state.selected_keys.clone()), live);
+    let parked = s.state.comp_selections.get(&first).unwrap();
+    assert!(parked.props.is_empty() && parked.keys.is_empty(), "the inactive composition must not keep removed control references");
+    let after = s.project.comp(first).unwrap().layer(LayerId(lid)).unwrap().props.group(path).unwrap().clone();
+    assert!(after.get("innerRadius").is_none());
+    assert!(s.undo());
+    assert_eq!(s.project.comp(first).unwrap().layer(LayerId(lid)).unwrap().props.group(path).unwrap(), &before);
+    assert!(s.redo());
+    assert_eq!(s.project.comp(first).unwrap().layer(LayerId(lid)).unwrap().props.group(path).unwrap(), &after);
+}
+
+#[test]
+fn polystar_multi_property_expression_clear_resolves_targets_before_removing_controls() {
+    let mut s = comp();
+    let lid = s.execute("layer.newShape", json!({"kind": "polygon"})).unwrap()["layer"].as_u64().unwrap();
+    let group = |s: &Session| layer(s, lid).props.group("contents/group/contents/star").unwrap().clone();
+    let type_uid = group(&s).get("type").unwrap().uid;
+    s.execute("prop.setExpression", json!({"layer": lid, "prop": type_uid, "expression": "1"})).unwrap();
+    let inner = group(&s).get("innerRadius").unwrap().uid;
+    s.execute("prop.setExpression", json!({"layer": lid, "prop": inner, "expression": "37"})).unwrap();
+    let before = group(&s);
+    s.state.selected_props = vec![(LayerId(lid), type_uid), (LayerId(lid), inner)];
+    assert_eq!(s.execute("prop.setExpression", json!({"expression": ""})).unwrap(), json!([null, null]));
+    let after = group(&s);
+    assert!(after.get("type").unwrap().expr.is_none());
+    assert!(after.get("innerRadius").is_none());
+    assert_eq!(s.state.selected_props, vec![(LayerId(lid), type_uid)]);
+    assert!(s.undo());
+    assert_eq!(group(&s), before);
+    assert!(s.redo());
+    assert_eq!(group(&s), after);
+}
+
+/// Undo must discard removed controls before their UIDs can name newly allocated properties.
+#[test]
+fn polystar_undo_sanitizes_live_and_parked_property_selections_before_uid_reuse() {
+    for parked in [false, true] {
+        let mut s = comp();
+        let cid = s.active_comp_id().unwrap();
+        let lid = s.execute("layer.newShape", json!({"kind": "polygon"})).unwrap()["layer"].as_u64().unwrap();
+        let polygon = layer(&s, lid).props.group("contents/group/contents/star").unwrap().clone();
+        let type_uid = polygon.get("type").unwrap().uid;
+        s.execute("comp.new", json!({"width": 100, "height": 100, "duration": 2})).unwrap();
+        let other = s.active_comp_id().unwrap();
+        s.activate_comp(cid);
+        s.state.selected_props = vec![(LayerId(lid), type_uid)];
+        s.execute("anim.addKeyframe", json!({})).unwrap();
+        let inner = layer(&s, lid).props.group("contents/group/contents/star").unwrap().get("innerRadius").unwrap().uid;
+        let valid = vec![(LayerId(lid), type_uid), (LayerId(lid), polygon.uid)];
+        s.state.selected_props = valid.iter().copied().chain([(LayerId(lid), inner)]).collect();
+        s.state.selected_keys = vec![crate::KeyRef { layer: LayerId(lid), prop: inner, time: Tick::ZERO }];
+        if parked {
+            s.activate_comp(other);
+        }
+        assert!(s.undo());
+        let (props, keys) = if parked {
+            let selection = s.state.comp_selections.get(&cid).unwrap();
+            (&selection.props, &selection.keys)
+        } else {
+            (&s.state.selected_props, &s.state.selected_keys)
+        };
+        assert_eq!(props, &valid, "remove stale leaves while preserving property and group selections");
+        assert!(keys.is_empty());
+        s.activate_comp(cid);
+        s.execute("prop.separateDimensions", json!({"layer": lid, "value": true})).unwrap();
+        let position_z = layer(&s, lid).props.prop("transform/positionZ").unwrap().clone();
+        assert_eq!(position_z.uid, inner, "the removed control's UID was actually reused");
+        s.execute("prop.setExpression", json!({"expression": "1"})).unwrap();
+        assert_eq!(layer(&s, lid).props.prop("transform/positionZ").unwrap(), &position_z, "the reused UID must not become an implicit expression target");
+    }
+}
diff --git a/crates/engine/src/tests_crypto_pick.rs b/crates/engine/src/tests_crypto_pick.rs
deleted file mode 100644
index 799027c7e..000000000
--- a/crates/engine/src/tests_crypto_pick.rs
+++ /dev/null
@@ -1,336 +0,0 @@
-//! `effect.pickCryptomatte` / `effect.cryptomatteAt` (#473): the Cryptomatte eyedropper reads the
-//! aux channels the effect renders from (footage at its source time, a 3D precomp's generated
-//! pass) and edits the Selection text in one undo step.
-
-use std::sync::Arc;
-
-use effectcraft_project::{Footage, FootageKind, ItemId};
-use effectcraft_raster::channels3d::{crypto_float, crypto_hash};
-use effectcraft_raster::{AuxChannels, Image};
-use effectcraft_time::{FrameRate, Tick};
-use serde_json::{Value, json};
-
-use crate::Session;
-use crate::render::FootageSource;
-
-const COMMA: &str = "Green, \"Glossy\"";
-
-/// 8 × 4 footage with a 16 × 8 Cryptomatte (two aux pixels per layer pixel). Layer pixels in x:
-/// 0-1 `left` (0.6) over `right` (0.4); 2-3 `left` (0.3) under the comma name (0.7), ranks out of
-/// order; 4-5 `star*`; 6 an ID missing from the manifest; 7 a 0.5 / 0.5 tie of `left` and
-/// `right`. Rows 3+ are empty. From 1 s of source time `late` replaces columns 0-1.
-struct Crypto;
-
-fn aux_at(t: Tick) -> AuxChannels {
-    let (w, h) = (16usize, 8usize);
-    let mut planes = vec![vec![0.0f32; w * h]; 4];
-    for (i, x) in (0..w * h).map(|i| (i, i % w)).filter(|(i, _)| i / w < 6) {
-        let late = if t >= Tick::from_seconds_f64(1.0) { "late" } else { "left" };
-        let (a, ca, b, cb) = match x {
-            0..4 => (late, 0.6, "right", 0.4),
-            4..8 => ("left", 0.3, COMMA, 0.7),
-            8..12 => ("star*", 1.0, "", 0.0),
-            12..14 => ("ghost", 1.0, "", 0.0),
-            _ => ("left", 0.5, "right", 0.5),
-        };
-        for (k, v) in [crypto_float(crypto_hash(a)), ca, crypto_float(crypto_hash(b)), cb].into_iter().enumerate() {
-            planes[k][i] = v;
-        }
-    }
-    let mut aux = AuxChannels::new(w as u32, h as u32, 1.0);
-    for (k, c) in ["R", "G", "B", "A"].iter().enumerate() {
-        aux.channels.push((format!("CryptoObject00.{c}"), planes[k].clone()));
-    }
-    aux.manifests = vec![("CryptoObject".into(), ["left", "right", "late", COMMA, "star*"].iter().map(|n| (n.to_string(), crypto_hash(n))).collect())];
-    aux
-}
-
-impl FootageSource for Crypto {
-    fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
-        Some(Arc::new(Image::new(f.width, f.height)))
-    }
-    fn aux(&self, _: ItemId, _: &Footage, t: Tick) -> Option<Arc<AuxChannels>> {
-        Some(Arc::new(aux_at(t)))
-    }
-}
-
-struct Probe;
-impl crate::Importer for Probe {
-    fn probe(&self, path: &str) -> Result<Footage, String> {
-        let duration = Tick::from_seconds_f64(2.0);
-        // A half-size proxy of the EXR.
-        let (width, height) = if path.contains("proxy") { (4, 2) } else { (8, 4) };
-        Ok(Footage {
-            path: path.into(),
-            kind: FootageKind::Video,
-            width,
-            height,
-            has_video: true,
-            frame_rate: FrameRate::from_f64(24.0),
-            duration,
-            ..Default::default()
-        })
-    }
-}
-
-fn session() -> Session {
-    let mut s = Session { footage: Arc::new(Crypto), importer: Some(Arc::new(Probe)), ..Default::default() };
-    let item = s.execute("file.import", json!({"paths": ["/renders/crypto.exr"]})).unwrap()["items"][0].clone();
-    s.execute("comp.new", json!({"name": "C", "width": 8, "height": 4, "frameRate": 24, "duration": 2})).unwrap();
-    s.execute("layer.addItem", json!({"item": item})).unwrap();
-    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
-    s
-}
-
-fn pick(s: &mut Session, x: f64, mode: &str) -> Value {
-    s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": x, "y": 1.5, "mode": mode})).unwrap()
-}
-
-fn selection(s: &Session) -> String {
-    let l = &s.active_comp().unwrap().layers[0];
-    let g = l.effects().unwrap().groups().next().unwrap();
-    match &g.prop("selection").unwrap().value {
-        effectcraft_keyframe::Value::Str(t) => t.clone(),
-        v => panic!("{v:?}"),
-    }
-}
-
-#[test]
-fn picks_replace_add_and_remove_in_one_undo_step_each() {
-    let mut s = session();
-    let steps = s.history.undo.len();
-    let r = pick(&mut s, 0.5, "replace");
-    assert_eq!((r["name"].as_str(), r["selection"].as_str(), r["changed"].as_bool()), (Some("left"), Some("left"), Some(true)), "{r}");
-    assert_eq!(r["hash"], format!("{:08x}", crypto_hash("left")));
-    assert_eq!(s.history.undo.len(), steps + 1);
-    // The highest coverage wins even when it is not rank 0; the name is quoted.
-    assert_eq!(pick(&mut s, 2.5, "add")["selection"], r#"left, "Green, \"Glossy\"""#);
-    // Adding it again changes nothing and leaves no undo step.
-    let again = pick(&mut s, 3.5, "add");
-    assert_eq!((again["changed"].as_bool(), s.history.undo.len()), (Some(false), steps + 2));
-    // A `*` name and an unnamed ID go in as hashes; a tie goes to rank 0.
-    pick(&mut s, 4.5, "add");
-    assert_eq!(pick(&mut s, 6.5, "add")["selection"], format!(r#"left, "Green, \"Glossy\"", <{:08x}>, <{:08x}>"#, crypto_hash("star*"), crypto_hash("ghost")));
-    assert_eq!(s.execute("effect.cryptomatteAt", json!({"effect": 1, "x": 7.5, "y": 0.5})).unwrap()["name"], "left");
-    let r = pick(&mut s, 0.0, "remove");
-    assert_eq!(r["selection"], format!(r#""Green, \"Glossy\"", <{:08x}>, <{:08x}>"#, crypto_hash("star*"), crypto_hash("ghost")));
-    assert_eq!(r["selected"], false);
-    // The text parses back to exactly the picked IDs.
-    let manifest = aux_at(Tick::ZERO).manifests[0].1.clone();
-    let got = effectcraft_effects::selection_hashes(&selection(&s), Some(&manifest));
-    assert_eq!(got, [COMMA, "star*", "ghost"].map(crypto_hash));
-    assert_eq!(s.history.undo.len(), steps + 5);
-    s.execute("edit.undo", json!({})).unwrap();
-    assert!(selection(&s).starts_with("left, "), "{}", selection(&s));
-    pick(&mut s, 2.0, "replace");
-    assert_eq!(selection(&s), r#""Green, \"Glossy\"""#);
-    // The same selection with other spacing: no change, no undo step.
-    s.execute_checked("prop.set", json!({"path": "effects/#1/selection", "value": " \"Green, \\\"Glossy\\\"\" "})).unwrap();
-    let n = s.history.undo.len();
-    assert_eq!((pick(&mut s, 2.0, "replace")["changed"].as_bool(), s.history.undo.len()), (Some(false), n));
-}
-
-#[test]
-fn bad_points_layers_and_modes_are_errors_and_change_nothing() {
-    let mut s = session();
-    let at = |s: &mut Session, x: f64, y: f64| s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": x, "y": y}));
-    for (x, y) in [(-0.1, 1.0), (8.0, 1.0), (1.0, 4.0), (1.0, 3.5), (1e300, -1e300)] {
-        assert!(at(&mut s, x, y).is_err(), "{x},{y}");
-        assert_eq!(s.execute("effect.cryptomatteAt", json!({"effect": 1, "x": x, "y": y})).unwrap(), Value::Null);
-    }
-    assert!(s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 1, "y": 1, "mode": "toggle"})).is_err());
-    assert!(s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 1})).is_err());
-    for scale in [0.0, -1.0, 2.0] {
-        assert!(s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 1, "y": 1, "scale": scale})).is_err(), "{scale}");
-    }
-    s.execute_checked("effect.apply", json!({"effect": "Gaussian Blur"})).unwrap();
-    assert!(s.execute_checked("effect.pickCryptomatte", json!({"effect": 2, "x": 1, "y": 1})).is_err(), "not a Cryptomatte effect");
-    assert_eq!(selection(&s), "");
-    // A layer without aux channels.
-    s.execute("layer.newSolid", json!({"name": "S"})).unwrap();
-    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
-    let e = s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 1, "y": 1})).unwrap_err().to_string();
-    assert!(e.contains("no Cryptomatte channels"), "{e}");
-    // An expression-driven Selection would ignore the edit.
-    let mut s = session();
-    s.execute_checked("prop.setExpression", json!({"path": "effects/#1/selection", "expression": "\"right\""})).unwrap();
-    assert!(s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 1, "y": 1})).is_err());
-    assert_eq!(s.execute("effect.cryptomatteAt", json!({"effect": 1, "x": 1, "y": 1})).unwrap()["selected"], false);
-}
-
-/// The pick reads the frame the render shows: Time Remap's source time, not the layer time.
-#[test]
-fn time_remap_picks_the_shown_source_frame() {
-    let mut s = session();
-    assert_eq!(pick(&mut s, 0.5, "replace")["name"], "left");
-    s.execute_checked("layer.enableTimeRemap", json!({})).unwrap();
-    s.execute_checked("prop.set", json!({"path": "timeRemap", "value": 1.5})).unwrap();
-    assert_eq!(pick(&mut s, 0.5, "replace")["name"], "late");
-}
-
-/// A precomp of a 3D comp: the generated CryptoObject pass names its layers.
-#[test]
-fn picks_on_a_precomp_of_a_3d_comp() {
-    let mut s = Session::default();
-    s.execute("comp.new", json!({"name": "Outer", "width": 40, "height": 20, "frameRate": 24, "duration": 1})).unwrap();
-    let l = s.execute("layer.newSolid", json!({"name": "Red, Ball", "width": 40, "height": 20})).unwrap()["layer"].clone();
-    s.execute("layer.setSwitch", json!({"layers": [l], "switch": "threeD", "value": true})).unwrap();
-    s.execute("layer.precompose", json!({"layers": [l], "name": "Inner"})).unwrap();
-    s.execute("layer.select", json!({"layers": [s.active_comp().unwrap().layers[0].id.0]})).ok();
-    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
-    let r = s.execute_checked("effect.pickCryptomatte", json!({"effect": 1, "x": 20, "y": 10})).unwrap();
-    assert_eq!((r["name"].as_str(), r["selection"].as_str()), (Some("Red, Ball"), Some("\"Red, Ball\"")), "{r}");
-}
-
-/// The matte the rendered Cryptomatte effect gives the picked ID at the buffer pixel under
-/// `{x, y}`: the pick has to name the ID the effect's own input buffer samples there.
-fn rendered_matte_of_pick(s: &mut Session, x: f64, y: f64, scale: f64) -> (String, f32) {
-    let r = s.execute_checked("effect.pickCryptomatte", json!({"effect": "Cryptomatte", "x": x, "y": y, "scale": scale, "mode": "replace"})).unwrap();
-    let fx = s.active_comp().unwrap().layers[0].effects().unwrap().groups().position(|g| g.match_id == "ec.3d.cryptomatte").unwrap() + 1;
-    s.execute_checked("prop.set", json!({"path": format!("effects/#{fx}/matteOnly"), "value": true})).unwrap();
-    let (cid, comp) = (s.active_comp_id().unwrap(), s.active_comp().unwrap());
-    let layer = &comp.layers[0];
-    let ctx = effectcraft_render::EvalCtx { project: &s.project, comp_id: cid, comp, time: Tick::ZERO, expr: None, footage: None };
-    let buf = s.renderer(effectcraft_render::RenderOpts { scale, ..Default::default() }).content_buf(&ctx, layer).unwrap();
-    let (px, py) = buf.to_px([x, y]);
-    let m = buf.img.get(px.floor() as i64, py.floor() as i64)[0];
-    (r["name"].as_str().unwrap_or("?").to_string(), m)
-}
-
-/// Between 3/4 and full resolution footage keeps its native pixels: at 0.8 the effect samples
-/// layer pixel 2 (the comma name, 0.7) at x = 2.2, not the 0.8-grid pixel snapped back to 1.
-#[test]
-fn pick_at_scale_0_8_matches_the_native_buffer_the_effect_renders() {
-    let mut s = session();
-    let (name, m) = rendered_matte_of_pick(&mut s, 2.2, 1.5, 0.8);
-    assert!(m >= 0.5, "picked {name:?}, but the render gives it matte {m} there");
-    assert_eq!(name, COMMA);
-}
-
-/// A half-size proxy renders a buffer at 0.5 layer pixels per pixel even at full resolution:
-/// x = 6.5 lies in buffer pixel 3, which samples layer x = 7 (the `left` / `right` tie).
-#[test]
-fn pick_on_a_proxy_matches_the_proxy_sized_buffer() {
-    let mut s = session();
-    let item = *s.project.items.iter().find(|(_, i)| matches!(i.kind, effectcraft_project::ItemKind::Footage(_))).unwrap().0;
-    s.execute("file.setProxy", json!({"item": item.0, "path": "/renders/crypto_proxy.exr"})).unwrap();
-    let (name, m) = rendered_matte_of_pick(&mut s, 6.5, 1.5, 1.0);
-    assert!(m >= 0.5, "picked {name:?}, but the render gives it matte {m} there");
-    assert_eq!(name, "left");
-}
-
-/// 1920-px footage with `left` up to x = 120 and `right` after it, and a 104-px proxy.
-struct Edge;
-impl FootageSource for Edge {
-    fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
-        Some(Arc::new(Image::new(f.width, f.height)))
-    }
-    fn aux(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<AuxChannels>> {
-        let (w, h) = (1920usize, 40usize);
-        let mut aux = AuxChannels::new(w as u32, h as u32, 1.0);
-        let ids = (0..w * h).map(|i| crypto_float(crypto_hash(if i % w < 120 { "left" } else { "right" }))).collect();
-        aux.channels = vec![("CryptoObject00.R".into(), ids), ("CryptoObject00.G".into(), vec![1.0; w * h])];
-        aux.manifests = vec![("CryptoObject".into(), ["left", "right"].iter().map(|n| (n.to_string(), crypto_hash(n))).collect())];
-        Some(Arc::new(aux))
-    }
-}
-
-/// Proxy buffer pixel 6's centre maps to layer x = 6.5 / (104 / 1920): 120.0 by division, but
-/// 119.99999999999999 by the reciprocal the effect multiplies with. The pick must agree.
-#[test]
-fn pick_maps_pixel_centres_bit_exactly_as_the_effect() {
-    let mut s = Session { footage: Arc::new(Edge), ..Default::default() };
-    let at = |path: &str, width| Footage {
-        path: path.into(),
-        kind: FootageKind::Video,
-        width,
-        height: 40,
-        has_video: true,
-        frame_rate: FrameRate::from_f64(24.0),
-        duration: Tick::from_seconds_f64(2.0),
-        ..Default::default()
-    };
-    s.importer = Some(Arc::new(EdgeProbe(at("/renders/edge.exr", 1920), at("/renders/edge_proxy.exr", 104))));
-    let item = s.execute("file.import", json!({"paths": ["/renders/edge.exr"]})).unwrap()["items"][0].clone();
-    s.execute("comp.new", json!({"name": "C", "width": 1920, "height": 40, "frameRate": 24, "duration": 2})).unwrap();
-    s.execute("layer.addItem", json!({"item": item})).unwrap();
-    s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
-    s.execute("file.setProxy", json!({"item": item, "path": "/renders/edge_proxy.exr"})).unwrap();
-    let (name, m) = rendered_matte_of_pick(&mut s, 118.0, 5.0, 1.0);
-    assert_eq!((name.as_str(), m), ("left", 1.0));
-}
-
-struct EdgeProbe(Footage, Footage);
-impl crate::Importer for EdgeProbe {
-    fn probe(&self, path: &str) -> Result<Footage, String> {
-        Ok(if path.contains("proxy") { self.1.clone() } else { self.0.clone() })
-    }
-}
-
-/// Footage whose decoded frames are `num / den` of the probed size (a file re-rendered at another
-/// resolution, a relinked file): the render stretches them over the layer.
-struct OffNominal(u32, u32);
-impl FootageSource for OffNominal {
-    fn frame(&self, _: ItemId, f: &Footage, _: Tick) -> Option<Arc<Image>> {
-        Some(Arc::new(Image::new(f.width * self.0 / self.1, f.height * self.0 / self.1)))
-    }
-    fn aux(&self, _: ItemId, _: &Footage, t: Tick) -> Option<Arc<AuxChannels>> {
-        Some(Arc::new(aux_at(t)))
-    }
-}
-
-/// Points along rows `ys` where the picked ID isn't lit in the rendered matte under the point.
-fn mismatches(s: &mut Session, scales: &[f64], xs: impl Iterator<Item = f64> + Clone, ys: &[f64]) -> Vec<String> {
-    let mut bad = vec![];
-    for &scale in scales {
-        for (x, &y) in ys.iter().flat_map(|y| xs.clone().map(move |x| (x, y))) {
-            if s.execute("effect.cryptomatteAt", json!({"effect": "Cryptomatte", "x": x, "y": y, "scale": scale})).unwrap().is_null() {
-                continue;
-            }
-            let (name, m) = rendered_matte_of_pick(s, x, y, scale);
-            if m < 0.5 {
-                bad.push(format!("scale {scale} ({x:.2}, {y}): picked {name:?}, matte {m}"));
-            }
-        }
-    }
-    bad
-}
-
-const PREVIEW_SCALES: [f64; 7] = [1.0, 0.8, 0.75, 0.74, 0.5, 0.33, 0.25];
-
-/// The pick follows the decoded frame's real size, not the footage's nominal one.
-#[test]
-fn pick_matches_the_render_when_frames_decode_off_nominal_size() {
-    for (num, den) in [(2, 1), (1, 2), (3, 4)] {
-        let mut s = Session { footage: Arc::new(OffNominal(num, den)), importer: Some(Arc::new(Probe)), ..Default::default() };
-        let item = s.execute("file.import", json!({"paths": ["/renders/crypto.exr"]})).unwrap()["items"][0].clone();
-        s.execute("comp.new", json!({"name": "C", "width": 8, "height": 4, "frameRate": 24, "duration": 2})).unwrap();
-        s.execute("layer.addItem", json!({"item": item})).unwrap();
-        s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
-        let bad = mismatches(&mut s, &PREVIEW_SCALES, (0..80).map(|i| i as f64 * 0.1 + 0.05), &[0.3, 1.7, 2.6]);
-        assert!(bad.is_empty(), "decode {num}/{den}: {} mismatches:\n{}", bad.len(), bad.join("\n"));
-    }
-}
-
-/// A precomp of a 3D comp, with and without Preserve Resolution (drawn at full size below full
-/// resolution), behind a disabled effect: the pick names the ID the rendered matte shows.
-#[test]
-fn pick_matches_the_render_on_precomps_with_and_without_preserve_resolution() {
-    for preserve in [false, true] {
-        let mut s = Session::default();
-        s.execute("comp.new", json!({"name": "Outer", "width": 40, "height": 20, "frameRate": 24, "duration": 2})).unwrap();
-        let a = s.execute("layer.newSolid", json!({"name": "A", "width": 40, "height": 20})).unwrap()["layer"].clone();
-        let b = s.execute("layer.newSolid", json!({"name": "B", "width": 7, "height": 20})).unwrap()["layer"].clone();
-        s.execute_checked("prop.set", json!({"layer": b, "path": "transform/position", "value": [3.5, 10, -10]})).unwrap();
-        s.execute("layer.setSwitch", json!({"layers": [a, b], "switch": "threeD", "value": true})).unwrap();
-        s.execute("layer.precompose", json!({"layers": [a, b], "name": "Inner"})).unwrap();
-        let inner = *s.project.items.iter().find(|(_, i)| i.name == "Inner").unwrap().0;
-        s.execute_checked("comp.settings", json!({"comp": inner.0, "preserveResolution": preserve})).unwrap();
-        s.execute("layer.select", json!({"layers": [s.active_comp().unwrap().layers[0].id.0]})).ok();
-        s.execute_checked("effect.apply", json!({"effect": "Gaussian Blur"})).unwrap();
-        s.execute_checked("effect.toggle", json!({"effect": 1, "value": false})).unwrap();
-        s.execute_checked("effect.apply", json!({"effect": "Cryptomatte"})).unwrap();
-        let bad = mismatches(&mut s, &PREVIEW_SCALES, (0..93).map(|i| i as f64 * 0.15 + 0.05), &[10.0]);
-        assert!(bad.is_empty(), "preserve {preserve}: {} mismatches:\n{}", bad.len(), bad.join("\n"));
-    }
-}
diff --git a/crates/engine/src/tests_delete_keys.rs b/crates/engine/src/tests_delete_keys.rs
deleted file mode 100644
index b1b9af316..000000000
--- a/crates/engine/src/tests_delete_keys.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//! `keys.delete` reports the keys it removed, not the keys it was asked to remove.
-
-use effectcraft_project::LayerId;
-use serde_json::json;
-
-use crate::{KeyRef, Session};
-
-fn setup() -> (Session, u64, u64) {
-    let mut s = Session::default();
-    s.execute_checked("comp.new", json!({"width": 64, "height": 64, "frameRate": 30, "duration": 4})).unwrap();
-    let layer = s.execute_checked("layer.newSolid", json!({"name": "Box", "color": "#fff"})).unwrap()["layer"].as_u64().unwrap();
-    for t in 0..3 {
-        s.execute_checked("prop.addKey", json!({"layer": layer, "path": "transform/opacity", "time": t, "value": t * 25})).unwrap();
-    }
-    let prop = s.active_comp().unwrap().layer(LayerId(layer)).unwrap().props.prop("transform/opacity").unwrap().uid;
-    (s, layer, prop)
-}
-
-fn keys_of(s: &Session, layer: u64, prop: u64) -> Vec<KeyRef> {
-    let keys = &s.active_comp().unwrap().layer(LayerId(layer)).unwrap().props.find(prop).unwrap().keys;
-    keys.iter().map(|k| KeyRef { layer: LayerId(layer), prop, time: k.time }).collect()
-}
-
-#[test]
-fn delete_keys_counts_only_the_keys_it_removed() {
-    let (mut s, layer, prop) = setup();
-    let keys = keys_of(&s, layer, prop);
-    assert_eq!(keys.len(), 3);
-    // Two real keys, one of them listed twice, and a key of a property that does not exist.
-    let missing = KeyRef { layer: LayerId(layer), prop: u64::MAX, time: keys[1].time };
-    s.state.selected_keys = vec![keys[0], keys[2], keys[0], missing];
-    let removed = s.execute_checked("keys.delete", json!({})).unwrap();
-    assert_eq!(removed, json!(2));
-    assert_eq!(keys_of(&s, layer, prop), vec![keys[1]]);
-}
-
-#[test]
-fn delete_keys_reports_zero_when_no_selected_key_exists() {
-    let (mut s, layer, prop) = setup();
-    let keys = keys_of(&s, layer, prop);
-    s.state.selected_keys = vec![KeyRef { layer: LayerId(layer), prop: u64::MAX, time: keys[0].time }];
-    let removed = s.execute_checked("keys.delete", json!({})).unwrap();
-    assert_eq!(removed, json!(0));
-    assert_eq!(keys_of(&s, layer, prop), keys);
-}
diff --git a/crates/engine/src/tests_models.rs b/crates/engine/src/tests_models.rs
deleted file mode 100644
index 66111eb34..000000000
--- a/crates/engine/src/tests_models.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-//! Settings ▸ Roto Brush and Settings ▸ Face Tracking: the model registry, choosing, installing
-//! (verified, with its notice) and loading trained models.
-
-use std::sync::Arc;
-
-use effectcraft_segment::Task;
-use serde_json::json;
-
-use crate::Session;
-use crate::config::{ConfigStore, DirConfig};
-
-fn session(tag: &str) -> (Session, std::path::PathBuf) {
-    let d = std::env::temp_dir().join(format!("ec-models-{tag}-{}", std::process::id()));
-    let store: Arc<dyn ConfigStore> = Arc::new(DirConfig::new(d.join("config")));
-    (Session { config: Some(store), ..Default::default() }, d)
-}
-
-/// Poll until `task`'s model is in use (or a few seconds pass).
-fn wait_loaded(s: &mut Session, task: Task) {
-    for _ in 0..400 {
-        s.poll_models();
-        if s.models.status(task).active.is_some() {
-            return;
-        }
-        std::thread::sleep(std::time::Duration::from_millis(20));
-    }
-}
-
-#[test]
-fn models_are_listed_chosen_and_verified() {
-    crate::tests_roto::hold_roto_cache_test_lock();
-    let (mut s, d) = session("list");
-    std::fs::create_dir_all(&d).unwrap();
-    let bogus = d.join("bogus.bin");
-    std::fs::write(&bogus, b"not the weights").unwrap();
-    for (prefix, model, task) in [("roto", "mobilesam", Task::Mask), ("face", "mediapipe-face", Task::Face)] {
-        let list = s.execute_checked(&format!("{prefix}.models"), json!({})).unwrap();
-        let ids: Vec<&str> = list["models"].as_array().unwrap().iter().map(|m| m["id"].as_str().unwrap()).collect();
-        assert_eq!(ids, ["classical", model]);
-        let m = &list["models"][1];
-        assert_eq!((m["licence"].as_str(), m["installed"].as_bool()), (Some("Apache-2.0"), Some(false)));
-        assert!(m["url"].as_str().unwrap().starts_with("https://") && !m["authors"].as_str().unwrap().is_empty());
-        // Unknown ids, the other task's models and files that aren't the published weights are
-        // refused.
-        let other = if task == Task::Mask { "mediapipe-face" } else { "mobilesam" };
-        for id in ["nope", other] {
-            assert!(s.execute_checked(&format!("{prefix}.model.select"), json!({"id": id})).is_err(), "{prefix} {id}");
-        }
-        let path = bogus.to_string_lossy();
-        let e = s.execute_checked(&format!("{prefix}.model.install"), json!({"path": path})).unwrap_err().to_string();
-        assert!(e.contains("SHA-256"), "{e}");
-        assert!(s.execute_checked(&format!("{prefix}.model.install"), json!({"path": path, "id": model})).is_err());
-        // Choosing a model that isn't installed keeps the classic engine.
-        s.execute_checked(&format!("{prefix}.model.select"), json!({"id": model})).unwrap();
-        assert_eq!(s.chosen_model(task), model);
-        assert!(s.models.status(task).active.is_none());
-        assert!(crate::prefs::pages().iter().any(|p| p.id == prefix));
-    }
-    assert!(s.models.face().is_none());
-    assert_eq!(crate::prefs::page_id("Face Tracking"), Some("face"));
-    // With the real weights (EFFECTCRAFT_MOBILESAM=path/to/mobile_sam.pt): install, load, use.
-    if let Ok(path) = std::env::var("EFFECTCRAFT_MOBILESAM") {
-        s.execute_checked("roto.model.install", json!({"path": path})).unwrap();
-        wait_loaded(&mut s, Task::Mask);
-        assert_eq!(s.models.status(Task::Mask).active.as_deref(), Some("mobilesam"));
-        // Roto Brush 3.0 (the default version) now segments with it.
-        let params = crate::effects::Params { values: [("version".to_string(), effectcraft_keyframe::Value::Enum(2))].into_iter().collect() };
-        assert_eq!(crate::effects::roto::model_for(&params).map(|m| m.info().id), Some("mobilesam"));
-        s.execute_checked("roto.model.select", json!({"id": "classical"})).unwrap();
-        assert!(crate::effects::roto::model_for(&params).is_none());
-    }
-    // EFFECTCRAFT_FACE_LANDMARKER=path/to/face_landmarker.task: installed with its notice,
-    // loaded for face tracking, dropped when the classic tracker is chosen, removed.
-    if let Ok(path) = std::env::var("EFFECTCRAFT_FACE_LANDMARKER") {
-        let r = s.execute_checked("face.model.install", json!({"path": path})).unwrap();
-        assert_eq!(r["id"], "mediapipe-face");
-        let dir = s.models_dir().unwrap();
-        let notice = std::fs::read_to_string(dir.join("face_landmarker.task.NOTICE.txt")).unwrap();
-        assert!(notice.contains("Google LLC") && notice.contains("Apache-2.0"), "{notice}");
-        wait_loaded(&mut s, Task::Face);
-        assert_eq!(s.models.face().map(|m| m.info().id), Some("mediapipe-face"));
-        s.execute_checked("face.model.select", json!({"id": "classical"})).unwrap();
-        assert!(s.models.face().is_none());
-        assert_eq!(s.execute_checked("face.model.remove", json!({"id": "mediapipe-face"})).unwrap()["removed"], true);
-        assert!(!dir.join("face_landmarker.task").exists() && !dir.join("face_landmarker.task.NOTICE.txt").exists());
-    }
-    let _ = std::fs::remove_dir_all(d);
-}
diff --git a/crates/engine/src/tests_proxy.rs b/crates/engine/src/tests_proxy.rs
deleted file mode 100644
index 16e0cb00c..000000000
--- a/crates/engine/src/tests_proxy.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-//! Proxies (Set Proxy, Use Proxy, Proxy Use render settings, comp proxies, Create Proxy) and
-//! Interpret Footage (fields, pixel aspect, alpha guess / invert, linear light), rendered through
-//! a synthetic footage source.
-
-use std::sync::Arc;
-
-use effectcraft_project::render_queue::ProxyUse;
-use effectcraft_project::{AlphaMode, Footage, FootageKind, ItemId, ItemKind};
-use effectcraft_raster::Image;
-use effectcraft_time::{FrameRate, Tick};
-use serde_json::json;
-
-use crate::Session;
-use crate::render::{FootageSource, RenderOpts};
-
-/// Files by name: `red16.png` (16×16 red), `blue8.png` (8×8 blue), `lines.mov` (interlaced:
-/// even rows red, odd rows blue; 4×4, 10 fps), `matte_black.png` / `matte_white.png` (a
-/// semi-transparent green premultiplied against black / white, read as straight), `half.png`
-/// (white at 25 % alpha), `wide.png` (10×10 white).
-struct Synthetic;
-
-fn file_px(path: &str, x: u32, y: u32) -> [f32; 4] {
-    let name = std::path::Path::new(path).file_name().and_then(std::ffi::OsStr::to_str).unwrap_or("");
-    match name {
-        "red16.png" => [1.0, 0.0, 0.0, 1.0],
-        "blue8.png" => [0.0, 0.0, 1.0, 1.0],
-        "lines.mov" => {
-            if y.is_multiple_of(2) {
-                [1.0, 0.0, 0.0, 1.0]
-            } else {
-                [0.0, 0.0, 1.0, 1.0]
-            }
-        }
-        // Straight interpretation of a file whose colour is green·a + matte·(1 − a), a = 0.5.
-        "matte_black.png" => [0.0, 0.5, 0.0, 0.5],
-        "matte_white.png" => [0.5, 1.0, 0.5, 0.5],
-        "half.png" => [1.0, 1.0, 1.0, 0.25],
-        _ => {
-            let _ = x;
-            [1.0, 1.0, 1.0, 1.0]
-        }
-    }
-}
-
-fn size_of(path: &str) -> (u32, u32) {
-    match std::path::Path::new(path).file_name().and_then(std::ffi::OsStr::to_str).unwrap_or("") {
-        "red16.png" => (16, 16),
-        "blue8.png" => (8, 8),
-        "lines.mov" | "matte_black.png" | "matte_white.png" | "half.png" => (4, 4),
-        _ => (10, 10),
-    }
-}
-
-impl FootageSource for Synthetic {
-    fn frame(&self, _: ItemId, f: &Footage, _t: Tick) -> Option<Arc<Image>> {
-        let (w, h) = size_of(&f.path);
-        let mut img = Image::new(w, h);
-        for y in 0..h {
-            for x in 0..w {
-                // Decoders hand out premultiplied pixels (straight file colour × alpha).
-                let p = file_px(&f.path, x, y);
-                img.set(x, y, [p[0] * p[3], p[1] * p[3], p[2] * p[3], p[3]]);
-            }
-        }
-        Some(Arc::new(img))
-    }
-}
-
-struct Probe;
-impl crate::Importer for Probe {
-    fn probe(&self, path: &str) -> Result<Footage, String> {
-        let (w, h) = size_of(path);
-        let video = path.ends_with(".mov");
-        Ok(Footage {
-            path: path.into(),
-            kind: if video { FootageKind::Video } else { FootageKind::Still },
-            width: w,
-            height: h,
-            has_video: true,
-            frame_rate: FrameRate::from_f64(10.0),
-            duration: Tick::from_seconds_f64(if video { 2.0 } else { 0.0 }),
-            ..Default::default()
-        })
-    }
-}
-
-fn session() -> Session {
-    Session { footage: Arc::new(Synthetic), importer: Some(Arc::new(Probe)), ..Default::default() }
-}
-
-fn import(s: &mut Session, path: &str) -> ItemId {
-    ItemId(s.execute("file.import", json!({"paths": [path]})).unwrap()["items"][0].as_u64().unwrap())
-}
-
-fn px(s: &Session, comp: ItemId, t: f64, opts: RenderOpts, x: i64, y: i64) -> [f32; 4] {
-    s.render(comp, Tick::from_seconds_f64(t), opts).get(x, y)
-}
-
-fn red(p: [f32; 4]) -> bool {
-    p[0] > 0.99 && p[2] < 0.01 && p[3] > 0.99
-}
-fn blue(p: [f32; 4]) -> bool {
-    p[2] > 0.99 && p[0] < 0.01 && p[3] > 0.99
-}
-
-#[test]
-fn footage_proxy_follows_use_proxy_and_proxy_use() {
-    let mut s = session();
-    let full = import(&mut s, "/m/red16.png");
-    s.execute("comp.new", json!({"name": "C", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
-    let c = s.active_comp_id().unwrap();
-    s.execute("layer.addItem", json!({"item": full.0})).unwrap();
-    let o = RenderOpts::default();
-    assert!(red(px(&s, c, 0.0, o, 8, 8)));
-    s.execute("file.setProxy", json!({"item": full.0, "path": "/m/blue8.png"})).unwrap();
-    // The 8×8 proxy fills the 16×16 footage frame.
-    for (x, y) in [(1, 1), (8, 8), (14, 14)] {
-        assert!(blue(px(&s, c, 0.0, o, x, y)), "proxy at {x},{y}");
-    }
-    assert!(s.project.item(full).unwrap().proxy.as_ref().unwrap().enabled);
-    // Render Settings ▸ Proxy Use.
-    assert!(red(px(&s, c, 0.0, RenderOpts { proxy: ProxyUse::UseNone, ..o }, 8, 8)));
-    assert!(red(px(&s, c, 0.0, RenderOpts { proxy: ProxyUse::UseCompOnly, ..o }, 8, 8)));
-    // Use Proxy off: the viewer shows the source, Use All Proxies still uses it.
-    s.execute("file.useProxy", json!({"item": full.0})).unwrap();
-    assert!(!s.project.item(full).unwrap().proxy.as_ref().unwrap().enabled);
-    assert!(red(px(&s, c, 0.0, o, 8, 8)));
-    assert!(blue(px(&s, c, 0.0, RenderOpts { proxy: ProxyUse::UseAll, ..o }, 8, 8)));
-    // Undo / Set Proxy ▸ None.
-    s.execute("edit.undo", json!({})).unwrap();
-    assert!(blue(px(&s, c, 0.0, o, 8, 8)));
-    s.execute("file.setProxyNone", json!({"item": full.0})).unwrap();
-    assert!(s.project.item(full).unwrap().proxy.is_none());
-    assert!(red(px(&s, c, 0.0, RenderOpts { proxy: ProxyUse::UseAll, ..o }, 8, 8)));
-    // Render queue items carry Proxy Use (Best Settings: none).
-    let r = s.execute("renderQueue.add", json!({"proxyUse": "all"})).unwrap();
-    assert_eq!(s.project.render_queue[0].settings.proxy_use, ProxyUse::UseAll, "{r}");
-    assert_eq!(effectcraft_project::render_queue::RenderSettings::default().proxy_use, ProxyUse::UseNone);
-}
-
-#[test]
-fn comp_proxy_and_create_proxy() {
-    let mut s = session();
-    s.execute("comp.new", json!({"name": "Inner", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
-    let inner = s.active_comp_id().unwrap();
-    s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
-    s.execute("comp.new", json!({"name": "Outer", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
-    let outer = s.active_comp_id().unwrap();
-    s.execute("layer.addItem", json!({"item": inner.0})).unwrap();
-    let o = RenderOpts::default();
-    assert!(red(px(&s, outer, 0.0, o, 8, 8)));
-    s.execute("file.setProxy", json!({"item": inner.0, "path": "/m/blue8.png"})).unwrap();
-    assert!(blue(px(&s, outer, 0.0, o, 14, 1)));
-    assert!(blue(px(&s, outer, 0.0, RenderOpts { proxy: ProxyUse::UseCompOnly, ..o }, 8, 8)));
-    assert!(red(px(&s, outer, 0.0, RenderOpts { proxy: ProxyUse::UseNone, ..o }, 8, 8)));
-    s.execute("file.setProxyNone", json!({"item": inner.0})).unwrap();
-    // Create Proxy queues a half-resolution render whose post-render action sets the proxy.
-    s.state.project_selection = vec![inner];
-    let r = s.execute("file.createProxy", json!({"kind": "still"})).unwrap();
-    let it = s.project.render_queue.last().unwrap().clone();
-    assert_eq!(it.comp, inner);
-    assert_eq!(it.post_render, effectcraft_project::render_queue::PostRenderAction::SetProxy);
-    assert_eq!(it.settings.resolution, 0.5);
-    assert!(r["output"].as_str().unwrap().contains("Inner_proxy_"), "{r}");
-    let m = s.execute("file.createProxy", json!({"kind": "movie", "comp": inner.0})).unwrap();
-    assert!(m["output"].as_str().unwrap().ends_with("Inner_proxy.mov"), "{m}");
-    // The post-render action (what a finished render runs) attaches the file.
-    let id = it.id;
-    s.post_render_action(id, "/m/blue8.png").unwrap();
-    assert_eq!(s.project.item(inner).unwrap().proxy.as_ref().unwrap().footage.path, "/m/blue8.png");
-    assert!(blue(px(&s, outer, 0.0, o, 8, 8)));
-}
-
-#[test]
-fn interpret_proxy_settings_apply_to_the_proxy() {
-    let mut s = session();
-    let full = import(&mut s, "/m/red16.png");
-    s.execute("file.setProxy", json!({"item": full.0, "path": "/m/half.png"})).unwrap();
-    s.execute("file.interpretProxy", json!({"item": full.0, "alpha": "ignore", "invertAlpha": true})).unwrap();
-    let px = s.project.item(full).unwrap().proxy.clone().unwrap();
-    assert_eq!(px.footage.alpha, AlphaMode::Ignore);
-    assert!(px.footage.invert_alpha);
-    let f = match &s.project.item(full).unwrap().kind {
-        ItemKind::Footage(f) => f.clone(),
-        _ => panic!("not footage"),
-    };
-    assert_eq!(f.alpha, AlphaMode::Straight, "the main footage keeps its interpretation");
-}
-
-/// Separate Fields: each field becomes a frame at twice the frame rate, the other field's lines
-/// interpolated; the dominant field comes first.
-#[test]
-fn separate_fields_make_frames_from_fields() {
-    let mut s = session();
-    let mov = import(&mut s, "/m/lines.mov");
-    s.execute("comp.new", json!({"name": "C", "width": 4, "height": 4, "frameRate": 20, "duration": 1})).unwrap();
-    let c = s.active_comp_id().unwrap();
-    s.execute("layer.addItem", json!({"item": mov.0})).unwrap();
-    let o = RenderOpts::default();
-    // Progressive: alternating rows.
-    assert!(red(px(&s, c, 0.0, o, 1, 0)) && blue(px(&s, c, 0.0, o, 1, 1)));
-    s.execute("file.interpretFootage", json!({"item": mov.0, "fields": "upper"})).unwrap();
-    // Field 1 (upper = even rows, red) then field 2 (odd rows, blue), each 1/20 s.
-    for y in 0..3 {
-        assert!(red(px(&s, c, 0.0, o, 1, y)), "upper field at row {y}");
-        assert!(blue(px(&s, c, 0.05, o, 1, y + 1)), "lower field at row {}", y + 1);
-    }
-    s.execute("file.interpretFootage", json!({"item": mov.0, "fields": "lower"})).unwrap();
-    assert!(blue(px(&s, c, 0.0, o, 1, 2)));
-    assert!(red(px(&s, c, 0.05, o, 1, 1)));
-    let r = s.execute("file.interpretFootage", json!({"item": mov.0, "fields": "off"})).unwrap();
-    assert_eq!(r["items"][0]["fields"], "Off");
-}
-
-/// Non-square pixels: a 10×10 footage with pixel aspect 2 covers 20×10 comp pixels.
-#[test]
-fn pixel_aspect_stretches_footage_in_the_comp() {
-    let mut s = session();
-    let w = import(&mut s, "/m/wide.png");
-    s.execute("comp.new", json!({"name": "C", "width": 40, "height": 20, "frameRate": 10, "duration": 1})).unwrap();
-    let c = s.active_comp_id().unwrap();
-    s.execute("layer.addItem", json!({"item": w.0})).unwrap();
-    let o = RenderOpts::default();
-    let covered = |s: &Session| s.render(c, Tick::ZERO, o).data.iter().filter(|p| p[3] > 0.5).count();
-    assert_eq!(covered(&s), 100);
-    s.execute("file.interpretFootage", json!({"item": w.0, "pixelAspect": 2.0})).unwrap();
-    assert_eq!(covered(&s), 200);
-    // Centered on the comp: x 10..30 (edge pixels are filtered).
-    assert!(px(&s, c, 0.0, o, 11, 10)[3] > 0.99 && px(&s, c, 0.0, o, 28, 10)[3] > 0.99);
-    assert!(px(&s, c, 0.0, o, 8, 10)[3] < 0.01 && px(&s, c, 0.0, o, 31, 10)[3] < 0.01);
-    // A comp with the same pixel aspect shows the footage 1:1.
-    s.execute("comp.settings", json!({"pixelAspect": 2.0})).unwrap();
-    assert_eq!(covered(&s), 100);
-}
-
-/// Alpha ▸ Guess: premultiplied files are recognised with their matte colour; Invert Alpha
-/// and Interpret As Linear Light change the decoded pixels.
-#[test]
-fn guess_alpha_invert_and_linear_light() {
-    let mut s = session();
-    let b = import(&mut s, "/m/matte_black.png");
-    let w = import(&mut s, "/m/matte_white.png");
-    let h = import(&mut s, "/m/half.png");
-    let foot = |s: &Session, i: ItemId| match &s.project.item(i).unwrap().kind {
-        ItemKind::Footage(f) => f.clone(),
-        _ => panic!("not footage"),
-    };
-    s.execute("file.interpretFootage", json!({"items": [b.0, w.0, h.0], "alpha": "guess"})).unwrap();
-    assert_eq!(foot(&s, b).alpha, AlphaMode::Premultiplied);
-    assert_eq!(foot(&s, b).premul_color, [0.0; 3]);
-    assert_eq!(foot(&s, w).alpha, AlphaMode::Premultiplied);
-    assert_eq!(foot(&s, w).premul_color, [1.0; 3]);
-    // White at 25 %: not explained by a black matte (1 > 0.25) but it is by white… either way
-    // the guess is consistent with the pixels.
-    assert!(matches!(foot(&s, h).alpha, AlphaMode::Straight | AlphaMode::Premultiplied));
-    // An explicit matte colour.
-    s.execute("file.interpretFootage", json!({"item": b.0, "alpha": "premultiplied", "matteColor": "#808080"})).unwrap();
-    assert!((foot(&s, b).premul_color[0] - 128.0 / 255.0).abs() < 1e-3);
-    // Invert Alpha: 25 % → 75 %.
-    s.execute("file.interpretFootage", json!({"item": h.0, "alpha": "straight", "invertAlpha": true})).unwrap();
-    s.execute("comp.new", json!({"name": "C", "width": 4, "height": 4, "frameRate": 10, "duration": 1})).unwrap();
-    let c = s.active_comp_id().unwrap();
-    s.execute("layer.addItem", json!({"item": h.0})).unwrap();
-    let p = px(&s, c, 0.0, RenderOpts::default(), 1, 1);
-    assert!((p[3] - 0.75).abs() < 0.01 && p[0] > 0.7, "{p:?}");
-    // Interpret As Linear Light keeps alpha and re-encodes the colour.
-    s.execute("file.interpretFootage", json!({"item": h.0, "invertAlpha": false, "linearLight": true})).unwrap();
-    let p = px(&s, c, 0.0, RenderOpts::default(), 1, 1);
-    assert!((p[3] - 0.25).abs() < 0.01, "{p:?}");
-    // Remember / Apply Interpretation carries the new settings.
-    s.state.project_selection = vec![h];
-    s.execute("file.rememberInterpretation", json!({"item": h.0})).unwrap();
-    s.execute("file.applyInterpretation", json!({"items": [w.0]})).unwrap();
-    assert!(foot(&s, w).linear_light);
-    // Color ▸ Preserve RGB (#411) is set, rendered and carried by Apply Interpretation.
-    let out = s.execute("file.interpretFootage", json!({"item": h.0, "preserveRgb": true})).unwrap();
-    assert_eq!(out["items"][0]["preserveRgb"], true);
-    let p = px(&s, c, 0.0, RenderOpts::default(), 1, 1);
-    assert!((p[0] - 0.25).abs() < 0.01, "white at 25 %, unconverted: {p:?}");
-    s.execute("file.rememberInterpretation", json!({"item": h.0})).unwrap();
-    s.execute("file.applyInterpretation", json!({"items": [w.0]})).unwrap();
-    assert!(foot(&s, w).preserve_rgb);
-}
diff --git a/crates/engine/tests/blender_scene_oracle.py b/crates/engine/tests/blender_scene_oracle.py
new file mode 100644
index 000000000..3d1cbeda7
--- /dev/null
+++ b/crates/engine/tests/blender_scene_oracle.py
@@ -0,0 +1,61 @@
+"""Public-API oracle for scripts generated by src/tests/blender.rs; no Blender source dependency."""
+import json
+import math
+import runpy
+import sys
+
+import bpy
+from bpy_extras.object_utils import world_to_camera_view
+from mathutils import Quaternion, Vector
+
+path = sys.argv[sys.argv.index("--") + 1]
+before = set(bpy.data.scenes)
+exported = runpy.run_path(path, run_name="__main__")
+scene = exported["EFFECTCRAFT_SCENE"]
+data = exported["DATA"]
+assert before.issubset(set(bpy.data.scenes)), "existing scenes were removed"
+assert scene not in before
+assert scene.frame_start == 101 and scene.frame_end == 103
+assert abs(scene.render.fps / scene.render.fps_base - 30000 / 1001) < 1e-4
+assert (scene.render.resolution_x, scene.render.resolution_y) == (640, 360)
+camera = scene.camera
+assert camera.animation_data.action is not None
+assert camera.data.animation_data.action is not None
+assert camera.data.sensor_fit == 'HORIZONTAL'
+metadata = json.loads(bpy.data.texts[scene["effectcraft_metadata_text"]].as_string())
+assert metadata["solve"]["averageError"] == 0.12
+cloud = scene.objects["Solved Track Points"]
+assert len(cloud.data.vertices) == 2
+assert cloud.hide_render
+assert cloud.data.attributes["track_id"].data[0].value == 7
+assert any(obj.name.startswith("Solved Ground Plane") for obj in scene.objects)
+
+for i, sample in enumerate(data["frames"]):
+    scene.frame_set(sample["frame"])
+    bpy.context.view_layer.update()
+    assert abs(camera.data.lens - sample["lens"]) < 1e-5
+    assert abs(camera.data.dof.focus_distance - sample["focus"]) < 1e-5
+    assert abs(camera.data.dof.aperture_fstop - sample["fstop"]) < 1e-5
+    assert camera.data.dof.use_dof
+    assert (camera.location - Vector(sample["location"])).length < 1e-5
+    raw = data["solve"]["frames"][i]
+    rot = Vector(raw["rot"])
+    rotation = Quaternion(rot.normalized(), rot.length).to_matrix() if rot.length else Quaternion().to_matrix()
+    for vertex, point in zip(cloud.data.vertices, data["solve"]["points"]):
+        relative = rotation @ (Vector(point["pos"]) - Vector(raw["center"]))
+        expected = (raw["focal"] * relative.x / relative.z + 320,
+                    raw["focal"] * relative.y / relative.z + 180)
+        projected = world_to_camera_view(scene, camera, vertex.co)
+        actual = (projected.x * 640, (1.0 - projected.y) * 360)
+        assert math.dist(actual, expected) < 0.002, (sample["frame"], actual, expected)
+
+    if "Video not found" not in " ".join(data["warnings"]):
+        background = camera.data.background_images[0]
+        assert background.image.source == 'MOVIE'
+        assert tuple(background.image.size) == (640, 360)
+        user = background.image_user
+        actual_source = sample["frame"] - user.frame_start + user.frame_offset
+        assert actual_source == sample["sourceFrame"], (actual_source, sample["sourceFrame"])
+        assert user.use_auto_refresh
+
+print("EFFECTCRAFT_BLENDER_ORACLE_OK")
diff --git a/crates/engine/tests/it/parenting_3d_position.rs b/crates/engine/tests/it/parenting_3d_position.rs
index f9dd9ae3f..61440e273 100644
--- a/crates/engine/tests/it/parenting_3d_position.rs
+++ b/crates/engine/tests/it/parenting_3d_position.rs
@@ -410,12 +410,12 @@ fn parenting_static_orientation_is_exact_just_off_gimbal_lock() {
 fn parenting_animated_orientation_and_nonuniform_parent_keep_authored_pose_boundary() {
     for animated in [true, false] {
         let (mut s, p, c) = fixture(true, true);
+        // A non-uniform parent has no uniform pose to re-express, animated or not.
+        set(&mut s, p, "transform/scale", json!([120.0, 100.0, 80.0]));
         if animated {
             for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.0, json!([5.0, 18.0, 14.0]))] {
                 command(&mut s, "prop.addKey", json!({"layer":c,"path":"transform/orientation","time":time,"value":value}));
             }
-        } else {
-            set(&mut s, p, "transform/scale", json!([120.0, 100.0, 80.0]));
         }
         let layer = s.active_comp().unwrap().layer(LayerId(c)).unwrap();
         let orientation = layer.props.prop("transform/orientation").unwrap().clone();
@@ -430,6 +430,27 @@ fn parenting_animated_orientation_and_nonuniform_parent_keep_authored_pose_bound
     }
 }
 
+/// Keyed Orientation under a uniform parent is re-expressed at every key, so the child's world pose
+/// and pixels stay put at every time (the parent is Z-only, so the paths between keys stay exact too).
+#[test]
+fn parenting_uniform_parent_re_expresses_keyed_orientation() {
+    for factor in [120.0, -120.0] {
+        let (mut s, p, c) = fixture(true, false);
+        set(&mut s, p, "transform/rotation", json!(42.0));
+        set(&mut s, p, "transform/scale", json!([factor, factor, factor]));
+        for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.0, json!([5.0, 18.0, 14.0]))] {
+            command(&mut s, "prop.addKey", json!({"layer":c,"path":"transform/orientation","time":time,"value":value}));
+        }
+        let times = [0.0, 0.25, 0.5, 0.75, 1.0].map(Tick::from_seconds_f64);
+        let before = times.map(|t| world(&s, c, t));
+        let images = times.map(|t| cpu(&s, t));
+        parent(&mut s, c, Some(p), true);
+        let error = times.into_iter().zip(before).map(|(t, b)| displacement(b, world(&s, c, t))).fold(0.0, f64::max);
+        let pixels = times.into_iter().zip(&images).map(|(t, i)| diff(i, &cpu(&s, t))).fold(0.0, f32::max);
+        assert!(error < 1e-8 && pixels < 2e-5, "keyed Orientation under a uniform parent (factor {factor}): corners {error}, pixels {pixels}");
+    }
+}
+
 /// Position's temporal speed is measured along its spatial path, in parent-space units.
 #[test]
 fn parenting_uniform_parent_preserves_eased_position_at_quarter_times_and_undo() {
diff --git a/crates/export/Cargo.toml b/crates/export/Cargo.toml
index 2ef6f5ad8..f2c185262 100644
--- a/crates/export/Cargo.toml
+++ b/crates/export/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "effectcraft-export"
-description = "Render Queue jobs and output modules: H.264 MP4 (+AAC), ProRes and uncompressed MOV (+PCM) via FilmCraft, HEVC / AV1 MP4 (+AAC) and WebM (VP9 or AV1 + Opus) via EffectCraft encoders, PNG/JPEG/TIFF/EXR sequences, animated GIF, WAV/AIFF"
+description = "Render Queue jobs and output modules: H.264 MP4 (+AAC), ProRes and uncompressed MOV (+PCM) via FilmCraft, HEVC / AV1 MP4 (+AAC) and WebM (VP9 or AV1 + Opus) via EffectCraft encoders, PNG/JPEG/TIFF/EXR/Targa sequences, animated GIF, WAV/AIFF"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
@@ -22,7 +22,7 @@ effectcraft-opusenc = { workspace = true }
 effectcraft-vp9enc = { workspace = true }
 effectcraft-hevcenc = { workspace = true }
 effectcraft-av1enc = { workspace = true }
-image = { workspace = true, features = ["png", "jpeg", "tiff", "exr"] }
+image = { workspace = true, features = ["png", "jpeg", "tiff", "exr", "tga"] }
 gif = { workspace = true }
 rayon = { workspace = true }
 web-time = { workspace = true }
diff --git a/crates/export/src/encode.rs b/crates/export/src/encode.rs
index e4a45561d..c9888a035 100644
--- a/crates/export/src/encode.rs
+++ b/crates/export/src/encode.rs
@@ -4,10 +4,10 @@
 
 use std::io::Write;
 
-use effectcraft_project::Comp;
 use effectcraft_project::render_queue::{AudioFormat, Channels, OutputFormat, ProResProfile};
+use effectcraft_project::{Comp, ProjectSettings};
 use effectcraft_time::{FrameRate, Tick};
-use filmcraft_isobmff::{Brand, FourCc, Mp4Writer, PcmConfig, SampleEntry, TrackConfig, WriteSample, WriterOptions};
+use filmcraft_isobmff::{Brand, ColorInfo, FourCc, Mp4Writer, PcmConfig, SampleEntry, TrackConfig, WriteSample, WriterOptions};
 use rayon::prelude::*;
 
 use crate::{Cx, ExportError, Report, Result, State, batch_size, wants_audio};
@@ -19,6 +19,17 @@ fn mux_err(e: impl std::fmt::Display) -> ExportError {
     ExportError::Io(e.to_string())
 }
 
+/// Tag a video [`SampleEntry`] with the BT.709 limited-range `colr` (nclx) box every video
+/// encoder here outputs (`rgba_to_yuv420`, `rgba_to_yuv_10` and `rgba_to_yuv420_bits` all use
+/// the 0.2126/0.7152/0.0722 luma and a 16–235 luma range). Without it a re-import falls back to
+/// the container's resolution-based `default_matrix` — BT.601 below 1024×577 — and shifts the
+/// colours (pure red came back as [232,0,1]).
+pub(crate) fn tag_bt709_limited(entry: &mut SampleEntry) {
+    if let Some(v) = entry.video.as_mut() {
+        v.color = Some(ColorInfo::Nclx { primaries: 1, transfer: 1, matrix: 1, full_range: false });
+    }
+}
+
 pub(crate) struct Packet {
     pub(crate) data: Vec<u8>,
     pub(crate) key: bool,
@@ -26,9 +37,49 @@ pub(crate) struct Packet {
     pub(crate) cto: i32,
 }
 
-pub(crate) trait VideoEncoder {
+/// A frame for the movie encoder: 8-bit RGBA, or 8-bit 4:2:0 planes already converted on the
+/// render threads (for encoders whose [`VideoEncoder::takes_yuv420`] is true).
+pub(crate) enum Pixels {
+    Rgba(Vec<u8>),
+    Yuv420(Yuv420),
+}
+
+/// BT.709 limited-range 8-bit 4:2:0 planes ([`rgba_to_yuv420`], or Y then U and V from the
+/// accelerator).
+pub(crate) enum Yuv420 {
+    Planes { y: Vec<u8>, u: Vec<u8>, v: Vec<u8> },
+    Packed(Vec<u8>),
+}
+
+impl Yuv420 {
+    fn from_rgba(rgba: &[u8], w: usize, h: usize) -> Yuv420 {
+        let (mut y, mut u, mut v) = (vec![], vec![], vec![]);
+        rgba_to_yuv420(rgba, w, h, &mut y, &mut u, &mut v);
+        Yuv420::Planes { y, u, v }
+    }
+    fn slices(&self, w: usize, h: usize) -> (&[u8], &[u8], &[u8]) {
+        match self {
+            Yuv420::Planes { y, u, v } => (y, u, v),
+            Yuv420::Packed(p) => {
+                let (cw, ch) = (w.div_ceil(2), h.div_ceil(2));
+                let (y, uv) = p.split_at(w * h);
+                let (u, v) = uv.split_at(cw * ch);
+                (y, u, v)
+            }
+        }
+    }
+}
+
+pub(crate) trait VideoEncoder: Send {
     fn sample_entry(&self) -> SampleEntry;
     fn encode(&mut self, rgba: &[u8], index: u64) -> Result<Vec<Packet>>;
+    /// Whether frames should come as [`Pixels::Yuv420`] (converted while other frames render).
+    fn takes_yuv420(&self) -> bool {
+        false
+    }
+    fn encode_yuv420(&mut self, _frame: &Yuv420, _index: u64) -> Result<Vec<Packet>> {
+        Err(ExportError::Unsupported("this encoder takes RGBA frames".into()))
+    }
     fn flush(&mut self) -> Result<Vec<Packet>>;
     /// Edit-list media start (B-frame delay) in the track timescale.
     fn media_start(&self) -> Option<i64> {
@@ -70,12 +121,27 @@ impl VideoEncoder for H264 {
             let (sps, pps) = self.enc.sps_pps();
             filmcraft_isobmff::AvcConfig::new(vec![sps], vec![pps], 4)
         });
-        SampleEntry::avc(cfg, self.w as u16, self.h as u16)
+        let mut entry = SampleEntry::avc(cfg, self.w as u16, self.h as u16);
+        tag_bt709_limited(&mut entry);
+        entry
     }
     fn encode(&mut self, rgba: &[u8], index: u64) -> Result<Vec<Packet>> {
-        rgba_to_yuv420(rgba, self.w as usize, self.h as usize, &mut self.y, &mut self.u, &mut self.v);
-        let cw = (self.w as usize).div_ceil(2);
-        let frame = filmcraft_h264enc::YuvFrame { y: &self.y, u: &self.u, v: &self.v, y_stride: self.w as usize, uv_stride: cw };
+        let (mut y, mut u, mut v) = (std::mem::take(&mut self.y), std::mem::take(&mut self.u), std::mem::take(&mut self.v));
+        rgba_to_yuv420(rgba, self.w as usize, self.h as usize, &mut y, &mut u, &mut v);
+        let planes = Yuv420::Planes { y, u, v };
+        let r = self.encode_yuv420(&planes, index);
+        if let Yuv420::Planes { y, u, v } = planes {
+            (self.y, self.u, self.v) = (y, u, v);
+        }
+        r
+    }
+    fn takes_yuv420(&self) -> bool {
+        true
+    }
+    fn encode_yuv420(&mut self, p: &Yuv420, index: u64) -> Result<Vec<Packet>> {
+        let (w, cw) = (self.w as usize, (self.w as usize).div_ceil(2));
+        let (y, u, v) = p.slices(w, self.h as usize);
+        let frame = filmcraft_h264enc::YuvFrame { y, u, v, y_stride: w, uv_stride: cw };
         let ps = self.enc.try_encode(&frame, index as i64 * self.rate.den).map_err(enc)?;
         Ok(self.packets(ps))
     }
@@ -88,33 +154,7 @@ impl VideoEncoder for H264 {
     }
 }
 
-/// BT.709 limited-range 8-bit 4:2:0 from RGBA8 (2×2 chroma average; alpha ignored).
-pub(crate) fn rgba_to_yuv420(rgba: &[u8], w: usize, h: usize, y: &mut Vec<u8>, u: &mut Vec<u8>, v: &mut Vec<u8>) {
-    let (cw, ch) = (w.div_ceil(2), h.div_ceil(2));
-    y.resize(w * h, 0);
-    u.resize(cw * ch, 0);
-    v.resize(cw * ch, 0);
-    y.par_chunks_mut(w * 2).zip(u.par_chunks_mut(cw).zip(v.par_chunks_mut(cw))).enumerate().for_each(|(cy, (yr, (ur, vr)))| {
-        let rows = yr.len() / w;
-        let mut acc = vec![(0f32, 0f32, 0f32); cw];
-        for dy in 0..rows {
-            let src = &rgba[(cy * 2 + dy) * w * 4..][..w * 4];
-            for x in 0..w {
-                let (r, g, b) = (src[x * 4] as f32 / 255.0, src[x * 4 + 1] as f32 / 255.0, src[x * 4 + 2] as f32 / 255.0);
-                let l = 0.2126 * r + 0.7152 * g + 0.0722 * b;
-                yr[dy * w + x] = (16.0 + 219.0 * l).round().clamp(1.0, 254.0) as u8;
-                let a = &mut acc[x / 2];
-                a.0 += (b - l) / 1.8556;
-                a.1 += (r - l) / 1.5748;
-                a.2 += 1.0;
-            }
-        }
-        for (cx, a) in acc.iter().enumerate() {
-            ur[cx] = (128.0 + 224.0 * a.0 / a.2).round().clamp(1.0, 254.0) as u8;
-            vr[cx] = (128.0 + 224.0 * a.1 / a.2).round().clamp(1.0, 254.0) as u8;
-        }
-    });
-}
+pub(crate) use effectcraft_raster::yuv::rgba_to_yuv420;
 
 // ---------------------------------------------------------------- ProRes
 
@@ -124,6 +164,28 @@ struct ProRes {
     w: u32,
     h: u32,
     alpha: bool,
+    colr: ColorInfo,
+}
+
+/// The `colr` atom of a ProRes render: what its frames are, in H.273 code points. MOV uses
+/// QuickTime's `nclc`, which has no range flag; ProRes frames are limited range. The matrix is the
+/// one [`rgba_to_yuv_10`] always uses. Primaries and transfer follow the render path
+/// (`Pipe::output`): only a working space converts to the output space, so unmanaged frames pass
+/// through. sRGB output keeps transfer 1 rather than 13 (#340), and an alpha matte is not in the
+/// output space.
+fn prores_colr(settings: &ProjectSettings, channels: Channels) -> ColorInfo {
+    use effectcraft_project::ColorSpace as Space;
+    let output = settings.working_space.and(settings.output_space).filter(|_| channels != Channels::Alpha);
+    let (primaries, transfer) = match output {
+        None | Some(Space::Srgb | Space::Rec709) => (1, 1),
+        Some(Space::Rec2020) => (9, 1),
+        Some(Space::DisplayP3) => (12, 13),
+        Some(Space::Rec2100Pq) => (9, 16),
+        Some(Space::Rec2100Hlg) => (9, 18),
+        // H.273 has no code for the ACES primaries: unspecified, in linear light.
+        Some(Space::AcesCg | Space::Aces2065) => (2, 8),
+    };
+    ColorInfo::Nclc { primaries, transfer, matrix: 1 }
 }
 
 fn prores_profile(p: ProResProfile) -> filmcraft_prores::Profile {
@@ -139,14 +201,20 @@ fn prores_profile(p: ProResProfile) -> filmcraft_prores::Profile {
 }
 
 impl ProRes {
-    fn new(w: u32, h: u32, profile: ProResProfile, channels: Channels) -> ProRes {
+    fn new(w: u32, h: u32, profile: ProResProfile, channels: Channels, colr: ColorInfo) -> ProRes {
         // Alpha needs a 4444 flavour.
         let profile = if channels == Channels::Rgba && !profile.is_4444() { ProResProfile::P4444 } else { profile };
         let profile = prores_profile(profile);
         let alpha = channels == Channels::Rgba;
         let mut cfg = filmcraft_prores::EncoderConfig::new(profile, w, h);
         cfg.encode_alpha = alpha;
-        ProRes { enc: filmcraft_prores::Encoder::with_config(cfg), profile, w, h, alpha }
+        // The frame header carries the same H.273 codes as the `colr` atom, so readers that trust
+        // either one agree.
+        if let ColorInfo::Nclc { primaries, transfer, matrix } = colr {
+            let code = |c| u8::try_from(c).unwrap_or(2);
+            cfg.color = filmcraft_prores::ColorInfo { primaries: code(primaries), transfer: code(transfer), matrix: code(matrix) };
+        }
+        ProRes { enc: filmcraft_prores::Encoder::with_config(cfg), profile, w, h, alpha, colr }
     }
     fn is_444(&self) -> bool {
         matches!(self.profile, filmcraft_prores::Profile::P4444 | filmcraft_prores::Profile::P4444Xq)
@@ -155,7 +223,11 @@ impl ProRes {
 
 impl VideoEncoder for ProRes {
     fn sample_entry(&self) -> SampleEntry {
-        SampleEntry::prores(FourCc(self.profile.fourcc()), self.w as u16, self.h as u16)
+        let mut entry = SampleEntry::prores(FourCc(self.profile.fourcc()), self.w as u16, self.h as u16);
+        if let Some(v) = entry.video.as_mut() {
+            v.color = Some(self.colr.clone());
+        }
+        entry
     }
     fn encode(&mut self, rgba: &[u8], _index: u64) -> Result<Vec<Packet>> {
         let chroma = if self.is_444() { filmcraft_prores::ChromaFormat::Yuv444 } else { filmcraft_prores::ChromaFormat::Yuv422 };
@@ -261,19 +333,48 @@ pub(crate) async fn movie(job: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut St
         OutputFormat::Hevc => Box::new(crate::hevc_av1::Hevc::new(w, h, rate, job.output)?),
         OutputFormat::Av1 => Box::new(crate::hevc_av1::Av1::new(w, h, rate, job.output)?),
         OutputFormat::Uncompressed => Box::new(crate::uncompressed::Raw::new(w, h, channels == Channels::Rgba)?),
-        _ => Box::new(ProRes::new(w, h, job.output.prores_profile, if channels == Channels::Alpha { Channels::Rgb } else { channels })),
+        _ => {
+            let colr = prores_colr(&job.project.settings, channels);
+            Box::new(ProRes::new(w, h, job.output.prores_profile, if channels == Channels::Alpha { Channels::Rgb } else { channels }, colr))
+        }
     };
     let brand = if matches!(fmt, OutputFormat::ProRes | OutputFormat::Uncompressed) { Brand::Mov } else { Brand::Mp4 };
     let batch = batch_size();
-    let render = |_: u64, img: effectcraft_raster::Image| -> Vec<u8> { job.pixels(&img, comp, channels, w, h) };
+    let yuv = venc.takes_yuv420();
+    let render = |_: u64, img: effectcraft_raster::Image| -> Pixels {
+        let px = job.pixels(&img, comp, channels, w, h);
+        if yuv { Pixels::Yuv420(Yuv420::from_rgba(&px, w as usize, h as usize)) } else { Pixels::Rgba(px) }
+    };
+    // H.264 frames the accelerator can convert itself come back as planes (12 MB instead of
+    // 133 MB of RGBA f32 read back at 4K); everything else renders and converts as before.
+    // Deferred readbacks (a browser worker) keep their pass-based path: no blocking there.
+    let gpu_yuv = yuv && channels == Channels::Rgb && !job.deferred();
+    let batch_frames = async |ks: Vec<u64>| -> Vec<Pixels> {
+        if gpu_yuv { job.h264_frames(comp, ks, w, h, |p| Pixels::Yuv420(Yuv420::Packed(p)), render) } else { job.frames(comp, ks, render).await }
+    };
+    let encode = |venc: &mut Box<dyn VideoEncoder>, px: &Pixels, index: u64| match px {
+        Pixels::Rgba(rgba) => venc.encode(rgba, index),
+        Pixels::Yuv420(planes) => venc.encode_yuv420(planes, index),
+    };
+
+    let beside = crate::pipeline::Beside::shared();
+    let total = st.total;
 
     // Encode the first batch before creating tracks: encoders finalise their config on frame 1.
-    let first_end = batch.min(st.total);
-    let first: Vec<Vec<u8>> = job.frames(comp, (0..first_end).collect(), render).await;
-    let mut pending = Vec::new();
-    for (k, px) in first.iter().enumerate() {
-        pending.extend(venc.encode(px, k as u64)?);
-    }
+    // Each batch encodes while the next one renders.
+    let first_end = batch.min(total);
+    let first: Vec<Pixels> = batch_frames((0..first_end).collect()).await;
+    let next_end = (first_end + batch).min(total);
+    let (pending, mut ready) = job
+        .beside(beside, batch_frames((first_end..next_end).collect()), || -> Result<Vec<Packet>> {
+            let mut pending = Vec::new();
+            for (k, px) in first.iter().enumerate() {
+                pending.extend(encode(&mut venc, px, k as u64)?);
+            }
+            Ok(pending)
+        })
+        .await?;
+    let pending = pending?;
     drop(first);
     st.advance(first_end)?;
 
@@ -351,19 +452,25 @@ pub(crate) async fn movie(job: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut St
         }
         Ok(())
     };
-    let total = st.total;
     let frame_end_time = |k: u64| -> Tick { if k >= total { span_end } else { job.settings.frame_time(comp, k) } };
     write_video(&mut mux, pending)?;
     write_audio_until(&mut mux, frame_end_time(first_end), &mut cursor)?;
     let mut i = first_end;
     while i < total {
         let end = (i + batch).min(total);
-        let frames: Vec<Vec<u8>> = job.frames(comp, (i..end).collect(), render).await;
-        for (k, px) in frames.iter().enumerate() {
-            let ps = venc.encode(px, i + k as u64)?;
-            write_video(&mut mux, ps)?;
-        }
-        write_audio_until(&mut mux, frame_end_time(end), &mut cursor)?;
+        let next_end = (end + batch).min(total);
+        let frames = std::mem::take(&mut ready);
+        let (done, next) = job
+            .beside(beside, batch_frames((end..next_end).collect()), || -> Result<()> {
+                for (k, px) in frames.iter().enumerate() {
+                    let ps = encode(&mut venc, px, i + k as u64)?;
+                    write_video(&mut mux, ps)?;
+                }
+                write_audio_until(&mut mux, frame_end_time(end), &mut cursor)
+            })
+            .await?;
+        done?;
+        ready = next;
         st.advance(end - i)?;
         i = end;
     }
@@ -382,8 +489,74 @@ pub(crate) async fn movie(job: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut St
 
 #[cfg(test)]
 mod tests {
+    use effectcraft_raster::yuv::{UNIT8, round_pos};
+
     use super::*;
 
+    /// The conversion as first written (per-pixel division and `f32::round`).
+    fn yuv420_reference(rgba: &[u8], w: usize, h: usize) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
+        let (cw, ch) = (w.div_ceil(2), h.div_ceil(2));
+        let (mut y, mut u, mut v) = (vec![0u8; w * h], vec![0u8; cw * ch], vec![0u8; cw * ch]);
+        for cy in 0..ch {
+            let mut acc = vec![(0f32, 0f32, 0f32); cw];
+            for row in cy * 2..(cy * 2 + 2).min(h) {
+                for x in 0..w {
+                    let s = &rgba[(row * w + x) * 4..];
+                    let (r, g, b) = (s[0] as f32 / 255.0, s[1] as f32 / 255.0, s[2] as f32 / 255.0);
+                    let l = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+                    y[row * w + x] = (16.0 + 219.0 * l).round().clamp(1.0, 254.0) as u8;
+                    let a = &mut acc[x / 2];
+                    a.0 += (b - l) / 1.8556;
+                    a.1 += (r - l) / 1.5748;
+                    a.2 += 1.0;
+                }
+            }
+            for (cx, a) in acc.iter().enumerate() {
+                u[cy * cw + cx] = (128.0 + 224.0 * a.0 / a.2).round().clamp(1.0, 254.0) as u8;
+                v[cy * cw + cx] = (128.0 + 224.0 * a.1 / a.2).round().clamp(1.0, 254.0) as u8;
+            }
+        }
+        (y, u, v)
+    }
+
+    #[test]
+    fn round_pos_is_round() {
+        for i in 0..2_000_000u32 {
+            let v = i as f32 * 0.000_25;
+            assert_eq!(round_pos(v).to_bits(), v.round().to_bits(), "{v}");
+            let n = f32::from_bits(v.to_bits().wrapping_sub(1)).max(0.0);
+            assert_eq!(round_pos(n).to_bits(), n.round().to_bits(), "{n}");
+        }
+        for k in 0..1024u32 {
+            for v in [k as f32 + 0.5, f32::from_bits((k as f32 + 0.5).to_bits() - 1), f32::from_bits((k as f32 + 0.5).to_bits() + 1)] {
+                assert_eq!(round_pos(v), v.round(), "{v}");
+            }
+        }
+        for (i, u) in UNIT8.iter().enumerate() {
+            assert_eq!(u.to_bits(), (i as f32 / 255.0).to_bits());
+        }
+    }
+
+    #[test]
+    fn yuv420_matches_the_reference() {
+        // Every 8-bit level in every channel, odd sizes, and pseudo-random pixels.
+        for (w, h) in [(1, 1), (2, 2), (3, 5), (17, 9), (64, 33)] {
+            let mut rgba = vec![0u8; w * h * 4];
+            let mut seed = (w * 31 + h) as u32;
+            for (i, b) in rgba.iter_mut().enumerate() {
+                seed = seed.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
+                *b = if i % 7 == 0 { (i / 4 % 256) as u8 } else { (seed >> 24) as u8 };
+            }
+            let (mut y, mut u, mut v) = (vec![], vec![], vec![]);
+            rgba_to_yuv420(&rgba, w, h, &mut y, &mut u, &mut v);
+            assert_eq!((y, u, v), yuv420_reference(&rgba, w, h), "{w}x{h}");
+        }
+        let grey: Vec<u8> = (0..=255u8).flat_map(|g| [g, g, g, 255, g, 255 - g, g / 2, 255]).collect();
+        let (mut y, mut u, mut v) = (vec![], vec![], vec![]);
+        rgba_to_yuv420(&grey, 512, 1, &mut y, &mut u, &mut v);
+        assert_eq!((y, u, v), yuv420_reference(&grey, 512, 1));
+    }
+
     #[test]
     fn yuv_of_primaries() {
         let rgba = [255u8, 255, 255, 255, 0, 0, 0, 255, 255, 0, 0, 255, 0, 255, 0, 255];
diff --git a/crates/export/src/hevc_av1.rs b/crates/export/src/hevc_av1.rs
index f42ccda24..c363dff35 100644
--- a/crates/export/src/hevc_av1.rs
+++ b/crates/export/src/hevc_av1.rs
@@ -92,7 +92,9 @@ impl Hevc {
 impl VideoEncoder for Hevc {
     fn sample_entry(&self) -> SampleEntry {
         let cfg = HevcConfig::parse(&self.enc.hvcc()).unwrap_or_default();
-        SampleEntry::hevc(cfg, self.w as u16, self.h as u16)
+        let mut entry = SampleEntry::hevc(cfg, self.w as u16, self.h as u16);
+        crate::encode::tag_bt709_limited(&mut entry);
+        entry
     }
     fn encode(&mut self, rgba: &[u8], _index: u64) -> Result<Vec<Packet>> {
         let (w, h) = (self.w as usize, self.h as usize);
@@ -148,7 +150,9 @@ impl Av1 {
 impl VideoEncoder for Av1 {
     fn sample_entry(&self) -> SampleEntry {
         let cfg = Av1Config::parse(&self.enc.av1c()).unwrap_or_default();
-        SampleEntry::video(FourCc(*b"av01"), CodecConfig::Av1(cfg), self.w as u16, self.h as u16)
+        let mut entry = SampleEntry::video(FourCc(*b"av01"), CodecConfig::Av1(cfg), self.w as u16, self.h as u16);
+        crate::encode::tag_bt709_limited(&mut entry);
+        entry
     }
     fn encode(&mut self, rgba: &[u8], _index: u64) -> Result<Vec<Packet>> {
         let (w, h) = (self.w as usize, self.h as usize);
diff --git a/crates/export/src/lib.rs b/crates/export/src/lib.rs
index eda979958..1b69a87bd 100644
--- a/crates/export/src/lib.rs
+++ b/crates/export/src/lib.rs
@@ -7,13 +7,14 @@
 //! | Uncompressed | QuickTime MOV (`raw `) | 8-bit RGB (depth 24, rows padded to even bytes) or ARGB (depth 32) | RGB + Alpha (straight or premultiplied) | PCM 16/24-bit or 32-bit float, mono/stereo |
 //! | PNG / JPEG / TIFF sequence | one file per frame | 8-bit | PNG, TIFF | — |
 //! | OpenEXR sequence | one file per frame | 32-bit float, linear light, premultiplied | yes | — |
+//! | Targa sequence | one file per frame | uncompressed 8-bit: 24-bit RGB, 32-bit RGB + Alpha (8 alpha bits), 8-bit grey for Alpha; top-left origin | yes (straight or premultiplied) | — |
 //! | Animated GIF | GIF89a | 256-colour palette per frame (NeuQuant) | 1-bit | — |
 //! | WebM | WebM (Matroska) | VP9 profile 0 (`effectcraft-vp9enc`: key + inter frames, a key frame every 2 s, loop filter), 8-bit 4:2:0; or AV1 (`effectcraft-av1enc`) | VP9 alpha (BlockAdditional) | Opus (`effectcraft-opusenc`: SILK / hybrid / CELT by bitrate and application), 48 kHz |
 //! | HEVC | MP4 (`hvc1`) | `effectcraft-hevcenc` Main / Main 10 4:2:0, I + P slices, bitrate or constant quality, level, key-frame interval | no | AAC-LC (FilmCraft) |
 //! | AV1 | MP4 (`av01`) | `effectcraft-av1enc` Main 8/10-bit 4:2:0, key + inter frames | no | AAC-LC (FilmCraft) |
 //! | WAV / AIFF | RIFF WAVE / AIFF (AIFF-C for float) | — | — | PCM 16/24-bit or 32-bit float, mono/stereo (audio only) |
 //!
-//! Every frame goes through [`pipeline`]: the Render Settings overrides (Effects, Solo Switches,
+//! Every frame goes through the internal `pipeline` module: the Render Settings overrides (Effects, Solo Switches,
 //! Guide Layers, Frame Blending, Motion Blur, Color Depth), field rendering (two fields half a
 //! frame apart woven line by line, with optional 3:2 pulldown from film frames at 4/5 of the
 //! rate), then the Output Module's Crop (edges or the region of interest) and Resize. Channels
@@ -270,7 +271,7 @@ async fn sequence(cx: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut State<'_>)
                 let path = sequence_path(cx.path, f0 + k as i64);
                 // Encode in memory first: the storage hook decides where it fits.
                 let mut buf = std::io::Cursor::new(Vec::new());
-                write_still(cx, &mut buf, fmt, &img, comp, channels, w, h, cx.output.quality)?;
+                write_still(cx, &mut buf, &img, comp, StillOutput { format: fmt, channels, size: (w, h), quality: cx.output.quality })?;
                 let data = buf.into_inner();
                 let path = cx.place(&path, data.len() as u64);
                 let mut f = cx.create(&path)?;
@@ -287,18 +288,15 @@ async fn sequence(cx: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut State<'_>)
     Ok(Report { path: sequence_path(cx.path, f0), frames: 0, width: w, height: h, seconds: 0.0, bytes, audio: false, log: None, overflow: vec![] })
 }
 
-#[allow(clippy::too_many_arguments)]
-fn write_still<W: std::io::Write + std::io::Seek>(
-    cx: &Cx,
-    file: &mut W,
-    fmt: OutputFormat,
-    img: &Image,
-    comp: &Comp,
+struct StillOutput {
+    format: OutputFormat,
     channels: Channels,
-    w: u32,
-    h: u32,
+    size: (u32, u32),
     quality: u8,
-) -> Result<()> {
+}
+
+fn write_still<W: std::io::Write + std::io::Seek>(cx: &Cx, file: &mut W, img: &Image, comp: &Comp, output: StillOutput) -> Result<()> {
+    let StillOutput { format: fmt, channels, size: (w, h), quality } = output;
     use image::{ExtendedColorType, ImageEncoder, ImageFormat};
     match fmt {
         OutputFormat::ExrSequence => {
@@ -338,19 +336,22 @@ fn write_still<W: std::io::Write + std::io::Seek>(
                 .write_image(&rgb, w, h, ExtendedColorType::Rgb8)
                 .map_err(|e| ExportError::Encode(e.to_string()))
         }
-        OutputFormat::PngSequence | OutputFormat::TiffSequence => {
+        OutputFormat::PngSequence | OutputFormat::TiffSequence | OutputFormat::TargaSequence => {
             let px = cx.pixels(img, comp, channels, w, h);
             let (data, ct) = match channels {
                 Channels::Rgba => (px, ExtendedColorType::Rgba8),
                 Channels::Alpha => (px.as_chunks::<4>().0.iter().map(|p| p[0]).collect(), ExtendedColorType::L8),
                 Channels::Rgb => (px.as_chunks::<4>().0.iter().flat_map(|p| [p[0], p[1], p[2]]).collect(), ExtendedColorType::Rgb8),
             };
-            if fmt == OutputFormat::PngSequence {
-                image::codecs::png::PngEncoder::new(file).write_image(&data, w, h, ct).map_err(|e| ExportError::Encode(e.to_string()))
-            } else {
+            match fmt {
+                OutputFormat::PngSequence => image::codecs::png::PngEncoder::new(file).write_image(&data, w, h, ct),
+                // Uncompressed (the encoder's run-length compression is off), top-left origin, the
+                // alpha bits in the image descriptor: 8 for RGB + Alpha, 0 otherwise.
+                OutputFormat::TargaSequence => image::codecs::tga::TgaEncoder::new(file).disable_rle().write_image(&data, w, h, ct),
                 // (the TIFF encoder needs Seek)
-                image::codecs::tiff::TiffEncoder::new(file).write_image(&data, w, h, ct).map_err(|e| ExportError::Encode(e.to_string()))
+                _ => image::codecs::tiff::TiffEncoder::new(file).write_image(&data, w, h, ct),
             }
+            .map_err(|e| ExportError::Encode(e.to_string()))
         }
         f => Err(ExportError::Unsupported(format!("{} is not a still format", f.label()))),
     }
@@ -375,7 +376,7 @@ async fn gif_export(job: &Cx<'_>, comp: &Comp, w: u32, h: u32, st: &mut State<'_
         let end = (i + batch).min(st.total);
         let frames: Vec<gif::Frame<'static>> = job
             .frames(comp, (i..end).collect(), |_, img| {
-                let mut px = job.pixels(&img, comp, job.output.channels, w, h);
+                let mut px = job.pixels_with(&img, comp, job.output.channels, w, h, false);
                 gif::Frame::from_rgba_speed(w as u16, h as u16, &mut px, 10)
             })
             .await;
diff --git a/crates/export/src/pipeline.rs b/crates/export/src/pipeline.rs
index 9fd131474..8e8c90561 100644
--- a/crates/export/src/pipeline.rs
+++ b/crates/export/src/pipeline.rs
@@ -4,10 +4,8 @@
 
 use std::sync::Mutex;
 
-use effectcraft_project::render_queue::{
-    AlphaMode, Channels, ColorDepth, CurrentOrOff, EffectsMode, FrameSample, RenderLog, ResizeQuality, SwitchOverride, log_path,
-};
-use effectcraft_project::{Comp, Project};
+use effectcraft_project::render_queue::{AlphaMode, Channels, CurrentOrOff, EffectsMode, FrameSample, RenderLog, ResizeQuality, SwitchOverride, log_path};
+use effectcraft_project::{BitDepth, Comp, Project};
 use effectcraft_raster::Image;
 use effectcraft_render::{Backend, LayerCache, RenderOpts, Renderer};
 use effectcraft_time::Tick;
@@ -39,6 +37,57 @@ pub(crate) fn gpu_inflight(var: Option<&str>) -> usize {
     }
 }
 
+/// Caps CPU frames in flight (#1615): a whole number of frames, at least 1. Unset, CPU renders
+/// keep one frame per thread in flight as before. A heavy comp can need gigabytes of working
+/// memory per frame, so 16 threads at once can get the process OOM-killed; the headless CLI
+/// reads no `memory.*` preferences, so this is how a render there is held to fewer frames.
+pub(crate) const CPU_INFLIGHT_ENV: &str = "EFFECTCRAFT_CPU_INFLIGHT";
+
+/// CPU frames in flight from the `EFFECTCRAFT_CPU_INFLIGHT` value: `None` (no cap) when unset or
+/// blank, a positive whole number, or `None` with a warning when it is 0, negative, not a
+/// number or too large.
+pub(crate) fn cpu_inflight(var: Option<&str>) -> Option<usize> {
+    let v = var?;
+    if v.trim().is_empty() {
+        return None;
+    }
+    match v.trim().parse::<usize>() {
+        Ok(n) if n >= 1 => Some(n),
+        _ => {
+            log::warn!(target: "effectcraft_export", "{CPU_INFLIGHT_ENV}={v:?} is not a whole number of frames of at least 1: CPU frames are not capped");
+            None
+        }
+    }
+}
+
+/// The frames-in-flight caps of a batch: `gpu` (#879) for the GPU's memory, `cpu` (#1615) for
+/// the process's.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub(crate) struct Inflight {
+    pub gpu: Option<usize>,
+    pub cpu: Option<usize>,
+}
+
+impl Inflight {
+    /// Frames rendered at once: the smaller cap while the GPU renders, and only the CPU cap once
+    /// it has stopped for good (the CPU fallback renders in parallel, #1511). `None`: uncapped.
+    pub fn renders(&self, gpu_live: bool) -> Option<usize> {
+        let gpu = self.gpu.filter(|_| gpu_live);
+        let n = match (gpu, self.cpu) {
+            (Some(g), Some(c)) => Some(g.min(c)),
+            (g, c) => g.or(c),
+        };
+        n.map(|n| n.max(1))
+    }
+
+    /// Frames per window, rendered (`renders` at a time) and then encoded in parallel: with a CPU
+    /// cap at most that many, so finished images held before encoding count against it too;
+    /// with a GPU cap alone, one per thread (the images are in RAM, not VRAM).
+    pub fn window(&self, renders: usize) -> usize {
+        self.cpu.map_or(renders.max(rayon::current_num_threads()), |c| c.max(1))
+    }
+}
+
 /// `render` then `encode` over the frames `ks`, results in `ks` order.
 ///
 /// Without `cap` every frame renders and encodes in one parallel batch (the CPU path, as
@@ -55,42 +104,63 @@ pub(crate) fn map_frames<I: Send, T: Send>(
     render: impl Fn(u64) -> I + Sync + Send,
     encode: impl Fn(u64, I) -> T + Sync + Send,
 ) -> Vec<T> {
-    map_frames_while(ks, cap, || true, render, encode)
+    map_frames_while(ks, Inflight { gpu: cap, cpu: None }, || true, render, encode)
 }
 
-/// [`map_frames`] whose `cap` holds only while `capped()`: once it turns false (the GPU stopped
-/// for good, so every frame falls back to the CPU), the remaining frames render in parallel
-/// like the uncapped CPU path instead of one chunk of `cap` at a time.
+/// [`map_frames`] with the caps of `caps`, the GPU cap holding only while `gpu_live()`: once it
+/// turns false (the GPU stopped for good, so every frame falls back to the CPU), the remaining
+/// frames render under the CPU cap alone, in parallel when there is none, instead of one chunk
+/// of the GPU cap at a time. A CPU cap also bounds each window ([`Inflight::window`]).
 pub(crate) fn map_frames_while<I: Send, T: Send>(
     ks: Vec<u64>,
-    cap: Option<usize>,
-    capped: impl Fn() -> bool,
+    caps: Inflight,
+    gpu_live: impl Fn() -> bool,
     render: impl Fn(u64) -> I + Sync + Send,
     encode: impl Fn(u64, I) -> T + Sync + Send,
 ) -> Vec<T> {
     use rayon::prelude::*;
-    let Some(n) = cap.map(|n| n.max(1)).filter(|_| capped()) else {
+    if caps.renders(gpu_live()).is_none() {
         return ks.into_par_iter().map(|k| encode(k, render(k))).collect();
-    };
-    let window = n.max(rayon::current_num_threads());
+    }
     let mut out = Vec::with_capacity(ks.len());
-    for (w, win) in ks.chunks(window).enumerate() {
-        if !capped() {
-            out.par_extend(ks[w * window..].par_iter().map(|&k| encode(k, render(k))));
+    let mut rest = &ks[..];
+    while !rest.is_empty() {
+        let Some(n) = caps.renders(gpu_live()) else {
+            out.par_extend(rest.par_iter().map(|&k| encode(k, render(k))));
             break;
-        }
+        };
+        let (win, tail) = rest.split_at(caps.window(n).min(rest.len()));
         let mut imgs = Vec::with_capacity(win.len());
         let mut i = 0;
         while i < win.len() {
-            let end = if capped() { (i + n).min(win.len()) } else { win.len() };
+            let end = caps.renders(gpu_live()).map_or(win.len(), |n| (i + n).min(win.len()));
             imgs.par_extend(win[i..end].par_iter().map(|&k| render(k)));
             i = end;
         }
         out.par_extend(win.par_iter().copied().zip(imgs.into_par_iter()).map(|(k, img)| encode(k, img)));
+        rest = tail;
     }
     out
 }
 
+/// Threads that encode one batch of frames while the next renders ([`Cx::frames_beside`]).
+/// Their own pool: the encoder's parallel steps (colour conversion) would otherwise queue behind
+/// the render's work in the global pool. `None` where threads can't be started (a browser
+/// without them): encoding and rendering then take turns.
+pub(crate) struct Beside(Option<rayon::ThreadPool>);
+
+impl Beside {
+    fn new() -> Beside {
+        Beside(rayon::ThreadPoolBuilder::new().thread_name(|i| format!("export-encode-{i}")).build().ok())
+    }
+
+    /// The process's encode threads, started by the first movie export and shared by all.
+    pub fn shared() -> &'static Beside {
+        static SHARED: std::sync::OnceLock<Beside> = std::sync::OnceLock::new();
+        SHARED.get_or_init(Beside::new)
+    }
+}
+
 /// A job being exported: the job, the project with the Render Settings overrides applied, the
 /// job's layer cache and per-frame timing for the render log.
 pub(crate) struct Cx<'a> {
@@ -148,6 +218,9 @@ impl<'a> Cx<'a> {
     pub fn new(job: &'a Job<'a>) -> Cx<'a> {
         let mut project = job.project.clone();
         apply_overrides(&mut project, job);
+        // Render Settings ▸ Color Depth overrides the project's depth for the whole render (every
+        // layer and effect quantises at it), not just the finished frame (#2022).
+        project.settings.bit_depth = job.settings.color_depth.resolve(project.settings.bit_depth);
         let frame_times = (job.options.log == RenderLog::PlusPerFrameInfo).then(|| Mutex::new(Vec::new()));
         let cache = LayerCache::default();
         // With deferred readbacks, buffers computed from a missed pass's placeholders are not kept.
@@ -168,7 +241,7 @@ impl<'a> Cx<'a> {
         // compositors differ slightly, so a per-frame choice made renders differ run to run.
         let backend = if self.project.settings.gpu_acceleration { Backend::Gpu } else { Backend::Cpu };
         let opts = RenderOpts {
-            scale: s.resolution.clamp(0.01, 4.0),
+            scale: self.comp().map(|c| s.effective_scale(c)).unwrap_or_else(|| s.resolution.clamp(0.01, 4.0)),
             motion_blur: s.motion_blur_override() != SwitchOverride::OffForAll,
             guides: s.guide_layers == CurrentOrOff::Current,
             draft: s.quality == RenderQuality::Draft,
@@ -208,10 +281,56 @@ impl<'a> Cx<'a> {
             }
             return out;
         }
-        // The cap is for the GPU's memory: once it has stopped for good, frames render on the
-        // CPU in parallel.
+        // The GPU cap is for the GPU's memory: once it has stopped for good, frames render on the
+        // CPU, in parallel or under the CPU cap (#1615), which holds throughout.
         let gpu_live = || self.job.accel.is_none_or(|a| a.available());
-        map_frames_while(ks, self.gpu_cap(), gpu_live, |k| self.frame(comp, k), f)
+        map_frames_while(ks, self.inflight(), gpu_live, |k| self.frame(comp, k), f)
+    }
+
+    /// [`Cx::frames`] for `ks` while `encode` runs beside them on `beside`'s threads, so the
+    /// render threads don't wait for the (largely sequential) encoder of the previous batch.
+    /// With deferred readbacks, or where no encode thread could be started, `encode` runs first.
+    #[cfg(test)]
+    pub async fn frames_beside<T: Send, A: Send>(
+        &self,
+        beside: &Beside,
+        comp: &Comp,
+        ks: Vec<u64>,
+        f: impl Fn(u64, Image) -> T + Sync + Send,
+        encode: impl FnOnce() -> A + Send,
+    ) -> crate::Result<(A, Vec<T>)> {
+        self.beside(beside, self.frames(comp, ks, f), encode).await
+    }
+
+    /// Run `encode` on `beside`'s threads while `frames` renders the next batch. With deferred
+    /// readbacks, or where no encode thread could be started, `encode` runs first.
+    pub async fn beside<T: Send, A: Send>(
+        &self,
+        beside: &Beside,
+        frames: impl std::future::Future<Output = Vec<T>>,
+        encode: impl FnOnce() -> A + Send,
+    ) -> crate::Result<(A, Vec<T>)> {
+        match &beside.0 {
+            Some(pool) if !self.deferred() => {
+                let mut done = None;
+                let frames = pool.in_place_scope(|s| {
+                    s.spawn(|_| done = Some(std::panic::catch_unwind(std::panic::AssertUnwindSafe(encode))));
+                    effectcraft_render::passes::block_on(frames)
+                });
+                match done {
+                    Some(Ok(a)) => Ok((a, frames)),
+                    Some(Err(panic)) => {
+                        let why = panic.downcast_ref::<&str>().map(|s| s.to_string()).or_else(|| panic.downcast_ref::<String>().cloned()).unwrap_or_default();
+                        Err(crate::ExportError::Encode(format!("the encoder stopped unexpectedly: {why}")))
+                    }
+                    None => Err(crate::ExportError::Encode("the encoder stopped unexpectedly".into())),
+                }
+            }
+            _ => {
+                let a = encode();
+                Ok((a, frames.await))
+            }
+        }
     }
 
     /// GPU frames rendered at once (#879), decided once per batch: with a GPU accelerator every
@@ -222,6 +341,11 @@ impl<'a> Cx<'a> {
         (self.job.accel.is_some() && self.project.settings.gpu_acceleration).then(|| gpu_inflight(std::env::var(GPU_INFLIGHT_ENV).ok().as_deref()))
     }
 
+    /// The GPU and CPU frames-in-flight caps every frame loop shares (#1615).
+    fn inflight(&self) -> Inflight {
+        Inflight { gpu: self.gpu_cap(), cpu: cpu_inflight(std::env::var(CPU_INFLIGHT_ENV).ok().as_deref()) }
+    }
+
     /// Output frame `i`: sampled (fields, pulldown), at the colour depth, cropped and resized.
     pub fn frame(&self, comp: &Comp, i: u64) -> Image {
         effectcraft_render::passes::block_on(self.frame_async(comp, i))
@@ -237,14 +361,6 @@ impl<'a> Cx<'a> {
                 if second == first { a } else { interleave(&a, &self.render_at(second).await, upper_first) }
             }
         };
-        let mut img = img;
-        // Color Depth: renders run at the project's depth; another depth quantises the frame.
-        let depth = self.job.settings.color_depth;
-        if depth != ColorDepth::Current
-            && let Some(levels) = depth.resolve(self.project.settings.bit_depth).levels()
-        {
-            img.quantize(levels);
-        }
         let img = self.crop_resize(img);
         if let Some(ft) = &self.frame_times {
             ft.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push((i, t0.elapsed().as_secs_f64()));
@@ -252,16 +368,76 @@ impl<'a> Cx<'a> {
         img
     }
 
+    /// Output frame `i` as the H.264 export's 4:2:0 planes at `w`×`h`, rendered and converted
+    /// by the accelerator ([`effectcraft_render::Accelerator::comp_frame_yuv420`]). Only for
+    /// frames that need nothing done after the render (progressive, at the project's depth, no
+    /// crop or resize, rendered at exactly `w`×`h`). `None`: render it with [`Cx::frame`].
+    pub fn yuv420_frame(&self, comp: &Comp, i: u64, w: u32, h: u32) -> Option<Vec<u8>> {
+        if self.deferred() {
+            return None;
+        }
+        let FrameSample::Progressive(t) = self.job.settings.sample(comp, i) else { return None };
+        // Above 8 bpc the colour is dithered on its way to 8 bits (`Cx::pixels`), which the
+        // accelerator's conversion doesn't do: those frames render as usual so H.264 doesn't
+        // band (#2022). The project's depth already includes Render Settings ▸ Color Depth.
+        if self.project.settings.bit_depth != BitDepth::Bpc8 {
+            return None;
+        }
+        let om = self.job.output;
+        let scale = self.job.settings.effective_scale(comp);
+        let size = |n: u32| ((n as f64 * scale).round() as u32).max(1);
+        if om.resize.enabled || (size(comp.width), size(comp.height)) != (w, h) || om.crop.edges(w, h, scale) != (0, 0, 0, 0) {
+            return None;
+        }
+        let t0 = Instant::now();
+        let r = self.renderer();
+        let planes = r.active_accel()?.comp_frame_yuv420(&r, self.job.comp, t, comp.background)?;
+        let (cw, ch) = (w.div_ceil(2) as usize, h.div_ceil(2) as usize);
+        if planes.len() != w as usize * h as usize + 2 * cw * ch {
+            return None;
+        }
+        if let Some(ft) = &self.frame_times {
+            ft.lock().unwrap_or_else(|e| e.into_inner()).push((i, t0.elapsed().as_secs_f64()));
+        }
+        Some(planes)
+    }
+
+    /// Output frames `ks` for the H.264 encoder: the accelerator's planes
+    /// ([`Cx::yuv420_frame`]) where it can, otherwise `fallback` of the frame rendered as usual.
+    pub(crate) fn h264_frames<T: Send>(
+        &self,
+        comp: &Comp,
+        ks: Vec<u64>,
+        w: u32,
+        h: u32,
+        planes: impl Fn(Vec<u8>) -> T + Sync + Send,
+        fallback: impl Fn(u64, Image) -> T + Sync + Send,
+    ) -> Vec<T> {
+        // As in `frames`: once the GPU has stopped for good, the rest render in parallel.
+        let gpu_live = || self.job.accel.is_none_or(|a| a.available());
+        map_frames_while(
+            ks,
+            self.inflight(),
+            gpu_live,
+            |k| self.yuv420_frame(comp, k, w, h).ok_or_else(|| self.frame(comp, k)),
+            |k, r| match r {
+                Ok(p) => planes(p),
+                Err(img) => fallback(k, img),
+            },
+        )
+    }
+
     /// Output Module ▸ Crop, then Resize.
     fn crop_resize(&self, img: Image) -> Image {
         let om = self.job.output;
-        let scale = self.job.settings.resolution.clamp(0.01, 4.0);
+        let scale = self.comp().map(|c| self.job.settings.effective_scale(c)).unwrap_or_else(|| self.job.settings.resolution.clamp(0.01, 4.0));
+        // frame_size applies crop itself: use the original frame and the same scale as edges.
+        let (w, h) = om.frame_size(img.width, img.height, scale);
         let (t, l, b, r) = om.crop.edges(img.width, img.height, scale);
         let img = if (t, l, b, r) == (0, 0, 0, 0) { img } else { crop(&img, t, l, b, r) };
         if !om.resize.enabled {
             return img;
         }
-        let (w, h) = om.frame_size(img.width, img.height, 1.0);
         if (w, h) == (img.width, img.height) {
             return img;
         }
@@ -273,12 +449,24 @@ impl<'a> Cx<'a> {
 
     /// 8-bit RGBA of the requested channels cropped/padded to `w`×`h` (codec rounding): RGB over
     /// the comp background (opaque), RGB + Alpha straight or premultiplied, or the alpha matte.
+    /// When the render runs above 8 bpc, the colour is dithered on its way to 8 bits, as After
+    /// Effects dithers colours converted down to 8 bpc for rendering and export, so gradients
+    /// rendered at 16 or 32 bpc don't band (#2022). An 8 bpc render has no finer values to
+    /// dither, so its output stays byte for byte what it was.
     pub fn pixels(&self, img: &Image, comp: &Comp, channels: Channels, w: u32, h: u32) -> Vec<u8> {
+        let dither = self.project.settings.bit_depth != BitDepth::Bpc8;
+        self.pixels_with(img, comp, channels, w, h, dither)
+    }
+
+    /// [`Cx::pixels`], dithering the colour or not (a GIF palette gains nothing from dither noise).
+    pub fn pixels_with(&self, img: &Image, comp: &Comp, channels: Channels, w: u32, h: u32, dither: bool) -> Vec<u8> {
         let px = match channels {
+            Channels::Rgb if dither => img.to_rgba8_over_dithered(comp.background),
             Channels::Rgb => img.to_rgba8_over(comp.background),
-            Channels::Rgba => match self.job.output.alpha_mode {
-                AlphaMode::Straight => img.to_rgba8(),
-                AlphaMode::Premultiplied => premultiplied8(img),
+            Channels::Rgba => match (self.job.output.alpha_mode, dither) {
+                (AlphaMode::Straight, true) => img.to_rgba8_dithered(),
+                (AlphaMode::Straight, false) => img.to_rgba8(),
+                (AlphaMode::Premultiplied, _) => premultiplied8(img, dither),
             },
             Channels::Alpha => img
                 .data
@@ -439,21 +627,42 @@ fn bicubic(src: &Image, w: u32, h: u32) -> Image {
     out
 }
 
-/// Premultiplied 8-bit RGBA (colour matted with black).
-fn premultiplied8(img: &Image) -> Vec<u8> {
-    img.data
-        .iter()
-        .flat_map(|p| {
-            let a = p[3].clamp(0.0, 1.0);
-            [0, 1, 2].map(|c| (p[c].clamp(0.0, a) * 255.0 + 0.5) as u8).into_iter().chain([(a * 255.0 + 0.5) as u8])
-        })
-        .collect()
+/// Premultiplied 8-bit RGBA (colour matted with black), the colour dithered when `dither`.
+fn premultiplied8(img: &Image, dither: bool) -> Vec<u8> {
+    let w = img.width.max(1) as usize;
+    let mut out = Vec::with_capacity(img.data.len() * 4);
+    for (i, p) in img.data.iter().enumerate() {
+        let a = p[3].clamp(0.0, 1.0);
+        let a8 = (a * 255.0 + 0.5) as u8;
+        let (x, y) = ((i % w) as u32, (i / w) as u32);
+        for c in 0..3 {
+            let v = p[c].clamp(0.0, a);
+            // Dither may round up past the rounded alpha; premultiplied colour never exceeds it.
+            out.push(if dither { effectcraft_raster::dither_u8(v, x, y).min(a8) } else { (v * 255.0 + 0.5) as u8 });
+        }
+        out.push(a8);
+    }
+    out
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use rayon::prelude::*;
+    use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+
+    /// Dither may round a colour up while alpha rounds down; premultiplied colour stays at or
+    /// below the written alpha at every pixel.
+    #[test]
+    fn dithered_premultiplied_colour_never_exceeds_alpha() {
+        let v = 100.25 / 255.0;
+        let img = Image::filled(64, 64, [v, v, v, v]);
+        let px = premultiplied8(&img, true);
+        assert!(px.as_chunks::<4>().0.iter().all(|p| p[..3].iter().all(|c| *c <= p[3])), "a colour byte is above its alpha");
+        assert!(px.as_chunks::<4>().0.iter().all(|p| p[3] == 100));
+        let plain = premultiplied8(&img, false);
+        assert!(plain.as_chunks::<4>().0.iter().all(|p| *p == [100, 100, 100, 100]));
+    }
 
     /// Frames `0..n` through [`map_frames`] with `cap`, recording the most running at once.
     fn run_capped(n: u64, cap: Option<usize>) -> (Vec<u64>, usize) {
@@ -486,7 +695,7 @@ mod tests {
         let out = pool.install(|| {
             map_frames_while(
                 (0..24).collect(),
-                Some(1),
+                Inflight { gpu: Some(1), cpu: None },
                 || live.load(Ordering::SeqCst),
                 |k| {
                     if k == 1 {
@@ -646,6 +855,103 @@ mod tests {
         assert_eq!(Cx::new(&job).gpu_cap(), None, "no accelerator");
     }
 
+    #[test]
+    fn cpu_inflight_is_off_unless_a_positive_number() {
+        assert_eq!(cpu_inflight(None), None);
+        assert_eq!(cpu_inflight(Some("2")), Some(2));
+        assert_eq!(cpu_inflight(Some(" 4 ")), Some(4));
+        for bad in ["0", "", "  ", "-2", "three", "2.5", "99999999999999999999999"] {
+            assert_eq!(cpu_inflight(Some(bad)), None, "{bad:?}");
+        }
+    }
+
+    #[test]
+    fn cpu_cap_holds_and_combines_with_the_gpu_cap() {
+        // #1615: CPU renders had no cap; a GPU cap alone still lapses when the GPU stops.
+        let caps = |gpu, cpu| Inflight { gpu, cpu };
+        for live in [true, false] {
+            assert_eq!(caps(None, None).renders(live), None);
+            assert_eq!(caps(None, Some(2)).renders(live), Some(2));
+        }
+        assert_eq!(caps(Some(1), None).renders(true), Some(1));
+        assert_eq!(caps(Some(1), None).renders(false), None);
+        assert_eq!(caps(Some(3), Some(2)).renders(true), Some(2));
+        assert_eq!(caps(Some(1), Some(4)).renders(true), Some(1));
+        // Review of #1615: once the GPU stops, the CPU cap applies, not the GPU's 1.
+        assert_eq!(caps(Some(1), Some(4)).renders(false), Some(4));
+        // A CPU cap of 2 on 8 threads renders at most 2 frames at once.
+        let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();
+        let (now, max) = (AtomicUsize::new(0), AtomicUsize::new(0));
+        let out = pool.install(|| map_frames_while((0..16).collect(), caps(None, Some(2)), || true, |k| track(&now, &max, k), |_, k| k));
+        assert_eq!(out, (0..16).collect::<Vec<_>>());
+        assert!(max.load(Ordering::SeqCst) <= 2, "{max:?} frames in flight");
+    }
+
+    /// Counts `k` in flight in `now`, records the most in `max`, and holds it for a moment.
+    fn track(now: &AtomicUsize, max: &AtomicUsize, k: u64) -> u64 {
+        let c = now.fetch_add(1, Ordering::SeqCst) + 1;
+        max.fetch_max(c, Ordering::SeqCst);
+        std::thread::sleep(std::time::Duration::from_millis(5));
+        now.fetch_sub(1, Ordering::SeqCst);
+        k
+    }
+
+    #[test]
+    fn a_cpu_cap_bounds_the_images_waiting_to_encode() {
+        // Review of #1615: a window of one image per thread was rendered before any encoded, so
+        // a cap of 2 on 8 threads still held 8 finished images.
+        let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();
+        for gpu in [None, Some(1)] {
+            let (held, max) = (AtomicUsize::new(0), AtomicUsize::new(0));
+            let out = pool.install(|| {
+                map_frames_while(
+                    (0..20).collect(),
+                    Inflight { gpu, cpu: Some(2) },
+                    || true,
+                    |k| {
+                        let c = held.fetch_add(1, Ordering::SeqCst) + 1;
+                        max.fetch_max(c, Ordering::SeqCst);
+                        k
+                    },
+                    |k, img| {
+                        held.fetch_sub(1, Ordering::SeqCst);
+                        assert_eq!(k, img);
+                        k
+                    },
+                )
+            });
+            assert_eq!(out, (0..20).collect::<Vec<_>>());
+            assert!(max.load(Ordering::SeqCst) <= 2, "gpu {gpu:?}: {max:?} images held");
+        }
+    }
+
+    #[test]
+    fn the_cpu_cap_takes_over_once_the_gpu_stops() {
+        // Review of #1615: with both caps, frames after the GPU stopped rendered one at a time.
+        let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap();
+        let (live, now, max) = (AtomicBool::new(true), AtomicUsize::new(0), AtomicUsize::new(0));
+        let out = pool.install(|| {
+            map_frames_while(
+                (0..40).collect(),
+                Inflight { gpu: Some(1), cpu: Some(4) },
+                || live.load(Ordering::SeqCst),
+                |k| {
+                    if k == 1 {
+                        live.store(false, Ordering::SeqCst);
+                    }
+                    if k < 4 {
+                        return k;
+                    }
+                    track(&now, &max, k)
+                },
+                |_, k| k,
+            )
+        });
+        assert_eq!(out, (0..40).collect::<Vec<_>>());
+        let max = max.load(Ordering::SeqCst);
+        assert!((2..=4).contains(&max), "{max} frames in flight after the GPU stopped");
+    }
+
     #[test]
     fn gpu_inflight_override_is_a_positive_number_or_the_default() {
         assert_eq!(gpu_inflight(None), GPU_INFLIGHT_DEFAULT);
@@ -706,6 +1012,45 @@ mod tests {
         assert!(stats.hits >= 9, "{stats:?}");
     }
 
+    #[test]
+    fn frames_render_beside_the_encoder() {
+        use effectcraft_project::render_queue::{OutputFormat, OutputModule, RenderSettings};
+        use effectcraft_render::NoFootage;
+        use effectcraft_time::FrameRate;
+        let mut p = Project::default();
+        let comp = Comp::new(32, 16, FrameRate::FPS_25, Tick::from_seconds_f64(1.0));
+        let cid = p.add_item("Comp", effectcraft_color::Label::Sandstone, None, effectcraft_project::ItemKind::Comp(comp.into()));
+        let (settings, output) = (RenderSettings::default(), OutputModule::for_format(OutputFormat::H264));
+        let job = Job {
+            project: &p,
+            footage: &NoFootage,
+            expr: None,
+            accel: None,
+            comp: cid,
+            settings: &settings,
+            output: &output,
+            path: "/c/out.mp4",
+            sink: None,
+            nested_switches: true,
+            options: Default::default(),
+        };
+        let cx = Cx::new(&job);
+        let comp = cx.comp().unwrap();
+        use effectcraft_render::passes::block_on;
+        let want = block_on(cx.frames(comp, (0..6).collect(), |k, img| (k, img.width, img.height)));
+        // On threads of their own, and taking turns (no threads): the same frames, in order.
+        for beside in [Beside::shared(), &Beside(None)] {
+            let (a, frames) = block_on(cx.frames_beside(beside, comp, (0..6).collect(), |k, img| (k, img.width, img.height), || 7)).unwrap();
+            assert_eq!((a, &frames), (7, &want));
+        }
+        // A panicking encoder fails the export instead of taking the render thread down.
+        let r = block_on(cx.frames_beside(Beside::shared(), comp, vec![0], |k, _| k, || -> u32 { panic!("encoder bug") }));
+        match r {
+            Err(crate::ExportError::Encode(e)) => assert!(e.contains("encoder bug"), "{e}"),
+            other => panic!("{:?}", other.map(|(a, f)| (a, f.len()))),
+        }
+    }
+
     #[test]
     fn interleave_takes_alternate_lines() {
         let a = Image::filled(3, 4, [1.0, 0.0, 0.0, 1.0]);
@@ -718,6 +1063,91 @@ mod tests {
         }
     }
 
+    /// Regress the locked-aspect example: cropping 1920x1080 must resize to 1280x1440.
+    #[test]
+    fn crop_resize_applies_margins_once() {
+        use effectcraft_project::render_queue::{Crop, OutputModule, Resize};
+        let output = OutputModule {
+            crop: Crop { enabled: true, left: 480, right: 480, ..Default::default() },
+            resize: Resize { enabled: true, width: 1280, lock_aspect: true, quality: ResizeQuality::Low, ..Default::default() },
+            ..Default::default()
+        };
+        assert_eq!(output.frame_size(1920, 1080, 1.0), (1280, 1440));
+        let img = run_crop_resize(Image::new(1920, 1080), &output, 1.0);
+        assert_eq!((img.width, img.height), (1280, 1440));
+        assert_eq!(img.data.len(), 1280 * 1440);
+    }
+
+    /// Apply output-module geometry to a synthetic frame without rendering or writing files.
+    fn run_crop_resize(img: Image, output: &effectcraft_project::render_queue::OutputModule, scale: f64) -> Image {
+        use effectcraft_project::render_queue::RenderSettings;
+        let project = Project::default();
+        let settings = RenderSettings { resolution: scale, ..Default::default() };
+        let job = Job {
+            project: &project,
+            footage: &effectcraft_render::NoFootage,
+            expr: None,
+            accel: None,
+            comp: effectcraft_project::ItemId(0),
+            settings: &settings,
+            output,
+            path: "unused.png",
+            sink: None,
+            nested_switches: true,
+            options: Default::default(),
+        };
+        Cx::new(&job).crop_resize(img)
+    }
+
+    /// Match predicted dimensions across crop, padding, ROI scale, aspect locks and resize qualities.
+    #[test]
+    fn crop_resize_dimensions_match_the_output_module() {
+        use effectcraft_project::render_queue::{Crop, OutputModule, Resize};
+        let edges = Crop { enabled: true, left: 2, right: 2, ..Default::default() };
+        let padding = Crop { enabled: true, left: -2, bottom: -2, ..Default::default() };
+        let roi = |rect| Crop { enabled: true, use_roi: true, roi: Some(rect), ..Default::default() };
+        for quality in [ResizeQuality::Low, ResizeQuality::High] {
+            let resize = |width| Resize { enabled: true, width, height: 1, lock_aspect: true, quality };
+            for (crop, resize, scale, expected) in [
+                (Crop::default(), Resize::default(), 1.0, (8, 6)),
+                (edges, Resize::default(), 1.0, (4, 6)),
+                (Crop::default(), resize(4), 1.0, (4, 3)),
+                (edges, resize(8), 1.0, (8, 12)),
+                (padding, resize(5), 1.0, (5, 4)),
+                (roi([4.0, 2.0, 8.0, 6.0]), resize(8), 0.5, (8, 6)),
+                (roi([1.0, 0.5, 2.0, 1.5]), resize(8), 2.0, (8, 6)),
+                (edges, Resize { lock_aspect: false, height: 2, ..resize(5) }, 1.0, (5, 2)),
+            ] {
+                let output = OutputModule { crop, resize, ..Default::default() };
+                assert_eq!(output.frame_size(8, 6, scale), expected);
+                let img = run_crop_resize(Image::filled(8, 6, [0.25, 0.0, 0.0, 0.5]), &output, scale);
+                assert_eq!((img.width, img.height), expected, "{crop:?}, {resize:?}, scale {scale}");
+                assert_eq!(img.data.len(), expected.0 as usize * expected.1 as usize);
+            }
+        }
+    }
+
+    /// Exercise zero/empty inputs, collapsed crops and existing caps on extreme single-axis resizes.
+    #[test]
+    fn crop_resize_zero_and_extreme_sizes_stay_bounded() {
+        use effectcraft_project::render_queue::{Crop, OutputModule, Resize};
+        for quality in [ResizeQuality::Low, ResizeQuality::High] {
+            for (size, crop, width, height, expected) in [
+                ((8, 6), Crop::default(), 0, 0, (1, 1)),
+                ((8, 1), Crop::default(), u32::MAX, 1, (30_000, 1)),
+                ((1, 8), Crop::default(), 1, u32::MAX, (1, 30_000)),
+                ((8, 6), Crop { enabled: true, left: 20_000, right: 20_000, ..Default::default() }, 2, 3, (2, 3)),
+                ((0, 0), Crop { enabled: true, left: 1, top: 1, ..Default::default() }, 2, 3, (2, 3)),
+            ] {
+                let output = OutputModule { crop, resize: Resize { enabled: true, width, height, lock_aspect: false, quality }, ..Default::default() };
+                let img = run_crop_resize(Image::new(size.0, size.1), &output, 1.0);
+                assert_eq!((img.width, img.height), expected);
+                assert_eq!(img.data.len(), expected.0 as usize * expected.1 as usize);
+                assert!(img.data.iter().all(|p| *p == [0.0; 4]));
+            }
+        }
+    }
+
     #[test]
     fn crop_and_pad() {
         let mut img = Image::new(4, 3);
diff --git a/crates/export/tests/it/banding.rs b/crates/export/tests/it/banding.rs
new file mode 100644
index 000000000..3f99f1eb6
--- /dev/null
+++ b/crates/export/tests/it/banding.rs
@@ -0,0 +1,156 @@
+//! Gradients exported at 16 bpc (or with a 16 bpc Color Depth override) don't band (#2022): the
+//! float frame is dithered on its way to 8 bits, and the Render Settings' Color Depth reaches the
+//! render itself.
+
+use std::sync::{Arc, Mutex};
+
+use effectcraft_color::Label;
+use effectcraft_export::render_queue::*;
+use effectcraft_export::{Job, JobOptions, Sink, export};
+use effectcraft_keyframe::Value;
+use effectcraft_project::build::{self, Ids};
+use effectcraft_project::{BitDepth, Comp, ItemId, ItemKind, LayerSource, Project, Solid};
+use effectcraft_render::NoFootage;
+use effectcraft_time::{FrameRate, Tick};
+
+const W: u32 = 1024;
+const H: u32 = 16;
+/// The ramp runs from this grey to `HI` across the comp: about 25 eight-bit codes in 1024 px,
+/// so plain rounding makes bands about 40 px wide.
+const LO: f64 = 0.20;
+const HI: f64 = 0.30;
+/// Width of the column blocks whose mean is compared with the ideal ramp.
+const WINDOW: u32 = 8;
+
+/// A grey horizontal ramp over a comp of the given project depth.
+fn ramp_project(depth: BitDepth) -> (Project, ItemId) {
+    let mut p = Project::default();
+    p.settings.bit_depth = depth;
+    let mut comp = Comp::new(W, H, FrameRate::new(25, 1), Tick::from_seconds_f64(1.0));
+    comp.background = [0.0, 0.0, 0.0];
+    let sid = p.add_item("Ramp", Label::Red, None, ItemKind::Solid(Solid { color: [1.0, 1.0, 1.0], width: W, height: H, pixel_aspect: 1.0 }));
+    let mut layer = build::layer(&mut p, &comp, "Ramp", LayerSource::Solid { item: sid }, (W, H), None);
+    let spec = effectcraft_effects::find("ec.generate.gradientramp").expect("gradient ramp effect");
+    let mut next = p.next_id;
+    let mut group = effectcraft_effects::instantiate(spec, &mut Ids(&mut next), spec.name, [W as f64, H as f64]);
+    p.next_id = next;
+    for (k, v) in [
+        ("start", Value::Vec2([0.0, 0.0])),
+        ("end", Value::Vec2([W as f64, 0.0])),
+        ("startColor", Value::Color([LO, LO, LO, 1.0])),
+        ("endColor", Value::Color([HI, HI, HI, 1.0])),
+    ] {
+        group.get_mut(k).expect("ramp parameter").value = v;
+    }
+    layer.props.sub_mut("effects").expect("effects group").children.push(group.into());
+    comp.layers.push(layer);
+    let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.into()));
+    (p, cid)
+}
+
+/// Export frame 0 as PNG with the Render Settings' Color Depth `depth` and return the grey of
+/// every row.
+fn export_rows(p: &Project, cid: ItemId, depth: ColorDepth) -> Vec<Vec<u8>> {
+    let files: Arc<Mutex<Vec<(String, Vec<u8>)>>> = Default::default();
+    let f = files.clone();
+    let sink: Box<Sink> = Box::new(move |path: &str, data: Vec<u8>| f.lock().unwrap().push((path.to_string(), data)));
+    let settings =
+        RenderSettings { time_span: TimeSpan::Custom { start: Tick::ZERO, end: Tick::from_seconds_f64(0.04) }, color_depth: depth, ..Default::default() };
+    let om = OutputModule::for_format(OutputFormat::PngSequence);
+    let job = Job {
+        project: p,
+        footage: &NoFootage,
+        expr: None,
+        accel: None,
+        comp: cid,
+        settings: &settings,
+        output: &om,
+        path: "/banding/f_[#####].png",
+        sink: Some(&*sink),
+        options: JobOptions::default(),
+        nested_switches: true,
+    };
+    export(&job, &mut |_| true).expect("export");
+    let files = files.lock().unwrap();
+    let (_, png) = files.iter().find(|(path, _)| path.ends_with(".png")).expect("a PNG");
+    let img = image::load_from_memory(png).expect("png").to_rgba8();
+    (0..H).map(|y| (0..W).map(|x| img.get_pixel(x, y).0[1]).collect()).collect()
+}
+
+/// The ideal ramp at column `x`, in 8-bit codes.
+fn ideal(x: f64) -> f64 {
+    255.0 * (LO + (HI - LO) * (x + 0.5) / W as f64)
+}
+
+/// Longest run of equal neighbours in the row: a band's width.
+fn longest_run(row: &[u8]) -> usize {
+    let (mut best, mut run) = (1, 1);
+    for w in row.windows(2) {
+        run = if w[0] == w[1] { run + 1 } else { 1 };
+        best = best.max(run);
+    }
+    best
+}
+
+/// Horizontal neighbours with different values, over all rows: ~25 per row when every band is a
+/// flat step, hundreds when the steps are dithered.
+fn transitions(rows: &[Vec<u8>]) -> usize {
+    rows.iter().map(|r| r.windows(2).filter(|w| w[0] != w[1]).count()).sum()
+}
+
+/// Largest difference, in 8-bit codes, between the mean of a `WINDOW`-column block over all rows
+/// and the ideal ramp's mean over it. Plain rounding leaves up to ~0.4 codes of it beside a step
+/// edge; dither averages it away (its noise on a mean of `WINDOW * H` samples is under 0.05).
+fn worst_window_error(rows: &[Vec<u8>]) -> f64 {
+    (0..W / WINDOW)
+        .map(|i| {
+            let (x0, x1) = ((i * WINDOW) as usize, ((i + 1) * WINDOW) as usize);
+            let sum: f64 = rows.iter().flat_map(|r| &r[x0..x1]).map(|&v| v as f64).sum();
+            let mean = sum / (rows.len() * (x1 - x0)) as f64;
+            (mean - ideal((x0 + x1) as f64 / 2.0 - 1.0)).abs()
+        })
+        .fold(0.0, f64::max)
+}
+
+#[test]
+fn a_16_bpc_gradient_export_is_dithered() {
+    let (p, cid) = ramp_project(BitDepth::Bpc16);
+    let rows = export_rows(&p, cid, ColorDepth::Current);
+    let (steps, err) = (transitions(&rows), worst_window_error(&rows));
+    eprintln!("16 bpc project: {steps} transitions, worst {WINDOW}-px mean error {err:.3} codes");
+    // Undithered there are ~25 flat steps per row (400 transitions) and the block means are off
+    // by up to ~0.4 codes.
+    assert!(steps > 2000, "the steps survive: {steps} transitions");
+    assert!(err < 0.25, "the local mean is off by {err} codes");
+    // Dither never moves a value a whole code from the ideal ramp.
+    for row in &rows {
+        for (x, &v) in row.iter().enumerate() {
+            let want = ideal(x as f64);
+            assert!((v as f64 - want).abs() < 1.05, "x {x}: {v} vs {want}");
+        }
+    }
+}
+
+#[test]
+fn the_export_is_the_same_every_time() {
+    let (p, cid) = ramp_project(BitDepth::Bpc16);
+    assert_eq!(export_rows(&p, cid, ColorDepth::Current), export_rows(&p, cid, ColorDepth::Current));
+}
+
+#[test]
+fn the_render_color_depth_reaches_the_render() {
+    // An 8 bpc project renders every layer at 8 bits: flat steps, nothing for the output to dither.
+    let (p, cid) = ramp_project(BitDepth::Bpc8);
+    let banded = export_rows(&p, cid, ColorDepth::Current);
+    assert!(longest_run(&banded[0]) >= 30, "an 8 bpc render is quantised before export");
+    assert!(transitions(&banded) < 16 * 30);
+    // The Render Settings' 16 bpc depth overrides the project's: the render keeps its precision
+    // until the final conversion, which dithers.
+    let deep = export_rows(&p, cid, ColorDepth::Bpc16);
+    let (steps, err) = (transitions(&deep), worst_window_error(&deep));
+    eprintln!("8 bpc project, 16 bpc render: {steps} transitions, worst {WINDOW}-px mean error {err:.3} codes");
+    assert!(steps > 2000 && err < 0.25, "a 16 bpc render still bands: {steps} transitions, error {err}");
+    // And 8 bpc on a 16 bpc project renders at 8 bits.
+    let (p16, cid16) = ramp_project(BitDepth::Bpc16);
+    assert_eq!(export_rows(&p16, cid16, ColorDepth::Bpc8), banded);
+}
diff --git a/crates/export/tests/it/h264_gpu_yuv.rs b/crates/export/tests/it/h264_gpu_yuv.rs
new file mode 100644
index 000000000..0f99a7b54
--- /dev/null
+++ b/crates/export/tests/it/h264_gpu_yuv.rs
@@ -0,0 +1,194 @@
+//! H.264 export with an accelerator that converts frames to 4:2:0 itself
+//! (`Accelerator::comp_frame_yuv420`): the file is the same as the CPU conversion's, and frames
+//! the accelerator can't take (odd sizes, crop) fall back to the RGBA path.
+
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+use effectcraft_color::Label;
+use effectcraft_export::render_queue::{ColorDepth, OutputFormat, OutputModule, RenderSettings, TimeSpan};
+use effectcraft_export::{Job, export};
+use effectcraft_project::{Comp, ItemId, ItemKind, LayerSource, Project, Solid, build};
+use effectcraft_raster::Image;
+use effectcraft_render::{Accelerator, NoFootage, Renderer};
+use effectcraft_time::{FrameRate, Tick};
+
+/// Renders on the CPU; converts to 4:2:0 with the export's own function when `yuv` is set.
+/// `deferred`: claims deferred readbacks (a browser worker's GPU), whose frames render in passes.
+/// `stop_after`: the device stops for good after that many planes (`available` turns false).
+struct Fake {
+    yuv: bool,
+    yuv_frames: AtomicUsize,
+    deferred: bool,
+    stop_after: usize,
+    /// Frames asking for planes right now, and the most at once after the stop.
+    asking: AtomicUsize,
+    most_after_stop: AtomicUsize,
+}
+
+impl Fake {
+    fn new(yuv: bool, deferred: bool, stop_after: usize) -> Self {
+        Fake { yuv, yuv_frames: AtomicUsize::new(0), deferred, stop_after, asking: AtomicUsize::new(0), most_after_stop: AtomicUsize::new(0) }
+    }
+}
+
+impl Accelerator for Fake {
+    fn name(&self) -> String {
+        "fake".into()
+    }
+    fn comp_frame(&self, r: &Renderer, comp: ItemId, t: Tick) -> Option<Image> {
+        Some(r.comp_frame_cpu(comp, t))
+    }
+    fn comp_frame_yuv420(&self, r: &Renderer, comp: ItemId, t: Tick, bg: [f32; 3]) -> Option<Vec<u8>> {
+        if !self.yuv {
+            return None;
+        }
+        if self.yuv_frames.fetch_add(1, Ordering::SeqCst) >= self.stop_after {
+            self.yuv_frames.fetch_sub(1, Ordering::SeqCst);
+            // Stopped: every frame still asks first, so asks that overlap are frames rendering at once.
+            let now = self.asking.fetch_add(1, Ordering::SeqCst) + 1;
+            self.most_after_stop.fetch_max(now, Ordering::SeqCst);
+            std::thread::sleep(std::time::Duration::from_millis(30));
+            self.asking.fetch_sub(1, Ordering::SeqCst);
+            return None;
+        }
+        Some(effectcraft_raster::yuv::yuv420_over(&r.comp_frame_cpu(comp, t), bg))
+    }
+    fn available(&self) -> bool {
+        self.yuv_frames.load(Ordering::SeqCst) < self.stop_after
+    }
+    fn miss_gate(&self) -> Option<std::sync::Arc<std::sync::atomic::AtomicBool>> {
+        self.deferred.then(Default::default)
+    }
+    fn supports_effect(&self, _id: &str) -> bool {
+        false
+    }
+    fn effects(&self, _chain: &[effectcraft_render::FxStep], _buf: &effectcraft_effects::Buf, _levels: Option<f32>) -> Option<effectcraft_effects::Buf> {
+        None
+    }
+}
+
+fn out_dir(name: &str) -> PathBuf {
+    let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/export").join(name);
+    let _ = std::fs::remove_dir_all(&d);
+    std::fs::create_dir_all(&d).expect("mkdir");
+    d
+}
+
+fn project() -> (Project, ItemId) {
+    let mut p = Project::default();
+    p.settings.gpu_acceleration = true;
+    let mut comp = Comp::new(64, 48, FrameRate::new(10, 1), Tick::from_seconds_f64(0.6));
+    comp.background = [0.1, 0.1, 0.4];
+    let sid = p.add_item("Red", Label::Red, None, ItemKind::Solid(Solid { color: [1.0, 0.2, 0.0], width: 30, height: 20, pixel_aspect: 1.0 }));
+    let mut l = build::layer(&mut p, &comp, "Red", LayerSource::Solid { item: sid }, (30, 20), None);
+    l.in_point = comp.frame_rate.tick_of(2);
+    comp.layers.push(l);
+    let cid = p.add_item("Comp 1", Label::Sandstone, None, ItemKind::Comp(comp.into()));
+    (p, cid)
+}
+
+fn run(p: &Project, cid: ItemId, accel: Option<&dyn Accelerator>, s: &RenderSettings, path: &Path) -> Vec<u8> {
+    let om = OutputModule { bitrate_kbps: 4000, ..OutputModule::for_format(OutputFormat::H264) };
+    let path = path.to_string_lossy().to_string();
+    let job = Job {
+        project: p,
+        footage: &NoFootage,
+        expr: None,
+        accel,
+        comp: cid,
+        settings: s,
+        output: &om,
+        path: &path,
+        sink: None,
+        options: Default::default(),
+        nested_switches: true,
+    };
+    export(&job, &mut |_| true).expect("export");
+    std::fs::read(&path).expect("read")
+}
+
+#[test]
+fn accelerator_planes_encode_like_the_cpu_conversion() {
+    let d = out_dir("h264-gpu-yuv");
+    let (mut p, cid) = project();
+    // Across more than one 16-frame batch so the second batch renders beside the encoder.
+    p.comp_mut(cid).unwrap().duration = Tick::from_seconds_f64(2.0);
+    let s = RenderSettings { time_span: TimeSpan::LengthOfComp, ..Default::default() };
+    let yuv = Fake::new(true, false, usize::MAX);
+    let rgba = Fake::new(false, false, usize::MAX);
+    let yuv_mp4 = d.join("yuv.mp4");
+    let a = run(&p, cid, Some(&yuv), &s, &yuv_mp4);
+    let b = run(&p, cid, Some(&rgba), &s, &d.join("rgba.mp4"));
+    let c = run(&p, cid, None, &s, &d.join("cpu.mp4"));
+    assert_eq!(yuv.yuv_frames.load(Ordering::SeqCst), 20, "every frame came from the accelerator");
+    assert!(a == b && b == c, "the three files differ");
+    let f = effectcraft_media::probe(&yuv_mp4).expect("probe yuv.mp4");
+    assert_eq!((f.width, f.height), (64, 48));
+    assert_eq!(f.frame_rate.frame_at(f.duration - Tick(1)) + 1, 20);
+    let pool = effectcraft_media::MediaPool::new();
+    for k in 0..20 {
+        let img = pool.frame_at(&f, f.frame_rate.tick_of(k)).expect("decode frame");
+        assert_eq!((img.width, img.height), (64, 48));
+    }
+}
+
+#[test]
+fn frames_the_accelerator_cannot_take_fall_back_to_rgba() {
+    let d = out_dir("h264-gpu-yuv-fallback");
+    let (p, cid) = project();
+    let base = RenderSettings { time_span: TimeSpan::LengthOfComp, ..Default::default() };
+    // Renders at 62×47, encodes at 62×46 (the codec size): planes of the render would not fit.
+    let odd = RenderSettings { resolution: 31.0 / 32.0, ..base.clone() };
+    let yuv = Fake::new(true, false, usize::MAX);
+    let a = run(&p, cid, Some(&yuv), &odd, &d.join("yuv.mp4"));
+    let c = run(&p, cid, None, &odd, &d.join("cpu.mp4"));
+    assert_eq!(yuv.yuv_frames.load(Ordering::SeqCst), 0);
+    assert!(a == c);
+}
+
+/// Above 8 bpc the colour is dithered on its way to 8 bits, which the accelerator's planes
+/// don't do: those frames take the RGBA path, so an H.264 export doesn't band (#2022).
+#[test]
+fn renders_above_8_bpc_skip_the_planes() {
+    let d = out_dir("h264-gpu-yuv-16bpc");
+    let (p, cid) = project();
+    let s = RenderSettings { time_span: TimeSpan::LengthOfComp, color_depth: ColorDepth::Bpc16, ..Default::default() };
+    let yuv = Fake::new(true, false, usize::MAX);
+    let a = run(&p, cid, Some(&yuv), &s, &d.join("yuv.mp4"));
+    let c = run(&p, cid, None, &s, &d.join("cpu.mp4"));
+    assert_eq!(yuv.yuv_frames.load(Ordering::SeqCst), 0, "no planes asked for above 8 bpc");
+    assert!(a == c);
+}
+
+/// With deferred readbacks the export keeps rendering frames in passes (`Cx::frames`), never
+/// through the blocking per-frame path the planes use.
+#[test]
+fn deferred_accelerators_keep_the_pass_based_path() {
+    let d = out_dir("h264-gpu-yuv-deferred");
+    let (p, cid) = project();
+    let s = RenderSettings { time_span: TimeSpan::LengthOfComp, ..Default::default() };
+    let deferred = Fake::new(true, true, usize::MAX);
+    let a = run(&p, cid, Some(&deferred), &s, &d.join("deferred.mp4"));
+    let c = run(&p, cid, None, &s, &d.join("cpu.mp4"));
+    assert_eq!(deferred.yuv_frames.load(Ordering::SeqCst), 0, "no planes asked for");
+    assert!(a == c);
+}
+
+/// An accelerator that stops for good mid-export (`available` false): the frames left render
+/// on the CPU side by side, not one at a time under the GPU's frames-in-flight cap (as
+/// `Cx::frames` does), and the file is still the CPU's.
+#[test]
+fn frames_after_the_accelerator_stops_render_on_the_cpu() {
+    let d = out_dir("h264-gpu-yuv-stops");
+    let (p, cid) = project();
+    let s = RenderSettings { time_span: TimeSpan::LengthOfComp, ..Default::default() };
+    let stops = Fake::new(true, false, 1);
+    // Enough threads for frames to overlap wherever the machine runs it.
+    let pool = rayon::ThreadPoolBuilder::new().num_threads(4).build().unwrap();
+    let a = pool.install(|| run(&p, cid, Some(&stops), &s, &d.join("stops.mp4")));
+    let c = run(&p, cid, None, &s, &d.join("cpu.mp4"));
+    assert_eq!(stops.yuv_frames.load(Ordering::SeqCst), 1, "planes only until the stop");
+    assert!(stops.most_after_stop.load(Ordering::SeqCst) > 1, "frames after the stop rendered one at a time");
+    assert!(a == c);
+}
diff --git a/crates/export/tests/it/hevc_av1_roundtrip.rs b/crates/export/tests/it/hevc_av1_roundtrip.rs
index 93a82719a..4022da1ca 100644
--- a/crates/export/tests/it/hevc_av1_roundtrip.rs
+++ b/crates/export/tests/it/hevc_av1_roundtrip.rs
@@ -123,7 +123,15 @@ fn ffprobe_video(path: &Path) -> Option<String> {
         .output()
         .expect("ffprobe");
     assert!(out.status.success() && out.stderr.is_empty(), "ffprobe rejected {}: {}", path.display(), String::from_utf8_lossy(&out.stderr));
-    Some(String::from_utf8_lossy(&out.stdout).trim().to_string())
+    let s = String::from_utf8_lossy(&out.stdout).trim().to_string();
+    // An ffprobe whose build lacks this codec's decoder (distro "free" builds) only parses the
+    // container: pix_fmt and the counted frames come back unknown/N/A, describing the build
+    // rather than our output. Skip the oracle, as when ffprobe is absent.
+    if s.contains("|unknown|") || s.ends_with("|N/A") {
+        eprintln!("ffprobe cannot decode this codec here: skipping the oracle ({s})");
+        return None;
+    }
+    Some(s)
 }
 
 /// Decode every frame with ffmpeg (no errors allowed) and check frames 0, 4, 5 and the last.
@@ -140,7 +148,14 @@ fn ffmpeg_check(path: &Path, decoder: Option<&str>, tol: f32) {
         cmd.args(["-c:v", d]);
     }
     let out = cmd.arg("-i").arg(path).args(["-pix_fmt", "rgba"]).arg(dir.join("f%03d.png")).output().expect("ffmpeg");
-    assert!(out.status.success() && out.stderr.is_empty(), "ffmpeg ({decoder:?}) failed on {}: {}", path.display(), String::from_utf8_lossy(&out.stderr));
+    let err = String::from_utf8_lossy(&out.stderr).to_string();
+    // Same as ffprobe: an ffmpeg without this codec's decoder cannot judge our output, so the
+    // oracle skips instead of failing (the in-repo decode above already proved the frames).
+    if !out.status.success() && err.contains("no decoder found") {
+        eprintln!("ffmpeg cannot decode this codec here: skipping the oracle decode ({err})");
+        return;
+    }
+    assert!(out.status.success() && err.is_empty(), "ffmpeg ({decoder:?}) failed on {}: {}", path.display(), err);
     for k in [0, 4, 5, FRAMES - 1] {
         let img = image::open(dir.join(format!("f{:03}.png", k + 1))).expect("ffmpeg frame").to_rgba8();
         check_frame(&Image::from_rgba8(img.width(), img.height(), img.as_raw()), k, tol);
diff --git a/crates/export/tests/it/main.rs b/crates/export/tests/it/main.rs
index 0f89a641d..a5b9fa99a 100644
--- a/crates/export/tests/it/main.rs
+++ b/crates/export/tests/it/main.rs
@@ -1,14 +1,19 @@
 //! The crate's integration tests, one binary (each module is a former `tests/<name>.rs`).
 
 mod audio_sample_positions;
+mod banding;
+mod h264_gpu_yuv;
 mod hevc_av1_roundtrip;
 #[cfg(not(target_arch = "wasm32"))]
 mod mov_audio_sample_positions;
+mod movie_bytes;
 mod ms_rounded_footage;
 #[cfg(not(target_arch = "wasm32"))]
 mod native_audio_sample_positions;
 mod opus_roundtrip;
+mod prores_color;
 mod render_settings;
 mod roundtrip;
+mod targa_sequence;
 mod uncompressed_mov;
 mod vp9_roundtrip;
diff --git a/crates/export/tests/it/movie_bytes.rs b/crates/export/tests/it/movie_bytes.rs
new file mode 100644
index 000000000..c72ec5427
--- /dev/null
+++ b/crates/export/tests/it/movie_bytes.rs
@@ -0,0 +1,107 @@
+//! Movie exports pinned byte for byte: a comp longer than one render batch, with a rotating
+//! stroked ring (mostly transparent, bilinear), a fading half-transparent solid at a fractional
+//! position and a Screen-mode shape, in 8 bpc. The comp is at most four macroblock rows high,
+//! so the H.264 encoder writes one slice per frame on any number of cores. The hashes are those of the files written before
+//! frames rendered while the previous batch encoded, before transparent source tiles were
+//! skipped and before blended pixels were quantised as they were drawn: those changes must not
+//! move a single byte.
+
+use effectcraft_color::{BlendMode, Label};
+use effectcraft_export::render_queue::{OutputFormat, OutputModule, RenderSettings, TimeSpan};
+use effectcraft_export::{Job, Sink, export};
+use effectcraft_keyframe::{Keyframe, Value};
+use effectcraft_project::build::{self, Ids};
+use effectcraft_project::{Comp, ItemId, ItemKind, LayerSource, Project, Solid};
+use effectcraft_render::NoFootage;
+use effectcraft_time::{FrameRate, Tick};
+
+fn fnv1a(data: &[u8]) -> u64 {
+    data.iter().fold(0xcbf2_9ce4_8422_2325u64, |h, &b| (h ^ b as u64).wrapping_mul(0x100_0000_01b3))
+}
+
+fn project() -> (Project, ItemId) {
+    let mut p = Project::default();
+    let mut comp = Comp::new(160, 64, FrameRate::new(30, 1), Tick::from_seconds_f64(2.0));
+    comp.background = [0.05, 0.1, 0.3];
+    let t = Tick::from_seconds_f64;
+
+    let sid = p.add_item("Half", Label::Red, None, ItemKind::Solid(Solid { color: [0.9, 0.5, 0.1], width: 70, height: 40, pixel_aspect: 1.0 }));
+    let mut solid = build::layer(&mut p, &comp, "Half", LayerSource::Solid { item: sid }, (70, 40), None);
+    if let Some(pr) = solid.props.prop_mut("transform/position") {
+        pr.value = Value::Vec3([60.25, 36.5, 0.0]);
+    }
+    if let Some(pr) = solid.props.prop_mut("transform/opacity") {
+        pr.keys = vec![Keyframe::new(t(0.0), Value::Scalar(20.0)), Keyframe::new(t(2.0), Value::Scalar(70.0))];
+    }
+
+    let mut ring = build::layer(&mut p, &comp, "Ring", LayerSource::Shape, (160, 64), None);
+    let mut box_ = build::layer(&mut p, &comp, "Box", LayerSource::Shape, (160, 64), None);
+    let mut next = p.next_id;
+    {
+        let mut ids = Ids(&mut next);
+        let e = build::shape_ellipse(&mut ids, [56.0, 56.0], [0.0, 0.0]);
+        let s = build::shape_stroke(&mut ids, [0.3, 0.8, 1.0, 1.0], 3.0);
+        let g = build::shape_group(&mut ids, "Ring", vec![e, s]);
+        if let Some(c) = ring.props.sub_mut("contents") {
+            c.children.push(g.into());
+        }
+        let r = build::shape_rect(&mut ids, [30.0, 20.0], [25.0, -10.0], 4.0);
+        let f = build::shape_fill(&mut ids, [0.2, 1.0, 0.4, 0.8]);
+        let g = build::shape_group(&mut ids, "Box", vec![r, f]);
+        if let Some(c) = box_.props.sub_mut("contents") {
+            c.children.push(g.into());
+        }
+    }
+    p.next_id = next;
+    if let Some(pr) = ring.props.prop_mut("transform/rotation") {
+        pr.keys = vec![Keyframe::new(t(0.0), Value::Scalar(0.0)), Keyframe::new(t(2.0), Value::Scalar(130.0))];
+    }
+    if let Some(pr) = box_.props.prop_mut("transform/position") {
+        pr.keys = vec![Keyframe::new(t(0.0), Value::Vec3([70.0, 30.0, 0.0])), Keyframe::new(t(2.0), Value::Vec3([95.5, 38.25, 0.0]))];
+    }
+    box_.blend_mode = BlendMode::Screen;
+
+    comp.layers = vec![box_, ring, solid].into();
+    let cid = p.add_item("Comp 1", Label::Sandstone, None, ItemKind::Comp(comp.into()));
+    (p, cid)
+}
+
+fn export_bytes(format: OutputFormat, name: &str) -> Vec<u8> {
+    let (p, cid) = project();
+    let settings = RenderSettings { time_span: TimeSpan::LengthOfComp, ..Default::default() };
+    let om = OutputModule::for_format(format);
+    let out = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
+    let file = out.clone();
+    let sink: &Sink = &move |_: &str, data: Vec<u8>| *file.lock().unwrap() = data;
+    let job = Job {
+        project: &p,
+        footage: &NoFootage,
+        expr: None,
+        accel: None,
+        comp: cid,
+        settings: &settings,
+        output: &om,
+        path: name,
+        sink: Some(sink),
+        options: Default::default(),
+        nested_switches: true,
+    };
+    let r = export(&job, &mut |_| true).expect("export");
+    assert_eq!(r.frames, 60);
+    std::mem::take(&mut *out.lock().unwrap())
+}
+
+#[test]
+fn h264_movie_bytes_are_pinned() {
+    let data = export_bytes(OutputFormat::H264, "/out/pinned.mp4");
+    // FilmCraft 09aaf9b's encoder lists its settings in the first frame's user-data SEI (211
+    // bytes where 0.1.1's name took 50): 161 bytes more than the FilmCraft 2c5ba7a pin.
+    assert_eq!((data.len(), fnv1a(&data)), (104_341, 17_655_680_090_264_218_914), "H.264 MP4");
+}
+
+#[test]
+fn prores_movie_bytes_are_pinned() {
+    let data = export_bytes(OutputFormat::ProRes, "/out/pinned.mov");
+    // The `nclc` colr atom (#2801) adds exactly 18 bytes; the frames don't move.
+    assert_eq!((data.len(), fnv1a(&data)), (270_112, 2_693_123_490_992_200_481), "ProRes MOV");
+}
diff --git a/crates/export/tests/it/prores_color.rs b/crates/export/tests/it/prores_color.rs
new file mode 100644
index 000000000..89ecea486
--- /dev/null
+++ b/crates/export/tests/it/prores_color.rs
@@ -0,0 +1,118 @@
+//! ProRes `colr` atom (#2801): it describes the frames the render path made, read back with
+//! FilmCraft's demuxer and, when installed, ffprobe as an external oracle.
+
+use std::path::Path;
+use std::process::Command;
+
+use effectcraft_color::Label;
+use effectcraft_export::render_queue::{Channels, OutputFormat, OutputModule, RenderSettings, TimeSpan};
+use effectcraft_export::{Job, export};
+use effectcraft_project::{ColorSpace, Comp, ItemKind, LayerSource, Project, Solid, build};
+use effectcraft_render::NoFootage;
+use effectcraft_time::{FrameRate, Tick};
+use filmcraft_isobmff::{ColorInfo, TrackKind};
+
+struct Row {
+    name: &'static str,
+    working: Option<ColorSpace>,
+    output: Option<ColorSpace>,
+    channels: Channels,
+    /// H.273 primaries, transfer and matrix.
+    codes: [u16; 3],
+    /// The same as ffprobe names them.
+    names: [&'static str; 3],
+}
+
+const SRGB: Option<ColorSpace> = Some(ColorSpace::Srgb);
+const PQ: Option<ColorSpace> = Some(ColorSpace::Rec2100Pq);
+const BT709: [&str; 3] = ["bt709", "bt709", "bt709"];
+
+const ROWS: &[Row] = &[
+    Row { name: "unmanaged", working: None, output: None, channels: Channels::Rgb, codes: [1, 1, 1], names: BT709 },
+    Row { name: "unmanaged_ignores_output", working: None, output: PQ, channels: Channels::Rgb, codes: [1, 1, 1], names: BT709 },
+    Row { name: "srgb_output_stays_1_1_1", working: SRGB, output: None, channels: Channels::Rgb, codes: [1, 1, 1], names: BT709 },
+    Row { name: "rec709", working: SRGB, output: Some(ColorSpace::Rec709), channels: Channels::Rgb, codes: [1, 1, 1], names: BT709 },
+    Row { name: "rec2020", working: SRGB, output: Some(ColorSpace::Rec2020), channels: Channels::Rgb, codes: [9, 1, 1], names: ["bt2020", "bt709", "bt709"] },
+    Row {
+        name: "p3",
+        working: SRGB,
+        output: Some(ColorSpace::DisplayP3),
+        channels: Channels::Rgb,
+        codes: [12, 13, 1],
+        names: ["smpte432", "iec61966-2-1", "bt709"],
+    },
+    Row { name: "pq", working: SRGB, output: PQ, channels: Channels::Rgb, codes: [9, 16, 1], names: ["bt2020", "smpte2084", "bt709"] },
+    Row {
+        name: "hlg",
+        working: SRGB,
+        output: Some(ColorSpace::Rec2100Hlg),
+        channels: Channels::Rgb,
+        codes: [9, 18, 1],
+        names: ["bt2020", "arib-std-b67", "bt709"],
+    },
+    Row { name: "aces", working: SRGB, output: Some(ColorSpace::AcesCg), channels: Channels::Rgb, codes: [2, 8, 1], names: ["unknown", "linear", "bt709"] },
+    Row { name: "pq_with_alpha", working: SRGB, output: PQ, channels: Channels::Rgba, codes: [9, 16, 1], names: ["bt2020", "smpte2084", "bt709"] },
+    Row { name: "alpha_matte", working: SRGB, output: PQ, channels: Channels::Alpha, codes: [1, 1, 1], names: BT709 },
+];
+
+fn render(row: &Row, path: &Path) {
+    let mut p = Project::default();
+    p.settings.working_space = row.working;
+    p.settings.output_space = row.output;
+    let mut comp = Comp::new(64, 48, FrameRate::new(10, 1), Tick::from_seconds_f64(0.2));
+    let sid = p.add_item("Solid", Label::Red, None, ItemKind::Solid(Solid { color: [0.75, 0.25, 0.5], width: 64, height: 48, pixel_aspect: 1.0 }));
+    comp.layers.push(build::layer(&mut p, &comp, "Solid", LayerSource::Solid { item: sid }, (64, 48), None));
+    let comp = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.into()));
+    let settings = RenderSettings { time_span: TimeSpan::LengthOfComp, ..Default::default() };
+    let output = OutputModule { channels: row.channels, ..OutputModule::for_format(OutputFormat::ProRes) };
+    let out = path.to_string_lossy().to_string();
+    let job = Job {
+        project: &p,
+        footage: &NoFootage,
+        expr: None,
+        accel: None,
+        comp,
+        settings: &settings,
+        output: &output,
+        path: &out,
+        sink: None,
+        options: Default::default(),
+        nested_switches: true,
+    };
+    export(&job, &mut |_| true).expect("export");
+}
+
+/// ffprobe's primaries, transfer and matrix for the stream, or `None` without ffprobe.
+fn ffprobe_tags(path: &Path) -> Option<Vec<String>> {
+    let out = Command::new("ffprobe")
+        .args(["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=color_primaries,color_transfer,color_space", "-of", "default=nw=1"])
+        .arg(path)
+        .output()
+        .ok()?;
+    assert!(out.status.success(), "ffprobe rejected {}: {}", path.display(), String::from_utf8_lossy(&out.stderr));
+    let text = String::from_utf8_lossy(&out.stdout).to_string();
+    let tag = |key: &str| text.lines().find_map(|l| l.strip_prefix(key)?.strip_prefix('=')).unwrap_or("").to_string();
+    Some(vec![tag("color_primaries"), tag("color_transfer"), tag("color_space")])
+}
+
+#[test]
+fn prores_colr_describes_the_frames() {
+    let dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/export/prores_color");
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).expect("mkdir");
+    for row in ROWS {
+        let path = dir.join(format!("{}.mov", row.name));
+        render(row, &path);
+
+        let bytes = std::fs::read(&path).expect("read movie");
+        let mov = filmcraft_isobmff::open(bytes.as_slice()).expect("demux");
+        let track = mov.tracks.iter().find(|t| t.kind == TrackKind::Video).expect("video track");
+        let [primaries, transfer, matrix] = row.codes;
+        let colr = track.entries[0].video.as_ref().and_then(|v| v.color.clone());
+        assert_eq!(colr, Some(ColorInfo::Nclc { primaries, transfer, matrix }), "{}: colr", row.name);
+
+        if let Some(stream) = ffprobe_tags(&path) {
+            assert_eq!(stream, row.names, "{}: ffprobe stream tags", row.name);
+        }
+    }
+}
diff --git a/crates/export/tests/it/render_settings.rs b/crates/export/tests/it/render_settings.rs
index 9e9a0a18f..0fd6d471b 100644
--- a/crates/export/tests/it/render_settings.rs
+++ b/crates/export/tests/it/render_settings.rs
@@ -45,7 +45,7 @@ fn custom(start: f64, end: f64) -> RenderSettings {
 }
 
 fn run_with(p: &Project, cid: ItemId, s: &RenderSettings, om: &OutputModule, path: &str, options: JobOptions, cancel: bool) -> (Result<Report, String>, Files) {
-    run_on(p, cid, s, om, path, options, None, cancel)
+    run_on(p, cid, s, om, path, options, (None, cancel))
 }
 
 /// [`run_with`] with an accelerator.
@@ -56,9 +56,9 @@ fn run_on(
     om: &OutputModule,
     path: &str,
     options: JobOptions,
-    accel: Option<&dyn Accelerator>,
-    cancel: bool,
+    execution: (Option<&dyn Accelerator>, bool),
 ) -> (Result<Report, String>, Files) {
+    let (accel, cancel) = execution;
     let files: Files = Default::default();
     let f = files.clone();
     let sink: Box<Sink> = Box::new(move |path: &str, data: Vec<u8>| f.lock().unwrap().push((path.to_string(), data)));
@@ -174,6 +174,31 @@ fn crop_roi_and_resize() {
     assert_eq!((z.width(), z.height()), (32, 24));
 }
 
+/// Resizing to the cropped frame's own dimensions must preserve every decoded PNG pixel.
+/// Compare against crop-only output for padding and scaled ROIs with both resize qualities.
+#[test]
+fn crop_resize_preserves_pixels_when_the_cropped_size_is_requested() {
+    let (p, cid) = project(FrameRate::new(25, 1), |_, _| {});
+    for (crop, scale, expected) in [
+        (Crop { enabled: true, left: 16, right: 16, ..Default::default() }, 1.0, (32, 48)),
+        (Crop { enabled: true, left: -4, top: -2, ..Default::default() }, 1.0, (68, 50)),
+        (Crop { enabled: true, use_roi: true, roi: Some([0.0, 24.0, 32.0, 24.0]), ..Default::default() }, 0.5, (16, 12)),
+        (Crop { enabled: true, use_roi: true, roi: Some([0.0, 24.0, 32.0, 24.0]), ..Default::default() }, 2.0, (64, 48)),
+    ] {
+        let settings = RenderSettings { resolution: scale, ..custom(0.4, 0.44) };
+        let mut output = OutputModule { crop, ..OutputModule::for_format(OutputFormat::PngSequence) };
+        let reference = png(&run(&p, cid, &settings, &output, "/c/reference_[#####].png"), 0);
+        assert_eq!(reference.dimensions(), expected);
+        assert!(reference.pixels().any(|p| p.0[0] > 150), "the reference contains visible content");
+        for quality in [ResizeQuality::Low, ResizeQuality::High] {
+            output.resize = Resize { enabled: true, width: expected.0, height: 1, lock_aspect: true, quality };
+            let actual = png(&run(&p, cid, &settings, &output, "/c/resized_[#####].png"), 0);
+            assert_eq!(actual.dimensions(), expected);
+            assert!(actual == reference, "crop {crop:?}, scale {scale}, quality {quality:?}: pixels changed");
+        }
+    }
+}
+
 #[test]
 fn alpha_only_and_premultiplied() {
     let (p, cid) = project(FrameRate::new(25, 1), |p, comp| {
@@ -456,7 +481,7 @@ fn a_job_renders_on_one_compositor() {
     let om = OutputModule::for_format(OutputFormat::PngSequence);
     let s = custom(0.0, 0.4);
     let render = |p: &Project, accel: &GreenAccel, path: &str| {
-        let (r, files) = run_on(p, cid, &s, &om, path, JobOptions::default(), Some(accel), false);
+        let (r, files) = run_on(p, cid, &s, &om, path, JobOptions::default(), (Some(accel), false));
         r.expect("export");
         (0..10).map(|i| png(&files, i)).collect::<Vec<_>>()
     };
diff --git a/crates/export/tests/it/roundtrip.rs b/crates/export/tests/it/roundtrip.rs
index 0fc747018..477191f64 100644
--- a/crates/export/tests/it/roundtrip.rs
+++ b/crates/export/tests/it/roundtrip.rs
@@ -23,6 +23,24 @@ const H: u32 = 48;
 const BG: [f32; 3] = [0.1, 0.1, 0.4];
 const FRAMES: u64 = 12;
 
+/// An H.264 encoder this ffmpeg build actually ships, or `None` when it has none. Distro "free"
+/// builds often omit `libx264` but ship an alternative (e.g. libopenh264), so pick the first
+/// present by name rather than hard-coding one that may be absent. The oracle only needs *an*
+/// H.264 encoder; the encoder identity is irrelevant to the assertion.
+fn h264_encoder() -> Option<&'static str> {
+    static ENC: std::sync::OnceLock<Option<&'static str>> = std::sync::OnceLock::new();
+    *ENC.get_or_init(|| {
+        let out = Command::new("ffmpeg").args(["-hide_banner", "-encoders"]).output().ok()?;
+        if !out.status.success() {
+            return None;
+        }
+        let text = String::from_utf8_lossy(&out.stdout);
+        ["libx264", "libopenh264", "h264_nvenc", "h264_vaapi", "h264_qsv", "h264_v4l2m2m", "h264_amf"]
+            .into_iter()
+            .find(|name| text.lines().any(|l| l.split_whitespace().any(|tok| tok == *name)))
+    })
+}
+
 fn out_dir(name: &str) -> PathBuf {
     let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/export").join(name);
     let _ = std::fs::remove_dir_all(&d);
@@ -260,6 +278,8 @@ fn image_sequences_roundtrip() {
         (OutputFormat::JpegSequence, "jpg", 0.06, Channels::Rgb),
         (OutputFormat::TiffSequence, "tif", 0.01, Channels::Rgb),
         (OutputFormat::TiffSequence, "tif", 0.01, Channels::Rgba),
+        (OutputFormat::TargaSequence, "tga", 0.01, Channels::Rgb),
+        (OutputFormat::TargaSequence, "tga", 0.01, Channels::Rgba),
     ] {
         let d = out_dir(&format!("seq-{ext}-{ch:?}"));
         let om = OutputModule { channels: ch, ..OutputModule::for_format(fmt) };
@@ -489,14 +509,18 @@ fn ffmpeg_audio(src: &Path) -> Vec<f32> {
 fn movies_carry_resampled_footage_audio() {
     let d = out_dir("audio-44k");
     let clip = d.join("clip.mp4");
+    let Some(enc) = h264_encoder() else {
+        eprintln!("ffmpeg has no H.264 encoder: skipping");
+        return;
+    };
     let made = Command::new("ffmpeg")
         .args(["-hide_banner", "-loglevel", "error", "-y", "-f", "lavfi", "-i", "testsrc2=size=64x48:rate=30000/1001:duration=3", "-f", "lavfi", "-i"])
-        .args(["aevalsrc=0.5*sin(2*PI*440*t)|0.5*sin(2*PI*(200+400*t/3)*t):s=44100:d=3", "-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac", "-shortest"])
+        .args(["aevalsrc=0.5*sin(2*PI*440*t)|0.5*sin(2*PI*(200+400*t/3)*t):s=44100:d=3", "-c:v", enc, "-pix_fmt", "yuv420p", "-c:a", "aac", "-shortest"])
         .arg(&clip)
         .status()
         .is_ok_and(|s| s.success());
     if !made {
-        eprintln!("ffmpeg not found: skipping");
+        eprintln!("ffmpeg could not make the H.264 fixture: skipping");
         return;
     }
     let fps = FrameRate::new(30000, 1001);
diff --git a/crates/export/tests/it/targa_sequence.rs b/crates/export/tests/it/targa_sequence.rs
new file mode 100644
index 000000000..b496163d2
--- /dev/null
+++ b/crates/export/tests/it/targa_sequence.rs
@@ -0,0 +1,218 @@
+//! Targa sequence output: every file is an uncompressed TGA (Truevision TGA 2.0 specification:
+//! an 18-byte header, BGR(A) pixels, top-left origin, the alpha bits in the image descriptor)
+//! holding exactly the pixels the lossless PNG sequence of the same job writes, and EffectCraft's
+//! own Targa import (#745) reads the frames back as the same picture.
+//!
+//! The comp is 7×4 @ 10 fps, 3 frames: frame 0 is the background alone, frames 1 and 2 add a
+//! 2×2 solid in the top two rows (so a flipped picture shows), on a half pixel horizontally, so
+//! its left and right columns carry partial alpha.
+
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use effectcraft_color::Label;
+use effectcraft_export::render_queue::{AlphaMode, Channels, OutputFormat, OutputModule, RenderSettings, TimeSpan, sequence_path};
+use effectcraft_export::{Job, export};
+use effectcraft_keyframe::Value;
+use effectcraft_media::MediaPool;
+use effectcraft_project::{Comp, Footage, FootageKind, ItemId, ItemKind, LayerSource, Project, Solid, build};
+use effectcraft_render::NoFootage;
+use effectcraft_time::{FrameRate, Tick};
+
+const W: u32 = 7;
+const H: u32 = 4;
+const FRAMES: u64 = 3;
+
+fn out_dir(name: &str) -> PathBuf {
+    let d = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/export").join(name);
+    let _ = std::fs::remove_dir_all(&d);
+    std::fs::create_dir_all(&d).expect("mkdir");
+    d
+}
+
+fn project() -> (Project, ItemId) {
+    let mut p = Project::default();
+    let mut comp = Comp::new(W, H, FrameRate::new(10, 1), Tick::from_seconds_f64(FRAMES as f64 / 10.0));
+    comp.background = [0.1, 0.3, 0.6];
+    let sid = p.add_item("Red", Label::Red, None, ItemKind::Solid(Solid { color: [0.9, 0.2, 0.1], width: 2, height: 2, pixel_aspect: 1.0 }));
+    let mut l = build::layer(&mut p, &comp, "Red", LayerSource::Solid { item: sid }, (2, 2), None);
+    l.props.prop_mut("transform/position").expect("position").value = Value::Vec3([3.5, 1.0, 0.0]);
+    l.in_point = comp.frame_rate.tick_of(1);
+    comp.layers.push(l);
+    let cid = p.add_item("Comp 1", Label::Sandstone, None, ItemKind::Comp(comp.into()));
+    (p, cid)
+}
+
+/// Render the comp through `om` to `dir/f_[#####].<ext>`; the first frame's path.
+fn render(p: &Project, cid: ItemId, om: &OutputModule, dir: &Path) -> String {
+    let s = RenderSettings { time_span: TimeSpan::LengthOfComp, ..Default::default() };
+    let path = dir.join(format!("f_[#####].{}", om.format.extension())).to_string_lossy().to_string();
+    let job = Job {
+        project: p,
+        footage: &NoFootage,
+        expr: None,
+        accel: None,
+        comp: cid,
+        settings: &s,
+        output: om,
+        path: &path,
+        sink: None,
+        options: Default::default(),
+        nested_switches: true,
+    };
+    let r = export(&job, &mut |_| true).expect("export");
+    assert_eq!((r.frames, r.width, r.height), (FRAMES, W, H));
+    r.path
+}
+
+/// The numbered files of a render of `ext`: frames 0..FRAMES and nothing after.
+fn frame_paths(dir: &Path, ext: &str) -> Vec<String> {
+    let template = dir.join(format!("f_[#####].{ext}")).to_string_lossy().to_string();
+    assert!(!Path::new(&sequence_path(&template, FRAMES as i64)).exists(), "no frame after the last");
+    (0..FRAMES as i64).map(|k| sequence_path(&template, k)).collect()
+}
+
+/// A Targa file's header fields and its pixels as top-down RGBA bytes.
+struct Tga {
+    image_type: u8,
+    width: u16,
+    height: u16,
+    depth: u8,
+    descriptor: u8,
+    rgba: Vec<u8>,
+}
+
+fn read_tga(path: &str) -> Tga {
+    let b = std::fs::read(path).unwrap_or_else(|e| panic!("{path}: {e}"));
+    let u16_at = |i: usize| u16::from_le_bytes([b[i], b[i + 1]]);
+    assert_eq!((b[0], b[1]), (0, 0), "{path}: no image ID, no colour map");
+    assert_eq!((u16_at(8), u16_at(10)), (0, 0), "{path}: X / Y origin");
+    let (width, height, depth, descriptor) = (u16_at(12), u16_at(14), b[16], b[17]);
+    let bpp = usize::from(depth / 8);
+    // Uncompressed, without an image ID, colour map or 2.0 footer: header and pixels only.
+    assert_eq!(b.len(), 18 + usize::from(width) * usize::from(height) * bpp, "{path}: file size");
+    let rgba = b[18..]
+        .chunks(bpp)
+        .flat_map(|p| match p {
+            [b, g, r, a] => [*r, *g, *b, *a],
+            [b, g, r] => [*r, *g, *b, 255],
+            [v] => [*v, *v, *v, 255],
+            _ => panic!("{path}: {depth}-bit pixels"),
+        })
+        .collect();
+    Tga { image_type: b[2], width, height, depth, descriptor, rgba }
+}
+
+fn png_rgba(path: &str) -> Vec<u8> {
+    image::open(path).unwrap_or_else(|e| panic!("{path}: {e}")).to_rgba8().into_raw()
+}
+
+#[test]
+fn targa_sequence_writes_the_png_sequence_pixels() {
+    let (p, cid) = project();
+    for (channels, alpha_mode, image_type, depth, descriptor) in [
+        (Channels::Rgb, AlphaMode::Straight, 2, 24, 0x20),
+        (Channels::Rgba, AlphaMode::Straight, 2, 32, 0x28),
+        (Channels::Rgba, AlphaMode::Premultiplied, 2, 32, 0x28),
+        (Channels::Alpha, AlphaMode::Straight, 3, 8, 0x20),
+    ] {
+        let name = format!("tga-{channels:?}-{alpha_mode:?}");
+        let tga_dir = out_dir(&name);
+        let png_dir = out_dir(&format!("{name}-png"));
+        let om = OutputModule { channels, alpha_mode, ..OutputModule::for_format(OutputFormat::TargaSequence) };
+        let first = render(&p, cid, &om, &tga_dir);
+        assert!(first.ends_with("f_00000.tga"), "{first}");
+        render(&p, cid, &OutputModule { format: OutputFormat::PngSequence, ..om.clone() }, &png_dir);
+        let mut frames = Vec::new();
+        for (tga, png) in frame_paths(&tga_dir, "tga").iter().zip(frame_paths(&png_dir, "png")) {
+            let t = read_tga(tga);
+            assert_eq!((t.image_type, t.width, t.height, t.depth, t.descriptor), (image_type, W as u16, H as u16, depth, descriptor), "{tga}");
+            assert_eq!(t.rgba, png_rgba(&png), "{tga} matches {png}");
+            frames.push(t.rgba);
+        }
+        // Frame 0 is background only; frames 1 and 2 hold the solid, so the numbering follows
+        // the comp's frames.
+        let at = |f: &[u8], x: u32, y: u32| -> [u8; 4] {
+            let i = ((y * W + x) * 4) as usize;
+            [f[i], f[i + 1], f[i + 2], f[i + 3]]
+        };
+        assert_ne!(at(&frames[0], 3, 1), at(&frames[1], 3, 1), "{name}");
+        assert_eq!(frames[1], frames[2], "{name}");
+        // Top-down rows: the solid is in the top half, the bottom rows are still background.
+        assert_eq!(at(&frames[1], 3, 3), at(&frames[0], 3, 3), "{name}: bottom row");
+        match channels {
+            Channels::Rgb => {
+                assert_eq!(at(&frames[0], 0, 0)[3], 255);
+                assert_eq!(at(&frames[1], 3, 1), [230, 51, 26, 255], "{name}: the opaque solid");
+            }
+            Channels::Rgba => {
+                assert_eq!(at(&frames[0], 0, 0), [0, 0, 0, 0], "{name}: transparent background");
+                assert_eq!(at(&frames[1], 3, 1), [230, 51, 26, 255], "{name}: the opaque solid");
+                let edge = at(&frames[1], 2, 1);
+                assert!(edge[3] > 0 && edge[3] < 255, "{name}: partial alpha at the solid's edge {edge:?}");
+                if alpha_mode == AlphaMode::Straight {
+                    // Unmatted from the renderer's premultiplied pixel: the solid's colour, within rounding.
+                    assert!(edge[..3].iter().zip([230u8, 51, 26]).all(|(a, b)| a.abs_diff(b) <= 1), "{name}: straight colour {edge:?}");
+                } else {
+                    assert!(edge[0] < 230 && edge[0] <= edge[3], "{name}: premultiplied colour {edge:?}");
+                }
+            }
+            Channels::Alpha => {
+                assert_eq!(at(&frames[0], 0, 0), [0, 0, 0, 255], "{name}: no matte yet");
+                assert_eq!(at(&frames[1], 3, 1), [255, 255, 255, 255], "{name}: the solid's matte");
+            }
+        }
+    }
+}
+
+/// Numbered stills read back as an image sequence through the media layer (Targa: #745).
+fn import_sequence(paths: &[String]) -> (Footage, MediaPool) {
+    let pool = MediaPool::new();
+    pool.set_read_ahead(false);
+    let first = effectcraft_media::probe(&paths[0]).expect("probe our output");
+    assert_eq!((first.kind, first.width, first.height), (FootageKind::Still, W, H));
+    for p in paths {
+        let bytes: Arc<[u8]> = std::fs::read(p).expect("read").into();
+        pool.add_bytes(p, bytes);
+    }
+    let mut footage = Footage { kind: FootageKind::Sequence, sequence: paths.to_vec(), ..first };
+    footage.sync_sequence_duration();
+    (footage, pool)
+}
+
+#[test]
+fn targa_sequence_round_trips_through_targa_import() {
+    let (p, cid) = project();
+    for alpha_mode in [AlphaMode::Straight, AlphaMode::Premultiplied] {
+        let name = format!("tga-import-{alpha_mode:?}");
+        let tga_dir = out_dir(&name);
+        let png_dir = out_dir(&format!("{name}-png"));
+        let om = OutputModule { channels: Channels::Rgba, alpha_mode, ..OutputModule::for_format(OutputFormat::TargaSequence) };
+        render(&p, cid, &om, &tga_dir);
+        // The reference: the same job as a straight-alpha PNG sequence (PNG's alpha is labelled).
+        render(&p, cid, &OutputModule { format: OutputFormat::PngSequence, alpha_mode: AlphaMode::Straight, ..om.clone() }, &png_dir);
+        let (mut tga, tga_pool) = import_sequence(&frame_paths(&tga_dir, "tga"));
+        let (png, png_pool) = import_sequence(&frame_paths(&png_dir, "png"));
+        assert_eq!(tga.codec, "TGA");
+        assert_eq!(tga.sequence_frames(), FRAMES as i64);
+        // Targa doesn't label its alpha: import guesses straight, and Interpret Footage sets
+        // premultiplied for a premultiplied render.
+        assert_eq!(tga.alpha, effectcraft_project::AlphaMode::Straight);
+        if alpha_mode == AlphaMode::Premultiplied {
+            tga.alpha = effectcraft_project::AlphaMode::Premultiplied;
+        }
+        // Premultiplying to 8 bits rounds partially transparent colour.
+        let tol = if alpha_mode == AlphaMode::Straight { 0.0 } else { 1.0 / 255.0 };
+        for k in 0..FRAMES as i64 {
+            let a = tga_pool.frame_at(&tga, tga.frame_rate.tick_of(k)).expect("decode Targa");
+            let b = png_pool.frame_at(&png, png.frame_rate.tick_of(k)).expect("decode PNG");
+            assert_eq!((a.width, a.height), (W, H));
+            for (x, y) in a.data.iter().zip(&b.data) {
+                assert!(x.iter().zip(y).all(|(x, y)| (x - y).abs() <= tol), "{name} frame {k}: {x:?} != {y:?}");
+            }
+        }
+        let opaque = tga_pool.frame_at(&tga, tga.frame_rate.tick_of(1)).expect("decode");
+        assert_eq!(opaque.data[opaque.idx(0, 0)][3], 0.0, "{name}: the background stays transparent");
+        assert_eq!(opaque.data[opaque.idx(3, 1)][3], 1.0, "{name}: the solid is opaque");
+    }
+}
diff --git a/crates/export/tests/it/vp9_roundtrip.rs b/crates/export/tests/it/vp9_roundtrip.rs
index e7c2b0346..1432e3892 100644
--- a/crates/export/tests/it/vp9_roundtrip.rs
+++ b/crates/export/tests/it/vp9_roundtrip.rs
@@ -41,7 +41,7 @@ fn source(w: usize, h: usize, kind: u32) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
 }
 
 fn decode(frame: &[u8]) -> filmcraft_vp9::Picture {
-    let mut d = Decoder::new();
+    let mut d = Decoder::with_threads(1);
     let mut pics = d.decode(frame, 0).expect("decode");
     assert_eq!(pics.len(), 1);
     pics.remove(0)
@@ -189,7 +189,7 @@ fn planes_of(p: &filmcraft_vp9::Picture, w: usize, h: usize) -> [Vec<u8>; 3] {
 fn run_sequence(cfg: EncoderConfig, n: usize, kind: u32) -> (usize, f64) {
     let (w, h) = (cfg.width as usize, cfg.height as usize);
     let mut e = Vp9Encoder::new(cfg);
-    let mut d = Decoder::new();
+    let mut d = Decoder::with_threads(1);
     let (mut bytes, mut db) = (0usize, 0.0);
     for t in 0..n {
         let (y, u, v) = moving(w, h, t, kind);
@@ -344,7 +344,7 @@ fn frames_never_end_in_a_superframe_marker() {
     }
     let Some((w, h, q, frames, recon)) = padded else { panic!("no frame needed the padding: widen the search") };
     // The padded frames decode exactly, with FilmCraft's decoder and with ffmpeg.
-    let mut d = Decoder::new();
+    let mut d = Decoder::with_threads(1);
     for (t, (f, r)) in frames.iter().zip(&recon).enumerate() {
         let mut pics = d.decode(f, t as i64).unwrap_or_else(|e| panic!("{w}x{h} q{q} frame {t}: {e:?}"));
         assert_eq!(planes_of(&pics.remove(0), w, h), *r, "{w}x{h} q{q} frame {t}");
diff --git a/crates/expr/src/host.rs b/crates/expr/src/host.rs
index f98b895a5..fa2993f97 100644
--- a/crates/expr/src/host.rs
+++ b/crates/expr/src/host.rs
@@ -10,7 +10,7 @@
 use effectcraft_geom::{Mat3, Mat4};
 use effectcraft_keyframe::Value;
 use effectcraft_project::{Comp, ItemId, ItemKind, Layer, LayerId, LayerSource, Node, PropGroup, Property};
-use effectcraft_render::{EvalCtx, source_size};
+use effectcraft_render::EvalCtx;
 use effectcraft_time::Tick;
 
 /// A name-or-index argument (`layer("A")`, `layer(2)`, `effect(1)`).
@@ -299,7 +299,17 @@ impl<'a> Resolver<'a> {
     }
     fn ctx_at(&self, c: u64, t: f64) -> Option<EvalCtx<'a>> {
         let comp = self.comp(c)?;
-        Some(EvalCtx { project: self.ctx.project, comp_id: ItemId(c), comp, time: Tick::from_seconds_f64(t), expr: self.ctx.expr, footage: self.ctx.footage })
+        let same_comp = c == self.ctx.comp_id.0;
+        Some(EvalCtx {
+            project: self.ctx.project,
+            comp_id: ItemId(c),
+            comp,
+            time: Tick::from_seconds_f64(t),
+            expr: self.ctx.expr,
+            footage: self.ctx.footage,
+            property_overrides: if same_comp { self.ctx.property_overrides } else { &[] },
+            media_overrides: if same_comp { self.ctx.media_overrides } else { &[] },
+        })
     }
     fn prop(&self, c: u64, l: u64, path: &str) -> Option<(&'a Layer, &'a Property)> {
         let layer = self.layer(c, l)?;
@@ -313,6 +323,32 @@ impl<'a> Resolver<'a> {
         self.try_resolve(req).unwrap_or(Resp::Null)
     }
 
+    /// Resolve an ancestor from its UID path while preserving child indexing.
+    fn ancestor(&self, comp: u64, layer: u64, path: &str, up: i64) -> Option<Resp> {
+        let l = self.layer(comp, layer)?;
+        // The node's full `@uid/@uid/…` path from the layer: its ancestors are its prefixes.
+        let uid = match self.prop(comp, layer, path) {
+            Some((_, p)) => p.uid,
+            None => l.props.node(path)?.uid(),
+        };
+        let full = l.props.path_of(uid)?;
+        let segs: Vec<&str> = full.split('/').collect();
+        let up = usize::try_from(up).ok().filter(|u| *u >= 1 && *u <= segs.len())?;
+        if up == segs.len() {
+            return Some(Resp::Str("layer".into()));
+        }
+        let keep = segs.len() - up;
+        let group_path = segs.get(..keep)?.join("/");
+        let parent = match keep {
+            1 => &l.props,
+            _ => l.props.group(&segs.get(..keep - 1)?.join("/"))?,
+        };
+        let uid = segs.get(keep - 1)?.strip_prefix('@')?.parse::<u64>().ok()?;
+        let index = parent.children.iter().position(|c| c.uid() == uid)?;
+        let n = parent.children.get(index)?;
+        Some(node_resp(group_path, n, index + 1))
+    }
+
     fn try_resolve(&self, req: &Req) -> Option<Resp> {
         let project = self.ctx.project;
         Some(match req {
@@ -346,7 +382,7 @@ impl<'a> Resolver<'a> {
             Req::LayerInfo { comp, layer } => {
                 let c = self.comp(*comp)?;
                 let l = self.layer(*comp, *layer)?;
-                let (mut w, mut h) = source_size(project, l);
+                let (mut w, mut h) = self.ctx_at(*comp, self.ctx.time.seconds())?.source_size(l);
                 if w == 0 || h == 0 {
                     (w, h) = (c.width, c.height);
                 }
@@ -373,30 +409,7 @@ impl<'a> Resolver<'a> {
                 let path = if group.is_empty() { format!("@{}", n.uid()) } else { format!("{group}/@{}", n.uid()) };
                 node_resp(path, n, index)
             }
-            Req::Ancestor { comp, layer, path, up } => {
-                let l = self.layer(*comp, *layer)?;
-                // The node's full `@uid/@uid/…` path from the layer: its ancestors are its prefixes.
-                let uid = match self.prop(*comp, *layer, path) {
-                    Some((_, p)) => p.uid,
-                    None => l.props.node(path)?.uid(),
-                };
-                let full = l.props.path_of(uid)?;
-                let segs: Vec<&str> = full.split('/').collect();
-                let up = usize::try_from(*up).ok().filter(|u| *u >= 1 && *u <= segs.len())?;
-                if up == segs.len() {
-                    return Some(Resp::Str("layer".into()));
-                }
-                let keep = segs.len() - up;
-                let group_path = segs.get(..keep)?.join("/");
-                let parent = match keep {
-                    1 => &l.props,
-                    _ => l.props.group(&segs.get(..keep - 1)?.join("/"))?,
-                };
-                let uid = segs.get(keep - 1)?.strip_prefix('@')?.parse::<u64>().ok()?;
-                let index = parent.children.iter().position(|c| c.uid() == uid)?;
-                let n = parent.children.get(index)?;
-                node_resp(group_path, n, index + 1)
-            }
+            Req::Ancestor { comp, layer, path, up } => return self.ancestor(*comp, *layer, path, *up),
             Req::PropInfo { comp, layer, path } => {
                 let (l, p) = self.prop(*comp, *layer, path)?;
                 let dims = prop_dims(l, p);
@@ -464,7 +477,7 @@ impl<'a> Resolver<'a> {
                         }
                     }
                     _ => {
-                        let (w, h) = source_size(project, l);
+                        let (w, h) = ctx.source_size(l);
                         [0.0, 0.0, w as f64, h as f64]
                     }
                 };
@@ -498,7 +511,12 @@ impl<'a> Resolver<'a> {
             Req::SourceInfo { comp, layer } => {
                 let c = self.comp(*comp)?;
                 let l = self.layer(*comp, *layer)?;
-                let it = project.item(l.source.item()?)?;
+                let ctx = self.ctx_at(*comp, self.ctx.time.seconds())?;
+                let item = match &l.source {
+                    LayerSource::Footage { item } => ctx.media_item(l, *item),
+                    _ => l.source.item()?,
+                };
+                let it = project.item(item)?;
                 let (kind, aspect, frame, duration) = match &it.kind {
                     ItemKind::Comp(nc) => ("comp", nc.pixel_aspect, nc.frame_duration().seconds(), nc.duration.seconds()),
                     ItemKind::Footage(f) => ("footage", f.pixel_aspect, f.frame_rate.frame_duration().seconds(), f.duration.seconds()),
diff --git a/crates/expr/src/lib.rs b/crates/expr/src/lib.rs
index 4963810c4..9e78d250f 100644
--- a/crates/expr/src/lib.rs
+++ b/crates/expr/src/lib.rs
@@ -17,7 +17,8 @@
 //!   `sourceRectAtTime`), property methods (`valueAtTime`, `velocityAtTime`, `speedAtTime`, `key`,
 //!   `nearestKey`, `numKeys`, `wiggle`, `temporalWiggle`, `smooth`, `loopIn/Out[Duration]`) and the
 //!   global helpers (`linear`/`ease`/`easeIn`/`easeOut`, `random`/`gaussRandom`/`seedRandom`/
-//!   `noise`, vector maths, `clamp`, `lookAt`, time and colour conversions, `posterizeTime`).
+//!   `noise`, vector maths, `clamp`, `lookAt`, time and colour conversions, `posterizeTime`),
+//!   plus `bezier`, a CSS-style cubic-Bezier easing helper that After Effects does not have.
 //! * **Determinism**: `wiggle` and `random` are seeded by layer index, property uid (and time /
 //!   `seedRandom`), so frames render identically on every thread and platform.
 //! * **Runtime**: one boa `Context` per thread with compiled scripts cached by text. Scripts read
@@ -93,7 +94,7 @@ impl ExprHost for Expressions {
             return Ok([v.first().copied().unwrap_or(100.0), v.get(1).copied().unwrap_or(100.0), v.get(2).copied().unwrap_or(100.0)]);
         };
         let value = prop.value_at(layer.layer_time(ctx.time));
-        let out = evaluate_out(self, ctx, layer, prop, &value, &e.text, [index as f64 + 1.0, total as f64], selector)?;
+        let out = evaluate_out(self, ctx, layer, prop, &value, &e.text, TextSelector { index_total: [index as f64 + 1.0, total as f64], value: selector })?;
         let num = |o: &runtime::Out| match o {
             runtime::Out::Num(x) => Some(*x),
             runtime::Out::Bool(b) => Some(if *b { 100.0 } else { 0.0 }),
@@ -124,13 +125,17 @@ impl Drop for FrameGuard {
 /// Evaluate `text` as the expression of `prop` on `layer` at `ctx.time`, given its keyframed
 /// `value`. Other properties' expressions are evaluated through `host`.
 pub fn evaluate(host: &dyn ExprHost, ctx: &EvalCtx, layer: &Layer, prop: &Property, value: &Value, text: &str) -> Result<Value, String> {
-    let out = evaluate_out(host, ctx, layer, prop, value, text, [1.0, 1.0], [100.0; 3])?;
+    let out = evaluate_out(host, ctx, layer, prop, value, text, TextSelector { index_total: [1.0, 1.0], value: [100.0; 3] })?;
     runtime::to_value(&out, value)
 }
 
-/// Run an expression and return the raw script result. `text_sel` / `selector` are the text
-/// Expression Selector's `[textIndex, textTotal]` and `selectorValue`.
-#[allow(clippy::too_many_arguments)]
+/// Expression Selector state: `[textIndex, textTotal]` and `selectorValue`.
+struct TextSelector {
+    index_total: [f64; 2],
+    value: [f64; 3],
+}
+
+/// Run an expression and return the raw script result.
 fn evaluate_out(
     host: &dyn ExprHost,
     ctx: &EvalCtx,
@@ -138,9 +143,9 @@ fn evaluate_out(
     prop: &Property,
     value: &Value,
     text: &str,
-    text_sel: [f64; 2],
-    selector: [f64; 3],
+    text_selector: TextSelector,
 ) -> Result<runtime::Out, String> {
+    let TextSelector { index_total: text_sel, value: selector } = text_selector;
     let owner = Owner { comp: ctx.comp_id.0, layer: layer.id.0, uid: prop.uid, time: ctx.time, text: text.to_string() };
     let (depth, cycle) = FRAMES.with(|f| {
         let f = f.borrow();
@@ -158,7 +163,16 @@ fn evaluate_out(
         return Err("Error: expressions reference each other too deeply (circular reference?)".into());
     }
     budget_left()?;
-    let ctx = EvalCtx { project: ctx.project, comp_id: ctx.comp_id, comp: ctx.comp, time: ctx.time, expr: Some(host), footage: ctx.footage };
+    let ctx = EvalCtx {
+        project: ctx.project,
+        comp_id: ctx.comp_id,
+        comp: ctx.comp,
+        time: ctx.time,
+        expr: Some(host),
+        footage: ctx.footage,
+        property_overrides: ctx.property_overrides,
+        media_overrides: ctx.media_overrides,
+    };
     let comp = ctx.comp_id.0;
     let path = layer.props.path_of(prop.uid).unwrap_or_else(|| format!("@{}", prop.uid));
     let resolver = Resolver { ctx, own: Own { comp, layer, prop, path: path.clone() } };
diff --git a/crates/expr/src/prelude.js b/crates/expr/src/prelude.js
index df6ed3ff4..c6fcbab03 100644
--- a/crates/expr/src/prelude.js
+++ b/crates/expr/src/prelude.js
@@ -31,6 +31,7 @@ function __begin(t, v, c, l, path, uid, idx, fd, ti, tt, sv) {
   __seed = 0;
   __timeless = false;
   __projectInfo = null;
+  __layersTrim();
 }
 
 function __finish(r) {
@@ -44,7 +45,7 @@ function __finish(r) {
 
 function __result(r) {
   r = __v(r);
-  if (r !== null && typeof r === 'object' && r.__isLayer) return r.index;
+  if (typeof r === 'function' && r.__isLayer) return r.index;
   if (r !== null && typeof r === 'object' && r.__isTextStyle) return r.__out();
   // `[temp, temp]` where temp is a property (pick-whip 1D → 2D): read the values here, while
   // host requests can still be answered and the script re-run.
@@ -207,6 +208,60 @@ function ease() { return __interp(__ease, arguments); }
 function easeIn() { return __interp(__easeIn, arguments); }
 function easeOut() { return __interp(__easeOut, arguments); }
 
+// Cubic-Bezier easing (the CSS cubic-bezier() shape): [x1, y1, x2, y2], with x1 / x2 in 0..1
+// and y1 / y2 free (overshoot included). Solves x(u) = x by Newton–Raphson, then by bisection
+// when Newton leaves 0..1 or the derivative vanishes, and returns y(u). A curve that is not four
+// finite numbers is linear, never an error.
+function __cubicBezier(curve) {
+  var x1, y1, x2, y2;
+  if (Array.isArray(curve) && curve.length === 4) {
+    x1 = curve[0]; y1 = curve[1]; x2 = curve[2]; y2 = curve[3];
+  }
+  if (typeof x1 !== 'number' || typeof y1 !== 'number' || typeof x2 !== 'number' || typeof y2 !== 'number' ||
+      !isFinite(x1) || !isFinite(y1) || !isFinite(x2) || !isFinite(y2)) {
+    return __lin;
+  }
+  x1 = Math.max(0, Math.min(1, x1));
+  x2 = Math.max(0, Math.min(1, x2));
+  function bx(u) { var v = 1 - u; return 3 * v * v * u * x1 + 3 * v * u * u * x2 + u * u * u; }
+  function dbx(u) { var v = 1 - u; return 3 * v * v * x1 + 6 * v * u * (x2 - x1) + 3 * u * u * (1 - x2); }
+  function by(u) { var v = 1 - u; return 3 * v * v * u * y1 + 3 * v * u * u * y2 + u * u * u; }
+  function dby(u) { var v = 1 - u; return 3 * v * v * y1 + 6 * v * u * (y2 - y1) + 3 * u * u * (1 - y2); }
+  return function (x) {
+    if (x <= 0) return 0;
+    if (x >= 1) return 1;
+    var u = x;
+    for (var i = 0; i < 8; i++) {
+      var f = bx(u) - x;
+      var d = dbx(u);
+      if (Math.abs(d) < 1e-12) break;
+      // Stop when the *value* is accurate: near the endpoints dy/dx is steep, so a residual in x
+      // alone can still mean a visible error in y (f * dy/dx estimates it).
+      if (Math.abs(f * dby(u) / d) < 1e-9) return by(u);
+      var n = u - f / d;
+      if (!(n >= 0 && n <= 1)) break;
+      u = n;
+    }
+    var lo = 0, hi = 1;
+    for (var j = 0; j < 60; j++) {
+      var mid = (lo + hi) / 2;
+      if (bx(mid) < x) lo = mid; else hi = mid;
+    }
+    return by((lo + hi) / 2);
+  };
+}
+
+// bezier(t, tMin, tMax, value1, value2, curve), or bezier(t, value1, value2, curve): the curve is
+// the sixth / fourth argument. Read it by position, not from the end: when it is missing or
+// unusable, the interpolation falls back to linear without consuming the last value.
+function bezier() {
+  var a = arguments, n = a.length;
+  if (n >= 6) return __interp(__cubicBezier(a[5]), [a[0], a[1], a[2], a[3], a[4]]);
+  if (n === 5) return __interp(__lin, [a[0], a[1], a[2], a[3], a[4]]);
+  if (n === 4) return __interp(__cubicBezier(a[3]), [a[0], a[1], a[2]]);
+  return __interp(__lin, [a[0], a[1], a[2]]);
+}
+
 // ---------------------------------------------------------------------------------------------
 // Random numbers and noise.
 
@@ -434,7 +489,7 @@ function __ancestor(c, l, path, countUp) {
   if (typeof n !== 'number' || !(n >= 1) || !isFinite(n)) __err('propertyGroup(' + countUp + '): the count must be a number of 1 or more');
   n = Math.floor(n);
   var info = __h(__ANCESTOR, c, l, path, n);
-  if (info === 'layer') return new Layer(c, l);
+  if (info === 'layer') return __layer(c, l);
   if (info === null) __err('propertyGroup(' + n + ') goes above the layer');
   return __mkGroup(c, l, info);
 }
@@ -464,10 +519,10 @@ Comp.prototype = {
     return __err('Composition "' + this.name + '" has no active camera');
   },
   layer: function (a, rel) {
-    if (a !== null && typeof a === 'object' && a.__isLayer) return this.layer(a.index + (rel || 0));
+    if (typeof a === 'function' && a.__isLayer) return this.layer(a.index + (rel || 0));
     var id = __h(__LAYER, this.__c, a);
     if (id === null) __err(typeof a === 'string' ? 'Layer named "' + a + '" does not exist' : 'Layer index ' + a + ' out of range');
-    return new Layer(this.__c, id);
+    return __layer(this.__c, id);
   },
   toString: function () { return '[object Comp]'; },
 };
@@ -542,7 +597,55 @@ var thisProject = {
 
 // Layer -----------------------------------------------------------------------------------------
 
-function Layer(c, l) { this.__c = c; this.__l = l; this.__i = null; }
+// A layer is a property group too, as in After Effects: `thisLayer("transform")`, another layer's
+// `("effects")("Slider Control")`, `thisLayer(1)` (what the pick whip writes with Compact English
+// off). Callable like a group (`__mkGroup`), with the Layer methods.
+function Layer(c, l) {
+  var f = function (k) { return f.__group(k); };
+  delete f.name;
+  delete f.length;
+  Object.setPrototypeOf(f, Layer.prototype);
+  // Kept across evaluations (`__layer`), so an expression can't change which layer it is, delete
+  // a field or leave its own on it. Its info is private to `__info`, which reads it again in an
+  // evaluation whose `__S` isn't the one it was read in (every evaluation has a new `__S`), so
+  // freezing the layer can't keep its info either.
+  var info = null, read = null;
+  Object.defineProperty(f, '__c', { value: c });
+  Object.defineProperty(f, '__l', { value: l });
+  Object.defineProperty(f, '__info', {
+    get: function () {
+      if (read !== __S) { info = __h(__LINFO, c, l); read = __S; }
+      return info;
+    },
+  });
+  Object.preventExtensions(f);
+  return f;
+}
+
+// Layer `l` of comp `c`, made once per runtime: a callable Layer is dearer to make than a plain
+// object, so it is kept, and its info (`__info`) is read again in each evaluation.
+// The kept layers are out of an expression's reach (their maps have no prototype, so a change to
+// `Object.prototype` doesn't reach them either), and bounded like the runtime's scripts: once
+// `max` are kept, the layers after them aren't, and the next evaluation starts over
+// (`__layersTrim`, so a layer stays the same object for a whole evaluation).
+var __layer, __layersTrim;
+(function () {
+  var layers = Object.create(null), kept = 0, max = 4096;
+  __layer = function (c, l) {
+    // By comp, then layer: a `c + ':' + l` key costs more to build than the lookup saves.
+    var m = layers[c], f = m && m[l];
+    if (f) return f;
+    f = new Layer(c, l);
+    if (kept < max) {
+      (m || (layers[c] = Object.create(null)))[l] = f;
+      kept++;
+    }
+    return f;
+  };
+  __layersTrim = function () {
+    if (kept >= max) { layers = Object.create(null); kept = 0; }
+  };
+})();
 
 function __m3(m, p) {
   var x = p[0] || 0, y = p[1] || 0;
@@ -566,7 +669,6 @@ function __m4(m, p, vec) {
 
 Layer.prototype = {
   __isLayer: true,
-  get __info() { return this.__i || (this.__i = __h(__LINFO, this.__c, this.__l)); },
   get name() { return this.__info[0]; },
   get index() { return this.__info[1]; },
   get inPoint() { return this.__info[2]; },
@@ -578,7 +680,7 @@ Layer.prototype = {
   get parent() {
     var p = this.__info[7];
     if (p === null) __err('Layer "' + this.name + '" has no parent');
-    return new Layer(this.__c, p);
+    return __layer(this.__c, p);
   },
   get hasVideo() { return this.__info[8]; },
   get enabled() { return this.__info[11]; },
@@ -670,14 +772,17 @@ var __groupHandler = {
   },
 };
 
-function __mkGroup(c, l, info) {
-  var f = function (k) { return f.__get(k); };
-  delete f.name;
-  delete f.length;
-  Object.setPrototypeOf(f, __GroupProto);
-  f.__c = c; f.__l = l; f.__p = info[0]; f.__info = info;
-  return new Proxy(f, __groupHandler);
-}
+// `Proxy` is private to the object model (see "Stack safety" at the end).
+var __mkGroup = (function (P) {
+  return function (c, l, info) {
+    var f = function (k) { return f.__get(k); };
+    delete f.name;
+    delete f.length;
+    Object.setPrototypeOf(f, __GroupProto);
+    f.__c = c; f.__l = l; f.__p = info[0]; f.__info = info;
+    return new P(f, __groupHandler);
+  };
+})(Proxy);
 
 // Properties ------------------------------------------------------------------------------------
 
@@ -747,7 +852,7 @@ Prop.prototype = {
   propertyGroup: function (n) { return __ancestor(this.__c, this.__l, this.__p, n); },
   __wrap: function (v) {
     var kind = this.__info[2];
-    if (kind === 'layer') return v === null ? null : new Layer(this.__c, v);
+    if (kind === 'layer') return v === null ? null : __layer(this.__c, v);
     if (kind === 'path' && v !== null) return new __Path(v[0], v[1], v[2], v[3]);
     return v;
   },
@@ -777,7 +882,7 @@ Prop.prototype = {
     for (var i = 1; i < times.length; i++) if (Math.abs(times[i] - t) < Math.abs(times[best] - t)) best = i;
     return this.key(best + 1);
   },
-  __seedIndex: function () { return this.__self ? __S.idx : new Layer(this.__c, this.__l).index; },
+  __seedIndex: function () { return this.__self ? __S.idx : __layer(this.__c, this.__l).index; },
   wiggle: function (freq, amp, octaves, ampMult, t) {
     if (octaves === undefined) octaves = 1;
     if (ampMult === undefined) ampMult = 0.5;
@@ -840,21 +945,24 @@ var __propHandler = {
     // A layer-valued property (a Layer Control's Layer) is named as its layer (#809).
     if (k === 'name' && t.__info[2] === 'layer') {
       var lv = t.value;
-      if (lv !== null && lv !== undefined && lv.__isLayer) return lv.name;
+      if (lv?.__isLayer) return lv.name;
     }
     if (k in t) return t[k];
     var v = t.value;
     if (v === null || v === undefined) return undefined;
     var x = v[k];
-    // Property groups are callable proxies: hand them over as they are, not bound like methods (#809).
-    if (x !== null && x !== undefined && x.__isGroup) return x;
+    // Property groups and layers are callable: hand them over as they are, not bound like methods
+    // (#809).
+    if (typeof x === 'function' && (x.__isGroup || x.__isLayer)) return x;
     return typeof x === 'function' ? x.bind(v) : x;
   },
 };
 
-function __mkProp(c, l, path) {
-  return new Proxy(new Prop(c, l, path), __propHandler);
-}
+var __mkProp = (function (P) {
+  return function (c, l, path) {
+    return new P(new Prop(c, l, path), __propHandler);
+  };
+})(Proxy);
 
 // Text styles (the Source Text style API) ------------------------------------------------------
 // A TextStyle is the source document (as JSON from the host), the character index it reads its
@@ -904,8 +1012,8 @@ __TextStyle.prototype = {
   },
   get text() {
     var t = this.__d.text;
-    for (var k = 0; k < this.__ops.length; k++) {
-      var o = this.__ops[k];
+    for (const elem of this.__ops) {
+      var o = elem;
       if (o[0] !== 'text') continue;
       if (o[2] < 0) t = String(o[1]);
       else t = t.slice(0, o[2]) + String(o[1]) + (o[3] < 0 ? '' : t.slice(o[2] + o[3]));
@@ -1023,20 +1131,20 @@ Markers.prototype = {
 // ---------------------------------------------------------------------------------------------
 // Unqualified names: thisLayer / thisProperty attributes and the `this*` objects. They're
 // accessors on the global object; assigning one (`var width = 10`) shadows it for the current
-// evaluation only.
+// evaluation only. They can't be deleted or redefined, so an expression can't take one away from
+// the evaluations after it.
 
 function __global(name, get) {
   Object.defineProperty(globalThis, name, {
-    configurable: true,
     get: function () { return name in __S.vars ? __S.vars[name] : get(); },
     set: function (v) { __S.vars[name] = v; },
   });
 }
 
 __global('thisComp', function () { return __S.comp || (__S.comp = new Comp(__S.c)); });
-__global('thisLayer', function () { return __S.layer || (__S.layer = new Layer(__S.c, __S.l)); });
+__global('thisLayer', function () { return __S.layer || (__S.layer = __layer(__S.c, __S.l)); });
 __global('thisProperty', function () { return __S.prop || (__S.prop = __mkProp(__S.c, __S.l, __S.path)); });
-['name', 'index', 'inPoint', 'outPoint', 'startTime', 'width', 'height', 'hasParent', 'parent', 'hasVideo', 'enabled', 'active',
+['name', 'index', 'inPoint', 'outPoint', 'startTime', 'width', 'height', 'hasParent', 'parent', 'hasVideo', 'enabled', 'active', 'source',
   'transform', 'position', 'scale', 'rotation', 'opacity', 'anchorPoint', 'text', 'marker'].forEach(function (k) {
   __global(k, function () { return thisLayer[k]; });
 });
@@ -1069,3 +1177,121 @@ function velocityAtTime(t) { return thisProperty.velocityAtTime(t); }
 function speedAtTime(t) { return thisProperty.speedAtTime(t); }
 function key(n) { return thisProperty.key(n); }
 function nearestKey(t) { return thisProperty.nearestKey(t); }
+
+// ---------------------------------------------------------------------------------------------
+// Stack safety (#2124, #2125). A stack overflow aborts the whole app, so nothing a script does
+// may nest native code without bound. The expression text is checked for nesting before it is
+// compiled; source handed to `eval` and the function constructors at run time is checked by
+// `__nest`. The natives that walk nested values recursively (`join`, which `toString` and string
+// conversion use, `toLocaleString`, `JSON.stringify`, `flat`) call `__stack` once per level,
+// which throws once the run has used its share of the stack. `Proxy` (chains of proxies nest
+// without any script frame) and `Reflect` are not available to expressions.
+(function () {
+  var nest = __nest, stack = __stack, apply = Reflect.apply, construct = Reflect.construct;
+  var define = Object.defineProperty, describe = Object.getOwnPropertyDescriptor, proto = Object.getPrototypeOf;
+  // Replace `obj[name]` keeping its attributes.
+  function replace(obj, name, f) {
+    var d = describe(obj, name);
+    define(obj, name, { value: f, writable: d.writable, enumerable: d.enumerable, configurable: true });
+  }
+  function guard(obj, name) {
+    var f = obj[name];
+    replace(obj, name, function () { stack(); return apply(f, this, arguments); });
+  }
+
+  // Indirect on purpose: a wrapper can't make a direct eval, so `eval` sees globals and `var`s
+  // but not `let`/`const` locals of the expression. Keeping direct eval would mean leaving it
+  // unchecked; expressions practically never need their locals inside eval.
+  var evalJs = eval;
+  eval = function (x) {
+    if (typeof x === 'string') {
+      stack();
+      nest(x);
+    }
+    return evalJs(x);
+  };
+  // `Function` and the generator / async variants (reachable as `(function* () {}).constructor`).
+  function dynamic(F) {
+    var w = function () {
+      var args = [];
+      for (var i = 0; i < arguments.length; i++) args.push(String(arguments[i]));
+      stack();
+      nest(args.slice(0, -1).join(','));
+      nest(args.length ? args[args.length - 1] : '');
+      return construct(F, args);
+    };
+    define(w, 'name', { value: F.name, configurable: true });
+    w.prototype = F.prototype;
+    replace(F.prototype, 'constructor', w);
+    return w;
+  }
+  Function = dynamic(Function);
+  dynamic(proto(function* () {}).constructor);
+  dynamic(proto(async function () {}).constructor);
+  dynamic(proto(async function* () {}).constructor);
+
+  guard(Array.prototype, 'join');
+  guard(Array.prototype, 'toLocaleString');
+  var flat = Array.prototype.flat;
+  replace(Array.prototype, 'flat', function (depth) {
+    stack();
+    var d = depth === undefined ? 1 : Number(depth);
+    return apply(flat, this, [d > 64 ? 64 : d]);
+  });
+
+  // A replacer function sees every value before it is serialized: the per-level check. An array
+  // replacer (a list of keys) becomes one that copies each object's listed keys, in list order.
+  // Each source object gets one copy per call, so a cycle in the source is a cycle of copies and
+  // the native check reports it (TypeError); an object shared without a cycle is still fine.
+  var stringify = JSON.stringify, MapJs = Map;
+  replace(JSON, 'stringify', function (value, replacer, space) {
+    var fn = typeof replacer === 'function' ? replacer : null;
+    var keys = null, copies = new MapJs();
+    if (Array.isArray(replacer)) {
+      keys = [];
+      for (var i = 0; i < replacer.length; i++) {
+        var k = replacer[i];
+        if (typeof k === 'number' || k instanceof Number || k instanceof String) k = String(k);
+        if (typeof k === 'string' && keys.indexOf(k) < 0) keys.push(k);
+      }
+    }
+    return apply(stringify, JSON, [value, function (key, v) {
+      stack();
+      if (fn !== null) v = apply(fn, this, [key, v]);
+      if (keys !== null && v !== null && typeof v === 'object' && !Array.isArray(v) &&
+          !(v instanceof Number || v instanceof String || v instanceof Boolean)) {
+        var o = copies.get(v);
+        if (o === undefined) {
+          o = {};
+          for (var j = 0; j < keys.length; j++) if (keys[j] in v) o[keys[j]] = v[keys[j]];
+          copies.set(v, o);
+        }
+        v = o;
+      }
+      return v;
+    }, space]);
+  });
+
+  delete globalThis.Proxy;
+  delete globalThis.Reflect;
+})();
+
+// ---------------------------------------------------------------------------------------------
+// The runtime runs this file once and keeps it for the thread's later evaluations, so an
+// expression can't change the object model or the internals: the prototypes are frozen, and the
+// `__` globals, the constructors and `thisProject` can't be reassigned. The `__` state below is
+// set again by `__begin` in each evaluation.
+
+[Comp, Footage, Layer, Prop, Markers, __Path, __TextStyle].forEach(function (f) {
+  Object.freeze(f.prototype);
+  Object.freeze(f);
+});
+[__GroupProto, __groupHandler, __propHandler, thisProject].forEach(Object.freeze);
+(function () {
+  var perEvaluation = { __S: true, __rc: true, __seed: true, __timeless: true, __projectInfo: true };
+  var model = { Comp: true, Footage: true, Layer: true, Prop: true, Markers: true, thisProject: true };
+  Object.getOwnPropertyNames(globalThis).forEach(function (k) {
+    if (!(k.slice(0, 2) === '__' && !perEvaluation[k]) && !model[k]) return;
+    if ('value' in Object.getOwnPropertyDescriptor(globalThis, k)) Object.defineProperty(globalThis, k, { writable: false, configurable: false });
+  });
+})();
diff --git a/crates/expr/src/rewrite.rs b/crates/expr/src/rewrite.rs
index 6b0ea539f..34b52439b 100644
--- a/crates/expr/src/rewrite.rs
+++ b/crates/expr/src/rewrite.rs
@@ -581,7 +581,7 @@ fn push_piece(out: &mut String, p: Piece) {
 /// rewrite (which nests a call per arithmetic operator). The JavaScript parser and compiler
 /// recurse per level and a 2 MiB thread overflows its stack (aborting the app) at about 75
 /// nested brackets, so deeper expressions are rejected with an error instead. Constructs that
-/// nest without brackets count as part of a level ([`too_nested`]).
+/// nest without brackets count as part of a level (`too_nested`).
 pub const MAX_NESTING: usize = 32;
 /// Hard limit on bytes emitted by the array-math source rewrite.
 pub const MAX_REWRITTEN_BYTES: usize = 4 * 1024 * 1024;
@@ -608,7 +608,7 @@ const HEAVY: usize = 32;
 /// about 3 800 links).
 const LIGHT: usize = 6;
 
-/// One bracket level of [`too_nested`]'s walk.
+/// One bracket level of `too_nested`'s walk.
 #[derive(Default)]
 struct Level {
     /// `[`: commas separate elements (a loop in the parser), not operands.
@@ -710,7 +710,7 @@ fn too_nested(toks: &[Tok]) -> bool {
     too_nested_from(toks, 0)
 }
 
-/// [`too_nested`] for code that already sits `base` deep (a template substitution).
+/// `too_nested` for code that already sits `base` deep (a template substitution).
 fn too_nested_from(toks: &[Tok], base: usize) -> bool {
     let mut levels = vec![Level::default()];
     let mut prefix = 0usize;
@@ -805,6 +805,12 @@ pub fn check_nesting(src: &str) -> Result<(), String> {
     Ok(())
 }
 
+/// An error when plain JavaScript `src` (not rewritten: what `eval` and `Function` get at run
+/// time) nests deeper than [`MAX_NESTING`] levels.
+pub fn check_plain_nesting(src: &str) -> Result<(), String> {
+    if too_nested(&tokenize(src).0) { Err(too_deep()) } else { Ok(()) }
+}
+
 fn too_deep() -> String {
     format!("Error: expression is nested too deeply (more than {MAX_NESTING} levels of brackets, or too long a chain of operators)")
 }
diff --git a/crates/expr/src/runtime.rs b/crates/expr/src/runtime.rs
index 53c2960ba..84bfcdf3c 100644
--- a/crates/expr/src/runtime.rs
+++ b/crates/expr/src/runtime.rs
@@ -51,6 +51,8 @@ thread_local! {
     pub static FRAMES: RefCell<Vec<Frame>> = const { RefCell::new(Vec::new()) };
     /// Script runs since the outermost evaluation on this thread began (nested ones included).
     pub static RUNS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+    /// Stack address where the current script run began (0: none; see [`native_stack`]).
+    static STACK_BASE: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -232,17 +234,54 @@ fn native_random(_: &JsValue, args: &[JsValue], ctx: &mut Context) -> JsResult<J
     Ok(JsValue::from(noise::unit(noise::mix(&parts))))
 }
 
+/// Stack a script run may use below [`run`] for natives that recurse once per level of a nested
+/// value (`join`, `JSON.stringify`, …; the prelude calls [`native_stack`] per level). It is the
+/// same on every thread, so a value converts or fails alike in preview, export and commands.
+/// Expressions run on render, export and diagnostics threads (2 MiB, std and rayon's default)
+/// and on the main thread for commands and syntax checks (1 MiB on Windows). A debug build
+/// stops the nested-value tests within a fresh 512 KiB thread, which leaves the main thread
+/// 512 KiB for its callers. The parser's limit ([`crate::rewrite::MAX_NESTING`]) is the tighter
+/// one there: 30 levels need about 1 MiB in debug builds. On wasm32 the address of a local is on
+/// the shadow stack, not the engine's call stack, so this measures nothing useful there.
+const NATIVE_STACK: usize = 256 << 10;
+
+/// An address on the current stack (on wasm32, the shadow stack).
+fn stack_here() -> usize {
+    let marker = 0u8;
+    std::hint::black_box(&marker) as *const u8 as usize
+}
+
+/// `__stack()`: throw once the current run has used [`NATIVE_STACK`] (values nested so deeply
+/// would overflow the stack, which aborts the app).
+fn native_stack(_: &JsValue, _: &[JsValue], _: &mut Context) -> JsResult<JsValue> {
+    let base = STACK_BASE.with(|b| b.get());
+    if base != 0 && base.abs_diff(stack_here()) > NATIVE_STACK {
+        return Err(JsNativeError::range().with_message("value is nested too deeply").into());
+    }
+    Ok(JsValue::undefined())
+}
+
+/// `__nest(src)`: throw when source handed to `eval` / `Function` at run time nests deeper than
+/// the parser's stack allows (the expression text itself is checked before it is compiled).
+fn native_nesting(_: &JsValue, args: &[JsValue], ctx: &mut Context) -> JsResult<JsValue> {
+    let src = string(args, 0, ctx)?;
+    crate::rewrite::check_plain_nesting(&src).map_err(|e| JsNativeError::range().with_message(e.trim_start_matches("Error: ").to_string()))?;
+    Ok(JsValue::undefined())
+}
+
 impl Runtime {
     fn new() -> Result<Runtime, String> {
         let mut ctx = Context::default();
         let limits = ctx.runtime_limits_mut();
         limits.set_loop_iteration_limit(LOOP_LIMIT);
         limits.set_recursion_limit(400);
-        let natives: [(JsString, usize, fn(&JsValue, &[JsValue], &mut Context) -> JsResult<JsValue>); 4] = [
+        let natives: [(JsString, usize, fn(&JsValue, &[JsValue], &mut Context) -> JsResult<JsValue>); 6] = [
+            (js_string!("__stack"), 0, native_stack),
             (js_string!("__h"), 6, native_host),
             (js_string!("__wig"), 8, native_wiggle),
             (js_string!("__noise"), 3, native_noise),
             (js_string!("__rnd"), 6, native_random),
+            (js_string!("__nest"), 1, native_nesting),
         ];
         for (name, len, f) in natives {
             ctx.register_global_callable(name, len, NativeFunction::from_fn_ptr(f)).map_err(|e| e.to_string())?;
@@ -361,6 +400,9 @@ pub fn out_of_time() -> bool {
     }
 }
 
+/// Levels of nested arrays a script result keeps.
+const MAX_DETACH: usize = 4;
+
 /// Copy a JS value out of the heap.
 fn detach(v: &JsValue, ctx: &mut Context, depth: usize) -> Result<Out, String> {
     if v.is_undefined() {
@@ -380,7 +422,7 @@ fn detach(v: &JsValue, ctx: &mut Context, depth: usize) -> Result<Out, String> {
     }
     let err = |e: boa_engine::JsError| format_error(&e.to_string(), usize::MAX);
     if let Some(o) = v.as_object() {
-        if o.is_array() && depth < 4 {
+        if o.is_array() && depth < MAX_DETACH {
             let arr = JsArray::from_object(o).map_err(err)?;
             let n = arr.length(ctx).map_err(err)?.min(1 << 16);
             let mut out = Vec::with_capacity(n as usize);
@@ -408,6 +450,11 @@ fn detach(v: &JsValue, ctx: &mut Context, depth: usize) -> Result<Out, String> {
             return Ok(Out::Path { points, ins, outs, closed });
         }
     }
+    // Below the levels detached above, an object's text could be its whole nested content
+    // (`String([[[…]]])`), converted by natives that recurse once per level.
+    if depth >= MAX_DETACH && v.is_object() {
+        return Ok(Out::Object("[object]".into()));
+    }
     Ok(Out::Object(v.to_string(ctx).map(|s| s.to_std_string_escaped()).unwrap_or_default()))
 }
 
@@ -484,6 +531,8 @@ fn position_line(msg: &str) -> Option<usize> {
 /// `__begin` with memoized answers, so nothing carries over. A script that really overflows the
 /// stack fails again on the fresh context and reports the error.
 pub fn run(text: &str, b: &Begin) -> Run {
+    // Runs don't nest (other expressions are evaluated between runs), so one base suffices.
+    STACK_BASE.with(|s| s.set(stack_here()));
     RUNTIME.with(|r| {
         let mut r = r.borrow_mut();
         for fresh in [false, true] {
@@ -628,6 +677,7 @@ pub fn styled_doc(v: &serde_json::Value, own: &effectcraft_keyframe::TextDoc) ->
             let p0 = src.para(0);
             d.set_paras(vec![p0; d.para_count()]);
             d.stroke_over_fill = src.stroke_over_fill;
+            d.line_join = src.line_join;
         }
     }
     for op in v.get("ops").and_then(|o| o.as_array()).into_iter().flatten() {
diff --git a/crates/expr/src/tests.rs b/crates/expr/src/tests.rs
index 7d2790255..fd5de44fa 100644
--- a/crates/expr/src/tests.rs
+++ b/crates/expr/src/tests.rs
@@ -1,5 +1,6 @@
 use std::time::Instant;
 
+mod deep_nesting;
 mod fuzz;
 
 use effectcraft_color::Label;
@@ -76,7 +77,7 @@ fn fx() -> Fx {
 
     let ids = (a.id, b.id, title.id, shape.id);
     let c = p.comp_mut(cid).unwrap();
-    c.layers = vec![a, b, title, shape];
+    c.layers = vec![a, b, title, shape].into();
     c.markers.push(Marker { time: secs(1.5), comment: "comp marker".into(), ..Default::default() });
 
     let other = Comp::new(64, 32, FrameRate::FPS_24, Tick::from_seconds_f64(3.0));
@@ -313,8 +314,78 @@ fn interpolation_with_arrays() {
     assert_eq!(f.pos("ease(time, 0, 1, [0, 0], [100, 50])", 1.0), [100.0, 50.0, 0.0]);
 }
 
-// ---- object model -----------------------------------------------------------------------------
+#[test]
+fn cubic_bezier_curves() {
+    let f = fx();
+    // ease(t, …) is cubic-bezier(1/3, 0, 2/3, 1): x(u) = u and y(u) = 3u² - 2u³.
+    assert_close!(f.num("bezier(0.25, 0, 1, 0, 100, [0.3333333333333333, 0, 0.6666666666666666, 1])", 0.0), f.num("ease(0.25, 0, 1, 0, 100)", 0.0));
+    assert_close!(f.num("bezier(0.5, 0, 1, 0, 100, [0.3333333333333333, 0, 0.6666666666666666, 1])", 0.0), 50.0);
+    // Symmetric ease-in-out: slower at both ends, faster in the middle.
+    let early = f.num("bezier(0.25, 0, 1, 0, 100, [0.42, 0, 0.58, 1])", 0.0);
+    let late = f.num("bezier(0.75, 0, 1, 0, 100, [0.42, 0, 0.58, 1])", 0.0);
+    assert!(early < 25.0 && late > 75.0, "ease-in-out: {early}, {late}");
+    // Control points on the diagonal are linear.
+    assert_close!(f.num("bezier(0.3, 0, 1, 0, 100, [0, 0, 1, 1])", 0.0), 30.0);
+    // t is clamped to tMin..tMax; tMin == tMax behaves like the other helpers.
+    assert_close!(f.num("bezier(-1, 0, 1, 0, 100, [0.42, 0, 0.58, 1])", 0.0), 0.0);
+    assert_close!(f.num("bezier(2, 0, 1, 0, 100, [0.42, 0, 0.58, 1])", 0.0), 100.0);
+    assert_close!(f.num("bezier(5, 2, 2, 0, 100, [0.42, 0, 0.58, 1])", 0.0), 100.0);
+}
 
+#[test]
+fn cubic_bezier_short_form_arrays_and_fallbacks() {
+    let f = fx();
+    // Short form: no tMin / tMax.
+    assert_close!(f.num("bezier(0.25, 10, 20, [0, 0, 1, 1])", 0.0), 12.5);
+    assert_eq!(f.pos("bezier(time, 0, 1, [0, 0], [100, 50], [0.42, 0, 0.58, 1])", 1.0), [100.0, 50.0, 0.0]);
+    // y outside 0..1 overshoots, as CSS allows.
+    let over = f.num("bezier(0.5, 0, 1, 0, 100, [0.5, 2, 0.5, 2])", 0.0);
+    assert!(over > 100.0, "overshoot: {over}");
+    // A curve that is not four finite numbers falls back to linear instead of throwing.
+    assert_close!(f.num("bezier(0.5, 0, 1, 0, 100, [1, 0])", 0.0), 50.0);
+    assert_close!(f.num("bezier(0.5, 0, 1, 0, 100, 'ease')", 0.0), 50.0);
+    // A missing or unusable curve must not consume the last value: read the curve by position.
+    assert_close!(f.num("bezier(0.5, 0, 1, 0, 100)", 0.0), 50.0);
+    assert_close!(f.num("bezier(0.5, 0, 100)", 0.0), 50.0);
+    assert_close!(f.num("bezier(0.5, 0, 100, [1, 0])", 0.0), 50.0);
+    let v = f.ev(f.shape, "contents/#1/contents/fill/color", "bezier(0.5, 0, 1, [0, 0, 0, 1], [1, 1, 1, 1])", 0.0).unwrap();
+    assert_eq!(v, Value::Color([0.5, 0.5, 0.5, 1.0]));
+    // Exactly four values are a curve; extra ones mean the curve is malformed, so linear.
+    assert_close!(f.num("bezier(0.5, 0, 1, 0, 100, [0.42, 0, 0.58, 1, 0])", 0.0), 50.0);
+    assert_close!(f.num("bezier(0.5, 0, 1, 0, 100, [0.42, 0, 0.58, 1, 2, 3])", 0.0), 50.0);
+    // x control points outside 0..1 are clamped, as CSS requires.
+    let v = f.num("bezier(0.5, 0, 1, 0, 100, [-1, 0, 2, 1])", 0.0);
+    assert!(v.is_finite(), "clamped curve: {v}");
+}
+
+#[test]
+fn cubic_bezier_is_accurate_near_the_endpoints() {
+    /// The value the curve reaches at `x`, by bisection on its monotone x(u).
+    fn reference(x1: f64, y1: f64, x2: f64, y2: f64, x: f64) -> f64 {
+        let bx = |u: f64| 3.0 * (1.0 - u) * (1.0 - u) * u * x1 + 3.0 * (1.0 - u) * u * u * x2 + u * u * u;
+        let by = |u: f64| 3.0 * (1.0 - u) * (1.0 - u) * u * y1 + 3.0 * (1.0 - u) * u * u * y2 + u * u * u;
+        let (mut lo, mut hi) = (0.0f64, 1.0f64);
+        for _ in 0..100 {
+            let mid = 0.5 * (lo + hi);
+            if bx(mid) < x {
+                lo = mid;
+            } else {
+                hi = mid;
+            }
+        }
+        by(0.5 * (lo + hi))
+    }
+    // Steep curves: a residual in x is not a residual in y near the endpoints (dy/dx is in the
+    // thousands), so the solver stops on the estimated y error instead.
+    let f = fx();
+    for (c, x) in [([0.0, 1000.0, 1.0, 1.0], 1e-6), ([0.0, 100.0, 1.0, 0.0], 1e-9), ([0.8, -500.0, 1.0, 1.0], 0.999999)] {
+        let got = f.num(&format!("bezier({x}, 0, 1, [{}, {}, {}, {}])", c[0], c[1], c[2], c[3]), 0.0);
+        let want = reference(c[0], c[1], c[2], c[3], x);
+        assert!((got - want).abs() < 1e-6, "curve {c:?} at {x}: {got} vs {want}");
+    }
+}
+
+// ---- object model -----------------------------------------------------------------------------
 #[test]
 fn comp_attributes() {
     let f = fx();
@@ -907,6 +978,49 @@ fn source_rect_at_time() {
     assert!((s[0] + 31.0).abs() < 2.0 && (s[1] + 16.0).abs() < 2.0 && (s[2] - 62.0).abs() < 3.0, "{s:?}");
 }
 
+#[test]
+fn source_dimensions_follow_media_replacement() {
+    let mut p = Project::default();
+    let comp = Comp::new(200, 100, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
+    let cid = p.add_item("Main", Label::Sandstone, None, ItemKind::Comp(comp.clone().into()));
+    let footage = |p: &mut Project, name: &str, width, height| {
+        p.add_item(
+            name,
+            Label::SeaFoam,
+            None,
+            ItemKind::Footage(effectcraft_project::Footage {
+                path: name.into(),
+                kind: effectcraft_project::FootageKind::Still,
+                width,
+                height,
+                has_video: true,
+                ..Default::default()
+            }),
+        )
+    };
+    let original = footage(&mut p, "original.png", 100, 80);
+    let replacement = footage(&mut p, "replacement.png", 30, 40);
+    let mut l = build::layer(&mut p, &comp, "Clip", LayerSource::Footage { item: original }, (100, 80), None);
+    l.props.prop_mut(ROT).unwrap().expr =
+        Some(Expression { text: "thisLayer.width + thisLayer.height + thisLayer.source.width + sourceRectAtTime().width".into(), enabled: true });
+    let lid = l.id;
+    p.comp_mut(cid).unwrap().layers.push(l);
+    let c = p.comp(cid).unwrap();
+    let l = c.layer(lid).unwrap();
+    let media = effectcraft_render::MediaOverride::new(lid, replacement);
+    let ctx = EvalCtx {
+        project: &p,
+        comp_id: cid,
+        comp: c,
+        time: Tick::ZERO,
+        expr: Some(&Expressions),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[media],
+    };
+    assert_eq!(ctx.value(l, l.props.prop(ROT).unwrap()), Value::Scalar(130.0));
+}
+
 // ---- colour -----------------------------------------------------------------------------------
 
 #[test]
@@ -985,6 +1099,8 @@ fn shadowing_layer_attribute_names_is_local() {
     let f = fx();
     assert_close!(f.num("var width = 3;\nwidth * 2", 0.0), 6.0);
     assert_close!(f.num("width", 0.0), 20.0, 1e-9);
+    assert_close!(f.num("function width() { return 4; }\nwidth() * 2", 0.0), 8.0);
+    assert_close!(f.num("width", 0.0), 20.0, 1e-9);
 }
 
 #[test]
@@ -1114,7 +1230,16 @@ fn text_expression_selector_values() {
     let sel_of = |p: &Project| {
         let c = p.comp(cid).unwrap();
         let l = c.layer(lid).unwrap();
-        let ctx = EvalCtx { project: p, comp_id: cid, comp: c, time: Tick::ZERO, expr: Some(&Expressions), footage: None };
+        let ctx = EvalCtx {
+            project: p,
+            comp_id: cid,
+            comp: c,
+            time: Tick::ZERO,
+            expr: Some(&Expressions),
+            footage: None,
+            property_overrides: &[],
+            media_overrides: &[],
+        };
         let doc = effectcraft_render::text::source_text(&ctx, l).unwrap();
         let lay = effectcraft_text::layout_doc(&doc);
         let anim = l.props.group("text/animators/#1").unwrap();
@@ -1277,6 +1402,89 @@ fn layer_source_is_the_layers_source_item() {
     assert_close!(f.num("thisComp.layer('Pre').source.numLayers", 0.0), 1.0);
 }
 
+/// The fixture plus a 20×12 solid "Wide", a 48×36 still "Still" (item "still.png") and a precomp
+/// layer "Pre" of the 64×32 "Other" comp.
+fn implicit_source_fx() -> (Fx, LayerId, LayerId, LayerId) {
+    let mut f = fx();
+    let main = f.p.comp(f.cid).unwrap().clone();
+    let wide = solid(&mut f.p, &main, "Wide", [1.0, 1.0, 0.0], 20, 12);
+    let item = f.p.add_item(
+        "still.png",
+        Label::SeaFoam,
+        None,
+        ItemKind::Footage(effectcraft_project::Footage {
+            path: "still.png".into(),
+            kind: effectcraft_project::FootageKind::Still,
+            width: 48,
+            height: 36,
+            has_video: true,
+            ..Default::default()
+        }),
+    );
+    let still = build::layer(&mut f.p, &main, "Still", LayerSource::Footage { item }, (48, 36), None);
+    let other = f.p.items.values().find(|i| i.name == "Other").unwrap().id;
+    let pre = build::layer(&mut f.p, &main, "Pre", LayerSource::Comp { item: other }, (64, 32), None);
+    let ids = (wide.id, still.id, pre.id);
+    let c = f.p.comp_mut(f.cid).unwrap();
+    c.layers.push(wide);
+    c.layers.push(still);
+    c.layers.push(pre);
+    (f, ids.0, ids.1, ids.2)
+}
+
+fn num_on(f: &Fx, layer: LayerId, text: &str) -> f64 {
+    match f.ev(layer, ROT, text, 0.0) {
+        Ok(v) => v.as_f64(),
+        Err(e) => panic!("{text}: {e}"),
+    }
+}
+
+#[test]
+fn implicit_source_matches_this_layer_source() {
+    let (f, wide, still, pre) = implicit_source_fx();
+    let same = "['name', 'width', 'height', 'duration', 'frameDuration', 'pixelAspect']\
+                .every(function (k) { return source[k] === thisLayer.source[k]; }) ? 1 : 0";
+    for (layer, name, w, h) in [(wide, "Wide", 20.0, 12.0), (still, "still.png", 48.0, 36.0), (pre, "Other", 64.0, 32.0)] {
+        assert_close!(num_on(&f, layer, "source.width"), w);
+        assert_close!(num_on(&f, layer, "source.height"), h);
+        assert_close!(num_on(&f, layer, &format!("source.name == '{name}' ? 1 : 0")), 1.0);
+        assert_close!(num_on(&f, layer, same), 1.0);
+    }
+    assert_close!(num_on(&f, pre, "source.numLayers"), 1.0);
+}
+
+#[test]
+fn implicit_source_is_null_without_a_source_item() {
+    let f = fx();
+    for layer in [f.title, f.shape] {
+        assert_close!(num_on(&f, layer, "source === null && thisLayer.source === null ? 1 : 0"), 1.0);
+        let bare = f.ev(layer, ROT, "source.width", 0.0).unwrap_err();
+        let qualified = f.ev(layer, ROT, "thisLayer.source.width", 0.0).unwrap_err();
+        assert!(qualified.contains("TypeError"), "{qualified}");
+        assert_eq!(bare, qualified);
+    }
+}
+
+#[test]
+fn implicit_source_can_be_shadowed_locally() {
+    let (f, wide, ..) = implicit_source_fx();
+    assert_close!(num_on(&f, wide, "var source = 7;\nsource * 2"), 14.0);
+    assert_close!(num_on(&f, wide, "source.width"), 20.0);
+    assert_close!(num_on(&f, wide, "var source = thisComp.layer('B').source;\nsource.width"), 40.0);
+    assert_close!(num_on(&f, wide, "source.height"), 12.0);
+}
+
+#[test]
+fn implicit_source_follows_the_current_layer() {
+    let (f, wide, still, pre) = implicit_source_fx();
+    let e = "source === null ? -1 : source.width * 1000 + source.height";
+    for _ in 0..2 {
+        for (layer, want) in [(wide, 20012.0), (still, 48036.0), (pre, 64032.0), (f.title, -1.0), (f.b, 40040.0)] {
+            assert_close!(num_on(&f, layer, e), want);
+        }
+    }
+}
+
 #[test]
 fn layer_control_property_stands_for_its_layer() {
     let mut f = fx();
@@ -1370,4 +1578,97 @@ fn time_to_frames_preserves_coercion_and_small_durations() {
     }
 }
 
+/// A layer is a property group too, as in After Effects: `thisLayer("transform")`, another
+/// layer's `("effects")("Slider Control")` or `(1)`, as the pick whip writes them with Compact
+/// English off (they failed: "not a callable function"). It is still a layer.
+#[test]
+fn layers_are_callable_property_groups() {
+    let f = fx();
+    assert_close!(f.num("thisLayer(\"transform\")(\"opacity\")", 0.0), 100.0);
+    assert_close!(f.num("thisComp.layer(\"A\")(\"effects\")(\"ec.control.slider\")(\"slider\")", 0.0), 42.0);
+    assert_close!(f.num("thisComp.layer(\"A\")(\"effects\")(\"Slider Control\")(1)", 0.0), 42.0);
+    assert_close!(f.num("thisComp.layer(1)(\"effects\")(1)(1)", 0.0), 42.0);
+    // Its own name, index and methods, and a layer as the result still reads as its index.
+    assert_close!(f.num("thisLayer.name == \"A\" ? thisComp.layer(\"B\").index : 0", 0.0), 2.0);
+    assert_close!(f.num("thisComp.layer(\"B\")", 0.0), 2.0);
+    assert_close!(f.num("thisComp.layer(thisComp.layer(\"B\"), -1).index", 0.0), 1.0);
+    assert!(f.err("thisLayer(\"nope\")").contains("no property"), "{}", f.err("thisLayer(\"nope\")"));
+}
+
+/// A layer is kept from one evaluation to the next (it is dear to make) but reads the project
+/// afresh in each, and an expression's own fields on it don't reach the next one.
+#[test]
+fn a_kept_layer_reads_the_project_again() {
+    let mut f = fx();
+    let first = "thisComp.layer(\"B\").index * 10 + thisComp.layer(2).name.length";
+    assert_close!(f.num(first, 0.0), 21.0);
+    f.layer_mut(f.b).name = "Bee".into();
+    f.p.comp_mut(f.cid).unwrap().layers.swap(0, 1);
+    assert_close!(f.num("thisComp.layer(\"Bee\").index * 10 + thisComp.layer(2).name.length", 0.0), 11.0);
+    assert_close!(f.num("thisLayer.index", 0.0), 2.0);
+    let _ = f.ev(f.a, ROT, "thisLayer.mine = 5; 0", 0.0);
+    assert_close!(f.num("thisLayer.mine === undefined ? 1 : 0", 0.0), 1.0);
+    let _ = f.ev(f.a, ROT, "var L = thisLayer; L.__c = 'x'; L.__l = 99; L.__i = ['Z', 7]; L.__s = __S; 0", 0.0);
+    assert_close!(f.num("thisLayer.index * 10 + thisLayer.name.length", 0.0), 21.0);
+    let _ = f.ev(f.a, ROT, "var L = thisLayer; delete L.__c; delete L.__l; delete L.__i; delete L.__s; 0", 0.0);
+    assert_close!(f.num("thisLayer.index * 10 + thisLayer.name.length", 0.0), 21.0);
+    let _ = f.ev(f.a, ROT, "Object.freeze(thisLayer); 0", 0.0);
+    f.layer_mut(f.a).name = "Ay".into();
+    f.p.comp_mut(f.cid).unwrap().layers.swap(0, 1);
+    assert_close!(f.num("thisLayer.index * 10 + thisLayer.name.length", 0.0), 12.0);
+}
+
+/// The kept layers are bounded: past the bound a layer isn't kept, an evaluation that makes more
+/// layers than are kept still sees one object for each layer it had kept, and the evaluations
+/// after it, which start over, read the right layers.
+#[test]
+fn the_kept_layers_are_bounded() {
+    let f = fx();
+    let same = "(thisLayer === thisComp.layer(thisLayer.index) ? 1 : 0)";
+    let many =
+        format!("var c = thisLayer.__c;\nfor (var i = 0; i < 5000; i++) __layer(c, 100000 + i);\n{same} * 10 + (__layer(c, 1e6) === __layer(c, 1e6) ? 0 : 1)");
+    assert_close!(f.num(&many, 0.0), 11.0);
+    assert_close!(f.num(&format!("{same} * 100 + thisLayer.index * 10 + thisLayer.name.length"), 0.0), 111.0);
+    assert_close!(f.num(&format!("{same} * 100 + thisLayer.index * 10 + thisLayer.name.length"), 0.0), 111.0);
+}
+
+/// A change to `Object.prototype` doesn't reach the kept layers: a frozen object put there under
+/// the comp's id, before any of its layers is kept, doesn't stop them being kept.
+#[test]
+fn the_kept_layers_dont_go_through_object_prototype() {
+    let f = fx();
+    let _ = f.ev(f.a, ROT, "try { Object.prototype[thisComp.__c] = Object.freeze({}); } catch (e) {} 0", 0.0);
+    assert_close!(f.num("thisLayer === thisComp.layer(thisLayer.index) ? 1 : 0", 0.0), 1.0);
+}
+
+/// The prelude is kept from one evaluation to the next, so an expression can't change its object
+/// model or internals for the ones after it.
+#[test]
+fn an_expression_cant_change_the_prelude_for_the_next() {
+    let f = fx();
+    let read = "[thisComp.layer(1).index, thisLayer.index, thisLayer('transform').property('rotation').value,                 thisLayer.transform.opacity.value, thisProject.bitsPerChannel, comp(thisComp.name).numLayers, width]";
+    let before = f.ev(f.a, ROT, read, 0.5).unwrap();
+    let attacks = [
+        "Comp.prototype.layer = function () { return 0; }",
+        "Object.getPrototypeOf(thisLayer).index = 0",
+        "Object.getPrototypeOf(thisLayer('transform')).property = function () { return 0; }",
+        "Object.getPrototypeOf(thisLayer.transform.opacity).value = 0",
+        "Comp = function () {}",
+        "Prop = function () {}",
+        "thisProject = null",
+        "__h = function () { return null; }",
+        "__layer = function () { return null; }",
+        "__child = function () {}",
+        "delete __mkProp",
+        "delete thisLayer",
+        "delete thisComp",
+        "delete width",
+        "Object.defineProperty(globalThis, 'thisComp', { get: function () { return 0; } })",
+    ];
+    for a in attacks {
+        let _ = f.ev(f.a, ROT, &format!("try {{ {a} }} catch (e) {{}} 0"), 0.0);
+        assert_eq!(f.ev(f.a, ROT, read, 0.5).unwrap(), before, "after `{a}`");
+    }
+}
+
 mod property_group;
diff --git a/crates/expr/src/tests/deep_nesting.rs b/crates/expr/src/tests/deep_nesting.rs
new file mode 100644
index 000000000..ae78c5b20
--- /dev/null
+++ b/crates/expr/src/tests/deep_nesting.rs
@@ -0,0 +1,130 @@
+//! Deep nesting the expression text check can't see (#2124, #2125): source handed to `eval` /
+//! `Function` at run time, and deeply nested values that boa's natives (`join`, `JSON.stringify`,
+//! proxies…) walk recursively. Each used to overflow the stack, which aborts the whole app
+//! (`catch_unwind` can't catch it); now each is an expression error.
+
+use super::*;
+
+/// The render threads' stack size (rayon's default): what the app gets.
+const RENDER_STACK: usize = 2 << 20;
+
+/// Evaluate `text` on the title's source text (any result converts) on a render-sized stack.
+fn eval_small_stack(text: &str) -> Result<Value, String> {
+    eval_on_stack(text, RENDER_STACK)
+}
+
+/// Evaluate `text` on the title's source text on a thread with `size` bytes of stack.
+fn eval_on_stack(text: &str, size: usize) -> Result<Value, String> {
+    let text = text.to_string();
+    std::thread::Builder::new()
+        .stack_size(size)
+        .spawn(move || {
+            let f = fx();
+            f.ev(f.title, "text/sourceText", &text, 0.0)
+        })
+        .unwrap()
+        .join()
+        .unwrap()
+}
+
+fn text_of(r: Result<Value, String>) -> String {
+    match r {
+        Ok(Value::Text(d)) => d.text,
+        other => panic!("not text: {other:?}"),
+    }
+}
+
+/// A 100 000-deep array: `var a = []; … a = [a]` in a loop (under the loop limit).
+const DEEP_ARRAY: &str = "var a = []; for (var i = 0; i < 100000; i++) a = [a];";
+
+#[test]
+fn eval_and_function_constructors_check_nesting() {
+    let deep = r#""(".repeat(1000) + "1" + ")".repeat(1000)"#;
+    for call in [
+        format!("eval({deep})"),
+        format!("Function({deep})()"),
+        format!("new Function('a', {deep})(1)"),
+        format!("Function('a = ' + {deep}, 'return a')()"),
+        "Function.apply(null, '('.repeat(1000).split('').concat(['1']))".to_string(),
+        format!("(function () {{}}).constructor({deep})()"),
+        format!("Object.getPrototypeOf(function* () {{}}).constructor({deep})"),
+        format!("Object.getPrototypeOf(async function () {{}}).constructor({deep})"),
+        format!("Object.getPrototypeOf(async function* () {{}}).constructor({deep})"),
+    ] {
+        let e = eval_small_stack(&call).expect_err(&call);
+        assert!(e.contains("nested too deeply"), "{call}: {e}");
+    }
+}
+
+#[test]
+fn eval_and_function_still_work() {
+    let f = fx();
+    assert_eq!(f.num("eval('1 + 2')", 0.0), 3.0);
+    assert_eq!(f.num("eval('[1, [2, (3)]]')[1][1]", 0.0), 3.0);
+    assert_eq!(f.num("new Function('a', 'b', 'return a * b')(3, 4)", 0.0), 12.0);
+    assert_eq!(f.num("Function('return 5')()", 0.0), 5.0);
+    assert_eq!(f.num("(function () {}).constructor('return 6')()", 0.0), 6.0);
+    assert_eq!(f.num("(function () {}) instanceof Function ? 1 : 0", 0.0), 1.0);
+    assert_eq!(f.num("(function () {}).constructor === Function ? 1 : 0", 0.0), 1.0);
+    assert_eq!(f.num("Object.getPrototypeOf(function* () { yield 7; }).constructor('yield 7')().next().value", 0.0), 7.0);
+}
+
+#[test]
+fn deep_array_result_is_an_error_or_text_not_a_crash() {
+    // The result itself: detaching it used to `toString` it past depth 4.
+    let _ = eval_small_stack(&format!("{DEEP_ARRAY} a"));
+    // Explicit conversions inside the script.
+    for tail in ["a.join()", "a.toString()", "String(a)", "a + ''", "`${a}`", "a.toLocaleString()", "JSON.stringify(a)", "JSON.stringify({ a: a })"] {
+        let text = format!("{DEEP_ARRAY} {tail}");
+        let e = eval_small_stack(&text).expect_err(&text);
+        assert!(e.contains("nested too deeply"), "{text}: {e}");
+    }
+    // A deep array as a text style value goes through JSON.stringify in the prelude.
+    let _ = eval_small_stack(&format!("{DEEP_ARRAY} text.sourceText.style.setFontSize(a)"));
+}
+
+#[test]
+fn deep_proxy_chain_is_an_error_not_a_crash() {
+    let text = "var p = {}; for (var i = 0; i < 100000; i++) p = new Proxy(p, {}); p.x";
+    let e = eval_small_stack(text).expect_err(text);
+    assert!(e.contains("Proxy") && e.contains("not defined"), "{text}: {e}");
+    // Neither is available to expressions; the object model's own proxies still work.
+    let f = fx();
+    assert_eq!(f.text("typeof Proxy + ' ' + typeof Reflect", 0.0), "undefined undefined");
+    assert_eq!(f.num("thisComp.layer('A').effect('Slider Control')('Slider')", 0.0), 42.0);
+}
+
+#[test]
+fn nested_values_still_convert() {
+    let f = fx();
+    assert_eq!(f.text("[[1, 2], [3, [4, 5]]].join(';')", 0.0), "1,2;3,4,5");
+    assert_eq!(f.text("String([[1, 2], 3])", 0.0), "1,2,3");
+    assert_eq!(f.text("JSON.stringify({ a: [1, { b: [2] }] })", 0.0), r#"{"a":[1,{"b":[2]}]}"#);
+    assert_eq!(f.text("JSON.stringify({ a: 1, b: 2 }, ['b'])", 0.0), r#"{"b":2}"#);
+    assert_eq!(f.text("JSON.stringify([1, [2]], null, 1)", 0.0), "[\n 1,\n [\n  2\n ]\n]");
+    assert_eq!(f.text("JSON.stringify({ a: 1 }, function (k, v) { return k === 'a' ? v + 1 : v; })", 0.0), r#"{"a":2}"#);
+    // Nested deeper than the detached levels: still converts to its text.
+    assert_eq!(text_of(eval_small_stack("[[[[[[1, 2]]]]]]")), "");
+    assert_eq!(f.text("String([[[[[[[[1]]]]]]]])", 0.0), "1");
+    assert_eq!(f.num("[1, [2, [3, [4]]]].flat(Infinity).length", 0.0), 4.0);
+}
+
+/// The main thread runs commands and syntax checks: 1 MiB on Windows. Half of it, for the
+/// callers above the evaluation, must still turn the nested-value triggers into errors.
+#[test]
+fn nested_values_are_an_error_on_half_the_main_thread() {
+    for tail in ["a.join()", "String([a])", "JSON.stringify(a)", "a.toLocaleString()"] {
+        let text = format!("{DEEP_ARRAY} {tail}");
+        let e = eval_on_stack(&text, 512 << 10).expect_err(&text);
+        assert!(e.contains("nested too deeply"), "{tail}: {e}");
+    }
+}
+
+#[test]
+fn stringify_with_a_key_list_reports_cycles_and_allows_shared_objects() {
+    let f = fx();
+    let cyclic = f.text("var o = {a: 1}; o.self = o; try { JSON.stringify(o, ['a', 'self']) } catch (e) { e.name }", 0.0);
+    assert_eq!(cyclic, "TypeError");
+    let shared = f.text("var x = {a: 1, b: 2}; JSON.stringify({p: x, q: x}, ['p', 'q', 'a'])", 0.0);
+    assert_eq!(shared, r#"{"p":{"a":1},"q":{"a":1}}"#);
+}
diff --git a/crates/expr/src/tests/fuzz.rs b/crates/expr/src/tests/fuzz.rs
index 1bfaf8c16..37b28c415 100644
--- a/crates/expr/src/tests/fuzz.rs
+++ b/crates/expr/src/tests/fuzz.rs
@@ -93,6 +93,8 @@ const SEEDS: &[&str] = &[
     "linear(time, 0, 1, 0, 100)",
     "ease(time, 0, 2, [0, 0], [100, 50])",
     "easeIn(time, 0, 1, 0, 360) + easeOut(time, 1, 2, 0, 10)",
+    "bezier(time, 0, 1, 0, 100, [0.42, 0, 0.58, 1])",
+    "bezier(time, [0, 0], [100, 50], [0.25, 0.1, 0.25, 1])",
     "clamp(value * 2, 0, 100)",
     "length([0, 0], [3, 4]) + dot([1, 0], [0, 1]) + cross([1, 0, 0], [0, 1, 0])[2]",
     "normalize([3, 4])[0] * degreesToRadians(180)",
diff --git a/crates/expr/src/tests/property_group.rs b/crates/expr/src/tests/property_group.rs
index debe5e5ac..c96045ec2 100644
--- a/crates/expr/src/tests/property_group.rs
+++ b/crates/expr/src/tests/property_group.rs
@@ -72,6 +72,9 @@ fn property_group_reaches_the_layer() {
     assert_close!(f.num("thisProperty.propertyGroup(2).name == 'A' ? 1 : 0", 0.0), 1.0);
     assert_close!(f.num("thisProperty.propertyGroup(2).index", 0.0), 1.0);
     assert_close!(f.num("thisProperty.propertyGroup(1).propertyGroup(1).name == 'A' ? 1 : 0", 0.0), 1.0);
+    // The layer it reaches is the same object as `thisLayer`.
+    assert_close!(f.num("thisLayer('transform').propertyGroup(1) === thisLayer ? 1 : 0", 0.0), 1.0);
+    assert_close!(f.num("thisProperty.propertyGroup(2) === thisLayer ? 1 : 0", 0.0), 1.0);
     let s = staggered();
     assert_close!(s.shape_num(SCALE_2, "thisProperty.propertyGroup(4).name == 'Shape' ? 1 : 0"), 1.0);
 }
diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rs
index d86784f1e..32121ffcb 100644
--- a/crates/geom/src/lib.rs
+++ b/crates/geom/src/lib.rs
@@ -261,6 +261,9 @@ impl Mat3 {
             return Mat3([[x1 - x0, x3 - x0, x0], [y1 - y0, y3 - y0, y0], [0.0, 0.0, 1.0]]);
         }
         let den = dx1 * dy2 - dx2 * dy1;
+        if den == 0.0 || !den.is_finite() {
+            return Mat3::IDENTITY;
+        }
         let g = (sx * dy2 - dx2 * sy) / den;
         let h = (dx1 * sy - sx * dy1) / den;
         Mat3([[x1 - x0 + g * x1, x3 - x0 + h * x3, x0], [y1 - y0 + g * y1, y3 - y0 + h * y3, y0], [g, h, 1.0]])
@@ -449,6 +452,19 @@ pub fn look_at(pos: Vec3, poi: Vec3, extra: Mat4) -> Mat4 {
 mod tests {
     use super::*;
 
+    /// A quad with three collinear corners has no projective map: identity, not NaN.
+    #[test]
+    fn square_to_quad_degenerate_is_finite() {
+        let m = Mat3::square_to_quad([vec2(0.0, 5.0), vec2(0.0, 0.0), vec2(10.0, 0.0), vec2(20.0, 0.0)]);
+        assert!(m.0.iter().flatten().all(|v| v.is_finite()), "non-finite: {m:?}");
+    }
+
+    #[test]
+    fn square_to_quad_regular_is_finite() {
+        let m = Mat3::square_to_quad([vec2(0.0, 0.0), vec2(10.0, 0.0), vec2(8.0, 6.0), vec2(0.0, 5.0)]);
+        assert!(m.0.iter().flatten().all(|v| v.is_finite()));
+    }
+
     fn close(a: Vec2, b: Vec2) -> bool {
         (a - b).length() < 1e-9
     }
diff --git a/crates/gpu/src/adv3d.rs b/crates/gpu/src/adv3d.rs
index 24c5a3b35..c96e57d2d 100644
--- a/crates/gpu/src/adv3d.rs
+++ b/crates/gpu/src/adv3d.rs
@@ -77,7 +77,7 @@ fn buffer_bytes(count: u64, stride: u64, limit: u64) -> Option<u64> {
 /// Checking these before serialization bounds host packing as well as the GPU uploads.
 fn packed_bytes(counts: [u64; 6], uniform_limit: u64, storage_limit: u64, buffer_limit: u64) -> Option<[u64; 7]> {
     let mut sizes = [0; 7];
-    sizes[0] = buffer_bytes(40, 4, uniform_limit.min(buffer_limit))?;
+    sizes[0] = buffer_bytes(44, 4, uniform_limit.min(buffer_limit))?;
     for (index, (count, stride)) in counts.into_iter().zip([96, 16, 16, 80, 80, 4]).enumerate() {
         let size = count.checked_mul(stride)?.max(16);
         sizes[index + 1] = buffer_bytes(size, 1, storage_limit.min(buffer_limit))?;
@@ -164,11 +164,11 @@ mod capability_tests {
 
     #[test]
     fn packed_arrays_preflight_exact_strides_and_empty_padding() {
-        assert_eq!(packed_bytes([0; 6], 160, 16, 160), Some([160, 16, 16, 16, 16, 16, 16]));
-        assert_eq!(packed_bytes([2; 6], 160, 192, 192), Some([160, 192, 32, 32, 160, 160, 16]));
-        assert!(packed_bytes([0; 6], 159, 16, 160).is_none());
-        assert!(packed_bytes([0; 6], 160, 15, 160).is_none());
-        assert!(packed_bytes([2; 6], 160, 192, 191).is_none());
+        assert_eq!(packed_bytes([0; 6], 176, 16, 176), Some([176, 16, 16, 16, 16, 16, 16]));
+        assert_eq!(packed_bytes([2; 6], 176, 192, 192), Some([176, 192, 32, 32, 160, 160, 16]));
+        assert!(packed_bytes([0; 6], 175, 16, 176).is_none());
+        assert!(packed_bytes([0; 6], 176, 15, 176).is_none());
+        assert!(packed_bytes([2; 6], 176, 192, 191).is_none());
         for index in 0..6 {
             let mut counts = [0; 6];
             counts[index] = u64::MAX;
@@ -203,7 +203,7 @@ mod capability_tests {
         };
         for (scene, counts) in [(Scene::default(), [0; 6]), (scene, [1; 6])] {
             let actual = pack(&scene).map(|bytes| bytes.len() as u64);
-            assert_eq!(Some(actual), packed_bytes(counts, 160, 160, 160));
+            assert_eq!(Some(actual), packed_bytes(counts, 176, 176, 176));
         }
     }
 }
@@ -315,10 +315,25 @@ fn pack(s: &Scene) -> [Vec<u8>; 7] {
     globals.extend([s.eye[0], s.eye[1], s.eye[2], s.ortho as u32 as f32]);
     globals.extend([s.cam_fwd[0], s.cam_fwd[1], s.cam_fwd[2], s.lights.len() as f32]);
     globals.extend([s.ambient[0], s.ambient[1], s.ambient[2], s.env.is_some() as u32 as f32]);
-    let e = s.env.unwrap_or(effectcraft_render::three_d::adv::EnvInfo { radiance: 0, mips: 1, irradiance: 0, intensity: 0.0, rotation: 0.0 });
+    let e = s.env.unwrap_or(effectcraft_render::three_d::adv::EnvInfo {
+        radiance: 0,
+        mips: 1,
+        irradiance: 0,
+        intensity: 0.0,
+        rotation: 0.0,
+        sun: [0.0; 3],
+        key: 0.0,
+        shadow: -1,
+        shadow_darkness: 0.0,
+        shadow_diffusion: 0.0,
+    });
     globals.extend([e.radiance as f32, e.mips as f32, e.irradiance as f32, e.intensity]);
     let lit = !(s.lights.is_empty() && s.env.is_none() && s.ambient == [0.0; 3]);
-    globals.extend([e.rotation, lit as u32 as f32, 0.0, 0.0]);
+    // env2: rotation, any lighting (0/1), shadow map index (-1 none), shadow darkness.
+    globals.extend([e.rotation, lit as u32 as f32, e.shadow as f32, e.shadow_darkness]);
+    // The environment's dominant direction (its shadow's source), for the shadow bias slope,
+    // and its key fraction — how much of its light the shadow can remove (shade::env_shadow).
+    globals.extend([e.sun[0], e.sun[1], e.sun[2], e.key]);
     let mats = s.materials.iter().flat_map(|m| {
         let flags = (m.double_sided as u32)
             | (m.unlit as u32) << 1
diff --git a/crates/gpu/src/bokeh.rs b/crates/gpu/src/bokeh.rs
index ac07448c9..a3f05bf12 100644
--- a/crates/gpu/src/bokeh.rs
+++ b/crates/gpu/src/bokeh.rs
@@ -10,8 +10,9 @@ use crate::context::{Enc, GpuImage, Params};
 
 /// Blur `src` (an unpadded plane buffer) as `d` says. Returns the padded, blurred image.
 pub(crate) fn apply(e: &mut Enc, src: &GpuImage, d: &PlaneDof) -> Option<GpuImage> {
-    let (w, h) = (src.width + 2 * d.pad, src.height + 2 * d.pad);
-    if !e.g.fits(w + 1, h) || d.radius.len() != w as usize * h as usize || d.levels.is_empty() {
+    // Saturating, so an oversized padding is refused by `fits` below instead of wrapping around.
+    let (w, h) = (src.width.saturating_add(d.pad.saturating_mul(2)), src.height.saturating_add(d.pad.saturating_mul(2)));
+    if !e.g.fits(w.saturating_add(1), h) || d.radius.len() != w as usize * h as usize || d.levels.is_empty() {
         return None;
     }
     let padded = e.image(w, h);
@@ -26,7 +27,7 @@ pub(crate) fn apply(e: &mut Enc, src: &GpuImage, d: &PlaneDof) -> Option<GpuImag
         padded
     };
     let prefix = e.image(w + 1, h);
-    e.dispatch("bokeh_prefix", &Params::default(), &boosted, None, &prefix, None, (h.div_ceil(64), 1));
+    e.dispatch("bokeh_prefix", &Params::default(), crate::context::KernelImages { src: &boosted, aux: None, out: &prefix }, None, (h.div_ceil(64), 1));
     // Radius map, then every level's spans.
     let mut data: Vec<f32> = d.radius.as_ref().clone();
     let mut levels = vec![];
diff --git a/crates/gpu/src/classic3d.rs b/crates/gpu/src/classic3d.rs
index 7ee2988f9..65dc52a6e 100644
--- a/crates/gpu/src/classic3d.rs
+++ b/crates/gpu/src/classic3d.rs
@@ -126,6 +126,10 @@ const LIGHT_BYTES: usize = 6 * 16;
 /// Composite a prepared Classic 3D run over `canvas`. `None` when it cannot run here (the
 /// caller draws it on the CPU).
 pub(crate) fn draw_run(e: &mut Enc, run: &Run3d, canvas: &GpuImage) -> Option<GpuImage> {
+    // FXC (DirectX 12) may fail to build the kernel (#613): the caller renders the run on the CPU.
+    if !e.g.has_kernel("classic3d") {
+        return None;
+    }
     let (w, h) = (canvas.width, canvas.height);
     let boxes: Vec<[i64; 4]> = run.planes.iter().filter(|p| p.draw).map(|p| p.bbox).collect();
     if boxes.is_empty() {
@@ -214,7 +218,14 @@ pub(crate) fn draw_run(e: &mut Enc, run: &Run3d, canvas: &GpuImage) -> Option<Gp
     let mut p = Params::default();
     p.u[0] = [run.planes.len() as u32, run.lights.len() as u32, run.casters.len() as u32, 0];
     let out = e.scratch(w, h);
-    e.dispatch_ext("classic3d", &p, &atlas, Some(canvas), &out, Some(&mb), (w.div_ceil(16), h.div_ceil(16)), Some([&pb, &gb, &lb, &cb]));
+    e.dispatch_ext(
+        "classic3d",
+        &p,
+        crate::context::KernelImages { src: &atlas, aux: Some(canvas), out: &out },
+        Some(&mb),
+        (w.div_ceil(16), h.div_ceil(16)),
+        Some([&pb, &gb, &lb, &cb]),
+    );
     Some(out)
 }
 
diff --git a/crates/gpu/src/context.rs b/crates/gpu/src/context.rs
index 52d27afe3..44e777b5a 100644
--- a/crates/gpu/src/context.rs
+++ b/crates/gpu/src/context.rs
@@ -30,7 +30,8 @@ const ENTRIES: &[&str] = &[
 const EFFECT_ENTRIES: &[&str] = &["box_h", "box_v", "directional", "glow_bright", "glow_combine", "shadow_make", "shadow_combine", "pointwise"];
 
 /// Entry points that also bind group 1 (four read-only storage buffers; see
-/// [`Enc::dispatch_ext`]).
+/// [`Enc::dispatch_ext`]). Like the effect kernels, one that fails to build (FXC on DirectX 12
+/// can't unroll `classic3d`'s loops, #613) leaves its work to the CPU.
 const EXT_ENTRIES: &[&str] = &["classic3d"];
 
 /// Pixel format of every working texture: premultiplied RGBA, 32-bit float (32 bpc headroom;
@@ -73,6 +74,8 @@ struct Lease {
     pool: Weak<Mutex<Pool>>,
     /// The [`Enc`] that took it (see [`Pool::owned`]).
     owner: u64,
+    /// The pool's [`Pool::generation`] when it was taken.
+    generation: u64,
 }
 
 impl std::fmt::Debug for Lease {
@@ -86,7 +89,7 @@ impl Drop for Lease {
         if let Some(pool) = self.pool.upgrade()
             && let Ok(mut p) = pool.lock()
         {
-            p.release_owned(self.texture.clone(), self.owner);
+            p.release_owned(self.texture.clone(), self.owner, self.generation);
         }
     }
 }
@@ -117,6 +120,8 @@ pub(crate) struct Pool {
     /// working texture of another `Enc` before it is gone.
     owned: HashMap<u64, HashMap<(u32, u32), Vec<wgpu::Texture>>>,
     next_owner: u64,
+    /// Raised by [`Pool::discard`]: a texture taken before it never comes back to the pool.
+    generation: u64,
 }
 
 /// In-`Enc` texture reuse ([`Pool::owned`]); tests turn it off to compare.
@@ -275,7 +280,10 @@ impl Pool {
         }
     }
 
-    fn release_owned(&mut self, t: wgpu::Texture, owner: u64) {
+    fn release_owned(&mut self, t: wgpu::Texture, owner: u64, generation: u64) {
+        if generation != self.generation {
+            return;
+        }
         if let Some(m) = self.owned.get_mut(&owner) {
             m.entry((t.width(), t.height())).or_default().push(t);
             return;
@@ -305,6 +313,18 @@ impl Pool {
         self.free.clear();
         self.bytes = 0;
     }
+
+    /// After a failed frame (#1319): drop every kept texture, the free ones and those waiting
+    /// for an open encoder or kept by one, and the textures still out never return. The
+    /// encoders' bookkeeping stays, so reuse remains ordered.
+    fn discard(&mut self) {
+        self.clear();
+        self.released.clear();
+        for kept in self.owned.values_mut() {
+            kept.clear();
+        }
+        self.generation = self.generation.wrapping_add(1);
+    }
 }
 
 /// Uniform parameter block shared by every kernel (see `shaders/common.wgsl`).
@@ -351,6 +371,7 @@ pub struct GpuContext {
     pub queue: wgpu::Queue,
     pub(crate) name: String,
     pub(crate) max_dim: u32,
+    pub(crate) median_kernel: crate::fx_noise::MedianKernel,
     bgl: wgpu::BindGroupLayout,
     bgl_ext: wgpu::BindGroupLayout,
     pipelines: HashMap<&'static str, wgpu::ComputePipeline>,
@@ -383,6 +404,12 @@ pub struct GpuContext {
     pub(crate) particle_states: crate::particles::StatesCell,
     /// Deferred readbacks (a browser worker's WebGPU device), see [`crate::deferred`].
     pub(crate) deferred: Option<Arc<crate::deferred::Deferred>>,
+    /// The adapter is a software rasteriser (llvmpipe, WARP): its float maths follows the
+    /// CPU's exactly, so the YUV tests hold it to exact parity.
+    #[cfg_attr(not(test), allow(dead_code))]
+    pub(crate) software: bool,
+    /// Export frame → YUV 4:2:0 kernel (built on first use).
+    pub(crate) yuv: std::sync::OnceLock<Result<crate::yuv::YuvPipe, String>>,
     readbacks: Arc<crate::readback::Readbacks>,
 }
 
@@ -436,7 +463,7 @@ pub(crate) fn init_resource<T>(device: &wgpu::Device, label: &str, create: impl
 /// Browser scope completion is asynchronous. Preserve the existing browser constructor;
 /// never block its event loop or introduce a guard across an asynchronous boundary here.
 #[cfg(target_arch = "wasm32")]
-fn init_resource<T>(_device: &wgpu::Device, _label: &str, create: impl FnOnce() -> T) -> Result<T, String> {
+pub(crate) fn init_resource<T>(_device: &wgpu::Device, _label: &str, create: impl FnOnce() -> T) -> Result<T, String> {
     Ok(create())
 }
 
@@ -481,6 +508,9 @@ impl GpuContext {
     /// [`Self::device_failure_notifier`] for immediate readback cancellation.
     pub fn new(adapter: &wgpu::Adapter, device: wgpu::Device, queue: wgpu::Queue) -> Result<GpuContext, String> {
         let info = adapter.get_info();
+        let median_kernel = crate::fx_noise::MedianKernel::for_adapter(info.backend, info.device_type);
+        #[cfg(test)]
+        let median_kernel = median_kernel.test_override()?;
         if !adapter.get_downlevel_capabilities().flags.contains(wgpu::DownlevelFlags::COMPUTE_SHADERS) {
             return Err(format!("{} ({:?}): no compute shaders", info.name, info.backend));
         }
@@ -500,6 +530,7 @@ impl GpuContext {
             ("max_compute_workgroup_size_x", l.max_compute_workgroup_size_x, 64),
             ("max_compute_workgroup_size_y", l.max_compute_workgroup_size_y, 16),
             ("max_compute_invocations_per_workgroup", l.max_compute_invocations_per_workgroup, 256),
+            ("max_compute_workgroup_storage_size", l.max_compute_workgroup_storage_size, median_kernel.workgroup_storage()),
         ];
         if let Some((limit, have, need)) = needs.iter().find(|(_, have, need)| have < need) {
             return Err(format!("{} ({:?}): device limit {limit} is {have}, needs {need}", info.name, info.backend));
@@ -525,6 +556,7 @@ impl GpuContext {
             include_str!("shaders/fx_key.wgsl"),
             include_str!("shaders/fx_stylize.wgsl"),
             include_str!("shaders/fx_noise.wgsl"),
+            median_kernel.source(),
             include_str!("shaders/fx_tone.wgsl"),
             include_str!("shaders/fx_warp.wgsl"),
             include_str!("shaders/fx_extra.wgsl"),
@@ -610,15 +642,21 @@ impl GpuContext {
             })
         };
         // The compositor's own kernels are required; an effect kernel that doesn't build is
-        // left out, and its effects render on the CPU (see `Enc::take_missing`).
-        let mut pipelines = ENTRIES
-            .iter()
-            .chain(crate::adv3d::SKY_KERNELS)
-            .map(|e| (e, &layout))
-            .chain(EXT_ENTRIES.iter().map(|e| (e, &layout_ext)))
-            .map(|(e, layout)| Ok((*e, build(e, layout)?)))
-            .collect::<Result<HashMap<_, _>, String>>()?;
+        // left out, and its effects render on the CPU (see `Enc::take_missing`). So is a
+        // missing Classic 3D kernel: its 3D runs render on the CPU.
+        let mut pipelines = ENTRIES.iter().chain(crate::adv3d::SKY_KERNELS).map(|e| Ok((*e, build(e, &layout)?))).collect::<Result<HashMap<_, _>, String>>()?;
         let mut unavailable = vec![];
+        for e in EXT_ENTRIES {
+            match build(e, &layout_ext) {
+                Ok(p) => {
+                    pipelines.insert(*e, p);
+                }
+                Err(why) => {
+                    log::warn!("gpu {name}: kernel {e} unavailable, its 3D layers render on the CPU: {why}");
+                    unavailable.push((*e, why));
+                }
+            }
+        }
         for e in EFFECT_ENTRIES
             .iter()
             .chain(crate::fx_color::KERNELS)
@@ -706,6 +744,7 @@ impl GpuContext {
             queue,
             name,
             max_dim,
+            median_kernel,
             bgl,
             bgl_ext,
             pipelines,
@@ -724,6 +763,8 @@ impl GpuContext {
             transfers: Default::default(),
             zeros: Default::default(),
             adv3d: std::sync::OnceLock::new(),
+            yuv: std::sync::OnceLock::new(),
+            software: info.device_type == wgpu::DeviceType::Cpu,
             adv3d_raster: adv3d_unsupported.is_none(),
             particles: Default::default(),
             particle_states: Default::default(),
@@ -739,6 +780,18 @@ impl GpuContext {
         self.readbacks.check()
     }
 
+    /// Export frame → YUV 4:2:0 kernel, initialized once and `None` when shader or pipeline creation fails.
+    pub(crate) fn yuv_pipe(&self) -> Option<&crate::yuv::YuvPipe> {
+        self.yuv
+            .get_or_init(|| {
+                crate::yuv::YuvPipe::new(&self.device).inspect_err(|e| {
+                    log::warn!(target: "effectcraft_gpu", "yuv420 kernel unavailable: {e}");
+                })
+            })
+            .as_ref()
+            .ok()
+    }
+
     /// A notification hook for the owner of a shared device's error/loss handlers.
     /// Invoke it with diagnostic context when the host observes a device failure.
     /// It retires this context and settles pending readbacks without replacing any
@@ -900,6 +953,11 @@ impl GpuContext {
         &self.unavailable
     }
 
+    /// Whether kernel `entry` was built (an effect or Classic 3D kernel can be missing, #613).
+    pub(crate) fn has_kernel(&self, entry: &str) -> bool {
+        self.pipelines.contains_key(entry)
+    }
+
     /// Leave kernel `entry` out, as if it had failed to build (tests of the CPU fallback).
     #[cfg(test)]
     pub(crate) fn drop_kernel(&mut self, entry: &'static str) {
@@ -907,6 +965,49 @@ impl GpuContext {
         self.unavailable.push((entry, "dropped by a test".into()));
     }
 
+    /// A copy of this context sharing the same [`wgpu::Device`] and [`wgpu::Queue`] with
+    /// kernel `entry` left out, as if it had failed to build (tests of the CPU fallback
+    /// without opening a second device on `llvmpipe`).
+    #[cfg(test)]
+    pub(crate) fn without_kernel(&self, entry: &'static str) -> GpuContext {
+        let mut pipelines = self.pipelines.clone();
+        pipelines.remove(entry);
+        let mut unavailable = self.unavailable.clone();
+        unavailable.push((entry, "dropped by a test".into()));
+        GpuContext {
+            device: self.device.clone(),
+            queue: self.queue.clone(),
+            name: self.name.clone(),
+            max_dim: self.max_dim,
+            median_kernel: self.median_kernel,
+            bgl: self.bgl.clone(),
+            bgl_ext: self.bgl_ext.clone(),
+            pipelines,
+            unavailable,
+            display_bgl: self.display_bgl.clone(),
+            display: self.display.clone(),
+            display_mip: self.display_mip.clone(),
+            dummy_tex: self.dummy_tex.clone(),
+            dummy: self.dummy.clone(),
+            dummy_buf: self.dummy_buf.clone(),
+            uploads: Mutex::new(Uploads::default()),
+            upload_budget: std::sync::atomic::AtomicUsize::new(UPLOAD_BUDGET),
+            upload_full_warned: Default::default(),
+            pool: self.pool.clone(),
+            staging: Default::default(),
+            transfers: Default::default(),
+            zeros: Default::default(),
+            adv3d: std::sync::OnceLock::new(),
+            adv3d_raster: self.adv3d_raster,
+            particles: Default::default(),
+            particle_states: Default::default(),
+            deferred: self.deferred.clone(),
+            readbacks: self.readbacks.clone(),
+            software: self.software,
+            yuv: std::sync::OnceLock::new(),
+        }
+    }
+
     /// Bytes of readback staging buffers kept for reuse (tests).
     #[cfg(test)]
     pub(crate) fn staging_bytes(&self) -> u64 {
@@ -933,8 +1034,9 @@ impl GpuContext {
     }
 
     fn texture(&self, w: u32, h: u32) -> wgpu::Texture {
+        // Named with its size, so a GPU error about it says which texture failed (#1319).
         self.device.create_texture(&wgpu::TextureDescriptor {
-            label: None,
+            label: Some(&format!("working image {w}×{h}")),
             size: wgpu::Extent3d { width: w.max(1), height: h.max(1), depth_or_array_layers: 1 },
             mip_level_count: 1,
             sample_count: 1,
@@ -949,10 +1051,10 @@ impl GpuContext {
     /// one is zeroed.
     fn pooled(&self, w: u32, h: u32, owner: u64) -> (GpuImage, bool) {
         let (w, h) = (w.max(1), h.max(1));
-        let reused = self.pool.lock().ok().and_then(|mut p| p.take_owned(owner, w, h).or_else(|| p.take(w, h)));
+        let (reused, generation) = self.pool.lock().map(|mut p| (p.take_owned(owner, w, h).or_else(|| p.take(w, h)), p.generation)).unwrap_or((None, u64::MAX));
         let was_reused = reused.is_some();
         let texture = reused.unwrap_or_else(|| self.texture(w, h));
-        let lease = Arc::new(Lease { texture: texture.clone(), pool: Arc::downgrade(&self.pool), owner });
+        let lease = Arc::new(Lease { texture: texture.clone(), pool: Arc::downgrade(&self.pool), owner, generation });
         (GpuImage { texture, width: w, height: h, _lease: Some(lease), levels: None }, was_reused)
     }
 
@@ -1068,6 +1170,21 @@ impl GpuContext {
             s.clear();
         }
     }
+
+    /// After a failed frame: forget every texture and buffer kept for reuse, since any of them
+    /// may be one the device rejected (#1319). Later frames allocate afresh.
+    pub fn discard_kept(&self) {
+        self.clear_uploads();
+        if let Ok(mut p) = self.pool.lock() {
+            p.discard();
+        }
+        if let Ok(mut z) = self.zeros.lock() {
+            z.clear();
+        }
+        if let Ok(mut c) = self.particle_states.lock() {
+            c.clear();
+        }
+    }
 }
 
 /// Records GPU work for one render (a command encoder submitted at readback or the end).
@@ -1082,6 +1199,13 @@ pub(crate) struct Enc<'g> {
     owner: u64,
 }
 
+/// Images bound to a compute kernel's source, optional auxiliary and output slots.
+pub(crate) struct KernelImages<'a> {
+    pub src: &'a GpuImage,
+    pub aux: Option<&'a GpuImage>,
+    pub out: &'a GpuImage,
+}
+
 impl Drop for Enc<'_> {
     fn drop(&mut self) {
         // Unsubmitted work is discarded, so nothing recorded will read pooled textures.
@@ -1155,32 +1279,21 @@ impl<'g> Enc<'g> {
     }
 
     /// Run kernel `entry` writing `out` (dispatched over `groups` workgroups).
-    pub fn dispatch(
-        &mut self,
-        entry: &str,
-        p: &Params,
-        src: &GpuImage,
-        aux: Option<&GpuImage>,
-        out: &GpuImage,
-        data: Option<&wgpu::Buffer>,
-        groups: (u32, u32),
-    ) {
-        self.dispatch_ext(entry, p, src, aux, out, data, groups, None);
+    pub fn dispatch(&mut self, entry: &str, p: &Params, images: KernelImages<'_>, data: Option<&wgpu::Buffer>, groups: (u32, u32)) {
+        self.dispatch_ext(entry, p, images, data, groups, None);
     }
 
     /// [`Enc::dispatch`] for the kernels in `EXT_ENTRIES`, with their group 1 storage buffers.
-    #[allow(clippy::too_many_arguments)]
     pub fn dispatch_ext(
         &mut self,
         entry: &str,
         p: &Params,
-        src: &GpuImage,
-        aux: Option<&GpuImage>,
-        out: &GpuImage,
+        images: KernelImages<'_>,
         data: Option<&wgpu::Buffer>,
         groups: (u32, u32),
         ext: Option<[&wgpu::Buffer; 4]>,
     ) {
+        let KernelImages { src, aux, out } = images;
         let g = self.g;
         let Some(pipe) = g.pipelines.get(entry) else {
             if !g.unavailable.iter().any(|(e, _)| *e == entry) {
@@ -1236,7 +1349,7 @@ impl<'g> Enc<'g> {
     /// Per-pixel kernel over `out`'s size (16×16 workgroups).
     pub fn pixels(&mut self, entry: &str, p: &Params, src: &GpuImage, aux: Option<&GpuImage>, out: &GpuImage, data: Option<&wgpu::Buffer>) {
         let groups = (out.width.div_ceil(16), out.height.div_ceil(16));
-        self.dispatch(entry, p, src, aux, out, data, groups);
+        self.dispatch(entry, p, KernelImages { src, aux, out }, data, groups);
     }
 
     /// Copy `src` into a larger zeroed image at (`x`, `y`) (Buf::pad).
diff --git a/crates/gpu/src/effects.rs b/crates/gpu/src/effects.rs
index 5041582f9..5a2b80f1c 100644
--- a/crates/gpu/src/effects.rs
+++ b/crates/gpu/src/effects.rs
@@ -2,7 +2,6 @@
 //! radii, parameter conversions), with the pixel loops as compute kernels.
 
 use effectcraft_effects::{Buf, EffectCtx};
-use effectcraft_geom::{Mat3, vec2};
 use effectcraft_raster::Sampling;
 use effectcraft_render::FxStep;
 
@@ -23,12 +22,45 @@ pub(crate) struct GBuf {
 }
 
 impl GBuf {
+    /// [`effectcraft_effects::Buf::cover`] on the device; `None` when it can't hold it.
+    pub fn cover(&mut self, e: &mut Enc, size: [f64; 2]) -> Option<()> {
+        let Some((dx, dy, w, h)) = effectcraft_effects::cover_plan(self.offset, self.scale, size, self.img.width, self.img.height) else { return Some(()) };
+        if !e.g.fits(w, h) {
+            return None;
+        }
+        let out = e.image(w, h);
+        e.copy_into(&self.img, &out, dx, dy);
+        self.img = out;
+        self.offset[0] += dx as f64;
+        self.offset[1] += dy as f64;
+        Some(())
+    }
+
     pub fn to_px(&self, p: [f64; 2]) -> (f64, f64) {
         (p[0] * self.scale + self.offset[0], p[1] * self.scale + self.offset[1])
     }
 
+    /// Buf::pad_sides: grow by transparent pixels (left, top, right, bottom).
+    pub fn pad_sides(&mut self, e: &mut Enc, sides: [u32; 4]) -> Option<()> {
+        let [l, t, r, b] = sides;
+        if l == 0 && t == 0 && r == 0 && b == 0 {
+            return Some(());
+        }
+        let (w, h) = (self.img.width.checked_add(l)?.checked_add(r)?, self.img.height.checked_add(t)?.checked_add(b)?);
+        if !e.g.fits(w, h) {
+            return None;
+        }
+        let out = e.image(w, h);
+        e.copy_into(&self.img, &out, l, t);
+        self.img = out;
+        self.offset[0] += l as f64;
+        self.offset[1] += t as f64;
+        Some(())
+    }
+
     /// Buf::pad: grow by `pad` transparent pixels on every side.
     pub fn pad(&mut self, e: &mut Enc, pad: u32) -> Option<()> {
+        let pad = effectcraft_effects::pad_within_budget(self.img.width, self.img.height, pad);
         if pad == 0 {
             return Some(());
         }
@@ -149,12 +181,23 @@ impl effectcraft_render::FxTarget for GpuFx<'_, '_> {
     /// GBuf::cover, like `pad`: a bigger texture with the old one copied into place, no
     /// readback. A region the device can't allocate leaves the buffer as it is.
     fn cover(&mut self, size: [f64; 2]) {
+        let Some(mut b) = self.b.take() else { return };
+        let keep = (b.img.clone(), b.offset);
+        if b.cover(self.e, size).is_none() {
+            (b.img, b.offset) = keep;
+        }
+        self.b = Some(b);
+    }
+
+    /// [`effectcraft_effects::Buf::align`] on the device: a texture grown left/top, the old one
+    /// copied in. A size the device can't allocate leaves the buffer as it is.
+    fn align(&mut self, size: [f64; 2]) {
         let Some(b) = self.b.take() else { return };
-        let out = match effectcraft_effects::cover_plan(b.offset, b.scale, size, b.img.width, b.img.height) {
-            Some((dx, dy, w, h)) if self.e.g.fits(w, h) => {
-                let img = self.e.image(w, h);
-                self.e.copy_into(&b.img, &img, dx, dy);
-                GBuf { img, offset: [b.offset[0] + dx as f64, b.offset[1] + dy as f64], scale: b.scale }
+        let out = match effectcraft_effects::align_plan(b.offset, b.scale, size, b.img.width, b.img.height) {
+            Some((l, t)) if self.e.g.fits(b.img.width + l, b.img.height + t) => {
+                let img = self.e.image(b.img.width + l, b.img.height + t);
+                self.e.copy_into(&b.img, &img, l, t);
+                GBuf { img, offset: [b.offset[0] + l as f64, b.offset[1] + t as f64], scale: b.scale }
             }
             _ => b,
         };
@@ -234,7 +277,13 @@ pub(crate) fn box_passes(e: &mut Enc, img: &GpuImage, rx: &[usize], ry: &[usize]
         let mut p = Params::default();
         p.u[0] = [r as u32, repeat as u32, block, 0];
         let out = e.scratch(cur.width, cur.height);
-        e.dispatch(if vertical { "box_v" } else { "box_h" }, &p, &cur, None, &out, None, (lines.div_ceil(64), n.div_ceil(block)));
+        e.dispatch(
+            if vertical { "box_v" } else { "box_h" },
+            &p,
+            crate::context::KernelImages { src: &cur, aux: None, out: &out },
+            None,
+            (lines.div_ceil(64), n.div_ceil(block)),
+        );
         cur = out;
     }
     cur
@@ -268,6 +317,9 @@ fn gaussian(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
     let repeat = ctx.params.b("repeatEdge");
     if !repeat && !ctx.adjustment {
         b.pad(e, (s * 3.0).ceil() as u32)?;
+    } else if repeat && !ctx.adjustment {
+        // The edge it repeats is the layer's, not the painted content's (#1205).
+        b.cover(e, ctx.layer_size)?;
     }
     b.img = gaussian_blur(e, &b.img, s * kx, s * ky, repeat || ctx.adjustment);
     Some(b)
@@ -288,6 +340,9 @@ fn box_blur(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
     let repeat = ctx.params.b("repeatEdge");
     if !repeat && !ctx.adjustment {
         b.pad(e, (r * it) as u32 + 1)?;
+    } else if repeat && !ctx.adjustment {
+        // The edge it repeats is the layer's, not the painted content's (#1205).
+        b.cover(e, ctx.layer_size)?;
     }
     b.img = box_passes(e, &b.img, &vec![r * kx as usize; it], &vec![r * ky as usize; it], repeat || ctx.adjustment);
     Some(b)
@@ -333,10 +388,11 @@ fn glow(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
     p.f[2] = cb;
     let bright = e.image(b.img.width, b.img.height);
     e.pixels("glow_bright", &p, &b.img, None, &bright, None);
-    let s = (radius / 2.0).max(0.5);
+    let s = effectcraft_effects::glow_sigma(radius);
     let blurred = gaussian_blur(e, &bright, s * kx, s * ky, false);
     let mut p = Params::default();
     p.u[0][0] = ctx.params.e("operation").min(2);
+    p.u[0][1] = (ctx.params.e("based") == 0) as u32;
     p.f[0][0] = intensity;
     let out = e.scratch(b.img.width, b.img.height);
     e.pixels("glow_combine", &p, &b.img, Some(&blurred), &out, None);
@@ -378,19 +434,17 @@ fn transform(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
     if ctx.env.host.is_some() && effectcraft_effects::transform_shutter(ctx).is_some() {
         return None;
     }
-    let anchor = b.to_px(ctx.params.v2("anchor"));
-    let pos = b.to_px(ctx.params.v2("position"));
-    let sh = ctx.params.f("scaleHeight");
-    let sw = if ctx.params.b("uniform") { sh } else { ctx.params.f("scaleWidth") };
     let opacity = ctx.params.f("opacity") as f32 / 100.0;
-    let m = Mat3::translate(vec2(pos.0, pos.1))
-        * Mat3::rotate_deg(ctx.params.f("rotation"))
-        * Mat3::skew_deg(ctx.params.f("skew"), ctx.params.f("skewAxis"))
-        * Mat3::scale(vec2(sw / 100.0, sh / 100.0))
-        * Mat3::translate(vec2(-anchor.0, -anchor.1));
+    // As distort::transform: After Effects' matrix, drawn outside the layer's bounds.
+    if !ctx.adjustment {
+        let m = effectcraft_effects::transform_matrix_px(ctx.params, |p| b.to_px(p));
+        let sides = effectcraft_effects::transform_grow(&[m], b.img.width, b.img.height);
+        b.pad_sides(e, sides)?;
+    }
+    let m = effectcraft_effects::transform_matrix_px(ctx.params, |p| b.to_px(p));
     let sampling = if ctx.params.e("sampling") == 1 { Sampling::Bicubic } else { Sampling::Bilinear };
     let empty = e.image(b.img.width, b.img.height);
-    b.img = ops::warp(e, &empty, &b.img, &m, sampling, effectcraft_color::BlendMode::Normal, opacity, 0, None);
+    b.img = ops::warp(e, &empty, &b.img, &m, ops::WarpOptions { sampling, mode: effectcraft_color::BlendMode::Normal, opacity, seed: 0 }, None);
     Some(b)
 }
 
@@ -537,9 +591,19 @@ fn pointwise(e: &mut Enc, id: &str, ctx: &EffectCtx, b: GBuf) -> Option<GBuf> {
             let sub = (f("subSettings/subScaling") / 100.0).clamp(0.1, 1.0);
             p.u[0] = [10, kind, octaves.ceil() as u32, f("evolutionOptions/seed") as u32 ^ 0x51ed];
             p.u[1] = [pr.b("invert") as u32, pr.e("overflow"), mode, 0];
-            p.f[0] = [f("contrast") as f32 / 100.0, f("brightness") as f32 / 100.0, (sw * b.scale).max(1.0) as f32, (octaves - octaves.floor()) as f32];
+            p.f[0] = [
+                f("contrast") as f32 / 100.0,
+                f("brightness") as f32 / 100.0,
+                (sw * effectcraft_effects::NOISE_CELL * b.scale).max(1.0) as f32,
+                (octaves - octaves.floor()) as f32,
+            ];
             p.f[1] = [ox as f32, oy as f32, sr, cr];
-            p.f[2] = [f("evolution") as f32 / 360.0, f("blend") as f32 / 100.0, (f("opacity") as f32 / 100.0).clamp(0.0, 1.0), (sh * b.scale).max(1.0) as f32];
+            p.f[2] = [
+                f("evolution") as f32 / 360.0,
+                f("blend") as f32 / 100.0,
+                (f("opacity") as f32 / 100.0).clamp(0.0, 1.0),
+                (sh * effectcraft_effects::NOISE_CELL * b.scale).max(1.0) as f32,
+            ];
             p.f[3] = [(f("subSettings/subInfluence") as f32 / 100.0).clamp(0.0, 1.0), 1.0 / sub as f32, 0.0, 0.0];
         }
         _ => return None,
diff --git a/crates/gpu/src/fx_depth.rs b/crates/gpu/src/fx_depth.rs
index 1bb0e49e1..eb2a96adb 100644
--- a/crates/gpu/src/fx_depth.rs
+++ b/crates/gpu/src/fx_depth.rs
@@ -280,7 +280,7 @@ fn cryptomatte(e: &mut Enc, ctx: &EffectCtx, b: GBuf, a: &AuxChannels) -> Option
     // cores with the rank planes resolved once.
     // The ID colours are only read by the Colors display; Matte, Preview and Matte Only need the
     // matte alone.
-    // `tests_fx_depth::cryptomatte_every_display_matches_the_cpu` guards this against the shader.
+    // `tests::fx_depth::cryptomatte_every_display_matches_the_cpu` guards this against the shader.
     let what = effectcraft_effects::CryptoAux::for_display(pr.e("display"), pr.b("matteOnly"));
     let img = effectcraft_effects::crypto_aux_image_with(a, &layer, &sel, what);
     let tex = e.g.upload_image(&img)?;
diff --git a/crates/gpu/src/fx_distort.rs b/crates/gpu/src/fx_distort.rs
index ce7133822..510f91e8c 100644
--- a/crates/gpu/src/fx_distort.rs
+++ b/crates/gpu/src/fx_distort.rs
@@ -180,6 +180,9 @@ fn turbulent(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
     let size = (ctx.params.f("size") * b.scale).max(1.0);
     if ctx.params.b("resizeLayer") && !ctx.adjustment {
         b.pad(e, amount.abs().ceil() as u32 + 1)?;
+    } else {
+        // Room for pixels displaced past the content, up to the layer's edge (#1205).
+        b.pad(e, effectcraft_effects::cover_pad(ctx, [b.img.width, b.img.height], b.offset, b.scale, amount.abs().ceil() as u32 + 1))?;
     }
     let off = b.to_px(ctx.params.v2("offset"));
     let oct = ctx.params.f("complexity").clamp(1.0, 10.0);
diff --git a/crates/gpu/src/fx_generate.rs b/crates/gpu/src/fx_generate.rs
index 0089dd4f4..d0c96a029 100644
--- a/crates/gpu/src/fx_generate.rs
+++ b/crates/gpu/src/fx_generate.rs
@@ -165,7 +165,7 @@ fn camera_lens(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
             return None;
         }
         let pre = e.image(w + 1, h);
-        e.dispatch("gen_row_prefix", &Params::default(), &src, None, &pre, None, (h.div_ceil(64), 1));
+        e.dispatch("gen_row_prefix", &Params::default(), crate::context::KernelImages { src: &src, aux: None, out: &pre }, None, (h.div_ceil(64), 1));
         Some(pre)
     } else {
         None
@@ -207,55 +207,53 @@ fn linear_wipe(e: &mut Enc, ctx: &EffectCtx, b: GBuf) -> Option<GBuf> {
 }
 
 fn venetian(e: &mut Enc, ctx: &EffectCtx, b: GBuf) -> Option<GBuf> {
-    let done = ctx.params.f("completion") / 100.0;
+    let done = (ctx.params.f("completion") / 100.0).clamp(0.0, 1.0);
+    if done <= 0.0 {
+        return Some(b);
+    }
     let ang = ctx.params.f("direction").to_radians();
     let width = (ctx.params.f("width") * b.scale).max(1.0);
-    let feather = (ctx.params.f("feather") * b.scale).max(0.001);
+    let sigma = ctx.params.f("feather").max(0.0) * b.scale / 2.0;
+    // The CPU's even veil and term count (effects::venetian_cover).
+    if sigma > 8.0 * width {
+        return None;
+    }
     let (dx, dy) = (ang.cos(), ang.sin());
-    let mut data = Vec::with_capacity((6 * b.img.width + 2 * b.img.height) as usize);
+    let (ox, oy) = b.to_px(effectcraft_effects::venetian_origin(ctx.layer_size));
+    let mut data = Vec::with_capacity((4 * b.img.width + 2 * b.img.height) as usize);
     for x in 0..b.img.width {
-        let cx = ((x as f64 + 0.5) * dx).rem_euclid(width);
-        data.extend(hl(cx - done * width));
-        data.extend(hl(cx - width - done * width));
+        let cx = ((x as f64 + 0.5 - ox) * dx).rem_euclid(width);
+        data.extend(hl(cx));
         data.extend(hl(cx - width));
     }
     for y in 0..b.img.height {
-        data.extend(hl(((y as f64 + 0.5) * dy).rem_euclid(width)));
+        data.extend(hl(((y as f64 + 0.5 - oy) * dy).rem_euclid(width)));
     }
     let mut p = Params::default();
-    p.u[0][0] = 6 * b.img.width;
-    p.f[0][0] = feather as f32;
+    p.u[0][0] = 4 * b.img.width;
+    p.u[0][1] = if sigma < 1e-3 { 0 } else { ((4.0 * sigma / width).ceil() as u32 + 1).clamp(1, 40) };
+    p.f[0] = [width as f32, (done * width) as f32, sigma as f32, 0.0];
     run(e, "gen_venetian", &p, b, None, Some(&data))
 }
 
 fn radial_wipe(e: &mut Enc, ctx: &EffectCtx, b: GBuf) -> Option<GBuf> {
-    let done = ctx.params.f("completion") / 100.0;
+    let done = (ctx.params.f("completion") / 100.0).clamp(0.0, 1.0);
+    if done <= 0.0 {
+        return Some(b);
+    }
     let start = ctx.params.f("startAngle");
     let c = b.to_px(ctx.params.v2("center"));
-    let dir = ctx.params.e("wipe");
-    let feather = ctx.params.f("feather").max(0.01);
-    let edge = if dir == 2 { done * 180.0 } else { done * 360.0 };
-    // Rotations: the start angle, and the start angle ± the edge (where the wipe's edge lies).
-    let rots = [start, start + edge, start - edge].map(|r| r.to_radians().sin_cos());
-    let mut data = Vec::with_capacity(9 * (b.img.width + b.img.height) as usize);
-    for x in 0..b.img.width {
-        let ux = x as f64 + 0.5 - c.0;
-        for (s, co) in rots {
-            data.extend(hl(ux * co));
-            data.push((ux * s) as f32);
-        }
-    }
-    for y in 0..b.img.height {
-        let uy = -(y as f64 + 0.5 - c.1);
-        for (s, co) in rots {
-            data.extend(hl(uy * s));
-            data.push((uy * co) as f32);
-        }
-    }
+    let (w0, span) = effectcraft_effects::radial_wipe_wedge(ctx.params.e("wipe"), done);
+    let sigma = effectcraft_effects::radial_wipe_sigma(ctx.params.f("feather")) * b.scale;
+    let ray0 = start + w0;
+    let (s0, c0) = ray0.to_radians().sin_cos();
+    let (s1, c1) = (ray0 + span).to_radians().sin_cos();
     let mut p = Params::default();
-    p.u[0] = [9 * b.img.width, dir.min(2), 0, 0];
-    p.f[0] = [edge as f32, feather as f32, 0.0, 0.0];
-    run(e, "gen_radial_wipe", &p, b, None, Some(&data))
+    p.u[0] = [(done >= 1.0) as u32, (sigma < 1e-3) as u32, 0, 0];
+    p.f[0] = [c.0 as f32, c.1 as f32, sigma.max(1e-3) as f32, ray0.rem_euclid(360.0) as f32];
+    p.f[1] = [s0 as f32, c0 as f32, s1 as f32, c1 as f32];
+    p.f[2][0] = span as f32;
+    run(e, "gen_radial_wipe", &p, b, None, None)
 }
 
 fn gradient_wipe(e: &mut Enc, ctx: &EffectCtx, b: GBuf) -> Option<GBuf> {
diff --git a/crates/gpu/src/fx_noise.rs b/crates/gpu/src/fx_noise.rs
index 1a20aa453..22f23fd86 100644
--- a/crates/gpu/src/fx_noise.rs
+++ b/crates/gpu/src/fx_noise.rs
@@ -73,6 +73,53 @@ pub(crate) const IDS: &[&str] = &[
 /// not its square.
 pub(crate) const MEDIAN_BISECT_R: usize = 4;
 
+/// Physical GPUs retain the original parallel private histogram. Software Vulkan
+/// uses bounded workgroup storage to avoid its expensive first-use private-array
+/// lowering. This trades some warmed software throughput for bounded first use.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum MedianKernel {
+    Private64,
+    Software2,
+}
+
+impl MedianKernel {
+    pub(crate) fn for_adapter(backend: wgpu::Backend, device_type: wgpu::DeviceType) -> Self {
+        if backend == wgpu::Backend::Vulkan && device_type == wgpu::DeviceType::Cpu { Self::Software2 } else { Self::Private64 }
+    }
+
+    pub(crate) fn rows_per_workgroup(self) -> u32 {
+        match self {
+            Self::Private64 => 64,
+            Self::Software2 => 2,
+        }
+    }
+
+    pub(crate) fn workgroup_storage(self) -> u32 {
+        match self {
+            Self::Private64 => 0,
+            Self::Software2 => 16_384,
+        }
+    }
+
+    pub(crate) fn source(self) -> &'static str {
+        match self {
+            Self::Private64 => include_str!("shaders/median_private.wgsl"),
+            Self::Software2 => include_str!("shaders/median_software.wgsl"),
+        }
+    }
+
+    /// Separate test processes can qualify both implementations against existing oracles.
+    #[cfg(test)]
+    pub(crate) fn test_override(self) -> Result<Self, String> {
+        match std::env::var("EFFECTCRAFT_TEST_MEDIAN_KERNEL") {
+            Err(std::env::VarError::NotPresent) => Ok(self),
+            Ok(value) if value == "private64" => Ok(Self::Private64),
+            Ok(value) if value == "software2" => Ok(Self::Software2),
+            value => Err(format!("invalid EFFECTCRAFT_TEST_MEDIAN_KERNEL {value:?}; expected private64 or software2")),
+        }
+    }
+}
+
 /// Run effect `id` (one of [`IDS`]); `None` = this parameter combination runs on the CPU.
 pub(crate) fn apply(e: &mut Enc, id: &str, ctx: &EffectCtx, b: GBuf) -> Option<GBuf> {
     match id {
@@ -166,7 +213,8 @@ pub(crate) fn median_image(e: &mut Enc, img: &GpuImage, r: usize, straight: bool
     // sliding along the rest.
     let seg = (4 * r as u32).clamp(32, 512).min(q.width);
     let out = e.scratch(q.width, q.height);
-    e.dispatch("fxn_median_huang", &with_u0([r as u32, seg, 0, 0]), &q, None, &out, Some(&levels), (q.height.div_ceil(64), q.width.div_ceil(seg)));
+    let groups = (q.height.div_ceil(e.g.median_kernel.rows_per_workgroup()), q.width.div_ceil(seg));
+    e.dispatch("fxn_median_huang", &with_u0([r as u32, seg, 0, 0]), crate::context::KernelImages { src: &q, aux: None, out: &out }, Some(&levels), groups);
     out
 }
 
diff --git a/crates/gpu/src/fx_sim.rs b/crates/gpu/src/fx_sim.rs
index a2d2c24dd..944ca6c07 100644
--- a/crates/gpu/src/fx_sim.rs
+++ b/crates/gpu/src/fx_sim.rs
@@ -253,6 +253,7 @@ fn bubbles(e: &mut Enc, ctx: &EffectCtx, b: GBuf, geo: &effectcraft_effects::Buf
     }
     let mut p = Params::default();
     p.u[1] = [0, (ctx.params.e("reflectionType") == 1) as u32, ctx.params.e("shadingType"), 0];
+    p.f[0] = effectcraft_effects::bubble_sample_bounds(ctx, b.offset, b.scale);
     let img = raster(e, items, 1, false, &b.img, None, p, w, h)?;
     Some(GBuf { img, ..b })
 }
diff --git a/crates/gpu/src/fx_stylize.rs b/crates/gpu/src/fx_stylize.rs
index d53367e76..cc9045a41 100644
--- a/crates/gpu/src/fx_stylize.rs
+++ b/crates/gpu/src/fx_stylize.rs
@@ -879,7 +879,7 @@ fn corner_pin(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
     let o = b.to_px([0.0, 0.0]);
     let m = quad * Mat3::scale(vec2(1.0 / (w * b.scale), 1.0 / (h * b.scale))) * Mat3::translate(vec2(-o.0, -o.1));
     let empty = e.image(b.img.width, b.img.height);
-    b.img = ops::warp(e, &empty, &b.img, &m, Sampling::Bilinear, BlendMode::Normal, 1.0, 0, None);
+    b.img = ops::warp(e, &empty, &b.img, &m, ops::WarpOptions { sampling: Sampling::Bilinear, mode: BlendMode::Normal, opacity: 1.0, seed: 0 }, None);
     Some(b)
 }
 
@@ -937,11 +937,12 @@ pub(crate) fn glow(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBuf> {
         p.f[2] = ctx.params.color("colorB");
         e.pixels("glow_bright", &p, &b.img, None, &bright, None);
     }
-    let s = (radius / 2.0).max(0.5);
+    let s = effectcraft_effects::glow_sigma(radius);
     let blurred = gaussian_blur(e, &bright, s * kx, s * ky, false);
     let operation = ctx.params.e("operation");
     let glow_op = effectcraft_effects::glow_operation(ctx);
     let mut p = Params::default();
+    p.u[0][1] = (ctx.params.e("based") == 0) as u32;
     p.f[0][0] = intensity;
     let out = e.scratch(b.img.width, b.img.height);
     if operation == 0 && glow_op != BlendMode::Add {
@@ -963,15 +964,7 @@ pub(crate) fn transform_blur(ctx: &EffectCtx) -> bool {
 
 /// distort::transform_matrix.
 fn transform_matrix(pr: &effectcraft_effects::Params, b: &GBuf) -> Mat3 {
-    let anchor = b.to_px(pr.v2("anchor"));
-    let pos = b.to_px(pr.v2("position"));
-    let sh = pr.f("scaleHeight");
-    let sw = if pr.b("uniform") { sh } else { pr.f("scaleWidth") };
-    Mat3::translate(vec2(pos.0, pos.1))
-        * Mat3::rotate_deg(pr.f("rotation"))
-        * Mat3::skew_deg(pr.f("skew"), pr.f("skewAxis"))
-        * Mat3::scale(vec2(sw / 100.0, sh / 100.0))
-        * Mat3::translate(vec2(-anchor.0, -anchor.1))
+    effectcraft_effects::transform_matrix_px(pr, |p| b.to_px(p))
 }
 
 /// distort::transform's motion blur: the transform at Samples instants across the shutter,
@@ -981,15 +974,24 @@ pub(crate) fn transform(e: &mut Enc, ctx: &EffectCtx, mut b: GBuf) -> Option<GBu
     let host = ctx.env.host?;
     let sampling = if ctx.params.e("sampling") == 1 { Sampling::Bicubic } else { Sampling::Bilinear };
     let fd = 1.0 / ctx.fps();
+    let samples: Vec<effectcraft_effects::Params> =
+        (0..n).filter_map(|k| host.params_at(ctx.time + (phase + angle * k as f64 / (n - 1) as f64) / 360.0 * fd)).collect();
+    if samples.is_empty() {
+        // The CPU renders the frame sharp.
+        return None;
+    }
+    if !ctx.adjustment {
+        let ms: Vec<Mat3> = samples.iter().map(|pr| transform_matrix(pr, &b)).collect();
+        let sides = effectcraft_effects::transform_grow(&ms, b.img.width, b.img.height);
+        b.pad_sides(e, sides)?;
+    }
     let (w, h) = (b.img.width, b.img.height);
     let mut acc = e.image(w, h);
     let mut count = 0u32;
-    for k in 0..n {
-        let t = ctx.time + (phase + angle * k as f64 / (n - 1) as f64) / 360.0 * fd;
-        let Some(pr) = host.params_at(t) else { continue };
+    for pr in &samples {
         let op = pr.f("opacity") as f32 / 100.0;
         let empty = e.image(w, h);
-        let one = ops::warp(e, &empty, &b.img, &transform_matrix(&pr, &b), sampling, BlendMode::Normal, op, 0, None);
+        let one = ops::warp(e, &empty, &b.img, &transform_matrix(pr, &b), ops::WarpOptions { sampling, mode: BlendMode::Normal, opacity: op, seed: 0 }, None);
         let sum = e.image(w, h);
         e.pixels("fxs_add", &Params::default(), &acc, Some(&one), &sum, None);
         acc = sum;
diff --git a/crates/gpu/src/fx_vr.rs b/crates/gpu/src/fx_vr.rs
index e719d606f..438eeb661 100644
--- a/crates/gpu/src/fx_vr.rs
+++ b/crates/gpu/src/fx_vr.rs
@@ -181,7 +181,13 @@ fn sphere_blur(e: &mut Enc, img: &GpuImage, sigma: f64) -> GpuImage {
         let mut p = Params::default();
         p.u[0][0] = 256;
         let out = e.scratch(cur.width, cur.height);
-        e.dispatch("fxv_box_h", &p, &cur, None, &out, Some(&buf), (cur.height.div_ceil(64), cur.width.div_ceil(256)));
+        e.dispatch(
+            "fxv_box_h",
+            &p,
+            crate::context::KernelImages { src: &cur, aux: None, out: &out },
+            Some(&buf),
+            (cur.height.div_ceil(64), cur.width.div_ceil(256)),
+        );
         cur = out;
     }
     for &r in &radii {
@@ -192,7 +198,13 @@ fn sphere_blur(e: &mut Enc, img: &GpuImage, sigma: f64) -> GpuImage {
         let mut p = Params::default();
         p.u[0] = [block, r as u32, 0, 0];
         let out = e.scratch(cur.width, cur.height);
-        e.dispatch("fxv_box_v", &p, &cur, None, &out, None, (cur.width.div_ceil(64), cur.height.div_ceil(block)));
+        e.dispatch(
+            "fxv_box_v",
+            &p,
+            crate::context::KernelImages { src: &cur, aux: None, out: &out },
+            None,
+            (cur.width.div_ceil(64), cur.height.div_ceil(block)),
+        );
         cur = out;
     }
     cur
diff --git a/crates/gpu/src/lib.rs b/crates/gpu/src/lib.rs
index 1064a216d..c58ccd59e 100644
--- a/crates/gpu/src/lib.rs
+++ b/crates/gpu/src/lib.rs
@@ -83,6 +83,7 @@ mod ops;
 mod particles;
 mod readback;
 mod walk;
+mod yuv;
 
 use std::sync::Arc;
 
@@ -96,6 +97,29 @@ pub use wgpu;
 
 use crate::context::Enc;
 
+/// Why [`Gpu::within_memory`] discarded a frame.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum FrameError {
+    /// The GPU context is retired (device lost, a readback timed out, an uncaptured error).
+    Retired(String),
+    /// Out of video memory (or a driver reporting a failed allocation as an internal error),
+    /// with any validation errors it went on to cause.
+    Memory(String),
+    /// The device rejected a command with no allocation failure before it (an invalid texture
+    /// or parameters, #1319): a compositor bug, not memory pressure.
+    Validation(String),
+}
+
+impl std::fmt::Display for FrameError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FrameError::Retired(e) | FrameError::Memory(e) | FrameError::Validation(e) => f.write_str(e),
+        }
+    }
+}
+
+impl std::error::Error for FrameError {}
+
 /// The GPU compositor (cheap to clone; one device shared by all clones).
 #[derive(Clone)]
 pub struct Gpu {
@@ -264,33 +288,42 @@ impl Gpu {
         }
     }
 
-    /// Run work in native thread-local out-of-memory and internal-error scopes. A failed
-    /// result is discarded and cached allocations are released; callers can retry with a fresh
-    /// CPU renderer. Some drivers report a failed allocation as an internal error rather than
-    /// out-of-memory (Adreno's `ERROR_INITIALIZATION_FAILED`, #591), so both count.
+    /// Run work in native thread-local out-of-memory, internal-error and validation scopes. A
+    /// failed result is discarded and the textures and buffers kept for reuse are released;
+    /// callers can retry with a fresh CPU renderer. Some drivers report a failed allocation as an
+    /// internal error rather than out-of-memory (Adreno's `ERROR_INITIALIZATION_FAILED`, #591),
+    /// so both count. A failed allocation leaves an invalid texture whose use is then a
+    /// validation error (`Texture::create_view`, #1319): caught here, it fails this frame only
+    /// instead of retiring the GPU compositor for the session as an uncaptured error.
     /// Browser callers use the host/owned-device failure bridge and bounded readbacks instead
     /// of blocking their event loop on an error-scope future.
-    pub fn within_memory<T>(&self, f: impl FnOnce() -> T) -> Result<T, String> {
-        self.ctx.check_health()?;
+    pub fn within_memory<T>(&self, f: impl FnOnce() -> T) -> Result<T, FrameError> {
+        self.ctx.check_health().map_err(FrameError::Retired)?;
         #[cfg(not(target_arch = "wasm32"))]
         {
             let oom = self.ctx.device.push_error_scope(wgpu::ErrorFilter::OutOfMemory);
             let internal = self.ctx.device.push_error_scope(wgpu::ErrorFilter::Internal);
+            let validation = self.ctx.device.push_error_scope(wgpu::ErrorFilter::Validation);
             let out = f();
+            let validation = pollster::block_on(validation.pop());
             let internal = pollster::block_on(internal.pop());
             let oom = pollster::block_on(oom.pop());
-            match internal.or(oom) {
-                Some(e) => {
-                    self.ctx.clear_uploads();
-                    Err(e.to_string())
-                }
-                None => self.ctx.check_health().map(|()| out),
+            let memory = oom.is_some() || internal.is_some();
+            // The allocation failure first: a validation error is often its consequence.
+            let errors: Vec<String> = [oom, internal, validation].into_iter().flatten().map(|e| e.to_string()).collect();
+            if errors.is_empty() {
+                return self.ctx.check_health().map(|()| out).map_err(FrameError::Retired);
             }
+            // Its textures go back to the pool when dropped: drop them before emptying it.
+            drop(out);
+            self.ctx.discard_kept();
+            let errors = errors.join("; then: ");
+            Err(if memory { FrameError::Memory(errors) } else { FrameError::Validation(errors) })
         }
         #[cfg(target_arch = "wasm32")]
         {
             let out = f();
-            self.ctx.check_health().map(|()| out)
+            self.ctx.check_health().map(|()| out).map_err(FrameError::Retired)
         }
     }
 
@@ -339,6 +372,25 @@ impl Accelerator for Gpu {
         img
     }
 
+    fn comp_frame_yuv420(&self, r: &Renderer, comp: ItemId, t: Tick, bg: [f32; 3]) -> Option<Vec<u8>> {
+        self.ctx.check_health().ok()?;
+        if !self.ctx.can_readback() || self.ctx.deferred.is_some() {
+            return None;
+        }
+        // Sizes the kernel can't take fall back before any GPU work, not after a render.
+        let (w, h) = walk::frame_size(r, comp, t)?;
+        if !yuv::supported(w, h) || !yuv::fits_limits(w, h, &self.ctx.device.limits()) {
+            return None;
+        }
+        let yp = self.ctx.yuv_pipe()?;
+        let mut e = Enc::new(&self.ctx);
+        let img = walk::render(&mut e, r, comp, t)?;
+        let planes = yuv::convert(&mut e, yp, &img, bg)?;
+        // A device fault seen while the frame recorded makes the planes untrustworthy.
+        self.ctx.check_health().ok()?;
+        Some(planes)
+    }
+
     fn supports_effect(&self, id: &str) -> bool {
         self.ctx.check_health().is_ok() && self.ctx.can_readback() && effects::supports(id)
     }
@@ -407,59 +459,3 @@ impl effectcraft_effects::psim::ParticleSim for Gpu {
 
 #[cfg(test)]
 mod tests;
-#[cfg(test)]
-mod tests_3d;
-#[cfg(test)]
-mod tests_adjust;
-#[cfg(test)]
-mod tests_adv3d;
-#[cfg(test)]
-mod tests_deferred;
-#[cfg(test)]
-mod tests_deferred_jobs;
-#[cfg(test)]
-mod tests_fx_color;
-#[cfg(test)]
-mod tests_fx_depth;
-#[cfg(test)]
-mod tests_fx_distort;
-#[cfg(test)]
-mod tests_fx_extra;
-#[cfg(test)]
-mod tests_fx_gen2;
-#[cfg(test)]
-mod tests_fx_generate;
-#[cfg(test)]
-mod tests_fx_key;
-#[cfg(test)]
-mod tests_fx_light;
-#[cfg(test)]
-mod tests_fx_lut;
-#[cfg(test)]
-mod tests_fx_noise;
-#[cfg(test)]
-mod tests_fx_particles;
-#[cfg(test)]
-mod tests_fx_pixel2;
-#[cfg(test)]
-mod tests_fx_sim;
-#[cfg(test)]
-mod tests_fx_stylize;
-#[cfg(test)]
-mod tests_fx_text;
-#[cfg(test)]
-mod tests_fx_time;
-#[cfg(test)]
-mod tests_fx_tone;
-#[cfg(test)]
-mod tests_fx_transition;
-#[cfg(test)]
-mod tests_fx_vr;
-#[cfg(test)]
-mod tests_fx_warp;
-#[cfg(all(test, not(target_arch = "wasm32")))]
-mod tests_init;
-#[cfg(test)]
-mod tests_particles;
-#[cfg(test)]
-mod tests_wgsl_grammar;
diff --git a/crates/gpu/src/ops.rs b/crates/gpu/src/ops.rs
index c9e0900e9..30c8c9bea 100644
--- a/crates/gpu/src/ops.rs
+++ b/crates/gpu/src/ops.rs
@@ -32,37 +32,23 @@ pub fn half(e: &mut Enc, src: &GpuImage) -> GpuImage {
     out
 }
 
-/// `raster::composite_warp` (and, with `accumulate = Some(weight)`, `accumulate_warp`): draw
-/// `src` transformed by `m` (src pixels → dst pixels) onto `dst`.
-pub fn warp(
-    e: &mut Enc,
-    dst: &GpuImage,
-    src: &GpuImage,
-    m: &Mat3,
-    sampling: Sampling,
-    mode: BlendMode,
-    opacity: f32,
-    seed: u32,
-    accumulate: Option<f32>,
-) -> GpuImage {
-    warp_q(e, dst, src, m, sampling, mode, opacity, seed, accumulate, None)
+/// Sampling and blending policy for a transformed GPU image.
+pub struct WarpOptions {
+    pub sampling: Sampling,
+    pub mode: BlendMode,
+    pub opacity: f32,
+    pub seed: u32,
+}
+
+/// Draw `src` transformed by `m` onto `dst`, or accumulate it with a sample weight.
+pub fn warp(e: &mut Enc, dst: &GpuImage, src: &GpuImage, m: &Mat3, opts: WarpOptions, accumulate: Option<f32>) -> GpuImage {
+    warp_q(e, dst, src, m, opts, accumulate, None)
 }
 
 /// [`warp`], clamping and quantising the result to `levels` (8/16 bpc: the comp after a layer,
 /// in the same pass).
-#[allow(clippy::too_many_arguments)]
-pub fn warp_q(
-    e: &mut Enc,
-    dst: &GpuImage,
-    src: &GpuImage,
-    m: &Mat3,
-    sampling: Sampling,
-    mode: BlendMode,
-    opacity: f32,
-    seed: u32,
-    accumulate: Option<f32>,
-    levels: Option<f32>,
-) -> GpuImage {
+pub fn warp_q(e: &mut Enc, dst: &GpuImage, src: &GpuImage, m: &Mat3, opts: WarpOptions, accumulate: Option<f32>, levels: Option<f32>) -> GpuImage {
+    let WarpOptions { sampling, mode, opacity, seed } = opts;
     if src.width == 0 || src.height == 0 || opacity <= 0.0 {
         return dst.clone();
     }
diff --git a/crates/gpu/src/particles.rs b/crates/gpu/src/particles.rs
index 7934dee0c..9ac103557 100644
--- a/crates/gpu/src/particles.rs
+++ b/crates/gpu/src/particles.rs
@@ -23,16 +23,38 @@ struct Checkpoint {
     key: u64,
     steps: u64,
     n: u32,
+    /// The birth steps of its particles (see [`born`]).
+    born: u64,
     buf: wgpu::Buffer,
     used: u64,
 }
 
+/// The particles born in the first `steps` steps of `births` (ascending birth steps) and a hash
+/// of their birth steps: a checkpoint is only resumed from when the request's births before it
+/// are the same (a keyframed Birth Rate isn't part of the system key, #1373).
+fn born(births: &[u32], steps: u64) -> (u32, u64) {
+    let mut h = 0xcbf2_9ce4_8422_2325u64;
+    let mut n = 0u32;
+    for &b in births.iter().take_while(|&&b| u64::from(b) < steps) {
+        h = (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3);
+        n += 1;
+    }
+    (n, h)
+}
+
 #[derive(Default)]
 pub(crate) struct Checkpoints {
     list: Vec<Checkpoint>,
     clock: u64,
 }
 
+impl Checkpoints {
+    /// Forget every kept state (after a failed frame, whose buffers may be invalid).
+    pub(crate) fn clear(&mut self) {
+        self.list.clear();
+    }
+}
+
 fn pipes(g: &GpuContext) -> &Pipes {
     g.particles.get_or_init(|| {
         let d = &g.device;
@@ -106,6 +128,10 @@ fn uniforms(req: &SimRequest, n: u32, s0: u64, prev_n: u32) -> Vec<u8> {
     out
 }
 
+/// Simulations dispatched on the GPU (tests check the GPU path really ran).
+#[cfg(test)]
+pub(crate) static DISPATCHES: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+
 /// Simulate `req` (see [`effectcraft_effects::psim::ParticleSim`]).
 ///
 /// With deferred readbacks (a browser worker) the state's readback is keyed by the request
@@ -141,7 +167,7 @@ pub(crate) fn simulate(g: &GpuContext, req: &SimRequest) -> Option<Vec<SimPartic
         let mut c = g.particle_states.lock().ok()?;
         c.clock += 1;
         let now = c.clock;
-        match c.list.iter_mut().filter(|k| k.key == req.key && k.steps <= req.steps).max_by_key(|k| k.steps) {
+        match c.list.iter_mut().filter(|k| k.key == req.key && k.steps <= req.steps && born(req.births, k.steps) == (k.n, k.born)).max_by_key(|k| k.steps) {
             Some(k) => {
                 k.used = now;
                 (k.steps, Some(k.buf.clone()), k.n)
@@ -187,6 +213,8 @@ pub(crate) fn simulate(g: &GpuContext, req: &SimRequest) -> Option<Vec<SimPartic
     }
     enc.copy_buffer_to_buffer(&next, 0, &read, 0, size);
     g.queue.submit([enc.finish()]);
+    #[cfg(test)]
+    DISPATCHES.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
     if let (Some(d), Some(k)) = (&deferred, key) {
         let row = usize::try_from(size).ok()?;
         let done = d.start(k, n, 1, [0.0; 2], 1.0);
@@ -232,7 +260,8 @@ fn keep_checkpoint(g: &GpuContext, req: &SimRequest, n: u32, next: wgpu::Buffer)
     if let Ok(mut c) = g.particle_states.lock() {
         let now = c.clock;
         c.list.retain(|k| !(k.key == req.key && k.steps == req.steps));
-        c.list.push(Checkpoint { key: req.key, steps: req.steps, n, buf: next, used: now });
+        let (_, h) = born(req.births, req.steps);
+        c.list.push(Checkpoint { key: req.key, steps: req.steps, n, born: h, buf: next, used: now });
         while c.list.len() > CHECKPOINTS {
             let Some(i) = c.list.iter().enumerate().min_by_key(|(_, k)| k.used).map(|(i, _)| i) else { break };
             c.list.remove(i);
diff --git a/crates/gpu/src/readback.rs b/crates/gpu/src/readback.rs
index 0ca011350..b9d0a28a8 100644
--- a/crates/gpu/src/readback.rs
+++ b/crates/gpu/src/readback.rs
@@ -2,12 +2,15 @@
 // Browser callbacks stay on their worker thread. The workspace's wgpu feature still
 // requires Send callbacks on non-atomic wasm, and ParticleSim requires Send + Sync.
 use std::collections::BTreeMap;
+#[cfg(not(target_arch = "wasm32"))]
+use std::sync::Condvar;
 use std::sync::{Arc, Mutex, Weak};
 use std::time::Duration;
 
 pub(crate) const TIMEOUT: Duration = Duration::from_secs(10);
 pub(crate) type Error = String;
 type Done = Box<dyn FnOnce(Result<Vec<u8>, Error>) + Send>;
+const TIMED_OUT: &str = "GPU readback timed out; context retired";
 
 struct Entry {
     deadline: web_time::Instant,
@@ -20,9 +23,70 @@ struct State {
     retired: Option<Error>,
     #[cfg(target_arch = "wasm32")]
     timer_armed: bool,
+    /// The deadline worker is to exit: the context was dropped.
+    #[cfg(not(target_arch = "wasm32"))]
+    closed: bool,
+    /// How many times the deadline worker woke up (tests: it must not wake while idle).
+    #[cfg(all(test, not(target_arch = "wasm32")))]
+    worker_wakes: u64,
+}
+/// The state and, natively, the condition the deadline worker sleeps on. The worker owns an
+/// `Arc` of this, not of the [`Readbacks`], so it can block on the condition without keeping
+/// the context alive; dropping the context closes it.
+#[derive(Default)]
+struct Inner {
+    state: Mutex<State>,
+    #[cfg(not(target_arch = "wasm32"))]
+    wake: Condvar,
 }
 #[derive(Default)]
-pub(crate) struct Readbacks(Mutex<State>);
+pub(crate) struct Readbacks(Arc<Inner>);
+
+/// Retire the context when a deadline has passed: the entries to fail, or `None` when none
+/// is due (or it is retired already). Decides and drains under the lock the caller holds.
+fn expire_locked(s: &mut State, now: web_time::Instant) -> Option<Vec<Entry>> {
+    // Decide and drain atomically: a cancelled old deadline must not retire
+    // a newer request inserted between the deadline check and retirement.
+    if s.retired.is_some() || !s.pending.values().any(|e| now >= e.deadline) {
+        return None;
+    }
+    s.retired = Some(TIMED_OUT.to_string());
+    Some(std::mem::take(&mut s.pending).into_values().collect())
+}
+
+/// The deadline worker. It sleeps while nothing is pending, and otherwise exactly until the
+/// earliest deadline or until what is pending changes, so an idle context costs no wakeups
+/// (a 100 ms polling loop here was ten wakeups a second for the life of the app). When a
+/// deadline has passed it retires the context and fails every pending readback.
+#[cfg(not(target_arch = "wasm32"))]
+fn run_deadlines(inner: &Inner) {
+    let mut s = inner.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    loop {
+        if s.closed {
+            return;
+        }
+        let now = web_time::Instant::now();
+        match s.pending.values().map(|e| e.deadline).min() {
+            None => s = inner.wake.wait(s).unwrap_or_else(std::sync::PoisonError::into_inner),
+            Some(deadline) if deadline > now => {
+                s = inner.wake.wait_timeout(s, deadline - now).unwrap_or_else(std::sync::PoisonError::into_inner).0;
+            }
+            Some(_) => {
+                let expired = expire_locked(&mut s, now);
+                drop(s);
+                for entry in expired.into_iter().flatten() {
+                    notify(entry.done, Err(TIMED_OUT.into()));
+                }
+                s = inner.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+                continue;
+            }
+        }
+        #[cfg(test)]
+        {
+            s.worker_wakes += 1;
+        }
+    }
+}
 pub(crate) struct Ticket {
     owner: Weak<Readbacks>,
     id: u64,
@@ -50,23 +114,24 @@ impl Readbacks {
         let me = Arc::new(Self::default());
         #[cfg(not(target_arch = "wasm32"))]
         {
-            let weak = Arc::downgrade(&me);
+            let inner = Arc::clone(&me.0);
             std::thread::Builder::new()
                 .name("gpu-readback-deadlines".into())
-                .spawn(move || {
-                    loop {
-                        std::thread::sleep(Duration::from_millis(100));
-                        let Some(me) = weak.upgrade() else { break };
-                        me.expire(web_time::Instant::now());
-                    }
-                })
+                .spawn(move || run_deadlines(&inner))
                 .map_err(|e| format!("starting GPU readback deadline worker: {e}"))?;
         }
         Ok(me)
     }
 
+    /// Have the deadline worker look at what is pending again (natively; the browser's timer
+    /// re-arms itself).
+    fn poke(&self) {
+        #[cfg(not(target_arch = "wasm32"))]
+        self.0.wake.notify_one();
+    }
+
     pub(crate) fn check(&self) -> Result<(), Error> {
-        let s = self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+        let s = self.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
         match &s.retired {
             Some(e) => Err(e.clone()),
             None => Ok(()),
@@ -76,7 +141,7 @@ impl Readbacks {
     pub(crate) fn start(self: &Arc<Self>, done: impl FnOnce(Result<Vec<u8>, Error>) + wgpu::WasmNotSend + 'static) -> Result<Ticket, Error> {
         let mut done: Option<Done> = Some(Box::new(done));
         let result = {
-            let mut s = self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+            let mut s = self.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
             if let Some(e) = &s.retired {
                 Err(e.clone())
             } else if s.pending.len() >= 256 {
@@ -96,8 +161,10 @@ impl Readbacks {
         {
             notify(done, Err(e.clone()));
         }
-        #[cfg(target_arch = "wasm32")]
         if result.is_ok() {
+            // The worker may be asleep with nothing pending: this is its new earliest deadline.
+            self.poke();
+            #[cfg(target_arch = "wasm32")]
             self.arm_timer();
         }
         result
@@ -106,7 +173,7 @@ impl Readbacks {
     #[cfg(target_arch = "wasm32")]
     fn arm_timer(self: &Arc<Self>) {
         let delay = {
-            let mut s = self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+            let mut s = self.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
             if s.timer_armed || s.retired.is_some() {
                 return;
             }
@@ -123,13 +190,14 @@ impl Readbacks {
 
     pub(crate) fn retire(&self, error: Error) {
         let pending = {
-            let mut s = self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+            let mut s = self.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
             if s.retired.is_some() {
                 return;
             }
             s.retired = Some(error.clone());
             std::mem::take(&mut s.pending)
         };
+        self.poke();
         for (_, entry) in pending {
             notify(entry.done, Err(error.clone()));
         }
@@ -137,34 +205,49 @@ impl Readbacks {
 
     pub(crate) fn cancel_pending(&self, error: Error) {
         let pending = {
-            let mut s = self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+            let mut s = self.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
             std::mem::take(&mut s.pending)
         };
+        self.poke();
         for (_, entry) in pending {
             notify(entry.done, Err(error.clone()));
         }
     }
 
+    /// Retire the context when a deadline has passed (the browser's timer and tests; natively
+    /// the deadline worker does this itself).
+    #[cfg(any(test, target_arch = "wasm32"))]
     fn expire(&self, now: web_time::Instant) {
-        let error = "GPU readback timed out; context retired".to_string();
-        let pending = {
-            let mut s = self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
-            // Decide and drain atomically: a cancelled old deadline must not retire
-            // a newer request inserted between the deadline check and retirement.
-            if s.retired.is_some() || !s.pending.values().any(|e| now >= e.deadline) {
-                return;
-            }
-            s.retired = Some(error.clone());
-            std::mem::take(&mut s.pending)
+        let expired = {
+            let mut s = self.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+            expire_locked(&mut s, now)
         };
-        for (_, entry) in pending {
-            notify(entry.done, Err(error.clone()));
+        for entry in expired.into_iter().flatten() {
+            notify(entry.done, Err(TIMED_OUT.into()));
         }
     }
+
+    /// Move every pending deadline to `deadline` and wake the worker, as a test's stand-in for
+    /// waiting out the production timeout.
+    #[cfg(all(test, not(target_arch = "wasm32")))]
+    fn move_deadlines_for_test(&self, deadline: web_time::Instant) {
+        {
+            let mut s = self.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+            for entry in s.pending.values_mut() {
+                entry.deadline = deadline;
+            }
+        }
+        self.poke();
+    }
 }
 impl Drop for Readbacks {
     fn drop(&mut self) {
         self.retire("GPU readback context dropped".into());
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            self.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner).closed = true;
+            self.0.wake.notify_all();
+        }
     }
 }
 
@@ -194,12 +277,14 @@ impl Layout {
 
 impl Ticket {
     pub(crate) fn active(&self) -> bool {
-        self.owner.upgrade().is_some_and(|me| me.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner).pending.contains_key(&self.id))
+        self.owner.upgrade().is_some_and(|me| me.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner).pending.contains_key(&self.id))
     }
     pub(crate) fn complete(self, result: Result<Vec<u8>, Error>) {
         let Some(me) = self.owner.upgrade() else { return };
-        let entry = me.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner).pending.remove(&self.id);
+        let entry = me.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner).pending.remove(&self.id);
         if let Some(entry) = entry {
+            // Its deadline is gone: the worker sleeps until the next one, or until something new.
+            me.poke();
             notify(entry.done, result);
         }
     }
@@ -215,7 +300,7 @@ fn schedule(me: Weak<Readbacks>, delay: Duration) -> Result<(), Error> {
         .map_err(|_| "GPU deadline timer unavailable".to_string())?;
     let callback = Closure::once(move || {
         if let Some(me) = me.upgrade() {
-            me.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner).timer_armed = false;
+            me.0.state.lock().unwrap_or_else(std::sync::PoisonError::into_inner).timer_armed = false;
             me.expire(web_time::Instant::now());
             // If the earliest request completed, arm for the next live deadline.
             me.arm_timer();
@@ -377,7 +462,7 @@ mod tests {
         assert_eq!(deferred.in_flight(), 0);
         assert_eq!(wakes.0.load(Ordering::SeqCst), 1);
         assert!(matches!(settled.as_mut().poll(&mut Context::from_waker(&waker)), Poll::Ready(())));
-        assert!(me.0.lock().unwrap().pending.is_empty());
+        assert!(me.0.state.lock().unwrap().pending.is_empty());
         rx.recv_timeout(Duration::from_secs(2)).unwrap();
         rx.recv_timeout(Duration::from_secs(2)).unwrap();
 
@@ -390,17 +475,64 @@ mod tests {
                 tx2.send(()).unwrap();
             })
             .unwrap();
-        {
-            let mut state = me.0.lock().unwrap();
-            for entry in state.pending.values_mut() {
-                entry.deadline = web_time::Instant::now();
-            }
-        }
+        me.move_deadlines_for_test(web_time::Instant::now());
         rx.recv_timeout(Duration::from_secs(2)).unwrap();
-        assert!(me.0.lock().unwrap().pending.is_empty());
+        assert!(me.0.state.lock().unwrap().pending.is_empty());
         assert!(me.check().is_err());
     }
 
+    /// With nothing pending the deadline worker sleeps: no periodic wakeups (it used to poll
+    /// every 100 ms for the life of the app, ten wakeups a second while idle).
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))]
+    fn an_idle_deadline_worker_does_not_wake_up() {
+        let me = Readbacks::new().unwrap();
+        std::thread::sleep(Duration::from_millis(350));
+        let wakes = me.0.state.lock().unwrap().worker_wakes;
+        assert!(wakes <= 1, "the worker woke {wakes} times while nothing was pending");
+        // A readback that completes in time: the worker is told, and goes back to sleep.
+        let ticket = me.start(|r| assert!(r.is_ok())).unwrap();
+        ticket.complete(Ok(vec![1]));
+        std::thread::sleep(Duration::from_millis(350));
+        let wakes = me.0.state.lock().unwrap().worker_wakes;
+        assert!(wakes <= 3, "the worker woke {wakes} times for one completed readback");
+        assert!(me.check().is_ok());
+    }
+
+    /// A deadline that passes wakes the worker exactly then, without the old polling loop.
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))]
+    fn a_pending_deadline_wakes_the_worker_when_it_is_due() {
+        let me = Readbacks::new().unwrap();
+        let (tx, rx) = std::sync::mpsc::channel();
+        let _ticket = me
+            .start(move |r| {
+                assert!(r.is_err());
+                tx.send(web_time::Instant::now()).unwrap();
+            })
+            .unwrap();
+        let due = web_time::Instant::now() + Duration::from_millis(200);
+        me.move_deadlines_for_test(due);
+        let fired = rx.recv_timeout(Duration::from_secs(5)).expect("the deadline fires");
+        assert!(fired >= due, "fired {:?} early", due - fired);
+        assert!(fired < due + Duration::from_secs(2), "fired {:?} late", fired - due);
+        assert!(me.check().is_err());
+    }
+
+    /// Dropping the last handle lets the worker exit: it holds the state, not the context.
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))]
+    fn dropping_the_context_stops_the_deadline_worker() {
+        let me = Readbacks::new().unwrap();
+        let inner = Arc::downgrade(&me.0);
+        drop(me);
+        let t0 = web_time::Instant::now();
+        while inner.upgrade().is_some() {
+            assert!(t0.elapsed() < Duration::from_secs(5), "the worker is still holding the state");
+            std::thread::sleep(Duration::from_millis(10));
+        }
+    }
+
     #[test]
     fn missing_callback_times_out_once_and_rejects_late_success() {
         let me = Arc::new(Readbacks::default());
diff --git a/crates/gpu/src/shaders/advanced3d.wgsl b/crates/gpu/src/shaders/advanced3d.wgsl
index 4eea78c8c..8ac143ad0 100644
--- a/crates/gpu/src/shaders/advanced3d.wgsl
+++ b/crates/gpu/src/shaders/advanced3d.wgsl
@@ -14,8 +14,10 @@ struct Globals {
     ambient: vec4<f32>,
     // radiance first texture, mip count, irradiance texture, intensity
     env: vec4<f32>,
-    // rotation, any lighting (0/1), -, -
+    // rotation, any lighting (0/1), shadow map index (-1 none), shadow darkness
     env2: vec4<f32>,
+    // the environment's dominant direction (its shadow's source)
+    env_sun: vec4<f32>,
 };
 
 @group(0) @binding(0) var<uniform> g: Globals;
@@ -194,6 +196,25 @@ fn tap_hash(x: i32, y: i32) -> u32 {
     return h;
 }
 
+fn tap_jitter_at(x: i32, y: i32) -> vec2<f32> {
+    let h = tap_hash(x, y);
+    return vec2<f32>(f32(h & 0xFFFFu) * (1.0 / 65536.0) - 0.5, f32((h >> 16u) & 0xFFFFu) * (1.0 / 65536.0) - 0.5);
+}
+
+// shade::tap_jitter: the hash at the four corners of the receiver's 1/8-texel lattice
+// cell (cx, cy), blended bilinearly by the receiver's position w in the cell.
+fn tap_jitter(cx: i32, cy: i32, w: vec2<f32>, i: i32, j: i32) -> vec2<f32> {
+    let x = cx + i * 7919;
+    let y = cy + j * 7919;
+    let c00 = tap_jitter_at(x, y);
+    let c10 = tap_jitter_at(x + 1, y);
+    let c01 = tap_jitter_at(x, y + 1);
+    let c11 = tap_jitter_at(x + 1, y + 1);
+    let a = c00 + (c10 - c00) * w.x;
+    let b = c01 + (c11 - c01) * w.x;
+    return a + (b - a) * w.y;
+}
+
 const PCF_MAX_TAPS: i32 = 10;
 const PLANE_SLOPE_MAX: f32 = 64.0;
 
@@ -244,7 +265,8 @@ fn shadow_factor(m: u32, p: vec3<f32>, ng: vec3<f32>, n_l: f32) -> f32 {
     // shadows off their casters), each texel compared against the receiver plane's
     // depth at its centre so wide kernels never self-shadow a lit surface, an N×N grid
     // jittered by an integer hash (bit-identical across backends) of the sub-texel
-    // cell and tap index, and bilinear compares of the four nearest texel centres.
+    // lattice and tap index, blended across the receiver's lattice cell, and bilinear
+    // compares of the four nearest texel centers.
     // extra.y is the wanted penumbra in output pixels; dividing by the receiver's
     // texel footprint keeps it in output pixels at any map resolution, and the reach
     // is at least two texels so hard edges ramp over texel steps instead of showing them.
@@ -268,16 +290,17 @@ fn shadow_factor(m: u32, p: vec3<f32>, ng: vec3<f32>, n_l: f32) -> f32 {
     let n = clamp(i32(ceil(reach)) + 1, 5, PCF_MAX_TAPS);
     let step = reach / f32(n - 1);
     let half = f32(n - 1) * 0.5;
-    let cx = i32(floor(u * 8.0));
-    let cy = i32(floor(v * 8.0));
+    let gu = u * 8.0;
+    let gv = v * 8.0;
+    let cx = i32(floor(gu));
+    let cy = i32(floor(gv));
+    let wc = vec2<f32>(gu - floor(gu), gv - floor(gv));
     var lit = 0.0;
     for (var j = 0; j < n; j = j + 1) {
         for (var i = 0; i < n; i = i + 1) {
-            let h = tap_hash(cx + i * 7919, cy + j * 7919);
-            let jx = f32(h & 0xFFFFu) * (1.0 / 65536.0) - 0.5;
-            let jy = f32((h >> 16u) & 0xFFFFu) * (1.0 / 65536.0) - 0.5;
-            let su = u + ((f32(i) - half) + jx) * step;
-            let sv = v + ((f32(j) - half) + jy) * step;
+            let jit = tap_jitter(cx, cy, wc, i, j);
+            let su = u + ((f32(i) - half) + jit.x) * step;
+            let sv = v + ((f32(j) - half) + jit.y) * step;
             // Texel (x, y) holds the depth at its centre (x + 0.5, y + 0.5); each of the
             // four is compared against the receiver plane at that centre.
             let tu = su - 0.5;
@@ -318,6 +341,18 @@ fn light_shadow(li: u32, kind: u32, lpos: vec3<f32>, shadow: i32, darkness: f32,
     return 1.0 - darkness * (1.0 - f);
 }
 
+// The Environment light's shadow from its dominant direction (shade::env_shadow). Only the
+// image's key fraction (g.env_sun.w) of the light is occluded — the fill keeps shining — so
+// the shadow stays partial the way After Effects renders an area-light shadow.
+fn env_shadow(p: vec3<f32>, ng: vec3<f32>, n: vec3<f32>) -> f32 {
+    if (g.env2.z < 0.0) {
+        return 1.0;
+    }
+    let n_l = clamp(dot(n, g.env_sun.xyz), 0.0, 1.0);
+    let f = shadow_factor(u32(g.env2.z + 0.5) * SHADOW_STRIDE, p, ng, n_l);
+    return 1.0 - g.env2.w * g.env_sun.w * (1.0 - f);
+}
+
 fn attenuation(kind: u32, falloff: u32, radius: f32, falloff_distance: f32, cos_inner: f32, cos_outer: f32, dir: vec3<f32>, to_l: vec3<f32>, dist: f32) -> f32 {
     var k = 1.0;
     if (falloff == 1u && kind != 0u) {
@@ -404,6 +439,10 @@ fn shadow_only_amount(unlit: bool, normal: vec3<f32>, front: bool, pos: vec3<f32
         }
         amount = max(amount, 1.0 - light_shadow(li, kind, l0.xyz, i32(l3.w), l4.x, pos, n, n_l));
     }
+    // The Environment light's shadow counts too (it reaches every surface: no falloff).
+    if (g.ambient.w > 0.5) {
+        amount = max(amount, 1.0 - env_shadow(pos, n, n));
+    }
     return amount;
 }
 
@@ -543,7 +582,11 @@ fn fs(i: VOut, @builtin(front_facing) front: bool) -> FOut {
         let f0 = mix(vec3<f32>(0.04 * spec_k), rgb, metallic);
         let ab = env_brdf(n_v, rough);
         let fs = f0 * ab.x + vec3<f32>(ab.y);
-        acc = acc + (irr * rgb * (vec3<f32>(1.0) - fs) * (1.0 - metallic) * diff_k + spec * fs) * ao;
+        var esh = 1.0;
+        if (receives_shadows) {
+            esh = env_shadow(i.pos, ng, n);
+        }
+        acc = acc + (irr * rgb * (vec3<f32>(1.0) - fs) * (1.0 - metallic) * diff_k + spec * fs) * ao * esh;
     }
     let c = acc + emissive;
     out.color = vec4<f32>(c * alpha, alpha);
diff --git a/crates/gpu/src/shaders/classic3d.wgsl b/crates/gpu/src/shaders/classic3d.wgsl
index d2cad8324..41996af36 100644
--- a/crates/gpu/src/shaders/classic3d.wgsl
+++ b/crates/gpu/src/shaders/classic3d.wgsl
@@ -199,6 +199,12 @@ fn attenuation(l: u32, p: vec3<f32>) -> f32 {
     return k;
 }
 
+// compose::shadow_taps: samples per side of the Shadow Diffusion kernel.
+fn shadow_taps(r_px: f32) -> u32 {
+    let n = clamp(u32(ceil(2.0 * r_px / 1.5)), 3u, 15u);
+    return n | 1u;
+}
+
 // compose::occlusion: RGB transmittance of light `l` reaching `p` past caster `c`.
 fn occlusion(c: u32, p: vec3<f32>, l: u32) -> vec3<f32> {
     let pl = planes[c];
@@ -243,9 +249,14 @@ fn occlusion(c: u32, p: vec3<f32>, l: u32) -> vec3<f32> {
     if (r * pl.tex.z < 0.5) {
         px = texel(c, hit.x, hit.y);
     } else {
-        for (var j = -1; j <= 1; j++) {
-            for (var i = -1; i <= 1; i++) {
-                px += texel(c, hit.x + f32(i) * r * 0.66, hit.y + f32(j) * r * 0.66) / 9.0;
+        // compose::shadow_taps: n × n box filter over the penumbra square.
+        let n = shadow_taps(r * pl.tex.z);
+        let step = 2.0 * r / f32(n);
+        let h = i32(n / 2u);
+        let w = 1.0 / f32(n * n);
+        for (var j = -h; j <= h; j++) {
+            for (var i = -h; i <= h; i++) {
+                px += texel(c, hit.x + f32(i) * step, hit.y + f32(j) * step) * w;
             }
         }
     }
@@ -255,16 +266,14 @@ fn occlusion(c: u32, p: vec3<f32>, l: u32) -> vec3<f32> {
     }
     let tr = pl.mat1.y;
     let dark = li.shadow.x;
-    var o = vec3<f32>(1.0);
-    for (var k = 0; k < 3; k++) {
-        var st = 0.0;
-        if (px.w > 0.0) {
-            st = clamp(px[k] / px.w, 0.0, 1.0);
-        }
-        let through = (1.0 - alpha) + alpha * tr * st;
-        o[k] = 1.0 - dark * (1.0 - through);
+    // Per channel, as whole vectors: FXC (DirectX 12) can't write a vector component through a
+    // loop index without unrolling every loop around the call, and fails (#613).
+    var st = vec3<f32>(0.0);
+    if (px.w > 0.0) {
+        st = clamp(px.xyz / px.w, vec3<f32>(0.0), vec3<f32>(1.0));
     }
-    return o;
+    let through = (1.0 - alpha) + alpha * tr * st;
+    return 1.0 - dark * (1.0 - through);
 }
 
 fn shadow_of(it: u32, l: u32, p: vec3<f32>) -> vec3<f32> {
diff --git a/crates/gpu/src/shaders/fx_distort.wgsl b/crates/gpu/src/shaders/fx_distort.wgsl
index 5fbc76b4b..5e9e20a12 100644
--- a/crates/gpu/src/shaders/fx_distort.wgsl
+++ b/crates/gpu/src/shaders/fx_distort.wgsl
@@ -238,7 +238,7 @@ fn dst_fbm(u: f32, v: f32, z: f32, seed: u32) -> f32 {
         if (o + 1u == n && frac > 0.0) {
             w = frac;
         }
-        sum += value_noise(u * f, v * f, z + f32(o) * 5.17, seed + o * 101u) * amp * w;
+        sum += value_noise_linear_z(u * f, v * f, z + f32(o) * 5.17, seed + o * 101u) * amp * w;
         norm += amp * w;
         amp *= falloff;
         f *= 2.0;
diff --git a/crates/gpu/src/shaders/fx_generate.wgsl b/crates/gpu/src/shaders/fx_generate.wgsl
index bca00ce1b..57d1c89e3 100644
--- a/crates/gpu/src/shaders/fx_generate.wgsl
+++ b/crates/gpu/src/shaders/fx_generate.wgsl
@@ -42,6 +42,15 @@ fn gen_sum(a: vec2<f32>, b: vec2<f32>) -> f32 {
     return (a.x + b.x) + (a.y + b.y);
 }
 
+// Standard normal CDF (Abramowitz & Stegun 7.1.26 erf; effects::misc::norm_cdf).
+fn gen_norm_cdf(z: f32) -> f32 {
+    let x = abs(z) * 0.70710678;
+    let t = 1.0 / (1.0 + 0.3275911 * x);
+    let poly = t * (0.254829592 + t * (-0.284496736 + t * (1.421413741 + t * (-1.453152027 + t * 1.061405429))));
+    let erf = 1.0 - poly * exp(-x * x);
+    return select(0.5 * (1.0 - erf), 0.5 * (1.0 + erf), z >= 0.0);
+}
+
 // ---------------------------------------------------------------- Radial Blur (raster::radial_blur)
 
 // u[0] = (zoom, samples); f[0] = (cx, cy); data = per sample (sin, cos) (spin) or k (zoom).
@@ -67,7 +76,10 @@ fn gen_radial_blur(@builtin(global_invocation_id) gid: vec3<u32>) {
             let cs = data[2u * i + 1u];
             s = vec2<f32>(c.x + v.x * cs - v.y * sn, c.y + v.x * sn + v.y * cs);
         }
-        acc += sample_bilinear(src, s.x, s.y);
+        // Edge samples repeat (raster::radial_blur).
+        let hi = vec2<f32>(f32(dims.x), f32(dims.y)) - vec2<f32>(0.5);
+        let sc = clamp(s, vec2<f32>(0.5), max(hi, vec2<f32>(0.5)));
+        acc += sample_bilinear(src, sc.x, sc.y);
     }
     textureStore(out, p, acc / f32(n));
 }
@@ -235,9 +247,9 @@ fn gen_linear_wipe(@builtin(global_invocation_id) gid: vec3<u32>) {
     textureStore(out, p, textureLoad(src, p, 0) * k);
 }
 
-// Venetian Blinds. Per column (6 floats): (cx − done·w), (cx − w − done·w), (cx − w) as
-// (hi, lo), with cx = ((x + 0.5)·dx) mod w; per row (2 floats): ((y + 0.5)·dy) mod w.
-// u[0].x = row table offset; f[0].x = feather.
+// Venetian Blinds (effects::venetian_cover). Per column (4 floats): cx, (cx − w) as (hi, lo),
+// with cx = ((x + 0.5 − ox)·dx) mod w; per row (2 floats): ((y + 0.5 − oy)·dy) mod w.
+// u[0] = (row table offset, Gaussian terms per side, 0 = hard edge); f[0] = (w, band, σ).
 @compute @workgroup_size(16, 16)
 fn gen_venetian(@builtin(global_invocation_id) gid: vec3<u32>) {
     let dims = out_dims();
@@ -245,34 +257,33 @@ fn gen_venetian(@builtin(global_invocation_id) gid: vec3<u32>) {
     if (p.x >= dims.x || p.y >= dims.y) {
         return;
     }
-    let col = 6u * u32(p.x);
+    let col = 4u * u32(p.x);
     let row = gen_hl(P.u[0].x + 2u * u32(p.y));
     // (d mod w) wraps once the column and row terms reach w.
-    let wrapped = gen_sum(gen_hl(col + 4u), row) >= 0.0;
-    var t: f32;
-    if (wrapped) {
-        t = gen_sum(gen_hl(col + 2u), row);
-    } else {
-        t = gen_sum(gen_hl(col), row);
+    var d = gen_sum(gen_hl(col), row);
+    if (gen_sum(gen_hl(col + 2u), row) >= 0.0) {
+        d = gen_sum(gen_hl(col + 2u), row);
     }
-    let k = clamp(t / P.f[0].x + 0.5, 0.0, 1.0);
-    textureStore(out, p, textureLoad(src, p, 0) * k);
+    let w = P.f[0].x;
+    let band = P.f[0].y;
+    let sigma = P.f[0].z;
+    let n = i32(P.u[0].y);
+    var t = 0.0;
+    if (n == 0) {
+        t = select(0.0, 1.0, d < band);
+    } else {
+        for (var k = -n; k <= n; k++) {
+            let u = d + f32(k) * w;
+            t += gen_norm_cdf(u / sigma) - gen_norm_cdf((u - band) / sigma);
+        }
+    }
+    let cover = clamp(t, 0.0, 1.0);
+    textureStore(out, p, textureLoad(src, p, 0) * (1.0 - cover));
 }
 
-// Angle (degrees, clockwise from up) of the pixel vector rotated by rotation `r` (0 = start,
-// 1 = start + edge, 2 = start − edge), from the per-column / per-row tables of Radial Wipe.
-fn gen_psi(r: u32, x: u32, y: u32) -> f32 {
-    let c = 9u * x + 3u * r;
-    let w = P.u[0].x + 9u * y + 3u * r;
-    // x' = ux·cos R − uy·sin R (cancels at the edge), y' = uy·cos R + ux·sin R.
-    let xr = (data[c] - data[w]) + (data[c + 1u] - data[w + 1u]);
-    let yr = data[w + 2u] + data[c + 2u];
-    return atan2(xr, yr) * GEN_DEG;
-}
-
-// Radial Wipe. data: per column 9 floats (for each rotation: ux·cos R (hi, lo), ux·sin R),
-// per row 9 floats (uy·sin R (hi, lo), uy·cos R); u[0] = (row offset, wipe);
-// f[0] = (edge, feather).
+// Radial Wipe (effects::misc::radial_wipe_alpha). u[0] = (fully wiped, hard edge);
+// f[0] = (centre x, centre y, σ, first ray in degrees); f[1] = (sin, cos) of both rays;
+// f[2].x = span in degrees.
 @compute @workgroup_size(16, 16)
 fn gen_radial_wipe(@builtin(global_invocation_id) gid: vec3<u32>) {
     let dims = out_dims();
@@ -280,30 +291,31 @@ fn gen_radial_wipe(@builtin(global_invocation_id) gid: vec3<u32>) {
     if (p.x >= dims.x || p.y >= dims.y) {
         return;
     }
-    let x = u32(p.x);
-    let y = u32(p.y);
-    let dir = P.u[0].y;
-    let edge = P.f[0].x;
-    var a = gen_psi(0u, x, y);
-    if (a < 0.0) {
-        a += 360.0;
-    }
-    var base: f32;
-    if (dir == 0u || (dir == 2u && a <= 180.0)) {
-        base = a - edge;
-        if (abs(base) < 90.0) {
-            base = gen_psi(1u, x, y);
-        }
-    } else {
-        base = (360.0 - a) - edge;
-        if (abs(base) < 90.0) {
-            base = -gen_psi(2u, x, y);
+    var k = 0.0;
+    if (P.u[0].x == 0u) {
+        let ux = f32(p.x) + 0.5 - P.f[0].x;
+        let uy = f32(p.y) + 0.5 - P.f[0].y;
+        var a = atan2(ux, -uy) * GEN_DEG - P.f[0].w;
+        a = a - 360.0 * floor(a / 360.0);
+        let wiped = a < P.f[2].x;
+        let d = min(gen_ray_dist(ux, uy, P.f[1].x, P.f[1].y), gen_ray_dist(ux, uy, P.f[1].z, P.f[1].w));
+        if (P.u[0].y != 0u) {
+            k = select(1.0, 0.0, wiped);
+        } else {
+            k = gen_norm_cdf(select(d, -d, wiped) / P.f[0].z);
         }
     }
-    let k = clamp(base / P.f[0].y + 0.5, 0.0, 1.0);
     textureStore(out, p, textureLoad(src, p, 0) * k);
 }
 
+// Distance from (ux, uy) to the ray from the centre in direction (s, −c) (y down).
+fn gen_ray_dist(ux: f32, uy: f32, s: f32, c: f32) -> f32 {
+    if (ux * s - uy * c > 0.0) {
+        return abs(ux * c + uy * s);
+    }
+    return length(vec2<f32>(ux, uy));
+}
+
 // Gradient Wipe: aux = the placed gradient layer. u[0].x = invert; f[0] = (done, softness).
 @compute @workgroup_size(16, 16)
 fn gen_gradient_wipe(@builtin(global_invocation_id) gid: vec3<u32>) {
diff --git a/crates/gpu/src/shaders/fx_noise.wgsl b/crates/gpu/src/shaders/fx_noise.wgsl
index 5e68e10c1..d2f2977ad 100644
--- a/crates/gpu/src/shaders/fx_noise.wgsl
+++ b/crates/gpu/src/shaders/fx_noise.wgsl
@@ -82,69 +82,6 @@ fn fxn_median(@builtin(global_invocation_id) gid: vec3<u32>) {
     textureStore(out, p, vec4<f32>(data[level.x], data[level.y], data[level.z], data[level.w]));
 }
 
-// The same median for large radii, as the CPU computes it: a sliding 512-bin histogram per
-// channel (Huang). One invocation per row segment of u[0].y pixels: it fills the histogram for
-// the segment's first window, then slides right one column at a time (remove the column
-// leaving, add the one entering) and moves each channel's median by the counts below it.
-// u[0] = (r, segment length); dispatched over (rows, segments) with 64 × 1 workgroups.
-// data = the 512 CPU-rounded level / 511 values.
-@compute @workgroup_size(64, 1)
-fn fxn_median_huang(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let dims = out_dims();
-    let y = i32(gid.x);
-    let seg = i32(P.u[0].y);
-    let x0 = i32(gid.y) * seg;
-    if (y >= dims.y || x0 >= dims.x) {
-        return;
-    }
-    let x1 = min(x0 + seg, dims.x);
-    let r = i32(P.u[0].x);
-    let half = u32((2 * r + 1) * (2 * r + 1) / 2);
-    var hist: array<u32, 2048>;
-    for (var dy = -r; dy <= r; dy++) {
-        for (var dx = -r; dx <= r; dx++) {
-            let v = vec4<u32>(tex_get_clamped(src, x0 + dx, y + dy));
-            hist[v.x] += 1u;
-            hist[512u + v.y] += 1u;
-            hist[1024u + v.z] += 1u;
-            hist[1536u + v.w] += 1u;
-        }
-    }
-    // Per channel: the median level and the count of values below it.
-    var med = vec4<u32>(0u);
-    var lt = vec4<u32>(0u);
-    for (var x = x0; x < x1; x++) {
-        if (x > x0) {
-            for (var dy = -r; dy <= r; dy++) {
-                let o = vec4<u32>(tex_get_clamped(src, x - 1 - r, y + dy));
-                let n = vec4<u32>(tex_get_clamped(src, x + r, y + dy));
-                for (var c = 0u; c < 4u; c++) {
-                    hist[c * 512u + o[c]] -= 1u;
-                    if (o[c] < med[c]) {
-                        lt[c] -= 1u;
-                    }
-                    hist[c * 512u + n[c]] += 1u;
-                    if (n[c] < med[c]) {
-                        lt[c] += 1u;
-                    }
-                }
-            }
-        }
-        for (var c = 0u; c < 4u; c++) {
-            let base = c * 512u;
-            while (lt[c] > half) {
-                med[c] -= 1u;
-                lt[c] -= hist[base + med[c]];
-            }
-            while (lt[c] + hist[base + med[c]] <= half) {
-                lt[c] += hist[base + med[c]];
-                med[c] += 1u;
-            }
-        }
-        textureStore(out, vec2<i32>(x, y), vec4<f32>(data[med.x], data[med.y], data[med.z], data[med.w]));
-    }
-}
-
 // noise::median_px.
 fn fxn_median_px(o: vec4<f32>, m: vec4<f32>, on_alpha: bool) -> vec4<f32> {
     if (on_alpha) {
diff --git a/crates/gpu/src/shaders/fx_pixel2.wgsl b/crates/gpu/src/shaders/fx_pixel2.wgsl
index a63a91fed..2c6f5e50c 100644
--- a/crates/gpu/src/shaders/fx_pixel2.wgsl
+++ b/crates/gpu/src/shaders/fx_pixel2.wgsl
@@ -647,7 +647,9 @@ fn fp2_hextile(@builtin(global_invocation_id) gid: vec3<u32>) {
     // stylize3::hex_cell (cube rounding).
     let q = (0.5773502691896257 * u - v / 3.0) / r;
     let rr = (2.0 / 3.0 * v) / r;
-    let ccy = -q - rr;
+    // Evaluate the third cube coordinate symmetrically with q so the centerline
+    // tie is not broken by subtracting separately rounded coordinates.
+    let ccy = (-0.5773502691896257 * u - v / 3.0) / r;
     var rx = round_away(q);
     let ry = round_away(ccy);
     var rz = round_away(rr);
diff --git a/crates/gpu/src/shaders/fx_sim.wgsl b/crates/gpu/src/shaders/fx_sim.wgsl
index d936861d3..0c6023f32 100644
--- a/crates/gpu/src/shaders/fx_sim.wgsl
+++ b/crates/gpu/src/shaders/fx_sim.wgsl
@@ -165,7 +165,8 @@ fn fxm_sprite(at: u32, x: f32, y: f32) -> FxmShade {
     return FxmShade(true, vec4<f32>(rgb * a, a));
 }
 
-// CC Bubbles' bubble (sim::bubbles). u[1].y = metal, u[1].z = shading type.
+// CC Bubbles' bubble (sim::bubbles). u[1].y = metal, u[1].z = shading type, f[0] = the layer
+// rectangle's first and last pixel centres (x0, y0, x1, y1), which refraction samples stay within.
 fn fxm_bubble(at: u32, x: f32, y: f32) -> FxmShade {
     let qx = data[at + 1u];
     let qy = data[at + 2u];
@@ -180,7 +181,9 @@ fn fxm_bubble(at: u32, x: f32, y: f32) -> FxmShade {
     }
     let k = select(-0.7, 1.6, P.u[1].y != 0u);
     let nz = sqrt(max(1.0 - d2, 0.0));
-    let s = fxm_unpremul(sample_bilinear(src, data[at + 4u] + dx * qr * k, data[at + 5u] + dy * qr * k));
+    let sx = min(max(data[at + 4u] + dx * qr * k, P.f[0].x), P.f[0].z);
+    let sy = min(max(data[at + 5u] + dy * qr * k, P.f[0].y), P.f[0].w);
+    let s = fxm_unpremul(sample_bilinear_clamped(src, sx, sy));
     var c = s.xyz;
     if (s.w <= 0.0) {
         c = vec3<f32>(0.6, 0.7, 0.8);
diff --git a/crates/gpu/src/shaders/fx_stylize.wgsl b/crates/gpu/src/shaders/fx_stylize.wgsl
index 3db442750..97db06c52 100644
--- a/crates/gpu/src/shaders/fx_stylize.wgsl
+++ b/crates/gpu/src/shaders/fx_stylize.wgsl
@@ -922,18 +922,28 @@ fn fxs_glow_map(@builtin(global_invocation_id) gid: vec3<u32>) {
     let k = clamp((l - thr) / max(1.0 - thr, 1e-3), 0.0, 1.0);
     let t = glow_ab_t(l);
     let c = vec3<f32>(curve_eval(P.f[1].x, t), curve_eval(P.f[1].y, t), curve_eval(P.f[1].z, t));
-    textureStore(out, p, vec4<f32>(c * k * a, k * a));
+    // Based on the colour channels the glow covers the layer's whole alpha (effects::misc::glow).
+    var ga = a;
+    if (P.u[0].y != 0u) {
+        ga = k * a;
+    }
+    textureStore(out, p, vec4<f32>(c * k * a, ga));
 }
 
 // On Top with another Glow Operation: blend_pixel(mode, original, glow · intensity, 0).
-// aux = the blurred glow; u[0].x = blend mode id; f[0].x = intensity
+// aux = the blurred glow; u[0].x = blend mode id; u[0].y = based on alpha (intensity also
+// scales the glow's alpha); f[0].x = intensity
 @compute @workgroup_size(16, 16)
 fn fxs_glow_op(@builtin(global_invocation_id) gid: vec3<u32>) {
     let p = vec2<i32>(gid.xy);
     if (!fxs_inside(p)) {
         return;
     }
-    let g = textureLoad(aux, p, 0) * P.f[0].x;
+    let gs = textureLoad(aux, p, 0);
+    var g = vec4<f32>(gs.xyz * P.f[0].x, gs.w);
+    if (P.u[0].y != 0u) {
+        g.w = gs.w * P.f[0].x;
+    }
     var o = blend_pixel(P.u[0].x, textureLoad(src, p, 0), g, 0.0);
     o.w = clamp(o.w, 0.0, 1.0);
     textureStore(out, p, o);
diff --git a/crates/gpu/src/shaders/kernels.wgsl b/crates/gpu/src/shaders/kernels.wgsl
index 5bb69693e..bb4a5e63a 100644
--- a/crates/gpu/src/shaders/kernels.wgsl
+++ b/crates/gpu/src/shaders/kernels.wgsl
@@ -380,19 +380,31 @@ fn glow_bright(@builtin(global_invocation_id) gid: vec3<u32>) {
         l = a;
     }
     let k = clamp((l - thr) / max(1.0 - thr, 1e-3), 0.0, 1.0);
+    // Based on the colour channels the glow covers the layer's whole alpha (effects::misc::glow).
+    var ga = a;
+    if (P.u[0].y != 0u) {
+        ga = k * a;
+    }
     if (P.u[0].x != 0u) {
         let t = glow_ab_t(l);
         let ca = P.f[1].xyz;
         let cb = P.f[2].xyz;
         let c = ca + (cb - ca) * t;
-        textureStore(out, p, vec4<f32>(c * k * a, k * a));
+        textureStore(out, p, vec4<f32>(c * k * a, ga));
+    } else if (P.u[0].y != 0u) {
+        textureStore(out, p, vec4<f32>(px.xyz * k, ga));
     } else {
-        textureStore(out, p, px * k);
+        // Original colours, per channel (effects::misc::glow_bright_channel): gain 8.0 is
+        // effects::GLOW_GAIN, 0.0611 is effects::GLOW_KNEE (checked by the test
+        // glow_constants_match_the_cpu).
+        let c = max(8.0 * (px.xyz / a - vec3<f32>(thr - 0.0611)), vec3<f32>(0.0));
+        textureStore(out, p, vec4<f32>(c * a, ga));
     }
 }
 
 // Glow composite: original `src` with the blurred glow `aux`. u[0].x = 0 on top, 1 behind,
-// 2 none (glow only); f[0].x = intensity.
+// 2 none (glow only); u[0].y = based on alpha (intensity also scales the glow's alpha);
+// f[0].x = intensity.
 @compute @workgroup_size(16, 16)
 fn glow_combine(@builtin(global_invocation_id) gid: vec3<u32>) {
     let dims = out_dims();
@@ -401,7 +413,11 @@ fn glow_combine(@builtin(global_invocation_id) gid: vec3<u32>) {
         return;
     }
     var o = textureLoad(src, p, 0);
-    let g = textureLoad(aux, p, 0) * P.f[0].x;
+    let gs = textureLoad(aux, p, 0);
+    var g = vec4<f32>(gs.xyz * P.f[0].x, gs.w);
+    if (P.u[0].y != 0u) {
+        g.w = gs.w * P.f[0].x;
+    }
     if (P.u[0].x == 2u) {
         o = g;
     } else if (P.u[0].x == 1u) {
@@ -509,12 +525,25 @@ fn fade(t: f32) -> f32 {
 }
 
 fn value_noise(x: f32, y: f32, z: f32, seed: u32) -> f32 {
+    return value_noise_z(x, y, z, seed, true);
+}
+
+// effects::generate::value_noise_linear_z: z (evolution) interpolates linearly, x and y keep the
+// quintic fade (Turbulent Displace, #943).
+fn value_noise_linear_z(x: f32, y: f32, z: f32, seed: u32) -> f32 {
+    return value_noise_z(x, y, z, seed, false);
+}
+
+fn value_noise_z(x: f32, y: f32, z: f32, seed: u32, ease_z: bool) -> f32 {
     let x0 = floor(x);
     let y0 = floor(y);
     let z0 = floor(z);
     let fx = fade(x - x0);
     let fy = fade(y - y0);
-    let fz = fade(z - z0);
+    var fz = z - z0;
+    if (ease_z) {
+        fz = fade(fz);
+    }
     let ix = i32(x0);
     let iy = i32(y0);
     let iz = i32(z0);
diff --git a/crates/gpu/src/shaders/median_private.wgsl b/crates/gpu/src/shaders/median_private.wgsl
new file mode 100644
index 000000000..5b3afefe4
--- /dev/null
+++ b/crates/gpu/src/shaders/median_private.wgsl
@@ -0,0 +1,63 @@
+// The same median for large radii, as the CPU computes it: a sliding 512-bin histogram per
+// channel (Huang). One invocation per row segment of u[0].y pixels: it fills the histogram for
+// the segment's first window, then slides right one column at a time (remove the column
+// leaving, add the one entering) and moves each channel's median by the counts below it.
+// u[0] = (r, segment length); dispatched over (rows, segments) with 64 × 1 workgroups.
+// data = the 512 CPU-rounded level / 511 values.
+@compute @workgroup_size(64, 1)
+fn fxn_median_huang(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let dims = out_dims();
+    let y = i32(gid.x);
+    let seg = i32(P.u[0].y);
+    let x0 = i32(gid.y) * seg;
+    if (y >= dims.y || x0 >= dims.x) {
+        return;
+    }
+    let x1 = min(x0 + seg, dims.x);
+    let r = i32(P.u[0].x);
+    let half = u32((2 * r + 1) * (2 * r + 1) / 2);
+    var hist: array<u32, 2048>;
+    for (var dy = -r; dy <= r; dy++) {
+        for (var dx = -r; dx <= r; dx++) {
+            let v = vec4<u32>(tex_get_clamped(src, x0 + dx, y + dy));
+            hist[v.x] += 1u;
+            hist[512u + v.y] += 1u;
+            hist[1024u + v.z] += 1u;
+            hist[1536u + v.w] += 1u;
+        }
+    }
+    // Per channel: the median level and the count of values below it.
+    var med = vec4<u32>(0u);
+    var lt = vec4<u32>(0u);
+    for (var x = x0; x < x1; x++) {
+        if (x > x0) {
+            for (var dy = -r; dy <= r; dy++) {
+                let o = vec4<u32>(tex_get_clamped(src, x - 1 - r, y + dy));
+                let n = vec4<u32>(tex_get_clamped(src, x + r, y + dy));
+                for (var c = 0u; c < 4u; c++) {
+                    hist[c * 512u + o[c]] -= 1u;
+                    if (o[c] < med[c]) {
+                        lt[c] -= 1u;
+                    }
+                    hist[c * 512u + n[c]] += 1u;
+                    if (n[c] < med[c]) {
+                        lt[c] += 1u;
+                    }
+                }
+            }
+        }
+        for (var c = 0u; c < 4u; c++) {
+            let base = c * 512u;
+            while (lt[c] > half) {
+                med[c] -= 1u;
+                lt[c] -= hist[base + med[c]];
+            }
+            while (lt[c] + hist[base + med[c]] <= half) {
+                lt[c] += hist[base + med[c]];
+                med[c] += 1u;
+            }
+        }
+        textureStore(out, vec2<i32>(x, y), vec4<f32>(data[med.x], data[med.y], data[med.z], data[med.w]));
+    }
+}
+
diff --git a/crates/gpu/src/shaders/median_software.wgsl b/crates/gpu/src/shaders/median_software.wgsl
new file mode 100644
index 000000000..606a5e4b4
--- /dev/null
+++ b/crates/gpu/src/shaders/median_software.wgsl
@@ -0,0 +1,65 @@
+// The same median for large radii, as the CPU computes it: a sliding 512-bin histogram per
+// channel (Huang). One invocation per row segment of u[0].y pixels: it fills the histogram for
+// the segment's first window, then slides right one column at a time (remove the column
+// leaving, add the one entering) and moves each channel's median by the counts below it.
+// Each invocation owns one 8 KiB slice of the workgroup's zero-initialized histogram.
+// Two slices fit the guaranteed 16 KiB workgroup storage limit. No bins are shared.
+var<workgroup> median_hist: array<array<u32, 2048>, 2>;
+// u[0] = (r, segment length); dispatched over (rows, segments) with 2 × 1 workgroups.
+// data = the 512 CPU-rounded level / 511 values.
+@compute @workgroup_size(2, 1)
+fn fxn_median_huang(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(local_invocation_index) lane: u32) {
+    let dims = out_dims();
+    let y = i32(gid.x);
+    let seg = i32(P.u[0].y);
+    let x0 = i32(gid.y) * seg;
+    if (y >= dims.y || x0 >= dims.x) {
+        return;
+    }
+    let x1 = min(x0 + seg, dims.x);
+    let r = i32(P.u[0].x);
+    let half = u32((2 * r + 1) * (2 * r + 1) / 2);
+    for (var dy = -r; dy <= r; dy++) {
+        for (var dx = -r; dx <= r; dx++) {
+            let v = vec4<u32>(tex_get_clamped(src, x0 + dx, y + dy));
+            median_hist[lane][v.x] += 1u;
+            median_hist[lane][512u + v.y] += 1u;
+            median_hist[lane][1024u + v.z] += 1u;
+            median_hist[lane][1536u + v.w] += 1u;
+        }
+    }
+    // Per channel: the median level and the count of values below it.
+    var med = vec4<u32>(0u);
+    var lt = vec4<u32>(0u);
+    for (var x = x0; x < x1; x++) {
+        if (x > x0) {
+            for (var dy = -r; dy <= r; dy++) {
+                let o = vec4<u32>(tex_get_clamped(src, x - 1 - r, y + dy));
+                let n = vec4<u32>(tex_get_clamped(src, x + r, y + dy));
+                for (var c = 0u; c < 4u; c++) {
+                    median_hist[lane][c * 512u + o[c]] -= 1u;
+                    if (o[c] < med[c]) {
+                        lt[c] -= 1u;
+                    }
+                    median_hist[lane][c * 512u + n[c]] += 1u;
+                    if (n[c] < med[c]) {
+                        lt[c] += 1u;
+                    }
+                }
+            }
+        }
+        for (var c = 0u; c < 4u; c++) {
+            let base = c * 512u;
+            while (lt[c] > half) {
+                med[c] -= 1u;
+                lt[c] -= median_hist[lane][base + med[c]];
+            }
+            while (lt[c] + median_hist[lane][base + med[c]] <= half) {
+                lt[c] += median_hist[lane][base + med[c]];
+                med[c] += 1u;
+            }
+        }
+        textureStore(out, vec2<i32>(x, y), vec4<f32>(data[med.x], data[med.y], data[med.z], data[med.w]));
+    }
+}
+
diff --git a/crates/gpu/src/shaders/yuv.wgsl b/crates/gpu/src/shaders/yuv.wgsl
new file mode 100644
index 000000000..935acb4dc
--- /dev/null
+++ b/crates/gpu/src/shaders/yuv.wgsl
@@ -0,0 +1,96 @@
+// Finished frame → 8-bit BT.709 limited-range 4:2:0 (Y, U, V planes packed 4 bytes per word),
+// composited over the comp background: the GPU twin of `Image::to_rgba8_over` followed by
+// export's `rgba_to_yuv420`, operation for operation (same order of float operations, the same
+// rounding: `as u8` truncation of `x * 255 + 0.5`, `f32::round` half away from zero).
+
+struct YP {
+    // width, height, chroma width, Y words
+    size: vec4<u32>,
+    bg: vec4<f32>,
+}
+
+@group(0) @binding(0) var<uniform> Y: YP;
+@group(0) @binding(1) var frame: texture_2d<f32>;
+@group(0) @binding(2) var<storage, read_write> outw: array<u32>;
+
+// NaN by its bits: drivers may assume arithmetic never sees NaN.
+fn is_nan(x: f32) -> bool {
+    return (bitcast<u32>(x) & 0x7fffffffu) > 0x7f800000u;
+}
+
+// `(c.clamp(0, 1) * 255 + 0.5) as u8`; the CPU's `as u8` turns NaN into 0.
+fn q8(c: f32, nan: bool) -> f32 {
+    if (nan) {
+        return 0.0;
+    }
+    return floor(clamp(c, 0.0, 1.0) * 255.0 + 0.5);
+}
+
+// f32::round for x >= 0 (half away from zero).
+fn round_pos(x: f32) -> f32 {
+    let f = floor(x);
+    return select(f, f + 1.0, x - f >= 0.5);
+}
+
+fn px(x: u32, y: u32) -> vec3<f32> {
+    let p = textureLoad(frame, vec2<i32>(i32(x), i32(y)), 0);
+    // A NaN alpha makes every channel NaN on the CPU (k is NaN).
+    let na = is_nan(p.w);
+    let k = select(1.0 - clamp(p.w, 0.0, 1.0), 0.0, na);
+    let c = vec3<f32>(q8(p.x + Y.bg.x * k, na || is_nan(p.x)), q8(p.y + Y.bg.y * k, na || is_nan(p.y)), q8(p.z + Y.bg.z * k, na || is_nan(p.z)));
+    return c / 255.0;
+}
+
+fn luma(c: vec3<f32>) -> f32 {
+    return 0.2126 * c.x + 0.7152 * c.y + 0.0722 * c.z;
+}
+
+fn y8(l: f32) -> u32 {
+    return u32(clamp(round_pos(16.0 + 219.0 * l), 1.0, 254.0));
+}
+
+// One invocation: 4 chroma samples = 8 × 2 pixels.
+@compute @workgroup_size(8, 8)
+fn yuv420(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let w = Y.size.x;
+    let h = Y.size.y;
+    let cw = Y.size.z;
+    if (gid.x * 4u >= cw || gid.y * 2u >= h) {
+        return;
+    }
+    let x0 = gid.x * 8u;
+    let cy = gid.y;
+    var uw = 0u;
+    var vw = 0u;
+    var yw = array<u32, 4>(0u, 0u, 0u, 0u);
+    for (var q = 0u; q < 4u; q++) {
+        // Accumulate in the CPU's order: row 0 left, right; row 1 left, right.
+        var a0 = 0.0;
+        var a1 = 0.0;
+        for (var dy = 0u; dy < 2u; dy++) {
+            for (var dx = 0u; dx < 2u; dx++) {
+                let x = x0 + q * 2u + dx;
+                let c = px(x, cy * 2u + dy);
+                let l = luma(c);
+                let byte = q * 2u + dx;
+                yw[dy * 2u + byte / 4u] |= y8(l) << (8u * (byte % 4u));
+                a0 += (c.z - l) / 1.8556;
+                a1 += (c.x - l) / 1.5748;
+            }
+        }
+        let u = u32(clamp(round_pos(128.0 + 224.0 * a0 / 4.0), 1.0, 254.0));
+        let v = u32(clamp(round_pos(128.0 + 224.0 * a1 / 4.0), 1.0, 254.0));
+        uw |= u << (8u * q);
+        vw |= v << (8u * q);
+    }
+    let r0 = (cy * 2u * w + x0) / 4u;
+    let r1 = ((cy * 2u + 1u) * w + x0) / 4u;
+    outw[r0] = yw[0];
+    outw[r0 + 1u] = yw[1];
+    outw[r1] = yw[2];
+    outw[r1 + 1u] = yw[3];
+    let cwords = cw / 4u * (h / 2u);
+    let ci = (cy * cw) / 4u + gid.x;
+    outw[Y.size.w + ci] = uw;
+    outw[Y.size.w + cwords + ci] = vw;
+}
diff --git a/crates/gpu/src/tests.rs b/crates/gpu/src/tests.rs
index b2e1113e2..44e8922a6 100644
--- a/crates/gpu/src/tests.rs
+++ b/crates/gpu/src/tests.rs
@@ -26,6 +26,36 @@ use effectcraft_time::{FrameRate, Tick};
 
 use crate::Gpu;
 
+mod adjust;
+mod adv3d;
+mod deferred;
+mod deferred_jobs;
+mod fx_color;
+mod fx_depth;
+mod fx_distort;
+mod fx_extra;
+mod fx_gen2;
+mod fx_generate;
+mod fx_key;
+mod fx_light;
+mod fx_lut;
+mod fx_noise;
+mod fx_particles;
+mod fx_pixel2;
+mod fx_sim;
+mod fx_stylize;
+mod fx_text;
+mod fx_time;
+mod fx_tone;
+mod fx_transition;
+mod fx_vr;
+mod fx_warp;
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod init;
+mod particles;
+mod three_d;
+mod wgsl_grammar;
+
 /// One GPU test at a time in this process: the calling test thread holds a process-wide lock
 /// until it exits (libtest runs every test on a thread of its own). wgpu's OpenGL backend (Mesa
 /// llvmpipe on FreeBSD, Linux without Vulkan) has one context lock per adapter and panics when a
@@ -52,9 +82,29 @@ pub(crate) fn gpu() -> Option<&'static Gpu> {
     static G: OnceLock<Result<Gpu, String>> = OnceLock::new();
     hold_gpu_lock();
     let g = G.get_or_init(|| {
+        // Readback mapping/allocation errors become None without necessarily retiring the
+        // context. Preserve their original messages alongside the failure's health snapshot.
+        struct GpuTestLog;
+        impl log::Log for GpuTestLog {
+            fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
+                metadata.level() <= log::Level::Warn && metadata.target().starts_with("effectcraft_gpu")
+            }
+
+            fn log(&self, record: &log::Record<'_>) {
+                if self.enabled(record.metadata()) {
+                    eprintln!("{} {}: {}", record.level(), record.target(), record.args());
+                }
+            }
+
+            fn flush(&self) {}
+        }
+        static LOGGER: GpuTestLog = GpuTestLog;
+        if log::set_logger(&LOGGER).is_ok() {
+            log::set_max_level(log::LevelFilter::Warn);
+        }
         let g = Gpu::try_headless();
         match &g {
-            Ok(g) => eprintln!("effectcraft-gpu tests: adapter {}", g.ctx.name),
+            Ok(g) => eprintln!("effectcraft-gpu tests: adapter {}, median {:?}", g.ctx.name, g.ctx.median_kernel),
             Err(e) => eprintln!("effectcraft-gpu tests: no GPU ({e}), skipping GPU comparisons"),
         }
         g
@@ -448,7 +498,7 @@ fn layer_styles_collapsed_precomps_and_cpu_fallbacks() {
             b.blend_mode = BlendMode::Difference;
             (a, b)
         };
-        s.p.comp_mut(inner_id).unwrap().layers = vec![b, a];
+        s.p.comp_mut(inner_id).unwrap().layers = vec![b, a].into();
         let bg = s.footage(97, 61);
         s.push(bg);
         let mut pre = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (60, 40), None);
@@ -460,6 +510,12 @@ fn layer_styles_collapsed_precomps_and_cpu_fallbacks() {
         adj.switches.adjustment = true;
         s.effect(&mut adj, "ec.channel.invert", &[]);
         s.push(adj);
+        // An adjustment layer in another blend mode blends the adjusted comp in that mode (#2618).
+        let mut adj = s.solid([1.0, 1.0, 1.0], 70, 40);
+        adj.switches.adjustment = true;
+        adj.blend_mode = BlendMode::Screen;
+        set(&mut adj, "transform/opacity", Value::Scalar(60.0));
+        s.push(adj);
         check(&format!("collapse + adjustment {depth:?}"), compare_at(&s, opts(), Tick::ZERO), 0.0);
     }
 }
@@ -481,7 +537,16 @@ pub(crate) fn effect_direct(id: &str, vals: &[(&str, Value)], adjustment: bool)
         let buf = effectcraft_effects::Buf { img, offset: [0.0, 0.0], scale };
         let ctx = || effectcraft_effects::EffectCtx { params: &params, time: 0.25, layer_size: size, seed: 11, adjustment, env: Default::default() };
         let cpu = (spec.render)(&ctx(), buf.clone());
-        let out = effectcraft_render::Accelerator::effects(g, &[effectcraft_render::FxStep { spec, ctx: ctx() }], &buf, None).expect("the GPU runs the effect");
+        let started = std::time::Instant::now();
+        let out = effectcraft_render::Accelerator::effects(g, &[effectcraft_render::FxStep { spec, ctx: ctx() }], &buf, None).unwrap_or_else(|| {
+            panic!(
+                "the GPU runs {id} {vals:?} adj {adjustment} scale {scale}; elapsed={:?}, health={:?}, unavailable={:?}, transfers={:?}",
+                started.elapsed(),
+                g.ctx.check_health(),
+                g.ctx.unavailable_kernels(),
+                g.ctx.transfer_stats()
+            )
+        });
         if expect_empty {
             assert!(out.img.data.iter().all(|p| p[3] == 0.0), "{id} {vals:?} adj {adjustment} scale {scale}: Cut Away 100 produced non-zero alpha");
         }
@@ -805,6 +870,71 @@ fn within_memory_returns_the_work_when_there_is_room() {
     assert_eq!((img.width, img.height), (64, 32));
 }
 
+/// A texture the device rejected (deliberately too wide), made outside any frame under a scope
+/// of its own: the view a frame then makes of it is the reported validation error.
+fn rejected_texture(g: &Gpu) -> wgpu::Texture {
+    let scope = g.ctx.device.push_error_scope(wgpu::ErrorFilter::Validation);
+    let too_wide = g.ctx.device.limits().max_texture_dimension_2d.saturating_add(1);
+    let t = g.ctx.device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("deliberately too wide"),
+        size: wgpu::Extent3d { width: too_wide, height: 1, depth_or_array_layers: 1 },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8Unorm,
+        usage: wgpu::TextureUsages::TEXTURE_BINDING,
+        view_formats: &[],
+    });
+    assert!(pollster::block_on(scope.pop()).is_some(), "the device rejected the texture");
+    t
+}
+
+/// A frame that makes a view of an invalid texture ("Texture with '' label is invalid", #1319)
+/// fails alone: the validation error doesn't reach the device's handler (which retires the
+/// compositor for the session, and panics in tests), and the next frame composites on the GPU,
+/// read back, like the CPU.
+#[test]
+fn a_view_of_an_invalid_texture_fails_the_frame_not_the_compositor() {
+    hold_gpu_lock();
+    let Some(g) = Gpu::headless() else { return };
+    let rejected = rejected_texture(&g);
+    let err = g.within_memory(|| rejected.create_view(&Default::default())).expect_err("the frame fails");
+    assert!(matches!(&err, crate::FrameError::Validation(e) if e.contains("deliberately too wide")), "{err:?}");
+    assert!(g.ctx.check_health().is_ok(), "the compositor stays on: {:?}", g.ctx.check_health());
+    let s = blend_scene(BitDepth::Bpc32, BlendMode::Normal);
+    let cpu = Renderer::new(&s.p, &Pattern, RenderOpts { backend: Backend::Cpu, ..opts() }).comp_frame_cpu(s.cid, Tick::ZERO);
+    let mut r = Renderer::new(&s.p, &Pattern, RenderOpts { backend: Backend::Gpu, ..opts() });
+    r.accel = Some(&g);
+    let img = g.within_memory(|| g.render(&r, s.cid, Tick::ZERO)).expect("the next frame isn't rejected").expect("the GPU renders it");
+    let mut d = diff(&cpu, &img, tolerance(BitDepth::Bpc32));
+    d.quantized = false;
+    check("after a rejected frame", Some(d), 0.0);
+}
+
+/// No texture of a failed frame is reused: not one released while another encoder is still
+/// open (it waits for that encoder), nor one taken before the failure and handed back after.
+#[test]
+fn a_failed_frame_returns_no_texture_to_the_pool() {
+    hold_gpu_lock();
+    let Some(g) = Gpu::headless() else { return };
+    let rejected = rejected_texture(&g);
+    let earlier = g.within_memory(|| crate::context::Enc::new(&g.ctx).image(48, 16)).expect("an earlier frame");
+    let mut other = crate::context::Enc::new(&g.ctx);
+    other.encoder();
+    g.within_memory(|| (crate::context::Enc::new(&g.ctx).image(64, 32), rejected.create_view(&Default::default()))).expect_err("the frame fails");
+    drop(earlier);
+    drop(other);
+    let (hits, _) = g.ctx.pool_stats();
+    let (a, b) = g
+        .within_memory(|| {
+            let mut e = crate::context::Enc::new(&g.ctx);
+            (e.image(64, 32), e.image(48, 16))
+        })
+        .expect("the next frame");
+    assert_eq!(((a.width, a.height), (b.width, b.height)), ((64, 32), (48, 16)));
+    assert_eq!(g.ctx.pool_stats().0, hits, "no texture of the failed frame was reused");
+}
+
 /// A buffer whose allocation fails (here: over the device's buffer size limit; on Adreno an
 /// internal `ERROR_INITIALIZATION_FAILED`) is reported to the caller's error scope instead of
 /// panicking in `create_buffer_init`'s mapped range on a frame thread (#591).
@@ -899,6 +1029,16 @@ fn effects_whose_kernels_failed_render_on_the_cpu() {
     }
 }
 
+/// WGSL cannot read the CPU's constants, so Glow's bright pass repeats them as literals; this
+/// ties them to `effects::GLOW_GAIN` / `GLOW_KNEE` (runs without a GPU).
+#[test]
+fn glow_constants_match_the_cpu() {
+    use effectcraft_effects::{GLOW_GAIN, GLOW_KNEE};
+    let kernels = include_str!("shaders/kernels.wgsl");
+    let want = format!("max({GLOW_GAIN:?} * (px.xyz / a - vec3<f32>(thr - {GLOW_KNEE:?})), vec3<f32>(0.0))");
+    assert!(kernels.contains(&want), "Glow's bright pass in kernels.wgsl is not `{want}`");
+}
+
 /// The GPU Tint gives After Effects 2026's greys for full-frame solids at its defaults (sRGB
 /// working space, not linearised): Rec. 601 weights, as the CPU (`color_fx::luma_601`).
 #[test]
diff --git a/crates/gpu/src/tests_adjust.rs b/crates/gpu/src/tests/adjust.rs
similarity index 98%
rename from crates/gpu/src/tests_adjust.rs
rename to crates/gpu/src/tests/adjust.rs
index 5635e08e1..39438d43e 100644
--- a/crates/gpu/src/tests_adjust.rs
+++ b/crates/gpu/src/tests/adjust.rs
@@ -83,7 +83,7 @@ fn track_mattes_limit_gpu_adjustments_like_the_cpu() {
             set(&mut matte, "transform/rotation", Value::Scalar(10.0));
             let mid = s.push(matte);
             let c = s.p.comp_mut(s.cid).unwrap();
-            let adj = c.layers.iter_mut().find(|l| l.switches.adjustment).unwrap();
+            let adj = c.layers.find_mut(|l| l.switches.adjustment).unwrap();
             adj.track_matte = Some(TrackMatte { layer: mid, kind });
             check(&format!("matted adjustment {kind:?} {depth:?}"), compare_at(&s, opts(), Tick::ZERO), 0.0);
         }
diff --git a/crates/gpu/src/tests_adv3d.rs b/crates/gpu/src/tests/adv3d.rs
similarity index 92%
rename from crates/gpu/src/tests_adv3d.rs
rename to crates/gpu/src/tests/adv3d.rs
index 21422aa6b..00b1fee14 100644
--- a/crates/gpu/src/tests_adv3d.rs
+++ b/crates/gpu/src/tests/adv3d.rs
@@ -5,7 +5,7 @@
 //! edges may be covered by the other neighbour. Interior pixels agree within 2/255; at most
 //! 1.5 % of pixels (silhouettes) may differ more. Skipped without an adapter.
 
-use effectcraft_keyframe::Value;
+use effectcraft_keyframe::{Gradient, Value};
 use effectcraft_project::build;
 use effectcraft_project::{Comp, ItemId, ItemKind, LayerSource, LightKind, PrimitiveKind, Project, Renderer as R3, Solid};
 use effectcraft_render::three_d::adv::{self, Scene};
@@ -38,7 +38,8 @@ fn set(l: &mut effectcraft_project::Layer, path: &str, v: Value) {
 }
 
 /// Primitives with metal/dielectric materials, a shadow-casting spot light and a point light,
-/// an environment light, a semi-transparent textured card.
+/// a shadow-casting Environment light over a sky-gradient environment layer, a semi-transparent
+/// textured card.
 pub(crate) fn scene_project() -> (Project, ItemId) {
     let mut p = Project::default();
     let mut c = Comp::new(240, 160, FrameRate::FPS_30, Tick::from_seconds_f64(1.0));
@@ -73,12 +74,29 @@ pub(crate) fn scene_project() -> (Project, ItemId) {
         set(l, "transform/position", Value::Vec3([120.0, 80.0, -60.0]));
         set(l, "transform/rotationY", Value::Scalar(30.0));
     });
-    let env = p.add_item("E", Default::default(), None, ItemKind::Solid(Solid { color: [0.6, 0.7, 1.0], width: 32, height: 16, pixel_aspect: 1.0 }));
-    add(&mut p, cid, LayerSource::Solid { item: env }, |l| {
-        l.environment = true;
+    // The Environment Layer: a sky-to-ground gradient (its dominant region, the bright sky,
+    // shadows the scene from above).
+    add(&mut p, cid, LayerSource::Shape, |l| {
         l.switches.three_d = true;
+        let mut next = 10_000u64;
+        let ids = &mut build::Ids(&mut next);
+        let rect = build::shape_rect(ids, [240.0, 160.0], [0.0, 0.0], 0.0);
+        let gfill = build::shape_gradient_fill(
+            ids,
+            false,
+            [0.0, -80.0],
+            [0.0, 80.0],
+            Gradient { colors: vec![(0.0, [1.0, 1.0, 1.0, 1.0]), (1.0, [0.04, 0.05, 0.08, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 1.0)] },
+        );
+        let g = build::shape_group(ids, "Sky", vec![rect, gfill]);
+        l.props.sub_mut("contents").unwrap().children.push(g.into());
+        l.environment = true;
+    });
+    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |l| {
+        set(l, "lightOptions/intensity", Value::Scalar(50.0));
+        set(l, "lightOptions/castsShadows", Value::Bool(true));
+        set(l, "lightOptions/shadowDiffusion", Value::Scalar(6.0));
     });
-    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |l| set(l, "lightOptions/intensity", Value::Scalar(50.0)));
     add(&mut p, cid, LayerSource::Light { kind: LightKind::Spot }, |l| {
         set(l, "transform/position", Value::Vec3([40.0, -120.0, -200.0]));
         set(l, "transform/poi", Value::Vec3([120.0, 100.0, 0.0]));
@@ -96,7 +114,16 @@ pub(crate) fn scene_project() -> (Project, ItemId) {
 
 pub(crate) fn scene(p: &Project, cid: ItemId) -> Scene {
     let r = Renderer::new(p, &NoFootage, RenderOpts::default());
-    let ctx = EvalCtx { project: p, comp_id: cid, comp: p.comp(cid).unwrap(), time: Tick::ZERO, expr: None, footage: None };
+    let ctx = EvalCtx {
+        project: p,
+        comp_id: cid,
+        comp: p.comp(cid).unwrap(),
+        time: Tick::ZERO,
+        expr: None,
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let run: Vec<&effectcraft_project::Layer> = ctx.comp.layers.iter().rev().filter(|l| l.is_3d() && l.has_video()).collect();
     adv::scene_of(&r, &ctx, &run, (ctx.comp.width, ctx.comp.height))
 }
@@ -135,6 +162,8 @@ fn gpu_matches_cpu_lit_scene() {
     let (p, cid) = scene_project();
     let s = scene(&p, cid);
     assert!(!s.shadows.is_empty() && s.env.is_some() && s.opaque_count < s.indices.len() as u32);
+    // The Environment light casts its shadow (the sky gradient's dominant direction).
+    assert!(s.env.is_some_and(|e| e.shadow >= 0 && e.sun != [0.0; 3]), "the environment shadow map is built");
     compare(&s, &g);
 }
 
@@ -181,7 +210,7 @@ fn gpu_matches_cpu_wide_penumbrae() {
     set(&mut comp.layers[0], "lightOptions/shadowDiffusion", Value::Scalar(30.0));
     let s = scene(&p, cid);
     let (cpu, gt) = (adv::raster::render(&s), g.raster_3d(&s).expect("gpu raster"));
-    for l in &mut p.comp_mut(cid).unwrap().layers[..2] {
+    for l in p.comp_mut(cid).unwrap().layers.iter_mut().take(2) {
         set(l, "lightOptions/castsShadows", Value::Bool(false));
     }
     let unshadowed = adv::raster::render(&scene(&p, cid));
@@ -251,7 +280,7 @@ pub(crate) fn dof_mb_project() -> (Project, ItemId) {
     c.enable_motion_blur = true;
     c.motion_blur_samples = 6;
     // The sphere moves 40 px per frame.
-    let sphere = c.layers.iter_mut().find(|l| matches!(l.source, LayerSource::Primitive { kind: PrimitiveKind::Sphere })).unwrap();
+    let sphere = c.layers.find_mut(|l| matches!(l.source, LayerSource::Primitive { kind: PrimitiveKind::Sphere })).unwrap();
     sphere.switches.motion_blur = true;
     sphere.props.prop_mut("transform/position").unwrap().keys = vec![
         effectcraft_keyframe::Keyframe::new(Tick::ZERO, Value::Vec3([80.0, 95.0, 0.0])),
@@ -277,7 +306,16 @@ pub(crate) fn off_share(a: &[[f32; 4]], b: &[[f32; 4]]) -> (f64, f32) {
 }
 
 pub(crate) fn run_of(p: &Project, cid: ItemId) -> (EvalCtx<'_>, Vec<&effectcraft_project::Layer>) {
-    let ctx = EvalCtx { project: p, comp_id: cid, comp: p.comp(cid).unwrap(), time: Tick::ZERO, expr: None, footage: None };
+    let ctx = EvalCtx {
+        project: p,
+        comp_id: cid,
+        comp: p.comp(cid).unwrap(),
+        time: Tick::ZERO,
+        expr: None,
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let run: Vec<&effectcraft_project::Layer> = ctx.comp.layers.iter().rev().filter(|l| l.is_3d() && l.has_video()).collect();
     (ctx, run)
 }
@@ -411,7 +449,7 @@ fn gpu_compositor_draws_advanced_3d_runs_on_the_device() {
     eprintln!("walk: {:.3} % beyond 1/255 (max {max:.4})", share * 100.0);
     assert!(share <= 0.01, "{:.3} % of pixels differ", share * 100.0);
     // A blend mode in the run takes the 2D compositing path (`SplitRun`, also on the GPU).
-    p.comp_mut(cid).unwrap().layers.iter_mut().find(|l| l.switches.three_d && !l.is_light() && l.source.is_av()).unwrap().blend_mode =
+    p.comp_mut(cid).unwrap().layers.find_mut(|l| l.switches.three_d && !l.is_light() && l.source.is_av()).unwrap().blend_mode =
         effectcraft_color::BlendMode::Screen;
     let (ctx, run) = run_of(&p, cid);
     assert!(Renderer::new(&p, &NoFootage, RenderOpts::default()).prepare_adv_run(&ctx, &run, (240, 160)).is_none());
@@ -532,12 +570,12 @@ fn gpu_compositor_draws_split_advanced_3d_runs_and_skies() {
             });
         }
         let c = p.comp_mut(cid).unwrap();
-        let env = c.layers.iter_mut().find(|l| l.environment).unwrap();
+        let env = c.layers.find_mut(|l| l.environment).unwrap();
         env.props.sub_mut("effects").unwrap().children.push(ramp.into());
         let ids: Vec<_> = c.layers.iter().filter(|l| l.switches.three_d && !l.is_light() && !l.environment && l.source.is_av()).map(|l| l.id).collect();
         let top = c.layers[0].id;
         fn by_id(c: &mut Comp, id: effectcraft_project::LayerId) -> &mut effectcraft_project::Layer {
-            c.layers.iter_mut().find(|l| l.id == id).unwrap()
+            c.layers.find_mut(|l| l.id == id).unwrap()
         }
         match case {
             0 => by_id(c, ids[1]).blend_mode = effectcraft_color::BlendMode::Screen,
@@ -555,7 +593,7 @@ fn gpu_compositor_draws_split_advanced_3d_runs_and_skies() {
             }
             _ => {
                 // An environment background behind the run, and the 2D track matte.
-                c.layers.iter_mut().find(|l| l.environment).unwrap().environment_background = true;
+                c.layers.find_mut(|l| l.environment).unwrap().environment_background = true;
                 by_id(c, ids[0]).track_matte = Some(effectcraft_project::TrackMatte { layer: top, kind: effectcraft_project::MatteKind::Alpha });
             }
         }
diff --git a/crates/gpu/src/tests_deferred.rs b/crates/gpu/src/tests/deferred.rs
similarity index 100%
rename from crates/gpu/src/tests_deferred.rs
rename to crates/gpu/src/tests/deferred.rs
diff --git a/crates/gpu/src/tests_deferred_jobs.rs b/crates/gpu/src/tests/deferred_jobs.rs
similarity index 95%
rename from crates/gpu/src/tests_deferred_jobs.rs
rename to crates/gpu/src/tests/deferred_jobs.rs
index 7f10f53d4..7e5edbedd 100644
--- a/crates/gpu/src/tests_deferred_jobs.rs
+++ b/crates/gpu/src/tests/deferred_jobs.rs
@@ -8,10 +8,10 @@ use effectcraft_render::three_d::adv;
 use effectcraft_render::{Accelerator, Backend, LayerCache, NoFootage, RenderOpts, Renderer};
 use effectcraft_time::Tick;
 
+use crate::tests::adv3d::{off_share, run_of, scene, scene_project};
+use crate::tests::deferred::{deferred_gpu, render_passes};
+use crate::tests::particles::{Host, agree, params};
 use crate::tests::{Pattern, diff, n, tolerance};
-use crate::tests_adv3d::{off_share, run_of, scene, scene_project};
-use crate::tests_deferred::{deferred_gpu, render_passes};
-use crate::tests_particles::{Host, agree, params};
 
 /// The device's readbacks have landed (the browser's event loop; natively a poll).
 fn settle(g: &crate::Gpu) {
@@ -87,7 +87,7 @@ fn advanced_3d_resolves_in_passes() {
 #[test]
 fn job_frames_render_in_passes() {
     let Some((g, _lock)) = deferred_gpu() else { return };
-    let s = crate::tests_deferred::scene();
+    let s = crate::tests::deferred::scene();
     let t = Tick::from_seconds_f64(0.5);
     let cache = LayerCache::default();
     cache.set_gate(g.miss_gate());
diff --git a/crates/gpu/src/tests_fx_color.rs b/crates/gpu/src/tests/fx_color.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_color.rs
rename to crates/gpu/src/tests/fx_color.rs
diff --git a/crates/gpu/src/tests_fx_depth.rs b/crates/gpu/src/tests/fx_depth.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_depth.rs
rename to crates/gpu/src/tests/fx_depth.rs
diff --git a/crates/gpu/src/tests_fx_distort.rs b/crates/gpu/src/tests/fx_distort.rs
similarity index 95%
rename from crates/gpu/src/tests_fx_distort.rs
rename to crates/gpu/src/tests/fx_distort.rs
index 19cdcd605..1b8621408 100644
--- a/crates/gpu/src/tests_fx_distort.rs
+++ b/crates/gpu/src/tests/fx_distort.rs
@@ -55,6 +55,11 @@ fn turbulent_displace_and_cc_lens() {
         ],
     );
     effect_case("ec.distort.turbulentdisplace", &[("displacement", e(8)), ("size", n(15.0)), ("pinning", e(6))]);
+    // #943: Evolution moves the pattern at a constant rate on both paths, including steps of a
+    // few degrees and angles past a whole revolution, where an eased evolution axis diverges.
+    for evolution in [10.0, 37.0, 400.0, 725.5] {
+        effect_case("ec.distort.turbulentdisplace", &[("evolution", n(evolution)), ("size", n(12.0)), ("amount", n(30.0))]);
+    }
     effect_case("ec.distort.cclens", &[("size", n(70.0))]);
     effect_case("ec.distort.cclens", &[("size", n(45.0)), ("convergence", n(60.0)), ("center", Value::Vec2([30.0, 20.0]))]);
     effect_case("ec.distort.cclens", &[("convergence", n(-70.0))]);
diff --git a/crates/gpu/src/tests_fx_extra.rs b/crates/gpu/src/tests/fx_extra.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_extra.rs
rename to crates/gpu/src/tests/fx_extra.rs
diff --git a/crates/gpu/src/tests_fx_gen2.rs b/crates/gpu/src/tests/fx_gen2.rs
similarity index 99%
rename from crates/gpu/src/tests_fx_gen2.rs
rename to crates/gpu/src/tests/fx_gen2.rs
index 8eba75c8c..620cced13 100644
--- a/crates/gpu/src/tests_fx_gen2.rs
+++ b/crates/gpu/src/tests/fx_gen2.rs
@@ -7,8 +7,8 @@
 use effectcraft_keyframe::Value;
 use effectcraft_time::Tick;
 
+use crate::tests::fx_pixel2::{e, env_case, env_case_allow, env_case_at, off, on, pt};
 use crate::tests::{c, n};
-use crate::tests_fx_pixel2::{e, env_case, env_case_allow, env_case_at, off, on, pt};
 
 fn layer(id: u64) -> Value {
     Value::Layer(Some(id))
diff --git a/crates/gpu/src/tests_fx_generate.rs b/crates/gpu/src/tests/fx_generate.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_generate.rs
rename to crates/gpu/src/tests/fx_generate.rs
diff --git a/crates/gpu/src/tests_fx_key.rs b/crates/gpu/src/tests/fx_key.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_key.rs
rename to crates/gpu/src/tests/fx_key.rs
diff --git a/crates/gpu/src/tests_fx_light.rs b/crates/gpu/src/tests/fx_light.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_light.rs
rename to crates/gpu/src/tests/fx_light.rs
diff --git a/crates/gpu/src/tests_fx_lut.rs b/crates/gpu/src/tests/fx_lut.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_lut.rs
rename to crates/gpu/src/tests/fx_lut.rs
diff --git a/crates/gpu/src/tests_fx_noise.rs b/crates/gpu/src/tests/fx_noise.rs
similarity index 88%
rename from crates/gpu/src/tests_fx_noise.rs
rename to crates/gpu/src/tests/fx_noise.rs
index 476f08642..7d13004ee 100644
--- a/crates/gpu/src/tests_fx_noise.rs
+++ b/crates/gpu/src/tests/fx_noise.rs
@@ -22,6 +22,24 @@ fn pt(x: f64, y: f64) -> Value {
     Value::Vec2([x, y])
 }
 
+#[test]
+fn median_kernel_selection_preserves_physical_gpu_path() {
+    use crate::fx_noise::MedianKernel;
+    for backend in [wgpu::Backend::Vulkan, wgpu::Backend::Metal, wgpu::Backend::Dx12, wgpu::Backend::Gl, wgpu::Backend::BrowserWebGpu] {
+        for device_type in
+            [wgpu::DeviceType::DiscreteGpu, wgpu::DeviceType::IntegratedGpu, wgpu::DeviceType::VirtualGpu, wgpu::DeviceType::Cpu, wgpu::DeviceType::Other]
+        {
+            let selected = MedianKernel::for_adapter(backend, device_type);
+            let expected =
+                if backend == wgpu::Backend::Vulkan && device_type == wgpu::DeviceType::Cpu { MedianKernel::Software2 } else { MedianKernel::Private64 };
+            assert_eq!(selected, expected, "{backend:?} {device_type:?}");
+        }
+    }
+    assert_eq!(MedianKernel::Private64.rows_per_workgroup(), 64);
+    assert_eq!(MedianKernel::Software2.rows_per_workgroup(), 2);
+    assert_eq!(MedianKernel::Software2.workgroup_storage(), 16_384);
+}
+
 #[test]
 fn medians() {
     effect_case("ec.noise.median", &[("radius", n(2.0))]);
@@ -190,7 +208,7 @@ fn echo_and_posterize_time() {
             pos.keys = vec![Keyframe::new(Tick::ZERO, crate::tests::v3(10.0, 12.0)), Keyframe::new(Tick::from_seconds_f64(1.0), crate::tests::v3(50.0, 30.0))];
             let rot = a.props.prop_mut("transform/rotation").unwrap();
             rot.keys = vec![Keyframe::new(Tick::ZERO, Value::Scalar(0.0)), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Scalar(90.0))];
-            s.p.comp_mut(inner_id).unwrap().layers = vec![a];
+            s.p.comp_mut(inner_id).unwrap().layers = vec![a].into();
             let mut l = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (60, 40), None);
             s.effect(&mut l, id, &vals);
             set(&mut l, "transform/rotation", Value::Scalar(8.0));
@@ -237,8 +255,17 @@ fn median_levels_match_cpu_division() {
         // A monotone row's median is its centre, including repeated edges. Exercise both
         // the bisection and sliding-histogram kernels at every quantised level.
         let mut enc = crate::context::Enc::new(&g.ctx);
+        let started = std::time::Instant::now();
         let median = crate::fx_noise::median_image(&mut enc, &input, radius, false);
-        let actual = enc.download(&median).unwrap();
+        let actual = enc.download(&median).unwrap_or_else(|| {
+            panic!(
+                "median download radius {radius}; elapsed={:?}, health={:?}, unavailable={:?}, transfers={:?}",
+                started.elapsed(),
+                g.ctx.check_health(),
+                g.ctx.unavailable_kernels(),
+                g.ctx.transfer_stats()
+            )
+        });
         for (level, (want, got)) in image.data.iter().zip(&actual.data).enumerate() {
             assert_eq!(got, want, "radius {radius}, level {level}");
         }
@@ -273,7 +300,16 @@ fn dust_strict_threshold_boundaries() {
             let buf = effectcraft_effects::Buf { img, offset: [0.0; 2], scale: 1.0 };
             let cpu = (spec.render)(&ctx(), buf.clone());
             assert_eq!(cpu.img.data[24] != original, replaced, "CPU radius {radius}, threshold {threshold}");
-            let gpu = effectcraft_render::Accelerator::effects(g, &[effectcraft_render::FxStep { spec, ctx: ctx() }], &buf, None).unwrap();
+            let started = std::time::Instant::now();
+            let gpu = effectcraft_render::Accelerator::effects(g, &[effectcraft_render::FxStep { spec, ctx: ctx() }], &buf, None).unwrap_or_else(|| {
+                panic!(
+                    "dust radius {radius}, threshold {threshold}; elapsed={:?}, health={:?}, unavailable={:?}, transfers={:?}",
+                    started.elapsed(),
+                    g.ctx.check_health(),
+                    g.ctx.unavailable_kernels(),
+                    g.ctx.transfer_stats()
+                )
+            });
             assert_eq!(gpu.img.data[24], cpu.img.data[24], "radius {radius}, threshold {threshold}");
         }
     }
diff --git a/crates/gpu/src/tests_fx_particles.rs b/crates/gpu/src/tests/fx_particles.rs
similarity index 99%
rename from crates/gpu/src/tests_fx_particles.rs
rename to crates/gpu/src/tests/fx_particles.rs
index b67df9a43..e8c3a7ce6 100644
--- a/crates/gpu/src/tests_fx_particles.rs
+++ b/crates/gpu/src/tests/fx_particles.rs
@@ -7,8 +7,8 @@ use effectcraft_project::{BitDepth, LayerSource, build};
 use effectcraft_render::RenderOpts;
 use effectcraft_time::Tick;
 
+use crate::tests::fx_sim::{case, composited, e, off, on};
 use crate::tests::{Scene, check, compare_at, n, opts, set};
-use crate::tests_fx_sim::{case, composited, e, off, on};
 
 fn v2(x: f64, y: f64) -> Value {
     Value::Vec2([x, y])
diff --git a/crates/gpu/src/tests_fx_pixel2.rs b/crates/gpu/src/tests/fx_pixel2.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_pixel2.rs
rename to crates/gpu/src/tests/fx_pixel2.rs
diff --git a/crates/gpu/src/tests_fx_sim.rs b/crates/gpu/src/tests/fx_sim.rs
similarity index 83%
rename from crates/gpu/src/tests_fx_sim.rs
rename to crates/gpu/src/tests/fx_sim.rs
index dc2510bb3..4f54e07b6 100644
--- a/crates/gpu/src/tests_fx_sim.rs
+++ b/crates/gpu/src/tests/fx_sim.rs
@@ -105,6 +105,34 @@ fn bubbles_drizzle_mercury() {
     case("ec.sim.ccmrmercury", &[("birthRate", n(3.0)), ("blobInfluence", n(60.0)), ("shading/metal", n(80.0)), ("gravity", n(2.0))], 1.5, 0.0);
 }
 
+/// CC Bubbles on a buffer with transparent padding around the layer: both sides clamp the
+/// refraction samples to the layer rectangle, not to the buffer (#2024).
+#[test]
+fn bubbles_on_padded_buffers() {
+    let Some(g) = gpu() else { return };
+    let spec = effectcraft_effects::find("ec.sim.ccbubbles").unwrap();
+    let size = [70.0, 44.0];
+    for reflection in [0, 1] {
+        let mut params =
+            effectcraft_effects::Params { values: spec.params.iter().map(|ps| (ps.id.to_string(), effectcraft_effects::default_value(ps, size))).collect() };
+        for (k, v) in [("bubbleAmount", n(80.0)), ("bubbleSize", n(4.0)), ("reflectionType", e(reflection))] {
+            params.values.insert(k.to_string(), v);
+        }
+        for scale in [1.0, 0.5] {
+            let img = pattern(7, (size[0] * scale) as u32, (size[1] * scale) as u32);
+            let mut buf = effectcraft_effects::Buf { img, offset: [0.0, 0.0], scale };
+            buf.pad(6);
+            let ctx = || effectcraft_effects::EffectCtx { params: &params, time: 0.5, layer_size: size, seed: 11, adjustment: false, env: Default::default() };
+            let cpu = (spec.render)(&ctx(), buf.clone());
+            let out =
+                effectcraft_render::Accelerator::effects(g, &[effectcraft_render::FxStep { spec, ctx: ctx() }], &buf, None).expect("the GPU runs the effect");
+            assert_eq!((out.offset, out.scale), (cpu.offset, cpu.scale), "geometry");
+            let d = diff(&cpu.img, &out.img, 1e-3);
+            assert!(d.over == 0, "reflection {reflection} scale {scale}: {} of {} pixels over 1e-3 (max {}); worst {:?}", d.over, d.total, d.max, d.worst);
+        }
+    }
+}
+
 #[test]
 fn hair_wave_world_foam() {
     case("ec.sim.cchair", &[("density", n(300.0)), ("length", n(10.0))], 0.0, 0.0);
diff --git a/crates/gpu/src/tests_fx_stylize.rs b/crates/gpu/src/tests/fx_stylize.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_stylize.rs
rename to crates/gpu/src/tests/fx_stylize.rs
diff --git a/crates/gpu/src/tests_fx_text.rs b/crates/gpu/src/tests/fx_text.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_text.rs
rename to crates/gpu/src/tests/fx_text.rs
diff --git a/crates/gpu/src/tests_fx_time.rs b/crates/gpu/src/tests/fx_time.rs
similarity index 98%
rename from crates/gpu/src/tests_fx_time.rs
rename to crates/gpu/src/tests/fx_time.rs
index 0c94bb413..c71355736 100644
--- a/crates/gpu/src/tests_fx_time.rs
+++ b/crates/gpu/src/tests/fx_time.rs
@@ -40,7 +40,7 @@ fn moving(id: &str, vals: &[(&str, Value)], map: Option<&str>) {
         pos.keys = vec![Keyframe::new(Tick::ZERO, v3(10.0, 12.0)), Keyframe::new(Tick::from_seconds_f64(1.0), v3(50.0, 30.0))];
         let rot = a.props.prop_mut("transform/rotation").unwrap();
         rot.keys = vec![Keyframe::new(Tick::ZERO, Value::Scalar(0.0)), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Scalar(90.0))];
-        s.p.comp_mut(inner_id).unwrap().layers = vec![a];
+        s.p.comp_mut(inner_id).unwrap().layers = vec![a].into();
         let mut l = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (60, 40), None);
         s.effect(&mut l, id, &vals);
         set(&mut l, "transform/rotation", Value::Scalar(8.0));
diff --git a/crates/gpu/src/tests_fx_tone.rs b/crates/gpu/src/tests/fx_tone.rs
similarity index 99%
rename from crates/gpu/src/tests_fx_tone.rs
rename to crates/gpu/src/tests/fx_tone.rs
index 08212a12a..40bc9483f 100644
--- a/crates/gpu/src/tests_fx_tone.rs
+++ b/crates/gpu/src/tests/fx_tone.rs
@@ -164,7 +164,7 @@ fn color_stabilizer() {
             pos.keys = vec![Keyframe::new(Tick::ZERO, crate::tests::v3(22.0, 18.0)), Keyframe::new(Tick::from_seconds_f64(1.0), crate::tests::v3(38.0, 24.0))];
             let op = a.props.prop_mut("transform/opacity").unwrap();
             op.keys = vec![Keyframe::new(Tick::ZERO, Value::Scalar(100.0)), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Scalar(40.0))];
-            s.p.comp_mut(inner_id).unwrap().layers = vec![a];
+            s.p.comp_mut(inner_id).unwrap().layers = vec![a].into();
             let mut l = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (60, 40), None);
             let vals = [
                 ("stabilize", e(mode)),
diff --git a/crates/gpu/src/tests_fx_transition.rs b/crates/gpu/src/tests/fx_transition.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_transition.rs
rename to crates/gpu/src/tests/fx_transition.rs
diff --git a/crates/gpu/src/tests_fx_vr.rs b/crates/gpu/src/tests/fx_vr.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_vr.rs
rename to crates/gpu/src/tests/fx_vr.rs
diff --git a/crates/gpu/src/tests_fx_warp.rs b/crates/gpu/src/tests/fx_warp.rs
similarity index 100%
rename from crates/gpu/src/tests_fx_warp.rs
rename to crates/gpu/src/tests/fx_warp.rs
diff --git a/crates/gpu/src/tests_init.rs b/crates/gpu/src/tests/init.rs
similarity index 89%
rename from crates/gpu/src/tests_init.rs
rename to crates/gpu/src/tests/init.rs
index 9c579ae69..4578a8489 100644
--- a/crates/gpu/src/tests_init.rs
+++ b/crates/gpu/src/tests/init.rs
@@ -2,7 +2,6 @@
 //! Set EFFECTCRAFT_REQUIRE_GPU=1 for acceptance: unavailable adapters/devices then fail
 //! instead of taking the explicitly logged headless-CI skip path.
 #![cfg(not(target_arch = "wasm32"))]
-#![allow(clippy::expect_used)] // Test helpers require successful setup to exercise rejection.
 
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -149,23 +148,28 @@ fn opengl_adapters_get_cpu_compositing_at_once() {
     assert!(t.elapsed() < std::time::Duration::from_secs(1), "{:?}", t.elapsed());
 }
 
+/// #613: FXC (DirectX 12's default shader compiler) builds Classic 3D, so the compositor starts
+/// on DirectX 12 with its 3D kernel, and initialization leaves the caller's error scope and the
+/// host's error handler untouched. Ignored by default: FXC compiles every kernel, which takes
+/// minutes. Skips where there is no DirectX 12 adapter.
 #[test]
 #[cfg(target_os = "windows")]
-#[ignore = "requires the reproduced Windows DX12/FXC pointwise compiler failure; no adapter skips"]
-fn reproduced_fxc_pointwise_failure_returns_error_without_escaping_or_notifying_host() {
+#[ignore = "slow: FXC compiles every kernel"]
+fn fxc_builds_classic3d_and_initialization_errors_stay_scoped() {
     let mut desc = wgpu::InstanceDescriptor::new_without_display_handle();
     desc.backends = wgpu::Backends::DX12;
     desc.backend_options.dx12.shader_compiler = wgpu::Dx12Compiler::Fxc;
-    let (adapter, device, queue) = native_device(desc, true).expect("required DX12 device");
+    let Some((adapter, device, queue)) = native_device(desc, false) else { return };
     assert_eq!(adapter.get_info().backend, wgpu::Backend::Dx12);
     let host = count_host_errors(&device);
     let outer = device.push_error_scope(wgpu::ErrorFilter::Validation);
     let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| GpuContext::new(&adapter, device.clone(), queue)));
-    let error = match result.expect("FXC compiler failure must not escape the constructor") {
-        Err(error) => error,
-        Ok(_) => panic!("the platform-specific FXC failure no longer reproduces; reassess this diagnostic"),
+    let ctx = match result.expect("an FXC compiler failure must not escape the constructor") {
+        Ok(ctx) => ctx,
+        Err(error) => panic!("the compositor starts on DirectX 12 with FXC: {}", brief(error)),
     };
-    assert!(error.contains("GPU initialization (pointwise)") && error.contains("FXC D3DCompile"), "{}", brief(error));
+    let missing: Vec<&str> = ctx.unavailable_kernels().iter().map(|(e, _)| *e).collect();
+    assert!(ctx.has_kernel("classic3d"), "FXC builds classic3d (unavailable: {missing:?})");
     assert!(pollster::block_on(outer.pop()).is_none(), "constructor must drain its own scopes and leave the caller's scope clean");
     assert_eq!(host.load(Ordering::SeqCst), 0);
     valid_pipeline(&device);
diff --git a/crates/gpu/src/tests_particles.rs b/crates/gpu/src/tests/particles.rs
similarity index 67%
rename from crates/gpu/src/tests_particles.rs
rename to crates/gpu/src/tests/particles.rs
index d2a229b0f..e11dd6585 100644
--- a/crates/gpu/src/tests_particles.rs
+++ b/crates/gpu/src/tests/particles.rs
@@ -91,6 +91,79 @@ fn particle_world_matches_the_cpu() {
     }
 }
 
+/// A host whose Birth Rate is `rate(layer time)` (#1373), with the GPU backend or without (the
+/// CPU oracle).
+struct Keyed {
+    gpu: Option<&'static Gpu>,
+    rate: fn(f64) -> f64,
+}
+
+impl EffectHost for Keyed {
+    fn layer(&self, _id: u64, _masks_and_effects: bool) -> Option<LayerPixels> {
+        None
+    }
+    fn audio(&self, _id: u64, _start: f64, _frames: usize, _rate: u32) -> Option<Vec<f32>> {
+        None
+    }
+    fn particles(&self) -> Option<&dyn ParticleSim> {
+        self.gpu.map(|g| g as &dyn ParticleSim)
+    }
+    fn param_at(&self, _effect_index: usize, id: &str, t: f64) -> Option<Value> {
+        (id == "birthRate").then(|| n((self.rate)(t)))
+    }
+}
+
+/// Effect `id`'s live particles at layer time `t` through `host`.
+fn keyed_state(id: &str, p: &Params, t: f64, host: &Keyed) -> Vec<SimParticle> {
+    let env = EffectEnv { host: Some(host), ..Default::default() };
+    let ctx = EffectCtx { params: p, time: t, layer_size: [320.0, 240.0], seed: 5, adjustment: false, env };
+    effectcraft_effects::particle_state(id, &ctx).unwrap()
+}
+
+/// 3 a second from 0 to 0.5 s.
+fn early(t: f64) -> f64 {
+    if t < 0.5 { 3.0 } else { 0.0 }
+}
+
+/// 3 a second from 0.25 to 0.75 s: as many births by 0.9 s as [`early`], at other steps.
+fn late(t: f64) -> f64 {
+    if (0.25..0.75).contains(&t) { 3.0 } else { 0.0 }
+}
+
+/// Effect `id` (parameters `p`) under the [`early`] then the [`late`] Birth Rate history: the
+/// GPU's particles match the CPU's, and each really came from the GPU.
+fn keyed_agree(id: &str, p: &Params, g: &'static Gpu) {
+    for (rate, times) in [(early as fn(f64) -> f64, [0.4, 0.9, 1.2]), (late, [0.9, 1.2, 0.6])] {
+        let (cpu_host, gpu_host) = (Keyed { gpu: None, rate }, Keyed { gpu: Some(g), rate });
+        for t in times {
+            let cpu = keyed_state(id, p, t, &cpu_host);
+            let before = crate::particles::DISPATCHES.load(std::sync::atomic::Ordering::Relaxed);
+            let gpu = keyed_state(id, p, t, &gpu_host);
+            assert!(crate::particles::DISPATCHES.load(std::sync::atomic::Ordering::Relaxed) > before, "{id} t {t}: simulated on the GPU");
+            agree(&format!("{id} keyed birth rate t {t}"), &cpu, &gpu, 1e-4, cpu.len() / 100 + 1);
+        }
+    }
+}
+
+/// #1373: with a keyed Birth Rate the GPU is given the births of each moment, as the CPU
+/// simulates them: a burst lives on after the rate drops to 0, and a GPU checkpoint of one
+/// history is not resumed for another with the same system key, even when both have born as
+/// many particles (180 by 0.9 s here) at other steps.
+#[test]
+fn particle_world_with_a_keyed_birth_rate_matches_the_cpu() {
+    let Some(g) = gpu() else { return };
+    let p = params("ec.sim.ccparticleworld", &[("birthRate", n(0.0)), ("longevity", n(1.2)), ("extras/randomSeed", n(21.0))]);
+    keyed_agree("ec.sim.ccparticleworld", &p, g);
+}
+
+/// The same for CC Particle Systems II (90 births by 0.9 s in both histories).
+#[test]
+fn particle_systems_ii_with_a_keyed_birth_rate_matches_the_cpu() {
+    let Some(g) = gpu() else { return };
+    let p = params("ec.sim.ccparticlesystems2", &[("birthRate", n(0.0)), ("longevity", n(1.2)), ("randomSeed", n(22.0))]);
+    keyed_agree("ec.sim.ccparticlesystems2", &p, g);
+}
+
 #[test]
 fn particle_systems_ii_matches_the_cpu() {
     let Some(g) = gpu() else { return };
diff --git a/crates/gpu/src/tests_3d.rs b/crates/gpu/src/tests/three_d.rs
similarity index 84%
rename from crates/gpu/src/tests_3d.rs
rename to crates/gpu/src/tests/three_d.rs
index bd9455b9e..acdbea7b1 100644
--- a/crates/gpu/src/tests_3d.rs
+++ b/crates/gpu/src/tests/three_d.rs
@@ -11,7 +11,7 @@ use effectcraft_project::{BitDepth, Comp, ItemKind, Layer, LayerSource, LightKin
 use effectcraft_render::{Backend, RenderOpts, Renderer};
 use effectcraft_time::{FrameRate, Tick};
 
-use crate::tests::{Pattern, Scene, check, compare_at, gpu, n, opts, set};
+use crate::tests::{Pattern, Scene, check, compare_at, diff, gpu, n, opts, set, tolerance};
 
 const W: u32 = 160;
 const H: u32 = 100;
@@ -133,6 +133,22 @@ fn lights_specular_transmission_and_shadows() {
     }
 }
 
+#[test]
+fn wide_shadow_diffusion() {
+    // #2444: a wide penumbra takes more than the 3 × 3 kernel's samples; both sides pick the
+    // same count.
+    for depth in [BitDepth::Bpc8, BitDepth::Bpc32] {
+        let mut s = crossing(depth, BlendMode::Normal);
+        for l in &mut s.p.comp_mut(s.cid).unwrap().layers {
+            if l.switches.three_d {
+                set(l, "materialOptions/castsShadows", Value::Enum(1));
+            }
+        }
+        light(&mut s, LightKind::Point, [150.0, 20.0, -80.0], &[("castsShadows", Value::Bool(true)), ("shadowDiffusion", n(60.0))]);
+        check(&format!("wide shadow diffusion {depth:?}"), compare_at(&s, opts(), Tick::ZERO), 0.005);
+    }
+}
+
 #[test]
 fn depth_of_field_and_motion_blur() {
     for depth in [BitDepth::Bpc8, BitDepth::Bpc32] {
@@ -161,7 +177,7 @@ fn mattes_preserve_transparency_precomps_and_adjustment_splits() {
         let mid = s.push(m);
         let layers = &mut s.p.comp_mut(s.cid).unwrap().layers;
         layers[1].track_matte = Some(TrackMatte { layer: mid, kind: MatteKind::Luma });
-        if let Some(far) = layers.iter_mut().find(|l| l.switches.three_d && l.name == "Pattern") {
+        if let Some(far) = layers.find_mut(|l| l.switches.three_d && l.name == "Pattern") {
             far.preserve_transparency = true;
         }
         // Move the matte below the bottom so the 3D run stays one run.
@@ -187,7 +203,7 @@ fn mattes_preserve_transparency_precomps_and_adjustment_splits() {
         a.switches.three_d = true;
         set(&mut a, "transform/rotationX", Value::Scalar(40.0));
         let b = s.solid([0.2, 0.8, 0.4], 30, 20);
-        s.p.comp_mut(inner_id).unwrap().layers = vec![b, a];
+        s.p.comp_mut(inner_id).unwrap().layers = vec![b, a].into();
         let mut pre = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (80, 60), None);
         pre.switches.collapse = true;
         pre.switches.three_d = true;
@@ -209,6 +225,10 @@ fn the_gpu_draws_classic_3d_runs_itself() {
     assert_eq!(prep.planes.iter().filter(|p| p.draw).count(), 3);
     let mut e = crate::context::Enc::new(g.context());
     let canvas = e.image(W, H);
+    if !g.context().has_kernel("classic3d") {
+        // FXC (DirectX 12) can't build the kernel (#613); the CPU fallback is tested below.
+        return;
+    }
     let out = crate::classic3d::draw_run(&mut e, &prep, &canvas).expect("the kernel draws the run");
     let img = e.download(&out).unwrap();
     let mut cpu = effectcraft_raster::Image::new(W, H);
@@ -253,7 +273,9 @@ fn bokeh_depth_of_field_runs_on_the_gpu() {
                 assert!(prep.planes.iter().filter(|p| p.draw).all(|p| p.dof.is_some()), "{label}: depth of field deferred to the GPU");
                 let mut e = crate::context::Enc::new(g.context());
                 let canvas = e.image(W, H);
-                assert!(crate::classic3d::draw_run(&mut e, &prep, &canvas).is_some(), "{label}: drawn on the GPU");
+                if g.context().has_kernel("classic3d") {
+                    assert!(crate::classic3d::draw_run(&mut e, &prep, &canvas).is_some(), "{label}: drawn on the GPU");
+                }
             }
         }
     }
@@ -277,7 +299,7 @@ fn two_d_layer_with_a_three_d_track_matte() {
             let layers = &mut s.p.comp_mut(s.cid).unwrap().layers;
             let fi = layers.iter().position(|l| l.id == fid).unwrap();
             layers[fi].track_matte = Some(TrackMatte { layer: mid, kind });
-            if let Some(ml) = layers.iter_mut().find(|l| l.id == mid) {
+            if let Some(ml) = layers.find_mut(|l| l.id == mid) {
                 ml.switches.video = false;
             }
             check(&format!("3d matte {kind:?} {depth:?}"), compare_at(&s, opts(), Tick::ZERO), 0.005);
@@ -288,3 +310,27 @@ fn two_d_layer_with_a_three_d_track_matte() {
         }
     }
 }
+
+/// #613: FXC on DirectX 12 fails to build `classic3d` (it can't unroll its loops). The
+/// compositor still starts without it, lists it, and 3D runs render on the CPU, matching the
+/// CPU render.
+#[test]
+fn classic_3d_runs_render_on_the_cpu_without_the_kernel() {
+    let Some(base) = gpu() else {
+        return;
+    };
+    let ctx = base.context().without_kernel("classic3d");
+    assert!(!ctx.has_kernel("classic3d"));
+    let g = crate::Gpu::from_context(ctx);
+    for depth in [BitDepth::Bpc8, BitDepth::Bpc32] {
+        let mut s = crossing(depth, BlendMode::Normal);
+        camera(&mut s, [30.0, 20.0, -260.0], None);
+        let cpu = Renderer::new(&s.p, &Pattern, RenderOpts { backend: Backend::Cpu, ..opts() }).comp_frame_cpu(s.cid, Tick::ZERO);
+        let mut r = Renderer::new(&s.p, &Pattern, RenderOpts { backend: Backend::Gpu, ..opts() });
+        r.accel = Some(&g);
+        let img = g.render(&r, s.cid, Tick::ZERO).expect("the GPU renders the frame");
+        let mut d = diff(&cpu, &img, tolerance(depth));
+        d.quantized = depth != BitDepth::Bpc32;
+        check(&format!("classic 3D without its kernel {depth:?}"), Some(d), 0.0);
+    }
+}
diff --git a/crates/gpu/src/tests_wgsl_grammar.rs b/crates/gpu/src/tests/wgsl_grammar.rs
similarity index 53%
rename from crates/gpu/src/tests_wgsl_grammar.rs
rename to crates/gpu/src/tests/wgsl_grammar.rs
index 18fef7a0f..dfb75b5a5 100644
--- a/crates/gpu/src/tests_wgsl_grammar.rs
+++ b/crates/gpu/src/tests/wgsl_grammar.rs
@@ -22,9 +22,22 @@ enum Tok<'a> {
 
 const BITWISE: [&str; 3] = ["&", "|", "^"];
 
+const OPS: [&str; 18] = ["&&", "||", "==", "!=", "<=", ">=", "<<", ">>", "<", ">", "+", "-", "*", "/", "%", "&", "|", "^"];
+
 /// Drop comments and template argument lists (`vec3<f32>`, `array<vec4<u32>>`), whose
 /// angle brackets are not relational operators.
 fn strip(src: &str) -> String {
+    let mut out = drop_comments(src);
+    loop {
+        let (next, changed) = drop_template_lists_once(&out);
+        out = next;
+        if !changed {
+            return out;
+        }
+    }
+}
+
+fn drop_comments(src: &str) -> String {
     let mut out = String::with_capacity(src.len());
     let b = src.as_bytes();
     let mut i = 0;
@@ -45,31 +58,104 @@ fn strip(src: &str) -> String {
             i += 1;
         }
     }
-    loop {
-        let mut changed = false;
-        let mut next = String::with_capacity(out.len());
-        let c: Vec<char> = out.chars().collect();
-        let mut i = 0;
-        while i < c.len() {
-            if c[i] == '<' && i > 0 && (c[i - 1].is_alphanumeric() || c[i - 1] == '_') {
-                let mut j = i + 1;
-                while j < c.len() && (c[j].is_alphanumeric() || c[j] == '_' || c[j] == ',' || c[j] == ' ') {
-                    j += 1;
-                }
-                if j < c.len() && c[j] == '>' {
-                    i = j + 1;
-                    changed = true;
-                    continue;
-                }
+    out
+}
+
+/// One pass over `out` dropping every template argument list. Returns whether one was dropped.
+fn drop_template_lists_once(out: &str) -> (String, bool) {
+    let mut changed = false;
+    let mut next = String::with_capacity(out.len());
+    let c: Vec<char> = out.chars().collect();
+    let mut i = 0;
+    while i < c.len() {
+        if let Some(end) = template_list_end(&c, i) {
+            i = end;
+            changed = true;
+            continue;
+        }
+        next.push(c[i]);
+        i += 1;
+    }
+    (next, changed)
+}
+
+/// If `c[i]` opens a template argument list after an identifier, the index just past its `>`.
+fn template_list_end(c: &[char], i: usize) -> Option<usize> {
+    let prev = i.checked_sub(1).and_then(|p| c.get(p))?;
+    if c.get(i) != Some(&'<') || !(prev.is_alphanumeric() || *prev == '_') {
+        return None;
+    }
+    let mut j = i + 1;
+    while let Some(&ch) = c.get(j) {
+        if !(ch.is_alphanumeric() || ch == '_' || ch == ',' || ch == ' ') {
+            break;
+        }
+        j += 1;
+    }
+    (c.get(j) == Some(&'>')).then_some(j + 1)
+}
+
+/// Scans the token starting at `*at` (not whitespace) and advances `*at` past it.
+fn next_token<'a>(s: &'a str, at: &mut usize) -> Tok<'a> {
+    let b = s.as_bytes();
+    let Some(&ch) = b.get(*at) else {
+        return Tok::Sep;
+    };
+    let mut i = *at;
+    let tok = if ch.is_ascii_alphanumeric() || ch == b'_' || ch == b'.' {
+        // Identifier, member access or number (`1e-6`, `0x9E3779B9u`).
+        let start = i;
+        while i < b.len() && (b[i].is_ascii_alphanumeric() || b[i] == b'_' || b[i] == b'.') {
+            if (b[i] == b'e' || b[i] == b'E')
+                && b[start].is_ascii_digit()
+                && !s[start..i].starts_with("0x")
+                && i + 1 < b.len()
+                && (b[i + 1] == b'-' || b[i + 1] == b'+')
+            {
+                i += 1;
             }
-            next.push(c[i]);
             i += 1;
         }
-        out = next;
-        if !changed {
-            return out;
+        Tok::Operand
+    } else if ch == b'(' || ch == b'[' {
+        i += 1;
+        Tok::Open
+    } else if ch == b')' || ch == b']' {
+        i += 1;
+        Tok::Close
+    } else if b[i..].starts_with(b"->") || b[i..].starts_with(b"++") || b[i..].starts_with(b"--") {
+        i += 2;
+        Tok::Sep
+    } else if matches!(ch, b',' | b';' | b'{' | b'}' | b':' | b'@') {
+        i += 1;
+        Tok::Sep
+    } else if let Some(op) = OPS.iter().find(|op| b[i..].starts_with(op.as_bytes())) {
+        i += op.len();
+        if b.get(i) == Some(&b'=') && !matches!(*op, "==" | "!=" | "<=" | ">=") {
+            i += 1;
+            Tok::Sep // compound assignment
+        } else {
+            Tok::Op(op)
         }
+    } else if ch == b'=' {
+        i += 1;
+        Tok::Sep
+    } else {
+        i += 1;
+        Tok::Prefix
+    };
+    *at = i;
+    tok
+}
+
+/// Records a binary operator at the current parenthesis level, reporting it if it mixes with
+/// one already seen there.
+fn note_operator<'a>(level: &mut Vec<&'a str>, op: &'a str, line: usize, out: &mut Vec<(usize, String)>) {
+    let mixes = |a: &str, b: &str| a != b && (BITWISE.contains(&a) || BITWISE.contains(&b));
+    if let Some(other) = level.iter().find(|o| mixes(o, op)) {
+        out.push((line, format!("mixing '{other}' and '{op}' requires parentheses")));
     }
+    level.push(op);
 }
 
 /// `(line, message)` for every bitwise operator mixed with another binary operator at
@@ -82,7 +168,6 @@ fn violations(src: &str) -> Vec<(usize, String)> {
     let mut levels: Vec<Vec<&str>> = vec![vec![]];
     let mut prev = Tok::Sep;
     let (mut i, mut line) = (0, 1);
-    const OPS: [&str; 18] = ["&&", "||", "==", "!=", "<=", ">=", "<<", ">>", "<", ">", "+", "-", "*", "/", "%", "&", "|", "^"];
     while i < b.len() {
         let ch = b[i];
         if ch == b'\n' {
@@ -94,53 +179,12 @@ fn violations(src: &str) -> Vec<(usize, String)> {
             i += 1;
             continue;
         }
-        let tok = if ch.is_ascii_alphanumeric() || ch == b'_' || ch == b'.' {
-            // Identifier, member access or number (`1e-6`, `0x9E3779B9u`).
-            let start = i;
-            while i < b.len() && (b[i].is_ascii_alphanumeric() || b[i] == b'_' || b[i] == b'.') {
-                if (b[i] == b'e' || b[i] == b'E')
-                    && b[start].is_ascii_digit()
-                    && !s[start..i].starts_with("0x")
-                    && i + 1 < b.len()
-                    && (b[i + 1] == b'-' || b[i + 1] == b'+')
-                {
-                    i += 1;
-                }
-                i += 1;
-            }
-            Tok::Operand
-        } else if ch == b'(' || ch == b'[' {
-            i += 1;
-            levels.push(vec![]);
-            Tok::Open
-        } else if ch == b')' || ch == b']' {
-            i += 1;
-            if levels.len() > 1 {
+        let tok = next_token(&s, &mut i);
+        match tok {
+            Tok::Open => levels.push(vec![]),
+            Tok::Close if levels.len() > 1 => {
                 levels.pop();
             }
-            Tok::Close
-        } else if b[i..].starts_with(b"->") || b[i..].starts_with(b"++") || b[i..].starts_with(b"--") {
-            i += 2;
-            Tok::Sep
-        } else if matches!(ch, b',' | b';' | b'{' | b'}' | b':' | b'@') {
-            i += 1;
-            Tok::Sep
-        } else if let Some(op) = OPS.iter().find(|op| b[i..].starts_with(op.as_bytes())) {
-            i += op.len();
-            if b.get(i) == Some(&b'=') && !matches!(*op, "==" | "!=" | "<=" | ">=") {
-                i += 1;
-                Tok::Sep // compound assignment
-            } else {
-                Tok::Op(op)
-            }
-        } else if ch == b'=' {
-            i += 1;
-            Tok::Sep
-        } else {
-            i += 1;
-            Tok::Prefix
-        };
-        match tok {
             Tok::Sep => {
                 if let Some(l) = levels.last_mut() {
                     l.clear();
@@ -148,11 +192,7 @@ fn violations(src: &str) -> Vec<(usize, String)> {
             }
             Tok::Op(op) if matches!(prev, Tok::Operand | Tok::Close) => {
                 let level = levels.last_mut().expect("level");
-                let mixes = |a: &str, b: &str| a != b && (BITWISE.contains(&a) || BITWISE.contains(&b));
-                if let Some(other) = level.iter().find(|o| mixes(o, op)) {
-                    out.push((line, format!("mixing '{other}' and '{op}' requires parentheses")));
-                }
-                level.push(op);
+                note_operator(level, op, line, &mut out);
             }
             _ => {}
         }
diff --git a/crates/gpu/src/walk.rs b/crates/gpu/src/walk.rs
index b6e78870c..fdcb58dd4 100644
--- a/crates/gpu/src/walk.rs
+++ b/crates/gpu/src/walk.rs
@@ -17,6 +17,12 @@ use effectcraft_time::Tick;
 use crate::context::{Enc, GpuImage};
 use crate::ops;
 
+/// The size [`render`] renders `comp_id` at, without rendering it.
+pub(crate) fn frame_size(r: &Renderer, comp_id: ItemId, t: Tick) -> Option<(u32, u32)> {
+    let ctx = r.eval_ctx(comp_id, t)?;
+    Some(effectcraft_render::frame_size(ctx.comp.width, ctx.comp.height, r.opts.scale))
+}
+
 /// Render a comp frame into a GPU image (the canvas in the output space, as
 /// `Renderer::comp_frame_cpu` returns it). `None` when something cannot run here (the caller
 /// renders on the CPU instead).
@@ -83,7 +89,7 @@ fn draw_comp<'a>(e: &mut Enc, r: &Renderer<'a>, ctx: &EvalCtx<'a>, canvas: &mut
             i = j;
         } else {
             match r.collapsed(ctx, visible[i]) {
-                Some(item) => draw_collapsed(e, r, ctx, visible[i], item, canvas)?,
+                Some(collapsed) => draw_collapsed(e, r, ctx, visible[i], &collapsed, canvas)?,
                 None => draw_layer(e, r, ctx, visible[i], canvas)?,
             }
             i += 1;
@@ -181,19 +187,26 @@ fn draw_split(e: &mut Enc, r: &Renderer, ctx: &EvalCtx, split: &effectcraft_rend
     Some(cv)
 }
 
-fn draw_collapsed<'a>(e: &mut Enc, r: &Renderer<'a>, ctx: &EvalCtx<'a>, layer: &Layer, item: ItemId, canvas: &mut GpuImage) -> Option<()> {
+fn draw_collapsed<'a>(
+    e: &mut Enc,
+    r: &Renderer<'a>,
+    ctx: &EvalCtx<'a>,
+    layer: &'a Layer,
+    collapsed: &effectcraft_render::Collapsed,
+    canvas: &mut GpuImage,
+) -> Option<()> {
     let opacity = r.layer_opacity(ctx, layer);
     if opacity <= 0.0 {
         return Some(());
     }
     let matte = r.track_matte(ctx, layer).is_some();
     if layer.blend_mode == BlendMode::Normal && !matte && !layer.preserve_transparency {
-        if let Some((sub, nctx)) = r.collapse_into(ctx, layer, item, opacity) {
+        if let Some((sub, nctx)) = r.collapse_into(ctx, layer, collapsed, opacity) {
             draw_comp(e, &sub, &nctx, canvas)?;
         }
         return Some(());
     }
-    let Some((sub, nctx)) = r.collapse_into(ctx, layer, item, 1.0) else { return Some(()) };
+    let Some((sub, nctx)) = r.collapse_into(ctx, layer, collapsed, 1.0) else { return Some(()) };
     let mut iso = e.zeros(canvas.width, canvas.height);
     draw_comp(e, &sub, &nctx, &mut iso)?;
     composite_iso(e, r, ctx, layer, iso, canvas, opacity)
@@ -339,8 +352,8 @@ fn draw_precomp(e: &mut Enc, r: &Renderer, ctx: &EvalCtx, layer: &Layer, canvas:
 
 /// Adjustment layer (`Renderer::draw_adjustment`): the effect stack runs on the comp below,
 /// resident on the GPU (non-GPU effects read back, run on the CPU and upload), and the result
-/// replaces the canvas inside the layer's footprint × track matte × opacity. `None` = draw it
-/// on the CPU.
+/// replaces the canvas inside the layer's footprint × track matte × opacity, or blends onto it in
+/// the layer's blend mode when that isn't Normal. `None` = draw it on the CPU.
 fn draw_adjustment(e: &mut Enc, r: &Renderer, ctx: &EvalCtx, layer: &Layer, canvas: &mut GpuImage) -> Option<()> {
     let opacity = r.layer_opacity(ctx, layer);
     let Some(foot) = r.adjustment_footprint(ctx, layer) else { return Some(()) };
@@ -366,7 +379,13 @@ fn draw_adjustment(e: &mut Enc, r: &Renderer, ctx: &EvalCtx, layer: &Layer, canv
     if let Some(c) = pipe.to_blend() {
         adjusted = ops::convert(e, &adjusted, &c);
     }
-    *canvas = ops::adjust_mix(e, canvas, &adjusted, &matte, opacity);
+    *canvas = if layer.blend_mode == BlendMode::Normal {
+        ops::adjust_mix(e, canvas, &adjusted, &matte, opacity)
+    } else {
+        // The adjusted comp is a layer in that mode over the comp below (#2618).
+        let iso = ops::matte(e, &adjusted, &matte, effectcraft_project::MatteKind::Alpha);
+        ops::blend_full(e, canvas, &iso, layer.blend_mode, opacity, layer.id.0 as u32, None)
+    };
     Some(())
 }
 
@@ -466,12 +485,12 @@ fn place_src(
 ) -> Option<GpuImage> {
     let pl = r.placement(ctx, layer, buf);
     if let [m] = pl.matrices.as_slice() {
-        return Some(ops::warp_q(e, target, &src, m, pl.sampling, mode, opacity, pl.seed, None, levels));
+        return Some(ops::warp_q(e, target, &src, m, ops::WarpOptions { sampling: pl.sampling, mode, opacity, seed: pl.seed }, None, levels));
     }
     let mut acc = e.zeros(target.width, target.height);
     let k = 1.0 / pl.matrices.len() as f32;
     for m in &pl.matrices {
-        acc = ops::warp(e, &acc, &src, m, pl.sampling, BlendMode::Normal, 1.0, 0, Some(k));
+        acc = ops::warp(e, &acc, &src, m, ops::WarpOptions { sampling: pl.sampling, mode: BlendMode::Normal, opacity: 1.0, seed: 0 }, Some(k));
     }
     Some(ops::blend_full(e, target, &acc, mode, opacity, pl.seed, levels))
 }
diff --git a/crates/gpu/src/yuv.rs b/crates/gpu/src/yuv.rs
new file mode 100644
index 000000000..aba3ec700
--- /dev/null
+++ b/crates/gpu/src/yuv.rs
@@ -0,0 +1,403 @@
+//! Export frames converted on the device to the H.264 encoder's input (8-bit BT.709 limited
+//! range 4:2:0, see `shaders/yuv.wgsl`): a 4K frame reads back 12 MB of planes instead of
+//! 133 MB of RGBA f32, and the CPU skips `to_rgba8_over` + `rgba_to_yuv420`.
+
+use wgpu::util::DeviceExt;
+
+use crate::context::{Enc, GpuImage};
+
+pub(crate) struct YuvPipe {
+    bgl: wgpu::BindGroupLayout,
+    pipe: wgpu::ComputePipeline,
+}
+
+impl YuvPipe {
+    pub(crate) fn new(device: &wgpu::Device) -> Result<YuvPipe, String> {
+        crate::context::init_resource(device, "yuv420", || {
+            let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+                label: Some("yuv420"),
+                source: wgpu::ShaderSource::Wgsl(include_str!("shaders/yuv.wgsl").into()),
+            });
+            let storage =
+                wgpu::BindingType::Buffer { ty: wgpu::BufferBindingType::Storage { read_only: false }, has_dynamic_offset: false, min_binding_size: None };
+            let bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: Some("yuv420"),
+                entries: &[
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 0,
+                        visibility: wgpu::ShaderStages::COMPUTE,
+                        ty: wgpu::BindingType::Buffer { ty: wgpu::BufferBindingType::Uniform, has_dynamic_offset: false, min_binding_size: None },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStages::COMPUTE,
+                        ty: wgpu::BindingType::Texture {
+                            sample_type: wgpu::TextureSampleType::Float { filterable: false },
+                            view_dimension: wgpu::TextureViewDimension::D2,
+                            multisampled: false,
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry { binding: 2, visibility: wgpu::ShaderStages::COMPUTE, ty: storage, count: None },
+                ],
+            });
+            let layout =
+                device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("yuv420"), bind_group_layouts: &[Some(&bgl)], immediate_size: 0 });
+            let pipe = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+                label: Some("yuv420"),
+                layout: Some(&layout),
+                module: &module,
+                entry_point: Some("yuv420"),
+                compilation_options: Default::default(),
+                cache: None,
+            });
+            YuvPipe { bgl, pipe }
+        })
+    }
+}
+
+/// The frame sizes the kernel handles: width a multiple of 8 (4 chroma samples per
+/// invocation), height even.
+pub(crate) fn supported(w: u32, h: u32) -> bool {
+    w > 0 && h > 0 && w.is_multiple_of(8) && h.is_multiple_of(2)
+}
+
+/// Bytes of the planes: Y `w×h`, then U and V `w/2 × h/2`.
+pub(crate) fn planes_len(w: u32, h: u32) -> u64 {
+    w as u64 * h as u64 + 2 * ((w / 2) as u64 * (h / 2) as u64)
+}
+
+/// Whether the [`planes_len`] storage and staging buffers for `w×h` fit within `limits`.
+pub(crate) fn fits_limits(w: u32, h: u32, limits: &wgpu::Limits) -> bool {
+    let size = planes_len(w, h);
+    size <= limits.max_storage_buffer_binding_size && size <= limits.max_buffer_size
+}
+
+/// Record the conversion of `img` over `bg` into a new `MAP_READ` buffer of
+/// [`planes_len`] bytes and submit it. `None`: the size is not [`supported`], exceeds the
+/// device's buffer limits, or buffer allocation failed.
+pub(crate) fn record(e: &mut Enc, yp: &YuvPipe, img: &GpuImage, bg: [f32; 3]) -> Option<wgpu::Buffer> {
+    let (w, h) = (img.width, img.height);
+    let g = e.g;
+    if !supported(w, h) || !fits_limits(w, h, &g.device.limits()) {
+        return None;
+    }
+    let cw = w / 2;
+    let size = planes_len(w, h);
+    let mut params = [0u8; 32];
+    // w * h fits in u32: both are at most the texture limit (16384).
+    for (i, v) in [w, h, cw, w * h / 4].into_iter().enumerate() {
+        params[i * 4..i * 4 + 4].copy_from_slice(&v.to_le_bytes());
+    }
+    for (i, v) in [bg[0], bg[1], bg[2], 1.0].into_iter().enumerate() {
+        params[16 + i * 4..16 + i * 4 + 4].copy_from_slice(&v.to_le_bytes());
+    }
+    let (out, stg, ub) = match crate::context::init_resource(&g.device, "yuv420 buffers", || {
+        let out = g.device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("yuv420 out"),
+            size,
+            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
+            mapped_at_creation: false,
+        });
+        let stg = g.device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("yuv420 staging"),
+            size,
+            usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        let ub = g.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("yuv420 params"),
+            contents: &params,
+            usage: wgpu::BufferUsages::UNIFORM,
+        });
+        (out, stg, ub)
+    }) {
+        Ok(buffers) => buffers,
+        Err(err) => {
+            log::warn!(target: "effectcraft_gpu", "yuv420 buffers: {err}");
+            return None;
+        }
+    };
+    let view = img.texture.create_view(&Default::default());
+    let group = g.device.create_bind_group(&wgpu::BindGroupDescriptor {
+        label: Some("yuv420"),
+        layout: &yp.bgl,
+        entries: &[
+            wgpu::BindGroupEntry { binding: 0, resource: ub.as_entire_binding() },
+            wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::TextureView(&view) },
+            wgpu::BindGroupEntry { binding: 2, resource: out.as_entire_binding() },
+        ],
+    });
+    {
+        let enc = e.encoder();
+        {
+            let mut pass = enc.begin_compute_pass(&wgpu::ComputePassDescriptor { label: Some("yuv420"), timestamp_writes: None });
+            pass.set_pipeline(&yp.pipe);
+            pass.set_bind_group(0, &group, &[]);
+            pass.dispatch_workgroups((w / 8).div_ceil(8), (h / 2).div_ceil(8), 1);
+        }
+        enc.copy_buffer_to_buffer(&out, 0, &stg, 0, size);
+    }
+    e.submit();
+    Some(stg)
+}
+
+/// Convert `img` over `bg` and read the planes back, waiting for the device.
+pub(crate) fn convert(e: &mut Enc, yp: &YuvPipe, img: &GpuImage, bg: [f32; 3]) -> Option<Vec<u8>> {
+    let stg = record(e, yp, img, bg)?;
+    let n = planes_len(img.width, img.height) as usize;
+    e.g.read_buffer(&stg, n, n, 1).map_err(|err| log::error!(target: "effectcraft_gpu", "yuv420 readback: {err}")).ok()
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use effectcraft_raster::Image;
+
+    /// The export's conversion (`to_rgba8_over` + `rgba_to_yuv420`), the reference the kernel
+    /// is held to.
+    pub(crate) fn cpu(img: &Image, bg: [f32; 3]) -> Vec<u8> {
+        effectcraft_raster::yuv::yuv420_over(img, bg)
+    }
+
+    /// Premultiplied noise with some out-of-range values, opaque pixels, exact 8-bit levels and
+    /// a few NaN and infinite components (the CPU writes 0 for NaN).
+    pub(crate) fn noise(w: u32, h: u32, seed: u32) -> Image {
+        let mut img = Image::new(w, h);
+        let mut s = seed | 1;
+        let mut rnd = || {
+            s ^= s << 13;
+            s ^= s >> 17;
+            s ^= s << 5;
+            s as f32 / u32::MAX as f32
+        };
+        for (i, p) in img.data.iter_mut().enumerate() {
+            let a = if i % 7 == 0 { 1.0 } else { rnd() };
+            *p = if i % 97 == 3 {
+                [f32::NAN, 0.5, f32::INFINITY, a]
+            } else if i % 101 == 5 {
+                [0.2, 0.3, 0.4, f32::NAN]
+            } else if i % 103 == 7 {
+                [f32::NEG_INFINITY, 0.1, 0.9, f32::INFINITY]
+            } else if i % 5 == 0 {
+                let q = (i % 256) as f32 / 255.0;
+                [q, 1.0 - q, q * 0.5, 1.0]
+            } else {
+                [rnd() * a * 1.1 - 0.02, rnd() * a, rnd() * a, a]
+            };
+        }
+        img
+    }
+
+    /// Check `got` against the CPU's `want`. Software adapters (llvmpipe, WARP) must match
+    /// exactly. A hardware driver may contract multiply-adds or divide less exactly, which
+    /// moves a value near a rounding boundary by one level (seen on an RTX 3090 under Vulkan):
+    /// there every byte must be within one level and at most `budget` of them off (about 2–3×
+    /// the rate measured on the 3090). A wrong formula, rounding mode or NaN rule fails either
+    /// way on software adapters.
+    pub(crate) fn assert_parity(g: &crate::Gpu, got: &[u8], want: &[u8], budget: f64, what: &str) {
+        assert_eq!(got.len(), want.len(), "{what}: length");
+        let diff: Vec<usize> = (0..got.len()).filter(|&i| got[i] != want[i]).collect();
+        let max = diff.iter().map(|&i| (got[i] as i32 - want[i] as i32).abs()).max().unwrap_or(0);
+        eprintln!("{what} on {}: {} of {} bytes differ (max {max})", g.ctx.name, diff.len(), got.len());
+        if g.ctx.software {
+            assert!(diff.is_empty(), "{what}: a software adapter must match exactly, first diffs at {:?}", &diff[..diff.len().min(10)]);
+            return;
+        }
+        assert!(max <= 1, "{what}: a byte is {max} levels off, first diffs at {:?}", &diff[..diff.len().min(10)]);
+        assert!(diff.len() as f64 <= budget * got.len() as f64, "{what}: {} of {} bytes off by one", diff.len(), got.len());
+    }
+
+    #[test]
+    fn yuv420_matches_cpu() {
+        let Some(g) = crate::tests::gpu() else { return };
+        let yp = super::YuvPipe::new(&g.ctx.device).expect("yuv420 pipe");
+        for (w, h, bg) in [(264u32, 150u32, [0.05, 0.1, 0.2]), (8, 2, [1.0, 1.0, 1.0]), (1928, 6, [0.0, 0.0, 0.0])] {
+            let img = noise(w, h, w ^ (h << 16));
+            let src = g.ctx.upload_image(&img).expect("upload");
+            let got = super::convert(&mut crate::context::Enc::new(&g.ctx), &yp, &src, bg).expect("readback");
+            assert_parity(g, &got, &cpu(&img, bg), 0.00005, &format!("noise {w}x{h}"));
+        }
+    }
+
+    #[test]
+    fn unsupported_sizes_are_declined() {
+        assert!(super::supported(8, 2));
+        for (w, h) in [(0, 2), (8, 0), (12, 2), (8, 3), (7, 4)] {
+            assert!(!super::supported(w, h), "{w}x{h}");
+        }
+        assert_eq!(super::planes_len(8, 2), 16 + 2 * 4);
+    }
+
+    #[test]
+    fn sizes_exceeding_buffer_limits_are_declined() {
+        let def = wgpu::Limits::default();
+        assert!(super::fits_limits(3840, 2160, &def));
+        // 16384×16384 planes are 384 MiB, over default max_storage_buffer_binding_size (128 MiB)
+        // and max_buffer_size (256 MiB).
+        assert!(!super::fits_limits(16384, 16384, &def));
+        let size = super::planes_len(64, 64);
+        assert!(super::fits_limits(64, 64, &wgpu::Limits { max_storage_buffer_binding_size: size, max_buffer_size: size, ..def.clone() }));
+        assert!(!super::fits_limits(64, 64, &wgpu::Limits { max_storage_buffer_binding_size: size - 1, max_buffer_size: size, ..def.clone() }));
+        assert!(!super::fits_limits(64, 64, &wgpu::Limits { max_storage_buffer_binding_size: size, max_buffer_size: size - 1, ..def.clone() }));
+
+        let Some(_) = crate::tests::gpu() else { return };
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).expect("adapter");
+        let required_limits = wgpu::Limits { max_storage_buffer_binding_size: 4096, max_buffer_size: 4096, ..def };
+        let (device, queue) = pollster::block_on(adapter.request_device(&crate::context::device_descriptor(required_limits))).expect("limited device");
+        let g = crate::Gpu::new(&adapter, device, queue).expect("limited Gpu");
+        let yp = super::YuvPipe::new(&g.ctx.device).expect("yuv420 pipe");
+        let src = g.ctx.upload_image(&noise(64, 64, 1)).expect("upload");
+        assert!(super::convert(&mut crate::context::Enc::new(&g.ctx), &yp, &src, [0.0; 3]).is_none());
+        assert!(g.ctx.check_health().is_ok());
+    }
+
+    #[test]
+    fn unsupported_sizes_are_not_converted() {
+        let Some(g) = crate::tests::gpu() else { return };
+        let yp = super::YuvPipe::new(&g.ctx.device).expect("yuv420 pipe");
+        let src = g.ctx.upload_image(&noise(12, 4, 3)).expect("upload");
+        assert!(super::convert(&mut crate::context::Enc::new(&g.ctx), &yp, &src, [0.0; 3]).is_none());
+    }
+}
+
+#[cfg(test)]
+mod accel_tests {
+    use effectcraft_color::Label;
+    use effectcraft_project::{BitDepth, Comp, ItemKind};
+    use effectcraft_render::{Accelerator, Backend, RenderOpts, Renderer};
+    use effectcraft_time::{FrameRate, Tick};
+
+    use crate::tests::{Pattern, Scene, opts};
+
+    fn scene(w: u32, h: u32) -> Scene {
+        let mut s = Scene::new(BitDepth::Bpc8);
+        let comp = Comp::new(w, h, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
+        s.cid = s.p.add_item("Comp yuv", Label::Sandstone, None, ItemKind::Comp(comp.clone().into()));
+        s.comp = comp;
+        let l = s.footage(w + 7, h + 3);
+        s.push(l);
+        let sol = s.solid([0.9, 0.2, 0.4], w / 2, h / 3);
+        s.push(sol);
+        s
+    }
+
+    /// The accelerator's YUV frame is the export's CPU conversion of the very frame
+    /// `comp_frame` returns.
+    #[test]
+    fn comp_frame_yuv420_is_the_cpu_conversion_of_comp_frame() {
+        let Some(g) = crate::tests::gpu() else { return };
+        let s = scene(96, 60);
+        let mut r = Renderer::new(&s.p, &Pattern, RenderOpts { backend: Backend::Gpu, ..opts() });
+        r.accel = Some(g);
+        let bg = [0.2, 0.3, 0.4];
+        let rgba = g.comp_frame(&r, s.cid, Tick::ZERO).expect("rgba frame");
+        let yuv = g.comp_frame_yuv420(&r, s.cid, Tick::ZERO, bg).expect("yuv frame");
+        super::tests::assert_parity(g, &yuv, &super::tests::cpu(&rgba, bg), 0.006, "comp frame");
+    }
+
+    #[test]
+    fn odd_sized_comps_fall_back_to_the_cpu() {
+        let Some(g) = crate::tests::gpu() else { return };
+        let s = scene(97, 61);
+        let mut r = Renderer::new(&s.p, &Pattern, RenderOpts { backend: Backend::Gpu, ..opts() });
+        r.accel = Some(g);
+        assert!(g.comp_frame(&r, s.cid, Tick::ZERO).is_some());
+        assert!(g.comp_frame_yuv420(&r, s.cid, Tick::ZERO, [0.0; 3]).is_none());
+    }
+
+    #[test]
+    fn comp_frame_yuv420_falls_back_when_pipeline_init_failed() {
+        let Some(_) = crate::tests::gpu() else { return };
+        let g = crate::Gpu::try_headless().expect("headless Gpu");
+        let _ = g.ctx.yuv.set(Err("simulated yuv420 init failure".into()));
+        let s = scene(96, 60);
+        let mut r = Renderer::new(&s.p, &Pattern, RenderOpts { backend: Backend::Gpu, ..opts() });
+        r.accel = Some(&g);
+        assert!(g.comp_frame_yuv420(&r, s.cid, Tick::ZERO, [0.0; 3]).is_none());
+    }
+}
+
+#[cfg(test)]
+mod tie_tests {
+    use effectcraft_raster::Image;
+
+    fn lum(r: u8, g: u8, b: u8) -> f32 {
+        let (r, g, b) = (r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0);
+        0.2126 * r + 0.7152 * g + 0.0722 * b
+    }
+
+    fn px(p: [u8; 3]) -> [f32; 4] {
+        [p[0] as f32 / 255.0, p[1] as f32 / 255.0, p[2] as f32 / 255.0, 1.0]
+    }
+
+    /// Opaque pixels whose Y (or whose 2×2 block's U or V) lands exactly on .5 in the CPU's f32
+    /// math: a kernel that rounds ties the other way moves most of them.
+    #[test]
+    fn rounding_ties_match_cpu() {
+        let mut ties: Vec<[u8; 3]> = vec![];
+        for r in 0..=255u8 {
+            for g in 0..=255u8 {
+                for b in 0..=255u8 {
+                    let x = 16.0 + 219.0 * lum(r, g, b);
+                    if x - x.floor() == 0.5 {
+                        ties.push([r, g, b]);
+                    }
+                }
+            }
+        }
+        assert!(!ties.is_empty());
+        let mut blocks: Vec<[[u8; 3]; 4]> = vec![];
+        let mut s = 12345u32;
+        let mut rnd = || {
+            s ^= s << 13;
+            s ^= s >> 17;
+            s ^= s << 5;
+            (s >> 24) as u8
+        };
+        // Bounded so the search stays quick in debug builds (a few hundred blocks).
+        for _ in 0..8_000_000 {
+            let blk = [[rnd(), rnd(), rnd()], [rnd(), rnd(), rnd()], [rnd(), rnd(), rnd()], [rnd(), rnd(), rnd()]];
+            let (mut a0, mut a1) = (0f32, 0f32);
+            for p in blk {
+                let l = lum(p[0], p[1], p[2]);
+                a0 += (p[2] as f32 / 255.0 - l) / 1.8556;
+                a1 += (p[0] as f32 / 255.0 - l) / 1.5748;
+            }
+            let u = 128.0 + 224.0 * a0 / 4.0;
+            let v = 128.0 + 224.0 * a1 / 4.0;
+            if u - u.floor() == 0.5 || v - v.floor() == 0.5 {
+                blocks.push(blk);
+            }
+        }
+        eprintln!("Y tie pixels: {}, chroma tie blocks: {}", ties.len(), blocks.len());
+        assert!(!blocks.is_empty());
+        let Some(g) = crate::tests::gpu() else { return };
+        let yp = super::YuvPipe::new(&g.ctx.device).expect("yuv420 pipe");
+        let w = 1024usize;
+        let h = (ties.len().div_ceil(w) + 1) & !1;
+        let mut img = Image::new(w as u32, h as u32);
+        for (i, p) in img.data.iter_mut().enumerate() {
+            *p = px(ties[i % ties.len()]);
+        }
+        let src = g.ctx.upload_image(&img).expect("upload");
+        let got = super::convert(&mut crate::context::Enc::new(&g.ctx), &yp, &src, [0.0; 3]).expect("readback");
+        super::tests::assert_parity(g, &got, &super::tests::cpu(&img, [0.0; 3]), 0.02, "Y ties");
+        let cw = 512usize;
+        let rows = blocks.len().div_ceil(cw);
+        let mut img = Image::new((cw * 2) as u32, (rows * 2) as u32);
+        for cy in 0..rows {
+            for cx in 0..cw {
+                let b = blocks[(cy * cw + cx) % blocks.len()];
+                for (k, p) in b.iter().enumerate() {
+                    let (x, y) = (cx * 2 + k % 2, cy * 2 + k / 2);
+                    img.data[y * cw * 2 + x] = px(*p);
+                }
+            }
+        }
+        let src = g.ctx.upload_image(&img).expect("upload");
+        let got = super::convert(&mut crate::context::Enc::new(&g.ctx), &yp, &src, [0.0; 3]).expect("readback");
+        super::tests::assert_parity(g, &got, &super::tests::cpu(&img, [0.0; 3]), 0.06, "chroma ties");
+    }
+}
diff --git a/crates/hevcenc/src/deblock.rs b/crates/hevcenc/src/deblock.rs
index 6f5d17b87..6d326e5d4 100644
--- a/crates/hevcenc/src/deblock.rs
+++ b/crates/hevcenc/src/deblock.rs
@@ -78,7 +78,6 @@ pub fn deblock(planes: &mut [Vec<u16>; 3], blk: &[Blk], w: usize, h: usize, qp:
 
 /// Filter one 4-sample luma edge segment. `o` = offset of q0 of the first line, `step` = distance
 /// between samples across the edge, `along` = distance between lines.
-#[allow(clippy::too_many_arguments)]
 fn filter_luma(s: &mut [u16], o: usize, step: usize, along: usize, tc: i32, beta: i32, bd: u32) {
     let px = |s: &[u16], k: usize, i: usize| s[o + k * along - (i + 1) * step] as i32;
     let qx = |s: &[u16], k: usize, i: usize| s[o + k * along + i * step] as i32;
diff --git a/crates/hevcenc/src/frame.rs b/crates/hevcenc/src/frame.rs
index 760bea2b0..ee141e3e7 100644
--- a/crates/hevcenc/src/frame.rs
+++ b/crates/hevcenc/src/frame.rs
@@ -7,7 +7,10 @@ use crate::inter::{self, PlaneRef};
 use crate::intra::{self, Refs};
 use crate::me::MeRef;
 use crate::params::{LOG2_CTB, LOG2_MAX_TB, LOG2_MIN_CB, MAX_MERGE_CAND};
-use crate::tables::*;
+use crate::tables::{
+    ABS_MVD_GT0, ABS_MVD_GT1, CBF_CHROMA, CBF_LUMA, CODED_SUB_BLOCK, CTX_IDX_MAP, CU_SKIP, GT1, GT2, INTRA_CHROMA, LAST_X_PREFIX, LAST_Y_PREFIX, MERGE_FLAG,
+    MERGE_IDX, MVP_FLAG, PART_MODE, PRED_MODE, PREV_INTRA_LUMA, RQT_ROOT_CBF, SCAN_4, SIG_COEFF, SPLIT_CU, qpc_420, scan_order,
+};
 use crate::transform;
 
 pub const F_INTRA: u8 = 1;
@@ -73,6 +76,40 @@ pub enum SliceKind {
     P,
 }
 
+/// Picture geometry and slice coding parameters shared by the CTU encoder.
+pub struct FrameConfig {
+    pub bit_depth: u32,
+    pub width: usize,
+    pub height: usize,
+    pub kind: SliceKind,
+    pub slice_qp: i32,
+}
+
+/// A square node in the coding or transform quadtree.
+#[derive(Clone, Copy)]
+struct TreeNode {
+    x: usize,
+    y: usize,
+    log2: u32,
+    depth: u32,
+}
+
+impl TreeNode {
+    fn children(self) -> impl Iterator<Item = Self> {
+        let h = 1usize << (self.log2 - 1);
+        [(0, 0), (h, 0), (0, h), (h, h)].into_iter().map(move |(dx, dy)| Self { x: self.x + dx, y: self.y + dy, log2: self.log2 - 1, depth: self.depth + 1 })
+    }
+}
+
+/// Transform syntax inherited from the parent node and the enclosing CU.
+#[derive(Clone, Copy)]
+struct TransformState {
+    blk_idx: u32,
+    parent: [bool; 2],
+    intra: bool,
+    nxn: bool,
+}
+
 pub struct FrameCoder<'a> {
     pub bd: u32,
     pub w: usize,
@@ -114,17 +151,8 @@ fn morton(x: u32, y: u32) -> u32 {
 const COARSE_MODES: [u32; 11] = [0, 1, 2, 6, 10, 14, 18, 22, 26, 30, 34];
 
 impl<'a> FrameCoder<'a> {
-    #[allow(clippy::too_many_arguments)]
-    pub fn new(
-        bd: u32,
-        w: usize,
-        h: usize,
-        kind: SliceKind,
-        slice_qp: i32,
-        src: &'a [Vec<u16>; 3],
-        refp: Option<&'a [Vec<u16>; 3]>,
-        me: Option<&'a MeRef>,
-    ) -> Self {
+    pub fn new(config: FrameConfig, src: &'a [Vec<u16>; 3], refp: Option<&'a [Vec<u16>; 3]>, me: Option<&'a MeRef>) -> Self {
+        let FrameConfig { bit_depth: bd, width: w, height: h, kind, slice_qp } = config;
         let off = 6 * (bd as i32 - 8);
         let qpi = slice_qp.clamp(-off, 57);
         let qp_c = qpc_420(qpi) + off;
@@ -256,7 +284,7 @@ impl<'a> FrameCoder<'a> {
             let mut decs = Vec::with_capacity(64);
             self.decide(x, y, LOG2_CTB, 0, &mut est, &mut decs);
             let mut idx = 0;
-            self.write_cq(enc, x, y, LOG2_CTB, 0, &decs, &mut idx);
+            self.write_cq(enc, TreeNode { x, y, log2: LOG2_CTB, depth: 0 }, &decs, &mut idx);
             debug_assert_eq!(idx, decs.len());
             debug_assert_eq!(est.ctx, enc.ctx);
             enc.terminate((i + 1 == total) as u32); // end_of_slice_segment_flag
@@ -276,7 +304,8 @@ impl<'a> FrameCoder<'a> {
     }
 
     /// Final pass: re-code the decided quadtree with the real arithmetic coder.
-    fn write_cq(&mut self, enc: &mut CabacEncoder, x: usize, y: usize, log2: u32, depth: u32, decs: &[CuDec], idx: &mut usize) {
+    fn write_cq(&mut self, enc: &mut CabacEncoder, node: TreeNode, decs: &[CuDec], idx: &mut usize) {
+        let TreeNode { x, y, log2, depth } = node;
         if x >= self.w || y >= self.h {
             return;
         }
@@ -294,9 +323,8 @@ impl<'a> FrameCoder<'a> {
             let (eff, _) = self.encode_cu(enc, x, y, log2, depth, d.mode);
             debug_assert_eq!(eff, d.mode);
         } else {
-            let h = n / 2;
-            for (dx, dy) in [(0, 0), (h, 0), (0, h), (h, h)] {
-                self.write_cq(enc, x + dx, y + dy, log2 - 1, depth + 1, decs, idx);
+            for child in node.children() {
+                self.write_cq(enc, child, decs, idx);
             }
         }
     }
@@ -447,7 +475,7 @@ impl<'a> FrameCoder<'a> {
                 self.write_intra_modes(s, x, y, n, nxn, &modes);
                 s.decision(INTRA_CHROMA, 0); // intra_chroma_pred_mode 4 (DM)
                 let mut ti = 0;
-                self.write_tt(s, x, y, x, y, log2, 0, 0, [true, true], true, nxn, &mut ti);
+                self.write_tt(s, TreeNode { x, y, log2, depth: 0 }, TransformState { blk_idx: 0, parent: [true, true], intra: true, nxn }, &mut ti);
                 (mode, self.cu_dist(x, y, n))
             }
             _ => {
@@ -490,7 +518,12 @@ impl<'a> FrameCoder<'a> {
                         s.decision(MERGE_FLAG, 1);
                         write_merge_idx(s, idx as usize);
                         let mut ti = 0;
-                        self.write_tt(s, x, y, x, y, log2, 0, 0, [true, true], false, false, &mut ti);
+                        self.write_tt(
+                            s,
+                            TreeNode { x, y, log2, depth: 0 },
+                            TransformState { blk_idx: 0, parent: [true, true], intra: false, nxn: false },
+                            &mut ti,
+                        );
                     }
                     CuMode::Amvp { mv, mvp } => {
                         s.decision(CU_SKIP + skip_ctx, 0);
@@ -503,7 +536,12 @@ impl<'a> FrameCoder<'a> {
                         s.decision(RQT_ROOT_CBF, root as u32);
                         if root {
                             let mut ti = 0;
-                            self.write_tt(s, x, y, x, y, log2, 0, 0, [true, true], false, false, &mut ti);
+                            self.write_tt(
+                                s,
+                                TreeNode { x, y, log2, depth: 0 },
+                                TransformState { blk_idx: 0, parent: [true, true], intra: false, nxn: false },
+                                &mut ti,
+                            );
                         }
                     }
                     // Handled by the arm above.
@@ -715,22 +753,9 @@ impl<'a> FrameCoder<'a> {
 
     /// transform_tree() (7.3.8.8) over the coded transform blocks of the CU; no split flag is ever
     /// coded (max_transform_hierarchy_depth_* = 0), splits are inferred.
-    #[allow(clippy::too_many_arguments)]
-    fn write_tt<S: Sink>(
-        &self,
-        s: &mut S,
-        x0: usize,
-        y0: usize,
-        xb: usize,
-        yb: usize,
-        log2: u32,
-        depth: u32,
-        blk_idx: u32,
-        parent: [bool; 2],
-        intra: bool,
-        nxn: bool,
-        ti: &mut usize,
-    ) {
+    fn write_tt<S: Sink>(&self, s: &mut S, node: TreeNode, state: TransformState, ti: &mut usize) {
+        let TreeNode { x: x0, y: y0, log2, depth } = node;
+        let TransformState { blk_idx, parent, intra, nxn } = state;
         let n = 1usize << log2;
         let split = log2 > LOG2_MAX_TB || (nxn && depth == 0);
         let mut cbf_c = [false; 2];
@@ -745,13 +770,11 @@ impl<'a> FrameCoder<'a> {
             cbf_c = parent;
         }
         if split {
-            let h = n / 2;
-            for (i, (dx, dy)) in [(0, 0), (h, 0), (0, h), (h, h)].into_iter().enumerate() {
-                self.write_tt(s, x0 + dx, y0 + dy, x0, y0, log2 - 1, depth + 1, i as u32, cbf_c, intra, nxn, ti);
+            for (i, child) in node.children().enumerate() {
+                self.write_tt(s, child, TransformState { blk_idx: i as u32, parent: cbf_c, ..state }, ti);
             }
             return;
         }
-        let _ = (xb, yb);
         let tb = self.tbs[*ti];
         *ti += 1;
         debug_assert_eq!(tb.c, 0);
@@ -874,9 +897,9 @@ impl<'a> FrameCoder<'a> {
             let (px, py, pn, pw, ph) = if c == 0 { (x, y, n, self.w, self.h) } else { (x / 2, y / 2, n / 2, self.cw, self.ch) };
             let pr = PlaneRef { data: &refp[c], w: pw, h: ph };
             if c == 0 {
-                inter::mc_luma(pr, self.bd, px as i32, py as i32, mv, pn, pn, &mut self.pred);
+                inter::mc_luma(pr, self.bd, px as i32, py as i32, mv, (pn, pn), &mut self.pred);
             } else {
-                inter::mc_chroma(pr, self.bd, px as i32, py as i32, mv, pn, pn, &mut self.pred);
+                inter::mc_chroma(pr, self.bd, px as i32, py as i32, mv, (pn, pn), &mut self.pred);
             }
             inter::put_uni(&self.pred, pn, pn, self.bd, &mut self.rec[c][py * pw + px..], pw);
         }
@@ -1153,8 +1176,119 @@ fn last_prefix(v: u32) -> (u32, u32, u32) {
     }
 }
 
+/// Context increment for significant_coeff_flag (H.265 9.3.4.2).
+fn significance_context(group: (usize, usize), pos: (usize, usize), log2: u32, prev_csbf: u8, c: usize, scan_idx: usize) -> usize {
+    let (xs, ys) = group;
+    let (xp, yp) = pos;
+    let (xc, yc) = (xs * 4 + xp, ys * 4 + yp);
+    if log2 == 2 {
+        CTX_IDX_MAP[(yc << 2) + xc] as usize
+    } else if xc + yc == 0 {
+        0
+    } else {
+        let mut sc = match prev_csbf {
+            0 => {
+                if xp + yp == 0 {
+                    2
+                } else if xp + yp < 3 {
+                    1
+                } else {
+                    0
+                }
+            }
+            1 => {
+                if yp == 0 {
+                    2
+                } else if yp == 1 {
+                    1
+                } else {
+                    0
+                }
+            }
+            2 => {
+                if xp == 0 {
+                    2
+                } else if xp == 1 {
+                    1
+                } else {
+                    0
+                }
+            }
+            _ => 2,
+        };
+        if c == 0 {
+            if xs + ys > 0 {
+                sc += 3;
+            }
+            sc += if log2 == 3 { if scan_idx == 0 { 9 } else { 15 } } else { 21 };
+        } else {
+            sc += if log2 == 3 { 9 } else { 12 };
+        }
+        sc
+    }
+}
+
+/// Absolute levels, signs and Rice remainders for one significant coefficient group.
+fn write_coefficient_levels<S: Sink>(s: &mut S, sig: &[u8], at: impl Fn(usize) -> i32, i: usize, c: usize, prev_g1: &mut Option<u32>) {
+    let nsig = sig.len();
+    let abs_at = |k: usize| at(sig[k] as usize).unsigned_abs();
+    let mut ctx_set = if i == 0 || c > 0 { 0 } else { 2 };
+    if *prev_g1 == Some(0) {
+        ctx_set += 1;
+    }
+    let mut g1ctx = 1u32;
+    let mut gt1 = [0u8; 16];
+    let mut first_g1: Option<usize> = None;
+    let c_off_g1 = if c > 0 { 16 } else { 0 };
+    for k in 0..nsig.min(8) {
+        let f = abs_at(k) > 1;
+        s.decision(GT1 + ctx_set * 4 + g1ctx.min(3) as usize + c_off_g1, f as u32);
+        gt1[k] = f as u8;
+        if f {
+            g1ctx = 0;
+            if first_g1.is_none() {
+                first_g1 = Some(k);
+            }
+        } else if g1ctx > 0 {
+            g1ctx += 1;
+        }
+    }
+    *prev_g1 = Some(g1ctx);
+    let mut gt2 = 0u32;
+    if let Some(k) = first_g1 {
+        gt2 = (abs_at(k) > 2) as u32;
+        s.decision(GT2 + ctx_set + if c > 0 { 4 } else { 0 }, gt2);
+    }
+    // sign data hiding: the sign of the first coefficient in scan order (sig[nsig - 1]) is
+    // inferred from the parity of the sum of absolute levels
+    let hidden = sig[0] as i32 - sig[nsig - 1] as i32 > 3;
+    let nsigns = if hidden { nsig - 1 } else { nsig };
+    for k in 0..nsigns {
+        s.bypass((at(sig[k] as usize) < 0) as u32);
+    }
+    if hidden {
+        let sum: u32 = (0..nsig).map(abs_at).sum();
+        debug_assert_eq!(at(sig[nsig - 1] as usize) < 0, sum & 1 == 1, "sign hiding parity");
+    }
+    let mut rice = 0u32;
+    for k in 0..nsig {
+        let mut base = 1 + gt1[k] as u32;
+        if Some(k) == first_g1 {
+            base += gt2;
+        }
+        let thresh = if k < 8 { if Some(k) == first_g1 { 3 } else { 2 } } else { 1 };
+        if base == thresh {
+            let level = abs_at(k);
+            write_remaining(s, level - base, rice);
+            if level > 3 * (1 << rice) {
+                rice = (rice + 1).min(4);
+            }
+        }
+    }
+}
+
 /// residual_coding() (7.3.8.11) of one transform block of levels (row-major, n x n). No transform
-/// skip, no sign data hiding.
+/// skip; signs use sign data hiding where the coefficient span permits it.
 fn residual_coding<S: Sink>(s: &mut S, lv: &[i32], log2: u32, c: usize, scan_idx: usize) {
     let n = 1usize << log2;
     let log2sb = log2 - 2;
@@ -1233,51 +1367,7 @@ fn residual_coding<S: Sink>(s: &mut S, lv: &[i32], log2: u32, c: usize, scan_idx
             let (xc, yc) = (xs * 4 + xp, ys * 4 + yp);
             let v = lv[yc * n + xc] != 0;
             if np > 0 || !infer_dc {
-                let sig_ctx = if log2 == 2 {
-                    CTX_IDX_MAP[(yc << 2) + xc] as usize
-                } else if xc + yc == 0 {
-                    0
-                } else {
-                    let mut sc = match prev_csbf {
-                        0 => {
-                            if xp + yp == 0 {
-                                2
-                            } else if xp + yp < 3 {
-                                1
-                            } else {
-                                0
-                            }
-                        }
-                        1 => {
-                            if yp == 0 {
-                                2
-                            } else if yp == 1 {
-                                1
-                            } else {
-                                0
-                            }
-                        }
-                        2 => {
-                            if xp == 0 {
-                                2
-                            } else if xp == 1 {
-                                1
-                            } else {
-                                0
-                            }
-                        }
-                        _ => 2,
-                    };
-                    if c == 0 {
-                        if xs + ys > 0 {
-                            sc += 3;
-                        }
-                        sc += if log2 == 3 { if scan_idx == 0 { 9 } else { 15 } } else { 21 };
-                    } else {
-                        sc += if log2 == 3 { 9 } else { 12 };
-                    }
-                    sc
-                };
+                let sig_ctx = significance_context((xs, ys), (xp, yp), log2, prev_csbf, c, scan_idx);
                 s.decision(SIG_COEFF + c_off_sig + sig_ctx, v as u32);
                 if v {
                     sig[nsig] = p as u8;
@@ -1294,60 +1384,7 @@ fn residual_coding<S: Sink>(s: &mut S, lv: &[i32], log2: u32, c: usize, scan_idx
         if nsig == 0 {
             continue;
         }
-        let abs_at = |k: usize| at(xs, ys, sig[k] as usize).unsigned_abs();
-        let mut ctx_set = if i == 0 || c > 0 { 0 } else { 2 };
-        if prev_g1 == Some(0) {
-            ctx_set += 1;
-        }
-        let mut g1ctx = 1u32;
-        let mut gt1 = [0u8; 16];
-        let mut first_g1: Option<usize> = None;
-        let c_off_g1 = if c > 0 { 16 } else { 0 };
-        for k in 0..nsig.min(8) {
-            let f = abs_at(k) > 1;
-            s.decision(GT1 + ctx_set * 4 + g1ctx.min(3) as usize + c_off_g1, f as u32);
-            gt1[k] = f as u8;
-            if f {
-                g1ctx = 0;
-                if first_g1.is_none() {
-                    first_g1 = Some(k);
-                }
-            } else if g1ctx > 0 {
-                g1ctx += 1;
-            }
-        }
-        prev_g1 = Some(g1ctx);
-        let mut gt2 = 0u32;
-        if let Some(k) = first_g1 {
-            gt2 = (abs_at(k) > 2) as u32;
-            s.decision(GT2 + ctx_set + if c > 0 { 4 } else { 0 }, gt2);
-        }
-        // sign data hiding: the sign of the first coefficient in scan order (sig[nsig - 1]) is
-        // inferred from the parity of the sum of absolute levels
-        let hidden = sig[0] as i32 - sig[nsig - 1] as i32 > 3;
-        let nsigns = if hidden { nsig - 1 } else { nsig };
-        for k in 0..nsigns {
-            s.bypass((at(xs, ys, sig[k] as usize) < 0) as u32);
-        }
-        if hidden {
-            let sum: u32 = (0..nsig).map(abs_at).sum();
-            debug_assert_eq!(at(xs, ys, sig[nsig - 1] as usize) < 0, sum & 1 == 1, "sign hiding parity");
-        }
-        let mut rice = 0u32;
-        for k in 0..nsig {
-            let mut base = 1 + gt1[k] as u32;
-            if Some(k) == first_g1 {
-                base += gt2;
-            }
-            let thresh = if k < 8 { if Some(k) == first_g1 { 3 } else { 2 } } else { 1 };
-            if base == thresh {
-                let level = abs_at(k);
-                write_remaining(s, level - base, rice);
-                if level > 3 * (1 << rice) {
-                    rice = (rice + 1).min(4);
-                }
-            }
-        }
+        write_coefficient_levels(s, &sig[..nsig], |p| at(xs, ys, p), i, c, &mut prev_g1);
     }
 }
 
diff --git a/crates/hevcenc/src/inter.rs b/crates/hevcenc/src/inter.rs
index e363871b5..03bf50ffb 100644
--- a/crates/hevcenc/src/inter.rs
+++ b/crates/hevcenc/src/inter.rs
@@ -35,7 +35,8 @@ impl PlaneRef<'_> {
 
 /// Luma prediction samples (14-bit intermediate) of a w x h block at (x, y) displaced by the
 /// quarter-sample vector `mv`, into `out` (stride w).
-pub fn mc_luma(f: PlaneRef, bd: u32, x: i32, y: i32, mv: [i16; 2], w: usize, h: usize, out: &mut [i16]) {
+pub fn mc_luma(f: PlaneRef, bd: u32, x: i32, y: i32, mv: [i16; 2], size: (usize, usize), out: &mut [i16]) {
+    let (w, h) = size;
     let (fx, fy) = ((mv[0] & 3) as usize, (mv[1] & 3) as usize);
     let xi = x + (mv[0] as i32 >> 2);
     let yi = y + (mv[1] as i32 >> 2);
@@ -89,7 +90,8 @@ pub fn mc_luma(f: PlaneRef, bd: u32, x: i32, y: i32, mv: [i16; 2], w: usize, h:
 }
 
 /// Chroma prediction samples of a w x h block at chroma position (x, y) with a 1/8-sample vector.
-pub fn mc_chroma(f: PlaneRef, bd: u32, x: i32, y: i32, mv: [i16; 2], w: usize, h: usize, out: &mut [i16]) {
+pub fn mc_chroma(f: PlaneRef, bd: u32, x: i32, y: i32, mv: [i16; 2], size: (usize, usize), out: &mut [i16]) {
+    let (w, h) = size;
     let (fx, fy) = ((mv[0] & 7) as usize, (mv[1] & 7) as usize);
     let xi = x + (mv[0] as i32 >> 3);
     let yi = y + (mv[1] as i32 >> 3);
diff --git a/crates/hevcenc/src/lib.rs b/crates/hevcenc/src/lib.rs
index b2e86b6a1..4d38f84d9 100644
--- a/crates/hevcenc/src/lib.rs
+++ b/crates/hevcenc/src/lib.rs
@@ -15,8 +15,6 @@
 //! ```
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
-// Index loops over fixed-size blocks read more clearly than iterator chains in codec code.
-#![allow(clippy::needless_range_loop, clippy::too_many_arguments)]
 
 mod bitstream;
 mod cabac;
@@ -311,7 +309,7 @@ impl Encoder {
         let kind = if idr { SliceKind::I } else { SliceKind::P };
         let me = if idr { None } else { self.reference.as_ref().map(|r| me::MeRef::new(&r[0], w, h, bd)) };
         let refp = if idr { None } else { self.reference.as_ref() };
-        let mut fc = FrameCoder::new(bd, w, h, kind, qp, &src, refp, me.as_ref());
+        let mut fc = FrameCoder::new(frame::FrameConfig { bit_depth: bd, width: w, height: h, kind, slice_qp: qp }, &src, refp, me.as_ref());
 
         // slice_segment_header() (7.3.6.1)
         let mut bw = BitWriter::new();
diff --git a/crates/hevcenc/tests/roundtrip.rs b/crates/hevcenc/tests/roundtrip.rs
index 777bc455b..7591517e9 100644
--- a/crates/hevcenc/tests/roundtrip.rs
+++ b/crates/hevcenc/tests/roundtrip.rs
@@ -132,12 +132,36 @@ fn ffmpeg_available() -> bool {
     Command::new("ffmpeg").arg("-version").output().map(|o| o.status.success()).unwrap_or(false)
 }
 
+/// `true` when this ffmpeg/ffprobe build actually ships an HEVC decoder. Distro "free" builds
+/// (e.g. Fedora's ffmpeg-free) ship without one — the tools run but cannot decode our stream, so
+/// the external oracle means nothing and the test skips rather than failing on a gap in the tool.
+fn hevc_decoder_available() -> bool {
+    Command::new("ffmpeg")
+        .args(["-hide_banner", "-decoders"])
+        .output()
+        .map(|o| {
+            String::from_utf8_lossy(&o.stdout).lines().any(|l| {
+                // Decoder rows look like ` V....D hevc ...`; match the codec name, not the text.
+                // Every row of `-decoders` is a decoder, so the flags column says nothing about
+                // that — its trailing `D` is "supports direct rendering method 1", which a
+                // build's hevc decoder may well lack (requiring it would skip a working oracle).
+                let mut it = l.split_whitespace();
+                it.next().is_some() && it.next() == Some("hevc")
+            })
+        })
+        .unwrap_or(false)
+}
+
 /// Decode the Annex-B stream with ffmpeg and require bit-exact equality and an empty stderr.
 fn check_ffmpeg(run: &Run, w: usize, h: usize, bd: u32, tag: &str) {
     if !ffmpeg_available() {
         eprintln!("ffmpeg not found; skipping the ffmpeg oracle");
         return;
     }
+    if !hevc_decoder_available() {
+        eprintln!("ffmpeg has no HEVC decoder here; skipping the ffmpeg oracle");
+        return;
+    }
     let dir = std::env::temp_dir();
     let uniq = format!("{}-{}-{}", tag, std::process::id(), std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos());
     let inp = dir.join(format!("hevcenc-{uniq}.hevc"));
@@ -197,6 +221,10 @@ fn ffprobe_stream_info() {
     if !ffmpeg_available() {
         return;
     }
+    if !hevc_decoder_available() {
+        eprintln!("ffmpeg has no HEVC decoder here; ffprobe cannot fully describe our stream, skipping");
+        return;
+    }
     let (w, h) = (130, 72);
     let pics: Vec<Pic> = (0..2).map(|i| synth(w, h, 10, i, 0)).collect();
     let mut c = cfg(w as u32, h as u32, 30, 30, Profile::Main10);
diff --git a/crates/host/src/lib.rs b/crates/host/src/lib.rs
index 577492a53..9a6556fdc 100644
--- a/crates/host/src/lib.rs
+++ b/crates/host/src/lib.rs
@@ -33,6 +33,10 @@ impl Exporter for FileExporter {
     fn formats(&self) -> Vec<OutputFormat> {
         effectcraft_export::available_formats()
     }
+    fn supports_skip_existing(&self, settings: &effectcraft_project::render_queue::RenderSettings) -> bool {
+        // The exporter's existence check precedes storage-overflow redirection.
+        self.sink.is_none() && !cfg!(target_arch = "wasm32") && !settings.storage_overflow
+    }
     fn export(&self, job: &ExportJob, progress: &mut dyn FnMut(u64, u64) -> bool) -> Result<ExportResult, String> {
         effectcraft_engine::render::passes::block_on(self.export_async(job, progress))
     }
@@ -106,552 +110,4 @@ pub fn config_dir() -> Option<std::path::PathBuf> {
 }
 
 #[cfg(test)]
-mod tests {
-    use serde_json::json;
-
-    #[test]
-    fn host_runs_tasks_scheduled_by_panel_handlers() {
-        let mut s = super::session();
-        let result = s.execute("script.run", json!({"code": "var w=new Window('palette','Timer regression'); var b=w.add('button',undefined,'Import'); b.onClick=function(){app.scheduleTask(\"app.project.items.addComp('Scheduled',64,64,1,1,25)\",0,false);};w.show();"})).unwrap();
-        assert_eq!(result["ok"], true, "{result}");
-        s.execute("scriptui.click", json!({"window":"Timer regression","widget":"Import"})).unwrap();
-        assert!(s.project.items.is_empty());
-        let tick = s.execute("script.runTasks", json!({})).unwrap();
-        assert_eq!(tick["ran"], 1, "{tick}");
-        assert_eq!(tick["errors"], json!([]), "{tick}");
-        assert!(s.project.items.values().any(|item| item.name == "Scheduled"));
-        s.execute("scriptui.close", json!({"window":"Timer regression"})).unwrap();
-    }
-
-    /// Layer ▸ Camera ▸ Link Focus Distance to Point of Interest / to Layer: the expressions
-    /// evaluate to the camera's focus on the target.
-    #[test]
-    fn focus_link_expressions_track_the_target() {
-        use effectcraft_engine::geom::vec3;
-        let mut s = super::session();
-        s.execute("comp.new", json!({"name": "F", "width": 400, "height": 300, "duration": 2})).unwrap();
-        let t = s.execute("layer.newSolid", json!({"color": "#ffffff", "width": 50, "height": 50})).unwrap()["layer"].as_u64().unwrap();
-        s.execute("layer.setSwitch", json!({"layers": [t], "switch": "threeD", "value": true})).unwrap();
-        s.execute("layer.setTransform", json!({"layer": t, "prop": "position", "value": [260, 120, 400]})).unwrap();
-        let cam = s.execute("layer.newCamera", json!({})).unwrap()["layer"].as_u64().unwrap();
-        let cid = s.active_comp_id().unwrap();
-        let focus = |s: &effectcraft_engine::Session| {
-            let comp = s.project.comp(cid).unwrap();
-            let mut ctx = effectcraft_engine::render::EvalCtx::new(&s.project, cid, comp, s.time());
-            ctx.expr = s.expr.as_deref();
-            let l = comp.layer(effectcraft_engine::project::LayerId(cam)).unwrap();
-            ctx.value(l, l.props.prop("cameraOptions/focusDistance").unwrap()).as_f64()
-        };
-        let depth = |s: &effectcraft_engine::Session| {
-            let comp = s.project.comp(cid).unwrap();
-            let ctx = effectcraft_engine::render::EvalCtx::new(&s.project, cid, comp, s.time());
-            let c = comp.layer(effectcraft_engine::project::LayerId(cam)).unwrap();
-            let tl = comp.layer(effectcraft_engine::project::LayerId(t)).unwrap();
-            let cs = effectcraft_engine::render::three_d::camera::layer_camera(&ctx, c);
-            cs.depth(ctx.world_matrix(tl).apply(vec3(25.0, 25.0, 0.0)))
-        };
-        s.execute("layer.select", json!({"layers": [cam, t]})).unwrap();
-        let set = s.execute("camera.setFocusToLayer", json!({})).unwrap()["focusDistance"].as_f64().unwrap();
-        assert!((set - depth(&s)).abs() < 1e-6 && (focus(&s) - set).abs() < 1e-6);
-        s.execute("camera.linkFocusToLayer", json!({})).unwrap();
-        // Move the target: the linked focus follows.
-        s.execute("layer.setTransform", json!({"layer": t, "prop": "position", "value": [200, 150, 900]})).unwrap();
-        assert!((focus(&s) - depth(&s)).abs() < 1e-3, "{} vs {}", focus(&s), depth(&s));
-        s.execute("camera.linkFocusToPoi", json!({"camera": cam})).unwrap();
-        let poi = {
-            let l = s.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(cam)).unwrap();
-            let p = l.props.prop("transform/position").unwrap().value.as_vec3();
-            let q = l.props.prop("transform/poi").unwrap().value.as_vec3();
-            ((p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2) + (p[2] - q[2]).powi(2)).sqrt()
-        };
-        assert!((focus(&s) - poi).abs() < 1e-6, "{} vs {poi}", focus(&s));
-    }
-
-    #[test]
-    fn wired_session_renders_demo_with_expressions() {
-        let mut s = super::session();
-        s.execute("file.openDemoProject", json!({})).unwrap();
-        let cid = s.active_comp_id().unwrap();
-        let lid = s.active_comp().unwrap().layers[1].id.0;
-        s.execute("prop.setExpression", json!({"layer": lid, "path": "transform/rotation", "expression": "time * 90"})).unwrap();
-        let img = s.render(cid, s.time(), effectcraft_engine::render::RenderOpts { scale: 0.25, ..Default::default() });
-        assert!(img.data.iter().any(|p| p[3] > 0.5));
-    }
-
-    /// File ▸ Import of glTF/GLB/OBJ models through the media layer, placed as model layers and
-    /// drawn by the Advanced 3D renderer.
-    #[test]
-    fn imported_models_render_in_advanced_3d() {
-        let fx = |n: &str| format!("{}/../model/tests/fixtures/{n}", env!("CARGO_MANIFEST_DIR"));
-        let mut s = super::session();
-        s.execute("comp.new", json!({"name": "M", "width": 160, "height": 120, "renderer": "advanced3d"})).unwrap();
-        let r = s.execute("file.import", json!({"paths": [fx("cube.obj"), fx("quad.glb"), fx("quad.gltf")]})).unwrap();
-        assert_eq!(r["errors"], json!([]), "{r}");
-        let items: Vec<u64> = r["items"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
-        assert_eq!(items.len(), 3);
-        let cube = s.execute("layer.addItem", json!({"item": items[0]})).unwrap()["layer"].as_u64().unwrap();
-        s.execute("prop.set", json!({"layer": cube, "path": "transform/rotationY", "value": 30})).unwrap();
-        s.execute("prop.set", json!({"layer": cube, "path": "transform/rotationX", "value": 20})).unwrap();
-        let cid = s.active_comp_id().unwrap();
-        let opts = effectcraft_engine::render::RenderOpts::default();
-        let img = s.render(cid, s.time(), opts);
-        let covered = img.data.iter().filter(|p| p[3] > 0.99).count();
-        assert!(covered > 1000, "the cube covers part of the frame: {covered}");
-        // Red faces (material Red) are visible.
-        assert!(img.data.iter().any(|p| p[3] > 0.99 && p[0] > 0.5 && p[1] < 0.2));
-        // The textured binary glTF quad.
-        for _ in 0..3 {
-            s.execute("edit.undo", json!({})).unwrap();
-        }
-        s.execute("layer.addItem", json!({"item": items[1]})).unwrap();
-        let img = s.render(cid, s.time(), opts);
-        assert!(img.data.iter().filter(|p| p[3] > 0.99).count() > 1000);
-        // Classic 3D doesn't draw models.
-        s.execute("comp.renderer", json!({"renderer": "classic3d"})).unwrap();
-        assert!(s.render(cid, s.time(), opts).data.iter().all(|p| p[3] == 0.0));
-    }
-
-    /// A binary glTF of a red cube 2 units wide (positions and indices only).
-    fn glb_cube() -> Vec<u8> {
-        let mut bin: Vec<u8> = (0..8u32).flat_map(|i| [i & 1, (i >> 1) & 1, (i >> 2) & 1].map(|b| b as f32 * 2.0 - 1.0)).flat_map(f32::to_le_bytes).collect();
-        let faces: [[u16; 4]; 6] = [[0, 2, 3, 1], [4, 5, 7, 6], [0, 1, 5, 4], [2, 6, 7, 3], [0, 4, 6, 2], [1, 3, 7, 5]];
-        bin.extend(faces.iter().flat_map(|f| [f[0], f[1], f[2], f[0], f[2], f[3]]).flat_map(u16::to_le_bytes));
-        let gltf = json!({
-            "asset": {"version": "2.0"},
-            "scene": 0,
-            "scenes": [{"nodes": [0]}],
-            "nodes": [{"mesh": 0}],
-            "meshes": [{"primitives": [{"attributes": {"POSITION": 0}, "indices": 1, "material": 0}]}],
-            "materials": [{"pbrMetallicRoughness": {"baseColorFactor": [1, 0, 0, 1], "metallicFactor": 0, "roughnessFactor": 1}}],
-            "buffers": [{"byteLength": bin.len()}],
-            "bufferViews": [{"buffer": 0, "byteOffset": 0, "byteLength": 96}, {"buffer": 0, "byteOffset": 96, "byteLength": 72}],
-            "accessors": [
-                {"bufferView": 0, "componentType": 5126, "count": 8, "type": "VEC3", "min": [-1, -1, -1], "max": [1, 1, 1]},
-                {"bufferView": 1, "componentType": 5123, "count": 36, "type": "SCALAR"}
-            ]
-        });
-        let mut text = gltf.to_string().into_bytes();
-        text.resize(text.len().div_ceil(4) * 4, b' ');
-        let chunk = |kind: &[u8; 4], data: &[u8]| [&(data.len() as u32).to_le_bytes()[..], kind, data].concat();
-        let body = [chunk(b"JSON", &text), chunk(b"BIN\0", &bin)].concat();
-        [&b"glTF"[..], &2u32.to_le_bytes(), &(12 + body.len() as u32).to_le_bytes(), &body].concat()
-    }
-
-    /// #264: a model imported into a new composition (Classic 3D by default) was invisible on
-    /// every renderer, because only Advanced 3D draws models. Adding it now switches the comp,
-    /// and the software renderer (no GPU, as on the reporter's Intel HD Graphics 5500) draws it.
-    #[test]
-    fn imported_glb_shows_in_a_new_composition() {
-        let path = std::env::temp_dir().join(format!("effectcraft-264-cube-{}.glb", std::process::id()));
-        std::fs::write(&path, glb_cube()).unwrap();
-        let mut s = super::session();
-        assert!(s.accel.is_none(), "renders in software");
-        let r = s.execute("file.import", json!({"paths": [path.to_string_lossy()]})).unwrap();
-        assert_eq!(r["errors"], json!([]), "{r}");
-        s.state.project_selection = vec![effectcraft_project::ItemId(r["items"][0].as_u64().unwrap())];
-        s.execute("file.newCompFromSelection", json!({})).unwrap();
-        let comp = s.active_comp().unwrap();
-        assert_eq!(comp.renderer, effectcraft_project::Renderer::Advanced3D);
-        let layer = comp.layers[0].id.0;
-        s.execute("prop.set", json!({"layer": layer, "path": "transform/rotationY", "value": 30})).unwrap();
-        s.execute("prop.set", json!({"layer": layer, "path": "transform/rotationX", "value": 20})).unwrap();
-        let cid = s.active_comp_id().unwrap();
-        let img = s.render(cid, s.time(), effectcraft_engine::render::RenderOpts { scale: 0.25, ..Default::default() });
-        let red = img.data.iter().filter(|p| p[3] > 0.99 && p[0] > 0.2 && p[1] < 0.05 && p[2] < 0.05).count();
-        let _ = std::fs::remove_file(&path);
-        // Half the comp height wide, seen at an angle: well over 5% of the frame.
-        assert!(red * 20 > img.data.len(), "red cube pixels: {red} of {}", img.data.len());
-    }
-
-    /// #651: an animated GIF imported from disk plays: the layer shows each frame at its time,
-    /// in the viewer's renders and in exports alike.
-    #[test]
-    fn an_imported_animated_gif_plays() {
-        let dir = std::env::temp_dir().join(format!("ec-gif-{}", std::process::id()));
-        std::fs::create_dir_all(&dir).unwrap();
-        let path = dir.join("anim.gif");
-        let mut bytes = Vec::new();
-        {
-            let mut enc = gif::Encoder::new(&mut bytes, 4, 4, &[]).unwrap();
-            for rgb in [[255u8, 0, 0], [0, 255, 0], [0, 0, 255]] {
-                let mut f = gif::Frame::from_rgb(4, 4, &rgb.repeat(16));
-                f.delay = 10;
-                enc.write_frame(&f).unwrap();
-            }
-        }
-        std::fs::write(&path, bytes).unwrap();
-        let mut s = super::session();
-        s.execute("comp.new", json!({"name": "G", "width": 4, "height": 4, "frameRate": 30, "duration": 1})).unwrap();
-        s.execute("file.import", json!({"paths": [path.to_string_lossy()], "addToComp": true})).unwrap();
-        let cid = s.active_comp_id().unwrap();
-        let rgb = |t: f64| {
-            let img = s.render(cid, effectcraft_time::Tick::from_seconds_f64(t), effectcraft_engine::render::RenderOpts::default());
-            let p = img.data[5];
-            [p[0].round(), p[1].round(), p[2].round()]
-        };
-        assert_eq!(rgb(0.05), [1.0, 0.0, 0.0]);
-        assert_eq!(rgb(0.15), [0.0, 1.0, 0.0]);
-        assert_eq!(rgb(0.25), [0.0, 0.0, 1.0]);
-        let _ = std::fs::remove_dir_all(dir);
-    }
-
-    /// The web app's path: outputs go to a sink (downloads), never to the file system.
-    #[test]
-    fn render_queue_exports_to_a_sink() {
-        use std::sync::{Arc, Mutex};
-        let got: Arc<Mutex<Vec<(String, Vec<u8>)>>> = Arc::default();
-        let g = got.clone();
-        let mut s = super::session();
-        s.exporter = Some(Arc::new(super::FileExporter { sink: Some(Arc::new(move |p: &str, d: Vec<u8>| g.lock().unwrap().push((p.to_string(), d)))) }));
-        s.execute("file.openDemoProject", json!({})).unwrap();
-        // Rooted without a drive letter is not absolute on Windows, where the engine joins it to the home drive.
-        let dir = if cfg!(windows) { "C:/no-such-dir-effectcraft-sink-test" } else { "/no-such-dir-effectcraft-sink-test" };
-        s.execute(
-            "renderQueue.add",
-            json!({"format": "gif", "output": format!("{dir}/a.gif"), "resolution": 0.0625, "timeSpan": "custom", "start": 0.0, "end": 0.2}),
-        )
-        .unwrap();
-        s.execute(
-            "renderQueue.add",
-            json!({"format": "png", "output": format!("{dir}/seq_[##].png"), "resolution": 0.0625, "timeSpan": "custom", "start": 0.0, "end": 0.1}),
-        )
-        .unwrap();
-        s.execute("renderQueue.render", json!({"wait": true})).unwrap();
-        s.poll_render();
-        let mut got = got.lock().unwrap().clone();
-        got.sort_by(|a, b| a.0.cmp(&b.0));
-        let names: Vec<std::path::PathBuf> = got.iter().map(|(p, _)| std::path::PathBuf::from(p)).collect();
-        let expected = [format!("{dir}/a.gif"), format!("{dir}/seq_00.png"), format!("{dir}/seq_01.png"), format!("{dir}/seq_02.png")]
-            .map(|p| std::path::absolute(p).unwrap());
-        assert_eq!(names, expected);
-        assert!(got[0].1.starts_with(b"GIF89a"));
-        assert!(got[1].1.starts_with(b"\x89PNG"));
-        assert!(!std::path::Path::new(dir).exists());
-    }
-
-    #[test]
-    fn render_queue_exports_demo_comp() {
-        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-rq");
-        let _ = std::fs::remove_dir_all(&dir);
-        let mut s = super::session();
-        s.execute("file.openDemoProject", json!({})).unwrap();
-        let out = dir.join("[compName]_[width]x[height].[fileExtension]");
-        let r = s
-            .execute(
-                "renderQueue.add",
-                json!({"format": "h264", "output": out.to_string_lossy(), "resolution": 0.125, "timeSpan": "custom", "start": 0.0, "end": 0.4}),
-            )
-            .unwrap();
-        let path = r["outputPath"].as_str().unwrap().to_string();
-        assert!(path.ends_with("_240x134.mp4"), "{path}");
-        // A second item: PNG sequence, rendered in the background.
-        s.execute("renderQueue.add", json!({"format": "png", "output": dir.join("seq_[###].png").to_string_lossy(), "resolution": 0.0625, "timeSpan": "custom", "start": 0.0, "end": 0.2})).unwrap();
-        let r = s.execute("renderQueue.render", json!({"wait": false})).unwrap();
-        assert_eq!(r["items"].as_array().unwrap().len(), 2);
-        let t0 = std::time::Instant::now();
-        while s.is_rendering() {
-            assert!(t0.elapsed().as_secs() < 300, "render timed out");
-            std::thread::sleep(std::time::Duration::from_millis(20));
-            s.poll_render();
-        }
-        s.poll_render();
-        let list = s.execute("renderQueue.list", json!({})).unwrap();
-        for it in list["items"].as_array().unwrap() {
-            assert_eq!(it["statusLabel"], "Done", "{it}");
-            assert!(it["render_time"].as_f64().is_some());
-            assert!(std::path::Path::new(it["last_output"].as_str().unwrap()).exists(), "{it}");
-        }
-        assert!(std::path::Path::new(&path).metadata().unwrap().len() > 500);
-        assert!(dir.join("seq_000.png").exists() && dir.join("seq_005.png").exists() && !dir.join("seq_006.png").exists());
-        // Rendering again needs a re-queue.
-        assert!(s.execute("renderQueue.render", json!({})).is_err());
-        s.execute("renderQueue.setRender", json!({"index": 1, "render": true})).unwrap();
-        assert_eq!(s.project.render_queue[0].status, effectcraft_engine::project::render_queue::RenderStatus::Queued);
-    }
-
-    /// Value of a property of layer `l` at time 0 (keys + expression).
-    fn value(s: &effectcraft_engine::Session, l: u64, path: &str) -> effectcraft_engine::keyframe::Value {
-        let cid = s.active_comp_id().unwrap();
-        let comp = s.project.comp(cid).unwrap();
-        let layer = comp.layer(effectcraft_engine::project::LayerId(l)).unwrap();
-        let ctx =
-            effectcraft_engine::render::EvalCtx { project: &s.project, comp_id: cid, comp, time: Default::default(), expr: s.expr.as_deref(), footage: None };
-        ctx.value(layer, layer.props.prop(path).unwrap())
-    }
-
-    #[test]
-    fn pick_whip_expressions_evaluate() {
-        let mut s = super::session();
-        s.execute("comp.new", json!({"name": "C", "width": 200, "height": 200, "frameRate": 30, "duration": 2})).unwrap();
-        let a = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
-        let b = s.execute("layer.newSolid", json!({"name": "Src", "color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
-        s.execute("prop.set", json!({"layer": b, "path": "transform/rotation", "value": 33})).unwrap();
-        s.execute("prop.set", json!({"layer": b, "path": "transform/position", "value": [12, 34]})).unwrap();
-        s.execute("effect.apply", json!({"layer": b, "effect": "Gaussian Blur"})).unwrap();
-        s.execute("prop.set", json!({"layer": b, "path": "effects/#1/blurriness", "value": 21})).unwrap();
-        s.execute("layer.addMask", json!({"layer": b})).unwrap();
-        s.execute("prop.set", json!({"layer": b, "path": "masks/#1/feather", "value": [7, 7]})).unwrap();
-        let link = |s: &mut effectcraft_engine::Session, from: &str, to: &str| {
-            s.execute("prop.pickWhip", json!({"layer": a, "path": from, "target": {"layer": b, "path": to}})).unwrap();
-        };
-        link(&mut s, "transform/opacity", "transform/rotation");
-        assert_eq!(value(&s, a, "transform/opacity").as_f64(), 33.0);
-        link(&mut s, "transform/scale", "transform/rotation");
-        let cid = s.active_comp_id().unwrap();
-        let ep = effectcraft_expr::eval_property(&s.project, cid, effectcraft_engine::project::LayerId(a), "transform/scale", 0.0);
-        assert!(ep.is_ok(), "{ep:?}");
-        assert_eq!(value(&s, a, "transform/scale").as_vec2(), [33.0, 33.0]);
-        link(&mut s, "transform/position", "transform/position");
-        assert_eq!(value(&s, a, "transform/position").as_vec2(), [12.0, 34.0]);
-        link(&mut s, "transform/rotation", "effects/#1/blurriness");
-        assert_eq!(value(&s, a, "transform/rotation").as_f64(), 21.0);
-        link(&mut s, "transform/opacity", "masks/#1/feather");
-        assert_eq!(value(&s, a, "transform/opacity").as_f64(), 7.0);
-        // Separated dimensions: X Position reference.
-        s.execute("prop.separateDimensions", json!({"layer": b})).unwrap();
-        link(&mut s, "transform/rotation", "transform/positionX");
-        assert_eq!(value(&s, a, "transform/rotation").as_f64(), 12.0);
-    }
-
-    /// The expression error bar's list: evaluation errors and syntax errors, with the layer and
-    /// property they belong to.
-    #[test]
-    fn expression_errors_are_collected() {
-        let mut s = super::session();
-        s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
-        let a = s.execute("layer.newSolid", json!({"name": "Box", "color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
-        s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "50"})).unwrap();
-        assert_eq!(s.execute("expr.errors", json!({})).unwrap()["count"], 0);
-        s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "expression": "thisComp.layer(\"Nope\").rotation"})).unwrap();
-        s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "1 +* ("})).unwrap();
-        let r = s.execute("expr.errors", json!({})).unwrap();
-        assert_eq!(r["count"], 2, "{r}");
-        let errs = r["errors"].as_array().unwrap();
-        let rot = errs.iter().find(|e| e["path"] == "transform/rotation").unwrap();
-        assert!(rot["message"].as_str().unwrap().contains("Nope"), "{rot}");
-        assert_eq!(rot["layerIndex"], 1);
-        assert_eq!(rot["layerName"], "Box");
-        assert_eq!(rot["disabled"], false);
-        let op = errs.iter().find(|e| e["path"] == "transform/opacity").unwrap();
-        assert_eq!(op["disabled"], true);
-        assert!(r["text"][0].as_str().unwrap().contains("of layer 1 ('Box') in comp 'C'"), "{r}");
-        // A user-disabled (but valid) expression is not an error.
-        s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "expression": "45"})).unwrap();
-        s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "enabled": false})).unwrap();
-        assert_eq!(s.execute("expr.errors", json!({})).unwrap()["count"], 1);
-        // The Expression Language menu is categorised.
-        let m = s.execute("expr.languageMenu", json!({})).unwrap();
-        assert!(m.as_array().unwrap().iter().any(|c| c["category"] == "Footage" && c["items"].as_array().unwrap().iter().any(|i| i["text"] == "sourceData")));
-    }
-
-    /// File ▸ Import of JSON/CSV data files as data footage, read by expressions.
-    #[test]
-    fn imported_data_files_drive_expressions() {
-        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-data");
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        std::fs::write(dir.join("levels.csv"), "label,value\nlow,10\nhigh,90\n").unwrap();
-        std::fs::write(dir.join("cfg.json"), r#"{"angle": 33}"#).unwrap();
-        std::fs::write(dir.join("broken.json"), "{nope").unwrap();
-        let mut s = super::session();
-        s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
-        let paths: Vec<String> = ["levels.csv", "cfg.json", "broken.json"].iter().map(|n| dir.join(n).to_string_lossy().to_string()).collect();
-        let r = s.execute("file.import", json!({"paths": paths})).unwrap();
-        assert_eq!(r["items"].as_array().unwrap().len(), 2, "{r}");
-        assert_eq!(r["errors"].as_array().unwrap().len(), 1, "{r}");
-        let csv = r["items"][0].as_u64().unwrap();
-        assert_eq!(s.project.item(effectcraft_engine::project::ItemId(csv)).unwrap().type_name(), "Data");
-        assert!(s.execute("layer.addItem", json!({"item": csv})).is_err(), "data files are not layers");
-        let a = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
-        s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "footage(\"levels.csv\").sourceData[1].value"})).unwrap();
-        s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "expression": "footage(\"cfg.json\").sourceData.angle"})).unwrap();
-        assert_eq!(value(&s, a, "transform/opacity").as_f64(), 90.0);
-        assert_eq!(value(&s, a, "transform/rotation").as_f64(), 33.0);
-    }
-
-    /// sampleImage through the renderer: a box's Fill colour follows the solid under it.
-    #[test]
-    fn sample_image_drives_a_colour() {
-        let mut s = super::session();
-        s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
-        s.execute("layer.newSolid", json!({"name": "Bg", "color": "#00ff00"})).unwrap();
-        let a = s.execute("layer.newSolid", json!({"name": "Fg", "color": "#ffffff", "width": 20, "height": 20})).unwrap()["layer"].as_u64().unwrap();
-        s.execute("effect.apply", json!({"layer": a, "effect": "Fill"})).unwrap();
-        s.execute(
-            "prop.setExpression",
-            json!({"layer": a, "path": "effects/#1/color", "expression": "thisComp.layer(\"Bg\").sampleImage(thisComp.layer(\"Bg\").fromComp(toComp(anchorPoint)))"}),
-        )
-        .unwrap();
-        let cid = s.active_comp_id().unwrap();
-        let img = s.render(cid, s.time(), effectcraft_engine::render::RenderOpts::default());
-        let px = img.get(50, 50);
-        assert!(px[1] > 0.99 && px[0] < 0.01, "the box is filled with the sampled green: {px:?}");
-    }
-
-    /// Proxies through the real media and export layers: Render Settings ▸ Proxy Use decides
-    /// whether an export uses the proxy, and Create Proxy renders and attaches one.
-    #[test]
-    fn proxies_in_exports_and_create_proxy() {
-        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-proxy");
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        let p = |n: &str| dir.join(n).to_string_lossy().to_string();
-        let mut s = super::session();
-        // Source and proxy stills, written by the app itself.
-        s.execute("comp.new", json!({"name": "Red", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
-        let red = s.active_comp_id().unwrap();
-        s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
-        s.execute("comp.saveFrameAs", json!({"path": p("red.png")})).unwrap();
-        s.execute("comp.new", json!({"name": "Blue", "width": 8, "height": 8, "frameRate": 10, "duration": 1})).unwrap();
-        s.execute("layer.newSolid", json!({"color": "#0000ff"})).unwrap();
-        s.execute("comp.saveFrameAs", json!({"path": p("blue.png")})).unwrap();
-        let foot = s.execute("file.import", json!({"paths": [p("red.png")]})).unwrap()["items"][0].as_u64().unwrap();
-        s.execute("file.setProxy", json!({"item": foot, "path": p("blue.png")})).unwrap();
-        s.execute("comp.new", json!({"name": "Out", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
-        let out = s.active_comp_id().unwrap();
-        s.execute("layer.addItem", json!({"item": foot})).unwrap();
-        // Export one frame with each Proxy Use.
-        for (name, using) in [("all", "use_all_[#].png"), ("none", "use_none_[#].png")] {
-            s.execute(
-                "renderQueue.add",
-                json!({"comp": out.0, "format": "png", "output": p(using), "timeSpan": "custom", "start": 0.0, "end": 0.1, "proxyUse": name}),
-            )
-            .unwrap();
-        }
-        s.execute("renderQueue.render", json!({"wait": true})).unwrap();
-        s.poll_render();
-        let centre = |s: &mut effectcraft_engine::Session, path: &str| {
-            let id = s.execute("file.import", json!({"paths": [path]})).unwrap()["items"][0].as_u64().unwrap();
-            s.execute("comp.new", json!({"name": "Probe", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
-            s.execute("layer.addItem", json!({"item": id})).unwrap();
-            let c = s.active_comp_id().unwrap();
-            s.render(c, Default::default(), Default::default()).get(8, 8)
-        };
-        let all = centre(&mut s, &p("use_all_0.png"));
-        assert!(all[2] > 0.99 && all[0] < 0.01, "Use All Proxies renders the blue proxy: {all:?}");
-        let none = centre(&mut s, &p("use_none_0.png"));
-        assert!(none[0] > 0.99 && none[2] < 0.01, "Use No Proxies renders the red source: {none:?}");
-        // Create Proxy ▸ Still: rendered at half size and attached to the comp.
-        s.execute("file.createProxy", json!({"kind": "still", "comp": red.0, "path": p("red_proxy_[#####].png")})).unwrap();
-        s.execute("renderQueue.render", json!({"wait": true})).unwrap();
-        s.poll_render();
-        let px = s.project.item(red).unwrap().proxy.clone().expect("Create Proxy attached the rendered still");
-        assert!(px.enabled);
-        assert_eq!((px.footage.width, px.footage.height), (8, 8));
-        assert!(std::path::Path::new(&px.footage.path).exists(), "{}", px.footage.path);
-    }
-
-    /// A script builds a comp, queues it and renders it through the Render Queue.
-    #[test]
-    fn script_renders_through_the_render_queue() {
-        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-script");
-        let _ = std::fs::remove_dir_all(&dir);
-        let out = dir.join("scripted.gif");
-        let mut s = super::session();
-        let code = format!(
-            r#"
-            var comp = app.project.items.addComp("Scripted", 64, 48, 1, 0.2, 10);
-            var sq = comp.layers.addSolid([1, 0.5, 0], "Square", 16, 16, 1);
-            sq.transform.position.setValueAtTime(0, [8, 24]);
-            sq.transform.position.setValueAtTime(0.1, [56, 24]);
-            var item = app.project.renderQueue.items.add(comp);
-            item.outputModule(1).applyTemplate("GIF");
-            item.outputModule(1).file = new File({});
-            app.project.renderQueue.render();
-            [item.status == RQItemStatus.DONE, item.outputModule(1).file.fsName, app.project.renderQueue.numItems]
-            "#,
-            serde_json::to_string(&out.to_string_lossy()).unwrap()
-        );
-        let r = s.execute("script.run", json!({"code": code})).unwrap();
-        assert_eq!(r["ok"], json!(true), "{r}");
-        assert_eq!(r["result"][0], json!(true), "{r}");
-        assert_eq!(r["result"][2], json!(1));
-        let bytes = std::fs::read(&out).unwrap();
-        assert!(bytes.starts_with(b"GIF89a"));
-    }
-
-    /// importFile, layers.add(footage) and project save/open from a script.
-    #[test]
-    fn script_imports_footage_and_saves() {
-        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-script-import");
-        let _ = std::fs::remove_dir_all(&dir);
-        std::fs::create_dir_all(&dir).unwrap();
-        let q = |n: &str| serde_json::to_string(&dir.join(n).to_string_lossy()).unwrap();
-        let mut s = super::session();
-        let code = format!(
-            r#"
-            var c = app.project.items.addComp("Src", 32, 32, 1, 1, 10);
-            c.layers.addSolid([0, 1, 0], "G", 32, 32, 1);
-            app.run("comp.saveFrameAs", {{comp: c.id, path: {png}}});
-            var still = app.project.importFile(new ImportOptions(new File({png})));
-            var main = app.project.items.addComp("Main", 64, 64, 1, 1, 10);
-            var l = main.layers.add(still);
-            app.project.save(new File({proj}));
-            [still instanceof FootageItem, still.width, still.mainSource.isStill, l.source.name, app.project.file.name]
-            "#,
-            png = q("frame.png"),
-            proj = q("p.ecproj")
-        );
-        let r = s.execute("script.run", json!({"code": code})).unwrap();
-        assert_eq!(r["ok"], json!(true), "{r}");
-        assert_eq!(r["result"], json!([true, 32, true, "frame.png", "p.ecproj"]), "{r}");
-        let r = s.execute("script.run", json!({"code": format!("app.open(new File({})); app.project.numItems", q("p.ecproj"))})).unwrap();
-        assert_eq!(r["result"], json!(5), "{r}"); // Src, Solids, G, frame.png, Main
-    }
-
-    #[test]
-    fn expression_syntax_errors_disable_the_expression() {
-        let mut s = super::session();
-        s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
-        let a = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
-        let r = s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "1 +* ("})).unwrap();
-        assert!(r["error"].is_string(), "{r}");
-        let pr = s.active_comp().unwrap().layers[0].props.prop("transform/opacity").unwrap().clone();
-        assert!(!pr.expr.unwrap().enabled);
-        assert_eq!(value(&s, a, "transform/opacity").as_f64(), 100.0);
-        s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "50"})).unwrap();
-        assert_eq!(value(&s, a, "transform/opacity").as_f64(), 50.0);
-    }
-    /// Create Stereo 3D Rig: the eye cameras' expressions follow the master camera and the
-    /// Stereo 3D Controls (and agree with the values the command wrote).
-    #[test]
-    fn stereo_rig_expressions_follow_the_master_camera() {
-        let mut s = super::session();
-        s.execute("comp.new", json!({"name": "Shot", "width": 640, "height": 360, "frameRate": 30, "duration": 2})).unwrap();
-        let src = s.active_comp_id().unwrap();
-        let cam = s.execute("layer.newCamera", json!({"name": "Main", "position": [320, 180, -800], "poi": [320, 180, 0], "zoom": 900})).unwrap()["layer"]
-            .as_u64()
-            .unwrap();
-        let r = s.execute("camera.stereoRig", json!({"sceneDepth": 4})).unwrap();
-        let ctl = r["controls"].as_u64().unwrap();
-        let left = effectcraft_engine::project::ItemId(r["leftComp"].as_u64().unwrap());
-        // The left eye camera's evaluated value (expressions on).
-        let v3 = |s: &effectcraft_engine::Session, path: &str| {
-            let comp = s.project.comp(left).unwrap();
-            let layer = &comp.layers[0];
-            let ctx = effectcraft_engine::render::EvalCtx {
-                project: &s.project,
-                comp_id: left,
-                comp,
-                time: Default::default(),
-                expr: s.expr.as_deref(),
-                footage: None,
-            };
-            ctx.value(layer, layer.props.prop(path).unwrap()).as_vec3()
-        };
-        let close = |a: [f64; 3], b: [f64; 3]| (0..3).all(|i| (a[i] - b[i]).abs() < 1e-6);
-        let d = 0.04 * 640.0;
-        assert!(close(v3(&s, "transform/position"), [320.0 - d / 2.0, 180.0, -800.0]), "{:?}", v3(&s, "transform/position"));
-        assert!(close(v3(&s, "transform/poi"), [320.0 - d / 2.0, 180.0, 0.0]), "{:?}", v3(&s, "transform/poi"));
-        // Moving the master moves the eyes.
-        s.execute("comp.open", json!({"comp": src.0})).unwrap();
-        s.execute("prop.set", json!({"layer": cam, "path": "transform/position", "value": [300, 180, -800]})).unwrap();
-        s.execute("prop.set", json!({"layer": cam, "path": "transform/poi", "value": [300, 180, 0]})).unwrap();
-        assert!(close(v3(&s, "transform/position"), [300.0 - d / 2.0, 180.0, -800.0]), "{:?}", v3(&s, "transform/position"));
-        // Controls: Center & Left puts the left eye a full separation left; convergence toes in.
-        s.execute("prop.set", json!({"layer": ctl, "path": "effects/#1/configuration", "value": 2})).unwrap();
-        s.execute("prop.set", json!({"layer": ctl, "path": "effects/#1/convergence", "value": true})).unwrap();
-        assert!(close(v3(&s, "transform/position"), [300.0 - d, 180.0, -800.0]), "{:?}", v3(&s, "transform/position"));
-        assert!(close(v3(&s, "transform/poi"), [300.0, 180.0, 0.0]), "{:?}", v3(&s, "transform/poi"));
-    }
-}
+mod tests;
diff --git a/crates/host/src/tests.rs b/crates/host/src/tests.rs
new file mode 100644
index 000000000..f628ce4e4
--- /dev/null
+++ b/crates/host/src/tests.rs
@@ -0,0 +1,626 @@
+use serde_json::json;
+
+#[test]
+#[cfg(not(target_arch = "wasm32"))]
+fn storage_overflow_cannot_bypass_duplicate_output_protection() {
+    for same_folder in [true, false] {
+        refuse_overflow_collision(same_folder);
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn refuse_overflow_collision(same_folder: bool) {
+    use std::{path::PathBuf, sync::Arc};
+    struct OverflowOnly(PathBuf);
+    impl effectcraft_project::render_queue::StorageQuota for OverflowOnly {
+        fn has_room(&self, path: &str, _: u64) -> bool {
+            std::path::Path::new(path).starts_with(&self.0)
+        }
+    }
+    let dir = std::env::temp_dir().join(format!("ec-duplicate-overflow-{}-{same_folder}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    let overflow = dir.join("overflow");
+    std::fs::create_dir_all(&overflow).unwrap();
+    let mut s = effectcraft_engine::Session {
+        exporter: Some(Arc::new(super::FileExporter::default())),
+        storage_quota: Some(Arc::new(OverflowOnly(overflow.clone()))),
+        ..Default::default()
+    };
+    Arc::make_mut(&mut s.project).render_prefs.overflow_folders = vec![overflow.to_string_lossy().into_owned(); 2];
+    s.execute("comp.new", json!({"width": 16, "height": 16, "frameRate": 10, "duration": 0.2})).unwrap();
+    for index in 0..2 {
+        let folder = if same_folder { dir.clone() } else { dir.join(index.to_string()) };
+        s.execute("renderQueue.add", json!({"format": "png", "output": folder.join("frames_[#####].png"), "skipExisting": true, "storageOverflow": true}))
+            .unwrap();
+    }
+    let result = s.execute("renderQueue.render", json!({}));
+    let written = std::fs::read_dir(&overflow).unwrap().count();
+    assert!(result.is_err(), "overflow destinations cannot skip previous frames: {result:?}");
+    assert_eq!(written, 0, "refused before any overflow file is written");
+    s.execute("renderQueue.remove", json!({"index": 2})).unwrap();
+    let result = s.execute("renderQueue.render", json!({})).unwrap();
+    assert_eq!(result["items"][0]["status"], "Done", "one output's alternatives are not separate outputs: {result}");
+    assert_eq!(std::fs::read_dir(&overflow).unwrap().count(), 2);
+    std::fs::remove_dir_all(&dir).unwrap();
+}
+
+#[test]
+fn memory_sink_cannot_overwrite_a_previous_output_even_with_skip_existing() {
+    use std::sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    };
+    let writes = Arc::new(AtomicUsize::new(0));
+    let count = writes.clone();
+    let sink: Arc<effectcraft_export::Sink> = Arc::new(move |_, _| {
+        count.fetch_add(1, Ordering::Relaxed);
+    });
+    let mut s = effectcraft_engine::Session { exporter: Some(Arc::new(super::FileExporter { sink: Some(sink) })), ..Default::default() };
+    s.execute("comp.new", json!({"name": "Main", "width": 16, "height": 16, "frameRate": 10, "duration": 0.2})).unwrap();
+    for _ in 0..2 {
+        s.execute("renderQueue.add", json!({"format": "png", "output": "/virtual/frames_[#####].png", "skipExisting": true})).unwrap();
+    }
+    let result = s.execute("renderQueue.render", json!({}));
+    assert!(result.is_err(), "a sink cannot skip previous paths: {result:?}");
+    assert_eq!(writes.load(Ordering::Relaxed), 0, "refused before the sink receives bytes");
+}
+
+#[test]
+fn host_runs_tasks_scheduled_by_panel_handlers() {
+    let mut s = super::session();
+    let result = s.execute("script.run", json!({"code": "var w=new Window('palette','Timer regression'); var b=w.add('button',undefined,'Import'); b.onClick=function(){app.scheduleTask(\"app.project.items.addComp('Scheduled',64,64,1,1,25)\",0,false);};w.show();"})).unwrap();
+    assert_eq!(result["ok"], true, "{result}");
+    s.execute("scriptui.click", json!({"window":"Timer regression","widget":"Import"})).unwrap();
+    assert!(s.project.items.is_empty());
+    let tick = s.execute("script.runTasks", json!({})).unwrap();
+    assert_eq!(tick["ran"], 1, "{tick}");
+    assert_eq!(tick["errors"], json!([]), "{tick}");
+    assert!(s.project.items.values().any(|item| item.name == "Scheduled"));
+    s.execute("scriptui.close", json!({"window":"Timer regression"})).unwrap();
+}
+
+/// Layer ▸ Camera ▸ Link Focus Distance to Point of Interest / to Layer: the expressions
+/// evaluate to the camera's focus on the target.
+#[test]
+fn focus_link_expressions_track_the_target() {
+    use effectcraft_engine::geom::vec3;
+    let mut s = super::session();
+    s.execute("comp.new", json!({"name": "F", "width": 400, "height": 300, "duration": 2})).unwrap();
+    let t = s.execute("layer.newSolid", json!({"color": "#ffffff", "width": 50, "height": 50})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [t], "switch": "threeD", "value": true})).unwrap();
+    s.execute("layer.setTransform", json!({"layer": t, "prop": "position", "value": [260, 120, 400]})).unwrap();
+    let cam = s.execute("layer.newCamera", json!({})).unwrap()["layer"].as_u64().unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let focus = |s: &effectcraft_engine::Session| {
+        let comp = s.project.comp(cid).unwrap();
+        let mut ctx = effectcraft_engine::render::EvalCtx::new(&s.project, cid, comp, s.time());
+        ctx.expr = s.expr.as_deref();
+        let l = comp.layer(effectcraft_engine::project::LayerId(cam)).unwrap();
+        ctx.value(l, l.props.prop("cameraOptions/focusDistance").unwrap()).as_f64()
+    };
+    let depth = |s: &effectcraft_engine::Session| {
+        let comp = s.project.comp(cid).unwrap();
+        let ctx = effectcraft_engine::render::EvalCtx::new(&s.project, cid, comp, s.time());
+        let c = comp.layer(effectcraft_engine::project::LayerId(cam)).unwrap();
+        let tl = comp.layer(effectcraft_engine::project::LayerId(t)).unwrap();
+        let cs = effectcraft_engine::render::three_d::camera::layer_camera(&ctx, c);
+        cs.depth(ctx.world_matrix(tl).apply(vec3(25.0, 25.0, 0.0)))
+    };
+    s.execute("layer.select", json!({"layers": [cam, t]})).unwrap();
+    let set = s.execute("camera.setFocusToLayer", json!({})).unwrap()["focusDistance"].as_f64().unwrap();
+    assert!((set - depth(&s)).abs() < 1e-6 && (focus(&s) - set).abs() < 1e-6);
+    s.execute("camera.linkFocusToLayer", json!({})).unwrap();
+    // Move the target: the linked focus follows.
+    s.execute("layer.setTransform", json!({"layer": t, "prop": "position", "value": [200, 150, 900]})).unwrap();
+    assert!((focus(&s) - depth(&s)).abs() < 1e-3, "{} vs {}", focus(&s), depth(&s));
+    s.execute("camera.linkFocusToPoi", json!({"camera": cam})).unwrap();
+    let poi = {
+        let l = s.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(cam)).unwrap();
+        let p = l.props.prop("transform/position").unwrap().value.as_vec3();
+        let q = l.props.prop("transform/poi").unwrap().value.as_vec3();
+        ((p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2) + (p[2] - q[2]).powi(2)).sqrt()
+    };
+    assert!((focus(&s) - poi).abs() < 1e-6, "{} vs {poi}", focus(&s));
+}
+
+#[test]
+fn wired_session_renders_demo_with_expressions() {
+    let mut s = super::session();
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let lid = s.active_comp().unwrap().layers[1].id.0;
+    s.execute("prop.setExpression", json!({"layer": lid, "path": "transform/rotation", "expression": "time * 90"})).unwrap();
+    let img = s.render(cid, s.time(), effectcraft_engine::render::RenderOpts { scale: 0.25, ..Default::default() });
+    assert!(img.data.iter().any(|p| p[3] > 0.5));
+}
+
+/// File ▸ Import of glTF/GLB/OBJ models through the media layer, placed as model layers and
+/// drawn by the Advanced 3D renderer.
+#[test]
+fn imported_models_render_in_advanced_3d() {
+    let fx = |n: &str| format!("{}/../model/tests/fixtures/{n}", env!("CARGO_MANIFEST_DIR"));
+    let mut s = super::session();
+    s.execute("comp.new", json!({"name": "M", "width": 160, "height": 120, "renderer": "advanced3d"})).unwrap();
+    let r = s.execute("file.import", json!({"paths": [fx("cube.obj"), fx("quad.glb"), fx("quad.gltf")]})).unwrap();
+    assert_eq!(r["errors"], json!([]), "{r}");
+    let items: Vec<u64> = r["items"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
+    assert_eq!(items.len(), 3);
+    let cube = s.execute("layer.addItem", json!({"item": items[0]})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": cube, "path": "transform/rotationY", "value": 30})).unwrap();
+    s.execute("prop.set", json!({"layer": cube, "path": "transform/rotationX", "value": 20})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let opts = effectcraft_engine::render::RenderOpts::default();
+    let img = s.render(cid, s.time(), opts);
+    let covered = img.data.iter().filter(|p| p[3] > 0.99).count();
+    assert!(covered > 1000, "the cube covers part of the frame: {covered}");
+    // Red faces (material Red) are visible.
+    assert!(img.data.iter().any(|p| p[3] > 0.99 && p[0] > 0.5 && p[1] < 0.2));
+    // The textured binary glTF quad.
+    for _ in 0..3 {
+        s.execute("edit.undo", json!({})).unwrap();
+    }
+    s.execute("layer.addItem", json!({"item": items[1]})).unwrap();
+    let img = s.render(cid, s.time(), opts);
+    assert!(img.data.iter().filter(|p| p[3] > 0.99).count() > 1000);
+    // Classic 3D doesn't draw models.
+    s.execute("comp.renderer", json!({"renderer": "classic3d"})).unwrap();
+    assert!(s.render(cid, s.time(), opts).data.iter().all(|p| p[3] == 0.0));
+}
+
+/// A binary glTF of a red cube 2 units wide (positions and indices only).
+fn glb_cube() -> Vec<u8> {
+    let mut bin: Vec<u8> = (0..8u32).flat_map(|i| [i & 1, (i >> 1) & 1, (i >> 2) & 1].map(|b| b as f32 * 2.0 - 1.0)).flat_map(f32::to_le_bytes).collect();
+    let faces: [[u16; 4]; 6] = [[0, 2, 3, 1], [4, 5, 7, 6], [0, 1, 5, 4], [2, 6, 7, 3], [0, 4, 6, 2], [1, 3, 7, 5]];
+    bin.extend(faces.iter().flat_map(|f| [f[0], f[1], f[2], f[0], f[2], f[3]]).flat_map(u16::to_le_bytes));
+    let gltf = json!({
+        "asset": {"version": "2.0"},
+        "scene": 0,
+        "scenes": [{"nodes": [0]}],
+        "nodes": [{"mesh": 0}],
+        "meshes": [{"primitives": [{"attributes": {"POSITION": 0}, "indices": 1, "material": 0}]}],
+        "materials": [{"pbrMetallicRoughness": {"baseColorFactor": [1, 0, 0, 1], "metallicFactor": 0, "roughnessFactor": 1}}],
+        "buffers": [{"byteLength": bin.len()}],
+        "bufferViews": [{"buffer": 0, "byteOffset": 0, "byteLength": 96}, {"buffer": 0, "byteOffset": 96, "byteLength": 72}],
+        "accessors": [
+            {"bufferView": 0, "componentType": 5126, "count": 8, "type": "VEC3", "min": [-1, -1, -1], "max": [1, 1, 1]},
+            {"bufferView": 1, "componentType": 5123, "count": 36, "type": "SCALAR"}
+        ]
+    });
+    let mut text = gltf.to_string().into_bytes();
+    text.resize(text.len().div_ceil(4) * 4, b' ');
+    let chunk = |kind: &[u8; 4], data: &[u8]| [&(data.len() as u32).to_le_bytes()[..], kind, data].concat();
+    let body = [chunk(b"JSON", &text), chunk(b"BIN\0", &bin)].concat();
+    [&b"glTF"[..], &2u32.to_le_bytes(), &(12 + body.len() as u32).to_le_bytes(), &body].concat()
+}
+
+/// #264: a model imported into a new composition (Classic 3D by default) was invisible on
+/// every renderer, because only Advanced 3D draws models. Adding it now switches the comp,
+/// and the software renderer (no GPU, as on the reporter's Intel HD Graphics 5500) draws it.
+#[test]
+fn imported_glb_shows_in_a_new_composition() {
+    let path = std::env::temp_dir().join(format!("effectcraft-264-cube-{}.glb", std::process::id()));
+    std::fs::write(&path, glb_cube()).unwrap();
+    let mut s = super::session();
+    assert!(s.accel.is_none(), "renders in software");
+    let r = s.execute("file.import", json!({"paths": [path.to_string_lossy()]})).unwrap();
+    assert_eq!(r["errors"], json!([]), "{r}");
+    s.state.project_selection = vec![effectcraft_project::ItemId(r["items"][0].as_u64().unwrap())];
+    s.execute("file.newCompFromSelection", json!({})).unwrap();
+    let comp = s.active_comp().unwrap();
+    assert_eq!(comp.renderer, effectcraft_project::Renderer::Advanced3D);
+    let layer = comp.layers[0].id.0;
+    s.execute("prop.set", json!({"layer": layer, "path": "transform/rotationY", "value": 30})).unwrap();
+    s.execute("prop.set", json!({"layer": layer, "path": "transform/rotationX", "value": 20})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let img = s.render(cid, s.time(), effectcraft_engine::render::RenderOpts { scale: 0.25, ..Default::default() });
+    let red = img.data.iter().filter(|p| p[3] > 0.99 && p[0] > 0.2 && p[1] < 0.05 && p[2] < 0.05).count();
+    let _ = std::fs::remove_file(&path);
+    // Half the comp height wide, seen at an angle: well over 5% of the frame.
+    assert!(red * 20 > img.data.len(), "red cube pixels: {red} of {}", img.data.len());
+}
+
+/// #651: an animated GIF imported from disk plays: the layer shows each frame at its time,
+/// in the viewer's renders and in exports alike.
+#[test]
+fn an_imported_animated_gif_plays() {
+    let dir = std::env::temp_dir().join(format!("ec-gif-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("anim.gif");
+    let mut bytes = Vec::new();
+    {
+        let mut enc = gif::Encoder::new(&mut bytes, 4, 4, &[]).unwrap();
+        for rgb in [[255u8, 0, 0], [0, 255, 0], [0, 0, 255]] {
+            let mut f = gif::Frame::from_rgb(4, 4, &rgb.repeat(16));
+            f.delay = 10;
+            enc.write_frame(&f).unwrap();
+        }
+    }
+    std::fs::write(&path, bytes).unwrap();
+    let mut s = super::session();
+    s.execute("comp.new", json!({"name": "G", "width": 4, "height": 4, "frameRate": 30, "duration": 1})).unwrap();
+    s.execute("file.import", json!({"paths": [path.to_string_lossy()], "addToComp": true})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let rgb = |t: f64| {
+        let img = s.render(cid, effectcraft_time::Tick::from_seconds_f64(t), effectcraft_engine::render::RenderOpts::default());
+        let p = img.data[5];
+        [p[0].round(), p[1].round(), p[2].round()]
+    };
+    assert_eq!(rgb(0.05), [1.0, 0.0, 0.0]);
+    assert_eq!(rgb(0.15), [0.0, 1.0, 0.0]);
+    assert_eq!(rgb(0.25), [0.0, 0.0, 1.0]);
+    let _ = std::fs::remove_dir_all(dir);
+}
+
+/// The web app's path: outputs go to a sink (downloads), never to the file system.
+#[test]
+fn render_queue_exports_to_a_sink() {
+    use std::sync::{Arc, Mutex};
+    let got: Arc<Mutex<Vec<(String, Vec<u8>)>>> = Arc::default();
+    let g = got.clone();
+    let mut s = super::session();
+    s.exporter = Some(Arc::new(super::FileExporter { sink: Some(Arc::new(move |p: &str, d: Vec<u8>| g.lock().unwrap().push((p.to_string(), d)))) }));
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    // Rooted without a drive letter is not absolute on Windows, where the engine joins it to the home drive.
+    let dir = if cfg!(windows) { "C:/no-such-dir-effectcraft-sink-test" } else { "/no-such-dir-effectcraft-sink-test" };
+    s.execute(
+        "renderQueue.add",
+        json!({"format": "gif", "output": format!("{dir}/a.gif"), "resolution": 0.0625, "timeSpan": "custom", "start": 0.0, "end": 0.2}),
+    )
+    .unwrap();
+    s.execute(
+        "renderQueue.add",
+        json!({"format": "png", "output": format!("{dir}/seq_[##].png"), "resolution": 0.0625, "timeSpan": "custom", "start": 0.0, "end": 0.1}),
+    )
+    .unwrap();
+    s.execute("renderQueue.render", json!({"wait": true})).unwrap();
+    s.poll_render();
+    let mut got = got.lock().unwrap().clone();
+    got.sort_by(|a, b| a.0.cmp(&b.0));
+    let names: Vec<std::path::PathBuf> = got.iter().map(|(p, _)| std::path::PathBuf::from(p)).collect();
+    let expected = [format!("{dir}/a.gif"), format!("{dir}/seq_00.png"), format!("{dir}/seq_01.png"), format!("{dir}/seq_02.png")]
+        .map(|p| std::path::absolute(p).unwrap());
+    assert_eq!(names, expected);
+    assert!(got[0].1.starts_with(b"GIF89a"));
+    assert!(got[1].1.starts_with(b"\x89PNG"));
+    assert!(!std::path::Path::new(dir).exists());
+}
+
+#[test]
+fn render_queue_exports_demo_comp() {
+    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-rq");
+    let _ = std::fs::remove_dir_all(&dir);
+    let mut s = super::session();
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    let out = dir.join("[compName]_[width]x[height].[fileExtension]");
+    let r = s
+        .execute(
+            "renderQueue.add",
+            json!({"format": "h264", "output": out.to_string_lossy(), "resolution": 0.125, "timeSpan": "custom", "start": 0.0, "end": 0.4}),
+        )
+        .unwrap();
+    let path = r["outputPath"].as_str().unwrap().to_string();
+    assert!(path.ends_with("_240x134.mp4"), "{path}");
+    // A second item: PNG sequence, rendered in the background.
+    s.execute(
+        "renderQueue.add",
+        json!({"format": "png", "output": dir.join("seq_[###].png").to_string_lossy(), "resolution": 0.0625, "timeSpan": "custom", "start": 0.0, "end": 0.2}),
+    )
+    .unwrap();
+    let r = s.execute("renderQueue.render", json!({"wait": false})).unwrap();
+    assert_eq!(r["items"].as_array().unwrap().len(), 2);
+    let t0 = std::time::Instant::now();
+    while s.is_rendering() {
+        assert!(t0.elapsed().as_secs() < 300, "render timed out");
+        std::thread::sleep(std::time::Duration::from_millis(20));
+        s.poll_render();
+    }
+    s.poll_render();
+    let list = s.execute("renderQueue.list", json!({})).unwrap();
+    for it in list["items"].as_array().unwrap() {
+        assert_eq!(it["statusLabel"], "Done", "{it}");
+        assert!(it["render_time"].as_f64().is_some());
+        assert!(std::path::Path::new(it["last_output"].as_str().unwrap()).exists(), "{it}");
+    }
+    assert!(std::path::Path::new(&path).metadata().unwrap().len() > 500);
+    assert!(dir.join("seq_000.png").exists() && dir.join("seq_005.png").exists() && !dir.join("seq_006.png").exists());
+    // Rendering again needs a re-queue.
+    assert!(s.execute("renderQueue.render", json!({})).is_err());
+    s.execute("renderQueue.setRender", json!({"index": 1, "render": true})).unwrap();
+    assert_eq!(s.project.render_queue[0].status, effectcraft_engine::project::render_queue::RenderStatus::Queued);
+}
+
+/// Value of a property of layer `l` at time 0 (keys + expression).
+fn value(s: &effectcraft_engine::Session, l: u64, path: &str) -> effectcraft_engine::keyframe::Value {
+    let cid = s.active_comp_id().unwrap();
+    let comp = s.project.comp(cid).unwrap();
+    let layer = comp.layer(effectcraft_engine::project::LayerId(l)).unwrap();
+    let ctx = effectcraft_engine::render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time: Default::default(),
+        expr: s.expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
+    ctx.value(layer, layer.props.prop(path).unwrap())
+}
+
+#[test]
+fn pick_whip_expressions_evaluate() {
+    let mut s = super::session();
+    s.execute("comp.new", json!({"name": "C", "width": 200, "height": 200, "frameRate": 30, "duration": 2})).unwrap();
+    let a = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
+    let b = s.execute("layer.newSolid", json!({"name": "Src", "color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": b, "path": "transform/rotation", "value": 33})).unwrap();
+    s.execute("prop.set", json!({"layer": b, "path": "transform/position", "value": [12, 34]})).unwrap();
+    s.execute("effect.apply", json!({"layer": b, "effect": "Gaussian Blur"})).unwrap();
+    s.execute("prop.set", json!({"layer": b, "path": "effects/#1/blurriness", "value": 21})).unwrap();
+    s.execute("layer.addMask", json!({"layer": b})).unwrap();
+    s.execute("prop.set", json!({"layer": b, "path": "masks/#1/feather", "value": [7, 7]})).unwrap();
+    let link = |s: &mut effectcraft_engine::Session, from: &str, to: &str| {
+        s.execute("prop.pickWhip", json!({"layer": a, "path": from, "target": {"layer": b, "path": to}})).unwrap();
+    };
+    link(&mut s, "transform/opacity", "transform/rotation");
+    assert_eq!(value(&s, a, "transform/opacity").as_f64(), 33.0);
+    link(&mut s, "transform/scale", "transform/rotation");
+    let cid = s.active_comp_id().unwrap();
+    let ep = effectcraft_expr::eval_property(&s.project, cid, effectcraft_engine::project::LayerId(a), "transform/scale", 0.0);
+    assert!(ep.is_ok(), "{ep:?}");
+    assert_eq!(value(&s, a, "transform/scale").as_vec2(), [33.0, 33.0]);
+    link(&mut s, "transform/position", "transform/position");
+    assert_eq!(value(&s, a, "transform/position").as_vec2(), [12.0, 34.0]);
+    link(&mut s, "transform/rotation", "effects/#1/blurriness");
+    assert_eq!(value(&s, a, "transform/rotation").as_f64(), 21.0);
+    link(&mut s, "transform/opacity", "masks/#1/feather");
+    assert_eq!(value(&s, a, "transform/opacity").as_f64(), 7.0);
+    // Separated dimensions: X Position reference.
+    s.execute("prop.separateDimensions", json!({"layer": b})).unwrap();
+    link(&mut s, "transform/rotation", "transform/positionX");
+    assert_eq!(value(&s, a, "transform/rotation").as_f64(), 12.0);
+}
+
+/// The expression error bar's list: evaluation errors and syntax errors, with the layer and
+/// property they belong to.
+#[test]
+fn expression_errors_are_collected() {
+    let mut s = super::session();
+    s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
+    let a = s.execute("layer.newSolid", json!({"name": "Box", "color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "50"})).unwrap();
+    assert_eq!(s.execute("expr.errors", json!({})).unwrap()["count"], 0);
+    s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "expression": "thisComp.layer(\"Nope\").rotation"})).unwrap();
+    s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "1 +* ("})).unwrap();
+    let r = s.execute("expr.errors", json!({})).unwrap();
+    assert_eq!(r["count"], 2, "{r}");
+    let errs = r["errors"].as_array().unwrap();
+    let rot = errs.iter().find(|e| e["path"] == "transform/rotation").unwrap();
+    assert!(rot["message"].as_str().unwrap().contains("Nope"), "{rot}");
+    assert_eq!(rot["layerIndex"], 1);
+    assert_eq!(rot["layerName"], "Box");
+    assert_eq!(rot["disabled"], false);
+    let op = errs.iter().find(|e| e["path"] == "transform/opacity").unwrap();
+    assert_eq!(op["disabled"], true);
+    assert!(r["text"][0].as_str().unwrap().contains("of layer 1 ('Box') in comp 'C'"), "{r}");
+    // A user-disabled (but valid) expression is not an error.
+    s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "expression": "45"})).unwrap();
+    s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "enabled": false})).unwrap();
+    assert_eq!(s.execute("expr.errors", json!({})).unwrap()["count"], 1);
+    // The Expression Language menu is categorised.
+    let m = s.execute("expr.languageMenu", json!({})).unwrap();
+    assert!(m.as_array().unwrap().iter().any(|c| c["category"] == "Footage" && c["items"].as_array().unwrap().iter().any(|i| i["text"] == "sourceData")));
+}
+
+/// File ▸ Import of JSON/CSV data files as data footage, read by expressions.
+#[test]
+fn imported_data_files_drive_expressions() {
+    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-data");
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(dir.join("levels.csv"), "label,value\nlow,10\nhigh,90\n").unwrap();
+    std::fs::write(dir.join("cfg.json"), r#"{"angle": 33}"#).unwrap();
+    std::fs::write(dir.join("broken.json"), "{nope").unwrap();
+    let mut s = super::session();
+    s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
+    let paths: Vec<String> = ["levels.csv", "cfg.json", "broken.json"].iter().map(|n| dir.join(n).to_string_lossy().to_string()).collect();
+    let r = s.execute("file.import", json!({"paths": paths})).unwrap();
+    assert_eq!(r["items"].as_array().unwrap().len(), 2, "{r}");
+    assert_eq!(r["errors"].as_array().unwrap().len(), 1, "{r}");
+    let csv = r["items"][0].as_u64().unwrap();
+    assert_eq!(s.project.item(effectcraft_engine::project::ItemId(csv)).unwrap().type_name(), "Data");
+    assert!(s.execute("layer.addItem", json!({"item": csv})).is_err(), "data files are not layers");
+    let a = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "footage(\"levels.csv\").sourceData[1].value"})).unwrap();
+    s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "expression": "footage(\"cfg.json\").sourceData.angle"})).unwrap();
+    assert_eq!(value(&s, a, "transform/opacity").as_f64(), 90.0);
+    assert_eq!(value(&s, a, "transform/rotation").as_f64(), 33.0);
+}
+
+/// sampleImage through the renderer: a box's Fill colour follows the solid under it.
+#[test]
+fn sample_image_drives_a_colour() {
+    let mut s = super::session();
+    s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Bg", "color": "#00ff00"})).unwrap();
+    let a = s.execute("layer.newSolid", json!({"name": "Fg", "color": "#ffffff", "width": 20, "height": 20})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("effect.apply", json!({"layer": a, "effect": "Fill"})).unwrap();
+    s.execute(
+        "prop.setExpression",
+        json!({"layer": a, "path": "effects/#1/color", "expression": "thisComp.layer(\"Bg\").sampleImage(thisComp.layer(\"Bg\").fromComp(toComp(anchorPoint)))"}),
+    )
+    .unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let img = s.render(cid, s.time(), effectcraft_engine::render::RenderOpts::default());
+    let px = img.get(50, 50);
+    assert!(px[1] > 0.99 && px[0] < 0.01, "the box is filled with the sampled green: {px:?}");
+}
+
+/// Proxies through the real media and export layers: Render Settings ▸ Proxy Use decides
+/// whether an export uses the proxy, and Create Proxy renders and attaches one.
+#[test]
+fn proxies_in_exports_and_create_proxy() {
+    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-proxy");
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let p = |n: &str| dir.join(n).to_string_lossy().to_string();
+    let mut s = super::session();
+    // Source and proxy stills, written by the app itself.
+    s.execute("comp.new", json!({"name": "Red", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
+    let red = s.active_comp_id().unwrap();
+    s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
+    s.execute("comp.saveFrameAs", json!({"path": p("red.png")})).unwrap();
+    s.execute("comp.new", json!({"name": "Blue", "width": 8, "height": 8, "frameRate": 10, "duration": 1})).unwrap();
+    s.execute("layer.newSolid", json!({"color": "#0000ff"})).unwrap();
+    s.execute("comp.saveFrameAs", json!({"path": p("blue.png")})).unwrap();
+    let foot = s.execute("file.import", json!({"paths": [p("red.png")]})).unwrap()["items"][0].as_u64().unwrap();
+    s.execute("file.setProxy", json!({"item": foot, "path": p("blue.png")})).unwrap();
+    s.execute("comp.new", json!({"name": "Out", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
+    let out = s.active_comp_id().unwrap();
+    s.execute("layer.addItem", json!({"item": foot})).unwrap();
+    // Export one frame with each Proxy Use.
+    for (name, using) in [("all", "use_all_[#].png"), ("none", "use_none_[#].png")] {
+        s.execute(
+            "renderQueue.add",
+            json!({"comp": out.0, "format": "png", "output": p(using), "timeSpan": "custom", "start": 0.0, "end": 0.1, "proxyUse": name}),
+        )
+        .unwrap();
+    }
+    s.execute("renderQueue.render", json!({"wait": true})).unwrap();
+    s.poll_render();
+    let centre = |s: &mut effectcraft_engine::Session, path: &str| {
+        let id = s.execute("file.import", json!({"paths": [path]})).unwrap()["items"][0].as_u64().unwrap();
+        s.execute("comp.new", json!({"name": "Probe", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
+        s.execute("layer.addItem", json!({"item": id})).unwrap();
+        let c = s.active_comp_id().unwrap();
+        s.render(c, Default::default(), Default::default()).get(8, 8)
+    };
+    let all = centre(&mut s, &p("use_all_0.png"));
+    assert!(all[2] > 0.99 && all[0] < 0.01, "Use All Proxies renders the blue proxy: {all:?}");
+    let none = centre(&mut s, &p("use_none_0.png"));
+    assert!(none[0] > 0.99 && none[2] < 0.01, "Use No Proxies renders the red source: {none:?}");
+    // Create Proxy ▸ Still: rendered at half size and attached to the comp.
+    s.execute("file.createProxy", json!({"kind": "still", "comp": red.0, "path": p("red_proxy_[#####].png")})).unwrap();
+    s.execute("renderQueue.render", json!({"wait": true})).unwrap();
+    s.poll_render();
+    let px = s.project.item(red).unwrap().proxy.clone().expect("Create Proxy attached the rendered still");
+    assert!(px.enabled);
+    assert_eq!((px.footage.width, px.footage.height), (8, 8));
+    assert!(std::path::Path::new(&px.footage.path).exists(), "{}", px.footage.path);
+}
+
+/// A script builds a comp, queues it and renders it through the Render Queue.
+#[test]
+fn script_renders_through_the_render_queue() {
+    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-script");
+    let _ = std::fs::remove_dir_all(&dir);
+    let out = dir.join("scripted.gif");
+    let mut s = super::session();
+    let code = format!(
+        r#"
+            var comp = app.project.items.addComp("Scripted", 64, 48, 1, 0.2, 10);
+            var sq = comp.layers.addSolid([1, 0.5, 0], "Square", 16, 16, 1);
+            sq.transform.position.setValueAtTime(0, [8, 24]);
+            sq.transform.position.setValueAtTime(0.1, [56, 24]);
+            var item = app.project.renderQueue.items.add(comp);
+            item.outputModule(1).applyTemplate("GIF");
+            item.outputModule(1).file = new File({});
+            app.project.renderQueue.render();
+            [item.status == RQItemStatus.DONE, item.outputModule(1).file.fsName, app.project.renderQueue.numItems]
+            "#,
+        serde_json::to_string(&out.to_string_lossy()).unwrap()
+    );
+    let r = s.execute("script.run", json!({"code": code})).unwrap();
+    assert_eq!(r["ok"], json!(true), "{r}");
+    assert_eq!(r["result"][0], json!(true), "{r}");
+    assert_eq!(r["result"][2], json!(1));
+    let bytes = std::fs::read(&out).unwrap();
+    assert!(bytes.starts_with(b"GIF89a"));
+}
+
+/// importFile, layers.add(footage) and project save/open from a script.
+#[test]
+fn script_imports_footage_and_saves() {
+    let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-script-import");
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    let q = |n: &str| serde_json::to_string(&dir.join(n).to_string_lossy()).unwrap();
+    let mut s = super::session();
+    let code = format!(
+        r#"
+            var c = app.project.items.addComp("Src", 32, 32, 1, 1, 10);
+            c.layers.addSolid([0, 1, 0], "G", 32, 32, 1);
+            app.run("comp.saveFrameAs", {{comp: c.id, path: {png}}});
+            var still = app.project.importFile(new ImportOptions(new File({png})));
+            var main = app.project.items.addComp("Main", 64, 64, 1, 1, 10);
+            var l = main.layers.add(still);
+            app.project.save(new File({proj}));
+            [still instanceof FootageItem, still.width, still.mainSource.isStill, l.source.name, app.project.file.name]
+            "#,
+        png = q("frame.png"),
+        proj = q("p.ecproj")
+    );
+    let r = s.execute("script.run", json!({"code": code})).unwrap();
+    assert_eq!(r["ok"], json!(true), "{r}");
+    assert_eq!(r["result"], json!([true, 32, true, "frame.png", "p.ecproj"]), "{r}");
+    let r = s.execute("script.run", json!({"code": format!("app.open(new File({})); app.project.numItems", q("p.ecproj"))})).unwrap();
+    assert_eq!(r["result"], json!(5), "{r}"); // Src, Solids, G, frame.png, Main
+}
+
+#[test]
+fn expression_syntax_errors_disable_the_expression() {
+    let mut s = super::session();
+    s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
+    let a = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
+    let r = s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "1 +* ("})).unwrap();
+    assert!(r["error"].is_string(), "{r}");
+    let pr = s.active_comp().unwrap().layers[0].props.prop("transform/opacity").unwrap().clone();
+    assert!(!pr.expr.unwrap().enabled);
+    assert_eq!(value(&s, a, "transform/opacity").as_f64(), 100.0);
+    s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "50"})).unwrap();
+    assert_eq!(value(&s, a, "transform/opacity").as_f64(), 50.0);
+}
+/// Create Stereo 3D Rig: the eye cameras' expressions follow the master camera and the
+/// Stereo 3D Controls (and agree with the values the command wrote).
+#[test]
+fn stereo_rig_expressions_follow_the_master_camera() {
+    let mut s = super::session();
+    s.execute("comp.new", json!({"name": "Shot", "width": 640, "height": 360, "frameRate": 30, "duration": 2})).unwrap();
+    let src = s.active_comp_id().unwrap();
+    let cam = s.execute("layer.newCamera", json!({"name": "Main", "position": [320, 180, -800], "poi": [320, 180, 0], "zoom": 900})).unwrap()["layer"]
+        .as_u64()
+        .unwrap();
+    let r = s.execute("camera.stereoRig", json!({"sceneDepth": 4})).unwrap();
+    let ctl = r["controls"].as_u64().unwrap();
+    let left = effectcraft_engine::project::ItemId(r["leftComp"].as_u64().unwrap());
+    // The left eye camera's evaluated value (expressions on).
+    let v3 = |s: &effectcraft_engine::Session, path: &str| {
+        let comp = s.project.comp(left).unwrap();
+        let layer = &comp.layers[0];
+        let ctx = effectcraft_engine::render::EvalCtx {
+            project: &s.project,
+            comp_id: left,
+            comp,
+            time: Default::default(),
+            expr: s.expr.as_deref(),
+            footage: None,
+            property_overrides: &[],
+            media_overrides: &[],
+        };
+        ctx.value(layer, layer.props.prop(path).unwrap()).as_vec3()
+    };
+    let close = |a: [f64; 3], b: [f64; 3]| (0..3).all(|i| (a[i] - b[i]).abs() < 1e-6);
+    let d = 0.04 * 640.0;
+    assert!(close(v3(&s, "transform/position"), [320.0 - d / 2.0, 180.0, -800.0]), "{:?}", v3(&s, "transform/position"));
+    assert!(close(v3(&s, "transform/poi"), [320.0 - d / 2.0, 180.0, 0.0]), "{:?}", v3(&s, "transform/poi"));
+    // Moving the master moves the eyes.
+    s.execute("comp.open", json!({"comp": src.0})).unwrap();
+    s.execute("prop.set", json!({"layer": cam, "path": "transform/position", "value": [300, 180, -800]})).unwrap();
+    s.execute("prop.set", json!({"layer": cam, "path": "transform/poi", "value": [300, 180, 0]})).unwrap();
+    assert!(close(v3(&s, "transform/position"), [300.0 - d / 2.0, 180.0, -800.0]), "{:?}", v3(&s, "transform/position"));
+    // Controls: Center & Left puts the left eye a full separation left; convergence toes in.
+    s.execute("prop.set", json!({"layer": ctl, "path": "effects/#1/configuration", "value": 2})).unwrap();
+    s.execute("prop.set", json!({"layer": ctl, "path": "effects/#1/convergence", "value": true})).unwrap();
+    assert!(close(v3(&s, "transform/position"), [300.0 - d, 180.0, -800.0]), "{:?}", v3(&s, "transform/position"));
+    assert!(close(v3(&s, "transform/poi"), [300.0, 180.0, 0.0]), "{:?}", v3(&s, "transform/poi"));
+}
diff --git a/crates/host/tests/it/background_presets.rs b/crates/host/tests/it/background_presets.rs
index e3e44b009..c03ec0066 100644
--- a/crates/host/tests/it/background_presets.rs
+++ b/crates/host/tests/it/background_presets.rs
@@ -58,3 +58,34 @@ fn every_background_preset_renders_moves_and_undoes() {
         assert_eq!(fx, 0, "{id}: undo removes the effects");
     }
 }
+
+/// #1510: each Behaviors preset keeps its layer moving (position, scale, rotation or opacity
+/// changes over time) and renders finite, deterministic frames.
+#[test]
+fn every_behavior_preset_renders_and_moves() {
+    let mut s = effectcraft_host::session();
+    s.execute("comp.new", json!({"name": "BH", "width": 160, "height": 90, "frameRate": 30, "duration": 8})).unwrap();
+    // A small white square in the middle so position, scale and rotation changes are visible.
+    let solid = s.execute("layer.newSolid", json!({"name": "S", "color": "#ffffff", "width": 60, "height": 60})).unwrap()["layer"].as_u64().unwrap();
+    let list = s.execute("anim.builtinPresets", json!({"category": "Behaviors"})).unwrap();
+    let list = list.as_array().unwrap().clone();
+    assert!(list.len() >= 20, "{}", list.len());
+    for p in &list {
+        let id = p["id"].as_str().unwrap();
+        s.execute("time.set", json!({"time": 0.0})).unwrap();
+        let r = s.execute("anim.applyBuiltinPreset", json!({"layers": [solid], "preset": id})).unwrap();
+        assert_eq!(r["skipped"], json!([]), "{id}");
+        let mut frames = Vec::new();
+        // Times chosen off the periods of every preset so no two samples coincide.
+        for t in [0.03, 0.13, 0.41, 0.97, 1.73] {
+            let (px, _, _, nan) = frame(&s, t);
+            assert!(!nan, "{id} @ {t}: NaN or infinite pixel");
+            let (again, ..) = frame(&s, t);
+            assert!(px == again, "{id} @ {t}: render is not deterministic");
+            frames.push(px);
+        }
+        let moved = (1..frames.len()).any(|i| diff(&frames[0], &frames[i]) > 20.0);
+        assert!(moved, "{id}: the layer does not move ({:?})", (1..frames.len()).map(|i| diff(&frames[0], &frames[i])).collect::<Vec<_>>());
+        s.execute("edit.undo", json!({})).unwrap();
+    }
+}
diff --git a/crates/host/tests/it/footage_reload.rs b/crates/host/tests/it/footage_reload.rs
index faf2b09e3..876c543ec 100644
--- a/crates/host/tests/it/footage_reload.rs
+++ b/crates/host/tests/it/footage_reload.rs
@@ -146,27 +146,58 @@ fn a_file_still_being_written_is_tried_again() {
     assert!(near(pixel(&s, cid, 32, 24), BLUE));
 }
 
+/// The desktop app's watcher ([`footage_reload::Watcher`]) notices a footage file another app
+/// saved, hands its stamps over once, and reloads it through [`footage_reload::apply_stamps`];
+/// while nothing changes it hands over nothing (so the interface is never woken for it).
 #[test]
-fn background_scan_reloads_changed_footage() {
-    let path = tmp("scan.psd");
+fn the_watcher_notices_a_footage_file_changed_on_disk() {
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::time::{Duration, Instant};
+    let path = tmp("watched.psd");
     std::fs::write(&path, flat(RED, false)).unwrap();
     let (mut s, _, cid) = flat_in_comp(&path);
-    let scan = |s: &mut Session| {
-        footage_reload::start_scan(s);
-        let t0 = std::time::Instant::now();
+    let wakes = Arc::new(AtomicUsize::new(0));
+    let counter = Arc::clone(&wakes);
+    let fast = Duration::from_millis(20);
+    let mut w = footage_reload::Watcher::start_with(
+        s.services.clone(),
+        move || {
+            counter.fetch_add(1, Ordering::SeqCst);
+        },
+        fast,
+        Duration::from_secs(60),
+    )
+    .unwrap();
+    w.set_focused(true);
+    w.set_watched(footage_reload::watched(&s));
+    // Report `n`: the worker stores the stamps and then wakes the interface, so wait for the
+    // wake too, not only for the stamps.
+    let next = |w: &footage_reload::Watcher, n: usize| {
+        let t0 = Instant::now();
         loop {
-            if let Some(r) = footage_reload::poll_scan(s) {
-                return r.unwrap();
+            if wakes.load(Ordering::SeqCst) >= n
+                && let Some(stamps) = w.take()
+            {
+                return stamps;
             }
-            assert!(t0.elapsed().as_secs() < 10, "scan never finished");
-            std::thread::yield_now();
+            assert!(t0.elapsed() < Duration::from_secs(10), "the watcher never reported");
+            std::thread::sleep(Duration::from_millis(5));
         }
     };
-    assert_eq!(scan(&mut s), json!({"files": 0, "reloaded": 0}));
+    // First look: remembered, nothing to reload.
+    assert_eq!(footage_reload::apply_stamps(&mut s, next(&w, 1)).unwrap(), json!({"files": 0, "reloaded": 0}));
+    assert_eq!(wakes.load(Ordering::SeqCst), 1);
+    std::thread::sleep(fast * 15);
+    assert!(w.take().is_none(), "an unchanged file is never reported");
+    assert_eq!(wakes.load(Ordering::SeqCst), 1, "and never wakes the interface");
+    // Saved in another app: reported once, reloaded, shown.
     save(&path, &flat(GREEN, true));
-    assert_eq!(scan(&mut s), json!({"files": 1, "reloaded": 1}));
+    assert_eq!(footage_reload::apply_stamps(&mut s, next(&w, 2)).unwrap(), json!({"files": 1, "reloaded": 1}));
     assert!(near(pixel(&s, cid, 32, 24), GREEN));
-    assert!(s.footage_scan.is_none());
+    assert_eq!(wakes.load(Ordering::SeqCst), 2);
+    std::thread::sleep(fast * 10);
+    assert!(w.take().is_none());
 }
 
 #[test]
diff --git a/crates/host/tests/it/main.rs b/crates/host/tests/it/main.rs
index 73fc04841..826363edb 100644
--- a/crates/host/tests/it/main.rs
+++ b/crates/host/tests/it/main.rs
@@ -6,9 +6,11 @@ mod determinism;
 mod exr_layers;
 mod footage_reload;
 mod gif_animates;
+mod pick_whip;
 mod plugins;
 mod relink;
 mod tga_import;
 mod timeline_interop;
 mod vector_import;
+mod wav_markers;
 mod webm_metadata;
diff --git a/crates/host/tests/it/pick_whip.rs b/crates/host/tests/it/pick_whip.rs
new file mode 100644
index 000000000..340cda053
--- /dev/null
+++ b/crates/host/tests/it/pick_whip.rs
@@ -0,0 +1,38 @@
+//! The pick whip's references read the property they were made from (#1072): an Alt pick whip's
+//! (`byIndex`) select an effect's properties by index, `effect("Fractal Noise")(i)(j)`, and must
+//! read the same value as the reference by name.
+//!
+//! (With Compact English off, a reference to another layer, `thisComp.layer("Other")("effects")…`,
+//! doesn't evaluate yet, by name or by index: "not a callable function".)
+
+use serde_json::{Value, json};
+
+#[test]
+fn index_references_read_the_same_values_as_names() {
+    let mut s = effectcraft_host::session();
+    s.execute("comp.new", json!({"name": "T", "width": 64, "height": 64, "duration": 1})).unwrap();
+    let l = s.execute("layer.newSolid", json!({"name": "Reader", "color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
+    let o = s.execute("layer.newSolid", json!({"name": "Other", "color": "#00ff00"})).unwrap()["layer"].as_u64().unwrap();
+    for fx in ["Fractal Noise", "Point Control"] {
+        s.execute("effect.apply", json!({"layer": o, "effect": fx})).unwrap();
+    }
+    s.execute("prop.set", json!({"layer": o, "path": "effects/#1/transform/scale", "value": 77})).unwrap();
+    s.execute("prop.set", json!({"layer": o, "path": "effects/#2/point", "value": [12, 34]})).unwrap();
+    let evaluated = |s: &mut effectcraft_engine::Session, path: &str| -> Value {
+        let v = s.execute("prop.get", json!({"layer": l, "path": path})).unwrap();
+        assert!(v.get("expressionError").is_none(), "{v}");
+        v["evaluated"].clone()
+    };
+    for (path, target, dimension, want) in
+        [("transform/rotation", "effects/#1/transform/scale", None, json!(77.0)), ("transform/opacity", "effects/#2/point", Some(1), json!(34.0))]
+    {
+        let mut t = json!({"layer": o, "path": target});
+        if let Some(d) = dimension {
+            t["dimension"] = json!(d);
+        }
+        for by_index in [false, true] {
+            let e = s.execute("prop.pickWhip", json!({"layer": l, "path": path, "target": t, "byIndex": by_index})).unwrap();
+            assert_eq!(evaluated(&mut s, path), want, "by index {by_index}: {e}");
+        }
+    }
+}
diff --git a/crates/host/tests/it/timeline_interop.rs b/crates/host/tests/it/timeline_interop.rs
index 5123dc721..9688a409f 100644
--- a/crates/host/tests/it/timeline_interop.rs
+++ b/crates/host/tests/it/timeline_interop.rs
@@ -56,8 +56,9 @@ fn still(p: &mut fp::Project, path: &str) -> fp::ItemId {
             color: Default::default(),
             has_alpha: false,
             bitrate: None,
+            hdr: None,
         }),
-        audio: None,
+        audio_streams: Vec::new(),
         container: String::new(),
         start_timecode: None,
         file_size: None,
diff --git a/crates/host/tests/it/vector_import.rs b/crates/host/tests/it/vector_import.rs
index 36d83dd1a..badd60b66 100644
--- a/crates/host/tests/it/vector_import.rs
+++ b/crates/host/tests/it/vector_import.rs
@@ -509,7 +509,7 @@ fn shapes_from_vector_layer_keeps_images_as_footage_layers() {
     assert_eq!(names, ["images.pdf Outlines", "Image", "Image", "images.pdf Outlines 1", "images.pdf"]);
     assert_eq!(c.layers[0].id.0, sid);
     assert_eq!(r["layers"].as_array().unwrap().len(), 2);
-    for l in &c.layers[1..3] {
+    for l in c.layers.iter().skip(1).take(2) {
         assert_eq!(l.parent.map(|p| p.0), Some(sid), "{}", l.name);
         assert!(matches!(l.source, effectcraft_project::LayerSource::Footage { .. }));
     }
diff --git a/crates/host/tests/it/wav_markers.rs b/crates/host/tests/it/wav_markers.rs
new file mode 100644
index 000000000..98d2685dc
--- /dev/null
+++ b/crates/host/tests/it/wav_markers.rs
@@ -0,0 +1,126 @@
+//! Markers a WAV file carries, through the fully wired session (media import included): the
+//! layer made from the file starts with them, and Update Markers From Source copies them again,
+//! through its bound `layers` parameter as well as the selection, as one undo step.
+
+use effectcraft_engine::Session;
+use effectcraft_project::LayerSource;
+use serde_json::json;
+
+/// The comments of a layer's markers, in time order.
+fn names(s: &mut Session, layer: u64) -> Vec<String> {
+    let list = s.execute_checked("markers.list", json!({"layer": layer})).unwrap();
+    list.as_array().unwrap().iter().map(|m| m["comment"].as_str().unwrap().to_string()).collect()
+}
+
+/// A one-second mono 8 kHz WAV with the named cue points `(id, sample, name)` (a `cue ` chunk and a
+/// `LIST` `adtl`).
+fn marker_wav(points: &[(u32, u32, &str)]) -> Vec<u8> {
+    fn chunk(id: &[u8; 4], body: &[u8]) -> Vec<u8> {
+        let mut v = id.to_vec();
+        v.extend((body.len() as u32).to_le_bytes());
+        v.extend(body);
+        if body.len() % 2 == 1 {
+            v.push(0);
+        }
+        v
+    }
+    let mut fmt = Vec::new();
+    fmt.extend(1u16.to_le_bytes());
+    fmt.extend(1u16.to_le_bytes());
+    fmt.extend(8000u32.to_le_bytes());
+    fmt.extend(16000u32.to_le_bytes());
+    fmt.extend(2u16.to_le_bytes());
+    fmt.extend(16u16.to_le_bytes());
+    let mut cue = (points.len() as u32).to_le_bytes().to_vec();
+    let mut adtl = b"adtl".to_vec();
+    for &(id, at, name) in points {
+        for v in [id, 0] {
+            cue.extend(v.to_le_bytes());
+        }
+        cue.extend(b"data");
+        for v in [0, 0, at] {
+            cue.extend(u32::to_le_bytes(v));
+        }
+        let mut labl = id.to_le_bytes().to_vec();
+        labl.extend(name.as_bytes());
+        labl.push(0);
+        adtl.extend(chunk(b"labl", &labl));
+    }
+    let mut body = b"WAVE".to_vec();
+    for c in [chunk(b"fmt ", &fmt), chunk(b"data", &[0; 16000]), chunk(b"cue ", &cue), chunk(b"LIST", &adtl)] {
+        body.extend(c);
+    }
+    let mut file = b"RIFF".to_vec();
+    file.extend((body.len() as u32).to_le_bytes());
+    file.extend(body);
+    file
+}
+
+/// A WAV's cue points become markers on the layer made from it, named as in the file, and
+/// Update Markers From Source brings back one that was deleted (through the fully wired session,
+/// media import included).
+#[test]
+fn a_wav_layer_starts_with_the_markers_in_its_file() {
+    let mut s = effectcraft_host::session();
+    s.execute_checked("comp.new", json!({"name": "C", "width": 64, "height": 48, "frameRate": 30, "duration": 2})).unwrap();
+    let dir = std::env::temp_dir().join(format!("effectcraft-host-wav-markers-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("cues.wav");
+    std::fs::write(&path, marker_wav(&[(1, 0, "Intro"), (2, 4000, "Middle")])).unwrap();
+    let r = s.execute_checked("file.import", json!({"paths": [path.to_string_lossy()], "addToComp": true})).unwrap();
+    assert_eq!(r["errors"], json!([]), "{r}");
+    let layer = s.active_comp().unwrap().layers.iter().find(|l| matches!(l.source, LayerSource::Footage { .. })).unwrap().id.0;
+    let list = s.execute_checked("markers.list", json!({"layer": layer})).unwrap();
+    let marks: Vec<(String, f64)> =
+        list.as_array().unwrap().iter().map(|m| (m["comment"].as_str().unwrap().to_string(), m["time"].as_f64().unwrap())).collect();
+    assert_eq!(marks, [("Intro".to_string(), 0.0), ("Middle".to_string(), 0.5)]);
+    s.execute_checked("markers.delete", json!({"layer": layer, "index": 0})).unwrap();
+    assert_eq!(names(&mut s, layer), ["Middle"]);
+    s.execute_checked("layer.select", json!({"layers": [layer]})).unwrap();
+    // The bound `layers` parameter (what a script or the menu's own binding passes) brings the marker back...
+    let r = s.execute_checked("layer.updateMarkersFromSource", json!({"layers": [layer]})).unwrap();
+    assert_eq!(r["added"], 1);
+    assert_eq!(names(&mut s, layer), ["Intro", "Middle"]);
+    // ...as one undo step: undo removes it again, redo restores it.
+    assert!(s.undo());
+    assert_eq!(names(&mut s, layer), ["Middle"]);
+    assert!(s.redo());
+    assert_eq!(names(&mut s, layer), ["Intro", "Middle"]);
+    // The selection route (no parameter) finds nothing more to add.
+    assert_eq!(s.execute_checked("layer.updateMarkersFromSource", json!({})).unwrap()["added"], 0);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// Reload Footage re-reads the markers the file carries: a cue point added to the file after the
+/// import is available to Update Markers From Source (and a layer already made keeps its own).
+#[test]
+fn reloading_a_wav_picks_up_cue_points_added_to_the_file() {
+    let mut s = effectcraft_host::session();
+    s.execute_checked("comp.new", json!({"name": "C", "width": 64, "height": 48, "frameRate": 30, "duration": 2})).unwrap();
+    let dir = std::env::temp_dir().join(format!("effectcraft-host-wav-reload-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("cues.wav");
+    std::fs::write(&path, marker_wav(&[(1, 0, "Intro")])).unwrap();
+    let r = s.execute_checked("file.import", json!({"paths": [path.to_string_lossy()], "addToComp": true})).unwrap();
+    assert_eq!(r["errors"], json!([]), "{r}");
+    let (layer, item) = s
+        .active_comp()
+        .unwrap()
+        .layers
+        .iter()
+        .find_map(|l| match l.source {
+            LayerSource::Footage { item } => Some((l.id.0, item.0)),
+            _ => None,
+        })
+        .unwrap();
+    assert_eq!(names(&mut s, layer), ["Intro"]);
+    // The file gains a cue point; the layer does not change until asked.
+    std::fs::write(&path, marker_wav(&[(1, 0, "Intro"), (2, 4000, "Added later")])).unwrap();
+    let r = s.execute_checked("file.reloadFootage", json!({"items": [item]})).unwrap();
+    assert_eq!(r["reloaded"], 1, "{r}");
+    assert_eq!(names(&mut s, layer), ["Intro"]);
+    let r = s.execute_checked("layer.updateMarkersFromSource", json!({"layers": [layer]})).unwrap();
+    assert_eq!(r["added"], 1);
+    assert_eq!(names(&mut s, layer), ["Intro", "Added later"]);
+    let _ = std::fs::remove_dir_all(&dir);
+}
diff --git a/crates/interchange/src/export.rs b/crates/interchange/src/export.rs
index 7da18913a..375c1bf1b 100644
--- a/crates/interchange/src/export.rs
+++ b/crates/interchange/src/export.rs
@@ -138,7 +138,7 @@ fn unsupported(project: &Project, comp: &Comp, l: &Layer, format: TimelineFormat
     if l.is_3d() {
         return Some("3D layer".into());
     }
-    if l.props.sub("layerStyles").is_some_and(|g| !g.children.is_empty()) {
+    if l.styles_change_pixels() {
         return Some("layer styles".into());
     }
     if l.props.get("timeRemap").is_some_and(|p| p.is_animated()) {
@@ -155,12 +155,7 @@ fn unsupported(project: &Project, comp: &Comp, l: &Layer, format: TimelineFormat
         return Some(format!("blend mode {}", l.blend_mode.label()));
     }
     // Premiere's Basic Motion in the interchange formats has one (uniform) scale.
-    if let Some(s) = l.transform().and_then(|t| t.get("scale"))
-        && std::iter::once(&s.value).chain(s.keys.iter().map(|k| &k.value)).any(|v| {
-            let a = v.as_vec3();
-            (a[0] - a[1]).abs() > 1e-9
-        })
-    {
+    if l.transform().and_then(|t| t.get("scale")).is_some_and(non_uniform_scale) {
         return Some("non-uniform scale".into());
     }
     if l.preserve_transparency {
@@ -581,10 +576,7 @@ impl Exporter<'_> {
             }
         }
         if let Some(p) = tr.get("scale") {
-            let uniform = std::iter::once(&p.value).chain(p.keys.iter().map(|k| &k.value)).all(|v| {
-                let a = v.as_vec3();
-                (a[0] - a[1]).abs() < 1e-9
-            });
+            let uniform = !non_uniform_scale(p);
             m.params.insert("scale".into(), param_out(p, &to_clip, |v| fp::ParamValue::Float(v.as_vec3()[1])));
             if !uniform {
                 m.params.insert("scale_width".into(), param_out(p, &to_clip, |v| fp::ParamValue::Float(v.as_vec3()[0])));
@@ -636,6 +628,16 @@ fn differs(v: &Value, def: [f64; 2]) -> bool {
     (a[0] - def[0]).abs() > 1e-6 || (a[1] - def[1]).abs() > 1e-6
 }
 
+/// Whether a scale property is non-uniform at some point: active key values, or the static
+/// value when every key is muted (muted keys are not exported, #1894).
+fn non_uniform_scale(p: &Property) -> bool {
+    let non_uniform = |v: &Value| {
+        let a = v.as_vec3();
+        (a[0] - a[1]).abs() > 1e-9
+    };
+    if p.keys.iter().any(|k| !k.muted) { p.keys.iter().filter(|k| !k.muted).any(|k| non_uniform(&k.value)) } else { non_uniform(&p.value) }
+}
+
 /// The clip's `id` effect, or a new instance of it (None if the registry has no such effect).
 fn effect_or_new(ti: &fp::TrackItem, id: &str) -> Option<fp::EffectInstance> {
     ti.effect(id).cloned().or_else(|| fp::find_effect(id).map(|e| e.instance()))
@@ -651,7 +653,9 @@ fn set_effect(ti: &mut fp::TrackItem, e: fp::EffectInstance) {
 /// A property → a FilmCraft parameter (layer-time keys → clip-time keys).
 fn param_out(p: &Property, to_clip: &impl Fn(Tick) -> filmcraft_time::Tick, conv: impl Fn(&Value) -> fp::ParamValue) -> fp::Param {
     let mut out = fp::Param::new(conv(&p.value));
-    for k in &p.keys {
+    // XML timelines have no mute state: leave muted keys out, as the Lottie exporter does, so
+    // the exported animation matches what the renderer shows (#1894).
+    for k in p.keys.iter().filter(|k| !k.muted) {
         let mut fk = fp::Keyframe::new(to_clip(k.time), conv(&k.value));
         fk.interp = match k.out_interp {
             Interp::Linear => fp::Interpolation::Linear,
@@ -684,8 +688,12 @@ fn media_info(name: &str, kind: MediaKind, duration: Tick, video: Option<VideoSp
             color: Default::default(),
             has_alpha,
             bitrate: None,
+            hdr: None,
         }),
-        audio: audio.then(|| AudioStreamInfo { sample_rate: 48_000, channels: 2, codec: "pcm".into(), bits_per_sample: Some(16) }),
+        audio_streams: audio
+            .then(|| AudioStreamInfo { sample_rate: 48_000, channels: 2, codec: "pcm".into(), bits_per_sample: Some(16) })
+            .into_iter()
+            .collect(),
         container: String::new(),
         start_timecode: None,
         file_size: None,
diff --git a/crates/interchange/src/import.rs b/crates/interchange/src/import.rs
index 55161b718..28f638a90 100644
--- a/crates/interchange/src/import.rs
+++ b/crates/interchange/src/import.rs
@@ -143,6 +143,11 @@ pub fn import(
     if depth > MAX_DEPTH {
         return Err(Error::TooDeep(MAX_DEPTH));
     }
+    // FilmCraft's parser expands internal entities without a node limit (#2129); Final Cut Pro
+    // and FCPXML exports never declare any.
+    if matches!(format, TimelineFormat::Fcp7Xml | TimelineFormat::Fcpxml) && bytes.windows(8).any(|w| w == b"<!ENTITY") {
+        return Err(Error::XmlEntities);
+    }
     let fc_opts = filmcraft_interchange::ImportOptions {
         base_dir: opts.base_dir.clone(),
         edl_frame_rate: opts.edl_frame_rate.map(|f| {
@@ -271,7 +276,7 @@ impl Importer<'_> {
             MediaKind::AudioOnly => FootageKind::Audio,
             MediaKind::Still => FootageKind::Still,
             MediaKind::ImageSequence => FootageKind::Sequence,
-            _ if v.is_none() && info.audio.is_some() => FootageKind::Audio,
+            _ if v.is_none() && info.has_audio() => FootageKind::Audio,
             _ => FootageKind::Video,
         };
         let _ = name;
@@ -284,7 +289,7 @@ impl Importer<'_> {
             frame_rate: rate_in(info.frame_rate()),
             duration: tick_in(info.duration),
             has_video: kind != FootageKind::Audio,
-            has_audio: info.audio.is_some() || kind == FootageKind::Audio,
+            has_audio: info.has_audio() || kind == FootageKind::Audio,
             alpha: if v.is_some_and(|v| v.has_alpha) { AlphaMode::Straight } else { AlphaMode::Ignore },
             codec: v.map(|v| v.codec.clone()).unwrap_or_default(),
             missing: true,
diff --git a/crates/interchange/src/lib.rs b/crates/interchange/src/lib.rs
index 34d9aeab3..5b03403df 100644
--- a/crates/interchange/src/lib.rs
+++ b/crates/interchange/src/lib.rs
@@ -160,6 +160,8 @@ pub enum Error {
     NoComp(u64),
     #[error("the timeline document nests more than {0} levels deep")]
     TooDeep(usize),
+    #[error("the timeline document declares XML entities, which timeline files don't use and which can expand without bound")]
+    XmlEntities,
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
diff --git a/crates/interchange/src/tests.rs b/crates/interchange/src/tests.rs
index 3ad7fcaae..97efd76cd 100644
--- a/crates/interchange/src/tests.rs
+++ b/crates/interchange/src/tests.rs
@@ -36,8 +36,12 @@ fn info(kind: filmcraft_media::MediaKind, video: bool, audio: bool) -> filmcraft
             color: Default::default(),
             has_alpha: false,
             bitrate: None,
+            hdr: None,
         }),
-        audio: audio.then(|| filmcraft_media::AudioStreamInfo { sample_rate: 48_000, channels: 2, codec: "pcm".into(), bits_per_sample: Some(16) }),
+        audio_streams: audio
+            .then(|| filmcraft_media::AudioStreamInfo { sample_rate: 48_000, channels: 2, codec: "pcm".into(), bits_per_sample: Some(16) })
+            .into_iter()
+            .collect(),
         container: String::new(),
         start_timecode: None,
         file_size: None,
@@ -411,7 +415,7 @@ fn ae_project() -> (Project, ItemId) {
     let mut ls = effectcraft_project::build::layer(&mut p, &c, "tone", LayerSource::Footage { item: s }, (0, 0), None);
     ls.out_point = t(3.0);
     ls.props.prop_mut("audio/levels").unwrap().value = Value::Vec2([-3.0, -3.0]);
-    c.layers = vec![lt, lp, la, ls];
+    c.layers = vec![lt, lp, la, ls].into();
     let cid = comp_item(&mut p, "Main", c);
     (p, cid)
 }
@@ -429,6 +433,36 @@ fn plan_prerenders_rendered_only_layers() {
     assert!(plan_prerender(&p, cid, &ExportOptions { prerender: PrerenderMode::None, ..Default::default() }).is_empty());
 }
 
+/// A Layer Styles group that doesn't change the picture (Blending Options at their defaults, or
+/// every style switched off) keeps a clip a clip; Fill Opacity or a style that is on pre-renders it.
+#[test]
+fn only_layer_styles_that_change_pixels_prerender() {
+    use effectcraft_project::styles::{self as st, GROUP};
+    let opts = ExportOptions::default();
+    let reason = |edit: &dyn Fn(&mut Project, &mut Layer)| {
+        let (mut p, cid) = ae_project();
+        let c = p.comp(cid).unwrap();
+        let gl = c.global_light.clone();
+        let mut l = c.layers.iter().find(|l| l.name == "clip a").unwrap().clone();
+        st::add_blending_options(&mut l, &mut effectcraft_project::build::Ids(&mut p.next_id), &gl).unwrap();
+        edit(&mut p, &mut l);
+        let lid = l.id;
+        *p.comp_mut(cid).unwrap().layers.iter_mut().find(|x| x.id == lid).unwrap() = l;
+        prerender_reason(&p, cid, lid, &opts)
+    };
+    let fill = |l: &mut Layer, v: f64| l.props.prop_mut(&format!("{GROUP}/blendingOptions/advancedBlending/fillOpacity")).unwrap().value = Value::Scalar(v);
+    assert_eq!(reason(&|_, _| {}), None, "Blending Options at their defaults");
+    assert_eq!(reason(&|_, l| fill(l, 40.0)).as_deref(), Some("layer styles"));
+    let style = |on: bool| {
+        move |p: &mut Project, l: &mut Layer| {
+            let gl = effectcraft_project::styles::GlobalLight::default();
+            st::add_style(l, &mut effectcraft_project::build::Ids(&mut p.next_id), "dropShadow", &gl, on).unwrap();
+        }
+    };
+    assert_eq!(reason(&style(false)), None, "a style switched off");
+    assert_eq!(reason(&style(true)).as_deref(), Some("layer styles"));
+}
+
 #[test]
 fn export_then_reimport_keeps_the_timeline() {
     let (p, cid) = ae_project();
@@ -480,6 +514,59 @@ fn tr_orig(l: &Layer) -> &effectcraft_project::Property {
     l.transform().unwrap().get("position").unwrap()
 }
 
+/// #1894: XML timelines have no mute state, so a muted key must not be written as a keyframe
+/// (the export would otherwise animate through it).
+#[test]
+fn export_skips_muted_keyframes() {
+    let mut p = Project::default();
+    let a = footage_item(&mut p, "/media/a.mov");
+    let mut c = Comp::new(W, H, FrameRate::new(25, 1), t(4.0));
+    let mut l = effectcraft_project::build::layer(&mut p, &c, "clip", LayerSource::Footage { item: a }, (W, H), None);
+    {
+        let pos = l.transform_mut().unwrap().get_mut("position").unwrap();
+        pos.keys = vec![
+            Keyframe::new(t(0.0), Value::Vec3([100.0, 120.0, 0.0])),
+            Keyframe::new(t(1.0), Value::Vec3([500.0, 240.0, 0.0])),
+            Keyframe::new(t(2.0), Value::Vec3([300.0, 60.0, 0.0])),
+        ];
+        pos.keys[1].muted = true;
+    }
+    c.layers.push(l);
+    let cid = comp_item(&mut p, "Main", c);
+    let out = export(&p, cid, &ExportOptions { format: TimelineFormat::Fcp7Xml, ..Default::default() }, &HashMap::new()).unwrap();
+    let (q, r) = import_doc(&out.bytes, "Main.xml", &mut probe);
+    let main = r.comps.iter().copied().find(|c| q.item(*c).unwrap().name == "Main").expect("Main");
+    let pos = layer(q.comp(main).unwrap(), "clip").transform().unwrap().get("position").unwrap();
+    assert_eq!(pos.keys.len(), 2, "the muted key was exported");
+    assert_eq!(pos.keys[0].value.as_vec3()[0], 100.0);
+    assert_eq!(pos.keys[1].value.as_vec3()[0], 300.0);
+}
+
+/// #1894: a muted non-uniform scale key must not force a uniform layer to pre-render; only the
+/// active keys matter, and the static value when every key is muted.
+#[test]
+fn muted_non_uniform_scale_does_not_force_prerendering() {
+    let mut p = Project::default();
+    let a = footage_item(&mut p, "/media/a.mov");
+    let mut c = Comp::new(W, H, FrameRate::new(25, 1), t(2.0));
+    let mut l = effectcraft_project::build::layer(&mut p, &c, "clip", LayerSource::Footage { item: a }, (W, H), None);
+    {
+        let scale = l.transform_mut().unwrap().get_mut("scale").unwrap();
+        scale.keys = vec![Keyframe::new(t(0.0), Value::Vec3([100.0, 100.0, 100.0])), Keyframe::new(t(1.0), Value::Vec3([50.0, 200.0, 100.0]))];
+        scale.keys[1].muted = true;
+    }
+    let lid = l.id;
+    c.layers.push(l);
+    let cid = comp_item(&mut p, "Main", c);
+    assert_eq!(prerender_reason(&p, cid, lid, &ExportOptions::default()), None);
+    // With every key muted the static value drives evaluation, so a non-uniform static scale
+    // still takes the flattened path.
+    let scale = p.comp_mut(cid).unwrap().layer_mut(lid).unwrap().transform_mut().unwrap().get_mut("scale").unwrap();
+    scale.keys[0].muted = true;
+    scale.value = Value::Vec3([50.0, 200.0, 100.0]);
+    assert_eq!(prerender_reason(&p, cid, lid, &ExportOptions::default()).as_deref(), Some("non-uniform scale"));
+}
+
 #[test]
 fn export_without_prerender_leaves_text_out() {
     let (p, cid) = ae_project();
@@ -520,6 +607,21 @@ fn export_survives_a_precomp_layer_pointing_at_a_non_comp() {
     assert!(matches!(export(&p, footage, &ExportOptions::default(), &HashMap::new()), Err(Error::NoComp(_))));
 }
 
+#[test]
+fn xml_timelines_declaring_entities_are_refused() {
+    // #2129: the timeline parser expands internal entities without a node limit.
+    let dtd = "<!DOCTYPE x [<!ENTITY a \"aaaaaaaaaa\"><!ENTITY b \"&a;&a;&a;&a;&a;&a;&a;&a;&a;&a;\">]>";
+    let docs = [
+        (TimelineFormat::Fcp7Xml, format!("<?xml version=\"1.0\"?>{dtd}<xmeml version=\"5\">&b;</xmeml>")),
+        (TimelineFormat::Fcpxml, format!("<?xml version=\"1.0\"?>{dtd}<fcpxml version=\"1.9\">&b;</fcpxml>")),
+    ];
+    for (format, doc) in docs {
+        let mut p = Project::default();
+        let r = import(&mut p, doc.as_bytes(), Some(format), &ImportOptions::default(), &mut |_| None);
+        assert!(matches!(r, Err(Error::XmlEntities)), "{format:?}");
+    }
+}
+
 #[test]
 fn deeply_nested_documents_error_instead_of_overflowing_the_stack() {
     // A few hundred kilobytes nested 100 000 levels deep overflowed the parsers' stack.
diff --git a/crates/keyframe/src/lib.rs b/crates/keyframe/src/lib.rs
index 83774764d..abf929fe9 100644
--- a/crates/keyframe/src/lib.rs
+++ b/crates/keyframe/src/lib.rs
@@ -15,7 +15,8 @@ pub mod value;
 
 use effectcraft_time::{TICKS_PER_SECOND, Tick};
 use serde::{Deserialize, Serialize};
-pub use text_doc::{BaselineOption, CharStyle, Composer, Direction, FigureStyle, FigureWidth, Kerning, OpenType, ParaStyle, StyleRun};
+use std::borrow::Borrow;
+pub use text_doc::{BaselineOption, CharStyle, Composer, Direction, FigureStyle, FigureWidth, Kerning, LineJoin, OpenType, ParaStyle, StyleRun};
 pub use value::{FeatherPoint, Gradient, Justify, ShapePath, TextDoc, Value};
 
 /// Temporal interpolation on one side of a keyframe.
@@ -89,12 +90,19 @@ pub struct Keyframe {
     /// Keyframe color label: index into the label list (0 = None).
     #[serde(default, skip_serializing_if = "is_zero")]
     pub label: u8,
+    /// Muted keys stay in the list (and the UI) but evaluation skips them.
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub muted: bool,
 }
 
 fn is_zero(v: &u8) -> bool {
     *v == 0
 }
 
+fn is_false(v: &bool) -> bool {
+    !*v
+}
+
 fn yes() -> bool {
     true
 }
@@ -116,6 +124,7 @@ impl Keyframe {
             spatial_continuous: false,
             roving: false,
             label: 0,
+            muted: false,
         }
     }
     pub fn hold(mut self) -> Keyframe {
@@ -320,16 +329,16 @@ fn v3(v: &Value) -> [f64; 3] {
 /// tangent is a sixth of the way from the previous key to the next, the in tangent its mirror, and
 /// key times play no part. An end key uses its one neighbour, so the path leaves the first key
 /// and enters the last one toward the neighbouring key instead of with no tangent.
-fn auto_spatial(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
+fn auto_spatial<K: Borrow<Keyframe>>(keys: &[K], i: usize) -> ([f64; 3], [f64; 3]) {
     if i >= keys.len() || keys.len() < 2 {
         return ([0.0; 3], [0.0; 3]);
     }
-    let a = v3(&keys[i.saturating_sub(1)].value);
-    let c = v3(&keys[(i + 1).min(keys.len() - 1)].value);
+    let a = v3(&keys[i.saturating_sub(1)].borrow().value);
+    let c = v3(&keys[(i + 1).min(keys.len() - 1)].borrow().value);
     let tout = [(c[0] - a[0]) / 6.0, (c[1] - a[1]) / 6.0, (c[2] - a[2]) / 6.0];
     // A side facing a key at the same position gets no tangent, so the segment between two
     // identical keys has zero length and the layer holds still (#1675).
-    let p = v3(&keys[i].value);
+    let p = v3(&keys[i].borrow().value);
     let tin = if i > 0 && a == p { [0.0; 3] } else { [-tout[0], -tout[1], -tout[2]] };
     let tout = if i + 1 < keys.len() && c == p { [0.0; 3] } else { tout };
     (tin, tout)
@@ -337,7 +346,12 @@ fn auto_spatial(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
 
 /// Effective spatial tangents of key `i` (auto or stored).
 pub fn spatial_tangents(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
-    let Some(key) = keys.get(i) else { return ([0.0; 3], [0.0; 3]) };
+    tangents_of(keys, i)
+}
+
+/// [`spatial_tangents`] over stored keys or a filtered list of them (see [`evaluate`]).
+fn tangents_of<K: Borrow<Keyframe>>(keys: &[K], i: usize) -> ([f64; 3], [f64; 3]) {
+    let Some(key) = keys.get(i).map(Borrow::borrow) else { return ([0.0; 3], [0.0; 3]) };
     if key.spatial_auto { auto_spatial(keys, i) } else { (key.spatial_in, key.spatial_out) }
 }
 
@@ -373,18 +387,18 @@ pub fn spatial_handles(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
 }
 
 /// Effective temporal ease of key `i` for dimension `d` (auto-Bezier keys get the neighbour slope).
-fn effective_ease(keys: &[Keyframe], i: usize, d: usize, spatial: bool, out: bool) -> Ease {
-    let k = &keys[i];
+fn effective_ease<K: Borrow<Keyframe>>(keys: &[K], i: usize, d: usize, spatial: bool, out: bool) -> Ease {
+    let k = keys[i].borrow();
     let list = if out { &k.out_ease } else { &k.in_ease };
     if k.auto_bezier && i > 0 && i + 1 < keys.len() {
-        let dt = secs(keys[i + 1].time) - secs(keys[i - 1].time);
+        let dt = secs(keys[i + 1].borrow().time) - secs(keys[i - 1].borrow().time);
         let slope = if spatial {
-            let a = v3(&keys[i - 1].value);
-            let c = v3(&keys[i + 1].value);
+            let a = v3(&keys[i - 1].borrow().value);
+            let c = v3(&keys[i + 1].borrow().value);
             ((c[0] - a[0]).powi(2) + (c[1] - a[1]).powi(2) + (c[2] - a[2]).powi(2)).sqrt() / dt.max(1e-12)
         } else {
-            let a = keys[i - 1].value.components();
-            let c = keys[i + 1].value.components();
+            let a = keys[i - 1].borrow().value.components();
+            let c = keys[i + 1].borrow().value.components();
             (c.get(d).unwrap_or(&0.0) - a.get(d).unwrap_or(&0.0)) / dt.max(1e-12)
         };
         return Ease { speed: slope, influence: 1.0 / 6.0 };
@@ -508,23 +522,39 @@ pub fn time_reverse(keys: &mut [Keyframe]) {
 }
 
 /// Evaluate a keyframed property at `t`. `spatial` selects motion-path semantics for 2D/3D values.
+/// Muted keys are skipped, so the active neighbours interpolate as if they were not there; `None`
+/// means every key is muted (the property's static value applies).
 pub fn evaluate(keys: &[Keyframe], t: Tick, spatial: bool) -> Option<Value> {
-    let first = keys.first()?;
+    if !keys.iter().any(|k| k.muted) {
+        return evaluate_active(keys, t, spatial);
+    }
+    // Muting is rare: skip the muted keys by reference rather than copying every key and value.
+    let active: Vec<&Keyframe> = keys.iter().filter(|k| !k.muted).collect();
+    evaluate_active(&active, t, spatial)
+}
+
+fn evaluate_active<K: Borrow<Keyframe>>(keys: &[K], t: Tick, spatial: bool) -> Option<Value> {
+    let first = keys.first()?.borrow();
     if keys.len() == 1 || t <= first.time {
         return Some(first.value.clone());
     }
-    let last = keys.last()?;
+    let last = keys.last()?.borrow();
     if t >= last.time {
         return Some(last.value.clone());
     }
-    let i = keys.partition_point(|k| k.time <= t) - 1;
-    Some(segment_value(keys, i, t, spatial))
+    let i = keys.partition_point(|k| k.borrow().time <= t) - 1;
+    Some(segment_value_of(keys, i, t, spatial))
 }
 
 /// Value inside segment `i` → `i+1` at time `t`.
 pub fn segment_value(keys: &[Keyframe], i: usize, t: Tick, spatial: bool) -> Value {
-    let a = &keys[i];
-    let b = &keys[i + 1];
+    segment_value_of(keys, i, t, spatial)
+}
+
+/// [`segment_value`] over stored keys or a filtered list of them (see [`evaluate`]).
+fn segment_value_of<K: Borrow<Keyframe>>(keys: &[K], i: usize, t: Tick, spatial: bool) -> Value {
+    let a = keys[i].borrow();
+    let b = keys[i + 1].borrow();
     if a.out_interp == Interp::Hold || !a.value.interpolates() {
         return a.value.clone();
     }
@@ -539,8 +569,8 @@ pub fn segment_value(keys: &[Keyframe], i: usize, t: Tick, spatial: bool) -> Val
     if is_spatial {
         let p0 = v3(&a.value);
         let p3 = v3(&b.value);
-        let (_, out_t) = spatial_tangents(keys, i);
-        let (in_t, _) = spatial_tangents(keys, i + 1);
+        let (_, out_t) = tangents_of(keys, i);
+        let (in_t, _) = tangents_of(keys, i + 1);
         let seg = SpatialSeg::new([p0, [p0[0] + out_t[0], p0[1] + out_t[1], p0[2] + out_t[2]], [p3[0] + in_t[0], p3[1] + in_t[1], p3[2] + in_t[2]], p3]);
         let len = seg.length();
         let f = if lin_out && lin_in || len <= 1e-12 {
@@ -617,6 +647,7 @@ pub fn set_key(keys: &mut Vec<Keyframe>, key: Keyframe) -> usize {
             k.spatial_continuous = old.spatial_continuous;
             k.roving = old.roving;
             k.label = old.label;
+            k.muted = old.muted;
             keys[i] = k;
             i
         }
@@ -647,402 +678,4 @@ pub fn easy_ease(k: &mut Keyframe, ease_in: bool, ease_out: bool) {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn s(x: f64) -> Tick {
-        Tick::from_seconds_f64(x)
-    }
-
-    #[test]
-    fn missing_spatial_keys_have_no_tangents_or_length() {
-        let keys = vec![Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0]))];
-        for i in [1, usize::MAX] {
-            assert_eq!(spatial_tangents(&keys, i), ([0.0; 3], [0.0; 3]));
-            assert_eq!(spatial_segment_length(&keys, i), 0.0);
-        }
-        assert_eq!(spatial_tangents(&[], 0), ([0.0; 3], [0.0; 3]));
-        assert_eq!(spatial_segment_length(&[], usize::MAX), 0.0);
-    }
-
-    #[test]
-    fn time_reverse_handles_deserialized_tick_extremes() {
-        // Tick's public serde representation can contain values beyond from_seconds_f64's cap.
-        for (first, last) in [(i64::MIN, i64::MIN + 10), (i64::MAX - 10, i64::MAX), (i64::MIN, i64::MAX)] {
-            let mut keys = vec![Keyframe::new(Tick(first), Value::Scalar(1.0)), Keyframe::new(Tick(last), Value::Scalar(2.0))];
-            time_reverse(&mut keys);
-            assert_eq!(keys[0].time, Tick(first));
-            assert_eq!(keys[0].value, Value::Scalar(2.0));
-            assert_eq!(keys[1].time, Tick(last));
-            assert_eq!(keys[1].value, Value::Scalar(1.0));
-            time_reverse(&mut keys);
-            assert_eq!(keys[0].value, Value::Scalar(1.0));
-        }
-    }
-
-    #[test]
-    fn roving_handles_deserialized_tick_extremes() {
-        let mut keys = vec![
-            Keyframe::new(Tick(i64::MIN), Value::Vec2([0.0, 0.0])),
-            Keyframe::new(Tick(10), Value::Vec2([50.0, 0.0])),
-            Keyframe::new(Tick(i64::MAX), Value::Vec2([100.0, 0.0])),
-        ];
-        for key in &mut keys {
-            key.spatial_auto = false;
-        }
-        keys[1].roving = true;
-        assert!(retime_roving(&mut keys, true));
-        assert_eq!(keys[1].time, Tick::ZERO);
-    }
-
-    #[test]
-    fn replacing_key_preserves_spatial_metadata() {
-        let mut key = Keyframe::new(s(1.0), Value::Vec2([20.0, 30.0]));
-        key.roving = true;
-        key.spatial_continuous = true;
-        let mut keys = vec![key];
-        set_key(&mut keys, Keyframe::new(s(1.0), Value::Vec2([40.0, 50.0])));
-        assert!(keys[0].roving);
-        assert!(keys[0].spatial_continuous);
-        assert_eq!(keys[0].value, Value::Vec2([40.0, 50.0]));
-    }
-
-    #[test]
-    fn temporal_ease_matches_live_ae_with_overlapping_influences() {
-        // Original Rotation probe via AEsync 2.0.4, AE 26.3x87, 2026-10-05.
-        // AE retains each handle's requested influence even when their sum exceeds 100%.
-        for (from, to, out_speed, out_inf, in_speed, in_inf, samples) in [
-            (0.0, 100.0, 0.0, 0.8, 0.0, 0.8, [(0.1, 0.59243939036327), (0.25, 4.76438030608764), (0.4, 18.4284394271562), (0.75, 95.2356196939123)]),
-            (0.0, 100.0, 20.0, 0.8, 80.0, 0.6, [(0.1, 2.25754942621577), (0.25, 6.99841889412931), (0.4, 14.9334636959052), (0.75, 73.8196785378389)]),
-            (100.0, 0.0, -20.0, 0.6, -80.0, 0.8, [(0.1, 97.6395466334594), (0.25, 91.597048571292), (0.4, 74.5367957474338), (0.75, 22.3789127753126)]),
-        ] {
-            let mut a = Keyframe::new(s(0.0), Value::Scalar(from));
-            let mut b = Keyframe::new(s(1.0), Value::Scalar(to));
-            a.out_interp = Interp::Bezier;
-            b.in_interp = Interp::Bezier;
-            a.out_ease = vec![Ease { speed: out_speed, influence: out_inf }];
-            b.in_ease = vec![Ease { speed: in_speed, influence: in_inf }];
-            for (time, expected) in samples {
-                let value = evaluate(&[a.clone(), b.clone()], s(time), false).unwrap().as_f64();
-                assert!((value - expected).abs() < 1e-7, "{time}: {value} != {expected}");
-                let normalized = ease_progress(out_speed / (to - from), out_inf, in_speed / (to - from), in_inf, time);
-                assert!((from + normalized * (to - from) - expected).abs() < 1e-7);
-            }
-        }
-    }
-
-    #[test]
-    fn maximum_influence_resolves_flat_midpoint_time_curve() {
-        for time in [0.5 - 1e-9, 0.5 - 1e-12, 0.5, 0.5 + 1e-12, 0.5 + 1e-9] {
-            // At 100%/100%, x = 0.5 + 4*(u - 0.5)^3 exactly.
-            let u = 0.5 + ((time - 0.5) / 4.0_f64).cbrt();
-            let expected = bez(0.0, 0.0, 1.0, 1.0, u);
-            let actual = ease_progress(0.0, 1.0, 0.0, 1.0, time);
-            assert!((actual - expected).abs() < 1e-10, "{time}: {actual} != {expected}");
-        }
-    }
-
-    /// M13.15: agents set gradients as plain JSON, not only the tagged form `get` returns.
-    #[test]
-    fn gradients_coerce_from_plain_json() {
-        let g = Value::Gradient(Gradient::default());
-        let plain = serde_json::json!({"colors": [[0, [0, 0.5, 1, 1]], [1, "#ffff00"]], "opacities": [[0, 1], [1, 0.5]]});
-        let Some(Value::Gradient(a)) = g.coerce_json(&plain) else { panic!("object form") };
-        assert_eq!(a.colors, vec![(0.0, [0.0, 0.5, 1.0, 1.0]), (1.0, [1.0, 1.0, 0.0, 1.0])]);
-        assert_eq!(a.opacities, vec![(0.0, 1.0), (1.0, 0.5)]);
-        let Some(Value::Gradient(b)) = g.coerce_json(&serde_json::json!(["#ff0000", "#00ff00", "#0000ff"])) else { panic!("list form") };
-        assert_eq!(b.colors.iter().map(|c| c.0).collect::<Vec<_>>(), vec![0.0, 0.5, 1.0]);
-        assert_eq!(b.opacities.len(), 3);
-        // The tagged form (what prop.get returns) still round-trips.
-        assert_eq!(g.coerce_json(&g.to_json()), Some(g.clone()));
-        assert_eq!(g.coerce_json(&serde_json::json!(5)), None);
-    }
-
-    /// #612: the gradient editor samples a new stop from its own track only. `sample` multiplies
-    /// in the opacity stops, so feeding its alpha into a colour stop would apply 50% twice (25%).
-    #[test]
-    fn gradient_tracks_sample_separately() {
-        let g = Gradient { colors: vec![(0.0, [1.0, 0.0, 0.0, 0.8]), (1.0, [0.0, 0.0, 1.0, 0.4])], opacities: vec![(0.0, 0.5), (1.0, 0.5)] };
-        let c = g.color_at(0.5);
-        assert!((c[0] - 0.5).abs() < 1e-6 && (c[2] - 0.5).abs() < 1e-6, "{c:?}");
-        assert!((c[3] - 0.6).abs() < 1e-6, "the colour track's own alpha, without opacity: {c:?}");
-        assert!((g.opacity_at(0.5) - 0.5).abs() < 1e-6);
-        assert!((g.sample(0.5)[3] - 0.3).abs() < 1e-6, "sample still applies opacity once");
-        // A stop added at 50% from the opacity track keeps 50%: sampled again, it is still 50%.
-        let mut with_stop = g.clone();
-        with_stop.opacities.insert(1, (0.5, g.opacity_at(0.5)));
-        assert!((with_stop.opacity_at(0.5) - 0.5).abs() < 1e-6);
-        assert!((with_stop.sample(0.5)[3] - 0.3).abs() < 1e-6, "adding a stop doesn't change the look");
-        // Outside the stops, and with none: the ends hold, and an empty track is opaque white.
-        assert_eq!(g.color_at(-1.0), [1.0, 0.0, 0.0, 0.8]);
-        assert_eq!(g.color_at(2.0), [0.0, 0.0, 1.0, 0.4]);
-        let empty = Gradient { colors: vec![], opacities: vec![] };
-        assert_eq!((empty.color_at(0.3), empty.opacity_at(0.3)), ([1.0; 4], 1.0));
-    }
-
-    /// #612: the editor saves the typed form, so one colour stop (which the plain JSON parser
-    /// rejects) and each stop's RGBA come back exactly.
-    #[test]
-    fn typed_gradient_round_trips_one_stop_and_rgba() {
-        let one = Value::Gradient(Gradient { colors: vec![(0.25, [0.1, 0.2, 0.3, 0.7])], opacities: vec![(0.0, 1.0), (0.6, 0.35)] });
-        let cur = Value::Gradient(Gradient::default());
-        assert_eq!(cur.coerce_json(&one.to_json()), Some(one.clone()));
-        assert_eq!(cur.coerce_json(&serde_json::json!({"colors": [[0.25, [0.1, 0.2, 0.3, 0.7]]]})), None, "plain JSON needs two colours");
-    }
-
-    #[test]
-    fn linear_and_hold() {
-        let keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), Keyframe::new(s(2.0), Value::Scalar(100.0))];
-        assert_eq!(evaluate(&keys, s(1.0), false), Some(Value::Scalar(50.0)));
-        assert_eq!(evaluate(&keys, s(-1.0), false), Some(Value::Scalar(0.0)));
-        assert_eq!(evaluate(&keys, s(3.0), false), Some(Value::Scalar(100.0)));
-        let held = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)).hold(), Keyframe::new(s(2.0), Value::Scalar(100.0))];
-        assert_eq!(evaluate(&held, s(1.999), false), Some(Value::Scalar(0.0)));
-    }
-
-    #[test]
-    fn hold_key_keeps_its_incoming_segment_linear() {
-        // Hold on the second key (in and out, as KeyframeInterpolationType.HOLD sets it) holds
-        // what comes after it, not the linear motion into it.
-        let keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), Keyframe::new(s(2.0), Value::Scalar(100.0)).hold()];
-        assert_eq!(evaluate(&keys, s(0.5), false), Some(Value::Scalar(25.0)));
-        let keys = vec![Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])), Keyframe::new(s(2.0), Value::Vec2([100.0, 0.0])).hold()];
-        let p = evaluate(&keys, s(0.5), true).unwrap().as_vec2();
-        assert!((p[0] - 25.0).abs() < 0.01, "{p:?}");
-    }
-
-    #[test]
-    fn easy_ease_is_symmetric_and_slow_at_ends() {
-        let keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)).eased(), Keyframe::new(s(1.0), Value::Scalar(100.0)).eased()];
-        let mid = evaluate(&keys, s(0.5), false).unwrap().as_f64();
-        assert!((mid - 50.0).abs() < 1e-6, "{mid}");
-        let early = evaluate(&keys, s(0.1), false).unwrap().as_f64();
-        assert!(early < 10.0 && early > 0.0, "{early}");
-        let v0 = velocity(&keys, s(0.01), false)[0];
-        let vm = velocity(&keys, s(0.5), false)[0];
-        assert!(v0 < vm);
-    }
-
-    #[test]
-    fn bezier_with_linear_speed_matches_linear() {
-        let mut a = Keyframe::new(s(0.0), Value::Scalar(0.0));
-        let mut b = Keyframe::new(s(2.0), Value::Scalar(100.0));
-        a.out_interp = Interp::Bezier;
-        b.in_interp = Interp::Bezier;
-        a.out_ease = vec![Ease { speed: 50.0, influence: 1.0 / 3.0 }];
-        b.in_ease = vec![Ease { speed: 50.0, influence: 1.0 / 3.0 }];
-        let keys = vec![a, b];
-        for i in 0..=20 {
-            let t = i as f64 * 0.1;
-            let v = evaluate(&keys, s(t), false).unwrap().as_f64();
-            assert!((v - 50.0 * t).abs() < 1e-6, "{t} {v}");
-        }
-    }
-
-    #[test]
-    fn spatial_linear_constant_speed() {
-        let keys = vec![Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])), Keyframe::new(s(1.0), Value::Vec2([300.0, 400.0]))];
-        let p = evaluate(&keys, s(0.5), true).unwrap().as_vec2();
-        assert!((p[0] - 150.0).abs() < 0.5 && (p[1] - 200.0).abs() < 0.5, "{p:?}");
-    }
-
-    /// #456: along a curved spatial path with linear (constant-speed) keys the speed graph is
-    /// flat, not a sawtooth from a piecewise-linear arc-length table.
-    #[test]
-    fn spatial_curved_path_has_smooth_constant_speed() {
-        let mut a = Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0]));
-        let mut b = Keyframe::new(s(2.0), Value::Vec2([400.0, 0.0]));
-        a.spatial_auto = false;
-        b.spatial_auto = false;
-        a.spatial_out = [50.0, -300.0, 0.0];
-        b.spatial_in = [80.0, 250.0, 0.0];
-        let keys = vec![a, b];
-        let len = spatial_segment_length(&keys, 0);
-        let speeds: Vec<f64> = (1..400).map(|i| speed(&keys, s(i as f64 * 0.005), true)).collect();
-        for v in &speeds {
-            assert!((v - len / 2.0).abs() < 1e-3 * len, "speed {v} vs {}", len / 2.0);
-        }
-    }
-
-    #[test]
-    fn spatial_auto_bezier_passes_through_keys() {
-        let keys = vec![
-            Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])),
-            Keyframe::new(s(1.0), Value::Vec2([100.0, 100.0])),
-            Keyframe::new(s(2.0), Value::Vec2([200.0, 0.0])),
-        ];
-        let p = evaluate(&keys, s(1.0), true).unwrap().as_vec2();
-        assert_eq!(p, [100.0, 100.0]);
-        // Curved: the midpoint of the first segment lies off the straight line.
-        let m = evaluate(&keys, s(0.5), true).unwrap().as_vec2();
-        assert!((m[0] - m[1]).abs() > 1.0, "{m:?}");
-    }
-
-    #[test]
-    fn straight_auto_bezier_path_is_exact() {
-        // Auto-Bezier ends now have handles along the line; the chord is still hit exactly.
-        let keys = vec![Keyframe::new(s(0.0), Value::Vec2([40.0, 50.0])), Keyframe::new(s(2.0), Value::Vec2([120.0, 50.0]))];
-        assert_eq!(segment_value(&keys, 0, s(1.0), true), Value::Vec2([80.0, 50.0]));
-    }
-
-    /// #880: a motion path whose arc length overflows (huge coordinates, as the Position field
-    /// accepts) or is NaN evaluates without panicking: scrubbing over it crashed the app.
-    #[test]
-    fn overflowing_or_nan_motion_paths_evaluate() {
-        let paths = [
-            [[-1.7e308, 0.0], [1.7e308, 0.0], [-1.7e308, 5.0]],
-            [[0.0, 0.0], [f64::NAN, 10.0], [20.0, 0.0]],
-            [[f64::INFINITY, 0.0], [0.0, f64::NEG_INFINITY], [20.0, 0.0]],
-        ];
-        for path in paths {
-            let mut keys: Vec<Keyframe> = path.iter().enumerate().map(|(i, &v)| Keyframe::new(s(i as f64 * 2.0), Value::Vec2(v))).collect();
-            for eased in [false, true] {
-                if eased {
-                    keys = keys.into_iter().map(Keyframe::eased).collect();
-                }
-                for f in 0..=40 {
-                    let t = s(f as f64 * 0.1);
-                    assert!(evaluate(&keys, t, true).is_some());
-                    let _ = speed(&keys, t, true);
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn spatial_auto_bezier_tangents_follow_after_effects() {
-        // Measured on After Effects 26.3 with original paths (docs/fidelity/README.md): each
-        // auto-Bezier key's out tangent is (next - previous) / 6 and its in tangent the mirror,
-        // whatever the key times. End keys use their one neighbour: (neighbour - key) / 6.
-        let p = [[40.0, 300.0, 0.0], [260.0, 80.0, 20.0], [700.0, 420.0, -40.0], [1100.0, 150.0, 0.0]];
-        let mut keys: Vec<Keyframe> = [0.0, 0.2, 1.5, 1.8].iter().zip(p).map(|(&t, v)| Keyframe::new(s(t), Value::Vec3(v))).collect();
-        let sixth = |a: [f64; 3], b: [f64; 3]| [(b[0] - a[0]) / 6.0, (b[1] - a[1]) / 6.0, (b[2] - a[2]) / 6.0];
-        let neg = |v: [f64; 3]| [-v[0], -v[1], -v[2]];
-        let close = |a: [f64; 3], b: [f64; 3]| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-9);
-        let want = [sixth(p[0], p[1]), sixth(p[0], p[2]), sixth(p[1], p[3]), sixth(p[2], p[3])];
-        for (i, out) in want.into_iter().enumerate() {
-            let (tin, tout) = spatial_tangents(&keys, i);
-            assert!(close(tout, out) && close(tin, neg(out)), "key {i}: {tin:?} {tout:?}");
-        }
-        // Moving a key in time leaves every tangent as it was.
-        keys[1].time = s(1.2);
-        assert!(close(spatial_tangents(&keys, 1).1, sixth(p[0], p[2])));
-        // A key between two coincident neighbours, and a lone key, have none.
-        let still = [[5.0, 5.0], [9.0, 1.0], [5.0, 5.0]].iter().enumerate().map(|(i, &v)| Keyframe::new(s(i as f64), Value::Vec2(v))).collect::<Vec<_>>();
-        assert_eq!(spatial_tangents(&still, 1), ([0.0; 3], [0.0; 3]));
-        assert_eq!(spatial_tangents(&still[..1], 0), ([0.0; 3], [0.0; 3]));
-    }
-
-    #[test]
-    fn auto_spatial_holds_between_identical_keys() {
-        let path = [(0.0, [0.0, 540.0]), (0.6, [400.0, 540.0]), (4.4, [400.0, 540.0]), (5.0, [0.0, 540.0])];
-        for eased in [false, true] {
-            let keys: Vec<Keyframe> = path
-                .iter()
-                .map(|&(t, v)| {
-                    let k = Keyframe::new(s(t), Value::Vec2(v));
-                    if eased { k.eased() } else { k }
-                })
-                .collect();
-            assert_eq!(spatial_tangents(&keys, 1).1, [0.0; 3]);
-            assert_eq!(spatial_tangents(&keys, 2).0, [0.0; 3]);
-            for t in [0.7, 1.0, 2.5, 4.0, 4.3] {
-                let p = evaluate(&keys, s(t), true).unwrap().as_vec3();
-                assert!((p[0] - 400.0).abs() < 1e-6 && (p[1] - 540.0).abs() < 1e-6, "eased={eased} t={t} p={p:?}");
-            }
-        }
-    }
-
-    #[test]
-    fn set_key_replaces_same_time() {
-        let mut keys = vec![];
-        set_key(&mut keys, Keyframe::new(s(1.0), Value::Scalar(1.0)).eased());
-        set_key(&mut keys, Keyframe::new(s(0.0), Value::Scalar(0.0)));
-        set_key(&mut keys, Keyframe::new(s(1.0), Value::Scalar(5.0)));
-        assert_eq!(keys.len(), 2);
-        assert_eq!(keys[1].value, Value::Scalar(5.0));
-        assert_eq!(keys[1].in_interp, Interp::Bezier);
-    }
-
-    #[test]
-    fn colors_and_paths_interpolate() {
-        let keys = vec![Keyframe::new(s(0.0), Value::Color([0.0, 0.0, 0.0, 1.0])), Keyframe::new(s(1.0), Value::Color([1.0, 0.5, 0.0, 1.0]))];
-        assert_eq!(evaluate(&keys, s(0.5), false).unwrap().as_color(), [0.5, 0.25, 0.0, 1.0]);
-        let a = ShapePath::rect([0.0, 0.0], 10.0, 10.0);
-        let b = ShapePath::rect([0.0, 0.0], 20.0, 20.0);
-        let keys = vec![Keyframe::new(s(0.0), Value::Path(a)), Keyframe::new(s(1.0), Value::Path(b))];
-        let v = evaluate(&keys, s(0.5), false).unwrap();
-        assert_eq!(v.as_path().unwrap().vertices[0], [-7.5, -7.5]);
-    }
-
-    #[test]
-    fn roving_keys_get_constant_speed_times() {
-        let mut keys = vec![
-            Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])),
-            Keyframe::new(s(0.2), Value::Vec2([300.0, 0.0])),
-            Keyframe::new(s(2.0), Value::Vec2([400.0, 0.0])),
-        ];
-        for k in &mut keys {
-            k.spatial_auto = false;
-        }
-        keys[1].roving = true;
-        assert!(retime_roving(&mut keys, true));
-        // 300 of 400 px → 75 % of the 2 s span.
-        assert!((keys[1].time.seconds() - 1.5).abs() < 1e-6, "{}", keys[1].time.seconds());
-        let v0 = speed(&keys, s(0.5), true);
-        let v1 = speed(&keys, s(1.8), true);
-        assert!((v0 - 200.0).abs() < 1.0 && (v1 - 200.0).abs() < 1.0, "{v0} {v1}");
-        // First/last keys can't rove.
-        keys[0].roving = true;
-        retime_roving(&mut keys, true);
-        assert!(!keys[0].roving);
-    }
-
-    #[test]
-    fn roving_keys_never_share_a_time_with_a_fixed_key() {
-        // Zero-length last segment (issue #532) and zero-length first segment.
-        for xs in [[0.0, 40.0, 120.0, 120.0], [0.0, 0.0, 40.0, 120.0]] {
-            let mut keys: Vec<Keyframe> = xs.iter().enumerate().map(|(i, x)| Keyframe::new(s(i as f64), Value::Vec2([*x, 64.0]))).collect();
-            for k in &mut keys {
-                k.spatial_auto = false;
-            }
-            keys[1].roving = true;
-            keys[2].roving = true;
-            retime_roving(&mut keys, true);
-            assert!(keys.windows(2).all(|w| w[0].time < w[1].time), "{xs:?}: {:?}", keys.iter().map(|k| k.time).collect::<Vec<_>>());
-        }
-    }
-
-    #[test]
-    fn side_ease_reports_linear_and_eased_sides() {
-        let keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), Keyframe::new(s(2.0), Value::Scalar(100.0)).eased()];
-        let out = side_ease(&keys, 0, 0, false, true).unwrap();
-        assert!((out.speed - 50.0).abs() < 1e-9);
-        let inn = side_ease(&keys, 1, 0, false, false).unwrap();
-        assert_eq!(inn, Ease::EASY);
-        assert!(side_ease(&keys, 0, 0, false, false).is_none());
-    }
-
-    #[test]
-    fn time_reverse_mirrors_keys() {
-        let mut keys =
-            vec![Keyframe::new(s(1.0), Value::Scalar(0.0)).eased(), Keyframe::new(s(2.0), Value::Scalar(5.0)), Keyframe::new(s(4.0), Value::Scalar(10.0))];
-        keys[0].out_interp = Interp::Hold;
-        time_reverse(&mut keys);
-        assert_eq!(keys.iter().map(|k| k.time.seconds().round() as i64).collect::<Vec<_>>(), vec![1, 3, 4]);
-        assert_eq!(keys[0].value, Value::Scalar(10.0));
-        assert_eq!(keys[2].in_interp, Interp::Hold);
-    }
-
-    proptest::proptest! {
-        #[test]
-        fn eased_values_stay_in_range(t in 0.0f64..1.0, i0 in 0.01f64..1.0, i1 in 0.01f64..1.0) {
-            let mut a = Keyframe::new(s(0.0), Value::Scalar(0.0)).eased();
-            let mut b = Keyframe::new(s(1.0), Value::Scalar(10.0)).eased();
-            a.out_ease = vec![Ease { speed: 0.0, influence: i0 }];
-            b.in_ease = vec![Ease { speed: 0.0, influence: i1 }];
-            let v = evaluate(&[a, b], s(t), false).unwrap().as_f64();
-            proptest::prop_assert!((-1e-9..=10.0 + 1e-9).contains(&v));
-        }
-    }
-}
+mod tests;
diff --git a/crates/keyframe/src/tests.rs b/crates/keyframe/src/tests.rs
new file mode 100644
index 000000000..312703239
--- /dev/null
+++ b/crates/keyframe/src/tests.rs
@@ -0,0 +1,453 @@
+use super::*;
+
+fn s(x: f64) -> Tick {
+    Tick::from_seconds_f64(x)
+}
+
+#[test]
+fn missing_spatial_keys_have_no_tangents_or_length() {
+    let keys = vec![Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0]))];
+    for i in [1, usize::MAX] {
+        assert_eq!(spatial_tangents(&keys, i), ([0.0; 3], [0.0; 3]));
+        assert_eq!(spatial_segment_length(&keys, i), 0.0);
+    }
+    assert_eq!(spatial_tangents(&[], 0), ([0.0; 3], [0.0; 3]));
+    assert_eq!(spatial_segment_length(&[], usize::MAX), 0.0);
+}
+
+#[test]
+fn time_reverse_handles_deserialized_tick_extremes() {
+    // Tick's public serde representation can contain values beyond from_seconds_f64's cap.
+    for (first, last) in [(i64::MIN, i64::MIN + 10), (i64::MAX - 10, i64::MAX), (i64::MIN, i64::MAX)] {
+        let mut keys = vec![Keyframe::new(Tick(first), Value::Scalar(1.0)), Keyframe::new(Tick(last), Value::Scalar(2.0))];
+        time_reverse(&mut keys);
+        assert_eq!(keys[0].time, Tick(first));
+        assert_eq!(keys[0].value, Value::Scalar(2.0));
+        assert_eq!(keys[1].time, Tick(last));
+        assert_eq!(keys[1].value, Value::Scalar(1.0));
+        time_reverse(&mut keys);
+        assert_eq!(keys[0].value, Value::Scalar(1.0));
+    }
+}
+
+#[test]
+fn roving_handles_deserialized_tick_extremes() {
+    let mut keys = vec![
+        Keyframe::new(Tick(i64::MIN), Value::Vec2([0.0, 0.0])),
+        Keyframe::new(Tick(10), Value::Vec2([50.0, 0.0])),
+        Keyframe::new(Tick(i64::MAX), Value::Vec2([100.0, 0.0])),
+    ];
+    for key in &mut keys {
+        key.spatial_auto = false;
+    }
+    keys[1].roving = true;
+    assert!(retime_roving(&mut keys, true));
+    assert_eq!(keys[1].time, Tick::ZERO);
+}
+
+#[test]
+fn replacing_key_preserves_spatial_metadata() {
+    let mut key = Keyframe::new(s(1.0), Value::Vec2([20.0, 30.0]));
+    key.roving = true;
+    key.spatial_continuous = true;
+    let mut keys = vec![key];
+    set_key(&mut keys, Keyframe::new(s(1.0), Value::Vec2([40.0, 50.0])));
+    assert!(keys[0].roving);
+    assert!(keys[0].spatial_continuous);
+    assert_eq!(keys[0].value, Value::Vec2([40.0, 50.0]));
+}
+
+#[test]
+fn temporal_ease_matches_live_ae_with_overlapping_influences() {
+    // Original Rotation probe via AEsync 2.0.4, AE 26.3x87, 2026-10-05.
+    // AE retains each handle's requested influence even when their sum exceeds 100%.
+    for (from, to, out_speed, out_inf, in_speed, in_inf, samples) in [
+        (0.0, 100.0, 0.0, 0.8, 0.0, 0.8, [(0.1, 0.59243939036327), (0.25, 4.76438030608764), (0.4, 18.4284394271562), (0.75, 95.2356196939123)]),
+        (0.0, 100.0, 20.0, 0.8, 80.0, 0.6, [(0.1, 2.25754942621577), (0.25, 6.99841889412931), (0.4, 14.9334636959052), (0.75, 73.8196785378389)]),
+        (100.0, 0.0, -20.0, 0.6, -80.0, 0.8, [(0.1, 97.6395466334594), (0.25, 91.597048571292), (0.4, 74.5367957474338), (0.75, 22.3789127753126)]),
+    ] {
+        let mut a = Keyframe::new(s(0.0), Value::Scalar(from));
+        let mut b = Keyframe::new(s(1.0), Value::Scalar(to));
+        a.out_interp = Interp::Bezier;
+        b.in_interp = Interp::Bezier;
+        a.out_ease = vec![Ease { speed: out_speed, influence: out_inf }];
+        b.in_ease = vec![Ease { speed: in_speed, influence: in_inf }];
+        for (time, expected) in samples {
+            let value = evaluate(&[a.clone(), b.clone()], s(time), false).unwrap().as_f64();
+            assert!((value - expected).abs() < 1e-7, "{time}: {value} != {expected}");
+            let normalized = ease_progress(out_speed / (to - from), out_inf, in_speed / (to - from), in_inf, time);
+            assert!((from + normalized * (to - from) - expected).abs() < 1e-7);
+        }
+    }
+}
+
+#[test]
+fn maximum_influence_resolves_flat_midpoint_time_curve() {
+    for time in [0.5 - 1e-9, 0.5 - 1e-12, 0.5, 0.5 + 1e-12, 0.5 + 1e-9] {
+        // At 100%/100%, x = 0.5 + 4*(u - 0.5)^3 exactly.
+        let u = 0.5 + ((time - 0.5) / 4.0_f64).cbrt();
+        let expected = bez(0.0, 0.0, 1.0, 1.0, u);
+        let actual = ease_progress(0.0, 1.0, 0.0, 1.0, time);
+        assert!((actual - expected).abs() < 1e-10, "{time}: {actual} != {expected}");
+    }
+}
+
+/// M13.15: agents set gradients as plain JSON, not only the tagged form `get` returns.
+#[test]
+fn gradients_coerce_from_plain_json() {
+    let g = Value::Gradient(Gradient::default());
+    let plain = serde_json::json!({"colors": [[0, [0, 0.5, 1, 1]], [1, "#ffff00"]], "opacities": [[0, 1], [1, 0.5]]});
+    let Some(Value::Gradient(a)) = g.coerce_json(&plain) else { panic!("object form") };
+    assert_eq!(a.colors, vec![(0.0, [0.0, 0.5, 1.0, 1.0]), (1.0, [1.0, 1.0, 0.0, 1.0])]);
+    assert_eq!(a.opacities, vec![(0.0, 1.0), (1.0, 0.5)]);
+    let Some(Value::Gradient(b)) = g.coerce_json(&serde_json::json!(["#ff0000", "#00ff00", "#0000ff"])) else { panic!("list form") };
+    assert_eq!(b.colors.iter().map(|c| c.0).collect::<Vec<_>>(), vec![0.0, 0.5, 1.0]);
+    assert_eq!(b.opacities.len(), 3);
+    // The tagged form (what prop.get returns) still round-trips.
+    assert_eq!(g.coerce_json(&g.to_json()), Some(g.clone()));
+    assert_eq!(g.coerce_json(&serde_json::json!(5)), None);
+}
+
+/// #612: the gradient editor samples a new stop from its own track only. `sample` multiplies
+/// in the opacity stops, so feeding its alpha into a colour stop would apply 50% twice (25%).
+#[test]
+fn gradient_tracks_sample_separately() {
+    let g = Gradient { colors: vec![(0.0, [1.0, 0.0, 0.0, 0.8]), (1.0, [0.0, 0.0, 1.0, 0.4])], opacities: vec![(0.0, 0.5), (1.0, 0.5)] };
+    let c = g.color_at(0.5);
+    assert!((c[0] - 0.5).abs() < 1e-6 && (c[2] - 0.5).abs() < 1e-6, "{c:?}");
+    assert!((c[3] - 0.6).abs() < 1e-6, "the colour track's own alpha, without opacity: {c:?}");
+    assert!((g.opacity_at(0.5) - 0.5).abs() < 1e-6);
+    assert!((g.sample(0.5)[3] - 0.3).abs() < 1e-6, "sample still applies opacity once");
+    // A stop added at 50% from the opacity track keeps 50%: sampled again, it is still 50%.
+    let mut with_stop = g.clone();
+    with_stop.opacities.insert(1, (0.5, g.opacity_at(0.5)));
+    assert!((with_stop.opacity_at(0.5) - 0.5).abs() < 1e-6);
+    assert!((with_stop.sample(0.5)[3] - 0.3).abs() < 1e-6, "adding a stop doesn't change the look");
+    // Outside the stops, and with none: the ends hold, and an empty track is opaque white.
+    assert_eq!(g.color_at(-1.0), [1.0, 0.0, 0.0, 0.8]);
+    assert_eq!(g.color_at(2.0), [0.0, 0.0, 1.0, 0.4]);
+    let empty = Gradient { colors: vec![], opacities: vec![] };
+    assert_eq!((empty.color_at(0.3), empty.opacity_at(0.3)), ([1.0; 4], 1.0));
+}
+
+/// #612: the editor saves the typed form, so one colour stop (which the plain JSON parser
+/// rejects) and each stop's RGBA come back exactly.
+#[test]
+fn typed_gradient_round_trips_one_stop_and_rgba() {
+    let one = Value::Gradient(Gradient { colors: vec![(0.25, [0.1, 0.2, 0.3, 0.7])], opacities: vec![(0.0, 1.0), (0.6, 0.35)] });
+    let cur = Value::Gradient(Gradient::default());
+    assert_eq!(cur.coerce_json(&one.to_json()), Some(one.clone()));
+    assert_eq!(cur.coerce_json(&serde_json::json!({"colors": [[0.25, [0.1, 0.2, 0.3, 0.7]]]})), None, "plain JSON needs two colours");
+}
+
+#[test]
+fn linear_and_hold() {
+    let keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), Keyframe::new(s(2.0), Value::Scalar(100.0))];
+    assert_eq!(evaluate(&keys, s(1.0), false), Some(Value::Scalar(50.0)));
+    assert_eq!(evaluate(&keys, s(-1.0), false), Some(Value::Scalar(0.0)));
+    assert_eq!(evaluate(&keys, s(3.0), false), Some(Value::Scalar(100.0)));
+    let held = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)).hold(), Keyframe::new(s(2.0), Value::Scalar(100.0))];
+    assert_eq!(evaluate(&held, s(1.999), false), Some(Value::Scalar(0.0)));
+}
+
+#[test]
+fn hold_key_keeps_its_incoming_segment_linear() {
+    // Hold on the second key (in and out, as KeyframeInterpolationType.HOLD sets it) holds
+    // what comes after it, not the linear motion into it.
+    let keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), Keyframe::new(s(2.0), Value::Scalar(100.0)).hold()];
+    assert_eq!(evaluate(&keys, s(0.5), false), Some(Value::Scalar(25.0)));
+    let keys = vec![Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])), Keyframe::new(s(2.0), Value::Vec2([100.0, 0.0])).hold()];
+    let p = evaluate(&keys, s(0.5), true).unwrap().as_vec2();
+    assert!((p[0] - 25.0).abs() < 0.01, "{p:?}");
+}
+
+#[test]
+fn easy_ease_is_symmetric_and_slow_at_ends() {
+    let keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)).eased(), Keyframe::new(s(1.0), Value::Scalar(100.0)).eased()];
+    let mid = evaluate(&keys, s(0.5), false).unwrap().as_f64();
+    assert!((mid - 50.0).abs() < 1e-6, "{mid}");
+    let early = evaluate(&keys, s(0.1), false).unwrap().as_f64();
+    assert!(early < 10.0 && early > 0.0, "{early}");
+    let v0 = velocity(&keys, s(0.01), false)[0];
+    let vm = velocity(&keys, s(0.5), false)[0];
+    assert!(v0 < vm);
+}
+
+#[test]
+fn bezier_with_linear_speed_matches_linear() {
+    let mut a = Keyframe::new(s(0.0), Value::Scalar(0.0));
+    let mut b = Keyframe::new(s(2.0), Value::Scalar(100.0));
+    a.out_interp = Interp::Bezier;
+    b.in_interp = Interp::Bezier;
+    a.out_ease = vec![Ease { speed: 50.0, influence: 1.0 / 3.0 }];
+    b.in_ease = vec![Ease { speed: 50.0, influence: 1.0 / 3.0 }];
+    let keys = vec![a, b];
+    for i in 0..=20 {
+        let t = i as f64 * 0.1;
+        let v = evaluate(&keys, s(t), false).unwrap().as_f64();
+        assert!((v - 50.0 * t).abs() < 1e-6, "{t} {v}");
+    }
+}
+
+#[test]
+fn spatial_linear_constant_speed() {
+    let keys = vec![Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])), Keyframe::new(s(1.0), Value::Vec2([300.0, 400.0]))];
+    let p = evaluate(&keys, s(0.5), true).unwrap().as_vec2();
+    assert!((p[0] - 150.0).abs() < 0.5 && (p[1] - 200.0).abs() < 0.5, "{p:?}");
+}
+
+/// #456: along a curved spatial path with linear (constant-speed) keys the speed graph is
+/// flat, not a sawtooth from a piecewise-linear arc-length table.
+#[test]
+fn spatial_curved_path_has_smooth_constant_speed() {
+    let mut a = Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0]));
+    let mut b = Keyframe::new(s(2.0), Value::Vec2([400.0, 0.0]));
+    a.spatial_auto = false;
+    b.spatial_auto = false;
+    a.spatial_out = [50.0, -300.0, 0.0];
+    b.spatial_in = [80.0, 250.0, 0.0];
+    let keys = vec![a, b];
+    let len = spatial_segment_length(&keys, 0);
+    let speeds: Vec<f64> = (1..400).map(|i| speed(&keys, s(i as f64 * 0.005), true)).collect();
+    for v in &speeds {
+        assert!((v - len / 2.0).abs() < 1e-3 * len, "speed {v} vs {}", len / 2.0);
+    }
+}
+
+#[test]
+fn spatial_auto_bezier_passes_through_keys() {
+    let keys = vec![
+        Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])),
+        Keyframe::new(s(1.0), Value::Vec2([100.0, 100.0])),
+        Keyframe::new(s(2.0), Value::Vec2([200.0, 0.0])),
+    ];
+    let p = evaluate(&keys, s(1.0), true).unwrap().as_vec2();
+    assert_eq!(p, [100.0, 100.0]);
+    // Curved: the midpoint of the first segment lies off the straight line.
+    let m = evaluate(&keys, s(0.5), true).unwrap().as_vec2();
+    assert!((m[0] - m[1]).abs() > 1.0, "{m:?}");
+}
+
+#[test]
+fn straight_auto_bezier_path_is_exact() {
+    // Auto-Bezier ends now have handles along the line; the chord is still hit exactly.
+    let keys = vec![Keyframe::new(s(0.0), Value::Vec2([40.0, 50.0])), Keyframe::new(s(2.0), Value::Vec2([120.0, 50.0]))];
+    assert_eq!(segment_value(&keys, 0, s(1.0), true), Value::Vec2([80.0, 50.0]));
+}
+
+/// #880: a motion path whose arc length overflows (huge coordinates, as the Position field
+/// accepts) or is NaN evaluates without panicking: scrubbing over it crashed the app.
+#[test]
+fn overflowing_or_nan_motion_paths_evaluate() {
+    let paths = [
+        [[-1.7e308, 0.0], [1.7e308, 0.0], [-1.7e308, 5.0]],
+        [[0.0, 0.0], [f64::NAN, 10.0], [20.0, 0.0]],
+        [[f64::INFINITY, 0.0], [0.0, f64::NEG_INFINITY], [20.0, 0.0]],
+    ];
+    for path in paths {
+        let mut keys: Vec<Keyframe> = path.iter().enumerate().map(|(i, &v)| Keyframe::new(s(i as f64 * 2.0), Value::Vec2(v))).collect();
+        for eased in [false, true] {
+            if eased {
+                keys = keys.into_iter().map(Keyframe::eased).collect();
+            }
+            for f in 0..=40 {
+                let t = s(f as f64 * 0.1);
+                assert!(evaluate(&keys, t, true).is_some());
+                let _ = speed(&keys, t, true);
+            }
+        }
+    }
+}
+
+#[test]
+fn spatial_auto_bezier_tangents_follow_after_effects() {
+    // Measured on After Effects 26.3 with original paths (docs/fidelity/README.md): each
+    // auto-Bezier key's out tangent is (next - previous) / 6 and its in tangent the mirror,
+    // whatever the key times. End keys use their one neighbour: (neighbour - key) / 6.
+    let p = [[40.0, 300.0, 0.0], [260.0, 80.0, 20.0], [700.0, 420.0, -40.0], [1100.0, 150.0, 0.0]];
+    let mut keys: Vec<Keyframe> = [0.0, 0.2, 1.5, 1.8].iter().zip(p).map(|(&t, v)| Keyframe::new(s(t), Value::Vec3(v))).collect();
+    let sixth = |a: [f64; 3], b: [f64; 3]| [(b[0] - a[0]) / 6.0, (b[1] - a[1]) / 6.0, (b[2] - a[2]) / 6.0];
+    let neg = |v: [f64; 3]| [-v[0], -v[1], -v[2]];
+    let close = |a: [f64; 3], b: [f64; 3]| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-9);
+    let want = [sixth(p[0], p[1]), sixth(p[0], p[2]), sixth(p[1], p[3]), sixth(p[2], p[3])];
+    for (i, out) in want.into_iter().enumerate() {
+        let (tin, tout) = spatial_tangents(&keys, i);
+        assert!(close(tout, out) && close(tin, neg(out)), "key {i}: {tin:?} {tout:?}");
+    }
+    // Moving a key in time leaves every tangent as it was.
+    keys[1].time = s(1.2);
+    assert!(close(spatial_tangents(&keys, 1).1, sixth(p[0], p[2])));
+    // A key between two coincident neighbours, and a lone key, have none.
+    let still = [[5.0, 5.0], [9.0, 1.0], [5.0, 5.0]].iter().enumerate().map(|(i, &v)| Keyframe::new(s(i as f64), Value::Vec2(v))).collect::<Vec<_>>();
+    assert_eq!(spatial_tangents(&still, 1), ([0.0; 3], [0.0; 3]));
+    assert_eq!(spatial_tangents(&still[..1], 0), ([0.0; 3], [0.0; 3]));
+}
+
+#[test]
+fn auto_spatial_holds_between_identical_keys() {
+    let path = [(0.0, [0.0, 540.0]), (0.6, [400.0, 540.0]), (4.4, [400.0, 540.0]), (5.0, [0.0, 540.0])];
+    for eased in [false, true] {
+        let keys: Vec<Keyframe> = path
+            .iter()
+            .map(|&(t, v)| {
+                let k = Keyframe::new(s(t), Value::Vec2(v));
+                if eased { k.eased() } else { k }
+            })
+            .collect();
+        assert_eq!(spatial_tangents(&keys, 1).1, [0.0; 3]);
+        assert_eq!(spatial_tangents(&keys, 2).0, [0.0; 3]);
+        for t in [0.7, 1.0, 2.5, 4.0, 4.3] {
+            let p = evaluate(&keys, s(t), true).unwrap().as_vec3();
+            assert!((p[0] - 400.0).abs() < 1e-6 && (p[1] - 540.0).abs() < 1e-6, "eased={eased} t={t} p={p:?}");
+        }
+    }
+}
+
+#[test]
+fn set_key_replaces_same_time() {
+    let mut keys = vec![];
+    set_key(&mut keys, Keyframe::new(s(1.0), Value::Scalar(1.0)).eased());
+    set_key(&mut keys, Keyframe::new(s(0.0), Value::Scalar(0.0)));
+    set_key(&mut keys, Keyframe::new(s(1.0), Value::Scalar(5.0)));
+    assert_eq!(keys.len(), 2);
+    assert_eq!(keys[1].value, Value::Scalar(5.0));
+    assert_eq!(keys[1].in_interp, Interp::Bezier);
+}
+
+#[test]
+fn colors_and_paths_interpolate() {
+    let keys = vec![Keyframe::new(s(0.0), Value::Color([0.0, 0.0, 0.0, 1.0])), Keyframe::new(s(1.0), Value::Color([1.0, 0.5, 0.0, 1.0]))];
+    assert_eq!(evaluate(&keys, s(0.5), false).unwrap().as_color(), [0.5, 0.25, 0.0, 1.0]);
+    let a = ShapePath::rect([0.0, 0.0], 10.0, 10.0);
+    let b = ShapePath::rect([0.0, 0.0], 20.0, 20.0);
+    let keys = vec![Keyframe::new(s(0.0), Value::Path(a)), Keyframe::new(s(1.0), Value::Path(b))];
+    let v = evaluate(&keys, s(0.5), false).unwrap();
+    assert_eq!(v.as_path().unwrap().vertices[0], [-7.5, -7.5]);
+}
+
+#[test]
+fn roving_keys_get_constant_speed_times() {
+    let mut keys = vec![
+        Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])),
+        Keyframe::new(s(0.2), Value::Vec2([300.0, 0.0])),
+        Keyframe::new(s(2.0), Value::Vec2([400.0, 0.0])),
+    ];
+    for k in &mut keys {
+        k.spatial_auto = false;
+    }
+    keys[1].roving = true;
+    assert!(retime_roving(&mut keys, true));
+    // 300 of 400 px → 75 % of the 2 s span.
+    assert!((keys[1].time.seconds() - 1.5).abs() < 1e-6, "{}", keys[1].time.seconds());
+    let v0 = speed(&keys, s(0.5), true);
+    let v1 = speed(&keys, s(1.8), true);
+    assert!((v0 - 200.0).abs() < 1.0 && (v1 - 200.0).abs() < 1.0, "{v0} {v1}");
+    // First/last keys can't rove.
+    keys[0].roving = true;
+    retime_roving(&mut keys, true);
+    assert!(!keys[0].roving);
+}
+
+#[test]
+fn roving_keys_never_share_a_time_with_a_fixed_key() {
+    // Zero-length last segment (issue #532) and zero-length first segment.
+    for xs in [[0.0, 40.0, 120.0, 120.0], [0.0, 0.0, 40.0, 120.0]] {
+        let mut keys: Vec<Keyframe> = xs.iter().enumerate().map(|(i, x)| Keyframe::new(s(i as f64), Value::Vec2([*x, 64.0]))).collect();
+        for k in &mut keys {
+            k.spatial_auto = false;
+        }
+        keys[1].roving = true;
+        keys[2].roving = true;
+        retime_roving(&mut keys, true);
+        assert!(keys.windows(2).all(|w| w[0].time < w[1].time), "{xs:?}: {:?}", keys.iter().map(|k| k.time).collect::<Vec<_>>());
+    }
+}
+
+#[test]
+fn side_ease_reports_linear_and_eased_sides() {
+    let keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), Keyframe::new(s(2.0), Value::Scalar(100.0)).eased()];
+    let out = side_ease(&keys, 0, 0, false, true).unwrap();
+    assert!((out.speed - 50.0).abs() < 1e-9);
+    let inn = side_ease(&keys, 1, 0, false, false).unwrap();
+    assert_eq!(inn, Ease::EASY);
+    assert!(side_ease(&keys, 0, 0, false, false).is_none());
+}
+
+#[test]
+fn time_reverse_mirrors_keys() {
+    let mut keys =
+        vec![Keyframe::new(s(1.0), Value::Scalar(0.0)).eased(), Keyframe::new(s(2.0), Value::Scalar(5.0)), Keyframe::new(s(4.0), Value::Scalar(10.0))];
+    keys[0].out_interp = Interp::Hold;
+    time_reverse(&mut keys);
+    assert_eq!(keys.iter().map(|k| k.time.seconds().round() as i64).collect::<Vec<_>>(), vec![1, 3, 4]);
+    assert_eq!(keys[0].value, Value::Scalar(10.0));
+    assert_eq!(keys[2].in_interp, Interp::Hold);
+}
+
+proptest::proptest! {
+    #[test]
+    fn eased_values_stay_in_range(t in 0.0f64..1.0, i0 in 0.01f64..1.0, i1 in 0.01f64..1.0) {
+        let mut a = Keyframe::new(s(0.0), Value::Scalar(0.0)).eased();
+        let mut b = Keyframe::new(s(1.0), Value::Scalar(10.0)).eased();
+        a.out_ease = vec![Ease { speed: 0.0, influence: i0 }];
+        b.in_ease = vec![Ease { speed: 0.0, influence: i1 }];
+        let v = evaluate(&[a, b], s(t), false).unwrap().as_f64();
+        proptest::prop_assert!((-1e-9..=10.0 + 1e-9).contains(&v));
+    }
+}
+
+#[test]
+fn muted_keys_are_skipped_by_evaluation() {
+    let mut keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), Keyframe::new(s(1.0), Value::Scalar(100.0)), Keyframe::new(s(2.0), Value::Scalar(300.0))];
+    let at = |keys: &[Keyframe], t: f64| evaluate(keys, s(t), false).unwrap().as_f64();
+    assert!((at(&keys, 0.5) - 50.0).abs() < 1e-9);
+    assert!((at(&keys, 1.5) - 200.0).abs() < 1e-9);
+    keys[1].muted = true;
+    // The 0 → 300 segment now spans 0 → 2 s.
+    assert!((at(&keys, 0.5) - 75.0).abs() < 1e-9);
+    assert!((at(&keys, 1.0) - 150.0).abs() < 1e-9);
+    assert!((at(&keys, 1.5) - 225.0).abs() < 1e-9);
+    for k in &mut keys {
+        k.muted = true;
+    }
+    assert!(evaluate(&keys, s(0.5), false).is_none());
+}
+
+#[test]
+fn muted_key_automation_uses_the_active_neighbours() {
+    let mut keys = vec![
+        Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])),
+        Keyframe::new(s(1.0), Value::Vec2([50.0, 100.0])),
+        Keyframe::new(s(2.0), Value::Vec2([100.0, 0.0])),
+    ];
+    for k in &mut keys {
+        k.auto_bezier = true;
+        k.in_interp = Interp::Bezier;
+        k.out_interp = Interp::Bezier;
+    }
+    let all = keys.clone();
+    let mut active = keys.clone();
+    active.remove(1);
+    keys[1].muted = true;
+    for t in [0.0, 0.25, 0.5, 1.0, 1.5, 1.75, 2.0] {
+        assert_eq!(evaluate(&keys, s(t), true), evaluate(&active, s(t), true), "{t}");
+    }
+    // The muted auto-Bezier key no longer bulges the motion path.
+    assert_ne!(evaluate(&keys, s(0.5), true), evaluate(&all, s(0.5), true));
+}
+
+#[test]
+fn mute_round_trips_and_survives_value_replacement() {
+    let mut k = Keyframe::new(s(0.0), Value::Scalar(1.0));
+    let json = serde_json::to_value(&k).unwrap();
+    assert!(json.get("muted").is_none(), "false is the default and is skipped");
+    k.muted = true;
+    let json = serde_json::to_value(&k).unwrap();
+    assert_eq!(json["muted"], serde_json::json!(true));
+    let back: Keyframe = serde_json::from_value(json).unwrap();
+    assert!(back.muted);
+    let mut keys = vec![k];
+    set_key(&mut keys, Keyframe::new(s(0.0), Value::Scalar(2.0)));
+    assert!(keys[0].muted);
+    assert_eq!(keys[0].value, Value::Scalar(2.0));
+}
diff --git a/crates/keyframe/src/text_doc.rs b/crates/keyframe/src/text_doc.rs
index 6c1e5b843..96a8b6be3 100644
--- a/crates/keyframe/src/text_doc.rs
+++ b/crates/keyframe/src/text_doc.rs
@@ -179,6 +179,31 @@ pub enum Composer {
 fn single_line() -> Composer {
     Composer::SingleLine
 }
+
+/// How the corners of a text stroke are drawn (Character panel Line Join).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum LineJoin {
+    /// Sharp corners (AE's default for new text).
+    #[default]
+    Miter,
+    Round,
+    Bevel,
+}
+
+impl LineJoin {
+    pub fn parse(s: &str) -> Option<LineJoin> {
+        Some(match s.to_ascii_lowercase().as_str() {
+            "miter" => LineJoin::Miter,
+            "round" => LineJoin::Round,
+            "bevel" => LineJoin::Bevel,
+            _ => return None,
+        })
+    }
+}
+
+fn round_join() -> LineJoin {
+    LineJoin::Round
+}
 fn yes() -> bool {
     true
 }
@@ -402,6 +427,9 @@ pub struct TextDoc {
     pub apply_fill: bool,
     pub apply_stroke: bool,
     pub stroke_over_fill: bool,
+    /// Documents saved before line joins existed drew round joins.
+    #[serde(default = "round_join")]
+    pub line_join: LineJoin,
     pub tracking: f64,
     /// None = auto (120% of size).
     pub leading: Option<f64>,
@@ -463,6 +491,7 @@ impl Default for TextDoc {
             apply_fill: true,
             apply_stroke: false,
             stroke_over_fill: true,
+            line_join: LineJoin::Miter,
             tracking: 0.0,
             leading: None,
             justify: Justify::Left,
@@ -909,6 +938,10 @@ impl TextDoc {
                 self.stroke_over_fill = v.as_bool().ok_or("strokeOverFill: expected a boolean")?;
                 return Ok(true);
             }
+            "lineJoin" => {
+                self.line_join = v.as_str().and_then(LineJoin::parse).ok_or("lineJoin: expected miter|round|bevel")?;
+                return Ok(true);
+            }
             "vertical" => {
                 self.vertical = v.as_bool().ok_or("vertical: expected a boolean")?;
                 return Ok(true);
@@ -1423,6 +1456,8 @@ mod tests {
         assert!(d.is_uniform());
         assert_eq!(d.style_at(2).size, 50.0);
         assert_eq!(d.composer, Composer::SingleLine, "old box text keeps greedy breaking");
+        assert_eq!(d.line_join, LineJoin::Round, "old strokes keep their round corners");
+        assert_eq!(TextDoc::default().line_join, LineJoin::Miter);
         assert!(d.ligatures);
         assert_eq!(d.kerning, Kerning::Metrics);
         // Round trip with runs.
diff --git a/crates/lottie/src/anim.rs b/crates/lottie/src/anim.rs
index e3264e3b7..4925460a9 100644
--- a/crates/lottie/src/anim.rs
+++ b/crates/lottie/src/anim.rs
@@ -73,9 +73,22 @@ fn is_spatial(p: &Property) -> bool {
 }
 
 /// Export a property as a Lottie animatable property (`{a, k}` plus `x` for expressions).
-/// `label` names the property in warnings.
+/// `label` names the property in warnings. Muted keys are omitted: Lottie has no mute state, and
+/// the remaining keys carry the animation the renderer shows.
 pub(crate) fn export_prop(ex: &mut Ex, p: &Property, conv: &dyn Fn(&Value) -> Json, label: &str) -> Json {
-    let mut out = if p.keys.is_empty() { json!({"a": 0, "k": conv(&p.value)}) } else { json!({"a": 1, "k": export_keys(ex, p, conv)}) };
+    let muted = p.keys.iter().any(|k| k.muted);
+    if muted {
+        ex.warn(format!("{label}: muted keyframes are not exported"));
+    }
+    let active: Vec<Keyframe>;
+    let keys: &[Keyframe] = if muted {
+        active = p.keys.iter().filter(|k| !k.muted).cloned().collect();
+        &active
+    } else {
+        &p.keys
+    };
+    let mut out =
+        if keys.is_empty() { json!({"a": 0, "k": conv(&p.value)}) } else { json!({"a": 1, "k": export_keys(ex, keys, is_spatial(p), p.hold_only, conv)}) };
     if let Some(e) = p.expr.as_ref().filter(|e| e.enabled && !e.text.trim().is_empty()) {
         if ex.include_expressions {
             out["x"] = json!(e.text);
@@ -86,20 +99,18 @@ pub(crate) fn export_prop(ex: &mut Ex, p: &Property, conv: &dyn Fn(&Value) -> Js
     out
 }
 
-fn export_keys(ex: &Ex, p: &Property, conv: &dyn Fn(&Value) -> Json) -> Vec<Json> {
-    let keys = &p.keys;
-    let spatial = is_spatial(p);
+fn export_keys(ex: &Ex, keys: &[Keyframe], spatial: bool, hold_only: bool, conv: &dyn Fn(&Value) -> Json) -> Vec<Json> {
     let mut out = Vec::with_capacity(keys.len());
     for (i, k) in keys.iter().enumerate() {
         let mut o = json!({"t": r6(ex.tb.frame(k.time)), "s": wrap(conv(&k.value))});
         if i + 1 == keys.len() {
-            if k.out_interp == Interp::Hold || p.hold_only {
+            if k.out_interp == Interp::Hold || hold_only {
                 o["h"] = json!(1);
             }
             out.push(o);
             continue;
         }
-        if k.out_interp == Interp::Hold || p.hold_only || !k.value.interpolates() {
+        if k.out_interp == Interp::Hold || hold_only || !k.value.interpolates() {
             o["h"] = json!(1);
             out.push(o);
             continue;
diff --git a/crates/lottie/src/import.rs b/crates/lottie/src/import.rs
index b2eeece49..6d7cc1f5a 100644
--- a/crates/lottie/src/import.rs
+++ b/crates/lottie/src/import.rs
@@ -47,7 +47,9 @@ fn s<'a>(j: &'a Json, k: &str) -> Option<&'a str> {
 
 fn hex_color(sc: &str) -> [f32; 3] {
     let h = sc.trim_start_matches('#');
-    let c = |i: usize| h.get(i..i + 2).and_then(|x| u8::from_str_radix(x, 16).ok()).unwrap_or(0) as f32 / 255.0;
+    let c = |i: usize| {
+        h.get(i..i + 2).filter(|x| x.bytes().all(|b| b.is_ascii_hexdigit())).and_then(|x| u8::from_str_radix(x, 16).ok()).unwrap_or(0) as f32 / 255.0
+    };
     [c(0), c(2), c(4)]
 }
 
@@ -141,7 +143,9 @@ pub fn import(
         let Some(id) = s(a, "id") else { continue };
         if a.get("layers").is_some() {
             let folder = cx.folder(project);
-            let (aw, ah) = (f(a, "w").map(|v| v as u32).unwrap_or(w), f(a, "h").map(|v| v as u32).unwrap_or(h));
+            let layer = precomp_layer_size(&doc, &assets, id);
+            let aw = f(a, "w").map(|v| v as u32).or(layer.map(|l| l.0)).unwrap_or(w);
+            let ah = f(a, "h").map(|v| v as u32).or(layer.map(|l| l.1)).unwrap_or(h);
             let arate = f(a, "fr").map(FrameRate::from_f64).unwrap_or(rate);
             let c = Comp::new(aw, ah, arate, duration);
             let nm = s(a, "nm").unwrap_or(id).to_string();
@@ -240,6 +244,19 @@ pub fn import(
     Ok(ImportResult { comp: id, items: cx.items, warnings: cx.im.warnings })
 }
 
+/// The `w`/`h` of the first precomp layer, in the main comp or in any asset, that shows asset `id`.
+/// lottie-spec gives a precomposition asset no size: the layer's `w`/`h` are its clipping rect.
+fn precomp_layer_size(doc: &Json, assets: &[Json], id: &str) -> Option<(u32, u32)> {
+    let lists = doc.get("layers").into_iter().chain(assets.iter().filter_map(|a| a.get("layers")));
+    lists.filter_map(Json::as_array).flatten().find_map(|l| {
+        if l.get("ty").and_then(Json::as_u64) != Some(0) || s(l, "refId") != Some(id) {
+            return None;
+        }
+        let (lw, lh) = f(l, "w").zip(f(l, "h"))?;
+        Some((lw.round().max(1.0) as u32, lh.round().max(1.0) as u32))
+    })
+}
+
 fn transform(im: &Im, ks: &Json, tr: &mut PropGroup, next: &mut u64) {
     let set = |tr: &mut PropGroup, m: &str, j: Option<&Json>, conv: &dyn Fn(&Json) -> Option<Value>| {
         if let (Some(j), Some(p)) = (j, tr.get_mut(m)) {
@@ -399,7 +416,14 @@ fn build_layers(cx: &mut Ctx, project: &mut Project, comp: &mut Comp, layers: &[
         l.in_point = tb.tick(ip);
         l.out_point = tb.tick(op.max(ip));
         l.start_time = tb.tick(f(j, "st").unwrap_or(0.0));
-        l.stretch = f(j, "sr").unwrap_or(1.0) * 100.0;
+        // Below 1 % (or 0) the layer time divides by ~0, and layer.timeStretch refuses it too.
+        let sr = f(j, "sr").unwrap_or(1.0);
+        l.stretch = if sr.is_finite() && sr.abs() >= 0.01 {
+            sr * 100.0
+        } else {
+            cx.im.warn(format!("{name}: a time stretch of {} % is not supported (100 % used)", sr * 100.0));
+            100.0
+        };
         if j.get("ddd").and_then(Json::as_u64) == Some(1) {
             l.switches.three_d = true;
         }
@@ -485,3 +509,15 @@ fn build_layers(cx: &mut Ctx, project: &mut Project, comp: &mut Comp, layers: &[
         }
     }
 }
+
+#[cfg(test)]
+mod hex_color_tests {
+    use super::hex_color;
+
+    #[test]
+    fn hex_color_rejects_plus_sign() {
+        assert_eq!(hex_color("#+f0000"), [0.0, 0.0, 0.0]);
+        assert_eq!(hex_color("#zz0000"), [0.0, 0.0, 0.0]);
+        assert_eq!(hex_color("#ff0000"), [1.0, 0.0, 0.0]);
+    }
+}
diff --git a/crates/lottie/src/shapes.rs b/crates/lottie/src/shapes.rs
index 1283a2497..5b9d29970 100644
--- a/crates/lottie/src/shapes.rs
+++ b/crates/lottie/src/shapes.rs
@@ -3,8 +3,8 @@
 
 use effectcraft_color::BlendMode;
 use effectcraft_keyframe::{Gradient, ShapePath, Value};
-use effectcraft_project::build::{self, Ids};
-use effectcraft_project::{Node, PropGroup};
+use effectcraft_project::build::{self, EXTRA_DASHES, Ids};
+use effectcraft_project::{Node, ParamUi, PropGroup};
 use serde_json::{Map, Value as Json, json};
 
 use crate::anim::{self, Ex, Im, export_prop, import_prop};
@@ -113,6 +113,9 @@ impl Out<'_, '_> {
     fn f(&self, m: &str) -> f64 {
         self.g.get(m).map(|p| p.value.as_f64()).unwrap_or(0.0)
     }
+    fn flag(&self, m: &str) -> bool {
+        self.g.get(m).map(|p| p.value.as_bool()).unwrap_or(false)
+    }
     fn animated(&self, m: &str) -> bool {
         self.g.get(m).is_some_and(|p| p.is_animated() || p.has_expression())
     }
@@ -232,7 +235,20 @@ pub(crate) fn export_items(ex: &mut Ex, contents: &PropGroup, label: &str) -> Ve
                 dir(&mut o);
                 o.put("s", "size", &anim::arr2);
                 o.put("p", "position", &anim::arr2);
-                o.put("r", "roundness", &anim::num);
+                if o.flag("perCorner") {
+                    let names = ["topLeftRoundness", "topRightRoundness", "bottomRightRoundness", "bottomLeftRoundness"];
+                    let radii = names.map(|m| o.f(m));
+                    // Lottie `rc` has one `r`: four equal static radii export as that value.
+                    // `r` is a property (`{a, k}`) like the uniform branch writes, not a bare number.
+                    if radii.iter().all(|v| (v - radii[0]).abs() < 1e-6) && !names.iter().any(|m| o.animated(m)) && radii[0] >= 0.0 {
+                        o.raw("r", json!({"a": 0, "k": r(radii[0])}));
+                    } else {
+                        o.ex.warn(format!("{}: per-corner roundness has no Lottie rectangle equivalent (roundness 0 exported)", o.label));
+                        o.raw("r", json!({"a": 0, "k": 0}));
+                    }
+                } else {
+                    o.put("r", "roundness", &anim::num);
+                }
             }
             "el" => {
                 dir(&mut o);
@@ -356,7 +372,7 @@ fn import_blend(j: &Json, g: &mut PropGroup) {
     }
 }
 
-fn import_stroke(im: &Im, j: &Json, g: &mut PropGroup) {
+fn import_stroke(im: &Im, ids: &mut Ids, j: &Json, g: &mut PropGroup) {
     set(im, g, "width", j.get("w"), &anim::to_scalar);
     if let Some(lc) = int(j, "lc") {
         set_enum(g, "cap", lc.saturating_sub(1).clamp(0, 2) as u32);
@@ -374,17 +390,32 @@ fn import_stroke(im: &Im, j: &Json, g: &mut PropGroup) {
     if let Some(list) = j.get("d").and_then(Json::as_array)
         && let Some(d) = g.sub_mut("dashes")
     {
-        let mut seen_dash = false;
+        // The n-th `d` and `g` are the n-th Dash/Gap pair; the extra pairs are created as the Dashes "+" does.
+        let (mut dashes, mut gaps) = (0, 0);
         for e in list {
-            let m = match e.get("n").and_then(Json::as_str) {
-                Some("d") if !seen_dash => {
-                    seen_dash = true;
-                    "dash"
+            let (n, pair) = match e.get("n").and_then(Json::as_str) {
+                Some("d") => (&mut dashes, 0),
+                Some("g") => (&mut gaps, 1),
+                Some("o") => {
+                    set(im, d, "offset", e.get("v"), &anim::to_scalar);
+                    continue;
                 }
-                Some("g") => "gap",
-                Some("o") => "offset",
                 _ => continue,
             };
+            let k = *n;
+            *n += 1;
+            let m = match k {
+                0 => ["dash", "gap"][pair],
+                _ => {
+                    let Some(&(dm, gm)) = EXTRA_DASHES.get(k - 1) else { continue };
+                    if d.get(dm).is_none() {
+                        let at = d.children.iter().position(|c| c.match_id() == "offset").unwrap_or(d.children.len());
+                        d.children.insert(at, ids.prop(gm, &format!("Gap {}", k + 1), Value::Scalar(0.0)).with_ui(ParamUi::Pixels).into());
+                        d.children.insert(at, ids.prop(dm, &format!("Dash {}", k + 1), Value::Scalar(0.0)).with_ui(ParamUi::Pixels).into());
+                    }
+                    [dm, gm][pair]
+                }
+            };
             set(im, d, m, e.get("v"), &anim::to_scalar);
         }
     }
@@ -432,6 +463,11 @@ pub(crate) fn import_items(im: &mut Im, ids: &mut Ids, items: &[Json]) -> Vec<Pr
                 set(im, &mut g, "size", j.get("s"), &anim::to_vec2);
                 set(im, &mut g, "position", j.get("p"), &anim::to_vec2);
                 set(im, &mut g, "roundness", j.get("r"), &anim::to_scalar);
+                // Lottie has one roundness: keep the per-corner values in step so ticking the box
+                // on an imported rectangle keeps the shape.
+                for m in ["topLeftRoundness", "topRightRoundness", "bottomRightRoundness", "bottomLeftRoundness"] {
+                    set(im, &mut g, m, j.get("r"), &anim::to_scalar);
+                }
                 g
             }
             "el" => {
@@ -474,7 +510,7 @@ pub(crate) fn import_items(im: &mut Im, ids: &mut Ids, items: &[Json]) -> Vec<Pr
                 let mut g = build::shape_stroke(ids, [1.0, 1.0, 1.0, 1.0], 2.0);
                 set(im, &mut g, "color", j.get("c"), &anim::to_color);
                 set(im, &mut g, "opacity", j.get("o"), &anim::to_scalar);
-                import_stroke(im, j, &mut g);
+                import_stroke(im, ids, j, &mut g);
                 import_blend(j, &mut g);
                 g
             }
@@ -501,7 +537,7 @@ pub(crate) fn import_items(im: &mut Im, ids: &mut Ids, items: &[Json]) -> Vec<Pr
                         set_enum(&mut g, "rule", 1);
                     }
                 } else {
-                    import_stroke(im, j, &mut g);
+                    import_stroke(im, ids, j, &mut g);
                 }
                 import_blend(j, &mut g);
                 g
diff --git a/crates/lottie/src/tests.rs b/crates/lottie/src/tests.rs
index e819c0239..83c81e242 100644
--- a/crates/lottie/src/tests.rs
+++ b/crates/lottie/src/tests.rs
@@ -407,6 +407,30 @@ fn offset_paths_miter_uses_animatable_lottie_value() {
     assert_eq!(second.get("miter").unwrap().value, Value::Scalar(6.0));
 }
 
+#[test]
+fn extra_dash_gap_pairs_survive_a_roundtrip() {
+    let (mut p, cid) = setup();
+    let l = shape_layer(&mut p, cid, |ids| {
+        let mut stroke = build::shape_stroke(ids, [0.0, 0.0, 1.0, 1.0], 3.0);
+        let d = stroke.sub_mut("dashes").unwrap();
+        d.get_mut("dash").unwrap().value = Value::Scalar(10.0);
+        d.get_mut("gap").unwrap().value = Value::Scalar(5.0);
+        let at = d.children.iter().position(|n| n.match_id() == "offset").unwrap();
+        d.children.insert(at, ids.prop("gap2", "Gap 2", Value::Scalar(3.0)).into());
+        d.children.insert(at, ids.prop("dash2", "Dash 2", Value::Scalar(20.0)).into());
+        let rect = build::shape_rect(ids, [60.0, 40.0], [0.0, 0.0], 0.0);
+        vec![build::shape_group(ids, "G", vec![rect, stroke])]
+    });
+    push(&mut p, cid, l);
+    let (q, nc, _, _) = roundtrip(&p, cid, &ExportOptions::default());
+    let c = q.comp(nc).unwrap();
+    let g = c.layers[0].props.sub("contents").unwrap().groups().next().unwrap();
+    let stroke = g.sub("contents").unwrap().groups().find(|g| g.match_id == "stroke").unwrap();
+    let d = stroke.sub("dashes").unwrap();
+    let v = |m: &str| d.get(m).map(|p| p.value.as_f64());
+    assert_eq!((v("dash"), v("gap"), v("dash2"), v("gap2")), (Some(10.0), Some(5.0), Some(20.0), Some(3.0)));
+}
+
 // ---------------------------------------------------------------- layers
 
 #[test]
@@ -484,6 +508,18 @@ fn layers_parenting_timing_mattes_masks_and_blend_modes() {
     compare_renders(&p, cid, &q, nc, 2.0 / 255.0);
 }
 
+#[test]
+fn zero_time_stretch_is_not_imported() {
+    let doc = json!({"w": 20, "h": 20, "fr": 30, "ip": 0, "op": 30, "assets": [],
+        "layers": [{"ty": 1, "ind": 1, "sc": "#ff0000", "sw": 20, "sh": 20, "sr": 0, "ip": 0, "op": 30, "st": 0, "ks": {}}]});
+    let mut q = Project::default();
+    let imp = import(&mut q, doc.to_string().as_bytes(), "Imported", "", &mut |_| None).unwrap();
+    let l = &q.comp(imp.comp).unwrap().layers[0];
+    // layer.timeStretch refuses anything below 1 %, and keyframe commands refuse a layer with 0 %.
+    assert_eq!(l.stretch, 100.0);
+    assert!(imp.warnings.iter().any(|w| w.contains("time stretch")), "{:?}", imp.warnings);
+}
+
 #[test]
 fn precomp_with_time_remap() {
     let (mut p, cid) = setup();
@@ -515,6 +551,19 @@ fn precomp_with_time_remap() {
     compare_renders(&p, cid, &q, nc, 2.0 / 255.0);
 }
 
+#[test]
+fn precomp_size_comes_from_the_layer_when_the_asset_has_none() {
+    // lottie-spec: a precomposition asset has no `w`/`h`; the precomp layer carries them.
+    let doc = json!({"w": 200, "h": 120, "fr": 30, "ip": 0, "op": 30,
+        "assets": [{"id": "c", "layers": []}],
+        "layers": [{"ty": 0, "ind": 1, "refId": "c", "w": 50, "h": 40, "ip": 0, "op": 30, "st": 0, "ks": {}}]});
+    let mut q = Project::default();
+    let nc = import(&mut q, doc.to_string().as_bytes(), "Imported", "", &mut |_| None).unwrap().comp;
+    let LayerSource::Comp { item } = q.comp(nc).unwrap().layers[0].source else { panic!("not a precomp") };
+    let pc = q.comp(item).unwrap();
+    assert_eq!((pc.width, pc.height), (50, 40));
+}
+
 #[test]
 fn text_layers_roundtrip_as_text_and_as_shapes() {
     let (mut p, cid) = setup();
@@ -829,3 +878,57 @@ fn external_images_are_local_or_skipped() {
     assert_eq!(std::path::Path::new(&paths[0]), base.join("images").join("a.png"));
     assert_eq!(r.warnings.iter().filter(|w| w.contains("is not imported")).count(), assets.len() - 1, "{:?}", r.warnings);
 }
+
+#[test]
+fn muted_keys_are_omitted_from_the_export() {
+    let (mut p, cid) = setup();
+    let mut l = solid_layer(&mut p, cid, [0.0, 1.0, 0.0], 20, 20);
+    let mut b = Keyframe::new(s(1.0), Value::Scalar(100.0));
+    b.muted = true;
+    l.props.prop_mut("transform/opacity").unwrap().keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), b, Keyframe::new(s(2.0), Value::Scalar(300.0))];
+    push(&mut p, cid, l);
+    let (q, nc, warnings, json) = roundtrip(&p, cid, &ExportOptions::default());
+    assert!(warnings.iter().any(|w| w.contains("muted keyframes")), "{warnings:?}");
+    // Lottie has no mute state: the two active keys carry the 0 → 300 animation.
+    assert_eq!(json["layers"][0]["ks"]["o"]["k"].as_array().unwrap().len(), 2);
+    assert_eq!(json["layers"][0]["ks"]["o"]["k"][1]["s"], json!([300.0]));
+    let opacity_at = |p: &Project, cid: ItemId, t: f64| p.comp(cid).unwrap().layers[0].props.prop("transform/opacity").unwrap().value_at(s(t)).as_f64();
+    assert!((opacity_at(&p, cid, 1.0) - 150.0).abs() < 1e-6);
+    assert!((opacity_at(&q, nc, 1.0) - 150.0).abs() < 1e-6);
+}
+
+#[test]
+fn per_corner_roundness_exports_equal_radii_and_warns_when_mixed() {
+    let shape = |radii: [f64; 4], roundness: f64, per_corner: bool| {
+        let (mut p, cid) = setup();
+        let l = shape_layer(&mut p, cid, move |ids| {
+            let mut g = build::shape_rect(ids, [100.0, 50.0], [0.0, 0.0], roundness);
+            g.prop_mut("perCorner").unwrap().value = Value::Bool(per_corner);
+            for (m, v) in
+                [("topLeftRoundness", radii[0]), ("topRightRoundness", radii[1]), ("bottomRightRoundness", radii[2]), ("bottomLeftRoundness", radii[3])]
+            {
+                g.prop_mut(m).unwrap().value = Value::Scalar(v);
+            }
+            let fill = build::shape_fill(ids, [1.0, 0.0, 0.0, 1.0]);
+            vec![build::shape_group(ids, "Rectangle 1", vec![g, fill])]
+        });
+        push(&mut p, cid, l);
+        (p, cid)
+    };
+    let rc = |json: &Json| -> Json { json["layers"][0]["shapes"][0]["it"].as_array().unwrap().iter().find(|i| i["ty"] == "rc").cloned().unwrap() };
+    // Four equal static radii: `rc.r` carries the value, no warning.
+    let (p, cid) = shape([12.0; 4], 5.0, true);
+    let (_, _, warnings, json) = roundtrip(&p, cid, &ExportOptions::default());
+    assert_eq!(rc(&json)["r"], json!({"a": 0, "k": 12.0}));
+    assert!(!warnings.iter().any(|w| w.contains("per-corner")), "{warnings:?}");
+    // Mixed radii: not representable, roundness 0 exported with a warning.
+    let (p, cid) = shape([10.0, 20.0, 10.0, 20.0], 5.0, true);
+    let (_, _, warnings, json) = roundtrip(&p, cid, &ExportOptions::default());
+    assert_eq!(rc(&json)["r"], json!({"a": 0, "k": 0}));
+    assert!(warnings.iter().any(|w| w.contains("per-corner roundness")), "{warnings:?}");
+    // The checkbox off exports the single Roundness and ignores the four values.
+    let (p, cid) = shape([10.0, 20.0, 10.0, 20.0], 5.0, false);
+    let (_, _, warnings, json) = roundtrip(&p, cid, &ExportOptions::default());
+    assert_eq!(rc(&json)["r"]["k"], json!(5.0));
+    assert!(!warnings.iter().any(|w| w.contains("per-corner")), "{warnings:?}");
+}
diff --git a/crates/media/Cargo.toml b/crates/media/Cargo.toml
index 0ef01d831..a4070297b 100644
--- a/crates/media/Cargo.toml
+++ b/crates/media/Cargo.toml
@@ -12,6 +12,7 @@ workspace = true
 [dependencies]
 craft-docpath = { workspace = true }
 effectcraft-time = { workspace = true }
+effectcraft-color = { workspace = true }
 effectcraft-project = { workspace = true }
 effectcraft-raster = { workspace = true }
 effectcraft-render = { workspace = true }
@@ -21,12 +22,13 @@ effectcraft-pdf = { workspace = true }
 effectcraft-model = { workspace = true }
 filmcraft-codecs = { workspace = true }
 filmcraft-media = { workspace = true }
+filmcraft-aac = { workspace = true }
 filmcraft-isobmff = { workspace = true }
+filmcraft-matroska = { workspace = true }
+filmcraft-mpegts = { workspace = true }
 filmcraft-frame = { workspace = true }
 filmcraft-color = { workspace = true }
 filmcraft-time = { workspace = true }
-# AIFF import (#1428): enables the aiff reader of filmcraft-codecs' symphonia.
-symphonia = { workspace = true }
 exr = { workspace = true }
 gif = { workspace = true }
 image = { workspace = true, features = ["gif", "webp", "tiff", "bmp", "exr", "tga", "hdr"] }
diff --git a/crates/media/src/aac.rs b/crates/media/src/aac.rs
new file mode 100644
index 000000000..625c37b43
--- /dev/null
+++ b/crates/media/src/aac.rs
@@ -0,0 +1,116 @@
+//! The AudioSpecificConfig of the AAC track FilmCraft plays from a movie, from the containers that carry
+//! it outside the audio frames: MP4 / MOV (`esds`), Matroska (`CodecPrivate`) and LATM in MPEG
+//! TS / PS (its StreamMuxConfig). FilmCraft's other AAC is ADTS (in MPEG TS / PS or a raw `.aac`),
+//! whose channel configurations FilmCraft decodes (1 to 7) its channel count tells apart
+//! ([`crate::downmix::Order::Aac`]).
+
+use std::io;
+
+use filmcraft_aac::AudioSpecificConfig;
+use filmcraft_media::ByteReader;
+
+/// How far into an MPEG TS / PS file the audio streams are looked for: the stream is indexed as
+/// far as this, not through the whole file.
+const MPEG_HEAD: u64 = 8 << 20;
+
+/// The configuration of the audio track FilmCraft plays, if it is AAC: from an MP4 / MOV `header`
+/// (its ftyp and moov, or the whole file) and `file`, or else from `file`, read as Matroska or
+/// MPEG TS / PS.
+pub(crate) fn config(header: Option<&[u8]>, file: Option<&dyn ByteReader>) -> Option<AudioSpecificConfig> {
+    let asc = match header.and_then(|h| mp4(h, file)) {
+        Some(asc) => asc,
+        None => {
+            let file = file?;
+            let mut magic = [0u8; 4];
+            file.read_at(0, &mut magic).ok()?;
+            if magic == [0x1A, 0x45, 0xDF, 0xA3] { matroska(file)? } else { latm(file)? }
+        }
+    };
+    AudioSpecificConfig::parse(&asc).ok()
+}
+
+/// The track FilmCraft's MP4 source plays: the first audio track with samples, a sample
+/// description and a timescale, read from the whole file as it is (a fragmented movie's samples
+/// are in its fragments, not the `moov`).
+fn mp4(header: &[u8], file: Option<&dyn ByteReader>) -> Option<Vec<u8>> {
+    let mp4 = match file {
+        Some(f) => filmcraft_isobmff::open(Head(f, f.len())),
+        None => filmcraft_isobmff::open(header),
+    };
+    let mp4 = mp4.ok()?;
+    let playable =
+        |t: &&filmcraft_isobmff::Track| t.kind == filmcraft_isobmff::TrackKind::Audio && !t.samples.is_empty() && !t.entries.is_empty() && t.timescale > 0;
+    let track = mp4.tracks.iter().find(playable)?;
+    match &track.entries.first()?.codec {
+        filmcraft_isobmff::CodecConfig::Aac(a) => Some(a.asc.clone()),
+        _ => None,
+    }
+}
+
+/// The track FilmCraft's Matroska source plays: the first audio track with frames, found by
+/// indexing the clusters as that source does.
+fn matroska(file: &dyn ByteReader) -> Option<Vec<u8>> {
+    let mkv = filmcraft_matroska::open(Head(file, file.len())).ok()?;
+    match &mkv.tracks.iter().find(|t| t.kind == filmcraft_matroska::TrackKind::Audio && !t.samples.is_empty())?.codec {
+        filmcraft_matroska::Codec::Aac { asc } => Some(asc.clone()),
+        _ => None,
+    }
+}
+
+/// The configuration of the stream FilmCraft's MPEG source plays: the first audio stream whose
+/// first unit it can read. Only AAC is asked about, so the streams before that one were refused
+/// whatever their codec, and an ADTS stream played has no configuration outside its frames.
+fn latm(file: &dyn ByteReader) -> Option<Vec<u8>> {
+    use filmcraft_mpegts::Codec;
+    let head = Head(file, file.len().min(MPEG_HEAD));
+    let mpeg = filmcraft_mpegts::open(&head).ok()?;
+    let audio = mpeg.streams.iter().enumerate().filter(|(_, s)| s.kind() == filmcraft_mpegts::Kind::Audio && !s.units.is_empty());
+    let played = audio.take(filmcraft_media::MAX_AUDIO_STREAMS).find_map(|(i, s)| {
+        let first = mpeg.read_unit(&head, i, 0).ok()?;
+        match s.codec {
+            Codec::AacAdts => filmcraft_mpegts::frame_info(&s.codec, &first).map(|_| None),
+            Codec::AacLatm => filmcraft_codecs::audio::latm_config(&first).map(|c| Some(c.asc)),
+            _ => None,
+        }
+    });
+    played?
+}
+
+/// The first `.1` bytes of a file, as the byte source FilmCraft's demuxers read.
+struct Head<'a>(&'a dyn ByteReader, u64);
+
+impl Head<'_> {
+    fn read(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
+        match offset.checked_add(buf.len() as u64) {
+            Some(end) if end <= self.1 => self.0.read_at(offset, buf),
+            _ => Err(io::Error::new(io::ErrorKind::UnexpectedEof, "read past the end")),
+        }
+    }
+}
+
+impl filmcraft_isobmff::ByteSource for Head<'_> {
+    fn len(&self) -> u64 {
+        self.1
+    }
+    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
+        self.read(offset, buf)
+    }
+}
+
+impl filmcraft_matroska::ByteSource for Head<'_> {
+    fn len(&self) -> u64 {
+        self.1
+    }
+    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
+        self.read(offset, buf)
+    }
+}
+
+impl filmcraft_mpegts::ByteSource for Head<'_> {
+    fn len(&self) -> u64 {
+        self.1
+    }
+    fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<()> {
+        self.read(offset, buf)
+    }
+}
diff --git a/crates/media/src/convert.rs b/crates/media/src/convert.rs
index d483e4b47..9e88ab4dd 100644
--- a/crates/media/src/convert.rs
+++ b/crates/media/src/convert.rs
@@ -103,12 +103,34 @@ pub(crate) fn frame_to_image_in(f: &VideoFrame, op: AlphaOp, mut buf: Vec<Px>) -
         PixelData::Yuv8 { planes, chroma, alpha } => {
             let yuv = Yuv::new(f.color.matrix, f.color.range, 8);
             let amax = 255.0;
-            convert_yuv(&mut img, w, h, *chroma, [&planes[0][..], &planes[1][..], &planes[2][..]], alpha.as_deref().map(|a| &a[..]), amax, &yuv, op);
+            convert_yuv(
+                &mut img,
+                YuvSource {
+                    size: (w, h),
+                    chroma: *chroma,
+                    planes: [&planes[0][..], &planes[1][..], &planes[2][..]],
+                    alpha: alpha.as_deref().map(|a| &a[..]),
+                    amax,
+                },
+                &yuv,
+                op,
+            );
         }
         PixelData::Yuv16 { planes, chroma, bits, alpha } => {
             let yuv = Yuv::new(f.color.matrix, f.color.range, *bits);
             let amax = ((1u32 << *bits) - 1) as f32;
-            convert_yuv(&mut img, w, h, *chroma, [&planes[0][..], &planes[1][..], &planes[2][..]], alpha.as_deref().map(|a| &a[..]), amax, &yuv, op);
+            convert_yuv(
+                &mut img,
+                YuvSource {
+                    size: (w, h),
+                    chroma: *chroma,
+                    planes: [&planes[0][..], &planes[1][..], &planes[2][..]],
+                    alpha: alpha.as_deref().map(|a| &a[..]),
+                    amax,
+                },
+                &yuv,
+                op,
+            );
         }
     }
     img
@@ -280,8 +302,17 @@ fn centred(i: usize, n: usize) -> (usize, usize) {
     (c, o)
 }
 
-#[allow(clippy::too_many_arguments)]
-fn convert_yuv<T: Sample>(img: &mut Image, w: usize, h: usize, chroma: Chroma, planes: [&[T]; 3], alpha: Option<&[T]>, amax: f32, k: &Yuv, op: AlphaOp) {
+/// Borrowed YUV planes and the geometry/range needed to interpret their samples.
+struct YuvSource<'a, T> {
+    size: (usize, usize),
+    chroma: Chroma,
+    planes: [&'a [T]; 3],
+    alpha: Option<&'a [T]>,
+    amax: f32,
+}
+
+fn convert_yuv<T: Sample>(img: &mut Image, source: YuvSource<'_, T>, k: &Yuv, op: AlphaOp) {
+    let YuvSource { size: (w, h), chroma, planes, alpha, amax } = source;
     let (sx, sy) = chroma.shifts();
     let cw = w.div_ceil(1 << sx);
     let ch = h.div_ceil(1 << sy);
diff --git a/crates/media/src/downmix.rs b/crates/media/src/downmix.rs
index 2ef417dd7..09bb1e1f6 100644
--- a/crates/media/src/downmix.rs
+++ b/crates/media/src/downmix.rs
@@ -10,16 +10,19 @@
 //! exceed full scale: 5.1 is scaled by 1/(1 + 0.707 + 0.707). Mono stays duplicated at unity and
 //! stereo is untouched.
 //!
-//! Channel order follows the WAVE / SMPTE convention by channel count (what FilmCraft's AC-3, PCM,
-//! FLAC and Opus readers deliver): 3 = L R C, 4 = quad L R Ls Rs, 5 = L R C Ls Rs,
-//! 6 = L R C LFE Ls Rs, 7 = L R C LFE Cs Ls Rs, 8 = L R C LFE Lb Rb Ls Rs. FilmCraft's AAC-LC
-//! decoder instead delivers AAC's own order (C L R first, LFE last), so AAC gets its own tables.
-//! More than 8 channels carry no known layout: only the first two (front L/R) are used.
+//! A decoded channel's gains come from where it plays. WAVE / SMPTE order by channel count is what
+//! FilmCraft's AC-3, PCM, FLAC and Opus readers deliver: 3 = L R C, 4 = quad L R Ls Rs,
+//! 5 = L R C Ls Rs, 6 = L R C LFE Ls Rs, 7 = L R C LFE Cs Ls Rs, 8 = L R C LFE Lb Rb Ls Rs. AAC
+//! arrives in an order its configuration decides ([`aac_order`]). More than 8 channels in WAVE
+//! order carry no known layout: only the first two (front L/R) are used.
 
 use std::f32::consts::FRAC_1_SQRT_2;
+use std::sync::Arc;
+
+use filmcraft_aac::{AudioSpecificConfig, ProgramConfig};
 
 /// A source channel's contribution to the left and right outputs, before normalisation.
-type Pair = [f32; 2];
+pub type Pair = [f32; 2];
 
 const FL: Pair = [1.0, 0.0];
 const FR: Pair = [0.0, 1.0];
@@ -29,33 +32,18 @@ const SL: Pair = [FRAC_1_SQRT_2, 0.0];
 const SR: Pair = [0.0, FRAC_1_SQRT_2];
 const CS: Pair = [0.5, 0.5];
 
-/// The per-channel `[left, right]` gains for `count` channels in the given order, normalised.
-/// `aac` selects AAC's native channel order. Empty for zero channels.
-pub fn stereo_gains(count: usize, aac: bool) -> Vec<Pair> {
-    let raw: &[Pair] = match (count, aac) {
-        (0, _) => &[],
-        (1, _) => &[[1.0, 1.0]],
-        (2, _) => &[FL, FR],
-        (3, false) => &[FL, FR, FC],
-        (3, true) => &[FC, FL, FR],
-        (4, false) => &[FL, FR, SL, SR],
-        (4, true) => &[FC, FL, FR, CS],
-        (5, false) => &[FL, FR, FC, SL, SR],
-        (5, true) => &[FC, FL, FR, SL, SR],
-        (6, false) => &[FL, FR, FC, LFE, SL, SR],
-        (6, true) => &[FC, FL, FR, SL, SR, LFE],
-        (7, false) => &[FL, FR, FC, LFE, CS, SL, SR],
-        (7, true) => &[FC, FL, FR, SL, SR, CS, LFE],
-        (8, false) => &[FL, FR, FC, LFE, SL, SR, SL, SR],
-        (8, true) => &[FC, FL, FR, SL, SR, SL, SR, LFE],
-        _ => &[FL, FR],
-    };
+/// AAC channel configuration 7 as FilmCraft decodes it (element order, not reordered).
+const CONFIG_7: [Pair; 8] = [FC, FL, FR, SL, SR, SL, SR, LFE];
+/// AAC channel configuration 4 (C L R Cs), which FilmCraft reorders to L R C Cs.
+const CONFIG_4: [Pair; 4] = [FL, FR, FC, CS];
+
+/// `raw` scaled by the reciprocal of its larger row sum when that exceeds 1 (more than two
+/// channels): full-scale input can never exceed full scale.
+fn normalised(raw: &[Pair]) -> Vec<Pair> {
     let mut out = raw.to_vec();
-    // Channels beyond a known layout (more than 8) are silent.
-    out.resize(count, [0.0, 0.0]);
     let peak = out.iter().map(|g| g[0]).sum::<f32>().max(out.iter().map(|g| g[1]).sum::<f32>());
     // Mono is deliberately left at unity on both sides; so is anything already within range.
-    if count > 2 && peak > 1.0 {
+    if out.len() > 2 && peak > 1.0 {
         for g in &mut out {
             g[0] /= peak;
             g[1] /= peak;
@@ -64,11 +52,109 @@ pub fn stereo_gains(count: usize, aac: bool) -> Vec<Pair> {
     out
 }
 
-/// Downmix planar `channels` to interleaved stereo in `out` (`out.len() / 2` frames); frames a
-/// channel is too short for count as silence, extra frames in `out` stay as they are.
-pub fn downmix_into(channels: &[Vec<f32>], aac: bool, out: &mut [f32]) {
-    let gains = stereo_gains(channels.len(), aac);
-    for (ch, g) in channels.iter().zip(&gains) {
+/// The per-channel `[left, right]` gains for `count` channels in WAVE / SMPTE order, normalised.
+/// Empty for zero channels.
+pub fn stereo_gains(count: usize) -> Vec<Pair> {
+    let raw: &[Pair] = match count {
+        0 => &[],
+        1 => &[[1.0, 1.0]],
+        2 => &[FL, FR],
+        3 => &[FL, FR, FC],
+        4 => &[FL, FR, SL, SR],
+        5 => &[FL, FR, FC, SL, SR],
+        6 => &[FL, FR, FC, LFE, SL, SR],
+        7 => &[FL, FR, FC, LFE, CS, SL, SR],
+        8 => &[FL, FR, FC, LFE, SL, SR, SL, SR],
+        _ => &[FL, FR],
+    };
+    let mut raw = raw.to_vec();
+    // Channels beyond a known layout (more than 8) are silent.
+    raw.resize(count, [0.0, 0.0]);
+    normalised(&raw)
+}
+
+/// Where a source's decoded channels play.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub enum Order {
+    /// WAVE / SMPTE by channel count: PCM, FLAC, AC-3, Opus and the rest.
+    #[default]
+    Wav,
+    /// AAC whose configuration wasn't read: by channel count as the configurations 1 to 7 decode
+    /// (exact for ADTS, which can signal no other configuration FilmCraft decodes), 7 channels as
+    /// configuration 11.
+    Aac,
+    /// Each decoded channel's gains, before normalisation.
+    Speakers(Arc<[Pair]>),
+}
+
+/// How FilmCraft's decoder hands over AAC with the configuration `asc`: it reorders channel
+/// configurations 3 to 6, 11 and 12 to WAVE / SMPTE and leaves 7 and PCE layouts in element order.
+pub fn aac_order(asc: &AudioSpecificConfig) -> Order {
+    match (asc.channel_config, &asc.pce) {
+        (4, _) => Order::Speakers(CONFIG_4.into()),
+        (1..=6 | 11 | 12, _) => Order::Wav,
+        (7, _) => Order::Speakers(CONFIG_7.into()),
+        (0, Some(pce)) => Order::Speakers(pce_speakers(pce).into()),
+        _ => Order::Aac,
+    }
+}
+
+/// ffmpeg's encoder fills a program config element's elements with its layout's channels in its
+/// own order (L R C LFE …), and for these structures that order doesn't match the element
+/// positions: an LFE in a side SCE, a back centre in a side pair. Front, side and back element
+/// types (`true` for a pair) and the channels of the ffmpeg layout with that structure (the first
+/// ffmpeg 8.1 lists, where several share it: 6.1 for 6.1(back) and 6.1(front), 7.1(wide) for
+/// 7.1(wide-side)).
+const FFMPEG_PCE: [(&[bool], &[bool], &[bool], &[Pair]); 6] = [
+    (&[true, false], &[false], &[false], &[FL, FR, FC, LFE, CS]),
+    (&[true, false], &[false], &[true], &[FL, FR, FC, LFE, SL, SR]),
+    (&[true, false], &[true], &[false], &[FL, FR, FC, CS, SL, SR]),
+    (&[true, false], &[false], &[true, false], &[FL, FR, FC, LFE, CS, SL, SR]),
+    (&[true, false], &[false], &[true, true], &[FL, FR, FC, LFE, SL, SR, FL, FR]),
+    (&[true, false], &[true], &[true, false], &[FL, FR, FC, SL, SR, CS, SL, SR]),
+];
+
+/// The channels of a PCE layout in decoded (element) order: ffmpeg's for its structures above
+/// (it names itself in the PCE's comment), otherwise by position (ISO/IEC 14496-3's program config element):
+/// front pairs left and right, a front single the centre, side and back pairs surrounds, a side
+/// or back single a back centre.
+fn pce_speakers(pce: &ProgramConfig) -> Vec<Pair> {
+    let pairs = |els: &[(bool, u8)]| els.iter().map(|e| e.0).collect::<Vec<_>>();
+    let (front, side, back) = (pairs(&pce.front), pairs(&pce.side), pairs(&pce.back));
+    if pce.comment.starts_with(b"Lavc") && pce.lfe.is_empty() {
+        let known = FFMPEG_PCE.iter().find(|(f, s, b, _)| *f == front.as_slice() && *s == side.as_slice() && *b == back.as_slice());
+        if let Some((.., speakers)) = known {
+            return speakers.to_vec();
+        }
+    }
+    let mut out = Vec::new();
+    for pair in front {
+        out.extend_from_slice(if pair { &[FL, FR] } else { &[FC] });
+    }
+    for pair in side.into_iter().chain(back) {
+        out.extend_from_slice(if pair { &[SL, SR] } else { &[CS] });
+    }
+    out.extend(pce.lfe.iter().map(|_| LFE));
+    out
+}
+
+/// The gains for `count` channels arriving in `order`. FilmCraft decodes as many channels as the
+/// container names, the first ones of the layout where that is fewer (MPEG-TS LATM names 7 of
+/// configuration 7's 8, ffmpeg 4.2 MP4s 2 of a PCE's); more go by count.
+pub fn decoded_gains(count: usize, order: &Order) -> Vec<Pair> {
+    match order {
+        Order::Speakers(s) if count <= s.len() => normalised(s.get(..count).unwrap_or_default()),
+        Order::Aac if count == 4 => normalised(&CONFIG_4),
+        Order::Aac if count == 8 => normalised(&CONFIG_7),
+        _ => stereo_gains(count),
+    }
+}
+
+/// Downmix planar `channels` arriving in `order` to interleaved stereo in `out` (`out.len() / 2`
+/// frames); frames a channel is too short for count as silence, extra frames in `out` stay as
+/// they are.
+pub fn downmix_into(channels: &[Vec<f32>], order: &Order, out: &mut [f32]) {
+    for (ch, g) in channels.iter().zip(&decoded_gains(channels.len(), order)) {
         if g[0] == 0.0 && g[1] == 0.0 {
             continue;
         }
@@ -85,49 +171,105 @@ mod tests {
 
     #[test]
     fn every_channel_count_has_a_bounded_defined_matrix() {
-        for aac in [false, true] {
+        let pce = Order::Speakers([FL, FR, FC, FC, SL, SR, SL, SR, CS, LFE].into());
+        for order in [Order::Wav, Order::Aac, Order::Speakers(CONFIG_7.into()), pce] {
             for n in 0..40usize {
-                let g = stereo_gains(n, aac);
+                let g = decoded_gains(n, &order);
                 assert_eq!(g.len(), n);
                 let (l, r) = (g.iter().map(|p| p[0]).sum::<f32>(), g.iter().map(|p| p[1]).sum::<f32>());
                 if n > 2 {
-                    assert!(l <= 1.0001 && r <= 1.0001, "{n} channels (aac {aac}): {l} {r}");
+                    assert!(l <= 1.0001 && r <= 1.0001, "{n} channels ({order:?}): {l} {r}");
                     assert!(l > 0.0 && r > 0.0);
                 }
             }
         }
     }
 
+    /// AudioSpecificConfigs as ffmpeg 8.1 and FilmCraft's encoder write them (48 kHz AAC-LC).
+    const PCE_FFMPEG_61: &str = "118004c848002000c4400d4c61766336322e32382e31303256e500";
+    const PCE_FILMCRAFT_61: &str = "118004c845000108840000";
+
+    fn order(hex: &str) -> Order {
+        let asc: Vec<u8> = (0..hex.len() / 2).filter_map(|i| hex.get(2 * i..2 * i + 2).and_then(|b| u8::from_str_radix(b, 16).ok())).collect();
+        aac_order(&AudioSpecificConfig::parse(&asc).expect("an AudioSpecificConfig"))
+    }
+
+    fn speakers(order: &Order) -> Vec<Pair> {
+        match order {
+            Order::Speakers(s) => s.to_vec(),
+            o => panic!("{o:?} names no speakers"),
+        }
+    }
+
+    #[test]
+    fn aac_order_follows_the_channel_configuration() {
+        for n in [1, 2, 3, 5, 6, 11, 12] {
+            assert_eq!(aac_order(&AudioSpecificConfig::lc(3, n)), Order::Wav, "configuration {n}");
+        }
+        assert_eq!(speakers(&aac_order(&AudioSpecificConfig::lc(3, 4))), [FL, FR, FC, CS]);
+        assert_eq!(speakers(&aac_order(&AudioSpecificConfig::lc(3, 7))), [FC, FL, FR, SL, SR, SL, SR, LFE]);
+        assert_eq!(speakers(&order(PCE_FFMPEG_61)), [FL, FR, FC, LFE, CS, SL, SR], "ffmpeg's 6.1 carries the LFE in a side SCE");
+        assert_eq!(speakers(&order(PCE_FILMCRAFT_61)), [FC, FL, FR, SL, SR, CS, LFE], "a centre-first PCE by position");
+    }
+
+    #[test]
+    fn only_ffmpeg_pce_structures_it_misplaces_take_its_channel_order() {
+        let pce = |comment: &[u8], side: Vec<(bool, u8)>, lfe: Vec<u8>| ProgramConfig {
+            front: vec![(true, 0), (false, 0)],
+            side,
+            back: vec![(true, 1)],
+            lfe,
+            comment: comment.to_vec(),
+            ..Default::default()
+        };
+        // 5.1(side): ffmpeg's LFE sits in the side SCE
+        assert_eq!(pce_speakers(&pce(b"Lavc58.54.100", vec![(false, 1)], vec![])), [FL, FR, FC, LFE, SL, SR]);
+        // the same structure from another encoder: a back centre by position
+        assert_eq!(pce_speakers(&pce(b"", vec![(false, 1)], vec![])), [FL, FR, FC, CS, SL, SR]);
+        // 7.0: ffmpeg's order matches the positions
+        assert_eq!(pce_speakers(&pce(b"Lavc62.28.102", vec![(true, 2)], vec![])), [FL, FR, FC, SL, SR, SL, SR]);
+        // a real LFE element is never ffmpeg's misplaced one
+        assert_eq!(pce_speakers(&pce(b"Lavc62.28.102", vec![(false, 1)], vec![0])), [FL, FR, FC, CS, SL, SR, LFE]);
+    }
+
+    #[test]
+    fn a_decode_of_fewer_channels_takes_the_first_of_the_layout_and_more_go_by_count() {
+        assert_eq!(decoded_gains(2, &order(PCE_FILMCRAFT_61)), [FC, FL]);
+        assert_eq!(decoded_gains(7, &Order::Speakers(CONFIG_7.into())), normalised(&CONFIG_7[..7]));
+        assert_eq!(decoded_gains(9, &Order::Speakers(CONFIG_7.into())), stereo_gains(9));
+        assert_eq!(decoded_gains(4, &Order::Aac), normalised(&[FL, FR, FC, CS]));
+        assert_eq!(decoded_gains(8, &Order::Aac), normalised(&CONFIG_7));
+        for n in [3, 5, 6, 7] {
+            assert_eq!(decoded_gains(n, &Order::Aac), stereo_gains(n), "{n} channels");
+        }
+    }
+
     #[test]
     fn five_one_matches_the_bs775_matrix() {
         let k = 1.0 / (1.0 + 2.0 * FRAC_1_SQRT_2);
-        let g = stereo_gains(6, false);
+        let g = stereo_gains(6);
         assert!((g[0][0] - k).abs() < 1e-6 && g[0][1] == 0.0);
         assert!((g[2][0] - k * FRAC_1_SQRT_2).abs() < 1e-6 && (g[2][1] - k * FRAC_1_SQRT_2).abs() < 1e-6);
         assert_eq!(g[3], [0.0, 0.0], "LFE is left out");
         assert!((g[4][0] - k * FRAC_1_SQRT_2).abs() < 1e-6 && g[4][1] == 0.0);
         assert!((g[5][1] - k * FRAC_1_SQRT_2).abs() < 1e-6 && g[5][0] == 0.0);
-        // AAC order: the centre is first, LFE last
-        let a = stereo_gains(6, true);
-        assert_eq!((a[0], a[5]), (g[2], g[3]));
-        assert_eq!((a[1], a[2]), (g[0], g[1]));
     }
 
     #[test]
     fn mono_and_stereo_are_untouched_and_wide_layouts_use_the_front_pair() {
-        assert_eq!(stereo_gains(1, false), vec![[1.0, 1.0]]);
-        assert_eq!(stereo_gains(2, true), vec![FL, FR]);
-        let g = stereo_gains(12, false);
+        assert_eq!(stereo_gains(1), vec![[1.0, 1.0]]);
+        assert_eq!(stereo_gains(2), vec![FL, FR]);
+        let g = stereo_gains(12);
         assert_eq!((g[0], g[1], g[2]), (FL, FR, [0.0, 0.0]));
     }
 
     #[test]
     fn ragged_and_empty_input_never_panics() {
         let mut out = vec![0.0; 8];
-        downmix_into(&[], false, &mut out);
-        downmix_into(&[vec![1.0; 100], vec![1.0; 2], vec![], vec![1.0; 3], vec![1.0; 1], vec![1.0]], true, &mut out);
+        downmix_into(&[], &Order::Wav, &mut out);
+        downmix_into(&[vec![1.0; 100], vec![1.0; 2], vec![], vec![1.0; 3], vec![1.0; 1], vec![1.0]], &Order::Aac, &mut out);
         assert!(out.iter().all(|v| v.is_finite()));
         let mut none: [f32; 0] = [];
-        downmix_into(&vec![vec![1.0; 3]; 7], false, &mut none);
+        downmix_into(&vec![vec![1.0; 3]; 7], &Order::Speakers(CONFIG_7.into()), &mut none);
     }
 }
diff --git a/crates/media/src/exr_channels.rs b/crates/media/src/exr_channels.rs
index 8c4cb1339..d372ec849 100644
--- a/crates/media/src/exr_channels.rs
+++ b/crates/media/src/exr_channels.rs
@@ -13,6 +13,10 @@ use std::sync::{Arc, Mutex, OnceLock};
 use effectcraft_raster::AuxChannels;
 use effectcraft_raster::channels3d::{BACKGROUND_DEPTH, split_channel};
 
+/// The largest display window decoded (16384²; vector footage and Continuously Rasterize
+/// stop at the same size).
+const MAX_DISPLAY_PIXELS: usize = 1 << 28;
+
 fn is_depth(name: &str) -> bool {
     let last = name.rsplit('.').next().unwrap_or(name);
     last.eq_ignore_ascii_case("z") || name.to_ascii_lowercase().contains("depth")
@@ -75,7 +79,9 @@ pub fn read_exr_channels(bytes: &[u8]) -> Option<AuxChannels> {
         }
     };
     collect_meta(&img.attributes.other);
-    let n = w.checked_mul(h)?;
+    // Each channel is a display-window plane: a 60000² window over a 1×1 data window was a
+    // multi-gigabyte allocation per channel (#2141).
+    let n = w.checked_mul(h).filter(|n| *n <= MAX_DISPLAY_PIXELS)?;
     // The decoded image is consumed channel by channel, so each channel's samples are freed (or
     // moved) as its plane is made instead of the whole file being held twice (#474).
     for layer in img.layer_data {
@@ -183,7 +189,7 @@ fn picture_layer<'a>(aux: &AuxChannels, layers: &[&'a str]) -> Option<&'a str> {
 /// The picture of a multi-layer OpenEXR file without an unnamed RGB layer (Blender's
 /// `ViewLayer.Combined.R`, the compositor's `Image.R`, Nuke's `beauty.R`, …), which the image
 /// decoder rejects. After Effects shows a file's main RGBA channels and leaves the other layers
-/// to EXtractoR; here that is the beauty pass by name ([`BEAUTY`]), else the first colour layer
+/// to EXtractoR; here that is the beauty pass by name (`BEAUTY`), else the first colour layer
 /// that is not a data pass (never Cryptomatte, depth or normals, #412), else the first channel
 /// as grey. Linear, straight RGBA as the file stores it. `None` when it is not a readable EXR.
 pub fn layered_image(bytes: &[u8]) -> Option<image::DynamicImage> {
@@ -337,6 +343,18 @@ mod tests {
         assert_eq!(aux.get("GlossDir.R").and_then(|p| p.first()).copied(), Some(0.25));
     }
 
+    /// #2141: one pixel of data in a 60000² display window is refused, not allocated per channel.
+    #[test]
+    fn a_huge_display_window_is_refused_not_allocated() {
+        use exr::prelude::*;
+        let channels = AnyChannels::sort(vec![AnyChannel::new("R", FlatSamples::F32(vec![0.5]))].into());
+        let mut image = Image::from_layer(Layer::new((1, 1), LayerAttributes::default(), Encoding::FAST_LOSSLESS, channels));
+        image.attributes.display_window = IntegerBounds::new((0, 0), (60000, 60000));
+        let mut bytes = std::io::Cursor::new(Vec::new());
+        image.write().to_buffered(&mut bytes).unwrap();
+        assert!(read_exr_channels(&bytes.into_inner()).is_none());
+    }
+
     #[test]
     fn layered_exr_without_an_unnamed_rgb_layer_imports() {
         use exr::prelude::*;
diff --git a/crates/media/src/layered.rs b/crates/media/src/layered.rs
index 055c3feb0..b259c8b7f 100644
--- a/crates/media/src/layered.rs
+++ b/crates/media/src/layered.rs
@@ -113,6 +113,11 @@ pub(crate) fn decode(path: &str, bytes: &[u8], footage: &Footage, op: AlphaOp) -
     if is_svg(path, bytes) || is_pdf_like(path, bytes) {
         let doc = vector_doc(path, bytes, footage.layer.as_ref(), footage.page).unwrap_or(Err(String::new())).map_err(MediaError::Decode)?;
         let (w, h) = doc.pixel_size();
+        // A declared size up to 30000² would be a 14 GB allocation that aborts the app (#2136):
+        // past what Continuously Rasterize can draw, the footage reports an error instead.
+        if u64::from(w) * u64::from(h) > u64::from(MAX_VECTOR_SIDE) * u64::from(MAX_VECTOR_SIDE) {
+            return Err(MediaError::Decode(format!("{path}: {w}×{h} pixels is larger than vector footage can be drawn ({MAX_VECTOR_SIDE}×{MAX_VECTOR_SIDE})")));
+        }
         let img = effectcraft_svg::rasterize(&doc, w, h, 1.0);
         // The rasteriser produces premultiplied pixels already.
         let _ = op;
@@ -121,10 +126,32 @@ pub(crate) fn decode(path: &str, bytes: &[u8], footage: &Footage, op: AlphaOp) -
     Ok(None)
 }
 
+/// The largest side vector footage is drawn at, decoded or continuously rasterised.
+const MAX_VECTOR_SIDE: u32 = 16384;
+
 /// A vector file rasterised at `scale` × its pixel size (Continuously Rasterize).
 pub(crate) fn rasterize_vector(path: &str, bytes: &[u8], layer: Option<&effectcraft_project::SourceLayer>, page: u32, scale: f64) -> Option<Image> {
     let doc = vector_doc(path, bytes, layer, page)?.ok()?;
     let (w, h) = doc.pixel_size();
-    let (sw, sh) = (((w as f64 * scale).ceil() as u32).clamp(1, 16384), ((h as f64 * scale).ceil() as u32).clamp(1, 16384));
+    let (sw, sh) = (((w as f64 * scale).ceil() as u32).clamp(1, MAX_VECTOR_SIDE), ((h as f64 * scale).ceil() as u32).clamp(1, MAX_VECTOR_SIDE));
     Some(effectcraft_svg::rasterize(&doc, sw, sh, scale))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// #2136: an SVG that declares 30000×30000 asked for a 14 GB image and aborted the app; it
+    /// is now an error, and a drawable size still decodes.
+    #[test]
+    fn vector_footage_past_the_drawable_size_is_an_error_not_an_abort() {
+        let huge = br#"<svg xmlns="http://www.w3.org/2000/svg" width="30000" height="30000"/>"#;
+        let footage = probe("huge.svg", huge).unwrap().unwrap();
+        let e = decode("huge.svg", huge, &footage, AlphaOp::new(footage.alpha, footage.premul_color)).err().map(|e| e.to_string()).unwrap_or_default();
+        assert!(e.contains("30000×30000"), "{e}");
+        let small = br#"<svg xmlns="http://www.w3.org/2000/svg" width="40" height="20"><rect width="40" height="20"/></svg>"#;
+        let footage = probe("small.svg", small).unwrap().unwrap();
+        let img = decode("small.svg", small, &footage, AlphaOp::new(footage.alpha, footage.premul_color)).unwrap().unwrap();
+        assert_eq!((img.width, img.height), (40, 20));
+    }
+}
diff --git a/crates/media/src/lib.rs b/crates/media/src/lib.rs
index 9b5b491ab..e985985b7 100644
--- a/crates/media/src/lib.rs
+++ b/crates/media/src/lib.rs
@@ -15,6 +15,7 @@
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
+mod aac;
 mod convert;
 pub mod downmix;
 mod dpx;
@@ -25,6 +26,7 @@ pub use layered::vector_doc;
 mod pool;
 mod probe;
 mod stream;
+mod wav_markers;
 mod webp_anim;
 
 pub use pool::{DEFAULT_BUDGET, MediaPool, PoolStats};
@@ -63,8 +65,7 @@ pub const STILL_EXTENSIONS: &[&str] =
     &["png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "exr", "tga", "hdr", "psd", "psb", "svg", "pdf", "ai", "eps"];
 /// File extensions recognised as audio-only files.
 pub const AUDIO_EXTENSIONS: &[&str] = filmcraft_media::AUDIO_EXTENSIONS;
-/// File extensions recognised as movies.
-pub const VIDEO_EXTENSIONS: &[&str] = &["mp4", "m4v", "mov", "mkv", "webm", "mxf"];
+pub use effectcraft_project::VIDEO_EXTENSIONS;
 
 /// File extensions recognised as 3D models (Advanced 3D model layers).
 pub const MODEL_EXTENSIONS: &[&str] = &["gltf", "glb", "obj", "stl", "fbx"];
@@ -79,6 +80,22 @@ pub fn is_importable(path: &std::path::Path) -> bool {
         || dpx::EXTENSIONS.contains(&ext.as_str())
 }
 
+/// A whole file's bytes, refusing anything that isn't a regular file: a project can name
+/// `/dev/zero` or a FIFO as footage, and reading those never ends (#2134).
+pub(crate) fn read_regular_file(path: &std::path::Path) -> std::io::Result<Vec<u8>> {
+    use std::io::Read;
+    let mut file = std::fs::File::open(path)?;
+    let meta = file.metadata()?;
+    if !meta.is_file() {
+        return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, format!("{} is not a file", path.display())));
+    }
+    let mut bytes = Vec::new();
+    // A sparse file can claim far more than memory: an error, not an abort.
+    bytes.try_reserve_exact(usize::try_from(meta.len()).unwrap_or(usize::MAX)).map_err(|e| std::io::Error::new(std::io::ErrorKind::OutOfMemory, e))?;
+    file.read_to_end(&mut bytes)?;
+    Ok(bytes)
+}
+
 pub(crate) fn ext_of(path: &std::path::Path) -> String {
     path.extension().and_then(std::ffi::OsStr::to_str).unwrap_or("").to_ascii_lowercase()
 }
@@ -99,3 +116,20 @@ pub(crate) fn still_format(path: &str, bytes: &[u8]) -> Option<image::ImageForma
 pub(crate) fn rate_from_fc(r: filmcraft_time::FrameRate) -> effectcraft_time::FrameRate {
     if r.num > 0 && r.den > 0 { effectcraft_time::FrameRate::new(r.num, r.den) } else { effectcraft_time::FrameRate::FPS_30 }
 }
+
+#[cfg(test)]
+mod read_tests {
+    /// #2134: a folder (and on Unix a device) named as footage is an error, not an endless read.
+    #[test]
+    fn only_regular_files_are_read_whole() {
+        let dir = std::env::temp_dir();
+        assert!(super::read_regular_file(&dir).is_err());
+        assert!(crate::probe::probe(&dir).is_err(), "probing a folder fails instead of reading it");
+        #[cfg(unix)]
+        assert!(super::read_regular_file(std::path::Path::new("/dev/zero")).is_err());
+        let f = dir.join(format!("ec-read-regular-{}.bin", std::process::id()));
+        std::fs::write(&f, b"abc").unwrap();
+        assert_eq!(super::read_regular_file(&f).unwrap(), b"abc");
+        let _ = std::fs::remove_file(f);
+    }
+}
diff --git a/crates/media/src/pool.rs b/crates/media/src/pool.rs
index 7f602465d..655ca4ed8 100644
--- a/crates/media/src/pool.rs
+++ b/crates/media/src/pool.rs
@@ -12,6 +12,7 @@ use filmcraft_media::{FrameRequest, SharedSource};
 use image::metadata::Orientation;
 
 use crate::convert::{AlphaOp, dynamic_to_image, frame_to_image_in, frame_to_image_scaled, turned};
+use crate::downmix::Order;
 use crate::gif_anim::{self, Anim};
 use crate::{MediaError, Result};
 
@@ -67,6 +68,10 @@ const CONFORM_VERSION: u32 = 3;
 /// conform thread allocate all of it at once (#408).
 const MAX_CONFORM_SECONDS: i64 = 24 * 3600;
 
+/// The sample rates audio is read at; a header outside them is damaged or hostile (#2141).
+const MIN_SAMPLE_RATE: u32 = 1_000;
+const MAX_SAMPLE_RATE: u32 = 768_000;
+
 /// The sample frames of `footage`'s audio at `rate` Hz that a conformed file holds, `None` past
 /// [`MAX_CONFORM_SECONDS`].
 #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
@@ -174,10 +179,36 @@ struct CacheState {
     last: HashMap<Arc<str>, i64>,
 }
 
-/// A movie/audio source by path and the turn its picture is shown with
-/// ([`crate::probe::video_turn`]), opened by the first caller while the others wait for it
-/// (`None`: failed to open; not retried until `forget`).
-type SourceSlot = Arc<OnceLock<Option<(SharedSource, Orientation)>>>;
+/// A movie/audio source by path ([`Opened`]), opened by the first caller while the others wait
+/// for it (`None`: failed to open; not retried until `forget`).
+type SourceSlot = Arc<OnceLock<Option<Opened>>>;
+
+/// An opened movie/audio source, the turn its picture is shown with and the order its decoded
+/// audio channels arrive in.
+#[derive(Clone)]
+struct Opened {
+    src: SharedSource,
+    turn: Orientation,
+    order: Order,
+}
+
+impl Opened {
+    /// `src` with what its container says: `header` is an MP4/MOV's ftyp and moov (or the whole
+    /// file), `file` the file for other containers' AAC configuration.
+    fn new(src: SharedSource, header: Option<&[u8]>, file: Option<&dyn filmcraft_media::ByteReader>) -> Opened {
+        let turn = header.map_or(Orientation::NoTransforms, crate::probe::video_turn);
+        Opened { order: channel_order(&src, header, file), src, turn }
+    }
+}
+
+/// The order `src`'s audio channels decode in; multichannel AAC's by its configuration, where
+/// the container's header shows it ([`crate::aac::config`]).
+fn channel_order(src: &SharedSource, header: Option<&[u8]>, file: Option<&dyn filmcraft_media::ByteReader>) -> Order {
+    match src.info().audio() {
+        Some(a) if a.codec.contains("AAC") && a.channels > 2 => crate::aac::config(header, file).map_or(Order::Aac, |asc| crate::downmix::aac_order(&asc)),
+        _ => Order::Wav,
+    }
+}
 
 /// An animated GIF by path, as [`SourceSlot`] (the error message when it failed to load).
 type GifSlot = Arc<OnceLock<std::result::Result<Arc<Anim>, String>>>;
@@ -388,7 +419,7 @@ impl MediaPool {
     }
 
     /// The conformed-audio file of `path` at `rate` (named by a hash of the path, size and
-    /// modification time, so an edited file conforms again, and of [`CONFORM_VERSION`]).
+    /// modification time, so an edited file conforms again, and of `CONFORM_VERSION`).
     pub fn conformed_path(&self, path: &str, rate: u32) -> Option<std::path::PathBuf> {
         use std::hash::{Hash, Hasher};
         let folder = lock(&self.inner.conform).clone()?;
@@ -510,18 +541,23 @@ impl MediaPool {
     /// [`MediaPool::decode_audio`], failing when the source can't be opened or read.
     fn try_decode_audio(&self, footage: &Footage, start: Tick, frames: usize, rate: u32) -> std::result::Result<Vec<f32>, String> {
         let path: Arc<str> = footage.path.as_str().into();
-        let src = self.inner.source(&path).ok_or("the file can't be opened")?;
+        let Opened { src, order, .. } = self.inner.opened(&path).ok_or("the file can't be opened")?;
         let s0 = start.to_units_floor(rate as i64);
-        let native = src.info().audio.as_ref().map_or(rate, |a| a.sample_rate);
+        let native = src.info().audio().map_or(rate, |a| a.sample_rate);
+        // The header's rate scales the samples read: 0xFFFFFFFF Hz made one conform chunk about
+        // 47 GB (#2141). Real audio is 1–768 kHz.
+        if native != 0 && !(MIN_SAMPLE_RATE..=MAX_SAMPLE_RATE).contains(&native) {
+            return Err(format!("a sample rate of {native} Hz is outside {MIN_SAMPLE_RATE}–{MAX_SAMPLE_RATE} Hz"));
+        }
         if native == 0 || rate == 0 || native == rate {
-            return read_stereo(&src, s0, frames, rate);
+            return read_stereo(&src, &order, s0, frames, rate);
         }
         // Output sample `n` sits at source position n × native / rate.
         let (native_i, rate_i) = (i128::from(native), i128::from(rate));
         let first = (i128::from(s0) * native_i).div_euclid(rate_i);
         let last = ((i128::from(s0) + frames as i128) * native_i).div_euclid(rate_i) + 1;
         let (Ok(first64), Ok(count)) = (i64::try_from(first), usize::try_from(last - first + 1)) else { return Ok(vec![0.0; frames * 2]) };
-        let buf = read_stereo(&src, first64, count, native)?;
+        let buf = read_stereo(&src, &order, first64, count, native)?;
         let mut out = Vec::with_capacity(frames * 2);
         for k in 0..frames as i128 {
             let pos = (i128::from(s0) + k) * native_i;
@@ -581,20 +617,15 @@ impl Inner {
         if let Some(b) = lock(&self.files).get(path) {
             return Ok(b.clone());
         }
-        std::fs::read(path).map(Into::into).map_err(|e| MediaError::Io(format!("{path}: {e}")))
+        crate::read_regular_file(std::path::Path::new(path)).map(Into::into).map_err(|e| MediaError::Io(format!("{path}: {e}")))
     }
 
-    /// The opened movie/audio source for `path`. The first caller opens it, outside the map's
-    /// lock (reading and parsing a large file takes a moment; FLAC, MP3, Ogg and AIFF files are
-    /// decoded whole); callers asking for the same file meanwhile wait for that instead of opening
-    /// it again: a preview's frame workers, audio feeder, conform and waveform threads each
-    /// decoded a long FLAC in full at once (#408).
-    fn source(&self, path: &Arc<str>) -> Option<SharedSource> {
-        self.opened(path).map(|(src, _)| src)
-    }
-
-    /// [`Self::source`] and the turn the movie's picture is shown with.
-    fn opened(&self, path: &Arc<str>) -> Option<(SharedSource, Orientation)> {
+    /// The opened movie/audio source for `path` ([`Opened`]). The first caller opens it, outside
+    /// the map's lock (reading and parsing a large file takes a moment; FLAC, MP3, Ogg and AIFF
+    /// files are decoded whole); callers asking for the same file meanwhile wait for that instead
+    /// of opening it again: a preview's frame workers, audio feeder, conform and waveform threads
+    /// each decoded a long FLAC in full at once (#408).
+    fn opened(&self, path: &Arc<str>) -> Option<Opened> {
         let slot = lock(&self.sources).entry(path.clone()).or_default().clone();
         slot.get_or_init(|| {
             self.opened.fetch_add(1, Ordering::Relaxed);
@@ -604,14 +635,14 @@ impl Inner {
             let file = std::path::Path::new(&**path);
             let in_place = if in_memory { None } else { crate::stream::open_source(file) };
             let in_place = in_place.map(|src| {
-                let turn = crate::stream::movie_header(file).map_or(Orientation::NoTransforms, |h| crate::probe::video_turn(&h));
-                src.map(|src| (src, turn))
+                let (header, reader) = (crate::stream::movie_header(file), crate::stream::file_reader(file));
+                src.map(|src| Opened::new(src, header.as_deref(), reader.as_deref()))
             });
             let opened = in_place.unwrap_or_else(|| {
                 self.read(path).and_then(|bytes| {
                     let name = std::path::Path::new(&**path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();
-                    let turn = crate::probe::video_turn(&bytes);
-                    filmcraft_codecs::open_bytes(&name, bytes).map(|src| (src, turn)).map_err(MediaError::from)
+                    let src = filmcraft_codecs::open_bytes(&name, bytes.clone()).map_err(MediaError::from)?;
+                    Ok(Opened::new(src, Some(&bytes), Some(&filmcraft_media::reader::MemReader(bytes.clone()))))
                 })
             });
             match opened {
@@ -703,9 +734,12 @@ impl Inner {
                 let rate = footage.frame_rate;
                 let n = Self::frame_count(rate, footage.duration);
                 let i = Self::frame_index(rate, t, n, footage.loop_count);
-                // Middle of the frame in the file's own timing (robust to timestamp rounding).
+                // A quarter into the frame in the file's own timing: FilmCraft rounds a request to
+                // the track's nearest timestamp unit (halves up), so the middle of a frame would
+                // land on the next one when the timescale is the frame rate; a quarter still
+                // tolerates timestamps rounded either way.
                 let native = footage.native_rate.unwrap_or(rate);
-                let mt = native.tick_of(i) + Tick(native.frame_duration().0 / 2);
+                let mt = native.tick_of(i) + Tick(native.frame_duration().0 / 4);
                 Loc { key: key(&footage.path, i), media_t: Some(mt), float }
             }
         }
@@ -842,7 +876,7 @@ impl Inner {
                 Ok(dynamic_to_image(frame, op))
             }
             Some(mt) => {
-                let (src, turn) = self.opened(path).ok_or_else(|| MediaError::Io(format!("{path}: cannot open")))?;
+                let Opened { src, turn, .. } = self.opened(path).ok_or_else(|| MediaError::Io(format!("{path}: cannot open")))?;
                 let vf = src
                     .video_frame(FrameRequest::full(filmcraft_time::Tick(mt.0)))
                     .map_err(MediaError::from)
@@ -941,8 +975,8 @@ impl FootageSource for MediaPool {
 
 /// `frames` stereo sample frames (interleaved) of `src` from sample `s0` at `rate` Hz, which
 /// FilmCraft serves as decoded when it is the source's own rate. Mono is duplicated to both
-/// channels, multichannel sources are downmixed ([`crate::downmix`]); silence before the start. An error where decoding fails.
-fn read_stereo(src: &SharedSource, s0: i64, frames: usize, rate: u32) -> std::result::Result<Vec<f32>, String> {
+/// channels, multichannel sources (channels in `order`) are downmixed ([`crate::downmix`]); silence before the start. An error where decoding fails.
+fn read_stereo(src: &SharedSource, order: &Order, s0: i64, frames: usize, rate: u32) -> std::result::Result<Vec<f32>, String> {
     let mut out = vec![0.0; frames * 2];
     let skip = usize::try_from(s0.saturating_neg()).unwrap_or(0);
     if skip >= frames {
@@ -950,8 +984,7 @@ fn read_stereo(src: &SharedSource, s0: i64, frames: usize, rate: u32) -> std::re
     }
     let buf = src.audio(s0.max(0), frames - skip, rate).map_err(|e| e.to_string())?;
     let Some(dst) = skip.checked_mul(2).and_then(|i| out.get_mut(i..)) else { return Ok(out) };
-    let aac = src.info().audio.as_ref().is_some_and(|a| a.codec.starts_with("AAC"));
-    crate::downmix::downmix_into(&buf.channels, aac, dst);
+    crate::downmix::downmix_into(&buf.channels, order, dst);
     Ok(out)
 }
 
@@ -1218,8 +1251,8 @@ mod tests {
         assert_eq!(px(&f, FloatCurve::Gamma24), g24);
     }
 
-    /// A model's material library is read beside it; one named by a path to another computer
-    /// is not read.
+    /// A model's material library is read beside it; one named by a path to another computer is
+    /// looked up under its own file name beside the model, never fetched from that machine (#1274).
     #[test]
     fn model_files_on_other_computers_are_not_read() {
         let dir = std::env::temp_dir().join(format!("ec-model-files-{}", std::process::id()));
@@ -1233,11 +1266,13 @@ mod tests {
             model.materials.iter().any(|m| m.base_color[..3] == [1.0, 0.0, 0.0])
         };
         assert!(red("beside.obj", "red.mtl"));
-        assert!(!red("unc.obj", r"\\192.0.2.1\share\red.mtl"));
-        assert!(!red("url.obj", "file://192.0.2.1/s/red.mtl"));
+        // 192.0.2.1 is a test-net address nothing here can reach, so these passes prove the
+        // material library came from beside the model, not from another computer.
+        assert!(red("unc.obj", r"\\192.0.2.1\share\red.mtl"));
+        assert!(red("url.obj", "file://192.0.2.1/s/red.mtl"));
         // Linux reads `//dir/red.mtl` as the local file.
         #[cfg(unix)]
-        assert!(!red("slashes.obj", &format!("/{}", dir.join("red.mtl").display())));
+        assert!(red("slashes.obj", &format!("/{}", dir.join("red.mtl").display())));
         let _ = std::fs::remove_dir_all(&dir);
     }
 }
diff --git a/crates/media/src/probe.rs b/crates/media/src/probe.rs
index 6bba682b3..6bae86f5b 100644
--- a/crates/media/src/probe.rs
+++ b/crates/media/src/probe.rs
@@ -23,9 +23,10 @@ pub fn probe(path: impl AsRef<Path>) -> Result<Footage> {
         let turn = header.as_deref().map_or(Orientation::NoTransforms, video_turn);
         turn_footage(&mut f, turn);
         correct_rate(&mut f, header.as_deref().and_then(video_rate));
+        trim_to_edits(&mut f, header.as_deref().and_then(video_shown));
         return Ok(f);
     }
-    let bytes = std::fs::read(path).map_err(|e| MediaError::Io(format!("{}: {e}", path.display())))?;
+    let bytes = crate::read_regular_file(path).map_err(|e| MediaError::Io(format!("{}: {e}", path.display())))?;
     if crate::MODEL_EXTENSIONS.contains(&ext_of(path).as_str()) {
         return probe_model(&path.to_string_lossy(), &bytes, &side_file_reader(path));
     }
@@ -38,7 +39,7 @@ fn side_file_reader(model: &Path) -> impl Fn(&str) -> Option<Vec<u8>> + use<> {
     let model = std::path::absolute(model).unwrap_or_else(|_| model.to_path_buf());
     move |uri| {
         let p = craft_docpath::resolve_absolute(uri, Some(&model)).ok()?;
-        std::fs::read(p).ok()
+        crate::read_regular_file(&p).ok()
     }
 }
 
@@ -107,13 +108,45 @@ pub fn probe_bytes(path: &str, bytes: Arc<[u8]>) -> Result<Footage> {
     let name = Path::new(path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| path.to_string());
     let turn = video_turn(&bytes);
     let rate = video_rate(&bytes);
+    let shown = video_shown(&bytes);
+    // A WAV's cue points and XMP markers become the footage's markers.
+    let markers = crate::wav_markers::read(&bytes);
     let src = filmcraft_codecs::open_bytes(&name, bytes)?;
     let mut f = footage_from_info(path, src.info());
+    f.markers = markers;
     turn_footage(&mut f, turn);
     correct_rate(&mut f, rate);
+    trim_to_edits(&mut f, shown);
     Ok(f)
 }
 
+/// A movie lasts as long as its video edit list shows (#2592): the reader reports the media
+/// duration (`mdhd`), which for H.264 with B-frames runs past the last shown frame by the
+/// encoder delay the edit list trims (75 frames at 25 fps read as 3.04 s). Never lengthens.
+fn trim_to_edits(f: &mut Footage, shown: Option<Tick>) {
+    if f.kind == FootageKind::Video
+        && let Some(shown) = shown.filter(|s| *s > Tick::ZERO && *s < f.duration)
+    {
+        f.duration = shown;
+    }
+}
+
+/// How long the video track's edit list shows its media (`elst` segments, movie timescale):
+/// `None` without edits, or with an empty edit (a delayed start keeps the reader's duration).
+fn video_shown(bytes: &[u8]) -> Option<Tick> {
+    let file = filmcraft_isobmff::open(bytes).ok()?;
+    let t = file.tracks.iter().find(|t| t.kind == filmcraft_isobmff::TrackKind::Video && !t.samples.is_empty())?;
+    edits_shown(&t.edits, file.timescale)
+}
+
+fn edits_shown(edits: &[filmcraft_isobmff::Edit], timescale: u32) -> Option<Tick> {
+    if edits.is_empty() || timescale == 0 || edits.iter().any(|e| e.media_time < 0) {
+        return None;
+    }
+    let units = edits.iter().try_fold(0u64, |acc, e| acc.checked_add(e.segment_duration))?;
+    Some(Tick::from_units(i64::try_from(units).ok()?, i64::from(timescale)))
+}
+
 /// A movie's frame rate as its frame durations average to ([`video_rate`]), where the reader's
 /// own estimate misreads it.
 fn correct_rate(f: &mut Footage, rate: Option<FrameRate>) {
@@ -142,7 +175,7 @@ pub(crate) fn footage_from_info(path: &str, info: &filmcraft_media::MediaInfo) -
         (_, None) => FootageKind::Audio,
     };
     let rate = v.map_or(FrameRate::FPS_30, |v| rate_from_fc(v.frame_rate));
-    let codec = match (v, info.audio.as_ref()) {
+    let codec = match (v, info.audio()) {
         (Some(v), _) => v.codec.clone(),
         (None, Some(a)) => a.codec.clone(),
         _ => String::new(),
@@ -157,7 +190,7 @@ pub(crate) fn footage_from_info(path: &str, info: &filmcraft_media::MediaInfo) -
         native_rate: None,
         duration: if kind == FootageKind::Still { Tick::ZERO } else { Tick(info.duration.0) },
         has_video: v.is_some(),
-        has_audio: info.audio.is_some(),
+        has_audio: info.has_audio(),
         alpha: if v.is_some_and(|v| v.has_alpha) { AlphaMode::Straight } else { AlphaMode::Ignore },
         premul_color: [0.0; 3],
         loop_count: 1,
@@ -262,12 +295,19 @@ pub(crate) fn load_oriented(bytes: &[u8], fmt: Option<image::ImageFormat>) -> im
 /// The rotation an MP4/MOV movie is shown with (a phone held upright records sideways frames and
 /// says so in its video track's header): the quarter turn nearest the track's rotation. Only the
 /// rotation counts; any mirroring, scaling or offset in the header is ignored, and other
-/// containers have none.
+/// containers have none. FilmCraft turns the frames of a pure 0/90/180/270° header itself, so this
+/// is only the quarter turn nearest to a header it does not turn.
 pub(crate) fn video_turn(bytes: &[u8]) -> Orientation {
     let Ok(file) = filmcraft_isobmff::open(bytes) else { return Orientation::NoTransforms };
-    let Some(m) = file.tracks.iter().find(|t| t.kind == filmcraft_isobmff::TrackKind::Video).map(|t| t.matrix) else {
+    let Some(track) = file.tracks.iter().find(|t| t.kind == filmcraft_isobmff::TrackKind::Video) else {
         return Orientation::NoTransforms;
     };
+    // A pure rotation is already applied by FilmCraft's decoder (frames and size come out
+    // upright); only the headers it leaves as stored (mirrored, scaled, sheared) are turned here.
+    if track.display_rotation().is_some() {
+        return Orientation::NoTransforms;
+    }
+    let m = track.matrix;
     // [a b u; c d v; x y w]: (a, b) is where the picture's x axis points.
     let (a, b) = (m[0] as i64, m[1] as i64);
     match (a.abs() >= b.abs(), a >= 0, b >= 0) {
@@ -319,6 +359,24 @@ fn averaged_rate(timescale: u32, durations: impl Iterator<Item = u32>) -> Option
 mod tests {
     use super::*;
 
+    /// #2592: an encoder-delayed H.264 track's edit list shows 75 frames at 25 fps (3 s at a
+    /// 1000 timescale), though its media runs a frame longer; empty edits and no edits leave it.
+    #[test]
+    fn the_edit_list_trims_a_movie_to_the_frames_it_shows() {
+        let edit = |segment_duration, media_time| filmcraft_isobmff::Edit { segment_duration, media_time, media_rate: 0x0001_0000 };
+        let shown = edits_shown(&[edit(3000, 1024)], 1000);
+        assert_eq!(shown, Some(Tick::from_units(3, 1)));
+        let mut f = Footage { kind: FootageKind::Video, duration: Tick::from_units(76, 25), ..Footage::default() };
+        trim_to_edits(&mut f, shown);
+        assert_eq!(f.duration, Tick::from_units(75, 25));
+        // Never longer than the reader's duration, and only for video.
+        trim_to_edits(&mut f, Some(Tick::from_units(4, 1)));
+        assert_eq!(f.duration, Tick::from_units(75, 25));
+        assert_eq!(edits_shown(&[edit(1000, -1), edit(3000, 0)], 1000), None);
+        assert_eq!(edits_shown(&[], 1000), None);
+        assert_eq!(edits_shown(&[edit(3000, 0)], 0), None);
+    }
+
     /// Durations (in 1/`timescale` s) of `n` frames at `rate` whose times are rounded to the timescale.
     fn rounded(rate: FrameRate, timescale: i64, n: i64) -> Vec<u32> {
         let at = |k: i64| (2 * k * timescale * rate.den + rate.num) / (2 * rate.num);
diff --git a/crates/media/src/stream.rs b/crates/media/src/stream.rs
index 447e239d1..80db21fc4 100644
--- a/crates/media/src/stream.rs
+++ b/crates/media/src/stream.rs
@@ -85,6 +85,17 @@ pub(crate) fn open_source(_path: &Path) -> Option<Result<SharedSource>> {
     None
 }
 
+/// `path` read in place (`None` when it can't be opened, or without a native file system).
+#[cfg(any(unix, windows))]
+pub(crate) fn file_reader(path: &Path) -> Option<Box<dyn filmcraft_media::ByteReader>> {
+    Some(Box::new(FileReader::open(path).ok()?))
+}
+
+#[cfg(not(any(unix, windows)))]
+pub(crate) fn file_reader(_path: &Path) -> Option<Box<dyn filmcraft_media::ByteReader>> {
+    None
+}
+
 /// The leading `ftyp` and the `moov` box of an ISO-BMFF movie on disk (all a track's display
 /// matrix needs), without reading the samples: top-level box headers are walked with positional
 /// reads. `None` when the file isn't ISO-BMFF or its `moov` is missing or implausibly large.
diff --git a/crates/media/src/wav_markers.rs b/crates/media/src/wav_markers.rs
new file mode 100644
index 000000000..ca40824b6
--- /dev/null
+++ b/crates/media/src/wav_markers.rs
@@ -0,0 +1,517 @@
+//! Markers a WAV file carries, read from its RIFF chunks.
+//!
+//! Two encodings are read and merged:
+//! - **Cue points** (the standard): a `cue ` chunk with one point per marker, named by `labl` (or
+//!   `note`) sub-chunks of a `LIST` `adtl` chunk, and given a length by `ltxt`.
+//! - **XMP** (Adobe's tools): an `_PMX` chunk holding an XMP packet whose `xmpDM:markers` list has
+//!   one entry per marker (`xmpDM:startTime`, `xmpDM:duration`, `xmpDM:name`), counted in frames
+//!   of `xmpDM:frameRate` (`f44100` for samples at 44.1 kHz).
+//!
+//! RF64 files (WAVs over 4 GB) carry a `0xFFFFFFFF` size for a chunk too big for 32 bits and give its real size in a
+//! `ds64` chunk; those sizes are resolved so the chunks after the audio are still found.
+//!
+//! The file is untrusted input: every read is bounds-checked, sizes use checked arithmetic, and
+//! the number of markers, of `adtl` sub-chunks looked at and the size of the XMP packet are capped.
+
+use std::collections::{HashMap, HashSet};
+
+use effectcraft_color::Label;
+use effectcraft_project::Marker;
+use effectcraft_time::Tick;
+
+/// Most markers read from one file.
+pub const MAX_MARKERS: usize = 10_000;
+/// Largest XMP packet read (bytes).
+const MAX_XMP: usize = 4 << 20;
+/// Most `adtl` sub-chunks (`labl`, `note`, `ltxt`) looked at in one file: a few per cue point is plenty.
+const MAX_ADTL_RECORDS: usize = 4 * MAX_MARKERS;
+/// Most entries read from an RF64 file's `ds64` size table.
+const MAX_DS64_TABLE: usize = 1_024;
+
+fn u32_at(b: &[u8], at: usize) -> Option<u32> {
+    let s = b.get(at..at.checked_add(4)?)?;
+    Some(u32::from_le_bytes(s.try_into().ok()?))
+}
+
+fn u64_at(b: &[u8], at: usize) -> Option<u64> {
+    let s = b.get(at..at.checked_add(8)?)?;
+    Some(u64::from_le_bytes(s.try_into().ok()?))
+}
+
+/// The text of a NUL-terminated label (the rest of the chunk), lossily decoded.
+fn label(b: &[u8]) -> String {
+    let end = b.iter().position(|&c| c == 0).unwrap_or(b.len());
+    String::from_utf8_lossy(b.get(..end).unwrap_or_default()).trim().to_string()
+}
+
+fn secs(frames: f64, rate: f64) -> Tick {
+    if rate > 0.0 && frames.is_finite() { Tick::from_seconds_f64((frames / rate).max(0.0)) } else { Tick::ZERO }
+}
+
+/// Whether `bytes` start a RIFF/WAVE file.
+pub fn is_wav(bytes: &[u8]) -> bool {
+    matches!(bytes.get(0..4), Some(b"RIFF" | b"RF64")) && bytes.get(8..12) == Some(b"WAVE")
+}
+
+/// The sizes an RF64 file's `ds64` chunk gives for chunks too big for the 32-bit size field.
+struct Ds64 {
+    /// The `data` chunk's size.
+    data: u64,
+    /// Other chunks: `(id, size)`.
+    table: Vec<([u8; 4], u64)>,
+}
+
+impl Ds64 {
+    /// The real size of chunk `id`, when the file says.
+    fn size_of(&self, id: &[u8; 4]) -> Option<u64> {
+        if id == b"data" { Some(self.data) } else { self.table.iter().find(|(t, _)| t == id).map(|(_, size)| *size) }
+    }
+}
+
+/// The `ds64` chunk of an RF64 file (`RF64`, size, `WAVE`, then `ds64`); `None` for any other file or one whose
+/// `ds64` doesn't fit.
+fn ds64(bytes: &[u8]) -> Option<Ds64> {
+    if bytes.get(0..4) != Some(b"RF64") || bytes.get(12..16) != Some(b"ds64") {
+        return None;
+    }
+    let size = usize::try_from(u32_at(bytes, 16)?).ok()?;
+    let body = bytes.get(20..20usize.checked_add(size)?)?;
+    // riff size (8), data size (8), sample count (8), table length (4), then `(id, size)` entries of 12 bytes
+    let data = u64_at(body, 8)?;
+    let entries = usize::try_from(u32_at(body, 24)?).ok()?;
+    let mut table = Vec::new();
+    for i in 0..entries.min(MAX_DS64_TABLE) {
+        let at = 28usize.checked_add(i.checked_mul(12)?)?;
+        let id = <[u8; 4]>::try_from(body.get(at..at.checked_add(4)?)?).ok()?;
+        table.push((id, u64_at(body, at + 4)?));
+    }
+    Some(Ds64 { data, table })
+}
+
+/// The chunks of a WAVE file as `(id, body)`, stopping at the first one that doesn't fit.
+fn chunks(bytes: &[u8]) -> Vec<([u8; 4], &[u8])> {
+    let big = ds64(bytes);
+    let mut out = Vec::new();
+    let mut at = 12usize;
+    while let Some(head) = bytes.get(at..at.saturating_add(8)) {
+        let (Ok(id), Some(field)) = (<[u8; 4]>::try_from(&head[..4]), u32_at(head, 4)) else { break };
+        // In an RF64 file a size field of 0xFFFFFFFF stands for the size `ds64` gives.
+        let size = match &big {
+            Some(d) if field == u32::MAX => d.size_of(&id).unwrap_or(u64::from(field)),
+            _ => u64::from(field),
+        };
+        let start = at.saturating_add(8);
+        let Some(end) = usize::try_from(size).ok().and_then(|n| start.checked_add(n)) else { break };
+        let Some(body) = bytes.get(start..end) else { break };
+        out.push((id, body));
+        // Chunks are padded to an even size.
+        at = end.saturating_add(end & 1);
+    }
+    out
+}
+
+/// The markers `bytes` carry, in time order (empty for anything that isn't a WAV with markers).
+pub fn read(bytes: &[u8]) -> Vec<Marker> {
+    if !is_wav(bytes) {
+        return Vec::new();
+    }
+    let chunks = chunks(bytes);
+    let rate = chunks.iter().find(|(id, _)| id == b"fmt ").and_then(|(_, b)| u32_at(b, 4)).map_or(0.0, f64::from);
+    let mut out = cue_markers(&chunks, rate);
+    if let Some((_, xmp)) = chunks.iter().find(|(id, _)| id == b"_PMX") {
+        // Tools that write both encodings repeat each marker.
+        let mut seen: HashSet<(String, Tick)> = out.iter().map(|o| (o.comment.clone(), o.time)).collect();
+        for m in xmp_markers(xmp, rate) {
+            if seen.insert((m.comment.clone(), m.time)) {
+                out.push(m);
+            }
+        }
+    }
+    out.truncate(MAX_MARKERS);
+    out.sort_by_key(|m| m.time);
+    out
+}
+
+/// Cue points named and sized by the `adtl` list.
+fn cue_markers(chunks: &[([u8; 4], &[u8])], rate: f64) -> Vec<Marker> {
+    let Some((_, cue)) = chunks.iter().find(|(id, _)| id == b"cue ") else { return Vec::new() };
+    let count = (u32_at(cue, 0).unwrap_or(0) as usize).min(MAX_MARKERS);
+    // The cue points first: `(id, offset in samples)`.
+    let mut points = Vec::new();
+    for i in 0..count {
+        let Some(point) = cue.get(4usize.saturating_add(i.saturating_mul(24))..) else { break };
+        let (Some(id), Some(offset)) = (u32_at(point, 0), u32_at(point, 20)) else { break };
+        points.push((id, offset));
+    }
+    // Only the names and lengths of those ids are kept, so a hostile `adtl` list cannot grow them past the cue count,
+    // and each record is a lookup, not a scan.
+    let wanted: HashSet<u32> = points.iter().map(|(id, _)| *id).collect();
+    let mut names: HashMap<u32, String> = HashMap::new();
+    let mut lengths: HashMap<u32, u32> = HashMap::new();
+    let mut records = 0usize;
+    'lists: for (_, list) in chunks.iter().filter(|(id, b)| id == b"LIST" && b.get(0..4) == Some(b"adtl")) {
+        let mut at = 4usize;
+        while let Some(head) = list.get(at..at.saturating_add(8)) {
+            let (Ok(id), Some(size)) = (<[u8; 4]>::try_from(&head[..4]), u32_at(head, 4)) else { break };
+            let start = at.saturating_add(8);
+            let Some(end) = start.checked_add(size as usize) else { break };
+            let Some(body) = list.get(start..end) else { break };
+            records += 1;
+            if records > MAX_ADTL_RECORDS {
+                break 'lists;
+            }
+            if let Some(cue_id) = u32_at(body, 0).filter(|c| wanted.contains(c)) {
+                match &id {
+                    // A `labl` is the name; a `note` only when there is none.
+                    b"labl" => {
+                        names.insert(cue_id, label(body.get(4..).unwrap_or_default()));
+                    }
+                    b"note" => {
+                        names.entry(cue_id).or_insert_with(|| label(body.get(4..).unwrap_or_default()));
+                    }
+                    // The first `ltxt` of a cue point gives its length.
+                    b"ltxt" => {
+                        lengths.entry(cue_id).or_insert_with(|| u32_at(body, 4).unwrap_or(0));
+                    }
+                    _ => {}
+                }
+            }
+            at = end.saturating_add(end & 1);
+        }
+    }
+    points
+        .into_iter()
+        .map(|(id, offset)| {
+            let comment = names.get(&id).cloned().unwrap_or_default();
+            let length = lengths.get(&id).copied().unwrap_or(0);
+            Marker { time: secs(f64::from(offset), rate), duration: secs(f64::from(length), rate), comment, label: Label::None, ..Default::default() }
+        })
+        .collect()
+}
+
+/// The text of `name` in an XMP entry, as an attribute (`name="v"`) or an element
+/// (`<name>v</name>`).
+fn xmp_value(entry: &str, name: &str) -> Option<String> {
+    let attr = format!("{name}=\"");
+    if let Some(i) = entry.find(&attr) {
+        let rest = entry.get(i + attr.len()..)?;
+        return Some(unescape(rest.get(..rest.find('"')?)?));
+    }
+    let open = format!("<{name}>");
+    let i = entry.find(&open)?;
+    let rest = entry.get(i + open.len()..)?;
+    Some(unescape(rest.get(..rest.find('<')?)?))
+}
+
+fn unescape(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    let mut rest = s;
+    while let Some(i) = rest.find('&') {
+        out.push_str(rest.get(..i).unwrap_or_default());
+        let tail = rest.get(i..).unwrap_or_default();
+        let Some(semi) = tail.find(';').filter(|&n| n <= 10) else {
+            out.push('&');
+            rest = tail.get(1..).unwrap_or_default();
+            continue;
+        };
+        let ent = tail.get(1..semi).unwrap_or_default();
+        match ent {
+            "amp" => out.push('&'),
+            "lt" => out.push('<'),
+            "gt" => out.push('>'),
+            "quot" => out.push('"'),
+            "apos" => out.push('\''),
+            _ => {
+                let code = ent.strip_prefix("#x").and_then(|h| u32::from_str_radix(h, 16).ok()).or_else(|| ent.strip_prefix('#').and_then(|d| d.parse().ok()));
+                match code.and_then(char::from_u32) {
+                    Some(c) => out.push(c),
+                    None => out.push_str(tail.get(..=semi).unwrap_or_default()),
+                }
+            }
+        }
+        rest = tail.get(semi + 1..).unwrap_or_default();
+    }
+    out.push_str(rest);
+    out.trim().to_string()
+}
+
+/// A frame rate as XMP writes it: `f44100`, or `f30000s1001` (rate over scale).
+fn xmp_rate(text: &str) -> Option<f64> {
+    let t = text.trim().strip_prefix('f')?;
+    let (num, den) = t.split_once('s').unwrap_or((t, "1"));
+    let (n, d): (f64, f64) = (num.parse().ok()?, den.parse().ok()?);
+    (n > 0.0 && d > 0.0).then_some(n / d)
+}
+
+/// The markers of an XMP packet's `xmpDM:markers` entries.
+fn xmp_markers(packet: &[u8], file_rate: f64) -> Vec<Marker> {
+    let text = String::from_utf8_lossy(packet.get(..packet.len().min(MAX_XMP)).unwrap_or_default());
+    let mut out = Vec::new();
+    // The frame rate belongs to the track an entry follows.
+    let mut rate = file_rate;
+    for entry in text.split("<rdf:li").skip(1) {
+        if let Some(r) = xmp_value(entry, "xmpDM:frameRate").as_deref().and_then(xmp_rate) {
+            rate = r;
+        }
+        let Some(start) = xmp_value(entry, "xmpDM:startTime").and_then(|v| v.trim().parse::<f64>().ok()) else { continue };
+        let length = xmp_value(entry, "xmpDM:duration").and_then(|v| v.trim().parse::<f64>().ok()).unwrap_or(0.0);
+        let comment = xmp_value(entry, "xmpDM:name").unwrap_or_default();
+        out.push(Marker { time: secs(start, rate), duration: secs(length, rate), comment, label: Label::None, ..Default::default() });
+        if out.len() >= MAX_MARKERS {
+            break;
+        }
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn chunk(id: &[u8; 4], body: &[u8]) -> Vec<u8> {
+        let mut v = id.to_vec();
+        v.extend((body.len() as u32).to_le_bytes());
+        v.extend(body);
+        if body.len() % 2 == 1 {
+            v.push(0);
+        }
+        v
+    }
+
+    fn fmt(rate: u32) -> Vec<u8> {
+        let mut b = Vec::new();
+        b.extend(1u16.to_le_bytes()); // PCM
+        b.extend(1u16.to_le_bytes()); // mono
+        b.extend(rate.to_le_bytes());
+        b.extend((rate * 2).to_le_bytes());
+        b.extend(2u16.to_le_bytes());
+        b.extend(16u16.to_le_bytes());
+        chunk(b"fmt ", &b)
+    }
+
+    fn wav(chunks: &[Vec<u8>]) -> Vec<u8> {
+        let body: Vec<u8> = chunks.iter().flatten().copied().collect();
+        let mut v = b"RIFF".to_vec();
+        v.extend((body.len() as u32 + 4).to_le_bytes());
+        v.extend(b"WAVE");
+        v.extend(body);
+        v
+    }
+
+    fn cue(points: &[(u32, u32)]) -> Vec<u8> {
+        let mut b = (points.len() as u32).to_le_bytes().to_vec();
+        for (id, offset) in points {
+            b.extend(id.to_le_bytes());
+            b.extend(0u32.to_le_bytes());
+            b.extend(b"data");
+            b.extend(0u32.to_le_bytes());
+            b.extend(0u32.to_le_bytes());
+            b.extend(offset.to_le_bytes());
+        }
+        chunk(b"cue ", &b)
+    }
+
+    fn labl(id: &[u8; 4], cue_id: u32, text: &str) -> Vec<u8> {
+        let mut b = cue_id.to_le_bytes().to_vec();
+        b.extend(text.as_bytes());
+        b.push(0);
+        chunk(id, &b)
+    }
+
+    fn adtl(subs: &[Vec<u8>]) -> Vec<u8> {
+        let mut b = b"adtl".to_vec();
+        b.extend(subs.iter().flatten());
+        chunk(b"LIST", &b)
+    }
+
+    #[test]
+    fn cue_points_are_named_by_the_adtl_list_and_timed_in_samples() {
+        let file = wav(&[
+            fmt(44100),
+            chunk(b"data", &[0; 8]),
+            cue(&[(2, 88200), (1, 22050)]),
+            adtl(&[labl(b"labl", 1, "SEQ01_Prologue"), labl(b"labl", 2, "SEQ02_Vallee_P1_Agriculture")]),
+        ]);
+        let m = read(&file);
+        assert_eq!(m.len(), 2);
+        assert_eq!((m[0].comment.as_str(), m[0].time), ("SEQ01_Prologue", Tick::from_seconds_f64(0.5)));
+        assert_eq!((m[1].comment.as_str(), m[1].time), ("SEQ02_Vallee_P1_Agriculture", Tick::from_seconds_f64(2.0)));
+    }
+
+    #[test]
+    fn a_note_names_a_cue_only_when_it_has_no_label_and_ltxt_gives_a_length() {
+        let mut ltxt = 1u32.to_le_bytes().to_vec();
+        ltxt.extend(44100u32.to_le_bytes());
+        ltxt.extend([0; 16]);
+        let file = wav(&[
+            fmt(44100),
+            cue(&[(1, 0), (2, 44100)]),
+            adtl(&[labl(b"note", 1, "from note"), chunk(b"ltxt", &ltxt), labl(b"labl", 2, "named"), labl(b"note", 2, "ignored")]),
+        ]);
+        let m = read(&file);
+        assert_eq!((m[0].comment.as_str(), m[0].duration), ("from note", Tick::from_seconds_f64(1.0)));
+        assert_eq!(m[1].comment, "named");
+    }
+
+    const XMP_ELEMENTS: &str = r#"<x:xmpmeta><rdf:RDF><rdf:Description><xmpDM:Tracks><rdf:Bag><rdf:li rdf:parseType="Resource"><xmpDM:trackName>Markers</xmpDM:trackName><xmpDM:trackType>Cue</xmpDM:trackType><xmpDM:frameRate>f44100</xmpDM:frameRate><xmpDM:markers><rdf:Seq><rdf:li rdf:parseType="Resource"><xmpDM:startTime>44100</xmpDM:startTime><xmpDM:duration>0</xmpDM:duration><xmpDM:name>One &amp; Two</xmpDM:name></rdf:li><rdf:li rdf:parseType="Resource"><xmpDM:startTime>132300</xmpDM:startTime><xmpDM:duration>22050</xmpDM:duration><xmpDM:name>Three</xmpDM:name></rdf:li></rdf:Seq></xmpDM:markers></rdf:li></rdf:Bag></xmpDM:Tracks></rdf:Description></rdf:RDF></x:xmpmeta>"#;
+
+    #[test]
+    fn xmp_markers_are_read_as_elements_in_frames_of_the_track_rate() {
+        let file = wav(&[fmt(48000), chunk(b"_PMX", XMP_ELEMENTS.as_bytes())]);
+        let m = read(&file);
+        assert_eq!(m.len(), 2);
+        // 44100 frames at f44100 is one second, whatever the file's own rate.
+        assert_eq!((m[0].comment.as_str(), m[0].time), ("One & Two", Tick::from_seconds_f64(1.0)));
+        assert_eq!((m[1].comment.as_str(), m[1].time, m[1].duration), ("Three", Tick::from_seconds_f64(3.0), Tick::from_seconds_f64(0.5)));
+    }
+
+    #[test]
+    fn xmp_markers_are_read_as_attributes_and_use_the_file_rate_without_a_track_rate() {
+        let xmp = r#"<rdf:Seq><rdf:li xmpDM:startTime="24000" xmpDM:duration="0" xmpDM:name="Attr &#233;"/></rdf:Seq>"#;
+        let m = read(&wav(&[fmt(48000), chunk(b"_PMX", xmp.as_bytes())]));
+        assert_eq!((m[0].comment.as_str(), m[0].time), ("Attr é", Tick::from_seconds_f64(0.5)));
+    }
+
+    #[test]
+    fn a_marker_in_both_encodings_is_listed_once() {
+        let xmp = r#"<rdf:li xmpDM:startTime="44100" xmpDM:name="Same"/><rdf:li xmpDM:startTime="88200" xmpDM:name="Only XMP"/>"#;
+        let file = wav(&[fmt(44100), cue(&[(1, 44100)]), adtl(&[labl(b"labl", 1, "Same")]), chunk(b"_PMX", xmp.as_bytes())]);
+        let names: Vec<String> = read(&file).into_iter().map(|m| m.comment).collect();
+        assert_eq!(names, ["Same", "Only XMP"]);
+    }
+
+    #[test]
+    fn importing_a_wav_puts_its_markers_on_the_footage() {
+        let file = wav(&[
+            fmt(44100),
+            chunk(b"data", &[0; 4 * 44100]),
+            cue(&[(1, 0), (2, 44100)]),
+            adtl(&[labl(b"labl", 1, "SEQ01_Prologue"), labl(b"labl", 2, "SEQ02_Vallee_P1_Agriculture")]),
+        ]);
+        let f = crate::probe::probe_bytes("markers.wav", file.into()).expect("probe");
+        assert!(f.has_audio);
+        let names: Vec<&str> = f.markers.iter().map(|m| m.comment.as_str()).collect();
+        assert_eq!(names, ["SEQ01_Prologue", "SEQ02_Vallee_P1_Agriculture"]);
+        assert_eq!(f.markers[1].time, Tick::from_seconds_f64(1.0));
+    }
+
+    #[test]
+    fn damaged_or_hostile_files_read_as_far_as_they_go_without_panicking() {
+        assert!(read(b"").is_empty());
+        assert!(read(b"RIFF").is_empty());
+        assert!(read(b"not a wav file at all").is_empty());
+        let good = wav(&[fmt(44100), cue(&[(1, 44100)]), adtl(&[labl(b"labl", 1, "Kept")])]);
+        // Every truncation is safe.
+        for n in 0..good.len() {
+            let _ = read(&good[..n]);
+        }
+        // A cue count far beyond the chunk, and chunk sizes past the end of the file.
+        let mut huge = 0xFFFF_FFFFu32.to_le_bytes().to_vec();
+        huge.extend([0; 24]);
+        let m = read(&wav(&[fmt(44100), chunk(b"cue ", &huge)]));
+        assert!(m.len() <= 1);
+        let mut lying = good.clone();
+        lying.extend(b"LIST\xff\xff\xff\xffadtl");
+        assert_eq!(read(&lying).len(), 1);
+        // No sample rate: times are zero, not a division by zero.
+        let m = read(&wav(&[cue(&[(1, 44100)])]));
+        assert_eq!(m[0].time, Tick::ZERO);
+    }
+
+    /// A chunk whose size field says `field` (an RF64 file's `0xFFFFFFFF`) while its body is `body`.
+    fn chunk_with_size_field(id: &[u8; 4], field: u32, body: &[u8]) -> Vec<u8> {
+        let mut v = id.to_vec();
+        v.extend(field.to_le_bytes());
+        v.extend(body);
+        if body.len() % 2 == 1 {
+            v.push(0);
+        }
+        v
+    }
+
+    /// An RF64 `ds64` chunk: the `data` chunk's size and a table of other chunks' sizes.
+    fn ds64_chunk(data_size: u64, table: &[([u8; 4], u64)]) -> Vec<u8> {
+        let mut b = 0u64.to_le_bytes().to_vec(); // riff size (not used)
+        b.extend(data_size.to_le_bytes());
+        b.extend(0u64.to_le_bytes()); // sample count
+        b.extend((table.len() as u32).to_le_bytes());
+        for (id, size) in table {
+            b.extend(id);
+            b.extend(size.to_le_bytes());
+        }
+        chunk(b"ds64", &b)
+    }
+
+    fn rf64(chunks: &[Vec<u8>]) -> Vec<u8> {
+        let body: Vec<u8> = chunks.iter().flatten().copied().collect();
+        let mut v = b"RF64".to_vec();
+        v.extend(u32::MAX.to_le_bytes());
+        v.extend(b"WAVE");
+        v.extend(body);
+        v
+    }
+
+    #[test]
+    fn rf64_markers_after_a_data_chunk_of_sentinel_size_are_read() {
+        let audio = [0u8; 8];
+        let file = rf64(&[
+            ds64_chunk(audio.len() as u64, &[]),
+            fmt(44100),
+            chunk_with_size_field(b"data", u32::MAX, &audio),
+            cue(&[(1, 44100)]),
+            adtl(&[labl(b"labl", 1, "After the audio")]),
+        ]);
+        let m = read(&file);
+        assert_eq!(m.len(), 1);
+        assert_eq!((m[0].comment.as_str(), m[0].time), ("After the audio", Tick::from_seconds_f64(1.0)));
+    }
+
+    #[test]
+    fn rf64_sizes_of_other_chunks_come_from_the_ds64_table() {
+        let junk = [7u8; 6];
+        let tail = || [cue(&[(1, 8000)]), adtl(&[labl(b"labl", 1, "Found")])].concat();
+        let with_entry = rf64(&[ds64_chunk(0, &[(*b"junk", junk.len() as u64)]), fmt(8000), chunk_with_size_field(b"junk", u32::MAX, &junk), tail()]);
+        assert_eq!(read(&with_entry)[0].comment, "Found");
+        // Without the table entry the sentinel is all there is, and what follows is not reached.
+        let without = rf64(&[ds64_chunk(0, &[]), fmt(8000), chunk_with_size_field(b"junk", u32::MAX, &junk), tail()]);
+        assert!(read(&without).is_empty());
+    }
+
+    #[test]
+    fn hostile_rf64_size_tables_read_as_far_as_they_go_without_panicking() {
+        // sizes that overflow when added to an offset
+        for data in [u64::MAX, u64::MAX - 7, 1 << 63] {
+            let file = rf64(&[ds64_chunk(data, &[(*b"junk", u64::MAX)]), fmt(8000), chunk_with_size_field(b"data", u32::MAX, &[0; 4]), cue(&[(1, 0)])]);
+            assert!(read(&file).is_empty());
+        }
+        // a table that claims far more entries than its chunk holds
+        let mut liar = ds64_chunk(0, &[]);
+        liar[8 + 24..8 + 28].copy_from_slice(&u32::MAX.to_le_bytes());
+        let _ = read(&rf64(&[liar, fmt(8000), cue(&[(1, 0)])]));
+        // every truncation of a good RF64 file is safe
+        let good =
+            rf64(&[ds64_chunk(4, &[]), fmt(44100), chunk_with_size_field(b"data", u32::MAX, &[0; 4]), cue(&[(1, 44100)]), adtl(&[labl(b"labl", 1, "Kept")])]);
+        assert_eq!(read(&good).len(), 1);
+        for n in 0..good.len() {
+            let _ = read(&good[..n]);
+        }
+    }
+
+    #[test]
+    fn a_huge_adtl_list_is_read_in_linear_time_and_only_for_the_cue_points_that_exist() {
+        // Records for ids that have no cue point are skipped, not stored, and the number looked at is capped.
+        let junk = |n: u32| (1000..1000 + n).map(|id| labl(b"labl", id, "n")).collect::<Vec<_>>();
+        let started = std::time::Instant::now();
+        // the real label comes first: read
+        let mut subs = vec![labl(b"labl", 1, "Real")];
+        subs.extend(junk(100_000));
+        let m = read(&wav(&[fmt(44100), cue(&[(1, 44100)]), adtl(&subs)]));
+        assert_eq!(m[0].comment, "Real");
+        // it comes after more records than are looked at: not read, and the marker is still there
+        let mut subs = junk(MAX_ADTL_RECORDS as u32 + 10);
+        subs.push(labl(b"labl", 1, "Too late"));
+        let m = read(&wav(&[fmt(44100), cue(&[(1, 44100)]), adtl(&subs)]));
+        assert_eq!((m.len(), m[0].comment.as_str()), (1, ""));
+        assert!(started.elapsed() < std::time::Duration::from_secs(5), "took {:?}", started.elapsed());
+    }
+}
diff --git a/crates/media/tests/it/aac_layout.rs b/crates/media/tests/it/aac_layout.rs
new file mode 100644
index 000000000..fb3e078a6
--- /dev/null
+++ b/crates/media/tests/it/aac_layout.rs
@@ -0,0 +1,422 @@
+//! Multichannel AAC reaches stereo by where each channel plays, whatever order its channel
+//! configuration decodes in (#1701). Fixtures are tones encoded with FilmCraft's AAC encoder (no
+//! ffmpeg needed, so nothing is skipped), with the configuration rewritten where the coded
+//! elements fit another: configurations 11 and 12 code the same elements as the encoder's 7- and
+//! 8-channel output, and a program config element can name any of them.
+
+use std::f64::consts::PI;
+use std::io::Cursor;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use effectcraft_media::{MediaPool, probe, probe_bytes};
+use effectcraft_time::Tick;
+use filmcraft_aac::{AudioSpecificConfig, Encoder, EncoderConfig, ProgramConfig};
+
+const RATE: u32 = 48_000;
+/// Tone frequencies by channel; an LFE gets [`LFE_TONE`], which its element can carry.
+const FREQS: [u32; 8] = [300, 500, 700, 900, 1100, 1300, 1500, 1700];
+const LFE_TONE: u32 = 60;
+const AMP: f32 = 0.25;
+const K: f64 = std::f64::consts::FRAC_1_SQRT_2;
+
+/// A channel's content, by where it plays.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Ch {
+    L,
+    R,
+    C,
+    Lfe,
+    Ls,
+    Rs,
+    Cs,
+}
+
+impl Ch {
+    /// ITU-R BS.775 gains into `[left, right]`, before normalisation.
+    fn gains(self) -> [f64; 2] {
+        match self {
+            Ch::L => [1.0, 0.0],
+            Ch::R => [0.0, 1.0],
+            Ch::C => [K, K],
+            Ch::Lfe => [0.0, 0.0],
+            Ch::Ls => [K, 0.0],
+            Ch::Rs => [0.0, K],
+            Ch::Cs => [0.5, 0.5],
+        }
+    }
+}
+
+struct Case {
+    name: &'static str,
+    /// What the encoder's input channels carry (its element order: C, L R, …, LFE last).
+    content: &'static [Ch],
+    /// The AudioSpecificConfig written to the container instead of the encoder's, if any.
+    asc: Option<AudioSpecificConfig>,
+}
+
+fn lc(config: u8) -> Option<AudioSpecificConfig> {
+    Some(AudioSpecificConfig::lc(3, config))
+}
+
+fn pce(front: Vec<(bool, u8)>, side: Vec<(bool, u8)>, back: Vec<(bool, u8)>, lfe: Vec<u8>, comment: &[u8]) -> Option<AudioSpecificConfig> {
+    let pce = ProgramConfig { object_type: 1, sf_index: 3, front, side, back, lfe, comment: comment.to_vec(), ..Default::default() };
+    Some(AudioSpecificConfig { pce: Some(pce), ..AudioSpecificConfig::lc(3, 0) })
+}
+
+use Ch::*;
+
+fn cases() -> Vec<Case> {
+    vec![
+        Case { name: "config3", content: &[C, L, R], asc: None },
+        Case { name: "config4", content: &[C, L, R, Cs], asc: None },
+        Case { name: "config5", content: &[C, L, R, Ls, Rs], asc: None },
+        Case { name: "config6", content: &[C, L, R, Ls, Rs, Lfe], asc: None },
+        // configuration 7 as ffmpeg writes 7.1: the second and third pairs are surrounds
+        Case { name: "config7", content: &[C, L, R, Ls, Rs, Ls, Rs, Lfe], asc: None },
+        Case { name: "config11", content: &[C, L, R, Ls, Rs, Cs, Lfe], asc: lc(11) },
+        Case { name: "config12", content: &[C, L, R, Ls, Rs, Ls, Rs, Lfe], asc: lc(12) },
+        // the encoder's own 6.1: a PCE listing the centre first
+        Case { name: "pce61-centre-first", content: &[C, L, R, Ls, Rs, Cs, Lfe], asc: None },
+        // ffmpeg's 6.1 PCE: front pair and centre, a side SCE, a back pair and SCE, no LFE
+        // element, its channels in ffmpeg's order L R C LFE Cs Ls Rs. The decoder places the
+        // encoder's SCE 0 in the front SCE, pair 0 front, pair 1 back, SCE 1 in the back SCE (tag
+        // 1) and the LFE in the side SCE left over (tag 5).
+        Case {
+            name: "pce61-ffmpeg",
+            content: &[C, L, R, Cs, Ls, Rs, Lfe],
+            asc: pce(vec![(true, 0), (false, 0)], vec![(false, 5)], vec![(true, 1), (false, 1)], vec![], b"Lavc62.28.102"),
+        },
+    ]
+}
+
+fn freq(content: &[Ch], i: usize) -> u32 {
+    if content.get(i) == Some(&Lfe) { LFE_TONE } else { FREQS[i] }
+}
+
+/// Two seconds of `content`'s tones encoded as AAC: the AudioSpecificConfig and access units.
+fn encode(content: &[Ch], adts: bool) -> (Vec<u8>, Vec<Vec<u8>>) {
+    let n = content.len();
+    let mut cfg = EncoderConfig::cbr(RATE, n, 96_000 * n as u32);
+    cfg.adts = adts;
+    let mut enc = Encoder::new(cfg).expect("encoder");
+    let planes: Vec<Vec<f32>> =
+        (0..n).map(|c| (0..2 * RATE).map(|i| AMP * (2.0 * PI * f64::from(freq(content, c)) * f64::from(i) / f64::from(RATE)).sin() as f32).collect()).collect();
+    let refs: Vec<&[f32]> = planes.iter().map(Vec::as_slice).collect();
+    let mut units = enc.encode(&refs);
+    units.extend(enc.flush());
+    (enc.audio_specific_config(), units)
+}
+
+fn mp4(asc: Vec<u8>, channels: u32, units: &[Vec<u8>]) -> Vec<u8> {
+    mp4_after(None, asc, channels, units)
+}
+
+/// As [`mp4`], after an audio track with the configuration and channel count `empty` and no
+/// samples, if any.
+fn mp4_after(empty: Option<(Vec<u8>, u32)>, asc: Vec<u8>, channels: u32, units: &[Vec<u8>]) -> Vec<u8> {
+    use filmcraft_isobmff::{Brand, Mp4Writer, SampleEntry, TrackConfig, WriteSample, WriterOptions};
+    let mut w = Mp4Writer::new(Cursor::new(Vec::new()), WriterOptions::new(Brand::Mp4)).expect("writer");
+    if let Some((asc, channels)) = empty {
+        w.add_track(TrackConfig::new(SampleEntry::aac(asc, channels, RATE), RATE)).expect("empty track");
+    }
+    let t = w.add_track(TrackConfig::new(SampleEntry::aac(asc, channels, RATE), RATE)).expect("track");
+    for u in units {
+        w.write_sample(t, WriteSample { data: u, duration: 1024, composition_offset: 0, is_sync: true }).expect("sample");
+    }
+    w.finish().expect("finish").into_inner()
+}
+
+fn mkv(asc: Vec<u8>, channels: u32, units: &[Vec<u8>]) -> Vec<u8> {
+    mkv_after(None, asc, channels, units)
+}
+
+/// As [`mkv`], after an audio track with the configuration and channel count `empty` and no
+/// frames, if any.
+fn mkv_after(empty: Option<(Vec<u8>, u32)>, asc: Vec<u8>, channels: u32, units: &[Vec<u8>]) -> Vec<u8> {
+    use filmcraft_matroska::{MkvWriter, MuxOptions, TrackKind, TrackSpec};
+    let track = |asc: Vec<u8>, channels: u32| {
+        let mut t = TrackSpec::new(TrackKind::Audio, "A_AAC");
+        t.codec_private = asc;
+        t.audio = Some((f64::from(RATE), u64::from(channels), None));
+        t
+    };
+    let tracks: Vec<TrackSpec> = empty.into_iter().map(|(asc, n)| track(asc, n)).chain([track(asc, channels)]).collect();
+    let played = tracks.len() - 1;
+    let mut w = MkvWriter::new(Cursor::new(Vec::new()), tracks, MuxOptions::default()).expect("writer");
+    let frame_ns = 1_000_000_000 * 1024 / i64::from(RATE);
+    for (i, u) in units.iter().enumerate() {
+        w.write_frame(played, i as i64 * frame_ns, true, u, Some(frame_ns as u64)).expect("frame");
+    }
+    w.finish().expect("finish").into_inner()
+}
+
+/// The fixture written to disk as `name`.
+fn write(name: &str, bytes: &[u8]) -> PathBuf {
+    let dir = std::env::temp_dir().join(format!("effectcraft-aac-layout-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).expect("mkdir");
+    let p = dir.join(name);
+    std::fs::write(&p, bytes).expect("write");
+    p
+}
+
+/// Amplitude of the tone at `freq` in one side of interleaved stereo.
+fn amp(s: &[f32], side: usize, freq: u32) -> f64 {
+    let (mut re, mut im, mut n) = (0.0, 0.0, 0usize);
+    for (i, f) in s.as_chunks::<2>().0.iter().enumerate() {
+        let w = 2.0 * PI * f64::from(freq) * i as f64 / f64::from(RATE);
+        re += f64::from(f[side]) * w.cos();
+        im += f64::from(f[side]) * w.sin();
+        n += 1;
+    }
+    2.0 * (re * re + im * im).sqrt() / n.max(1) as f64
+}
+
+/// Stereo of one second from 0.5 s in, through the media pool as footage reads it.
+fn mix(pool: &MediaPool, footage: &effectcraft_project::Footage) -> Vec<f32> {
+    pool.audio_samples(footage, Tick::from_seconds_f64(0.5), RATE as usize, RATE)
+}
+
+/// Each channel of `content` reaches each side at its BS.775 gain, normalised by the larger
+/// side's sum (an LFE nowhere).
+fn check(label: &str, content: &[Ch], s: &[f32]) {
+    let raw: Vec<[f64; 2]> = content.iter().map(|c| c.gains()).collect();
+    let norm = raw.iter().map(|g| g[0]).sum::<f64>().max(raw.iter().map(|g| g[1]).sum::<f64>()).max(1.0);
+    for (i, (ch, g)) in content.iter().zip(&raw).enumerate() {
+        for side in 0..2 {
+            let (got, want) = (amp(s, side, freq(content, i)), f64::from(AMP) * g[side] / norm);
+            assert!(
+                (got - want).abs() <= f64::from(AMP) * 0.05,
+                "{label}: {ch:?} ({} Hz) -> {} is {got:.4}, expected {want:.4}",
+                freq(content, i),
+                ["L", "R"][side]
+            );
+        }
+    }
+}
+
+/// The LFE tone survives encoding, so its absence from the mix means it was left out.
+fn lfe_is_coded(case: &Case, bytes: Vec<u8>) {
+    if !case.content.contains(&Lfe) {
+        return;
+    }
+    let src = filmcraft_codecs::open_bytes("lfe.mp4", bytes.into()).expect("open");
+    let buf = src.audio(24_000, RATE as usize, RATE).expect("decode");
+    let best = buf.channels.iter().map(|ch| amp(&ch.iter().flat_map(|&v| [v, v]).collect::<Vec<_>>(), 0, LFE_TONE)).fold(0.0, f64::max);
+    assert!(best > 0.8 * f64::from(AMP), "{}: the LFE tone is coded ({best:.4})", case.name);
+}
+
+#[test]
+fn every_aac_layout_mixes_by_speaker_in_mp4() {
+    for case in cases() {
+        let (asc, units) = encode(case.content, false);
+        let asc = case.asc.as_ref().map_or(asc, AudioSpecificConfig::to_bytes);
+        let bytes = mp4(asc, case.content.len() as u32, &units);
+        lfe_is_coded(&case, bytes.clone());
+        let p = write(&format!("{}.mp4", case.name), &bytes);
+        check(case.name, case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe")));
+        // in memory (`add_bytes`) as well as in place
+        let (path, bytes): (String, Arc<[u8]>) = (format!("/mem/{}.mp4", case.name), bytes.into());
+        let pool = MediaPool::new();
+        pool.add_bytes(&path, bytes.clone());
+        check(&format!("{} in memory", case.name), case.content, &mix(&pool, &probe_bytes(&path, bytes).expect("probe")));
+    }
+}
+
+#[test]
+fn matroska_aac_layouts_mix_by_speaker() {
+    for case in cases().into_iter().filter(|c| matches!(c.name, "config12" | "pce61-centre-first" | "pce61-ffmpeg")) {
+        let (asc, units) = encode(case.content, false);
+        let asc = case.asc.as_ref().map_or(asc, AudioSpecificConfig::to_bytes);
+        let p = write(&format!("{}.mkv", case.name), &mkv(asc, case.content.len() as u32, &units));
+        check(case.name, case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe")));
+    }
+}
+
+/// ADTS signals configurations 1 to 7 only, which the channel count tells apart.
+#[test]
+fn adts_aac_layouts_mix_by_speaker() {
+    for case in cases().into_iter().filter(|c| c.asc.is_none() && c.content.len() != 7) {
+        let (_, units) = encode(case.content, true);
+        let p = write(&format!("{}.aac", case.name), &units.concat());
+        check(case.name, case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe")));
+    }
+}
+
+/// Audio plays from the first track FilmCraft can play, so an audio track with no samples before
+/// it lends it no configuration. Each case decodes in another order than the empty track's
+/// configuration would (FilmCraft reorders 12 to WAVE / SMPTE but not 7, and 11 but not a PCE).
+#[test]
+fn an_empty_audio_track_lends_its_configuration_to_no_other() {
+    for (name, empty) in [("config12", 7), ("pce61-centre-first", 11)] {
+        let case = cases().into_iter().find(|c| c.name == name).expect("case");
+        let n = case.content.len() as u32;
+        let empty = Some((AudioSpecificConfig::lc(3, empty).to_bytes(), n));
+        let (asc, units) = encode(case.content, false);
+        let asc = case.asc.as_ref().map_or(asc, AudioSpecificConfig::to_bytes);
+        let p = write(&format!("{name}-after-empty.mp4"), &mp4_after(empty.clone(), asc.clone(), n, &units));
+        check(&format!("{name} MP4"), case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe")));
+        let p = write(&format!("{name}-after-empty.mkv"), &mkv_after(empty, asc, n, &units));
+        check(&format!("{name} Matroska"), case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe")));
+    }
+}
+
+/// A transport stream plays its first audio stream and mixes by that stream's configuration,
+/// whatever follows it. ADTS of configuration 7 decodes in element order, LATM of configuration
+/// 12 reordered to WAVE / SMPTE; LATM of configuration 7 names 7 channels, which mix as
+/// configuration 7's rather than as 7 channels by count. (FilmCraft decodes LATM of configuration
+/// 12 as 12 channels, so it isn't played here.)
+#[test]
+fn mpeg_aac_mixes_by_the_stream_played() {
+    let case = cases().into_iter().find(|c| c.name == "config7").expect("case");
+    let (_, adts) = encode(case.content, true);
+    let (_, raw) = encode(case.content, false);
+    for (label, latm_first, latm_config) in [("ADTS before LATM", false, 12), ("LATM before ADTS", true, 7)] {
+        let (adts_pid, latm_pid) = if latm_first { (0x102, 0x101) } else { (0x101, 0x102) };
+        let mut ts = Ts::default();
+        let mut streams = [(0x0F, adts_pid), (0x11, latm_pid)];
+        streams.sort_by_key(|s| s.1);
+        ts.psi(&streams);
+        for (i, (a, r)) in adts.iter().zip(&raw).enumerate() {
+            let pts = 1920 * i as i64;
+            let mut units = [(adts_pid, pes(pts, a)), (latm_pid, pes(pts, &loas(latm_config, r)))];
+            units.sort_by_key(|u| u.0);
+            for (pid, unit) in units {
+                ts.pes(pid, &unit);
+            }
+        }
+        let p = write(&format!("latm-first-{latm_first}.ts"), &ts.out);
+        check(label, case.content, &mix(&MediaPool::new(), &probe(&p).expect("probe")));
+    }
+}
+
+/// A LOAS frame of `payload` with its StreamMuxConfig: AAC LC, 48 kHz, channel configuration
+/// `config`.
+fn loas(config: u32, payload: &[u8]) -> Vec<u8> {
+    let mut bits = Bits::default();
+    // useSameStreamMux, audioMuxVersion, allStreamsSameTimeFraming, numSubFrames, numProgram, numLayer
+    bits.put(0b001, 3);
+    bits.put(0, 13);
+    // AudioSpecificConfig and GASpecificConfig
+    bits.put(2, 5);
+    bits.put(3, 4);
+    bits.put(config, 4);
+    bits.put(0, 3);
+    // frameLengthType, latmBufferFullness, otherDataPresent, crcCheckPresent
+    bits.put(0, 3);
+    bits.put(0xFF, 8);
+    bits.put(0, 2);
+    let mut len = payload.len();
+    while len >= 255 {
+        bits.put(255, 8);
+        len -= 255;
+    }
+    bits.put(len as u32, 8);
+    for &b in payload {
+        bits.put(u32::from(b), 8);
+    }
+    let body = bits.finish();
+    let mut v = vec![0x56, 0xE0 | (body.len() >> 8) as u8, body.len() as u8];
+    v.extend(body);
+    v
+}
+
+/// A big-endian bit writer.
+#[derive(Default)]
+struct Bits {
+    out: Vec<u8>,
+    acc: u64,
+    n: u32,
+}
+
+impl Bits {
+    fn put(&mut self, v: u32, n: u32) {
+        self.acc = self.acc << n | u64::from(v);
+        self.n += n;
+        while self.n >= 8 {
+            self.n -= 8;
+            self.out.push((self.acc >> self.n) as u8);
+        }
+    }
+    fn finish(mut self) -> Vec<u8> {
+        if self.n > 0 {
+            self.put(0, 8 - self.n);
+        }
+        self.out
+    }
+}
+
+/// An audio PES packet (stream id 0xC0) presented at `pts` (90 kHz).
+fn pes(pts: i64, payload: &[u8]) -> Vec<u8> {
+    let t = [0x21 | ((pts >> 29) & 0x0E) as u8, (pts >> 22) as u8, ((pts >> 14) & 0xFE) as u8 | 1, (pts >> 7) as u8, ((pts << 1) & 0xFE) as u8 | 1];
+    let len = 8 + payload.len();
+    let mut v = vec![0, 0, 1, 0xC0, (len >> 8) as u8, len as u8, 0x80, 0x80, 5];
+    v.extend(t);
+    v.extend_from_slice(payload);
+    v
+}
+
+/// A transport stream of one program (its PMT on PID 0x100), PES cut into 188-byte packets.
+#[derive(Default)]
+struct Ts {
+    out: Vec<u8>,
+    cc: std::collections::HashMap<u16, u8>,
+}
+
+impl Ts {
+    fn packet(&mut self, pid: u16, start: bool, payload: &[u8]) -> usize {
+        let cc = self.cc.entry(pid).or_insert(0);
+        let mut p = vec![0x47, u8::from(start) << 6 | (pid >> 8) as u8, pid as u8];
+        let n = payload.len().min(184);
+        if n < 184 {
+            let stuffing = 183 - n;
+            p.extend([0x30 | *cc, stuffing as u8]);
+            if stuffing > 0 {
+                p.push(0);
+                p.extend(std::iter::repeat_n(0xFF, stuffing - 1));
+            }
+        } else {
+            p.push(0x10 | *cc);
+        }
+        *cc = (*cc + 1) & 15;
+        p.extend_from_slice(&payload[..n]);
+        self.out.extend(p);
+        n
+    }
+    fn section(&mut self, pid: u16, body: &[u8]) {
+        let mut s = vec![0];
+        s.extend_from_slice(body);
+        s.extend(crc32_mpeg(body).to_be_bytes());
+        self.packet(pid, true, &s);
+    }
+    /// The PAT and a PMT of `streams` (stream type, PID).
+    fn psi(&mut self, streams: &[(u8, u16)]) {
+        self.section(0, &[0x00, 0xB0, 13, 0, 1, 0xC1, 0, 0, 0, 1, 0xE1, 0x00]);
+        let mut pmt = vec![0x02, 0xB0, 0, 0, 1, 0xC1, 0, 0, 0xE1, 0x01, 0xF0, 0];
+        for &(kind, pid) in streams {
+            pmt.extend([kind, 0xE0 | (pid >> 8) as u8, pid as u8, 0xF0, 0]);
+        }
+        pmt[2] = (pmt.len() + 1) as u8;
+        self.section(0x100, &pmt);
+    }
+    fn pes(&mut self, pid: u16, data: &[u8]) {
+        let (mut rest, mut start) = (data, true);
+        while !rest.is_empty() {
+            let n = self.packet(pid, start, rest);
+            rest = &rest[n..];
+            start = false;
+        }
+    }
+}
+
+/// CRC-32 of PSI sections (MSB first, polynomial 0x04C11DB7, initial value all ones).
+fn crc32_mpeg(data: &[u8]) -> u32 {
+    let mut crc = u32::MAX;
+    for &b in data {
+        crc ^= u32::from(b) << 24;
+        for _ in 0..8 {
+            crc = if crc & 0x8000_0000 != 0 { crc << 1 ^ 0x04C1_1DB7 } else { crc << 1 };
+        }
+    }
+    crc
+}
diff --git a/crates/media/tests/it/downmix.rs b/crates/media/tests/it/downmix.rs
index e0e7d2252..05205ab6a 100644
--- a/crates/media/tests/it/downmix.rs
+++ b/crates/media/tests/it/downmix.rs
@@ -94,8 +94,18 @@ fn cases() -> Vec<Case> {
     let (n71, g71) = seven_one();
     let k5 = 1.0 / (1.0 + 2.0 * K);
     let kq = 1.0 / (1.0 + K);
+    let k61 = 1.0 / (1.5 + 2.0 * K);
     vec![
         Case { file: "dm51.m4a", layout: "5.1", names: n51, codec: &["-c:a", "aac", "-b:a", "384k"], gains: g51.clone(), tol: 0.15 },
+        Case {
+            file: "dm61.m4a",
+            layout: "6.1",
+            names: &["FL", "FR", "FC", "LFE", "BC", "SL", "SR"],
+            codec: &["-c:a", "aac", "-b:a", "448k"],
+            gains: vec![[k61, 0.0], [0.0, k61], [k61 * K, k61 * K], [0.0, 0.0], [k61 / 2.0, k61 / 2.0], [k61 * K, 0.0], [0.0, k61 * K]],
+            tol: 0.15,
+        },
+        Case { file: "dm71.m4a", layout: "7.1", names: n71, codec: &["-c:a", "aac", "-b:a", "512k"], gains: g71.clone(), tol: 0.15 },
         Case { file: "dm51.ac3.mp4", layout: "5.1", names: n51, codec: &["-c:a", "ac3", "-b:a", "640k"], gains: g51.clone(), tol: 0.15 },
         Case { file: "dm51.wav", layout: "5.1", names: n51, codec: &["-c:a", "pcm_s16le"], gains: g51.clone(), tol: 0.02 },
         Case { file: "dm51.flac", layout: "5.1", names: n51, codec: &["-c:a", "flac"], gains: g51, tol: 0.02 },
@@ -154,24 +164,58 @@ fn each_channel_reaches_stereo_at_its_bs775_gain() {
     for c in cases() {
         let freqs: Vec<u32> = FREQS.iter().copied().take(c.names.len()).collect();
         let Some(p) = fixture(c.file, c.layout, c.names, &freqs, c.codec) else { continue };
-        let s = ours(&p);
-        let sine = 0.125 * 1.0; // peak of ffmpeg's sine source (0.125 = 2^-3)
-        for (i, (name, g)) in c.names.iter().zip(&c.gains).enumerate() {
-            for (side, gain) in g.iter().enumerate() {
-                let got = amp(&s, side, freqs[i]);
-                let want = sine * gain;
-                assert!((got - want).abs() <= sine * c.tol.max(0.02), "{}: {name} -> {} is {got:.4}, expected {want:.4}", c.file, ["L", "R"][side]);
-            }
-        }
-        let theirs = ffmpeg_ac2(&p);
-        let (a, b) = (rms(&s), rms(&theirs));
-        let db = 20.0 * (a / b).log10();
-        assert!(db.abs() < 1.0, "{}: level {db:.2} dB off ffmpeg -ac 2 (rms {a:.4} vs {b:.4})", c.file);
-        let pdb = 20.0 * (peak(&s) / peak(&theirs)).log10();
-        assert!(pdb.abs() < 1.5, "{}: peak {pdb:.2} dB off ffmpeg -ac 2", c.file);
+        check(&c, &p);
     }
 }
 
+/// `p`, or a copy whose AAC sample entry names all `channels` of its PCE layout: ffmpeg 4.2 writes
+/// 2 there for a PCE layout (8.1 the real count), and FilmCraft decodes as many channels as the
+/// sample entry names, so the other five of a 6.1 would never reach the mix.
+fn whole_pce_entry(p: &Path, channels: usize) -> PathBuf {
+    let mut bytes = std::fs::read(p).expect("read");
+    let Some((asc, 2)) = aac_entry(&bytes) else { return p.to_path_buf() };
+    if channels <= 2 || filmcraft_aac::AudioSpecificConfig::parse(&asc).map(|a| a.channel_config).ok() != Some(0) {
+        return p.to_path_buf();
+    }
+    // the `mp4a` entry's channelcount follows its 6 reserved bytes, data reference index and
+    // 8 reserved bytes
+    let at = bytes.windows(4).position(|w| w == b"mp4a").expect("an mp4a sample entry") + 4 + 6 + 2 + 8;
+    bytes[at..at + 2].copy_from_slice(&(channels as u16).to_be_bytes());
+    eprintln!("{}: its sample entry names 2 of {channels} channels (ffmpeg 4.2): reading a copy naming all", p.display());
+    let out = p.with_extension("entry.m4a");
+    std::fs::write(&out, bytes).expect("write");
+    out
+}
+
+/// The AudioSpecificConfig and sample entry channel count of an MP4's first AAC track.
+fn aac_entry(bytes: &[u8]) -> Option<(Vec<u8>, u32)> {
+    let file = filmcraft_isobmff::open(bytes).ok()?;
+    file.tracks.iter().flat_map(|t| &t.entries).find_map(|e| match &e.codec {
+        filmcraft_isobmff::CodecConfig::Aac(a) => Some((a.asc.clone(), e.audio.as_ref()?.channels)),
+        _ => None,
+    })
+}
+
+fn check(c: &Case, p: &Path) {
+    let p = &whole_pce_entry(p, c.names.len());
+    let s = ours(p);
+    let freqs: Vec<u32> = FREQS.iter().copied().take(c.names.len()).collect();
+    let sine = 0.125 * 1.0; // peak of ffmpeg's sine source (0.125 = 2^-3)
+    for (i, (name, g)) in c.names.iter().zip(&c.gains).enumerate() {
+        for (side, gain) in g.iter().enumerate() {
+            let got = amp(&s, side, freqs[i]);
+            let want = sine * gain;
+            assert!((got - want).abs() <= sine * c.tol.max(0.02), "{}: {name} -> {} is {got:.4}, expected {want:.4}", c.file, ["L", "R"][side]);
+        }
+    }
+    let theirs = ffmpeg_ac2(p);
+    let (a, b) = (rms(&s), rms(&theirs));
+    let db = 20.0 * (a / b).log10();
+    assert!(db.abs() < 1.0, "{}: level {db:.2} dB off ffmpeg -ac 2 (rms {a:.4} vs {b:.4})", c.file);
+    let pdb = 20.0 * (peak(&s) / peak(&theirs)).log10();
+    assert!(pdb.abs() < 1.5, "{}: peak {pdb:.2} dB off ffmpeg -ac 2", c.file);
+}
+
 /// Full-scale in every channel must not clip.
 #[test]
 fn loud_surround_does_not_clip() {
diff --git a/crates/media/tests/it/footage.rs b/crates/media/tests/it/footage.rs
index a2849dc1d..0cae33417 100644
--- a/crates/media/tests/it/footage.rs
+++ b/crates/media/tests/it/footage.rs
@@ -24,9 +24,40 @@ fn have_ffmpeg() -> bool {
     *HAVE.get_or_init(|| Command::new("ffmpeg").arg("-version").output().is_ok_and(|o| o.status.success()))
 }
 
+/// An H.264 encoder this ffmpeg build actually ships, or `None` when it has none. Distro "free"
+/// builds often omit `libx264` (the one named historically here) but ship an alternative, so pick
+/// the first present by name rather than hard-coding one that may be absent. These tests only
+/// need *an* H.264 encoder to make an oracle fixture; the encoder identity is irrelevant.
+fn h264_encoder() -> Option<&'static str> {
+    static ENC: std::sync::OnceLock<Option<&'static str>> = std::sync::OnceLock::new();
+    *ENC.get_or_init(|| {
+        let out = Command::new("ffmpeg").args(["-hide_banner", "-encoders"]).output().ok()?;
+        if !out.status.success() {
+            return None;
+        }
+        let text = String::from_utf8_lossy(&out.stdout);
+        ["libx264", "libopenh264", "h264_nvenc", "h264_vaapi", "h264_qsv", "h264_v4l2m2m", "h264_amf"]
+            .into_iter()
+            .find(|name| text.lines().any(|l| l.split_whitespace().any(|tok| tok == *name)))
+    })
+}
+
 /// Run ffmpeg to produce `name` (once; written to a temp name and renamed so concurrent test
 /// processes never see a partial file). `None` when ffmpeg is unavailable.
 fn ffmpeg_fixture(name: &str, args: &[&str]) -> Option<PathBuf> {
+    ffmpeg_fixture_inner(name, args, true)
+}
+
+/// Like [`ffmpeg_fixture`] for a fixture this build of ffmpeg may fail to make: an encoder found
+/// in the `-encoders` listing can still not run here (the hardware backends need their device,
+/// Fedora's `libopenh264` is the `noopenh264` stub), and fixtures built from one, like
+/// [`h264_mp4`], should skip with a note rather than fail on the packager's choice of ffmpeg —
+/// the same way every test here skips when ffmpeg is missing altogether.
+fn try_ffmpeg_fixture(name: &str, args: &[&str]) -> Option<PathBuf> {
+    ffmpeg_fixture_inner(name, args, false)
+}
+
+fn ffmpeg_fixture_inner(name: &str, args: &[&str], must_succeed: bool) -> Option<PathBuf> {
     if !have_ffmpeg() {
         eprintln!("ffmpeg not found: skipping");
         return None;
@@ -39,7 +70,14 @@ fn ffmpeg_fixture(name: &str, args: &[&str]) -> Option<PathBuf> {
     let ext = out.extension().map(|e| e.to_string_lossy().to_string()).unwrap_or_default();
     let tmp = out.with_file_name(format!("tmp-{}-{:?}.{ext}", std::process::id(), std::thread::current().id()).replace(['(', ')'], ""));
     let st = Command::new("ffmpeg").args(["-hide_banner", "-loglevel", "error", "-y"]).args(args).arg(&tmp).status().expect("run ffmpeg");
-    assert!(st.success(), "ffmpeg failed for {name}");
+    if !st.success() {
+        let _ = std::fs::remove_file(&tmp);
+        if must_succeed {
+            panic!("ffmpeg failed for {name}");
+        }
+        eprintln!("this ffmpeg build cannot make {name}: skipping");
+        return None;
+    }
     if std::fs::rename(&tmp, &out).is_err() {
         // Another test made it first; on Windows the rename fails while that test has it open.
         let _ = std::fs::remove_file(&tmp);
@@ -48,39 +86,35 @@ fn ffmpeg_fixture(name: &str, args: &[&str]) -> Option<PathBuf> {
     Some(out)
 }
 
+/// Video options the chosen H.264 encoder actually accepts. `libx264` keeps its constant-quality
+/// `-preset`/`-crf` pair; `libopenh264` rejects both (it takes a bitrate), and the hardware
+/// backends take a bitrate too — without this, a build whose picked encoder is not libx264 failed
+/// the fixture and silently skipped every check gated on it.
+fn h264_video_options(enc: &str) -> Vec<&'static str> {
+    if enc == "libx264" { vec!["-preset", "medium", "-crf", "18"] } else { vec!["-b:v", "2M"] }
+}
+
 fn h264_mp4() -> Option<PathBuf> {
-    ffmpeg_fixture(
-        "testsrc2_1080p.mp4",
-        &[
-            "-f",
-            "lavfi",
-            "-i",
-            "testsrc2=size=1920x1080:rate=30:duration=2",
-            "-f",
-            "lavfi",
-            "-i",
-            "sine=frequency=440:sample_rate=48000:duration=2",
-            "-c:v",
-            "libx264",
-            "-pix_fmt",
-            "yuv420p",
-            "-preset",
-            "medium",
-            "-crf",
-            "18",
-            "-colorspace",
-            "bt709",
-            "-color_primaries",
-            "bt709",
-            "-color_trc",
-            "bt709",
-            "-c:a",
-            "aac",
-            "-ac",
-            "2",
-            "-shortest",
-        ],
-    )
+    // Made with whatever encoder this build has listed: a listed encoder can still fail at run
+    // time (the hardware ones without their device), so this may skip rather than fail.
+    let enc = h264_encoder()?;
+    let mut args: Vec<&'static str> = vec![
+        "-f",
+        "lavfi",
+        "-i",
+        "testsrc2=size=1920x1080:rate=30:duration=2",
+        "-f",
+        "lavfi",
+        "-i",
+        "sine=frequency=440:sample_rate=48000:duration=2",
+        "-c:v",
+        enc,
+        "-pix_fmt",
+        "yuv420p",
+    ];
+    args.extend(h264_video_options(enc));
+    args.extend(["-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709", "-c:a", "aac", "-ac", "2", "-shortest"]);
+    try_ffmpeg_fixture("testsrc2_1080p.mp4", &args)
 }
 
 fn prores_mov() -> Option<PathBuf> {
@@ -172,9 +206,14 @@ fn tone_wav() -> Option<PathBuf> {
 
 /// Frame `n` of `src` as RGBA PNG extracted by ffmpeg (Y'CbCr → RGB with the BT.709 matrix).
 fn reference_frame(src: &Path, n: usize) -> Image {
+    reference_frame_in(src, n, "bt709")
+}
+
+/// [`reference_frame`] of a movie whose Y'CbCr is in `matrix` (`bt601` for Motion JPEG).
+fn reference_frame_in(src: &Path, n: usize, matrix: &str) -> Image {
     let stem = src.file_stem().expect("stem").to_string_lossy().to_string();
     let name = format!("ref_{stem}_{n}.png");
-    let vf = format!("select='eq(n\\,{n})',scale=in_color_matrix=bt709:in_range=auto:out_range=pc:flags=bilinear+accurate_rnd+full_chroma_int,format=rgba");
+    let vf = format!("select='eq(n\\,{n})',scale=in_color_matrix={matrix}:in_range=auto:out_range=pc:flags=bilinear+accurate_rnd+full_chroma_int,format=rgba");
     let p = ffmpeg_fixture(&name, &["-i", src.to_str().expect("utf8"), "-vf", &vf, "-fps_mode", "passthrough", "-frames:v", "1"]).expect("ffmpeg");
     load_png(&p)
 }
@@ -281,7 +320,10 @@ fn h264_audio_samples() {
 /// H.264 + AAC at 44.1 kHz in MP4 (ffmpeg writes an edit list that skips the AAC priming):
 /// 440 Hz left, a 200 → 1000 Hz sweep right, 29.97 fps.
 fn aac_44k_mp4() -> Option<PathBuf> {
-    ffmpeg_fixture(
+    // Made with whatever encoder this build has listed: a listed encoder can still fail at run
+    // time (the hardware ones without their device), so this may skip rather than fail.
+    let enc = h264_encoder()?;
+    try_ffmpeg_fixture(
         "aac_44k.mp4",
         &[
             "-f",
@@ -293,7 +335,7 @@ fn aac_44k_mp4() -> Option<PathBuf> {
             "-i",
             "aevalsrc=0.5*sin(2*PI*440*t)|0.5*sin(2*PI*(200+400*t/3)*t):s=44100:d=3",
             "-c:v",
-            "libx264",
+            enc,
             "-pix_fmt",
             "yuv420p",
             "-c:a",
@@ -476,12 +518,12 @@ fn dnxhd_mxf() -> Option<PathBuf> {
     )
 }
 
-/// MXF is importable footage (After Effects imports it), whatever the extension's case.
+/// MXF and AVI are importable footage (After Effects imports them), whatever the extension's case.
 #[test]
-fn mxf_is_importable() {
-    assert!(effectcraft_media::is_importable(Path::new("/media/A001C003.mxf")));
-    assert!(effectcraft_media::is_importable(Path::new("/media/A001C003.MXF")));
-    assert!(!effectcraft_media::is_importable(Path::new("/media/A001C003.avi")), "no AVI demuxer yet");
+fn mxf_and_avi_are_importable() {
+    for name in ["A001C003.mxf", "A001C003.MXF", "capture.avi", "CAPTURE.AVI"] {
+        assert!(effectcraft_media::is_importable(&Path::new("/media").join(name)), "{name}");
+    }
 }
 
 #[test]
@@ -527,6 +569,124 @@ fn mxf_dnxhd_frames() {
     }
 }
 
+fn mjpeg_avi() -> Option<PathBuf> {
+    ffmpeg_fixture(
+        "testsrc2_mjpeg_pcm.avi",
+        &[
+            "-f",
+            "lavfi",
+            "-i",
+            "testsrc2=size=640x360:rate=25:duration=2",
+            "-f",
+            "lavfi",
+            "-i",
+            "sine=frequency=440:sample_rate=48000:duration=2",
+            "-c:v",
+            "mjpeg",
+            "-q:v",
+            "2",
+            "-pix_fmt",
+            "yuvj420p",
+            "-c:a",
+            "pcm_s16le",
+            "-ac",
+            "2",
+        ],
+    )
+}
+
+#[test]
+fn avi_mjpeg_with_pcm_audio() {
+    let Some(p) = mjpeg_avi() else { return };
+    let f = probe(&p).expect("probe");
+    assert_eq!(f.kind, FootageKind::Video);
+    assert_eq!((f.width, f.height), (640, 360));
+    assert_eq!(f.frame_rate, FrameRate::FPS_25);
+    assert!((f.duration.seconds() - 2.0).abs() < 0.1, "duration {:?}", f.duration.seconds());
+    assert!(f.has_video && f.has_audio);
+    assert_eq!(f.codec, "Motion JPEG");
+    let pool = MediaPool::new();
+    for n in [0usize, 1, 30, 7, 49] {
+        let img = pool.frame_at(&f, t_of(f.frame_rate, n as i64)).expect("frame");
+        let db = psnr(&img, &reference_frame_in(&p, n, "bt601"));
+        assert!(db > 35.0, "frame {n}: {db:.2} dB");
+    }
+    let s = pool.audio_samples(&f, Tick(TICKS_PER_SECOND / 2), 4800, 48_000);
+    assert_eq!(s.len(), 9600);
+    let rms = (s.iter().map(|v| v * v).sum::<f32>() / s.len() as f32).sqrt();
+    assert!((rms - 0.0625).abs() < 0.01, "rms {rms}");
+}
+
+/// An AVI whose video FilmCraft can't decode imports, and says why it shows no picture (as an
+/// unsupported stream in any other container does), rather than failing as a broken file.
+#[test]
+fn avi_with_an_unsupported_codec_says_so() {
+    let Some(p) = ffmpeg_fixture("testsrc2_xvid.avi", &["-f", "lavfi", "-i", "testsrc2=size=320x180:rate=25:duration=1", "-c:v", "mpeg4", "-vtag", "XVID"])
+    else {
+        return;
+    };
+    let f = probe(&p).expect("a valid AVI imports");
+    assert_eq!((f.kind, f.width, f.height), (FootageKind::Video, 320, 180));
+    let pool = MediaPool::new();
+    if pool.frame(ItemId(1), &f, Tick::ZERO).is_some() {
+        // FilmCraft decodes MPEG-4 Part 2 now: nothing to report
+        assert_eq!(pool.problem(&f), None);
+        return;
+    }
+    let why = pool.problem(&f).expect("a failed frame leaves a reason");
+    assert!(why.contains("MPEG-4 Part 2") && why.contains("isn't supported"), "{why}");
+}
+
+/// A file that only looks like an AVI is an import error that says so.
+#[test]
+fn an_invalid_avi_is_an_import_error() {
+    let e = probe_bytes("broken.avi", Arc::from(&b"RIFF\x10\0\0\0AVI LIST\0\0\0\0garbage"[..])).expect_err("not an AVI");
+    assert!(e.to_string().contains("invalid AVI"), "{e}");
+}
+
+/// A damaged AVI imports: a truncated recording as far as it goes, and a packet that doesn't
+/// decode loses its own frame only, with a reason that says the file is damaged rather than
+/// unsupported.
+#[test]
+fn a_damaged_avi_loses_only_what_is_damaged() {
+    let Some(p) = mjpeg_avi() else { return };
+    let bytes = std::fs::read(&p).expect("read");
+    let full = probe(&p).expect("probe");
+    let pool = MediaPool::new();
+
+    let cut: Arc<[u8]> = bytes[..bytes.len() / 3].into();
+    let f = probe_bytes("cut.avi", cut.clone()).expect("a truncated AVI imports");
+    assert!(f.duration > Tick::ZERO && f.duration < full.duration, "{:?} of {:?}", f.duration, full.duration);
+    pool.add_bytes("cut.avi", cut);
+    let last = f.frame_rate.frame_at(f.duration - Tick(1));
+    assert!(pool.frame(ItemId(1), &f, t_of(f.frame_rate, last)).is_some(), "its last frame");
+
+    // Garble the JPEG data of the video chunk of frame 10.
+    let mut bad = bytes.clone();
+    let mut at = bad.windows(4).position(|w| w == b"movi").expect("movi") + 4;
+    let mut video = 0;
+    while let Some(head) = bad.get(at..at + 8) {
+        let size = u32::from_le_bytes([head[4], head[5], head[6], head[7]]) as usize;
+        if &head[2..4] == b"dc" {
+            if video == 10 {
+                bad[at + 8 + 200..at + 8 + size.min(3000)].iter_mut().enumerate().for_each(|(i, b)| *b = if i % 7 == 0 { 0xFF } else { 0 });
+                break;
+            }
+            video += 1;
+        }
+        at += 8 + size + size % 2;
+    }
+    assert_eq!(video, 10, "found frame 10's chunk");
+    let f = probe_bytes("bad.avi", bad.clone().into()).expect("a damaged AVI imports");
+    pool.add_bytes("bad.avi", bad.into());
+    assert!(pool.frame(ItemId(2), &f, t_of(f.frame_rate, 10)).is_none(), "the damaged frame");
+    for n in [9, 11, 30] {
+        assert!(pool.frame(ItemId(2), &f, t_of(f.frame_rate, n)).is_some(), "frame {n}");
+    }
+    let why = pool.problem(&f).expect("a failed frame leaves a reason");
+    assert!(why.contains("can't be decoded") && !why.contains("isn't supported"), "{why}");
+}
+
 #[test]
 fn png_sequence_import() {
     let Some(first) = png_sequence() else { return };
@@ -878,7 +1038,7 @@ fn flac_audio_of_any_shape_reads_in_device_blocks() {
         // ffmpeg's sine source has an amplitude of 1/8 (mono is duplicated). The fixture carries
         // channels 0 and 1 at full level and the others at half, so a multichannel file sounds as
         // its stereo downmix (tests/it/downmix.rs checks that matrix channel by channel).
-        let gains = effectcraft_media::downmix::stereo_gains(channels as usize, false);
+        let gains = effectcraft_media::downmix::stereo_gains(channels as usize);
         let side = |s: usize| gains.iter().enumerate().map(|(c, g)| f64::from(g[s]) * if c < 2 { 1.0 } else { 0.5 }).sum::<f64>();
         let want = 0.125 * ((side(0).powi(2) + side(1).powi(2)) / 2.0).sqrt() / 2f64.sqrt();
         let rms = (sum / n.max(1) as f64).sqrt();
@@ -1098,7 +1258,7 @@ fn a_called_off_read_does_not_decode() {
 /// footage reports it (not a black frame without a word).
 #[test]
 fn an_unsupported_stream_reports_why_it_shows_no_picture() {
-    let Some(p) = ffmpeg_fixture(
+    let Some(p) = try_ffmpeg_fixture(
         "h264_high422_10bit.mp4",
         &["-f", "lavfi", "-i", "testsrc=size=320x180:rate=24:duration=1", "-c:v", "libx264", "-profile:v", "high422", "-pix_fmt", "yuv422p10le"],
     ) else {
@@ -1122,3 +1282,13 @@ fn an_unsupported_stream_reports_why_it_shows_no_picture() {
     pool.forget(&f.path);
     assert_eq!(pool.problem(&f), None);
 }
+
+#[test]
+fn the_h264_fixture_options_fit_the_picked_encoder() {
+    assert_eq!(h264_video_options("libx264"), ["-preset", "medium", "-crf", "18"]);
+    for enc in ["libopenh264", "h264_nvenc", "h264_vaapi", "h264_qsv"] {
+        let options = h264_video_options(enc);
+        assert!(!options.iter().any(|o| *o == "-preset" || *o == "-crf"), "{enc} rejects preset/crf: {options:?}");
+        assert!(options.contains(&"-b:v"), "{enc} gets a bitrate: {options:?}");
+    }
+}
diff --git a/crates/media/tests/it/main.rs b/crates/media/tests/it/main.rs
index 5f7fb8037..69bed4a9f 100644
--- a/crates/media/tests/it/main.rs
+++ b/crates/media/tests/it/main.rs
@@ -1,5 +1,6 @@
 //! The crate's integration tests, one binary (each module is a former `tests/<name>.rs`).
 
+mod aac_layout;
 mod downmix;
 mod exif_orientation;
 mod footage;
diff --git a/crates/media/tests/it/open_in_place.rs b/crates/media/tests/it/open_in_place.rs
index 78b0abcbc..2cf314d03 100644
--- a/crates/media/tests/it/open_in_place.rs
+++ b/crates/media/tests/it/open_in_place.rs
@@ -19,8 +19,26 @@ fn fixtures() -> PathBuf {
     Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/fixtures/media")
 }
 
+/// An H.264 encoder this ffmpeg build actually ships, or `None` when it has none (see the same
+/// helper in `footage.rs`: distro "free" builds often omit `libx264` and ship an alternative).
+fn h264_encoder() -> Option<&'static str> {
+    static ENC: std::sync::OnceLock<Option<&'static str>> = std::sync::OnceLock::new();
+    *ENC.get_or_init(|| {
+        let out = Command::new("ffmpeg").args(["-hide_banner", "-encoders"]).output().ok()?;
+        if !out.status.success() {
+            return None;
+        }
+        let text = String::from_utf8_lossy(&out.stdout);
+        ["libx264", "libopenh264", "h264_nvenc", "h264_vaapi", "h264_qsv", "h264_v4l2m2m", "h264_amf"]
+            .into_iter()
+            .find(|name| text.lines().any(|l| l.split_whitespace().any(|tok| tok == *name)))
+    })
+}
+
 /// A 2 s 320×240 H.264 + AAC movie (written to a temp name and renamed, so concurrent test
-/// processes never see a partial file). `None` without ffmpeg.
+/// processes never see a partial file). `None` without ffmpeg, or when this build cannot encode
+/// H.264 at all — the test only measures how a movie is read, so it skips rather than asserting
+/// on the packager's choice of ffmpeg.
 fn small_mp4() -> Option<PathBuf> {
     let out = fixtures().join("in_place_small.mp4");
     if out.exists() {
@@ -29,16 +47,21 @@ fn small_mp4() -> Option<PathBuf> {
     if !Command::new("ffmpeg").arg("-version").output().is_ok_and(|o| o.status.success()) {
         return None;
     }
+    let enc = h264_encoder()?;
     std::fs::create_dir_all(fixtures()).unwrap();
     let tmp = fixtures().join(format!("in_place_tmp_{}.mp4", std::process::id()));
     let st = Command::new("ffmpeg")
         .args(["-hide_banner", "-loglevel", "error", "-y", "-f", "lavfi", "-i", "testsrc2=size=320x240:rate=30:duration=2"])
         .args(["-f", "lavfi", "-i", "sine=frequency=440:sample_rate=48000:duration=2"])
-        .args(["-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac", "-shortest"])
+        .args(["-c:v", enc, "-pix_fmt", "yuv420p", "-c:a", "aac", "-shortest"])
         .arg(&tmp)
         .status()
         .unwrap();
-    assert!(st.success(), "ffmpeg failed");
+    if !st.success() {
+        let _ = std::fs::remove_file(&tmp);
+        eprintln!("this ffmpeg build cannot make in_place_small.mp4: skipping");
+        return None;
+    }
     std::fs::rename(&tmp, &out).unwrap();
     Some(out)
 }
@@ -56,12 +79,29 @@ fn reset_peak() -> Option<u64> {
     status_kib("VmHWM:").map(|k| k * 1024)
 }
 
+/// Set in the child process that does the measuring (see below).
+const ALONE: &str = "EFFECTCRAFT_TEST_RSS_ALONE";
+
 #[test]
 fn a_long_movie_is_read_in_place_not_whole() {
     if !cfg!(target_os = "linux") {
         eprintln!("peak RSS is read from /proc: skipping");
         return;
     }
+    // Peak RSS is per process, and the other tests in this binary run on parallel threads, so
+    // their allocations would count against this one. Measure in a child running only this test.
+    if std::env::var_os(ALONE).is_none() {
+        let out = std::process::Command::new(std::env::current_exe().unwrap())
+            .args(["--exact", "open_in_place::a_long_movie_is_read_in_place_not_whole", "--test-threads=1", "--nocapture"])
+            .env(ALONE, "1")
+            .output()
+            .unwrap();
+        let log = format!("{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr));
+        assert!(out.status.success(), "the measuring child failed:\n{log}");
+        assert!(log.contains("1 passed"), "the measuring child ran no test:\n{log}");
+        eprintln!("{log}");
+        return;
+    }
     let Some(small) = small_mp4() else {
         eprintln!("ffmpeg not found: skipping");
         return;
diff --git a/crates/model/Cargo.toml b/crates/model/Cargo.toml
index 25397921a..ebe7da7e8 100644
--- a/crates/model/Cargo.toml
+++ b/crates/model/Cargo.toml
@@ -14,5 +14,6 @@ effectcraft-geom = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
+log = { workspace = true }
 image = { workspace = true }
-miniz_oxide = "0.8"
+miniz_oxide = "0.9"
diff --git a/crates/model/src/fbx.rs b/crates/model/src/fbx.rs
index 8a3fd9f40..bca387ff2 100644
--- a/crates/model/src/fbx.rs
+++ b/crates/model/src/fbx.rs
@@ -951,5 +951,4 @@ fn parse_within(bytes: &[u8], resolve: &dyn Fn(&str) -> Option<Vec<u8>>, limit:
 }
 
 #[cfg(test)]
-#[path = "fbx_tests.rs"]
 mod tests;
diff --git a/crates/model/src/fbx_tests.rs b/crates/model/src/fbx/tests.rs
similarity index 100%
rename from crates/model/src/fbx_tests.rs
rename to crates/model/src/fbx/tests.rs
diff --git a/crates/model/src/gltf.rs b/crates/model/src/gltf.rs
index e17d014f6..c0b736359 100644
--- a/crates/model/src/gltf.rs
+++ b/crates/model/src/gltf.rs
@@ -11,7 +11,7 @@
 //! `KHR_lights_punctual` lights (directional, point, spot). Sparse accessors and morph targets
 //! are ignored.
 
-use std::sync::Arc;
+use std::{cell::Cell, sync::Arc};
 
 use serde_json::Value;
 
@@ -87,6 +87,8 @@ pub fn uri_decode(s: &str) -> String {
     while i < b.len() {
         if b[i] == b'%'
             && i + 2 < b.len()
+            && b[i + 1].is_ascii_hexdigit()
+            && b[i + 2].is_ascii_hexdigit()
             && let Ok(v) = u8::from_str_radix(std::str::from_utf8(&b[i + 1..i + 3]).unwrap_or("zz"), 16)
         {
             out.push(v);
@@ -112,6 +114,14 @@ fn load_uri(uri: &str, resolve: &dyn Fn(&str) -> Option<Vec<u8>>) -> Result<Vec<
 struct Doc<'a> {
     j: &'a Value,
     buffers: Vec<Vec<u8>>,
+    /// Zero components that buffer-less accessors may still allocate, across the whole file:
+    /// nothing backs them, so many references to one capped accessor must not multiply (#2139).
+    zero_left: Cell<usize>,
+    /// Components every accessor read may still allocate, across the whole file: each primitive
+    /// that references an accessor keeps its own copy, so references must not multiply memory.
+    read_left: Cell<usize>,
+    /// The budget `read_left` started from, for the error message.
+    read_cap: usize,
 }
 
 fn arr<'v>(v: &'v Value, k: &str) -> &'v [Value] {
@@ -126,10 +136,18 @@ fn indices(v: &Value, k: &str) -> Vec<usize> {
     arr(v, k).iter().filter_map(Value::as_u64).filter_map(|c| usize::try_from(c).ok()).collect()
 }
 
-/// The most components an accessor without a buffer view (all zeros) may have: nothing in the
-/// file backs its count, so it is capped instead of checked against a buffer (#1235).
+/// The most components accessors without a buffer view (all zeros) may have, together: nothing
+/// in the file backs their counts, so they are capped instead of checked against a buffer
+/// (#1235, #2139).
 const MAX_ZERO_COMPONENTS: usize = 1 << 24;
 
+/// The most components all accessor reads in one file may allocate together (about 1 GiB as
+/// `f32`/`u32`). Each primitive keeps its own copy of what it reads, so an accessor referenced
+/// N times costs N times; this bounds that by a fixed amount rather than by buffer size, because
+/// real assets legitimately share one vertex buffer across many primitives. A 10M-triangle scan
+/// (5M vertices with position, normal, UV and tangent, 30M indices) reads about 90M.
+const MAX_READ_COMPONENTS: usize = 1 << 28;
+
 /// Where an accessor's elements lie in its buffer: `count` elements of `elem` bytes, `stride`
 /// apart from `base`, all checked to be inside `buf`.
 struct Span<'b> {
@@ -150,7 +168,30 @@ fn nums<const N: usize>(v: &Value, k: &str, d: [f64; N]) -> [f64; N] {
     out
 }
 
+/// Bytes of component `c` of element `i`, with checked offsets (the span was validated, but
+/// nothing derived from the file is indexed unchecked).
+fn component(buf: &[u8], base: usize, stride: usize, i: usize, c: usize, csize: usize) -> Result<&[u8]> {
+    let o = i.checked_mul(stride).and_then(|o| o.checked_add(base)).and_then(|o| o.checked_add(c.checked_mul(csize)?));
+    o.and_then(|o| buf.get(o..o.checked_add(csize)?)).ok_or_else(|| perr("accessor reads past its buffer"))
+}
+
 impl Doc<'_> {
+    /// Charge `total` components to the file's read budget before allocating them.
+    fn charge(&self, total: usize) -> Result<()> {
+        let left = self.read_left.get();
+        let Some(rest) = left.checked_sub(total) else {
+            let cap = self.read_cap;
+            return Err(perr(format!("accessor reads need more than {cap} components in total ({total} requested, {left} left)")));
+        };
+        self.read_left.set(rest);
+        Ok(())
+    }
+
+    /// Charge `count` items of `per` components each.
+    fn charge_each(&self, count: usize, per: usize) -> Result<()> {
+        self.charge(count.checked_mul(per).ok_or_else(|| perr("primitive is too large"))?)
+    }
+
     /// The accessor's element count and total components (`count * n`), checked; and its span in
     /// the buffer, validated before anything is allocated from the count. `None` for an
     /// accessor without a buffer view, whose components are all zero.
@@ -161,16 +202,19 @@ impl Doc<'_> {
         };
         let total = count.checked_mul(n).ok_or_else(|| perr("accessor count is too large"))?;
         let Some(bv) = idx(acc, "bufferView") else {
-            if total > MAX_ZERO_COMPONENTS {
-                return Err(perr(format!("accessor without a bufferView has {total} components (at most {MAX_ZERO_COMPONENTS})")));
-            }
+            let left = self.zero_left.get();
+            let Some(rest) = left.checked_sub(total) else {
+                return Err(perr(format!("accessors without a bufferView have more than {MAX_ZERO_COMPONENTS} components ({total} requested, {left} left)")));
+            };
+            self.zero_left.set(rest);
+            self.charge(total)?;
             return Ok((count, total, None));
         };
         let view = arr(self.j, "bufferViews").get(bv).ok_or_else(|| perr(format!("no bufferView {bv}")))?;
         let buf = self.buffers.get(idx(view, "buffer").unwrap_or(0)).ok_or_else(|| perr("bufferView buffer out of range"))?;
         let past = || perr("accessor reads past its buffer");
         let base = idx(view, "byteOffset").unwrap_or(0).checked_add(idx(acc, "byteOffset").unwrap_or(0)).ok_or_else(past)?;
-        let elem = csize * n;
+        let elem = csize.checked_mul(n).ok_or_else(past)?;
         let stride = idx(view, "byteStride").filter(|s| *s > 0).unwrap_or(elem);
         if stride < elem {
             return Err(perr(format!("bufferView byteStride {stride} is smaller than its {elem}-byte elements")));
@@ -181,6 +225,7 @@ impl Doc<'_> {
                 return Err(past());
             }
         }
+        self.charge(total)?;
         Ok((count, total, Some(Span { buf, base, stride })))
     }
 
@@ -214,8 +259,7 @@ impl Doc<'_> {
         // Matrices of 1/2-byte components pad columns to 4 bytes; ignored (rare).
         for i in 0..count {
             for c in 0..n {
-                let o = base + i * stride + c * csize;
-                let s = buf.get(o..o + csize).ok_or_else(|| perr("accessor reads past its buffer"))?;
+                let s = component(buf, base, stride, i, c, csize)?;
                 out[i * n + c] = match ct {
                     5126 => f32::from_le_bytes([s[0], s[1], s[2], s[3]]),
                     5125 => u32::from_le_bytes([s[0], s[1], s[2], s[3]]) as f32,
@@ -264,8 +308,7 @@ impl Doc<'_> {
         let mut out = Vec::with_capacity(total);
         for i in 0..count {
             for c in 0..n {
-                let o = base + i * stride + c * csize;
-                let s = buf.get(o..o + csize).ok_or_else(|| perr("accessor reads past its buffer"))?;
+                let s = component(buf, base, stride, i, c, csize)?;
                 out.push(match csize {
                     1 => s[0] as u32,
                     2 => u16::from_le_bytes([s[0], s[1]]) as u32,
@@ -279,6 +322,11 @@ impl Doc<'_> {
 
 /// Parse a `.gltf` (JSON) or `.glb` file.
 pub fn parse(bytes: &[u8], resolve: &dyn Fn(&str) -> Option<Vec<u8>>) -> Result<Model> {
+    parse_with_budget(bytes, resolve, MAX_READ_COMPONENTS)
+}
+
+/// [`parse`] with a read budget of `read_budget` accessor components for the whole file.
+pub(crate) fn parse_with_budget(bytes: &[u8], resolve: &dyn Fn(&str) -> Option<Vec<u8>>, read_budget: usize) -> Result<Model> {
     let (json, bin) = if bytes.starts_with(b"glTF") { split_glb(bytes)? } else { (bytes, None) };
     let j: Value = serde_json::from_slice(json).map_err(|e| perr(format!("glTF JSON: {e}")))?;
     let ver = j.get("asset").and_then(|a| a.get("version")).and_then(Value::as_str).unwrap_or("");
@@ -300,7 +348,7 @@ pub fn parse(bytes: &[u8], resolve: &dyn Fn(&str) -> Option<Vec<u8>>) -> Result<
         };
         buffers.push(data);
     }
-    let d = Doc { j: &j, buffers };
+    let d = Doc { j: &j, buffers, zero_left: Cell::new(MAX_ZERO_COMPONENTS), read_left: Cell::new(read_budget), read_cap: read_budget };
 
     // Images → textures (decoded once per image; samplers set the wrap modes).
     let mut images: Vec<Option<Arc<Texture>>> = vec![];
@@ -567,7 +615,11 @@ fn primitive(d: &Doc, p: &Value, materials: &[Material]) -> Result<Option<Primit
     };
     let raw: Vec<u32> = match idx(p, "indices") {
         Some(a) => d.ints(a)?,
-        None => (0..n as u32).collect(),
+        None => {
+            // Generated indices are allocated like a read, once per referencing primitive.
+            d.charge(n)?;
+            (0..n as u32).collect()
+        }
     };
     if raw.iter().any(|&i| i as usize >= n) {
         return Err(perr("index out of range"));
@@ -587,11 +639,19 @@ fn primitive(d: &Doc, p: &Value, materials: &[Material]) -> Result<Option<Primit
         }
         _ => indices.extend(raw.as_chunks::<3>().0.iter().flatten()),
     }
+    // The triangle list is kept besides the raw indices (a strip or fan of k indices becomes
+    // 3(k-2)), so it is charged like a read.
+    d.charge(indices.len())?;
     if normals.len() != n {
         normals.clear();
     }
     let material = idx(p, "material").filter(|&m| m < materials.len());
     let skinned = joints.len() == n && weights.len() == n;
+    if normals.is_empty() {
+        // Flat normals unshare every vertex: position and normal, plus UVs and joints/weights.
+        let per = 6 + if uvs.len() == n { 2 } else { 0 } + if skinned { 8 } else { 0 };
+        d.charge_each(indices.len(), per)?;
+    }
     let mut prim = Primitive {
         positions,
         normals,
@@ -608,7 +668,20 @@ fn primitive(d: &Doc, p: &Value, materials: &[Material]) -> Result<Option<Primit
     }
     let needs_tangents = material.is_some_and(|m| materials[m].normal_tex.is_some());
     if needs_tangents && prim.tangents.is_empty() {
+        d.charge_each(prim.positions.len(), 4)?;
         prim.compute_tangents();
     }
     Ok(Some(prim))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::uri_decode;
+
+    #[test]
+    fn uri_decode_rejects_signed_hex_pair() {
+        assert_eq!(uri_decode("a%+1b"), "a%+1b");
+        assert_eq!(uri_decode("a%-1b"), "a%-1b");
+        assert_eq!(uri_decode("a%41b"), "aAb");
+    }
+}
diff --git a/crates/model/src/obj.rs b/crates/model/src/obj.rs
index 059278ecd..22d9877a2 100644
--- a/crates/model/src/obj.rs
+++ b/crates/model/src/obj.rs
@@ -14,18 +14,52 @@ use std::sync::Arc;
 
 use crate::{AlphaMode, Material, Mesh, Model, Primitive, Result, TexRef, Texture, perr};
 
+/// The last component of a referenced path, treating `\` as a separator too: a path from a
+/// machine of another kind (`C:\textures\checker.png`) still finds `checker.png` next to the
+/// model (#1274). `None` when the name carries no path at all.
+fn sibling_name(name: &str) -> Option<&str> {
+    let file = name.rsplit(['/', '\\']).next()?;
+    (!file.is_empty() && file.len() < name.len()).then_some(file)
+}
+
+/// A material reference resolved against the model's folder: the name as written (a name
+/// containing spaces is one name), then its file name (an absolute path from another machine,
+/// #1274), then the final token (the options convention, `-bm 1 file.png`).
+fn resolve_reference(resolve: &dyn Fn(&str) -> Option<Vec<u8>>, name: &str) -> Option<Vec<u8>> {
+    let mut tried: Vec<&str> = vec![];
+    for candidate in [name, sibling_name(name).unwrap_or(name), name.split_whitespace().last().unwrap_or(name)] {
+        if tried.contains(&candidate) {
+            continue;
+        }
+        tried.push(candidate);
+        if let Some(b) = resolve(candidate) {
+            return Some(b);
+        }
+    }
+    None
+}
+
 /// Parse MTL text into named materials (textures appended to `textures`).
 pub fn parse_mtl(text: &str, resolve: &dyn Fn(&str) -> Option<Vec<u8>>, textures: &mut Vec<Arc<Texture>>) -> Vec<Material> {
     let mut out: Vec<Material> = vec![];
     let mut loaded: HashMap<String, Option<usize>> = HashMap::new();
     let mut tex = |name: &str, textures: &mut Vec<Arc<Texture>>| -> Option<TexRef> {
-        // Options (`-bm 1 file.png`): the file name is the last token.
-        let file = name.split_whitespace().last()?.to_string();
-        let t = *loaded.entry(file.clone()).or_insert_with(|| {
-            let b = resolve(&file)?;
-            let t = Texture::decode(&b).ok()?;
-            textures.push(Arc::new(t));
-            Some(textures.len() - 1)
+        let key = name.trim().to_string();
+        let t = *loaded.entry(key.clone()).or_insert_with(|| {
+            let Some(b) = resolve_reference(resolve, &key) else {
+                log::warn!("model: texture `{key}` was not found next to the model");
+                return None;
+            };
+            match Texture::decode(&b) {
+                Ok(t) => {
+                    textures.push(Arc::new(t));
+                    Some(textures.len() - 1)
+                }
+                Err(e) => {
+                    log::warn!("model: cannot decode texture `{key}`: {e}");
+                    None
+                }
+            }
         });
         t.map(|texture| TexRef { texture, uv_set: 0 })
     };
@@ -147,13 +181,18 @@ pub fn parse(bytes: &[u8], resolve: &dyn Fn(&str) -> Option<Vec<u8>>) -> Result<
             }
             "mtllib" => {
                 let name = line["mtllib".len()..].trim();
-                for file in std::iter::once(name).chain(name.split_whitespace()) {
+                let mut found = false;
+                for file in std::iter::once(name).chain(name.split_whitespace()).chain(sibling_name(name)) {
                     if let Some(b) = resolve(file) {
                         let mut ms = parse_mtl(&String::from_utf8_lossy(&b), resolve, &mut textures);
                         materials.append(&mut ms);
+                        found = true;
                         break;
                     }
                 }
+                if !found && !name.is_empty() {
+                    log::warn!("model: material library `{name}` was not found next to the model");
+                }
             }
             "usemtl" => {
                 let name = line["usemtl".len()..].trim();
diff --git a/crates/model/src/tests.rs b/crates/model/src/tests.rs
index 7c98c1ae7..5ee6a6950 100644
--- a/crates/model/src/tests.rs
+++ b/crates/model/src/tests.rs
@@ -119,6 +119,92 @@ fn obj_without_normals_gets_them() {
     assert!(obj::parse(b"v 0 0 0\n", &|_| None).is_err());
 }
 
+#[test]
+fn obj_textures_from_another_machine_find_the_file_next_to_the_model() {
+    // No committed media: the material file and its textures are written by the test itself.
+    let d = std::env::temp_dir().join(format!("ec-obj-sibling-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&d);
+    std::fs::create_dir_all(&d).unwrap();
+    let png = {
+        let img = image::RgbaImage::from_fn(2, 2, |x, y| if (x + y) % 2 == 0 { image::Rgba([255, 0, 0, 255]) } else { image::Rgba([0, 0, 255, 255]) });
+        let mut out = std::io::Cursor::new(Vec::new());
+        img.write_to(&mut out, image::ImageFormat::Png).unwrap();
+        out.into_inner()
+    };
+    std::fs::write(d.join("checker.png"), &png).unwrap();
+    std::fs::write(d.join("Diffuse Map.png"), &png).unwrap();
+    let mtl = "newmtl Mat\nKd 0.640000 0.640000 0.640000\nmap_Kd C:\\Users\\somebody\\Desktop\\textures\\checker.png\n\
+               newmtl Spaced\nKd 1.000000 1.000000 1.000000\nmap_Kd Diffuse Map.png\n\
+               newmtl Missing\nKd 0.500000 0.500000 0.500000\nmap_Kd nowhere.png\n";
+    let obj = "mtllib quad.mtl\nv -1 -1 0\nv 1 -1 0\nv 1 1 0\nv -1 1 0\nvt 0 0\nvt 1 0\nvt 1 1\nvt 0 1\n\
+               usemtl Mat\nf 1/1 2/2 3/3\nf 1/1 3/3 4/4\n";
+    // Like the media layer's resolver: a relative name joins the model's folder; an absolute
+    // path is only looked up where it points (here: nowhere else).
+    let resolve = |uri: &str| -> Option<Vec<u8>> {
+        let p = std::path::Path::new(uri);
+        if p.is_absolute() {
+            return None;
+        }
+        std::fs::read(d.join(p)).ok()
+    };
+    let resolver = |uri: &str| -> Option<Vec<u8>> { if uri == "quad.mtl" { Some(mtl.as_bytes().to_vec()) } else { resolve(uri) } };
+    let m = obj::parse(obj.as_bytes(), &resolver).unwrap();
+    assert_eq!(m.materials.len(), 3);
+    let mat = &m.materials[0];
+    let t = mat.base_color_tex.expect("the absolute map_Kd path finds checker.png next to the .obj");
+    let tex = &m.textures[t.texture];
+    assert_eq!((tex.width, tex.height), (2, 2));
+    assert_eq!(tex.data[0], [1.0, 0.0, 0.0, 1.0]);
+    assert!((mat.base_color[0] - obj::srgb_to_linear(0.64)).abs() < 1e-6, "Kd still tints the texture");
+    assert!(m.materials[1].base_color_tex.is_some(), "a texture name containing spaces is one name");
+    assert!(m.materials[2].base_color_tex.is_none(), "a genuinely missing texture keeps the Kd colour");
+    assert!((m.materials[2].base_color[0] - obj::srgb_to_linear(0.5)).abs() < 1e-6);
+    // The same fallback applies to the material library itself.
+    let here = obj.replace("mtllib quad.mtl", "mtllib C:\\build\\quad.mtl");
+    assert_eq!(obj::parse(here.as_bytes(), &resolver).unwrap().materials.len(), 3);
+    let _ = std::fs::remove_dir_all(&d);
+}
+
+#[test]
+fn obj_texture_prefers_the_complete_name_over_its_final_token() {
+    // Two textures sit beside the model: `Map.png` (the final whitespace token of the reference)
+    // and `Diffuse Map.png` (the complete name). The complete name must win, its basename next,
+    // the final token last (the `-bm 1 file.png` options convention).
+    let d = std::env::temp_dir().join(format!("ec-obj-full-name-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&d);
+    std::fs::create_dir_all(&d).unwrap();
+    let png = |w: u32| {
+        let img = image::RgbaImage::from_fn(w, 2, |_, _| image::Rgba([255, 0, 0, 255]));
+        let mut out = std::io::Cursor::new(Vec::new());
+        img.write_to(&mut out, image::ImageFormat::Png).unwrap();
+        out.into_inner()
+    };
+    std::fs::write(d.join("Map.png"), png(2)).unwrap();
+    std::fs::write(d.join("Diffuse Map.png"), png(4)).unwrap();
+    let mtl = "newmtl Spaced\nmap_Kd Diffuse Map.png\n\
+               newmtl Absolute\nmap_Kd C:\\tex\\Diffuse Map.png\n\
+               newmtl Options\nmap_Kd -bm 1 Map.png\n";
+    let obj = "mtllib quad.mtl\nv -1 -1 0\nv 1 -1 0\nv 1 1 0\nv -1 1 0\nvt 0 0\nvt 1 0\nvt 1 1\nvt 0 1\n\
+               usemtl Spaced\nf 1/1 2/2 3/3\nf 1/1 3/3 4/4\n";
+    // Like the media layer's resolver: a relative name joins the model's folder; an absolute
+    // path is only looked up where it points (here: nowhere else).
+    let resolve = |uri: &str| -> Option<Vec<u8>> {
+        let p = std::path::Path::new(uri);
+        if p.is_absolute() {
+            return None;
+        }
+        std::fs::read(d.join(p)).ok()
+    };
+    let resolver = |uri: &str| -> Option<Vec<u8>> { if uri == "quad.mtl" { Some(mtl.as_bytes().to_vec()) } else { resolve(uri) } };
+    let m = obj::parse(obj.as_bytes(), &resolver).unwrap();
+    assert_eq!(m.materials.len(), 3);
+    let size = |mat: &Material| mat.base_color_tex.map(|t| (m.textures[t.texture].width, m.textures[t.texture].height));
+    assert_eq!(size(&m.materials[0]), Some((4, 2)), "the complete `Diffuse Map.png` wins over its final token `Map.png`");
+    assert_eq!(size(&m.materials[1]), Some((4, 2)), "an absolute path's spaced basename beats its final token");
+    assert_eq!(size(&m.materials[2]), Some((2, 2)), "the `-bm 1 file.png` options convention still finds the final token");
+    let _ = std::fs::remove_dir_all(&d);
+}
+
 #[test]
 fn channel_interpolation_modes() {
     let mut c = Channel { node: 0, path: ChannelPath::Translation, interp: Interp::Step, times: vec![0.0, 1.0], values: vec![0.0, 0.0, 0.0, 10.0, 0.0, 0.0] };
@@ -564,3 +650,84 @@ fn gltf_strided_and_buffer_less_accessors_still_import() {
     let doc = gltf_doc(r#"{"bufferView": 0, "componentType": 5126, "type": "VEC3", "count": 3}"#, r#"{"buffer": 0, "byteStride": 24}"#, 59);
     assert!(crate::gltf::parse(doc.as_bytes(), &|_| None).is_err());
 }
+
+#[test]
+fn gltf_issue_2139_huge_mat4_count_is_an_error() {
+    // The audit's trigger (#2139): a MAT4 accessor with a count of 10^11, with and without a
+    // buffer view, must fail cleanly instead of sizing an allocation from the count.
+    let view = r#"{"buffer": 0, "byteLength": 64}"#;
+    for acc in [
+        r#"{"bufferView": 0, "componentType": 5126, "type": "MAT4", "count": 100000000000}"#,
+        r#"{"componentType": 5126, "type": "MAT4", "count": 100000000000}"#,
+    ] {
+        let doc = gltf_doc(r#"{"bufferView": 0, "componentType": 5126, "type": "VEC3", "count": 1}"#, view, 64)
+            .replace(r#""count": 1}]"#, &format!(r#""count": 1}}, {acc}]"#))
+            .replace(r#""nodes": [{"mesh": 0}]"#, r#""nodes": [{"mesh": 0, "skin": 0}], "skins": [{"joints": [0], "inverseBindMatrices": 1}]"#);
+        assert!(doc.contains("inverseBindMatrices"), "{doc}");
+        assert!(crate::gltf::parse(doc.as_bytes(), &|_| None).is_err(), "{acc}");
+    }
+}
+
+#[test]
+fn gltf_buffer_less_accessors_share_one_zero_budget() {
+    // Each buffer-less accessor is capped, but nothing backs any of them, so referencing a capped
+    // one from many primitives must not multiply the allocation (#2139).
+    let acc = r#"{"componentType": 5126, "type": "VEC3", "count": 5000000}"#;
+    let prims = [r#"{"attributes": {"POSITION": 0}}"#; 4].join(", ");
+    let doc = gltf_doc(acc, r#"{"buffer": 0}"#, 3).replace(r#"[{"attributes": {"POSITION": 0}}]"#, &format!("[{prims}]"));
+    assert_eq!(doc.matches(r#""POSITION": 0"#).count(), 4);
+    let e = crate::gltf::parse(doc.as_bytes(), &|_| None).err().unwrap_or_else(|| panic!("imported"));
+    assert!(e.to_string().contains("without a bufferView"), "{e}");
+    // One such accessor read once still imports.
+    let doc = gltf_doc(acc, r#"{"buffer": 0}"#, 3);
+    assert!(crate::gltf::parse(doc.as_bytes(), &|_| None).is_ok());
+}
+
+/// `refs` primitives sharing one buffer-backed `verts`-vertex POSITION accessor, without indices.
+fn gltf_shared_positions(verts: usize, refs: usize) -> String {
+    let acc = format!(r#"{{"bufferView": 0, "componentType": 5126, "type": "VEC3", "count": {verts}}}"#);
+    let prims = vec![r#"{"attributes": {"POSITION": 0}}"#; refs].join(", ");
+    gltf_doc(&acc, r#"{"buffer": 0}"#, verts * 12).replace(r#"[{"attributes": {"POSITION": 0}}]"#, &format!("[{prims}]"))
+}
+
+#[test]
+fn gltf_buffer_backed_reads_share_one_read_budget() {
+    // A buffer-backed accessor is checked against its buffer, but each primitive that references
+    // it reads and keeps its own copy, so a small file listing many references must not ask for
+    // memory set by the reference count (#2139 review). Everything a primitive keeps is charged
+    // to one per-file budget: 1,000 vertices without indices or normals cost 3,000 position
+    // components, 1,000 generated indices, a 999-index triangle list and 999 flat-shaded
+    // vertices of 6 components, 10,993 in all.
+    let one = gltf_shared_positions(1000, 1);
+    let m = crate::gltf::parse_with_budget(one.as_bytes(), &|_| None, 20_000).unwrap();
+    assert_eq!(m.meshes[0].primitives.len(), 1);
+    let three = gltf_shared_positions(1000, 3);
+    assert_eq!(three.matches(r#""POSITION": 0"#).count(), 3);
+    let e = crate::gltf::parse_with_budget(three.as_bytes(), &|_| None, 20_000).err().unwrap_or_else(|| panic!("imported"));
+    assert!(e.to_string().contains("more than 20000 components"), "{e}");
+    // The real cap leaves room for legitimate sharing: many primitives over one vertex buffer.
+    let m = crate::gltf::parse(gltf_shared_positions(1000, 50).as_bytes(), &|_| None).unwrap();
+    assert_eq!(m.meshes[0].primitives.len(), 50);
+}
+
+#[test]
+fn gltf_missing_indices_are_charged_to_the_read_budget() {
+    // Without `indices` every vertex gets a generated index, allocated like a read: after the
+    // 3,000 position components, 999 left is one short for the 1,000 indices.
+    let doc = gltf_shared_positions(1000, 1);
+    let e = crate::gltf::parse_with_budget(doc.as_bytes(), &|_| None, 3999).err().unwrap_or_else(|| panic!("imported"));
+    assert!(e.to_string().contains("(1000 requested, 999 left)"), "{e}");
+}
+
+#[test]
+fn gltf_strip_expansion_is_charged_to_the_read_budget() {
+    // A strip of k indices becomes 3(k-2) triangle indices and as many flat-shaded vertices, so
+    // the output is charged, not only the 1,009 components read.
+    let doc = gltf_doc(r#"{"bufferView": 0, "componentType": 5126, "type": "VEC3", "count": 3}"#, r#"{"buffer": 0}"#, 1036)
+        .replace(r#""count": 3}]"#, r#""count": 3}, {"bufferView": 0, "componentType": 5121, "type": "SCALAR", "count": 1000}]"#)
+        .replace(r#""attributes": {"POSITION": 0}"#, r#""attributes": {"POSITION": 0}, "indices": 1, "mode": 5"#);
+    let m = crate::gltf::parse_with_budget(doc.as_bytes(), &|_| None, 30_000).unwrap();
+    assert_eq!(m.meshes[0].primitives[0].indices.len(), 2994);
+    let e = crate::gltf::parse_with_budget(doc.as_bytes(), &|_| None, 5000).err().unwrap_or_else(|| panic!("imported"));
+    assert!(e.to_string().contains("more than 5000 components"), "{e}");
+}
diff --git a/crates/opusenc/src/bands.rs b/crates/opusenc/src/bands.rs
index 744de3fe3..f90a554c4 100644
--- a/crates/opusenc/src/bands.rs
+++ b/crates/opusenc/src/bands.rs
@@ -8,7 +8,8 @@
 
 use crate::range::{BITRES, RangeEncoder, ilog};
 use crate::rate::{Mode, QTHETA_OFFSET, get_pulses};
-use crate::tables::*;
+use crate::tables::EBANDS;
+use crate::{CeltFrame, rate::Allocation};
 
 pub const SPREAD_NORMAL: usize = 2;
 
@@ -55,7 +56,7 @@ fn exp_rotation1_inv(x: &mut [f32], len: usize, stride: usize, c: f32, s: f32) {
     if len <= stride {
         return;
     }
-    if len >= 2 * stride + 1 {
+    if len > 2 * stride {
         for i in 0..=len - 2 * stride - 1 {
             let x1 = x[i];
             let x2 = x[i + stride];
@@ -96,12 +97,24 @@ pub fn exp_rotation_inv(x: &mut [f32], len: usize, k: usize, spread: usize) {
     }
 }
 
+/// Relative slack for the pulse-candidate filter in [`pvq_search`]: far above the f32 rounding of
+/// the filter score (a few 1e-7), far below the spread of real scores.
+const PVQ_SCORE_SLACK: f32 = 1e-5;
+
 /// Greedy PVQ search: the integer vector `y` with `sum |y| = k` closest in direction to `x`.
 pub fn pvq_search(x: &[f32], k: usize, y: &mut [i32]) {
     let n = x.len();
     y[..n].fill(0);
-    let abs: Vec<f32> = x.iter().map(|v| v.abs()).collect();
-    let sum: f32 = abs.iter().sum();
+    // `abs`, `dy` (2 y + 1, infinite in the padding) and the per-pass scores `score`, each padded to
+    // whole 8-lane chunks.
+    let np = n.next_multiple_of(8);
+    let mut buf = vec![0f32; 3 * np];
+    let (abs, rest) = buf.split_at_mut(np);
+    let (dy, score) = rest.split_at_mut(np);
+    for (a, v) in abs.iter_mut().zip(x) {
+        *a = v.abs();
+    }
+    let sum: f32 = abs[..n].iter().sum();
     if !sum.is_finite() || sum <= 1e-15 {
         y[0] = k as i32;
         return;
@@ -113,30 +126,69 @@ pub fn pvq_search(x: &[f32], k: usize, y: &mut [i32]) {
         // Pre-project onto the pyramid (rounding down) and place the rest greedily.
         let r = (k as f32 - 1.0) / sum;
         for j in 0..n {
-            let p = (abs[j] * r).floor() as i32;
+            // Non-negative and at most k, so the truncating cast is the floor.
+            let p = (abs[j] * r) as i32;
             y[j] = p;
             placed += p as usize;
             xy += abs[j] * p as f32;
             yy += (p * p) as f32;
         }
     }
+    for j in 0..np {
+        dy[j] = if j < n { 2.0 * y[j] as f32 + 1.0 } else { f32::INFINITY };
+    }
     while placed < k {
+        // Vectorisable scores (xy + |x_j|)^2 / (yy + 2 y_j + 1) and their maximum.
+        for ((sc, &a), &d) in score.iter_mut().zip(abs.iter()).zip(dy.iter()) {
+            let t = xy + a;
+            *sc = t * t / (yy + d);
+        }
+        let mut lane_max = [0f32; 8];
+        for c in score.as_chunks::<8>().0 {
+            for i in 0..8 {
+                lane_max[i] = if c[i] > lane_max[i] { c[i] } else { lane_max[i] };
+            }
+        }
+        let top = lane_max.iter().fold(0f32, |m, &v| if v > m { v } else { m });
+        // The exact cross-multiplied test below, in index order with the first maximum winning, only
+        // matters for entries within rounding distance of the top score: every other entry is beaten
+        // by the top one whenever it is reached and never beats it afterwards. Running the test on
+        // those alone therefore picks the same pulse as running it on all of them.
+        let filter = top > 1e-30 && top.is_finite();
+        let lo = top * (1.0 - PVQ_SCORE_SLACK);
+        // Usually exactly one entry qualifies; its index falls out of a lane-wise count.
+        let mut count = [0u32; 8];
+        let mut index = [0u32; 8];
+        for (ci, c) in score.as_chunks::<8>().0.iter().enumerate() {
+            for i in 0..8 {
+                let hit = u32::from(c[i] >= lo);
+                count[i] += hit;
+                index[i] += hit * (ci * 8 + i) as u32;
+            }
+        }
         let mut best = 0usize;
-        let mut best_num = -1f32;
-        let mut best_den = 1f32;
-        for j in 0..n {
-            let num = xy + abs[j];
-            let num = num * num;
-            let den = yy + 2.0 * y[j] as f32 + 1.0;
-            if num * best_den > best_num * den {
-                best_num = num;
-                best_den = den;
-                best = j;
+        if filter && count.iter().sum::<u32>() == 1 {
+            best = index.iter().sum::<u32>() as usize;
+        } else {
+            let mut best_num = -1f32;
+            let mut best_den = 1f32;
+            for j in 0..n {
+                if !filter || score[j] >= lo {
+                    let num = xy + abs[j];
+                    let num = num * num;
+                    let den = yy + 2.0 * y[j] as f32 + 1.0;
+                    if num * best_den > best_num * den {
+                        best_num = num;
+                        best_den = den;
+                        best = j;
+                    }
+                }
             }
         }
         xy += abs[best];
         yy += 2.0 * y[best] as f32 + 1.0;
         y[best] += 1;
+        dy[best] = 2.0 * y[best] as f32 + 1.0;
         placed += 1;
     }
     for j in 0..n {
@@ -146,25 +198,45 @@ pub fn pvq_search(x: &[f32], k: usize, y: &mut [i32]) {
     }
 }
 
-/// Encodes the PVQ codeword `y` (`sum |y| = k`) as the index the RFC 6716 §4.3.4.2 decoder maps
-/// back to `y`.
-pub fn encode_pulses(y: &[i32], k: usize, enc: &mut RangeEncoder, v: &mut Vec<u64>) {
-    let n = y.len();
-    let w = k + 1;
-    v.clear();
-    v.resize((n + 1) * w, 0);
+/// Largest band width and pulse count the encoder codes (176 coefficients, `get_pulses(40)` = 128).
+const PVQ_MAX_N: usize = 176;
+const PVQ_MAX_K: usize = 128;
+
+/// Row-major `V(n, k)` for `n <= max_n`, `k <= max_k` with row stride `max_k + 1`, saturated at
+/// `u32::MAX` (a codebook that large is never coded, see `rate::fits_in32`).
+fn build_pvq_table(max_n: usize, max_k: usize) -> Vec<u32> {
+    let w = max_k + 1;
+    let mut v = vec![0u32; (max_n + 1) * w];
     v[0] = 1;
-    for nn in 1..=n {
+    for nn in 1..=max_n {
         v[nn * w] = 1;
-        for kk in 1..=k {
-            let a = v[(nn - 1) * w + kk];
-            let b = v[nn * w + kk - 1];
-            let c = v[(nn - 1) * w + kk - 1];
-            v[nn * w + kk] = a.saturating_add(b).saturating_add(c);
+        for kk in 1..=max_k {
+            let sum = v[(nn - 1) * w + kk] as u64 + v[nn * w + kk - 1] as u64 + v[(nn - 1) * w + kk - 1] as u64;
+            v[nn * w + kk] = sum.min(u32::MAX as u64) as u32;
         }
     }
-    let total = v[n * w + k];
-    let vv = |nn: usize, kx: usize| v[nn * w + kx];
+    v
+}
+
+fn pvq_table() -> &'static [u32] {
+    static TABLE: std::sync::OnceLock<Vec<u32>> = std::sync::OnceLock::new();
+    TABLE.get_or_init(|| build_pvq_table(PVQ_MAX_N, PVQ_MAX_K))
+}
+
+/// Encodes the PVQ codeword `y` (`sum |y| = k`) as the index the RFC 6716 §4.3.4.2 decoder maps
+/// back to `y`.
+pub fn encode_pulses(y: &[i32], k: usize, enc: &mut RangeEncoder) {
+    let n = y.len();
+    // Shapes outside the coded range (never produced by the band layout) get a local table.
+    let local;
+    let (v, w) = if n <= PVQ_MAX_N && k <= PVQ_MAX_K {
+        (pvq_table(), PVQ_MAX_K + 1)
+    } else {
+        local = build_pvq_table(n, k);
+        (&local[..], k + 1)
+    };
+    let row = |nn: usize| &v[nn * w..(nn + 1) * w];
+    let total = row(n)[k] as u64;
     let mut index = 0u64;
     let mut kk = k;
     for j in 0..n {
@@ -173,10 +245,11 @@ pub fn encode_pulses(y: &[i32], k: usize, enc: &mut RangeEncoder, v: &mut Vec<u6
         }
         let rem = n - j;
         let t = y[j].unsigned_abs() as usize;
+        let below = row(rem - 1);
         // Codewords with |y_j| = t start at sum_{m < kk - t} V(rem-1, m) within their sign half.
-        let mut base: u64 = (0..kk - t).map(|m| vv(rem - 1, m)).sum();
+        let mut base: u64 = below[..kk - t].iter().map(|&x| x as u64).sum();
         if y[j] < 0 {
-            base += (vv(rem - 1, kk) + vv(rem, kk)) / 2;
+            base += (below[kk] as u64 + row(rem)[kk] as u64) / 2;
         }
         index += base;
         kk -= t;
@@ -193,7 +266,6 @@ pub struct BandEnc<'m, 'e> {
     pub i: usize,
     pub spread: usize,
     pub remaining_bits: i32,
-    pvq_v: Vec<u64>,
     iy: Vec<i32>,
     tmp: Vec<f32>,
 }
@@ -217,7 +289,7 @@ impl BandEnc<'_, '_> {
             let q = qn as u32;
             let half = q >> 1;
             let ft = (half + 1) * (half + 1);
-            let (fl, fs) = if it <= half { (it * (it + 1) >> 1, it + 1) } else { (ft - ((q + 1 - it) * (q + 2 - it) >> 1), q + 1 - it) };
+            let (fl, fs) = if it <= half { ((it * (it + 1)) >> 1, it + 1) } else { (ft - (((q + 1 - it) * (q + 2 - it)) >> 1), q + 1 - it) };
             self.enc.encode(fl, fl + fs, ft);
             itheta = ((it * 16384) / q) as i32;
         }
@@ -287,36 +359,29 @@ impl BandEnc<'_, '_> {
             iy.clear();
             iy.resize(n, 0);
             pvq_search(&tmp, k, &mut iy);
-            encode_pulses(&iy, k, self.enc, &mut self.pvq_v);
+            encode_pulses(&iy, k, self.enc);
             self.iy = iy;
             self.tmp = tmp;
         }
     }
 }
 
-/// Codes all band shapes (`quant_all_bands`, encoder side, long blocks). `x` holds `c` channels
-/// of `n` normalised MDCT coefficients each.
-#[allow(clippy::too_many_arguments)]
-pub fn quant_all_bands(
-    m: &Mode,
-    start: usize,
-    end: usize,
-    x: &[f32],
-    n_total: usize,
-    c: usize,
-    pulses: &[i32; NB_EBANDS],
-    spread: usize,
-    dual_stereo: bool,
-    intensity: usize,
-    total_bits: i32,
-    mut balance: i32,
-    enc: &mut RangeEncoder,
-    lm: usize,
-    coded_bands: usize,
-) {
+/// Shape-coding controls, independent of the selected band allocation.
+pub struct BandCoding {
+    pub spread: usize,
+    pub total_bits: i32,
+}
+
+/// Codes all band shapes (`quant_all_bands`, encoder side, long blocks). `x` holds
+/// `frame.channels` channels of `n_total` normalised MDCT coefficients each.
+pub fn quant_all_bands(m: &Mode, frame: CeltFrame, x: &[f32], n_total: usize, allocation: &Allocation, coding: BandCoding, enc: &mut RangeEncoder) {
+    let CeltFrame { start, end, channels: c, lm } = frame;
+    let Allocation { pulses, dual_stereo, intensity, coded_bands, balance, .. } = allocation;
+    let (dual_stereo, intensity, coded_bands, mut balance) = (*dual_stereo, *intensity, *coded_bands, *balance);
+    let BandCoding { spread, total_bits } = coding;
     let mm = 1usize << lm;
     debug_assert!(c == 1 || dual_stereo || intensity <= start, "stereo frames are coded as dual stereo");
-    let mut ctx = BandEnc { m, enc, i: 0, spread, remaining_bits: 0, pvq_v: Vec::new(), iy: Vec::new(), tmp: Vec::new() };
+    let mut ctx = BandEnc { m, enc, i: 0, spread, remaining_bits: 0, iy: Vec::new(), tmp: Vec::new() };
     for i in start..end {
         ctx.i = i;
         let xo = mm * EBANDS[i] as usize;
@@ -362,7 +427,7 @@ mod tests {
             x[i + stride] = c * x2 + s * x1;
             x[i] = c * x1 + ms * x2;
         }
-        if len >= 2 * stride + 1 {
+        if len > 2 * stride {
             for i in (0..=len - 2 * stride - 1).rev() {
                 let x1 = x[i];
                 let x2 = x[i + stride];
@@ -466,12 +531,11 @@ mod tests {
 
     #[test]
     fn pvq_index_roundtrip_exhaustive() {
-        let mut v = Vec::new();
         for n in 1..6usize {
             for k in 1..6usize {
                 for y in all_codewords(n, k) {
                     let mut e = RangeEncoder::new();
-                    encode_pulses(&y, k, &mut e, &mut v);
+                    encode_pulses(&y, k, &mut e);
                     let buf = e.done(16);
                     let mut d = RangeDecoder::new(&buf);
                     assert_eq!(decode_pulses(n, k, &mut d), y, "n={n} k={k}");
@@ -480,6 +544,165 @@ mod tests {
         }
     }
 
+    /// The per-call table encoder this module used before the shared table.
+    fn encode_pulses_reference(y: &[i32], k: usize, enc: &mut RangeEncoder) {
+        let n = y.len();
+        let w = k + 1;
+        let mut v = vec![0u64; (n + 1) * w];
+        v[0] = 1;
+        for nn in 1..=n {
+            v[nn * w] = 1;
+            for kk in 1..=k {
+                let a = v[(nn - 1) * w + kk];
+                let b = v[nn * w + kk - 1];
+                let c = v[(nn - 1) * w + kk - 1];
+                v[nn * w + kk] = a.saturating_add(b).saturating_add(c);
+            }
+        }
+        let total = v[n * w + k];
+        let vv = |nn: usize, kx: usize| v[nn * w + kx];
+        let mut index = 0u64;
+        let mut kk = k;
+        for j in 0..n {
+            if kk == 0 {
+                break;
+            }
+            let rem = n - j;
+            let t = y[j].unsigned_abs() as usize;
+            let mut base: u64 = (0..kk - t).map(|m| vv(rem - 1, m)).sum();
+            if y[j] < 0 {
+                base += (vv(rem - 1, kk) + vv(rem, kk)) / 2;
+            }
+            index += base;
+            kk -= t;
+        }
+        if total >= 2 {
+            enc.uint(index as u32, total as u32);
+        }
+    }
+
+    #[test]
+    fn pvq_table_encode_matches_per_call_table() {
+        let mut seed = 0x9E37_79B9_7F4A_7C15u64;
+        let mut next = move |m: u64| {
+            seed ^= seed << 13;
+            seed ^= seed >> 7;
+            seed ^= seed << 17;
+            seed % m
+        };
+        let mut checked = 0;
+        for n in (1..=PVQ_MAX_N).step_by(5).chain([PVQ_MAX_N]) {
+            for k in (1..=PVQ_MAX_K).step_by(3).chain([PVQ_MAX_K]) {
+                if crate::rate::pvq_v(n, k) > u32::MAX as u128 {
+                    continue;
+                }
+                for _ in 0..4 {
+                    let mut y = vec![0i32; n];
+                    for _ in 0..k {
+                        let at = next(n as u64) as usize;
+                        y[at] += if next(2) == 0 { 1 } else { -1 };
+                    }
+                    // Opposite pulses cancel; top up so that sum |y| = k again.
+                    let mut have: usize = y.iter().map(|v| v.unsigned_abs() as usize).sum();
+                    while have < k {
+                        let at = next(n as u64) as usize;
+                        y[at] += if y[at] < 0 { -1 } else { 1 };
+                        have += 1;
+                    }
+                    let (mut a, mut b) = (RangeEncoder::new(), RangeEncoder::new());
+                    encode_pulses(&y, k, &mut a);
+                    encode_pulses_reference(&y, k, &mut b);
+                    assert_eq!(a.done(16), b.done(16), "n={n} k={k}");
+                    checked += 1;
+                }
+            }
+        }
+        assert!(checked > 100, "{checked}");
+    }
+
+    /// The scalar greedy search the vectorised one replaced.
+    fn pvq_search_ref(x: &[f32], k: usize, y: &mut [i32]) {
+        let n = x.len();
+        y[..n].fill(0);
+        let abs: Vec<f32> = x.iter().map(|v| v.abs()).collect();
+        let sum: f32 = abs.iter().sum();
+        if !sum.is_finite() || sum <= 1e-15 {
+            y[0] = k as i32;
+            return;
+        }
+        let mut placed = 0usize;
+        let mut xy = 0f32;
+        let mut yy = 0f32;
+        if k > n / 2 {
+            let r = (k as f32 - 1.0) / sum;
+            for j in 0..n {
+                let p = (abs[j] * r).floor() as i32;
+                y[j] = p;
+                placed += p as usize;
+                xy += abs[j] * p as f32;
+                yy += (p * p) as f32;
+            }
+        }
+        while placed < k {
+            let mut best = 0usize;
+            let mut best_num = -1f32;
+            let mut best_den = 1f32;
+            for j in 0..n {
+                let num = xy + abs[j];
+                let num = num * num;
+                let den = yy + 2.0 * y[j] as f32 + 1.0;
+                if num * best_den > best_num * den {
+                    best_num = num;
+                    best_den = den;
+                    best = j;
+                }
+            }
+            xy += abs[best];
+            yy += 2.0 * y[best] as f32 + 1.0;
+            y[best] += 1;
+            placed += 1;
+        }
+        for j in 0..n {
+            if x[j] < 0.0 {
+                y[j] = -y[j];
+            }
+        }
+    }
+
+    #[test]
+    fn pvq_search_matches_scalar_reference() {
+        let mut state = 0x9e3779b97f4a7c15u64;
+        let mut rnd = move || {
+            state ^= state << 13;
+            state ^= state >> 7;
+            state ^= state << 17;
+            (state >> 40) as f32 / (1u64 << 24) as f32 * 2.0 - 1.0
+        };
+        let mut a = vec![0i32; 200];
+        let mut b = vec![0i32; 200];
+        let mut cases = 0;
+        for round in 0..6000 {
+            let n = 1 + (round * 37 + (rnd().abs() * 176.0) as usize) % 176;
+            let k = 1 + (rnd().abs() * 127.0) as usize;
+            let scale = [1.0f32, 1e-9, 1e6, 3e-3][round % 4];
+            let x: Vec<f32> = (0..n)
+                .map(|_| match round % 6 {
+                    0 => rnd(),
+                    1 => if rnd() > 0.8 { rnd() } else { 0.0 },
+                    2 => (rnd() * 4.0).round() / 4.0,
+                    3 => if rnd() > 0.0 { 1.0 } else { -1.0 },
+                    4 => rnd().powi(5),
+                    _ => if rnd() > 0.95 { 3.0 * rnd() } else { 1e-4 * rnd() },
+                } * scale)
+                .collect();
+            pvq_search(&x, k, &mut a);
+            pvq_search_ref(&x, k, &mut b);
+            assert_eq!(a[..n], b[..n], "n={n} k={k} round={round}");
+            cases += 1;
+        }
+        assert_eq!(cases, 6000);
+    }
+
     #[test]
     fn pvq_search_finds_good_direction() {
         let x: Vec<f32> = (0..32).map(|i| ((i as f32) * 0.7).sin()).collect();
diff --git a/crates/opusenc/src/energy.rs b/crates/opusenc/src/energy.rs
index 0057ae33a..1d4b12719 100644
--- a/crates/opusenc/src/energy.rs
+++ b/crates/opusenc/src/energy.rs
@@ -4,9 +4,10 @@
 //! The quantised energies are updated with exactly the decoder's arithmetic so the prediction
 //! state never drifts between encoder and decoder.
 
+use crate::CeltFrame;
 use crate::range::RangeEncoder;
-use crate::rate::MAX_FINE_BITS;
-use crate::tables::*;
+use crate::rate::{Allocation, MAX_FINE_BITS};
+use crate::tables::{BETA_COEF, BETA_INTRA, E_PROB_MODEL, NB_EBANDS, PRED_COEF, SMALL_ENERGY_ICDF};
 
 const LAPLACE_MINP: u32 = 1;
 const LAPLACE_NMIN: u32 = 16;
@@ -56,18 +57,8 @@ pub fn laplace_encode(enc: &mut RangeEncoder, value: i32, mut fs: u32, decay: u3
 /// `quant_coarse_energy` for one prediction mode. `e` holds the target log2 energies (relative
 /// to `E_MEANS`), `old_e` the quantised energies, updated in place. `budget` is the frame size in
 /// bits.
-#[allow(clippy::too_many_arguments)]
-pub fn quant_coarse_energy(
-    start: usize,
-    end: usize,
-    e: &[f32; 2 * NB_EBANDS],
-    old_e: &mut [f32; 2 * NB_EBANDS],
-    intra: bool,
-    enc: &mut RangeEncoder,
-    c: usize,
-    lm: usize,
-    budget: i32,
-) {
+pub fn quant_coarse_energy(frame: CeltFrame, e: &[f32; 2 * NB_EBANDS], old_e: &mut [f32; 2 * NB_EBANDS], intra: bool, enc: &mut RangeEncoder, budget: i32) {
+    let CeltFrame { start, end, channels: c, lm } = frame;
     let prob = &E_PROB_MODEL[lm][intra as usize];
     let (coef, beta) = if intra { (0.0, BETA_INTRA) } else { (PRED_COEF[lm], BETA_COEF[lm]) };
     let mut prev = [0f32; 2];
@@ -111,15 +102,8 @@ pub fn quant_coarse_energy(
 }
 
 /// `quant_fine_energy`: raw bits refining each band's quantised energy.
-pub fn quant_fine_energy(
-    start: usize,
-    end: usize,
-    e: &[f32; 2 * NB_EBANDS],
-    old_e: &mut [f32; 2 * NB_EBANDS],
-    fine_quant: &[i32; NB_EBANDS],
-    enc: &mut RangeEncoder,
-    c: usize,
-) {
+pub fn quant_fine_energy(frame: CeltFrame, e: &[f32; 2 * NB_EBANDS], old_e: &mut [f32; 2 * NB_EBANDS], fine_quant: &[i32; NB_EBANDS], enc: &mut RangeEncoder) {
+    let CeltFrame { start, end, channels: c, .. } = frame;
     for i in start..end {
         let fq = fine_quant[i];
         if fq <= 0 {
@@ -139,18 +123,16 @@ pub fn quant_fine_energy(
 
 /// `quant_energy_finalise`: spends the bits left at the end of the frame on one more bit of
 /// energy resolution per band, in priority order.
-#[allow(clippy::too_many_arguments)]
 pub fn quant_energy_finalise(
-    start: usize,
-    end: usize,
+    frame: CeltFrame,
     e: &[f32; 2 * NB_EBANDS],
     old_e: &mut [f32; 2 * NB_EBANDS],
-    fine_quant: &[i32; NB_EBANDS],
-    fine_priority: &[i32; NB_EBANDS],
+    allocation: &Allocation,
     mut bits_left: i32,
     enc: &mut RangeEncoder,
-    c: usize,
 ) {
+    let CeltFrame { start, end, channels: c, .. } = frame;
+    let Allocation { fine_quant, fine_priority, .. } = allocation;
     for prio in 0..2 {
         let mut i = start;
         while i < end && bits_left >= c as i32 {
diff --git a/crates/opusenc/src/lib.rs b/crates/opusenc/src/lib.rs
index 9cc1f6a51..b4346ebd6 100644
--- a/crates/opusenc/src/lib.rs
+++ b/crates/opusenc/src/lib.rs
@@ -24,8 +24,6 @@
 //! ```
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
-// The bit-allocation code mirrors the normative integer arithmetic; keep C-like shift expressions.
-#![allow(clippy::precedence, clippy::int_plus_one)]
 
 mod bands;
 mod energy;
@@ -38,14 +36,23 @@ mod tables;
 
 use std::sync::OnceLock;
 
-use bands::{SPREAD_NORMAL, quant_all_bands};
+use bands::{BandCoding, SPREAD_NORMAL, quant_all_bands};
 use energy::{quant_coarse_energy, quant_energy_finalise, quant_fine_energy};
 use mdct::Mdct;
 use range::{BITRES, RangeEncoder};
-use rate::{Mode as CeltMode, compute_allocation};
+use rate::{AllocationInput, Mode as CeltMode, compute_allocation};
 use resample::Downsampler;
 use silk::SilkEncoder;
-use tables::*;
+use tables::{E_MEANS, EBANDS, NB_EBANDS, OVERLAP, PREEMPH, SPREAD_ICDF, TF_SELECT_TABLE, TRIM_ICDF};
+
+/// Band range, channel count and transform size shared by CELT coding stages.
+#[derive(Clone, Copy)]
+struct CeltFrame {
+    start: usize,
+    end: usize,
+    channels: usize,
+    lm: usize,
+}
 
 /// Samples per channel in one 20 ms frame at 48 kHz.
 const N: usize = 960;
@@ -314,7 +321,7 @@ impl OpusEncoder {
             Mode::Celt => {
                 let (log_e, silence) = self.celt_analysis(pcm);
                 let len = self.frame_bytes;
-                packet.extend_from_slice(&self.encode_celt(RangeEncoder::new(), len, 0, NB_EBANDS, &log_e, silence));
+                packet.extend_from_slice(&self.encode_celt(RangeEncoder::new(), len, 0..NB_EBANDS, &log_e, silence));
             }
             Mode::Silk => {
                 let x = self.silk_input(pcm);
@@ -344,7 +351,7 @@ impl OpusEncoder {
                 }
                 let (log_e, _) = self.celt_analysis(pcm);
                 let end = if self.bandwidth == Bandwidth::SuperWideband { 19 } else { NB_EBANDS };
-                packet.extend_from_slice(&self.encode_celt(enc, len, HYBRID_START_BAND, end, &log_e, false));
+                packet.extend_from_slice(&self.encode_celt(enc, len, HYBRID_START_BAND..end, &log_e, false));
             }
         }
         packet
@@ -406,10 +413,11 @@ impl OpusEncoder {
     /// Codes one CELT frame (RFC 6716 §4.3, in bitstream order) of `len` bytes into `enc`
     /// (which already holds the SILK frame in hybrid mode), coding bands `start..end`, and
     /// finalises the frame.
-    #[allow(clippy::too_many_arguments)]
-    fn encode_celt(&mut self, mut enc: RangeEncoder, len: usize, start: usize, end: usize, log_e: &[f32; 2 * NB_EBANDS], silence: bool) -> Vec<u8> {
+    fn encode_celt(&mut self, mut enc: RangeEncoder, len: usize, bands: std::ops::Range<usize>, log_e: &[f32; 2 * NB_EBANDS], silence: bool) -> Vec<u8> {
         let m = celt_mode();
         let c = self.channels;
+        let frame = CeltFrame { start: bands.start, end: bands.end, channels: c, lm: LM };
+        let CeltFrame { start, end, .. } = frame;
         if c == 1 {
             for i in 0..NB_EBANDS {
                 self.old_band_e[i] = self.old_band_e[i].max(self.old_band_e[NB_EBANDS + i]);
@@ -438,10 +446,10 @@ impl OpusEncoder {
             let mut enc_intra = enc.clone();
             let mut old_intra = self.old_band_e;
             enc_intra.bit_logp(true, 3);
-            quant_coarse_energy(start, end, log_e, &mut old_intra, true, &mut enc_intra, c, LM, total_bits_raw);
+            quant_coarse_energy(frame, log_e, &mut old_intra, true, &mut enc_intra, total_bits_raw);
             enc.bit_logp(false, 3);
             let mut old_inter = self.old_band_e;
-            quant_coarse_energy(start, end, log_e, &mut old_inter, false, &mut enc, c, LM, total_bits_raw);
+            quant_coarse_energy(frame, log_e, &mut old_inter, false, &mut enc, total_bits_raw);
             if enc_intra.tell_frac() < enc.tell_frac() {
                 enc = enc_intra;
                 self.old_band_e = old_intra;
@@ -449,14 +457,14 @@ impl OpusEncoder {
                 self.old_band_e = old_inter;
             }
         } else {
-            quant_coarse_energy(start, end, log_e, &mut self.old_band_e, false, &mut enc, c, LM, total_bits_raw);
+            quant_coarse_energy(frame, log_e, &mut self.old_band_e, false, &mut enc, total_bits_raw);
         }
         // TF resolution: no changes.
         {
             let mut budget = total_bits_raw;
             let mut tell = enc.tell();
             let mut logp = 4;
-            let tf_select_rsv = LM > 0 && tell + logp + 1 <= budget;
+            let tf_select_rsv = LM > 0 && tell + logp < budget;
             budget -= tf_select_rsv as i32;
             for _ in start..end {
                 if tell + logp <= budget {
@@ -488,27 +496,11 @@ impl OpusEncoder {
             enc.icdf(alloc_trim as usize, &TRIM_ICDF, 7);
         }
         let bits = (total_bits_raw << BITRES) - enc.tell_frac() - 1;
-        let alloc = compute_allocation(m, start, end, &offsets, &cap, alloc_trim, bits, c, LM, &mut enc);
-        quant_fine_energy(start, end, log_e, &mut self.old_band_e, &alloc.fine_quant, &mut enc, c);
-        quant_all_bands(
-            m,
-            start,
-            end,
-            &self.freq,
-            N,
-            c,
-            &alloc.pulses,
-            SPREAD_NORMAL,
-            alloc.dual_stereo,
-            alloc.intensity,
-            total_bits_raw << BITRES,
-            alloc.balance,
-            &mut enc,
-            LM,
-            alloc.coded_bands,
-        );
+        let alloc = compute_allocation(m, frame, AllocationInput { offsets: &offsets, cap: &cap, trim: alloc_trim, bits }, &mut enc);
+        quant_fine_energy(frame, log_e, &mut self.old_band_e, &alloc.fine_quant, &mut enc);
+        quant_all_bands(m, frame, &self.freq, N, &alloc, BandCoding { spread: SPREAD_NORMAL, total_bits: total_bits_raw << BITRES }, &mut enc);
         let bits_left = total_bits_raw - enc.tell();
-        quant_energy_finalise(start, end, log_e, &mut self.old_band_e, &alloc.fine_quant, &alloc.fine_priority, bits_left, &mut enc, c);
+        quant_energy_finalise(frame, log_e, &mut self.old_band_e, &alloc, bits_left, &mut enc);
         debug_assert!(enc.tell() <= total_bits_raw, "frame overflow: {} > {}", enc.tell(), total_bits_raw);
         if c == 1 {
             let (a, b) = self.old_band_e.split_at_mut(NB_EBANDS);
diff --git a/crates/opusenc/src/mdct.rs b/crates/opusenc/src/mdct.rs
index 814de0375..131c4a7a1 100644
--- a/crates/opusenc/src/mdct.rs
+++ b/crates/opusenc/src/mdct.rs
@@ -24,6 +24,10 @@ impl Cpx {
     fn add(self, o: Cpx) -> Cpx {
         Cpx { re: self.re + o.re, im: self.im + o.im }
     }
+    #[inline]
+    fn sub(self, o: Cpx) -> Cpx {
+        Cpx { re: self.re - o.re, im: self.im - o.im }
+    }
 }
 
 /// Mixed-radix (2, 3, 4, 5) forward complex FFT, unscaled (decimation in time, recursive).
@@ -71,18 +75,64 @@ impl Fft {
                 self.rec(&mut out[q * m..(q + 1) * m], &inp[q * in_stride..], in_stride * p, m, fi + 1, tw_stride * p);
             }
         }
-        let big = self.n;
-        let mut t = [Cpx::default(); 5];
-        for k in 0..m {
-            for (q, tq) in t.iter_mut().enumerate().take(p) {
-                *tq = out[q * m + k].mul(self.twiddle[(q * k * tw_stride) % big]);
+        // The twiddle index q * k * tw_stride is always below n, so no modulo is needed.
+        let tw = &self.twiddle;
+        match p {
+            2 => {
+                for k in 0..m {
+                    let a0 = out[k];
+                    let a1 = out[m + k].mul(tw[k * tw_stride]);
+                    out[k] = a0.add(a1);
+                    out[m + k] = a0.sub(a1);
+                }
             }
-            for q2 in 0..p {
-                let mut acc = Cpx::default();
-                for (q, tq) in t.iter().enumerate().take(p) {
-                    acc = acc.add(tq.mul(self.twiddle[((q * q2) % p) * (big / p)]));
+            4 => {
+                for k in 0..m {
+                    let t0 = out[k];
+                    let t1 = out[m + k].mul(tw[k * tw_stride]);
+                    let t2 = out[2 * m + k].mul(tw[2 * k * tw_stride]);
+                    let t3 = out[3 * m + k].mul(tw[3 * k * tw_stride]);
+                    let (s0, d0) = (t0.add(t2), t0.sub(t2));
+                    let (s1, d1) = (t1.add(t3), t1.sub(t3));
+                    out[k] = s0.add(s1);
+                    out[2 * m + k] = s0.sub(s1);
+                    // The odd outputs combine d0 with -j * d1 = (d1.im, -d1.re) and its negative.
+                    out[m + k] = Cpx { re: d0.re + d1.im, im: d0.im - d1.re };
+                    out[3 * m + k] = Cpx { re: d0.re - d1.im, im: d0.im + d1.re };
+                }
+            }
+            3 => {
+                // Imaginary part of exp(-2 pi i / 3) = -sqrt(3) / 2.
+                let h = tw[self.n / 3].im;
+                for k in 0..m {
+                    let t0 = out[k];
+                    let t1 = out[m + k].mul(tw[k * tw_stride]);
+                    let t2 = out[2 * m + k].mul(tw[2 * k * tw_stride]);
+                    let (s, d) = (t1.add(t2), t1.sub(t2));
+                    let a = Cpx { re: t0.re - 0.5 * s.re, im: t0.im - 0.5 * s.im };
+                    out[k] = t0.add(s);
+                    // j * h * d = (-h * d.im, h * d.re)
+                    out[m + k] = Cpx { re: a.re - h * d.im, im: a.im + h * d.re };
+                    out[2 * m + k] = Cpx { re: a.re + h * d.im, im: a.im - h * d.re };
+                }
+            }
+            _ => {
+                // Generic DFT butterfly (radix 5, once per transform).
+                let roots: [Cpx; 5] = std::array::from_fn(|q| if q < p { tw[q * (self.n / p)] } else { Cpx::default() });
+                let mut t = [Cpx::default(); 5];
+                for k in 0..m {
+                    t[0] = out[k];
+                    for q in 1..p {
+                        t[q] = out[q * m + k].mul(tw[q * k * tw_stride]);
+                    }
+                    for q2 in 0..p {
+                        let mut acc = t[0];
+                        for q in 1..p {
+                            acc = acc.add(t[q].mul(roots[(q * q2) % p]));
+                        }
+                        out[q2 * m + k] = acc;
+                    }
                 }
-                out[q2 * m + k] = acc;
             }
         }
     }
@@ -198,6 +248,26 @@ mod tests {
             .collect()
     }
 
+    #[test]
+    fn fft_matches_dft() {
+        // Every radix combination, including the 480-point size of the 20 ms frame.
+        for &n in &[2usize, 3, 4, 5, 6, 8, 12, 15, 16, 20, 24, 30, 48, 60, 120, 240, 480] {
+            let fft = Fft::new(n);
+            let x: Vec<Cpx> = (0..n).map(|i| Cpx { re: ((i * 37 % 101) as f32 - 50.0) / 7.0, im: ((i * 53 % 89) as f32 - 44.0) / 9.0 }).collect();
+            let mut y = x.clone();
+            fft.process(&mut y, &mut Vec::new());
+            for k in 0..n {
+                let (mut re, mut im) = (0f64, 0f64);
+                for (j, v) in x.iter().enumerate() {
+                    let ph = -2.0 * std::f64::consts::PI * ((j * k) % n) as f64 / n as f64;
+                    re += v.re as f64 * ph.cos() - v.im as f64 * ph.sin();
+                    im += v.re as f64 * ph.sin() + v.im as f64 * ph.cos();
+                }
+                assert!((y[k].re as f64 - re).abs() < 2e-3 && (y[k].im as f64 - im).abs() < 2e-3, "n={n} k={k}: ({}, {}) vs ({re}, {im})", y[k].re, y[k].im);
+            }
+        }
+    }
+
     #[test]
     fn matches_direct_formula() {
         for &n in &[240usize, 960] {
diff --git a/crates/opusenc/src/rate.rs b/crates/opusenc/src/rate.rs
index a6ae81f5c..ff6ccae95 100644
--- a/crates/opusenc/src/rate.rs
+++ b/crates/opusenc/src/rate.rs
@@ -4,8 +4,9 @@
 //! spec-derived `filmcraft-opus` decoder (first-party, MIT OR Apache-2.0) step by step; the only
 //! difference is that the encoder *writes* the band-skip, intensity and dual-stereo symbols.
 
+use crate::CeltFrame;
 use crate::range::{BITRES, RangeEncoder, ilog};
-use crate::tables::*;
+use crate::tables::{ALLOC, EBANDS, LOG2_FRAC_TABLE, MAX_LM, NB_EBANDS};
 
 const MAX_PSEUDO: i32 = 40;
 const LOG_MAX_PSEUDO: i32 = 6;
@@ -127,7 +128,7 @@ impl Mode {
         let mut cap = [0i32; NB_EBANDS];
         for (i, cp) in cap.iter_mut().enumerate() {
             let n = (EBANDS[i + 1] - EBANDS[i]) << lm;
-            *cp = (self.caps[NB_EBANDS * (2 * lm + c - 1) + i] as i32 + 64) * c as i32 * n >> 2;
+            *cp = ((self.caps[NB_EBANDS * (2 * lm + c - 1) + i] as i32 + 64) * c as i32 * n) >> 2;
         }
         cap
     }
@@ -200,7 +201,7 @@ fn compute_caps(m: &Mode) -> Vec<u8> {
                 let mut n0 = EBANDS[j + 1] - EBANDS[j];
 
                 let max_bits = if n0 << i == 1 {
-                    c * (1 + MAX_FINE_BITS) << BITRES
+                    (c * (1 + MAX_FINE_BITS)) << BITRES
                 } else {
                     let mut lm0 = 0;
                     if n0 > 2 {
@@ -240,7 +241,7 @@ fn compute_caps(m: &Mode) -> Vec<u8> {
                     let num = mb + ndof * offset;
                     let den = (ndof - 1) << BITRES;
                     let qb = ((num + (den >> 1)) / den).min(MAX_FINE_BITS);
-                    mb += c * qb << BITRES;
+                    mb += (c * qb) << BITRES;
                     mb
                 };
                 let w = c * ((EBANDS[j + 1] - EBANDS[j]) << i);
@@ -263,21 +264,19 @@ pub struct Allocation {
     pub fine_priority: [i32; NB_EBANDS],
 }
 
+/// Per-band limits, boosts and available budget for the allocation search.
+pub struct AllocationInput<'a> {
+    pub offsets: &'a [i32; NB_EBANDS],
+    pub cap: &'a [i32; NB_EBANDS],
+    pub trim: i32,
+    pub bits: i32,
+}
+
 /// `clt_compute_allocation`, encoder side. Stereo frames are always coded as dual (L/R) stereo
 /// with no intensity bands, and no band is skipped voluntarily.
-#[allow(clippy::too_many_arguments)]
-pub fn compute_allocation(
-    m: &Mode,
-    start: usize,
-    end: usize,
-    offsets: &[i32; NB_EBANDS],
-    cap: &[i32; NB_EBANDS],
-    alloc_trim: i32,
-    total: i32,
-    c: usize,
-    lm: usize,
-    enc: &mut RangeEncoder,
-) -> Allocation {
+pub fn compute_allocation(m: &Mode, frame: CeltFrame, input: AllocationInput<'_>, enc: &mut RangeEncoder) -> Allocation {
+    let CeltFrame { start, end, channels: c, lm } = frame;
+    let AllocationInput { offsets, cap, trim: alloc_trim, bits: total } = input;
     let ci = c as i32;
     let lmi = lm as i32;
     let mut total = total.max(0);
@@ -302,8 +301,8 @@ pub fn compute_allocation(
     let mut trim_offset = [0i32; NB_EBANDS];
     for j in start..end {
         let w = EBANDS[j + 1] - EBANDS[j];
-        thresh[j] = (ci << BITRES).max((3 * w << lmi << BITRES) >> 4);
-        trim_offset[j] = ci * w * (alloc_trim - 5 - lmi) * (end as i32 - j as i32 - 1) * (1 << (lmi + BITRES as i32)) >> 6;
+        thresh[j] = (ci << BITRES).max(((3 * w) << lmi << BITRES) >> 4);
+        trim_offset[j] = (ci * w * (alloc_trim - 5 - lmi) * (end as i32 - j as i32 - 1) * (1 << (lmi + BITRES as i32))) >> 6;
         if w << lmi == 1 {
             trim_offset[j] -= ci << BITRES;
         }
@@ -317,7 +316,7 @@ pub fn compute_allocation(
         let mid = (lo + hi) >> 1;
         for j in (start..end).rev() {
             let n = EBANDS[j + 1] - EBANDS[j];
-            let mut bitsj = ci * n * (ALLOC[mid as usize][j] as i32) << lmi >> 2;
+            let mut bitsj = (ci * n * (ALLOC[mid as usize][j] as i32)) << lmi >> 2;
             if bitsj > 0 {
                 bitsj = (bitsj + trim_offset[j]).max(0);
             }
@@ -342,8 +341,8 @@ pub fn compute_allocation(
     lo -= 1;
     for j in start..end {
         let n = EBANDS[j + 1] - EBANDS[j];
-        let mut bits1j = ci * n * (ALLOC[lo as usize][j] as i32) << lmi >> 2;
-        let mut bits2j = if hi >= nb_alloc { cap[j] } else { ci * n * (ALLOC[hi as usize][j] as i32) << lmi >> 2 };
+        let mut bits1j = (ci * n * (ALLOC[lo as usize][j] as i32)) << lmi >> 2;
+        let mut bits2j = if hi >= nb_alloc { cap[j] } else { (ci * n * (ALLOC[hi as usize][j] as i32)) << lmi >> 2 };
         if bits1j > 0 {
             bits1j = (bits1j + trim_offset[j]).max(0);
         }
@@ -361,27 +360,27 @@ pub fn compute_allocation(
         bits1[j] = bits1j;
         bits2[j] = bits2j;
     }
-    interp_bits2pulses(m, start, end, skip_start, &bits1, &bits2, &thresh, cap, total, skip_rsv, intensity_rsv, dual_stereo_rsv, c, lm, enc)
+    let interpolation =
+        AllocationInterpolation { skip_start, bits1: &bits1, bits2: &bits2, thresh: &thresh, cap, total, skip_rsv, intensity_rsv, dual_stereo_rsv };
+    interp_bits2pulses(m, frame, interpolation, enc)
 }
 
-#[allow(clippy::too_many_arguments)]
-fn interp_bits2pulses(
-    m: &Mode,
-    start: usize,
-    end: usize,
+/// Bracketing allocation vectors and signalling reserves for the interpolation stage.
+struct AllocationInterpolation<'a> {
     skip_start: usize,
-    bits1: &[i32; NB_EBANDS],
-    bits2: &[i32; NB_EBANDS],
-    thresh: &[i32; NB_EBANDS],
-    cap: &[i32; NB_EBANDS],
-    mut total: i32,
+    bits1: &'a [i32; NB_EBANDS],
+    bits2: &'a [i32; NB_EBANDS],
+    thresh: &'a [i32; NB_EBANDS],
+    cap: &'a [i32; NB_EBANDS],
+    total: i32,
     skip_rsv: i32,
-    mut intensity_rsv: i32,
-    mut dual_stereo_rsv: i32,
-    c: usize,
-    lm: usize,
-    enc: &mut RangeEncoder,
-) -> Allocation {
+    intensity_rsv: i32,
+    dual_stereo_rsv: i32,
+}
+
+fn interp_bits2pulses(m: &Mode, frame: CeltFrame, interpolation: AllocationInterpolation<'_>, enc: &mut RangeEncoder) -> Allocation {
+    let CeltFrame { start, end, channels: c, lm } = frame;
+    let AllocationInterpolation { skip_start, bits1, bits2, thresh, cap, mut total, skip_rsv, mut intensity_rsv, mut dual_stereo_rsv } = interpolation;
     let ci = c as i32;
     let alloc_floor = ci << BITRES;
     let stereo = (c > 1) as i32;
@@ -393,7 +392,7 @@ fn interp_bits2pulses(
         let mut psum = 0;
         let mut done = false;
         for j in (start..end).rev() {
-            let tmp = bits1[j] + (mid * bits2[j] >> ALLOC_STEPS);
+            let tmp = bits1[j] + ((mid * bits2[j]) >> ALLOC_STEPS);
             if tmp >= thresh[j] || done {
                 done = true;
                 psum += tmp.min(cap[j]);
@@ -411,7 +410,7 @@ fn interp_bits2pulses(
     let mut psum = 0;
     let mut done = false;
     for j in (start..end).rev() {
-        let mut tmp = bits1[j] + (lo * bits2[j] >> ALLOC_STEPS);
+        let mut tmp = bits1[j] + ((lo * bits2[j]) >> ALLOC_STEPS);
         if tmp < thresh[j] && !done {
             tmp = if tmp >= alloc_floor { alloc_floor } else { 0 };
         } else {
@@ -500,9 +499,9 @@ fn interp_bits2pulses(
             if n == 2 {
                 offset += (den << BITRES) >> 2;
             }
-            if bits[j] + offset < den * 2 << BITRES {
+            if bits[j] + offset < (den * 2) << BITRES {
                 offset += nclogn >> 2;
-            } else if bits[j] + offset < den * 3 << BITRES {
+            } else if bits[j] + offset < (den * 3) << BITRES {
                 offset += nclogn >> 3;
             }
             let mut eb = (bits[j] + offset + (den << (BITRES - 1))).max(0);
@@ -513,7 +512,7 @@ fn interp_bits2pulses(
             eb = eb.min(MAX_FINE_BITS);
             ebits[j] = eb;
             fine_priority[j] = (eb * (den << BITRES) >= bits[j] + offset) as i32;
-            bits[j] -= ci * eb << BITRES;
+            bits[j] -= (ci * eb) << BITRES;
         } else {
             excess = (bit - (ci << BITRES)).max(0);
             bits[j] = bit - excess;
@@ -523,7 +522,7 @@ fn interp_bits2pulses(
         if excess > 0 {
             let extra_fine = (excess >> (stereo + BITRES as i32)).min(MAX_FINE_BITS - ebits[j]);
             ebits[j] += extra_fine;
-            let extra_bits = extra_fine * ci << BITRES;
+            let extra_bits = (extra_fine * ci) << BITRES;
             fine_priority[j] = (extra_bits >= excess - balance) as i32;
             excess -= extra_bits;
         }
diff --git a/crates/opusenc/src/resample.rs b/crates/opusenc/src/resample.rs
index 9045cb86d..1acc9a4e7 100644
--- a/crates/opusenc/src/resample.rs
+++ b/crates/opusenc/src/resample.rs
@@ -45,6 +45,25 @@ fn design(fc: f64, beta: f64, delay: usize) -> Vec<f32> {
     h.iter().map(|&v| v as f32).collect()
 }
 
+/// Dot product with eight independent partial sums, which the compiler can vectorise (a single
+/// running sum is bound by the latency of the float addition). The sums are combined pairwise.
+#[inline]
+fn dot8(a: &[f32], b: &[f32]) -> f32 {
+    let mut s = [0f32; 8];
+    let (ca, ra) = a.as_chunks::<8>();
+    let (cb, rb) = b.as_chunks::<8>();
+    for (x, y) in ca.iter().zip(cb) {
+        for l in 0..8 {
+            s[l] += x[l] * y[l];
+        }
+    }
+    let mut acc = ((s[0] + s[4]) + (s[1] + s[5])) + ((s[2] + s[6]) + (s[3] + s[7]));
+    for (x, y) in ra.iter().zip(rb) {
+        acc += x * y;
+    }
+    acc
+}
+
 /// Decimates one channel of 48 kHz audio by 3, 4 or 6.
 #[derive(Clone)]
 pub struct Downsampler {
@@ -77,7 +96,7 @@ impl Downsampler {
             let t = taps - 1 + self.factor * j;
             let win = &self.buf[t + 1 - taps..=t];
             // h is symmetric, so the window can be taken in forward order.
-            out.push(win.iter().zip(&self.h).map(|(a, b)| a * b).sum());
+            out.push(dot8(win, &self.h));
         }
         let n = self.buf.len();
         self.buf.copy_within(n - (taps - 1).., 0);
@@ -97,6 +116,16 @@ mod tests {
         (x.iter().map(|&v| (v as f64).powi(2)).sum::<f64>() / x.len() as f64).sqrt()
     }
 
+    #[test]
+    fn dot8_matches_sequential_sum() {
+        for len in [0usize, 1, 7, 8, 9, 63, 167, 251] {
+            let a: Vec<f32> = (0..len).map(|i| ((i * 37 % 101) as f32 - 50.0) / 50.0).collect();
+            let b: Vec<f32> = (0..len).map(|i| ((i * 53 % 89) as f32 - 44.0) / 44.0).collect();
+            let exact: f64 = a.iter().zip(&b).map(|(&x, &y)| x as f64 * y as f64).sum();
+            assert!((dot8(&a, &b) as f64 - exact).abs() < 1e-4, "len {len}");
+        }
+    }
+
     #[test]
     fn passes_band_and_rejects_aliases() {
         for &(fs, pass, stop) in &[(16_000u32, 6_000.0, 8_600.0), (12_000, 4_500.0, 6_500.0), (8_000, 3_000.0, 4_500.0)] {
diff --git a/crates/opusenc/src/silk/mod.rs b/crates/opusenc/src/silk.rs
similarity index 98%
rename from crates/opusenc/src/silk/mod.rs
rename to crates/opusenc/src/silk.rs
index c7a4b8692..2678a96a0 100644
--- a/crates/opusenc/src/silk/mod.rs
+++ b/crates/opusenc/src/silk.rs
@@ -16,8 +16,12 @@ mod pulses;
 #[allow(dead_code)]
 pub(crate) mod tables;
 
-use lpc::*;
-use tables::*;
+use lpc::{MAX_LPC_ORDER, div32_varq, inverse32_varq, nlsf2a, rshift_round, sat16, smlawb, smulwb, smulww};
+use tables::{
+    DELTA_GAIN, GAIN_MSB, LTP_FILTER, LTP_PERIODICITY, LTP_SCALE, LTP_TAPS_0, LTP_TAPS_1, LTP_TAPS_2, MID_ONLY, NLSF_EXT, NLSF_INTERP, NLSF_SEL_NBMB,
+    NLSF_SEL_WB, NLSF_STAGE1, NLSF_STAGE2, PITCH_CONTOUR, PITCH_HIGH, PITCH_LOW, STEREO_PRED_JOINT, STEREO_WEIGHTS_Q13, TYPE_ACTIVE, TYPE_INACTIVE, UNIFORM3,
+    UNIFORM4, UNIFORM5, UNIFORM8,
+};
 
 use crate::range::RangeEncoder;
 
diff --git a/crates/opusenc/src/silk/analysis.rs b/crates/opusenc/src/silk/analysis.rs
index de510433e..d80052046 100644
--- a/crates/opusenc/src/silk/analysis.rs
+++ b/crates/opusenc/src/silk/analysis.rs
@@ -1,7 +1,7 @@
 //! Encoder-side signal analysis for SILK (own design): windowed autocorrelation LPC, LPC → NLSF
 //! conversion, open-loop pitch search and LTP codebook search.
 
-use super::tables::*;
+use super::tables::{CB_NB_20, CB_WB_20, LTP_FILTER, LTP_PERIODICITY, LTP_TAPS_0, LTP_TAPS_1, LTP_TAPS_2};
 
 /// Short-term prediction coefficients `a` (prediction `x[n] ≈ Σ a[j] x[n-1-j]`) from the
 /// windowed segment `x`, with a Gaussian lag window and white-noise correction.
@@ -69,28 +69,55 @@ pub fn levinson(r: &[f64], order: usize) -> Vec<f64> {
 }
 
 /// Evaluates the symmetric polynomial `p` (length `d + 1`, `d` even) as the cosine series
-/// `e^{jωd/2} P(e^{jω})`.
-fn cos_series(p: &[f64], w: f64) -> f64 {
+/// `e^{jωd/2} P(e^{jω})`, with `cos_m(m)` giving `cos(m ω)`.
+#[inline]
+fn cos_series_with(p: &[f64], cos_m: impl Fn(usize) -> f64) -> f64 {
     let h = (p.len() - 1) / 2;
     let mut s = p[h];
     for k in 0..h {
-        s += 2.0 * p[k] * ((h - k) as f64 * w).cos();
+        s += 2.0 * p[k] * cos_m(h - k);
     }
     s
 }
 
+fn cos_series(p: &[f64], w: f64) -> f64 {
+    cos_series_with(p, |m| (m as f64 * w).cos())
+}
+
+/// Number of grid intervals the root search scans over `[0, π]`.
+const GRID: usize = 1024;
+/// Largest multiple of ω in the series (half the LPC order, at most 16 / 2).
+const MAX_H: usize = 8;
+/// Bisection steps per root: the bracket shrinks to 3e-9 rad, far below one Q15 NLSF step (9.6e-5 rad).
+const BISECT_STEPS: usize = 20;
+
+/// `cos(m · π g / GRID)` for every grid point `g` and `m` in `0..=MAX_H`, computed with the same
+/// expression as [`cos_series`], so the table values are bit-identical to calling `cos` there.
+fn grid_cos() -> &'static [[f64; MAX_H + 1]] {
+    static TABLE: std::sync::OnceLock<Vec<[f64; MAX_H + 1]>> = std::sync::OnceLock::new();
+    TABLE.get_or_init(|| {
+        (0..=GRID)
+            .map(|g| {
+                let w = std::f64::consts::PI * g as f64 / GRID as f64;
+                std::array::from_fn(|m| (m as f64 * w).cos())
+            })
+            .collect()
+    })
+}
+
 fn roots(p: &[f64], out: &mut Vec<f64>) {
-    const GRID: usize = 1024;
+    let grid = grid_cos();
+    let at_grid = |g: usize| cos_series_with(p, |m| grid[g][m]);
     let mut w0 = 0.0;
-    let mut f0 = cos_series(p, w0);
+    let mut f0 = at_grid(0);
     for g in 1..=GRID {
         let w1 = std::f64::consts::PI * g as f64 / GRID as f64;
-        let f1 = cos_series(p, w1);
+        let f1 = at_grid(g);
         if f0 == 0.0 {
             out.push(w0);
         } else if f0 * f1 < 0.0 {
             let (mut lo, mut hi, mut flo) = (w0, w1, f0);
-            for _ in 0..40 {
+            for _ in 0..BISECT_STEPS {
                 let mid = 0.5 * (lo + hi);
                 let fm = cos_series(p, mid);
                 if fm * flo <= 0.0 {
@@ -111,6 +138,9 @@ fn roots(p: &[f64], out: &mut Vec<f64>) {
 /// when the root search fails (unstable or degenerate filter).
 pub fn a2nlsf(a: &[f64]) -> Option<Vec<f64>> {
     let d = a.len();
+    if d > 2 * MAX_H {
+        return None;
+    }
     let mut c = vec![0f64; d + 2];
     c[0] = 1.0;
     for k in 0..d {
@@ -199,9 +229,20 @@ pub fn pitch_search(x: &[f32], start: usize, len: usize, fs_khz: usize) -> Pitch
     let score = full[(lag - min_lag) as usize];
     // Contour: per-subframe lag offsets around the chosen lag.
     let cb: &[[i32; 4]] = if fs_khz == 8 { &CB_NB_20 } else { &CB_WB_20 };
+    // The contour search revisits the same (subframe, lag) pairs for neighbouring base lags and
+    // codebook entries, so each correlation is computed once.
+    let span = (18 * fs - min_lag + 1) as usize;
+    let memo = std::cell::RefCell::new(vec![f64::NAN; 4 * span]);
     let sub_score = |k: usize, l: i32| -> f64 {
         let l = l.clamp(min_lag, 18 * fs);
-        ncorr(x, start + k * sub..start + (k + 1) * sub, l as usize)
+        let slot = k * span + (l - min_lag) as usize;
+        let cached = memo.borrow()[slot];
+        if !cached.is_nan() {
+            return cached;
+        }
+        let v = ncorr(x, start + k * sub..start + (k + 1) * sub, l as usize);
+        memo.borrow_mut()[slot] = v;
+        v
     };
     let mut best = (f64::MIN, lag, 0usize);
     for l0 in (lag - 2).max(min_lag)..=(lag + 2).min(max_lag) {
@@ -319,4 +360,59 @@ mod tests {
             }
         }
     }
+
+    /// The root search as it was before the grid table: `cos` called for every evaluation.
+    fn roots_reference(p: &[f64], out: &mut Vec<f64>) {
+        let mut w0 = 0.0;
+        let mut f0 = cos_series(p, w0);
+        for g in 1..=GRID {
+            let w1 = std::f64::consts::PI * g as f64 / GRID as f64;
+            let f1 = cos_series(p, w1);
+            if f0 == 0.0 {
+                out.push(w0);
+            } else if f0 * f1 < 0.0 {
+                let (mut lo, mut hi, mut flo) = (w0, w1, f0);
+                for _ in 0..BISECT_STEPS {
+                    let mid = 0.5 * (lo + hi);
+                    let fm = cos_series(p, mid);
+                    if fm * flo <= 0.0 {
+                        hi = mid;
+                    } else {
+                        lo = mid;
+                        flo = fm;
+                    }
+                }
+                out.push(0.5 * (lo + hi));
+            }
+            w0 = w1;
+            f0 = f1;
+        }
+    }
+
+    #[test]
+    fn grid_table_roots_are_bit_identical_to_direct_cos() {
+        let mut seed = 7u64;
+        let mut rnd = move || {
+            seed ^= seed << 13;
+            seed ^= seed >> 7;
+            seed ^= seed << 17;
+            (seed >> 11) as f64 / (1u64 << 53) as f64 * 2.0 - 1.0
+        };
+        let mut found = 0;
+        for len in [11usize, 17] {
+            for _ in 0..300 {
+                let mut p = vec![0f64; len];
+                for k in 0..len / 2 + 1 {
+                    p[k] = rnd();
+                    p[len - 1 - k] = p[k];
+                }
+                let (mut a, mut b) = (Vec::new(), Vec::new());
+                roots(&p, &mut a);
+                roots_reference(&p, &mut b);
+                assert_eq!(a.iter().map(|v| v.to_bits()).collect::<Vec<_>>(), b.iter().map(|v| v.to_bits()).collect::<Vec<_>>());
+                found += a.len();
+            }
+        }
+        assert!(found > 1000, "{found}");
+    }
 }
diff --git a/crates/opusenc/src/silk/lpc.rs b/crates/opusenc/src/silk/lpc.rs
index 7846d2973..e0f8c107e 100644
--- a/crates/opusenc/src/silk/lpc.rs
+++ b/crates/opusenc/src/silk/lpc.rs
@@ -5,7 +5,10 @@
 //! spec-derived `filmcraft-opus` decoder (MIT OR Apache-2.0): the encoder must reconstruct the
 //! quantised NLSFs and LPC coefficients bit-exactly as the decoder does.
 
-use super::tables::*;
+use super::tables::{
+    COS_Q12, LSF_ORDER_NBMB, LSF_ORDER_WB, NLSF_CB_NBMB, NLSF_CB_WB, NLSF_MIN_SPACING_NBMB, NLSF_MIN_SPACING_WB, NLSF_PRED_NBMB, NLSF_PRED_WB, NLSF_PSEL_NBMB,
+    NLSF_PSEL_WB,
+};
 
 pub const MAX_LPC_ORDER: usize = 16;
 
diff --git a/crates/opusenc/src/silk/nlsf.rs b/crates/opusenc/src/silk/nlsf.rs
index 3f1f17ac6..4695152ff 100644
--- a/crates/opusenc/src/silk/nlsf.rs
+++ b/crates/opusenc/src/silk/nlsf.rs
@@ -3,7 +3,9 @@
 //! dequantisation exactly. The search strategy is our own.
 
 use super::lpc::{MAX_LPC_ORDER, nlsf_decode, smlawb, sqrt_approx};
-use super::tables::*;
+use super::tables::{
+    NLSF_CB_NBMB, NLSF_CB_WB, NLSF_EXT, NLSF_PRED_NBMB, NLSF_PRED_WB, NLSF_PSEL_NBMB, NLSF_PSEL_WB, NLSF_SEL_NBMB, NLSF_SEL_WB, NLSF_STAGE1, NLSF_STAGE2,
+};
 
 /// Number of stage-1 candidates refined with stage 2.
 const SURVIVORS: usize = 8;
diff --git a/crates/opusenc/src/silk/pulses.rs b/crates/opusenc/src/silk/pulses.rs
index f8cda15a9..ba22b5ec5 100644
--- a/crates/opusenc/src/silk/pulses.rs
+++ b/crates/opusenc/src/silk/pulses.rs
@@ -2,7 +2,7 @@
 //! with LSB escapes, the recursive shell code, LSBs and signs, written in exactly the order the
 //! decoder reads them.
 
-use super::tables::*;
+use super::tables::{EXC_LSB, EXC_SIGN, PULSE_COUNT, RATE_LEVEL, SHELL_2, SHELL_4, SHELL_8, SHELL_16};
 use crate::range::RangeEncoder;
 
 /// Largest pulse magnitude the quantiser produces (keeps every 16-sample block codable).
diff --git a/crates/path/Cargo.toml b/crates/path/Cargo.toml
index 46cf0a832..2e9bc85d9 100644
--- a/crates/path/Cargo.toml
+++ b/crates/path/Cargo.toml
@@ -15,4 +15,4 @@ effectcraft-keyframe = { workspace = true }
 effectcraft-raster = { workspace = true }
 kurbo = { workspace = true }
 tiny-skia = { workspace = true }
-linesweeper = "0.4"
+linesweeper = "0.5"
diff --git a/crates/path/src/boolean.rs b/crates/path/src/boolean.rs
index 5a81b3e19..bcd395566 100644
--- a/crates/path/src/boolean.rs
+++ b/crates/path/src/boolean.rs
@@ -5,7 +5,7 @@
 //! MIT OR Apache-2.0), reworked to take and return kurbo paths directly.
 //!
 //! Inputs are closed implicitly (a filled open path is painted as if closed). The sweep splits
-//! curves at intersections and y-extrema; [`tidy_segments`] re-joins pieces that came from one
+//! curves at intersections and y-extrema; `tidy_segments` re-joins pieces that came from one
 //! input curve (exactly) or one smooth run (by least-squares refit), so results carry roughly as
 //! few vertices as the inputs. Output contours are simple and consistently oriented (holes wind
 //! opposite to their outer contour), so they fill the same under either fill rule.
diff --git a/crates/path/src/lib.rs b/crates/path/src/lib.rs
index 5069cb83e..61fd0e6c3 100644
--- a/crates/path/src/lib.rs
+++ b/crates/path/src/lib.rs
@@ -130,13 +130,84 @@ pub fn from_kurbo(path: &BezPath) -> Vec<ShapePath> {
     out
 }
 
-/// Rectangle path centred at `pos` with corner `roundness` (AE draws clockwise from the top-right).
+/// Rectangle path centred at `pos` with corner `roundness`, drawn as After Effects draws it
+/// (Trim Paths measures from its first point): clockwise from the top-right corner, or with
+/// round corners from the end of the top-right arc on the right edge (After Effects 2026,
+/// 400 × 300 rectangles trimmed 0–25 %, case 930).
 pub fn rect(size: [f64; 2], pos: [f64; 2], roundness: f64) -> BezPath {
-    let r = kurbo::Rect::from_center_size(Point::new(pos[0], pos[1]), (size[0].abs(), size[1].abs()));
-    let max_rad = size[0].abs().min(size[1].abs()) / 2.0;
+    let (w, h) = (size[0].abs(), size[1].abs());
+    let (x0, y0, x1, y1) = (pos[0] - w / 2.0, pos[1] - h / 2.0, pos[0] + w / 2.0, pos[1] + h / 2.0);
+    let max_rad = w.min(h) / 2.0;
     // `f64::clamp` panics on a NaN bound (both size components NaN): fall back to no roundness.
-    let rad = if max_rad.is_nan() { 0.0 } else { roundness.clamp(0.0, max_rad) };
-    if rad > 0.0 { r.to_rounded_rect(rad).to_path(0.1) } else { r.to_path(0.1) }
+    let rad = if roundness.is_finite() && !max_rad.is_nan() { roundness.clamp(0.0, max_rad) } else { 0.0 };
+    let mut p = BezPath::new();
+    if rad <= 0.0 {
+        p.move_to((x1, y0));
+        p.line_to((x1, y1));
+        p.line_to((x0, y1));
+        p.line_to((x0, y0));
+        p.close_path();
+        return p;
+    }
+    // Quarter circles as cubics (handle 0.5523 × radius).
+    let k = rad * 0.552_284_749_8;
+    p.move_to((x1, y0 + rad));
+    p.line_to((x1, y1 - rad));
+    p.curve_to((x1, y1 - rad + k), (x1 - rad + k, y1), (x1 - rad, y1));
+    p.line_to((x0 + rad, y1));
+    p.curve_to((x0 + rad - k, y1), (x0, y1 - rad + k), (x0, y1 - rad));
+    p.line_to((x0, y0 + rad));
+    p.curve_to((x0, y0 + rad - k), (x0 + rad - k, y0), (x0 + rad, y0));
+    p.line_to((x1 - rad, y0));
+    p.curve_to((x1 - rad + k, y0), (x1, y0 + rad - k), (x1, y0 + rad));
+    p.close_path();
+    p
+}
+
+/// Rectangle path centred at `pos` with independent corner radii `[top-left, top-right,
+/// bottom-right, bottom-left]`, clockwise in screen coordinates. Negative and non-finite radii
+/// are 0; radii that would overlap are scaled down as CSS `border-radius` does.
+pub fn rect_radii(size: [f64; 2], pos: [f64; 2], radii: [f64; 4]) -> BezPath {
+    // Start at the end of the top-right arc on the right edge, like `rect`, and walk the corners
+    // clockwise: Trim Paths measures from the first point, so ticking per-corner roundness must
+    // not make a trim jump (#1896).
+    let w = if size[0].is_finite() { size[0].abs() } else { 0.0 };
+    let h = if size[1].is_finite() { size[1].abs() } else { 0.0 };
+    let (x0, y0) = (pos[0] - w / 2.0, pos[1] - h / 2.0);
+    let (x1, y1) = (pos[0] + w / 2.0, pos[1] + h / 2.0);
+    let mut r = radii.map(|v| if v.is_finite() { v.max(0.0) } else { 0.0 });
+    // CSS border-radius: when two radii on an edge overlap, scale every radius by the smallest
+    // edge ratio (a uniform radius then clamps to half the shorter side, as before).
+    let ratio = |a: f64, b: f64, edge: f64| if a + b > edge && a + b > 0.0 { (edge / (a + b)).min(1.0) } else { 1.0 };
+    let f = ratio(r[0], r[1], w).min(ratio(r[3], r[2], w)).min(ratio(r[0], r[3], h)).min(ratio(r[1], r[2], h));
+    if f < 1.0 {
+        for v in &mut r {
+            *v *= f;
+        }
+    }
+    let [tl, tr, br, bl] = r;
+    // Quarter-circle Bezier control distance.
+    const K: f64 = 0.552_284_749_830_793_6;
+    let mut p = BezPath::new();
+    p.move_to((x1, y0 + tr));
+    p.line_to((x1, y1 - br));
+    if br > 0.0 {
+        p.curve_to((x1, y1 - br + K * br), (x1 - br + K * br, y1), (x1 - br, y1));
+    }
+    p.line_to((x0 + bl, y1));
+    if bl > 0.0 {
+        p.curve_to((x0 + bl - K * bl, y1), (x0, y1 - bl + K * bl), (x0, y1 - bl));
+    }
+    p.line_to((x0, y0 + tl));
+    if tl > 0.0 {
+        p.curve_to((x0, y0 + tl - K * tl), (x0 + tl - K * tl, y0), (x0 + tl, y0));
+    }
+    p.line_to((x1 - tr, y0));
+    if tr > 0.0 {
+        p.curve_to((x1 - tr + K * tr, y0), (x1, y0 + tr - K * tr), (x1, y0 + tr));
+    }
+    p.close_path();
+    p
 }
 
 pub fn ellipse(size: [f64; 2], pos: [f64; 2]) -> BezPath {
@@ -144,7 +215,20 @@ pub fn ellipse(size: [f64; 2], pos: [f64; 2]) -> BezPath {
 }
 
 /// Polystar: a star (`inner` radius used) or polygon, rotation in degrees, roundness in percent.
-pub fn polystar(star: bool, points: f64, pos: [f64; 2], rotation: f64, inner: f64, outer: f64, inner_round: f64, outer_round: f64) -> BezPath {
+pub struct Polystar {
+    pub star: bool,
+    pub points: f64,
+    pub pos: [f64; 2],
+    pub rotation: f64,
+    pub inner: f64,
+    pub outer: f64,
+    pub inner_round: f64,
+    pub outer_round: f64,
+}
+
+/// Build the path described by the polystar's geometry.
+pub fn polystar(spec: Polystar) -> BezPath {
+    let Polystar { star, points, pos, rotation, inner, outer, inner_round, outer_round } = spec;
     let n = points.max(3.0).round() as usize;
     let verts = if star { n * 2 } else { n };
     let mut path = BezPath::new();
@@ -356,6 +440,42 @@ pub fn transform(paths: &[BezPath], m: &Mat3) -> Vec<BezPath> {
 mod tests {
     use super::*;
 
+    /// After Effects 2026 (case 930): 400 × 300 rectangles at the origin with Trim Paths. Plain:
+    /// 0–25 % runs from the top-right corner down the right edge and 50 px along the bottom.
+    /// Round corners 40: from the end of the top-right arc (200, −110) down, round the
+    /// bottom-right corner, to x 110 on the bottom. Start 70 / End 30 draws 30–70 %.
+    #[test]
+    fn rectangles_start_where_after_effects_starts_them() {
+        let ends = |p: &BezPath| {
+            let mut first = None;
+            let mut last = None;
+            for el in p.elements() {
+                match *el {
+                    PathEl::MoveTo(q) if first.is_none() => first = Some(q),
+                    PathEl::MoveTo(q) | PathEl::LineTo(q) | PathEl::CurveTo(_, _, q) | PathEl::QuadTo(_, q) => last = Some(q),
+                    PathEl::ClosePath => {}
+                }
+            }
+            (first.unwrap_or_default(), last.unwrap_or_default())
+        };
+        let near = |a: Point, b: (f64, f64)| (a.x - b.0).abs() < 1.0 && (a.y - b.1).abs() < 1.0;
+        let plain = ops::trim(&[rect([400.0, 300.0], [0.0, 0.0], 0.0)], 0.0, 25.0, 0.0);
+        let (a, b) = ends(&plain[0]);
+        assert!(near(a, (200.0, -150.0)) && near(b, (150.0, 150.0)), "{a:?} {b:?}");
+        let round = ops::trim(&[rect([400.0, 300.0], [0.0, 0.0], 40.0)], 0.0, 25.0, 0.0);
+        let (a, b) = ends(&round[0]);
+        assert!(near(a, (200.0, -110.0)) && near(b, (110.0, 150.0)), "{a:?} {b:?}");
+        // Per-corner roundness starts and runs in the same order: ticking the checkbox must not
+        // move a Trim Paths contour.
+        let corners = ops::trim(&[rect_radii([400.0, 300.0], [0.0, 0.0], [40.0; 4])], 0.0, 25.0, 0.0);
+        let (a, b) = ends(&corners[0]);
+        assert!(near(a, (200.0, -110.0)) && near(b, (110.0, 150.0)), "per-corner: {a:?} {b:?}");
+        // Start > End: AE draws 30..70 % (plain: from x 80 on the bottom up to y −130 on the left).
+        let swapped = ops::trim(&[rect([400.0, 300.0], [0.0, 0.0], 0.0)], 70.0, 30.0, 0.0);
+        let (a, b) = ends(&swapped[0]);
+        assert!(near(a, (80.0, 150.0)) && near(b, (-200.0, -130.0)), "{a:?} {b:?}");
+    }
+
     #[test]
     fn rect_with_nan_size_does_not_panic() {
         let _ = rect([f64::NAN, f64::NAN], [0.0, 0.0], 5.0);
@@ -387,6 +507,32 @@ mod tests {
         assert!((area - 200.0).abs() < 1.0, "{area}");
     }
 
+    #[test]
+    fn rect_radii_uniform_matches_a_rounded_rect() {
+        for r in [0.0, 5.0, 25.0, 100.0] {
+            let p = rect_radii([100.0, 50.0], [10.0, 20.0], [r; 4]);
+            let clamped = r.min(25.0);
+            let expect = 100.0 * 50.0 - (4.0 - std::f64::consts::PI) * clamped * clamped;
+            assert!((p.area().abs() - expect).abs() < 1.0, "{r}: {} != {expect}", p.area());
+            assert!((p.area() - rect([100.0, 50.0], [10.0, 20.0], r).area()).abs() < 1e-6);
+        }
+    }
+
+    #[test]
+    fn rect_radii_mixes_corners_and_scales_overlaps() {
+        // Only the top-left and bottom-right corners round.
+        let p = rect_radii([100.0, 50.0], [0.0, 0.0], [10.0, 0.0, 20.0, 0.0]);
+        let expect = 100.0 * 50.0 - (1.0 - std::f64::consts::PI / 4.0) * (10.0 * 10.0 + 20.0 * 20.0);
+        assert!((p.area().abs() - expect).abs() < 1.0, "{}", p.area());
+        // Radii wider than the top edge scale down together, like CSS border-radius.
+        let p = rect_radii([50.0, 100.0], [0.0, 0.0], [40.0, 40.0, 0.0, 0.0]);
+        let scaled = rect_radii([50.0, 100.0], [0.0, 0.0], [25.0, 25.0, 0.0, 0.0]);
+        assert!((p.area() - scaled.area()).abs() < 1e-9);
+        // Negative and non-finite radii are square corners.
+        let p = rect_radii([50.0, 50.0], [0.0, 0.0], [-5.0, f64::NAN, f64::INFINITY, 0.0]);
+        assert!((p.area().abs() - 2500.0).abs() < 1e-9);
+    }
+
     #[test]
     fn stroke_has_area() {
         let r = rect([40.0, 40.0], [50.0, 50.0], 0.0);
@@ -398,7 +544,7 @@ mod tests {
 
     #[test]
     fn star_has_right_vertex_count() {
-        let p = polystar(true, 5.0, [0.0, 0.0], 0.0, 20.0, 50.0, 0.0, 0.0);
+        let p = polystar(Polystar { star: true, points: 5.0, pos: [0.0, 0.0], rotation: 0.0, inner: 20.0, outer: 50.0, inner_round: 0.0, outer_round: 0.0 });
         let v = from_kurbo(&p);
         assert_eq!(v[0].vertices.len(), 10);
     }
diff --git a/crates/path/src/ops.rs b/crates/path/src/ops.rs
index ec6e18604..ba5349312 100644
--- a/crates/path/src/ops.rs
+++ b/crates/path/src/ops.rs
@@ -533,12 +533,15 @@ pub struct WiggleParams {
     pub correlation: f64,
     /// Temporal phase in degrees (360° = one wiggle period).
     pub phase_deg: f64,
+    /// Spatial phase in degrees: slides each subpath's pattern of displacements along its points
+    /// (360° = once around the subpath).
+    pub spatial_phase_deg: f64,
     pub seed: f64,
 }
 
 impl Default for WiggleParams {
     fn default() -> Self {
-        WiggleParams { size: 10.0, detail: 10.0, smooth: true, speed: 2.0, correlation: 50.0, phase_deg: 0.0, seed: 0.0 }
+        WiggleParams { size: 10.0, detail: 10.0, smooth: true, speed: 2.0, correlation: 50.0, phase_deg: 0.0, spatial_phase_deg: 0.0, seed: 0.0 }
     }
 }
 
@@ -561,16 +564,24 @@ fn noise(seed: u64, idx: u64, t: f64) -> f64 {
     let i = t.floor();
     let f = t - i;
     let i = i as i64;
-    let p = |k: i64| hash(seed, idx, i + k);
+    // `i` saturates at the i64 ends for an absurd `t`, so the neighbours wrap rather than overflow.
+    let p = |k: i64| hash(seed, idx, i.wrapping_add(k));
     // Catmull-Rom through four lattice values keeps the motion C1-continuous.
     let (p0, p1, p2, p3) = (p(-1), p(0), p(1), p(2));
     let v = 0.5 * (2.0 * p1 + (-p0 + p2) * f + (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) * f * f + (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * f * f * f);
     v.clamp(-1.0, 1.0)
 }
 
+/// Catmull-Rom interpolation between `p1` (f = 0) and `p2` (f = 1).
+fn catmull_rom(p0: f64, p1: f64, p2: f64, p3: f64, f: f64) -> f64 {
+    0.5 * (2.0 * p1 + (-p0 + p2) * f + (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) * f * f + (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * f * f * f)
+}
+
 /// Wiggle Paths: subdivides the paths (`detail` points per segment) and displaces every point by
 /// smooth random noise of up to `size` pixels that evolves over `time_s` seconds at `speed`
-/// wiggles per second. Deterministic for a given seed and time.
+/// wiggles per second. The spatial phase moves each point's own share of the noise along the
+/// subpath, and a fraction of a point is interpolated between its neighbors. Deterministic for a
+/// given seed and time.
 pub fn wiggle(paths: &[BezPath], w: &WiggleParams, time_s: f64) -> Vec<BezPath> {
     if w.size == 0.0 {
         return paths.to_vec();
@@ -580,6 +591,7 @@ pub fn wiggle(paths: &[BezPath], w: &WiggleParams, time_s: f64) -> Vec<BezPath>
     let t = time_s * w.speed + w.phase_deg / 360.0;
     let corr = (w.correlation / 100.0).clamp(0.0, 1.0);
     let shared = Vec2::new(noise(seed, u64::MAX, t), noise(seed, u64::MAX - 1, t));
+    let turns = if w.spatial_phase_deg.is_finite() { (w.spatial_phase_deg / 360.0).rem_euclid(1.0) } else { 0.0 };
     let mut idx: u64 = 0;
     paths
         .iter()
@@ -587,14 +599,28 @@ pub fn wiggle(paths: &[BezPath], w: &WiggleParams, time_s: f64) -> Vec<BezPath>
             let mut out = BezPath::new();
             for sub in subs(p) {
                 let s = resample(&sub, m);
-                let disp: Vec<Vec2> = s
-                    .iter()
-                    .map(|_| {
-                        let own = Vec2::new(noise(seed, idx * 2, t + idx as f64 * 0.37), noise(seed, idx * 2 + 1, t + idx as f64 * 0.61));
-                        idx += 1;
-                        (shared * corr + own * (1.0 - corr)) * w.size
-                    })
-                    .collect();
+                let n = s.len();
+                let first = idx;
+                let own = |j: usize| {
+                    let i = first + j as u64;
+                    Vec2::new(noise(seed, i * 2, t + i as f64 * 0.37), noise(seed, i * 2 + 1, t + i as f64 * 0.61))
+                };
+                let along = |j: usize| {
+                    if turns == 0.0 {
+                        return own(j);
+                    }
+                    let u = (j as f64 + turns * n as f64).rem_euclid(n as f64);
+                    let k = u.floor();
+                    let f = u - k;
+                    let k = k as usize % n;
+                    if f == 0.0 {
+                        return own(k);
+                    }
+                    let (p0, p1, p2, p3) = (own((k + n - 1) % n), own(k), own((k + 1) % n), own((k + 2) % n));
+                    Vec2::new(catmull_rom(p0.x, p1.x, p2.x, p3.x, f).clamp(-1.0, 1.0), catmull_rom(p0.y, p1.y, p2.y, p3.y, f).clamp(-1.0, 1.0))
+                };
+                let disp: Vec<Vec2> = (0..n).map(|j| (shared * corr + along(j) * (1.0 - corr)) * w.size).collect();
+                idx += n as u64;
                 emit(&s, &disp, sub.closed, w.smooth, 1.0 / 3.0, &mut out);
             }
             out
diff --git a/crates/path/src/ops/tests.rs b/crates/path/src/ops/tests.rs
index dbdf213ba..1ebdcea5b 100644
--- a/crates/path/src/ops/tests.rs
+++ b/crates/path/src/ops/tests.rs
@@ -292,6 +292,18 @@ fn wiggle_is_deterministic_and_time_varying() {
     assert_eq!(vertex_count(&a[0]), 4 * 11);
 }
 
+#[test]
+fn wiggle_survives_an_absurd_speed_or_time() {
+    // `t` far past i64 saturates the lattice index at i64::MAX, and the neighbours' `+ 1`, `+ 2` used to overflow.
+    let s = [sq(0.0, 0.0, 100.0)];
+    for v in [f64::INFINITY, f64::NEG_INFINITY, f64::NAN, f64::MAX, f64::MIN, 1e300, 9.3e18] {
+        let by_speed = wiggle(&s, &WiggleParams { speed: v, ..Default::default() }, 1.0);
+        let by_time = wiggle(&s, &WiggleParams::default(), v);
+        let by_phase = wiggle(&s, &WiggleParams { phase_deg: v, ..Default::default() }, 0.0);
+        assert_eq!((by_speed.len(), by_time.len(), by_phase.len()), (1, 1, 1), "wiggle with {v}");
+    }
+}
+
 #[test]
 fn wiggle_displacement_is_bounded() {
     let mut l = BezPath::new();
@@ -317,6 +329,38 @@ fn wiggle_full_correlation_translates() {
     assert_eq!(zero[0], s[0]);
 }
 
+/// Spatial Phase moves the pattern of displacements along the path: 360° is once around, and a
+/// whole number of points' worth gives each point the displacement of the point that far ahead.
+#[test]
+fn wiggle_spatial_phase_moves_the_pattern_along_the_path() {
+    let s = [sq(0.0, 0.0, 100.0)];
+    let w = WiggleParams { detail: 3.0, correlation: 0.0, smooth: false, ..Default::default() };
+    // Displacements are proportional to Size: twice the size less once the size.
+    let disp = |w: WiggleParams| -> Vec<Vec2> {
+        let a = on_curve(&wiggle(&s, &w, 0.4)[0]);
+        let b = on_curve(&wiggle(&s, &WiggleParams { size: w.size * 2.0, ..w }, 0.4)[0]);
+        a.iter().zip(&b).map(|(a, b)| *b - *a).take(16).collect()
+    };
+    let d0 = disp(w);
+    let n = d0.len();
+    assert_eq!(n, 16);
+    for k in [1, 5] {
+        let dk = disp(WiggleParams { spatial_phase_deg: 360.0 * k as f64 / n as f64, ..w });
+        for j in 0..n {
+            let e = d0[(j + k) % n];
+            assert!(close(dk[j].x, e.x, 1e-9) && close(dk[j].y, e.y, 1e-9), "{k} ahead, point {j}: {:?} vs {e:?}", dk[j]);
+        }
+    }
+    // Whole turns either way leave the path as it is.
+    let base = wiggle(&s, &w, 0.4);
+    assert_eq!(wiggle(&s, &WiggleParams { spatial_phase_deg: 360.0, ..w }, 0.4), base);
+    assert_eq!(wiggle(&s, &WiggleParams { spatial_phase_deg: -720.0, ..w }, 0.4), base);
+    // Half a point ahead, the displacements change and stay within Size.
+    let half = disp(WiggleParams { spatial_phase_deg: 180.0 / n as f64, ..w });
+    assert!(half.iter().zip(&d0).any(|(h, d)| (*h - *d).hypot() > 1e-3));
+    assert!(half.iter().all(|h| h.x.abs() <= 10.0 + 1e-9 && h.y.abs() <= 10.0 + 1e-9));
+}
+
 // ---------------------------------------------------------------- merge / booleans
 
 fn inclusion_exclusion(a: BezPath, b: BezPath) {
diff --git a/crates/path/src/trace.rs b/crates/path/src/trace.rs
index 429738032..01508bcaf 100644
--- a/crates/path/src/trace.rs
+++ b/crates/path/src/trace.rs
@@ -6,7 +6,7 @@
 //!    with "outside" so every contour closes.
 //! 2. **Douglas–Peucker** simplification of each closed loop to the Tolerance (pixels).
 //! 3. **Bezier fitting**: each simplified span is fitted with one cubic (least squares with fixed
-//!    end tangents, Newton reparameterisation; [`crate::fit`]). The tangent at each vertex is the
+//!    end tangents, Newton reparameterisation; `crate::fit`). The tangent at each vertex is the
 //!    chord direction at Corner Roundness 0 (straight segments, sharp corners) and the smooth
 //!    (Catmull–Rom) direction at 100 %, blended between.
 //!
diff --git a/crates/pdf/Cargo.toml b/crates/pdf/Cargo.toml
index b37dff50f..bf6148569 100644
--- a/crates/pdf/Cargo.toml
+++ b/crates/pdf/Cargo.toml
@@ -14,7 +14,7 @@ craft-pdf.workspace = true
 effectcraft-svg = { workspace = true }
 kurbo = { workspace = true }
 effectcraft-text = { workspace = true }
-miniz_oxide = "0.8"
+miniz_oxide = "0.9"
 # Embedded TrueType / OpenType font programs (MIT OR Apache-2.0).
 skrifa = { workspace = true }
 # DCT (JPEG) images (MIT OR Apache-2.0 OR Zlib; pure Rust).
diff --git a/crates/pdf/README.md b/crates/pdf/README.md
index e4970edc9..20f655611 100644
--- a/crates/pdf/README.md
+++ b/crates/pdf/README.md
@@ -138,7 +138,7 @@ ffmpeg elsewhere) to check the code tables against an independent implementation
 ## Shared parser setup and bounds
 
 The workspace pins `craft-pdf` to `craft-libs` Git revision
-`9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef`, with `default-features = false` and only the explicit `read`
+`92d392cff132eaf53e13afff77f38b5c11b73aa0`, with `default-features = false` and only the explicit `read`
 feature. This excludes the backend's bundled fonts and Adobe CMaps and preserves EffectCraft's
 font and asset policies. The shared parser does not change the supported drawing operators,
 image codecs, continuously rasterized SVG tree, editable shapes, or EPS interpreter.
diff --git a/crates/pdf/src/font.rs b/crates/pdf/src/font.rs
index 2c27838a2..64b0a1c3a 100644
--- a/crates/pdf/src/font.rs
+++ b/crates/pdf/src/font.rs
@@ -89,7 +89,7 @@ impl OutlinePen for Pen {
 
 /// A bundled stand-in for a font that is not embedded, by its PostScript name.
 fn fallback(base: &str) -> &'static [u8] {
-    use effectcraft_text::fonts::*;
+    use effectcraft_text::fonts::{INTER_BOLD, INTER_ITALIC, INTER_REGULAR, INTER_SEMIBOLD, JETBRAINS_MONO_REGULAR, NOTO_SERIF_REGULAR};
     let b = base.to_ascii_lowercase();
     if b.contains("courier") || b.contains("mono") || b.contains("consol") {
         return JETBRAINS_MONO_REGULAR;
@@ -393,89 +393,10 @@ impl Font {
         }
         // Widths.
         if f.composite {
-            f.default_width = file.get_num(&desc_dict, "DW").unwrap_or(1000.0) / 1000.0;
-            if let Some(w) = file.get(&desc_dict, "W").and_then(Obj::array) {
-                let mut i = 0;
-                while i < w.len() {
-                    let first = file.resolve(&w[i]).num().unwrap_or(0.0) as u32;
-                    match w.get(i + 1).map(|x| file.resolve(x)) {
-                        Some(Obj::Array(list)) => {
-                            for (k, v) in list.iter().enumerate() {
-                                if let Some(cid) = first.checked_add(k as u32) {
-                                    f.cid_widths.insert(cid, file.resolve(v).num().unwrap_or(0.0) / 1000.0);
-                                }
-                            }
-                            i += 2;
-                        }
-                        Some(Obj::Num(last)) => {
-                            let wv = w.get(i + 2).and_then(|x| file.resolve(x).num()).unwrap_or(0.0) / 1000.0;
-                            for c in first..=(*last as u32).min(first.saturating_add(65535)) {
-                                f.cid_widths.insert(c, wv);
-                            }
-                            i += 3;
-                        }
-                        _ => break,
-                    }
-                }
-            }
-            // Vertical metrics (§9.7.4.3): /DW2 [vy w1y] and /W2 entries
-            // `c [w1y vx vy …]` or `cfirst clast w1y vx vy`.
-            let dw2 = file.get(&desc_dict, "DW2").map(|x| file.nums(x)).unwrap_or_default();
-            if dw2.len() == 2 {
-                f.dw2 = (dw2[0] / 1000.0, dw2[1] / 1000.0);
-            }
-            if let Some(w) = file.get(&desc_dict, "W2").and_then(Obj::array) {
-                let num = |i: usize| w.get(i).and_then(|x| file.resolve(x).num());
-                let mut i = 0;
-                while i < w.len() {
-                    let Some(first) = num(i) else { break };
-                    let first = first.max(0.0) as u32;
-                    match w.get(i + 1).map(|x| file.resolve(x)) {
-                        Some(Obj::Array(list)) => {
-                            let v: Vec<f64> = list.iter().filter_map(|x| file.resolve(x).num()).collect();
-                            for (k, t) in v.as_chunks::<3>().0.iter().enumerate() {
-                                if let Some(cid) = first.checked_add(k as u32) {
-                                    f.cid_vmetrics.insert(cid, (t[0] / 1000.0, t[1] / 1000.0, t[2] / 1000.0));
-                                }
-                            }
-                            i += 2;
-                        }
-                        Some(Obj::Num(last)) => {
-                            let (Some(w1), Some(vx), Some(vy)) = (num(i + 2), num(i + 3), num(i + 4)) else { break };
-                            for c in first..=(last.max(0.0) as u32).min(first.saturating_add(65535)) {
-                                f.cid_vmetrics.insert(c, (w1 / 1000.0, vx / 1000.0, vy / 1000.0));
-                            }
-                            i += 5;
-                        }
-                        _ => break,
-                    }
-                }
-            }
+            f.load_cid_widths(file, &desc_dict);
+            f.load_vertical_metrics(file, &desc_dict);
             f.has_widths = true;
-            // Encoding CMap.
-            match file.get(d, "Encoding") {
-                Some(Obj::Name(n)) => {
-                    f.vertical = n.ends_with("-V");
-                    if !n.starts_with("Identity") {
-                        skipped.push(format!("CMap {n}"));
-                    }
-                }
-                Some(Obj::Stream(sd, raw)) => {
-                    if let Some(data) = decode_stream(file, sd, raw) {
-                        let cm = parse_cmap(&data);
-                        f.vertical = cm.wmode || file.get_num(sd, "WMode") == Some(1.0);
-                        f.codespace = cm.codespace;
-                        f.cid_ranges = cm.cids;
-                    }
-                }
-                _ => {}
-            }
-            match file.get(&desc_dict, "CIDToGIDMap") {
-                Some(Obj::Stream(sd, raw)) => {
-                    f.cid_to_gid = decode_stream(file, sd, raw).map(|b| b.as_chunks::<2>().0.iter().map(|c| u16::from_be_bytes([c[0], c[1]])).collect());
-                }
-                _ => f.cid_to_gid = None,
-            }
+            f.load_cid_encoding(file, d, &desc_dict, skipped);
         } else {
             f.first_char = file.get_num(d, "FirstChar").unwrap_or(0.0) as u32;
             if let Some(w) = file.get(d, "Widths") {
@@ -486,16 +407,113 @@ impl Font {
                 f.default_width = file.get_num(fd, "MissingWidth").unwrap_or(0.0);
             }
         }
+        f.load_program(file, d, fd.as_ref(), &subtype, skipped);
+        f.load_simple_encoding(file, d);
+        f
+    }
+
+    fn load_cid_widths(&mut self, file: &File, desc_dict: &Dict) {
+        self.default_width = file.get_num(desc_dict, "DW").unwrap_or(1000.0) / 1000.0;
+        if let Some(w) = file.get(desc_dict, "W").and_then(Obj::array) {
+            let mut i = 0;
+            while i < w.len() {
+                let first = file.resolve(&w[i]).num().unwrap_or(0.0) as u32;
+                match w.get(i + 1).map(|x| file.resolve(x)) {
+                    Some(Obj::Array(list)) => {
+                        for (k, v) in list.iter().enumerate() {
+                            if let Some(cid) = first.checked_add(k as u32) {
+                                self.cid_widths.insert(cid, file.resolve(v).num().unwrap_or(0.0) / 1000.0);
+                            }
+                        }
+                        i += 2;
+                    }
+                    Some(Obj::Num(last)) => {
+                        let wv = w.get(i + 2).and_then(|x| file.resolve(x).num()).unwrap_or(0.0) / 1000.0;
+                        for c in first..=(*last as u32).min(first.saturating_add(65535)) {
+                            self.cid_widths.insert(c, wv);
+                        }
+                        i += 3;
+                    }
+                    _ => break,
+                }
+            }
+        }
+    }
+
+    fn load_vertical_metrics(&mut self, file: &File, desc_dict: &Dict) {
+        // Vertical metrics (§9.7.4.3): /DW2 [vy w1y] and /W2 entries
+        // `c [w1y vx vy …]` or `cfirst clast w1y vx vy`.
+        let dw2 = file.get(desc_dict, "DW2").map(|x| file.nums(x)).unwrap_or_default();
+        if dw2.len() == 2 {
+            self.dw2 = (dw2[0] / 1000.0, dw2[1] / 1000.0);
+        }
+        if let Some(w) = file.get(desc_dict, "W2").and_then(Obj::array) {
+            let num = |i: usize| w.get(i).and_then(|x| file.resolve(x).num());
+            let mut i = 0;
+            while i < w.len() {
+                let Some(first) = num(i) else { break };
+                let first = first.max(0.0) as u32;
+                match w.get(i + 1).map(|x| file.resolve(x)) {
+                    Some(Obj::Array(list)) => {
+                        let v: Vec<f64> = list.iter().filter_map(|x| file.resolve(x).num()).collect();
+                        for (k, t) in v.as_chunks::<3>().0.iter().enumerate() {
+                            if let Some(cid) = first.checked_add(k as u32) {
+                                self.cid_vmetrics.insert(cid, (t[0] / 1000.0, t[1] / 1000.0, t[2] / 1000.0));
+                            }
+                        }
+                        i += 2;
+                    }
+                    Some(Obj::Num(last)) => {
+                        let (Some(w1), Some(vx), Some(vy)) = (num(i + 2), num(i + 3), num(i + 4)) else { break };
+                        for c in first..=(last.max(0.0) as u32).min(first.saturating_add(65535)) {
+                            self.cid_vmetrics.insert(c, (w1 / 1000.0, vx / 1000.0, vy / 1000.0));
+                        }
+                        i += 5;
+                    }
+                    _ => break,
+                }
+            }
+        }
+    }
+
+    fn load_cid_encoding(&mut self, file: &File, d: &Dict, desc_dict: &Dict, skipped: &mut Vec<String>) {
+        // Encoding CMap.
+        match file.get(d, "Encoding") {
+            Some(Obj::Name(n)) => {
+                self.vertical = n.ends_with("-V");
+                if !n.starts_with("Identity") {
+                    skipped.push(format!("CMap {n}"));
+                }
+            }
+            Some(Obj::Stream(sd, raw)) => {
+                if let Some(data) = decode_stream(file, sd, raw) {
+                    let cm = parse_cmap(&data);
+                    self.vertical = cm.wmode || file.get_num(sd, "WMode") == Some(1.0);
+                    self.codespace = cm.codespace;
+                    self.cid_ranges = cm.cids;
+                }
+            }
+            _ => {}
+        }
+        match file.get(desc_dict, "CIDToGIDMap") {
+            Some(Obj::Stream(sd, raw)) => {
+                self.cid_to_gid = decode_stream(file, sd, raw).map(|b| b.as_chunks::<2>().0.iter().map(|c| u16::from_be_bytes([c[0], c[1]])).collect());
+            }
+            _ => self.cid_to_gid = None,
+        }
+    }
+
+    fn load_program(&mut self, file: &File, d: &Dict, fd: Option<&Dict>, subtype: &str, skipped: &mut Vec<String>) {
         // The program.
         let font_file = |key: &str| -> Option<(Dict, Vec<u8>)> {
-            let fd = fd.as_ref()?;
+            let fd = fd?;
             match file.get(fd, key) {
                 Some(Obj::Stream(sd, raw)) => Some((sd.clone(), decode_stream(file, sd, raw)?)),
                 _ => None,
             }
         };
         if subtype == "Type3" {
-            f.matrix = file
+            self.matrix = file
                 .get(d, "FontMatrix")
                 .map(|m| file.nums(m))
                 .filter(|m| m.len() == 6)
@@ -511,76 +529,78 @@ impl Font {
                     }
                 }
             }
-            f.program = Program::Type3 { procs, resources: file.get_dict(d, "Resources").cloned() };
+            self.program = Program::Type3 { procs, resources: file.get_dict(d, "Resources").cloned() };
             // Type 3 widths are in glyph space.
-            let m = f.matrix.as_coeffs()[0];
-            for w in &mut f.widths {
+            let m = self.matrix.as_coeffs()[0];
+            for w in &mut self.widths {
                 *w *= m * 1000.0;
             }
         } else if let Some((_, data)) = font_file("FontFile2") {
-            f.program = Program::TrueType(Arc::new(data));
+            self.program = Program::TrueType(Arc::new(data));
         } else if let Some((sd, data)) = font_file("FontFile3") {
             match file.get(&sd, "Subtype").and_then(Obj::name) {
                 Some("OpenType") => {
                     // An OpenType wrapper: TrueType outlines through skrifa, CFF through ours.
                     let cff = FontRef::new(&data).ok().and_then(|fr| fr.table_data(skrifa::Tag::new(b"CFF ")).map(|t| t.as_bytes().to_vec()));
                     match cff.and_then(|c| Cff::parse(&c)) {
-                        Some(c) => f.program = Program::Cff(Box::new(c)),
-                        None => f.program = Program::TrueType(Arc::new(data)),
+                        Some(c) => self.program = Program::Cff(Box::new(c)),
+                        None => self.program = Program::TrueType(Arc::new(data)),
                     }
                 }
                 _ => match Cff::parse(&data) {
-                    Some(c) => f.program = Program::Cff(Box::new(c)),
+                    Some(c) => self.program = Program::Cff(Box::new(c)),
                     None => skipped.push("font program (CFF)".into()),
                 },
             }
         } else if let Some((_, data)) = font_file("FontFile") {
             match Type1::parse(&data) {
-                Some(t) => f.program = Program::Type1(Box::new(t)),
+                Some(t) => self.program = Program::Type1(Box::new(t)),
                 None => skipped.push("font program (Type 1)".into()),
             }
         } else {
-            f.program = Program::Fallback(fallback(&base_name));
+            self.program = Program::Fallback(fallback(&self.base_name));
         }
-        if let Program::Cff(c) = &f.program {
+        if let Program::Cff(c) = &self.program {
             let m = c.font_matrix;
-            f.matrix = Affine::new(m);
+            self.matrix = Affine::new(m);
         }
-        if let Program::Type1(t) = &f.program
+        if let Program::Type1(t) = &self.program
             && let Some(m) = t.font_matrix
         {
-            f.matrix = Affine::new(m);
+            self.matrix = Affine::new(m);
         }
+    }
+
+    fn load_simple_encoding(&mut self, file: &File, d: &Dict) {
         // Simple-font encoding: base encoding, built-in encoding, Differences.
-        if !f.composite {
+        if !self.composite {
             let enc = file.get(d, "Encoding").map(|e| file.resolve(e));
             let base = match enc {
                 Some(Obj::Name(n)) => Base::from_name(n),
                 Some(Obj::Dict(e)) => file.get(e, "BaseEncoding").and_then(Obj::name).and_then(Base::from_name),
                 _ => None,
             };
-            let builtin: Option<Vec<Option<String>>> = match &f.program {
+            let builtin: Option<Vec<Option<String>>> = match &self.program {
                 Program::Type1(t) if !t.encoding.is_empty() => Some((0..256).map(|c| t.encoding.get(&(c as u8)).cloned()).collect()),
                 _ => None,
             };
-            let fallback_base = if f.symbolic { None } else { Some(Base::Standard) };
+            let fallback_base = if self.symbolic { None } else { Some(Base::Standard) };
             for c in 0..256usize {
-                f.names[c] = match (base, &builtin) {
+                self.names[c] = match (base, &builtin) {
                     (Some(b), _) => b.name(c as u8),
                     (None, Some(bi)) => bi[c].clone(),
-                    (None, None) => match &f.program {
+                    (None, None) => match &self.program {
                         // TrueType symbolic fonts map codes directly; others use Standard.
-                        Program::TrueType(_) if f.symbolic => None,
-                        Program::Fallback(_) if base_name.contains("Symbol") || base_name.contains("Dingbats") => None,
+                        Program::TrueType(_) if self.symbolic => None,
+                        Program::Fallback(_) if self.base_name.contains("Symbol") || self.base_name.contains("Dingbats") => None,
                         _ => fallback_base.or(Some(Base::Standard)).and_then(|b| b.name(c as u8)),
                     },
                 };
             }
             if let Some(Obj::Dict(e)) = enc {
-                differences(file, e, &mut f.names);
+                differences(file, e, &mut self.names);
             }
         }
-        f
     }
 
     /// Split a string into (code, byte length) pairs.
diff --git a/crates/pdf/src/lib.rs b/crates/pdf/src/lib.rs
index 7c766559f..567dca9c0 100644
--- a/crates/pdf/src/lib.rs
+++ b/crates/pdf/src/lib.rs
@@ -218,11 +218,3 @@ pub fn layer_doc_with_sizes(doc: &Doc, index: usize, retain: bool) -> (Doc, [f64
 
 #[cfg(test)]
 mod tests;
-#[cfg(test)]
-mod tests_groups;
-#[cfg(test)]
-mod tests_import;
-#[cfg(test)]
-mod tests_reader;
-#[cfg(test)]
-mod tests_shading;
diff --git a/crates/pdf/src/object.rs b/crates/pdf/src/object.rs
index cdbb9733a..79a91dde8 100644
--- a/crates/pdf/src/object.rs
+++ b/crates/pdf/src/object.rs
@@ -275,19 +275,26 @@ fn hexv(c: u8) -> u8 {
     }
 }
 
-fn decode_name(w: &[u8]) -> String {
-    let mut out = vec![];
+/// The bytes of a name token (after its `/`), with `#xx` escapes decoded.
+pub(crate) fn name_bytes(w: &[u8]) -> impl Iterator<Item = u8> {
     let mut i = 0;
-    while i < w.len() {
-        if w[i] == b'#' && w.get(i + 1).is_some_and(u8::is_ascii_hexdigit) && w.get(i + 2).is_some_and(u8::is_ascii_hexdigit) {
-            out.push((hexv(w[i + 1]) << 4) | hexv(w[i + 2]));
-            i += 3;
-        } else {
-            out.push(w[i]);
-            i += 1;
+    std::iter::from_fn(move || {
+        let c = *w.get(i)?;
+        match (c, w.get(i + 1), w.get(i + 2)) {
+            (b'#', Some(&hi), Some(&lo)) if hi.is_ascii_hexdigit() && lo.is_ascii_hexdigit() => {
+                i += 3;
+                Some((hexv(hi) << 4) | hexv(lo))
+            }
+            _ => {
+                i += 1;
+                Some(c)
+            }
         }
-    }
-    String::from_utf8_lossy(&out).into_owned()
+    })
+}
+
+fn decode_name(w: &[u8]) -> String {
+    String::from_utf8_lossy(&name_bytes(w).collect::<Vec<_>>()).into_owned()
 }
 
 pub fn parse_num(w: &[u8]) -> Option<f64> {
diff --git a/crates/pdf/src/ps.rs b/crates/pdf/src/ps.rs
index dd7350754..3d734e46c 100644
--- a/crates/pdf/src/ps.rs
+++ b/crates/pdf/src/ps.rs
@@ -18,296 +18,16 @@ use crate::build::{Builder, MAX_PATH};
 use crate::font::Font;
 use crate::object::{ascii85, is_white, parse_num};
 
-type DictRef = Rc<RefCell<HashMap<String, V>>>;
+mod builtin;
+mod eps;
+mod exec;
+mod paths;
+mod scanner;
+mod text;
+mod value;
 
-#[derive(Clone)]
-enum V {
-    Num(f64),
-    Bool(bool),
-    /// An executable name.
-    Name(Rc<str>),
-    /// A literal name (`/name`).
-    Lit(Rc<str>),
-    /// A built-in operator, as `load` returns it for a name no dictionary defines.
-    Op(Rc<str>),
-    Str(Rc<RefCell<Vec<u8>>>),
-    Proc(Rc<Vec<V>>),
-    Array(Rc<RefCell<Vec<V>>>),
-    Dict(DictRef),
-    Mark,
-    Null,
-    /// `currentfile`.
-    File,
-}
-
-impl V {
-    fn num(&self) -> Option<f64> {
-        match self {
-            V::Num(n) => Some(*n),
-            _ => None,
-        }
-    }
-    fn key(&self) -> String {
-        match self {
-            V::Name(n) | V::Lit(n) | V::Op(n) => n.to_string(),
-            V::Str(s) => String::from_utf8_lossy(&s.borrow()).into_owned(),
-            V::Num(n) => format!("{n}"),
-            V::Bool(b) => format!("{b}"),
-            _ => String::new(),
-        }
-    }
-    fn items(&self) -> Option<Vec<V>> {
-        match self {
-            V::Array(a) => Some(a.borrow().clone()),
-            V::Proc(p) => Some(p.as_ref().clone()),
-            _ => None,
-        }
-    }
-}
-
-enum Flow {
-    Exit,
-    Stop,
-    Quit,
-}
-
-#[derive(Clone)]
-struct GState {
-    ctm: Affine,
-    color: [f64; 3],
-    lw: f64,
-    cap: Cap,
-    join: Join,
-    miter: f64,
-    dash: Option<(Vec<f64>, f64)>,
-    path: BezPath,
-    cur: Option<Point>,
-    start: Option<Point>,
-    depth: usize,
-    /// The current font dictionary.
-    font: Option<DictRef>,
-}
-
-/// Source tokenizer (the data source for `currentfile`).
-struct Src<'a> {
-    d: &'a [u8],
-    pos: usize,
-}
-
-impl Src<'_> {
-    fn skip_ws(&mut self) {
-        while self.pos < self.d.len() {
-            let c = self.d[self.pos];
-            if is_white(c) {
-                self.pos += 1;
-            } else if c == b'%' {
-                let s = self.pos;
-                while self.pos < self.d.len() && !matches!(self.d[self.pos], b'\n' | b'\r') {
-                    self.pos += 1;
-                }
-                // DSC: skip embedded binary / data sections.
-                let line = &self.d[s..self.pos];
-                if line.starts_with(b"%%BeginData:") || line.starts_with(b"%%BeginBinary:") || line.starts_with(b"%%BeginPreview") {
-                    let end: &[u8] = if line.starts_with(b"%%BeginData:") {
-                        b"%%EndData"
-                    } else if line.starts_with(b"%%BeginBinary:") {
-                        b"%%EndBinary"
-                    } else {
-                        b"%%EndPreview"
-                    };
-                    match self.d[self.pos..].windows(end.len()).position(|w| w == end) {
-                        Some(p) => self.pos += p,
-                        None => self.pos = self.d.len(),
-                    }
-                }
-            } else {
-                break;
-            }
-        }
-    }
-
-    fn word(&mut self) -> &[u8] {
-        let s = self.pos;
-        while self.pos < self.d.len() {
-            let c = self.d[self.pos];
-            if is_white(c) || matches!(c, b'(' | b')' | b'<' | b'>' | b'[' | b']' | b'{' | b'}' | b'/' | b'%') {
-                break;
-            }
-            self.pos += 1;
-        }
-        &self.d[s..self.pos]
-    }
-
-    /// The next token; `{ … }` comes back as a whole procedure.
-    fn token(&mut self, depth: usize) -> Option<V> {
-        self.skip_ws();
-        let c = *self.d.get(self.pos)?;
-        Some(match c {
-            b'{' => {
-                self.pos += 1;
-                let mut body = vec![];
-                loop {
-                    self.skip_ws();
-                    match self.d.get(self.pos) {
-                        None => break,
-                        Some(b'}') => {
-                            self.pos += 1;
-                            break;
-                        }
-                        _ => {
-                            if depth > 100 {
-                                return None;
-                            }
-                            match self.token(depth + 1) {
-                                Some(t) => body.push(t),
-                                None => break,
-                            }
-                        }
-                    }
-                }
-                V::Proc(Rc::new(body))
-            }
-            b'}' => {
-                self.pos += 1;
-                V::Null
-            }
-            b'/' => {
-                self.pos += 1;
-                let imm = self.d.get(self.pos) == Some(&b'/');
-                if imm {
-                    self.pos += 1;
-                }
-                let w = String::from_utf8_lossy(self.word()).into_owned();
-                // `//name` (immediately evaluated) is treated like a plain name.
-                if imm { V::Name(w.into()) } else { V::Lit(w.into()) }
-            }
-            b'(' => {
-                self.pos += 1;
-                let mut out = vec![];
-                let mut depth = 1;
-                while self.pos < self.d.len() {
-                    let c = self.d[self.pos];
-                    self.pos += 1;
-                    match c {
-                        b'\\' => {
-                            let e = self.d.get(self.pos).copied().unwrap_or(b'\\');
-                            self.pos += 1;
-                            match e {
-                                b'n' => out.push(b'\n'),
-                                b'r' => out.push(b'\r'),
-                                b't' => out.push(b'\t'),
-                                b'0'..=b'7' => {
-                                    let mut v = (e - b'0') as u32;
-                                    for _ in 0..2 {
-                                        match self.d.get(self.pos) {
-                                            Some(d @ b'0'..=b'7') => {
-                                                v = v * 8 + (d - b'0') as u32;
-                                                self.pos += 1;
-                                            }
-                                            _ => break,
-                                        }
-                                    }
-                                    out.push(v as u8);
-                                }
-                                b'\n' | b'\r' => {}
-                                o => out.push(o),
-                            }
-                        }
-                        b'(' => {
-                            depth += 1;
-                            out.push(c);
-                        }
-                        b')' => {
-                            depth -= 1;
-                            if depth == 0 {
-                                break;
-                            }
-                            out.push(c);
-                        }
-                        _ => out.push(c),
-                    }
-                }
-                V::Str(Rc::new(RefCell::new(out)))
-            }
-            b'<' if self.d.get(self.pos + 1) == Some(&b'<') => {
-                self.pos += 2;
-                V::Name("<<".into())
-            }
-            b'>' if self.d.get(self.pos + 1) == Some(&b'>') => {
-                self.pos += 2;
-                V::Name(">>".into())
-            }
-            b'<' if self.d.get(self.pos + 1) == Some(&b'~') => {
-                let s = self.pos;
-                while self.pos + 1 < self.d.len() && !(self.d[self.pos] == b'~' && self.d[self.pos + 1] == b'>') {
-                    self.pos += 1;
-                }
-                self.pos = (self.pos + 2).min(self.d.len());
-                V::Str(Rc::new(RefCell::new(ascii85(&self.d[s..self.pos]))))
-            }
-            b'<' => {
-                self.pos += 1;
-                let mut hex = vec![];
-                while self.pos < self.d.len() && self.d[self.pos] != b'>' {
-                    if self.d[self.pos].is_ascii_hexdigit() {
-                        hex.push(self.d[self.pos]);
-                    }
-                    self.pos += 1;
-                }
-                self.pos += 1;
-                if hex.len() % 2 == 1 {
-                    hex.push(b'0');
-                }
-                let h = |c: u8| (c as char).to_digit(16).unwrap_or(0) as u8;
-                V::Str(Rc::new(RefCell::new(hex.chunks(2).map(|p| (h(p[0]) << 4) | h(p[1])).collect())))
-            }
-            b'[' | b']' => {
-                self.pos += 1;
-                V::Name(if c == b'[' { "[" } else { "]" }.into())
-            }
-            b')' | b'>' => {
-                self.pos += 1;
-                V::Null
-            }
-            _ => {
-                let w = self.word();
-                if w.is_empty() {
-                    self.pos += 1;
-                    return Some(V::Null);
-                }
-                match parse_num(w) {
-                    Some(n) => V::Num(n),
-                    None => {
-                        // Radix numbers (16#FF).
-                        let s = String::from_utf8_lossy(w).into_owned();
-                        match s.split_once('#').and_then(|(r, v)| i64::from_str_radix(v, r.parse::<u32>().ok().filter(|r| (2..=36).contains(r))?).ok()) {
-                            Some(n) => V::Num(n as f64),
-                            None => V::Name(s.into()),
-                        }
-                    }
-                }
-            }
-        })
-    }
-
-    /// Step over inline image data that follows an `image` operator reading `currentfile`.
-    fn skip_image_data(&mut self) {
-        self.skip_ws();
-        if self.d[self.pos..].starts_with(b"<~") || self.d.get(self.pos).is_some_and(|c| (b'!'..=b'u').contains(c) && !c.is_ascii_hexdigit()) {
-            match self.d[self.pos..].windows(2).position(|w| w == b"~>") {
-                Some(p) => self.pos += p + 2,
-                None => self.pos = self.d.len(),
-            }
-            return;
-        }
-        while self.pos < self.d.len() && (self.d[self.pos].is_ascii_hexdigit() || is_white(self.d[self.pos])) {
-            self.pos += 1;
-        }
-        if self.d.get(self.pos) == Some(&b'>') {
-            self.pos += 1;
-        }
-    }
-}
+pub use eps::eps_parts;
+use value::{DictRef, GState, V};
 
 pub(crate) struct Interp {
     pub b: Builder,
@@ -327,1712 +47,3 @@ pub(crate) struct Interp {
     page: [f64; 4],
     pub unknown: Vec<String>,
 }
-
-fn new_dict() -> DictRef {
-    Rc::new(RefCell::new(HashMap::new()))
-}
-
-fn array(v: Vec<V>) -> V {
-    V::Array(Rc::new(RefCell::new(v)))
-}
-
-fn matrix_of(v: &V) -> Option<Affine> {
-    let a: Vec<f64> = v.items()?.iter().filter_map(V::num).collect();
-    (a.len() == 6).then(|| Affine::new([a[0], a[1], a[2], a[3], a[4], a[5]]))
-}
-
-fn matrix_val(m: Affine) -> V {
-    array(m.as_coeffs().iter().map(|c| V::Num(*c)).collect())
-}
-
-/// The angle from `a` counterclockwise to `b` (degrees, 0 to 360), worked out from what is left
-/// of each after whole turns.
-fn ccw_turn(a: f64, b: f64) -> f64 {
-    (b % 360.0 - a % 360.0).rem_euclid(360.0)
-}
-
-/// The most turns one `arc` or `arcn` draws.
-const MAX_ARC_TURNS: f64 = 1024.0;
-
-/// The deepest procedure nesting run (deeper recursion stops the program).
-const MAX_CALL_DEPTH: usize = 256;
-
-impl Interp {
-    pub fn new(page: [f64; 4]) -> Interp {
-        Interp {
-            b: Builder::new(),
-            st: vec![],
-            dicts: vec![new_dict()],
-            gs: GState {
-                ctm: Affine::IDENTITY,
-                color: [0.0; 3],
-                lw: 1.0,
-                cap: Cap::Butt,
-                join: Join::Miter,
-                miter: 10.0,
-                dash: None,
-                path: BezPath::new(),
-                cur: None,
-                start: None,
-                depth: 1,
-                font: None,
-            },
-            saved: vec![],
-            budget: 8_000_000,
-            calls: 0,
-            font_dir: HashMap::new(),
-            embedded: HashMap::new(),
-            font_cache: HashMap::new(),
-            page,
-            unknown: vec![],
-        }
-    }
-
-    pub fn run(&mut self, data: &[u8]) {
-        self.embedded = embedded_fonts(data);
-        let mut src = Src { d: data, pos: 0 };
-        while let Some(t) = src.token(0) {
-            if let Err(Flow::Quit) = self.exec_token(t, &mut src) {
-                break;
-            }
-        }
-    }
-
-    fn pop(&mut self) -> V {
-        self.st.pop().unwrap_or(V::Null)
-    }
-    fn popn(&mut self) -> f64 {
-        self.pop().num().unwrap_or(0.0)
-    }
-    fn push(&mut self, v: V) {
-        if self.st.len() < 100_000 {
-            self.st.push(v);
-        }
-    }
-
-    fn lookup(&self, k: &str) -> Option<V> {
-        self.dicts.iter().rev().find_map(|d| d.borrow().get(k).cloned())
-    }
-
-    /// A token read from the file: procedures are pushed, names executed.
-    fn exec_token(&mut self, t: V, src: &mut Src) -> Result<(), Flow> {
-        match t {
-            V::Name(n) => self.exec_name(&n, src),
-            other => {
-                self.push(other);
-                Ok(())
-            }
-        }
-    }
-
-    /// Execute a value as an object (procedures run).
-    fn exec_obj(&mut self, v: V, src: &mut Src) -> Result<(), Flow> {
-        match v {
-            V::Proc(p) => {
-                if self.calls >= MAX_CALL_DEPTH {
-                    self.b.skip("PostScript (recursion limit)");
-                    return Err(Flow::Quit);
-                }
-                self.calls += 1;
-                let mut r = Ok(());
-                for x in p.iter() {
-                    match x {
-                        V::Name(n) => {
-                            r = self.exec_name(n, src);
-                            if r.is_err() {
-                                break;
-                            }
-                        }
-                        V::Op(op) => {
-                            r = self.spend(1).and_then(|()| self.builtin(op, src));
-                            if r.is_err() {
-                                break;
-                            }
-                        }
-                        // Other items count against the budget as names do.
-                        other => {
-                            r = self.spend(1);
-                            if r.is_err() {
-                                break;
-                            }
-                            self.push(other.clone());
-                        }
-                    }
-                }
-                self.calls -= 1;
-                r
-            }
-            // An executable name can run another (`exec` of `/exec cvx`), so names count too.
-            V::Name(n) => {
-                if self.calls >= MAX_CALL_DEPTH {
-                    self.b.skip("PostScript (recursion limit)");
-                    return Err(Flow::Quit);
-                }
-                self.calls += 1;
-                let r = self.exec_name(&n, src);
-                self.calls -= 1;
-                r
-            }
-            V::Op(op) => {
-                self.spend(1)?;
-                self.builtin(&op, src)
-            }
-            other => {
-                self.push(other);
-                Ok(())
-            }
-        }
-    }
-
-    fn exec_name(&mut self, n: &str, src: &mut Src) -> Result<(), Flow> {
-        self.spend(1)?;
-        if let Some(v) = self.lookup(n) {
-            return match v {
-                V::Proc(_) => self.exec_obj(v, src),
-                // An operator stored under another name (`/mo /moveto load def`, as Illustrator's
-                // EPS prolog does for every path operator) runs that operator. It pushed the
-                // operator's name instead, so such files drew nothing (#955).
-                V::Op(op) => self.builtin(&op, src),
-                // An executable name (`/y /x cvx def`) runs what that name is bound to.
-                V::Name(_) => self.exec_obj(v, src),
-                other => {
-                    self.push(other);
-                    Ok(())
-                }
-            };
-        }
-        self.builtin(n, src)
-    }
-
-    /// Count `n` operations against the budget, and stop the program when fewer are left. An
-    /// operator that makes, reads or copies path elements counts each one as an operation.
-    fn spend(&mut self, n: usize) -> Result<(), Flow> {
-        match self.budget.checked_sub(n) {
-            Some(left) => {
-                self.budget = left;
-                Ok(())
-            }
-            None => {
-                self.b.skip("PostScript (operation limit)");
-                Err(Flow::Quit)
-            }
-        }
-    }
-
-    fn device_scale(&self) -> f64 {
-        self.gs.ctm.determinant().abs().sqrt()
-    }
-
-    fn user_point(&mut self) -> Point {
-        let y = self.popn();
-        let x = self.popn();
-        Point::new(x, y)
-    }
-
-    /// Stop the program when a path of `len` elements would be longer than [`MAX_PATH`].
-    fn path_fits(&mut self, len: usize) -> Result<(), Flow> {
-        if len <= MAX_PATH {
-            return Ok(());
-        }
-        self.b.skip("PostScript (path limit)");
-        Err(Flow::Quit)
-    }
-
-    /// [`Self::path_fits`] for the current path with `n` more elements.
-    fn room(&mut self, n: usize) -> Result<(), Flow> {
-        self.path_fits(self.gs.path.elements().len().saturating_add(n))
-    }
-
-    fn move_to(&mut self, p: Point) -> Result<(), Flow> {
-        // A moveto right after a moveto replaces it (PostScript Language Reference §8.2, `moveto`).
-        if matches!(self.gs.path.elements().last(), Some(PathEl::MoveTo(_))) {
-            self.gs.path.pop();
-        }
-        self.room(1)?;
-        let q = self.gs.ctm * p;
-        self.gs.path.move_to(q);
-        self.gs.cur = Some(q);
-        self.gs.start = Some(q);
-        Ok(())
-    }
-    fn line_to(&mut self, p: Point) -> Result<(), Flow> {
-        self.room(1 + usize::from(self.gs.cur.is_none()))?;
-        let q = self.gs.ctm * p;
-        if self.gs.cur.is_none() {
-            self.gs.path.move_to(q);
-            self.gs.start = Some(q);
-        }
-        self.gs.path.line_to(q);
-        self.gs.cur = Some(q);
-        Ok(())
-    }
-    fn curve_to(&mut self, a: Point, b: Point, c: Point) -> Result<(), Flow> {
-        self.room(1 + usize::from(self.gs.cur.is_none()))?;
-        let m = self.gs.ctm;
-        if self.gs.cur.is_none() {
-            self.gs.path.move_to(m * a);
-        }
-        self.gs.path.curve_to(m * a, m * b, m * c);
-        self.gs.cur = Some(m * c);
-        Ok(())
-    }
-    fn current_user(&self) -> Point {
-        self.gs.ctm.inverse() * self.gs.cur.unwrap_or_default()
-    }
-
-    fn arc(&mut self, neg: bool) -> Result<(), Flow> {
-        let a2 = self.popn();
-        let a1 = self.popn();
-        let r = self.popn();
-        let c = self.user_point();
-        // `arc` raises `a2` by multiples of 360 until it is at least `a1`, and `arcn` lowers it
-        // until it is at most `a1` (PostScript Language Reference §8.2, `arc` and `arcn`). Those
-        // sweeps, and the first endpoint, are worked out from what is left of each angle after
-        // whole turns.
-        let sweep = if !neg && a2 < a1 {
-            ccw_turn(a1, a2)
-        } else if neg && a2 > a1 {
-            -ccw_turn(a2, a1)
-        } else {
-            a2 - a1
-        };
-        // A sweep of more than `MAX_ARC_TURNS` turns is shortened by whole pairs of turns to
-        // between `MAX_ARC_TURNS - 2` and `MAX_ARC_TURNS` turns, with a skip note. The arc still
-        // ends at `a2`, and an even-odd fill or clip of it covers the same area as the full sweep.
-        let max = MAX_ARC_TURNS * 360.0;
-        let sweep = if sweep.abs() > max {
-            self.b.skip("arc (too many turns)");
-            let s = sweep.signum();
-            s * (max - 720.0 + (s * (a2 % 720.0 - a1 % 720.0)).rem_euclid(720.0))
-        } else {
-            sweep
-        };
-        let (a1, sweep) = ((a1 % 360.0).to_radians(), sweep.to_radians());
-        let start = Point::new(c.x + r * a1.cos(), c.y + r * a1.sin());
-        if self.gs.cur.is_some() {
-            self.line_to(start)?;
-        } else {
-            self.move_to(start)?;
-        }
-        let arc = kurbo::Arc::new(c, (r, r), a1, sweep, 0.0);
-        let m = self.gs.ctm;
-        // kurbo divides an arc into more curves the larger the radius (about 3.7 × 10^49 for a
-        // quarter turn at a radius of 10^300, more than a usize can count), so each one counts
-        // against the budget and the path limit.
-        let mut curves = arc.append_iter(0.1);
-        while let Some(PathEl::CurveTo(p1, p2, p3)) = curves.next() {
-            self.room(1)?;
-            self.spend(1)?;
-            self.gs.path.curve_to(m * p1, m * p2, m * p3);
-            self.gs.cur = Some(m * p3);
-        }
-        Ok(())
-    }
-
-    fn paint(&mut self, fill: Option<FillRule>, stroke: bool) {
-        let path = std::mem::take(&mut self.gs.path);
-        self.gs.cur = None;
-        self.gs.start = None;
-        let s = self.device_scale();
-        let st = stroke.then(|| Stroke {
-            paint: Paint::Color(self.gs.color),
-            opacity: 1.0,
-            width: if self.gs.lw <= 0.0 { 1.0 } else { self.gs.lw * s },
-            cap: self.gs.cap,
-            join: self.gs.join,
-            miter: self.gs.miter.max(1.0),
-            dash: self.gs.dash.as_ref().map(|(a, o)| (a.iter().map(|v| v * s).collect(), o * s)),
-        });
-        self.b.fill_stroke(path, Affine::IDENTITY, fill.map(|r| (Paint::Color(self.gs.color), 1.0, r)), st);
-    }
-
-    fn rect_path(&mut self) -> Result<Vec<BezPath>, Flow> {
-        // x y w h, or an array / string of numbers.
-        let top = self.pop();
-        let nums: Vec<f64> = match &top {
-            V::Array(_) | V::Proc(_) => {
-                let items = top.items().unwrap_or_default();
-                // An array's rectangles count against the budget, five path elements each.
-                self.spend(items.len() / 4 * 5)?;
-                items.iter().filter_map(V::num).collect()
-            }
-            V::Num(h) => {
-                let w = self.popn();
-                let y = self.popn();
-                let x = self.popn();
-                vec![x, y, w, *h]
-            }
-            _ => vec![],
-        };
-        self.path_fits(nums.len() / 4 * 5)?;
-        let m = self.gs.ctm;
-        Ok(nums
-            .as_chunks::<4>()
-            .0
-            .iter()
-            .map(|r| {
-                let mut p = BezPath::new();
-                p.move_to(m * Point::new(r[0], r[1]));
-                p.line_to(m * Point::new(r[0] + r[2], r[1]));
-                p.line_to(m * Point::new(r[0] + r[2], r[1] + r[3]));
-                p.line_to(m * Point::new(r[0], r[1] + r[3]));
-                p.close_path();
-                p
-            })
-            .collect())
-    }
-
-    fn grestore(&mut self) {
-        if let Some(g) = self.saved.pop() {
-            let d = g.depth;
-            self.gs = g;
-            self.b.close_to(d);
-        }
-    }
-
-    fn builtin(&mut self, n: &str, src: &mut Src) -> Result<(), Flow> {
-        match n {
-            // Stack.
-            "pop" => {
-                self.pop();
-            }
-            "exch" => {
-                let b = self.pop();
-                let a = self.pop();
-                self.push(b);
-                self.push(a);
-            }
-            "dup" => {
-                let a = self.st.last().cloned().unwrap_or(V::Null);
-                self.push(a);
-            }
-            "copy" => match self.pop() {
-                V::Num(k) => {
-                    let k = (k.max(0.0) as usize).min(self.st.len());
-                    let tail: Vec<V> = self.st[self.st.len() - k..].to_vec();
-                    self.st.extend(tail);
-                }
-                V::Array(dst) => {
-                    let s = self.pop().items().unwrap_or_default();
-                    let mut d = dst.borrow_mut();
-                    for (i, v) in s.into_iter().enumerate() {
-                        if i < d.len() {
-                            d[i] = v;
-                        }
-                    }
-                    drop(d);
-                    self.push(V::Array(dst));
-                }
-                other => self.push(other),
-            },
-            "index" => {
-                let k = self.popn().max(0.0) as usize;
-                let v = if k < self.st.len() { self.st[self.st.len() - 1 - k].clone() } else { V::Null };
-                self.push(v);
-            }
-            "roll" => {
-                let j = self.popn() as i64;
-                let k = (self.popn().max(0.0) as usize).min(self.st.len());
-                if k > 0 {
-                    let s = self.st.len() - k;
-                    let r = j.rem_euclid(k as i64) as usize;
-                    self.st[s..].rotate_right(r);
-                }
-            }
-            "clear" => self.st.clear(),
-            "count" => self.push(V::Num(self.st.len() as f64)),
-            "mark" | "[" | "<<" => self.push(V::Mark),
-            "cleartomark" => {
-                while let Some(v) = self.st.pop() {
-                    if matches!(v, V::Mark) {
-                        break;
-                    }
-                }
-            }
-            "counttomark" => {
-                let k = self.st.iter().rev().position(|v| matches!(v, V::Mark)).unwrap_or(self.st.len());
-                self.push(V::Num(k as f64));
-            }
-            "]" => {
-                let k = self.st.iter().rev().position(|v| matches!(v, V::Mark)).unwrap_or(self.st.len());
-                let items = self.st.split_off(self.st.len() - k);
-                self.st.pop();
-                self.push(array(items));
-            }
-            ">>" => {
-                let k = self.st.iter().rev().position(|v| matches!(v, V::Mark)).unwrap_or(self.st.len());
-                let items = self.st.split_off(self.st.len() - k);
-                self.st.pop();
-                let d = new_dict();
-                for kv in items.as_chunks::<2>().0 {
-                    d.borrow_mut().insert(kv[0].key(), kv[1].clone());
-                }
-                self.push(V::Dict(d));
-            }
-            // Arithmetic.
-            "add" | "sub" | "mul" | "div" | "idiv" | "mod" | "atan" | "exp" | "max" | "min" => {
-                let b = self.popn();
-                let a = self.popn();
-                let v = match n {
-                    "add" => a + b,
-                    "sub" => a - b,
-                    "mul" => a * b,
-                    "div" => {
-                        if b == 0.0 {
-                            0.0
-                        } else {
-                            a / b
-                        }
-                    }
-                    // `checked_*` give 0 both for a zero divisor and for the one overflowing
-                    // case, `i64::MIN / -1` (`/` and `%` panic on it in every build).
-                    "idiv" => (a as i64).checked_div(b as i64).unwrap_or(0) as f64,
-                    "mod" => (a as i64).checked_rem(b as i64).unwrap_or(0) as f64,
-                    "atan" => a.atan2(b).to_degrees().rem_euclid(360.0),
-                    "exp" => a.powf(b),
-                    "max" => a.max(b),
-                    _ => a.min(b),
-                };
-                self.push(V::Num(if v.is_finite() { v } else { 0.0 }));
-            }
-            "neg" | "abs" | "sqrt" | "sin" | "cos" | "ln" | "log" | "cvi" | "cvr" | "round" | "floor" | "ceiling" | "truncate" => {
-                let a = match self.pop() {
-                    V::Str(s) => parse_num(&s.borrow()).unwrap_or(0.0),
-                    v => v.num().unwrap_or(0.0),
-                };
-                let v = match n {
-                    "neg" => -a,
-                    "abs" => a.abs(),
-                    "sqrt" => a.max(0.0).sqrt(),
-                    "sin" => a.to_radians().sin(),
-                    "cos" => a.to_radians().cos(),
-                    "ln" => a.ln(),
-                    "log" => a.log10(),
-                    "cvi" | "truncate" => a.trunc(),
-                    "round" => (a + 0.5).floor(),
-                    "floor" => a.floor(),
-                    "ceiling" => a.ceil(),
-                    _ => a,
-                };
-                self.push(V::Num(if v.is_finite() { v } else { 0.0 }));
-            }
-            // Comparison and logic.
-            "eq" | "ne" => {
-                let b = self.pop();
-                let a = self.pop();
-                let eq = match (&a, &b) {
-                    (V::Num(x), V::Num(y)) => x == y,
-                    (V::Bool(x), V::Bool(y)) => x == y,
-                    (V::Null, V::Null) => true,
-                    (V::Array(x), V::Array(y)) => Rc::ptr_eq(x, y),
-                    (V::Dict(x), V::Dict(y)) => Rc::ptr_eq(x, y),
-                    (x, y) => !x.key().is_empty() && x.key() == y.key(),
-                };
-                self.push(V::Bool(eq == (n == "eq")));
-            }
-            "gt" | "ge" | "lt" | "le" => {
-                let b = self.popn();
-                let a = self.popn();
-                self.push(V::Bool(match n {
-                    "gt" => a > b,
-                    "ge" => a >= b,
-                    "lt" => a < b,
-                    _ => a <= b,
-                }));
-            }
-            "not" => match self.pop() {
-                V::Bool(b) => self.push(V::Bool(!b)),
-                v => self.push(V::Num(!(v.num().unwrap_or(0.0) as i64) as f64)),
-            },
-            "and" | "or" | "xor" => {
-                let b = self.pop();
-                let a = self.pop();
-                match (a, b) {
-                    (V::Bool(x), V::Bool(y)) => self.push(V::Bool(match n {
-                        "and" => x && y,
-                        "or" => x || y,
-                        _ => x ^ y,
-                    })),
-                    (x, y) => {
-                        let (x, y) = (x.num().unwrap_or(0.0) as i64, y.num().unwrap_or(0.0) as i64);
-                        self.push(V::Num(match n {
-                            "and" => x & y,
-                            "or" => x | y,
-                            _ => x ^ y,
-                        } as f64));
-                    }
-                }
-            }
-            "true" => self.push(V::Bool(true)),
-            "false" => self.push(V::Bool(false)),
-            "null" => self.push(V::Null),
-            // Control.
-            "exec" => {
-                let v = self.pop();
-                self.exec_obj(v, src)?;
-            }
-            "if" => {
-                let p = self.pop();
-                if let V::Bool(true) = self.pop() {
-                    self.exec_obj(p, src)?;
-                }
-            }
-            "ifelse" => {
-                let f = self.pop();
-                let t = self.pop();
-                let c = matches!(self.pop(), V::Bool(true));
-                self.exec_obj(if c { t } else { f }, src)?;
-            }
-            // Each pass of a loop counts against the budget.
-            "repeat" => {
-                let p = self.pop();
-                let k = self.popn().clamp(0.0, 1e6) as usize;
-                for _ in 0..k {
-                    self.spend(1)?;
-                    match self.exec_obj(p.clone(), src) {
-                        Err(Flow::Exit) => break,
-                        r => r?,
-                    }
-                }
-            }
-            "for" => {
-                let p = self.pop();
-                let lim = self.popn();
-                let inc = self.popn();
-                let mut i = self.popn();
-                let mut guard = 0;
-                while inc != 0.0 && ((inc > 0.0 && i <= lim) || (inc < 0.0 && i >= lim)) && guard < 1_000_000 {
-                    self.spend(1)?;
-                    self.push(V::Num(i));
-                    match self.exec_obj(p.clone(), src) {
-                        Err(Flow::Exit) => break,
-                        r => r?,
-                    }
-                    i += inc;
-                    guard += 1;
-                }
-            }
-            "loop" => {
-                let p = self.pop();
-                for _ in 0..1_000_000 {
-                    self.spend(1)?;
-                    match self.exec_obj(p.clone(), src) {
-                        Err(Flow::Exit) => break,
-                        r => r?,
-                    }
-                }
-            }
-            "forall" => {
-                let p = self.pop();
-                match self.pop() {
-                    V::Dict(d) => {
-                        let items: Vec<(String, V)> = d.borrow().iter().map(|(k, v)| (k.clone(), v.clone())).collect();
-                        for (k, v) in items {
-                            self.spend(1)?;
-                            self.push(V::Lit(k.into()));
-                            self.push(v);
-                            match self.exec_obj(p.clone(), src) {
-                                Err(Flow::Exit) => break,
-                                r => r?,
-                            }
-                        }
-                    }
-                    V::Str(s) => {
-                        let bytes = s.borrow().clone();
-                        for c in bytes {
-                            self.spend(1)?;
-                            self.push(V::Num(c as f64));
-                            match self.exec_obj(p.clone(), src) {
-                                Err(Flow::Exit) => break,
-                                r => r?,
-                            }
-                        }
-                    }
-                    a => {
-                        for v in a.items().unwrap_or_default() {
-                            self.spend(1)?;
-                            self.push(v);
-                            match self.exec_obj(p.clone(), src) {
-                                Err(Flow::Exit) => break,
-                                r => r?,
-                            }
-                        }
-                    }
-                }
-            }
-            "exit" => return Err(Flow::Exit),
-            "stop" => return Err(Flow::Stop),
-            "stopped" => {
-                let p = self.pop();
-                let stopped = match self.exec_obj(p, src) {
-                    Err(Flow::Quit) => return Err(Flow::Quit),
-                    Err(_) => true,
-                    Ok(()) => false,
-                };
-                self.push(V::Bool(stopped));
-            }
-            "quit" => return Err(Flow::Quit),
-            "showpage" | "copypage" => {}
-            // Dictionaries.
-            "def" => {
-                let v = self.pop();
-                let k = self.pop().key();
-                if let Some(d) = self.dicts.last() {
-                    d.borrow_mut().insert(k, v);
-                }
-            }
-            "store" => {
-                let v = self.pop();
-                let k = self.pop().key();
-                let d = self.dicts.iter().rev().find(|d| d.borrow().contains_key(&k)).or(self.dicts.last()).cloned();
-                if let Some(d) = d {
-                    d.borrow_mut().insert(k, v);
-                }
-            }
-            "load" => {
-                let k = self.pop().key();
-                let v = self.lookup(&k).unwrap_or(V::Op(k.into()));
-                self.push(v);
-            }
-            "undef" => {
-                let k = self.pop().key();
-                if let V::Dict(d) = self.pop() {
-                    d.borrow_mut().remove(&k);
-                }
-            }
-            "dict" => {
-                self.pop();
-                self.push(V::Dict(new_dict()));
-            }
-            "begin" => {
-                if let V::Dict(d) = self.pop()
-                    && self.dicts.len() < 64
-                {
-                    self.dicts.push(d);
-                }
-            }
-            "end" => {
-                if self.dicts.len() > 1 {
-                    self.dicts.pop();
-                }
-            }
-            "currentdict" => {
-                let d = self.dicts.last().cloned().unwrap_or_else(new_dict);
-                self.push(V::Dict(d));
-            }
-            "userdict" | "globaldict" | "systemdict" | "statusdict" | "errordict" | "$error" => {
-                let d = self.dicts[0].clone();
-                self.push(V::Dict(d));
-            }
-            "where" => {
-                let k = self.pop().key();
-                match self.dicts.iter().rev().find(|d| d.borrow().contains_key(&k)).cloned() {
-                    Some(d) => {
-                        self.push(V::Dict(d));
-                        self.push(V::Bool(true));
-                    }
-                    None => self.push(V::Bool(false)),
-                }
-            }
-            "known" => {
-                let k = self.pop().key();
-                let v = match self.pop() {
-                    V::Dict(d) => d.borrow().contains_key(&k),
-                    _ => false,
-                };
-                self.push(V::Bool(v));
-            }
-            "countdictstack" => self.push(V::Num(self.dicts.len() as f64)),
-            "cleardictstack" => self.dicts.truncate(1),
-            "findresource" | "findfont" | "findencoding" => {
-                let category = if n == "findresource" { self.pop().key() } else { String::new() };
-                let key = self.pop().key();
-                match (n, category.as_str()) {
-                    ("findfont", _) | (_, "Font") => {
-                        let f = self.find_font(&key);
-                        self.push(V::Dict(f));
-                    }
-                    ("findencoding", _) | (_, "Encoding") => self.push(encoding_array(&key)),
-                    _ => self.push(V::Dict(new_dict())),
-                }
-            }
-            "defineresource" => {
-                let category = self.pop().key();
-                let v = self.pop();
-                let key = self.pop().key();
-                if let (V::Dict(d), "Font") = (&v, category.as_str()) {
-                    self.font_dir.insert(key, d.clone());
-                }
-                self.push(v);
-            }
-            "resourcestatus" => {
-                self.pop();
-                self.pop();
-                self.push(V::Bool(false));
-            }
-            // Arrays and strings.
-            "array" => {
-                let k = self.popn().clamp(0.0, 1e6) as usize;
-                self.push(array(vec![V::Null; k]));
-            }
-            "string" => {
-                let k = self.popn().clamp(0.0, 1e7) as usize;
-                self.push(V::Str(Rc::new(RefCell::new(vec![0; k]))));
-            }
-            "length" => {
-                let l = match self.pop() {
-                    V::Str(s) => s.borrow().len(),
-                    V::Dict(d) => d.borrow().len(),
-                    V::Name(s) | V::Lit(s) => s.len(),
-                    v => v.items().map_or(0, |i| i.len()),
-                };
-                self.push(V::Num(l as f64));
-            }
-            "get" => {
-                let k = self.pop();
-                let v = match self.pop() {
-                    V::Dict(d) => d.borrow().get(&k.key()).cloned().unwrap_or(V::Null),
-                    V::Str(s) => V::Num(s.borrow().get(k.num().unwrap_or(0.0) as usize).copied().unwrap_or(0) as f64),
-                    a => a.items().and_then(|i| i.get(k.num().unwrap_or(0.0) as usize).cloned()).unwrap_or(V::Null),
-                };
-                self.push(v);
-            }
-            "put" => {
-                let v = self.pop();
-                let k = self.pop();
-                match self.pop() {
-                    V::Dict(d) => {
-                        d.borrow_mut().insert(k.key(), v);
-                    }
-                    V::Array(a) => {
-                        let i = k.num().unwrap_or(0.0) as usize;
-                        if let Some(slot) = a.borrow_mut().get_mut(i) {
-                            *slot = v;
-                        }
-                    }
-                    V::Str(s) => {
-                        let i = k.num().unwrap_or(0.0) as usize;
-                        if let Some(slot) = s.borrow_mut().get_mut(i) {
-                            *slot = v.num().unwrap_or(0.0) as u8;
-                        }
-                    }
-                    _ => {}
-                }
-            }
-            "getinterval" => {
-                let c = self.popn().max(0.0) as usize;
-                let i = self.popn().max(0.0) as usize;
-                match self.pop() {
-                    V::Str(s) => {
-                        let b = s.borrow();
-                        let part = b.get(i.min(b.len())..(i + c).min(b.len())).unwrap_or(&[]).to_vec();
-                        drop(b);
-                        self.push(V::Str(Rc::new(RefCell::new(part))));
-                    }
-                    a => {
-                        let items = a.items().unwrap_or_default();
-                        let part = items.get(i.min(items.len())..(i + c).min(items.len())).unwrap_or(&[]).to_vec();
-                        self.push(array(part));
-                    }
-                }
-            }
-            "putinterval" => {
-                self.pop();
-                self.pop();
-                self.pop();
-            }
-            "aload" => {
-                let a = self.pop();
-                for v in a.items().unwrap_or_default() {
-                    self.push(v);
-                }
-                self.push(a);
-            }
-            "astore" => {
-                let a = self.pop();
-                if let V::Array(arr) = &a {
-                    let k = arr.borrow().len().min(self.st.len());
-                    let items = self.st.split_off(self.st.len() - k);
-                    *arr.borrow_mut() = items;
-                }
-                self.push(a);
-            }
-            "cvx" => match self.pop() {
-                V::Array(a) => self.push(V::Proc(Rc::new(a.borrow().clone()))),
-                V::Lit(s) => self.push(V::Name(s)),
-                V::Str(s) => {
-                    // Executable string: tokenize it as a procedure.
-                    let bytes = s.borrow().clone();
-                    let mut sub = Src { d: &bytes, pos: 0 };
-                    let mut body = vec![];
-                    while let Some(t) = sub.token(0) {
-                        body.push(t);
-                    }
-                    self.push(V::Proc(Rc::new(body)));
-                }
-                v => self.push(v),
-            },
-            "cvlit" => match self.pop() {
-                V::Proc(p) => self.push(array(p.as_ref().clone())),
-                V::Name(s) => self.push(V::Lit(s)),
-                v => self.push(v),
-            },
-            "cvn" => {
-                let k = self.pop().key();
-                self.push(V::Lit(k.into()));
-            }
-            "cvs" => {
-                self.pop();
-                let k = self.pop().key();
-                self.push(V::Str(Rc::new(RefCell::new(k.into_bytes()))));
-            }
-            "xcheck" => {
-                let v = self.pop();
-                self.push(V::Bool(matches!(v, V::Proc(_) | V::Name(_) | V::Op(_))));
-            }
-            "type" => {
-                let t = match self.pop() {
-                    V::Num(_) => "realtype",
-                    V::Bool(_) => "booleantype",
-                    V::Name(_) | V::Lit(_) => "nametype",
-                    V::Op(_) => "operatortype",
-                    V::Str(_) => "stringtype",
-                    V::Proc(_) | V::Array(_) => "arraytype",
-                    V::Dict(_) => "dicttype",
-                    V::Mark => "marktype",
-                    V::Null => "nulltype",
-                    V::File => "filetype",
-                };
-                self.push(V::Name(t.into()));
-            }
-            "bind" | "readonly" | "executeonly" | "noaccess" => {}
-            "languagelevel" => self.push(V::Num(3.0)),
-            "version" | "product" => self.push(V::Str(Rc::new(RefCell::new(b"3010".to_vec())))),
-            "save" => {
-                self.spend(self.gs.path.elements().len())?;
-                self.saved.push(self.gs.clone());
-                self.gs.depth = self.b.depth();
-                self.push(V::Null);
-            }
-            "restore" => {
-                self.pop();
-                self.grestore();
-            }
-            "currentfile" => self.push(V::File),
-            "readstring" | "readhexstring" | "readline" => {
-                self.pop();
-                self.pop();
-                self.push(V::Str(Rc::new(RefCell::new(vec![]))));
-                self.push(V::Bool(false));
-            }
-            "flushfile" | "closefile" | "print" | "==" | "=" | "pstack" | "setpagedevice" | "setglobal" | "setpacking" | "setshared" | "setobjectformat"
-            | "setsmoothness" => {
-                if !matches!(n, "pstack") {
-                    self.pop();
-                }
-            }
-            "currentglobal" | "currentpacking" | "currentshared" => self.push(V::Bool(false)),
-            // Operators that return values must push them, or the rest of the program reads a
-            // shifted stack: Illustrator's EPS prolog queries the device this way and then drew
-            // nothing (#955). Values are a plain device's defaults (PostScript Language
-            // Reference, 3rd ed., chapter 8).
-            "currentflat" => self.push(V::Num(1.0)),
-            "currentscreen" => {
-                self.push(V::Num(60.0));
-                self.push(V::Num(45.0));
-                self.push(V::Proc(Rc::new(vec![])));
-            }
-            "currentblackgeneration" | "currentundercolorremoval" | "currenttransfer" => self.push(V::Proc(Rc::new(vec![]))),
-            "currentcolortransfer" => {
-                for _ in 0..4 {
-                    self.push(V::Proc(Rc::new(vec![])));
-                }
-            }
-            "currentpagedevice" | "currenthalftone" | "currentsystemparams" | "currentuserparams" | "currentdevparams" => {
-                if n == "currentdevparams" {
-                    self.pop();
-                }
-                self.push(V::Dict(new_dict()));
-            }
-            "setuserparams" | "setsystemparams" | "setcolortransfer" | "setblackgeneration" | "setundercolorremoval" => {
-                let k = if n == "setcolortransfer" { 4 } else { 1 };
-                for _ in 0..k {
-                    self.pop();
-                }
-            }
-            // `file status` → false; `string status` → false (no such file).
-            "status" => {
-                self.pop();
-                self.push(V::Bool(false));
-            }
-            "dictstack" => {
-                self.pop();
-                let ds: Vec<V> = self.dicts.iter().map(|d| V::Dict(d.clone())).collect();
-                self.push(array(ds));
-            }
-            "maxlength" => {
-                let k = match self.pop() {
-                    V::Dict(d) => d.borrow().len(),
-                    _ => 0,
-                };
-                self.push(V::Num(k.saturating_add(16) as f64));
-            }
-            "internaldict" => {
-                self.pop();
-                let d = self.dicts[0].clone();
-                self.push(V::Dict(d));
-            }
-            "undefineresource" => {
-                self.pop();
-                self.pop();
-            }
-            // `[ … /Name pdfmark`: a Distiller annotation; other interpreters discard it.
-            "pdfmark" => {
-                while let Some(v) = self.st.pop() {
-                    if matches!(v, V::Mark) {
-                        break;
-                    }
-                }
-            }
-            // `source [params] /Name filter`. A SubFileDecode of the current file with a count of
-            // 0 reads to its end-of-data string: skip that data (an embedded XMP packet, which
-            // otherwise ran as PostScript). Other filters read what their source reads.
-            "filter" => {
-                let name = self.pop().key();
-                let mut skipped = false;
-                let source = if name == "SubFileDecode" && !matches!(self.st.last(), Some(V::Dict(_))) {
-                    let eod = match self.pop() {
-                        V::Str(s) => s.borrow().clone(),
-                        _ => vec![],
-                    };
-                    let count = self.popn();
-                    let source = self.pop();
-                    if matches!(source, V::File) && count == 0.0 && !eod.is_empty() {
-                        src.pos = match find_from(src.d, &eod, src.pos) {
-                            Some(p) => p.saturating_add(eod.len()),
-                            None => src.d.len(),
-                        };
-                        skipped = true;
-                    }
-                    source
-                } else {
-                    if matches!(self.st.last(), Some(V::Dict(_))) {
-                        self.pop();
-                    }
-                    self.pop()
-                };
-                // Data already stepped over leaves nothing for `image` to skip.
-                self.push(if skipped { V::Null } else { source });
-            }
-            "vmstatus" => {
-                for _ in 0..3 {
-                    self.push(V::Num(0.0));
-                }
-            }
-            // Graphics state.
-            "gsave" => {
-                self.spend(self.gs.path.elements().len())?;
-                let mut g = self.gs.clone();
-                g.depth = self.b.depth();
-                self.saved.push(g);
-            }
-            "grestore" => self.grestore(),
-            "grestoreall" => {
-                while !self.saved.is_empty() {
-                    self.grestore();
-                }
-            }
-            "initgraphics" => {
-                self.gs.ctm = Affine::IDENTITY;
-                self.gs.lw = 1.0;
-                self.gs.color = [0.0; 3];
-            }
-            "setlinewidth" => self.gs.lw = self.popn(),
-            "currentlinewidth" => self.push(V::Num(self.gs.lw)),
-            "setlinecap" => self.gs.cap = [Cap::Butt, Cap::Round, Cap::Square][(self.popn().max(0.0) as usize).min(2)],
-            "setlinejoin" => self.gs.join = [Join::Miter, Join::Round, Join::Bevel][(self.popn().max(0.0) as usize).min(2)],
-            "setmiterlimit" => self.gs.miter = self.popn(),
-            "setdash" => {
-                let off = self.popn();
-                let a: Vec<f64> = self.pop().items().unwrap_or_default().iter().filter_map(V::num).collect();
-                self.gs.dash = (!a.is_empty() && a.iter().any(|v| *v > 0.0)).then_some((a, off));
-            }
-            "setflat" | "setstrokeadjust" | "setoverprint" | "setrenderingintent" | "setcolorrendering" | "sethalftone" | "settransfer" => {
-                self.pop();
-            }
-            // frequency angle proc
-            "setscreen" => {
-                for _ in 0..3 {
-                    self.pop();
-                }
-            }
-            "setgray" => {
-                let g = self.popn().clamp(0.0, 1.0);
-                self.gs.color = [g; 3];
-            }
-            "setrgbcolor" => {
-                let b = self.popn();
-                let g = self.popn();
-                let r = self.popn();
-                self.gs.color = [r, g, b].map(|v| v.clamp(0.0, 1.0));
-            }
-            "sethsbcolor" => {
-                let v = self.popn().clamp(0.0, 1.0);
-                let s = self.popn().clamp(0.0, 1.0);
-                let h = self.popn().rem_euclid(1.0) * 6.0;
-                let (i, f) = (h.floor() as i32, h.fract());
-                let (p, q, t) = (v * (1.0 - s), v * (1.0 - s * f), v * (1.0 - s * (1.0 - f)));
-                self.gs.color = match i {
-                    0 => [v, t, p],
-                    1 => [q, v, p],
-                    2 => [p, v, t],
-                    3 => [p, q, v],
-                    4 => [t, p, v],
-                    _ => [v, p, q],
-                };
-            }
-            "setcmykcolor" => {
-                let k = self.popn().clamp(0.0, 1.0);
-                let y = self.popn().clamp(0.0, 1.0);
-                let m = self.popn().clamp(0.0, 1.0);
-                let c = self.popn().clamp(0.0, 1.0);
-                self.gs.color = [(1.0 - c) * (1.0 - k), (1.0 - m) * (1.0 - k), (1.0 - y) * (1.0 - k)];
-            }
-            "setcolorspace" => {
-                self.pop();
-            }
-            "setcolor" => {
-                // Device colour by operand count (patterns are not drawn).
-                let k = self.st.iter().rev().take_while(|v| matches!(v, V::Num(_))).count().min(4);
-                let c: Vec<f64> = self.st.split_off(self.st.len() - k).iter().filter_map(V::num).collect();
-                self.gs.color = match c.len() {
-                    1 => [c[0]; 3],
-                    3 => [c[0], c[1], c[2]],
-                    4 => [(1.0 - c[0]) * (1.0 - c[3]), (1.0 - c[1]) * (1.0 - c[3]), (1.0 - c[2]) * (1.0 - c[3])],
-                    _ => self.gs.color,
-                };
-            }
-            "currentgray" => self.push(V::Num((self.gs.color[0] + self.gs.color[1] + self.gs.color[2]) / 3.0)),
-            "currentrgbcolor" => {
-                for c in self.gs.color {
-                    self.push(V::Num(c));
-                }
-            }
-            // Coordinates.
-            "matrix" => self.push(matrix_val(Affine::IDENTITY)),
-            "identmatrix" | "defaultmatrix" => {
-                self.pop();
-                self.push(matrix_val(Affine::IDENTITY));
-            }
-            "currentmatrix" => {
-                self.pop();
-                self.push(matrix_val(self.gs.ctm));
-            }
-            "setmatrix" => {
-                let m = self.pop();
-                self.gs.ctm = matrix_of(&m).unwrap_or(Affine::IDENTITY);
-            }
-            "concat" => {
-                let m = self.pop();
-                if let Some(m) = matrix_of(&m) {
-                    self.gs.ctm *= m;
-                }
-            }
-            "concatmatrix" => {
-                self.pop();
-                let b = self.pop();
-                let a = self.pop();
-                let (a, b) = (matrix_of(&a).unwrap_or(Affine::IDENTITY), matrix_of(&b).unwrap_or(Affine::IDENTITY));
-                self.push(matrix_val(b * a));
-            }
-            "invertmatrix" => {
-                self.pop();
-                let a = self.pop();
-                self.push(matrix_val(matrix_of(&a).unwrap_or(Affine::IDENTITY).inverse()));
-            }
-            "translate" | "scale" => {
-                let top = self.pop();
-                let (m_out, y) = match top {
-                    V::Array(_) => (Some(top), self.popn()),
-                    v => (None, v.num().unwrap_or(0.0)),
-                };
-                let x = self.popn();
-                let t = if n == "translate" { Affine::translate((x, y)) } else { Affine::scale_non_uniform(x, y) };
-                match m_out {
-                    Some(_) => self.push(matrix_val(t)),
-                    None => self.gs.ctm *= t,
-                }
-            }
-            "rotate" => {
-                let top = self.pop();
-                match top {
-                    V::Array(_) => {
-                        let a = self.popn();
-                        self.push(matrix_val(Affine::rotate(a.to_radians())));
-                    }
-                    v => self.gs.ctm *= Affine::rotate(v.num().unwrap_or(0.0).to_radians()),
-                }
-            }
-            "transform" | "itransform" | "dtransform" | "idtransform" => {
-                let top = self.pop();
-                let (m, y) = match top {
-                    V::Array(_) | V::Proc(_) => (matrix_of(&top).unwrap_or(Affine::IDENTITY), self.popn()),
-                    v => (self.gs.ctm, v.num().unwrap_or(0.0)),
-                };
-                let x = self.popn();
-                let m = if n.starts_with('i') { m.inverse() } else { m };
-                let p = if n.contains('d') {
-                    let c = m.as_coeffs();
-                    Point::new(c[0] * x + c[2] * y, c[1] * x + c[3] * y)
-                } else {
-                    m * Point::new(x, y)
-                };
-                self.push(V::Num(p.x));
-                self.push(V::Num(p.y));
-            }
-            // Paths.
-            "newpath" => {
-                self.gs.path = BezPath::new();
-                self.gs.cur = None;
-                self.gs.start = None;
-            }
-            "moveto" => {
-                let p = self.user_point();
-                self.move_to(p)?;
-            }
-            "rmoveto" => {
-                let d = self.user_point();
-                let c = self.current_user();
-                self.move_to(Point::new(c.x + d.x, c.y + d.y))?;
-            }
-            "lineto" => {
-                let p = self.user_point();
-                self.line_to(p)?;
-            }
-            "rlineto" => {
-                let d = self.user_point();
-                let c = self.current_user();
-                self.line_to(Point::new(c.x + d.x, c.y + d.y))?;
-            }
-            "curveto" | "rcurveto" => {
-                let p3 = self.user_point();
-                let p2 = self.user_point();
-                let p1 = self.user_point();
-                if n == "rcurveto" {
-                    let c = self.current_user();
-                    let o = |p: Point| Point::new(c.x + p.x, c.y + p.y);
-                    self.curve_to(o(p1), o(p2), o(p3))?;
-                } else {
-                    self.curve_to(p1, p2, p3)?;
-                }
-            }
-            "closepath" => {
-                if self.gs.cur.is_some() {
-                    self.room(1)?;
-                    self.gs.path.close_path();
-                    self.gs.cur = self.gs.start;
-                }
-            }
-            "arc" => self.arc(false)?,
-            "arcn" => self.arc(true)?,
-            "currentpoint" => {
-                let c = self.current_user();
-                self.push(V::Num(c.x));
-                self.push(V::Num(c.y));
-            }
-            "pathbbox" => {
-                self.spend(self.gs.path.elements().len())?;
-                let r = kurbo::Shape::bounding_box(&self.gs.path);
-                let inv = self.gs.ctm.inverse();
-                let (a, b) = (inv * Point::new(r.x0, r.y0), inv * Point::new(r.x1, r.y1));
-                for v in [a.x.min(b.x), a.y.min(b.y), a.x.max(b.x), a.y.max(b.y)] {
-                    self.push(V::Num(v));
-                }
-            }
-            "flattenpath" | "reversepath" | "strokepath" | "initclip" => {}
-            "clippath" => {
-                let p = self.page;
-                self.gs.path = kurbo::Shape::to_path(&kurbo::Rect::new(p[0], p[1], p[2], p[3]), 0.1);
-            }
-            // Painting.
-            "fill" => self.paint(Some(FillRule::NonZero), false),
-            "eofill" => self.paint(Some(FillRule::EvenOdd), false),
-            "stroke" => self.paint(None, true),
-            "clip" | "eoclip" => {
-                let rule = if n == "clip" { FillRule::NonZero } else { FillRule::EvenOdd };
-                self.spend(self.gs.path.elements().len())?;
-                let p = self.gs.path.clone();
-                if !p.elements().iter().all(|e| matches!(e, PathEl::MoveTo(_))) {
-                    self.b.clip(p, rule);
-                }
-            }
-            "rectfill" | "rectstroke" | "rectclip" => {
-                let paths = self.rect_path()?;
-                if n == "rectstroke" && matches!(self.st.last(), Some(V::Array(_))) {
-                    self.pop();
-                }
-                let mut all = BezPath::new();
-                for p in paths {
-                    all.extend(p);
-                }
-                match n {
-                    "rectclip" => self.b.clip(all, FillRule::NonZero),
-                    _ => {
-                        let saved = std::mem::replace(&mut self.gs.path, all);
-                        self.paint(if n == "rectfill" { Some(FillRule::NonZero) } else { None }, n == "rectstroke");
-                        self.gs.path = saved;
-                    }
-                }
-            }
-            "shfill" => {
-                self.pop();
-                self.b.skip("smooth shading (shfill)");
-            }
-            // Text (see `text_op`).
-            "scalefont" | "makefont" | "selectfont" | "setfont" | "show" | "charpath" | "glyphshow" | "rootfont" | "currentfont" | "setcachedevice"
-            | "setcharwidth" | "ashow" | "widthshow" | "awidthshow" | "xshow" | "yshow" | "xyshow" | "kshow" | "cshow" | "stringwidth" | "definefont"
-            | "StandardEncoding" | "ISOLatin1Encoding" | "eexec" | "StartData" | "undefinefont" => self.text_op(n, src)?,
-            // Images: operands popped, inline data skipped.
-            "image" | "imagemask" | "colorimage" => {
-                let mut reads_file = false;
-                let check = |v: &V, rf: &mut bool| {
-                    if matches!(v, V::File) || matches!(v, V::Proc(p) if p.iter().any(|x| matches!(x, V::Name(n) if &**n == "currentfile"))) {
-                        *rf = true;
-                    }
-                };
-                if n == "colorimage" {
-                    let ncomp = self.popn().max(1.0) as usize;
-                    let multi = matches!(self.pop(), V::Bool(true));
-                    for _ in 0..if multi { ncomp.min(4) } else { 1 } {
-                        let v = self.pop();
-                        check(&v, &mut reads_file);
-                    }
-                    for _ in 0..4 {
-                        self.pop();
-                    }
-                } else {
-                    match self.pop() {
-                        V::Dict(d) => {
-                            if let Some(ds) = d.borrow().get("DataSource") {
-                                check(ds, &mut reads_file);
-                            }
-                        }
-                        top => {
-                            check(&top, &mut reads_file);
-                            for _ in 0..4 {
-                                self.pop();
-                            }
-                        }
-                    }
-                }
-                if reads_file {
-                    src.skip_image_data();
-                }
-                self.b.skip("image");
-            }
-            _ => {
-                if self.unknown.len() < 32 && !self.unknown.iter().any(|u| u == n) {
-                    self.unknown.push(n.to_string());
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
-/// The PostScript section of an EPS file (DOS EPS binary header handled) and its bounding box
-/// (`%%HiResBoundingBox` preferred).
-pub fn eps_parts(bytes: &[u8]) -> Option<(&[u8], [f64; 4])> {
-    let ps = if bytes.starts_with(&[0xC5, 0xD0, 0xD3, 0xC6]) && bytes.len() >= 12 {
-        let off = u32::from_le_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]) as usize;
-        let len = u32::from_le_bytes([bytes[8], bytes[9], bytes[10], bytes[11]]) as usize;
-        bytes.get(off..off.checked_add(len)?.min(bytes.len()))?
-    } else {
-        bytes
-    };
-    let find_box = |key: &[u8]| -> Option<[f64; 4]> {
-        let mut from = 0;
-        while let Some(p) = ps[from..].windows(key.len()).position(|w| w == key) {
-            let s = from + p + key.len();
-            let e = ps[s..].iter().position(|c| matches!(c, b'\n' | b'\r')).map_or(ps.len(), |q| s + q);
-            let v: Vec<f64> = String::from_utf8_lossy(&ps[s..e]).split_whitespace().filter_map(|t| t.parse().ok()).collect();
-            if v.len() == 4 && v[2] > v[0] && v[3] > v[1] {
-                return Some([v[0], v[1], v[2], v[3]]);
-            }
-            from = s;
-        }
-        None
-    };
-    let bbox = find_box(b"%%HiResBoundingBox:").or_else(|| find_box(b"%%BoundingBox:"))?;
-    Some((ps, bbox))
-}
-
-// ------------------------------------------------------------------ text
-
-/// An encoding array of glyph names (`StandardEncoding`; `ISOLatin1Encoding` and others are
-/// approximated by WinAnsi, which agrees with ISO Latin-1 on the printable codes).
-fn encoding_array(name: &str) -> V {
-    let base = if name == "StandardEncoding" { crate::encoding::Base::Standard } else { crate::encoding::Base::WinAnsi };
-    array((0..256).map(|c| V::Lit(base.name(c as u8).unwrap_or_else(|| ".notdef".into()).into())).collect())
-}
-
-fn find_from(hay: &[u8], needle: &[u8], from: usize) -> Option<usize> {
-    hay.get(from..)?.windows(needle.len()).position(|w| w == needle).map(|p| p + from)
-}
-
-fn rfind_before(hay: &[u8], needle: &[u8], to: usize) -> Option<usize> {
-    hay.get(..to)?.windows(needle.len()).rposition(|w| w == needle)
-}
-
-/// The name after `key` (`/FontName /Name`).
-fn name_after(b: &[u8], key: &[u8]) -> Option<String> {
-    let p = find_from(b, key, 0)? + key.len();
-    let rest = &b[p..];
-    let s = rest.iter().position(|c| *c == b'/')? + 1;
-    let e = rest[s..].iter().position(|c| is_white(*c) || matches!(c, b'/' | b'[' | b'(' | b'{')).map_or(rest.len(), |q| s + q);
-    (e > s).then(|| String::from_utf8_lossy(&rest[s..e]).into_owned())
-}
-
-/// Embedded font programs of an EPS file: Type 1 fonts (`… /FontName /X … currentfile eexec
-/// … cleartomark`, hexadecimal or binary) and CFF font sets (`… <length> StartData <bytes>`).
-fn embedded_fonts(ps: &[u8]) -> HashMap<String, (Rc<Vec<u8>>, bool)> {
-    let mut out = HashMap::new();
-    let mut from = 0;
-    while let Some(ee) = find_from(ps, b"eexec", from) {
-        from = ee + 5;
-        let start = [b"%!PS-AdobeFont".as_slice(), b"%!FontType1"]
-            .iter()
-            .filter_map(|h| rfind_before(ps, h, ee))
-            .max()
-            .or_else(|| rfind_before(ps, b"/FontName", ee).map(|p| p.saturating_sub(512)));
-        let Some(start) = start else { continue };
-        let end = find_from(ps, b"cleartomark", ee).map_or(ps.len(), |p| p + 11);
-        if let Some(name) = name_after(&ps[start..ee], b"/FontName") {
-            out.insert(name, (Rc::new(ps[start..end].to_vec()), false));
-        }
-        from = end;
-    }
-    let mut from = 0;
-    while let Some(sd) = find_from(ps, b"StartData", from) {
-        from = sd + 9;
-        let head = String::from_utf8_lossy(&ps[sd.saturating_sub(64)..sd]).into_owned();
-        let Some(len) = head.split_whitespace().last().and_then(|t| t.parse::<usize>().ok()) else { continue };
-        let s = sd + 10;
-        let Some(data) = ps.get(s..s.saturating_add(len)) else { continue };
-        if let Some(name) = crate::cff::font_name(data) {
-            out.insert(name, (Rc::new(data.to_vec()), true));
-        }
-        from = s + len;
-    }
-    out
-}
-
-fn dict_matrix(d: &DictRef, key: &str) -> Affine {
-    d.borrow().get(key).and_then(matrix_of).unwrap_or(Affine::IDENTITY)
-}
-
-/// A copy of a font dictionary with `m` applied after its matrix (`scalefont`, `makefont`).
-fn transformed(font: &DictRef, m: Affine) -> DictRef {
-    let copy: HashMap<String, V> = font.borrow().clone();
-    let d = Rc::new(RefCell::new(copy));
-    let old = dict_matrix(&d, "__m");
-    d.borrow_mut().insert("__m".into(), matrix_val(m * old));
-    d
-}
-
-impl Interp {
-    /// A font dictionary by name: one `definefont` made, else a new dictionary for an
-    /// embedded program or a bundled stand-in.
-    fn find_font(&mut self, key: &str) -> DictRef {
-        if let Some(d) = self.font_dir.get(key) {
-            return d.clone();
-        }
-        let d = new_dict();
-        {
-            let mut m = d.borrow_mut();
-            m.insert("FontName".into(), V::Lit(key.into()));
-            m.insert("FontType".into(), V::Num(1.0));
-            m.insert("FontMatrix".into(), matrix_val(Affine::scale(0.001)));
-            m.insert("FID".into(), V::Null);
-            m.insert("__base".into(), V::Lit(key.into()));
-            m.insert("__m".into(), matrix_val(Affine::IDENTITY));
-        }
-        self.font_dir.insert(key.to_string(), d.clone());
-        d
-    }
-
-    /// The drawable font of a font dictionary (its base program and encoding) and the matrix
-    /// from text space (font size 1) to user space.
-    fn font_of(&mut self, d: &DictRef) -> Option<(Rc<Font>, Affine)> {
-        if matches!(d.borrow().get("FontType"), Some(V::Num(t)) if *t == 3.0) {
-            // Type 3 fonts (glyph procedures) are not run.
-            self.b.skip("EPS Type 3 font");
-            return None;
-        }
-        let (base, names) = {
-            let m = d.borrow();
-            let base = m.get("__base").or_else(|| m.get("FontName")).map(V::key)?;
-            let names: Option<Vec<Option<String>>> = m.get("Encoding").and_then(V::items).map(|a| {
-                a.iter()
-                    .map(|v| match v {
-                        V::Lit(n) | V::Name(n) if &**n != ".notdef" => Some(n.to_string()),
-                        _ => None,
-                    })
-                    .collect()
-            });
-            (base, names)
-        };
-        let key = match &names {
-            Some(n) => format!("{base}\u{0}{}", n.iter().map(|x| x.as_deref().unwrap_or("")).collect::<Vec<_>>().join(" ")),
-            None => base.clone(),
-        };
-        let font = match self.font_cache.get(&key) {
-            Some(f) => f.clone(),
-            None => {
-                // Not embedded: a bundled stand-in, as for PDF.
-                let prog = self.embedded.get(&base).cloned();
-                let f = Rc::new(Font::standalone(&base, prog.as_ref().map(|(d, cff)| (d.as_slice(), *cff)), names));
-                self.font_cache.insert(key, f.clone());
-                f
-            }
-        };
-        Some((font, dict_matrix(d, "__m")))
-    }
-
-    /// A string's glyph outlines (device space) from the current point, with an extra
-    /// displacement `extra(index, code)` (user space) after each glyph; moves the current
-    /// point.
-    fn text_path(&mut self, bytes: &[u8], mut extra: impl FnMut(usize, u32) -> (f64, f64)) -> Result<Option<(BezPath, String)>, Flow> {
-        let Some(d) = self.gs.font.clone() else { return Ok(None) };
-        let Some((font, m)) = self.font_of(&d) else { return Ok(None) };
-        let mut p = self.current_user();
-        let mut path = BezPath::new();
-        let mut text = String::new();
-        let ctm = self.gs.ctm;
-        for (i, &code) in bytes.iter().enumerate() {
-            let code = code as u32;
-            if let Some(g) = font.glyph(code) {
-                path.extend(ctm * Affine::translate(p.to_vec2()) * m * (*g).clone());
-            }
-            text.push_str(&font.unicode(code));
-            let adv = m * Point::new(font.width(code), 0.0) - m * Point::ZERO;
-            let (ex, ey) = extra(i, code);
-            p += adv + kurbo::Vec2::new(ex, ey);
-        }
-        self.move_to(p)?;
-        Ok(Some((path, text)))
-    }
-
-    fn fill_text(&mut self, path: BezPath, text: &str) {
-        let label: String = text.chars().filter(|c| !c.is_control()).take(40).collect();
-        let name = if label.trim().is_empty() { "Text".to_string() } else { format!("Text: {}", label.trim()) };
-        self.b.fill_stroke_named(&name, path, Affine::IDENTITY, Some((Paint::Color(self.gs.color), 1.0, FillRule::NonZero)), None);
-    }
-
-    fn pop_string(&mut self) -> Vec<u8> {
-        match self.pop() {
-            V::Str(s) => s.borrow().clone(),
-            _ => vec![],
-        }
-    }
-
-    fn show_with(&mut self, s: &[u8], extra: impl FnMut(usize, u32) -> (f64, f64)) -> Result<(), Flow> {
-        match self.text_path(s, extra)? {
-            Some((path, text)) => self.fill_text(path, &text),
-            None => self.b.skip("text (no font)"),
-        }
-        Ok(())
-    }
-
-    /// Text and font operators (PostScript Language Reference §5.1, §8.2).
-    fn text_op(&mut self, n: &str, src: &mut Src) -> Result<(), Flow> {
-        match n {
-            "scalefont" | "makefont" => {
-                let m = if n == "scalefont" {
-                    Affine::scale(self.popn())
-                } else {
-                    let v = self.pop();
-                    matrix_of(&v).unwrap_or(Affine::IDENTITY)
-                };
-                let font = match self.pop() {
-                    V::Dict(d) => d,
-                    _ => self.find_font("Helvetica"),
-                };
-                self.push(V::Dict(transformed(&font, m)));
-            }
-            "selectfont" => {
-                let size = self.pop();
-                let key = self.pop().key();
-                let font = self.find_font(&key);
-                let m = match &size {
-                    V::Num(s) => Affine::scale(*s),
-                    other => matrix_of(other).unwrap_or(Affine::IDENTITY),
-                };
-                self.gs.font = Some(transformed(&font, m));
-            }
-            "setfont" => {
-                if let V::Dict(d) = self.pop() {
-                    self.gs.font = Some(d);
-                }
-            }
-            "currentfont" | "rootfont" => {
-                let d = self.gs.font.clone().unwrap_or_else(new_dict);
-                self.push(V::Dict(d));
-            }
-            "definefont" => {
-                let v = self.pop();
-                let key = self.pop().key();
-                if let V::Dict(d) = &v {
-                    if !d.borrow().contains_key("__base") {
-                        // A font the file defines itself: its embedded program, by name.
-                        d.borrow_mut().insert("__base".into(), V::Lit(key.as_str().into()));
-                        d.borrow_mut().insert("__m".into(), matrix_val(Affine::IDENTITY));
-                    }
-                    self.font_dir.insert(key, d.clone());
-                }
-                self.push(v);
-            }
-            "undefinefont" => {
-                let key = self.pop().key();
-                self.font_dir.remove(&key);
-            }
-            "StandardEncoding" | "ISOLatin1Encoding" => self.push(encoding_array(n)),
-            "show" => {
-                let s = self.pop_string();
-                self.show_with(&s, |_, _| (0.0, 0.0))?;
-            }
-            "ashow" => {
-                let s = self.pop_string();
-                let ay = self.popn();
-                let ax = self.popn();
-                self.show_with(&s, |_, _| (ax, ay))?;
-            }
-            "widthshow" => {
-                let s = self.pop_string();
-                let ch = self.popn() as u32;
-                let cy = self.popn();
-                let cx = self.popn();
-                self.show_with(&s, |_, c| if c == ch { (cx, cy) } else { (0.0, 0.0) })?;
-            }
-            "awidthshow" => {
-                let s = self.pop_string();
-                let ay = self.popn();
-                let ax = self.popn();
-                let ch = self.popn() as u32;
-                let cy = self.popn();
-                let cx = self.popn();
-                self.show_with(&s, |_, c| if c == ch { (cx + ax, cy + ay) } else { (ax, ay) })?;
-            }
-            "kshow" | "cshow" => {
-                // The procedure between characters is not run.
-                let s = self.pop_string();
-                self.pop();
-                self.show_with(&s, |_, _| (0.0, 0.0))?;
-            }
-            "xshow" | "yshow" | "xyshow" => {
-                let disp: Vec<f64> = self.pop().items().unwrap_or_default().iter().filter_map(V::num).collect();
-                let s = self.pop_string();
-                self.explicit_show(&s, &disp, n)?;
-            }
-            "glyphshow" => {
-                let name = self.pop().key();
-                let Some(d) = self.gs.font.clone() else { return Ok(()) };
-                // Drawn through a one-glyph encoding.
-                let mut e: Vec<V> = (0..256).map(|_| V::Lit(".notdef".into())).collect();
-                e[65] = V::Lit(name.as_str().into());
-                let tmp = transformed(&d, Affine::IDENTITY);
-                tmp.borrow_mut().insert("Encoding".into(), array(e));
-                self.gs.font = Some(tmp);
-                self.show_with(b"A", |_, _| (0.0, 0.0))?;
-                self.gs.font = Some(d);
-            }
-            "charpath" => {
-                self.pop();
-                let s = self.pop_string();
-                let saved = std::mem::take(&mut self.gs.path);
-                let start = self.gs.start;
-                match self.text_path(&s, |_, _| (0.0, 0.0))? {
-                    Some((glyphs, _)) => {
-                        // The outlines join the path: each element counts against the budget and
-                        // the path limit.
-                        self.gs.path = saved;
-                        self.room(glyphs.elements().len() + 1)?;
-                        self.spend(glyphs.elements().len())?;
-                        self.gs.path.extend(glyphs);
-                        if let Some(c) = self.gs.cur {
-                            self.gs.path.move_to(c);
-                        }
-                        self.gs.start = start;
-                    }
-                    None => self.gs.path = saved,
-                }
-            }
-            "stringwidth" => {
-                let s = self.pop_string();
-                let (mut w, mut h) = (0.0, 0.0);
-                if let Some(d) = self.gs.font.clone()
-                    && let Some((font, m)) = self.font_of(&d)
-                {
-                    for &c in &s {
-                        let v = m * Point::new(font.width(c as u32), 0.0) - m * Point::ZERO;
-                        w += v.x;
-                        h += v.y;
-                    }
-                }
-                self.push(V::Num(w));
-                self.push(V::Num(h));
-            }
-            "setcachedevice" => {
-                for _ in 0..6 {
-                    self.pop();
-                }
-            }
-            "setcharwidth" => {
-                self.pop();
-                self.pop();
-            }
-            // An embedded Type 1 program's encrypted part (read by `embedded_fonts`).
-            "eexec" => {
-                if matches!(self.pop(), V::File) {
-                    let rest = &src.d[src.pos.min(src.d.len())..];
-                    src.pos += rest.windows(11).position(|w| w == b"cleartomark").map_or(rest.len(), |p| p + 11);
-                }
-            }
-            // A CFF font set's binary data (read by `embedded_fonts`).
-            "StartData" => {
-                let len = self.popn().max(0.0) as usize;
-                self.pop();
-                src.pos = src.pos.saturating_add(1).saturating_add(len).min(src.d.len());
-            }
-            _ => {}
-        }
-        Ok(())
-    }
-
-    /// `xshow` / `yshow` / `xyshow`: glyph displacements from a number array instead of the
-    /// advances.
-    fn explicit_show(&mut self, s: &[u8], disp: &[f64], n: &str) -> Result<(), Flow> {
-        let step = if n == "xyshow" { 2 } else { 1 };
-        let d: Vec<(f64, f64)> = (0..s.len())
-            .map(|k| {
-                let i = k * step;
-                let v = |j: usize| disp.get(j).copied().unwrap_or(0.0);
-                match n {
-                    "xshow" => (v(i), 0.0),
-                    "yshow" => (0.0, v(i)),
-                    _ => (v(i), v(i + 1)),
-                }
-            })
-            .collect();
-        let Some(fd) = self.gs.font.clone() else {
-            self.b.skip("text (no font)");
-            return Ok(());
-        };
-        let Some((font, m)) = self.font_of(&fd) else { return Ok(()) };
-        self.show_with(s, move |k, c| {
-            let adv = m * Point::new(font.width(c), 0.0) - m * Point::ZERO;
-            let (dx, dy) = d.get(k).copied().unwrap_or((0.0, 0.0));
-            (dx - adv.x, dy - adv.y)
-        })
-    }
-}
diff --git a/crates/pdf/src/ps/builtin.rs b/crates/pdf/src/ps/builtin.rs
new file mode 100644
index 000000000..dcafa9417
--- /dev/null
+++ b/crates/pdf/src/ps/builtin.rs
@@ -0,0 +1,1066 @@
+use super::eps::find_from;
+use super::scanner::Src;
+use super::text::encoding_array;
+use super::value::{Flow, V, array, matrix_of, matrix_val, new_dict};
+use super::{Affine, BezPath, Cap, FillRule, Interp, Join, PathEl, Point, Rc, RefCell, parse_num};
+
+impl Interp {
+    pub(super) fn builtin(&mut self, n: &str, src: &mut Src) -> Result<(), Flow> {
+        // Every handler leaves the stacks untouched when the operator is outside its family.
+        if self.try_stack_op(n)
+            || self.try_arithmetic_op(n)
+            || self.try_logic_op(n)
+            || self.try_control_op(n, src)?
+            || self.try_dictionary_op(n)
+            || self.try_collection_op(n)
+            || self.try_environment_op(n, src)?
+            || self.try_graphics_op(n)?
+            || self.try_coordinate_op(n)
+            || self.try_path_op(n)?
+            || self.try_paint_op(n)?
+        {
+            return Ok(());
+        }
+        match n {
+            // Text (see `text_op`).
+            "scalefont" | "makefont" | "selectfont" | "setfont" | "show" | "charpath" | "glyphshow" | "rootfont" | "currentfont" | "setcachedevice"
+            | "setcharwidth" | "ashow" | "widthshow" | "awidthshow" | "xshow" | "yshow" | "xyshow" | "kshow" | "cshow" | "stringwidth" | "definefont"
+            | "StandardEncoding" | "ISOLatin1Encoding" | "eexec" | "StartData" | "undefinefont" => self.text_op(n, src)?,
+            // Images: operands popped, inline data skipped.
+            "image" | "imagemask" | "colorimage" => {
+                let mut reads_file = false;
+                let check = |v: &V, rf: &mut bool| {
+                    if matches!(v, V::File) || matches!(v, V::Proc(p) if p.iter().any(|x| matches!(x, V::Name(n) if &**n == "currentfile"))) {
+                        *rf = true;
+                    }
+                };
+                if n == "colorimage" {
+                    let ncomp = self.popn().max(1.0) as usize;
+                    let multi = matches!(self.pop(), V::Bool(true));
+                    for _ in 0..if multi { ncomp.min(4) } else { 1 } {
+                        let v = self.pop();
+                        check(&v, &mut reads_file);
+                    }
+                    for _ in 0..4 {
+                        self.pop();
+                    }
+                } else {
+                    match self.pop() {
+                        V::Dict(d) => {
+                            if let Some(ds) = d.borrow().get("DataSource") {
+                                check(ds, &mut reads_file);
+                            }
+                        }
+                        top => {
+                            check(&top, &mut reads_file);
+                            for _ in 0..4 {
+                                self.pop();
+                            }
+                        }
+                    }
+                }
+                if reads_file {
+                    src.skip_image_data();
+                }
+                self.b.skip("image");
+            }
+            _ => {
+                if self.unknown.len() < 32 && !self.unknown.iter().any(|u| u == n) {
+                    self.unknown.push(n.to_string());
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn repeat_proc(&mut self, src: &mut Src) -> Result<(), Flow> {
+        let p = self.pop();
+        let k = self.popn().clamp(0.0, 1e6) as usize;
+        for _ in 0..k {
+            self.spend(1)?;
+            match self.exec_obj(p.clone(), src) {
+                Err(Flow::Exit) => break,
+                r => r?,
+            }
+        }
+
+        Ok(())
+    }
+
+    fn for_proc(&mut self, src: &mut Src) -> Result<(), Flow> {
+        let p = self.pop();
+        let lim = self.popn();
+        let inc = self.popn();
+        let mut i = self.popn();
+        let mut guard = 0;
+        while inc != 0.0 && ((inc > 0.0 && i <= lim) || (inc < 0.0 && i >= lim)) && guard < 1_000_000 {
+            self.spend(1)?;
+            self.push(V::Num(i));
+            match self.exec_obj(p.clone(), src) {
+                Err(Flow::Exit) => break,
+                r => r?,
+            }
+            i += inc;
+            guard += 1;
+        }
+
+        Ok(())
+    }
+
+    fn loop_proc(&mut self, src: &mut Src) -> Result<(), Flow> {
+        let p = self.pop();
+        for _ in 0..1_000_000 {
+            self.spend(1)?;
+            match self.exec_obj(p.clone(), src) {
+                Err(Flow::Exit) => break,
+                r => r?,
+            }
+        }
+
+        Ok(())
+    }
+
+    fn forall_proc(&mut self, src: &mut Src) -> Result<(), Flow> {
+        let p = self.pop();
+        match self.pop() {
+            V::Dict(d) => {
+                let items: Vec<(String, V)> = d.borrow().iter().map(|(k, v)| (k.clone(), v.clone())).collect();
+                for (k, v) in items {
+                    self.spend(1)?;
+                    self.push(V::Lit(k.into()));
+                    self.push(v);
+                    match self.exec_obj(p.clone(), src) {
+                        Err(Flow::Exit) => break,
+                        r => r?,
+                    }
+                }
+            }
+            V::Str(s) => {
+                let bytes = s.borrow().clone();
+                for c in bytes {
+                    self.spend(1)?;
+                    self.push(V::Num(c as f64));
+                    match self.exec_obj(p.clone(), src) {
+                        Err(Flow::Exit) => break,
+                        r => r?,
+                    }
+                }
+            }
+            a => {
+                for v in a.items().unwrap_or_default() {
+                    self.spend(1)?;
+                    self.push(v);
+                    match self.exec_obj(p.clone(), src) {
+                        Err(Flow::Exit) => break,
+                        r => r?,
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn try_stack_op(&mut self, n: &str) -> bool {
+        match n {
+            // Stack.
+            "pop" => {
+                self.pop();
+            }
+            "exch" => {
+                let b = self.pop();
+                let a = self.pop();
+                self.push(b);
+                self.push(a);
+            }
+            "dup" => {
+                let a = self.st.last().cloned().unwrap_or(V::Null);
+                self.push(a);
+            }
+            "copy" => {
+                match self.pop() {
+                    V::Num(k) => {
+                        let k = (k.max(0.0) as usize).min(self.st.len());
+                        let tail: Vec<V> = self.st[self.st.len() - k..].to_vec();
+                        self.st.extend(tail);
+                    }
+                    V::Array(dst) => {
+                        let s = self.pop().items().unwrap_or_default();
+                        let mut d = dst.borrow_mut();
+                        for (i, v) in s.into_iter().enumerate() {
+                            if i < d.len() {
+                                d[i] = v;
+                            }
+                        }
+                        drop(d);
+                        self.push(V::Array(dst));
+                    }
+                    other => self.push(other),
+                };
+            }
+            "index" => {
+                let k = self.popn().max(0.0) as usize;
+                let v = if k < self.st.len() { self.st[self.st.len() - 1 - k].clone() } else { V::Null };
+                self.push(v);
+            }
+            "roll" => {
+                let j = self.popn() as i64;
+                let k = (self.popn().max(0.0) as usize).min(self.st.len());
+                if k > 0 {
+                    let s = self.st.len() - k;
+                    let r = j.rem_euclid(k as i64) as usize;
+                    self.st[s..].rotate_right(r);
+                }
+            }
+            "clear" => self.st.clear(),
+            "count" => self.push(V::Num(self.st.len() as f64)),
+            "mark" | "[" | "<<" => self.push(V::Mark),
+            "cleartomark" => {
+                while let Some(v) = self.st.pop() {
+                    if matches!(v, V::Mark) {
+                        break;
+                    }
+                }
+            }
+            "counttomark" => {
+                let k = self.st.iter().rev().position(|v| matches!(v, V::Mark)).unwrap_or(self.st.len());
+                self.push(V::Num(k as f64));
+            }
+            "]" => {
+                let k = self.st.iter().rev().position(|v| matches!(v, V::Mark)).unwrap_or(self.st.len());
+                let items = self.st.split_off(self.st.len() - k);
+                self.st.pop();
+                self.push(array(items));
+            }
+            ">>" => {
+                let k = self.st.iter().rev().position(|v| matches!(v, V::Mark)).unwrap_or(self.st.len());
+                let items = self.st.split_off(self.st.len() - k);
+                self.st.pop();
+                let d = new_dict();
+                for kv in items.as_chunks::<2>().0 {
+                    d.borrow_mut().insert(kv[0].key(), kv[1].clone());
+                }
+                self.push(V::Dict(d));
+            }
+            _ => return false,
+        }
+        true
+    }
+
+    fn try_arithmetic_op(&mut self, n: &str) -> bool {
+        match n {
+            // Arithmetic.
+            "add" | "sub" | "mul" | "div" | "idiv" | "mod" | "atan" | "exp" | "max" | "min" => {
+                let b = self.popn();
+                let a = self.popn();
+                let v = match n {
+                    "add" => a + b,
+                    "sub" => a - b,
+                    "mul" => a * b,
+                    "div" => {
+                        if b == 0.0 {
+                            0.0
+                        } else {
+                            a / b
+                        }
+                    }
+                    // `checked_*` give 0 both for a zero divisor and for the one overflowing
+                    // case, `i64::MIN / -1` (`/` and `%` panic on it in every build).
+                    "idiv" => (a as i64).checked_div(b as i64).unwrap_or(0) as f64,
+                    "mod" => (a as i64).checked_rem(b as i64).unwrap_or(0) as f64,
+                    "atan" => a.atan2(b).to_degrees().rem_euclid(360.0),
+                    "exp" => a.powf(b),
+                    "max" => a.max(b),
+                    _ => a.min(b),
+                };
+                self.push(V::Num(if v.is_finite() { v } else { 0.0 }));
+            }
+            "neg" | "abs" | "sqrt" | "sin" | "cos" | "ln" | "log" | "cvi" | "cvr" | "round" | "floor" | "ceiling" | "truncate" => {
+                let a = match self.pop() {
+                    V::Str(s) => parse_num(&s.borrow()).unwrap_or(0.0),
+                    v => v.num().unwrap_or(0.0),
+                };
+                let v = match n {
+                    "neg" => -a,
+                    "abs" => a.abs(),
+                    "sqrt" => a.max(0.0).sqrt(),
+                    "sin" => a.to_radians().sin(),
+                    "cos" => a.to_radians().cos(),
+                    "ln" => a.ln(),
+                    "log" => a.log10(),
+                    "cvi" | "truncate" => a.trunc(),
+                    "round" => (a + 0.5).floor(),
+                    "floor" => a.floor(),
+                    "ceiling" => a.ceil(),
+                    _ => a,
+                };
+                self.push(V::Num(if v.is_finite() { v } else { 0.0 }));
+            }
+            _ => return false,
+        }
+        true
+    }
+
+    fn try_logic_op(&mut self, n: &str) -> bool {
+        match n {
+            // Comparison and logic.
+            "eq" | "ne" => {
+                let b = self.pop();
+                let a = self.pop();
+                let eq = match (&a, &b) {
+                    (V::Num(x), V::Num(y)) => x == y,
+                    (V::Bool(x), V::Bool(y)) => x == y,
+                    (V::Null, V::Null) => true,
+                    (V::Array(x), V::Array(y)) => Rc::ptr_eq(x, y),
+                    (V::Dict(x), V::Dict(y)) => Rc::ptr_eq(x, y),
+                    (x, y) => !x.key().is_empty() && x.key() == y.key(),
+                };
+                self.push(V::Bool(eq == (n == "eq")));
+            }
+            "gt" | "ge" | "lt" | "le" => {
+                let b = self.popn();
+                let a = self.popn();
+                self.push(V::Bool(match n {
+                    "gt" => a > b,
+                    "ge" => a >= b,
+                    "lt" => a < b,
+                    _ => a <= b,
+                }));
+            }
+            "not" => match self.pop() {
+                V::Bool(b) => self.push(V::Bool(!b)),
+                v => self.push(V::Num(!(v.num().unwrap_or(0.0) as i64) as f64)),
+            },
+            "and" | "or" | "xor" => {
+                let b = self.pop();
+                let a = self.pop();
+                match (a, b) {
+                    (V::Bool(x), V::Bool(y)) => self.push(V::Bool(match n {
+                        "and" => x && y,
+                        "or" => x || y,
+                        _ => x ^ y,
+                    })),
+                    (x, y) => {
+                        let (x, y) = (x.num().unwrap_or(0.0) as i64, y.num().unwrap_or(0.0) as i64);
+                        self.push(V::Num(match n {
+                            "and" => x & y,
+                            "or" => x | y,
+                            _ => x ^ y,
+                        } as f64));
+                    }
+                }
+            }
+            "true" => self.push(V::Bool(true)),
+            "false" => self.push(V::Bool(false)),
+            "null" => self.push(V::Null),
+            _ => return false,
+        }
+        true
+    }
+
+    fn try_control_op(&mut self, n: &str, src: &mut Src) -> Result<bool, Flow> {
+        match n {
+            // Control.
+            "exec" => {
+                let v = self.pop();
+                self.exec_obj(v, src)?;
+            }
+            "if" => {
+                let p = self.pop();
+                if let V::Bool(true) = self.pop() {
+                    self.exec_obj(p, src)?;
+                }
+            }
+            "ifelse" => {
+                let f = self.pop();
+                let t = self.pop();
+                let c = matches!(self.pop(), V::Bool(true));
+                self.exec_obj(if c { t } else { f }, src)?;
+            }
+            // Each pass of a loop counts against the budget.
+            "repeat" => self.repeat_proc(src)?,
+            "for" => self.for_proc(src)?,
+            "loop" => self.loop_proc(src)?,
+            "forall" => self.forall_proc(src)?,
+            "exit" => return Err(Flow::Exit),
+            "stop" => return Err(Flow::Stop),
+            "stopped" => {
+                let p = self.pop();
+                let stopped = match self.exec_obj(p, src) {
+                    Err(Flow::Quit) => return Err(Flow::Quit),
+                    Err(_) => true,
+                    Ok(()) => false,
+                };
+                self.push(V::Bool(stopped));
+            }
+            "quit" => return Err(Flow::Quit),
+            "showpage" | "copypage" => {}
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn try_dictionary_op(&mut self, n: &str) -> bool {
+        match n {
+            // Dictionaries.
+            "def" => {
+                let v = self.pop();
+                let k = self.pop().key();
+                if let Some(d) = self.dicts.last() {
+                    d.borrow_mut().insert(k, v);
+                }
+            }
+            "store" => {
+                let v = self.pop();
+                let k = self.pop().key();
+                let d = self.dicts.iter().rev().find(|d| d.borrow().contains_key(&k)).or(self.dicts.last()).cloned();
+                if let Some(d) = d {
+                    d.borrow_mut().insert(k, v);
+                }
+            }
+            "load" => {
+                let k = self.pop().key();
+                let v = self.lookup(&k).unwrap_or(V::Op(k.into()));
+                self.push(v);
+            }
+            "undef" => {
+                let k = self.pop().key();
+                if let V::Dict(d) = self.pop() {
+                    d.borrow_mut().remove(&k);
+                }
+            }
+            "dict" => {
+                self.pop();
+                self.push(V::Dict(new_dict()));
+            }
+            "begin" => {
+                if let V::Dict(d) = self.pop()
+                    && self.dicts.len() < 64
+                {
+                    self.dicts.push(d);
+                }
+            }
+            "end" => {
+                if self.dicts.len() > 1 {
+                    self.dicts.pop();
+                }
+            }
+            "currentdict" => {
+                let d = self.dicts.last().cloned().unwrap_or_else(new_dict);
+                self.push(V::Dict(d));
+            }
+            "userdict" | "globaldict" | "systemdict" | "statusdict" | "errordict" | "$error" => {
+                let d = self.dicts[0].clone();
+                self.push(V::Dict(d));
+            }
+            "where" => {
+                let k = self.pop().key();
+                match self.dicts.iter().rev().find(|d| d.borrow().contains_key(&k)).cloned() {
+                    Some(d) => {
+                        self.push(V::Dict(d));
+                        self.push(V::Bool(true));
+                    }
+                    None => self.push(V::Bool(false)),
+                }
+            }
+            "known" => {
+                let k = self.pop().key();
+                let v = match self.pop() {
+                    V::Dict(d) => d.borrow().contains_key(&k),
+                    _ => false,
+                };
+                self.push(V::Bool(v));
+            }
+            "countdictstack" => self.push(V::Num(self.dicts.len() as f64)),
+            "cleardictstack" => self.dicts.truncate(1),
+            "findresource" | "findfont" | "findencoding" => {
+                let category = if n == "findresource" { self.pop().key() } else { String::new() };
+                let key = self.pop().key();
+                match (n, category.as_str()) {
+                    ("findfont", _) | (_, "Font") => {
+                        let f = self.find_font(&key);
+                        self.push(V::Dict(f));
+                    }
+                    ("findencoding", _) | (_, "Encoding") => self.push(encoding_array(&key)),
+                    _ => self.push(V::Dict(new_dict())),
+                }
+            }
+            "defineresource" => {
+                let category = self.pop().key();
+                let v = self.pop();
+                let key = self.pop().key();
+                if let (V::Dict(d), "Font") = (&v, category.as_str()) {
+                    self.font_dir.insert(key, d.clone());
+                }
+                self.push(v);
+            }
+            "resourcestatus" => {
+                self.pop();
+                self.pop();
+                self.push(V::Bool(false));
+            }
+            _ => return false,
+        }
+        true
+    }
+
+    fn try_collection_op(&mut self, n: &str) -> bool {
+        match n {
+            // Arrays and strings.
+            "array" => {
+                let k = self.popn().clamp(0.0, 1e6) as usize;
+                self.push(array(vec![V::Null; k]));
+            }
+            "string" => {
+                let k = self.popn().clamp(0.0, 1e7) as usize;
+                self.push(V::Str(Rc::new(RefCell::new(vec![0; k]))));
+            }
+            "length" => {
+                let l = match self.pop() {
+                    V::Str(s) => s.borrow().len(),
+                    V::Dict(d) => d.borrow().len(),
+                    V::Name(s) | V::Lit(s) => s.len(),
+                    v => v.items().map_or(0, |i| i.len()),
+                };
+                self.push(V::Num(l as f64));
+            }
+            "get" => {
+                let k = self.pop();
+                let v = match self.pop() {
+                    V::Dict(d) => d.borrow().get(&k.key()).cloned().unwrap_or(V::Null),
+                    V::Str(s) => V::Num(s.borrow().get(k.num().unwrap_or(0.0) as usize).copied().unwrap_or(0) as f64),
+                    a => a.items().and_then(|i| i.get(k.num().unwrap_or(0.0) as usize).cloned()).unwrap_or(V::Null),
+                };
+                self.push(v);
+            }
+            "put" => {
+                let v = self.pop();
+                let k = self.pop();
+                match self.pop() {
+                    V::Dict(d) => {
+                        d.borrow_mut().insert(k.key(), v);
+                    }
+                    V::Array(a) => {
+                        let i = k.num().unwrap_or(0.0) as usize;
+                        if let Some(slot) = a.borrow_mut().get_mut(i) {
+                            *slot = v;
+                        }
+                    }
+                    V::Str(s) => {
+                        let i = k.num().unwrap_or(0.0) as usize;
+                        if let Some(slot) = s.borrow_mut().get_mut(i) {
+                            *slot = v.num().unwrap_or(0.0) as u8;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            "getinterval" => {
+                let c = self.popn().max(0.0) as usize;
+                let i = self.popn().max(0.0) as usize;
+                match self.pop() {
+                    V::Str(s) => {
+                        let b = s.borrow();
+                        let part = b.get(i.min(b.len())..(i + c).min(b.len())).unwrap_or(&[]).to_vec();
+                        drop(b);
+                        self.push(V::Str(Rc::new(RefCell::new(part))));
+                    }
+                    a => {
+                        let items = a.items().unwrap_or_default();
+                        let part = items.get(i.min(items.len())..(i + c).min(items.len())).unwrap_or(&[]).to_vec();
+                        self.push(array(part));
+                    }
+                }
+            }
+            "putinterval" => {
+                self.pop();
+                self.pop();
+                self.pop();
+            }
+            "aload" => {
+                let a = self.pop();
+                for v in a.items().unwrap_or_default() {
+                    self.push(v);
+                }
+                self.push(a);
+            }
+            "astore" => {
+                let a = self.pop();
+                if let V::Array(arr) = &a {
+                    let k = arr.borrow().len().min(self.st.len());
+                    let items = self.st.split_off(self.st.len() - k);
+                    *arr.borrow_mut() = items;
+                }
+                self.push(a);
+            }
+            "cvx" => match self.pop() {
+                V::Array(a) => self.push(V::Proc(Rc::new(a.borrow().clone()))),
+                V::Lit(s) => self.push(V::Name(s)),
+                V::Str(s) => {
+                    // Executable string: tokenize it as a procedure.
+                    let bytes = s.borrow().clone();
+                    let mut sub = Src { d: &bytes, pos: 0 };
+                    let mut body = vec![];
+                    while let Some(t) = sub.token(0) {
+                        body.push(t);
+                    }
+                    self.push(V::Proc(Rc::new(body)));
+                }
+                v => self.push(v),
+            },
+            "cvlit" => match self.pop() {
+                V::Proc(p) => self.push(array(p.as_ref().clone())),
+                V::Name(s) => self.push(V::Lit(s)),
+                v => self.push(v),
+            },
+            "cvn" => {
+                let k = self.pop().key();
+                self.push(V::Lit(k.into()));
+            }
+            "cvs" => {
+                self.pop();
+                let k = self.pop().key();
+                self.push(V::Str(Rc::new(RefCell::new(k.into_bytes()))));
+            }
+            "xcheck" => {
+                let v = self.pop();
+                self.push(V::Bool(matches!(v, V::Proc(_) | V::Name(_) | V::Op(_))));
+            }
+            "type" => {
+                let t = match self.pop() {
+                    V::Num(_) => "realtype",
+                    V::Bool(_) => "booleantype",
+                    V::Name(_) | V::Lit(_) => "nametype",
+                    V::Op(_) => "operatortype",
+                    V::Str(_) => "stringtype",
+                    V::Proc(_) | V::Array(_) => "arraytype",
+                    V::Dict(_) => "dicttype",
+                    V::Mark => "marktype",
+                    V::Null => "nulltype",
+                    V::File => "filetype",
+                };
+                self.push(V::Name(t.into()));
+            }
+            "bind" | "readonly" | "executeonly" | "noaccess" => {}
+            _ => return false,
+        }
+        true
+    }
+
+    fn try_environment_op(&mut self, n: &str, src: &mut Src) -> Result<bool, Flow> {
+        match n {
+            "languagelevel" => self.push(V::Num(3.0)),
+            "version" | "product" => self.push(V::Str(Rc::new(RefCell::new(b"3010".to_vec())))),
+            "save" => {
+                self.spend(self.gs.path.elements().len())?;
+                self.saved.push(self.gs.clone());
+                self.gs.depth = self.b.depth();
+                self.push(V::Null);
+            }
+            "restore" => {
+                self.pop();
+                self.grestore();
+            }
+            "currentfile" => self.push(V::File),
+            "readstring" | "readhexstring" | "readline" => {
+                self.pop();
+                self.pop();
+                self.push(V::Str(Rc::new(RefCell::new(vec![]))));
+                self.push(V::Bool(false));
+            }
+            "flushfile" | "closefile" | "print" | "==" | "=" | "pstack" | "setpagedevice" | "setglobal" | "setpacking" | "setshared" | "setobjectformat"
+            | "setsmoothness" => {
+                if !matches!(n, "pstack") {
+                    self.pop();
+                }
+            }
+            "currentglobal" | "currentpacking" | "currentshared" => self.push(V::Bool(false)),
+            // Operators that return values must push them, or the rest of the program reads a
+            // shifted stack: Illustrator's EPS prolog queries the device this way and then drew
+            // nothing (#955). Values are a plain device's defaults (PostScript Language
+            // Reference, 3rd ed., chapter 8).
+            "currentflat" => self.push(V::Num(1.0)),
+            "currentscreen" => {
+                self.push(V::Num(60.0));
+                self.push(V::Num(45.0));
+                self.push(V::Proc(Rc::new(vec![])));
+            }
+            "currentblackgeneration" | "currentundercolorremoval" | "currenttransfer" => self.push(V::Proc(Rc::new(vec![]))),
+            "currentcolortransfer" => {
+                for _ in 0..4 {
+                    self.push(V::Proc(Rc::new(vec![])));
+                }
+            }
+            "currentpagedevice" | "currenthalftone" | "currentsystemparams" | "currentuserparams" | "currentdevparams" => {
+                if n == "currentdevparams" {
+                    self.pop();
+                }
+                self.push(V::Dict(new_dict()));
+            }
+            "setuserparams" | "setsystemparams" | "setcolortransfer" | "setblackgeneration" | "setundercolorremoval" => {
+                let k = if n == "setcolortransfer" { 4 } else { 1 };
+                for _ in 0..k {
+                    self.pop();
+                }
+            }
+            // `file status` → false; `string status` → false (no such file).
+            "status" => {
+                self.pop();
+                self.push(V::Bool(false));
+            }
+            "dictstack" => {
+                self.pop();
+                let ds: Vec<V> = self.dicts.iter().map(|d| V::Dict(d.clone())).collect();
+                self.push(array(ds));
+            }
+            "maxlength" => {
+                let k = match self.pop() {
+                    V::Dict(d) => d.borrow().len(),
+                    _ => 0,
+                };
+                self.push(V::Num(k.saturating_add(16) as f64));
+            }
+            "internaldict" => {
+                self.pop();
+                let d = self.dicts[0].clone();
+                self.push(V::Dict(d));
+            }
+            "undefineresource" => {
+                self.pop();
+                self.pop();
+            }
+            // `[ … /Name pdfmark`: a Distiller annotation; other interpreters discard it.
+            "pdfmark" => {
+                while let Some(v) = self.st.pop() {
+                    if matches!(v, V::Mark) {
+                        break;
+                    }
+                }
+            }
+            // `source [params] /Name filter`. A SubFileDecode of the current file with a count of
+            // 0 reads to its end-of-data string: skip that data (an embedded XMP packet, which
+            // otherwise ran as PostScript). Other filters read what their source reads.
+            "filter" => {
+                let name = self.pop().key();
+                let mut skipped = false;
+                let source = if name == "SubFileDecode" && !matches!(self.st.last(), Some(V::Dict(_))) {
+                    let eod = match self.pop() {
+                        V::Str(s) => s.borrow().clone(),
+                        _ => vec![],
+                    };
+                    let count = self.popn();
+                    let source = self.pop();
+                    if matches!(source, V::File) && count == 0.0 && !eod.is_empty() {
+                        src.pos = match find_from(src.d, &eod, src.pos) {
+                            Some(p) => p.saturating_add(eod.len()),
+                            None => src.d.len(),
+                        };
+                        skipped = true;
+                    }
+                    source
+                } else {
+                    if matches!(self.st.last(), Some(V::Dict(_))) {
+                        self.pop();
+                    }
+                    self.pop()
+                };
+                // Data already stepped over leaves nothing for `image` to skip.
+                self.push(if skipped { V::Null } else { source });
+            }
+            "vmstatus" => {
+                for _ in 0..3 {
+                    self.push(V::Num(0.0));
+                }
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn try_graphics_op(&mut self, n: &str) -> Result<bool, Flow> {
+        match n {
+            // Graphics state.
+            "gsave" => {
+                self.spend(self.gs.path.elements().len())?;
+                let mut g = self.gs.clone();
+                g.depth = self.b.depth();
+                self.saved.push(g);
+            }
+            "grestore" => self.grestore(),
+            "grestoreall" => {
+                while !self.saved.is_empty() {
+                    self.grestore();
+                }
+            }
+            "initgraphics" => {
+                self.gs.ctm = Affine::IDENTITY;
+                self.gs.lw = 1.0;
+                self.gs.color = [0.0; 3];
+            }
+            "setlinewidth" => self.gs.lw = self.popn(),
+            "currentlinewidth" => self.push(V::Num(self.gs.lw)),
+            "setlinecap" => self.gs.cap = [Cap::Butt, Cap::Round, Cap::Square][(self.popn().max(0.0) as usize).min(2)],
+            "setlinejoin" => self.gs.join = [Join::Miter, Join::Round, Join::Bevel][(self.popn().max(0.0) as usize).min(2)],
+            "setmiterlimit" => self.gs.miter = self.popn(),
+            "setdash" => {
+                let off = self.popn();
+                let a: Vec<f64> = self.pop().items().unwrap_or_default().iter().filter_map(V::num).collect();
+                self.gs.dash = (!a.is_empty() && a.iter().any(|v| *v > 0.0)).then_some((a, off));
+            }
+            "setflat" | "setstrokeadjust" | "setoverprint" | "setrenderingintent" | "setcolorrendering" | "sethalftone" | "settransfer" => {
+                self.pop();
+            }
+            // frequency angle proc
+            "setscreen" => {
+                for _ in 0..3 {
+                    self.pop();
+                }
+            }
+            "setgray" => {
+                let g = self.popn().clamp(0.0, 1.0);
+                self.gs.color = [g; 3];
+            }
+            "setrgbcolor" => {
+                let b = self.popn();
+                let g = self.popn();
+                let r = self.popn();
+                self.gs.color = [r, g, b].map(|v| v.clamp(0.0, 1.0));
+            }
+            "sethsbcolor" => {
+                let v = self.popn().clamp(0.0, 1.0);
+                let s = self.popn().clamp(0.0, 1.0);
+                let h = self.popn().rem_euclid(1.0) * 6.0;
+                let (i, f) = (h.floor() as i32, h.fract());
+                let (p, q, t) = (v * (1.0 - s), v * (1.0 - s * f), v * (1.0 - s * (1.0 - f)));
+                self.gs.color = match i {
+                    0 => [v, t, p],
+                    1 => [q, v, p],
+                    2 => [p, v, t],
+                    3 => [p, q, v],
+                    4 => [t, p, v],
+                    _ => [v, p, q],
+                };
+            }
+            "setcmykcolor" => {
+                let k = self.popn().clamp(0.0, 1.0);
+                let y = self.popn().clamp(0.0, 1.0);
+                let m = self.popn().clamp(0.0, 1.0);
+                let c = self.popn().clamp(0.0, 1.0);
+                self.gs.color = [(1.0 - c) * (1.0 - k), (1.0 - m) * (1.0 - k), (1.0 - y) * (1.0 - k)];
+            }
+            "setcolorspace" => {
+                self.pop();
+            }
+            "setcolor" => {
+                // Device colour by operand count (patterns are not drawn).
+                let k = self.st.iter().rev().take_while(|v| matches!(v, V::Num(_))).count().min(4);
+                let c: Vec<f64> = self.st.split_off(self.st.len() - k).iter().filter_map(V::num).collect();
+                self.gs.color = match c.len() {
+                    1 => [c[0]; 3],
+                    3 => [c[0], c[1], c[2]],
+                    4 => [(1.0 - c[0]) * (1.0 - c[3]), (1.0 - c[1]) * (1.0 - c[3]), (1.0 - c[2]) * (1.0 - c[3])],
+                    _ => self.gs.color,
+                };
+            }
+            "currentgray" => self.push(V::Num((self.gs.color[0] + self.gs.color[1] + self.gs.color[2]) / 3.0)),
+            "currentrgbcolor" => {
+                for c in self.gs.color {
+                    self.push(V::Num(c));
+                }
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn try_coordinate_op(&mut self, n: &str) -> bool {
+        match n {
+            // Coordinates.
+            "matrix" => self.push(matrix_val(Affine::IDENTITY)),
+            "identmatrix" | "defaultmatrix" => {
+                self.pop();
+                self.push(matrix_val(Affine::IDENTITY));
+            }
+            "currentmatrix" => {
+                self.pop();
+                self.push(matrix_val(self.gs.ctm));
+            }
+            "setmatrix" => {
+                let m = self.pop();
+                self.gs.ctm = matrix_of(&m).unwrap_or(Affine::IDENTITY);
+            }
+            "concat" => {
+                let m = self.pop();
+                if let Some(m) = matrix_of(&m) {
+                    self.gs.ctm *= m;
+                }
+            }
+            "concatmatrix" => {
+                self.pop();
+                let b = self.pop();
+                let a = self.pop();
+                let (a, b) = (matrix_of(&a).unwrap_or(Affine::IDENTITY), matrix_of(&b).unwrap_or(Affine::IDENTITY));
+                self.push(matrix_val(b * a));
+            }
+            "invertmatrix" => {
+                self.pop();
+                let a = self.pop();
+                self.push(matrix_val(matrix_of(&a).unwrap_or(Affine::IDENTITY).inverse()));
+            }
+            "translate" | "scale" => {
+                let top = self.pop();
+                let (m_out, y) = match top {
+                    V::Array(_) => (Some(top), self.popn()),
+                    v => (None, v.num().unwrap_or(0.0)),
+                };
+                let x = self.popn();
+                let t = if n == "translate" { Affine::translate((x, y)) } else { Affine::scale_non_uniform(x, y) };
+                match m_out {
+                    Some(_) => self.push(matrix_val(t)),
+                    None => self.gs.ctm *= t,
+                }
+            }
+            "rotate" => {
+                let top = self.pop();
+                match top {
+                    V::Array(_) => {
+                        let a = self.popn();
+                        self.push(matrix_val(Affine::rotate(a.to_radians())));
+                    }
+                    v => self.gs.ctm *= Affine::rotate(v.num().unwrap_or(0.0).to_radians()),
+                }
+            }
+            "transform" | "itransform" | "dtransform" | "idtransform" => {
+                let top = self.pop();
+                let (m, y) = match top {
+                    V::Array(_) | V::Proc(_) => (matrix_of(&top).unwrap_or(Affine::IDENTITY), self.popn()),
+                    v => (self.gs.ctm, v.num().unwrap_or(0.0)),
+                };
+                let x = self.popn();
+                let m = if n.starts_with('i') { m.inverse() } else { m };
+                let p = if n.contains('d') {
+                    let c = m.as_coeffs();
+                    Point::new(c[0] * x + c[2] * y, c[1] * x + c[3] * y)
+                } else {
+                    m * Point::new(x, y)
+                };
+                self.push(V::Num(p.x));
+                self.push(V::Num(p.y));
+            }
+            _ => return false,
+        }
+        true
+    }
+
+    fn try_path_op(&mut self, n: &str) -> Result<bool, Flow> {
+        match n {
+            // Paths.
+            "newpath" => {
+                self.gs.path = BezPath::new();
+                self.gs.cur = None;
+                self.gs.start = None;
+            }
+            "moveto" => {
+                let p = self.user_point();
+                self.move_to(p)?;
+            }
+            "rmoveto" => {
+                let d = self.user_point();
+                let c = self.current_user();
+                self.move_to(Point::new(c.x + d.x, c.y + d.y))?;
+            }
+            "lineto" => {
+                let p = self.user_point();
+                self.line_to(p)?;
+            }
+            "rlineto" => {
+                let d = self.user_point();
+                let c = self.current_user();
+                self.line_to(Point::new(c.x + d.x, c.y + d.y))?;
+            }
+            "curveto" | "rcurveto" => {
+                let p3 = self.user_point();
+                let p2 = self.user_point();
+                let p1 = self.user_point();
+                if n == "rcurveto" {
+                    let c = self.current_user();
+                    let o = |p: Point| Point::new(c.x + p.x, c.y + p.y);
+                    self.curve_to(o(p1), o(p2), o(p3))?;
+                } else {
+                    self.curve_to(p1, p2, p3)?;
+                }
+            }
+            "closepath" => {
+                if self.gs.cur.is_some() {
+                    self.room(1)?;
+                    self.gs.path.close_path();
+                    self.gs.cur = self.gs.start;
+                }
+            }
+            "arc" => self.arc(false)?,
+            "arcn" => self.arc(true)?,
+            "currentpoint" => {
+                let c = self.current_user();
+                self.push(V::Num(c.x));
+                self.push(V::Num(c.y));
+            }
+            "pathbbox" => {
+                self.spend(self.gs.path.elements().len())?;
+                let r = kurbo::Shape::bounding_box(&self.gs.path);
+                let inv = self.gs.ctm.inverse();
+                let (a, b) = (inv * Point::new(r.x0, r.y0), inv * Point::new(r.x1, r.y1));
+                for v in [a.x.min(b.x), a.y.min(b.y), a.x.max(b.x), a.y.max(b.y)] {
+                    self.push(V::Num(v));
+                }
+            }
+            "flattenpath" | "reversepath" | "strokepath" | "initclip" => {}
+            "clippath" => {
+                let p = self.page;
+                self.gs.path = kurbo::Shape::to_path(&kurbo::Rect::new(p[0], p[1], p[2], p[3]), 0.1);
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+
+    fn try_paint_op(&mut self, n: &str) -> Result<bool, Flow> {
+        match n {
+            // Painting.
+            "fill" => self.paint(Some(FillRule::NonZero), false),
+            "eofill" => self.paint(Some(FillRule::EvenOdd), false),
+            "stroke" => self.paint(None, true),
+            "clip" | "eoclip" => {
+                let rule = if n == "clip" { FillRule::NonZero } else { FillRule::EvenOdd };
+                self.spend(self.gs.path.elements().len())?;
+                let p = self.gs.path.clone();
+                if !p.elements().iter().all(|e| matches!(e, PathEl::MoveTo(_))) {
+                    self.b.clip(p, rule);
+                }
+            }
+            "rectfill" | "rectstroke" | "rectclip" => {
+                let paths = self.rect_path()?;
+                if n == "rectstroke" && matches!(self.st.last(), Some(V::Array(_))) {
+                    self.pop();
+                }
+                let mut all = BezPath::new();
+                for p in paths {
+                    all.extend(p);
+                }
+                match n {
+                    "rectclip" => self.b.clip(all, FillRule::NonZero),
+                    _ => {
+                        let saved = std::mem::replace(&mut self.gs.path, all);
+                        self.paint(if n == "rectfill" { Some(FillRule::NonZero) } else { None }, n == "rectstroke");
+                        self.gs.path = saved;
+                    }
+                }
+            }
+            "shfill" => {
+                self.pop();
+                self.b.skip("smooth shading (shfill)");
+            }
+            _ => return Ok(false),
+        }
+        Ok(true)
+    }
+}
diff --git a/crates/pdf/src/ps/eps.rs b/crates/pdf/src/ps/eps.rs
new file mode 100644
index 000000000..90d60cfbe
--- /dev/null
+++ b/crates/pdf/src/ps/eps.rs
@@ -0,0 +1,79 @@
+use super::{HashMap, Rc, is_white};
+
+/// The PostScript section of an EPS file (DOS EPS binary header handled) and its bounding box
+/// (`%%HiResBoundingBox` preferred).
+pub fn eps_parts(bytes: &[u8]) -> Option<(&[u8], [f64; 4])> {
+    let ps = if bytes.starts_with(&[0xC5, 0xD0, 0xD3, 0xC6]) && bytes.len() >= 12 {
+        let off = u32::from_le_bytes([bytes[4], bytes[5], bytes[6], bytes[7]]) as usize;
+        let len = u32::from_le_bytes([bytes[8], bytes[9], bytes[10], bytes[11]]) as usize;
+        bytes.get(off..off.checked_add(len)?.min(bytes.len()))?
+    } else {
+        bytes
+    };
+    let find_box = |key: &[u8]| -> Option<[f64; 4]> {
+        let mut from = 0;
+        while let Some(p) = ps[from..].windows(key.len()).position(|w| w == key) {
+            let s = from + p + key.len();
+            let e = ps[s..].iter().position(|c| matches!(c, b'\n' | b'\r')).map_or(ps.len(), |q| s + q);
+            let v: Vec<f64> = String::from_utf8_lossy(&ps[s..e]).split_whitespace().filter_map(|t| t.parse().ok()).collect();
+            if v.len() == 4 && v[2] > v[0] && v[3] > v[1] {
+                return Some([v[0], v[1], v[2], v[3]]);
+            }
+            from = s;
+        }
+        None
+    };
+    let bbox = find_box(b"%%HiResBoundingBox:").or_else(|| find_box(b"%%BoundingBox:"))?;
+    Some((ps, bbox))
+}
+
+pub(super) fn find_from(hay: &[u8], needle: &[u8], from: usize) -> Option<usize> {
+    hay.get(from..)?.windows(needle.len()).position(|w| w == needle).map(|p| p + from)
+}
+
+fn rfind_before(hay: &[u8], needle: &[u8], to: usize) -> Option<usize> {
+    hay.get(..to)?.windows(needle.len()).rposition(|w| w == needle)
+}
+
+/// The name after `key` (`/FontName /Name`).
+fn name_after(b: &[u8], key: &[u8]) -> Option<String> {
+    let p = find_from(b, key, 0)? + key.len();
+    let rest = &b[p..];
+    let s = rest.iter().position(|c| *c == b'/')? + 1;
+    let e = rest[s..].iter().position(|c| is_white(*c) || matches!(c, b'/' | b'[' | b'(' | b'{')).map_or(rest.len(), |q| s + q);
+    (e > s).then(|| String::from_utf8_lossy(&rest[s..e]).into_owned())
+}
+
+/// Embedded font programs of an EPS file: Type 1 fonts (`… /FontName /X … currentfile eexec
+/// … cleartomark`, hexadecimal or binary) and CFF font sets (`… <length> StartData <bytes>`).
+pub(super) fn embedded_fonts(ps: &[u8]) -> HashMap<String, (Rc<Vec<u8>>, bool)> {
+    let mut out = HashMap::new();
+    let mut from = 0;
+    while let Some(ee) = find_from(ps, b"eexec", from) {
+        from = ee + 5;
+        let start = [b"%!PS-AdobeFont".as_slice(), b"%!FontType1"]
+            .iter()
+            .filter_map(|h| rfind_before(ps, h, ee))
+            .max()
+            .or_else(|| rfind_before(ps, b"/FontName", ee).map(|p| p.saturating_sub(512)));
+        let Some(start) = start else { continue };
+        let end = find_from(ps, b"cleartomark", ee).map_or(ps.len(), |p| p + 11);
+        if let Some(name) = name_after(&ps[start..ee], b"/FontName") {
+            out.insert(name, (Rc::new(ps[start..end].to_vec()), false));
+        }
+        from = end;
+    }
+    let mut from = 0;
+    while let Some(sd) = find_from(ps, b"StartData", from) {
+        from = sd + 9;
+        let head = String::from_utf8_lossy(&ps[sd.saturating_sub(64)..sd]).into_owned();
+        let Some(len) = head.split_whitespace().last().and_then(|t| t.parse::<usize>().ok()) else { continue };
+        let s = sd + 10;
+        let Some(data) = ps.get(s..s.saturating_add(len)) else { continue };
+        if let Some(name) = crate::cff::font_name(data) {
+            out.insert(name, (Rc::new(data.to_vec()), true));
+        }
+        from = s + len;
+    }
+    out
+}
diff --git a/crates/pdf/src/ps/exec.rs b/crates/pdf/src/ps/exec.rs
new file mode 100644
index 000000000..27697527c
--- /dev/null
+++ b/crates/pdf/src/ps/exec.rs
@@ -0,0 +1,172 @@
+use super::eps::embedded_fonts;
+use super::scanner::Src;
+use super::value::{Flow, GState, V, new_dict};
+use super::{Affine, BezPath, Builder, Cap, HashMap, Interp, Join};
+
+/// The deepest procedure nesting run (deeper recursion stops the program).
+const MAX_CALL_DEPTH: usize = 256;
+
+impl Interp {
+    pub fn new(page: [f64; 4]) -> Interp {
+        Interp {
+            b: Builder::new(),
+            st: vec![],
+            dicts: vec![new_dict()],
+            gs: GState {
+                ctm: Affine::IDENTITY,
+                color: [0.0; 3],
+                lw: 1.0,
+                cap: Cap::Butt,
+                join: Join::Miter,
+                miter: 10.0,
+                dash: None,
+                path: BezPath::new(),
+                cur: None,
+                start: None,
+                depth: 1,
+                font: None,
+            },
+            saved: vec![],
+            budget: 8_000_000,
+            calls: 0,
+            font_dir: HashMap::new(),
+            embedded: HashMap::new(),
+            font_cache: HashMap::new(),
+            page,
+            unknown: vec![],
+        }
+    }
+
+    pub fn run(&mut self, data: &[u8]) {
+        self.embedded = embedded_fonts(data);
+        let mut src = Src { d: data, pos: 0 };
+        while let Some(t) = src.token(0) {
+            if let Err(Flow::Quit) = self.exec_token(t, &mut src) {
+                break;
+            }
+        }
+    }
+
+    pub(super) fn pop(&mut self) -> V {
+        self.st.pop().unwrap_or(V::Null)
+    }
+
+    pub(super) fn popn(&mut self) -> f64 {
+        self.pop().num().unwrap_or(0.0)
+    }
+
+    pub(super) fn push(&mut self, v: V) {
+        if self.st.len() < 100_000 {
+            self.st.push(v);
+        }
+    }
+
+    pub(super) fn lookup(&self, k: &str) -> Option<V> {
+        self.dicts.iter().rev().find_map(|d| d.borrow().get(k).cloned())
+    }
+
+    /// A token read from the file: procedures are pushed, names executed.
+    fn exec_token(&mut self, t: V, src: &mut Src) -> Result<(), Flow> {
+        match t {
+            V::Name(n) => self.exec_name(&n, src),
+            other => {
+                self.push(other);
+                Ok(())
+            }
+        }
+    }
+
+    /// Execute a value as an object (procedures run).
+    pub(super) fn exec_obj(&mut self, v: V, src: &mut Src) -> Result<(), Flow> {
+        match v {
+            V::Proc(p) => {
+                if self.calls >= MAX_CALL_DEPTH {
+                    self.b.skip("PostScript (recursion limit)");
+                    return Err(Flow::Quit);
+                }
+                self.calls += 1;
+                let mut r = Ok(());
+                for x in p.iter() {
+                    match x {
+                        V::Name(n) => {
+                            r = self.exec_name(n, src);
+                            if r.is_err() {
+                                break;
+                            }
+                        }
+                        V::Op(op) => {
+                            r = self.spend(1).and_then(|()| self.builtin(op, src));
+                            if r.is_err() {
+                                break;
+                            }
+                        }
+                        // Other items count against the budget as names do.
+                        other => {
+                            r = self.spend(1);
+                            if r.is_err() {
+                                break;
+                            }
+                            self.push(other.clone());
+                        }
+                    }
+                }
+                self.calls -= 1;
+                r
+            }
+            // An executable name can run another (`exec` of `/exec cvx`), so names count too.
+            V::Name(n) => {
+                if self.calls >= MAX_CALL_DEPTH {
+                    self.b.skip("PostScript (recursion limit)");
+                    return Err(Flow::Quit);
+                }
+                self.calls += 1;
+                let r = self.exec_name(&n, src);
+                self.calls -= 1;
+                r
+            }
+            V::Op(op) => {
+                self.spend(1)?;
+                self.builtin(&op, src)
+            }
+            other => {
+                self.push(other);
+                Ok(())
+            }
+        }
+    }
+
+    fn exec_name(&mut self, n: &str, src: &mut Src) -> Result<(), Flow> {
+        self.spend(1)?;
+        if let Some(v) = self.lookup(n) {
+            return match v {
+                V::Proc(_) => self.exec_obj(v, src),
+                // An operator stored under another name (`/mo /moveto load def`, as Illustrator's
+                // EPS prolog does for every path operator) runs that operator. It pushed the
+                // operator's name instead, so such files drew nothing (#955).
+                V::Op(op) => self.builtin(&op, src),
+                // An executable name (`/y /x cvx def`) runs what that name is bound to.
+                V::Name(_) => self.exec_obj(v, src),
+                other => {
+                    self.push(other);
+                    Ok(())
+                }
+            };
+        }
+        self.builtin(n, src)
+    }
+
+    /// Count `n` operations against the budget, and stop the program when fewer are left. An
+    /// operator that makes, reads or copies path elements counts each one as an operation.
+    pub(super) fn spend(&mut self, n: usize) -> Result<(), Flow> {
+        match self.budget.checked_sub(n) {
+            Some(left) => {
+                self.budget = left;
+                Ok(())
+            }
+            None => {
+                self.b.skip("PostScript (operation limit)");
+                Err(Flow::Quit)
+            }
+        }
+    }
+}
diff --git a/crates/pdf/src/ps/paths.rs b/crates/pdf/src/ps/paths.rs
new file mode 100644
index 000000000..b1fe07092
--- /dev/null
+++ b/crates/pdf/src/ps/paths.rs
@@ -0,0 +1,187 @@
+use super::value::{Flow, V};
+use super::{Affine, BezPath, FillRule, Interp, MAX_PATH, Paint, PathEl, Point, Stroke};
+
+/// The angle from `a` counterclockwise to `b` (degrees, 0 to 360), worked out from what is left
+/// of each after whole turns.
+fn ccw_turn(a: f64, b: f64) -> f64 {
+    (b % 360.0 - a % 360.0).rem_euclid(360.0)
+}
+
+/// The most turns one `arc` or `arcn` draws.
+const MAX_ARC_TURNS: f64 = 1024.0;
+
+impl Interp {
+    fn device_scale(&self) -> f64 {
+        self.gs.ctm.determinant().abs().sqrt()
+    }
+
+    pub(super) fn user_point(&mut self) -> Point {
+        let y = self.popn();
+        let x = self.popn();
+        Point::new(x, y)
+    }
+
+    /// Stop the program when a path of `len` elements would be longer than [`MAX_PATH`].
+    fn path_fits(&mut self, len: usize) -> Result<(), Flow> {
+        if len <= MAX_PATH {
+            return Ok(());
+        }
+        self.b.skip("PostScript (path limit)");
+        Err(Flow::Quit)
+    }
+
+    /// [`Self::path_fits`] for the current path with `n` more elements.
+    pub(super) fn room(&mut self, n: usize) -> Result<(), Flow> {
+        self.path_fits(self.gs.path.elements().len().saturating_add(n))
+    }
+
+    pub(super) fn move_to(&mut self, p: Point) -> Result<(), Flow> {
+        // A moveto right after a moveto replaces it (PostScript Language Reference §8.2, `moveto`).
+        if matches!(self.gs.path.elements().last(), Some(PathEl::MoveTo(_))) {
+            self.gs.path.pop();
+        }
+        self.room(1)?;
+        let q = self.gs.ctm * p;
+        self.gs.path.move_to(q);
+        self.gs.cur = Some(q);
+        self.gs.start = Some(q);
+        Ok(())
+    }
+
+    pub(super) fn line_to(&mut self, p: Point) -> Result<(), Flow> {
+        self.room(1 + usize::from(self.gs.cur.is_none()))?;
+        let q = self.gs.ctm * p;
+        if self.gs.cur.is_none() {
+            self.gs.path.move_to(q);
+            self.gs.start = Some(q);
+        }
+        self.gs.path.line_to(q);
+        self.gs.cur = Some(q);
+        Ok(())
+    }
+
+    pub(super) fn curve_to(&mut self, a: Point, b: Point, c: Point) -> Result<(), Flow> {
+        self.room(1 + usize::from(self.gs.cur.is_none()))?;
+        let m = self.gs.ctm;
+        if self.gs.cur.is_none() {
+            self.gs.path.move_to(m * a);
+        }
+        self.gs.path.curve_to(m * a, m * b, m * c);
+        self.gs.cur = Some(m * c);
+        Ok(())
+    }
+
+    pub(super) fn current_user(&self) -> Point {
+        self.gs.ctm.inverse() * self.gs.cur.unwrap_or_default()
+    }
+
+    pub(super) fn arc(&mut self, neg: bool) -> Result<(), Flow> {
+        let a2 = self.popn();
+        let a1 = self.popn();
+        let r = self.popn();
+        let c = self.user_point();
+        // `arc` raises `a2` by multiples of 360 until it is at least `a1`, and `arcn` lowers it
+        // until it is at most `a1` (PostScript Language Reference §8.2, `arc` and `arcn`). Those
+        // sweeps, and the first endpoint, are worked out from what is left of each angle after
+        // whole turns.
+        let sweep = if !neg && a2 < a1 {
+            ccw_turn(a1, a2)
+        } else if neg && a2 > a1 {
+            -ccw_turn(a2, a1)
+        } else {
+            a2 - a1
+        };
+        // A sweep of more than `MAX_ARC_TURNS` turns is shortened by whole pairs of turns to
+        // between `MAX_ARC_TURNS - 2` and `MAX_ARC_TURNS` turns, with a skip note. The arc still
+        // ends at `a2`, and an even-odd fill or clip of it covers the same area as the full sweep.
+        let max = MAX_ARC_TURNS * 360.0;
+        let sweep = if sweep.abs() > max {
+            self.b.skip("arc (too many turns)");
+            let s = sweep.signum();
+            s * (max - 720.0 + (s * (a2 % 720.0 - a1 % 720.0)).rem_euclid(720.0))
+        } else {
+            sweep
+        };
+        let (a1, sweep) = ((a1 % 360.0).to_radians(), sweep.to_radians());
+        let start = Point::new(c.x + r * a1.cos(), c.y + r * a1.sin());
+        if self.gs.cur.is_some() {
+            self.line_to(start)?;
+        } else {
+            self.move_to(start)?;
+        }
+        let arc = kurbo::Arc::new(c, (r, r), a1, sweep, 0.0);
+        let m = self.gs.ctm;
+        // kurbo divides an arc into more curves the larger the radius (about 3.7 × 10^49 for a
+        // quarter turn at a radius of 10^300, more than a usize can count), so each one counts
+        // against the budget and the path limit.
+        let mut curves = arc.append_iter(0.1);
+        while let Some(PathEl::CurveTo(p1, p2, p3)) = curves.next() {
+            self.room(1)?;
+            self.spend(1)?;
+            self.gs.path.curve_to(m * p1, m * p2, m * p3);
+            self.gs.cur = Some(m * p3);
+        }
+        Ok(())
+    }
+
+    pub(super) fn paint(&mut self, fill: Option<FillRule>, stroke: bool) {
+        let path = std::mem::take(&mut self.gs.path);
+        self.gs.cur = None;
+        self.gs.start = None;
+        let s = self.device_scale();
+        let st = stroke.then(|| Stroke {
+            paint: Paint::Color(self.gs.color),
+            opacity: 1.0,
+            width: if self.gs.lw <= 0.0 { 1.0 } else { self.gs.lw * s },
+            cap: self.gs.cap,
+            join: self.gs.join,
+            miter: self.gs.miter.max(1.0),
+            dash: self.gs.dash.as_ref().map(|(a, o)| (a.iter().map(|v| v * s).collect(), o * s)),
+        });
+        self.b.fill_stroke(path, Affine::IDENTITY, fill.map(|r| (Paint::Color(self.gs.color), 1.0, r)), st);
+    }
+
+    pub(super) fn rect_path(&mut self) -> Result<Vec<BezPath>, Flow> {
+        // x y w h, or an array / string of numbers.
+        let top = self.pop();
+        let nums: Vec<f64> = match &top {
+            V::Array(_) | V::Proc(_) => {
+                let items = top.items().unwrap_or_default();
+                // An array's rectangles count against the budget, five path elements each.
+                self.spend(items.len() / 4 * 5)?;
+                items.iter().filter_map(V::num).collect()
+            }
+            V::Num(h) => {
+                let w = self.popn();
+                let y = self.popn();
+                let x = self.popn();
+                vec![x, y, w, *h]
+            }
+            _ => vec![],
+        };
+        self.path_fits(nums.len() / 4 * 5)?;
+        let m = self.gs.ctm;
+        Ok(nums
+            .as_chunks::<4>()
+            .0
+            .iter()
+            .map(|r| {
+                let mut p = BezPath::new();
+                p.move_to(m * Point::new(r[0], r[1]));
+                p.line_to(m * Point::new(r[0] + r[2], r[1]));
+                p.line_to(m * Point::new(r[0] + r[2], r[1] + r[3]));
+                p.line_to(m * Point::new(r[0], r[1] + r[3]));
+                p.close_path();
+                p
+            })
+            .collect())
+    }
+
+    pub(super) fn grestore(&mut self) {
+        if let Some(g) = self.saved.pop() {
+            let d = g.depth;
+            self.gs = g;
+            self.b.close_to(d);
+        }
+    }
+}
diff --git a/crates/pdf/src/ps/scanner.rs b/crates/pdf/src/ps/scanner.rs
new file mode 100644
index 000000000..59933e214
--- /dev/null
+++ b/crates/pdf/src/ps/scanner.rs
@@ -0,0 +1,223 @@
+use super::value::V;
+use super::{Rc, RefCell, ascii85, is_white, parse_num};
+
+/// Source tokenizer (the data source for `currentfile`).
+pub(super) struct Src<'a> {
+    pub(super) d: &'a [u8],
+    pub(crate) pos: usize,
+}
+
+impl Src<'_> {
+    fn skip_ws(&mut self) {
+        while self.pos < self.d.len() {
+            let c = self.d[self.pos];
+            if is_white(c) {
+                self.pos += 1;
+            } else if c == b'%' {
+                let s = self.pos;
+                while self.pos < self.d.len() && !matches!(self.d[self.pos], b'\n' | b'\r') {
+                    self.pos += 1;
+                }
+                // DSC: skip embedded binary / data sections.
+                let line = &self.d[s..self.pos];
+                if line.starts_with(b"%%BeginData:") || line.starts_with(b"%%BeginBinary:") || line.starts_with(b"%%BeginPreview") {
+                    let end: &[u8] = if line.starts_with(b"%%BeginData:") {
+                        b"%%EndData"
+                    } else if line.starts_with(b"%%BeginBinary:") {
+                        b"%%EndBinary"
+                    } else {
+                        b"%%EndPreview"
+                    };
+                    match self.d[self.pos..].windows(end.len()).position(|w| w == end) {
+                        Some(p) => self.pos += p,
+                        None => self.pos = self.d.len(),
+                    }
+                }
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn word(&mut self) -> &[u8] {
+        let s = self.pos;
+        while self.pos < self.d.len() {
+            let c = self.d[self.pos];
+            if is_white(c) || matches!(c, b'(' | b')' | b'<' | b'>' | b'[' | b']' | b'{' | b'}' | b'/' | b'%') {
+                break;
+            }
+            self.pos += 1;
+        }
+        &self.d[s..self.pos]
+    }
+
+    /// The next token; `{ … }` comes back as a whole procedure.
+    pub(super) fn token(&mut self, depth: usize) -> Option<V> {
+        self.skip_ws();
+        let c = *self.d.get(self.pos)?;
+        Some(match c {
+            b'{' => {
+                self.pos += 1;
+                let mut body = vec![];
+                loop {
+                    self.skip_ws();
+                    match self.d.get(self.pos) {
+                        None => break,
+                        Some(b'}') => {
+                            self.pos += 1;
+                            break;
+                        }
+                        _ => {
+                            if depth > 100 {
+                                return None;
+                            }
+                            match self.token(depth + 1) {
+                                Some(t) => body.push(t),
+                                None => break,
+                            }
+                        }
+                    }
+                }
+                V::Proc(Rc::new(body))
+            }
+            b'}' => {
+                self.pos += 1;
+                V::Null
+            }
+            b'/' => {
+                self.pos += 1;
+                let imm = self.d.get(self.pos) == Some(&b'/');
+                if imm {
+                    self.pos += 1;
+                }
+                let w = String::from_utf8_lossy(self.word()).into_owned();
+                // `//name` (immediately evaluated) is treated like a plain name.
+                if imm { V::Name(w.into()) } else { V::Lit(w.into()) }
+            }
+            b'(' => {
+                self.pos += 1;
+                let mut out = vec![];
+                let mut depth = 1;
+                while self.pos < self.d.len() {
+                    let c = self.d[self.pos];
+                    self.pos += 1;
+                    match c {
+                        b'\\' => {
+                            let e = self.d.get(self.pos).copied().unwrap_or(b'\\');
+                            self.pos += 1;
+                            match e {
+                                b'n' => out.push(b'\n'),
+                                b'r' => out.push(b'\r'),
+                                b't' => out.push(b'\t'),
+                                b'0'..=b'7' => {
+                                    let mut v = (e - b'0') as u32;
+                                    for _ in 0..2 {
+                                        match self.d.get(self.pos) {
+                                            Some(d @ b'0'..=b'7') => {
+                                                v = v * 8 + (d - b'0') as u32;
+                                                self.pos += 1;
+                                            }
+                                            _ => break,
+                                        }
+                                    }
+                                    out.push(v as u8);
+                                }
+                                b'\n' | b'\r' => {}
+                                o => out.push(o),
+                            }
+                        }
+                        b'(' => {
+                            depth += 1;
+                            out.push(c);
+                        }
+                        b')' => {
+                            depth -= 1;
+                            if depth == 0 {
+                                break;
+                            }
+                            out.push(c);
+                        }
+                        _ => out.push(c),
+                    }
+                }
+                V::Str(Rc::new(RefCell::new(out)))
+            }
+            b'<' if self.d.get(self.pos + 1) == Some(&b'<') => {
+                self.pos += 2;
+                V::Name("<<".into())
+            }
+            b'>' if self.d.get(self.pos + 1) == Some(&b'>') => {
+                self.pos += 2;
+                V::Name(">>".into())
+            }
+            b'<' if self.d.get(self.pos + 1) == Some(&b'~') => {
+                let s = self.pos;
+                while self.pos + 1 < self.d.len() && !(self.d[self.pos] == b'~' && self.d[self.pos + 1] == b'>') {
+                    self.pos += 1;
+                }
+                self.pos = (self.pos + 2).min(self.d.len());
+                V::Str(Rc::new(RefCell::new(ascii85(&self.d[s..self.pos]))))
+            }
+            b'<' => {
+                self.pos += 1;
+                let mut hex = vec![];
+                while self.pos < self.d.len() && self.d[self.pos] != b'>' {
+                    if self.d[self.pos].is_ascii_hexdigit() {
+                        hex.push(self.d[self.pos]);
+                    }
+                    self.pos += 1;
+                }
+                self.pos += 1;
+                if hex.len() % 2 == 1 {
+                    hex.push(b'0');
+                }
+                let h = |c: u8| (c as char).to_digit(16).unwrap_or(0) as u8;
+                V::Str(Rc::new(RefCell::new(hex.chunks(2).map(|p| (h(p[0]) << 4) | h(p[1])).collect())))
+            }
+            b'[' | b']' => {
+                self.pos += 1;
+                V::Name(if c == b'[' { "[" } else { "]" }.into())
+            }
+            b')' | b'>' => {
+                self.pos += 1;
+                V::Null
+            }
+            _ => {
+                let w = self.word();
+                if w.is_empty() {
+                    self.pos += 1;
+                    return Some(V::Null);
+                }
+                match parse_num(w) {
+                    Some(n) => V::Num(n),
+                    None => {
+                        // Radix numbers (16#FF).
+                        let s = String::from_utf8_lossy(w).into_owned();
+                        match s.split_once('#').and_then(|(r, v)| i64::from_str_radix(v, r.parse::<u32>().ok().filter(|r| (2..=36).contains(r))?).ok()) {
+                            Some(n) => V::Num(n as f64),
+                            None => V::Name(s.into()),
+                        }
+                    }
+                }
+            }
+        })
+    }
+
+    /// Step over inline image data that follows an `image` operator reading `currentfile`.
+    pub(super) fn skip_image_data(&mut self) {
+        self.skip_ws();
+        if self.d[self.pos..].starts_with(b"<~") || self.d.get(self.pos).is_some_and(|c| (b'!'..=b'u').contains(c) && !c.is_ascii_hexdigit()) {
+            match self.d[self.pos..].windows(2).position(|w| w == b"~>") {
+                Some(p) => self.pos += p + 2,
+                None => self.pos = self.d.len(),
+            }
+            return;
+        }
+        while self.pos < self.d.len() && (self.d[self.pos].is_ascii_hexdigit() || is_white(self.d[self.pos])) {
+            self.pos += 1;
+        }
+        if self.d.get(self.pos) == Some(&b'>') {
+            self.pos += 1;
+        }
+    }
+}
diff --git a/crates/pdf/src/ps/text.rs b/crates/pdf/src/ps/text.rs
new file mode 100644
index 000000000..b138965bb
--- /dev/null
+++ b/crates/pdf/src/ps/text.rs
@@ -0,0 +1,322 @@
+use super::scanner::Src;
+use super::value::{DictRef, Flow, V, array, matrix_of, matrix_val, new_dict};
+use super::{Affine, BezPath, FillRule, Font, HashMap, Interp, Paint, Point, Rc, RefCell};
+
+// ------------------------------------------------------------------ text
+
+/// An encoding array of glyph names (`StandardEncoding`; `ISOLatin1Encoding` and others are
+/// approximated by WinAnsi, which agrees with ISO Latin-1 on the printable codes).
+pub(super) fn encoding_array(name: &str) -> V {
+    let base = if name == "StandardEncoding" { crate::encoding::Base::Standard } else { crate::encoding::Base::WinAnsi };
+    array((0..256).map(|c| V::Lit(base.name(c as u8).unwrap_or_else(|| ".notdef".into()).into())).collect())
+}
+
+fn dict_matrix(d: &DictRef, key: &str) -> Affine {
+    d.borrow().get(key).and_then(matrix_of).unwrap_or(Affine::IDENTITY)
+}
+
+/// A copy of a font dictionary with `m` applied after its matrix (`scalefont`, `makefont`).
+fn transformed(font: &DictRef, m: Affine) -> DictRef {
+    let copy: HashMap<String, V> = font.borrow().clone();
+    let d = Rc::new(RefCell::new(copy));
+    let old = dict_matrix(&d, "__m");
+    d.borrow_mut().insert("__m".into(), matrix_val(m * old));
+    d
+}
+
+impl Interp {
+    /// A font dictionary by name: one `definefont` made, else a new dictionary for an
+    /// embedded program or a bundled stand-in.
+    pub(super) fn find_font(&mut self, key: &str) -> DictRef {
+        if let Some(d) = self.font_dir.get(key) {
+            return d.clone();
+        }
+        let d = new_dict();
+        {
+            let mut m = d.borrow_mut();
+            m.insert("FontName".into(), V::Lit(key.into()));
+            m.insert("FontType".into(), V::Num(1.0));
+            m.insert("FontMatrix".into(), matrix_val(Affine::scale(0.001)));
+            m.insert("FID".into(), V::Null);
+            m.insert("__base".into(), V::Lit(key.into()));
+            m.insert("__m".into(), matrix_val(Affine::IDENTITY));
+        }
+        self.font_dir.insert(key.to_string(), d.clone());
+        d
+    }
+
+    /// The drawable font of a font dictionary (its base program and encoding) and the matrix
+    /// from text space (font size 1) to user space.
+    fn font_of(&mut self, d: &DictRef) -> Option<(Rc<Font>, Affine)> {
+        if matches!(d.borrow().get("FontType"), Some(V::Num(t)) if *t == 3.0) {
+            // Type 3 fonts (glyph procedures) are not run.
+            self.b.skip("EPS Type 3 font");
+            return None;
+        }
+        let (base, names) = {
+            let m = d.borrow();
+            let base = m.get("__base").or_else(|| m.get("FontName")).map(V::key)?;
+            let names: Option<Vec<Option<String>>> = m.get("Encoding").and_then(V::items).map(|a| {
+                a.iter()
+                    .map(|v| match v {
+                        V::Lit(n) | V::Name(n) if &**n != ".notdef" => Some(n.to_string()),
+                        _ => None,
+                    })
+                    .collect()
+            });
+            (base, names)
+        };
+        let key = match &names {
+            Some(n) => format!("{base}\u{0}{}", n.iter().map(|x| x.as_deref().unwrap_or("")).collect::<Vec<_>>().join(" ")),
+            None => base.clone(),
+        };
+        let font = match self.font_cache.get(&key) {
+            Some(f) => f.clone(),
+            None => {
+                // Not embedded: a bundled stand-in, as for PDF.
+                let prog = self.embedded.get(&base).cloned();
+                let f = Rc::new(Font::standalone(&base, prog.as_ref().map(|(d, cff)| (d.as_slice(), *cff)), names));
+                self.font_cache.insert(key, f.clone());
+                f
+            }
+        };
+        Some((font, dict_matrix(d, "__m")))
+    }
+
+    /// A string's glyph outlines (device space) from the current point, with an extra
+    /// displacement `extra(index, code)` (user space) after each glyph; moves the current
+    /// point.
+    fn text_path(&mut self, bytes: &[u8], mut extra: impl FnMut(usize, u32) -> (f64, f64)) -> Result<Option<(BezPath, String)>, Flow> {
+        let Some(d) = self.gs.font.clone() else { return Ok(None) };
+        let Some((font, m)) = self.font_of(&d) else { return Ok(None) };
+        let mut p = self.current_user();
+        let mut path = BezPath::new();
+        let mut text = String::new();
+        let ctm = self.gs.ctm;
+        for (i, &code) in bytes.iter().enumerate() {
+            let code = code as u32;
+            if let Some(g) = font.glyph(code) {
+                path.extend(ctm * Affine::translate(p.to_vec2()) * m * (*g).clone());
+            }
+            text.push_str(&font.unicode(code));
+            let adv = m * Point::new(font.width(code), 0.0) - m * Point::ZERO;
+            let (ex, ey) = extra(i, code);
+            p += adv + kurbo::Vec2::new(ex, ey);
+        }
+        self.move_to(p)?;
+        Ok(Some((path, text)))
+    }
+
+    fn fill_text(&mut self, path: BezPath, text: &str) {
+        let label: String = text.chars().filter(|c| !c.is_control()).take(40).collect();
+        let name = if label.trim().is_empty() { "Text".to_string() } else { format!("Text: {}", label.trim()) };
+        self.b.fill_stroke_named(&name, path, Affine::IDENTITY, Some((Paint::Color(self.gs.color), 1.0, FillRule::NonZero)), None);
+    }
+
+    fn pop_string(&mut self) -> Vec<u8> {
+        match self.pop() {
+            V::Str(s) => s.borrow().clone(),
+            _ => vec![],
+        }
+    }
+
+    fn show_with(&mut self, s: &[u8], extra: impl FnMut(usize, u32) -> (f64, f64)) -> Result<(), Flow> {
+        match self.text_path(s, extra)? {
+            Some((path, text)) => self.fill_text(path, &text),
+            None => self.b.skip("text (no font)"),
+        }
+        Ok(())
+    }
+
+    /// Text and font operators (PostScript Language Reference §5.1, §8.2).
+    pub(super) fn text_op(&mut self, n: &str, src: &mut Src) -> Result<(), Flow> {
+        match n {
+            "scalefont" | "makefont" => {
+                let m = if n == "scalefont" {
+                    Affine::scale(self.popn())
+                } else {
+                    let v = self.pop();
+                    matrix_of(&v).unwrap_or(Affine::IDENTITY)
+                };
+                let font = match self.pop() {
+                    V::Dict(d) => d,
+                    _ => self.find_font("Helvetica"),
+                };
+                self.push(V::Dict(transformed(&font, m)));
+            }
+            "selectfont" => {
+                let size = self.pop();
+                let key = self.pop().key();
+                let font = self.find_font(&key);
+                let m = match &size {
+                    V::Num(s) => Affine::scale(*s),
+                    other => matrix_of(other).unwrap_or(Affine::IDENTITY),
+                };
+                self.gs.font = Some(transformed(&font, m));
+            }
+            "setfont" => {
+                if let V::Dict(d) = self.pop() {
+                    self.gs.font = Some(d);
+                }
+            }
+            "currentfont" | "rootfont" => {
+                let d = self.gs.font.clone().unwrap_or_else(new_dict);
+                self.push(V::Dict(d));
+            }
+            "definefont" => {
+                let v = self.pop();
+                let key = self.pop().key();
+                if let V::Dict(d) = &v {
+                    if !d.borrow().contains_key("__base") {
+                        // A font the file defines itself: its embedded program, by name.
+                        d.borrow_mut().insert("__base".into(), V::Lit(key.as_str().into()));
+                        d.borrow_mut().insert("__m".into(), matrix_val(Affine::IDENTITY));
+                    }
+                    self.font_dir.insert(key, d.clone());
+                }
+                self.push(v);
+            }
+            "undefinefont" => {
+                let key = self.pop().key();
+                self.font_dir.remove(&key);
+            }
+            "StandardEncoding" | "ISOLatin1Encoding" => self.push(encoding_array(n)),
+            "show" => {
+                let s = self.pop_string();
+                self.show_with(&s, |_, _| (0.0, 0.0))?;
+            }
+            "ashow" => {
+                let s = self.pop_string();
+                let ay = self.popn();
+                let ax = self.popn();
+                self.show_with(&s, |_, _| (ax, ay))?;
+            }
+            "widthshow" => {
+                let s = self.pop_string();
+                let ch = self.popn() as u32;
+                let cy = self.popn();
+                let cx = self.popn();
+                self.show_with(&s, |_, c| if c == ch { (cx, cy) } else { (0.0, 0.0) })?;
+            }
+            "awidthshow" => {
+                let s = self.pop_string();
+                let ay = self.popn();
+                let ax = self.popn();
+                let ch = self.popn() as u32;
+                let cy = self.popn();
+                let cx = self.popn();
+                self.show_with(&s, |_, c| if c == ch { (cx + ax, cy + ay) } else { (ax, ay) })?;
+            }
+            "kshow" | "cshow" => {
+                // The procedure between characters is not run.
+                let s = self.pop_string();
+                self.pop();
+                self.show_with(&s, |_, _| (0.0, 0.0))?;
+            }
+            "xshow" | "yshow" | "xyshow" => {
+                let disp: Vec<f64> = self.pop().items().unwrap_or_default().iter().filter_map(V::num).collect();
+                let s = self.pop_string();
+                self.explicit_show(&s, &disp, n)?;
+            }
+            "glyphshow" => {
+                let name = self.pop().key();
+                let Some(d) = self.gs.font.clone() else { return Ok(()) };
+                // Drawn through a one-glyph encoding.
+                let mut e: Vec<V> = (0..256).map(|_| V::Lit(".notdef".into())).collect();
+                e[65] = V::Lit(name.as_str().into());
+                let tmp = transformed(&d, Affine::IDENTITY);
+                tmp.borrow_mut().insert("Encoding".into(), array(e));
+                self.gs.font = Some(tmp);
+                self.show_with(b"A", |_, _| (0.0, 0.0))?;
+                self.gs.font = Some(d);
+            }
+            "charpath" => {
+                self.pop();
+                let s = self.pop_string();
+                let saved = std::mem::take(&mut self.gs.path);
+                let start = self.gs.start;
+                match self.text_path(&s, |_, _| (0.0, 0.0))? {
+                    Some((glyphs, _)) => {
+                        // The outlines join the path: each element counts against the budget and
+                        // the path limit.
+                        self.gs.path = saved;
+                        self.room(glyphs.elements().len() + 1)?;
+                        self.spend(glyphs.elements().len())?;
+                        self.gs.path.extend(glyphs);
+                        if let Some(c) = self.gs.cur {
+                            self.gs.path.move_to(c);
+                        }
+                        self.gs.start = start;
+                    }
+                    None => self.gs.path = saved,
+                }
+            }
+            "stringwidth" => {
+                let s = self.pop_string();
+                let (mut w, mut h) = (0.0, 0.0);
+                if let Some(d) = self.gs.font.clone()
+                    && let Some((font, m)) = self.font_of(&d)
+                {
+                    for &c in &s {
+                        let v = m * Point::new(font.width(c as u32), 0.0) - m * Point::ZERO;
+                        w += v.x;
+                        h += v.y;
+                    }
+                }
+                self.push(V::Num(w));
+                self.push(V::Num(h));
+            }
+            "setcachedevice" => {
+                for _ in 0..6 {
+                    self.pop();
+                }
+            }
+            "setcharwidth" => {
+                self.pop();
+                self.pop();
+            }
+            // An embedded Type 1 program's encrypted part (read by `embedded_fonts`).
+            "eexec" => {
+                if matches!(self.pop(), V::File) {
+                    let rest = &src.d[src.pos.min(src.d.len())..];
+                    src.pos += rest.windows(11).position(|w| w == b"cleartomark").map_or(rest.len(), |p| p + 11);
+                }
+            }
+            // A CFF font set's binary data (read by `embedded_fonts`).
+            "StartData" => {
+                let len = self.popn().max(0.0) as usize;
+                self.pop();
+                src.pos = src.pos.saturating_add(1).saturating_add(len).min(src.d.len());
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    /// `xshow` / `yshow` / `xyshow`: glyph displacements from a number array instead of the
+    /// advances.
+    fn explicit_show(&mut self, s: &[u8], disp: &[f64], n: &str) -> Result<(), Flow> {
+        let step = if n == "xyshow" { 2 } else { 1 };
+        let d: Vec<(f64, f64)> = (0..s.len())
+            .map(|k| {
+                let i = k * step;
+                let v = |j: usize| disp.get(j).copied().unwrap_or(0.0);
+                match n {
+                    "xshow" => (v(i), 0.0),
+                    "yshow" => (0.0, v(i)),
+                    _ => (v(i), v(i + 1)),
+                }
+            })
+            .collect();
+        let Some(fd) = self.gs.font.clone() else {
+            self.b.skip("text (no font)");
+            return Ok(());
+        };
+        let Some((font, m)) = self.font_of(&fd) else { return Ok(()) };
+        self.show_with(s, move |k, c| {
+            let adv = m * Point::new(font.width(c), 0.0) - m * Point::ZERO;
+            let (dx, dy) = d.get(k).copied().unwrap_or((0.0, 0.0));
+            (dx - adv.x, dy - adv.y)
+        })
+    }
+}
diff --git a/crates/pdf/src/ps/value.rs b/crates/pdf/src/ps/value.rs
new file mode 100644
index 000000000..3cfafed6e
--- /dev/null
+++ b/crates/pdf/src/ps/value.rs
@@ -0,0 +1,88 @@
+use super::{Affine, BezPath, Cap, HashMap, Join, Point, Rc, RefCell};
+
+pub(crate) type DictRef = Rc<RefCell<HashMap<String, V>>>;
+
+#[derive(Clone)]
+pub(crate) enum V {
+    Num(f64),
+    Bool(bool),
+    /// An executable name.
+    Name(Rc<str>),
+    /// A literal name (`/name`).
+    Lit(Rc<str>),
+    /// A built-in operator, as `load` returns it for a name no dictionary defines.
+    Op(Rc<str>),
+    Str(Rc<RefCell<Vec<u8>>>),
+    Proc(Rc<Vec<V>>),
+    Array(Rc<RefCell<Vec<V>>>),
+    Dict(DictRef),
+    Mark,
+    Null,
+    /// `currentfile`.
+    File,
+}
+
+impl V {
+    pub(super) fn num(&self) -> Option<f64> {
+        match self {
+            V::Num(n) => Some(*n),
+            _ => None,
+        }
+    }
+    pub(super) fn key(&self) -> String {
+        match self {
+            V::Name(n) | V::Lit(n) | V::Op(n) => n.to_string(),
+            V::Str(s) => String::from_utf8_lossy(&s.borrow()).into_owned(),
+            V::Num(n) => format!("{n}"),
+            V::Bool(b) => format!("{b}"),
+            _ => String::new(),
+        }
+    }
+    pub(super) fn items(&self) -> Option<Vec<V>> {
+        match self {
+            V::Array(a) => Some(a.borrow().clone()),
+            V::Proc(p) => Some(p.as_ref().clone()),
+            _ => None,
+        }
+    }
+}
+
+pub(super) enum Flow {
+    Exit,
+    Stop,
+    Quit,
+}
+
+#[derive(Clone)]
+pub(super) struct GState {
+    pub(crate) ctm: Affine,
+    pub(crate) color: [f64; 3],
+    pub(crate) lw: f64,
+    pub(crate) cap: Cap,
+    pub(crate) join: Join,
+    pub(crate) miter: f64,
+    pub(crate) dash: Option<(Vec<f64>, f64)>,
+    pub(crate) path: BezPath,
+    pub(crate) cur: Option<Point>,
+    pub(crate) start: Option<Point>,
+    pub(crate) depth: usize,
+    /// The current font dictionary.
+    pub(crate) font: Option<DictRef>,
+}
+
+pub(super) fn new_dict() -> DictRef {
+    Rc::new(RefCell::new(HashMap::new()))
+}
+
+pub(super) fn array(v: Vec<V>) -> V {
+    V::Array(Rc::new(RefCell::new(v)))
+}
+
+pub(super) fn matrix_of(v: &V) -> Option<Affine> {
+    let a: Vec<f64> = v.items()?.iter().filter_map(V::num).collect();
+    (a.len() == 6).then(|| Affine::new([a[0], a[1], a[2], a[3], a[4], a[5]]))
+}
+
+pub(super) fn matrix_val(m: Affine) -> V {
+    array(m.as_coeffs().iter().map(|c| V::Num(*c)).collect())
+}
diff --git a/crates/pdf/src/read.rs b/crates/pdf/src/read.rs
index 953582fc8..b9c86d0ad 100644
--- a/crates/pdf/src/read.rs
+++ b/crates/pdf/src/read.rs
@@ -2,6 +2,7 @@
 //! Only reachable objects are retained, references keep their generation, and native parser
 //! panics (including lazy object reads) discard the entire partially populated adapter.
 
+use std::cell::LazyCell;
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::panic::{AssertUnwindSafe, catch_unwind};
 use std::sync::Arc;
@@ -10,12 +11,21 @@ use craft_pdf::syntax::object::{Dict as PdfDict, MaybeRef, Name, ObjRef, Object,
 use craft_pdf::syntax::xref::XRef;
 
 use crate::Error;
-use crate::object::{Dict, File, Lexer, Obj};
+use crate::object::{Dict, File, Lexer, Obj, is_delim, is_white, name_bytes};
 
 const MAX_OBJECTS: usize = 100_000;
 const MAX_VALUES: usize = 1_000_000;
 const MAX_DEPTH: usize = 64;
 const MAX_BYTES: usize = 512 * 1024 * 1024;
+/// How far after each `trailer` marker the encryption pre-scan lexes. A classic trailer
+/// dictionary is a few hundred bytes. If the lexer reaches the window's end before any object
+/// or inside a dictionary, the dictionary may start or continue past it, so the file is refused
+/// when a name token that decodes to `Encrypt`, in any spelling (`/Encrypt`, `/Encr#79pt`), ends
+/// past the window. This fallback is conservative: it refuses on any such name there, which in
+/// practice only encrypted files contain. The pre-scan stays linear in file size, at most
+/// `MAX_OBJECTS` windows (about 400 MB) and one search for the name, even when a marker is
+/// followed by an unterminated string or dictionary the lexer would follow to the end.
+const TRAILER_WINDOW: usize = 4 * 1024;
 
 fn limit(what: &str) -> Error {
     Error::Read(format!("PDF exceeds the {what} import limit"))
@@ -41,6 +51,15 @@ fn open_inner(bytes: &[u8]) -> Result<File, Error> {
     // Preserve the app's refusal of encrypted PDFs, including empty-user-password files.
     // Classic trailer dictionaries use the existing lexer; xref-stream dictionaries below
     // are read by the shared parser. This does not parse document objects a second time.
+    let regular = |c: u8| !is_white(c) && !is_delim(c);
+    // Where the last name token decoding to `Encrypt` (escaped or not) ends, searched at most once.
+    // Each token scan stops at the next `/`, so the search is linear.
+    let last_encrypt = LazyCell::new(|| {
+        bytes.iter().enumerate().rev().filter(|&(_, &c)| c == b'/').find_map(|(at, _)| {
+            let token = bytes.get(at + 1..).unwrap_or_default().split(|&c| !regular(c)).next().unwrap_or_default();
+            name_bytes(token).eq(*b"Encrypt").then_some(at + 1 + token.len())
+        })
+    });
     let mut markers = 0;
     for (offset, word) in bytes.windows(7).enumerate() {
         if word == b"trailer" {
@@ -48,9 +67,28 @@ fn open_inner(bytes: &[u8]) -> Result<File, Error> {
             if markers > MAX_OBJECTS {
                 return Err(limit("trailer count"));
             }
-            if let Some(Obj::Dict(dict)) = Lexer::new(bytes, offset + 7).next()
-                && dict.contains_key("Encrypt")
-            {
+            let start = offset + 7;
+            let mut end = bytes.len().min(start.saturating_add(TRAILER_WINDOW));
+            // If the first object after the marker starts in the window and does not open a dictionary
+            // (`<<`), such as a string running on through a stream, no trailer dictionary follows the
+            // marker, so the fallback below does not apply.
+            let mut first = Lexer::new(bytes.get(..end).unwrap_or_default(), start);
+            first.skip_ws();
+            let maybe_dict = first.pos >= end || bytes.get(first.pos..).is_some_and(|rest| rest.starts_with(b"<<"));
+            // A window ending inside a token (a regular byte on each side of the cut) would read its
+            // first part as all of it, such as `/Encrypt` of `/Encrypted`. It ends before that token
+            // instead, so the fallback below reads the token whole.
+            if bytes.get(end).is_some_and(|&c| regular(c)) {
+                end = end.saturating_sub(bytes.get(start..end).unwrap_or_default().iter().rev().take_while(|&&c| regular(c)).count());
+            }
+            let window = bytes.get(start..end).unwrap_or_default();
+            let mut lexer = Lexer::new(window, 0);
+            let encrypt = matches!(lexer.next(), Some(Obj::Dict(dict)) if dict.contains_key("Encrypt"));
+            // Whatever it returned, a lexer at the window's end (one past it after an unterminated
+            // hex string) may have stopped before the dictionary started or partway through it, so
+            // an `Encrypt` name in any spelling that ends past the window refuses the file.
+            let cut = maybe_dict && lexer.pos >= window.len() && last_encrypt.is_some_and(|name_end| name_end > end);
+            if encrypt || cut {
                 return Err(Error::Encrypted);
             }
         }
diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs
index 40f064af7..2d09a7406 100644
--- a/crates/pdf/src/tests.rs
+++ b/crates/pdf/src/tests.rs
@@ -4,6 +4,11 @@ use super::*;
 
 use crate::write::pdf;
 
+mod groups;
+mod import;
+mod reader;
+mod shading;
+
 const CONTENT: &str = "/OC /MC0 BDC\n0 1 0 rg 0 0 200 100 re f\nEMC\n\
 /OC /MC1 BDC\nq 10 10 80 80 re W n\n1 0 0 rg 0 0 50 100 re f\nQ\n\
 /Pattern cs /P0 scn 100 0 100 50 re f\n\
diff --git a/crates/pdf/src/tests_groups.rs b/crates/pdf/src/tests/groups.rs
similarity index 99%
rename from crates/pdf/src/tests_groups.rs
rename to crates/pdf/src/tests/groups.rs
index ce928139f..14b6a4b09 100644
--- a/crates/pdf/src/tests_groups.rs
+++ b/crates/pdf/src/tests/groups.rs
@@ -1,8 +1,8 @@
 //! M13.12: transparency groups (isolated, knockout, group alpha) and soft masks on a group's
 //! combined result.
 
-use super::*;
 use crate::tests::{page_pdf, render};
+use crate::*;
 
 fn near(a: [f32; 4], b: [f32; 4]) -> bool {
     (0..4).all(|i| (a[i] - b[i]).abs() < 0.02)
diff --git a/crates/pdf/src/tests_import.rs b/crates/pdf/src/tests/import.rs
similarity index 99%
rename from crates/pdf/src/tests_import.rs
rename to crates/pdf/src/tests/import.rs
index 11ef72f8f..c7dcbee57 100644
--- a/crates/pdf/src/tests_import.rs
+++ b/crates/pdf/src/tests/import.rs
@@ -1,8 +1,8 @@
 //! M13.12: CCITT images in PDF pages, EPS text and parser robustness over truncated and
 //! corrupt inputs (generated fixtures).
 
-use super::*;
 use crate::tests::{coverage, page_pdf, render, shape_names};
+use crate::*;
 
 fn eps(body: &[u8]) -> Doc {
     let mut b = b"%!PS-Adobe-3.0 EPSF-3.0\n%%BoundingBox: 0 0 200 100\n".to_vec();
diff --git a/crates/pdf/src/tests/reader.rs b/crates/pdf/src/tests/reader.rs
new file mode 100644
index 000000000..da5a0eab1
--- /dev/null
+++ b/crates/pdf/src/tests/reader.rs
@@ -0,0 +1,195 @@
+//! The shared object adapter preserves scalar references and bounds both tree and graph input.
+
+use crate::{Error, parse};
+
+fn document(extra: &str, tail: &[(u32, u16, String)]) -> Vec<u8> {
+    let content = "/GS gs 1 0 0 rg 0 0 20 10 re f";
+    let mut objects = vec![
+        (1, 0, format!("<< /Type /Catalog /Pages 2 0 R {extra} >>")),
+        (2, 0, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".into()),
+        (3, 0, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 20 10] /Resources << /ExtGState << /GS << /ca 5 7 R >> >> >> /Contents 4 0 R >>".into()),
+        (4, 0, format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len())),
+        (5, 7, "0.25".into()),
+    ];
+    objects.extend_from_slice(tail);
+    let mut data = b"%PDF-1.7\n".to_vec();
+    let mut offsets = std::collections::BTreeMap::new();
+    for (number, generation, value) in objects {
+        offsets.insert(number, (data.len(), generation));
+        data.extend_from_slice(format!("{number} {generation} obj\n{value}\nendobj\n").as_bytes());
+    }
+    let xref = data.len();
+    let count = offsets.keys().last().copied().unwrap() + 1;
+    data.extend_from_slice(format!("xref\n0 {count}\n0000000000 65535 f \n").as_bytes());
+    for number in 1..count {
+        let entry = offsets.get(&number).map_or_else(|| "0000000000 65535 f \n".into(), |(offset, generation)| format!("{offset:010} {generation:05} n \n"));
+        data.extend_from_slice(entry.as_bytes());
+    }
+    data.extend_from_slice(format!("trailer\n<< /Size {count} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes());
+    data
+}
+
+#[test]
+fn a_nonzero_generation_scalar_keeps_the_drawing_opacity() {
+    let doc = parse(&document("", &[])).unwrap();
+    assert!(doc.skipped.is_empty(), "{:?}", doc.skipped);
+    let pixel = effectcraft_svg::rasterize(&doc, 20, 10, 1.0).get(10, 5);
+    assert!((pixel[0] - 0.25).abs() < 0.001 && (pixel[3] - 0.25).abs() < 0.001, "{pixel:?}");
+}
+
+#[test]
+fn a_long_cyclic_reference_graph_does_not_expand_recursively() {
+    let objects: Vec<_> = (10..1010).map(|id| (id, 0, format!("<< /Next {} 0 R >>", if id == 1009 { 10 } else { id + 1 }))).collect();
+    let plain = parse(&document("", &[])).unwrap();
+    let cyclic = parse(&document("/Extra 10 0 R", &objects)).unwrap();
+    assert_eq!(plain, cyclic);
+}
+
+#[test]
+fn excessive_inline_nesting_returns_an_error_instead_of_partial_art() {
+    let extra = format!("/Extra {}0{}", "[".repeat(80), "]".repeat(80));
+    let bytes = document(&extra, &[]);
+    // The shared parser rejects the catalog before the adapter's depth limit runs.
+    // Its Invalid result follows the existing NoPages mapping, with no partial document.
+    assert_eq!(crate::page_count(&bytes), 0);
+    assert_eq!(parse(&bytes), Err(Error::NoPages));
+}
+
+fn object_stream(entries: &[(u32, &str)]) -> String {
+    let (mut header, mut body) = (String::new(), String::new());
+    for (number, value) in entries {
+        header.push_str(&format!("{number} {} ", body.len()));
+        body.push_str(value);
+        body.push(' ');
+    }
+    let first = header.len();
+    let content = header + &body;
+    format!("<< /Type /ObjStm /N {} /First {first} /Length {} >>\nstream\n{content}\nendstream", entries.len(), content.len())
+}
+
+#[test]
+fn duplicate_unreferenced_compressed_objects_do_not_block_repair() {
+    let objects = vec![(20, 0, object_stream(&[(10, "<< /Value 1 >>"), (30, "null")])), (21, 0, object_stream(&[(30, "42")]))];
+    let doc = parse(&document("/Missing 10 0 R", &objects)).unwrap();
+    assert!(doc.skipped.iter().any(|warning| warning.contains("recovered PDF object from an object stream: 10 0")));
+    assert!(matches!(parse(&document("/Missing 30 0 R", &objects)), Err(Error::Read(message)) if message.contains("ambiguous recovered object 30")));
+}
+
+#[test]
+fn many_trailer_markers_with_unterminated_objects_do_not_rescan_the_file() {
+    // The encryption pre-scan lexes after every `trailer` marker. Unbounded, each unterminated
+    // string or dictionary here ran to the end of the file: about 10^11 bytes lexed (minutes),
+    // against 2 × 10^8 within the window. The markers sit in an unreferenced stream, so the
+    // file still opens as the plain document.
+    let junk = "trailer(trailer<<".repeat(25_000) + &" ".repeat(2 << 20);
+    let stream = (6, 0, format!("<< /Length {} >>\nstream\n{junk}\nendstream", junk.len()));
+    let plain = parse(&document("", &[])).unwrap();
+    assert_eq!(parse(&document("", &[stream])), Ok(plain));
+}
+
+#[test]
+fn a_classic_trailer_with_an_encrypt_entry_is_refused() {
+    let plain = String::from_utf8(document("", &[])).unwrap();
+    let encrypted = plain.replace("/Root 1 0 R >>", "/Root 1 0 R /Encrypt 9 0 R >>");
+    assert_ne!(encrypted, plain);
+    // Object 9 does not exist: the trailer pre-scan refuses the file before the shared parser runs.
+    assert_eq!(parse(encrypted.as_bytes()), Err(Error::Encrypted));
+}
+
+#[test]
+fn a_trailer_with_a_long_id_fits_the_window() {
+    // Two 128-byte file identifiers leave the trailer dictionary under 600 bytes, well inside the
+    // 4 KiB pre-scan window, so /Encrypt after them is read there.
+    let plain = String::from_utf8(document("", &[])).unwrap();
+    let id = format!("<{}>", "0123456789ABCDEF".repeat(16));
+    let with_id = plain.replace("/Root 1 0 R >>", &format!("/Root 1 0 R /ID [{id} {id}] >>"));
+    let encrypted = plain.replace("/Root 1 0 R >>", &format!("/Root 1 0 R /ID [{id} {id}] /Encrypt 9 0 R >>"));
+    let doc = parse(plain.as_bytes()).unwrap();
+    assert_eq!(parse(with_id.as_bytes()), Ok(doc));
+    assert_eq!(parse(encrypted.as_bytes()), Err(Error::Encrypted));
+}
+
+#[test]
+fn an_encrypt_entry_past_the_trailer_window_is_refused() {
+    // The filler pushes /Encrypt past the pre-scan's 4 KiB window. Object 9 does not exist, and the
+    // shared parser reads /Encrypt only as a dictionary, so it alone would open the file.
+    let plain = String::from_utf8(document("", &[])).unwrap();
+    let filler = "x".repeat(8 * 1024);
+    let long = plain.replace("/Root 1 0 R >>", &format!("/Root 1 0 R /Filler ({filler}) >>"));
+    let encrypted = plain.replace("/Root 1 0 R >>", &format!("/Root 1 0 R /Filler ({filler}) /Encrypt 9 0 R >>"));
+    let doc = parse(plain.as_bytes()).unwrap();
+    assert_eq!(parse(long.as_bytes()), Ok(doc));
+    assert_eq!(parse(encrypted.as_bytes()), Err(Error::Encrypted));
+}
+
+#[test]
+fn an_escaped_encrypt_entry_past_the_trailer_window_is_refused() {
+    // A name may write any byte as `#` and two hex digits, so these keys all read as /Encrypt and
+    // the past-the-window fallback refuses them. The decoys decode to other names and still open.
+    let plain = String::from_utf8(document("", &[])).unwrap();
+    let doc = parse(plain.as_bytes()).unwrap();
+    let filler = "x".repeat(8 * 1024);
+    let trailer = |key: &str| plain.replace("/Root 1 0 R >>", &format!("/Root 1 0 R /Filler ({filler}) {key} 9 0 R >>"));
+    for key in ["/Encr#79pt", "/#45#6E#63rypt", "/E#6e#63rypt"] {
+        assert_eq!(parse(trailer(key).as_bytes()), Err(Error::Encrypted), "{key}");
+    }
+    for decoy in ["/Encrypted", "/Encr#7Apt"] {
+        assert_eq!(parse(trailer(decoy).as_bytes()).as_ref(), Ok(&doc), "{decoy}");
+    }
+}
+
+#[test]
+fn a_hash_without_two_hex_digits_stays_in_a_name() {
+    // `#` escapes a byte only before two hex digits. Otherwise it and what follows stay as written,
+    // so none of these reads as `Encrypt`.
+    let name = |token: &str| String::from_utf8(crate::object::name_bytes(token.as_bytes()).collect()).unwrap();
+    assert_eq!(name("Encry#pt"), "Encry#pt");
+    assert_eq!(name("Encrypt#"), "Encrypt#");
+    assert_eq!(name("Encrypt#7"), "Encrypt#7");
+}
+
+#[test]
+fn an_encrypt_entry_after_a_window_cut_before_the_trailer_dictionary_is_refused() {
+    // The 4 KiB pre-scan window ends in the whitespace before the trailer dictionary (the lexer
+    // returns nothing) or between the two `<` of its `<<` (the lexer reads a hex string).
+    let plain = String::from_utf8(document("", &[])).unwrap();
+    let doc = parse(plain.as_bytes()).unwrap();
+    for pad in [4 * 1024, 4 * 1024 - 2] {
+        let spaced = plain.replace("trailer\n<<", &format!("trailer\n{}<<", " ".repeat(pad)));
+        let encrypted = spaced.replace("/Root 1 0 R >>", "/Root 1 0 R /Encrypt 9 0 R >>");
+        assert_eq!(parse(spaced.as_bytes()).as_ref(), Ok(&doc));
+        assert_eq!(parse(encrypted.as_bytes()), Err(Error::Encrypted));
+    }
+}
+
+#[test]
+fn a_key_cut_by_the_trailer_window_is_read_whole() {
+    // Spaces put the 4 KiB pre-scan window's end inside a trailer key, `inside` bytes into it. The
+    // `/Encrypt` of the decoy `/Encrypted` is not taken for the key, a real `/Encrypt` cut after
+    // `/Encryp` is still refused, and one ending exactly at the window's end is read there.
+    let plain = String::from_utf8(document("", &[])).unwrap();
+    let doc = parse(plain.as_bytes()).unwrap();
+    let window_end = plain.find("trailer").unwrap() + "trailer".len() + 4 * 1024;
+    let key_at = plain.find("/Root 1 0 R >>").unwrap() + "/Root 1 0 R ".len();
+    let trailer = |key: &str, inside: usize| {
+        let file = plain.replace("/Root 1 0 R >>", &format!("/Root 1 0 R {}{key} 9 0 R >>", " ".repeat(window_end - inside - key_at)));
+        assert!(file[window_end - inside..].starts_with(key), "{key}");
+        file
+    };
+    assert_eq!(parse(trailer("/Encrypted", 8).as_bytes()).as_ref(), Ok(&doc));
+    assert_eq!(parse(trailer("/Encrypt", 7).as_bytes()), Err(Error::Encrypted));
+    assert_eq!(parse(trailer("/Encrypt", 8).as_bytes()), Err(Error::Encrypted));
+}
+
+#[test]
+fn a_trailer_string_in_a_stream_does_not_refuse_a_later_encrypt_name() {
+    // A `trailer` marker in an unreferenced stream opens a string or array that runs on past the
+    // 4 KiB pre-scan window to an `Encrypt` name. The unbounded lexer read that object, not a
+    // trailer dictionary, so the past-the-window fallback does not refuse the file either.
+    let plain = parse(&document("", &[])).unwrap();
+    for (open, key) in [("(", "/Encrypt"), ("[", "/Encr#79pt")] {
+        let content = format!("trailer{open}{}{key} 9 0 R", "text ".repeat(1024));
+        let stream = (6, 0, format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len()));
+        assert_eq!(parse(&document("", &[stream])).as_ref(), Ok(&plain), "{open}");
+    }
+}
diff --git a/crates/pdf/src/tests_shading.rs b/crates/pdf/src/tests/shading.rs
similarity index 99%
rename from crates/pdf/src/tests_shading.rs
rename to crates/pdf/src/tests/shading.rs
index 12ca2ff86..8e96193ab 100644
--- a/crates/pdf/src/tests_shading.rs
+++ b/crates/pdf/src/tests/shading.rs
@@ -1,7 +1,7 @@
 //! M13.12: function-based and mesh shadings (generated fixtures).
 
-use super::*;
 use crate::tests::{Objs, page_pdf, render};
+use crate::*;
 
 /// Mesh vertex data: 8-bit flags, 16-bit coordinates (Decode `[0 65535 0 65535 …]`, so raw
 /// values are page units) and 8-bit components.
diff --git a/crates/pdf/src/tests_reader.rs b/crates/pdf/src/tests_reader.rs
deleted file mode 100644
index 999a9900f..000000000
--- a/crates/pdf/src/tests_reader.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-//! The shared object adapter preserves scalar references and bounds both tree and graph input.
-
-use crate::{Error, parse};
-
-fn document(extra: &str, tail: &[(u32, u16, String)]) -> Vec<u8> {
-    let content = "/GS gs 1 0 0 rg 0 0 20 10 re f";
-    let mut objects = vec![
-        (1, 0, format!("<< /Type /Catalog /Pages 2 0 R {extra} >>")),
-        (2, 0, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".into()),
-        (3, 0, "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 20 10] /Resources << /ExtGState << /GS << /ca 5 7 R >> >> >> /Contents 4 0 R >>".into()),
-        (4, 0, format!("<< /Length {} >>\nstream\n{content}\nendstream", content.len())),
-        (5, 7, "0.25".into()),
-    ];
-    objects.extend_from_slice(tail);
-    let mut data = b"%PDF-1.7\n".to_vec();
-    let mut offsets = std::collections::BTreeMap::new();
-    for (number, generation, value) in objects {
-        offsets.insert(number, (data.len(), generation));
-        data.extend_from_slice(format!("{number} {generation} obj\n{value}\nendobj\n").as_bytes());
-    }
-    let xref = data.len();
-    let count = offsets.keys().last().copied().unwrap() + 1;
-    data.extend_from_slice(format!("xref\n0 {count}\n0000000000 65535 f \n").as_bytes());
-    for number in 1..count {
-        let entry = offsets.get(&number).map_or_else(|| "0000000000 65535 f \n".into(), |(offset, generation)| format!("{offset:010} {generation:05} n \n"));
-        data.extend_from_slice(entry.as_bytes());
-    }
-    data.extend_from_slice(format!("trailer\n<< /Size {count} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n").as_bytes());
-    data
-}
-
-#[test]
-fn a_nonzero_generation_scalar_keeps_the_drawing_opacity() {
-    let doc = parse(&document("", &[])).unwrap();
-    assert!(doc.skipped.is_empty(), "{:?}", doc.skipped);
-    let pixel = effectcraft_svg::rasterize(&doc, 20, 10, 1.0).get(10, 5);
-    assert!((pixel[0] - 0.25).abs() < 0.001 && (pixel[3] - 0.25).abs() < 0.001, "{pixel:?}");
-}
-
-#[test]
-fn a_long_cyclic_reference_graph_does_not_expand_recursively() {
-    let objects: Vec<_> = (10..1010).map(|id| (id, 0, format!("<< /Next {} 0 R >>", if id == 1009 { 10 } else { id + 1 }))).collect();
-    let plain = parse(&document("", &[])).unwrap();
-    let cyclic = parse(&document("/Extra 10 0 R", &objects)).unwrap();
-    assert_eq!(plain, cyclic);
-}
-
-#[test]
-fn excessive_inline_nesting_returns_an_error_instead_of_partial_art() {
-    let extra = format!("/Extra {}0{}", "[".repeat(80), "]".repeat(80));
-    let bytes = document(&extra, &[]);
-    // The shared parser rejects the catalog before the adapter's depth limit runs.
-    // Its Invalid result follows the existing NoPages mapping, with no partial document.
-    assert_eq!(crate::page_count(&bytes), 0);
-    assert_eq!(parse(&bytes), Err(Error::NoPages));
-}
-
-fn object_stream(entries: &[(u32, &str)]) -> String {
-    let (mut header, mut body) = (String::new(), String::new());
-    for (number, value) in entries {
-        header.push_str(&format!("{number} {} ", body.len()));
-        body.push_str(value);
-        body.push(' ');
-    }
-    let first = header.len();
-    let content = header + &body;
-    format!("<< /Type /ObjStm /N {} /First {first} /Length {} >>\nstream\n{content}\nendstream", entries.len(), content.len())
-}
-
-#[test]
-fn duplicate_unreferenced_compressed_objects_do_not_block_repair() {
-    let objects = vec![(20, 0, object_stream(&[(10, "<< /Value 1 >>"), (30, "null")])), (21, 0, object_stream(&[(30, "42")]))];
-    let doc = parse(&document("/Missing 10 0 R", &objects)).unwrap();
-    assert!(doc.skipped.iter().any(|warning| warning.contains("recovered PDF object from an object stream: 10 0")));
-    assert!(matches!(parse(&document("/Missing 30 0 R", &objects)), Err(Error::Read(message)) if message.contains("ambiguous recovered object 30")));
-}
diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.toml
index 72d40db34..db11fea11 100644
--- a/crates/project/Cargo.toml
+++ b/crates/project/Cargo.toml
@@ -14,6 +14,7 @@ effectcraft-time = { workspace = true }
 effectcraft-geom = { workspace = true }
 effectcraft-color = { workspace = true }
 effectcraft-keyframe = { workspace = true }
+craft-ecproj-format = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
diff --git a/crates/project/src/build.rs b/crates/project/src/build.rs
index 935c03b0e..1aa8d7c90 100644
--- a/crates/project/src/build.rs
+++ b/crates/project/src/build.rs
@@ -4,7 +4,7 @@ use effectcraft_color::{BlendMode, Label};
 use effectcraft_keyframe::{Gradient, ShapePath, TextDoc, Value};
 use effectcraft_time::Tick;
 
-use crate::props::{GroupKind, MaskMode, ParamUi, PropGroup, Property};
+use crate::props::{GroupKind, MaskMode, Node, ParamUi, PropGroup, Property};
 use crate::{Comp, Layer, LayerId, LayerSource, LightKind, Project, Switches};
 
 /// Id allocator borrowing the project's counter.
@@ -385,11 +385,18 @@ pub fn shape_group(ids: &mut Ids, name: &str, items: Vec<PropGroup>) -> PropGrou
 }
 
 pub fn shape_rect(ids: &mut Ids, size: [f64; 2], position: [f64; 2], roundness: f64) -> PropGroup {
+    // Per-corner radii start from the uniform Roundness, so ticking the box keeps the shape.
+    let r = if roundness.is_finite() { roundness.max(0.0) } else { 0.0 };
     indexed(ids.group("rect", "Rectangle Path 1"))
         .with(ids.prop("direction", "Path Direction", Value::Enum(0)).with_ui(ParamUi::Hidden))
         .with(ids.prop("size", "Size", Value::Vec2(size)).with_ui(ParamUi::Pixels))
         .with(ids.prop("position", "Position", Value::Vec2(position)).with_ui(ParamUi::Point))
         .with(ids.prop("roundness", "Roundness", Value::Scalar(roundness)).with_ui(ParamUi::Pixels))
+        .with(ids.prop("perCorner", "Per-Corner Roundness", Value::Bool(false)).with_ui(ParamUi::Checkbox))
+        .with(ids.prop("topLeftRoundness", "Top Left Roundness", Value::Scalar(r)).with_ui(ParamUi::Pixels))
+        .with(ids.prop("topRightRoundness", "Top Right Roundness", Value::Scalar(r)).with_ui(ParamUi::Pixels))
+        .with(ids.prop("bottomRightRoundness", "Bottom Right Roundness", Value::Scalar(r)).with_ui(ParamUi::Pixels))
+        .with(ids.prop("bottomLeftRoundness", "Bottom Left Roundness", Value::Scalar(r)).with_ui(ParamUi::Pixels))
 }
 
 pub fn shape_ellipse(ids: &mut Ids, size: [f64; 2], position: [f64; 2]) -> PropGroup {
@@ -594,7 +601,24 @@ pub fn shape_simple_op(ids: &mut Ids, kind: &str) -> Option<PropGroup> {
             .with(ids.prop("speed", "Wiggles/Second", Value::Scalar(2.0)))
             .with(ids.prop("correlation", "Correlation", Value::Scalar(50.0)).with_ui(ParamUi::Percent))
             .with(ids.prop("phase", "Temporal Phase", Value::Scalar(0.0)).with_ui(ParamUi::Angle))
+            .with(wiggle_spatial_phase(ids))
             .with(ids.prop("seed", "Random Seed", Value::Scalar(0.0))),
+        "wiggler" | "wiggleTransform" => {
+            // The Transform group holds how far each transformation wiggles.
+            let tr = ids
+                .group("transform", "Transform")
+                .with(ids.prop("anchor", "Anchor Point", Value::Vec2([0.0, 0.0])).with_ui(ParamUi::Point))
+                .with(ids.prop("position", "Position", Value::Vec2([0.0, 0.0])).with_ui(ParamUi::Point))
+                .with(ids.prop("scale", "Scale", Value::Vec2([0.0, 0.0])).with_ui(ParamUi::Percent))
+                .with(ids.prop("rotation", "Rotation", Value::Scalar(0.0)).with_ui(ParamUi::Angle));
+            indexed(ids.group("wiggler", "Wiggle Transform 1"))
+                .with(ids.prop("speed", "Wiggles/Second", Value::Scalar(2.0)))
+                .with(ids.prop("correlation", "Correlation", Value::Scalar(50.0)).with_ui(ParamUi::Percent))
+                .with(ids.prop("phase", "Temporal Phase", Value::Scalar(0.0)).with_ui(ParamUi::Angle))
+                .with(ids.prop("spatialPhase", "Spatial Phase", Value::Scalar(0.0)).with_ui(ParamUi::Angle))
+                .with(ids.prop("seed", "Random Seed", Value::Scalar(0.0)))
+                .with(tr)
+        }
         "merge" => indexed(ids.group("merge", "Merge Paths 1")).with(ids.prop("mode", "Mode", Value::Enum(0)).with_ui(popup(&[
             "Merge",
             "Add",
@@ -607,6 +631,32 @@ pub fn shape_simple_op(ids: &mut Ids, kind: &str) -> Option<PropGroup> {
     Some(g)
 }
 
+/// Wiggle Paths' Spatial Phase.
+fn wiggle_spatial_phase(ids: &mut Ids) -> Property {
+    ids.prop("spatialPhase", "Spatial Phase", Value::Scalar(0.0)).with_ui(ParamUi::Angle)
+}
+
+/// Adds the properties that shape path operations have gained since a project was saved (Wiggle
+/// Paths' Spatial Phase), at their defaults, to the operations in `contents` and its nested
+/// groups. Returns whether anything was added. It walks the nested groups with a work list and
+/// does not recurse.
+pub fn upgrade_shape_contents(ids: &mut Ids, contents: &mut PropGroup) -> bool {
+    let mut changed = false;
+    let mut todo = vec![contents];
+    while let Some(group) = todo.pop() {
+        for n in &mut group.children {
+            let Node::Group(g) = n else { continue };
+            if g.match_id == "wiggle" && !g.children.iter().any(|c| c.match_id() == "spatialPhase") {
+                let at = g.children.iter().position(|c| c.match_id() == "phase").map_or(g.children.len(), |i| i + 1);
+                g.children.insert(at, wiggle_spatial_phase(ids).into());
+                changed = true;
+            }
+            todo.push(g);
+        }
+    }
+    changed
+}
+
 // ---------------------------------------------------------------- camera / light / 3D
 
 pub fn camera_options(ids: &mut Ids, zoom: f64) -> PropGroup {
@@ -654,10 +704,16 @@ pub fn light_options(ids: &mut Ids, kind: LightKind) -> PropGroup {
     }
     if kind == LightKind::Environment {
         // The environment image: a layer (footage, comp…) mapped as an equirectangular panorama;
-        // none = the comp's Environment Layer.
+        // none = the comp's Environment Layer, or a flat default environment of the light's
+        // colour × intensity when there is none. No Falloff: an environment light shines from
+        // every direction at once. Environment lights cast shadows too (After Effects' Light
+        // Settings shows Cast Shadows for them; not for Ambient) (#2436).
         return g
             .with(ids.prop("source", "Source", Value::Layer(None)).with_ui(ParamUi::Layer))
-            .with(ids.prop("rotation", "Environment Rotation", Value::Scalar(0.0)).with_ui(ParamUi::Angle));
+            .with(ids.prop("rotation", "Environment Rotation", Value::Scalar(0.0)).with_ui(ParamUi::Angle))
+            .with(ids.prop("castsShadows", "Casts Shadows", Value::Bool(false)).with_ui(ParamUi::Checkbox))
+            .with(ids.prop("shadowDarkness", "Shadow Darkness", Value::Scalar(100.0)).with_ui(ParamUi::Percent))
+            .with(ids.prop("shadowDiffusion", "Shadow Diffusion", Value::Scalar(0.0)).with_ui(ParamUi::Pixels));
     }
     if kind != LightKind::Ambient {
         g = g
@@ -854,6 +910,14 @@ pub fn layer(project: &mut Project, comp: &Comp, name: &str, source: LayerSource
             _ => {}
         }
     }
+    // A footage layer starts with the markers its file carries (layer time is footage time).
+    let footage_markers = match &source {
+        LayerSource::Footage { item } => match project.item(*item).map(|i| &i.kind) {
+            Some(crate::ItemKind::Footage(f)) => f.markers.clone(),
+            _ => vec![],
+        },
+        _ => vec![],
+    };
     let has_audio = matches!(&source, LayerSource::Footage { item } if matches!(project.item(*item).map(|i| &i.kind), Some(crate::ItemKind::Footage(f)) if f.has_audio))
         || matches!(source, LayerSource::Comp { .. });
     if has_audio {
@@ -883,7 +947,7 @@ pub fn layer(project: &mut Project, comp: &Comp, name: &str, source: LayerSource
         preserve_transparency: false,
         track_matte: None,
         parent: None,
-        markers: vec![],
+        markers: footage_markers,
         markers_locked: false,
         environment: false,
         environment_background: false,
diff --git a/crates/project/src/comp.rs b/crates/project/src/comp.rs
new file mode 100644
index 000000000..aa4ff7201
--- /dev/null
+++ b/crates/project/src/comp.rs
@@ -0,0 +1,446 @@
+use super::item::LayerId;
+use super::layer::{Layer, LayerSource};
+use super::settings::{Marker, yes};
+use super::{Deserialize, FrameRate, Node, PropGroup, Serialize, Tick, Value, essential, styles};
+
+/// 3D renderer of a composition.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Renderer {
+    #[default]
+    Classic3D,
+    Advanced3D,
+}
+
+/// A composition's Resolution (the Composition panel's Resolution/Down Sample Factor popup, View ▸
+/// Resolution): how many of its pixels the viewer renders. Auto follows the magnification.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Resolution {
+    #[default]
+    Auto,
+    Full,
+    Half,
+    Third,
+    Quarter,
+    /// View ▸ Resolution ▸ Custom: render every n-th pixel (2..=40).
+    Custom(u8),
+}
+
+impl Resolution {
+    pub const ALL: [Resolution; 5] = [Resolution::Auto, Resolution::Full, Resolution::Half, Resolution::Third, Resolution::Quarter];
+    pub fn label(self) -> &'static str {
+        match self {
+            Resolution::Auto => "Auto",
+            Resolution::Full => "Full",
+            Resolution::Half => "Half",
+            Resolution::Third => "Third",
+            Resolution::Quarter => "Quarter",
+            Resolution::Custom(_) => "Custom",
+        }
+    }
+    pub fn is_auto(&self) -> bool {
+        *self == Resolution::Auto
+    }
+    /// The down-sample factor (render every n-th pixel); `None` for Auto.
+    pub fn factor(self) -> Option<u8> {
+        match self {
+            Resolution::Auto => None,
+            Resolution::Full => Some(1),
+            Resolution::Half => Some(2),
+            Resolution::Third => Some(3),
+            Resolution::Quarter => Some(4),
+            Resolution::Custom(n) => Some(n),
+        }
+    }
+    /// The resolution that renders every `n`-th pixel (1 = Full … 4 = Quarter; up to 40).
+    pub fn from_factor(n: u64) -> Resolution {
+        match n.clamp(1, 40) {
+            1 => Resolution::Full,
+            2 => Resolution::Half,
+            3 => Resolution::Third,
+            4 => Resolution::Quarter,
+            n => Resolution::Custom(n as u8),
+        }
+    }
+    /// Render scale for a viewer magnification (and display pixel density).
+    pub fn scale(self, zoom: f32, ppp: f32) -> f64 {
+        match self.factor() {
+            Some(n) => 1.0 / f64::from(n.clamp(1, 40)),
+            // As in After Effects, Auto renders the pixels the magnification needs: the coarsest
+            // whole factor that still gives every screen pixel a rendered one (Full above 50 %,
+            // Half down to 33.3 %, Third down to 25 %, Quarter below), never fewer (#417).
+            None => {
+                let n = (1.0 / (zoom * ppp) as f64 + 1e-3).floor();
+                if n >= 1.0 { 1.0 / n.min(4.0) } else { 1.0 }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Comp {
+    pub width: u32,
+    pub height: u32,
+    pub pixel_aspect: f64,
+    pub frame_rate: FrameRate,
+    pub duration: Tick,
+    /// Start timecode/frame shown for time 0.
+    pub display_start: Tick,
+    pub background: [f32; 3],
+    pub work_area: (Tick, Tick),
+    /// Layer #1 first (top of the stack). Each layer is shared between undo states until edited.
+    pub layers: super::Layers,
+    #[serde(default)]
+    pub markers: Vec<Marker>,
+    pub shutter_angle: f64,
+    pub shutter_phase: f64,
+    /// Samples Per Frame: the minimum motion-blur samples (and the count for 3D layers).
+    pub motion_blur_samples: u32,
+    /// Adaptive Sample Limit (Composition Settings ▸ Advanced): the most samples a 2D layer gets
+    /// when it moves far within the shutter.
+    #[serde(default = "adaptive_limit_default")]
+    pub motion_blur_adaptive_limit: u32,
+    #[serde(default)]
+    pub renderer: Renderer,
+    /// Comp switches (timeline toolbar).
+    #[serde(default)]
+    pub hide_shy: bool,
+    #[serde(default = "yes")]
+    pub enable_motion_blur: bool,
+    #[serde(default = "yes")]
+    pub enable_frame_blending: bool,
+    #[serde(default)]
+    pub draft_3d: bool,
+    /// Composition Settings ▸ Advanced ▸ Preserve frame rate when nested or in render queue:
+    /// nested in another comp, or rendered at another rate, it shows only its own frames.
+    #[serde(default)]
+    pub preserve_frame_rate: bool,
+    /// Composition Settings ▸ Advanced ▸ Preserve resolution when nested: nested in a comp
+    /// previewed at a lower resolution, it still renders at full size.
+    #[serde(default)]
+    pub preserve_resolution: bool,
+    #[serde(default)]
+    pub poster_time: Tick,
+    /// Global Light for layer styles (Layer ▸ Layer Styles ▸ Blending Options).
+    #[serde(default)]
+    pub global_light: styles::GlobalLight,
+    /// Viewer guides (View ▸ Add Guide…), in comp pixels.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub guides: Vec<Guide>,
+    /// Essential Graphics: the controls this comp exposes to instances and templates.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub essential: Option<essential::EssentialGraphics>,
+    /// The Composition panel's Resolution, saved with the project as in After Effects. It changes
+    /// what the viewer renders, not the comp's pixels ([`Comp::same_pixels`]), and stays out of
+    /// the undo history.
+    #[serde(default, skip_serializing_if = "Resolution::is_auto")]
+    pub resolution: Resolution,
+}
+
+/// A viewer guide line: vertical guides sit at an x position, horizontal ones at a y position.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Guide {
+    pub vertical: bool,
+    /// Comp pixels, or percent of the comp's width (vertical) / height (horizontal) when
+    /// [`Guide::percent`] is set.
+    pub position: f64,
+    /// A percentage guide (After Effects 26.5): `position` is a percent of the comp's size, so the
+    /// guide keeps its relative place when the comp is resized. Absent in older projects.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub percent: bool,
+}
+
+impl Guide {
+    /// The comp's extent along this guide's axis, never zero.
+    fn extent(&self, width: u32, height: u32) -> f64 {
+        f64::from(if self.vertical { width } else { height }).max(1.0)
+    }
+
+    /// The guide's position in comp pixels for a comp of this size.
+    pub fn px(&self, width: u32, height: u32) -> f64 {
+        if self.percent { self.position / 100.0 * self.extent(width, height) } else { self.position }
+    }
+
+    /// Place the guide at `px` comp pixels, keeping its unit.
+    pub fn set_px(&mut self, px: f64, width: u32, height: u32) {
+        self.position = if self.percent { px / self.extent(width, height) * 100.0 } else { px };
+    }
+
+    /// Switch between pixels and percent without moving the guide on the comp.
+    pub fn set_percent(&mut self, percent: bool, width: u32, height: u32) {
+        let px = self.px(width, height);
+        self.percent = percent;
+        self.set_px(px, width, height);
+    }
+}
+
+fn adaptive_limit_default() -> u32 {
+    128
+}
+
+impl Comp {
+    pub fn new(width: u32, height: u32, frame_rate: FrameRate, duration: Tick) -> Comp {
+        Comp {
+            width,
+            height,
+            pixel_aspect: 1.0,
+            frame_rate,
+            duration,
+            display_start: Tick::ZERO,
+            background: [0.0, 0.0, 0.0],
+            work_area: (Tick::ZERO, duration),
+            layers: super::Layers::new(),
+            markers: vec![],
+            shutter_angle: 180.0,
+            shutter_phase: -90.0,
+            motion_blur_samples: 16,
+            motion_blur_adaptive_limit: 128,
+            renderer: Renderer::Classic3D,
+            hide_shy: false,
+            enable_motion_blur: true,
+            enable_frame_blending: true,
+            draft_3d: false,
+            preserve_frame_rate: false,
+            preserve_resolution: false,
+            poster_time: Tick::ZERO,
+            guides: vec![],
+            global_light: styles::GlobalLight::default(),
+            essential: None,
+            resolution: Resolution::Auto,
+        }
+    }
+
+    /// Whether the composition has a frame at its time `t`: nested, it shows nothing before it
+    /// starts or after it ends (a precomp layer trimmed or remapped past it).
+    pub fn covers(&self, t: Tick) -> bool {
+        t >= Tick::ZERO && t < self.duration
+    }
+
+    /// A new, empty composition with this one's settings (frame rate, pixel aspect, background,
+    /// motion blur, frame blending and the 3D renderer), as Pre-compose makes.
+    pub fn nested_like(&self, width: u32, height: u32, duration: Tick) -> Comp {
+        Comp {
+            pixel_aspect: self.pixel_aspect,
+            background: self.background,
+            shutter_angle: self.shutter_angle,
+            shutter_phase: self.shutter_phase,
+            motion_blur_samples: self.motion_blur_samples,
+            motion_blur_adaptive_limit: self.motion_blur_adaptive_limit,
+            renderer: self.renderer,
+            enable_motion_blur: self.enable_motion_blur,
+            enable_frame_blending: self.enable_frame_blending,
+            preserve_frame_rate: self.preserve_frame_rate,
+            preserve_resolution: self.preserve_resolution,
+            ..Comp::new(width, height, self.frame_rate, duration)
+        }
+    }
+
+    pub fn layer(&self, id: LayerId) -> Option<&Layer> {
+        self.layers.iter().find(|l| l.id == id)
+    }
+
+    pub fn layer_mut(&mut self, id: LayerId) -> Option<&mut Layer> {
+        self.layers.find_mut(|l| l.id == id)
+    }
+
+    /// 1-based layer number (#) of a layer.
+    pub fn index_of(&self, id: LayerId) -> Option<usize> {
+        self.layers.iter().position(|l| l.id == id).map(|i| i + 1)
+    }
+
+    pub fn layer_by_name(&self, name: &str) -> Option<&Layer> {
+        self.layers.iter().find(|l| l.name == name)
+    }
+
+    pub fn frame_duration(&self) -> Tick {
+        self.frame_rate.frame_duration()
+    }
+
+    /// Any 3D layer present (camera/lights or a 3D switch).
+    pub fn has_3d(&self) -> bool {
+        self.layers.iter().any(|l| l.switches.three_d || matches!(l.source, LayerSource::Camera | LayerSource::Light { .. }))
+    }
+
+    /// The active camera at `t`: the topmost enabled camera layer active at that time.
+    pub fn active_camera(&self, t: Tick) -> Option<&Layer> {
+        self.layers.iter().find(|l| matches!(l.source, LayerSource::Camera) && l.switches.video && l.is_active_at(t))
+    }
+
+    /// Unique layer name with a numeric suffix (`Shape Layer 2`).
+    pub fn unique_layer_name(&self, base: &str) -> String {
+        if !self.layers.iter().any(|l| l.name == base) {
+            return base.to_string();
+        }
+        let stem = base.trim_end_matches(|c: char| c.is_ascii_digit()).trim_end();
+        (2..).map(|i| format!("{stem} {i}")).find(|n| !self.layers.iter().any(|l| &l.name == n)).unwrap_or_default()
+    }
+}
+
+/// A protected time marker with a duration sets the comp's timing (Responsive Design), so it is
+/// part of the pixels even where plain markers are not.
+fn is_timing_marker(m: &Marker) -> bool {
+    m.protected && m.duration > Tick::ZERO
+}
+
+fn timing_markers(m: &[Marker]) -> impl Iterator<Item = (Tick, Tick)> + '_ {
+    m.iter().filter(|m| is_timing_marker(m)).map(|m| (m.time, m.duration))
+}
+
+impl Comp {
+    /// Draws the same pixels as `o`: equal but for its layers' Audio, Lock and Shy switches, Hide
+    /// Shy Layers and the viewer's Resolution.
+    pub fn same_pixels(&self, o: &Comp) -> bool {
+        self.same_pixels_with(o, true)
+    }
+
+    /// [`Self::same_pixels`], with the comp's and its layers' markers counting only when
+    /// `with_markers`: only expressions read them, so while none does, adding or moving a marker
+    /// (even during playback) leaves every rendered frame valid. Protected time markers with a
+    /// duration set the timing (Responsive Design), so those always count.
+    pub fn same_pixels_with(&self, o: &Comp, with_markers: bool) -> bool {
+        self.same_settings(o, with_markers)
+            && self.layers.len() == o.layers.len()
+            && self.layers.iter().zip(&o.layers).all(|(a, b)| a.same_pixels_with(b, with_markers))
+    }
+
+    /// [`Self::same_pixels_with`] but for the layers.
+    fn same_settings(&self, o: &Comp, with_markers: bool) -> bool {
+        // Every field (no `..`: a new field must be considered here).
+        let Comp {
+            width,
+            height,
+            pixel_aspect,
+            frame_rate,
+            duration,
+            display_start,
+            background,
+            work_area,
+            layers: _,
+            markers,
+            shutter_angle,
+            shutter_phase,
+            motion_blur_samples,
+            motion_blur_adaptive_limit,
+            renderer,
+            hide_shy: _,
+            enable_motion_blur,
+            enable_frame_blending,
+            draft_3d,
+            preserve_frame_rate,
+            preserve_resolution,
+            poster_time,
+            global_light,
+            guides,
+            essential,
+            resolution: _,
+        } = self;
+        *width == o.width
+            && *height == o.height
+            && *pixel_aspect == o.pixel_aspect
+            && *frame_rate == o.frame_rate
+            && *duration == o.duration
+            && *display_start == o.display_start
+            && *background == o.background
+            && *work_area == o.work_area
+            && (if with_markers { *markers == o.markers } else { timing_markers(markers).eq(timing_markers(&o.markers)) })
+            && *shutter_angle == o.shutter_angle
+            && *shutter_phase == o.shutter_phase
+            && *motion_blur_samples == o.motion_blur_samples
+            && *motion_blur_adaptive_limit == o.motion_blur_adaptive_limit
+            && *renderer == o.renderer
+            && *enable_motion_blur == o.enable_motion_blur
+            && *enable_frame_blending == o.enable_frame_blending
+            && *draft_3d == o.draft_3d
+            && *preserve_frame_rate == o.preserve_frame_rate
+            && *preserve_resolution == o.preserve_resolution
+            && *poster_time == o.poster_time
+            && *global_light == o.global_light
+            && *guides == o.guides
+            && *essential == o.essential
+    }
+
+    /// The comp-time span (`in_point..out_point` of every layer changed, added or removed,
+    /// widened by the shutter) outside which `self` draws the same pixels as `o`, so cached
+    /// frames there stay valid (#1641). `None` when the edit can reach any frame: a comp setting,
+    /// a layer reorder, Solo turning on or off, an expression (it reads anything), or a changed
+    /// layer another layer parents to, mattes with or picks in an effect.
+    pub fn changed_span(&self, o: &Comp) -> Option<(Tick, Tick)> {
+        fn reads(g: &PropGroup, changed: &[LayerId]) -> bool {
+            g.children.iter().any(|c| match c {
+                Node::Prop(p) => {
+                    p.expr.is_some()
+                        || std::iter::once(&p.value)
+                            .chain(p.keys.iter().map(|k| &k.value))
+                            .any(|v| matches!(v, Value::Layer(Some(id)) if changed.contains(&LayerId(*id))))
+                }
+                Node::Group(g) => reads(g, changed),
+            })
+        }
+        // Solo hides every other layer at every frame.
+        if !self.same_settings(o, true) || self.any_solo() != o.any_solo() {
+            return None;
+        }
+        let common = |a: &Comp, b: &Comp| a.layers.iter().map(|l| l.id).filter(|id| b.layer(*id).is_some()).collect::<Vec<_>>();
+        if common(self, o) != common(o, self) {
+            return None;
+        }
+        let mut changed = Vec::new();
+        let mut span: Option<(Tick, Tick)> = None;
+        // Each changed layer comes up from both sides: its old and its new span.
+        for (l, other) in self.layers.iter().map(|l| (l, o.layer(l.id))).chain(o.layers.iter().map(|l| (l, self.layer(l.id)))) {
+            if other.is_some_and(|b| l.same_pixels(b)) {
+                continue;
+            }
+            changed.push(l.id);
+            let (s, e) = (l.in_point.min(l.out_point), l.in_point.max(l.out_point));
+            span = Some(span.map_or((s, e), |(a, b)| (a.min(s), b.max(e))));
+        }
+        let reaches = |l: &Layer| {
+            l.parent.is_some_and(|p| changed.contains(&p)) || l.track_matte.as_ref().is_some_and(|m| changed.contains(&m.layer)) || reads(&l.props, &changed)
+        };
+        if self.layers.iter().chain(&o.layers).any(reaches) {
+            return None;
+        }
+        // A frame at `t` samples cameras, lights and transforms over its shutter,
+        // `t + (phase + angle * 0..=1) / 360` frames, and draws the layers active at `t` itself.
+        let (a, p) = (self.shutter_angle / 360.0, self.shutter_phase / 360.0);
+        let fd = self.frame_duration().seconds();
+        let (before, after) = (Tick::from_seconds_f64(p.max(p + a).max(0.0) * fd), Tick::from_seconds_f64(-p.min(p + a).min(0.0) * fd));
+        span.map(|(s, e)| (s - before, e + after))
+    }
+
+    /// Some layer is soloed: only the soloed layers draw.
+    pub fn any_solo(&self) -> bool {
+        self.layers.iter().any(|l| l.switches.solo && l.source.is_av())
+    }
+
+    /// The comp with those switches and the Resolution at their defaults (borrowed when they
+    /// already are), for keys that hash the whole comp.
+    pub fn pixel_form(&self) -> std::borrow::Cow<'_, Comp> {
+        self.pixel_form_with(true)
+    }
+
+    /// [`Self::pixel_form`], also without the comp's plain markers and its layers' markers when not
+    /// `with_markers` (see [`Self::same_pixels_with`] and [`Project::reads_markers`]).
+    pub fn pixel_form_with(&self, with_markers: bool) -> std::borrow::Cow<'_, Comp> {
+        if !self.hide_shy
+            && self.resolution.is_auto()
+            && self.layers.iter().all(|l| l.switches == l.switches.pixels())
+            && (with_markers || (self.markers.iter().all(is_timing_marker) && self.layers.iter().all(|l| l.markers.is_empty())))
+        {
+            return std::borrow::Cow::Borrowed(self);
+        }
+        let mut c = self.clone();
+        c.hide_shy = false;
+        c.resolution = Resolution::Auto;
+        if !with_markers {
+            c.markers.retain(is_timing_marker);
+        }
+        for l in &mut c.layers {
+            l.switches = l.switches.pixels();
+            if !with_markers {
+                l.markers.clear();
+            }
+        }
+        std::borrow::Cow::Owned(c)
+    }
+}
diff --git a/crates/project/src/footage.rs b/crates/project/src/footage.rs
new file mode 100644
index 000000000..8cf07ea2e
--- /dev/null
+++ b/crates/project/src/footage.rs
@@ -0,0 +1,390 @@
+use super::settings::{Marker, yes};
+use super::{ColorSpace, Deserialize, FrameRate, Serialize, Tick};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum FootageKind {
+    #[default]
+    Video,
+    Still,
+    Sequence,
+    Audio,
+    /// A 3D model (glTF 2.0 / OBJ), placed as a model layer.
+    Model,
+    /// A data file (JSON, CSV, TSV) for data-driven animation: read by expressions through
+    /// `footage(name).sourceData` / `sourceText` / `dataValue`; it has no pixels.
+    Data,
+}
+
+/// Interpret Footage ▸ Fields and Pulldown ▸ Separate Fields.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum FieldOrder {
+    /// Progressive frames.
+    #[default]
+    Off,
+    /// Interlaced, upper (odd) field first: each field becomes a frame at twice the rate.
+    UpperFirst,
+    LowerFirst,
+}
+
+impl FieldOrder {
+    pub fn label(self) -> &'static str {
+        match self {
+            FieldOrder::Off => "Off",
+            FieldOrder::UpperFirst => "Upper Field First",
+            FieldOrder::LowerFirst => "Lower Field First",
+        }
+    }
+    pub fn parse(s: &str) -> Option<FieldOrder> {
+        match s.to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
+            "off" | "none" | "progressive" => Some(FieldOrder::Off),
+            "upper" | "upperfirst" | "upperfieldfirst" => Some(FieldOrder::UpperFirst),
+            "lower" | "lowerfirst" | "lowerfieldfirst" => Some(FieldOrder::LowerFirst),
+            _ => None,
+        }
+    }
+}
+
+/// File extensions of the movie containers footage is imported from (FilmCraft reads them). The
+/// import and proxy file dialogs, the Media Browser and `effectcraft_media::is_importable` all go
+/// by this list.
+pub const VIDEO_EXTENSIONS: &[&str] = &["mp4", "m4v", "mov", "mkv", "webm", "mxf", "avi"];
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum AlphaMode {
+    #[default]
+    Straight,
+    Premultiplied,
+    Ignore,
+}
+
+/// Interpret Footage ▸ Cineon Settings ▸ Units: how the Converted Black and White Points are
+/// shown and entered.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum CineonUnits {
+    /// 10-bit code values (0–1023).
+    #[default]
+    TenBit,
+    /// 8-bit values (0–255).
+    EightBit,
+    /// Floating point (0–1).
+    Float,
+}
+
+impl CineonUnits {
+    pub const ALL: [CineonUnits; 3] = [CineonUnits::TenBit, CineonUnits::EightBit, CineonUnits::Float];
+
+    /// The id commands use: `10bit`, `8bit` or `float`.
+    pub fn id(self) -> &'static str {
+        match self {
+            CineonUnits::TenBit => "10bit",
+            CineonUnits::EightBit => "8bit",
+            CineonUnits::Float => "float",
+        }
+    }
+
+    pub fn label(self) -> &'static str {
+        match self {
+            CineonUnits::TenBit => "10-bit",
+            CineonUnits::EightBit => "8-bit",
+            CineonUnits::Float => "Float",
+        }
+    }
+
+    pub fn parse(s: &str) -> Option<CineonUnits> {
+        match s.to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
+            "10bit" | "10" => Some(CineonUnits::TenBit),
+            "8bit" | "8" => Some(CineonUnits::EightBit),
+            "float" | "32bit" => Some(CineonUnits::Float),
+            _ => None,
+        }
+    }
+
+    /// A 10-bit value (0–1023) in these units.
+    pub fn from_ten_bit(self, v: f64) -> f64 {
+        match self {
+            CineonUnits::TenBit => v,
+            CineonUnits::EightBit => v * 255.0 / 1023.0,
+            CineonUnits::Float => v / 1023.0,
+        }
+    }
+
+    /// A value in these units as a 10-bit value (0–1023).
+    pub fn to_ten_bit(self, v: f64) -> f64 {
+        match self {
+            CineonUnits::TenBit => v,
+            CineonUnits::EightBit => v * 1023.0 / 255.0,
+            CineonUnits::Float => v * 1023.0,
+        }
+    }
+}
+
+/// Interpret Footage ▸ Cineon Settings of DPX and Cineon footage: how the file's logarithmic
+/// (printing density) code values become the footage's pixels. Code values are counted in 10-bit
+/// units whatever the file's bit depth.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct CineonSettings {
+    /// Logarithmic Conversion: convert the code values from log to the Current Gamma. When it
+    /// is off, the code values are shown as stored.
+    pub log_conversion: bool,
+    /// Converted Black Point: the level the 10 Bit Black Point becomes (10-bit units).
+    pub converted_black: f32,
+    /// Converted White Point: the level the 10 Bit White Point becomes (10-bit units).
+    pub converted_white: f32,
+    /// 10 Bit Black Point: the code value of minimum density.
+    pub black: f32,
+    /// 10 Bit White Point: the code value of maximum density.
+    pub white: f32,
+    /// Current Gamma: the gamma the converted values are encoded with (1: linear light).
+    pub gamma: f32,
+    /// Highlight Rolloff (0–100): values near and above the white point ramp off gradually
+    /// instead of clipping; 0 keeps over-range values.
+    pub rolloff: f32,
+    /// Units of the Converted Black and White Points.
+    pub units: CineonUnits,
+}
+
+impl Default for CineonSettings {
+    fn default() -> Self {
+        CineonSettings {
+            log_conversion: false,
+            converted_black: 0.0,
+            converted_white: 1023.0,
+            black: 95.0,
+            white: 685.0,
+            gamma: 1.7,
+            rolloff: 20.0,
+            units: CineonUnits::TenBit,
+        }
+    }
+}
+
+impl CineonSettings {
+    /// The highest 10-bit value.
+    pub const MAX: f32 = 1023.0;
+
+    /// A code value (0–1 of the 10-bit range) converted from log to the Current Gamma and the
+    /// converted black and white levels (0–1; above 1 for over-range highlights).
+    pub fn convert(&self, v: f32) -> f32 {
+        let lin = cineon_log_to_lin(v, self.black, self.white, 1.0, self.gamma, self.rolloff);
+        let out = (self.converted_black + (self.converted_white - self.converted_black) * lin) / Self::MAX;
+        if out.is_finite() { out } else { 0.0 }
+    }
+}
+
+/// Cineon log to linear, shared by Interpret Footage ▸ Cineon Settings and the Cineon Converter
+/// effect. `v` is a code value as 0–1 of the 10-bit range; `black` and `white` are the 10 Bit
+/// Black and White Points. The result is 0 at the black point and 1 at the white point, raised to
+/// `scale / gamma`, with values above `1 - rolloff / 100` ramped off toward 1 (Highlight Rolloff
+/// 0–100; 0 keeps over-range values). A Gamma below 0.01 is raised to 0.01. Cineon Settings passes
+/// a `scale` of 1 (Gamma 1 gives linear light) and the Cineon Converter passes 1.7 (its default
+/// Gamma 1.7 gives linear light).
+pub fn cineon_log_to_lin(v: f32, black: f32, white: f32, scale: f32, gamma: f32, rolloff: f32) -> f32 {
+    // Kodak printing density: 0.002 density per code value, negative gamma 0.6.
+    let exposure = |code: f32| 10f32.powf((code - white) * 0.002 / 0.6);
+    let offset = exposure(black);
+    let mut lin = ((exposure(v * CineonSettings::MAX) - offset) / (1.0 - offset).max(1e-6)).max(0.0);
+    lin = lin.powf(scale / gamma.max(0.01));
+    let knee = 1.0 - (rolloff / 100.0).clamp(0.0, 0.99);
+    if knee < 1.0 && lin > knee {
+        let w = 1.0 - knee;
+        lin = knee + w * (1.0 - (-(lin - knee) / w).exp());
+    }
+    lin
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Footage {
+    pub path: String,
+    pub kind: FootageKind,
+    pub width: u32,
+    pub height: u32,
+    pub pixel_aspect: f64,
+    pub frame_rate: FrameRate,
+    /// Native rate before "Conform to frame rate".
+    #[serde(default)]
+    pub native_rate: Option<FrameRate>,
+    pub duration: Tick,
+    pub has_video: bool,
+    pub has_audio: bool,
+    pub alpha: AlphaMode,
+    #[serde(default)]
+    pub premul_color: [f32; 3],
+    #[serde(default = "one")]
+    pub loop_count: u32,
+    #[serde(default)]
+    pub codec: String,
+    #[serde(default)]
+    pub missing: bool,
+    /// Image sequence files (when kind = Sequence).
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sequence: Vec<String>,
+    /// Colour profile (from the file's metadata, or Interpret Footage). `None` = sRGB.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub color_profile: Option<ColorSpace>,
+    /// One layer of a layered file (Photoshop) instead of its merged image.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub layer: Option<SourceLayer>,
+    /// Interpret Footage ▸ Fields and Pulldown ▸ Separate Fields.
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub fields: FieldOrder,
+    /// Interpret Footage ▸ Alpha ▸ Invert Alpha.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub invert_alpha: bool,
+    /// Interpret Footage ▸ Color ▸ Interpret As Linear Light: the file's values are linear.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub linear_light: bool,
+    /// Interpret Footage ▸ Color ▸ Preserve RGB: the file's values enter the composition
+    /// unconverted. Float footage (OpenEXR, float TIFF) is not sRGB-encoded on decode, and the
+    /// colour profile, Interpret As Linear Light and the working space don't apply.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub preserve_rgb: bool,
+    /// Interpret Footage ▸ Cineon Settings (DPX and Cineon files only; [`Footage::cineon_applies`]).
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub cineon: CineonSettings,
+    /// Data footage ([`FootageKind::Data`]): the file's text (JSON, CSV or TSV), kept in the
+    /// project so expressions read it everywhere (and on the web).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+    /// PDF / Illustrator footage: the page shown (0-based; File ▸ Import ▸ Page).
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub page: u32,
+    /// Image sequences imported with Force Alphabetical Order: the files play one after another
+    /// and their numbering doesn't count (otherwise a gap in it shows a placeholder, as in After
+    /// Effects; [`sequence`]).
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub alphabetical: bool,
+    /// Interpret Footage ▸ Start Timecode ▸ Override Start: the frame (at the footage's frame
+    /// rate) its timecode shows at its first frame. `None` = Use Source File Timecode (0: file
+    /// timecode isn't read). It only relabels source time, as in After Effects.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub start_timecode: Option<i64>,
+    /// Markers the file carries (a WAV's cue points and XMP markers), at footage time. A layer
+    /// made from the footage starts with them, and Update Markers From Source copies new ones.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub markers: Vec<Marker>,
+}
+
+fn is_default<T: Default + PartialEq>(v: &T) -> bool {
+    *v == T::default()
+}
+
+impl Default for Footage {
+    fn default() -> Self {
+        Footage {
+            path: String::new(),
+            kind: FootageKind::Still,
+            width: 0,
+            height: 0,
+            pixel_aspect: 1.0,
+            frame_rate: FrameRate::FPS_30,
+            native_rate: None,
+            duration: Tick::ZERO,
+            has_video: false,
+            has_audio: false,
+            alpha: AlphaMode::Straight,
+            premul_color: [0.0; 3],
+            loop_count: 1,
+            codec: String::new(),
+            missing: false,
+            sequence: vec![],
+            color_profile: None,
+            fields: FieldOrder::Off,
+            invert_alpha: false,
+            linear_light: false,
+            preserve_rgb: false,
+            cineon: CineonSettings::default(),
+            data: None,
+            layer: None,
+            page: 0,
+            alphabetical: false,
+            start_timecode: None,
+            markers: vec![],
+        }
+    }
+}
+
+impl Footage {
+    /// The file is DPX or Cineon (the formats Interpret Footage ▸ Cineon Settings applies to).
+    pub fn is_cineon_file(&self) -> bool {
+        let ext = std::path::Path::new(&self.path).extension().and_then(|e| e.to_str()).unwrap_or("").to_ascii_lowercase();
+        matches!(ext.as_str(), "dpx" | "cin")
+    }
+
+    /// Cineon Settings ▸ Logarithmic Conversion applies: it is on and the file is DPX or Cineon.
+    pub fn cineon_applies(&self) -> bool {
+        self.cineon.log_conversion && self.is_cineon_file()
+    }
+
+    /// Interpret As Linear Light applies (Preserve RGB passes the file's values through).
+    pub fn linear_light_applies(&self) -> bool {
+        self.linear_light && !self.preserve_rgb
+    }
+
+    /// How long the footage plays: its duration times Interpret Footage ▸ Loop.
+    pub fn looped_duration(&self) -> Tick {
+        Tick(self.duration.0.saturating_mul(self.loop_count.max(1) as i64))
+    }
+
+    /// Source time as the footage's timecode: its frame `frame` from Start Timecode
+    /// (`0:00:41:20`), as the Footage panel shows it.
+    pub fn timecode(&self, frame: i64) -> String {
+        effectcraft_time::format_timecode_ae(frame.saturating_add(self.start_timecode.unwrap_or(0)), self.frame_rate, false)
+    }
+
+    /// The data format of data footage: `json`, `csv` or `tsv` (from the file extension).
+    pub fn data_format(&self) -> Option<&'static str> {
+        if self.kind != FootageKind::Data {
+            return None;
+        }
+        let ext = std::path::Path::new(&self.path).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("").to_ascii_lowercase();
+        Some(match ext.as_str() {
+            "csv" => "csv",
+            "tsv" | "tab" => "tsv",
+            _ => "json",
+        })
+    }
+}
+
+/// A proxy: a stand-in file used instead of a footage item or composition (File ▸ Set Proxy /
+/// Create Proxy), when its Use Proxy switch is on and the render's Proxy Use allows it.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Proxy {
+    /// The proxy's footage (path, size, rate…; File ▸ Interpret Footage ▸ Proxy edits it).
+    pub footage: Footage,
+    /// Use Proxy (the Project panel's proxy indicator: filled = in use, hollow = set but off).
+    #[serde(default = "yes")]
+    pub enabled: bool,
+}
+
+/// A layer of a layered still (a Photoshop document, or a PDF / Illustrator / EPS file) used as
+/// footage (File ▸ Import ▸ Composition / Composition – Retain Layer Sizes, or Choose Layer).
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SourceLayer {
+    /// Layer record index in the file (bottom of the stack = 0).
+    pub index: u32,
+    pub name: String,
+    /// The footage is the layer's own bounds (Retain Layer Sizes) rather than the document size.
+    #[serde(default)]
+    pub layer_size: bool,
+    /// A Photoshop smart object: the unique id of its embedded file (linked layer data), which
+    /// is the footage instead of the layer's pixels.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub embedded: Option<String>,
+    /// A smart object with a perspective quad or a warp: the footage is its embedded file baked
+    /// as placed (warped and pinned to its corners) over the placed bounds in document space.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub placed: bool,
+}
+
+fn one() -> u32 {
+    1
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Solid {
+    pub color: [f32; 3],
+    pub width: u32,
+    pub height: u32,
+    pub pixel_aspect: f64,
+}
diff --git a/crates/project/src/item.rs b/crates/project/src/item.rs
new file mode 100644
index 000000000..1ef3d1f0a
--- /dev/null
+++ b/crates/project/src/item.rs
@@ -0,0 +1,310 @@
+use super::comp::Comp;
+use super::footage::{Footage, FootageKind, Proxy, Solid};
+use super::layer::LayerSource;
+use super::settings::{APP_VERSION, ProjectError, ProjectSettings, SCHEMA_VERSION, SavedView};
+use super::{Arc, BTreeMap, Deserialize, FrameRate, Label, Project, Serialize, Tick, file_check, limits};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct ItemId(pub u64);
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct LayerId(pub u64);
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type")]
+#[allow(clippy::large_enum_variant)]
+pub enum ItemKind {
+    Folder,
+    Comp(Arc<Comp>),
+    Footage(Footage),
+    Solid(Solid),
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Item {
+    pub id: ItemId,
+    pub name: String,
+    pub label: Label,
+    #[serde(default)]
+    pub comment: String,
+    /// Containing folder (None = project root).
+    #[serde(default)]
+    pub parent: Option<ItemId>,
+    pub kind: ItemKind,
+    /// The item's proxy (footage and compositions).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub proxy: Option<Box<Proxy>>,
+}
+
+impl Item {
+    pub fn type_name(&self) -> &'static str {
+        match &self.kind {
+            ItemKind::Folder => "Folder",
+            ItemKind::Comp(_) => "Composition",
+            ItemKind::Footage(f) => match f.kind {
+                FootageKind::Video => "Video",
+                FootageKind::Still => "Image",
+                FootageKind::Sequence => "Image Sequence",
+                FootageKind::Audio => "Audio",
+                FootageKind::Model => "3D Model",
+                FootageKind::Data => "Data",
+            },
+            ItemKind::Solid(_) => "Solid",
+        }
+    }
+    pub fn as_comp(&self) -> Option<&Comp> {
+        if let ItemKind::Comp(c) = &self.kind { Some(c) } else { None }
+    }
+    pub fn is_folder(&self) -> bool {
+        matches!(self.kind, ItemKind::Folder)
+    }
+    /// (width, height) for visual items.
+    pub fn dimensions(&self) -> Option<(u32, u32)> {
+        match &self.kind {
+            ItemKind::Comp(c) => Some((c.width, c.height)),
+            ItemKind::Footage(f) if f.has_video => Some((f.width, f.height)),
+            ItemKind::Solid(s) => Some((s.width, s.height)),
+            _ => None,
+        }
+    }
+    pub fn duration(&self) -> Option<Tick> {
+        match &self.kind {
+            ItemKind::Comp(c) => Some(c.duration),
+            ItemKind::Footage(f) if f.kind != FootageKind::Still => Some(f.looped_duration()),
+            _ => None,
+        }
+    }
+    pub fn frame_rate(&self) -> Option<FrameRate> {
+        match &self.kind {
+            ItemKind::Comp(c) => Some(c.frame_rate),
+            ItemKind::Footage(f) if f.kind == FootageKind::Video || f.kind == FootageKind::Sequence => Some(f.frame_rate),
+            _ => None,
+        }
+    }
+}
+
+impl Default for Project {
+    fn default() -> Self {
+        Project {
+            schema: SCHEMA_VERSION,
+            settings: ProjectSettings::default(),
+            items: BTreeMap::new(),
+            next_id: 1,
+            render_queue: Vec::new(),
+            render_templates: Default::default(),
+            render_prefs: Default::default(),
+        }
+    }
+}
+
+impl Project {
+    /// Some layer has an expression, which can read markers (`marker.key(1)`, `numKeys`,
+    /// `nearestKey`...). Only then do the markers of comps and layers affect what is rendered, so
+    /// frame caches ignore them otherwise.
+    pub fn reads_markers(&self) -> bool {
+        // Called for every frame identity and disk-cache key: stops at the first expression and
+        // builds no paths (`PropGroup::walk` formats one per node).
+        fn any_expr(g: &crate::PropGroup) -> bool {
+            g.children.iter().any(|c| match c {
+                crate::Node::Prop(p) => p.expr.is_some(),
+                crate::Node::Group(sub) => any_expr(sub),
+            })
+        }
+        self.comps().any(|(_, c)| c.layers.iter().any(|l| any_expr(&l.props)))
+    }
+
+    /// Allocate an id (items, layers and property uids share one counter).
+    pub fn alloc(&mut self) -> u64 {
+        let id = self.next_id;
+        self.next_id += 1;
+        id
+    }
+    pub fn item(&self, id: ItemId) -> Option<&Item> {
+        self.items.get(&id)
+    }
+    pub fn item_mut(&mut self, id: ItemId) -> Option<&mut Item> {
+        self.items.get_mut(&id)
+    }
+    pub fn comp(&self, id: ItemId) -> Option<&Comp> {
+        self.items.get(&id)?.as_comp()
+    }
+    /// A shared handle on a comp: a snapshot that costs a reference count, not a deep copy of
+    /// its layers (frontends hold one across a frame instead of cloning the comp).
+    pub fn comp_arc(&self, id: ItemId) -> Option<Arc<Comp>> {
+        match &self.items.get(&id)?.kind {
+            ItemKind::Comp(c) => Some(c.clone()),
+            _ => None,
+        }
+    }
+    /// Mutable comp (copy-on-write).
+    pub fn comp_mut(&mut self, id: ItemId) -> Option<&mut Comp> {
+        match &mut self.items.get_mut(&id)?.kind {
+            ItemKind::Comp(c) => Some(Arc::make_mut(c)),
+            _ => None,
+        }
+    }
+    /// Adds an item; its size, frame rate and the like are brought within [`limits`] first.
+    pub fn add_item(&mut self, name: &str, label: Label, parent: Option<ItemId>, mut kind: ItemKind) -> ItemId {
+        limits::repair_kind(name, &mut kind, &mut vec![]);
+        let id = ItemId(self.alloc());
+        self.items.insert(id, Item { id, name: name.into(), label, comment: String::new(), parent, kind, proxy: None });
+        id
+    }
+    /// Children of a folder (None = root), folders first then by name.
+    pub fn children(&self, folder: Option<ItemId>) -> Vec<&Item> {
+        let mut v: Vec<&Item> = self.items.values().filter(|i| i.parent == folder).collect();
+        v.sort_by(|a, b| b.is_folder().cmp(&a.is_folder()).then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase())));
+        v
+    }
+    pub fn comps(&self) -> impl Iterator<Item = (&ItemId, &Comp)> {
+        self.items.iter().filter_map(|(id, i)| i.as_comp().map(|c| (id, c)))
+    }
+    pub fn find_by_name(&self, name: &str) -> Option<&Item> {
+        self.items.values().find(|i| i.name == name)
+    }
+    /// A numbered name for a copy of `base` that no project item has (Edit ▸ Duplicate): its
+    /// trailing number is dropped and the lowest free one from 2 is added (`Comp 1` → `Comp 2`,
+    /// `Name` → `Name 2`, then `Name 3`). Items for which `ignore` holds don't count.
+    pub fn numbered_item_name(&self, base: &str, ignore: impl Fn(&Item) -> bool) -> String {
+        let stem = base.trim_end_matches(|c: char| c.is_ascii_digit()).trim_end();
+        let taken = |n: &str| self.items.values().any(|i| i.name == n && !ignore(i));
+        (2u64..).map(|k| format!("{stem} {k}")).find(|n| !taken(n)).unwrap_or_default()
+    }
+    /// `base` when no project item has that name, else the next free numbered name as
+    /// [`Project::numbered_item_name`] gives it. Items for which `ignore` holds don't count.
+    pub fn unique_item_name(&self, base: &str, ignore: impl Fn(&Item) -> bool) -> String {
+        if self.items.values().any(|i| i.name == base && !ignore(i)) { self.numbered_item_name(base, ignore) } else { base.to_string() }
+    }
+    pub fn folder_named(&self, name: &str) -> Option<ItemId> {
+        self.items.values().find(|i| i.is_folder() && i.name == name).map(|i| i.id)
+    }
+    /// Find the comp that contains `layer`.
+    pub fn comp_of_layer(&self, layer: LayerId) -> Option<ItemId> {
+        self.comps().find(|(_, c)| c.layer(layer).is_some()).map(|(id, _)| *id)
+    }
+    /// The compositions whose layers use `item` as their source (footage, solid, 3D model or
+    /// precomp), each with how many of its layers do, ordered by comp name then id. Only direct
+    /// layers count, as in After Effects' Project panel ("used 3 times"): a solid inside a precomp
+    /// is used by the precomp, not by the comps that nest it. The total is the sum of the counts.
+    pub fn item_users(&self, item: ItemId) -> Vec<(ItemId, usize)> {
+        let mut users: Vec<(ItemId, String, usize)> = self
+            .items
+            .iter()
+            .filter_map(|(id, it)| {
+                let comp = it.as_comp()?;
+                let n = comp.layers.iter().filter(|l| l.source.item() == Some(item)).count();
+                (n > 0).then(|| (*id, it.name.to_lowercase(), n))
+            })
+            .collect();
+        users.sort_by(|a, b| a.1.cmp(&b.1).then(a.0.cmp(&b.0)));
+        users.into_iter().map(|(id, _, n)| (id, n)).collect()
+    }
+    /// Whether comp `inner` is (transitively) nested inside comp `outer` (to prevent cycles).
+    pub fn comp_contains(&self, outer: ItemId, inner: ItemId) -> bool {
+        // A walk with a stack and a visited set rather than recursion (#1237): a damaged project
+        // may hold a precomp cycle that doesn't pass `inner` (recursion never ended), a long
+        // chain must not use up the call stack, and comps shared by many paths are visited once
+        // (recursion re-walked them for every path).
+        if outer == inner {
+            return true;
+        }
+        let mut seen = std::collections::HashSet::new();
+        let mut stack = vec![outer];
+        while let Some(id) = stack.pop() {
+            if !seen.insert(id) {
+                continue;
+            }
+            let Some(c) = self.comp(id) else { continue };
+            for l in &c.layers {
+                if let LayerSource::Comp { item } = l.source {
+                    if item == inner {
+                        return true;
+                    }
+                    if !seen.contains(&item) {
+                        stack.push(item);
+                    }
+                }
+            }
+        }
+        false
+    }
+    /// Make sure `next_id` exceeds every id in the project (after loading or merging).
+    pub fn fix_next_id(&mut self) {
+        let mut m = self.next_id;
+        for (id, it) in &self.items {
+            // Saturating: a damaged file's ids must not overflow (the import then refuses it).
+            m = m.max(id.0.saturating_add(1));
+            if let ItemKind::Comp(c) = &it.kind {
+                for l in &c.layers {
+                    m = m.max(l.id.0.saturating_add(1)).max(l.props.max_uid().saturating_add(1));
+                }
+            }
+        }
+        self.next_id = m;
+    }
+    /// Whether `other` holds the same content. An allocated id counts (an edit may hand it out
+    /// beyond the project, so it must stay taken). Shared compositions compare by pointer first,
+    /// so after a copy-on-write edit only the comps it touched are compared field by field.
+    pub fn same_content(&self, other: &Project) -> bool {
+        let item_eq = |a: &Item, b: &Item| {
+            let kind = match (&a.kind, &b.kind) {
+                (ItemKind::Comp(x), ItemKind::Comp(y)) => Arc::ptr_eq(x, y) || x == y,
+                (x, y) => x == y,
+            };
+            kind && a.id == b.id && a.name == b.name && a.label == b.label && a.comment == b.comment && a.parent == b.parent && a.proxy == b.proxy
+        };
+        self.schema == other.schema
+            && self.next_id == other.next_id
+            && self.settings == other.settings
+            && self.items.len() == other.items.len()
+            && self.items.iter().zip(&other.items).all(|((ka, a), (kb, b))| ka == kb && item_eq(a, b))
+            && self.render_queue == other.render_queue
+            && self.render_templates == other.render_templates
+            && self.render_prefs == other.render_prefs
+    }
+    /// The project file's text: the project with the version that wrote it (`savedBy`), checked
+    /// to read back, so a save never writes a file that can't be opened. Values JSON can't hold
+    /// (NaN or infinity, written as `null`, and nesting too deep to parse) are refused on every
+    /// save; debug builds also read the text back.
+    pub fn to_file_json(&self) -> Result<String, ProjectError> {
+        self.to_file_json_with_view(&SavedView::default(), false)
+    }
+    /// [`Project::to_file_json`] that also records the open compositions ([`SavedView`]), on one
+    /// line when `compact` (Settings ▸ Project ▸ Save Compact Project Files).
+    pub fn to_file_json_with_view(&self, view: &SavedView, compact: bool) -> Result<String, ProjectError> {
+        craft_ecproj_format::check_schema(self.schema)
+            .map_err(|e| ProjectError::Invalid(format!("the project can't be saved: it holds a value a project file can't store ({e})")))?;
+        let file = craft_ecproj_format::File::new(APP_VERSION, view, self);
+        file_check::check(&file)
+            .map_err(|e| ProjectError::Invalid(format!("the project can't be saved: it holds a value a project file can't store ({e})")))?;
+        let text =
+            if compact { file.to_json_compact() } else { file.to_json() }.map_err(|e| ProjectError::Invalid(format!("the project can't be saved: {e}")))?;
+        #[cfg(debug_assertions)]
+        Project::from_json(&text)
+            .map_err(|e| ProjectError::Invalid(format!("the project can't be saved: it holds a value a project file can't store ({e})")))?;
+        Ok(text)
+    }
+    pub fn to_json(&self) -> String {
+        serde_json::to_string_pretty(self).unwrap_or_default()
+    }
+    /// [`Project::to_json`] without indentation: smaller and faster (auto-saves).
+    pub fn to_json_compact(&self) -> String {
+        serde_json::to_string(self).unwrap_or_default()
+    }
+    pub fn from_json(s: &str) -> Result<Project, ProjectError> {
+        Project::from_json_repaired(s).map(|(p, _)| p)
+    }
+    /// [`Project::from_json`], also returning one line per value that was out of [`limits`] and
+    /// was corrected (a composition of a billion pixels, a zero frame rate…), so a corrupt or
+    /// hostile file still opens, within bounds, and the user can be told what changed.
+    pub fn from_json_repaired(s: &str) -> Result<(Project, Vec<String>), ProjectError> {
+        let mut p: Project = serde_json::from_str(s).map_err(|e| ProjectError::Invalid(e.to_string()))?;
+        craft_ecproj_format::check_schema(p.schema).map_err(|e| ProjectError::Invalid(e.to_string()))?;
+        p.fix_next_id();
+        let mut notes = vec![];
+        for item in p.items.values_mut() {
+            limits::repair_item(item, &mut notes);
+        }
+        Ok((p, notes))
+    }
+}
diff --git a/crates/project/src/layer.rs b/crates/project/src/layer.rs
new file mode 100644
index 000000000..3d7676b28
--- /dev/null
+++ b/crates/project/src/layer.rs
@@ -0,0 +1,390 @@
+use super::item::{ItemId, LayerId};
+use super::settings::Marker;
+use super::{BlendMode, Deserialize, Label, ParamUi, PropGroup, Property, Serialize, Tick};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum LightKind {
+    Parallel,
+    Spot,
+    #[default]
+    Point,
+    Ambient,
+    Environment,
+}
+
+impl LightKind {
+    pub const ALL: [LightKind; 5] = [LightKind::Parallel, LightKind::Spot, LightKind::Point, LightKind::Ambient, LightKind::Environment];
+    pub fn label(self) -> &'static str {
+        match self {
+            LightKind::Parallel => "Parallel",
+            LightKind::Spot => "Spot",
+            LightKind::Point => "Point",
+            LightKind::Ambient => "Ambient",
+            LightKind::Environment => "Environment",
+        }
+    }
+}
+
+/// A parametric 3D primitive (Layer ▸ New ▸ Cube/Sphere/Plane/Torus/Cone/Cylinder).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum PrimitiveKind {
+    #[default]
+    Cube,
+    Sphere,
+    Plane,
+    Torus,
+    Cone,
+    Cylinder,
+}
+
+impl PrimitiveKind {
+    pub const ALL: [PrimitiveKind; 6] =
+        [PrimitiveKind::Cube, PrimitiveKind::Sphere, PrimitiveKind::Plane, PrimitiveKind::Torus, PrimitiveKind::Cone, PrimitiveKind::Cylinder];
+    pub fn label(self) -> &'static str {
+        match self {
+            PrimitiveKind::Cube => "Cube",
+            PrimitiveKind::Sphere => "Sphere",
+            PrimitiveKind::Plane => "Plane",
+            PrimitiveKind::Torus => "Torus",
+            PrimitiveKind::Cone => "Cone",
+            PrimitiveKind::Cylinder => "Cylinder",
+        }
+    }
+    pub fn parse(s: &str) -> Option<PrimitiveKind> {
+        PrimitiveKind::ALL.into_iter().find(|k| k.label().eq_ignore_ascii_case(s.trim()))
+    }
+}
+
+/// What a layer shows.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum LayerSource {
+    /// Footage item (video, still, sequence, audio).
+    Footage {
+        item: ItemId,
+    },
+    /// Nested composition (precomp).
+    Comp {
+        item: ItemId,
+    },
+    /// Solid item (solids also back adjustment layers).
+    Solid {
+        item: ItemId,
+    },
+    Text,
+    Shape,
+    Null,
+    Camera,
+    Light {
+        kind: LightKind,
+    },
+    /// An imported 3D model (a footage item of kind [`FootageKind::Model`]; Advanced 3D).
+    Model {
+        item: ItemId,
+    },
+    /// A parametric 3D primitive (Advanced 3D).
+    Primitive {
+        kind: PrimitiveKind,
+    },
+}
+
+impl LayerSource {
+    pub fn item(&self) -> Option<ItemId> {
+        match self {
+            LayerSource::Footage { item } | LayerSource::Comp { item } | LayerSource::Solid { item } | LayerSource::Model { item } => Some(*item),
+            _ => None,
+        }
+    }
+    pub fn type_name(&self) -> &'static str {
+        match self {
+            LayerSource::Footage { .. } => "Footage",
+            LayerSource::Comp { .. } => "Composition",
+            LayerSource::Solid { .. } => "Solid",
+            LayerSource::Text => "Text",
+            LayerSource::Shape => "Shape",
+            LayerSource::Null => "Null",
+            LayerSource::Camera => "Camera",
+            LayerSource::Light { .. } => "Light",
+            LayerSource::Model { .. } => "3D Model",
+            LayerSource::Primitive { .. } => "3D Primitive",
+        }
+    }
+    /// Layers with pixels (cameras, lights and nulls have none).
+    pub fn is_av(&self) -> bool {
+        !matches!(self, LayerSource::Camera | LayerSource::Light { .. } | LayerSource::Null)
+    }
+    /// A 3D model or primitive layer (meshes; drawn by the Advanced 3D renderer).
+    pub fn is_model(&self) -> bool {
+        matches!(self, LayerSource::Model { .. } | LayerSource::Primitive { .. })
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Quality {
+    #[default]
+    Best,
+    Draft,
+    Wireframe,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Sampling {
+    #[default]
+    Bilinear,
+    Bicubic,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum FrameBlend {
+    #[default]
+    Off,
+    FrameMix,
+    PixelMotion,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Switches {
+    pub video: bool,
+    pub audio: bool,
+    pub solo: bool,
+    pub locked: bool,
+    pub shy: bool,
+    /// Collapse transformations (precomps) / continuously rasterize (vector layers).
+    pub collapse: bool,
+    pub quality: Quality,
+    pub sampling: Sampling,
+    pub effects: bool,
+    pub frame_blend: FrameBlend,
+    pub motion_blur: bool,
+    pub adjustment: bool,
+    pub three_d: bool,
+    pub guide: bool,
+}
+
+impl Default for Switches {
+    fn default() -> Self {
+        Switches {
+            video: true,
+            audio: true,
+            solo: false,
+            locked: false,
+            shy: false,
+            collapse: false,
+            quality: Quality::Best,
+            sampling: Sampling::Bilinear,
+            effects: true,
+            frame_blend: FrameBlend::Off,
+            motion_blur: false,
+            adjustment: false,
+            three_d: false,
+            guide: false,
+        }
+    }
+}
+
+// What a frame's pixels depend on. Caches key on it: the Audio, Lock and Shy switches and Hide
+// Shy Layers don't change pixels, so toggling them keeps cached frames (#103).
+
+impl Switches {
+    /// These switches with Audio, Lock and Shy at their defaults.
+    pub fn pixels(&self) -> Switches {
+        Switches { audio: true, locked: false, shy: false, ..self.clone() }
+    }
+}
+
+impl Layer {
+    /// Draws the same pixels as `o`: equal but for the Audio, Lock and Shy switches.
+    pub fn same_pixels(&self, o: &Layer) -> bool {
+        self.same_pixels_with(o, true)
+    }
+
+    /// [`Self::same_pixels`], with the markers counting only when `with_markers` (they are read by
+    /// expressions alone, so a project without any can edit them freely).
+    pub fn same_pixels_with(&self, o: &Layer, with_markers: bool) -> bool {
+        // Every field (no `..`: a new field must be considered here); the property tree last.
+        let Layer {
+            id,
+            name,
+            source,
+            label,
+            comment,
+            start_time,
+            in_point,
+            out_point,
+            stretch,
+            switches,
+            blend_mode,
+            preserve_transparency,
+            track_matte,
+            parent,
+            markers,
+            markers_locked,
+            auto_orient,
+            environment,
+            environment_background,
+            props,
+        } = self;
+        *id == o.id
+            && *name == o.name
+            && *source == o.source
+            && *label == o.label
+            && *comment == o.comment
+            && *start_time == o.start_time
+            && *in_point == o.in_point
+            && *out_point == o.out_point
+            && *stretch == o.stretch
+            && switches.pixels() == o.switches.pixels()
+            && *blend_mode == o.blend_mode
+            && *preserve_transparency == o.preserve_transparency
+            && *track_matte == o.track_matte
+            && *parent == o.parent
+            && (!with_markers || *markers == o.markers)
+            && *markers_locked == o.markers_locked
+            && *auto_orient == o.auto_orient
+            && *environment == o.environment
+            && *environment_background == o.environment_background
+            && *props == o.props
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum MatteKind {
+    #[default]
+    Alpha,
+    AlphaInverted,
+    Luma,
+    LumaInverted,
+}
+
+impl MatteKind {
+    pub const ALL: [MatteKind; 4] = [MatteKind::Alpha, MatteKind::AlphaInverted, MatteKind::Luma, MatteKind::LumaInverted];
+    pub fn label(self) -> &'static str {
+        match self {
+            MatteKind::Alpha => "Alpha Matte",
+            MatteKind::AlphaInverted => "Alpha Inverted Matte",
+            MatteKind::Luma => "Luma Matte",
+            MatteKind::LumaInverted => "Luma Inverted Matte",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct TrackMatte {
+    pub layer: LayerId,
+    pub kind: MatteKind,
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum AutoOrient {
+    #[default]
+    Off,
+    AlongPath,
+    TowardsCamera,
+    TowardsPointOfInterest,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Layer {
+    pub id: LayerId,
+    pub name: String,
+    pub source: LayerSource,
+    pub label: Label,
+    #[serde(default)]
+    pub comment: String,
+    /// Comp time where the layer's time 0 sits.
+    pub start_time: Tick,
+    /// Visible span in comp time.
+    pub in_point: Tick,
+    pub out_point: Tick,
+    /// Time stretch in percent (100 = normal, negative = reversed).
+    pub stretch: f64,
+    pub switches: Switches,
+    pub blend_mode: BlendMode,
+    #[serde(default)]
+    pub preserve_transparency: bool,
+    #[serde(default)]
+    pub track_matte: Option<TrackMatte>,
+    #[serde(default)]
+    pub parent: Option<LayerId>,
+    #[serde(default)]
+    pub markers: Vec<Marker>,
+    /// Layer ▸ Markers ▸ Lock Markers.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub markers_locked: bool,
+    #[serde(default)]
+    pub auto_orient: AutoOrient,
+    /// Layer ▸ Environment Layer: the layer is the environment (image-based light and
+    /// reflections) of Advanced 3D comps instead of being drawn.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub environment: bool,
+    /// Layer ▸ Light ▸ Create Environment Light Background Layer: the layer's (equirectangular)
+    /// image is drawn as the 3D scene's backdrop, seen through the camera, instead of as a card.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub environment_background: bool,
+    /// The property tree (Masks, Effects, Transform, Text, Contents, Camera/Light options…).
+    pub props: PropGroup,
+}
+
+impl Layer {
+    pub fn is_active_at(&self, t: Tick) -> bool {
+        t >= self.in_point && t < self.out_point
+    }
+
+    /// Layer time for a comp time (stretch-aware).
+    pub fn layer_time(&self, comp_t: Tick) -> Tick {
+        let d = comp_t - self.start_time;
+        if (self.stretch - 100.0).abs() < 1e-9 { d } else { Tick((d.0 as f64 * 100.0 / self.stretch) as i64) }
+    }
+
+    /// Comp time for a layer time.
+    pub fn comp_time(&self, layer_t: Tick) -> Tick {
+        if (self.stretch - 100.0).abs() < 1e-9 { self.start_time + layer_t } else { self.start_time + Tick((layer_t.0 as f64 * self.stretch / 100.0) as i64) }
+    }
+
+    pub fn transform(&self) -> Option<&PropGroup> {
+        self.props.sub("transform")
+    }
+
+    pub fn transform_mut(&mut self) -> Option<&mut PropGroup> {
+        self.props.sub_mut("transform")
+    }
+
+    pub fn effects(&self) -> Option<&PropGroup> {
+        self.props.sub("effects")
+    }
+
+    pub fn masks(&self) -> Option<&PropGroup> {
+        self.props.sub("masks")
+    }
+
+    /// The labels popup property `p` of this layer offers: Text Path Options ▸ Path lists None and
+    /// the layer's masks (value k = mask k), every other popup its own options. `None` when `p` is
+    /// not a popup.
+    pub fn popup_options<'a>(&'a self, p: &'a Property) -> Option<std::borrow::Cow<'a, [String]>> {
+        if self.props.prop("text/pathOptions/path").is_some_and(|q| q.uid == p.uid) {
+            let masks = self.masks().into_iter().flat_map(|m| m.groups().map(|g| g.name.clone()));
+            return Some(std::iter::once("None".to_string()).chain(masks).collect::<Vec<_>>().into());
+        }
+        match &p.ui {
+            ParamUi::Popup { options } => Some(options.as_slice().into()),
+            _ => None,
+        }
+    }
+
+    pub fn is_camera(&self) -> bool {
+        matches!(self.source, LayerSource::Camera)
+    }
+
+    pub fn is_light(&self) -> bool {
+        matches!(self.source, LayerSource::Light { .. })
+    }
+
+    /// The layer participates in 3D (3D switch, or cameras/lights which are always 3D).
+    pub fn is_3d(&self) -> bool {
+        self.switches.three_d || self.is_camera() || self.is_light()
+    }
+
+    pub fn has_video(&self) -> bool {
+        self.source.is_av() && self.switches.video
+    }
+}
diff --git a/crates/project/src/layers.rs b/crates/project/src/layers.rs
new file mode 100644
index 000000000..6119a5753
--- /dev/null
+++ b/crates/project/src/layers.rs
@@ -0,0 +1,209 @@
+//! A comp's layer stack with structural sharing.
+//!
+//! Every undoable edit keeps the previous project for undo, so the comp it touches is shared and
+//! `Arc::make_mut` copies it. With the layers stored inline that copy is the whole stack, every
+//! layer and every keyframe, so an edit costs time in proportion to the comp's size and a script
+//! that sets many keys in a big comp goes quadratic. Here each layer sits behind its own `Arc`:
+//! copying the stack copies pointers, and only the layer an edit actually changes is copied.
+//!
+//! The API mirrors the `Vec<Layer>` it replaces. Serialized form is identical (a list of layers).
+
+use std::ops::{Index, IndexMut};
+use std::sync::Arc;
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use super::layer::Layer;
+
+/// Layer #1 first (top of the stack).
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Layers(Vec<Arc<Layer>>);
+
+impl Layers {
+    pub const fn new() -> Self {
+        Self(Vec::new())
+    }
+    pub fn with_capacity(n: usize) -> Self {
+        Self(Vec::with_capacity(n))
+    }
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+    pub fn iter(&self) -> impl DoubleEndedIterator<Item = &Layer> + ExactSizeIterator + Clone {
+        self.0.iter().map(|l| &**l)
+    }
+    /// Mutable access to every layer: each one that is still shared with an undo state is copied,
+    /// so prefer [`Layers::get_mut`] (or `iter` to find, then `get_mut`) when only some change.
+    pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut Layer> + ExactSizeIterator {
+        self.0.iter_mut().map(Arc::make_mut)
+    }
+    /// Mutable access to just the layers `keep` accepts. `keep` reads each layer without copying
+    /// it; only the matching ones are copied (if shared). Use this, not `iter_mut().filter(..)`.
+    pub fn iter_mut_where<'a>(&'a mut self, mut keep: impl FnMut(&Layer) -> bool + 'a) -> impl Iterator<Item = &'a mut Layer> + 'a {
+        self.0.iter_mut().filter(move |l| keep(l)).map(Arc::make_mut)
+    }
+    /// The first layer `pred` accepts, copied only if it is that one. Use this, not `iter_mut().find(..)`.
+    pub fn find_mut(&mut self, mut pred: impl FnMut(&Layer) -> bool) -> Option<&mut Layer> {
+        self.0.iter_mut().find(|l| pred(l)).map(Arc::make_mut)
+    }
+    pub fn get(&self, i: usize) -> Option<&Layer> {
+        self.0.get(i).map(|l| &**l)
+    }
+    pub fn get_mut(&mut self, i: usize) -> Option<&mut Layer> {
+        self.0.get_mut(i).map(Arc::make_mut)
+    }
+    pub fn first(&self) -> Option<&Layer> {
+        self.get(0)
+    }
+    pub fn last(&self) -> Option<&Layer> {
+        self.0.last().map(|l| &**l)
+    }
+    pub fn first_mut(&mut self) -> Option<&mut Layer> {
+        self.get_mut(0)
+    }
+    pub fn last_mut(&mut self) -> Option<&mut Layer> {
+        self.0.last_mut().map(Arc::make_mut)
+    }
+    pub fn push(&mut self, l: Layer) {
+        self.0.push(Arc::new(l));
+    }
+    pub fn insert(&mut self, i: usize, l: Layer) {
+        self.0.insert(i, Arc::new(l));
+    }
+    pub fn remove(&mut self, i: usize) -> Layer {
+        Arc::unwrap_or_clone(self.0.remove(i))
+    }
+    pub fn pop(&mut self) -> Option<Layer> {
+        self.0.pop().map(Arc::unwrap_or_clone)
+    }
+    pub fn retain(&mut self, mut f: impl FnMut(&Layer) -> bool) {
+        self.0.retain(|l| f(l));
+    }
+    pub fn swap(&mut self, a: usize, b: usize) {
+        self.0.swap(a, b);
+    }
+    pub fn truncate(&mut self, n: usize) {
+        self.0.truncate(n);
+    }
+    pub fn clear(&mut self) {
+        self.0.clear();
+    }
+    pub fn reverse(&mut self) {
+        self.0.reverse();
+    }
+    pub fn sort_by_key<K: Ord>(&mut self, mut f: impl FnMut(&Layer) -> K) {
+        self.0.sort_by_key(|l| f(l));
+    }
+    pub fn sort_by(&mut self, mut f: impl FnMut(&Layer, &Layer) -> std::cmp::Ordering) {
+        self.0.sort_by(|a, b| f(a, b));
+    }
+    pub fn rotate_left(&mut self, n: usize) {
+        self.0.rotate_left(n);
+    }
+    pub fn rotate_right(&mut self, n: usize) {
+        self.0.rotate_right(n);
+    }
+    /// `layers[range].rotate_left(n)` (a slice of `Arc`s can't be handed out as a `&mut [Layer]`).
+    pub fn rotate_range_left(&mut self, r: impl std::slice::SliceIndex<[Arc<Layer>], Output = [Arc<Layer>]>, n: usize) {
+        if let Some(s) = self.0.get_mut(r) {
+            s.rotate_left(n);
+        }
+    }
+    pub fn rotate_range_right(&mut self, r: impl std::slice::SliceIndex<[Arc<Layer>], Output = [Arc<Layer>]>, n: usize) {
+        if let Some(s) = self.0.get_mut(r) {
+            s.rotate_right(n);
+        }
+    }
+    pub fn split_off(&mut self, at: usize) -> Layers {
+        Layers(self.0.split_off(at))
+    }
+    pub fn append(&mut self, other: &mut Layers) {
+        self.0.append(&mut other.0);
+    }
+    /// Remove a range of layers and return them (owned).
+    pub fn drain(&mut self, r: impl std::ops::RangeBounds<usize>) -> std::vec::IntoIter<Layer> {
+        self.0.drain(r).map(Arc::unwrap_or_clone).collect::<Vec<_>>().into_iter()
+    }
+    /// Whether `self` and `other` hold the very same (unchanged) layer at `i`: a cheap "did this
+    /// layer change" test between two project states.
+    pub fn same_at(&self, other: &Layers, i: usize) -> bool {
+        matches!((self.0.get(i), other.0.get(i)), (Some(a), Some(b)) if Arc::ptr_eq(a, b))
+    }
+    /// The shared layers themselves, for parallel iteration (`rayon` over `&[Arc<Layer>]`).
+    pub fn as_arcs(&self) -> &[Arc<Layer>] {
+        &self.0
+    }
+    pub fn to_vec(&self) -> Vec<Layer> {
+        self.iter().cloned().collect()
+    }
+}
+
+impl Index<usize> for Layers {
+    type Output = Layer;
+    fn index(&self, i: usize) -> &Layer {
+        &self.0[i]
+    }
+}
+
+impl IndexMut<usize> for Layers {
+    fn index_mut(&mut self, i: usize) -> &mut Layer {
+        Arc::make_mut(&mut self.0[i])
+    }
+}
+
+impl From<Vec<Layer>> for Layers {
+    fn from(v: Vec<Layer>) -> Self {
+        Self(v.into_iter().map(Arc::new).collect())
+    }
+}
+
+impl FromIterator<Layer> for Layers {
+    fn from_iter<I: IntoIterator<Item = Layer>>(it: I) -> Self {
+        Self(it.into_iter().map(Arc::new).collect())
+    }
+}
+
+impl Extend<Layer> for Layers {
+    fn extend<I: IntoIterator<Item = Layer>>(&mut self, it: I) {
+        self.0.extend(it.into_iter().map(Arc::new));
+    }
+}
+
+impl IntoIterator for Layers {
+    type Item = Layer;
+    type IntoIter = std::iter::Map<std::vec::IntoIter<Arc<Layer>>, fn(Arc<Layer>) -> Layer>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter().map(Arc::unwrap_or_clone as fn(Arc<Layer>) -> Layer)
+    }
+}
+
+impl<'a> IntoIterator for &'a Layers {
+    type Item = &'a Layer;
+    type IntoIter = std::iter::Map<std::slice::Iter<'a, Arc<Layer>>, fn(&'a Arc<Layer>) -> &'a Layer>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter().map(|l| &**l)
+    }
+}
+
+impl<'a> IntoIterator for &'a mut Layers {
+    type Item = &'a mut Layer;
+    type IntoIter = std::iter::Map<std::slice::IterMut<'a, Arc<Layer>>, fn(&'a mut Arc<Layer>) -> &'a mut Layer>;
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter_mut().map(Arc::make_mut)
+    }
+}
+
+impl Serialize for Layers {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        s.collect_seq(self.iter())
+    }
+}
+
+impl<'de> Deserialize<'de> for Layers {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        Vec::<Layer>::deserialize(d).map(Layers::from)
+    }
+}
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 822fc7f75..6cfbda344 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -1,8 +1,8 @@
 //! The EffectCraft document model.
 //!
 //! `Project` → items (folders, compositions, footage, solids) → `Comp` → `Layer` → property tree
-//! ([`props`]). Compositions sit behind `Arc` so undo snapshots share everything that did not
-//! change.
+//! ([`props`]). Compositions, and each layer within them ([`Layers`]), sit behind `Arc` so undo
+//! snapshots share everything that did not change.
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
@@ -29,1393 +29,22 @@ use serde::{Deserialize, Serialize};
 pub use effectcraft_keyframe as keyframe;
 pub use effectcraft_keyframe::{Keyframe, Value};
 
-/// The project file schema. 2: effects on layers without a source rectangle (shape, text)
-/// measure positions from the top-left of their comp-sized bounds (effect space), not from
-/// the layer's origin; projects from schema 1 are converted when opened (#227).
-pub const SCHEMA_VERSION: u32 = 2;
-
-/// The first schema in which effect positions are in effect space (see [`SCHEMA_VERSION`]).
-pub const SCHEMA_EFFECT_SPACE: u32 = 2;
-
-/// The EffectCraft version, written into project files as `savedBy`.
-pub const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
-
-/// The EffectCraft version that wrote a project file (its `savedBy`), when it says.
-pub fn saved_by(text: &str) -> Option<String> {
-    #[derive(Deserialize)]
-    struct Meta {
-        #[serde(rename = "savedBy", default)]
-        saved_by: Option<String>,
-    }
-    serde_json::from_str::<Meta>(text).ok()?.saved_by
-}
-
-/// The compositions that were open when a project file was saved and their current times
-/// (`activeComp`, `openComps` and `compTimes` next to `savedBy`), so it reopens where it was left
-/// (#748, #1714). Editor state rather than project
-/// content: opening a comp doesn't make the project unsaved, and it isn't part of
-/// [`Project`]. Older files have none; older versions ignore it.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SavedView {
-    /// The comp shown in the viewer and the Timeline.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub active_comp: Option<ItemId>,
-    /// The open comps (Timeline tabs), in tab order.
-    #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub open_comps: Vec<ItemId>,
-    /// Each comp's current time, so a project reopens on the frame it was saved at rather than
-    /// at 0, where its layers may not have started yet (#1714).
-    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
-    pub comp_times: BTreeMap<ItemId, Tick>,
-}
-
-/// The view a project file was saved with ([`SavedView`]); empty for older files. Values that
-/// aren't ids are ignored (whether an id still names a comp is up to the caller).
-pub fn saved_view(text: &str) -> SavedView {
-    #[derive(Deserialize)]
-    struct Meta {
-        #[serde(rename = "activeComp", default)]
-        active_comp: Option<serde_json::Value>,
-        #[serde(rename = "openComps", default)]
-        open_comps: Option<serde_json::Value>,
-        #[serde(rename = "compTimes", default)]
-        comp_times: Option<serde_json::Value>,
-    }
-    let Ok(m) = serde_json::from_str::<Meta>(text) else { return SavedView::default() };
-    SavedView {
-        active_comp: m.active_comp.as_ref().and_then(serde_json::Value::as_u64).map(ItemId),
-        open_comps: m
-            .open_comps
-            .as_ref()
-            .and_then(serde_json::Value::as_array)
-            .map_or_else(Vec::new, |a| a.iter().filter_map(serde_json::Value::as_u64).map(ItemId).collect()),
-        comp_times: m
-            .comp_times
-            .as_ref()
-            .and_then(serde_json::Value::as_object)
-            .map_or_else(BTreeMap::new, |o| o.iter().filter_map(|(k, v)| Some((ItemId(k.parse().ok()?), Tick(v.as_i64()?)))).collect()),
-    }
-}
-
-/// Whether version `a` (`major.minor.patch`, pre-release suffixes ignored) is newer than `b`.
-pub fn is_newer_version(a: &str, b: &str) -> bool {
-    let parts = |v: &str| -> [u64; 3] {
-        let mut n = v.split(['-', '+']).next().unwrap_or("").split('.').map(|x| x.parse().unwrap_or(0));
-        [n.next().unwrap_or(0), n.next().unwrap_or(0), n.next().unwrap_or(0)]
-    };
-    parts(a) > parts(b)
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-pub struct ItemId(pub u64);
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-pub struct LayerId(pub u64);
-
-#[derive(Debug, thiserror::Error)]
-pub enum ProjectError {
-    #[error("no item {0:?}")]
-    NoItem(ItemId),
-    #[error("item {0:?} is not a composition")]
-    NotComp(ItemId),
-    #[error("no layer {0:?}")]
-    NoLayer(LayerId),
-    #[error("no property `{0}`")]
-    NoProperty(String),
-    #[error("{0}")]
-    Invalid(String),
-}
-
-/// Project bit depth.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum BitDepth {
-    #[default]
-    Bpc8,
-    Bpc16,
-    Bpc32,
-}
-
-impl BitDepth {
-    pub fn label(self) -> &'static str {
-        match self {
-            BitDepth::Bpc8 => "8 bpc",
-            BitDepth::Bpc16 => "16 bpc",
-            BitDepth::Bpc32 => "32 bpc",
-        }
-    }
-    pub fn next(self) -> BitDepth {
-        match self {
-            BitDepth::Bpc8 => BitDepth::Bpc16,
-            BitDepth::Bpc16 => BitDepth::Bpc32,
-            BitDepth::Bpc32 => BitDepth::Bpc8,
-        }
-    }
-    pub fn is_float(self) -> bool {
-        self == BitDepth::Bpc32
-    }
-    /// Quantisation levels per channel of the integer depths (8 bpc: 255; 16 bpc: 32768, After
-    /// Effects' "15 + 1" bit range), `None` for 32 bpc float.
-    pub fn levels(self) -> Option<f32> {
-        match self {
-            BitDepth::Bpc8 => Some(255.0),
-            BitDepth::Bpc16 => Some(32768.0),
-            BitDepth::Bpc32 => None,
-        }
-    }
-    pub fn bits(self) -> u32 {
-        match self {
-            BitDepth::Bpc8 => 8,
-            BitDepth::Bpc16 => 16,
-            BitDepth::Bpc32 => 32,
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum TimeDisplayStyle {
-    #[default]
-    Timecode,
-    Frames,
-    /// Feet + Frames, 35 mm film (16 frames per foot).
-    Feet35,
-    /// Feet + Frames, 16 mm film (40 frames per foot).
-    Feet16,
-}
-
-impl TimeDisplayStyle {
-    /// Frames per foot of the Feet + Frames styles.
-    pub fn frames_per_foot(self) -> Option<i64> {
-        match self {
-            TimeDisplayStyle::Feet35 => Some(16),
-            TimeDisplayStyle::Feet16 => Some(40),
-            _ => None,
-        }
-    }
-    pub fn id(self) -> &'static str {
-        match self {
-            TimeDisplayStyle::Timecode => "timecode",
-            TimeDisplayStyle::Frames => "frames",
-            TimeDisplayStyle::Feet35 => "feet35",
-            TimeDisplayStyle::Feet16 => "feet16",
-        }
-    }
-    pub fn parse(s: &str) -> Option<TimeDisplayStyle> {
-        let k: String = s.chars().filter(char::is_ascii_alphanumeric).collect::<String>().to_ascii_lowercase();
-        match k.as_str() {
-            "timecode" => Some(TimeDisplayStyle::Timecode),
-            "frames" => Some(TimeDisplayStyle::Frames),
-            "feet35" | "feetframes" | "feetandframes" | "feet35mm" | "35mm" | "feetframes35mm" => Some(TimeDisplayStyle::Feet35),
-            "feet16" | "feet16mm" | "16mm" | "feetframes16mm" => Some(TimeDisplayStyle::Feet16),
-            _ => None,
-        }
-    }
-}
-
-/// Project Settings ▸ Color ▸ Color Engine.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum ColorEngine {
-    /// Built-in colour management (ICC-style working spaces).
-    #[default]
-    Adobe,
-    /// OCIO managed, with the built-in configuration (ACES working spaces).
-    Ocio,
-}
-
-/// Project Settings ▸ Color ▸ HDR: how over-range (HDR) values reach a standard-dynamic-range
-/// display or output.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum HdrMode {
-    /// Values above 1.0 clip.
-    #[default]
-    Clip,
-    /// Highlights above 80% are companded (an exponential knee) into the remaining range.
-    Compand,
-    /// Extended Reinhard tone mapping of luminance (white at 4.0).
-    ToneMap,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct ProjectSettings {
-    pub bit_depth: BitDepth,
-    /// Linearize Working Space: the working space uses linear light (1.0 gamma) for everything
-    /// (sources, effects, blending). Needs a working space.
-    pub linearize: bool,
-    /// Working Space (colour management). `None` = no colour management.
-    #[serde(default)]
-    pub working_space: Option<ColorSpace>,
-    /// Blend Colors Using 1.0 Gamma: layers blend in linear light (sources and effects stay in
-    /// the working space's encoding).
-    #[serde(default)]
-    pub blend_linear: bool,
-    pub time_display: TimeDisplayStyle,
-    /// Frame numbering starts at 0 (or 1).
-    pub frame_start: i64,
-    pub audio_sample_rate: u32,
-    /// Video Rendering and Effects ▸ Use: Mercury GPU Acceleration (`true`, the default; used
-    /// when a GPU adapter exists) or Mercury Software Only (`false`, the CPU compositor).
-    #[serde(default = "yes")]
-    pub gpu_acceleration: bool,
-    /// The project's comment (Metadata panel).
-    #[serde(default, skip_serializing_if = "String::is_empty")]
-    pub comment: String,
-    /// Color Engine (Adobe-style built-in or OCIO with ACES working spaces).
-    #[serde(default)]
-    pub color_engine: ColorEngine,
-    /// HDR handling for standard-dynamic-range output (display and renders).
-    #[serde(default)]
-    pub hdr: HdrMode,
-    /// The space the top-level comp is output in (renders and the viewer's source). `None` =
-    /// sRGB; Rec. 2100 PQ / HLG give HDR output.
-    #[serde(default)]
-    pub output_space: Option<ColorSpace>,
-    /// Working Gamma, 2.2 or 2.4 (`app.project.workingGamma`): with no working space, the curve
-    /// Interpret As Linear Light footage is encoded with and Blend Colors Using 1.0 Gamma
-    /// linearizes with: the sRGB curve at 2.2, a pure 2.4 power curve at 2.4. Ignored with a
-    /// working space (as in After Effects).
-    #[serde(default = "gamma_22")]
-    pub working_gamma: f64,
-}
-
-fn gamma_22() -> f64 {
-    2.2
-}
-
-impl ProjectSettings {
-    /// Working Gamma is 2.4 (anything else reads as 2.2).
-    pub fn working_gamma_24(&self) -> bool {
-        (self.working_gamma - 2.4).abs() < 0.05
-    }
-}
-
-impl Default for ProjectSettings {
-    fn default() -> Self {
-        ProjectSettings {
-            bit_depth: BitDepth::Bpc8,
-            linearize: false,
-            working_space: None,
-            blend_linear: false,
-            time_display: TimeDisplayStyle::Timecode,
-            frame_start: 0,
-            audio_sample_rate: 48_000,
-            gpu_acceleration: true,
-            comment: String::new(),
-            color_engine: ColorEngine::Adobe,
-            hdr: HdrMode::Clip,
-            output_space: None,
-            working_gamma: 2.2,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-pub struct Marker {
-    pub time: Tick,
-    #[serde(default)]
-    pub duration: Tick,
-    #[serde(default)]
-    pub comment: String,
-    #[serde(default)]
-    pub label: Label,
-    #[serde(default)]
-    pub chapter: String,
-    #[serde(default)]
-    pub url: String,
-    #[serde(default)]
-    pub protected: bool,
-    /// Web link frame target (`_blank`, a frame name…).
-    #[serde(default, skip_serializing_if = "String::is_empty")]
-    pub frame_target: String,
-    /// Flash/video cue point (Event or Navigation) with name and parameters.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub cue_point: Option<CuePoint>,
-}
-
-/// A marker's cue point (Composition/Layer Marker dialog ▸ Cue Point).
-#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
-pub struct CuePoint {
-    pub name: String,
-    /// Navigation (true) or Event cue point.
-    #[serde(default)]
-    pub navigation: bool,
-    /// (name, value) parameter pairs.
-    #[serde(default)]
-    pub params: Vec<(String, String)>,
-}
-
-/// 3D renderer of a composition.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Renderer {
-    #[default]
-    Classic3D,
-    Advanced3D,
-}
-
-/// A composition's Resolution (the Composition panel's Resolution/Down Sample Factor popup, View ▸
-/// Resolution): how many of its pixels the viewer renders. Auto follows the magnification.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Resolution {
-    #[default]
-    Auto,
-    Full,
-    Half,
-    Third,
-    Quarter,
-    /// View ▸ Resolution ▸ Custom: render every n-th pixel (2..=40).
-    Custom(u8),
-}
-
-impl Resolution {
-    pub const ALL: [Resolution; 5] = [Resolution::Auto, Resolution::Full, Resolution::Half, Resolution::Third, Resolution::Quarter];
-    pub fn label(self) -> &'static str {
-        match self {
-            Resolution::Auto => "Auto",
-            Resolution::Full => "Full",
-            Resolution::Half => "Half",
-            Resolution::Third => "Third",
-            Resolution::Quarter => "Quarter",
-            Resolution::Custom(_) => "Custom",
-        }
-    }
-    pub fn is_auto(&self) -> bool {
-        *self == Resolution::Auto
-    }
-    /// The down-sample factor (render every n-th pixel); `None` for Auto.
-    pub fn factor(self) -> Option<u8> {
-        match self {
-            Resolution::Auto => None,
-            Resolution::Full => Some(1),
-            Resolution::Half => Some(2),
-            Resolution::Third => Some(3),
-            Resolution::Quarter => Some(4),
-            Resolution::Custom(n) => Some(n),
-        }
-    }
-    /// The resolution that renders every `n`-th pixel (1 = Full … 4 = Quarter; up to 40).
-    pub fn from_factor(n: u64) -> Resolution {
-        match n.clamp(1, 40) {
-            1 => Resolution::Full,
-            2 => Resolution::Half,
-            3 => Resolution::Third,
-            4 => Resolution::Quarter,
-            n => Resolution::Custom(n as u8),
-        }
-    }
-    /// Render scale for a viewer magnification (and display pixel density).
-    pub fn scale(self, zoom: f32, ppp: f32) -> f64 {
-        match self.factor() {
-            Some(n) => 1.0 / f64::from(n.clamp(1, 40)),
-            // As in After Effects, Auto renders the pixels the magnification needs: the coarsest
-            // whole factor that still gives every screen pixel a rendered one (Full above 50 %,
-            // Half down to 33.3 %, Third down to 25 %, Quarter below), never fewer (#417).
-            None => {
-                let n = (1.0 / (zoom * ppp) as f64 + 1e-3).floor();
-                if n >= 1.0 { 1.0 / n.min(4.0) } else { 1.0 }
-            }
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Comp {
-    pub width: u32,
-    pub height: u32,
-    pub pixel_aspect: f64,
-    pub frame_rate: FrameRate,
-    pub duration: Tick,
-    /// Start timecode/frame shown for time 0.
-    pub display_start: Tick,
-    pub background: [f32; 3],
-    pub work_area: (Tick, Tick),
-    /// Layer #1 first (top of the stack).
-    pub layers: Vec<Layer>,
-    #[serde(default)]
-    pub markers: Vec<Marker>,
-    pub shutter_angle: f64,
-    pub shutter_phase: f64,
-    /// Samples Per Frame: the minimum motion-blur samples (and the count for 3D layers).
-    pub motion_blur_samples: u32,
-    /// Adaptive Sample Limit (Composition Settings ▸ Advanced): the most samples a 2D layer gets
-    /// when it moves far within the shutter.
-    #[serde(default = "adaptive_limit_default")]
-    pub motion_blur_adaptive_limit: u32,
-    #[serde(default)]
-    pub renderer: Renderer,
-    /// Comp switches (timeline toolbar).
-    #[serde(default)]
-    pub hide_shy: bool,
-    #[serde(default = "yes")]
-    pub enable_motion_blur: bool,
-    #[serde(default = "yes")]
-    pub enable_frame_blending: bool,
-    #[serde(default)]
-    pub draft_3d: bool,
-    /// Composition Settings ▸ Advanced ▸ Preserve frame rate when nested or in render queue:
-    /// nested in another comp, or rendered at another rate, it shows only its own frames.
-    #[serde(default)]
-    pub preserve_frame_rate: bool,
-    /// Composition Settings ▸ Advanced ▸ Preserve resolution when nested: nested in a comp
-    /// previewed at a lower resolution, it still renders at full size.
-    #[serde(default)]
-    pub preserve_resolution: bool,
-    #[serde(default)]
-    pub poster_time: Tick,
-    /// Global Light for layer styles (Layer ▸ Layer Styles ▸ Blending Options).
-    #[serde(default)]
-    pub global_light: styles::GlobalLight,
-    /// Viewer guides (View ▸ Add Guide…), in comp pixels.
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub guides: Vec<Guide>,
-    /// Essential Graphics: the controls this comp exposes to instances and templates.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub essential: Option<essential::EssentialGraphics>,
-    /// The Composition panel's Resolution, saved with the project as in After Effects. It changes
-    /// what the viewer renders, not the comp's pixels ([`Comp::same_pixels`]), and stays out of
-    /// the undo history.
-    #[serde(default, skip_serializing_if = "Resolution::is_auto")]
-    pub resolution: Resolution,
-}
-
-/// A viewer guide line: vertical guides sit at an x position, horizontal ones at a y position.
-#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Guide {
-    pub vertical: bool,
-    /// Comp pixels, or percent of the comp's width (vertical) / height (horizontal) when
-    /// [`Guide::percent`] is set.
-    pub position: f64,
-    /// A percentage guide (After Effects 26.5): `position` is a percent of the comp's size, so the
-    /// guide keeps its relative place when the comp is resized. Absent in older projects.
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub percent: bool,
-}
-
-impl Guide {
-    /// The comp's extent along this guide's axis, never zero.
-    fn extent(&self, width: u32, height: u32) -> f64 {
-        f64::from(if self.vertical { width } else { height }).max(1.0)
-    }
-
-    /// The guide's position in comp pixels for a comp of this size.
-    pub fn px(&self, width: u32, height: u32) -> f64 {
-        if self.percent { self.position / 100.0 * self.extent(width, height) } else { self.position }
-    }
-
-    /// Place the guide at `px` comp pixels, keeping its unit.
-    pub fn set_px(&mut self, px: f64, width: u32, height: u32) {
-        self.position = if self.percent { px / self.extent(width, height) * 100.0 } else { px };
-    }
-
-    /// Switch between pixels and percent without moving the guide on the comp.
-    pub fn set_percent(&mut self, percent: bool, width: u32, height: u32) {
-        let px = self.px(width, height);
-        self.percent = percent;
-        self.set_px(px, width, height);
-    }
-}
-
-fn yes() -> bool {
-    true
-}
-
-fn adaptive_limit_default() -> u32 {
-    128
-}
-
-impl Comp {
-    pub fn new(width: u32, height: u32, frame_rate: FrameRate, duration: Tick) -> Comp {
-        Comp {
-            width,
-            height,
-            pixel_aspect: 1.0,
-            frame_rate,
-            duration,
-            display_start: Tick::ZERO,
-            background: [0.0, 0.0, 0.0],
-            work_area: (Tick::ZERO, duration),
-            layers: vec![],
-            markers: vec![],
-            shutter_angle: 180.0,
-            shutter_phase: -90.0,
-            motion_blur_samples: 16,
-            motion_blur_adaptive_limit: 128,
-            renderer: Renderer::Classic3D,
-            hide_shy: false,
-            enable_motion_blur: true,
-            enable_frame_blending: true,
-            draft_3d: false,
-            preserve_frame_rate: false,
-            preserve_resolution: false,
-            poster_time: Tick::ZERO,
-            guides: vec![],
-            global_light: styles::GlobalLight::default(),
-            essential: None,
-            resolution: Resolution::Auto,
-        }
-    }
-    /// Whether the composition has a frame at its time `t`: nested, it shows nothing before it
-    /// starts or after it ends (a precomp layer trimmed or remapped past it).
-    pub fn covers(&self, t: Tick) -> bool {
-        t >= Tick::ZERO && t < self.duration
-    }
-    /// A new, empty composition with this one's settings (frame rate, pixel aspect, background,
-    /// motion blur, frame blending and the 3D renderer), as Pre-compose makes.
-    pub fn nested_like(&self, width: u32, height: u32, duration: Tick) -> Comp {
-        Comp {
-            pixel_aspect: self.pixel_aspect,
-            background: self.background,
-            shutter_angle: self.shutter_angle,
-            shutter_phase: self.shutter_phase,
-            motion_blur_samples: self.motion_blur_samples,
-            motion_blur_adaptive_limit: self.motion_blur_adaptive_limit,
-            renderer: self.renderer,
-            enable_motion_blur: self.enable_motion_blur,
-            enable_frame_blending: self.enable_frame_blending,
-            preserve_frame_rate: self.preserve_frame_rate,
-            preserve_resolution: self.preserve_resolution,
-            ..Comp::new(width, height, self.frame_rate, duration)
-        }
-    }
-    pub fn layer(&self, id: LayerId) -> Option<&Layer> {
-        self.layers.iter().find(|l| l.id == id)
-    }
-    pub fn layer_mut(&mut self, id: LayerId) -> Option<&mut Layer> {
-        self.layers.iter_mut().find(|l| l.id == id)
-    }
-    /// 1-based layer number (#) of a layer.
-    pub fn index_of(&self, id: LayerId) -> Option<usize> {
-        self.layers.iter().position(|l| l.id == id).map(|i| i + 1)
-    }
-    pub fn layer_by_name(&self, name: &str) -> Option<&Layer> {
-        self.layers.iter().find(|l| l.name == name)
-    }
-    pub fn frame_duration(&self) -> Tick {
-        self.frame_rate.frame_duration()
-    }
-    /// Any 3D layer present (camera/lights or a 3D switch).
-    pub fn has_3d(&self) -> bool {
-        self.layers.iter().any(|l| l.switches.three_d || matches!(l.source, LayerSource::Camera | LayerSource::Light { .. }))
-    }
-    /// The active camera at `t`: the topmost enabled camera layer active at that time.
-    pub fn active_camera(&self, t: Tick) -> Option<&Layer> {
-        self.layers.iter().find(|l| matches!(l.source, LayerSource::Camera) && l.switches.video && l.is_active_at(t))
-    }
-    /// Unique layer name with a numeric suffix (`Shape Layer 2`).
-    pub fn unique_layer_name(&self, base: &str) -> String {
-        if !self.layers.iter().any(|l| l.name == base) {
-            return base.to_string();
-        }
-        let stem = base.trim_end_matches(|c: char| c.is_ascii_digit()).trim_end();
-        (2..).map(|i| format!("{stem} {i}")).find(|n| !self.layers.iter().any(|l| &l.name == n)).unwrap_or_default()
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum LightKind {
-    Parallel,
-    Spot,
-    #[default]
-    Point,
-    Ambient,
-    Environment,
-}
-
-impl LightKind {
-    pub const ALL: [LightKind; 5] = [LightKind::Parallel, LightKind::Spot, LightKind::Point, LightKind::Ambient, LightKind::Environment];
-    pub fn label(self) -> &'static str {
-        match self {
-            LightKind::Parallel => "Parallel",
-            LightKind::Spot => "Spot",
-            LightKind::Point => "Point",
-            LightKind::Ambient => "Ambient",
-            LightKind::Environment => "Environment",
-        }
-    }
-}
-
-/// A parametric 3D primitive (Layer ▸ New ▸ Cube/Sphere/Plane/Torus/Cone/Cylinder).
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum PrimitiveKind {
-    #[default]
-    Cube,
-    Sphere,
-    Plane,
-    Torus,
-    Cone,
-    Cylinder,
-}
-
-impl PrimitiveKind {
-    pub const ALL: [PrimitiveKind; 6] =
-        [PrimitiveKind::Cube, PrimitiveKind::Sphere, PrimitiveKind::Plane, PrimitiveKind::Torus, PrimitiveKind::Cone, PrimitiveKind::Cylinder];
-    pub fn label(self) -> &'static str {
-        match self {
-            PrimitiveKind::Cube => "Cube",
-            PrimitiveKind::Sphere => "Sphere",
-            PrimitiveKind::Plane => "Plane",
-            PrimitiveKind::Torus => "Torus",
-            PrimitiveKind::Cone => "Cone",
-            PrimitiveKind::Cylinder => "Cylinder",
-        }
-    }
-    pub fn parse(s: &str) -> Option<PrimitiveKind> {
-        PrimitiveKind::ALL.into_iter().find(|k| k.label().eq_ignore_ascii_case(s.trim()))
-    }
-}
-
-/// What a layer shows.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type")]
-pub enum LayerSource {
-    /// Footage item (video, still, sequence, audio).
-    Footage {
-        item: ItemId,
-    },
-    /// Nested composition (precomp).
-    Comp {
-        item: ItemId,
-    },
-    /// Solid item (solids also back adjustment layers).
-    Solid {
-        item: ItemId,
-    },
-    Text,
-    Shape,
-    Null,
-    Camera,
-    Light {
-        kind: LightKind,
-    },
-    /// An imported 3D model (a footage item of kind [`FootageKind::Model`]; Advanced 3D).
-    Model {
-        item: ItemId,
-    },
-    /// A parametric 3D primitive (Advanced 3D).
-    Primitive {
-        kind: PrimitiveKind,
-    },
-}
-
-impl LayerSource {
-    pub fn item(&self) -> Option<ItemId> {
-        match self {
-            LayerSource::Footage { item } | LayerSource::Comp { item } | LayerSource::Solid { item } | LayerSource::Model { item } => Some(*item),
-            _ => None,
-        }
-    }
-    pub fn type_name(&self) -> &'static str {
-        match self {
-            LayerSource::Footage { .. } => "Footage",
-            LayerSource::Comp { .. } => "Composition",
-            LayerSource::Solid { .. } => "Solid",
-            LayerSource::Text => "Text",
-            LayerSource::Shape => "Shape",
-            LayerSource::Null => "Null",
-            LayerSource::Camera => "Camera",
-            LayerSource::Light { .. } => "Light",
-            LayerSource::Model { .. } => "3D Model",
-            LayerSource::Primitive { .. } => "3D Primitive",
-        }
-    }
-    /// Layers with pixels (cameras, lights and nulls have none).
-    pub fn is_av(&self) -> bool {
-        !matches!(self, LayerSource::Camera | LayerSource::Light { .. } | LayerSource::Null)
-    }
-    /// A 3D model or primitive layer (meshes; drawn by the Advanced 3D renderer).
-    pub fn is_model(&self) -> bool {
-        matches!(self, LayerSource::Model { .. } | LayerSource::Primitive { .. })
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Quality {
-    #[default]
-    Best,
-    Draft,
-    Wireframe,
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Sampling {
-    #[default]
-    Bilinear,
-    Bicubic,
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum FrameBlend {
-    #[default]
-    Off,
-    FrameMix,
-    PixelMotion,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Switches {
-    pub video: bool,
-    pub audio: bool,
-    pub solo: bool,
-    pub locked: bool,
-    pub shy: bool,
-    /// Collapse transformations (precomps) / continuously rasterize (vector layers).
-    pub collapse: bool,
-    pub quality: Quality,
-    pub sampling: Sampling,
-    pub effects: bool,
-    pub frame_blend: FrameBlend,
-    pub motion_blur: bool,
-    pub adjustment: bool,
-    pub three_d: bool,
-    pub guide: bool,
-}
-
-impl Default for Switches {
-    fn default() -> Self {
-        Switches {
-            video: true,
-            audio: true,
-            solo: false,
-            locked: false,
-            shy: false,
-            collapse: false,
-            quality: Quality::Best,
-            sampling: Sampling::Bilinear,
-            effects: true,
-            frame_blend: FrameBlend::Off,
-            motion_blur: false,
-            adjustment: false,
-            three_d: false,
-            guide: false,
-        }
-    }
-}
-
-// What a frame's pixels depend on. Caches key on it: the Audio, Lock and Shy switches and Hide
-// Shy Layers don't change pixels, so toggling them keeps cached frames (#103).
-
-impl Switches {
-    /// These switches with Audio, Lock and Shy at their defaults.
-    pub fn pixels(&self) -> Switches {
-        Switches { audio: true, locked: false, shy: false, ..self.clone() }
-    }
-}
-
-impl Layer {
-    /// Draws the same pixels as `o`: equal but for the Audio, Lock and Shy switches.
-    pub fn same_pixels(&self, o: &Layer) -> bool {
-        // Every field (no `..`: a new field must be considered here); the property tree last.
-        let Layer {
-            id,
-            name,
-            source,
-            label,
-            comment,
-            start_time,
-            in_point,
-            out_point,
-            stretch,
-            switches,
-            blend_mode,
-            preserve_transparency,
-            track_matte,
-            parent,
-            markers,
-            markers_locked,
-            auto_orient,
-            environment,
-            environment_background,
-            props,
-        } = self;
-        *id == o.id
-            && *name == o.name
-            && *source == o.source
-            && *label == o.label
-            && *comment == o.comment
-            && *start_time == o.start_time
-            && *in_point == o.in_point
-            && *out_point == o.out_point
-            && *stretch == o.stretch
-            && switches.pixels() == o.switches.pixels()
-            && *blend_mode == o.blend_mode
-            && *preserve_transparency == o.preserve_transparency
-            && *track_matte == o.track_matte
-            && *parent == o.parent
-            && *markers == o.markers
-            && *markers_locked == o.markers_locked
-            && *auto_orient == o.auto_orient
-            && *environment == o.environment
-            && *environment_background == o.environment_background
-            && *props == o.props
-    }
-}
-
-impl Comp {
-    /// Draws the same pixels as `o`: equal but for its layers' Audio, Lock and Shy switches, Hide
-    /// Shy Layers and the viewer's Resolution.
-    pub fn same_pixels(&self, o: &Comp) -> bool {
-        self.same_settings(o) && self.layers.len() == o.layers.len() && self.layers.iter().zip(&o.layers).all(|(a, b)| a.same_pixels(b))
-    }
-
-    /// [`Self::same_pixels`] but for the layers.
-    fn same_settings(&self, o: &Comp) -> bool {
-        // Every field (no `..`: a new field must be considered here).
-        let Comp {
-            width,
-            height,
-            pixel_aspect,
-            frame_rate,
-            duration,
-            display_start,
-            background,
-            work_area,
-            layers: _,
-            markers,
-            shutter_angle,
-            shutter_phase,
-            motion_blur_samples,
-            motion_blur_adaptive_limit,
-            renderer,
-            hide_shy: _,
-            enable_motion_blur,
-            enable_frame_blending,
-            draft_3d,
-            preserve_frame_rate,
-            preserve_resolution,
-            poster_time,
-            global_light,
-            guides,
-            essential,
-            resolution: _,
-        } = self;
-        *width == o.width
-            && *height == o.height
-            && *pixel_aspect == o.pixel_aspect
-            && *frame_rate == o.frame_rate
-            && *duration == o.duration
-            && *display_start == o.display_start
-            && *background == o.background
-            && *work_area == o.work_area
-            && *markers == o.markers
-            && *shutter_angle == o.shutter_angle
-            && *shutter_phase == o.shutter_phase
-            && *motion_blur_samples == o.motion_blur_samples
-            && *motion_blur_adaptive_limit == o.motion_blur_adaptive_limit
-            && *renderer == o.renderer
-            && *enable_motion_blur == o.enable_motion_blur
-            && *enable_frame_blending == o.enable_frame_blending
-            && *draft_3d == o.draft_3d
-            && *preserve_frame_rate == o.preserve_frame_rate
-            && *preserve_resolution == o.preserve_resolution
-            && *poster_time == o.poster_time
-            && *global_light == o.global_light
-            && *guides == o.guides
-            && *essential == o.essential
-    }
-
-    /// The comp-time span (`in_point..out_point` of every layer changed, added or removed,
-    /// widened by the shutter) outside which `self` draws the same pixels as `o`, so cached
-    /// frames there stay valid (#1641). `None` when the edit can reach any frame: a comp setting,
-    /// a layer reorder, Solo turning on or off, an expression (it reads anything), or a changed
-    /// layer another layer parents to, mattes with or picks in an effect.
-    pub fn changed_span(&self, o: &Comp) -> Option<(Tick, Tick)> {
-        fn reads(g: &PropGroup, changed: &[LayerId]) -> bool {
-            g.children.iter().any(|c| match c {
-                Node::Prop(p) => {
-                    p.expr.is_some()
-                        || std::iter::once(&p.value)
-                            .chain(p.keys.iter().map(|k| &k.value))
-                            .any(|v| matches!(v, Value::Layer(Some(id)) if changed.contains(&LayerId(*id))))
-                }
-                Node::Group(g) => reads(g, changed),
-            })
-        }
-        // Solo hides every other layer at every frame.
-        if !self.same_settings(o) || self.any_solo() != o.any_solo() {
-            return None;
-        }
-        let common = |a: &Comp, b: &Comp| a.layers.iter().map(|l| l.id).filter(|id| b.layer(*id).is_some()).collect::<Vec<_>>();
-        if common(self, o) != common(o, self) {
-            return None;
-        }
-        let mut changed = Vec::new();
-        let mut span: Option<(Tick, Tick)> = None;
-        // Each changed layer comes up from both sides: its old and its new span.
-        for (l, other) in self.layers.iter().map(|l| (l, o.layer(l.id))).chain(o.layers.iter().map(|l| (l, self.layer(l.id)))) {
-            if other.is_some_and(|b| l.same_pixels(b)) {
-                continue;
-            }
-            changed.push(l.id);
-            let (s, e) = (l.in_point.min(l.out_point), l.in_point.max(l.out_point));
-            span = Some(span.map_or((s, e), |(a, b)| (a.min(s), b.max(e))));
-        }
-        let reaches = |l: &Layer| {
-            l.parent.is_some_and(|p| changed.contains(&p)) || l.track_matte.as_ref().is_some_and(|m| changed.contains(&m.layer)) || reads(&l.props, &changed)
-        };
-        if self.layers.iter().chain(&o.layers).any(reaches) {
-            return None;
-        }
-        // A frame at `t` samples cameras, lights and transforms over its shutter,
-        // `t + (phase + angle * 0..=1) / 360` frames, and draws the layers active at `t` itself.
-        let (a, p) = (self.shutter_angle / 360.0, self.shutter_phase / 360.0);
-        let fd = self.frame_duration().seconds();
-        let (before, after) = (Tick::from_seconds_f64(p.max(p + a).max(0.0) * fd), Tick::from_seconds_f64(-p.min(p + a).min(0.0) * fd));
-        span.map(|(s, e)| (s - before, e + after))
-    }
-
-    /// Some layer is soloed: only the soloed layers draw.
-    pub fn any_solo(&self) -> bool {
-        self.layers.iter().any(|l| l.switches.solo && l.source.is_av())
-    }
-
-    /// Draws the same pixels as `o` once plain markers are ignored: they change no pixels. Protected
-    /// time markers with a duration set the timing (Responsive Design), so those still count.
-    pub fn same_pixels_ignoring_markers(&self, o: &Comp) -> bool {
-        let protected =
-            |m: &[Marker]| -> Vec<(Tick, Tick)> { m.iter().filter(|m| m.protected && m.duration > Tick::ZERO).map(|m| (m.time, m.duration)).collect() };
-        if protected(&self.markers) != protected(&o.markers) {
-            return false;
-        }
-        let mut c = self.clone();
-        c.markers = o.markers.clone();
-        for (a, b) in c.layers.iter_mut().zip(&o.layers) {
-            a.markers = b.markers.clone();
-            a.markers_locked = b.markers_locked;
-        }
-        c.same_pixels(o)
-    }
-
-    /// The comp with those switches and the Resolution at their defaults (borrowed when they
-    /// already are), for keys that hash the whole comp.
-    pub fn pixel_form(&self) -> std::borrow::Cow<'_, Comp> {
-        if !self.hide_shy && self.resolution.is_auto() && self.layers.iter().all(|l| l.switches == l.switches.pixels()) {
-            return std::borrow::Cow::Borrowed(self);
-        }
-        let mut c = self.clone();
-        c.hide_shy = false;
-        c.resolution = Resolution::Auto;
-        for l in &mut c.layers {
-            l.switches = l.switches.pixels();
-        }
-        std::borrow::Cow::Owned(c)
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum MatteKind {
-    #[default]
-    Alpha,
-    AlphaInverted,
-    Luma,
-    LumaInverted,
-}
-
-impl MatteKind {
-    pub const ALL: [MatteKind; 4] = [MatteKind::Alpha, MatteKind::AlphaInverted, MatteKind::Luma, MatteKind::LumaInverted];
-    pub fn label(self) -> &'static str {
-        match self {
-            MatteKind::Alpha => "Alpha Matte",
-            MatteKind::AlphaInverted => "Alpha Inverted Matte",
-            MatteKind::Luma => "Luma Matte",
-            MatteKind::LumaInverted => "Luma Inverted Matte",
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct TrackMatte {
-    pub layer: LayerId,
-    pub kind: MatteKind,
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum AutoOrient {
-    #[default]
-    Off,
-    AlongPath,
-    TowardsCamera,
-    TowardsPointOfInterest,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Layer {
-    pub id: LayerId,
-    pub name: String,
-    pub source: LayerSource,
-    pub label: Label,
-    #[serde(default)]
-    pub comment: String,
-    /// Comp time where the layer's time 0 sits.
-    pub start_time: Tick,
-    /// Visible span in comp time.
-    pub in_point: Tick,
-    pub out_point: Tick,
-    /// Time stretch in percent (100 = normal, negative = reversed).
-    pub stretch: f64,
-    pub switches: Switches,
-    pub blend_mode: BlendMode,
-    #[serde(default)]
-    pub preserve_transparency: bool,
-    #[serde(default)]
-    pub track_matte: Option<TrackMatte>,
-    #[serde(default)]
-    pub parent: Option<LayerId>,
-    #[serde(default)]
-    pub markers: Vec<Marker>,
-    /// Layer ▸ Markers ▸ Lock Markers.
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub markers_locked: bool,
-    #[serde(default)]
-    pub auto_orient: AutoOrient,
-    /// Layer ▸ Environment Layer: the layer is the environment (image-based light and
-    /// reflections) of Advanced 3D comps instead of being drawn.
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub environment: bool,
-    /// Layer ▸ Light ▸ Create Environment Light Background Layer: the layer's (equirectangular)
-    /// image is drawn as the 3D scene's backdrop, seen through the camera, instead of as a card.
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub environment_background: bool,
-    /// The property tree (Masks, Effects, Transform, Text, Contents, Camera/Light options…).
-    pub props: PropGroup,
-}
-
-impl Layer {
-    pub fn is_active_at(&self, t: Tick) -> bool {
-        t >= self.in_point && t < self.out_point
-    }
-    /// Layer time for a comp time (stretch-aware).
-    pub fn layer_time(&self, comp_t: Tick) -> Tick {
-        let d = comp_t - self.start_time;
-        if (self.stretch - 100.0).abs() < 1e-9 { d } else { Tick((d.0 as f64 * 100.0 / self.stretch) as i64) }
-    }
-    /// Comp time for a layer time.
-    pub fn comp_time(&self, layer_t: Tick) -> Tick {
-        if (self.stretch - 100.0).abs() < 1e-9 { self.start_time + layer_t } else { self.start_time + Tick((layer_t.0 as f64 * self.stretch / 100.0) as i64) }
-    }
-    pub fn transform(&self) -> Option<&PropGroup> {
-        self.props.sub("transform")
-    }
-    pub fn transform_mut(&mut self) -> Option<&mut PropGroup> {
-        self.props.sub_mut("transform")
-    }
-    pub fn effects(&self) -> Option<&PropGroup> {
-        self.props.sub("effects")
-    }
-    pub fn masks(&self) -> Option<&PropGroup> {
-        self.props.sub("masks")
-    }
-    pub fn is_camera(&self) -> bool {
-        matches!(self.source, LayerSource::Camera)
-    }
-    pub fn is_light(&self) -> bool {
-        matches!(self.source, LayerSource::Light { .. })
-    }
-    /// The layer participates in 3D (3D switch, or cameras/lights which are always 3D).
-    pub fn is_3d(&self) -> bool {
-        self.switches.three_d || self.is_camera() || self.is_light()
-    }
-    pub fn has_video(&self) -> bool {
-        self.source.is_av() && self.switches.video
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum FootageKind {
-    #[default]
-    Video,
-    Still,
-    Sequence,
-    Audio,
-    /// A 3D model (glTF 2.0 / OBJ), placed as a model layer.
-    Model,
-    /// A data file (JSON, CSV, TSV) for data-driven animation: read by expressions through
-    /// `footage(name).sourceData` / `sourceText` / `dataValue`; it has no pixels.
-    Data,
-}
-
-/// Interpret Footage ▸ Fields and Pulldown ▸ Separate Fields.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum FieldOrder {
-    /// Progressive frames.
-    #[default]
-    Off,
-    /// Interlaced, upper (odd) field first: each field becomes a frame at twice the rate.
-    UpperFirst,
-    LowerFirst,
-}
-
-impl FieldOrder {
-    pub fn label(self) -> &'static str {
-        match self {
-            FieldOrder::Off => "Off",
-            FieldOrder::UpperFirst => "Upper Field First",
-            FieldOrder::LowerFirst => "Lower Field First",
-        }
-    }
-    pub fn parse(s: &str) -> Option<FieldOrder> {
-        match s.to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {
-            "off" | "none" | "progressive" => Some(FieldOrder::Off),
-            "upper" | "upperfirst" | "upperfieldfirst" => Some(FieldOrder::UpperFirst),
-            "lower" | "lowerfirst" | "lowerfieldfirst" => Some(FieldOrder::LowerFirst),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub enum AlphaMode {
-    #[default]
-    Straight,
-    Premultiplied,
-    Ignore,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Footage {
-    pub path: String,
-    pub kind: FootageKind,
-    pub width: u32,
-    pub height: u32,
-    pub pixel_aspect: f64,
-    pub frame_rate: FrameRate,
-    /// Native rate before "Conform to frame rate".
-    #[serde(default)]
-    pub native_rate: Option<FrameRate>,
-    pub duration: Tick,
-    pub has_video: bool,
-    pub has_audio: bool,
-    pub alpha: AlphaMode,
-    #[serde(default)]
-    pub premul_color: [f32; 3],
-    #[serde(default = "one")]
-    pub loop_count: u32,
-    #[serde(default)]
-    pub codec: String,
-    #[serde(default)]
-    pub missing: bool,
-    /// Image sequence files (when kind = Sequence).
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub sequence: Vec<String>,
-    /// Colour profile (from the file's metadata, or Interpret Footage). `None` = sRGB.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub color_profile: Option<ColorSpace>,
-    /// One layer of a layered file (Photoshop) instead of its merged image.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub layer: Option<SourceLayer>,
-    /// Interpret Footage ▸ Fields and Pulldown ▸ Separate Fields.
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub fields: FieldOrder,
-    /// Interpret Footage ▸ Alpha ▸ Invert Alpha.
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub invert_alpha: bool,
-    /// Interpret Footage ▸ Color ▸ Interpret As Linear Light: the file's values are linear.
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub linear_light: bool,
-    /// Interpret Footage ▸ Color ▸ Preserve RGB: the file's values enter the composition
-    /// unconverted. Float footage (OpenEXR, float TIFF) is not sRGB-encoded on decode, and the
-    /// colour profile, Interpret As Linear Light and the working space don't apply.
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub preserve_rgb: bool,
-    /// Data footage ([`FootageKind::Data`]): the file's text (JSON, CSV or TSV), kept in the
-    /// project so expressions read it everywhere (and on the web).
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub data: Option<String>,
-    /// PDF / Illustrator footage: the page shown (0-based; File ▸ Import ▸ Page).
-    #[serde(default, skip_serializing_if = "is_default")]
-    pub page: u32,
-    /// Image sequences imported with Force Alphabetical Order: the files play one after another
-    /// and their numbering doesn't count (otherwise a gap in it shows a placeholder, as in After
-    /// Effects; [`sequence`]).
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub alphabetical: bool,
-    /// Interpret Footage ▸ Start Timecode ▸ Override Start: the frame (at the footage's frame
-    /// rate) its timecode shows at its first frame. `None` = Use Source File Timecode (0: file
-    /// timecode isn't read). It only relabels source time, as in After Effects.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub start_timecode: Option<i64>,
-}
-
-fn is_default<T: Default + PartialEq>(v: &T) -> bool {
-    *v == T::default()
-}
-
-impl Default for Footage {
-    fn default() -> Self {
-        Footage {
-            path: String::new(),
-            kind: FootageKind::Still,
-            width: 0,
-            height: 0,
-            pixel_aspect: 1.0,
-            frame_rate: FrameRate::FPS_30,
-            native_rate: None,
-            duration: Tick::ZERO,
-            has_video: false,
-            has_audio: false,
-            alpha: AlphaMode::Straight,
-            premul_color: [0.0; 3],
-            loop_count: 1,
-            codec: String::new(),
-            missing: false,
-            sequence: vec![],
-            color_profile: None,
-            fields: FieldOrder::Off,
-            invert_alpha: false,
-            linear_light: false,
-            preserve_rgb: false,
-            data: None,
-            layer: None,
-            page: 0,
-            alphabetical: false,
-            start_timecode: None,
-        }
-    }
-}
-
-impl Footage {
-    /// Interpret As Linear Light applies (Preserve RGB passes the file's values through).
-    pub fn linear_light_applies(&self) -> bool {
-        self.linear_light && !self.preserve_rgb
-    }
-
-    /// How long the footage plays: its duration times Interpret Footage ▸ Loop.
-    pub fn looped_duration(&self) -> Tick {
-        Tick(self.duration.0.saturating_mul(self.loop_count.max(1) as i64))
-    }
-
-    /// Source time as the footage's timecode: its frame `frame` from Start Timecode
-    /// (`0:00:41:20`), as the Footage panel shows it.
-    pub fn timecode(&self, frame: i64) -> String {
-        effectcraft_time::format_timecode_ae(frame.saturating_add(self.start_timecode.unwrap_or(0)), self.frame_rate, false)
-    }
-
-    /// The data format of data footage: `json`, `csv` or `tsv` (from the file extension).
-    pub fn data_format(&self) -> Option<&'static str> {
-        if self.kind != FootageKind::Data {
-            return None;
-        }
-        let ext = std::path::Path::new(&self.path).extension().and_then(std::ffi::OsStr::to_str).unwrap_or("").to_ascii_lowercase();
-        Some(match ext.as_str() {
-            "csv" => "csv",
-            "tsv" | "tab" => "tsv",
-            _ => "json",
-        })
-    }
-}
-
-/// A proxy: a stand-in file used instead of a footage item or composition (File ▸ Set Proxy /
-/// Create Proxy), when its Use Proxy switch is on and the render's Proxy Use allows it.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Proxy {
-    /// The proxy's footage (path, size, rate…; File ▸ Interpret Footage ▸ Proxy edits it).
-    pub footage: Footage,
-    /// Use Proxy (the Project panel's proxy indicator: filled = in use, hollow = set but off).
-    #[serde(default = "yes")]
-    pub enabled: bool,
-}
-
-/// A layer of a layered still (a Photoshop document, or a PDF / Illustrator / EPS file) used as
-/// footage (File ▸ Import ▸ Composition / Composition – Retain Layer Sizes, or Choose Layer).
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SourceLayer {
-    /// Layer record index in the file (bottom of the stack = 0).
-    pub index: u32,
-    pub name: String,
-    /// The footage is the layer's own bounds (Retain Layer Sizes) rather than the document size.
-    #[serde(default)]
-    pub layer_size: bool,
-    /// A Photoshop smart object: the unique id of its embedded file (linked layer data), which
-    /// is the footage instead of the layer's pixels.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub embedded: Option<String>,
-    /// A smart object with a perspective quad or a warp: the footage is its embedded file baked
-    /// as placed (warped and pinned to its corners) over the placed bounds in document space.
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub placed: bool,
-}
-
-fn one() -> u32 {
-    1
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Solid {
-    pub color: [f32; 3],
-    pub width: u32,
-    pub height: u32,
-    pub pixel_aspect: f64,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type")]
-#[allow(clippy::large_enum_variant)]
-pub enum ItemKind {
-    Folder,
-    Comp(Arc<Comp>),
-    Footage(Footage),
-    Solid(Solid),
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Item {
-    pub id: ItemId,
-    pub name: String,
-    pub label: Label,
-    #[serde(default)]
-    pub comment: String,
-    /// Containing folder (None = project root).
-    #[serde(default)]
-    pub parent: Option<ItemId>,
-    pub kind: ItemKind,
-    /// The item's proxy (footage and compositions).
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub proxy: Option<Box<Proxy>>,
-}
-
-impl Item {
-    pub fn type_name(&self) -> &'static str {
-        match &self.kind {
-            ItemKind::Folder => "Folder",
-            ItemKind::Comp(_) => "Composition",
-            ItemKind::Footage(f) => match f.kind {
-                FootageKind::Video => "Video",
-                FootageKind::Still => "Image",
-                FootageKind::Sequence => "Image Sequence",
-                FootageKind::Audio => "Audio",
-                FootageKind::Model => "3D Model",
-                FootageKind::Data => "Data",
-            },
-            ItemKind::Solid(_) => "Solid",
-        }
-    }
-    pub fn as_comp(&self) -> Option<&Comp> {
-        if let ItemKind::Comp(c) = &self.kind { Some(c) } else { None }
-    }
-    pub fn is_folder(&self) -> bool {
-        matches!(self.kind, ItemKind::Folder)
-    }
-    /// (width, height) for visual items.
-    pub fn dimensions(&self) -> Option<(u32, u32)> {
-        match &self.kind {
-            ItemKind::Comp(c) => Some((c.width, c.height)),
-            ItemKind::Footage(f) if f.has_video => Some((f.width, f.height)),
-            ItemKind::Solid(s) => Some((s.width, s.height)),
-            _ => None,
-        }
-    }
-    pub fn duration(&self) -> Option<Tick> {
-        match &self.kind {
-            ItemKind::Comp(c) => Some(c.duration),
-            ItemKind::Footage(f) if f.kind != FootageKind::Still => Some(f.looped_duration()),
-            _ => None,
-        }
-    }
-    pub fn frame_rate(&self) -> Option<FrameRate> {
-        match &self.kind {
-            ItemKind::Comp(c) => Some(c.frame_rate),
-            ItemKind::Footage(f) if f.kind == FootageKind::Video || f.kind == FootageKind::Sequence => Some(f.frame_rate),
-            _ => None,
-        }
-    }
-}
+mod comp;
+mod footage;
+mod item;
+mod layer;
+mod layers;
+mod settings;
+
+pub use comp::{Comp, Guide, Renderer, Resolution};
+pub use footage::{AlphaMode, CineonSettings, CineonUnits, FieldOrder, Footage, FootageKind, Proxy, Solid, SourceLayer, VIDEO_EXTENSIONS, cineon_log_to_lin};
+pub use item::{Item, ItemId, ItemKind, LayerId};
+pub use layer::{AutoOrient, FrameBlend, Layer, LayerSource, LightKind, MatteKind, PrimitiveKind, Quality, Sampling, Switches, TrackMatte};
+pub use layers::Layers;
+pub use settings::{
+    APP_VERSION, BitDepth, ColorEngine, CuePoint, HdrMode, Marker, ProjectError, ProjectSettings, SCHEMA_EFFECT_SPACE, SCHEMA_VERSION, SavedView,
+    TimeDisplayStyle, is_newer_version, saved_by, saved_view,
+};
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Project {
@@ -1434,229 +63,5 @@ pub struct Project {
     pub render_prefs: render_queue::RenderQueuePrefs,
 }
 
-impl Default for Project {
-    fn default() -> Self {
-        Project {
-            schema: SCHEMA_VERSION,
-            settings: ProjectSettings::default(),
-            items: BTreeMap::new(),
-            next_id: 1,
-            render_queue: Vec::new(),
-            render_templates: Default::default(),
-            render_prefs: Default::default(),
-        }
-    }
-}
-
-impl Project {
-    /// Allocate an id (items, layers and property uids share one counter).
-    pub fn alloc(&mut self) -> u64 {
-        let id = self.next_id;
-        self.next_id += 1;
-        id
-    }
-    pub fn item(&self, id: ItemId) -> Option<&Item> {
-        self.items.get(&id)
-    }
-    pub fn item_mut(&mut self, id: ItemId) -> Option<&mut Item> {
-        self.items.get_mut(&id)
-    }
-    pub fn comp(&self, id: ItemId) -> Option<&Comp> {
-        self.items.get(&id)?.as_comp()
-    }
-    /// A shared handle on a comp: a snapshot that costs a reference count, not a deep copy of
-    /// its layers (frontends hold one across a frame instead of cloning the comp).
-    pub fn comp_arc(&self, id: ItemId) -> Option<Arc<Comp>> {
-        match &self.items.get(&id)?.kind {
-            ItemKind::Comp(c) => Some(c.clone()),
-            _ => None,
-        }
-    }
-    /// Mutable comp (copy-on-write).
-    pub fn comp_mut(&mut self, id: ItemId) -> Option<&mut Comp> {
-        match &mut self.items.get_mut(&id)?.kind {
-            ItemKind::Comp(c) => Some(Arc::make_mut(c)),
-            _ => None,
-        }
-    }
-    /// Adds an item; its size, frame rate and the like are brought within [`limits`] first.
-    pub fn add_item(&mut self, name: &str, label: Label, parent: Option<ItemId>, mut kind: ItemKind) -> ItemId {
-        limits::repair_kind(name, &mut kind, &mut vec![]);
-        let id = ItemId(self.alloc());
-        self.items.insert(id, Item { id, name: name.into(), label, comment: String::new(), parent, kind, proxy: None });
-        id
-    }
-    /// Children of a folder (None = root), folders first then by name.
-    pub fn children(&self, folder: Option<ItemId>) -> Vec<&Item> {
-        let mut v: Vec<&Item> = self.items.values().filter(|i| i.parent == folder).collect();
-        v.sort_by(|a, b| b.is_folder().cmp(&a.is_folder()).then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase())));
-        v
-    }
-    pub fn comps(&self) -> impl Iterator<Item = (&ItemId, &Comp)> {
-        self.items.iter().filter_map(|(id, i)| i.as_comp().map(|c| (id, c)))
-    }
-    pub fn find_by_name(&self, name: &str) -> Option<&Item> {
-        self.items.values().find(|i| i.name == name)
-    }
-    /// A numbered name for a copy of `base` that no project item has (Edit ▸ Duplicate): its
-    /// trailing number is dropped and the lowest free one from 2 is added (`Comp 1` → `Comp 2`,
-    /// `Name` → `Name 2`, then `Name 3`). Items for which `ignore` holds don't count.
-    pub fn numbered_item_name(&self, base: &str, ignore: impl Fn(&Item) -> bool) -> String {
-        let stem = base.trim_end_matches(|c: char| c.is_ascii_digit()).trim_end();
-        let taken = |n: &str| self.items.values().any(|i| i.name == n && !ignore(i));
-        (2u64..).map(|k| format!("{stem} {k}")).find(|n| !taken(n)).unwrap_or_default()
-    }
-    /// `base` when no project item has that name, else the next free numbered name as
-    /// [`Project::numbered_item_name`] gives it. Items for which `ignore` holds don't count.
-    pub fn unique_item_name(&self, base: &str, ignore: impl Fn(&Item) -> bool) -> String {
-        if self.items.values().any(|i| i.name == base && !ignore(i)) { self.numbered_item_name(base, ignore) } else { base.to_string() }
-    }
-    pub fn folder_named(&self, name: &str) -> Option<ItemId> {
-        self.items.values().find(|i| i.is_folder() && i.name == name).map(|i| i.id)
-    }
-    /// Find the comp that contains `layer`.
-    pub fn comp_of_layer(&self, layer: LayerId) -> Option<ItemId> {
-        self.comps().find(|(_, c)| c.layer(layer).is_some()).map(|(id, _)| *id)
-    }
-    /// The compositions whose layers use `item` as their source (footage, solid, 3D model or
-    /// precomp), each with how many of its layers do, ordered by comp name then id. Only direct
-    /// layers count, as in After Effects' Project panel ("used 3 times"): a solid inside a precomp
-    /// is used by the precomp, not by the comps that nest it. The total is the sum of the counts.
-    pub fn item_users(&self, item: ItemId) -> Vec<(ItemId, usize)> {
-        let mut users: Vec<(ItemId, String, usize)> = self
-            .items
-            .iter()
-            .filter_map(|(id, it)| {
-                let comp = it.as_comp()?;
-                let n = comp.layers.iter().filter(|l| l.source.item() == Some(item)).count();
-                (n > 0).then(|| (*id, it.name.to_lowercase(), n))
-            })
-            .collect();
-        users.sort_by(|a, b| a.1.cmp(&b.1).then(a.0.cmp(&b.0)));
-        users.into_iter().map(|(id, _, n)| (id, n)).collect()
-    }
-    /// Whether comp `inner` is (transitively) nested inside comp `outer` (to prevent cycles).
-    pub fn comp_contains(&self, outer: ItemId, inner: ItemId) -> bool {
-        // A walk with a stack and a visited set rather than recursion (#1237): a damaged project
-        // may hold a precomp cycle that doesn't pass `inner` (recursion never ended), a long
-        // chain must not use up the call stack, and comps shared by many paths are visited once
-        // (recursion re-walked them for every path).
-        if outer == inner {
-            return true;
-        }
-        let mut seen = std::collections::HashSet::new();
-        let mut stack = vec![outer];
-        while let Some(id) = stack.pop() {
-            if !seen.insert(id) {
-                continue;
-            }
-            let Some(c) = self.comp(id) else { continue };
-            for l in &c.layers {
-                if let LayerSource::Comp { item } = l.source {
-                    if item == inner {
-                        return true;
-                    }
-                    if !seen.contains(&item) {
-                        stack.push(item);
-                    }
-                }
-            }
-        }
-        false
-    }
-    /// Make sure `next_id` exceeds every id in the project (after loading or merging).
-    pub fn fix_next_id(&mut self) {
-        let mut m = self.next_id;
-        for (id, it) in &self.items {
-            // Saturating: a damaged file's ids must not overflow (the import then refuses it).
-            m = m.max(id.0.saturating_add(1));
-            if let ItemKind::Comp(c) = &it.kind {
-                for l in &c.layers {
-                    m = m.max(l.id.0.saturating_add(1)).max(l.props.max_uid().saturating_add(1));
-                }
-            }
-        }
-        self.next_id = m;
-    }
-    /// Whether `other` holds the same content. An allocated id counts (an edit may hand it out
-    /// beyond the project, so it must stay taken). Shared compositions compare by pointer first,
-    /// so after a copy-on-write edit only the comps it touched are compared field by field.
-    pub fn same_content(&self, other: &Project) -> bool {
-        let item_eq = |a: &Item, b: &Item| {
-            let kind = match (&a.kind, &b.kind) {
-                (ItemKind::Comp(x), ItemKind::Comp(y)) => Arc::ptr_eq(x, y) || x == y,
-                (x, y) => x == y,
-            };
-            kind && a.id == b.id && a.name == b.name && a.label == b.label && a.comment == b.comment && a.parent == b.parent && a.proxy == b.proxy
-        };
-        self.schema == other.schema
-            && self.next_id == other.next_id
-            && self.settings == other.settings
-            && self.items.len() == other.items.len()
-            && self.items.iter().zip(&other.items).all(|((ka, a), (kb, b))| ka == kb && item_eq(a, b))
-            && self.render_queue == other.render_queue
-            && self.render_templates == other.render_templates
-            && self.render_prefs == other.render_prefs
-    }
-    /// The project file's text: the project with the version that wrote it (`savedBy`), checked
-    /// to read back, so a save never writes a file that can't be opened. Values JSON can't hold
-    /// (NaN or infinity, written as `null`, and nesting too deep to parse) are refused on every
-    /// save; debug builds also read the text back.
-    pub fn to_file_json(&self) -> Result<String, ProjectError> {
-        self.to_file_json_with_view(&SavedView::default())
-    }
-    /// [`Project::to_file_json`] that also records the open compositions ([`SavedView`]).
-    pub fn to_file_json_with_view(&self, view: &SavedView) -> Result<String, ProjectError> {
-        if self.schema > SCHEMA_VERSION {
-            return Err(ProjectError::Invalid(format!(
-                "the project can't be saved: it holds a value a project file can't store (project schema {} is newer than this version supports ({SCHEMA_VERSION}))",
-                self.schema
-            )));
-        }
-        #[derive(Serialize)]
-        struct File<'a> {
-            #[serde(rename = "savedBy")]
-            saved_by: &'a str,
-            #[serde(flatten)]
-            view: &'a SavedView,
-            #[serde(flatten)]
-            project: &'a Project,
-        }
-        let file = File { saved_by: APP_VERSION, view, project: self };
-        file_check::check(&file)
-            .map_err(|e| ProjectError::Invalid(format!("the project can't be saved: it holds a value a project file can't store ({e})")))?;
-        let text = serde_json::to_string_pretty(&file).map_err(|e| ProjectError::Invalid(format!("the project can't be saved: {e}")))?;
-        #[cfg(debug_assertions)]
-        Project::from_json(&text)
-            .map_err(|e| ProjectError::Invalid(format!("the project can't be saved: it holds a value a project file can't store ({e})")))?;
-        Ok(text)
-    }
-    pub fn to_json(&self) -> String {
-        serde_json::to_string_pretty(self).unwrap_or_default()
-    }
-    /// [`Project::to_json`] without indentation: smaller and faster (auto-saves).
-    pub fn to_json_compact(&self) -> String {
-        serde_json::to_string(self).unwrap_or_default()
-    }
-    pub fn from_json(s: &str) -> Result<Project, ProjectError> {
-        Project::from_json_repaired(s).map(|(p, _)| p)
-    }
-    /// [`Project::from_json`], also returning one line per value that was out of [`limits`] and
-    /// was corrected (a composition of a billion pixels, a zero frame rate…), so a corrupt or
-    /// hostile file still opens, within bounds, and the user can be told what changed.
-    pub fn from_json_repaired(s: &str) -> Result<(Project, Vec<String>), ProjectError> {
-        let mut p: Project = serde_json::from_str(s).map_err(|e| ProjectError::Invalid(e.to_string()))?;
-        if p.schema > SCHEMA_VERSION {
-            return Err(ProjectError::Invalid(format!("project schema {} is newer than this version supports ({SCHEMA_VERSION})", p.schema)));
-        }
-        p.fix_next_id();
-        let mut notes = vec![];
-        for item in p.items.values_mut() {
-            limits::repair_item(item, &mut notes);
-        }
-        Ok((p, notes))
-    }
-}
-
 #[cfg(test)]
 mod tests;
diff --git a/crates/project/src/props.rs b/crates/project/src/props.rs
index 6212a4b59..be2468c37 100644
--- a/crates/project/src/props.rs
+++ b/crates/project/src/props.rs
@@ -205,7 +205,8 @@ pub enum MaskMotionBlur {
     Off,
 }
 
-/// How a mask's feather ramps: Smooth (Gaussian) or Linear.
+/// How a mask's feather ramps: Smooth (three box passes, an S-shaped ramp of finite reach, as
+/// measured in After Effects) or Linear (one box pass: a straight ramp).
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum FeatherFalloff {
     #[default]
diff --git a/crates/project/src/render_queue.rs b/crates/project/src/render_queue.rs
index 2d3ab741b..c40096905 100644
--- a/crates/project/src/render_queue.rs
+++ b/crates/project/src/render_queue.rs
@@ -442,9 +442,18 @@ impl RenderSettings {
     pub fn frame_time(&self, comp: &Comp, i: u64) -> Tick {
         self.rate(comp).tick_of(self.first_frame(comp) + i as i64)
     }
-    pub fn output_size(&self, comp: &Comp) -> (u32, u32) {
+    pub fn effective_scale(&self, comp: &Comp) -> f64 {
         let s = self.resolution.clamp(0.01, 4.0);
-        (((comp.width as f64 * s).round() as u32).max(1), ((comp.height as f64 * s).round() as u32).max(1))
+        let max = f64::from(crate::limits::MAX_SIZE);
+        s.min(max / f64::from(comp.width.max(1))).min(max / f64::from(comp.height.max(1)))
+    }
+    pub fn output_size(&self, comp: &Comp) -> (u32, u32) {
+        let s = self.effective_scale(comp);
+        // The scale is clamped so neither side exceeds the comp limit, keeping the aspect
+        // ratio: a 30 000 px side at 4x renders at 1x instead of cropping to a corner.
+        let w = ((comp.width as f64 * s).round() as u32).max(1);
+        let h = ((comp.height as f64 * s).round() as u32).max(1);
+        (w, h)
     }
     pub fn resolution_label(&self) -> &'static str {
         match self.resolution {
@@ -509,6 +518,9 @@ pub enum OutputFormat {
     TiffSequence,
     /// OpenEXR sequence (32-bit float, linear light).
     ExrSequence,
+    /// Targa sequence: uncompressed 24-bit RGB or 32-bit RGB + Alpha (8 alpha bits), top-left
+    /// origin.
+    TargaSequence,
     /// Animated GIF.
     Gif,
     /// WebM: VP9 video (alpha with RGB + Alpha) + Opus audio.
@@ -528,7 +540,7 @@ pub enum OutputFormat {
 }
 
 impl OutputFormat {
-    pub const ALL: [OutputFormat; 13] = [
+    pub const ALL: [OutputFormat; 14] = [
         OutputFormat::H264,
         OutputFormat::Hevc,
         OutputFormat::Av1,
@@ -539,6 +551,7 @@ impl OutputFormat {
         OutputFormat::JpegSequence,
         OutputFormat::TiffSequence,
         OutputFormat::ExrSequence,
+        OutputFormat::TargaSequence,
         OutputFormat::Gif,
         OutputFormat::Wav,
         OutputFormat::Aiff,
@@ -552,6 +565,7 @@ impl OutputFormat {
             OutputFormat::JpegSequence => "JPEG Sequence",
             OutputFormat::TiffSequence => "TIFF Sequence",
             OutputFormat::ExrSequence => "OpenEXR Sequence",
+            OutputFormat::TargaSequence => "Targa Sequence",
             OutputFormat::Gif => "Animated GIF",
             OutputFormat::WebM => "WebM (VP9 + Opus)",
             OutputFormat::Wav => "WAV",
@@ -569,6 +583,7 @@ impl OutputFormat {
             OutputFormat::JpegSequence => "jpg",
             OutputFormat::TiffSequence => "tif",
             OutputFormat::ExrSequence => "exr",
+            OutputFormat::TargaSequence => "tga",
             OutputFormat::Gif => "gif",
             OutputFormat::WebM => "webm",
             OutputFormat::Wav => "wav",
@@ -577,7 +592,10 @@ impl OutputFormat {
         }
     }
     pub fn is_sequence(self) -> bool {
-        matches!(self, OutputFormat::PngSequence | OutputFormat::JpegSequence | OutputFormat::TiffSequence | OutputFormat::ExrSequence)
+        matches!(
+            self,
+            OutputFormat::PngSequence | OutputFormat::JpegSequence | OutputFormat::TiffSequence | OutputFormat::ExrSequence | OutputFormat::TargaSequence
+        )
     }
     pub fn is_movie(self) -> bool {
         matches!(self, OutputFormat::H264 | OutputFormat::ProRes | OutputFormat::Uncompressed | OutputFormat::WebM | OutputFormat::Hevc | OutputFormat::Av1)
@@ -603,7 +621,7 @@ impl OutputFormat {
         if matches!(self, OutputFormat::H264 | OutputFormat::Hevc) { (even(w), even(h)) } else { (w, h) }
     }
     /// Parse a format name: `h264`, `mp4`, `prores`, `mov`, `uncompressed`, `png`, `jpeg`/`jpg`,
-    /// `tiff`/`tif`, `exr`, `gif`, or a label.
+    /// `tiff`/`tif`, `exr`, `tga`/`targa`, `gif`, or a label.
     pub fn from_name(s: &str) -> Option<OutputFormat> {
         let n = s.trim().to_ascii_lowercase().replace([' ', '.', '-', '_'], "");
         Some(match n.as_str() {
@@ -616,6 +634,7 @@ impl OutputFormat {
             "jpg" | "jpeg" | "jpegsequence" => OutputFormat::JpegSequence,
             "tif" | "tiff" | "tiffsequence" => OutputFormat::TiffSequence,
             "exr" | "openexr" | "openexrsequence" => OutputFormat::ExrSequence,
+            "tga" | "targa" | "targasequence" => OutputFormat::TargaSequence,
             "gif" | "animatedgif" => OutputFormat::Gif,
             "webm" | "vp9" | "webmvp9opus" => OutputFormat::WebM,
             "wav" | "wave" => OutputFormat::Wav,
@@ -769,15 +788,18 @@ impl Crop {
         if self.use_roi
             && let Some([x, y, rw, rh]) = self.roi
         {
-            // The quad arrives unvalidated (control channel or a hand-edited project):
-            // clamp like the sibling edge fields (plus/minus 20 000) and subtract
-            // without overflow.
-            let conv = |v: f64| v.round().clamp(-20_000.0, 20_000.0) as i32;
-            let l = conv(x * scale);
-            let t = conv(y * scale);
-            let r = (w as i32).saturating_sub(conv((x + rw) * scale));
-            let b = (h as i32).saturating_sub(conv((y + rh) * scale));
-            return (t, l, b, r);
+            // The quad arrives unvalidated (control channel or a hand-edited project). As in
+            // After Effects, the region of interest lies inside the frame: each converted edge
+            // is clamped to [0, w] / [0, h] (inf clamps to a side, NaN converts to 0), and the
+            // far edge never passes the near one. Every edge then lies inside the frame, so the
+            // crop can't be larger than the frame and no subtraction can overflow.
+            let (wi, hi) = (i32::try_from(w).unwrap_or(i32::MAX), i32::try_from(h).unwrap_or(i32::MAX));
+            let conv = |v: f64, side: i32| v.round().clamp(0.0, f64::from(side)) as i32;
+            let l = conv(x * scale, wi);
+            let t = conv(y * scale, hi);
+            let r = conv((x + rw) * scale, wi).max(l);
+            let b = conv((y + rh) * scale, hi).max(t);
+            return (t, l, hi - b, wi - r);
         }
         (self.top, self.left, self.bottom, self.right)
     }
@@ -1116,7 +1138,7 @@ impl OutputModule {
     /// rounding).
     pub fn output_size(&self, comp: &Comp, settings: &RenderSettings) -> (u32, u32) {
         let (w, h) = settings.output_size(comp);
-        let (w, h) = self.frame_size(w, h, settings.resolution.clamp(0.01, 4.0));
+        let (w, h) = self.frame_size(w, h, settings.effective_scale(comp));
         self.format.coded_size(w, h)
     }
     /// Every setting as `(label, value)` lines (render logs).
@@ -1455,22 +1477,56 @@ pub fn expand_template(template: &str, format: OutputFormat, v: &TemplateVars) -
 /// Replace the first run of `#` (optionally in brackets, `[####]`) with the zero-padded frame
 /// number. Paths without a run get `_NNNNN` before the extension.
 pub fn sequence_path(path: &str, frame: i64) -> String {
+    let (before, width, after) = sequence_parts(path);
+    format!("{before}{frame:0width$}{after}")
+}
+
+/// A sequence output path around its frame number: what comes before it, how many digits it is
+/// padded to and what comes after (`out/a_[#####].png` → `out/a_`, 5, `.png`).
+pub fn sequence_parts(path: &str) -> (String, usize, String) {
     if let Some(start) = path.find('#') {
         let len = path[start..].chars().take_while(|c| *c == '#').count();
         let (mut a, mut b) = (start, start + len);
-        if a > 0 && path.as_bytes()[a - 1] == b'[' && path.as_bytes().get(b) == Some(&b']') {
+        if a > 0 && path.as_bytes().get(a - 1) == Some(&b'[') && path.as_bytes().get(b) == Some(&b']') {
             a -= 1;
             b += 1;
         }
-        return format!("{}{:0width$}{}", &path[..a], frame, &path[b..], width = len);
+        return (path[..a].to_string(), len, path[b..].to_string());
     }
     let p = std::path::Path::new(path);
     match p.extension() {
-        Some(ext) => format!("{}_{frame:05}.{}", p.with_extension("").to_string_lossy(), ext.to_string_lossy()),
-        None => format!("{path}_{frame:05}"),
+        Some(ext) => (format!("{}_", p.with_extension("").to_string_lossy()), 5, format!(".{}", ext.to_string_lossy())),
+        None => (format!("{path}_"), 5, String::new()),
     }
 }
 
+/// The frame number `candidate` is the file of, when `path` (a sequence output path) writes it:
+/// the inverse of [`sequence_path`].
+pub fn sequence_frame(path: &str, candidate: &str) -> Option<i64> {
+    let (before, width, after) = sequence_parts(path);
+    let digits = candidate.strip_prefix(before.as_str())?.strip_suffix(after.as_str())?;
+    let frame: i64 = digits.parse().ok()?;
+    (format!("{frame:0width$}") == digits).then_some(frame)
+}
+
+/// `template` with `_n` added to the name: before the frame-number run of a sequence, else before
+/// the extension (`[compName].[fileExtension]` → `[compName]_1.[fileExtension]`,
+/// `[compName]_[#####].[fileExtension]` → `[compName]_1_[#####].[fileExtension]`).
+pub fn numbered_template(template: &str, n: u32) -> String {
+    let at = match template.find('#') {
+        Some(hash) => {
+            // The run's `[`, then the separator that sets it off from the name.
+            let run = if template[..hash].ends_with('[') { hash - 1 } else { hash };
+            if template[..run].ends_with(['_', '-', '.', ' ']) { run - 1 } else { run }
+        }
+        None => {
+            let name = template.rfind(['/', '\\']).map_or(0, |i| i + 1);
+            template[name..].rfind('.').map_or(template.len(), |i| name + i)
+        }
+    };
+    format!("{}_{n}{}", &template[..at], &template[at..])
+}
+
 /// Make a name safe as a file name component.
 pub fn sanitize(name: &str) -> String {
     name.chars().map(|c| if matches!(c, '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|') { '_' } else { c }).collect()
@@ -1490,6 +1546,44 @@ mod tests {
         assert_eq!(sequence_path("a.png", 3), "a_00003.png");
     }
 
+    /// `sequence_frame` reads back what `sequence_path` writes, and nothing else.
+    #[test]
+    fn sequence_frames_read_back() {
+        for path in ["out/a_[#####].png", "a###.tif", "a.png", "/x/[compName]/shot_[##].exr", "noext", "dir.v2/clip"] {
+            for frame in [0, 7, 42, 99_999, 123_456, -3] {
+                assert_eq!(sequence_frame(path, &sequence_path(path, frame)), Some(frame), "{path} {frame}");
+            }
+        }
+        let (before, width, after) = sequence_parts("out/a_[#####].png");
+        assert_eq!((before.as_str(), width, after.as_str()), ("out/a_", 5, ".png"));
+        let (before, width, after) = sequence_parts("a.png");
+        assert_eq!((before.as_str(), width, after.as_str()), ("a_", 5, ".png"));
+        // Other numbers, other widths, other names are not frames of the sequence.
+        assert_eq!(sequence_frame("a_[#####].png", "a_0042.png"), None, "padded to four");
+        assert_eq!(sequence_frame("a_[####].png", "a_+042.png"), None, "a sign is not padding");
+        assert_eq!(sequence_frame("a_[#####].png", "a_00042.jpg"), None);
+        assert_eq!(sequence_frame("a_[#####].png", "b_00042.png"), None);
+        assert_eq!(sequence_frame("a_[#####].png", "a_00x42.png"), None);
+        assert_eq!(sequence_frame("a_[#####].png", "a_.png"), None);
+        assert_eq!(sequence_frame("a_[#####].png", "a_99999999999999999999.png"), None, "too big for a frame number");
+    }
+
+    #[test]
+    fn numbered_templates() {
+        assert_eq!(numbered_template(DEFAULT_TEMPLATE, 1), "[compName]_1.[fileExtension]");
+        assert_eq!(numbered_template(DEFAULT_SEQUENCE_TEMPLATE, 2), "[compName]_2_[#####].[fileExtension]");
+        assert_eq!(numbered_template("[compName]_frame.[fileExtension]", 3), "[compName]_frame_3.[fileExtension]");
+        assert_eq!(numbered_template("out/[compName]###.png", 1), "out/[compName]_1###.png");
+        assert_eq!(numbered_template("my.dir/clip", 4), "my.dir/clip_4", "a dot in a folder is not an extension");
+        assert_eq!(numbered_template("clip.v2.mov", 1), "clip.v2_1.mov");
+        assert_eq!(numbered_template("", 1), "_1");
+        assert_eq!(numbered_template("#", 1), "_1#");
+        assert_eq!(numbered_template("[#]", 1), "_1[#]");
+        // A numbered default is still a default: it expands to the numbered name.
+        let v = TemplateVars { comp_name: "footage", project_name: "P", width: 64, height: 36, frame_rate: 30.0, start_frame: 0, end_frame: 29 };
+        assert_eq!(expand_template(&numbered_template(DEFAULT_TEMPLATE, 1), OutputFormat::H264, &v), "footage_1.mp4");
+    }
+
     #[test]
     fn set_format_fixes_names() {
         let mut m = OutputModule::default();
@@ -1649,8 +1743,8 @@ mod tests {
 
     #[test]
     fn hostile_roi_cannot_overflow_crop_math() {
-        // `-1e12` saturates to `i32::MIN` on conversion: `w as i32 - l` must saturate,
-        // not overflow, and still yield a usable (degenerate) frame size.
+        // `-1e12` is clamped into the frame on conversion: it must not overflow and must still
+        // yield a usable (degenerate) frame size.
         let c = Comp::new(1920, 1080, FrameRate::new(30, 1), Tick::from_seconds_f64(1.0));
         let rs = RenderSettings::default();
         let mut m = OutputModule::for_format(OutputFormat::PngSequence);
@@ -1663,6 +1757,66 @@ mod tests {
         assert_eq!(m.output_size(&c, &half), (400, 200));
     }
 
+    #[test]
+    fn output_size_never_exceeds_the_comp_limit() {
+        // The effective scale is clamped so neither side exceeds the limit (exporter
+        // `w * h * 4` would overflow at 120 000 px sides); the pipeline renders at the
+        // same scale, so it never requests a frame larger than this reports.
+        let rs = RenderSettings { resolution: 4.0, ..Default::default() };
+        let m = OutputModule::for_format(OutputFormat::PngSequence);
+        let square = Comp::new(30_000, 30_000, FrameRate::new(30, 1), Tick::from_seconds_f64(1.0));
+        assert_eq!(rs.effective_scale(&square), 1.0);
+        assert_eq!(rs.output_size(&square), (30_000, 30_000));
+        assert_eq!(m.output_size(&square, &rs), (30_000, 30_000));
+        // Wide comps keep their aspect ratio instead of clamping each side on its own.
+        let wide = Comp::new(30_000, 15_000, FrameRate::new(30, 1), Tick::from_seconds_f64(1.0));
+        assert_eq!(rs.effective_scale(&wide), 1.0);
+        assert_eq!(rs.output_size(&wide), (30_000, 15_000));
+        assert_eq!(m.output_size(&wide, &rs), (30_000, 15_000));
+        // A mid-size comp renders at the largest scale that still fits.
+        let mid = Comp::new(20_000, 10_000, FrameRate::new(30, 1), Tick::from_seconds_f64(1.0));
+        assert_eq!(mid.width as f64 * rs.effective_scale(&mid), 30_000.0);
+        assert_eq!(rs.output_size(&mid), (30_000, 15_000));
+    }
+
+    #[test]
+    fn valid_wide_roi_endpoints_are_preserved() {
+        // A supported 30 000 x 100 frame at scale 1: ROI [10000, 0, 20000, 100] spans x 10 000..30 000
+        // and must give 20 000 x 100 (the absolute right edge 30 000 exceeds the old +/-20 000 clamp).
+        let c = Comp::new(30_000, 100, FrameRate::new(30, 1), Tick::from_seconds_f64(1.0));
+        let rs = RenderSettings::default();
+        let mut m = OutputModule::for_format(OutputFormat::PngSequence);
+        m.crop = Crop { enabled: true, use_roi: true, roi: Some([10_000.0, 0.0, 20_000.0, 100.0]), ..Default::default() };
+        assert_eq!(m.output_size(&c, &rs), (20_000, 100));
+        assert_eq!(m.crop.edges(30_000, 100, 1.0), (0, 10_000, 0, 0));
+        // Scale 4.0 pushes a valid edge to 120 000 px (30 000 x 4); the left edge 40 000 and the
+        // right edge 120 000 are both beyond 20 000 and must survive.
+        assert_eq!(m.crop.edges(120_000, 400, 4.0), (0, 40_000, 0, 0));
+        assert_eq!(m.frame_size(120_000, 400, 4.0), (80_000, 400));
+        // Hostile quads stay inside the frame: never empty, never larger than the frame, so the
+        // export can't be asked for an unbounded crop (an ROI reaching far outside the comp
+        // used to pad the frame instead).
+        let (fw, fh) = (1920, 1080);
+        let hostile = [
+            [1e300, 1e300, 1e300, 1e300],
+            [-1e300, -1e300, 1e300, 1e300],
+            [-1e6, -1e6, 2e6 + 1920.0, 2e6 + 1080.0],
+            [-1e12, -1e12, -1e12, -1e12],
+            [f64::NAN, f64::INFINITY, f64::NEG_INFINITY, f64::NAN],
+            [f64::NEG_INFINITY, f64::NEG_INFINITY, f64::INFINITY, f64::INFINITY],
+        ];
+        for roi in hostile {
+            m.crop.roi = Some(roi);
+            let (t, l, b, r) = m.crop.edges(fw, fh, 1.0);
+            assert!([t, l, b, r].iter().all(|e| *e >= 0), "{roi:?}: an edge pads the frame: {:?}", (t, l, b, r));
+            let (w, h) = m.frame_size(fw, fh, 1.0);
+            assert!((1..=fw).contains(&w) && (1..=fh).contains(&h), "{roi:?}: {w}x{h} is outside 1x1..={fw}x{fh}");
+        }
+        // An ROI covering more than the frame is the whole frame.
+        m.crop.roi = Some([-1e6, -1e6, 2e6 + 1920.0, 2e6 + 1080.0]);
+        assert_eq!(m.frame_size(fw, fh, 1.0), (fw, fh));
+    }
+
     #[test]
     fn uncompressed_quicktime_format() {
         let f = OutputFormat::from_name("uncompressed").unwrap();
@@ -1682,6 +1836,28 @@ mod tests {
         assert_eq!(serde_json::from_str::<OutputModule>(&json).unwrap().format, f);
     }
 
+    #[test]
+    fn targa_sequence_format() {
+        let f = OutputFormat::from_name("tga").unwrap();
+        assert_eq!(f, OutputFormat::TargaSequence);
+        assert_eq!(OutputFormat::from_name(&format!("{f:?}")), Some(f));
+        assert_eq!(OutputFormat::from_name("Targa"), Some(f));
+        assert_eq!(OutputFormat::from_name("Targa Sequence"), Some(f));
+        assert_eq!(OutputFormat::from_path("/out/shot_00001.TGA"), Some(f));
+        assert!(OutputFormat::ALL.contains(&f));
+        assert!(f.is_sequence() && f.supports_alpha() && !f.supports_audio() && !f.is_movie());
+        assert_eq!((f.label(), f.extension()), ("Targa Sequence", "tga"));
+        assert_eq!(f.coded_size(3, 5), (3, 5));
+        // A movie name becomes a numbered sequence; RGB + Alpha survives the switch.
+        let mut m = OutputModule::for_format(OutputFormat::ProRes);
+        m.output = "/out/Comp 1.mov".into();
+        m.channels = Channels::Rgba;
+        m.set_format(f);
+        assert_eq!((m.output.as_str(), m.channels), ("/out/Comp 1_[#####].tga", Channels::Rgba));
+        let json = serde_json::to_string(&m).unwrap();
+        assert_eq!(serde_json::from_str::<OutputModule>(&json).unwrap().format, f);
+    }
+
     #[test]
     fn hevc_av1_codec_options() {
         assert_eq!(OutputFormat::from_name("H.265"), Some(OutputFormat::Hevc));
diff --git a/crates/project/src/render_templates.rs b/crates/project/src/render_templates.rs
index cf52b000e..cadfab2ad 100644
--- a/crates/project/src/render_templates.rs
+++ b/crates/project/src/render_templates.rs
@@ -8,7 +8,9 @@
 
 use serde::{Deserialize, Serialize};
 
-use crate::render_queue::*;
+use crate::render_queue::{
+    AlphaMode, Channels, CurrentOrOff, FieldRender, OutputFormat, OutputModule, ProResProfile, ProxyUse, RenderQuality, RenderSettings, SwitchOverride,
+};
 use effectcraft_time::FrameRate;
 
 /// A default slot (the Defaults section of the Templates dialogs).
@@ -288,6 +290,7 @@ impl RenderTemplates {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::render_queue::{ColorDepth, Crop};
 
     #[test]
     fn builtins_defaults_and_round_trip() {
diff --git a/crates/project/src/sequence.rs b/crates/project/src/sequence.rs
index fa3d522b5..716c9b4fd 100644
--- a/crates/project/src/sequence.rs
+++ b/crates/project/src/sequence.rs
@@ -37,14 +37,21 @@ pub fn frame_number(path: &str) -> Option<i64> {
 }
 
 /// The After Effects name of a numbered sequence: `shot_[0001-0250].png`. `None` when the first
-/// file isn't numbered.
+/// file isn't numbered. Files that are only a number (`0001.png`) take their folder's name in
+/// front, `plate [0001-0250].png`, so sequences from several folders don't all read the same
+/// (#2019).
 pub fn sequence_name(files: &[String]) -> Option<String> {
     let (first, last) = (files.first()?, files.last()?);
-    let name = |p: &str| p.rsplit(['/', '\\']).next().unwrap_or(p).to_string();
+    let mut parts = first.rsplit(['/', '\\']);
+    let first_name = parts.next().unwrap_or(first);
+    let folder = parts.next().filter(|f| !f.is_empty() && !f.ends_with(':'));
     let (prefix, a) = split_frame_number(stem_of(first))?;
     let (_, b) = split_frame_number(stem_of(last))?;
-    let first_name = name(first);
     let ext = first_name.rsplit_once('.').map(|(_, e)| format!(".{e}")).unwrap_or_default();
+    let prefix = match folder {
+        Some(f) if prefix.is_empty() => format!("{f} "),
+        _ => prefix.to_string(),
+    };
     Some(format!("{prefix}[{a}-{b}]{ext}"))
 }
 
@@ -135,6 +142,13 @@ mod tests {
         let files: Vec<String> = ["/s/fx_0998.png", "/s/fx_1002.png"].map(String::from).to_vec();
         assert_eq!(sequence_name(&files).as_deref(), Some("fx_[0998-1002].png"));
         assert_eq!(sequence_name(&["/s/a.png".to_string()]), None);
+        // #2019: frames that are only a number take their folder's name.
+        let plain: Vec<String> = ["/shots/plate/0001.png", "/shots/plate/0250.png"].map(String::from).to_vec();
+        assert_eq!(sequence_name(&plain).as_deref(), Some("plate [0001-0250].png"));
+        let windows: Vec<String> = ["C:\\shots\\bg\\001.exr", "C:\\shots\\bg\\010.exr"].map(String::from).to_vec();
+        assert_eq!(sequence_name(&windows).as_deref(), Some("bg [001-010].exr"));
+        assert_eq!(sequence_name(&["0001.png".to_string(), "0002.png".to_string()]).as_deref(), Some("[0001-0002].png"));
+        assert_eq!(sequence_name(&["C:\\0001.png".to_string()]).as_deref(), Some("[0001-0001].png"));
     }
 
     #[test]
diff --git a/crates/project/src/settings.rs b/crates/project/src/settings.rs
new file mode 100644
index 000000000..29353908f
--- /dev/null
+++ b/crates/project/src/settings.rs
@@ -0,0 +1,314 @@
+use super::item::{ItemId, LayerId};
+use super::{BTreeMap, ColorSpace, Deserialize, Label, Serialize, Tick};
+
+/// The project file schema. 2: effects on layers without a source rectangle (shape, text)
+/// measure positions from the top-left of their comp-sized bounds (effect space), not from
+/// the layer's origin; projects from schema 1 are converted when opened (#227).
+pub use craft_ecproj_format::SCHEMA_VERSION;
+
+/// The first schema in which effect positions are in effect space (see [`SCHEMA_VERSION`]).
+pub const SCHEMA_EFFECT_SPACE: u32 = 2;
+
+/// The EffectCraft version, written into project files as `savedBy`.
+pub const APP_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// The EffectCraft version that wrote a project file (its `savedBy`), when it says, also for a
+/// project whose schema is newer than [`SCHEMA_VERSION`].
+pub fn saved_by(text: &str) -> Option<String> {
+    match craft_ecproj_format::Head::read(text) {
+        Ok(head) => head.saved_by,
+        Err(craft_ecproj_format::ReadError::TooNew { saved_by, .. }) => saved_by,
+        Err(_) => None,
+    }
+}
+
+/// The compositions that were open when a project file was saved and their current times
+/// (`activeComp`, `openComps` and `compTimes` next to `savedBy`), so it reopens where it was left
+/// (#748, #1714). Editor state rather than project
+/// content: opening a comp doesn't make the project unsaved, and it isn't part of
+/// [`Project`]. Older files have none; older versions ignore it.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SavedView {
+    /// The comp shown in the viewer and the Timeline.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub active_comp: Option<ItemId>,
+    /// The open comps (Timeline tabs), in tab order.
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub open_comps: Vec<ItemId>,
+    /// Each comp's current time, so a project reopens on the frame it was saved at rather than
+    /// at 0, where its layers may not have started yet (#1714).
+    #[serde(skip_serializing_if = "BTreeMap::is_empty")]
+    pub comp_times: BTreeMap<ItemId, Tick>,
+}
+
+/// The view a project file was saved with ([`SavedView`]); empty for older files. Values that
+/// aren't ids are ignored (whether an id still names a comp is up to the caller).
+pub fn saved_view(text: &str) -> SavedView {
+    #[derive(Deserialize)]
+    struct Meta {
+        #[serde(rename = "activeComp", default)]
+        active_comp: Option<serde_json::Value>,
+        #[serde(rename = "openComps", default)]
+        open_comps: Option<serde_json::Value>,
+        #[serde(rename = "compTimes", default)]
+        comp_times: Option<serde_json::Value>,
+    }
+    let Ok(m) = serde_json::from_str::<Meta>(text) else { return SavedView::default() };
+    SavedView {
+        active_comp: m.active_comp.as_ref().and_then(serde_json::Value::as_u64).map(ItemId),
+        open_comps: m
+            .open_comps
+            .as_ref()
+            .and_then(serde_json::Value::as_array)
+            .map_or_else(Vec::new, |a| a.iter().filter_map(serde_json::Value::as_u64).map(ItemId).collect()),
+        comp_times: m
+            .comp_times
+            .as_ref()
+            .and_then(serde_json::Value::as_object)
+            .map_or_else(BTreeMap::new, |o| o.iter().filter_map(|(k, v)| Some((ItemId(k.parse().ok()?), Tick(v.as_i64()?)))).collect()),
+    }
+}
+
+/// Whether version `a` (`major.minor.patch`, pre-release suffixes ignored) is newer than `b`.
+pub fn is_newer_version(a: &str, b: &str) -> bool {
+    let parts = |v: &str| -> [u64; 3] {
+        let mut n = v.split(['-', '+']).next().unwrap_or("").split('.').map(|x| x.parse().unwrap_or(0));
+        [n.next().unwrap_or(0), n.next().unwrap_or(0), n.next().unwrap_or(0)]
+    };
+    parts(a) > parts(b)
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ProjectError {
+    #[error("no item {0:?}")]
+    NoItem(ItemId),
+    #[error("item {0:?} is not a composition")]
+    NotComp(ItemId),
+    #[error("no layer {0:?}")]
+    NoLayer(LayerId),
+    #[error("no property `{0}`")]
+    NoProperty(String),
+    #[error("{0}")]
+    Invalid(String),
+}
+
+/// Project bit depth.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum BitDepth {
+    #[default]
+    Bpc8,
+    Bpc16,
+    Bpc32,
+}
+
+impl BitDepth {
+    pub fn label(self) -> &'static str {
+        match self {
+            BitDepth::Bpc8 => "8 bpc",
+            BitDepth::Bpc16 => "16 bpc",
+            BitDepth::Bpc32 => "32 bpc",
+        }
+    }
+    pub fn next(self) -> BitDepth {
+        match self {
+            BitDepth::Bpc8 => BitDepth::Bpc16,
+            BitDepth::Bpc16 => BitDepth::Bpc32,
+            BitDepth::Bpc32 => BitDepth::Bpc8,
+        }
+    }
+    pub fn is_float(self) -> bool {
+        self == BitDepth::Bpc32
+    }
+    /// Quantisation levels per channel of the integer depths (8 bpc: 255; 16 bpc: 32768, After
+    /// Effects' "15 + 1" bit range), `None` for 32 bpc float.
+    pub fn levels(self) -> Option<f32> {
+        match self {
+            BitDepth::Bpc8 => Some(255.0),
+            BitDepth::Bpc16 => Some(32768.0),
+            BitDepth::Bpc32 => None,
+        }
+    }
+    pub fn bits(self) -> u32 {
+        match self {
+            BitDepth::Bpc8 => 8,
+            BitDepth::Bpc16 => 16,
+            BitDepth::Bpc32 => 32,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum TimeDisplayStyle {
+    #[default]
+    Timecode,
+    Frames,
+    /// Feet + Frames, 35 mm film (16 frames per foot).
+    Feet35,
+    /// Feet + Frames, 16 mm film (40 frames per foot).
+    Feet16,
+}
+
+impl TimeDisplayStyle {
+    /// Frames per foot of the Feet + Frames styles.
+    pub fn frames_per_foot(self) -> Option<i64> {
+        match self {
+            TimeDisplayStyle::Feet35 => Some(16),
+            TimeDisplayStyle::Feet16 => Some(40),
+            _ => None,
+        }
+    }
+    pub fn id(self) -> &'static str {
+        match self {
+            TimeDisplayStyle::Timecode => "timecode",
+            TimeDisplayStyle::Frames => "frames",
+            TimeDisplayStyle::Feet35 => "feet35",
+            TimeDisplayStyle::Feet16 => "feet16",
+        }
+    }
+    pub fn parse(s: &str) -> Option<TimeDisplayStyle> {
+        let k: String = s.chars().filter(char::is_ascii_alphanumeric).collect::<String>().to_ascii_lowercase();
+        match k.as_str() {
+            "timecode" => Some(TimeDisplayStyle::Timecode),
+            "frames" => Some(TimeDisplayStyle::Frames),
+            "feet35" | "feetframes" | "feetandframes" | "feet35mm" | "35mm" | "feetframes35mm" => Some(TimeDisplayStyle::Feet35),
+            "feet16" | "feet16mm" | "16mm" | "feetframes16mm" => Some(TimeDisplayStyle::Feet16),
+            _ => None,
+        }
+    }
+}
+
+/// Project Settings ▸ Color ▸ Color Engine.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ColorEngine {
+    /// Built-in colour management (ICC-style working spaces).
+    #[default]
+    Adobe,
+    /// OCIO managed, with the built-in configuration (ACES working spaces).
+    Ocio,
+}
+
+/// Project Settings ▸ Color ▸ HDR: how over-range (HDR) values reach a standard-dynamic-range
+/// display or output.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub enum HdrMode {
+    /// Values above 1.0 clip.
+    #[default]
+    Clip,
+    /// Highlights above 80% are companded (an exponential knee) into the remaining range.
+    Compand,
+    /// Extended Reinhard tone mapping of luminance (white at 4.0).
+    ToneMap,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ProjectSettings {
+    pub bit_depth: BitDepth,
+    /// Linearize Working Space: the working space uses linear light (1.0 gamma) for everything
+    /// (sources, effects, blending). Needs a working space.
+    pub linearize: bool,
+    /// Working Space (colour management). `None` = no colour management.
+    #[serde(default)]
+    pub working_space: Option<ColorSpace>,
+    /// Blend Colors Using 1.0 Gamma: layers blend in linear light (sources and effects stay in
+    /// the working space's encoding).
+    #[serde(default)]
+    pub blend_linear: bool,
+    pub time_display: TimeDisplayStyle,
+    /// Frame numbering starts at 0 (or 1).
+    pub frame_start: i64,
+    pub audio_sample_rate: u32,
+    /// Video Rendering and Effects ▸ Use: Mercury GPU Acceleration (`true`, the default; used
+    /// when a GPU adapter exists) or Mercury Software Only (`false`, the CPU compositor).
+    #[serde(default = "yes")]
+    pub gpu_acceleration: bool,
+    /// The project's comment (Metadata panel).
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub comment: String,
+    /// Color Engine (Adobe-style built-in or OCIO with ACES working spaces).
+    #[serde(default)]
+    pub color_engine: ColorEngine,
+    /// HDR handling for standard-dynamic-range output (display and renders).
+    #[serde(default)]
+    pub hdr: HdrMode,
+    /// The space the top-level comp is output in (renders and the viewer's source). `None` =
+    /// sRGB; Rec. 2100 PQ / HLG give HDR output.
+    #[serde(default)]
+    pub output_space: Option<ColorSpace>,
+    /// Working Gamma, 2.2 or 2.4 (`app.project.workingGamma`): with no working space, the curve
+    /// Interpret As Linear Light footage is encoded with and Blend Colors Using 1.0 Gamma
+    /// linearizes with: the sRGB curve at 2.2, a pure 2.4 power curve at 2.4. Ignored with a
+    /// working space (as in After Effects).
+    #[serde(default = "gamma_22")]
+    pub working_gamma: f64,
+}
+
+fn gamma_22() -> f64 {
+    2.2
+}
+
+impl ProjectSettings {
+    /// Working Gamma is 2.4 (anything else reads as 2.2).
+    pub fn working_gamma_24(&self) -> bool {
+        (self.working_gamma - 2.4).abs() < 0.05
+    }
+}
+
+impl Default for ProjectSettings {
+    fn default() -> Self {
+        ProjectSettings {
+            bit_depth: BitDepth::Bpc8,
+            linearize: false,
+            working_space: None,
+            blend_linear: false,
+            time_display: TimeDisplayStyle::Timecode,
+            frame_start: 0,
+            audio_sample_rate: 48_000,
+            gpu_acceleration: true,
+            comment: String::new(),
+            color_engine: ColorEngine::Adobe,
+            hdr: HdrMode::Clip,
+            output_space: None,
+            working_gamma: 2.2,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct Marker {
+    pub time: Tick,
+    #[serde(default)]
+    pub duration: Tick,
+    #[serde(default)]
+    pub comment: String,
+    #[serde(default)]
+    pub label: Label,
+    #[serde(default)]
+    pub chapter: String,
+    #[serde(default)]
+    pub url: String,
+    #[serde(default)]
+    pub protected: bool,
+    /// Web link frame target (`_blank`, a frame name…).
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub frame_target: String,
+    /// Flash/video cue point (Event or Navigation) with name and parameters.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cue_point: Option<CuePoint>,
+}
+
+/// A marker's cue point (Composition/Layer Marker dialog ▸ Cue Point).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct CuePoint {
+    pub name: String,
+    /// Navigation (true) or Event cue point.
+    #[serde(default)]
+    pub navigation: bool,
+    /// (name, value) parameter pairs.
+    #[serde(default)]
+    pub params: Vec<(String, String)>,
+}
+
+pub(crate) fn yes() -> bool {
+    true
+}
diff --git a/crates/project/src/styles.rs b/crates/project/src/styles.rs
index 83db5e581..fd59fedda 100644
--- a/crates/project/src/styles.rs
+++ b/crates/project/src/styles.rs
@@ -312,6 +312,33 @@ impl Layer {
     pub fn can_have_styles(&self) -> bool {
         self.source.is_av() && !self.switches.adjustment
     }
+    /// Do the layer's styles change its pixels: the group on, and a style on or Advanced
+    /// Blending away from its defaults (animated counts as changed).
+    pub fn styles_change_pixels(&self) -> bool {
+        self.layer_styles()
+            .filter(|g| g.enabled && self.can_have_styles())
+            .is_some_and(|g| g.groups().any(|s| s.enabled && s.match_id != BLENDING) || g.sub(BLENDING).is_some_and(|bo| !blending_is_default(bo)))
+    }
+}
+
+/// Is Advanced Blending of this Blending Options group at its defaults (no keys, no
+/// expression)? Global Light is the comp's and doesn't count.
+pub fn blending_is_default(bo: &PropGroup) -> bool {
+    let mut next = 0;
+    let fresh = blending_options(&mut Ids(&mut next), &GlobalLight::default());
+    let (Some(adv), Some(def)) = (bo.sub("advancedBlending"), fresh.sub("advancedBlending")) else { return true };
+    def.props().all(|d| adv.get(&d.match_id).is_none_or(|p| same_anim(p, d)))
+}
+
+/// Give `layer` its Layer Styles group (Blending Options only, after Transform) when it has none.
+/// Returns the Blending Options group's uid.
+pub fn add_blending_options(layer: &mut Layer, ids: &mut Ids, gl: &GlobalLight) -> Option<u64> {
+    if layer.props.sub(GROUP).is_none() {
+        let g = layer_styles(ids, gl);
+        let at = layer.props.children.iter().position(|c| c.match_id() == "transform").map(|i| i + 1).unwrap_or(layer.props.children.len());
+        layer.props.children.insert(at, g.into());
+    }
+    Some(layer.props.sub(GROUP)?.sub(BLENDING)?.uid)
 }
 
 /// Add style `id` to `layer` (creating the Layer Styles group after Transform when missing).
@@ -319,9 +346,7 @@ impl Layer {
 pub fn add_style(layer: &mut Layer, ids: &mut Ids, id: &str, gl: &GlobalLight, enabled: bool) -> Option<u64> {
     let order = STYLES.iter().position(|s| s.0 == id)?;
     if layer.props.sub(GROUP).is_none() {
-        let g = layer_styles(ids, gl);
-        let at = layer.props.children.iter().position(|c| c.match_id() == "transform").map(|i| i + 1).unwrap_or(layer.props.children.len());
-        layer.props.children.insert(at, g.into());
+        add_blending_options(layer, ids, gl);
     }
     let ls = layer.props.sub_mut(GROUP)?;
     if let Some(g) = ls.sub(id) {
@@ -470,7 +495,7 @@ mod tests {
         let mut ids = Ids(&mut p.next_id);
         add_style(&mut a, &mut ids, "dropShadow", &gl, true);
         add_style(&mut b, &mut ids, "bevelEmboss", &gl, true);
-        comp.layers = vec![a, b];
+        comp.layers = vec![a, b].into();
         comp.layers[1].props.sub_mut(GROUP).unwrap().sub_mut(BLENDING).unwrap().get_mut("globalLightAngle").unwrap().value = Value::Scalar(45.0);
         assert!(needs_sync(&comp));
         sync_comp(&mut comp);
diff --git a/crates/project/src/tests.rs b/crates/project/src/tests.rs
index fe36c7724..a47792b89 100644
--- a/crates/project/src/tests.rs
+++ b/crates/project/src/tests.rs
@@ -162,6 +162,8 @@ fn project_files_name_their_version_and_always_read_back() {
     assert!(text.trim_start().starts_with("{\n  \"savedBy\""), "the version comes first");
     assert_eq!(Project::from_json(&text).unwrap(), p);
     assert_eq!(crate::saved_by(&p.to_json()), None, "plain JSON (worker hand-offs) has none");
+    assert_eq!(crate::saved_by(r#"{"savedBy": "999.0.0", "schema": 3}"#).as_deref(), Some("999.0.0"), "a newer schema still names its version");
+    assert_eq!(crate::saved_by(r#"[2, {}, {}, 1]"#), None, "the array form has none");
     // JSON can't hold NaN: saving refuses instead of writing a file that can't be opened.
     p.comp_mut(cid).unwrap().layers[0].props.prop_mut("transform/opacity").unwrap().value = Value::Scalar(f64::NAN);
     let e = p.to_file_json().unwrap_err().to_string();
@@ -183,7 +185,7 @@ fn project_files_refuse_newer_schemas() {
         crate::SCHEMA_VERSION
     );
     assert_eq!(p.to_file_json().unwrap_err().to_string(), expected);
-    assert_eq!(p.to_file_json_with_view(&crate::SavedView::default()).unwrap_err().to_string(), expected);
+    assert_eq!(p.to_file_json_with_view(&crate::SavedView::default(), false).unwrap_err().to_string(), expected);
 }
 
 #[test]
@@ -193,11 +195,27 @@ fn saved_files_reopen_in_pretty_and_compact_form() {
     assert_eq!(Project::from_json(&p.to_json_compact()).unwrap(), p, "compact JSON");
 }
 
+/// A project file read back and saved again is the same text, indented and compact (Save Compact
+/// Project Files), with its saved view.
+#[test]
+fn project_files_save_again_byte_for_byte() {
+    let (p, cid) = project_with_layer();
+    let view = crate::SavedView { active_comp: Some(cid), open_comps: vec![cid], comp_times: [(cid, effectcraft_time::Tick(4_237_833_600))].into() };
+    for compact in [false, true] {
+        let text = p.to_file_json_with_view(&view, compact).unwrap();
+        let prefix = if compact { "{\"savedBy\":\"" } else { "{\n  \"savedBy\": \"" };
+        assert!(text.starts_with(&format!("{prefix}{}\"", crate::APP_VERSION)), "compact {compact}: {text}");
+        assert_eq!(text.contains('\n'), !compact);
+        let again = Project::from_json(&text).unwrap().to_file_json_with_view(&crate::saved_view(&text), compact).unwrap();
+        assert_eq!(again, text, "compact {compact}");
+    }
+}
+
 #[test]
 fn project_files_remember_the_open_comps() {
     let (p, cid) = project_with_layer();
     let view = crate::SavedView { active_comp: Some(cid), open_comps: vec![cid], comp_times: [(cid, effectcraft_time::Tick(4_237_833_600))].into() };
-    let text = p.to_file_json_with_view(&view).unwrap();
+    let text = p.to_file_json_with_view(&view, false).unwrap();
     assert_eq!(crate::saved_view(&text), view);
     assert_eq!(Project::from_json(&text).unwrap(), p, "the view is not part of the project");
     // Files from before #748 have no view; a garbled one is ignored, not an error.
@@ -290,3 +308,78 @@ fn comp_contains_ends_on_cycles_long_chains_and_shared_precomps() {
     assert!(p.comp_contains(c[0], c[n - 1]));
     assert!(!p.comp_contains(c[n - 1], c[0]));
 }
+
+/// Interpret Footage ▸ Cineon Settings: the 10 Bit Black and White Points become the converted
+/// points, Current Gamma 1 gives linear light, Highlight Rolloff 0 keeps over-range values and
+/// a higher one ramps them off; the settings apply only to DPX and Cineon files, and projects
+/// saved without them read the defaults.
+#[test]
+fn cineon_settings_convert_log_code_values() {
+    use crate::{CineonSettings, CineonUnits, Footage};
+    let code = |v: f32| v / 1023.0;
+    let c = CineonSettings { log_conversion: true, rolloff: 0.0, ..Default::default() };
+    assert!(c.convert(code(95.0)).abs() < 1e-6, "black point");
+    assert!((c.convert(code(685.0)) - 1.0).abs() < 1e-5, "white point");
+    // Code 400: (10^(-0.95) - 10^(-1.9667)) / (1 - 10^(-1.9667)) = 0.10251 linear, ^(1/1.7).
+    assert!((c.convert(code(400.0)) - 0.26190).abs() < 1e-4, "{}", c.convert(code(400.0)));
+    let linear = CineonSettings { gamma: 1.0, ..c };
+    assert!((linear.convert(code(400.0)) - 0.10251).abs() < 1e-4, "{}", linear.convert(code(400.0)));
+    assert!(c.convert(code(1023.0)) > 1.5, "over range kept: {}", c.convert(code(1023.0)));
+    // The default rolloff (20) ramps the white point and above off, up to 1.
+    let rolled = CineonSettings { rolloff: 20.0, ..c };
+    let (w, mid, top) = (rolled.convert(code(685.0)), rolled.convert(code(720.0)), rolled.convert(code(1023.0)));
+    assert!(w > 0.8 && w < mid && mid < top && top <= 1.0, "{w} {mid} {top}");
+    let points = CineonSettings { converted_black: 64.0, converted_white: 940.0, ..c };
+    assert!((points.convert(code(95.0)) - 64.0 / 1023.0).abs() < 1e-5);
+    assert!((points.convert(code(685.0)) - 940.0 / 1023.0).abs() < 1e-5);
+    // Units.
+    assert!((CineonUnits::EightBit.from_ten_bit(1023.0) - 255.0).abs() < 1e-9);
+    assert!((CineonUnits::Float.to_ten_bit(0.5) - 511.5).abs() < 1e-9);
+    assert_eq!(CineonUnits::parse("8-bit"), Some(CineonUnits::EightBit));
+    assert!(CineonUnits::ALL.iter().all(|u| CineonUnits::parse(u.id()) == Some(*u)));
+    // DPX and Cineon files only, and only with Logarithmic Conversion on.
+    let on = CineonSettings { log_conversion: true, ..Default::default() };
+    let dpx = Footage { path: "/m/plate.0001.DPX".into(), cineon: on, ..Default::default() };
+    assert!(dpx.cineon_applies());
+    assert!(Footage { path: "/m/scan.cin".into(), cineon: on, ..Default::default() }.cineon_applies());
+    assert!(!Footage { path: "/m/still.png".into(), cineon: on, ..Default::default() }.cineon_applies());
+    assert!(!Footage { path: "/m/plate.dpx".into(), ..Default::default() }.cineon_applies());
+    // Saved only when changed; read back, and absent in older projects.
+    let plain = serde_json::to_value(Footage { path: "/m/a.dpx".into(), ..Default::default() }).unwrap();
+    assert!(plain.get("cineon").is_none(), "{plain}");
+    let saved = serde_json::to_string(&dpx).unwrap();
+    assert_eq!(serde_json::from_str::<Footage>(&saved).unwrap().cineon, on);
+    assert_eq!(serde_json::from_value::<Footage>(plain).unwrap().cineon, CineonSettings::default());
+}
+
+/// A Wiggle Paths 100 000 groups deep gets Spatial Phase on a 2 MiB stack.
+#[test]
+fn upgrading_deeply_nested_shape_groups_fits_a_small_stack() {
+    let n = 100_000;
+    let mut next = 1;
+    let mut contents = build::shape_simple_op(&mut Ids(&mut next), "wiggle").unwrap();
+    contents.children.retain(|c| c.match_id() != "spatialPhase");
+    for _ in 0..n {
+        let uid = Ids(&mut next).alloc();
+        contents = crate::PropGroup::new(uid, "group", "Group 1").with(contents);
+    }
+    let h = std::thread::Builder::new()
+        .stack_size(2 << 20)
+        .spawn(move || {
+            let added = build::upgrade_shape_contents(&mut Ids(&mut next), &mut contents);
+            (added, contents)
+        })
+        .unwrap();
+    let (added, mut g) = h.join().unwrap();
+    assert!(added);
+    // One level at a time: dropping the whole tree would recurse as deep as it is nested.
+    let mut depth = 0;
+    while g.match_id == "group" {
+        let Some(crate::Node::Group(child)) = g.children.pop() else { panic!("a nested group") };
+        g = child;
+        depth += 1;
+    }
+    assert_eq!(depth, n);
+    let ids: Vec<&str> = g.children.iter().map(|c| c.match_id()).collect();
+    assert_eq!(ids, ["size", "detail", "points", "speed", "correlation", "phase", "spatialPhase", "seed"]);
+}
diff --git a/crates/psd/Cargo.toml b/crates/psd/Cargo.toml
index 49dda6a3b..b6849041b 100644
--- a/crates/psd/Cargo.toml
+++ b/crates/psd/Cargo.toml
@@ -10,4 +10,4 @@ rust-version.workspace = true
 workspace = true
 
 [dependencies]
-miniz_oxide = "0.8"
+miniz_oxide = "0.9"
diff --git a/crates/psd/src/counters.rs b/crates/psd/src/counters.rs
new file mode 100644
index 000000000..f5c59b02c
--- /dev/null
+++ b/crates/psd/src/counters.rs
@@ -0,0 +1,19 @@
+use std::cell::Cell;
+use std::thread::LocalKey;
+
+thread_local! {
+    /// Scratch rows allocated by the 32-bit ZIP un-predictor.
+    pub static SCRATCH: Cell<usize> = const { Cell::new(0) };
+    /// `inside the mask rect` evaluations of the layer-mask loop.
+    pub static INSIDE: Cell<usize> = const { Cell::new(0) };
+    /// `square_to_quad` solves.
+    pub static QUAD: Cell<usize> = const { Cell::new(0) };
+}
+
+pub fn bump(c: &'static LocalKey<Cell<usize>>) {
+    c.with(|c| c.set(c.get() + 1));
+}
+/// Read and reset.
+pub fn take(c: &'static LocalKey<Cell<usize>>) -> usize {
+    c.with(|c| c.replace(0))
+}
diff --git a/crates/psd/src/lib.rs b/crates/psd/src/lib.rs
index 5ae32126a..91792a837 100644
--- a/crates/psd/src/lib.rs
+++ b/crates/psd/src/lib.rs
@@ -1,5 +1,5 @@
 //! Photoshop document (PSD / PSB) reader, implemented from Adobe's public *Photoshop File Formats
-//! Specification* (see README.md), and a minimal writer ([`write`]) for fixtures.
+//! Specification* (see README.md), and a minimal writer ([`mod@write`]) for fixtures.
 //!
 //! [`Psd::parse`] reads the structure (header, layer records and their additional information,
 //! the layer tree) without decoding pixels; [`Psd::composite`] decodes the merged image and
@@ -15,411 +15,26 @@ pub mod placed;
 mod read;
 pub mod write;
 
-use std::borrow::Cow;
 use std::sync::Arc;
 
 pub use descriptor::{DValue, Descriptor};
 use read::Reader;
 
-#[derive(Debug, Clone, PartialEq)]
-pub enum Error {
-    NotPsd,
-    Truncated,
-    Unsupported(String),
-    Invalid(String),
-}
+mod limits;
+mod model;
+mod parse;
+mod pixels;
 
-impl std::fmt::Display for Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Error::NotPsd => write!(f, "not a Photoshop document"),
-            Error::Truncated => write!(f, "truncated Photoshop document"),
-            Error::Unsupported(s) => write!(f, "unsupported Photoshop feature: {s}"),
-            Error::Invalid(s) => write!(f, "invalid Photoshop document: {s}"),
-        }
-    }
-}
-
-impl std::error::Error for Error {}
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-/// The most pixels one decoded image (the composite, a layer or a mask) may have: 2^28, e.g.
-/// 16 384 × 16 384, 4 GiB as float RGBA. Bounds read from a file are untrusted, so a few bytes
-/// can't make the reader allocate more than that.
-const MAX_DECODE_PIXELS: u64 = 1 << 28;
-
-/// `w × h` as a pixel count, or an error when it exceeds [`MAX_DECODE_PIXELS`].
-fn decode_pixels(w: usize, h: usize) -> Result<usize> {
-    match (w as u64).checked_mul(h as u64) {
-        Some(n) if n <= MAX_DECODE_PIXELS => Ok(n as usize),
-        _ => Err(Error::Unsupported(format!("{w}×{h} pixels is too large to decode"))),
-    }
-}
-
-fn too_large(w: usize, h: usize) -> Error {
-    Error::Unsupported(format!("{w}×{h} pixels is too large to decode"))
-}
-
-/// What one decode (the composite, or one layer) may hold in memory at once: 4 GiB, 1 GiB where
-/// pointers are 32 bits wide (WebAssembly). [`MAX_DECODE_PIXELS`] bounds one image; this bounds
-/// the sum of the buffers a decode keeps alive together.
-#[cfg(target_pointer_width = "32")]
-const DECODE_BUDGET: u64 = 1 << 30;
-#[cfg(not(target_pointer_width = "32"))]
-const DECODE_BUDGET: u64 = 4 << 30;
-
-/// The bytes the buffers of one decode hold right now, against a limit. A decode charges a buffer
-/// before it allocates it (and releases it when it drops it), so a file that would need more
-/// than the limit fails with an error instead of an out-of-memory abort.
-struct Budget {
-    limit: u64,
-    live: u64,
-}
-
-impl Budget {
-    fn new(limit: u64) -> Budget {
-        Budget { limit, live: 0 }
-    }
-
-    fn charge(&mut self, bytes: u64) -> Result<()> {
-        self.check(bytes)?;
-        self.live += bytes;
-        Ok(())
-    }
-
-    /// Whether `bytes` more would still fit, without taking them. A decode checks its whole
-    /// expected peak first, so one that cannot fit fails before it has allocated anything.
-    fn check(&self, bytes: u64) -> Result<()> {
-        match self.live.checked_add(bytes) {
-            Some(total) if total <= self.limit => Ok(()),
-            _ => {
-                const MIB: u64 = 1 << 20;
-                Err(Error::Unsupported(format!(
-                    "decoding needs {} MiB more with {} MiB in use, over the {} MiB memory budget",
-                    bytes / MIB,
-                    self.live / MIB,
-                    self.limit / MIB
-                )))
-            }
-        }
-    }
-
-    fn release(&mut self, bytes: u64) {
-        self.live = self.live.saturating_sub(bytes);
-    }
-
-    /// An empty vector with room for `n` items, charged.
-    fn vec<T>(&mut self, n: usize) -> Result<Vec<T>> {
-        self.charge((n as u64).saturating_mul(std::mem::size_of::<T>() as u64))?;
-        let mut v = Vec::new();
-        v.try_reserve_exact(n).map_err(|_| Error::Unsupported(format!("out of memory for {n} items")))?;
-        Ok(v)
-    }
-
-    /// `n` copies of `value`, charged.
-    fn filled<T: Clone>(&mut self, n: usize, value: T) -> Result<Vec<T>> {
-        let mut v = self.vec::<T>(n)?;
-        v.resize(n, value);
-        Ok(v)
-    }
-}
-
-/// Inflate a zlib stream to at most `limit` bytes.
-fn inflate(src: &[u8], limit: usize) -> Result<Vec<u8>> {
-    miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(src, limit).map_err(|e| Error::Invalid(format!("zip: {e:?}")))
-}
-
-/// Give back what a channel buffer from `Psd::channel_bytes` / `Psd::decode_plane` was charged:
-/// a borrowed one (uncompressed data, or a plane of an inflated stream charged as a whole) was not.
-fn release_bytes(budget: &mut Budget, raw: Cow<'_, [u8]>) {
-    if let Cow::Owned(v) = raw {
-        budget.release(v.len() as u64);
-    }
-}
-
-/// A 32-bit float sample made safe to use: NaN reads as 0, +inf as white (1.0, like the integer
-/// depths' maximum), -inf as 0.
-fn finite_sample(v: f32) -> f32 {
-    if v.is_nan() {
-        0.0
-    } else if v == f32::INFINITY {
-        1.0
-    } else if v == f32::NEG_INFINITY {
-        0.0
-    } else {
-        v
-    }
-}
-
-/// Whether `bytes` start like a Photoshop document.
-pub fn is_psd(bytes: &[u8]) -> bool {
-    bytes.len() >= 6 && &bytes[..4] == b"8BPS" && matches!(u16::from_be_bytes([bytes[4], bytes[5]]), 1 | 2)
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum ColorMode {
-    Bitmap,
-    Grayscale,
-    Indexed,
-    Rgb,
-    Cmyk,
-    Multichannel,
-    Duotone,
-    Lab,
-}
-
-impl ColorMode {
-    pub fn from_u16(v: u16) -> Option<ColorMode> {
-        Some(match v {
-            0 => ColorMode::Bitmap,
-            1 => ColorMode::Grayscale,
-            2 => ColorMode::Indexed,
-            3 => ColorMode::Rgb,
-            4 => ColorMode::Cmyk,
-            7 => ColorMode::Multichannel,
-            8 => ColorMode::Duotone,
-            9 => ColorMode::Lab,
-            _ => return None,
-        })
-    }
-    pub fn to_u16(self) -> u16 {
-        match self {
-            ColorMode::Bitmap => 0,
-            ColorMode::Grayscale => 1,
-            ColorMode::Indexed => 2,
-            ColorMode::Rgb => 3,
-            ColorMode::Cmyk => 4,
-            ColorMode::Multichannel => 7,
-            ColorMode::Duotone => 8,
-            ColorMode::Lab => 9,
-        }
-    }
-    /// Number of colour channels (before alpha).
-    pub fn color_channels(self) -> usize {
-        match self {
-            ColorMode::Rgb | ColorMode::Lab => 3,
-            ColorMode::Cmyk => 4,
-            _ => 1,
-        }
-    }
-}
-
-/// A rectangle in document pixels (`right`/`bottom` exclusive).
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct Rect {
-    pub top: i32,
-    pub left: i32,
-    pub bottom: i32,
-    pub right: i32,
-}
-
-impl Rect {
-    pub fn new(left: i32, top: i32, width: i32, height: i32) -> Rect {
-        Rect { top, left, bottom: top.saturating_add(height), right: left.saturating_add(width) }
-    }
-    pub fn width(&self) -> u32 {
-        (i64::from(self.right) - i64::from(self.left)).clamp(0, i64::from(u32::MAX)) as u32
-    }
-    pub fn height(&self) -> u32 {
-        (i64::from(self.bottom) - i64::from(self.top)).clamp(0, i64::from(u32::MAX)) as u32
-    }
-    pub fn is_empty(&self) -> bool {
-        self.width() == 0 || self.height() == 0
-    }
-}
-
-/// One channel of a layer: id (0.. colour, -1 transparency, -2 layer mask, -3 real user mask) and
-/// where its data (compression + image data) sits in the file.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct ChannelInfo {
-    pub id: i16,
-    pub offset: usize,
-    pub len: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct LayerMask {
-    pub rect: Rect,
-    /// Value outside the mask rectangle (0 or 255).
-    pub default_color: u8,
-    pub disabled: bool,
-    pub inverted: bool,
-}
-
-/// Layer kind from the section divider setting (`lsct`).
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub enum Section {
-    #[default]
-    Layer,
-    OpenFolder,
-    ClosedFolder,
-    /// The hidden "</Layer group>" record that closes a group (below its children).
-    Divider,
-}
-
-/// A type layer (`TySh`).
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct TextInfo {
-    /// Text with `\n` line breaks.
-    pub text: String,
-    /// Affine transform (xx, xy, yx, yy, tx, ty): the text origin sits at (tx, ty).
-    pub transform: [f64; 6],
-    pub style: engine_data::TextStyle,
-    /// Text bounds (left, top, right, bottom) relative to the origin, when stored.
-    pub bounds: Option<[f64; 4]>,
-}
-
-/// Adjustment layers (best effort).
-#[derive(Clone, Debug, PartialEq)]
-pub enum Adjustment {
-    Invert,
-    BrightnessContrast {
-        brightness: f64,
-        contrast: f64,
-        legacy: bool,
-    },
-    HueSaturation {
-        hue: f64,
-        saturation: f64,
-        lightness: f64,
-        colorize: bool,
-    },
-    Levels {
-        in_black: f64,
-        in_white: f64,
-        gamma: f64,
-        out_black: f64,
-        out_white: f64,
-    },
-    Exposure {
-        exposure: f64,
-        offset: f64,
-        gamma: f64,
-    },
-    /// Another adjustment (its tagged-block key, e.g. `curv`, `blnc`).
-    Other(String),
-}
-
-/// A vector mask path: sub-paths of (in tangent, vertex, out tangent) points in document pixels.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct VectorMask {
-    pub inverted: bool,
-    pub disabled: bool,
-    pub subpaths: Vec<SubPath>,
-}
-
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct SubPath {
-    pub closed: bool,
-    /// Per knot: [control point preceding, anchor, control point leaving] as (x, y).
-    pub knots: Vec<[[f64; 2]; 3]>,
-}
-
-/// A placed layer (smart object): `SoLd` / `SoLE` (placed layer data) or the older `PlLd`.
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct SmartObject {
-    /// Unique id of the linked file ([`Psd::linked`]) the layer shows.
-    pub uuid: String,
-    /// Where the content's corners sit in document pixels: top-left, top-right, bottom-right,
-    /// bottom-left.
-    pub quad: [[f64; 2]; 4],
-    /// The content's size in pixels (`Sz  `), when recorded.
-    pub size: Option<[f64; 2]>,
-    /// The placed layer's warp (`warp`), when it has one ([`placed`]).
-    pub warp: Option<placed::Warp>,
-}
-
-impl SmartObject {
-    /// The quad as an affine placement of a `w`×`h` content rectangle: (centre, scale x, scale
-    /// y, rotation in degrees). Perspective and skew are dropped.
-    pub fn placement(&self, w: f64, h: f64) -> ([f64; 2], f64, f64, f64) {
-        let q = self.quad;
-        let centre = [(q[0][0] + q[1][0] + q[2][0] + q[3][0]) / 4.0, (q[0][1] + q[1][1] + q[2][1] + q[3][1]) / 4.0];
-        let top = [q[1][0] - q[0][0], q[1][1] - q[0][1]];
-        let left = [q[3][0] - q[0][0], q[3][1] - q[0][1]];
-        let sx = top[0].hypot(top[1]) / w.max(1e-9);
-        let sy = left[0].hypot(left[1]) / h.max(1e-9);
-        // Mirrored content (left edge turning the other way) keeps a negative y scale.
-        let cross = top[0] * left[1] - top[1] * left[0];
-        (centre, sx, if cross < 0.0 { -sy } else { sy }, top[1].atan2(top[0]).to_degrees())
-    }
-}
-
-/// A file embedded in (or linked from) the document: linked layer data (`lnk2`, `lnkD`,
-/// `lnk3`, `lnkE`).
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct LinkedFile {
-    pub uuid: String,
-    pub name: String,
-    /// File type code (`8BPS`, `PNGf`, `JPEG`…), may be blank.
-    pub file_type: String,
-    /// Embedded data (absent for externally linked files).
-    pub data: Option<std::ops::Range<usize>>,
-}
-
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct Layer {
-    /// Index in [`Psd::layers`] (file order: bottom of the stack first).
-    pub index: usize,
-    pub name: String,
-    pub id: Option<u32>,
-    pub rect: Rect,
-    /// Blend mode key (`norm`, `mul `, `pass`…).
-    pub blend: [u8; 4],
-    pub opacity: u8,
-    /// Fill opacity (`iOpa`), 255 when absent.
-    pub fill_opacity: u8,
-    /// Clipped to the layer below.
-    pub clipping: bool,
-    pub hidden: bool,
-    pub protect_transparency: bool,
-    pub section: Section,
-    pub channels: Vec<ChannelInfo>,
-    pub mask: Option<LayerMask>,
-    pub text: Option<TextInfo>,
-    pub adjustment: Option<Adjustment>,
-    /// Solid colour fill layer (`SoCo`), RGB 0..1.
-    pub fill: Option<[f64; 3]>,
-    /// Layer effects (`lfx2` descriptor).
-    pub effects: Option<Descriptor>,
-    pub vector_mask: Option<VectorMask>,
-    /// Smart object placement.
-    pub smart_object: Option<SmartObject>,
-    /// Keys of every additional-information block the layer carries.
-    pub keys: Vec<[u8; 4]>,
-}
-
-impl Layer {
-    pub fn is_group(&self) -> bool {
-        matches!(self.section, Section::OpenFolder | Section::ClosedFolder)
-    }
-    pub fn blend_key(&self) -> &str {
-        std::str::from_utf8(&self.blend).unwrap_or("norm")
-    }
-    pub fn has_pixels(&self) -> bool {
-        !self.rect.is_empty() && self.channels.iter().any(|c| c.id >= 0)
-    }
-}
-
-/// How deep groups nest in [`Psd::tree`]; deeper ones are flattened (a hostile file can nest
-/// thousands, and walking or dropping that tree would overflow the stack).
-pub const MAX_GROUP_DEPTH: usize = 64;
-
-/// The layer tree, top of the stack first.
-#[derive(Clone, Debug, PartialEq)]
-pub enum Node {
-    Layer(usize),
-    Group { layer: usize, children: Vec<Node> },
-}
-
-/// Decoded pixels: straight RGBA, row-major.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Pixels {
-    pub width: u32,
-    pub height: u32,
-    pub data: Vec<[f32; 4]>,
-}
+#[cfg(test)]
+use limits::{Budget, decode_pixels};
+pub use limits::{Error, Result};
+pub use model::{
+    Adjustment, ChannelInfo, ColorMode, Layer, LayerMask, LinkedFile, MAX_GROUP_DEPTH, Node, Pixels, Rect, Section, SmartObject, SubPath, TextInfo, VectorMask,
+};
+pub use parse::is_psd;
+pub(crate) use pixels::pack_bits;
+#[cfg(test)]
+use pixels::{lab_to_rgb, srgb_encode, unpack_bits};
 
 /// A parsed Photoshop document.
 #[derive(Clone, Debug)]
@@ -446,1078 +61,11 @@ pub struct Psd {
     merged_offset: usize,
 }
 
-impl Psd {
-    pub fn parse(data: impl Into<Arc<[u8]>>) -> Result<Psd> {
-        let data: Arc<[u8]> = data.into();
-        let mut r = Reader::new(&data);
-        if r.bytes(4).ok() != Some(b"8BPS") {
-            return Err(Error::NotPsd);
-        }
-        let version = r.u16()?;
-        let psb = match version {
-            1 => false,
-            2 => true,
-            _ => return Err(Error::NotPsd),
-        };
-        r.skip(6)?;
-        let channels = r.u16()?;
-        let height = r.u32()?;
-        let width = r.u32()?;
-        let depth = r.u16()?;
-        let mode_v = r.u16()?;
-        let mode = ColorMode::from_u16(mode_v).ok_or_else(|| Error::Unsupported(format!("colour mode {mode_v}")))?;
-        if !matches!(depth, 1 | 8 | 16 | 32) {
-            return Err(Error::Unsupported(format!("{depth}-bit")));
-        }
-        if width == 0 || height == 0 || width > 300_000 || height > 300_000 {
-            return Err(Error::Invalid(format!("size {width}x{height}")));
-        }
-        // Colour mode data.
-        let n = r.u32()? as usize;
-        let palette = r.bytes(n)?.to_vec();
-        // Image resources.
-        let n = r.u32()? as usize;
-        r.skip(n)?;
-        // Layer and mask information.
-        let mut psd = Psd {
-            psb,
-            width,
-            height,
-            channels,
-            depth,
-            mode,
-            layers: vec![],
-            merged_alpha: false,
-            palette,
-            linked: vec![],
-            warnings: vec![],
-            data: data.clone(),
-            merged_offset: 0,
-        };
-        let lm_len = r.length(psb)?;
-        let lm_end = r.pos.checked_add(lm_len).filter(|&e| e <= data.len()).ok_or(Error::Truncated)?;
-        if lm_len > 0 {
-            let li_len = r.length(psb)?;
-            let li_end = r.pos.checked_add(li_len).filter(|&e| e <= lm_end).ok_or(Error::Truncated)?;
-            if li_len > 0
-                && let Err(e) = psd.layer_info(&data, r.pos, li_end)
-            {
-                // A damaged layer section must not discard the document: keep the header and the
-                // merged image, drop the layers and say so. Without a merged image there is
-                // nothing to fall back to, so the original error stands.
-                if lm_end.checked_add(2).is_none_or(|n| n > data.len()) {
-                    return Err(e);
-                }
-                psd.layers.clear();
-                psd.warnings.push(format!("Layers could not be read ({e}); only the flattened image is available"));
-            }
-            r.pos = li_end;
-            if r.pos + 4 <= lm_end {
-                let g = r.u32()? as usize;
-                r.pos = (r.pos + g).min(lm_end);
-            }
-            // Global additional layer information (16/32-bit layer info lives here).
-            while let Some((key, start, end)) = next_block(&data, &mut r.pos, lm_end, psb) {
-                if matches!(&key, b"lnk2" | b"lnkD" | b"lnk3" | b"lnkE") {
-                    psd.linked_files(&data, start, end);
-                }
-                if matches!(&key, b"Lr16" | b"Lr32" | b"Layr") && psd.layers.is_empty() && end > start {
-                    // The block holds the layer info, normally without its length field; accept
-                    // both layouts.
-                    if psd.layer_info(&data, start, end).is_err() || psd.layers.is_empty() {
-                        psd.layers.clear();
-                        let skip = if psb { 8 } else { 4 };
-                        if start + skip < end && psd.layer_info(&data, start + skip, end).is_err() {
-                            psd.layers.clear();
-                        }
-                    }
-                }
-                r.pos = end;
-            }
-        }
-        if !psd.layers.is_empty() {
-            // A 16/32-bit layer block recovered the layers.
-            psd.warnings.clear();
-        }
-        psd.merged_offset = lm_end;
-        Ok(psd)
-    }
-
-    /// The embedded bytes of linked file `uuid`.
-    pub fn linked_data(&self, uuid: &str) -> Option<&[u8]> {
-        let f = self.linked.iter().find(|f| f.uuid == uuid)?;
-        self.data.get(f.data.clone()?)
-    }
-
-    /// Linked layer data records (spec: "Linked Layer"): length, kind (`liFD` embedded data,
-    /// `liFE` external file, `liFA` alias), version, unique id, original file name, type,
-    /// creator, data length, optional descriptors, then the data. A damaged record ends the list.
-    fn linked_files(&mut self, data: &[u8], start: usize, end: usize) {
-        let mut pos = start;
-        while pos + 8 <= end {
-            let mut r = Reader::at(&data[..end], pos);
-            let Ok(len) = r.u64() else { break };
-            let body = r.pos;
-            let Some(rec_end) = body.checked_add(len as usize).filter(|e| *e <= end) else { break };
-            let mut r = Reader::at(&data[..rec_end], body);
-            let rec = (|| -> Result<LinkedFile> {
-                let kind = r.tag()?;
-                let version = r.u32()?;
-                let n = r.u8()? as usize;
-                let uuid = String::from_utf8_lossy(r.bytes(n)?).into_owned();
-                let name = descriptor::read_unicode(&mut r)?;
-                let file_type = String::from_utf8_lossy(&r.tag()?).trim().to_string();
-                let _creator = r.tag()?;
-                let dlen = r.u64()? as usize;
-                if r.u8()? != 0 {
-                    let _v = r.u32()?;
-                    descriptor::read_descriptor(&mut r)?;
-                }
-                let mut out = LinkedFile { uuid, name, file_type, data: None };
-                match &kind {
-                    b"liFD" => {
-                        let s = r.pos;
-                        r.skip(dlen)?;
-                        out.data = Some(s..s + dlen);
-                    }
-                    b"liFE" => {
-                        let _v = r.u32()?;
-                        descriptor::read_descriptor(&mut r)?;
-                        if version > 3 {
-                            r.skip(4 + 4 + 8)?;
-                        }
-                        let _size = r.u64()?;
-                        if version > 2 && r.remaining() >= dlen && dlen > 0 {
-                            let s = r.pos;
-                            out.data = Some(s..s + dlen);
-                        }
-                    }
-                    _ => {}
-                }
-                Ok(out)
-            })();
-            match rec {
-                Ok(f) => self.linked.push(f),
-                Err(_) => break,
-            }
-            pos = rec_end.div_ceil(4) * 4;
-        }
-    }
-
-    fn layer_info(&mut self, data: &[u8], start: usize, end: usize) -> Result<()> {
-        let mut r = Reader::at(&data[..end], start);
-        let count = r.i16()?;
-        self.merged_alpha = count < 0;
-        let n = count.unsigned_abs() as usize;
-        let mut layers = Vec::with_capacity(n);
-        for i in 0..n {
-            layers.push(self.layer_record(&mut r, i)?);
-        }
-        // Channel image data follows in record order.
-        for l in &mut layers {
-            for c in &mut l.channels {
-                c.offset = r.pos;
-                r.skip(c.len)?;
-            }
-        }
-        self.layers = layers;
-        Ok(())
-    }
-
-    fn layer_record(&self, r: &mut Reader, index: usize) -> Result<Layer> {
-        let psb = self.psb;
-        let (top, left, bottom, right) = (r.i32()?, r.i32()?, r.i32()?, r.i32()?);
-        let nch = r.u16()? as usize;
-        if nch > 64 {
-            return Err(Error::Invalid("channel count".into()));
-        }
-        let mut channels = Vec::with_capacity(nch);
-        for _ in 0..nch {
-            let id = r.i16()?;
-            let len = r.length(psb)?;
-            channels.push(ChannelInfo { id, offset: 0, len });
-        }
-        if r.bytes(4)? != b"8BIM" {
-            return Err(Error::Invalid("layer record signature".into()));
-        }
-        let blend = r.tag()?;
-        let opacity = r.u8()?;
-        let clipping = r.u8()? != 0;
-        let flags = r.u8()?;
-        r.skip(1)?;
-        let extra = r.u32()? as usize;
-        let extra_end = r.pos.checked_add(extra).filter(|&e| e <= r.data.len()).ok_or(Error::Truncated)?;
-        let mut l = Layer {
-            index,
-            rect: Rect { top, left, bottom, right },
-            blend,
-            opacity,
-            fill_opacity: 255,
-            clipping,
-            hidden: flags & 2 != 0,
-            protect_transparency: flags & 1 != 0,
-            channels,
-            ..Default::default()
-        };
-        // Layer mask data.
-        let mlen = r.u32()? as usize;
-        let mstart = r.pos;
-        if mlen >= 18 {
-            let rect = Rect { top: r.i32()?, left: r.i32()?, bottom: r.i32()?, right: r.i32()? };
-            let default_color = r.u8()?;
-            let mflags = r.u8()?;
-            l.mask = Some(LayerMask { rect, default_color, disabled: mflags & 2 != 0, inverted: mflags & 4 != 0 });
-        }
-        r.pos = mstart + mlen;
-        // Blending ranges.
-        let blen = r.u32()? as usize;
-        r.skip(blen)?;
-        l.name = r.pascal(4)?;
-        let mut pos = r.pos;
-        let data = r.data;
-        while let Some((key, start, end)) = next_block(data, &mut pos, extra_end, psb) {
-            l.keys.push(key);
-            let block = &data[start..end];
-            // A malformed block only loses that block's information.
-            let _ = self.layer_block(&mut l, &key, block);
-            pos = end;
-        }
-        r.pos = extra_end;
-        Ok(l)
-    }
-
-    fn layer_block(&self, l: &mut Layer, key: &[u8; 4], b: &[u8]) -> Result<()> {
-        let mut r = Reader::new(b);
-        match key {
-            b"luni" => {
-                let name = descriptor::read_unicode(&mut r)?;
-                if !name.is_empty() {
-                    l.name = name;
-                }
-            }
-            b"lyid" => l.id = Some(r.u32()?),
-            b"iOpa" => l.fill_opacity = r.u8()?,
-            b"lsct" | b"lsdk" => {
-                l.section = match r.u32()? {
-                    1 => Section::OpenFolder,
-                    2 => Section::ClosedFolder,
-                    3 => Section::Divider,
-                    _ => Section::Layer,
-                };
-                if b.len() >= 12 && &b[4..8] == b"8BIM" {
-                    l.blend.copy_from_slice(&b[8..12]);
-                }
-            }
-            b"TySh" => {
-                let _ver = r.u16()?;
-                let mut t = [0.0; 6];
-                for v in &mut t {
-                    *v = r.f64()?;
-                }
-                // A transform with NaN/inf is unusable: fall back to the identity.
-                if t.iter().any(|v| !v.is_finite()) {
-                    t = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
-                }
-                let _text_ver = r.u16()?;
-                let _desc_ver = r.u32()?;
-                let d = descriptor::read_descriptor(&mut r)?;
-                let text = d.text("Txt ").unwrap_or_default().replace("\r\n", "\n").replace('\r', "\n");
-                let text = text.strip_suffix('\n').map(str::to_string).unwrap_or(text);
-                let style = d.raw("EngineData").map(|e| engine_data::text_style(&engine_data::parse(e))).unwrap_or_default();
-                let bounds =
-                    d.obj("bounds").or_else(|| d.obj("boundingBox")).and_then(|o| Some([o.num("Left")?, o.num("Top ")?, o.num("Rght")?, o.num("Btom")?]));
-                l.text = Some(TextInfo { text, transform: t, style, bounds });
-            }
-            b"lfx2" => {
-                let _ver = r.u32()?;
-                let _dver = r.u32()?;
-                l.effects = Some(descriptor::read_descriptor(&mut r)?);
-            }
-            b"SoCo" => {
-                let _ver = r.u32()?;
-                let d = descriptor::read_descriptor(&mut r)?;
-                l.fill = d.color("Clr ");
-            }
-            b"nvrt" => l.adjustment = Some(Adjustment::Invert),
-            b"brit" => {
-                let brightness = r.i16()? as f64;
-                let contrast = r.i16()? as f64;
-                if l.adjustment.is_none() {
-                    l.adjustment = Some(Adjustment::BrightnessContrast { brightness, contrast, legacy: true });
-                }
-            }
-            b"CgEd" => {
-                let _ver = r.u32()?;
-                let d = descriptor::read_descriptor(&mut r)?;
-                l.adjustment = Some(Adjustment::BrightnessContrast {
-                    brightness: d.num("Brgh").unwrap_or(0.0),
-                    contrast: d.num("Cntr").unwrap_or(0.0),
-                    legacy: d.bool("useLegacy").unwrap_or(false),
-                });
-            }
-            b"hue2" | b"hue " => {
-                let _ver = r.u16()?;
-                let colorize = r.u8()? != 0;
-                r.skip(1)?;
-                let ch = (r.i16()? as f64, r.i16()? as f64, r.i16()? as f64);
-                let m = (r.i16()? as f64, r.i16()? as f64, r.i16()? as f64);
-                let (hue, saturation, lightness) = if colorize { ch } else { m };
-                l.adjustment = Some(Adjustment::HueSaturation { hue, saturation, lightness, colorize });
-            }
-            b"levl" => {
-                let _ver = r.u16()?;
-                let (ib, iw, ob, ow, g) = (r.i16()?, r.i16()?, r.i16()?, r.i16()?, r.i16()?);
-                l.adjustment =
-                    Some(Adjustment::Levels { in_black: ib as f64, in_white: iw as f64, gamma: g as f64 / 100.0, out_black: ob as f64, out_white: ow as f64 });
-            }
-            b"expA" => {
-                let _ver = r.u16()?;
-                let mut finite = |default: f64| -> Result<f64> {
-                    let v = f64::from(r.f32()?);
-                    Ok(if v.is_finite() { v } else { default })
-                };
-                let exposure = finite(0.0)?;
-                let offset = finite(0.0)?;
-                let gamma = finite(1.0)?;
-                l.adjustment = Some(Adjustment::Exposure { exposure, offset, gamma });
-            }
-            b"curv" | b"blnc" | b"post" | b"thrs" | b"selc" | b"mixr" | b"phfl" | b"vibA" | b"blwh" | b"grdm" | b"clrL" if l.adjustment.is_none() => {
-                l.adjustment = Some(Adjustment::Other(String::from_utf8_lossy(key).into_owned()));
-            }
-            b"SoLd" | b"SoLE" => {
-                let _id = r.tag()?;
-                let _ver = r.u32()?;
-                let _dver = r.u32()?;
-                let d = descriptor::read_descriptor(&mut r)?;
-                let uuid = d.text("Idnt").unwrap_or_default().to_string();
-                let t = placed::eight(&d, "Trnf").unwrap_or([0.0; 8]);
-                // The non-affine transform when present (perspective), else the transform.
-                let t = placed::eight(&d, "nonAffineTransform").unwrap_or(t);
-                let size = d.obj("Sz  ").and_then(|s| Some([s.num("Wdth")?, s.num("Hght")?]));
-                let warp = d.obj("warp").and_then(placed::Warp::read);
-                l.smart_object = Some(SmartObject { uuid, quad: placed::quad_from(t), size, warp });
-            }
-            b"PlLd" if l.smart_object.is_none() => {
-                let _id = r.tag()?;
-                let _ver = r.u32()?;
-                let n = r.u8()? as usize;
-                let uuid = String::from_utf8_lossy(r.bytes(n)?).into_owned();
-                let _page = r.u32()?;
-                let _pages = r.u32()?;
-                let _aa = r.u32()?;
-                let _ty = r.u32()?;
-                let mut t = [0.0; 8];
-                for v in &mut t {
-                    *v = r.f64_finite()?;
-                }
-                l.smart_object = Some(SmartObject { uuid, quad: placed::quad_from(t), size: None, warp: None });
-            }
-            b"vmsk" | b"vsms" => {
-                let _ver = r.u32()?;
-                let flags = r.u32()?;
-                l.vector_mask = Some(self.vector_paths(&mut r, flags)?);
-            }
-            _ => {}
-        }
-        Ok(())
-    }
-
-    fn vector_paths(&self, r: &mut Reader, flags: u32) -> Result<VectorMask> {
-        let (w, h) = (self.width as f64, self.height as f64);
-        let mut vm = VectorMask { inverted: flags & 1 != 0, disabled: flags & 4 != 0, subpaths: vec![] };
-        let fixed = |r: &mut Reader| -> Result<f64> { Ok(r.i32()? as f64 / (1 << 24) as f64) };
-        while r.remaining() >= 26 {
-            let sel = r.u16()?;
-            match sel {
-                0 | 3 => {
-                    let _n = r.u16()?;
-                    r.skip(22)?;
-                    vm.subpaths.push(SubPath { closed: sel == 0, knots: vec![] });
-                }
-                1 | 2 | 4 | 5 => {
-                    let mut pts = [[0.0; 2]; 3];
-                    for p in &mut pts {
-                        let y = fixed(r)?;
-                        let x = fixed(r)?;
-                        *p = [x * w, y * h];
-                    }
-                    if let Some(sp) = vm.subpaths.last_mut() {
-                        sp.knots.push(pts);
-                    }
-                }
-                _ => r.skip(24)?,
-            }
-        }
-        vm.subpaths.retain(|s| !s.knots.is_empty());
-        Ok(vm)
-    }
-
-    /// The layer tree, top of the stack first. Groups nest at most [`MAX_GROUP_DEPTH`] deep (see
-    /// [`Psd::tree_report`]).
-    pub fn tree(&self) -> Vec<Node> {
-        self.tree_report().0
-    }
-
-    /// The layer tree plus the number of groups nested deeper than [`MAX_GROUP_DEPTH`]. Those
-    /// are flattened into their deepest allowed ancestor: their children stay, in order, and
-    /// the group record itself becomes a plain [`Node::Layer`], so no layer is lost and the
-    /// tree (and its `Drop`, `Clone` and `PartialEq`) cannot recurse deeper than the limit.
-    pub fn tree_report(&self) -> (Vec<Node>, usize) {
-        let mut stack: Vec<Vec<Node>> = vec![vec![]];
-        // Dividers seen while `MAX_GROUP_DEPTH` groups were already open.
-        let mut flattened_open = 0usize;
-        let mut flattened = 0usize;
-        for l in &self.layers {
-            match l.section {
-                Section::Divider => {
-                    if stack.len() > MAX_GROUP_DEPTH {
-                        flattened_open += 1;
-                    } else {
-                        stack.push(vec![]);
-                    }
-                }
-                Section::OpenFolder | Section::ClosedFolder => {
-                    if flattened_open > 0 {
-                        flattened_open -= 1;
-                        flattened += 1;
-                        if let Some(top) = stack.last_mut() {
-                            top.push(Node::Layer(l.index));
-                        }
-                        continue;
-                    }
-                    let children = if stack.len() > 1 { stack.pop().unwrap_or_default() } else { vec![] };
-                    if let Some(top) = stack.last_mut() {
-                        top.push(Node::Group { layer: l.index, children });
-                    }
-                }
-                Section::Layer => {
-                    if let Some(top) = stack.last_mut() {
-                        top.push(Node::Layer(l.index));
-                    }
-                }
-            }
-        }
-        while stack.len() > 1 {
-            let c = stack.pop().unwrap_or_default();
-            if let Some(top) = stack.last_mut() {
-                top.extend(c);
-            }
-        }
-        // Depth is at most `MAX_GROUP_DEPTH`, so recursion is bounded.
-        fn rev(v: &mut Vec<Node>) {
-            v.reverse();
-            for n in v {
-                if let Node::Group { children, .. } = n {
-                    rev(children);
-                }
-            }
-        }
-        let mut out = stack.pop().unwrap_or_default();
-        rev(&mut out);
-        (out, flattened)
-    }
-
-    fn bytes_per_sample(&self) -> usize {
-        match self.depth {
-            16 => 2,
-            32 => 4,
-            _ => 1,
-        }
-    }
-
-    /// The raw big-endian bytes of one channel of `w`×`h` samples at `offset` (compression field
-    /// first): `row_bytes(w) × h` of them with the compression and the prediction undone.
-    /// Uncompressed data is borrowed from the file, not copied; any other buffer is charged to
-    /// `budget` and the caller releases it (see [`release_bytes`]) once it is dropped.
-    fn channel_bytes(&self, offset: usize, len: usize, w: usize, h: usize, budget: &mut Budget) -> Result<Cow<'_, [u8]>> {
-        let end = offset.checked_add(len).filter(|&e| e <= self.data.len()).ok_or(Error::Truncated)?;
-        let mut r = Reader::at(self.data.get(..end).ok_or(Error::Truncated)?, offset);
-        let comp = r.u16()?;
-        decode_pixels(w, h)?;
-        self.plane_bytes(comp, &mut r, w, h, budget)
-    }
-
-    /// The raw bytes (`row_bytes(w)` × `h`, ZIP prediction undone) of one channel whose pixel data
-    /// follows `r`'s position (after the compression field). Uncompressed data is borrowed, not
-    /// copied; the other buffers are charged to `budget`.
-    fn plane_bytes<'a>(&self, comp: u16, r: &mut Reader<'a>, w: usize, h: usize, budget: &mut Budget) -> Result<Cow<'a, [u8]>> {
-        let rowb = self.row_bytes(w);
-        let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;
-        Ok(match self.open_planes(comp, r, 1, 1, w, h, budget)? {
-            PlaneStream::Raw => Cow::Borrowed(r.bytes(size)?),
-            PlaneStream::Rle(counts) => Cow::Owned(Self::unpack_plane(&counts, 0, r, rowb, h, budget)?),
-            PlaneStream::Zip(mut v) => {
-                v.resize(size, 0);
-                self.zip_plane(comp, &mut v, 0, w, h)?;
-                Cow::Owned(v)
-            }
-        })
-    }
-
-    /// Prepare the pixel data at `r` (just after the compression field) of `total` planes of
-    /// `w`×`h` samples, of which the first `want` are decoded: the RLE row sizes of every plane,
-    /// or the inflated ZIP data, which holds all planes one after another (charged to `budget`
-    /// before it is inflated).
-    #[allow(clippy::too_many_arguments)]
-    fn open_planes(&self, comp: u16, r: &mut Reader, total: usize, want: usize, w: usize, h: usize, budget: &mut Budget) -> Result<PlaneStream> {
-        let size = self.row_bytes(w).checked_mul(h).ok_or_else(|| too_large(w, h))?;
-        Ok(match comp {
-            0 => PlaneStream::Raw,
-            1 => {
-                let n = total.saturating_mul(h);
-                let mut counts = Vec::with_capacity(n.min(r.remaining() / 2));
-                for _ in 0..n {
-                    counts.push(if self.psb { r.u32()? as usize } else { r.u16()? as usize });
-                }
-                PlaneStream::Rle(counts)
-            }
-            2 | 3 => {
-                let rest = r.bytes(r.remaining())?;
-                // One stream holds every plane: what it may decode to is what they need.
-                let all = size.checked_mul(want).ok_or_else(|| too_large(w, h))?;
-                budget.charge(all as u64)?;
-                PlaneStream::Zip(inflate(rest, all)?)
-            }
-            c => return Err(Error::Unsupported(format!("compression {c}"))),
-        })
-    }
-
-    /// The raw bytes (`row_bytes(w)` × `h`, ZIP prediction undone) of plane `c`: raw and RLE
-    /// planes are read from `r` in order, raw ones borrowed from the file data, ZIP ones from the
-    /// inflated buffer (un-predicted in place; already charged by `open_planes`), RLE ones charged
-    /// to `budget`.
-    #[allow(clippy::too_many_arguments)]
-    fn decode_plane<'x, 'a: 'x>(
-        &self,
-        comp: u16,
-        planes: &'x mut PlaneStream,
-        r: &mut Reader<'a>,
-        c: usize,
-        w: usize,
-        h: usize,
-        budget: &mut Budget,
-    ) -> Result<Cow<'x, [u8]>> {
-        let rowb = self.row_bytes(w);
-        let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;
-        Ok(match planes {
-            PlaneStream::Raw => Cow::Borrowed(r.bytes(size)?),
-            PlaneStream::Rle(counts) => Cow::Owned(Self::unpack_plane(counts, c, r, rowb, h, budget)?),
-            PlaneStream::Zip(v) => Cow::Borrowed(self.zip_plane(comp, v, c, w, h)?),
-        })
-    }
-
-    /// Unpack the `h` RLE rows of plane `c` (row byte counts `counts`, plane after plane) into a
-    /// buffer charged to `budget`.
-    fn unpack_plane(counts: &[usize], c: usize, r: &mut Reader, rowb: usize, h: usize, budget: &mut Budget) -> Result<Vec<u8>> {
-        let mut out = budget.vec::<u8>(rowb.checked_mul(h).ok_or(Error::Truncated)?)?;
-        for row in 0..h {
-            let n = *counts.get(c * h + row).ok_or(Error::Truncated)?;
-            unpack_bits(r.bytes(n)?, rowb, &mut out)?;
-        }
-        Ok(out)
-    }
-
-    /// Plane `c` of the inflated ZIP data of consecutive planes, un-predicted in place (`comp` 3).
-    fn zip_plane<'v>(&self, comp: u16, v: &'v mut [u8], c: usize, w: usize, h: usize) -> Result<&'v [u8]> {
-        let rowb = self.row_bytes(w);
-        let plane = v.get_mut(c * rowb * h..(c + 1) * rowb * h).ok_or(Error::Truncated)?;
-        if comp == 3 {
-            self.unpredict(plane, w, h);
-        }
-        Ok(plane)
-    }
-
-    /// One channel as `w * h` floats (0..1), charged to `budget` (the caller releases it).
-    fn channel_floats(&self, offset: usize, len: usize, w: usize, h: usize, budget: &mut Budget) -> Result<Vec<f32>> {
-        let raw = self.channel_bytes(offset, len, w, h, budget)?;
-        let mut out = budget.filled(decode_pixels(w, h)?, 0.0f32)?;
-        self.for_each_sample(&raw, w, h, |i, v| {
-            if let Some(o) = out.get_mut(i) {
-                *o = v;
-            }
-        });
-        release_bytes(budget, raw);
-        Ok(out)
-    }
-
-    fn row_bytes(&self, w: usize) -> usize {
-        if self.depth == 1 { w.div_ceil(8) } else { w * self.bytes_per_sample() }
-    }
-
-    fn unpredict(&self, v: &mut [u8], w: usize, h: usize) {
-        match self.depth {
-            16 => {
-                for row in v.chunks_exact_mut(w * 2).take(h) {
-                    let mut prev = 0u16;
-                    for c in row.as_chunks_mut::<2>().0 {
-                        let x = u16::from_be_bytes([c[0], c[1]]).wrapping_add(prev);
-                        c.copy_from_slice(&x.to_be_bytes());
-                        prev = x;
-                    }
-                }
-            }
-            32 => {
-                // One scratch row for the whole plane.
-                let mut planar = vec![0u8; w * 4];
-                #[cfg(test)]
-                counters::bump(&counters::SCRATCH);
-                for row in v.chunks_exact_mut(w * 4).take(h) {
-                    for i in 1..row.len() {
-                        row[i] = row[i].wrapping_add(row[i - 1]);
-                    }
-                    // Bytes are stored plane by plane (all first bytes, then all second bytes…).
-                    planar.copy_from_slice(row);
-                    for x in 0..w {
-                        for b in 0..4 {
-                            row[x * 4 + b] = planar[b * w + x];
-                        }
-                    }
-                }
-            }
-            _ => {
-                for row in v.chunks_exact_mut(w).take(h) {
-                    for i in 1..row.len() {
-                        row[i] = row[i].wrapping_add(row[i - 1]);
-                    }
-                }
-            }
-        }
-    }
-
-    /// Hand every sample of `raw` (`w`×`h`, row-major, in order) to `f` as a float. Samples a short
-    /// `raw` does not have are not reported.
-    fn for_each_sample(&self, raw: &[u8], w: usize, h: usize, mut f: impl FnMut(usize, f32)) {
-        let n = w.saturating_mul(h);
-        match self.depth {
-            1 => {
-                let rowb = w.div_ceil(8);
-                for y in 0..h {
-                    for x in 0..w {
-                        let b = raw.get(y * rowb + x / 8).copied().unwrap_or(0);
-                        // 1 = black.
-                        f(y * w + x, if b & (0x80 >> (x % 8)) != 0 { 0.0 } else { 1.0 });
-                    }
-                }
-            }
-            16 => raw.as_chunks::<2>().0.iter().take(n).enumerate().for_each(|(i, c)| f(i, u16::from_be_bytes([c[0], c[1]]) as f32 / 65535.0)),
-            // NaN reads as 0, +inf as white (1.0, like the integer depths' maximum), -inf as 0.
-            32 => raw.as_chunks::<4>().0.iter().take(n).enumerate().for_each(|(i, c)| f(i, finite_sample(f32::from_be_bytes([c[0], c[1], c[2], c[3]])))),
-            _ => raw.iter().take(n).enumerate().for_each(|(i, &b)| f(i, b as f32 / 255.0)),
-        }
-    }
-
-    /// Convert colour values (the document mode's channels, missing ones 0) to RGB.
-    fn rgb_from(&self, v: [f32; 4]) -> [f32; 3] {
-        let g = |k: usize| v.get(k).copied().unwrap_or(0.0);
-        let rgb = match self.mode {
-            ColorMode::Rgb => [g(0), g(1), g(2)],
-            ColorMode::Cmyk => {
-                // Stored inverted (1 = no ink).
-                let k = g(3);
-                [g(0) * k, g(1) * k, g(2) * k]
-            }
-            ColorMode::Indexed if self.palette.len() >= 768 => {
-                let idx = (g(0) * 255.0).round() as usize & 255;
-                [self.palette[idx] as f32 / 255.0, self.palette[256 + idx] as f32 / 255.0, self.palette[512 + idx] as f32 / 255.0]
-            }
-            ColorMode::Lab => lab_to_rgb(g(0) * 100.0, g(1) * 255.0 - 128.0, g(2) * 255.0 - 128.0),
-            _ => [g(0); 3],
-        };
-        if self.depth == 32 && self.mode != ColorMode::Lab { rgb.map(srgb_encode) } else { rgb }
-    }
-
-    /// Write merged-image channel `c` (raw bytes) into the result: the first three colour channels
-    /// and the alpha channel into their slot of a pixel, the fourth CMYK channel into `black`.
-    fn store_merged_channel(&self, c: usize, raw: &[u8], data: &mut [[f32; 4]], black: &mut Option<Vec<f32>>) {
-        let (w, h, cc) = (self.width as usize, self.height as usize, self.mode.color_channels());
-        if c < cc.min(3) {
-            self.for_each_sample(raw, w, h, |i, v| {
-                if let Some(p) = data.get_mut(i) {
-                    p[c] = v;
-                }
-            });
-        } else if c == 3 && c < cc {
-            if let Some(k) = black {
-                self.for_each_sample(raw, w, h, |i, v| {
-                    if let Some(o) = k.get_mut(i) {
-                        *o = v;
-                    }
-                });
-            }
-        } else if c == cc && self.merged_alpha {
-            self.for_each_sample(raw, w, h, |i, v| {
-                if let Some(p) = data.get_mut(i) {
-                    p[3] = v;
-                }
-            });
-        }
-    }
-
-    /// The merged (flattened) image.
-    pub fn composite(&self) -> Result<Pixels> {
-        self.composite_with_budget(DECODE_BUDGET)
-    }
-
-    /// [`Self::composite`] with at most `limit` bytes live at once. The channels are written
-    /// straight into the result, so the peak is the result (16 bytes a pixel), the CMYK black
-    /// channel, and the one buffer a channel (or, for ZIP, all channels) decodes through.
-    pub(crate) fn composite_with_budget(&self, limit: u64) -> Result<Pixels> {
-        let mut budget = Budget::new(limit);
-        let (w, h) = (self.width as usize, self.height as usize);
-        let n = decode_pixels(w, h)?;
-        let mut r = Reader::at(&self.data, self.merged_offset);
-        let comp = r.u16()?;
-        let nch = self.channels as usize;
-        let cc = self.mode.color_channels();
-        let want = (cc + usize::from(self.merged_alpha)).min(nch);
-        let rowb = self.row_bytes(w);
-        let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;
-        // The peak: the result, the CMYK black channel and what the channels decode through.
-        let black_bytes = if self.mode == ColorMode::Cmyk && want > 3 { 4 * n as u64 } else { 0 };
-        let transient = if matches!(comp, 2 | 3) { (size as u64).saturating_mul(want as u64) } else { size as u64 };
-        budget.check((16 * n as u64).saturating_add(black_bytes).saturating_add(transient))?;
-        // Opaque black until a channel says otherwise.
-        let mut data = budget.filled(n, [0.0f32, 0.0, 0.0, 1.0])?;
-        let mut black = if self.mode == ColorMode::Cmyk && want > 3 { Some(budget.filled(n, 0.0f32)?) } else { None };
-        let mut stream = self.open_planes(comp, &mut r, nch, want, w, h, &mut budget)?;
-        for c in 0..want {
-            let raw = self.decode_plane(comp, &mut stream, &mut r, c, w, h, &mut budget)?;
-            self.store_merged_channel(c, &raw, &mut data, &mut black);
-            release_bytes(&mut budget, raw);
-        }
-        for (i, p) in data.iter_mut().enumerate() {
-            let k = black.as_ref().and_then(|k| k.get(i)).copied().unwrap_or(0.0);
-            let [r, g, b] = self.rgb_from([p[0], p[1], p[2], k]);
-            *p = [r, g, b, p[3]];
-        }
-        Ok(Pixels { width: w as u32, height: h as u32, data })
-    }
-
-    /// One layer's pixels with its layer mask (and vector-less fill colour) applied to alpha.
-    /// `canvas`: document-sized with the layer in place; otherwise the layer's own bounds.
-    pub fn layer_pixels(&self, index: usize, canvas: bool) -> Result<Pixels> {
-        self.layer_pixels_with_budget(index, canvas, DECODE_BUDGET)
-    }
-
-    /// [`Self::layer_pixels`] with at most `limit` bytes live at once: the result (16 bytes a
-    /// pixel) with the channels written straight into it, the CMYK black channel, the one channel
-    /// being decoded, and the mask.
-    pub(crate) fn layer_pixels_with_budget(&self, index: usize, canvas: bool, limit: u64) -> Result<Pixels> {
-        let mut budget = Budget::new(limit);
-        let l = self.layers.get(index).ok_or_else(|| Error::Invalid(format!("no layer {index}")))?;
-        let doc = Rect { top: 0, left: 0, bottom: self.height as i32, right: self.width as i32 };
-        // Fill layers often have no pixel data: they cover the canvas (or the mask).
-        let fill_rect =
-            if l.fill.is_some() && !l.has_pixels() { l.mask.filter(|m| !m.rect.is_empty() && m.default_color == 0).map_or(doc, |m| m.rect) } else { l.rect };
-        let out_rect = if canvas {
-            doc
-        } else if fill_rect.is_empty() {
-            Rect { top: 0, left: 0, bottom: 1, right: 1 }
-        } else {
-            fill_rect
-        };
-        let (ow, oh) = (out_rect.width() as usize, out_rect.height() as usize);
-        let n = decode_pixels(ow, oh)?;
-        let src = fill_rect;
-        let (sw, sh) = (src.width() as usize, src.height() as usize);
-        // The peak: the result, then either the CMYK black channel with the channel being decoded,
-        // or the mask as floats with its bytes. Checked before anything is allocated.
-        let plane = |w: usize, h: usize| (self.row_bytes(w) as u64).saturating_mul(h as u64);
-        let mut pixels_peak = 0u64;
-        if l.has_pixels() && sw > 0 && sh > 0 {
-            pixels_peak = plane(sw, sh).saturating_add(if self.mode == ColorMode::Cmyk { 4 * n as u64 } else { 0 });
-        }
-        let mut mask_peak = 0u64;
-        if let Some(m) = l.mask.filter(|m| !m.disabled) {
-            let (mw, mh) = (m.rect.width() as usize, m.rect.height() as usize);
-            if mw > 0 && mh > 0 && l.channels.iter().any(|c| c.id == -2) {
-                mask_peak = plane(mw, mh).saturating_add((mw as u64).saturating_mul(mh as u64).saturating_mul(4));
-            }
-        }
-        budget.check((16 * n as u64).saturating_add(pixels_peak.max(mask_peak)))?;
-        let mut out = budget.filled(n, [0.0f32; 4])?;
-        if sw > 0 && sh > 0 {
-            // The source rows / columns that land inside the output (64-bit: file bounds can span
-            // the whole i32 range).
-            let span = |s0: i32, n: usize, o0: i32, on: usize| {
-                let off = i64::from(o0) - i64::from(s0);
-                let lo = off.clamp(0, n as i64);
-                let hi = (off + on as i64).clamp(lo, n as i64);
-                (lo as usize..hi as usize, off)
-            };
-            let (ys, oy) = span(src.top, sh, out_rect.top, oh);
-            let (xs, ox) = span(src.left, sw, out_rect.left, ow);
-            let dest = |y: usize, x: usize| (y as i64 - oy) as usize * ow + (x as i64 - ox) as usize;
-            let fill = l.fill.map(|c| c.map(|v| v as f32));
-            match fill {
-                Some(f) if !l.has_pixels() => {
-                    for y in ys {
-                        for x in xs.clone() {
-                            if let Some(p) = out.get_mut(dest(y, x)) {
-                                *p = [f[0], f[1], f[2], 1.0];
-                            }
-                        }
-                    }
-                }
-                _ => {
-                    // Opaque unless there is an alpha channel.
-                    for y in ys.clone() {
-                        for x in xs.clone() {
-                            if let Some(p) = out.get_mut(dest(y, x)) {
-                                p[3] = 1.0;
-                            }
-                        }
-                    }
-                    let cc = self.mode.color_channels();
-                    let mut black: Option<Vec<f32>> = None;
-                    if l.has_pixels() {
-                        for c in &l.channels {
-                            let slot = match c.id {
-                                -1 => 3,
-                                id if id >= 0 && (id as usize) < cc => id as usize,
-                                _ => continue,
-                            };
-                            let raw = self.channel_bytes(c.offset, c.len, sw, sh, &mut budget)?;
-                            // The fourth CMYK channel is the black plate, not a slot of the result.
-                            let to_black = c.id == 3;
-                            if to_black && black.is_none() {
-                                black = Some(budget.filled(out.len(), 0.0f32)?);
-                            }
-                            // Samples arrive in row-major order of the source.
-                            let (mut sy, mut sx) = (0usize, 0usize);
-                            self.for_each_sample(&raw, sw, sh, |_, v| {
-                                if ys.contains(&sy) && xs.contains(&sx) {
-                                    let d = dest(sy, sx);
-                                    if to_black {
-                                        if let Some(o) = black.as_mut().and_then(|k| k.get_mut(d)) {
-                                            *o = v;
-                                        }
-                                    } else if let Some(p) = out.get_mut(d) {
-                                        p[slot] = v;
-                                    }
-                                }
-                                sx += 1;
-                                if sx == sw {
-                                    sx = 0;
-                                    sy += 1;
-                                }
-                            });
-                            release_bytes(&mut budget, raw);
-                        }
-                    }
-                    for y in ys {
-                        for x in xs.clone() {
-                            let d = dest(y, x);
-                            let k = black.as_ref().and_then(|k| k.get(d)).copied().unwrap_or(0.0);
-                            if let Some(p) = out.get_mut(d) {
-                                let [r, g, b] = self.rgb_from([p[0], p[1], p[2], k]);
-                                *p = [r, g, b, p[3]];
-                            }
-                        }
-                    }
-                    if let Some(k) = black {
-                        budget.release(k.len() as u64 * 4);
-                    }
-                }
-            }
-        }
-        // Layer mask: multiplies alpha (also outside the mask rect, by its default colour).
-        if let Some(m) = l.mask.filter(|m| !m.disabled) {
-            let mc = l.channels.iter().find(|c| c.id == -2);
-            let (mw, mh) = (m.rect.width() as usize, m.rect.height() as usize);
-            let mask = match mc {
-                Some(c) if mw > 0 && mh > 0 => Some(self.channel_floats(c.offset, c.len, mw, mh, &mut budget)?),
-                _ => None,
-            };
-            let def = m.default_color as f32 / 255.0;
-            // The factor outside the mask rect, or everywhere when there is no mask data.
-            let outside = if m.inverted { 1.0 - def } else { def };
-            let scale = |px: &mut [[f32; 4]], v: f32| {
-                if v != 1.0 {
-                    for p in px {
-                        p[3] *= v;
-                    }
-                }
-            };
-            match &mask {
-                None => scale(&mut out, outside),
-                Some(mk) => {
-                    // The columns of the output that fall inside the mask rect (the same for every row).
-                    let lo = (i64::from(m.rect.left) - i64::from(out_rect.left)).clamp(0, ow as i64);
-                    let hi = (i64::from(m.rect.right) - i64::from(out_rect.left)).clamp(lo, ow as i64);
-                    let (lo, hi) = (lo as usize, hi as usize);
-                    for (y, row) in out.chunks_exact_mut(ow.max(1)).take(oh).enumerate() {
-                        let py = i64::from(out_rect.top) + y as i64;
-                        #[cfg(test)]
-                        counters::bump(&counters::INSIDE);
-                        if py < i64::from(m.rect.top) || py >= i64::from(m.rect.bottom) {
-                            scale(row, outside);
-                            continue;
-                        }
-                        let (left, rest) = row.split_at_mut(lo);
-                        let (mid, right) = rest.split_at_mut(hi - lo);
-                        scale(left, outside);
-                        scale(right, outside);
-                        // The mask row under `mid`: its first column is output column `lo`.
-                        let base = (py - i64::from(m.rect.top)) as usize * mw + (i64::from(out_rect.left) + lo as i64 - i64::from(m.rect.left)) as usize;
-                        for (i, p) in mid.iter_mut().enumerate() {
-                            let v = mk.get(base + i).copied().unwrap_or(def);
-                            p[3] *= if m.inverted { 1.0 - v } else { v };
-                        }
-                    }
-                }
-            }
-        }
-        Ok(Pixels { width: ow as u32, height: oh as u32, data: out })
-    }
-}
-
-/// The pixel data of a run of planes, as prepared by `Psd::open_planes`.
-enum PlaneStream {
-    Raw,
-    /// RLE row byte counts of every plane, plane after plane.
-    Rle(Vec<usize>),
-    /// The inflated ZIP data of all planes.
-    Zip(Vec<u8>),
-}
-
-/// The next additional-information block at `*pos` (signature `8BIM`/`8B64`, key, length):
-/// returns (key, data start, data end). Skips up to 3 padding bytes before a signature.
-fn next_block(data: &[u8], pos: &mut usize, end: usize, psb: bool) -> Option<([u8; 4], usize, usize)> {
-    let mut p = *pos;
-    for _ in 0..4 {
-        if p + 12 > end {
-            return None;
-        }
-        if &data[p..p + 4] == b"8BIM" || &data[p..p + 4] == b"8B64" {
-            break;
-        }
-        p += 1;
-    }
-    if p + 12 > end || !(&data[p..p + 4] == b"8BIM" || &data[p..p + 4] == b"8B64") {
-        return None;
-    }
-    let mut key = [0u8; 4];
-    key.copy_from_slice(&data[p + 4..p + 8]);
-    let wide =
-        psb && matches!(&key, b"LMsk" | b"Lr16" | b"Lr32" | b"Layr" | b"Mt16" | b"Mt32" | b"Mtrn" | b"Alph" | b"FMsk" | b"lnk2" | b"FEid" | b"FXid" | b"PxSD");
-    let mut r = Reader::at(&data[..end], p + 8);
-    let len = r.length(wide).ok()?;
-    let start = r.pos;
-    let stop = start.checked_add(len)?;
-    if stop > end {
-        return None;
-    }
-    *pos = stop;
-    Some((key, start, stop))
-}
-
-/// PackBits decoding of one row (appends exactly `row` bytes, zero-padded).
-fn unpack_bits(src: &[u8], row: usize, out: &mut Vec<u8>) -> Result<()> {
-    let start = out.len();
-    let mut i = 0;
-    while i < src.len() && out.len() - start < row {
-        let n = src[i] as i8;
-        i += 1;
-        if n >= 0 {
-            let k = n as usize + 1;
-            let s = src.get(i..i + k).ok_or(Error::Truncated)?;
-            out.extend_from_slice(s);
-            i += k;
-        } else if n != -128 {
-            let k = (1 - n as isize) as usize;
-            let v = *src.get(i).ok_or(Error::Truncated)?;
-            out.extend(std::iter::repeat_n(v, k));
-            i += 1;
-        }
-    }
-    out.resize(start + row, 0);
-    Ok(())
-}
-
-/// PackBits encoding of one row.
-pub(crate) fn pack_bits(src: &[u8]) -> Vec<u8> {
-    let mut out = vec![];
-    let mut i = 0;
-    while i < src.len() {
-        // run of identical bytes
-        let mut run = 1;
-        while i + run < src.len() && src[i + run] == src[i] && run < 128 {
-            run += 1;
-        }
-        if run >= 2 {
-            out.push((1 - run as isize) as i8 as u8);
-            out.push(src[i]);
-            i += run;
-            continue;
-        }
-        // literal run
-        let start = i;
-        let mut n = 0;
-        while i < src.len() && n < 128 {
-            if i + 1 < src.len() && src[i + 1] == src[i] {
-                break;
-            }
-            i += 1;
-            n += 1;
-        }
-        if n == 0 {
-            i += 1;
-            n = 1;
-        }
-        out.push((n - 1) as u8);
-        out.extend_from_slice(&src[start..start + n]);
-    }
-    out
-}
-
-fn srgb_encode(v: f32) -> f32 {
-    if v <= 0.003_130_8 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 }
-}
-
-/// CIE L*a*b* (D50) to sRGB (D65 via the Bradford-adapted matrix), clamped.
-fn lab_to_rgb(l: f32, a: f32, b: f32) -> [f32; 3] {
-    let fy = (l + 16.0) / 116.0;
-    let fx = fy + a / 500.0;
-    let fz = fy - b / 200.0;
-    let f = |t: f32| if t > 6.0 / 29.0 { t * t * t } else { 3.0 * (6.0f32 / 29.0).powi(2) * (t - 4.0 / 29.0) };
-    let (x, y, z) = (0.964_22 * f(fx), f(fy), 0.825_21 * f(fz));
-    // XYZ (D50) → linear sRGB.
-    let r = 3.133_856 * x - 1.616_867 * y - 0.490_615 * z;
-    let g = -0.978_768 * x + 1.916_142 * y + 0.033_454 * z;
-    let bb = 0.071_945 * x - 0.228_991 * y + 1.405_243 * z;
-    [r, g, bb].map(|v| srgb_encode(v.clamp(0.0, 1.0)))
-}
-
 #[cfg(test)]
 mod memory_tests;
 #[cfg(test)]
 mod tests;
-#[cfg(test)]
-mod tests_integration;
-#[cfg(test)]
-mod tests_opt;
 
 /// Test-only call counters (per thread), to prove what the optimised paths avoid doing.
 #[cfg(test)]
-pub(crate) mod counters {
-    use std::cell::Cell;
-    use std::thread::LocalKey;
-
-    thread_local! {
-        /// Scratch rows allocated by the 32-bit ZIP un-predictor.
-        pub static SCRATCH: Cell<usize> = const { Cell::new(0) };
-        /// `inside the mask rect` evaluations of the layer-mask loop.
-        pub static INSIDE: Cell<usize> = const { Cell::new(0) };
-        /// `square_to_quad` solves.
-        pub static QUAD: Cell<usize> = const { Cell::new(0) };
-    }
-
-    pub fn bump(c: &'static LocalKey<Cell<usize>>) {
-        c.with(|c| c.set(c.get() + 1));
-    }
-    /// Read and reset.
-    pub fn take(c: &'static LocalKey<Cell<usize>>) -> usize {
-        c.with(|c| c.replace(0))
-    }
-}
+pub(crate) mod counters;
diff --git a/crates/psd/src/limits.rs b/crates/psd/src/limits.rs
new file mode 100644
index 000000000..c1c23b390
--- /dev/null
+++ b/crates/psd/src/limits.rs
@@ -0,0 +1,133 @@
+use std::borrow::Cow;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Error {
+    NotPsd,
+    Truncated,
+    Unsupported(String),
+    Invalid(String),
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::NotPsd => write!(f, "not a Photoshop document"),
+            Error::Truncated => write!(f, "truncated Photoshop document"),
+            Error::Unsupported(s) => write!(f, "unsupported Photoshop feature: {s}"),
+            Error::Invalid(s) => write!(f, "invalid Photoshop document: {s}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// The most pixels one decoded image (the composite, a layer or a mask) may have: 2^28, e.g.
+/// 16 384 × 16 384, 4 GiB as float RGBA. Bounds read from a file are untrusted, so a few bytes
+/// can't make the reader allocate more than that.
+const MAX_DECODE_PIXELS: u64 = 1 << 28;
+
+/// `w × h` as a pixel count, or an error when it exceeds [`MAX_DECODE_PIXELS`].
+pub(crate) fn decode_pixels(w: usize, h: usize) -> Result<usize> {
+    match (w as u64).checked_mul(h as u64) {
+        Some(n) if n <= MAX_DECODE_PIXELS => Ok(n as usize),
+        _ => Err(Error::Unsupported(format!("{w}×{h} pixels is too large to decode"))),
+    }
+}
+
+pub(crate) fn too_large(w: usize, h: usize) -> Error {
+    Error::Unsupported(format!("{w}×{h} pixels is too large to decode"))
+}
+
+/// What one decode (the composite, or one layer) may hold in memory at once: 4 GiB, 1 GiB where
+/// pointers are 32 bits wide (WebAssembly). [`MAX_DECODE_PIXELS`] bounds one image; this bounds
+/// the sum of the buffers a decode keeps alive together.
+#[cfg(target_pointer_width = "32")]
+pub(crate) const DECODE_BUDGET: u64 = 1 << 30;
+
+#[cfg(not(target_pointer_width = "32"))]
+pub(crate) const DECODE_BUDGET: u64 = 4 << 30;
+
+/// The bytes the buffers of one decode hold right now, against a limit. A decode charges a buffer
+/// before it allocates it (and releases it when it drops it), so a file that would need more
+/// than the limit fails with an error instead of an out-of-memory abort.
+pub(crate) struct Budget {
+    limit: u64,
+    live: u64,
+}
+
+impl Budget {
+    pub(crate) fn new(limit: u64) -> Budget {
+        Budget { limit, live: 0 }
+    }
+
+    pub(crate) fn charge(&mut self, bytes: u64) -> Result<()> {
+        self.check(bytes)?;
+        self.live += bytes;
+        Ok(())
+    }
+
+    /// Whether `bytes` more would still fit, without taking them. A decode checks its whole
+    /// expected peak first, so one that cannot fit fails before it has allocated anything.
+    pub(crate) fn check(&self, bytes: u64) -> Result<()> {
+        match self.live.checked_add(bytes) {
+            Some(total) if total <= self.limit => Ok(()),
+            _ => {
+                const MIB: u64 = 1 << 20;
+                Err(Error::Unsupported(format!(
+                    "decoding needs {} MiB more with {} MiB in use, over the {} MiB memory budget",
+                    bytes / MIB,
+                    self.live / MIB,
+                    self.limit / MIB
+                )))
+            }
+        }
+    }
+
+    pub(crate) fn release(&mut self, bytes: u64) {
+        self.live = self.live.saturating_sub(bytes);
+    }
+
+    /// An empty vector with room for `n` items, charged.
+    pub(crate) fn vec<T>(&mut self, n: usize) -> Result<Vec<T>> {
+        self.charge((n as u64).saturating_mul(std::mem::size_of::<T>() as u64))?;
+        let mut v = Vec::new();
+        v.try_reserve_exact(n).map_err(|_| Error::Unsupported(format!("out of memory for {n} items")))?;
+        Ok(v)
+    }
+
+    /// `n` copies of `value`, charged.
+    pub(crate) fn filled<T: Clone>(&mut self, n: usize, value: T) -> Result<Vec<T>> {
+        let mut v = self.vec::<T>(n)?;
+        v.resize(n, value);
+        Ok(v)
+    }
+}
+
+/// Inflate a zlib stream to at most `limit` bytes.
+pub(crate) fn inflate(src: &[u8], limit: usize) -> Result<Vec<u8>> {
+    miniz_oxide::inflate::decompress_to_vec_zlib_with_limit(src, limit).map_err(|e| Error::Invalid(format!("zip: {e:?}")))
+}
+
+/// Give back what a channel buffer from `Psd::channel_bytes` / `Psd::decode_plane` was charged:
+/// a borrowed one (uncompressed data, or a plane of an inflated stream charged as a whole) was not.
+pub(crate) fn release_bytes(budget: &mut Budget, raw: Cow<'_, [u8]>) {
+    if let Cow::Owned(v) = raw {
+        budget.release(v.len() as u64);
+    }
+}
+
+/// A 32-bit float sample made safe to use: NaN reads as 0, +inf as white (1.0, like the integer
+/// depths' maximum), -inf as 0.
+pub(crate) fn finite_sample(v: f32) -> f32 {
+    if v.is_nan() {
+        0.0
+    } else if v == f32::INFINITY {
+        1.0
+    } else if v == f32::NEG_INFINITY {
+        0.0
+    } else {
+        v
+    }
+}
diff --git a/crates/psd/src/model.rs b/crates/psd/src/model.rs
new file mode 100644
index 000000000..729b9a3c4
--- /dev/null
+++ b/crates/psd/src/model.rs
@@ -0,0 +1,265 @@
+use super::{Descriptor, engine_data, placed};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ColorMode {
+    Bitmap,
+    Grayscale,
+    Indexed,
+    Rgb,
+    Cmyk,
+    Multichannel,
+    Duotone,
+    Lab,
+}
+
+impl ColorMode {
+    pub fn from_u16(v: u16) -> Option<ColorMode> {
+        Some(match v {
+            0 => ColorMode::Bitmap,
+            1 => ColorMode::Grayscale,
+            2 => ColorMode::Indexed,
+            3 => ColorMode::Rgb,
+            4 => ColorMode::Cmyk,
+            7 => ColorMode::Multichannel,
+            8 => ColorMode::Duotone,
+            9 => ColorMode::Lab,
+            _ => return None,
+        })
+    }
+    pub fn to_u16(self) -> u16 {
+        match self {
+            ColorMode::Bitmap => 0,
+            ColorMode::Grayscale => 1,
+            ColorMode::Indexed => 2,
+            ColorMode::Rgb => 3,
+            ColorMode::Cmyk => 4,
+            ColorMode::Multichannel => 7,
+            ColorMode::Duotone => 8,
+            ColorMode::Lab => 9,
+        }
+    }
+    /// Number of colour channels (before alpha).
+    pub fn color_channels(self) -> usize {
+        match self {
+            ColorMode::Rgb | ColorMode::Lab => 3,
+            ColorMode::Cmyk => 4,
+            _ => 1,
+        }
+    }
+}
+
+/// A rectangle in document pixels (`right`/`bottom` exclusive).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct Rect {
+    pub top: i32,
+    pub left: i32,
+    pub bottom: i32,
+    pub right: i32,
+}
+
+impl Rect {
+    pub fn new(left: i32, top: i32, width: i32, height: i32) -> Rect {
+        Rect { top, left, bottom: top.saturating_add(height), right: left.saturating_add(width) }
+    }
+    pub fn width(&self) -> u32 {
+        (i64::from(self.right) - i64::from(self.left)).clamp(0, i64::from(u32::MAX)) as u32
+    }
+    pub fn height(&self) -> u32 {
+        (i64::from(self.bottom) - i64::from(self.top)).clamp(0, i64::from(u32::MAX)) as u32
+    }
+    pub fn is_empty(&self) -> bool {
+        self.width() == 0 || self.height() == 0
+    }
+}
+
+/// One channel of a layer: id (0.. colour, -1 transparency, -2 layer mask, -3 real user mask) and
+/// where its data (compression + image data) sits in the file.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ChannelInfo {
+    pub id: i16,
+    pub offset: usize,
+    pub len: usize,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct LayerMask {
+    pub rect: Rect,
+    /// Value outside the mask rectangle (0 or 255).
+    pub default_color: u8,
+    pub disabled: bool,
+    pub inverted: bool,
+}
+
+/// Layer kind from the section divider setting (`lsct`).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Section {
+    #[default]
+    Layer,
+    OpenFolder,
+    ClosedFolder,
+    /// The hidden "</Layer group>" record that closes a group (below its children).
+    Divider,
+}
+
+/// A type layer (`TySh`).
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct TextInfo {
+    /// Text with `\n` line breaks.
+    pub text: String,
+    /// Affine transform (xx, xy, yx, yy, tx, ty): the text origin sits at (tx, ty).
+    pub transform: [f64; 6],
+    pub style: engine_data::TextStyle,
+    /// Text bounds (left, top, right, bottom) relative to the origin, when stored.
+    pub bounds: Option<[f64; 4]>,
+}
+
+/// Adjustment layers (best effort).
+#[derive(Clone, Debug, PartialEq)]
+pub enum Adjustment {
+    Invert,
+    BrightnessContrast {
+        brightness: f64,
+        contrast: f64,
+        legacy: bool,
+    },
+    HueSaturation {
+        hue: f64,
+        saturation: f64,
+        lightness: f64,
+        colorize: bool,
+    },
+    Levels {
+        in_black: f64,
+        in_white: f64,
+        gamma: f64,
+        out_black: f64,
+        out_white: f64,
+    },
+    Exposure {
+        exposure: f64,
+        offset: f64,
+        gamma: f64,
+    },
+    /// Another adjustment (its tagged-block key, e.g. `curv`, `blnc`).
+    Other(String),
+}
+
+/// A vector mask path: sub-paths of (in tangent, vertex, out tangent) points in document pixels.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct VectorMask {
+    pub inverted: bool,
+    pub disabled: bool,
+    pub subpaths: Vec<SubPath>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct SubPath {
+    pub closed: bool,
+    /// Per knot: [control point preceding, anchor, control point leaving] as (x, y).
+    pub knots: Vec<[[f64; 2]; 3]>,
+}
+
+/// A placed layer (smart object): `SoLd` / `SoLE` (placed layer data) or the older `PlLd`.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct SmartObject {
+    /// Unique id of the linked file ([`Psd::linked`]) the layer shows.
+    pub uuid: String,
+    /// Where the content's corners sit in document pixels: top-left, top-right, bottom-right,
+    /// bottom-left.
+    pub quad: [[f64; 2]; 4],
+    /// The content's size in pixels (`Sz  `), when recorded.
+    pub size: Option<[f64; 2]>,
+    /// The placed layer's warp (`warp`), when it has one ([`placed`]).
+    pub warp: Option<placed::Warp>,
+}
+
+impl SmartObject {
+    /// The quad as an affine placement of a `w`×`h` content rectangle: (centre, scale x, scale
+    /// y, rotation in degrees). Perspective and skew are dropped.
+    pub fn placement(&self, w: f64, h: f64) -> ([f64; 2], f64, f64, f64) {
+        let q = self.quad;
+        let centre = [(q[0][0] + q[1][0] + q[2][0] + q[3][0]) / 4.0, (q[0][1] + q[1][1] + q[2][1] + q[3][1]) / 4.0];
+        let top = [q[1][0] - q[0][0], q[1][1] - q[0][1]];
+        let left = [q[3][0] - q[0][0], q[3][1] - q[0][1]];
+        let sx = top[0].hypot(top[1]) / w.max(1e-9);
+        let sy = left[0].hypot(left[1]) / h.max(1e-9);
+        // Mirrored content (left edge turning the other way) keeps a negative y scale.
+        let cross = top[0] * left[1] - top[1] * left[0];
+        (centre, sx, if cross < 0.0 { -sy } else { sy }, top[1].atan2(top[0]).to_degrees())
+    }
+}
+
+/// A file embedded in (or linked from) the document: linked layer data (`lnk2`, `lnkD`,
+/// `lnk3`, `lnkE`).
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct LinkedFile {
+    pub uuid: String,
+    pub name: String,
+    /// File type code (`8BPS`, `PNGf`, `JPEG`…), may be blank.
+    pub file_type: String,
+    /// Embedded data (absent for externally linked files).
+    pub data: Option<std::ops::Range<usize>>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Layer {
+    /// Index in [`Psd::layers`] (file order: bottom of the stack first).
+    pub index: usize,
+    pub name: String,
+    pub id: Option<u32>,
+    pub rect: Rect,
+    /// Blend mode key (`norm`, `mul `, `pass`…).
+    pub blend: [u8; 4],
+    pub opacity: u8,
+    /// Fill opacity (`iOpa`), 255 when absent.
+    pub fill_opacity: u8,
+    /// Clipped to the layer below.
+    pub clipping: bool,
+    pub hidden: bool,
+    pub protect_transparency: bool,
+    pub section: Section,
+    pub channels: Vec<ChannelInfo>,
+    pub mask: Option<LayerMask>,
+    pub text: Option<TextInfo>,
+    pub adjustment: Option<Adjustment>,
+    /// Solid colour fill layer (`SoCo`), RGB 0..1.
+    pub fill: Option<[f64; 3]>,
+    /// Layer effects (`lfx2` descriptor).
+    pub effects: Option<Descriptor>,
+    pub vector_mask: Option<VectorMask>,
+    /// Smart object placement.
+    pub smart_object: Option<SmartObject>,
+    /// Keys of every additional-information block the layer carries.
+    pub keys: Vec<[u8; 4]>,
+}
+
+impl Layer {
+    pub fn is_group(&self) -> bool {
+        matches!(self.section, Section::OpenFolder | Section::ClosedFolder)
+    }
+    pub fn blend_key(&self) -> &str {
+        std::str::from_utf8(&self.blend).unwrap_or("norm")
+    }
+    pub fn has_pixels(&self) -> bool {
+        !self.rect.is_empty() && self.channels.iter().any(|c| c.id >= 0)
+    }
+}
+
+/// How deep groups nest in [`Psd::tree`]; deeper ones are flattened (a hostile file can nest
+/// thousands, and walking or dropping that tree would overflow the stack).
+pub const MAX_GROUP_DEPTH: usize = 64;
+
+/// The layer tree, top of the stack first.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Node {
+    Layer(usize),
+    Group { layer: usize, children: Vec<Node> },
+}
+
+/// Decoded pixels: straight RGBA, row-major.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Pixels {
+    pub width: u32,
+    pub height: u32,
+    pub data: Vec<[f32; 4]>,
+}
diff --git a/crates/psd/src/parse.rs b/crates/psd/src/parse.rs
new file mode 100644
index 000000000..d221b9044
--- /dev/null
+++ b/crates/psd/src/parse.rs
@@ -0,0 +1,514 @@
+use super::limits::{Error, Result};
+use super::model::{
+    Adjustment, ChannelInfo, ColorMode, Layer, LayerMask, LinkedFile, MAX_GROUP_DEPTH, Node, Rect, Section, SmartObject, SubPath, TextInfo, VectorMask,
+};
+use super::{Psd, Reader, descriptor, engine_data, placed};
+use std::sync::Arc;
+
+/// Whether `bytes` start like a Photoshop document.
+pub fn is_psd(bytes: &[u8]) -> bool {
+    bytes.len() >= 6 && &bytes[..4] == b"8BPS" && matches!(u16::from_be_bytes([bytes[4], bytes[5]]), 1 | 2)
+}
+
+impl Psd {
+    pub fn parse(data: impl Into<Arc<[u8]>>) -> Result<Psd> {
+        let data: Arc<[u8]> = data.into();
+        let mut r = Reader::new(&data);
+        if r.bytes(4).ok() != Some(b"8BPS") {
+            return Err(Error::NotPsd);
+        }
+        let version = r.u16()?;
+        let psb = match version {
+            1 => false,
+            2 => true,
+            _ => return Err(Error::NotPsd),
+        };
+        r.skip(6)?;
+        let channels = r.u16()?;
+        let height = r.u32()?;
+        let width = r.u32()?;
+        let depth = r.u16()?;
+        let mode_v = r.u16()?;
+        let mode = ColorMode::from_u16(mode_v).ok_or_else(|| Error::Unsupported(format!("colour mode {mode_v}")))?;
+        if !matches!(depth, 1 | 8 | 16 | 32) {
+            return Err(Error::Unsupported(format!("{depth}-bit")));
+        }
+        if width == 0 || height == 0 || width > 300_000 || height > 300_000 {
+            return Err(Error::Invalid(format!("size {width}x{height}")));
+        }
+        // Colour mode data.
+        let n = r.u32()? as usize;
+        let palette = r.bytes(n)?.to_vec();
+        // Image resources.
+        let n = r.u32()? as usize;
+        r.skip(n)?;
+        // Layer and mask information.
+        let mut psd = Psd {
+            psb,
+            width,
+            height,
+            channels,
+            depth,
+            mode,
+            layers: vec![],
+            merged_alpha: false,
+            palette,
+            linked: vec![],
+            warnings: vec![],
+            data: data.clone(),
+            merged_offset: 0,
+        };
+        let lm_len = r.length(psb)?;
+        let lm_end = r.pos.checked_add(lm_len).filter(|&e| e <= data.len()).ok_or(Error::Truncated)?;
+        if lm_len > 0 {
+            let li_len = r.length(psb)?;
+            let li_end = r.pos.checked_add(li_len).filter(|&e| e <= lm_end).ok_or(Error::Truncated)?;
+            if li_len > 0
+                && let Err(e) = psd.layer_info(&data, r.pos, li_end)
+            {
+                // A damaged layer section must not discard the document: keep the header and the
+                // merged image, drop the layers and say so. Without a merged image there is
+                // nothing to fall back to, so the original error stands.
+                if lm_end.checked_add(2).is_none_or(|n| n > data.len()) {
+                    return Err(e);
+                }
+                psd.layers.clear();
+                psd.warnings.push(format!("Layers could not be read ({e}); only the flattened image is available"));
+            }
+            r.pos = li_end;
+            if r.pos + 4 <= lm_end {
+                let g = r.u32()? as usize;
+                r.pos = (r.pos + g).min(lm_end);
+            }
+            // Global additional layer information (16/32-bit layer info lives here).
+            while let Some((key, start, end)) = next_block(&data, &mut r.pos, lm_end, psb) {
+                if matches!(&key, b"lnk2" | b"lnkD" | b"lnk3" | b"lnkE") {
+                    psd.linked_files(&data, start, end);
+                }
+                if matches!(&key, b"Lr16" | b"Lr32" | b"Layr") && psd.layers.is_empty() && end > start {
+                    // The block holds the layer info, normally without its length field; accept
+                    // both layouts.
+                    if psd.layer_info(&data, start, end).is_err() || psd.layers.is_empty() {
+                        psd.layers.clear();
+                        let skip = if psb { 8 } else { 4 };
+                        if start + skip < end && psd.layer_info(&data, start + skip, end).is_err() {
+                            psd.layers.clear();
+                        }
+                    }
+                }
+                r.pos = end;
+            }
+        }
+        if !psd.layers.is_empty() {
+            // A 16/32-bit layer block recovered the layers.
+            psd.warnings.clear();
+        }
+        psd.merged_offset = lm_end;
+        Ok(psd)
+    }
+
+    /// The embedded bytes of linked file `uuid`.
+    pub fn linked_data(&self, uuid: &str) -> Option<&[u8]> {
+        let f = self.linked.iter().find(|f| f.uuid == uuid)?;
+        self.data.get(f.data.clone()?)
+    }
+
+    /// Linked layer data records (spec: "Linked Layer"): length, kind (`liFD` embedded data,
+    /// `liFE` external file, `liFA` alias), version, unique id, original file name, type,
+    /// creator, data length, optional descriptors, then the data. A damaged record ends the list.
+    fn linked_files(&mut self, data: &[u8], start: usize, end: usize) {
+        let mut pos = start;
+        while pos + 8 <= end {
+            let mut r = Reader::at(&data[..end], pos);
+            let Ok(len) = r.u64() else { break };
+            let body = r.pos;
+            let Some(rec_end) = body.checked_add(len as usize).filter(|e| *e <= end) else { break };
+            let mut r = Reader::at(&data[..rec_end], body);
+            let rec = (|| -> Result<LinkedFile> {
+                let kind = r.tag()?;
+                let version = r.u32()?;
+                let n = r.u8()? as usize;
+                let uuid = String::from_utf8_lossy(r.bytes(n)?).into_owned();
+                let name = descriptor::read_unicode(&mut r)?;
+                let file_type = String::from_utf8_lossy(&r.tag()?).trim().to_string();
+                let _creator = r.tag()?;
+                let dlen = r.u64()? as usize;
+                if r.u8()? != 0 {
+                    let _v = r.u32()?;
+                    descriptor::read_descriptor(&mut r)?;
+                }
+                let mut out = LinkedFile { uuid, name, file_type, data: None };
+                match &kind {
+                    b"liFD" => {
+                        let s = r.pos;
+                        r.skip(dlen)?;
+                        out.data = Some(s..s + dlen);
+                    }
+                    b"liFE" => {
+                        let _v = r.u32()?;
+                        descriptor::read_descriptor(&mut r)?;
+                        if version > 3 {
+                            r.skip(4 + 4 + 8)?;
+                        }
+                        let _size = r.u64()?;
+                        if version > 2 && r.remaining() >= dlen && dlen > 0 {
+                            let s = r.pos;
+                            out.data = Some(s..s + dlen);
+                        }
+                    }
+                    _ => {}
+                }
+                Ok(out)
+            })();
+            match rec {
+                Ok(f) => self.linked.push(f),
+                Err(_) => break,
+            }
+            pos = rec_end.div_ceil(4) * 4;
+        }
+    }
+
+    fn layer_info(&mut self, data: &[u8], start: usize, end: usize) -> Result<()> {
+        let mut r = Reader::at(&data[..end], start);
+        let count = r.i16()?;
+        self.merged_alpha = count < 0;
+        let n = count.unsigned_abs() as usize;
+        let mut layers = Vec::with_capacity(n);
+        for i in 0..n {
+            layers.push(self.layer_record(&mut r, i)?);
+        }
+        // Channel image data follows in record order.
+        for l in &mut layers {
+            for c in &mut l.channels {
+                c.offset = r.pos;
+                r.skip(c.len)?;
+            }
+        }
+        self.layers = layers;
+        Ok(())
+    }
+
+    fn layer_record(&self, r: &mut Reader, index: usize) -> Result<Layer> {
+        let psb = self.psb;
+        let (top, left, bottom, right) = (r.i32()?, r.i32()?, r.i32()?, r.i32()?);
+        let nch = r.u16()? as usize;
+        if nch > 64 {
+            return Err(Error::Invalid("channel count".into()));
+        }
+        let mut channels = Vec::with_capacity(nch);
+        for _ in 0..nch {
+            let id = r.i16()?;
+            let len = r.length(psb)?;
+            channels.push(ChannelInfo { id, offset: 0, len });
+        }
+        if r.bytes(4)? != b"8BIM" {
+            return Err(Error::Invalid("layer record signature".into()));
+        }
+        let blend = r.tag()?;
+        let opacity = r.u8()?;
+        let clipping = r.u8()? != 0;
+        let flags = r.u8()?;
+        r.skip(1)?;
+        let extra = r.u32()? as usize;
+        let extra_end = r.pos.checked_add(extra).filter(|&e| e <= r.data.len()).ok_or(Error::Truncated)?;
+        let mut l = Layer {
+            index,
+            rect: Rect { top, left, bottom, right },
+            blend,
+            opacity,
+            fill_opacity: 255,
+            clipping,
+            hidden: flags & 2 != 0,
+            protect_transparency: flags & 1 != 0,
+            channels,
+            ..Default::default()
+        };
+        // Layer mask data.
+        let mlen = r.u32()? as usize;
+        let mstart = r.pos;
+        if mlen >= 18 {
+            let rect = Rect { top: r.i32()?, left: r.i32()?, bottom: r.i32()?, right: r.i32()? };
+            let default_color = r.u8()?;
+            let mflags = r.u8()?;
+            l.mask = Some(LayerMask { rect, default_color, disabled: mflags & 2 != 0, inverted: mflags & 4 != 0 });
+        }
+        r.pos = mstart + mlen;
+        // Blending ranges.
+        let blen = r.u32()? as usize;
+        r.skip(blen)?;
+        l.name = r.pascal(4)?;
+        let mut pos = r.pos;
+        let data = r.data;
+        while let Some((key, start, end)) = next_block(data, &mut pos, extra_end, psb) {
+            l.keys.push(key);
+            let block = &data[start..end];
+            // A malformed block only loses that block's information.
+            let _ = self.layer_block(&mut l, &key, block);
+            pos = end;
+        }
+        r.pos = extra_end;
+        Ok(l)
+    }
+
+    fn layer_block(&self, l: &mut Layer, key: &[u8; 4], b: &[u8]) -> Result<()> {
+        let mut r = Reader::new(b);
+        match key {
+            b"luni" => {
+                let name = descriptor::read_unicode(&mut r)?;
+                if !name.is_empty() {
+                    l.name = name;
+                }
+            }
+            b"lyid" => l.id = Some(r.u32()?),
+            b"iOpa" => l.fill_opacity = r.u8()?,
+            b"lsct" | b"lsdk" => {
+                l.section = match r.u32()? {
+                    1 => Section::OpenFolder,
+                    2 => Section::ClosedFolder,
+                    3 => Section::Divider,
+                    _ => Section::Layer,
+                };
+                if b.len() >= 12 && &b[4..8] == b"8BIM" {
+                    l.blend.copy_from_slice(&b[8..12]);
+                }
+            }
+            b"TySh" => {
+                let _ver = r.u16()?;
+                let mut t = [0.0; 6];
+                for v in &mut t {
+                    *v = r.f64()?;
+                }
+                // A transform with NaN/inf is unusable: fall back to the identity.
+                if t.iter().any(|v| !v.is_finite()) {
+                    t = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
+                }
+                let _text_ver = r.u16()?;
+                let _desc_ver = r.u32()?;
+                let d = descriptor::read_descriptor(&mut r)?;
+                let text = d.text("Txt ").unwrap_or_default().replace("\r\n", "\n").replace('\r', "\n");
+                let text = text.strip_suffix('\n').map(str::to_string).unwrap_or(text);
+                let style = d.raw("EngineData").map(|e| engine_data::text_style(&engine_data::parse(e))).unwrap_or_default();
+                let bounds =
+                    d.obj("bounds").or_else(|| d.obj("boundingBox")).and_then(|o| Some([o.num("Left")?, o.num("Top ")?, o.num("Rght")?, o.num("Btom")?]));
+                l.text = Some(TextInfo { text, transform: t, style, bounds });
+            }
+            b"lfx2" => {
+                let _ver = r.u32()?;
+                let _dver = r.u32()?;
+                l.effects = Some(descriptor::read_descriptor(&mut r)?);
+            }
+            b"SoCo" => {
+                let _ver = r.u32()?;
+                let d = descriptor::read_descriptor(&mut r)?;
+                l.fill = d.color("Clr ");
+            }
+            b"nvrt" => l.adjustment = Some(Adjustment::Invert),
+            b"brit" => {
+                let brightness = r.i16()? as f64;
+                let contrast = r.i16()? as f64;
+                if l.adjustment.is_none() {
+                    l.adjustment = Some(Adjustment::BrightnessContrast { brightness, contrast, legacy: true });
+                }
+            }
+            b"CgEd" => {
+                let _ver = r.u32()?;
+                let d = descriptor::read_descriptor(&mut r)?;
+                l.adjustment = Some(Adjustment::BrightnessContrast {
+                    brightness: d.num("Brgh").unwrap_or(0.0),
+                    contrast: d.num("Cntr").unwrap_or(0.0),
+                    legacy: d.bool("useLegacy").unwrap_or(false),
+                });
+            }
+            b"hue2" | b"hue " => {
+                let _ver = r.u16()?;
+                let colorize = r.u8()? != 0;
+                r.skip(1)?;
+                let ch = (r.i16()? as f64, r.i16()? as f64, r.i16()? as f64);
+                let m = (r.i16()? as f64, r.i16()? as f64, r.i16()? as f64);
+                let (hue, saturation, lightness) = if colorize { ch } else { m };
+                l.adjustment = Some(Adjustment::HueSaturation { hue, saturation, lightness, colorize });
+            }
+            b"levl" => {
+                let _ver = r.u16()?;
+                let (ib, iw, ob, ow, g) = (r.i16()?, r.i16()?, r.i16()?, r.i16()?, r.i16()?);
+                l.adjustment =
+                    Some(Adjustment::Levels { in_black: ib as f64, in_white: iw as f64, gamma: g as f64 / 100.0, out_black: ob as f64, out_white: ow as f64 });
+            }
+            b"expA" => {
+                let _ver = r.u16()?;
+                let mut finite = |default: f64| -> Result<f64> {
+                    let v = f64::from(r.f32()?);
+                    Ok(if v.is_finite() { v } else { default })
+                };
+                let exposure = finite(0.0)?;
+                let offset = finite(0.0)?;
+                let gamma = finite(1.0)?;
+                l.adjustment = Some(Adjustment::Exposure { exposure, offset, gamma });
+            }
+            b"curv" | b"blnc" | b"post" | b"thrs" | b"selc" | b"mixr" | b"phfl" | b"vibA" | b"blwh" | b"grdm" | b"clrL" if l.adjustment.is_none() => {
+                l.adjustment = Some(Adjustment::Other(String::from_utf8_lossy(key).into_owned()));
+            }
+            b"SoLd" | b"SoLE" => {
+                let _id = r.tag()?;
+                let _ver = r.u32()?;
+                let _dver = r.u32()?;
+                let d = descriptor::read_descriptor(&mut r)?;
+                let uuid = d.text("Idnt").unwrap_or_default().to_string();
+                let t = placed::eight(&d, "Trnf").unwrap_or([0.0; 8]);
+                // The non-affine transform when present (perspective), else the transform.
+                let t = placed::eight(&d, "nonAffineTransform").unwrap_or(t);
+                let size = d.obj("Sz  ").and_then(|s| Some([s.num("Wdth")?, s.num("Hght")?]));
+                let warp = d.obj("warp").and_then(placed::Warp::read);
+                l.smart_object = Some(SmartObject { uuid, quad: placed::quad_from(t), size, warp });
+            }
+            b"PlLd" if l.smart_object.is_none() => {
+                let _id = r.tag()?;
+                let _ver = r.u32()?;
+                let n = r.u8()? as usize;
+                let uuid = String::from_utf8_lossy(r.bytes(n)?).into_owned();
+                let _page = r.u32()?;
+                let _pages = r.u32()?;
+                let _aa = r.u32()?;
+                let _ty = r.u32()?;
+                let mut t = [0.0; 8];
+                for v in &mut t {
+                    *v = r.f64_finite()?;
+                }
+                l.smart_object = Some(SmartObject { uuid, quad: placed::quad_from(t), size: None, warp: None });
+            }
+            b"vmsk" | b"vsms" => {
+                let _ver = r.u32()?;
+                let flags = r.u32()?;
+                l.vector_mask = Some(self.vector_paths(&mut r, flags)?);
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn vector_paths(&self, r: &mut Reader, flags: u32) -> Result<VectorMask> {
+        let (w, h) = (self.width as f64, self.height as f64);
+        let mut vm = VectorMask { inverted: flags & 1 != 0, disabled: flags & 4 != 0, subpaths: vec![] };
+        let fixed = |r: &mut Reader| -> Result<f64> { Ok(r.i32()? as f64 / (1 << 24) as f64) };
+        while r.remaining() >= 26 {
+            let sel = r.u16()?;
+            match sel {
+                0 | 3 => {
+                    let _n = r.u16()?;
+                    r.skip(22)?;
+                    vm.subpaths.push(SubPath { closed: sel == 0, knots: vec![] });
+                }
+                1 | 2 | 4 | 5 => {
+                    let mut pts = [[0.0; 2]; 3];
+                    for p in &mut pts {
+                        let y = fixed(r)?;
+                        let x = fixed(r)?;
+                        *p = [x * w, y * h];
+                    }
+                    if let Some(sp) = vm.subpaths.last_mut() {
+                        sp.knots.push(pts);
+                    }
+                }
+                _ => r.skip(24)?,
+            }
+        }
+        vm.subpaths.retain(|s| !s.knots.is_empty());
+        Ok(vm)
+    }
+
+    /// The layer tree, top of the stack first. Groups nest at most [`MAX_GROUP_DEPTH`] deep (see
+    /// [`Psd::tree_report`]).
+    pub fn tree(&self) -> Vec<Node> {
+        self.tree_report().0
+    }
+
+    /// The layer tree plus the number of groups nested deeper than [`MAX_GROUP_DEPTH`]. Those
+    /// are flattened into their deepest allowed ancestor: their children stay, in order, and
+    /// the group record itself becomes a plain [`Node::Layer`], so no layer is lost and the
+    /// tree (and its `Drop`, `Clone` and `PartialEq`) cannot recurse deeper than the limit.
+    pub fn tree_report(&self) -> (Vec<Node>, usize) {
+        let mut stack: Vec<Vec<Node>> = vec![vec![]];
+        // Dividers seen while `MAX_GROUP_DEPTH` groups were already open.
+        let mut flattened_open = 0usize;
+        let mut flattened = 0usize;
+        for l in &self.layers {
+            match l.section {
+                Section::Divider => {
+                    if stack.len() > MAX_GROUP_DEPTH {
+                        flattened_open += 1;
+                    } else {
+                        stack.push(vec![]);
+                    }
+                }
+                Section::OpenFolder | Section::ClosedFolder => {
+                    if flattened_open > 0 {
+                        flattened_open -= 1;
+                        flattened += 1;
+                        if let Some(top) = stack.last_mut() {
+                            top.push(Node::Layer(l.index));
+                        }
+                        continue;
+                    }
+                    let children = if stack.len() > 1 { stack.pop().unwrap_or_default() } else { vec![] };
+                    if let Some(top) = stack.last_mut() {
+                        top.push(Node::Group { layer: l.index, children });
+                    }
+                }
+                Section::Layer => {
+                    if let Some(top) = stack.last_mut() {
+                        top.push(Node::Layer(l.index));
+                    }
+                }
+            }
+        }
+        while stack.len() > 1 {
+            let c = stack.pop().unwrap_or_default();
+            if let Some(top) = stack.last_mut() {
+                top.extend(c);
+            }
+        }
+        // Depth is at most `MAX_GROUP_DEPTH`, so recursion is bounded.
+        fn rev(v: &mut Vec<Node>) {
+            v.reverse();
+            for n in v {
+                if let Node::Group { children, .. } = n {
+                    rev(children);
+                }
+            }
+        }
+        let mut out = stack.pop().unwrap_or_default();
+        rev(&mut out);
+        (out, flattened)
+    }
+}
+
+/// The next additional-information block at `*pos` (signature `8BIM`/`8B64`, key, length):
+/// returns (key, data start, data end). Skips up to 3 padding bytes before a signature.
+fn next_block(data: &[u8], pos: &mut usize, end: usize, psb: bool) -> Option<([u8; 4], usize, usize)> {
+    let mut p = *pos;
+    for _ in 0..4 {
+        if p + 12 > end {
+            return None;
+        }
+        if &data[p..p + 4] == b"8BIM" || &data[p..p + 4] == b"8B64" {
+            break;
+        }
+        p += 1;
+    }
+    if p + 12 > end || !(&data[p..p + 4] == b"8BIM" || &data[p..p + 4] == b"8B64") {
+        return None;
+    }
+    let mut key = [0u8; 4];
+    key.copy_from_slice(&data[p + 4..p + 8]);
+    let wide =
+        psb && matches!(&key, b"LMsk" | b"Lr16" | b"Lr32" | b"Layr" | b"Mt16" | b"Mt32" | b"Mtrn" | b"Alph" | b"FMsk" | b"lnk2" | b"FEid" | b"FXid" | b"PxSD");
+    let mut r = Reader::at(&data[..end], p + 8);
+    let len = r.length(wide).ok()?;
+    let start = r.pos;
+    let stop = start.checked_add(len)?;
+    if stop > end {
+        return None;
+    }
+    *pos = stop;
+    Some((key, start, stop))
+}
diff --git a/crates/psd/src/pixels.rs b/crates/psd/src/pixels.rs
new file mode 100644
index 000000000..21a5c8845
--- /dev/null
+++ b/crates/psd/src/pixels.rs
@@ -0,0 +1,554 @@
+#[cfg(test)]
+use super::counters;
+use super::limits::{Budget, DECODE_BUDGET, Error, Result, decode_pixels, finite_sample, inflate, release_bytes, too_large};
+use super::model::{ColorMode, Layer, Pixels, Rect};
+use super::{Psd, Reader};
+use std::borrow::Cow;
+
+impl Psd {
+    fn bytes_per_sample(&self) -> usize {
+        match self.depth {
+            16 => 2,
+            32 => 4,
+            _ => 1,
+        }
+    }
+
+    /// The raw big-endian bytes of one channel of `w`×`h` samples at `offset` (compression field
+    /// first): `row_bytes(w) × h` of them with the compression and the prediction undone.
+    /// Uncompressed data is borrowed from the file, not copied; any other buffer is charged to
+    /// `budget` and the caller releases it (see [`release_bytes`]) once it is dropped.
+    fn channel_bytes(&self, offset: usize, len: usize, w: usize, h: usize, budget: &mut Budget) -> Result<Cow<'_, [u8]>> {
+        let end = offset.checked_add(len).filter(|&e| e <= self.data.len()).ok_or(Error::Truncated)?;
+        let mut r = Reader::at(self.data.get(..end).ok_or(Error::Truncated)?, offset);
+        let comp = r.u16()?;
+        decode_pixels(w, h)?;
+        self.plane_bytes(comp, &mut r, w, h, budget)
+    }
+
+    /// The raw bytes (`row_bytes(w)` × `h`, ZIP prediction undone) of one channel whose pixel data
+    /// follows `r`'s position (after the compression field). Uncompressed data is borrowed, not
+    /// copied; the other buffers are charged to `budget`.
+    pub(crate) fn plane_bytes<'a>(&self, comp: u16, r: &mut Reader<'a>, w: usize, h: usize, budget: &mut Budget) -> Result<Cow<'a, [u8]>> {
+        let rowb = self.row_bytes(w);
+        let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;
+        Ok(match self.open_planes(comp, r, 1, 1, (w, h), budget)? {
+            PlaneStream::Raw => Cow::Borrowed(r.bytes(size)?),
+            PlaneStream::Rle(counts) => Cow::Owned(Self::unpack_plane(&counts, 0, r, rowb, h, budget)?),
+            PlaneStream::Zip(mut v) => {
+                v.resize(size, 0);
+                self.zip_plane(comp, &mut v, 0, w, h)?;
+                Cow::Owned(v)
+            }
+        })
+    }
+
+    /// Prepare the pixel data at `r` (just after the compression field) of `total` planes of
+    /// `w`×`h` samples, of which the first `want` are decoded: the RLE row sizes of every plane,
+    /// or the inflated ZIP data, which holds all planes one after another (charged to `budget`
+    /// before it is inflated).
+    fn open_planes(&self, comp: u16, r: &mut Reader, total: usize, want: usize, size: (usize, usize), budget: &mut Budget) -> Result<PlaneStream> {
+        let (w, h) = size;
+        let size = self.row_bytes(w).checked_mul(h).ok_or_else(|| too_large(w, h))?;
+        Ok(match comp {
+            0 => PlaneStream::Raw,
+            1 => {
+                let n = total.saturating_mul(h);
+                let mut counts = Vec::with_capacity(n.min(r.remaining() / 2));
+                for _ in 0..n {
+                    counts.push(if self.psb { r.u32()? as usize } else { r.u16()? as usize });
+                }
+                PlaneStream::Rle(counts)
+            }
+            2 | 3 => {
+                let rest = r.bytes(r.remaining())?;
+                // One stream holds every plane: what it may decode to is what they need.
+                let all = size.checked_mul(want).ok_or_else(|| too_large(w, h))?;
+                budget.charge(all as u64)?;
+                PlaneStream::Zip(inflate(rest, all)?)
+            }
+            c => return Err(Error::Unsupported(format!("compression {c}"))),
+        })
+    }
+
+    /// The raw bytes (`row_bytes(w)` × `h`, ZIP prediction undone) of plane `c`: raw and RLE
+    /// planes are read from `r` in order, raw ones borrowed from the file data, ZIP ones from the
+    /// inflated buffer (un-predicted in place; already charged by `open_planes`), RLE ones charged
+    /// to `budget`.
+    fn decode_plane<'x, 'a: 'x>(
+        &self,
+        comp: u16,
+        planes: &'x mut PlaneStream,
+        r: &mut Reader<'a>,
+        c: usize,
+        size: (usize, usize),
+        budget: &mut Budget,
+    ) -> Result<Cow<'x, [u8]>> {
+        let (w, h) = size;
+        let rowb = self.row_bytes(w);
+        let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;
+        Ok(match planes {
+            PlaneStream::Raw => Cow::Borrowed(r.bytes(size)?),
+            PlaneStream::Rle(counts) => Cow::Owned(Self::unpack_plane(counts, c, r, rowb, h, budget)?),
+            PlaneStream::Zip(v) => Cow::Borrowed(self.zip_plane(comp, v, c, w, h)?),
+        })
+    }
+
+    /// Unpack the `h` RLE rows of plane `c` (row byte counts `counts`, plane after plane) into a
+    /// buffer charged to `budget`.
+    fn unpack_plane(counts: &[usize], c: usize, r: &mut Reader, rowb: usize, h: usize, budget: &mut Budget) -> Result<Vec<u8>> {
+        let mut out = budget.vec::<u8>(rowb.checked_mul(h).ok_or(Error::Truncated)?)?;
+        for row in 0..h {
+            let n = *counts.get(c * h + row).ok_or(Error::Truncated)?;
+            unpack_bits(r.bytes(n)?, rowb, &mut out)?;
+        }
+        Ok(out)
+    }
+
+    /// Plane `c` of the inflated ZIP data of consecutive planes, un-predicted in place (`comp` 3).
+    pub(crate) fn zip_plane<'v>(&self, comp: u16, v: &'v mut [u8], c: usize, w: usize, h: usize) -> Result<&'v [u8]> {
+        let rowb = self.row_bytes(w);
+        let plane = v.get_mut(c * rowb * h..(c + 1) * rowb * h).ok_or(Error::Truncated)?;
+        if comp == 3 {
+            self.unpredict(plane, w, h);
+        }
+        Ok(plane)
+    }
+
+    /// One channel as `w * h` floats (0..1), charged to `budget` (the caller releases it).
+    fn channel_floats(&self, offset: usize, len: usize, w: usize, h: usize, budget: &mut Budget) -> Result<Vec<f32>> {
+        let raw = self.channel_bytes(offset, len, w, h, budget)?;
+        let mut out = budget.filled(decode_pixels(w, h)?, 0.0f32)?;
+        self.for_each_sample(&raw, w, h, |i, v| {
+            if let Some(o) = out.get_mut(i) {
+                *o = v;
+            }
+        });
+        release_bytes(budget, raw);
+        Ok(out)
+    }
+
+    pub(crate) fn row_bytes(&self, w: usize) -> usize {
+        if self.depth == 1 { w.div_ceil(8) } else { w * self.bytes_per_sample() }
+    }
+
+    pub(crate) fn unpredict(&self, v: &mut [u8], w: usize, h: usize) {
+        match self.depth {
+            16 => {
+                for row in v.chunks_exact_mut(w * 2).take(h) {
+                    let mut prev = 0u16;
+                    for c in row.as_chunks_mut::<2>().0 {
+                        let x = u16::from_be_bytes([c[0], c[1]]).wrapping_add(prev);
+                        c.copy_from_slice(&x.to_be_bytes());
+                        prev = x;
+                    }
+                }
+            }
+            32 => {
+                // One scratch row for the whole plane.
+                let mut planar = vec![0u8; w * 4];
+                #[cfg(test)]
+                counters::bump(&counters::SCRATCH);
+                for row in v.chunks_exact_mut(w * 4).take(h) {
+                    for i in 1..row.len() {
+                        row[i] = row[i].wrapping_add(row[i - 1]);
+                    }
+                    // Bytes are stored plane by plane (all first bytes, then all second bytes…).
+                    planar.copy_from_slice(row);
+                    for x in 0..w {
+                        for b in 0..4 {
+                            row[x * 4 + b] = planar[b * w + x];
+                        }
+                    }
+                }
+            }
+            _ => {
+                for row in v.chunks_exact_mut(w).take(h) {
+                    for i in 1..row.len() {
+                        row[i] = row[i].wrapping_add(row[i - 1]);
+                    }
+                }
+            }
+        }
+    }
+
+    /// Hand every sample of `raw` (`w`×`h`, row-major, in order) to `f` as a float. Samples a short
+    /// `raw` does not have are not reported.
+    pub(crate) fn for_each_sample(&self, raw: &[u8], w: usize, h: usize, mut f: impl FnMut(usize, f32)) {
+        let n = w.saturating_mul(h);
+        match self.depth {
+            1 => {
+                let rowb = w.div_ceil(8);
+                for y in 0..h {
+                    for x in 0..w {
+                        let b = raw.get(y * rowb + x / 8).copied().unwrap_or(0);
+                        // 1 = black.
+                        f(y * w + x, if b & (0x80 >> (x % 8)) != 0 { 0.0 } else { 1.0 });
+                    }
+                }
+            }
+            16 => raw.as_chunks::<2>().0.iter().take(n).enumerate().for_each(|(i, c)| f(i, u16::from_be_bytes([c[0], c[1]]) as f32 / 65535.0)),
+            // NaN reads as 0, +inf as white (1.0, like the integer depths' maximum), -inf as 0.
+            32 => raw.as_chunks::<4>().0.iter().take(n).enumerate().for_each(|(i, c)| f(i, finite_sample(f32::from_be_bytes([c[0], c[1], c[2], c[3]])))),
+            _ => raw.iter().take(n).enumerate().for_each(|(i, &b)| f(i, b as f32 / 255.0)),
+        }
+    }
+
+    /// Convert colour values (the document mode's channels, missing ones 0) to RGB.
+    pub(crate) fn rgb_from(&self, v: [f32; 4]) -> [f32; 3] {
+        let g = |k: usize| v.get(k).copied().unwrap_or(0.0);
+        let rgb = match self.mode {
+            ColorMode::Rgb => [g(0), g(1), g(2)],
+            ColorMode::Cmyk => {
+                // Stored inverted (1 = no ink).
+                let k = g(3);
+                [g(0) * k, g(1) * k, g(2) * k]
+            }
+            ColorMode::Indexed if self.palette.len() >= 768 => {
+                let idx = (g(0) * 255.0).round() as usize & 255;
+                [self.palette[idx] as f32 / 255.0, self.palette[256 + idx] as f32 / 255.0, self.palette[512 + idx] as f32 / 255.0]
+            }
+            ColorMode::Lab => lab_to_rgb(g(0) * 100.0, g(1) * 255.0 - 128.0, g(2) * 255.0 - 128.0),
+            _ => [g(0); 3],
+        };
+        if self.depth == 32 && self.mode != ColorMode::Lab { rgb.map(srgb_encode) } else { rgb }
+    }
+
+    /// Write merged-image channel `c` (raw bytes) into the result: the first three colour channels
+    /// and the alpha channel into their slot of a pixel, the fourth CMYK channel into `black`.
+    fn store_merged_channel(&self, c: usize, raw: &[u8], data: &mut [[f32; 4]], black: &mut Option<Vec<f32>>) {
+        let (w, h, cc) = (self.width as usize, self.height as usize, self.mode.color_channels());
+        if c < cc.min(3) {
+            self.for_each_sample(raw, w, h, |i, v| {
+                if let Some(p) = data.get_mut(i) {
+                    p[c] = v;
+                }
+            });
+        } else if c == 3 && c < cc {
+            if let Some(k) = black {
+                self.for_each_sample(raw, w, h, |i, v| {
+                    if let Some(o) = k.get_mut(i) {
+                        *o = v;
+                    }
+                });
+            }
+        } else if c == cc && self.merged_alpha {
+            self.for_each_sample(raw, w, h, |i, v| {
+                if let Some(p) = data.get_mut(i) {
+                    p[3] = v;
+                }
+            });
+        }
+    }
+
+    /// The merged (flattened) image.
+    pub fn composite(&self) -> Result<Pixels> {
+        self.composite_with_budget(DECODE_BUDGET)
+    }
+
+    /// [`Self::composite`] with at most `limit` bytes live at once. The channels are written
+    /// straight into the result, so the peak is the result (16 bytes a pixel), the CMYK black
+    /// channel, and the one buffer a channel (or, for ZIP, all channels) decodes through.
+    pub(crate) fn composite_with_budget(&self, limit: u64) -> Result<Pixels> {
+        let mut budget = Budget::new(limit);
+        let (w, h) = (self.width as usize, self.height as usize);
+        let n = decode_pixels(w, h)?;
+        let mut r = Reader::at(&self.data, self.merged_offset);
+        let comp = r.u16()?;
+        let nch = self.channels as usize;
+        let cc = self.mode.color_channels();
+        let want = (cc + usize::from(self.merged_alpha)).min(nch);
+        let rowb = self.row_bytes(w);
+        let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;
+        // The peak: the result, the CMYK black channel and what the channels decode through.
+        let black_bytes = if self.mode == ColorMode::Cmyk && want > 3 { 4 * n as u64 } else { 0 };
+        let transient = if matches!(comp, 2 | 3) { (size as u64).saturating_mul(want as u64) } else { size as u64 };
+        budget.check((16 * n as u64).saturating_add(black_bytes).saturating_add(transient))?;
+        // Opaque black until a channel says otherwise.
+        let mut data = budget.filled(n, [0.0f32, 0.0, 0.0, 1.0])?;
+        let mut black = if self.mode == ColorMode::Cmyk && want > 3 { Some(budget.filled(n, 0.0f32)?) } else { None };
+        let mut stream = self.open_planes(comp, &mut r, nch, want, (w, h), &mut budget)?;
+        for c in 0..want {
+            let raw = self.decode_plane(comp, &mut stream, &mut r, c, (w, h), &mut budget)?;
+            self.store_merged_channel(c, &raw, &mut data, &mut black);
+            release_bytes(&mut budget, raw);
+        }
+        for (i, p) in data.iter_mut().enumerate() {
+            let k = black.as_ref().and_then(|k| k.get(i)).copied().unwrap_or(0.0);
+            let [r, g, b] = self.rgb_from([p[0], p[1], p[2], k]);
+            *p = [r, g, b, p[3]];
+        }
+        Ok(Pixels { width: w as u32, height: h as u32, data })
+    }
+
+    /// One layer's pixels with its layer mask (and vector-less fill colour) applied to alpha.
+    /// `canvas`: document-sized with the layer in place; otherwise the layer's own bounds.
+    pub fn layer_pixels(&self, index: usize, canvas: bool) -> Result<Pixels> {
+        self.layer_pixels_with_budget(index, canvas, DECODE_BUDGET)
+    }
+
+    /// [`Self::layer_pixels`] with at most `limit` bytes live at once: the result (16 bytes a
+    /// pixel) with the channels written straight into it, the CMYK black channel, the one channel
+    /// being decoded, and the mask.
+    pub(crate) fn layer_pixels_with_budget(&self, index: usize, canvas: bool, limit: u64) -> Result<Pixels> {
+        let mut budget = Budget::new(limit);
+        let l = self.layers.get(index).ok_or_else(|| Error::Invalid(format!("no layer {index}")))?;
+        let doc = Rect { top: 0, left: 0, bottom: self.height as i32, right: self.width as i32 };
+        // Fill layers often have no pixel data: they cover the canvas (or the mask).
+        let fill_rect =
+            if l.fill.is_some() && !l.has_pixels() { l.mask.filter(|m| !m.rect.is_empty() && m.default_color == 0).map_or(doc, |m| m.rect) } else { l.rect };
+        let out_rect = if canvas {
+            doc
+        } else if fill_rect.is_empty() {
+            Rect { top: 0, left: 0, bottom: 1, right: 1 }
+        } else {
+            fill_rect
+        };
+        let (ow, oh) = (out_rect.width() as usize, out_rect.height() as usize);
+        let n = decode_pixels(ow, oh)?;
+        let src = fill_rect;
+        let (sw, sh) = (src.width() as usize, src.height() as usize);
+        // The peak: the result, then either the CMYK black channel with the channel being decoded,
+        // or the mask as floats with its bytes. Checked before anything is allocated.
+        let plane = |w: usize, h: usize| (self.row_bytes(w) as u64).saturating_mul(h as u64);
+        let mut pixels_peak = 0u64;
+        if l.has_pixels() && sw > 0 && sh > 0 {
+            pixels_peak = plane(sw, sh).saturating_add(if self.mode == ColorMode::Cmyk { 4 * n as u64 } else { 0 });
+        }
+        let mut mask_peak = 0u64;
+        if let Some(m) = l.mask.filter(|m| !m.disabled) {
+            let (mw, mh) = (m.rect.width() as usize, m.rect.height() as usize);
+            if mw > 0 && mh > 0 && l.channels.iter().any(|c| c.id == -2) {
+                mask_peak = plane(mw, mh).saturating_add((mw as u64).saturating_mul(mh as u64).saturating_mul(4));
+            }
+        }
+        budget.check((16 * n as u64).saturating_add(pixels_peak.max(mask_peak)))?;
+        let mut out = budget.filled(n, [0.0f32; 4])?;
+        if sw > 0 && sh > 0 {
+            // The source rows / columns that land inside the output (64-bit: file bounds can span
+            // the whole i32 range).
+            let span = |s0: i32, n: usize, o0: i32, on: usize| {
+                let off = i64::from(o0) - i64::from(s0);
+                let lo = off.clamp(0, n as i64);
+                let hi = (off + on as i64).clamp(lo, n as i64);
+                (lo as usize..hi as usize, off)
+            };
+            let (ys, oy) = span(src.top, sh, out_rect.top, oh);
+            let (xs, ox) = span(src.left, sw, out_rect.left, ow);
+            let dest = |y: usize, x: usize| (y as i64 - oy) as usize * ow + (x as i64 - ox) as usize;
+            let fill = l.fill.map(|c| c.map(|v| v as f32));
+            match fill {
+                Some(f) if !l.has_pixels() => {
+                    for y in ys {
+                        for x in xs.clone() {
+                            if let Some(p) = out.get_mut(dest(y, x)) {
+                                *p = [f[0], f[1], f[2], 1.0];
+                            }
+                        }
+                    }
+                }
+                _ => {
+                    // Opaque unless there is an alpha channel.
+                    for y in ys.clone() {
+                        for x in xs.clone() {
+                            if let Some(p) = out.get_mut(dest(y, x)) {
+                                p[3] = 1.0;
+                            }
+                        }
+                    }
+                    let cc = self.mode.color_channels();
+                    let mut black: Option<Vec<f32>> = None;
+                    if l.has_pixels() {
+                        for c in &l.channels {
+                            let slot = match c.id {
+                                -1 => 3,
+                                id if id >= 0 && (id as usize) < cc => id as usize,
+                                _ => continue,
+                            };
+                            let raw = self.channel_bytes(c.offset, c.len, sw, sh, &mut budget)?;
+                            // The fourth CMYK channel is the black plate, not a slot of the result.
+                            let to_black = c.id == 3;
+                            if to_black && black.is_none() {
+                                black = Some(budget.filled(out.len(), 0.0f32)?);
+                            }
+                            // Samples arrive in row-major order of the source.
+                            let (mut sy, mut sx) = (0usize, 0usize);
+                            self.for_each_sample(&raw, sw, sh, |_, v| {
+                                if ys.contains(&sy) && xs.contains(&sx) {
+                                    let d = dest(sy, sx);
+                                    if to_black {
+                                        if let Some(o) = black.as_mut().and_then(|k| k.get_mut(d)) {
+                                            *o = v;
+                                        }
+                                    } else if let Some(p) = out.get_mut(d) {
+                                        p[slot] = v;
+                                    }
+                                }
+                                sx += 1;
+                                if sx == sw {
+                                    sx = 0;
+                                    sy += 1;
+                                }
+                            });
+                            release_bytes(&mut budget, raw);
+                        }
+                    }
+                    for y in ys {
+                        for x in xs.clone() {
+                            let d = dest(y, x);
+                            let k = black.as_ref().and_then(|k| k.get(d)).copied().unwrap_or(0.0);
+                            if let Some(p) = out.get_mut(d) {
+                                let [r, g, b] = self.rgb_from([p[0], p[1], p[2], k]);
+                                *p = [r, g, b, p[3]];
+                            }
+                        }
+                    }
+                    if let Some(k) = black {
+                        budget.release(k.len() as u64 * 4);
+                    }
+                }
+            }
+        }
+        self.apply_layer_mask(l, out_rect, &mut out, &mut budget)?;
+        Ok(Pixels { width: ow as u32, height: oh as u32, data: out })
+    }
+
+    /// Apply the raster mask to alpha, including its default outside the mask bounds.
+    fn apply_layer_mask(&self, l: &Layer, out_rect: Rect, out: &mut [[f32; 4]], budget: &mut Budget) -> Result<()> {
+        let (ow, oh) = (out_rect.width() as usize, out_rect.height() as usize);
+        // Layer mask: multiplies alpha (also outside the mask rect, by its default colour).
+        if let Some(m) = l.mask.filter(|m| !m.disabled) {
+            let mc = l.channels.iter().find(|c| c.id == -2);
+            let (mw, mh) = (m.rect.width() as usize, m.rect.height() as usize);
+            let mask = match mc {
+                Some(c) if mw > 0 && mh > 0 => Some(self.channel_floats(c.offset, c.len, mw, mh, budget)?),
+                _ => None,
+            };
+            let def = m.default_color as f32 / 255.0;
+            // The factor outside the mask rect, or everywhere when there is no mask data.
+            let outside = if m.inverted { 1.0 - def } else { def };
+            let scale = |px: &mut [[f32; 4]], v: f32| {
+                if v != 1.0 {
+                    for p in px {
+                        p[3] *= v;
+                    }
+                }
+            };
+            match &mask {
+                None => scale(out, outside),
+                Some(mk) => {
+                    // The columns of the output that fall inside the mask rect (the same for every row).
+                    let lo = (i64::from(m.rect.left) - i64::from(out_rect.left)).clamp(0, ow as i64);
+                    let hi = (i64::from(m.rect.right) - i64::from(out_rect.left)).clamp(lo, ow as i64);
+                    let (lo, hi) = (lo as usize, hi as usize);
+                    for (y, row) in out.chunks_exact_mut(ow.max(1)).take(oh).enumerate() {
+                        let py = i64::from(out_rect.top) + y as i64;
+                        #[cfg(test)]
+                        counters::bump(&counters::INSIDE);
+                        if py < i64::from(m.rect.top) || py >= i64::from(m.rect.bottom) {
+                            scale(row, outside);
+                            continue;
+                        }
+                        let (left, rest) = row.split_at_mut(lo);
+                        let (mid, right) = rest.split_at_mut(hi - lo);
+                        scale(left, outside);
+                        scale(right, outside);
+                        // The mask row under `mid`: its first column is output column `lo`.
+                        let base = (py - i64::from(m.rect.top)) as usize * mw + (i64::from(out_rect.left) + lo as i64 - i64::from(m.rect.left)) as usize;
+                        for (i, p) in mid.iter_mut().enumerate() {
+                            let v = mk.get(base + i).copied().unwrap_or(def);
+                            p[3] *= if m.inverted { 1.0 - v } else { v };
+                        }
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+/// The pixel data of a run of planes, as prepared by `Psd::open_planes`.
+enum PlaneStream {
+    Raw,
+    /// RLE row byte counts of every plane, plane after plane.
+    Rle(Vec<usize>),
+    /// The inflated ZIP data of all planes.
+    Zip(Vec<u8>),
+}
+
+/// PackBits decoding of one row (appends exactly `row` bytes, zero-padded).
+pub(crate) fn unpack_bits(src: &[u8], row: usize, out: &mut Vec<u8>) -> Result<()> {
+    let start = out.len();
+    let mut i = 0;
+    while i < src.len() && out.len() - start < row {
+        let n = src[i] as i8;
+        i += 1;
+        if n >= 0 {
+            let k = n as usize + 1;
+            let s = src.get(i..i + k).ok_or(Error::Truncated)?;
+            out.extend_from_slice(s);
+            i += k;
+        } else if n != -128 {
+            let k = (1 - n as isize) as usize;
+            let v = *src.get(i).ok_or(Error::Truncated)?;
+            out.extend(std::iter::repeat_n(v, k));
+            i += 1;
+        }
+    }
+    out.resize(start + row, 0);
+    Ok(())
+}
+
+/// PackBits encoding of one row.
+pub(crate) fn pack_bits(src: &[u8]) -> Vec<u8> {
+    let mut out = vec![];
+    let mut i = 0;
+    while i < src.len() {
+        // run of identical bytes
+        let mut run = 1;
+        while i + run < src.len() && src[i + run] == src[i] && run < 128 {
+            run += 1;
+        }
+        if run >= 2 {
+            out.push((1 - run as isize) as i8 as u8);
+            out.push(src[i]);
+            i += run;
+            continue;
+        }
+        // literal run
+        let start = i;
+        let mut n = 0;
+        while i < src.len() && n < 128 {
+            if i + 1 < src.len() && src[i + 1] == src[i] {
+                break;
+            }
+            i += 1;
+            n += 1;
+        }
+        if n == 0 {
+            i += 1;
+            n = 1;
+        }
+        out.push((n - 1) as u8);
+        out.extend_from_slice(&src[start..start + n]);
+    }
+    out
+}
+
+pub(crate) fn srgb_encode(v: f32) -> f32 {
+    if v <= 0.003_130_8 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 }
+}
+
+/// CIE L*a*b* (D50) to sRGB (D65 via the Bradford-adapted matrix), clamped.
+pub(crate) fn lab_to_rgb(l: f32, a: f32, b: f32) -> [f32; 3] {
+    let fy = (l + 16.0) / 116.0;
+    let fx = fy + a / 500.0;
+    let fz = fy - b / 200.0;
+    let f = |t: f32| if t > 6.0 / 29.0 { t * t * t } else { 3.0 * (6.0f32 / 29.0).powi(2) * (t - 4.0 / 29.0) };
+    let (x, y, z) = (0.964_22 * f(fx), f(fy), 0.825_21 * f(fz));
+    // XYZ (D50) → linear sRGB.
+    let r = 3.133_856 * x - 1.616_867 * y - 0.490_615 * z;
+    let g = -0.978_768 * x + 1.916_142 * y + 0.033_454 * z;
+    let bb = 0.071_945 * x - 0.228_991 * y + 1.405_243 * z;
+    [r, g, bb].map(|v| srgb_encode(v.clamp(0.0, 1.0)))
+}
diff --git a/crates/psd/src/placed.rs b/crates/psd/src/placed.rs
index dff525a89..981f4ff23 100644
--- a/crates/psd/src/placed.rs
+++ b/crates/psd/src/placed.rs
@@ -16,6 +16,13 @@ use crate::{Pixels, SmartObject};
 /// from the file's transform, which is untrusted.
 pub const MAX_BAKE_PIXELS: u64 = 1 << 24;
 
+/// The bake's rasterising budget, in bounding-box pixels visited over all mesh triangles, as a
+/// multiple of the output pixel count. A sane warp visits about 2× the output; a hostile mesh
+/// that makes every triangle cover the whole output would visit thousands of times more.
+const BAKE_WORK_FACTOR: u64 = 8;
+/// The smallest budget, so tiny outputs are never refused for rounding at the triangle edges.
+const MIN_BAKE_WORK: u64 = 1 << 20;
+
 /// A placed layer's warp.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct Warp {
@@ -305,7 +312,8 @@ impl SmartObject {
     /// Bake the content (straight RGBA) as placed: warped and mapped by the quad, rendered at
     /// `k` pixels per document pixel (into `size` pixels when given; see [`Self::placed_size`]).
     /// Returns the pixels and their document-space origin. `None` when the content is empty or
-    /// the baked image would exceed [`MAX_BAKE_PIXELS`].
+    /// the baked image would exceed [`MAX_BAKE_PIXELS`] or the mesh needs more rasterising work than
+    /// the budget allows (see [`BAKE_WORK_FACTOR`]).
     pub fn render_placed(&self, content: &Pixels, k: f64, size: Option<(u32, u32)>) -> Option<(Pixels, [f64; 2])> {
         let (cw, ch) = (content.width as f64, content.height as f64);
         if content.width == 0 || content.height == 0 {
@@ -352,6 +360,12 @@ impl SmartObject {
             o
         };
         let idx = |i: usize, j: usize| j * (n + 1) + i;
+        // A sane mesh's triangles each span about one grid cell (ow/n by oh/n), rounded out to
+        // whole pixels. A thin output (16384×1) stacks every grid row onto the same pixel row, so
+        // allow each of the 2n² triangles about two cells' extent along each axis, with margin.
+        let rounding = (4 * n as u64).saturating_mul((ow as u64).saturating_add(oh as u64).saturating_add(n as u64));
+        let budget = (count as u64).saturating_mul(BAKE_WORK_FACTOR).max(MIN_BAKE_WORK).saturating_add(rounding);
+        let mut work = 0u64;
         for j in 0..n {
             for i in 0..n {
                 for tri in [[idx(i, j), idx(i + 1, j), idx(i + 1, j + 1)], [idx(i, j), idx(i + 1, j + 1), idx(i, j + 1)]] {
@@ -368,6 +382,10 @@ impl SmartObject {
                     let x1 = (a[0].max(b[0]).max(c[0]).ceil() as usize).min(ow);
                     let y0 = a[1].min(b[1]).min(c[1]).floor().max(0.0) as usize;
                     let y1 = (a[1].max(b[1]).max(c[1]).ceil() as usize).min(oh);
+                    work = work.saturating_add((x1.saturating_sub(x0) as u64).saturating_mul(y1.saturating_sub(y0) as u64));
+                    if work > budget {
+                        return None;
+                    }
                     for y in y0..y1 {
                         for x in x0..x1 {
                             let (px, py) = (x as f64 + 0.5, y as f64 + 0.5);
@@ -510,4 +528,37 @@ mod tests {
         assert!(s.render_placed(&content, 1.0, Some((16384, 16384))).is_none());
         assert!(s.render_placed(&content, 1.0, Some((u32::MAX, u32::MAX))).is_none());
     }
+
+    #[test]
+    fn a_mesh_that_makes_every_triangle_cover_the_output_is_refused() {
+        // A 48×48 custom mesh whose patch corners scatter over the four corners of the
+        // content, so most of the 4608 triangles span the whole 2048² output.
+        let (cols, rows) = (48usize, 48usize);
+        let stride = cols * 3 + 1;
+        let mut mesh = vec![[0.0, 0.0]; stride * (rows * 3 + 1)];
+        for j in 0..=rows {
+            for i in 0..=cols {
+                if let Some(p) = mesh.get_mut(j * 3 * stride + i * 3) {
+                    let h = (i * 7 + j * 13 + i * j * 5) % 4;
+                    *p = [if h & 1 == 0 { 0.0 } else { 16.0 }, if h & 2 == 0 { 0.0 } else { 16.0 }];
+                }
+            }
+        }
+        let warp = Warp { style: "warpCustom".into(), bounds: [0.0, 0.0, 16.0, 16.0], cols, rows, mesh, ..Default::default() };
+        let s = SmartObject { uuid: "x".into(), quad: [[0.0, 0.0], [2048.0, 0.0], [2048.0, 2048.0], [0.0, 2048.0]], size: None, warp: Some(warp) };
+        let content = Pixels { width: 16, height: 16, data: vec![[1.0, 0.0, 0.0, 1.0]; 256] };
+        assert!(s.render_placed(&content, 1.0, Some((2048, 2048))).is_none());
+    }
+
+    #[test]
+    fn a_thin_output_is_not_refused_for_rounding() {
+        let s = SmartObject {
+            uuid: "x".into(),
+            quad: [[0.0, 0.0], [16384.0, 0.0], [16384.0, 1.0], [0.0, 1.0]],
+            size: None,
+            warp: Some(Warp { style: "warpArc".into(), bounds: [0.0, 0.0, 16.0, 16.0], bend: 20.0, ..Default::default() }),
+        };
+        let content = Pixels { width: 16, height: 16, data: vec![[1.0, 0.0, 0.0, 1.0]; 256] };
+        assert!(s.render_placed(&content, 1.0, Some((16384, 1))).is_some());
+    }
 }
diff --git a/crates/psd/src/tests.rs b/crates/psd/src/tests.rs
index 60283b229..074976510 100644
--- a/crates/psd/src/tests.rs
+++ b/crates/psd/src/tests.rs
@@ -1,6 +1,9 @@
 use super::write::*;
 use super::*;
 
+mod integration;
+mod opt;
+
 fn gradient(w: u32, h: u32) -> Vec<[f32; 4]> {
     (0..w * h).map(|i| [(i % w) as f32 / (w - 1).max(1) as f32, (i / w) as f32 / (h - 1).max(1) as f32, 0.25, 1.0]).collect()
 }
diff --git a/crates/psd/src/tests_integration.rs b/crates/psd/src/tests/integration.rs
similarity index 98%
rename from crates/psd/src/tests_integration.rs
rename to crates/psd/src/tests/integration.rs
index a2b48b20c..ee40aee16 100644
--- a/crates/psd/src/tests_integration.rs
+++ b/crates/psd/src/tests/integration.rs
@@ -2,9 +2,9 @@
 //! the limit, a NaN text transform), a damaged layer section, and a tiny file claiming a huge
 //! image. Each ends in a clean result or a clean error, on a 2 MiB stack, never a panic.
 
-use super::memory_tests::with_merged;
-use super::write::*;
-use super::*;
+use crate::memory_tests::with_merged;
+use crate::write::*;
+use crate::*;
 
 /// Run `f` on a 2 MiB thread; a panic or stack overflow in it fails the test.
 fn on_small_stack<T: Send + 'static>(f: impl FnOnce() -> T + Send + 'static) -> T {
diff --git a/crates/psd/src/tests_opt.rs b/crates/psd/src/tests/opt.rs
similarity index 99%
rename from crates/psd/src/tests_opt.rs
rename to crates/psd/src/tests/opt.rs
index f129480c1..908026d07 100644
--- a/crates/psd/src/tests_opt.rs
+++ b/crates/psd/src/tests/opt.rs
@@ -1,10 +1,12 @@
 //! The optimised decode / mask / placed-bake paths against the implementations they replaced
 //! (kept below verbatim as references), and counters for the work they no longer do.
 
-use super::counters::{self, INSIDE, QUAD, SCRATCH};
-use super::placed::{Warp, square_to_quad};
-use super::write::*;
-use super::*;
+use std::borrow::Cow;
+
+use crate::counters::{self, INSIDE, QUAD, SCRATCH};
+use crate::placed::{Warp, square_to_quad};
+use crate::write::*;
+use crate::*;
 
 // ------------------------------------------------------------------ the replaced code
 
diff --git a/crates/raster/src/blur.rs b/crates/raster/src/blur.rs
index 46b749a9a..c8689a7b6 100644
--- a/crates/raster/src/blur.rs
+++ b/crates/raster/src/blur.rs
@@ -247,7 +247,9 @@ pub fn radial_blur(img: &Image, center: (f64, f64), amount: f64, zoom: bool) ->
                     let (s, c) = (t * amount).to_radians().sin_cos();
                     (center.0 + vx * c - vy * s, center.1 + vx * s + vy * c)
                 };
-                let p = img.sample_bilinear(sx, sy);
+                // Samples outside the image repeat its edge: After Effects' Radial Blur keeps a
+                // layer's edges (cases 713, 829) instead of fading them toward transparency.
+                let p = img.sample_bilinear(sx.clamp(0.5, (img.width as f64 - 0.5).max(0.5)), sy.clamp(0.5, (img.height as f64 - 0.5).max(0.5)));
                 for ch in 0..4 {
                     acc[ch] += p[ch];
                 }
diff --git a/crates/raster/src/inpaint.rs b/crates/raster/src/inpaint.rs
index 15bdaa0dd..c64de3375 100644
--- a/crates/raster/src/inpaint.rs
+++ b/crates/raster/src/inpaint.rs
@@ -607,38 +607,44 @@ pub struct FillInput {
     pub references: Vec<(usize, Image)>,
 }
 
-/// Trace pixel (x, y) of frame `t` through `flows` (`step` = +1 forward with `fwd`, −1 backward
-/// with `bwd`) to the nearest frame where it is visible: (sampled colour, frames travelled).
-fn trace(
-    t: usize,
+/// Shared frame and flow data for tracing pixels through a sequence.
+struct TraceContext<'a> {
+    fwd: &'a [Flow],
+    bwd: &'a [Flow],
+    known: &'a (dyn Fn(usize, i64, i64) -> bool + Sync),
+    frames: &'a [&'a Image],
+    max: usize,
+}
+
+/// Starting frame, point, and direction for a flow trace.
+struct TraceStart {
+    frame: usize,
     x: f64,
     y: f64,
     step: i64,
-    fwd: &[Flow],
-    bwd: &[Flow],
-    known: &dyn Fn(usize, i64, i64) -> bool,
-    frames: &[&Image],
-    max: usize,
-) -> Option<([f32; 4], usize)> {
-    let n = frames.len();
-    let (w, h) = (frames[0].width as f64, frames[0].height as f64);
-    let (mut px, mut py) = (x, y);
-    let mut k = t as i64;
-    for d in 1..=max {
-        let v = if step > 0 {
+}
+
+/// Trace a point to the nearest visible frame: (sampled colour, frames travelled).
+fn trace(context: &TraceContext<'_>, start: TraceStart) -> Option<([f32; 4], usize)> {
+    let n = context.frames.len();
+    let (w, h) = (context.frames[0].width as f64, context.frames[0].height as f64);
+    let (mut px, mut py) = (start.x, start.y);
+    let mut k = start.frame as i64;
+    for d in 1..=context.max {
+        let v = if start.step > 0 {
             if k as usize + 1 >= n {
                 return None;
             }
-            fwd[k as usize].at(px, py)
+            context.fwd[k as usize].at(px, py)
         } else {
             if k == 0 {
                 return None;
             }
-            bwd[k as usize - 1].at(px, py)
+            context.bwd[k as usize - 1].at(px, py)
         };
         px += v[0] as f64;
         py += v[1] as f64;
-        k += step;
+        k += start.step;
         if px < 0.0 || py < 0.0 || px >= w || py >= h {
             return None;
         }
@@ -646,9 +652,9 @@ fn trace(
         let (x0, y0) = ((px - 0.5).floor() as i64, (py - 0.5).floor() as i64);
         let ok = [(x0, y0), (x0 + 1, y0), (x0, y0 + 1), (x0 + 1, y0 + 1)]
             .iter()
-            .all(|&(xx, yy)| known(k as usize, xx.clamp(0, w as i64 - 1), yy.clamp(0, h as i64 - 1)));
+            .all(|&(xx, yy)| (context.known)(k as usize, xx.clamp(0, w as i64 - 1), yy.clamp(0, h as i64 - 1)));
         if ok {
-            return Some((frames[k as usize].sample_bilinear_clamped(px, py), d));
+            return Some((context.frames[k as usize].sample_bilinear_clamped(px, py), d));
         }
     }
     None
@@ -697,6 +703,7 @@ pub fn fill_sequence(input: &FillInput, o: &FillOpts, progress: &mut dyn FnMut(u
     // 2. Propagation (and the lighting-correction border ring).
     let refs: Vec<&Image> = frames.iter().collect();
     let known = |k: usize, x: i64, y: i64| !holes[k][y as usize * w + x as usize];
+    let trace_context = TraceContext { fwd: &fwd, bwd: &bwd, known: &known, frames: &refs, max: n };
     let ring_r = 2usize;
     let propagated: Vec<(Image, Vec<bool>)> = (0..n)
         .into_par_iter()
@@ -708,8 +715,8 @@ pub fn fill_sequence(input: &FillInput, o: &FillOpts, progress: &mut dyn FnMut(u
             }
             let sample = |i: usize| -> Option<[f32; 4]> {
                 let (x, y) = ((i % w) as f64 + 0.5, (i / w) as f64 + 0.5);
-                let f = trace(t, x, y, 1, &fwd, &bwd, &known, &refs, n);
-                let b = trace(t, x, y, -1, &fwd, &bwd, &known, &refs, n);
+                let f = trace(&trace_context, TraceStart { frame: t, x, y, step: 1 });
+                let b = trace(&trace_context, TraceStart { frame: t, x, y, step: -1 });
                 match (f, b) {
                     (Some((a, da)), Some((c, dc))) => {
                         let (wa, wc) = (1.0 / da as f32, 1.0 / dc as f32);
diff --git a/crates/raster/src/lib.rs b/crates/raster/src/lib.rs
index dce8dda81..fd2fd183b 100644
--- a/crates/raster/src/lib.rs
+++ b/crates/raster/src/lib.rs
@@ -12,16 +12,44 @@ pub mod flow;
 pub mod inpaint;
 pub mod scopes;
 pub mod warp;
+pub mod yuv;
 
 use effectcraft_color::{BlendMode, blend_pixel};
 use rayon::prelude::*;
 
 pub use blur::{box_blur, directional_blur, gaussian_blur, gaussian_blur_exact, gaussian_is_exact, radial_blur};
 pub use channels3d::AuxChannels;
-pub use warp::{Sampling, WarpOpts, accumulate_warp, composite_warp, composite_warp_reference, resample};
+pub use warp::{Sampling, WarpOpts, accumulate_warp, composite_warp, composite_warp_changed, composite_warp_reference, resample};
 
 pub type Px = [f32; 4];
 
+/// Maximum padded side in pixels — mirrors the project crate's `limits::MAX_SIZE` (30 000;
+/// raster sits below it in the layering and may not depend on it, so the two must stay equal).
+/// A padded side beyond the largest supported comp side has no render use.
+pub const MAX_PADDED_SIDE: u32 = 30_000;
+
+/// Clamp (colour ≤ alpha ≤ 1, NaN → 0) and round half up to `levels` steps (`inv` = 1 / levels):
+/// one pixel of an 8/16 bpc buffer. Values are non-negative after the clamp, so the integer
+/// conversion rounds like `round()` and vectorises.
+#[allow(clippy::manual_clamp)] // max/min map NaN to 0; clamp would keep NaN
+#[inline(always)]
+pub fn quantize_px(p: &mut Px, levels: f32, inv: f32) {
+    let a = round_half_up(p[3].max(0.0).min(1.0) * levels) * inv;
+    let hi = [a, a, a, a];
+    for c in 0..3 {
+        p[c] = round_half_up(p[c].max(0.0).min(hi[c]) * levels) * inv;
+    }
+    p[3] = a;
+}
+
+/// `v` (0..=65 535) rounded half up. The same either way; the fastest on each target: x86-64's
+/// baseline converts to integers in one instruction but has no `floor` (SSE4.1), while in wasm
+/// `floor` is one instruction and converting back from `u32` several (about 1.5× faster there).
+#[inline(always)]
+fn round_half_up(v: f32) -> f32 {
+    if cfg!(target_arch = "wasm32") { (v + 0.5).floor() } else { (v + 0.5) as u32 as f32 }
+}
+
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct Image {
     pub width: u32,
@@ -138,13 +166,28 @@ impl Image {
         }
         o
     }
-    /// Copy with `pad` transparent pixels on every side.
+    /// The pad [`Image::padded`] applies for a requested `pad`: clamped so neither output side
+    /// exceeds [`MAX_PADDED_SIDE`]. At most `(MAX_PADDED_SIDE - side) / 2`, so
+    /// `side + 2 · pad ≤ MAX_PADDED_SIDE` and overflow is unreachable by construction (a side
+    /// already past the cap gets pad 0). Callers that track where the pixels went (a buffer
+    /// offset) must move by this, not by the requested pad.
+    pub fn effective_pad(&self, pad: u32) -> u32 {
+        pad.min(MAX_PADDED_SIDE.saturating_sub(self.width) / 2).min(MAX_PADDED_SIDE.saturating_sub(self.height) / 2)
+    }
+    /// Copy with [`Image::effective_pad`] transparent pixels on every side.
+    ///
+    /// The clamp keeps the output within the largest image the engine supports (a max-size comp
+    /// frame), so an unbounded pad cannot overflow or size a buffer past that. It is not a memory
+    /// budget: callers that pad by a derived, possibly large amount bound the area themselves
+    /// (`DOF_PAD_BUDGET` in render's `three_d/compose.rs`, `fits()` on the GPU path) or reject an
+    /// oversized pad first (`padded_size`); legitimate bounded pads are byte-identical.
     pub fn padded(&self, pad: u32) -> Image {
-        let mut out = Image::new(self.width + 2 * pad, self.height + 2 * pad);
+        let eff = self.effective_pad(pad);
+        let mut out = Image::new(self.width + 2 * eff, self.height + 2 * eff);
         let ow = out.width as usize;
         for y in 0..self.height as usize {
             let src = &self.data[y * self.width as usize..(y + 1) * self.width as usize];
-            let o = (y + pad as usize) * ow + pad as usize;
+            let o = (y + eff as usize) * ow + eff as usize;
             out.data[o..o + self.width as usize].copy_from_slice(src);
         }
         out
@@ -199,26 +242,54 @@ impl Image {
     }
     /// Straight-alpha 8-bit RGBA (sRGB-encoded values as stored).
     pub fn to_rgba8(&self) -> Vec<u8> {
-        let mut out = vec![0u8; self.data.len() * 4];
-        out.par_chunks_mut(4).zip(self.data.par_iter()).for_each(|(o, p)| {
+        self.map_rgba8(|o, p, _, _| {
             let a = p[3].clamp(0.0, 1.0);
             let inv = if a > 0.0 { 1.0 / p[3] } else { 0.0 };
             for c in 0..3 {
                 o[c] = ((p[c] * inv).clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
             }
             o[3] = (a * 255.0 + 0.5) as u8;
-        });
-        out
+        })
+    }
+    /// [`Image::to_rgba8`] with the colour dithered ([`dither_u8`]); alpha is rounded.
+    pub fn to_rgba8_dithered(&self) -> Vec<u8> {
+        self.map_rgba8(|o, p, x, y| {
+            let a = p[3].clamp(0.0, 1.0);
+            let inv = if a > 0.0 { 1.0 / p[3] } else { 0.0 };
+            for c in 0..3 {
+                o[c] = dither_u8(p[c] * inv, x, y);
+            }
+            o[3] = (a * 255.0 + 0.5) as u8;
+        })
     }
     /// Composite over an opaque background colour and return opaque 8-bit RGBA.
     pub fn to_rgba8_over(&self, bg: [f32; 3]) -> Vec<u8> {
-        let mut out = vec![0u8; self.data.len() * 4];
-        out.par_chunks_mut(4).zip(self.data.par_iter()).for_each(|(o, p)| {
+        self.map_rgba8(|o, p, _, _| {
             let k = 1.0 - p[3].clamp(0.0, 1.0);
             for c in 0..3 {
                 o[c] = ((p[c] + bg[c] * k).clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
             }
             o[3] = 255;
+        })
+    }
+    /// [`Image::to_rgba8_over`] with the colour dithered ([`dither_u8`]).
+    pub fn to_rgba8_over_dithered(&self, bg: [f32; 3]) -> Vec<u8> {
+        self.map_rgba8(|o, p, x, y| {
+            let k = 1.0 - p[3].clamp(0.0, 1.0);
+            for c in 0..3 {
+                o[c] = dither_u8(p[c] + bg[c] * k, x, y);
+            }
+            o[3] = 255;
+        })
+    }
+    /// 8-bit RGBA with each pixel written by `f` (given its x and y), row-parallel.
+    fn map_rgba8(&self, f: impl Fn(&mut [u8; 4], &Px, u32, u32) + Sync) -> Vec<u8> {
+        let mut out = vec![0u8; self.data.len() * 4];
+        let w = self.width.max(1) as usize;
+        out.par_chunks_mut(w * 4).zip(self.data.par_chunks(w)).enumerate().for_each(|(y, (o, row))| {
+            for (x, (o, p)) in o.as_chunks_mut::<4>().0.iter_mut().zip(row).enumerate() {
+                f(o, p, x as u32, y as u32);
+            }
         });
         out
     }
@@ -292,6 +363,22 @@ pub fn hash_noise(x: u32, y: u32, seed: u32) -> f32 {
     (h & 0x00ff_ffff) as f32 / 16_777_216.0
 }
 
+/// Seed of the output dither: fixed, so a frame converts to the same bytes every time.
+const DITHER_SEED: u32 = 0x5bd1_e995;
+
+/// A colour value in 0..1 as an 8-bit code, dithered by pixel position (#2022): the value is
+/// scaled to 0..255 and rounded up or down against a per-pixel hash threshold, so the codes of
+/// a smooth gradient average to the gradient instead of stepping in bands. A value already on
+/// an 8-bit code (anything rendered at 8 bpc) comes out unchanged. Deterministic: depends only
+/// on the value and the pixel position, never on a clock or a global generator.
+#[inline]
+pub fn dither_u8(v: f32, x: u32, y: u32) -> u8 {
+    let s = v.clamp(0.0, 1.0) * 255.0;
+    // The threshold stays inside (1e-4, 1 - 1e-4) so float error on an exact code can't flip it.
+    let t = hash_noise(x, y, DITHER_SEED) * (1.0 - 2e-4) + 1e-4;
+    (s + t).floor() as u8
+}
+
 /// A single-channel coverage mask.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct Mask {
@@ -316,6 +403,35 @@ impl Mask {
 mod tests {
     use super::*;
 
+    #[test]
+    fn dither_keeps_exact_codes_and_averages_the_rest() {
+        // A value on an 8-bit code is that code at every position.
+        for code in 0..=255u32 {
+            let v = code as f32 / 255.0;
+            for (x, y) in [(0, 0), (1, 0), (17, 3), (1919, 1079), (4095, 4095)] {
+                assert_eq!(dither_u8(v, x, y) as u32, code, "code {code} at ({x}, {y})");
+            }
+        }
+        // Out-of-range and NaN values saturate instead of wrapping.
+        assert_eq!((dither_u8(-3.0, 5, 5), dither_u8(7.0, 5, 5), dither_u8(f32::NAN, 5, 5)), (0, 255, 0));
+        // A value between two codes lands on both, in proportion: the mean over a block is the value.
+        let v = (100.0 + 0.3) / 255.0;
+        let n = 64u32;
+        let sum: u32 = (0..n * n).map(|i| dither_u8(v, i % n, i / n) as u32).sum();
+        let mean = sum as f32 / (n * n) as f32;
+        assert!((mean - 100.3).abs() < 0.03, "{mean}");
+        // Deterministic.
+        assert_eq!(dither_u8(v, 9, 4), dither_u8(v, 9, 4));
+    }
+
+    #[test]
+    fn dithered_conversions_match_the_plain_ones_on_exact_codes() {
+        let src: Vec<u8> = vec![255, 128, 0, 255, 10, 20, 30, 255, 0, 0, 0, 255, 1, 2, 3, 255];
+        let img = Image::from_rgba8(2, 2, &src);
+        assert_eq!(img.to_rgba8_dithered(), img.to_rgba8());
+        assert_eq!(img.to_rgba8_over_dithered([0.0; 3]), img.to_rgba8_over([0.0; 3]));
+    }
+
     #[test]
     fn rgba8_roundtrip() {
         let src: Vec<u8> = vec![255, 128, 0, 255, 10, 20, 30, 128, 0, 0, 0, 0, 1, 2, 3, 4];
@@ -354,4 +470,29 @@ mod tests {
             assert!((0.0..1.0).contains(&n));
         }
     }
+
+    #[test]
+    fn padded_bounds_hostile_pad_at_the_api() {
+        // Fail-before (#2092 class): before the clamp, a caller passing a hostile pad sized an
+        // oversized buffer here — the very OOM this guard exists to stop, now caught in padded().
+        // (Wide-flat source so the clamped-to-cap output stays a test-sized allocation.)
+        let mut img = Image::new(29_990, 2);
+        img.set(29_989, 1, [1.0, 0.0, 0.0, 1.0]);
+        let out = img.padded(u32::MAX);
+        // Width binds first: eff = (MAX_PADDED_SIDE - 29 990) / 2 = 5.
+        assert_eq!((out.width, out.height), (MAX_PADDED_SIDE, 12));
+        // The source lands intact at the clamped offset, not the requested one.
+        assert_eq!(out.get(29_994, 6), [1.0, 0.0, 0.0, 1.0]);
+        assert_eq!(out.get(0, 0), [0.0; 4]); // clamped pad region stays transparent
+    }
+
+    #[test]
+    fn padded_leaves_legit_pads_untouched() {
+        // Anti-over-clamp: an ordinary pad must round exactly, byte for byte.
+        let mut img = Image::new(8, 6);
+        img.set(3, 2, [1.0, 0.0, 0.0, 1.0]);
+        let out = img.padded(4);
+        assert_eq!((out.width, out.height), (16, 14));
+        assert_eq!(out.get(7, 6), [1.0, 0.0, 0.0, 1.0]); // (3+4, 2+4)
+    }
 }
diff --git a/crates/raster/src/warp.rs b/crates/raster/src/warp.rs
index 8b45761e4..9f6de31ce 100644
--- a/crates/raster/src/warp.rs
+++ b/crates/raster/src/warp.rs
@@ -57,7 +57,15 @@ fn half(src: &Image) -> Image {
 /// bilinear without bounds checks, integer-translation copies, inlined Normal blending); it
 /// matches [`composite_warp_reference`] to float rounding.
 pub fn composite_warp(dst: &mut Image, src: &Image, m: &Mat3, opts: &WarpOpts) {
-    composite_warp_impl(dst, src, m, opts, true, None);
+    composite_warp_impl(dst, src, m, opts, true, None, None);
+}
+
+/// [`composite_warp`], also returning the destination pixels it changed when it knows them:
+/// `Some([x0, y0, x1, y1])` (half-open, empty when nothing was drawn) on the fast affine path,
+/// `None` otherwise. With `quantize` (an 8/16 bpc destination's levels), the fast path also
+/// quantises each pixel it blends ([`crate::quantize_px`]): exactly when this returns `Some`.
+pub fn composite_warp_changed(dst: &mut Image, src: &Image, m: &Mat3, opts: &WarpOpts, quantize: Option<f32>) -> Option<[u32; 4]> {
+    composite_warp_impl(dst, src, m, opts, true, None, quantize)
 }
 
 /// `dst += warp(src) · weight` (plain sum, no blending): motion-blur sub-samples accumulate
@@ -65,7 +73,7 @@ pub fn composite_warp(dst: &mut Image, src: &Image, m: &Mat3, opts: &WarpOpts) {
 pub fn accumulate_warp(dst: &mut Image, src: &Image, m: &Mat3, sampling: Sampling, weight: f32) {
     let opts = WarpOpts { sampling, ..Default::default() };
     if m.is_affine() && m.inverse().is_some_and(|i| i.is_affine()) {
-        composite_warp_impl(dst, src, m, &opts, true, Some(weight));
+        composite_warp_impl(dst, src, m, &opts, true, Some(weight), None);
         return;
     }
     let mut tmp = Image::new(dst.width, dst.height);
@@ -79,7 +87,7 @@ pub fn accumulate_warp(dst: &mut Image, src: &Image, m: &Mat3, sampling: Samplin
 
 /// The straightforward per-pixel implementation (reference for the fast path's tests).
 pub fn composite_warp_reference(dst: &mut Image, src: &Image, m: &Mat3, opts: &WarpOpts) {
-    composite_warp_impl(dst, src, m, opts, false, None);
+    composite_warp_impl(dst, src, m, opts, false, None, None);
 }
 
 /// Bilinear blend of four taps (same operation order as [`Image::sample_bilinear`]).
@@ -94,9 +102,49 @@ fn bilerp(a: Px, b: Px, c: Px, d: Px, tx: f32, ty: f32) -> Px {
     o
 }
 
-/// Bilinear sample with an unchecked interior fast path.
+/// Side of the square source tiles of [`ClearTiles`].
+const TILE: usize = 16;
+
+/// Which `TILE`×`TILE` source tiles are fully transparent, the one-pixel apron to their right
+/// and below included: the four taps of a bilinear sample whose top-left tap lies in such a
+/// tile all have zero alpha, so the sample is transparent and draws nothing.
+struct ClearTiles {
+    cols: usize,
+    clear: Vec<bool>,
+}
+
+impl ClearTiles {
+    fn new(img: &Image) -> ClearTiles {
+        let (w, h) = (img.width as usize, img.height as usize);
+        let (cols, rows) = (w.div_ceil(TILE), h.div_ceil(TILE));
+        let clear = (0..rows)
+            .into_par_iter()
+            .flat_map_iter(|ty| {
+                let mut row_clear = vec![true; cols];
+                for y in ty * TILE..(ty * TILE + TILE + 1).min(h) {
+                    let row = &img.data[y * w..(y + 1) * w];
+                    for (tx, c) in row_clear.iter_mut().enumerate() {
+                        if *c {
+                            *c = row[tx * TILE..(tx * TILE + TILE + 1).min(w)].iter().all(|p| p[3] == 0.0);
+                        }
+                    }
+                }
+                row_clear
+            })
+            .collect();
+        ClearTiles { cols, clear }
+    }
+
+    #[inline(always)]
+    fn is_clear(&self, x: usize, y: usize) -> bool {
+        self.clear.get((y / TILE) * self.cols + x / TILE).copied().unwrap_or(false)
+    }
+}
+
+/// Bilinear sample with an unchecked interior fast path; `None` when every interior tap is in a
+/// [`ClearTiles`] tile (the sample would have zero alpha).
 #[inline(always)]
-fn sample_bilinear_fast(img: &Image, x: f64, y: f64) -> Px {
+fn sample_bilinear_fast(img: &Image, clear: &ClearTiles, x: f64, y: f64) -> Option<Px> {
     let fx = x - 0.5;
     let fy = y - 0.5;
     let x0 = fx.floor();
@@ -104,14 +152,17 @@ fn sample_bilinear_fast(img: &Image, x: f64, y: f64) -> Px {
     let (xi, yi) = (x0 as i64, y0 as i64);
     let (w, h) = (img.width as i64, img.height as i64);
     if xi >= 0 && yi >= 0 && xi + 1 < w && yi + 1 < h {
+        if clear.is_clear(xi as usize, yi as usize) {
+            return None;
+        }
         let tx = (fx - x0) as f32;
         let ty = (fy - y0) as f32;
         let i = yi as usize * w as usize + xi as usize;
         let row0 = &img.data[i..i + 2];
         let row1 = &img.data[i + w as usize..i + w as usize + 2];
-        return bilerp(row0[0], row0[1], row1[0], row1[1], tx, ty);
+        return Some(bilerp(row0[0], row0[1], row1[0], row1[1], tx, ty));
     }
-    img.sample_bilinear(x, y)
+    Some(img.sample_bilinear(x, y))
 }
 
 /// Index range `[lo, hi)` of `i` in `0..n` for which `p0 + i·s` may lie in `[min, max]`
@@ -127,20 +178,43 @@ fn span(p0: f64, s: f64, min: f64, max: f64, n: usize) -> (usize, usize) {
     if hi <= lo { (0, 0) } else { (lo as usize, hi as usize) }
 }
 
-/// Fast affine rows: `blend(dst, src, x, y)` is only called for visible source pixels.
-#[allow(clippy::too_many_arguments)]
-fn affine_rows(
-    dst: &mut Image,
-    img: &Image,
-    inv: &Mat3,
+/// Columns `[a, b)` of one destination row that a warp changed (`a == b`: none).
+#[derive(Clone, Copy)]
+struct RowSpan {
+    a: usize,
+    b: usize,
+}
+
+impl RowSpan {
+    const NONE: RowSpan = RowSpan { a: usize::MAX, b: 0 };
+    #[inline(always)]
+    fn add(&mut self, x: usize) {
+        self.a = self.a.min(x);
+        self.b = x + 1;
+    }
+}
+
+/// Union of changed pixels as `[x0, y0, x1, y1]` (half-open; `x0 >= x1` when empty).
+fn union(r: [usize; 4], q: [usize; 4]) -> [usize; 4] {
+    match (r[0] < r[2], q[0] < q[2]) {
+        (false, _) => q,
+        (_, false) => r,
+        _ => [r[0].min(q[0]), r[1].min(q[1]), r[2].max(q[2]), r[3].max(q[3])],
+    }
+}
+
+/// Sampling, blending and destination bounds for an affine row operation.
+struct AffineRows {
     sampling: Sampling,
-    op: f32,
-    x0: usize,
-    x1: usize,
-    y0: usize,
-    y1: usize,
-    blend: impl Fn(Px, Px, u32, u32) -> Px + Sync,
-) {
+    opacity: f32,
+    quantize: Option<f32>,
+    bounds: [usize; 4],
+}
+
+/// Blend visible source samples and return the rectangle of changed pixels.
+fn affine_rows(dst: &mut Image, img: &Image, inv: &Mat3, rows: AffineRows, blend: impl Fn(Px, Px, u32, u32) -> Px + Sync) -> [usize; 4] {
+    let AffineRows { sampling, opacity: op, quantize, bounds: [x0, x1, y0, y1] } = rows;
+    let levels = quantize.map(|l| (l, 1.0 / l));
     let w = dst.width as usize;
     let m = inv.0;
     let (iw, ih) = (img.width as f64, img.height as f64);
@@ -148,71 +222,104 @@ fn affine_rows(
     // Pure integer translation: every sample lands on a pixel centre, so all filters return the
     // source pixel itself (bicubic still clamps negatives, as in the reference).
     let int_tx = m[0][0] == 1.0 && m[1][1] == 1.0 && m[0][1] == 0.0 && m[1][0] == 0.0 && m[0][2].fract() == 0.0 && m[1][2].fract() == 0.0;
-    dst.data.par_chunks_mut(w).enumerate().skip(y0).take(y1 - y0).for_each(|(y, row)| {
-        let fy = y as f64 + 0.5;
-        let p0 = vec2(m[0][0] * (x0 as f64 + 0.5) + m[0][1] * fy + m[0][2], m[1][0] * (x0 as f64 + 0.5) + m[1][1] * fy + m[1][2]);
-        let n = x1 - x0;
-        let (ax, bx) = span(p0.x, step.x, -1.0, iw + 1.0, n);
-        let (ay, by) = span(p0.y, step.y, -1.0, ih + 1.0, n);
-        let (lo, hi) = (ax.max(ay), bx.min(by));
-        if lo >= hi {
-            return;
-        }
-        if int_tx {
-            let sy = y as i64 + m[1][2] as i64;
-            if sy < 0 || sy >= img.height as i64 {
-                return;
+    // Bilinear samples skip the transparent parts of the source (most of a thin shape's or a
+    // glow-padded layer's buffer) without reading them.
+    let clear = (sampling == Sampling::Bilinear && !int_tx).then(|| ClearTiles::new(img));
+    let empty = [usize::MAX, usize::MAX, 0, 0];
+    dst.data
+        .par_chunks_mut(w)
+        .enumerate()
+        .skip(y0)
+        .take(y1 - y0)
+        .map(|(y, row)| {
+            let mut changed = RowSpan::NONE;
+            let fy = y as f64 + 0.5;
+            let p0 = vec2(m[0][0] * (x0 as f64 + 0.5) + m[0][1] * fy + m[0][2], m[1][0] * (x0 as f64 + 0.5) + m[1][1] * fy + m[1][2]);
+            let n = x1 - x0;
+            let (ax, bx) = span(p0.x, step.x, -1.0, iw + 1.0, n);
+            let (ay, by) = span(p0.y, step.y, -1.0, ih + 1.0, n);
+            let (lo, hi) = (ax.max(ay), bx.min(by));
+            if lo >= hi {
+                return empty;
             }
-            let dx = m[0][2] as i64;
-            let srow = &img.data[sy as usize * img.width as usize..(sy as usize + 1) * img.width as usize];
-            let xa = (x0 as i64 + lo as i64).max(-dx).max(0) as usize;
-            let xb = ((x0 + hi) as i64).min(img.width as i64 - dx).max(0) as usize;
-            for x in xa..xb.max(xa) {
-                let mut s = srow[(x as i64 + dx) as usize];
-                if sampling == Sampling::Bicubic {
-                    s = [s[0].max(0.0), s[1].max(0.0), s[2].max(0.0), s[3].max(0.0)];
+            if int_tx {
+                let sy = y as i64 + m[1][2] as i64;
+                if sy < 0 || sy >= img.height as i64 {
+                    return empty;
                 }
-                if s[3] <= 0.0 {
-                    continue;
-                }
-                if op < 1.0 {
-                    for c in s.iter_mut() {
-                        *c *= op;
+                let dx = m[0][2] as i64;
+                let srow = &img.data[sy as usize * img.width as usize..(sy as usize + 1) * img.width as usize];
+                let xa = (x0 as i64 + lo as i64).max(-dx).max(0) as usize;
+                let xb = ((x0 + hi) as i64).min(img.width as i64 - dx).max(0) as usize;
+                for x in xa..xb.max(xa) {
+                    let mut s = srow[(x as i64 + dx) as usize];
+                    if sampling == Sampling::Bicubic {
+                        s = [s[0].max(0.0), s[1].max(0.0), s[2].max(0.0), s[3].max(0.0)];
                     }
+                    if s[3] <= 0.0 {
+                        continue;
+                    }
+                    if op < 1.0 {
+                        for c in s.iter_mut() {
+                            *c *= op;
+                        }
+                    }
+                    row[x] = blend(row[x], s, x as u32, y as u32);
+                    if let Some((l, inv)) = levels {
+                        crate::quantize_px(&mut row[x], l, inv);
+                    }
+                    changed.add(x);
                 }
-                row[x] = blend(row[x], s, x as u32, y as u32);
-            }
-            return;
-        }
-        for i in lo..hi {
-            let x = x0 + i;
-            let p = vec2(p0.x + step.x * i as f64, p0.y + step.y * i as f64);
-            if p.x < -1.0 || p.y < -1.0 || p.x > iw + 1.0 || p.y > ih + 1.0 {
-                continue;
-            }
-            let mut s = match sampling {
-                Sampling::Nearest => img.get(p.x.floor() as i64, p.y.floor() as i64),
-                Sampling::Bilinear => sample_bilinear_fast(img, p.x, p.y),
-                Sampling::Bicubic => img.sample_bicubic(p.x, p.y),
-            };
-            if s[3] <= 0.0 {
-                continue;
-            }
-            if op < 1.0 {
-                for c in s.iter_mut() {
-                    *c *= op;
+            } else {
+                for i in lo..hi {
+                    let x = x0 + i;
+                    let p = vec2(p0.x + step.x * i as f64, p0.y + step.y * i as f64);
+                    if p.x < -1.0 || p.y < -1.0 || p.x > iw + 1.0 || p.y > ih + 1.0 {
+                        continue;
+                    }
+                    let mut s = match (sampling, &clear) {
+                        (Sampling::Nearest, _) => img.get(p.x.floor() as i64, p.y.floor() as i64),
+                        (Sampling::Bilinear, Some(clear)) => match sample_bilinear_fast(img, clear, p.x, p.y) {
+                            Some(s) => s,
+                            None => continue,
+                        },
+                        (Sampling::Bilinear, None) => img.sample_bilinear(p.x, p.y),
+                        (Sampling::Bicubic, _) => img.sample_bicubic(p.x, p.y),
+                    };
+                    if s[3] <= 0.0 {
+                        continue;
+                    }
+                    if op < 1.0 {
+                        for c in s.iter_mut() {
+                            *c *= op;
+                        }
+                    }
+                    row[x] = blend(row[x], s, x as u32, y as u32);
+                    if let Some((l, inv)) = levels {
+                        crate::quantize_px(&mut row[x], l, inv);
+                    }
+                    changed.add(x);
                 }
             }
-            row[x] = blend(row[x], s, x as u32, y as u32);
-        }
-    });
+            if changed.a < changed.b { [changed.a, y, changed.b, y + 1] } else { empty }
+        })
+        .reduce(|| empty, union)
 }
 
-fn composite_warp_impl(dst: &mut Image, src: &Image, m: &Mat3, opts: &WarpOpts, allow_fast: bool, accumulate: Option<f32>) {
+fn composite_warp_impl(
+    dst: &mut Image,
+    src: &Image,
+    m: &Mat3,
+    opts: &WarpOpts,
+    allow_fast: bool,
+    accumulate: Option<f32>,
+    quantize: Option<f32>,
+) -> Option<[u32; 4]> {
+    const NOTHING: Option<[u32; 4]> = Some([0; 4]);
     if src.is_empty() || dst.is_empty() || opts.opacity <= 0.0 {
-        return;
+        return NOTHING;
     }
-    let Some(inv) = m.inverse() else { return };
+    let Some(inv) = m.inverse() else { return NOTHING };
     // Minification: pick a pre-filtered level so sampling doesn't alias.
     let scale = m.mean_scale();
     let mut level_img;
@@ -239,7 +346,7 @@ fn composite_warp_impl(dst: &mut Image, src: &Image, m: &Mat3, opts: &WarpOpts,
         area = area.intersect(&c);
     }
     if area.is_empty() {
-        return;
+        return NOTHING;
     }
     let (x0, x1) = (area.x0.max(0.0) as usize, area.x1.min(dst.width as f64) as usize);
     let (y0, y1) = (area.y0.max(0.0) as usize, area.y1.min(dst.height as f64) as usize);
@@ -247,25 +354,34 @@ fn composite_warp_impl(dst: &mut Image, src: &Image, m: &Mat3, opts: &WarpOpts,
     let affine = inv.is_affine();
     let mode = opts.mode;
     let op = opts.opacity;
+    let changed = |r: [usize; 4]| Some(r.map(|v| v.min(u32::MAX as usize) as u32));
     if let Some(k) = accumulate
         && affine
     {
-        affine_rows(dst, img, &inv, opts.sampling, 1.0, x0, x1, y0, y1, |d, s, _, _| [d[0] + s[0] * k, d[1] + s[1] * k, d[2] + s[2] * k, d[3] + s[3] * k]);
-        return;
+        let r = affine_rows(dst, img, &inv, AffineRows { sampling: opts.sampling, opacity: 1.0, quantize: None, bounds: [x0, x1, y0, y1] }, |d, s, _, _| {
+            [d[0] + s[0] * k, d[1] + s[1] * k, d[2] + s[2] * k, d[3] + s[3] * k]
+        });
+        return changed(r);
     }
     if allow_fast && affine && !mode.is_stencil() {
-        match mode {
-            BlendMode::Normal => affine_rows(dst, img, &inv, opts.sampling, op, x0, x1, y0, y1, |d, s, _, _| {
-                let k = 1.0 - s[3];
-                [s[0] + d[0] * k, s[1] + d[1] * k, s[2] + d[2] * k, s[3] + d[3] * k]
-            }),
+        let r = match mode {
+            BlendMode::Normal => {
+                affine_rows(dst, img, &inv, AffineRows { sampling: opts.sampling, opacity: op, quantize, bounds: [x0, x1, y0, y1] }, |d, s, _, _| {
+                    let k = 1.0 - s[3];
+                    [s[0] + d[0] * k, s[1] + d[1] * k, s[2] + d[2] * k, s[3] + d[3] * k]
+                })
+            }
             BlendMode::Dissolve | BlendMode::DancingDissolve => {
                 let seed = opts.seed;
-                affine_rows(dst, img, &inv, opts.sampling, op, x0, x1, y0, y1, |d, s, x, y| blend_pixel(mode, d, s, hash_noise(x, y, seed)))
+                affine_rows(dst, img, &inv, AffineRows { sampling: opts.sampling, opacity: op, quantize, bounds: [x0, x1, y0, y1] }, |d, s, x, y| {
+                    blend_pixel(mode, d, s, hash_noise(x, y, seed))
+                })
             }
-            _ => affine_rows(dst, img, &inv, opts.sampling, op, x0, x1, y0, y1, |d, s, _, _| blend_pixel(mode, d, s, 0.5)),
-        }
-        return;
+            _ => affine_rows(dst, img, &inv, AffineRows { sampling: opts.sampling, opacity: op, quantize, bounds: [x0, x1, y0, y1] }, |d, s, _, _| {
+                blend_pixel(mode, d, s, 0.5)
+            }),
+        };
+        return changed(r);
     }
     dst.data.par_chunks_mut(w).enumerate().skip(y0).take(y1 - y0).for_each(|(y, row)| {
         let fy = y as f64 + 0.5;
@@ -312,6 +428,7 @@ fn composite_warp_impl(dst: &mut Image, src: &Image, m: &Mat3, opts: &WarpOpts,
             }
         }
     }
+    None
 }
 
 /// Resize with bilinear filtering (box pre-filter when shrinking).
@@ -394,6 +511,116 @@ mod tests {
         }
     }
 
+    /// A mostly transparent source: a thin ring with a few stray pixels (one with negative zero alpha).
+    fn sparse_image(w: u32, h: u32) -> Image {
+        let mut img = Image::new(w, h);
+        let (cx, cy, r) = (w as f32 / 2.0, h as f32 / 2.0, w.min(h) as f32 * 0.4);
+        for y in 0..h {
+            for x in 0..w {
+                let d = ((x as f32 + 0.5 - cx).hypot(y as f32 + 0.5 - cy) - r).abs();
+                if d < 1.5 {
+                    let a = 1.0 - d / 1.5;
+                    img.set(x, y, [0.2 * a, 0.6 * a, a, a]);
+                }
+            }
+        }
+        img.set(3, 2, [0.5, 0.5, 0.5, 0.5]);
+        img.set(w - 1, h - 1, [1.0; 4]);
+        img.set(w / 2, 1, [0.0, 0.0, 0.0, -0.0]);
+        img
+    }
+
+    #[test]
+    fn clear_tiles_hold_only_transparent_taps() {
+        let img = sparse_image(150, 97);
+        let clear = ClearTiles::new(&img);
+        let mut skipped = 0;
+        for y in 0..img.height as usize - 1 {
+            for x in 0..img.width as usize - 1 {
+                if clear.is_clear(x, y) {
+                    skipped += 1;
+                    for (dx, dy) in [(0, 0), (1, 0), (0, 1), (1, 1)] {
+                        assert_eq!(img.get(x as i64 + dx, y as i64 + dy)[3], 0.0, "tap ({}, {}) of a clear tile", x as i64 + dx, y as i64 + dy);
+                    }
+                }
+            }
+        }
+        assert!(skipped > 100 * 70, "the ring's empty middle is skipped: {skipped}");
+    }
+
+    /// The changed rectangle holds every pixel a warp changed, and the skipped transparent
+    /// samples leave the result as the reference path draws it.
+    #[test]
+    fn changed_rect_covers_the_changed_pixels() {
+        let src = sparse_image(90, 70);
+        let mats = [
+            Mat3::translate(vec2(7.0, 3.0)),
+            Mat3::translate(vec2(10.25, 4.5)),
+            Mat3::translate(vec2(60.0, 50.0)) * Mat3::rotate_deg(33.0) * Mat3::scale(vec2(0.9, 1.2)) * Mat3::translate(vec2(-45.0, -35.0)),
+            Mat3::translate(vec2(-30.0, -20.0)),
+            Mat3::scale(vec2(0.3, 0.3)),
+        ];
+        for (mi, m) in mats.iter().enumerate() {
+            for mode in [BlendMode::Normal, BlendMode::Add, BlendMode::Dissolve] {
+                let opts = WarpOpts { mode, seed: 3, ..Default::default() };
+                let before = test_image(120, 100, 4);
+                let mut a = before.clone();
+                let r = composite_warp_changed(&mut a, &src, m, &opts, None);
+                let Some([x0, y0, x1, y1]) = r else { panic!("mat {mi}: the fast path tracks what it changed") };
+                for (i, (p, q)) in a.data.iter().zip(&before.data).enumerate() {
+                    let (x, y) = (i as u32 % a.width, i as u32 / a.width);
+                    if p != q {
+                        assert!(x >= x0 && x < x1 && y >= y0 && y < y1, "mat {mi} {mode:?}: ({x}, {y}) changed outside {r:?}");
+                    }
+                }
+                let mut b = before.clone();
+                composite_warp_reference(&mut b, &src, m, &opts);
+                for (i, (p, q)) in a.data.iter().zip(&b.data).enumerate() {
+                    for c in 0..4 {
+                        assert!((p[c] - q[c]).abs() < 1e-4, "mat {mi} {mode:?} px {i}: {p:?} vs {q:?}");
+                    }
+                }
+            }
+        }
+        let mut dst = Image::new(10, 10);
+        assert_eq!(composite_warp_changed(&mut dst, &Image::new(4, 4), &Mat3::IDENTITY, &WarpOpts::default(), None), Some([u32::MAX, u32::MAX, 0, 0]));
+        let stencil = WarpOpts { mode: BlendMode::StencilAlpha, ..Default::default() };
+        assert_eq!(composite_warp_changed(&mut dst, &src, &Mat3::IDENTITY, &stencil, Some(255.0)), None, "stencils change the whole destination");
+    }
+
+    /// Quantising while blending equals blending, then quantising the changed rectangle of an
+    /// already quantised destination (what an 8/16 bpc comp did after every layer), bit for bit.
+    #[test]
+    fn quantize_while_blending_matches_quantizing_after() {
+        let src = sparse_image(90, 70);
+        let mats = [Mat3::translate(vec2(7.0, 3.0)), Mat3::translate(vec2(60.0, 50.0)) * Mat3::rotate_deg(33.0) * Mat3::translate(vec2(-45.0, -35.0))];
+        for m in &mats {
+            for mode in [BlendMode::Normal, BlendMode::Screen, BlendMode::Dissolve] {
+                for (levels, opacity) in [(255.0f32, 1.0), (32_768.0, 0.7)] {
+                    let mut before = test_image(120, 100, 8);
+                    for p in &mut before.data {
+                        crate::quantize_px(p, levels, 1.0 / levels);
+                    }
+                    let opts = WarpOpts { mode, opacity, seed: 5, ..Default::default() };
+                    let mut after = before.clone();
+                    let Some([x0, y0, x1, y1]) = composite_warp_changed(&mut after, &src, m, &opts, None) else { panic!("fast path") };
+                    for y in y0..y1 {
+                        for x in x0..x1 {
+                            let i = after.idx(x, y);
+                            crate::quantize_px(&mut after.data[i], levels, 1.0 / levels);
+                        }
+                    }
+                    let mut fused = before.clone();
+                    let r = composite_warp_changed(&mut fused, &src, m, &opts, Some(levels));
+                    assert_eq!(r, Some([x0, y0, x1, y1]));
+                    for (i, (p, q)) in fused.data.iter().zip(&after.data).enumerate() {
+                        assert_eq!(p.map(f32::to_bits), q.map(f32::to_bits), "{mode:?} {levels} px {i}");
+                    }
+                }
+            }
+        }
+    }
+
     /// Accumulating sub-samples equals warping each into its own image and summing.
     #[test]
     fn accumulate_matches_per_sample_images() {
diff --git a/crates/raster/src/yuv.rs b/crates/raster/src/yuv.rs
new file mode 100644
index 000000000..fdfbc0c0a
--- /dev/null
+++ b/crates/raster/src/yuv.rs
@@ -0,0 +1,60 @@
+//! 8-bit BT.709 limited-range 4:2:0, the H.264 export's input. Shared by the export and by the
+//! GPU compositor's tests, which hold its kernel to this function.
+
+use rayon::prelude::*;
+
+/// `v / 255` for every 8-bit `v` (the same values as dividing).
+pub const UNIT8: [f32; 256] = {
+    let mut t = [0.0; 256];
+    let mut i = 0;
+    while i < 256 {
+        t[i] = i as f32 / 255.0;
+        i += 1;
+    }
+    t
+};
+
+/// `v.round()` for `0 <= v < 2^23`, the range the colour conversions round in: truncation and
+/// the fraction are exact there, so this is `f32::round` without its libm call.
+#[inline(always)]
+pub fn round_pos(v: f32) -> f32 {
+    let t = v as u32 as f32;
+    if v - t >= 0.5 { t + 1.0 } else { t }
+}
+
+/// BT.709 limited-range 8-bit 4:2:0 from RGBA8 (2×2 chroma average; alpha ignored).
+pub fn rgba_to_yuv420(rgba: &[u8], w: usize, h: usize, y: &mut Vec<u8>, u: &mut Vec<u8>, v: &mut Vec<u8>) {
+    let (cw, ch) = (w.div_ceil(2), h.div_ceil(2));
+    y.resize(w * h, 0);
+    u.resize(cw * ch, 0);
+    v.resize(cw * ch, 0);
+    y.par_chunks_mut(w * 2).zip(u.par_chunks_mut(cw).zip(v.par_chunks_mut(cw))).enumerate().for_each(|(cy, (yr, (ur, vr)))| {
+        let mut acc = vec![(0f32, 0f32, 0f32); cw];
+        for (dy, yrow) in yr.chunks_exact_mut(w).enumerate() {
+            let src = &rgba[(cy * 2 + dy) * w * 4..][..w * 4];
+            for (x, (s, yo)) in src.as_chunks::<4>().0.iter().zip(yrow.iter_mut()).enumerate() {
+                let (r, g, b) = (UNIT8[s[0] as usize], UNIT8[s[1] as usize], UNIT8[s[2] as usize]);
+                let l = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+                *yo = round_pos(16.0 + 219.0 * l).clamp(1.0, 254.0) as u8;
+                let a = &mut acc[x / 2];
+                a.0 += (b - l) / 1.8556;
+                a.1 += (r - l) / 1.5748;
+                a.2 += 1.0;
+            }
+        }
+        for (cx, a) in acc.iter().enumerate() {
+            ur[cx] = round_pos(128.0 + 224.0 * a.0 / a.2).clamp(1.0, 254.0) as u8;
+            vr[cx] = round_pos(128.0 + 224.0 * a.1 / a.2).clamp(1.0, 254.0) as u8;
+        }
+    });
+}
+
+/// The H.264 export's planes of `img` over `bg` (opaque): Y, then U and V, as
+/// [`crate::Image::to_rgba8_over`] + [`rgba_to_yuv420`] produce them.
+pub fn yuv420_over(img: &crate::Image, bg: [f32; 3]) -> Vec<u8> {
+    let (mut y, mut u, mut v) = (vec![], vec![], vec![]);
+    rgba_to_yuv420(&img.to_rgba8_over(bg), img.width as usize, img.height as usize, &mut y, &mut u, &mut v);
+    y.extend_from_slice(&u);
+    y.extend_from_slice(&v);
+    y
+}
diff --git a/crates/render/Cargo.toml b/crates/render/Cargo.toml
index db2fa9dd0..efbd1fc19 100644
--- a/crates/render/Cargo.toml
+++ b/crates/render/Cargo.toml
@@ -19,7 +19,7 @@ effectcraft-raster = { workspace = true }
 effectcraft-path = { workspace = true }
 effectcraft-text = { workspace = true }
 effectcraft-effects = { workspace = true }
-lz4_flex = { version = "0.11", default-features = false, features = ["std", "safe-encode", "safe-decode", "checked-decode"] }
+lz4_flex = { version = "0.14", default-features = false, features = ["std", "safe-encode", "safe-decode", "checked-decode"] }
 effectcraft-model = { workspace = true }
 kurbo = { workspace = true }
 rayon = { workspace = true }
diff --git a/crates/render/src/accel.rs b/crates/render/src/accel.rs
new file mode 100644
index 000000000..e6bbd2113
--- /dev/null
+++ b/crates/render/src/accel.rs
@@ -0,0 +1,371 @@
+use super::frames::content_bounds;
+use super::fx_host::MAX_FX_DEPTH;
+use super::layers::StyledLayer;
+use super::opts::LayerTiming;
+use super::{
+    Arc, AutoPick, Buf, EffectCtx, EvalCtx, Image, ItemId, ItemKind, Layer, LayerSource, Mat3, MatteKind, Renderer, Tick, cache, color, masks, three_d, vec2,
+};
+
+/// Which compositor renders a frame (Project Settings ▸ Video Rendering and Effects).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum Backend {
+    /// The CPU reference compositor (Mercury Software Only).
+    #[default]
+    Cpu,
+    /// The GPU compositor whenever an [`Accelerator`] is attached, whatever the project says.
+    Gpu,
+    /// The GPU compositor when an [`Accelerator`] is attached and the project's renderer is
+    /// Mercury GPU Acceleration (the viewer's choice); the CPU otherwise.
+    Auto,
+}
+
+impl Backend {
+    pub fn parse(s: &str) -> Option<Backend> {
+        match s.to_ascii_lowercase().as_str() {
+            "cpu" | "software" | "mercury software only" => Some(Backend::Cpu),
+            "gpu" | "mercury gpu acceleration" => Some(Backend::Gpu),
+            "auto" => Some(Backend::Auto),
+            _ => None,
+        }
+    }
+}
+
+/// One effect of a GPU effect chain (see [`Accelerator::effects`]).
+pub struct FxStep<'x> {
+    pub spec: &'static effectcraft_effects::EffectSpec,
+    pub ctx: EffectCtx<'x>,
+}
+
+/// A GPU (or other hardware) backend for the compositor. The CPU [`Renderer`] stays the
+/// reference: an accelerator renders what it supports and returns `None` for the rest, which
+/// then runs on the CPU. Implemented by `effectcraft-gpu`.
+pub trait Accelerator: Send + Sync {
+    /// Adapter / backend name for status readouts ("Apple M2 (Metal)").
+    fn name(&self) -> String;
+    /// Render a top-level comp frame (what [`Renderer::comp_frame`] returns). `None` = not
+    /// handled (the CPU renders it).
+    fn comp_frame(&self, r: &Renderer, comp: ItemId, t: Tick) -> Option<Image>;
+    /// Render a top-level comp frame like [`Self::comp_frame`], composite it over `bg` and
+    /// convert it to the H.264 export's 8-bit BT.709 limited-range 4:2:0 (Y plane, then U and V
+    /// at half size; see `effectcraft_raster::yuv`). Every byte is within one level of the CPU
+    /// conversion of the same frame (a driver's arithmetic may move a value near a rounding
+    /// boundary). `None` = not handled (the caller renders and converts on the CPU).
+    fn comp_frame_yuv420(&self, _r: &Renderer, _comp: ItemId, _t: Tick, _bg: [f32; 3]) -> Option<Vec<u8>> {
+        None
+    }
+    /// The accelerator implements effect `id` with the CPU effect's semantics.
+    fn supports_effect(&self, id: &str) -> bool;
+    /// Run a chain of supported effects on `buf`, clamping and quantising to `levels` after
+    /// every effect when set (8/16 bpc). `None` = not handled.
+    fn effects(&self, chain: &[FxStep], buf: &Buf, levels: Option<f32>) -> Option<Buf>;
+    /// Rasterise and shade an Advanced 3D scene at its raster size (depth buffer, PBR, image
+    /// based light, shadow maps), with the CPU rasteriser's semantics
+    /// ([`three_d::adv::raster::render`]). `None` = not handled (the CPU renders it).
+    fn raster_3d(&self, _scene: &three_d::adv::Scene) -> Option<three_d::adv::Target> {
+        None
+    }
+    /// Render a whole prepared Advanced 3D run (every motion-blur sub-sample rasterised and
+    /// resolved, averaged, depth of field, encoding) with [`three_d::adv::render_prepared`]'s
+    /// semantics. `None` = not handled (the CPU path runs, using [`Self::raster_3d`]).
+    fn render_3d(&self, _run: &three_d::adv::Prepared) -> Option<three_d::adv::Rendered> {
+        None
+    }
+    /// A particle simulation backend (GPU particles) for the stepped particle effects, with
+    /// the CPU simulation's semantics. `None` = they simulate on the CPU.
+    fn particles(&self) -> Option<&dyn effectcraft_effects::psim::ParticleSim> {
+        None
+    }
+    /// Timing history [`Backend::Auto`] uses to send each comp's top-level frames to the
+    /// faster compositor. `None` = Auto always tries the accelerator first.
+    fn auto_pick(&self) -> Option<&AutoPick> {
+        None
+    }
+    /// Whether the accelerator can still render frames. `false` once it has stopped for good
+    /// (its device was lost or retired): every frame it is asked for falls back to the CPU, so
+    /// callers that limit frames in flight for it can stop doing so.
+    fn available(&self) -> bool {
+        true
+    }
+    /// Deferred readbacks: where a GPU readback cannot be waited for (WebGPU in a browser
+    /// worker), a frame renders in *passes*. A readback the accelerator does not have yet is
+    /// started, the step returns a cheap placeholder and the pass is marked missed
+    /// ([`Self::pass_missed`]); the caller waits for the readbacks in flight (asynchronously)
+    /// and renders the frame again, and the steps whose results arrived are served from them.
+    /// The frame is done after a pass with no miss. `frame_begin` forgets the previous frame's
+    /// results, `pass_begin` clears the miss. Synchronous accelerators never miss.
+    fn frame_begin(&self) {}
+    fn pass_begin(&self) {}
+    fn pass_missed(&self) -> bool {
+        false
+    }
+    /// Raised from a pass's first miss to its end (results computed meanwhile may hold
+    /// placeholders): give it to [`LayerCache::set_gate`] so they are not cached.
+    fn miss_gate(&self) -> Option<Arc<std::sync::atomic::AtomicBool>> {
+        None
+    }
+    /// With deferred readbacks: a future that resolves once the readbacks in flight have
+    /// landed (the browser delivers them from its event loop; natively the device is polled
+    /// before it returns, so the future is ready). `None` = nothing to wait for. See
+    /// [`passes::in_passes`].
+    fn settle(&self) -> Option<std::pin::Pin<Box<dyn std::future::Future<Output = ()> + '_>>> {
+        None
+    }
+}
+
+/// Where an effect stack runs (see [`Renderer::run_effects_on`]): a CPU buffer, or an image
+/// resident on an accelerator.
+pub trait FxTarget {
+    /// Run a chain of accelerator-supported effects (quantising after each to the bit depth).
+    /// `false` = not handled: the effects then run one by one through [`FxTarget::cpu`].
+    fn gpu(&mut self, steps: &[FxStep]) -> bool;
+    /// Run one CPU effect: `f` maps the buffer.
+    fn cpu(&mut self, f: &mut dyn FnMut(Buf) -> Buf);
+    /// Grow the buffer to cover its whole layer rectangle (`size` layer pixels from its own
+    /// corner, the `layer_size` handed to effects), as [`effectcraft_effects::Buf::cover`].
+    /// Authored buffers (text, shapes) only span their painted content; this gives the stack
+    /// the room a sized source's buffer already has (#659).
+    fn cover(&mut self, size: [f64; 2]) {
+        self.cpu(&mut |mut buf| {
+            buf.cover(size);
+            buf
+        });
+    }
+    /// Give the buffer the pixel-grid phase the layer rectangle's cover would
+    /// ([`effectcraft_effects::Buf::align`]): grows left/top by less than 64 pixels.
+    fn align(&mut self, size: [f64; 2]) {
+        self.cpu(&mut |mut buf| {
+            buf.align(size);
+            buf
+        });
+    }
+}
+
+/// The CPU effect target (GPU chains go through [`Accelerator::effects`]: upload, readback).
+pub(crate) struct CpuFx<'a> {
+    pub(crate) accel: Option<&'a dyn Accelerator>,
+    pub(crate) levels: Option<f32>,
+    pub(crate) buf: Option<Buf>,
+}
+
+impl FxTarget for CpuFx<'_> {
+    fn gpu(&mut self, steps: &[FxStep]) -> bool {
+        let (Some(a), Some(b)) = (self.accel, &self.buf) else { return false };
+        match a.effects(steps, b, self.levels) {
+            Some(out) => {
+                self.buf = Some(out);
+                true
+            }
+            None => false,
+        }
+    }
+    fn cpu(&mut self, f: &mut dyn FnMut(Buf) -> Buf) {
+        if let Some(b) = self.buf.take() {
+            self.buf = Some(f(b));
+        }
+    }
+}
+
+/// Hooks for accelerated compositors (`effectcraft-gpu`): the pieces of the CPU walk they reuse
+/// or fall back to. The CPU compositor itself is [`Renderer::comp_frame_cpu`].
+impl<'a> Renderer<'a> {
+    /// The project's colour pipeline.
+    pub fn pipe(&self) -> color::Pipe {
+        self.pipe
+    }
+
+    /// Nesting depth (0 = the top-level comp).
+    pub fn depth(&self) -> usize {
+        self.depth
+    }
+
+    /// The auxiliary 3D channels of comp `comp_id` at comp time `t` (depth, layer IDs, normals,
+    /// UVs, Cryptomatte; see `three_d::compose::aux_pass`), at the renderer's output scale.
+    pub fn comp_aux(&self, comp_id: ItemId, t: Tick) -> Option<effectcraft_raster::AuxChannels> {
+        let ctx = self.eval_ctx(comp_id, t)?;
+        Some(three_d::compose::aux_pass(self, &ctx))
+    }
+
+    /// The auxiliary channels effects on `layer` read ([`EffectHost::aux`]): its multi-layer
+    /// OpenEXR footage's at the layer's source time (Time Remap included), or a precomp's
+    /// generated 3D channels at its nested time. `None` for other layers.
+    pub fn layer_aux(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<effectcraft_raster::AuxChannels>> {
+        match &layer.source {
+            LayerSource::Footage { item } => {
+                let item = ctx.media_item(layer, *item);
+                let ItemKind::Footage(f) = &self.project.item(item)?.kind else { return None };
+                let a = self.footage.aux(item, f, ctx.source_time(layer))?;
+                // Aux pixels per layer pixel (the layer is the footage at its nominal size). The
+                // planes are only copied when that changes the scale.
+                let scale = a.width as f64 / f.width as f64;
+                if f.width > 0 && a.width > 0 && a.scale != scale {
+                    let mut a = (*a).clone();
+                    a.scale = scale;
+                    return Some(Arc::new(a));
+                }
+                Some(a)
+            }
+            LayerSource::Comp { item } => {
+                if self.depth > MAX_FX_DEPTH || self.project.comp_contains(*item, ctx.comp_id) {
+                    return None;
+                }
+                self.nested().comp_aux(*item, ctx.nested_time(layer)).map(Arc::new)
+            }
+            _ => None,
+        }
+    }
+
+    /// Evaluation context of comp `comp_id` at comp time `t`.
+    pub fn eval_ctx(&self, comp_id: ItemId, t: Tick) -> Option<EvalCtx<'a>> {
+        Some(self.ctx(comp_id, self.project.comp(comp_id)?, t))
+    }
+
+    /// The layers drawn at the context time, bottom to top (solo, guides and visibility
+    /// applied).
+    pub fn visible_layers(&self, ctx: &EvalCtx<'a>) -> Vec<&'a Layer> {
+        let (comp, t) = (ctx.comp, ctx.time);
+        let any_solo = comp.any_solo();
+        comp.layers
+            .iter()
+            .rev()
+            .filter(|l| l.is_active_at(t) && l.has_video() && !l.environment && (!any_solo || l.switches.solo) && (self.opts.guides || !l.switches.guide))
+            .collect()
+    }
+
+    /// Draw a run of consecutive 3D layers into `canvas` (CPU).
+    pub fn draw_3d_run(&self, ctx: &EvalCtx<'a>, run: &[&Layer], canvas: &mut Image) {
+        three_d::compose::draw_run(self, ctx, run, canvas);
+    }
+
+    /// A run of consecutive 3D layers prepared for an accelerator (planes, lights, shadow
+    /// casters; see [`three_d::Run3d`]) at output size `out`. `None` = draw it with
+    /// [`Self::draw_3d_run`] (adjustment or wireframe layers in the run, Advanced 3D).
+    pub fn prepare_3d_run(&self, ctx: &EvalCtx<'a>, run: &[&Layer], out: (u32, u32)) -> Option<three_d::Run3d> {
+        three_d::compose::gpu_run(self, ctx, run, out)
+    }
+
+    /// A run of consecutive 3D layers of an Advanced 3D comp prepared for an accelerator's
+    /// compositor ([`three_d::adv::Prepared`]): rendered as one scene and composited (Normal,
+    /// premultiplied over) onto the canvas. `None` = not an Advanced 3D comp, or a layer needs the
+    /// 2D compositing path (blend mode, track matte, Preserve Transparency): draw it with
+    /// [`Self::draw_3d_run`].
+    pub fn prepare_adv_run<'p>(&'p self, ctx: &'p EvalCtx<'a>, run: &'p [&'p Layer], out: (u32, u32)) -> Option<three_d::adv::Prepared<'p, 'a>> {
+        three_d::adv::prepare_run(self, ctx, run, out)
+    }
+
+    /// A run of consecutive 3D layers of an Advanced 3D comp whose layers need the 2D
+    /// compositing path (blend mode, track matte, Preserve Transparency), split for an
+    /// accelerator's compositor ([`three_d::adv::SplitRun`]). `None` = [`Self::prepare_adv_run`]
+    /// covers it, or it isn't an Advanced 3D run.
+    pub fn split_adv_run<'p>(&'p self, ctx: &'p EvalCtx<'a>, run: &'p [&'p Layer], out: (u32, u32)) -> Option<three_d::adv::SplitRun<'p, 'a>> {
+        three_d::adv::split_run(self, ctx, run, out)
+    }
+
+    /// Whether the comp's 3D layers draw with the Advanced 3D renderer.
+    pub fn is_adv3d(&self, ctx: &EvalCtx) -> bool {
+        three_d::adv::active(self, ctx)
+    }
+
+    /// An Environment Light Background layer ready to draw on an accelerator
+    /// ([`three_d::SkyDraw`]; the CPU draws it in `draw_3d_run`). `None` = nothing to draw.
+    pub fn sky_draw(&self, ctx: &EvalCtx, layer: &Layer) -> Option<three_d::SkyDraw> {
+        three_d::compose::sky_draw(self, ctx, layer)
+    }
+
+    /// The pixels a Wireframe-quality layer sets (white, opaque) on a `size` canvas: its
+    /// bounds' outline, one pixel wide. Empty when the layer has no bounds.
+    pub fn wireframe_pixels(&self, ctx: &EvalCtx, layer: &Layer, size: (u32, u32)) -> Vec<(u32, u32)> {
+        let Some(b) = content_bounds(ctx, layer) else { return vec![] };
+        let s = self.opts.scale;
+        let (l2c, _) = ctx.layer_to_comp(layer);
+        let m = Mat3::scale(vec2(s, s)) * self.outer.map_or(l2c, |o| o * l2c);
+        let c = [(b[0], b[1]), (b[2], b[1]), (b[2], b[3]), (b[0], b[3])].map(|(x, y)| m.apply(vec2(x, y)));
+        let (w, h) = (size.0 as i64, size.1 as i64);
+        let mut out = vec![];
+        for i in 0..4 {
+            let (p, q) = (c[i], c[(i + 1) % 4]);
+            let n = ((q.x - p.x).abs().max((q.y - p.y).abs()) * 2.0).ceil().clamp(1.0, 1.0e5) as usize;
+            for j in 0..=n {
+                let t = j as f64 / n as f64;
+                let (x, y) = ((p.x + (q.x - p.x) * t).floor() as i64, (p.y + (q.y - p.y) * t).floor() as i64);
+                if x >= 0 && y >= 0 && x < w && y < h {
+                    out.push((x as u32, y as u32));
+                }
+            }
+        }
+        out
+    }
+
+    /// Run the layer's effect stack on `target` (an accelerator's resident image): GPU-capable
+    /// runs through [`FxTarget::gpu`], the others through [`FxTarget::cpu`], with the CPU's
+    /// parameters and environment. `adjustment`: the stack runs on the comp below (adjustment
+    /// layers).
+    pub fn run_effects_on(&self, ctx: &EvalCtx, layer: &Layer, adjustment: bool, target: &mut dyn FxTarget) {
+        // `target` is used as it is: the comp below for adjustment layers (the callers).
+        self.run_effect_stack(ctx, layer, crate::pipeline::EffectStack { adjustment, limit: usize::MAX, origin: [0.0; 2] }, None, target);
+    }
+
+    /// [`Renderer::run_effects_on`] for a (non-adjustment) layer's own pixels: `target` holds
+    /// them in effect space (as [`Renderer::layer_input`] hands them out) and the result stays
+    /// there. Returns the effect-space origin in layer coordinates (rebase by its negation).
+    pub fn run_layer_effects_on(&self, ctx: &EvalCtx, layer: &Layer, target: &mut dyn FxTarget) -> [f64; 2] {
+        let origin = ctx.effect_bounds(layer).1;
+        self.run_effect_stack(ctx, layer, crate::pipeline::EffectStack { adjustment: false, limit: usize::MAX, origin }, None, target);
+        origin
+    }
+
+    /// An adjustment layer's footprint (its source with masks applied, layer space): where
+    /// its effects show. `None` = the layer changes nothing.
+    pub fn adjustment_footprint(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<Buf>> {
+        // Cached, so an accelerator sees the same buffer (and uploads it once) every frame.
+        let key = self.cache.and_then(|_| cache::footprint_key(ctx, layer, self.raster_scale(ctx, layer), self.opts.draft, self.mb_on(ctx, layer)));
+        if let (Some(c), Some(k)) = (self.cache, key)
+            && let Some(b) = c.get(k)
+        {
+            return Some(b);
+        }
+        let mut foot = self.source(ctx, layer)?;
+        let _ = masks::apply(ctx, layer, &mut foot, self.mask_blur(ctx, layer));
+        let foot = Arc::new(foot);
+        // The buffer the cache keeps (another worker's, if it kept one first).
+        let foot = match (self.cache_to_keep(), key) {
+            (Some(c), Some(k)) => c.insert(k, foot),
+            _ => foot,
+        };
+        Some(foot)
+    }
+
+    /// Draw one 2D layer into `canvas` on the CPU (any kind: adjustment, wireframe, styled…).
+    pub fn draw_layer_cpu(&self, ctx: &EvalCtx, layer: &Layer, canvas: &mut Image) {
+        self.draw_layer(ctx, layer, canvas, false);
+    }
+
+    /// Draw a collapsed precomp layer into `canvas` on the CPU.
+    pub fn draw_collapsed_cpu(&self, ctx: &EvalCtx<'a>, layer: &'a Layer, collapsed: &crate::Collapsed, canvas: &mut Image) {
+        self.draw_collapsed(ctx, layer, collapsed, canvas, false);
+    }
+
+    /// The layer's finished buffers (styles included) in the blending space.
+    pub fn styled_layer(&self, ctx: &EvalCtx, layer: &Layer) -> Option<StyledLayer> {
+        let mut timing = self.profile.map(|_| LayerTiming { depth: self.depth, layer: layer.name.clone(), ..Default::default() });
+        let t0 = web_time::Instant::now();
+        let st = self.styled(ctx, layer, timing.as_mut()).map(|st| self.styled_to_blend(st));
+        if let (Some(prof), Some(mut timing)) = (self.profile, timing) {
+            timing.process_ms = t0.elapsed().as_secs_f64() * 1e3;
+            if let Ok(mut v) = prof.lock() {
+                v.push(timing);
+            }
+        }
+        st
+    }
+
+    /// Opacity the layer composites with (its Opacity × collapsed precomps' opacity).
+    pub fn layer_opacity(&self, ctx: &EvalCtx, layer: &Layer) -> f32 {
+        ctx.opacity(layer) as f32 * self.opacity_mul
+    }
+
+    /// The layer's track matte layer and kind, if it has a valid one.
+    pub fn track_matte<'c>(&self, ctx: &EvalCtx<'c>, layer: &Layer) -> Option<(&'c Layer, MatteKind)> {
+        layer.track_matte.and_then(|tm| ctx.comp.layer(tm.layer).filter(|m| m.id != layer.id).map(|m| (m, tm.kind)))
+    }
+}
diff --git a/crates/render/src/audio.rs b/crates/render/src/audio.rs
index 68be63fe4..e2861340c 100644
--- a/crates/render/src/audio.rs
+++ b/crates/render/src/audio.rs
@@ -4,10 +4,13 @@
 //! (Effect > Audio, see [`effectcraft_effects::audio_fx`]) run on each layer's audio before
 //! its levels; Backwards plays the layer's [in, out) span reversed.
 //!
-//! Callers mix in short blocks (one video frame, or an audio device buffer). Effects and levels
-//! are evaluated once per block. To make the result independent of block boundaries, layer
-//! effects are run from a cleared state over a pre-roll of earlier audio and only the block's
-//! tail is kept — so preview playback and export produce identical samples.
+//! Callers mix in short blocks (one video frame, an audio device buffer, or a second of export).
+//! Effect parameters are evaluated once per block. Animated Audio Levels, and animated effects
+//! that work sample by sample (Stereo Mixer), are evaluated on a grid of comp samples every
+//! millisecond instead, so keyframed fades ramp smoothly whatever the block size. To make the
+//! result independent of block boundaries, layer effects are run from a cleared state over a
+//! pre-roll of earlier audio and only the block's tail is kept — so preview playback and export
+//! produce identical samples.
 //!
 //! Time-stretched layers are resampled nearest-sample; reversed (negative stretch) layers are
 //! silent for now.
@@ -25,7 +28,7 @@ const MAX_DEPTH: usize = 16;
 /// interleaved (L R L R …).
 pub fn mix_comp(project: &Project, footage: &dyn FootageSource, expr: Option<&dyn ExprHost>, comp: ItemId, start: Tick, frames: usize, rate: u32) -> Vec<f32> {
     let mut out = vec![0.0f32; frames * 2];
-    mix_into(project, footage, expr, comp, start, rate, &mut out, 1.0, 1.0, 0);
+    mix_into(&AudioSources { project, footage, expr, rate }, comp, start, &mut out, 0);
     out
 }
 
@@ -85,6 +88,20 @@ fn units_ceil(t: Tick, rate: u32) -> i64 {
     (n.div_euclid(d) + i128::from(n.rem_euclid(d) != 0)) as i64
 }
 
+/// Samples between evaluations of animated levels and per-sample effects: one millisecond, on
+/// a grid of comp sample indices so the result does not depend on where a block starts.
+fn param_step(rate: u32) -> i64 {
+    i64::from(rate / 1000).max(1)
+}
+
+/// Does any property of the group change over time?
+fn animated(g: &effectcraft_project::PropGroup) -> bool {
+    g.children.iter().any(|c| match c {
+        Node::Prop(p) => p.is_animated() || p.has_expression(),
+        Node::Group(sub) => animated(sub),
+    })
+}
+
 fn sample_tick(i: i64, rate: u32) -> Tick {
     // Keep the requested sample when the rate does not divide the tick clock.
     let t = Tick::from_units(i, i64::from(rate));
@@ -151,7 +168,7 @@ impl MixEnv<'_> {
                     return out;
                 }
                 let mut sub = vec![0.0f32; src_n * 2];
-                mix_into(self.project, self.footage, self.expr, *item, lt, rate, &mut sub, 1.0, 1.0, self.depth + 1);
+                mix_into(&AudioSources { project: self.project, footage: self.footage, expr: self.expr, rate }, *item, lt, &mut sub, self.depth + 1);
                 sub
             }
             _ => return out,
@@ -189,36 +206,82 @@ impl MixEnv<'_> {
     /// `i0 .. i0 + n`.
     fn layer_audio(&self, l: &Layer, i0: i64, n: usize) -> Vec<f32> {
         let t = sample_tick(i0, self.rate);
-        let fx: Vec<(&str, Params)> = audio_effect_groups(l).map(|(id, g)| (id, self.params(l, g, t))).collect();
+        let fx: Vec<(&str, &effectcraft_project::PropGroup, Params)> = audio_effect_groups(l).map(|(id, g)| (id, g, self.params(l, g, t))).collect();
         if fx.is_empty() {
             return self.layer_raw(l, i0, n, false);
         }
-        let reversed = fx.iter().any(|(id, _)| audio_fx::reverses(id));
-        let pre_s: f64 = fx.iter().map(|(id, p)| audio_fx::preroll(id, p)).sum();
+        let reversed = fx.iter().any(|(id, _, _)| audio_fx::reverses(id));
+        let pre_s: f64 = fx.iter().map(|(id, _, p)| audio_fx::preroll(id, p)).sum();
         let pre = (pre_s * self.rate as f64).ceil() as usize;
-        let mut buf = self.layer_raw(l, i0 - pre as i64, n + pre, reversed);
-        let start = l.layer_time(sample_tick(i0 - pre as i64, self.rate)).seconds();
-        for (id, p) in &fx {
-            audio_fx::process(id, p, &mut buf, self.rate, start);
+        let b0 = i0 - pre as i64;
+        let mut buf = self.layer_raw(l, b0, n + pre, reversed);
+        let start = l.layer_time(sample_tick(b0, self.rate)).seconds();
+        for (id, g, p) in &fx {
+            if audio_fx::per_sample(id) && animated(g) {
+                self.process_stepped(l, id, g, &mut buf, b0);
+            } else {
+                audio_fx::process(id, p, &mut buf, self.rate, start);
+            }
         }
         buf.drain(..pre * 2);
         buf
     }
+
+    /// Run per-sample effect `id` over `buf` (comp samples from `b0`) in pieces of the parameter
+    /// grid, each with the parameters at its first sample.
+    fn process_stepped(&self, l: &Layer, id: &str, g: &effectcraft_project::PropGroup, buf: &mut [f32], b0: i64) {
+        let step = param_step(self.rate);
+        let frames = buf.len() / 2;
+        let mut k = 0usize;
+        while k < frames {
+            let i = b0.saturating_add(k as i64);
+            let next = i.div_euclid(step).saturating_add(1).saturating_mul(step);
+            let end = usize::try_from(next.saturating_sub(b0)).unwrap_or(frames).clamp(k + 1, frames);
+            let t = sample_tick(i, self.rate);
+            if let Some(piece) = buf.get_mut(k * 2..end * 2) {
+                audio_fx::process(id, &self.params(l, g, t), piece, self.rate, l.layer_time(t).seconds());
+            }
+            k = end;
+        }
+    }
+
+    /// Linear gains (left, right) of the layer's Audio Levels for comp samples `i0 .. i0 + n`.
+    /// Animated levels are evaluated on the parameter grid and interpolated in dB in between.
+    fn level_gains(&self, l: &Layer, i0: i64, n: usize) -> Vec<[f32; 2]> {
+        let Some(pr) = l.props.sub("audio").and_then(|g| g.get("levels")) else { return vec![[1.0, 1.0]; n] };
+        let db = |i: i64| self.ctx(sample_tick(i, self.rate)).value(l, pr).as_vec2();
+        let gain = |[a, b]: [f64; 2]| [db_to_gain(a), db_to_gain(b)];
+        if !pr.is_animated() && !pr.has_expression() {
+            return vec![gain(db(i0)); n];
+        }
+        let step = param_step(self.rate);
+        let end = i0.saturating_add(n as i64);
+        let mut out = Vec::with_capacity(n);
+        let mut k = i0.div_euclid(step).saturating_mul(step);
+        let mut lo = db(k);
+        while k < end {
+            let hi = db(k.saturating_add(step));
+            for i in k.max(i0)..k.saturating_add(step).min(end) {
+                let f = (i - k) as f64 / step as f64;
+                out.push(gain([lo[0] + (hi[0] - lo[0]) * f, lo[1] + (hi[1] - lo[1]) * f]));
+            }
+            k = k.saturating_add(step);
+            lo = hi;
+        }
+        out
+    }
 }
 
-#[allow(clippy::too_many_arguments)]
-fn mix_into(
-    project: &Project,
-    footage: &dyn FootageSource,
-    expr: Option<&dyn ExprHost>,
-    comp_id: ItemId,
-    start: Tick,
+/// Shared inputs for composition audio mixing, including nested compositions.
+struct AudioSources<'a> {
+    project: &'a Project,
+    footage: &'a dyn FootageSource,
+    expr: Option<&'a dyn ExprHost>,
     rate: u32,
-    out: &mut [f32],
-    gl: f32,
-    gr: f32,
-    depth: usize,
-) {
+}
+
+fn mix_into(sources: &AudioSources<'_>, comp_id: ItemId, start: Tick, out: &mut [f32], depth: usize) {
+    let AudioSources { project, footage, expr, rate } = *sources;
     let Some(comp) = project.comp(comp_id) else { return };
     if depth >= MAX_DEPTH || rate == 0 {
         return;
@@ -237,26 +300,18 @@ fn mix_into(
         if a >= b {
             continue;
         }
-        let t_a = sample_tick(s0 + a as i64, rate);
-        let (ll, lr) = levels(&env, l, t_a);
-        let (ll, lr) = (ll * gl, lr * gr);
-        if ll == 0.0 && lr == 0.0 {
+        let gains = env.level_gains(l, s0 + a as i64, b - a);
+        if gains.iter().all(|g| *g == [0.0, 0.0]) {
             continue;
         }
         let buf = env.layer_audio(l, s0 + a as i64, b - a);
-        for (i, f) in buf.as_chunks::<2>().0.iter().enumerate() {
-            out[(a + i) * 2] += f[0] * ll;
-            out[(a + i) * 2 + 1] += f[1] * lr;
+        for (i, (f, g)) in buf.as_chunks::<2>().0.iter().zip(&gains).enumerate() {
+            out[(a + i) * 2] += f[0] * g[0];
+            out[(a + i) * 2 + 1] += f[1] * g[1];
         }
     }
 }
 
-fn levels(env: &MixEnv, l: &Layer, t: Tick) -> (f32, f32) {
-    let Some(g) = l.props.sub("audio") else { return (1.0, 1.0) };
-    let [a, b] = env.ctx(t).v2(l, g, "levels", [0.0, 0.0]);
-    (db_to_gain(a), db_to_gain(b))
-}
-
 /// A min/max peak summary of interleaved stereo audio for waveform drawing: one entry per
 /// `bin` sample frames, `[min L, max L, min R, max R]`.
 pub fn peak_summary(samples: &[f32], bin: usize) -> Vec<[f32; 4]> {
@@ -351,7 +406,7 @@ mod tests {
             pr.value = effectcraft_project::Value::Vec2([-6.0206, -96.0]);
         }
         let mut comp = comp;
-        comp.layers = vec![l1, l2];
+        comp.layers = vec![l1, l2].into();
         let cid = p.add_item("C", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(comp.into()));
         assert!(comp_has_audio(&p, cid));
         let rate = 1000;
@@ -397,11 +452,11 @@ mod tests {
         let base = Comp::new(64, 64, FrameRate::new(25, 1), Tick::from_seconds_f64(2.0));
         let tone = build::layer(&mut p, &base, "tone", LayerSource::Footage { item: fid }, (0, 0), None);
         let mut inner = base.clone();
-        inner.layers = vec![tone];
+        inner.layers = vec![tone].into();
         let inner_id = p.add_item("Inner", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(inner.into()));
         let pre = build::layer(&mut p, &base, "pre", LayerSource::Comp { item: inner_id }, (64, 64), None);
         let mut outer = base.clone();
-        outer.layers = vec![pre];
+        outer.layers = vec![pre].into();
         let outer_id = p.add_item("Outer", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(outer.into()));
         let rate = 8000;
         let t = Tick::from_seconds_f64(0.5);
@@ -428,7 +483,7 @@ mod tests {
         let mut tone = build::layer(&mut p, &base, "tone", LayerSource::Footage { item: fid }, (0, 0), None);
         tone.stretch = stretch;
         let mut comp = base.clone();
-        comp.layers = vec![tone];
+        comp.layers = vec![tone].into();
         let cid = p.add_item("C", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(comp.into()));
         let n = 2000usize;
         let t = Tick::from_seconds_f64(0.5);
diff --git a/crates/render/src/cache.rs b/crates/render/src/cache.rs
index 89e9fd1c9..cf1a84e82 100644
--- a/crates/render/src/cache.rs
+++ b/crates/render/src/cache.rs
@@ -458,7 +458,7 @@ fn time_dependent(layer: &Layer, effects: bool) -> bool {
     if matches!(layer.source, LayerSource::Shape)
         && let Some(c) = layer.props.sub("contents")
     {
-        return group_has(c, "wiggle");
+        return group_has(c, "wiggle") || group_has(c, "wiggler");
     }
     // Wiggly selectors move with time; Expression selectors evaluate per character (their
     // property value alone doesn't capture the result).
@@ -479,6 +479,19 @@ fn group_has(g: &PropGroup, match_id: &str) -> bool {
 
 /// Feed every property of `g` that can change over time (keyframes or expression) as its value
 /// at the context time. The static structure is hashed separately.
+/// Mix the collapsed-instance overrides that target `id` into a cache key. They replace values
+/// without editing the layer, so a key without them would reuse another instance's buffer.
+fn hash_overrides(h: &mut KeyHasher, ctx: &EvalCtx, id: effectcraft_project::LayerId) {
+    for o in ctx.property_overrides.iter().filter(|o| o.layer == id) {
+        o.prop.hash(h);
+        o.font.hash(h);
+        hash_debug(h, &o.value);
+    }
+    for m in ctx.media_overrides.iter().filter(|m| m.layer == id) {
+        m.item.hash(h);
+    }
+}
+
 fn hash_values(h: &mut KeyHasher, ctx: &EvalCtx, layer: &Layer, g: &PropGroup) {
     for c in &g.children {
         match c {
@@ -497,10 +510,11 @@ fn hash_values(h: &mut KeyHasher, ctx: &EvalCtx, layer: &Layer, g: &PropGroup) {
 /// time, or `None` when the layer must not be cached (movie footage, precomps, cameras, adjustment
 /// layers…).
 pub fn layer_key(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool) -> Option<u64> {
-    // Time effects see property values at other times. Keyframes are part of the hashed
-    // structure (and the layer time is folded in), but expressions may read other layers at
-    // those times, which the key cannot see: such layers are not cached.
-    if reads_other_times(layer) && layer.props.children.iter().any(|c| matches!(c, Node::Group(g) if g.match_id != "transform" && has_expression(g))) {
+    // Time effects (and CC Particle World's Birth Rate history) see property values at other
+    // times. Keyframes are part of the hashed structure (and the layer time is folded in), but
+    // expressions may read other layers at those times, which the key cannot see: such layers
+    // are not cached.
+    if history_unkeyable(layer, None) {
         return None;
     }
     key_with(ctx, layer, scale, draft, blur, false)
@@ -510,23 +524,35 @@ pub fn layer_key(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bo
 /// effects (see `Renderer::layer_input`). Unlike [`layer_key`], footage layers are cached here
 /// (keyed by item and source time), since Time effects read many neighbouring frames.
 pub fn input_key(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool, effects: usize) -> Option<u64> {
-    if layer.switches.adjustment {
+    if layer.switches.adjustment || history_unkeyable(layer, Some(effects)) {
         return None;
     }
-    let base = key_any(ctx, layer, scale, draft, blur, true, Some(effects))?;
+    let base = key_any(ctx, layer, scale, draft, blur, true, EffectScope::First(effects))?;
     let mut h = KeyHasher(base ^ 0x5bd1_e995_7a3c_11d3);
     effects.hash(&mut h);
     Some(h.finish())
 }
 
-/// Does the layer run an effect that reads the layer at other times (Echo, Timewarp…)?
-fn reads_other_times(layer: &Layer) -> bool {
+/// Does the layer run (among its first `effects` effects, all when `None`) an effect that reads
+/// the layer at other times (Echo, Timewarp…) or its own parameters' history (CC Particle
+/// World's Birth Rate, #1373)?
+fn reads_other_times(layer: &Layer, effects: Option<usize>) -> bool {
     layer.switches.effects
         && layer.effects().is_some_and(|fx| {
-            fx.groups().any(|g| g.enabled && matches!(&g.kind, effectcraft_project::GroupKind::Effect { effect } if effect.starts_with("ec.time.")))
+            fx.groups().take(effects.unwrap_or(usize::MAX)).any(|g| {
+                g.enabled
+                    && matches!(&g.kind, effectcraft_project::GroupKind::Effect { effect }
+                        if effect.starts_with("ec.time.") || effectcraft_effects::reads_param_history(effect))
+            })
         })
 }
 
+/// The layer reads values at other times (see [`reads_other_times`]) and has expressions
+/// (outside Transform), whose results at those times the key can't see.
+fn history_unkeyable(layer: &Layer, effects: Option<usize>) -> bool {
+    reads_other_times(layer, effects) && layer.props.children.iter().any(|c| matches!(c, Node::Group(g) if g.match_id != "transform" && has_expression(g)))
+}
+
 /// A still image (no proxy): its layer is cached like a text or shape layer, so the GPU
 /// compositor uploads it once, not every frame (#1812: four 21120 px plates re-uploaded by every
 /// preview worker ran the GPU out of memory). Movies and sequences stay in the media pool only.
@@ -562,26 +588,39 @@ fn has_expression(g: &PropGroup) -> bool {
     })
 }
 
+/// How far the effect stack reaches into a cache key. [`EffectScope::Footprint`] keys an
+/// adjustment layer's footprint — its source through its masks, without any effects — so the
+/// stack must not reach the key at all (#687).
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(super) enum EffectScope {
+    /// The whole stack (the processed layer).
+    All,
+    /// Only the first `n` effects (a layer's input, see [`input_key`]).
+    First(usize),
+    /// None of it (an adjustment layer's footprint).
+    Footprint,
+}
+
 /// Cache key for an adjustment layer's footprint (its source through its masks, see
 /// `Renderer::adjustment_footprint`): the GPU compositor then uploads it once, not every frame.
 pub fn footprint_key(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool) -> Option<u64> {
     // The footprint is the source through the masks, without the effects: a time-dependent
     // effect (Noise on a finishing adjustment layer) must not re-key it every frame (on the GPU,
-    // a full-frame re-upload per frame).
-    Some(derive(key_any(ctx, layer, scale, draft, blur, false, Some(0))?, 0xf007_9417))
+    // a full-frame re-upload per frame). Shutter, paint, the comp scene and effect dependencies
+    // stay out of this key too; a mask still does.
+    Some(derive(key_any(ctx, layer, scale, draft, blur, false, EffectScope::Footprint)?, 0xf007_9417))
 }
 
 fn key_with(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool, footage: bool) -> Option<u64> {
     if layer.switches.adjustment {
         return None;
     }
-    key_any(ctx, layer, scale, draft, blur, footage, None)
+    key_any(ctx, layer, scale, draft, blur, footage, EffectScope::All)
 }
 
-/// `blur`: the layer is motion blurred in this render (`Renderer::mb_on`). `effects`: key only
-/// the first that many effects (a layer's input, see [`input_key`]).
-#[allow(clippy::too_many_arguments)]
-fn key_any(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool, footage: bool, effects: Option<usize>) -> Option<u64> {
+/// `blur`: the layer is motion blurred in this render (`Renderer::mb_on`). `effects`: how far
+/// the effect stack reaches into the key (see [`EffectScope`]).
+fn key_any(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool, footage: bool, effects: EffectScope) -> Option<u64> {
     let mut h = KeyHasher(0xcbf2_9ce4_8422_2325);
     ctx.comp.frame_rate.as_f64().to_bits().hash(&mut h);
     ctx.comp.enable_frame_blending.hash(&mut h);
@@ -593,8 +632,9 @@ fn key_any(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool, fo
             hash_debug(&mut h, s);
         }
         LayerSource::Text | LayerSource::Shape => {}
-        LayerSource::Footage { item } if footage || still_footage(ctx, *item) => {
-            let it = ctx.project.item(*item)?;
+        LayerSource::Footage { item } if footage || still_footage(ctx, ctx.media_item(layer, *item)) => {
+            let item = ctx.media_item(layer, *item);
+            let it = ctx.project.item(item)?;
             let ItemKind::Footage(f) = &it.kind else { return None };
             hash_debug(&mut h, f);
             // A proxy (and its Use Proxy switch) changes the pixels.
@@ -617,12 +657,18 @@ fn key_any(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool, fo
     scale.to_bits().hash(&mut h);
     draft.hash(&mut h);
     layer.id.hash(&mut h);
+    // Collapsed-instance overrides replace values without editing the nested layer, so mix them
+    // into the key: a Font override, effect parameter or any other source-affecting override
+    // must not reuse another instance's processed buffer.
+    hash_overrides(&mut h, ctx, layer.id);
     hash_debug(&mut h, &layer.source);
     // (Audio, Lock and Shy don't change pixels.)
     hash_debug(&mut h, &layer.switches.pixels());
     // Mask motion blur and effects that read the shutter depend on whether the layer is motion
-    // blurred in this render and on the comp's shutter.
-    if layer.masks().is_some_and(|m| !m.children.is_empty()) || layer.effects().is_some_and(|fx| !fx.children.is_empty()) {
+    // blurred in this render and on the comp's shutter. A footprint has no effects, so only its
+    // masks put the shutter in the key.
+    if layer.masks().is_some_and(|m| !m.children.is_empty()) || (effects != EffectScope::Footprint && layer.effects().is_some_and(|fx| !fx.children.is_empty()))
+    {
         blur.hash(&mut h);
         ctx.comp.enable_motion_blur.hash(&mut h);
         ctx.comp.shutter_angle.to_bits().hash(&mut h);
@@ -636,23 +682,29 @@ fn key_any(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool, fo
         {
             continue;
         }
+        // A footprint is its source through its masks: the effect stack is not in it at all.
         // A layer's input runs only its first effects: the later ones (a Puppet whose pins are
         // dragged, #212) don't change it, so it stays cached.
-        if let (Some(n), Node::Group(g)) = (effects, c)
+        if let Node::Group(g) = c
             && g.match_id == "effects"
         {
-            let mut first = g.clone();
-            let mut seen = 0;
-            first.children.retain(|e| match e {
-                Node::Prop(_) => true,
-                Node::Group(_) => {
-                    seen += 1;
-                    seen <= n
-                }
-            });
-            hash_debug(&mut h, &first);
-            hash_values(&mut h, ctx, layer, &first);
-            continue;
+            if effects == EffectScope::Footprint {
+                continue;
+            }
+            if let EffectScope::First(n) = effects {
+                let mut first = g.clone();
+                let mut seen = 0;
+                first.children.retain(|e| match e {
+                    Node::Prop(_) => true,
+                    Node::Group(_) => {
+                        seen += 1;
+                        seen <= n
+                    }
+                });
+                hash_debug(&mut h, &first);
+                hash_values(&mut h, ctx, layer, &first);
+                continue;
+            }
         }
         // Static structure: values, keyframes, expressions, enabled flags, effect ids, modes.
         hash_debug(&mut h, c);
@@ -661,7 +713,9 @@ fn key_any(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool, fo
         }
     }
     // Paint strokes appear and disappear with their Duration spans (not property values).
-    if layer.switches.effects
+    // A footprint does not include them.
+    if effects != EffectScope::Footprint
+        && layer.switches.effects
         && let Some(fx) = layer.effects()
     {
         let lt = layer.layer_time(ctx.time).seconds();
@@ -674,14 +728,14 @@ fn key_any(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, blur: bool, fo
     if mask_motion_blur(ctx, layer, blur) {
         layer.layer_time(ctx.time).0.hash(&mut h);
     }
-    if time_dependent(layer, effects != Some(0)) {
+    if time_dependent(layer, effects != EffectScope::Footprint) {
         layer.layer_time(ctx.time).0.hash(&mut h);
         // Effects also see the layer's time mapping.
         layer.start_time.0.hash(&mut h);
         layer.stretch.to_bits().hash(&mut h);
     }
     // Effects that see the comp camera or lights (#397) change when they or the layer move.
-    if reads_comp_scene(layer) {
+    if effects != EffectScope::Footprint && reads_comp_scene(layer) {
         hash_debug(&mut h, &crate::comp_scene(ctx, layer));
     }
     Some(h.finish())
diff --git a/crates/render/src/cache/dependencies.rs b/crates/render/src/cache/dependencies.rs
index 483b19da3..db1465c07 100644
--- a/crates/render/src/cache/dependencies.rs
+++ b/crates/render/src/cache/dependencies.rs
@@ -3,12 +3,18 @@
 //! cyclic/over-budget graphs or expressions sampled at unknown times.
 use super::{KeyHasher, hash_debug, hash_values};
 use crate::EvalCtx;
-use effectcraft_project::{ItemId, ItemKind, Layer, LayerId, LayerSource, Node, PropGroup};
+use effectcraft_project::{ItemId, ItemKind, Layer, LayerId, LayerSource, LightKind, Node, PropGroup};
 use std::hash::Hash;
 
-pub(super) fn hash(h: &mut KeyHasher, ctx: &EvalCtx, layer: &Layer, effects: Option<usize>) -> Option<()> {
-    let mut deps = Dependencies { h, path: vec![(ctx.comp_id, layer.id)], remaining: 1024, other_times: super::reads_other_times(layer) };
-    deps.effects(ctx, layer, effects)
+pub(super) fn hash(h: &mut KeyHasher, ctx: &EvalCtx, layer: &Layer, effects: super::EffectScope) -> Option<()> {
+    // A footprint runs no effects: nothing they read is in its pixels or its key.
+    let limit = match effects {
+        super::EffectScope::Footprint => return Some(()),
+        super::EffectScope::All => None,
+        super::EffectScope::First(n) => Some(n),
+    };
+    let mut deps = Dependencies { h, path: vec![(ctx.comp_id, layer.id)], remaining: 1024, other_times: super::reads_other_times(layer, None) };
+    deps.effects(ctx, layer, limit)
 }
 
 struct Dependencies<'a> {
@@ -21,7 +27,7 @@ struct Dependencies<'a> {
 impl Dependencies<'_> {
     fn effects(&mut self, ctx: &EvalCtx, layer: &Layer, limit: Option<usize>) -> Option<()> {
         let previous = self.other_times;
-        self.other_times |= super::reads_other_times(layer);
+        self.other_times |= super::reads_other_times(layer, None);
         if layer.switches.effects
             && let Some(fx) = layer.effects()
         {
@@ -63,19 +69,82 @@ impl Dependencies<'_> {
         Some(())
     }
 
+    /// What a referenced 3D model or primitive layer's solo render depends on: the layer itself
+    /// (geometry, materials, switches, in/out), its animated values and transform at the time,
+    /// the mesh item, the comp's camera (with its depth of field) and its lights at the time
+    /// (the lights are off in draft 3D, and the renderer setting changes the pixels), the model's
+    /// layer time while it plays an animation clip, and the in/out gate (outside the range the
+    /// read is transparent). An Environment light's image can be any layer's render: with one on
+    /// the read is not cached. Comp size and render scale are in the owner's key already.
+    fn soloed_model(&mut self, ctx: &EvalCtx, layer: &Layer) -> Option<()> {
+        self.remaining = self.remaining.checked_sub(1)?;
+        // Expressions sampled at other times: not cacheable, as in the ordinary path.
+        if (self.other_times || super::reads_other_times(layer, None)) && super::has_expression(&layer.props) {
+            return None;
+        }
+        hash_debug(self.h, layer);
+        // An overridden clip plays on the layer clock and a keyed one from its key: the same
+        // selection at the same time can pose differently.
+        super::hash_overrides(self.h, ctx, layer.id);
+        hash_values(self.h, ctx, layer, &layer.props);
+        hash_debug(self.h, &ctx.world_matrix(layer));
+        if let Some(item) = layer.source.item() {
+            hash_debug(self.h, &ctx.project.item(item));
+        }
+        // The solo render goes through the comp's camera and lights. The camera's depth of
+        // field blurs it (focus, aperture, iris, highlights) — none of that is in the
+        // projection hashed above.
+        hash_debug(self.h, &ctx.camera());
+        hash_debug(self.h, &crate::three_d::active_camera(ctx).dof);
+        hash_debug(self.h, &crate::three_d::light::lights_at(ctx));
+        hash_debug(self.h, &ctx.comp.draft_3d);
+        hash_debug(self.h, &ctx.comp.renderer);
+        // An Environment light's image lights Advanced 3D models (its source can be any
+        // layer's render, or any environment layer) — too open-ended to hash: while one is
+        // on (and lighting: Draft 3D lights nothing), don't cache the read.
+        if ctx.comp.renderer == effectcraft_project::Renderer::Advanced3D
+            && !ctx.comp.draft_3d
+            && ctx.comp.layers.iter().any(|l| {
+                l.is_light() && l.switches.video && l.is_active_at(ctx.time) && matches!(l.source, LayerSource::Light { kind: LightKind::Environment })
+            })
+        {
+            return None;
+        }
+        // A model with an animation clip selected is posed at its layer time (Animation Speed
+        // and Looping are static, hashed above): every time is its own entry. Without one the
+        // pose is the same at every time: keep the static key.
+        if layer.props.sub("geometryOptions").map_or(0, |g| ctx.e(layer, g, "animation")) != 0 {
+            layer.layer_time(ctx.time).0.hash(self.h);
+        }
+        // Outside the layer's in/out range the read is transparent: fold the gate in, so a
+        // static model renders once inside it and again when it leaves.
+        layer.is_active_at(ctx.time).hash(self.h);
+        Some(())
+    }
+
     fn layer(&mut self, ctx: &EvalCtx, layer: &Layer) -> Option<()> {
         let id = (ctx.comp_id, layer.id);
         if self.path.len() > crate::MAX_FX_DEPTH || self.path.contains(&id) {
             return None;
         }
+        // A referenced 3D model or primitive layer renders through the comp's camera and lights
+        // (an effect layer parameter reads it that way — Create 3D Layer Instance): hash what
+        // moves its pixels, so the owner keeps a cache entry that changes when any of it does.
+        if layer.source.is_model() {
+            self.soloed_model(ctx, layer)?;
+            return Some(());
+        }
         self.remaining = self.remaining.checked_sub(1)?;
-        if (self.other_times || super::reads_other_times(layer)) && super::has_expression(&layer.props) {
+        if (self.other_times || super::reads_other_times(layer, None)) && super::has_expression(&layer.props) {
             return None;
         }
         self.path.push(id);
         // Include transforms/parents as well as pixels: selected-layer anchors and
         // continuously rasterized sources can depend on them.
         hash_debug(self.h, layer);
+        // A referenced layer's static values can be overridden by the collapsed instance without
+        // editing it (`hash_values` only sees animated ones), so the owner's key needs them too.
+        super::hash_overrides(self.h, ctx, layer.id);
         hash_values(self.h, ctx, layer, &layer.props);
         hash_debug(self.h, &ctx.world_matrix(layer));
         // A cached owner never runs this layer's effects, so the comp camera and lights its
@@ -88,6 +157,10 @@ impl Dependencies<'_> {
         }
         match layer.source {
             LayerSource::Solid { item } | LayerSource::Footage { item } | LayerSource::Comp { item } => {
+                let item = match layer.source {
+                    LayerSource::Footage { .. } => ctx.media_item(layer, item),
+                    _ => item,
+                };
                 let source = ctx.project.item(item);
                 hash_debug(self.h, &source);
                 if let Some(source) = source {
diff --git a/crates/render/src/color.rs b/crates/render/src/color.rs
index abfa791e8..d27526553 100644
--- a/crates/render/src/color.rs
+++ b/crates/render/src/color.rs
@@ -21,7 +21,7 @@
 
 use effectcraft_color::{ColorSpace, Conversion};
 use effectcraft_project::{Footage, HdrMode, ProjectSettings};
-use effectcraft_raster::Image;
+use effectcraft_raster::{Image, quantize_px};
 use rayon::prelude::*;
 
 /// The colour pipeline of a project (see the module docs).
@@ -218,27 +218,6 @@ pub fn quantize(img: &mut Image, levels: f32) {
     quantize_rect(img, PxRect { x0: 0, y0: 0, x1: img.width, y1: img.height }, levels);
 }
 
-/// Clamp (colour ≤ alpha ≤ 1, NaN → 0) and round half up; values are non-negative after the
-/// clamp, so the integer conversion rounds like `round()` and vectorises.
-#[allow(clippy::manual_clamp)] // max/min map NaN to 0; clamp would keep NaN
-#[inline(always)]
-fn quantize_px(p: &mut [f32; 4], levels: f32, inv: f32) {
-    let a = round_half_up(p[3].max(0.0).min(1.0) * levels) * inv;
-    let hi = [a, a, a, a];
-    for c in 0..3 {
-        p[c] = round_half_up(p[c].max(0.0).min(hi[c]) * levels) * inv;
-    }
-    p[3] = a;
-}
-
-/// `v` (0..=65 535) rounded half up. The same either way; the fastest on each target: x86-64's
-/// baseline converts to integers in one instruction but has no `floor` (SSE4.1), while in wasm
-/// `floor` is one instruction and converting back from `u32` several (about 1.5× faster there).
-#[inline(always)]
-fn round_half_up(v: f32) -> f32 {
-    if cfg!(target_arch = "wasm32") { (v + 0.5).floor() } else { (v + 0.5) as u32 as f32 }
-}
-
 /// [`quantize`] restricted to a rectangle (already clamped to the image), row-parallel.
 fn quantize_rect(img: &mut Image, r: PxRect, levels: f32) {
     if r.x0 >= r.x1 || r.y0 >= r.y1 {
@@ -248,7 +227,17 @@ fn quantize_rect(img: &mut Image, r: PxRect, levels: f32) {
     let w = img.width as usize;
     let (x0, x1) = (r.x0 as usize, r.x1 as usize);
     img.data[r.y0 as usize * w..r.y1 as usize * w].par_chunks_mut(w).for_each(|row| {
-        for p in &mut row[x0..x1] {
+        // Runs of all-zero pixels (+0.0 in every channel) quantise to themselves: skip them a
+        // cache line at a time (sparse shape, precomp and glow buffers are mostly empty).
+        let (blocks, rest) = row[x0..x1].as_chunks_mut::<4>();
+        for b in blocks {
+            if b.as_flattened().iter().fold(0, |a, v| a | v.to_bits()) != 0 {
+                for p in b {
+                    quantize_px(p, levels, inv);
+                }
+            }
+        }
+        for p in rest {
             quantize_px(p, levels, inv);
         }
     });
@@ -307,6 +296,39 @@ pub fn output_hdr(img: &mut Image, to_linear: Option<Conversion>, mode: HdrMode,
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+
+    /// Skipping all-zero runs leaves every pixel as quantising it one by one does, bit for bit
+    /// (negative zeros and lone pixels in empty runs included).
+    #[test]
+    fn quantize_skips_only_zero_runs() {
+        let mut img = Image::new(23, 7);
+        for (i, p) in img.data.iter_mut().enumerate() {
+            *p = match i % 11 {
+                0 => [0.3, -0.2, 0.71, 0.9],
+                3 => [-0.0, 0.0, 0.0, 0.0],
+                5 => [0.0, 0.0, 0.0, -0.0],
+                7 => [1.7, 0.4, f32::NAN, 0.5],
+                _ => [0.0; 4],
+            };
+        }
+        for levels in [255.0f32, 32_768.0] {
+            let mut want = img.clone();
+            for p in &mut want.data {
+                quantize_px(p, levels, 1.0 / levels);
+            }
+            for r in [PxRect { x0: 0, y0: 0, x1: 23, y1: 7 }, PxRect { x0: 3, y0: 1, x1: 20, y1: 6 }] {
+                let mut got = img.clone();
+                quantize_rect(&mut got, r, levels);
+                for (i, (g, p)) in got.data.iter().zip(&img.data).enumerate() {
+                    let (x, y) = (i as u32 % 23, i as u32 / 23);
+                    let w = if x >= r.x0 && x < r.x1 && y >= r.y0 && y < r.y1 { want.data[i] } else { *p };
+                    assert_eq!(g.map(f32::to_bits), w.map(f32::to_bits), "{levels} {r:?} px ({x}, {y})");
+                }
+            }
+        }
+    }
+
     /// Both forms `round_half_up` picks between agree on everything quantising feeds it:
     /// 0..=levels, exact halves included.
     #[test]
diff --git a/crates/render/src/disk_cache.rs b/crates/render/src/disk_cache.rs
index 4fa2e1cb3..9cf5694f0 100644
--- a/crates/render/src/disk_cache.rs
+++ b/crates/render/src/disk_cache.rs
@@ -12,9 +12,11 @@
 //!   `FrameSeg::to_bytes` (keyed by their content-keyed chain key and scale, so they are
 //!   reused whenever the same frames, settings and prompt come back, also after a restart). Every file ends in a checksum; damaged files read as misses and
 //!   are deleted.
-//! * Size limit with least-recently-used eviction. The in-memory index is rebuilt from the
-//!   folder when the cache opens (file modification times order it), so the cache survives
-//!   restarts; reads refresh a file's time.
+//! * Size limit with least-recently-used eviction, down to 90% of the limit so the eviction scan
+//!   runs once per tenth of the limit written, not on every write. The limit shrinks to keep
+//!   free space on the cache's disk ([`DiskCache::set_disk_space`]). The in-memory index is
+//!   rebuilt from the folder when the cache opens (file modification times order it), so the
+//!   cache survives restarts; reads refresh a file's time.
 //! * Safe concurrent access: writes go to a unique temporary file that is renamed into place
 //!   (atomic on every desktop OS), so readers in this or another process never see a partial
 //!   entry; a missing or damaged file is just a miss. Writes run on a background thread with a
@@ -22,7 +24,7 @@
 
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
-use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, Condvar, Mutex};
 
 use effectcraft_effects::Buf;
@@ -75,11 +77,15 @@ pub struct DiskStats {
     pub entries: usize,
     pub bytes: u64,
     pub max_bytes: u64,
+    /// The limit in effect: `max_bytes`, or less when the disk is short of free space.
+    pub limit_bytes: u64,
     pub hits: u64,
     pub misses: u64,
     pub writes: u64,
     pub evictions: u64,
     pub dropped: u64,
+    /// Writes that failed (a full disk, permissions).
+    pub failed: u64,
 }
 
 struct Meta {
@@ -157,15 +163,17 @@ impl DiskIndex {
         v.into_iter().map(|e| e.1).collect()
     }
 
-    /// Remove least recently used entries until the total fits `max` bytes; returns them (the
-    /// caller deletes their files).
+    /// When the total exceeds `max` bytes, remove least recently used entries down to 90% of
+    /// it (so the sort runs once per tenth of `max` written, not on every write); returns them
+    /// (the caller deletes their files).
     pub fn evict(&mut self, max: u64) -> Vec<(Kind, u128)> {
         if self.total <= max {
             return vec![];
         }
+        let target = max - max / 10;
         let mut out = vec![];
         for k in self.lru_order() {
-            if self.total <= max {
+            if self.total <= target {
                 break;
             }
             self.remove(k.0, k.1);
@@ -225,11 +233,16 @@ pub struct DiskCache {
     dir: PathBuf,
     index: Mutex<DiskIndex>,
     max_bytes: AtomicU64,
+    /// The size free disk space allows (`u64::MAX` = unknown), see [`DiskCache::set_disk_space`].
+    disk_cap: AtomicU64,
+    /// Free space is limiting the cache (warned once per episode).
+    space_limited: AtomicBool,
     hits: AtomicU64,
     misses: AtomicU64,
     writes: AtomicU64,
     evictions: AtomicU64,
     dropped: AtomicU64,
+    failed: AtomicU64,
     tmp_counter: AtomicU64,
     queue: Arc<(Mutex<Queue>, Condvar)>,
     /// Layer buffers that took less than this to render are not written (ms).
@@ -298,16 +311,21 @@ impl DiskCache {
             dir,
             index: Mutex::new(DiskIndex::default()),
             max_bytes: AtomicU64::new(max_bytes),
+            disk_cap: AtomicU64::new(u64::MAX),
+            space_limited: AtomicBool::new(false),
             hits: AtomicU64::new(0),
             misses: AtomicU64::new(0),
             writes: AtomicU64::new(0),
             evictions: AtomicU64::new(0),
             dropped: AtomicU64::new(0),
+            failed: AtomicU64::new(0),
             tmp_counter: AtomicU64::new(0),
-            queue: Arc::new((Mutex::new(Queue { jobs: Default::default(), busy: false }), Condvar::new())),
+            queue: Arc::new((Mutex::new(Queue { jobs: Default::default(), busy: cfg!(not(target_arch = "wasm32")) }), Condvar::new())),
             min_layer_ms: AtomicU64::new(30),
         });
         dc.rescan();
+        // Shrinking a large cache deletes many files: the writer thread does it.
+        #[cfg(target_arch = "wasm32")]
         dc.evict();
         #[cfg(not(target_arch = "wasm32"))]
         {
@@ -371,6 +389,32 @@ impl DiskCache {
         self.evict();
     }
 
+    /// The limit in effect: the setting, or less when the disk is short of free space.
+    pub fn limit_bytes(&self) -> u64 {
+        self.max_bytes().min(self.disk_cap.load(Ordering::Relaxed))
+    }
+
+    /// The cache's disk: `(total, available)` bytes, `None` = unknown. The cache leaves at least
+    /// 2 GB or 5% of the disk free, whichever is more (evicting when it must).
+    pub fn set_disk_space(&self, space: Option<(u64, u64)>) {
+        let cap = match space {
+            // (a disk reported as 0 bytes, such as an automount map, is unknown)
+            Some((total, available)) if total > 0 => {
+                let reserve = (2u64 << 30).max(total / 20);
+                let used = self.index.lock().map(|g| g.total()).unwrap_or_default();
+                // The cache's own files count as free: below the reserve it gives space back.
+                used.saturating_add(available).saturating_sub(reserve)
+            }
+            _ => u64::MAX,
+        };
+        self.disk_cap.store(cap, Ordering::Relaxed);
+        let limited = cap < self.max_bytes();
+        if self.space_limited.swap(limited, Ordering::Relaxed) != limited && limited {
+            log::warn!("disk cache at {}: little free disk space, limiting the cache to {} MB", self.folder().display(), cap >> 20);
+        }
+        self.evict();
+    }
+
     /// Layer buffers faster to render than this are not worth a disk write.
     pub fn set_min_layer_ms(&self, ms: u64) {
         self.min_layer_ms.store(ms, Ordering::Relaxed);
@@ -395,11 +439,13 @@ impl DiskCache {
             entries,
             bytes,
             max_bytes: self.max_bytes(),
+            limit_bytes: self.limit_bytes(),
             hits: self.hits.load(Ordering::Relaxed),
             misses: self.misses.load(Ordering::Relaxed),
             writes: self.writes.load(Ordering::Relaxed),
             evictions: self.evictions.load(Ordering::Relaxed),
             dropped: self.dropped.load(Ordering::Relaxed),
+            failed: self.failed.load(Ordering::Relaxed),
         }
     }
 
@@ -494,30 +540,44 @@ impl DiskCache {
         }
         let path = self.path(kind, key);
         let Some(parent) = path.parent() else { return };
-        if std::fs::create_dir_all(parent).is_err() {
+        if let Err(e) = std::fs::create_dir_all(parent) {
+            self.write_failed(&e);
             return;
         }
         let data = seal(kind, payload);
-        let n = self.tmp_counter.fetch_add(1, Ordering::Relaxed);
-        let tmp = parent.join(format!("{key:032x}.tmp.{}.{n}", std::process::id()));
-        if std::fs::write(&tmp, &data).is_err() {
-            let _ = std::fs::remove_file(&tmp);
+        // An entry that cannot fit would be evicted straight away.
+        if data.len() as u64 > self.limit_bytes() {
             return;
         }
-        if std::fs::rename(&tmp, &path).is_err() {
+        // Make room first, so the cache never exceeds its limit (or the free-space reserve).
+        self.evict_to(self.limit_bytes().saturating_sub(data.len() as u64));
+        let n = self.tmp_counter.fetch_add(1, Ordering::Relaxed);
+        let tmp = parent.join(format!("{key:032x}.tmp.{}.{n}", std::process::id()));
+        if let Err(e) = std::fs::write(&tmp, &data).and_then(|()| std::fs::rename(&tmp, &path)) {
             let _ = std::fs::remove_file(&tmp);
+            self.write_failed(&e);
             return;
         }
         self.writes.fetch_add(1, Ordering::Relaxed);
         if let Ok(mut g) = self.index.lock() {
             g.insert(kind, key, data.len() as u64);
         }
-        self.evict();
+    }
+
+    /// Count a failed write; the first one is logged (a full disk shouldn't go unnoticed).
+    fn write_failed(&self, e: &std::io::Error) {
+        if self.failed.fetch_add(1, Ordering::Relaxed) == 0 {
+            log::warn!("disk cache at {}: a write failed: {e}", self.folder().display());
+        }
     }
 
     /// Remove least recently used entries until the cache fits its limit.
     fn evict(&self) {
-        let max = self.max_bytes();
+        self.evict_to(self.limit_bytes());
+    }
+
+    /// Remove least recently used entries until the cache fits `max` bytes.
+    fn evict_to(&self, max: u64) {
         let victims = match self.index.lock() {
             Ok(mut g) => g.evict(max),
             Err(_) => return,
@@ -586,6 +646,15 @@ impl DiskCache {
 #[cfg(not(target_arch = "wasm32"))]
 fn writer(dc: std::sync::Weak<DiskCache>, q: Arc<(Mutex<Queue>, Condvar)>) {
     let (m, cv) = &*q;
+    // The eviction at open (a lower limit than the folder holds), off the opening thread;
+    // `busy` starts set, so `flush` waits for it.
+    if let Some(cache) = dc.upgrade() {
+        cache.evict();
+    }
+    if let Ok(mut g) = m.lock() {
+        g.busy = false;
+    }
+    cv.notify_all();
     loop {
         let job = {
             let Ok(mut g) = m.lock() else { return };
@@ -652,7 +721,7 @@ pub fn read_layer_entry(data: &[u8]) -> Option<Buf> {
 /// The disk key of a segmentation: its chain key and scale.
 fn seg_key(key: u64, scale: f64) -> u128 {
     let mut h = Hash128::default();
-    h.write(b"segmentation-v1");
+    h.write(b"segmentation-v2");
     h.write_u64(key);
     h.write_u64(scale.to_bits());
     h.finish()
@@ -772,7 +841,7 @@ fn decode_layer(p: &[u8]) -> Option<Buf> {
 // ---------------------------------------------------------------- content keys
 
 /// Bump when rendering changes in a way that makes old disk entries wrong.
-const RENDER_VERSION: &str = "effectcraft-render-2";
+const RENDER_VERSION: &str = "effectcraft-render-5";
 
 fn hash_debug(h: &mut Hash128, v: &impl std::fmt::Debug) {
     h.write(format!("{v:?}").as_bytes());
@@ -834,16 +903,26 @@ pub fn footage_salt_with(project: &effectcraft_project::Project, virtual_id: Opt
 /// Content key of a composition's pixels: project render settings, the comp and everything it
 /// uses (nested comps, footage, solids, their proxies and Use Proxy switches, footage and proxy
 /// files' size and time). With expressions in play (which can read any comp) the whole project
-/// counts. Switches that don't change pixels (Audio, Lock, Shy, Hide Shy Layers) don't count.
+/// counts. Switches that don't change pixels (Audio, Lock, Shy, Hide Shy Layers) don't count, and
+/// neither do markers unless an expression mentions them.
 pub fn comp_content_key(project: &effectcraft_project::Project, comp: effectcraft_project::ItemId) -> u128 {
     comp_content_key_with(project, comp, None)
 }
 
 /// [`comp_content_key`] with [`VirtualFileId`] for paths `std::fs::metadata` cannot describe.
 pub fn comp_content_key_with(project: &effectcraft_project::Project, comp: effectcraft_project::ItemId, virtual_id: Option<VirtualFileId<'_>>) -> u128 {
+    comp_content_key_for_renderer(project, comp, virtual_id, RENDER_VERSION)
+}
+
+fn comp_content_key_for_renderer(
+    project: &effectcraft_project::Project,
+    comp: effectcraft_project::ItemId,
+    virtual_id: Option<VirtualFileId<'_>>,
+    renderer: &str,
+) -> u128 {
     use effectcraft_project::{ItemKind, LayerSource};
     let mut h = Hash128::default();
-    h.write(RENDER_VERSION.as_bytes());
+    h.write(renderer.as_bytes());
     hash_debug(&mut h, &project.settings);
     let mut seen = std::collections::BTreeSet::new();
     let mut stack = vec![comp];
@@ -864,13 +943,15 @@ pub fn comp_content_key_with(project: &effectcraft_project::Project, comp: effec
             }
         }
     }
+    // Markers are pixels only to the expressions that read them (#1083).
+    let markers = project.reads_markers();
     let ids: Vec<effectcraft_project::ItemId> = if expressions { project.items.keys().copied().collect() } else { seen.into_iter().collect() };
     for id in ids {
         let Some(it) = project.item(id) else { continue };
         h.write_u64(id.0);
         h.write(it.name.as_bytes());
         match &it.kind {
-            ItemKind::Comp(c) => hash_debug(&mut h, &c.pixel_form()),
+            ItemKind::Comp(c) => hash_debug(&mut h, &c.pixel_form_with(markers)),
             k => hash_debug(&mut h, k),
         }
         if let ItemKind::Footage(f) = &it.kind {
@@ -1001,6 +1082,28 @@ mod tests {
         assert!(dc.get_frame(42).is_none());
     }
 
+    #[test]
+    fn previous_renderer_frames_are_not_reused() {
+        use effectcraft_project::{Comp, ItemKind, Project};
+        use effectcraft_time::{FrameRate, Tick};
+
+        let mut project = Project::default();
+        let comp = Comp::new(2, 2, FrameRate::FPS_30, Tick::from_seconds_f64(1.0));
+        let id = project.add_item("Cached composition", effectcraft_color::Label::None, None, ItemKind::Comp(comp.into()));
+        let key = frame_key(comp_content_key(&project, id), 0, 1000, 0);
+        let previous_key = frame_key(comp_content_key_for_renderer(&project, id, None, "effectcraft-render-4"), 0, 1000, 0);
+        let dir = tmpdir("previous-renderer");
+        {
+            let cache = DiskCache::open(&dir, 1 << 30).unwrap();
+            cache.put_frame_now(previous_key, 2, 2, &[9; 16]);
+        }
+        let cache = DiskCache::open(&dir, 1 << 30).unwrap();
+        assert_eq!(cache.get_frame(previous_key).unwrap().rgba, vec![9; 16]);
+        assert!(cache.get_frame(key).is_none());
+        cache.put_frame_now(key, 2, 2, &[17; 16]);
+        assert_eq!(cache.get_frame(key).unwrap().rgba, vec![17; 16]);
+    }
+
     #[test]
     fn persists_across_restarts_and_clears() {
         let dir = tmpdir("persist");
@@ -1030,9 +1133,9 @@ mod tests {
         let per = dc.stats().bytes / 6;
         // Touch 0 so it is the most recently used.
         assert!(dc.get_layer(0).is_some());
-        dc.set_max_bytes(per * 3 + per / 2);
+        dc.set_max_bytes(per * 3 + per * 3 / 4);
         let st = dc.stats();
-        assert!(st.bytes <= per * 3 + per / 2, "{st:?}");
+        assert!(st.bytes <= per * 3 + per * 3 / 4, "{st:?}");
         assert_eq!(st.entries, 3);
         assert!(dc.contains(Kind::Layer, 0), "recently used survives");
         assert!(!dc.contains(Kind::Layer, 1) && !dc.contains(Kind::Layer, 2) && !dc.contains(Kind::Layer, 3));
@@ -1042,7 +1145,69 @@ mod tests {
         assert_eq!(files, 3);
         // New writes keep evicting.
         dc.put_layer_now(99, &buf(9, 64, 64));
-        assert!(dc.stats().bytes <= per * 3 + per / 2);
+        assert!(dc.stats().bytes <= per * 3 + per * 3 / 4);
+    }
+
+    #[test]
+    fn eviction_goes_down_to_ninety_percent_in_lru_order() {
+        let mut ix = DiskIndex::default();
+        for k in 0..10u128 {
+            ix.insert(Kind::Layer, k, 100);
+        }
+        assert!(ix.touch(Kind::Layer, 0));
+        // Over 950: down to 855, least recently used first.
+        ix.insert(Kind::Layer, 10, 100);
+        assert_eq!(ix.evict(950), vec![(Kind::Layer, 1), (Kind::Layer, 2), (Kind::Layer, 3)]);
+        assert_eq!(ix.total(), 800);
+        // The slack absorbs the next write without another scan.
+        ix.insert(Kind::Layer, 11, 100);
+        assert!(ix.evict(950).is_empty());
+    }
+
+    #[test]
+    fn free_disk_space_caps_the_limit() {
+        let dir = tmpdir("space");
+        let dc = DiskCache::open(&dir, 1 << 30).unwrap();
+        for k in 0..4u128 {
+            dc.put_layer_now(k, &buf(k as u32, 64, 64));
+        }
+        let used = dc.stats().bytes;
+        // Unknown space: the setting alone.
+        dc.set_disk_space(None);
+        assert_eq!(dc.stats().limit_bytes, 1 << 30);
+        // A disk reported as 0 bytes is unknown.
+        dc.set_disk_space(Some((0, 0)));
+        assert_eq!(dc.stats().limit_bytes, 1 << 30);
+        // 100 GB disk, 5 GB reserved, exactly 5 GB free: the cache may not grow.
+        dc.set_disk_space(Some((100 << 30, 5 << 30)));
+        let st = dc.stats();
+        assert_eq!((st.max_bytes, st.limit_bytes), (1 << 30, used));
+        dc.put_layer_now(9, &buf(9, 64, 64));
+        let st = dc.stats();
+        assert!(st.bytes <= st.limit_bytes && st.bytes <= used - used / 10 && st.evictions > 0, "{st:?}");
+        assert!(dc.contains(Kind::Layer, 9), "the new entry is the most recently used");
+        // Below the reserve the cache gives its space back, and skips writes that can't fit.
+        dc.set_disk_space(Some((100 << 30, 4 << 30)));
+        dc.put_layer_now(10, &buf(10, 64, 64));
+        let st = dc.stats();
+        assert_eq!((st.limit_bytes, st.entries, st.bytes), (0, 0, 0), "{st:?}");
+        // Plenty of space again: back to the setting.
+        dc.set_disk_space(Some((100 << 30, 50 << 30)));
+        assert_eq!(dc.stats().limit_bytes, 1 << 30);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn failed_writes_are_counted() {
+        let dir = tmpdir("failed");
+        let dc = DiskCache::open(&dir, 1 << 30).unwrap();
+        // A file where the layers folder should be: every layer write fails.
+        std::fs::write(dir.join(VERSION).join(Kind::Layer.dir()), b"x").unwrap();
+        dc.put_layer_now(1, &buf(1, 8, 8));
+        dc.put_layer_now(2, &buf(2, 8, 8));
+        let st = dc.stats();
+        assert_eq!((st.failed, st.writes, st.entries), (2, 0, 0));
+        let _ = std::fs::remove_dir_all(&dir);
     }
 
     fn walk(d: &Path) -> usize {
@@ -1113,7 +1278,7 @@ mod tests {
         let f = Footage { path: "/virtual.mov".into(), width: 16, height: 9, duration: Tick::from_seconds_f64(1.0), has_video: true, ..Default::default() };
         let fid = p.add_item("virtual.mov", effectcraft_color::Label::None, None, ItemKind::Footage(f));
         let mut comp = Comp::new(16, 9, FrameRate::FPS_30, Tick::from_seconds_f64(1.0));
-        comp.layers = vec![build::layer(&mut p, &comp, "clip", LayerSource::Footage { item: fid }, (16, 9), None)];
+        comp.layers = vec![build::layer(&mut p, &comp, "clip", LayerSource::Footage { item: fid }, (16, 9), None)].into();
         let cid = p.add_item("C", effectcraft_color::Label::None, None, ItemKind::Comp(comp.into()));
 
         let id = |mark: u64| move |path: &str| (path == "/virtual.mov").then_some((8, mark));
diff --git a/crates/render/src/eval.rs b/crates/render/src/eval.rs
index 8a193b87a..81fe45d6c 100644
--- a/crates/render/src/eval.rs
+++ b/crates/render/src/eval.rs
@@ -39,17 +39,33 @@ pub struct EvalCtx<'a> {
     /// Footage frames for expressions that read rendered pixels (`sampleImage`): the renderer's
     /// own source while rendering; `None` renders footage as transparent.
     pub footage: Option<&'a dyn crate::FootageSource>,
+    /// Property values overridden by the Essential Properties of a collapsed precomp instance.
+    pub property_overrides: &'a [crate::PropertyOverride],
+    /// Media Replacement values overridden by the Essential Properties of a collapsed precomp
+    /// instance.
+    pub media_overrides: &'a [crate::MediaOverride],
 }
 
 impl<'a> EvalCtx<'a> {
     pub fn new(project: &'a Project, comp_id: ItemId, comp: &'a Comp, time: Tick) -> EvalCtx<'a> {
-        EvalCtx { project, comp_id, comp, time, expr: None, footage: None }
+        EvalCtx { project, comp_id, comp, time, expr: None, footage: None, property_overrides: &[], media_overrides: &[] }
     }
     pub fn at(&self, time: Tick) -> EvalCtx<'a> {
         EvalCtx { time, ..*self }
     }
     /// Value of a property at the context time (keyframes, then expression).
     pub fn value(&self, layer: &Layer, prop: &Property) -> Value {
+        // A collapsed precomp instance's Essential Property override replaces the base value;
+        // its expression (if any) still runs, and sees the overrides of this context.
+        if let Some(o) = self.property_overrides.iter().rev().find(|o| o.layer == layer.id && o.prop == prop.uid) {
+            let v = o.value(layer, prop, self.time);
+            if prop.has_expression()
+                && let Some(h) = self.expr
+            {
+                return h.eval(self, layer, prop, &v).unwrap_or(v);
+            }
+            return v;
+        }
         // Separated Position reads as the combination of X/Y/Z Position.
         if prop.match_id == "position"
             && let Some(tr) = layer.transform()
@@ -60,7 +76,13 @@ impl<'a> EvalCtx<'a> {
             let y = tr.get("positionY").map(|p| self.value(layer, p).as_f64()).unwrap_or(0.0);
             return Value::Vec3([self.value(layer, px).as_f64(), y, z]);
         }
-        let lt = layer.layer_time(self.time);
+        self.value_at_layer_time(layer, prop, layer.layer_time(self.time))
+    }
+    /// [`Self::value`] with the keyframes read at layer time `lt` exactly, rather than at the
+    /// context time mapped through the layer's start and stretch (which rounds under a
+    /// fractional stretch: a Hold key at `lt` could read its previous value). An expression
+    /// still runs at the context time.
+    pub fn value_at_layer_time(&self, layer: &Layer, prop: &Property, lt: Tick) -> Value {
         let v = prop.value_at(lt);
         if prop.has_expression()
             && let Some(h) = self.expr
@@ -139,13 +161,15 @@ impl<'a> EvalCtx<'a> {
     /// Source pixel aspect relative to the comp's: non-square footage (or solids, or precomps
     /// with another pixel aspect) is stretched horizontally by this factor in the comp.
     pub fn par_ratio(&self, layer: &Layer) -> f64 {
-        let par = match &layer.source {
-            LayerSource::Footage { item } | LayerSource::Solid { item } | LayerSource::Comp { item } => match self.project.item(*item).map(|i| &i.kind) {
-                Some(effectcraft_project::ItemKind::Footage(f)) => f.pixel_aspect,
-                Some(effectcraft_project::ItemKind::Solid(s)) => s.pixel_aspect,
-                Some(effectcraft_project::ItemKind::Comp(c)) => c.pixel_aspect,
-                _ => 1.0,
-            },
+        let item = match &layer.source {
+            LayerSource::Footage { item } => Some(self.media_item(layer, *item)),
+            LayerSource::Solid { item } | LayerSource::Comp { item } => Some(*item),
+            _ => None,
+        };
+        let par = match item.and_then(|item| self.project.item(item)).map(|i| &i.kind) {
+            Some(effectcraft_project::ItemKind::Footage(f)) => f.pixel_aspect,
+            Some(effectcraft_project::ItemKind::Solid(s)) => s.pixel_aspect,
+            Some(effectcraft_project::ItemKind::Comp(c)) => c.pixel_aspect,
             _ => 1.0,
         };
         let r = par / if self.comp.pixel_aspect > 0.0 { self.comp.pixel_aspect } else { 1.0 };
@@ -231,9 +255,27 @@ impl<'a> EvalCtx<'a> {
             (Mat3([[m[0][0], m[0][1], m[0][3]], [m[1][0], m[1][1], m[1][3]], [0.0, 0.0, 1.0]]), 0.0)
         }
     }
+    /// The footage item a layer uses, honouring this instance's Media Replacement override.
+    pub fn media_item(&self, layer: &Layer, item: ItemId) -> ItemId {
+        self.media_overrides.iter().rev().find(|m| m.layer == layer.id).map_or(item, |m| m.item)
+    }
+
+    /// Size of a layer's source in layer pixels, honouring Media Replacement.
+    pub fn source_size(&self, layer: &Layer) -> (u32, u32) {
+        let item = match &layer.source {
+            LayerSource::Footage { item } => Some(self.media_item(layer, *item)),
+            LayerSource::Comp { item } | LayerSource::Solid { item } => Some(*item),
+            _ => None,
+        };
+        match layer.source {
+            LayerSource::Null => (100, 100),
+            _ => item.and_then(|item| self.project.item(item)).and_then(|i| i.dimensions()).unwrap_or((0, 0)),
+        }
+    }
+
     /// [`effect_bounds`] of a layer of this comp.
     pub fn effect_bounds(&self, layer: &Layer) -> ([f64; 2], [f64; 2]) {
-        effect_bounds(self.project, self.comp, layer)
+        effect_bounds_of(self.comp, self.source_size(layer))
     }
     /// Effect space (see [`effect_bounds`]) → comp matrix.
     pub fn effect_to_comp(&self, layer: &Layer) -> Mat3 {
@@ -242,6 +284,20 @@ impl<'a> EvalCtx<'a> {
     }
 }
 
+impl crate::PropertyOverride {
+    fn value(&self, layer: &Layer, prop: &Property, time: Tick) -> Value {
+        if self.font {
+            // A Font control merges only the font into the target text, as
+            // `essential::with_overrides` does.
+            let mut value = prop.value_at(layer.layer_time(time));
+            effectcraft_project::essential::merge_font(&mut value, &self.value);
+            value
+        } else {
+            self.value.clone()
+        }
+    }
+}
+
 /// The protected regions of a comp (Responsive Design — Time markers), merged, sorted and
 /// clamped to the comp, in seconds.
 pub fn protected_regions(comp: &Comp) -> Vec<(f64, f64)> {
@@ -315,7 +371,11 @@ pub fn responsive_source_time(comp: &Comp, stretch: f64, elapsed: f64) -> Option
 /// surrounds. Effects work in **effect space**, measured from that corner (After Effects' layer
 /// space for effect points: a shape layer's default effect point is its bounds' centre).
 pub fn effect_bounds(project: &Project, comp: &Comp, layer: &Layer) -> ([f64; 2], [f64; 2]) {
-    match source_size(project, layer) {
+    effect_bounds_of(comp, source_size(project, layer))
+}
+
+fn effect_bounds_of(comp: &Comp, size: (u32, u32)) -> ([f64; 2], [f64; 2]) {
+    match size {
         (0, _) => {
             let (w, h) = (comp.width as f64, comp.height as f64);
             ([w, h], [-w / 2.0, -h / 2.0])
diff --git a/crates/render/src/footage.rs b/crates/render/src/footage.rs
new file mode 100644
index 000000000..db1561ad6
--- /dev/null
+++ b/crates/render/src/footage.rs
@@ -0,0 +1,190 @@
+use super::{Arc, AtomicBool, Footage, Image, ItemId, ItemKind, Ordering, Tick};
+
+/// How a [`FootageSource`] hands over float footage (OpenEXR, float TIFF), whose values are
+/// linear light: encoded with a curve, as the compositor takes footage, or as stored. Other
+/// footage is decoded the same way whatever it says. Interpret Footage ▸ Preserve RGB always
+/// reads the values as stored.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+pub enum FloatCurve {
+    /// The sRGB curve (managed projects, and Working Gamma 2.2).
+    #[default]
+    Srgb,
+    /// A pure 2.4 power curve (no working space, Working Gamma 2.4).
+    Gamma24,
+    /// The linear values as stored (Interpret As Linear Light encodes them afterwards).
+    Linear,
+}
+
+/// Supplies decoded footage frames (implemented by the media layer).
+pub trait FootageSource: Send + Sync {
+    /// The frame of `item` at source time `t`, straight from the file (any size).
+    fn frame(&self, item: ItemId, footage: &Footage, t: Tick) -> Option<Arc<Image>>;
+    /// [`FootageSource::frame`] for a render that shows it at `width` × `height`, at most half its
+    /// size: either that frame or, when the source can make it more cheaply than the whole frame
+    /// (movies, see `effectcraft-media`), the frame already resampled to that size as
+    /// [`effectcraft_raster::resample`] would.
+    fn frame_at_size(&self, item: ItemId, footage: &Footage, t: Tick, _width: u32, _height: u32) -> Option<Arc<Image>> {
+        self.frame(item, footage, t)
+    }
+    /// [`FootageSource::frame`] (`size: None`) or [`FootageSource::frame_at_size`] with float
+    /// footage handed over as `float` says ([`FootageSource::frame`] uses [`FloatCurve::Srgb`]).
+    /// Sources without float footage can leave the default, which ignores `float`.
+    fn frame_with(&self, item: ItemId, footage: &Footage, t: Tick, size: Option<(u32, u32)>, float: FloatCurve) -> Option<Arc<Image>> {
+        let _ = float;
+        match size {
+            Some((w, h)) => self.frame_at_size(item, footage, t, w, h),
+            None => self.frame(item, footage, t),
+        }
+    }
+    /// `frames` interleaved stereo sample frames of `item`'s audio from source time `t` at
+    /// `rate` Hz (`None` when unavailable). The first sample is `t.to_units_floor(rate)`;
+    /// a sample boundary uses the earliest representable tick that selects that sample.
+    fn audio(&self, _item: ItemId, _footage: &Footage, _t: Tick, _frames: usize, _rate: u32) -> Option<Vec<f32>> {
+        None
+    }
+    /// Auxiliary 3D channels of `item` at source time `t` (multi-layer OpenEXR: depth, IDs,
+    /// Cryptomatte, any named channel), with `scale` relative to the file's pixels. `None` when
+    /// the footage has none.
+    fn aux(&self, _item: ItemId, _footage: &Footage, _t: Tick) -> Option<Arc<effectcraft_raster::AuxChannels>> {
+        None
+    }
+    /// The parsed 3D model of a [`effectcraft_project::FootageKind::Model`] item (Advanced 3D).
+    fn model(&self, _item: ItemId, _footage: &Footage) -> Option<Arc<effectcraft_model::Model>> {
+        None
+    }
+    /// Set the decoded-frame cache budget in bytes (Settings ▸ Memory & CPU); sources without
+    /// a cache ignore it.
+    fn set_cache_budget(&self, _bytes: usize) {}
+    /// Drop the decoded frames it keeps (Edit ▸ Purge ▸ All Memory / Image Cache Memory): the
+    /// next reads decode again. Sources without a cache ignore it.
+    fn purge(&self) {}
+    /// The file at `path` changed on disk (Reload Footage): drop what it keeps of it (decoded
+    /// frames, open decoders, parsed models), so the next reads see the new contents. Sources
+    /// without a cache ignore it.
+    fn forget(&self, _path: &str) {}
+    /// Settings ▸ Disk ▸ Conformed Audio Folder: where decoded audio is kept between reads
+    /// (`None` = off); sources that don't decode audio ignore it.
+    fn set_conform_folder(&self, _folder: Option<std::path::PathBuf>) {}
+    /// The decoded-frame cache budget in bytes, if the source has a cache.
+    fn cache_budget(&self) -> Option<usize> {
+        None
+    }
+    /// Vector footage (SVG) rasterised at `scale` × its pixel size, for Continuously Rasterize.
+    /// `None` when the footage is not vector or cannot be read.
+    fn vector_frame(&self, _item: ItemId, _footage: &Footage, _scale: f64) -> Option<Arc<Image>> {
+        None
+    }
+    /// Run `f`, which reads frames from this source, as work that can be called off: once
+    /// `cancel` is set, long decodes it starts (a movie seeking back to a keyframe and decoding
+    /// forward) stop early and their frames come back `None`. Sources that can't stop a decode
+    /// just run `f`. See [`CancellableFootage`].
+    fn cancellable(&self, _cancel: &Arc<AtomicBool>, f: &mut dyn FnMut()) {
+        f()
+    }
+    /// Reads through this source have been called off: frames may have come back `None` that
+    /// exist, so what was made from them must not be kept.
+    fn called_off(&self) -> bool {
+        false
+    }
+    /// Why `footage` shows no picture although its file is there: a read of it failed because
+    /// no decoder handles its codec, profile, chroma format or bit depth, or the stream is damaged
+    /// (e.g. "H.264 (High 4:2:2) isn't supported by the built-in decoder: ..."). `None` while it
+    /// decodes, and for sources that don't track failures. Stays set until the file is forgotten.
+    fn problem(&self, _footage: &Footage) -> Option<String> {
+        None
+    }
+    /// [`Self::problem`] of what `item` shows: its proxy's while Use Proxy shows the proxy
+    /// instead (the reason then says it is the proxy's), else the footage item's own. A
+    /// composition has one only through its proxy.
+    fn item_problem(&self, item: &effectcraft_project::Item) -> Option<String> {
+        match item.proxy.as_deref().filter(|px| px.enabled && px.footage.has_video) {
+            Some(px) => self.problem(&px.footage).map(|why| format!("Proxy: {why}")),
+            None => match &item.kind {
+                ItemKind::Footage(f) => self.problem(f),
+                _ => None,
+            },
+        }
+    }
+}
+
+/// A render's view of a [`FootageSource`] whose frame reads can be called off with `cancel`
+/// (a viewer frame nobody waits for any more, #329). Every read goes through
+/// [`FootageSource::cancellable`] on its own, so reads made for this render on another thread
+/// (a parallel loop) answer to this render's flag, and reads for other renders never do.
+pub struct CancellableFootage<'a> {
+    pub inner: &'a dyn FootageSource,
+    pub cancel: Arc<AtomicBool>,
+}
+
+impl CancellableFootage<'_> {
+    fn read<R>(&self, f: impl FnOnce() -> Option<R>) -> Option<R> {
+        if self.cancel.load(Ordering::Relaxed) {
+            return None;
+        }
+        let (mut f, mut out) = (Some(f), None);
+        self.inner.cancellable(&self.cancel, &mut || out = f.take().and_then(|f| f()));
+        out
+    }
+}
+
+impl FootageSource for CancellableFootage<'_> {
+    fn frame(&self, item: ItemId, footage: &Footage, t: Tick) -> Option<Arc<Image>> {
+        self.read(|| self.inner.frame(item, footage, t))
+    }
+    fn frame_at_size(&self, item: ItemId, footage: &Footage, t: Tick, width: u32, height: u32) -> Option<Arc<Image>> {
+        self.read(|| self.inner.frame_at_size(item, footage, t, width, height))
+    }
+    fn audio(&self, item: ItemId, footage: &Footage, t: Tick, frames: usize, rate: u32) -> Option<Vec<f32>> {
+        self.inner.audio(item, footage, t, frames, rate)
+    }
+    fn aux(&self, item: ItemId, footage: &Footage, t: Tick) -> Option<Arc<effectcraft_raster::AuxChannels>> {
+        self.inner.aux(item, footage, t)
+    }
+    fn model(&self, item: ItemId, footage: &Footage) -> Option<Arc<effectcraft_model::Model>> {
+        self.inner.model(item, footage)
+    }
+    fn set_cache_budget(&self, bytes: usize) {
+        self.inner.set_cache_budget(bytes)
+    }
+    fn purge(&self) {
+        self.inner.purge()
+    }
+    fn forget(&self, path: &str) {
+        self.inner.forget(path)
+    }
+    fn set_conform_folder(&self, folder: Option<std::path::PathBuf>) {
+        self.inner.set_conform_folder(folder)
+    }
+    fn cache_budget(&self) -> Option<usize> {
+        self.inner.cache_budget()
+    }
+    fn vector_frame(&self, item: ItemId, footage: &Footage, scale: f64) -> Option<Arc<Image>> {
+        self.inner.vector_frame(item, footage, scale)
+    }
+    fn cancellable(&self, cancel: &Arc<AtomicBool>, f: &mut dyn FnMut()) {
+        self.inner.cancellable(cancel, f)
+    }
+    fn called_off(&self) -> bool {
+        self.cancel.load(Ordering::Relaxed) || self.inner.called_off()
+    }
+    fn problem(&self, footage: &Footage) -> Option<String> {
+        self.inner.problem(footage)
+    }
+    fn frame_with(&self, item: ItemId, footage: &Footage, t: Tick, size: Option<(u32, u32)>, float: FloatCurve) -> Option<Arc<Image>> {
+        self.read(|| self.inner.frame_with(item, footage, t, size, float))
+    }
+}
+
+/// Footage that can be rasterised at any scale (SVG).
+pub fn is_vector_footage(f: &Footage) -> bool {
+    matches!(f.codec.as_str(), "SVG" | "PDF" | "AI" | "EPS")
+}
+
+/// No footage available (renders footage layers as transparent).
+pub struct NoFootage;
+
+impl FootageSource for NoFootage {
+    fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
+        None
+    }
+}
diff --git a/crates/render/src/frames.rs b/crates/render/src/frames.rs
new file mode 100644
index 000000000..20c655694
--- /dev/null
+++ b/crates/render/src/frames.rs
@@ -0,0 +1,166 @@
+use super::footage::NoFootage;
+use super::opts::RenderOpts;
+use super::{Arc, EvalCtx, Footage, FrameBlend, FrameRate, Image, ItemId, Layer, LayerSource, Project, Renderer, TICKS_PER_SECOND, Tick, shapes, text};
+use rayon::prelude::*;
+
+/// The layer's frame blending mode, if the comp's Enable Frame Blending switch is on.
+/// One field of an interlaced frame as a full frame: the field's lines (`parity` 0 = even /
+/// upper, 1 = odd / lower) kept, the other lines interpolated from their neighbours.
+pub fn field_frame(img: &Image, parity: usize) -> Image {
+    let (w, h) = (img.width as usize, img.height as usize);
+    let mut out = img.clone();
+    if h < 2 {
+        return out;
+    }
+    for y in 0..h {
+        if y % 2 == parity {
+            continue;
+        }
+        let above = y.checked_sub(1);
+        let below = (y + 1 < h).then_some(y + 1);
+        for x in 0..w {
+            let px = match (above, below) {
+                (Some(a), Some(b)) => {
+                    let (p, q) = (img.data[a * w + x], img.data[b * w + x]);
+                    [(p[0] + q[0]) * 0.5, (p[1] + q[1]) * 0.5, (p[2] + q[2]) * 0.5, (p[3] + q[3]) * 0.5]
+                }
+                (Some(a), None) => img.data[a * w + x],
+                (None, Some(b)) => img.data[b * w + x],
+                (None, None) => img.data[y * w + x],
+            };
+            out.data[y * w + x] = px;
+        }
+    }
+    out
+}
+
+/// Interpret Footage ▸ Cineon Settings ▸ Logarithmic Conversion converts the log code values of
+/// a decoded (premultiplied) frame of `f` to the Current Gamma. When the conversion does not
+/// apply, the frame is returned unchanged.
+pub fn cineon_frame(img: Arc<Image>, f: &Footage) -> Arc<Image> {
+    if !f.cineon_applies() {
+        return img;
+    }
+    let cs = f.cineon;
+    let mut out = (*img).clone();
+    out.data.par_iter_mut().for_each(|p| {
+        let a = p[3];
+        let c = if a > 1e-6 { [p[0] / a, p[1] / a, p[2] / a] } else { [0.0; 3] }.map(|v| cs.convert(v));
+        *p = [c[0] * a, c[1] * a, c[2] * a, a];
+    });
+    Arc::new(out)
+}
+
+/// Interpret Footage ▸ Invert Alpha and Interpret As Linear Light on decoded (premultiplied)
+/// pixels; linear light is encoded in `space` ([`color::Pipe::linear_footage_space`]).
+pub fn interpret_pixels(img: &Image, f: &Footage, space: effectcraft_color::ColorSpace) -> Image {
+    let linear = f.linear_light_applies();
+    if !f.invert_alpha && !linear {
+        return img.clone();
+    }
+    let mut out = img.clone();
+    for p in out.data.iter_mut() {
+        let a = p[3];
+        let mut c = if a > 1e-6 { [p[0] / a, p[1] / a, p[2] / a] } else { [0.0; 3] };
+        if linear {
+            // The file's values are linear light: encode them like the rest of the footage.
+            c = c.map(|v| space.encode(v));
+        }
+        let a = if f.invert_alpha { 1.0 - a } else { a };
+        *p = [c[0] * a, c[1] * a, c[2] * a, a];
+    }
+    out
+}
+
+pub(crate) fn frame_blend_mode(ctx: &EvalCtx, layer: &Layer) -> FrameBlend {
+    if ctx.comp.enable_frame_blending { layer.switches.frame_blend } else { FrameBlend::Off }
+}
+
+/// Position of source time `t` among frames at `rate`: the frame at or before `t` and the
+/// fraction (0..1) of the way to the next frame. Exact (integer tick arithmetic), so frames that
+/// line up exactly report a fraction of 0.
+pub fn frame_position(t: Tick, rate: FrameRate) -> (i64, f64) {
+    // A project file can carry a zero or negative rate; there are no frames to land between.
+    if rate.num <= 0 || rate.den <= 0 {
+        return (0, 0.0);
+    }
+    let num = t.0 as i128 * rate.num as i128;
+    let den = TICKS_PER_SECOND as i128 * rate.den as i128;
+    (num.div_euclid(den) as i64, num.rem_euclid(den) as f64 / den as f64)
+}
+
+/// Blend two neighbouring frames `w` of the way from `a` to `b`: a cross-fade (Frame Mix) or a
+/// motion-compensated interpolation (Pixel Motion).
+pub fn blend_frames(mode: FrameBlend, a: &Image, b: &Image, w: f32) -> Image {
+    match mode {
+        FrameBlend::PixelMotion => effectcraft_raster::flow::interpolate(a, b, w),
+        _ => effectcraft_raster::flow::mix(a, b, w),
+    }
+}
+
+/// Convenience: render one frame of a comp with no footage source.
+/// Adaptive motion-blur sample count for a layer whose corners travel `travel` output pixels
+/// during the shutter: one sample per pixel, clamped to Samples Per Frame … Adaptive Sample Limit.
+pub fn adaptive_samples(travel: f64, per_frame: u32, limit: u32) -> usize {
+    let lo = per_frame.clamp(2, 64) as f64;
+    let hi = (limit.clamp(16, 256) as f64).max(lo);
+    travel.ceil().clamp(lo, hi) as usize
+}
+
+/// A region of interest `[x, y, w, h]` lies within a `w`×`h` comp frame.
+pub fn roi_inside(r: [f64; 4], w: u32, h: u32) -> bool {
+    r[0] >= 0.0 && r[1] >= 0.0 && r[0] + r[2] <= w as f64 + 1e-6 && r[1] + r[3] <= h as f64 + 1e-6
+}
+
+/// The Extended Viewer's region of interest: the comp frame grown by `margin` × its size on every
+/// side (`margin` = 1 shows a pasteboard one comp wide around the frame), intersected with the
+/// `visible` comp-space rectangle `[x0, y0, x1, y1]` and snapped outward to whole 16 px steps from the frame edges
+/// so panning re-renders rarely. `None` when the visible area lies inside the frame.
+pub fn extended_region(w: u32, h: u32, visible: [f64; 4], margin: f64) -> Option<[f64; 4]> {
+    let (w, h) = (w as f64, h as f64);
+    let (mx, my) = (w * margin, h * margin);
+    let snap_lo = |v: f64| (v / 16.0).floor() * 16.0;
+    let snap_hi = |v: f64| (v / 16.0).ceil() * 16.0;
+    let x0 = snap_lo(visible[0].max(-mx)).min(0.0);
+    let y0 = snap_lo(visible[1].max(-my)).min(0.0);
+    let x1 = w + snap_hi(visible[2].min(w + mx) - w).max(0.0);
+    let y1 = h + snap_hi(visible[3].min(h + my) - h).max(0.0);
+    if x0 >= 0.0 && y0 >= 0.0 && x1 <= w && y1 <= h {
+        return None;
+    }
+    Some([x0, y0, x1 - x0, y1 - y0])
+}
+
+/// The size of a `width` x `height` comp frame rendered at `scale` (both compositors, and the
+/// frame size Composition Settings shows for a Resolution).
+pub fn frame_size(width: u32, height: u32, scale: f64) -> (u32, u32) {
+    (((width as f64 * scale).round() as u32).max(1), ((height as f64 * scale).round() as u32).max(1))
+}
+
+pub fn render_frame(project: &Project, comp: ItemId, t: Tick, scale: f64) -> Image {
+    Renderer::new(project, &NoFootage, RenderOpts { scale, ..Default::default() }).comp_frame(comp, t)
+}
+
+/// Layer-space bounds `[x0, y0, x1, y1]` of a layer's content at the context time (source size
+/// for solids/footage/precomps, glyph bounds for text, painted bounds for shapes). Used for viewer
+/// handles and hit testing.
+pub fn content_bounds(ctx: &EvalCtx, layer: &effectcraft_project::Layer) -> Option<[f64; 4]> {
+    match &layer.source {
+        LayerSource::Text => {
+            let glyphs = text::glyph_paths(ctx, layer);
+            let paths: Vec<_> = glyphs.into_iter().map(|g| g.0).collect();
+            effectcraft_path::bounds(&paths).map(|r| [r.x0, r.y0, r.x1, r.y1])
+        }
+        LayerSource::Shape => layer.props.sub("contents").and_then(|c| shapes::content_bounds(ctx, layer, c)).map(|r| [r.x0, r.y0, r.x1, r.y1]),
+        LayerSource::Camera | LayerSource::Light { .. } => None,
+        _ => {
+            let (w, h) = ctx.source_size(layer);
+            (w > 0 && h > 0).then_some([0.0, 0.0, w as f64, h as f64])
+        }
+    }
+}
+
+/// A mask/shape path as a kurbo path (for drawing overlays).
+pub fn kurbo_path(sp: &effectcraft_keyframe::ShapePath) -> kurbo::BezPath {
+    effectcraft_path::to_kurbo(sp)
+}
diff --git a/crates/render/src/fx_host.rs b/crates/render/src/fx_host.rs
new file mode 100644
index 000000000..65bafe002
--- /dev/null
+++ b/crates/render/src/fx_host.rs
@@ -0,0 +1,199 @@
+use super::{Arc, Buf, EffectHost, EvalCtx, ItemKind, Layer, LayerPixels, LayerSource, Params, Renderer, Tick, three_d};
+
+/// Layer parameters and audio for effects (see [`effectcraft_effects::EffectHost`]). What it
+/// hands out is in effect space (see [`effect_bounds`]): the other layer's for its pixels, the
+/// running layer's for its own frames and the comp scene.
+pub(crate) struct FxHost<'r, 'a, 'c> {
+    pub(crate) r: &'r Renderer<'a>,
+    pub(crate) ctx: &'c EvalCtx<'a>,
+    pub(crate) layer: &'c Layer,
+    /// Where the stack's effect space starts in layer coordinates (zero on adjustment layers,
+    /// whose effects run on the comp below).
+    pub(crate) origin: [f64; 2],
+    /// Index of the effect being rendered (bounds `self_at` to effects before it).
+    pub(crate) index: usize,
+    pub(crate) original: Option<&'c Buf>,
+}
+
+impl FxHost<'_, '_, '_> {
+    /// Another layer's pixels for a layer parameter, in its effect space; `layer_space`: `buf`
+    /// is still in layer space (its source or its content).
+    fn pixels(&self, other: &Layer, mut buf: Buf, layer_space: bool) -> LayerPixels {
+        let (size, origin) = self.ctx.effect_bounds(other);
+        if layer_space {
+            buf.rebase(origin);
+        }
+        LayerPixels { buf, size }
+    }
+}
+
+/// The comp's camera and first light relative to `layer`, in its layer pixels (see
+/// [`EffectHost::comp_scene`]): the comp camera's view of the layer (as if 3D at its transform),
+/// brought back into the layer's own pixel grid through the inverse of how the layer itself
+/// composites.
+pub(crate) fn comp_scene(ctx: &EvalCtx, layer: &Layer) -> Option<effectcraft_effects::CompScene> {
+    let world = ctx.world_matrix(layer);
+    let (cam, _, _) = ctx.camera();
+    let p = (cam * world).0;
+    let back = ctx.layer_to_comp(layer).0.inverse()?.0;
+    let rows = [p[0], p[1], p[3]];
+    let camera: [[f64; 4]; 3] = std::array::from_fn(|i| std::array::from_fn(|j| (0..3).map(|k| back[i][k] * rows[k][j]).sum()));
+    let inv = world.inverse();
+    let light = three_d::light::lights_at(ctx).first().and_then(|l| {
+        let inv = inv.as_ref()?;
+        let pos = inv.apply(l.pos);
+        let dir = inv.apply_vec(l.dir);
+        let len = (dir.x * dir.x + dir.y * dir.y + dir.z * dir.z).sqrt().max(1e-12);
+        let kind = match l.kind {
+            effectcraft_project::LightKind::Parallel => 0,
+            effectcraft_project::LightKind::Ambient => 2,
+            _ => 1,
+        };
+        Some(effectcraft_effects::CompLight { pos: [pos.x, pos.y, pos.z], dir: [dir.x / len, dir.y / len, dir.z / len], color: l.color, kind })
+    });
+    let camera_layer = ctx.comp.active_camera(ctx.time).is_some();
+    Some(effectcraft_effects::CompScene { camera: Some(camera), camera_layer, light })
+}
+
+/// Nesting limit for effects that render layers (other layers, other times).
+pub(crate) const MAX_FX_DEPTH: usize = 8;
+
+impl EffectHost for FxHost<'_, '_, '_> {
+    fn original(&self) -> Option<&Buf> {
+        self.original
+    }
+
+    fn particles(&self) -> Option<&dyn effectcraft_effects::psim::ParticleSim> {
+        self.r.active_accel().and_then(|a| a.particles())
+    }
+    fn layer(&self, id: u64, masks_and_effects: bool) -> Option<LayerPixels> {
+        let other = self.ctx.layer(effectcraft_project::LayerId(id))?;
+        if (other.id == self.layer.id && masks_and_effects) || self.r.depth > MAX_FX_DEPTH {
+            return None;
+        }
+        let sub = self.r.nested();
+        // A 3D model or primitive layer has no 2D source of its own: an effect referencing one
+        // reads it as After Effects does — the layer rendered on its own through the comp's
+        // camera (Create 3D Layer Instance's effect), in the layer's effect space (the
+        // comp, centred on the layer's anchor).
+        if other.source.is_model() {
+            let buf = sub.solo_3d(self.ctx, other);
+            return Some(self.pixels(other, buf, false));
+        }
+        // The cached layer buffer is shared; effects get their own copy.
+        let buf = if masks_and_effects { (*sub.content_buf(self.ctx, other)?).clone() } else { sub.source(self.ctx, other)? };
+        Some(self.pixels(other, buf, true))
+    }
+
+    fn layer_masks(&self, id: u64) -> Option<LayerPixels> {
+        let other = self.ctx.layer(effectcraft_project::LayerId(id))?;
+        if self.r.depth > MAX_FX_DEPTH {
+            return None;
+        }
+        let sub = self.r.nested();
+        let buf = (*sub.layer_input(self.ctx, other, 0)?).clone();
+        Some(self.pixels(other, buf, false))
+    }
+
+    fn audio(&self, id: u64, start: f64, frames: usize, rate: u32) -> Option<Vec<f32>> {
+        let other = self.ctx.layer(effectcraft_project::LayerId(id))?;
+        let LayerSource::Footage { item } = &other.source else { return None };
+        let item = self.ctx.media_item(other, *item);
+        let ItemKind::Footage(f) = &self.r.project.item(item)?.kind else { return None };
+        if !f.has_audio {
+            return None;
+        }
+        let st = other.layer_time(Tick::from_seconds_f64(start));
+        self.r.footage.audio(item, f, st, frames, rate)
+    }
+
+    fn self_at(&self, layer_time: f64, effects: usize) -> Option<Buf> {
+        if self.r.depth > MAX_FX_DEPTH || self.layer.switches.adjustment {
+            return None;
+        }
+        let n = effects.min(self.index);
+        let t = self.layer.comp_time(Tick::from_seconds_f64(layer_time));
+        let sub = self.r.nested();
+        sub.layer_input(&self.ctx.at(t), self.layer, n).map(|b| (*b).clone())
+    }
+
+    fn aux(&self) -> Option<Arc<effectcraft_raster::AuxChannels>> {
+        self.r.layer_aux(self.ctx, self.layer)
+    }
+
+    fn params_at(&self, layer_time: f64) -> Option<Params> {
+        let g = self.layer.effects()?.groups().nth(self.index)?;
+        let ctx = self.ctx.at(self.layer.comp_time(Tick::from_seconds_f64(layer_time)));
+        Some(effectcraft_effects::flatten_params(g, &mut |pr| ctx.value(self.layer, pr)))
+    }
+
+    fn param_at(&self, effect_index: usize, id: &str, layer_time: f64) -> Option<effectcraft_keyframe::Value> {
+        // Only the one property: a simulation samples it at every step. Its keyframes are read
+        // at the requested layer time exactly (mapping it to comp time and back rounds under a
+        // fractional stretch, so a Hold key there could read its previous value).
+        let p = effect_param(self.layer, effect_index, id)?;
+        let lt = Tick::from_seconds_f64(layer_time);
+        Some(self.ctx.at(self.layer.comp_time(lt)).value_at_layer_time(self.layer, p, lt))
+    }
+
+    fn param_is_static(&self, effect_index: usize, id: &str) -> bool {
+        effect_param(self.layer, effect_index, id).is_some_and(|p| p.keys.is_empty() && !p.has_expression())
+    }
+
+    fn comp_scene(&self) -> Option<effectcraft_effects::CompScene> {
+        Some(comp_scene(self.ctx, self.layer)?.rebased(self.origin))
+    }
+
+    fn layer_at(&self, id: u64, comp_time: f64, masks_and_effects: bool) -> Option<LayerPixels> {
+        let other = self.ctx.layer(effectcraft_project::LayerId(id))?;
+        if (other.id == self.layer.id && masks_and_effects) || !comp_time.is_finite() || self.r.depth > MAX_FX_DEPTH {
+            return None;
+        }
+        let ctx = self.ctx.at(Tick::from_seconds_f64(comp_time));
+        let sub = self.r.nested();
+        Some(if masks_and_effects {
+            self.pixels(other, (*sub.content_buf(&ctx, other)?).clone(), true)
+        } else if other.id == self.layer.id {
+            self.pixels(other, sub.source(&ctx, other)?, true)
+        } else {
+            // Preserve other-layer reads: time effects historically see source + masks.
+            self.pixels(other, (*sub.layer_input(&ctx, other, 0)?).clone(), false)
+        })
+    }
+}
+
+/// Parameter `id` (a flattened id: match ids joined by `/`) of effect `effect_index` in
+/// `layer`'s stack.
+fn effect_param<'a>(layer: &'a Layer, effect_index: usize, id: &str) -> Option<&'a effectcraft_project::Property> {
+    let mut g = layer.effects()?.groups().nth(effect_index)?;
+    let mut path = id.split('/').peekable();
+    while let Some(m) = path.next() {
+        if path.peek().is_none() {
+            return g.children.iter().find_map(|c| match c {
+                effectcraft_project::Node::Prop(p) if p.match_id == m => Some(p),
+                _ => None,
+            });
+        }
+        g = g.children.iter().find_map(|c| match c {
+            effectcraft_project::Node::Group(sg) if sg.match_id == m => Some(sg),
+            _ => None,
+        })?;
+    }
+    None
+}
+
+/// The Essential Properties overrides of a precomp layer, evaluated at the context time.
+pub fn essential_overrides(ctx: &EvalCtx, layer: &Layer) -> Vec<effectcraft_project::essential::Override> {
+    use effectcraft_project::essential;
+    let over = essential::overridden(layer);
+    let Some(g) = essential::group(layer).filter(|_| !over.is_empty()) else { return vec![] };
+    let mut out = vec![];
+    g.walk("", &mut |_, p| {
+        if over.contains(&p.uid)
+            && let Some(control) = essential::control_of(&p.match_id)
+        {
+            out.push(essential::Override { control, value: ctx.value(layer, p) });
+        }
+    });
+    out
+}
diff --git a/crates/render/src/layers.rs b/crates/render/src/layers.rs
new file mode 100644
index 000000000..d105c6f13
--- /dev/null
+++ b/crates/render/src/layers.rs
@@ -0,0 +1,613 @@
+use super::frames::adaptive_samples;
+use super::opts::{LayerTiming, Through};
+use super::{
+    Arc, BlendMode, Buf, Comp, EvalCtx, Image, IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator, Layer, LayerSource, Mat3,
+    MatteKind, ParallelIterator, Quality, Region, Renderer, Sampling, Tick, WarpOpts, cache, color, composite_warp_changed, masks, styles, vec2,
+};
+
+/// Blend policy for placing a layer, including optional output-depth quantization.
+struct PlacementBlend {
+    mode: BlendMode,
+    opacity: f32,
+    quantize: Option<f32>,
+}
+
+/// A motion-blur shutter: the comp's, or for a collapsed precomp's layers the outermost
+/// containing comp's (they are drawn into its frames).
+#[derive(Clone, Copy)]
+struct Shutter {
+    /// Shutter angle and phase as fractions of a frame.
+    angle: f64,
+    phase: f64,
+    /// Frame duration (seconds).
+    frame: f64,
+    /// Samples Per Frame and Adaptive Sample Limit.
+    samples: u32,
+    limit: u32,
+}
+
+impl Shutter {
+    /// Seconds from the frame time to sub-sample `i` of `n`, spread over the open shutter.
+    fn offset(&self, i: usize, n: usize) -> f64 {
+        let f = if n > 1 { i as f64 / (n - 1) as f64 } else { 0.0 };
+        (self.phase + self.angle * f) * self.frame
+    }
+}
+
+impl<'a> Renderer<'a> {
+    /// The layer with its styles: exterior passes and body (cached per pass).
+    pub(crate) fn styled(&self, ctx: &EvalCtx, layer: &Layer, mut timing: Option<&mut LayerTiming>) -> Option<StyledLayer> {
+        let (content, ckey) = self.content_buf_timed(ctx, layer, timing.as_deref_mut())?;
+        if !styles::active(ctx, layer) {
+            return Some(StyledLayer { passes: vec![], body: content.clone(), content, key: ckey, ckey, plain: true });
+        }
+        let modes = styles::pass_modes(ctx, layer);
+        let key = ckey.map(|k| cache::styles_key(ctx, layer, k));
+        if let (Some(c), Some(k)) = (self.cache, key)
+            && let Some(body) = c.get(k)
+        {
+            let passes: Option<Vec<_>> = modes.iter().enumerate().map(|(i, m)| c.get(cache::derive(k, i as u64 + 1)).map(|b| (b, *m))).collect();
+            if let Some(passes) = passes {
+                return Some(StyledLayer { passes, body, content, key, ckey, plain: false });
+            }
+        }
+        let t0 = web_time::Instant::now();
+        let size = ctx.source_size(layer);
+        let layer_size = if size.0 == 0 { [ctx.comp.width as f64, ctx.comp.height as f64] } else { [size.0 as f64, size.1 as f64] };
+        let st = styles::render(ctx, layer, &content, layer_size);
+        if let Some(t) = timing {
+            t.cached = false;
+            t.effects.push(("layerStyles".into(), t0.elapsed().as_secs_f64() * 1e3));
+        }
+        let mut body = Arc::new(st.body);
+        let mut passes: Vec<_> = st.passes.into_iter().map(|(b, m)| (Arc::new(b), m)).collect();
+        // The buffers the cache keeps (another worker's, if it kept them first).
+        if let (Some(c), Some(k)) = (self.cache_to_keep(), key) {
+            body = c.insert(k, body);
+            for (i, (b, _)) in passes.iter_mut().enumerate() {
+                *b = c.insert(cache::derive(k, i as u64 + 1), b.clone());
+            }
+        }
+        Some(StyledLayer { passes, body, content, key, ckey, plain: false })
+    }
+
+    /// The styled layer's buffers in the blending space.
+    pub(crate) fn styled_to_blend(&self, st: StyledLayer) -> StyledLayer {
+        if self.pipe.to_blend().is_none() {
+            return st;
+        }
+        let body = self.to_blend(st.body, st.key);
+        let content = if st.plain { body.clone() } else { self.to_blend(st.content, st.ckey) };
+        let passes = st.passes.into_iter().enumerate().map(|(i, (b, m))| (self.to_blend(b, st.key.map(|k| cache::derive(k, i as u64 + 1))), m)).collect();
+        StyledLayer { passes, body, content, ..st }
+    }
+
+    pub(crate) fn sampling(&self, layer: &Layer) -> effectcraft_raster::Sampling {
+        if self.quality(layer) == Quality::Draft {
+            // Draft quality: no interpolation (nearest neighbour), as After Effects' Draft.
+            effectcraft_raster::Sampling::Nearest
+        } else if self.opts.draft {
+            effectcraft_raster::Sampling::Bilinear
+        } else if layer.switches.sampling == Sampling::Bicubic {
+            effectcraft_raster::Sampling::Bicubic
+        } else {
+            effectcraft_raster::Sampling::Bilinear
+        }
+    }
+
+    /// The region of interest of a top-level 2D frame: (x, y) offset of the output in output
+    /// pixels and its size. `None` renders the whole comp (no ROI, or a nested comp).
+    pub(crate) fn roi_offset(&self) -> Option<(f64, f64, u32, u32)> {
+        let r = self.opts.roi.filter(|_| self.top)?;
+        let s = self.opts.scale;
+        if r[2] <= 0.0 || r[3] <= 0.0 {
+            return None;
+        }
+        Some(((r[0] * s).round(), (r[1] * s).round(), ((r[2] * s).round() as u32).max(1), ((r[3] * s).round() as u32).max(1)))
+    }
+
+    /// The region of interest's offset in output pixels for 3D projection (0 without one).
+    pub(crate) fn out_offset(&self) -> (f64, f64) {
+        self.roi_offset().map_or((0.0, 0.0), |(x, y, _, _)| (x, y))
+    }
+
+    /// Scaled comp pixel → output pixel: the region of interest's offset.
+    fn out_matrix(&self) -> Mat3 {
+        match self.roi_offset() {
+            Some((x, y, _, _)) => Mat3::translate(vec2(-x, -y)),
+            None => Mat3::IDENTITY,
+        }
+    }
+
+    /// Buffer pixel → output pixel matrix for the layer at the context time.
+    fn buf_matrix(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf) -> Mat3 {
+        let (l2c, _) = ctx.layer_to_comp(layer);
+        self.place_matrix(self.outer.map_or(l2c, |o| o * l2c), buf)
+    }
+
+    /// Buffer pixel → output pixel matrix for a layer → (top-level) comp matrix.
+    fn place_matrix(&self, l2c: Mat3, buf: &Buf) -> Mat3 {
+        let s = self.opts.scale;
+        self.out_matrix()
+            * Mat3::scale(vec2(s, s))
+            * l2c
+            * Mat3::scale(vec2(1.0 / buf.scale, 1.0 / buf.scale))
+            * Mat3::translate(vec2(-buf.offset[0], -buf.offset[1]))
+    }
+
+    /// The collapsed precomp layers this comp is drawn through, outermost first.
+    fn links(&self) -> impl Iterator<Item = &Through<'a>> {
+        self.through.iter().map_while(Option::as_ref)
+    }
+
+    /// The shutter of a layer's motion blur: its comp's, or for a collapsed precomp's layers the
+    /// outermost containing comp's.
+    fn shutter(&self, ctx: &EvalCtx) -> Shutter {
+        let c: &Comp = match self.links().next() {
+            Some(l) => l.comp,
+            None => ctx.comp,
+        };
+        Shutter {
+            angle: c.shutter_angle / 360.0,
+            phase: c.shutter_phase / 360.0,
+            frame: c.frame_duration().seconds(),
+            samples: c.motion_blur_samples,
+            limit: c.motion_blur_adaptive_limit,
+        }
+    }
+
+    /// Whether a layer moves within the shutter: its own motion blur, or that of a collapsed
+    /// precomp layer it is drawn through.
+    fn blurred(&self, ctx: &EvalCtx, layer: &Layer) -> bool {
+        self.mb_on(ctx, layer) || (!self.through_lost && self.links().any(|l| l.blur))
+    }
+
+    /// The collapsed precomps' matrix (nested comp → the frame's comp) and the nested comp's time
+    /// `dt` seconds into the outermost comp's shutter: each precomp layer moves if it is motion
+    /// blurred, and times map down through each one (stretch, time remapping).
+    fn outer_at(&self, ctx: &EvalCtx, dt: f64) -> (Option<Mat3>, Tick) {
+        let shift = Tick::from_seconds_f64(dt);
+        let mut outer: Option<Mat3> = None;
+        let mut t: Option<Tick> = None;
+        for l in self.links() {
+            let at = EvalCtx { comp_id: l.comp_id, comp: l.comp, time: t.unwrap_or(l.time + shift), ..*ctx };
+            let (m, _) = if l.blur { at.layer_to_comp(l.layer) } else { EvalCtx { time: l.time, ..at }.layer_to_comp(l.layer) };
+            outer = Some(outer.map_or(m, |o| o * m));
+            t = Some(at.nested_time(l.layer));
+        }
+        (outer, t.unwrap_or(ctx.time + shift))
+    }
+
+    /// [`Self::buf_matrix`] for the motion-blur sub-sample `dt` seconds into the shutter: the
+    /// layer moves if it is motion blurred, the collapsed precomps above it if theirs are.
+    fn buf_matrix_at(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf, dt: f64) -> Mat3 {
+        if self.through_lost || self.links().next().is_none() {
+            return self.buf_matrix(&ctx.at(ctx.time + Tick::from_seconds_f64(dt)), layer, buf);
+        }
+        let (outer, t) = self.outer_at(ctx, dt);
+        let lctx = if self.mb_on(ctx, layer) { ctx.at(t) } else { *ctx };
+        let (l2c, _) = lctx.layer_to_comp(layer);
+        self.place_matrix(outer.map_or(l2c, |o| o * l2c), buf)
+    }
+
+    /// Shape and text content that animates within the shutter (paths, Trim Paths, text
+    /// animators…) of a motion-blurred layer: the times its source is drawn at and averaged,
+    /// Samples Per Frame of them, as After Effects does for shape layers. `None` when the content
+    /// holds still (compared through its cache key, which leaves the transform out).
+    pub(crate) fn content_times(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Vec<Tick>> {
+        if !matches!(layer.source, LayerSource::Shape | LayerSource::Text) || !self.mb_on(ctx, layer) {
+            return None;
+        }
+        let sh = self.shutter(ctx);
+        if sh.angle <= 0.0 {
+            return None;
+        }
+        let n = if self.opts.draft { 4 } else { (sh.samples as usize).clamp(2, 64) };
+        let times: Vec<Tick> = (0..n).map(|i| self.outer_at(ctx, sh.offset(i, n)).1).collect();
+        let key = |t: Tick| cache::layer_key(&ctx.at(t), layer, 1.0, false, false);
+        let k0 = key(*times.first()?)?;
+        let moves = [times.get(n / 2), times.last()].into_iter().flatten().any(|t| key(*t) != Some(k0));
+        moves.then_some(times)
+    }
+
+    /// The layer's source drawn at each of `times` and averaged (premultiplied) on the union of
+    /// their bounds. Content that also changes its raster scale within the shutter, or would need
+    /// an outsized buffer, is drawn once.
+    pub(crate) fn blurred_source(&self, ctx: &EvalCtx, layer: &Layer, times: &[Tick]) -> Option<Buf> {
+        let bufs: Vec<Buf> = times.iter().filter_map(|t| self.source(&ctx.at(*t), layer)).collect();
+        let scale = bufs.first()?.scale;
+        // Pixel = layer point × scale + offset: with the largest offset every buffer lands at
+        // x + (off - its offset) ≥ 0.
+        let off = [0, 1].map(|i| bufs.iter().map(|b| b.offset[i]).fold(f64::MIN, f64::max));
+        let w = bufs.iter().map(|b| off[0] - b.offset[0] + b.img.width as f64).fold(0.0, f64::max).ceil();
+        let h = bufs.iter().map(|b| off[1] - b.offset[1] + b.img.height as f64).fold(0.0, f64::max).ceil();
+        if bufs.iter().any(|b| (b.scale - scale).abs() > 1e-9) || !(w * h).is_finite() || w * h > (1u64 << 26) as f64 {
+            return self.source(ctx, layer);
+        }
+        let mut acc = Image::new(w as u32, h as u32);
+        let k = 1.0 / bufs.len() as f32;
+        for b in &bufs {
+            let m = Mat3::translate(vec2(off[0] - b.offset[0], off[1] - b.offset[1]));
+            effectcraft_raster::accumulate_warp(&mut acc, &b.img, &m, effectcraft_raster::Sampling::Bilinear, k);
+        }
+        Some(Buf { img: acc, offset: off, scale })
+    }
+
+    /// A processed-layer cache key that also covers content motion blur (the averaged source
+    /// depends on the content at every sub-sample).
+    pub(crate) fn content_key(&self, ctx: &EvalCtx, layer: &Layer, key: Option<u64>) -> Option<u64> {
+        let k = key?;
+        let Some(times) = self.content_times(ctx, layer) else { return Some(k) };
+        times.iter().try_fold(cache::derive(k, 0x6d62_6c72), |d, t| Some(cache::derive(d, cache::layer_key(&ctx.at(*t), layer, 1.0, false, false)?)))
+    }
+
+    /// Whether a layer is motion blurred: the render options, the comp's switch and the layer's
+    /// switch (limited by the precomp layers above when switches affect nested comps). Layer
+    /// motion, mask motion blur, effects that read the shutter and Advanced 3D all ask this.
+    pub(crate) fn mb_on(&self, ctx: &EvalCtx, layer: &Layer) -> bool {
+        self.opts.motion_blur && ctx.comp.enable_motion_blur && self.layer_motion_blur(layer)
+    }
+
+    /// What a layer's mask motion blur may do in this render (see [`masks::MaskBlur`]).
+    pub(crate) fn mask_blur(&self, ctx: &EvalCtx, layer: &Layer) -> masks::MaskBlur {
+        masks::MaskBlur {
+            allowed: self.opts.motion_blur && ctx.comp.enable_motion_blur && self.inherited.is_none_or(|(_, mb)| mb),
+            layer: self.layer_motion_blur(layer),
+            samples: if self.opts.draft { 4 } else { ctx.comp.motion_blur_samples as usize },
+        }
+    }
+
+    /// Motion-blur sub-samples for a layer buffer (1 = no motion blur). As in After Effects, a 2D
+    /// layer gets about one sample per output pixel its corners travel during the shutter,
+    /// at least Samples Per Frame and at most the comp's Adaptive Sample Limit; a layer that
+    /// does not move within the shutter is drawn once.
+    fn mb_samples(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf) -> usize {
+        if !self.blurred(ctx, layer) {
+            return 1;
+        }
+        let travel = self.shutter_travel(ctx, layer, buf);
+        if travel < 1e-3 {
+            return 1;
+        }
+        if self.opts.draft {
+            return 4;
+        }
+        let sh = self.shutter(ctx);
+        adaptive_samples(travel, sh.samples, sh.limit)
+    }
+
+    /// Largest distance (output pixels) a corner of the layer buffer moves during the shutter,
+    /// measured along the path at a few points.
+    fn shutter_travel(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf) -> f64 {
+        let sh = self.shutter(ctx);
+        let (w, h) = (buf.img.width as f64, buf.img.height as f64);
+        let corners = [(0.0, 0.0), (w, 0.0), (0.0, h), (w, h), (w * 0.5, h * 0.5)];
+        const PROBES: usize = 8;
+        let mut prev: Option<Vec<effectcraft_geom::Vec2>> = None;
+        let mut travel = vec![0.0f64; corners.len()];
+        for i in 0..PROBES {
+            let m = self.buf_matrix_at(ctx, layer, buf, sh.offset(i, PROBES));
+            let pts: Vec<_> = corners.iter().map(|&(x, y)| m.apply(vec2(x, y))).collect();
+            if let Some(p) = &prev {
+                for (k, (a, b)) in p.iter().zip(&pts).enumerate() {
+                    travel[k] += (b.x - a.x).hypot(b.y - a.y);
+                }
+            }
+            prev = Some(pts);
+        }
+        travel.into_iter().fold(0.0, f64::max)
+    }
+
+    /// Canvas pixels that compositing `buf` for `layer` can change: the transformed buffer's
+    /// bounds plus the resampling footprint. Stencil/silhouette modes, motion blur and
+    /// perspective fall back to the whole canvas.
+    ///
+    /// A quantised buffer placed pixel-exactly (integer translation, Normal, 100%) over a blank
+    /// canvas leaves exactly its own (quantised) pixels: nothing to re-quantise.
+    fn footprint(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf, opacity: f32, blank: bool) -> Region {
+        if layer.blend_mode.is_stencil() || self.mb_samples(ctx, layer, buf) > 1 {
+            return Region::Full;
+        }
+        let m = self.buf_matrix(ctx, layer, buf);
+        if !m.is_affine() {
+            return Region::Full;
+        }
+        let matte = layer.track_matte.is_some_and(|tm| tm.layer != layer.id && ctx.comp.layer(tm.layer).is_some());
+        let k = &m.0;
+        let integral = |v: f64| v == v.round();
+        if blank
+            && layer.blend_mode == BlendMode::Normal
+            && opacity == 1.0
+            && !matte
+            && !layer.preserve_transparency
+            && self.pipe.to_blend().is_none()
+            && k[0][0] == 1.0
+            && k[1][1] == 1.0
+            && k[0][1] == 0.0
+            && k[1][0] == 0.0
+            && integral(k[0][2])
+            && integral(k[1][2])
+        {
+            return Region::Empty;
+        }
+        let (w, h) = (buf.img.width as f64, buf.img.height as f64);
+        let c = [(0.0, 0.0), (w, 0.0), (0.0, h), (w, h)].map(|(x, y)| m.apply(vec2(x, y)));
+        let (x0, x1) = (c.iter().map(|p| p.x).fold(f64::INFINITY, f64::min), c.iter().map(|p| p.x).fold(f64::NEG_INFINITY, f64::max));
+        let (y0, y1) = (c.iter().map(|p| p.y).fold(f64::INFINITY, f64::min), c.iter().map(|p| p.y).fold(f64::NEG_INFINITY, f64::max));
+        color::PxRect::covering(x0, y0, x1, y1, 3.0).map_or(Region::Full, Region::Rect)
+    }
+
+    /// How a processed layer buffer lands in the output: one buffer → output matrix, or one per
+    /// motion-blur sub-sample (averaged), with the layer's sampling filter and dissolve seed.
+    pub fn placement(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf) -> Placement {
+        let samples = self.mb_samples(ctx, layer, buf);
+        let (sampling, seed) = (self.sampling(layer), layer.id.0 as u32);
+        if samples <= 1 {
+            return Placement { matrices: vec![self.buf_matrix(ctx, layer, buf)], sampling, seed };
+        }
+        let sh = self.shutter(ctx);
+        let matrices = (0..samples).map(|i| self.buf_matrix_at(ctx, layer, buf, sh.offset(i, samples))).collect();
+        Placement { matrices, sampling, seed }
+    }
+
+    /// Draw a processed layer into `target` (transform, motion blur) with `mode`/`opacity`.
+    pub(crate) fn place(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf, target: &mut Image, mode: BlendMode, opacity: f32) {
+        self.place_changed(ctx, layer, buf, target, PlacementBlend { mode, opacity, quantize: None });
+    }
+
+    /// [`Self::place`], returning the target pixels it changed when the warp tracked them (then
+    /// also quantised to `quantize` levels; see [`composite_warp_changed`]).
+    fn place_changed(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf, target: &mut Image, blend: PlacementBlend) -> Option<[u32; 4]> {
+        let PlacementBlend { mode, opacity, quantize } = blend;
+        let pl = self.placement(ctx, layer, buf);
+        let opts = WarpOpts { sampling: pl.sampling, opacity, mode, seed: pl.seed, clip: None };
+        if let [m] = pl.matrices.as_slice() {
+            return composite_warp_changed(target, &buf.img, m, &opts, quantize);
+        }
+        // Sub-samples sum straight into one buffer (each warp is row-parallel).
+        let mut acc = Image::new(target.width, target.height);
+        let k = 1.0 / pl.matrices.len() as f32;
+        for m in &pl.matrices {
+            effectcraft_raster::accumulate_warp(&mut acc, &buf.img, m, opts.sampling, k);
+        }
+        target.blend_from(&acc, mode, opacity, pl.seed);
+        None
+    }
+
+    /// Draw a 2D layer into `canvas`; returns the region it may have changed.
+    pub(crate) fn draw_layer(&self, ctx: &EvalCtx, layer: &Layer, canvas: &mut Image, blank: bool) -> Region {
+        let opacity = ctx.opacity(layer) as f32 * self.opacity_mul;
+        if self.quality(layer) == Quality::Wireframe && !layer.switches.adjustment {
+            self.draw_wireframe(ctx, layer, canvas);
+            return Region::Full;
+        }
+        if opacity <= 0.0 && !layer.switches.adjustment {
+            return Region::Empty;
+        }
+        if layer.switches.adjustment {
+            self.draw_adjustment(ctx, layer, canvas, opacity);
+            return Region::Full;
+        }
+        let mut timing = self.profile.map(|_| LayerTiming { depth: self.depth, layer: layer.name.clone(), ..Default::default() });
+        let t0 = web_time::Instant::now();
+        let Some(st) = self.styled(ctx, layer, timing.as_mut()) else { return Region::Empty };
+        let st = self.styled_to_blend(st);
+        let t1 = web_time::Instant::now();
+        let changed = if st.plain {
+            // Pixels the warp tracks are quantised as it blends them (nothing left to do); the
+            // footprint is still needed when it doesn't, or when no pixel needs quantising.
+            let footprint = self.footprint(ctx, layer, &st.body, opacity, blank);
+            let quantize = if footprint == Region::Empty { None } else { self.pipe.levels };
+            match self.composite_layer(ctx, layer, &st.body, canvas, opacity, quantize) {
+                Some(_) if quantize.is_some() => Region::Empty,
+                drawn => narrow(footprint, drawn),
+            }
+        } else {
+            self.composite_styled(ctx, layer, &st, canvas, opacity);
+            Region::Full
+        };
+        if let (Some(prof), Some(mut timing)) = (self.profile, timing) {
+            timing.process_ms = (t1 - t0).as_secs_f64() * 1e3;
+            timing.composite_ms = t1.elapsed().as_secs_f64() * 1e3;
+            if let Ok(mut v) = prof.lock() {
+                v.push(timing);
+            }
+        }
+        changed
+    }
+
+    /// Composite a styled layer: exterior passes with their own modes, then the body with the
+    /// layer's mode; the layer's opacity fades the whole stack. Knockout clears what is below the
+    /// layer's content; switched-off R/G/B channels keep the values below.
+    fn composite_styled(&self, ctx: &EvalCtx, layer: &Layer, st: &StyledLayer, canvas: &mut Image, opacity: f32) {
+        let bl = styles::blending(ctx, layer);
+        let matte = layer.track_matte.is_some_and(|tm| tm.layer != layer.id && ctx.comp.layer(tm.layer).is_some());
+        if matte || layer.preserve_transparency {
+            let mut iso = Image::new(canvas.width, canvas.height);
+            for (b, m) in &st.passes {
+                self.place(ctx, layer, b, &mut iso, *m, 1.0);
+            }
+            self.place(ctx, layer, &st.body, &mut iso, BlendMode::Normal, 1.0);
+            self.composite_iso(ctx, layer, iso, canvas, opacity);
+            return;
+        }
+        let mut tmp = canvas.clone();
+        if bl.knockout > 0 {
+            let mut k = Image::new(canvas.width, canvas.height);
+            self.place(ctx, layer, &st.content, &mut k, BlendMode::Normal, 1.0);
+            tmp.data.par_iter_mut().zip(k.data.par_iter()).for_each(|(p, q)| {
+                let keep = 1.0 - q[3].clamp(0.0, 1.0);
+                for c in p.iter_mut() {
+                    *c *= keep;
+                }
+            });
+        }
+        for (b, m) in &st.passes {
+            self.place(ctx, layer, b, &mut tmp, *m, 1.0);
+        }
+        self.place(ctx, layer, &st.body, &mut tmp, layer.blend_mode, 1.0);
+        let ch = bl.channels;
+        canvas.data.par_iter_mut().zip(tmp.data.par_iter()).for_each(|(c, t)| {
+            for i in 0..4 {
+                let v = if i < 3 && !ch[i] { c[i] } else { t[i] };
+                c[i] += (v - c[i]) * opacity;
+            }
+        });
+    }
+
+    /// Composite a plain layer; returns the canvas pixels it changed when they are known (then
+    /// also quantised to `quantize` levels).
+    fn composite_layer(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf, canvas: &mut Image, opacity: f32, quantize: Option<f32>) -> Option<[u32; 4]> {
+        let matte = layer.track_matte.is_some_and(|tm| tm.layer != layer.id && ctx.comp.layer(tm.layer).is_some());
+        if !matte && !layer.preserve_transparency {
+            return self.place_changed(ctx, layer, buf, canvas, PlacementBlend { mode: layer.blend_mode, opacity, quantize });
+        }
+        // Render in isolation, then matte / preserve transparency, then blend.
+        let mut iso = Image::new(canvas.width, canvas.height);
+        self.place(ctx, layer, buf, &mut iso, BlendMode::Normal, 1.0);
+        self.composite_iso(ctx, layer, iso, canvas, opacity);
+        None
+    }
+
+    /// Apply the track matte / preserve transparency to an isolated layer render, then blend.
+    pub(crate) fn composite_iso(&self, ctx: &EvalCtx, layer: &Layer, iso: Image, canvas: &mut Image, opacity: f32) {
+        self.composite_iso_with(ctx, layer, iso, canvas, opacity, None);
+    }
+
+    /// [`Self::composite_iso`] with the track matte's pixels already drawn (`matte`, e.g. a 3D
+    /// matte seen through the camera); otherwise the matte layer is placed in 2D.
+    pub(crate) fn composite_iso_with(&self, ctx: &EvalCtx, layer: &Layer, mut iso: Image, canvas: &mut Image, opacity: f32, matte_img: Option<Image>) {
+        self.apply_track_matte(ctx, layer, &mut iso, matte_img);
+        if layer.preserve_transparency {
+            iso.data.par_iter_mut().zip(canvas.data.par_iter()).for_each(|(p, q)| {
+                for c in p.iter_mut() {
+                    *c *= q[3];
+                }
+            });
+        }
+        canvas.blend_from(&iso, layer.blend_mode, opacity, layer.id.0 as u32);
+    }
+
+    /// Multiply `img` (comp-sized) by the layer's track matte, if it has one; `matte_img` as in
+    /// [`Self::composite_iso_with`].
+    fn apply_track_matte(&self, ctx: &EvalCtx, layer: &Layer, img: &mut Image, matte_img: Option<Image>) {
+        let matte = layer.track_matte.and_then(|tm| ctx.comp.layer(tm.layer).filter(|m| m.id != layer.id).map(|m| (m, tm.kind)));
+        if let Some((m, kind)) = matte {
+            let mimg = match matte_img {
+                Some(i) if i.width == img.width && i.height == img.height => i,
+                _ => {
+                    let mut mimg = Image::new(img.width, img.height);
+                    if m.is_active_at(ctx.time)
+                        && let Some(mb) = self.layer_buf(ctx, m)
+                    {
+                        let mo = ctx.opacity(m) as f32;
+                        self.place(ctx, m, &mb, &mut mimg, BlendMode::Normal, mo);
+                    }
+                    mimg
+                }
+            };
+            img.data.par_iter_mut().zip(mimg.data.par_iter()).for_each(|(p, q)| {
+                let k = match kind {
+                    MatteKind::Alpha => q[3],
+                    MatteKind::AlphaInverted => 1.0 - q[3],
+                    MatteKind::Luma => effectcraft_color::luminance(q[0], q[1], q[2]),
+                    MatteKind::LumaInverted => 1.0 - effectcraft_color::luminance(q[0], q[1], q[2]),
+                }
+                .clamp(0.0, 1.0);
+                for c in p.iter_mut() {
+                    *c *= k;
+                }
+            });
+        }
+    }
+
+    /// Adjustment layer: effects applied to the comp below, limited to the layer's footprint
+    /// and its track matte, and blended back in the layer's blend mode.
+    fn draw_adjustment(&self, ctx: &EvalCtx, layer: &Layer, canvas: &mut Image, opacity: f32) {
+        let Some(mut foot) = self.source(ctx, layer) else { return };
+        let _ = masks::apply(ctx, layer, &mut foot, self.mask_blur(ctx, layer));
+        let mut matte = Image::new(canvas.width, canvas.height);
+        self.place(ctx, layer, &foot, &mut matte, BlendMode::Normal, 1.0);
+        self.apply_track_matte(ctx, layer, &mut matte, None);
+        let o = self.roi_offset().map(|(x, y, _, _)| [-x, -y]).unwrap_or([0.0; 2]);
+        let mut below = Buf { img: canvas.clone(), offset: o, scale: self.opts.scale };
+        // Effects run in the working space, not the linear blending space.
+        if let Some(c) = self.pipe.from_blend() {
+            color::convert(&mut below.img, &c);
+        }
+        let mut adjusted = self.apply_effects(ctx, layer, below, true);
+        // An effect that changed the frame (Motion Tile's Output size): back onto the canvas.
+        if let Some((dx, dy)) =
+            effectcraft_effects::adjustment_crop(adjusted.offset, o, (adjusted.img.width, adjusted.img.height), (canvas.width, canvas.height))
+        {
+            adjusted.img = adjusted.img.crop(dx, dy, canvas.width, canvas.height);
+        }
+        if let Some(c) = self.pipe.to_blend() {
+            color::convert(&mut adjusted.img, &c);
+        }
+        if adjusted.img.width != canvas.width || adjusted.img.height != canvas.height {
+            return;
+        }
+        if layer.blend_mode != BlendMode::Normal {
+            // The adjusted comp is a layer in that mode over the comp below, as in After Effects:
+            // an adjustment layer with no effects in Screen screens the comp with itself (#2618).
+            let mut iso = adjusted.img;
+            iso.data.par_iter_mut().zip(matte.data.par_iter()).for_each(|(p, m)| {
+                for c in p.iter_mut() {
+                    *c *= m[3];
+                }
+            });
+            canvas.blend_from(&iso, layer.blend_mode, opacity, layer.id.0 as u32);
+            return;
+        }
+        canvas.data.par_iter_mut().zip(adjusted.img.data.par_iter()).zip(matte.data.par_iter()).for_each(|((c, a), m)| {
+            let k = m[3] * opacity;
+            for i in 0..4 {
+                c[i] += (a[i] - c[i]) * k;
+            }
+        });
+    }
+}
+
+/// A layer ready to composite (see [`Renderer::styled_layer`]).
+pub struct StyledLayer {
+    /// Exterior style passes (Drop Shadow, Outer Glow) with their blend modes.
+    pub passes: Vec<(Arc<Buf>, BlendMode)>,
+    pub body: Arc<Buf>,
+    /// Pre-style pixels (knockout shape).
+    pub content: Arc<Buf>,
+    /// Styled cache key (the content key when plain).
+    pub(crate) key: Option<u64>,
+    /// Content cache key.
+    ckey: Option<u64>,
+    /// No layer styles: composite `body` the usual way.
+    pub plain: bool,
+}
+
+/// Where a layer buffer lands (see [`Renderer::placement`]).
+#[derive(Clone, Debug)]
+pub struct Placement {
+    /// Buffer pixel → output pixel; several = motion-blur sub-samples (equal weights).
+    pub matrices: Vec<Mat3>,
+    pub sampling: effectcraft_raster::Sampling,
+    /// Dissolve noise seed.
+    pub seed: u32,
+}
+
+/// The part of `footprint` a warp actually changed (`drawn`, see [`composite_warp_changed`]):
+/// pixels it left alone are still quantised.
+fn narrow(footprint: Region, drawn: Option<[u32; 4]>) -> Region {
+    let Some([x0, y0, x1, y1]) = drawn else { return footprint };
+    if x0 >= x1 || y0 >= y1 {
+        return Region::Empty;
+    }
+    let r = color::PxRect { x0, y0, x1, y1 };
+    match footprint {
+        Region::Empty => Region::Empty,
+        Region::Full => Region::Rect(r),
+        Region::Rect(f) => {
+            let q = color::PxRect { x0: r.x0.max(f.x0), y0: r.y0.max(f.y0), x1: r.x1.min(f.x1), y1: r.y1.min(f.y1) };
+            if q.x0 >= q.x1 || q.y0 >= q.y1 { Region::Empty } else { Region::Rect(q) }
+        }
+    }
+}
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index bf3aa42ee..dd5335623 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -32,539 +32,35 @@ use effectcraft_effects::{Buf, EffectCtx, EffectEnv, EffectHost, LayerPixels, Pa
 use effectcraft_geom::{Mat3, Mat4, vec2};
 use effectcraft_project::{Comp, Footage, FootageKind, FrameBlend, GroupKind, ItemId, ItemKind, Layer, LayerSource, MatteKind, Project, Quality, Sampling};
 pub use effectcraft_raster::Image;
-use effectcraft_raster::{WarpOpts, composite_warp};
+use effectcraft_raster::{WarpOpts, composite_warp_changed};
 use effectcraft_time::{FrameRate, TICKS_PER_SECOND, Tick};
 pub use eval::{EvalCtx, ExprHost, effect_bounds, source_size};
 use rayon::prelude::*;
 
-/// How a [`FootageSource`] hands over float footage (OpenEXR, float TIFF), whose values are
-/// linear light: encoded with a curve, as the compositor takes footage, or as stored. Other
-/// footage is decoded the same way whatever it says. Interpret Footage ▸ Preserve RGB always
-/// reads the values as stored.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
-pub enum FloatCurve {
-    /// The sRGB curve (managed projects, and Working Gamma 2.2).
-    #[default]
-    Srgb,
-    /// A pure 2.4 power curve (no working space, Working Gamma 2.4).
-    Gamma24,
-    /// The linear values as stored (Interpret As Linear Light encodes them afterwards).
-    Linear,
-}
+mod accel;
+mod footage;
+mod frames;
+mod fx_host;
+mod layers;
+mod opts;
+mod pipeline;
 
-/// Supplies decoded footage frames (implemented by the media layer).
-pub trait FootageSource: Send + Sync {
-    /// The frame of `item` at source time `t`, straight from the file (any size).
-    fn frame(&self, item: ItemId, footage: &Footage, t: Tick) -> Option<Arc<Image>>;
-    /// [`FootageSource::frame`] for a render that shows it at `width` × `height`, at most half its
-    /// size: either that frame or, when the source can make it more cheaply than the whole frame
-    /// (movies, see `effectcraft-media`), the frame already resampled to that size as
-    /// [`effectcraft_raster::resample`] would.
-    fn frame_at_size(&self, item: ItemId, footage: &Footage, t: Tick, _width: u32, _height: u32) -> Option<Arc<Image>> {
-        self.frame(item, footage, t)
-    }
-    /// [`FootageSource::frame`] (`size: None`) or [`FootageSource::frame_at_size`] with float
-    /// footage handed over as `float` says ([`FootageSource::frame`] uses [`FloatCurve::Srgb`]).
-    /// Sources without float footage can leave the default, which ignores `float`.
-    fn frame_with(&self, item: ItemId, footage: &Footage, t: Tick, size: Option<(u32, u32)>, float: FloatCurve) -> Option<Arc<Image>> {
-        let _ = float;
-        match size {
-            Some((w, h)) => self.frame_at_size(item, footage, t, w, h),
-            None => self.frame(item, footage, t),
-        }
-    }
-    /// `frames` interleaved stereo sample frames of `item`'s audio from source time `t` at
-    /// `rate` Hz (`None` when unavailable). The first sample is `t.to_units_floor(rate)`;
-    /// a sample boundary uses the earliest representable tick that selects that sample.
-    fn audio(&self, _item: ItemId, _footage: &Footage, _t: Tick, _frames: usize, _rate: u32) -> Option<Vec<f32>> {
-        None
-    }
-    /// Auxiliary 3D channels of `item` at source time `t` (multi-layer OpenEXR: depth, IDs,
-    /// Cryptomatte, any named channel), with `scale` relative to the file's pixels. `None` when
-    /// the footage has none.
-    fn aux(&self, _item: ItemId, _footage: &Footage, _t: Tick) -> Option<Arc<effectcraft_raster::AuxChannels>> {
-        None
-    }
-    /// The parsed 3D model of a [`effectcraft_project::FootageKind::Model`] item (Advanced 3D).
-    fn model(&self, _item: ItemId, _footage: &Footage) -> Option<Arc<effectcraft_model::Model>> {
-        None
-    }
-    /// Set the decoded-frame cache budget in bytes (Settings ▸ Memory & CPU); sources without
-    /// a cache ignore it.
-    fn set_cache_budget(&self, _bytes: usize) {}
-    /// Drop the decoded frames it keeps (Edit ▸ Purge ▸ All Memory / Image Cache Memory): the
-    /// next reads decode again. Sources without a cache ignore it.
-    fn purge(&self) {}
-    /// The file at `path` changed on disk (Reload Footage): drop what it keeps of it (decoded
-    /// frames, open decoders, parsed models), so the next reads see the new contents. Sources
-    /// without a cache ignore it.
-    fn forget(&self, _path: &str) {}
-    /// Settings ▸ Disk ▸ Conformed Audio Folder: where decoded audio is kept between reads
-    /// (`None` = off); sources that don't decode audio ignore it.
-    fn set_conform_folder(&self, _folder: Option<std::path::PathBuf>) {}
-    /// The decoded-frame cache budget in bytes, if the source has a cache.
-    fn cache_budget(&self) -> Option<usize> {
-        None
-    }
-    /// Vector footage (SVG) rasterised at `scale` × its pixel size, for Continuously Rasterize.
-    /// `None` when the footage is not vector or cannot be read.
-    fn vector_frame(&self, _item: ItemId, _footage: &Footage, _scale: f64) -> Option<Arc<Image>> {
-        None
-    }
-    /// Run `f`, which reads frames from this source, as work that can be called off: once
-    /// `cancel` is set, long decodes it starts (a movie seeking back to a keyframe and decoding
-    /// forward) stop early and their frames come back `None`. Sources that can't stop a decode
-    /// just run `f`. See [`CancellableFootage`].
-    fn cancellable(&self, _cancel: &Arc<AtomicBool>, f: &mut dyn FnMut()) {
-        f()
-    }
-    /// Reads through this source have been called off: frames may have come back `None` that
-    /// exist, so what was made from them must not be kept.
-    fn called_off(&self) -> bool {
-        false
-    }
-    /// Why `footage` shows no picture although its file is there: a read of it failed because
-    /// no decoder handles its codec, profile, chroma format or bit depth, or the stream is damaged
-    /// (e.g. "H.264 (High 4:2:2) isn't supported by the built-in decoder: ..."). `None` while it
-    /// decodes, and for sources that don't track failures. Stays set until the file is forgotten.
-    fn problem(&self, _footage: &Footage) -> Option<String> {
-        None
-    }
-}
-
-/// A render's view of a [`FootageSource`] whose frame reads can be called off with `cancel`
-/// (a viewer frame nobody waits for any more, #329). Every read goes through
-/// [`FootageSource::cancellable`] on its own, so reads made for this render on another thread
-/// (a parallel loop) answer to this render's flag, and reads for other renders never do.
-pub struct CancellableFootage<'a> {
-    pub inner: &'a dyn FootageSource,
-    pub cancel: Arc<AtomicBool>,
-}
-
-impl CancellableFootage<'_> {
-    fn read<R>(&self, f: impl FnOnce() -> Option<R>) -> Option<R> {
-        if self.cancel.load(Ordering::Relaxed) {
-            return None;
-        }
-        let (mut f, mut out) = (Some(f), None);
-        self.inner.cancellable(&self.cancel, &mut || out = f.take().and_then(|f| f()));
-        out
-    }
-}
-
-impl FootageSource for CancellableFootage<'_> {
-    fn frame(&self, item: ItemId, footage: &Footage, t: Tick) -> Option<Arc<Image>> {
-        self.read(|| self.inner.frame(item, footage, t))
-    }
-    fn frame_at_size(&self, item: ItemId, footage: &Footage, t: Tick, width: u32, height: u32) -> Option<Arc<Image>> {
-        self.read(|| self.inner.frame_at_size(item, footage, t, width, height))
-    }
-    fn audio(&self, item: ItemId, footage: &Footage, t: Tick, frames: usize, rate: u32) -> Option<Vec<f32>> {
-        self.inner.audio(item, footage, t, frames, rate)
-    }
-    fn aux(&self, item: ItemId, footage: &Footage, t: Tick) -> Option<Arc<effectcraft_raster::AuxChannels>> {
-        self.inner.aux(item, footage, t)
-    }
-    fn model(&self, item: ItemId, footage: &Footage) -> Option<Arc<effectcraft_model::Model>> {
-        self.inner.model(item, footage)
-    }
-    fn set_cache_budget(&self, bytes: usize) {
-        self.inner.set_cache_budget(bytes)
-    }
-    fn purge(&self) {
-        self.inner.purge()
-    }
-    fn forget(&self, path: &str) {
-        self.inner.forget(path)
-    }
-    fn set_conform_folder(&self, folder: Option<std::path::PathBuf>) {
-        self.inner.set_conform_folder(folder)
-    }
-    fn cache_budget(&self) -> Option<usize> {
-        self.inner.cache_budget()
-    }
-    fn vector_frame(&self, item: ItemId, footage: &Footage, scale: f64) -> Option<Arc<Image>> {
-        self.inner.vector_frame(item, footage, scale)
-    }
-    fn cancellable(&self, cancel: &Arc<AtomicBool>, f: &mut dyn FnMut()) {
-        self.inner.cancellable(cancel, f)
-    }
-    fn called_off(&self) -> bool {
-        self.cancel.load(Ordering::Relaxed) || self.inner.called_off()
-    }
-    fn problem(&self, footage: &Footage) -> Option<String> {
-        self.inner.problem(footage)
-    }
-    fn frame_with(&self, item: ItemId, footage: &Footage, t: Tick, size: Option<(u32, u32)>, float: FloatCurve) -> Option<Arc<Image>> {
-        self.read(|| self.inner.frame_with(item, footage, t, size, float))
-    }
-}
-
-/// Footage that can be rasterised at any scale (SVG).
-pub fn is_vector_footage(f: &Footage) -> bool {
-    matches!(f.codec.as_str(), "SVG" | "PDF" | "AI" | "EPS")
-}
-
-/// Layer parameters and audio for effects (see [`effectcraft_effects::EffectHost`]). What it
-/// hands out is in effect space (see [`effect_bounds`]): the other layer's for its pixels, the
-/// running layer's for its own frames and the comp scene.
-struct FxHost<'r, 'a, 'c> {
-    r: &'r Renderer<'a>,
-    ctx: &'c EvalCtx<'a>,
-    layer: &'c Layer,
-    /// Where the stack's effect space starts in layer coordinates (zero on adjustment layers,
-    /// whose effects run on the comp below).
-    origin: [f64; 2],
-    /// Index of the effect being rendered (bounds `self_at` to effects before it).
-    index: usize,
-    original: Option<&'c Buf>,
-}
-
-impl FxHost<'_, '_, '_> {
-    /// Another layer's pixels for a layer parameter, in its effect space; `layer_space`: `buf`
-    /// is still in layer space (its source or its content).
-    fn pixels(&self, other: &Layer, mut buf: Buf, layer_space: bool) -> LayerPixels {
-        let (size, origin) = self.ctx.effect_bounds(other);
-        if layer_space {
-            buf.rebase(origin);
-        }
-        LayerPixels { buf, size }
-    }
-}
-
-/// The comp's camera and first light relative to `layer`, in its layer pixels (see
-/// [`EffectHost::comp_scene`]): the comp camera's view of the layer (as if 3D at its transform),
-/// brought back into the layer's own pixel grid through the inverse of how the layer itself
-/// composites.
-pub(crate) fn comp_scene(ctx: &EvalCtx, layer: &Layer) -> Option<effectcraft_effects::CompScene> {
-    let world = ctx.world_matrix(layer);
-    let (cam, _, _) = ctx.camera();
-    let p = (cam * world).0;
-    let back = ctx.layer_to_comp(layer).0.inverse()?.0;
-    let rows = [p[0], p[1], p[3]];
-    let camera: [[f64; 4]; 3] = std::array::from_fn(|i| std::array::from_fn(|j| (0..3).map(|k| back[i][k] * rows[k][j]).sum()));
-    let inv = world.inverse();
-    let light = three_d::light::lights_at(ctx).first().and_then(|l| {
-        let inv = inv.as_ref()?;
-        let pos = inv.apply(l.pos);
-        let dir = inv.apply_vec(l.dir);
-        let len = (dir.x * dir.x + dir.y * dir.y + dir.z * dir.z).sqrt().max(1e-12);
-        let kind = match l.kind {
-            effectcraft_project::LightKind::Parallel => 0,
-            effectcraft_project::LightKind::Ambient => 2,
-            _ => 1,
-        };
-        Some(effectcraft_effects::CompLight { pos: [pos.x, pos.y, pos.z], dir: [dir.x / len, dir.y / len, dir.z / len], color: l.color, kind })
-    });
-    let camera_layer = ctx.comp.active_camera(ctx.time).is_some();
-    Some(effectcraft_effects::CompScene { camera: Some(camera), camera_layer, light })
-}
-
-/// Nesting limit for effects that render layers (other layers, other times).
-const MAX_FX_DEPTH: usize = 8;
-
-impl EffectHost for FxHost<'_, '_, '_> {
-    fn original(&self) -> Option<&Buf> {
-        self.original
-    }
-
-    fn particles(&self) -> Option<&dyn effectcraft_effects::psim::ParticleSim> {
-        self.r.active_accel().and_then(|a| a.particles())
-    }
-    fn layer(&self, id: u64, masks_and_effects: bool) -> Option<LayerPixels> {
-        let other = self.ctx.layer(effectcraft_project::LayerId(id))?;
-        if (other.id == self.layer.id && masks_and_effects) || self.r.depth > MAX_FX_DEPTH {
-            return None;
-        }
-        let sub = self.r.nested();
-        // The cached layer buffer is shared; effects get their own copy.
-        let buf = if masks_and_effects { (*sub.content_buf(self.ctx, other)?).clone() } else { sub.source(self.ctx, other)? };
-        Some(self.pixels(other, buf, true))
-    }
-
-    fn layer_masks(&self, id: u64) -> Option<LayerPixels> {
-        let other = self.ctx.layer(effectcraft_project::LayerId(id))?;
-        if self.r.depth > MAX_FX_DEPTH {
-            return None;
-        }
-        let sub = self.r.nested();
-        let buf = (*sub.layer_input(self.ctx, other, 0)?).clone();
-        Some(self.pixels(other, buf, false))
-    }
-
-    fn audio(&self, id: u64, start: f64, frames: usize, rate: u32) -> Option<Vec<f32>> {
-        let other = self.ctx.layer(effectcraft_project::LayerId(id))?;
-        let LayerSource::Footage { item } = &other.source else { return None };
-        let ItemKind::Footage(f) = &self.r.project.item(*item)?.kind else { return None };
-        if !f.has_audio {
-            return None;
-        }
-        let st = other.layer_time(Tick::from_seconds_f64(start));
-        self.r.footage.audio(*item, f, st, frames, rate)
-    }
-
-    fn self_at(&self, layer_time: f64, effects: usize) -> Option<Buf> {
-        if self.r.depth > MAX_FX_DEPTH || self.layer.switches.adjustment {
-            return None;
-        }
-        let n = effects.min(self.index);
-        let t = self.layer.comp_time(Tick::from_seconds_f64(layer_time));
-        let sub = self.r.nested();
-        sub.layer_input(&self.ctx.at(t), self.layer, n).map(|b| (*b).clone())
-    }
-
-    fn aux(&self) -> Option<Arc<effectcraft_raster::AuxChannels>> {
-        self.r.layer_aux(self.ctx, self.layer)
-    }
-
-    fn params_at(&self, layer_time: f64) -> Option<Params> {
-        let g = self.layer.effects()?.groups().nth(self.index)?;
-        let ctx = self.ctx.at(self.layer.comp_time(Tick::from_seconds_f64(layer_time)));
-        Some(effectcraft_effects::flatten_params(g, &mut |pr| ctx.value(self.layer, pr)))
-    }
-
-    fn comp_scene(&self) -> Option<effectcraft_effects::CompScene> {
-        Some(comp_scene(self.ctx, self.layer)?.rebased(self.origin))
-    }
-
-    fn layer_at(&self, id: u64, comp_time: f64, masks_and_effects: bool) -> Option<LayerPixels> {
-        let other = self.ctx.layer(effectcraft_project::LayerId(id))?;
-        if (other.id == self.layer.id && masks_and_effects) || !comp_time.is_finite() || self.r.depth > MAX_FX_DEPTH {
-            return None;
-        }
-        let ctx = self.ctx.at(Tick::from_seconds_f64(comp_time));
-        let sub = self.r.nested();
-        Some(if masks_and_effects {
-            self.pixels(other, (*sub.content_buf(&ctx, other)?).clone(), true)
-        } else if other.id == self.layer.id {
-            self.pixels(other, sub.source(&ctx, other)?, true)
-        } else {
-            // Preserve other-layer reads: time effects historically see source + masks.
-            self.pixels(other, (*sub.layer_input(&ctx, other, 0)?).clone(), false)
-        })
-    }
-}
-
-/// The Essential Properties overrides of a precomp layer, evaluated at the context time.
-pub fn essential_overrides(ctx: &EvalCtx, layer: &Layer) -> Vec<effectcraft_project::essential::Override> {
-    use effectcraft_project::essential;
-    let over = essential::overridden(layer);
-    let Some(g) = essential::group(layer).filter(|_| !over.is_empty()) else { return vec![] };
-    let mut out = vec![];
-    g.walk("", &mut |_, p| {
-        if over.contains(&p.uid)
-            && let Some(control) = essential::control_of(&p.match_id)
-        {
-            out.push(essential::Override { control, value: ctx.value(layer, p) });
-        }
-    });
-    out
-}
-
-/// No footage available (renders footage layers as transparent).
-pub struct NoFootage;
-impl FootageSource for NoFootage {
-    fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
-        None
-    }
-}
-
-/// Which compositor renders a frame (Project Settings ▸ Video Rendering and Effects).
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum Backend {
-    /// The CPU reference compositor (Mercury Software Only).
-    #[default]
-    Cpu,
-    /// The GPU compositor whenever an [`Accelerator`] is attached, whatever the project says.
-    Gpu,
-    /// The GPU compositor when an [`Accelerator`] is attached and the project's renderer is
-    /// Mercury GPU Acceleration (the viewer's choice); the CPU otherwise.
-    Auto,
-}
-
-impl Backend {
-    pub fn parse(s: &str) -> Option<Backend> {
-        match s.to_ascii_lowercase().as_str() {
-            "cpu" | "software" | "mercury software only" => Some(Backend::Cpu),
-            "gpu" | "mercury gpu acceleration" => Some(Backend::Gpu),
-            "auto" => Some(Backend::Auto),
-            _ => None,
-        }
-    }
-}
-
-/// One effect of a GPU effect chain (see [`Accelerator::effects`]).
-pub struct FxStep<'x> {
-    pub spec: &'static effectcraft_effects::EffectSpec,
-    pub ctx: EffectCtx<'x>,
-}
-
-/// A GPU (or other hardware) backend for the compositor. The CPU [`Renderer`] stays the
-/// reference: an accelerator renders what it supports and returns `None` for the rest, which
-/// then runs on the CPU. Implemented by `effectcraft-gpu`.
-pub trait Accelerator: Send + Sync {
-    /// Adapter / backend name for status readouts ("Apple M2 (Metal)").
-    fn name(&self) -> String;
-    /// Render a top-level comp frame (what [`Renderer::comp_frame`] returns). `None` = not
-    /// handled (the CPU renders it).
-    fn comp_frame(&self, r: &Renderer, comp: ItemId, t: Tick) -> Option<Image>;
-    /// The accelerator implements effect `id` with the CPU effect's semantics.
-    fn supports_effect(&self, id: &str) -> bool;
-    /// Run a chain of supported effects on `buf`, clamping and quantising to `levels` after
-    /// every effect when set (8/16 bpc). `None` = not handled.
-    fn effects(&self, chain: &[FxStep], buf: &Buf, levels: Option<f32>) -> Option<Buf>;
-    /// Rasterise and shade an Advanced 3D scene at its raster size (depth buffer, PBR, image
-    /// based light, shadow maps), with the CPU rasteriser's semantics
-    /// ([`three_d::adv::raster::render`]). `None` = not handled (the CPU renders it).
-    fn raster_3d(&self, _scene: &three_d::adv::Scene) -> Option<three_d::adv::Target> {
-        None
-    }
-    /// Render a whole prepared Advanced 3D run (every motion-blur sub-sample rasterised and
-    /// resolved, averaged, depth of field, encoding) with [`three_d::adv::render_prepared`]'s
-    /// semantics. `None` = not handled (the CPU path runs, using [`Self::raster_3d`]).
-    fn render_3d(&self, _run: &three_d::adv::Prepared) -> Option<three_d::adv::Rendered> {
-        None
-    }
-    /// A particle simulation backend (GPU particles) for the stepped particle effects, with
-    /// the CPU simulation's semantics. `None` = they simulate on the CPU.
-    fn particles(&self) -> Option<&dyn effectcraft_effects::psim::ParticleSim> {
-        None
-    }
-    /// Timing history [`Backend::Auto`] uses to send each comp's top-level frames to the
-    /// faster compositor. `None` = Auto always tries the accelerator first.
-    fn auto_pick(&self) -> Option<&AutoPick> {
-        None
-    }
-    /// Whether the accelerator can still render frames. `false` once it has stopped for good
-    /// (its device was lost or retired): every frame it is asked for falls back to the CPU, so
-    /// callers that limit frames in flight for it can stop doing so.
-    fn available(&self) -> bool {
-        true
-    }
-    /// Deferred readbacks: where a GPU readback cannot be waited for (WebGPU in a browser
-    /// worker), a frame renders in *passes*. A readback the accelerator does not have yet is
-    /// started, the step returns a cheap placeholder and the pass is marked missed
-    /// ([`Self::pass_missed`]); the caller waits for the readbacks in flight (asynchronously)
-    /// and renders the frame again, and the steps whose results arrived are served from them.
-    /// The frame is done after a pass with no miss. `frame_begin` forgets the previous frame's
-    /// results, `pass_begin` clears the miss. Synchronous accelerators never miss.
-    fn frame_begin(&self) {}
-    fn pass_begin(&self) {}
-    fn pass_missed(&self) -> bool {
-        false
-    }
-    /// Raised from a pass's first miss to its end (results computed meanwhile may hold
-    /// placeholders): give it to [`LayerCache::set_gate`] so they are not cached.
-    fn miss_gate(&self) -> Option<Arc<std::sync::atomic::AtomicBool>> {
-        None
-    }
-    /// With deferred readbacks: a future that resolves once the readbacks in flight have
-    /// landed (the browser delivers them from its event loop; natively the device is polled
-    /// before it returns, so the future is ready). `None` = nothing to wait for. See
-    /// [`passes::in_passes`].
-    fn settle(&self) -> Option<std::pin::Pin<Box<dyn std::future::Future<Output = ()> + '_>>> {
-        None
-    }
-}
-
-/// Where an effect stack runs (see [`Renderer::run_effects_on`]): a CPU buffer, or an image
-/// resident on an accelerator.
-pub trait FxTarget {
-    /// Run a chain of accelerator-supported effects (quantising after each to the bit depth).
-    /// `false` = not handled: the effects then run one by one through [`FxTarget::cpu`].
-    fn gpu(&mut self, steps: &[FxStep]) -> bool;
-    /// Run one CPU effect: `f` maps the buffer.
-    fn cpu(&mut self, f: &mut dyn FnMut(Buf) -> Buf);
-    /// Grow the buffer to cover its whole layer rectangle (`size` layer pixels from its own
-    /// corner, the `layer_size` handed to effects), as [`effectcraft_effects::Buf::cover`].
-    /// Authored buffers (text, shapes) only span their painted content; this gives the stack
-    /// the room a sized source's buffer already has (#659).
-    fn cover(&mut self, size: [f64; 2]) {
-        self.cpu(&mut |mut buf| {
-            buf.cover(size);
-            buf
-        });
-    }
-}
-
-/// The CPU effect target (GPU chains go through [`Accelerator::effects`]: upload, readback).
-struct CpuFx<'a> {
-    accel: Option<&'a dyn Accelerator>,
-    levels: Option<f32>,
-    buf: Option<Buf>,
-}
-
-impl FxTarget for CpuFx<'_> {
-    fn gpu(&mut self, steps: &[FxStep]) -> bool {
-        let (Some(a), Some(b)) = (self.accel, &self.buf) else { return false };
-        match a.effects(steps, b, self.levels) {
-            Some(out) => {
-                self.buf = Some(out);
-                true
-            }
-            None => false,
-        }
-    }
-    fn cpu(&mut self, f: &mut dyn FnMut(Buf) -> Buf) {
-        if let Some(b) = self.buf.take() {
-            self.buf = Some(f(b));
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, serde::Serialize, serde::Deserialize)]
-#[serde(default, rename_all = "camelCase")]
-pub struct RenderOpts {
-    /// Output scale relative to comp pixels (1 = Full, 0.5 = Half…).
-    pub scale: f64,
-    pub motion_blur: bool,
-    /// Render guide layers (viewer only). Only the top-level comp's own guide layers: nested
-    /// comps (precomps, collapsed precomps, comps read by effects) never draw theirs, as in
-    /// After Effects (see [`Renderer::nested_opts`]).
-    pub guides: bool,
-    /// Draft quality: fewer motion-blur samples, bilinear only.
-    pub draft: bool,
-    /// 3D view camera override (viewer Front/Top/Custom views); None = the comp's active camera.
-    pub view: Option<three_d::CameraState>,
-    /// CPU or GPU compositor (the GPU needs [`Renderer::accel`]).
-    pub backend: Backend,
-    /// Region of interest `[x, y, w, h]` in comp pixels (viewer only): the top-level frame covers
-    /// just this rectangle, and only its pixels are composited.
-    pub roi: Option<[f64; 4]>,
-    /// Which proxies stand in for footage and compositions (Render Settings ▸ Proxy Use).
-    pub proxy: effectcraft_project::render_queue::ProxyUse,
-    /// Switches Affect Nested Comps (Settings ▸ General): a precomp layer's Quality and Motion
-    /// Blur switches also limit the layers of the nested comp (Draft/Wireframe or motion blur off
-    /// propagate down; they never raise a nested layer's own setting).
-    pub nested_switches: bool,
-    /// Realtime Shadows in Draft (Settings ▸ 3D): draft renders (`draft`) still cast shadows.
-    pub draft_shadows: bool,
-}
-
-impl RenderOpts {
-    /// Whether 3D layers cast shadows in this render.
-    pub fn shadows(&self) -> bool {
-        !self.draft || self.draft_shadows
-    }
-}
-
-impl Default for RenderOpts {
-    fn default() -> Self {
-        RenderOpts {
-            scale: 1.0,
-            motion_blur: true,
-            guides: false,
-            draft: false,
-            view: None,
-            roi: None,
-            backend: Backend::Cpu,
-            nested_switches: true,
-            draft_shadows: true,
-            proxy: effectcraft_project::render_queue::ProxyUse::CurrentSettings,
-        }
-    }
-}
+pub use accel::{Accelerator, Backend, FxStep, FxTarget};
+pub use footage::{CancellableFootage, FloatCurve, FootageSource, NoFootage, is_vector_footage};
+pub use frames::{
+    adaptive_samples, blend_frames, cineon_frame, content_bounds, extended_region, field_frame, frame_position, frame_size, interpret_pixels, kurbo_path,
+    render_frame, roi_inside,
+};
+#[cfg(test)]
+use fx_host::FxHost;
+use fx_host::MAX_FX_DEPTH;
+pub(crate) use fx_host::comp_scene;
+pub use fx_host::essential_overrides;
+pub use layers::{Placement, StyledLayer};
+pub(crate) use opts::Collapse3d;
+pub use opts::{LayerTiming, RenderOpts};
+use opts::{MAX_THROUGH, Through};
+pub use pipeline::{Collapsed, MediaOverride, PropertyOverride};
 
 pub struct Renderer<'a> {
     pub project: &'a Project,
@@ -603,1858 +99,5 @@ pub struct Renderer<'a> {
     through_lost: bool,
 }
 
-/// One collapsed precomp layer a nested comp is drawn through.
-#[derive(Clone, Copy)]
-struct Through<'a> {
-    comp_id: ItemId,
-    comp: &'a Comp,
-    /// The containing comp's time at this frame.
-    time: Tick,
-    layer: &'a Layer,
-    /// The precomp layer is motion blurred: its own motion blurs the nested layers.
-    blur: bool,
-}
-
-/// Collapsed precomps within collapsed precomps that motion blur follows (more than
-/// [`Renderer::collapsed`]'s nesting limit).
-const MAX_THROUGH: usize = 16;
-
-/// A motion-blur shutter: the comp's, or for a collapsed precomp's layers the outermost
-/// containing comp's (they are drawn into its frames).
-#[derive(Clone, Copy)]
-struct Shutter {
-    /// Shutter angle and phase as fractions of a frame.
-    angle: f64,
-    phase: f64,
-    /// Frame duration (seconds).
-    frame: f64,
-    /// Samples Per Frame and Adaptive Sample Limit.
-    samples: u32,
-    limit: u32,
-}
-
-impl Shutter {
-    /// Seconds from the frame time to sub-sample `i` of `n`, spread over the open shutter.
-    fn offset(&self, i: usize, n: usize) -> f64 {
-        let f = if n > 1 { i as f64 / (n - 1) as f64 } else { 0.0 };
-        (self.phase + self.angle * f) * self.frame
-    }
-}
-
-/// How a collapsed precomp's 3D layers are placed in the parent (see `Renderer::collapse_into`).
-#[derive(Clone, Copy)]
-pub(crate) struct Collapse3d<'a> {
-    /// Nested comp world → parent world (the precomp layer's world transform).
-    pub world: Mat4,
-    /// The parent's camera.
-    pub cam: three_d::CameraState,
-    /// The outermost comp's context (its lights light the nested layers).
-    pub parent: EvalCtx<'a>,
-}
-
-/// Time spent on one layer of one frame (milliseconds).
-#[derive(Clone, Debug, Default)]
-pub struct LayerTiming {
-    pub depth: usize,
-    pub layer: String,
-    /// Source + masks + effects (cache lookup only, on a hit).
-    pub process_ms: f64,
-    /// Per effect: (effect id, ms). Empty on a cache hit.
-    pub effects: Vec<(String, f64)>,
-    /// Transform + matte + blend.
-    pub composite_ms: f64,
-    /// The processed buffer came from the layer cache.
-    pub cached: bool,
-}
-
-impl<'a> Renderer<'a> {
-    pub fn new(project: &'a Project, footage: &'a dyn FootageSource, opts: RenderOpts) -> Renderer<'a> {
-        Renderer {
-            project,
-            footage,
-            expr: None,
-            opts,
-            cache: None,
-            profile: None,
-            accel: None,
-            depth: 0,
-            pipe: color::Pipe::of(&project.settings),
-            outer: None,
-            opacity_mul: 1.0,
-            collapse3d: None,
-            inherited: None,
-            defer_dof: false,
-            top: true,
-            through: [None; MAX_THROUGH],
-            through_lost: false,
-        }
-    }
-
-    /// The layer cache to keep this render's buffers in: none once its footage reads were
-    /// called off, as they may have come back empty ([`FootageSource::called_off`], #329).
-    fn cache_to_keep(&self) -> Option<&'a LayerCache> {
-        self.cache.filter(|_| !self.footage.called_off())
-    }
-
-    /// A layer's Quality switch, limited by the precomp layers above it when
-    /// [`RenderOpts::nested_switches`] is on.
-    pub fn quality(&self, layer: &Layer) -> Quality {
-        let rank = |q: Quality| match q {
-            Quality::Best => 0,
-            Quality::Draft => 1,
-            Quality::Wireframe => 2,
-        };
-        match self.inherited {
-            Some((q, _)) if rank(q) > rank(layer.switches.quality) => q,
-            _ => layer.switches.quality,
-        }
-    }
-
-    /// A layer's Motion Blur switch, limited by the precomp layers above it.
-    pub(crate) fn layer_motion_blur(&self, layer: &Layer) -> bool {
-        layer.switches.motion_blur && self.inherited.is_none_or(|(_, mb)| mb)
-    }
-
-    /// The renderer for the nested comp of precomp layer `layer`: its switches pass down when
-    /// [`RenderOpts::nested_switches`] is on.
-    fn nested_through(&self, layer: &Layer) -> Renderer<'a> {
-        let mut sub = self.nested();
-        if self.opts.nested_switches {
-            sub.inherited = Some((self.quality(layer), self.layer_motion_blur(layer)));
-        }
-        sub
-    }
-
-    /// The render options one level down (precomps, collapsed precomps, comps read by effects):
-    /// guide layers render only in their own comp, never when it is nested.
-    fn nested_opts(&self) -> RenderOpts {
-        RenderOpts { guides: false, ..self.opts }
-    }
-
-    /// A renderer for nested work (precomps, layers read by effects): one level deeper.
-    fn nested(&self) -> Renderer<'a> {
-        Renderer {
-            opts: self.nested_opts(),
-            depth: self.depth + 1,
-            outer: None,
-            opacity_mul: 1.0,
-            collapse3d: None,
-            defer_dof: false,
-            top: false,
-            through: [None; MAX_THROUGH],
-            through_lost: false,
-            ..*self
-        }
-    }
-
-    /// A precomp layer's nested comp for an accelerator to render resident (no CPU render and
-    /// upload of the nested frame): the renderer one level down, the comp, its time and the
-    /// buffer scale, exactly as [`Self::layer_source`]'s comp branch would render it. `None`
-    /// when that branch does more (composition proxy, Essential Properties overrides, frame
-    /// blending, recursion) or draws nothing (outside the nested comp's span): use the CPU path.
-    pub fn precomp_source(&self, ctx: &EvalCtx, layer: &Layer) -> Option<(Renderer<'a>, ItemId, Tick, f64)> {
-        let LayerSource::Comp { item } = layer.source else { return None };
-        if layer.switches.adjustment || self.project.comp_contains(item, ctx.comp_id) {
-            return None;
-        }
-        let nc = self.project.comp(item)?;
-        let lt = ctx.nested_time(layer);
-        if self.content_times(ctx, layer).is_some() {
-            return None;
-        }
-        if !nc.covers(lt) || self.proxy_for(item).is_some() || !essential_overrides(ctx, layer).is_empty() || frame_blend_mode(ctx, layer) != FrameBlend::Off {
-            return None;
-        }
-        let s = self.opts.scale;
-        let bs = if s < 1.0 && nc.preserve_resolution { 1.0 } else { s };
-        let base = self.nested_through(layer);
-        Some((Renderer { opts: RenderOpts { scale: bs, ..base.opts }, ..base }, item, lt, bs))
-    }
-
-    /// The nested comp of a precomp layer whose transformations collapse into this comp: the
-    /// Collapse Transformations switch is on and the layer has no masks, effects or layer
-    /// styles (those force a flattened render of the precomp, as in After Effects).
-    pub fn collapsed(&self, ctx: &EvalCtx, layer: &Layer) -> Option<ItemId> {
-        if !layer.switches.collapse || layer.switches.adjustment || self.depth > 12 {
-            return None;
-        }
-        let LayerSource::Comp { item } = &layer.source else { return None };
-        if self.project.comp_contains(*item, ctx.comp_id) || self.project.comp(*item).is_none() {
-            return None;
-        }
-        if layer.masks().is_some_and(|m| !m.children.is_empty()) {
-            return None;
-        }
-        if layer.switches.effects && layer.effects().is_some_and(|fx| fx.groups().any(|g| g.enabled)) {
-            return None;
-        }
-        if styles::active(ctx, layer) {
-            return None;
-        }
-        // Instance overrides (Essential Properties) need the nested comp rendered on its own.
-        if !effectcraft_project::essential::overridden(layer).is_empty() {
-            return None;
-        }
-        Some(*item)
-    }
-
-    /// A renderer and context that draw a collapsed precomp's layers straight into this comp:
-    /// their transforms are concatenated with the precomp layer's (one resample, no
-    /// rasterisation at the precomp's bounds), their opacity multiplied by `opacity`, and their
-    /// 3D layers use this comp's camera and lights.
-    pub fn collapse_into(&self, ctx: &EvalCtx<'a>, layer: &'a Layer, item: ItemId, opacity: f32) -> Option<(Renderer<'a>, EvalCtx<'a>)> {
-        let nc = self.project.comp(item)?;
-        let t = ctx.nested_time(layer);
-        if !nc.covers(t) {
-            return None;
-        }
-        let nctx = EvalCtx { comp_id: item, comp: nc, time: t, ..*ctx };
-        let (l2c, _) = ctx.layer_to_comp(layer);
-        let outer = Some(self.outer.map_or(l2c, |o| o * l2c));
-        let world = ctx.world_matrix(layer);
-        let c3 = Collapse3d {
-            world: self.collapse3d.map_or(world, |c| c.world * world),
-            cam: three_d::compose::camera_for(self, ctx),
-            parent: self.collapse3d.map_or(*ctx, |c| c.parent),
-        };
-        // Motion blur follows the precomp layer's own motion too.
-        let link = Through { comp_id: ctx.comp_id, comp: ctx.comp, time: ctx.time, layer, blur: self.mb_on(ctx, layer) };
-        let mut through = self.through;
-        let slot = through.iter_mut().find(|t| t.is_none());
-        let through_lost = self.through_lost || slot.is_none();
-        if let Some(slot) = slot {
-            *slot = Some(link);
-        }
-        Some((
-            Renderer { opts: self.nested_opts(), depth: self.depth + 1, outer, opacity_mul: opacity, collapse3d: Some(c3), through, through_lost, ..*self },
-            nctx,
-        ))
-    }
-
-    pub(crate) fn opacity_mul(&self) -> f32 {
-        self.opacity_mul
-    }
-
-    /// Draw a collapsed 2D precomp layer: nested layers blend straight into `canvas` with their
-    /// own modes (Normal precomp, no matte); otherwise they are drawn into an isolated buffer
-    /// that then takes the precomp layer's track matte, Preserve Transparency and blend mode.
-    /// Returns the region left to re-quantise (nested layers drawn straight into `canvas`
-    /// quantise their own footprints).
-    fn draw_collapsed(&self, ctx: &EvalCtx<'a>, layer: &Layer, item: ItemId, canvas: &mut Image, blank: bool) -> Region {
-        let opacity = ctx.opacity(layer) as f32 * self.opacity_mul;
-        if opacity <= 0.0 {
-            return Region::Empty;
-        }
-        let matte = layer.track_matte.is_some_and(|tm| tm.layer != layer.id && ctx.comp.layer(tm.layer).is_some());
-        if layer.blend_mode == BlendMode::Normal && !matte && !layer.preserve_transparency {
-            if let Some((sub, nctx)) = self.collapse_into(ctx, layer, item, opacity) {
-                sub.draw_comp(&nctx, canvas, blank);
-            }
-            return Region::Empty;
-        }
-        let Some((sub, nctx)) = self.collapse_into(ctx, layer, item, 1.0) else { return Region::Empty };
-        let mut iso = Image::new(canvas.width, canvas.height);
-        sub.draw_comp(&nctx, &mut iso, true);
-        self.composite_iso(ctx, layer, iso, canvas, opacity);
-        Region::Full
-    }
-
-    /// Whether `layer`'s processed buffer (source → masks → effects) is cached and the same as
-    /// one frame earlier: drawing it from the layer cache (an accelerator uploads it once) beats
-    /// re-running its effects every frame.
-    pub fn layer_is_static(&self, ctx: &EvalCtx, layer: &Layer) -> bool {
-        if self.cache.is_none() {
-            return false;
-        }
-        let (scale, draft, blur) = (self.raster_scale(ctx, layer), self.opts.draft, self.mb_on(ctx, layer));
-        let prev = ctx.time - ctx.comp.frame_rate.frame_duration();
-        let now = cache::layer_key(ctx, layer, scale, draft, blur);
-        now.is_some() && now == cache::layer_key(&ctx.at(prev), layer, scale, draft, blur)
-    }
-
-    /// Rasterisation scale of a layer's source: the output scale, or — for text and shape layers,
-    /// which are always continuously rasterised (#390, #751), and Continuously Rasterize vector
-    /// footage — the output scale times the layer's on-screen scale (quarter-octave steps, rounded
-    /// up, so vector content is drawn at its final size and stays sharp when scaled up).
-    pub fn raster_scale(&self, ctx: &EvalCtx, layer: &Layer) -> f64 {
-        let s = self.opts.scale;
-        let continuous = match layer.source {
-            LayerSource::Text | LayerSource::Shape => true,
-            LayerSource::Footage { item } => {
-                layer.switches.collapse && matches!(self.project.item(item).map(|i| &i.kind), Some(ItemKind::Footage(f)) if is_vector_footage(f))
-            }
-            _ => false,
-        };
-        if !continuous {
-            return s;
-        }
-        let (l2c, _) = ctx.layer_to_comp(layer);
-        let m = self.outer.map_or(l2c, |o| o * l2c);
-        let a = layer.transform().map(|tr| ctx.v3(layer, tr, "anchor", [0.0; 3])).unwrap_or([0.0; 3]);
-        let p0 = m.apply(vec2(a[0], a[1]));
-        let px = m.apply(vec2(a[0] + 1.0, a[1]));
-        let py = m.apply(vec2(a[0], a[1] + 1.0));
-        let k = ((px.x - p0.x).hypot(px.y - p0.y)).max((py.x - p0.x).hypot(py.y - p0.y));
-        if !k.is_finite() || k <= 1e-6 {
-            return s;
-        }
-        // The step is rounded up past rounding noise only: an unscaled layer whose position isn't
-        // a whole number maps the unit vectors to lengths a hair over 1, which must stay 1 (#390:
-        // rounded up to 2^¼, unscaled text was drawn larger and resampled, softer).
-        let mut k = 2f64.powf((k.log2() * 4.0 - 1e-6).ceil() / 4.0).clamp(1.0 / 16.0, 64.0);
-        // Keep the buffer within about 16 million pixels.
-        if let Some(b) = content_bounds(ctx, layer) {
-            let area = ((b[2] - b[0]) * (b[3] - b[1])).max(1.0) * s * s;
-            k = k.min((16.0e6 / area).sqrt().max(1.0));
-        }
-        s * k
-    }
-
-    /// Draw a Wireframe-quality layer: its bounds as a one-pixel outline.
-    fn draw_wireframe(&self, ctx: &EvalCtx, layer: &Layer, canvas: &mut Image) {
-        for (x, y) in self.wireframe_pixels(ctx, layer, (canvas.width, canvas.height)) {
-            canvas.set(x, y, [1.0, 1.0, 1.0, 1.0]);
-        }
-    }
-
-    fn ctx(&self, comp_id: ItemId, comp: &'a Comp, t: Tick) -> EvalCtx<'a> {
-        EvalCtx { project: self.project, comp_id, comp, time: t, expr: self.expr, footage: Some(self.footage) }
-    }
-
-    /// This renderer with another accelerator (or none): the passes of
-    /// [`passes::in_passes`] render with the accelerator, its CPU fallback without.
-    pub fn with_accel(&self, accel: Option<&'a dyn Accelerator>) -> Renderer<'a> {
-        Renderer { accel, ..*self }
-    }
-
-    /// The accelerator to use for this render, if any (see [`Backend`]).
-    pub fn active_accel(&self) -> Option<&'a dyn Accelerator> {
-        let a = self.accel?;
-        match self.opts.backend {
-            Backend::Cpu => None,
-            Backend::Gpu => Some(a),
-            Backend::Auto => self.project.settings.gpu_acceleration.then_some(a),
-        }
-    }
-
-    /// Render a composition at comp time `t` (transparent background, comp size × scale).
-    /// Top-level frames go to the GPU when [`Self::active_accel`] is set and handles them.
-    pub fn comp_frame(&self, comp_id: ItemId, t: Tick) -> Image {
-        // Classic 3D runs composite on the GPU too (M12.7), so Auto sends 3D comps there as well;
-        // Auto renders each comp on whichever compositor measured faster ([`AutoPick`]).
-        if self.depth == 0
-            && let Some(a) = self.active_accel()
-        {
-            let auto = self.frame_auto(a, comp_id, false);
-            if auto.is_none_or(|(p, key)| p.choose(key)) {
-                let t0 = web_time::Instant::now();
-                if let Some(img) = a.comp_frame(self, comp_id, t) {
-                    if let Some((p, key)) = auto {
-                        p.record(key, true, t0.elapsed().as_secs_f64() * 1e3);
-                    }
-                    return img;
-                }
-                if let Some((p, key)) = auto {
-                    p.declined(key);
-                }
-            }
-            let t0 = web_time::Instant::now();
-            let img = self.comp_frame_cpu(comp_id, t);
-            if let Some((p, key)) = auto {
-                p.record(key, false, t0.elapsed().as_secs_f64() * 1e3);
-            }
-            return img;
-        }
-        self.comp_frame_cpu(comp_id, t)
-    }
-
-    /// The Auto timing history and key for a top-level frame of `comp` (`None` unless the
-    /// backend is [`Backend::Auto`] and the accelerator keeps history).
-    pub fn frame_auto(&self, a: &'a dyn Accelerator, comp: ItemId, display: bool) -> Option<(&'a AutoPick, AutoKey)> {
-        if self.opts.backend != Backend::Auto || self.opts.roi.is_some() {
-            return None;
-        }
-        Some((a.auto_pick()?, AutoKey::new(comp, self.opts.scale, display)))
-    }
-
-    /// [`Self::comp_frame`] on the CPU compositor only.
-    pub fn comp_frame_cpu(&self, comp_id: ItemId, t: Tick) -> Image {
-        let Some(comp) = self.project.comp(comp_id) else { return Image::new(1, 1) };
-        let s = self.opts.scale;
-        let (w, h) = frame_size(comp.width, comp.height, s);
-        // Region of interest on a comp with 3D layers: render the frame and crop it. A region
-        // reaching past the comp frame (the Extended Viewer) renders Classic 3D natively — the
-        // planes project through the offset camera — and Advanced 3D as the frame, padded.
-        if self.depth == 0
-            && let Some(r) = self.opts.roi
-            && comp.has_3d()
-            && (roi_inside(r, comp.width, comp.height) || comp.renderer == effectcraft_project::Renderer::Advanced3D)
-        {
-            let full = Renderer { opts: RenderOpts { roi: None, ..self.opts }, ..*self }.comp_frame(comp_id, t);
-            let (x0, y0) = ((r[0] * s).round() as i64, (r[1] * s).round() as i64);
-            let (rw, rh) = (((r[2] * s).round() as u32).max(1), ((r[3] * s).round() as u32).max(1));
-            let mut out = Image::new(rw, rh);
-            for y in 0..rh as i64 {
-                let sy = y + y0;
-                if sy < 0 || sy >= full.height as i64 {
-                    continue;
-                }
-                for x in 0..rw as i64 {
-                    let sx = x + x0;
-                    if sx >= 0 && sx < full.width as i64 {
-                        out.data[(y * rw as i64 + x) as usize] = full.data[(sy * full.width as i64 + sx) as usize];
-                    }
-                }
-            }
-            return out;
-        }
-        let (w, h) = match self.roi_offset() {
-            Some((_, _, rw, rh)) => (rw, rh),
-            None => (w, h),
-        };
-        let mut canvas = Image::new(w, h);
-        if self.depth > 16 {
-            return canvas;
-        }
-        let ctx = self.ctx(comp_id, comp, t);
-        self.draw_comp(&ctx, &mut canvas, true);
-        // The canvas is already quantised after every layer; only re-encoding changes it.
-        if let Some(c) = self.pipe.from_blend() {
-            color::convert(&mut canvas, &c);
-            self.pipe.quantize(&mut canvas);
-        }
-        // The top-level comp leaves the working space for the (sRGB) display / output.
-        if self.depth == 0
-            && let Some(c) = self.pipe.output()
-        {
-            color::convert(&mut canvas, &c);
-            self.pipe.quantize(&mut canvas);
-        }
-        if self.depth == 0
-            && let Some((lin, mode, enc)) = self.pipe.output_hdr()
-        {
-            color::output_hdr(&mut canvas, lin, mode, enc);
-            self.pipe.quantize(&mut canvas);
-        }
-        canvas
-    }
-
-    /// Draw a comp's layers (bottom to top) into `canvas` (blending space).
-    /// `blank`: the canvas is fully transparent (lets the first layer skip re-quantising).
-    fn draw_comp(&self, ctx: &EvalCtx<'a>, canvas: &mut Image, mut blank: bool) {
-        // Bottom-to-top, with runs of consecutive 3D layers depth-sorted (farthest first).
-        let visible = self.visible_layers(ctx);
-        let mut i = 0;
-        while i < visible.len() {
-            if visible[i].is_3d() {
-                let mut j = i;
-                while j < visible.len() && visible[j].is_3d() {
-                    j += 1;
-                }
-                three_d::compose::draw_run(self, ctx, &visible[i..j], canvas);
-                i = j;
-                self.pipe.quantize(canvas);
-                blank = false;
-            } else {
-                let changed = match self.collapsed(ctx, visible[i]) {
-                    Some(item) => self.draw_collapsed(ctx, visible[i], item, canvas, blank),
-                    None => self.draw_layer(ctx, visible[i], canvas, blank),
-                };
-                i += 1;
-                // 8/16 bpc: the comp is an integer buffer after every layer (only the pixels the
-                // layer touched need re-quantising).
-                self.pipe.quantize_region(canvas, changed);
-                blank = false;
-            }
-        }
-    }
-
-    /// Evaluate an effect instance's parameters.
-    fn effect_params(&self, ctx: &EvalCtx, layer: &Layer, g: &effectcraft_project::PropGroup) -> Params {
-        // Nested groups (Paint strokes, Puppet meshes and pins) are flattened too.
-        effectcraft_effects::flatten_params(g, &mut |pr| ctx.value(layer, pr))
-    }
-
-    fn apply_effects(&self, ctx: &EvalCtx, layer: &Layer, buf: Buf, adjustment: bool) -> Buf {
-        self.apply_effects_timed(ctx, layer, buf, adjustment, usize::MAX, None)
-    }
-
-    /// Run the first `limit` effects of the layer's stack (by position; disabled ones count) on
-    /// `buf` (layer space, or the comp below for an adjustment layer).
-    fn apply_effects_timed(&self, ctx: &EvalCtx, layer: &Layer, mut buf: Buf, adjustment: bool, limit: usize, timing: Option<&mut Vec<(String, f64)>>) -> Buf {
-        // The comp below an adjustment layer is not in its layer space: it stays as it is.
-        let origin = if adjustment { [0.0; 2] } else { ctx.effect_bounds(layer).1 };
-        buf.rebase(origin);
-        let mut out = self.effect_space_stack(ctx, layer, buf, adjustment, limit, timing, origin);
-        out.rebase([-origin[0], -origin[1]]);
-        out
-    }
-
-    /// [`Renderer::apply_effects_timed`] on a buffer already in effect space (measured from
-    /// `origin`, in layer coordinates); the result stays in effect space.
-    #[allow(clippy::too_many_arguments)]
-    fn effect_space_stack(
-        &self,
-        ctx: &EvalCtx,
-        layer: &Layer,
-        buf: Buf,
-        adjustment: bool,
-        limit: usize,
-        timing: Option<&mut Vec<(String, f64)>>,
-        origin: [f64; 2],
-    ) -> Buf {
-        let mut t = CpuFx { accel: self.active_accel(), levels: self.pipe.levels, buf: Some(buf) };
-        self.run_effect_stack(ctx, layer, adjustment, limit, timing, origin, &mut t);
-        t.buf.unwrap_or_else(|| Buf { img: Image::new(1, 1), offset: [0.0; 2], scale: self.opts.scale })
-    }
-
-    /// Run the layer's video effect stack on `target` (in effect space, measured from `origin`
-    /// in layer coordinates): runs of GPU-capable effects go to [`FxTarget::gpu`] (when an
-    /// accelerator is active and supports them), the rest to [`FxTarget::cpu`] one by one
-    /// (quantised to the bit depth after each).
-    #[allow(clippy::too_many_arguments)]
-    fn run_effect_stack(
-        &self,
-        ctx: &EvalCtx,
-        layer: &Layer,
-        adjustment: bool,
-        limit: usize,
-        mut timing: Option<&mut Vec<(String, f64)>>,
-        origin: [f64; 2],
-        target: &mut dyn FxTarget,
-    ) {
-        if !layer.switches.effects {
-            return;
-        }
-        let Some(fx) = layer.effects() else { return };
-        let lt = layer.layer_time(ctx.time);
-        let layer_size = ctx.effect_bounds(layer).0;
-        // #659: an authored layer's buffer spans only its painted content while the stack works
-        // on the layer's whole region (`layer_size`): give the buffer the room a sized source
-        // already has, so tiling or displacement can place pixels outside the content instead
-        // of losing them at its edge. Only when something will actually run, and not for an
-        // adjustment layer, whose buffer is the comp below and already spans it.
-        if !adjustment
-            && fx.groups().any(|g| g.enabled && matches!(&g.kind, GroupKind::Effect { effect } if effectcraft_effects::find(effect).is_some_and(|s| !effectcraft_effects::audio_fx::is_audio_effect(s.id)))) {
-            target.cover(layer_size);
-        }
-        let mut mask_shapes = masks::shapes(ctx, layer);
-        if origin != [0.0; 2] {
-            for q in mask_shapes.iter_mut().flat_map(|m| m.points.iter_mut()) {
-                *q = [q[0] - origin[0], q[1] - origin[1]];
-            }
-        }
-        // Capture once, before preceding effects can expand or replace the input. An
-        // adjustment stack's original is the comp below, not its solid source.
-        let needs_original =
-            fx.groups().take(limit).any(|g| g.enabled && matches!(&g.kind, GroupKind::Effect { effect } if effect == "ec.channel.cccomposite"));
-        let mut original = None;
-        if needs_original {
-            target.cpu(&mut |buf| {
-                original = Some(buf.clone());
-                buf
-            });
-        }
-        let host = FxHost { r: self, ctx, layer, origin, index: 0, original: original.as_ref() };
-        let env = EffectEnv {
-            masks: &mask_shapes,
-            host: Some(&host),
-            comp_time: ctx.time.seconds(),
-            frame_rate: ctx.comp.frame_rate.as_f64(),
-            effect_index: 0,
-            working_space: self.pipe.space,
-            working_linear: self.pipe.linear,
-            float_depth: self.pipe.levels.is_none(),
-            shutter: self.mb_on(ctx, layer).then_some((ctx.comp.shutter_angle, ctx.comp.shutter_phase, ctx.comp.motion_blur_samples)),
-        };
-        // Video effects in stack order (index, group, spec); disabled and audio effects skipped.
-        let stack: Vec<(usize, &effectcraft_project::PropGroup, &'static effectcraft_effects::EffectSpec)> = fx
-            .groups()
-            .enumerate()
-            .take_while(|(i, _)| *i < limit)
-            .filter(|(_, g)| g.enabled)
-            .filter_map(|(i, g)| match &g.kind {
-                GroupKind::Effect { effect } => effectcraft_effects::find(effect).map(|s| (i, g, s)),
-                _ => None,
-            })
-            .filter(|(_, _, s)| !effectcraft_effects::audio_fx::is_audio_effect(s.id))
-            .collect();
-        let accel = self.active_accel();
-        let mut k = 0;
-        while k < stack.len() {
-            let (i, g, spec) = stack[k];
-            // A run of GPU effects goes to the accelerator in one go.
-            if let Some(a) = accel
-                && spec.gpu
-                && a.supports_effect(spec.id)
-            {
-                let run: Vec<_> = stack[k..].iter().take_while(|(_, _, s)| s.gpu && a.supports_effect(s.id)).collect();
-                let params: Vec<Params> = run.iter().map(|(_, g, _)| self.effect_params(ctx, layer, g)).collect();
-                let hosts: Vec<_> = run.iter().map(|(i, _, _)| FxHost { index: *i, ..host }).collect();
-                let steps: Vec<FxStep> = run
-                    .iter()
-                    .zip(&params)
-                    .zip(&hosts)
-                    .map(|(((i, g, s), params), host)| FxStep {
-                        spec: s,
-                        ctx: EffectCtx {
-                            params,
-                            time: lt.seconds(),
-                            layer_size,
-                            seed: g.uid as u32,
-                            adjustment,
-                            env: EffectEnv { host: Some(host), effect_index: *i, ..env },
-                        },
-                    })
-                    .collect();
-                let t0 = web_time::Instant::now();
-                if target.gpu(&steps) {
-                    if let Some(v) = timing.as_deref_mut() {
-                        let ms = t0.elapsed().as_secs_f64() * 1e3 / run.len() as f64;
-                        v.extend(run.iter().map(|(_, _, s)| (format!("{} (gpu)", s.id), ms)));
-                    }
-                    k += run.len();
-                    continue;
-                }
-            }
-            k += 1;
-            let params = self.effect_params(ctx, layer, g);
-            let host = FxHost { index: i, ..host };
-            let env = EffectEnv { host: Some(&host), effect_index: i, ..env };
-            let ectx = EffectCtx { params: &params, time: lt.seconds(), layer_size, seed: g.uid as u32, adjustment, env };
-            let t0 = web_time::Instant::now();
-            target.cpu(&mut |buf| {
-                let mut buf = effectcraft_effects::apply(spec, &ectx, buf);
-                // 8/16 bpc effects write integer pixels.
-                self.pipe.quantize(&mut buf.img);
-                buf
-            });
-            if let Some(v) = timing.as_deref_mut() {
-                v.push((spec.id.to_string(), t0.elapsed().as_secs_f64() * 1e3));
-            }
-        }
-    }
-
-    /// Source pixels of a layer in layer space (before masks/effects).
-    fn source(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Buf> {
-        let s = self.opts.scale;
-        match &layer.source {
-            LayerSource::Solid { item } => {
-                let ItemKind::Solid(sol) = &self.project.item(*item)?.kind else { return None };
-                let w = ((sol.width as f64 * s).ceil() as u32).max(1);
-                let h = ((sol.height as f64 * s).ceil() as u32).max(1);
-                if layer.switches.adjustment {
-                    return Some(Buf { img: Image::filled(w, h, [1.0; 4]), offset: [0.0; 2], scale: s });
-                }
-                let mut c = sol.color;
-                if let Some(conv) = self.pipe.authored_in() {
-                    c = conv.apply(c);
-                }
-                let px = self.pipe.quantize_px([c[0], c[1], c[2], 1.0]);
-                Some(Buf { img: Image::filled(w, h, px), offset: [0.0; 2], scale: s })
-            }
-            LayerSource::Comp { item } => {
-                if self.project.comp_contains(*item, ctx.comp_id) {
-                    return None;
-                }
-                // A composition proxy (a rendered still or movie) stands in for the comp.
-                // Nothing before the nested comp starts or after it ends.
-                let lt = ctx.nested_time(layer);
-                if !self.project.comp(*item).is_some_and(|nc| nc.covers(lt)) {
-                    return None;
-                }
-                if let Some(pf) = self.proxy_for(*item)
-                    && let Some(nc) = self.project.comp(*item)
-                {
-                    let img = self.footage.frame_with(*item, pf, lt, None, self.pipe.float_encoding())?;
-                    return Some(self.footage_buf(&img, pf, nc.width, nc.height));
-                }
-                // Essential Properties overrides render the nested comp with this instance's
-                // values.
-                let ov = essential_overrides(ctx, layer);
-                let tmp = if ov.is_empty() { None } else { effectcraft_project::essential::with_overrides(self.project, *item, &ov) };
-                // Preserve resolution when nested: drawn at full size even when this comp renders
-                // smaller (the buffer's scale places it).
-                let full = s < 1.0 && self.project.comp(*item).is_some_and(|nc| nc.preserve_resolution);
-                let bs = if full { 1.0 } else { s };
-                let base = self.nested_through(layer);
-                let base = Renderer { opts: RenderOpts { scale: bs, ..base.opts }, ..base };
-                let sub = match &tmp {
-                    Some(p) => Renderer { project: p, ..base },
-                    None => base,
-                };
-                // Frame blending between the nested comp's frames (time-stretched/remapped).
-                let mode = frame_blend_mode(ctx, layer);
-                if mode != FrameBlend::Off
-                    && let Some(nc) = self.project.comp(*item)
-                {
-                    let (i, w) = frame_position(lt, nc.frame_rate);
-                    if w > 1e-6 {
-                        let a = sub.comp_frame(*item, nc.frame_rate.tick_of(i));
-                        let b = sub.comp_frame(*item, nc.frame_rate.tick_of(i + 1));
-                        return Some(Buf { img: blend_frames(mode, &a, &b, w as f32), offset: [0.0; 2], scale: bs });
-                    }
-                }
-                Some(Buf { img: sub.comp_frame(*item, lt), offset: [0.0; 2], scale: bs })
-            }
-            LayerSource::Footage { item } => {
-                let it = self.project.item(*item)?;
-                let ItemKind::Footage(f) = &it.kind else { return None };
-                if !f.has_video {
-                    return None;
-                }
-                // Continuously rasterised vector footage: drawn at the on-screen scale.
-                if layer.switches.collapse && is_vector_footage(f) {
-                    let k = self.raster_scale(ctx, layer);
-                    if let Some(img) = self.footage.vector_frame(*item, f, k) {
-                        let mut buf = Buf { img: (*img).clone(), offset: [0.0; 2], scale: k };
-                        if let Some(c) = self.pipe.media_in(f) {
-                            color::convert(&mut buf.img, &c);
-                        }
-                        return Some(buf);
-                    }
-                }
-                let lt = ctx.source_time(layer);
-                // The proxy is decoded instead, at its own size, and fills the footage's frame.
-                let proxy = self.proxy_for(*item);
-                let pf = proxy.unwrap_or(f);
-                let size = self.reduced_size(f.width, f.height).filter(|_| proxy.is_none());
-                let img = self.footage_frame(ctx, layer, *item, pf, lt, size)?;
-                Some(self.footage_buf(&img, pf, f.width, f.height))
-            }
-            LayerSource::Text => Some(self.authored(text::render(ctx, layer, self.raster_scale(ctx, layer)))),
-            LayerSource::Shape => layer.props.sub("contents").map(|c| self.authored(shapes::render(ctx, layer, c, self.raster_scale(ctx, layer)))),
-            _ => None,
-        }
-    }
-
-    /// The proxy footage used for `item` under this render's Proxy Use, if any.
-    pub fn proxy_for(&self, item: ItemId) -> Option<&'a Footage> {
-        let it = self.project.item(item)?;
-        let px = it.proxy.as_deref()?;
-        (self.opts.proxy.uses(matches!(it.kind, ItemKind::Comp(_)), px.enabled) && px.footage.has_video).then_some(&px.footage)
-    }
-
-    /// A decoded frame of `f` as a layer buffer covering `w`×`h` layer pixels (the footage's
-    /// nominal size; proxies are scaled up to it), converted from its colour profile.
-    fn footage_buf(&self, img: &Image, f: &Footage, w: u32, h: u32) -> Buf {
-        let s = self.opts.scale;
-        let k = if img.width > 0 { w.max(1) as f64 / img.width as f64 } else { 1.0 };
-        // Keep native pixels when downsampling is small; resample otherwise.
-        let mut buf = match self.reduced_size(w, h) {
-            // The source resampled it already (`FootageSource::frame_at_size`).
-            Some(size) if (img.width, img.height) == size => Buf { img: img.clone(), offset: [0.0; 2], scale: s },
-            Some((rw, rh)) if k <= 1.0 + 1e-9 => Buf { img: effectcraft_raster::resample(img, rw, rh), offset: [0.0; 2], scale: s },
-            _ => Buf { img: img.clone(), offset: [0.0; 2], scale: 1.0 / k },
-        };
-        if let Some(c) = self.pipe.media_in(f) {
-            color::convert(&mut buf.img, &c);
-        }
-        buf
-    }
-
-    /// The size of `w` × `h` layer pixels in this render when it is reduced enough that footage
-    /// is resampled to it (below 3/4 scale).
-    fn reduced_size(&self, w: u32, h: u32) -> Option<(u32, u32)> {
-        let s = self.opts.scale;
-        (s < 0.75).then(|| (((w as f64 * s).round() as u32).max(1), ((h as f64 * s).round() as u32).max(1)))
-    }
-
-    /// Authored colours into the working space (linear working spaces).
-    fn authored(&self, mut buf: Buf) -> Buf {
-        if let Some(c) = self.pipe.authored_in() {
-            color::convert(&mut buf.img, &c);
-        }
-        buf
-    }
-
-    /// A footage frame at source time `t`, frame-blended between the two nearest source frames
-    /// when the layer's Frame Blending switch (and the comp's Enable Frame Blending) is on and
-    /// `t` falls between frames (footage rate ≠ comp rate, time stretch, time remapping).
-    /// `size`: a plain frame may come resampled to it ([`FootageSource::frame_at_size`]).
-    fn footage_frame(&self, ctx: &EvalCtx, layer: &Layer, item: ItemId, f: &Footage, t: Tick, size: Option<(u32, u32)>) -> Option<Arc<Image>> {
-        // Interpret Footage ▸ Separate Fields: each field is a frame at twice the rate.
-        if f.fields != effectcraft_project::FieldOrder::Off && matches!(f.kind, FootageKind::Video | FootageKind::Sequence) {
-            let field_rate = FrameRate::new(f.frame_rate.num * 2, f.frame_rate.den);
-            let i = field_rate.frame_at(t).max(0);
-            let img = self.footage.frame_with(item, f, f.frame_rate.tick_of(i / 2), None, self.pipe.float_curve(f))?;
-            let dominant_upper = f.fields == effectcraft_project::FieldOrder::UpperFirst;
-            // Upper field = even lines (0, 2, …).
-            let parity = if (i % 2 == 0) == dominant_upper { 0 } else { 1 };
-            return Some(Arc::new(interpret_pixels(&field_frame(&img, parity), f, self.pipe.linear_footage_space(f))));
-        }
-        // Interpretation is per pixel but not linear: it runs on the frame before resampling.
-        let size = size.filter(|_| !(f.invert_alpha || f.linear_light_applies()));
-        let img = self.footage_frame_raw(ctx, layer, item, f, t, size)?;
-        if f.invert_alpha || f.linear_light_applies() { Some(Arc::new(interpret_pixels(&img, f, self.pipe.linear_footage_space(f)))) } else { Some(img) }
-    }
-
-    fn footage_frame_raw(&self, ctx: &EvalCtx, layer: &Layer, item: ItemId, f: &Footage, t: Tick, size: Option<(u32, u32)>) -> Option<Arc<Image>> {
-        let mode = frame_blend_mode(ctx, layer);
-        let float = self.pipe.float_curve(f);
-        if mode != FrameBlend::Off && matches!(f.kind, FootageKind::Video | FootageKind::Sequence) {
-            let (i, w) = frame_position(t, f.frame_rate);
-            if w > 1e-6 {
-                // Blended frames are cached (Pixel Motion is expensive).
-                let key = self.cache.map(|_| {
-                    use std::hash::{Hash, Hasher};
-                    let mut h = std::collections::hash_map::DefaultHasher::new();
-                    (0x00f8_a3e5_u64, item, i, (w as f32).to_bits(), mode as u8, f.frame_rate.num, f.frame_rate.den, &f.path, float).hash(&mut h);
-                    h.finish()
-                });
-                if let (Some(c), Some(k)) = (self.cache, key)
-                    && let Some(b) = c.get(k)
-                {
-                    return Some(Arc::new(b.img.clone()));
-                }
-                let a = self.footage.frame_with(item, f, f.frame_rate.tick_of(i), None, float);
-                let b = self.footage.frame_with(item, f, f.frame_rate.tick_of(i + 1), None, float);
-                if let (Some(a), Some(b)) = (a, b) {
-                    let img = blend_frames(mode, &a, &b, w as f32);
-                    if let (Some(c), Some(k)) = (self.cache_to_keep(), key) {
-                        c.insert(k, Arc::new(Buf { img: img.clone(), offset: [0.0; 2], scale: 1.0 }));
-                    }
-                    return Some(Arc::new(img));
-                }
-            }
-        }
-        self.footage.frame_with(item, f, t, size, float)
-    }
-
-    /// Source → masks, clamped/quantised to the project depth.
-    fn masked_source(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Buf> {
-        let mut buf = match self.content_times(ctx, layer) {
-            Some(times) => self.blurred_source(ctx, layer, &times)?,
-            None => self.source(ctx, layer)?,
-        };
-        // A solid is filled with a quantised colour: only masks can take it off the grid.
-        let solid = matches!(layer.source, LayerSource::Solid { .. });
-        if masks::apply(ctx, layer, &mut buf, self.mask_blur(ctx, layer)) || !solid {
-            self.pipe.quantize(&mut buf.img);
-        }
-        Some(buf)
-    }
-
-    /// Fully processed layer buffer (source → masks → effects → layer styles, flattened).
-    /// Served from the layer cache when the layer's content key matches.
-    pub fn layer_buf(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<Buf>> {
-        self.layer_buf_keyed(ctx, layer).map(|(b, _)| b)
-    }
-
-    /// [`Self::layer_buf`] in the blending space (linear with Blend Colors Using 1.0 Gamma).
-    pub fn blend_layer_buf(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<Buf>> {
-        let (b, k) = self.layer_buf_keyed(ctx, layer)?;
-        Some(self.to_blend(b, k))
-    }
-
-    /// A buffer converted to the blending space (cached under a key derived from `key`).
-    pub(crate) fn to_blend(&self, b: Arc<Buf>, key: Option<u64>) -> Arc<Buf> {
-        let Some(c) = self.pipe.to_blend() else { return b };
-        let key = key.map(|k| cache::derive(k, 0x1ea7));
-        if let (Some(cache), Some(k)) = (self.cache, key)
-            && let Some(x) = cache.get(k)
-        {
-            return x;
-        }
-        let mut nb = (*b).clone();
-        color::convert(&mut nb.img, &c);
-        let nb = Arc::new(nb);
-        // The buffer the cache keeps (another worker's, if it kept one first).
-        match (self.cache_to_keep(), key) {
-            (Some(cache), Some(k)) => cache.insert(k, nb),
-            _ => nb,
-        }
-    }
-
-    fn layer_buf_keyed(&self, ctx: &EvalCtx, layer: &Layer) -> Option<(Arc<Buf>, Option<u64>)> {
-        let st = self.styled(ctx, layer, None)?;
-        if st.passes.is_empty() {
-            return Some((st.body, st.key));
-        }
-        let key = st.key.map(|k| cache::derive(k, 0xf1a7));
-        if let (Some(c), Some(k)) = (self.cache, key)
-            && let Some(b) = c.get(k)
-        {
-            return Some((b, key));
-        }
-        let flat = Arc::new(styles::Styled { passes: st.passes.iter().map(|(b, m)| ((**b).clone(), *m)).collect(), body: (*st.body).clone() }.flatten());
-        // The buffer the cache keeps (another worker's, if it kept one first).
-        let flat = match (self.cache_to_keep(), key) {
-            (Some(c), Some(k)) => c.insert(k, flat),
-            _ => flat,
-        };
-        Some((flat, key))
-    }
-
-    /// A layer's source pixels at the context time, before masks, effects and the transform
-    /// (what the motion tracker analyses, like After Effects' Layer panel). `None` for layers
-    /// without pixels.
-    pub fn layer_source(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Buf> {
-        self.source(ctx, layer)
-    }
-
-    /// Layer pixels after source → masks → effects (no layer styles).
-    pub fn content_buf(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<Buf>> {
-        self.content_buf_timed(ctx, layer, None).map(|(b, _)| b)
-    }
-
-    fn content_buf_timed(&self, ctx: &EvalCtx, layer: &Layer, mut timing: Option<&mut LayerTiming>) -> Option<(Arc<Buf>, Option<u64>)> {
-        let key = self.cache.and_then(|_| cache::layer_key(ctx, layer, self.raster_scale(ctx, layer), self.opts.draft, self.mb_on(ctx, layer)));
-        let key = self.content_key(ctx, layer, key);
-        if let (Some(c), Some(k)) = (self.cache, key)
-            && let Some(b) = c.get(k)
-        {
-            if let Some(t) = timing.as_deref_mut() {
-                t.cached = true;
-            }
-            return Some((b, key));
-        }
-        let buf = self.masked_source(ctx, layer)?;
-        let buf = Arc::new(self.apply_effects_timed(ctx, layer, buf, false, usize::MAX, timing.map(|t| &mut t.effects)));
-        // The buffer the cache keeps (another worker's, if it kept one first).
-        let buf = match (self.cache_to_keep(), key) {
-            (Some(c), Some(k)) => c.insert(k, buf),
-            _ => buf,
-        };
-        Some((buf, key))
-    }
-
-    /// A layer's input at the context time: source → masks → its first `effects` effects
-    /// (what Time effects read at neighbouring times), in effect space (see [`effect_bounds`]):
-    /// what effect `effects` sees. Served from / stored in the layer cache under its own key,
-    /// so scrubbing reuses frames rendered for earlier output frames.
-    pub fn layer_input(&self, ctx: &EvalCtx, layer: &Layer, effects: usize) -> Option<Arc<Buf>> {
-        let key = self.cache.and_then(|_| cache::input_key(ctx, layer, self.raster_scale(ctx, layer), self.opts.draft, self.mb_on(ctx, layer), effects));
-        let key = self.content_key(ctx, layer, key);
-        if let (Some(c), Some(k)) = (self.cache, key)
-            && let Some(b) = c.get(k)
-        {
-            return Some(b);
-        }
-        let mut buf = self.masked_source(ctx, layer)?;
-        let origin = ctx.effect_bounds(layer).1;
-        buf.rebase(origin);
-        if effects > 0 {
-            buf = self.effect_space_stack(ctx, layer, buf, false, effects, None, origin);
-        }
-        let buf = Arc::new(buf);
-        // The buffer the cache keeps (another worker's, if it kept one first).
-        let buf = match (self.cache_to_keep(), key) {
-            (Some(c), Some(k)) => c.insert(k, buf),
-            _ => buf,
-        };
-        Some(buf)
-    }
-
-    /// The layer with its styles: exterior passes and body (cached per pass).
-    fn styled(&self, ctx: &EvalCtx, layer: &Layer, mut timing: Option<&mut LayerTiming>) -> Option<StyledLayer> {
-        let (content, ckey) = self.content_buf_timed(ctx, layer, timing.as_deref_mut())?;
-        if !styles::active(ctx, layer) {
-            return Some(StyledLayer { passes: vec![], body: content.clone(), content, key: ckey, ckey, plain: true });
-        }
-        let modes = styles::pass_modes(ctx, layer);
-        let key = ckey.map(|k| cache::styles_key(ctx, layer, k));
-        if let (Some(c), Some(k)) = (self.cache, key)
-            && let Some(body) = c.get(k)
-        {
-            let passes: Option<Vec<_>> = modes.iter().enumerate().map(|(i, m)| c.get(cache::derive(k, i as u64 + 1)).map(|b| (b, *m))).collect();
-            if let Some(passes) = passes {
-                return Some(StyledLayer { passes, body, content, key, ckey, plain: false });
-            }
-        }
-        let t0 = web_time::Instant::now();
-        let size = source_size(self.project, layer);
-        let layer_size = if size.0 == 0 { [ctx.comp.width as f64, ctx.comp.height as f64] } else { [size.0 as f64, size.1 as f64] };
-        let st = styles::render(ctx, layer, &content, layer_size);
-        if let Some(t) = timing {
-            t.cached = false;
-            t.effects.push(("layerStyles".into(), t0.elapsed().as_secs_f64() * 1e3));
-        }
-        let mut body = Arc::new(st.body);
-        let mut passes: Vec<_> = st.passes.into_iter().map(|(b, m)| (Arc::new(b), m)).collect();
-        // The buffers the cache keeps (another worker's, if it kept them first).
-        if let (Some(c), Some(k)) = (self.cache_to_keep(), key) {
-            body = c.insert(k, body);
-            for (i, (b, _)) in passes.iter_mut().enumerate() {
-                *b = c.insert(cache::derive(k, i as u64 + 1), b.clone());
-            }
-        }
-        Some(StyledLayer { passes, body, content, key, ckey, plain: false })
-    }
-
-    /// The styled layer's buffers in the blending space.
-    fn styled_to_blend(&self, st: StyledLayer) -> StyledLayer {
-        if self.pipe.to_blend().is_none() {
-            return st;
-        }
-        let body = self.to_blend(st.body, st.key);
-        let content = if st.plain { body.clone() } else { self.to_blend(st.content, st.ckey) };
-        let passes = st.passes.into_iter().enumerate().map(|(i, (b, m))| (self.to_blend(b, st.key.map(|k| cache::derive(k, i as u64 + 1))), m)).collect();
-        StyledLayer { passes, body, content, ..st }
-    }
-
-    fn sampling(&self, layer: &Layer) -> effectcraft_raster::Sampling {
-        if self.quality(layer) == Quality::Draft {
-            // Draft quality: no interpolation (nearest neighbour), as After Effects' Draft.
-            effectcraft_raster::Sampling::Nearest
-        } else if self.opts.draft {
-            effectcraft_raster::Sampling::Bilinear
-        } else if layer.switches.sampling == Sampling::Bicubic {
-            effectcraft_raster::Sampling::Bicubic
-        } else {
-            effectcraft_raster::Sampling::Bilinear
-        }
-    }
-
-    /// The region of interest of a top-level 2D frame: (x, y) offset of the output in output
-    /// pixels and its size. `None` renders the whole comp (no ROI, or a nested comp).
-    pub(crate) fn roi_offset(&self) -> Option<(f64, f64, u32, u32)> {
-        let r = self.opts.roi.filter(|_| self.top)?;
-        let s = self.opts.scale;
-        if r[2] <= 0.0 || r[3] <= 0.0 {
-            return None;
-        }
-        Some(((r[0] * s).round(), (r[1] * s).round(), ((r[2] * s).round() as u32).max(1), ((r[3] * s).round() as u32).max(1)))
-    }
-
-    /// The region of interest's offset in output pixels for 3D projection (0 without one).
-    pub(crate) fn out_offset(&self) -> (f64, f64) {
-        self.roi_offset().map_or((0.0, 0.0), |(x, y, _, _)| (x, y))
-    }
-
-    /// Scaled comp pixel → output pixel: the region of interest's offset.
-    fn out_matrix(&self) -> Mat3 {
-        match self.roi_offset() {
-            Some((x, y, _, _)) => Mat3::translate(vec2(-x, -y)),
-            None => Mat3::IDENTITY,
-        }
-    }
-
-    /// Buffer pixel → output pixel matrix for the layer at the context time.
-    fn buf_matrix(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf) -> Mat3 {
-        let (l2c, _) = ctx.layer_to_comp(layer);
-        self.place_matrix(self.outer.map_or(l2c, |o| o * l2c), buf)
-    }
-
-    /// Buffer pixel → output pixel matrix for a layer → (top-level) comp matrix.
-    fn place_matrix(&self, l2c: Mat3, buf: &Buf) -> Mat3 {
-        let s = self.opts.scale;
-        self.out_matrix()
-            * Mat3::scale(vec2(s, s))
-            * l2c
-            * Mat3::scale(vec2(1.0 / buf.scale, 1.0 / buf.scale))
-            * Mat3::translate(vec2(-buf.offset[0], -buf.offset[1]))
-    }
-
-    /// The collapsed precomp layers this comp is drawn through, outermost first.
-    fn links(&self) -> impl Iterator<Item = &Through<'a>> {
-        self.through.iter().map_while(Option::as_ref)
-    }
-
-    /// The shutter of a layer's motion blur: its comp's, or for a collapsed precomp's layers the
-    /// outermost containing comp's.
-    fn shutter(&self, ctx: &EvalCtx) -> Shutter {
-        let c: &Comp = match self.links().next() {
-            Some(l) => l.comp,
-            None => ctx.comp,
-        };
-        Shutter {
-            angle: c.shutter_angle / 360.0,
-            phase: c.shutter_phase / 360.0,
-            frame: c.frame_duration().seconds(),
-            samples: c.motion_blur_samples,
-            limit: c.motion_blur_adaptive_limit,
-        }
-    }
-
-    /// Whether a layer moves within the shutter: its own motion blur, or that of a collapsed
-    /// precomp layer it is drawn through.
-    fn blurred(&self, ctx: &EvalCtx, layer: &Layer) -> bool {
-        self.mb_on(ctx, layer) || (!self.through_lost && self.links().any(|l| l.blur))
-    }
-
-    /// The collapsed precomps' matrix (nested comp → the frame's comp) and the nested comp's time
-    /// `dt` seconds into the outermost comp's shutter: each precomp layer moves if it is motion
-    /// blurred, and times map down through each one (stretch, time remapping).
-    fn outer_at(&self, ctx: &EvalCtx, dt: f64) -> (Option<Mat3>, Tick) {
-        let shift = Tick::from_seconds_f64(dt);
-        let mut outer: Option<Mat3> = None;
-        let mut t: Option<Tick> = None;
-        for l in self.links() {
-            let at = EvalCtx { comp_id: l.comp_id, comp: l.comp, time: t.unwrap_or(l.time + shift), ..*ctx };
-            let (m, _) = if l.blur { at.layer_to_comp(l.layer) } else { EvalCtx { time: l.time, ..at }.layer_to_comp(l.layer) };
-            outer = Some(outer.map_or(m, |o| o * m));
-            t = Some(at.nested_time(l.layer));
-        }
-        (outer, t.unwrap_or(ctx.time + shift))
-    }
-
-    /// [`Self::buf_matrix`] for the motion-blur sub-sample `dt` seconds into the shutter: the
-    /// layer moves if it is motion blurred, the collapsed precomps above it if theirs are.
-    fn buf_matrix_at(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf, dt: f64) -> Mat3 {
-        if self.through_lost || self.links().next().is_none() {
-            return self.buf_matrix(&ctx.at(ctx.time + Tick::from_seconds_f64(dt)), layer, buf);
-        }
-        let (outer, t) = self.outer_at(ctx, dt);
-        let lctx = if self.mb_on(ctx, layer) { ctx.at(t) } else { *ctx };
-        let (l2c, _) = lctx.layer_to_comp(layer);
-        self.place_matrix(outer.map_or(l2c, |o| o * l2c), buf)
-    }
-
-    /// Shape and text content that animates within the shutter (paths, Trim Paths, text
-    /// animators…) of a motion-blurred layer: the times its source is drawn at and averaged,
-    /// Samples Per Frame of them, as After Effects does for shape layers. `None` when the content
-    /// holds still (compared through its cache key, which leaves the transform out).
-    fn content_times(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Vec<Tick>> {
-        if !matches!(layer.source, LayerSource::Shape | LayerSource::Text) || !self.mb_on(ctx, layer) {
-            return None;
-        }
-        let sh = self.shutter(ctx);
-        if sh.angle <= 0.0 {
-            return None;
-        }
-        let n = if self.opts.draft { 4 } else { (sh.samples as usize).clamp(2, 64) };
-        let times: Vec<Tick> = (0..n).map(|i| self.outer_at(ctx, sh.offset(i, n)).1).collect();
-        let key = |t: Tick| cache::layer_key(&ctx.at(t), layer, 1.0, false, false);
-        let k0 = key(*times.first()?)?;
-        let moves = [times.get(n / 2), times.last()].into_iter().flatten().any(|t| key(*t) != Some(k0));
-        moves.then_some(times)
-    }
-
-    /// The layer's source drawn at each of `times` and averaged (premultiplied) on the union of
-    /// their bounds. Content that also changes its raster scale within the shutter, or would need
-    /// an outsized buffer, is drawn once.
-    fn blurred_source(&self, ctx: &EvalCtx, layer: &Layer, times: &[Tick]) -> Option<Buf> {
-        let bufs: Vec<Buf> = times.iter().filter_map(|t| self.source(&ctx.at(*t), layer)).collect();
-        let scale = bufs.first()?.scale;
-        // Pixel = layer point × scale + offset: with the largest offset every buffer lands at
-        // x + (off - its offset) ≥ 0.
-        let off = [0, 1].map(|i| bufs.iter().map(|b| b.offset[i]).fold(f64::MIN, f64::max));
-        let w = bufs.iter().map(|b| off[0] - b.offset[0] + b.img.width as f64).fold(0.0, f64::max).ceil();
-        let h = bufs.iter().map(|b| off[1] - b.offset[1] + b.img.height as f64).fold(0.0, f64::max).ceil();
-        if bufs.iter().any(|b| (b.scale - scale).abs() > 1e-9) || !(w * h).is_finite() || w * h > (1u64 << 26) as f64 {
-            return self.source(ctx, layer);
-        }
-        let mut acc = Image::new(w as u32, h as u32);
-        let k = 1.0 / bufs.len() as f32;
-        for b in &bufs {
-            let m = Mat3::translate(vec2(off[0] - b.offset[0], off[1] - b.offset[1]));
-            effectcraft_raster::accumulate_warp(&mut acc, &b.img, &m, effectcraft_raster::Sampling::Bilinear, k);
-        }
-        Some(Buf { img: acc, offset: off, scale })
-    }
-
-    /// A processed-layer cache key that also covers content motion blur (the averaged source
-    /// depends on the content at every sub-sample).
-    fn content_key(&self, ctx: &EvalCtx, layer: &Layer, key: Option<u64>) -> Option<u64> {
-        let k = key?;
-        let Some(times) = self.content_times(ctx, layer) else { return Some(k) };
-        times.iter().try_fold(cache::derive(k, 0x6d62_6c72), |d, t| Some(cache::derive(d, cache::layer_key(&ctx.at(*t), layer, 1.0, false, false)?)))
-    }
-
-    /// Whether a layer is motion blurred: the render options, the comp's switch and the layer's
-    /// switch (limited by the precomp layers above when switches affect nested comps). Layer
-    /// motion, mask motion blur, effects that read the shutter and Advanced 3D all ask this.
-    pub(crate) fn mb_on(&self, ctx: &EvalCtx, layer: &Layer) -> bool {
-        self.opts.motion_blur && ctx.comp.enable_motion_blur && self.layer_motion_blur(layer)
-    }
-
-    /// What a layer's mask motion blur may do in this render (see [`masks::MaskBlur`]).
-    fn mask_blur(&self, ctx: &EvalCtx, layer: &Layer) -> masks::MaskBlur {
-        masks::MaskBlur {
-            allowed: self.opts.motion_blur && ctx.comp.enable_motion_blur && self.inherited.is_none_or(|(_, mb)| mb),
-            layer: self.layer_motion_blur(layer),
-            samples: if self.opts.draft { 4 } else { ctx.comp.motion_blur_samples as usize },
-        }
-    }
-
-    /// Motion-blur sub-samples for a layer buffer (1 = no motion blur). As in After Effects, a 2D
-    /// layer gets about one sample per output pixel its corners travel during the shutter,
-    /// at least Samples Per Frame and at most the comp's Adaptive Sample Limit; a layer that
-    /// does not move within the shutter is drawn once.
-    fn mb_samples(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf) -> usize {
-        if !self.blurred(ctx, layer) {
-            return 1;
-        }
-        let travel = self.shutter_travel(ctx, layer, buf);
-        if travel < 1e-3 {
-            return 1;
-        }
-        if self.opts.draft {
-            return 4;
-        }
-        let sh = self.shutter(ctx);
-        adaptive_samples(travel, sh.samples, sh.limit)
-    }
-
-    /// Largest distance (output pixels) a corner of the layer buffer moves during the shutter,
-    /// measured along the path at a few points.
-    fn shutter_travel(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf) -> f64 {
-        let sh = self.shutter(ctx);
-        let (w, h) = (buf.img.width as f64, buf.img.height as f64);
-        let corners = [(0.0, 0.0), (w, 0.0), (0.0, h), (w, h), (w * 0.5, h * 0.5)];
-        const PROBES: usize = 8;
-        let mut prev: Option<Vec<effectcraft_geom::Vec2>> = None;
-        let mut travel = vec![0.0f64; corners.len()];
-        for i in 0..PROBES {
-            let m = self.buf_matrix_at(ctx, layer, buf, sh.offset(i, PROBES));
-            let pts: Vec<_> = corners.iter().map(|&(x, y)| m.apply(vec2(x, y))).collect();
-            if let Some(p) = &prev {
-                for (k, (a, b)) in p.iter().zip(&pts).enumerate() {
-                    travel[k] += (b.x - a.x).hypot(b.y - a.y);
-                }
-            }
-            prev = Some(pts);
-        }
-        travel.into_iter().fold(0.0, f64::max)
-    }
-
-    /// Canvas pixels that compositing `buf` for `layer` can change: the transformed buffer's
-    /// bounds plus the resampling footprint. Stencil/silhouette modes, motion blur and
-    /// perspective fall back to the whole canvas.
-    ///
-    /// A quantised buffer placed pixel-exactly (integer translation, Normal, 100%) over a blank
-    /// canvas leaves exactly its own (quantised) pixels: nothing to re-quantise.
-    fn footprint(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf, opacity: f32, blank: bool) -> Region {
-        if layer.blend_mode.is_stencil() || self.mb_samples(ctx, layer, buf) > 1 {
-            return Region::Full;
-        }
-        let m = self.buf_matrix(ctx, layer, buf);
-        if !m.is_affine() {
-            return Region::Full;
-        }
-        let matte = layer.track_matte.is_some_and(|tm| tm.layer != layer.id && ctx.comp.layer(tm.layer).is_some());
-        let k = &m.0;
-        let integral = |v: f64| v == v.round();
-        if blank
-            && layer.blend_mode == BlendMode::Normal
-            && opacity == 1.0
-            && !matte
-            && !layer.preserve_transparency
-            && self.pipe.to_blend().is_none()
-            && k[0][0] == 1.0
-            && k[1][1] == 1.0
-            && k[0][1] == 0.0
-            && k[1][0] == 0.0
-            && integral(k[0][2])
-            && integral(k[1][2])
-        {
-            return Region::Empty;
-        }
-        let (w, h) = (buf.img.width as f64, buf.img.height as f64);
-        let c = [(0.0, 0.0), (w, 0.0), (0.0, h), (w, h)].map(|(x, y)| m.apply(vec2(x, y)));
-        let (x0, x1) = (c.iter().map(|p| p.x).fold(f64::INFINITY, f64::min), c.iter().map(|p| p.x).fold(f64::NEG_INFINITY, f64::max));
-        let (y0, y1) = (c.iter().map(|p| p.y).fold(f64::INFINITY, f64::min), c.iter().map(|p| p.y).fold(f64::NEG_INFINITY, f64::max));
-        color::PxRect::covering(x0, y0, x1, y1, 3.0).map_or(Region::Full, Region::Rect)
-    }
-
-    /// How a processed layer buffer lands in the output: one buffer → output matrix, or one per
-    /// motion-blur sub-sample (averaged), with the layer's sampling filter and dissolve seed.
-    pub fn placement(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf) -> Placement {
-        let samples = self.mb_samples(ctx, layer, buf);
-        let (sampling, seed) = (self.sampling(layer), layer.id.0 as u32);
-        if samples <= 1 {
-            return Placement { matrices: vec![self.buf_matrix(ctx, layer, buf)], sampling, seed };
-        }
-        let sh = self.shutter(ctx);
-        let matrices = (0..samples).map(|i| self.buf_matrix_at(ctx, layer, buf, sh.offset(i, samples))).collect();
-        Placement { matrices, sampling, seed }
-    }
-
-    /// Draw a processed layer into `target` (transform, motion blur) with `mode`/`opacity`.
-    fn place(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf, target: &mut Image, mode: BlendMode, opacity: f32) {
-        let pl = self.placement(ctx, layer, buf);
-        let opts = WarpOpts { sampling: pl.sampling, opacity, mode, seed: pl.seed, clip: None };
-        if let [m] = pl.matrices.as_slice() {
-            composite_warp(target, &buf.img, m, &opts);
-            return;
-        }
-        // Sub-samples sum straight into one buffer (each warp is row-parallel).
-        let mut acc = Image::new(target.width, target.height);
-        let k = 1.0 / pl.matrices.len() as f32;
-        for m in &pl.matrices {
-            effectcraft_raster::accumulate_warp(&mut acc, &buf.img, m, opts.sampling, k);
-        }
-        target.blend_from(&acc, mode, opacity, pl.seed);
-    }
-
-    /// Draw a 2D layer into `canvas`; returns the region it may have changed.
-    fn draw_layer(&self, ctx: &EvalCtx, layer: &Layer, canvas: &mut Image, blank: bool) -> Region {
-        let opacity = ctx.opacity(layer) as f32 * self.opacity_mul;
-        if self.quality(layer) == Quality::Wireframe && !layer.switches.adjustment {
-            self.draw_wireframe(ctx, layer, canvas);
-            return Region::Full;
-        }
-        if opacity <= 0.0 && !layer.switches.adjustment {
-            return Region::Empty;
-        }
-        if layer.switches.adjustment {
-            self.draw_adjustment(ctx, layer, canvas, opacity);
-            return Region::Full;
-        }
-        let mut timing = self.profile.map(|_| LayerTiming { depth: self.depth, layer: layer.name.clone(), ..Default::default() });
-        let t0 = web_time::Instant::now();
-        let Some(st) = self.styled(ctx, layer, timing.as_mut()) else { return Region::Empty };
-        let st = self.styled_to_blend(st);
-        let t1 = web_time::Instant::now();
-        let changed = if st.plain {
-            self.composite_layer(ctx, layer, &st.body, canvas, opacity);
-            self.footprint(ctx, layer, &st.body, opacity, blank)
-        } else {
-            self.composite_styled(ctx, layer, &st, canvas, opacity);
-            Region::Full
-        };
-        if let (Some(prof), Some(mut timing)) = (self.profile, timing) {
-            timing.process_ms = (t1 - t0).as_secs_f64() * 1e3;
-            timing.composite_ms = t1.elapsed().as_secs_f64() * 1e3;
-            if let Ok(mut v) = prof.lock() {
-                v.push(timing);
-            }
-        }
-        changed
-    }
-
-    /// Composite a styled layer: exterior passes with their own modes, then the body with the
-    /// layer's mode; the layer's opacity fades the whole stack. Knockout clears what is below the
-    /// layer's content; switched-off R/G/B channels keep the values below.
-    fn composite_styled(&self, ctx: &EvalCtx, layer: &Layer, st: &StyledLayer, canvas: &mut Image, opacity: f32) {
-        let bl = styles::blending(ctx, layer);
-        let matte = layer.track_matte.is_some_and(|tm| tm.layer != layer.id && ctx.comp.layer(tm.layer).is_some());
-        if matte || layer.preserve_transparency {
-            let mut iso = Image::new(canvas.width, canvas.height);
-            for (b, m) in &st.passes {
-                self.place(ctx, layer, b, &mut iso, *m, 1.0);
-            }
-            self.place(ctx, layer, &st.body, &mut iso, BlendMode::Normal, 1.0);
-            self.composite_iso(ctx, layer, iso, canvas, opacity);
-            return;
-        }
-        let mut tmp = canvas.clone();
-        if bl.knockout > 0 {
-            let mut k = Image::new(canvas.width, canvas.height);
-            self.place(ctx, layer, &st.content, &mut k, BlendMode::Normal, 1.0);
-            tmp.data.par_iter_mut().zip(k.data.par_iter()).for_each(|(p, q)| {
-                let keep = 1.0 - q[3].clamp(0.0, 1.0);
-                for c in p.iter_mut() {
-                    *c *= keep;
-                }
-            });
-        }
-        for (b, m) in &st.passes {
-            self.place(ctx, layer, b, &mut tmp, *m, 1.0);
-        }
-        self.place(ctx, layer, &st.body, &mut tmp, layer.blend_mode, 1.0);
-        let ch = bl.channels;
-        canvas.data.par_iter_mut().zip(tmp.data.par_iter()).for_each(|(c, t)| {
-            for i in 0..4 {
-                let v = if i < 3 && !ch[i] { c[i] } else { t[i] };
-                c[i] += (v - c[i]) * opacity;
-            }
-        });
-    }
-
-    fn composite_layer(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf, canvas: &mut Image, opacity: f32) {
-        let matte = layer.track_matte.is_some_and(|tm| tm.layer != layer.id && ctx.comp.layer(tm.layer).is_some());
-        if !matte && !layer.preserve_transparency {
-            self.place(ctx, layer, buf, canvas, layer.blend_mode, opacity);
-            return;
-        }
-        // Render in isolation, then matte / preserve transparency, then blend.
-        let mut iso = Image::new(canvas.width, canvas.height);
-        self.place(ctx, layer, buf, &mut iso, BlendMode::Normal, 1.0);
-        self.composite_iso(ctx, layer, iso, canvas, opacity);
-    }
-
-    /// Apply the track matte / preserve transparency to an isolated layer render, then blend.
-    fn composite_iso(&self, ctx: &EvalCtx, layer: &Layer, iso: Image, canvas: &mut Image, opacity: f32) {
-        self.composite_iso_with(ctx, layer, iso, canvas, opacity, None);
-    }
-
-    /// [`Self::composite_iso`] with the track matte's pixels already drawn (`matte`, e.g. a 3D
-    /// matte seen through the camera); otherwise the matte layer is placed in 2D.
-    pub(crate) fn composite_iso_with(&self, ctx: &EvalCtx, layer: &Layer, mut iso: Image, canvas: &mut Image, opacity: f32, matte_img: Option<Image>) {
-        self.apply_track_matte(ctx, layer, &mut iso, matte_img);
-        if layer.preserve_transparency {
-            iso.data.par_iter_mut().zip(canvas.data.par_iter()).for_each(|(p, q)| {
-                for c in p.iter_mut() {
-                    *c *= q[3];
-                }
-            });
-        }
-        canvas.blend_from(&iso, layer.blend_mode, opacity, layer.id.0 as u32);
-    }
-
-    /// Multiply `img` (comp-sized) by the layer's track matte, if it has one; `matte_img` as in
-    /// [`Self::composite_iso_with`].
-    fn apply_track_matte(&self, ctx: &EvalCtx, layer: &Layer, img: &mut Image, matte_img: Option<Image>) {
-        let matte = layer.track_matte.and_then(|tm| ctx.comp.layer(tm.layer).filter(|m| m.id != layer.id).map(|m| (m, tm.kind)));
-        if let Some((m, kind)) = matte {
-            let mimg = match matte_img {
-                Some(i) if i.width == img.width && i.height == img.height => i,
-                _ => {
-                    let mut mimg = Image::new(img.width, img.height);
-                    if m.is_active_at(ctx.time)
-                        && let Some(mb) = self.layer_buf(ctx, m)
-                    {
-                        let mo = ctx.opacity(m) as f32;
-                        self.place(ctx, m, &mb, &mut mimg, BlendMode::Normal, mo);
-                    }
-                    mimg
-                }
-            };
-            img.data.par_iter_mut().zip(mimg.data.par_iter()).for_each(|(p, q)| {
-                let k = match kind {
-                    MatteKind::Alpha => q[3],
-                    MatteKind::AlphaInverted => 1.0 - q[3],
-                    MatteKind::Luma => effectcraft_color::luminance(q[0], q[1], q[2]),
-                    MatteKind::LumaInverted => 1.0 - effectcraft_color::luminance(q[0], q[1], q[2]),
-                }
-                .clamp(0.0, 1.0);
-                for c in p.iter_mut() {
-                    *c *= k;
-                }
-            });
-        }
-    }
-
-    /// Adjustment layer: effects applied to the comp below, limited to the layer's footprint
-    /// and its track matte.
-    fn draw_adjustment(&self, ctx: &EvalCtx, layer: &Layer, canvas: &mut Image, opacity: f32) {
-        let Some(mut foot) = self.source(ctx, layer) else { return };
-        let _ = masks::apply(ctx, layer, &mut foot, self.mask_blur(ctx, layer));
-        let mut matte = Image::new(canvas.width, canvas.height);
-        self.place(ctx, layer, &foot, &mut matte, BlendMode::Normal, 1.0);
-        self.apply_track_matte(ctx, layer, &mut matte, None);
-        let o = self.roi_offset().map(|(x, y, _, _)| [-x, -y]).unwrap_or([0.0; 2]);
-        let mut below = Buf { img: canvas.clone(), offset: o, scale: self.opts.scale };
-        // Effects run in the working space, not the linear blending space.
-        if let Some(c) = self.pipe.from_blend() {
-            color::convert(&mut below.img, &c);
-        }
-        let mut adjusted = self.apply_effects(ctx, layer, below, true);
-        // An effect that changed the frame (Motion Tile's Output size): back onto the canvas.
-        if let Some((dx, dy)) =
-            effectcraft_effects::adjustment_crop(adjusted.offset, o, (adjusted.img.width, adjusted.img.height), (canvas.width, canvas.height))
-        {
-            adjusted.img = adjusted.img.crop(dx, dy, canvas.width, canvas.height);
-        }
-        if let Some(c) = self.pipe.to_blend() {
-            color::convert(&mut adjusted.img, &c);
-        }
-        if adjusted.img.width != canvas.width || adjusted.img.height != canvas.height {
-            return;
-        }
-        canvas.data.par_iter_mut().zip(adjusted.img.data.par_iter()).zip(matte.data.par_iter()).for_each(|((c, a), m)| {
-            let k = m[3] * opacity;
-            for i in 0..4 {
-                c[i] += (a[i] - c[i]) * k;
-            }
-        });
-    }
-}
-
-/// A layer ready to composite (see [`Renderer::styled_layer`]).
-pub struct StyledLayer {
-    /// Exterior style passes (Drop Shadow, Outer Glow) with their blend modes.
-    pub passes: Vec<(Arc<Buf>, BlendMode)>,
-    pub body: Arc<Buf>,
-    /// Pre-style pixels (knockout shape).
-    pub content: Arc<Buf>,
-    /// Styled cache key (the content key when plain).
-    key: Option<u64>,
-    /// Content cache key.
-    ckey: Option<u64>,
-    /// No layer styles: composite `body` the usual way.
-    pub plain: bool,
-}
-
-/// Where a layer buffer lands (see [`Renderer::placement`]).
-#[derive(Clone, Debug)]
-pub struct Placement {
-    /// Buffer pixel → output pixel; several = motion-blur sub-samples (equal weights).
-    pub matrices: Vec<Mat3>,
-    pub sampling: effectcraft_raster::Sampling,
-    /// Dissolve noise seed.
-    pub seed: u32,
-}
-
-/// Hooks for accelerated compositors (`effectcraft-gpu`): the pieces of the CPU walk they reuse
-/// or fall back to. The CPU compositor itself is [`Renderer::comp_frame_cpu`].
-impl<'a> Renderer<'a> {
-    /// The project's colour pipeline.
-    pub fn pipe(&self) -> color::Pipe {
-        self.pipe
-    }
-
-    /// Nesting depth (0 = the top-level comp).
-    pub fn depth(&self) -> usize {
-        self.depth
-    }
-
-    /// The auxiliary 3D channels of comp `comp_id` at comp time `t` (depth, layer IDs, normals,
-    /// UVs, Cryptomatte; see `three_d::compose::aux_pass`), at the renderer's output scale.
-    pub fn comp_aux(&self, comp_id: ItemId, t: Tick) -> Option<effectcraft_raster::AuxChannels> {
-        let ctx = self.eval_ctx(comp_id, t)?;
-        Some(three_d::compose::aux_pass(self, &ctx))
-    }
-
-    /// The auxiliary channels effects on `layer` read ([`EffectHost::aux`]): its multi-layer
-    /// OpenEXR footage's at the layer's source time (Time Remap included), or a precomp's
-    /// generated 3D channels at its nested time. `None` for other layers.
-    pub fn layer_aux(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<effectcraft_raster::AuxChannels>> {
-        match &layer.source {
-            LayerSource::Footage { item } => {
-                let ItemKind::Footage(f) = &self.project.item(*item)?.kind else { return None };
-                let a = self.footage.aux(*item, f, ctx.source_time(layer))?;
-                // Aux pixels per layer pixel (the layer is the footage at its nominal size). The
-                // planes are only copied when that changes the scale.
-                let scale = a.width as f64 / f.width as f64;
-                if f.width > 0 && a.width > 0 && a.scale != scale {
-                    let mut a = (*a).clone();
-                    a.scale = scale;
-                    return Some(Arc::new(a));
-                }
-                Some(a)
-            }
-            LayerSource::Comp { item } => {
-                if self.depth > MAX_FX_DEPTH || self.project.comp_contains(*item, ctx.comp_id) {
-                    return None;
-                }
-                self.nested().comp_aux(*item, ctx.nested_time(layer)).map(Arc::new)
-            }
-            _ => None,
-        }
-    }
-
-    /// Evaluation context of comp `comp_id` at comp time `t`.
-    pub fn eval_ctx(&self, comp_id: ItemId, t: Tick) -> Option<EvalCtx<'a>> {
-        Some(self.ctx(comp_id, self.project.comp(comp_id)?, t))
-    }
-
-    /// The layers drawn at the context time, bottom to top (solo, guides and visibility
-    /// applied).
-    pub fn visible_layers(&self, ctx: &EvalCtx<'a>) -> Vec<&'a Layer> {
-        let (comp, t) = (ctx.comp, ctx.time);
-        let any_solo = comp.any_solo();
-        comp.layers
-            .iter()
-            .rev()
-            .filter(|l| l.is_active_at(t) && l.has_video() && !l.environment && (!any_solo || l.switches.solo) && (self.opts.guides || !l.switches.guide))
-            .collect()
-    }
-
-    /// Draw a run of consecutive 3D layers into `canvas` (CPU).
-    pub fn draw_3d_run(&self, ctx: &EvalCtx<'a>, run: &[&Layer], canvas: &mut Image) {
-        three_d::compose::draw_run(self, ctx, run, canvas);
-    }
-
-    /// A run of consecutive 3D layers prepared for an accelerator (planes, lights, shadow
-    /// casters; see [`three_d::Run3d`]) at output size `out`. `None` = draw it with
-    /// [`Self::draw_3d_run`] (adjustment or wireframe layers in the run, Advanced 3D).
-    pub fn prepare_3d_run(&self, ctx: &EvalCtx<'a>, run: &[&Layer], out: (u32, u32)) -> Option<three_d::Run3d> {
-        three_d::compose::gpu_run(self, ctx, run, out)
-    }
-
-    /// A run of consecutive 3D layers of an Advanced 3D comp prepared for an accelerator's
-    /// compositor ([`three_d::adv::Prepared`]): rendered as one scene and composited (Normal,
-    /// premultiplied over) onto the canvas. `None` = not an Advanced 3D comp, or a layer needs the
-    /// 2D compositing path (blend mode, track matte, Preserve Transparency): draw it with
-    /// [`Self::draw_3d_run`].
-    pub fn prepare_adv_run<'p>(&'p self, ctx: &'p EvalCtx<'a>, run: &'p [&'p Layer], out: (u32, u32)) -> Option<three_d::adv::Prepared<'p, 'a>> {
-        three_d::adv::prepare_run(self, ctx, run, out)
-    }
-
-    /// A run of consecutive 3D layers of an Advanced 3D comp whose layers need the 2D
-    /// compositing path (blend mode, track matte, Preserve Transparency), split for an
-    /// accelerator's compositor ([`three_d::adv::SplitRun`]). `None` = [`Self::prepare_adv_run`]
-    /// covers it, or it isn't an Advanced 3D run.
-    pub fn split_adv_run<'p>(&'p self, ctx: &'p EvalCtx<'a>, run: &'p [&'p Layer], out: (u32, u32)) -> Option<three_d::adv::SplitRun<'p, 'a>> {
-        three_d::adv::split_run(self, ctx, run, out)
-    }
-
-    /// Whether the comp's 3D layers draw with the Advanced 3D renderer.
-    pub fn is_adv3d(&self, ctx: &EvalCtx) -> bool {
-        three_d::adv::active(self, ctx)
-    }
-
-    /// An Environment Light Background layer ready to draw on an accelerator
-    /// ([`three_d::SkyDraw`]; the CPU draws it in `draw_3d_run`). `None` = nothing to draw.
-    pub fn sky_draw(&self, ctx: &EvalCtx, layer: &Layer) -> Option<three_d::SkyDraw> {
-        three_d::compose::sky_draw(self, ctx, layer)
-    }
-
-    /// The pixels a Wireframe-quality layer sets (white, opaque) on a `size` canvas: its
-    /// bounds' outline, one pixel wide. Empty when the layer has no bounds.
-    pub fn wireframe_pixels(&self, ctx: &EvalCtx, layer: &Layer, size: (u32, u32)) -> Vec<(u32, u32)> {
-        let Some(b) = content_bounds(ctx, layer) else { return vec![] };
-        let s = self.opts.scale;
-        let (l2c, _) = ctx.layer_to_comp(layer);
-        let m = Mat3::scale(vec2(s, s)) * self.outer.map_or(l2c, |o| o * l2c);
-        let c = [(b[0], b[1]), (b[2], b[1]), (b[2], b[3]), (b[0], b[3])].map(|(x, y)| m.apply(vec2(x, y)));
-        let (w, h) = (size.0 as i64, size.1 as i64);
-        let mut out = vec![];
-        for i in 0..4 {
-            let (p, q) = (c[i], c[(i + 1) % 4]);
-            let n = ((q.x - p.x).abs().max((q.y - p.y).abs()) * 2.0).ceil().clamp(1.0, 1.0e5) as usize;
-            for j in 0..=n {
-                let t = j as f64 / n as f64;
-                let (x, y) = ((p.x + (q.x - p.x) * t).floor() as i64, (p.y + (q.y - p.y) * t).floor() as i64);
-                if x >= 0 && y >= 0 && x < w && y < h {
-                    out.push((x as u32, y as u32));
-                }
-            }
-        }
-        out
-    }
-
-    /// Run the layer's effect stack on `target` (an accelerator's resident image): GPU-capable
-    /// runs through [`FxTarget::gpu`], the others through [`FxTarget::cpu`], with the CPU's
-    /// parameters and environment. `adjustment`: the stack runs on the comp below (adjustment
-    /// layers).
-    pub fn run_effects_on(&self, ctx: &EvalCtx, layer: &Layer, adjustment: bool, target: &mut dyn FxTarget) {
-        // `target` is used as it is: the comp below for adjustment layers (the callers).
-        self.run_effect_stack(ctx, layer, adjustment, usize::MAX, None, [0.0; 2], target);
-    }
-
-    /// [`Renderer::run_effects_on`] for a (non-adjustment) layer's own pixels: `target` holds
-    /// them in effect space (as [`Renderer::layer_input`] hands them out) and the result stays
-    /// there. Returns the effect-space origin in layer coordinates (rebase by its negation).
-    pub fn run_layer_effects_on(&self, ctx: &EvalCtx, layer: &Layer, target: &mut dyn FxTarget) -> [f64; 2] {
-        let origin = ctx.effect_bounds(layer).1;
-        self.run_effect_stack(ctx, layer, false, usize::MAX, None, origin, target);
-        origin
-    }
-
-    /// An adjustment layer's footprint (its source with masks applied, layer space): where
-    /// its effects show. `None` = the layer changes nothing.
-    pub fn adjustment_footprint(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<Buf>> {
-        // Cached, so an accelerator sees the same buffer (and uploads it once) every frame.
-        let key = self.cache.and_then(|_| cache::footprint_key(ctx, layer, self.raster_scale(ctx, layer), self.opts.draft, self.mb_on(ctx, layer)));
-        if let (Some(c), Some(k)) = (self.cache, key)
-            && let Some(b) = c.get(k)
-        {
-            return Some(b);
-        }
-        let mut foot = self.source(ctx, layer)?;
-        let _ = masks::apply(ctx, layer, &mut foot, self.mask_blur(ctx, layer));
-        let foot = Arc::new(foot);
-        // The buffer the cache keeps (another worker's, if it kept one first).
-        let foot = match (self.cache_to_keep(), key) {
-            (Some(c), Some(k)) => c.insert(k, foot),
-            _ => foot,
-        };
-        Some(foot)
-    }
-
-    /// Draw one 2D layer into `canvas` on the CPU (any kind: adjustment, wireframe, styled…).
-    pub fn draw_layer_cpu(&self, ctx: &EvalCtx, layer: &Layer, canvas: &mut Image) {
-        self.draw_layer(ctx, layer, canvas, false);
-    }
-
-    /// Draw a collapsed precomp layer into `canvas` on the CPU.
-    pub fn draw_collapsed_cpu(&self, ctx: &EvalCtx<'a>, layer: &Layer, item: ItemId, canvas: &mut Image) {
-        self.draw_collapsed(ctx, layer, item, canvas, false);
-    }
-
-    /// The layer's finished buffers (styles included) in the blending space.
-    pub fn styled_layer(&self, ctx: &EvalCtx, layer: &Layer) -> Option<StyledLayer> {
-        let mut timing = self.profile.map(|_| LayerTiming { depth: self.depth, layer: layer.name.clone(), ..Default::default() });
-        let t0 = web_time::Instant::now();
-        let st = self.styled(ctx, layer, timing.as_mut()).map(|st| self.styled_to_blend(st));
-        if let (Some(prof), Some(mut timing)) = (self.profile, timing) {
-            timing.process_ms = t0.elapsed().as_secs_f64() * 1e3;
-            if let Ok(mut v) = prof.lock() {
-                v.push(timing);
-            }
-        }
-        st
-    }
-
-    /// Opacity the layer composites with (its Opacity × collapsed precomps' opacity).
-    pub fn layer_opacity(&self, ctx: &EvalCtx, layer: &Layer) -> f32 {
-        ctx.opacity(layer) as f32 * self.opacity_mul
-    }
-
-    /// The layer's track matte layer and kind, if it has a valid one.
-    pub fn track_matte<'c>(&self, ctx: &EvalCtx<'c>, layer: &Layer) -> Option<(&'c Layer, MatteKind)> {
-        layer.track_matte.and_then(|tm| ctx.comp.layer(tm.layer).filter(|m| m.id != layer.id).map(|m| (m, tm.kind)))
-    }
-}
-
-/// The layer's frame blending mode, if the comp's Enable Frame Blending switch is on.
-/// One field of an interlaced frame as a full frame: the field's lines (`parity` 0 = even /
-/// upper, 1 = odd / lower) kept, the other lines interpolated from their neighbours.
-pub fn field_frame(img: &Image, parity: usize) -> Image {
-    let (w, h) = (img.width as usize, img.height as usize);
-    let mut out = img.clone();
-    if h < 2 {
-        return out;
-    }
-    for y in 0..h {
-        if y % 2 == parity {
-            continue;
-        }
-        let above = y.checked_sub(1);
-        let below = (y + 1 < h).then_some(y + 1);
-        for x in 0..w {
-            let px = match (above, below) {
-                (Some(a), Some(b)) => {
-                    let (p, q) = (img.data[a * w + x], img.data[b * w + x]);
-                    [(p[0] + q[0]) * 0.5, (p[1] + q[1]) * 0.5, (p[2] + q[2]) * 0.5, (p[3] + q[3]) * 0.5]
-                }
-                (Some(a), None) => img.data[a * w + x],
-                (None, Some(b)) => img.data[b * w + x],
-                (None, None) => img.data[y * w + x],
-            };
-            out.data[y * w + x] = px;
-        }
-    }
-    out
-}
-
-/// Interpret Footage ▸ Invert Alpha and Interpret As Linear Light on decoded (premultiplied)
-/// pixels; linear light is encoded in `space` ([`color::Pipe::linear_footage_space`]).
-pub fn interpret_pixels(img: &Image, f: &Footage, space: effectcraft_color::ColorSpace) -> Image {
-    let linear = f.linear_light_applies();
-    if !f.invert_alpha && !linear {
-        return img.clone();
-    }
-    let mut out = img.clone();
-    for p in out.data.iter_mut() {
-        let a = p[3];
-        let mut c = if a > 1e-6 { [p[0] / a, p[1] / a, p[2] / a] } else { [0.0; 3] };
-        if linear {
-            // The file's values are linear light: encode them like the rest of the footage.
-            c = c.map(|v| space.encode(v));
-        }
-        let a = if f.invert_alpha { 1.0 - a } else { a };
-        *p = [c[0] * a, c[1] * a, c[2] * a, a];
-    }
-    out
-}
-
-fn frame_blend_mode(ctx: &EvalCtx, layer: &Layer) -> FrameBlend {
-    if ctx.comp.enable_frame_blending { layer.switches.frame_blend } else { FrameBlend::Off }
-}
-
-/// Position of source time `t` among frames at `rate`: the frame at or before `t` and the
-/// fraction (0..1) of the way to the next frame. Exact (integer tick arithmetic), so frames that
-/// line up exactly report a fraction of 0.
-pub fn frame_position(t: Tick, rate: FrameRate) -> (i64, f64) {
-    let num = t.0 as i128 * rate.num as i128;
-    let den = TICKS_PER_SECOND as i128 * rate.den as i128;
-    (num.div_euclid(den) as i64, num.rem_euclid(den) as f64 / den as f64)
-}
-
-/// Blend two neighbouring frames `w` of the way from `a` to `b`: a cross-fade (Frame Mix) or a
-/// motion-compensated interpolation (Pixel Motion).
-pub fn blend_frames(mode: FrameBlend, a: &Image, b: &Image, w: f32) -> Image {
-    match mode {
-        FrameBlend::PixelMotion => effectcraft_raster::flow::interpolate(a, b, w),
-        _ => effectcraft_raster::flow::mix(a, b, w),
-    }
-}
-
-/// Convenience: render one frame of a comp with no footage source.
-/// Adaptive motion-blur sample count for a layer whose corners travel `travel` output pixels
-/// during the shutter: one sample per pixel, clamped to Samples Per Frame … Adaptive Sample Limit.
-pub fn adaptive_samples(travel: f64, per_frame: u32, limit: u32) -> usize {
-    let lo = per_frame.clamp(2, 64) as f64;
-    let hi = (limit.clamp(16, 256) as f64).max(lo);
-    travel.ceil().clamp(lo, hi) as usize
-}
-
-/// A region of interest `[x, y, w, h]` lies within a `w`×`h` comp frame.
-pub fn roi_inside(r: [f64; 4], w: u32, h: u32) -> bool {
-    r[0] >= 0.0 && r[1] >= 0.0 && r[0] + r[2] <= w as f64 + 1e-6 && r[1] + r[3] <= h as f64 + 1e-6
-}
-
-/// The Extended Viewer's region of interest: the comp frame grown by `margin` × its size on every
-/// side (`margin` = 1 shows a pasteboard one comp wide around the frame), intersected with the
-/// `visible` comp-space rectangle `[x0, y0, x1, y1]` and snapped outward to whole 16 px steps from the frame edges
-/// so panning re-renders rarely. `None` when the visible area lies inside the frame.
-pub fn extended_region(w: u32, h: u32, visible: [f64; 4], margin: f64) -> Option<[f64; 4]> {
-    let (w, h) = (w as f64, h as f64);
-    let (mx, my) = (w * margin, h * margin);
-    let snap_lo = |v: f64| (v / 16.0).floor() * 16.0;
-    let snap_hi = |v: f64| (v / 16.0).ceil() * 16.0;
-    let x0 = snap_lo(visible[0].max(-mx)).min(0.0);
-    let y0 = snap_lo(visible[1].max(-my)).min(0.0);
-    let x1 = w + snap_hi(visible[2].min(w + mx) - w).max(0.0);
-    let y1 = h + snap_hi(visible[3].min(h + my) - h).max(0.0);
-    if x0 >= 0.0 && y0 >= 0.0 && x1 <= w && y1 <= h {
-        return None;
-    }
-    Some([x0, y0, x1 - x0, y1 - y0])
-}
-
-/// The size of a `width` x `height` comp frame rendered at `scale` (both compositors, and the
-/// frame size Composition Settings shows for a Resolution).
-pub fn frame_size(width: u32, height: u32, scale: f64) -> (u32, u32) {
-    (((width as f64 * scale).round() as u32).max(1), ((height as f64 * scale).round() as u32).max(1))
-}
-
-pub fn render_frame(project: &Project, comp: ItemId, t: Tick, scale: f64) -> Image {
-    Renderer::new(project, &NoFootage, RenderOpts { scale, ..Default::default() }).comp_frame(comp, t)
-}
-
 #[cfg(test)]
 mod tests;
-#[cfg(test)]
-mod tests_auto;
-#[cfg(test)]
-mod tests_remap;
-#[cfg(test)]
-mod tests_roi;
-#[cfg(test)]
-mod tests_styles;
-
-/// Layer-space bounds `[x0, y0, x1, y1]` of a layer's content at the context time (source size
-/// for solids/footage/precomps, glyph bounds for text, painted bounds for shapes). Used for viewer
-/// handles and hit testing.
-pub fn content_bounds(ctx: &EvalCtx, layer: &effectcraft_project::Layer) -> Option<[f64; 4]> {
-    match &layer.source {
-        LayerSource::Text => {
-            let glyphs = text::glyph_paths(ctx, layer);
-            let paths: Vec<_> = glyphs.into_iter().map(|g| g.0).collect();
-            effectcraft_path::bounds(&paths).map(|r| [r.x0, r.y0, r.x1, r.y1])
-        }
-        LayerSource::Shape => layer.props.sub("contents").and_then(|c| shapes::content_bounds(ctx, layer, c)).map(|r| [r.x0, r.y0, r.x1, r.y1]),
-        LayerSource::Camera | LayerSource::Light { .. } => None,
-        _ => {
-            let (w, h) = source_size(ctx.project, layer);
-            (w > 0 && h > 0).then_some([0.0, 0.0, w as f64, h as f64])
-        }
-    }
-}
-
-/// A mask/shape path as a kurbo path (for drawing overlays).
-pub fn kurbo_path(sp: &effectcraft_keyframe::ShapePath) -> kurbo::BezPath {
-    effectcraft_path::to_kurbo(sp)
-}
-#[cfg(test)]
-mod tests_audio_fx;
-#[cfg(test)]
-mod tests_aux;
-#[cfg(test)]
-mod tests_collapse;
-#[cfg(test)]
-mod tests_color;
-#[cfg(test)]
-mod tests_footage_size;
-#[cfg(test)]
-mod tests_frame_blend;
-#[cfg(test)]
-mod tests_guides;
-#[cfg(test)]
-mod tests_mask_blur;
-#[cfg(test)]
-mod tests_mask_expansion;
-#[cfg(test)]
-mod tests_motion_tile;
-#[cfg(test)]
-mod tests_nested;
-#[cfg(test)]
-mod tests_paint;
-#[cfg(test)]
-mod tests_time;
diff --git a/crates/render/src/masks.rs b/crates/render/src/masks.rs
index bb91ef71d..e6ba0a6fb 100644
--- a/crates/render/src/masks.rs
+++ b/crates/render/src/masks.rs
@@ -5,7 +5,7 @@ use effectcraft_geom::{Mat3, vec2};
 use effectcraft_keyframe::Value;
 use effectcraft_path::{FillRule, Join};
 use effectcraft_project::{FeatherFalloff, GroupKind, Layer, MaskMode, MaskMotionBlur};
-use effectcraft_raster::{Mask, box_blur, gaussian_blur};
+use effectcraft_raster::{Mask, box_blur};
 use rayon::prelude::*;
 
 use crate::eval::EvalCtx;
@@ -60,40 +60,213 @@ fn coverage(ctx: &EvalCtx, layer: &Layer, g: &effectcraft_project::PropGroup, bu
     coverage_at(ctx, layer, g, buf)
 }
 
+/// The largest feather taken, in buffer pixels (larger and non-finite values are clamped).
+const MAX_FEATHER_PX: f64 = 1.0e6;
+/// Smooth falloff (After Effects' default), measured on After Effects 2026 renders (feather 100,
+/// 300 and 1000; red value along rows, columns and the corner diagonal of a feathered rect mask):
+/// the edge is blurred separably by three box passes, each `2r + 1` pixels wide with
+/// `r = round(SMOOTH_BOX_RADIUS * feather)`. That is a quadratic B-spline reaching about
+/// 1.11 x feather either side of the path (finite support; a Gaussian of any width misses the
+/// measured profile by 3/255 or more, this kernel by less than 1/255).
+const SMOOTH_BOX_RADIUS: f64 = 0.37;
+/// Up to this box radius (buffer pixels) a feather is blurred at the buffer's resolution. A wider
+/// one is blurred on a grid coarser per axis, about `COARSE_RADIUS` grid pixels per box: a wide
+/// blur is smooth, so the coarse grid loses nothing visible, and the padding stays about
+/// 3 x `COARSE_RADIUS` grid pixels. (Box passes cost the same at any radius; the coarse grid
+/// bounds the padded area, i.e. memory.)
+const FULL_RES_RADIUS: usize = 48;
+const COARSE_RADIUS: usize = 32;
+/// The largest padded grid (pixels). A grid that would be bigger (a huge buffer) is coarsened
+/// (`grid`) until it fits, so the padding, and with it the feather of a mask edge outside the
+/// buffer, is never dropped.
+const MAX_GRID_PX: usize = 1 << 26;
+/// The coarsest factor `grid` tries before giving up on the padding (unreachable for any buffer
+/// that fits in memory: 1024 x 1024 buffer pixels per grid pixel).
+const MAX_COARSEN: usize = 1024;
+/// Padding for a variable-width feather, which is rasterised at the buffer's resolution.
+const MAX_VARIABLE_PAD: usize = 256;
+
+/// One axis of the grid a feathered mask is rasterised and blurred on: `step` buffer pixels per
+/// grid pixel, `pad` grid pixels on each side of the buffer, and the box radii in grid pixels.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct Axis {
+    step: usize,
+    pad: usize,
+    /// Radii of the box passes (Smooth: three; Linear: one, the others 0).
+    radii: [usize; 3],
+}
+
+impl Axis {
+    /// `feather` in buffer pixels. The pad covers the blur's whole support, so the coverage of
+    /// the path outside the buffer reaches into it as on an unbounded plane.
+    fn new(feather: f64, linear: bool, full_res_only: bool) -> Axis {
+        let f = if feather.is_finite() { feather.clamp(0.0, MAX_FEATHER_PX) } else { 0.0 };
+        let none = Axis { step: 1, pad: 0, radii: [0; 3] };
+        if f <= 0.0 {
+            return none;
+        }
+        let cap = |pad: usize| if full_res_only { pad.min(MAX_VARIABLE_PAD) } else { pad };
+        if linear {
+            // Linear falloff (not measured against After Effects): one box pass, a straight ramp
+            // `feather` pixels wide across the edge, as before. Not quite unchanged: a ramp wider
+            // than about `4 x FULL_RES_RADIUS` pixels is now blurred on the coarse grid and
+            // resampled bilinearly (a smooth ramp, so the difference is a rounding of the ramp).
+            let r = (f / 2.0).round().max(1.0) as usize;
+            let step = if full_res_only || r <= 2 * FULL_RES_RADIUS { 1 } else { r.div_ceil(2 * COARSE_RADIUS) };
+            let rg = ((r as f64 / step as f64).round() as usize).max(1);
+            return Axis { step, pad: cap(rg), radii: [rg, 0, 0] };
+        }
+        let r = (SMOOTH_BOX_RADIUS * f).round() as usize;
+        if r == 0 {
+            return none;
+        }
+        if full_res_only || r <= FULL_RES_RADIUS {
+            return Axis { step: 1, pad: cap(3 * r + 1), radii: [r; 3] };
+        }
+        // On a coarse grid the three windows (2 rg + 1 grid pixels each) should still add up to
+        // 3 (2r + 1) buffer pixels: of a few steps take the one that comes closest, and spread
+        // the radii over the passes.
+        let want = 3 * (2 * r + 1);
+        let s0 = r.div_ceil(COARSE_RADIUS);
+        let fit = |s: usize| -> (usize, usize) {
+            let sum = ((want as f64 / s as f64 - 3.0) / 2.0).round().max(0.0) as usize;
+            let got = (2 * sum + 3).saturating_mul(s);
+            (sum, got.abs_diff(want))
+        };
+        let (step, sum) = (s0..=s0 + (s0 / 2).min(8)).map(|s| (s, fit(s))).min_by_key(|&(s, (_, e))| (e, s)).map_or((s0, fit(s0).0), |(s, (sum, _))| (s, sum));
+        let radii = [0, 1, 2].map(|i| sum / 3 + usize::from(i < sum % 3));
+        Axis { step, pad: sum + 1, radii }
+    }
+
+    fn blurs(&self) -> bool {
+        self.radii.iter().any(|&r| r > 0)
+    }
+
+    /// The same blur on a grid `k` times coarser: radii and padding scaled down (a blurring
+    /// axis keeps at least one grid pixel of radius), the padding still covering the support.
+    fn coarser(self, k: usize) -> Axis {
+        if k <= 1 {
+            return self;
+        }
+        let blurs = self.blurs();
+        let mut radii = self.radii.map(|r| (r as f64 / k as f64).round() as usize);
+        if blurs && radii.iter().all(|&r| r == 0) {
+            radii[0] = 1;
+        }
+        let support = radii.iter().fold(0usize, |a, &r| a.saturating_add(r)).saturating_add(1);
+        let pad = if self.pad == 0 { 0 } else { self.pad.div_ceil(k).max(support) };
+        Axis { step: self.step.saturating_mul(k), pad, radii }
+    }
+
+    /// Grid pixels for `n` buffer pixels.
+    fn len(&self, n: u32) -> Option<usize> {
+        (n as usize).div_ceil(self.step).checked_add(self.pad.checked_mul(2)?)
+    }
+}
+
+/// Resamples a grid coverage (`gw` wide) back to the `w x h` buffer: bilinear between the grid
+/// pixel centres (an exact copy when both steps are 1).
+fn crop(grid: &Mask, ax: Axis, ay: Axis, w: u32, h: u32) -> Mask {
+    let (gw, gh) = (grid.width as usize, grid.height as usize);
+    let mut out = Mask::new(w, h, 0.0);
+    let at = |x: usize, y: usize| grid.data.get(y.saturating_mul(gw).saturating_add(x)).copied().unwrap_or(0.0);
+    // Grid coordinate of a buffer pixel centre, as (index, fraction) on that axis.
+    let map = |i: u32, a: Axis, n: usize| -> (usize, usize, f32) {
+        let u = (i as f64 + 0.5) / a.step as f64 + a.pad as f64 - 0.5;
+        let u = u.clamp(0.0, n.saturating_sub(1) as f64);
+        let i0 = u.floor() as usize;
+        (i0, (i0 + 1).min(n.saturating_sub(1)), (u - i0 as f64) as f32)
+    };
+    let xs: Vec<(usize, usize, f32)> = (0..w).map(|x| map(x, ax, gw)).collect();
+    out.data.par_chunks_mut(w.max(1) as usize).enumerate().for_each(|(y, row)| {
+        let (y0, y1, fy) = map(y as u32, ay, gh);
+        for (o, &(x0, x1, fx)) in row.iter_mut().zip(&xs) {
+            let top = at(x0, y0) + (at(x1, y0) - at(x0, y0)) * fx;
+            let bottom = at(x0, y1) + (at(x1, y1) - at(x0, y1)) * fx;
+            *o = top + (bottom - top) * fy;
+        }
+    });
+    out
+}
+
 fn coverage_at(ctx: &EvalCtx, layer: &Layer, g: &effectcraft_project::PropGroup, buf: &Buf) -> Option<Mask> {
     let Value::Path(sp) = ctx.group_value(layer, g, "path")? else { return None };
-    let path = effectcraft_path::to_kurbo(&sp);
-    let (w, h) = (buf.img.width, buf.img.height);
     let m = Mat3::translate(vec2(buf.offset[0], buf.offset[1])) * Mat3::scale(vec2(buf.scale, buf.scale));
     let exp = ctx.f(layer, g, "expansion", 0.0);
     let linear = matches!(g.kind, GroupKind::Mask { feather_falloff: FeatherFalloff::Linear, .. });
+    let feather = ctx.v2(layer, g, "feather", [0.0; 2]);
+    let feather = [feather[0] * buf.scale, feather[1] * buf.scale];
+    Some(feathered(&sp, &m, (buf.img.width, buf.img.height), exp, feather, linear, MAX_GRID_PX))
+}
+
+/// The padded grid for a `w x h` buffer: the axes as given, or coarsened together (by 2, 4, …)
+/// until the grid has at most `max_px` pixels. `None` without a blur (or, unreachably, when even
+/// the coarsest grid is too big).
+fn grid(w: u32, h: u32, ax: Axis, ay: Axis, max_px: usize) -> Option<(u32, u32, Axis, Axis)> {
+    if !(ax.blurs() || ay.blurs()) {
+        return None;
+    }
+    let mut k = 1usize;
+    while k <= MAX_COARSEN {
+        let (cx, cy) = (ax.coarser(k), ay.coarser(k));
+        if let (Some(gw), Some(gh)) = (cx.len(w), cy.len(h))
+            && gw.checked_mul(gh).is_some_and(|n| n <= max_px)
+            && let (Ok(gw), Ok(gh)) = (u32::try_from(gw), u32::try_from(gh))
+        {
+            return Some((gw, gh, cx, cy));
+        }
+        k = k.saturating_mul(2);
+    }
+    None
+}
+
+/// Coverage of the mask path `sp` (layer -> buffer `m`) on a `w x h` buffer, expanded by `exp`
+/// and feathered by `feather` buffer pixels per axis, on a padded grid of at most `max_px` pixels.
+fn feathered(sp: &effectcraft_keyframe::ShapePath, m: &Mat3, (w, h): (u32, u32), exp: f64, feather: [f64; 2], linear: bool, max_px: usize) -> Mask {
+    let path = effectcraft_path::to_kurbo(sp);
     // Variable-width feather (Mask Feather tool points): expansion and the per-point feather
     // are applied together from the signed distance to the path.
     let variable = !sp.feather.is_empty();
+    // The feather blurs the mask's own edge, also where the path lies outside the layer (After
+    // Effects: a feathered mask just below a layer still fades into it). So a feathered mask is
+    // rasterised on a grid padded by the blur's reach, blurred there and cropped to the buffer.
+    // A variable feather scales its point radii by the mean scale: it stays at full resolution
+    // (unless the grid has to be coarsened to fit `max_px`).
+    let (ax, ay) = (Axis::new(feather[0], linear, variable), Axis::new(feather[1], linear, variable));
+    let blurred = ax.blurs() || ay.blurs();
+    let grid = grid(w, h, ax, ay, max_px);
+    // Without the grid (no blur, or, unreachably, a grid too big even at the coarsest step):
+    // blurred within the buffer at its resolution.
+    let unpadded = |f: f64| Axis { pad: 0, ..Axis::new(f, linear, true) };
+    let (gw, gh, gx, gy) = grid.unwrap_or_else(|| (w, h, unpadded(feather[0]), unpadded(feather[1])));
+    // Buffer pixels -> grid pixels.
+    let to_grid = Mat3::scale(vec2(1.0 / gx.step as f64, 1.0 / gy.step as f64)) * Mat3::translate(vec2((gx.pad * gx.step) as f64, (gy.pad * gy.step) as f64));
+    let mg = to_grid * *m;
     let mut cov = if variable {
-        effectcraft_path::feather::variable_feather_coverage(&sp, &m, w, h, exp, linear)
+        effectcraft_path::feather::variable_feather_coverage(sp, &mg, gw, gh, exp, linear)
     } else if exp.abs() > 0.01 {
         // Expansion offsets the outline itself (round joins). Offset Paths' geometry stays right
         // when the expansion exceeds a curvature radius, where a fill + stroke blend leaves a
         // ring around an uncovered middle (growing) or islands (shrinking).
         let grown = effectcraft_path::offset::offset_path(&path, exp, Join::Round, 4.0);
-        effectcraft_path::fill_coverage(std::slice::from_ref(&grown), &m, w, h, FillRule::NonZero)
+        effectcraft_path::fill_coverage(std::slice::from_ref(&grown), &mg, gw, gh, FillRule::NonZero)
     } else {
-        effectcraft_path::fill_coverage(std::slice::from_ref(&path), &m, w, h, FillRule::NonZero)
+        effectcraft_path::fill_coverage(std::slice::from_ref(&path), &mg, gw, gh, FillRule::NonZero)
     };
-    let feather = ctx.v2(layer, g, "feather", [0.0; 2]);
-    if feather[0] > 0.0 || feather[1] > 0.0 {
-        let img = cov.to_image();
-        let b = if linear {
-            // One box pass: a straight ramp `feather` pixels wide across the edge.
-            let r = |f: f64| ((f * buf.scale / 2.0).round() as usize).max(if f > 0.0 { 1 } else { 0 });
-            box_blur(&img, r(feather[0]), r(feather[1]), 1, false)
-        } else {
-            gaussian_blur(&img, feather[0] * buf.scale / 2.0, feather[1] * buf.scale / 2.0, false)
-        };
-        cov = Mask::from_alpha(&b);
+    if blurred {
+        // Separable box passes (the corner of a feathered rect is the product of its edges).
+        let mut img = cov.to_image();
+        for (rx, ry) in gx.radii.into_iter().zip(gy.radii) {
+            if rx > 0 || ry > 0 {
+                img = box_blur(&img, rx, ry, 1, false);
+            }
+        }
+        cov = Mask::from_alpha(&img);
     }
-    Some(cov)
+    if grid.is_some() {
+        cov = crop(&cov, gx, gy, w, h);
+    }
+    cov
 }
 
 /// The layer's enabled masks at the context time, flattened to polylines in layer space (for
@@ -133,7 +306,9 @@ pub fn apply(ctx: &EvalCtx, layer: &Layer, buf: &mut Buf, blur: MaskBlur) -> boo
     if list.is_empty() {
         return false;
     }
-    // Masks may extend past the source: grow the buffer to cover them when feather/expansion pads.
+    // Masks may extend past the source: the buffer keeps its size (pixels outside the layer stay
+    // empty), but a feathered mask is blurred on a padded grid, so the feather of an edge outside
+    // the buffer still reaches into it (`coverage_at`).
     let n = (buf.img.width * buf.img.height) as usize;
     let first_sub = matches!(list[0].kind, GroupKind::Mask { mode: MaskMode::Subtract, .. });
     let mut acc = vec![if first_sub { 1.0f32 } else { 0.0 }; n];
@@ -169,3 +344,48 @@ pub fn apply(ctx: &EvalCtx, layer: &Layer, buf: &mut Buf, blur: MaskBlur) -> boo
     buf.img.mul_mask(&acc);
     true
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use effectcraft_keyframe::ShapePath;
+
+    /// CodeRabbit on #1874: an 8192 x 8192 layer with a 40 px Smooth feather needs a padded
+    /// grid larger than `MAX_GRID_PX`; it used to fall back to the unpadded buffer, so an Add mask
+    /// just outside the layer covered nothing and the whole layer vanished. The grid is now
+    /// coarsened instead and keeps a pad that covers the blur.
+    #[test]
+    fn a_grid_too_big_is_coarsened_and_keeps_its_padding() {
+        let a = Axis::new(40.0, false, false);
+        assert!(a.len(8192).zip(a.len(8192)).is_some_and(|(x, y)| x * y > MAX_GRID_PX), "the full-resolution grid is over the limit");
+        let (gw, gh, gx, gy) = grid(8192, 8192, a, a, MAX_GRID_PX).expect("a padded grid");
+        assert!((gw as usize) * (gh as usize) <= MAX_GRID_PX);
+        for g in [gx, gy] {
+            assert!(g.step > 1 && g.pad > 0 && g.blurs(), "{g:?}");
+            // The pad covers the blur's support (the three boxes' radii) in buffer pixels.
+            assert!(g.pad * g.step >= g.radii.iter().sum::<usize>() * g.step, "{g:?}");
+        }
+        // A grid that fits is not touched.
+        assert_eq!(grid(200, 100, a, a, MAX_GRID_PX).map(|g| g.2), Some(a));
+    }
+
+    /// The same failure at a testable size: a 200 x 100 buffer, a 40 px feather and a grid limit
+    /// just below the full-resolution padded grid. The Add mask lies just right of the buffer
+    /// (x 210..260); its feather still fades into the layer, close to the full-resolution result.
+    #[test]
+    fn a_coarsened_grid_still_feathers_a_mask_outside_the_buffer() {
+        let sp = ShapePath::rect([235.0, 50.0], 50.0, 200.0);
+        let m = Mat3::IDENTITY;
+        let full = feathered(&sp, &m, (200, 100), 0.0, [40.0, 40.0], false, MAX_GRID_PX);
+        let a = Axis::new(40.0, false, false);
+        let limit = a.len(200).zip(a.len(100)).map_or(0, |(x, y)| x * y) - 1;
+        let coarse = feathered(&sp, &m, (200, 100), 0.0, [40.0, 40.0], false, limit);
+        let at = |c: &Mask, x: usize, y: usize| c.data.get(y * 200 + x).copied().unwrap_or(-1.0);
+        assert!(at(&full, 199, 50) > 0.25, "full resolution: {}", at(&full, 199, 50));
+        assert!(at(&coarse, 199, 50) > 0.2, "the soft fade survives the coarse grid: {}", at(&coarse, 199, 50));
+        for x in [150, 170, 180, 190, 199] {
+            assert!((at(&coarse, x, 50) - at(&full, x, 50)).abs() < 0.05, "x {x}: coarse {} full {}", at(&coarse, x, 50), at(&full, x, 50));
+        }
+        assert!(at(&coarse, 100, 50) < 0.01, "far from the mask stays clear");
+    }
+}
diff --git a/crates/render/src/opts.rs b/crates/render/src/opts.rs
new file mode 100644
index 000000000..c6175bf39
--- /dev/null
+++ b/crates/render/src/opts.rs
@@ -0,0 +1,97 @@
+use super::accel::Backend;
+use super::{Comp, EvalCtx, ItemId, Layer, Mat4, Tick, three_d};
+
+#[derive(Clone, Copy, Debug, serde::Serialize, serde::Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct RenderOpts {
+    /// Output scale relative to comp pixels (1 = Full, 0.5 = Half…).
+    pub scale: f64,
+    pub motion_blur: bool,
+    /// Render guide layers (viewer only). Only the top-level comp's own guide layers: nested
+    /// comps (precomps, collapsed precomps, comps read by effects) never draw theirs, as in
+    /// After Effects (see `Renderer::nested_opts`).
+    pub guides: bool,
+    /// Draft quality: fewer motion-blur samples, bilinear only.
+    pub draft: bool,
+    /// 3D view camera override (viewer Front/Top/Custom views); None = the comp's active camera.
+    pub view: Option<three_d::CameraState>,
+    /// CPU or GPU compositor (the GPU needs [`Renderer::accel`]).
+    pub backend: Backend,
+    /// Region of interest `[x, y, w, h]` in comp pixels (viewer only): the top-level frame covers
+    /// just this rectangle, and only its pixels are composited.
+    pub roi: Option<[f64; 4]>,
+    /// Which proxies stand in for footage and compositions (Render Settings ▸ Proxy Use).
+    pub proxy: effectcraft_project::render_queue::ProxyUse,
+    /// Switches Affect Nested Comps (Settings ▸ General): a precomp layer's Quality and Motion
+    /// Blur switches also limit the layers of the nested comp (Draft/Wireframe or motion blur off
+    /// propagate down; they never raise a nested layer's own setting).
+    pub nested_switches: bool,
+    /// Realtime Shadows in Draft (Settings ▸ 3D): draft renders (`draft`) still cast shadows.
+    pub draft_shadows: bool,
+}
+
+impl RenderOpts {
+    /// Whether 3D layers cast shadows in this render.
+    pub fn shadows(&self) -> bool {
+        !self.draft || self.draft_shadows
+    }
+}
+
+impl Default for RenderOpts {
+    fn default() -> Self {
+        RenderOpts {
+            scale: 1.0,
+            motion_blur: true,
+            guides: false,
+            draft: false,
+            view: None,
+            roi: None,
+            backend: Backend::Cpu,
+            nested_switches: true,
+            draft_shadows: true,
+            proxy: effectcraft_project::render_queue::ProxyUse::CurrentSettings,
+        }
+    }
+}
+
+/// One collapsed precomp layer a nested comp is drawn through.
+#[derive(Clone, Copy)]
+pub(crate) struct Through<'a> {
+    pub(crate) comp_id: ItemId,
+    pub(crate) comp: &'a Comp,
+    /// The containing comp's time at this frame.
+    pub(crate) time: Tick,
+    pub(crate) layer: &'a Layer,
+    /// The precomp layer is motion blurred: its own motion blurs the nested layers.
+    pub(crate) blur: bool,
+}
+
+/// Collapsed precomps within collapsed precomps that motion blur follows (more than
+/// [`Renderer::collapsed`]'s nesting limit).
+pub(crate) const MAX_THROUGH: usize = 16;
+
+/// How a collapsed precomp's 3D layers are placed in the parent (see `Renderer::collapse_into`).
+#[derive(Clone, Copy)]
+pub(crate) struct Collapse3d<'a> {
+    /// Nested comp world → parent world (the precomp layer's world transform).
+    pub world: Mat4,
+    /// The parent's camera.
+    pub cam: three_d::CameraState,
+    /// The outermost comp's context (its lights light the nested layers).
+    pub parent: EvalCtx<'a>,
+}
+
+/// Time spent on one layer of one frame (milliseconds).
+#[derive(Clone, Debug, Default)]
+pub struct LayerTiming {
+    pub depth: usize,
+    pub layer: String,
+    /// Source + masks + effects (cache lookup only, on a hit).
+    pub process_ms: f64,
+    /// Per effect: (effect id, ms). Empty on a cache hit.
+    pub effects: Vec<(String, f64)>,
+    /// Transform + matte + blend.
+    pub composite_ms: f64,
+    /// The processed buffer came from the layer cache.
+    pub cached: bool,
+}
diff --git a/crates/render/src/pipeline.rs b/crates/render/src/pipeline.rs
new file mode 100644
index 000000000..a4927144f
--- /dev/null
+++ b/crates/render/src/pipeline.rs
@@ -0,0 +1,1034 @@
+use super::accel::{Accelerator, Backend, CpuFx, FxStep, FxTarget};
+use super::footage::{FootageSource, is_vector_footage};
+use super::frames::{blend_frames, cineon_frame, content_bounds, field_frame, frame_blend_mode, frame_position, frame_size, interpret_pixels, roi_inside};
+use super::fx_host::{FxHost, essential_overrides};
+use super::opts::{Collapse3d, LayerTiming, MAX_THROUGH, RenderOpts, Through};
+use super::{
+    Arc, AutoKey, AutoPick, BlendMode, Buf, Comp, EffectCtx, EffectEnv, EvalCtx, Footage, FootageKind, FrameBlend, FrameRate, GroupKind, Image, ItemId,
+    ItemKind, Layer, LayerCache, LayerSource, Params, Project, Quality, Region, Renderer, Tick, cache, color, masks, shapes, styles, text, three_d, vec2,
+};
+use effectcraft_keyframe::Value;
+use effectcraft_project::LayerId;
+
+/// Coordinate space and stack range shared by CPU and accelerated effect evaluation.
+#[derive(Clone, Copy)]
+pub(crate) struct EffectStack {
+    pub adjustment: bool,
+    pub limit: usize,
+    pub origin: [f64; 2],
+}
+
+/// A property value an Essential Properties override gives a layer of a collapsed precomp.
+#[derive(Clone, Debug)]
+pub struct PropertyOverride {
+    pub(crate) layer: LayerId,
+    pub(crate) prop: u64,
+    pub(crate) value: Value,
+    /// A Font control changes only the font of the target text, not its text.
+    pub(crate) font: bool,
+}
+
+/// A Media Replacement an Essential Properties override gives a footage layer of a collapsed
+/// precomp.
+#[derive(Clone, Copy, Debug)]
+pub struct MediaOverride {
+    pub(crate) layer: LayerId,
+    pub(crate) item: ItemId,
+}
+
+impl MediaOverride {
+    /// A Media Replacement of `layer`'s footage by `item`.
+    pub fn new(layer: LayerId, item: ItemId) -> Self {
+        MediaOverride { layer, item }
+    }
+}
+
+/// A collapsed precomp layer: the nested comp and the instance overrides that apply to it.
+pub struct Collapsed {
+    pub item: ItemId,
+    pub(crate) property_overrides: Vec<PropertyOverride>,
+    pub(crate) media_overrides: Vec<MediaOverride>,
+}
+
+/// The property and media overrides of a collapsed precomp layer. `None` when its Essential
+/// Properties group or the source comp's definitions are missing (the flattened path then
+/// preserves the old behaviour).
+fn collapsed_instance(ctx: &EvalCtx, layer: &Layer, item: ItemId) -> Option<(Vec<PropertyOverride>, Vec<MediaOverride>)> {
+    use effectcraft_project::essential::{self, ControlType, EgKind};
+    let over = essential::overridden(layer);
+    if over.is_empty() {
+        return Some((vec![], vec![]));
+    }
+    let g = essential::group(layer)?;
+    let eg = ctx.project.comp(item)?.essential.as_ref()?;
+    let mut property = vec![];
+    let mut fonts: Vec<PropertyOverride> = vec![];
+    let mut media = vec![];
+    g.walk("", &mut |_, p| {
+        if !over.contains(&p.uid) {
+            return;
+        }
+        let Some(control) = essential::control_of(&p.match_id) else { return };
+        let Some(ctl) = eg.resolve(control) else { return };
+        let value = ctx.value(layer, p);
+        match &ctl.kind {
+            EgKind::Property { .. } => {
+                let font = ctl.as_type == Some(ControlType::Font);
+                for (layer, prop) in ctl.kind.targets() {
+                    let o = PropertyOverride { layer, prop, value: value.clone(), font };
+                    if font { fonts.push(o) } else { property.push(o) }
+                }
+            }
+            EgKind::Media { layer: target } => {
+                let Value::Scalar(id) = value else { return };
+                let item = ItemId(id.max(0.0) as u64);
+                if matches!(ctx.project.item(item).map(|i| &i.kind), Some(ItemKind::Footage(_))) {
+                    media.push(MediaOverride { layer: *target, item });
+                }
+            }
+            _ => {}
+        }
+    });
+    // A Font control merges into the text its instance shows, after a whole-value (Text) override
+    // of the same property, as `essential::with_overrides` does: keep one entry per property.
+    for f in fonts {
+        match property.iter_mut().rev().find(|o| o.layer == f.layer && o.prop == f.prop) {
+            Some(o) => effectcraft_project::essential::merge_font(&mut o.value, &f.value),
+            None => property.push(f),
+        }
+    }
+    Some((property, media))
+}
+
+impl<'a> Renderer<'a> {
+    pub fn new(project: &'a Project, footage: &'a dyn FootageSource, opts: RenderOpts) -> Renderer<'a> {
+        Renderer {
+            project,
+            footage,
+            expr: None,
+            opts,
+            cache: None,
+            profile: None,
+            accel: None,
+            depth: 0,
+            pipe: color::Pipe::of(&project.settings),
+            outer: None,
+            opacity_mul: 1.0,
+            collapse3d: None,
+            inherited: None,
+            defer_dof: false,
+            top: true,
+            through: [None; MAX_THROUGH],
+            through_lost: false,
+        }
+    }
+
+    /// The layer cache to keep this render's buffers in: none once its footage reads were
+    /// called off, as they may have come back empty ([`FootageSource::called_off`], #329).
+    pub(crate) fn cache_to_keep(&self) -> Option<&'a LayerCache> {
+        self.cache.filter(|_| !self.footage.called_off())
+    }
+
+    /// A layer's Quality switch, limited by the precomp layers above it when
+    /// [`RenderOpts::nested_switches`] is on.
+    pub fn quality(&self, layer: &Layer) -> Quality {
+        let rank = |q: Quality| match q {
+            Quality::Best => 0,
+            Quality::Draft => 1,
+            Quality::Wireframe => 2,
+        };
+        match self.inherited {
+            Some((q, _)) if rank(q) > rank(layer.switches.quality) => q,
+            _ => layer.switches.quality,
+        }
+    }
+
+    /// A layer's Motion Blur switch, limited by the precomp layers above it.
+    pub(crate) fn layer_motion_blur(&self, layer: &Layer) -> bool {
+        layer.switches.motion_blur && self.inherited.is_none_or(|(_, mb)| mb)
+    }
+
+    /// The renderer for the nested comp of precomp layer `layer`: its switches pass down when
+    /// [`RenderOpts::nested_switches`] is on.
+    fn nested_through(&self, layer: &Layer) -> Renderer<'a> {
+        let mut sub = self.nested();
+        if self.opts.nested_switches {
+            sub.inherited = Some((self.quality(layer), self.layer_motion_blur(layer)));
+        }
+        sub
+    }
+
+    /// The render options one level down (precomps, collapsed precomps, comps read by effects):
+    /// guide layers render only in their own comp, never when it is nested.
+    fn nested_opts(&self) -> RenderOpts {
+        RenderOpts { guides: false, ..self.opts }
+    }
+
+    /// A renderer for nested work (precomps, layers read by effects): one level deeper.
+    pub(crate) fn nested(&self) -> Renderer<'a> {
+        Renderer {
+            opts: self.nested_opts(),
+            depth: self.depth + 1,
+            outer: None,
+            opacity_mul: 1.0,
+            collapse3d: None,
+            defer_dof: false,
+            top: false,
+            through: [None; MAX_THROUGH],
+            through_lost: false,
+            ..*self
+        }
+    }
+
+    /// A precomp layer's nested comp for an accelerator to render resident (no CPU render and
+    /// upload of the nested frame): the renderer one level down, the comp, its time and the
+    /// buffer scale, exactly as [`Self::layer_source`]'s comp branch would render it. `None`
+    /// when that branch does more (composition proxy, Essential Properties overrides, frame
+    /// blending, recursion) or draws nothing (outside the nested comp's span): use the CPU path.
+    pub fn precomp_source(&self, ctx: &EvalCtx, layer: &Layer) -> Option<(Renderer<'a>, ItemId, Tick, f64)> {
+        let LayerSource::Comp { item } = layer.source else { return None };
+        if layer.switches.adjustment || self.project.comp_contains(item, ctx.comp_id) {
+            return None;
+        }
+        let nc = self.project.comp(item)?;
+        let lt = ctx.nested_time(layer);
+        if self.content_times(ctx, layer).is_some() {
+            return None;
+        }
+        if !nc.covers(lt) || self.proxy_for(item).is_some() || !essential_overrides(ctx, layer).is_empty() || frame_blend_mode(ctx, layer) != FrameBlend::Off {
+            return None;
+        }
+        let s = self.opts.scale;
+        let bs = if s < 1.0 && nc.preserve_resolution { 1.0 } else { s };
+        let base = self.nested_through(layer);
+        Some((Renderer { opts: RenderOpts { scale: bs, ..base.opts }, ..base }, item, lt, bs))
+    }
+
+    /// The nested comp of a precomp layer whose transformations collapse into this comp: the
+    /// Collapse Transformations switch is on and the layer has no masks, effects or layer
+    /// styles (those force a flattened render of the precomp, as in After Effects). Essential
+    /// Properties overrides travel with it and are applied as the nested layers are evaluated,
+    /// so the nested comp is not rasterised at its frame.
+    pub fn collapsed(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Collapsed> {
+        if !layer.switches.collapse || layer.switches.adjustment || self.depth > 12 {
+            return None;
+        }
+        let LayerSource::Comp { item } = &layer.source else { return None };
+        if self.project.comp_contains(*item, ctx.comp_id) || self.project.comp(*item).is_none() {
+            return None;
+        }
+        if layer.masks().is_some_and(|m| !m.children.is_empty()) {
+            return None;
+        }
+        if layer.switches.effects && layer.effects().is_some_and(|fx| fx.groups().any(|g| g.enabled)) {
+            return None;
+        }
+        if styles::active(ctx, layer) {
+            return None;
+        }
+        // A composition proxy or frame blending is drawn by the flattened path (`precomp_source`);
+        // collapsing renders the nested comp directly and would ignore both.
+        if self.proxy_for(*item).is_some() || frame_blend_mode(ctx, layer) != FrameBlend::Off {
+            return None;
+        }
+        let (property_overrides, media_overrides) = collapsed_instance(ctx, layer, *item)?;
+        Some(Collapsed { item: *item, property_overrides, media_overrides })
+    }
+
+    /// A renderer and context that draw a collapsed precomp's layers straight into this comp:
+    /// their transforms are concatenated with the precomp layer's (one resample, no
+    /// rasterisation at the precomp's bounds), their opacity multiplied by `opacity`, and their
+    /// 3D layers use this comp's camera and lights.
+    pub fn collapse_into<'p>(&self, ctx: &EvalCtx<'a>, layer: &'a Layer, collapsed: &'p Collapsed, opacity: f32) -> Option<(Renderer<'p>, EvalCtx<'p>)>
+    where
+        'a: 'p,
+    {
+        let item = collapsed.item;
+        let nc = self.project.comp(item)?;
+        let t = ctx.nested_time(layer);
+        if !nc.covers(t) {
+            return None;
+        }
+        let nctx = EvalCtx {
+            comp_id: item,
+            comp: nc,
+            time: t,
+            property_overrides: &collapsed.property_overrides,
+            media_overrides: &collapsed.media_overrides,
+            ..*ctx
+        };
+        let (l2c, _) = ctx.layer_to_comp(layer);
+        let outer = Some(self.outer.map_or(l2c, |o| o * l2c));
+        let world = ctx.world_matrix(layer);
+        let c3 = Collapse3d {
+            world: self.collapse3d.map_or(world, |c| c.world * world),
+            cam: three_d::compose::camera_for(self, ctx),
+            parent: self.collapse3d.map_or(*ctx, |c| c.parent),
+        };
+        // Motion blur follows the precomp layer's own motion too.
+        let link = Through { comp_id: ctx.comp_id, comp: ctx.comp, time: ctx.time, layer, blur: self.mb_on(ctx, layer) };
+        let mut through = self.through;
+        let slot = through.iter_mut().find(|t| t.is_none());
+        let through_lost = self.through_lost || slot.is_none();
+        if let Some(slot) = slot {
+            *slot = Some(link);
+        }
+        Some((
+            Renderer { opts: self.nested_opts(), depth: self.depth + 1, outer, opacity_mul: opacity, collapse3d: Some(c3), through, through_lost, ..*self },
+            nctx,
+        ))
+    }
+
+    pub(crate) fn opacity_mul(&self) -> f32 {
+        self.opacity_mul
+    }
+
+    /// Draw a collapsed 2D precomp layer: nested layers blend straight into `canvas` with their
+    /// own modes (Normal precomp, no matte); otherwise they are drawn into an isolated buffer
+    /// that then takes the precomp layer's track matte, Preserve Transparency and blend mode.
+    /// Returns the region left to re-quantise (nested layers drawn straight into `canvas`
+    /// quantise their own footprints).
+    pub(crate) fn draw_collapsed(&self, ctx: &EvalCtx<'a>, layer: &'a Layer, collapsed: &Collapsed, canvas: &mut Image, blank: bool) -> Region {
+        let opacity = ctx.opacity(layer) as f32 * self.opacity_mul;
+        if opacity <= 0.0 {
+            return Region::Empty;
+        }
+        let matte = layer.track_matte.is_some_and(|tm| tm.layer != layer.id && ctx.comp.layer(tm.layer).is_some());
+        if layer.blend_mode == BlendMode::Normal && !matte && !layer.preserve_transparency {
+            if let Some((sub, nctx)) = self.collapse_into(ctx, layer, collapsed, opacity) {
+                sub.draw_comp(&nctx, canvas, blank);
+            }
+            return Region::Empty;
+        }
+        let Some((sub, nctx)) = self.collapse_into(ctx, layer, collapsed, 1.0) else { return Region::Empty };
+        let mut iso = Image::new(canvas.width, canvas.height);
+        sub.draw_comp(&nctx, &mut iso, true);
+        self.composite_iso(ctx, layer, iso, canvas, opacity);
+        Region::Full
+    }
+
+    /// Whether `layer`'s processed buffer (source → masks → effects) is cached and the same as
+    /// one frame earlier: drawing it from the layer cache (an accelerator uploads it once) beats
+    /// re-running its effects every frame.
+    pub fn layer_is_static(&self, ctx: &EvalCtx, layer: &Layer) -> bool {
+        if self.cache.is_none() {
+            return false;
+        }
+        let (scale, draft, blur) = (self.raster_scale(ctx, layer), self.opts.draft, self.mb_on(ctx, layer));
+        let prev = ctx.time - ctx.comp.frame_rate.frame_duration();
+        let now = cache::layer_key(ctx, layer, scale, draft, blur);
+        now.is_some() && now == cache::layer_key(&ctx.at(prev), layer, scale, draft, blur)
+    }
+
+    /// Rasterisation scale of a layer's source: the output scale, or — for text and shape layers,
+    /// which are always continuously rasterised (#390, #751), and Continuously Rasterize vector
+    /// footage — the output scale times the layer's on-screen scale (quarter-octave steps, rounded
+    /// up, so vector content is drawn at its final size and stays sharp when scaled up).
+    pub fn raster_scale(&self, ctx: &EvalCtx, layer: &Layer) -> f64 {
+        let s = self.opts.scale;
+        let continuous = match layer.source {
+            LayerSource::Text | LayerSource::Shape => true,
+            LayerSource::Footage { item } => {
+                let item = ctx.media_item(layer, item);
+                layer.switches.collapse && matches!(self.project.item(item).map(|i| &i.kind), Some(ItemKind::Footage(f)) if is_vector_footage(f))
+            }
+            _ => false,
+        };
+        if !continuous {
+            return s;
+        }
+        let (l2c, _) = ctx.layer_to_comp(layer);
+        let m = self.outer.map_or(l2c, |o| o * l2c);
+        let a = layer.transform().map(|tr| ctx.v3(layer, tr, "anchor", [0.0; 3])).unwrap_or([0.0; 3]);
+        let p0 = m.apply(vec2(a[0], a[1]));
+        let px = m.apply(vec2(a[0] + 1.0, a[1]));
+        let py = m.apply(vec2(a[0], a[1] + 1.0));
+        let k = ((px.x - p0.x).hypot(px.y - p0.y)).max((py.x - p0.x).hypot(py.y - p0.y));
+        if !k.is_finite() || k <= 1e-6 {
+            return s;
+        }
+        // The step is rounded up past rounding noise only: an unscaled layer whose position isn't
+        // a whole number maps the unit vectors to lengths a hair over 1, which must stay 1 (#390:
+        // rounded up to 2^¼, unscaled text was drawn larger and resampled, softer).
+        let mut k = 2f64.powf((k.log2() * 4.0 - 1e-6).ceil() / 4.0).clamp(1.0 / 16.0, 64.0);
+        // Keep the buffer within about 16 million pixels.
+        if let Some(b) = content_bounds(ctx, layer) {
+            let area = ((b[2] - b[0]) * (b[3] - b[1])).max(1.0) * s * s;
+            k = k.min((16.0e6 / area).sqrt().max(1.0));
+        }
+        s * k
+    }
+
+    /// Draw a Wireframe-quality layer: its bounds as a one-pixel outline.
+    pub(crate) fn draw_wireframe(&self, ctx: &EvalCtx, layer: &Layer, canvas: &mut Image) {
+        for (x, y) in self.wireframe_pixels(ctx, layer, (canvas.width, canvas.height)) {
+            canvas.set(x, y, [1.0, 1.0, 1.0, 1.0]);
+        }
+    }
+
+    pub(crate) fn ctx(&self, comp_id: ItemId, comp: &'a Comp, t: Tick) -> EvalCtx<'a> {
+        EvalCtx { project: self.project, comp_id, comp, time: t, expr: self.expr, footage: Some(self.footage), property_overrides: &[], media_overrides: &[] }
+    }
+
+    /// This renderer with another accelerator (or none): the passes of
+    /// [`passes::in_passes`] render with the accelerator, its CPU fallback without.
+    pub fn with_accel(&self, accel: Option<&'a dyn Accelerator>) -> Renderer<'a> {
+        Renderer { accel, ..*self }
+    }
+
+    /// The accelerator to use for this render, if any (see [`Backend`]).
+    pub fn active_accel(&self) -> Option<&'a dyn Accelerator> {
+        let a = self.accel?;
+        match self.opts.backend {
+            Backend::Cpu => None,
+            Backend::Gpu => Some(a),
+            Backend::Auto => self.project.settings.gpu_acceleration.then_some(a),
+        }
+    }
+
+    /// Render a composition at comp time `t` (transparent background, comp size × scale).
+    /// Top-level frames go to the GPU when [`Self::active_accel`] is set and handles them.
+    pub fn comp_frame(&self, comp_id: ItemId, t: Tick) -> Image {
+        // Classic 3D runs composite on the GPU too (M12.7), so Auto sends 3D comps there as well;
+        // Auto renders each comp on whichever compositor measured faster ([`AutoPick`]).
+        if self.depth == 0
+            && let Some(a) = self.active_accel()
+        {
+            let auto = self.frame_auto(a, comp_id, false);
+            if auto.is_none_or(|(p, key)| p.choose(key)) {
+                let t0 = web_time::Instant::now();
+                if let Some(img) = a.comp_frame(self, comp_id, t) {
+                    if let Some((p, key)) = auto {
+                        p.record(key, true, t0.elapsed().as_secs_f64() * 1e3);
+                    }
+                    return img;
+                }
+                if let Some((p, key)) = auto {
+                    p.declined(key);
+                }
+            }
+            let t0 = web_time::Instant::now();
+            let img = self.comp_frame_cpu(comp_id, t);
+            if let Some((p, key)) = auto {
+                p.record(key, false, t0.elapsed().as_secs_f64() * 1e3);
+            }
+            return img;
+        }
+        self.comp_frame_cpu(comp_id, t)
+    }
+
+    /// The Auto timing history and key for a top-level frame of `comp` (`None` unless the
+    /// backend is [`Backend::Auto`] and the accelerator keeps history).
+    pub fn frame_auto(&self, a: &'a dyn Accelerator, comp: ItemId, display: bool) -> Option<(&'a AutoPick, AutoKey)> {
+        if self.opts.backend != Backend::Auto || self.opts.roi.is_some() {
+            return None;
+        }
+        Some((a.auto_pick()?, AutoKey::new(comp, self.opts.scale, display)))
+    }
+
+    /// [`Self::comp_frame`] on the CPU compositor only.
+    pub fn comp_frame_cpu(&self, comp_id: ItemId, t: Tick) -> Image {
+        let Some(comp) = self.project.comp(comp_id) else { return Image::new(1, 1) };
+        let s = self.opts.scale;
+        let (w, h) = frame_size(comp.width, comp.height, s);
+        // Region of interest on a comp with 3D layers: render the frame and crop it. A region
+        // reaching past the comp frame (the Extended Viewer) renders Classic 3D natively — the
+        // planes project through the offset camera — and Advanced 3D as the frame, padded.
+        if self.depth == 0
+            && let Some(r) = self.opts.roi
+            && comp.has_3d()
+            && (roi_inside(r, comp.width, comp.height) || comp.renderer == effectcraft_project::Renderer::Advanced3D)
+        {
+            let full = Renderer { opts: RenderOpts { roi: None, ..self.opts }, ..*self }.comp_frame(comp_id, t);
+            let (x0, y0) = ((r[0] * s).round() as i64, (r[1] * s).round() as i64);
+            let (rw, rh) = (((r[2] * s).round() as u32).max(1), ((r[3] * s).round() as u32).max(1));
+            let mut out = Image::new(rw, rh);
+            for y in 0..rh as i64 {
+                let sy = y + y0;
+                if sy < 0 || sy >= full.height as i64 {
+                    continue;
+                }
+                for x in 0..rw as i64 {
+                    let sx = x + x0;
+                    if sx >= 0 && sx < full.width as i64 {
+                        out.data[(y * rw as i64 + x) as usize] = full.data[(sy * full.width as i64 + sx) as usize];
+                    }
+                }
+            }
+            return out;
+        }
+        let (w, h) = match self.roi_offset() {
+            Some((_, _, rw, rh)) => (rw, rh),
+            None => (w, h),
+        };
+        let mut canvas = Image::new(w, h);
+        if self.depth > 16 {
+            return canvas;
+        }
+        let ctx = self.ctx(comp_id, comp, t);
+        self.draw_comp(&ctx, &mut canvas, true);
+        // The canvas is already quantised after every layer; only re-encoding changes it.
+        if let Some(c) = self.pipe.from_blend() {
+            color::convert(&mut canvas, &c);
+            self.pipe.quantize(&mut canvas);
+        }
+        // The top-level comp leaves the working space for the (sRGB) display / output.
+        if self.depth == 0
+            && let Some(c) = self.pipe.output()
+        {
+            color::convert(&mut canvas, &c);
+            self.pipe.quantize(&mut canvas);
+        }
+        if self.depth == 0
+            && let Some((lin, mode, enc)) = self.pipe.output_hdr()
+        {
+            color::output_hdr(&mut canvas, lin, mode, enc);
+            self.pipe.quantize(&mut canvas);
+        }
+        canvas
+    }
+
+    /// Draw a comp's layers (bottom to top) into `canvas` (blending space).
+    /// `blank`: the canvas is fully transparent (lets the first layer skip re-quantising).
+    fn draw_comp(&self, ctx: &EvalCtx<'a>, canvas: &mut Image, mut blank: bool) {
+        // Bottom-to-top, with runs of consecutive 3D layers depth-sorted (farthest first).
+        let visible = self.visible_layers(ctx);
+        let mut i = 0;
+        while i < visible.len() {
+            if visible[i].is_3d() {
+                let mut j = i;
+                while j < visible.len() && visible[j].is_3d() {
+                    j += 1;
+                }
+                three_d::compose::draw_run(self, ctx, &visible[i..j], canvas);
+                i = j;
+                self.pipe.quantize(canvas);
+                blank = false;
+            } else {
+                let changed = match self.collapsed(ctx, visible[i]) {
+                    Some(collapsed) => self.draw_collapsed(ctx, visible[i], &collapsed, canvas, blank),
+                    None => self.draw_layer(ctx, visible[i], canvas, blank),
+                };
+                i += 1;
+                // 8/16 bpc: the comp is an integer buffer after every layer (only the pixels the
+                // layer touched need re-quantising).
+                self.pipe.quantize_region(canvas, changed);
+                blank = false;
+            }
+        }
+    }
+
+    /// Evaluate an effect instance's parameters.
+    fn effect_params(&self, ctx: &EvalCtx, layer: &Layer, g: &effectcraft_project::PropGroup) -> Params {
+        // Nested groups (Paint strokes, Puppet meshes and pins) are flattened too.
+        effectcraft_effects::flatten_params(g, &mut |pr| ctx.value(layer, pr))
+    }
+
+    pub(crate) fn apply_effects(&self, ctx: &EvalCtx, layer: &Layer, buf: Buf, adjustment: bool) -> Buf {
+        self.apply_effects_timed(ctx, layer, buf, adjustment, usize::MAX, None)
+    }
+
+    /// Run the first `limit` effects of the layer's stack (by position; disabled ones count) on
+    /// `buf` (layer space, or the comp below for an adjustment layer).
+    fn apply_effects_timed(&self, ctx: &EvalCtx, layer: &Layer, mut buf: Buf, adjustment: bool, limit: usize, timing: Option<&mut Vec<(String, f64)>>) -> Buf {
+        // The comp below an adjustment layer is not in its layer space: it stays as it is.
+        let origin = if adjustment { [0.0; 2] } else { ctx.effect_bounds(layer).1 };
+        buf.rebase(origin);
+        let mut out = self.effect_space_stack(ctx, layer, buf, EffectStack { adjustment, limit, origin }, timing);
+        out.rebase([-origin[0], -origin[1]]);
+        out
+    }
+
+    /// [`Renderer::apply_effects_timed`] on a buffer already in effect space (measured from
+    /// `origin`, in layer coordinates); the result stays in effect space.
+    fn effect_space_stack(&self, ctx: &EvalCtx, layer: &Layer, buf: Buf, stack: EffectStack, timing: Option<&mut Vec<(String, f64)>>) -> Buf {
+        let mut t = CpuFx { accel: self.active_accel(), levels: self.pipe.levels, buf: Some(buf) };
+        self.run_effect_stack(ctx, layer, stack, timing, &mut t);
+        t.buf.unwrap_or_else(|| Buf { img: Image::new(1, 1), offset: [0.0; 2], scale: self.opts.scale })
+    }
+
+    /// Run the layer's video effect stack on `target` (in effect space, measured from `origin`
+    /// in layer coordinates): runs of GPU-capable effects go to [`FxTarget::gpu`] (when an
+    /// accelerator is active and supports them), the rest to [`FxTarget::cpu`] one by one
+    /// (quantised to the bit depth after each).
+    pub(crate) fn run_effect_stack(
+        &self,
+        ctx: &EvalCtx,
+        layer: &Layer,
+        stack: EffectStack,
+        mut timing: Option<&mut Vec<(String, f64)>>,
+        target: &mut dyn FxTarget,
+    ) {
+        let EffectStack { adjustment, limit, origin } = stack;
+        if !layer.switches.effects {
+            return;
+        }
+        let Some(fx) = layer.effects() else { return };
+        let lt = layer.layer_time(ctx.time);
+        let layer_size = ctx.effect_bounds(layer).0;
+        // #659 / #1205: an authored layer's buffer spans only its painted content. Effects that
+        // place pixels outside it grow the buffer themselves, by exactly what they need
+        // (`layer_cover_pad`: CC Tiler, CC Smear, CC Mosaic sharp) instead of a blanket cover of
+        // the whole layer rectangle on every stack — which paid a comp-sized texture per layer,
+        // per frame in flight, for glow and blur that never use the extra room. The buffer still
+        // takes the cover's pixel-grid phase: a downscaled layer resamples along that grid.
+        // Effects not known to stay inside their own margins (Twirl, Bulge, Transform, ...) still
+        // get the cover: they move content past the painted bounds without growing the buffer.
+        let video = || {
+            fx.groups().filter(|g| g.enabled).filter_map(|g| match &g.kind {
+                GroupKind::Effect { effect } => effectcraft_effects::find(effect).filter(|s| !effectcraft_effects::audio_fx::is_audio_effect(s.id)),
+                _ => None,
+            })
+        };
+        if !adjustment && video().next().is_some() {
+            if video().all(|s| s.skips_cover()) {
+                target.align(layer_size);
+            } else {
+                target.cover(layer_size);
+            }
+        }
+        let mut mask_shapes = masks::shapes(ctx, layer);
+        if origin != [0.0; 2] {
+            for q in mask_shapes.iter_mut().flat_map(|m| m.points.iter_mut()) {
+                *q = [q[0] - origin[0], q[1] - origin[1]];
+            }
+        }
+        // Capture once, before preceding effects can expand or replace the input. An
+        // adjustment stack's original is the comp below, not its solid source.
+        let needs_original =
+            fx.groups().take(limit).any(|g| g.enabled && matches!(&g.kind, GroupKind::Effect { effect } if effect == "ec.channel.cccomposite"));
+        let mut original = None;
+        if needs_original {
+            target.cpu(&mut |buf| {
+                original = Some(buf.clone());
+                buf
+            });
+        }
+        let host = FxHost { r: self, ctx, layer, origin, index: 0, original: original.as_ref() };
+        let env = EffectEnv {
+            masks: &mask_shapes,
+            host: Some(&host),
+            comp_time: ctx.time.seconds(),
+            frame_rate: ctx.comp.frame_rate.as_f64(),
+            effect_index: 0,
+            working_space: self.pipe.space,
+            working_linear: self.pipe.linear,
+            float_depth: self.pipe.levels.is_none(),
+            shutter: self.mb_on(ctx, layer).then_some((ctx.comp.shutter_angle, ctx.comp.shutter_phase, ctx.comp.motion_blur_samples)),
+        };
+        // Video effects in stack order (index, group, spec); disabled and audio effects skipped.
+        let stack: Vec<(usize, &effectcraft_project::PropGroup, &'static effectcraft_effects::EffectSpec)> = fx
+            .groups()
+            .enumerate()
+            .take_while(|(i, _)| *i < limit)
+            .filter(|(_, g)| g.enabled)
+            .filter_map(|(i, g)| match &g.kind {
+                GroupKind::Effect { effect } => effectcraft_effects::find(effect).map(|s| (i, g, s)),
+                _ => None,
+            })
+            .filter(|(_, _, s)| !effectcraft_effects::audio_fx::is_audio_effect(s.id))
+            .collect();
+        let accel = self.active_accel();
+        let mut k = 0;
+        while k < stack.len() {
+            let (i, g, spec) = stack[k];
+            // A run of GPU effects goes to the accelerator in one go.
+            if let Some(a) = accel
+                && spec.gpu
+                && a.supports_effect(spec.id)
+            {
+                let run: Vec<_> = stack[k..].iter().take_while(|(_, _, s)| s.gpu && a.supports_effect(s.id)).collect();
+                let params: Vec<Params> = run.iter().map(|(_, g, _)| self.effect_params(ctx, layer, g)).collect();
+                let hosts: Vec<_> = run.iter().map(|(i, _, _)| FxHost { index: *i, ..host }).collect();
+                let steps: Vec<FxStep> = run
+                    .iter()
+                    .zip(&params)
+                    .zip(&hosts)
+                    .map(|(((i, g, s), params), host)| FxStep {
+                        spec: s,
+                        ctx: EffectCtx {
+                            params,
+                            time: lt.seconds(),
+                            layer_size,
+                            seed: g.uid as u32,
+                            adjustment,
+                            env: EffectEnv { host: Some(host), effect_index: *i, ..env },
+                        },
+                    })
+                    .collect();
+                let t0 = web_time::Instant::now();
+                if target.gpu(&steps) {
+                    if let Some(v) = timing.as_deref_mut() {
+                        let ms = t0.elapsed().as_secs_f64() * 1e3 / run.len() as f64;
+                        v.extend(run.iter().map(|(_, _, s)| (format!("{} (gpu)", s.id), ms)));
+                    }
+                    k += run.len();
+                    continue;
+                }
+            }
+            k += 1;
+            let params = self.effect_params(ctx, layer, g);
+            let host = FxHost { index: i, ..host };
+            let env = EffectEnv { host: Some(&host), effect_index: i, ..env };
+            let ectx = EffectCtx { params: &params, time: lt.seconds(), layer_size, seed: g.uid as u32, adjustment, env };
+            let t0 = web_time::Instant::now();
+            target.cpu(&mut |buf| {
+                let mut buf = effectcraft_effects::apply(spec, &ectx, buf);
+                // 8/16 bpc effects write integer pixels.
+                self.pipe.quantize(&mut buf.img);
+                buf
+            });
+            if let Some(v) = timing.as_deref_mut() {
+                v.push((spec.id.to_string(), t0.elapsed().as_secs_f64() * 1e3));
+            }
+        }
+    }
+
+    /// Source pixels of a layer in layer space (before masks/effects).
+    pub(crate) fn source(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Buf> {
+        let s = self.opts.scale;
+        match &layer.source {
+            LayerSource::Solid { item } => {
+                let ItemKind::Solid(sol) = &self.project.item(*item)?.kind else { return None };
+                let w = ((sol.width as f64 * s).ceil() as u32).max(1);
+                let h = ((sol.height as f64 * s).ceil() as u32).max(1);
+                if layer.switches.adjustment {
+                    return Some(Buf { img: Image::filled(w, h, [1.0; 4]), offset: [0.0; 2], scale: s });
+                }
+                let mut c = sol.color;
+                if let Some(conv) = self.pipe.authored_in() {
+                    c = conv.apply(c);
+                }
+                let px = self.pipe.quantize_px([c[0], c[1], c[2], 1.0]);
+                Some(Buf { img: Image::filled(w, h, px), offset: [0.0; 2], scale: s })
+            }
+            LayerSource::Comp { item } => {
+                if self.project.comp_contains(*item, ctx.comp_id) {
+                    return None;
+                }
+                // A composition proxy (a rendered still or movie) stands in for the comp. It is
+                // decoded like footage: its Separate Fields, Invert Alpha and Interpret As Linear
+                // Light settings and the layer's Frame Blending apply. Nothing before the nested
+                // comp starts or after it ends.
+                let lt = ctx.nested_time(layer);
+                if !self.project.comp(*item).is_some_and(|nc| nc.covers(lt)) {
+                    return None;
+                }
+                if let Some(pf) = self.proxy_for(*item)
+                    && let Some(nc) = self.project.comp(*item)
+                {
+                    let img = self.footage_frame(ctx, layer, *item, pf, lt, None)?;
+                    return Some(self.footage_buf(&img, pf, nc.width, nc.height));
+                }
+                // Essential Properties overrides render the nested comp with this instance's
+                // values.
+                let ov = essential_overrides(ctx, layer);
+                let tmp = if ov.is_empty() { None } else { effectcraft_project::essential::with_overrides(self.project, *item, &ov) };
+                // Preserve resolution when nested: drawn at full size even when this comp renders
+                // smaller (the buffer's scale places it).
+                let full = s < 1.0 && self.project.comp(*item).is_some_and(|nc| nc.preserve_resolution);
+                let bs = if full { 1.0 } else { s };
+                let base = self.nested_through(layer);
+                let base = Renderer { opts: RenderOpts { scale: bs, ..base.opts }, ..base };
+                let sub = match &tmp {
+                    Some(p) => Renderer { project: p, ..base },
+                    None => base,
+                };
+                // Frame blending between the nested comp's frames (time-stretched/remapped).
+                let mode = frame_blend_mode(ctx, layer);
+                if mode != FrameBlend::Off
+                    && let Some(nc) = self.project.comp(*item)
+                {
+                    let (i, w) = frame_position(lt, nc.frame_rate);
+                    if w > 1e-6 {
+                        let a = sub.comp_frame(*item, nc.frame_rate.tick_of(i));
+                        let b = sub.comp_frame(*item, nc.frame_rate.tick_of(i + 1));
+                        return Some(Buf { img: blend_frames(mode, &a, &b, w as f32), offset: [0.0; 2], scale: bs });
+                    }
+                }
+                Some(Buf { img: sub.comp_frame(*item, lt), offset: [0.0; 2], scale: bs })
+            }
+            LayerSource::Footage { item } => {
+                let item = ctx.media_item(layer, *item);
+                let it = self.project.item(item)?;
+                let ItemKind::Footage(f) = &it.kind else { return None };
+                if !f.has_video {
+                    return None;
+                }
+                // Continuously rasterised vector footage: drawn at the on-screen scale.
+                if layer.switches.collapse && is_vector_footage(f) {
+                    let k = self.raster_scale(ctx, layer);
+                    if let Some(img) = self.footage.vector_frame(item, f, k) {
+                        let mut buf = Buf { img: (*img).clone(), offset: [0.0; 2], scale: k };
+                        if let Some(c) = self.pipe.media_in(f) {
+                            color::convert(&mut buf.img, &c);
+                        }
+                        return Some(buf);
+                    }
+                }
+                let lt = ctx.source_time(layer);
+                // The proxy is decoded instead, at its own size, and fills the footage's frame.
+                let proxy = self.proxy_for(item);
+                let pf = proxy.unwrap_or(f);
+                let size = self.reduced_size(f.width, f.height).filter(|_| proxy.is_none());
+                let img = self.footage_frame(ctx, layer, item, pf, lt, size)?;
+                Some(self.footage_buf(&img, pf, f.width, f.height))
+            }
+            LayerSource::Text => Some(self.authored(text::render(ctx, layer, self.raster_scale(ctx, layer)))),
+            LayerSource::Shape => layer.props.sub("contents").map(|c| self.authored(shapes::render(ctx, layer, c, self.raster_scale(ctx, layer)))),
+            _ => None,
+        }
+    }
+
+    /// The proxy footage used for `item` under this render's Proxy Use, if any.
+    pub fn proxy_for(&self, item: ItemId) -> Option<&'a Footage> {
+        let it = self.project.item(item)?;
+        let px = it.proxy.as_deref()?;
+        (self.opts.proxy.uses(matches!(it.kind, ItemKind::Comp(_)), px.enabled) && px.footage.has_video).then_some(&px.footage)
+    }
+
+    /// A decoded frame of `f` as a layer buffer covering `w`×`h` layer pixels (the footage's
+    /// nominal size; proxies are scaled up to it), converted from its colour profile.
+    fn footage_buf(&self, img: &Image, f: &Footage, w: u32, h: u32) -> Buf {
+        let s = self.opts.scale;
+        let k = if img.width > 0 { w.max(1) as f64 / img.width as f64 } else { 1.0 };
+        // Keep native pixels when downsampling is small; resample otherwise.
+        let mut buf = match self.reduced_size(w, h) {
+            // The source resampled it already (`FootageSource::frame_at_size`).
+            Some(size) if (img.width, img.height) == size => Buf { img: img.clone(), offset: [0.0; 2], scale: s },
+            Some((rw, rh)) if k <= 1.0 + 1e-9 => Buf { img: effectcraft_raster::resample(img, rw, rh), offset: [0.0; 2], scale: s },
+            _ => Buf { img: img.clone(), offset: [0.0; 2], scale: 1.0 / k },
+        };
+        if let Some(c) = self.pipe.media_in(f) {
+            color::convert(&mut buf.img, &c);
+        }
+        buf
+    }
+
+    /// The size of `w` × `h` layer pixels in this render when it is reduced enough that footage
+    /// is resampled to it (below 3/4 scale).
+    fn reduced_size(&self, w: u32, h: u32) -> Option<(u32, u32)> {
+        let s = self.opts.scale;
+        (s < 0.75).then(|| (((w as f64 * s).round() as u32).max(1), ((h as f64 * s).round() as u32).max(1)))
+    }
+
+    /// Authored colours into the working space (linear working spaces).
+    fn authored(&self, mut buf: Buf) -> Buf {
+        if let Some(c) = self.pipe.authored_in() {
+            color::convert(&mut buf.img, &c);
+        }
+        buf
+    }
+
+    /// A footage frame at source time `t`, frame-blended between the two nearest source frames
+    /// when the layer's Frame Blending switch (and the comp's Enable Frame Blending) is on and
+    /// `t` falls between frames (footage rate ≠ comp rate, time stretch, time remapping).
+    /// `size`: a plain frame may come resampled to it ([`FootageSource::frame_at_size`]).
+    fn footage_frame(&self, ctx: &EvalCtx, layer: &Layer, item: ItemId, f: &Footage, t: Tick, size: Option<(u32, u32)>) -> Option<Arc<Image>> {
+        // Interpret Footage ▸ Separate Fields: each field is a frame at twice the rate.
+        if f.fields != effectcraft_project::FieldOrder::Off && matches!(f.kind, FootageKind::Video | FootageKind::Sequence) {
+            let field_rate = FrameRate::new(f.frame_rate.num * 2, f.frame_rate.den);
+            let i = field_rate.frame_at(t).max(0);
+            let img = cineon_frame(self.footage.frame_with(item, f, f.frame_rate.tick_of(i / 2), None, self.pipe.float_curve(f))?, f);
+            let dominant_upper = f.fields == effectcraft_project::FieldOrder::UpperFirst;
+            // Upper field = even lines (0, 2, …).
+            let parity = if (i % 2 == 0) == dominant_upper { 0 } else { 1 };
+            return Some(Arc::new(interpret_pixels(&field_frame(&img, parity), f, self.pipe.linear_footage_space(f))));
+        }
+        // Interpretation is per pixel but not linear: it runs on the frame before resampling.
+        let per_pixel = f.invert_alpha || f.linear_light_applies();
+        let size = size.filter(|_| !(per_pixel || f.cineon_applies()));
+        let img = self.footage_frame_raw(ctx, layer, item, f, t, size)?;
+        if per_pixel { Some(Arc::new(interpret_pixels(&img, f, self.pipe.linear_footage_space(f)))) } else { Some(img) }
+    }
+
+    fn footage_frame_raw(&self, ctx: &EvalCtx, layer: &Layer, item: ItemId, f: &Footage, t: Tick, size: Option<(u32, u32)>) -> Option<Arc<Image>> {
+        let mode = frame_blend_mode(ctx, layer);
+        let float = self.pipe.float_curve(f);
+        if mode != FrameBlend::Off && matches!(f.kind, FootageKind::Video | FootageKind::Sequence) {
+            let (i, w) = frame_position(t, f.frame_rate);
+            if w > 1e-6 {
+                // Blended frames are cached (Pixel Motion is expensive).
+                let key = self.cache.map(|_| {
+                    use std::hash::{Hash, Hasher};
+                    let mut h = std::collections::hash_map::DefaultHasher::new();
+                    (0x00f8_a3e5_u64, item, i, (w as f32).to_bits(), mode as u8, f.frame_rate.num, f.frame_rate.den, &f.path, float).hash(&mut h);
+                    (f.alpha as u8).hash(&mut h);
+                    if f.alpha == effectcraft_project::AlphaMode::Premultiplied {
+                        f.premul_color.map(f32::to_bits).hash(&mut h);
+                    }
+                    if f.cineon_applies() {
+                        let c = &f.cineon;
+                        [c.converted_black, c.converted_white, c.black, c.white, c.gamma, c.rolloff].map(f32::to_bits).hash(&mut h);
+                    }
+                    h.finish()
+                });
+                if let (Some(c), Some(k)) = (self.cache, key)
+                    && let Some(b) = c.get(k)
+                {
+                    return Some(Arc::new(b.img.clone()));
+                }
+                // Log scans are converted before they blend: the conversion is not linear.
+                let a = self.footage.frame_with(item, f, f.frame_rate.tick_of(i), None, float).map(|a| cineon_frame(a, f));
+                let b = self.footage.frame_with(item, f, f.frame_rate.tick_of(i + 1), None, float).map(|b| cineon_frame(b, f));
+                if let (Some(a), Some(b)) = (a, b) {
+                    let img = blend_frames(mode, &a, &b, w as f32);
+                    if let (Some(c), Some(k)) = (self.cache_to_keep(), key) {
+                        c.insert(k, Arc::new(Buf { img: img.clone(), offset: [0.0; 2], scale: 1.0 }));
+                    }
+                    return Some(Arc::new(img));
+                }
+            }
+        }
+        self.footage.frame_with(item, f, t, size, float).map(|img| cineon_frame(img, f))
+    }
+
+    /// Source → masks, clamped/quantised to the project depth.
+    fn masked_source(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Buf> {
+        let mut buf = match self.content_times(ctx, layer) {
+            Some(times) => self.blurred_source(ctx, layer, &times)?,
+            None => self.source(ctx, layer)?,
+        };
+        // A solid is filled with a quantised colour: only masks can take it off the grid.
+        let solid = matches!(layer.source, LayerSource::Solid { .. });
+        if masks::apply(ctx, layer, &mut buf, self.mask_blur(ctx, layer)) || !solid {
+            self.pipe.quantize(&mut buf.img);
+        }
+        Some(buf)
+    }
+
+    /// Fully processed layer buffer (source → masks → effects → layer styles, flattened).
+    /// Served from the layer cache when the layer's content key matches.
+    pub fn layer_buf(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<Buf>> {
+        self.layer_buf_keyed(ctx, layer).map(|(b, _)| b)
+    }
+
+    /// [`Self::layer_buf`] in the blending space (linear with Blend Colors Using 1.0 Gamma).
+    pub fn blend_layer_buf(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<Buf>> {
+        let (b, k) = self.layer_buf_keyed(ctx, layer)?;
+        Some(self.to_blend(b, k))
+    }
+
+    /// A buffer converted to the blending space (cached under a key derived from `key`).
+    pub(crate) fn to_blend(&self, b: Arc<Buf>, key: Option<u64>) -> Arc<Buf> {
+        let Some(c) = self.pipe.to_blend() else { return b };
+        let key = key.map(|k| cache::derive(k, 0x1ea7));
+        if let (Some(cache), Some(k)) = (self.cache, key)
+            && let Some(x) = cache.get(k)
+        {
+            return x;
+        }
+        let mut nb = (*b).clone();
+        color::convert(&mut nb.img, &c);
+        let nb = Arc::new(nb);
+        // The buffer the cache keeps (another worker's, if it kept one first).
+        match (self.cache_to_keep(), key) {
+            (Some(cache), Some(k)) => cache.insert(k, nb),
+            _ => nb,
+        }
+    }
+
+    fn layer_buf_keyed(&self, ctx: &EvalCtx, layer: &Layer) -> Option<(Arc<Buf>, Option<u64>)> {
+        let st = self.styled(ctx, layer, None)?;
+        if st.passes.is_empty() {
+            return Some((st.body, st.key));
+        }
+        let key = st.key.map(|k| cache::derive(k, 0xf1a7));
+        if let (Some(c), Some(k)) = (self.cache, key)
+            && let Some(b) = c.get(k)
+        {
+            return Some((b, key));
+        }
+        let flat = Arc::new(styles::Styled { passes: st.passes.iter().map(|(b, m)| ((**b).clone(), *m)).collect(), body: (*st.body).clone() }.flatten());
+        // The buffer the cache keeps (another worker's, if it kept one first).
+        let flat = match (self.cache_to_keep(), key) {
+            (Some(c), Some(k)) => c.insert(k, flat),
+            _ => flat,
+        };
+        Some((flat, key))
+    }
+
+    /// A layer's source pixels at the context time, before masks, effects and the transform
+    /// (what the motion tracker analyses, like After Effects' Layer panel). `None` for layers
+    /// without pixels.
+    pub fn layer_source(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Buf> {
+        self.source(ctx, layer)
+    }
+
+    /// A 3D model or primitive layer rendered on its own, through the comp's camera: what an
+    /// effect layer parameter reads when it references one, as After Effects, which renders 3D
+    /// layers through the active camera. The comp's pixels at this render's scale; the layer's
+    /// blend mode, track matte and video switch don't apply (a source read, not a composite —
+    /// the solo clone of a 3D track matte, see `three_d::adv`).
+    pub(crate) fn solo_3d(&self, ctx: &EvalCtx, layer: &Layer) -> Buf {
+        let s = self.opts.scale;
+        let w = ((ctx.comp.width as f64 * s).ceil() as u32).max(1);
+        let h = ((ctx.comp.height as f64 * s).ceil() as u32).max(1);
+        let mut canvas = Image::new(w, h);
+        // Outside the layer's in/out points there is nothing to read: the copy is transparent
+        // there, like any other layer reference (the 3D pipelines don't gate on the range).
+        if !layer.is_active_at(ctx.time) {
+            return Buf { img: canvas, offset: [0.0; 2], scale: s };
+        }
+        let mut solo = layer.clone();
+        solo.track_matte = None;
+        solo.blend_mode = effectcraft_color::BlendMode::Normal;
+        solo.preserve_transparency = false;
+        solo.switches.video = true;
+        three_d::compose::draw_run(self, ctx, &[&solo], &mut canvas);
+        Buf { img: canvas, offset: [0.0; 2], scale: s }
+    }
+
+    /// Layer pixels after source → masks → effects (no layer styles).
+    pub fn content_buf(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<Buf>> {
+        self.content_buf_timed(ctx, layer, None).map(|(b, _)| b)
+    }
+
+    pub(crate) fn content_buf_timed(&self, ctx: &EvalCtx, layer: &Layer, mut timing: Option<&mut LayerTiming>) -> Option<(Arc<Buf>, Option<u64>)> {
+        let key = self.cache.and_then(|_| cache::layer_key(ctx, layer, self.raster_scale(ctx, layer), self.opts.draft, self.mb_on(ctx, layer)));
+        let key = self.content_key(ctx, layer, key);
+        if let (Some(c), Some(k)) = (self.cache, key)
+            && let Some(b) = c.get(k)
+        {
+            if let Some(t) = timing.as_deref_mut() {
+                t.cached = true;
+            }
+            return Some((b, key));
+        }
+        let buf = self.masked_source(ctx, layer)?;
+        let buf = Arc::new(self.apply_effects_timed(ctx, layer, buf, false, usize::MAX, timing.map(|t| &mut t.effects)));
+        // The buffer the cache keeps (another worker's, if it kept one first).
+        let buf = match (self.cache_to_keep(), key) {
+            (Some(c), Some(k)) => c.insert(k, buf),
+            _ => buf,
+        };
+        Some((buf, key))
+    }
+
+    /// A layer's input at the context time: source → masks → its first `effects` effects
+    /// (what Time effects read at neighbouring times), in effect space (see [`effect_bounds`]):
+    /// what effect `effects` sees. Served from / stored in the layer cache under its own key,
+    /// so scrubbing reuses frames rendered for earlier output frames.
+    pub fn layer_input(&self, ctx: &EvalCtx, layer: &Layer, effects: usize) -> Option<Arc<Buf>> {
+        let key = self.cache.and_then(|_| cache::input_key(ctx, layer, self.raster_scale(ctx, layer), self.opts.draft, self.mb_on(ctx, layer), effects));
+        let key = self.content_key(ctx, layer, key);
+        if let (Some(c), Some(k)) = (self.cache, key)
+            && let Some(b) = c.get(k)
+        {
+            return Some(b);
+        }
+        let mut buf = self.masked_source(ctx, layer)?;
+        let origin = ctx.effect_bounds(layer).1;
+        buf.rebase(origin);
+        if effects > 0 {
+            buf = self.effect_space_stack(ctx, layer, buf, EffectStack { adjustment: false, limit: effects, origin }, None);
+        }
+        let buf = Arc::new(buf);
+        // The buffer the cache keeps (another worker's, if it kept one first).
+        let buf = match (self.cache_to_keep(), key) {
+            (Some(c), Some(k)) => c.insert(k, buf),
+            _ => buf,
+        };
+        Some(buf)
+    }
+}
diff --git a/crates/render/src/shapes.rs b/crates/render/src/shapes.rs
index f8de5a290..2497ea807 100644
--- a/crates/render/src/shapes.rs
+++ b/crates/render/src/shapes.rs
@@ -2,8 +2,8 @@
 //! with the After Effects stacking semantics:
 //!
 //! - path operators (Trim Paths, Round Corners, Offset Paths, Pucker & Bloat, Twist, Zig Zag,
-//!   Wiggle Paths, Merge Paths, Repeater) act on all paths above them in the same group, including
-//!   the paths of nested groups;
+//!   Wiggle Paths, Wiggle Transform, Merge Paths, Repeater) act on all paths above them in the
+//!   same group, including the paths of nested groups;
 //! - paint items (fills, strokes, gradient fills/strokes) paint the paths above them, *as modified
 //!   by every operator in the stack* — a Trim Paths below a Stroke still trims it;
 //! - items higher in the list draw on top;
@@ -17,7 +17,9 @@ use effectcraft_keyframe::{Gradient, Value};
 use effectcraft_path::{BezPath, Cap, FillRule, Join, StrokeStyle, ops, varstroke};
 use effectcraft_project::{Layer, Node, PropGroup};
 use effectcraft_raster::{Image, Mask};
+use effectcraft_text::selectors::{self, Wiggly};
 use rayon::prelude::*;
+use std::collections::{HashMap, HashSet};
 
 use crate::eval::EvalCtx;
 
@@ -185,9 +187,75 @@ fn used_slots(live: &[usize], draws: &[Draw]) -> Vec<usize> {
     v
 }
 
+/// Wiggle Transform: moves the live slots by a random offset of the Transform group's Anchor
+/// Point, Position, Scale and Rotation (the most each one wiggles), changing over time. Its
+/// Wiggles/Second, Correlation, Temporal Phase, Spatial Phase and Random Seed work as the Wiggly
+/// Selector's do, with each Repeater copy (`copy_of`) as one unit: the copies of a Repeater above
+/// the operation move on their own as far as Correlation allows, and the copies of a Repeater
+/// below it move as one. The four transformations of one operation move together.
+fn wiggle_transform(ctx: &EvalCtx, layer: &Layer, g: &PropGroup, arena: &mut [BezPath], live: &[usize], copy_of: &HashMap<usize, usize>, draws: &mut [Draw]) {
+    let Some(tr) = g.sub("transform") else { return };
+    let w = Wiggly {
+        max: 1.0,
+        min: -1.0,
+        wiggles_per_second: ctx.f(layer, g, "speed", 2.0),
+        correlation: ctx.f(layer, g, "correlation", 50.0) / 100.0,
+        temporal_phase: ctx.f(layer, g, "phase", 0.0),
+        spatial_phase: ctx.f(layer, g, "spatialPhase", 0.0),
+        lock_dimensions: false,
+        seed: ctx.f(layer, g, "seed", 0.0).round() as i64 as u64,
+    };
+    let anchor = ctx.v2(layer, tr, "anchor", [0.0; 2]);
+    let pos = ctx.v2(layer, tr, "position", [0.0; 2]);
+    let scale = ctx.v2(layer, tr, "scale", [0.0; 2]);
+    let rot = ctx.f(layer, tr, "rotation", 0.0);
+    let t = layer.layer_time(ctx.time).seconds();
+    let matrix = |k: usize| {
+        let (x, y) = (selectors::wiggly_value(&w, t, k, 0), selectors::wiggly_value(&w, t, k, 1));
+        Mat3::translate(vec2(pos[0] * x, pos[1] * y))
+            * Mat3::rotate_deg(rot * x)
+            * Mat3::scale(vec2(1.0 + scale[0] * x / 100.0, 1.0 + scale[1] * y / 100.0))
+            * Mat3::translate(vec2(-anchor[0] * x, -anchor[1] * y))
+    };
+    let mut by_copy: HashMap<usize, Mat3> = HashMap::new();
+    let mut done: HashSet<usize> = HashSet::new();
+    for &s in live {
+        if !done.insert(s) {
+            continue;
+        }
+        let k = copy_of.get(&s).copied().unwrap_or(0);
+        let m = *by_copy.entry(k).or_insert_with(|| matrix(k));
+        arena[s] = mat_path(&arena[s], &m);
+    }
+    // A paint above the operation whose paths all moved by one matrix moves its gradient and
+    // stroke scale with them, as a group transform does. A paint over copies that moved by
+    // different matrices stays one paint (its fill rule and opacity apply to all of them at once)
+    // and keeps its gradient and stroke scale.
+    for d in draws {
+        let mut ms = d.slots.iter().map(|s| done.contains(s).then(|| by_copy.get(&copy_of.get(s).copied().unwrap_or(0)).copied()).flatten());
+        let Some(Some(m)) = ms.next() else { continue };
+        if ms.all(|x| x == Some(m)) {
+            d.xf = m * d.xf;
+        }
+    }
+}
+
 /// Collect the draws of a contents group and the path slots live at its end (in group space).
 /// `arena` holds every path slot; operators rewrite slots in place.
 fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<BezPath>) -> (Vec<Draw>, Vec<usize>) {
+    collect_in(ctx, layer, contents, arena, &mut Copies::default())
+}
+
+/// The Repeater copy each path slot belongs to, for Wiggle Transform: `of` maps a slot a Repeater
+/// made to its copy's id (slots no Repeater made are copy 0). Ids are unique across the layer's
+/// groups, so copies made in a nested group stay apart in the groups around it.
+#[derive(Default)]
+struct Copies {
+    of: HashMap<usize, usize>,
+    next: usize,
+}
+
+fn collect_in(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<BezPath>, copy_ids: &mut Copies) -> (Vec<Draw>, Vec<usize>) {
     let mut draws: Vec<Draw> = Vec::new();
     let mut live: Vec<usize> = Vec::new();
     let opacity = |g: &PropGroup| (ctx.f(layer, g, "opacity", 100.0) / 100.0) as f32;
@@ -201,7 +269,20 @@ fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<B
             "rect" => {
                 let size = ctx.v2(layer, g, "size", [100.0; 2]);
                 let pos = ctx.v2(layer, g, "position", [0.0; 2]);
-                let p = effectcraft_path::rect(size, pos, ctx.f(layer, g, "roundness", 0.0));
+                let p = if ctx.b(layer, g, "perCorner") {
+                    effectcraft_path::rect_radii(
+                        size,
+                        pos,
+                        [
+                            ctx.f(layer, g, "topLeftRoundness", 0.0),
+                            ctx.f(layer, g, "topRightRoundness", 0.0),
+                            ctx.f(layer, g, "bottomRightRoundness", 0.0),
+                            ctx.f(layer, g, "bottomLeftRoundness", 0.0),
+                        ],
+                    )
+                } else {
+                    effectcraft_path::rect(size, pos, ctx.f(layer, g, "roundness", 0.0))
+                };
                 push_shape(ctx, layer, g, p, arena, &mut live);
             }
             "ellipse" => {
@@ -211,16 +292,16 @@ fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<B
             }
             "star" => {
                 let star = ctx.e(layer, g, "type") == 0;
-                let p = effectcraft_path::polystar(
+                let p = effectcraft_path::polystar(effectcraft_path::Polystar {
                     star,
-                    ctx.f(layer, g, "points", 5.0),
-                    ctx.v2(layer, g, "position", [0.0; 2]),
-                    ctx.f(layer, g, "rotation", 0.0),
-                    ctx.f(layer, g, "innerRadius", 50.0),
-                    ctx.f(layer, g, "outerRadius", 100.0),
-                    ctx.f(layer, g, "innerRoundness", 0.0),
-                    ctx.f(layer, g, "outerRoundness", 0.0),
-                );
+                    points: ctx.f(layer, g, "points", 5.0),
+                    pos: ctx.v2(layer, g, "position", [0.0; 2]),
+                    rotation: ctx.f(layer, g, "rotation", 0.0),
+                    inner: ctx.f(layer, g, "innerRadius", 50.0),
+                    outer: ctx.f(layer, g, "outerRadius", 100.0),
+                    inner_round: ctx.f(layer, g, "innerRoundness", 0.0),
+                    outer_round: ctx.f(layer, g, "outerRoundness", 0.0),
+                });
                 push_shape(ctx, layer, g, p, arena, &mut live);
             }
             "path" => {
@@ -324,11 +405,13 @@ fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<B
                     speed: ctx.f(layer, g, "speed", 2.0),
                     correlation: ctx.f(layer, g, "correlation", 50.0),
                     phase_deg: ctx.f(layer, g, "phase", 0.0),
+                    spatial_phase_deg: ctx.f(layer, g, "spatialPhase", 0.0),
                     seed: ctx.f(layer, g, "seed", 0.0),
                 };
                 let t = layer.layer_time(ctx.time).seconds();
                 apply(arena, &live, |p| ops::wiggle(p, &w, t));
             }
+            "wiggler" => wiggle_transform(ctx, layer, g, arena, &live, &copy_ids.of, &mut draws),
             "merge" => {
                 let mode = ops::MergeMode::from_index(ctx.e(layer, g, "mode"));
                 let input: Vec<BezPath> = live.iter().map(|&i| arena[i].clone()).collect();
@@ -341,7 +424,7 @@ fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<B
             }
             "group" => {
                 let Some(inner) = g.sub("contents") else { continue };
-                let (cd, cl) = collect(ctx, layer, inner, arena);
+                let (cd, cl) = collect_in(ctx, layer, inner, arena, copy_ids);
                 let (m, op) = g.sub("transform").map(|t| group_matrix(ctx, layer, t)).unwrap_or((Mat3::IDENTITY, 1.0));
                 for i in used_slots(&cl, &cd) {
                     arena[i] = mat_path(&arena[i], &m);
@@ -378,12 +461,20 @@ fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<B
                 // Each copy gets its own transformed slots, so operators below the repeater act on
                 // the repeated geometry (copy order: original first).
                 let mut copy_maps: Vec<std::collections::HashMap<usize, usize>> = Vec::with_capacity(n);
+                // Each copy of each earlier copy (a second Repeater) gets an id of its own.
+                let mut ids: HashMap<(usize, usize), usize> = HashMap::new();
                 for i in 0..n {
                     let m = step(i as f64 + offset);
                     let mut map = std::collections::HashMap::new();
                     for &s in &base_slots {
                         arena.push(mat_path(&arena[s], &m));
                         map.insert(s, arena.len() - 1);
+                        let base = copy_ids.of.get(&s).copied().unwrap_or(0);
+                        let id = *ids.entry((i, base)).or_insert_with(|| {
+                            copy_ids.next += 1;
+                            copy_ids.next
+                        });
+                        copy_ids.of.insert(arena.len() - 1, id);
                     }
                     live.extend(base_live.iter().map(|s| map[s]));
                     copy_maps.push(map);
@@ -395,7 +486,10 @@ fn collect(ctx: &EvalCtx, layer: &Layer, contents: &PropGroup, arena: &mut Vec<B
                 }
                 for i in order {
                     let m = step(i as f64 + offset);
-                    let t = if n > 1 { i as f32 / (n - 1) as f32 } else { 0.0 };
+                    // Copy i's opacity moves 1 / Copies of the way from Start to End Opacity per
+                    // copy, so the last copy stops one step short of End Opacity (After Effects
+                    // 2026, case 709: 3 copies, End Opacity 40 give 100 %, 80 %, 60 %).
+                    let t = if copies > 0.0 { (i as f64 / copies) as f32 } else { 0.0 };
                     let opk = so + (eo - so) * t;
                     let partial = if i + 1 == n && copies.fract() > 0.0 { copies.fract() as f32 } else { 1.0 };
                     for d in &base_draws {
diff --git a/crates/render/src/shapes/tests.rs b/crates/render/src/shapes/tests.rs
index 1dbf67a7a..ba7028a25 100644
--- a/crates/render/src/shapes/tests.rs
+++ b/crates/render/src/shapes/tests.rs
@@ -150,6 +150,28 @@ fn operators_below_repeater_act_on_copies() {
     assert!((coverage(&img) - 3.0 * 24.0 * 24.0).abs() < 30.0, "{}", coverage(&img));
 }
 
+/// After Effects 2026 (case 709): a 400 × 200 rectangle with Fill, then a Repeater of 3 copies
+/// (Position 150, 60, Rotation 10, Scale 90 / 80, End Opacity 40) gives the copies 100 %, 80 %
+/// and 60 % opacity (EffectCraft gave 70 % and 40 %). The points are comp pixels where AE shows
+/// only the last copy, only the middle one, and both.
+#[test]
+fn repeater_copy_opacity_matches_after_effects() {
+    let (p, cid) = shape_comp_sized(1920, 1080, |ids| {
+        let mut rep = build::shape_repeater(ids, 3.0, [150.0, 60.0]);
+        set(&mut rep, "transform/rotation", Value::Scalar(10.0));
+        set(&mut rep, "transform/scale", Value::Vec2([90.0, 80.0]));
+        set(&mut rep, "transform/endOpacity", Value::Scalar(40.0));
+        let items = vec![build::shape_rect(ids, [400.0, 200.0], [0.0, 0.0], 0.0), build::shape_fill(ids, [0.0, 1.0, 0.0, 1.0]), rep];
+        vec![build::shape_group(ids, "Group 1", items)]
+    });
+    let img = frame(&p, cid);
+    // AE's green over its red layer, 153, 153, 204, 235 and 255 of 255.
+    for (x, y, want) in [(1360, 700, 0.6), (1300, 620, 0.6), (1220, 560, 0.8), (1180, 630, 0.92), (1100, 600, 1.0)] {
+        let a = alpha(&img, x, y);
+        assert!((a - want).abs() < 2.0 / 255.0, "({x}, {y}): {a} vs AE {want}");
+    }
+}
+
 #[test]
 fn repeater_then_merge_unites_copies() {
     let (p, cid) = shape_comp(|ids| {
@@ -258,6 +280,24 @@ fn round_corners_clip_corner_pixels() {
     assert!((coverage(&img) - std::f32::consts::PI * 400.0).abs() < 15.0, "{}", coverage(&img));
 }
 
+/// Wiggle Paths' Spatial Phase changes the drawn shape; a whole turn draws it as at 0°.
+#[test]
+fn wiggle_paths_spatial_phase_renders() {
+    let render = |phase: f64| {
+        let (p, cid) = shape_comp(|ids| {
+            vec![
+                build::shape_ellipse(ids, [60.0, 60.0], [0.0, 0.0]),
+                op(ids, "wiggle", &[("size", Value::Scalar(8.0)), ("correlation", Value::Scalar(0.0)), ("spatialPhase", Value::Scalar(phase))]),
+                build::shape_fill(ids, RED),
+            ]
+        });
+        render_frame(&p, cid, Tick::from_seconds_f64(0.5), 1.0).data
+    };
+    let zero = render(0.0);
+    assert!(render(90.0) != zero, "Spatial Phase 90° draws the shape of 0°");
+    assert!(render(360.0) == zero, "Spatial Phase 360° draws another shape than 0°");
+}
+
 #[test]
 fn wiggle_paths_vary_over_time_deterministically() {
     let (p, cid) = shape_comp(|ids| {
@@ -270,6 +310,202 @@ fn wiggle_paths_vary_over_time_deterministically() {
     assert_ne!(a.data, c.data);
 }
 
+/// Alpha-weighted centroid of the pixels in columns `x0..x1`.
+fn centroid(img: &Image, x0: i64, x1: i64) -> [f32; 2] {
+    let (mut sx, mut sy, mut sa) = (0.0, 0.0, 0.0);
+    for x in x0..x1 {
+        for y in 0..img.height as i64 {
+            let a = alpha(img, x, y);
+            sx += a * x as f32;
+            sy += a * y as f32;
+            sa += a;
+        }
+    }
+    [sx / sa, sy / sa]
+}
+
+fn wiggle_transform(ids: &mut Ids, params: &[(&str, Value)]) -> PropGroup {
+    op(ids, "wiggler", params)
+}
+
+#[test]
+fn wiggle_transform_moves_paths_over_time() {
+    let run = |position: [f64; 2], t: f64| {
+        let (p, cid) = shape_comp(|ids| {
+            let w = wiggle_transform(ids, &[("transform/position", Value::Vec2(position))]);
+            vec![build::shape_rect(ids, [20.0, 20.0], [0.0, 0.0], 0.0), w, build::shape_fill(ids, RED)]
+        });
+        render_frame(&p, cid, Tick::from_seconds_f64(t), 1.0)
+    };
+    // The defaults wiggle nothing: the square stays centered on pixel 99.5, 49.5.
+    let rest = [99.5, 49.5];
+    assert_eq!(centroid(&run([0.0, 0.0], 0.37), 0, 200), rest);
+    let a = run([15.0, 15.0], 0.37);
+    assert_eq!(a.data, run([15.0, 15.0], 0.37).data, "the same time gives the same frame");
+    let b = run([15.0, 15.0], 1.21);
+    let (ca, cb) = (centroid(&a, 0, 200), centroid(&b, 0, 200));
+    assert!(ca != rest && ca != cb, "{ca:?} {cb:?}");
+    for c in [ca, cb] {
+        assert!((c[0] - rest[0]).abs() <= 15.01 && (c[1] - rest[1]).abs() <= 15.01, "{c:?}");
+    }
+    // A translation keeps the square's area.
+    assert!((coverage(&a) - 400.0).abs() < 1.0, "{}", coverage(&a));
+    // The layer cache keys a layer with a Wiggle Transform by time.
+    let (p, cid) = shape_comp(|ids| vec![build::shape_rect(ids, [20.0, 20.0], [0.0, 0.0], 0.0), wiggle_transform(ids, &[]), build::shape_fill(ids, RED)]);
+    let comp = p.comp(cid).unwrap();
+    let key = |t: f64| crate::cache::layer_key(&crate::eval::EvalCtx::new(&p, cid, comp, Tick::from_seconds_f64(t)), &comp.layers[0], 1.0, false, false);
+    assert_ne!(key(0.37), key(1.21));
+}
+
+#[test]
+fn wiggle_transform_scales_and_rotates() {
+    let run = |params: &[(&str, Value)]| {
+        let (p, cid) = shape_comp(|ids| {
+            let w = wiggle_transform(ids, params);
+            vec![build::shape_rect(ids, [40.0, 40.0], [0.0, 0.0], 0.0), w, build::shape_fill(ids, RED)]
+        });
+        render_frame(&p, cid, Tick::from_seconds_f64(0.37), 1.0)
+    };
+    let scaled = coverage(&run(&[("transform/scale", Value::Vec2([50.0, 50.0]))]));
+    assert!((scaled - 1600.0).abs() > 20.0, "{scaled}");
+    let rotated = run(&[("transform/rotation", Value::Scalar(45.0))]);
+    assert!((coverage(&rotated) - 1600.0).abs() < 2.0, "{}", coverage(&rotated));
+    assert!(alpha(&rotated, 81, 31) < 0.5 || alpha(&rotated, 119, 31) < 0.5, "a corner turned away");
+}
+
+/// A gradient above a Wiggle Transform moves with the paths it paints, as under a group transform.
+#[test]
+fn wiggle_transform_moves_the_gradient_with_the_path() {
+    let (p, cid) = shape_comp(|ids| {
+        let g = Gradient { colors: vec![(0.0, [0.0, 0.0, 0.0, 1.0]), (1.0, [1.0, 1.0, 1.0, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 1.0)] };
+        vec![
+            build::shape_rect(ids, [40.0, 40.0], [0.0, 0.0], 0.0),
+            build::shape_gradient_fill(ids, false, [-20.0, 0.0], [20.0, 0.0], g),
+            wiggle_transform(ids, &[("transform/position", Value::Vec2([60.0, 0.0]))]),
+        ]
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.37), 1.0);
+    let cols: Vec<i64> = (0..200).filter(|&x| alpha(&img, x, 50) > 0.99).collect();
+    let (l, r) = (cols[0], cols[cols.len() - 1]);
+    assert!((l - 80).abs() > 3, "the square moved: {l}");
+    let (cl, cr) = (img.get(l, 50), img.get(r, 50));
+    assert!(cl[0] < 0.1 && cr[0] > 0.9, "the ramp runs edge to edge: {cl:?} {cr:?}");
+}
+
+/// A gradient that paints every copy of a Repeater moves with the copies when they wiggle alike
+/// (Correlation 100).
+#[test]
+fn wiggle_transform_moves_a_gradient_shared_by_repeater_copies() {
+    let (p, cid) = shape_comp(|ids| {
+        let g = Gradient { colors: vec![(0.0, [0.0, 0.0, 0.0, 1.0]), (1.0, [1.0, 1.0, 1.0, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 1.0)] };
+        vec![
+            build::shape_rect(ids, [20.0, 20.0], [-60.0, 0.0], 0.0),
+            build::shape_repeater(ids, 3.0, [60.0, 0.0]),
+            build::shape_gradient_fill(ids, false, [0.0, -10.0], [0.0, 10.0], g),
+            wiggle_transform(ids, &[("correlation", Value::Scalar(100.0)), ("transform/position", Value::Vec2([0.0, 15.0]))]),
+        ]
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.9), 1.0);
+    for cx in [40, 100, 160] {
+        let rows: Vec<i64> = (0..100).filter(|&y| alpha(&img, cx, y) > 0.99).collect();
+        let (t, b) = (rows[0], rows[rows.len() - 1]);
+        assert!((t - 40).abs() > 3, "copy at {cx} moved: {t}");
+        let (ct, cb) = (img.get(cx, t), img.get(cx, b));
+        assert!(ct[0] < 0.1 && cb[0] > 0.9, "copy at {cx}: {ct:?} {cb:?}");
+    }
+}
+
+/// A gradient over copies that wiggle on their own keeps its place: every copy shows the ramp's
+/// middle at the group's origin row.
+#[test]
+fn wiggle_transform_keeps_a_gradient_over_copies_wiggling_apart() {
+    let (p, cid) = shape_comp(|ids| {
+        let g = Gradient { colors: vec![(0.0, [0.0, 0.0, 0.0, 1.0]), (1.0, [1.0, 1.0, 1.0, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 1.0)] };
+        vec![
+            build::shape_rect(ids, [20.0, 40.0], [-60.0, 0.0], 0.0),
+            build::shape_repeater(ids, 3.0, [60.0, 0.0]),
+            build::shape_gradient_fill(ids, false, [0.0, -20.0], [0.0, 20.0], g),
+            wiggle_transform(ids, &[("correlation", Value::Scalar(0.0)), ("transform/position", Value::Vec2([0.0, 15.0]))]),
+        ]
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.9), 1.0);
+    for cx in [40, 100, 160] {
+        let c = img.get(cx, 50);
+        assert!(c[3] > 0.99 && (c[0] - 0.5).abs() < 0.05, "copy at {cx}: {c:?}");
+    }
+}
+
+/// Copies wiggling on their own under one 50 % fill stay one paint: where they overlap, the fill
+/// covers them once.
+#[test]
+fn wiggle_transform_keeps_one_fill_over_overlapping_copies() {
+    let (p, cid) = shape_comp(|ids| {
+        let mut fill = build::shape_fill(ids, RED);
+        set(&mut fill, "opacity", Value::Scalar(50.0));
+        vec![
+            build::shape_rect(ids, [40.0, 40.0], [-20.0, 0.0], 0.0),
+            build::shape_repeater(ids, 3.0, [20.0, 0.0]),
+            fill,
+            wiggle_transform(ids, &[("correlation", Value::Scalar(0.0)), ("transform/position", Value::Vec2([0.0, 15.0]))]),
+        ]
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.9), 1.0);
+    let top = img.data.iter().map(|px| px[3]).fold(0.0f32, f32::max);
+    assert!((top - 0.5).abs() < 0.01, "{top}");
+}
+
+/// A long stack of Repeaters, each cleared by a zero-copy Repeater, still renders the last Repeater's copies.
+#[test]
+fn long_repeater_stack_with_cleared_copies_renders() {
+    let (p, cid) = shape_comp(|ids| {
+        let mut items = vec![];
+        for _ in 0..70 {
+            items.push(build::shape_rect(ids, [20.0, 20.0], [0.0, 0.0], 0.0));
+            items.push(build::shape_repeater(ids, 3.0, [10.0, 0.0]));
+            items.push(build::shape_repeater(ids, 0.0, [10.0, 0.0]));
+        }
+        items.push(build::shape_rect(ids, [20.0, 20.0], [0.0, 0.0], 0.0));
+        items.push(build::shape_repeater(ids, 3.0, [30.0, 0.0]));
+        items.push(wiggle_transform(ids, &[("correlation", Value::Scalar(0.0)), ("transform/position", Value::Vec2([0.0, 15.0]))]));
+        items.push(build::shape_fill(ids, RED));
+        items
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.37), 1.0);
+    assert!((coverage(&img) - 1200.0).abs() < 2.0, "{}", coverage(&img));
+}
+
+/// Copies a Repeater makes above a Wiggle Transform wiggle on their own (Correlation 0) or as one
+/// (Correlation 100); with the Wiggle Transform above the Repeater every copy wiggles the same.
+#[test]
+fn wiggle_transform_and_repeater_order() {
+    let offsets = |wiggle_first: bool, correlation: f64| {
+        let (p, cid) = shape_comp(|ids| {
+            let rect = build::shape_rect(ids, [20.0, 20.0], [-60.0, 0.0], 0.0);
+            let rep = build::shape_repeater(ids, 3.0, [60.0, 0.0]);
+            let w = wiggle_transform(ids, &[("correlation", Value::Scalar(correlation)), ("transform/position", Value::Vec2([0.0, 15.0]))]);
+            let fill = build::shape_fill(ids, RED);
+            if wiggle_first { vec![rect, w, rep, fill] } else { vec![rect, rep, w, fill] }
+        });
+        let img = render_frame(&p, cid, Tick::from_seconds_f64(0.37), 1.0);
+        [(0, 70), (70, 130), (130, 200)].map(|(x0, x1)| centroid(&img, x0, x1)[1] - 50.0)
+    };
+    let own = offsets(false, 0.0);
+    assert!((own[0] - own[1]).abs() > 0.5 || (own[1] - own[2]).abs() > 0.5, "copies wiggle on their own: {own:?}");
+    // A Repeater inside a group above the Wiggle Transform: its copies still wiggle on their own.
+    let (p, cid) = shape_comp(|ids| {
+        let inner = vec![build::shape_rect(ids, [20.0, 20.0], [-60.0, 0.0], 0.0), build::shape_repeater(ids, 3.0, [60.0, 0.0]), build::shape_fill(ids, RED)];
+        let group = build::shape_group(ids, "Repeated", inner);
+        vec![group, wiggle_transform(ids, &[("correlation", Value::Scalar(0.0)), ("transform/position", Value::Vec2([0.0, 15.0]))])]
+    });
+    let img = render_frame(&p, cid, Tick::from_seconds_f64(0.37), 1.0);
+    let nested = [(0, 70), (70, 130), (130, 200)].map(|(x0, x1)| centroid(&img, x0, x1)[1] - 50.0);
+    assert!((nested[0] - nested[1]).abs() > 0.5 || (nested[1] - nested[2]).abs() > 0.5, "nested copies: {nested:?}");
+    for same in [offsets(false, 100.0), offsets(true, 0.0)] {
+        assert!(same[0].abs() > 0.5, "{same:?}");
+        assert!((same[0] - same[1]).abs() < 0.05 && (same[1] - same[2]).abs() < 0.05, "copies wiggle as one: {same:?}");
+    }
+}
+
 #[test]
 fn zigzag_and_twist_render() {
     let (p, cid) = shape_comp(|ids| {
@@ -479,3 +715,33 @@ fn miter_corner_still_fits_its_buffer() {
     let b = shape_buf(&p, cid);
     assert!(b.img.height as f64 >= 50.0 + 20.0 * 4.0 * 0.5, "{}", b.img.height);
 }
+
+#[test]
+fn rect_per_corner_roundness_rounds_the_named_corners() {
+    let render = |per_corner: bool, radii: [f64; 4], roundness: f64| {
+        let (p, cid) = shape_comp_sized(200, 100, move |ids| {
+            let mut g = build::shape_rect(ids, [100.0, 100.0], [0.0, 0.0], roundness);
+            g.prop_mut("perCorner").unwrap().value = Value::Bool(per_corner);
+            for (m, v) in
+                [("topLeftRoundness", radii[0]), ("topRightRoundness", radii[1]), ("bottomRightRoundness", radii[2]), ("bottomLeftRoundness", radii[3])]
+            {
+                g.prop_mut(m).unwrap().value = Value::Scalar(v);
+            }
+            vec![g, build::shape_fill(ids, RED)]
+        });
+        frame(&p, cid)
+    };
+    // Only the top-left corner rounds: its corner pixels fade, the other three stay filled.
+    let img = render(true, [30.0, 0.0, 0.0, 0.0], 0.0);
+    assert!(alpha(&img, 52, 2) < 0.1, "top-left rounds: {}", alpha(&img, 52, 2));
+    for (x, y) in [(148, 2), (148, 98), (52, 98)] {
+        assert!(alpha(&img, x, y) > 0.9, "({x},{y}) stays square: {}", alpha(&img, x, y));
+    }
+    // The checkbox off ignores the four values (the single Roundness still rules).
+    let off = render(false, [30.0; 4], 0.0);
+    assert!((coverage(&off) - 100.0 * 100.0).abs() < 20.0, "{}", coverage(&off));
+    // Four equal per-corner radii render like the same Roundness.
+    let per = render(true, [25.0; 4], 0.0);
+    let uni = render(false, [0.0; 4], 25.0);
+    assert!((coverage(&per) - coverage(&uni)).abs() < 5.0, "{} vs {}", coverage(&per), coverage(&uni));
+}
diff --git a/crates/render/src/tests.rs b/crates/render/src/tests.rs
index 100ceda2f..865a4f59f 100644
--- a/crates/render/src/tests.rs
+++ b/crates/render/src/tests.rs
@@ -6,6 +6,25 @@ use effectcraft_time::{FrameRate, Tick};
 
 use crate::render_frame;
 
+mod audio_fx;
+mod auto;
+mod aux_channels;
+mod collapse;
+mod color;
+mod footage_size;
+mod frame_blend;
+mod guides;
+mod mask_blur;
+mod mask_expansion;
+mod mask_feather;
+mod motion_tile;
+mod nested;
+mod paint;
+mod remap;
+mod roi;
+mod styles;
+mod time;
+
 fn setup() -> (Project, ItemId, Comp) {
     let mut p = Project::default();
     // Exact float maths; 8/16 bpc quantisation has its own tests (tests_color).
@@ -187,6 +206,32 @@ fn track_matte_limits_an_adjustment_layer() {
     }
 }
 
+/// An adjustment layer's blend mode blends the adjusted comp onto the comp below, inside its
+/// footprint: with no effects, Screen screens a 0.25 grey with itself, Multiply darkens it,
+/// Normal leaves it, and Opacity mixes toward the result (#2618).
+#[test]
+fn adjustment_layer_blends_in_its_mode() {
+    for (mode, opacity, want) in
+        [(BlendMode::Normal, 100.0, 0.25), (BlendMode::Screen, 100.0, 0.4375), (BlendMode::Multiply, 100.0, 0.0625), (BlendMode::Screen, 50.0, 0.34375)]
+    {
+        let (mut p, cid, comp) = setup();
+        let mut adj = solid(&mut p, &comp, [1.0, 1.0, 1.0], 100, 100);
+        adj.props.prop_mut("transform/position").unwrap().value = Value::Vec3([50.0, 50.0, 0.0]);
+        adj.props.prop_mut("transform/opacity").unwrap().value = Value::Scalar(opacity);
+        adj.switches.adjustment = true;
+        adj.blend_mode = mode;
+        let bg = solid(&mut p, &comp, [0.25, 0.25, 0.25], 200, 100);
+        let c = p.comp_mut(cid).unwrap();
+        c.layers.push(adj);
+        c.layers.push(bg);
+        let img = render_frame(&p, cid, Tick::ZERO, 1.0);
+        let (inside, outside) = (img.get(50, 50), img.get(150, 50));
+        assert!((inside[0] - want).abs() < 1e-4, "{mode:?} {opacity}: {inside:?}");
+        assert!((outside[0] - 0.25).abs() < 1e-4, "{mode:?} {opacity}: outside the footprint {outside:?}");
+        assert_eq!(inside[3], 1.0, "{mode:?} keeps the comp opaque");
+    }
+}
+
 #[test]
 fn shape_layer_draws_fill_and_stroke() {
     let (mut p, cid, comp) = setup();
@@ -295,7 +340,7 @@ fn particle_world_scene(pan: f64) -> (Project, ItemId) {
         let Value::Vec3(v) = pr.value else { panic!("{path}: {:?}", pr.value) };
         pr.value = Value::Vec3([v[0] + pan, v[1], v[2]]);
     }
-    p.comp_mut(cid).unwrap().layers = vec![cam, l];
+    p.comp_mut(cid).unwrap().layers = vec![cam, l].into();
     (p, cid)
 }
 
@@ -328,6 +373,208 @@ fn particle_world_follows_the_comp_camera() {
     assert!(b < a - 20.0, "panning the camera right moves the particles left: {a} -> {b}");
 }
 
+/// A black solid with CC Particle World whose Birth Rate is 3 until layer time `cut`, then 0 a
+/// frame later (`None`: 3 throughout); the layer starts at comp time `start`, stretched `stretch` %.
+fn burst_scene(cut: Option<f64>, start: f64, stretch: f64) -> (Project, ItemId) {
+    burst_scene_keys(cut, start, stretch, false)
+}
+
+/// [`burst_scene`]; `hold`: Hold keys, 3 until `cut` and 0 from `cut` exactly.
+fn burst_scene_keys(cut: Option<f64>, start: f64, stretch: f64, hold: bool) -> (Project, ItemId) {
+    let (mut p, cid, comp) = setup();
+    let mut l = solid(&mut p, &comp, [0.0, 0.0, 0.0], 200, 100);
+    let vals = [("birthRate", Value::Scalar(3.0)), ("longevity", Value::Scalar(1.0)), ("particle/particleType", Value::Enum(2))];
+    add_effect(&mut p, &mut l, "ec.sim.ccparticleworld", [200.0, 100.0], &vals);
+    if let Some(cut) = cut {
+        let fx = l.props.sub_mut("effects").unwrap().children.iter_mut().find_map(|c| match c {
+            effectcraft_project::Node::Group(g) => Some(g),
+            _ => None,
+        });
+        let fx = fx.unwrap();
+        let rate = fx.prop_mut("birthRate").unwrap();
+        let key = |t: f64, v: f64| Keyframe::new(Tick::from_seconds_f64(t), Value::Scalar(v));
+        rate.keys = if hold { vec![key(0.0, 3.0).hold(), key(cut, 0.0).hold()] } else { vec![key(0.0, 3.0), key(cut, 3.0), key(cut + 1.0 / 30.0, 0.0)] };
+    }
+    l.start_time = Tick::from_seconds_f64(start);
+    l.in_point = l.start_time;
+    l.out_point = Tick::from_seconds_f64(4.0);
+    l.stretch = stretch;
+    p.comp_mut(cid).unwrap().layers = vec![l].into();
+    (p, cid)
+}
+
+/// Total light in a frame.
+fn light(img: &crate::Image) -> f32 {
+    img.data.iter().map(|p| p[0] + p[1] + p[2]).sum()
+}
+
+/// #1373: a Birth Rate keyed down to 0 stops new births; the particles already born live on
+/// until their Longevity runs out (they vanished the frame the rate reached 0).
+#[test]
+fn particle_world_keeps_a_burst_after_birth_rate_drops_to_zero() {
+    let (keyed, cid) = burst_scene(Some(0.5), 0.0, 100.0);
+    let (constant, _) = burst_scene(None, 0.0, 100.0);
+    let at = Tick::from_seconds_f64;
+    assert_same(&render_cached(&keyed, cid, at(0.4), None), &render_cached(&constant, cid, at(0.4), None), "during the burst");
+    let (k, c) = (light(&render_cached(&keyed, cid, at(0.9), None)), light(&render_cached(&constant, cid, at(0.9), None)));
+    assert!(k > 1.0 && k < c, "the burst is still drawn, with no new births: {k} vs {c}");
+    // Longevity 1 s (± 20 %): gone by 1.9 s.
+    assert_eq!(light(&render_cached(&keyed, cid, at(1.9), None)), 0.0);
+}
+
+/// The burst's history: moving an earlier key changes a later frame whose Birth Rate is the
+/// same (0), cached or not, and offset or stretched layers sample their own layer times.
+#[test]
+fn particle_world_birth_rate_history_with_the_layer_cache_and_time_mapping() {
+    let at = Tick::from_seconds_f64;
+    let (long, cid) = burst_scene(Some(0.5), 0.0, 100.0);
+    let (short, _) = burst_scene(Some(0.25), 0.0, 100.0);
+    let cache = crate::LayerCache::default();
+    let a = render_cached(&long, cid, at(0.9), Some(&cache));
+    let b = render_cached(&short, cid, at(0.9), Some(&cache));
+    assert_same(&b, &render_cached(&short, cid, at(0.9), None), "cached render after an earlier key moved");
+    assert!(light(&b) > 1.0 && light(&b) < light(&a), "a shorter burst: {} vs {}", light(&b), light(&a));
+    let plain = render_cached(&long, cid, at(0.9), None);
+    let (late, _) = burst_scene(Some(0.5), 0.5, 100.0);
+    assert_same(&render_cached(&late, cid, at(1.4), None), &plain, "a layer starting at 0.5 s");
+    let (slow, _) = burst_scene(Some(0.5), 0.0, 200.0);
+    assert_same(&render_cached(&slow, cid, at(1.8), None), &plain, "a layer stretched 200 %");
+}
+
+/// The Birth Rate history is read at exact layer times: under a fractional stretch, mapping a
+/// layer time to comp time and back rounds down a tick, so a Hold cut at 0.5 s read its
+/// previous value at the step starting there (six extra births).
+#[test]
+fn particle_world_reads_a_hold_cut_at_its_exact_layer_time_under_any_stretch() {
+    use crate::{EffectHost, FxHost, NoFootage, RenderOpts, Renderer};
+    let plain = {
+        let (p, cid) = burst_scene_keys(Some(0.5), 0.0, 100.0, true);
+        render_cached(&p, cid, Tick::from_seconds_f64(0.9), None)
+    };
+    assert!(light(&plain) > 1.0, "the burst is drawn");
+    for stretch in [33.3, 133.33, 200.0] {
+        let (p, cid) = burst_scene_keys(Some(0.5), 0.0, stretch, true);
+        let c = p.comp(cid).unwrap();
+        let l = &c.layers[0];
+        let ctx = crate::eval::EvalCtx::new(&p, cid, c, Tick::ZERO);
+        let renderer = Renderer::new(&p, &NoFootage, RenderOpts::default());
+        let host = FxHost { r: &renderer, ctx: &ctx, layer: l, origin: [0.0; 2], index: Default::default(), original: None };
+        let rate = |t: f64| host.param_at(0, "birthRate", t).unwrap().as_f64();
+        assert_eq!((rate(0.5 - 1.0 / 60.0), rate(0.5)), (3.0, 0.0), "stretch {stretch} %");
+        assert!(!host.param_is_static(0, "birthRate"));
+        let t = l.comp_time(Tick::from_seconds_f64(0.9));
+        assert_same(&render_cached(&p, cid, t, None), &plain, &format!("stretch {stretch} %"));
+    }
+}
+
+/// An expression that reads a Controller layer's Opacity (÷ 25) before layer time 0.5 s and is
+/// 0 after (a stand-in for the expression engine).
+struct ControllerRate;
+
+impl crate::eval::ExprHost for ControllerRate {
+    fn eval(&self, ctx: &crate::eval::EvalCtx, layer: &effectcraft_project::Layer, _: &effectcraft_project::Property, _: &Value) -> Result<Value, String> {
+        if layer.layer_time(ctx.time).seconds() >= 0.5 {
+            return Ok(Value::Scalar(0.0));
+        }
+        let c = ctx.comp.layers.iter().find(|l| l.name == "Controller").ok_or("no controller")?;
+        let opacity = c.props.prop("transform/opacity").ok_or("no opacity")?;
+        Ok(Value::Scalar(ctx.value(c, opacity).as_f64() / 25.0))
+    }
+}
+
+/// A Birth Rate expression reading another layer: changing that layer changes the history but
+/// not the current rate (0) nor this layer's properties, which is all the layer cache key sees.
+/// CC Particle World layers with expressions therefore aren't layer cached.
+#[test]
+fn particle_world_with_a_birth_rate_expression_is_not_served_from_the_layer_cache() {
+    let scene = |opacity: f64| {
+        let (mut p, cid) = burst_scene(None, 0.0, 100.0);
+        let comp = p.comp(cid).unwrap().clone();
+        let mut ctl = solid(&mut p, &comp, [0.0, 0.0, 0.0], 10, 10);
+        ctl.name = "Controller".into();
+        ctl.switches.video = false;
+        ctl.props.prop_mut("transform/opacity").unwrap().value = Value::Scalar(opacity);
+        let c = p.comp_mut(cid).unwrap();
+        let fx = c.layers[0].props.sub_mut("effects").unwrap().children.iter_mut().find_map(|n| match n {
+            effectcraft_project::Node::Group(g) => Some(g),
+            _ => None,
+        });
+        fx.unwrap().prop_mut("birthRate").unwrap().expr = Some(effectcraft_project::Expression { text: "controller".into(), enabled: true });
+        c.layers.push(ctl);
+        (p, cid)
+    };
+    let render = |p: &Project, cid: ItemId, cache: Option<&crate::LayerCache>| {
+        let mut r = crate::Renderer::new(p, &crate::NoFootage, crate::RenderOpts::default());
+        r.expr = Some(&ControllerRate);
+        r.cache = cache;
+        r.comp_frame(cid, Tick::from_seconds_f64(0.9))
+    };
+    let ((many, cid), (few, _)) = (scene(75.0), scene(25.0));
+    let cache = crate::LayerCache::default();
+    let a = render(&many, cid, Some(&cache));
+    let b = render(&few, cid, Some(&cache));
+    assert_same(&b, &render(&few, cid, None), "cached render after the controller changed");
+    assert!(light(&b) > 1.0 && light(&b) < light(&a), "fewer births: {} vs {}", light(&b), light(&a));
+}
+
+/// A grey solid (CC Mr. Mercury shades its blobs from it) with effect `id` (CC Particle Systems
+/// II, CC Mr. Mercury): Birth Rate `rate`,
+/// or keyed 3 until 0.5 s and 0 a frame later (`None`); Longevity 1 s.
+fn system_scene(id: &str, rate: Option<f64>) -> (Project, ItemId) {
+    let (mut p, cid, comp) = setup();
+    let mut l = solid(&mut p, &comp, [0.5, 0.5, 0.5], 200, 100);
+    let vals = [("birthRate", Value::Scalar(rate.unwrap_or(3.0))), ("longevity", Value::Scalar(1.0))];
+    add_effect(&mut p, &mut l, id, [200.0, 100.0], &vals);
+    if rate.is_none() {
+        let fx = l.props.sub_mut("effects").unwrap().children.iter_mut().find_map(|c| match c {
+            effectcraft_project::Node::Group(g) => Some(g),
+            _ => None,
+        });
+        let key = |t: f64, v: f64| Keyframe::new(Tick::from_seconds_f64(t), Value::Scalar(v));
+        fx.unwrap().prop_mut("birthRate").unwrap().keys = vec![key(0.0, 3.0), key(0.5, 3.0), key(0.5 + 1.0 / 30.0, 0.0)];
+    }
+    p.comp_mut(cid).unwrap().layers = vec![l].into();
+    (p, cid)
+}
+
+/// #1373 for CC Particle Systems II and CC Mr. Mercury through the renderer: a keyed burst
+/// draws as the constant rate during it, still draws after the rate drops to 0 (unlike a rate
+/// of 0 throughout), and draws as nothing born once Longevity has run out.
+#[test]
+fn particle_systems_ii_and_mr_mercury_keep_a_burst_after_birth_rate_drops_to_zero() {
+    let at = Tick::from_seconds_f64;
+    for id in ["ec.sim.ccparticlesystems2", "ec.sim.ccmrmercury"] {
+        let (keyed, cid) = system_scene(id, None);
+        let (constant, _) = system_scene(id, Some(3.0));
+        let (none, _) = system_scene(id, Some(0.0));
+        assert_same(&render_cached(&keyed, cid, at(0.4), None), &render_cached(&constant, cid, at(0.4), None), &format!("{id}: during the burst"));
+        let (k, z) = (render_cached(&keyed, cid, at(0.9), None), render_cached(&none, cid, at(0.9), None));
+        assert!((light(&k) - light(&z)).abs() > 1.0, "{id}: the burst is still drawn: {} vs {}", light(&k), light(&z));
+        assert_same(&render_cached(&keyed, cid, at(1.9), None), &render_cached(&none, cid, at(1.9), None), &format!("{id}: gone after Longevity"));
+    }
+}
+
+/// A Birth Rate expression on any of the stepped particle systems keeps the layer out of the
+/// layer cache (its key can't see what the expression returned at earlier times); without one
+/// the layer is cached.
+#[test]
+fn stepped_particle_layers_with_a_birth_rate_expression_are_not_layer_cached() {
+    for id in ["ec.sim.ccparticleworld", "ec.sim.ccparticlesystems2", "ec.sim.ccmrmercury"] {
+        let (mut p, cid) = system_scene(id, Some(2.0));
+        let key = |p: &Project| {
+            let c = p.comp(cid).unwrap();
+            crate::cache::layer_key(&crate::eval::EvalCtx::new(p, cid, c, Tick::from_seconds_f64(0.9)), &c.layers[0], 1.0, false, false)
+        };
+        assert!(key(&p).is_some(), "{id}: cached without an expression");
+        let fx = p.comp_mut(cid).unwrap().layers[0].props.sub_mut("effects").unwrap().children.iter_mut().find_map(|c| match c {
+            effectcraft_project::Node::Group(g) => Some(g),
+            _ => None,
+        });
+        fx.unwrap().prop_mut("birthRate").unwrap().expr = Some(effectcraft_project::Expression { text: "time < 0.5 ? 3 : 0".into(), enabled: true });
+        assert!(key(&p).is_none(), "{id}: not cached with a Birth Rate expression");
+    }
+}
+
 // ------------------------------------------------------------------------------ layer cache
 
 fn render_cached(p: &Project, cid: ItemId, t: Tick, cache: Option<&crate::LayerCache>) -> crate::Image {
@@ -393,7 +640,7 @@ fn cache_scene() -> (Project, ItemId) {
         vec![Keyframe::new(Tick::ZERO, Value::Vec3([20.0, 70.0, 0.0])), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Vec3([120.0, 70.0, 0.0]))];
     add_effect_200(&mut p, &mut text, "ec.blur.gaussian", &[("blurriness", Value::Scalar(6.0))]);
     let c = p.comp_mut(cid).unwrap();
-    c.layers = vec![text, shape, bg];
+    c.layers = vec![text, shape, bg].into();
     (p, cid)
 }
 
@@ -633,7 +880,7 @@ fn edge_pinning_displaces_all_of_a_centred_shape_layer() {
         p.comp_mut(cid).unwrap().layers.push(l.clone());
         let plain = render_frame(&p, cid, Tick::ZERO, 1.0);
         add_effect_200(&mut p, &mut l, id, &vals);
-        p.comp_mut(cid).unwrap().layers = vec![l];
+        p.comp_mut(cid).unwrap().layers = vec![l].into();
         let warped = render_frame(&p, cid, Tick::ZERO, 1.0);
         // Alpha change per comp quadrant (TL, TR, BL, BR): the rectangle's edges move in each.
         let mut q = [0.0f32; 4];
@@ -667,7 +914,7 @@ fn default_effect_points_sit_at_the_centre_of_a_shape_layer() {
         p.comp_mut(cid).unwrap().layers.push(l.clone());
         let plain = render_frame(&p, cid, Tick::ZERO, 1.0);
         add_effect_200(&mut p, &mut l, id, &vals);
-        p.comp_mut(cid).unwrap().layers = vec![l];
+        p.comp_mut(cid).unwrap().layers = vec![l].into();
         let warped = render_frame(&p, cid, Tick::ZERO, 1.0);
         // Alpha change per comp quadrant (TL, TR, BL, BR): the top and bottom edges move in each.
         let mut q = [0.0f32; 4];
@@ -682,6 +929,54 @@ fn default_effect_points_sit_at_the_centre_of_a_shape_layer() {
     }
 }
 
+/// #687: an adjustment layer's footprint (its source through its masks) must not be keyed by
+/// its effect stack. Noise on a finishing adjustment changes every frame, and letting that
+/// reach the key re-rendered and re-uploaded a full-frame buffer every frame. A moving mask
+/// must still re-key it, and the cached buffer must follow the mask.
+#[test]
+fn adjustment_footprint_key_ignores_the_effect_stack() {
+    let (mut p, cid, comp) = setup();
+    let mut adj = solid(&mut p, &comp, [1.0, 1.0, 1.0], 200, 100);
+    adj.switches.adjustment = true;
+    add_effect_200(&mut p, &mut adj, "ec.noise.noise", &[("amount", Value::Scalar(50.0))]);
+    let key = |p: &Project, t: f64| {
+        let c = p.comp(cid).unwrap();
+        crate::cache::footprint_key(&crate::EvalCtx::new(p, cid, c, Tick::from_seconds_f64(t)), &c.layers[0], 1.0, false, false).unwrap()
+    };
+    let mut next = p.next_id;
+    let mut m = build::mask(&mut Ids(&mut next), "Mask 1", ShapePath::rect([50.0, 50.0], 40.0, 40.0), MaskMode::Add, [255, 255, 0]);
+    p.next_id = next;
+    m.prop_mut("path").unwrap().keys = vec![
+        Keyframe::new(Tick::ZERO, Value::Path(ShapePath::rect([50.0, 50.0], 40.0, 40.0))),
+        Keyframe::new(Tick::from_seconds_f64(1.0), Value::Path(ShapePath::rect([150.0, 50.0], 40.0, 40.0))),
+    ];
+    // Effects alone must not put the shutter in the footprint key. Masks, added below, may.
+    p.comp_mut(cid).unwrap().layers.push(adj.clone());
+    let bare = key(&p, 0.0);
+    p.comp_mut(cid).unwrap().shutter_angle = 90.0;
+    assert_eq!(bare, key(&p, 0.0), "the comp shutter must not re-key a footprint");
+    p.comp_mut(cid).unwrap().shutter_angle = 180.0;
+    p.comp_mut(cid).unwrap().layers[0].props.sub_mut("masks").unwrap().children.push(m.into());
+    let foot = |p: &Project, t: f64| {
+        let c = p.comp(cid).unwrap();
+        let mut r = crate::Renderer::new(p, &crate::NoFootage, crate::RenderOpts::default());
+        let cache = crate::LayerCache::default();
+        r.cache = Some(&cache);
+        let layer = c.layers[0].clone();
+        let b = r.adjustment_footprint(&crate::EvalCtx::new(p, cid, c, Tick::from_seconds_f64(t)), &layer).unwrap();
+        b.img.get(50, 50)
+    };
+    assert_ne!(key(&p, 0.0), key(&p, 0.5), "an animated mask path must re-key the footprint");
+    assert_ne!(key(&p, 0.0), key(&p, 1.0));
+    assert_ne!(foot(&p, 0.0), foot(&p, 1.0), "the moved mask must reach the cached footprint");
+    assert_eq!(key(&p, 1.0), key(&p, 1.5), "a per-frame effect on the adjustment re-keyed its footprint");
+    assert_eq!(key(&p, 1.0), key(&p, 3.5), "the footprint key followed the clock past the mask");
+    assert_eq!(foot(&p, 1.0), foot(&p, 3.5));
+    let before = key(&p, 0.0);
+    p.comp_mut(cid).unwrap().layers[0].props.prop_mut("effects/#1/amount").unwrap().value = Value::Scalar(90.0);
+    assert_eq!(before, key(&p, 0.0), "editing an effect parameter must not re-key the footprint");
+}
+
 /// #659: a tiling effect on a text layer tiles across the layer's whole region. The glyphs
 /// were cut off at their own bounding box: the effect computed over the comp-sized layer rect
 /// but wrote into the painted (glyph-bounds) buffer alone. Tiling shrinks each copy, so the
@@ -696,7 +991,7 @@ fn effects_on_text_reach_past_the_text_bounds() {
     let plain = render_frame(&p, cid, Tick::ZERO, 1.0);
     let painted = plain.data.iter().filter(|px| px[3] > 0.5).count();
     add_effect_200(&mut p, &mut l, "ec.distort.cctiler", &[("scale", Value::Scalar(25.0))]);
-    p.comp_mut(cid).unwrap().layers = vec![l];
+    p.comp_mut(cid).unwrap().layers = vec![l].into();
     let tiled = render_frame(&p, cid, Tick::ZERO, 1.0);
     let (mut lo, mut hi) = (u32::MAX, 0u32);
     for y in 0..100 {
@@ -730,7 +1025,7 @@ fn cc_smear_trails_text_past_its_bounds() {
         "ec.distort.ccsmear",
         &[("from", Value::Vec2([110.0, 45.0])), ("to", Value::Vec2([185.0, 45.0])), ("reach", Value::Scalar(100.0)), ("radius", Value::Scalar(40.0))],
     );
-    p.comp_mut(cid).unwrap().layers = vec![l];
+    p.comp_mut(cid).unwrap().layers = vec![l].into();
     let smeared = right(&render_frame(&p, cid, Tick::ZERO, 1.0));
     assert!(plain > 40 && smeared > plain + 25, "CC Smear trails the glyphs past the text bounds: right edge {plain} → {smeared}");
 }
@@ -753,7 +1048,7 @@ fn layer_parameters_see_a_whole_shape_layer() {
     let matte_id = shape.id;
     let mut s = solid(&mut p, &comp, [0.0, 0.0, 1.0], 200, 100);
     add_effect_200(&mut p, &mut s, "ec.channel.setmatte", &[("takeMatteFromLayer", Value::Layer(Some(matte_id.0)))]);
-    p.comp_mut(cid).unwrap().layers = vec![s, shape];
+    p.comp_mut(cid).unwrap().layers = vec![s, shape].into();
     let f = render_frame(&p, cid, Tick::ZERO, 1.0);
     // The matte covers x 50..150, y 25..75: kept inside (all four quadrants), gone outside.
     for (x, y) in [(60, 30), (140, 30), (60, 70), (140, 70)] {
@@ -843,7 +1138,7 @@ fn self_inputs_share_source_semantics_across_effects_and_times() {
         "ec.channel.blend",
         &[("blendWithLayer", Value::Layer(Some(id))), ("blendWithLayerSource", Value::Enum(0)), ("blendWithOriginal", Value::Scalar(0.0))],
     );
-    p.comp_mut(cid).unwrap().layers = vec![l];
+    p.comp_mut(cid).unwrap().layers = vec![l].into();
     let c = p.comp(cid).unwrap();
     let ctx = crate::eval::EvalCtx::new(&p, cid, c, Tick::ZERO);
     assert!(crate::cache::input_key(&ctx, &c.layers[0], 1.0, false, false, 1).is_some());
@@ -861,7 +1156,7 @@ fn timed_source_reads_preserve_other_layer_masks() {
     let mask = build::mask(&mut Ids(&mut next), "Left", ShapePath::rect([50.0, 50.0], 80.0, 80.0), MaskMode::Add, [255, 255, 0]);
     p.next_id = next;
     other.props.sub_mut("masks").unwrap().children.push(mask.into());
-    p.comp_mut(cid).unwrap().layers = vec![owner.clone(), other.clone()];
+    p.comp_mut(cid).unwrap().layers = vec![owner.clone(), other.clone()].into();
     let ctx = crate::EvalCtx::new(&p, cid, p.comp(cid).unwrap(), Tick::ZERO);
     let renderer = crate::Renderer::new(&p, &crate::NoFootage, crate::RenderOpts::default());
     let host = crate::FxHost { r: &renderer, ctx: &ctx, layer: &owner, origin: [0.0; 2], index: Default::default(), original: None };
@@ -882,7 +1177,7 @@ fn layer_dependencies_remain_cacheable_and_invalidate_only_related_edits() {
     let unrelated = solid(&mut p, &comp, [0.2, 0.3, 0.4], 200, 100);
     add_effect_200(&mut p, &mut source, "ec.channel.blend", &[("blendWithLayer", Value::Layer(Some(third.id.0))), ("blendWithOriginal", Value::Scalar(0.0))]);
     add_effect_200(&mut p, &mut owner, "ec.channel.blend", &[("blendWithLayer", Value::Layer(Some(source.id.0))), ("blendWithOriginal", Value::Scalar(0.0))]);
-    p.comp_mut(cid).unwrap().layers = vec![owner, source, third, unrelated];
+    p.comp_mut(cid).unwrap().layers = vec![owner, source, third, unrelated].into();
     let key = |p: &Project, time: f64, limit| {
         let comp = p.comp(cid).unwrap();
         let ctx = crate::EvalCtx::new(p, cid, comp, Tick::from_seconds_f64(time));
@@ -923,12 +1218,12 @@ fn precomp_dependencies_hash_nested_sources_and_evaluated_animation() {
     child.props.prop_mut("transform/opacity").unwrap().keys =
         vec![Keyframe::new(Tick::ZERO, Value::Scalar(100.0)), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Scalar(50.0))];
     let mut nested = comp.clone();
-    nested.layers = vec![child];
+    nested.layers = vec![child].into();
     let nested_id = p.add_item("Nested", Label::Sandstone, None, ItemKind::Comp(nested.into()));
     let pre = build::layer(&mut p, &comp, "Precomp", LayerSource::Comp { item: nested_id }, (200, 100), None);
     let mut owner = solid(&mut p, &comp, [1.0, 0.0, 0.0], 200, 100);
     add_effect_200(&mut p, &mut owner, "ec.channel.blend", &[("blendWithLayer", Value::Layer(Some(pre.id.0))), ("blendWithOriginal", Value::Scalar(0.0))]);
-    p.comp_mut(cid).unwrap().layers = vec![owner, pre];
+    p.comp_mut(cid).unwrap().layers = vec![owner, pre].into();
     let key = |p: &Project, time| {
         let c = p.comp(cid).unwrap();
         crate::cache::layer_key(&crate::EvalCtx::new(p, cid, c, time), &c.layers[0], 1.0, false, false).unwrap()
@@ -1003,7 +1298,7 @@ fn scene_reader_dependency(pan: f64) -> (Project, ItemId) {
         let Value::Vec3(v) = pr.value else { panic!("{path}: {:?}", pr.value) };
         pr.value = Value::Vec3([v[0] + pan, v[1], v[2]]);
     }
-    p.comp_mut(cid).unwrap().layers = vec![cam, owner, source];
+    p.comp_mut(cid).unwrap().layers = vec![cam, owner, source].into();
     (p, cid)
 }
 
@@ -1055,3 +1350,412 @@ fn workers_rendering_a_layer_at_once_share_one_buffer() {
     assert!(bufs.iter().all(|b| std::sync::Arc::ptr_eq(b, &bufs[0])), "one shared buffer");
     assert_eq!(cache.stats().entries, 1);
 }
+
+// ------------------------------------------------------------------------------ 3D layer instances
+
+/// A red triangle in the Z = 0 plane (the engine instance3d tests' glTF, buffer embedded as a
+/// data URI), parsed in memory: a FootageSource that knows one model item.
+const TRIANGLE: &str = r#"{
+  "asset": {"version": "2.0"},
+  "scenes": [{"nodes": [0]}],
+  "nodes": [{"mesh": 0}],
+  "meshes": [{"primitives": [{"attributes": {"POSITION": 0, "NORMAL": 1}, "material": 0}]}],
+  "materials": [{"pbrMetallicRoughness": {"baseColorFactor": [1.0, 0.0, 0.0, 1.0]}}],
+  "buffers": [{"byteLength": 72, "uri": "data:application/octet-stream;base64,AACAvwAAgL8AAAAAAACAPwAAgL8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/"}],
+  "bufferViews": [
+    {"buffer": 0, "byteOffset": 0, "byteLength": 36},
+    {"buffer": 0, "byteOffset": 36, "byteLength": 36}
+  ],
+  "accessors": [
+    {"bufferView": 0, "componentType": 5126, "type": "VEC3", "count": 3, "min": [-1.0, -1.0, 0.0], "max": [1.0, 1.0, 0.0]},
+    {"bufferView": 1, "componentType": 5126, "type": "VEC3", "count": 3}
+  ]
+}"#;
+
+struct SoloModels;
+
+impl crate::FootageSource for SoloModels {
+    fn frame(&self, _: ItemId, _: &effectcraft_project::Footage, _: Tick) -> Option<std::sync::Arc<crate::Image>> {
+        None
+    }
+    fn model(&self, _: ItemId, f: &effectcraft_project::Footage) -> Option<std::sync::Arc<effectcraft_model::Model>> {
+        effectcraft_model::load(&f.path, TRIANGLE.as_bytes(), &|_| None).ok().map(std::sync::Arc::new)
+    }
+}
+
+/// A red triangle 3D model, a camera panned right by `pan` px and, on top of the stack, the
+/// copy: a solid with a 3D Layer Instance effect referencing the model.
+fn instance_scene(pan: f64) -> (Project, ItemId) {
+    let (mut p, cid, comp) = setup();
+    // Models are Advanced 3D (layer.newModel switches a Classic comp over).
+    p.comp_mut(cid).unwrap().renderer = effectcraft_project::Renderer::Advanced3D;
+    let mid = p.add_item(
+        "Triangle",
+        Label::Red,
+        None,
+        ItemKind::Footage(effectcraft_project::Footage {
+            path: "Triangle.gltf".into(),
+            kind: effectcraft_project::FootageKind::Model,
+            frame_rate: FrameRate::FPS_30,
+            codec: "glTF".into(),
+            ..Default::default()
+        }),
+    );
+    let model = build::layer(&mut p, &comp, "Triangle", LayerSource::Model { item: mid }, (200, 100), None);
+    let mut cam = build::layer(&mut p, &comp, "Camera", LayerSource::Camera, (200, 100), None);
+    for path in ["transform/position", "transform/poi"] {
+        let pr = cam.props.prop_mut(path).unwrap();
+        let Value::Vec3(v) = pr.value else { panic!("{path}: {:?}", pr.value) };
+        pr.value = Value::Vec3([v[0] + pan, v[1], v[2]]);
+    }
+    let mut owner = solid(&mut p, &comp, [1.0, 1.0, 1.0], 200, 100);
+    add_effect_200(&mut p, &mut owner, "ec.3d.instance3d", &[("layer", Value::Layer(Some(model.id.0)))]);
+    p.comp_mut(cid).unwrap().layers = vec![cam, owner, model].into();
+    (p, cid)
+}
+
+fn render_models(p: &Project, cid: ItemId, t: Tick, cache: Option<&crate::LayerCache>) -> crate::Image {
+    let mut r = crate::Renderer::new(p, &SoloModels, crate::RenderOpts::default());
+    r.cache = cache;
+    r.comp_frame(cid, t)
+}
+
+/// The coverage-weighted centre of the triangle (x): where its drawn pixels are, lit or not.
+fn cover_x(img: &crate::Image) -> f32 {
+    let (mut m, mut sx) = (0.0, 0.0);
+    for y in 0..img.height {
+        for x in 0..img.width {
+            let a = img.get(x as i64, y as i64)[3];
+            m += a;
+            sx += a * x as f32;
+        }
+    }
+    assert!(m > 1.0, "the triangle is drawn");
+    sx / m
+}
+
+/// Create 3D Layer Instance: the copy (the owner) is cached, and its key covers what the
+/// referenced model's solo render depends on — the camera, and the model's in/out gate.
+#[test]
+fn an_instance_of_a_model_is_cached_and_follows_the_camera() {
+    let t = Tick::from_seconds_f64(1.0);
+    let (p, cid) = instance_scene(0.0);
+    let (q, _) = instance_scene(40.0);
+    let key_at = |p: &Project, t: Tick| {
+        let c = p.comp(cid).unwrap();
+        crate::cache::layer_key(&crate::EvalCtx::new(p, cid, c, t), &c.layers[1], 1.0, false, false).unwrap()
+    };
+    assert_ne!(key_at(&p, t), key_at(&q, t), "moving the camera changes the copy's key");
+    // The same layer at a later time, outside its in/out range: the read turns transparent.
+    let mut out = p.clone();
+    out.comp_mut(cid).unwrap().layers[2].out_point = Tick::from_seconds_f64(0.5);
+    assert_ne!(key_at(&out, Tick::from_seconds_f64(0.25)), key_at(&out, t), "leaving the model's in/out range changes the copy's key");
+    // Two renders of one time: the second is served from the cache.
+    let cache = crate::LayerCache::default();
+    let here = render_models(&p, cid, t, Some(&cache));
+    let again = render_models(&p, cid, t, Some(&cache));
+    assert_same(&again, &render_models(&p, cid, t, None), "the second render is the cached one");
+    assert!(cache.stats().hits > 0, "the copy was served from the cache");
+    // Panning the camera: the copy (and the model) move with it.
+    let panned = render_models(&q, cid, t, Some(&cache));
+    assert_same(&panned, &render_models(&q, cid, t, None), "cached render after the camera moved");
+    let (a, b) = (cover_x(&here), cover_x(&panned));
+    assert!(b < a - 20.0, "panning the camera right moves the copy left: {a} -> {b}");
+}
+
+/// The camera's depth of field blurs the solo render (focus, aperture, iris, highlights) —
+/// none of it is in the projection matrix: changing any of it must change the copy's key, or
+/// it would serve the un-blurred pixels.
+#[test]
+fn the_copy_key_covers_the_cameras_depth_of_field() {
+    let t = Tick::from_seconds_f64(1.0);
+    let (p, cid) = instance_scene(0.0);
+    let set_dof = |p: &Project, on: bool, focus: f64, aperture: f64| {
+        let mut q = p.clone();
+        let cam = &mut q.comp_mut(cid).unwrap().layers[0];
+        for (path, v) in
+            [("cameraOptions/dof", Value::Bool(on)), ("cameraOptions/focusDistance", Value::Scalar(focus)), ("cameraOptions/aperture", Value::Scalar(aperture))]
+        {
+            cam.props.prop_mut(path).unwrap().value = v;
+        }
+        q
+    };
+    let key_at = |p: &Project| {
+        let c = p.comp(cid).unwrap();
+        crate::cache::layer_key(&crate::EvalCtx::new(p, cid, c, t), &c.layers[1], 1.0, false, false).unwrap()
+    };
+    let ka = key_at(&set_dof(&p, true, 500.0, 20.0));
+    let kb = key_at(&set_dof(&p, true, 500.0, 40.0)); // aperture
+    let kc = key_at(&set_dof(&p, true, 700.0, 20.0)); // focus
+    let kd = key_at(&set_dof(&p, false, 500.0, 20.0)); // the switch off
+    assert!(ka != kb && ka != kc && ka != kd && kb != kc, "aperture, focus and the switch each change the key");
+}
+
+/// A model with an animation clip selected is posed at its layer time: every time is its own
+/// entry. Without one (the default) the pose is the same at every time: one key inside the
+/// in/out range, as before.
+#[test]
+fn the_copy_key_covers_an_animated_models_layer_time() {
+    let (p, cid) = instance_scene(0.0);
+    let (t0, t1) = (Tick::from_seconds_f64(0.5), Tick::from_seconds_f64(1.0));
+    let key_at = |p: &Project, t: Tick| {
+        let c = p.comp(cid).unwrap();
+        crate::cache::layer_key(&crate::EvalCtx::new(p, cid, c, t), &c.layers[1], 1.0, false, false).unwrap()
+    };
+    assert_eq!(key_at(&p, t0), key_at(&p, t1), "a model without a clip keeps one key across times");
+    let mut q = p.clone();
+    q.comp_mut(cid).unwrap().layers[2].props.prop_mut("geometryOptions/animation").unwrap().value = Value::Enum(1);
+    assert_ne!(key_at(&q, t0), key_at(&q, t1), "an animated model's key follows its layer time");
+    // Two times and back: each is rendered fresh, none served another time's pixels.
+    let cache = crate::LayerCache::default();
+    let first = render_models(&q, cid, t0, Some(&cache));
+    let second = render_models(&q, cid, t1, Some(&cache));
+    assert_eq!(cache.stats().hits, 0, "the second time is not served the first time's pixels");
+    assert_same(&second, &render_models(&q, cid, t1, None), "the second time is a fresh render");
+    let again = render_models(&q, cid, t0, Some(&cache));
+    assert_eq!(cache.stats().hits, 1, "the first time is served on the way back");
+    assert_same(&again, &first, "the way back is the first time's pixels");
+}
+
+/// An Environment light's image lights Advanced 3D models — its source can be any layer's
+/// render: with one on, the read is not cached, so changes to it cannot reuse stale pixels.
+#[test]
+fn an_environment_light_makes_the_copy_uncached() {
+    let (p, cid) = instance_scene(0.0);
+    let mut q = p.clone();
+    let comp = q.comp(cid).unwrap().clone();
+    let env = build::layer(&mut q, &comp, "Env", LayerSource::Light { kind: effectcraft_project::LightKind::Environment }, (200, 100), None);
+    q.comp_mut(cid).unwrap().layers.insert(0, env);
+    let t = Tick::from_seconds_f64(1.0);
+    let key_at = |p: &Project| {
+        let c = p.comp(cid).unwrap();
+        crate::cache::layer_key(&crate::EvalCtx::new(p, cid, c, t), &c.layers[2], 1.0, false, false)
+    };
+    assert!(key_at(&q).is_none(), "with an Environment light the read is not cached");
+    let cache = crate::LayerCache::default();
+    let a = render_models(&q, cid, t, Some(&cache));
+    let b = render_models(&q, cid, t, Some(&cache));
+    assert_same(&a, &b, "two fresh renders agree");
+    assert_eq!(cache.stats().hits, 0, "nothing is served from the cache");
+    // The light off (not lighting): the cache comes back.
+    q.comp_mut(cid).unwrap().layers[0].switches.video = false;
+    assert!(key_at(&q).is_some(), "the light off, the read is cached again");
+}
+
+// ------------------------------------------------------------------- keyed model animation clips
+
+/// [`TRIANGLE`] with one 1 s clip: its node slides from x = -1 to x = +1 (linear).
+const SLIDING_TRIANGLE: &str = r#"{
+  "asset": {"version": "2.0"},
+  "scenes": [{"nodes": [0]}],
+  "nodes": [{"mesh": 0}],
+  "meshes": [{"primitives": [{"attributes": {"POSITION": 0, "NORMAL": 1}, "material": 0}]}],
+  "materials": [{"pbrMetallicRoughness": {"baseColorFactor": [1.0, 0.0, 0.0, 1.0]}}],
+  "animations": [{"samplers": [{"input": 2, "output": 3, "interpolation": "LINEAR"}], "channels": [{"sampler": 0, "target": {"node": 0, "path": "translation"}}]}],
+  "buffers": [{"byteLength": 104, "uri": "data:application/octet-stream;base64,AACAvwAAgL8AAAAAAACAPwAAgL8AAAAAAAAAAAAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAAAAAAIA/AAAAAAAAgD8AAIC/AAAAAAAAAAAAAIA/AAAAAAAAAAA="}],
+  "bufferViews": [
+    {"buffer": 0, "byteOffset": 0, "byteLength": 36},
+    {"buffer": 0, "byteOffset": 36, "byteLength": 36},
+    {"buffer": 0, "byteOffset": 72, "byteLength": 8},
+    {"buffer": 0, "byteOffset": 80, "byteLength": 24}
+  ],
+  "accessors": [
+    {"bufferView": 0, "componentType": 5126, "type": "VEC3", "count": 3, "min": [-1.0, -1.0, 0.0], "max": [1.0, 1.0, 0.0]},
+    {"bufferView": 1, "componentType": 5126, "type": "VEC3", "count": 3},
+    {"bufferView": 2, "componentType": 5126, "type": "SCALAR", "count": 2, "min": [0.0], "max": [1.0]},
+    {"bufferView": 3, "componentType": 5126, "type": "VEC3", "count": 2}
+  ]
+}"#;
+
+struct SlidingModels;
+
+impl crate::FootageSource for SlidingModels {
+    fn frame(&self, _: ItemId, _: &effectcraft_project::Footage, _: Tick) -> Option<std::sync::Arc<crate::Image>> {
+        None
+    }
+    fn model(&self, _: ItemId, f: &effectcraft_project::Footage) -> Option<std::sync::Arc<effectcraft_model::Model>> {
+        effectcraft_model::load(&f.path, SLIDING_TRIANGLE.as_bytes(), &|_| None).ok().map(std::sync::Arc::new)
+    }
+}
+
+fn clip_comp() -> Comp {
+    let mut c = Comp::new(200, 100, FrameRate::FPS_30, Tick::from_seconds_f64(6.0));
+    c.renderer = effectcraft_project::Renderer::Advanced3D;
+    c
+}
+
+/// The sliding triangle at 20 px a model unit. `keys` key Geometry Options ▸ Animation as
+/// (layer seconds, popup value); with none, clip 1 is selected statically.
+fn sliding_model(p: &mut Project, comp: &Comp, keys: &[(f64, u32)], looping: bool) -> effectcraft_project::Layer {
+    let footage = effectcraft_project::Footage {
+        path: "Sliding.gltf".into(),
+        kind: effectcraft_project::FootageKind::Model,
+        frame_rate: FrameRate::FPS_30,
+        codec: "glTF".into(),
+        ..Default::default()
+    };
+    let mid = p.add_item("Sliding", Label::Red, None, ItemKind::Footage(footage));
+    let mut l = build::layer(p, comp, "Sliding", LayerSource::Model { item: mid }, (200, 100), None);
+    l.props.prop_mut("geometryOptions/unitScale").unwrap().value = Value::Scalar(20.0);
+    l.props.prop_mut("geometryOptions/loopAnimation").unwrap().value = Value::Bool(looping);
+    let clip = l.props.prop_mut("geometryOptions/animation").unwrap();
+    clip.value = Value::Enum(1);
+    clip.keys = keys.iter().map(|&(t, v)| Keyframe::new(Tick::from_seconds_f64(t), Value::Enum(v)).hold()).collect();
+    l
+}
+
+fn clip_scene(keys: &[(f64, u32)], looping: bool, stretch: f64, start: f64) -> (Project, ItemId) {
+    let (mut p, mut comp) = (Project::default(), clip_comp());
+    p.settings.bit_depth = effectcraft_project::BitDepth::Bpc32;
+    let mut l = sliding_model(&mut p, &comp, keys, looping);
+    l.stretch = stretch;
+    l.start_time = Tick::from_seconds_f64(start);
+    comp.layers = vec![l].into();
+    let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.into()));
+    (p, cid)
+}
+
+fn clip_frame(p: &Project, cid: ItemId, t: Tick) -> crate::Image {
+    crate::Renderer::new(p, &SlidingModels, crate::RenderOpts::default()).comp_frame(cid, t)
+}
+
+/// The pose of the clip `elapsed` seconds in: clip 1 selected statically, played on the layer
+/// clock.
+fn clip_pose(looping: bool, elapsed: f64) -> crate::Image {
+    let (p, cid) = clip_scene(&[], looping, 100.0, 0.0);
+    clip_frame(&p, cid, Tick::from_seconds_f64(elapsed))
+}
+
+fn assert_poses(p: &Project, cid: ItemId, looping: bool, cases: &[(f64, f64)]) {
+    for &(t, elapsed) in cases {
+        let at = clip_frame(p, cid, Tick::from_seconds_f64(t));
+        assert_same(&at, &clip_pose(looping, elapsed), &format!("at {t}s the clip is {elapsed}s in"));
+    }
+}
+
+#[test]
+fn a_static_clip_plays_on_the_layer_clock() {
+    let xs: Vec<f32> = [0.0, 0.25, 0.75, 1.0].iter().map(|&e| cover_x(&clip_pose(false, e))).collect();
+    assert!(xs.windows(2).all(|w| w[1] > w[0] + 5.0), "the clip slides the triangle right: {xs:?}");
+    assert_same(&clip_pose(true, 1.25), &clip_pose(true, 0.25), "a looping clip wraps on the layer clock");
+}
+
+#[test]
+fn a_clip_keyed_on_later_starts_from_its_first_frame() {
+    let (p, cid) = clip_scene(&[(0.0, 0), (3.0, 1)], false, 100.0, 0.0);
+    assert_poses(&p, cid, false, &[(3.0, 0.0), (3.25, 0.25), (3.75, 0.75), (4.0, 1.0), (5.0, 1.0)]);
+}
+
+#[test]
+fn a_looping_clip_keyed_on_later_loops_from_its_activation() {
+    let (p, cid) = clip_scene(&[(0.0, 0), (2.5, 1)], true, 100.0, 0.0);
+    assert_poses(&p, cid, true, &[(2.75, 0.25), (3.75, 0.25)]);
+}
+
+#[test]
+fn a_clip_reselected_after_none_restarts() {
+    let (p, cid) = clip_scene(&[(0.0, 1), (1.5, 0), (3.0, 1)], false, 100.0, 0.0);
+    assert_poses(&p, cid, false, &[(0.5, 0.5), (3.25, 0.25)]);
+}
+
+#[test]
+fn a_repeated_key_of_the_same_clip_does_not_restart_it() {
+    let (p, cid) = clip_scene(&[(0.0, 0), (2.0, 1), (3.0, 1)], false, 100.0, 0.0);
+    assert_poses(&p, cid, false, &[(2.5, 0.5), (3.25, 1.25)]);
+}
+
+#[test]
+fn seeking_a_keyed_clip_poses_it_the_same_in_any_order() {
+    let (p, cid) = clip_scene(&[(0.0, 0), (3.0, 1)], false, 100.0, 0.0);
+    let cache = crate::LayerCache::default();
+    let mut r = crate::Renderer::new(&p, &SlidingModels, crate::RenderOpts::default());
+    r.cache = Some(&cache);
+    for (t, elapsed) in [(4.0, 1.0), (3.25, 0.25), (3.0, 0.0), (3.75, 0.75), (3.25, 0.25), (4.0, 1.0)] {
+        let at = r.comp_frame(cid, Tick::from_seconds_f64(t));
+        assert_same(&at, &clip_pose(false, elapsed), &format!("seek to {t}s: the clip is {elapsed}s in"));
+    }
+}
+
+#[test]
+fn a_stretched_layer_times_its_clip_from_activation_in_layer_time() {
+    let (p, cid) = clip_scene(&[(0.0, 0), (1.5, 1)], false, 200.0, 0.0);
+    let t = p.comp(cid).unwrap().layers[0].comp_time(Tick::from_seconds_f64(1.75));
+    assert_same(&clip_frame(&p, cid, t), &clip_pose(false, 0.25), "layer time 1.75 s: the clip is 0.25 s in");
+}
+
+#[test]
+fn a_reversed_layer_times_its_clip_from_activation_in_layer_time() {
+    let (p, cid) = clip_scene(&[(0.0, 0), (3.0, 1)], false, -100.0, 5.0);
+    let l = &p.comp(cid).unwrap().layers[0];
+    let t = l.comp_time(Tick::from_seconds_f64(3.25));
+    assert!(l.is_active_at(t), "the reversed layer is on at {t:?}");
+    assert_same(&clip_frame(&p, cid, t), &clip_pose(false, 0.25), "layer time 3.25 s: the clip is 0.25 s in");
+}
+
+#[test]
+fn an_expression_driven_clip_keeps_the_layer_clock() {
+    let (mut p, cid) = clip_scene(&[(0.0, 0), (2.5, 1)], true, 100.0, 0.0);
+    let clip = p.comp_mut(cid).unwrap().layers[0].props.prop_mut("geometryOptions/animation").unwrap();
+    clip.expr = Some(effectcraft_project::Expression { text: "value".into(), enabled: true });
+    assert_poses(&p, cid, true, &[(3.25, 3.25)]);
+    assert!((cover_x(&clip_pose(true, 3.25)) - cover_x(&clip_pose(true, 0.75))).abs() > 5.0, "the layer clock and the activation clock disagree");
+}
+
+/// The sliding model keyed None, then clip 1 at 3 s, in a collapsed 3D precomp; `overridden`
+/// sets the clip through its Essential Property, and `copy` adds a 3D Layer Instance of it.
+fn collapsed_clip_scene(overridden: bool, copy: bool) -> (Project, ItemId) {
+    use effectcraft_project::essential::{self, EgControl, EgKind, EssentialGraphics};
+    let mut p = Project::default();
+    p.settings.bit_depth = effectcraft_project::BitDepth::Bpc32;
+    let (mut inner, mut outer) = (clip_comp(), clip_comp());
+    let model = sliding_model(&mut p, &inner, &[(0.0, 0), (3.0, 1)], false);
+    let prop = model.props.prop("geometryOptions/animation").unwrap().uid;
+    let kind = EgKind::Property { layer: model.id, prop, links: vec![] };
+    inner.essential = Some(EssentialGraphics { controls: vec![EgControl { id: 1, name: "Clip".into(), kind, as_type: None }], ..Default::default() });
+    let mut layers = vec![];
+    if copy {
+        let mut owner = solid(&mut p, &inner, [1.0, 1.0, 1.0], 200, 100);
+        add_effect_200(&mut p, &mut owner, "ec.3d.instance3d", &[("layer", Value::Layer(Some(model.id.0)))]);
+        layers.push(owner);
+    }
+    layers.push(model);
+    inner.layers = layers.into();
+    let iid = p.add_item("Inner", Label::Sandstone, None, ItemKind::Comp(inner.into()));
+    let mut pre = build::layer(&mut p, &outer, "Inner", LayerSource::Comp { item: iid }, (200, 100), None);
+    pre.switches.three_d = true;
+    pre.switches.collapse = true;
+    if overridden {
+        let mut ids = Ids(&mut p.next_id);
+        let control = ids.prop(&essential::match_id(1), "Clip", Value::Enum(1));
+        let mut group = ids.group(essential::GROUP, "Essential Properties");
+        group.kind = effectcraft_project::GroupKind::Essential { overridden: vec![control.uid] };
+        group.children.push(control.into());
+        pre.props.children.push(group.into());
+    }
+    outer.layers = vec![pre].into();
+    let cid = p.add_item("Outer", Label::Sandstone, None, ItemKind::Comp(outer.into()));
+    (p, cid)
+}
+
+#[test]
+fn an_essential_property_override_of_the_clip_keeps_the_layer_clock() {
+    let (p, cid) = collapsed_clip_scene(true, false);
+    assert_poses(&p, cid, false, &[(1.0, 1.0), (3.25, 3.25)]);
+    assert!((cover_x(&clip_pose(false, 3.25)) - cover_x(&clip_pose(false, 0.25))).abs() > 5.0, "the layer clock and the activation clock disagree");
+}
+
+/// The keyed clip and its override select the same clip at 3.25 s but pose it 0.25 s and
+/// 3.25 s in: a 3D Layer Instance of one is not served the other's pixels.
+#[test]
+fn a_copy_of_an_overridden_clip_is_not_served_the_keyed_clips_pixels() {
+    let t = Tick::from_seconds_f64(3.25);
+    let cache = crate::LayerCache::default();
+    let render = |(p, cid): &(Project, ItemId), cache: Option<&crate::LayerCache>| {
+        let mut r = crate::Renderer::new(p, &SlidingModels, crate::RenderOpts::default());
+        r.cache = cache;
+        r.comp_frame(*cid, t)
+    };
+    let (keyed, overridden) = (collapsed_clip_scene(false, true), collapsed_clip_scene(true, true));
+    assert_same(&render(&keyed, Some(&cache)), &render(&keyed, None), "the keyed clip's copy");
+    assert_same(&render(&overridden, Some(&cache)), &render(&overridden, None), "the overridden clip's copy");
+}
diff --git a/crates/render/src/tests_audio_fx.rs b/crates/render/src/tests/audio_fx.rs
similarity index 82%
rename from crates/render/src/tests_audio_fx.rs
rename to crates/render/src/tests/audio_fx.rs
index aced8208e..a6c85f2de 100644
--- a/crates/render/src/tests_audio_fx.rs
+++ b/crates/render/src/tests/audio_fx.rs
@@ -2,7 +2,7 @@
 
 use std::sync::Arc;
 
-use effectcraft_keyframe::Value;
+use effectcraft_keyframe::{Keyframe, Value};
 use effectcraft_project::build::{self, Ids};
 use effectcraft_project::{Comp, Footage, FootageKind, ItemId, ItemKind, LayerSource, Project, Solid};
 use effectcraft_time::{FrameRate, Tick};
@@ -78,7 +78,7 @@ fn comp_with(id: Option<&str>, vals: &[(&str, Value)], solid: bool) -> (Project,
         l.props.sub_mut("effects").unwrap().children.push(g.into());
     }
     let mut comp = comp;
-    comp.layers = vec![l];
+    comp.layers = vec![l].into();
     let cid = p.add_item("C", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(comp.into()));
     (p, cid)
 }
@@ -148,6 +148,42 @@ fn stereo_mixer_pans() {
     assert!(m.chunks(2).all(|f| f[0].abs() < 1e-6 && (f[1] - 0.5).abs() < 1e-6), "{:?}", &m[..4]);
 }
 
+/// Key `prop` of layer 0 (`effect`: in its first effect, else in Audio) from `a` at 0 s to `b` at 1 s.
+fn key(p: &mut Project, cid: ItemId, effect: bool, prop: &str, a: Value, b: Value) {
+    let l = &mut p.comp_mut(cid).unwrap().layers[0];
+    let g = if effect { l.props.sub_mut("effects").unwrap().children[0].as_group_mut().unwrap() } else { l.props.sub_mut("audio").unwrap() };
+    g.get_mut(prop).unwrap().keys = vec![Keyframe::new(Tick::ZERO, a), Keyframe::new(Tick::from_seconds_f64(1.0), b)];
+}
+
+/// Left samples of a mix of constant 0.5 audio over the layer's 1 s, in blocks of `block` samples.
+fn left_ramp(p: &Project, cid: ItemId, block: usize) -> Vec<f32> {
+    fn half(_: f64) -> (f32, f32) {
+        (0.5, 0.5)
+    }
+    let mut m = vec![];
+    for k in 0..SR as usize / block {
+        m.extend(mix(p, &Signal(half), cid, (k * block) as f64 / SR as f64, block));
+    }
+    m.iter().step_by(2).copied().collect()
+}
+
+/// Keyframed Audio Levels and Stereo Mixer levels ramp smoothly inside a block (export mixes one
+/// second at a time), instead of holding the value at the block's first sample.
+#[test]
+fn animated_levels_ramp_within_a_block() {
+    let (mut levels, lc) = comp_with(None, &[], false);
+    key(&mut levels, lc, false, "levels", Value::Vec2([-60.0, -60.0]), Value::Vec2([0.0, 0.0]));
+    let (mut mixer, mc) = comp_with(Some("ec.audio.stereomixer"), &[], false);
+    key(&mut mixer, mc, true, "leftLevel", Value::Scalar(0.0), Value::Scalar(100.0));
+    for (name, p, cid, mid) in [("levels", &levels, lc, 0.5 * 10f32.powf(-1.5)), ("stereo mixer", &mixer, mc, 0.25)] {
+        let one = left_ramp(p, cid, SR as usize);
+        assert!(one.windows(2).all(|w| w[1] >= w[0]), "{name}: not monotonic");
+        assert!(one[100] < one[4000] && one[4000] < one[7900], "{name}: {} {} {}", one[100], one[4000], one[7900]);
+        assert!((one[4000] / mid - 1.0).abs() < 0.05, "{name}: {} at 0.5 s, want {mid}", one[4000]);
+        assert_eq!(one, left_ramp(p, cid, 320), "{name}: block size changes the result");
+    }
+}
+
 #[test]
 fn tone_makes_a_solid_audible_at_its_frequency() {
     let mut vals: Vec<(&str, Value)> = vec![("frequency1", Value::Scalar(500.0))];
@@ -236,7 +272,7 @@ fn audio_spectrum_follows_time_through_the_layer_cache() {
     g.prop_mut("audioLayer").unwrap().value = Value::Layer(Some(a.id.0));
     s.props.sub_mut("effects").unwrap().children.push(g.into());
     let mut comp = comp;
-    comp.layers = vec![s, a];
+    comp.layers = vec![s, a].into();
     let cid = p.add_item("C", effectcraft_color::Label::Sandstone, None, ItemKind::Comp(comp.into()));
 
     let src = Signal(late_tone);
diff --git a/crates/render/src/tests_auto.rs b/crates/render/src/tests/auto.rs
similarity index 100%
rename from crates/render/src/tests_auto.rs
rename to crates/render/src/tests/auto.rs
diff --git a/crates/render/src/tests_aux.rs b/crates/render/src/tests/aux_channels.rs
similarity index 100%
rename from crates/render/src/tests_aux.rs
rename to crates/render/src/tests/aux_channels.rs
diff --git a/crates/render/src/tests_collapse.rs b/crates/render/src/tests/collapse.rs
similarity index 80%
rename from crates/render/src/tests_collapse.rs
rename to crates/render/src/tests/collapse.rs
index 797960033..30d2163c1 100644
--- a/crates/render/src/tests_collapse.rs
+++ b/crates/render/src/tests/collapse.rs
@@ -3,7 +3,7 @@
 use effectcraft_color::{BlendMode, Label};
 use effectcraft_keyframe::{TextDoc, Value};
 use effectcraft_project::build::{self, Ids};
-use effectcraft_project::{BitDepth, Comp, ItemId, ItemKind, Layer, LayerSource, Project, Quality, Solid};
+use effectcraft_project::{BitDepth, Comp, FrameBlend, ItemId, ItemKind, Layer, LayerSource, Project, Quality, Solid};
 use effectcraft_time::{FrameRate, Tick};
 
 use crate::{EvalCtx, Image, NoFootage, RenderOpts, Renderer, render_frame};
@@ -53,17 +53,17 @@ fn scene(collapse: bool, flatten: bool) -> (Project, ItemId) {
         a.parent = Some(null.id);
         b.parent = Some(null.id);
         let mut c = outer.clone();
-        c.layers = vec![null, b, a, bg];
+        c.layers = vec![null, b, a, bg].into();
         p.add_item("Outer", Label::Sandstone, None, ItemKind::Comp(c.into()))
     } else {
         let mut inner = inner;
-        inner.layers = vec![b, a];
+        inner.layers = vec![b, a].into();
         let iid = p.add_item("Inner", Label::Sandstone, None, ItemKind::Comp(inner.into()));
         let mut pre = build::layer(&mut p, &outer, "Inner", LayerSource::Comp { item: iid }, (100, 100), None);
         xf(&mut pre);
         pre.switches.collapse = collapse;
         let mut c = outer.clone();
-        c.layers = vec![pre, bg];
+        c.layers = vec![pre, bg].into();
         p.add_item("Outer", Label::Sandstone, None, ItemKind::Comp(c.into()))
     };
     (p, cid)
@@ -110,6 +110,66 @@ fn masks_on_a_collapsed_layer_force_a_flattened_render() {
     assert!(max_diff(&a, &b) < 1e-4, "{}", max_diff(&a, &b));
 }
 
+/// #1747: the flattened path honours a composition proxy and frame blending; a collapsed layer
+/// renders the nested comp directly and ignores both, so such a layer must not collapse.
+#[test]
+fn proxy_and_frame_blending_keep_a_precomp_on_the_flattened_path() {
+    let (mut p, cid) = scene(true, false);
+    let id = p.comp(cid).unwrap().layers[0].id;
+    let collapses = |p: &Project| {
+        let r = Renderer::new(p, &NoFootage, RenderOpts::default());
+        let ctx = EvalCtx::new(p, cid, p.comp(cid).unwrap(), Tick::ZERO);
+        r.collapsed(&ctx, ctx.comp.layer(id).unwrap()).is_some()
+    };
+    assert!(collapses(&p), "a plain precomp collapses");
+    // Frame blending needs both the comp's switch and the layer's.
+    p.comp_mut(cid).unwrap().enable_frame_blending = true;
+    p.comp_mut(cid).unwrap().layers[0].switches.frame_blend = FrameBlend::FrameMix;
+    assert!(!collapses(&p), "frame blending keeps the flattened path");
+    p.comp_mut(cid).unwrap().enable_frame_blending = false;
+    p.comp_mut(cid).unwrap().layers[0].switches.frame_blend = FrameBlend::Off;
+    // A composition proxy stands in for the precomp's pixels.
+    let LayerSource::Comp { item } = p.comp(cid).unwrap().layers[0].source else { panic!("a precomp layer") };
+    let proxy =
+        effectcraft_project::Proxy { footage: effectcraft_project::Footage { has_video: true, width: 32, height: 32, ..Default::default() }, enabled: true };
+    p.item_mut(item).unwrap().proxy = Some(Box::new(proxy));
+    assert!(!collapses(&p), "a proxy keeps the flattened path");
+}
+
+/// #1747: an effect on B that reads A must not reuse its cached buffer when two collapsed
+/// instances give A different static overrides (`hash_values` only sees animated values).
+#[test]
+fn referenced_layer_overrides_change_the_owner_cache_key() {
+    let mut p = project();
+    let comp = Comp::new(100, 100, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
+    let a = solid(&mut p, &comp, [1.0, 1.0, 1.0], (40, 40), [30.0, 50.0, 0.0]);
+    let aid = a.id;
+    let mut b = solid(&mut p, &comp, [1.0, 1.0, 1.0], (100, 100), [50.0, 50.0, 0.0]);
+    let bid = b.id;
+    let mut next = p.next_id;
+    let mut ids = Ids(&mut next);
+    let spec = effectcraft_effects::find("ec.channel.setmatte").unwrap();
+    let mut fx = effectcraft_effects::instantiate(spec, &mut ids, spec.name, [100.0, 100.0]);
+    fx.prop_mut("takeMatteFromLayer").unwrap().value = Value::Layer(Some(a.id.0));
+    p.next_id = next;
+    b.props.sub_mut("effects").unwrap().children.push(fx.into());
+    let mut c = comp;
+    c.layers = vec![b, a].into();
+    let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
+    let comp = p.comp(cid).unwrap();
+    let b = comp.layer(bid).unwrap();
+    let opacity = comp.layer(aid).unwrap().props.prop("transform/opacity").unwrap().uid;
+    let key = |value: f64| {
+        let overrides = [crate::PropertyOverride { layer: aid, prop: opacity, value: Value::Scalar(value), font: false }];
+        let ctx =
+            EvalCtx { project: &p, comp_id: cid, comp, time: Tick::ZERO, expr: None, footage: None, property_overrides: &overrides, media_overrides: &[] };
+        crate::cache::layer_key(&ctx, b, 1.0, false, false)
+    };
+    let (opaque, half) = (key(100.0), key(50.0));
+    assert!(opaque.is_some(), "the owner is cacheable");
+    assert_ne!(opaque, half, "A's static override changes B's key");
+}
+
 #[test]
 fn collapsed_3d_layers_join_the_parent_scene() {
     // Parent: a red 3D solid at z = 0 above (in the stack) a collapsed 3D precomp holding a
@@ -122,7 +182,7 @@ fn collapsed_3d_layers_join_the_parent_scene() {
         let mut blue = solid(&mut p, &inner, [0.0, 0.0, 1.0], (60, 60), [100.0, 100.0, -200.0]);
         blue.switches.three_d = true;
         let mut inner = inner;
-        inner.layers = vec![blue];
+        inner.layers = vec![blue].into();
         let iid = p.add_item("Inner", Label::Sandstone, None, ItemKind::Comp(inner.into()));
         let mut pre = build::layer(&mut p, &outer, "Inner", LayerSource::Comp { item: iid }, (200, 200), None);
         pre.switches.three_d = true;
@@ -130,7 +190,7 @@ fn collapsed_3d_layers_join_the_parent_scene() {
         let mut red = solid(&mut p, &outer, [1.0, 0.0, 0.0], (100, 100), [100.0, 100.0, 0.0]);
         red.switches.three_d = true;
         let mut c = outer;
-        c.layers = vec![red, pre];
+        c.layers = vec![red, pre].into();
         let cid = p.add_item("Outer", Label::Sandstone, None, ItemKind::Comp(c.into()));
         render_frame(&p, cid, Tick::ZERO, 1.0).get(100, 100)
     };
@@ -168,11 +228,11 @@ fn scaled_square(cr: bool, via_parent: bool) -> Image {
         set(&mut null, "transform/scale", Value::Vec3([800.0, 800.0, 100.0]));
         set(&mut l, "transform/position", Value::Vec3([0.0, 0.0, 0.0]));
         l.parent = Some(null.id);
-        c.layers = vec![l, null];
+        c.layers = vec![l, null].into();
     } else {
         set(&mut l, "transform/position", Value::Vec3([100.3, 100.3, 0.0]));
         set(&mut l, "transform/scale", Value::Vec3([800.0, 800.0, 100.0]));
-        c.layers = vec![l];
+        c.layers = vec![l].into();
     }
     let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
     render_frame(&p, cid, Tick::ZERO, 1.0)
@@ -201,7 +261,7 @@ fn wireframe_quality_draws_the_layer_bounds() {
     let mut l = solid(&mut p, &comp, [1.0, 0.0, 0.0], (40, 40), [50.0, 50.0, 0.0]);
     l.switches.quality = Quality::Wireframe;
     let mut c = comp;
-    c.layers = vec![l];
+    c.layers = vec![l].into();
     let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
     let img = render_frame(&p, cid, Tick::ZERO, 1.0);
     assert_eq!(img.get(50, 50)[3], 0.0, "no fill");
@@ -212,7 +272,7 @@ fn wireframe_quality_draws_the_layer_bounds() {
     let mut l = solid(&mut p, &comp, [1.0, 1.0, 1.0], (40, 40), [50.5, 50.0, 0.0]);
     l.switches.quality = Quality::Draft;
     let mut c = comp;
-    c.layers = vec![l];
+    c.layers = vec![l].into();
     let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
     let img = render_frame(&p, cid, Tick::ZERO, 1.0);
     assert!(img.data.iter().all(|q| q[3] == 0.0 || q[3] == 1.0));
@@ -230,13 +290,13 @@ fn collapsed_precomp_of_another_size_renders_through_the_parent_camera() {
         let mut blue = solid(&mut p, &inner, [0.0, 0.0, 1.0], (40, 40), [500.0, 300.0, 0.0]);
         blue.switches.three_d = true;
         let mut inner = inner;
-        inner.layers = vec![blue];
+        inner.layers = vec![blue].into();
         let iid = p.add_item("Scene", Label::Sandstone, None, ItemKind::Comp(inner.into()));
         let mut pre = build::layer(&mut p, &outer, "Scene", LayerSource::Comp { item: iid }, (1000, 600), None);
         pre.switches.three_d = three_d_precomp;
         pre.switches.collapse = true;
         let mut c = outer.clone();
-        c.layers = vec![pre];
+        c.layers = vec![pre].into();
         if camera {
             let cam = build::layer(&mut p, &outer, "Camera", LayerSource::Camera, (300, 200), None);
             c.layers.insert(0, cam);
@@ -267,7 +327,7 @@ fn text_scaled_up_stays_sharp_without_the_switch() {
         set(&mut l, "transform/scale", Value::Vec3([scale, scale, 100.0]));
         assert!(!l.switches.collapse);
         let mut c = comp;
-        c.layers = vec![l];
+        c.layers = vec![l].into();
         let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
         render_frame(&p, cid, Tick::ZERO, 1.0)
     };
@@ -291,7 +351,7 @@ fn unscaled_text_rasterises_at_the_output_scale() {
     let mut comp = Comp::new(240, 160, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
     let mut l = build::layer(&mut p, &comp, "Text", LayerSource::Text, (240, 160), None);
     l.props.prop_mut("text/sourceText").unwrap().value = Value::Text(Box::new(TextDoc { text: "HE".into(), size: 30.0, ..Default::default() }));
-    comp.layers = vec![l];
+    comp.layers = vec![l].into();
     let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.into()));
     for i in 0..500 {
         let pos = [3.1 + i as f64 * 0.37, 7.3 + i as f64 * 0.29, 0.0];
@@ -327,7 +387,7 @@ fn effects_on_a_scaled_shape_follow_its_scale() {
         set(&mut l, "transform/position", Value::Vec3([100.0, 100.0, 0.0]));
         set(&mut l, "transform/scale", Value::Vec3([scale, scale, 100.0]));
         let mut c = comp;
-        c.layers = vec![l];
+        c.layers = vec![l].into();
         let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(c.into()));
         render_frame(&p, cid, Tick::ZERO, 1.0)
     };
diff --git a/crates/render/src/tests_color.rs b/crates/render/src/tests/color.rs
similarity index 100%
rename from crates/render/src/tests_color.rs
rename to crates/render/src/tests/color.rs
diff --git a/crates/render/src/tests_footage_size.rs b/crates/render/src/tests/footage_size.rs
similarity index 100%
rename from crates/render/src/tests_footage_size.rs
rename to crates/render/src/tests/footage_size.rs
diff --git a/crates/render/src/tests_frame_blend.rs b/crates/render/src/tests/frame_blend.rs
similarity index 96%
rename from crates/render/src/tests_frame_blend.rs
rename to crates/render/src/tests/frame_blend.rs
index 6cfbdb11b..ac3555af1 100644
--- a/crates/render/src/tests_frame_blend.rs
+++ b/crates/render/src/tests/frame_blend.rs
@@ -167,3 +167,10 @@ fn time_stretched_precomp_frame_mixes() {
     let img = crate::render_frame(&p, cid, FrameRate::FPS_30.tick_of(1), 1.0);
     assert!(img.get(12, 10)[3] < 1e-3 && (img.get(17, 10)[3] - 1.0).abs() < 1e-3 && (img.get(22, 10)[3] - 1.0).abs() < 1e-3 && img.get(27, 10)[3] < 1e-3);
 }
+
+#[test]
+fn frame_position_survives_degenerate_rates() {
+    for rate in [FrameRate { num: 24, den: 0 }, FrameRate { num: 0, den: 1 }, FrameRate { num: -24, den: 1 }] {
+        assert_eq!(frame_position(Tick(1_000_000), rate), (0, 0.0));
+    }
+}
diff --git a/crates/render/src/tests_guides.rs b/crates/render/src/tests/guides.rs
similarity index 98%
rename from crates/render/src/tests_guides.rs
rename to crates/render/src/tests/guides.rs
index cb9851250..44f3fc7b0 100644
--- a/crates/render/src/tests_guides.rs
+++ b/crates/render/src/tests/guides.rs
@@ -40,7 +40,7 @@ fn scene(nest: Nest) -> (Project, ItemId, ItemId) {
     guide.switches.guide = true;
     let bg = solid(&mut p, &inner, [1.0, 0.0, 0.0], (100, 100), three_d);
     let mut inner = inner;
-    inner.layers = vec![guide, bg];
+    inner.layers = vec![guide, bg].into();
     let iid = p.add_item("Inner", Label::Sandstone, None, ItemKind::Comp(inner.into()));
     let mut outer = Comp::new(100, 100, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
     if matches!(nest, Nest::CollapsedAdvanced) {
@@ -49,7 +49,7 @@ fn scene(nest: Nest) -> (Project, ItemId, ItemId) {
     let mut pre = build::layer(&mut p, &outer, "Inner", LayerSource::Comp { item: iid }, (100, 100), None);
     pre.switches.collapse = !matches!(nest, Nest::Precomp);
     pre.switches.three_d = three_d;
-    outer.layers = vec![pre];
+    outer.layers = vec![pre].into();
     let oid = p.add_item("Outer", Label::Sandstone, None, ItemKind::Comp(outer.into()));
     (p, iid, oid)
 }
diff --git a/crates/render/src/tests_mask_blur.rs b/crates/render/src/tests/mask_blur.rs
similarity index 100%
rename from crates/render/src/tests_mask_blur.rs
rename to crates/render/src/tests/mask_blur.rs
diff --git a/crates/render/src/tests_mask_expansion.rs b/crates/render/src/tests/mask_expansion.rs
similarity index 100%
rename from crates/render/src/tests_mask_expansion.rs
rename to crates/render/src/tests/mask_expansion.rs
diff --git a/crates/render/src/tests/mask_feather.rs b/crates/render/src/tests/mask_feather.rs
new file mode 100644
index 000000000..db04b1f9f
--- /dev/null
+++ b/crates/render/src/tests/mask_feather.rs
@@ -0,0 +1,251 @@
+//! A feathered mask blurs its own edge, also where the path lies outside the layer: the feather
+//! of a mask partly or wholly outside the layer reaches into it (After Effects), instead of the
+//! coverage stopping at the layer edge.
+
+use effectcraft_color::Label;
+use effectcraft_keyframe::{ShapePath, Value};
+use effectcraft_project::build::{self, Ids};
+use effectcraft_project::{BitDepth, Comp, FeatherFalloff, GroupKind, ItemId, ItemKind, Layer, LayerSource, MaskMode, Node, Project, Solid};
+use effectcraft_time::{FrameRate, Tick};
+
+use crate::render_frame;
+
+fn solid(p: &mut Project, comp: &Comp, color: [f32; 3], w: u32, h: u32) -> Layer {
+    let sid = p.add_item("Solid", Label::Red, None, ItemKind::Solid(Solid { color, width: w, height: h, pixel_aspect: 1.0 }));
+    build::layer(p, comp, "Solid", LayerSource::Solid { item: sid }, (w, h), None)
+}
+
+fn add_mask(p: &mut Project, l: &mut Layer, rect: ShapePath, feather: [f64; 2], linear: bool) {
+    let mut next = p.next_id;
+    let mut m = build::mask(&mut Ids(&mut next), "Mask 1", rect, MaskMode::Add, [255, 255, 0]);
+    p.next_id = next;
+    m.get_mut("feather").unwrap().value = Value::Vec2(feather);
+    if linear && let GroupKind::Mask { feather_falloff, .. } = &mut m.kind {
+        *feather_falloff = FeatherFalloff::Linear;
+    }
+    l.props.sub_mut("masks").unwrap().children.push(Node::Group(m));
+}
+
+/// Coverage at signed distance `d` inside an edge blurred by three box passes `w` pixels wide
+/// (the Smooth falloff: an Irwin-Hall n = 3 distribution function, support +-1.5 w).
+fn edge(d: f64, w: f64) -> f64 {
+    let t = (d / w + 1.5).clamp(0.0, 3.0);
+    if t < 1.0 {
+        t * t * t / 6.0
+    } else if t < 2.0 {
+        (-2.0 * t * t * t + 9.0 * t * t - 9.0 * t + 3.0) / 6.0
+    } else {
+        1.0 - (3.0 - t).powi(3) / 6.0
+    }
+}
+
+/// The box window of the Smooth falloff for `feather` pixels: `2 round(0.37 feather) + 1`.
+fn window(feather: f64) -> f64 {
+    2.0 * (0.37 * feather).round() + 1.0
+}
+
+/// Coverage at pixel centre `x` of the span `a..b` feathered by `feather` (one axis).
+fn span(x: f64, a: f64, b: f64, feather: f64) -> f64 {
+    let w = window(feather);
+    edge(x - a, w) + edge(b - x, w) - 1.0
+}
+
+/// A white 200×100 solid (32 bpc) with one Add mask.
+fn white_with_mask(rect: ShapePath, feather: [f64; 2], linear: bool, scale: f64) -> effectcraft_raster::Image {
+    let mut p = Project::default();
+    p.settings.bit_depth = BitDepth::Bpc32;
+    let comp = Comp::new(200, 100, FrameRate::FPS_30, Tick::from_seconds_f64(1.0));
+    let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.clone().into()));
+    let mut l = solid(&mut p, &comp, [1.0; 3], 200, 100);
+    add_mask(&mut p, &mut l, rect, feather, linear);
+    p.comp_mut(cid).unwrap().layers.push(l);
+    render_frame(&p, cid, Tick::ZERO, scale)
+}
+
+#[test]
+fn a_feathered_mask_outside_a_solid_reaches_into_it() {
+    // The mask spans x 210..260, right of the layer (x 0..200); feather 40 = three 31 px boxes.
+    let img = white_with_mask(ShapePath::rect([235.0, 50.0], 50.0, 200.0), [40.0, 40.0], false, 1.0);
+    for x in [150i64, 170, 180, 199] {
+        let want = span(x as f64 + 0.5, 210.0, 260.0, 40.0) * span(50.5, -50.0, 150.0, 40.0);
+        let got = img.get(x, 50)[3] as f64;
+        assert!((got - want).abs() < 0.01, "x {x}: alpha {got}, the box kernel gives {want}");
+    }
+    assert!(img.get(199, 50)[3] > 0.25, "the feather reaches the layer edge");
+    // Finite support: nothing beyond 1.5 windows (46.5 px) from the edge.
+    assert!(img.get(160, 50)[3] == 0.0 && img.get(100, 50)[3] == 0.0);
+    // Without feather the mask hides the layer.
+    let hard = white_with_mask(ShapePath::rect([235.0, 50.0], 50.0, 200.0), [0.0, 0.0], false, 1.0);
+    assert!(hard.data.iter().all(|p| p[3] == 0.0));
+    // A linear falloff ramps over the feather width: 20 px either side of the edge at x 210.
+    let lin = white_with_mask(ShapePath::rect([235.0, 50.0], 50.0, 200.0), [40.0, 40.0], true, 1.0);
+    let a = lin.get(199, 50)[3];
+    assert!((a - 0.24).abs() < 0.04, "linear: {a}");
+    assert!(lin.get(185, 50)[3] < 0.01);
+    // At half resolution the same layer pixel gets the same coverage.
+    let half = white_with_mask(ShapePath::rect([235.0, 50.0], 50.0, 200.0), [40.0, 40.0], false, 0.5);
+    assert!((half.get(99, 25)[3] - img.get(198, 50)[3]).abs() < 0.02, "{} {}", half.get(99, 25)[3], img.get(198, 50)[3]);
+}
+
+#[test]
+fn a_feathered_mask_larger_than_the_layer_keeps_the_layer_edges() {
+    // The mask covers the layer and 100 px around it: the layer edges are inside the mask and
+    // stay opaque (they used to fade, as if the layer edge were the mask edge).
+    let img = white_with_mask(ShapePath::rect([100.0, 50.0], 400.0, 300.0), [40.0, 40.0], false, 1.0);
+    for (x, y) in [(0i64, 0i64), (0, 50), (199, 99), (100, 0)] {
+        assert!(img.get(x, y)[3] > 0.99, "({x}, {y}): {}", img.get(x, y)[3]);
+    }
+    // A mask edge inside the layer is feathered as before: half coverage on the edge.
+    let inner = white_with_mask(ShapePath::rect([100.0, 50.0], 100.0, 400.0), [40.0, 40.0], false, 1.0);
+    assert!((inner.get(50, 50)[3] - 0.5).abs() < 0.03, "{}", inner.get(50, 50)[3]);
+    assert!(inner.get(100, 50)[3] > 0.98);
+}
+
+#[test]
+fn huge_and_broken_feathers_stay_bounded() {
+    for f in [1.0e5, 1.0e9, f64::INFINITY, f64::NAN, -5.0] {
+        let img = white_with_mask(ShapePath::rect([235.0, 50.0], 50.0, 200.0), [f, f], false, 1.0);
+        assert!(img.data.iter().all(|p| p[3].is_finite() && (0.0..=1.0).contains(&p[3])), "feather {f}");
+        let img = white_with_mask(ShapePath::rect([235.0, 50.0], 50.0, 200.0), [f, 10.0], true, 1.0);
+        assert!(img.data.iter().all(|p| p[3].is_finite() && (0.0..=1.0).contains(&p[3])), "linear feather {f}");
+    }
+}
+
+/// Case 398 of the .aep corpus, built in EffectCraft's own model: a 1920×1080 comp at 8 bpc, a
+/// red solid, above it an adjustment layer of comp size with a Gradient Ramp at its defaults and
+/// one Add mask entirely below the layer (1920×200 centred at [960, 1250]) with feather 1000.
+fn case_398(with_mask: bool) -> (Project, ItemId) {
+    let mut p = Project::default();
+    assert_eq!(p.settings.bit_depth, BitDepth::Bpc8, "After Effects' default depth");
+    let comp = Comp::new(1920, 1080, FrameRate::FPS_30, Tick::from_seconds_f64(5.0));
+    let cid = p.add_item("C", Label::Sandstone, None, ItemKind::Comp(comp.clone().into()));
+    let red = solid(&mut p, &comp, [1.0, 0.0, 0.0], 1920, 1080);
+    let mut adj = solid(&mut p, &comp, [1.0; 3], 1920, 1080);
+    adj.switches.adjustment = true;
+    let spec = effectcraft_effects::find("ec.generate.gradientramp").unwrap();
+    let mut next = p.next_id;
+    let ramp = effectcraft_effects::instantiate(spec, &mut Ids(&mut next), spec.name, [1920.0, 1080.0]);
+    p.next_id = next;
+    adj.props.sub_mut("effects").unwrap().children.push(ramp.into());
+    if with_mask {
+        add_mask(&mut p, &mut adj, ShapePath::rect([960.0, 1250.0], 1920.0, 200.0), [1000.0, 1000.0], false);
+    }
+    let c = p.comp_mut(cid).unwrap();
+    c.layers.push(adj);
+    c.layers.push(red);
+    (p, cid)
+}
+
+fn rgb8(img: &effectcraft_raster::Image, x: i64, y: i64) -> [i32; 3] {
+    let px = img.get(x, y);
+    [0, 1, 2].map(|c| (px[c].clamp(0.0, 1.0) * 255.0).round() as i32)
+}
+
+#[test]
+fn case_398_a_feathered_mask_below_an_adjustment_layer_reaches_into_it() {
+    let t = Tick::from_seconds_f64(1.0);
+    let (p, cid) = case_398(true);
+    let img = render_frame(&p, cid, t, 1.0);
+    // The ramp alone (no mask): what the adjustment layer mixes in.
+    let (q, qid) = case_398(false);
+    let ramp = render_frame(&q, qid, t, 1.0);
+    // After Effects 2026, 8 bpc, the render of 398 at 1 s.
+    let ae = [
+        ((960, 0), [255, 0, 0]),
+        ((960, 300), [254, 0, 0]),
+        ((960, 540), [250, 5, 5]),
+        ((960, 800), [248, 20, 20]),
+        ((960, 1000), [252, 40, 40]),
+        ((960, 1079), [255, 47, 47]),
+        ((100, 1079), [255, 29, 29]),
+    ];
+    let mut report = Vec::new();
+    for ((x, y), want_ae) in ae {
+        let got = rgb8(&img, x, y);
+        // 1. The coverage is the mask's Smooth falloff (three 741 px boxes for feather 1000),
+        //    blurred from the mask edge outside the layer (on the coarse grid); the result is the
+        //    red mixed toward the ramp by it.
+        let c = span(x as f64 + 0.5, 0.0, 1920.0, 1000.0) * span(y as f64 + 0.5, 1150.0, 1350.0, 1000.0);
+        let r = ramp.get(x, y);
+        let want = [0, 1, 2].map(|k| {
+            let red = if k == 0 { 1.0 } else { 0.0 };
+            ((red + (r[k] as f64 - red) * c) * 255.0).round() as i32
+        });
+        for k in 0..3 {
+            assert!((got[k] - want[k]).abs() <= 2, "({x}, {y}): {got:?}, the box coverage {c:.4} gives {want:?}");
+        }
+        // 2. After Effects: within 2 levels per channel.
+        for k in 0..3 {
+            assert!((got[k] - want_ae[k]).abs() <= 2, "({x}, {y}): EffectCraft {got:?}, After Effects {want_ae:?}");
+        }
+        report.push(format!("({x},{y}) ec {got:?} ae {want_ae:?}"));
+    }
+    println!("398: {}", report.join("; "));
+    // The mask covers nothing of the layer itself, but its feather does: the top stays (nearly) red.
+    assert!(rgb8(&img, 960, 0)[0] >= 253 && rgb8(&img, 960, 0)[1] == 0);
+    assert!(rgb8(&img, 960, 1079)[1] > 25, "the feather reaches the bottom edge");
+}
+
+/// After Effects 2026 (sRGB, 32 bpc): a red 1920x1080 solid with a 1000x600 Add mask centred at
+/// [960, 540] (left edge at x 460), feather `f` on both axes; coverage along the row y 540 from
+/// x 160 to 760 in steps of 20 (8-bit values / 255).
+const AE_FEATHER_100: [(i64, f64); 11] =
+    [(360, 0.0), (380, 0.016), (400, 0.059), (420, 0.153), (440, 0.31), (460, 0.506), (480, 0.698), (500, 0.855), (520, 0.945), (540, 0.988), (560, 1.0)];
+const AE_FEATHER_300: [(i64, f64); 31] = [
+    (160, 0.0),
+    (180, 0.004),
+    (200, 0.008),
+    (220, 0.012),
+    (240, 0.024),
+    (260, 0.035),
+    (280, 0.055),
+    (300, 0.078),
+    (320, 0.11),
+    (340, 0.149),
+    (360, 0.192),
+    (380, 0.247),
+    (400, 0.306),
+    (420, 0.369),
+    (440, 0.435),
+    (460, 0.502),
+    (480, 0.569),
+    (500, 0.635),
+    (520, 0.698),
+    (540, 0.757),
+    (560, 0.808),
+    (580, 0.851),
+    (600, 0.89),
+    (620, 0.922),
+    (640, 0.945),
+    (660, 0.965),
+    (680, 0.976),
+    (700, 0.988),
+    (720, 0.992),
+    (740, 0.996),
+    (760, 1.0),
+];
+
+#[test]
+fn the_smooth_feather_falloff_matches_after_effects() {
+    for (f, ae) in [(100.0, &AE_FEATHER_100[..]), (300.0, &AE_FEATHER_300[..])] {
+        let mut p = Project::default();
+        p.settings.bit_depth = BitDepth::Bpc32;
+        let comp = Comp::new(1920, 1080, FrameRate::FPS_30, Tick::from_seconds_f64(1.0));
+        let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.clone().into()));
+        let mut l = solid(&mut p, &comp, [1.0, 0.0, 0.0], 1920, 1080);
+        add_mask(&mut p, &mut l, ShapePath::rect([960.0, 540.0], 1000.0, 600.0), [f, f], false);
+        p.comp_mut(cid).unwrap().layers.push(l);
+        let img = render_frame(&p, cid, Tick::ZERO, 1.0);
+        let mut worst = 0.0f64;
+        for &(x, want) in ae {
+            let got = img.get(x, 540)[3] as f64;
+            // Tolerance 2/255 on the 8-bit After Effects values.
+            assert!((got - want).abs() <= 2.0 / 255.0, "feather {f}, x {x}: {got:.4}, After Effects {want}");
+            worst = worst.max((got - want).abs());
+        }
+        // The corner is the product of its two edges (a separable blur): 0.25 for both feathers.
+        let corner = img.get(460, 240)[3] as f64;
+        assert!((corner - 0.251).abs() <= 2.0 / 255.0, "feather {f}: corner {corner}");
+        println!("feather {f}: largest deviation from After Effects {:.2}/255", worst * 255.0);
+    }
+}
diff --git a/crates/render/src/tests_motion_tile.rs b/crates/render/src/tests/motion_tile.rs
similarity index 97%
rename from crates/render/src/tests_motion_tile.rs
rename to crates/render/src/tests/motion_tile.rs
index 7d1645a02..28faca73c 100644
--- a/crates/render/src/tests_motion_tile.rs
+++ b/crates/render/src/tests/motion_tile.rs
@@ -58,7 +58,7 @@ fn adjustment_scene(out: f64, scale: f64) -> (Project, ItemId) {
     tile_then_scale(&mut p, &mut adj, out, scale);
     let mut layers = vec![adj];
     layers.extend(picture(&mut p, &comp));
-    p.comp_mut(cid).unwrap().layers = layers;
+    p.comp_mut(cid).unwrap().layers = layers.into();
     (p, cid)
 }
 
@@ -68,7 +68,7 @@ fn layer_scene(out: f64, scale: f64) -> (Project, ItemId) {
     let inner = Comp::new(W, H, FrameRate::FPS_30, Tick::from_seconds_f64(1.0));
     let iid = p.add_item("Picture", Label::Sandstone, None, ItemKind::Comp(inner.clone().into()));
     let layers = picture(&mut p, &inner);
-    p.comp_mut(iid).unwrap().layers = layers;
+    p.comp_mut(iid).unwrap().layers = layers.into();
     let mut pre = build::layer(&mut p, &comp, "Picture", LayerSource::Comp { item: iid }, (W, H), None);
     tile_then_scale(&mut p, &mut pre, out, scale);
     p.comp_mut(cid).unwrap().layers.push(pre);
@@ -151,7 +151,7 @@ fn adjustment_motion_tile_matches_the_after_effects_frames() {
             }
             adj.props.sub_mut("effects").unwrap().children.push(g.into());
         }
-        p.comp_mut(cid).unwrap().layers = vec![adj, red];
+        p.comp_mut(cid).unwrap().layers = vec![adj, red].into();
         // Quarter resolution: comp pixel (x, y) is output pixel (x / 4, y / 4).
         let img = render_frame(&p, cid, Tick::ZERO, 0.25);
         let at = |x: f64, y: f64| img.get((x / 4.0) as i64, (y / 4.0) as i64);
diff --git a/crates/render/src/tests_nested.rs b/crates/render/src/tests/nested.rs
similarity index 100%
rename from crates/render/src/tests_nested.rs
rename to crates/render/src/tests/nested.rs
diff --git a/crates/render/src/tests_paint.rs b/crates/render/src/tests/paint.rs
similarity index 100%
rename from crates/render/src/tests_paint.rs
rename to crates/render/src/tests/paint.rs
diff --git a/crates/render/src/tests_remap.rs b/crates/render/src/tests/remap.rs
similarity index 100%
rename from crates/render/src/tests_remap.rs
rename to crates/render/src/tests/remap.rs
diff --git a/crates/render/src/tests_roi.rs b/crates/render/src/tests/roi.rs
similarity index 98%
rename from crates/render/src/tests_roi.rs
rename to crates/render/src/tests/roi.rs
index 9182817cf..a9892d9c7 100644
--- a/crates/render/src/tests_roi.rs
+++ b/crates/render/src/tests/roi.rs
@@ -29,7 +29,7 @@ fn project(three_d: bool) -> (Project, effectcraft_project::ItemId) {
         }
         layers.push(l);
     }
-    p.comp_mut(cid).unwrap().layers = layers;
+    p.comp_mut(cid).unwrap().layers = layers.into();
     (p, cid)
 }
 
diff --git a/crates/render/src/tests_styles.rs b/crates/render/src/tests/styles.rs
similarity index 99%
rename from crates/render/src/tests_styles.rs
rename to crates/render/src/tests/styles.rs
index b59f009de..2450fcf64 100644
--- a/crates/render/src/tests_styles.rs
+++ b/crates/render/src/tests/styles.rs
@@ -44,7 +44,7 @@ fn scene(color: [f32; 3], bg: Option<[f32; 3]>, f: impl FnOnce(&mut Project, &Co
     if let Some(bg) = bg {
         layers.push(solid(&mut p, &comp, bg, 200, 100));
     }
-    p.comp_mut(cid).unwrap().layers = layers;
+    p.comp_mut(cid).unwrap().layers = layers.into();
     (p, cid)
 }
 
diff --git a/crates/render/src/tests_time.rs b/crates/render/src/tests/time.rs
similarity index 96%
rename from crates/render/src/tests_time.rs
rename to crates/render/src/tests/time.rs
index 8739140de..e9599f70b 100644
--- a/crates/render/src/tests_time.rs
+++ b/crates/render/src/tests/time.rs
@@ -134,7 +134,16 @@ fn input_keys_ignore_later_effects() {
     }
     let key = |p: &Project| {
         let comp = p.comp(cid).unwrap();
-        let ctx = crate::EvalCtx { project: p, comp_id: cid, comp, time: Tick::from_seconds_f64(0.5), expr: None, footage: None };
+        let ctx = crate::EvalCtx {
+            project: p,
+            comp_id: cid,
+            comp,
+            time: Tick::from_seconds_f64(0.5),
+            expr: None,
+            footage: None,
+            property_overrides: &[],
+            media_overrides: &[],
+        };
         let l = &comp.layers[0];
         (crate::cache::input_key(&ctx, l, 1.0, false, false, 1), crate::cache::input_key(&ctx, l, 1.0, false, false, 2))
     };
diff --git a/crates/render/src/text.rs b/crates/render/src/text.rs
index 496bc3a60..19c17d53f 100644
--- a/crates/render/src/text.rs
+++ b/crates/render/src/text.rs
@@ -42,7 +42,8 @@ pub struct CharXf {
     pub stroke_hsb: [f64; 3],
     pub stroke_opacity: f64,
     pub stroke_width: f64,
-    /// Tracking (1/1000 em) added before / after the character.
+    /// Tracking (pixels: an animator's Tracking Amount, as After Effects) added before / after
+    /// the character.
     pub track_before: f64,
     pub track_after: f64,
     /// Line Anchor (percent) and the selection weight it was set with.
@@ -287,11 +288,13 @@ pub fn char_transforms(ctx: &EvalCtx, layer: &Layer, text: &PropGroup, lay: &Tex
         let pos = get("position").map(|v| c3(v, 0.0));
         let anchor = get("anchor").map(|v| c3(v, 0.0));
         let scale = get("scale").map(|v| c3(v, 100.0));
-        let rot = get1("rotation");
-        let rx = get1("rotationX");
-        let ry = get1("rotationY");
-        let skew = get1("skew");
-        let skew_axis = get1("skewAxis");
+        let angles = CharacterAngles {
+            rotation: get1("rotation"),
+            rotation_x: get1("rotationX"),
+            rotation_y: get1("rotationY"),
+            skew: get1("skew"),
+            skew_axis: get1("skewAxis"),
+        };
         let op = get1("opacity");
         let fill = props.get("fillColor").map(|p| ctx.value(layer, p).as_color());
         let stroke = props.get("strokeColor").map(|p| ctx.value(layer, p).as_color());
@@ -338,21 +341,7 @@ pub fn char_transforms(ctx: &EvalCtx, layer: &Layer, text: &PropGroup, lay: &Tex
                     c.scale[d] *= 1.0 + (s[d] / 100.0 - 1.0) * k3[d];
                 }
             }
-            if let Some(r) = rot {
-                c.rotation += r * k;
-            }
-            if let Some(r) = rx {
-                c.rotation_x += r * k;
-            }
-            if let Some(r) = ry {
-                c.rotation_y += r * k;
-            }
-            if let Some(s) = skew {
-                c.skew += s * k;
-            }
-            if let Some(a) = skew_axis {
-                c.skew_axis = a;
-            }
+            angles.apply(c, k);
             if let Some(o) = op {
                 c.opacity *= 1.0 + (o / 100.0 - 1.0) * k;
             }
@@ -381,17 +370,7 @@ pub fn char_transforms(ctx: &EvalCtx, layer: &Layer, text: &PropGroup, lay: &Tex
             if let Some(w) = sw {
                 c.stroke_width += w * k;
             }
-            if let Some(t) = tracking {
-                let t = t * k;
-                match tracking_type {
-                    1 => c.track_before += t,
-                    2 => c.track_after += t,
-                    _ => {
-                        c.track_before += t * 0.5;
-                        c.track_after += t * 0.5;
-                    }
-                }
-            }
+            apply_tracking(c, tracking, tracking_type, k);
             if let Some(a) = line_anchor
                 && k.abs() >= c.line_anchor_k
             {
@@ -432,6 +411,50 @@ pub fn char_transforms(ctx: &EvalCtx, layer: &Layer, text: &PropGroup, lay: &Tex
     out
 }
 
+/// Optional animator orientation properties; an omitted property leaves the glyph unchanged.
+struct CharacterAngles {
+    rotation: Option<f64>,
+    rotation_x: Option<f64>,
+    rotation_y: Option<f64>,
+    skew: Option<f64>,
+    skew_axis: Option<f64>,
+}
+
+impl CharacterAngles {
+    fn apply(&self, c: &mut CharXf, k: f64) {
+        if let Some(r) = self.rotation {
+            c.rotation += r * k;
+        }
+        if let Some(r) = self.rotation_x {
+            c.rotation_x += r * k;
+        }
+        if let Some(r) = self.rotation_y {
+            c.rotation_y += r * k;
+        }
+        if let Some(s) = self.skew {
+            c.skew += s * k;
+        }
+        if let Some(a) = self.skew_axis {
+            c.skew_axis = a;
+        }
+    }
+}
+
+/// Distribute selected tracking before and/or after a glyph according to Tracking Type.
+fn apply_tracking(c: &mut CharXf, tracking: Option<f64>, tracking_type: u32, k: f64) {
+    if let Some(t) = tracking {
+        let t = t * k;
+        match tracking_type {
+            1 => c.track_before += t,
+            2 => c.track_after += t,
+            _ => {
+                c.track_before += t * 0.5;
+                c.track_after += t * 0.5;
+            }
+        }
+    }
+}
+
 /// Character Offset / Character Value substitution (None = unchanged).
 pub fn substitute(ch: char, x: &CharXf) -> Option<char> {
     if ch.is_whitespace() {
@@ -487,6 +510,7 @@ pub struct PlacedGlyph {
     pub fill: [f32; 4],
     pub stroke: [f32; 4],
     pub stroke_width: f64,
+    pub join: effectcraft_path::Join,
     /// Faux Bold (or synthetic bold for a family without a bold face): how far the outline grows
     /// on every side, in character space (0 when not bold).
     pub bold: f64,
@@ -672,10 +696,12 @@ pub fn text_geom(ctx: &EvalCtx, layer: &Layer) -> Option<TextGeom> {
         let (mut la, mut la_k) = (50.0 * f64::from(align_index(justify)), 0.0);
         for gi in li_start..li_end {
             let x = &xfs[gi];
-            let em = lay.styles.get(lay.glyphs[gi].run).map_or(doc.size, |s| s.size) / 1000.0;
-            pen += x.track_before * em;
+            // An animator's Tracking Amount is in pixels, whatever the font size (After Effects
+            // 2026: Amount 30 adds 30 px between selected characters at 80 px and at 40 px), unlike
+            // the Character panel's tracking in 1/1000 em.
+            pen += x.track_before;
             shift[gi] = pen;
-            pen += x.track_after * em + vadv[gi];
+            pen += x.track_after + vadv[gi];
             if x.line_anchor_k > la_k {
                 la = x.line_anchor;
                 la_k = x.line_anchor_k;
@@ -783,9 +809,12 @@ pub fn text_geom(ctx: &EvalCtx, layer: &Layer) -> Option<TextGeom> {
         };
         // Outline relative to the pivot.
         let local = kurbo::Affine::translate((o[0] - pivot[0], o[1] - pivot[1])) * outline;
-        let char_m = Mat4::rotate_z(x.rotation)
+        // Rx · Ry · Rz (Z turns first): the order After Effects gives a 3D layer's X / Y / Z
+        // Rotation too. #1876 moves layers to it with a helper, `Mat4::rotation_xyz`; once both
+        // land, this should call that helper (one convention, one place).
+        let char_m = Mat4::rotate_x(x.rotation_x)
             * Mat4::rotate_y(x.rotation_y)
-            * Mat4::rotate_x(x.rotation_x)
+            * Mat4::rotate_z(x.rotation)
             * Mat4::from_mat3_affine(&Mat3::skew_deg(-x.skew, x.skew_axis))
             * Mat4::scale(Vec3::from(x.scale) / 100.0)
             * Mat4::translate(-Vec3::from(x.anchor));
@@ -810,6 +839,7 @@ pub fn text_geom(ctx: &EvalCtx, layer: &Layer) -> Option<TextGeom> {
             fill,
             stroke,
             stroke_width: (base_stroke_w + x.stroke_width).max(0.0),
+            join: path_join(doc.line_join),
             bold: if g.synth_bold { FAUX_BOLD_RADIUS * g.size } else { 0.0 },
             apply_fill: st.apply_fill,
             char_index: g.char_index,
@@ -825,6 +855,15 @@ pub fn glyph_paths(ctx: &EvalCtx, layer: &Layer) -> Vec<(BezPath, CharXf)> {
     text_geom(ctx, layer).map(|t| t.glyphs.iter().map(|g| (g.path(), g.xf)).collect()).unwrap_or_default()
 }
 
+fn path_join(j: effectcraft_keyframe::LineJoin) -> effectcraft_path::Join {
+    use effectcraft_keyframe::LineJoin;
+    match j {
+        LineJoin::Miter => effectcraft_path::Join::Miter,
+        LineJoin::Round => effectcraft_path::Join::Round,
+        LineJoin::Bevel => effectcraft_path::Join::Bevel,
+    }
+}
+
 /// One paint pass of a glyph: fill (false) or stroke (true).
 type Pass = (usize, bool);
 
@@ -891,7 +930,7 @@ fn raster_pass(g: &PlacedGlyph, stroke: bool, paths: &[BezPath], m: &Mat3, rect:
         }
         outer
     } else if stroke {
-        let st = StrokeStyle { width: g.stroke_width, join: effectcraft_path::Join::Round, ..Default::default() };
+        let st = StrokeStyle { width: g.stroke_width, join: g.join, ..Default::default() };
         effectcraft_path::stroke_coverage(paths, &st, &mm, w, h)
     } else {
         grown_coverage(paths, &mm, w, h, bold)
diff --git a/crates/render/src/text/tests.rs b/crates/render/src/text/tests.rs
index ea89e37b0..503ea097c 100644
--- a/crates/render/src/text/tests.rs
+++ b/crates/render/src/text/tests.rs
@@ -220,9 +220,9 @@ fn tracking_line_anchor_and_character_offset() {
     animator(&mut p, &mut l, &["tracking", "lineAnchor"], &["range"]);
     p.comp_mut(cid).unwrap().layers.push(l);
     let w0 = bounds_of(&glyph_paths(&ctx(&p, cid, 0.0), &p.comp(cid).unwrap().layers[0]));
-    set(&mut p.comp_mut(cid).unwrap().layers[0], "text/animators/#1/properties/tracking", Value::Scalar(500.0));
+    set(&mut p.comp_mut(cid).unwrap().layers[0], "text/animators/#1/properties/tracking", Value::Scalar(20.0));
     let w1 = bounds_of(&glyph_paths(&ctx(&p, cid, 0.0), &p.comp(cid).unwrap().layers[0]));
-    // 4 chars × 500/1000 em × 40 px: the last glyph moves ~ 3.5 × 20 px further (before & after).
+    // Tracking Amount 20 (pixels, as After Effects): the last glyph moves ~ 3.5 × 20 px further (before & after).
     assert!((w1.width() - w0.width() - 3.0 * 20.0).abs() < 1.5, "{} {}", w0.width(), w1.width());
     assert!((w1.x0 - w0.x0 - 10.0).abs() < 1.0, "first char shifts by half its tracking: {} {}", w0.x0, w1.x0);
     // Line Anchor 100%: tracking grows to the left.
@@ -262,10 +262,10 @@ fn tracking_grows_from_each_paragraphs_alignment() {
         p.comp_mut(cid).unwrap().layers.push(l);
         glyph_paths(&ctx(&p, cid, 0.0), &p.comp(cid).unwrap().layers[0])
     };
-    // 4 chars × 500/1000 em × 40 px: 20 px of tracking each, half before and half after.
+    // Tracking Amount 20 (pixels): 20 px of tracking each, half before and half after.
     for (justify, x0, centre, x1) in [(Justify::Left, 10.0, 40.0, 70.0), (Justify::Center, -30.0, 0.0, 30.0), (Justify::Right, -70.0, -40.0, -10.0)] {
         let d = TextDoc { justify, ..doc("ABCD", 40.0) };
-        let (w0, w1) = (bounds_of(&tracked(d.clone(), 0.0)), bounds_of(&tracked(d, 500.0)));
+        let (w0, w1) = (bounds_of(&tracked(d.clone(), 0.0)), bounds_of(&tracked(d, 20.0)));
         let got = [w1.x0 - w0.x0, w1.center().x - w0.center().x, w1.x1 - w0.x1];
         assert!(got.iter().zip([x0, centre, x1]).all(|(g, w)| (g - w).abs() < 1.0), "{justify:?}: moved {got:?}, want {:?}", [x0, centre, x1]);
     }
@@ -277,11 +277,36 @@ fn tracking_grows_from_each_paragraphs_alignment() {
         let (a, b): (Vec<_>, Vec<_>) = paths.into_iter().partition(|g| bounds_of(std::slice::from_ref(g)).center().y < 10.0);
         [bounds_of(&a), bounds_of(&b)]
     };
-    let ([a0, b0], [a1, b1]) = (lines(tracked(d.clone(), 0.0)), lines(tracked(d, 500.0)));
+    let ([a0, b0], [a1, b1]) = (lines(tracked(d.clone(), 0.0)), lines(tracked(d, 20.0)));
     assert!((a1.x0 - a0.x0 - 10.0).abs() < 1.0, "the left paragraph grows right: {} {}", a0.x0, a1.x0);
     assert!((b1.x1 - b0.x1 + 10.0).abs() < 1.0, "the right paragraph grows left: {} {}", b0.x1, b1.x1);
 }
 
+/// #1798: After Effects adds Tracking Amount in absolute pixels between neighbouring characters,
+/// independent of font size.
+#[test]
+fn text_animator_tracking_amount_uses_pixels_independent_of_font_size() {
+    let width_diff = |font_size: f64, amount: f64| {
+        let (mut p, cid, comp) = setup(2000, 400);
+        let mut l = text_layer(&mut p, &comp, doc("ABCDE", font_size));
+        animator(&mut p, &mut l, &["tracking"], &["range"]);
+        set(&mut l, "text/animators/#1/properties/tracking", Value::Scalar(amount));
+        p.comp_mut(cid).unwrap().layers.push(l);
+        let w = bounds_of(&glyph_paths(&ctx(&p, cid, 0.0), &p.comp(cid).unwrap().layers[0])).width();
+        let (mut p0, cid0, comp0) = setup(2000, 400);
+        let l0 = text_layer(&mut p0, &comp0, doc("ABCDE", font_size));
+        p0.comp_mut(cid0).unwrap().layers.push(l0);
+        let w0 = bounds_of(&glyph_paths(&ctx(&p0, cid0, 0.0), &p0.comp(cid0).unwrap().layers[0])).width();
+        w - w0
+    };
+    // 5 characters = 4 gaps. In After Effects, Tracking Amount 100 adds 100 px per gap = 400 px total width delta,
+    // regardless of whether font size is 50 px or 200 px.
+    let diff_50 = width_diff(50.0, 100.0);
+    let diff_200 = width_diff(200.0, 100.0);
+    assert!((diff_50 - 400.0).abs() < 1.0, "font_size 50 px width delta: {diff_50}");
+    assert!((diff_200 - 400.0).abs() < 1.0, "font_size 200 px width delta: {diff_200}");
+}
+
 #[test]
 fn anchor_grouping_line_rotates_around_line_centre() {
     let (mut p, cid, comp) = setup(600, 300);
@@ -479,6 +504,37 @@ fn per_character_3d_projects_characters() {
     assert!(b[2] - b[0] < flat[2] - flat[0] && b[2] > b[0] + 10, "{b:?} {flat:?}");
 }
 
+/// After Effects 2026 (case 931: "H", 400 px, per-character 3D, X / Y / Z Rotation 40 / 30 /
+/// 20): a character turns like a 3D layer, Rx · Ry · Rz (Z first), so its matrix is the same
+/// product as a layer's X / Y / Z Rotation. The render then matches AE (3 of 5184 grid points
+/// off at edges; with Rz · Ry · Rx 23).
+#[test]
+fn per_character_rotation_turns_z_first_as_a_3d_layer() {
+    let (mut p, cid, comp) = setup(400, 300);
+    let mut l = text_layer(&mut p, &comp, doc("H", 80.0));
+    l.switches.three_d = true;
+    animator(&mut p, &mut l, &["rotation"], &["range"]);
+    let mut next = p.next_id;
+    let mut extra = build::text_anim_props(&mut Ids(&mut next), "rotation", true);
+    p.next_id = next;
+    let props: &mut PropGroup = l.props.group_mut("text/animators/#1/properties").unwrap();
+    props.children.retain(|c| c.match_id() != "rotation");
+    props.children.extend(extra.drain(..).map(Into::into));
+    for (id, v) in [("rotationX", 40.0), ("rotationY", 30.0), ("rotation", 20.0)] {
+        props.get_mut(id).unwrap().value = Value::Scalar(v);
+    }
+    l.props.sub_mut("text").unwrap().get_mut("perChar3d").unwrap().value = Value::Bool(true);
+    p.comp_mut(cid).unwrap().layers.push(l);
+    let geom = text_geom(&ctx(&p, cid, 0.0), &p.comp(cid).unwrap().layers[0]).unwrap();
+    let g = &geom.glyphs[0];
+    let want = Mat4::rotate_x(40.0) * Mat4::rotate_y(30.0) * Mat4::rotate_z(20.0);
+    for r in 0..3 {
+        for c in 0..3 {
+            assert!((g.m.0[r][c] - want.0[r][c]).abs() < 1e-9, "row {r} col {c}: {:?} vs {:?}", g.m.0, want.0);
+        }
+    }
+}
+
 #[test]
 fn keyframed_selector_animates() {
     let (mut p, cid, comp) = setup(400, 200);
@@ -542,6 +598,7 @@ fn touching_glyphs_join_without_a_seam() {
             fill,
             stroke: [0.0; 4],
             stroke_width: 0.0,
+            join: effectcraft_path::Join::Miter,
             bold: 0.0,
             apply_fill: true,
             char_index: 0,
@@ -612,6 +669,7 @@ fn faux_bold_under_a_non_uniform_scale() {
         fill: [1.0; 4],
         stroke: [0.0; 4],
         stroke_width: 0.0,
+        join: effectcraft_path::Join::Miter,
         bold: 2.0,
         apply_fill: true,
         char_index: 0,
diff --git a/crates/render/src/three_d/mod.rs b/crates/render/src/three_d.rs
similarity index 93%
rename from crates/render/src/three_d/mod.rs
rename to crates/render/src/three_d.rs
index bccfc3e05..f2cc1c70a 100644
--- a/crates/render/src/three_d/mod.rs
+++ b/crates/render/src/three_d.rs
@@ -2,7 +2,7 @@
 //! compositor for runs of 3D layers.
 //!
 //! The 2D compositor (`Renderer::comp_frame`) walks the layer stack bottom-to-top; each run of
-//! consecutive 3D layers is handed to [`compose::draw_run`] as a group (2D layers break 3D
+//! consecutive 3D layers is handed to `compose::draw_run` as a group (2D layers break 3D
 //! groups, as in After Effects).
 
 pub mod adv;
diff --git a/crates/render/src/three_d/adv/mod.rs b/crates/render/src/three_d/adv.rs
similarity index 100%
rename from crates/render/src/three_d/adv/mod.rs
rename to crates/render/src/three_d/adv.rs
diff --git a/crates/render/src/three_d/adv/raster.rs b/crates/render/src/three_d/adv/raster.rs
index 395057935..1c37a6267 100644
--- a/crates/render/src/three_d/adv/raster.rs
+++ b/crates/render/src/three_d/adv/raster.rs
@@ -13,7 +13,7 @@ use std::collections::BinaryHeap;
 
 use rayon::prelude::*;
 
-use super::scene::{Scene, ShadowMap, Vertex};
+use super::scene::{EnvInfo, Scene, ShadowMap, Vertex};
 use super::shade::{Frag, sample, shade};
 
 /// A rendered target at raster size.
@@ -500,11 +500,39 @@ pub(crate) fn shadow_sizes(width: u32, height: u32, draft: bool, kinds: &[u32])
     sizes.into_iter().map(|z| (z > 0).then_some(z)).collect()
 }
 
-/// Build the shadow maps of every shadow-casting light (lights marked `shadow == 0`).
+/// The Environment light's shadow map: one orthographic map over the scene's bounding sphere
+/// from its dominant direction (the light travels from the bright region into the scene), like
+/// a parallel light's.
+fn env_shadow_map(e: EnvInfo, centre: [f64; 3], radius: f64, size: u32) -> ShadowMap {
+    // After Effects' environment-light shadows are soft out of the box, and this
+    // map covers the whole scene bounding sphere — not the view — so its texels
+    // can be coarse (all the more in a draft render's flat 512 budget). A
+    // penumbra of at least eight output pixels, or four map texels where those
+    // are coarser, keeps the edge smooth at any map resolution; Shadow Diffusion
+    // widens it further, as for the other lights.
+    let texel = 2.0 * radius / size as f64;
+    let soft = (4.0 * texel).max(8.0) + (e.shadow_diffusion as f64 * 0.5).min(24.0);
+    let sun = e.sun.map(|v| v as f64);
+    let dir = [-sun[0], -sun[1], -sun[2]];
+    let eye = [centre[0] + sun[0] * radius * 2.0, centre[1] + sun[1] * radius * 2.0, centre[2] + sun[2] * radius * 2.0];
+    let hint = if dir[1].abs() < 0.9 { [0.0, 1.0, 0.0] } else { [0.0, 0.0, 1.0] };
+    let focal = (size as f64 * 0.5 / radius) as f32;
+    ShadowMap { view: basis(eye, dir, hint), focal, ortho: true, size, offset: 0, bias: 1.5, radius: soft as f32 }
+}
+
+/// Build the shadow maps of every shadow-casting light (lights marked `shadow == 0`), and of
+/// the Environment light when it casts shadows and its image has a dominant direction (marked
+/// `env.shadow == 0`, `env.sun != [0; 3]`): one map from that direction, like a parallel light.
 pub(crate) fn shadow_maps(s: &mut Scene, draft: bool) {
     let casters: Vec<usize> = (0..s.indices.len() / 3)
         .filter(|&t| s.materials.get(s.vertices[s.indices[3 * t] as usize].material as usize).is_some_and(|m| m.casts_shadows))
         .collect();
+    // The Environment light casts a shadow when marked and its image has a dominant direction;
+    // with nothing to cast one, its mark is cleared either way.
+    let env_shadow = !casters.is_empty() && s.env.is_some_and(|e| e.shadow == 0 && e.sun != [0.0; 3]);
+    if !env_shadow && let Some(e) = &mut s.env {
+        e.shadow = -1;
+    }
     if casters.is_empty() {
         for l in &mut s.lights {
             l.shadow = -1;
@@ -536,6 +564,8 @@ pub(crate) fn shadow_maps(s: &mut Scene, draft: bool) {
                 1
             }
         })
+        // The Environment light's map is a single orthographic one.
+        .chain(std::iter::once(if env_shadow { 1 } else { 0 }))
         .collect();
     let sizes = shadow_sizes(s.width, s.height, draft, &kinds);
     let mut maps: Vec<ShadowMap> = vec![];
@@ -583,6 +613,25 @@ pub(crate) fn shadow_maps(s: &mut Scene, draft: bool) {
         }
         s.lights[li].shadow = first;
     }
+    // The Environment light's shadow: one orthographic map over the scene from its dominant
+    // direction (the light travels from the bright region into the scene), after the lights'.
+    if env_shadow && let Some(e) = s.env {
+        match sizes.get(s.lights.len()).copied().flatten() {
+            Some(size) => {
+                let first = maps.len() as i32;
+                maps.push(env_shadow_map(e, centre, radius, size));
+                if let Some(e) = &mut s.env {
+                    e.shadow = first;
+                }
+            }
+            // The texel budget dropped it.
+            None => {
+                if let Some(e) = &mut s.env {
+                    e.shadow = -1;
+                }
+            }
+        }
+    }
     let texels: Vec<Vec<f32>> = maps.par_iter().map(|m| shadow_raster(s, m, &casters)).collect();
     for (m, t) in maps.iter_mut().zip(texels) {
         m.offset = s.shadow_texels.len() as u32;
diff --git a/crates/render/src/three_d/adv/scene.rs b/crates/render/src/three_d/adv/scene.rs
index a97272434..22507069e 100644
--- a/crates/render/src/three_d/adv/scene.rs
+++ b/crates/render/src/three_d/adv/scene.rs
@@ -18,7 +18,8 @@ use std::sync::Arc;
 use effectcraft_effects::Buf;
 use effectcraft_geom::{Mat4, Vec3, vec3};
 use effectcraft_model::{self as model, Primitive};
-use effectcraft_project::{ItemKind, Layer, LayerSource, LightKind, PrimitiveKind};
+use effectcraft_project::{ItemKind, Layer, LayerSource, LightKind, PrimitiveKind, Property};
+use effectcraft_time::Tick;
 
 use super::shade::srgb_to_linear;
 use crate::three_d::camera::{CameraState, NEAR};
@@ -172,6 +173,24 @@ pub struct EnvInfo {
     pub intensity: f32,
     /// Radians about the vertical axis.
     pub rotation: f32,
+    /// Unit direction from the scene towards the environment's dominant (radiance-weighted)
+    /// bright region — the direction its shadow is cast from, like a parallel light's
+    /// `to_light`. `[0; 3]` when the image is directionless (uniform, or opposing bright
+    /// regions that cancel) or the light casts no shadow (nothing reads it then): no shadow.
+    pub sun: [f32; 3],
+    /// The image's directional (key) fraction — `|Σ dir·radiance| / Σ radiance` over the
+    /// sphere, 0 for a uniform image and near 1 for a single bright spot. An Environment
+    /// light's shadow occludes only this much of its light: the key lobe is blocked where
+    /// the map says so, the remaining fill keeps shining, so the shadow stays partial the
+    /// way After Effects renders an area-light shadow (a broad environment like the default
+    /// studio shadows softly, a lone bright spot on black almost fully).
+    pub key: f32,
+    /// Shadow map index into [`Scene::shadows`]: 0 marked (assigned by `raster::shadow_maps`),
+    /// -1 casts no shadow. Gated by the light's Cast Shadows.
+    pub shadow: i32,
+    pub shadow_darkness: f32,
+    /// The light's Shadow Diffusion (the penumbra width the shadow map's PCF widens to).
+    pub shadow_diffusion: f32,
 }
 
 #[derive(Clone, Debug, Default)]
@@ -439,6 +458,25 @@ pub fn model_to_layer(unit_scale: f64) -> Mat4 {
     Mat4::scale(vec3(unit_scale, -unit_scale, -unit_scale))
 }
 
+/// Layer time the selected clip started at: the last key that changed the selection, so a clip
+/// keyed on later plays from its first frame. Before any change, the layer clock; likewise under
+/// an expression or an Essential Property override, as the keys don't say when those switch.
+fn clip_start(ctx: &EvalCtx, layer: &Layer, prop: &Property, lt: Tick) -> Tick {
+    if prop.has_expression() || ctx.property_overrides.iter().any(|o| o.layer == layer.id && o.prop == prop.uid) {
+        return Tick::ZERO;
+    }
+    let mut keys = prop.keys.iter().filter(|k| !k.muted && k.time <= lt);
+    let Some(first) = keys.next() else { return Tick::ZERO };
+    let (mut clip, mut start) = (first.value.as_enum(), Tick::ZERO);
+    for k in keys {
+        let v = k.value.as_enum();
+        if v != clip {
+            (clip, start) = (v, k.time);
+        }
+    }
+    start
+}
+
 fn model_layer(r: &Renderer, ctx: &EvalCtx, layer: &Layer, b: &mut Builder) {
     let lin = b.s.linear_io;
     let (opts, prim_mat) = model_options(ctx, layer, lin);
@@ -454,7 +492,9 @@ fn model_layer(r: &Renderer, ctx: &EvalCtx, layer: &Layer, b: &mut Builder) {
             let clip = geo.map_or(0, |g| ctx.e(layer, g, "animation")) as usize;
             let clip = clip.checked_sub(1).filter(|c| *c < m.animations.len());
             let speed = geo.map_or(100.0, |g| ctx.f(layer, g, "animationSpeed", 100.0)) / 100.0;
-            let mut t = layer.layer_time(ctx.time).seconds() * speed;
+            let lt = layer.layer_time(ctx.time);
+            let start = geo.and_then(|g| g.get("animation")).map_or(Tick::ZERO, |p| clip_start(ctx, layer, p, lt));
+            let mut t = (lt - start).seconds() * speed;
             if let Some(c) = clip {
                 let d = m.animations[c].duration();
                 let looping = geo.is_none_or(|g| ctx.b(layer, g, "loopAnimation"));
@@ -572,7 +612,7 @@ pub fn extruded_meshes(ctx: &EvalCtx, layer: &Layer, p: &model::extrude::Extrude
                         groups.push((vec![g.local.clone()], c, g.m, usize::from(!stroke_on_top), g.xf.surface_colors(c)));
                     }
                     if g.stroke_width > 0.0 && g.stroke[3] * op > 0.0 {
-                        let st = effectcraft_path::StrokeStyle { width: g.stroke_width, join: effectcraft_path::Join::Round, ..Default::default() };
+                        let st = effectcraft_path::StrokeStyle { width: g.stroke_width, join: g.join, ..Default::default() };
                         if let Some(region) = crate::shapes::stroke_region(std::slice::from_ref(&g.local), &st) {
                             let c = [g.stroke[0], g.stroke[1], g.stroke[2], g.stroke[3] * op];
                             groups.push((vec![region], c, g.m, usize::from(stroke_on_top), g.xf.surface_colors(c)));
@@ -670,9 +710,20 @@ fn card_layer(r: &Renderer, ctx: &EvalCtx, layer: &Layer, b: &mut Builder) {
     }
 }
 
-/// Evaluated lights: (scene lights, ambient sum, environment light (layer, intensity × colour,
-/// rotation)).
-fn lights(ctx: &EvalCtx, lin: bool) -> (Vec<Light>, [f32; 3], Option<(Option<u64>, [f32; 3], f32)>) {
+/// The evaluated Environment light: its image source, intensity × colour, rotation, and
+/// shadow settings (After Effects' Light Settings shows Cast Shadows for Environment lights).
+#[derive(Clone, Copy)]
+pub(crate) struct EnvLight {
+    src: Option<u64>,
+    color: [f32; 3],
+    rot: f32,
+    casts_shadows: bool,
+    shadow_darkness: f64,
+    shadow_diffusion: f64,
+}
+
+/// Evaluated lights: (scene lights, ambient sum, environment light).
+fn lights(ctx: &EvalCtx, lin: bool) -> (Vec<Light>, [f32; 3], Option<EnvLight>) {
     let mut out = vec![];
     let mut ambient = [0.0f32; 3];
     let mut env = None;
@@ -693,7 +744,14 @@ fn lights(ctx: &EvalCtx, lin: bool) -> (Vec<Light>, [f32; 3], Option<(Option<u64
                 if env.is_none() {
                     let src = g.get("source").and_then(|p| ctx.value(layer, p).as_layer());
                     let rot = ctx.f(layer, g, "rotation", 0.0).to_radians() as f32;
-                    env = Some((src, color, rot));
+                    env = Some(EnvLight {
+                        src,
+                        color,
+                        rot,
+                        casts_shadows: ctx.b(layer, g, "castsShadows"),
+                        shadow_darkness: ctx.f(layer, g, "shadowDarkness", 100.0).clamp(0.0, 100.0) / 100.0,
+                        shadow_diffusion: ctx.f(layer, g, "shadowDiffusion", 0.0).max(0.0),
+                    });
                 }
             }
             _ => {
@@ -783,8 +841,54 @@ pub fn irradiance_map(sw: u32, sh: u32, src: &[[f32; 4]], w: u32, h: u32) -> Vec
     out
 }
 
+/// The environment image's dominant direction and key strength: the mean texel direction
+/// weighted by the radiance the light actually emits — solid-angle weighted, rotation applied,
+/// each texel's channels scaled by `tint` (the light's colour, `[1; 3]` for a white one) — or
+/// `([0; 3], 0.0)` when that radiance is directionless (a uniform environment cancels to zero,
+/// and opposing bright regions that cancel leave no mean either — though a chromatic one need
+/// not stay directionless once tinted: a red light over equally bright red and blue opposite
+/// regions removes the blue pull and points at the red one). The mean of a single bright spot
+/// on black points straight at it; a gradient points somewhere between its ends. The returned
+/// key fraction is the mean vector's length over the radiance weight — how directional the
+/// image is, 0 (uniform) to ~1 (a lone spot) — and is the most of its light an Environment
+/// light's shadow can remove.
+pub(crate) fn dominant_direction(w: u32, h: u32, d: &[[f32; 4]], tint: [f32; 3], rot: f32) -> ([f32; 3], f32) {
+    use super::shade::equirect_dir;
+    let (mut x, mut y, mut z) = (0.0f32, 0.0f32, 0.0f32);
+    let mut weight = 0.0f32;
+    for (i, p) in d.iter().enumerate() {
+        let (tx, ty) = ((i % w as usize) as u32, (i / w as usize) as u32);
+        let (u, v) = ((tx as f32 + 0.5) / w as f32, (ty as f32 + 0.5) / h as f32);
+        // Tinted radiance × solid angle (∝ sin θ): the shadow must follow the light the
+        // environment emits, not the raw texels.
+        let lum = (p[0] * tint[0] + p[1] * tint[1] + p[2] * tint[2]) * (v * std::f32::consts::PI).sin();
+        let dir = equirect_dir(u, v, rot);
+        x += dir[0] * lum;
+        y += dir[1] * lum;
+        z += dir[2] * lum;
+        weight += lum.abs();
+    }
+    // Under 1 % directional, the image is uniform to the eye: no dominant region to shadow
+    // from. A non-finite sum (a NaN or infinite texel) is garbage, not a direction: none then.
+    let len = (x * x + y * y + z * z).sqrt();
+    if !weight.is_finite() || !len.is_finite() || weight <= 1e-9 || len < weight * 0.01 {
+        return ([0.0; 3], 0.0);
+    }
+    ([x / len, y / len, z / len], (len / weight).clamp(0.0, 1.0))
+}
+
 /// Prefilter an environment image into the scene's textures.
-pub(crate) fn add_environment(b: &mut Builder, w: u32, h: u32, data: Vec<[f32; 4]>, intensity: [f32; 3], rotation: f32) {
+pub(crate) fn add_environment(b: &mut Builder, env: &EnvLight, w: u32, h: u32, data: Vec<[f32; 4]>) {
+    // Intensity × colour folded into the radiance (one scalar on the GPU): tint the texels.
+    // A white (or off) light leaves them as they are.
+    let k = (env.color[0] + env.color[1] + env.color[2]) / 3.0;
+    let tint = if k > 0.0 && (env.color[0] != env.color[1] || env.color[1] != env.color[2]) { env.color.map(|c| c / k) } else { [1.0, 1.0, 1.0] };
+    // The shadow direction and key strength from the full-resolution image, before the mip
+    // chain averages it — only a shadow-casting light reads them, so only one pays for the
+    // pass — and weighted by the tint, so the shadow follows the radiance the light emits:
+    // opposing chromatic regions that cancel untinted need not cancel once the colour removes
+    // one of them (a red light over equally bright red and blue sides shadows from the red).
+    let (sun, key) = if env.casts_shadows { dominant_direction(w, h, &data, tint, env.rot) } else { ([0.0; 3], 0.0) };
     // Radiance level 0 at most 1024 wide.
     let (mut w, mut h, mut d) = (w, h, data);
     while w > 1024 {
@@ -807,10 +911,7 @@ pub(crate) fn add_environment(b: &mut Builder, w: u32, h: u32, data: Vec<[f32; 4
     let (sw, sh, sd) = small.unwrap_or((w, h, d));
     let irr = irradiance_map(sw, sh, &sd, 32, 16);
     let ii = b.texture_from(32, 16, [0, 1], irr.into_iter()) as u32;
-    // Intensity × colour folded into the radiance (one scalar on the GPU): tint the texels.
-    let k = (intensity[0] + intensity[1] + intensity[2]) / 3.0;
-    if k > 0.0 && (intensity[0] != intensity[1] || intensity[1] != intensity[2]) {
-        let tint = intensity.map(|c| c / k);
+    if tint != [1.0, 1.0, 1.0] {
         for t in first..=ii {
             let ti = b.s.textures[t as usize];
             for p in &mut b.s.texels[ti.offset as usize..(ti.offset + ti.width * ti.height) as usize] {
@@ -820,16 +921,45 @@ pub(crate) fn add_environment(b: &mut Builder, w: u32, h: u32, data: Vec<[f32; 4
             }
         }
     }
-    b.s.env = Some(EnvInfo { radiance: first, mips: levels, irradiance: ii, intensity: k, rotation });
+    b.s.env = Some(EnvInfo {
+        radiance: first,
+        mips: levels,
+        irradiance: ii,
+        intensity: k,
+        rotation: env.rot,
+        sun,
+        key,
+        // Marked; `raster::shadow_maps` assigns the map (a directionless image casts none).
+        shadow: if env.casts_shadows { 0 } else { -1 },
+        shadow_darkness: env.shadow_darkness as f32,
+        shadow_diffusion: env.shadow_diffusion as f32,
+    });
 }
 
-/// The environment layer's pixels as linear straight RGBA.
-fn env_pixels(r: &Renderer, ctx: &EvalCtx, src: Option<u64>, lin: bool) -> Option<(u32, u32, Vec<[f32; 4]>)> {
+/// The Environment light's image: `Absent` when the light has no Source and the comp has no
+/// Environment Layer (the default studio environment applies — After Effects "uses a default
+/// environment map" for an Environment light too), `Image` when the source renders, `Failed`
+/// when a selected or found source produced no pixels (a deleted layer, missing footage, a
+/// failed decode). A failed source must not silently become the default environment — that
+/// would relight and reshadow the scene behind the user's back — so, like any layer whose
+/// source fails renders nothing, it contributes nothing (#2436).
+enum EnvPixels {
+    Absent,
+    Image((u32, u32, Vec<[f32; 4]>)),
+    Failed,
+}
+
+fn env_pixels(r: &Renderer, ctx: &EvalCtx, src: Option<u64>, lin: bool) -> EnvPixels {
     let layer = match src {
-        Some(id) => ctx.comp.layer(effectcraft_project::LayerId(id))?,
-        None => ctx.comp.layers.iter().find(|l| l.environment && l.is_active_at(ctx.time))?,
+        Some(id) => ctx.comp.layer(effectcraft_project::LayerId(id)),
+        None => ctx.comp.layers.iter().find(|l| l.environment && l.is_active_at(ctx.time)),
     };
-    let buf = r.blend_layer_buf(ctx, layer)?;
+    let Some(layer) = layer else {
+        // A set Source that resolves to no layer (deleted) failed; an unset one with no
+        // Environment Layer is simply unconfigured.
+        return if src.is_some() { EnvPixels::Failed } else { EnvPixels::Absent };
+    };
+    let Some(buf) = r.blend_layer_buf(ctx, layer) else { return EnvPixels::Failed };
     let img = &buf.img;
     let data = img
         .data
@@ -843,7 +973,43 @@ fn env_pixels(r: &Renderer, ctx: &EvalCtx, src: Option<u64>, lin: bool) -> Optio
             if lin { [s[0], s[1], s[2], 1.0] } else { [srgb_to_linear(s[0]), srgb_to_linear(s[1]), srgb_to_linear(s[2]), 1.0] }
         })
         .collect();
-    Some((img.width, img.height, data))
+    EnvPixels::Image((img.width, img.height, data))
+}
+
+/// The default environment when the light has no Source and no Environment Layer: a dim studio
+/// gradient, bright above and toward the initial camera, dark below and behind — After
+/// Effects "uses a default environment map" for an Environment light too, and its default
+/// casts shadows out of the box. The solid-angle-weighted mean is 0.3, a soft studio ambience
+/// (a mean of 1 would act like a 100 % white Ambient light and wash the whole scene out, which
+/// is not what After Effects' default looks like); the light's colour × intensity still scales
+/// the overall level, and its Rotation turns the key around the scene (#2436).
+pub(crate) fn default_environment() -> (u32, u32, Vec<[f32; 4]>) {
+    use super::shade::{dot, equirect_dir};
+    // The key region's centre: three quarters up, two thirds toward the viewer (the default
+    // camera looks +z from -z).
+    let key = [0.0f32, -0.75, -0.66];
+    let (w, h) = (8u32, 4u32);
+    let mut data = Vec::with_capacity((w * h) as usize);
+    let (mut mean, mut weight) = (0.0f32, 0.0f32);
+    for y in 0..h {
+        let v = (y as f32 + 0.5) / h as f32;
+        let sa = (v * std::f32::consts::PI).sin();
+        for x in 0..w {
+            let u = (x as f32 + 0.5) / w as f32;
+            let l = 0.15 + 1.2 * dot(equirect_dir(u, v, 0.0), key).max(0.0);
+            data.push([l, l, l, 1.0]);
+            mean += l * sa;
+            weight += sa;
+        }
+    }
+    // A dim studio: scale the gradient to a weighted mean of exactly 0.3.
+    let k = if mean.is_finite() && mean > 1e-6 { 0.3 * weight / mean } else { 1.0 };
+    for p in &mut data {
+        for c in 0..3 {
+            p[c] *= k;
+        }
+    }
+    (w, h, data)
 }
 
 /// Supersampling factor: 2×2 unless draft or very large.
@@ -857,8 +1023,8 @@ fn emit_layer<'a>(r: &Renderer<'a>, ctx: &EvalCtx<'a>, layer: &Layer, b: &mut Bu
     if layer.environment || layer.switches.adjustment || ctx.opacity(layer) <= 0.0 || !layer.has_video() {
         return;
     }
-    if let Some(item) = r.collapsed(ctx, layer) {
-        collapsed_layer(r, ctx, layer, item, b);
+    if let Some(collapsed) = r.collapsed(ctx, layer) {
+        collapsed_layer(r, ctx, layer, &collapsed, b);
     } else if layer.source.is_model() {
         model_layer(r, ctx, layer, b);
     } else if matches!(layer.source, LayerSource::Text | LayerSource::Shape)
@@ -874,9 +1040,9 @@ fn emit_layer<'a>(r: &Renderer<'a>, ctx: &EvalCtx<'a>, layer: &Layer, b: &mut Bu
 /// (meshes, extrusions, cards) placed by the precomp layer's world transform, so they
 /// intersect, occlude and shadow the parent's layers. Nested 2D layers lie on the precomp
 /// layer's plane; nested lights and cameras are ignored (the parent's light the scene).
-fn collapsed_layer<'a>(r: &Renderer<'a>, ctx: &EvalCtx<'a>, layer: &Layer, item: effectcraft_project::ItemId, b: &mut Builder) {
+fn collapsed_layer<'a>(r: &Renderer<'a>, ctx: &EvalCtx<'a>, layer: &Layer, collapsed: &crate::Collapsed, b: &mut Builder) {
     let op = ctx.opacity(layer) as f32 * r.opacity_mul();
-    let Some((sub, nctx)) = r.collapse_into(ctx, layer, item, op) else { return };
+    let Some((sub, nctx)) = r.collapse_into(ctx, layer, collapsed, op) else { return };
     let saved = b.outer;
     b.outer = saved * ctx.world_matrix(layer);
     let t = nctx.time;
@@ -935,10 +1101,23 @@ pub(crate) fn build_at(r: &Renderer, ctx: &EvalCtx, sub: Option<&EvalCtx>, run:
         let (ls, amb, env) = lights(ctx, lin);
         b.s.lights = ls;
         b.s.ambient = amb;
-        if let Some((src, k, rot)) = env
-            && let Some((w, h, d)) = env_pixels(r, ctx, src, lin)
-        {
-            add_environment(&mut b, w, h, d, k, rot);
+        if let Some(env) = env {
+            match env_pixels(r, ctx, env.src, lin) {
+                EnvPixels::Image((w, h, d)) => add_environment(&mut b, &env, w, h, d),
+                // No Source and no Environment Layer: the default environment, a soft studio
+                // gradient of the light's colour × intensity — After Effects "uses a default
+                // environment map" for an Environment light — so the light always lights the
+                // scene per its parameters, and its dominant region casts shadows (#2436).
+                EnvPixels::Absent => {
+                    let (w, h, d) = default_environment();
+                    add_environment(&mut b, &env, w, h, d)
+                }
+                // A selected or found source that produced no pixels (deleted layer, missing
+                // footage, failed decode): no environment at all — the light contributes
+                // nothing, exactly like a layer whose source failed renders nothing, never a
+                // silent swap to the default studio's lighting and shadows (#2436).
+                EnvPixels::Failed => {}
+            }
         }
         if r.opts.shadows() {
             super::raster::shadow_maps(&mut b.s, r.opts.draft);
@@ -947,6 +1126,9 @@ pub(crate) fn build_at(r: &Renderer, ctx: &EvalCtx, sub: Option<&EvalCtx>, run:
             for l in &mut b.s.lights {
                 l.shadow = -1;
             }
+            if let Some(e) = &mut b.s.env {
+                e.shadow = -1;
+            }
         }
     }
     // Camera matrices.
diff --git a/crates/render/src/three_d/adv/shade.rs b/crates/render/src/three_d/adv/shade.rs
index c7c1a40f1..820e8fecf 100644
--- a/crates/render/src/three_d/adv/shade.rs
+++ b/crates/render/src/three_d/adv/shade.rs
@@ -82,9 +82,20 @@ pub fn f_schlick(f0: [f32; 3], v_h: f32) -> [f32; 3] {
     [f0[0] + (1.0 - f0[0]) * k, f0[1] + (1.0 - f0[1]) * k, f0[2] + (1.0 - f0[2]) * k]
 }
 
+/// Surface parameters used by the direct-light BRDF after texture sampling.
+#[derive(Clone, Copy)]
+pub struct BrdfSurface {
+    pub base: [f32; 3],
+    pub metallic: f32,
+    pub roughness: f32,
+    pub specular: f32,
+    pub diffuse: f32,
+}
+
 /// Cook–Torrance BRDF × N·L × π for one light: (diffuse colour factor, specular colour).
 /// Returned as the reflected fraction of the light's irradiance.
-pub fn brdf(base: [f32; 3], metallic: f32, rough: f32, spec_k: f32, diff_k: f32, n: [f32; 3], v: [f32; 3], l: [f32; 3]) -> [f32; 3] {
+pub fn brdf(surface: BrdfSurface, n: [f32; 3], v: [f32; 3], l: [f32; 3]) -> [f32; 3] {
+    let BrdfSurface { base, metallic, roughness: rough, specular: spec_k, diffuse: diff_k } = surface;
     let n_l = dot(n, l);
     if n_l <= 0.0 {
         return [0.0; 3];
@@ -217,6 +228,25 @@ fn tap_hash(x: i32, y: i32) -> u32 {
     h
 }
 
+/// The jitter of tap (`i`, `j`), each axis in [−0.5, 0.5): [`tap_hash`] values at the four
+/// corners of the receiver's 1/8-texel lattice cell (`cx`, `cy`), blended bilinearly by the
+/// receiver's position in the cell (`wx`, `wy`). The jitter is continuous in the receiver's
+/// map position, so a position that differs between backends in its last bits moves the
+/// taps by an amount proportional to that difference and does not switch them to another
+/// cell's jitter.
+fn tap_jitter(cx: i32, cy: i32, wx: f32, wy: f32, i: i32, j: i32) -> (f32, f32) {
+    let corner = |dx: i32, dy: i32| -> (f32, f32) {
+        let h = tap_hash(cx.wrapping_add(dx).wrapping_add(i.wrapping_mul(7919)), cy.wrapping_add(dy).wrapping_add(j.wrapping_mul(7919)));
+        (((h & 0xFFFF) as f32) * (1.0 / 65536.0) - 0.5, (((h >> 16) & 0xFFFF) as f32) * (1.0 / 65536.0) - 0.5)
+    };
+    let (c00, c10, c01, c11) = (corner(0, 0), corner(1, 0), corner(0, 1), corner(1, 1));
+    let ax = c00.0 + (c10.0 - c00.0) * wx;
+    let bx = c01.0 + (c11.0 - c01.0) * wx;
+    let ay = c00.1 + (c10.1 - c00.1) * wx;
+    let by = c01.1 + (c11.1 - c01.1) * wx;
+    (ax + (bx - ax) * wy, ay + (by - ay) * wy)
+}
+
 /// Upper bound of the PCF grid's taps per axis. The grid grows with the reach so taps
 /// stay about one texel apart for moderate penumbrae; the cap bounds the per-fragment
 /// cost of very wide ones (bilinear taps still overlap and the jitter dithers the rest).
@@ -230,10 +260,11 @@ const PLANE_SLOPE_MAX: f32 = 64.0;
 /// Fraction of light reaching `p` through shadow map `m` (1 = lit). `ng` is the
 /// receiver's geometric (not normal-mapped) normal facing the viewer.
 ///
-/// PCF over an N×N tap grid (5 ≤ N ≤ [`PCF_MAX_TAPS`]) spread over a reach derived
+/// PCF over an N×N tap grid (5 ≤ N ≤ `PCF_MAX_TAPS`) spread over a reach derived
 /// from `radius` (the wanted penumbra in output pixels) divided by the receiver's
-/// texel footprint, each tap jittered by an integer hash of the receiver's
-/// sub-texel cell and the tap index, and each tap comparing against the four
+/// texel footprint, each tap jittered by [`tap_jitter`] (an integer hash of the
+/// receiver's sub-texel lattice and the tap index, blended across the receiver's
+/// lattice cell), and each tap comparing against the four
 /// nearest texel centres with bilinear weights. The jitter detaches the tap grid
 /// from the texel axes (axis-aligned binary taps are what stair-step a straight
 /// shadow edge), and keying it below texel size keeps the dither finer than an
@@ -301,13 +332,13 @@ pub fn shadow_factor(m: &ShadowMap, texels: &[f32], p: [f32; 3], ng: [f32; 3], n
     let n = (reach.ceil() as i32 + 1).clamp(5, PCF_MAX_TAPS);
     let step = reach / (n - 1) as f32;
     let half = (n - 1) as f32 * 0.5;
-    let (cx, cy) = ((u * 8.0).floor() as i32, (v * 8.0).floor() as i32);
+    let (gu, gv) = (u * 8.0, v * 8.0);
+    let (cx, cy) = (gu.floor() as i32, gv.floor() as i32);
+    let (wx, wy) = (gu - gu.floor(), gv - gv.floor());
     let mut lit = 0.0;
     for j in 0..n {
         for i in 0..n {
-            let h = tap_hash(cx.wrapping_add(i.wrapping_mul(7919)), cy.wrapping_add(j.wrapping_mul(7919)));
-            let jx = ((h & 0xFFFF) as f32) * (1.0 / 65536.0) - 0.5;
-            let jy = (((h >> 16) & 0xFFFF) as f32) * (1.0 / 65536.0) - 0.5;
+            let (jx, jy) = tap_jitter(cx, cy, wx, wy, i, j);
             let (su, sv) = (u + ((i as f32 - half) + jx) * step, v + ((j as f32 - half) + jy) * step);
             // Texel (x, y) holds the depth at its centre (x + 0.5, y + 0.5); each of the
             // four is compared against the receiver plane at that centre.
@@ -351,6 +382,23 @@ pub fn light_shadow(s: &Scene, l: &Light, p: [f32; 3], ng: [f32; 3], n_l: f32) -
     1.0 - l.shadow_darkness * (1.0 - f)
 }
 
+/// The visibility of the Environment light at `p` (1 = unshadowed), darkened by its Shadow
+/// Darkness — but only by the image's key fraction: the shadow map occludes the dominant
+/// (key) lobe, while the environment's fill keeps shining on the shadowed surface, so an
+/// Environment light's shadow stays partial the way After Effects renders an area-light
+/// shadow (a broad environment like the default studio shadows softly, a lone bright spot
+/// on black almost fully). A directionless image (or a non-casting light) has no map
+/// and shades unshadowed.
+pub fn env_shadow(s: &Scene, e: &EnvInfo, p: [f32; 3], ng: [f32; 3], n: [f32; 3]) -> f32 {
+    if e.shadow < 0 || e.sun == [0.0; 3] {
+        return 1.0;
+    }
+    let Some(m) = s.shadows.get(e.shadow as usize) else { return 1.0 };
+    let n_l = dot(n, e.sun).clamp(0.0, 1.0);
+    let f = shadow_factor(m, &s.shadow_texels, p, ng, n_l);
+    1.0 - e.shadow_darkness * e.key * (1.0 - f)
+}
+
 /// Unit direction from `p` to light `l`, and the distance (infinite for a parallel light).
 fn to_light(l: &Light, p: [f32; 3]) -> ([f32; 3], f32) {
     if l.kind == 0 {
@@ -484,7 +532,7 @@ pub fn shade(s: &Scene, f: &Frag) -> Option<[f32; 4]> {
             continue;
         }
         let sh = if m.receives_shadows { light_shadow(s, l, f.pos, ng, n_l) } else { 1.0 };
-        let b = brdf(rgb, metallic, rough, m.specular_k, m.diffuse_k, n, v, to_l);
+        let b = brdf(BrdfSurface { base: rgb, metallic, roughness: rough, specular: m.specular_k, diffuse: m.diffuse_k }, n, v, to_l);
         for c in 0..3 {
             out[c] += b[c] * l.color[c] * k * sh;
         }
@@ -498,9 +546,11 @@ pub fn shade(s: &Scene, f: &Frag) -> Option<[f32; 4]> {
         let (irr, spec) = env_light(s, e, n, r, rough);
         let f0 = [mix(0.04 * m.specular_k, rgb[0], metallic), mix(0.04 * m.specular_k, rgb[1], metallic), mix(0.04 * m.specular_k, rgb[2], metallic)];
         let (a, b) = env_brdf(n_v, rough);
+        // The Environment light's shadow darkens its own diffuse and specular.
+        let sh = if m.receives_shadows { env_shadow(s, e, f.pos, ng, n) } else { 1.0 };
         for c in 0..3 {
             let fs = f0[c] * a + b;
-            out[c] += (irr[c] * rgb[c] * (1.0 - fs) * (1.0 - metallic) * m.diffuse_k + spec[c] * fs) * ao;
+            out[c] += (irr[c] * rgb[c] * (1.0 - fs) * (1.0 - metallic) * m.diffuse_k + spec[c] * fs) * ao * sh;
         }
     }
     let c = add(out, emissive);
@@ -526,5 +576,9 @@ fn shadow_only(s: &Scene, m: &Material, f: &Frag, alpha: f32) -> [f32; 4] {
         }
         amount = amount.max(1.0 - light_shadow(s, l, f.pos, n, n_l));
     }
+    // The Environment light's shadow counts too (it reaches every surface: no falloff).
+    if let Some(e) = &s.env {
+        amount = amount.max(1.0 - env_shadow(s, e, f.pos, n, n));
+    }
     [0.0, 0.0, 0.0, alpha * amount]
 }
diff --git a/crates/render/src/three_d/adv/tests.rs b/crates/render/src/three_d/adv/tests.rs
index 3f5ee4813..b2612de98 100644
--- a/crates/render/src/three_d/adv/tests.rs
+++ b/crates/render/src/three_d/adv/tests.rs
@@ -2,7 +2,7 @@ use effectcraft_keyframe::Value;
 use effectcraft_project::{Comp, ItemId, ItemKind, LayerSource, LightKind, PrimitiveKind, Project, Renderer as R3, build};
 use effectcraft_time::{FrameRate, Tick};
 
-use super::scene::{Material, Scene, TexInfo, Vertex, irradiance_map};
+use super::scene::{Material, Scene, TexInfo, Vertex, dominant_direction, irradiance_map};
 use super::shade::{self, PI};
 use super::*;
 use crate::{NoFootage, RenderOpts, Renderer};
@@ -16,7 +16,7 @@ fn brdf_matches_cook_torrance_formula() {
     let v = shade::norm([0.3, 0.1, 1.0]);
     let l = shade::norm([-0.4, 0.2, 1.0]);
     let (base, metal, rough) = ([0.8, 0.4, 0.2], 0.3f32, 0.45f32);
-    let got = shade::brdf(base, metal, rough, 1.0, 1.0, n, v, l);
+    let got = shade::brdf(shade::BrdfSurface { base, metallic: metal, roughness: rough, specular: 1.0, diffuse: 1.0 }, n, v, l);
     let h = shade::norm([v[0] + l[0], v[1] + l[1], v[2] + l[2]]);
     let (nv, nl, nh, vh) = (shade::dot(n, v), shade::dot(n, l), shade::dot(n, h), shade::dot(v, h));
     let a2 = (rough * rough).powi(2);
@@ -30,9 +30,9 @@ fn brdf_matches_cook_torrance_formula() {
         assert!((got[c] - expect).abs() < 1e-5, "channel {c}: {} vs {expect}", got[c]);
     }
     // No light from behind the surface.
-    assert_eq!(shade::brdf(base, metal, rough, 1.0, 1.0, n, v, [0.0, 0.0, -1.0]), [0.0; 3]);
+    assert_eq!(shade::brdf(shade::BrdfSurface { base, metallic: metal, roughness: rough, specular: 1.0, diffuse: 1.0 }, n, v, [0.0, 0.0, -1.0]), [0.0; 3]);
     // A white rough dielectric lit head-on reflects about its base colour (π folded in).
-    let w = shade::brdf([1.0; 3], 0.0, 1.0, 1.0, 1.0, n, n, n);
+    let w = shade::brdf(shade::BrdfSurface { base: [1.0; 3], metallic: 0.0, roughness: 1.0, specular: 1.0, diffuse: 1.0 }, n, n, n);
     assert!(w[0] > 0.95 && w[0] < 1.05, "{w:?}");
 }
 
@@ -67,6 +67,90 @@ fn constant_environment_has_constant_irradiance() {
     assert!(irr[16][0] > 0.9 && irr[15 * 32 + 16][0] < 0.1, "{:?} {:?}", irr[16], irr[15 * 32 + 16]);
 }
 
+/// A NaN or infinite texel poisons the sums (every NaN comparison is false, so the thresholds
+/// alone would pass it through as a NaN direction); an infinite one even where sin θ = 0 turns
+/// into NaN. Either way the sum is garbage, not a direction: no sun and no key, so no shadow
+/// (#2436).
+#[test]
+fn a_non_finite_environment_has_no_sun_direction() {
+    let nan = vec![[f32::NAN; 4]; 8 * 4];
+    assert_eq!(dominant_direction(8, 4, &nan, [1.0; 3], 0.0), ([0.0; 3], 0.0));
+    let inf = vec![[f32::INFINITY, 0.0, 0.0, 1.0]; 8 * 4];
+    assert_eq!(dominant_direction(8, 4, &inf, [1.0; 3], 0.0), ([0.0; 3], 0.0));
+}
+
+/// The key fraction: a uniform image is directionless (key 0), a lone bright spot on black is
+/// almost fully directional, and a broad gradient sits in between — the soft studio default
+/// shadows visibly but keeps most of its light as fill (#2436).
+#[test]
+fn environment_key_strength_tracks_directionality() {
+    let uniform = vec![[0.5f32, 0.5, 0.5, 1.0]; 8 * 4];
+    assert_eq!(dominant_direction(8, 4, &uniform, [1.0; 3], 0.0).1, 0.0);
+    let mut spot = vec![[0.0f32; 4]; 64 * 32];
+    spot[16 * 64 + 32] = [1.0, 1.0, 1.0, 1.0];
+    let (_, key) = dominant_direction(64, 32, &spot, [1.0; 3], 0.0);
+    assert!(key > 0.95, "a lone spot is almost fully directional: {key}");
+    let (w, h, d) = scene::default_environment();
+    let (_, key) = dominant_direction(w, h, &d, [1.0; 3], 0.0);
+    assert!((0.35..0.55).contains(&key), "the default studio is a broad key with fill: {key}");
+}
+
+/// #2436 review: a non-uniform image can be directionless too — two equal bright spots at
+/// opposite azimuths pull the radiance-weighted mean in opposite directions and cancel,
+/// leaving no dominant region to shadow from (under 1 % directional): no sun, no key, so no
+/// shadow, just like a uniform image. Tilt the balance and a direction re-emerges, pointing
+/// at the brighter spot.
+#[test]
+fn opposing_bright_regions_cancel_to_no_shadow() {
+    let (w, h) = (64u32, 32u32);
+    let mut opposed = vec![[0.0f32; 4]; (w * h) as usize];
+    // Rows 15 and 16 mirror about the equator (v = 0.484375 / 0.515625), and columns 16 and 48
+    // sit half a width apart (u = 0.2578125 / 0.7578125): the two texel-centre directions are
+    // exactly opposite — equal solid-angle weight, opposite pull.
+    let (a, b) = ((15 * w + 16) as usize, (16 * w + 48) as usize);
+    opposed[a] = [1.0, 1.0, 1.0, 1.0];
+    opposed[b] = [1.0, 1.0, 1.0, 1.0];
+    assert_eq!(dominant_direction(w, h, &opposed, [1.0; 3], 0.0), ([0.0; 3], 0.0));
+    // One side twice as bright: the mean points at the brighter spot with its share of the
+    // weight (key = 1/3 — two parts against one).
+    let mut tilted = opposed.clone();
+    tilted[a] = [2.0, 2.0, 2.0, 1.0];
+    let (sun, key) = dominant_direction(w, h, &tilted, [1.0; 3], 0.0);
+    assert!(sun != [0.0; 3] && key > 0.3, "the brighter side wins: {sun:?} key {key}");
+    let want = shade::equirect_dir(16.5 / 64.0, 15.5 / 32.0, 0.0);
+    let dot = sun[0] * want[0] + sun[1] * want[1] + sun[2] * want[2];
+    assert!(dot > 0.999, "the sun points at the brighter spot: {sun:?} vs {want:?}");
+}
+
+/// #2436 review: the sun follows the tinted radiance, not the raw texels — equally bright red
+/// and blue regions on exactly opposite texels cancel to a white light (no shadow), but the
+/// red light's tint removes the blue side's pull, so the mean points straight at the red one
+/// (a blue light, at the blue one): the shadow lands where the emitted light comes from.
+#[test]
+fn a_coloured_light_shadows_from_the_region_it_tints() {
+    let (w, h) = (64u32, 32u32);
+    let mut opposed = vec![[0.0f32; 4]; (w * h) as usize];
+    // Rows 15 and 16 mirror about the equator, columns 16 and 48 half a width apart: the two
+    // texel-centre directions are exactly opposite — equal solid-angle weight, opposite pull.
+    let (a, b) = ((15 * w + 16) as usize, (16 * w + 48) as usize);
+    opposed[a] = [1.0, 0.0, 0.0, 1.0];
+    opposed[b] = [0.0, 0.0, 1.0, 1.0];
+    // To a white light the channel sums are equal: they cancel, no shadow.
+    assert_eq!(dominant_direction(w, h, &opposed, [1.0; 3], 0.0), ([0.0; 3], 0.0));
+    // A red light's tint zeroes the blue texel's weight: the red one becomes a lone spot.
+    // (Any positive scale of the tint — the normalised [3, 0, 0] included — points the same
+    // way; only the channel ratios matter.)
+    let (sun, key) = dominant_direction(w, h, &opposed, [1.0, 0.0, 0.0], 0.0);
+    let want = shade::equirect_dir(16.5 / 64.0, 15.5 / 32.0, 0.0);
+    let dot = sun[0] * want[0] + sun[1] * want[1] + sun[2] * want[2];
+    assert!(dot > 0.999 && key > 0.95, "the red side wins: {sun:?} key {key}");
+    // A blue light points at the blue one instead.
+    let (sun, _) = dominant_direction(w, h, &opposed, [0.0, 0.0, 1.0], 0.0);
+    let want = shade::equirect_dir(48.5 / 64.0, 16.5 / 32.0, 0.0);
+    let dot = sun[0] * want[0] + sun[1] * want[1] + sun[2] * want[2];
+    assert!(dot > 0.999, "the blue side wins: {sun:?}");
+}
+
 #[test]
 fn equirect_round_trip_and_env_brdf() {
     for (u, v) in [(0.1f32, 0.2f32), (0.5, 0.5), (0.9, 0.7)] {
@@ -337,6 +421,365 @@ fn cards_and_environment_light() {
     assert_eq!(lit.data[80 * 120 + 110][3], 0.0);
 }
 
+/// An Environment light with no Source and no Environment Layer lights the scene with a flat
+/// default environment of its colour × intensity — After Effects "uses a default environment
+/// map" for an Environment light — not nothing at all (#2436).
+#[test]
+fn environment_light_without_a_source_lights_the_scene() {
+    let (mut p, cid) = project(120, 90);
+    let sid = p.add_item(
+        "S",
+        Default::default(),
+        None,
+        ItemKind::Solid(effectcraft_project::Solid { color: [0.5, 0.5, 0.5], width: 60, height: 40, pixel_aspect: 1.0 }),
+    );
+    add(&mut p, cid, LayerSource::Solid { item: sid }, |l| l.switches.three_d = true);
+    let unlit = render(&p, cid);
+    let c = unlit.data[20 * 120 + 30];
+    assert!((c[0] - 0.5).abs() < 0.01 && c[3] > 0.99, "unlit card keeps its colour: {c:?}");
+    // No Source, no Environment Layer: the light still lights the card (a flat white
+    // environment at the light's colour × intensity; a card's Material Options shade it).
+    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |_| {});
+    let lit = render(&p, cid);
+    let c2 = lit.data[20 * 120 + 30];
+    assert!((c2[0] - c[0]).abs() > 0.05 && c2[3] > 0.99, "the light has an effect: {c2:?} vs {c:?}");
+    // The light's parameters drive it: half intensity darkens towards zero intensity's black.
+    set(p.comp_mut(cid).unwrap().layers.first_mut().unwrap(), "lightOptions/intensity", Value::Scalar(50.0));
+    let half = render(&p, cid);
+    let c3 = half.data[20 * 120 + 30];
+    assert!(c3[0] < c2[0] - 0.02, "half intensity lights less: {c3:?} vs {c2:?}");
+    set(p.comp_mut(cid).unwrap().layers.first_mut().unwrap(), "lightOptions/intensity", Value::Scalar(0.0));
+    let dark = render(&p, cid);
+    let c4 = dark.data[20 * 120 + 30];
+    assert!(c4[0] < 0.02 && c4[3] > 0.99, "zero intensity lights nothing: {c4:?}");
+    // And its colour tints the light red.
+    set(p.comp_mut(cid).unwrap().layers.first_mut().unwrap(), "lightOptions/intensity", Value::Scalar(100.0));
+    set(p.comp_mut(cid).unwrap().layers.first_mut().unwrap(), "lightOptions/color", Value::Color([1.0, 0.0, 0.0, 1.0]));
+    let red = render(&p, cid);
+    let c5 = red.data[20 * 120 + 30];
+    assert!(c5[0] > 0.15 && c5[1] < 0.05 && c5[2] < 0.05, "red environment: {c5:?}");
+}
+
+/// #2436 review: a selected or auto-picked environment source that fails to render (missing
+/// footage, a deleted layer) must not silently swap in the default studio environment — the
+/// light contributes nothing, exactly like a layer whose source failed renders nothing. Only a
+/// light with no Source at all (and no Environment Layer in the comp) uses the default.
+#[test]
+fn a_failed_environment_source_lights_nothing() {
+    let (mut p, cid) = project(120, 90);
+    let sid = p.add_item(
+        "S",
+        Default::default(),
+        None,
+        ItemKind::Solid(effectcraft_project::Solid { color: [1.0, 1.0, 1.0], width: 60, height: 40, pixel_aspect: 1.0 }),
+    );
+    add(&mut p, cid, LayerSource::Solid { item: sid }, |l| l.switches.three_d = true);
+    let unlit = render(&p, cid);
+    // The Environment Layer's footage is unreadable (missing; NoFootage serves no frames).
+    let fid = p.add_item(
+        "F",
+        Default::default(),
+        None,
+        ItemKind::Footage(effectcraft_project::Footage {
+            path: "missing.exr".into(),
+            kind: effectcraft_project::FootageKind::Still,
+            width: 64,
+            height: 32,
+            pixel_aspect: 1.0,
+            duration: Tick::from_seconds_f64(1.0),
+            has_video: true,
+            missing: true,
+            ..Default::default()
+        }),
+    );
+    add(&mut p, cid, LayerSource::Footage { item: fid }, |l| {
+        l.switches.three_d = true;
+        l.environment = true;
+    });
+    let env_layer = p.comp(cid).unwrap().layers.iter().find(|l| l.environment).unwrap().id;
+    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |l| {
+        set(l, "lightOptions/castsShadows", Value::Bool(true));
+    });
+    fn light(p: &mut Project, cid: ItemId) -> &mut effectcraft_project::Layer {
+        p.comp_mut(cid).unwrap().layers.iter_mut().find(|l| l.is_light()).unwrap()
+    }
+    // Auto-picked Environment Layer, unreadable: the light is off — no studio default, no
+    // default-environment shadow either.
+    let failed = render(&p, cid);
+    assert_eq!(failed.data, unlit.data, "an unreadable Environment Layer lights nothing");
+    // The light's Source set to that unreadable layer: same.
+    set(light(&mut p, cid), "lightOptions/source", Value::Layer(Some(env_layer.0)));
+    let failed = render(&p, cid);
+    assert_eq!(failed.data, unlit.data, "an unreadable selected Source lights nothing");
+    // The Source pointing at a deleted layer: same.
+    set(light(&mut p, cid), "lightOptions/source", Value::Layer(Some(999_999)));
+    let failed = render(&p, cid);
+    assert_eq!(failed.data, unlit.data, "a deleted selected Source lights nothing");
+    // Contrast: with no Source and no Environment Layer, the default studio still lights it.
+    let comp = p.comp_mut(cid).unwrap();
+    comp.layers.retain(|l| l.is_light() || !l.environment);
+    set(comp.layers.iter_mut().find(|l| l.is_light()).unwrap(), "lightOptions/source", Value::Layer(None));
+    let lit = render(&p, cid);
+    let (c, c2) = (unlit.data[20 * 120 + 30], lit.data[20 * 120 + 30]);
+    assert!(c2[3] > 0.99 && (c2[0] - c[0]).abs() > 0.05, "the unconfigured light still lights: {c2:?} vs {c:?}");
+}
+
+/// #2436: an Environment light's Cast Shadows works like After Effects' — its image's dominant
+/// (brightest) region shadows the scene. A bright disc above the image's centre, turned to
+/// shine from up and behind the camera (rotation 180°), shadows a sphere onto the floor below
+/// it; Cast Shadows off lights it evenly.
+#[test]
+fn environment_lights_cast_shadows() {
+    let (mut p, cid) = project(200, 150);
+    // The floor facing the camera, a sphere in front of it casting shadows only.
+    add(&mut p, cid, LayerSource::Primitive { kind: PrimitiveKind::Plane }, |l| {
+        set(l, "geometryOptions/width", Value::Scalar(400.0));
+        set(l, "geometryOptions/height", Value::Scalar(400.0));
+        set(l, "transform/position", Value::Vec3([100.0, 75.0, 110.0]));
+        set(l, "materialOptions/baseColor", Value::Color([1.0, 1.0, 1.0, 1.0]));
+    });
+    add(&mut p, cid, LayerSource::Primitive { kind: PrimitiveKind::Sphere }, |l| {
+        set(l, "geometryOptions/radius", Value::Scalar(30.0));
+        set(l, "transform/position", Value::Vec3([100.0, 75.0, 50.0]));
+        set(l, "materialOptions/castsShadows", Value::Enum(2));
+    });
+    // The Environment Layer: a tight bright key above the image's centre, on black — a
+    // full-comp rect keeps the layer buffer full-size, the radial gradient is the key.
+    add(&mut p, cid, LayerSource::Shape, |l| {
+        l.switches.three_d = true;
+        let mut next = 10_000u64;
+        let ids = &mut build::Ids(&mut next);
+        let rect = build::shape_rect(ids, [200.0, 150.0], [0.0, 0.0], 0.0);
+        let key = build::shape_gradient_fill(
+            ids,
+            true,
+            [0.0, -30.0],
+            [0.0, 5.0],
+            effectcraft_keyframe::Gradient { colors: vec![(0.0, [1.0, 1.0, 1.0, 1.0]), (1.0, [0.0, 0.0, 0.0, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 1.0)] },
+        );
+        let g = build::shape_group(ids, "Key", vec![rect, key]);
+        l.props.sub_mut("contents").unwrap().children.push(g.into());
+        l.environment = true;
+    });
+    // Turned 180°, the key shines from up and behind the camera onto the sphere and floor.
+    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |l| {
+        set(l, "lightOptions/rotation", Value::Scalar(180.0));
+        set(l, "lightOptions/castsShadows", Value::Bool(true));
+    });
+    // The shadow lands below the sphere on the floor: its core is the darkest floor pixel
+    // below the sphere; the lit floor is the sample to the left. The frame is sRGB-encoded,
+    // so the ratios below are gamma-compressed (a linear halving reads as ~0.73).
+    let luma = |img: &crate::Image, x: usize, y: usize| (img.data[y * 200 + x][0] + img.data[y * 200 + x][1] + img.data[y * 200 + x][2]) / 3.0;
+    let img = render(&p, cid);
+    let side = luma(&img, 25, 75);
+    let (mut core, mut cx, mut cy) = (f32::INFINITY, 0usize, 0usize);
+    for y in 100..150 {
+        for x in 60..140 {
+            if luma(&img, x, y) < core {
+                core = luma(&img, x, y);
+                cx = x;
+                cy = y;
+            }
+        }
+    }
+    assert!(side > 0.1, "the floor is lit: {side}");
+    assert!(core < side * 0.65, "the key shadows the sphere onto the floor: {core} vs {side} at ({cx}, {cy})");
+    // Cast Shadows off: the floor is lit everywhere, core included.
+    let comp = p.comp_mut(cid).unwrap();
+    set(&mut comp.layers[0], "lightOptions/castsShadows", Value::Bool(false));
+    let img = render(&p, cid);
+    let mid = luma(&img, cx, cy);
+    assert!(mid > side * 0.9, "no shadow without Cast Shadows: {mid} vs {side}");
+}
+
+/// #2436: a uniform environment has no dominant region, so even with Cast Shadows on it casts
+/// nothing — the render is the same as with the option off.
+#[test]
+fn a_uniform_environment_casts_no_shadow() {
+    let (mut p, cid) = project(120, 90);
+    let card = p.add_item(
+        "S",
+        Default::default(),
+        None,
+        ItemKind::Solid(effectcraft_project::Solid { color: [1.0, 1.0, 1.0], width: 60, height: 40, pixel_aspect: 1.0 }),
+    );
+    add(&mut p, cid, LayerSource::Solid { item: card }, |l| l.switches.three_d = true);
+    let env = p.add_item(
+        "E",
+        Default::default(),
+        None,
+        ItemKind::Solid(effectcraft_project::Solid { color: [1.0, 1.0, 1.0], width: 64, height: 32, pixel_aspect: 1.0 }),
+    );
+    add(&mut p, cid, LayerSource::Solid { item: env }, |l| {
+        l.environment = true;
+        l.switches.three_d = true;
+    });
+    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |l| {
+        set(l, "lightOptions/castsShadows", Value::Bool(true));
+    });
+    let casting = render(&p, cid);
+    let comp = p.comp_mut(cid).unwrap();
+    set(&mut comp.layers[0], "lightOptions/castsShadows", Value::Bool(false));
+    let off = render(&p, cid);
+    assert!(casting.data[20 * 120 + 30][0] > 0.3, "the card is lit");
+    assert_eq!(casting.data, off.data, "a directionless image casts no shadow");
+}
+
+/// #2436 review: a chromatic environment under a coloured light — equally bright red and blue
+/// regions on exactly opposite sides of the image cancel to a white light (it casts no
+/// shadow), but the red Environment light's tint removes the blue region's pull, so the red
+/// one becomes the key and casts the shadow the user asked for, from the red side.
+#[test]
+fn a_red_light_shadows_from_the_red_region_of_a_chromatic_environment() {
+    let (mut p, cid) = project(200, 150);
+    // The floor facing the camera, a sphere in front of it casting shadows only.
+    add(&mut p, cid, LayerSource::Primitive { kind: PrimitiveKind::Plane }, |l| {
+        set(l, "geometryOptions/width", Value::Scalar(400.0));
+        set(l, "geometryOptions/height", Value::Scalar(400.0));
+        set(l, "transform/position", Value::Vec3([100.0, 75.0, 110.0]));
+        set(l, "materialOptions/baseColor", Value::Color([1.0, 1.0, 1.0, 1.0]));
+    });
+    add(&mut p, cid, LayerSource::Primitive { kind: PrimitiveKind::Sphere }, |l| {
+        set(l, "geometryOptions/radius", Value::Scalar(30.0));
+        set(l, "transform/position", Value::Vec3([100.0, 75.0, 50.0]));
+        set(l, "materialOptions/castsShadows", Value::Enum(2));
+    });
+    // The Environment Layer: a black background with a red square and an equally bright blue
+    // one at exactly antipodal image positions (the blue is the point mirror of the red through
+    // the antipodal map x -> x + w/2, y -> h - y: centres (14.5, 44.5) and (114.5, 105.5) in a
+    // 200x150 image, 20x20 each) — equal solid-angle weight, opposite pull. The red sits up,
+    // left and toward the camera; the blue down, right and away from it.
+    add(&mut p, cid, LayerSource::Shape, |l| {
+        l.environment = true;
+        let mut next = 10_000u64;
+        let ids = &mut build::Ids(&mut next);
+        // Contents stack like the AE timeline — the first group is on top — so the background
+        // goes in last, under the red and blue squares (and its full-comp rect keeps the
+        // layer buffer full-size: a shape layer's buffer otherwise crops to its content).
+        let red_rect = build::shape_rect(ids, [20.0, 20.0], [-85.5, -30.5], 0.0);
+        let red_fill = build::shape_fill(ids, [1.0, 0.0, 0.0, 1.0]);
+        let red = build::shape_group(ids, "Red", vec![red_rect, red_fill]);
+        let blue_rect = build::shape_rect(ids, [20.0, 20.0], [14.5, 30.5], 0.0);
+        let blue_fill = build::shape_fill(ids, [0.0, 0.0, 1.0, 1.0]);
+        let blue = build::shape_group(ids, "Blue", vec![blue_rect, blue_fill]);
+        let bg_rect = build::shape_rect(ids, [200.0, 150.0], [0.0, 0.0], 0.0);
+        let bg_fill = build::shape_fill(ids, [0.0, 0.0, 0.0, 1.0]);
+        let bg = build::shape_group(ids, "BG", vec![bg_rect, bg_fill]);
+        for g in [red, blue, bg] {
+            l.props.sub_mut("contents").unwrap().children.push(g.into());
+        }
+    });
+    // A white light over the chromatic image: the regions cancel — Cast Shadows changes
+    // nothing, exactly like a directionless image.
+    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |l| {
+        set(l, "lightOptions/castsShadows", Value::Bool(true));
+    });
+    let white_casting = render(&p, cid);
+    let comp = p.comp_mut(cid).unwrap();
+    set(comp.layers.iter_mut().find(|l| l.is_light()).unwrap(), "lightOptions/castsShadows", Value::Bool(false));
+    let white_off = render(&p, cid);
+    assert_eq!(white_casting.data, white_off.data, "a white light sees no dominant region in the opposed red and blue");
+    // The red light: the tint removes the blue region, the red one shadows the sphere onto the
+    // floor below and right of it (the shadow falls opposite the red region).
+    let comp = p.comp_mut(cid).unwrap();
+    let light = comp.layers.iter_mut().find(|l| l.is_light()).unwrap();
+    set(light, "lightOptions/color", Value::Color([1.0, 0.0, 0.0, 1.0]));
+    set(light, "lightOptions/castsShadows", Value::Bool(true));
+    let img = render(&p, cid);
+    let chan = |img: &crate::Image, x: usize, y: usize| img.data[y * 200 + x][0];
+    let side = chan(&img, 25, 75);
+    let (mut core, mut cx) = (f32::INFINITY, 0usize);
+    for y in 100..150 {
+        for x in 60..170 {
+            if chan(&img, x, y) < core {
+                core = chan(&img, x, y);
+                cx = x;
+            }
+        }
+    }
+    assert!(side > 0.1, "the floor is lit red: {side}");
+    assert!(core < side * 0.65, "the red region shadows the sphere onto the floor: {core} vs {side} at x {cx}");
+    assert!(cx > 100, "the shadow is opposite the red region (right of the sphere): {cx}");
+}
+
+/// #2436: the default environment (no Source, no Environment Layer) is a dim studio — a mean
+/// of 0.3, not the 1.0 that would act like a 100 % white Ambient light and wash the scene out
+/// (After Effects' default does not) — and directional: its dominant region points up and
+/// toward the initial camera, so a shadow-casting Environment light casts soft, partial
+/// shadows out of the box, like After Effects' default.
+#[test]
+fn default_environment_keeps_the_level_and_points_up() {
+    let (w, h, d) = scene::default_environment();
+    assert_eq!((w, h), (8, 4));
+    let (mut mean, mut weight) = (0.0f32, 0.0f32);
+    for (i, p) in d.iter().enumerate() {
+        let v = ((i / w as usize) as f32 + 0.5) / h as f32;
+        let sa = (v * PI).sin();
+        mean += (p[0] + p[1] + p[2]) / 3.0 * sa;
+        weight += sa;
+    }
+    assert!((mean / weight - 0.3).abs() < 0.01, "dim studio mean: {}", mean / weight);
+    let (sun, key) = dominant_direction(w, h, &d, [1.0; 3], 0.0);
+    assert!(sun[1] < -0.5, "the key is up: {sun:?}");
+    assert!(sun[2] < -0.3, "the key is toward the camera: {sun:?}");
+    assert!(sun[0].abs() < 0.1, "symmetric left-right: {sun:?}");
+    assert!((0.35..0.55).contains(&key), "a broad key with fill: {key}");
+    // No texel clips past white at the default intensity (the fog of a mean-1 environment).
+    assert!(d.iter().all(|p| p[0] <= 1.0 && p[0] > 0.0), "0 < radiance <= 1");
+}
+
+/// #2436: with no Source and no Environment Layer, the Environment light's default environment
+/// casts soft, partial shadows like After Effects' default environment map — a sphere shadows
+/// the plane behind it, darkening part of the light while the fill keeps the floor visible
+/// (an area-light shadow, not the pitch black a point light casts); Cast Shadows off lights
+/// the floor evenly.
+#[test]
+fn the_default_environment_casts_shadows() {
+    let (mut p, cid) = project(200, 150);
+    // The floor facing the camera, a sphere in front of it casting shadows only.
+    add(&mut p, cid, LayerSource::Primitive { kind: PrimitiveKind::Plane }, |l| {
+        set(l, "geometryOptions/width", Value::Scalar(400.0));
+        set(l, "geometryOptions/height", Value::Scalar(400.0));
+        set(l, "transform/position", Value::Vec3([100.0, 75.0, 120.0]));
+        set(l, "materialOptions/baseColor", Value::Color([1.0, 1.0, 1.0, 1.0]));
+    });
+    add(&mut p, cid, LayerSource::Primitive { kind: PrimitiveKind::Sphere }, |l| {
+        set(l, "geometryOptions/radius", Value::Scalar(30.0));
+        set(l, "transform/position", Value::Vec3([100.0, 45.0, 50.0]));
+        set(l, "materialOptions/castsShadows", Value::Enum(2));
+    });
+    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |l| {
+        set(l, "lightOptions/castsShadows", Value::Bool(true));
+    });
+    // The default key (up and toward the camera) drops the shadow below the sphere: the core
+    // is the darkest floor pixel below it, the lit floor the sample to the left.
+    let luma = |img: &crate::Image, x: usize, y: usize| (img.data[y * 200 + x][0] + img.data[y * 200 + x][1] + img.data[y * 200 + x][2]) / 3.0;
+    let img = render(&p, cid);
+    let side = luma(&img, 30, 100);
+    let (mut core, mut cx, mut cy) = (f32::INFINITY, 0usize, 0usize);
+    for y in 110..150 {
+        for x in 80..120 {
+            if luma(&img, x, y) < core {
+                core = luma(&img, x, y);
+                cx = x;
+                cy = y;
+            }
+        }
+    }
+    assert!(side > 0.1, "the floor is lit: {side}");
+    // Partial: the key lobe is occluded (a clear darkening) but the fill keeps shining —
+    // not the pitch black a point light's shadow would cast at the same darkness. The frame
+    // is sRGB-encoded, so the ratios are gamma-compressed (a linear halving reads as ~0.73).
+    assert!(core < side * 0.8, "the default environment shadows the sphere onto the floor: {core} vs {side} at ({cx}, {cy})");
+    assert!(core > side * 0.45, "an area-light shadow, partial like After Effects': {core} vs {side}");
+    // Cast Shadows off: the floor is lit everywhere, core included.
+    let comp = p.comp_mut(cid).unwrap();
+    set(&mut comp.layers[0], "lightOptions/castsShadows", Value::Bool(false));
+    let img = render(&p, cid);
+    let mid = luma(&img, cx, cy);
+    assert!(mid > side * 0.9, "no shadow without Cast Shadows: {mid} vs {side}");
+}
+
 #[test]
 fn depth_of_field_blurs_out_of_focus_surfaces() {
     let mut img = Image::new(64, 64);
@@ -370,7 +813,16 @@ fn extruded_text_renders_as_a_mesh() {
         set(l, "geometryOptions/bevelStyle", Value::Enum(1));
         set(l, "transform/rotationY", Value::Scalar(40.0));
     });
-    let ctx = crate::EvalCtx { project: &p, comp_id: cid, comp: p.comp(cid).unwrap(), time: Tick::ZERO, expr: None, footage: None };
+    let ctx = crate::EvalCtx {
+        project: &p,
+        comp_id: cid,
+        comp: p.comp(cid).unwrap(),
+        time: Tick::ZERO,
+        expr: None,
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let l = &ctx.comp.layers[0];
     let params = scene::extrusion_params(&ctx, l).unwrap();
     let meshes = scene::extruded_meshes(&ctx, l, &params);
@@ -409,7 +861,16 @@ fn shape_surface_items_colour_the_extruded_surfaces() {
         set(l, "geometryOptions/extrusionDepth", Value::Scalar(40.0));
         set(l, "transform/position", Value::Vec3([100.0, 100.0, 0.0]));
     });
-    let ctx = crate::EvalCtx { project: &p, comp_id: cid, comp: p.comp(cid).unwrap(), time: Tick::ZERO, expr: None, footage: None };
+    let ctx = crate::EvalCtx {
+        project: &p,
+        comp_id: cid,
+        comp: p.comp(cid).unwrap(),
+        time: Tick::ZERO,
+        expr: None,
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let l = &ctx.comp.layers[0];
     let params = scene::extrusion_params(&ctx, l).unwrap();
     let meshes = scene::extruded_meshes(&ctx, l, &params);
@@ -445,7 +906,16 @@ fn text_animators_colour_the_extruded_surfaces() {
         set(l, "geometryOptions/extrusionDepth", Value::Scalar(30.0));
         set(l, "geometryOptions/bevelStyle", Value::Enum(1));
     });
-    let ctx = crate::EvalCtx { project: &p, comp_id: cid, comp: p.comp(cid).unwrap(), time: Tick::ZERO, expr: None, footage: None };
+    let ctx = crate::EvalCtx {
+        project: &p,
+        comp_id: cid,
+        comp: p.comp(cid).unwrap(),
+        time: Tick::ZERO,
+        expr: None,
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let l = &ctx.comp.layers[0];
     let params = scene::extrusion_params(&ctx, l).unwrap();
     let meshes = scene::extruded_meshes(&ctx, l, &params);
@@ -643,7 +1113,16 @@ fn extruded_strokes_render_as_bevelled_meshes() {
         set(l, "geometryOptions/extrusionDepth", Value::Scalar(20.0));
         set(l, "geometryOptions/bevelStyle", Value::Enum(1));
     });
-    let ctx = crate::EvalCtx { project: &p, comp_id: cid, comp: p.comp(cid).unwrap(), time: Tick::ZERO, expr: None, footage: None };
+    let ctx = crate::EvalCtx {
+        project: &p,
+        comp_id: cid,
+        comp: p.comp(cid).unwrap(),
+        time: Tick::ZERO,
+        expr: None,
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let l = &ctx.comp.layers[0];
     let params = scene::extrusion_params(&ctx, l).unwrap();
     let meshes = scene::extruded_meshes(&ctx, l, &params);
@@ -887,6 +1366,26 @@ fn penumbra_dithers_along_a_straight_edge() {
     assert!(distinct(&within) >= 4, "coverage inside one texel takes {} distinct values", distinct(&within));
 }
 
+#[test]
+fn penumbra_jitter_is_continuous_across_its_lattice() {
+    // Receiver pairs 1/5000 texel either side of a line of the 1/8-texel jitter lattice,
+    // across u and across v, inside the penumbra. The GPU places a receiver within a few
+    // ulps of the CPU, so coverage that jumps at a lattice line differs between the two
+    // backends there; both sides of each line must agree within one 8-bit level.
+    let (m, texels) = wall_map(64, 1.0, 6.0);
+    let f = |p: [f32; 2]| shade::shadow_factor(&m, &texels, [p[0], p[1], 13.5], FACING, 1.0);
+    let mut worst = 0.0f32;
+    for k in 0..16 {
+        let line = k as f32 * 0.125;
+        for (a, b) in [([-16.0 + line - 2e-4, 0.3], [-16.0 + line + 2e-4, 0.3]), ([-16.3, line - 2e-4], [-16.3, line + 2e-4])] {
+            let (fa, fb) = (f(a), f(b));
+            assert!(fa > 0.05 && fa < 0.95, "{a:?} lies in the penumbra: {fa}");
+            worst = worst.max((fa - fb).abs());
+        }
+    }
+    assert!(worst < 1.0 / 255.0, "coverage jumps by {worst} across a jitter lattice line");
+}
+
 #[test]
 fn penumbra_width_is_independent_of_map_resolution() {
     // One wall (edge at world x = −16) in a 64-texel map at 1 texel per world unit and
@@ -1047,3 +1546,54 @@ fn hard_edges_ramp_over_two_texels() {
         assert!((1.7..3.0).contains(&w), "v {v0}: hard edge ramps over {w} texels");
     }
 }
+
+// ---------------------------------------------------------------- the After Effects look (#2436)
+
+/// #2436: an Environment light with every option at its default renders like After Effects':
+/// a dim studio that leaves the lit floor a mid gray instead of washing it out to white (the
+/// fog of a mean-1 default), a partial shadow (the key lobe occluded, the fill still shining —
+/// not the pitch black a point light casts), and a soft edge in both quality and draft renders
+/// (the map's texel grid never shows through as stair-steps).
+#[test]
+fn environment_shadows_match_the_after_effects_look() {
+    let (mut p, cid) = project(800, 600);
+    add(&mut p, cid, LayerSource::Primitive { kind: PrimitiveKind::Plane }, |l| {
+        set(l, "geometryOptions/width", Value::Scalar(1200.0));
+        set(l, "geometryOptions/height", Value::Scalar(900.0));
+        set(l, "transform/position", Value::Vec3([400.0, 300.0, 300.0]));
+        set(l, "materialOptions/baseColor", Value::Color([1.0, 1.0, 1.0, 1.0]));
+    });
+    add(&mut p, cid, LayerSource::Primitive { kind: PrimitiveKind::Sphere }, |l| {
+        set(l, "geometryOptions/radius", Value::Scalar(80.0));
+        set(l, "transform/position", Value::Vec3([400.0, 300.0, 120.0]));
+        set(l, "materialOptions/castsShadows", Value::Enum(2));
+    });
+    add(&mut p, cid, LayerSource::Light { kind: LightKind::Environment }, |l| {
+        set(l, "lightOptions/castsShadows", Value::Bool(true));
+    });
+    let luma = |img: &crate::Image, x: usize, y: usize| (img.data[y * 800 + x][0] + img.data[y * 800 + x][1] + img.data[y * 800 + x][2]) / 3.0;
+    for (name, opts) in [("quality", RenderOpts::default()), ("draft", RenderOpts { draft: true, ..Default::default() })] {
+        let img = Renderer::new(&p, &NoFootage, opts).comp_frame(cid, Tick::ZERO);
+        // The shadow core: the darkest pixel of the lower half (the key drops the shadow
+        // below the sphere); the lit floor is the mean of the band to its left.
+        let (mut core, mut cx, mut cy) = (f32::INFINITY, 0usize, 0usize);
+        for y in 420..580 {
+            for x in 300..500 {
+                if luma(&img, x, y) < core {
+                    core = luma(&img, x, y);
+                    cx = x;
+                    cy = y;
+                }
+            }
+        }
+        let lit: f32 = (60..260).map(|x| luma(&img, x, cy)).sum::<f32>() / 200.0;
+        assert!(lit > 0.15 && lit < 0.85, "{name}: the lit floor is a mid gray, no white fog: {lit}");
+        // The frame is sRGB-encoded, so the ratio is gamma-compressed (a linear halving
+        // reads as ~0.73): partial means clearly darker than lit, far from black.
+        assert!(core > lit * 0.45 && core < lit * 0.85, "{name}: a partial area-light shadow: core {core} vs lit {lit}");
+        // The edge's 10-90 % ramp from the lit plateau (left) down into the shadow.
+        let first_below = |t: f32| (260..cx).position(|x| luma(&img, x, cy) < core + (lit - core) * t).map(|i| 260 + i);
+        let w = (first_below(0.1).unwrap() as f32) - (first_below(0.9).unwrap() as f32);
+        assert!(w >= 3.5, "{name}: the edge ramps over {w} px (After Effects' env shadows are soft)");
+    }
+}
diff --git a/crates/render/src/three_d/bokeh.rs b/crates/render/src/three_d/bokeh.rs
index 12bcbcf37..098f095d0 100644
--- a/crates/render/src/three_d/bokeh.rs
+++ b/crates/render/src/three_d/bokeh.rs
@@ -289,16 +289,24 @@ pub fn progressive_blur(img: &Image, iris: &Iris, radius: &[f32]) -> Image {
         return bokeh_blur(img, iris, levels[0] as f64);
     }
     let (lo, hi, n) = (levels[0], levels[levels.len() - 1], levels.len());
-    let blurred: Vec<Image> = levels.par_iter().map(|&r| bokeh_blur(img, iris, r as f64)).collect();
+    // A pixel blends only the two levels around its radius, so the levels are made in order and
+    // only that pair is held: peak memory stays a few images whatever the level count, rather
+    // than one image per level. Each level's blur is parallel over its rows.
     let mut out = Image::new(img.width, img.height);
-    out.data.par_iter_mut().enumerate().for_each(|(i, o)| {
-        let r = radius[i];
-        let f = ((r - lo) / (hi - lo) * (n - 1) as f32).clamp(0.0, (n - 1) as f32);
-        let k = (f.floor() as usize).min(n - 2);
-        let t = f - k as f32;
-        let (a, b) = (blurred[k].data[i], blurred[k + 1].data[i]);
-        *o = [0, 1, 2, 3].map(|c| a[c] + (b[c] - a[c]) * t);
-    });
+    let mut below = bokeh_blur(img, iris, lo as f64);
+    for (k, &r) in levels.iter().enumerate().skip(1) {
+        let above = bokeh_blur(img, iris, r as f64);
+        out.data.par_iter_mut().enumerate().for_each(|(i, o)| {
+            let f = ((radius[i] - lo) / (hi - lo) * (n - 1) as f32).clamp(0.0, (n - 1) as f32);
+            let kk = (f.floor() as usize).min(n - 2);
+            if kk + 1 == k {
+                let t = f - kk as f32;
+                let (a, b) = (below.data[i], above.data[i]);
+                *o = [0, 1, 2, 3].map(|c| a[c] + (b[c] - a[c]) * t);
+            }
+        });
+        below = above;
+    }
     out
 }
 
diff --git a/crates/render/src/three_d/camera.rs b/crates/render/src/three_d/camera.rs
index 30873b6a9..a927e2ceb 100644
--- a/crates/render/src/three_d/camera.rs
+++ b/crates/render/src/three_d/camera.rs
@@ -37,7 +37,8 @@ pub struct Dof {
 impl Dof {
     /// Circle-of-confusion diameter (comp pixels) for a point at camera depth `z`.
     pub fn coc(&self, z: f64) -> f64 {
-        if z <= NEAR || self.focus <= 0.0 {
+        // No defocus can be measured against a non-finite focus or depth, so it counts as in focus.
+        if !z.is_finite() || z <= NEAR || !self.focus.is_finite() || self.focus <= 0.0 {
             return 0.0;
         }
         self.aperture * (z - self.focus).abs() / z * self.blur_level
@@ -241,6 +242,53 @@ fn path_tangent(ctx: &EvalCtx, layer: &Layer) -> Option<Vec3> {
         .filter(|k| **k <= ctx.time)
         .find_map(|&k| dir(pos(k) - pos(k - dt)))
         .or_else(|| keys.iter().filter(|k| **k > ctx.time).find_map(|&k| dir(pos(k + dt) - pos(k))))
+        .or_else(|| {
+            // An expression has no keys to fall back on: sample it instead.
+            let expr = dims.iter().any(|m| tr.get(m).is_some_and(|p| p.has_expression()));
+            expr.then(|| sampled_tangent(ctx, layer, &pos, dt, true).or_else(|| sampled_tangent(ctx, layer, &pos, dt, false))).flatten()
+        })
+}
+
+/// Samples spent on each phase of [`sampled_tangent`]: it runs per layer per frame.
+const MOTION_SEARCH_STEPS: u32 = 12;
+
+/// Direction of the motion nearest to the context time, before it (`earlier`) or after it, for a
+/// position with no keyframes to fall back on (an expression). Steps 1, 2, 4, ... frames away
+/// (within the layer's in/out points) until the position differs from the current one, then
+/// bisects down to `dt` the moment the motion stopped (or started), so the heading kept is the
+/// one at the end of the motion whichever frame is shown.
+fn sampled_tangent(ctx: &EvalCtx, layer: &Layer, pos: &dyn Fn(effectcraft_time::Tick) -> Vec3, dt: effectcraft_time::Tick, earlier: bool) -> Option<Vec3> {
+    let here = pos(ctx.time);
+    let moved = |t| (pos(t) - here).length() > 1e-9;
+    let limit = if earlier { layer.in_point.min(ctx.time) } else { layer.out_point.max(ctx.time) };
+    let mut step = ctx.comp.frame_duration().max(dt);
+    let (mut still, mut away) = (ctx.time, None);
+    for _ in 0..MOTION_SEARCH_STEPS {
+        let t = if earlier { (ctx.time - step).max(limit) } else { (ctx.time + step).min(limit) };
+        if moved(t) {
+            away = Some(t);
+            break;
+        }
+        still = t;
+        if t == limit {
+            break;
+        }
+        step = step + step;
+    }
+    let mut away = away?;
+    for _ in 0..MOTION_SEARCH_STEPS {
+        if (still - away).abs() <= dt {
+            break;
+        }
+        let mid = away + (still - away).mul_ratio(1, 2);
+        if moved(mid) {
+            away = mid;
+        } else {
+            still = mid;
+        }
+    }
+    let d = if earlier { here - pos(away) } else { pos(away) - here };
+    (d.length() > 1e-9 && d.length().is_finite()).then(|| d.normalize())
 }
 
 /// Auto-Orient ▸ Orient Along Path for 2D layers: extra Z rotation in degrees.
@@ -313,22 +361,27 @@ pub fn layer_camera(ctx: &EvalCtx, cam: &Layer) -> CameraState {
     let (eye, fwd, down) = layer_frame(ctx, cam);
     let opts = cam.props.sub("cameraOptions");
     let zoom = opts.map(|g| ctx.f(cam, g, "zoom", 1000.0)).unwrap_or(1000.0).max(1e-3);
-    let dof = opts.filter(|g| ctx.b(cam, g, "dof")).map(|g| Dof {
-        focus: ctx.f(cam, g, "focusDistance", zoom),
-        aperture: ctx.f(cam, g, "aperture", default_aperture(w)).max(0.0),
-        blur_level: ctx.f(cam, g, "blurLevel", 100.0).max(0.0) / 100.0,
-        iris: super::bokeh::Iris {
-            sides: super::bokeh::Iris::sides_of_shape(ctx.e(cam, g, "irisShape")),
-            rotation: ctx.f(cam, g, "irisRotation", 0.0),
-            roundness: ctx.f(cam, g, "irisRoundness", 0.0) / 100.0,
-            aspect: ctx.f(cam, g, "irisAspectRatio", 1.0).max(0.01),
-            fringe: ctx.f(cam, g, "irisDiffractionFringe", 0.0).max(0.0) / 100.0,
-        },
-        highlight: super::bokeh::Highlight {
-            gain: ctx.f(cam, g, "highlightGain", 0.0).clamp(0.0, 100.0) / 100.0,
-            threshold: ctx.f(cam, g, "highlightThreshold", 255.0).clamp(0.0, 255.0) / 255.0,
-            saturation: ctx.f(cam, g, "highlightSaturation", 0.0).clamp(0.0, 100.0) / 100.0,
-        },
+    let dof = opts.filter(|g| ctx.b(cam, g, "dof")).map(|g| {
+        // A non-finite Focus Distance would make every blur radius non-finite; use the value the
+        // property defaults to (the zoom plane) instead.
+        let focus = ctx.f(cam, g, "focusDistance", zoom);
+        Dof {
+            focus: if focus.is_finite() { focus } else { zoom },
+            aperture: ctx.f(cam, g, "aperture", default_aperture(w)).max(0.0),
+            blur_level: ctx.f(cam, g, "blurLevel", 100.0).max(0.0) / 100.0,
+            iris: super::bokeh::Iris {
+                sides: super::bokeh::Iris::sides_of_shape(ctx.e(cam, g, "irisShape")),
+                rotation: ctx.f(cam, g, "irisRotation", 0.0),
+                roundness: ctx.f(cam, g, "irisRoundness", 0.0) / 100.0,
+                aspect: ctx.f(cam, g, "irisAspectRatio", 1.0).max(0.01),
+                fringe: ctx.f(cam, g, "irisDiffractionFringe", 0.0).max(0.0) / 100.0,
+            },
+            highlight: super::bokeh::Highlight {
+                gain: ctx.f(cam, g, "highlightGain", 0.0).clamp(0.0, 100.0) / 100.0,
+                threshold: ctx.f(cam, g, "highlightThreshold", 255.0).clamp(0.0, 255.0) / 255.0,
+                saturation: ctx.f(cam, g, "highlightSaturation", 0.0).clamp(0.0, 100.0) / 100.0,
+            },
+        }
     });
     CameraState { view: basis_view(eye, fwd, down), eye, zoom, ortho: false, dof }
 }
diff --git a/crates/render/src/three_d/compose.rs b/crates/render/src/three_d/compose.rs
index 20061f756..a5a7c170e 100644
--- a/crates/render/src/three_d/compose.rs
+++ b/crates/render/src/three_d/compose.rs
@@ -18,7 +18,7 @@ use std::sync::Arc;
 use effectcraft_color::{BlendMode, blend_pixel};
 use effectcraft_effects::Buf;
 use effectcraft_geom::{Mat3, Mat4, Vec3, vec3};
-use effectcraft_project::{Layer, LightKind, MatteKind};
+use effectcraft_project::{Layer, LightKind, MatteKind, limits};
 use effectcraft_raster::{Image, Px, hash_noise};
 use effectcraft_time::Tick;
 use rayon::prelude::*;
@@ -195,34 +195,31 @@ fn mb_samples(r: &Renderer, ctx: &EvalCtx, layer: &Layer) -> usize {
 }
 
 /// Prepare a layer (buffer, geometry, material). `None` when it shows nothing.
-pub(crate) fn prepare<'a>(r: &Renderer, ctx: &EvalCtx<'a>, layer: &'a Layer, order: usize, out: (u32, u32), in_run: bool) -> Option<Item<'a>> {
+pub(crate) fn prepare<'a>(r: &Renderer, ctx: &EvalCtx<'_>, layer: &'a Layer, order: usize, out: (u32, u32), in_run: bool) -> Option<Item<'a>> {
     let buf = r.blend_layer_buf(ctx, layer)?;
-    prepare_with(r, ctx, layer, order, out, in_run, buf, Mat4::IDENTITY)
+    prepare_with(r, ctx, layer, order, out, in_run, PlaneInput { buf, local: Mat4::IDENTITY })
 }
 
 /// Prepare a layer as planes: one per character for per-character 3D text, else one.
-pub(crate) fn prepare_all<'a>(r: &Renderer, ctx: &EvalCtx<'a>, layer: &'a Layer, order: usize, out: (u32, u32), in_run: bool) -> Vec<Item<'a>> {
+pub(crate) fn prepare_all<'a>(r: &Renderer, ctx: &EvalCtx<'_>, layer: &'a Layer, order: usize, out: (u32, u32), in_run: bool) -> Vec<Item<'a>> {
     if crate::text::per_char_3d(ctx, layer) {
         return crate::text::per_char_planes(ctx, layer, r.opts.scale)
             .into_iter()
-            .filter_map(|(buf, m)| prepare_with(r, ctx, layer, order, out, in_run, r.to_blend(Arc::new(buf), None), m))
+            .filter_map(|(buf, m)| prepare_with(r, ctx, layer, order, out, in_run, PlaneInput { buf: r.to_blend(Arc::new(buf), None), local: m }))
             .collect();
     }
     prepare(r, ctx, layer, order, out, in_run).into_iter().collect()
 }
 
-/// Prepare a plane showing `buf`, whose space maps into the layer through `local`.
-#[allow(clippy::too_many_arguments)]
-fn prepare_with<'a>(
-    r: &Renderer,
-    ctx: &EvalCtx<'a>,
-    layer: &'a Layer,
-    order: usize,
-    out: (u32, u32),
-    in_run: bool,
-    mut buf: Arc<Buf>,
+/// A processed plane and its mapping into the layer's coordinate system.
+struct PlaneInput {
+    buf: Arc<Buf>,
     local: Mat4,
-) -> Option<Item<'a>> {
+}
+
+/// Prepare the plane's geometry, motion samples and material.
+fn prepare_with<'a>(r: &Renderer, ctx: &EvalCtx<'_>, layer: &'a Layer, order: usize, out: (u32, u32), in_run: bool, plane: PlaneInput) -> Option<Item<'a>> {
+    let PlaneInput { mut buf, local } = plane;
     if buf.img.is_empty() {
         return None;
     }
@@ -290,12 +287,45 @@ fn prepare_with<'a>(
 }
 
 /// Blur radius (buffer pixels) of every buffer pixel of a plane at `world` (layer → world), from
-/// its camera depth: the circle of confusion over the on-screen size of one layer pixel there.
-fn dof_radii(cam: &CameraState, dof: &super::camera::Dof, world: Mat4, buf: &Buf) -> Vec<f32> {
-    dof_radii_at(cam, dof, world, (buf.img.width as usize, buf.img.height as usize), buf.offset, buf.scale)
+/// its camera depth: the circle of confusion over the on-screen size of one layer pixel there, at
+/// most `cap` ([`dof_radius_cap`]).
+fn dof_radii(cam: &CameraState, dof: &super::camera::Dof, world: Mat4, buf: &Buf, cap: f64) -> Vec<f32> {
+    dof_radii_at(cam, dof, world, (buf.img.width as usize, buf.img.height as usize), buf.offset, buf.scale, cap)
 }
 
-fn dof_radii_at(cam: &CameraState, dof: &super::camera::Dof, world: Mat4, (w, h): (usize, usize), offset: [f64; 2], scale: f64) -> Vec<f32> {
+/// Pixels a padded blur buffer may have: the ~16 million layer buffers are held to
+/// ([`crate::Renderer::raster_scale`]), or twice the buffer when that is larger, so a big buffer
+/// can still be blurred. The blur holds a few images of this size at once whatever its level
+/// count ([`super::bokeh::progressive_blur`]), so blurring a small plane costs no more memory than
+/// blurring a large layer.
+const DOF_PAD_BUDGET: f64 = 16.0e6;
+
+/// Comp pixels per buffer pixel below which a plane isn't blurred. Such a plane covers almost no
+/// screen area (a 0%-scaled layer, one at an extreme distance), while its radius in buffer
+/// pixels grows without bound as it shrinks: blurring it would cost the most for the least.
+const DOF_MIN_SCREEN_SCALE: f64 = 1e-3;
+
+/// The largest blur radius (buffer pixels) of a `w`×`h` buffer: the one whose padded copy just
+/// fits [`DOF_PAD_BUDGET`]. The circle of confusion has no bound of its own (a focus distance far
+/// beyond the scene, a near-zero layer scale), so memory sets the limit; ordinary bokeh stays far
+/// below it and is never clamped.
+pub(super) fn dof_radius_cap(dof: &super::camera::Dof, w: u32, h: u32) -> f64 {
+    let (w, h) = (w as f64, h as f64);
+    let budget = DOF_PAD_BUDGET.max(2.0 * w * h);
+    // (w + 2p)·(h + 2p) = budget, solved for the padding p.
+    let pad = (((w - h) * (w - h) + 4.0 * budget).sqrt() - (w + h)) / 4.0;
+    ((pad - 2.0) / iris_stretch(dof)).max(0.0)
+}
+
+pub(super) fn dof_radii_at(
+    cam: &CameraState,
+    dof: &super::camera::Dof,
+    world: Mat4,
+    (w, h): (usize, usize),
+    offset: [f64; 2],
+    scale: f64,
+    cap: f64,
+) -> Vec<f32> {
     let s = scale.max(1e-9);
     let sx = world.apply_vec(vec3(1.0, 0.0, 0.0)).length().max(1e-9);
     let at = |x: f64, y: f64| cam.depth(world.apply(vec3((x - offset[0]) / s, (y - offset[1]) / s, 0.0)));
@@ -309,31 +339,48 @@ fn dof_radii_at(cam: &CameraState, dof: &super::camera::Dof, world: Mat4, (w, h)
             if z <= super::camera::NEAR {
                 continue;
             }
-            // coc · ½ / (zoom / z · sx) · scale
-            *o = (dof.coc(z) * 0.5 * z / (cam.zoom * sx) * s) as f32;
+            // coc · ½ / (zoom / z · sx) · scale. Infinity clamps to the cap like any large radius,
+            // so the blur keeps growing with defocus; only NaN, which has no defocus, stays sharp.
+            let r = dof.coc(z) * 0.5 * z / (cam.zoom * sx) * s;
+            *o = if r.is_nan() || cam.zoom * sx / (z * s) < DOF_MIN_SCREEN_SCALE { 0.0 } else { r.min(cap) as f32 };
         }
     });
     out
 }
 
+/// How much the iris' aspect ratio stretches a blur radius along its longer axis.
+fn iris_stretch(dof: &super::camera::Dof) -> f64 {
+    let a = dof.iris.aspect.clamp(0.01, 100.0).sqrt();
+    a.max(1.0 / a)
+}
+
 /// The padding [`dof_blur`] gives a buffer whose largest blur radius is `rmax`.
 fn dof_pad(dof: &super::camera::Dof, rmax: f64) -> u32 {
-    let a = dof.iris.aspect.clamp(0.01, 100.0).sqrt().max(1.0 / dof.iris.aspect.clamp(0.01, 100.0).sqrt());
-    (rmax * a).ceil() as u32 + 2
+    ((rmax * iris_stretch(dof)).ceil() as u32).saturating_add(2)
+}
+
+/// The size of `img` padded by `pad` on every side, or `None` past [`limits::MAX_SIZE`] on a side:
+/// [`DOF_PAD_BUDGET`] bounds the area, so a long thin buffer could still outgrow a side.
+fn padded_size(img: &Image, pad: u32) -> Option<(u32, u32)> {
+    let grow = |n: u32| n.saturating_add(pad.saturating_mul(2));
+    let (w, h) = (grow(img.width), grow(img.height));
+    (w <= limits::MAX_SIZE && h <= limits::MAX_SIZE).then_some((w, h))
 }
 
 /// [`dof_blur`] planned for an accelerator: the padding, radius map and levels, and the padded
 /// buffer's layer-space bounds. `None` when nothing blurs.
 fn dof_plan(cam: &CameraState, dof: &super::camera::Dof, world: Mat4, buf: &Buf) -> Option<(PlaneDof, [f64; 4])> {
-    let radii = dof_radii(cam, dof, world, buf);
+    let cap = dof_radius_cap(dof, buf.img.width, buf.img.height);
+    let radii = dof_radii(cam, dof, world, buf, cap);
     let rmax = radii.iter().copied().fold(0.0f32, f32::max) as f64;
     if rmax <= 0.3 {
         return None;
     }
     let pad = dof_pad(dof, rmax);
-    let (w, h) = (buf.img.width as usize + 2 * pad as usize, buf.img.height as usize + 2 * pad as usize);
+    let (wp, hp) = padded_size(&buf.img, pad)?;
+    let (w, h) = (wp as usize, hp as usize);
     let offset = [buf.offset[0] + pad as f64, buf.offset[1] + pad as f64];
-    let radius = dof_radii_at(cam, dof, world, (w, h), offset, buf.scale);
+    let radius = dof_radii_at(cam, dof, world, (w, h), offset, buf.scale, cap);
     let levels = super::bokeh::blur_levels(&radius)?;
     let s = buf.scale.max(1e-9);
     let bounds = [-offset[0] / s, -offset[1] / s, (w as f64 - offset[0]) / s, (h as f64 - offset[1]) / s];
@@ -342,16 +389,20 @@ fn dof_plan(cam: &CameraState, dof: &super::camera::Dof, world: Mat4, buf: &Buf)
 
 /// Depth of field for one plane: highlights boosted, then a bokeh-shaped blur by depth.
 fn dof_blur(cam: &CameraState, dof: &super::camera::Dof, world: Mat4, buf: Arc<Buf>) -> Arc<Buf> {
-    let radii = dof_radii(cam, dof, world, &buf);
+    let cap = dof_radius_cap(dof, buf.img.width, buf.img.height);
+    let radii = dof_radii(cam, dof, world, &buf, cap);
     let rmax = radii.iter().copied().fold(0.0f32, f32::max) as f64;
     if rmax <= 0.3 {
         return buf;
     }
     let pad = dof_pad(dof, rmax);
+    if padded_size(&buf.img, pad).is_none() {
+        return buf;
+    }
     let mut padded = buf.img.padded(pad);
     super::bokeh::boost_highlights(&mut padded, &dof.highlight);
     let pbuf = Buf { img: padded, offset: [buf.offset[0] + pad as f64, buf.offset[1] + pad as f64], scale: buf.scale };
-    let pr = dof_radii(cam, dof, world, &pbuf);
+    let pr = dof_radii(cam, dof, world, &pbuf, cap);
     // The (cached, shared) layer buffer stays untouched; the blurred copy is per frame.
     Arc::new(Buf { img: super::bokeh::progressive_blur(&pbuf.img, &dof.iris, &pr), offset: pbuf.offset, scale: pbuf.scale })
 }
@@ -452,8 +503,8 @@ fn gather<'a>(r: &Renderer<'a>, ctx: &EvalCtx<'a>, run: &[&'a Layer], out: (u32,
         .flat_map_iter(|(i, l)| {
             // Stack order with room for a collapsed precomp's layers in between.
             let i = i * 1024;
-            if let Some(item) = r.collapsed(ctx, l) {
-                return collapsed_items(r, ctx, l, item, i, out);
+            if let Some(collapsed) = r.collapsed(ctx, l) {
+                return collapsed_items(r, ctx, l, &collapsed, i, out);
             }
             let mut its = prepare_all(r, ctx, l, i, out, true);
             if !its.is_empty() {
@@ -472,6 +523,7 @@ fn gather<'a>(r: &Renderer<'a>, ctx: &EvalCtx<'a>, run: &[&'a Layer], out: (u32,
         extra = ctx
             .comp
             .layers
+            .as_arcs()
             .par_iter()
             .filter(|l| l.switches.three_d && l.has_video() && l.is_active_at(ctx.time) && !in_run.contains(&l.id) && !l.switches.adjustment)
             .filter(|l| Material::of(ctx, l).casts_shadows != 0)
@@ -486,20 +538,13 @@ fn gather<'a>(r: &Renderer<'a>, ctx: &EvalCtx<'a>, run: &[&'a Layer], out: (u32,
 /// 3D space (world = precomp layer's world × nested world), depth-sorted with the run, so they
 /// intersect the parent's 3D layers; nested 2D layers lie on the precomp layer's plane in stack
 /// order. (Nested adjustment layers are skipped here.)
-fn collapsed_items<'a>(
-    r: &Renderer<'a>,
-    ctx: &EvalCtx<'a>,
-    layer: &'a Layer,
-    item: effectcraft_project::ItemId,
-    order: usize,
-    out: (u32, u32),
-) -> Vec<Item<'a>> {
+fn collapsed_items<'a>(r: &Renderer<'a>, ctx: &EvalCtx<'a>, layer: &'a Layer, collapsed: &crate::Collapsed, order: usize, out: (u32, u32)) -> Vec<Item<'a>> {
     let op = ctx.opacity(layer) as f32 * r.opacity_mul();
-    let Some((sub, nctx)) = r.collapse_into(ctx, layer, item, op) else { return vec![] };
+    let Some((sub, nctx)) = r.collapse_into(ctx, layer, collapsed, op) else { return vec![] };
     let t = nctx.time;
-    let any_solo = nctx.comp.any_solo();
-    let nested: Vec<&'a Layer> = nctx
-        .comp
+    let Some(nc) = r.project.comp(collapsed.item) else { return vec![] };
+    let any_solo = nc.any_solo();
+    let nested: Vec<&'a Layer> = nc
         .layers
         .iter()
         .rev()
@@ -648,6 +693,13 @@ fn shade_texel(it: &Item, g: &Geo, u: f64, v: f64, t: Px, lights: &[LightState],
     [lit[0] * a, lit[1] * a, lit[2] * a, a]
 }
 
+/// Samples per side of the Shadow Diffusion kernel for a penumbra radius of `r_px` caster pixels:
+/// odd, at least 3, and enough that neighbouring samples are at most 1.5 pixels apart, up to 15.
+pub(crate) fn shadow_taps(r_px: f64) -> u32 {
+    let n = ((2.0 * r_px / 1.5).ceil() as u32).clamp(3, 15);
+    n | 1
+}
+
 /// RGB transmittance of light `l` reaching `p` past caster `c` (1 = unoccluded).
 fn occlusion(c: &Item, p: Vec3, l: &LightState) -> [f32; 3] {
     const FAR: f64 = 1.0e6;
@@ -675,11 +727,17 @@ fn occlusion(c: &Item, p: Vec3, l: &LightState) -> [f32; 3] {
     if r * c.buf.scale < 0.5 {
         px = c.texel(hit.x, hit.y);
     } else {
-        for j in -1..=1 {
-            for i in -1..=1 {
-                let q = c.texel(hit.x + i as f64 * r * 0.66, hit.y + j as f64 * r * 0.66);
+        // Box filter over the penumbra square: n × n cell centres, dense enough that a wide
+        // diffusion blurs the caster instead of stamping copies of it (#2444).
+        let n = shadow_taps(r * c.buf.scale);
+        let step = 2.0 * r / n as f64;
+        let h = (n / 2) as i32;
+        let w = 1.0 / (n * n) as f32;
+        for j in -h..=h {
+            for i in -h..=h {
+                let q = c.texel(hit.x + f64::from(i) * step, hit.y + f64::from(j) * step);
                 for k in 0..4 {
-                    px[k] += q[k] / 9.0;
+                    px[k] += q[k] * w;
                 }
             }
         }
@@ -703,7 +761,7 @@ fn occlusion(c: &Item, p: Vec3, l: &LightState) -> [f32; 3] {
 
 /// A Classic 3D run prepared for an accelerator ([`Renderer::prepare_3d_run`]): every plane
 /// with its geometry, material and buffer, ready for the per-pixel depth sort, lighting and
-/// ray-cast shadows of [`draw_run`] on another device.
+/// ray-cast shadows of `draw_run` on another device.
 #[derive(Clone, Debug)]
 pub struct Run3d {
     /// Drawn planes in stack order, then shadow casters from outside the run (`draw` false).
@@ -853,7 +911,7 @@ pub(crate) fn aux_pass(r: &Renderer, ctx: &EvalCtx) -> effectcraft_raster::AuxCh
                     if nv[2] > 0.0 {
                         nv = nv.map(|v| -v);
                     }
-                    let (sw, sh) = crate::source_size(r.project, it.layer);
+                    let (sw, sh) = ctx.source_size(it.layer);
                     let size = if sw == 0 { [ctx.comp.width as f64, ctx.comp.height as f64] } else { [sw as f64, sh as f64] };
                     (number(it.layer), source_id(it.layer), crypto_hash(&it.layer.name), crypto_hash(&source_name(it.layer)), nv, size)
                 })
@@ -971,7 +1029,7 @@ pub(crate) fn environment_rotation(ctx: &EvalCtx) -> f32 {
         .to_radians() as f32
 }
 
-/// An Environment Light Background layer ready to draw (see [`draw_sky`]): the layer's
+/// An Environment Light Background layer ready to draw (see `draw_sky`): the layer's
 /// buffer in the blending space, its opacity and the camera's view rays. Also handed to an
 /// accelerator's compositor (`Renderer::sky_draw`).
 #[derive(Clone)]
diff --git a/crates/render/src/three_d/tests.rs b/crates/render/src/three_d/tests.rs
index 9f1dbb344..026929623 100644
--- a/crates/render/src/three_d/tests.rs
+++ b/crates/render/src/three_d/tests.rs
@@ -13,10 +13,15 @@ const W: u32 = 200;
 const H: u32 = 100;
 
 fn setup() -> (Project, ItemId, Comp) {
+    setup_sized(W, H)
+}
+
+/// [`setup`] with a `w`×`h` comp.
+fn setup_sized(w: u32, h: u32) -> (Project, ItemId, Comp) {
     let mut p = Project::default();
     // Exact float maths; 8/16 bpc quantisation has its own tests (tests_color).
     p.settings.bit_depth = effectcraft_project::BitDepth::Bpc32;
-    let comp = Comp::new(W, H, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
+    let comp = Comp::new(w, h, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
     let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.clone().into()));
     (p, cid, comp)
 }
@@ -344,10 +349,37 @@ fn shadow_darkness_and_accepts_off() {
     assert!(close(v, 0.5, 1e-3), "no shadow accepted: {v}");
 }
 
+#[test]
+fn shadow_diffusion_is_a_soft_ramp_not_copies() {
+    // #2444: a wide Shadow Diffusion stamped 3 × 3 copies of the caster, so the penumbra stepped
+    // through three flat levels instead of ramping smoothly from lit to shadowed.
+    let (mut p, cid, comp) = setup();
+    let mut recv = solid3(&mut p, &comp, [1.0, 1.0, 1.0], 400, 200, [100.0, 50.0, 100.0]);
+    no_specular(&mut recv);
+    let mut caster = solid3(&mut p, &comp, [1.0, 1.0, 1.0], 100, 200, [40.0, 50.0, 0.0]);
+    set(&mut caster, "materialOptions/castsShadows", Value::Enum(2)); // Only: invisible caster
+    let mut l = light(&mut p, &comp, LightKind::Parallel, [100.0, 50.0, -500.0]);
+    set(&mut l, "transform/poi", Value::Vec3([100.0, 50.0, 0.0]));
+    set(&mut l, "lightOptions/castsShadows", Value::Bool(true));
+    // 100 px to the caster over the parallel light's 1000: a 15 px penumbra radius.
+    set(&mut l, "lightOptions/shadowDiffusion", Value::Scalar(150.0));
+    push(&mut p, cid, l);
+    push(&mut p, cid, caster);
+    push(&mut p, cid, recv);
+    let img = render(&p, cid);
+    let row: Vec<f32> = (0..i64::from(W)).map(|x| img.get(x, 50)[0]).collect();
+    // The row crosses both vertical edges of the caster's shadow: lit, ramp, shadowed, ramp, lit.
+    assert!(row.iter().any(|v| *v < 0.01) && close(row[W as usize - 1], 0.5, 1e-3), "shadow and light: {row:?}");
+    let ramp = row.iter().filter(|v| **v > 0.02 && **v < 0.48).count();
+    assert!(ramp >= 16, "two penumbras several pixels wide: {row:?}");
+    let step = row.windows(2).map(|w| (w[1] - w[0]).abs()).fold(0.0f32, f32::max);
+    assert!(step < 0.08, "no jumps between copies of the caster (largest step {step}): {row:?}");
+}
+
 // ---------------------------------------------------------------- cameras
 
 fn camera(p: &mut Project, comp: &Comp) -> Layer {
-    build::layer(p, comp, "Camera", LayerSource::Camera, (W, H), None)
+    build::layer(p, comp, "Camera", LayerSource::Camera, (comp.width, comp.height), None)
 }
 
 #[test]
@@ -423,9 +455,155 @@ fn depth_of_field_blurs_out_of_focus_layers() {
     assert!(b.get(66, 50)[3] > 0.01);
 }
 
+/// A non-finite Focus Distance doesn't reach the blur: the camera focuses on the property's
+/// default plane (`zoom`) instead.
+#[test]
+fn dof_falls_back_when_focus_distance_is_not_finite() {
+    for bad in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+        let (mut p, cid, comp) = setup();
+        let mut cam = camera(&mut p, &comp);
+        set(&mut cam, "cameraOptions/dof", Value::Bool(true));
+        set(&mut cam, "cameraOptions/aperture", Value::Scalar(60.0));
+        set(&mut cam, "cameraOptions/focusDistance", Value::Scalar(bad));
+        let s = solid3(&mut p, &comp, [1.0, 1.0, 1.0], 60, 60, [100.0, 50.0, 0.0]);
+        push(&mut p, cid, cam);
+        push(&mut p, cid, s);
+        let cp = p.comp(cid).unwrap();
+        let ctx = crate::EvalCtx::new(&p, cid, cp, Tick::ZERO);
+        let cs = crate::three_d::camera::layer_camera(&ctx, &cp.layers[0]);
+        let f = cs.dof.unwrap().focus;
+        assert!((f - zoom()).abs() < 1e-9, "{bad}: evaluated to {f}, expected the fallback to zoom {}", zoom());
+        // The z = 0 plane is in focus: hard edge, finite pixels.
+        let img = render(&p, cid);
+        assert!(img.get(71, 50)[3] > 0.99 && img.get(69, 50)[3] < 0.01, "{bad}: the edge should be hard");
+        assert!(img.data.iter().all(|px| px.iter().all(|c| c.is_finite())), "{bad}: non-finite pixels");
+    }
+}
+
+/// The Classic 3D blur stays bounded for degenerate inputs: a 0%-scaled 3D layer off the focal
+/// plane (e.g. the first frame of a scale-in) or a huge but finite Focus Distance asks for a
+/// radius of billions of buffer pixels, whose padded buffer can't be allocated.
+#[test]
+fn dof_blur_radius_is_bounded_for_degenerate_inputs() {
+    let scene = |focus: f64, scale: f64| {
+        let (mut p, cid, comp) = setup();
+        let mut cam = camera(&mut p, &comp);
+        set(&mut cam, "cameraOptions/dof", Value::Bool(true));
+        set(&mut cam, "cameraOptions/aperture", Value::Scalar(60.0));
+        set(&mut cam, "cameraOptions/focusDistance", Value::Scalar(focus));
+        let mut s = solid3(&mut p, &comp, [1.0, 1.0, 1.0], 60, 60, [100.0, 50.0, 0.0]);
+        set(&mut s, "transform/scale", Value::Vec3([scale, scale, 100.0]));
+        push(&mut p, cid, cam);
+        push(&mut p, cid, s);
+        render(&p, cid)
+    };
+    let finite = |img: &effectcraft_raster::Image| img.data.iter().all(|px| px.iter().all(|c| c.is_finite()));
+    // A 0%-scaled layer 10 px off the focal plane: an ordinary defocus times 1/sx (sx = 1e-9).
+    assert!(finite(&scene(zoom() + 10.0, 0.0)), "zero-scaled: non-finite pixels");
+    // Huge but finite Focus Distances (typed in, or a large expression result): the blur is as
+    // large as the buffer budget allows, never refused (which would render the layer sharp).
+    // 1e307 overflows the circle of confusion itself to infinity: still the largest blur.
+    for focus in [1.0e12, 1.0e307] {
+        let img = scene(focus, 100.0);
+        assert!(finite(&img), "focus {focus:e}: non-finite pixels");
+        assert!(img.get(100, 50)[3] < 0.5, "focus {focus:e}: the layer should be spread out, not sharp ({})", img.get(100, 50)[3]);
+    }
+}
+
+/// The blur radius map of a plane: a 0%-scaled plane is degenerate on screen and isn't blurred;
+/// any other radius stays within the buffer budget's cap.
+#[test]
+fn dof_radii_skip_degenerate_planes_and_respect_the_cap() {
+    let radii = |focus: f64, scale: f64| {
+        let (mut p, cid, comp) = setup();
+        let mut cam = camera(&mut p, &comp);
+        set(&mut cam, "cameraOptions/dof", Value::Bool(true));
+        set(&mut cam, "cameraOptions/aperture", Value::Scalar(60.0));
+        set(&mut cam, "cameraOptions/focusDistance", Value::Scalar(focus));
+        let mut s = solid3(&mut p, &comp, [1.0, 1.0, 1.0], 60, 60, [100.0, 50.0, 0.0]);
+        set(&mut s, "transform/scale", Value::Vec3([scale, scale, 100.0]));
+        push(&mut p, cid, cam);
+        push(&mut p, cid, s);
+        let cp = p.comp(cid).unwrap();
+        let ctx = crate::EvalCtx::new(&p, cid, cp, Tick::ZERO);
+        let cs = super::camera::layer_camera(&ctx, &cp.layers[0]);
+        let dof = cs.dof.unwrap();
+        let cap = super::compose::dof_radius_cap(&dof, 60, 60);
+        (super::compose::dof_radii_at(&cs, &dof, ctx.world_matrix(&cp.layers[1]), (60, 60), [0.0; 2], 1.0, cap), cap)
+    };
+    let (r, _) = radii(zoom() + 10.0, 0.0);
+    assert!(r.iter().all(|&r| r == 0.0), "a 0%-scaled plane is not blurred");
+    let (r, cap) = radii(1.0e12, 100.0);
+    assert!(cap > 1000.0, "a 60×60 buffer may blur by well over 1000 px: {cap}");
+    assert!(r.iter().all(|&r| r as f64 <= cap && r as f64 > cap - 1.0), "huge focus: every radius at the cap {cap}");
+}
+
+/// Two layers that look the same on screen (400×100 at 100%, 1600×400 at 25%) at the same depth
+/// blur by the same amount on screen: the radius bound must not depend on the layer's scale.
+#[test]
+fn dof_blur_is_independent_of_layer_scale() {
+    let ramp = |w: u32, h: u32, scale: f64| {
+        let (mut p, cid, comp) = setup_sized(800, 400);
+        let zoom = 800.0 * 50.0 / 36.0;
+        let mut cam = camera(&mut p, &comp);
+        set(&mut cam, "cameraOptions/dof", Value::Bool(true));
+        set(&mut cam, "cameraOptions/aperture", Value::Scalar(200.0));
+        // coc = aperture·|z − f| / z: a 40 px comp radius on the z = 0 plane (depth = zoom).
+        set(&mut cam, "cameraOptions/focusDistance", Value::Scalar(zoom + 2.0 * 40.0 * zoom / 200.0));
+        let mut s = solid3(&mut p, &comp, [1.0, 1.0, 1.0], w, h, [400.0, 200.0, 0.0]);
+        set(&mut s, "transform/scale", Value::Vec3([scale, scale, 100.0]));
+        push(&mut p, cid, cam);
+        push(&mut p, cid, s);
+        let img = render(&p, cid);
+        soft_count(&img, (0..400).map(|x| (x, 200)))
+    };
+    let (full, quarter) = (ramp(400, 100, 100.0), ramp(1600, 400, 25.0));
+    assert!(full > 60, "the out-of-focus edge should be soft: {full}");
+    assert!(full.abs_diff(quarter) <= 2, "same on-screen layer, same depth: {full} px at 100% vs {quarter} px at 25%");
+}
+
+/// The same frame at Full and Half resolution shows the same blur (in comp pixels). The radius
+/// (~100 px) is large so that any bound that depends on the resolution would show.
+#[test]
+fn dof_blur_matches_across_render_resolutions() {
+    let (mut p, cid, comp) = setup_sized(800, 400);
+    let zoom = 800.0 * 50.0 / 36.0;
+    let mut cam = camera(&mut p, &comp);
+    set(&mut cam, "cameraOptions/dof", Value::Bool(true));
+    set(&mut cam, "cameraOptions/aperture", Value::Scalar(200.0));
+    set(&mut cam, "cameraOptions/focusDistance", Value::Scalar(2.0 * zoom));
+    let s = solid3(&mut p, &comp, [1.0, 1.0, 1.0], 400, 100, [400.0, 200.0, 0.0]);
+    push(&mut p, cid, cam);
+    push(&mut p, cid, s);
+    let ramp = |scale: f64| {
+        let img = render_frame(&p, cid, Tick::ZERO, scale);
+        let (w, h) = (img.width as i64, img.height as i64);
+        soft_count(&img, (0..w / 2).map(|x| (x, h / 2))) as f64 / scale
+    };
+    let (full, half) = (ramp(1.0), ramp(0.5));
+    assert!(full > 150.0, "a ~100 px radius must not be clamped: {full} comp px");
+    assert!((full - half).abs() <= 4.0, "Full {full} vs Half {half} comp px");
+}
+
+/// `Dof::coc` treats a non-finite focus or depth as in focus.
+#[test]
+fn dof_coc_is_zero_for_non_finite_inputs() {
+    let d = |focus: f64| super::camera::Dof { focus, aperture: 50.0, blur_level: 1.0, iris: Default::default(), highlight: Default::default() };
+    for bad in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+        assert_eq!(d(bad).coc(500.0), 0.0, "focus {bad}");
+        assert_eq!(d(400.0).coc(bad), 0.0, "depth {bad}");
+    }
+    assert!(d(400.0).coc(500.0) > 0.0);
+}
+
+/// Pixels among `pts` whose alpha is strictly between 0.05 and 0.95.
+fn soft_count(img: &effectcraft_raster::Image, pts: impl Iterator<Item = (i64, i64)>) -> usize {
+    pts.filter(|&(x, y)| (0.05..0.95).contains(&img.get(x, y)[3])).count()
+}
+
 /// Pixels in column `x` whose alpha is strictly between 0.05 and 0.95.
 fn soft_px(img: &effectcraft_raster::Image, x: i64) -> usize {
-    (0..img.height as i64).filter(|&y| (0.05..0.95).contains(&img.get(x, y)[3])).count()
+    soft_count(img, (0..img.height as i64).map(|y| (x, y)))
 }
 
 #[test]
diff --git a/crates/render/src/three_d/tests_orient.rs b/crates/render/src/three_d/tests_orient.rs
index 06f2599dc..f9c72e296 100644
--- a/crates/render/src/three_d/tests_orient.rs
+++ b/crates/render/src/three_d/tests_orient.rs
@@ -8,6 +8,7 @@ use effectcraft_project::{AutoOrient, Comp, ItemId, ItemKind, Layer, LayerSource
 use effectcraft_time::{FrameRate, Tick};
 
 use super::active_camera;
+use super::camera::auto_orient_2d;
 use crate::EvalCtx;
 
 fn setup() -> (Project, ItemId, Comp) {
@@ -78,6 +79,69 @@ fn orient_along_path_keeps_the_last_heading_at_and_after_the_end() {
     }
 }
 
+/// #1650: the same end-of-path flip when Position has no keyframes of its own and is driven by
+/// an expression (e.g. `pointOnPath()` fed by a keyframed slider on another layer): once the
+/// motion stops there are no Position keys to fall back on, and the heading snapped to 0 degrees.
+#[test]
+fn orient_along_path_keeps_the_last_heading_when_position_is_an_expression() {
+    /// Stand-in for an expression: holds, moves 100 px left over 0.5..1 s, then holds again (like
+    /// a slider going from 0% to 100%).
+    struct LeftThenHold;
+    impl crate::ExprHost for LeftThenHold {
+        fn eval(&self, ctx: &EvalCtx, _: &Layer, prop: &effectcraft_project::Property, value: &Value) -> Result<Value, String> {
+            if prop.match_id != "position" {
+                return Ok(value.clone());
+            }
+            let s = ((ctx.time.seconds() - 0.5) * 2.0).clamp(0.0, 1.0);
+            Ok(Value::Vec3([150.0 - 100.0 * s, 50.0, 0.0]))
+        }
+    }
+    for three_d in [false, true] {
+        let (mut p, cid, comp) = setup();
+        let mut l = solid(&mut p, &comp, three_d, [150.0, 50.0, 0.0]);
+        l.auto_orient = AutoOrient::AlongPath;
+        let pos = l.props.prop_mut("transform/position").unwrap();
+        assert!(pos.keys.is_empty(), "the fixture must have no Position keyframes");
+        pos.expr = Some(effectcraft_project::Expression { text: "left then hold".into(), enabled: true });
+        p.comp_mut(cid).unwrap().layers.push(l);
+        let c = p.comp(cid).unwrap();
+        for secs in [0.2, 0.75, 1.0, 1.0 + 1.0 / 30.0, 1.2, 1.9] {
+            let ctx = EvalCtx { expr: Some(&LeftThenHold), ..EvalCtx::new(&p, cid, c, Tick::from_seconds_f64(secs)) };
+            let x_axis = ctx.world_matrix(&c.layers[0]).apply_vec(vec3(1.0, 0.0, 0.0));
+            // Moving left (-x): the layer's x axis points left before the motion starts and after it stops.
+            assert!((x_axis.x + 1.0).abs() < 1e-6 && x_axis.y.abs() < 1e-6 && x_axis.z.abs() < 1e-6, "3d={three_d} t={secs}: {x_axis:?}");
+        }
+    }
+}
+
+/// #1650 on a curved path: the heading kept once an expression stops moving is the one at the end
+/// of the motion, the same on every later frame, not whatever earlier point a coarse search lands on.
+#[test]
+fn orient_along_a_curved_expression_path_keeps_the_end_heading() {
+    /// Quarter circle over 0..1 s: heading 0 degrees at the start, 90 degrees (down) at the end.
+    struct Arc;
+    impl crate::ExprHost for Arc {
+        fn eval(&self, ctx: &EvalCtx, _: &Layer, prop: &effectcraft_project::Property, value: &Value) -> Result<Value, String> {
+            if prop.match_id != "position" {
+                return Ok(value.clone());
+            }
+            let a = ctx.time.seconds().clamp(0.0, 1.0) * std::f64::consts::FRAC_PI_2;
+            Ok(Value::Vec3([100.0 * a.sin(), 100.0 - 100.0 * a.cos(), 0.0]))
+        }
+    }
+    let (mut p, cid, comp) = setup();
+    let mut l = solid(&mut p, &comp, false, [0.0, 0.0, 0.0]);
+    l.auto_orient = AutoOrient::AlongPath;
+    l.props.prop_mut("transform/position").unwrap().expr = Some(effectcraft_project::Expression { text: "arc".into(), enabled: true });
+    p.comp_mut(cid).unwrap().layers.push(l);
+    let c = p.comp(cid).unwrap();
+    for frame in [31, 33, 37, 45, 59] {
+        let ctx = EvalCtx { expr: Some(&Arc), ..EvalCtx::new(&p, cid, c, Tick::from_seconds_f64(frame as f64 / 30.0)) };
+        let deg = auto_orient_2d(&ctx, &c.layers[0]);
+        assert!((deg - 90.0).abs() < 0.5, "frame {frame}: {deg}");
+    }
+}
+
 #[test]
 fn layers_parented_to_a_camera_follow_its_rotation() {
     let (mut p, cid, comp) = setup();
diff --git a/crates/sam2/Cargo.toml b/crates/sam2/Cargo.toml
new file mode 100644
index 000000000..e45cc8def
--- /dev/null
+++ b/crates/sam2/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "effectcraft-sam2"
+description = "SAM 2.1 (Hiera) video object tracker for the Roto Brush: a Rust port of the Hugging Face transformers implementation, native only, weights downloaded by the user"
+version.workspace = true
+edition.workspace = true
+license = "Apache-2.0"
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+effectcraft-segment = { workspace = true }
+rayon = { workspace = true }
+log = { workspace = true }
+
+# Native only (D1): candle is not built for wasm32, where this crate is empty.
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+candle-core = "=0.9.2"
+candle-nn = "=0.9.2"
+# The optional GPU path (wgpu compute, any vendor); the CPU path stays the reference.
+wgpu = { workspace = true }
+pollster = { workspace = true }
+bytemuck = { workspace = true }
+half = "2.7"
diff --git a/crates/sam2/NOTICE b/crates/sam2/NOTICE
new file mode 100644
index 000000000..2dcb613fa
--- /dev/null
+++ b/crates/sam2/NOTICE
@@ -0,0 +1,11 @@
+EffectCraft SAM 2 (effectcraft-sam2)
+Copyright the EffectCraft contributors.
+
+This crate is a Rust port of the SAM 2 implementation in Hugging Face `transformers`
+(`models/sam2` and `models/sam2_video`), Copyright 2025 The HuggingFace Inc. team, which in turn
+implements "SAM 2: Segment Anything in Images and Videos" by Meta AI (facebookresearch/sam2).
+Both are licensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0).
+
+Each ported source file states that it is a modified work (Apache-2.0 section 4(b)).
+Model weights are not part of this crate; they are downloaded by the user from the official
+`facebook/sam2.1-hiera-*` repositories (Apache-2.0).
diff --git a/crates/sam2/examples/gpu_matmul.rs b/crates/sam2/examples/gpu_matmul.rs
new file mode 100644
index 000000000..1429ebf02
--- /dev/null
+++ b/crates/sam2/examples/gpu_matmul.rs
@@ -0,0 +1,164 @@
+//! A spike for the GPU path (plan phase 6): how fast is a plain tiled WGSL matrix multiply on this
+//! machine's GPU, against the candle CPU matmul the encoder uses today? Candle has no AMD/Vulkan
+//! backend; this measures what hand-written wgpu kernels could reach on the shapes SAM 2 needs.
+//!
+//! `cargo run --release -p effectcraft-sam2 --example gpu_matmul`
+
+use std::time::Instant;
+
+use candle_core::{Device, Tensor};
+use wgpu::util::DeviceExt;
+
+const SHADER: &str = r#"
+struct P { m: u32, n: u32, k: u32, pad: u32 }
+@group(0) @binding(0) var<storage, read> a: array<f32>;
+@group(0) @binding(1) var<storage, read> b: array<f32>;
+@group(0) @binding(2) var<storage, read_write> c: array<f32>;
+@group(0) @binding(3) var<uniform> p: P;
+var<workgroup> sa: array<f32, 1024>;
+var<workgroup> sb: array<f32, 1024>;
+@compute @workgroup_size(16, 16)
+fn main(@builtin(workgroup_id) wg: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let row0 = wg.y * 64u;
+    let col0 = wg.x * 64u;
+    let tid = li.y * 16u + li.x;
+    var acc: array<f32, 16>;
+    for (var i = 0u; i < 16u; i++) { acc[i] = 0.0; }
+    for (var kt = 0u; kt < p.k; kt += 16u) {
+        for (var i = 0u; i < 4u; i++) {
+            let idx = tid + i * 256u;
+            let r = idx / 16u;
+            let cc = idx % 16u;
+            let gr = row0 + r;
+            let gc = kt + cc;
+            var va = 0.0;
+            if (gr < p.m && gc < p.k) { va = a[gr * p.k + gc]; }
+            sa[idx] = va;
+            let r2 = idx / 64u;
+            let c2 = idx % 64u;
+            let gr2 = kt + r2;
+            let gc2 = col0 + c2;
+            var vb = 0.0;
+            if (gr2 < p.k && gc2 < p.n) { vb = b[gr2 * p.n + gc2]; }
+            sb[idx] = vb;
+        }
+        workgroupBarrier();
+        for (var kk = 0u; kk < 16u; kk++) {
+            var ar: array<f32, 4>;
+            var br: array<f32, 4>;
+            for (var i = 0u; i < 4u; i++) {
+                ar[i] = sa[(li.y * 4u + i) * 16u + kk];
+                br[i] = sb[kk * 64u + li.x * 4u + i];
+            }
+            for (var i = 0u; i < 4u; i++) {
+                for (var j = 0u; j < 4u; j++) { acc[i * 4u + j] += ar[i] * br[j]; }
+            }
+        }
+        workgroupBarrier();
+    }
+    for (var i = 0u; i < 4u; i++) {
+        for (var j = 0u; j < 4u; j++) {
+            let gr = row0 + li.y * 4u + i;
+            let gc = col0 + li.x * 4u + j;
+            if (gr < p.m && gc < p.n) { c[gr * p.n + gc] = acc[i * 4u + j]; }
+        }
+    }
+}
+"#;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+    let adapter = pollster::block_on(
+        instance.request_adapter(&wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, ..Default::default() }),
+    )?;
+    println!("adapter: {:?}", adapter.get_info().name);
+    let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor { required_limits: adapter.limits(), ..Default::default() }))?;
+    let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: None, source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
+    let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+        label: None,
+        layout: None,
+        module: &module,
+        entry_point: Some("main"),
+        compilation_options: Default::default(),
+        cache: None,
+    });
+    // (name, m, k, n): the matmul shapes of SAM 2's encoder and memory attention
+    let shapes = [
+        ("hiera block 0 qkv", 65536usize, 96usize, 288usize),
+        ("hiera block 0 mlp in", 65536, 96, 384),
+        ("hiera global attention q.kT (one head)", 4096, 96, 4096),
+        ("memory attention q.kT (full bank)", 4096, 256, 28736),
+    ];
+    for (name, m, k, n) in shapes {
+        let a = Tensor::randn(0f32, 1.0, (m, k), &Device::Cpu)?;
+        let b = Tensor::randn(0f32, 1.0, (k, n), &Device::Cpu)?;
+        let av = a.flatten_all()?.to_vec1::<f32>()?;
+        let bv = b.flatten_all()?.to_vec1::<f32>()?;
+        let ba = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: None,
+            contents: bytemuck::cast_slice(&av),
+            usage: wgpu::BufferUsages::STORAGE,
+        });
+        let bb = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: None,
+            contents: bytemuck::cast_slice(&bv),
+            usage: wgpu::BufferUsages::STORAGE,
+        });
+        let bc = device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: (m * n * 4) as u64,
+            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
+            mapped_at_creation: false,
+        });
+        let params = [m as u32, n as u32, k as u32, 0];
+        let bp = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: None,
+            contents: bytemuck::cast_slice(&params),
+            usage: wgpu::BufferUsages::UNIFORM,
+        });
+        let bg = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: None,
+            layout: &pipeline.get_bind_group_layout(0),
+            entries: &[
+                wgpu::BindGroupEntry { binding: 0, resource: ba.as_entire_binding() },
+                wgpu::BindGroupEntry { binding: 1, resource: bb.as_entire_binding() },
+                wgpu::BindGroupEntry { binding: 2, resource: bc.as_entire_binding() },
+                wgpu::BindGroupEntry { binding: 3, resource: bp.as_entire_binding() },
+            ],
+        });
+        let run = |reps: usize| {
+            let mut enc = device.create_command_encoder(&Default::default());
+            for _ in 0..reps {
+                let mut pass = enc.begin_compute_pass(&Default::default());
+                pass.set_pipeline(&pipeline);
+                pass.set_bind_group(0, &bg, &[]);
+                pass.dispatch_workgroups(n.div_ceil(64) as u32, m.div_ceil(64) as u32, 1);
+            }
+            queue.submit([enc.finish()]);
+            let _ = device.poll(wgpu::PollType::wait_indefinitely());
+        };
+        run(1);
+        let reps = 5;
+        let t = Instant::now();
+        run(reps);
+        let gpu = t.elapsed().as_secs_f64() / reps as f64;
+        let flops = 2.0 * m as f64 * k as f64 * n as f64;
+        // the CPU: candle's matmul, as the encoder uses it
+        let _ = a.matmul(&b)?;
+        let t = Instant::now();
+        let cpu_reps = 3;
+        for _ in 0..cpu_reps {
+            let _ = a.matmul(&b)?;
+        }
+        let cpu = t.elapsed().as_secs_f64() / cpu_reps as f64;
+        println!(
+            "{name:<42} gpu {:>7.1} ms ({:>6.0} GFLOPS)   cpu {:>7.1} ms ({:>5.0} GFLOPS)   x{:.1}",
+            gpu * 1e3,
+            flops / gpu / 1e9,
+            cpu * 1e3,
+            flops / cpu / 1e9,
+            cpu / gpu
+        );
+    }
+    Ok(())
+}
diff --git a/crates/sam2/examples/op_bench.rs b/crates/sam2/examples/op_bench.rs
new file mode 100644
index 000000000..4e2b5b4a3
--- /dev/null
+++ b/crates/sam2/examples/op_bench.rs
@@ -0,0 +1,68 @@
+//! Times the tensor operations a Hiera block is made of, at the sizes of its first (biggest) block.
+//! `cargo run --release -p effectcraft-sam2 --example op_bench`
+
+use std::time::Instant;
+
+use candle_core::{DType, Device, Tensor};
+use candle_nn::{Linear, Module};
+
+fn time<T>(name: &str, mut f: impl FnMut() -> T) {
+    let _ = f();
+    let n = 5;
+    let t = Instant::now();
+    for _ in 0..n {
+        let _ = f();
+    }
+    println!("{name:<44} {:>8.1} ms", t.elapsed().as_secs_f64() * 1e3 / n as f64);
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let d = Device::Cpu;
+    // block 0: 1 x 256 x 256 x 96 activations, windows of 8 x 8
+    let x = Tensor::randn(0f32, 1.0, (1, 256, 256, 96), &d)?;
+    let w = Tensor::randn(0f32, 0.1, (288, 96), &d)?;
+    let b = Tensor::zeros(288, DType::F32, &d)?;
+    let lin = Linear::new(w, Some(b));
+    let flat = x.reshape((65536, 96))?;
+    time("linear 65536x96 -> 288 (qkv)", || lin.forward(&flat).unwrap());
+    let big = Tensor::randn(0f32, 1.0, (65536, 384), &d)?;
+    time("gelu_erf on 65536 x 384", || big.gelu_erf().unwrap());
+    time("relu on 65536 x 384", || big.relu().unwrap());
+    time("add 65536 x 384", || (&big + &big).unwrap());
+    let xs = x.clone();
+    time("permute+contiguous (window partition)", || x.reshape((1, 32, 8, 32, 8, 96)).unwrap().permute((0, 1, 3, 2, 4, 5)).unwrap().contiguous().unwrap());
+    let lnw = Tensor::ones(96, DType::F32, &d)?;
+    let lnb = Tensor::zeros(96, DType::F32, &d)?;
+    time("fused layer_norm 256x256x96", || candle_nn::ops::layer_norm(&xs, &lnw, &lnb, 1e-6).unwrap());
+    // windowed attention: 1024 windows x 64 tokens x 96 dims, one head
+    let q = Tensor::randn(0f32, 1.0, (1024, 1, 64, 96), &d)?;
+    let kt = Tensor::randn(0f32, 1.0, (1024, 1, 96, 64), &d)?;
+    time("batched matmul 1024 x (64x96)(96x64)", || q.matmul(&kt).unwrap());
+    let sc = Tensor::randn(0f32, 1.0, (1024, 1, 64, 64), &d)?;
+    time("softmax_last_dim 1024x64x64", || candle_nn::ops::softmax_last_dim(&sc).unwrap());
+    let v = Tensor::randn(0f32, 1.0, (1024, 1, 64, 96), &d)?;
+    time("batched matmul 1024 x (64x64)(64x96)", || sc.matmul(&v).unwrap());
+    // the MLP matmuls
+    let w1 = Linear::new(Tensor::randn(0f32, 0.1, (384, 96), &d)?, Some(Tensor::zeros(384, DType::F32, &d)?));
+    time("linear 65536x96 -> 384 (mlp in)", || w1.forward(&flat).unwrap());
+    let w2 = Linear::new(Tensor::randn(0f32, 0.1, (96, 384), &d)?, Some(Tensor::zeros(96, DType::F32, &d)?));
+    time("linear 65536x384 -> 96 (mlp out)", || w2.forward(&big).unwrap());
+    // block 1 (the first stage change): pooling and the wide projections
+    let p1 = Tensor::randn(0f32, 1.0, (1, 192, 256, 256), &d)?;
+    time("max_pool2d 2x2 on 1 x 192 x 256 x 256", || p1.max_pool2d_with_stride(2, 2).unwrap());
+    let p2 = Tensor::randn(0f32, 1.0, (1024, 192, 8, 8), &d)?;
+    time("max_pool2d 2x2 on 1024 x 192 x 8 x 8", || p2.max_pool2d_with_stride(2, 2).unwrap());
+    let nhwc = Tensor::randn(0f32, 1.0, (1, 256, 256, 192), &d)?;
+    time("permute NHWC -> NCHW + contiguous (192ch)", || nhwc.permute((0, 3, 1, 2)).unwrap().contiguous().unwrap());
+    let w3 = Linear::new(Tensor::randn(0f32, 0.1, (192, 96), &d)?, Some(Tensor::zeros(192, DType::F32, &d)?));
+    time("linear 65536x96 -> 192 (block 1 proj)", || w3.forward(&flat).unwrap());
+    time("NHWC 2x2 max via reshape + max(2), max(3)", || nhwc.reshape((1, 128, 2, 128, 2, 192)).unwrap().max(2).unwrap().max(3).unwrap());
+    time("NHWC 2x2 max via two strided maxes of narrowed", || {
+        let a = nhwc.reshape((1, 128, 2, 256, 192)).unwrap();
+        let m = a.narrow(2, 0, 1).unwrap().maximum(&a.narrow(2, 1, 1).unwrap()).unwrap().squeeze(2).unwrap();
+        let b = m.reshape((1, 128, 128, 2, 192)).unwrap();
+        b.narrow(3, 0, 1).unwrap().maximum(&b.narrow(3, 1, 1).unwrap()).unwrap().squeeze(3).unwrap()
+    });
+    println!("threads: {}", std::thread::available_parallelism().map_or(1, |n| n.get()));
+    Ok(())
+}
diff --git a/crates/sam2/examples/sam2_bench.rs b/crates/sam2/examples/sam2_bench.rs
new file mode 100644
index 000000000..0b51dd668
--- /dev/null
+++ b/crates/sam2/examples/sam2_bench.rs
@@ -0,0 +1,126 @@
+//! Timing of the SAM 2 image path on this machine: load, encode one frame, decode a click.
+//!
+//! `cargo run -p effectcraft-sam2 --example sam2_bench -- [MODEL_DIR]` (default `sam2-tiny`).
+//! Prints a message and exits when the weights are not there.
+
+use std::time::Instant;
+
+use candle_core::{DType, Device, Tensor};
+use effectcraft_sam2::model::ImageModel;
+use effectcraft_sam2::prompt::Prompt;
+
+fn main() {
+    if let Err(e) = run() {
+        eprintln!("sam2_bench: {e}");
+        std::process::exit(1);
+    }
+}
+
+fn run() -> Result<(), Box<dyn std::error::Error>> {
+    let dir = std::env::args().nth(1).unwrap_or_else(|| "sam2-tiny".to_string());
+    let file = std::path::Path::new(&dir).join("model.safetensors");
+    if !file.exists() {
+        println!("no weights at {} (download facebook/sam2.1-hiera-tiny first)", file.display());
+        return Ok(());
+    }
+    let t = Instant::now();
+    let model = ImageModel::open(&file)?;
+    println!("load: {:.2} s", t.elapsed().as_secs_f64());
+    let pixels = Tensor::randn(0f32, 1.0, (1, 3, 1024, 1024), &Device::Cpu)?.to_dtype(DType::F32)?;
+    for run in 0..3 {
+        let t = Instant::now();
+        let enc = model.encode(&pixels)?;
+        let encode = t.elapsed().as_secs_f64();
+        let prompt = Prompt { points: vec![([512.0, 512.0], true)], bbox: None };
+        let t = Instant::now();
+        let out = model.segment(&enc, &prompt, true)?;
+        println!("run {run}: encode {encode:.2} s, click {:.0} ms, masks {:?}", t.elapsed().as_secs_f64() * 1e3, out.masks.dims());
+    }
+    // Where the encode time goes: patch embedding, then each Hiera block.
+    let hiera = &model.vision.hiera;
+    let t = Instant::now();
+    let mut x = hiera.patch_embed(&pixels)?;
+    println!("patch embed: {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
+    for (i, b) in hiera.blocks.iter().enumerate() {
+        let t = Instant::now();
+        x = b.forward(&x)?;
+        println!("block {i}: {:.0} ms, out {:?}", t.elapsed().as_secs_f64() * 1e3, x.dims());
+    }
+    // The rest of the encode: the neck (1x1 convolutions, top-down sums) and its sine position encodings.
+    let stages = hiera.forward(&pixels)?;
+    let t = Instant::now();
+    let _ = model.vision.neck.forward(&stages)?;
+    println!("neck (convolutions + positions): {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
+    let t = Instant::now();
+    for (h, w) in [(32, 32), (64, 64), (128, 128), (256, 256)] {
+        let _ = effectcraft_sam2::neck::sine_position(128, h, w)?;
+    }
+    println!("sine positions for the four levels: {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
+    // What a tracked frame adds to the encode: memory attention over the memory bank (7 memory frames and
+    // 16 object pointers of 4 tokens), then the memory encoder.
+    let weights = effectcraft_sam2::weights::Weights::open(&file)?;
+    let attn = effectcraft_sam2::memattn::MemoryAttention::load(&weights)?;
+    let cur = Tensor::randn(0f32, 1.0, (4096, 256), &Device::Cpu)?;
+    let cur_pos = Tensor::randn(0f32, 1.0, (4096, 256), &Device::Cpu)?;
+    let m = 7 * 4096 + 64;
+    let mem = Tensor::randn(0f32, 1.0, (m, 64), &Device::Cpu)?;
+    let mem_pos = Tensor::randn(0f32, 1.0, (m, 64), &Device::Cpu)?;
+    for run in 0..2 {
+        let t = Instant::now();
+        let _ = attn.forward(&cur, &cur_pos, &mem, &mem_pos, 64)?;
+        println!("memory attention (run {run}, {m} memory tokens): {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
+    }
+    // The same two costs on the GPU (wgpu kernels), when there is one.
+    match effectcraft_sam2::gpu::Gpu::shared() {
+        Ok(gpu) => {
+            println!("GPU: {}", gpu.adapter_name());
+            let enc = effectcraft_sam2::gpu::encoder::GpuEncoder::load(gpu.clone(), &weights, model.vision.hiera.clone())?;
+            let gattn = effectcraft_sam2::gpu::memattn::GpuMemoryAttention::load(gpu, &weights)?;
+            for run in 0..3 {
+                let t = Instant::now();
+                let _ = enc.encode(&pixels)?;
+                let encode = t.elapsed().as_secs_f64() * 1e3;
+                let t = Instant::now();
+                let _ = gattn.forward(&cur, &cur_pos, &mem, &mem_pos, 64)?;
+                println!("GPU run {run}: encode {encode:.0} ms, memory attention (full bank) {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
+            }
+        }
+        Err(e) => println!("no GPU: {e}"),
+    }
+    // A whole tracked frame (encode, memory attention, decode, memory encoding) through the video session, on each backend.
+    struct Same(Tensor);
+    impl effectcraft_sam2::session::FrameSource for Same {
+        fn num_frames(&self) -> usize {
+            12
+        }
+        fn frame(&self, _i: usize) -> effectcraft_sam2::Result<Tensor> {
+            Ok(self.0.clone())
+        }
+    }
+    for backend in [effectcraft_sam2::session::Backend::Cpu, effectcraft_sam2::session::Backend::Gpu] {
+        let Ok(vm) = effectcraft_sam2::session::VideoModel::load_with(&weights, backend) else { continue };
+        let vm = std::sync::Arc::new(vm);
+        let mut tracker = effectcraft_sam2::session::VideoTracker::new(vm.clone(), Box::new(Same(pixels.clone())))?;
+        let obj = effectcraft_sam2::session::ObjectId(1);
+        let t = Instant::now();
+        tracker.prompt(0, obj, &Prompt { points: vec![([512.0, 512.0], true)], bbox: None })?;
+        println!("{:?} ({}): prompt frame {:.0} ms", backend, vm.device_name(), t.elapsed().as_secs_f64() * 1e3);
+        let mut last = Instant::now();
+        let mut times = vec![];
+        tracker.propagate(0, effectcraft_sam2::session::Direction::Forward, None, &effectcraft_sam2::session::Cancel::new(), &mut |m| {
+            if m.frame > 0 {
+                times.push(last.elapsed().as_secs_f64() * 1e3);
+            }
+            last = Instant::now();
+        })?;
+        println!(
+            "{:?}: tracked frames {:.0} ms each (first {:.0}, last {:.0})",
+            backend,
+            times.iter().sum::<f64>() / times.len().max(1) as f64,
+            times.first().copied().unwrap_or(0.0),
+            times.last().copied().unwrap_or(0.0)
+        );
+    }
+    println!("threads: {}", std::thread::available_parallelism().map_or(1, |n| n.get()));
+    Ok(())
+}
diff --git a/crates/sam2/src/decoder.rs b/crates/sam2/src/decoder.rs
new file mode 100644
index 000000000..d6b25a7e4
--- /dev/null
+++ b/crates/sam2/src/decoder.rs
@@ -0,0 +1,260 @@
+// Modified work: ported from Hugging Face `transformers` `models/sam2/modeling_sam2.py`
+// (Sam2Attention, Sam2TwoWayAttentionBlock, Sam2TwoWayTransformer, Sam2MaskDecoder; Apache-2.0,
+// Copyright The HuggingFace Inc. team) to Rust on candle. See NOTICE.
+//! The two-way mask decoder: output tokens and prompt tokens attend to the image and back, then
+//! hyper-networks turn the mask tokens into masks over the up-scaled image embedding.
+//! One object per call (batch 1, one point batch).
+
+use candle_core::{D, Tensor};
+use candle_nn::{Linear, ops::sigmoid, ops::softmax};
+
+use crate::nn::{LayerNorm, apply, gelu, layer_norm, linear};
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+const DIM: usize = 256;
+const MASK_TOKENS: usize = 4;
+
+struct Attention {
+    q: Linear,
+    k: Linear,
+    v: Linear,
+    o: Linear,
+    heads: usize,
+    scale: f64,
+}
+
+impl Attention {
+    fn load(w: &Weights, prefix: &str, downsample: usize, heads: usize) -> Result<Attention> {
+        let inner = DIM / downsample;
+        Ok(Attention {
+            q: linear(w, &format!("{prefix}.q_proj"), DIM, inner)?,
+            k: linear(w, &format!("{prefix}.k_proj"), DIM, inner)?,
+            v: linear(w, &format!("{prefix}.v_proj"), DIM, inner)?,
+            o: linear(w, &format!("{prefix}.o_proj"), inner, DIM)?,
+            heads,
+            scale: ((inner / heads) as f64).powf(-0.5),
+        })
+    }
+
+    /// `q`: `[1, nq, 256]`, `k` and `v`: `[1, nk, 256]`.
+    fn forward(&self, q: &Tensor, k: &Tensor, v: &Tensor) -> Result<Tensor> {
+        let split = |t: Tensor| -> Result<Tensor> { Ok(t.reshape((1, (), self.heads, t.dim(2)? / self.heads))?.transpose(1, 2)?.contiguous()?) };
+        let (q, k, v) = (split(apply(&self.q, q)?)?, split(apply(&self.k, k)?)?, split(apply(&self.v, v)?)?);
+        let att = softmax(&(q.matmul(&k.transpose(2, 3)?.contiguous()?)? * self.scale)?, D::Minus1)?;
+        let out = att.matmul(&v)?.transpose(1, 2)?.contiguous()?;
+        let (n, h, d) = (out.dim(1)?, out.dim(2)?, out.dim(3)?);
+        apply(&self.o, &out.reshape((1, n, h * d))?)
+    }
+}
+
+/// Feed-forward with ReLU, `Sam2FeedForward`: `proj_in`, `layers`, `proj_out`.
+pub struct FeedForward {
+    proj_in: Linear,
+    layers: Vec<Linear>,
+    proj_out: Linear,
+    sigmoid_output: bool,
+}
+
+impl FeedForward {
+    pub fn load(w: &Weights, prefix: &str, input: usize, hidden: usize, output: usize, num_layers: usize, sigmoid_output: bool) -> Result<FeedForward> {
+        Ok(FeedForward {
+            proj_in: linear(w, &format!("{prefix}.proj_in"), input, hidden)?,
+            layers: (0..num_layers.saturating_sub(2)).map(|i| linear(w, &format!("{prefix}.layers.{i}"), hidden, hidden)).collect::<Result<_>>()?,
+            proj_out: linear(w, &format!("{prefix}.proj_out"), hidden, output)?,
+            sigmoid_output,
+        })
+    }
+
+    pub fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        let mut x = apply(&self.proj_in, x)?.relu()?;
+        for l in &self.layers {
+            x = apply(l, &x)?.relu()?;
+        }
+        let x = apply(&self.proj_out, &x)?;
+        Ok(if self.sigmoid_output { sigmoid(&x)? } else { x })
+    }
+}
+
+struct Block {
+    self_attn: Attention,
+    ln1: LayerNorm,
+    token_to_image: Attention,
+    ln2: LayerNorm,
+    mlp: FeedForward,
+    ln3: LayerNorm,
+    ln4: LayerNorm,
+    image_to_token: Attention,
+    skip_first_pe: bool,
+}
+
+impl Block {
+    fn forward(&self, queries: &Tensor, keys: &Tensor, query_pe: &Tensor, key_pe: &Tensor) -> Result<(Tensor, Tensor)> {
+        let mut queries = if self.skip_first_pe {
+            self.self_attn.forward(queries, queries, queries)?
+        } else {
+            let q = (queries + query_pe)?;
+            (queries + self.self_attn.forward(&q, &q, queries)?)?
+        };
+        queries = self.ln1.forward(&queries)?;
+        let (q, k) = ((&queries + query_pe)?, (keys + key_pe)?);
+        queries = self.ln2.forward(&(&queries + self.token_to_image.forward(&q, &k, keys)?)?)?;
+        queries = self.ln3.forward(&(&queries + self.mlp.forward(&queries)?)?)?;
+        let (q, k) = ((&queries + query_pe)?, (keys + key_pe)?);
+        let keys = self.ln4.forward(&(keys + self.image_to_token.forward(&k, &q, &queries)?)?)?;
+        Ok((queries, keys))
+    }
+}
+
+/// What the decoder returns for one object.
+pub struct DecoderOutput {
+    /// Mask logits `[1, k, 4 * GRID, 4 * GRID]` (`k` is 3 for multimask output, else 1).
+    pub masks: Tensor,
+    /// Predicted IoU per mask `[1, k]`.
+    pub iou: Tensor,
+    /// The output tokens of the chosen masks `[1, k, 256]` (the object pointer is made from these).
+    pub sam_tokens: Tensor,
+    /// Object-presence logit `[1, 1]` (negative: the object is not in the frame).
+    pub object_score: Tensor,
+}
+
+pub struct MaskDecoder {
+    obj_token: Tensor,
+    iou_token: Tensor,
+    mask_tokens: Tensor,
+    layers: Vec<Block>,
+    final_attn: Attention,
+    final_ln: LayerNorm,
+    up1: (Tensor, Tensor),
+    up2: (Tensor, Tensor),
+    up_ln: LayerNorm,
+    conv_s0: (Tensor, Tensor),
+    conv_s1: (Tensor, Tensor),
+    hyper: Vec<FeedForward>,
+    iou_head: FeedForward,
+    obj_head: FeedForward,
+}
+
+fn conv_w(w: &Weights, name: &str, i: usize, o: usize, k: usize, transposed: bool) -> Result<(Tensor, Tensor)> {
+    let shape = if transposed { [i, o, k, k] } else { [o, i, k, k] };
+    Ok((w.get(&format!("{name}.weight"), &shape)?, w.get(&format!("{name}.bias"), &[o])?))
+}
+
+fn add_bias(x: Tensor, b: &Tensor) -> Result<Tensor> {
+    Ok(x.broadcast_add(&b.reshape((1, b.dim(0)?, 1, 1))?)?)
+}
+
+impl MaskDecoder {
+    pub fn load(w: &Weights) -> Result<MaskDecoder> {
+        let layers = (0..2)
+            .map(|i| {
+                let p = format!("mask_decoder.transformer.layers.{i}");
+                Ok(Block {
+                    self_attn: Attention::load(w, &format!("{p}.self_attn"), 1, 8)?,
+                    ln1: layer_norm(w, &format!("{p}.layer_norm1"), DIM, 1e-5)?,
+                    token_to_image: Attention::load(w, &format!("{p}.cross_attn_token_to_image"), 2, 8)?,
+                    ln2: layer_norm(w, &format!("{p}.layer_norm2"), DIM, 1e-5)?,
+                    mlp: FeedForward::load(w, &format!("{p}.mlp"), DIM, 2048, DIM, 2, false)?,
+                    ln3: layer_norm(w, &format!("{p}.layer_norm3"), DIM, 1e-5)?,
+                    ln4: layer_norm(w, &format!("{p}.layer_norm4"), DIM, 1e-5)?,
+                    image_to_token: Attention::load(w, &format!("{p}.cross_attn_image_to_token"), 2, 8)?,
+                    skip_first_pe: i == 0,
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+        Ok(MaskDecoder {
+            obj_token: w.get("mask_decoder.obj_score_token.weight", &[1, DIM])?,
+            iou_token: w.get("mask_decoder.iou_token.weight", &[1, DIM])?,
+            mask_tokens: w.get("mask_decoder.mask_tokens.weight", &[MASK_TOKENS, DIM])?,
+            layers,
+            final_attn: Attention::load(w, "mask_decoder.transformer.final_attn_token_to_image", 2, 8)?,
+            final_ln: layer_norm(w, "mask_decoder.transformer.layer_norm_final_attn", DIM, 1e-5)?,
+            up1: conv_w(w, "mask_decoder.upscale_conv1", DIM, DIM / 4, 2, true)?,
+            up2: conv_w(w, "mask_decoder.upscale_conv2", DIM / 4, DIM / 8, 2, true)?,
+            up_ln: layer_norm(w, "mask_decoder.upscale_layer_norm", DIM / 4, 1e-6)?,
+            conv_s0: conv_w(w, "mask_decoder.conv_s0", DIM, DIM / 8, 1, false)?,
+            conv_s1: conv_w(w, "mask_decoder.conv_s1", DIM, DIM / 4, 1, false)?,
+            hyper: (0..MASK_TOKENS)
+                .map(|i| FeedForward::load(w, &format!("mask_decoder.output_hypernetworks_mlps.{i}"), DIM, DIM, DIM / 8, 3, false))
+                .collect::<Result<_>>()?,
+            iou_head: FeedForward::load(w, "mask_decoder.iou_prediction_head", DIM, DIM, MASK_TOKENS, 3, true)?,
+            obj_head: FeedForward::load(w, "mask_decoder.pred_obj_score_head", DIM, DIM, 1, 3, false)?,
+        })
+    }
+
+    /// Project the two highest-resolution neck levels to the decoder's skip features
+    /// (`conv_s0` on the 4x level, `conv_s1` on the 2x level), `[1, 32, 4g, 4g]` and `[1, 64, 2g, 2g]`.
+    pub fn high_res(&self, level0: &Tensor, level1: &Tensor) -> Result<(Tensor, Tensor)> {
+        let s0 = add_bias(level0.conv2d(&self.conv_s0.0, 0, 1, 1, 1)?, &self.conv_s0.1)?;
+        let s1 = add_bias(level1.conv2d(&self.conv_s1.0, 0, 1, 1, 1)?, &self.conv_s1.1)?;
+        Ok((s0, s1))
+    }
+
+    /// Predict masks. `image` and `pos`: `[1, 256, g, g]` (the lowest-resolution level with the
+    /// no-memory embedding already added when there is no memory), `sparse`: `[1, n, 256]`,
+    /// `dense`: `[1, 256, g, g]`, `high`: the skip features from [`MaskDecoder::high_res`].
+    pub fn forward(&self, image: &Tensor, pos: &Tensor, sparse: &Tensor, dense: &Tensor, high: &(Tensor, Tensor), multimask: bool) -> Result<DecoderOutput> {
+        let (_, c, g, gw) = image.dims4()?;
+        if c != DIM || g != gw {
+            return Err(Error::Input(format!("image embedding must be 256 x g x g, got {:?}", image.dims())));
+        }
+        let output_tokens = Tensor::cat(&[&self.obj_token, &self.iou_token, &self.mask_tokens], 0)?.unsqueeze(0)?;
+        let tokens = Tensor::cat(&[&output_tokens, sparse], 1)?;
+        let image = (image + dense)?;
+        let flat = |t: &Tensor| -> Result<Tensor> { Ok(t.flatten_from(2)?.transpose(1, 2)?.contiguous()?) };
+        let (mut keys, key_pe) = (flat(&image)?, flat(pos)?);
+        let mut queries = tokens.clone();
+        for l in &self.layers {
+            (queries, keys) = l.forward(&queries, &keys, &tokens, &key_pe)?;
+        }
+        let (q, k) = ((&queries + &tokens)?, (&keys + &key_pe)?);
+        let queries = self.final_ln.forward(&(&queries + self.final_attn.forward(&q, &k, &keys)?)?)?;
+
+        let iou_out = queries.narrow(1, 1, 1)?.squeeze(1)?;
+        let mask_tokens_out = queries.narrow(1, 2, MASK_TOKENS)?;
+        let obj_out = queries.narrow(1, 0, 1)?.squeeze(1)?;
+
+        let emb = keys.transpose(1, 2)?.contiguous()?.reshape((1, DIM, g, g))?;
+        let (s0, s1) = high;
+        let up = add_bias(emb.conv_transpose2d(&self.up1.0, 0, 0, 2, 1)?, &self.up1.1)?;
+        let up = (up + s1)?;
+        let up = self.up_ln.forward(&up.permute((0, 2, 3, 1))?)?.permute((0, 3, 1, 2))?.contiguous()?;
+        let up = gelu(&up)?;
+        let up = (add_bias(up.conv_transpose2d(&self.up2.0, 0, 0, 2, 1)?, &self.up2.1)? + s0)?;
+        let up = gelu(&up)?;
+
+        let hyper: Vec<Tensor> = self.hyper.iter().enumerate().map(|(i, m)| m.forward(&mask_tokens_out.narrow(1, i, 1)?.squeeze(1)?)).collect::<Result<_>>()?;
+        let hyper = Tensor::stack(&hyper, 1)?;
+        let (_, uc, uh, uw) = up.dims4()?;
+        let masks = hyper.matmul(&up.reshape((1, uc, uh * uw))?)?.reshape((1, MASK_TOKENS, uh, uw))?;
+        let iou = self.iou_head.forward(&iou_out)?;
+        let object_score = self.obj_head.forward(&obj_out)?;
+
+        let (masks, iou, sam_tokens) = if multimask {
+            (masks.narrow(1, 1, 3)?, iou.narrow(1, 1, 3)?, mask_tokens_out.narrow(1, 1, 3)?)
+        } else {
+            let (m, i) = dynamic_single(&masks, &iou)?;
+            (m, i, mask_tokens_out.narrow(1, 0, 1)?)
+        };
+        Ok(DecoderOutput { masks, iou, sam_tokens, object_score })
+    }
+}
+
+/// Single-mask output with the stability fallback (`_dynamic_multimask_via_stability`): if the
+/// first mask token's mask is unstable, use the best of the other three.
+fn dynamic_single(masks: &Tensor, iou: &Tensor) -> Result<(Tensor, Tensor)> {
+    const DELTA: f32 = 0.05;
+    const THRESH: f32 = 0.98;
+    let single = masks.narrow(1, 0, 1)?;
+    let single_iou = iou.narrow(1, 0, 1)?;
+    let logits = single.flatten_all()?.to_vec1::<f32>()?;
+    let area_i = logits.iter().filter(|v| **v > DELTA).count() as f32;
+    let area_u = logits.iter().filter(|v| **v > -DELTA).count() as f32;
+    let stability = if area_u > 0.0 { area_i / area_u } else { 1.0 };
+    if stability >= THRESH {
+        return Ok((single, single_iou));
+    }
+    let multi_iou = iou.narrow(1, 1, 3)?.flatten_all()?.to_vec1::<f32>()?;
+    let best = multi_iou.iter().enumerate().fold((0usize, f32::NEG_INFINITY), |b, (i, v)| if *v > b.1 { (i, *v) } else { b }).0;
+    Ok((masks.narrow(1, 1 + best, 1)?, iou.narrow(1, 1 + best, 1)?))
+}
diff --git a/crates/sam2/src/gpu.rs b/crates/sam2/src/gpu.rs
new file mode 100644
index 000000000..bc83b605f
--- /dev/null
+++ b/crates/sam2/src/gpu.rs
@@ -0,0 +1,471 @@
+// Original work for EffectCraft (wgpu compute kernels); the maths follows the Hugging Face
+// `transformers` SAM 2 implementation (Apache-2.0, see NOTICE).
+//! An optional GPU path for the heavy parts of SAM 2 (the Hiera backbone, the neck and the memory
+//! attention), as wgpu compute kernels: it runs on AMD, NVIDIA and Intel alike, where candle has
+//! no backend for the first. The CPU path stays the reference: every kernel is tested against it,
+//! and any GPU failure (no adapter, an out-of-memory error, a lost device) is an `Err` the caller
+//! answers by running the CPU path.
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex, PoisonError};
+
+use wgpu::util::DeviceExt;
+
+use crate::{Error, Result};
+
+const SHADER: &str = concat!(include_str!("gpu/kernels.wgsl"), include_str!("gpu/kernels_ops.wgsl"));
+/// Words in a kernel's parameter block.
+const PARAM_WORDS: usize = 24;
+
+/// A buffer of f32 on the GPU (cheap to clone: it is a handle).
+#[derive(Clone)]
+pub struct Buf {
+    pub(crate) buffer: wgpu::Buffer,
+    /// Elements (f32).
+    pub len: usize,
+    /// Two half-precision values per 32-bit word (a weight matrix only; `len` still counts values).
+    pub(crate) f16: bool,
+}
+
+/// One strided matrix operand: `(offset, batch stride, row stride, column stride)` in elements.
+#[derive(Clone, Copy, Debug)]
+pub struct Strides {
+    pub offset: usize,
+    pub batch: usize,
+    pub row: usize,
+    pub col: usize,
+}
+
+impl Strides {
+    /// A row-major `[rows, cols]` matrix (one batch).
+    pub fn row_major(cols: usize) -> Strides {
+        Strides { offset: 0, batch: 0, row: cols, col: 1 }
+    }
+}
+
+/// What to do to a matrix product after the multiplication.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub enum Act {
+    #[default]
+    None,
+    Gelu,
+    Relu,
+}
+
+/// A batched matrix product `C[b] = act(alpha * A[b] . B[b] + bias) (+ residual)`.
+pub struct Matmul<'a> {
+    pub m: usize,
+    pub n: usize,
+    pub k: usize,
+    pub batch: usize,
+    pub a: (&'a Buf, Strides),
+    pub b: (&'a Buf, Strides),
+    pub bias: Option<&'a Buf>,
+    pub c: (&'a Buf, Strides),
+    pub residual: Option<&'a Buf>,
+    pub alpha: f32,
+    pub act: Act,
+}
+
+/// The GPU device and its compiled kernels.
+pub struct Gpu {
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    module: wgpu::ShaderModule,
+    pipelines: Mutex<HashMap<&'static str, Arc<wgpu::ComputePipeline>>>,
+    encoder: Mutex<Option<wgpu::CommandEncoder>>,
+    turn: Mutex<()>,
+    error: Arc<Mutex<Option<String>>>,
+    adapter: String,
+}
+
+fn words(v: &[u32]) -> [u32; PARAM_WORDS] {
+    let mut out = [0u32; PARAM_WORDS];
+    for (o, x) in out.iter_mut().zip(v) {
+        *o = *x;
+    }
+    out
+}
+
+fn u32_of(v: usize, what: &str) -> Result<u32> {
+    u32::try_from(v).map_err(|_| Error::Compute(format!("{what} {v} does not fit a GPU index")))
+}
+
+/// Whether weight matrices are kept on the GPU in half precision (`EFFECTCRAFT_SAM2_F16=1`).
+pub fn half_weights() -> bool {
+    std::env::var("EFFECTCRAFT_SAM2_F16").is_ok_and(|v| matches!(v.trim(), "1" | "on" | "true"))
+}
+
+/// The process's one GPU device, once something has asked for it.
+static DEVICE: std::sync::OnceLock<std::result::Result<Arc<Gpu>, String>> = std::sync::OnceLock::new();
+
+impl Gpu {
+    /// The process's one GPU device, created on first use. Several devices at once upset some Vulkan loaders
+    /// (a crash when two threads create or drop them together), and one is all SAM 2 needs: models come and go,
+    /// the device stays. An error (no GPU) is remembered too.
+    pub fn shared() -> Result<Arc<Gpu>> {
+        DEVICE.get_or_init(|| Gpu::new().map(Arc::new).map_err(|e| e.to_string())).clone().map_err(Error::Compute)
+    }
+
+    /// Whether the shared device has been looked for yet, and found: `None` before anything has asked
+    /// for it (this never creates it, so a caller that only wants to describe the GPU does not stall
+    /// on the adapter and shader compilation), then `Some(true)` or `Some(false)` (no GPU).
+    pub fn probe() -> Option<bool> {
+        DEVICE.get().map(|d| d.is_ok())
+    }
+
+    /// A device on the best real GPU (a software adapter is refused: the CPU path is faster).
+    fn new() -> Result<Gpu> {
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+        let adapter = pollster::block_on(
+            instance.request_adapter(&wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, ..Default::default() }),
+        )
+        .map_err(|e| Error::Compute(format!("no GPU adapter: {e}")))?;
+        let info = adapter.get_info();
+        if info.device_type == wgpu::DeviceType::Cpu {
+            return Err(Error::Compute(format!("only a software adapter ({}) is available", info.name)));
+        }
+        let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
+            label: Some("effectcraft sam2"),
+            required_limits: adapter.limits(),
+            ..Default::default()
+        }))
+        .map_err(|e| Error::Compute(format!("no GPU device: {e}")))?;
+        let error: Arc<Mutex<Option<String>>> = Arc::default();
+        let sink = error.clone();
+        device.on_uncaptured_error(Arc::new(move |e| {
+            log::error!("sam2 gpu: {e}");
+            sink.lock().unwrap_or_else(PoisonError::into_inner).get_or_insert_with(|| e.to_string());
+        }));
+        let sink = error.clone();
+        device.set_device_lost_callback(move |reason, message| {
+            sink.lock().unwrap_or_else(PoisonError::into_inner).get_or_insert_with(|| format!("GPU device lost ({reason:?}): {message}"));
+        });
+        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("sam2 kernels"), source: wgpu::ShaderSource::Wgsl(SHADER.into()) });
+        Ok(Gpu { device, queue, module, pipelines: Mutex::default(), encoder: Mutex::new(None), turn: Mutex::new(()), error, adapter: info.name })
+    }
+
+    /// One GPU pass at a time: a caller holds this while it queues, flushes and reads back a whole job, so
+    /// two threads never interleave their dispatches in one command stream.
+    pub fn exclusive(&self) -> std::sync::MutexGuard<'_, ()> {
+        self.turn.lock().unwrap_or_else(PoisonError::into_inner)
+    }
+
+    pub fn adapter_name(&self) -> &str {
+        &self.adapter
+    }
+
+    fn take_error(&self) -> Result<()> {
+        match self.error.lock().unwrap_or_else(PoisonError::into_inner).take() {
+            Some(e) => Err(Error::Compute(format!("GPU: {e}"))),
+            None => Ok(()),
+        }
+    }
+
+    pub fn upload(&self, data: &[f32]) -> Buf {
+        // `write_buffer` instead of a mapped-at-creation buffer: on a lost or out-of-memory device the latter panics inside wgpu,
+        // while this records the error for `take_error`.
+        let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: (data.len().max(1) as u64) * 4,
+            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        if !data.is_empty() {
+            self.queue.write_buffer(&buffer, 0, bytemuck::cast_slice(data));
+        }
+        Buf { buffer, len: data.len(), f16: false }
+    }
+
+    /// A weight matrix: stored as half precision (half the memory) when `EFFECTCRAFT_SAM2_F16` asks for it and every
+    /// value fits, as f32 otherwise.
+    pub fn upload_weights(&self, data: &[f32]) -> Buf {
+        if !half_weights() || data.is_empty() || data.iter().any(|v| v.abs() > 60_000.0) {
+            return self.upload(data);
+        }
+        self.upload_f16(data)
+    }
+
+    /// `data` as half precision, two values per word.
+    pub(crate) fn upload_f16(&self, data: &[f32]) -> Buf {
+        let words: Vec<u32> = data
+            .chunks(2)
+            .map(|p| {
+                let lo = half::f16::from_f32(p.first().copied().unwrap_or(0.0)).to_bits();
+                let hi = half::f16::from_f32(p.get(1).copied().unwrap_or(0.0)).to_bits();
+                u32::from(lo) | (u32::from(hi) << 16)
+            })
+            .collect();
+        let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: (words.len() as u64) * 4,
+            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        self.queue.write_buffer(&buffer, 0, bytemuck::cast_slice(&words));
+        Buf { buffer, len: data.len(), f16: true }
+    }
+
+    /// A zeroed buffer of `len` elements.
+    pub fn zeros(&self, len: usize) -> Result<Buf> {
+        let bytes = (len.max(1) as u64).checked_mul(4).ok_or_else(|| Error::Budget("GPU buffer size overflows".into()))?;
+        if bytes > self.device.limits().max_buffer_size || bytes > self.device.limits().max_storage_buffer_binding_size {
+            return Err(Error::Budget(format!("a {} MB GPU buffer is over this GPU's limit", bytes >> 20)));
+        }
+        let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: bytes,
+            usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        Ok(Buf { buffer, len, f16: false })
+    }
+
+    fn pipeline(&self, entry: &'static str) -> Arc<wgpu::ComputePipeline> {
+        let mut map = self.pipelines.lock().unwrap_or_else(PoisonError::into_inner);
+        map.entry(entry)
+            .or_insert_with(|| {
+                Arc::new(self.device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+                    label: Some(entry),
+                    layout: None,
+                    module: &self.module,
+                    entry_point: Some(entry),
+                    compilation_options: Default::default(),
+                    cache: None,
+                }))
+            })
+            .clone()
+    }
+
+    /// Queue one dispatch of `entry`. `bindings` are the kernel's buffers by binding index.
+    pub(crate) fn run(&self, entry: &'static str, bindings: &[(u32, &Buf)], params: &[u32], groups: (u32, u32, u32)) {
+        let pipeline = self.pipeline(entry);
+        let uniform = self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: None,
+            contents: bytemuck::cast_slice(&words(params)),
+            usage: wgpu::BufferUsages::UNIFORM,
+        });
+        let mut entries: Vec<wgpu::BindGroupEntry<'_>> =
+            bindings.iter().map(|(i, b)| wgpu::BindGroupEntry { binding: *i, resource: b.buffer.as_entire_binding() }).collect();
+        entries.push(wgpu::BindGroupEntry { binding: 5, resource: uniform.as_entire_binding() });
+        let group = self.device.create_bind_group(&wgpu::BindGroupDescriptor { label: None, layout: &pipeline.get_bind_group_layout(0), entries: &entries });
+        let mut slot = self.encoder.lock().unwrap_or_else(PoisonError::into_inner);
+        let enc = slot.get_or_insert_with(|| self.device.create_command_encoder(&Default::default()));
+        let mut pass = enc.begin_compute_pass(&Default::default());
+        pass.set_pipeline(&pipeline);
+        pass.set_bind_group(0, &group, &[]);
+        pass.dispatch_workgroups(groups.0, groups.1, groups.2);
+    }
+
+    /// Submit what is queued and wait for it to finish.
+    pub fn flush(&self) -> Result<()> {
+        let enc = self.encoder.lock().unwrap_or_else(PoisonError::into_inner).take();
+        if let Some(enc) = enc {
+            self.queue.submit([enc.finish()]);
+        }
+        let _ = self.device.poll(wgpu::PollType::wait_indefinitely());
+        self.take_error()
+    }
+
+    /// Copy a buffer back to the CPU (after submitting everything queued).
+    pub fn download(&self, buf: &Buf) -> Result<Vec<f32>> {
+        let bytes = buf.len as u64 * 4;
+        if bytes == 0 {
+            return Ok(vec![]);
+        }
+        let staging = self.device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: bytes,
+            usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        let mut enc =
+            self.encoder.lock().unwrap_or_else(PoisonError::into_inner).take().unwrap_or_else(|| self.device.create_command_encoder(&Default::default()));
+        enc.copy_buffer_to_buffer(&buf.buffer, 0, &staging, 0, bytes);
+        self.queue.submit([enc.finish()]);
+        let (tx, rx) = std::sync::mpsc::channel();
+        staging.map_async(wgpu::MapMode::Read, .., move |r| {
+            let _ = tx.send(r);
+        });
+        let _ = self.device.poll(wgpu::PollType::wait_indefinitely());
+        self.take_error()?;
+        rx.recv().map_err(|_| Error::Compute("GPU readback never completed".into()))?.map_err(|e| Error::Compute(format!("GPU readback: {e}")))?;
+        let out = {
+            let view = staging.get_mapped_range(..).map_err(|e| Error::Compute(format!("GPU readback: {e}")))?;
+            bytemuck::cast_slice::<u8, f32>(&view).to_vec()
+        };
+        staging.unmap();
+        Ok(out)
+    }
+
+    /// Queue `C[b] = act(alpha * A[b] . B[b] + bias) (+ residual)`.
+    pub fn matmul(&self, op: &Matmul<'_>) -> Result<()> {
+        let (a, sa) = op.a;
+        let (b, sb) = op.b;
+        let (c, sc) = op.c;
+        if op.m == 0 || op.n == 0 || op.batch == 0 {
+            return Ok(());
+        }
+        if sc.col != 1 {
+            return Err(Error::Input(format!("matmul output needs a column stride of 1, got {}", sc.col)));
+        }
+        // bounds: the last element each operand touches must lie inside its buffer
+        let last = |s: Strides, rows: usize, cols: usize| {
+            s.offset.checked_add((op.batch - 1).checked_mul(s.batch)?)?.checked_add((rows - 1).checked_mul(s.row)?)?.checked_add((cols - 1).checked_mul(s.col)?)
+        };
+        for (name, buf, s, rows, cols) in [("A", a, sa, op.m, op.k), ("B", b, sb, op.k, op.n), ("C", c, sc, op.m, op.n)] {
+            if name != "C" && op.k == 0 {
+                continue;
+            }
+            let last = last(s, rows, cols).ok_or_else(|| Error::Input(format!("matmul operand {name} layout overflows its element index")))?;
+            if last >= buf.len {
+                return Err(Error::Input(format!("matmul operand {name} reaches element {last} of a {}-element buffer", buf.len)));
+            }
+        }
+        if op.bias.is_some_and(|bias| bias.len < op.n) || op.residual.is_some_and(|r| r.len < c.len) {
+            return Err(Error::Input("matmul bias or residual is too small".into()));
+        }
+        let flags = u32::from(op.bias.is_some())
+            | (match op.act {
+                Act::None => 0,
+                Act::Gelu => 1,
+                Act::Relu => 2,
+            } << 1)
+            | (u32::from(op.residual.is_some()) << 3);
+        let params = [
+            u32_of(op.m, "m")?,
+            u32_of(op.n, "n")?,
+            u32_of(op.k, "k")?,
+            u32_of(op.batch, "batch")?,
+            u32_of(sa.offset, "a offset")?,
+            u32_of(sa.batch, "a batch")?,
+            u32_of(sa.row, "a row")?,
+            u32_of(sa.col, "a col")?,
+            u32_of(sb.offset, "b offset")?,
+            u32_of(sb.batch, "b batch")?,
+            u32_of(sb.row, "b row")?,
+            u32_of(sb.col, "b col")?,
+            u32_of(sc.offset, "c offset")?,
+            u32_of(sc.batch, "c batch")?,
+            u32_of(sc.row, "c row")?,
+            flags,
+            op.alpha.to_bits(),
+        ];
+        let dummy;
+        let bias = match op.bias {
+            Some(b) => b,
+            None => {
+                dummy = self.upload(&[0.0]);
+                &dummy
+            }
+        };
+        // a buffer is never bound twice in one dispatch (read and read-write), so no residual means a dummy
+        let dummy_res;
+        let res = match op.residual {
+            Some(r) => r,
+            None => {
+                dummy_res = self.upload(&[0.0]);
+                &dummy_res
+            }
+        };
+        self.run(
+            if b.f16 { "matmul_w16" } else { "matmul" },
+            &[(0, a), (1, b), (2, bias), (3, c), (4, res)],
+            &params,
+            (u32_of(op.n.div_ceil(64), "groups")?, u32_of(op.m.div_ceil(64), "groups")?, u32_of(op.batch, "batch")?),
+        );
+        Ok(())
+    }
+}
+
+pub mod encoder;
+pub mod memattn;
+pub mod memenc;
+mod ops;
+
+/// A linear layer's weight `[out, in]` and bias `[out]` on the GPU.
+pub struct GLinear {
+    pub(crate) w: Buf,
+    pub(crate) b: Buf,
+    pub(crate) inp: usize,
+    pub(crate) out: usize,
+}
+
+/// A layer norm's scale and shift on the GPU.
+pub struct GNorm {
+    pub(crate) w: Buf,
+    pub(crate) b: Buf,
+}
+
+fn flat(t: candle_core::Tensor) -> Result<Vec<f32>> {
+    Ok(t.flatten_all()?.to_vec1::<f32>()?)
+}
+
+impl GLinear {
+    /// From `{name}.weight` (`[out, in]`) and `{name}.bias`.
+    pub fn load(g: &Gpu, w: &crate::weights::Weights, name: &str, inp: usize, out: usize) -> Result<GLinear> {
+        Ok(GLinear {
+            w: g.upload_weights(&flat(w.get(&format!("{name}.weight"), &[out, inp])?)?),
+            b: g.upload(&flat(w.get(&format!("{name}.bias"), &[out])?)?),
+            inp,
+            out,
+        })
+    }
+
+    /// As [`GLinear::load`], with output channel `j` scaled by `scale[j]` (the memory fuser's layer scale).
+    pub fn load_scaled(g: &Gpu, w: &crate::weights::Weights, name: &str, inp: usize, out: usize, scale: &[f32]) -> Result<GLinear> {
+        if scale.len() != out {
+            return Err(Error::Weights(format!("`{name}`: {} scales for {out} outputs", scale.len())));
+        }
+        let mut wt = flat(w.get(&format!("{name}.weight"), &[out, inp])?)?;
+        let mut bias = flat(w.get(&format!("{name}.bias"), &[out])?)?;
+        for (j, s) in scale.iter().enumerate() {
+            if let Some(row) = wt.get_mut(j * inp..(j + 1) * inp) {
+                row.iter_mut().for_each(|v| *v *= s);
+            }
+            if let Some(b) = bias.get_mut(j) {
+                *b *= s;
+            }
+        }
+        Ok(GLinear { w: g.upload_weights(&wt), b: g.upload(&bias), inp, out })
+    }
+
+    /// A 1 x 1 convolution (`[out, in, 1, 1]`) as a linear layer over channels-last tokens.
+    pub fn load_conv1x1(g: &Gpu, w: &crate::weights::Weights, name: &str, inp: usize, out: usize) -> Result<GLinear> {
+        Ok(GLinear {
+            w: g.upload_weights(&flat(w.get(&format!("{name}.weight"), &[out, inp, 1, 1])?)?),
+            b: g.upload(&flat(w.get(&format!("{name}.bias"), &[out])?)?),
+            inp,
+            out,
+        })
+    }
+}
+
+impl GNorm {
+    pub fn load(g: &Gpu, w: &crate::weights::Weights, name: &str, dim: usize) -> Result<GNorm> {
+        Ok(GNorm { w: g.upload(&flat(w.get(&format!("{name}.weight"), &[dim])?)?), b: g.upload(&flat(w.get(&format!("{name}.bias"), &[dim])?)?) })
+    }
+}
+
+impl Gpu {
+    /// `out = act(x . W^T + bias) (+ residual)` for `rows` rows of `l.inp` values.
+    pub fn linear(&self, x: &Buf, rows: usize, l: &GLinear, out: &Buf, act: Act, residual: Option<&Buf>) -> Result<()> {
+        // the weight is stored [out, in]: B[k][j] = w[j * in + k]
+        self.matmul(&Matmul {
+            m: rows,
+            n: l.out,
+            k: l.inp,
+            batch: 1,
+            a: (x, Strides::row_major(l.inp)),
+            b: (&l.w, Strides { offset: 0, batch: 0, row: 1, col: l.inp }),
+            bias: Some(&l.b),
+            c: (out, Strides::row_major(l.out)),
+            residual,
+            alpha: 1.0,
+            act,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/sam2/src/gpu/encoder.rs b/crates/sam2/src/gpu/encoder.rs
new file mode 100644
index 000000000..a33f9069c
--- /dev/null
+++ b/crates/sam2/src/gpu/encoder.rs
@@ -0,0 +1,289 @@
+// Original work for EffectCraft; the maths follows the Hugging Face `transformers` SAM 2
+// implementation (Apache-2.0, see NOTICE).
+//! The vision encoder on the GPU: patch embedding, the Hiera blocks and the neck, with the decoder's two
+//! skip convolutions. Activations stay on the GPU between the kernels; only the three tensors the rest of
+//! the model needs come back.
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex, PoisonError};
+
+use candle_core::{Device, Tensor};
+
+use super::{Act, Buf, GLinear, GNorm, Gpu, Matmul, Strides};
+use crate::hiera::{BlockPlan, Hiera, HieraConfig};
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+struct GBlock {
+    plan: BlockPlan,
+    norm1: GNorm,
+    qkv: GLinear,
+    proj: GLinear,
+    norm2: GNorm,
+    mlp_in: GLinear,
+    mlp_out: GLinear,
+    block_proj: Option<GLinear>,
+}
+
+/// What the rest of the model takes from the encoder (CPU tensors, NCHW).
+pub struct GpuFeatures {
+    /// The lowest-resolution neck level `[1, 256, 64, 64]`.
+    pub low: Tensor,
+    /// The decoder's skip features: `conv_s0` of the highest level `[1, 32, 256, 256]` and `conv_s1` of the
+    /// next `[1, 64, 128, 128]`.
+    pub high: (Tensor, Tensor),
+}
+
+pub struct GpuEncoder {
+    gpu: Arc<Gpu>,
+    cfg: HieraConfig,
+    patch_w: Buf,
+    patch_b: Buf,
+    blocks: Vec<GBlock>,
+    stage_ends: Vec<usize>,
+    neck: Vec<GLinear>,
+    top_down: Vec<usize>,
+    skip0: GLinear,
+    skip1: GLinear,
+    /// The position embedding of each grid size, uploaded on first use.
+    pos: Mutex<HashMap<(usize, usize), Buf>>,
+    /// The CPU backbone, which owns the position embedding tables.
+    cpu: Arc<Hiera>,
+    eps: f32,
+}
+
+impl GpuEncoder {
+    /// Upload the backbone, the neck and the skip convolutions. `cpu` supplies the position embedding.
+    pub fn load(gpu: Arc<Gpu>, w: &Weights, cpu: Arc<Hiera>) -> Result<GpuEncoder> {
+        let cfg = cpu.config().clone();
+        let flat = |t: Tensor| -> Result<Vec<f32>> { Ok(t.flatten_all()?.to_vec1::<f32>()?) };
+        let hidden = cfg.embed_dims.first().copied().unwrap_or(96);
+        let mut blocks = vec![];
+        for (total, plan) in BlockPlan::all(&cfg)?.into_iter().enumerate() {
+            let p = format!("vision_encoder.backbone.blocks.{total}");
+            blocks.push(GBlock {
+                plan,
+                norm1: GNorm::load(&gpu, w, &format!("{p}.layer_norm1"), plan.dim)?,
+                qkv: GLinear::load(&gpu, w, &format!("{p}.attn.qkv"), plan.dim, plan.dim_out * 3)?,
+                proj: GLinear::load(&gpu, w, &format!("{p}.attn.proj"), plan.dim_out, plan.dim_out)?,
+                norm2: GNorm::load(&gpu, w, &format!("{p}.layer_norm2"), plan.dim_out)?,
+                mlp_in: GLinear::load(&gpu, w, &format!("{p}.mlp.proj_in"), plan.dim_out, plan.dim_out * cfg.mlp_ratio)?,
+                mlp_out: GLinear::load(&gpu, w, &format!("{p}.mlp.proj_out"), plan.dim_out * cfg.mlp_ratio, plan.dim_out)?,
+                block_proj: (plan.dim != plan.dim_out).then(|| GLinear::load(&gpu, w, &format!("{p}.proj"), plan.dim, plan.dim_out)).transpose()?,
+            });
+        }
+        let mut stage_ends = vec![];
+        let mut n = 0;
+        for b in &cfg.blocks {
+            n += b;
+            stage_ends.push(n.saturating_sub(1));
+        }
+        let channels: Vec<usize> = cfg.embed_dims.iter().rev().copied().collect();
+        let neck = channels
+            .iter()
+            .enumerate()
+            .map(|(j, c)| GLinear::load_conv1x1(&gpu, w, &format!("vision_encoder.neck.convs.{j}"), *c, 256))
+            .collect::<Result<Vec<_>>>()?;
+        Ok(GpuEncoder {
+            patch_w: gpu.upload(&flat(w.get("vision_encoder.backbone.patch_embed.projection.weight", &[hidden, 3, 7, 7])?)?),
+            patch_b: gpu.upload(&flat(w.get("vision_encoder.backbone.patch_embed.projection.bias", &[hidden])?)?),
+            skip0: GLinear::load_conv1x1(&gpu, w, "mask_decoder.conv_s0", 256, 32)?,
+            skip1: GLinear::load_conv1x1(&gpu, w, "mask_decoder.conv_s1", 256, 64)?,
+            gpu,
+            eps: cfg.eps as f32,
+            cfg,
+            blocks,
+            stage_ends,
+            neck,
+            top_down: vec![2, 3],
+            pos: Mutex::default(),
+            cpu,
+        })
+    }
+
+    fn linear(&self, x: &Buf, rows: usize, l: &GLinear, out: &Buf, act: Act, residual: Option<&Buf>) -> Result<()> {
+        self.gpu.linear(x, rows, l, out, act, residual)
+    }
+
+    fn norm(&self, x: &Buf, rows: usize, dim: usize, n: &GNorm) -> Result<Buf> {
+        let out = self.gpu.zeros(rows * dim)?;
+        self.gpu.layernorm(x, &n.w, &n.b, &out, rows, dim, self.eps, false)?;
+        Ok(out)
+    }
+
+    fn pos_buffer(&self, h: usize, w: usize) -> Result<Buf> {
+        let mut map = self.pos.lock().unwrap_or_else(PoisonError::into_inner);
+        if let Some(b) = map.get(&(h, w)) {
+            return Ok(b.clone());
+        }
+        let table = self.cpu.pos(h, w)?.flatten_all()?.to_vec1::<f32>()?;
+        let buf = self.gpu.upload(&table);
+        map.insert((h, w), buf.clone());
+        Ok(buf)
+    }
+
+    /// One Hiera block on `[h * w, dim]` tokens; returns the new tokens and grid size.
+    fn block(&self, b: &GBlock, x: &Buf, h: usize, w: usize) -> Result<(Buf, usize, usize)> {
+        let g = &self.gpu;
+        let BlockPlan { dim, dim_out, heads, window, query_stride } = b.plan;
+        let n = h * w;
+        let normed = self.norm(x, n, dim, &b.norm1)?;
+        // the skip connection: from the block's input, or (stage change) its projection, pooled with the queries
+        let (oh, ow) = query_stride.map_or((h, w), |s| (h / s, w / s));
+        if query_stride.is_some_and(|s| s != 2) {
+            return Err(Error::Input("only a query stride of 2 is supported on the GPU".into()));
+        }
+        let residual = match (&b.block_proj, query_stride) {
+            (Some(p), Some(_)) => {
+                let proj = g.zeros(n * dim_out)?;
+                self.linear(&normed, n, p, &proj, Act::None, None)?;
+                let pooled = g.zeros(oh * ow * dim_out)?;
+                g.maxpool2(&proj, &pooled, 1, h, w, dim_out, (n * dim_out, w * dim_out, dim_out))?;
+                pooled
+            }
+            (Some(p), None) => {
+                let proj = g.zeros(n * dim_out)?;
+                self.linear(&normed, n, p, &proj, Act::None, None)?;
+                proj
+            }
+            (None, _) => x.clone(),
+        };
+        // windows (or the whole grid for global attention)
+        let (hw, nwin, t, win_h, win_w) = if window > 0 {
+            let (nwx, nwy) = (w.div_ceil(window), h.div_ceil(window));
+            let buf = g.zeros(nwx * nwy * window * window * dim)?;
+            g.window_partition(&normed, &buf, h, w, dim, window)?;
+            (buf, nwx * nwy, window * window, window, window)
+        } else {
+            (normed, 1, n, h, w)
+        };
+        let tok = nwin * t;
+        let qkv = g.zeros(tok * 3 * dim_out)?;
+        self.linear(&hw, tok, &b.qkv, &qkv, Act::None, None)?;
+        // queries, pooled when the stage changes
+        let (q_buf, q_rs, tq) = match query_stride {
+            Some(s) => {
+                let (qh, qw) = (win_h / s, win_w / s);
+                let pooled = g.zeros(nwin * qh * qw * dim_out)?;
+                g.maxpool2(&qkv, &pooled, nwin, win_h, win_w, dim_out, (t * 3 * dim_out, win_w * 3 * dim_out, 3 * dim_out))?;
+                (pooled, dim_out, qh * qw)
+            }
+            None => (qkv.clone(), 3 * dim_out, t),
+        };
+        let hd = dim_out / heads.max(1);
+        let scale = (hd as f32).powf(-0.5);
+        let scores = g.zeros(nwin * tq * t)?;
+        let attn = g.zeros(nwin * tq * dim_out)?;
+        for hh in 0..heads {
+            g.matmul(&Matmul {
+                m: tq,
+                n: t,
+                k: hd,
+                batch: nwin,
+                a: (&q_buf, Strides { offset: hh * hd, batch: tq * q_rs, row: q_rs, col: 1 }),
+                b: (&qkv, Strides { offset: dim_out + hh * hd, batch: t * 3 * dim_out, row: 1, col: 3 * dim_out }),
+                bias: None,
+                c: (&scores, Strides { offset: 0, batch: tq * t, row: t, col: 1 }),
+                residual: None,
+                alpha: scale,
+                act: Act::None,
+            })?;
+            g.softmax(&scores, nwin * tq, t)?;
+            g.matmul(&Matmul {
+                m: tq,
+                n: hd,
+                k: t,
+                batch: nwin,
+                a: (&scores, Strides { offset: 0, batch: tq * t, row: t, col: 1 }),
+                b: (&qkv, Strides { offset: 2 * dim_out + hh * hd, batch: t * 3 * dim_out, row: 3 * dim_out, col: 1 }),
+                bias: None,
+                c: (&attn, Strides { offset: hh * hd, batch: tq * dim_out, row: dim_out, col: 1 }),
+                residual: None,
+                alpha: 1.0,
+                act: Act::None,
+            })?;
+        }
+        let projected = g.zeros(nwin * tq * dim_out)?;
+        self.linear(&attn, nwin * tq, &b.proj, &projected, Act::None, None)?;
+        let attn_img = if window > 0 {
+            let ws = window / query_stride.unwrap_or(1);
+            let img = g.zeros(oh * ow * dim_out)?;
+            g.window_unpartition(&projected, &img, oh, ow, dim_out, ws)?;
+            img
+        } else {
+            projected
+        };
+        let n2 = oh * ow;
+        let x2 = g.zeros(n2 * dim_out)?;
+        g.add(&residual, &attn_img, &x2, n2 * dim_out)?;
+        let normed2 = self.norm(&x2, n2, dim_out, &b.norm2)?;
+        let hidden = g.zeros(n2 * b.mlp_in.out)?;
+        self.linear(&normed2, n2, &b.mlp_in, &hidden, Act::Gelu, None)?;
+        let out = g.zeros(n2 * dim_out)?;
+        self.linear(&hidden, n2, &b.mlp_out, &out, Act::None, Some(&x2))?;
+        Ok((out, oh, ow))
+    }
+
+    /// Encode normalised `[1, 3, H, W]` pixels (`H` and `W` multiples of 32).
+    pub fn encode(&self, pixels: &Tensor) -> Result<GpuFeatures> {
+        let g = &self.gpu;
+        let _turn = g.exclusive();
+        let (_, c, ph, pw) = pixels.dims4()?;
+        let window0 = self.cfg.windows.first().copied().unwrap_or(8);
+        if c != 3 || ph == 0 || pw == 0 || ph % 4 != 0 || pw % 4 != 0 || (ph / 4) % window0 != 0 || (pw / 4) % window0 != 0 {
+            return Err(Error::Input(format!("image size {pw}x{ph} does not fit the encoder")));
+        }
+        let hidden = self.cfg.embed_dims.first().copied().unwrap_or(96);
+        let px = g.upload(&pixels.contiguous()?.flatten_all()?.to_vec1::<f32>()?);
+        let (mut h, mut w) = (ph / 4, pw / 4);
+        let tokens = g.zeros(h * w * hidden)?;
+        g.patch_embed(&px, &self.patch_w, &self.patch_b, &tokens, (ph, pw, hidden))?;
+        let mut x = g.zeros(h * w * hidden)?;
+        g.add(&tokens, &self.pos_buffer(h, w)?, &x, h * w * hidden)?;
+        let mut stages: Vec<(Buf, usize, usize, usize)> = vec![];
+        for (i, b) in self.blocks.iter().enumerate() {
+            let (nx, nh, nw) = self.block(b, &x, h, w)?;
+            (x, h, w) = (nx, nh, nw);
+            // submit per block so the GPU can free the previous block's intermediates (Large would otherwise run out of memory)
+            g.flush()?;
+            if self.stage_ends.contains(&i) {
+                stages.push((x.clone(), h, w, b.plan.dim_out));
+            }
+        }
+        // the neck, from the lowest resolution up: lateral 1x1 convolutions, and the top-down sum on the levels that have it
+        let n = self.neck.len();
+        if stages.len() != n {
+            return Err(Error::Compute("the backbone returned the wrong number of stages".into()));
+        }
+        let mut levels: Vec<(Buf, usize, usize)> = vec![];
+        let mut prev: Option<(Buf, usize, usize)> = None;
+        for i in (0..n).rev() {
+            let (buf, sh, sw, _) = &stages[i];
+            let conv = self.neck.get(n - 1 - i).ok_or_else(|| Error::Compute("missing neck convolution".into()))?;
+            let lateral = g.zeros(sh * sw * 256)?;
+            self.linear(buf, sh * sw, conv, &lateral, Act::None, None)?;
+            let cur = match (&prev, self.top_down.contains(&i) && i != n - 1) {
+                (Some((p, _, _)), true) => {
+                    let sum = g.zeros(sh * sw * 256)?;
+                    g.upsample_add(&lateral, p, &sum, *sh, *sw, 256)?;
+                    sum
+                }
+                _ => lateral,
+            };
+            prev = Some((cur.clone(), *sh, *sw));
+            levels.push((cur, *sh, *sw));
+        }
+        // levels: lowest resolution first. The decoder needs the third (64 x 64) and the skip convolutions of the last two.
+        let [_, (l2, h2, w2), (l1, h1, w1), (l0, h0, w0)] = <[_; 4]>::try_from(levels).map_err(|_| Error::Compute("the neck must have four levels".into()))?;
+        let s0 = g.zeros(h0 * w0 * 32)?;
+        self.linear(&l0, h0 * w0, &self.skip0, &s0, Act::None, None)?;
+        let s1 = g.zeros(h1 * w1 * 64)?;
+        self.linear(&l1, h1 * w1, &self.skip1, &s1, Act::None, None)?;
+        g.flush()?;
+        let nchw = |buf: &Buf, hh: usize, ww: usize, ch: usize| -> Result<Tensor> {
+            let v = g.download(buf)?;
+            Ok(Tensor::from_vec(v, (1, hh, ww, ch), &Device::Cpu)?.permute((0, 3, 1, 2))?.contiguous()?)
+        };
+        Ok(GpuFeatures { low: nchw(&l2, h2, w2, 256)?, high: (nchw(&s0, h0, w0, 32)?, nchw(&s1, h1, w1, 64)?) })
+    }
+}
diff --git a/crates/sam2/src/gpu/kernels.wgsl b/crates/sam2/src/gpu/kernels.wgsl
new file mode 100644
index 000000000..faea20e76
--- /dev/null
+++ b/crates/sam2/src/gpu/kernels.wgsl
@@ -0,0 +1,165 @@
+// SAM 2 compute kernels (f32). Original work for EffectCraft; the maths follows the Hugging Face
+// `transformers` SAM 2 implementation (Apache-2.0, see NOTICE).
+//
+// Every kernel reads its parameters from one uniform: 24 u32 words (floats are bit-cast).
+
+struct P { v: array<vec4<u32>, 6> }
+@group(0) @binding(0) var<storage, read> in0: array<f32>;
+@group(0) @binding(1) var<storage, read> in1: array<f32>;
+@group(0) @binding(2) var<storage, read> in2: array<f32>;
+@group(0) @binding(3) var<storage, read_write> out0: array<f32>;
+@group(0) @binding(4) var<storage, read> in3: array<f32>;
+@group(0) @binding(5) var<uniform> p: P;
+
+fn u(i: u32) -> u32 { return p.v[i / 4u][i % 4u]; }
+fn f(i: u32) -> f32 { return bitcast<f32>(u(i)); }
+
+// erf, Abramowitz and Stegun 7.1.26 (abs error 1.5e-7).
+fn erf_(x: f32) -> f32 {
+    let s = select(1.0, -1.0, x < 0.0);
+    let a = abs(x);
+    let t = 1.0 / (1.0 + 0.3275911 * a);
+    let y = 1.0 - (((((1.061405429 * t - 1.453152027) * t) + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t * exp(-a * a);
+    return s * y;
+}
+fn gelu_(x: f32) -> f32 { return (erf_(x * 0.70710678) + 1.0) * 0.5 * x; }
+
+// ---------------------------------------------------------------- strided batched matmul
+// C[b] = act(alpha * A[b] (m x k) . B[b] (k x n) + bias) (+ residual), with free strides for A and B.
+//  words: 0 m, 1 n, 2 k, 3 batch, 4 a_off, 5 a_bs, 6 a_rs, 7 a_cs, 8 b_off, 9 b_bs, 10 b_rs, 11 b_cs,
+//         12 c_off, 13 c_bs, 14 c_rs, 15 flags (bit0 bias, bits 1-2 act: 1 gelu 2 relu, bit3 residual),
+//         16 alpha (f32)
+//  in0 = A, in1 = B, in2 = bias (n), out0 = C, in3 = residual (same layout as C)
+var<workgroup> sa: array<f32, 1024>;
+var<workgroup> sb: array<f32, 1024>;
+
+@compute @workgroup_size(16, 16)
+fn matmul(@builtin(workgroup_id) wg: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let m = u(0u); let n = u(1u); let k = u(2u);
+    let a_base = u(4u) + wg.z * u(5u);
+    let b_base = u(8u) + wg.z * u(9u);
+    let a_rs = u(6u); let a_cs = u(7u); let b_rs = u(10u); let b_cs = u(11u);
+    let row0 = wg.y * 64u;
+    let col0 = wg.x * 64u;
+    let tid = li.y * 16u + li.x;
+    let a_k_contig = a_cs == 1u;
+    let b_n_contig = b_cs == 1u;
+    var acc: array<f32, 16>;
+    for (var i = 0u; i < 16u; i++) { acc[i] = 0.0; }
+    for (var kt = 0u; kt < k; kt += 16u) {
+        for (var i = 0u; i < 4u; i++) {
+            let idx = tid + i * 256u;
+            var r: u32; var c: u32;
+            if (a_k_contig) { r = idx / 16u; c = idx % 16u; } else { r = idx % 64u; c = idx / 64u; }
+            let gr = row0 + r; let gc = kt + c;
+            var va = 0.0;
+            if (gr < m && gc < k) { va = in0[a_base + gr * a_rs + gc * a_cs]; }
+            sa[r * 16u + c] = va;
+            var r2: u32; var c2: u32;
+            if (b_n_contig) { r2 = idx / 64u; c2 = idx % 64u; } else { r2 = idx % 16u; c2 = idx / 16u; }
+            let gr2 = kt + r2; let gc2 = col0 + c2;
+            var vb = 0.0;
+            if (gr2 < k && gc2 < n) { vb = in1[b_base + gr2 * b_rs + gc2 * b_cs]; }
+            sb[r2 * 64u + c2] = vb;
+        }
+        workgroupBarrier();
+        for (var kk = 0u; kk < 16u; kk++) {
+            var ar: array<f32, 4>;
+            var br: array<f32, 4>;
+            for (var i = 0u; i < 4u; i++) {
+                ar[i] = sa[(li.y * 4u + i) * 16u + kk];
+                br[i] = sb[kk * 64u + li.x * 4u + i];
+            }
+            for (var i = 0u; i < 4u; i++) {
+                for (var j = 0u; j < 4u; j++) { acc[i * 4u + j] += ar[i] * br[j]; }
+            }
+        }
+        workgroupBarrier();
+    }
+    let flags = u(15u);
+    let alpha = f(16u);
+    let c_base = u(12u) + wg.z * u(13u);
+    let c_rs = u(14u);
+    let act = (flags >> 1u) & 3u;
+    for (var i = 0u; i < 4u; i++) {
+        for (var j = 0u; j < 4u; j++) {
+            let gr = row0 + li.y * 4u + i;
+            let gc = col0 + li.x * 4u + j;
+            if (gr < m && gc < n) {
+                var v = acc[i * 4u + j] * alpha;
+                if ((flags & 1u) != 0u) { v += in2[gc]; }
+                if (act == 1u) { v = gelu_(v); } else if (act == 2u) { v = max(v, 0.0); }
+                let idx = c_base + gr * c_rs + gc;
+                if ((flags & 8u) != 0u) { v += in3[idx]; }
+                out0[idx] = v;
+            }
+        }
+    }
+}
+
+// The same, with B (a weight matrix) stored as half precision, two values per word.
+@group(0) @binding(1) var<storage, read> w16: array<u32>;
+
+@compute @workgroup_size(16, 16)
+fn matmul_w16(@builtin(workgroup_id) wg: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let m = u(0u); let n = u(1u); let k = u(2u);
+    let a_base = u(4u) + wg.z * u(5u);
+    let b_base = u(8u) + wg.z * u(9u);
+    let a_rs = u(6u); let a_cs = u(7u); let b_rs = u(10u); let b_cs = u(11u);
+    let row0 = wg.y * 64u;
+    let col0 = wg.x * 64u;
+    let tid = li.y * 16u + li.x;
+    let a_k_contig = a_cs == 1u;
+    let b_n_contig = b_cs == 1u;
+    var acc: array<f32, 16>;
+    for (var i = 0u; i < 16u; i++) { acc[i] = 0.0; }
+    for (var kt = 0u; kt < k; kt += 16u) {
+        for (var i = 0u; i < 4u; i++) {
+            let idx = tid + i * 256u;
+            var r: u32; var c: u32;
+            if (a_k_contig) { r = idx / 16u; c = idx % 16u; } else { r = idx % 64u; c = idx / 64u; }
+            let gr = row0 + r; let gc = kt + c;
+            var va = 0.0;
+            if (gr < m && gc < k) { va = in0[a_base + gr * a_rs + gc * a_cs]; }
+            sa[r * 16u + c] = va;
+            var r2: u32; var c2: u32;
+            if (b_n_contig) { r2 = idx / 64u; c2 = idx % 64u; } else { r2 = idx % 16u; c2 = idx / 16u; }
+            let gr2 = kt + r2; let gc2 = col0 + c2;
+            var vb = 0.0;
+            if (gr2 < k && gc2 < n) { let bi = b_base + gr2 * b_rs + gc2 * b_cs; vb = unpack2x16float(w16[bi >> 1u])[bi & 1u]; }
+            sb[r2 * 64u + c2] = vb;
+        }
+        workgroupBarrier();
+        for (var kk = 0u; kk < 16u; kk++) {
+            var ar: array<f32, 4>;
+            var br: array<f32, 4>;
+            for (var i = 0u; i < 4u; i++) {
+                ar[i] = sa[(li.y * 4u + i) * 16u + kk];
+                br[i] = sb[kk * 64u + li.x * 4u + i];
+            }
+            for (var i = 0u; i < 4u; i++) {
+                for (var j = 0u; j < 4u; j++) { acc[i * 4u + j] += ar[i] * br[j]; }
+            }
+        }
+        workgroupBarrier();
+    }
+    let flags = u(15u);
+    let alpha = f(16u);
+    let c_base = u(12u) + wg.z * u(13u);
+    let c_rs = u(14u);
+    let act = (flags >> 1u) & 3u;
+    for (var i = 0u; i < 4u; i++) {
+        for (var j = 0u; j < 4u; j++) {
+            let gr = row0 + li.y * 4u + i;
+            let gc = col0 + li.x * 4u + j;
+            if (gr < m && gc < n) {
+                var v = acc[i * 4u + j] * alpha;
+                if ((flags & 1u) != 0u) { v += in2[gc]; }
+                if (act == 1u) { v = gelu_(v); } else if (act == 2u) { v = max(v, 0.0); }
+                let idx = c_base + gr * c_rs + gc;
+                if ((flags & 8u) != 0u) { v += in3[idx]; }
+                out0[idx] = v;
+            }
+        }
+    }
+}
diff --git a/crates/sam2/src/gpu/kernels_ops.wgsl b/crates/sam2/src/gpu/kernels_ops.wgsl
new file mode 100644
index 000000000..419476600
--- /dev/null
+++ b/crates/sam2/src/gpu/kernels_ops.wgsl
@@ -0,0 +1,206 @@
+
+// ---------------------------------------------------------------- helpers
+// A 1-D index over n items spread on a 2-D grid of 256-thread groups (a dimension holds 65535 groups).
+fn gid1(wg: vec3<u32>, nw: vec3<u32>, li: vec3<u32>) -> u32 { return (wg.y * nw.x + wg.x) * 256u + li.x; }
+
+var<workgroup> red: array<f32, 64>;
+
+// Sum of `red` over the workgroup (64 threads), for a caller that has filled it; all threads get the result.
+fn reduce_sum(li: u32) -> f32 {
+    workgroupBarrier();
+    for (var st = 32u; st > 0u; st = st / 2u) {
+        if (li < st) { red[li] += red[li + st]; }
+        workgroupBarrier();
+    }
+    let r = red[0];
+    workgroupBarrier();
+    return r;
+}
+
+fn reduce_max(li: u32) -> f32 {
+    workgroupBarrier();
+    for (var st = 32u; st > 0u; st = st / 2u) {
+        if (li < st) { red[li] = max(red[li], red[li + st]); }
+        workgroupBarrier();
+    }
+    let r = red[0];
+    workgroupBarrier();
+    return r;
+}
+
+// ---------------------------------------------------------------- layer norm over the last dimension
+//  words: 0 rows, 1 cols, 2 eps (f32), 3 gelu (1: apply GELU to the result). in0 x, in1 weight, in2 bias, out0 y. One workgroup per row.
+@compute @workgroup_size(64)
+fn layernorm(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let row = wg.y * nw.x + wg.x;
+    let rows = u(0u); let cols = u(1u);
+    if (row >= rows) { return; }
+    let base = row * cols;
+    var s = 0.0;
+    for (var c = li.x; c < cols; c += 64u) { s += in0[base + c]; }
+    red[li.x] = s;
+    let mean = reduce_sum(li.x) / f32(cols);
+    var q = 0.0;
+    for (var c = li.x; c < cols; c += 64u) { let d = in0[base + c] - mean; q += d * d; }
+    red[li.x] = q;
+    let inv = inverseSqrt(reduce_sum(li.x) / f32(cols) + f(2u));
+    for (var c = li.x; c < cols; c += 64u) {
+        var y = (in0[base + c] - mean) * inv * in1[c] + in2[c];
+        if (u(3u) == 1u) { y = gelu_(y); }
+        out0[base + c] = y;
+    }
+}
+
+// ---------------------------------------------------------------- convolution over channels-last [H, W, Ci]
+//  words: 0 n (output elements), 1 H, 2 W, 3 Ci, 4 Co, 5 Ho, 6 Wo, 7 k, 8 stride, 9 pad, 10 groups.
+//  in0 input, in1 weight [Co, Ci / groups, k, k], in2 bias [Co]; output [Ho, Wo, Co].
+@compute @workgroup_size(256)
+fn conv2d(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let i = gid1(wg, nw, li);
+    if (i >= u(0u)) { return; }
+    let H = u(1u); let W = u(2u); let Ci = u(3u); let Co = u(4u); let Wo = u(6u);
+    let k = u(7u); let stride = u(8u); let pad = i32(u(9u)); let groups = u(10u);
+    let co = i % Co; let t = i / Co;
+    let ox = t % Wo; let oy = t / Wo;
+    let cig = Ci / groups;
+    let g0 = co / (Co / groups);
+    var acc = in2[co];
+    for (var c = 0u; c < cig; c++) {
+        let ci = g0 * cig + c;
+        for (var ky = 0u; ky < k; ky++) {
+            let iy = i32(oy * stride + ky) - pad;
+            if (iy < 0 || iy >= i32(H)) { continue; }
+            for (var kx = 0u; kx < k; kx++) {
+                let ix = i32(ox * stride + kx) - pad;
+                if (ix < 0 || ix >= i32(W)) { continue; }
+                acc += in0[(u32(iy) * W + u32(ix)) * Ci + ci] * in1[((co * cig + c) * k + ky) * k + kx];
+            }
+        }
+    }
+    out0[i] = acc;
+}
+
+// ---------------------------------------------------------------- softmax over rows, in place on out0
+//  words: 0 rows, 1 cols. One workgroup per row.
+@compute @workgroup_size(64)
+fn softmax(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let row = wg.y * nw.x + wg.x;
+    let rows = u(0u); let cols = u(1u);
+    if (row >= rows) { return; }
+    let base = row * cols;
+    var mx = -3.0e38;
+    for (var c = li.x; c < cols; c += 64u) { mx = max(mx, out0[base + c]); }
+    red[li.x] = mx;
+    let m = reduce_max(li.x);
+    var s = 0.0;
+    for (var c = li.x; c < cols; c += 64u) { let e = exp(out0[base + c] - m); out0[base + c] = e; s += e; }
+    red[li.x] = s;
+    let inv = 1.0 / reduce_sum(li.x);
+    for (var c = li.x; c < cols; c += 64u) { out0[base + c] = out0[base + c] * inv; }
+}
+
+// ---------------------------------------------------------------- elementwise add: out0 = in0 + in1 (n items)
+@compute @workgroup_size(256)
+fn add(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let i = gid1(wg, nw, li);
+    if (i < u(0u)) { out0[i] = in0[i] + in1[i]; }
+}
+
+// ---------------------------------------------------------------- windows
+//  words: 0 n (output elements), 1 H, 2 W, 3 C, 4 ws, 5 windows across (nwx)
+//  window_partition: [H, W, C] -> [nwin, ws, ws, C] (zero padded); window_unpartition: the inverse.
+@compute @workgroup_size(256)
+fn window_partition(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let i = gid1(wg, nw, li);
+    if (i >= u(0u)) { return; }
+    let H = u(1u); let W = u(2u); let C = u(3u); let ws = u(4u); let nwx = u(5u);
+    let c = i % C; var t = i / C;
+    let x = t % ws; t = t / ws;
+    let y = t % ws; let win = t / ws;
+    let gy = (win / nwx) * ws + y;
+    let gx = (win % nwx) * ws + x;
+    var v = 0.0;
+    if (gy < H && gx < W) { v = in0[(gy * W + gx) * C + c]; }
+    out0[i] = v;
+}
+
+@compute @workgroup_size(256)
+fn window_unpartition(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let i = gid1(wg, nw, li);
+    if (i >= u(0u)) { return; }
+    let W = u(2u); let C = u(3u); let ws = u(4u); let nwx = u(5u);
+    let c = i % C; let t = i / C;
+    let gx = t % W; let gy = t / W;
+    let win = (gy / ws) * nwx + gx / ws;
+    out0[i] = in0[((win * ws + gy % ws) * ws + gx % ws) * C + c];
+}
+
+// ---------------------------------------------------------------- 2 x 2 max pool over [nb, h, w, c] tokens
+//  words: 0 n (output elements), 1 nb, 2 h, 3 w, 4 c, 5 src image stride, 6 src row stride, 7 src token stride
+//  (so it can read the q third of a qkv buffer in place). Output [nb, h/2, w/2, c] contiguous.
+@compute @workgroup_size(256)
+fn maxpool2(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let i = gid1(wg, nw, li);
+    if (i >= u(0u)) { return; }
+    let h = u(2u); let w = u(3u); let c = u(4u);
+    let oh = h / 2u; let ow = w / 2u;
+    let ch = i % c; var t = i / c;
+    let ox = t % ow; t = t / ow;
+    let oy = t % oh; let img = t / oh;
+    let base = img * u(5u) + (oy * 2u) * u(6u) + (ox * 2u) * u(7u) + ch;
+    out0[i] = max(max(in0[base], in0[base + u(7u)]), max(in0[base + u(6u)], in0[base + u(6u) + u(7u)]));
+}
+
+// ---------------------------------------------------------------- patch embedding: 7 x 7 stride 4 pad 3 convolution
+//  words: 0 n (output elements), 1 H, 2 W, 3 Co, 4 Ho, 5 Wo. in0 pixels [3, H, W], in1 weight [Co, 3, 7, 7],
+//  in2 bias [Co]. Output [Ho, Wo, Co].
+@compute @workgroup_size(256)
+fn patch_embed(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let i = gid1(wg, nw, li);
+    if (i >= u(0u)) { return; }
+    let H = u(1u); let W = u(2u); let Co = u(3u); let Wo = u(5u);
+    let co = i % Co; let t = i / Co;
+    let ox = t % Wo; let oy = t / Wo;
+    var acc = in2[co];
+    for (var ci = 0u; ci < 3u; ci++) {
+        for (var ky = 0u; ky < 7u; ky++) {
+            let iy = i32(oy * 4u + ky) - 3;
+            if (iy < 0 || iy >= i32(H)) { continue; }
+            for (var kx = 0u; kx < 7u; kx++) {
+                let ix = i32(ox * 4u + kx) - 3;
+                if (ix < 0 || ix >= i32(W)) { continue; }
+                acc += in0[ci * H * W + u32(iy) * W + u32(ix)] * in1[((co * 3u + ci) * 7u + ky) * 7u + kx];
+            }
+        }
+    }
+    out0[i] = acc;
+}
+
+// ---------------------------------------------------------------- rotary position encoding on [rows, cols]
+//  words: 0 n (= rows * cols), 1 cols, 2 table rows, 3 rows rotated (the rest is copied). in0 x, in1 cos, in2 sin
+//  (tables [table rows, cols]); pairs (x0, x1) -> (x0 c - x1 s, x1 c + x0 s).
+@compute @workgroup_size(256)
+fn rope(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let i = gid1(wg, nw, li);
+    if (i >= u(0u)) { return; }
+    let cols = u(1u);
+    let row = i / cols; let col = i % cols;
+    if (row >= u(3u)) { out0[i] = in0[i]; return; }
+    let t = (row % u(2u)) * cols + col;
+    let x = in0[i];
+    var pair = 0.0;
+    if ((col & 1u) == 1u) { pair = in0[i - 1u]; } else { pair = in0[i + 1u]; }
+    if ((col & 1u) == 0u) { out0[i] = x * in1[t] - pair * in2[t]; } else { out0[i] = x * in1[t] + pair * in2[t]; }
+}
+
+// ---------------------------------------------------------------- neck: lateral + nearest 2x upsample of prev
+//  words: 0 n (output elements), 1 h, 2 w, 3 c. in0 lateral [h, w, c], in1 prev [h/2, w/2, c].
+@compute @workgroup_size(256)
+fn upsample_add(@builtin(workgroup_id) wg: vec3<u32>, @builtin(num_workgroups) nw: vec3<u32>, @builtin(local_invocation_id) li: vec3<u32>) {
+    let i = gid1(wg, nw, li);
+    if (i >= u(0u)) { return; }
+    let w = u(2u); let c = u(3u);
+    let ch = i % c; let t = i / c;
+    let x = t % w; let y = t / w;
+    out0[i] = in0[i] + in1[(((y / 2u) * (w / 2u)) + x / 2u) * c + ch];
+}
diff --git a/crates/sam2/src/gpu/memattn.rs b/crates/sam2/src/gpu/memattn.rs
new file mode 100644
index 000000000..38c5139a7
--- /dev/null
+++ b/crates/sam2/src/gpu/memattn.rs
@@ -0,0 +1,184 @@
+// Original work for EffectCraft; the maths follows the Hugging Face `transformers` SAM 2 video
+// implementation (Apache-2.0, see NOTICE).
+//! Memory attention on the GPU: four layers of self-attention over the current frame and cross-attention to
+//! the memory bank, with axial rotary position encoding. The attention is one head of 256 channels; the
+//! score matrix against a full memory bank is 4096 x 28736 floats, which stays on the GPU.
+
+use std::sync::Arc;
+
+use candle_core::{Device, Tensor};
+
+use super::{Act, Buf, GLinear, GNorm, Gpu, Matmul, Strides};
+use crate::memattn::{GRID, rope_tables};
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+const DIM: usize = 256;
+const LAYERS: usize = 4;
+
+struct GAttn {
+    q: GLinear,
+    k: GLinear,
+    v: GLinear,
+    o: GLinear,
+}
+
+struct GLayer {
+    self_attn: GAttn,
+    cross: GAttn,
+    ln1: GNorm,
+    ln2: GNorm,
+    ln3: GNorm,
+    lin1: GLinear,
+    lin2: GLinear,
+}
+
+pub struct GpuMemoryAttention {
+    gpu: Arc<Gpu>,
+    layers: Vec<GLayer>,
+    final_ln: GNorm,
+    cos: Buf,
+    sin: Buf,
+}
+
+fn attn(g: &Gpu, w: &Weights, prefix: &str, kv: usize) -> Result<GAttn> {
+    Ok(GAttn {
+        q: GLinear::load(g, w, &format!("{prefix}.q_proj"), DIM, DIM)?,
+        k: GLinear::load(g, w, &format!("{prefix}.k_proj"), kv, DIM)?,
+        v: GLinear::load(g, w, &format!("{prefix}.v_proj"), kv, DIM)?,
+        o: GLinear::load(g, w, &format!("{prefix}.o_proj"), DIM, DIM)?,
+    })
+}
+
+impl GpuMemoryAttention {
+    pub fn load(gpu: Arc<Gpu>, w: &Weights) -> Result<GpuMemoryAttention> {
+        let layers = (0..LAYERS)
+            .map(|i| {
+                let p = format!("memory_attention.layers.{i}");
+                Ok(GLayer {
+                    self_attn: attn(&gpu, w, &format!("{p}.self_attn"), DIM)?,
+                    cross: attn(&gpu, w, &format!("{p}.cross_attn_image"), 64)?,
+                    ln1: GNorm::load(&gpu, w, &format!("{p}.layer_norm1"), DIM)?,
+                    ln2: GNorm::load(&gpu, w, &format!("{p}.layer_norm2"), DIM)?,
+                    ln3: GNorm::load(&gpu, w, &format!("{p}.layer_norm3"), DIM)?,
+                    lin1: GLinear::load(&gpu, w, &format!("{p}.linear1"), DIM, 2048)?,
+                    lin2: GLinear::load(&gpu, w, &format!("{p}.linear2"), 2048, DIM)?,
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+        let (cos, sin) = rope_tables(10000.0)?;
+        let flat = |t: Tensor| -> Result<Vec<f32>> { Ok(t.flatten_all()?.to_vec1::<f32>()?) };
+        Ok(GpuMemoryAttention {
+            final_ln: GNorm::load(&gpu, w, "memory_attention.layer_norm", DIM)?,
+            cos: gpu.upload(&flat(cos)?),
+            sin: gpu.upload(&flat(sin)?),
+            layers,
+            gpu,
+        })
+    }
+
+    fn norm(&self, x: &Buf, rows: usize, n: &GNorm) -> Result<Buf> {
+        let out = self.gpu.zeros(rows * DIM)?;
+        self.gpu.layernorm(x, &n.w, &n.b, &out, rows, DIM, 1e-5, false)?;
+        Ok(out)
+    }
+
+    fn rope(&self, x: &Buf, rows: usize, rotated: usize) -> Result<Buf> {
+        let out = self.gpu.zeros(rows * DIM)?;
+        self.gpu.rope(x, &self.cos, &self.sin, &out, rows, DIM, GRID * GRID, rotated)?;
+        Ok(out)
+    }
+
+    /// `softmax(q . k^T / 16) . v` for `[nq, 256]` queries and `[nk, 256]` keys and values, through `scores`
+    /// (at least `nq * nk` elements); returns `[nq, 256]`.
+    fn attention(&self, q: &Buf, k: &Buf, v: &Buf, nq: usize, nk: usize, scores: &Buf) -> Result<Buf> {
+        let g = &self.gpu;
+        g.matmul(&Matmul {
+            m: nq,
+            n: nk,
+            k: DIM,
+            batch: 1,
+            a: (q, Strides::row_major(DIM)),
+            b: (k, Strides { offset: 0, batch: 0, row: 1, col: DIM }),
+            bias: None,
+            c: (scores, Strides::row_major(nk)),
+            residual: None,
+            alpha: (DIM as f32).powf(-0.5),
+            act: Act::None,
+        })?;
+        g.softmax(scores, nq, nk)?;
+        let out = g.zeros(nq * DIM)?;
+        g.matmul(&Matmul {
+            m: nq,
+            n: DIM,
+            k: nk,
+            batch: 1,
+            a: (scores, Strides::row_major(nk)),
+            b: (v, Strides::row_major(DIM)),
+            bias: None,
+            c: (&out, Strides::row_major(DIM)),
+            residual: None,
+            alpha: 1.0,
+            act: Act::None,
+        })?;
+        Ok(out)
+    }
+
+    /// As [`crate::memattn::MemoryAttention::forward`]: `current` and `current_pos` `[4096, 256]`, `memory` and
+    /// `memory_pos` `[M, 64]`, the last `num_pointers` memory rows being object pointers (not rotated).
+    pub fn forward(&self, current: &Tensor, current_pos: &Tensor, memory: &Tensor, memory_pos: &Tensor, num_pointers: usize) -> Result<Tensor> {
+        let g = &self.gpu;
+        let _turn = g.exclusive();
+        let n = GRID * GRID;
+        if current.dims() != [n, DIM] || current_pos.dims() != [n, DIM] {
+            return Err(Error::Input(format!("current features must be [{n}, {DIM}], got {:?}", current.dims())));
+        }
+        let (m, md) = memory.dims2()?;
+        if md != 64 || memory_pos.dims() != [m, 64] {
+            return Err(Error::Input(format!("memory must be [M, 64] with a matching position encoding, got {:?}", memory.dims())));
+        }
+        let rotated = m.checked_sub(num_pointers).ok_or_else(|| Error::Input("more object pointers than memory tokens".into()))?;
+        if rotated % n != 0 {
+            return Err(Error::Input(format!("memory length {rotated} is not a multiple of {n}")));
+        }
+        let flat = |t: &Tensor| -> Result<Vec<f32>> { Ok(t.contiguous()?.flatten_all()?.to_vec1::<f32>()?) };
+        let mut x = g.upload(&flat(&(current + (current_pos * 0.1)?)?)?);
+        let mem = g.upload(&flat(memory)?);
+        let keys_in = g.upload(&flat(&(memory + memory_pos)?)?);
+        let scores = g.zeros(n * n.max(m))?;
+        for l in &self.layers {
+            // self-attention over the frame
+            let q_in = self.norm(&x, n, &l.ln1)?;
+            let (q, k, v) = (g.zeros(n * DIM)?, g.zeros(n * DIM)?, g.zeros(n * DIM)?);
+            g.linear(&q_in, n, &l.self_attn.q, &q, Act::None, None)?;
+            g.linear(&q_in, n, &l.self_attn.k, &k, Act::None, None)?;
+            g.linear(&q_in, n, &l.self_attn.v, &v, Act::None, None)?;
+            let (q, k) = (self.rope(&q, n, n)?, self.rope(&k, n, n)?);
+            let a = self.attention(&q, &k, &v, n, n, &scores)?;
+            let x1 = g.zeros(n * DIM)?;
+            g.linear(&a, n, &l.self_attn.o, &x1, Act::None, Some(&x))?;
+            // cross-attention to the memory bank
+            let q_in = self.norm(&x1, n, &l.ln2)?;
+            let q = g.zeros(n * DIM)?;
+            g.linear(&q_in, n, &l.cross.q, &q, Act::None, None)?;
+            let q = self.rope(&q, n, n)?;
+            let (k, v) = (g.zeros(m * DIM)?, g.zeros(m * DIM)?);
+            g.linear(&keys_in, m, &l.cross.k, &k, Act::None, None)?;
+            g.linear(&mem, m, &l.cross.v, &v, Act::None, None)?;
+            let k = self.rope(&k, m, rotated)?;
+            let a = self.attention(&q, &k, &v, n, m, &scores)?;
+            let x2 = g.zeros(n * DIM)?;
+            g.linear(&a, n, &l.cross.o, &x2, Act::None, Some(&x1))?;
+            // feed-forward
+            let f_in = self.norm(&x2, n, &l.ln3)?;
+            let hidden = g.zeros(n * 2048)?;
+            g.linear(&f_in, n, &l.lin1, &hidden, Act::Relu, None)?;
+            let x3 = g.zeros(n * DIM)?;
+            g.linear(&hidden, n, &l.lin2, &x3, Act::None, Some(&x2))?;
+            x = x3;
+        }
+        let out = self.norm(&x, n, &self.final_ln)?;
+        g.flush()?;
+        Ok(Tensor::from_vec(g.download(&out)?, (n, DIM), &Device::Cpu)?)
+    }
+}
diff --git a/crates/sam2/src/gpu/memenc.rs b/crates/sam2/src/gpu/memenc.rs
new file mode 100644
index 000000000..2cfa693d0
--- /dev/null
+++ b/crates/sam2/src/gpu/memenc.rs
@@ -0,0 +1,127 @@
+// Original work for EffectCraft; the maths follows the Hugging Face `transformers` SAM 2 video
+// implementation (Apache-2.0, see NOTICE).
+//! The memory encoder on the GPU: the mask is down-sampled by four strided convolutions, fused with the
+//! frame's features by two ConvNeXt-style blocks, and projected to the 64 channels of a memory.
+
+use std::sync::Arc;
+
+use candle_core::{Device, Tensor};
+
+use super::{Act, Buf, GLinear, GNorm, Gpu};
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+struct GConv {
+    w: Buf,
+    b: Buf,
+    ci: usize,
+    co: usize,
+    k: usize,
+}
+
+struct GFuser {
+    dw: GConv,
+    norm: GNorm,
+    pw1: GLinear,
+    /// The layer scale is folded into this layer's weights.
+    pw2: GLinear,
+}
+
+pub struct GpuMemoryEncoder {
+    gpu: Arc<Gpu>,
+    down: Vec<(GConv, GNorm)>,
+    final_conv: GLinear,
+    feature_projection: GLinear,
+    fuser: Vec<GFuser>,
+    projection: GLinear,
+}
+
+fn conv(g: &Gpu, w: &Weights, name: &str, ci: usize, co: usize, k: usize, groups: usize) -> Result<GConv> {
+    let flat = |t: Tensor| -> Result<Vec<f32>> { Ok(t.flatten_all()?.to_vec1::<f32>()?) };
+    Ok(GConv {
+        w: g.upload(&flat(w.get(&format!("{name}.weight"), &[co, ci / groups, k, k])?)?),
+        b: g.upload(&flat(w.get(&format!("{name}.bias"), &[co])?)?),
+        ci,
+        co,
+        k,
+    })
+}
+
+impl GpuMemoryEncoder {
+    pub fn load(gpu: Arc<Gpu>, w: &Weights) -> Result<GpuMemoryEncoder> {
+        let mut down = vec![];
+        let mut ch = 1;
+        for i in 0..4 {
+            let out = ch * 4;
+            let p = format!("memory_encoder.mask_downsampler.layers.{i}");
+            down.push((conv(&gpu, w, &format!("{p}.conv"), ch, out, 3, 1)?, GNorm::load(&gpu, w, &format!("{p}.layer_norm"), out)?));
+            ch = out;
+        }
+        let fuser = (0..2)
+            .map(|i| {
+                let p = format!("memory_encoder.memory_fuser.layers.{i}");
+                let scale = w.get(&format!("{p}.scale"), &[256])?.flatten_all()?.to_vec1::<f32>()?;
+                Ok(GFuser {
+                    dw: conv(&gpu, w, &format!("{p}.depthwise_conv"), 256, 256, 7, 256)?,
+                    norm: GNorm::load(&gpu, w, &format!("{p}.layer_norm"), 256)?,
+                    pw1: GLinear::load(&gpu, w, &format!("{p}.pointwise_conv1"), 256, 1024)?,
+                    pw2: GLinear::load_scaled(&gpu, w, &format!("{p}.pointwise_conv2"), 1024, 256, &scale)?,
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+        Ok(GpuMemoryEncoder {
+            final_conv: GLinear::load_conv1x1(&gpu, w, "memory_encoder.mask_downsampler.final_conv", 256, 256)?,
+            feature_projection: GLinear::load_conv1x1(&gpu, w, "memory_encoder.feature_projection", 256, 256)?,
+            projection: GLinear::load_conv1x1(&gpu, w, "memory_encoder.projection", 256, 64)?,
+            down,
+            fuser,
+            gpu,
+        })
+    }
+
+    /// `features`: `[1, 256, 64, 64]`; `mask`: `[1, 1, 1024, 1024]` already scaled (`20 m - 10`). Returns the raw
+    /// memory tokens `[4096, 64]` (the occlusion embedding and bfloat16 rounding are the caller's).
+    pub fn encode(&self, features: &Tensor, mask: &Tensor) -> Result<Tensor> {
+        let g = &self.gpu;
+        let _turn = g.exclusive();
+        let flat = |t: &Tensor| -> Result<Vec<f32>> { Ok(t.contiguous()?.flatten_all()?.to_vec1::<f32>()?) };
+        if features.dims() != [1, 256, 64, 64] || mask.dims() != [1, 1, 1024, 1024] {
+            return Err(Error::Input(format!("memory encoder input shapes {:?} / {:?}", features.dims(), mask.dims())));
+        }
+        let tokens = features.permute((0, 2, 3, 1))?.contiguous()?;
+        let ftok = g.upload(&flat(&tokens)?);
+        let mut cur = g.upload(&flat(mask)?);
+        let (mut h, mut w) = (1024usize, 1024usize);
+        for (c, ln) in &self.down {
+            let (ho, wo) = (h / 2, w / 2);
+            let raw = g.zeros(ho * wo * c.co)?;
+            g.conv2d(&cur, &c.w, &c.b, &raw, (h, w, c.ci, c.co), c.k, 2, 1, 1)?;
+            let normed = g.zeros(ho * wo * c.co)?;
+            g.layernorm(&raw, &ln.w, &ln.b, &normed, ho * wo, c.co, 1e-6, true)?;
+            (cur, h, w) = (normed, ho, wo);
+        }
+        let n = h * w;
+        if n != 4096 {
+            return Err(Error::Compute(format!("the mask down-sampler ended at {w}x{h}, not 64x64")));
+        }
+        let m = g.zeros(n * 256)?;
+        g.linear(&cur, n, &self.final_conv, &m, Act::None, None)?;
+        let mut x = g.zeros(n * 256)?;
+        g.linear(&ftok, n, &self.feature_projection, &x, Act::None, Some(&m))?;
+        for b in &self.fuser {
+            let d = g.zeros(n * 256)?;
+            g.conv2d(&x, &b.dw.w, &b.dw.b, &d, (h, w, 256, 256), 7, 1, 3, 256)?;
+            let normed = g.zeros(n * 256)?;
+            g.layernorm(&d, &b.norm.w, &b.norm.b, &normed, n, 256, 1e-6, false)?;
+            let hidden = g.zeros(n * 1024)?;
+            g.linear(&normed, n, &b.pw1, &hidden, Act::Gelu, None)?;
+            let next = g.zeros(n * 256)?;
+            g.linear(&hidden, n, &b.pw2, &next, Act::None, Some(&x))?;
+            x = next;
+        }
+        let out = g.zeros(n * 64)?;
+        g.linear(&x, n, &self.projection, &out, Act::None, None)?;
+        g.flush()?;
+        Ok(Tensor::from_vec(g.download(&out)?, (n, 64), &Device::Cpu)?)
+    }
+}
diff --git a/crates/sam2/src/gpu/ops.rs b/crates/sam2/src/gpu/ops.rs
new file mode 100644
index 000000000..08143724e
--- /dev/null
+++ b/crates/sam2/src/gpu/ops.rs
@@ -0,0 +1,219 @@
+//! The non-matmul kernels, as methods of [`Gpu`] (each queues one dispatch).
+
+use super::{Buf, Gpu};
+use crate::{Error, Result};
+
+fn n32(v: usize, what: &str) -> Result<u32> {
+    u32::try_from(v).map_err(|_| Error::Compute(format!("{what} {v} does not fit a GPU index")))
+}
+
+/// A 2-D grid of groups covering `groups` (a dimension holds 65535).
+fn grid(groups: usize) -> Result<(u32, u32, u32)> {
+    let gx = groups.clamp(1, 65535);
+    Ok((n32(gx, "groups")?, n32(groups.div_ceil(gx).max(1), "groups")?, 1))
+}
+
+/// One 256-thread group per 256 items.
+fn items(n: usize) -> Result<(u32, u32, u32)> {
+    grid(n.div_ceil(256))
+}
+
+fn need(buf: &Buf, len: usize, what: &str) -> Result<()> {
+    if buf.len < len {
+        return Err(Error::Input(format!("{what}: a buffer of {} elements is smaller than the {len} needed", buf.len)));
+    }
+    Ok(())
+}
+
+impl Gpu {
+    /// `y = layer_norm(x) * weight + bias` over the last dimension of a `[rows, cols]` buffer.
+    #[allow(clippy::too_many_arguments)]
+    pub fn layernorm(&self, x: &Buf, weight: &Buf, bias: &Buf, y: &Buf, rows: usize, cols: usize, eps: f32, gelu: bool) -> Result<()> {
+        need(x, rows * cols, "layernorm x")?;
+        need(y, rows * cols, "layernorm y")?;
+        need(weight, cols, "layernorm weight")?;
+        need(bias, cols, "layernorm bias")?;
+        self.run(
+            "layernorm",
+            &[(0, x), (1, weight), (2, bias), (3, y)],
+            &[n32(rows, "rows")?, n32(cols, "cols")?, eps.to_bits(), u32::from(gelu)],
+            grid(rows)?,
+        );
+        Ok(())
+    }
+
+    /// Softmax over each of `rows` rows of `cols`, in place.
+    pub fn softmax(&self, x: &Buf, rows: usize, cols: usize) -> Result<()> {
+        need(x, rows * cols, "softmax")?;
+        self.run("softmax", &[(3, x)], &[n32(rows, "rows")?, n32(cols, "cols")?], grid(rows)?);
+        Ok(())
+    }
+
+    /// A convolution over channels-last `[h, w, ci]` with weight `[co, ci / groups, k, k]` and bias `[co]`,
+    /// output `[ho, wo, co]` (`groups == ci == co` is depthwise).
+    #[allow(clippy::too_many_arguments)]
+    pub fn conv2d(
+        &self,
+        x: &Buf,
+        weight: &Buf,
+        bias: &Buf,
+        out: &Buf,
+        dims: (usize, usize, usize, usize),
+        k: usize,
+        stride: usize,
+        pad: usize,
+        groups: usize,
+    ) -> Result<()> {
+        let (h, w, ci, co) = dims;
+        if k == 0 || stride == 0 || groups == 0 || ci % groups != 0 || co % groups != 0 || h + 2 * pad < k || w + 2 * pad < k {
+            return Err(Error::Input(format!("a {k}x{k} convolution (stride {stride}, groups {groups}) does not fit {w}x{h}x{ci} -> {co}")));
+        }
+        let (ho, wo) = ((h + 2 * pad - k) / stride + 1, (w + 2 * pad - k) / stride + 1);
+        need(x, h * w * ci, "conv2d input")?;
+        need(weight, co * (ci / groups) * k * k, "conv2d weight")?;
+        need(bias, co, "conv2d bias")?;
+        need(out, ho * wo * co, "conv2d output")?;
+        let n = ho * wo * co;
+        self.run(
+            "conv2d",
+            &[(0, x), (1, weight), (2, bias), (3, out)],
+            &[
+                n32(n, "n")?,
+                n32(h, "h")?,
+                n32(w, "w")?,
+                n32(ci, "ci")?,
+                n32(co, "co")?,
+                n32(ho, "ho")?,
+                n32(wo, "wo")?,
+                n32(k, "k")?,
+                n32(stride, "stride")?,
+                n32(pad, "pad")?,
+                n32(groups, "groups")?,
+            ],
+            items(n)?,
+        );
+        Ok(())
+    }
+
+    /// `out = a + b` over `n` elements.
+    pub fn add(&self, a: &Buf, b: &Buf, out: &Buf, n: usize) -> Result<()> {
+        need(a, n, "add a")?;
+        need(b, n, "add b")?;
+        need(out, n, "add out")?;
+        self.run("add", &[(0, a), (1, b), (3, out)], &[n32(n, "n")?], items(n)?);
+        Ok(())
+    }
+
+    /// `[h, w, c]` to `[windows, ws, ws, c]`, zero padded at the bottom and right.
+    pub fn window_partition(&self, x: &Buf, out: &Buf, h: usize, w: usize, c: usize, ws: usize) -> Result<()> {
+        if ws == 0 {
+            return Err(Error::Input("window size 0".into()));
+        }
+        let (nwx, nwy) = (w.div_ceil(ws), h.div_ceil(ws));
+        let n = nwx * nwy * ws * ws * c;
+        need(x, h * w * c, "window_partition input")?;
+        need(out, n, "window_partition output")?;
+        self.run(
+            "window_partition",
+            &[(0, x), (3, out)],
+            &[n32(n, "n")?, n32(h, "h")?, n32(w, "w")?, n32(c, "c")?, n32(ws, "ws")?, n32(nwx, "windows")?],
+            items(n)?,
+        );
+        Ok(())
+    }
+
+    /// The inverse of [`Gpu::window_partition`] (the padding is dropped).
+    pub fn window_unpartition(&self, x: &Buf, out: &Buf, h: usize, w: usize, c: usize, ws: usize) -> Result<()> {
+        if ws == 0 {
+            return Err(Error::Input("window size 0".into()));
+        }
+        let (nwx, nwy) = (w.div_ceil(ws), h.div_ceil(ws));
+        need(x, nwx * nwy * ws * ws * c, "window_unpartition input")?;
+        need(out, h * w * c, "window_unpartition output")?;
+        self.run(
+            "window_unpartition",
+            &[(0, x), (3, out)],
+            &[n32(h * w * c, "n")?, n32(h, "h")?, n32(w, "w")?, n32(c, "c")?, n32(ws, "ws")?, n32(nwx, "windows")?],
+            items(h * w * c)?,
+        );
+        Ok(())
+    }
+
+    /// 2 x 2 max pool of `nb` images of `[h, w, c]` tokens (`h` and `w` even) read with the given strides
+    /// (image, row, token) so it can pool one third of a qkv buffer in place; output contiguous.
+    #[allow(clippy::too_many_arguments)]
+    pub fn maxpool2(&self, x: &Buf, out: &Buf, nb: usize, h: usize, w: usize, c: usize, strides: (usize, usize, usize)) -> Result<()> {
+        if !h.is_multiple_of(2) || !w.is_multiple_of(2) {
+            return Err(Error::Input(format!("maxpool2 needs even sizes, got {w}x{h}")));
+        }
+        let n = nb * (h / 2) * (w / 2) * c;
+        let last = (nb.saturating_sub(1)) * strides.0 + (h - 1) * strides.1 + (w - 1) * strides.2 + c;
+        need(x, last, "maxpool2 input")?;
+        need(out, n, "maxpool2 output")?;
+        self.run(
+            "maxpool2",
+            &[(0, x), (3, out)],
+            &[
+                n32(n, "n")?,
+                n32(nb, "nb")?,
+                n32(h, "h")?,
+                n32(w, "w")?,
+                n32(c, "c")?,
+                n32(strides.0, "stride")?,
+                n32(strides.1, "stride")?,
+                n32(strides.2, "stride")?,
+            ],
+            items(n)?,
+        );
+        Ok(())
+    }
+
+    /// The patch embedding: `[3, h, w]` pixels, weight `[co, 3, 7, 7]`, bias `[co]`; output `[h/4, w/4, co]`.
+    pub fn patch_embed(&self, pixels: &Buf, weight: &Buf, bias: &Buf, out: &Buf, (h, w, co): (usize, usize, usize)) -> Result<()> {
+        let (ho, wo) = ((h + 6 - 7) / 4 + 1, (w + 6 - 7) / 4 + 1);
+        need(pixels, 3 * h * w, "patch_embed pixels")?;
+        need(weight, co * 3 * 49, "patch_embed weight")?;
+        need(bias, co, "patch_embed bias")?;
+        need(out, ho * wo * co, "patch_embed output")?;
+        let n = ho * wo * co;
+        self.run(
+            "patch_embed",
+            &[(0, pixels), (1, weight), (2, bias), (3, out)],
+            &[n32(n, "n")?, n32(h, "h")?, n32(w, "w")?, n32(co, "co")?, n32(ho, "ho")?, n32(wo, "wo")?],
+            items(n)?,
+        );
+        Ok(())
+    }
+
+    /// Rotary encoding of `[rows, cols]`: rows below `rotated` are rotated with the `[table_rows, cols]`
+    /// tables (row `r` uses table row `r % table_rows`), the rest copied.
+    #[allow(clippy::too_many_arguments)]
+    pub fn rope(&self, x: &Buf, cos: &Buf, sin: &Buf, out: &Buf, rows: usize, cols: usize, table_rows: usize, rotated: usize) -> Result<()> {
+        if !cols.is_multiple_of(2) || table_rows == 0 {
+            return Err(Error::Input("rope needs an even width and a table".into()));
+        }
+        need(x, rows * cols, "rope input")?;
+        need(out, rows * cols, "rope output")?;
+        need(cos, table_rows * cols, "rope cos")?;
+        need(sin, table_rows * cols, "rope sin")?;
+        self.run(
+            "rope",
+            &[(0, x), (1, cos), (2, sin), (3, out)],
+            &[n32(rows * cols, "n")?, n32(cols, "cols")?, n32(table_rows, "table")?, n32(rotated.min(rows), "rotated")?],
+            items(rows * cols)?,
+        );
+        Ok(())
+    }
+
+    /// `out = lateral + nearest_upsample_2x(prev)` for `[h, w, c]` (`h` and `w` even).
+    pub fn upsample_add(&self, lateral: &Buf, prev: &Buf, out: &Buf, h: usize, w: usize, c: usize) -> Result<()> {
+        if !h.is_multiple_of(2) || !w.is_multiple_of(2) {
+            return Err(Error::Input(format!("upsample_add needs even sizes, got {w}x{h}")));
+        }
+        need(lateral, h * w * c, "upsample_add lateral")?;
+        need(prev, h / 2 * (w / 2) * c, "upsample_add prev")?;
+        need(out, h * w * c, "upsample_add out")?;
+        self.run("upsample_add", &[(0, lateral), (1, prev), (3, out)], &[n32(h * w * c, "n")?, n32(h, "h")?, n32(w, "w")?, n32(c, "c")?], items(h * w * c)?);
+        Ok(())
+    }
+}
diff --git a/crates/sam2/src/gpu/tests.rs b/crates/sam2/src/gpu/tests.rs
new file mode 100644
index 000000000..e974c34df
--- /dev/null
+++ b/crates/sam2/src/gpu/tests.rs
@@ -0,0 +1,454 @@
+//! Each kernel against a plain CPU computation. They skip when there is no GPU.
+
+use std::sync::{Mutex, PoisonError};
+
+use super::*;
+
+/// The one device the tests share (several devices at once upset the Vulkan loader), held for the whole
+/// test so the tests take turns.
+pub(crate) struct Shared(#[allow(dead_code)] std::sync::MutexGuard<'static, ()>, Arc<Gpu>);
+
+impl std::ops::Deref for Shared {
+    type Target = Gpu;
+    fn deref(&self) -> &Gpu {
+        &self.1
+    }
+}
+
+pub(crate) fn gpu() -> Option<Shared> {
+    static TURN: Mutex<()> = Mutex::new(());
+    let guard = TURN.lock().unwrap_or_else(PoisonError::into_inner);
+    match Gpu::shared() {
+        Ok(g) => Some(Shared(guard, g)),
+        Err(e) => {
+            eprintln!("skipped: {e}");
+            None
+        }
+    }
+}
+
+/// Deterministic pseudo-random values in -1..1.
+pub(crate) fn noise(n: usize, seed: u32) -> Vec<f32> {
+    let mut s = seed.wrapping_mul(2654435761).wrapping_add(1);
+    (0..n)
+        .map(|_| {
+            s ^= s << 13;
+            s ^= s >> 17;
+            s ^= s << 5;
+            (s % 20001) as f32 / 10000.0 - 1.0
+        })
+        .collect()
+}
+
+pub(crate) fn assert_close(got: &[f32], want: &[f32], tol: f32, what: &str) {
+    assert_eq!(got.len(), want.len(), "{what}: length");
+    let worst = got.iter().zip(want).map(|(a, b)| (a - b).abs()).fold(0f32, f32::max);
+    assert!(worst <= tol, "{what}: max abs error {worst} (tolerance {tol})");
+}
+
+fn gelu(x: f32) -> f32 {
+    use candle_core::{Device, Tensor};
+    let t = Tensor::new(&[x], &Device::Cpu).and_then(|t| t.gelu_erf()).and_then(|t| t.to_vec1::<f32>());
+    t.map(|v| v[0]).unwrap_or(f32::NAN)
+}
+
+/// `C[b][i][j] = sum_k A[b][i][k] * B[b][k][j]` by the definition, with the strides given.
+#[allow(clippy::too_many_arguments)]
+fn naive(a: &[f32], sa: Strides, b: &[f32], sb: Strides, m: usize, n: usize, k: usize, batch: usize) -> Vec<f32> {
+    let mut c = vec![0f32; batch * m * n];
+    for z in 0..batch {
+        for i in 0..m {
+            for j in 0..n {
+                let mut acc = 0f32;
+                for l in 0..k {
+                    acc += a[sa.offset + z * sa.batch + i * sa.row + l * sa.col] * b[sb.offset + z * sb.batch + l * sb.row + j * sb.col];
+                }
+                c[z * m * n + i * n + j] = acc;
+            }
+        }
+    }
+    c
+}
+
+#[test]
+fn matmul_matches_the_definition_for_awkward_sizes_and_strides() {
+    let Some(g) = gpu() else { return };
+    // (m, n, k, batch): not multiples of the 64 x 64 x 16 tile, and degenerate ones
+    for (m, n, k, batch) in [(100, 50, 37, 1), (1, 1, 1, 1), (65, 129, 17, 2), (64, 64, 16, 1), (3, 200, 96, 3), (130, 7, 300, 1)] {
+        let (av, bv) = (noise(batch * m * k, 1), noise(batch * k * n, 2));
+        let (a, b) = (g.upload(&av), g.upload(&bv));
+        let c = g.zeros(batch * m * n).unwrap();
+        let (sa, sb) = (Strides { offset: 0, batch: m * k, row: k, col: 1 }, Strides { offset: 0, batch: k * n, row: n, col: 1 });
+        let sc = Strides { offset: 0, batch: m * n, row: n, col: 1 };
+        g.matmul(&Matmul { m, n, k, batch, a: (&a, sa), b: (&b, sb), bias: None, c: (&c, sc), residual: None, alpha: 1.0, act: Act::None }).unwrap();
+        g.flush().unwrap();
+        assert_close(&g.download(&c).unwrap(), &naive(&av, sa, &bv, sb, m, n, k, batch), 2e-4 * (k as f32).sqrt(), &format!("{m}x{n}x{k} x{batch}"));
+    }
+}
+
+#[test]
+fn matmul_rejects_nonunit_output_columns() {
+    let Some(g) = gpu() else { return };
+    let value = g.upload(&[1.0]);
+    let c = g.zeros(8).unwrap();
+    for col in [0, 2] {
+        let broadcast = Strides { offset: 0, batch: 0, row: 0, col: 0 };
+        let out = Strides { offset: 0, batch: 0, row: 4, col };
+        let op = Matmul {
+            m: 2,
+            n: 2,
+            k: 1,
+            batch: 1,
+            a: (&value, broadcast),
+            b: (&value, broadcast),
+            c: (&c, out),
+            bias: None,
+            residual: None,
+            alpha: 1.0,
+            act: Act::None,
+        };
+        assert!(matches!(g.matmul(&op), Err(Error::Input(_))), "output column stride {col}");
+    }
+}
+
+#[test]
+fn matmul_zero_inner_dimension_checks_output_and_writes_bias() {
+    let Some(g) = gpu() else { return };
+    let empty = g.upload(&[]);
+    let tiny = g.zeros(1).unwrap();
+    let bias = g.upload(&[3.0, 5.0]);
+    let mut op = Matmul {
+        m: 2,
+        n: 2,
+        k: 0,
+        batch: 1,
+        a: (&empty, Strides::row_major(0)),
+        b: (&empty, Strides::row_major(2)),
+        c: (&tiny, Strides::row_major(2)),
+        bias: Some(&bias),
+        residual: None,
+        alpha: 1.0,
+        act: Act::None,
+    };
+    assert!(matches!(g.matmul(&op), Err(Error::Input(_))), "C is written even when K is zero");
+    let c = g.zeros(4).unwrap();
+    op.c = (&c, Strides::row_major(2));
+    g.matmul(&op).unwrap();
+    g.flush().unwrap();
+    assert_eq!(g.download(&c).unwrap(), [3.0, 5.0, 3.0, 5.0]);
+}
+
+#[test]
+fn matmul_rejects_overflowing_operand_offsets() {
+    let Some(g) = gpu() else { return };
+    let value = g.upload(&[1.0]);
+    let c = g.zeros(4).unwrap();
+    let broadcast = Strides { offset: 0, batch: 0, row: 0, col: 0 };
+    let out = Strides { offset: usize::MAX, batch: 0, row: 1, col: 1 };
+    let op = Matmul {
+        m: 2,
+        n: 1,
+        k: 1,
+        batch: 1,
+        a: (&value, broadcast),
+        b: (&value, broadcast),
+        c: (&c, out),
+        bias: None,
+        residual: None,
+        alpha: 1.0,
+        act: Act::None,
+    };
+    assert!(matches!(g.matmul(&op), Err(Error::Input(_))));
+}
+
+#[test]
+fn matmul_with_transposed_operands_bias_activation_and_residual() {
+    let Some(g) = gpu() else { return };
+    let (m, n, k) = (70, 90, 41);
+    let (av, wv, bias, res) = (noise(m * k, 3), noise(n * k, 4), noise(n, 5), noise(m * n, 6));
+    let (a, w, bi, r) = (g.upload(&av), g.upload(&wv), g.upload(&bias), g.upload(&res));
+    let c = g.zeros(m * n).unwrap();
+    // B is a weight stored [n, k] (a linear layer): B[k][j] = w[j * k + l]
+    let sb = Strides { offset: 0, batch: 0, row: 1, col: k };
+    let sa = Strides::row_major(k);
+    g.matmul(&Matmul {
+        m,
+        n,
+        k,
+        batch: 1,
+        a: (&a, sa),
+        b: (&w, sb),
+        bias: Some(&bi),
+        c: (&c, Strides::row_major(n)),
+        residual: Some(&r),
+        alpha: 0.5,
+        act: Act::Gelu,
+    })
+    .unwrap();
+    g.flush().unwrap();
+    let base = naive(&av, sa, &wv, sb, m, n, k, 1);
+    let want: Vec<f32> = base.iter().enumerate().map(|(i, v)| gelu(v * 0.5 + bias[i % n]) + res[i]).collect();
+    assert_close(&g.download(&c).unwrap(), &want, 1e-3, "linear + gelu + residual");
+    // relu, and a transposed A (m contiguous)
+    let at: Vec<f32> = (0..k * m).map(|i| av[(i % m) * k + i / m]).collect();
+    let (a2, c2) = (g.upload(&at), g.zeros(m * n).unwrap());
+    g.matmul(&Matmul {
+        m,
+        n,
+        k,
+        batch: 1,
+        a: (&a2, Strides { offset: 0, batch: 0, row: 1, col: m }),
+        b: (&w, sb),
+        bias: None,
+        c: (&c2, Strides::row_major(n)),
+        residual: None,
+        alpha: 1.0,
+        act: Act::Relu,
+    })
+    .unwrap();
+    g.flush().unwrap();
+    let want: Vec<f32> = base.iter().map(|v| v.max(0.0)).collect();
+    assert_close(&g.download(&c2).unwrap(), &want, 1e-3, "transposed A, relu");
+}
+
+#[test]
+fn matmul_refuses_operands_that_overrun_their_buffers() {
+    let Some(g) = gpu() else { return };
+    let (a, b, c) = (g.upload(&[1.0; 6]), g.upload(&[1.0; 6]), g.zeros(4).unwrap());
+    let ok = Matmul {
+        m: 2,
+        n: 2,
+        k: 3,
+        batch: 1,
+        a: (&a, Strides::row_major(3)),
+        b: (&b, Strides::row_major(2)),
+        bias: None,
+        c: (&c, Strides::row_major(2)),
+        residual: None,
+        alpha: 1.0,
+        act: Act::None,
+    };
+    assert!(g.matmul(&ok).is_ok());
+    let too_big = Matmul { m: 2, n: 2, k: 4, ..ok };
+    assert!(matches!(g.matmul(&too_big), Err(Error::Input(_))));
+    assert!(g.zeros(usize::MAX / 2).is_err());
+    g.flush().unwrap();
+}
+
+// ---------------------------------------------------------------- the other kernels
+
+fn run_and_read(g: &Gpu, out: &Buf) -> Vec<f32> {
+    g.flush().unwrap();
+    g.download(out).unwrap()
+}
+
+#[test]
+fn layernorm_and_softmax_match_the_definition() {
+    let Some(g) = gpu() else { return };
+    for (rows, cols) in [(7, 96), (1, 1), (300, 768), (70_000, 8)] {
+        let x = noise(rows * cols, 7);
+        let (w, b) = (noise(cols, 8), noise(cols, 9));
+        let (gx, gw, gb, gy) = (g.upload(&x), g.upload(&w), g.upload(&b), g.zeros(rows * cols).unwrap());
+        g.layernorm(&gx, &gw, &gb, &gy, rows, cols, 1e-6, false).unwrap();
+        let want: Vec<f32> = x
+            .chunks(cols)
+            .flat_map(|r| {
+                let mean = r.iter().sum::<f32>() / cols as f32;
+                let var = r.iter().map(|v| (v - mean).powi(2)).sum::<f32>() / cols as f32;
+                r.iter().enumerate().map(|(i, v)| (v - mean) / (var + 1e-6).sqrt() * w[i] + b[i]).collect::<Vec<_>>()
+            })
+            .collect();
+        assert_close(&run_and_read(&g, &gy), &want, 2e-4, &format!("layernorm {rows}x{cols}"));
+    }
+    for (rows, cols) in [(5, 64), (3, 1), (100, 4096), (2, 28736), (70_000, 64)] {
+        let x = noise(rows * cols, 10).iter().map(|v| v * 6.0).collect::<Vec<_>>();
+        let gx = g.upload(&x);
+        g.softmax(&gx, rows, cols).unwrap();
+        let want: Vec<f32> = x
+            .chunks(cols)
+            .flat_map(|r| {
+                let m = r.iter().cloned().fold(f32::MIN, f32::max);
+                let e: Vec<f32> = r.iter().map(|v| (v - m).exp()).collect();
+                let s: f32 = e.iter().sum();
+                e.into_iter().map(|v| v / s).collect::<Vec<_>>()
+            })
+            .collect();
+        assert_close(&run_and_read(&g, &gx), &want, 1e-5, &format!("softmax {rows}x{cols}"));
+    }
+}
+
+#[test]
+fn windows_pooling_and_add_match_naive_loops() {
+    let Some(g) = gpu() else { return };
+    let (h, w, c, ws) = (13, 22, 5, 8);
+    let x = noise(h * w * c, 11);
+    let (nwx, nwy) = (w.div_ceil(ws), h.div_ceil(ws));
+    let (gx, parts, back) = (g.upload(&x), g.zeros(nwx * nwy * ws * ws * c).unwrap(), g.zeros(h * w * c).unwrap());
+    g.window_partition(&gx, &parts, h, w, c, ws).unwrap();
+    g.window_unpartition(&parts, &back, h, w, c, ws).unwrap();
+    let mut want = vec![0f32; nwx * nwy * ws * ws * c];
+    for win in 0..nwx * nwy {
+        for y in 0..ws {
+            for xx in 0..ws {
+                let (gy, gxx) = ((win / nwx) * ws + y, (win % nwx) * ws + xx);
+                for ch in 0..c {
+                    if gy < h && gxx < w {
+                        want[((win * ws + y) * ws + xx) * c + ch] = x[(gy * w + gxx) * c + ch];
+                    }
+                }
+            }
+        }
+    }
+    g.flush().unwrap();
+    assert_close(&g.download(&parts).unwrap(), &want, 0.0, "window_partition");
+    assert_close(&g.download(&back).unwrap(), &x, 0.0, "window round trip");
+    assert!(g.window_partition(&gx, &parts, h, w, c, 0).is_err());
+
+    // pooling a q third of a [nb, 8, 6, 3 * c] buffer in place
+    let (nb, ph, pw, pc) = (3, 8, 6, 4);
+    let qkv = noise(nb * ph * pw * 3 * pc, 12);
+    let (gq, out) = (g.upload(&qkv), g.zeros(nb * (ph / 2) * (pw / 2) * pc).unwrap());
+    g.maxpool2(&gq, &out, nb, ph, pw, pc, (ph * pw * 3 * pc, pw * 3 * pc, 3 * pc)).unwrap();
+    let mut want = vec![];
+    for img in 0..nb {
+        for oy in 0..ph / 2 {
+            for ox in 0..pw / 2 {
+                for ch in 0..pc {
+                    let at = |y: usize, xx: usize| qkv[((img * ph + y) * pw + xx) * 3 * pc + ch];
+                    want.push(at(2 * oy, 2 * ox).max(at(2 * oy, 2 * ox + 1)).max(at(2 * oy + 1, 2 * ox)).max(at(2 * oy + 1, 2 * ox + 1)));
+                }
+            }
+        }
+    }
+    assert_close(&run_and_read(&g, &out), &want, 0.0, "maxpool2");
+    assert!(g.maxpool2(&gq, &out, nb, 7, pw, pc, (1, 1, 1)).is_err());
+
+    let (a, b) = (noise(100_001, 13), noise(100_001, 14));
+    let (ga, gb, go) = (g.upload(&a), g.upload(&b), g.zeros(a.len()).unwrap());
+    g.add(&ga, &gb, &go, a.len()).unwrap();
+    let want: Vec<f32> = a.iter().zip(&b).map(|(x, y)| x + y).collect();
+    assert_close(&run_and_read(&g, &go), &want, 0.0, "add");
+}
+
+#[test]
+fn patch_embed_rope_and_upsample_match_the_cpu_definitions() {
+    use candle_core::{Device, Tensor};
+    let Some(g) = gpu() else { return };
+    // the 7 x 7 stride 4 convolution against candle's conv2d
+    let (h, w, co) = (64usize, 96usize, 8usize);
+    let (px, wt, bias) = (noise(3 * h * w, 15), noise(co * 147, 16), noise(co, 17));
+    let (gp, gw, gb) = (g.upload(&px), g.upload(&wt), g.upload(&bias));
+    let (ho, wo) = (h / 4, w / 4);
+    let out = g.zeros(ho * wo * co).unwrap();
+    g.patch_embed(&gp, &gw, &gb, &out, (h, w, co)).unwrap();
+    let t = Tensor::from_vec(px, (1, 3, h, w), &Device::Cpu).unwrap();
+    let k = Tensor::from_vec(wt, (co, 3, 7, 7), &Device::Cpu).unwrap();
+    let want =
+        t.conv2d(&k, 3, 4, 1, 1).unwrap().broadcast_add(&Tensor::from_vec(bias, (1, co, 1, 1), &Device::Cpu).unwrap()).unwrap().permute((0, 2, 3, 1)).unwrap();
+    assert_close(&run_and_read(&g, &out), &want.flatten_all().unwrap().to_vec1::<f32>().unwrap(), 2e-4, "patch_embed");
+
+    // rotary encoding: pairs rotated with row % table rows, later rows copied
+    let (rows, cols, table, rotated) = (37usize, 16usize, 10usize, 30usize);
+    let (x, cs, sn) = (noise(rows * cols, 18), noise(table * cols, 19), noise(table * cols, 20));
+    let (gx, gc, gs, go) = (g.upload(&x), g.upload(&cs), g.upload(&sn), g.zeros(rows * cols).unwrap());
+    g.rope(&gx, &gc, &gs, &go, rows, cols, table, rotated).unwrap();
+    let mut want = x.clone();
+    for r in 0..rotated {
+        for j in 0..cols / 2 {
+            let (x0, x1) = (x[r * cols + 2 * j], x[r * cols + 2 * j + 1]);
+            let (t0, t1) = ((r % table) * cols + 2 * j, (r % table) * cols + 2 * j + 1);
+            want[r * cols + 2 * j] = x0 * cs[t0] - x1 * sn[t0];
+            want[r * cols + 2 * j + 1] = x1 * cs[t1] + x0 * sn[t1];
+        }
+    }
+    assert_close(&run_and_read(&g, &go), &want, 1e-6, "rope");
+    assert!(g.rope(&gx, &gc, &gs, &go, rows, 15, table, rotated).is_err());
+
+    // neck: lateral + nearest upsample
+    let (h, w, c) = (6usize, 10usize, 7usize);
+    let (lat, prev) = (noise(h * w * c, 21), noise(h / 2 * (w / 2) * c, 22));
+    let (gl, gp2, go) = (g.upload(&lat), g.upload(&prev), g.zeros(h * w * c).unwrap());
+    g.upsample_add(&gl, &gp2, &go, h, w, c).unwrap();
+    let want: Vec<f32> = (0..h * w * c).map(|i| lat[i] + prev[((i / c / w / 2) * (w / 2) + (i / c % w) / 2) * c + i % c]).collect();
+    assert_close(&run_and_read(&g, &go), &want, 0.0, "upsample_add");
+}
+
+#[test]
+fn convolutions_and_the_layernorm_gelu_epilogue_match_candle() {
+    use candle_core::{Device, Tensor};
+    let Some(g) = gpu() else { return };
+    // (h, w, ci, co, k, stride, pad, groups): a strided 3 x 3, a depthwise 7 x 7, and a 1-channel input
+    for (h, w, ci, co, k, stride, pad, groups) in
+        [(9usize, 13usize, 3usize, 5usize, 3usize, 2usize, 1usize, 1usize), (10, 10, 4, 4, 7, 1, 3, 4), (16, 16, 1, 4, 3, 2, 1, 1)]
+    {
+        let (x, wt, b) = (noise(h * w * ci, 30), noise(co * (ci / groups) * k * k, 31), noise(co, 32));
+        let (gx, gw, gb) = (g.upload(&x), g.upload(&wt), g.upload(&b));
+        let (ho, wo) = ((h + 2 * pad - k) / stride + 1, (w + 2 * pad - k) / stride + 1);
+        let out = g.zeros(ho * wo * co).unwrap();
+        g.conv2d(&gx, &gw, &gb, &out, (h, w, ci, co), k, stride, pad, groups).unwrap();
+        // candle works on NCHW: bring the channels-last input over, convolve, bring the result back
+        let t = Tensor::from_vec(x, (1, h, w, ci), &Device::Cpu).unwrap().permute((0, 3, 1, 2)).unwrap().contiguous().unwrap();
+        let kern = Tensor::from_vec(wt, (co, ci / groups, k, k), &Device::Cpu).unwrap();
+        let want = t
+            .conv2d(&kern, pad, stride, 1, groups)
+            .unwrap()
+            .broadcast_add(&Tensor::from_vec(b, (1, co, 1, 1), &Device::Cpu).unwrap())
+            .unwrap()
+            .permute((0, 2, 3, 1))
+            .unwrap();
+        assert_close(
+            &run_and_read(&g, &out),
+            &want.flatten_all().unwrap().to_vec1::<f32>().unwrap(),
+            2e-4,
+            &format!("conv {k}x{k} stride {stride} groups {groups}"),
+        );
+    }
+    assert!(g.conv2d(&g.upload(&[0.0; 4]), &g.upload(&[0.0; 4]), &g.upload(&[0.0; 1]), &g.zeros(4).unwrap(), (2, 2, 1, 1), 5, 1, 0, 1).is_err());
+    // layer norm followed by GELU in the same pass
+    let (rows, cols) = (50usize, 96usize);
+    let (x, wt, b) = (noise(rows * cols, 33), noise(cols, 34), noise(cols, 35));
+    let (gx, gw, gb, gy) = (g.upload(&x), g.upload(&wt), g.upload(&b), g.zeros(rows * cols).unwrap());
+    g.layernorm(&gx, &gw, &gb, &gy, rows, cols, 1e-6, true).unwrap();
+    let want: Vec<f32> = x
+        .chunks(cols)
+        .flat_map(|r| {
+            let mean = r.iter().sum::<f32>() / cols as f32;
+            let var = r.iter().map(|v| (v - mean).powi(2)).sum::<f32>() / cols as f32;
+            r.iter().enumerate().map(|(i, v)| gelu((v - mean) / (var + 1e-6).sqrt() * wt[i] + b[i])).collect::<Vec<_>>()
+        })
+        .collect();
+    assert_close(&run_and_read(&g, &gy), &want, 1e-3, "layernorm + gelu");
+}
+
+#[test]
+fn half_precision_weights_give_the_same_product_to_half_precision() {
+    let Some(g) = gpu() else { return };
+    // odd sizes: the last word holds one value; the weight is a linear layer's [n, k]
+    let (m, n, k) = (70, 91, 41);
+    let (av, wv) = (noise(m * k, 3), noise(n * k, 4));
+    let (a, w16, w32) = (g.upload(&av), g.upload_f16(&wv), g.upload(&wv));
+    assert!(w16.f16 && w16.len == n * k);
+    let (c16, c32) = (g.zeros(m * n).unwrap(), g.zeros(m * n).unwrap());
+    let sb = Strides { offset: 0, batch: 0, row: 1, col: k };
+    for (w, c) in [(&w16, &c16), (&w32, &c32)] {
+        g.matmul(&Matmul {
+            m,
+            n,
+            k,
+            batch: 1,
+            a: (&a, Strides::row_major(k)),
+            b: (w, sb),
+            bias: None,
+            c: (c, Strides::row_major(n)),
+            residual: None,
+            alpha: 1.0,
+            act: Act::None,
+        })
+        .unwrap();
+    }
+    g.flush().unwrap();
+    let (got, want) = (g.download(&c16).unwrap(), g.download(&c32).unwrap());
+    // f16 keeps 11 bits: each weight is off by at most 2^-11 relative
+    assert_close(&got, &want, 2e-3 * (k as f32).sqrt(), "f16 vs f32 weights");
+    assert!(got != want, "the weights really were rounded to half precision");
+}
diff --git a/crates/sam2/src/hiera.rs b/crates/sam2/src/hiera.rs
new file mode 100644
index 000000000..82862c829
--- /dev/null
+++ b/crates/sam2/src/hiera.rs
@@ -0,0 +1,449 @@
+// Modified work: ported from Hugging Face `transformers` `models/sam2/modeling_sam2.py`
+// (Sam2PatchEmbeddings, Sam2MultiScaleAttention, Sam2MultiScaleBlock, Sam2HieraDetModel;
+// Apache-2.0, Copyright The HuggingFace Inc. team) to Rust on candle. See NOTICE.
+//! The Hiera backbone: patch embedding, windowed positional embedding, and blocks with window or
+//! global attention and query pooling at the stage changes. Activations are NHWC like the reference.
+
+use candle_core::Tensor;
+use candle_nn::{Linear, ops::softmax_last_dim};
+
+use crate::nn::{LayerNorm, Mlp, apply, layer_norm, linear};
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+/// Hiera hyper-parameters (the released SAM 2.1 sizes differ only here).
+#[derive(Clone, Debug, PartialEq)]
+pub struct HieraConfig {
+    pub embed_dims: Vec<usize>,
+    pub blocks: Vec<usize>,
+    pub heads: Vec<usize>,
+    pub windows: Vec<usize>,
+    pub global_blocks: Vec<usize>,
+    pub query_stride: usize,
+    pub query_pool_stages: usize,
+    pub mlp_ratio: usize,
+    pub eps: f64,
+    pub pos_background: usize,
+}
+
+impl HieraConfig {
+    /// `facebook/sam2.1-hiera-tiny`.
+    pub fn tiny() -> HieraConfig {
+        HieraConfig {
+            embed_dims: vec![96, 192, 384, 768],
+            blocks: vec![1, 2, 7, 2],
+            heads: vec![1, 2, 4, 8],
+            windows: vec![8, 4, 14, 7],
+            global_blocks: vec![5, 7, 9],
+            query_stride: 2,
+            query_pool_stages: 3,
+            mlp_ratio: 4,
+            eps: 1e-6,
+            pos_background: 7,
+        }
+    }
+
+    /// `facebook/sam2.1-hiera-small`: the same widths as Tiny with deeper third and fourth stages.
+    pub fn small() -> HieraConfig {
+        HieraConfig { blocks: vec![1, 2, 11, 2], global_blocks: vec![7, 10, 13], ..HieraConfig::tiny() }
+    }
+
+    /// `facebook/sam2.1-hiera-base-plus`.
+    pub fn base_plus() -> HieraConfig {
+        HieraConfig {
+            embed_dims: vec![112, 224, 448, 896],
+            blocks: vec![2, 3, 16, 3],
+            heads: vec![2, 4, 8, 16],
+            global_blocks: vec![12, 16, 20],
+            pos_background: 14,
+            ..HieraConfig::tiny()
+        }
+    }
+
+    /// `facebook/sam2.1-hiera-large`.
+    pub fn large() -> HieraConfig {
+        HieraConfig {
+            embed_dims: vec![144, 288, 576, 1152],
+            blocks: vec![2, 6, 36, 4],
+            heads: vec![2, 4, 8, 16],
+            windows: vec![8, 4, 16, 8],
+            global_blocks: vec![23, 33, 43],
+            ..HieraConfig::tiny()
+        }
+    }
+
+    /// The configuration of a released size.
+    pub fn for_size(size: crate::Size) -> HieraConfig {
+        match size {
+            crate::Size::Tiny => HieraConfig::tiny(),
+            crate::Size::Small => HieraConfig::small(),
+            crate::Size::BasePlus => HieraConfig::base_plus(),
+            crate::Size::Large => HieraConfig::large(),
+        }
+    }
+}
+
+fn at<T: Copy>(v: &[T], i: usize, what: &str) -> Result<T> {
+    v.get(i).copied().ok_or_else(|| Error::Weights(format!("Hiera config has no {what} for stage {i}")))
+}
+
+/// Max pool a `[B, H, W, C]` tensor by `stride` (kernel = stride, no padding, floor), without the
+/// permutes a pooling layer would need: it groups the cells and takes the maximum over each group.
+fn do_pool(x: &Tensor, stride: usize) -> Result<Tensor> {
+    let (b, h, w, c) = x.dims4()?;
+    if stride == 0 {
+        return Err(Error::Input("pool stride 0".into()));
+    }
+    let (oh, ow) = (h / stride, w / stride);
+    let x = if oh * stride != h || ow * stride != w { x.narrow(1, 0, oh * stride)?.narrow(2, 0, ow * stride)? } else { x.clone() };
+    Ok(x.contiguous()?.reshape((b, oh, stride, ow, stride, c))?.max(2)?.max(3)?.contiguous()?)
+}
+
+/// Split `[B, H, W, C]` into `[B * nH * nW, ws, ws, C]` windows, zero padding the bottom/right.
+fn window_partition(x: &Tensor, ws: usize) -> Result<(Tensor, (usize, usize))> {
+    let (b, h, w, c) = x.dims4()?;
+    if ws == 0 {
+        return Err(Error::Input("window size 0".into()));
+    }
+    let (ph, pw) = ((ws - h % ws) % ws, (ws - w % ws) % ws);
+    let x = x.pad_with_zeros(2, 0, pw)?.pad_with_zeros(1, 0, ph)?;
+    let (nh, nw) = ((h + ph) / ws, (w + pw) / ws);
+    let x = x.reshape((b, nh, ws, nw, ws, c))?.permute((0, 1, 3, 2, 4, 5))?.contiguous()?.reshape((b * nh * nw, ws, ws, c))?;
+    Ok((x, (h + ph, w + pw)))
+}
+
+fn window_unpartition(win: &Tensor, ws: usize, padded: (usize, usize), orig: (usize, usize)) -> Result<Tensor> {
+    if ws == 0 {
+        return Err(Error::Input("window size 0".into()));
+    }
+    let (nh, nw) = (padded.0 / ws, padded.1 / ws);
+    let (n, _, _, c) = win.dims4()?;
+    let b = n / (nh * nw).max(1);
+    let x = win.reshape((b, nh, nw, ws, ws, c))?.permute((0, 1, 3, 2, 4, 5))?.contiguous()?.reshape((b, padded.0, padded.1, c))?;
+    Ok(x.narrow(1, 0, orig.0)?.narrow(2, 0, orig.1)?.contiguous()?)
+}
+
+struct Attention {
+    qkv: Linear,
+    proj: Linear,
+    heads: usize,
+    scale: f64,
+    query_stride: Option<usize>,
+}
+
+impl Attention {
+    fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        let (b, h, w, _) = x.dims4()?;
+        let qkv = apply(&self.qkv, x)?.reshape((b, h * w, 3, self.heads, ()))?;
+        let part = |i: usize| -> Result<Tensor> { Ok(qkv.narrow(2, i, 1)?.squeeze(2)?) };
+        let (mut q, k, v) = (part(0)?, part(1)?, part(2)?);
+        let (mut oh, mut ow) = (h, w);
+        if let Some(s) = self.query_stride {
+            let pooled = do_pool(&q.reshape((b, h, w, ()))?, s)?;
+            (oh, ow) = (pooled.dim(1)?, pooled.dim(2)?);
+            q = pooled.reshape((b, oh * ow, self.heads, ()))?;
+        }
+        let q = q.transpose(1, 2)?.contiguous()?;
+        let k = k.transpose(1, 2)?.contiguous()?;
+        let v = v.transpose(1, 2)?.contiguous()?;
+        // Scaling the (small) queries first equals scaling the scores, and the fused softmax is
+        // much faster than the generic one on the 4096 x 4096 global-attention maps.
+        let att = (q * self.scale)?.matmul(&k.transpose(2, 3)?.contiguous()?)?;
+        let att = softmax_last_dim(&att)?;
+        let out = att.matmul(&v)?.transpose(1, 2)?.contiguous()?.reshape((b, oh, ow, ()))?;
+        apply(&self.proj, &out)
+    }
+}
+
+/// What a block is made of: its widths, heads, window (0: global attention) and query pooling.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) struct BlockPlan {
+    pub dim: usize,
+    pub dim_out: usize,
+    pub heads: usize,
+    pub window: usize,
+    pub query_stride: Option<usize>,
+}
+
+impl BlockPlan {
+    pub(crate) fn new(cfg: &HieraConfig, stage: usize, block_in_stage: usize, total: usize) -> Result<BlockPlan> {
+        let first = stage > 0 && block_in_stage == 0;
+        let dim = at(&cfg.embed_dims, if first { stage - 1 } else { stage }, "embed dim")?;
+        let dim_out = at(&cfg.embed_dims, stage, "embed dim")?;
+        let window = if first { at(&cfg.windows, stage - 1, "window")? } else { at(&cfg.windows, stage, "window")? };
+        let window = if cfg.global_blocks.contains(&total) { 0 } else { window };
+        let query_stride = (stage > 0 && stage <= cfg.query_pool_stages && block_in_stage == 0).then_some(cfg.query_stride);
+        Ok(BlockPlan { dim, dim_out, heads: at(&cfg.heads, stage, "heads")?, window, query_stride })
+    }
+
+    /// Every block of the backbone, in order.
+    pub(crate) fn all(cfg: &HieraConfig) -> Result<Vec<BlockPlan>> {
+        let mut out = vec![];
+        for (stage, n) in cfg.blocks.iter().enumerate() {
+            for b in 0..*n {
+                out.push(BlockPlan::new(cfg, stage, b, out.len())?);
+            }
+        }
+        Ok(out)
+    }
+}
+
+/// One Hiera block: pre-norm attention (window or global, optionally pooling the queries) and MLP.
+pub struct Block {
+    norm1: LayerNorm,
+    attn: Attention,
+    norm2: LayerNorm,
+    mlp: Mlp,
+    proj: Option<Linear>,
+    window: usize,
+    query_stride: Option<usize>,
+}
+
+impl Block {
+    fn load(w: &Weights, cfg: &HieraConfig, stage: usize, block_in_stage: usize, total: usize) -> Result<Block> {
+        let prefix = format!("vision_encoder.backbone.blocks.{total}");
+        let plan = BlockPlan::new(cfg, stage, block_in_stage, total)?;
+        let (dim, dim_out, heads) = (plan.dim, plan.dim_out, plan.heads);
+        Ok(Block {
+            norm1: layer_norm(w, &format!("{prefix}.layer_norm1"), dim, cfg.eps)?,
+            attn: Attention {
+                qkv: linear(w, &format!("{prefix}.attn.qkv"), dim, dim_out * 3)?,
+                proj: linear(w, &format!("{prefix}.attn.proj"), dim_out, dim_out)?,
+                heads,
+                scale: ((dim_out / heads.max(1)) as f64).powf(-0.5),
+                query_stride: plan.query_stride,
+            },
+            norm2: layer_norm(w, &format!("{prefix}.layer_norm2"), dim_out, cfg.eps)?,
+            mlp: Mlp::load(w, &format!("{prefix}.mlp"), dim_out, dim_out * cfg.mlp_ratio)?,
+            proj: (dim != dim_out).then(|| linear(w, &format!("{prefix}.proj"), dim, dim_out)).transpose()?,
+            window: plan.window,
+            query_stride: plan.query_stride,
+        })
+    }
+
+    pub fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        let h = self.norm1.forward(x)?;
+        let residual = match (&self.proj, self.query_stride) {
+            (Some(p), Some(s)) => do_pool(&apply(p, &h)?, s)?,
+            (Some(p), None) => apply(p, &h)?,
+            (None, _) => x.clone(),
+        };
+        let (hh, ww) = (h.dim(1)?, h.dim(2)?);
+        let mut ws = self.window;
+        let mut padded = (hh, ww);
+        let h = if ws > 0 {
+            let (win, pad) = window_partition(&h, ws)?;
+            padded = pad;
+            win
+        } else {
+            h
+        };
+        let mut h = self.attn.forward(&h)?;
+        let mut orig = (hh, ww);
+        if let Some(s) = self.query_stride {
+            ws /= s.max(1);
+            orig = (residual.dim(1)?, residual.dim(2)?);
+            if ws > 0 {
+                padded = (orig.0 + (ws - orig.0 % ws) % ws, orig.1 + (ws - orig.1 % ws) % ws);
+            }
+        }
+        if ws > 0 {
+            h = window_unpartition(&h, ws, padded, orig)?;
+        }
+        let h = (residual + h)?;
+        let m = self.mlp.forward(&self.norm2.forward(&h)?)?;
+        Ok((h + m)?)
+    }
+}
+
+/// PyTorch `F.interpolate(mode="bicubic", align_corners=False)` of `[C, in_h, in_w]` to `[C, out_h, out_w]`.
+fn bicubic_resize(src: &[f32], c: usize, in_hw: (usize, usize), out_hw: (usize, usize)) -> Vec<f32> {
+    const A: f32 = -0.75;
+    let near = |x: f32| ((A + 2.0) * x - (A + 3.0)) * x * x + 1.0;
+    let far = |x: f32| ((A * x - 5.0 * A) * x + 8.0 * A) * x - 4.0 * A;
+    let axis = |n_in: usize, n_out: usize| -> Vec<([usize; 4], [f32; 4])> {
+        let scale = n_in as f32 / n_out.max(1) as f32;
+        (0..n_out)
+            .map(|o| {
+                let s = (o as f32 + 0.5) * scale - 0.5;
+                let i0 = s.floor();
+                let t = s - i0;
+                let w = [far(t + 1.0), near(t), near(1.0 - t), far(2.0 - t)];
+                let last = n_in as i64 - 1;
+                let idx = [-1i64, 0, 1, 2].map(|d| (i0 as i64 + d).clamp(0, last.max(0)) as usize);
+                (idx, w)
+            })
+            .collect()
+    };
+    let (ys, xs) = (axis(in_hw.0, out_hw.0), axis(in_hw.1, out_hw.1));
+    let mut out = vec![0f32; c * out_hw.0 * out_hw.1];
+    for ch in 0..c {
+        let plane = src.get(ch * in_hw.0 * in_hw.1..(ch + 1) * in_hw.0 * in_hw.1).unwrap_or(&[]);
+        for (oy, (yi, yw)) in ys.iter().enumerate() {
+            for (ox, (xi, xw)) in xs.iter().enumerate() {
+                let mut acc = 0f32;
+                for (a, wy) in yi.iter().zip(yw) {
+                    for (b, wx) in xi.iter().zip(xw) {
+                        acc += plane.get(a * in_hw.1 + b).copied().unwrap_or(0.0) * wy * wx;
+                    }
+                }
+                if let Some(o) = out.get_mut((ch * out_hw.0 + oy) * out_hw.1 + ox) {
+                    *o = acc;
+                }
+            }
+        }
+    }
+    out
+}
+
+pub struct Hiera {
+    cfg: HieraConfig,
+    patch_w: Tensor,
+    patch_b: Tensor,
+    pos_embed: Vec<f32>,
+    pos_embed_window: Vec<f32>,
+    window0: usize,
+    hidden: usize,
+    pub blocks: Vec<Block>,
+    stage_ends: Vec<usize>,
+}
+
+impl Hiera {
+    pub fn load(w: &Weights, cfg: &HieraConfig) -> Result<Hiera> {
+        let hidden = at(&cfg.embed_dims, 0, "embed dim")?;
+        let window0 = at(&cfg.windows, 0, "window")?;
+        let bg = cfg.pos_background;
+        let mut blocks = vec![];
+        let mut stage_ends = vec![];
+        for (stage, n) in cfg.blocks.iter().enumerate() {
+            for b in 0..*n {
+                blocks.push(Block::load(w, cfg, stage, b, blocks.len())?);
+            }
+            stage_ends.push(blocks.len().saturating_sub(1));
+        }
+        let flat = |t: Tensor| -> Result<Vec<f32>> { Ok(t.flatten_all()?.to_vec1::<f32>()?) };
+        Ok(Hiera {
+            cfg: cfg.clone(),
+            patch_w: w.get("vision_encoder.backbone.patch_embed.projection.weight", &[hidden, 3, 7, 7])?,
+            patch_b: w.get("vision_encoder.backbone.patch_embed.projection.bias", &[hidden])?,
+            pos_embed: flat(w.get("vision_encoder.backbone.pos_embed", &[1, hidden, bg, bg])?)?,
+            pos_embed_window: flat(w.get("vision_encoder.backbone.pos_embed_window", &[1, hidden, window0, window0])?)?,
+            window0,
+            hidden,
+            blocks,
+            stage_ends,
+        })
+    }
+
+    /// Patch embedding of `[B, 3, H, W]` pixels: `[B, H/4, W/4, C]` (before the positional embedding).
+    pub(crate) fn config(&self) -> &HieraConfig {
+        &self.cfg
+    }
+
+    pub fn patch_embed(&self, pixels: &Tensor) -> Result<Tensor> {
+        let x = pixels.conv2d(&self.patch_w, 3, 4, 1, 1)?;
+        let x = x.broadcast_add(&self.patch_b.reshape((1, self.hidden, 1, 1))?)?;
+        Ok(x.permute((0, 2, 3, 1))?.contiguous()?)
+    }
+
+    /// Background embedding resized to the grid plus the tiled window embedding, `[1, H, W, C]`.
+    pub(crate) fn pos(&self, h: usize, w: usize) -> Result<Tensor> {
+        let bg = self.cfg.pos_background;
+        let big = bicubic_resize(&self.pos_embed, self.hidden, (bg, bg), (h, w));
+        let ws = self.window0.max(1);
+        let mut out = vec![0f32; h * w * self.hidden];
+        for c in 0..self.hidden {
+            for y in 0..h {
+                for x in 0..w {
+                    let tile = self.pos_embed_window.get((c * ws + y % ws) * ws + x % ws).copied().unwrap_or(0.0);
+                    let base = big.get((c * h + y) * w + x).copied().unwrap_or(0.0);
+                    if let Some(o) = out.get_mut((y * w + x) * self.hidden + c) {
+                        *o = base + tile;
+                    }
+                }
+            }
+        }
+        Ok(Tensor::from_vec(out, (1, h, w, self.hidden), &candle_core::Device::Cpu)?)
+    }
+
+    /// Run all blocks. Returns the output of the last block of each stage (NHWC).
+    pub fn forward(&self, pixels: &Tensor) -> Result<Vec<Tensor>> {
+        let (_, _, ph, pw) = pixels.dims4()?;
+        if ph == 0 || pw == 0 || ph % 4 != 0 || pw % 4 != 0 {
+            return Err(Error::Input(format!("image size {pw}x{ph} must be a positive multiple of 4")));
+        }
+        let mut x = self.patch_embed(pixels)?;
+        let (h, w) = (x.dim(1)?, x.dim(2)?);
+        if h % self.window0 != 0 || w % self.window0 != 0 {
+            return Err(Error::Input(format!("patch grid {w}x{h} must be a multiple of {}", self.window0)));
+        }
+        x = x.broadcast_add(&self.pos(h, w)?)?;
+        let mut stages = vec![];
+        for (i, b) in self.blocks.iter().enumerate() {
+            x = b.forward(&x)?;
+            if self.stage_ends.contains(&i) {
+                stages.push(x.clone());
+            }
+        }
+        Ok(stages)
+    }
+
+    /// Run the blocks, returning every block's output (for the stage-by-stage reference test).
+    pub fn forward_all(&self, pixels: &Tensor) -> Result<(Tensor, Vec<Tensor>)> {
+        let emb = self.patch_embed(pixels)?;
+        let (h, w) = (emb.dim(1)?, emb.dim(2)?);
+        let mut x = emb.broadcast_add(&self.pos(h, w)?)?;
+        let mut outs = vec![];
+        for b in &self.blocks {
+            x = b.forward(&x)?;
+            outs.push(x.clone());
+        }
+        Ok((emb, outs))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use candle_core::Device;
+
+    #[test]
+    fn bicubic_of_a_constant_is_that_constant() {
+        let out = bicubic_resize(&[2.5; 49], 1, (7, 7), (32, 32));
+        assert!(out.iter().all(|v| (v - 2.5).abs() < 1e-5));
+    }
+
+    #[test]
+    fn bicubic_identity_size_is_identity() {
+        let src: Vec<f32> = (0..49).map(|i| (i as f32 * 0.37).sin()).collect();
+        let out = bicubic_resize(&src, 1, (7, 7), (7, 7));
+        assert!(src.iter().zip(&out).all(|(a, b)| (a - b).abs() < 1e-5));
+    }
+
+    #[test]
+    fn windows_round_trip_with_padding() {
+        let x = Tensor::arange(0f32, 60.0, &Device::Cpu).unwrap().reshape((1, 5, 6, 2)).unwrap();
+        let (win, pad) = window_partition(&x, 4).unwrap();
+        assert_eq!((win.dims(), pad), (&[4, 4, 4, 2][..], (8, 8)));
+        let back = window_unpartition(&win, 4, pad, (5, 6)).unwrap();
+        let d = (back - x).unwrap().abs().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap();
+        assert_eq!(d, 0.0);
+    }
+
+    #[test]
+    fn pooling_equals_a_max_pool_layer_including_odd_sizes() {
+        let x = Tensor::randn(0f32, 1.0, (2, 7, 9, 5), &Device::Cpu).unwrap();
+        let want = x.permute((0, 3, 1, 2)).unwrap().contiguous().unwrap().max_pool2d_with_stride(2, 2).unwrap().permute((0, 2, 3, 1)).unwrap();
+        let got = do_pool(&x, 2).unwrap();
+        assert_eq!(got.dims(), want.dims());
+        let d = (got - want).unwrap().abs().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap();
+        assert_eq!(d, 0.0);
+        assert!(do_pool(&x, 0).is_err());
+    }
+
+    #[test]
+    fn zero_window_is_an_error_not_a_panic() {
+        let x = Tensor::zeros((1, 4, 4, 2), candle_core::DType::F32, &Device::Cpu).unwrap();
+        assert!(window_partition(&x, 0).is_err());
+    }
+}
diff --git a/crates/sam2/src/lib.rs b/crates/sam2/src/lib.rs
new file mode 100644
index 000000000..f2aba0390
--- /dev/null
+++ b/crates/sam2/src/lib.rs
@@ -0,0 +1,145 @@
+//! SAM 2.1 video object tracker (Hiera backbone) for the Roto Brush.
+//!
+//! A Rust port of the Hugging Face `transformers` SAM 2 implementation (Apache-2.0; see
+//! `NOTICE`). Native only: the crate is empty on wasm32 so L0–L4 still build for the web.
+//! Nothing here loads weights unless asked to; weights are never bundled.
+//!
+//! Modules are added stage by stage, each checked against reference tensors produced by
+//! `tools/sam2_reference.py`.
+#![cfg(not(target_arch = "wasm32"))]
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+
+use std::fmt;
+
+pub mod decoder;
+pub mod gpu;
+pub mod hiera;
+pub mod mask;
+pub mod memattn;
+pub mod memory;
+pub mod model;
+pub mod neck;
+pub mod nn;
+pub mod prompt;
+pub mod resize;
+pub mod session;
+pub mod track;
+pub mod weights;
+
+/// Everything that can go wrong in this crate. Never a panic.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Error {
+    /// The weights file is missing a tensor, has the wrong shape, or contains non-finite values.
+    Weights(String),
+    /// The input (frame size, prompt, frame index) is unusable.
+    Input(String),
+    /// The work was cancelled by the caller.
+    Cancelled,
+    /// A time or memory budget was exceeded.
+    Budget(String),
+    /// A tensor operation failed (shape mismatch, out of memory, device error).
+    Compute(String),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::Weights(m) => write!(f, "SAM 2 weights: {m}"),
+            Error::Input(m) => write!(f, "SAM 2 input: {m}"),
+            Error::Cancelled => write!(f, "SAM 2: cancelled"),
+            Error::Budget(m) => write!(f, "SAM 2 budget: {m}"),
+            Error::Compute(m) => write!(f, "SAM 2 compute: {m}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl From<candle_core::Error> for Error {
+    fn from(e: candle_core::Error) -> Error {
+        Error::Compute(e.to_string())
+    }
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// The released SAM 2.1 sizes. Only Tiny is wired up first; the others are configuration.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Size {
+    Tiny,
+    Small,
+    BasePlus,
+    Large,
+}
+
+impl Size {
+    /// The Hugging Face repository the official weights come from.
+    pub fn repo(self) -> &'static str {
+        match self {
+            Size::Tiny => "facebook/sam2.1-hiera-tiny",
+            Size::Small => "facebook/sam2.1-hiera-small",
+            Size::BasePlus => "facebook/sam2.1-hiera-base-plus",
+            Size::Large => "facebook/sam2.1-hiera-large",
+        }
+    }
+
+    /// The size a checkpoint is, from its tensors: the width of the patch embedding (96 for Tiny and Small, 112 for
+    /// Base+, 144 for Large) and the number of blocks (12 for Tiny, 16 for Small).
+    pub fn detect(w: &weights::Weights) -> Result<Size> {
+        let width = w.shape("vision_encoder.backbone.patch_embed.projection.weight").and_then(|s| s.first().copied());
+        Ok(match width {
+            Some(112) => Size::BasePlus,
+            Some(144) => Size::Large,
+            Some(96) if w.contains("vision_encoder.backbone.blocks.15.layer_norm1.weight") => Size::Small,
+            Some(96) => Size::Tiny,
+            _ => return Err(Error::Weights("this checkpoint is not a SAM 2.1 Hiera size (patch embedding width)".into())),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sizes_name_their_official_repositories() {
+        assert_eq!(Size::Tiny.repo(), "facebook/sam2.1-hiera-tiny");
+        assert!(Size::Large.repo().ends_with("large"));
+    }
+
+    #[test]
+    fn configs_match_the_released_sizes() {
+        let blocks = |s| hiera::HieraConfig::for_size(s).blocks.iter().sum::<usize>();
+        assert_eq!([Size::Tiny, Size::Small, Size::BasePlus, Size::Large].map(blocks), [12, 16, 24, 48]);
+        for s in [Size::Tiny, Size::Small, Size::BasePlus, Size::Large] {
+            let c = hiera::HieraConfig::for_size(s);
+            assert_eq!((c.embed_dims.len(), c.heads.len(), c.windows.len()), (4, 4, 4));
+            assert!(c.global_blocks.iter().all(|g| *g < blocks(s)));
+        }
+    }
+
+    #[test]
+    fn size_comes_from_the_patch_embedding_and_depth() {
+        use candle_core::{DType, Device, Tensor};
+        let make = |width: usize, deep: bool| {
+            let mut m = std::collections::HashMap::new();
+            m.insert("vision_encoder.backbone.patch_embed.projection.weight".to_string(), Tensor::zeros((width, 3, 7, 7), DType::F32, &Device::Cpu).unwrap());
+            if deep {
+                m.insert("vision_encoder.backbone.blocks.15.layer_norm1.weight".to_string(), Tensor::zeros(4, DType::F32, &Device::Cpu).unwrap());
+            }
+            weights::Weights::from_map(m).unwrap()
+        };
+        assert_eq!(Size::detect(&make(96, false)).unwrap(), Size::Tiny);
+        assert_eq!(Size::detect(&make(96, true)).unwrap(), Size::Small);
+        assert_eq!(Size::detect(&make(112, false)).unwrap(), Size::BasePlus);
+        assert_eq!(Size::detect(&make(144, false)).unwrap(), Size::Large);
+        assert!(Size::detect(&make(64, false)).is_err());
+        assert!(Size::detect(&weights::Weights::from_map(Default::default()).unwrap()).is_err());
+    }
+
+    #[test]
+    fn errors_say_what_failed() {
+        assert!(Error::Input("empty frame".into()).to_string().contains("empty frame"));
+        assert_eq!(Error::Cancelled.to_string(), "SAM 2: cancelled");
+    }
+}
diff --git a/crates/sam2/src/mask.rs b/crates/sam2/src/mask.rs
new file mode 100644
index 000000000..382f9b514
--- /dev/null
+++ b/crates/sam2/src/mask.rs
@@ -0,0 +1,227 @@
+// Modified work: wraps the ported SAM 2 image path behind EffectCraft's `MaskModel` interface
+// (Apache-2.0, see NOTICE).
+//! SAM 2 as a drop-in [`MaskModel`]: a frame and a prompt in, a foreground probability per pixel
+//! out. The frame's encoding is cached, so further strokes on the same frame cost one decode.
+
+use std::sync::{Arc, Mutex, PoisonError};
+
+use candle_core::{Device, Tensor};
+use effectcraft_segment::{MaskModel, ModelInfo, SAM2_TINY};
+
+use crate::model::Encoded;
+use crate::prompt::{INPUT_SIZE, Prompt};
+use crate::session::VideoModel;
+use crate::{Error, Result};
+
+/// Largest frame accepted (pixels per side and in total).
+const MAX_SIDE: usize = 16_384;
+const MAX_PIXELS: usize = 100_000_000;
+
+/// Resize `w x h` RGB (0..1) to the model input and normalise it: `[1, 3, 1024, 1024]`.
+pub fn preprocess(rgb: &[[f32; 3]], w: usize, h: usize) -> Result<Tensor> {
+    let pixels = validate_frame_size(w, h, rgb.len())?;
+    const MEAN: [f32; 3] = [0.485, 0.456, 0.406];
+    const STD: [f32; 3] = [0.229, 0.224, 0.225];
+    let mut planar = vec![0f32; 3 * pixels];
+    for (i, px) in rgb.iter().enumerate() {
+        for c in 0..3 {
+            let v = px.get(c).copied().unwrap_or(0.0);
+            if let Some(o) = planar.get_mut(c * pixels + i) {
+                *o = if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.0 };
+            }
+        }
+    }
+    let x = Tensor::from_vec(planar, (1, 3, h, w), &Device::Cpu)?.upsample_bilinear2d(INPUT_SIZE, INPUT_SIZE, false)?;
+    let mean = Tensor::from_slice(&MEAN, (1, 3, 1, 1), &Device::Cpu)?;
+    let std = Tensor::from_slice(&STD, (1, 3, 1, 1), &Device::Cpu)?;
+    Ok(x.broadcast_sub(&mean)?.broadcast_div(&std)?)
+}
+
+pub(crate) fn validate_frame_size(w: usize, h: usize, len: usize) -> Result<usize> {
+    w.checked_mul(h)
+        .filter(|n| *n > 0 && *n == len && w <= MAX_SIDE && h <= MAX_SIDE && *n <= MAX_PIXELS)
+        .ok_or_else(|| Error::Input(format!("a {w} x {h} frame needs {} pixels (at most {MAX_PIXELS}), got {len}", w.saturating_mul(h))))
+}
+
+fn fingerprint(rgb: &[[f32; 3]], w: usize, h: usize) -> u64 {
+    let mut hash = 0xcbf2_9ce4_8422_2325u64 ^ ((w as u64) << 32 | h as u64);
+    for px in rgb {
+        for v in px {
+            hash = (hash ^ u64::from(v.to_bits())).wrapping_mul(0x0100_0000_01b3);
+        }
+    }
+    hash
+}
+
+/// SAM 2 for single frames.
+pub struct Sam2Mask {
+    model: Arc<VideoModel>,
+    info: &'static ModelInfo,
+    last: Mutex<Option<(u64, Arc<Encoded>)>>,
+    used: Mutex<std::time::Instant>,
+    pub(crate) peak: std::sync::atomic::AtomicU64,
+}
+
+impl Sam2Mask {
+    pub fn new(model: Arc<VideoModel>) -> Sam2Mask {
+        Sam2Mask::with_info(model, &SAM2_TINY)
+    }
+
+    /// A model of a given registry entry (its size).
+    pub fn with_info(model: Arc<VideoModel>, info: &'static ModelInfo) -> Sam2Mask {
+        Sam2Mask { model, info, last: Mutex::new(None), used: Mutex::new(std::time::Instant::now()), peak: std::sync::atomic::AtomicU64::new(0) }
+    }
+
+    /// Note that the model is being used (for [`MaskModel::idle_secs`]).
+    pub(crate) fn touch(&self) {
+        *self.used.lock().unwrap_or_else(PoisonError::into_inner) = std::time::Instant::now();
+    }
+
+    /// The video model, for trackers built on the same weights.
+    pub fn video_model(&self) -> &Arc<VideoModel> {
+        &self.model
+    }
+
+    fn encoded(&self, rgb: &[[f32; 3]], w: usize, h: usize) -> Result<Arc<Encoded>> {
+        let key = fingerprint(rgb, w, h);
+        if let Some((k, e)) = self.last.lock().unwrap_or_else(PoisonError::into_inner).as_ref()
+            && *k == key
+        {
+            return Ok(e.clone());
+        }
+        let enc = Arc::new(self.model.encode(&preprocess(rgb, w, h)?)?);
+        *self.last.lock().unwrap_or_else(PoisonError::into_inner) = Some((key, enc.clone()));
+        Ok(enc)
+    }
+
+    fn probability(&self, rgb: &[[f32; 3]], w: usize, h: usize, prompt: &effectcraft_segment::Prompt) -> Result<Vec<f32>> {
+        let enc = self.encoded(rgb, w, h)?;
+        let (sx, sy) = (INPUT_SIZE as f32 / w as f32, INPUT_SIZE as f32 / h as f32);
+        let p = Prompt {
+            points: prompt.points.iter().map(|(c, fg)| ([c[0] * sx, c[1] * sy], *fg)).collect(),
+            bbox: prompt.bbox.map(|b| [b[0] * sx, b[1] * sy, b[2] * sx, b[3] * sy]),
+        };
+        if p.points.is_empty() && p.bbox.is_none() {
+            return Err(Error::Input("SAM 2 needs at least one point or a box".into()));
+        }
+        let multimask = p.points.len() + 2 * usize::from(p.bbox.is_some()) <= 1;
+        let out = self.model.image.segment(&enc, &p, multimask)?;
+        let ious = out.iou.flatten_all()?.to_vec1::<f32>()?;
+        let best = ious.iter().enumerate().fold((0usize, f32::NEG_INFINITY), |b, (i, v)| if *v > b.1 { (i, *v) } else { b }).0;
+        let logits = out.masks.narrow(1, best, 1)?.upsample_bilinear2d(h, w, false)?;
+        Ok(candle_nn::ops::sigmoid(&logits)?.flatten_all()?.to_vec1::<f32>()?)
+    }
+}
+
+impl MaskModel for Sam2Mask {
+    fn info(&self) -> &'static ModelInfo {
+        self.info
+    }
+
+    fn segment(&self, rgb: &[[f32; 3]], w: usize, h: usize, prompt: &effectcraft_segment::Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+        self.touch();
+        self.probability(rgb, w, h, prompt).map_err(|e| e.to_string())
+    }
+
+    fn tracker(&self) -> Option<&dyn effectcraft_segment::ObjectTracker> {
+        Some(self)
+    }
+
+    fn device_name(&self) -> Option<String> {
+        Some(self.model.device_name())
+    }
+
+    fn peak_state_bytes(&self) -> Option<u64> {
+        Some(self.peak.load(std::sync::atomic::Ordering::Relaxed))
+    }
+
+    fn idle_secs(&self) -> Option<f64> {
+        Some(self.used.lock().unwrap_or_else(PoisonError::into_inner).elapsed().as_secs_f64())
+    }
+}
+
+/// Verify the installed file against the registry and build the model.
+pub fn load(bytes: &[u8]) -> std::result::Result<Arc<Sam2Mask>, String> {
+    let got = effectcraft_segment::sha256::hex(bytes);
+    let Some(info) = SIZES.iter().find(|m| m.sha256 == got) else {
+        return Err(format!("SAM 2.1: the file does not match any published size (SHA-256 {got})"));
+    };
+    let w = crate::weights::Weights::from_bytes(bytes).map_err(|e| e.to_string())?;
+    let model = VideoModel::load_auto(&w).map_err(|e| e.to_string())?;
+    Ok(Arc::new(Sam2Mask::with_info(Arc::new(model), info)))
+}
+
+/// The size to suggest: Tiny. On the benchmark clips (`bench --roto`, 24 frames, a GPU) no larger size tracked better, they
+/// cost 1.0x (Small), 1.15x (Base+) and 1.7x (Large) the time, and Large lost the object after it re-entered the frame.
+pub fn recommended() -> &'static ModelInfo {
+    &SAM2_TINY
+}
+
+/// A one-line note for the Settings list: what was measured for this size, and what the bigger ones cost without a GPU.
+pub fn hint(id: &str) -> Option<String> {
+    hint_for(id, crate::gpu::Gpu::probe())
+}
+
+/// [`hint`] given whether a GPU is known (`None`: not looked for yet). The list is built on the
+/// Settings path, so it never creates the GPU device itself: that happens when a model is loaded,
+/// and after that the notes say whether one was found.
+fn hint_for(id: &str, gpu: Option<bool>) -> Option<String> {
+    Some(
+        match id {
+            "sam2.1-hiera-tiny" => "Recommended: the smallest download, and no larger size tracked better on the benchmark clips.",
+            "sam2.1-hiera-small" => "As fast as Tiny on a GPU and no better on the benchmark clips; worth a try on difficult footage.",
+            "sam2.1-hiera-base-plus" => match gpu {
+                Some(false) => "Slow without a GPU (several seconds a frame); none was found.",
+                Some(true) => "About 15% slower than Tiny on a GPU and no better on the benchmark clips.",
+                None => "About 15% slower than Tiny on a GPU and no better on the benchmark clips; several seconds a frame without one.",
+            },
+            "sam2.1-hiera-large" => match gpu {
+                Some(false) => "Slow without a GPU (many seconds a frame); none was found.",
+                Some(true) => {
+                    "About 1.7 times Tiny's time on a GPU; it lost the object after it re-entered in one benchmark clip. Try it on difficult footage."
+                }
+                None => "About 1.7 times Tiny's time on a GPU, many seconds a frame without one; it lost the object after it re-entered in one benchmark clip.",
+            },
+            _ => return None,
+        }
+        .to_string(),
+    )
+}
+
+/// The registry entries this crate loads.
+pub const SIZES: [&ModelInfo; 4] = [&SAM2_TINY, &effectcraft_segment::SAM2_SMALL, &effectcraft_segment::SAM2_BASE_PLUS, &effectcraft_segment::SAM2_LARGE];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn preprocess_rejects_bad_frames_and_cleans_pixels() {
+        assert!(preprocess(&[], 0, 0).is_err());
+        assert!(preprocess(&[[0.0; 3]; 3], 2, 2).is_err());
+        assert!(preprocess(&[[0.5; 3]; 4], usize::MAX, 2).is_err());
+        let t = preprocess(&[[f32::NAN, 2.0, -1.0]; 4], 2, 2).unwrap();
+        assert_eq!(t.dims(), [1, 3, INPUT_SIZE, INPUT_SIZE]);
+        let v = t.flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        assert!(v.iter().all(|x| x.is_finite()));
+    }
+
+    /// The Settings list asks for hints without creating the GPU device: before anything has loaded a
+    /// model there is no answer yet, and the notes say so rather than guess.
+    #[test]
+    fn hints_do_not_need_the_gpu_to_have_been_created() {
+        for id in ["sam2.1-hiera-base-plus", "sam2.1-hiera-large"] {
+            let (unknown, none, found) = (hint_for(id, None), hint_for(id, Some(false)), hint_for(id, Some(true)));
+            assert!(unknown.is_some() && none.is_some() && found.is_some());
+            assert!(none.as_deref().is_some_and(|h| h.contains("none was found")), "{id}: {none:?}");
+            assert!(unknown.as_deref().is_some_and(|h| h.contains("without one") && !h.contains("none was found")), "{id}: {unknown:?}");
+        }
+        assert!(hint_for("mobilesam", None).is_none());
+    }
+
+    #[test]
+    fn a_wrong_file_is_refused_before_parsing() {
+        let e = load(b"not the weights").err().unwrap_or_default();
+        assert!(e.contains("does not match"), "{e}");
+    }
+}
diff --git a/crates/sam2/src/memattn.rs b/crates/sam2/src/memattn.rs
new file mode 100644
index 000000000..d455f1ed1
--- /dev/null
+++ b/crates/sam2/src/memattn.rs
@@ -0,0 +1,173 @@
+// Modified work: ported from Hugging Face `transformers` `models/sam2_video/modeling_sam2_video.py`
+// (Sam2VideoMemoryAttention, Sam2VideoMemoryAttentionLayer, Sam2VideoRoPEAttention,
+// Sam2VideoVisionRotaryEmbedding; Apache-2.0, Copyright The HuggingFace Inc. team) to Rust on
+// candle. See NOTICE.
+//! Memory attention: the current frame's features attend to themselves and to the memory bank
+//! (memory frames plus object pointers) with axial 2-D rotary position encoding.
+
+use candle_core::{D, Device, Tensor};
+use candle_nn::{Linear, ops::softmax_last_dim};
+
+use crate::nn::{LayerNorm, apply, layer_norm, linear};
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+const DIM: usize = 256;
+const LAYERS: usize = 4;
+/// Side of the feature grid the rotary encoding is defined on.
+pub const GRID: usize = 64;
+
+/// `cos` and `sin` of the axial rotary encoding for the `GRID x GRID` grid, each `[GRID², 256]`.
+pub(crate) fn rope_tables(theta: f32) -> Result<(Tensor, Tensor)> {
+    let freqs = DIM / 2 / 2; // per axis: head_dim / 4
+    let inv: Vec<f32> = (0..freqs).map(|i| 1.0 / theta.powf(i as f32 / freqs as f32)).collect();
+    let n = GRID * GRID;
+    let (mut cos, mut sin) = (vec![0f32; n * DIM], vec![0f32; n * DIM]);
+    for p in 0..n {
+        let (x, y) = ((p % GRID) as f32, (p / GRID) as f32);
+        for j in 0..DIM / 2 {
+            let f = if j < freqs { x * inv.get(j).copied().unwrap_or(0.0) } else { y * inv.get(j - freqs).copied().unwrap_or(0.0) };
+            for k in 0..2 {
+                if let (Some(c), Some(s)) = (cos.get_mut(p * DIM + 2 * j + k), sin.get_mut(p * DIM + 2 * j + k)) {
+                    *c = f.cos();
+                    *s = f.sin();
+                }
+            }
+        }
+    }
+    Ok((Tensor::from_vec(cos, (n, DIM), &Device::Cpu)?, Tensor::from_vec(sin, (n, DIM), &Device::Cpu)?))
+}
+
+/// `(x0, x1) -> (-x1, x0)` over adjacent pairs of the last dimension.
+fn rotate_pairwise(x: &Tensor) -> Result<Tensor> {
+    let (n, d) = x.dims2()?;
+    let pairs = x.reshape((n, d / 2, 2))?;
+    let (x1, x2) = (pairs.narrow(2, 0, 1)?.squeeze(2)?, pairs.narrow(2, 1, 1)?.squeeze(2)?);
+    Ok(Tensor::stack(&[&x2.neg()?, &x1], D::Minus1)?.reshape((n, d))?)
+}
+
+fn rope(x: &Tensor, cos: &Tensor, sin: &Tensor) -> Result<Tensor> {
+    Ok(((x * cos)? + (rotate_pairwise(x)? * sin)?)?)
+}
+
+struct RopeAttention {
+    q: Linear,
+    k: Linear,
+    v: Linear,
+    o: Linear,
+}
+
+impl RopeAttention {
+    fn load(w: &Weights, prefix: &str, kv_dim: usize) -> Result<RopeAttention> {
+        Ok(RopeAttention {
+            q: linear(w, &format!("{prefix}.q_proj"), DIM, DIM)?,
+            k: linear(w, &format!("{prefix}.k_proj"), kv_dim, DIM)?,
+            v: linear(w, &format!("{prefix}.v_proj"), kv_dim, DIM)?,
+            o: linear(w, &format!("{prefix}.o_proj"), DIM, DIM)?,
+        })
+    }
+
+    /// `query`: `[N, 256]`, `key`/`value`: `[M, kv]`. The first `M - exclude` keys are rotated
+    /// (their table is `cos`/`sin` tiled to length); the last `exclude` (object pointers) are not.
+    fn forward(&self, query: &Tensor, key: &Tensor, value: &Tensor, tables: &(Tensor, Tensor), exclude: usize) -> Result<Tensor> {
+        let (cos, sin) = tables;
+        let q = rope(&apply(&self.q, query)?, cos, sin)?;
+        let k = apply(&self.k, key)?;
+        let v = apply(&self.v, value)?;
+        let m = k.dim(0)?;
+        let rotated = m.checked_sub(exclude).ok_or_else(|| Error::Input("more object pointers than memory tokens".into()))?;
+        let k = if rotated == 0 {
+            k
+        } else {
+            let n = cos.dim(0)?;
+            let reps = if rotated == n {
+                1
+            } else if rotated % n == 0 {
+                rotated / n
+            } else {
+                return Err(Error::Input(format!("memory length {rotated} is not a multiple of {n}")));
+            };
+            let tile = |t: &Tensor| -> Result<Tensor> { Ok(Tensor::cat(&vec![t; reps], 0)?) };
+            let k_rot = rope(&k.narrow(0, 0, rotated)?, &tile(cos)?, &tile(sin)?)?;
+            if exclude == 0 { k_rot } else { Tensor::cat(&[&k_rot, &k.narrow(0, rotated, exclude)?], 0)? }
+        };
+        let scale = (DIM as f64).powf(-0.5);
+        let att = softmax_last_dim(&((q * scale)?.matmul(&k.t()?.contiguous()?)?))?;
+        apply(&self.o, &att.matmul(&v)?)
+    }
+}
+
+struct Layer {
+    self_attn: RopeAttention,
+    cross: RopeAttention,
+    ln1: LayerNorm,
+    ln2: LayerNorm,
+    ln3: LayerNorm,
+    lin1: Linear,
+    lin2: Linear,
+}
+
+pub struct MemoryAttention {
+    layers: Vec<Layer>,
+    final_ln: LayerNorm,
+    tables: (Tensor, Tensor),
+}
+
+impl MemoryAttention {
+    pub fn load(w: &Weights) -> Result<MemoryAttention> {
+        let layers = (0..LAYERS)
+            .map(|i| {
+                let p = format!("memory_attention.layers.{i}");
+                Ok(Layer {
+                    self_attn: RopeAttention::load(w, &format!("{p}.self_attn"), DIM)?,
+                    cross: RopeAttention::load(w, &format!("{p}.cross_attn_image"), 64)?,
+                    ln1: layer_norm(w, &format!("{p}.layer_norm1"), DIM, 1e-5)?,
+                    ln2: layer_norm(w, &format!("{p}.layer_norm2"), DIM, 1e-5)?,
+                    ln3: layer_norm(w, &format!("{p}.layer_norm3"), DIM, 1e-5)?,
+                    lin1: linear(w, &format!("{p}.linear1"), DIM, 2048)?,
+                    lin2: linear(w, &format!("{p}.linear2"), 2048, DIM)?,
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+        Ok(MemoryAttention { layers, final_ln: layer_norm(w, "memory_attention.layer_norm", DIM, 1e-5)?, tables: rope_tables(10000.0)? })
+    }
+
+    /// Condition the current frame on memory.
+    ///
+    /// `current` and `current_pos`: `[4096, 256]` (the lowest-resolution neck level and its
+    /// position encoding, one row per cell); `memory` and `memory_pos`: `[M, 64]` (memory frames
+    /// followed by `num_pointers` object-pointer tokens). Returns `[4096, 256]`.
+    pub fn forward(&self, current: &Tensor, current_pos: &Tensor, memory: &Tensor, memory_pos: &Tensor, num_pointers: usize) -> Result<Tensor> {
+        if current.dims() != [GRID * GRID, DIM] {
+            return Err(Error::Input(format!("current features must be [{}, {DIM}], got {:?}", GRID * GRID, current.dims())));
+        }
+        let keys_pos = (memory + memory_pos)?;
+        let mut out = (current + (current_pos * 0.1)?)?;
+        for l in &self.layers {
+            let q = l.ln1.forward(&out)?;
+            out = (&out + l.self_attn.forward(&q, &q, &q, &self.tables, 0)?)?;
+            let q = l.ln2.forward(&out)?;
+            out = (&out + l.cross.forward(&q, &keys_pos, memory, &self.tables, num_pointers)?)?;
+            let q = l.ln3.forward(&out)?;
+            out = (&out + apply(&l.lin2, &apply(&l.lin1, &q)?.relu()?)?)?;
+        }
+        self.final_ln.forward(&out)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rotation_is_pairwise_and_tables_start_at_identity() {
+        let x = Tensor::new(&[[1f32, 2.0, 3.0, 4.0]], &Device::Cpu).unwrap();
+        let r = rotate_pairwise(&x).unwrap().to_vec2::<f32>().unwrap();
+        assert_eq!(r, vec![vec![-2.0, 1.0, -4.0, 3.0]]);
+        let (cos, sin) = rope_tables(10000.0).unwrap();
+        // cell (0, 0): angle 0 everywhere
+        let c = cos.narrow(0, 0, 1).unwrap().to_vec2::<f32>().unwrap();
+        let s = sin.narrow(0, 0, 1).unwrap().to_vec2::<f32>().unwrap();
+        assert!(c[0].iter().all(|v| *v == 1.0) && s[0].iter().all(|v| *v == 0.0));
+    }
+}
diff --git a/crates/sam2/src/memory.rs b/crates/sam2/src/memory.rs
new file mode 100644
index 000000000..7a73fd5a3
--- /dev/null
+++ b/crates/sam2/src/memory.rs
@@ -0,0 +1,138 @@
+// Modified work: ported from Hugging Face `transformers` `models/sam2_video/modeling_sam2_video.py`
+// (Sam2VideoMemoryEncoder, Sam2VideoMaskDownSampler, Sam2VideoMemoryFuser; Apache-2.0, Copyright
+// The HuggingFace Inc. team) to Rust on candle. See NOTICE.
+//! The memory encoder: a frame's mask is down-sampled and fused with the frame's image features
+//! into a compact memory (64 channels on the 64 x 64 grid) plus its position encoding.
+
+use candle_core::Tensor;
+
+use crate::Result;
+use crate::neck::sine_position;
+use crate::nn::{LayerNorm, apply, apply_gelu, gelu, layer_norm, linear};
+use crate::weights::Weights;
+use candle_nn::Linear;
+
+struct Conv {
+    w: Tensor,
+    b: Tensor,
+    padding: usize,
+    stride: usize,
+    groups: usize,
+}
+
+impl Conv {
+    fn load(w: &Weights, name: &str, shape: &[usize], padding: usize, stride: usize, groups: usize) -> Result<Conv> {
+        let out = shape.first().copied().unwrap_or(0);
+        Ok(Conv { w: w.get(&format!("{name}.weight"), shape)?, b: w.get(&format!("{name}.bias"), &[out])?, padding, stride, groups })
+    }
+
+    fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        let y = x.conv2d(&self.w, self.padding, self.stride, 1, self.groups)?;
+        Ok(y.broadcast_add(&self.b.reshape((1, self.b.dim(0)?, 1, 1))?)?)
+    }
+}
+
+/// Layer norm over the channel dimension of `[B, C, H, W]`.
+fn norm_channels_first(ln: &LayerNorm, x: &Tensor) -> Result<Tensor> {
+    ln.forward(&x.permute((0, 2, 3, 1))?.contiguous()?)?.permute((0, 3, 1, 2))?.contiguous().map_err(Into::into)
+}
+
+struct FuserBlock {
+    depthwise: Conv,
+    norm: LayerNorm,
+    pw1: Linear,
+    pw2: Linear,
+    scale: Tensor,
+}
+
+impl FuserBlock {
+    fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        let h = norm_channels_first(&self.norm, &self.depthwise.forward(x)?)?;
+        let h = h.permute((0, 2, 3, 1))?.contiguous()?;
+        let h = apply(&self.pw2, &apply_gelu(&self.pw1, &h)?)?;
+        let h = h.broadcast_mul(&self.scale)?.permute((0, 3, 1, 2))?.contiguous()?;
+        Ok((x + h)?)
+    }
+}
+
+pub struct MemoryEncoder {
+    down: Vec<(Conv, LayerNorm)>,
+    final_conv: Conv,
+    feature_projection: Conv,
+    fuser: Vec<FuserBlock>,
+    projection: Conv,
+    occlusion: Tensor,
+}
+
+/// A frame's memory: `features` is `[HW, 64]` rounded through bfloat16 exactly as the reference
+/// stores it, `pos` is the `[HW, 64]` sine position encoding.
+pub struct Memory {
+    pub features: Tensor,
+    pub pos: Tensor,
+}
+
+impl MemoryEncoder {
+    pub fn load(w: &Weights) -> Result<MemoryEncoder> {
+        let mut down = vec![];
+        let mut ch = 1;
+        for i in 0..4 {
+            let out = ch * 4;
+            let p = format!("memory_encoder.mask_downsampler.layers.{i}");
+            down.push((Conv::load(w, &format!("{p}.conv"), &[out, ch, 3, 3], 1, 2, 1)?, layer_norm(w, &format!("{p}.layer_norm"), out, 1e-6)?));
+            ch = out;
+        }
+        let fuser = (0..2)
+            .map(|i| {
+                let p = format!("memory_encoder.memory_fuser.layers.{i}");
+                Ok(FuserBlock {
+                    depthwise: Conv::load(w, &format!("{p}.depthwise_conv"), &[256, 1, 7, 7], 3, 1, 256)?,
+                    norm: layer_norm(w, &format!("{p}.layer_norm"), 256, 1e-6)?,
+                    pw1: linear(w, &format!("{p}.pointwise_conv1"), 256, 1024)?,
+                    pw2: linear(w, &format!("{p}.pointwise_conv2"), 1024, 256)?,
+                    scale: w.get(&format!("{p}.scale"), &[256])?,
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+        Ok(MemoryEncoder {
+            down,
+            final_conv: Conv::load(w, "memory_encoder.mask_downsampler.final_conv", &[256, 256, 1, 1], 0, 1, 1)?,
+            feature_projection: Conv::load(w, "memory_encoder.feature_projection", &[256, 256, 1, 1], 0, 1, 1)?,
+            fuser,
+            projection: Conv::load(w, "memory_encoder.projection", &[64, 256, 1, 1], 0, 1, 1)?,
+            occlusion: w.get("occlusion_spatial_embedding_parameter", &[1, 64])?,
+        })
+    }
+
+    /// `features`: `[1, 256, g, g]` image features; `mask`: `[1, 1, 16 g, 16 g]` already scaled
+    /// (`20 * m - 10`). Returns the raw `[1, 64, g, g]` features and position encoding.
+    pub fn encode(&self, features: &Tensor, mask: &Tensor) -> Result<(Tensor, Tensor)> {
+        let mut m = mask.clone();
+        for (conv, ln) in &self.down {
+            m = gelu(&norm_channels_first(ln, &conv.forward(&m)?)?)?;
+        }
+        let m = self.final_conv.forward(&m)?;
+        let mut x = (self.feature_projection.forward(features)? + m)?;
+        for b in &self.fuser {
+            x = b.forward(&x)?;
+        }
+        let x = self.projection.forward(&x)?;
+        let pos = sine_position(32, x.dim(2)?, x.dim(3)?)?;
+        Ok((x, pos))
+    }
+
+    /// The memory kept for a frame: the encoder output, plus the occlusion embedding when the
+    /// object is absent, rounded through bfloat16 like the reference.
+    pub fn memory(&self, features: &Tensor, mask: &Tensor, object_present: bool) -> Result<Memory> {
+        let (x, _) = self.encode(features, mask)?;
+        self.finish(&x.flatten_from(2)?.squeeze(0)?.t()?.contiguous()?, object_present)
+    }
+
+    /// A memory from the encoder's raw tokens `[HW, 64]`: the occlusion embedding when the object is absent,
+    /// rounded through bfloat16, with the position encoding (shared by the CPU and GPU encoders).
+    pub fn finish(&self, tokens: &Tensor, object_present: bool) -> Result<Memory> {
+        let tokens = if object_present { tokens.clone() } else { tokens.broadcast_add(&self.occlusion)? };
+        let features = tokens.to_dtype(candle_core::DType::BF16)?.to_dtype(candle_core::DType::F32)?;
+        let pos = sine_position(32, 64, 64)?;
+        Ok(Memory { features, pos: pos.flatten_from(2)?.squeeze(0)?.t()?.contiguous()? })
+    }
+}
diff --git a/crates/sam2/src/model.rs b/crates/sam2/src/model.rs
new file mode 100644
index 000000000..36e30e310
--- /dev/null
+++ b/crates/sam2/src/model.rs
@@ -0,0 +1,87 @@
+// Modified work: ported from Hugging Face `transformers` `Sam2Model` (Apache-2.0, Copyright The
+// HuggingFace Inc. team) to Rust on candle. See NOTICE.
+//! The single-image model: encode a frame once, then decode any number of prompts against it.
+
+use std::path::Path;
+
+use candle_core::{Device, Tensor};
+
+use crate::decoder::{DecoderOutput, MaskDecoder};
+use crate::neck::{ImageFeatures, VisionEncoder};
+use crate::prompt::{INPUT_SIZE, Prompt, PromptEncoder};
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+/// A frame after the vision encoder: reusable for every prompt on that frame.
+pub struct Encoded {
+    /// The three neck levels, highest resolution first (`[1, 256, 256, 256]`, `128`, `64`).
+    pub features: ImageFeatures,
+    /// The decoder's skip features from the two highest-resolution levels.
+    pub high: (Tensor, Tensor),
+}
+
+pub struct ImageModel {
+    pub vision: VisionEncoder,
+    pub prompt: PromptEncoder,
+    pub decoder: MaskDecoder,
+    no_memory: Tensor,
+    image_pos: Tensor,
+}
+
+impl ImageModel {
+    pub fn load(w: &Weights) -> Result<ImageModel> {
+        let prompt = PromptEncoder::load(w)?;
+        Ok(ImageModel {
+            vision: VisionEncoder::load(w)?,
+            decoder: MaskDecoder::load(w)?,
+            no_memory: w.get("no_memory_embedding", &[1, 1, 256])?.reshape((1, 256, 1, 1))?,
+            image_pos: prompt.image_positions()?,
+            prompt,
+        })
+    }
+
+    pub fn open(path: &Path) -> Result<ImageModel> {
+        ImageModel::load(&Weights::open(path)?)
+    }
+
+    /// Encode a normalised `[1, 3, 1024, 1024]` frame.
+    pub fn encode(&self, pixels: &Tensor) -> Result<Encoded> {
+        if pixels.dims() != [1, 3, INPUT_SIZE, INPUT_SIZE] {
+            return Err(Error::Input(format!("pixels must be [1, 3, {INPUT_SIZE}, {INPUT_SIZE}], got {:?}", pixels.dims())));
+        }
+        let features = self.vision.forward(pixels)?;
+        let (l0, l1) = match (features.features.first(), features.features.get(1)) {
+            (Some(a), Some(b)) => (a, b),
+            _ => return Err(Error::Compute("vision encoder returned too few levels".into())),
+        };
+        let high = self.decoder.high_res(l0, l1)?;
+        Ok(Encoded { features, high })
+    }
+
+    /// Prompt embeddings (sparse tokens, empty dense map) for a click/box prompt.
+    pub fn embed_prompt(&self, p: &Prompt) -> Result<(Tensor, Tensor)> {
+        Ok((self.prompt.sparse(p)?, self.prompt.dense_empty()?))
+    }
+
+    /// Decode masks for a prompt on an encoded frame.
+    pub fn segment(&self, enc: &Encoded, p: &Prompt, multimask: bool) -> Result<DecoderOutput> {
+        let low = enc.features.features.get(2).ok_or_else(|| Error::Compute("vision encoder returned too few levels".into()))?;
+        let image = low.broadcast_add(&self.no_memory)?;
+        let (sparse, dense) = self.embed_prompt(p)?;
+        self.decoder.forward(&image, &self.image_pos, &sparse, &dense, &enc.high, multimask)
+    }
+
+    /// Decode against an already memory-conditioned embedding `[1, 256, g, g]` (video tracking).
+    pub fn decode_embedded(&self, image: &Tensor, high: &(Tensor, Tensor), sparse: &Tensor, dense: &Tensor, multimask: bool) -> Result<DecoderOutput> {
+        self.decoder.forward(image, &self.image_pos, sparse, dense, high, multimask)
+    }
+
+    /// The learned embedding added to a frame's features when there is no memory yet.
+    pub fn no_memory(&self) -> &Tensor {
+        &self.no_memory
+    }
+
+    pub fn device(&self) -> Device {
+        Device::Cpu
+    }
+}
diff --git a/crates/sam2/src/neck.rs b/crates/sam2/src/neck.rs
new file mode 100644
index 000000000..50733fe79
--- /dev/null
+++ b/crates/sam2/src/neck.rs
@@ -0,0 +1,221 @@
+// Modified work: ported from Hugging Face `transformers` `models/sam2/modeling_sam2.py`
+// (Sam2VisionNeck, Sam2SinePositionEmbedding, Sam2VisionModel; Apache-2.0, Copyright The
+// HuggingFace Inc. team) to Rust on candle. See NOTICE.
+//! The feature pyramid neck on top of Hiera, and the vision encoder that joins them.
+
+use std::collections::HashMap;
+use std::sync::{Mutex, OnceLock, PoisonError};
+
+use candle_core::{Device, Tensor};
+
+use crate::hiera::{Hiera, HieraConfig};
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+/// Sine position encoding `[1, 2 * num_pos_features, h, w]`, normalised (`Sam2SinePositionEmbedding`).
+/// Only small tables are retained globally; the neck owns its larger feature-pyramid tables.
+pub fn sine_position(num_pos_features: usize, h: usize, w: usize) -> Result<Tensor> {
+    static CACHE: OnceLock<PositionCache> = OnceLock::new();
+    CACHE.get_or_init(|| PositionCache::new(1024 * 1024 / size_of::<f32>())).get(num_pos_features, h, w)
+}
+
+const MAX_POSITION_ELEMENTS: usize = 128 * 1024 * 1024 / size_of::<f32>();
+
+struct PositionCache {
+    entries: Mutex<HashMap<(usize, usize, usize), Tensor>>,
+    max_elements: usize,
+}
+
+impl PositionCache {
+    fn new(max_elements: usize) -> Self {
+        Self { entries: Mutex::new(HashMap::new()), max_elements }
+    }
+
+    fn get(&self, features: usize, h: usize, w: usize) -> Result<Tensor> {
+        let key = (features, h, w);
+        if let Some(t) = self.entries.lock().unwrap_or_else(PoisonError::into_inner).get(&key) {
+            return Ok(t.clone());
+        }
+        let t = build_sine_position(features, h, w)?;
+        let count = t.elem_count();
+        if count <= self.max_elements {
+            let mut map = self.entries.lock().unwrap_or_else(PoisonError::into_inner);
+            let retained = map.values().fold(0usize, |n, t| n.saturating_add(t.elem_count()));
+            if map.len() >= 16 || retained.saturating_add(count) > self.max_elements {
+                map.clear();
+            }
+            map.insert(key, t.clone());
+        }
+        Ok(t)
+    }
+}
+
+fn build_sine_position(num_pos_features: usize, h: usize, w: usize) -> Result<Tensor> {
+    let count = num_pos_features.checked_mul(2).and_then(|n| n.checked_mul(h)).and_then(|n| n.checked_mul(w));
+    let count =
+        count.filter(|n| *n > 0 && *n <= MAX_POSITION_ELEMENTS).ok_or_else(|| Error::Input("sine position dimensions are empty or exceed 128 MiB".into()))?;
+    let eps = 1e-6f32;
+    let scale = 2.0 * std::f32::consts::PI;
+    let dim_t: Vec<f32> = (0..num_pos_features).map(|i| 10000f32.powf(2.0 * (i / 2) as f32 / num_pos_features as f32)).collect();
+    let axis = |n: usize, k: usize| -> Vec<f32> {
+        // value of one coordinate at index k of an axis of length n, over the feature dimension
+        let e = (k + 1) as f32 / (n as f32 + eps) * scale;
+        dim_t.iter().enumerate().map(|(i, d)| if i % 2 == 0 { (e / d).sin() } else { (e / d).cos() }).collect()
+    };
+    let (ys, xs): (Vec<_>, Vec<_>) = ((0..h).map(|k| axis(h, k)).collect(), (0..w).map(|k| axis(w, k)).collect());
+    let mut out = vec![0f32; count];
+    for y in 0..h {
+        for x in 0..w {
+            for f in 0..num_pos_features {
+                let (py, px) = (ys.get(y).and_then(|v| v.get(f)), xs.get(x).and_then(|v| v.get(f)));
+                if let (Some(py), Some(px)) = (py, px) {
+                    if let Some(o) = out.get_mut((f * h + y) * w + x) {
+                        *o = *py;
+                    }
+                    if let Some(o) = out.get_mut(((num_pos_features + f) * h + y) * w + x) {
+                        *o = *px;
+                    }
+                }
+            }
+        }
+    }
+    Ok(Tensor::from_vec(out, (1, 2 * num_pos_features, h, w), &Device::Cpu)?)
+}
+
+struct Conv1x1 {
+    w: Tensor,
+    b: Tensor,
+    out: usize,
+}
+
+impl Conv1x1 {
+    fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        Ok(x.conv2d(&self.w, 0, 1, 1, 1)?.broadcast_add(&self.b.reshape((1, self.out, 1, 1))?)?)
+    }
+}
+
+/// The FPN neck: a 1x1 conv per stage, top-down additions on the two lowest-resolution levels.
+pub struct Neck {
+    convs: Vec<Conv1x1>,
+    top_down: Vec<usize>,
+    pos_features: usize,
+    positions: PositionCache,
+}
+
+/// What the neck produces, both in the neck's own order (lowest resolution first, all four
+/// levels) as `[B, C, H, W]`.
+pub struct NeckOutput {
+    pub features: Vec<Tensor>,
+    pub positions: Vec<Tensor>,
+}
+
+impl Neck {
+    /// Position tables shared by the CPU and GPU paths, released with this neck.
+    pub(crate) fn position(&self, h: usize, w: usize) -> Result<Tensor> {
+        self.positions.get(self.pos_features, h, w)
+    }
+
+    pub fn load(w: &Weights, channels: &[usize], fpn: usize, top_down: &[usize]) -> Result<Neck> {
+        let convs = channels
+            .iter()
+            .enumerate()
+            .map(|(j, c)| {
+                Ok(Conv1x1 {
+                    w: w.get(&format!("vision_encoder.neck.convs.{j}.weight"), &[fpn, *c, 1, 1])?,
+                    b: w.get(&format!("vision_encoder.neck.convs.{j}.bias"), &[fpn])?,
+                    out: fpn,
+                })
+            })
+            .collect::<Result<Vec<_>>>()?;
+        Ok(Neck { convs, top_down: top_down.to_vec(), pos_features: fpn / 2, positions: PositionCache::new(MAX_POSITION_ELEMENTS) })
+    }
+
+    /// `stages`: Hiera stage outputs, NHWC, highest resolution first.
+    pub fn forward(&self, stages: &[Tensor]) -> Result<NeckOutput> {
+        let n = self.convs.len().checked_sub(1).ok_or_else(|| Error::Weights("neck has no convolutions".into()))?;
+        if stages.len() != self.convs.len() {
+            return Err(Error::Input(format!("neck expects {} stages, got {}", self.convs.len(), stages.len())));
+        }
+        let (mut features, mut positions) = (vec![], vec![]);
+        let mut prev: Option<Tensor> = None;
+        for i in (0..=n).rev() {
+            let stage = stages.get(i).ok_or_else(|| Error::Input("missing stage".into()))?;
+            let conv = self.convs.get(n - i).ok_or_else(|| Error::Weights("missing neck convolution".into()))?;
+            let lateral = conv.forward(&stage.permute((0, 3, 1, 2))?.contiguous()?)?;
+            let cur = match (&prev, self.top_down.contains(&i) && i != n) {
+                (Some(p), true) => {
+                    let (h, w) = (p.dim(2)? * 2, p.dim(3)? * 2);
+                    (lateral + p.upsample_nearest2d(h, w)?)?
+                }
+                _ => lateral,
+            };
+            positions.push(self.position(cur.dim(2)?, cur.dim(3)?)?);
+            features.push(cur.clone());
+            prev = Some(cur);
+        }
+        Ok(NeckOutput { features, positions })
+    }
+}
+
+/// Hiera plus neck: `Sam2VisionModel`.
+pub struct VisionEncoder {
+    pub hiera: std::sync::Arc<Hiera>,
+    pub neck: Neck,
+    levels: usize,
+}
+
+/// The multi-scale image features the decoder and memory modules use, highest resolution first
+/// (256², 128², 64² for a 1024 input), `[B, C, H, W]`.
+pub struct ImageFeatures {
+    pub features: Vec<Tensor>,
+    pub positions: Vec<Tensor>,
+}
+
+impl VisionEncoder {
+    /// The encoder of whichever size the checkpoint is.
+    pub fn load(w: &Weights) -> Result<VisionEncoder> {
+        let cfg = HieraConfig::for_size(crate::Size::detect(w)?);
+        let channels: Vec<usize> = cfg.embed_dims.iter().rev().copied().collect();
+        Ok(VisionEncoder { hiera: std::sync::Arc::new(Hiera::load(w, &cfg)?), neck: Neck::load(w, &channels, 256, &[2, 3])?, levels: 3 })
+    }
+
+    pub fn forward(&self, pixels: &Tensor) -> Result<ImageFeatures> {
+        let stages = self.hiera.forward(pixels)?;
+        let out = self.neck.forward(&stages)?;
+        // keep the last `levels` of the neck order and reverse: high to low resolution
+        let keep = |v: Vec<Tensor>| -> Vec<Tensor> {
+            let skip = v.len().saturating_sub(self.levels);
+            v.into_iter().skip(skip).rev().collect()
+        };
+        Ok(ImageFeatures { features: keep(out.features), positions: keep(out.positions) })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn position_tables_reject_empty_overflowing_and_oversized_dimensions() {
+        for (features, h, w) in [(0, 1, 1), (1, 0, 1), (1, 1, 0), (usize::MAX, 2, 2), (128, usize::MAX, 2), (128, 1024, 1024)] {
+            assert!(matches!(sine_position(features, h, w), Err(Error::Input(_))), "{features}, {h}, {w}");
+        }
+    }
+
+    #[test]
+    fn position_cache_bounds_retained_elements_and_preserves_the_encoding() {
+        let neck = Neck { convs: vec![], top_down: vec![], pos_features: 2, positions: PositionCache::new(64) };
+        let cache = &neck.positions;
+        let first = neck.position(2, 4).unwrap();
+        assert_eq!(first.dims(), &[1, 4, 2, 4]);
+        assert_eq!(first.flatten_all().unwrap().to_vec1::<f32>().unwrap(), neck.position(2, 4).unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap());
+        neck.position(3, 4).unwrap();
+        let entries = cache.entries.lock().unwrap();
+        assert_eq!(entries.len(), 1, "older tables are evicted to fit the budget");
+        assert!(entries.values().map(Tensor::elem_count).sum::<usize>() <= 64);
+        drop(entries);
+        let large = neck.position(8, 8).unwrap();
+        assert_eq!(large.dims(), &[1, 4, 8, 8]);
+        assert_eq!(cache.entries.lock().unwrap().len(), 1, "a table over budget is returned without retention");
+    }
+}
diff --git a/crates/sam2/src/nn.rs b/crates/sam2/src/nn.rs
new file mode 100644
index 000000000..256a60da9
--- /dev/null
+++ b/crates/sam2/src/nn.rs
@@ -0,0 +1,171 @@
+// Modified work: small layers used by the ported SAM 2 modules (Apache-2.0, see NOTICE).
+//! Linear, layer norm and a few tensor helpers on candle.
+
+use candle_core::{CpuStorage, CustomOp1, CustomOp2, Layout, Shape, Tensor};
+use candle_nn::Linear;
+
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+pub fn linear(w: &Weights, prefix: &str, input: usize, output: usize) -> Result<Linear> {
+    Ok(Linear::new(w.get(&format!("{prefix}.weight"), &[output, input])?, Some(w.get(&format!("{prefix}.bias"), &[output])?)))
+}
+
+/// Layer norm over the last dimension using candle's fused kernel (much faster than the
+/// composed `candle_nn::LayerNorm` on large activations).
+pub struct LayerNorm {
+    weight: Tensor,
+    bias: Tensor,
+    eps: f32,
+}
+
+impl LayerNorm {
+    pub fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        Ok(candle_nn::ops::layer_norm(&x.contiguous()?, &self.weight, &self.bias, self.eps)?)
+    }
+}
+
+pub fn layer_norm(w: &Weights, prefix: &str, dim: usize, eps: f64) -> Result<LayerNorm> {
+    Ok(LayerNorm { weight: w.get(&format!("{prefix}.weight"), &[dim])?, bias: w.get(&format!("{prefix}.bias"), &[dim])?, eps: eps as f32 })
+}
+
+/// Two-layer MLP with exact (erf) GELU, as `Sam2FeedForward` with `num_layers = 2`.
+pub struct Mlp {
+    pub proj_in: Linear,
+    pub proj_out: Linear,
+}
+
+impl Mlp {
+    pub fn load(w: &Weights, prefix: &str, dim: usize, hidden: usize) -> Result<Mlp> {
+        Ok(Mlp { proj_in: linear(w, &format!("{prefix}.proj_in"), dim, hidden)?, proj_out: linear(w, &format!("{prefix}.proj_out"), hidden, dim)? })
+    }
+
+    pub fn forward(&self, x: &Tensor) -> Result<Tensor> {
+        apply(&self.proj_out, &apply_gelu(&self.proj_in, x)?)
+    }
+}
+
+/// `x + bias` (and, for [`bias_gelu`], then GELU) over rows of `x`, on all cores. Candle adds a bias
+/// on one thread, which cost more than the matmul it followed on the wide activations of the early
+/// Hiera blocks.
+struct BiasAdd {
+    gelu: bool,
+}
+
+impl CustomOp2 for BiasAdd {
+    fn name(&self) -> &'static str {
+        "bias_add_parallel"
+    }
+
+    fn cpu_fwd(&self, xs: &CpuStorage, xl: &Layout, bs: &CpuStorage, bl: &Layout) -> candle_core::Result<(CpuStorage, Shape)> {
+        use rayon::prelude::*;
+        let (CpuStorage::F32(x), CpuStorage::F32(b)) = (xs, bs) else { candle_core::bail!("bias_add_parallel needs f32") };
+        let (Some((x0, x1)), Some((b0, b1))) = (xl.contiguous_offsets(), bl.contiguous_offsets()) else {
+            candle_core::bail!("bias_add_parallel needs contiguous inputs")
+        };
+        let (x, b) = match (x.get(x0..x1), b.get(b0..b1)) {
+            (Some(x), Some(b)) if !b.is_empty() && x.len() % b.len() == 0 => (x, b),
+            _ => candle_core::bail!("bias_add_parallel: sizes do not fit"),
+        };
+        let cols = b.len();
+        let mut out = vec![0f32; x.len()];
+        let rows_per = (64 * 1024 / cols).max(1);
+        let gelu = self.gelu;
+        out.par_chunks_mut(rows_per * cols).zip(x.par_chunks(rows_per * cols)).for_each(|(o, i)| {
+            for (orow, irow) in o.chunks_mut(cols).zip(i.chunks(cols)) {
+                for ((a, v), bias) in orow.iter_mut().zip(irow).zip(b) {
+                    let y = v + bias;
+                    *a = if gelu { (candle_core::cpu::erf::erf_f32(y * std::f32::consts::FRAC_1_SQRT_2) + 1.0) * 0.5 * y } else { y };
+                }
+            }
+        });
+        Ok((CpuStorage::F32(out), xl.shape().clone()))
+    }
+}
+
+fn bias_op(x: &Tensor, bias: &Tensor, gelu: bool) -> Result<Tensor> {
+    if x.dtype() != candle_core::DType::F32 || !x.device().is_cpu() {
+        let y = x.broadcast_add(bias)?;
+        return Ok(if gelu { y.gelu_erf()? } else { y });
+    }
+    Ok(x.contiguous()?.apply_op2_no_bwd(&bias.contiguous()?, &BiasAdd { gelu })?)
+}
+
+fn matmul_bias(l: &Linear, x: &Tensor, gelu: bool) -> Result<Tensor> {
+    let dims = x.dims();
+    let (&last, lead) = dims.split_last().ok_or_else(|| Error::Compute("linear on a scalar".into()))?;
+    let rows: usize = lead.iter().product();
+    let y = x.reshape((rows, last))?.matmul(&l.weight().t()?)?;
+    let y = match l.bias() {
+        Some(b) => bias_op(&y, b, gelu)?,
+        None if gelu => y.gelu_erf()?,
+        None => y,
+    };
+    let mut out: Vec<usize> = lead.to_vec();
+    out.push(y.dim(1)?);
+    Ok(y.reshape(out)?)
+}
+
+/// Apply a linear layer to `[.., in]` through a flat 2-D matmul and a parallel bias add. Candle's
+/// `Linear::forward` broadcasts the weight over every leading dimension (copying it per window) and
+/// adds the bias on one thread: both slow on the 4-D activations of the backbone.
+pub fn apply(l: &Linear, x: &Tensor) -> Result<Tensor> {
+    matmul_bias(l, x, false)
+}
+
+/// [`apply`] followed by the exact GELU, in the same pass over the output.
+pub fn apply_gelu(l: &Linear, x: &Tensor) -> Result<Tensor> {
+    matmul_bias(l, x, true)
+}
+
+/// Exact (erf) GELU on all cores. Candle's own `gelu_erf` runs on one thread, which made it a third of
+/// the time of the Hiera blocks; this gives the same values (it calls the same `erf` per element).
+struct GeluErf;
+
+impl CustomOp1 for GeluErf {
+    fn name(&self) -> &'static str {
+        "gelu_erf_parallel"
+    }
+
+    fn cpu_fwd(&self, storage: &CpuStorage, layout: &Layout) -> candle_core::Result<(CpuStorage, Shape)> {
+        use rayon::prelude::*;
+        let CpuStorage::F32(data) = storage else { candle_core::bail!("gelu_erf_parallel needs f32") };
+        let Some((start, end)) = layout.contiguous_offsets() else { candle_core::bail!("gelu_erf_parallel needs a contiguous input") };
+        let src = data.get(start..end).ok_or_else(|| candle_core::Error::Msg("gelu_erf_parallel: layout outside the storage".into()))?;
+        let mut out = vec![0f32; src.len()];
+        const CHUNK: usize = 16 * 1024;
+        out.par_chunks_mut(CHUNK).zip(src.par_chunks(CHUNK)).for_each(|(o, i)| {
+            for (a, v) in o.iter_mut().zip(i) {
+                *a = (candle_core::cpu::erf::erf_f32(v * std::f32::consts::FRAC_1_SQRT_2) + 1.0) * 0.5 * v;
+            }
+        });
+        Ok((CpuStorage::F32(out), layout.shape().clone()))
+    }
+}
+
+/// Exact GELU of `x`, in parallel for f32 tensors.
+pub fn gelu(x: &Tensor) -> Result<Tensor> {
+    if x.dtype() != candle_core::DType::F32 || !x.device().is_cpu() {
+        return Ok(x.gelu_erf()?);
+    }
+    Ok(x.contiguous()?.apply_op1_no_bwd(&GeluErf)?)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use candle_core::Device;
+
+    #[test]
+    fn the_parallel_gelu_equals_candles_bit_for_bit() {
+        let v: Vec<f32> = (0..101_000).map(|i| ((i as f32) * 0.00037).sin() * 6.0 - 0.5).collect();
+        let x = Tensor::from_vec(v, (101, 1000), &Device::Cpu).unwrap();
+        let (a, b) = (gelu(&x).unwrap(), x.gelu_erf().unwrap());
+        assert_eq!(a.flatten_all().unwrap().to_vec1::<f32>().unwrap(), b.flatten_all().unwrap().to_vec1::<f32>().unwrap());
+        // a transposed (non-contiguous) input works, and an empty one does too
+        let t = x.t().unwrap();
+        assert_eq!(gelu(&t).unwrap().dims(), t.dims());
+        let e = Tensor::zeros((0, 4), candle_core::DType::F32, &Device::Cpu).unwrap();
+        assert_eq!(gelu(&e).unwrap().elem_count(), 0);
+    }
+}
diff --git a/crates/sam2/src/prompt.rs b/crates/sam2/src/prompt.rs
new file mode 100644
index 000000000..23d9a7c99
--- /dev/null
+++ b/crates/sam2/src/prompt.rs
@@ -0,0 +1,237 @@
+// Modified work: ported from Hugging Face `transformers` `models/sam2/modeling_sam2.py`
+// (Sam2PositionalEmbedding, Sam2MaskEmbedding, Sam2PromptEncoder; Apache-2.0, Copyright The
+// HuggingFace Inc. team) to Rust on candle. See NOTICE.
+//! The prompt encoder: clicks and boxes become sparse tokens, a mask or "no mask" becomes a dense map.
+
+use candle_core::{Device, Tensor};
+
+use crate::nn::{LayerNorm, gelu, layer_norm};
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+/// Side of the (square) model input in pixels; prompts are given in these coordinates.
+pub const INPUT_SIZE: usize = 1024;
+/// Side of the image-embedding grid (input / 16).
+pub const GRID: usize = INPUT_SIZE / 16;
+const DIM: usize = 256;
+
+/// What the user pointed at, in model-input pixels (0..1024).
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Prompt {
+    /// Clicks and whether each is foreground.
+    pub points: Vec<([f32; 2], bool)>,
+    /// A box `[x0, y0, x1, y1]`.
+    pub bbox: Option<[f32; 4]>,
+}
+
+impl Prompt {
+    /// Reject non-finite or absurd coordinates (they come from the user or an agent).
+    pub fn validate(&self) -> Result<()> {
+        let bad = |v: f32| !v.is_finite() || v.abs() > 4.0 * INPUT_SIZE as f32;
+        if self.points.iter().any(|(p, _)| p.iter().any(|v| bad(*v))) || self.bbox.is_some_and(|b| b.iter().any(|v| bad(*v))) {
+            return Err(Error::Input("prompt coordinates must be finite and near the frame".into()));
+        }
+        if self.points.len() > 64 {
+            return Err(Error::Input("at most 64 points per prompt".into()));
+        }
+        Ok(())
+    }
+}
+
+struct MaskEmbed {
+    conv: [(Tensor, Tensor, usize, usize); 3],
+    ln1: LayerNorm,
+    ln2: LayerNorm,
+}
+
+/// Sparse and dense prompt embeddings.
+pub struct PromptEncoder {
+    gauss: Vec<f32>,
+    point_embed: Vec<f32>,
+    not_a_point: Vec<f32>,
+    no_mask: Tensor,
+    mask: MaskEmbed,
+}
+
+fn rows(t: Tensor) -> Result<Vec<f32>> {
+    Ok(t.flatten_all()?.to_vec1::<f32>()?)
+}
+
+impl PromptEncoder {
+    pub fn load(w: &Weights) -> Result<PromptEncoder> {
+        let conv = |name: &str, i: usize, o: usize, k: usize, stride: usize| -> Result<(Tensor, Tensor, usize, usize)> {
+            Ok((
+                w.get(&format!("prompt_encoder.mask_embed.{name}.weight"), &[o, i, k, k])?,
+                w.get(&format!("prompt_encoder.mask_embed.{name}.bias"), &[o])?,
+                k,
+                stride,
+            ))
+        };
+        Ok(PromptEncoder {
+            gauss: rows(w.get("prompt_encoder.shared_embedding.positional_embedding", &[2, DIM / 2])?)?,
+            point_embed: rows(w.get("prompt_encoder.point_embed.weight", &[4, DIM])?)?,
+            not_a_point: rows(w.get("prompt_encoder.not_a_point_embed.weight", &[1, DIM])?)?,
+            no_mask: w.get("prompt_encoder.no_mask_embed.weight", &[1, DIM])?,
+            mask: MaskEmbed {
+                conv: [conv("conv1", 1, 4, 2, 2)?, conv("conv2", 4, 16, 2, 2)?, conv("conv3", 16, DIM, 1, 1)?],
+                ln1: layer_norm(w, "prompt_encoder.mask_embed.layer_norm1", 4, 1e-6)?,
+                ln2: layer_norm(w, "prompt_encoder.mask_embed.layer_norm2", 16, 1e-6)?,
+            },
+        })
+    }
+
+    /// Random-Fourier position encoding of coordinates already normalised to 0..1: `[n * 256]`.
+    fn fourier(&self, coords01: &[[f32; 2]]) -> Vec<f32> {
+        let half = DIM / 2;
+        let mut out = vec![0f32; coords01.len() * DIM];
+        for (n, c) in coords01.iter().enumerate() {
+            let (x, y) = (2.0 * c[0] - 1.0, 2.0 * c[1] - 1.0);
+            for j in 0..half {
+                let g0 = self.gauss.get(j).copied().unwrap_or(0.0);
+                let g1 = self.gauss.get(half + j).copied().unwrap_or(0.0);
+                let v = 2.0 * std::f32::consts::PI * (x * g0 + y * g1);
+                if let Some(o) = out.get_mut(n * DIM + j) {
+                    *o = v.sin();
+                }
+                if let Some(o) = out.get_mut(n * DIM + half + j) {
+                    *o = v.cos();
+                }
+            }
+        }
+        out
+    }
+
+    /// The position encoding of the whole `GRID x GRID` embedding, `[1, 256, GRID, GRID]`.
+    pub fn image_positions(&self) -> Result<Tensor> {
+        let coords: Vec<[f32; 2]> = (0..GRID * GRID).map(|i| [((i % GRID) as f32 + 0.5) / GRID as f32, ((i / GRID) as f32 + 0.5) / GRID as f32]).collect();
+        let flat = self.fourier(&coords);
+        Ok(Tensor::from_vec(flat, (GRID * GRID, DIM), &Device::Cpu)?.t()?.reshape((1, DIM, GRID, GRID))?.contiguous()?)
+    }
+
+    fn point_row(&self, i: usize) -> &[f32] {
+        self.point_embed.get(i * DIM..(i + 1) * DIM).unwrap_or(&[])
+    }
+
+    /// Sparse tokens `[1, n, 256]`; the pinned reference pads both click-only and box prompts.
+    pub fn sparse(&self, p: &Prompt) -> Result<Tensor> {
+        p.validate()?;
+        let norm = |c: [f32; 2]| [(c[0] + 0.5) / INPUT_SIZE as f32, (c[1] + 0.5) / INPUT_SIZE as f32];
+        let mut tokens: Vec<f32> = vec![];
+        let mut n = 0;
+        let mut push = |v: &[f32]| {
+            tokens.extend_from_slice(v);
+            n += 1;
+        };
+        let pts: Vec<[f32; 2]> = p.points.iter().map(|(c, _)| norm(*c)).collect();
+        let enc = self.fourier(&pts);
+        for (k, (_, fg)) in p.points.iter().enumerate() {
+            let e = enc.get(k * DIM..(k + 1) * DIM).unwrap_or(&[]);
+            let label_row = self.point_row(usize::from(*fg));
+            let v: Vec<f32> = e.iter().zip(label_row).map(|(a, b)| a + b).collect();
+            push(&v);
+        }
+        match p.bbox {
+            None => push(&self.not_a_point.clone()),
+            Some(b) => {
+                let corners = [norm([b[0], b[1]]), norm([b[2], b[3]])];
+                let enc = self.fourier(&corners);
+                for (k, row) in [2usize, 3].into_iter().enumerate() {
+                    let e = enc.get(k * DIM..(k + 1) * DIM).unwrap_or(&[]);
+                    let v: Vec<f32> = e.iter().zip(self.point_row(row)).map(|(a, b)| a + b).collect();
+                    push(&v);
+                }
+                // _embed_boxes adds its own no-point token, separately from _embed_points.
+                push(&self.not_a_point.clone());
+            }
+        }
+        Ok(Tensor::from_vec(tokens, (1, n, DIM), &Device::Cpu)?)
+    }
+
+    /// Tokens for "no prompt" on a tracked frame: the reference feeds one point labelled -1 and
+    /// then pads another, so two `not_a_point` tokens, `[1, 2, 256]`.
+    pub fn sparse_none(&self) -> Result<Tensor> {
+        let mut v = self.not_a_point.clone();
+        v.extend_from_slice(&self.not_a_point);
+        Ok(Tensor::from_vec(v, (1, 2, DIM), &Device::Cpu)?)
+    }
+
+    /// The dense embedding for "no mask prompt", `[1, 256, GRID, GRID]`.
+    pub fn dense_empty(&self) -> Result<Tensor> {
+        Ok(self.no_mask.reshape((1, DIM, 1, 1))?.broadcast_as((1, DIM, GRID, GRID))?.contiguous()?)
+    }
+
+    /// The dense embedding of a mask prompt `[1, 1, 4 * GRID, 4 * GRID]` (low-resolution logits).
+    pub fn dense_mask(&self, mask: &Tensor) -> Result<Tensor> {
+        let (c1, c2, c3) = (&self.mask.conv[0], &self.mask.conv[1], &self.mask.conv[2]);
+        let step = |x: &Tensor, c: &(Tensor, Tensor, usize, usize)| -> Result<Tensor> {
+            Ok(x.conv2d(&c.0, 0, c.3, 1, 1)?.broadcast_add(&c.1.reshape((1, c.1.dim(0)?, 1, 1))?)?)
+        };
+        let cl = |x: &Tensor, ln: &LayerNorm| -> Result<Tensor> { Ok(ln.forward(&x.permute((0, 2, 3, 1))?)?.permute((0, 3, 1, 2))?.contiguous()?) };
+        let x = gelu(&cl(&step(mask, c1)?, &self.mask.ln1)?)?;
+        let x = gelu(&cl(&step(&x, c2)?, &self.mask.ln2)?)?;
+        step(&x, c3)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A tiny deterministic checkpoint exercises token labels without downloading trained weights.
+    fn encoder() -> PromptEncoder {
+        let mut map = std::collections::HashMap::new();
+        for (name, shape) in [
+            ("shared_embedding.positional_embedding", vec![2, DIM / 2]),
+            ("no_mask_embed.weight", vec![1, DIM]),
+            ("mask_embed.conv1.weight", vec![4, 1, 2, 2]),
+            ("mask_embed.conv1.bias", vec![4]),
+            ("mask_embed.conv2.weight", vec![16, 4, 2, 2]),
+            ("mask_embed.conv2.bias", vec![16]),
+            ("mask_embed.conv3.weight", vec![DIM, 16, 1, 1]),
+            ("mask_embed.conv3.bias", vec![DIM]),
+            ("mask_embed.layer_norm1.weight", vec![4]),
+            ("mask_embed.layer_norm1.bias", vec![4]),
+            ("mask_embed.layer_norm2.weight", vec![16]),
+            ("mask_embed.layer_norm2.bias", vec![16]),
+        ] {
+            map.insert(format!("prompt_encoder.{name}"), Tensor::zeros(shape, candle_core::DType::F32, &Device::Cpu).unwrap());
+        }
+        let rows: Vec<f32> = (1..=4).flat_map(|row| vec![row as f32 * 10.0; DIM]).collect();
+        map.insert("prompt_encoder.point_embed.weight".into(), Tensor::from_vec(rows, (4, DIM), &Device::Cpu).unwrap());
+        map.insert("prompt_encoder.not_a_point_embed.weight".into(), Tensor::from_vec(vec![-1000.0f32; DIM], (1, DIM), &Device::Cpu).unwrap());
+        PromptEncoder::load(&Weights::from_map(map).unwrap()).unwrap()
+    }
+
+    /// Transformers 5.19.0 pads click-only prompts in _embed_points and boxes in _embed_boxes.
+    #[test]
+    fn box_and_click_tokens_match_the_pinned_reference_padding() {
+        let encoder = encoder();
+        let points = vec![([10.0, 20.0], false), ([30.0, 40.0], true)];
+        for points in [vec![], points.clone()] {
+            let sparse = encoder.sparse(&Prompt { points: points.clone(), bbox: Some([0.0, 0.0, 100.0, 100.0]) }).unwrap();
+            assert_eq!(sparse.dims(), &[1, points.len() + 3, DIM]);
+            let rows = sparse.to_vec3::<f32>().unwrap();
+            assert!(rows[0].last().unwrap().iter().all(|value| *value == -1000.0));
+            for (token, label) in rows[0].iter().zip(if points.is_empty() { vec![30.0, 40.0] } else { vec![10.0, 20.0, 30.0, 40.0] }) {
+                assert!(token[..DIM / 2].iter().all(|value| *value == label));
+                assert!(token[DIM / 2..].iter().all(|value| *value == label + 1.0));
+            }
+        }
+        let clicks = encoder.sparse(&Prompt { points, bbox: None }).unwrap();
+        assert_eq!(clicks.dims(), &[1, 3, DIM]);
+        assert!(clicks.to_vec3::<f32>().unwrap()[0][2].iter().all(|value| *value == -1000.0));
+        let none = encoder.sparse_none().unwrap();
+        assert_eq!(none.dims(), &[1, 2, DIM]);
+        assert!(none.flatten_all().unwrap().to_vec1::<f32>().unwrap().iter().all(|value| *value == -1000.0));
+    }
+
+    #[test]
+    fn hostile_prompts_are_rejected() {
+        let ok = Prompt { points: vec![([10.0, 20.0], true)], bbox: None };
+        assert!(ok.validate().is_ok());
+        assert!(Prompt { points: vec![([f32::NAN, 0.0], true)], bbox: None }.validate().is_err());
+        assert!(Prompt { points: vec![], bbox: Some([0.0, 0.0, f32::INFINITY, 5.0]) }.validate().is_err());
+        assert!(Prompt { points: vec![([1e9, 0.0], false)], bbox: None }.validate().is_err());
+        assert!(Prompt { points: vec![([1.0, 1.0], true); 65], bbox: None }.validate().is_err());
+    }
+}
diff --git a/crates/sam2/src/resize.rs b/crates/sam2/src/resize.rs
new file mode 100644
index 000000000..fdbcbab48
--- /dev/null
+++ b/crates/sam2/src/resize.rs
@@ -0,0 +1,124 @@
+// Modified work: the antialiased bilinear resize of PyTorch `F.interpolate(mode="bilinear",
+// antialias=True, align_corners=False)`, as used by the Hugging Face `transformers` SAM 2 mask path
+// (Apache-2.0 for the model code; the algorithm follows PyTorch's documented behaviour). See NOTICE.
+//! Resizing masks to and from the model's resolution.
+
+use candle_core::{Device, Tensor};
+
+use crate::Result;
+use crate::mask::validate_frame_size;
+use crate::prompt::INPUT_SIZE;
+
+/// For each output index: the first input index and the normalised triangle-filter weights.
+fn axis_weights(n_in: usize, n_out: usize) -> Vec<(usize, Vec<f32>)> {
+    let scale = n_in as f64 / n_out.max(1) as f64;
+    let support = if scale >= 1.0 { scale } else { 1.0 };
+    let invscale = if scale >= 1.0 { 1.0 / scale } else { 1.0 };
+    (0..n_out)
+        .map(|i| {
+            let center = scale * (i as f64 + 0.5);
+            let xmin = ((center - support + 0.5) as i64).max(0) as usize;
+            let xmax = (((center + support + 0.5) as i64).max(0) as usize).min(n_in);
+            let mut w: Vec<f32> = (xmin..xmax.max(xmin))
+                .map(|x| {
+                    let d = ((x as f64 - center + 0.5) * invscale).abs();
+                    if d < 1.0 { (1.0 - d) as f32 } else { 0.0 }
+                })
+                .collect();
+            let total: f32 = w.iter().sum();
+            if total > 0.0 {
+                w.iter_mut().for_each(|v| *v /= total);
+            }
+            (xmin, w)
+        })
+        .collect()
+}
+
+/// Antialiased bilinear resize of a row-major `h x w` image to `oh x ow`.
+pub fn antialias_bilinear(src: &[f32], (h, w): (usize, usize), (oh, ow): (usize, usize)) -> Result<Vec<f32>> {
+    validate_frame_size(w, h, src.len())?;
+    let out_len = validate_frame_size(ow, oh, oh.saturating_mul(ow))?;
+    let mid_len = validate_frame_size(ow, h, h.saturating_mul(ow))?;
+    let xs = axis_weights(w, ow);
+    let ys = axis_weights(h, oh);
+    // horizontal pass: h x ow
+    let mut mid = vec![0f32; mid_len];
+    for y in 0..h {
+        let row = src.get(y * w..(y + 1) * w).unwrap_or(&[]);
+        for (x, (x0, wt)) in xs.iter().enumerate() {
+            let acc: f32 = wt.iter().enumerate().map(|(k, a)| a * row.get(x0 + k).copied().unwrap_or(0.0)).sum();
+            if let Some(o) = mid.get_mut(y * ow + x) {
+                *o = acc;
+            }
+        }
+    }
+    // vertical pass: oh x ow
+    let mut out = vec![0f32; out_len];
+    for (y, (y0, wt)) in ys.iter().enumerate() {
+        for x in 0..ow {
+            let acc: f32 = wt.iter().enumerate().map(|(k, a)| a * mid.get((y0 + k) * ow + x).copied().unwrap_or(0.0)).sum();
+            if let Some(o) = out.get_mut(y * ow + x) {
+                *o = acc;
+            }
+        }
+    }
+    Ok(out)
+}
+
+/// A binary mask of any size as the model's mask prompt: `[1, 1, 1024, 1024]` of 0 and 1 (resized
+/// like the reference: antialiased bilinear, then thresholded at one half).
+pub fn mask_to_model(mask: &[u8], w: usize, h: usize) -> Result<Tensor> {
+    validate_frame_size(w, h, mask.len())?;
+    let side = INPUT_SIZE;
+    let f: Vec<f32> = mask.iter().map(|v| f32::from(*v != 0)).collect();
+    let data = if (w, h) == (side, side) { f } else { antialias_bilinear(&f, (h, w), (side, side))?.into_iter().map(|v| f32::from(v >= 0.5)).collect() };
+    Ok(Tensor::from_vec(data, (1, 1, side, side), &Device::Cpu)?)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn resize_rejects_overflowing_oversized_and_mismatched_grids() {
+        for (input, output) in [((usize::MAX, 2), (1, 1)), ((1, 1), (usize::MAX, 2)), ((1, 1), (16_385, 1)), ((0, 1), (1, 1))] {
+            assert!(antialias_bilinear(&[1.0], input, output).is_err(), "{input:?} to {output:?}");
+        }
+        assert!(mask_to_model(&[1], usize::MAX, 2).is_err());
+        assert!(mask_to_model(&[1], INPUT_SIZE, INPUT_SIZE).is_err());
+    }
+
+    #[test]
+    fn a_constant_stays_constant_and_weights_sum_to_one() {
+        let out = antialias_bilinear(&[3.0; 64 * 64], (64, 64), (16, 16)).unwrap();
+        assert!(out.iter().all(|v| (v - 3.0).abs() < 1e-5));
+        let up = antialias_bilinear(&[2.0; 16], (4, 4), (9, 7)).unwrap();
+        assert!(up.iter().all(|v| (v - 2.0).abs() < 1e-5));
+    }
+
+    #[test]
+    fn a_half_plane_blurs_over_the_filter_width() {
+        // 8 x 1: left half 0, right half 1, down to 2 x 1. The triangle filter is four pixels wide on
+        // each side, so the first output sees the ones at weights 0.375 and 0.125 of a total 3.5.
+        let src = [0., 0., 0., 0., 1., 1., 1., 1.];
+        let out = antialias_bilinear(&src, (1, 8), (1, 2)).unwrap();
+        assert!((out[0] - 0.5 / 3.5).abs() < 1e-6 && (out[1] - 3.0 / 3.5).abs() < 1e-6, "{out:?}");
+    }
+
+    #[test]
+    fn hostile_sizes_are_errors() {
+        assert!(antialias_bilinear(&[1.0; 4], (2, 2), (0, 3)).is_err());
+        assert!(antialias_bilinear(&[1.0; 5], (2, 2), (1, 1)).is_err());
+        assert!(mask_to_model(&[1; 3], 2, 2).is_err());
+        assert!(mask_to_model(&[], 0, 0).is_err());
+    }
+
+    #[test]
+    fn a_small_mask_becomes_a_model_sized_binary_mask() {
+        let m = mask_to_model(&[0, 1, 1, 0], 2, 2).unwrap();
+        assert_eq!(m.dims(), [1, 1, INPUT_SIZE, INPUT_SIZE]);
+        let v = m.flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        assert!(v.iter().all(|x| *x == 0.0 || *x == 1.0));
+        assert!(v.iter().sum::<f32>() > 0.0);
+    }
+}
diff --git a/crates/sam2/src/session.rs b/crates/sam2/src/session.rs
new file mode 100644
index 000000000..0524ee89e
--- /dev/null
+++ b/crates/sam2/src/session.rs
@@ -0,0 +1,733 @@
+// Modified work: ported from Hugging Face `transformers` `models/sam2_video/modeling_sam2_video.py`
+// (Sam2VideoModel and Sam2VideoInferenceSession: memory-conditioned single-frame inference,
+// memory bank selection, object pointers, propagation; Apache-2.0, Copyright The HuggingFace
+// Inc. team) to Rust on candle. See NOTICE.
+//! The video tracker: per-object memory banks, prompts on any frame, propagation forwards and
+//! backwards with streaming results and cancellation.
+
+use std::collections::{BTreeMap, VecDeque};
+use std::path::Path;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use candle_core::{DType, Tensor};
+use candle_nn::{Linear, ops::sigmoid};
+
+use crate::decoder::FeedForward;
+use crate::gpu::Gpu;
+use crate::gpu::encoder::GpuEncoder;
+use crate::gpu::memattn::GpuMemoryAttention;
+use crate::gpu::memenc::GpuMemoryEncoder;
+use crate::memattn::MemoryAttention;
+use crate::memory::{Memory, MemoryEncoder};
+use crate::model::{Encoded, ImageModel};
+use crate::neck::ImageFeatures;
+use crate::nn::{apply, linear};
+use crate::prompt::{INPUT_SIZE, Prompt};
+use crate::resize::antialias_bilinear;
+use crate::weights::Weights;
+use crate::{Error, Result};
+
+/// Mask logit used where the object is absent (the reference's `NO_OBJ_SCORE`).
+const NO_OBJECT: f32 = -1024.0;
+/// Frames of memory the attention looks back over.
+const MEMORY_FRAMES: usize = 7;
+/// Object pointers kept per query.
+const MAX_POINTERS: usize = 16;
+/// Largest clip the session accepts.
+const MAX_FRAMES: usize = 1_000_000;
+const GRID: usize = 64;
+
+/// Frames of the clip, already resized to the model input and normalised: `[1, 3, 1024, 1024]`.
+pub trait FrameSource {
+    fn num_frames(&self) -> usize;
+    fn frame(&self, index: usize) -> Result<Tensor>;
+}
+
+/// Cooperative cancellation shared with the caller.
+#[derive(Clone, Default)]
+pub struct Cancel(Arc<AtomicBool>);
+
+impl Cancel {
+    pub fn new() -> Cancel {
+        Cancel::default()
+    }
+    pub fn cancel(&self) {
+        self.0.store(true, Ordering::Relaxed);
+    }
+    pub fn is_cancelled(&self) -> bool {
+        self.0.load(Ordering::Relaxed)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ObjectId(pub u32);
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Direction {
+    Forward,
+    Backward,
+}
+
+/// One object's mask on one frame.
+#[derive(Clone, Debug, PartialEq)]
+pub struct FrameMask {
+    pub frame: usize,
+    pub object: ObjectId,
+    /// Mask logits at 256 x 256 (positive is inside the object); `-1024` everywhere when the
+    /// object is absent.
+    pub logits: Vec<f32>,
+    /// The model's own estimate of the mask quality (0..1).
+    pub iou: f32,
+    /// Object-presence logit; at or below zero the object is not in the frame.
+    pub object_score: f32,
+    pub occluded: bool,
+}
+
+/// Which device runs the heavy parts (the backbone, the neck and the memory attention).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Backend {
+    /// Candle on the CPU: the reference path.
+    Cpu,
+    /// wgpu compute on the GPU (any vendor); an error if there is none.
+    Gpu,
+    /// The GPU when there is a real one and it loads, else the CPU. The environment variable
+    /// `EFFECTCRAFT_SAM2_DEVICE` (`cpu`, `gpu` or `auto`) overrides the choice.
+    Auto,
+}
+
+/// The GPU path: kernels for the backbone and memory attention. Device failures disable it;
+/// memory-attention budget limits fall back to the CPU for that call only.
+struct GpuParts {
+    encoder: GpuEncoder,
+    attention: GpuMemoryAttention,
+    memory_encoder: GpuMemoryEncoder,
+    ok: AtomicBool,
+    adapter: String,
+}
+
+/// The weights of everything the video tracker needs.
+pub struct VideoModel {
+    gpu: Option<GpuParts>,
+    pub image: ImageModel,
+    memory_encoder: MemoryEncoder,
+    memory_attention: MemoryAttention,
+    temporal_pos: Vec<f32>,
+    no_object_pointer: Tensor,
+    pointer_proj: FeedForward,
+    pointer_time_proj: Linear,
+    /// `mask_downsample`: a 4 x 4 stride-4 convolution taking a mask prompt to the prompt encoder's resolution.
+    mask_down: (Tensor, Tensor),
+}
+
+impl VideoModel {
+    /// On the CPU: the reference path every test compares against.
+    pub fn load(w: &Weights) -> Result<VideoModel> {
+        VideoModel::load_with(w, Backend::Cpu)
+    }
+
+    /// On the GPU when there is one (see [`Backend::Auto`]).
+    pub fn load_auto(w: &Weights) -> Result<VideoModel> {
+        VideoModel::load_with(w, Backend::Auto)
+    }
+
+    pub fn load_with(w: &Weights, backend: Backend) -> Result<VideoModel> {
+        let backend = match (backend, std::env::var("EFFECTCRAFT_SAM2_DEVICE").ok().as_deref()) {
+            (Backend::Auto, Some("cpu")) => Backend::Cpu,
+            (Backend::Auto, Some("gpu")) => Backend::Gpu,
+            (b, _) => b,
+        };
+        let image = ImageModel::load(w)?;
+        let gpu = match backend {
+            Backend::Cpu => None,
+            Backend::Gpu => Some(Self::load_gpu(w, &image)?),
+            Backend::Auto => match Self::load_gpu(w, &image) {
+                Ok(g) => Some(g),
+                Err(e) => {
+                    log::info!("SAM 2 runs on the CPU: {e}");
+                    None
+                }
+            },
+        };
+        Ok(VideoModel {
+            gpu,
+            image,
+            memory_encoder: MemoryEncoder::load(w)?,
+            memory_attention: MemoryAttention::load(w)?,
+            temporal_pos: w.get("memory_temporal_positional_encoding", &[MEMORY_FRAMES, 1, 1, 64])?.flatten_all()?.to_vec1::<f32>()?,
+            no_object_pointer: w.get("no_object_pointer", &[1, 256])?,
+            pointer_proj: FeedForward::load(w, "object_pointer_proj", 256, 256, 256, 3, false)?,
+            pointer_time_proj: linear(w, "temporal_positional_encoding_projection_layer", 256, 64)?,
+            mask_down: (w.get("mask_downsample.weight", &[1, 1, 4, 4])?, w.get("mask_downsample.bias", &[1])?),
+        })
+    }
+
+    fn load_gpu(w: &Weights, image: &ImageModel) -> Result<GpuParts> {
+        let gpu = Gpu::shared()?;
+        Ok(GpuParts {
+            encoder: GpuEncoder::load(gpu.clone(), w, image.vision.hiera.clone())?,
+            attention: GpuMemoryAttention::load(gpu.clone(), w)?,
+            memory_encoder: GpuMemoryEncoder::load(gpu.clone(), w)?,
+            ok: AtomicBool::new(true),
+            adapter: gpu.adapter_name().to_string(),
+        })
+    }
+
+    /// The device the heavy parts run on now: the GPU's name, or "CPU".
+    pub fn device_name(&self) -> String {
+        match &self.gpu {
+            Some(g) if g.ok.load(Ordering::Relaxed) => g.adapter.clone(),
+            _ => "CPU".to_string(),
+        }
+    }
+
+    /// Run on the CPU from now on (a GPU that misbehaves, or the user's choice). Weights and results are
+    /// unchanged; only the device differs.
+    pub fn disable_gpu(&self) {
+        if let Some(g) = &self.gpu {
+            g.ok.store(false, Ordering::Relaxed);
+        }
+    }
+
+    fn gpu_failed(&self, what: &str, e: &Error) {
+        if let Some(g) = &self.gpu
+            && g.ok.swap(false, Ordering::Relaxed)
+        {
+            log::warn!("SAM 2 {what} failed on the GPU ({e}); the CPU takes over");
+        }
+    }
+
+    /// Encode a normalised `[1, 3, 1024, 1024]` frame on the GPU if it is working, else on the CPU.
+    pub fn encode(&self, pixels: &Tensor) -> Result<Encoded> {
+        if let Some(g) = self.gpu.as_ref().filter(|g| g.ok.load(Ordering::Relaxed)) {
+            match g.encoder.encode(pixels) {
+                Ok(f) => {
+                    let none = || Tensor::zeros((1, 0, 0, 0), DType::F32, &candle_core::Device::Cpu);
+                    let pos = self.image.vision.neck.position(GRID, GRID)?;
+                    let features = ImageFeatures { features: vec![none()?, none()?, f.low], positions: vec![none()?, none()?, pos] };
+                    return Ok(Encoded { features, high: f.high });
+                }
+                Err(e) => self.gpu_failed("encoding", &e),
+            }
+        }
+        self.image.encode(pixels)
+    }
+
+    /// The memory of a frame (its features and the scaled mask), on the GPU if it is working, else on the CPU.
+    fn memorize(&self, features: &Tensor, mask: &Tensor, present: bool) -> Result<Memory> {
+        if let Some(g) = self.gpu.as_ref().filter(|g| g.ok.load(Ordering::Relaxed)) {
+            match g.memory_encoder.encode(features, mask).and_then(|t| self.memory_encoder.finish(&t, present)) {
+                Ok(m) => return Ok(m),
+                Err(e) => self.gpu_failed("memory encoding", &e),
+            }
+        }
+        self.memory_encoder.memory(features, mask, present)
+    }
+
+    /// Memory attention on the GPU if it is working, else on the CPU.
+    fn attend(&self, current: &Tensor, current_pos: &Tensor, memory: &Tensor, memory_pos: &Tensor, pointers: usize) -> Result<Tensor> {
+        if let Some(g) = self.gpu.as_ref().filter(|g| g.ok.load(Ordering::Relaxed)) {
+            match g.attention.forward(current, current_pos, memory, memory_pos, pointers) {
+                Ok(t) => return Ok(t),
+                Err(Error::Budget(reason)) => log::info!("SAM 2 memory attention on the CPU for this call: {reason}"),
+                Err(e) => self.gpu_failed("memory attention", &e),
+            }
+        }
+        self.memory_attention.forward(current, current_pos, memory, memory_pos, pointers)
+    }
+
+    pub fn open(path: &Path) -> Result<VideoModel> {
+        VideoModel::load(&Weights::open(path)?)
+    }
+}
+
+/// What the tracker keeps for a frame it has processed.
+struct FrameOut {
+    memory: Memory,
+    /// `[1, 256]`
+    pointer: Tensor,
+    /// The mask of a conditioning frame (returned again, unchanged, when propagation passes it).
+    result: Option<FrameMask>,
+}
+
+#[derive(Default)]
+struct ObjectState {
+    cond: BTreeMap<usize, FrameOut>,
+    non_cond: BTreeMap<usize, FrameOut>,
+}
+
+struct FrameFeatures {
+    /// Lowest-resolution level `[1, 256, 64, 64]` and its position encoding.
+    low: Tensor,
+    pos: Tensor,
+    high: (Tensor, Tensor),
+}
+
+/// What a tracker may hold and take. A call that would exceed it stops with [`Error::Budget`].
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Budget {
+    /// Memory banks, results and cached frame features (bytes).
+    pub max_state_bytes: usize,
+    /// Wall-clock seconds one `propagate` call may take (`None`: no limit).
+    pub max_seconds: Option<f64>,
+}
+
+impl Default for Budget {
+    fn default() -> Budget {
+        Budget { max_state_bytes: 2 << 30, max_seconds: None }
+    }
+}
+
+/// Bytes of one stored frame: memory features and position encoding `[4096, 64]`, the pointer.
+const FRAME_BYTES: usize = 2 * GRID * GRID * 64 * 4 + 256 * 4;
+/// Bytes of a conditioning frame's kept result (`256 x 256` logits).
+const RESULT_BYTES: usize = 4 * GRID * 4 * GRID * 4;
+/// Bytes of one frame's cached neck features (lowest level and position, two skip levels).
+const FEATURE_BYTES: usize = (2 * 256 * GRID * GRID + 32 * 16 * GRID * GRID + 64 * 4 * GRID * GRID) * 4;
+
+pub struct VideoTracker<'a> {
+    model: Arc<VideoModel>,
+    frames: Box<dyn FrameSource + 'a>,
+    objects: BTreeMap<ObjectId, ObjectState>,
+    cache: VecDeque<(usize, Arc<FrameFeatures>)>,
+    budget: Budget,
+    peak: usize,
+}
+
+fn sine_embedding_1d(positions: &[f32], dim: usize) -> Result<Tensor> {
+    let half = dim / 2;
+    let dim_t: Vec<f32> = (0..half).map(|i| 10000f32.powf(2.0 * (i / 2) as f32 / half as f32)).collect();
+    let mut out = Vec::with_capacity(positions.len() * dim);
+    for p in positions {
+        out.extend(dim_t.iter().map(|d| (p / d).sin()));
+        out.extend(dim_t.iter().map(|d| (p / d).cos()));
+    }
+    Ok(Tensor::from_vec(out, (positions.len(), dim), &candle_core::Device::Cpu)?)
+}
+
+fn scalar(t: &Tensor) -> Result<f32> {
+    Ok(t.flatten_all()?.to_vec1::<f32>()?.first().copied().unwrap_or(0.0))
+}
+
+impl<'a> VideoTracker<'a> {
+    pub fn new(model: Arc<VideoModel>, frames: Box<dyn FrameSource + 'a>) -> Result<VideoTracker<'a>> {
+        let n = frames.num_frames();
+        if n == 0 || n > MAX_FRAMES {
+            return Err(Error::Input(format!("a clip needs between 1 and {MAX_FRAMES} frames, got {n}")));
+        }
+        Ok(VideoTracker { model, frames, objects: BTreeMap::new(), cache: VecDeque::new(), budget: Budget::default(), peak: 0 })
+    }
+
+    pub fn num_frames(&self) -> usize {
+        self.frames.num_frames()
+    }
+
+    /// Replace the limits (see [`Budget`]).
+    pub fn set_budget(&mut self, budget: Budget) {
+        self.budget = budget;
+    }
+
+    /// Bytes held now: stored frames, kept results and cached features.
+    pub fn state_bytes(&self) -> usize {
+        let frames: usize = self.objects.values().map(|o| (o.cond.len() + o.non_cond.len()) * FRAME_BYTES + o.cond.len() * RESULT_BYTES).sum();
+        frames + self.cache.len() * FEATURE_BYTES
+    }
+
+    /// The most [`VideoTracker::state_bytes`] reached so far.
+    pub fn peak_state_bytes(&self) -> usize {
+        self.peak
+    }
+
+    fn check_budget(&mut self) -> Result<()> {
+        let used = self.state_bytes();
+        self.peak = self.peak.max(used);
+        if used > self.budget.max_state_bytes {
+            return Err(Error::Budget(format!("the tracker holds {} MB, over its {} MB limit", used >> 20, self.budget.max_state_bytes >> 20)));
+        }
+        Ok(())
+    }
+
+    /// Forget every object and cached frame (the clip stays).
+    pub fn reset(&mut self) {
+        self.objects.clear();
+        self.cache.clear();
+    }
+
+    fn features(&mut self, frame: usize) -> Result<Arc<FrameFeatures>> {
+        if let Some((_, f)) = self.cache.iter().find(|(i, _)| *i == frame) {
+            return Ok(f.clone());
+        }
+        let pixels = self.frames.frame(frame)?;
+        let enc = self.model.encode(&pixels)?;
+        let (low, pos) = match (enc.features.features.get(2), enc.features.positions.get(2)) {
+            (Some(l), Some(p)) => (l.clone(), p.clone()),
+            _ => return Err(Error::Compute("vision encoder returned too few levels".into())),
+        };
+        let f = Arc::new(FrameFeatures { low, pos, high: enc.high });
+        self.cache.push_back((frame, f.clone()));
+        while self.cache.len() > 2 {
+            self.cache.pop_front();
+        }
+        Ok(f)
+    }
+
+    /// The memory bank for `frame`: memory frames and object pointers with their position
+    /// encodings, plus how many trailing tokens are pointers.
+    fn memory_bank(&self, obj: &ObjectState, frame: usize, reverse: bool) -> Result<(Tensor, Tensor, usize)> {
+        let (mut feats, mut poss) = (vec![], vec![]);
+        let temporal = |off: usize| -> Result<Tensor> {
+            // The reference indexes with `offset - 1`, so the conditioning frames (offset 0) use the last row.
+            let row = if off == 0 { MEMORY_FRAMES - 1 } else { off - 1 };
+            let v = self.model.temporal_pos.get(row * 64..(row + 1) * 64).ok_or_else(|| Error::Weights("temporal position table".into()))?;
+            Ok(Tensor::from_slice(v, (1, 64), &candle_core::Device::Cpu)?)
+        };
+        for out in obj.cond.values() {
+            feats.push(out.memory.features.clone());
+            poss.push(out.memory.pos.broadcast_add(&temporal(0)?)?);
+        }
+        for off in (1..MEMORY_FRAMES).rev() {
+            let prev = if reverse { frame.checked_add(off) } else { frame.checked_sub(off) };
+            if let Some(out) = prev.and_then(|p| obj.non_cond.get(&p)) {
+                feats.push(out.memory.features.clone());
+                poss.push(out.memory.pos.broadcast_add(&temporal(off)?)?);
+            }
+        }
+        // Object pointers: conditioning frames on the already-tracked side, then recent frames.
+        let n_frames = self.frames.num_frames();
+        let max_ptrs = n_frames.min(MAX_POINTERS);
+        let (mut offsets, mut pointers): (Vec<f32>, Vec<Tensor>) = (vec![], vec![]);
+        let sign = if reverse { -1.0f32 } else { 1.0 };
+        for (t, out) in &obj.cond {
+            if if reverse { *t >= frame } else { *t <= frame } {
+                offsets.push((frame as f32 - *t as f32) * sign);
+                pointers.push(out.pointer.clone());
+            }
+        }
+        for off in 1..max_ptrs {
+            let r = if reverse { frame.checked_add(off) } else { frame.checked_sub(off) };
+            let Some(r) = r.filter(|r| *r < n_frames) else { break };
+            if let Some(out) = obj.non_cond.get(&r) {
+                offsets.push(off as f32);
+                pointers.push(out.pointer.clone());
+            }
+        }
+        let mut n_pointer_tokens = 0;
+        if !pointers.is_empty() {
+            let max_diff = (max_ptrs.saturating_sub(1)).max(1) as f32;
+            let norm: Vec<f32> = offsets.iter().map(|o| o / max_diff).collect();
+            let pe = apply(&self.model.pointer_time_proj, &sine_embedding_1d(&norm, 256)?)?;
+            let ptrs = Tensor::cat(&pointers, 0)?; // [P, 256]
+            let p = ptrs.dim(0)?;
+            let tokens = ptrs.reshape((p * 4, 64))?;
+            let pe = pe.unsqueeze(1)?.broadcast_as((p, 4, 64))?.reshape((p * 4, 64))?;
+            n_pointer_tokens = p * 4;
+            feats.push(tokens);
+            poss.push(pe.contiguous()?);
+        }
+        if feats.is_empty() {
+            return Err(Error::Input("the object has no conditioning frame; add a prompt first".into()));
+        }
+        Ok((Tensor::cat(&feats, 0)?, Tensor::cat(&poss, 0)?, n_pointer_tokens))
+    }
+
+    /// Run the model on one frame for one object and store the result.
+    fn step(&mut self, id: ObjectId, frame: usize, prompt: Option<&Prompt>, reverse: bool, conditioning: bool) -> Result<FrameMask> {
+        // EFFECTCRAFT_SAM2_PROFILE=1 prints where a frame's time goes (stderr).
+        let profile = std::env::var_os("EFFECTCRAFT_SAM2_PROFILE").is_some();
+        let mut lap = std::time::Instant::now();
+        let mut mark = |what: &str| {
+            if profile {
+                eprintln!("sam2 frame {frame}: {what} {:.0} ms", lap.elapsed().as_secs_f64() * 1e3);
+            }
+            lap = std::time::Instant::now();
+        };
+        let feats = self.features(frame)?;
+        mark("encode");
+        let model = self.model.clone();
+        let tokens = |t: &Tensor| -> Result<Tensor> { Ok(t.flatten_from(2)?.squeeze(0)?.t()?.contiguous()?) };
+        let conditioned = if conditioning {
+            feats.low.broadcast_add(model.image.no_memory())?
+        } else {
+            let obj = self.objects.get(&id).ok_or_else(|| Error::Input("unknown object".into()))?;
+            let (mem, mem_pos, n_ptr) = self.memory_bank(obj, frame, reverse)?;
+            let out = model.attend(&tokens(&feats.low)?, &tokens(&feats.pos)?, &mem, &mem_pos, n_ptr)?;
+            out.t()?.contiguous()?.reshape((1, 256, GRID, GRID))?
+        };
+        mark("memory attention");
+        let num_points = prompt.map_or(0, |p| p.points.len() + 2 * usize::from(p.bbox.is_some()));
+        let multimask = num_points <= 1;
+        let sparse = match prompt {
+            Some(p) => model.image.prompt.sparse(p)?,
+            None => model.image.prompt.sparse_none()?,
+        };
+        let dense = model.image.prompt.dense_empty()?;
+        let out = model.image.decode_embedded(&conditioned, &feats.high, &sparse, &dense, multimask)?;
+
+        mark("decoder");
+        let score = scalar(&out.object_score)?;
+        let present = score > 0.0;
+        let ious = out.iou.flatten_all()?.to_vec1::<f32>()?;
+        let best = if multimask { ious.iter().enumerate().fold((0usize, f32::NEG_INFINITY), |b, (i, v)| if *v > b.1 { (i, *v) } else { b }).0 } else { 0 };
+        let low = out.masks.narrow(1, best, 1)?;
+        let low = if present { low } else { Tensor::full(NO_OBJECT, low.dims(), low.device())? };
+        let token = if multimask { out.sam_tokens.narrow(1, best, 1)? } else { out.sam_tokens.narrow(1, 0, 1)? }.squeeze(1)?;
+        let pointer = if present { model.pointer_proj.forward(&token)? } else { model.no_object_pointer.clone() };
+
+        let high = low.upsample_bilinear2d(INPUT_SIZE, INPUT_SIZE, false)?;
+        let for_memory = if prompt.is_some() { high.gt(0f32)?.to_dtype(DType::F32)? } else { sigmoid(&high)? };
+        let for_memory = ((for_memory * 20.0)? - 10.0)?;
+        mark("upsample and mask");
+        let memory = model.memorize(&feats.low, &for_memory, present)?;
+        mark("memory encoder");
+
+        let iou = ious.get(best).copied().unwrap_or(0.0);
+        let result = FrameMask { frame, object: id, logits: low.flatten_all()?.to_vec1::<f32>()?, iou, object_score: score, occluded: !present };
+        let state = self.objects.entry(id).or_default();
+        let entry = FrameOut { memory, pointer, result: conditioning.then(|| result.clone()) };
+        if conditioning {
+            state.non_cond.remove(&frame);
+            state.cond.insert(frame, entry);
+        } else {
+            state.non_cond.insert(frame, entry);
+            Self::prune(state, frame);
+        }
+        self.check_budget()?;
+        Ok(result)
+    }
+
+    /// Drop memories that no later frame in either direction can still look at.
+    fn prune(state: &mut ObjectState, frame: usize) {
+        let keep = |f: usize, cond: &BTreeMap<usize, FrameOut>| f.abs_diff(frame) <= MAX_POINTERS || cond.keys().any(|c| f.abs_diff(*c) <= MEMORY_FRAMES);
+        let doomed: Vec<usize> = state.non_cond.keys().copied().filter(|f| !keep(*f, &state.cond)).collect();
+        for f in doomed {
+            state.non_cond.remove(&f);
+        }
+    }
+
+    fn check_frame(&self, frame: usize) -> Result<()> {
+        if frame >= self.frames.num_frames() {
+            return Err(Error::Input(format!("frame {frame} is outside the clip of {} frames", self.frames.num_frames())));
+        }
+        Ok(())
+    }
+
+    /// Prompt an object on a frame (clicks and/or a box). The frame becomes one of the object's
+    /// conditioning frames when it has not been tracked yet; the mask comes back at once.
+    pub fn prompt(&mut self, frame: usize, object: ObjectId, prompt: &Prompt) -> Result<FrameMask> {
+        self.check_frame(frame)?;
+        prompt.validate()?;
+        if prompt.points.is_empty() && prompt.bbox.is_none() {
+            return Err(Error::Input("a prompt needs at least one point or a box".into()));
+        }
+        let tracked = self.objects.get(&object).is_some_and(|o| o.non_cond.contains_key(&frame));
+        if tracked {
+            // A correction on a tracked frame is conditioned on the memory like any tracked frame.
+            let reverse = false;
+            return self.step(object, frame, Some(prompt), reverse, false);
+        }
+        self.objects.entry(object).or_default();
+        self.step(object, frame, Some(prompt), false, true)
+    }
+
+    /// Prompt an object on a frame with a mask: `[1, 1, 1024, 1024]` of 0 and 1 (see
+    /// [`crate::resize::mask_to_model`]). The mask becomes the frame's output as it is (no decode of
+    /// the mask itself); the decoder only makes the object pointer. Like a click prompt, the frame is a
+    /// conditioning frame unless it has been tracked already.
+    pub fn prompt_mask(&mut self, frame: usize, object: ObjectId, mask: &Tensor) -> Result<FrameMask> {
+        self.check_frame(frame)?;
+        if mask.dims() != [1, 1, INPUT_SIZE, INPUT_SIZE] {
+            return Err(Error::Input(format!("a mask prompt must be [1, 1, {INPUT_SIZE}, {INPUT_SIZE}], got {:?}", mask.dims())));
+        }
+        let values = mask.flatten_all()?.to_vec1::<f32>()?;
+        if values.iter().any(|v| !v.is_finite()) {
+            return Err(Error::Input("a mask prompt must be finite".into()));
+        }
+        let tracked = self.objects.get(&object).is_some_and(|o| o.non_cond.contains_key(&frame));
+        self.objects.entry(object).or_default();
+        self.step_mask(object, frame, mask, &values, !tracked)
+    }
+
+    /// The reference's `_use_mask_as_output`: the mask is the output, the decoder makes the pointer.
+    fn step_mask(&mut self, id: ObjectId, frame: usize, mask: &Tensor, values: &[f32], conditioning: bool) -> Result<FrameMask> {
+        let feats = self.features(frame)?;
+        let model = self.model.clone();
+        let present = values.iter().any(|v| *v > 0.0);
+        let high = ((mask * 20.0)? - 10.0)?;
+        let low = antialias_bilinear(&high.flatten_all()?.to_vec1::<f32>()?, (INPUT_SIZE, INPUT_SIZE), (4 * GRID, 4 * GRID))?;
+        // The pointer: the decoder with the mask as its dense prompt and no clicks, on the frame's features
+        // without the no-memory embedding.
+        let down = mask.conv2d(&model.mask_down.0, 0, 4, 1, 1)?.broadcast_add(&model.mask_down.1.reshape((1, 1, 1, 1))?)?;
+        let dense = model.image.prompt.dense_mask(&down)?;
+        let out = model.image.decode_embedded(&feats.low, &feats.high, &model.image.prompt.sparse_none()?, &dense, true)?;
+        let ious = out.iou.flatten_all()?.to_vec1::<f32>()?;
+        let best = ious.iter().enumerate().fold((0usize, f32::NEG_INFINITY), |b, (i, v)| if *v > b.1 { (i, *v) } else { b }).0;
+        let token = out.sam_tokens.narrow(1, best, 1)?.squeeze(1)?;
+        let decoder_present = scalar(&out.object_score)? > 0.0;
+        let pointer = if decoder_present { model.pointer_proj.forward(&token)? } else { model.no_object_pointer.clone() };
+        let pointer = if present { pointer } else { model.no_object_pointer.clone() };
+        let memory = model.memorize(&feats.low, &high, present)?;
+        let score = if present { 10.0 } else { -10.0 };
+        let result = FrameMask { frame, object: id, logits: low, iou: 1.0, object_score: score, occluded: !present };
+        let state = self.objects.entry(id).or_default();
+        let entry = FrameOut { memory, pointer, result: conditioning.then(|| result.clone()) };
+        if conditioning {
+            state.non_cond.remove(&frame);
+            state.cond.insert(frame, entry);
+        } else {
+            state.non_cond.insert(frame, entry);
+            Self::prune(state, frame);
+        }
+        self.check_budget()?;
+        Ok(result)
+    }
+
+    /// Track every object from `start` through `max_frames` frames (the rest of the clip when
+    /// `None`) in `direction`, calling `out` for each object on each frame as it is finished.
+    pub fn propagate(&mut self, start: usize, direction: Direction, max_frames: Option<usize>, cancel: &Cancel, out: &mut dyn FnMut(FrameMask)) -> Result<()> {
+        self.propagate_objects(None, start, direction, max_frames, cancel, out)
+    }
+
+    /// [`VideoTracker::propagate`] for the listed objects only (`None`: every prompted object).
+    pub fn propagate_objects(
+        &mut self,
+        only: Option<&[ObjectId]>,
+        start: usize,
+        direction: Direction,
+        max_frames: Option<usize>,
+        cancel: &Cancel,
+        out: &mut dyn FnMut(FrameMask),
+    ) -> Result<()> {
+        self.check_frame(start)?;
+        let n = self.frames.num_frames();
+        let reverse = direction == Direction::Backward;
+        let span = max_frames.unwrap_or(n).min(n);
+        let ids: Vec<ObjectId> = self.objects.iter().filter(|(id, o)| !o.cond.is_empty() && only.is_none_or(|l| l.contains(id))).map(|(id, _)| *id).collect();
+        if ids.is_empty() {
+            return Err(Error::Input("no object has been prompted".into()));
+        }
+        let started = std::time::Instant::now();
+        for k in 0..=span {
+            let frame = if reverse { start.checked_sub(k) } else { Some(start + k).filter(|f| *f < n) };
+            let Some(frame) = frame else { break };
+            for id in &ids {
+                if cancel.is_cancelled() {
+                    return Err(Error::Cancelled);
+                }
+                if let Some(limit) = self.budget.max_seconds.filter(|l| started.elapsed().as_secs_f64() > *l) {
+                    return Err(Error::Budget(format!("tracking took more than {limit} s")));
+                }
+                let mask = self.mask_at(*id, frame, reverse)?;
+                out(mask);
+            }
+        }
+        Ok(())
+    }
+
+    /// Object `id` on `frame`: the result stored with its prompt there, else the tracker's step.
+    fn mask_at(&mut self, id: ObjectId, frame: usize, reverse: bool) -> Result<FrameMask> {
+        let stored = self.objects.get(&id).and_then(|o| o.cond.get(&frame)).and_then(|o| o.result.clone());
+        match stored {
+            Some(m) => Ok(m),
+            None => self.step(id, frame, None, reverse, false),
+        }
+    }
+
+    /// Track every listed object from its own prompted frame (`starts`: object, frame) in one pass
+    /// in `direction`, frame by frame with all the objects that have started: a frame is finished
+    /// for all of them before the next begins, so a caller that assembles the objects of a frame
+    /// does not hold frames waiting for a pass that has not got there. A backward pass leaves out
+    /// each object's own start frame (the forward pass reported it).
+    pub fn propagate_each(&mut self, starts: &[(ObjectId, usize)], direction: Direction, cancel: &Cancel, out: &mut dyn FnMut(FrameMask)) -> Result<()> {
+        let n = self.frames.num_frames();
+        for (id, start) in starts {
+            self.check_frame(*start)?;
+            if self.objects.get(id).is_none_or(|o| o.cond.is_empty()) {
+                return Err(Error::Input("no object has been prompted".into()));
+            }
+        }
+        if starts.is_empty() {
+            return Err(Error::Input("no object has been prompted".into()));
+        }
+        let reverse = direction == Direction::Backward;
+        let started = std::time::Instant::now();
+        for (id, frame) in pass_order(starts, n, reverse) {
+            if cancel.is_cancelled() {
+                return Err(Error::Cancelled);
+            }
+            if let Some(limit) = self.budget.max_seconds.filter(|l| started.elapsed().as_secs_f64() > *l) {
+                return Err(Error::Budget(format!("tracking took more than {limit} s")));
+            }
+            let mask = self.mask_at(id, frame, reverse)?;
+            out(mask);
+        }
+        Ok(())
+    }
+}
+
+/// The (object, frame) steps of [`VideoTracker::propagate_each`], in order: frame by frame from the
+/// first start (the last, backwards), each frame for the objects whose pass has reached it.
+fn pass_order(starts: &[(ObjectId, usize)], frames: usize, reverse: bool) -> impl Iterator<Item = (ObjectId, usize)> + '_ {
+    let first = if reverse { starts.iter().map(|s| s.1).max() } else { starts.iter().map(|s| s.1).min() };
+    let span = match first {
+        Some(f) if reverse => f + 1,
+        Some(f) => frames.saturating_sub(f),
+        None => 0,
+    };
+    (0..span).flat_map(move |k| {
+        let frame = if reverse { first.unwrap_or(0).saturating_sub(k) } else { first.unwrap_or(0) + k };
+        starts.iter().filter_map(move |(id, start)| {
+            let reached = if reverse { *start > frame } else { *start <= frame };
+            reached.then_some((*id, frame))
+        })
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn order(starts: &[(u32, usize)], frames: usize, reverse: bool) -> Vec<(u32, usize)> {
+        let starts: Vec<(ObjectId, usize)> = starts.iter().map(|(o, s)| (ObjectId(*o), *s)).collect();
+        pass_order(&starts, frames, reverse).map(|(o, f)| (o.0, f)).collect()
+    }
+
+    /// Forward, every frame is finished for all the objects that have started before the next frame
+    /// begins; an object joins the pass at its own start frame.
+    #[test]
+    fn the_forward_pass_goes_frame_by_frame_over_the_objects_that_have_started() {
+        assert_eq!(order(&[(1, 0), (2, 3)], 6, false), [(1, 0), (1, 1), (1, 2), (1, 3), (2, 3), (1, 4), (2, 4), (1, 5), (2, 5)]);
+        // Prompts on the same frame go together; the pass starts at the earliest start.
+        assert_eq!(order(&[(1, 2), (2, 2)], 4, false), [(1, 2), (2, 2), (1, 3), (2, 3)]);
+        assert_eq!(order(&[(1, 2)], 4, false), [(1, 2), (1, 3)]);
+    }
+
+    /// Backward, from the last start down to frame 0, leaving out each object's own start frame.
+    #[test]
+    fn the_backward_pass_goes_frame_by_frame_and_skips_each_objects_own_start() {
+        assert_eq!(order(&[(1, 0), (2, 3)], 6, true), [(2, 2), (2, 1), (2, 0)]);
+        assert_eq!(order(&[(1, 2), (2, 3)], 6, true), [(2, 2), (1, 1), (2, 1), (1, 0), (2, 0)]);
+        assert!(order(&[(1, 0)], 6, true).is_empty(), "nothing before frame 0");
+    }
+
+    /// A frame is finished for every object before the next begins, however far apart the prompts
+    /// are: the number of frames waiting for an object never grows with the clip.
+    #[test]
+    fn no_frame_waits_for_an_object_that_has_not_reached_it() {
+        let steps = order(&[(1, 0), (2, 1000)], 2000, false);
+        let mut waiting = 0usize;
+        let mut worst = 0usize;
+        let mut seen = std::collections::BTreeMap::<usize, usize>::new();
+        for (_, f) in steps {
+            let n = seen.entry(f).or_default();
+            *n += 1;
+            // From frame 1000 on, both objects report each frame back to back.
+            if f >= 1000 && *n == 2 {
+                waiting -= 1;
+            } else if f >= 1000 {
+                waiting += 1;
+            }
+            worst = worst.max(waiting);
+        }
+        assert!(worst <= 1, "{worst} frames waiting");
+    }
+}
diff --git a/crates/sam2/src/track.rs b/crates/sam2/src/track.rs
new file mode 100644
index 000000000..7e73a1c74
--- /dev/null
+++ b/crates/sam2/src/track.rs
@@ -0,0 +1,181 @@
+// Modified work: adapts the ported SAM 2 video tracker to EffectCraft's `ObjectTracker`
+// interface (Apache-2.0, see NOTICE).
+//! SAM 2 as the Roto Brush's object tracker: prompts on some frames, the whole clip tracked
+//! forwards and backwards, each frame reported as it is finished.
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use candle_core::Tensor;
+use effectcraft_segment::{ClipFrame, ObjectTracker, TrackRequest, TrackedFrame};
+
+use crate::mask::{Sam2Mask, preprocess, validate_frame_size};
+use crate::prompt::{INPUT_SIZE, Prompt};
+use crate::resize::mask_to_model;
+use crate::session::{Cancel, Direction, FrameMask, FrameSource, ObjectId, VideoTracker};
+use crate::{Error, Result};
+
+/// Most frames one tracking request may cover.
+const MAX_CLIP: usize = 100_000;
+
+type Frames<'a> = &'a mut dyn FnMut(i64) -> Option<Arc<ClipFrame>>;
+
+/// Feeds the host's frames to the tracker, remembering each frame's size for the output.
+struct Source<'a> {
+    first: i64,
+    count: usize,
+    fetch: RefCell<Frames<'a>>,
+    sizes: Rc<RefCell<HashMap<usize, (usize, usize)>>>,
+}
+
+impl FrameSource for Source<'_> {
+    fn num_frames(&self) -> usize {
+        self.count
+    }
+
+    fn frame(&self, index: usize) -> Result<Tensor> {
+        let number = i64::try_from(index)
+            .ok()
+            .filter(|_| index < self.count)
+            .and_then(|offset| self.first.checked_add(offset))
+            .ok_or_else(|| Error::Input(format!("frame index {index} is outside the clip")))?;
+        let f = (self.fetch.borrow_mut())(number).ok_or_else(|| Error::Input(format!("frame {number} is not available")))?;
+        self.sizes.borrow_mut().insert(index, (f.w, f.h));
+        preprocess(&f.rgb, f.w, f.h)
+    }
+}
+
+fn to_frame(m: &FrameMask, size: (usize, usize)) -> Result<TrackedFrame> {
+    let (w, h) = size;
+    let logits = Tensor::from_slice(&m.logits, (1, 1, 256, 256), &candle_core::Device::Cpu)?;
+    let prob = candle_nn::ops::sigmoid(&logits.upsample_bilinear2d(h, w, false)?)?.flatten_all()?.to_vec1::<f32>()?;
+    let presence = 1.0 / (1.0 + (-m.object_score).exp());
+    Ok(TrackedFrame { prob, w, h, confidence: (presence * m.iou.clamp(0.0, 1.0)).clamp(0.0, 1.0), occluded: m.occluded })
+}
+
+/// Most objects one request may track.
+const MAX_OBJECTS: usize = 32;
+
+impl Sam2Mask {
+    fn run_track(&self, req: &TrackRequest, frames: Frames<'_>, cancel: &dyn Fn() -> bool, out: &mut dyn FnMut(usize, i64, TrackedFrame)) -> Result<()> {
+        if req.count == 0 || req.count > MAX_CLIP {
+            return Err(Error::Input(format!("a tracking request needs 1 to {MAX_CLIP} frames, got {}", req.count)));
+        }
+        req.first.checked_add((req.count - 1) as i64).ok_or_else(|| Error::Input("the clip's last frame overflows its frame number".into()))?;
+        if req.objects.is_empty() || req.objects.len() > MAX_OBJECTS || req.objects.iter().any(|o| o.is_empty()) {
+            return Err(Error::Input(format!("tracking needs 1 to {MAX_OBJECTS} objects, each with a prompt on at least one frame")));
+        }
+        let sizes = Rc::new(RefCell::new(HashMap::new()));
+        let source = Source { first: req.first, count: req.count, fetch: RefCell::new(frames), sizes: sizes.clone() };
+        // Prompt coordinates are in the frame's pixels and the model works at 1024 x 1024, so the
+        // prompted frames' sizes are needed first.
+        let mut prompt_frames = vec![];
+        for (oi, prompts) in req.objects.iter().enumerate() {
+            for (frame, p) in prompts {
+                let idx = frame
+                    .checked_sub(req.first)
+                    .and_then(|offset| usize::try_from(offset).ok())
+                    .filter(|i| *i < req.count)
+                    .ok_or_else(|| Error::Input(format!("prompt frame {frame} is outside the clip")))?;
+                if !sizes.borrow().contains_key(&idx) {
+                    let f = (source.fetch.borrow_mut())(*frame).ok_or_else(|| Error::Input(format!("frame {frame} is not available")))?;
+                    validate_frame_size(f.w, f.h, f.rgb.len())?;
+                    sizes.borrow_mut().insert(idx, (f.w, f.h));
+                }
+                prompt_frames.push((oi, idx, p));
+            }
+        }
+        let mut tracker = VideoTracker::new(self.video_model().clone(), Box::new(source))?;
+        let object_id = |oi: usize| ObjectId(oi as u32 + 1);
+        // each object's first prompted frame: its pass starts there, forwards and backwards
+        let mut first_of: HashMap<usize, usize> = HashMap::new();
+        for (oi, idx, p) in prompt_frames {
+            if cancel() {
+                return Err(Error::Cancelled);
+            }
+            let (w, h) = sizes.borrow().get(&idx).copied().ok_or_else(|| Error::Compute("frame size unknown".into()))?;
+            // A prompt that is only a mask (probability per pixel of the frame) prompts with the mask.
+            if let (true, true, Some(m)) = (p.points.is_empty(), p.bbox.is_none(), p.mask.as_ref()) {
+                if m.len() != w * h {
+                    return Err(Error::Input(format!("a mask prompt of {} values does not fit a {w}x{h} frame", m.len())));
+                }
+                let binary: Vec<u8> = m.iter().map(|v| u8::from(*v >= 0.5)).collect();
+                tracker.prompt_mask(idx, object_id(oi), &mask_to_model(&binary, w, h)?)?;
+                let e = first_of.entry(oi).or_insert(idx);
+                *e = (*e).min(idx);
+                continue;
+            }
+            let (sx, sy) = (INPUT_SIZE as f32 / w as f32, INPUT_SIZE as f32 / h as f32);
+            let prompt = Prompt {
+                points: p.points.iter().map(|(c, fg)| ([c[0] * sx, c[1] * sy], *fg)).collect(),
+                bbox: p.bbox.map(|b| [b[0] * sx, b[1] * sy, b[2] * sx, b[3] * sy]),
+            };
+            tracker.prompt(idx, object_id(oi), &prompt)?;
+            let e = first_of.entry(oi).or_insert(idx);
+            *e = (*e).min(idx);
+        }
+        let mut starts: Vec<(ObjectId, usize)> = first_of.into_iter().map(|(oi, idx)| (object_id(oi), idx)).collect();
+        starts.sort_by_key(|(id, _)| id.0);
+        let flag = Cancel::new();
+        let mut failure: Option<Error> = None;
+        let mut emit = |m: FrameMask| {
+            if cancel() {
+                flag.cancel();
+            }
+            let oi = (m.object.0 as usize).saturating_sub(1);
+            match to_frame(&m, sizes.borrow().get(&m.frame).copied().unwrap_or((0, 0))) {
+                Ok(t) => out(oi, req.first + m.frame as i64, t),
+                Err(e) => {
+                    failure.get_or_insert(e);
+                    flag.cancel();
+                }
+            }
+        };
+        // One pass each way over all the objects, frame by frame, so the host can finish a frame (and
+        // let go of its masks) as soon as every object has it, however far apart the prompts are.
+        let passes = (|| {
+            tracker.propagate_each(&starts, Direction::Forward, &flag, &mut emit)?;
+            if starts.iter().any(|(_, start)| *start > 0) {
+                tracker.propagate_each(&starts, Direction::Backward, &flag, &mut emit)?;
+            }
+            Ok(())
+        })();
+        self.peak.store(tracker.peak_state_bytes() as u64, std::sync::atomic::Ordering::Relaxed);
+        // A frame that could not be converted cancelled the passes; that is the error to report, not
+        // the cancellation it caused.
+        match failure {
+            Some(e) => Err(e),
+            None => passes,
+        }
+    }
+}
+
+impl ObjectTracker for Sam2Mask {
+    fn track(
+        &self,
+        req: &TrackRequest,
+        frames: &mut dyn FnMut(i64) -> Option<Arc<ClipFrame>>,
+        cancel: &dyn Fn() -> bool,
+        out: &mut dyn FnMut(usize, i64, TrackedFrame),
+    ) -> effectcraft_segment::Result<()> {
+        self.touch();
+        let r = self.run_track(req, frames, cancel, out).map_err(|e| e.to_string());
+        self.touch();
+        r
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn source_rejects_overflowing_and_out_of_range_indices_before_fetching() {
+        let mut fetch = |_| panic!("invalid indices must not fetch a frame");
+        let source = Source { first: i64::MAX, count: 2, fetch: RefCell::new(&mut fetch), sizes: Default::default() };
+        assert!(matches!(source.frame(1), Err(Error::Input(_))));
+        assert!(matches!(source.frame(usize::MAX), Err(Error::Input(_))));
+    }
+}
diff --git a/crates/sam2/src/weights.rs b/crates/sam2/src/weights.rs
new file mode 100644
index 000000000..ca246b143
--- /dev/null
+++ b/crates/sam2/src/weights.rs
@@ -0,0 +1,112 @@
+// Modified work: loads the safetensors checkpoint of Hugging Face `transformers` SAM 2
+// (Apache-2.0, Copyright The HuggingFace Inc. team). See NOTICE.
+//! Checkpoint loading with validation: every tensor is f32 and finite, every lookup checks its
+//! shape, so a truncated, mislabelled or poisoned file is an error, not a crash or garbage.
+
+use std::collections::HashMap;
+use std::path::Path;
+
+use candle_core::{DType, Device, Tensor};
+
+use crate::{Error, Result};
+
+/// Named tensors of one checkpoint.
+pub struct Weights {
+    map: HashMap<String, Tensor>,
+}
+
+impl Weights {
+    /// Read a `.safetensors` file; rejects non-finite values and unsupported dtypes.
+    pub fn open(path: &Path) -> Result<Weights> {
+        let map = candle_core::safetensors::load(path, &Device::Cpu).map_err(|e| Error::Weights(format!("{}: {e}", path.display())))?;
+        Weights::from_map(map)
+    }
+
+    /// Read a checkpoint held in memory (the installed file's bytes, already verified by the caller).
+    pub fn from_bytes(bytes: &[u8]) -> Result<Weights> {
+        let map = candle_core::safetensors::load_buffer(bytes, &Device::Cpu).map_err(|e| Error::Weights(e.to_string()))?;
+        Weights::from_map(map)
+    }
+
+    /// Validate an already-loaded set of tensors.
+    pub fn from_map(map: HashMap<String, Tensor>) -> Result<Weights> {
+        let mut out = HashMap::with_capacity(map.len());
+        for (name, t) in map {
+            let t = match t.dtype() {
+                DType::F32 => t,
+                DType::F16 | DType::BF16 | DType::F64 => t.to_dtype(DType::F32)?,
+                other => return Err(Error::Weights(format!("`{name}` has unsupported dtype {other:?}"))),
+            };
+            let flat = t.flatten_all()?.to_vec1::<f32>()?;
+            if flat.iter().any(|v| !v.is_finite()) {
+                return Err(Error::Weights(format!("`{name}` contains NaN or infinity")));
+            }
+            out.insert(name, t);
+        }
+        Ok(Weights { map: out })
+    }
+
+    pub fn contains(&self, name: &str) -> bool {
+        self.map.contains_key(name)
+    }
+
+    /// The shape of a tensor, if the checkpoint has it.
+    pub fn shape(&self, name: &str) -> Option<Vec<usize>> {
+        self.map.get(name).map(|t| t.dims().to_vec())
+    }
+
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.map.is_empty()
+    }
+
+    /// The tensor `name`, which must have exactly `shape`.
+    pub fn get(&self, name: &str, shape: &[usize]) -> Result<Tensor> {
+        let t = self.map.get(name).ok_or_else(|| Error::Weights(format!("missing tensor `{name}`")))?;
+        if t.dims() != shape {
+            return Err(Error::Weights(format!("`{name}` has shape {:?}, expected {shape:?}", t.dims())));
+        }
+        Ok(t.clone())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn one(name: &str, t: Tensor) -> HashMap<String, Tensor> {
+        HashMap::from([(name.to_string(), t)])
+    }
+
+    #[test]
+    fn rejects_missing_wrong_shape_and_non_finite() {
+        let ok = Tensor::zeros((2, 3), DType::F32, &Device::Cpu).unwrap();
+        let w = Weights::from_map(one("a", ok)).unwrap();
+        assert!(w.get("a", &[2, 3]).is_ok());
+        assert!(matches!(w.get("a", &[3, 2]), Err(Error::Weights(_))));
+        assert!(matches!(w.get("b", &[1]), Err(Error::Weights(_))));
+        let bad = Tensor::new(&[1.0f32, f32::NAN], &Device::Cpu).unwrap();
+        assert!(matches!(Weights::from_map(one("n", bad)), Err(Error::Weights(_))));
+        let inf = Tensor::new(&[f32::INFINITY], &Device::Cpu).unwrap();
+        assert!(Weights::from_map(one("i", inf)).is_err());
+        let ints = Tensor::new(&[1u32], &Device::Cpu).unwrap();
+        assert!(Weights::from_map(one("u", ints)).is_err());
+    }
+
+    #[test]
+    fn a_truncated_file_is_an_error() {
+        let dir = std::env::temp_dir().join(format!("sam2-weights-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let p = dir.join("w.safetensors");
+        let t = Tensor::zeros((4, 4), DType::F32, &Device::Cpu).unwrap();
+        candle_core::safetensors::save(&one("x", t), &p).unwrap();
+        let bytes = std::fs::read(&p).unwrap();
+        std::fs::write(&p, &bytes[..bytes.len() - 8]).unwrap();
+        assert!(matches!(Weights::open(&p), Err(Error::Weights(_))));
+        assert!(matches!(Weights::open(&dir.join("absent")), Err(Error::Weights(_))));
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}
diff --git a/crates/sam2/tests/it/figure.rs b/crates/sam2/tests/it/figure.rs
new file mode 100644
index 000000000..2ca4d0b13
--- /dev/null
+++ b/crates/sam2/tests/it/figure.rs
@@ -0,0 +1,77 @@
+use effectcraft_sam2::model::ImageModel;
+use effectcraft_sam2::prompt::Prompt;
+use effectcraft_sam2::weights::Weights;
+
+fn figure(w: usize, h: usize) -> (Vec<[f32; 3]>, Vec<bool>) {
+    let mut rgb = vec![[0f32; 3]; w * h];
+    let mut gt = vec![false; w * h];
+    let part = |x: f32, y: f32| -> Option<[f32; 3]> {
+        let (cx, _cy) = (128.0, 0.0);
+        let r = |x0: f32, y0: f32, x1: f32, y1: f32| x >= x0 && x < x1 && y >= y0 && y < y1;
+        if (x - cx).powi(2) + (y - 40.0).powi(2) < 18.0f32.powi(2) {
+            return Some([0.8, 0.6, 0.5]);
+        } // head
+        if r(104.0, 60.0, 152.0, 130.0) {
+            return Some([0.2, 0.3, 0.7 + 0.1 * (x / 7.0).sin()]);
+        } // torso
+        if r(76.0, 62.0, 104.0, 74.0) || r(152.0, 62.0, 180.0, 74.0) {
+            return Some([0.8, 0.6, 0.5]);
+        } // arms
+        if r(108.0, 130.0, 124.0, 210.0) || r(132.0, 130.0, 148.0, 210.0) {
+            return Some([0.15, 0.15, 0.2]);
+        } // legs
+        if r(102.0, 210.0, 126.0, 224.0) || r(130.0, 210.0, 154.0, 224.0) {
+            return Some([0.95, 0.95, 0.95]);
+        } // white shoes
+        None
+    };
+    for y in 0..h {
+        for x in 0..w {
+            let bg = 0.45 + 0.1 * (x as f32 / 11.0).sin() * (y as f32 / 9.0).cos();
+            let p = part(x as f32, y as f32);
+            rgb[y * w + x] = p.unwrap_or([bg, bg * 0.9, bg * 0.8]);
+            gt[y * w + x] = p.is_some();
+        }
+    }
+    (rgb, gt)
+}
+
+fn iou(p: &[f32], gt: &[bool]) -> f64 {
+    let (mut i, mut u) = (0usize, 0usize);
+    for (a, b) in p.iter().zip(gt) {
+        let a = *a > 0.0;
+        i += usize::from(a && *b);
+        u += usize::from(a || *b);
+    }
+    i as f64 / u.max(1) as f64
+}
+
+/// A multi-part figure (torso, head, legs, arms, white shoes in different colours): clicks alone make
+/// SAM 2 pick the torso and head, a box around the figure makes it cover all of it. This is why Roto
+/// Brush prompts the tracker with a box from the classic engine's matte (found on real footage, where
+/// the stroke frame came out partial).
+#[test]
+fn a_box_makes_sam2_cover_every_part_of_the_object() {
+    let wf = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../sam2-tiny/model.safetensors");
+    let wf = std::env::var_os("EFFECTCRAFT_SAM2_DIR").map_or(wf, |d| std::path::PathBuf::from(d).join("model.safetensors"));
+    if !wf.exists() {
+        eprintln!("skipped: no SAM 2 weights");
+        return;
+    }
+    let model = ImageModel::load(&Weights::open(&wf).unwrap()).unwrap();
+    let (w, h) = (256usize, 256usize);
+    let (rgb, gt) = figure(w, h);
+    let enc = model.encode(&effectcraft_sam2::mask::preprocess(&rgb, w, h).unwrap()).unwrap();
+    let s = 4.0f32;
+    let clicks = vec![([128.0 * s, 75.0 * s], true), ([128.0 * s, 100.0 * s], true), ([128.0 * s, 125.0 * s], true), ([20.0 * s, 20.0 * s], false)];
+    let mask = |p: &Prompt| -> (f64, f32) {
+        let out = model.segment(&enc, p, false).unwrap();
+        let m = out.masks.narrow(1, 0, 1).unwrap().upsample_bilinear2d(h, w, false).unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        (iou(&m, &gt), out.iou.flatten_all().unwrap().to_vec1::<f32>().unwrap()[0])
+    };
+    let (points_only, _) = mask(&Prompt { points: clicks.clone(), bbox: None });
+    let (boxed, predicted) = mask(&Prompt { points: clicks, bbox: Some([70.0 * s, 18.0 * s, 186.0 * s, 228.0 * s]) });
+    eprintln!("clicks only: IoU {points_only:.2}; with the box: IoU {boxed:.2} (predicted quality {predicted:.2})");
+    assert!(points_only < 0.6, "the clicks-only failure this test documents is gone ({points_only}): revisit the box prompt");
+    assert!(boxed > 0.95 && predicted > 0.7, "boxed IoU {boxed}, predicted {predicted}");
+}
diff --git a/crates/sam2/tests/it/main.rs b/crates/sam2/tests/it/main.rs
new file mode 100644
index 000000000..b8232c63f
--- /dev/null
+++ b/crates/sam2/tests/it/main.rs
@@ -0,0 +1,4 @@
+//! The crate's integration tests, one binary (each module is a former `tests/<name>.rs`).
+
+mod figure;
+mod reference;
diff --git a/crates/sam2/tests/it/reference.rs b/crates/sam2/tests/it/reference.rs
new file mode 100644
index 000000000..01648e329
--- /dev/null
+++ b/crates/sam2/tests/it/reference.rs
@@ -0,0 +1,805 @@
+//! Stage-by-stage comparison with the PyTorch / transformers reference (`tools/sam2_reference.py`).
+//!
+//! Needs the `facebook/sam2.1-hiera-tiny` weights (default `<repo>/sam2-tiny`, or the folder in
+//! `EFFECTCRAFT_SAM2_DIR`) and the fixture tensors (`<repo>/plan/sam2-ref/image.safetensors`, or
+//! `EFFECTCRAFT_SAM2_REF`). Without them every test here skips, so CI stays green.
+#![cfg(not(target_arch = "wasm32"))]
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use candle_core::{Device, Tensor};
+use effectcraft_sam2::hiera::{Hiera, HieraConfig};
+use effectcraft_sam2::weights::Weights;
+
+fn repo() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..")
+}
+
+fn weights_file() -> PathBuf {
+    std::env::var_os("EFFECTCRAFT_SAM2_DIR").map_or_else(|| repo().join("sam2-tiny"), PathBuf::from).join("model.safetensors")
+}
+
+fn fixture_file() -> PathBuf {
+    std::env::var_os("EFFECTCRAFT_SAM2_REF").map_or_else(|| repo().join("plan/sam2-ref/image.safetensors"), PathBuf::from)
+}
+
+/// The weights and the reference tensors, or `None` (the test then skips).
+fn load() -> Option<(Weights, HashMap<String, Tensor>)> {
+    let (wf, rf) = (weights_file(), fixture_file());
+    if !wf.exists() || !rf.exists() {
+        eprintln!("skipped: SAM 2 weights or reference tensors not found ({} / {})", wf.display(), rf.display());
+        return None;
+    }
+    let w = Weights::open(&wf).unwrap();
+    let r = candle_core::safetensors::load(&rf, &Device::Cpu).unwrap();
+    note_size(&w);
+    Some((w, r))
+}
+
+fn max_abs(a: &Tensor, b: &Tensor) -> f32 {
+    assert_eq!(a.dims(), b.dims(), "shape mismatch");
+    (a - b).unwrap().abs().unwrap().flatten_all().unwrap().max(0).unwrap().to_scalar::<f32>().unwrap()
+}
+
+/// The largest magnitude in a tensor.
+fn peak(t: &Tensor) -> f32 {
+    t.abs().unwrap().flatten_all().unwrap().max(0).unwrap().to_scalar::<f32>().unwrap()
+}
+
+/// Set when the checkpoint is Base+ or Large (24 and 48 blocks): f32 rounding error is relative and accumulates with
+/// depth, and these backbones carry much larger activations (Large peaks at 140). Tiny and Small keep the strict bounds.
+static DEEP: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+
+fn note_size(w: &Weights) {
+    let size = effectcraft_sam2::Size::detect(w).unwrap();
+    DEEP.store(matches!(size, effectcraft_sam2::Size::BasePlus | effectcraft_sam2::Size::Large), std::sync::atomic::Ordering::Relaxed);
+}
+
+/// `base`, or for the deep backbones the larger of `base` and 5e-4 of the activations' peak.
+fn tol(base: f32, want: &Tensor) -> f32 {
+    if DEEP.load(std::sync::atomic::Ordering::Relaxed) { base.max(5e-4 * peak(want)) } else { base }
+}
+
+/// `base`, ×4 for the deep backbones.
+fn loose(base: f32) -> f32 {
+    if DEEP.load(std::sync::atomic::Ordering::Relaxed) { base * 4.0 } else { base }
+}
+
+/// f32 activations differ from PyTorch by accumulation order only; the Hiera blocks stay well
+/// inside this bound (measured max 2.6e-5, 2026-10-15).
+const HIERA_TOL: f32 = 1e-4;
+
+#[test]
+fn hiera_matches_pytorch_block_by_block() {
+    let Some((w, r)) = load() else { return };
+    let hiera = Hiera::load(&w, &HieraConfig::for_size(effectcraft_sam2::Size::detect(&w).unwrap())).unwrap();
+    let pixels = r.get("input.pixel_values").unwrap();
+    let (emb, blocks) = hiera.forward_all(pixels).unwrap();
+    let e = max_abs(&emb, r.get("vision_encoder.backbone.patch_embed.0").unwrap());
+    eprintln!("patch_embed max abs error {e:e}");
+    assert!(e < 1e-4, "patch embed error {e}");
+    assert_eq!(blocks.len(), HieraConfig::for_size(effectcraft_sam2::Size::detect(&w).unwrap()).blocks.iter().sum::<usize>());
+    for (i, b) in blocks.iter().enumerate() {
+        let want = r.get(&format!("vision_encoder.backbone.blocks.{i}.0")).unwrap();
+        let e = max_abs(b, want);
+        eprintln!("block {i}: max abs error {e:e}");
+        let t = tol(HIERA_TOL, want);
+        assert!(e < t, "block {i} error {e} (tolerance {t}, peak {})", peak(want));
+    }
+}
+
+#[test]
+fn hiera_is_deterministic_and_rejects_bad_sizes() {
+    let Some((w, r)) = load() else { return };
+    let hiera = Hiera::load(&w, &HieraConfig::for_size(effectcraft_sam2::Size::detect(&w).unwrap())).unwrap();
+    let pixels = r.get("input.pixel_values").unwrap();
+    let a = hiera.forward(pixels).unwrap();
+    let b = hiera.forward(pixels).unwrap();
+    assert_eq!(a.len(), 4);
+    for (x, y) in a.iter().zip(&b) {
+        assert_eq!(max_abs(x, y), 0.0);
+    }
+    let odd = pixels.narrow(2, 0, 1022).unwrap();
+    assert!(hiera.forward(&odd).is_err());
+}
+
+/// The neck adds 1x1 convolutions and nearest-neighbour sums to the Hiera output; the sine
+/// position encodings are exact functions of the grid size.
+const NECK_TOL: f32 = 1e-4;
+
+#[test]
+fn neck_and_vision_encoder_match_pytorch() {
+    let Some((w, r)) = load() else { return };
+    let enc = effectcraft_sam2::neck::VisionEncoder::load(&w).unwrap();
+    let pixels = r.get("input.pixel_values").unwrap();
+    let stages = enc.hiera.forward(pixels).unwrap();
+    let out = enc.neck.forward(&stages).unwrap();
+    assert_eq!((out.features.len(), out.positions.len()), (4, 4));
+    for (i, f) in out.features.iter().enumerate() {
+        let e = max_abs(f, r.get(&format!("vision_encoder.neck.{i}")).unwrap());
+        eprintln!("neck feature {i}: max abs error {e:e}");
+        let want = r.get(&format!("vision_encoder.neck.{i}")).unwrap();
+        assert!(e < tol(NECK_TOL, want), "neck feature {i} error {e} (peak {})", peak(want));
+    }
+    for (i, p) in out.positions.iter().enumerate() {
+        let e = max_abs(p, r.get(&format!("vision_encoder.neck.{}", i + 4)).unwrap());
+        eprintln!("neck position {i}: max abs error {e:e}");
+        assert!(e < NECK_TOL, "neck position {i} error {e}");
+    }
+    // The vision encoder keeps the three highest-resolution levels, highest first.
+    let feats = enc.forward(pixels).unwrap();
+    let dims: Vec<usize> = feats.features.iter().map(|f| f.dim(2).unwrap()).collect();
+    assert_eq!(dims, vec![256, 128, 64]);
+    let e = max_abs(feats.features.first().unwrap(), r.get("vision_encoder.neck.3").unwrap());
+    assert!(e < tol(NECK_TOL, r.get("vision_encoder.neck.3").unwrap()));
+}
+
+/// Click-prompted single image: prompt embeddings and decoder outputs against `Sam2Model`.
+const DECODER_TOL: f32 = 1e-3;
+
+#[test]
+fn prompt_encoder_and_decoder_match_pytorch() {
+    use effectcraft_sam2::model::ImageModel;
+    use effectcraft_sam2::prompt::Prompt;
+    let Some((w, r)) = load() else { return };
+    let model = ImageModel::load(&w).unwrap();
+    let pixels = r.get("input.pixel_values").unwrap();
+    let prompt = Prompt { points: vec![([460.0, 512.0], true)], bbox: None };
+
+    let (sparse, dense) = model.embed_prompt(&prompt).unwrap();
+    let want_sparse = r.get("prompt_encoder.0").unwrap().squeeze(0).unwrap();
+    let e = max_abs(&sparse, &want_sparse);
+    eprintln!("sparse prompt: max abs error {e:e}");
+    assert!(e < 1e-5, "sparse prompt error {e}");
+    let e = max_abs(&dense, r.get("prompt_encoder.1").unwrap());
+    assert!(e < 1e-6, "dense prompt error {e}");
+
+    let enc = model.encode(pixels).unwrap();
+    let out = model.segment(&enc, &prompt, true).unwrap();
+    let want_masks = r.get("mask_decoder.0").unwrap().squeeze(0).unwrap();
+    let e = max_abs(&out.masks, &want_masks);
+    eprintln!("masks: max abs error {e:e} (logit range {:?})", want_masks.flatten_all().unwrap().max(0).unwrap().to_scalar::<f32>());
+    assert!(e < loose(DECODER_TOL), "mask logits error {e}");
+    let e = max_abs(&out.iou, &r.get("mask_decoder.1").unwrap().squeeze(0).unwrap());
+    eprintln!("iou: max abs error {e:e}");
+    assert!(e < 1e-4, "iou error {e}");
+    let e = max_abs(&out.object_score, &r.get("mask_decoder.3").unwrap().squeeze(0).unwrap());
+    eprintln!("object score: max abs error {e:e}");
+    assert!(e < 1e-4, "object score error {e}");
+    let e = max_abs(&out.sam_tokens, &r.get("mask_decoder.2").unwrap().squeeze(0).unwrap());
+    assert!(e < loose(1e-4), "sam token error {e}");
+}
+
+fn video_fixture_file() -> PathBuf {
+    std::env::var_os("EFFECTCRAFT_SAM2_VIDEO_REF").map_or_else(|| repo().join("plan/sam2-ref/video.safetensors"), PathBuf::from)
+}
+
+/// The weights and the video reference tensors (`tools/sam2_video_reference.py`), or `None`.
+fn load_video() -> Option<(Weights, HashMap<String, Tensor>)> {
+    let (wf, rf) = (weights_file(), video_fixture_file());
+    if !wf.exists() || !rf.exists() {
+        eprintln!("skipped: SAM 2 weights or video reference tensors not found ({} / {})", wf.display(), rf.display());
+        return None;
+    }
+    let w = Weights::open(&wf).unwrap();
+    note_size(&w);
+    Some((w, candle_core::safetensors::load(&rf, &Device::Cpu).unwrap()))
+}
+
+/// Measured max 3.5e-6 (memory features), 2.6e-5 (memory attention), 2026-10-15.
+const MEMORY_TOL: f32 = 1e-4;
+
+#[test]
+fn memory_encoder_matches_pytorch() {
+    let Some((w, r)) = load_video() else { return };
+    let enc = effectcraft_sam2::memory::MemoryEncoder::load(&w).unwrap();
+    let (feat, pos) = enc.encode(r.get("mem.enc.vision_features").unwrap(), r.get("mem.enc.masks").unwrap()).unwrap();
+    let e = max_abs(&feat, r.get("mem.enc.out_features").unwrap());
+    eprintln!("memory features: max abs error {e:e}");
+    assert!(e < MEMORY_TOL, "memory feature error {e}");
+    let e = max_abs(&pos, r.get("mem.enc.out_pos").unwrap());
+    eprintln!("memory position encoding: max abs error {e:e}");
+    assert!(e < 1e-5, "memory position error {e}");
+}
+
+#[test]
+fn memory_attention_matches_pytorch() {
+    let Some((w, r)) = load_video() else { return };
+    let att = effectcraft_sam2::memattn::MemoryAttention::load(&w).unwrap();
+    let get = |k: &str| r.get(k).unwrap().squeeze(1).unwrap();
+    let pointers = r.get("mem.attn.num_pointers").unwrap().to_vec1::<f32>().unwrap()[0] as usize;
+    let out = att
+        .forward(
+            &get("mem.attn.current_vision_features"),
+            &get("mem.attn.current_vision_position_embeddings"),
+            &get("mem.attn.memory"),
+            &get("mem.attn.memory_posision_embeddings"),
+            pointers,
+        )
+        .unwrap();
+    let want = r.get("mem.attn.out").unwrap().squeeze(0).unwrap().squeeze(0).unwrap();
+    let e = max_abs(&out, &want);
+    eprintln!("memory attention: max abs error {e:e} (pointers {pointers})");
+    assert!(e < MEMORY_TOL, "memory attention error {e}");
+}
+
+/// Frames of the video fixture, served one at a time.
+struct Clip(Tensor);
+
+impl effectcraft_sam2::session::FrameSource for Clip {
+    fn num_frames(&self) -> usize {
+        self.0.dim(0).unwrap()
+    }
+    fn frame(&self, i: usize) -> effectcraft_sam2::Result<Tensor> {
+        Ok(self.0.narrow(0, i, 1)?.contiguous()?)
+    }
+}
+
+fn iou(a: &[f32], b: &[f32]) -> f64 {
+    let (mut i, mut u) = (0usize, 0usize);
+    for (x, y) in a.iter().zip(b) {
+        let (x, y) = (*x > 0.0, *y > 0.0);
+        i += usize::from(x && y);
+        u += usize::from(x || y);
+    }
+    if u == 0 { 1.0 } else { i as f64 / u as f64 }
+}
+
+/// Through the clip the memory bank feeds back on itself (bfloat16 memories, rotary attention), so
+/// the bound on logits is looser than for a single stage; the masks themselves must agree.
+/// Measured max 0.0038 over 9 frames forwards and backwards, 2026-10-15.
+const VIDEO_LOGIT_TOL: f32 = 0.02;
+const VIDEO_MIN_IOU: f64 = 0.995;
+
+fn check_video_tracking(backend: effectcraft_sam2::session::Backend) {
+    use effectcraft_sam2::prompt::Prompt;
+    use effectcraft_sam2::session::{Cancel, Direction, ObjectId, VideoModel, VideoTracker};
+    let Some((w, r)) = load_video() else { return };
+    let model = std::sync::Arc::new(match VideoModel::load_with(&w, backend) {
+        Ok(m) => m,
+        Err(e) => {
+            eprintln!("skipped: {e}");
+            return;
+        }
+    });
+    let clip = r.get("clip.pixel_values").unwrap().clone();
+    let mut tracker = VideoTracker::new(model, Box::new(Clip(clip))).unwrap();
+    let obj = ObjectId(1);
+    let first = tracker.prompt(2, obj, &Prompt { points: vec![([416.0, 512.0], true)], bbox: None }).unwrap();
+
+    let check = |tag: &str, m: &effectcraft_sam2::session::FrameMask| {
+        let want = r.get(&format!("video.{tag}.{}.pred_masks", m.frame)).unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        let want_score = r.get(&format!("video.{tag}.{}.score", m.frame)).unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap()[0];
+        let err = m.logits.iter().zip(&want).map(|(a, b)| (a - b).abs()).fold(0f32, f32::max);
+        let j = iou(&m.logits, &want);
+        eprintln!("{tag} frame {}: logit error {err:.4}, IoU {j:.4}, score {:.3} (want {want_score:.3})", m.frame, m.object_score);
+        assert!(j >= VIDEO_MIN_IOU, "{tag} frame {} IoU {j}", m.frame);
+        assert!(err < VIDEO_LOGIT_TOL, "{tag} frame {} logit error {err}", m.frame);
+        assert!((m.object_score - want_score).abs() < 0.05, "{tag} frame {} score {} vs {want_score}", m.frame, m.object_score);
+        assert_eq!(m.occluded, want_score <= 0.0);
+    };
+    check("prompt", &first);
+    let cancel = Cancel::new();
+    let mut fwd = vec![];
+    tracker.propagate(2, Direction::Forward, None, &cancel, &mut |m| fwd.push(m)).unwrap();
+    assert_eq!(fwd.iter().map(|m| m.frame).collect::<Vec<_>>(), vec![2, 3, 4, 5, 6]);
+    for m in &fwd {
+        check("fwd", m);
+    }
+    let mut rev = vec![];
+    tracker.propagate(2, Direction::Backward, None, &cancel, &mut |m| rev.push(m)).unwrap();
+    assert_eq!(rev.iter().map(|m| m.frame).collect::<Vec<_>>(), vec![2, 1, 0]);
+    for m in &rev {
+        check("rev", m);
+    }
+}
+
+#[test]
+fn video_tracking_matches_sam2_video_model() {
+    check_video_tracking(effectcraft_sam2::session::Backend::Cpu);
+}
+
+/// The same clip on the GPU: every frame's mask against `Sam2VideoModel`, forwards and backwards. The GPU path
+/// is within 1e-5 of PyTorch stage by stage; through the clip the bfloat16 memories can round the other way
+/// on a few values, so the bound on logits is the video one, and the masks must agree.
+#[test]
+fn video_tracking_on_the_gpu_matches_sam2_video_model() {
+    check_video_tracking(effectcraft_sam2::session::Backend::Gpu);
+}
+
+#[test]
+fn tracker_rejects_hostile_input_and_honours_cancel() {
+    use effectcraft_sam2::Error;
+    use effectcraft_sam2::prompt::Prompt;
+    use effectcraft_sam2::session::{Cancel, Direction, ObjectId, VideoModel, VideoTracker};
+    let Some((w, r)) = load_video() else { return };
+    let model = std::sync::Arc::new(VideoModel::load(&w).unwrap());
+    let clip = r.get("clip.pixel_values").unwrap().narrow(0, 0, 3).unwrap();
+    let mut t = VideoTracker::new(model.clone(), Box::new(Clip(clip.clone()))).unwrap();
+    let click = Prompt { points: vec![([416.0, 512.0], true)], bbox: None };
+    let obj = ObjectId(7);
+    // outside the clip, empty and non-finite prompts, nothing prompted yet
+    assert!(matches!(t.prompt(3, obj, &click), Err(Error::Input(_))));
+    assert!(matches!(t.prompt(0, obj, &Prompt::default()), Err(Error::Input(_))));
+    assert!(matches!(t.prompt(0, obj, &Prompt { points: vec![([f32::NAN, 1.0], true)], bbox: None }), Err(Error::Input(_))));
+    let mut sink = |_m| {};
+    assert!(matches!(t.propagate(0, Direction::Forward, None, &Cancel::new(), &mut sink), Err(Error::Input(_))));
+    assert!(matches!(t.propagate(9, Direction::Forward, None, &Cancel::new(), &mut sink), Err(Error::Input(_))));
+    // an empty clip is refused; a cancelled run stops with Cancelled and keeps the tracker usable
+    assert!(VideoTracker::new(model.clone(), Box::new(Clip(clip.narrow(0, 0, 0).unwrap()))).is_err());
+    t.prompt(0, obj, &click).unwrap();
+    let cancel = Cancel::new();
+    cancel.cancel();
+    assert!(matches!(t.propagate(0, Direction::Forward, None, &cancel, &mut sink), Err(Error::Cancelled)));
+    let mut seen = vec![];
+    t.propagate(0, Direction::Forward, Some(1), &Cancel::new(), &mut |m| seen.push(m.frame)).unwrap();
+    assert_eq!(seen, vec![0, 1]);
+    // a frame source that returns the wrong size is an error, not a crash
+    struct Bad;
+    impl effectcraft_sam2::session::FrameSource for Bad {
+        fn num_frames(&self) -> usize {
+            2
+        }
+        fn frame(&self, _i: usize) -> effectcraft_sam2::Result<Tensor> {
+            Ok(Tensor::zeros((1, 3, 64, 64), candle_core::DType::F32, &Device::Cpu)?)
+        }
+    }
+    let mut bad = VideoTracker::new(model, Box::new(Bad)).unwrap();
+    assert!(matches!(bad.prompt(0, obj, &click), Err(Error::Input(_))));
+}
+
+#[test]
+fn sam2_works_as_a_mask_model() {
+    use effectcraft_segment::{MaskModel, Prompt};
+    let Some((w, _)) = load() else { return };
+    let (fw, fh) = (256usize, 192usize);
+    let mut rgb = vec![[0f32; 3]; fw * fh];
+    let inside = |x: usize, y: usize| ((x as f32 - 120.0).powi(2) + (y as f32 - 96.0).powi(2)).sqrt() < 50.0;
+    for y in 0..fh {
+        for x in 0..fw {
+            let bg = 0.3 + 0.2 * (x as f32 / 9.0).sin() * (y as f32 / 7.0).cos();
+            rgb[y * fw + x] = if inside(x, y) { [0.85 + 0.1 * (x as f32 / 5.0).sin(), 0.4, 0.15] } else { [bg, bg * 0.8 + 0.1, bg * 0.6 + 0.3] };
+        }
+    }
+    let model = effectcraft_sam2::mask::Sam2Mask::new(std::sync::Arc::new(effectcraft_sam2::session::VideoModel::load(&w).unwrap()));
+    let prompt = Prompt { points: vec![([120.0, 96.0], true)], bbox: None, mask: None };
+    let p = model.segment(&rgb, fw, fh, &prompt).unwrap();
+    assert_eq!(p.len(), fw * fh);
+    assert!(p.iter().all(|v| (0.0..=1.0).contains(v)));
+    let (mut i, mut u) = (0usize, 0usize);
+    for y in 0..fh {
+        for x in 0..fw {
+            let (a, b) = (p[y * fw + x] > 0.5, inside(x, y));
+            i += usize::from(a && b);
+            u += usize::from(a || b);
+        }
+    }
+    let j = i as f64 / u as f64;
+    eprintln!("SAM 2 as a MaskModel: disc IoU {j:.3}");
+    assert!(j > 0.9, "IoU {j}");
+    // The same frame again is served from the cached encoding, and bad prompts are errors.
+    let again = model.segment(&rgb, fw, fh, &Prompt { points: vec![([20.0, 20.0], false), ([120.0, 96.0], true)], bbox: None, mask: None }).unwrap();
+    assert_eq!(again.len(), fw * fh);
+    assert!(model.segment(&rgb, fw, fh, &Prompt::default()).is_err());
+    assert!(model.segment(&rgb, fw + 1, fh, &prompt).is_err());
+}
+
+#[test]
+fn sam2_tracks_a_clip_through_the_object_tracker_interface() {
+    use effectcraft_segment::{ClipFrame, MaskModel, Prompt, TrackRequest};
+    let Some((w, _)) = load() else { return };
+    let (fw, fh, n) = (128usize, 96usize, 6usize);
+    let centre = |t: usize| (40.0 + 8.0 * t as f32, 48.0f32);
+    let inside = |t: usize, x: usize, y: usize| {
+        let c = centre(t);
+        ((x as f32 - c.0).powi(2) + (y as f32 - c.1).powi(2)).sqrt() < 26.0
+    };
+    let frames: Vec<std::sync::Arc<ClipFrame>> = (0..n)
+        .map(|t| {
+            let mut rgb = vec![[0f32; 3]; fw * fh];
+            for y in 0..fh {
+                for x in 0..fw {
+                    let bg = 0.3 + 0.2 * (x as f32 / 9.0).sin() * (y as f32 / 7.0).cos();
+                    rgb[y * fw + x] =
+                        if inside(t, x, y) { [0.85 + 0.1 * ((x as f32 - centre(t).0) / 5.0).sin(), 0.4, 0.15] } else { [bg, bg * 0.8 + 0.1, bg * 0.6 + 0.3] };
+                }
+            }
+            std::sync::Arc::new(ClipFrame { rgb, w: fw, h: fh })
+        })
+        .collect();
+    let model = effectcraft_sam2::mask::Sam2Mask::new(std::sync::Arc::new(effectcraft_sam2::session::VideoModel::load(&w).unwrap()));
+    assert!(model.tracker().is_some());
+    let c = centre(1);
+    let req = TrackRequest::single(100, n, vec![(101, Prompt { points: vec![([c.0, c.1], true)], bbox: None, mask: None })]);
+    let mut seen = std::collections::BTreeMap::new();
+    let mut get = |f: i64| frames.get((f - 100) as usize).cloned();
+    model
+        .tracker()
+        .unwrap()
+        .track(&req, &mut get, &|| false, &mut |o, f, t| {
+            assert_eq!(o, 0);
+            assert!(seen.insert(f, t).is_none(), "frame {f} reported twice");
+        })
+        .unwrap();
+    assert_eq!(seen.keys().copied().collect::<Vec<_>>(), (100..100 + n as i64).collect::<Vec<_>>());
+    for (f, t) in &seen {
+        assert_eq!((t.w, t.h, t.prob.len()), (fw, fh, fw * fh));
+        let k = (f - 100) as usize;
+        let (mut i, mut u) = (0usize, 0usize);
+        for y in 0..fh {
+            for x in 0..fw {
+                let (a, b) = (t.prob[y * fw + x] > 0.5, inside(k, x, y));
+                i += usize::from(a && b);
+                u += usize::from(a || b);
+            }
+        }
+        let j = i as f64 / u.max(1) as f64;
+        eprintln!("frame {f}: IoU {j:.3}, confidence {:.2}, occluded {}", t.confidence, t.occluded);
+        assert!(j > 0.85 && !t.occluded && t.confidence > 0.3, "frame {f}: IoU {j}");
+    }
+    // Cancelling before the work starts, and bad requests, are errors.
+    assert!(model.tracker().unwrap().track(&req, &mut get, &|| true, &mut |_, _, _| {}).is_err());
+    let none = TrackRequest::single(100, n, vec![]);
+    assert!(model.tracker().unwrap().track(&none, &mut get, &|| false, &mut |_, _, _| {}).is_err());
+    let outside = TrackRequest::single(100, n, vec![(500, Prompt { points: vec![([1.0, 1.0], true)], bbox: None, mask: None })]);
+    assert!(model.tracker().unwrap().track(&outside, &mut get, &|| false, &mut |_, _, _| {}).is_err());
+}
+
+/// Two objects in one pass: each follows its own disc, every frame is reported once per object, and
+/// objects may start on different frames.
+#[test]
+fn sam2_tracks_two_objects_in_one_pass() {
+    use effectcraft_segment::{ClipFrame, MaskModel, Prompt, TrackRequest};
+    let Some((w, _)) = load() else { return };
+    let (fw, fh, n) = (160usize, 120usize, 4usize);
+    // A red disc moving right and a blue one moving left, never touching.
+    let a = |t: usize| (36.0 + 6.0 * t as f32, 40.0f32);
+    let b = |t: usize| (124.0 - 6.0 * t as f32, 84.0f32);
+    let hit = |c: (f32, f32), x: usize, y: usize| ((x as f32 - c.0).powi(2) + (y as f32 - c.1).powi(2)).sqrt() < 20.0;
+    let frames: Vec<std::sync::Arc<ClipFrame>> = (0..n)
+        .map(|t| {
+            let mut rgb = vec![[0f32; 3]; fw * fh];
+            for y in 0..fh {
+                for x in 0..fw {
+                    let bg = 0.45 + 0.1 * (x as f32 / 9.0).sin() * (y as f32 / 7.0).cos();
+                    rgb[y * fw + x] = if hit(a(t), x, y) {
+                        [0.9, 0.15, 0.1]
+                    } else if hit(b(t), x, y) {
+                        [0.1, 0.25, 0.9]
+                    } else {
+                        [bg, bg * 0.9, bg * 0.8]
+                    };
+                }
+            }
+            std::sync::Arc::new(ClipFrame { rgb, w: fw, h: fh })
+        })
+        .collect();
+    let model = effectcraft_sam2::mask::Sam2Mask::new(std::sync::Arc::new(effectcraft_sam2::session::VideoModel::load(&w).unwrap()));
+    let click = |c: (f32, f32)| Prompt { points: vec![([c.0, c.1], true)], bbox: None, mask: None };
+    // object 0 is prompted on frame 0, object 1 on frame 2
+    let req = TrackRequest { first: 10, count: n, objects: vec![vec![(10, click(a(0)))], vec![(12, click(b(2)))]] };
+    let mut get = |f: i64| frames.get((f - 10) as usize).cloned();
+    let mut seen: std::collections::BTreeMap<(usize, i64), effectcraft_segment::TrackedFrame> = Default::default();
+    model.tracker().unwrap().track(&req, &mut get, &|| false, &mut |o, f, t| assert!(seen.insert((o, f), t).is_none(), "object {o} frame {f} twice")).unwrap();
+    assert_eq!(seen.len(), 2 * n, "{:?}", seen.keys().collect::<Vec<_>>());
+    for ((o, f), t) in &seen {
+        let k = (f - 10) as usize;
+        let c = if *o == 0 { a(k) } else { b(k) };
+        let (mut i, mut u) = (0usize, 0usize);
+        for y in 0..fh {
+            for x in 0..fw {
+                let (p, q) = (t.prob[y * fw + x] > 0.5, hit(c, x, y));
+                i += usize::from(p && q);
+                u += usize::from(p || q);
+            }
+        }
+        let j = i as f64 / u.max(1) as f64;
+        eprintln!("object {o} frame {f}: IoU {j:.3}, confidence {:.2}", t.confidence);
+        assert!(j > 0.85, "object {o} frame {f}: IoU {j}");
+    }
+    let too_many = TrackRequest { first: 10, count: n, objects: vec![vec![(10, click(a(0)))]; 40] };
+    assert!(model.tracker().unwrap().track(&too_many, &mut get, &|| false, &mut |_, _, _| {}).is_err());
+    let empty = TrackRequest { first: 10, count: n, objects: vec![] };
+    assert!(model.tracker().unwrap().track(&empty, &mut get, &|| false, &mut |_, _, _| {}).is_err());
+}
+
+/// A mask prompt instead of clicks: the mask is the prompt frame's output, and tracking forwards and
+/// backwards from it matches `Sam2VideoModel` given the same mask.
+#[test]
+fn mask_prompted_tracking_matches_sam2_video_model() {
+    use effectcraft_sam2::session::{Cancel, Direction, ObjectId, VideoModel, VideoTracker};
+    let Some((w, r)) = load_video() else { return };
+    let model = std::sync::Arc::new(VideoModel::load(&w).unwrap());
+    let mut tracker = VideoTracker::new(model, Box::new(Clip(r.get("clip.pixel_values").unwrap().clone()))).unwrap();
+    let obj = ObjectId(1);
+    let first = tracker.prompt_mask(2, obj, r.get("maskprompt.input").unwrap()).unwrap();
+    let check = |tag: &str, m: &effectcraft_sam2::session::FrameMask| {
+        let want = r.get(&format!("maskprompt.{tag}.{}.pred_masks", m.frame)).unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap();
+        let want_score = r.get(&format!("maskprompt.{tag}.{}.score", m.frame)).unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap()[0];
+        let err = m.logits.iter().zip(&want).map(|(a, b)| (a - b).abs()).fold(0f32, f32::max);
+        let j = iou(&m.logits, &want);
+        eprintln!("mask prompt {tag} frame {}: logit error {err:.4}, IoU {j:.4}, score {:.3} (want {want_score:.3})", m.frame, m.object_score);
+        assert!(j >= VIDEO_MIN_IOU, "{tag} frame {} IoU {j}", m.frame);
+        assert!(err < VIDEO_LOGIT_TOL, "{tag} frame {} logit error {err}", m.frame);
+        assert!((m.object_score - want_score).abs() < 0.05, "{tag} frame {} score {} vs {want_score}", m.frame, m.object_score);
+    };
+    check("prompt", &first);
+    let cancel = Cancel::new();
+    let mut fwd = vec![];
+    tracker.propagate(2, Direction::Forward, None, &cancel, &mut |m| fwd.push(m)).unwrap();
+    fwd.iter().for_each(|m| check("fwd", m));
+    let mut rev = vec![];
+    tracker.propagate(2, Direction::Backward, None, &cancel, &mut |m| rev.push(m)).unwrap();
+    rev.iter().for_each(|m| check("rev", m));
+    assert_eq!((fwd.len(), rev.len()), (5, 3));
+    // hostile masks are errors
+    let bad = Tensor::zeros((1, 1, 8, 8), candle_core::DType::F32, &Device::Cpu).unwrap();
+    assert!(tracker.prompt_mask(2, obj, &bad).is_err());
+    let nan = (Tensor::zeros((1, 1, 1024, 1024), candle_core::DType::F32, &Device::Cpu).unwrap() + f64::NAN).unwrap();
+    assert!(tracker.prompt_mask(2, obj, &nan).is_err());
+    assert!(tracker.prompt_mask(99, obj, r.get("maskprompt.input").unwrap()).is_err());
+}
+
+/// The tracker interface takes a mask as a prompt: the disc's true mask on frame 1 tracks the disc.
+#[test]
+fn a_mask_prompt_through_the_object_tracker_interface() {
+    use effectcraft_segment::{ClipFrame, MaskModel, Prompt, TrackRequest};
+    let Some((w, _)) = load() else { return };
+    let (fw, fh, n) = (128usize, 96usize, 4usize);
+    let centre = |t: usize| (40.0 + 8.0 * t as f32, 48.0f32);
+    let inside = |t: usize, x: usize, y: usize| ((x as f32 - centre(t).0).powi(2) + (y as f32 - centre(t).1).powi(2)).sqrt() < 26.0;
+    let frames: Vec<std::sync::Arc<ClipFrame>> = (0..n)
+        .map(|t| {
+            let mut rgb = vec![[0f32; 3]; fw * fh];
+            for y in 0..fh {
+                for x in 0..fw {
+                    let bg = 0.3 + 0.2 * (x as f32 / 9.0).sin() * (y as f32 / 7.0).cos();
+                    rgb[y * fw + x] = if inside(t, x, y) { [0.85, 0.4, 0.15] } else { [bg, bg * 0.8 + 0.1, bg * 0.6 + 0.3] };
+                }
+            }
+            std::sync::Arc::new(ClipFrame { rgb, w: fw, h: fh })
+        })
+        .collect();
+    let model = effectcraft_sam2::mask::Sam2Mask::new(std::sync::Arc::new(effectcraft_sam2::session::VideoModel::load(&w).unwrap()));
+    let mask: Vec<f32> = (0..fw * fh).map(|i| f32::from(inside(1, i % fw, i / fw))).collect();
+    let mut get = |f: i64| frames.get(f as usize).cloned();
+    let req = TrackRequest::single(0, n, vec![(1, Prompt { points: vec![], bbox: None, mask: Some(mask) })]);
+    let mut seen = std::collections::BTreeMap::new();
+    model
+        .tracker()
+        .unwrap()
+        .track(&req, &mut get, &|| false, &mut |_, f, t| {
+            seen.insert(f, t);
+        })
+        .unwrap();
+    assert_eq!(seen.len(), n);
+    for (f, t) in &seen {
+        let (mut i, mut u) = (0usize, 0usize);
+        for y in 0..fh {
+            for x in 0..fw {
+                let (a, b) = (t.prob[y * fw + x] > 0.5, inside(*f as usize, x, y));
+                i += usize::from(a && b);
+                u += usize::from(a || b);
+            }
+        }
+        let j = i as f64 / u.max(1) as f64;
+        eprintln!("mask-prompted frame {f}: IoU {j:.3}");
+        assert!(j > 0.85 && !t.occluded, "frame {f}: IoU {j}");
+    }
+    // a mask that does not fit the frame is an error
+    let bad = TrackRequest::single(0, n, vec![(1, Prompt { points: vec![], bbox: None, mask: Some(vec![1.0; 5]) })]);
+    assert!(model.tracker().unwrap().track(&bad, &mut get, &|| false, &mut |_, _, _| {}).is_err());
+}
+
+/// The same prompts on the same frames give the same masks, bit for bit, run after run (CPU).
+#[test]
+fn tracking_is_deterministic() {
+    use effectcraft_sam2::prompt::Prompt;
+    use effectcraft_sam2::session::{Cancel, Direction, ObjectId, VideoModel, VideoTracker};
+    let Some((w, r)) = load_video() else { return };
+    let model = std::sync::Arc::new(VideoModel::load(&w).unwrap());
+    let clip = r.get("clip.pixel_values").unwrap().narrow(0, 1, 3).unwrap();
+    let run = || {
+        let mut t = VideoTracker::new(model.clone(), Box::new(Clip(clip.clone()))).unwrap();
+        t.prompt(0, ObjectId(1), &Prompt { points: vec![([416.0, 512.0], true)], bbox: None }).unwrap();
+        let mut out = vec![];
+        t.propagate(0, Direction::Forward, None, &Cancel::new(), &mut |m| out.push(m)).unwrap();
+        out
+    };
+    let (a, b) = (run(), run());
+    assert_eq!(a.len(), 3);
+    for (x, y) in a.iter().zip(&b) {
+        assert_eq!(x.logits, y.logits, "frame {} differs between runs", x.frame);
+        assert_eq!((x.iou.to_bits(), x.object_score.to_bits()), (y.iou.to_bits(), y.object_score.to_bits()));
+    }
+}
+
+/// Hard limits: a tracker over its memory budget or past its time budget stops with Error::Budget.
+#[test]
+fn the_tracker_stops_at_its_budget() {
+    use effectcraft_sam2::Error;
+    use effectcraft_sam2::prompt::Prompt;
+    use effectcraft_sam2::session::{Budget, Cancel, Direction, ObjectId, VideoModel, VideoTracker};
+    let Some((w, r)) = load_video() else { return };
+    let model = std::sync::Arc::new(VideoModel::load(&w).unwrap());
+    let clip = r.get("clip.pixel_values").unwrap().narrow(0, 1, 3).unwrap();
+    let click = Prompt { points: vec![([416.0, 512.0], true)], bbox: None };
+    // memory: one frame's worth is more than a 1 MB limit
+    let mut t = VideoTracker::new(model.clone(), Box::new(Clip(clip.clone()))).unwrap();
+    t.set_budget(Budget { max_state_bytes: 1 << 20, max_seconds: None });
+    assert!(matches!(t.prompt(0, ObjectId(1), &click), Err(Error::Budget(_))));
+    // default limit: fine, and the bytes held are reported
+    let mut t = VideoTracker::new(model.clone(), Box::new(Clip(clip.clone()))).unwrap();
+    t.prompt(0, ObjectId(1), &click).unwrap();
+    let held = t.state_bytes();
+    assert!(held > 2 << 20 && held < 200 << 20, "{held}");
+    // time: a limit of zero stops the first propagation
+    t.set_budget(Budget { max_state_bytes: 2 << 30, max_seconds: Some(0.0) });
+    let r = t.propagate(0, Direction::Forward, None, &Cancel::new(), &mut |_| {});
+    assert!(matches!(r, Err(Error::Budget(_))), "{r:?}");
+}
+
+/// The GPU encoder (wgpu kernels, any vendor) against the CPU path and PyTorch on the same image. The two
+/// float implementations differ by accumulation order and the GPU's erf (1.5e-7), compounded through 12
+/// blocks. Measured (RX 7900 GRE, 2026-10-15): 6.8e-6 against PyTorch, 1.2e-5 against the CPU path.
+const GPU_TOL: f32 = 1e-4;
+
+#[test]
+fn gpu_encoder_matches_the_cpu_path_and_pytorch() {
+    use effectcraft_sam2::gpu::{Gpu, encoder::GpuEncoder};
+    use effectcraft_sam2::model::ImageModel;
+    let Some((w, r)) = load() else { return };
+    let gpu = match Gpu::shared() {
+        Ok(g) => g,
+        Err(e) => {
+            eprintln!("skipped: {e}");
+            return;
+        }
+    };
+    eprintln!("GPU: {}", gpu.adapter_name());
+    let model = ImageModel::load(&w).unwrap();
+    let pixels = r.get("input.pixel_values").unwrap();
+    let cpu = model.encode(pixels).unwrap();
+    let enc = GpuEncoder::load(gpu, &w, model.vision.hiera.clone()).unwrap();
+    let t = std::time::Instant::now();
+    let got = enc.encode(pixels).unwrap();
+    eprintln!("GPU encode (first run, includes shader compile): {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
+    let t = std::time::Instant::now();
+    let got = (enc.encode(pixels).unwrap(), got).0;
+    eprintln!("GPU encode: {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
+    let low_cpu = cpu.features.features.get(2).unwrap();
+    let e = max_abs(&got.low, low_cpu);
+    eprintln!("low level vs CPU: max abs error {e:e}");
+    assert!(e < tol(GPU_TOL, low_cpu), "low level error {e} (peak {})", peak(low_cpu));
+    let e = max_abs(&got.low, r.get("vision_encoder.neck.1").unwrap());
+    eprintln!("low level vs PyTorch: max abs error {e:e}");
+    assert!(e < tol(GPU_TOL, low_cpu), "low level vs PyTorch error {e}");
+    let (e0, e1) = (max_abs(&got.high.0, &cpu.high.0), max_abs(&got.high.1, &cpu.high.1));
+    eprintln!("skip features vs CPU: {e0:e} / {e1:e}");
+    assert!(e0 < tol(GPU_TOL, &cpu.high.0) && e1 < tol(GPU_TOL, &cpu.high.1), "skip feature errors {e0} / {e1}");
+}
+
+/// The GPU memory attention against PyTorch (the fixture's frame: one memory frame and four pointer tokens).
+/// Measured on the RX 7900 GRE, 2026-10-15; the CPU path is at 2.6e-5.
+const GPU_ATTN_TOL: f32 = 1e-3;
+
+#[test]
+fn gpu_memory_attention_matches_pytorch() {
+    use effectcraft_sam2::gpu::{Gpu, memattn::GpuMemoryAttention};
+    let Some((w, r)) = load_video() else { return };
+    let gpu = match Gpu::shared() {
+        Ok(g) => g,
+        Err(e) => {
+            eprintln!("skipped: {e}");
+            return;
+        }
+    };
+    let att = GpuMemoryAttention::load(gpu, &w).unwrap();
+    let get = |k: &str| r.get(k).unwrap().squeeze(1).unwrap();
+    let pointers = r.get("mem.attn.num_pointers").unwrap().to_vec1::<f32>().unwrap()[0] as usize;
+    let args = (
+        get("mem.attn.current_vision_features"),
+        get("mem.attn.current_vision_position_embeddings"),
+        get("mem.attn.memory"),
+        get("mem.attn.memory_posision_embeddings"),
+    );
+    let out = att.forward(&args.0, &args.1, &args.2, &args.3, pointers).unwrap();
+    let want = r.get("mem.attn.out").unwrap().squeeze(0).unwrap().squeeze(0).unwrap();
+    let e = max_abs(&out, &want);
+    eprintln!("GPU memory attention vs PyTorch: max abs error {e:e}");
+    assert!(e < GPU_ATTN_TOL, "GPU memory attention error {e}");
+    // a full bank (7 memory frames and 16 pointers of 4 tokens): the same maths on a bigger problem, against the CPU path
+    let cpu = effectcraft_sam2::memattn::MemoryAttention::load(&w).unwrap();
+    let m = 7 * 4096 + 64;
+    let mem = Tensor::randn(0f32, 1.0, (m, 64), &Device::Cpu).unwrap();
+    let mem_pos = Tensor::randn(0f32, 1.0, (m, 64), &Device::Cpu).unwrap();
+    let t = std::time::Instant::now();
+    let big = att.forward(&args.0, &args.1, &mem, &mem_pos, 64).unwrap();
+    eprintln!("GPU memory attention, full bank: {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
+    let want = cpu.forward(&args.0, &args.1, &mem, &mem_pos, 64).unwrap();
+    let e = max_abs(&big, &want);
+    eprintln!("full bank vs CPU: max abs error {e:e}");
+    assert!(e < GPU_ATTN_TOL, "full-bank error {e}");
+    // bad shapes are errors
+    assert!(att.forward(&args.0, &args.1, &mem, &mem_pos, m + 1).is_err());
+    assert!(att.forward(&args.0.narrow(0, 0, 10).unwrap(), &args.1, &mem, &mem_pos, 64).is_err());
+}
+
+/// The GPU can be switched off in the middle of a clip: the CPU takes over, the device name changes, and
+/// the masks still match `Sam2VideoModel` (the memory banks built on the GPU are read by the CPU path).
+#[test]
+fn switching_the_gpu_off_mid_clip_keeps_the_tracking_right() {
+    use effectcraft_sam2::prompt::Prompt;
+    use effectcraft_sam2::session::{Backend, Cancel, Direction, ObjectId, VideoModel, VideoTracker};
+    let Some((w, r)) = load_video() else { return };
+    let Ok(model) = VideoModel::load_with(&w, Backend::Gpu) else {
+        eprintln!("skipped: no GPU");
+        return;
+    };
+    let model = std::sync::Arc::new(model);
+    assert_ne!(model.device_name(), "CPU");
+    let mut t = VideoTracker::new(model.clone(), Box::new(Clip(r.get("clip.pixel_values").unwrap().clone()))).unwrap();
+    t.prompt(2, ObjectId(1), &Prompt { points: vec![([416.0, 512.0], true)], bbox: None }).unwrap();
+    let mut seen = vec![];
+    t.propagate(2, Direction::Forward, Some(1), &Cancel::new(), &mut |m| seen.push(m)).unwrap();
+    model.disable_gpu();
+    assert_eq!(model.device_name(), "CPU");
+    t.propagate(2, Direction::Forward, None, &Cancel::new(), &mut |m| seen.push(m)).unwrap();
+    let last = seen.last().unwrap();
+    assert_eq!(last.frame, 6);
+    let want = r.get("video.fwd.6.pred_masks").unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap();
+    let j = iou(&last.logits, &want);
+    assert!(j >= VIDEO_MIN_IOU, "frame 6 after the switch: IoU {j}");
+}
+
+/// The GPU memory encoder against the CPU one on the fixture's frame (a mask, the frame's features). The CPU
+/// path matches PyTorch to 3.5e-6; the GPU is held to the same output.
+#[test]
+fn gpu_memory_encoder_matches_the_cpu_one() {
+    use effectcraft_sam2::gpu::{Gpu, memenc::GpuMemoryEncoder};
+    let Some((w, r)) = load_video() else { return };
+    let Ok(gpu) = Gpu::shared() else {
+        eprintln!("skipped: no GPU");
+        return;
+    };
+    let cpu = effectcraft_sam2::memory::MemoryEncoder::load(&w).unwrap();
+    let enc = GpuMemoryEncoder::load(gpu, &w).unwrap();
+    let (features, mask) = (r.get("mem.enc.vision_features").unwrap(), r.get("mem.enc.masks").unwrap());
+    let t = std::time::Instant::now();
+    let got = enc.encode(features, mask).unwrap();
+    eprintln!("GPU memory encoder: {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
+    let want = r.get("mem.enc.out_features").unwrap().flatten_from(2).unwrap().squeeze(0).unwrap().t().unwrap().contiguous().unwrap();
+    let e = max_abs(&got, &want);
+    eprintln!("GPU memory encoder vs PyTorch: max abs error {e:e}");
+    assert!(e < 1e-3, "memory encoder error {e}");
+    // the whole memory (with the occlusion embedding and bfloat16 rounding) equals the CPU one
+    let (a, b) = (cpu.finish(&got, false).unwrap(), cpu.memory(features, mask, false).unwrap());
+    let e = max_abs(&a.features, &b.features);
+    assert!(e < 0.05, "memory features differ by {e} (bfloat16 steps are 2^-8 of the value)");
+    assert_eq!(max_abs(&a.pos, &b.pos), 0.0);
+    // wrong shapes are errors
+    assert!(enc.encode(&features.narrow(1, 0, 8).unwrap(), mask).is_err());
+}
+
+/// The tracker reports the most memory it held (memory banks, kept results, cached frames), and the model
+/// reports it for the last tracking run.
+#[test]
+fn the_tracker_reports_its_peak_memory() {
+    use effectcraft_segment::{ClipFrame, MaskModel, Prompt, TrackRequest};
+    let Some((w, _)) = load() else { return };
+    let model = effectcraft_sam2::mask::Sam2Mask::new(std::sync::Arc::new(effectcraft_sam2::session::VideoModel::load(&w).unwrap()));
+    assert_eq!(model.peak_state_bytes(), Some(0));
+    let (fw, fh) = (64usize, 48usize);
+    let frame = std::sync::Arc::new(ClipFrame {
+        rgb: (0..fw * fh).map(|i| if (i % fw).abs_diff(32) < 12 && (i / fw).abs_diff(24) < 12 { [0.9, 0.2, 0.1] } else { [0.2, 0.3, 0.5] }).collect(),
+        w: fw,
+        h: fh,
+    });
+    let mut get = |_f: i64| Some(frame.clone());
+    let req = TrackRequest::single(0, 3, vec![(0, Prompt { points: vec![([32.0, 24.0], true)], bbox: None, mask: None })]);
+    model.tracker().unwrap().track(&req, &mut get, &|| false, &mut |_, _, _| {}).unwrap();
+    let peak = model.peak_state_bytes().unwrap();
+    // three stored frames (about 2 MB each) and the cached frame features
+    assert!(peak > 6 << 20 && peak < 400 << 20, "peak {peak}");
+}
diff --git a/crates/script/src/lib.rs b/crates/script/src/lib.rs
index 5c1f8cdbb..11d837677 100644
--- a/crates/script/src/lib.rs
+++ b/crates/script/src/lib.rs
@@ -88,28 +88,7 @@ pub fn run_code(s: &mut Session, code: &str, name: &str) -> Outcome {
 
 #[cfg(test)]
 mod tests;
-#[cfg(test)]
-mod tests_callable;
-#[cfg(test)]
-mod tests_ease_presets;
-#[cfg(test)]
-mod tests_include;
-#[cfg(test)]
-mod tests_panels;
-#[cfg(test)]
-mod tests_tasks;
-#[cfg(test)]
-mod tests_ui;
-#[cfg(test)]
-mod tests_ui_more;
 
 // #760: `$.evalFile` and `BridgeTalk`.
-#[cfg(test)]
-mod tests_evalfile;
 // `/browser/…` is the web editor's file table, an absolute path on wasm; on Windows it has no
 // drive, so the script runtime resolves it under the current drive, where the host holds nothing.
-#[cfg(test)]
-#[cfg(not(windows))]
-mod tests_services;
-#[cfg(test)]
-mod tests_ui_mouse;
diff --git a/crates/script/src/matchnames.rs b/crates/script/src/matchnames.rs
index 205697b60..45b10a0df 100644
--- a/crates/script/src/matchnames.rs
+++ b/crates/script/src/matchnames.rs
@@ -90,6 +90,44 @@ pub fn stroke_dash(name: &str) -> Option<&'static str> {
 
 const TEXT_ANIMATOR: &[(&str, &str)] = &[("selectors", "ADBE Text Selectors"), ("properties", "ADBE Text Animator Properties")];
 
+/// Animator property ids and their stable After Effects scripting names. Shared by lookup,
+/// `.matchName`, and `addProperty` so the same property has one name in every direction.
+pub const TEXT_ANIMATOR_PROPERTIES: &[(&str, &str)] = &[
+    ("anchor", "ADBE Text Anchor Point 3D"),
+    ("position", "ADBE Text Position 3D"),
+    ("scale", "ADBE Text Scale 3D"),
+    ("skew", "ADBE Text Skew"),
+    ("rotation", "ADBE Text Rotation"),
+    ("opacity", "ADBE Text Opacity"),
+    ("fillColor", "ADBE Text Fill Color"),
+    ("fillHue", "ADBE Text Fill Hue"),
+    ("fillSaturation", "ADBE Text Fill Saturation"),
+    ("fillBrightness", "ADBE Text Fill Brightness"),
+    ("fillOpacity", "ADBE Text Fill Opacity"),
+    ("strokeColor", "ADBE Text Stroke Color"),
+    ("strokeHue", "ADBE Text Stroke Hue"),
+    ("strokeSaturation", "ADBE Text Stroke Saturation"),
+    ("strokeBrightness", "ADBE Text Stroke Brightness"),
+    ("strokeOpacity", "ADBE Text Stroke Opacity"),
+    ("strokeWidth", "ADBE Text Stroke Width"),
+    ("tracking", "ADBE Text Tracking Amount"),
+    ("lineAnchor", "ADBE Text Line Anchor"),
+    ("lineSpacing", "ADBE Text Line Spacing"),
+    ("characterOffset", "ADBE Text Character Offset"),
+    ("characterValue", "ADBE Text Character Replace"),
+    ("blur", "ADBE Text Blur"),
+];
+
+/// Companion properties that exist below an animator but are not kinds `addProperty` accepts:
+/// they come with Tracking (Track Type), Skew (Skew Axis) and per-character 3D Rotation
+/// (X and Y Rotation). Lookup and `.matchName` know them; `addProperty` does not.
+pub const TEXT_ANIMATOR_COMPANIONS: &[(&str, &str)] = &[
+    ("trackingType", "ADBE Text Track Type"),
+    ("skewAxis", "ADBE Text Skew Axis"),
+    ("rotationX", "ADBE Text Rotation X"),
+    ("rotationY", "ADBE Text Rotation Y"),
+];
+
 const TEXT_SELECTORS: &[(&str, &str)] =
     &[("rangeSelector", "ADBE Text Selector"), ("wigglySelector", "ADBE Text Wiggly Selector"), ("expressionSelector", "ADBE Text Expressible Selector")];
 
@@ -147,6 +185,7 @@ pub const SHAPE_ITEMS: &[(&str, &str)] = &[
     ("trim", "ADBE Vector Filter - Trim"),
     ("twist", "ADBE Vector Filter - Twist"),
     ("wiggle", "ADBE Vector Filter - Roughen"),
+    ("wiggler", "ADBE Vector Filter - Wiggler"),
     ("zigzag", "ADBE Vector Filter - Zigzag"),
 ];
 
@@ -208,7 +247,29 @@ const SHAPE_PROPS: &[(&str, &str, &str)] = &[
     ("pucker", "amount", "ADBE Vector PuckerBloat Amount"),
     ("twist", "angle", "ADBE Vector Twist Angle"),
     ("twist", "center", "ADBE Vector Twist Center"),
+    ("wiggler", "speed", "ADBE Vector Xform Temporal Freq"),
+    ("wiggler", "correlation", "ADBE Vector Correlation"),
+    ("wiggler", "phase", "ADBE Vector Temporal Phase"),
+    ("wiggler", "spatialPhase", "ADBE Vector Spatial Phase"),
+    ("wiggler", "seed", "ADBE Vector Random Seed"),
+    ("wiggler", "transform", "ADBE Vector Wiggler Transform"),
     ("merge", "mode", "ADBE Vector Merge Type"),
+    ("offset", "amount", "ADBE Vector Offset Amount"),
+    ("offset", "join", "ADBE Vector Offset Line Join"),
+    ("offset", "miter", "ADBE Vector Offset Miter Limit"),
+    ("offset", "copies", "ADBE Vector Offset Copies"),
+    ("offset", "copyOffset", "ADBE Vector Offset Copy Offset"),
+    ("zigzag", "size", "ADBE Vector Zigzag Size"),
+    ("zigzag", "ridges", "ADBE Vector Zigzag Detail"),
+    ("zigzag", "points", "ADBE Vector Zigzag Points"),
+    ("wiggle", "size", "ADBE Vector Roughen Size"),
+    ("wiggle", "detail", "ADBE Vector Roughen Detail"),
+    ("wiggle", "points", "ADBE Vector Roughen Points"),
+    ("wiggle", "speed", "ADBE Vector Temporal Freq"),
+    ("wiggle", "correlation", "ADBE Vector Correlation"),
+    ("wiggle", "phase", "ADBE Vector Temporal Phase"),
+    ("wiggle", "spatialPhase", "ADBE Vector Spatial Phase"),
+    ("wiggle", "seed", "ADBE Vector Random Seed"),
 ];
 
 /// Effects: our effect id → AE match name (the documented ones; the rest keep our id).
@@ -393,6 +454,7 @@ pub fn shape_kind(name: &str) -> Option<&'static str> {
         "twist" => "twist",
         "zigzag" => "zigzag",
         "wigglepaths" => "wiggle",
+        "wiggletransform" => "wiggler",
         "mergepaths" => "merge",
         _ => return None,
     })
@@ -479,6 +541,9 @@ pub fn node(chain: &[&Node]) -> String {
         "text" if pid == "animators" => "ADBE Text Animator".into(),
         "text" if pid == "selectors" => find(TEXT_SELECTORS, id).map(str::to_string).unwrap_or_else(own),
         "text" if pid == "rangeSelector" => find(TEXT_RANGE_SELECTOR, id).map(str::to_string).unwrap_or_else(own),
+        "text" if pid == "properties" && chain.len() == 5 && chain.get(1).is_some_and(|n| n.match_id() == "animators") => {
+            find(TEXT_ANIMATOR_PROPERTIES, id).or_else(|| find(TEXT_ANIMATOR_COMPANIONS, id)).map(str::to_string).unwrap_or_else(own)
+        }
         "text" if grand.map(|g| g.match_id()) == Some("animators") => find(TEXT_ANIMATOR, id).map(str::to_string).unwrap_or_else(own),
         "cameraOptions" => find(CAMERA, id).map(str::to_string).unwrap_or_else(own),
         "lightOptions" => find(LIGHT, id).map(str::to_string).unwrap_or_else(own),
@@ -529,6 +594,30 @@ mod tests {
         assert_eq!(shape_kind("nope"), None);
     }
 
+    #[test]
+    fn text_animator_property_names_are_canonical_and_scoped() {
+        let n = |m: &str| Node::from(effectcraft_project::PropGroup::new(1, m, m));
+        let (text, animators, animator, properties) = (n("text"), n("animators"), n("animator"), n("properties"));
+        for (id, name) in TEXT_ANIMATOR_PROPERTIES {
+            let prop = n(id);
+            assert_eq!(node(&[&text, &animators, &animator, &properties, &prop]), *name);
+            assert_eq!(node(&[&properties, &prop]), *id, "an unrelated Properties group keeps its own ids");
+        }
+    }
+
+    /// #1063: the companions an animator property brings (Track Type, Skew Axis, X / Y Rotation)
+    /// have their After Effects names too, though `addProperty` does not accept them.
+    #[test]
+    fn text_animator_companions_have_after_effects_names() {
+        let n = |m: &str| Node::from(effectcraft_project::PropGroup::new(1, m, m));
+        let (text, animators, animator, properties) = (n("text"), n("animators"), n("animator"), n("properties"));
+        for (id, name) in TEXT_ANIMATOR_COMPANIONS {
+            let prop = n(id);
+            assert_eq!(node(&[&text, &animators, &animator, &properties, &prop]), *name);
+            assert!(!TEXT_ANIMATOR_PROPERTIES.iter().any(|(k, m)| k == id || m == name), "{id} is not an addProperty kind");
+        }
+    }
+
     #[test]
     fn text_range_selector_names() {
         let n = |m: &str| Node::from(effectcraft_project::PropGroup::new(1, m, m));
diff --git a/crates/script/src/model.rs b/crates/script/src/model.rs
index 23356c064..258a6de2d 100644
--- a/crates/script/src/model.rs
+++ b/crates/script/src/model.rs
@@ -743,36 +743,12 @@ fn resolve_add(s: &Session, a: &J) -> R {
 /// A text animator property (`layer.addTextAnimatorProperty` key) from an After Effects match
 /// name or a display name.
 fn text_animator_property(name: &str) -> Option<&'static str> {
-    const AE: &[(&str, &str)] = &[
-        ("ADBE Text Anchor Point 3D", "anchor"),
-        ("ADBE Text Position 3D", "position"),
-        ("ADBE Text Scale 3D", "scale"),
-        ("ADBE Text Skew", "skew"),
-        ("ADBE Text Rotation", "rotation"),
-        ("ADBE Text Opacity", "opacity"),
-        ("ADBE Text Fill Color", "fillColor"),
-        ("ADBE Text Fill Hue", "fillHue"),
-        ("ADBE Text Fill Saturation", "fillSaturation"),
-        ("ADBE Text Fill Brightness", "fillBrightness"),
-        ("ADBE Text Fill Opacity", "fillOpacity"),
-        ("ADBE Text Stroke Color", "strokeColor"),
-        ("ADBE Text Stroke Hue", "strokeHue"),
-        ("ADBE Text Stroke Saturation", "strokeSaturation"),
-        ("ADBE Text Stroke Brightness", "strokeBrightness"),
-        ("ADBE Text Stroke Opacity", "strokeOpacity"),
-        ("ADBE Text Stroke Width", "strokeWidth"),
-        ("ADBE Text Tracking Amount", "tracking"),
-        ("ADBE Text Line Anchor", "lineAnchor"),
-        ("ADBE Text Line Spacing", "lineSpacing"),
-        ("ADBE Text Character Offset", "characterOffset"),
-        ("ADBE Text Character Replace", "characterValue"),
-        ("ADBE Text Blur", "blur"),
-    ];
-    if let Some((_, k)) = AE.iter().find(|(m, _)| m.eq_ignore_ascii_case(name)) {
+    let table = matchnames::TEXT_ANIMATOR_PROPERTIES;
+    if let Some((k, _)) = table.iter().find(|(_, m)| m.eq_ignore_ascii_case(name)) {
         return Some(k);
     }
     let n = loose(name);
-    AE.iter().map(|(_, k)| *k).find(|k| loose(k) == n || (n == "anchorpoint" && *k == "anchor") || (n == "trackingamount" && *k == "tracking"))
+    table.iter().map(|(k, _)| *k).find(|k| loose(k) == n || (n == "anchorpoint" && *k == "anchor") || (n == "trackingamount" && *k == "tracking"))
 }
 
 /// `app.findMenuCommandId(name)`: 1-based index of the command whose label matches (menu items
diff --git a/crates/script/src/prelude.js b/crates/script/src/prelude.js
index 5216db341..b9108b2a1 100644
--- a/crates/script/src/prelude.js
+++ b/crates/script/src/prelude.js
@@ -189,7 +189,12 @@ BridgeTalk.pump = function () { return false; };
 
 // ------------------------------------------------------------------ File / Folder
 
-function __join(a, b) { return a.replace(/[\/\\]+$/, "") + "/" + b; }
+function __trimPathSeparators(path) {
+  var end = path.length;
+  while (end > 0 && (path.charAt(end - 1) === "/" || path.charAt(end - 1) === "\\")) end--;
+  return path.slice(0, end);
+}
+function __join(a, b) { return __trimPathSeparators(a) + "/" + b; }
 
 function File(path) {
   if (!(this instanceof File)) return new File(path);
@@ -292,9 +297,9 @@ Folder.prototype = {
   get fsName() { return this.__path; },
   get fullName() { return this.__path; },
   get absoluteURI() { return this.__path; },
-  get name() { return this.__path.replace(/[\/\\]+$/, "").split(/[\/\\]/).pop(); },
+  get name() { return __trimPathSeparators(this.__path).split(/[\/\\]/).pop(); },
   get displayName() { return this.name; },
-  get path() { var p = this.__path.replace(/[\/\\]+$/, "").split(/[\/\\]/); p.pop(); return p.join("/"); },
+  get path() { var p = __trimPathSeparators(this.__path).split(/[\/\\]/); p.pop(); return p.join("/"); },
   get parent() { return new Folder(this.path); },
   get exists() { return JSON.parse(__file("isDir", this.__path)) === true; },
   toString: function () { return this.__path; },
@@ -420,7 +425,7 @@ function __callable(o) {
   delete f.length;
   Object.setPrototypeOf(f, Object.getPrototypeOf(o));
   var keys = Object.keys(o);
-  for (var i = 0; i < keys.length; i++) f[keys[i]] = o[keys[i]];
+  for (const elem of keys) f[elem] = o[elem];
   var self = new Proxy(f, {
     get: __attr.get,
     apply: function (t, thisArg, args) { return self.property(args[0]); },
@@ -473,7 +478,7 @@ function MarkerValue(comment, chapter, url, frameTarget, cuePointName, params) {
 }
 MarkerValue.prototype.getParameters = function () {
   var o = {};
-  for (var i = 0; i < this.__params.length; i++) o[this.__params[i][0]] = this.__params[i][1];
+  for (const elem of this.__params) o[elem[0]] = elem[1];
   return o;
 };
 MarkerValue.prototype.setParameters = function (o) {
@@ -513,8 +518,8 @@ TextDocument.prototype = {
   set text(v) { this.__text = String(v); this.__textSet = true; },
   __style: function (k, d) {
     if (k in this.__changed) return this.__changed[k];
-    if (this.__base && this.__base.first && k in this.__base.first) return this.__base.first[k];
-    if (this.__base && this.__base.para && k in this.__base.para) return this.__base.para[k];
+    if (this.__base?.first && k in this.__base.first) return this.__base.first[k];
+    if (this.__base?.para && k in this.__base.para) return this.__base.para[k];
     return d;
   },
   __set: function (k, v) { this.__changed[k] = v; },
@@ -580,14 +585,14 @@ TextDocument.prototype = {
   },
   get tsume() { return this.__style("tsume", 0); },
   set tsume(v) { this.__set("tsume", __num(v)); },
-  get boxText() { return !!(this.__base && this.__base.box_size); },
+  get boxText() { return !!this.__base?.box_size; },
   get pointText() { return !this.boxText; },
-  get boxTextSize() { return this.__base && this.__base.box_size ? this.__base.box_size.slice() : undefined; },
+  get boxTextSize() { return this.__base?.box_size ? this.__base.box_size.slice() : undefined; },
   set boxTextSize(v) {
     var p = this.boxTextPos || [0, 0];
     this.__set("box", [p[0], p[1], v[0], v[1]]);
   },
-  get boxTextPos() { return this.__base && this.__base.box_size ? this.__base.box_pos.slice() : undefined; },
+  get boxTextPos() { return this.__base?.box_size ? this.__base.box_pos.slice() : undefined; },
   get startIndent() { return this.__style("indentLeft", 0); },
   set startIndent(v) { this.__set("indentLeft", __num(v)); },
   get endIndent() { return this.__style("indentRight", 0); },
@@ -665,7 +670,7 @@ PropertyBase.prototype = {
   get isMask() { return !!this.__info().isMask; },
   get selected() {
     var c = __get("item", { id: this.__layer.__comp }).selectedProperties;
-    for (var i = 0; i < c.length; i++) if (c[i][0] === this.__layer.__id && c[i][1] === this.__uid) return true;
+    for (const elem of c) if (elem[0] === this.__layer.__id && elem[1] === this.__uid) return true;
     return false;
   },
   set selected(v) {
@@ -729,9 +734,8 @@ PropertyGroup.prototype.addProperty = function (name) {
   } else if (r.kind === "animator") {
     uid = __call("layer.addTextAnimator", { comp: L.__comp, layer: L.__id, properties: [] }).animator;
   } else if (r.kind === "animatorProperty") {
-    var before = this.numProperties;
-    __call("layer.addTextAnimatorProperty", { comp: L.__comp, layer: L.__id, animator: r.animator, property: r.property });
-    return this.property(before + 1);
+    var added = __call("layer.addTextAnimatorProperty", { comp: L.__comp, layer: L.__id, animator: r.animator, property: r.property });
+    return this.property(added.index);
   } else if (r.kind === "selector") {
     var n0 = this.numProperties;
     __call("layer.addTextSelector", { comp: L.__comp, layer: L.__id, animator: r.animator, kind: r.selector });
@@ -842,7 +846,7 @@ Property.prototype.property = function () { return null; };
     i = __num(i, "keyIndex");
     // Only the key asked for: fetching the whole list made every key call linear (#814).
     var r = i >= 1 && Math.floor(i) === i ? __get("keys", { comp: this.__layer.__comp, layer: this.__layer.__id, uid: this.__uid, index: i - 1 }) : null;
-    if (!r || !r.key) throw __err("keyIndex " + i + " is out of range 1.." + (r ? r.count : this.numKeys));
+    if (!r?.key) throw __err("keyIndex " + i + " is out of range 1.." + (r ? r.count : this.numKeys));
     return r.key;
   };
   // Script value → engine JSON for `prop.set` / `prop.addKey`.
@@ -853,13 +857,13 @@ Property.prototype.property = function () { return null; };
       return __get("textdoc", { comp: this.__layer.__comp, layer: this.__layer.__id, uid: this.__uid, time: time, attrs: td.__attrs() });
     }
     if (t === "SHAPE") {
-      if (!v || !v.vertices) throw __err("value must be a Shape");
+      if (!v?.vertices) throw __err("value must be a Shape");
       var n = v.vertices.length;
-      function fit(a) { var o = []; for (var i = 0; i < n; i++) o.push(a && a[i] ? [a[i][0], a[i][1]] : [0, 0]); return o; }
+      function fit(a) { var o = []; for (var i = 0; i < n; i++) o.push(a?.[i] ? [a[i][0], a[i][1]] : [0, 0]); return o; }
       return { vertices: fit(v.vertices), in_tangents: fit(v.inTangents), out_tangents: fit(v.outTangents), closed: v.closed !== false };
     }
     if (t === "LAYER_INDEX") {
-      var idx = v && v.__id !== undefined ? v.index : __num(v);
+      var idx = v?.__id !== undefined ? v.index : __num(v);
       if (!idx) return null;
       return this.__layer.containingComp.layer(idx).__id;
     }
@@ -1177,7 +1181,7 @@ Layer.prototype = {
   },
   get selectedProperties() {
     var c = this.containingComp.__info().selectedProperties, out = [];
-    for (var i = 0; i < c.length; i++) if (c[i][0] === this.__id) out.push(__propOf(this, __get("node", { comp: this.__comp, layer: this.__id, uid: c[i][1] })));
+    for (const elem of c) if (elem[0] === this.__id) out.push(__propOf(this, __get("node", { comp: this.__comp, layer: this.__id, uid: elem[1] })));
     return out;
   },
   get parent() { var p = this.__info().parent; return p === null ? null : __layer(this.__comp, p); },
@@ -1205,7 +1209,7 @@ Layer.prototype = {
     var before = this.containingComp.__info().layers;
     __call("edit.duplicate", this.__p());
     var after = this.containingComp.__info().layers;
-    for (var i = 0; i < after.length; i++) if (before.indexOf(after[i]) < 0) return __layer(this.__comp, after[i]);
+    for (const elem of after) if (before.indexOf(elem) < 0) return __layer(this.__comp, elem);
     return null;
   },
   copyToComp: function (comp) {
@@ -1310,7 +1314,7 @@ AVLayer.prototype.constructor = AVLayer;
   // AVLayer.replaceSource). `fixExpressions` is accepted for compatibility: only AV sources are
   // replaced, so the property tree and the layer's name stay and expressions keep resolving.
   P.replaceSource = function (newSource, fixExpressions) {
-    if (!newSource || newSource.__id === undefined) throw __err("replaceSource needs a project item");
+    if (newSource?.__id === undefined) throw __err("replaceSource needs a project item");
     __call("layer.replaceSource", { comp: this.__comp, layers: [this.__id], item: newSource.__id, fixExpressions: !!fixExpressions });
     return null;
   };
@@ -1371,7 +1375,7 @@ LayerCollection.prototype = {
     return layer;
   },
   add: function (item, duration) {
-    if (!item || item.id === undefined) throw __err("add(): expected an item");
+    if (item?.id === undefined) throw __err("add(): expected an item");
     var l = this.__new(__call("layer.addItem", { comp: this.__comp, item: item.id, time: 0 }));
     return this.__dur(l, duration);
   },
@@ -1414,15 +1418,15 @@ LayerCollection.prototype = {
   },
   precompose: function (indices, name, moveAllAttributes) {
     var ids = this.__ids(), sel = [];
-    for (var i = 0; i < indices.length; i++) sel.push(ids[indices[i] - 1]);
+    for (const elem of indices) sel.push(ids[elem - 1]);
     var r = __call("layer.precompose", { comp: this.__comp, layers: sel, name: String(name), mode: moveAllAttributes === false ? "leave" : "move" });
     return __item(r.comp);
   },
   byName: function (name) {
     var ids = this.__ids();
-    for (var i = 0; i < ids.length; i++) {
-      var l = __get("layer", { comp: this.__comp, layer: ids[i] });
-      if (l.name === name) return __layer(this.__comp, ids[i]);
+    for (const elem of ids) {
+      var l = __get("layer", { comp: this.__comp, layer: elem });
+      if (l.name === name) return __layer(this.__comp, elem);
     }
     return null;
   },
@@ -1493,7 +1497,7 @@ Item.prototype = {
   get label() { return this.__info().label; },
   set label(v) { __call("project.setLabel", { items: [this.__id], label: __num(v, "label") }); },
   get parentFolder() { return __item(this.__info().parent); },
-  set parentFolder(f) { __call("project.move", { items: [this.__id], folder: f && f.__id ? f.__id : null }); },
+  set parentFolder(f) { __call("project.move", { items: [this.__id], folder: f?.__id ? f.__id : null }); },
   get selected() { return this.__info().selected; },
   set selected(v) {
     var selection = __get("project").selection;
@@ -1527,7 +1531,7 @@ AVItem.prototype = Object.create(Item.prototype);
   def("hasVideo", function () { return this.__info().hasVideo; });
   def("hasAudio", function () { return this.__info().hasAudio; });
   def("footageMissing", function () { return !!this.__info().footageMissing; });
-  def("useProxy", function () { var p = this.__info().proxy; return !!(p && p.enabled); }, function (v) {
+  def("useProxy", function () { var p = this.__info().proxy; return !!p?.enabled; }, function (v) {
     if (!this.__info().proxy) throw __err("\"" + this.name + "\" has no proxy");
     __call("file.useProxy", { item: this.__id, on: !!v });
   });
@@ -1564,9 +1568,9 @@ CompItem.prototype.constructor = CompItem;
   });
   def("activeCamera", function () {
     var ids = this.__info().layers;
-    for (var i = 0; i < ids.length; i++) {
-      var l = __get("layer", { comp: this.__id, layer: ids[i] });
-      if (l.kind === "camera" && l.enabled && l.active) return __layer(this.__id, ids[i]);
+    for (const elem of ids) {
+      var l = __get("layer", { comp: this.__id, layer: elem });
+      if (l.kind === "camera" && l.enabled && l.active) return __layer(this.__id, elem);
     }
     return null;
   });
@@ -1606,7 +1610,7 @@ CompItem.prototype.constructor = CompItem;
       if (a < 1 || a > ids.length || Math.floor(a) !== a) throw __err("layer index " + a + " is out of range 1.." + ids.length);
       return __layer(this.__id, ids[a - 1]);
     }
-    if (a && a.__id !== undefined && typeof b === "number") {
+    if (a?.__id !== undefined && typeof b === "number") {
       var j = a.index + b;
       return j >= 1 && j <= ids.length ? __layer(this.__id, ids[j - 1]) : null;
     }
@@ -1619,9 +1623,9 @@ CompItem.prototype.constructor = CompItem;
   P.__controllers = function () {
     var out = [];
     (function walk(list) {
-      for (var i = 0; i < list.length; i++) {
-        if (list[i].kind === "property" || list[i].kind === "mirror" || list[i].kind === "media") out.push(list[i]);
-        if (list[i].children) walk(list[i].children);
+      for (const elem of list) {
+        if (elem.kind === "property" || elem.kind === "mirror" || elem.kind === "media") out.push(elem);
+        if (elem.children) walk(elem.children);
       }
     })(this.__eg().controls);
     return out;
@@ -1702,7 +1706,8 @@ Object.defineProperty(FootageItem.prototype, "mainSource", {
     return this.__mainSource;
   },
 });
-FootageItem.prototype.replace = function (f) { __call("file.replaceFootage", { item: this.__id, path: __str(f) }); };
+// replace() swaps in one file, even a numbered still (replaceWithSequence brings a run), as in After Effects.
+FootageItem.prototype.replace = function (f) { __call("file.replaceFootage", { item: this.__id, path: __str(f), sequence: false }); };
 FootageItem.prototype.replaceWithSequence = function (f, forceAlphabetical) {
   __call("file.replaceFootage", { item: this.__id, path: __str(f), sequence: true, alphabetical: !!forceAlphabetical });
 };
@@ -1732,7 +1737,7 @@ FolderItem.prototype.constructor = FolderItem;
   Object.defineProperty(P, "numItems", { get: function () { return new ItemCollection(this.__id).length; } });
   Object.defineProperty(P, "parentFolder", {
     get: function () { return this.__id === 0 ? null : __item(this.__info().parent); },
-    set: function (f) { __call("project.move", { items: [this.__id], folder: f && f.__id ? f.__id : null }); },
+    set: function (f) { __call("project.move", { items: [this.__id], folder: f?.__id ? f.__id : null }); },
   });
   P.item = function (i) {
     var v = new ItemCollection(this.__id).__at(__num(i, "index"));
@@ -1776,7 +1781,7 @@ RenderQueueItem.prototype = {
   constructor: RenderQueueItem,
   __info: function () {
     var l = __call("renderQueue.list", {}).items;
-    for (var i = 0; i < l.length; i++) if (l[i].id === this.__id) return l[i];
+    for (const elem of l) if (elem.id === this.__id) return elem;
     throw __err("the render queue item no longer exists");
   },
   get comp() { return __item(this.__info().comp); },
@@ -1812,7 +1817,7 @@ RenderQueueItem.prototype = {
     var before = __call("renderQueue.list", {}).items.map(function (i) { return i.id; });
     __call("renderQueue.duplicate", { item: this.__id });
     var after = __call("renderQueue.list", {}).items;
-    for (var i = 0; i < after.length; i++) if (before.indexOf(after[i].id) < 0) return new RenderQueueItem(after[i].id);
+    for (const elem of after) if (before.indexOf(elem.id) < 0) return new RenderQueueItem(elem.id);
     return null;
   },
   applyTemplate: function () {},
@@ -1945,9 +1950,9 @@ Project.prototype = {
       }
     }
     var r = __call("file.import", args);
-    if (r.errors && r.errors.length) throw __err(r.errors.join("; "));
+    if (r.errors?.length) throw __err(r.errors.join("; "));
     // Composition imports create several footage items, but callers need the comp.
-    return __item(r.comps && r.comps.length ? r.comps[0] : r.items[0]);
+    return __item(r.comps?.length ? r.comps[0] : r.items[0]);
   },
   importFileWithDialog: function () { return null; },
   importPlaceholder: function (name, w, h, rate, dur) {
diff --git a/crates/script/src/runtime.rs b/crates/script/src/runtime.rs
index 192da5740..2c18039e8 100644
--- a/crates/script/src/runtime.rs
+++ b/crates/script/src/runtime.rs
@@ -126,7 +126,7 @@ pub(crate) fn js_str(s: &str) -> JsValue {
 fn native_exec(_: &JsValue, args: &[JsValue], ctx: &mut Context) -> JsResult<JsValue> {
     let id = arg_string(args, 0, ctx)?;
     let mut params = arg_json(args, 1, ctx)?;
-    if id == "script.run" || id == "file.runScript" {
+    if effectcraft_engine::commands::scripts::RUNS_SCRIPTS.contains(&id.as_str()) {
         return Err(throw("scripts can't run scripts"));
     }
     let keys = params.as_object_mut().and_then(|o| o.remove("__keys"));
@@ -710,7 +710,7 @@ pub(crate) fn outcome(output: Vec<String>, result: Result<J, ScriptError>) -> Ou
 /// don't block.
 ///
 /// ExtendScript's `#include` / `#includepath` are inlined first, and errors point at the file
-/// and line they came from ([`crate::include`]).
+/// and line they came from (`crate::include`).
 pub fn run(session: &mut Session, req: &ScriptRequest) -> Outcome {
     let expanded = match crate::include::expand(session, req.code, req.name) {
         Ok(x) => x,
diff --git a/crates/script/src/scriptui.js b/crates/script/src/scriptui.js
index 52c65efb6..ddfbc1f3e 100644
--- a/crates/script/src/scriptui.js
+++ b/crates/script/src/scriptui.js
@@ -213,7 +213,7 @@ function __uiResPlain(v) {
   if (v instanceof Array) return v.map(__uiResPlain);
   if (v && typeof v === "object" && v.__object) {
     var o = {};
-    for (var k = 0; k < v.__object.length; k++) o[v.__object[k][0]] = __uiResPlain(v.__object[k][1]);
+    for (const elem of v.__object) o[elem[0]] = __uiResPlain(elem[1]);
     return o;
   }
   return v;
@@ -222,8 +222,8 @@ function __uiResPlain(v) {
 // A resource's own properties and its child elements (in source order).
 function __uiResProps(res) {
   var props = {}, kids = [];
-  for (var k = 0; k < res.list.length; k++) {
-    var e = res.list[k];
+  for (const elem2 of res.list) {
+    var e = elem2;
     if (e[1] && typeof e[1] === "object" && e[1].__element) kids.push([e[0], { type: e[1].__element, list: e[1].list }]);
     else props[e[0]] = __uiResPlain(e[1]);
   }
@@ -239,17 +239,17 @@ function __uiApplyRes(c, res) {
   // Ranges before values, items before selections.
   if (props.minvalue !== undefined) c.minvalue = __num(props.minvalue);
   if (props.maxvalue !== undefined) c.maxvalue = __num(props.maxvalue);
-  if (props.items instanceof Array && c.items) for (var n = 0; n < props.items.length; n++) c.add("item", props.items[n]);
+  if (props.items instanceof Array && c.items) for (const elem of props.items) c.add("item", elem);
   for (var k in props) {
     if (__uiResSkip[k]) continue;
     var v = props[k];
     if (__uiSizes[k] && v instanceof Array) v = __dim(v[0], v[1]);
     c[k] = v;
   }
-  for (var j = 0; j < pk.kids.length; j++) {
-    var child = __uiAddRes(c, pk.kids[j][1]);
-    child.__key = pk.kids[j][0];
-    c[pk.kids[j][0]] = child;
+  for (const elem of pk.kids) {
+    var child = __uiAddRes(c, elem[1]);
+    child.__key = elem[0];
+    c[elem[0]] = child;
   }
   return c;
 }
@@ -268,7 +268,7 @@ Window.alert = function (s) { alert(s); };
 Window.confirm = function (s) { return confirm(s); };
 Window.prompt = function (m, d) { return prompt(m, d); };
 Window.find = function (type, title) {
-  for (var i = 0; i < __uiWins.length; i++) if (__uiWins[i].text === title) return __uiWins[i];
+  for (const elem of __uiWins) if (elem.text === title) return elem;
   return null;
 };
 
@@ -335,7 +335,7 @@ function __uiColor(c) {
   return null;
 }
 function __uiFontSize(f, g) {
-  var x = f && f.size !== undefined ? Number(f.size) : g && g.font && g.font.size !== undefined ? Number(g.font.size) : 12;
+  var x = f?.size !== undefined ? Number(f.size) : g?.font && g.font.size !== undefined ? Number(g.font.size) : 12;
   return x > 0 ? x : 12;
 }
 
@@ -371,11 +371,11 @@ function __uiGraphics() {
       this.__push({ op: "fill", color: brush ? brush.color : null, path: (path || this.currentPath).slice() });
     },
     strokePath: function (pen, path) {
-      this.__push({ op: "stroke", color: pen ? pen.color : null, width: pen && pen.lineWidth !== undefined ? pen.lineWidth : 1, path: (path || this.currentPath).slice() });
+      this.__push({ op: "stroke", color: pen ? pen.color : null, width: pen?.lineWidth !== undefined ? pen.lineWidth : 1, path: (path || this.currentPath).slice() });
     },
     drawString: function (text, pen, x, y, font) {
       var f = font || this.font;
-      this.__push({ op: "text", text: String(text), color: pen ? pen.color : null, x: __num(x || 0), y: __num(y || 0), size: __uiFontSize(f, this), style: String(f && f.style !== undefined ? f.style : "") });
+      this.__push({ op: "text", text: String(text), color: pen ? pen.color : null, x: __num(x || 0), y: __num(y || 0), size: __uiFontSize(f, this), style: String(f?.style !== undefined ? f.style : "") });
     },
     drawOSControl: function () { this.__push({ op: "os" }); },
     drawImage: function (img, x, y, w, h) { this.__push({ op: "image", image: __uiImageJson(img), x: __num(x || 0), y: __num(y || 0), w: w === undefined ? 0 : __num(w), h: h === undefined ? 0 : __num(h) }); },
@@ -384,7 +384,7 @@ function __uiGraphics() {
       var size = __uiFontSize(font, this);
       var lines = String(s).split("\n");
       var cw = size * 0.58, w = 0;
-      for (var i = 0; i < lines.length; i++) w = Math.max(w, Math.ceil(lines[i].length * cw));
+      for (const elem of lines) w = Math.max(w, Math.ceil(elem.length * cw));
       var n = lines.length;
       if (boundaryWidth > 0 && w > boundaryWidth) {
         n = Math.ceil(w / boundaryWidth) + lines.length - 1;
@@ -405,14 +405,14 @@ function __uiRunDraws(win) {
   })(win);
   if (!drawn.length) return;
   __uiLayout(win);
-  for (var k = 0; k < drawn.length; k++) {
-    var c = drawn[k];
+  for (const elem of drawn) {
+    var c = elem;
     c.__draw = [];
     c.graphics.__rec = c.__draw;
     try {
       c.onDraw.call(c, { type: "draw", target: c });
     } catch (e) {
-      try { writeLn("onDraw: " + (e && e.message ? e.message : e)); } catch (e2) {}
+      try { writeLn("onDraw: " + (e?.message ? e.message : e)); } catch (e2) {}
     }
     c.graphics.__rec = null;
   }
@@ -498,7 +498,7 @@ function __uiProto() {
       var arg = t === "image" || t === "iconbutton" ? text : typeof text === "object" && text !== null && !(text instanceof Array) ? "" : text;
       __uiInit(c, t, this.window, this, bounds, arg, props);
       if ((t === "dropdownlist" || t === "listbox") && text instanceof Array) {
-        for (var i = 0; i < text.length; i++) c.add("item", text[i]);
+        for (const elem of text) c.add("item", elem);
         c.text = "";
       }
       if (t === "slider" || t === "scrollbar") {
@@ -521,7 +521,7 @@ function __uiProto() {
       if (t === "checkbox" || t === "radiobutton") c.value = false;
       if (t === "edittext" && c.properties.multiline) c.__multiline = true;
       if (t === "edittext" && c.properties.readonly) c.__readonly = true;
-      if (c.properties && c.properties.name) c.name = c.properties.name;
+      if (c.properties?.name) c.name = c.properties.name;
       this.children.push(c);
       if (t === "tab" && this.type === "tabbedpanel" && this.__sel.length === 0) this.__sel = [this.children.length - 1];
       return c;
@@ -608,21 +608,21 @@ function __uiProto() {
     removeEventListener: function (name, fn, capture) {
       var k = String(name).toLowerCase();
       var m = capture ? this.__capture : this.__listeners;
-      if (m && m[k]) m[k] = m[k].filter(function (f) { return f !== fn; });
+      if (m?.[k]) m[k] = m[k].filter(function (f) { return f !== fn; });
     },
     dispatchEvent: function (e) { this.__fire("on" + String(e.type || e).charAt(0).toUpperCase() + String(e.type || e).slice(1)); },
     __fire: function (name) {
       var r;
       if (typeof this[name] === "function") r = this[name].call(this);
       var l = this.__listeners[name.slice(2).toLowerCase()];
-      if (l) for (var i = 0; i < l.length; i++) l[i].call(this, { type: name.slice(2).toLowerCase(), target: this });
+      if (l) for (const elem of l) elem.call(this, { type: name.slice(2).toLowerCase(), target: this });
       return r;
     },
     __handlers: function () {
       var out = [];
       var names = ["onClick", "onChange", "onChanging", "onDoubleClick", "onClose", "onShow", "onActivate", "onDeactivate", "onResize", "onDraw"];
-      for (var i = 0; i < names.length; i++) {
-        var n = names[i];
+      for (const elem of names) {
+        var n = elem;
         if (typeof this[n] === "function" || (this.__listeners[n.slice(2).toLowerCase()] || []).length) out.push(n);
       }
       return out;
@@ -634,8 +634,8 @@ function __uiProto() {
 (function () {
   var all = ["Window", "Panel", "Group", "Button", "IconButton", "StaticText", "EditText", "Checkbox", "RadioButton", "Slider",
     "Scrollbar", "Progressbar", "DropDownList", "ListBox", "TabbedPanel", "Tab", "ScriptUIImage"];
-  for (var i = 0; i < all.length; i++) {
-    var C = __ecGlobal[all[i]];
+  for (const elem of all) {
+    var C = __ecGlobal[elem];
     var p = __uiProto();
     for (var k in p) C.prototype[k] = p[k];
     Object.defineProperty(C.prototype, "bounds", {
@@ -737,15 +737,16 @@ function __uiMouseListeners(c, type, capture) {
 // The mouse events that reach a listener at `c`: its own, and its containers' (`inherited`).
 function __uiMouseWanted(c, inherited) {
   var out = inherited.slice();
-  for (var i = 0; i < __uiMouseKinds.length; i++) {
-    var t = __uiMouseKinds[i];
+  for (const elem of __uiMouseKinds) {
+    var t = elem;
     if (out.indexOf(t) < 0 && (__uiMouseListeners(c, t, false).length || __uiMouseListeners(c, t, true).length)) out.push(t);
   }
   return out;
 }
 
 // A ScriptUI MouseEvent. `v`: {x, y (relative to the target control), button (0 left, 1 middle,
-// 2 right), detail (click count), screenX, screenY, altKey, ctrlKey, metaKey, shiftKey}.
+// 2 right), buttons (held: 1 left, 2 right, 4 middle), detail (click count), screenX, screenY,
+// altKey, ctrlKey, metaKey, shiftKey}.
 function __uiMouseEvent(type, target, v) {
   var num = function (x, d) {
     x = Number(x);
@@ -765,6 +766,7 @@ function __uiMouseEvent(type, target, v) {
     timeStamp: new Date(),
     detail: num(v.detail, type === "mousemove" || type === "mouseover" || type === "mouseout" ? 0 : 1),
     button: num(v.button, 0),
+    buttons: num(v.buttons, 0),
     clientX: num(v.x, 0),
     clientY: num(v.y, 0),
     screenX: num(v.screenX, 0),
@@ -793,7 +795,7 @@ function __uiMouseFire(target, type, v) {
     var l = __uiMouseListeners(c, type, capture);
     e.currentTarget = c;
     e.eventPhase = phase;
-    for (var i = 0; i < l.length; i++) if (typeof l[i] === "function") l[i].call(c, e);
+    for (const elem of l) if (typeof elem === "function") elem.call(c, e);
   };
   var n = path.length - 1;
   for (var i = 0; i < n; i++) {
@@ -832,7 +834,7 @@ function __uiJson(c, inherited) {
     if (m) o.margins = m;
     if (typeof c.spacing === "number") o.spacing = c.spacing;
     var kids = c.children;
-    for (var i = 0; i < kids.length; i++) o.children.push(__uiJson(kids[i], mouse));
+    for (const elem of kids) o.children.push(__uiJson(elem, mouse));
   }
   if (c.alignment !== null && c.alignment !== undefined) o.alignment = __uiAlign(c.alignment);
   if (c.type === "checkbox" || c.type === "radiobutton") o.checked = !!c.value;
@@ -859,8 +861,8 @@ function __uiJson(c, inherited) {
 // The open windows of this script, for the host.
 function __uiSnapshot() {
   var out = [];
-  for (var i = 0; i < __uiWins.length; i++) {
-    var w = __uiWins[i];
+  for (const elem of __uiWins) {
+    var w = elem;
     if (w.__shown && !w.__closed) __uiRunDraws(w);
     out.push({ id: w.__wid, kind: w.__kind, title: String(w.text || ""), visible: !!w.__shown && !w.__closed, modal: !!w.__modal, root: __uiJson(w) });
   }
@@ -871,12 +873,12 @@ function __uiSnapshot() {
 
 function __uiOpenCount() {
   var n = 0;
-  for (var i = 0; i < __uiWins.length; i++) if (__uiWins[i].__shown && !__uiWins[i].__closed) n++;
+  for (const elem of __uiWins) if (elem.__shown && !elem.__closed) n++;
   return n;
 }
 
 function __uiWin(id) {
-  for (var i = 0; i < __uiWins.length; i++) if (__uiWins[i].__wid === id) return __uiWins[i];
+  for (const elem of __uiWins) if (elem.__wid === id) return elem;
   return null;
 }
 function __uiFind(c, id) {
@@ -910,11 +912,23 @@ function __uiDispatch(winId, id, kind, valueJson) {
     w.close(v === null ? 2 : v);
     return;
   }
+  // The host gave the window a new size (a docked panel's dock): take it, lay out, tell the script.
+  if (kind === "resize") {
+    var nw = Number(v && v[0]), nh = Number(v && v[1]);
+    var b = w.__ub || w.__lb;
+    if (nw > 0 && nh > 0 && (b[2] - b[0] !== nw || b[3] - b[1] !== nh)) {
+      w.__ub = [b[0], b[1], b[0] + nw, b[1] + nh];
+      __uiLayout(w);
+      w.__fire("onResizing");
+      w.__fire("onResize");
+    }
+    return;
+  }
   var c = __uiFind(w, id);
   if (!c || c.enabled === false) return;
   var radio = function () {
     var sib = c.parent ? c.parent.children : [];
-    for (var i = 0; i < sib.length; i++) if (sib[i] !== c && sib[i].type === "radiobutton") sib[i].value = false;
+    for (const elem of sib) if (elem !== c && elem.type === "radiobutton") elem.value = false;
     c.value = true;
   };
   // A mouse click carries the pointer's details ({x, y, button, detail, …keys}).
diff --git a/crates/script/src/socket.rs b/crates/script/src/socket.rs
index 6b2976dc1..c024fcad5 100644
--- a/crates/script/src/socket.rs
+++ b/crates/script/src/socket.rs
@@ -55,7 +55,7 @@ mod imp {
     use std::sync::{Arc, Mutex};
     use std::time::{Duration, Instant};
 
-    use super::*;
+    use super::{J, err, json};
 
     enum Sock {
         Stream { s: TcpStream, buf: Vec<u8>, eof: bool },
@@ -394,19 +394,33 @@ mod tests {
 
     /// Fill bounded socket buffers nonblocking, rather than assuming a 64 MiB write stalls.
     /// In particular, Windows may accept that entire write with its default send buffering.
+    /// Writes must stay blocked for [`SETTLED`] before the buffers count as full: on macOS the
+    /// accepted stream does not keep the listener's 4 KiB receive buffer (it gets about 114 KiB),
+    /// so the first `WouldBlock` only means the 4 KiB send buffer is full, and the send buffer then
+    /// drains into the peer's larger receive buffer.
     fn backpressure(id: u32) {
+        const SETTLED: Duration = Duration::from_millis(200);
         let mut stream = super::imp::test_stream(id);
         socket2::SockRef::from(&stream).set_send_buffer_size(4096).unwrap();
         stream.set_nonblocking(true).unwrap();
         let start = Instant::now();
         let chunk = [b'x'; 4096];
         let mut sent = 0;
+        let mut blocked_since = None;
         loop {
             assert!(sent < 16 * 1024 * 1024 && start.elapsed() < Duration::from_secs(5), "could not establish backpressure");
             match stream.write(&chunk) {
                 Ok(0) => panic!("peer closed while establishing backpressure"),
-                Ok(n) => sent += n,
-                Err(e) if e.kind() == ErrorKind::WouldBlock => break,
+                Ok(n) => {
+                    sent += n;
+                    blocked_since = None;
+                }
+                Err(e) if e.kind() == ErrorKind::WouldBlock => {
+                    if blocked_since.get_or_insert_with(Instant::now).elapsed() >= SETTLED {
+                        break;
+                    }
+                    std::thread::sleep(Duration::from_millis(5));
+                }
                 Err(e) if e.kind() == ErrorKind::Interrupted => continue,
                 Err(e) => panic!("establishing backpressure: {e}"),
             }
diff --git a/crates/script/src/tests.rs b/crates/script/src/tests.rs
index 82f8ad289..eefa017f0 100644
--- a/crates/script/src/tests.rs
+++ b/crates/script/src/tests.rs
@@ -10,6 +10,19 @@ use serde_json::{Value, json};
 
 use crate::{Outcome, run_code};
 
+mod callable;
+mod ease_presets;
+mod evalfile;
+mod include;
+mod panels;
+#[cfg(not(windows))]
+mod services;
+mod startup;
+mod tasks;
+mod ui;
+mod ui_more;
+mod ui_mouse;
+
 fn session() -> Session {
     let mut s = Session { expr: Some(Arc::new(effectcraft_expr::Expressions)), expr_check: Some(effectcraft_expr::check_syntax), ..Default::default() };
     crate::install(&mut s);
@@ -258,6 +271,97 @@ fn an_undefined_name_mentioned_earlier_reports_its_use_in_the_reading_function()
     assert_eq!(e.line, Some(6), "{e:?}");
 }
 
+/// Scripts reach Wiggle Paths' properties, Spatial Phase included, by their match names.
+#[test]
+fn wiggle_paths_properties_by_match_name() {
+    let mut s = session();
+    let o = ok(
+        &mut s,
+        r#"
+        var c = app.project.items.addComp("W", 200, 200, 1, 2, 30);
+        var sh = c.layers.addShape();
+        var w = sh.property("ADBE Root Vectors Group").addProperty("ADBE Vector Filter - Roughen");
+        w.property("ADBE Vector Spatial Phase").setValue(45);
+        var names = [];
+        for (var i = 1; i <= w.numProperties; i++) names.push(w.property(i).matchName);
+        [w.matchName, w.property("ADBE Vector Spatial Phase").name, names]
+        "#,
+    );
+    assert_eq!(
+        o.result,
+        json!([
+            "ADBE Vector Filter - Roughen",
+            "Spatial Phase",
+            [
+                "ADBE Vector Roughen Size",
+                "ADBE Vector Roughen Detail",
+                "ADBE Vector Roughen Points",
+                "ADBE Vector Temporal Freq",
+                "ADBE Vector Correlation",
+                "ADBE Vector Temporal Phase",
+                "ADBE Vector Spatial Phase",
+                "ADBE Vector Random Seed"
+            ]
+        ])
+    );
+    let (_, c) = comp_named(&s, "W");
+    let sh = c.layers.iter().find(|l| l.props.sub("contents").is_some()).unwrap();
+    assert_eq!(sh.props.prop("contents/wiggle/spatialPhase").unwrap().value, KV::Scalar(45.0));
+}
+
+/// Scripts reach Offset Paths' and Zig Zag's properties by their match names.
+#[test]
+fn offset_paths_and_zig_zag_properties_by_match_name() {
+    let mut s = session();
+    let o = ok(
+        &mut s,
+        r#"
+        var c = app.project.items.addComp("O", 200, 200, 1, 2, 30);
+        var sh = c.layers.addShape();
+        var root = sh.property("ADBE Root Vectors Group");
+        root.addProperty("ADBE Vector Filter - Offset");
+        root.addProperty("ADBE Vector Filter - Zigzag");
+        var o = root.property("ADBE Vector Filter - Offset");
+        var z = root.property("ADBE Vector Filter - Zigzag");
+        var on = ["ADBE Vector Offset Amount", "ADBE Vector Offset Line Join", "ADBE Vector Offset Miter Limit",
+                  "ADBE Vector Offset Copies", "ADBE Vector Offset Copy Offset"];
+        var zn = ["ADBE Vector Zigzag Size", "ADBE Vector Zigzag Detail", "ADBE Vector Zigzag Points"];
+        var names = [];
+        for (var i = 0; i < on.length; i++) names.push([o.property(on[i]).matchName, o.property(on[i]).name]);
+        for (var j = 0; j < zn.length; j++) names.push([z.property(zn[j]).matchName, z.property(zn[j]).name]);
+        var before = [o.property("ADBE Vector Offset Amount").value, o.property("ADBE Vector Offset Line Join").value,
+                      z.property("ADBE Vector Zigzag Points").value];
+        o.property("ADBE Vector Offset Amount").setValue(-6);
+        o.property("ADBE Vector Offset Copies").setValue(3);
+        z.property("ADBE Vector Zigzag Detail").setValue(8);
+        [names, before, o.property("ADBE Vector Offset Nope") === null, z.property("ADBE Vector Zigzag Nope") === null]
+        "#,
+    );
+    assert_eq!(
+        o.result,
+        json!([
+            [
+                ["ADBE Vector Offset Amount", "Amount"],
+                ["ADBE Vector Offset Line Join", "Line Join"],
+                ["ADBE Vector Offset Miter Limit", "Miter Limit"],
+                ["ADBE Vector Offset Copies", "Copies"],
+                ["ADBE Vector Offset Copy Offset", "Copy Offset"],
+                ["ADBE Vector Zigzag Size", "Size"],
+                ["ADBE Vector Zigzag Detail", "Ridges per segment"],
+                ["ADBE Vector Zigzag Points", "Points"]
+            ],
+            [10, 1, 1],
+            true,
+            true
+        ])
+    );
+    let (_, c) = comp_named(&s, "O");
+    let sh = c.layers.iter().find(|l| l.props.sub("contents").is_some()).unwrap();
+    assert_eq!(sh.props.prop("contents/offset/amount").unwrap().value, KV::Scalar(-6.0));
+    assert_eq!(sh.props.prop("contents/offset/copies").unwrap().value, KV::Scalar(3.0));
+    assert_eq!(sh.props.prop("contents/zigzag/ridges").unwrap().value, KV::Scalar(8.0));
+}
+
 #[test]
 fn match_names_and_lookups() {
     let mut s = session();
@@ -321,6 +425,31 @@ fn match_names_and_lookups() {
     assert_eq!(sh.props.prop("contents/#1/contents/fill/color").unwrap().value, KV::Color([1.0, 0.0, 0.0, 1.0]));
 }
 
+/// Scripts add a Wiggle Transform by its match name or display name and reach its properties.
+#[test]
+fn wiggle_transform_by_match_name() {
+    let mut s = session();
+    let o = ok(
+        &mut s,
+        r#"
+        var c = app.project.items.addComp("W", 200, 200, 1, 2, 30);
+        var sh = c.layers.addShape();
+        var root = sh.property("ADBE Root Vectors Group");
+        var w = root.addProperty("ADBE Vector Filter - Wiggler");
+        var byName = root.addProperty("Wiggle Transform");
+        w.property("ADBE Vector Wiggler Transform").property("Position").setValue([20, 10]);
+        [
+          w.matchName, w.name, byName.matchName, w.property("ADBE Vector Xform Temporal Freq").value,
+          w.property("ADBE Vector Spatial Phase").name, w.property("ADBE Vector Wiggler Transform").name
+        ]
+        "#,
+    );
+    assert_eq!(o.result, json!(["ADBE Vector Filter - Wiggler", "Wiggle Transform 1", "ADBE Vector Filter - Wiggler", 2, "Spatial Phase", "Transform"]));
+    let (_, c) = comp_named(&s, "W");
+    let sh = c.layers.iter().find(|l| l.props.sub("contents").is_some()).unwrap();
+    assert_eq!(sh.props.prop("contents/wiggler/transform/position").unwrap().value, KV::Vec2([20.0, 10.0]));
+}
+
 #[test]
 fn keyframes_eases_and_interpolation() {
     let mut s = session();
@@ -444,6 +573,38 @@ fn layers_items_and_markers() {
     );
 }
 
+#[test]
+fn folder_paths_trim_trailing_separators() {
+    let mut s = session();
+    let o = ok(
+        &mut s,
+        r#"
+        var paths = ['', '/', '///', 'a/b/', 'a\\b\\/', 'a/b', 'a/\n'];
+        var result = paths.map(function (path) {
+          var folder = new Folder(path);
+          return [folder.name, folder.path, __join(path, 'child')];
+        });
+        // A long run followed by a non-separator used to cause quadratic regex backtracking.
+        var longPath = Array(20001).join('/') + 'x';
+        result.push([new Folder(longPath).name, new Folder(longPath).path.length, __join(longPath, 'child').length]);
+        result
+        "#,
+    );
+    assert_eq!(
+        o.result,
+        json!([
+            ["", "", "/child"],
+            ["", "", "/child"],
+            ["", "", "/child"],
+            ["b", "a", "a/b/child"],
+            ["b", "a", "a\\b/child"],
+            ["b", "a", "a/b/child"],
+            ["\n", "a", "a/\n/child"],
+            ["x", 19999, 20007]
+        ])
+    );
+}
+
 #[test]
 fn security_gate_for_files() {
     let dir = std::env::temp_dir().join(format!("ec-script-gate-{}", std::process::id()));
@@ -980,6 +1141,11 @@ fn footage_proxies_sequences_and_conform_rate() {
     let paths: Vec<String> =
         s.project.items.values().filter_map(|i| if let ItemKind::Footage(f) = &i.kind { Some(f.path.replace('\\', "/")) } else { None }).collect();
     assert!(paths.iter().any(|f| f.contains("take_")), "replaced with the take sequence: {paths:?}");
+    // replace() swaps in the one file, even a numbered still, as in After Effects.
+    ok(&mut s, &format!("app.project.item(1).replace(new File('{}'))", p("shot_0002.png")));
+    let kinds: Vec<_> =
+        s.project.items.values().filter_map(|i| if let ItemKind::Footage(f) = &i.kind { Some((f.kind, f.path.replace('\\', "/"))) } else { None }).collect();
+    assert!(kinds.iter().any(|(k, f)| *k == effectcraft_engine::project::FootageKind::Still && f.ends_with("shot_0002.png")), "{kinds:?}");
     let _ = std::fs::remove_dir_all(&dir);
 }
 
@@ -1637,6 +1803,50 @@ fn layer_property_resolves_transform_and_source_text_shortcuts() {
     assert_eq!(layer(c, "s").props.prop("transform/opacity").unwrap().value, KV::Scalar(25.0));
 }
 
+/// A text animator property added by its After Effects name is the one asked for, not its Tracking
+/// Type companion, and it can be found again by that name (#1063).
+#[test]
+fn scripted_text_animator_property_is_the_one_asked_for() {
+    let mut s = session();
+    let o = ok(
+        &mut s,
+        r#"
+        var c = app.project.items.addComp("Track", 960, 300, 1, 3, 30);
+        var t = c.layers.addText("MOVARA");
+        var a = t.property("ADBE Text Properties").property("ADBE Text Animators").addProperty("ADBE Text Animator");
+        var props = a.property("ADBE Text Animator Properties");
+        var added = props.addProperty("ADBE Text Tracking Amount");
+        added.setValue(20);
+        [added.name, props.property("ADBE Text Tracking Amount").value, props.property("ADBE Text Tracking Amount").name,
+         added.matchName, props.property(added.matchName).propertyIndex]
+        "#,
+    );
+    assert_eq!(o.result, json!(["Tracking Amount", 20, "Tracking Amount", "ADBE Text Tracking Amount", 2]));
+}
+
+/// The companion properties added with Tracking and Skew are found by their After Effects names,
+/// but cannot be added on their own (#1063).
+#[test]
+fn text_animator_companion_properties_resolve_by_name() {
+    let mut s = session();
+    let o = ok(
+        &mut s,
+        r#"
+        var c = app.project.items.addComp("Track", 960, 300, 1, 3, 30);
+        var t = c.layers.addText("MOVARA");
+        var props = t.property("ADBE Text Properties").property("ADBE Text Animators").addProperty("ADBE Text Animator").property("ADBE Text Animator Properties");
+        props.addProperty("ADBE Text Tracking Amount");
+        props.addProperty("ADBE Text Skew");
+        var type = props.property("ADBE Text Track Type");
+        var axis = props.property("ADBE Text Skew Axis");
+        var added = "";
+        try { props.addProperty("ADBE Text Track Type"); added = "added"; } catch (e) { added = "refused"; }
+        [type ? type.matchName : null, axis ? axis.matchName : null, added]
+        "#,
+    );
+    assert_eq!(o.result, json!(["ADBE Text Track Type", "ADBE Text Skew Axis", "refused"]));
+}
+
 /// #1936: an array whose length doesn't match the property's dimension is an error in After
 /// Effects, not a value to truncate or broadcast. Two values for a 3-D property stay legal.
 #[test]
diff --git a/crates/script/src/tests_callable.rs b/crates/script/src/tests/callable.rs
similarity index 100%
rename from crates/script/src/tests_callable.rs
rename to crates/script/src/tests/callable.rs
diff --git a/crates/script/src/tests_ease_presets.rs b/crates/script/src/tests/ease_presets.rs
similarity index 94%
rename from crates/script/src/tests_ease_presets.rs
rename to crates/script/src/tests/ease_presets.rs
index 009cc59c6..f075250b2 100644
--- a/crates/script/src/tests_ease_presets.rs
+++ b/crates/script/src/tests/ease_presets.rs
@@ -608,3 +608,37 @@ fn presets_saved_by_the_old_core_panel_carry_over() {
     let win = open_panel(&mut s);
     assert_eq!(control(&mut s, win, "presets")["items"].as_array().unwrap().len(), 12);
 }
+
+/// #2465: the Linear preset sets Linear interpolation on every side it applies to, including the
+/// unused first-in and last-out sides; editing its speeds makes a Bezier curve.
+#[test]
+fn the_linear_preset_sets_linear_interpolation_and_edited_speeds_give_bezier() {
+    let store = Arc::new(MemoryConfig::default());
+    let mut s = session(&store);
+    let l = setup(&mut s);
+    animate(&mut s, l, "transform/opacity", &[(0.0, json!(0)), (1.0, json!(100)), (3.0, json!(20))]);
+    s.execute("prop.select", json!({"layer": l, "path": "transform/opacity"})).unwrap();
+    let win = open_panel(&mut s);
+    // Start from Bezier keys so Linear has something to restore.
+    ok(
+        &mut s,
+        r#"var p = app.project.activeItem.layer(1).transform.opacity, K = KeyframeInterpolationType;
+        for (var i = 1; i <= p.numKeys; i++) p.setInterpolationTypeAtKey(i, K.BEZIER, K.BEZIER);"#,
+    );
+    let op = prop(&s, l, "transform/opacity");
+    for (i, k) in op.keys.iter().enumerate() {
+        assert_eq!((k.in_interp, k.out_interp), (Interp::Bezier, Interp::Bezier), "initial key {i}");
+    }
+    let steps = s.history.undo.len();
+    set(&mut s, win, "presets", json!("Linear"));
+    assert_eq!(s.history.undo.len(), steps + 1, "one undo step");
+    let op = prop(&s, l, "transform/opacity");
+    for (i, k) in op.keys.iter().enumerate() {
+        assert_eq!((k.in_interp, k.out_interp), (Interp::Linear, Interp::Linear), "key {i}");
+    }
+    // Edited speeds make a custom Bezier curve even though Linear is still the selected preset.
+    select_keys(&mut s, l, &[("transform/opacity", 1.0)]);
+    apply_typed(&mut s, win, "In-Out", [33.0, 2.0, 33.0, 2.0]);
+    let k = &prop(&s, l, "transform/opacity").keys[1];
+    assert_eq!((k.in_interp, k.out_interp), (Interp::Bezier, Interp::Bezier));
+}
diff --git a/crates/script/src/tests_evalfile.rs b/crates/script/src/tests/evalfile.rs
similarity index 100%
rename from crates/script/src/tests_evalfile.rs
rename to crates/script/src/tests/evalfile.rs
diff --git a/crates/script/src/tests_include.rs b/crates/script/src/tests/include.rs
similarity index 100%
rename from crates/script/src/tests_include.rs
rename to crates/script/src/tests/include.rs
diff --git a/crates/script/src/tests_panels.rs b/crates/script/src/tests/panels.rs
similarity index 74%
rename from crates/script/src/tests_panels.rs
rename to crates/script/src/tests/panels.rs
index c398a3a3f..3318d060f 100644
--- a/crates/script/src/tests_panels.rs
+++ b/crates/script/src/tests/panels.rs
@@ -86,3 +86,27 @@ fn open_panels_open_again_at_the_next_launch() {
     let mut s = session(&store);
     assert_eq!(s.execute("window.restoreScriptPanels", json!({})).unwrap(), json!({"opened": [], "failed": []}));
 }
+
+/// A panel in a subfolder (Window ▸ Motion Kit ▸ Animate.jsx) is `Motion Kit/Animate.jsx`: it opens
+/// titled after its file and opens again at the next launch.
+#[test]
+fn a_panel_in_a_subfolder_opens_and_opens_again_at_the_next_launch() {
+    let store = Arc::new(MemoryConfig::default());
+    store.write(&format!("{PANELS_DIR}/Motion Kit/Animate.jsx"), PANEL).unwrap();
+    let mut s = session(&store);
+    let list = s.execute("file.scripts.list", json!({})).unwrap();
+    assert!(list.as_array().unwrap().iter().any(|e| e["name"] == "Motion Kit/Animate.jsx" && e["panel"] == true), "{list}");
+    let r = s.execute("window.scriptPanel", json!({"name": "Motion Kit/Animate.jsx"})).unwrap();
+    let w = s.script_ui.window(r["window"].as_u64().unwrap() as u32).unwrap();
+    assert_eq!((w.kind, w.title.as_str()), (WindowKind::Panel, "Animate"));
+    assert_eq!(remembered(&store), json!({"open": ["Motion Kit/Animate.jsx"]}));
+    // A saved name that leaves the folder, or goes two folders deep, fails and is forgotten.
+    store.write(OPEN_PANELS_FILE, &json!({"open": ["../Top.jsx", "Motion Kit/Animate.jsx", "a/b/c.jsx"]}).to_string()).unwrap();
+    drop(s);
+    let mut s = session(&store);
+    let r = s.execute("window.restoreScriptPanels", json!({})).unwrap();
+    assert_eq!(r["opened"], json!(["Motion Kit/Animate.jsx"]));
+    assert_eq!(r["failed"].as_array().unwrap().iter().map(|f| f["name"].as_str().unwrap()).collect::<Vec<_>>(), ["../Top.jsx", "a/b/c.jsx"]);
+    assert!(panel_window(&s, "Motion Kit/Animate.jsx").is_some());
+    assert_eq!(remembered(&store), json!({"open": ["Motion Kit/Animate.jsx"]}));
+}
diff --git a/crates/script/src/tests_services.rs b/crates/script/src/tests/services.rs
similarity index 100%
rename from crates/script/src/tests_services.rs
rename to crates/script/src/tests/services.rs
diff --git a/crates/script/src/tests/startup.rs b/crates/script/src/tests/startup.rs
new file mode 100644
index 000000000..67da833c5
--- /dev/null
+++ b/crates/script/src/tests/startup.rs
@@ -0,0 +1,290 @@
+//! Startup and Shutdown scripts, as in After Effects: the scripts in the user's `Scripts/Startup`
+//! and `Scripts/Shutdown` folders (in the settings folder) run in alphabetical order at launch and
+//! as the app quits, after the project is closed.
+
+use std::sync::Arc;
+
+use effectcraft_engine::Session;
+use effectcraft_engine::commands::scripts::{OPEN_PANELS_FILE, PANELS_DIR, SCRIPTS_DIR, SHUTDOWN_DIR, STARTUP_DIR};
+use effectcraft_engine::config::{ConfigStore, MemoryConfig};
+use effectcraft_engine::scriptui::WindowKind;
+use serde_json::json;
+
+fn session(store: &Arc<MemoryConfig>) -> Session {
+    let mut s = Session::default();
+    crate::install(&mut s);
+    s.config = Some(store.clone());
+    s
+}
+
+/// A script that appends `mark` to the `Startup Test` / `order` script setting.
+fn mark(mark: &str) -> String {
+    format!(
+        r#"var k = app.settings.haveSetting("Startup Test", "order") ? app.settings.getSetting("Startup Test", "order") : "";
+app.settings.saveSetting("Startup Test", "order", k + "{mark}");"#
+    )
+}
+
+fn setting(s: &mut Session, key: &str) -> serde_json::Value {
+    s.execute("script.settings.get", json!({"section": "Startup Test", "key": key})).unwrap()["value"].clone()
+}
+
+#[test]
+fn startup_scripts_run_in_alphabetical_order_and_a_failing_one_does_not_stop_the_rest() {
+    let store = Arc::new(MemoryConfig::default());
+    store.write(&format!("{STARTUP_DIR}/b.jsx"), &mark("b")).unwrap();
+    store.write(&format!("{STARTUP_DIR}/A.jsx"), &mark("A")).unwrap();
+    store.write(&format!("{STARTUP_DIR}/B2.jsx"), &mark("B")).unwrap();
+    store.write(&format!("{STARTUP_DIR}/C.js"), "throw new Error('no');").unwrap();
+    store.write(&format!("{STARTUP_DIR}/d.jsx"), &mark("d")).unwrap();
+    // Not scripts, or not in the Startup folder: not run.
+    store.write(&format!("{STARTUP_DIR}/notes.txt"), &mark("x")).unwrap();
+    store.write(&format!("{SCRIPTS_DIR}/Menu Script.jsx"), &mark("m")).unwrap();
+    store.write(&format!("{SHUTDOWN_DIR}/Quit.jsx"), &mark("q")).unwrap();
+    let mut s = session(&store);
+    let r = s.execute("file.runStartupScripts", json!({})).unwrap();
+    assert_eq!(r["ran"], json!(["A.jsx", "b.jsx", "B2.jsx", "d.jsx"]), "{r}");
+    let failed: Vec<&str> = r["failed"].as_array().unwrap().iter().map(|f| f["name"].as_str().unwrap()).collect();
+    assert_eq!(failed, ["C.js"]);
+    assert_eq!(setting(&mut s, "order"), "AbBd");
+    // The failing script is reported in a toast.
+    let events = s.drain_events();
+    assert!(events.iter().any(|e| matches!(e, effectcraft_engine::Event::Toast { message, error: true } if message.starts_with("C.js"))), "{events:?}");
+    // The Startup folder's scripts are not offered in File ▸ Scripts.
+    let list = s.execute("file.scripts.list", json!({})).unwrap();
+    assert!(list.as_array().unwrap().iter().all(|e| e["name"] != "b.jsx"), "{list}");
+}
+
+#[test]
+fn shutdown_scripts_run_after_the_project_is_closed() {
+    let store = Arc::new(MemoryConfig::default());
+    let probe = r#"app.settings.saveSetting("Startup Test", "items", String(app.project.numItems));"#;
+    store.write(&format!("{SHUTDOWN_DIR}/Save State.jsx"), probe).unwrap();
+    let mut s = session(&store);
+    s.execute("script.run", json!({"code": r#"app.project.items.addComp("Main", 64, 64, 1, 1, 24);"#})).unwrap();
+    assert!(!s.project.items.is_empty());
+    let r = s.execute("file.runShutdownScripts", json!({})).unwrap();
+    assert_eq!(r, json!({"ran": ["Save State.jsx"], "waiting": [], "failed": []}));
+    assert_eq!(setting(&mut s, "items"), "0");
+    assert!(s.project.items.is_empty());
+}
+
+#[test]
+fn a_startup_dialog_stays_open_and_its_script_goes_on_when_it_closes() {
+    let store = Arc::new(MemoryConfig::default());
+    store.write(&format!("{STARTUP_DIR}/A Dialog.jsx"), &format!("new Window('dialog', 'Welcome').show();\n{}", mark("A"))).unwrap();
+    store.write(&format!("{STARTUP_DIR}/B.jsx"), &mark("B")).unwrap();
+    let mut s = session(&store);
+    let r = s.execute("file.runStartupScripts", json!({})).unwrap();
+    assert_eq!(r, json!({"ran": ["B.jsx"], "waiting": ["A Dialog.jsx"], "failed": []}));
+    assert_eq!(setting(&mut s, "order"), "B");
+    assert!(s.script_ui.windows.iter().any(|w| w.modal && w.title == "Welcome"));
+    s.execute("scriptui.close", json!({})).unwrap();
+    assert_eq!(setting(&mut s, "order"), "BA");
+}
+
+#[test]
+fn startup_scripts_tasks_go_on_after_a_project_opens() {
+    use web_time::{Duration, Instant};
+    let store = Arc::new(MemoryConfig::default());
+    store.write(&format!("{STARTUP_DIR}/A Poll.jsx"), "app.scheduleTask('writeLn(\"poll\")', 100, true);").unwrap();
+    // A task scheduled after the script's dialog closes.
+    store.write(&format!("{STARTUP_DIR}/B Ask.jsx"), "new Window('dialog', 'Ask').show();\napp.scheduleTask('writeLn(\"ask\")', 100, true);").unwrap();
+    let mut s = session(&store);
+    s.execute("file.runStartupScripts", json!({})).unwrap();
+    s.execute("scriptui.close", json!({})).unwrap();
+    // The launch opens a project after the Startup scripts ran.
+    s.execute("file.closeProject", json!({})).unwrap();
+    let r = crate::tasks::run_tasks_at(&mut s, Instant::now() + Duration::from_millis(500));
+    assert_eq!(r["ran"], json!(2), "{r}");
+    // A script run from File ▸ Scripts still stops when the project closes.
+    s.execute("script.run", json!({"code": "app.scheduleTask('writeLn(\"menu\")', 100, true);", "name": "Menu.jsx"})).unwrap();
+    s.execute("file.closeProject", json!({})).unwrap();
+    let r = crate::tasks::run_tasks_at(&mut s, Instant::now() + Duration::from_millis(5000));
+    assert_eq!(r["ran"], json!(2), "{r}");
+}
+
+#[test]
+fn shutdown_dialogs_close_as_if_canceled() {
+    let store = Arc::new(MemoryConfig::default());
+    let code = r#"var a = new Window("dialog", "One").show();
+var b = new Window("dialog", "Two").show();
+app.settings.saveSetting("Startup Test", "shown", a + "," + b);"#;
+    store.write(&format!("{SHUTDOWN_DIR}/Ask.jsx"), code).unwrap();
+    // An error after the dialog closes is a failure.
+    store.write(&format!("{SHUTDOWN_DIR}/Broken.jsx"), "new Window('dialog', 'Three').show();\nthrow new Error('late');").unwrap();
+    let mut s = session(&store);
+    let r = s.execute("file.runShutdownScripts", json!({})).unwrap();
+    assert_eq!((&r["ran"], &r["waiting"]), (&json!(["Ask.jsx"]), &json!([])), "{r}");
+    assert_eq!(r["failed"][0]["name"], "Broken.jsx", "{r}");
+    assert!(r["failed"][0]["error"].as_str().is_some_and(|e| e.contains("late")), "{r}");
+    assert_eq!(setting(&mut s, "shown"), "2,2");
+    assert!(s.script_ui.windows.is_empty());
+}
+
+#[test]
+fn shutdown_closes_only_its_own_scripts_dialogs() {
+    let store = Arc::new(MemoryConfig::default());
+    store.write(&format!("{STARTUP_DIR}/Same.jsx"), &format!("new Window('dialog', 'Startup').show();\n{}", mark("S"))).unwrap();
+    store.write(&format!("{SHUTDOWN_DIR}/Same.jsx"), &format!("new Window('dialog', 'Shutdown').show();\n{}", mark("Q"))).unwrap();
+    let mut s = session(&store);
+    assert_eq!(s.execute("file.runStartupScripts", json!({})).unwrap()["waiting"], json!(["Same.jsx"]));
+    let r = s.execute("file.runShutdownScripts", json!({})).unwrap();
+    assert_eq!(r, json!({"ran": ["Same.jsx"], "waiting": [], "failed": []}));
+    // The Startup script's dialog is still open, and its script has not gone on.
+    assert_eq!(setting(&mut s, "order"), "Q");
+    let titles: Vec<&str> = s.script_ui.windows.iter().map(|w| w.title.as_str()).collect();
+    assert_eq!(titles, ["Startup"]);
+}
+
+#[test]
+fn oversized_scripts_are_not_run() {
+    let store = Arc::new(MemoryConfig::default());
+    let big = format!("{}\n{}", "//".repeat(8 << 20), mark("x"));
+    store.write(&format!("{STARTUP_DIR}/Big.jsx"), &big).unwrap();
+    let mut s = session(&store);
+    let r = s.execute("file.runStartupScripts", json!({})).unwrap();
+    assert_eq!(r["ran"], json!([]));
+    assert_eq!(r["failed"][0]["name"], "Big.jsx");
+    let events = s.drain_events();
+    assert!(events.iter().any(|e| matches!(e, effectcraft_engine::Event::Toast { message, error: true } if message.starts_with("Big.jsx"))), "{events:?}");
+    assert_eq!(setting(&mut s, "order"), "");
+}
+
+#[test]
+fn scripts_in_a_settings_folder_on_disk_include_files_beside_them() {
+    use effectcraft_engine::config::DirConfig;
+    let root = std::env::temp_dir().join(format!("ec-startup-include-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&root);
+    for (file, code) in [
+        (format!("{STARTUP_DIR}/lib/helper.jsx"), mark("i")),
+        (format!("{STARTUP_DIR}/Main.jsx"), format!("#include \"lib/helper.jsx\"\n{}", mark("m"))),
+        (format!("{SHUTDOWN_DIR}/Ask.jsx"), format!("new Window('dialog', 'Bye').show();\n{}", mark("q"))),
+    ] {
+        let path = root.join(file);
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        std::fs::write(path, code).unwrap();
+    }
+    let mut s = Session::default();
+    crate::install(&mut s);
+    s.config = Some(Arc::new(DirConfig::new(&root)));
+    let r = s.execute("file.runStartupScripts", json!({})).unwrap();
+    assert_eq!(r, json!({"ran": ["Main.jsx"], "waiting": [], "failed": []}));
+    assert_eq!(setting(&mut s, "order"), "im");
+    // A Shutdown script run as its file still has its dialog closed.
+    let r = s.execute("file.runShutdownScripts", json!({})).unwrap();
+    assert_eq!(r, json!({"ran": ["Ask.jsx"], "waiting": [], "failed": []}));
+    assert_eq!(setting(&mut s, "order"), "imq");
+    let _ = std::fs::remove_dir_all(&root);
+}
+
+/// A session with one comp, for checking that a refused command leaves the project open.
+fn session_with_comp(store: &Arc<MemoryConfig>) -> Session {
+    let mut s = session(store);
+    s.execute("script.run", json!({"code": r#"app.project.items.addComp("Main", 64, 64, 1, 1, 24);"#})).unwrap();
+    assert!(!s.project.items.is_empty());
+    s
+}
+
+const FOLDER_COMMANDS: [&str; 2] = ["file.runStartupScripts", "file.runShutdownScripts"];
+
+#[test]
+fn scripts_cannot_run_the_startup_or_shutdown_folders() {
+    let store = Arc::new(MemoryConfig::default());
+    for id in FOLDER_COMMANDS {
+        let mut s = session_with_comp(&store);
+        let r = s.execute("script.run", json!({"code": format!("app.run('{id}', {{}})")})).unwrap();
+        assert!(r["error"]["message"].as_str().is_some_and(|m| m.contains("scripts can't run scripts")), "{id}: {r}");
+        assert!(!s.project.items.is_empty(), "{id}");
+    }
+}
+
+#[test]
+fn command_scripts_cannot_run_the_startup_or_shutdown_folders() {
+    let store = Arc::new(MemoryConfig::default());
+    for id in FOLDER_COMMANDS {
+        let mut s = session_with_comp(&store);
+        let e = s.execute("file.runScript", json!({"steps": [{"command": id}]})).unwrap_err().to_string();
+        assert!(e.contains("scripts can't run scripts"), "{id}: {e}");
+        assert!(!s.project.items.is_empty(), "{id}");
+    }
+}
+
+#[test]
+fn batches_cannot_run_the_startup_or_shutdown_folders() {
+    let store = Arc::new(MemoryConfig::default());
+    for id in FOLDER_COMMANDS {
+        let mut s = session_with_comp(&store);
+        let e = s.execute("engine.batch", json!({"steps": [{"command": id}]})).unwrap_err().to_string();
+        assert!(e.contains("can't run inside a batch"), "{id}: {e}");
+        assert!(!s.project.items.is_empty(), "{id}");
+    }
+}
+
+/// A ScriptUI panel whose script appends `p` to the `Startup Test` / `order` setting each time it
+/// runs, remembered as open at the last quit.
+fn session_with_panel(store: &Arc<MemoryConfig>) -> Session {
+    store.write(&format!("{PANELS_DIR}/Mark Panel.jsx"), &format!("this.add('statictext', undefined, 'Mark');\n{}", mark("p"))).unwrap();
+    store.write(OPEN_PANELS_FILE, &json!({"open": ["Mark Panel.jsx"]}).to_string()).unwrap();
+    session(store)
+}
+
+fn panel_open(s: &Session) -> bool {
+    s.script_ui.windows.iter().any(|w| w.kind == WindowKind::Panel && w.script == "Mark Panel.jsx")
+}
+
+/// The commands that open ScriptUI panels, which run the panel's script.
+fn panel_commands() -> [(&'static str, serde_json::Value); 2] {
+    [("window.scriptPanel", json!({"name": "Mark Panel.jsx"})), ("window.restoreScriptPanels", json!({}))]
+}
+
+#[test]
+fn scripts_cannot_open_script_panels() {
+    for (id, params) in panel_commands() {
+        let store = Arc::new(MemoryConfig::default());
+        let mut s = session_with_panel(&store);
+        // Opened by the user: a script's call would only bring it forward.
+        s.execute("window.scriptPanel", json!({"name": "Mark Panel.jsx"})).unwrap();
+        let r = s.execute("script.run", json!({"code": format!("app.run('{id}', {params})")})).unwrap();
+        assert!(r["error"]["message"].as_str().is_some_and(|m| m.contains("scripts can't run scripts")), "{id}: {r}");
+        assert_eq!(setting(&mut s, "order"), "p", "{id}");
+        assert_eq!(store.read(OPEN_PANELS_FILE).unwrap_or_default(), json!({"open": ["Mark Panel.jsx"]}).to_string(), "{id}");
+    }
+}
+
+#[test]
+fn command_scripts_and_batches_cannot_open_script_panels() {
+    for (id, params) in panel_commands() {
+        let store = Arc::new(MemoryConfig::default());
+        let mut s = session_with_panel(&store);
+        let e = s.execute("file.runScript", json!({"steps": [{"command": id, "params": params}]})).unwrap_err().to_string();
+        assert!(e.contains("scripts can't run scripts"), "{id}: {e}");
+        let e = s.execute("engine.batch", json!({"steps": [{"command": id, "params": params}]})).unwrap_err().to_string();
+        assert!(e.contains("can't run inside a batch"), "{id}: {e}");
+        assert!(!panel_open(&s), "{id}");
+        assert_eq!(setting(&mut s, "order"), "", "{id}");
+    }
+}
+
+#[test]
+fn the_app_still_reopens_script_panels_at_launch() {
+    let store = Arc::new(MemoryConfig::default());
+    let mut s = session_with_panel(&store);
+    // As the desktop and web apps call it at launch.
+    let r = s.execute("window.restoreScriptPanels", json!({})).unwrap();
+    assert_eq!(r, json!({"opened": ["Mark Panel.jsx"], "failed": []}));
+    assert!(panel_open(&s));
+    assert_eq!(setting(&mut s, "order"), "p");
+}
+
+#[test]
+fn empty_or_missing_folders_run_nothing() {
+    let none = json!({"ran": [], "waiting": [], "failed": []});
+    let store = Arc::new(MemoryConfig::default());
+    let mut s = session(&store);
+    assert_eq!(s.execute("file.runStartupScripts", json!({})).unwrap(), none);
+    // A session without a settings folder.
+    let mut s = Session::default();
+    crate::install(&mut s);
+    assert_eq!(s.execute("file.runShutdownScripts", json!({})).unwrap(), none);
+}
diff --git a/crates/script/src/tests_tasks.rs b/crates/script/src/tests/tasks.rs
similarity index 100%
rename from crates/script/src/tests_tasks.rs
rename to crates/script/src/tests/tasks.rs
diff --git a/crates/script/src/tests_ui.rs b/crates/script/src/tests/ui.rs
similarity index 100%
rename from crates/script/src/tests_ui.rs
rename to crates/script/src/tests/ui.rs
diff --git a/crates/script/src/tests_ui_more.rs b/crates/script/src/tests/ui_more.rs
similarity index 98%
rename from crates/script/src/tests_ui_more.rs
rename to crates/script/src/tests/ui_more.rs
index 228a58016..483d686ef 100644
--- a/crates/script/src/tests_ui_more.rs
+++ b/crates/script/src/tests/ui_more.rs
@@ -222,7 +222,16 @@ fn position_now(s: &Session, layer: u64) -> [f64; 2] {
     let cid = s.active_comp_id().unwrap();
     let comp = s.project.comp(cid).unwrap();
     let l = comp.layer(effectcraft_engine::project::LayerId(layer)).unwrap();
-    let ctx = effectcraft_engine::render::EvalCtx { project: &s.project, comp_id: cid, comp, time: s.time(), expr: s.expr.as_deref(), footage: None };
+    let ctx = effectcraft_engine::render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time: s.time(),
+        expr: s.expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let v = ctx.value(l, l.props.prop("transform/position").unwrap()).components();
     [v[0], v[1]]
 }
diff --git a/crates/script/src/tests_ui_mouse.rs b/crates/script/src/tests/ui_mouse.rs
similarity index 100%
rename from crates/script/src/tests_ui_mouse.rs
rename to crates/script/src/tests/ui_mouse.rs
diff --git a/crates/script/src/ui.rs b/crates/script/src/ui.rs
index 082a16cac..ab6f69846 100644
--- a/crates/script/src/ui.rs
+++ b/crates/script/src/ui.rs
@@ -404,8 +404,14 @@ fn dispatch_inline(session: &mut Session, host: u32, name: &str, ev: &ScriptUiEv
 
 // ---------------------------------------------------------------- scheduled tasks
 
+/// Whether `host`'s tasks stop now that the project it ran with was closed: it has no window
+/// open and is not a Startup script's.
+fn ends_with_project(session: &Session, host: u32) -> bool {
+    !session.script_ui.windows.iter().any(|w| w.host == host) && !session.script_ui.startup_hosts.contains(&host)
+}
+
 /// Run the due tasks of the script-host threads; hosts without windows whose project was closed
-/// end.
+/// end, except Startup scripts' hosts.
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) fn tick_threaded(session: &mut Session, now: Instant, report: &mut crate::tasks::Report) {
     let epoch = session.script_ui.project_epoch;
@@ -413,8 +419,7 @@ pub(crate) fn tick_threaded(session: &mut Session, now: Instant, report: &mut cr
     if let Ok(mut h) = hosts().lock() {
         for host in session.script_ui.task_hosts.clone() {
             let Some(end) = h.get(&host) else { continue };
-            let windowless = !session.script_ui.windows.iter().any(|w| w.host == host);
-            if windowless && end.epoch != epoch {
+            if end.epoch != epoch && ends_with_project(session, host) {
                 // Dropping its end lets the host thread finish.
                 stale.extend(h.remove(&host));
             } else if end.next_due.is_some_and(|d| d <= now) {
@@ -441,7 +446,7 @@ pub(crate) fn tick_threaded(session: &mut Session, now: Instant, report: &mut cr
 }
 
 /// Run the due tasks of the inline hosts on this thread (the Script Console, web runs); those
-/// without windows whose project was closed stop.
+/// without windows whose project was closed stop, except Startup scripts' hosts.
 pub(crate) fn tick_inline(session: &mut Session, now: Instant, report: &mut crate::tasks::Report) {
     for (host, name, epoch) in crate::tasks::hosts() {
         if !session.script_ui.task_hosts.contains(&host) {
@@ -449,7 +454,7 @@ pub(crate) fn tick_inline(session: &mut Session, now: Instant, report: &mut crat
         }
         let windowless = !session.script_ui.windows.iter().any(|w| w.host == host);
         let alive = host == CONSOLE_HOST || INLINE.with(|m| m.borrow().contains_key(&host));
-        if !alive || (windowless && epoch != session.script_ui.project_epoch) {
+        if !alive || (epoch != session.script_ui.project_epoch && ends_with_project(session, host)) {
             crate::tasks::drop_host(host);
             if host != CONSOLE_HOST && windowless {
                 drop_inline(host);
diff --git a/crates/segment/Cargo.toml b/crates/segment/Cargo.toml
index 98f3d1a14..515635db5 100644
--- a/crates/segment/Cargo.toml
+++ b/crates/segment/Cargo.toml
@@ -10,6 +10,6 @@ rust-version.workspace = true
 workspace = true
 
 [dependencies]
-miniz_oxide = "0.8"
+miniz_oxide = "0.9"
 ndarray = { version = "0.17", default-features = false, features = ["std"] }
 rayon = { workspace = true }
diff --git a/crates/segment/README.md b/crates/segment/README.md
index 79b1d996b..a95c92f93 100644
--- a/crates/segment/README.md
+++ b/crates/segment/README.md
@@ -12,7 +12,10 @@ Trained models for Roto Brush and face tracking, each kind behind one swappable
   depends on one model's layout. The classical face tracker stays built in as the fallback.
 - **`MODELS`**: the registry. Every entry must be open source under a licence compatible with
   EffectCraft's MIT OR Apache-2.0 (`ALLOWED_LICENCES`), with its task, authors, homepage, licence
-  URL, the official weights URL, size and SHA-256. `load` refuses anything else.
+  URL, an app download URL when available, size and SHA-256. `load` refuses anything else.
+  SAM 2 is Install from File only until a storytold-controlled mirror is available.
+  The checkpoint `source` stays separate from the app download URL, so file-install guidance and
+  licence notices identify the verified artifact even when app downloads are unavailable.
 - **Weights are never bundled.** They are downloaded on demand (or installed from a file) by the
   engine (`roto.model.*` / `face.model.*`, Settings ▸ Roto Brush / Face Tracking), verified
   against the registry's SHA-256 (`sha256`, dependency-free) and kept with a notice naming their
@@ -36,6 +39,10 @@ kernels at run time). No ML framework, no unsafe code.
 | id | Task | Model | Authors | Licence | File | Size |
 |---|---|---|---|---|---|---|
 | `mobilesam` | Roto Brush | [MobileSAM](https://github.com/ChaoningZhang/MobileSAM): Segment Anything with a 5M-parameter TinyViT encoder | Chaoning Zhang et al., building on Meta AI's Segment Anything and Microsoft's TinyViT | Apache-2.0 | `mobile_sam.pt` from the official repository | 40.7 MB |
+| `sam2.1-hiera-tiny` | Roto Brush | [SAM 2.1 Tiny](https://github.com/facebookresearch/sam2): Hiera-Tiny video object tracker with streaming memory | Meta AI (Nikhila Ravi et al.) | Apache-2.0 | `model.safetensors` of `facebook/sam2.1-hiera-tiny` (Hugging Face, pinned to a commit); loaded by `effectcraft-sam2` | 155.9 MB |
+| `sam2.1-hiera-small` | Roto Brush | [SAM 2.1 Small](https://github.com/facebookresearch/sam2): Hiera-Small video object tracker with streaming memory | Meta AI (Nikhila Ravi et al.) | Apache-2.0 | `model.safetensors` of `facebook/sam2.1-hiera-small` (Hugging Face, pinned to a commit); loaded by `effectcraft-sam2` | 184.3 MB |
+| `sam2.1-hiera-base-plus` | Roto Brush | [SAM 2.1 Base+](https://github.com/facebookresearch/sam2): Hiera-Base+ video object tracker with streaming memory | Meta AI (Nikhila Ravi et al.) | Apache-2.0 | `model.safetensors` of `facebook/sam2.1-hiera-base-plus` (Hugging Face, pinned to a commit); loaded by `effectcraft-sam2` | 323.5 MB |
+| `sam2.1-hiera-large` | Roto Brush | [SAM 2.1 Large](https://github.com/facebookresearch/sam2): Hiera-Large video object tracker with streaming memory | Meta AI (Nikhila Ravi et al.) | Apache-2.0 | `model.safetensors` of `facebook/sam2.1-hiera-large` (Hugging Face, pinned to a commit); loaded by `effectcraft-sam2` | 897.9 MB |
 | `mediapipe-face` | Face tracking | [MediaPipe Face Landmarker](https://developers.google.com/edge/mediapipe/solutions/vision/face_landmarker): BlazeFace detector and Face Mesh V2 | Google LLC | Apache-2.0 ([model card](https://storage.googleapis.com/mediapipe-assets/Model%20Card%20MediaPipe%20Face%20Mesh%20V2.pdf)) | `face_landmarker.task` (float16, version 1) from Google's model storage | 3.8 MB |
 
 How they were checked:
diff --git a/crates/segment/src/lib.rs b/crates/segment/src/lib.rs
index e04b7c336..7fc0e4ff6 100644
--- a/crates/segment/src/lib.rs
+++ b/crates/segment/src/lib.rs
@@ -14,8 +14,8 @@
 //!   so official weights load as published.
 //! - [`mobilesam`]: MobileSAM (Apache-2.0) and [`mediapipe`]: MediaPipe Face Landmarker
 //!   (Apache-2.0), in plain Rust ([`nn`] kernels on rayon).
-#![forbid(unsafe_code)]
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::todo, clippy::unreachable)]
+#![forbid(unsafe_code)]
 
 pub mod face;
 pub mod mediapipe;
@@ -45,6 +45,77 @@ pub trait MaskModel: Send + Sync {
     fn info(&self) -> &'static ModelInfo;
     /// Foreground probability (0–1) of each pixel of a frame (straight RGB 0–1, row-major `w×h`).
     fn segment(&self, rgb: &[[f32; 3]], w: usize, h: usize, prompt: &Prompt) -> Result<Vec<f32>>;
+    /// A video tracker built on the same weights, if the model has one.
+    fn tracker(&self) -> Option<&dyn ObjectTracker> {
+        None
+    }
+    /// The most memory (bytes) the last tracking run held for its memory banks and cached frames (`None`: not tracked).
+    fn peak_state_bytes(&self) -> Option<u64> {
+        None
+    }
+    /// What runs the model: the GPU's name or "CPU" (`None`: it does not say).
+    fn device_name(&self) -> Option<String> {
+        None
+    }
+    /// Seconds since the model was last used (`None`: it does not track use, so it is never unloaded
+    /// for being idle). Large models free their memory after a quiet spell and load again on use.
+    fn idle_secs(&self) -> Option<f64> {
+        None
+    }
+}
+
+/// One decoded frame handed to a tracker (straight RGB 0–1, row-major `w×h`).
+#[derive(Clone, Debug, Default)]
+pub struct ClipFrame {
+    pub rgb: Vec<[f32; 3]>,
+    pub w: usize,
+    pub h: usize,
+}
+
+/// What to track: the clip's frames `first..first + count` (the host's frame numbers) and, for
+/// each object, its prompts on their frames. Objects are tracked in one pass, so the cost of
+/// encoding each frame is shared.
+#[derive(Clone, Debug)]
+pub struct TrackRequest {
+    pub first: i64,
+    pub count: usize,
+    /// One entry per object: its prompts, each on its frame.
+    pub objects: Vec<Vec<(i64, Prompt)>>,
+}
+
+impl TrackRequest {
+    /// A request for a single object.
+    pub fn single(first: i64, count: usize, prompts: Vec<(i64, Prompt)>) -> TrackRequest {
+        TrackRequest { first, count, objects: vec![prompts] }
+    }
+}
+
+/// A tracker's answer for one frame.
+#[derive(Clone, Debug, Default)]
+pub struct TrackedFrame {
+    /// Foreground probability of every pixel (`w×h`); all zero when the object is absent.
+    pub prob: Vec<f32>,
+    pub w: usize,
+    pub h: usize,
+    /// How sure the tracker is (0–1), for the timeline.
+    pub confidence: f32,
+    /// The object is not in this frame (occluded or out of view).
+    pub occluded: bool,
+}
+
+/// A video tracker with memory (SAM 2): given prompts on some frames, it follows the object
+/// through the clip in both directions. Optional: a [`MaskModel`] may offer one.
+pub trait ObjectTracker: Send + Sync {
+    /// Track the objects. `frames(i)` supplies frame `i` (`None`: unavailable); `cancel()` is polled
+    /// between frames; `out(object, i, result)` is called as soon as each object's frame is finished
+    /// (`object` indexes `req.objects`).
+    fn track(
+        &self,
+        req: &TrackRequest,
+        frames: &mut dyn FnMut(i64) -> Option<Arc<ClipFrame>>,
+        cancel: &dyn Fn() -> bool,
+        out: &mut dyn FnMut(usize, i64, TrackedFrame),
+    ) -> Result<()>;
 }
 
 /// What a model is for.
@@ -70,8 +141,10 @@ pub struct ModelInfo {
     pub licence_url: &'static str,
     /// The project's page.
     pub homepage: &'static str,
-    /// The official weights file.
+    /// App download URL; empty when only Install from File is available.
     pub url: &'static str,
+    /// Checkpoint source for manual installation and notices; never used by the app downloader.
+    pub source: &'static str,
     pub file_name: &'static str,
     pub size: u64,
     /// SHA-256 of the weights file (lower-case hex).
@@ -91,11 +164,82 @@ pub const MOBILE_SAM: ModelInfo = ModelInfo {
     licence_url: "https://github.com/ChaoningZhang/MobileSAM/blob/master/LICENSE",
     homepage: "https://github.com/ChaoningZhang/MobileSAM",
     url: "https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/weights/mobile_sam.pt",
+    source: "https://raw.githubusercontent.com/ChaoningZhang/MobileSAM/master/weights/mobile_sam.pt",
     file_name: "mobile_sam.pt",
     size: 40_728_226,
     sha256: "6dbb90523a35330fedd7f1d3dfc66f995213d81b29a5ca8108dbcdd4e37d6c2f",
 };
 
+/// SAM 2.1 Tiny (Meta AI, Apache-2.0): a video object tracker with streaming memory. The weights are
+/// the Hugging Face `transformers` checkpoint, identified by SHA-256. Until a storytold mirror
+/// is available, install it from a file. `effectcraft-sam2` (native only) loads it, not [`load`].
+pub const SAM2_TINY: ModelInfo = ModelInfo {
+    id: "sam2.1-hiera-tiny",
+    task: Task::Mask,
+    name: "SAM 2.1 Tiny",
+    description: "Meta's Segment Anything Model 2 (Hiera-Tiny, 39M parameters). Follows the object through the clip with a streaming memory: it keeps tracking through occlusion and when the object leaves and re-enters the frame. Slower than MobileSAM on a CPU.",
+    authors: "Meta AI (Nikhila Ravi et al., SAM 2), Hugging Face transformers checkpoint",
+    licence: "Apache-2.0",
+    licence_url: "https://github.com/facebookresearch/sam2/blob/main/LICENSE",
+    homepage: "https://github.com/facebookresearch/sam2",
+    url: "",
+    source: "https://huggingface.co/facebook/sam2.1-hiera-tiny/blob/de431c4043854a71d8101e17995dfe596bf101a5/model.safetensors",
+    file_name: "sam2.1-hiera-tiny.safetensors",
+    size: 155_908_064,
+    sha256: "48c14467e5cf9e51870511feb72c89688e82dd74523142c0538b663e193ac2a7",
+};
+
+/// SAM 2.1 Small: the Small checkpoint, pinned to a commit like [`SAM2_TINY`].
+pub const SAM2_SMALL: ModelInfo = ModelInfo {
+    id: "sam2.1-hiera-small",
+    task: Task::Mask,
+    name: "SAM 2.1 Small",
+    description: "Meta's Segment Anything Model 2 (Hiera-Small, 46M parameters). The same streaming-memory tracker as SAM 2.1 Tiny with a larger backbone: a little more accurate on thin parts and busy backgrounds, a little slower.",
+    authors: "Meta AI (Nikhila Ravi et al., SAM 2), Hugging Face transformers checkpoint",
+    licence: "Apache-2.0",
+    licence_url: "https://github.com/facebookresearch/sam2/blob/main/LICENSE",
+    homepage: "https://github.com/facebookresearch/sam2",
+    url: "",
+    source: "https://huggingface.co/facebook/sam2.1-hiera-small/blob/ee5bba1d82bb8749febdf90f45e84b687142ba03/model.safetensors",
+    file_name: "sam2.1-hiera-small.safetensors",
+    size: 184_305_280,
+    sha256: "0a4067b11ce1e23d5229203f11c718a823060d15a4b23fa2372a7d4b77cbbc60",
+};
+
+/// SAM 2.1 Base+: the Base+ checkpoint, pinned to a commit like [`SAM2_TINY`].
+pub const SAM2_BASE_PLUS: ModelInfo = ModelInfo {
+    id: "sam2.1-hiera-base-plus",
+    task: Task::Mask,
+    name: "SAM 2.1 Base+",
+    description: "Meta's Segment Anything Model 2 (Hiera-Base+, 81M parameters). The same streaming-memory tracker as SAM 2.1 Tiny with a larger backbone: better on difficult footage; wants a GPU for comfortable speed.",
+    authors: "Meta AI (Nikhila Ravi et al., SAM 2), Hugging Face transformers checkpoint",
+    licence: "Apache-2.0",
+    licence_url: "https://github.com/facebookresearch/sam2/blob/main/LICENSE",
+    homepage: "https://github.com/facebookresearch/sam2",
+    url: "",
+    source: "https://huggingface.co/facebook/sam2.1-hiera-base-plus/blob/b7320756a13354e7530a63935656d35b2f91a290/model.safetensors",
+    file_name: "sam2.1-hiera-base-plus.safetensors",
+    size: 323_476_296,
+    sha256: "2012733a0de5d03efd1bba550a2847c4551be9ef2e0d497c83074df66189f780",
+};
+
+/// SAM 2.1 Large: the Large checkpoint, pinned to a commit like [`SAM2_TINY`].
+pub const SAM2_LARGE: ModelInfo = ModelInfo {
+    id: "sam2.1-hiera-large",
+    task: Task::Mask,
+    name: "SAM 2.1 Large",
+    description: "Meta's Segment Anything Model 2 (Hiera-Large, 224M parameters). The same streaming-memory tracker as SAM 2.1 Tiny with a larger backbone: the most accurate; about 900 MB and meant for a GPU.",
+    authors: "Meta AI (Nikhila Ravi et al., SAM 2), Hugging Face transformers checkpoint",
+    licence: "Apache-2.0",
+    licence_url: "https://github.com/facebookresearch/sam2/blob/main/LICENSE",
+    homepage: "https://github.com/facebookresearch/sam2",
+    url: "",
+    source: "https://huggingface.co/facebook/sam2.1-hiera-large/blob/665f8e2ad61cf5f53d65644ff27c8ee525124610/model.safetensors",
+    file_name: "sam2.1-hiera-large.safetensors",
+    size: 897_897_416,
+    sha256: "dc407dce21301fd94abb395c5099b4f2c455fdc8a8f261ac3d0ea6d4cd197230",
+};
+
 pub const FACE_LANDMARKER: ModelInfo = ModelInfo {
     id: "mediapipe-face",
     task: Task::Face,
@@ -106,13 +250,14 @@ pub const FACE_LANDMARKER: ModelInfo = ModelInfo {
     licence_url: "https://storage.googleapis.com/mediapipe-assets/Model%20Card%20MediaPipe%20Face%20Mesh%20V2.pdf",
     homepage: "https://developers.google.com/edge/mediapipe/solutions/vision/face_landmarker",
     url: "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task",
+    source: "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task",
     file_name: "face_landmarker.task",
     size: 3_758_596,
     sha256: "64184e229b263107bc2b804c6625db1341ff2bb731874b0bcc2fe6544e0bc9ff",
 };
 
 /// The trained models, besides the built-in classical engines.
-pub const MODELS: &[ModelInfo] = &[MOBILE_SAM, FACE_LANDMARKER];
+pub const MODELS: &[ModelInfo] = &[MOBILE_SAM, SAM2_TINY, SAM2_SMALL, SAM2_BASE_PLUS, SAM2_LARGE, FACE_LANDMARKER];
 
 /// The id of the built-in classical engines (graph cut segmenter, shape-model face tracker): no
 /// weights, always available.
@@ -144,21 +289,42 @@ pub fn load(id: &str, bytes: &[u8]) -> Result<Loaded> {
     if got != info.sha256 {
         return Err(format!("{}: the file does not match (SHA-256 {got}, expected {})", info.name, info.sha256));
     }
-    match id {
-        "mobilesam" => {
+    match loader(id) {
+        Some(Loader::MobileSam) => {
             let w = pt::read(bytes)?;
             Ok(Loaded::Mask(Arc::new(Sam { net: mobilesam::MobileSam::from_weights(&w)? })))
         }
-        "mediapipe-face" => Ok(Loaded::Face(Arc::new(mediapipe::FaceLandmarker::from_task(bytes)?))),
-        _ => Err(format!("no loader for `{id}`")),
+        Some(Loader::MediaPipe) => Ok(Loaded::Face(Arc::new(mediapipe::FaceLandmarker::from_task(bytes)?))),
+        Some(Loader::Desktop) => Err(format!("{} is loaded by the desktop application (effectcraft-sam2)", info.name)),
+        None => Err(format!("no loader for `{id}`")),
+    }
+}
+
+/// What builds a registered model.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Loader {
+    MobileSam,
+    MediaPipe,
+    /// Built outside this crate, by the desktop application (every SAM 2.1 size).
+    Desktop,
+}
+
+/// The loader for model `id`: one answer for every size of a family, so a new size cannot fall
+/// through to "no loader" while its sibling gets the helpful error.
+fn loader(id: &str) -> Option<Loader> {
+    match id {
+        "mobilesam" => Some(Loader::MobileSam),
+        "mediapipe-face" => Some(Loader::MediaPipe),
+        id if id.starts_with("sam2.1-hiera-") => Some(Loader::Desktop),
+        _ => None,
     }
 }
 
 /// The notice kept next to installed weights: what they are, who made them, their licence.
 pub fn notice(m: &ModelInfo) -> String {
     format!(
-        "{}\n\nAuthors: {}\nLicence: {} (full text: https://spdx.org/licenses/{}.html; as stated by the authors: {})\nSource: {}\nProject: {}\n\nDownloaded unmodified from the source above. EffectCraft runs it with its own implementation\nand is not affiliated with or endorsed by its authors.\n",
-        m.name, m.authors, m.licence, m.licence, m.licence_url, m.url, m.homepage
+        "{}\n\nAuthors: {}\nLicence: {} (full text: https://spdx.org/licenses/{}.html; as stated by the authors: {})\nSource: {}\nSHA-256: {}\nProject: {}\n\nInstalled unmodified. EffectCraft runs it with its own implementation\nand is not affiliated with or endorsed by its authors.\n",
+        m.name, m.authors, m.licence, m.licence, m.licence_url, m.source, m.sha256, m.homepage
     )
 }
 
@@ -260,13 +426,37 @@ mod tests {
         for m in MODELS {
             assert!(ALLOWED_LICENCES.contains(&m.licence), "{}", m.id);
             assert_eq!(m.sha256.len(), 64);
-            assert!(m.url.starts_with("https://") && m.licence_url.starts_with("https://") && m.homepage.starts_with("https://"));
+            assert!(m.url.is_empty() || m.url.starts_with("https://"));
+            assert!(m.source.starts_with("https://"));
+            assert!(m.licence_url.starts_with("https://") && m.homepage.starts_with("https://"));
             assert!(!m.authors.is_empty() && notice(m).contains(m.authors));
         }
+        assert_eq!(
+            models(Task::Mask).map(|m| m.id).collect::<Vec<_>>(),
+            ["mobilesam", "sam2.1-hiera-tiny", "sam2.1-hiera-small", "sam2.1-hiera-base-plus", "sam2.1-hiera-large"]
+        );
+        for model in [SAM2_TINY, SAM2_SMALL, SAM2_BASE_PLUS, SAM2_LARGE] {
+            assert!(model.url.is_empty(), "SAM 2 has no app download until a storytold mirror is available");
+            assert!(model.file_name.ends_with(".safetensors"));
+            assert!(model.source.contains("/blob/") && model.source.ends_with("/model.safetensors"));
+            assert!(notice(&model).contains(&format!("Source: {}", model.source)));
+            assert!(notice(&model).contains(model.sha256));
+        }
         assert_eq!(models(Task::Face).map(|m| m.id).collect::<Vec<_>>(), ["mediapipe-face"]);
         assert!(load("mediapipe-face", b"nope").err().is_some_and(|e| e.contains("does not match")));
         // A file that isn't the published one is refused before anything is parsed.
         assert!(load("mobilesam", b"not the weights").err().is_some_and(|e| e.contains("does not match")));
         assert!(load("nope", b"").is_err());
     }
+
+    /// Every registered model has a loader, so none falls through to "no loader" after its checksum
+    /// matches; every SAM 2.1 size is loaded by the desktop application.
+    #[test]
+    fn every_registered_model_has_a_loader() {
+        for m in MODELS {
+            let l = loader(m.id);
+            assert!(l.is_some(), "{} has no loader", m.id);
+            assert_eq!(l == Some(Loader::Desktop), m.id.starts_with("sam2.1-"), "{}", m.id);
+        }
+    }
 }
diff --git a/crates/segment/src/mobilesam.rs b/crates/segment/src/mobilesam.rs
index 22d98ba7c..6599b018a 100644
--- a/crates/segment/src/mobilesam.rs
+++ b/crates/segment/src/mobilesam.rs
@@ -191,7 +191,7 @@ impl Block {
                         v[t * dim + hh * hd..][..hd].copy_from_slice(&s[2 * hd..]);
                     }
                 }
-                nn::attention(&q, &k, &v, n, n, heads, hd, Some(&self.bias))
+                nn::attention(&q, &k, &v, nn::AttentionShape { query_tokens: n, key_tokens: n, heads, head_dim: hd }, Some(&self.bias))
             })
             .collect();
         // Un-window into the real grid, project, residual.
@@ -325,7 +325,7 @@ impl Attn {
     fn forward(&self, q: &[f32], nq: usize, k: &[f32], v: &[f32], nk: usize) -> Vec<f32> {
         let (q, k, v) = (self.q.forward(q, nq), self.k.forward(k, nk), self.v.forward(v, nk));
         let heads = 8;
-        let o = nn::attention(&q, &k, &v, nq, nk, heads, self.q.out / heads, None);
+        let o = nn::attention(&q, &k, &v, nn::AttentionShape { query_tokens: nq, key_tokens: nk, heads, head_dim: self.q.out / heads }, None);
         self.out.forward(&o, nq)
     }
 }
diff --git a/crates/segment/src/nn.rs b/crates/segment/src/nn.rs
index 4cf7a5344..713b392b8 100644
--- a/crates/segment/src/nn.rs
+++ b/crates/segment/src/nn.rs
@@ -334,9 +334,19 @@ pub fn softmax_rows(x: &mut [f32], n: usize) {
     }
 }
 
-/// Multi-head scaled dot-product attention of `nq` queries over `nk` keys/values, each `heads ×
-/// hd` wide (token-major, heads side by side), plus an optional per-head bias `[heads × nq × nk]`.
-pub fn attention(q: &[f32], k: &[f32], v: &[f32], nq: usize, nk: usize, heads: usize, hd: usize, bias: Option<&[f32]>) -> Vec<f32> {
+/// Token counts and channel layout shared by the query, key and value tensors.
+#[derive(Clone, Copy, Debug)]
+pub struct AttentionShape {
+    pub query_tokens: usize,
+    pub key_tokens: usize,
+    pub heads: usize,
+    pub head_dim: usize,
+}
+
+/// Multi-head scaled dot-product attention with token-major tensors, heads side by side,
+/// and an optional per-head bias `[heads × query_tokens × key_tokens]`.
+pub fn attention(q: &[f32], k: &[f32], v: &[f32], shape: AttentionShape, bias: Option<&[f32]>) -> Vec<f32> {
+    let AttentionShape { query_tokens: nq, key_tokens: nk, heads, head_dim: hd } = shape;
     let dim = heads * hd;
     let mut out = vec![0.0f32; nq * dim];
     if q.len() < nq * dim || k.len() < nk * dim || v.len() < nk * dim {
@@ -372,6 +382,37 @@ pub fn attention(q: &[f32], k: &[f32], v: &[f32], nq: usize, nk: usize, heads: u
 mod tests {
     use super::*;
 
+    #[test]
+    fn multi_head_cross_attention_matches_direct_sums() {
+        let shape = AttentionShape { query_tokens: 2, key_tokens: 3, heads: 2, head_dim: 2 };
+        let q = [1.0, -0.5, 0.25, 2.0, -1.0, 0.75, 1.5, -0.25];
+        let k = [0.5, 1.0, -0.5, 0.25, 1.5, -0.25, 0.75, 1.0, -1.0, 0.5, 2.0, -1.5];
+        let v = [1.0, 2.0, 3.0, 4.0, -1.0, 0.5, 1.5, -2.0, 0.25, 0.75, -0.5, 2.5];
+        let bias = [0.0, 0.5, -0.5, 1.0, 0.0, -1.0, -0.25, 0.25, 0.5, 0.0, -0.5, 1.0];
+        for bias in [None, Some(bias.as_slice())] {
+            let actual = attention(&q, &k, &v, shape, bias);
+            for query in 0..shape.query_tokens {
+                for head in 0..shape.heads {
+                    let mut scores: Vec<f32> = (0..shape.key_tokens)
+                        .map(|key| {
+                            let dot: f32 = (0..shape.head_dim).map(|channel| q[query * 4 + head * 2 + channel] * k[key * 4 + head * 2 + channel]).sum();
+                            dot / (shape.head_dim as f32).sqrt() + bias.map_or(0.0, |b| b[(head * 2 + query) * 3 + key])
+                        })
+                        .collect();
+                    let max = scores.iter().copied().fold(f32::NEG_INFINITY, f32::max);
+                    for score in &mut scores {
+                        *score = (*score - max).exp();
+                    }
+                    let total: f32 = scores.iter().sum();
+                    for channel in 0..shape.head_dim {
+                        let expected: f32 = scores.iter().enumerate().map(|(key, score)| score / total * v[key * 4 + head * 2 + channel]).sum();
+                        assert!((actual[query * 4 + head * 2 + channel] - expected).abs() < 1e-6);
+                    }
+                }
+            }
+        }
+    }
+
     #[test]
     fn gemm_matches_naive() {
         let (m, k, n) = (130, 17, 9);
diff --git a/crates/segment/src/tflite.rs b/crates/segment/src/tflite.rs
index 9cd34c6da..34e85dfab 100644
--- a/crates/segment/src/tflite.rs
+++ b/crates/segment/src/tflite.rs
@@ -763,361 +763,4 @@ fn concat(parts: &[(&[f32], &Vec<usize>)], axis: usize) -> Result<Vec<f32>> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn same_padding_matches_tensorflow() {
-        // TensorFlow pads the extra row after: 128 → 64 with a 3×3 stride-2 window pads 0 before.
-        assert_eq!(same(128, 3, 2), (64, 0));
-        assert_eq!(same(128, 5, 2), (64, 1));
-        assert_eq!(same(16, 3, 1), (16, 1));
-        assert_eq!(same(7, 2, 2), (4, 0));
-        assert_eq!(window(1, 4, 2, 2), Ok((2, 0)));
-        assert!(window(1, 1, 2, 2).is_err());
-    }
-
-    #[test]
-    fn asymmetric_conv_padding() {
-        // A 3×3 stride-2 "same" conv on 4×4: pads nothing before, one after.
-        let x: Vec<f32> = (0..16).map(|v| v as f32).collect();
-        let ones = vec![1.0f32; 9];
-        let c = Conv { wt: ones.clone(), b: vec![0.0], inp: 1, out: 1, ks: 3, stride: 2, pad: 0 };
-        let y = c.forward_sized(&x, 4, 4, 2, 2, [0, 0]);
-        // Top-left window rows 0–2, cols 0–2; the bottom-right one is cut by the edge.
-        assert_eq!(y, vec![45.0, 39.0, 66.0, 50.0]);
-        let d = Depthwise { w: ones, b: vec![0.0], c: 1, ks: 3, stride: 2 };
-        assert_eq!(d.forward_sized(&x, 4, 4, 2, 2, [0, 0]), y);
-    }
-
-    #[test]
-    fn pool_pad_and_concat() {
-        let x: Vec<f32> = (0..16).map(|v| v as f32).collect();
-        assert_eq!(max_pool(&x, [4, 4], 1, [2, 2], [2, 2], [2, 2], [0, 0]), vec![5.0, 7.0, 13.0, 15.0]);
-        // Same padding on 3×3 → 2×2: the last window is cut by the edge.
-        let x3: Vec<f32> = (0..9).map(|v| v as f32).collect();
-        assert_eq!(max_pool(&x3, [3, 3], 1, [2, 2], [2, 2], [2, 2], [0, 0]), vec![4.0, 5.0, 7.0, 8.0]);
-        // Channel padding (residual connections widen the channels with zeros).
-        let p = pad(&[1.0, 2.0, 3.0, 4.0], &[1, 1, 2, 2], &[[0, 0], [0, 0], [0, 0], [0, 1]]).unwrap();
-        assert_eq!(p, vec![1.0, 2.0, 0.0, 3.0, 4.0, 0.0]);
-        let p = pad(&[1.0, 2.0], &[1, 2], &[[0, 0], [1, 0]]).unwrap();
-        assert_eq!(p, vec![0.0, 1.0, 2.0]);
-        let a = [1.0, 2.0, 3.0, 4.0];
-        let b = [5.0, 6.0];
-        let (sa, sb) = (vec![1, 2, 2], vec![1, 1, 2]);
-        assert_eq!(concat(&[(&a, &sa), (&b, &sb)], 1).unwrap(), vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
-        let (sa, sb) = (vec![2, 2], vec![2, 1]);
-        assert_eq!(concat(&[(&a, &sa), (&b, &sb)], 1).unwrap(), vec![1.0, 2.0, 5.0, 3.0, 4.0, 6.0]);
-    }
-
-    #[test]
-    fn damaged_files_are_errors_not_panics() {
-        assert!(Model::read(b"").is_err());
-        assert!(Model::read(&[0xff; 64]).is_err());
-        // Every prefix and a few corruptions of a hand-made buffer.
-        let mut fb = vec![12, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 0, 0, 0, 0];
-        for n in 0..fb.len() {
-            let _ = Model::read(&fb[..n]);
-        }
-        for i in 0..fb.len() {
-            fb[i] ^= 0x5a;
-            let _ = Model::read(&fb);
-        }
-    }
-
-    /// A FlatBuffer value, to build small models in tests.
-    enum V {
-        Int(i32),
-        Byte(u8),
-        Table(Vec<(usize, V)>),
-        Ints(Vec<i32>),
-        Bytes(Vec<u8>),
-        Tables(Vec<V>),
-    }
-
-    fn put_u32(b: &mut [u8], at: usize, v: usize) {
-        b[at..at + 4].copy_from_slice(&(v as u32).to_le_bytes());
-    }
-
-    /// Append `v` (children after their parent, so every offset points forward); where it starts.
-    fn put(b: &mut Vec<u8>, v: &V) -> usize {
-        match v {
-            V::Table(fields) => {
-                let slots = fields.iter().map(|f| f.0 + 1).max().unwrap_or(0);
-                let vt = b.len();
-                let vt_len = 4 + 2 * slots;
-                b.resize(vt + vt_len, 0);
-                let t = b.len();
-                // Every field gets 8 bytes (the reader does not need alignment).
-                let t_len = 4 + 8 * fields.len();
-                b.resize(t + t_len, 0);
-                b[vt..vt + 2].copy_from_slice(&(vt_len as u16).to_le_bytes());
-                b[vt + 2..vt + 4].copy_from_slice(&(t_len as u16).to_le_bytes());
-                b[t..t + 4].copy_from_slice(&((t - vt) as i32).to_le_bytes());
-                for (k, (id, f)) in fields.iter().enumerate() {
-                    let at = t + 4 + 8 * k;
-                    b[vt + 4 + 2 * id..vt + 6 + 2 * id].copy_from_slice(&((at - t) as u16).to_le_bytes());
-                    match f {
-                        V::Int(i) => b[at..at + 4].copy_from_slice(&i.to_le_bytes()),
-                        V::Byte(x) => b[at] = *x,
-                        _ => {
-                            let child = put(b, f);
-                            put_u32(b, at, child - at);
-                        }
-                    }
-                }
-                t
-            }
-            V::Ints(xs) => {
-                let p = b.len();
-                b.extend((xs.len() as u32).to_le_bytes());
-                xs.iter().for_each(|x| b.extend(x.to_le_bytes()));
-                p
-            }
-            V::Bytes(xs) => {
-                let p = b.len();
-                b.extend((xs.len() as u32).to_le_bytes());
-                b.extend(xs);
-                p
-            }
-            V::Tables(ts) => {
-                let p = b.len();
-                b.extend((ts.len() as u32).to_le_bytes());
-                let slots = b.len();
-                b.resize(slots + 4 * ts.len(), 0);
-                for (i, t) in ts.iter().enumerate() {
-                    let child = put(b, t);
-                    put_u32(b, slots + 4 * i, child - (slots + 4 * i));
-                }
-                p
-            }
-            V::Int(_) | V::Byte(_) => b.len(),
-        }
-    }
-
-    /// A tensor: shape, type and its constant data (`Some(k)`: buffer `k` of the model's).
-    type T = (Vec<i32>, u8, Option<usize>);
-    /// An operator: code, inputs, outputs and its options' fields.
-    type O = (i32, Vec<i32>, Vec<i32>, Vec<(usize, V)>);
-
-    /// A `.tflite` file with one graph.
-    fn model(bufs: Vec<Vec<u8>>, tensors: Vec<T>, ops: Vec<O>, inputs: Vec<i32>, outputs: Vec<i32>) -> Vec<u8> {
-        let ts = tensors
-            .into_iter()
-            .enumerate()
-            .map(|(i, (shape, ty, buf))| {
-                let mut f = vec![(0, V::Ints(shape)), (1, V::Byte(ty)), (3, V::Bytes(format!("t{i}").into_bytes()))];
-                if let Some(k) = buf {
-                    f.push((2, V::Int(k as i32 + 1)));
-                }
-                V::Table(f)
-            })
-            .collect();
-        let mut codes = vec![];
-        let os = ops
-            .into_iter()
-            .map(|(code, ins, outs, opts)| {
-                let idx = codes.iter().position(|&c| c == code).unwrap_or_else(|| {
-                    codes.push(code);
-                    codes.len() - 1
-                });
-                V::Table(vec![(0, V::Int(idx as i32)), (1, V::Ints(ins)), (2, V::Ints(outs)), (4, V::Table(opts))])
-            })
-            .collect();
-        let g = V::Table(vec![(0, V::Tables(ts)), (1, V::Ints(inputs)), (2, V::Ints(outputs)), (3, V::Tables(os))]);
-        let buffers = std::iter::once(V::Table(vec![])).chain(bufs.into_iter().map(|d| V::Table(vec![(0, V::Bytes(d))]))).collect();
-        let codes = codes.into_iter().map(|c| V::Table(vec![(3, V::Int(c))])).collect();
-        let root = V::Table(vec![(1, V::Tables(codes)), (2, V::Tables(vec![g])), (4, V::Tables(buffers))]);
-        let mut b = vec![0u8; 4];
-        let r = put(&mut b, &root);
-        put_u32(&mut b, 0, r);
-        b
-    }
-
-    fn f32s(xs: &[f32]) -> Vec<u8> {
-        xs.iter().flat_map(|x| x.to_le_bytes()).collect()
-    }
-
-    /// Conv2DOptions / Pool2DOptions: padding (0 same, 1 valid) and stride.
-    fn window_opts(padding: u8, stride: i32) -> Vec<(usize, V)> {
-        vec![(0, V::Byte(padding)), (1, V::Int(stride)), (2, V::Int(stride))]
-    }
-
-    fn refused(bytes: &[u8], why: &str) {
-        let e = Model::read(bytes).err().unwrap_or_default();
-        assert!(e.contains(why), "refused for `{e}`, expected `{why}`");
-    }
-
-    #[test]
-    fn built_models_load_and_run() {
-        // A 3×3 stride-2 "same" conv on 4×4, then a RELU: as `asymmetric_conv_padding`.
-        let m = model(
-            vec![f32s(&[1.0; 9])],
-            vec![(vec![1, 4, 4, 1], FLOAT32, None), (vec![1, 3, 3, 1], FLOAT32, Some(0)), (vec![1, 2, 2, 1], FLOAT32, None), (vec![1, 2, 2, 1], FLOAT32, None)],
-            vec![(op::CONV_2D, vec![0, 1, -1], vec![2], window_opts(0, 2)), (op::RELU, vec![2], vec![3], vec![])],
-            vec![0],
-            vec![3],
-        );
-        let m = Model::read(&m).unwrap();
-        let c = m.cost().unwrap();
-        assert_eq!((c.macs, c.values, c.scratch, c.kernel), (2 * 2 * 9, 8, 2 * 9, 3));
-        // The input, the conv's output and its patch row, alive together.
-        assert_eq!(c.live, 16 + 4 + 2 * 9);
-        let x: Vec<f32> = (0..16).map(|v| v as f32).collect();
-        assert_eq!(m.run(&[&x]).unwrap(), vec![vec![45.0, 39.0, 66.0, 50.0]]);
-    }
-
-    /// #368: an 8 KB model whose CONV_2D needed a 512 GB scratch buffer aborted `run`.
-    #[test]
-    fn convolution_scratch_is_bounded() {
-        let w = 1 << 25;
-        let bomb = model(
-            vec![vec![0; 2 * 64 * 64]],
-            vec![(vec![1, 1, w, 1], FLOAT32, None), (vec![1, 64, 64, 1], FLOAT16, Some(0)), (vec![1, 1, w, 1], FLOAT32, None)],
-            vec![(op::CONV_2D, vec![0, 1, -1], vec![2], window_opts(0, 1))],
-            vec![0],
-            vec![2],
-        );
-        refused(&bomb, "kernel is too large");
-        // A small kernel over many channels: the patch row is `ow·3·3·cin`.
-        let (w, cin) = (1 << 20, 256);
-        let wide = model(
-            vec![vec![0; 2 * 9 * 256]],
-            vec![(vec![1, 1, w, cin], FLOAT32, None), (vec![1, 3, 3, cin], FLOAT16, Some(0)), (vec![1, 1, w, 1], FLOAT32, None)],
-            vec![(op::CONV_2D, vec![0, 1, -1], vec![2], window_opts(0, 1))],
-            vec![0],
-            vec![2],
-        );
-        refused(&wide, "working space is too large");
-    }
-
-    #[test]
-    fn kernel_sides_are_bounded() {
-        let k = MAX_KERNEL as i32 + 1;
-        let conv = model(
-            vec![vec![0; 2 * (k * k) as usize]],
-            vec![(vec![1, 40, 40, 1], FLOAT32, None), (vec![1, k, k, 1], FLOAT16, Some(0)), (vec![1, 40, 40, 1], FLOAT32, None)],
-            vec![(op::CONV_2D, vec![0, 1, -1], vec![2], window_opts(0, 1))],
-            vec![0],
-            vec![2],
-        );
-        refused(&conv, "kernel is too large");
-        let depthwise = model(
-            vec![vec![0; 2 * (k * k) as usize]],
-            vec![(vec![1, 40, 40, 1], FLOAT32, None), (vec![1, k, k, 1], FLOAT16, Some(0)), (vec![1, 40, 40, 1], FLOAT32, None)],
-            vec![(op::DEPTHWISE_CONV_2D, vec![0, 1, -1], vec![2], window_opts(0, 1))],
-            vec![0],
-            vec![2],
-        );
-        refused(&depthwise, "kernel is too large");
-        // A "same" pool takes any window: a huge one looped for billions of steps per output.
-        let mut opts = window_opts(0, 1);
-        opts.extend([(3, V::Int(i32::MAX)), (4, V::Int(i32::MAX))]);
-        let pool = model(
-            vec![],
-            vec![(vec![1, 8, 8, 1], FLOAT32, None), (vec![1, 8, 8, 1], FLOAT32, None)],
-            vec![(op::MAX_POOL_2D, vec![0], vec![1], opts)],
-            vec![0],
-            vec![1],
-        );
-        refused(&pool, "pooling window is too large");
-    }
-
-    #[test]
-    fn multiply_adds_are_bounded() {
-        // Three 16 → 16 pointwise convolutions over 4096×4096: 3·2³² multiply-adds.
-        let s = vec![1, 4096, 4096, 16];
-        let t = |buf| (s.clone(), FLOAT32, buf);
-        let m = model(
-            vec![vec![0; 2 * 16 * 16]],
-            vec![t(None), (vec![16, 1, 1, 16], FLOAT16, Some(0)), t(None), t(None), t(None)],
-            (0..3).map(|i| (op::CONV_2D, vec![if i == 0 { 0 } else { i + 1 }, 1, -1], vec![i + 2], window_opts(0, 1))).collect(),
-            vec![0],
-            vec![4],
-        );
-        refused(&m, "too many multiply-adds");
-    }
-
-    /// #368: 2000 RELUs over 2²⁵ values loaded fine, and one run took minutes.
-    #[test]
-    fn elementwise_work_is_bounded() {
-        let n = 2000;
-        let m = model(
-            vec![],
-            (0..=n).map(|_| (vec![1, 1 << 25], FLOAT32, None)).collect(),
-            (0..n).map(|i| (op::RELU, vec![i], vec![i + 1], vec![])).collect(),
-            vec![0],
-            vec![n],
-        );
-        refused(&m, "too much work");
-    }
-
-    #[test]
-    fn memory_alive_at_once_is_bounded() {
-        // Five outputs of 2²⁷ values each, all kept, besides the input.
-        let m = model(
-            vec![],
-            (0..6).map(|_| (vec![1, 1 << 27], FLOAT32, None)).collect(),
-            (1..6).map(|i| (op::RELU, vec![0], vec![i], vec![])).collect(),
-            vec![0],
-            (1..6).collect(),
-        );
-        refused(&m, "too much memory");
-    }
-
-    #[test]
-    fn shapes_computed_at_run_time_must_match_the_declared_ones() {
-        // PAD to 2³⁰ × 2³⁰ while declaring a 1×1 output.
-        let pads = vec![0, 1 << 30, 0, 1 << 30].into_iter().flat_map(i32::to_le_bytes).collect();
-        let pad = model(
-            vec![pads],
-            vec![(vec![1, 1], FLOAT32, None), (vec![2, 2], INT32, Some(0)), (vec![1, 1], FLOAT32, None)],
-            vec![(op::PAD, vec![0, 1], vec![2], vec![])],
-            vec![0],
-            vec![2],
-        );
-        refused(&pad, "padding disagrees");
-        // Many large parts concatenated into a small declared output.
-        let concat = model(
-            vec![],
-            vec![(vec![1, 1 << 27], FLOAT32, None), (vec![1, 2], FLOAT32, None)],
-            vec![(op::CONCATENATION, vec![0; 64], vec![1], vec![(0, V::Int(1))])],
-            vec![0],
-            vec![1],
-        );
-        refused(&concat, "parts disagree");
-        // A pool whose output claims more channels than its input has.
-        let pool = model(
-            vec![],
-            vec![(vec![1, 2, 2, 1], FLOAT32, None), (vec![1, 1, 1, 1 << 20], FLOAT32, None)],
-            vec![(op::MAX_POOL_2D, vec![0], vec![1], window_opts(1, 2).into_iter().chain([(3, V::Int(2)), (4, V::Int(2))]).collect())],
-            vec![0],
-            vec![1],
-        );
-        refused(&pool, "changes the channels");
-        // Dimensions may not hide behind a zero.
-        let zero = model(vec![], vec![(vec![0, 1 << 30, 1 << 30], FLOAT32, None)], vec![], vec![0], vec![0]);
-        refused(&zero, "tensor is too large");
-    }
-
-    #[test]
-    fn shared_weights_count_once_per_use() {
-        // One 128 KB buffer decoded for 2100 tensors would be 2100 copies of 2¹⁶ floats.
-        let m = model(vec![vec![0; 2 << 16]], (0..2100).map(|_| (vec![1, 1 << 16], FLOAT16, Some(0))).collect(), vec![], vec![], vec![]);
-        refused(&m, "weights are too large");
-    }
-
-    /// The official face models (`EFFECTCRAFT_FACE_LANDMARKER` = path to `face_landmarker.task`)
-    /// fit every budget with wide headroom.
-    #[test]
-    fn official_face_models_fit_the_budgets() {
-        let Some(path) = std::env::var_os("EFFECTCRAFT_FACE_LANDMARKER") else { return };
-        let bytes = std::fs::read(path).unwrap();
-        for name in [crate::mediapipe::DETECTOR, crate::mediapipe::MESH] {
-            let c = Model::read(&crate::pt::zip_file(&bytes, name).unwrap()).unwrap().cost().unwrap();
-            println!("{name}: {c:?}");
-            assert!(c.macs <= MAX_MACS / 8 && c.values <= MAX_VALUES / 8 && c.live <= MAX_LIVE / 8 && c.scratch <= MAX_SCRATCH / 8, "{name}: {c:?}");
-            assert!(c.kernel <= MAX_KERNEL as u64 / 4, "{name}: {c:?}");
-        }
-    }
-}
+mod tests;
diff --git a/crates/segment/src/tflite/tests.rs b/crates/segment/src/tflite/tests.rs
new file mode 100644
index 000000000..29a781d34
--- /dev/null
+++ b/crates/segment/src/tflite/tests.rs
@@ -0,0 +1,356 @@
+use super::*;
+
+#[test]
+fn same_padding_matches_tensorflow() {
+    // TensorFlow pads the extra row after: 128 → 64 with a 3×3 stride-2 window pads 0 before.
+    assert_eq!(same(128, 3, 2), (64, 0));
+    assert_eq!(same(128, 5, 2), (64, 1));
+    assert_eq!(same(16, 3, 1), (16, 1));
+    assert_eq!(same(7, 2, 2), (4, 0));
+    assert_eq!(window(1, 4, 2, 2), Ok((2, 0)));
+    assert!(window(1, 1, 2, 2).is_err());
+}
+
+#[test]
+fn asymmetric_conv_padding() {
+    // A 3×3 stride-2 "same" conv on 4×4: pads nothing before, one after.
+    let x: Vec<f32> = (0..16).map(|v| v as f32).collect();
+    let ones = vec![1.0f32; 9];
+    let c = Conv { wt: ones.clone(), b: vec![0.0], inp: 1, out: 1, ks: 3, stride: 2, pad: 0 };
+    let y = c.forward_sized(&x, 4, 4, 2, 2, [0, 0]);
+    // Top-left window rows 0–2, cols 0–2; the bottom-right one is cut by the edge.
+    assert_eq!(y, vec![45.0, 39.0, 66.0, 50.0]);
+    let d = Depthwise { w: ones, b: vec![0.0], c: 1, ks: 3, stride: 2 };
+    assert_eq!(d.forward_sized(&x, 4, 4, 2, 2, [0, 0]), y);
+}
+
+#[test]
+fn pool_pad_and_concat() {
+    let x: Vec<f32> = (0..16).map(|v| v as f32).collect();
+    assert_eq!(max_pool(&x, [4, 4], 1, [2, 2], [2, 2], [2, 2], [0, 0]), vec![5.0, 7.0, 13.0, 15.0]);
+    // Same padding on 3×3 → 2×2: the last window is cut by the edge.
+    let x3: Vec<f32> = (0..9).map(|v| v as f32).collect();
+    assert_eq!(max_pool(&x3, [3, 3], 1, [2, 2], [2, 2], [2, 2], [0, 0]), vec![4.0, 5.0, 7.0, 8.0]);
+    // Channel padding (residual connections widen the channels with zeros).
+    let p = pad(&[1.0, 2.0, 3.0, 4.0], &[1, 1, 2, 2], &[[0, 0], [0, 0], [0, 0], [0, 1]]).unwrap();
+    assert_eq!(p, vec![1.0, 2.0, 0.0, 3.0, 4.0, 0.0]);
+    let p = pad(&[1.0, 2.0], &[1, 2], &[[0, 0], [1, 0]]).unwrap();
+    assert_eq!(p, vec![0.0, 1.0, 2.0]);
+    let a = [1.0, 2.0, 3.0, 4.0];
+    let b = [5.0, 6.0];
+    let (sa, sb) = (vec![1, 2, 2], vec![1, 1, 2]);
+    assert_eq!(concat(&[(&a, &sa), (&b, &sb)], 1).unwrap(), vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0]);
+    let (sa, sb) = (vec![2, 2], vec![2, 1]);
+    assert_eq!(concat(&[(&a, &sa), (&b, &sb)], 1).unwrap(), vec![1.0, 2.0, 5.0, 3.0, 4.0, 6.0]);
+}
+
+#[test]
+fn damaged_files_are_errors_not_panics() {
+    assert!(Model::read(b"").is_err());
+    assert!(Model::read(&[0xff; 64]).is_err());
+    // Every prefix and a few corruptions of a hand-made buffer.
+    let mut fb = vec![12, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 0, 0, 0, 0];
+    for n in 0..fb.len() {
+        let _ = Model::read(&fb[..n]);
+    }
+    for i in 0..fb.len() {
+        fb[i] ^= 0x5a;
+        let _ = Model::read(&fb);
+    }
+}
+
+/// A FlatBuffer value, to build small models in tests.
+enum V {
+    Int(i32),
+    Byte(u8),
+    Table(Vec<(usize, V)>),
+    Ints(Vec<i32>),
+    Bytes(Vec<u8>),
+    Tables(Vec<V>),
+}
+
+fn put_u32(b: &mut [u8], at: usize, v: usize) {
+    b[at..at + 4].copy_from_slice(&(v as u32).to_le_bytes());
+}
+
+/// Append `v` (children after their parent, so every offset points forward); where it starts.
+fn put(b: &mut Vec<u8>, v: &V) -> usize {
+    match v {
+        V::Table(fields) => {
+            let slots = fields.iter().map(|f| f.0 + 1).max().unwrap_or(0);
+            let vt = b.len();
+            let vt_len = 4 + 2 * slots;
+            b.resize(vt + vt_len, 0);
+            let t = b.len();
+            // Every field gets 8 bytes (the reader does not need alignment).
+            let t_len = 4 + 8 * fields.len();
+            b.resize(t + t_len, 0);
+            b[vt..vt + 2].copy_from_slice(&(vt_len as u16).to_le_bytes());
+            b[vt + 2..vt + 4].copy_from_slice(&(t_len as u16).to_le_bytes());
+            b[t..t + 4].copy_from_slice(&((t - vt) as i32).to_le_bytes());
+            for (k, (id, f)) in fields.iter().enumerate() {
+                let at = t + 4 + 8 * k;
+                b[vt + 4 + 2 * id..vt + 6 + 2 * id].copy_from_slice(&((at - t) as u16).to_le_bytes());
+                match f {
+                    V::Int(i) => b[at..at + 4].copy_from_slice(&i.to_le_bytes()),
+                    V::Byte(x) => b[at] = *x,
+                    _ => {
+                        let child = put(b, f);
+                        put_u32(b, at, child - at);
+                    }
+                }
+            }
+            t
+        }
+        V::Ints(xs) => {
+            let p = b.len();
+            b.extend((xs.len() as u32).to_le_bytes());
+            xs.iter().for_each(|x| b.extend(x.to_le_bytes()));
+            p
+        }
+        V::Bytes(xs) => {
+            let p = b.len();
+            b.extend((xs.len() as u32).to_le_bytes());
+            b.extend(xs);
+            p
+        }
+        V::Tables(ts) => {
+            let p = b.len();
+            b.extend((ts.len() as u32).to_le_bytes());
+            let slots = b.len();
+            b.resize(slots + 4 * ts.len(), 0);
+            for (i, t) in ts.iter().enumerate() {
+                let child = put(b, t);
+                put_u32(b, slots + 4 * i, child - (slots + 4 * i));
+            }
+            p
+        }
+        V::Int(_) | V::Byte(_) => b.len(),
+    }
+}
+
+/// A tensor: shape, type and its constant data (`Some(k)`: buffer `k` of the model's).
+type T = (Vec<i32>, u8, Option<usize>);
+/// An operator: code, inputs, outputs and its options' fields.
+type O = (i32, Vec<i32>, Vec<i32>, Vec<(usize, V)>);
+
+/// A `.tflite` file with one graph.
+fn model(bufs: Vec<Vec<u8>>, tensors: Vec<T>, ops: Vec<O>, inputs: Vec<i32>, outputs: Vec<i32>) -> Vec<u8> {
+    let ts = tensors
+        .into_iter()
+        .enumerate()
+        .map(|(i, (shape, ty, buf))| {
+            let mut f = vec![(0, V::Ints(shape)), (1, V::Byte(ty)), (3, V::Bytes(format!("t{i}").into_bytes()))];
+            if let Some(k) = buf {
+                f.push((2, V::Int(k as i32 + 1)));
+            }
+            V::Table(f)
+        })
+        .collect();
+    let mut codes = vec![];
+    let os = ops
+        .into_iter()
+        .map(|(code, ins, outs, opts)| {
+            let idx = codes.iter().position(|&c| c == code).unwrap_or_else(|| {
+                codes.push(code);
+                codes.len() - 1
+            });
+            V::Table(vec![(0, V::Int(idx as i32)), (1, V::Ints(ins)), (2, V::Ints(outs)), (4, V::Table(opts))])
+        })
+        .collect();
+    let g = V::Table(vec![(0, V::Tables(ts)), (1, V::Ints(inputs)), (2, V::Ints(outputs)), (3, V::Tables(os))]);
+    let buffers = std::iter::once(V::Table(vec![])).chain(bufs.into_iter().map(|d| V::Table(vec![(0, V::Bytes(d))]))).collect();
+    let codes = codes.into_iter().map(|c| V::Table(vec![(3, V::Int(c))])).collect();
+    let root = V::Table(vec![(1, V::Tables(codes)), (2, V::Tables(vec![g])), (4, V::Tables(buffers))]);
+    let mut b = vec![0u8; 4];
+    let r = put(&mut b, &root);
+    put_u32(&mut b, 0, r);
+    b
+}
+
+fn f32s(xs: &[f32]) -> Vec<u8> {
+    xs.iter().flat_map(|x| x.to_le_bytes()).collect()
+}
+
+/// Conv2DOptions / Pool2DOptions: padding (0 same, 1 valid) and stride.
+fn window_opts(padding: u8, stride: i32) -> Vec<(usize, V)> {
+    vec![(0, V::Byte(padding)), (1, V::Int(stride)), (2, V::Int(stride))]
+}
+
+fn refused(bytes: &[u8], why: &str) {
+    let e = Model::read(bytes).err().unwrap_or_default();
+    assert!(e.contains(why), "refused for `{e}`, expected `{why}`");
+}
+
+#[test]
+fn built_models_load_and_run() {
+    // A 3×3 stride-2 "same" conv on 4×4, then a RELU: as `asymmetric_conv_padding`.
+    let m = model(
+        vec![f32s(&[1.0; 9])],
+        vec![(vec![1, 4, 4, 1], FLOAT32, None), (vec![1, 3, 3, 1], FLOAT32, Some(0)), (vec![1, 2, 2, 1], FLOAT32, None), (vec![1, 2, 2, 1], FLOAT32, None)],
+        vec![(op::CONV_2D, vec![0, 1, -1], vec![2], window_opts(0, 2)), (op::RELU, vec![2], vec![3], vec![])],
+        vec![0],
+        vec![3],
+    );
+    let m = Model::read(&m).unwrap();
+    let c = m.cost().unwrap();
+    assert_eq!((c.macs, c.values, c.scratch, c.kernel), (2 * 2 * 9, 8, 2 * 9, 3));
+    // The input, the conv's output and its patch row, alive together.
+    assert_eq!(c.live, 16 + 4 + 2 * 9);
+    let x: Vec<f32> = (0..16).map(|v| v as f32).collect();
+    assert_eq!(m.run(&[&x]).unwrap(), vec![vec![45.0, 39.0, 66.0, 50.0]]);
+}
+
+/// #368: an 8 KB model whose CONV_2D needed a 512 GB scratch buffer aborted `run`.
+#[test]
+fn convolution_scratch_is_bounded() {
+    let w = 1 << 25;
+    let bomb = model(
+        vec![vec![0; 2 * 64 * 64]],
+        vec![(vec![1, 1, w, 1], FLOAT32, None), (vec![1, 64, 64, 1], FLOAT16, Some(0)), (vec![1, 1, w, 1], FLOAT32, None)],
+        vec![(op::CONV_2D, vec![0, 1, -1], vec![2], window_opts(0, 1))],
+        vec![0],
+        vec![2],
+    );
+    refused(&bomb, "kernel is too large");
+    // A small kernel over many channels: the patch row is `ow·3·3·cin`.
+    let (w, cin) = (1 << 20, 256);
+    let wide = model(
+        vec![vec![0; 2 * 9 * 256]],
+        vec![(vec![1, 1, w, cin], FLOAT32, None), (vec![1, 3, 3, cin], FLOAT16, Some(0)), (vec![1, 1, w, 1], FLOAT32, None)],
+        vec![(op::CONV_2D, vec![0, 1, -1], vec![2], window_opts(0, 1))],
+        vec![0],
+        vec![2],
+    );
+    refused(&wide, "working space is too large");
+}
+
+#[test]
+fn kernel_sides_are_bounded() {
+    let k = MAX_KERNEL as i32 + 1;
+    let conv = model(
+        vec![vec![0; 2 * (k * k) as usize]],
+        vec![(vec![1, 40, 40, 1], FLOAT32, None), (vec![1, k, k, 1], FLOAT16, Some(0)), (vec![1, 40, 40, 1], FLOAT32, None)],
+        vec![(op::CONV_2D, vec![0, 1, -1], vec![2], window_opts(0, 1))],
+        vec![0],
+        vec![2],
+    );
+    refused(&conv, "kernel is too large");
+    let depthwise = model(
+        vec![vec![0; 2 * (k * k) as usize]],
+        vec![(vec![1, 40, 40, 1], FLOAT32, None), (vec![1, k, k, 1], FLOAT16, Some(0)), (vec![1, 40, 40, 1], FLOAT32, None)],
+        vec![(op::DEPTHWISE_CONV_2D, vec![0, 1, -1], vec![2], window_opts(0, 1))],
+        vec![0],
+        vec![2],
+    );
+    refused(&depthwise, "kernel is too large");
+    // A "same" pool takes any window: a huge one looped for billions of steps per output.
+    let mut opts = window_opts(0, 1);
+    opts.extend([(3, V::Int(i32::MAX)), (4, V::Int(i32::MAX))]);
+    let pool = model(
+        vec![],
+        vec![(vec![1, 8, 8, 1], FLOAT32, None), (vec![1, 8, 8, 1], FLOAT32, None)],
+        vec![(op::MAX_POOL_2D, vec![0], vec![1], opts)],
+        vec![0],
+        vec![1],
+    );
+    refused(&pool, "pooling window is too large");
+}
+
+#[test]
+fn multiply_adds_are_bounded() {
+    // Three 16 → 16 pointwise convolutions over 4096×4096: 3·2³² multiply-adds.
+    let s = vec![1, 4096, 4096, 16];
+    let t = |buf| (s.clone(), FLOAT32, buf);
+    let m = model(
+        vec![vec![0; 2 * 16 * 16]],
+        vec![t(None), (vec![16, 1, 1, 16], FLOAT16, Some(0)), t(None), t(None), t(None)],
+        (0..3).map(|i| (op::CONV_2D, vec![if i == 0 { 0 } else { i + 1 }, 1, -1], vec![i + 2], window_opts(0, 1))).collect(),
+        vec![0],
+        vec![4],
+    );
+    refused(&m, "too many multiply-adds");
+}
+
+/// #368: 2000 RELUs over 2²⁵ values loaded fine, and one run took minutes.
+#[test]
+fn elementwise_work_is_bounded() {
+    let n = 2000;
+    let m = model(
+        vec![],
+        (0..=n).map(|_| (vec![1, 1 << 25], FLOAT32, None)).collect(),
+        (0..n).map(|i| (op::RELU, vec![i], vec![i + 1], vec![])).collect(),
+        vec![0],
+        vec![n],
+    );
+    refused(&m, "too much work");
+}
+
+#[test]
+fn memory_alive_at_once_is_bounded() {
+    // Five outputs of 2²⁷ values each, all kept, besides the input.
+    let m = model(
+        vec![],
+        (0..6).map(|_| (vec![1, 1 << 27], FLOAT32, None)).collect(),
+        (1..6).map(|i| (op::RELU, vec![0], vec![i], vec![])).collect(),
+        vec![0],
+        (1..6).collect(),
+    );
+    refused(&m, "too much memory");
+}
+
+#[test]
+fn shapes_computed_at_run_time_must_match_the_declared_ones() {
+    // PAD to 2³⁰ × 2³⁰ while declaring a 1×1 output.
+    let pads = vec![0, 1 << 30, 0, 1 << 30].into_iter().flat_map(i32::to_le_bytes).collect();
+    let pad = model(
+        vec![pads],
+        vec![(vec![1, 1], FLOAT32, None), (vec![2, 2], INT32, Some(0)), (vec![1, 1], FLOAT32, None)],
+        vec![(op::PAD, vec![0, 1], vec![2], vec![])],
+        vec![0],
+        vec![2],
+    );
+    refused(&pad, "padding disagrees");
+    // Many large parts concatenated into a small declared output.
+    let concat = model(
+        vec![],
+        vec![(vec![1, 1 << 27], FLOAT32, None), (vec![1, 2], FLOAT32, None)],
+        vec![(op::CONCATENATION, vec![0; 64], vec![1], vec![(0, V::Int(1))])],
+        vec![0],
+        vec![1],
+    );
+    refused(&concat, "parts disagree");
+    // A pool whose output claims more channels than its input has.
+    let pool = model(
+        vec![],
+        vec![(vec![1, 2, 2, 1], FLOAT32, None), (vec![1, 1, 1, 1 << 20], FLOAT32, None)],
+        vec![(op::MAX_POOL_2D, vec![0], vec![1], window_opts(1, 2).into_iter().chain([(3, V::Int(2)), (4, V::Int(2))]).collect())],
+        vec![0],
+        vec![1],
+    );
+    refused(&pool, "changes the channels");
+    // Dimensions may not hide behind a zero.
+    let zero = model(vec![], vec![(vec![0, 1 << 30, 1 << 30], FLOAT32, None)], vec![], vec![0], vec![0]);
+    refused(&zero, "tensor is too large");
+}
+
+#[test]
+fn shared_weights_count_once_per_use() {
+    // One 128 KB buffer decoded for 2100 tensors would be 2100 copies of 2¹⁶ floats.
+    let m = model(vec![vec![0; 2 << 16]], (0..2100).map(|_| (vec![1, 1 << 16], FLOAT16, Some(0))).collect(), vec![], vec![], vec![]);
+    refused(&m, "weights are too large");
+}
+
+/// The official face models (`EFFECTCRAFT_FACE_LANDMARKER` = path to `face_landmarker.task`)
+/// fit every budget with wide headroom.
+#[test]
+fn official_face_models_fit_the_budgets() {
+    let Some(path) = std::env::var_os("EFFECTCRAFT_FACE_LANDMARKER") else { return };
+    let bytes = std::fs::read(path).unwrap();
+    for name in [crate::mediapipe::DETECTOR, crate::mediapipe::MESH] {
+        let c = Model::read(&crate::pt::zip_file(&bytes, name).unwrap()).unwrap().cost().unwrap();
+        println!("{name}: {c:?}");
+        assert!(c.macs <= MAX_MACS / 8 && c.values <= MAX_VALUES / 8 && c.live <= MAX_LIVE / 8 && c.scratch <= MAX_SCRATCH / 8, "{name}: {c:?}");
+        assert!(c.kernel <= MAX_KERNEL as u64 / 4, "{name}: {c:?}");
+    }
+}
diff --git a/crates/svg/src/lib.rs b/crates/svg/src/lib.rs
index 60f39adc6..95c00a91a 100644
--- a/crates/svg/src/lib.rs
+++ b/crates/svg/src/lib.rs
@@ -470,6 +470,39 @@ fn strip_comments(s: &str) -> String {
     out
 }
 
+/// Splits one simple selector (`tag.class#id`) into its tag, classes and id.
+fn parse_compound(one: &str) -> (Option<String>, Vec<String>, Option<String>) {
+    let mut tag = None;
+    let mut classes = vec![];
+    let mut id = None;
+    let mut cur = String::new();
+    let mut kind = 't';
+    let flush = |kind: char, cur: &mut String, tag: &mut Option<String>, classes: &mut Vec<String>, id: &mut Option<String>| {
+        if !cur.is_empty() {
+            match kind {
+                '.' => classes.push(std::mem::take(cur)),
+                '#' => *id = Some(std::mem::take(cur)),
+                _ => {
+                    if cur != "*" {
+                        *tag = Some(std::mem::take(cur));
+                    }
+                    cur.clear();
+                }
+            }
+        }
+    };
+    for c in one.chars() {
+        if c == '.' || c == '#' {
+            flush(kind, &mut cur, &mut tag, &mut classes, &mut id);
+            kind = c;
+        } else {
+            cur.push(c);
+        }
+    }
+    flush(kind, &mut cur, &mut tag, &mut classes, &mut id);
+    (tag, classes, id)
+}
+
 /// Add the rules of one `<style>` sheet. Errs once the sheets exceed [`MAX_CSS_SELECTORS`] or
 /// [`MAX_CSS_DECLARATIONS`] (#2140).
 fn parse_css(css: &str, sheet: &mut StyleSheet) -> Result<(), Error> {
@@ -477,12 +510,30 @@ fn parse_css(css: &str, sheet: &mut StyleSheet) -> Result<(), Error> {
     let mut rest = css.as_str();
     while let Some(open) = rest.find('{') {
         let sel = rest[..open].trim();
+        if sel.starts_with('@') {
+            // Skip the whole at-rule block, matching nested braces by depth.
+            let mut depth = 0usize;
+            let mut end = None;
+            for (i, c) in rest[open..].char_indices() {
+                match c {
+                    '{' => depth = depth.saturating_add(1),
+                    '}' => {
+                        depth = depth.saturating_sub(1);
+                        if depth == 0 {
+                            end = Some(open + i + 1);
+                            break;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            let Some(end) = end else { break };
+            rest = &rest[end..];
+            continue;
+        }
         let Some(close) = rest[open..].find('}') else { break };
         let body = &rest[open + 1..open + close];
         rest = &rest[open + close + 1..];
-        if sel.starts_with('@') {
-            continue;
-        }
         let mut decls = parse_decls(body);
         sheet.decls = sheet.decls.saturating_add(decls.len());
         if sheet.decls > MAX_CSS_DECLARATIONS {
@@ -505,34 +556,7 @@ fn parse_css(css: &str, sheet: &mut StyleSheet) -> Result<(), Error> {
                 sheet.blocks.push(std::mem::take(&mut decls));
                 i
             });
-            let mut tag = None;
-            let mut classes = vec![];
-            let mut id = None;
-            let mut cur = String::new();
-            let mut kind = 't';
-            let flush = |kind: char, cur: &mut String, tag: &mut Option<String>, classes: &mut Vec<String>, id: &mut Option<String>| {
-                if !cur.is_empty() {
-                    match kind {
-                        '.' => classes.push(std::mem::take(cur)),
-                        '#' => *id = Some(std::mem::take(cur)),
-                        _ => {
-                            if cur != "*" {
-                                *tag = Some(std::mem::take(cur));
-                            }
-                            cur.clear();
-                        }
-                    }
-                }
-            };
-            for c in one.chars() {
-                if c == '.' || c == '#' {
-                    flush(kind, &mut cur, &mut tag, &mut classes, &mut id);
-                    kind = c;
-                } else {
-                    cur.push(c);
-                }
-            }
-            flush(kind, &mut cur, &mut tag, &mut classes, &mut id);
+            let (tag, classes, id) = parse_compound(one);
             let specificity = (id.is_some() as u32 * 100)
                 .saturating_add(u32::try_from(classes.len()).unwrap_or(u32::MAX).saturating_mul(10))
                 .saturating_add(tag.is_some() as u32);
@@ -1237,6 +1261,10 @@ fn xml_depth(text: &str) -> usize {
     max
 }
 
+/// Nodes a document may expand to: a few kilobytes of nested internal entities
+/// (`<!ENTITY b "&a;&a;…">`) otherwise expand to millions and exhaust memory.
+const MAX_XML_NODES: u32 = 4_000_000;
+
 /// Parse an SVG document.
 pub fn parse(bytes: &[u8]) -> Result<Doc, Error> {
     let text = String::from_utf8_lossy(bytes);
@@ -1244,7 +1272,8 @@ pub fn parse(bytes: &[u8]) -> Result<Doc, Error> {
     if xml_depth(text) > MAX_XML_DEPTH {
         return Err(Error::Xml(format!("elements nested more than {MAX_XML_DEPTH} levels deep")));
     }
-    let opts = roxmltree::ParsingOptions { allow_dtd: true, ..Default::default() };
+    // DTDs stay allowed (Illustrator's SVGs declare entities), but expansion is bounded (#2129).
+    let opts = roxmltree::ParsingOptions { allow_dtd: true, nodes_limit: MAX_XML_NODES, ..Default::default() };
     let xml = roxmltree::Document::parse_with_options(text, opts).map_err(|e| Error::Xml(e.to_string()))?;
     let root = xml.root_element();
     if root.tag_name().name() != "svg" {
diff --git a/crates/svg/src/pathdata.rs b/crates/svg/src/pathdata.rs
index c8fa7f67f..7a2762db7 100644
--- a/crates/svg/src/pathdata.rs
+++ b/crates/svg/src/pathdata.rs
@@ -226,9 +226,18 @@ fn segment(l: &mut Lex, c: u8, base: Vec2, p: &mut BezPath, cur: &mut Point, las
             let sweep = l.flag()?;
             let e = pt(l)?;
             let arc = SvgArc { from: *cur, to: e, radii: Vec2::new(rx, ry), x_rotation: rot.to_radians(), large_arc: large, sweep };
-            match kurbo::Arc::from_svg_arc(&arc) {
-                Some(a) => a.to_cubic_beziers(0.1, |c1, c2, end| p.curve_to(c1, c2, end)),
-                None => p.line_to(e),
+            let mut last_end = None;
+            if let Some(a) = kurbo::Arc::from_svg_arc(&arc) {
+                // Scale tolerance with the radius so the segment count stays bounded.
+                let tol = 0.1_f64.max(a.radii.x.max(a.radii.y) * 1e-4);
+                a.to_cubic_beziers(tol, |c1, c2, end| {
+                    p.curve_to(c1, c2, end);
+                    last_end = Some(end);
+                });
+            }
+            // Degenerate arcs (e.g. huge radii) may emit nothing or stop short of the end point.
+            if last_end.is_none_or(|q| (q - e).hypot() > 1e-3 * (1.0 + e.to_vec2().hypot())) {
+                p.line_to(e);
             }
             *cur = e;
             *last_cubic = None;
@@ -261,6 +270,12 @@ mod tests {
     use super::*;
     use kurbo::PathEl;
 
+    #[test]
+    fn huge_arc_radius_stays_bounded() {
+        let p = parse_path_data("M0 0A1e36 1e36 0 1 1 1e30 0");
+        assert!(p.elements().len() < 1000, "got {} elements", p.elements().len());
+    }
+
     #[test]
     fn commands() {
         let p = parse_path_data("M10,10 L20,10 h10 v10 H10 z m5 5 l1-1.5.5.5e1 C 0 0 1 1 2 2 s3 3 4 4 Q1 1 2 2 t3 3 A5 5 0 0 1 20 20 a5 5 0 1010 0");
@@ -294,6 +309,18 @@ mod tests {
         assert!(parse_path_data("M0 0 L10 0 z 9 9").elements().len() <= 4);
     }
 
+    #[test]
+    fn huge_radius_arc_still_reaches_end_point() {
+        for d in ["M0 0 A1e20 1e20 0 0 1 10 0 L10 10", "M0 0 A1e20 1e20 0 1 1 10 0 L10 10", "M0 0 a1e20 1e20 0 0 1 10 0 L10 10"] {
+            let p = parse_path_data(d);
+            let reaches = p.elements().iter().any(|e| match e {
+                PathEl::LineTo(q) | PathEl::CurveTo(_, _, q) => (q.x - 10.0).abs() < 1e-6 && q.y.abs() < 1e-6,
+                _ => false,
+            });
+            assert!(reaches, "{d}: {:?}", p.elements());
+        }
+    }
+
     #[test]
     fn number_lists() {
         assert_eq!(numbers("0 0,100 50"), vec![0.0, 0.0, 100.0, 50.0]);
diff --git a/crates/svg/src/raster.rs b/crates/svg/src/raster.rs
index 8ccfa58c7..568b10b25 100644
--- a/crates/svg/src/raster.rs
+++ b/crates/svg/src/raster.rs
@@ -6,7 +6,7 @@ use effectcraft_raster::{Image, Mask};
 use kurbo::{Affine, Point, Shape as _};
 use rayon::prelude::*;
 
-use crate::{BlendMode, Doc, FillRule, Gradient, GradientKind, Group, Node, Paint, Shape, Spread};
+use crate::{BlendMode, Doc, FillRule, Gradient, GradientKind, Group, Node, Paint, Shape, SoftMask, Spread};
 
 fn mat3(a: Affine) -> Mat3 {
     let c = a.as_coeffs();
@@ -77,6 +77,11 @@ fn draw_group(g: &Group, m: Affine, opacity: f64, dst: &mut Image, budget: &mut
         }
         return;
     }
+    draw_offscreen_group(g, m, o, dst, budget);
+}
+
+/// Draws a group through an offscreen buffer, then composites it onto `dst`.
+fn draw_offscreen_group(g: &Group, m: Affine, o: f64, dst: &mut Image, budget: &mut SurfaceBudget) {
     let only_clip = g.mask.is_none() && g.blend == BlendMode::Normal && o >= 1.0 && !g.knockout;
     // Draw the children on their own (isolated) or over a copy of the backdrop, keep what
     // every clip path covers and the soft mask lets through, then composite with the group's
@@ -85,65 +90,24 @@ fn draw_group(g: &Group, m: Affine, opacity: f64, dst: &mut Image, budget: &mut
     if !g.isolated && backdrop.is_none() {
         return;
     }
-    let mut tmp = match &backdrop {
-        Some(b) => match budget.image(dst.width, dst.height, Some(b)) {
-            Some(image) => image,
-            None => {
-                budget.release(b);
-                return;
-            }
-        },
-        None => match budget.image(dst.width, dst.height, None) {
-            Some(image) => image,
-            None => return,
-        },
+    let Some(mut tmp) = budget.image(dst.width, dst.height, backdrop.as_ref()) else {
+        release_backdrop(budget, backdrop.as_ref());
+        return;
     };
     draw_children(g, m, &mut tmp, backdrop.as_ref(), budget);
     if let Some(b) = &backdrop {
         if only_clip {
             // A non-isolated clipping group: the backdrop where the clip excludes the children.
-            let cov = clip_coverage(g, m, dst.width, dst.height);
-            dst.data.par_iter_mut().zip(tmp.data.par_iter()).zip(cov.par_iter()).for_each(|((d, t), c)| {
-                for i in 0..4 {
-                    d[i] = d[i] * (1.0 - c) + t[i] * c;
-                }
-            });
+            clip_onto_backdrop(g, m, dst, &tmp);
             budget.release(&tmp);
-            drop(tmp);
-            if let Some(b) = &backdrop {
-                budget.release(b);
-            }
+            release_backdrop(budget, backdrop.as_ref());
             return;
         }
-        // Remove the backdrop's contribution (ISO 32000-1 §11.4.8): with the group's own
-        // alpha αg (its children alone), C = Cn + (Cn − C0)·(α0/αg − α0).
-        let Some(mut solo) = budget.image(dst.width, dst.height, None) else {
+        if !strip_backdrop(g, m, b, &mut tmp, budget) {
             budget.release(&tmp);
-            drop(tmp);
-            if let Some(b) = &backdrop {
-                budget.release(b);
-            }
+            release_backdrop(budget, backdrop.as_ref());
             return;
-        };
-        draw_children(g, m, &mut solo, None, budget);
-        tmp.data.par_iter_mut().zip(b.data.par_iter()).zip(solo.data.par_iter()).for_each(|((t, b0), s)| {
-            let ag = s[3];
-            if ag <= 0.0 {
-                *t = [0.0; 4];
-                return;
-            }
-            let un = |c: &[f32; 4]| if c[3] > 0.0 { [c[0] / c[3], c[1] / c[3], c[2] / c[3]] } else { [0.0; 3] };
-            let (cn, c0, a0) = (un(t), un(b0), b0[3]);
-            let k = a0 / ag - a0;
-            let mut out = [0.0; 4];
-            for i in 0..3 {
-                out[i] = (cn[i] + (cn[i] - c0[i]) * k).clamp(0.0, 1.0) * ag;
-            }
-            out[3] = ag;
-            *t = out;
-        });
-        budget.release(&solo);
-        drop(solo);
+        }
     }
     if !g.clip.is_empty() {
         let cov = clip_coverage(g, m, dst.width, dst.height);
@@ -153,33 +117,12 @@ fn draw_group(g: &Group, m: Affine, opacity: f64, dst: &mut Image, budget: &mut
             }
         });
     }
-    if let Some(sm) = &g.mask {
-        let Some(mut mk) = budget.image(dst.width, dst.height, None) else {
-            budget.release(&tmp);
-            drop(tmp);
-            if let Some(b) = &backdrop {
-                budget.release(b);
-            }
-            return;
-        };
-        draw_group(&sm.content, m, 1.0, &mut mk, budget);
-        let bc = sm.backdrop.map(|v| v as f32);
-        let lum = sm.luminosity;
-        tmp.data.par_iter_mut().zip(mk.data.par_iter()).for_each(|(p, q)| {
-            let k = if lum {
-                // The mask group composited over its backdrop colour, then its luminosity.
-                let c = [0, 1, 2].map(|i| q[i] + bc[i] * (1.0 - q[3]));
-                0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2]
-            } else {
-                q[3]
-            };
-            let k = k.clamp(0.0, 1.0);
-            for v in p.iter_mut() {
-                *v *= k;
-            }
-        });
-        budget.release(&mk);
-        drop(mk);
+    if let Some(sm) = &g.mask
+        && !apply_soft_mask(sm, m, &mut tmp, budget)
+    {
+        budget.release(&tmp);
+        release_backdrop(budget, backdrop.as_ref());
+        return;
     }
     if g.blend == BlendMode::Normal {
         over(dst, &tmp, o as f32);
@@ -194,12 +137,81 @@ fn draw_group(g: &Group, m: Affine, opacity: f64, dst: &mut Image, budget: &mut
         });
     }
     budget.release(&tmp);
-    drop(tmp);
-    if let Some(b) = &backdrop {
+    release_backdrop(budget, backdrop.as_ref());
+}
+
+fn release_backdrop(budget: &mut SurfaceBudget, backdrop: Option<&Image>) {
+    if let Some(b) = backdrop {
         budget.release(b);
     }
 }
 
+/// A clipping group over a backdrop: the children where the clip covers, the backdrop elsewhere.
+fn clip_onto_backdrop(g: &Group, m: Affine, dst: &mut Image, tmp: &Image) {
+    let cov = clip_coverage(g, m, dst.width, dst.height);
+    dst.data.par_iter_mut().zip(tmp.data.par_iter()).zip(cov.par_iter()).for_each(|((d, t), c)| {
+        for i in 0..4 {
+            d[i] = d[i] * (1.0 - c) + t[i] * c;
+        }
+    });
+}
+
+/// Remove the backdrop's contribution (ISO 32000-1 §11.4.8): with the group's own
+/// alpha αg (its children alone), C = Cn + (Cn − C0)·(α0/αg − α0). Returns false when no
+/// scratch buffer is available.
+fn strip_backdrop(g: &Group, m: Affine, backdrop: &Image, tmp: &mut Image, budget: &mut SurfaceBudget) -> bool {
+    let Some(mut solo) = budget.image(tmp.width, tmp.height, None) else {
+        return false;
+    };
+    draw_children(g, m, &mut solo, None, budget);
+    tmp.data.par_iter_mut().zip(backdrop.data.par_iter()).zip(solo.data.par_iter()).for_each(|((t, b0), s)| {
+        let ag = s[3];
+        if ag <= 0.0 {
+            *t = [0.0; 4];
+            return;
+        }
+        let un = |c: &[f32; 4]| if c[3] > 0.0 { [c[0] / c[3], c[1] / c[3], c[2] / c[3]] } else { [0.0; 3] };
+        let (cn, c0, a0) = (un(t), un(b0), b0[3]);
+        let k = a0 / ag - a0;
+        let mut out = [0.0; 4];
+        for i in 0..3 {
+            out[i] = (cn[i] + (cn[i] - c0[i]) * k).clamp(0.0, 1.0) * ag;
+        }
+        out[3] = ag;
+        *t = out;
+    });
+    budget.release(&solo);
+    drop(solo);
+    true
+}
+
+/// Multiplies the group's pixels by its soft mask. Returns false when no scratch buffer is
+/// available.
+fn apply_soft_mask(sm: &SoftMask, m: Affine, tmp: &mut Image, budget: &mut SurfaceBudget) -> bool {
+    let Some(mut mk) = budget.image(tmp.width, tmp.height, None) else {
+        return false;
+    };
+    draw_group(&sm.content, m, 1.0, &mut mk, budget);
+    let bc = sm.backdrop.map(|v| v as f32);
+    let lum = sm.luminosity;
+    tmp.data.par_iter_mut().zip(mk.data.par_iter()).for_each(|(p, q)| {
+        let k = if lum {
+            // The mask group composited over its backdrop colour, then its luminosity.
+            let c = [0, 1, 2].map(|i| q[i] + bc[i] * (1.0 - q[3]));
+            0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2]
+        } else {
+            q[3]
+        };
+        let k = k.clamp(0.0, 1.0);
+        for v in p.iter_mut() {
+            *v *= k;
+        }
+    });
+    budget.release(&mk);
+    drop(mk);
+    true
+}
+
 /// The product of a group's clip-path coverages.
 fn clip_coverage(g: &Group, m: Affine, w: u32, h: u32) -> Vec<f32> {
     let mut out = vec![1.0f32; w as usize * h as usize];
diff --git a/crates/svg/src/tests.rs b/crates/svg/src/tests.rs
index 466c9053e..06dfbd333 100644
--- a/crates/svg/src/tests.rs
+++ b/crates/svg/src/tests.rs
@@ -220,6 +220,18 @@ fn transforms() {
     assert!((p.x - 6.0).abs() < 1e-9 && (p.y - 7.0).abs() < 1e-9);
 }
 
+#[test]
+fn nested_entities_are_refused_instead_of_expanding_without_bound() {
+    // #2129: each top-level `&b;` stays under roxmltree's per-reference cap but adds 12 500
+    // nodes, so 40 KB of references expands to 5 million.
+    let dtd = format!("<!ENTITY a \"{}\"><!ENTITY b \"{}\">", "<g/>".repeat(50), "&a;".repeat(250));
+    let bomb = format!("<?xml version=\"1.0\"?><!DOCTYPE svg [{dtd}]><svg xmlns=\"http://www.w3.org/2000/svg\">{}</svg>", "&b;".repeat(400));
+    assert!(matches!(crate::parse(bomb.as_bytes()), Err(crate::Error::Xml(_))));
+    // An ordinary entity, as Illustrator declares them, still parses.
+    let ok = "<?xml version=\"1.0\"?><!DOCTYPE svg [<!ENTITY w \"40\">]><svg xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"&w;\" height=\"5\"/></svg>";
+    assert!(crate::parse(ok.as_bytes()).is_ok());
+}
+
 #[test]
 fn deep_nesting_errors_instead_of_overflowing_the_stack() {
     // 100 000 nested groups overflowed the XML parser's stack and aborted the process.
@@ -422,3 +434,15 @@ fn font_size_percentage_resolves_against_the_parent_font_size() {
         assert!(matches!(shapes[0].2.geom, Geom::Rect { w, .. } if w == expected), "{body}: {:?}", shapes[0].2.geom);
     }
 }
+
+#[test]
+fn at_rule_blocks_are_skipped_by_brace_depth() {
+    let mut sheet = StyleSheet::default();
+    parse_css("@media print { .a{fill:#ff0000} .b{fill:#0000ff} } .c{fill:red}", &mut sheet).unwrap();
+    assert_eq!(sheet.rules.len(), 1);
+    assert_eq!(sheet.rules[0].classes, vec!["c".to_string()]);
+    let mut sheet = StyleSheet::default();
+    parse_css("@media x { @supports y { .c{} } .d{} } .e{fill:red}", &mut sheet).unwrap();
+    assert_eq!(sheet.rules.len(), 1);
+    assert_eq!(sheet.rules[0].classes, vec!["e".to_string()]);
+}
diff --git a/crates/text/src/fonts.rs b/crates/text/src/fonts.rs
index e20ffcbd1..5388629cf 100644
--- a/crates/text/src/fonts.rs
+++ b/crates/text/src/fonts.rs
@@ -292,15 +292,37 @@ impl Face {
 }
 
 struct Db {
+    fallback: Arc<Face>,
     faces: Vec<Arc<Face>>,
     scanned: bool,
 }
 
+/// Keep the compiled-in regular face available independently of discovery results.
+fn bundled_default_face() -> Arc<Face> {
+    let info =
+        read_faces_bytes(INTER_REGULAR).into_iter().next().map(|n| info_from(n, FaceData::Static(INTER_REGULAR), "bundled")).unwrap_or_else(|| FaceInfo {
+            family: DEFAULT_FAMILY.into(),
+            style: "Regular".into(),
+            weight: 400,
+            italic: false,
+            index: 0,
+            data: FaceData::Static(INTER_REGULAR),
+            origin: "bundled",
+            native_family: None,
+            full_name: "Inter Regular".into(),
+            postscript: Some("Inter-Regular".into()),
+            variable: false,
+            instances: Vec::new(),
+        });
+    Arc::new(Face { id: 0, info, bytes: OnceLock::new(), shaper: OnceLock::new() })
+}
+
 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] {
+        let fallback = bundled_default_face();
+        let mut db = Db { faces: vec![fallback.clone()], fallback, scanned: false };
+        for b in [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"));
             }
@@ -363,7 +385,8 @@ pub fn scan_system() -> usize {
 }
 
 /// Scan the system font folders again, adding fonts installed since the last scan (faces already
-/// known are kept, so font ids stay valid). Returns the number of faces added.
+/// known are kept, so font ids stay valid). Returns the number of faces added. This walks every
+/// fontconfig directory, so the UI calls [`start_rescan`] instead of running it on the frame thread.
 pub fn rescan_system() -> usize {
     let _scan = SCAN.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
     let n = if cfg!(target_arch = "wasm32") { 0 } else { add_source(&DirectorySource::system()) };
@@ -371,6 +394,60 @@ pub fn rescan_system() -> usize {
     n
 }
 
+/// A rescan started by [`start_rescan`], if one is in flight or finished and not yet polled.
+#[cfg(not(target_arch = "wasm32"))]
+static RESCAN: std::sync::Mutex<Option<std::thread::JoinHandle<usize>>> = std::sync::Mutex::new(None);
+
+/// Start [`rescan_system`] on a background thread. Returns false when a rescan is already
+/// running, the thread could not be spawned, or this build has no system font folders (wasm).
+pub fn start_rescan() -> bool {
+    #[cfg(target_arch = "wasm32")]
+    {
+        false
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        let mut slot = RESCAN.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+        if slot.as_ref().is_some_and(|h| !h.is_finished()) {
+            return false;
+        }
+        match std::thread::Builder::new().name("font-rescan".into()).spawn(rescan_system) {
+            Ok(handle) => {
+                *slot = Some(handle);
+                true
+            }
+            Err(_) => false,
+        }
+    }
+}
+
+/// Whether a background rescan is still walking the font folders.
+pub fn rescan_busy() -> bool {
+    #[cfg(target_arch = "wasm32")]
+    {
+        false
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        RESCAN.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().is_some_and(|h| !h.is_finished())
+    }
+}
+
+/// Faces added by the latest background rescan, once that thread has finished. `None` while it
+/// is still running or when nothing was started.
+pub fn poll_rescan() -> Option<usize> {
+    #[cfg(target_arch = "wasm32")]
+    {
+        None
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        let mut slot = RESCAN.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+        let finished = slot.as_ref().is_some_and(std::thread::JoinHandle::is_finished);
+        if finished { slot.take().and_then(|h| h.join().ok()) } else { None }
+    }
+}
+
 /// Start the system font scan on a background thread, so the font menus are complete by the
 /// time someone opens them without the first open waiting for the scan. Native only; on wasm
 /// (no threads, no font folders) this does nothing.
@@ -394,10 +471,7 @@ pub fn system_scanned() -> bool {
 /// 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(std::sync::PoisonError::into_inner);
-    // The bundled fonts are compiled in and always parse (`tests::bundled_families_and_resolution` checks them), so
-    // the database is never empty.
-    #[allow(clippy::expect_used)]
-    d.faces.get(id).or_else(|| d.faces.first()).cloned().expect("bundled fonts present")
+    d.faces.get(id).cloned().unwrap_or_else(|| d.fallback.clone())
 }
 
 /// All faces (bundled first).
@@ -688,14 +762,28 @@ const JAPANESE_FAMILIES: &[&str] = &[
 ];
 /// Han ideograph families for Simplified Chinese, in the order the platforms' own fallback tables
 /// prefer them (Windows, macOS, then the Linux/Noto names). Missing ones cost one name lookup each.
-const SIMPLIFIED_CHINESE_FAMILIES: &[&str] =
-    &["Microsoft YaHei", "SimSun", "PingFang SC", "Noto Sans CJK SC", "Noto Sans SC", "Source Han Sans SC", "WenQuanYi Micro Hei"];
+/// `Hiragino Sans GB`, `Heiti SC` and `Songti SC` are the Simplified faces a macOS install without
+/// the on-demand PingFang has (macOS 27 on an English install ships them, not PingFang): without
+/// them Chinese Han text fell through to the Japanese face and drew Japanese glyph forms (#453).
+const SIMPLIFIED_CHINESE_FAMILIES: &[&str] = &[
+    "Microsoft YaHei",
+    "SimSun",
+    "PingFang SC",
+    "Hiragino Sans GB",
+    "Heiti SC",
+    "Songti SC",
+    "STSong",
+    "Noto Sans CJK SC",
+    "Noto Sans SC",
+    "Source Han Sans SC",
+    "WenQuanYi Micro Hei",
+];
 /// The same for Traditional Chinese. The two scripts share almost all of their code points but not
 /// the glyph forms (`东` against `東`'s neighbours, `直`, `骨`), so one list for both drew a
 /// Traditional interface with Simplified forms - the faces do not differ in *coverage*, which is
 /// what the fallback search checks, so the script has to pick the list.
 const TRADITIONAL_CHINESE_FAMILIES: &[&str] =
-    &["Microsoft JhengHei", "MingLiU", "PingFang TC", "Heiti TC", "Hiragino Sans CNS", "Noto Sans CJK TC", "Noto Sans TC", "Source Han Sans TC"];
+    &["Microsoft JhengHei", "MingLiU", "PingFang TC", "Heiti TC", "Hiragino Sans CNS", "Songti TC", "Noto Sans CJK TC", "Noto Sans TC", "Source Han Sans TC"];
 const KOREAN_FAMILIES: &[&str] = &["Malgun Gothic", "Gulim", "Apple SD Gothic Neo", "Noto Sans CJK KR", "Noto Sans KR", "Source Han Sans KR", "NanumGothic"];
 /// The platforms' plain text families for the other scripts the bundled fonts lack, in the same
 /// order (Windows, macOS, then the Linux/Noto names).
@@ -1030,476 +1118,4 @@ fn system_fallback(c: char, style: &str) -> Option<FaceId> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// Concurrent language requests must neither choose another context's font nor reuse its
-    /// cached family order. Synthetic fonts in a child process keep this independent of the host
-    /// font installation and of other tests that exercise the process-global database/locale.
-    #[test]
-    #[cfg(not(target_arch = "wasm32"))]
-    fn cjk_requests_keep_their_language_and_cache_entries() {
-        const CHILD: &str = "EFFECTCRAFT_TEST_ISOLATED_CJK";
-        if std::env::var_os(CHILD).is_none() {
-            let output = std::process::Command::new(std::env::current_exe().unwrap())
-                .args(["--exact", "fonts::tests::cjk_requests_keep_their_language_and_cache_entries", "--nocapture"])
-                .env(CHILD, "1")
-                .output()
-                .unwrap();
-            assert!(output.status.success(), "{}\n{}", String::from_utf8_lossy(&output.stdout), String::from_utf8_lossy(&output.stderr));
-            return;
-        }
-        let families = [("ja", "Yu Gothic"), ("zh-hans", "Microsoft YaHei"), ("zh-hant", "Microsoft JhengHei"), ("ko", "Malgun Gothic")];
-        let mut expected = Vec::new();
-        {
-            let mut d = db().write().unwrap();
-            d.scanned = true; // This test process uses only bundled and synthetic fonts.
-            for (language, family) in families {
-                let mut data = test_font(family);
-                let table = data[12..12 + 8 * 16].as_chunks::<16>().0.iter().find(|t| &t[..4] == b"cmap").unwrap();
-                let cmap = u32::from_be_bytes(table[8..12].try_into().unwrap()) as usize + 12;
-                // Map 页 to the fixture's triangle glyph instead of its private-use range.
-                // All four fonts cover the probe, so coverage cannot choose the right language.
-                for (offset, value) in [(16, '页' as u16), (24, '页' as u16), (30, 2u16.wrapping_sub('页' as u16))] {
-                    data[cmap + offset..cmap + offset + 2].copy_from_slice(&value.to_be_bytes());
-                }
-                let data = Arc::new(data);
-                let names = read_faces_bytes(&data).into_iter().next().unwrap();
-                let id = push(&mut d, info_from(names, FaceData::Shared(data), "test"));
-                expected.push((language, id));
-            }
-        }
-        let base = resolve("Inter", "Regular").face;
-        for &(_, id) in &expected {
-            assert!(face(id).has_char('页'));
-        }
-        // Force the original interleaving: Chinese starts, then Japanese replaces the global
-        // language before Chinese looks up its probe. The explicit request must still win.
-        set_cjk_locale("zh-hans");
-        set_cjk_locale("ja");
-        assert_eq!(fallback_for('页', base), expected[0].1);
-        assert_eq!(fallback_for_locale('页', base, "zh-hans"), expected[1].1);
-        // Do not clear the cache here: different policies must coexist in the same cache.
-        for _ in 0..3 {
-            for &(language, id) in &expected {
-                assert_eq!(fallback_for_locale('页', base, language), id, "{language}");
-            }
-        }
-        let barrier = Arc::new(std::sync::Barrier::new(expected.len()));
-        let threads: Vec<_> = expected
-            .into_iter()
-            .map(|(language, id)| {
-                let barrier = barrier.clone();
-                std::thread::spawn(move || {
-                    barrier.wait();
-                    for _ in 0..128 {
-                        set_cjk_locale(if language == "ja" { "zh-hans" } else { "ja" });
-                        assert_eq!(fallback_for_locale('页', base, language), id, "{language}");
-                    }
-                })
-            })
-            .collect();
-        for thread in threads {
-            thread.join().unwrap();
-        }
-    }
-
-    #[test]
-    fn extra_font_dirs_come_from_a_path_list() {
-        assert!(extra_dirs(None).is_empty());
-        let v = std::env::join_paths(["/a/fonts", "/b/more"]).unwrap_or_default();
-        assert_eq!(extra_dirs(Some(&v)), vec![PathBuf::from("/a/fonts"), PathBuf::from("/b/more")]);
-        assert!(extra_dirs(Some(std::ffi::OsStr::new(""))).is_empty());
-    }
-
-    #[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);
-        let faces = all_faces();
-        assert!(faces.iter().any(|f| f.info.family == "Noto Serif" && f.info.style == "Regular" && f.info.origin == "bundled"));
-        // A real installed Bold Italic takes priority. Partial installed families can instead
-        // supply the nearest weight/slant, so neither synthesis flag is fixed by the OS.
-        for family in ["Noto Serif", "Inter"] {
-            let resolved = resolve(family, "Bold Italic");
-            let selected = face(resolved.face);
-            assert!(selected.info.family.eq_ignore_ascii_case(family));
-            assert!(!resolved.missing);
-            let candidates: Vec<_> = faces.iter().filter(|f| f.info.family.eq_ignore_ascii_case(family)).collect();
-            if let Some(exact) = candidates.iter().find(|f| f.info.style.eq_ignore_ascii_case("Bold Italic")) {
-                assert_eq!(resolved.face, exact.id, "real style wins for {family}");
-                assert!(!resolved.synth_bold && !resolved.synth_italic);
-            } else {
-                // Italic mismatch dominates any supported font weight distance.
-                let distance = |f: &Face| u32::from(f.info.weight.abs_diff(700)) + if f.info.italic { 0 } else { 1_000 };
-                let nearest = candidates.iter().map(|f| distance(f)).min().unwrap();
-                assert_eq!(distance(&selected), nearest, "closest available style for {family}");
-                assert_eq!(resolved.synth_bold, selected.info.weight <= 500);
-                assert_eq!(resolved.synth_italic, !selected.info.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_text("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 postscript_and_full_names_resolve() {
-        // Bundled Inter: name id 6 is `Inter-Bold`, name id 4 is `Inter Bold`.
-        let ps = resolve("Inter-Bold", "");
-        assert_eq!(face(ps.face).info.style, "Bold");
-        assert!(!ps.missing && !ps.synth_bold);
-        let full = resolve("inter semibold", "");
-        assert_eq!(face(full.face).info.style, "SemiBold");
-        assert!(!full.missing);
-        // A family name still wins over a name lookup.
-        assert_eq!(face(resolve("Inter", "Bold").face).info.style, "Bold");
-    }
-
-    /// #1563: a variable font's named instances are styles of its family. `fontStyle = "Black"`,
-    /// the instance's PostScript name (`font = "Figtree-Black"`) and its full name select the
-    /// instance's axis values instead of the default instance made bold synthetically, and the
-    /// font menus list every instance.
-    #[test]
-    fn variable_named_instances_resolve_and_list() {
-        const FAMILY: &str = "EffectCraft Instance Test";
-        let instances = [
-            ("Light", 300.0, Some("EffectCraftInstanceTest-Light")),
-            ("Regular", 400.0, Some("EffectCraftInstanceTest-Regular")),
-            ("Black", 900.0, Some("EffectCraftInstanceTest-Black")),
-            ("Extra Bold", 800.0, None),
-        ];
-        assert_eq!(add_font_data(crate::sfnt::test_font::variable(FAMILY, &instances, true)).len(), 1);
-        let wght = |r: &Resolved| instance_variations(r);
-        // By style name.
-        let black = resolve(FAMILY, "Black");
-        assert!(!black.missing && !black.synth_bold && !black.synth_italic, "{black:?}");
-        assert_eq!(wght(&black), vec![("wght".to_string(), 900.0)]);
-        assert_eq!(wght(&resolve(FAMILY, "regular")), vec![("wght".to_string(), 400.0)]);
-        // The face's own style is its default instance: no axis values to set.
-        let light = resolve(FAMILY, "Light");
-        assert_eq!((light.face, light.instance), (black.face, None));
-        // A style the family lacks takes the nearest instance's weight, no synthetic bold.
-        let bold = resolve(FAMILY, "Bold");
-        assert!(!bold.synth_bold, "{bold:?}");
-        assert_eq!(wght(&bold), vec![("wght".to_string(), 800.0)]);
-        // By PostScript name, the font's own and the derived one, and by full name.
-        let ps = resolve("EffectCraftInstanceTest-Black", "Regular");
-        assert!(!ps.missing && ps.face == black.face, "{ps:?}");
-        assert_eq!(wght(&ps), vec![("wght".to_string(), 900.0)]);
-        assert_eq!(wght(&resolve("EffectCraftInstanceTest-ExtraBold", "")), vec![("wght".to_string(), 800.0)]);
-        assert_eq!(wght(&resolve("effectcraft instance test extra bold", "")), vec![("wght".to_string(), 800.0)]);
-        // The font menu lists every instance, in weight order.
-        let fams = families();
-        let styles = &fams.iter().find(|(f, _)| f == FAMILY).unwrap().1;
-        assert_eq!(styles, &["Light", "Regular", "Extra Bold", "Black"]);
-        // Static fonts are untouched.
-        assert_eq!(resolve("Inter", "Bold").instance, None);
-    }
-
-    /// Axis values set on the text win over the instance's; the others keep the instance's.
-    #[test]
-    fn explicit_variations_override_the_instance() {
-        let base = vec![("wdth".to_string(), 75.0), ("wght".to_string(), 900.0)];
-        assert_eq!(merge_variations(&base, &[("wght".to_string(), 450.0)]), vec![("wdth".to_string(), 75.0), ("wght".to_string(), 450.0)]);
-        assert_eq!(merge_variations(&base, &[]), base);
-        assert_eq!(merge_variations(&[], &[("opsz".to_string(), 12.0)]), vec![("opsz".to_string(), 12.0)]);
-    }
-
-    #[test]
-    fn scripts_are_classified() {
-        assert_eq!(script_of('あ'), FallbackScript::Japanese);
-        assert_eq!(script_of('ｶ'), FallbackScript::Japanese);
-        assert_eq!(script_of('한'), FallbackScript::Korean);
-        assert_eq!(script_of('水'), FallbackScript::Han);
-        assert_eq!(script_of('、'), FallbackScript::Han);
-        assert_eq!(script_of('Ａ'), FallbackScript::Han);
-        assert_eq!(script_of('\u{20000}'), FallbackScript::Han);
-        assert_eq!(script_of('A'), FallbackScript::Other);
-        assert_eq!(script_of('م'), FallbackScript::Arabic);
-        assert_eq!(script_of('\u{fefb}'), FallbackScript::Arabic);
-        assert_eq!(script_of('\u{5d0}'), FallbackScript::Hebrew);
-        assert_eq!(script_of('क'), FallbackScript::Indic);
-        assert_eq!(script_of('த'), FallbackScript::Indic);
-        assert_eq!(script_of('ก'), FallbackScript::Thai);
-        assert_eq!(script_of('ა'), FallbackScript::Georgian);
-        assert_eq!(script_of('\u{1c90}'), FallbackScript::Georgian, "Mtavruli");
-        assert_eq!(script_of('\u{feff}'), FallbackScript::Other, "the byte order mark is no Arabic letter");
-    }
-
-    /// Native: Arabic, Hebrew, Indic and Thai text in a Latin-only family falls back to the
-    /// platform's plain text family for its script (#394), not to the first installed face that
-    /// covers it (on Windows a calligraphic Arabic face sorts first). Skipped per script where no
-    /// family from its list is installed.
-    #[test]
-    fn other_scripts_fall_back_to_a_plain_system_family() {
-        scan_system();
-        let inter = resolve("Inter", "Regular").face;
-        for (c, families) in [('م', ARABIC_FAMILIES), ('א', HEBREW_FAMILIES), ('क', INDIC_FAMILIES), ('த', INDIC_FAMILIES), ('ก', THAI_FAMILIES)] {
-            let covering = families.iter().any(|n| resolve_in(n, "Regular").is_some_and(|r| face(r.face).has_char(c)));
-            if !covering {
-                eprintln!("{c}: no family from the list is installed; skipping");
-                continue;
-            }
-            let f = face(fallback_for(c, inter));
-            assert!(f.has_char(c), "{c}: {} lacks it", f.info.family);
-            assert!(families.iter().any(|n| f.info.family.eq_ignore_ascii_case(n)), "{c} → {}", f.info.family);
-        }
-    }
-
-    /// Native: Mkhedruli in a Latin-only family falls back to a family from the Georgian list,
-    /// ahead of faces already loaded and of the scan order. Skipped where no family from the list
-    /// is installed.
-    #[test]
-    fn georgian_falls_back_to_a_georgian_system_family() {
-        scan_system();
-        let c = 'ა';
-        if !GEORGIAN_FAMILIES.iter().any(|n| resolve_in(n, "Regular").is_some_and(|r| face(r.face).has_char(c))) {
-            eprintln!("no Georgian family from the list is installed; skipping");
-            return;
-        }
-        let f = face(fallback_for(c, resolve("Inter", "Regular").face));
-        assert!(f.has_char(c), "{} lacks it", f.info.family);
-        assert!(GEORGIAN_FAMILIES.iter().any(|n| f.info.family.eq_ignore_ascii_case(n)), "{c} → {}", f.info.family);
-    }
-
-    /// Native: Japanese text in a Latin-only family falls back to an installed Japanese family
-    /// (whichever the platform ships) instead of the missing-glyph box, without any layer having
-    /// loaded a CJK font first. Skipped where no family from the list is installed.
-    #[test]
-    fn cjk_falls_back_to_a_system_family() {
-        scan_system();
-        let inter = resolve("Inter", "Bold").face;
-        let installed = JAPANESE_FAMILIES.iter().any(|f| resolve_in(f, "Regular").is_some());
-        if !installed {
-            eprintln!("no Japanese family installed; skipping");
-            return;
-        }
-        for c in ['水', 'あ', 'ア', '。'] {
-            let id = fallback_for(c, inter);
-            let f = face(id);
-            assert!(f.has_char(c), "{c}: {} {} lacks it", f.info.family, f.info.style);
-            assert!(JAPANESE_FAMILIES.iter().any(|n| f.info.family.eq_ignore_ascii_case(n)), "{c} → {}", f.info.family);
-        }
-        // The bold cut of the fallback family is chosen for bold text when the family has one.
-        let f = face(fallback_for('水', inter));
-        let (w, _) = style_wants(&f.info.style);
-        let has_bold = all_faces().iter().any(|g| g.info.family == f.info.family && style_wants(&g.info.style).0 >= 600);
-        assert!(!has_bold || w >= 600, "{} {}", f.info.family, f.info.style);
-        // Cached: the second call is a lookup.
-        assert_eq!(fallback_for('水', inter), f.id);
-    }
-
-    /// A minimal TrueType font built in code (no font file in the repo): U+0020 and U+E000 map to
-    /// an empty glyph, U+E001 to a triangle.
-    fn blank_glyph_font() -> Vec<u8> {
-        test_font("Blank Glyph Test")
-    }
-
-    /// The blank-glyph test font under another family name.
-    fn test_font(family: &str) -> Vec<u8> {
-        fn u16s(v: &[u16]) -> Vec<u8> {
-            v.iter().flat_map(|x| x.to_be_bytes()).collect()
-        }
-        let delta_space = 1u16.wrapping_sub(0x20);
-        let cmap4 = {
-            let mut t = u16s(&[4, 0, 0, 6, 4, 1, 2]);
-            t.extend(u16s(&[0x20, 0xE001, 0xFFFF, 0, 0x20, 0xE000, 0xFFFF, delta_space, 0x2001, 1, 0, 0, 0]));
-            let len = t.len() as u16;
-            t[2..4].copy_from_slice(&len.to_be_bytes());
-            t
-        };
-        let mut cmap = u16s(&[0, 1, 3, 1, 0, 12]);
-        cmap.extend(cmap4);
-        // glyph 2: one contour of three on-curve points (100,0) (500,0) (300,600)
-        let mut glyf = u16s(&[1, 100, 0, 500, 600, 2, 0]);
-        glyf.extend([1u8, 1, 1]);
-        glyf.extend(u16s(&[100, 400, (-200i16) as u16, 0, 0, 600]));
-        glyf.push(0);
-        let loca = u16s(&[0, 0, 0, (glyf.len() / 2) as u16]);
-        let mut head = u16s(&[1, 0, 1, 0, 0, 0, 0x5F0F, 0x3CF5, 0, 1000]);
-        head.extend([0u8; 16]);
-        head.extend(u16s(&[100, 0, 500, 600, 0, 8, 2, 0, 0]));
-        let mut hhea = u16s(&[1, 0, 800, (-200i16) as u16, 0, 600, 0, 0, 500, 1, 0, 0]);
-        hhea.extend([0u8; 8]);
-        hhea.extend(u16s(&[0, 3]));
-        let hmtx = u16s(&[600, 0, 600, 0, 600, 0]);
-        let maxp = u16s(&[1, 0, 3, 3, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0]);
-        let strings: Vec<Vec<u8>> = [family, "Regular"].iter().map(|s| s.encode_utf16().flat_map(|u| u.to_be_bytes()).collect()).collect();
-        let mut name = u16s(&[0, 2, 30]);
-        let mut off = 0;
-        for (id, st) in strings.iter().enumerate() {
-            name.extend(u16s(&[3, 1, 0x409, id as u16 + 1, st.len() as u16, off]));
-            off += st.len() as u16;
-        }
-        strings.iter().for_each(|st| name.extend(st));
-        let tables: [(&[u8; 4], Vec<u8>); 8] =
-            [(b"cmap", cmap), (b"glyf", glyf), (b"head", head), (b"hhea", hhea), (b"hmtx", hmtx), (b"loca", loca), (b"maxp", maxp), (b"name", name)];
-        let mut out = u16s(&[1, 0, tables.len() as u16, 128, 3, 0]);
-        let mut offset = 12 + 16 * tables.len();
-        let mut body = vec![];
-        for (tag, data) in &tables {
-            out.extend(*tag);
-            out.extend([0u8; 4]);
-            out.extend((offset as u32).to_be_bytes());
-            out.extend((data.len() as u32).to_be_bytes());
-            let padded = data.len().div_ceil(4) * 4;
-            body.extend(data);
-            body.resize(body.len() + padded - data.len(), 0);
-            offset += padded;
-        }
-        out.extend(body);
-        out
-    }
-
-    /// A face that maps a character to an empty glyph doesn't cover it, so fallback skips it
-    /// (#285); a blank space still counts, and a drawn glyph is found as before.
-    #[test]
-    fn an_empty_glyph_does_not_cover_its_character() {
-        let ids = add_font_data(blank_glyph_font());
-        let &[id] = ids.as_slice() else { panic!("one face expected: {ids:?}") };
-        let f = face(id);
-        assert_eq!(f.info.family, "Blank Glyph Test");
-        assert!(f.glyph('\u{e000}').is_some(), "the cmap maps it");
-        assert!(!f.has_char('\u{e000}'), "but its glyph is empty");
-        assert!(f.has_char('\u{e001}'), "a drawn glyph covers its character");
-        assert!(f.has_char(' '), "a space is blank by nature");
-        let inter = resolve("Inter", "Regular").face;
-        assert_ne!(fallback_for('\u{e000}', inter), id, "fallback never picks the empty glyph");
-        assert_eq!(fallback_for('\u{e001}', inter), id, "fallback finds the drawn one");
-    }
-
-    /// A Microsoft family that isn't installed renders in its installed metric-compatible
-    /// substitute instead of Inter, and still reports itself missing (#1677).
-    #[test]
-    fn microsoft_families_resolve_to_metric_compatible_substitutes() {
-        add_font_data(test_font("Carlito"));
-        add_font_data(test_font("Caladea"));
-        let calibri = resolve("Calibri", "Regular");
-        assert_eq!(face(calibri.face).info.family, "Carlito");
-        assert!(calibri.missing, "the original name stays missing for Find Missing Fonts");
-        let cambria = resolve("Cambria", "Bold");
-        assert_eq!(face(cambria.face).info.family, "Caladea");
-        assert!(cambria.missing);
-        let unknown = resolve("No Such Family 1677", "Regular");
-        assert_eq!(face(unknown.face).info.family, DEFAULT_FAMILY);
-        assert!(unknown.missing);
-    }
-
-    #[test]
-    fn the_han_order_follows_the_cjk_locale() {
-        // Chinese first for any Chinese tag, whether or not it names a script.
-        for tag in ["zh", "zh-CN", "zh_Hans", "ZH-Hant-TW.UTF-8", "zh_MO"] {
-            assert_eq!(han_order_for(tag)[0], FallbackScript::Han, "{tag}");
-        }
-        assert_eq!(han_order_for("ko-KR"), [FallbackScript::Korean, FallbackScript::Japanese, FallbackScript::Han]);
-        // Japanese, and anything else, keeps the Japanese face first for Han text.
-        for tag in ["ja_JP.UTF-8", "en-US", "de", ""] {
-            assert_eq!(han_order_for(tag), [FallbackScript::Japanese, FallbackScript::Han, FallbackScript::Korean], "{tag}");
-        }
-        // The host's request is what `han_order` reads (the ui test covers the effect on the
-        // registered fallbacks; this only checks that clearing it returns to the environment).
-        assert_eq!(requested_cjk_locale(), None, "tests run without a request");
-        assert_eq!(han_order(), han_order_for(&active_cjk_locale()));
-    }
-
-    #[test]
-    fn the_chinese_family_list_follows_the_script_the_locale_asks_for() {
-        for tag in ["zh", "zh-CN", "zh_Hans", "zh_CN.UTF-8", "zh-SG"] {
-            assert_eq!(chinese_families_for(tag), SIMPLIFIED_CHINESE_FAMILIES, "{tag}");
-        }
-        for tag in ["zh-Hant", "zh-Hant-TW", "zh_TW", "zh-HK", "zh_MO.UTF-8"] {
-            assert_eq!(chinese_families_for(tag), TRADITIONAL_CHINESE_FAMILIES, "{tag}");
-        }
-        // Each list carries its own script's faces and not the other's, which is the point of
-        // splitting them: `PingFang SC` covers the same code points as `PingFang TC`, so the
-        // fallback search would have kept it and drawn Simplified forms in a Traditional interface.
-        assert!(SIMPLIFIED_CHINESE_FAMILIES.iter().any(|f| f.contains("PingFang SC") && !f.contains("Source")));
-        assert!(!SIMPLIFIED_CHINESE_FAMILIES.iter().any(|f| f.contains("TC") || f.contains("JhengHei")));
-        assert!(TRADITIONAL_CHINESE_FAMILIES.iter().any(|f| f.contains("PingFang TC")));
-        assert!(!TRADITIONAL_CHINESE_FAMILIES.iter().any(|f| f.contains(" SC") || f.contains("YaHei") || f.contains("WenQuanYi")));
-        assert!(TRADITIONAL_CHINESE_FAMILIES.iter().any(|f| f.contains("Heiti TC") || f.contains("Hiragino Sans CNS")));
-        // The arm the fallback itself walks: Han hands over the list the locale's script picked.
-        assert_eq!(families_for(FallbackScript::Han, CjkLocale::from_tag(&active_cjk_locale())), chinese_families_for(&active_cjk_locale()));
-        // Han text is the only thing these lists serve; the Japanese order does not change.
-        assert_eq!(han_order_for("ja_JP.UTF-8")[0], FallbackScript::Japanese);
-    }
-
-    #[test]
-    fn the_rendered_order_keeps_the_print_face_first() {
-        // A composed frame renders with these lists, so they keep the platform's print order: the
-        // interface prefers the platform's UI faces on its own (see `install_script_fallbacks` in
-        // the ui crate), and an existing project must not render differently because a window's
-        // chrome changed.
-        let pos = |list: &[&str], name: &str| list.iter().position(|f| *f == name).unwrap_or(usize::MAX);
-        assert!(
-            pos(JAPANESE_FAMILIES, "Yu Gothic") < pos(JAPANESE_FAMILIES, "Yu Gothic UI"),
-            "the print face must come before its UI sibling: {JAPANESE_FAMILIES:?}"
-        );
-        for name in ["Meiryo UI", "MS UI Gothic"] {
-            assert!(!JAPANESE_FAMILIES.contains(&name), "{name} belongs to the interface order, not this list");
-        }
-        assert_eq!(SIMPLIFIED_CHINESE_FAMILIES[0], "Microsoft YaHei");
-        assert_eq!(TRADITIONAL_CHINESE_FAMILIES[0], "Microsoft JhengHei");
-        for name in ["Microsoft YaHei UI", "Microsoft JhengHei UI", "PMingLiU"] {
-            assert!(
-                !SIMPLIFIED_CHINESE_FAMILIES.contains(&name) && !TRADITIONAL_CHINESE_FAMILIES.contains(&name),
-                "{name} belongs to the interface order, not these lists"
-            );
-        }
-    }
-
-    #[test]
-    fn bundled_ui_fonts_cover_the_ukrainian_alphabet() {
-        const ALPHABET: &str = "АБВГҐДЕЄЖЗИІЇЙКЛМНОПРСТУФХЦЧШЩЬЮЯабвгґдеєжзиіїйклмнопрстуфхцчшщьюя’«»";
-        for (name, bytes) in
-            [("Inter Regular", INTER_REGULAR), ("Inter Medium", INTER_MEDIUM), ("Inter SemiBold", INTER_SEMIBOLD), ("JetBrains Mono", JETBRAINS_MONO_REGULAR)]
-        {
-            let font = FontRef::new(bytes).unwrap();
-            for c in ALPHABET.chars() {
-                assert!(covers(&font, c), "{name} cannot draw {c}");
-            }
-        }
-    }
-
-    #[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"));
-    }
-}
+mod tests;
diff --git a/crates/text/src/fonts/tests.rs b/crates/text/src/fonts/tests.rs
new file mode 100644
index 000000000..d95f07c6a
--- /dev/null
+++ b/crates/text/src/fonts/tests.rs
@@ -0,0 +1,569 @@
+use super::*;
+
+/// Run `test` again in a child process with `variable` set. The fixture faces below go into the
+/// process-global font database and its fallback caches, so only a process that runs one such test
+/// on its own can use them.
+#[cfg(not(target_arch = "wasm32"))]
+fn run_in_child(variable: &str, test: &str) {
+    let output = std::process::Command::new(std::env::current_exe().unwrap()).args(["--exact", test, "--nocapture"]).env(variable, "1").output().unwrap();
+    assert!(output.status.success(), "{}\n{}", String::from_utf8_lossy(&output.stdout), String::from_utf8_lossy(&output.stderr));
+}
+
+/// Concurrent language requests must neither choose another context's font nor reuse its
+/// cached family order. Synthetic fonts in a child process keep this independent of the host
+/// font installation and of other tests that exercise the process-global database/locale.
+#[test]
+#[cfg(not(target_arch = "wasm32"))]
+fn cjk_requests_keep_their_language_and_cache_entries() {
+    const CHILD: &str = "EFFECTCRAFT_TEST_ISOLATED_CJK";
+    if std::env::var_os(CHILD).is_none() {
+        run_in_child(CHILD, "fonts::tests::cjk_requests_keep_their_language_and_cache_entries");
+        return;
+    }
+    let families = [("ja", "Yu Gothic"), ("zh-hans", "Microsoft YaHei"), ("zh-hant", "Microsoft JhengHei"), ("ko", "Malgun Gothic")];
+    let mut expected = Vec::new();
+    {
+        let mut d = db().write().unwrap();
+        d.scanned = true; // This test process uses only bundled and synthetic fonts.
+        for (language, family) in families {
+            let mut data = test_font(family);
+            let table = data[12..12 + 8 * 16].as_chunks::<16>().0.iter().find(|t| &t[..4] == b"cmap").unwrap();
+            let cmap = u32::from_be_bytes(table[8..12].try_into().unwrap()) as usize + 12;
+            // Map 页 to the fixture's triangle glyph instead of its private-use range.
+            // All four fonts cover the probe, so coverage cannot choose the right language.
+            for (offset, value) in [(16, '页' as u16), (24, '页' as u16), (30, 2u16.wrapping_sub('页' as u16))] {
+                data[cmap + offset..cmap + offset + 2].copy_from_slice(&value.to_be_bytes());
+            }
+            let data = Arc::new(data);
+            let names = read_faces_bytes(&data).into_iter().next().unwrap();
+            let id = push(&mut d, info_from(names, FaceData::Shared(data), "test"));
+            expected.push((language, id));
+        }
+    }
+    let base = resolve("Inter", "Regular").face;
+    for &(_, id) in &expected {
+        assert!(face(id).has_char('页'));
+    }
+    // Force the original interleaving: Chinese starts, then Japanese replaces the global
+    // language before Chinese looks up its probe. The explicit request must still win.
+    set_cjk_locale("zh-hans");
+    set_cjk_locale("ja");
+    assert_eq!(fallback_for('页', base), expected[0].1);
+    assert_eq!(fallback_for_locale('页', base, "zh-hans"), expected[1].1);
+    // Do not clear the cache here: different policies must coexist in the same cache.
+    for _ in 0..3 {
+        for &(language, id) in &expected {
+            assert_eq!(fallback_for_locale('页', base, language), id, "{language}");
+        }
+    }
+    let barrier = Arc::new(std::sync::Barrier::new(expected.len()));
+    let threads: Vec<_> = expected
+        .into_iter()
+        .map(|(language, id)| {
+            let barrier = barrier.clone();
+            std::thread::spawn(move || {
+                barrier.wait();
+                for _ in 0..128 {
+                    set_cjk_locale(if language == "ja" { "zh-hans" } else { "ja" });
+                    assert_eq!(fallback_for_locale('页', base, language), id, "{language}");
+                }
+            })
+        })
+        .collect();
+    for thread in threads {
+        thread.join().unwrap();
+    }
+}
+
+/// #453: with a Chinese interface, a Han ideograph that both a Chinese and a Japanese face cover
+/// must reach the installed Simplified Chinese family first, or Chinese text in a composition is
+/// drawn with Japanese glyph forms. Fixture faces named after the macOS families keep this
+/// independent of the host's fonts and of rendering. Before the fix the Simplified list named none
+/// of the macOS faces a stock install has, so the walk below reached the Japanese face - the
+/// regression this guards.
+#[test]
+#[cfg(not(target_arch = "wasm32"))]
+fn zh_hans_han_fallback_puts_the_chinese_family_first() {
+    const CHILD: &str = "EFFECTCRAFT_TEST_ZH_HANS_ORDER";
+    if std::env::var_os(CHILD).is_none() {
+        run_in_child(CHILD, "fonts::tests::zh_hans_han_fallback_puts_the_chinese_family_first");
+        return;
+    }
+    let mut ids = Vec::new();
+    {
+        let mut d = db().write().unwrap();
+        d.scanned = true; // This test process uses only bundled and synthetic fonts.
+        // The Japanese face is added first, so scan order cannot be what picks the Chinese one.
+        for family in ["Hiragino Sans", "Hiragino Sans GB"] {
+            let mut data = test_font(family);
+            let table = data[12..12 + 8 * 16].as_chunks::<16>().0.iter().find(|t| &t[..4] == b"cmap").unwrap();
+            let cmap = u32::from_be_bytes(table[8..12].try_into().unwrap()) as usize + 12;
+            // Map 页 to the fixture's triangle glyph instead of its private-use range.
+            for (offset, value) in [(16, '页' as u16), (24, '页' as u16), (30, 2u16.wrapping_sub('页' as u16))] {
+                data[cmap + offset..cmap + offset + 2].copy_from_slice(&value.to_be_bytes());
+            }
+            let data = Arc::new(data);
+            let names = read_faces_bytes(&data).into_iter().next().unwrap();
+            ids.push(push(&mut d, info_from(names, FaceData::Shared(data), "test")));
+        }
+    }
+    let &[japanese, chinese] = ids.as_slice() else { panic!("two fixture faces expected: {ids:?}") };
+    let base = resolve("Inter", "Regular").face;
+    assert!(face(japanese).has_char('页') && face(chinese).has_char('页'));
+    // The fallback list itself, before any coverage check: the Chinese family comes first for
+    // zh-hans and second for ja, whether or not either face can draw the probe.
+    let zh_hans: Vec<FaceId> = family_faces(FallbackScript::Han, &face(base), CjkLocale::Simplified).to_vec();
+    assert_eq!(zh_hans, [chinese, japanese], "zh-hans tries the Chinese family first");
+    let ja: Vec<FaceId> = family_faces(FallbackScript::Han, &face(base), CjkLocale::Japanese).to_vec();
+    assert_eq!(ja, [japanese, chinese], "ja keeps the Japanese family first");
+    // ...and the face a layout actually gets for the shared ideograph.
+    assert_eq!(face(fallback_for_locale('页', base, "zh-hans")).info.family, "Hiragino Sans GB");
+    assert_eq!(face(fallback_for_locale('页', base, "ja")).info.family, "Hiragino Sans");
+}
+
+#[test]
+fn extra_font_dirs_come_from_a_path_list() {
+    assert!(extra_dirs(None).is_empty());
+    let v = std::env::join_paths(["/a/fonts", "/b/more"]).unwrap_or_default();
+    assert_eq!(extra_dirs(Some(&v)), vec![PathBuf::from("/a/fonts"), PathBuf::from("/b/more")]);
+    assert!(extra_dirs(Some(std::ffi::OsStr::new(""))).is_empty());
+}
+
+#[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);
+    let faces = all_faces();
+    assert!(faces.iter().any(|f| f.info.family == "Noto Serif" && f.info.style == "Regular" && f.info.origin == "bundled"));
+    // A real installed Bold Italic — the face's own style, or a named instance of a variable
+    // face — takes priority. Partial installed families can instead supply the nearest
+    // weight/slant, so neither synthesis flag is fixed by the OS.
+    for family in ["Noto Serif", "Inter"] {
+        let resolved = resolve(family, "Bold Italic");
+        let selected = face(resolved.face);
+        assert!(selected.info.family.eq_ignore_ascii_case(family));
+        assert!(!resolved.missing);
+        let candidates: Vec<_> = faces.iter().filter(|f| f.info.family.eq_ignore_ascii_case(family)).collect();
+        let exact = candidates
+            .iter()
+            .find(|f| f.info.style.eq_ignore_ascii_case("Bold Italic"))
+            .or_else(|| candidates.iter().find(|f| f.info.instances.iter().any(|i| i.style.eq_ignore_ascii_case("Bold Italic"))));
+        if let Some(exact) = exact {
+            assert_eq!(resolved.face, exact.id, "real style wins for {family}");
+            let expected_instance = if exact.info.style.eq_ignore_ascii_case("Bold Italic") {
+                None
+            } else {
+                exact.info.instances.iter().position(|i| i.style.eq_ignore_ascii_case("Bold Italic")).and_then(|i| u16::try_from(i).ok())
+            };
+            assert_eq!(resolved.instance, expected_instance, "exact style instance for {family}");
+            assert!(!resolved.synth_bold && !resolved.synth_italic);
+        } else {
+            // Italic mismatch dominates any supported font weight distance. Named instances
+            // resolve at their effective weight and slant, not the face's defaults.
+            let selected_instance = resolved.instance.and_then(|i| selected.info.instances.get(usize::from(i)));
+            let selected_weight = selected_instance.map_or(selected.info.weight, |i| i.weight(selected.info.weight));
+            let selected_italic = selected_instance.map_or(selected.info.italic, |i| i.italic(selected.info.italic));
+            let distance = |weight: u16, italic: bool| u32::from(weight.abs_diff(700)) + if italic { 0 } else { 1_000 };
+            let nearest = candidates
+                .iter()
+                .flat_map(|f| {
+                    std::iter::once((f.info.weight, f.info.italic))
+                        .chain(f.info.instances.iter().map(move |i| (i.weight(f.info.weight), i.italic(f.info.italic))))
+                })
+                .map(|(weight, italic)| distance(weight, italic))
+                .min()
+                .unwrap();
+            assert_eq!(distance(selected_weight, selected_italic), nearest, "closest available style for {family}");
+            assert_eq!(resolved.synth_bold, selected_weight <= 500);
+            assert_eq!(resolved.synth_italic, !selected_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");
+    // A minimum face count on Linux belongs with the native-fonts gate in #1591. A container
+    // that has fontconfig and only a handful of faces must still pass this portable test.
+    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_text("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 postscript_and_full_names_resolve() {
+    // Bundled Inter: name id 6 is `Inter-Bold`, name id 4 is `Inter Bold`.
+    let ps = resolve("Inter-Bold", "");
+    assert_eq!(face(ps.face).info.style, "Bold");
+    assert!(!ps.missing && !ps.synth_bold);
+    let full = resolve("inter semibold", "");
+    assert_eq!(face(full.face).info.style, "SemiBold");
+    assert!(!full.missing);
+    // A family name still wins over a name lookup.
+    assert_eq!(face(resolve("Inter", "Bold").face).info.style, "Bold");
+}
+
+/// #1563: a variable font's named instances are styles of its family. `fontStyle = "Black"`,
+/// the instance's PostScript name (`font = "Figtree-Black"`) and its full name select the
+/// instance's axis values instead of the default instance made bold synthetically, and the
+/// font menus list every instance.
+#[test]
+fn variable_named_instances_resolve_and_list() {
+    const FAMILY: &str = "EffectCraft Instance Test";
+    let instances = [
+        ("Light", 300.0, Some("EffectCraftInstanceTest-Light")),
+        ("Regular", 400.0, Some("EffectCraftInstanceTest-Regular")),
+        ("Black", 900.0, Some("EffectCraftInstanceTest-Black")),
+        ("Extra Bold", 800.0, None),
+        ("Bold Italic", 700.0, Some("EffectCraftInstanceTest-BoldItalic")),
+    ];
+    assert_eq!(add_font_data(crate::sfnt::test_font::variable(FAMILY, &instances, true)).len(), 1);
+    let wght = |r: &Resolved| instance_variations(r);
+    // By style name.
+    let black = resolve(FAMILY, "Black");
+    assert!(!black.missing && !black.synth_bold && !black.synth_italic, "{black:?}");
+    assert_eq!(wght(&black), vec![("wght".to_string(), 900.0)]);
+    assert_eq!(wght(&resolve(FAMILY, "regular")), vec![("wght".to_string(), 400.0)]);
+    // The face's own style is its default instance: no axis values to set.
+    let light = resolve(FAMILY, "Light");
+    assert_eq!((light.face, light.instance), (black.face, None));
+    // A style the family lacks takes the nearest instance's weight, no synthetic bold.
+    let bold = resolve(FAMILY, "Bold");
+    assert!(!bold.synth_bold, "{bold:?}");
+    assert_eq!(wght(&bold), vec![("wght".to_string(), 800.0)]);
+    // By PostScript name, the font's own and the derived one, and by full name.
+    let ps = resolve("EffectCraftInstanceTest-Black", "Regular");
+    assert!(!ps.missing && ps.face == black.face, "{ps:?}");
+    assert_eq!(wght(&ps), vec![("wght".to_string(), 900.0)]);
+    assert_eq!(wght(&resolve("EffectCraftInstanceTest-ExtraBold", "")), vec![("wght".to_string(), 800.0)]);
+    assert_eq!(wght(&resolve("effectcraft instance test extra bold", "")), vec![("wght".to_string(), 800.0)]);
+    // A named instance keeps its own index, so layout applies its axis values.
+    let bold_italic = resolve(FAMILY, "Bold Italic");
+    assert!(!bold_italic.missing && !bold_italic.synth_bold && !bold_italic.synth_italic);
+    assert_eq!((bold_italic.face, bold_italic.instance), (black.face, Some(4)));
+    assert_eq!(wght(&bold_italic), vec![("wght".to_string(), 700.0)]);
+    // The font menu lists every instance, in weight order.
+    let fams = families();
+    let styles = &fams.iter().find(|(f, _)| f == FAMILY).unwrap().1;
+    assert_eq!(styles, &["Light", "Regular", "Extra Bold", "Black", "Bold Italic"]);
+    // Static fonts are untouched.
+    assert_eq!(resolve("Inter", "Bold").instance, None);
+}
+
+/// Axis values set on the text win over the instance's; the others keep the instance's.
+#[test]
+fn explicit_variations_override_the_instance() {
+    let base = vec![("wdth".to_string(), 75.0), ("wght".to_string(), 900.0)];
+    assert_eq!(merge_variations(&base, &[("wght".to_string(), 450.0)]), vec![("wdth".to_string(), 75.0), ("wght".to_string(), 450.0)]);
+    assert_eq!(merge_variations(&base, &[]), base);
+    assert_eq!(merge_variations(&[], &[("opsz".to_string(), 12.0)]), vec![("opsz".to_string(), 12.0)]);
+}
+
+#[test]
+fn scripts_are_classified() {
+    assert_eq!(script_of('あ'), FallbackScript::Japanese);
+    assert_eq!(script_of('ｶ'), FallbackScript::Japanese);
+    assert_eq!(script_of('한'), FallbackScript::Korean);
+    assert_eq!(script_of('水'), FallbackScript::Han);
+    assert_eq!(script_of('、'), FallbackScript::Han);
+    assert_eq!(script_of('Ａ'), FallbackScript::Han);
+    assert_eq!(script_of('\u{20000}'), FallbackScript::Han);
+    assert_eq!(script_of('A'), FallbackScript::Other);
+    assert_eq!(script_of('م'), FallbackScript::Arabic);
+    assert_eq!(script_of('\u{fefb}'), FallbackScript::Arabic);
+    assert_eq!(script_of('\u{5d0}'), FallbackScript::Hebrew);
+    assert_eq!(script_of('क'), FallbackScript::Indic);
+    assert_eq!(script_of('த'), FallbackScript::Indic);
+    assert_eq!(script_of('ก'), FallbackScript::Thai);
+    assert_eq!(script_of('ა'), FallbackScript::Georgian);
+    assert_eq!(script_of('\u{1c90}'), FallbackScript::Georgian, "Mtavruli");
+    assert_eq!(script_of('\u{feff}'), FallbackScript::Other, "the byte order mark is no Arabic letter");
+}
+
+/// Native: Arabic, Hebrew, Indic and Thai text in a Latin-only family falls back to the
+/// platform's plain text family for its script (#394), not to the first installed face that
+/// covers it (on Windows a calligraphic Arabic face sorts first). Skipped per script where no
+/// family from its list is installed.
+#[test]
+fn other_scripts_fall_back_to_a_plain_system_family() {
+    scan_system();
+    let inter = resolve("Inter", "Regular").face;
+    for (c, families) in [('م', ARABIC_FAMILIES), ('א', HEBREW_FAMILIES), ('क', INDIC_FAMILIES), ('த', INDIC_FAMILIES), ('ก', THAI_FAMILIES)] {
+        let covering = families.iter().any(|n| resolve_in(n, "Regular").is_some_and(|r| face(r.face).has_char(c)));
+        if !covering {
+            eprintln!("{c}: no family from the list is installed; skipping");
+            continue;
+        }
+        let f = face(fallback_for(c, inter));
+        assert!(f.has_char(c), "{c}: {} lacks it", f.info.family);
+        assert!(families.iter().any(|n| f.info.family.eq_ignore_ascii_case(n)), "{c} → {}", f.info.family);
+    }
+}
+
+/// Native: Mkhedruli in a Latin-only family falls back to a family from the Georgian list,
+/// ahead of faces already loaded and of the scan order. Skipped where no family from the list
+/// is installed.
+#[test]
+fn georgian_falls_back_to_a_georgian_system_family() {
+    scan_system();
+    let c = 'ა';
+    if !GEORGIAN_FAMILIES.iter().any(|n| resolve_in(n, "Regular").is_some_and(|r| face(r.face).has_char(c))) {
+        eprintln!("no Georgian family from the list is installed; skipping");
+        return;
+    }
+    let f = face(fallback_for(c, resolve("Inter", "Regular").face));
+    assert!(f.has_char(c), "{} lacks it", f.info.family);
+    assert!(GEORGIAN_FAMILIES.iter().any(|n| f.info.family.eq_ignore_ascii_case(n)), "{c} → {}", f.info.family);
+}
+
+/// Native: Japanese text in a Latin-only family falls back to an installed Japanese family
+/// (whichever the platform ships) instead of the missing-glyph box, without any layer having
+/// loaded a CJK font first. Skipped where no family from the list is installed.
+#[test]
+fn cjk_falls_back_to_a_system_family() {
+    scan_system();
+    let inter = resolve("Inter", "Bold").face;
+    let installed = JAPANESE_FAMILIES.iter().any(|f| resolve_in(f, "Regular").is_some());
+    if !installed {
+        eprintln!("no Japanese family installed; skipping");
+        return;
+    }
+    for c in ['水', 'あ', 'ア', '。'] {
+        let id = fallback_for(c, inter);
+        let f = face(id);
+        assert!(f.has_char(c), "{c}: {} {} lacks it", f.info.family, f.info.style);
+        assert!(JAPANESE_FAMILIES.iter().any(|n| f.info.family.eq_ignore_ascii_case(n)), "{c} → {}", f.info.family);
+    }
+    // The bold cut of the fallback family is chosen for bold text when the family has one.
+    let f = face(fallback_for('水', inter));
+    let (w, _) = style_wants(&f.info.style);
+    let has_bold = all_faces().iter().any(|g| g.info.family == f.info.family && style_wants(&g.info.style).0 >= 600);
+    assert!(!has_bold || w >= 600, "{} {}", f.info.family, f.info.style);
+    // Cached: the second call is a lookup.
+    assert_eq!(fallback_for('水', inter), f.id);
+}
+
+/// A minimal TrueType font built in code (no font file in the repo): U+0020 and U+E000 map to
+/// an empty glyph, U+E001 to a triangle.
+fn blank_glyph_font() -> Vec<u8> {
+    test_font("Blank Glyph Test")
+}
+
+/// The blank-glyph test font under another family name.
+fn test_font(family: &str) -> Vec<u8> {
+    fn u16s(v: &[u16]) -> Vec<u8> {
+        v.iter().flat_map(|x| x.to_be_bytes()).collect()
+    }
+    let delta_space = 1u16.wrapping_sub(0x20);
+    let cmap4 = {
+        let mut t = u16s(&[4, 0, 0, 6, 4, 1, 2]);
+        t.extend(u16s(&[0x20, 0xE001, 0xFFFF, 0, 0x20, 0xE000, 0xFFFF, delta_space, 0x2001, 1, 0, 0, 0]));
+        let len = t.len() as u16;
+        t[2..4].copy_from_slice(&len.to_be_bytes());
+        t
+    };
+    let mut cmap = u16s(&[0, 1, 3, 1, 0, 12]);
+    cmap.extend(cmap4);
+    // glyph 2: one contour of three on-curve points (100,0) (500,0) (300,600)
+    let mut glyf = u16s(&[1, 100, 0, 500, 600, 2, 0]);
+    glyf.extend([1u8, 1, 1]);
+    glyf.extend(u16s(&[100, 400, (-200i16) as u16, 0, 0, 600]));
+    glyf.push(0);
+    let loca = u16s(&[0, 0, 0, (glyf.len() / 2) as u16]);
+    let mut head = u16s(&[1, 0, 1, 0, 0, 0, 0x5F0F, 0x3CF5, 0, 1000]);
+    head.extend([0u8; 16]);
+    head.extend(u16s(&[100, 0, 500, 600, 0, 8, 2, 0, 0]));
+    let mut hhea = u16s(&[1, 0, 800, (-200i16) as u16, 0, 600, 0, 0, 500, 1, 0, 0]);
+    hhea.extend([0u8; 8]);
+    hhea.extend(u16s(&[0, 3]));
+    let hmtx = u16s(&[600, 0, 600, 0, 600, 0]);
+    let maxp = u16s(&[1, 0, 3, 3, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0]);
+    let strings: Vec<Vec<u8>> = [family, "Regular"].iter().map(|s| s.encode_utf16().flat_map(|u| u.to_be_bytes()).collect()).collect();
+    let mut name = u16s(&[0, 2, 30]);
+    let mut off = 0;
+    for (id, st) in strings.iter().enumerate() {
+        name.extend(u16s(&[3, 1, 0x409, id as u16 + 1, st.len() as u16, off]));
+        off += st.len() as u16;
+    }
+    strings.iter().for_each(|st| name.extend(st));
+    let tables: [(&[u8; 4], Vec<u8>); 8] =
+        [(b"cmap", cmap), (b"glyf", glyf), (b"head", head), (b"hhea", hhea), (b"hmtx", hmtx), (b"loca", loca), (b"maxp", maxp), (b"name", name)];
+    let mut out = u16s(&[1, 0, tables.len() as u16, 128, 3, 0]);
+    let mut offset = 12 + 16 * tables.len();
+    let mut body = vec![];
+    for (tag, data) in &tables {
+        out.extend(*tag);
+        out.extend([0u8; 4]);
+        out.extend((offset as u32).to_be_bytes());
+        out.extend((data.len() as u32).to_be_bytes());
+        let padded = data.len().div_ceil(4) * 4;
+        body.extend(data);
+        body.resize(body.len() + padded - data.len(), 0);
+        offset += padded;
+    }
+    out.extend(body);
+    out
+}
+
+/// A face that maps a character to an empty glyph doesn't cover it, so fallback skips it
+/// (#285); a blank space still counts, and a drawn glyph is found as before.
+#[test]
+fn an_empty_glyph_does_not_cover_its_character() {
+    let ids = add_font_data(blank_glyph_font());
+    let &[id] = ids.as_slice() else { panic!("one face expected: {ids:?}") };
+    let f = face(id);
+    assert_eq!(f.info.family, "Blank Glyph Test");
+    assert!(f.glyph('\u{e000}').is_some(), "the cmap maps it");
+    assert!(!f.has_char('\u{e000}'), "but its glyph is empty");
+    assert!(f.has_char('\u{e001}'), "a drawn glyph covers its character");
+    assert!(f.has_char(' '), "a space is blank by nature");
+    let inter = resolve("Inter", "Regular").face;
+    assert_ne!(fallback_for('\u{e000}', inter), id, "fallback never picks the empty glyph");
+    assert_eq!(fallback_for('\u{e001}', inter), id, "fallback finds the drawn one");
+}
+
+/// A missing Microsoft family uses its metric-compatible substitute instead of Inter and still
+/// reports itself missing (#1677). An installed original family takes precedence.
+#[test]
+fn microsoft_families_resolve_to_metric_compatible_substitutes() {
+    add_font_data(test_font("Carlito"));
+    add_font_data(test_font("Caladea"));
+    for (requested, style, substitute) in [("Calibri", "Regular", "Carlito"), ("Cambria", "Bold", "Caladea")] {
+        let alias = resolve_alias(requested, style).expect("the substitute is available");
+        assert_eq!(face(alias.face).info.family, substitute);
+        assert!(alias.missing, "the original name stays missing for Find Missing Fonts");
+
+        let resolved = resolve(requested, style);
+        let family = &face(resolved.face).info.family;
+        if family.eq_ignore_ascii_case(requested) {
+            assert!(!resolved.missing, "an installed original family is available");
+        } else {
+            assert_eq!(family, substitute);
+            assert!(resolved.missing);
+        }
+    }
+    let unknown = resolve("No Such Family 1677", "Regular");
+    assert_eq!(face(unknown.face).info.family, DEFAULT_FAMILY);
+    assert!(unknown.missing);
+}
+
+#[test]
+fn the_han_order_follows_the_cjk_locale() {
+    // Chinese first for any Chinese tag, whether or not it names a script.
+    for tag in ["zh", "zh-CN", "zh_Hans", "ZH-Hant-TW.UTF-8", "zh_MO"] {
+        assert_eq!(han_order_for(tag)[0], FallbackScript::Han, "{tag}");
+    }
+    assert_eq!(han_order_for("ko-KR"), [FallbackScript::Korean, FallbackScript::Japanese, FallbackScript::Han]);
+    // Japanese, and anything else, keeps the Japanese face first for Han text.
+    for tag in ["ja_JP.UTF-8", "en-US", "de", ""] {
+        assert_eq!(han_order_for(tag), [FallbackScript::Japanese, FallbackScript::Han, FallbackScript::Korean], "{tag}");
+    }
+    // The host's request is what `han_order` reads (the ui test covers the effect on the
+    // registered fallbacks; this only checks that clearing it returns to the environment).
+    assert_eq!(requested_cjk_locale(), None, "tests run without a request");
+    assert_eq!(han_order(), han_order_for(&active_cjk_locale()));
+}
+
+#[test]
+fn the_chinese_family_list_follows_the_script_the_locale_asks_for() {
+    for tag in ["zh", "zh-CN", "zh_Hans", "zh_CN.UTF-8", "zh-SG"] {
+        assert_eq!(chinese_families_for(tag), SIMPLIFIED_CHINESE_FAMILIES, "{tag}");
+    }
+    for tag in ["zh-Hant", "zh-Hant-TW", "zh_TW", "zh-HK", "zh_MO.UTF-8"] {
+        assert_eq!(chinese_families_for(tag), TRADITIONAL_CHINESE_FAMILIES, "{tag}");
+    }
+    // Each list carries its own script's faces and not the other's, which is the point of
+    // splitting them: `PingFang SC` covers the same code points as `PingFang TC`, so the
+    // fallback search would have kept it and drawn Simplified forms in a Traditional interface.
+    assert!(SIMPLIFIED_CHINESE_FAMILIES.iter().any(|f| f.contains("PingFang SC") && !f.contains("Source")));
+    assert!(!SIMPLIFIED_CHINESE_FAMILIES.iter().any(|f| f.contains("TC") || f.contains("JhengHei")));
+    assert!(TRADITIONAL_CHINESE_FAMILIES.iter().any(|f| f.contains("PingFang TC")));
+    assert!(!TRADITIONAL_CHINESE_FAMILIES.iter().any(|f| f.contains(" SC") || f.contains("YaHei") || f.contains("WenQuanYi")));
+    assert!(TRADITIONAL_CHINESE_FAMILIES.iter().any(|f| f.contains("Heiti TC") || f.contains("Hiragino Sans CNS")));
+    // The arm the fallback itself walks: Han hands over the list the locale's script picked.
+    assert_eq!(families_for(FallbackScript::Han, CjkLocale::from_tag(&active_cjk_locale())), chinese_families_for(&active_cjk_locale()));
+    // Han text is the only thing these lists serve; the Japanese order does not change.
+    assert_eq!(han_order_for("ja_JP.UTF-8")[0], FallbackScript::Japanese);
+}
+
+#[test]
+fn the_rendered_order_keeps_the_print_face_first() {
+    // A composed frame renders with these lists, so they keep the platform's print order: the
+    // interface prefers the platform's UI faces on its own (see `install_script_fallbacks` in
+    // the ui crate), and an existing project must not render differently because a window's
+    // chrome changed.
+    let pos = |list: &[&str], name: &str| list.iter().position(|f| *f == name).unwrap_or(usize::MAX);
+    assert!(
+        pos(JAPANESE_FAMILIES, "Yu Gothic") < pos(JAPANESE_FAMILIES, "Yu Gothic UI"),
+        "the print face must come before its UI sibling: {JAPANESE_FAMILIES:?}"
+    );
+    for name in ["Meiryo UI", "MS UI Gothic"] {
+        assert!(!JAPANESE_FAMILIES.contains(&name), "{name} belongs to the interface order, not this list");
+    }
+    assert_eq!(SIMPLIFIED_CHINESE_FAMILIES[0], "Microsoft YaHei");
+    assert_eq!(TRADITIONAL_CHINESE_FAMILIES[0], "Microsoft JhengHei");
+    for name in ["Microsoft YaHei UI", "Microsoft JhengHei UI", "PMingLiU"] {
+        assert!(
+            !SIMPLIFIED_CHINESE_FAMILIES.contains(&name) && !TRADITIONAL_CHINESE_FAMILIES.contains(&name),
+            "{name} belongs to the interface order, not these lists"
+        );
+    }
+}
+
+#[test]
+fn bundled_ui_fonts_cover_the_ukrainian_alphabet() {
+    const ALPHABET: &str = "АБВГҐДЕЄЖЗИІЇЙКЛМНОПРСТУФХЦЧШЩЬЮЯабвгґдеєжзиіїйклмнопрстуфхцчшщьюя’«»";
+    for (name, bytes) in
+        [("Inter Regular", INTER_REGULAR), ("Inter Medium", INTER_MEDIUM), ("Inter SemiBold", INTER_SEMIBOLD), ("JetBrains Mono", JETBRAINS_MONO_REGULAR)]
+    {
+        let font = FontRef::new(bytes).unwrap();
+        for c in ALPHABET.chars() {
+            assert!(covers(&font, c), "{name} cannot draw {c}");
+        }
+    }
+}
+
+#[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"));
+}
+
+#[test]
+fn unknown_face_id_returns_bundled_default() {
+    let fallback = face(usize::MAX);
+    assert_eq!(fallback.id, 0);
+    assert_eq!(fallback.info.family, DEFAULT_FAMILY);
+    assert!(fallback.font().is_some());
+    assert!(Arc::ptr_eq(&fallback, &face(0)));
+}
diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs
index 0730e4442..4c0b5a436 100644
--- a/crates/text/src/layout.rs
+++ b/crates/text/src/layout.rs
@@ -20,7 +20,7 @@ use unicode_bidi::{BidiInfo, Level};
 
 use effectcraft_keyframe::{OpenType, text_doc::paragraph_ranges};
 
-use crate::fonts::{self, FaceId, Resolved};
+use crate::fonts::{self, FaceId, Resolved, VMetrics};
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 pub enum Caps {
@@ -565,6 +565,34 @@ fn space_item(glyphs: &mut [ShapedGlyph], style: &TextStyle, text: &str, para_st
     }
 }
 
+/// After Effects' first-baseline offset of paragraph (box) text for a face at nominal size
+/// `px`: the height of its lowercase `d`, in whole thousandths of an em. Measured in After
+/// Effects 2026 (case 818): the first baseline sits 69.50 px below the box top for Times New
+/// Roman at 100 px (its `d` is 1422/2048 em, 694.3 thousandths, rounded 695) and 71.60 px for
+/// Arial (1466/2048, 715.8, rounded 716), at 50 px half of that; superscript text keeps the
+/// line where normal text puts it and only raises its glyphs. `None` without a `d` outline.
+fn first_ascent(face: FaceId, px: f32) -> Option<f32> {
+    let f = fonts::face(face);
+    let gid = f.glyph('d')?;
+    let units = crate::outline_units(face, gid)?;
+    let top = kurbo::Shape::bounding_box(&*units).y1 as f32;
+    let em = (top / f.units_per_em() * 1000.0).round() / 1000.0;
+    plausible_first(em, px, f.metrics(px).ascent)
+}
+
+/// A `d` at least this fraction of the font ascent is a Latin lowercase ascender; a shorter one
+/// (a symbol or icon font's `d`) would put the first baseline almost at the box top, so the font
+/// ascent is used instead (the rule before the `d` height).
+const MIN_D_OF_ASCENT: f32 = 0.3;
+
+/// The first baseline `em * px` below the box top, if `em` (the `d` height in em) is plausible:
+/// finite, positive, under 4 em and at least [`MIN_D_OF_ASCENT`] of the font `ascent` (px).
+fn plausible_first(em: f32, px: f32, ascent: f32) -> Option<f32> {
+    let h = em * px;
+    let tall_enough = !(ascent.is_finite() && ascent > 0.0) || h >= MIN_D_OF_ASCENT * ascent;
+    (h.is_finite() && h > 0.0 && em < 4.0 && tall_enough).then_some(h)
+}
+
 struct ParaLine {
     range: Range<usize>,
     glyphs: Vec<Glyph>,
@@ -575,6 +603,9 @@ struct ParaLine {
     hang: (f32, f32),
     ascent: f32,
     descent: f32,
+    /// Where a box's first line puts its baseline below the box top ([`first_ascent`] of the
+    /// line's styles at their nominal size; the font ascent where a face has no `d`).
+    first: f32,
     /// Line advance (largest leading on the line).
     advance: f32,
     align: Align,
@@ -597,61 +628,394 @@ fn run_at(runs: &[(Range<usize>, TextStyle)], b: usize) -> usize {
 }
 
 /// Lay out one paragraph (no newlines) whose text starts at byte `base` of the whole string.
-fn paragraph(
-    text: &str,
-    base: usize,
-    runs: &[(Range<usize>, TextStyle)],
-    primaries: &[Resolved],
-    variation_ids: &[u32],
-    para: &ParagraphStyle,
-    width: Option<f32>,
-) -> Vec<ParaLine> {
-    let rtl_para = para.rtl == Some(true);
-    let margins_for = |first: bool| -> (f32, f32) {
-        let fi = if first { para.indent_first } else { 0.0 };
-        if rtl_para { (para.indent_end, para.indent_start + fi) } else { (para.indent_start + fi, para.indent_end) }
-    };
-    let avail_for = |first: bool| -> Option<f32> {
-        let (l, r) = margins_for(first);
-        width.map(|w| (w - l - r).max(1.0))
-    };
-    let style_metrics = |si: usize| {
-        let st = &runs[si].1;
-        fonts::face(primaries[si].face).metrics(st.glyph_size())
-    };
-    let eff_align = |last: bool| -> Align {
-        if (last || width.is_none()) && para.align == Align::Justify {
-            if width.is_none() && para.justify_last == Align::Justify { Align::Left } else { para.justify_last }
-        } else {
-            para.align
-        }
-    };
-    if text.is_empty() {
-        let si = run_at(runs, base);
-        let pm = style_metrics(si);
-        return vec![ParaLine {
-            range: base..base,
-            glyphs: vec![],
-            carets: vec![(base, 0.0)],
-            content: 0.0,
-            left_trim: 0.0,
-            hang: (0.0, 0.0),
-            ascent: pm.ascent,
-            descent: pm.descent,
-            advance: runs[si].1.line_advance(),
-            align: eff_align(true),
-            avail: avail_for(true),
-            margins: margins_for(true),
-            underline: None,
-        }];
+/// Margins (left, right) of a paragraph's first or later lines.
+/// `rtl` is the resolved paragraph direction (an unset direction follows the text).
+fn margins_for(para: &ParagraphStyle, rtl: bool, first: bool) -> (f32, f32) {
+    let fi = if first { para.indent_first } else { 0.0 };
+    if rtl { (para.indent_end, para.indent_start + fi) } else { (para.indent_start + fi, para.indent_end) }
+}
+
+/// The width a line may fill (`None` for point text).
+fn avail_for(para: &ParagraphStyle, rtl: bool, width: Option<f32>, first: bool) -> Option<f32> {
+    let (l, r) = margins_for(para, rtl, first);
+    width.map(|w| (w - l - r).max(1.0))
+}
+
+/// The alignment of a line, justified lines that cannot stretch falling back to `justify_last`.
+fn align_for(para: &ParagraphStyle, rtl: bool, width: Option<f32>, last: bool) -> Align {
+    if rtl && width.is_none() && para.align == Align::Justify {
+        // Right-to-left point text with a justified paragraph sits flush at its start, the
+        // right (After Effects 2026, every justify code; left-to-right not measured).
+        Align::Right
+    } else if (last || width.is_none()) && para.align == Align::Justify {
+        if width.is_none() && para.justify_last == Align::Justify { Align::Left } else { para.justify_last }
+    } else {
+        para.align
     }
-    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, rtl, form, run)
-    let chars: Vec<(usize, char, char, FaceId, bool, Form, usize)> = text
-        .char_indices()
+}
+
+fn style_metrics(primaries: &[Resolved], runs: &[(Range<usize>, TextStyle)], si: usize) -> VMetrics {
+    fonts::face(primaries[si].face).metrics(runs[si].1.glyph_size())
+}
+
+/// The baseline of a box's first line for style run `si`: the `d` height, else the font ascent.
+fn style_first(primaries: &[Resolved], runs: &[(Range<usize>, TextStyle)], si: usize) -> f32 {
+    let st = &runs[si].1;
+    first_ascent(primaries[si].face, st.size).unwrap_or_else(|| fonts::face(primaries[si].face).metrics(st.size).ascent)
+}
+
+/// A char's shaping inputs: (byte, char, shaped char, face, rtl, form, run).
+type CharInfo = (usize, char, char, FaceId, bool, Form, usize);
+
+/// The glyphs of one line in visual order, where its pen ended, the extent of each cluster by
+/// byte, and the underline span.
+struct Placed {
+    glyphs: Vec<Glyph>,
+    pen: f32,
+    extents: HashMap<usize, (f32, f32, bool)>,
+    underline: Option<(f32, f32)>,
+}
+
+/// A paragraph shaped and measured, ready to be broken into lines.
+struct Para<'a> {
+    text: &'a str,
+    base: usize,
+    runs: &'a [(Range<usize>, TextStyle)],
+    primaries: &'a [Resolved],
+    variation_ids: &'a [u32],
+    para: &'a ParagraphStyle,
+    width: Option<f32>,
+    bidi: BidiInfo<'a>,
+    base_rtl: bool,
+    chars: Vec<CharInfo>,
+    items: Vec<Item>,
+    /// Advance of the glyphs at each byte, and prefix sums over it.
+    char_adv: Vec<f32>,
+    prefix_adv: Vec<f64>,
+    previous_non_ws: Vec<usize>,
+}
+
+impl<'a> Para<'a> {
+    fn new(
+        text: &'a str,
+        base: usize,
+        runs: &'a [(Range<usize>, TextStyle)],
+        primaries: &'a [Resolved],
+        variation_ids: &'a [u32],
+        para: &'a ParagraphStyle,
+        width: Option<f32>,
+    ) -> Self {
+        let default_level = para.rtl.map(|r| if r { Level::rtl() } else { Level::ltr() });
+        let bidi = BidiInfo::new(text, default_level);
+        let base_rtl = bidi.paragraphs[0].level.is_rtl();
+        let chars = char_forms(text, base, runs, primaries, &bidi);
+        let items = build_items(text, &chars, runs);
+        // Prefix widths and the preceding non-whitespace boundary make candidate line widths O(1).
+        // Every-line composition evaluates O(n²) candidate breaks; summing each candidate's bytes
+        // or rescanning its trailing whitespace would otherwise add another factor of text length.
+        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 + g.pre;
+            }
+        }
+        let mut prefix_adv = vec![0.0f64; text.len() + 1];
+        for i in 0..text.len() {
+            prefix_adv[i + 1] = prefix_adv[i] + f64::from(char_adv[i]);
+        }
+        let mut previous_non_ws = vec![0usize; text.len() + 1];
+        let mut non_ws_end = 0usize;
+        for (b, c) in text.char_indices() {
+            previous_non_ws[b] = non_ws_end;
+            if !c.is_whitespace() {
+                non_ws_end = b + c.len_utf8();
+            }
+            previous_non_ws[b + c.len_utf8()] = non_ws_end;
+        }
+        Para { text, base, runs, primaries, variation_ids, para, width, bidi, base_rtl, chars, items, char_adv, prefix_adv, previous_non_ws }
+    }
+
+    fn range_w(&self, r: Range<usize>) -> f32 {
+        (self.prefix_adv[r.end] - self.prefix_adv[r.start]) as f32
+    }
+
+    fn trailing_ws(&self, r: &Range<usize>) -> (usize, f32) {
+        let end = self.previous_non_ws[r.end].max(r.start).min(r.end);
+        (end, (self.prefix_adv[r.end] - self.prefix_adv[end]) as f32)
+    }
+
+    /// Hanging punctuation widths (left, right) of a line's content.
+    fn hang_of(&self, r: &Range<usize>, ce: usize) -> (f32, f32) {
+        if !self.para.hanging || self.width.is_none() || r.start >= ce {
+            return (0.0, 0.0);
+        }
+        let first = self.text[r.start..ce].chars().next().filter(|c| is_hanging_open(*c)).map_or(0.0, |_| self.char_adv[r.start]);
+        let last = self.text[r.start..ce].char_indices().next_back().filter(|(_, c)| is_hanging_close(*c)).map_or(0.0, |(b, _)| self.char_adv[r.start + b]);
+        (first, last)
+    }
+
+    fn fits_w(&self, r: &Range<usize>) -> f32 {
+        let (ce, _) = self.trailing_ws(r);
+        let (hl, hr) = self.hang_of(r, ce);
+        self.range_w(r.start..ce) - hl - hr
+    }
+
+    fn line_avail(&self, line: usize) -> f32 {
+        avail_for(self.para, self.base_rtl, self.width, line == 0).unwrap_or(f32::MAX)
+    }
+
+    /// The byte ranges of the lines, for the wrap width.
+    fn break_ranges(&self) -> Vec<Range<usize>> {
+        if self.width.is_none() {
+            return std::iter::once(0..self.text.len()).collect();
+        }
+        let opps: Vec<usize> = unicode_linebreak::linebreaks(self.text).map(|(p, _)| p).collect();
+        let mut ranges = if self.para.every_line && opps.len() > 1 && opps.len() <= 1500 { self.optimal_breaks(&opps) } else { self.greedy_breaks(opps) };
+        ranges.retain(|r| !r.is_empty());
+        if ranges.is_empty() {
+            ranges.push(0..self.text.len());
+        }
+        ranges
+    }
+
+    /// Minimises the summed squared slack of every line but the last; with Justify All the last
+    /// line is stretched too, so its slack counts (After Effects then balances the lines: 4 / 4 / 4
+    /// words where the other modes break 6 / 6 / 1).
+    fn optimal_breaks(&self, opps: &[usize]) -> Vec<Range<usize>> {
+        let last_counts = self.para.align == Align::Justify && self.para.justify_last == Align::Justify;
+        let nodes: Vec<usize> = std::iter::once(0).chain(opps.iter().copied()).collect();
+        let m = nodes.len();
+        let mut best = vec![(f32::INFINITY, 0usize); m];
+        best[0] = (0.0, 0);
+        for j in 1..m {
+            for i in (0..j).rev() {
+                if !best[i].0.is_finite() {
+                    continue;
+                }
+                let r = nodes[i]..nodes[j];
+                let w = self.fits_w(&r);
+                let maxw = self.line_avail(usize::from(i != 0));
+                let over = w > maxw;
+                if over && i + 1 != j {
+                    break;
+                }
+                let slack = maxw - w;
+                let cost = if over {
+                    1e12 + w
+                } else if j == m - 1 && !last_counts {
+                    0.0
+                } else {
+                    slack * slack
+                };
+                let total = best[i].0 + cost;
+                if total < best[j].0 {
+                    best[j] = (total, i);
+                }
+            }
+        }
+        let mut ranges = Vec::new();
+        let mut j = m - 1;
+        while j > 0 {
+            let i = best[j].1;
+            ranges.push(nodes[i]..nodes[j]);
+            j = i;
+        }
+        ranges.reverse();
+        ranges
+    }
+
+    /// Breaks at each opportunity that still fits, else at the last one that did.
+    fn greedy_breaks(&self, opps: Vec<usize>) -> Vec<Range<usize>> {
+        let mut ranges = Vec::new();
+        let mut start = 0usize;
+        let mut last_ok: Option<usize> = None;
+        for p in opps {
+            loop {
+                let w = self.fits_w(&(start..p));
+                if w <= self.line_avail(ranges.len()) || last_ok.is_none() {
+                    last_ok = Some(p);
+                    break;
+                }
+                let Some(b) = last_ok.take() else { break };
+                ranges.push(start..b);
+                start = b;
+            }
+        }
+        ranges.push(start..self.text.len());
+        ranges
+    }
+
+    /// The line over byte range `r`: the `li`-th of the paragraph, `last` if it is the final one.
+    fn place_line(&self, li: usize, r: Range<usize>, last: bool) -> ParaLine {
+        let align = align_for(self.para, self.base_rtl, self.width, last);
+        let avail = avail_for(self.para, self.base_rtl, self.width, li == 0);
+        let (ce, tw) = self.trailing_ws(&r);
+        let hang = self.hang_of(&r, ce);
+        let content = self.range_w(r.start..ce);
+        // justification
+        let mut space_extra = 0.0;
+        if align == Align::Justify
+            && let Some(maxw) = avail
+        {
+            let spaces = self.text[r.start..ce].chars().filter(|c| *c == ' ').count();
+            if spaces > 0 {
+                space_extra = ((maxw - (content - hang.0 - hang.1)) / spaces as f32).max(0.0);
+            }
+        }
+        let placed = self.place_glyphs(&r, space_extra, ce);
+        let carets = self.carets(&r, &placed.extents, placed.pen);
+        let (asc, desc, adv, first) = self.line_metrics(&r, &placed.glyphs);
+        let content_w = if space_extra > 0.0 { avail.map_or(content, |a| a + hang.0 + hang.1) } else { content };
+        ParaLine {
+            range: self.base + r.start..self.base + r.end,
+            glyphs: placed.glyphs,
+            carets,
+            content: content_w,
+            left_trim: if self.base_rtl { tw } else { 0.0 },
+            hang,
+            ascent: asc,
+            descent: desc,
+            first,
+            advance: adv,
+            align,
+            avail,
+            margins: margins_for(self.para, self.base_rtl, li == 0),
+            underline: placed.underline,
+        }
+    }
+
+    fn place_glyphs(&self, r: &Range<usize>, space_extra: f32, ce: usize) -> Placed {
+        let (levels, vruns) = self.bidi.visual_runs(&self.bidi.paragraphs[0], r.clone());
+        let mut pen = 0.0f32;
+        let mut glyphs = Vec::new();
+        let mut extents: HashMap<usize, (f32, f32, bool)> = HashMap::new();
+        let mut underline: Option<(f32, f32)> = None;
+        for run in vruns {
+            let rtl = levels[run.start].is_rtl();
+            // Items are ordered and disjoint: binary-search both ends of the overlapping slice.
+            let run_limit = self.items.partition_point(|item| item.range.start < run.end);
+            let run_first = self.items[..run_limit].partition_point(|item| item.range.end <= run.start);
+            let mut idx: Vec<usize> = (run_first..run_limit).collect();
+            if rtl {
+                idx.reverse();
+            }
+            for k in idx {
+                for g in self.items[k].glyphs.iter().filter(|g| run.contains(&g.cluster)) {
+                    let st = &self.runs[g.run].1;
+                    let x0 = pen;
+                    pen += g.pre;
+                    glyphs.push(Glyph {
+                        face: g.face,
+                        id: g.id,
+                        x: pen + g.dx,
+                        y: -g.dy - g.rise,
+                        size: g.size,
+                        cluster: self.base + g.cluster,
+                        synth_bold: self.primaries[g.run].synth_bold || st.faux_bold,
+                        synth_italic: self.primaries[g.run].synth_italic || st.faux_italic,
+                        h_scale: st.h_scale,
+                        v_scale: st.v_scale,
+                        run: g.run,
+                        variations: self.variation_ids[g.run],
+                    });
+                    pen += g.adv;
+                    if space_extra > 0.0 && self.text[g.cluster..].starts_with(' ') && g.cluster < ce {
+                        pen += space_extra;
+                    }
+                    if st.underline && g.cluster < ce {
+                        let u = underline.get_or_insert((x0, pen));
+                        u.0 = u.0.min(x0);
+                        u.1 = u.1.max(pen);
+                    }
+                    let e = extents.entry(g.cluster).or_insert((x0, pen, self.items[k].rtl));
+                    e.0 = e.0.min(x0);
+                    e.1 = e.1.max(pen);
+                }
+            }
+        }
+        Placed { glyphs, pen, extents, underline }
+    }
+
+    /// Caret stops at each char boundary of the line, and at its end.
+    fn carets(&self, r: &Range<usize>, extents: &HashMap<usize, (f32, f32, bool)>, pen: f32) -> Vec<(usize, f32)> {
+        let mut carets = Vec::new();
+        let mut cluster_starts: Vec<usize> = extents.keys().copied().collect();
+        cluster_starts.sort_unstable();
+        let char_bytes: Vec<usize> = self.text[r.clone()].char_indices().map(|(b, _)| r.start + b).collect();
+        let mut char_index = 0usize;
+        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);
+            while char_index < char_bytes.len() && char_bytes[char_index] < cs {
+                char_index += 1;
+            }
+            let begin = char_index;
+            while char_index < char_bytes.len() && char_bytes[char_index] < next {
+                char_index += 1;
+            }
+            let count = (char_index - begin).max(1) as f32;
+            for (mi, b) in char_bytes[begin..char_index].iter().enumerate() {
+                let f = mi as f32 / count;
+                let x = if rtl { x1 - (x1 - x0) * f } else { x0 + (x1 - x0) * f };
+                carets.push((self.base + b, x));
+            }
+        }
+        // end of line caret
+        let end_x = match self.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((self.base + r.end, end_x));
+        carets.sort_by_key(|c| c.0);
+        carets.dedup_by_key(|c| c.0);
+        carets
+    }
+
+    /// Ascent, descent and advance of the line: the tallest face and the largest leading on it.
+    fn line_metrics(&self, r: &Range<usize>, glyphs: &[Glyph]) -> (f32, f32, f32, f32) {
+        let (mut asc, mut desc, mut adv, mut first) = (0.0f32, 0.0f32, 0.0f32, 0.0f32);
+        let char_start = self.chars.partition_point(|c| c.0 < r.start);
+        let char_end = self.chars.partition_point(|c| c.0 < r.end);
+        let mut seen: Vec<usize> = self.chars[char_start..char_end].iter().map(|c| c.6).collect();
+        seen.sort_unstable();
+        seen.dedup();
+        if seen.is_empty() {
+            seen.push(self.chars.first().map_or(0, |c| c.6));
+        }
+        for &si in &seen {
+            let m = style_metrics(self.primaries, self.runs, si);
+            let rise = self.runs[si].1.rise();
+            asc = asc.max(m.ascent + rise.max(0.0));
+            desc = desc.max(m.descent - rise.min(0.0));
+            adv = adv.max(self.runs[si].1.line_advance());
+            first = first.max(style_first(self.primaries, self.runs, si));
+        }
+        for g in glyphs {
+            if g.face != self.primaries[g.run].face {
+                let m = fonts::face(g.face).metrics(g.size);
+                asc = asc.max(m.ascent);
+                desc = desc.max(m.descent);
+            }
+        }
+        (asc, desc, adv, first)
+    }
+}
+
+/// Each char with its shaped form, face, direction and run.
+fn char_forms(text: &str, base: usize, runs: &[(Range<usize>, TextStyle)], primaries: &[Resolved], bidi: &BidiInfo) -> Vec<CharInfo> {
+    text.char_indices()
         .map(|(b, c)| {
             let si = run_at(runs, base + b);
             let style = &runs[si].1;
@@ -677,13 +1041,15 @@ fn paragraph(
             }
             (b, c, sc, face, bidi.levels[b].is_rtl(), form, si)
         })
-        .collect();
-    // items: runs of equal (face, rtl, small, style)
+        .collect()
+}
+
+/// Runs of chars with the same face, direction, form, run and CJK vertical flag, shaped as one.
+fn build_items(text: &str, chars: &[CharInfo], runs: &[(Range<usize>, TextStyle)]) -> Vec<Item> {
+    let key = |c: &CharInfo| (c.3, c.4, c.5, c.6, runs.get(c.6).is_some_and(|run| run.1.vertical) && crate::is_cjk(c.1));
     let mut items: Vec<Item> = Vec::new();
     let mut i = 0;
     while i < chars.len() {
-        let key =
-            |c: &(usize, char, char, FaceId, bool, Form, usize)| (c.3, c.4, c.5, c.6, runs.get(c.6).is_some_and(|run| run.1.vertical) && crate::is_cjk(c.1));
         let k0 = key(&chars[i]);
         let mut j = i + 1;
         while j < chars.len() && key(&chars[j]) == k0 {
@@ -703,272 +1069,46 @@ fn paragraph(
         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 + g.pre;
-        }
+    items
+}
+
+fn paragraph(
+    text: &str,
+    base: usize,
+    runs: &[(Range<usize>, TextStyle)],
+    primaries: &[Resolved],
+    variation_ids: &[u32],
+    para: &ParagraphStyle,
+    width: Option<f32>,
+) -> Vec<ParaLine> {
+    if text.is_empty() {
+        let si = run_at(runs, base);
+        let pm = style_metrics(primaries, runs, si);
+        // No text to resolve a direction from: the explicit one.
+        let rtl = para.rtl == Some(true);
+        return vec![ParaLine {
+            range: base..base,
+            glyphs: vec![],
+            carets: vec![(base, 0.0)],
+            content: 0.0,
+            left_trim: 0.0,
+            hang: (0.0, 0.0),
+            ascent: pm.ascent,
+            descent: pm.descent,
+            advance: runs[si].1.line_advance(),
+            first: style_first(primaries, runs, si),
+            align: align_for(para, rtl, width, true),
+            avail: avail_for(para, rtl, width, true),
+            margins: margins_for(para, rtl, true),
+            underline: None,
+        }];
     }
-    // Prefix widths and the preceding non-whitespace boundary make candidate line widths O(1).
-    // Every-line composition evaluates O(n²) candidate breaks; summing each candidate's bytes
-    // or rescanning its trailing whitespace would otherwise add another factor of text length.
-    let mut prefix_adv = vec![0.0f64; text.len() + 1];
-    for i in 0..text.len() {
-        prefix_adv[i + 1] = prefix_adv[i] + f64::from(char_adv[i]);
-    }
-    let mut previous_non_ws = vec![0usize; text.len() + 1];
-    let mut non_ws_end = 0usize;
-    for (b, c) in text.char_indices() {
-        previous_non_ws[b] = non_ws_end;
-        if !c.is_whitespace() {
-            non_ws_end = b + c.len_utf8();
-        }
-        previous_non_ws[b + c.len_utf8()] = non_ws_end;
-    }
-    let range_w = |r: Range<usize>| -> f32 { (prefix_adv[r.end] - prefix_adv[r.start]) as f32 };
-    let trailing_ws = |r: &Range<usize>| -> (usize, f32) {
-        let end = previous_non_ws[r.end].max(r.start).min(r.end);
-        (end, (prefix_adv[r.end] - prefix_adv[end]) as f32)
-    };
-    // Hanging punctuation widths (left, right) of a line's content.
-    let hang_of = |r: &Range<usize>, ce: usize| -> (f32, f32) {
-        if !para.hanging || width.is_none() || r.start >= ce {
-            return (0.0, 0.0);
-        }
-        let first = text[r.start..ce].chars().next().filter(|c| is_hanging_open(*c)).map_or(0.0, |_| char_adv[r.start]);
-        let last = text[r.start..ce].char_indices().next_back().filter(|(_, c)| is_hanging_close(*c)).map_or(0.0, |(b, _)| char_adv[r.start + b]);
-        (first, last)
-    };
-    let fits_w = |r: &Range<usize>| -> f32 {
-        let (ce, _) = trailing_ws(r);
-        let (hl, hr) = hang_of(r, ce);
-        range_w(r.start..ce) - hl - hr
-    };
-    // line breaking
-    let mut ranges: Vec<Range<usize>> = Vec::new();
-    match width {
-        None => ranges.push(0..text.len()),
-        Some(_) => {
-            let opps: Vec<usize> = unicode_linebreak::linebreaks(text).map(|(p, _)| p).collect();
-            let avail = |line: usize| avail_for(line == 0).unwrap_or(f32::MAX);
-            if para.every_line && opps.len() > 1 && opps.len() <= 1500 {
-                // Minimise the summed squared slack of every line but the last.
-                let nodes: Vec<usize> = std::iter::once(0).chain(opps.iter().copied()).collect();
-                let m = nodes.len();
-                let mut best = vec![(f32::INFINITY, 0usize); m];
-                best[0] = (0.0, 0);
-                for j in 1..m {
-                    for i in (0..j).rev() {
-                        if !best[i].0.is_finite() {
-                            continue;
-                        }
-                        let r = nodes[i]..nodes[j];
-                        let w = fits_w(&r);
-                        let maxw = avail(usize::from(i != 0));
-                        let over = w > maxw;
-                        if over && i + 1 != j {
-                            break;
-                        }
-                        let slack = maxw - w;
-                        let cost = if over {
-                            1e12 + w
-                        } else if j == m - 1 {
-                            0.0
-                        } else {
-                            slack * slack
-                        };
-                        let total = best[i].0 + cost;
-                        if total < best[j].0 {
-                            best[j] = (total, i);
-                        }
-                    }
-                }
-                let mut j = m - 1;
-                while j > 0 {
-                    let i = best[j].1;
-                    ranges.push(nodes[i]..nodes[j]);
-                    j = i;
-                }
-                ranges.reverse();
-            } else {
-                let mut start = 0usize;
-                let mut last_ok: Option<usize> = None;
-                for p in opps {
-                    loop {
-                        let w = fits_w(&(start..p));
-                        if w <= avail(ranges.len()) || last_ok.is_none() {
-                            last_ok = Some(p);
-                            break;
-                        }
-                        let Some(b) = last_ok.take() else { break };
-                        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 p = Para::new(text, base, runs, primaries, variation_ids, para, width);
+    let ranges = p.break_ranges();
     let nlines = ranges.len();
-    let mut out = Vec::new();
-    for (li, r) in ranges.into_iter().enumerate() {
-        let last = li + 1 == nlines;
-        let align = eff_align(last);
-        let avail = avail_for(li == 0);
-        let (ce, tw) = trailing_ws(&r);
-        let hang = hang_of(&r, ce);
-        let content = range_w(r.start..ce);
-        // justification
-        let mut space_extra = 0.0;
-        if align == Align::Justify
-            && let Some(maxw) = avail
-        {
-            let spaces = text[r.start..ce].chars().filter(|c| *c == ' ').count();
-            if spaces > 0 {
-                space_extra = ((maxw - (content - hang.0 - hang.1)) / spaces as f32).max(0.0);
-            }
-        }
-        let (levels, vruns) = 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();
-        let mut underline: Option<(f32, f32)> = None;
-        for run in vruns {
-            let rtl = levels[run.start].is_rtl();
-            // Items are ordered and disjoint: binary-search both ends of the overlapping slice.
-            let run_limit = items.partition_point(|item| item.range.start < run.end);
-            let run_first = items[..run_limit].partition_point(|item| item.range.end <= run.start);
-            let mut idx: Vec<usize> = (run_first..run_limit).collect();
-            if rtl {
-                idx.reverse();
-            }
-            for k in idx {
-                for g in items[k].glyphs.iter().filter(|g| run.contains(&g.cluster)) {
-                    let st = &runs[g.run].1;
-                    let x0 = pen;
-                    pen += g.pre;
-                    glyphs.push(Glyph {
-                        face: g.face,
-                        id: g.id,
-                        x: pen + g.dx,
-                        y: -g.dy - g.rise,
-                        size: g.size,
-                        cluster: base + g.cluster,
-                        synth_bold: primaries[g.run].synth_bold || st.faux_bold,
-                        synth_italic: primaries[g.run].synth_italic || st.faux_italic,
-                        h_scale: st.h_scale,
-                        v_scale: st.v_scale,
-                        run: g.run,
-                        variations: variation_ids[g.run],
-                    });
-                    pen += g.adv;
-                    if space_extra > 0.0 && text[g.cluster..].starts_with(' ') && g.cluster < ce {
-                        pen += space_extra;
-                    }
-                    if st.underline && g.cluster < ce {
-                        let u = underline.get_or_insert((x0, pen));
-                        u.0 = u.0.min(x0);
-                        u.1 = u.1.max(pen);
-                    }
-                    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();
-        let mut char_index = 0usize;
-        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);
-            while char_index < char_bytes.len() && char_bytes[char_index] < cs {
-                char_index += 1;
-            }
-            let begin = char_index;
-            while char_index < char_bytes.len() && char_bytes[char_index] < next {
-                char_index += 1;
-            }
-            let count = (char_index - begin).max(1) as f32;
-            for (mi, b) in char_bytes[begin..char_index].iter().enumerate() {
-                let f = mi as f32 / count;
-                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);
-        // Line metrics: the tallest face and the largest leading on the line.
-        let (mut asc, mut desc, mut adv) = (0.0f32, 0.0f32, 0.0f32);
-        let char_start = chars.partition_point(|c| c.0 < r.start);
-        let char_end = chars.partition_point(|c| c.0 < r.end);
-        let mut seen: Vec<usize> = chars[char_start..char_end].iter().map(|c| c.6).collect();
-        seen.sort_unstable();
-        seen.dedup();
-        if seen.is_empty() {
-            seen.push(chars.first().map_or(0, |c| c.6));
-        }
-        for &si in &seen {
-            let m = style_metrics(si);
-            let rise = runs[si].1.rise();
-            asc = asc.max(m.ascent + rise.max(0.0));
-            desc = desc.max(m.descent - rise.min(0.0));
-            adv = adv.max(runs[si].1.line_advance());
-        }
-        for g in &glyphs {
-            if g.face != primaries[g.run].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 { avail.map_or(content, |a| a + hang.0 + hang.1) } 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 },
-            hang,
-            ascent: asc,
-            descent: desc,
-            advance: adv,
-            align,
-            avail,
-            margins: margins_for(li == 0),
-            underline,
-        });
-    }
-    out
+    ranges.into_iter().enumerate().map(|(li, r)| p.place_line(li, r, li + 1 == nlines)).collect()
 }
 
-/// Lay out `text` (paragraphs separated by CR, LF or CRLF) in one style.
 pub fn layout_uncached(text: &str, style: &TextStyle, para: &ParagraphStyle) -> Layout {
     layout_rich_uncached(text, &[(0..text.len(), style.clone())], std::slice::from_ref(para))
 }
@@ -992,10 +1132,8 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], para
     let primaries: Vec<Resolved> = runs.iter().map(|(_, s)| fonts::resolve(&s.family, &s.style)).collect();
     // A named instance of a variable font (`Figtree` `Black`, or `Figtree-Black`) sets the base
     // axis values; axes set explicitly in the style keep theirs.
-    let instanced: Vec<(Range<usize>, TextStyle)>;
-    let runs = if primaries.iter().any(|p| p.instance.is_some()) {
-        instanced = runs
-            .iter()
+    let instanced = primaries.iter().any(|p| p.instance.is_some()).then(|| {
+        runs.iter()
             .zip(&primaries)
             .map(|((r, s), p)| {
                 let base = fonts::instance_variations(p);
@@ -1005,16 +1143,12 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], para
                 }
                 (r.clone(), s)
             })
-            .collect();
-        &instanced[..]
-    } else {
-        runs
-    };
+            .collect::<Vec<_>>()
+    });
+    let runs = instanced.as_deref().unwrap_or(runs);
     // A location that cannot be interned would outline at the default; shape there too.
-    let cleared: Vec<(Range<usize>, TextStyle)>;
-    let runs = if runs.iter().any(|(_, s)| !s.variations.is_empty() && crate::variable::intern(&s.variations) == 0) {
-        cleared = runs
-            .iter()
+    let cleared = runs.iter().any(|(_, s)| !s.variations.is_empty() && crate::variable::intern(&s.variations) == 0).then(|| {
+        runs.iter()
             .map(|(r, s)| {
                 let mut s = s.clone();
                 if crate::variable::intern(&s.variations) == 0 {
@@ -1022,11 +1156,9 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], para
                 }
                 (r.clone(), s)
             })
-            .collect();
-        &cleared[..]
-    } else {
-        runs
-    };
+            .collect::<Vec<_>>()
+    });
+    let runs = cleared.as_deref().unwrap_or(runs);
     let variation_ids: Vec<u32> = runs.iter().map(|(_, s)| crate::variable::intern(&s.variations)).collect();
     let mut lay = Layout { missing_font: primaries.iter().any(|p| p.missing), text_len: text.len(), ..Default::default() };
     let mut plines: Vec<(usize, ParaLine)> = Vec::new();
@@ -1038,7 +1170,10 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], para
     for (i, (pi, pl)) in plines.into_iter().enumerate() {
         let para = para_at(pi);
         if i == 0 {
-            baseline = if width.is_some() { pl.ascent } else { 0.0 };
+            // Vertical type keeps its first column at the font ascent (not measured in AE).
+            let vertical = runs.get(run_at(runs, pl.range.start)).is_some_and(|r| r.1.vertical)
+                || runs.iter().any(|r| r.1.vertical && r.0.start < pl.range.end && r.0.end > pl.range.start);
+            baseline = if width.is_some() { if vertical { pl.ascent } else { pl.first } } else { 0.0 };
         } else {
             let prev_para = lay.lines.last().map_or(pi, |l| l.para);
             let mut adv = pl.advance + para.leading;
@@ -1047,17 +1182,7 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], para
             }
             baseline += adv;
         }
-        let shown = pl.content - pl.hang.0 - pl.hang.1;
-        let (ml, mr) = pl.margins;
-        let shift = match (pl.avail, pl.align) {
-            (None, Align::Left | Align::Justify) => ml,
-            (None, Align::Center) => -shown / 2.0 + (ml - mr) / 2.0,
-            (None, Align::Right) => -shown - mr,
-            (Some(_), Align::Left | Align::Justify) => ml,
-            (Some(a), Align::Center) => ml + (a - shown) / 2.0,
-            (Some(a), Align::Right) => ml + a - shown,
-        } - pl.left_trim
-            - pl.hang.0;
+        let shift = line_shift(&pl);
         let g0 = lay.glyphs.len();
         lay.glyphs.extend(pl.glyphs.into_iter().map(|mut g| {
             g.x += shift;
@@ -1086,6 +1211,27 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], para
     for i in 0..lay.lines.len() {
         lay.lines[i].para_end = lay.lines.get(i + 1).is_none_or(|n| n.para != lay.lines[i].para);
     }
+    set_bounds(&mut lay, width);
+    lay
+}
+
+/// Horizontal shift of a line from its paragraph's alignment, margins and hanging punctuation.
+fn line_shift(pl: &ParaLine) -> f32 {
+    let shown = pl.content - pl.hang.0 - pl.hang.1;
+    let (ml, mr) = pl.margins;
+    let shift = match (pl.avail, pl.align) {
+        (None, Align::Left | Align::Justify) => ml,
+        (None, Align::Center) => -shown / 2.0 + (ml - mr) / 2.0,
+        (None, Align::Right) => -shown - mr,
+        (Some(_), Align::Left | Align::Justify) => ml,
+        (Some(a), Align::Center) => ml + (a - shown) / 2.0,
+        (Some(a), Align::Right) => ml + a - shown,
+    };
+    shift - pl.left_trim - pl.hang.0
+}
+
+/// The layout's bounds: the lines' horizontal extent (and the wrap width), and their vertical extent.
+fn set_bounds(lay: &mut Layout, width: Option<f32>) {
     let (mut x0, mut x1) = (f32::MAX, f32::MIN);
     for l in &lay.lines {
         x0 = x0.min(l.x);
@@ -1098,7 +1244,6 @@ pub fn layout_rich_uncached(text: &str, runs: &[(Range<usize>, TextStyle)], para
     if let (Some(first), Some(last)) = (lay.lines.first(), lay.lines.last()) {
         lay.bounds = [x0, first.baseline - first.ascent, x1.max(x0), last.baseline + last.descent];
     }
-    lay
 }
 
 fn cache() -> &'static Mutex<HashMap<u64, (u64, Arc<Layout>)>> {
@@ -1147,372 +1292,4 @@ pub fn measure(text: &str, style: &TextStyle) -> f32 {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn st(size: f32) -> TextStyle {
-        TextStyle { size, ..Default::default() }
-    }
-
-    fn ids(text: &str, s: &TextStyle) -> Vec<u32> {
-        layout_uncached(text, s, &ParagraphStyle::default()).glyphs.iter().map(|g| g.id).collect()
-    }
-
-    fn ot(f: impl FnOnce(&mut OpenType)) -> TextStyle {
-        let mut s = st(100.0);
-        f(&mut s.opentype);
-        s
-    }
-
-    fn serif() -> TextStyle {
-        TextStyle { family: "Noto Serif".into(), ..st(100.0) }
-    }
-
-    #[test]
-    fn bundled_faces_list_their_features() {
-        let inter = fonts::face(fonts::resolve("Inter", "Regular").face).features();
-        for t in ["ss01", "dlig", "frac", "tnum", "sups", "ordn"] {
-            assert!(inter.iter().any(|f| f == t), "{t} in {inter:?}");
-        }
-        let serif = fonts::face(fonts::resolve("Noto Serif", "Regular").face).features();
-        for t in ["smcp", "c2sc", "onum", "lnum"] {
-            assert!(serif.iter().any(|f| f == t), "{t} in {serif:?}");
-        }
-    }
-
-    #[test]
-    fn opentype_features_substitute_glyphs() {
-        let plain = st(100.0);
-        // Stylistic sets, fractions, ordinals, figure widths and discretionary ligatures.
-        assert_ne!(ids("1234567890", &plain), ids("1234567890", &ot(|o| o.set_stylistic_set(1, true))), "ss01 alternate digits");
-        assert_eq!(ids("1234567890", &plain), ids("1234567890", &ot(|o| o.set_stylistic_set(20, true))), "Inter has no ss20");
-        assert_ne!(ids("1/2", &plain), ids("1/2", &ot(|o| o.fractions = true)), "frac");
-        assert_ne!(ids("1a 2o No", &plain), ids("1a 2o No", &ot(|o| o.ordinals = true)), "ordn");
-        let tab = measure("1111", &ot(|o| o.figure_width = effectcraft_keyframe::FigureWidth::Tabular));
-        let prop = measure("1111", &ot(|o| o.figure_width = effectcraft_keyframe::FigureWidth::Proportional));
-        assert!((tab - prop).abs() > 1.0, "tabular {tab} vs proportional {prop}");
-        // Old-style figures (Noto Serif).
-        let old = TextStyle { opentype: OpenType { figure_style: effectcraft_keyframe::FigureStyle::OldStyle, ..Default::default() }, ..serif() };
-        assert_ne!(ids("123", &serif()), ids("123", &old), "onum");
-        // Contextual alternates are on by default; turning them off can only keep or change glyphs.
-        let no_calt = ot(|o| o.contextual_alternates = false);
-        assert_eq!(ids("Hello", &plain).len(), ids("Hello", &no_calt).len());
-    }
-
-    #[test]
-    fn true_small_caps_and_superscripts_with_faux_fallback() {
-        // Noto Serif has smcp: lowercase letters take their own small-capital glyphs at full size.
-        let sc = TextStyle { caps: Caps::Small, ..serif() };
-        let l = layout_uncached("Ab", &sc, &ParagraphStyle::default());
-        let upper_b = ids("B", &serif())[0];
-        assert_ne!(l.glyphs[1].id, upper_b, "true small cap glyph, not a scaled capital");
-        assert_eq!(l.glyphs[1].size, 100.0);
-        // Inter has no smcp: a capital scaled down.
-        let faux = layout_uncached("Ab", &TextStyle { caps: Caps::Small, ..st(100.0) }, &ParagraphStyle::default());
-        assert_eq!(faux.glyphs[1].id, ids("B", &st(100.0))[0]);
-        assert!((faux.glyphs[1].size - 78.0).abs() < 0.01);
-        // All Small Caps: capitals become small capitals too (c2sc).
-        let all = TextStyle { opentype: OpenType { all_small_caps: true, ..Default::default() }, ..serif() };
-        let a = layout_uncached("AB", &all, &ParagraphStyle::default());
-        assert_ne!(a.glyphs[0].id, ids("A", &serif())[0]);
-        // Superscript: Inter's sups figures at full size on the baseline; letters it lacks are
-        // synthesized (smaller and raised).
-        let sup = TextStyle { script: Script::Super, ..st(100.0) };
-        let s2 = layout_uncached("2", &sup, &ParagraphStyle::default());
-        assert_ne!(s2.glyphs[0].id, ids("2", &st(100.0))[0]);
-        assert_eq!(s2.glyphs[0].size, 100.0);
-        assert_eq!(s2.glyphs[0].y, 0.0);
-        let sq = layout_uncached("q", &sup, &ParagraphStyle::default());
-        if !feature_substitutes(sq.glyphs[0].face, b"sups", 'q') {
-            assert!(sq.glyphs[0].size < 60.0 && sq.glyphs[0].y < -20.0, "{:?}", sq.glyphs[0]);
-        }
-        let sub = layout_uncached("2", &TextStyle { script: Script::Sub, ..st(100.0) }, &ParagraphStyle::default());
-        assert_ne!(sub.glyphs[0].id, s2.glyphs[0].id);
-    }
-
-    #[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]);
-    }
-
-    fn rich(text: &str, runs: &[(Range<usize>, TextStyle)], para: ParagraphStyle) -> Layout {
-        layout_rich_uncached(text, runs, &[para])
-    }
-
-    #[test]
-    fn mixed_sizes_share_a_baseline_and_take_the_largest_leading() {
-        let text = "small BIG\nnext";
-        let runs = [(0..6, st(20.0)), (6..9, st(80.0)), (9..text.len(), st(20.0))];
-        let l = rich(text, &runs, ParagraphStyle::default());
-        assert_eq!(l.lines.len(), 2);
-        let y0 = l.glyphs[0].y;
-        assert!(l.glyphs[..9].iter().all(|g| (g.y - y0).abs() < 1e-3), "one baseline per line");
-        assert!(l.glyphs[7].size > l.glyphs[0].size * 3.0);
-        // Line 2's advance is its own leading (20 px text: 24 px); line 1 is as tall as the big run.
-        assert!((l.lines[1].baseline - l.lines[0].baseline - 24.0).abs() < 1e-3, "{}", l.lines[1].baseline);
-        assert!(l.lines[0].ascent > 60.0);
-        // A big run on the second line pushes it down by its 120% leading.
-        let text2 = "aa\nBB";
-        let l2 = rich(text2, &[(0..3, st(20.0)), (3..5, st(80.0))], ParagraphStyle::default());
-        assert!((l2.lines[1].baseline - 96.0).abs() < 1e-3);
-        // Explicit leading wins over auto.
-        let mut fixed = st(20.0);
-        fixed.leading = Some(50.0);
-        let l3 = rich("a\nb", &[(0..3, fixed)], ParagraphStyle::default());
-        assert!((l3.lines[1].baseline - 50.0).abs() < 1e-3);
-    }
-
-    #[test]
-    fn super_subscript_tsume_and_kerning_metrics() {
-        let base = st(100.0);
-        let sup = TextStyle { script: Script::Super, ..base.clone() };
-        let sub = TextStyle { script: Script::Sub, ..base.clone() };
-        // A letter the font has no superior / inferior glyph for: synthesized.
-        let inter = fonts::resolve("Inter", "Regular").face;
-        let c = "qwkzvjxyQWK".chars().find(|&c| !feature_substitutes(inter, b"sups", c) && !feature_substitutes(inter, b"subs", c)).unwrap();
-        let text: String = ['x', c, 'y', c].iter().collect();
-        let l = rich(&text, &[(0..1, base.clone()), (1..2, sup), (2..3, base.clone()), (3..4, sub)], ParagraphStyle::default());
-        let g = &l.glyphs;
-        assert!((g[1].size - 58.3).abs() < 0.1);
-        assert!((g[1].y - (g[0].y - 33.3)).abs() < 0.1, "superscript raised by a third of the size");
-        assert!((g[3].y - (g[2].y + 33.3)).abs() < 0.1, "subscript lowered");
-        // Tsume removes side bearings; full tsume is narrower than none.
-        let w0 = measure("onion", &base);
-        let w1 = measure("onion", &TextStyle { tsume: 1.0, ..base.clone() });
-        assert!(w1 < w0 - 5.0, "{w1} vs {w0}");
-        // Manual kerning: +100/1000 em before each of the 5 later characters of AVAVAV, metrics off.
-        let nokern = measure("AVAVAV", &TextStyle { kerning: false, ..base.clone() });
-        let manual = measure("AVAVAV", &TextStyle { manual_kern: Some(100.0), ..base.clone() });
-        assert!((manual - nokern - 50.0).abs() < 0.5, "{manual} {nokern}");
-        let optical = measure("AVAVAV", &TextStyle { optical: true, ..base.clone() });
-        assert!(optical > 0.0 && (optical - nokern).abs() < 100.0);
-        // Horizontal scale stretches advances.
-        let wide = measure("onion", &TextStyle { h_scale: 2.0, ..base.clone() });
-        assert!((wide - 2.0 * w0).abs() < 0.5);
-        let l = layout("o", &TextStyle { h_scale: 2.0, v_scale: 0.5, ..base }, &ParagraphStyle::default());
-        assert_eq!((l.glyphs[0].h_scale, l.glyphs[0].v_scale), (2.0, 0.5));
-    }
-
-    #[test]
-    fn indents_and_paragraph_spacing() {
-        let s = st(20.0);
-        let text = "first paragraph here\nsecond one";
-        let p0 = ParagraphStyle { width: Some(400.0), indent_start: 30.0, indent_first: 15.0, space_after: 10.0, ..Default::default() };
-        let p1 = ParagraphStyle { width: Some(400.0), indent_end: 50.0, align: Align::Right, space_before: 7.0, ..Default::default() };
-        let l = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p0.clone(), p1]);
-        assert!((l.lines[0].x - 45.0).abs() < 1e-3, "left + first-line indent: {}", l.lines[0].x);
-        assert!((l.lines[1].x + l.lines[1].width - 350.0).abs() < 0.5, "right indent: {}", l.lines[1].x + l.lines[1].width);
-        assert!((l.lines[1].baseline - l.lines[0].baseline - (24.0 + 10.0 + 7.0)).abs() < 1e-3);
-        assert_eq!((l.lines[0].para, l.lines[1].para), (0, 1));
-        assert!(l.lines[0].para_end && l.lines[1].para_end);
-        // Wrapped lines after the first don't get the first-line indent.
-        let long = "word ".repeat(30);
-        let l = layout_rich_uncached(&long, &[(0..long.len(), s.clone())], &[p0]);
-        assert!(l.lines.len() > 2);
-        assert!((l.lines[1].x - 30.0).abs() < 1e-3);
-        assert!(l.lines.iter().all(|ln| ln.x + ln.width <= 400.0 + 0.5));
-        assert!(!l.lines[0].para_end);
-        // Point text: a right-aligned paragraph's end indent moves it left of the origin.
-        let l = layout_rich_uncached("abc", &[(0..3, s)], &[ParagraphStyle { align: Align::Right, indent_end: 12.0, ..Default::default() }]);
-        assert!((l.lines[0].x + l.lines[0].width + 12.0).abs() < 1e-3);
-    }
-
-    #[test]
-    fn justify_last_line_modes_and_every_line_composer() {
-        let text = "the quick brown fox jumps over the lazy dog and keeps running far";
-        let s = st(30.0);
-        let p = |last: Align| ParagraphStyle { width: Some(320.0), align: Align::Justify, justify_last: last, ..Default::default() };
-        let left = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p(Align::Left)]);
-        let n = left.lines.len();
-        assert!(n >= 3);
-        assert!((left.lines[0].width - 320.0).abs() < 0.5);
-        assert!(left.lines[n - 1].width < 320.0 && left.lines[n - 1].x.abs() < 1e-3);
-        let center = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p(Align::Center)]);
-        let lc = &center.lines[n - 1];
-        assert!((lc.x - (320.0 - lc.width) / 2.0).abs() < 0.5);
-        let right = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p(Align::Right)]);
-        let lr = &right.lines[n - 1];
-        assert!((lr.x + lr.width - 320.0).abs() < 0.5);
-        let all = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p(Align::Justify)]);
-        assert!((all.lines[n - 1].width - 320.0).abs() < 0.5, "justify all stretches the last line");
-        // Every-line composer: never worse (summed squared slack) than greedy breaking.
-        let slack = |l: &Layout| -> f32 { l.lines[..l.lines.len() - 1].iter().map(|ln| (320.0 - ln.width).powi(2)).sum() };
-        let greedy = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[ParagraphStyle { width: Some(320.0), ..Default::default() }]);
-        let every = layout_rich_uncached(text, &[(0..text.len(), s)], &[ParagraphStyle { width: Some(320.0), every_line: true, ..Default::default() }]);
-        assert!(slack(&every) <= slack(&greedy) + 1e-3, "{} vs {}", slack(&every), slack(&greedy));
-        assert!(every.lines.iter().all(|ln| ln.width <= 320.0 + 0.5));
-    }
-
-    #[test]
-    fn hanging_punctuation_overhangs_the_box() {
-        let s = st(40.0);
-        let text = "\"Hi.\"";
-        let p = ParagraphStyle { width: Some(400.0), hanging: true, ..Default::default() };
-        let l = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p]);
-        assert!(l.lines[0].x < -1.0, "opening quote hangs left: {}", l.lines[0].x);
-        let r = layout_rich_uncached(
-            text,
-            &[(0..text.len(), s)],
-            &[ParagraphStyle { width: Some(400.0), hanging: true, align: Align::Right, ..Default::default() }],
-        );
-        assert!(r.lines[0].x + r.lines[0].width > 401.0, "closing quote hangs right");
-    }
-
-    #[test]
-    fn oversized_layout_requests_are_bounded_without_caching() {
-        let text = "a".repeat(MAX_LAYOUT_BYTES + 1);
-        let layout = layout(&text, &TextStyle::default(), &ParagraphStyle::default());
-        assert_eq!(layout.text_len, text.len());
-        assert!(layout.lines.is_empty() && layout.glyphs.is_empty());
-        assert!(layout_rich_uncached("ok", &[], &[]).lines.len() == 1);
-    }
-
-    #[test]
-    fn rtl_paragraph_carets_run_right_to_left() {
-        let text = "\u{5d0}\u{5d1}\u{5d2}";
-        let l = layout_rich_uncached(text, &[(0..text.len(), st(40.0))], &[ParagraphStyle { rtl: Some(true), ..Default::default() }]);
-        let xs: Vec<f32> = l.lines[0].carets.iter().map(|c| c.1).collect();
-        assert_eq!(xs.len(), 4);
-        assert!(xs.windows(2).all(|w| w[1] < w[0]), "{xs:?}");
-        // Hit testing returns the logical position nearest the point.
-        assert_eq!(l.hit(xs[1] + 0.5, 0.0), 2);
-        assert_eq!(l.hit(xs[0] + 50.0, 0.0), 0);
-    }
-
-    /// #1563: text set in a named instance (`Black`) is laid out at the instance's axis values,
-    /// as if they had been set as variations; axes set on the text itself keep their values.
-    #[test]
-    fn named_instance_sets_the_base_variations() {
-        const FAMILY: &str = "EffectCraft Layout Instance Test";
-        fonts::add_font_data(crate::sfnt::test_font::variable(FAMILY, &[("Light", 300.0, None), ("Black", 900.0, None)], true));
-        let st = |style: &str, variations: Vec<(String, f32)>| TextStyle {
-            family: FAMILY.into(),
-            style: style.into(),
-            size: 50.0,
-            variations,
-            ..Default::default()
-        };
-        let coords = |l: &Layout| l.glyphs.iter().map(|g| crate::variable::coords(g.variations).to_vec()).collect::<Vec<_>>();
-        let black = layout_uncached("Hi", &st("Black", vec![]), &ParagraphStyle::default());
-        assert!(!black.glyphs.is_empty());
-        assert!(coords(&black).iter().all(|c| c == &[("wght".to_string(), 900.0)]), "{:?}", coords(&black));
-        let set = layout_uncached("Hi", &st("Black", vec![("wght".into(), 500.0)]), &ParagraphStyle::default());
-        assert!(coords(&set).iter().all(|c| c == &[("wght".to_string(), 500.0)]), "{:?}", coords(&set));
-        // A static family keeps no variations.
-        let inter = layout_uncached("Hi", &TextStyle::default(), &ParagraphStyle::default());
-        assert!(inter.glyphs.iter().all(|g| g.variations == 0));
-    }
-}
+mod tests;
diff --git a/crates/text/src/layout/tests.rs b/crates/text/src/layout/tests.rs
new file mode 100644
index 000000000..5792c1c16
--- /dev/null
+++ b/crates/text/src/layout/tests.rs
@@ -0,0 +1,496 @@
+use super::*;
+
+fn st(size: f32) -> TextStyle {
+    TextStyle { size, ..Default::default() }
+}
+
+fn ids(text: &str, s: &TextStyle) -> Vec<u32> {
+    layout_uncached(text, s, &ParagraphStyle::default()).glyphs.iter().map(|g| g.id).collect()
+}
+
+fn ot(f: impl FnOnce(&mut OpenType)) -> TextStyle {
+    let mut s = st(100.0);
+    f(&mut s.opentype);
+    s
+}
+
+fn serif() -> TextStyle {
+    TextStyle { family: "Noto Serif".into(), ..st(100.0) }
+}
+
+#[test]
+fn bundled_faces_list_their_features() {
+    let inter = fonts::face(fonts::resolve("Inter", "Regular").face).features();
+    for t in ["ss01", "dlig", "frac", "tnum", "sups", "ordn"] {
+        assert!(inter.iter().any(|f| f == t), "{t} in {inter:?}");
+    }
+    let serif = fonts::face(fonts::resolve("Noto Serif", "Regular").face).features();
+    for t in ["smcp", "c2sc", "onum", "lnum"] {
+        assert!(serif.iter().any(|f| f == t), "{t} in {serif:?}");
+    }
+}
+
+#[test]
+fn opentype_features_substitute_glyphs() {
+    let plain = st(100.0);
+    // Stylistic sets, fractions, ordinals, figure widths and discretionary ligatures.
+    assert_ne!(ids("1234567890", &plain), ids("1234567890", &ot(|o| o.set_stylistic_set(1, true))), "ss01 alternate digits");
+    assert_eq!(ids("1234567890", &plain), ids("1234567890", &ot(|o| o.set_stylistic_set(20, true))), "Inter has no ss20");
+    assert_ne!(ids("1/2", &plain), ids("1/2", &ot(|o| o.fractions = true)), "frac");
+    assert_ne!(ids("1a 2o No", &plain), ids("1a 2o No", &ot(|o| o.ordinals = true)), "ordn");
+    let tab = measure("1111", &ot(|o| o.figure_width = effectcraft_keyframe::FigureWidth::Tabular));
+    let prop = measure("1111", &ot(|o| o.figure_width = effectcraft_keyframe::FigureWidth::Proportional));
+    assert!((tab - prop).abs() > 1.0, "tabular {tab} vs proportional {prop}");
+    // Old-style figures (Noto Serif).
+    let old = TextStyle { opentype: OpenType { figure_style: effectcraft_keyframe::FigureStyle::OldStyle, ..Default::default() }, ..serif() };
+    assert_ne!(ids("123", &serif()), ids("123", &old), "onum");
+    // Contextual alternates are on by default; turning them off can only keep or change glyphs.
+    let no_calt = ot(|o| o.contextual_alternates = false);
+    assert_eq!(ids("Hello", &plain).len(), ids("Hello", &no_calt).len());
+}
+
+#[test]
+fn true_small_caps_and_superscripts_with_faux_fallback() {
+    // Noto Serif has smcp: lowercase letters take their own small-capital glyphs at full size.
+    let sc = TextStyle { caps: Caps::Small, ..serif() };
+    let l = layout_uncached("Ab", &sc, &ParagraphStyle::default());
+    let upper_b = ids("B", &serif())[0];
+    assert_ne!(l.glyphs[1].id, upper_b, "true small cap glyph, not a scaled capital");
+    assert_eq!(l.glyphs[1].size, 100.0);
+    // Inter has no smcp: a capital scaled down.
+    let faux = layout_uncached("Ab", &TextStyle { caps: Caps::Small, ..st(100.0) }, &ParagraphStyle::default());
+    assert_eq!(faux.glyphs[1].id, ids("B", &st(100.0))[0]);
+    assert!((faux.glyphs[1].size - 78.0).abs() < 0.01);
+    // All Small Caps: capitals become small capitals too (c2sc).
+    let all = TextStyle { opentype: OpenType { all_small_caps: true, ..Default::default() }, ..serif() };
+    let a = layout_uncached("AB", &all, &ParagraphStyle::default());
+    assert_ne!(a.glyphs[0].id, ids("A", &serif())[0]);
+    // Superscript: Inter's sups figures at full size on the baseline; letters it lacks are
+    // synthesized (smaller and raised).
+    let sup = TextStyle { script: Script::Super, ..st(100.0) };
+    let s2 = layout_uncached("2", &sup, &ParagraphStyle::default());
+    assert_ne!(s2.glyphs[0].id, ids("2", &st(100.0))[0]);
+    assert_eq!(s2.glyphs[0].size, 100.0);
+    assert_eq!(s2.glyphs[0].y, 0.0);
+    let sq = layout_uncached("q", &sup, &ParagraphStyle::default());
+    if !feature_substitutes(sq.glyphs[0].face, b"sups", 'q') {
+        assert!(sq.glyphs[0].size < 60.0 && sq.glyphs[0].y < -20.0, "{:?}", sq.glyphs[0]);
+    }
+    let sub = layout_uncached("2", &TextStyle { script: Script::Sub, ..st(100.0) }, &ParagraphStyle::default());
+    assert_ne!(sub.glyphs[0].id, s2.glyphs[0].id);
+}
+
+#[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]);
+}
+
+fn rich(text: &str, runs: &[(Range<usize>, TextStyle)], para: ParagraphStyle) -> Layout {
+    layout_rich_uncached(text, runs, &[para])
+}
+
+#[test]
+fn mixed_sizes_share_a_baseline_and_take_the_largest_leading() {
+    let text = "small BIG\nnext";
+    let runs = [(0..6, st(20.0)), (6..9, st(80.0)), (9..text.len(), st(20.0))];
+    let l = rich(text, &runs, ParagraphStyle::default());
+    assert_eq!(l.lines.len(), 2);
+    let y0 = l.glyphs[0].y;
+    assert!(l.glyphs[..9].iter().all(|g| (g.y - y0).abs() < 1e-3), "one baseline per line");
+    assert!(l.glyphs[7].size > l.glyphs[0].size * 3.0);
+    // Line 2's advance is its own leading (20 px text: 24 px); line 1 is as tall as the big run.
+    assert!((l.lines[1].baseline - l.lines[0].baseline - 24.0).abs() < 1e-3, "{}", l.lines[1].baseline);
+    assert!(l.lines[0].ascent > 60.0);
+    // A big run on the second line pushes it down by its 120% leading.
+    let text2 = "aa\nBB";
+    let l2 = rich(text2, &[(0..3, st(20.0)), (3..5, st(80.0))], ParagraphStyle::default());
+    assert!((l2.lines[1].baseline - 96.0).abs() < 1e-3);
+    // Explicit leading wins over auto.
+    let mut fixed = st(20.0);
+    fixed.leading = Some(50.0);
+    let l3 = rich("a\nb", &[(0..3, fixed)], ParagraphStyle::default());
+    assert!((l3.lines[1].baseline - 50.0).abs() < 1e-3);
+}
+
+#[test]
+fn super_subscript_tsume_and_kerning_metrics() {
+    let base = st(100.0);
+    let sup = TextStyle { script: Script::Super, ..base.clone() };
+    let sub = TextStyle { script: Script::Sub, ..base.clone() };
+    // A letter the font has no superior / inferior glyph for: synthesized.
+    let inter = fonts::resolve("Inter", "Regular").face;
+    let c = "qwkzvjxyQWK".chars().find(|&c| !feature_substitutes(inter, b"sups", c) && !feature_substitutes(inter, b"subs", c)).unwrap();
+    let text: String = ['x', c, 'y', c].iter().collect();
+    let l = rich(&text, &[(0..1, base.clone()), (1..2, sup), (2..3, base.clone()), (3..4, sub)], ParagraphStyle::default());
+    let g = &l.glyphs;
+    assert!((g[1].size - 58.3).abs() < 0.1);
+    assert!((g[1].y - (g[0].y - 33.3)).abs() < 0.1, "superscript raised by a third of the size");
+    assert!((g[3].y - (g[2].y + 33.3)).abs() < 0.1, "subscript lowered");
+    // Tsume removes side bearings; full tsume is narrower than none.
+    let w0 = measure("onion", &base);
+    let w1 = measure("onion", &TextStyle { tsume: 1.0, ..base.clone() });
+    assert!(w1 < w0 - 5.0, "{w1} vs {w0}");
+    // Manual kerning: +100/1000 em before each of the 5 later characters of AVAVAV, metrics off.
+    let nokern = measure("AVAVAV", &TextStyle { kerning: false, ..base.clone() });
+    let manual = measure("AVAVAV", &TextStyle { manual_kern: Some(100.0), ..base.clone() });
+    assert!((manual - nokern - 50.0).abs() < 0.5, "{manual} {nokern}");
+    let optical = measure("AVAVAV", &TextStyle { optical: true, ..base.clone() });
+    assert!(optical > 0.0 && (optical - nokern).abs() < 100.0);
+    // Horizontal scale stretches advances.
+    let wide = measure("onion", &TextStyle { h_scale: 2.0, ..base.clone() });
+    assert!((wide - 2.0 * w0).abs() < 0.5);
+    let l = layout("o", &TextStyle { h_scale: 2.0, v_scale: 0.5, ..base }, &ParagraphStyle::default());
+    assert_eq!((l.glyphs[0].h_scale, l.glyphs[0].v_scale), (2.0, 0.5));
+}
+
+#[test]
+fn indents_and_paragraph_spacing() {
+    let s = st(20.0);
+    let text = "first paragraph here\nsecond one";
+    let p0 = ParagraphStyle { width: Some(400.0), indent_start: 30.0, indent_first: 15.0, space_after: 10.0, ..Default::default() };
+    let p1 = ParagraphStyle { width: Some(400.0), indent_end: 50.0, align: Align::Right, space_before: 7.0, ..Default::default() };
+    let l = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p0.clone(), p1]);
+    assert!((l.lines[0].x - 45.0).abs() < 1e-3, "left + first-line indent: {}", l.lines[0].x);
+    assert!((l.lines[1].x + l.lines[1].width - 350.0).abs() < 0.5, "right indent: {}", l.lines[1].x + l.lines[1].width);
+    assert!((l.lines[1].baseline - l.lines[0].baseline - (24.0 + 10.0 + 7.0)).abs() < 1e-3);
+    assert_eq!((l.lines[0].para, l.lines[1].para), (0, 1));
+    assert!(l.lines[0].para_end && l.lines[1].para_end);
+    // Wrapped lines after the first don't get the first-line indent.
+    let long = "word ".repeat(30);
+    let l = layout_rich_uncached(&long, &[(0..long.len(), s.clone())], &[p0]);
+    assert!(l.lines.len() > 2);
+    assert!((l.lines[1].x - 30.0).abs() < 1e-3);
+    assert!(l.lines.iter().all(|ln| ln.x + ln.width <= 400.0 + 0.5));
+    assert!(!l.lines[0].para_end);
+    // Point text: a right-aligned paragraph's end indent moves it left of the origin.
+    let l = layout_rich_uncached("abc", &[(0..3, s)], &[ParagraphStyle { align: Align::Right, indent_end: 12.0, ..Default::default() }]);
+    assert!((l.lines[0].x + l.lines[0].width + 12.0).abs() < 1e-3);
+}
+
+#[test]
+fn justify_last_line_modes_and_every_line_composer() {
+    let text = "the quick brown fox jumps over the lazy dog and keeps running far";
+    let s = st(30.0);
+    let p = |last: Align| ParagraphStyle { width: Some(320.0), align: Align::Justify, justify_last: last, ..Default::default() };
+    let left = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p(Align::Left)]);
+    let n = left.lines.len();
+    assert!(n >= 3);
+    assert!((left.lines[0].width - 320.0).abs() < 0.5);
+    assert!(left.lines[n - 1].width < 320.0 && left.lines[n - 1].x.abs() < 1e-3);
+    let center = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p(Align::Center)]);
+    let lc = &center.lines[n - 1];
+    assert!((lc.x - (320.0 - lc.width) / 2.0).abs() < 0.5);
+    let right = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p(Align::Right)]);
+    let lr = &right.lines[n - 1];
+    assert!((lr.x + lr.width - 320.0).abs() < 0.5);
+    let all = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p(Align::Justify)]);
+    assert!((all.lines[n - 1].width - 320.0).abs() < 0.5, "justify all stretches the last line");
+    // Every-line composer: never worse (summed squared slack) than greedy breaking.
+    let slack = |l: &Layout| -> f32 { l.lines[..l.lines.len() - 1].iter().map(|ln| (320.0 - ln.width).powi(2)).sum() };
+    let greedy = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[ParagraphStyle { width: Some(320.0), ..Default::default() }]);
+    let every = layout_rich_uncached(text, &[(0..text.len(), s)], &[ParagraphStyle { width: Some(320.0), every_line: true, ..Default::default() }]);
+    assert!(slack(&every) <= slack(&greedy) + 1e-3, "{} vs {}", slack(&every), slack(&greedy));
+    assert!(every.lines.iter().all(|ln| ln.width <= 320.0 + 0.5));
+}
+
+#[test]
+fn hanging_punctuation_overhangs_the_box() {
+    let s = st(40.0);
+    let text = "\"Hi.\"";
+    let p = ParagraphStyle { width: Some(400.0), hanging: true, ..Default::default() };
+    let l = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p]);
+    assert!(l.lines[0].x < -1.0, "opening quote hangs left: {}", l.lines[0].x);
+    let r =
+        layout_rich_uncached(text, &[(0..text.len(), s)], &[ParagraphStyle { width: Some(400.0), hanging: true, align: Align::Right, ..Default::default() }]);
+    assert!(r.lines[0].x + r.lines[0].width > 401.0, "closing quote hangs right");
+}
+
+#[test]
+fn oversized_layout_requests_are_bounded_without_caching() {
+    let text = "a".repeat(MAX_LAYOUT_BYTES + 1);
+    let layout = layout(&text, &TextStyle::default(), &ParagraphStyle::default());
+    assert_eq!(layout.text_len, text.len());
+    assert!(layout.lines.is_empty() && layout.glyphs.is_empty());
+    assert!(layout_rich_uncached("ok", &[], &[]).lines.len() == 1);
+}
+
+#[test]
+fn rtl_paragraph_carets_run_right_to_left() {
+    let text = "\u{5d0}\u{5d1}\u{5d2}";
+    let l = layout_rich_uncached(text, &[(0..text.len(), st(40.0))], &[ParagraphStyle { rtl: Some(true), ..Default::default() }]);
+    let xs: Vec<f32> = l.lines[0].carets.iter().map(|c| c.1).collect();
+    assert_eq!(xs.len(), 4);
+    assert!(xs.windows(2).all(|w| w[1] < w[0]), "{xs:?}");
+    // Hit testing returns the logical position nearest the point.
+    assert_eq!(l.hit(xs[1] + 0.5, 0.0), 2);
+    assert_eq!(l.hit(xs[0] + 50.0, 0.0), 0);
+}
+
+/// #1563: text set in a named instance (`Black`) is laid out at the instance's axis values,
+/// as if they had been set as variations; axes set on the text itself keep their values.
+#[test]
+fn named_instance_sets_the_base_variations() {
+    const FAMILY: &str = "EffectCraft Layout Instance Test";
+    fonts::add_font_data(crate::sfnt::test_font::variable(FAMILY, &[("Light", 300.0, None), ("Black", 900.0, None)], true));
+    let st =
+        |style: &str, variations: Vec<(String, f32)>| TextStyle { family: FAMILY.into(), style: style.into(), size: 50.0, variations, ..Default::default() };
+    let coords = |l: &Layout| l.glyphs.iter().map(|g| crate::variable::coords(g.variations).to_vec()).collect::<Vec<_>>();
+    let black = layout_uncached("Hi", &st("Black", vec![]), &ParagraphStyle::default());
+    assert!(!black.glyphs.is_empty());
+    assert!(coords(&black).iter().all(|c| c == &[("wght".to_string(), 900.0)]), "{:?}", coords(&black));
+    let set = layout_uncached("Hi", &st("Black", vec![("wght".into(), 500.0)]), &ParagraphStyle::default());
+    assert!(coords(&set).iter().all(|c| c == &[("wght".to_string(), 500.0)]), "{:?}", coords(&set));
+    // A static family keeps no variations.
+    let inter = layout_uncached("Hi", &TextStyle::default(), &ParagraphStyle::default());
+    assert!(inter.glyphs.iter().all(|g| g.variations == 0));
+}
+
+/// After Effects 2026 (case 818): box text's first baseline is the `d` height (in whole
+/// thousandths of an em) below the box top, at the nominal size also for superscript, whose
+/// glyphs are then raised. EffectCraft used the font ascent of the drawn size (plus the
+/// superscript rise): 89.1 px instead of 69.5 for Times New Roman at 100 px, and the
+/// superscript glyphs 15.8 px low.
+#[test]
+fn box_text_first_baseline_is_the_d_height_as_after_effects() {
+    let boxed = ParagraphStyle { width: Some(600.0), ..Default::default() };
+    // The rule on a bundled face (works everywhere).
+    for (family, size) in [("Inter", 100.0f32), ("Noto Serif", 50.0)] {
+        let s = TextStyle { family: family.into(), ..st(size) };
+        let r = fonts::resolve(family, "Regular");
+        let f = fonts::face(r.face);
+        let d = crate::outline_units(r.face, f.glyph('d').unwrap()).unwrap();
+        let em = (kurbo::Shape::bounding_box(&*d).y1 as f32 / f.units_per_em() * 1000.0).round() / 1000.0;
+        let l = layout("Hxg", &s, &boxed);
+        assert!((l.lines[0].baseline - em * size).abs() < 1e-3, "{family}: {} vs {}", l.lines[0].baseline, em * size);
+        assert!(l.lines[0].baseline < l.lines[0].ascent, "{family}: below the full ascent");
+    }
+    // After Effects' numbers, where the real fonts are installed.
+    for (family, ae_normal) in [("Times New Roman", 69.5008f32), ("Arial", 71.5988)] {
+        let r = fonts::resolve(family, "Regular");
+        if fonts::face(r.face).info.family != family {
+            continue;
+        }
+        for (size, script, glyph_baseline) in
+            [(100.0, Script::Normal, ae_normal), (50.0, Script::Normal, ae_normal / 2.0), (100.0, Script::Super, ae_normal - 100.0 * SCRIPT_OFFSET)]
+        {
+            let s = TextStyle { family: family.into(), script, ..st(size) };
+            let l = layout("Hxg", &s, &boxed);
+            let drawn = l.glyphs[0].y;
+            assert!((drawn - glyph_baseline).abs() < 0.15, "{family} {size} {script:?}: {drawn} vs AE {glyph_baseline}");
+        }
+    }
+}
+
+/// CodeRabbit on #1875: a face whose `d` is very short (a symbol or icon font) would put the
+/// first baseline almost at the box top; below 0.3 of the ascent the font ascent is used.
+#[test]
+fn a_short_d_falls_back_to_the_font_ascent() {
+    // Latin faces: the `d` is about 0.7 em, the ascent about 0.9 em.
+    let near = |v: Option<f32>, want: f32| v.is_some_and(|v| (v - want).abs() < 1e-3);
+    assert!(near(plausible_first(0.7, 100.0, 90.0), 70.0));
+    // A `d` a tenth of the ascent: not a lowercase ascender.
+    assert_eq!(plausible_first(0.09, 100.0, 90.0), None);
+    assert_eq!(plausible_first(0.26, 100.0, 90.0), None);
+    assert!(near(plausible_first(0.28, 100.0, 90.0), 28.0));
+    // Broken values stay rejected; an unusable ascent does not reject a sane `d`.
+    for (em, px) in [(0.0, 100.0), (-0.5, 100.0), (f32::NAN, 100.0), (5.0, 100.0), (0.7, f32::INFINITY)] {
+        assert_eq!(plausible_first(em, px, 90.0), None, "{em} {px}");
+    }
+    assert!(near(plausible_first(0.7, 100.0, f32::NAN), 70.0));
+    // The bundled faces keep the `d` rule.
+    for family in ["Inter", "Noto Serif"] {
+        let r = fonts::resolve(family, "Regular");
+        assert!(first_ascent(r.face, 100.0).is_some(), "{family}");
+    }
+}
+
+/// After Effects 2026 (EXPORTER t6): with Justify All and the every-line composer, a box that
+/// the other justifications break into lines of 6, 6 and 1 words breaks 4 / 4 / 4, so the
+/// stretched last line is not a lone word; word positions then match AE to 1 px.
+#[test]
+fn justify_all_balances_the_lines_with_the_every_line_composer() {
+    let text = "one two three four five six seven eight nine ten eleven twelve";
+    let s = st(30.0);
+    let words = |l: &Layout| -> Vec<usize> { l.lines.iter().map(|ln| text[ln.range.clone()].split_whitespace().count()).collect() };
+    let p = |last: Align| ParagraphStyle { width: Some(450.0), align: Align::Justify, justify_last: last, every_line: true, ..Default::default() };
+    let left = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p(Align::Left)]);
+    let all = layout_rich_uncached(text, &[(0..text.len(), s)], &[p(Align::Justify)]);
+    let (wl, wa) = (words(&left), words(&all));
+    assert!(wl.last().copied().unwrap_or(0) < *wl.first().unwrap_or(&0), "{wl:?}");
+    let (lo, hi) = (wa.iter().min().copied().unwrap_or(0), wa.iter().max().copied().unwrap_or(0));
+    assert!(hi - lo <= 1, "Justify All balances the lines: {wa:?} (left-justified: {wl:?})");
+}
+
+/// After Effects 2026 (EXPORTER read-back t7): right-to-left point text with any justified
+/// code (justify last left / centre / right, justify all) sits flush right at its anchor, as
+/// right-aligned text does.
+#[test]
+fn rtl_point_text_with_a_justified_paragraph_is_flush_at_its_start() {
+    let text = "Right to left";
+    let s = st(30.0);
+    let at = |align: Align, last: Align| {
+        let p = ParagraphStyle { align, justify_last: last, rtl: Some(true), ..Default::default() };
+        let l = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p]);
+        (l.lines[0].x, l.lines[0].x + l.lines[0].width)
+    };
+    let right = at(Align::Right, Align::Left);
+    for last in [Align::Left, Align::Center, Align::Right, Align::Justify] {
+        let got = at(Align::Justify, last);
+        assert!((got.0 - right.0).abs() < 1e-3 && (got.1 - right.1).abs() < 1e-3, "{last:?}: {got:?} vs right-aligned {right:?}");
+    }
+}
+
+/// The same holds when the direction is unset and the text itself resolves right to left.
+#[test]
+fn detected_rtl_point_text_with_a_justified_paragraph_is_flush_at_its_start() {
+    let text = "\u{5d0}\u{5d1}\u{5d2} \u{5d3}\u{5d4}";
+    let s = st(30.0);
+    let at = |align: Align| {
+        let p = ParagraphStyle { align, justify_last: Align::Left, rtl: None, ..Default::default() };
+        let l = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p]);
+        (l.lines[0].x, l.lines[0].x + l.lines[0].width)
+    };
+    let (right, got) = (at(Align::Right), at(Align::Justify));
+    assert!((got.0 - right.0).abs() < 1e-3 && (got.1 - right.1).abs() < 1e-3, "{got:?} vs right-aligned {right:?}");
+}
+
+/// Indents follow the resolved direction too: detected right-to-left text puts its start
+/// indent on the right, as an explicit right-to-left paragraph does.
+#[test]
+fn detected_rtl_text_takes_its_indents_on_the_rtl_sides() {
+    let text = "\u{5d0}\u{5d1}\u{5d2} \u{5d3}\u{5d4}";
+    let s = st(30.0);
+    let at = |rtl: Option<bool>| {
+        let p = ParagraphStyle { align: Align::Justify, justify_last: Align::Left, indent_start: 20.0, rtl, ..Default::default() };
+        let l = layout_rich_uncached(text, &[(0..text.len(), s.clone())], &[p]);
+        (l.lines[0].x, l.lines[0].x + l.lines[0].width)
+    };
+    let (explicit, detected) = (at(Some(true)), at(None));
+    assert!((detected.0 - explicit.0).abs() < 1e-3 && (detected.1 - explicit.1).abs() < 1e-3, "{detected:?} vs {explicit:?}");
+}
+
+/// Only the first line's own runs decide whether box text starts at the font ascent: a
+/// vertical run further down leaves a horizontal first line on its `d`-height baseline.
+#[test]
+fn a_later_vertical_run_keeps_the_first_line_baseline() {
+    let text = "Top\nside";
+    let horiz = st(40.0);
+    let vert = TextStyle { vertical: true, ..horiz.clone() };
+    let p = ParagraphStyle { width: Some(400.0), ..Default::default() };
+    let plain = layout_rich_uncached(text, &[(0..text.len(), horiz.clone())], std::slice::from_ref(&p));
+    let mixed = layout_rich_uncached(text, &[(0..4, horiz), (4..text.len(), vert)], &[p]);
+    assert!((mixed.lines[0].baseline - plain.lines[0].baseline).abs() < 1e-3, "{} vs {}", mixed.lines[0].baseline, plain.lines[0].baseline);
+}
diff --git a/crates/text/src/lib.rs b/crates/text/src/lib.rs
index 35e7ecc06..8cc8e3264 100644
--- a/crates/text/src/lib.rs
+++ b/crates/text/src/lib.rs
@@ -659,7 +659,9 @@ mod tests {
         let doc = TextDoc { text: "ab cd".into(), size: 20.0, box_size: Some([200.0, 100.0]), box_pos: [-100.0, -50.0], ..Default::default() };
         let l = layout_doc(&doc);
         let (a, _) = l.caret(0);
-        assert!((a.x + 100.0).abs() < 1e-6 && (a.y + 50.0).abs() < 1.0, "{a:?}");
+        // The first baseline sits the `d` height below the box top (After Effects), so the
+        // caret, which spans the font's full ascent, starts a little above the box.
+        assert!((a.x + 100.0).abs() < 1e-6 && a.y + 50.0 < 0.0 && a.y + 50.0 > -0.35 * 20.0, "{a:?}");
         // Vertical: characters run down a column, carets are horizontal.
         let v = layout_doc(&TextDoc { text: "abc\nde".into(), size: 20.0, vertical: true, ..Default::default() });
         let ys: Vec<f64> = v.glyphs.iter().filter(|g| g.line_index == 0).map(|g| g.origin.y).collect();
diff --git a/crates/text/src/selectors.rs b/crates/text/src/selectors.rs
index e3a422460..fcecfd814 100644
--- a/crates/text/src/selectors.rs
+++ b/crates/text/src/selectors.rs
@@ -71,6 +71,15 @@ impl Mode {
     pub fn combine(self, acc: f64, v: f64) -> f64 {
         let r = match self {
             Mode::Add => acc + v,
+            // Subtracting more than is selected leaves nothing, not a negative selection (After
+            // Effects 2026: a Subtract selector over unselected characters leaves their
+            // Tracking at 0, EXPORTER read-back t8).
+            // Intended for every animator property, not only Tracking: selectors combine into one
+            // selection per character for the whole animator (`render::text::animator_selection`),
+            // which then scales each of its properties, as in After Effects, where selectors
+            // belong to the animator. The read-back observed that selection through Tracking;
+            // Opacity, Position and the rest were not measured separately.
+            Mode::Subtract if acc >= 0.0 => (acc - v).max(0.0),
             Mode::Subtract => acc - v,
             Mode::Intersect => acc * v,
             Mode::Min => acc.min(v),
@@ -352,6 +361,9 @@ mod tests {
         // A lone Subtract inverts.
         assert_eq!(Mode::Subtract.combine(Mode::Subtract.initial(), 1.0), 0.0);
         assert_eq!(Mode::Subtract.combine(Mode::Subtract.initial(), 0.0), 1.0);
+        // Subtracting from what is not selected leaves 0, not a negative selection (AE t8).
+        assert_eq!(Mode::Subtract.combine(0.0, 1.0), 0.0);
+        assert_eq!(Mode::Subtract.combine(0.25, 1.0), 0.0);
         assert_eq!(Mode::from_index(5), Mode::Difference);
     }
 
diff --git a/crates/time/src/lib.rs b/crates/time/src/lib.rs
index 7a64a82bb..9bc625d10 100644
--- a/crates/time/src/lib.rs
+++ b/crates/time/src/lib.rs
@@ -198,7 +198,9 @@ impl FrameRate {
                 return r;
             }
         }
-        FrameRate::new((fps * 1000.0).round() as i64, 1000)
+        let num = (fps * 1000.0).round() as i64;
+        // A tiny positive rate must not round to the invalid 0/1 rate.
+        FrameRate::new(if fps > 0.0 { num.max(1) } else { num }, 1000)
     }
 
     pub fn as_f64(self) -> f64 {
@@ -387,7 +389,11 @@ pub fn format_time(t: Tick, rate: FrameRate, drop_frame: bool, display: TimeDisp
             let rem = Tick(abs.rem_euclid(TICKS_PER_SECOND)).to_units_floor(sample_rate);
             format!("{sign}{:02}:{:02}:{:02}:{rem:05}", secs / 3600, (secs / 60) % 60, secs % 60)
         }
-        TimeDisplay::Seconds => format!("{:.3}", t.seconds()),
+        TimeDisplay::Seconds => {
+            let s = t.seconds();
+            // A value that rounds to zero must not print a sign ("-0.000").
+            format!("{:.3}", if (s * 1000.0).round() == 0.0 { 0.0 } else { s })
+        }
     }
 }
 
@@ -533,6 +539,21 @@ pub const SAMPLE_RATES: [i64; 6] = [32_000, 44_100, 48_000, 88_200, 96_000, 192_
 mod tests {
     use super::*;
 
+    #[test]
+    fn from_f64_tiny_positive_fps_is_nonzero() {
+        let r = FrameRate::from_f64(0.0001);
+        assert!(r.num > 0 && r.den > 0, "got {r:?}");
+    }
+
+    #[test]
+    fn seconds_display_has_no_negative_zero() {
+        for t in [Tick(-1), Tick(0), Tick(-100)] {
+            assert_eq!(format_time(t, FrameRate::FPS_30, false, TimeDisplay::Seconds, 48000), "0.000");
+        }
+        let one = Tick(-TICKS_PER_SECOND);
+        assert_eq!(format_time(one, FrameRate::FPS_30, false, TimeDisplay::Seconds, 48000), "-1.000");
+    }
+
     #[test]
     fn frame_rate_constructors_accept_extreme_numbers() {
         assert_eq!(FrameRate::new(i64::MIN, 1), FrameRate { num: i64::MIN, den: 1 });
diff --git a/crates/track/src/camtrack/mod.rs b/crates/track/src/camtrack.rs
similarity index 90%
rename from crates/track/src/camtrack/mod.rs
rename to crates/track/src/camtrack.rs
index e8cd28da8..ea4f89a3f 100644
--- a/crates/track/src/camtrack/mod.rs
+++ b/crates/track/src/camtrack.rs
@@ -67,8 +67,9 @@ pub struct Track2D {
 }
 
 impl Track2D {
+    /// Exclusive end frame, saturated when the track exceeds the frame index range.
     pub fn end(&self) -> u32 {
-        self.start + self.pts.len() as u32
+        u32::try_from(self.pts.len()).ok().and_then(|n| self.start.checked_add(n)).unwrap_or(u32::MAX)
     }
     /// Position on frame `k` when the track covers it.
     pub fn at(&self, k: u32) -> Option<[f64; 2]> {
@@ -483,3 +484,52 @@ pub fn point_color(id: u32) -> [f32; 3] {
     // Bright, slightly desaturated.
     [0.25 + 0.75 * r, 0.25 + 0.75 * g, 0.25 + 0.75 * b]
 }
+
+#[cfg(test)]
+mod validation_tests {
+    use super::*;
+
+    fn tracks() -> CameraTracks {
+        CameraTracks { size: [1920.0, 1080.0], factor: 1.0, frame_duration: 1.0 / 30.0, frames: 3, ..Default::default() }
+    }
+
+    #[test]
+    fn track_end_saturates_instead_of_wrapping() {
+        assert_eq!(Track2D { start: u32::MAX, pts: vec![[0.0; 2]], ..Default::default() }.end(), u32::MAX);
+        assert_eq!(Track2D { start: 3, pts: vec![[0.0; 2]; 2], ..Default::default() }.end(), 5);
+    }
+
+    #[test]
+    fn solve_rejects_large_frame_count_before_allocating() {
+        let t = CameraTracks { frames: u32::MAX, ..tracks() };
+        let error = solve(&t, &SolveSettings::default(), None).unwrap_err();
+        assert!(error.0.contains("frame or track count"));
+    }
+
+    #[test]
+    fn solve_rejects_overflowing_and_out_of_clip_tracks() {
+        for start in [u32::MAX, 2] {
+            let t = CameraTracks { tracks: vec![Track2D { start, pts: vec![[0.0; 2]; 3], ..Default::default() }], ..tracks() };
+            let error = solve(&t, &SolveSettings::default(), None).unwrap_err();
+            assert!(error.0.contains("frame range"));
+        }
+    }
+
+    #[test]
+    fn solve_rejects_non_finite_track_positions() {
+        let t = CameraTracks { tracks: vec![Track2D { pts: vec![[f32::NAN, 0.0]; 3], ..Default::default() }], ..tracks() };
+        let error = solve(&t, &SolveSettings::default(), None).unwrap_err();
+        assert!(error.0.contains("finite"));
+    }
+
+    #[test]
+    fn solve_rejects_invalid_dimensions_timing_and_scale() {
+        for t in [
+            CameraTracks { size: [f64::NAN, 1080.0], ..tracks() },
+            CameraTracks { frame_duration: 0.0, ..tracks() },
+            CameraTracks { factor: f64::INFINITY, ..tracks() },
+        ] {
+            assert!(solve(&t, &SolveSettings::default(), None).is_err());
+        }
+    }
+}
diff --git a/crates/track/src/camtrack/bundle.rs b/crates/track/src/camtrack/bundle.rs
index 077f04b71..a4412dbce 100644
--- a/crates/track/src/camtrack/bundle.rs
+++ b/crates/track/src/camtrack/bundle.rs
@@ -10,9 +10,9 @@
 
 use rayon::prelude::*;
 
-use super::Distortion;
 use super::geometry::Pose;
-use super::linalg::*;
+use super::linalg::{M3, V3, add, cholesky_solve, conjugate_gradient, dot, inv3, mm, mtv, mv, rodrigues, scale, skew, sub};
+use super::{Distortion, SolveError};
 
 /// A camera in the adjustment.
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -52,6 +52,7 @@ pub struct BaOpts {
     pub fixed: Vec<bool>,
     /// Huber threshold (pixels).
     pub huber: f64,
+    /// Maximum LM iterations (at most 1000).
     pub max_iter: usize,
     /// Adjust the shared radial distortion `(k1, k2)` too.
     pub distortion: bool,
@@ -76,21 +77,89 @@ fn huber(e2: f64, k: f64) -> f64 {
     if e2 <= k * k { e2 } else { 2.0 * k * e2.sqrt() - k * k }
 }
 
-/// Residual (pixels) of one observation, `None` behind the camera.
+// Bound the temporary systems before any input-sized allocation. Includes dense matrices
+// for the main system, trial copies and both Rayon phases, plus per-point/observation data.
+const MAX_BA_BYTES: usize = 256 * 1024 * 1024;
+const MAX_BA_CAMERAS: usize = 4096;
+const MAX_BA_POINTS: usize = 200_000;
+const MAX_BA_OBSERVATIONS: usize = 1_000_000;
+
+fn valid_camera(c: &BaCam) -> bool {
+    c.f.is_finite()
+        && c.f > 0.0
+        && c.pose.r.iter().flatten().chain(&c.pose.c).all(|v| v.is_finite())
+        && [c.dist.k1, c.dist.k2, c.dist.radius].iter().all(|v| v.is_finite())
+}
+
+fn validate(cams: &[BaCam], pts: &[V3], obs: &[BaObs], o: &BaOpts) -> Result<(), SolveError> {
+    if cams.len() > MAX_BA_CAMERAS || pts.len() > MAX_BA_POINTS || obs.len() > MAX_BA_OBSERVATIONS {
+        return Err(SolveError("bundle adjustment input exceeds the supported size".into()));
+    }
+    if !o.huber.is_finite() || o.huber <= 0.0 || o.max_iter > 1000 || matches!(o.focal, FocalMode::PerCamera(k) if !k.is_finite() || k < 0.0) {
+        return Err(SolveError("invalid bundle adjustment options".into()));
+    }
+    if cams.iter().any(|c| !valid_camera(c)) || pts.iter().flatten().any(|v| !v.is_finite()) {
+        return Err(SolveError("bundle adjustment cameras and points must be finite, with positive focal lengths".into()));
+    }
+    for ob in obs {
+        if cams.get(ob.cam as usize).is_none() || pts.get(ob.pt as usize).is_none() {
+            return Err(SolveError("bundle adjustment observation index is out of range".into()));
+        }
+        if ob.uv.iter().any(|v| !v.is_finite()) {
+            return Err(SolveError("bundle adjustment observations must be finite".into()));
+        }
+    }
+    Ok(())
+}
+
+fn matrix_len(n: usize, npts: usize, nobs: usize) -> Result<usize, SolveError> {
+    let threads = rayon::current_num_threads();
+    let build_workers = if n <= 700 && npts > 64 { threads.clamp(1, 16) } else { 0 };
+    let schur_workers = if n <= 1200 && npts >= 64 && threads > 1 { threads.clamp(1, 8) } else { 0 };
+    // The two worker phases do not coexist; allow the larger phase plus main/trial buffers.
+    let copies = 4 + build_workers.max(schur_workers);
+    let len = n.checked_mul(n);
+    let bytes = len
+        .and_then(|v| v.checked_add(n))
+        .and_then(|v| v.checked_mul(size_of::<f64>()))
+        .and_then(|v| v.checked_mul(copies))
+        .and_then(|v| npts.checked_mul(320).and_then(|p| v.checked_add(p)))
+        .and_then(|v| nobs.checked_mul(2 * 9 * size_of::<(usize, V3)>() + size_of::<BaObs>() + 2 * size_of::<u32>()).and_then(|p| v.checked_add(p)));
+    match (len, bytes) {
+        (Some(len), Some(bytes)) if bytes <= MAX_BA_BYTES => Ok(len),
+        _ => Err(SolveError("bundle adjustment exceeds its 256 MiB workspace budget; use fewer cameras or observations".into())),
+    }
+}
+
+/// Residual (pixels), or `None` for an invalid or behind-camera projection.
 pub fn residual(c: &BaCam, x: V3, uv: [f64; 2]) -> Option<[f64; 2]> {
+    if !valid_camera(c) || x.iter().chain(&uv).any(|v| !v.is_finite()) {
+        return None;
+    }
+    project_residual(c, x, uv)
+}
+
+fn project_residual(c: &BaCam, x: V3, uv: [f64; 2]) -> Option<[f64; 2]> {
     let p = c.pose.to_cam(x);
-    if p[2] <= 1e-9 {
+    if p[2] <= 1e-9 || p.iter().any(|v| !v.is_finite()) {
         return None;
     }
     let q = c.dist.distort([c.f * p[0] / p[2], c.f * p[1] / p[2]]);
-    Some([q[0] - uv[0], q[1] - uv[1]])
+    let r = [q[0] - uv[0], q[1] - uv[1]];
+    r.iter().all(|v| v.is_finite()).then_some(r)
 }
 
-/// Total robust cost.
-pub fn cost(cams: &[BaCam], pts: &[V3], obs: &[BaObs], o: &BaOpts) -> f64 {
+/// Total robust cost. Rejects invalid inputs before starting parallel evaluation.
+pub fn cost(cams: &[BaCam], pts: &[V3], obs: &[BaObs], o: &BaOpts) -> Result<f64, SolveError> {
+    validate(cams, pts, obs, o)?;
+    let c = validated_cost(cams, pts, obs, o);
+    if c.is_finite() { Ok(c) } else { Err(SolveError("bundle adjustment cost is not finite".into())) }
+}
+
+fn validated_cost(cams: &[BaCam], pts: &[V3], obs: &[BaObs], o: &BaOpts) -> f64 {
     let c: f64 = obs
         .par_iter()
-        .map(|ob| match residual(&cams[ob.cam as usize], pts[ob.pt as usize], ob.uv) {
+        .map(|ob| match cams.get(ob.cam as usize).zip(pts.get(ob.pt as usize)).and_then(|(c, x)| project_residual(c, *x, ob.uv)) {
             Some(r) => huber(r[0] * r[0] + r[1] * r[1], o.huber),
             None => BEHIND,
         })
@@ -147,8 +216,52 @@ fn layout(ncam: usize, o: &BaOpts) -> Layout {
     Layout { start, fidx, shared, dist, n, rot_only: o.fix_centers }
 }
 
+// Six pose parameters, one shared OR per-camera focal parameter, two distortion parameters.
+const MAX_CAMERA_JACOBIAN_ENTRIES: usize = 6 + 1 + 2;
+type CameraJacobianEntry = (usize, [f64; 2]);
+
+/// Keeps the current parameter set on the stack. Extra parameters spill rather than panic
+/// if a future extension grows beyond the inline capacity.
+struct CameraJacobian {
+    entries: [CameraJacobianEntry; MAX_CAMERA_JACOBIAN_ENTRIES],
+    len: usize,
+    overflow: Vec<CameraJacobianEntry>,
+}
+
+impl CameraJacobian {
+    fn new() -> Self {
+        Self { entries: [(0, [0.0; 2]); MAX_CAMERA_JACOBIAN_ENTRIES], len: 0, overflow: Vec::new() }
+    }
+
+    fn clear(&mut self) {
+        self.len = 0;
+        self.overflow.clear();
+    }
+
+    fn push(&mut self, entry: CameraJacobianEntry) {
+        if self.overflow.is_empty() {
+            if let Some(slot) = self.entries.get_mut(self.len) {
+                *slot = entry;
+                self.len += 1;
+                return;
+            }
+            self.overflow.extend_from_slice(&self.entries);
+        }
+        self.overflow.push(entry);
+    }
+
+    fn as_slice(&self) -> &[CameraJacobianEntry] {
+        if self.overflow.is_empty() {
+            // len only grows after a successful get_mut, so it cannot exceed capacity.
+            self.entries.get(..self.len).unwrap_or_default()
+        } else {
+            &self.overflow
+        }
+    }
+}
+
 /// Camera-side Jacobian entries of one observation: (parameter index, d r / d param).
-fn cam_jac(l: &Layout, ci: usize, c: &BaCam, xc: V3, a: &[[f64; 3]; 2], p: [f64; 2], out: &mut Vec<(usize, [f64; 2])>) {
+fn cam_jac(l: &Layout, ci: usize, c: &BaCam, xc: V3, a: &[[f64; 3]; 2], p: [f64; 2], out: &mut CameraJacobian) {
     out.clear();
     let s = l.start[ci];
     if s != usize::MAX {
@@ -174,16 +287,186 @@ fn cam_jac(l: &Layout, ci: usize, c: &BaCam, xc: V3, a: &[[f64; 3]; 2], p: [f64;
     }
 }
 
+struct PtSys {
+    v: M3,
+    bp: V3,
+    w: Vec<(usize, V3)>,
+}
+
+struct PreconditionerBlock {
+    start: usize,
+    dim: usize,
+    inverse: Vec<f64>,
+}
+
+fn camera_preconditioner(u: &[f64], l: &Layout) -> Option<Vec<PreconditionerBlock>> {
+    let mut ranges = Vec::new();
+    let pose_dim = if l.rot_only { 3 } else { 6 };
+    for (&pose, &focal) in l.start.iter().zip(&l.fidx) {
+        if pose != usize::MAX {
+            ranges.push((pose, pose_dim + usize::from(focal != usize::MAX)));
+        } else if focal != usize::MAX {
+            ranges.push((focal, 1));
+        }
+    }
+    if let Some(start) = l.shared.or(l.dist) {
+        ranges.push((start, l.n - start));
+    }
+    ranges
+        .into_iter()
+        .map(|(start, dim)| {
+            let mut matrix = Vec::with_capacity(dim * dim);
+            for i in 0..dim {
+                for j in 0..dim {
+                    matrix.push(*u.get((start + i) * l.n + start + j)?);
+                }
+            }
+            let mut inverse = vec![0.0; dim * dim];
+            for col in 0..dim {
+                let mut a = matrix.clone();
+                let mut b = vec![0.0; dim];
+                *b.get_mut(col)? = 1.0;
+                if !cholesky_solve(&mut a, dim, &mut b) {
+                    return None;
+                }
+                for (row, value) in b.into_iter().enumerate() {
+                    inverse[row * dim + col] = value;
+                }
+            }
+            Some(PreconditionerBlock { start, dim, inverse })
+        })
+        .collect()
+}
+
+/// Apply the point-eliminated system without materialising W V^-1 W^T.
+fn iterative_schur(u: &[f64], rhs: &[f64], systems: &[PtSys], vinv: &[Option<M3>], l: &Layout) -> Option<Vec<f64>> {
+    if l.n == 0 || l.n.checked_mul(l.n) != Some(u.len()) || rhs.len() != l.n || systems.len() != vinv.len() {
+        return None;
+    }
+    let blocks = camera_preconditioner(u, l)?;
+    // U contains camera blocks, global parameters and the focal prior. Store its nonzeros
+    // once; all subsequent products are linear in these and the point-camera connections.
+    let rows: Vec<Vec<(usize, f64)>> =
+        u.chunks_exact(l.n).map(|row| row.iter().enumerate().filter(|(_, v)| **v != 0.0).map(|(i, v)| (i, *v)).collect()).collect();
+    let mut reduced_rhs = rhs.to_vec();
+    for (ps, vi) in systems.iter().zip(vinv) {
+        let Some(vi) = vi else { continue };
+        let vb = mv(vi, ps.bp);
+        for (i, w) in &ps.w {
+            *reduced_rhs.get_mut(*i)? -= dot(*w, vb);
+        }
+    }
+    conjugate_gradient(
+        &reduced_rhs,
+        |x, y| {
+            for (i, row) in rows.iter().enumerate() {
+                y[i] = row.iter().map(|(j, v)| v * x[*j]).sum();
+            }
+            for (ps, vi) in systems.iter().zip(vinv) {
+                let Some(vi) = vi else { continue };
+                let q = ps.w.iter().fold([0.0; 3], |q, (i, w)| add(q, scale(*w, x[*i])));
+                let q = mv(vi, q);
+                for (i, w) in &ps.w {
+                    y[*i] -= dot(*w, q);
+                }
+            }
+        },
+        |r, z| {
+            z.fill(0.0);
+            for block in &blocks {
+                for i in 0..block.dim {
+                    z[block.start + i] = (0..block.dim).map(|j| block.inverse[i * block.dim + j] * r[block.start + j]).sum();
+                }
+            }
+        },
+    )
+}
+
+/// Smooth per-camera log focal lengths in the normal equations.
+fn add_focal_prior(cams: &[BaCam], o: &BaOpts, l: &Layout, s_mat: &mut [f64], bc: &mut [f64]) {
+    let n = l.n;
+    // Focal prior.
+    if let FocalMode::PerCamera(k) = o.focal {
+        for i in 0..cams.len().saturating_sub(1) {
+            let r = k * (cams[i].f.ln() - cams[i + 1].f.ln());
+            let (a, b) = (l.fidx[i], l.fidx[i + 1]);
+            let ia = (a != usize::MAX).then_some(a);
+            let ib = (b != usize::MAX).then_some(b);
+            for (idx, g) in [(ia, k), (ib, -k)] {
+                let Some(x) = idx else { continue };
+                bc[x] -= g * r;
+                for (idy, h) in [(ia, k), (ib, -k)] {
+                    if let Some(y) = idy {
+                        s_mat[x * n + y] += g * h;
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Eliminate the points into the camera system explicitly (`S -= W V^-1 W^T`, `rhs -= W V^-1 bp`).
+fn reduce_points(systems: &[PtSys], vinv: &[Option<M3>], n: usize, s: &mut [f64], rhs: &mut [f64]) {
+    let npts = systems.len();
+    let reduce = |range: std::ops::Range<usize>, s: &mut [f64], rhs: &mut [f64]| {
+        for j in range {
+            let (Some(vi), ps) = (&vinv[j], &systems[j]) else { continue };
+            let vb = mv(vi, ps.bp);
+            let wv: Vec<V3> = ps.w.iter().map(|(_, w)| mv(vi, *w)).collect();
+            for (a, (ia, wa)) in ps.w.iter().enumerate() {
+                rhs[*ia] -= dot(*wa, vb);
+                for (ib, wb) in &ps.w[a..] {
+                    let d = dot(wv[a], *wb);
+                    s[ia * n + ib] -= d;
+                    if ia != ib {
+                        s[ib * n + ia] -= d;
+                    }
+                }
+            }
+        }
+    };
+    let chunks = rayon::current_num_threads().clamp(1, 8);
+    if n <= 1200 && npts >= 64 && chunks > 1 {
+        let per = npts.div_ceil(chunks);
+        let parts: Vec<(Vec<f64>, Vec<f64>)> = (0..chunks)
+            .into_par_iter()
+            .map(|t| {
+                let (mut ds, mut dr) = (vec![0.0; n * n], vec![0.0; n]);
+                reduce(t * per..((t + 1) * per).min(npts), &mut ds, &mut dr);
+                (ds, dr)
+            })
+            .collect();
+        for (ds, dr) in parts {
+            s.par_iter_mut().zip(ds.par_iter()).for_each(|(x, y)| *x += y);
+            for (x, y) in rhs.iter_mut().zip(dr) {
+                *x += y;
+            }
+        }
+    } else {
+        reduce(0..npts, s, rhs);
+    }
+}
+
 /// Run Levenberg–Marquardt. `cams` and `pts` are updated in place.
-pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) -> BaReport {
+/// Invalid inputs or workspaces exceeding 256 MiB return an error before mutation.
+pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) -> Result<BaReport, SolveError> {
+    validate(cams, pts, obs, o)?;
+    adjust_impl(cams, pts, obs, o, true)
+}
+
+fn adjust_impl(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts, allow_iterative: bool) -> Result<BaReport, SolveError> {
     let l = layout(cams.len(), o);
+    let matrix_len = matrix_len(l.n, pts.len(), obs.len())?;
     let npts = pts.len();
     // Observations by point.
     let mut by_pt: Vec<Vec<u32>> = vec![vec![]; npts];
     for (i, ob) in obs.iter().enumerate() {
         by_pt[ob.pt as usize].push(i as u32);
     }
-    let mut cur = cost(cams, pts, obs, o);
+    let mut cur = validated_cost(cams, pts, obs, o);
+    if !cur.is_finite() {
+        return Err(SolveError("bundle adjustment cost is not finite".into()));
+    }
     let initial = cur;
     let t0 = web_time::Instant::now();
     let mut tries = 0usize;
@@ -191,7 +474,7 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
     let mut lambda = 1e-4;
     let mut iters = 0;
     if l.n == 0 && o.fix_points {
-        return BaReport { initial_cost: initial, cost: cur, iterations: 0 };
+        return Ok(BaReport { initial_cost: initial, cost: cur, iterations: 0 });
     }
     let n = l.n;
     let parallel = n <= 700;
@@ -199,14 +482,9 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
         iters += 1;
         // ---- Normal equations (Gauss–Newton with IRLS weights).
         // Per point: V (3×3), bp (3), W entries (cam-side index → 3).
-        struct PtSys {
-            v: [[f64; 3]; 3],
-            bp: V3,
-            w: Vec<(usize, V3)>,
-        }
         let build_point = |j: usize, s_acc: &mut Vec<f64>, bc: &mut Vec<f64>| -> PtSys {
             let mut ps = PtSys { v: [[0.0; 3]; 3], bp: [0.0; 3], w: vec![] };
-            let mut jc: Vec<(usize, [f64; 2])> = Vec::with_capacity(8);
+            let mut jc = CameraJacobian::new();
             for &oi in &by_pt[j] {
                 let ob = &obs[oi as usize];
                 let ci = ob.cam as usize;
@@ -231,6 +509,7 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
                     jc.push((g, [dk[0][0], dk[1][0]]));
                     jc.push((g + 1, [dk[0][1], dk[1][1]]));
                 }
+                let jc = jc.as_slice();
                 // Point Jacobian: A R.
                 let jx = if o.fix_points {
                     [[0.0; 3]; 2]
@@ -239,9 +518,9 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
                     let r1 = mtv(&c.pose.r, a[1]);
                     [r0, r1]
                 };
-                for (ia, ja) in &jc {
+                for (ia, ja) in jc.iter() {
                     bc[*ia] -= w * (ja[0] * r[0] + ja[1] * r[1]);
-                    for (ib, jb) in &jc {
+                    for (ib, jb) in jc.iter() {
                         s_acc[ia * n + ib] += w * (ja[0] * jb[0] + ja[1] * jb[1]);
                     }
                 }
@@ -252,7 +531,7 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
                             ps.v[a1][b1] += w * (jx[0][a1] * jx[0][b1] + jx[1][a1] * jx[1][b1]);
                         }
                     }
-                    for (ia, ja) in &jc {
+                    for (ia, ja) in jc.iter() {
                         let wv =
                             [w * (ja[0] * jx[0][0] + ja[1] * jx[1][0]), w * (ja[0] * jx[0][1] + ja[1] * jx[1][1]), w * (ja[0] * jx[0][2] + ja[1] * jx[1][2])];
                         // Each observation of a point is on another camera: only the shared focal
@@ -274,12 +553,12 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
             let parts: Vec<(Vec<f64>, Vec<f64>, Vec<PtSys>)> = (0..chunks)
                 .into_par_iter()
                 .map(|t| {
-                    let (mut s, mut b) = (vec![0.0; n * n], vec![0.0; n]);
+                    let (mut s, mut b) = (vec![0.0; matrix_len], vec![0.0; n]);
                     let v = (t * per..((t + 1) * per).min(npts)).map(|j| build_point(j, &mut s, &mut b)).collect();
                     (s, b, v)
                 })
                 .collect();
-            let mut s = vec![0.0; n * n];
+            let mut s = vec![0.0; matrix_len];
             let mut b = vec![0.0; n];
             let mut sys = Vec::with_capacity(npts);
             for (ps, pb, pv) in parts {
@@ -293,32 +572,19 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
             }
             (s, b, sys)
         } else {
-            let mut s = vec![0.0; n * n];
+            let mut s = vec![0.0; matrix_len];
             let mut b = vec![0.0; n];
             let sys = (0..npts).map(|j| build_point(j, &mut s, &mut b)).collect();
             (s, b, sys)
         };
-        // Focal prior.
-        if let FocalMode::PerCamera(k) = o.focal {
-            for i in 0..cams.len().saturating_sub(1) {
-                let r = k * (cams[i].f.ln() - cams[i + 1].f.ln());
-                let (a, b) = (l.fidx[i], l.fidx[i + 1]);
-                let ia = (a != usize::MAX).then_some(a);
-                let ib = (b != usize::MAX).then_some(b);
-                for (idx, g) in [(ia, k), (ib, -k)] {
-                    let Some(x) = idx else { continue };
-                    bc[x] -= g * r;
-                    for (idy, h) in [(ia, k), (ib, -k)] {
-                        if let Some(y) = idy {
-                            s_mat[x * n + y] += g * h;
-                        }
-                    }
-                }
-            }
-        }
+        add_focal_prior(cams, o, &l, &mut s_mat, &mut bc);
         let base_s = s_mat.clone();
         let base_bc = bc.clone();
         let mean_diag = ((0..n).map(|i| base_s[i * n + i]).sum::<f64>() / n.max(1) as f64).max(1e-12);
+        let schur_pairs = systems.iter().fold(0usize, |sum, ps| sum.saturating_add(ps.w.len().saturating_mul(ps.w.len().saturating_add(1)) / 2));
+        // Reserve the iterative solve for expensive long-track reductions; small systems
+        // retain the direct path and its rounding. Failed solves use the direct path too.
+        let mut use_iterative = allow_iterative && !o.fix_points && n >= 120 && schur_pairs > 4_000_000;
         // ---- Try steps with increasing damping.
         let mut accepted = false;
         for _try in 0..12 {
@@ -346,50 +612,26 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
                     })
                     .collect()
             };
-            if !o.fix_points {
-                let reduce = |range: std::ops::Range<usize>, s: &mut [f64], rhs: &mut [f64]| {
-                    for j in range {
-                        let (Some(vi), ps) = (&vinv[j], &systems[j]) else { continue };
-                        let vb = mv(vi, ps.bp);
-                        let wv: Vec<V3> = ps.w.iter().map(|(_, w)| mv(vi, *w)).collect();
-                        for (a, (ia, wa)) in ps.w.iter().enumerate() {
-                            rhs[*ia] -= dot(*wa, vb);
-                            for (ib, wb) in &ps.w[a..] {
-                                let d = dot(wv[a], *wb);
-                                s[ia * n + ib] -= d;
-                                if ia != ib {
-                                    s[ib * n + ia] -= d;
-                                }
-                            }
-                        }
-                    }
-                };
-                let chunks = rayon::current_num_threads().clamp(1, 8);
-                if n <= 1200 && npts >= 64 && chunks > 1 {
-                    let per = npts.div_ceil(chunks);
-                    let parts: Vec<(Vec<f64>, Vec<f64>)> = (0..chunks)
-                        .into_par_iter()
-                        .map(|t| {
-                            let (mut ds, mut dr) = (vec![0.0; n * n], vec![0.0; n]);
-                            reduce(t * per..((t + 1) * per).min(npts), &mut ds, &mut dr);
-                            (ds, dr)
-                        })
-                        .collect();
-                    for (ds, dr) in parts {
-                        s.par_iter_mut().zip(ds.par_iter()).for_each(|(x, y)| *x += y);
-                        for (x, y) in rhs.iter_mut().zip(dr) {
-                            *x += y;
-                        }
-                    }
-                } else {
-                    reduce(0..npts, &mut s, &mut rhs);
+            let iterative_step = if use_iterative { iterative_schur(&s, &rhs, &systems, &vinv, &l) } else { None };
+            if dbg && use_iterative {
+                eprintln!("ba iterative n={n} pairs={schur_pairs} solved={}", iterative_step.is_some());
+            }
+            if use_iterative && iterative_step.is_none() {
+                use_iterative = false;
+            }
+            let dc = if let Some(dc) = iterative_step {
+                dc
+            } else {
+                if !o.fix_points {
+                    reduce_points(&systems, &vinv, n, &mut s, &mut rhs);
                 }
-            }
-            let mut dc = rhs;
-            if n > 0 && !cholesky_solve(&mut s, n, &mut dc) {
-                lambda *= 10.0;
-                continue;
-            }
+                let mut dc = rhs;
+                if n > 0 && !cholesky_solve(&mut s, n, &mut dc) {
+                    lambda *= 10.0;
+                    continue;
+                }
+                dc
+            };
             // Apply.
             let mut nc: Vec<BaCam> = cams.to_vec();
             for (i, c) in nc.iter_mut().enumerate() {
@@ -424,7 +666,11 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
                     *x = add(*x, mv(vi, b));
                 });
             }
-            let c2 = cost(&nc, &np, obs, o);
+            if nc.iter().any(|c| !valid_camera(c)) || np.iter().flatten().any(|v| !v.is_finite()) {
+                lambda *= 4.0;
+                continue;
+            }
+            let c2 = validated_cost(&nc, &np, obs, o);
             if c2.is_finite() && c2 < cur {
                 cams.copy_from_slice(&nc);
                 pts.copy_from_slice(&np);
@@ -443,7 +689,7 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
                             t0.elapsed().as_secs_f64()
                         );
                     }
-                    return BaReport { initial_cost: initial, cost: cur, iterations: iters };
+                    return Ok(BaReport { initial_cost: initial, cost: cur, iterations: iters });
                 }
                 break;
             }
@@ -456,13 +702,208 @@ pub fn adjust(cams: &mut [BaCam], pts: &mut [V3], obs: &[BaObs], o: &BaOpts) ->
     if dbg {
         eprintln!("ba n={} pts={} obs={} iters={iters} tries={tries} {:.2}s cost {initial:.1} -> {cur:.1}", l.n, npts, obs.len(), t0.elapsed().as_secs_f64());
     }
-    BaReport { initial_cost: initial, cost: cur, iterations: iters }
+    Ok(BaReport { initial_cost: initial, cost: cur, iterations: iters })
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::camtrack::geometry::Rng;
+    use crate::camtrack::linalg::{I3, log_rot, mt, norm};
+
+    #[test]
+    fn long_track_adjustment_matches_direct_reprojections_and_outliers() {
+        rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap().install(|| {
+            for (focal, fix_centers, distortion) in
+                [(FocalMode::Fixed, false, false), (FocalMode::Shared, false, true), (FocalMode::PerCamera(30.0), false, true), (FocalMode::Shared, true, true)]
+            {
+                let mut rng = Rng(71);
+                let mut noise = || (rng.next_u64() % 100_000) as f64 / 100_000.0 - 0.5;
+                let truth: Vec<V3> = (0..320).map(|_| [noise() * 8.0, noise() * 5.0, 10.0 + noise() * 5.0]).collect();
+                let true_cams: Vec<_> = (0..60)
+                    .map(|i| BaCam {
+                        pose: Pose {
+                            r: rodrigues([0.001 * i as f64, -0.003 * i as f64, 0.0]),
+                            c: if fix_centers { [0.0; 3] } else { [0.03 * i as f64, 0.01 * (i as f64).sin(), 0.0] },
+                        },
+                        f: if matches!(focal, FocalMode::PerCamera(_)) { 900.0 * (1.0 + 0.05 * (i as f64 * 0.07).sin()) } else { 900.0 },
+                        dist: if distortion { Distortion { k1: 0.015, k2: -0.005, radius: 1100.0 } } else { Distortion::NONE },
+                    })
+                    .collect();
+                let mut obs = Vec::new();
+                for (ci, c) in true_cams.iter().enumerate() {
+                    for (pi, p) in truth.iter().enumerate() {
+                        let mut uv = residual(c, *p, [0.0; 2]).unwrap();
+                        uv[0] += noise() * 0.05;
+                        uv[1] += noise() * 0.05;
+                        if (ci * truth.len() + pi).is_multiple_of(37) {
+                            uv[0] += 25.0;
+                            uv[1] -= 30.0;
+                        }
+                        obs.push(BaObs { cam: ci as u32, pt: pi as u32, uv });
+                    }
+                }
+                let mut cams = true_cams.clone();
+                for c in cams.iter_mut().skip(2) {
+                    c.pose.r = mm(&rodrigues([0.001, -0.001, 0.0005]), &c.pose.r);
+                    if !fix_centers {
+                        c.pose.c = add(c.pose.c, [0.002, -0.003, 0.001]);
+                    }
+                }
+                let mut pts: Vec<_> = truth.iter().map(|p| add(*p, [0.01, -0.01, 0.005])).collect();
+                let (mut direct_cams, mut direct_pts) = (cams.clone(), pts.clone());
+                let opts = BaOpts { focal, fix_centers, distortion, fixed: (0..60).map(|i| i < 2).collect(), max_iter: 10, ..Default::default() };
+                let report = adjust(&mut cams, &mut pts, &obs, &opts).unwrap();
+                let direct = adjust_impl(&mut direct_cams, &mut direct_pts, &obs, &opts, false).unwrap();
+                assert!((report.cost - direct.cost).abs() < 1e-5 * direct.cost.max(1.0));
+                for ob in &obs {
+                    let a = residual(&cams[ob.cam as usize], pts[ob.pt as usize], ob.uv).unwrap();
+                    let b = residual(&direct_cams[ob.cam as usize], direct_pts[ob.pt as usize], ob.uv).unwrap();
+                    assert!((a[0] - b[0]).hypot(a[1] - b[1]) < 0.001);
+                    assert_eq!(a[0].hypot(a[1]) <= 4.0, b[0].hypot(b[1]) <= 4.0);
+                }
+                for (a, b) in cams.iter().zip(direct_cams) {
+                    assert!(norm(sub(a.pose.c, b.pose.c)) < 0.001);
+                    assert!(norm(log_rot(&mm(&a.pose.r, &mt(&b.pose.r)))) < 1e-4);
+                    assert!((a.f - b.f).abs() < 1e-4 * b.f);
+                    assert!((a.dist.k1 - b.dist.k1).abs() < 1e-4 && (a.dist.k2 - b.dist.k2).abs() < 1e-4);
+                }
+            }
+        });
+    }
+
+    #[test]
+    fn matrix_free_schur_matches_explicit_system_and_rejects_bad_preconditioner() {
+        let l = layout(20, &BaOpts::default());
+        let n = l.n;
+        let mut u = vec![0.0; n * n];
+        for i in 0..n {
+            u[i * n + i] = 10.0;
+        }
+        let systems: Vec<_> = (0..80)
+            .map(|j| PtSys {
+                v: I3,
+                bp: [0.01, -0.02, 0.03],
+                w: (0..n).map(|i| (i, [((j * 13 + i * 7) % 19) as f64 * 0.001 - 0.009, (i % 7) as f64 * 0.001, (j % 11) as f64 * 0.001])).collect(),
+            })
+            .collect();
+        let vinv = vec![Some(I3); systems.len()];
+        let rhs: Vec<_> = (0..n).map(|i| (i % 7) as f64 - 3.0).collect();
+        let x = iterative_schur(&u, &rhs, &systems, &vinv, &l).unwrap();
+        let mut explicit = u.clone();
+        let mut reduced_rhs = rhs.clone();
+        for ps in &systems {
+            for (i, a) in &ps.w {
+                reduced_rhs[*i] -= dot(*a, ps.bp);
+                for (j, b) in &ps.w {
+                    explicit[i * n + j] -= dot(*a, *b);
+                }
+            }
+        }
+        let mut direct = reduced_rhs.clone();
+        let mut factor = explicit.clone();
+        assert!(cholesky_solve(&mut factor, n, &mut direct));
+        for (a, b) in x.iter().zip(direct) {
+            assert!((a - b).abs() < 1e-9);
+        }
+        let mut error2 = 0.0;
+        for (i, row) in explicit.chunks_exact(n).enumerate() {
+            let ax: f64 = row.iter().zip(&x).map(|(a, x)| a * x).sum();
+            error2 += (ax - reduced_rhs[i]).powi(2);
+        }
+        assert!(error2 < 1e-18 * reduced_rhs.iter().map(|v| v * v).sum::<f64>());
+        u[0] = -1.0;
+        assert!(iterative_schur(&u, &rhs, &systems, &vinv, &l).is_none());
+    }
+
+    fn test_camera() -> BaCam {
+        BaCam { pose: Pose::IDENTITY, f: 900.0, dist: Distortion::NONE }
+    }
+
+    #[test]
+    fn cost_rejects_invalid_observation_indices() {
+        for (cam, pt) in [(1, 0), (0, 1)] {
+            let obs = [BaObs { cam, pt, uv: [0.0; 2] }];
+            assert!(cost(&[test_camera()], &[[0.0, 0.0, 5.0]], &obs, &BaOpts::default()).is_err());
+        }
+    }
+
+    #[test]
+    fn adjust_rejects_invalid_observation_without_mutating_inputs() {
+        for (cam, pt) in [(1, 0), (0, 1)] {
+            let mut cams = [test_camera()];
+            let mut pts = [[0.0, 0.0, 5.0]];
+            let before = (cams, pts);
+            let obs = [BaObs { cam, pt, uv: [0.0; 2] }];
+            assert!(adjust(&mut cams, &mut pts, &obs, &BaOpts::default()).is_err());
+            assert_eq!((cams, pts), before);
+        }
+    }
+
+    #[test]
+    fn residual_rejects_non_finite_inputs_and_projection_overflow() {
+        let cam = test_camera();
+        assert!(residual(&cam, [0.0, 0.0, f64::NAN], [0.0; 2]).is_none());
+        assert!(residual(&cam, [0.0, 0.0, 5.0], [f64::INFINITY, 0.0]).is_none());
+        for bad in [
+            BaCam { f: f64::NAN, ..cam },
+            BaCam { dist: Distortion { k1: f64::INFINITY, ..Distortion::NONE }, ..cam },
+            BaCam { pose: Pose { c: [f64::NAN; 3], ..Pose::IDENTITY }, ..cam },
+            BaCam { pose: Pose { r: [[f64::INFINITY; 3]; 3], ..Pose::IDENTITY }, ..cam },
+        ] {
+            assert!(residual(&bad, [0.0, 0.0, 5.0], [0.0; 2]).is_none());
+        }
+        assert!(residual(&cam, [f64::MAX, 0.0, 1.0], [0.0; 2]).is_none());
+    }
+
+    #[test]
+    fn adjustment_rejects_non_finite_points_observations_and_options() {
+        let cam = test_camera();
+        let pts = [[0.0, 0.0, 5.0]];
+        let obs = [BaObs { cam: 0, pt: 0, uv: [0.0; 2] }];
+        assert!(cost(&[cam], &[[f64::NAN, 0.0, 5.0]], &obs, &BaOpts::default()).is_err());
+        assert!(cost(&[cam], &pts, &[BaObs { uv: [f64::NAN; 2], ..obs[0] }], &BaOpts::default()).is_err());
+        for opts in [
+            BaOpts { huber: f64::NAN, ..Default::default() },
+            BaOpts { huber: 0.0, ..Default::default() },
+            BaOpts { focal: FocalMode::PerCamera(f64::INFINITY), ..Default::default() },
+            BaOpts { max_iter: usize::MAX, ..Default::default() },
+        ] {
+            let mut trial_pts = pts;
+            assert!(adjust(&mut [cam], &mut trial_pts, &obs, &opts).is_err());
+        }
+    }
+
+    #[test]
+    fn matrix_workspace_is_checked_and_bounded_before_allocation() {
+        assert!(matrix_len(usize::MAX, 0, 0).is_err());
+        assert!(matrix_len(1, usize::MAX, 0).is_err());
+        assert!(matrix_len(1, 0, usize::MAX).is_err());
+        let mut cams = vec![test_camera(); 1000];
+        assert!(adjust(&mut cams, &mut [], &[], &BaOpts::default()).is_err());
+        assert!(matrix_len(6, 1000, 1000).is_ok());
+        assert!(matrix_len(955, 900, 160 * 900).is_ok());
+    }
+
+    #[test]
+    fn camera_jacobian_keeps_extra_parameters_and_resets() {
+        let mut jac = CameraJacobian::new();
+        let count = MAX_CAMERA_JACOBIAN_ENTRIES + 3;
+        for i in 0..count {
+            jac.push((i, [i as f64, -(i as f64)]));
+        }
+        assert_eq!(jac.as_slice().iter().count(), count);
+        for (i, entry) in jac.as_slice().iter().enumerate() {
+            assert_eq!(*entry, (i, [i as f64, -(i as f64)]));
+        }
+        jac.clear();
+        assert_eq!(jac.as_slice().iter().count(), 0);
+        for i in 0..MAX_CAMERA_JACOBIAN_ENTRIES {
+            jac.push((i, [1.0, 2.0]));
+        }
+        assert_eq!(jac.as_slice().iter().count(), MAX_CAMERA_JACOBIAN_ENTRIES);
+        assert!(jac.overflow.is_empty());
+    }
 
     #[test]
     fn bundle_adjustment_converges_from_noise() {
@@ -493,7 +934,7 @@ mod tests {
         let mut fixed = vec![false; 6];
         fixed[0] = true;
         fixed[1] = true;
-        let rep = adjust(&mut cams, &mut pts, &obs, &BaOpts { fixed, max_iter: 50, ..Default::default() });
+        let rep = adjust(&mut cams, &mut pts, &obs, &BaOpts { fixed, max_iter: 50, ..Default::default() }).unwrap();
         let rms = (rep.cost / obs.len() as f64).sqrt();
         assert!(rms < 1e-4, "{rep:?}");
     }
diff --git a/crates/track/src/camtrack/features.rs b/crates/track/src/camtrack/features.rs
index 1775a304f..246febda4 100644
--- a/crates/track/src/camtrack/features.rs
+++ b/crates/track/src/camtrack/features.rs
@@ -61,15 +61,24 @@ impl TrackAnalyzer {
 
     /// Analyse the next frame.
     pub fn push(&mut self, frame: &Frame) {
-        let (max_side, want) = self.params();
+        let (max_side, _) = self.params();
         let factor = analysis_factor(frame.img.width, frame.img.height, max_side);
-        self.factor = factor as f64;
         let pyr = GrayPyramid::from_image(frame.img, frame.offset, factor, 4);
+        let prev = self.prev.take();
+        self.push_pyramid(prev.as_ref(), &pyr);
+        self.prev = Some(pyr);
+    }
+
+    /// Track using caller-owned consecutive pyramids. The caller retains the full pyramid
+    /// for the next frame; standalone camera analysis uses the same path through `push`.
+    pub(crate) fn push_pyramid(&mut self, prev: Option<&GrayPyramid>, pyr: &GrayPyramid) {
+        let (_, want) = self.params();
+        self.factor = pyr.factor;
         let k = self.frame;
-        match &self.prev {
+        match prev {
             Some(prev) if prev.width() == pyr.width() && prev.height() == pyr.height() && prev.offset == pyr.offset => {
                 let pts: Vec<[f64; 2]> = self.active.iter().map(|a| a.1).collect();
-                let q = track(prev, &pyr, &pts, None, &LkOpts { radius: 6, iterations: 30, epsilon: 0.005, fb_max: 0.5, ..Default::default() });
+                let q = track(prev, pyr, &pts, None, &LkOpts { radius: 6, iterations: 30, epsilon: 0.005, fb_max: 0.5, ..Default::default() });
                 let mut next = Vec::with_capacity(self.active.len());
                 for ((ti, _), q) in self.active.iter().zip(q) {
                     if let Some(q) = q {
@@ -101,14 +110,13 @@ impl TrackAnalyzer {
                 !occ.get(cy * gw + cx).copied().unwrap_or(true)
             };
             let opts = CornerOpts { max_features: want - self.active.len().min(want), min_distance: md, quality: 0.001, window: 2, border: 8 };
-            for p in good_features(&pyr, &opts, Some(&free)) {
+            for p in good_features(pyr, &opts, Some(&free)) {
                 let l = pyr.to_layer(p);
                 let id = self.tracks.len() as u32;
                 self.tracks.push(Track2D { id, start: k, pts: vec![[l[0] as f32, l[1] as f32]] });
                 self.active.push((id as usize, p));
             }
         }
-        self.prev = Some(pyr);
         self.frame += 1;
     }
 
diff --git a/crates/track/src/camtrack/geometry.rs b/crates/track/src/camtrack/geometry.rs
index 6956ac2b5..3ce32a397 100644
--- a/crates/track/src/camtrack/geometry.rs
+++ b/crates/track/src/camtrack/geometry.rs
@@ -5,7 +5,10 @@
 //! All image points here are **normalised** (calibrated) coordinates `x = (u − c) / f`.
 //! A camera is `(R, C)` with `X_cam = R (X − C)`.
 
-use super::linalg::*;
+use super::linalg::{
+    I3, M3, V3, add, col, cross, det3, dot, from_cols, madd, mm, mscale, mt, mtv, mv, nearest_rotation, normalize, null_vector, outer, scale, sub, svd3,
+    sym_eigen,
+};
 
 /// A deterministic xorshift generator for RANSAC samples.
 pub struct Rng(pub u64);
@@ -204,8 +207,8 @@ pub fn triangulate(views: &[(Pose, [f64; 2])]) -> Option<V3> {
     for (p, x) in views {
         let t = p.t();
         let rows = [[p.r[0][0], p.r[0][1], p.r[0][2], t[0]], [p.r[1][0], p.r[1][1], p.r[1][2], t[1]], [p.r[2][0], p.r[2][1], p.r[2][2], t[2]]];
-        let a0: Vec<f64> = (0..4).map(|j| x[0] * rows[2][j] - rows[0][j]).collect();
-        let a1: Vec<f64> = (0..4).map(|j| x[1] * rows[2][j] - rows[1][j]).collect();
+        let a0 = [0, 1, 2, 3].map(|j| x[0] * rows[2][j] - rows[0][j]);
+        let a1 = [0, 1, 2, 3].map(|j| x[1] * rows[2][j] - rows[1][j]);
         for a in [a0, a1] {
             let nrm = a.iter().map(|v| v * v).sum::<f64>().sqrt().max(1e-300);
             for i in 0..4 {
@@ -244,6 +247,9 @@ pub fn reproj2(pose: &Pose, x: V3, o: [f64; 2]) -> Option<f64> {
 /// Pick the essential decomposition with the most points in front of both cameras; returns
 /// the second camera (the first is the identity) and that count.
 pub fn select_pose(cands: &[(M3, V3)], x1: &[[f64; 2]], x2: &[[f64; 2]]) -> Option<(Pose, usize)> {
+    if x1.len() != x2.len() || x1.is_empty() || x1.iter().chain(x2).flatten().any(|v| !v.is_finite()) {
+        return None;
+    }
     let mut best: Option<(Pose, usize)> = None;
     for (r, t) in cands {
         let p2 = Pose::from_rt(*r, *t);
@@ -361,6 +367,7 @@ pub fn procrustes(a: &[V3], b: &[V3]) -> Option<M3> {
 
 #[cfg(test)]
 mod tests {
+    use super::super::linalg::{log_rot, norm, rodrigues};
     use super::*;
 
     fn scene() -> (Vec<V3>, Pose) {
@@ -380,6 +387,14 @@ mod tests {
         [c[0] / c[2], c[1] / c[2]]
     }
 
+    #[test]
+    fn pose_selection_rejects_mismatched_or_non_finite_correspondences() {
+        let candidates = [(I3, [0.1, 0.0, 0.0])];
+        assert!(select_pose(&candidates, &[[0.0; 2]], &[]).is_none());
+        assert!(select_pose(&candidates, &[], &[[0.0; 2]]).is_none());
+        assert!(select_pose(&candidates, &[[f64::NAN, 0.0]], &[[0.0; 2]]).is_none());
+    }
+
     #[test]
     fn essential_recovers_relative_pose() {
         let (pts, p2) = scene();
diff --git a/crates/track/src/camtrack/linalg.rs b/crates/track/src/camtrack/linalg.rs
index 2efc14556..71e88e109 100644
--- a/crates/track/src/camtrack/linalg.rs
+++ b/crates/track/src/camtrack/linalg.rs
@@ -145,6 +145,33 @@ pub fn slerp(a: &M3, b: &M3, t: f64) -> M3 {
 /// `max(m, n) × n` (rows beyond `m` belong to zero padding), `s` is sorted descending and `V`
 /// is `n × n` (columns are the right singular vectors).
 pub fn svd(a: &[f64], m: usize, n: usize) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
+    let rows = m.max(n);
+    let (mut u, mut s, v) = jacobi_factors(a, m, n);
+    for (j, sj) in s.iter().enumerate() {
+        if *sj > 1e-300 {
+            for r in 0..rows {
+                u[r * n + j] /= sj;
+            }
+        }
+    }
+    // Sort descending.
+    let mut order: Vec<usize> = (0..n).collect();
+    order.sort_by(|&a, &b| s[b].total_cmp(&s[a]));
+    let (mut u2, mut v2) = (vec![0.0; rows * n], vec![0.0; n * n]);
+    for (k, &j) in order.iter().enumerate() {
+        for r in 0..rows {
+            u2[r * n + k] = u[r * n + j];
+        }
+        for r in 0..n {
+            v2[r * n + k] = v[r * n + j];
+        }
+    }
+    s = order.iter().map(|&j| s[j]).collect();
+    (u2, s, v2)
+}
+
+// Unnormalised and unsorted factors; full SVD and null-space queries share every sweep.
+fn jacobi_factors(a: &[f64], m: usize, n: usize) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
     let rows = m.max(n);
     let mut u = vec![0.0; rows * n];
     u[..m * n].copy_from_slice(&a[..m * n]);
@@ -192,28 +219,8 @@ pub fn svd(a: &[f64], m: usize, n: usize) -> (Vec<f64>, Vec<f64>, Vec<f64>) {
             break;
         }
     }
-    let mut s: Vec<f64> = (0..n).map(|j| (0..rows).map(|r| u[r * n + j] * u[r * n + j]).sum::<f64>().sqrt()).collect();
-    for (j, sj) in s.iter().enumerate() {
-        if *sj > 1e-300 {
-            for r in 0..rows {
-                u[r * n + j] /= sj;
-            }
-        }
-    }
-    // Sort descending.
-    let mut order: Vec<usize> = (0..n).collect();
-    order.sort_by(|&a, &b| s[b].total_cmp(&s[a]));
-    let (mut u2, mut v2) = (vec![0.0; rows * n], vec![0.0; n * n]);
-    for (k, &j) in order.iter().enumerate() {
-        for r in 0..rows {
-            u2[r * n + k] = u[r * n + j];
-        }
-        for r in 0..n {
-            v2[r * n + k] = v[r * n + j];
-        }
-    }
-    s = order.iter().map(|&j| s[j]).collect();
-    (u2, s, v2)
+    let s: Vec<f64> = (0..n).map(|j| (0..rows).map(|r| u[r * n + j] * u[r * n + j]).sum::<f64>().sqrt()).collect();
+    (u, s, v)
 }
 
 /// SVD of a 3 × 3 matrix: (U, singular values descending, V) with `m = U diag(s) Vᵀ`.
@@ -235,8 +242,10 @@ pub fn svd3(m: &M3) -> (M3, V3, M3) {
 /// The unit vector `x` minimising `|A x|` (`m × n` row-major): the right singular vector of
 /// the smallest singular value.
 pub fn null_vector(a: &[f64], m: usize, n: usize) -> Vec<f64> {
-    let (_, _, v) = svd(a, m, n);
-    (0..n).map(|r| v[r * n + n - 1]).collect()
+    let (_, s, v) = jacobi_factors(a, m, n);
+    // The full SVD uses a stable descending sort: the last of equal minima wins.
+    let smallest = (0..n).min_by(|&i, &j| s[i].total_cmp(&s[j]).then_with(|| j.cmp(&i))).unwrap_or(0);
+    (0..n).map(|r| v[r * n + smallest]).collect()
 }
 
 /// Eigen-decomposition of a symmetric `n × n` matrix (cyclic Jacobi): eigenvalues ascending
@@ -317,9 +326,29 @@ fn dot_n(a: &[f64], b: &[f64]) -> f64 {
 /// Solve `A x = b` for a symmetric positive definite `A` (`n × n`, row-major) in place by
 /// Cholesky factorisation. Returns false when `A` is not positive definite.
 pub fn cholesky_solve(a: &mut [f64], n: usize, b: &mut [f64]) -> bool {
+    if n.checked_mul(n) != Some(a.len()) || b.len() != n {
+        return false;
+    }
+    let mut band = n.saturating_sub(1);
+    if b.iter().all(|v| v.is_finite()) {
+        band = 0;
+        'bandwidth: for i in (0..n).rev() {
+            for j in 0..i.saturating_sub(band) {
+                if a[i * n + j] != 0.0 {
+                    band = i - j;
+                    // Wide systems (including shared global parameters) use the dense path.
+                    if band >= n / 2 {
+                        band = n.saturating_sub(1);
+                        break 'bandwidth;
+                    }
+                    break;
+                }
+            }
+        }
+    }
     for j in 0..n {
         let mut d = a[j * n + j];
-        for k in 0..j {
+        for k in j.saturating_sub(band)..j {
             d -= a[j * n + k] * a[j * n + k];
         }
         if d <= 0.0 || !d.is_finite() {
@@ -330,14 +359,24 @@ pub fn cholesky_solve(a: &mut [f64], n: usize, b: &mut [f64]) -> bool {
         let (head, tail) = a.split_at_mut((j + 1) * n);
         let rowj = &head[j * n..j * n + j];
         // Rows below j (sequential: per-column parallel dispatch costs more than it saves).
-        for row in tail.chunks_mut(n) {
-            row[j] = (row[j] - dot_n(&row[..j], rowj)) / d;
+        for (off, row) in tail.chunks_mut(n).take(band).enumerate() {
+            // Removing full groups of four zero products preserves dot_n's lane order.
+            let start = (j + 1 + off).saturating_sub(band) / 4 * 4;
+            row[j] = (row[j] - dot_n(&row[start..j], &rowj[start..])) / d;
         }
     }
     // Forward: L y = b.
     for i in 0..n {
         let mut s = b[i];
-        for k in 0..i {
+        let start = i.saturating_sub(band);
+        // Subtracting signed-zero products can change -0.0 to +0.0. Preserve those
+        // operations when the accumulator is zero; nonzero values are unaffected.
+        if s == 0.0 {
+            for k in 0..start {
+                s -= a[i * n + k] * b[k];
+            }
+        }
+        for k in start..i {
             s -= a[i * n + k] * b[k];
         }
         b[i] = s / a[i * n + i];
@@ -345,14 +384,74 @@ pub fn cholesky_solve(a: &mut [f64], n: usize, b: &mut [f64]) -> bool {
     // Back: Lᵀ x = y.
     for i in (0..n).rev() {
         let mut s = b[i];
-        for k in i + 1..n {
+        let end = i.saturating_add(band).saturating_add(1).min(n);
+        for k in i + 1..end {
             s -= a[k * n + i] * b[k];
         }
+        if s == 0.0 {
+            for k in end..n {
+                s -= a[k * n + i] * b[k];
+            }
+        }
         b[i] = s / a[i * n + i];
     }
     b.iter().all(|v| v.is_finite())
 }
 
+/// Preconditioned conjugate gradients with an independently recomputed residual check.
+/// Failure to converge (or non-finite/non-positive curvature) requests the direct fallback.
+pub(crate) fn conjugate_gradient(rhs: &[f64], apply: impl Fn(&[f64], &mut [f64]), precondition: impl Fn(&[f64], &mut [f64])) -> Option<Vec<f64>> {
+    let n = rhs.len();
+    let norm2 = dot_n(rhs, rhs);
+    if !norm2.is_finite() {
+        return None;
+    }
+    if rhs.iter().all(|v| *v == 0.0) {
+        return Some(vec![0.0; n]);
+    }
+    let tolerance2 = norm2 * 1e-22;
+    if tolerance2 == 0.0 {
+        return None;
+    }
+    let mut x = vec![0.0; n];
+    let mut r = rhs.to_vec();
+    let mut z = vec![0.0; n];
+    let mut ap = vec![0.0; n];
+    precondition(&r, &mut z);
+    let mut p = z.clone();
+    let mut rz = dot_n(&r, &z);
+    for _ in 0..n.saturating_mul(2).min(512) {
+        if !rz.is_finite() || rz <= 0.0 {
+            return None;
+        }
+        apply(&p, &mut ap);
+        let curvature = dot_n(&p, &ap);
+        if !curvature.is_finite() || curvature <= 0.0 {
+            return None;
+        }
+        let alpha = rz / curvature;
+        for i in 0..n {
+            x[i] += alpha * p[i];
+            r[i] -= alpha * ap[i];
+        }
+        if dot_n(&r, &r) <= tolerance2 {
+            apply(&x, &mut ap);
+            for i in 0..n {
+                ap[i] = rhs[i] - ap[i];
+            }
+            return (x.iter().all(|v| v.is_finite()) && dot_n(&ap, &ap) <= 100.0 * tolerance2).then_some(x);
+        }
+        precondition(&r, &mut z);
+        let next_rz = dot_n(&r, &z);
+        let beta = next_rz / rz;
+        for i in 0..n {
+            p[i] = z[i] + beta * p[i];
+        }
+        rz = next_rz;
+    }
+    None
+}
+
 /// A similarity transform `x ↦ s R x + t`.
 #[derive(Clone, Copy, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct Similarity {
@@ -428,6 +527,143 @@ pub fn from_euler_xyz(e: V3) -> M3 {
 mod tests {
     use super::*;
 
+    fn dense_cholesky_reference(a: &mut [f64], n: usize, b: &mut [f64]) -> bool {
+        for j in 0..n {
+            let mut d = a[j * n + j];
+            for k in 0..j {
+                d -= a[j * n + k] * a[j * n + k];
+            }
+            if d <= 0.0 || !d.is_finite() {
+                return false;
+            }
+            let d = d.sqrt();
+            a[j * n + j] = d;
+            let (head, tail) = a.split_at_mut((j + 1) * n);
+            let rowj = &head[j * n..j * n + j];
+            // Rows below j (sequential: per-column parallel dispatch costs more than it saves).
+            for row in tail.chunks_mut(n) {
+                row[j] = (row[j] - dot_n(&row[..j], rowj)) / d;
+            }
+        }
+        // Forward: L y = b.
+        for i in 0..n {
+            let mut s = b[i];
+            for k in 0..i {
+                s -= a[i * n + k] * b[k];
+            }
+            b[i] = s / a[i * n + i];
+        }
+        // Back: Lᵀ x = y.
+        for i in (0..n).rev() {
+            let mut s = b[i];
+            for k in i + 1..n {
+                s -= a[k * n + i] * b[k];
+            }
+            b[i] = s / a[i * n + i];
+        }
+        b.iter().all(|v| v.is_finite())
+    }
+
+    #[test]
+    fn banded_cholesky_is_bit_identical_to_dense() {
+        for n in [1usize, 2, 3, 4, 5, 6, 7, 8, 13, 31, 65, 127] {
+            for width in [0usize, 1, 2, 5, 11, n - 1] {
+                for seed in 0..3 {
+                    for scale in [1.0, 1e-100, 1e100] {
+                        let mut a = vec![0.0; n * n];
+                        for i in 0..n {
+                            for j in 0..i {
+                                let value = if i - j <= width {
+                                    (((i * 13 + j * 17 + seed) % 23) as f64 - 11.0) / 128.0
+                                } else if (i + j) % 2 == 0 {
+                                    -0.0
+                                } else {
+                                    0.0
+                                };
+                                a[i * n + j] = value;
+                                a[j * n + i] = value;
+                            }
+                        }
+                        for i in 0..n {
+                            a[i * n + i] = a[i * n..(i + 1) * n].iter().map(|v| v.abs()).sum::<f64>() + 1.0;
+                        }
+                        for value in &mut a {
+                            *value *= scale;
+                        }
+                        let mut rhs: Vec<f64> = (0..n).map(|i| if i % 7 == 0 { -0.0 } else { ((i * 5 + seed) % 17) as f64 - 8.0 }).collect();
+                        let (mut reference_a, mut reference_rhs) = (a.clone(), rhs.clone());
+                        assert!(dense_cholesky_reference(&mut reference_a, n, &mut reference_rhs));
+                        assert!(cholesky_solve(&mut a, n, &mut rhs));
+                        assert_eq!(
+                            rhs.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),
+                            reference_rhs.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),
+                            "n={n} width={width} seed={seed} scale={scale}"
+                        );
+                        assert_eq!(
+                            a.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),
+                            reference_a.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),
+                            "factor n={n} width={width}"
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn banded_cholesky_preserves_underflow_and_signed_zero() {
+        let n = 8;
+        let mut a = vec![0.0; n * n];
+        for i in 0..n {
+            for j in 0..n {
+                a[i * n + j] = if i == j {
+                    1e300
+                } else if (i + j) % 2 == 0 {
+                    -0.0
+                } else {
+                    0.0
+                };
+            }
+        }
+        let mut rhs = vec![-1e-300, 1e-300, -0.0, 0.0, -1e-300, 1e-300, 0.0, -0.0];
+        let (mut original, mut expected) = (a.clone(), rhs.clone());
+        assert!(dense_cholesky_reference(&mut original, n, &mut expected));
+        assert!(cholesky_solve(&mut a, n, &mut rhs));
+        assert_eq!(rhs.iter().map(|v| v.to_bits()).collect::<Vec<_>>(), expected.iter().map(|v| v.to_bits()).collect::<Vec<_>>());
+    }
+
+    #[test]
+    fn cholesky_rejects_invalid_dimensions_without_indexing() {
+        assert!(!cholesky_solve(&mut [], usize::MAX, &mut []));
+        assert!(!cholesky_solve(&mut [1.0], 2, &mut [1.0, 1.0]));
+        assert!(!cholesky_solve(&mut [1.0], 1, &mut []));
+        assert!(cholesky_solve(&mut [], 0, &mut []));
+    }
+
+    #[test]
+    fn conjugate_gradient_checks_residual_and_bad_curvature() {
+        let n = 64;
+        let rhs: Vec<f64> = (0..n).map(|i| (i % 11) as f64 - 5.0).collect();
+        let apply = |x: &[f64], y: &mut [f64]| {
+            for i in 0..n {
+                y[i] = 4.0 * x[i] + if i > 0 { x[i - 1] } else { 0.0 } + if i + 1 < n { x[i + 1] } else { 0.0 };
+            }
+        };
+        let x = conjugate_gradient(&rhs, apply, |r, z| {
+            for (r, z) in r.iter().zip(z) {
+                *z = *r / 4.0;
+            }
+        })
+        .unwrap();
+        let mut product = vec![0.0; n];
+        apply(&x, &mut product);
+        let residual: f64 = rhs.iter().zip(product).map(|(b, ax)| (b - ax).powi(2)).sum();
+        assert!(residual < 1e-18 * dot_n(&rhs, &rhs));
+        assert!(conjugate_gradient(&[1.0], |x, y| y[0] = -x[0], |r, z| z.copy_from_slice(r)).is_none());
+        assert!(conjugate_gradient(&[f64::NAN], |_, _| {}, |_, _| {}).is_none());
+        assert_eq!(conjugate_gradient(&[0.0], |_, _| {}, |_, _| {}).unwrap(), vec![0.0]);
+    }
+
     #[test]
     fn svd_reconstructs() {
         let a = [3.0, 1.0, 2.0, -1.0, 4.0, 0.5, 2.0, 2.0, 7.0, 0.1, -3.0, 1.0];
@@ -441,6 +677,20 @@ mod tests {
         assert!(s[0] >= s[1] && s[1] >= s[2]);
     }
 
+    #[test]
+    fn null_vector_matches_full_svd_bits_including_ties() {
+        for (m, n) in [(0, 0), (1, 1), (3, 3), (8, 9), (9, 9), (20, 3), (100, 9)] {
+            for scale in [0.0, 1e-100, 1.0, 1e100] {
+                let a: Vec<f64> = (0..m * n).map(|i| (((i * 37) % 31) as f64 - 15.0) * scale).collect();
+                let (_, _, v) = svd(&a, m, n);
+                let expected: Vec<_> = (0..n).map(|r| v[r * n + n - 1].to_bits()).collect();
+                assert_eq!(null_vector(&a, m, n).iter().map(|v| v.to_bits()).collect::<Vec<_>>(), expected);
+            }
+        }
+        let a = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
+        assert_eq!(null_vector(&a, 3, 3), vec![0.0, 0.0, 1.0]);
+    }
+
     #[test]
     fn rotations_round_trip() {
         let w = [0.3, -1.2, 0.7];
diff --git a/crates/track/src/camtrack/solver.rs b/crates/track/src/camtrack/solver.rs
index a4e2c21e6..8e212127b 100644
--- a/crates/track/src/camtrack/solver.rs
+++ b/crates/track/src/camtrack/solver.rs
@@ -7,7 +7,7 @@ use rayon::prelude::*;
 
 use super::bundle::{self, BaCam, BaObs, BaOpts, FocalMode};
 use super::geometry::{self, Pose};
-use super::linalg::*;
+use super::linalg::{V3, add, log_rot, mm, mt, mtv, mv, norm, normalize, rodrigues, scale, slerp, sub, sym_eigen};
 use super::{CameraSolve, CameraTracks, Distortion, ShotType, SolveMethod, SolveSettings, SolvedFrame, SolvedPoint};
 use crate::fit::{Model, ransac};
 
@@ -42,13 +42,54 @@ struct Data {
     noise_bits: std::sync::atomic::AtomicU64,
 }
 
+// Input budgets apply before building the duplicated per-frame/per-track lookup tables.
+const MAX_SOLVE_FRAMES: usize = 100_000;
+const MAX_SOLVE_TRACKS: usize = 200_000;
+const MAX_SOLVE_OBSERVATIONS: usize = 2_000_000;
+
+fn validate_tracks(t: &CameraTracks) -> Result<(), SolveError> {
+    if t.frames as usize > MAX_SOLVE_FRAMES || t.tracks.len() > MAX_SOLVE_TRACKS {
+        return err("camera tracks exceed the supported frame or track count");
+    }
+    if t.size.iter().any(|v| !v.is_finite() || *v <= 0.0)
+        || !t.factor.is_finite()
+        || t.factor < 0.0
+        || !t.start.is_finite()
+        || !t.frame_duration.is_finite()
+        || t.frame_duration <= 0.0
+    {
+        return err("camera tracks have invalid dimensions, timing or analysis scale");
+    }
+    let mut count = 0usize;
+    for tr in &t.tracks {
+        count = count
+            .checked_add(tr.pts.len())
+            .filter(|n| *n <= MAX_SOLVE_OBSERVATIONS)
+            .ok_or_else(|| SolveError("camera tracks exceed the supported observation count".into()))?;
+        let end = u32::try_from(tr.pts.len()).ok().and_then(|n| tr.start.checked_add(n));
+        if end.is_none_or(|end| end > t.frames) {
+            return err("camera track extends beyond the clip's frame range");
+        }
+        if tr.pts.iter().flatten().any(|v| !v.is_finite()) {
+            return err("camera track positions must be finite");
+        }
+    }
+    Ok(())
+}
+
 impl Data {
-    fn new(t: &CameraTracks, deleted: &[u32]) -> Data {
+    fn new(t: &CameraTracks, deleted: &[u32]) -> Result<Data, SolveError> {
+        validate_tracks(t)?;
+        if deleted.len() > MAX_SOLVE_TRACKS {
+            return err("too many deleted camera track ids");
+        }
         let n = t.frames as usize;
         let c = [t.size[0] * 0.5, t.size[1] * 0.5];
         let del: HashSet<u32> = deleted.iter().copied().collect();
         let mut tracks = vec![];
-        let mut by_frame = vec![vec![]; n];
+        let mut by_frame = Vec::new();
+        by_frame.try_reserve_exact(n).map_err(|_| SolveError("not enough memory for camera track frames".into()))?;
+        by_frame.resize_with(n, Vec::new);
         for tr in t.tracks.iter().filter(|tr| !del.contains(&tr.id) && tr.pts.len() >= 3) {
             let ti = tracks.len() as u32;
             let pts: Vec<[f64; 2]> = tr.pts.iter().map(|p| [p[0] as f64 - c[0], p[1] as f64 - c[1]]).collect();
@@ -60,7 +101,7 @@ impl Data {
             tracks.push((tr.id, tr.start as usize, pts));
         }
         let noise = (0.5 * t.factor).max(0.5);
-        Data { n, w: t.size[0], tracks, by_frame, noise_bits: std::sync::atomic::AtomicU64::new(noise.to_bits()) }
+        Ok(Data { n, w: t.size[0], tracks, by_frame, noise_bits: std::sync::atomic::AtomicU64::new(noise.to_bits()) })
     }
     fn at(&self, ti: u32, k: usize) -> Option<[f64; 2]> {
         let (_, s, p) = &self.tracks[ti as usize];
@@ -174,10 +215,10 @@ impl Recon {
     }
 
     /// Bundle-adjust the cameras of `frames` (the first stays fixed) and their points.
-    fn adjust(&mut self, d: &Data, frames: &[usize], cfg: &Cfg, focal: FocalMode, iters: usize) -> f64 {
+    fn adjust(&mut self, d: &Data, frames: &[usize], cfg: &Cfg, focal: FocalMode, iters: usize) -> Result<f64, SolveError> {
         let (mut cams, mut pts, obs, ids) = self.observations(d, frames);
         if obs.is_empty() {
-            return f64::INFINITY;
+            return Ok(f64::INFINITY);
         }
         let mut fixed = vec![false; cams.len()];
         fixed[0] = true;
@@ -186,14 +227,14 @@ impl Recon {
             &mut pts,
             &obs,
             &BaOpts { focal, fix_points: false, fix_centers: cfg.kind == Kind::Tripod, fixed, huber: d.huber(), max_iter: iters, distortion: cfg.distortion },
-        );
+        )?;
         for (k, c) in frames.iter().zip(&cams) {
             self.cams.insert(*k, *c);
         }
         for (ti, x) in ids.iter().zip(&pts) {
             self.pts.insert(*ti, *x);
         }
-        rep.cost
+        Ok(rep.cost)
     }
 
     /// Mark observations above the inlier threshold as outliers; drop points left with fewer
@@ -302,8 +343,12 @@ impl Recon {
                 break;
             }
             let mut cams = vec![start];
-            bundle::adjust(&mut cams, &mut pts.clone(), &obs, &opts(d.inlier_thr() * 4.0));
-            bundle::adjust(&mut cams, &mut pts.clone(), &obs, &opts(d.huber()));
+            if bundle::adjust(&mut cams, &mut pts.clone(), &obs, &opts(d.inlier_thr() * 4.0)).is_err() {
+                return false;
+            }
+            if bundle::adjust(&mut cams, &mut pts.clone(), &obs, &opts(d.huber())).is_err() {
+                return false;
+            }
             let inl = obs.iter().filter(|o| bundle::residual(&cams[0], pts[o.pt as usize], o.uv).is_some_and(|r| r[0] * r[0] + r[1] * r[1] <= thr2)).count();
             if best.as_ref().is_none_or(|b| inl > b.0) {
                 best = Some((inl, cams[0]));
@@ -317,7 +362,9 @@ impl Recon {
         let keep: Vec<BaObs> =
             obs.iter().filter(|o| bundle::residual(&cam, pts[o.pt as usize], o.uv).is_some_and(|r| r[0] * r[0] + r[1] * r[1] <= thr2)).copied().collect();
         let mut cams = vec![cam];
-        bundle::adjust(&mut cams, &mut pts.clone(), &keep, &opts(d.huber()));
+        if bundle::adjust(&mut cams, &mut pts.clone(), &keep, &opts(d.huber())).is_err() {
+            return false;
+        }
         for o in &obs {
             let ok = bundle::residual(&cams[0], pts[o.pt as usize], o.uv).is_some_and(|r| r[0] * r[0] + r[1] * r[1] <= thr2);
             if !ok {
@@ -471,10 +518,11 @@ fn grow(d: &Data, kfs: &[usize], j: usize, init: &(Pose, HashMap<u32, V3>), f: f
     r.pts = init.1.clone();
     let inner = |r: &mut Recon, frames: &[usize]| {
         let focal = if cfg.per_frame_f && frames.len() > 2 { FocalMode::PerCamera(F_PRIOR) } else { FocalMode::Fixed };
-        r.adjust(d, frames, cfg, focal, 10);
+        r.adjust(d, frames, cfg, focal, 10)?;
         r.reject(d);
+        Ok::<(), SolveError>(())
     };
-    inner(&mut r, &[a, b]);
+    inner(&mut r, &[a, b]).ok()?;
     let order: Vec<usize> = kfs[1..j].iter().chain(&kfs[j + 1..]).copied().collect();
     let mut done = 0;
     for k in order {
@@ -491,11 +539,11 @@ fn grow(d: &Data, kfs: &[usize], j: usize, init: &(Pose, HashMap<u32, V3>), f: f
         done += 1;
         let frames: Vec<usize> = r.cams.keys().copied().collect();
         if done % 3 == 0 || frames.len() <= 6 {
-            inner(&mut r, &frames);
+            inner(&mut r, &frames).ok()?;
         }
     }
     let frames: Vec<usize> = r.cams.keys().copied().collect();
-    inner(&mut r, &frames);
+    inner(&mut r, &frames).ok()?;
     (r.cams.len() >= 2 && r.pts.len() >= 8).then_some(r)
 }
 
@@ -531,10 +579,10 @@ fn grow_tripod(d: &Data, kfs: &[usize], f: f64, cfg: &Cfg, cancel: Option<&Atomi
     r.triangulate(d, Kind::Tripod, 0.0, 20.0);
     let frames: Vec<usize> = r.cams.keys().copied().collect();
     let focal = if cfg.per_frame_f && frames.len() > 2 { FocalMode::PerCamera(F_PRIOR) } else { FocalMode::Fixed };
-    r.adjust(d, &frames, cfg, focal, 15);
+    r.adjust(d, &frames, cfg, focal, 15).ok()?;
     r.reject(d);
     r.triangulate(d, Kind::Tripod, 0.0, 1.0);
-    r.adjust(d, &frames, cfg, focal, 15);
+    r.adjust(d, &frames, cfg, focal, 15).ok()?;
     (r.cams.len() >= 2 && r.pts.len() >= 8).then_some(r)
 }
 
@@ -684,7 +732,7 @@ pub fn solve(tracks: &CameraTracks, s: &SolveSettings, cancel: Option<&AtomicBoo
     for pass in 0..2 {
         let und = (pass > 0).then(|| undistorted(tracks, &dist));
         let c = solve_core(und.as_ref().unwrap_or(tracks), s, cancel)?;
-        let d = Data::new(tracks, &s.deleted);
+        let d = Data::new(tracks, &s.deleted)?;
         d.set_noise(c.d.noise());
         let mut r = c.r;
         for cam in r.cams.values_mut() {
@@ -699,10 +747,10 @@ pub fn solve(tracks: &CameraTracks, s: &SolveSettings, cancel: Option<&AtomicBoo
         // The pinhole solve's outliers include the distorted frame edges: start from all
         // observations (the Huber loss keeps real outliers in check), then reject again.
         r.outliers.clear();
-        r.adjust(&d, &frames, &cfg, c.focal, 30);
+        r.adjust(&d, &frames, &cfg, c.focal, 30)?;
         r.outliers.clear();
         r.reject(&d);
-        r.adjust(&d, &frames, &cfg, c.focal, 30);
+        r.adjust(&d, &frames, &cfg, c.focal, 30)?;
         dist = r.cams[&frames[0]].dist;
         for cam in r.cams.values_mut() {
             cam.dist = dist;
@@ -742,7 +790,7 @@ pub fn solve(tracks: &CameraTracks, s: &SolveSettings, cancel: Option<&AtomicBoo
 }
 
 fn solve_core(tracks: &CameraTracks, s: &SolveSettings, cancel: Option<&AtomicBool>) -> Result<Core, SolveError> {
-    let d = Data::new(tracks, &s.deleted);
+    let d = Data::new(tracks, &s.deleted)?;
     if d.n < 2 {
         return err("the clip must be at least two frames long");
     }
@@ -848,7 +896,7 @@ fn solve_core(tracks: &CameraTracks, s: &SolveSettings, cancel: Option<&AtomicBo
     lap("tripod");
     // Keyframes: adjust with the focal length free, reject, re-triangulate, adjust again.
     let kf_frames: Vec<usize> = r.cams.keys().copied().collect();
-    r.adjust(&d, &kf_frames, &cfg, focal, 40);
+    r.adjust(&d, &kf_frames, &cfg, focal, 40)?;
     r.reject(&d);
     // Re-estimate the tracking noise from the inlier residuals (robustly, from their median:
     // for 2D Gaussian noise of deviation σ the median distance is 1.1774 σ), then tighten the
@@ -876,9 +924,9 @@ fn solve_core(tracks: &CameraTracks, s: &SolveSettings, cancel: Option<&AtomicBo
         r.reject(&d);
     }
     r.triangulate(&d, kind, 1.0, 1.0);
-    r.adjust(&d, &kf_frames, &cfg, focal, 40);
+    r.adjust(&d, &kf_frames, &cfg, focal, 40)?;
     r.reject(&d);
-    r.adjust(&d, &kf_frames, &cfg, focal, 20);
+    r.adjust(&d, &kf_frames, &cfg, focal, 20)?;
     if cancelled() {
         return err("cancelled");
     }
@@ -910,7 +958,7 @@ fn solve_core(tracks: &CameraTracks, s: &SolveSettings, cancel: Option<&AtomicBo
     let all: Vec<usize> = r.cams.keys().copied().collect();
     r.reject(&d);
     if all.len() <= 160 {
-        r.adjust(&d, &all, &cfg, focal, 25);
+        r.adjust(&d, &all, &cfg, focal, 25)?;
         r.reject(&d);
     } else {
         // Points only (cameras fixed) would be cheap but the keyframe solution is already
diff --git a/crates/track/src/face.rs b/crates/track/src/face.rs
index 45c7c4baa..708a05c4f 100644
--- a/crates/track/src/face.rs
+++ b/crates/track/src/face.rs
@@ -186,9 +186,16 @@ fn to_layer(c: [f64; 2], b: f64, roll_deg: f64, q: [f64; 2]) -> [f64; 2] {
 
 /// Layer pixels → face frame.
 fn to_face(c: [f64; 2], b: f64, roll_deg: f64, p: [f64; 2]) -> [f64; 2] {
+    face_mapper(c, b, roll_deg)(p)
+}
+
+/// [`to_face`] with the rotation worked out once, for mapping many points.
+fn face_mapper(c: [f64; 2], b: f64, roll_deg: f64) -> impl Fn([f64; 2]) -> [f64; 2] {
     let (sn, cs) = roll_deg.to_radians().sin_cos();
-    let d = [(p[0] - c[0]) / b, (p[1] - c[1]) / b];
-    [cs * d[0] + sn * d[1], -sn * d[0] + cs * d[1]]
+    move |p| {
+        let d = [(p[0] - c[0]) / b, (p[1] - c[1]) / b];
+        [cs * d[0] + sn * d[1], -sn * d[0] + cs * d[1]]
+    }
 }
 
 /// A synthetic face's landmarks in layer pixels.
@@ -547,6 +554,32 @@ fn fit_from_face(face: &Face, topo: &Topology, offset: [f64; 2]) -> Option<FaceF
     Some(FaceFit { landmarks, detected, outline, center, height: b, roll })
 }
 
+/// Find the first skin pixel in successive rings around the predicted center.
+fn nearest_skin(skin: &[bool], size: (usize, usize), center: (usize, usize), radius: i64) -> Option<(usize, usize)> {
+    let (w, h) = size;
+    let (ci, cj) = center;
+    for r in 0..radius {
+        for dj in -r..=r {
+            for di in -r..=r {
+                if di.abs() != r && dj.abs() != r {
+                    continue;
+                }
+                let (i, j) = (ci as i64 + di, cj as i64 + dj);
+                if i >= 0 && j >= 0 && (i as usize) < w && (j as usize) < h && skin[j as usize * w + i as usize] {
+                    return Some((i as usize, j as usize));
+                }
+            }
+        }
+    }
+    None
+}
+
+struct FaceGeometry {
+    center: [f64; 2],
+    height: f64,
+    roll: f64,
+}
+
 /// A pixel window of a frame in layer coordinates.
 struct Window {
     x0: i64,
@@ -578,6 +611,44 @@ impl Window {
     }
 }
 
+/// Per pixel of a `w × h` window: not skin and inside `poly` (even-odd rule, same comparisons as
+/// [`crate::mask::inside_polygon`] at `layer(i, j)`). A scanline crosses the polygon at the same
+/// edges for every pixel of a row, so the crossings are found once per row and each pixel's
+/// parity follows from how many lie right of it.
+fn non_skin_inside(poly: &[[f64; 2]], skin: &[bool], layer: impl Fn(usize, usize) -> [f64; 2], w: usize, h: usize) -> Vec<bool> {
+    let mut feat = vec![false; w * h];
+    let n = poly.len();
+    if n < 3 {
+        return feat;
+    }
+    let mut xs: Vec<f64> = Vec::with_capacity(n);
+    for j in 0..h {
+        let y = layer(0, j)[1];
+        xs.clear();
+        let mut prev = poly[n - 1];
+        for &cur in poly {
+            let (a, b) = (cur, prev);
+            if (a[1] > y) != (b[1] > y) {
+                xs.push((b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0]);
+            }
+            prev = cur;
+        }
+        if xs.is_empty() {
+            continue;
+        }
+        xs.sort_by(f64::total_cmp);
+        let mut left = 0;
+        for i in 0..w {
+            let x = layer(i, j)[0];
+            while left < xs.len() && xs[left] <= x {
+                left += 1;
+            }
+            feat[j * w + i] = (xs.len() - left) % 2 == 1 && !skin[j * w + i];
+        }
+    }
+    feat
+}
+
 fn median(v: &mut [f32]) -> f32 {
     v.sort_by(f32::total_cmp);
     v[v.len() / 2]
@@ -752,6 +823,53 @@ impl FaceTracker {
         Some(fit)
     }
 
+    /// Connected dark features inside the fitted face, in normalized face coordinates.
+    fn feature_blobs(&self, frame: &Frame, win: &Window, skin: &[bool], luma: &[f32], outline: &[[f64; 2]], geometry: FaceGeometry) -> Vec<Blob> {
+        let FaceGeometry { center, height: b, roll } = geometry;
+        let (w, h) = (win.w, win.h);
+        // Non-skin components inside the face outline (shrunk a little: anti-aliased edges).
+        let inner: Vec<[f64; 2]> = outline.iter().map(|p| [center[0] + 0.9 * (p[0] - center[0]), center[1] + 0.9 * (p[1] - center[1])]).collect();
+        let feat = non_skin_inside(&inner, skin, |i, j| win.layer(frame, i, j), w, h);
+        let min_area = (0.0006 * b * b).max(2.0) as usize;
+        let mut seen = vec![false; w * h];
+        let mut blobs: Vec<Blob> = vec![];
+        let skin_luma = self.skin.med[0] as f64;
+        let to_face = face_mapper(center, b, roll);
+        for j0 in 0..h {
+            for i0 in 0..w {
+                if !feat[j0 * w + i0] || seen[j0 * w + i0] {
+                    continue;
+                }
+                let mut st = vec![(i0, j0)];
+                seen[j0 * w + i0] = true;
+                let mut pts = vec![];
+                while let Some((i, j)) = st.pop() {
+                    let q = to_face(win.layer(frame, i, j));
+                    pts.push((q, skin_luma - luma[j * w + i] as f64));
+                    for dj in -1i64..=1 {
+                        for di in -1i64..=1 {
+                            let (a, c) = (i as i64 + di, j as i64 + dj);
+                            if a < 0 || c < 0 || a as usize >= w || c as usize >= h {
+                                continue;
+                            }
+                            let (a, c) = (a as usize, c as usize);
+                            if feat[c * w + a] && !seen[c * w + a] {
+                                seen[c * w + a] = true;
+                                st.push((a, c));
+                            }
+                        }
+                    }
+                }
+                if pts.len() >= min_area {
+                    let n = pts.len() as f64;
+                    let centroid = [pts.iter().map(|p| p.0[0]).sum::<f64>() / n, pts.iter().map(|p| p.0[1]).sum::<f64>() / n];
+                    blobs.push(Blob { pts, centroid });
+                }
+            }
+        }
+        blobs
+    }
+
     fn fit(&self, frame: &Frame) -> Option<FaceFit> {
         let pv = &self.prev;
         let b0 = pv.height;
@@ -769,22 +887,7 @@ impl FaceTracker {
         }
         // Seed: the skin pixel nearest the predicted centre.
         let (ci, cj) = win.cell(frame, pv.center)?;
-        let mut seed = None;
-        'search: for r in 0..(0.6 * b0).ceil() as i64 {
-            for dj in -r..=r {
-                for di in -r..=r {
-                    if di.abs() != r && dj.abs() != r {
-                        continue;
-                    }
-                    let (i, j) = (ci as i64 + di, cj as i64 + dj);
-                    if i >= 0 && j >= 0 && (i as usize) < w && (j as usize) < h && skin[j as usize * w + i as usize] {
-                        seed = Some((i as usize, j as usize));
-                        break 'search;
-                    }
-                }
-            }
-        }
-        let (si, sj) = seed?;
+        let (si, sj) = nearest_skin(&skin, (w, h), (ci, cj), (0.6 * b0).ceil() as i64)?;
         // Flood fill (4-connected).
         let mut comp = vec![false; w * h];
         let mut stack = vec![(si, sj)];
@@ -855,52 +958,7 @@ impl FaceTracker {
             roll += 180.0;
         }
         let b = major;
-        // Non-skin components inside the face outline (shrunk a little: anti-aliased edges).
-        let inner: Vec<[f64; 2]> = outline.iter().map(|p| [center[0] + 0.9 * (p[0] - center[0]), center[1] + 0.9 * (p[1] - center[1])]).collect();
-        let mut feat = vec![false; w * h];
-        for j in 0..h {
-            for i in 0..w {
-                if !skin[j * w + i] && crate::mask::inside_polygon(&inner, win.layer(frame, i, j)) {
-                    feat[j * w + i] = true;
-                }
-            }
-        }
-        let min_area = (0.0006 * b * b).max(2.0) as usize;
-        let mut seen = vec![false; w * h];
-        let mut blobs: Vec<Blob> = vec![];
-        let skin_luma = self.skin.med[0] as f64;
-        for j0 in 0..h {
-            for i0 in 0..w {
-                if !feat[j0 * w + i0] || seen[j0 * w + i0] {
-                    continue;
-                }
-                let mut st = vec![(i0, j0)];
-                seen[j0 * w + i0] = true;
-                let mut pts = vec![];
-                while let Some((i, j)) = st.pop() {
-                    let q = to_face(center, b, roll, win.layer(frame, i, j));
-                    pts.push((q, skin_luma - luma[j * w + i] as f64));
-                    for dj in -1i64..=1 {
-                        for di in -1i64..=1 {
-                            let (a, c) = (i as i64 + di, j as i64 + dj);
-                            if a < 0 || c < 0 || a as usize >= w || c as usize >= h {
-                                continue;
-                            }
-                            let (a, c) = (a as usize, c as usize);
-                            if feat[c * w + a] && !seen[c * w + a] {
-                                seen[c * w + a] = true;
-                                st.push((a, c));
-                            }
-                        }
-                    }
-                }
-                if pts.len() >= min_area {
-                    let n = pts.len() as f64;
-                    let centroid = [pts.iter().map(|p| p.0[0]).sum::<f64>() / n, pts.iter().map(|p| p.0[1]).sum::<f64>() / n];
-                    blobs.push(Blob { pts, centroid });
-                }
-            }
-        }
+        let blobs = self.feature_blobs(frame, &win, &skin, &luma, &outline, FaceGeometry { center, height: b, roll });
         // Match components to features near their expected positions.
         let ex = &self.expect;
         let mean_of = |ids: &[usize]| {
@@ -1174,6 +1232,35 @@ mod tests {
         assert!(err < 0.06 * 50.0, "max error {err}");
     }
 
+    #[test]
+    fn row_crossings_match_the_point_in_polygon_test() {
+        let (w, h) = (97, 83);
+        let off = [13.0, 7.0];
+        let layer = |i: usize, j: usize| [(20 + i) as f64 + 0.5 - off[0] + 0.25, (11 + j) as f64 + 0.5 - off[1]];
+        let star: Vec<[f64; 2]> = (0..48)
+            .map(|k| {
+                let a = k as f64 / 48.0 * std::f64::consts::TAU;
+                let r = 30.0 + 9.0 * (5.0 * a).sin() + 3.0 * (k % 3) as f64;
+                [50.0 + a.cos() * r, 40.0 + a.sin() * r * 1.3]
+            })
+            .collect();
+        // Vertices on pixel-centre rows and columns exercise the tie cases.
+        let tied: Vec<[f64; 2]> = vec![[10.0, 5.0], [70.0, 5.0], [70.0, 60.5], [40.0, 30.5], [10.0, 60.5], [10.0, 5.0]];
+        for poly in [star, tied, vec![[1.0, 1.0], [5.0, 5.0]]] {
+            let skin: Vec<bool> = (0..w * h).map(|i| (i * 7 + i / w) % 5 == 0).collect();
+            let got = non_skin_inside(&poly, &skin, layer, w, h);
+            let mut inside = 0;
+            for j in 0..h {
+                for i in 0..w {
+                    let want = !skin[j * w + i] && crate::mask::inside_polygon(&poly, layer(i, j));
+                    assert_eq!(got[j * w + i], want, "({i}, {j})");
+                    inside += want as usize;
+                }
+            }
+            assert!(inside > 0 || poly.len() < 3);
+        }
+    }
+
     #[test]
     fn tracks_a_moving_rotating_synthetic_face() {
         let (w, h) = (320, 240);
diff --git a/crates/track/src/klt.rs b/crates/track/src/klt.rs
index a4566c79a..c947bd4d1 100644
--- a/crates/track/src/klt.rs
+++ b/crates/track/src/klt.rs
@@ -254,6 +254,42 @@ impl Default for LkOpts {
     }
 }
 
+/// Bilinear taps shared by every pixel of a `(2r+1)²` window centred at `c`: the fractional
+/// offset is the same for the whole window, and the column/row indices are clamped like
+/// [`Plane::at`] (edges repeated). Row indices are pre-multiplied by the plane width.
+#[derive(Default)]
+struct Taps {
+    xs: Vec<[usize; 2]>,
+    ys: Vec<[usize; 2]>,
+    t: [f32; 2],
+}
+
+impl Taps {
+    fn set(&mut self, p: &Plane, c: [f64; 2], r: i32) {
+        debug_assert_eq!(p.ch, 1);
+        let (fx, fy) = (c[0] - 0.5, c[1] - 0.5);
+        let (x0, y0) = (fx.floor(), fy.floor());
+        self.t = [(fx - x0) as f32, (fy - y0) as f32];
+        const FAR: f64 = (1u64 << 40) as f64;
+        let (xi, yi) = (x0.clamp(-FAR, FAR) as isize, y0.clamp(-FAR, FAR) as isize);
+        let (wm, hm) = (p.w as isize - 1, p.h as isize - 1);
+        let r = r as isize;
+        self.xs.clear();
+        self.ys.clear();
+        self.xs.extend((-r..=r).map(|d| [(xi + d).clamp(0, wm) as usize, (xi + d + 1).clamp(0, wm) as usize]));
+        self.ys.extend((-r..=r).map(|d| [(yi + d).clamp(0, hm) as usize * p.w, (yi + d + 1).clamp(0, hm) as usize * p.w]));
+    }
+}
+
+/// [`Plane::sample`]'s bilinear form on pre-resolved taps.
+#[inline(always)]
+fn bilerp(d: &[f32], x: [usize; 2], y: [usize; 2], t: [f32; 2]) -> f32 {
+    let (a, b, c, e) = (d[y[0] + x[0]], d[y[0] + x[1]], d[y[1] + x[0]], d[y[1] + x[1]]);
+    let top = a + (b - a) * t[0];
+    let bot = c + (e - c) * t[0];
+    top + (bot - top) * t[1]
+}
+
 fn lk_point(a: &GrayPyramid, b: &GrayPyramid, p: [f64; 2], guess: [f64; 2], o: &LkOpts) -> Option<[f64; 2]> {
     let top = a.levels.len().min(b.levels.len()).checked_sub(1)?;
     let r = o.radius;
@@ -263,7 +299,7 @@ fn lk_point(a: &GrayPyramid, b: &GrayPyramid, p: [f64; 2], guess: [f64; 2], o: &
     let mut win = vec![0.0f32; ((2 * r + 1) * (2 * r + 1)) as usize];
     let mut wgx = win.clone();
     let mut wgy = win.clone();
-    let mut v1 = [0.0f32];
+    let mut taps = Taps::default();
     for l in (0..=top).rev() {
         let s = (1u32 << l) as f64;
         let (ia, ib) = (&a.levels[l], &b.levels[l]);
@@ -274,15 +310,12 @@ fn lk_point(a: &GrayPyramid, b: &GrayPyramid, p: [f64; 2], guess: [f64; 2], o: &
         }
         let (mut gxx, mut gxy, mut gyy) = (0.0f64, 0.0f64, 0.0f64);
         let mut k = 0;
-        for dy in -r..=r {
-            for dx in -r..=r {
-                let (x, y) = (c[0] + dx as f64, c[1] + dy as f64);
-                ia.sample(x, y, &mut v1);
-                win[k] = v1[0];
-                gx.sample(x, y, &mut v1);
-                wgx[k] = v1[0];
-                gy.sample(x, y, &mut v1);
-                wgy[k] = v1[0];
+        taps.set(ia, c, r);
+        for &y in &taps.ys {
+            for &x in &taps.xs {
+                win[k] = bilerp(&ia.data, x, y, taps.t);
+                wgx[k] = bilerp(&gx.data, x, y, taps.t);
+                wgy[k] = bilerp(&gy.data, x, y, taps.t);
                 let (ix, iy) = (wgx[k] as f64, wgy[k] as f64);
                 gxx += ix * ix;
                 gxy += ix * iy;
@@ -300,10 +333,10 @@ fn lk_point(a: &GrayPyramid, b: &GrayPyramid, p: [f64; 2], guess: [f64; 2], o: &
         for _ in 0..o.iterations {
             let (mut bx, mut by) = (0.0f64, 0.0f64);
             let mut k = 0;
-            for dy in -r..=r {
-                for dx in -r..=r {
-                    ib.sample(c[0] + g[0] + v[0] + dx as f64, c[1] + g[1] + v[1] + dy as f64, &mut v1);
-                    let diff = (win[k] - v1[0]) as f64;
+            taps.set(ib, [c[0] + g[0] + v[0], c[1] + g[1] + v[1]], r);
+            for &y in &taps.ys {
+                for &x in &taps.xs {
+                    let diff = (win[k] - bilerp(&ib.data, x, y, taps.t)) as f64;
                     bx += diff * wgx[k] as f64;
                     by += diff * wgy[k] as f64;
                     k += 1;
@@ -397,6 +430,87 @@ mod tests {
         im
     }
 
+    /// The per-pixel `Plane::sample` implementation `lk_point` replaced, kept as the oracle.
+    fn lk_point_ref(a: &GrayPyramid, b: &GrayPyramid, p: [f64; 2], guess: [f64; 2], o: &LkOpts) -> Option<[f64; 2]> {
+        let top = a.levels.len().min(b.levels.len()).checked_sub(1)?;
+        let r = o.radius;
+        let n = ((2 * r + 1) * (2 * r + 1)) as f64;
+        let s0 = (1u32 << top) as f64;
+        let mut g = [guess[0] / s0, guess[1] / s0];
+        let mut win = vec![0.0f32; ((2 * r + 1) * (2 * r + 1)) as usize];
+        let mut wgx = win.clone();
+        let mut wgy = win.clone();
+        let mut v1 = [0.0f32];
+        for l in (0..=top).rev() {
+            let s = (1u32 << l) as f64;
+            let (ia, ib) = (&a.levels[l], &b.levels[l]);
+            let (gx, gy) = &a.grads[l];
+            let c = [p[0] / s, p[1] / s];
+            if c[0] < -1.0 || c[1] < -1.0 || c[0] > ia.w as f64 + 1.0 || c[1] > ia.h as f64 + 1.0 {
+                return None;
+            }
+            let (mut gxx, mut gxy, mut gyy) = (0.0f64, 0.0f64, 0.0f64);
+            let mut k = 0;
+            for dy in -r..=r {
+                for dx in -r..=r {
+                    let (x, y) = (c[0] + dx as f64, c[1] + dy as f64);
+                    ia.sample(x, y, &mut v1);
+                    win[k] = v1[0];
+                    gx.sample(x, y, &mut v1);
+                    wgx[k] = v1[0];
+                    gy.sample(x, y, &mut v1);
+                    wgy[k] = v1[0];
+                    let (ix, iy) = (wgx[k] as f64, wgy[k] as f64);
+                    gxx += ix * ix;
+                    gxy += ix * iy;
+                    gyy += iy * iy;
+                    k += 1;
+                }
+            }
+            let det = gxx * gyy - gxy * gxy;
+            let tr = 0.5 * (gxx + gyy);
+            let mineig = (tr - (0.25 * (gxx - gyy).powi(2) + gxy * gxy).sqrt()) / n;
+            if mineig < o.min_eigen || det.abs() < 1e-18 {
+                return None;
+            }
+            let mut v = [0.0f64; 2];
+            for _ in 0..o.iterations {
+                let (mut bx, mut by) = (0.0f64, 0.0f64);
+                let mut k = 0;
+                for dy in -r..=r {
+                    for dx in -r..=r {
+                        ib.sample(c[0] + g[0] + v[0] + dx as f64, c[1] + g[1] + v[1] + dy as f64, &mut v1);
+                        let diff = (win[k] - v1[0]) as f64;
+                        bx += diff * wgx[k] as f64;
+                        by += diff * wgy[k] as f64;
+                        k += 1;
+                    }
+                }
+                let nx = (gyy * bx - gxy * by) / det;
+                let ny = (gxx * by - gxy * bx) / det;
+                v[0] += nx;
+                v[1] += ny;
+                if !(v[0].is_finite() && v[1].is_finite()) {
+                    return None;
+                }
+                if nx * nx + ny * ny < o.epsilon * o.epsilon {
+                    break;
+                }
+            }
+            if l > 0 {
+                g = [2.0 * (g[0] + v[0]), 2.0 * (g[1] + v[1])];
+            } else {
+                g = [g[0] + v[0], g[1] + v[1]];
+            }
+        }
+        let q = [p[0] + g[0], p[1] + g[1]];
+        let l0 = &b.levels[0];
+        if q[0] < 0.0 || q[1] < 0.0 || q[0] > l0.w as f64 || q[1] > l0.h as f64 {
+            return None;
+        }
+        Some(q)
+    }
+
     #[test]
     fn klt_recovers_a_shift() {
         let a = GrayPyramid::from_image(&img(0.0, 0.0), [0.0; 2], 1, 3);
@@ -411,6 +525,35 @@ mod tests {
         assert!(errs[errs.len() / 2] < 0.1, "median error {}", errs[errs.len() / 2]);
     }
 
+    #[test]
+    fn window_taps_match_per_pixel_sampling_bit_for_bit() {
+        let a = GrayPyramid::from_image(&img(0.0, 0.0), [0.0; 2], 1, 3);
+        let b = GrayPyramid::from_image(&img(6.3, -4.2), [0.0; 2], 1, 3);
+        let mut pts = vec![];
+        for y in (-3..125).step_by(3) {
+            for x in (-3..165).step_by(3) {
+                pts.push([x as f64 + 0.37 * ((x * 7 + y) % 3) as f64, y as f64 + 0.5 * ((x + y * 5) % 2) as f64]);
+            }
+        }
+        pts.extend([[0.0, 0.0], [160.0, 120.0], [80.0, 60.0], [0.5, 0.5], [159.5, 119.5]]);
+        let (mut tracked, mut lost) = (0, 0);
+        for (i, p) in pts.iter().enumerate() {
+            for o in [LkOpts::default(), LkOpts { radius: 3, iterations: 5, ..Default::default() }] {
+                let g = [(i % 5) as f64 - 2.0, (i % 3) as f64 - 1.0];
+                let (new, old) = (lk_point(&a, &b, *p, g, &o), lk_point_ref(&a, &b, *p, g, &o));
+                match (new, old) {
+                    (Some(n), Some(o)) => {
+                        assert_eq!([n[0].to_bits(), n[1].to_bits()], [o[0].to_bits(), o[1].to_bits()], "{p:?}");
+                        tracked += 1;
+                    }
+                    (None, None) => lost += 1,
+                    (n, o) => panic!("{p:?}: {n:?} vs {o:?}"),
+                }
+            }
+        }
+        assert!(tracked > 500 && lost > 0, "{tracked} tracked, {lost} lost");
+    }
+
     #[test]
     fn features_respect_the_region_and_spacing() {
         let a = GrayPyramid::from_image(&img(0.0, 0.0), [0.0; 2], 1, 2);
diff --git a/crates/track/src/lib.rs b/crates/track/src/lib.rs
index fe36bc096..8867bfcb8 100644
--- a/crates/track/src/lib.rs
+++ b/crates/track/src/lib.rs
@@ -201,7 +201,7 @@ fn ncc(plane: &Plane, p: &Patch, c: [f64; 2], a: [f64; 2]) -> f64 {
     }
     let ch = p.ch;
     let (mut s, mut s2, mut st) = (0.0f64, 0.0f64, 0.0f64);
-    let identity = (a[0] - 1.0).abs() < 1e-9 && a[1].abs() < 1e-9;
+    let identity = is_identity(a);
     let fx = c[0] - 0.5;
     let fy = c[1] - 0.5;
     let (bx, by) = (fx.floor(), fy.floor());
@@ -256,12 +256,114 @@ fn ncc(plane: &Plane, p: &Patch, c: [f64; 2], a: [f64; 2]) -> f64 {
     (st / (var * p.ss).sqrt()).clamp(-1.0, 1.0)
 }
 
+fn is_identity(a: [f64; 2]) -> bool {
+    (a[0] - 1.0).abs() < 1e-9 && a[1].abs() < 1e-9
+}
+
+/// The bilinear taps of every template pixel at `c + A u`. Candidates `c + (i, j)` with integer
+/// `(i, j)` give each pixel the same fractional offsets, so one table serves them all and a
+/// candidate is integer-indexed lerps (the arithmetic of `Plane::sample`) with one bounds check.
+struct Taps {
+    /// Offset (in samples) of the top-left tap per template pixel from the one at `base`.
+    off: Vec<isize>,
+    w: Vec<[f32; 2]>,
+    base: isize,
+    /// Tap bounding box (x0, y0, x1, y1) in plane pixels at the reference, `+1` taps included.
+    bb: [isize; 4],
+}
+
+impl Taps {
+    fn new(plane: &Plane, p: &Patch, c: [f64; 2], a: [f64; 2]) -> Option<Taps> {
+        let n = ((2 * p.r[0] + 1) * (2 * p.r[1] + 1)) as usize;
+        let (mut off, mut w) = (Vec::with_capacity(n), Vec::with_capacity(n));
+        let (rx, ry) = ((c[0] - 0.5).floor(), (c[1] - 0.5).floor());
+        if !(rx.abs() < 1e9 && ry.abs() < 1e9) {
+            return None;
+        }
+        let (rx, ry) = (rx as isize, ry as isize);
+        let mut bb = [isize::MAX, isize::MAX, isize::MIN, isize::MIN];
+        for gy in -p.r[1]..=p.r[1] {
+            for gx in -p.r[0]..=p.r[0] {
+                let (ux, uy) = (gx as f64, gy as f64);
+                let fx = c[0] + a[0] * ux - a[1] * uy - 0.5;
+                let fy = c[1] + a[1] * ux + a[0] * uy - 0.5;
+                let (x0, y0) = (fx.floor(), fy.floor());
+                if !(x0.abs() < 1e9 && y0.abs() < 1e9) {
+                    return None;
+                }
+                let (dx, dy) = (x0 as isize - rx, y0 as isize - ry);
+                bb = [bb[0].min(dx), bb[1].min(dy), bb[2].max(dx + 1), bb[3].max(dy + 1)];
+                off.push((dy * plane.w as isize + dx) * plane.ch as isize);
+                w.push([(fx - x0) as f32, (fy - y0) as f32]);
+            }
+        }
+        let base = (ry * plane.w as isize + rx) * plane.ch as isize;
+        Some(Taps { off, w, base, bb: [bb[0] + rx, bb[1] + ry, bb[2] + rx, bb[3] + ry] })
+    }
+
+    /// The correlation at `c + (i, j)`, or `None` when a tap leaves the plane.
+    fn ncc(&self, plane: &Plane, p: &Patch, i: isize, j: isize) -> Option<f64> {
+        if self.bb[0] + i < 0 || self.bb[1] + j < 0 || self.bb[2] + i >= plane.w as isize || self.bb[3] + j >= plane.h as isize {
+            return None;
+        }
+        let ch = p.ch;
+        let row = plane.w * ch;
+        let b = self.base + (j * plane.w as isize + i) * ch as isize;
+        let d = &plane.data;
+        let (mut s, mut s2, mut st) = (0.0f64, 0.0f64, 0.0f64);
+        let mut k = 0;
+        for (o, t) in self.off.iter().zip(&self.w) {
+            let i00 = (b + o) as usize;
+            let (i10, i01) = (i00 + ch, i00 + row);
+            for cc in 0..ch {
+                let top = d[i00 + cc] + (d[i10 + cc] - d[i00 + cc]) * t[0];
+                let bot = d[i01 + cc] + (d[i01 + ch + cc] - d[i01 + cc]) * t[0];
+                let x = (top + (bot - top) * t[1]) as f64;
+                s += x;
+                s2 += x * x;
+                st += x * p.zm[k] as f64;
+                k += 1;
+            }
+        }
+        let n = p.zm.len() as f64;
+        let var = s2 - s * s / n;
+        if var <= 1e-12 {
+            return Some(0.0);
+        }
+        Some((st / (var * p.ss).sqrt()).clamp(-1.0, 1.0))
+    }
+}
+
+/// `ncc` of one template at integer offsets from a reference centre, through a [`Taps`] table
+/// when the shape is not the identity (the identity has its own fast path in `ncc`).
+struct Scorer<'a> {
+    plane: &'a Plane,
+    p: &'a Patch,
+    c: [f64; 2],
+    a: [f64; 2],
+    taps: Option<Taps>,
+}
+
+impl<'a> Scorer<'a> {
+    fn new(plane: &'a Plane, p: &'a Patch, c: [f64; 2], a: [f64; 2]) -> Scorer<'a> {
+        let taps = if is_identity(a) || p.ss <= 1e-12 { None } else { Taps::new(plane, p, c, a) };
+        Scorer { plane, p, c, a, taps }
+    }
+
+    /// The correlation at the reference centre plus `(i, j)` pixels.
+    fn at(&self, i: i32, j: i32) -> f64 {
+        self.taps
+            .as_ref()
+            .and_then(|t| t.ncc(self.plane, self.p, i as isize, j as isize))
+            .unwrap_or_else(|| ncc(self.plane, self.p, [self.c[0] + i as f64, self.c[1] + j as f64], self.a))
+    }
+}
+
 /// The pre-processed pixels around one point: a pyramid of a crop. Plane coordinates are image
 /// pixels minus `origin`, divided by `2^level`.
 struct Crop {
     origin: [f64; 2],
     levels: Vec<Plane>,
-    grad0: (Plane, Plane),
 }
 
 impl Crop {
@@ -280,13 +382,12 @@ impl Crop {
         if opts.enhance {
             p = p.enhance();
         }
-        let grad0 = p.gradients();
         let mut lv = vec![p];
         for _ in 0..levels {
             let d = lv.last().map(Plane::downsample).unwrap_or_default();
             lv.push(d);
         }
-        Crop { origin: [x0, y0], levels: lv, grad0 }
+        Crop { origin: [x0, y0], levels: lv }
     }
     fn to_level(&self, p: [f64; 2], k: usize) -> [f64; 2] {
         let s = (1u32 << k) as f64;
@@ -298,6 +399,12 @@ impl Crop {
     }
 }
 
+/// Largest distance (in top-level pixels, per axis) between the best coarse match and the
+/// motion prediction for which the fine stage searches only ±1 pixel per level.
+const SMALL_MOTION: f64 = 1.0;
+/// Lowest coarse NCC score of the best match for which the fine stage may search only ±1.
+const RELIABLE_SCORE: f64 = 0.8;
+
 /// Per-point tracking state.
 #[derive(Clone, Debug)]
 struct PointState {
@@ -372,13 +479,15 @@ impl PointState {
         let (rx, ry) = ((range[0] / s).ceil() as i32, (range[1] / s).ceil() as i32);
         let plane = &crop.levels[top];
         let tpl = &self.templates[top];
+        let scorer = Scorer::new(plane, tpl, ctop, self.shape);
         let shape = self.shape;
         let mut cands: Vec<(f64, [f64; 2])> = (-ry..=ry)
             .into_par_iter()
             .flat_map_iter(|j| {
+                let scorer = &scorer;
                 (-rx..=rx).map(move |i| {
                     let c = [ctop[0] + i as f64, ctop[1] + j as f64];
-                    (ncc(plane, tpl, c, shape), c)
+                    (scorer.at(i, j), c)
                 })
             })
             .collect();
@@ -396,7 +505,10 @@ impl PointState {
                 break;
             }
         }
-        // Fine: refine each seed down the pyramid in a 5 × 5 neighbourhood.
+        // Fine: refine each seed down the pyramid. A good motion prediction plus a reliable coarse
+        // match only needs a 3 × 3 neighbourhood per level; otherwise keep 5 × 5.
+        let near = cands[0].0 >= RELIABLE_SCORE && seeds.first().is_some_and(|c| (c[0] - cp[0]).abs() <= SMALL_MOTION && (c[1] - cp[1]).abs() <= SMALL_MOTION);
+        let rr: i32 = if near { 1 } else { 2 };
         let mut best = (f64::MIN, sc);
         for seed in seeds {
             let mut c = seed;
@@ -405,14 +517,15 @@ impl PointState {
                 c = [c[0] * 2.0, c[1] * 2.0];
                 let (pl, tp) = (&crop.levels[k], &self.templates[k]);
                 // Start from the projected match; neighbours must beat it (no drift on ties).
-                let mut lb = (ncc(pl, tp, c, shape), c);
-                for j in -2..=2 {
-                    for i in -2..=2 {
+                let scorer = Scorer::new(pl, tp, c, shape);
+                let mut lb = (scorer.at(0, 0), c);
+                for j in -rr..=rr {
+                    for i in -rr..=rr {
                         if i == 0 && j == 0 {
                             continue;
                         }
                         let q = [c[0] + i as f64, c[1] + j as f64];
-                        let v = ncc(pl, tp, q, shape);
+                        let v = scorer.at(i, j);
                         if v > lb.0 + 1e-9 {
                             lb = (v, q);
                         }
@@ -431,15 +544,16 @@ impl PointState {
         // Sub-pixel (and shape) refinement.
         let (mut c, mut a) = (c0, shape);
         if opts.subpixel {
+            let mut grad = Grad::around(&crop.levels[0], c0, shape, self.templates[0].r);
             let mut ok = false;
             if opts.track_shape
-                && let Some((cr, ar)) = lk_refine(&crop, &self.templates[0], c0, shape, true)
+                && let Some((cr, ar)) = lk_refine(&crop, &mut grad, &self.templates[0], c0, shape, true)
             {
                 (c, a) = (cr, ar);
                 ok = true;
             }
             if !ok {
-                if let Some((cr, _)) = lk_refine(&crop, &self.templates[0], c0, shape, false) {
+                if let Some((cr, _)) = lk_refine(&crop, &mut grad, &self.templates[0], c0, shape, false) {
                     c = cr;
                 } else {
                     c = parabolic(&crop.levels[0], &self.templates[0], c0, shape);
@@ -506,12 +620,52 @@ fn parabolic(plane: &Plane, p: &Patch, c: [f64; 2], a: [f64; 2]) -> [f64; 2] {
     [c[0] + off(f(-1.0, 0.0), f(1.0, 0.0)), c[1] + off(f(0.0, -1.0), f(0.0, 1.0))]
 }
 
+/// Level-0 gradients of a crop, computed only where `lk_refine` reads them: valid on the pixel
+/// rectangle `valid` (x0, y0, x1, y1, inclusive) and zero elsewhere.
+struct Grad {
+    gx: Plane,
+    gy: Plane,
+    valid: [isize; 4],
+}
+
+impl Grad {
+    /// Extra pixels around the first window of taps, for the drift of the refinement. A window that
+    /// still runs out is replaced by the full gradients.
+    const MARGIN: isize = 6;
+
+    fn full(plane: &Plane) -> Grad {
+        let (gx, gy) = plane.gradients();
+        Grad { gx, gy, valid: [isize::MIN, isize::MIN, isize::MAX, isize::MAX] }
+    }
+
+    fn around(plane: &Plane, c: [f64; 2], a: [f64; 2], r: [i32; 2]) -> Grad {
+        let [x0, y0, x1, y1] = Grad::taps(c, a, r);
+        let m = Grad::MARGIN;
+        let clip = |v: isize, hi: usize| v.clamp(0, (hi as isize - 1).max(0)) as usize;
+        let rect = [clip(x0 - m, plane.w), clip(y0 - m, plane.h), clip(x1 + m, plane.w), clip(y1 + m, plane.h)];
+        let (gx, gy) = plane.gradients_in(rect);
+        Grad { gx, gy, valid: rect.map(|v| v as isize) }
+    }
+
+    /// The pixels read by sampling the template window at `c` with shape `a` (bilinear taps).
+    fn taps(c: [f64; 2], a: [f64; 2], r: [i32; 2]) -> [isize; 4] {
+        let ex = (a[0].abs() * r[0] as f64 + a[1].abs() * r[1] as f64) * (1.0 + 1e-9) + 1e-9;
+        let ey = (a[1].abs() * r[0] as f64 + a[0].abs() * r[1] as f64) * (1.0 + 1e-9) + 1e-9;
+        let px = |v: f64| v.clamp(-1e9, 1e9).floor() as isize;
+        [px(c[0] - ex - 0.5), px(c[1] - ey - 0.5), px(c[0] + ex - 0.5) + 1, px(c[1] + ey - 0.5) + 1]
+    }
+
+    fn covers(&self, c: [f64; 2], a: [f64; 2], r: [i32; 2]) -> bool {
+        let t = Grad::taps(c, a, r);
+        t[0] >= self.valid[0] && t[1] >= self.valid[1] && t[2] <= self.valid[2] && t[3] <= self.valid[3]
+    }
+}
+
 /// Forward-additive Lucas–Kanade (Gauss–Newton) alignment of the level-0 template with gain and
 /// bias: minimise Σ (I(c + A u) − g T(u) − b)² over the centre `c` and, with `shape`, the
 /// similarity `A`. Returns `None` when it diverges.
-fn lk_refine(crop: &Crop, p: &Patch, c0: [f64; 2], a0: [f64; 2], shape: bool) -> Option<([f64; 2], [f64; 2])> {
+fn lk_refine(crop: &Crop, grad: &mut Grad, p: &Patch, c0: [f64; 2], a0: [f64; 2], shape: bool) -> Option<([f64; 2], [f64; 2])> {
     let plane = &crop.levels[0];
-    let (gxp, gyp) = &crop.grad0;
     let ch = p.ch;
     let (mut c, mut a) = (c0, a0);
     let mut g = 1.0f64;
@@ -546,6 +700,10 @@ fn lk_refine(crop: &Crop, p: &Patch, c0: [f64; 2], a0: [f64; 2], shape: bool) ->
     let np = if shape { 6 } else { 4 };
     let (mut v, mut vx, mut vy) = ([0.0f32; 3], [0.0f32; 3], [0.0f32; 3]);
     for _ in 0..30 {
+        if !grad.covers(c, a, p.r) {
+            *grad = Grad::full(plane);
+        }
+        let (gxp, gyp) = (&grad.gx, &grad.gy);
         let mut h = [[0.0f64; 6]; 6];
         let mut rhs = [0.0f64; 6];
         let mut k = 0;
diff --git a/crates/track/src/mask.rs b/crates/track/src/mask.rs
index e1e133409..898c80f28 100644
--- a/crates/track/src/mask.rs
+++ b/crates/track/src/mask.rs
@@ -44,6 +44,19 @@ pub fn bounds(p: &[[f64; 2]]) -> [f64; 4] {
     b
 }
 
+/// Crop `img` to `region` (layer pixels), with the layer offset of the crop's origin: the part
+/// of the frame the tracker reads. `None` when the region leaves too little of the frame.
+fn crop_region(img: &Image, off: [f64; 2], region: [f64; 4]) -> Option<(Image, [f64; 2])> {
+    let x0 = (region[0] + off[0]).floor().max(0.0) as i64;
+    let y0 = (region[1] + off[1]).floor().max(0.0) as i64;
+    let x1 = ((region[2] + off[0]).ceil() as i64).min(img.width as i64);
+    let y1 = ((region[3] + off[1]).ceil() as i64).min(img.height as i64);
+    if x1 <= x0 + 8 || y1 <= y0 + 8 {
+        return None;
+    }
+    Some((img.crop(x0, y0, (x1 - x0) as u32, (y1 - y0) as u32), [off[0] - x0 as f64, off[1] - y0 as f64]))
+}
+
 /// Mask tracker state.
 #[derive(Clone, Debug)]
 pub struct MaskTracker {
@@ -52,8 +65,8 @@ pub struct MaskTracker {
     pub outline: Vec<[f64; 2]>,
     /// The last frame-to-frame motion (a constant-velocity guess for the next frame).
     velocity: Homography,
-    prev: Option<Image>,
-    prev_offset: [f64; 2],
+    /// The previous frame cropped to the region the next step reads, with its layer offset.
+    prev: Option<(Image, [f64; 2])>,
     /// Features used on the last step (layer pixels), for display and tests.
     pub last_features: usize,
 }
@@ -72,44 +85,39 @@ pub struct MaskStep {
 impl MaskTracker {
     /// Start on `frame` with the mask `outline` (a closed polyline in layer pixels).
     pub fn new(model: Model, outline: Vec<[f64; 2]>, frame: &Frame) -> MaskTracker {
-        MaskTracker { model, outline, velocity: Homography::IDENTITY, prev: Some(frame.img.clone()), prev_offset: frame.offset, last_features: 0 }
+        let mut t = MaskTracker { model, outline, velocity: Homography::IDENTITY, prev: None, last_features: 0 };
+        t.prev = t.region().and_then(|r| crop_region(frame.img, frame.offset, r));
+        t
+    }
+
+    /// Crop region (layer pixels) of the next step: the mask plus room for its motion.
+    fn region(&self) -> Option<[f64; 4]> {
+        let b = bounds(&self.outline);
+        if !(b[0].is_finite() && b[2] > b[0] && b[3] > b[1]) {
+            return None;
+        }
+        let margin = (0.35 * (b[2] - b[0]).max(b[3] - b[1])).max(32.0);
+        Some([b[0] - margin, b[1] - margin, b[2] + margin, b[3] + margin])
     }
 
     /// Track into `frame` (the next frame in either direction). `None` when the mask's pixels
     /// can't be followed (no texture, or the mask left the frame).
     pub fn step(&mut self, frame: &Frame) -> Option<MaskStep> {
-        let prev = self.prev.take()?;
-        let res = self.step_inner(&prev, self.prev_offset, frame);
-        self.prev = Some(frame.img.clone());
-        self.prev_offset = frame.offset;
-        let r = res?;
-        self.outline = self.outline.iter().map(|p| r.motion.apply(*p)).collect();
-        self.velocity = r.motion;
-        Some(r)
+        let (ca, oa) = self.prev.take()?;
+        let res = self.step_inner(ca, oa, frame);
+        if let Some(r) = &res {
+            self.outline = self.outline.iter().map(|p| r.motion.apply(*p)).collect();
+            self.velocity = r.motion;
+        }
+        self.prev = self.region().and_then(|r| crop_region(frame.img, frame.offset, r));
+        res
     }
 
-    fn step_inner(&mut self, prev: &Image, prev_off: [f64; 2], frame: &Frame) -> Option<MaskStep> {
+    fn step_inner(&mut self, ca: Image, oa: [f64; 2], frame: &Frame) -> Option<MaskStep> {
         let b = bounds(&self.outline);
-        if !(b[0].is_finite() && b[2] > b[0] && b[3] > b[1]) {
-            return None;
-        }
         let (bw, bh) = (b[2] - b[0], b[3] - b[1]);
-        // Crop region (layer pixels): the mask plus room for its motion.
-        let margin = (0.35 * bw.max(bh)).max(32.0);
-        let (lx0, ly0, lx1, ly1) = (b[0] - margin, b[1] - margin, b[2] + margin, b[3] + margin);
-        // Both frames share one plane coordinate system: crop in the frames' image pixels.
-        let crop = |img: &Image, off: [f64; 2]| {
-            let x0 = (lx0 + off[0]).floor().max(0.0) as i64;
-            let y0 = (ly0 + off[1]).floor().max(0.0) as i64;
-            let x1 = ((lx1 + off[0]).ceil() as i64).min(img.width as i64);
-            let y1 = ((ly1 + off[1]).ceil() as i64).min(img.height as i64);
-            if x1 <= x0 + 8 || y1 <= y0 + 8 {
-                return None;
-            }
-            Some((img.crop(x0, y0, (x1 - x0) as u32, (y1 - y0) as u32), [off[0] - x0 as f64, off[1] - y0 as f64]))
-        };
-        let (ca, oa) = crop(prev, prev_off)?;
-        let (cb, ob) = crop(frame.img, frame.offset)?;
+        // Both frames share one plane coordinate system: the crops are in image pixels.
+        let (cb, ob) = crop_region(frame.img, frame.offset, self.region()?)?;
         let factor = analysis_factor(ca.width.max(cb.width), ca.height.max(cb.height), 720);
         // Pyramids must share coordinates: use a common origin (layer pixels → plane).
         let levels = 3;
@@ -219,4 +227,20 @@ mod tests {
             assert!(err < 1.5, "frame {f}: max vertex error {err}");
         }
     }
+
+    #[test]
+    fn follows_the_disk_through_a_frame_offset() {
+        let off = [40.0, -25.0];
+        let pose = |f: usize| Homography([[1.0, 0.0, 140.0 + 5.0 * f as f64], [0.0, 1.0, 110.0 - 3.0 * f as f64], [0.0, 0.0, 1.0]]);
+        let ring: Vec<[f64; 2]> = (0..24).map(|i| (i as f64 * 15.0).to_radians()).map(|a| [40.0 * a.cos(), 40.0 * a.sin()]).collect();
+        let layer = |f: usize| -> Vec<[f64; 2]> { ring.iter().map(|p| pose(f).apply(*p)).map(|q| [q[0] - off[0], q[1] - off[1]]).collect() };
+        let f0 = frame(&pose(0));
+        let mut mt = MaskTracker::new(Model::Translation, layer(0), &Frame { img: &f0, offset: off });
+        for f in 1..6 {
+            let img = frame(&pose(f));
+            mt.step(&Frame { img: &img, offset: off }).expect("tracked");
+            let err = mt.outline.iter().zip(&layer(f)).map(|(a, b)| (a[0] - b[0]).hypot(a[1] - b[1])).fold(0.0, f64::max);
+            assert!(err < 1.0, "frame {f}: max vertex error {err}");
+        }
+    }
 }
diff --git a/crates/track/src/plane.rs b/crates/track/src/plane.rs
index bd2d987d6..ff15d08b2 100644
--- a/crates/track/src/plane.rs
+++ b/crates/track/src/plane.rs
@@ -191,15 +191,32 @@ impl Plane {
 
     /// Central-difference gradients `(d/dx, d/dy)`.
     pub fn gradients(&self) -> (Plane, Plane) {
+        self.gradients_in([0, 0, self.w.saturating_sub(1), self.h.saturating_sub(1)])
+    }
+
+    /// The gradients of the pixels in `[x0, y0, x1, y1]` (inclusive, within the plane); all other
+    /// pixels of the returned planes stay zero.
+    pub fn gradients_in(&self, [x0, y0, x1, y1]: [usize; 4]) -> (Plane, Plane) {
         let mut gx = Plane::new(self.w, self.h, self.ch);
         let mut gy = Plane::new(self.w, self.h, self.ch);
-        for y in 0..self.h {
-            for x in 0..self.w {
-                for c in 0..self.ch {
-                    let (xi, yi) = (x as isize, y as isize);
-                    let i = self.idx(x, y) + c;
-                    gx.data[i] = 0.5 * (self.at(xi + 1, yi, c) - self.at(xi - 1, yi, c));
-                    gy.data[i] = 0.5 * (self.at(xi, yi + 1, c) - self.at(xi, yi - 1, c));
+        if self.w == 0 || self.h == 0 {
+            return (gx, gy);
+        }
+        let (ch, row) = (self.ch, self.w * self.ch);
+        for y in y0..=y1.min(self.h - 1) {
+            for x in x0..=x1.min(self.w - 1) {
+                let i = self.idx(x, y);
+                if x > 0 && y > 0 && x + 1 < self.w && y + 1 < self.h {
+                    for c in i..i + ch {
+                        gx.data[c] = 0.5 * (self.data[c + ch] - self.data[c - ch]);
+                        gy.data[c] = 0.5 * (self.data[c + row] - self.data[c - row]);
+                    }
+                } else {
+                    for c in 0..ch {
+                        let (xi, yi) = (x as isize, y as isize);
+                        gx.data[i + c] = 0.5 * (self.at(xi + 1, yi, c) - self.at(xi - 1, yi, c));
+                        gy.data[i + c] = 0.5 * (self.at(xi, yi + 1, c) - self.at(xi, yi - 1, c));
+                    }
                 }
             }
         }
@@ -240,4 +257,27 @@ mod tests {
         assert_eq!(Plane::from_image(&img, Channel::Saturation, 0, 0, 2, 2).data[0], 1.0);
         assert_eq!(Channel::from_name("luminance"), Some(Channel::Luminance));
     }
+
+    #[test]
+    fn gradient_window_and_interior_path_match_the_clamped_definition() {
+        let mut p = Plane::new(11, 9, 3);
+        for (i, v) in p.data.iter_mut().enumerate() {
+            *v = ((i * 7919) % 101) as f32 / 37.0;
+        }
+        let (gx, gy) = p.gradients();
+        let rect = [2, 1, 8, 6];
+        let (wx, wy) = p.gradients_in(rect);
+        for y in 0..p.h {
+            for x in 0..p.w {
+                for c in 0..3 {
+                    let (xi, yi, i) = (x as isize, y as isize, p.idx(x, y) + c);
+                    assert_eq!(gx.data[i].to_bits(), (0.5 * (p.at(xi + 1, yi, c) - p.at(xi - 1, yi, c))).to_bits());
+                    assert_eq!(gy.data[i].to_bits(), (0.5 * (p.at(xi, yi + 1, c) - p.at(xi, yi - 1, c))).to_bits());
+                    let inside = (rect[0]..=rect[2]).contains(&x) && (rect[1]..=rect[3]).contains(&y);
+                    assert_eq!(wx.data[i], if inside { gx.data[i] } else { 0.0 });
+                    assert_eq!(wy.data[i], if inside { gy.data[i] } else { 0.0 });
+                }
+            }
+        }
+    }
 }
diff --git a/crates/track/src/roto/mod.rs b/crates/track/src/roto.rs
similarity index 74%
rename from crates/track/src/roto/mod.rs
rename to crates/track/src/roto.rs
index 305065d2c..c742654e9 100644
--- a/crates/track/src/roto/mod.rs
+++ b/crates/track/src/roto.rs
@@ -31,6 +31,7 @@
 //! deterministic function of its *chain*: the base frame's strokes, then every frame's strokes
 //! on the way out to it ([`RotoData::chain_keys`]).
 
+pub mod bench;
 pub mod gmm;
 pub mod matting;
 pub mod maxflow;
@@ -87,6 +88,15 @@ pub struct Stroke {
     pub frame: i64,
     pub radius: f64,
     pub points: Vec<[f64; 2]>,
+    /// Which object of the instance the stroke belongs to (0 for the first, and for every older project).
+    /// With a tracker each object is followed on its own and the mattes are combined; the classic engine
+    /// treats all foreground strokes as one object.
+    #[serde(default, skip_serializing_if = "is_zero")]
+    pub object: u32,
+}
+
+fn is_zero(v: &u32) -> bool {
+    *v == 0
 }
 
 /// A Roto Brush instance's user data: strokes, the base frame and the segmentation span
@@ -129,6 +139,18 @@ impl RotoData {
         v.dedup();
         v
     }
+    /// The objects that have a foreground stroke, in order.
+    pub fn objects(&self) -> Vec<u32> {
+        let mut v: Vec<u32> = self.strokes.iter().filter(|s| s.kind == StrokeKind::Fg).map(|s| s.object).collect();
+        v.sort_unstable();
+        v.dedup();
+        v
+    }
+    /// The strokes of `object` on `frame`: its own foreground, background and box strokes, and the Refine Edge
+    /// strokes (which belong to the whole matte).
+    pub fn strokes_of(&self, frame: i64, object: u32) -> Vec<&Stroke> {
+        self.strokes.iter().filter(|s| s.frame == frame && (s.object == object || matches!(s.kind, StrokeKind::Refine | StrokeKind::RefineErase))).collect()
+    }
     pub fn in_span(&self, f: i64) -> bool {
         self.base.is_some() && f >= self.span[0] && f <= self.span[1]
     }
@@ -223,6 +245,26 @@ pub struct FrameSeg {
 }
 
 impl FrameSeg {
+    /// The union of several objects' segmentations of one frame (the largest keeps its colour models). The
+    /// parts must share one size; any that does not is ignored.
+    pub fn union(parts: Vec<FrameSeg>) -> FrameSeg {
+        let Some(first) = parts.first() else { return FrameSeg::default() };
+        let (w, h) = (first.w, first.h);
+        let mut parts: Vec<FrameSeg> = parts.into_iter().filter(|p| p.w == w && p.h == h && p.matte.len() == w * h).collect();
+        parts.sort_by_key(|p| std::cmp::Reverse(p.area()));
+        let mut it = parts.into_iter();
+        let Some(mut out) = it.next() else { return FrameSeg::default() };
+        for p in it {
+            for (a, b) in out.matte.iter_mut().zip(&p.matte) {
+                *a = (*a).max(*b);
+            }
+            for (a, b) in out.refine.iter_mut().zip(&p.refine) {
+                *a = (*a).max(*b);
+            }
+        }
+        out
+    }
+
     pub fn empty(w: usize, h: usize) -> FrameSeg {
         let Some(n) = w.checked_mul(h).filter(|n| *n <= rle::MAX_PLANE_BYTES) else {
             return FrameSeg::default();
@@ -339,38 +381,76 @@ pub fn rgb_of(img: &Image) -> Vec<[f32; 3]> {
     img.data.par_iter().map(|p| if p[3] > 1e-6 { [p[0] / p[3], p[1] / p[3], p[2] / p[3]] } else { [0.0; 3] }).collect()
 }
 
-/// Pixels covered by `strokes` (of the given kinds) at `scale`.
-pub fn rasterize(strokes: &[&Stroke], kinds: &[StrokeKind], scale: f64, w: usize, h: usize) -> Vec<bool> {
-    let mut m = vec![false; w * h];
-    for s in strokes.iter().filter(|s| kinds.contains(&s.kind)) {
-        let r = (s.radius * scale).max(0.5);
-        let pts: Vec<[f64; 2]> = s.points.iter().map(|p| [p[0] * scale, p[1] * scale]).collect();
-        let segs: Vec<([f64; 2], [f64; 2])> = if pts.len() == 1 { vec![(pts[0], pts[0])] } else { pts.windows(2).map(|w| (w[0], w[1])).collect() };
-        for (a, b) in segs {
-            let x0 = (a[0].min(b[0]) - r).floor().max(0.0) as usize;
-            let x1 = ((a[0].max(b[0]) + r).ceil().max(0.0) as usize).min(w);
-            let y0 = (a[1].min(b[1]) - r).floor().max(0.0) as usize;
-            let y1 = ((a[1].max(b[1]) + r).ceil().max(0.0) as usize).min(h);
-            let d = [b[0] - a[0], b[1] - a[1]];
-            let l2 = d[0] * d[0] + d[1] * d[1];
-            for y in y0..y1 {
-                for x in x0..x1 {
-                    let p = [x as f64 + 0.5, y as f64 + 0.5];
-                    let t = if l2 > 0.0 { (((p[0] - a[0]) * d[0] + (p[1] - a[1]) * d[1]) / l2).clamp(0.0, 1.0) } else { 0.0 };
-                    let q = [a[0] + d[0] * t, a[1] + d[1] * t];
-                    if (p[0] - q[0]).hypot(p[1] - q[1]) <= r {
-                        m[y * w + x] = true;
-                    }
+/// A stroke's radius and segments at `scale`.
+fn segments(s: &Stroke, scale: f64) -> (f64, Vec<([f64; 2], [f64; 2])>) {
+    let pts: Vec<[f64; 2]> = s.points.iter().map(|p| [p[0] * scale, p[1] * scale]).collect();
+    let segs = match pts.as_slice() {
+        [p] => vec![(*p, *p)],
+        _ => pts.windows(2).map(|w| (w[0], w[1])).collect(),
+    };
+    ((s.radius * scale).max(0.5), segs)
+}
+
+/// Distance from `p` to the segment `a`–`b`.
+fn segment_distance(p: [f64; 2], a: [f64; 2], b: [f64; 2]) -> f64 {
+    let d = [b[0] - a[0], b[1] - a[1]];
+    let l2 = d[0] * d[0] + d[1] * d[1];
+    let t = if l2 > 0.0 { (((p[0] - a[0]) * d[0] + (p[1] - a[1]) * d[1]) / l2).clamp(0.0, 1.0) } else { 0.0 };
+    (p[0] - a[0] - d[0] * t).hypot(p[1] - a[1] - d[1] * t)
+}
+
+/// Call `paint` with every pixel `s` covers at `scale`.
+fn sweep(s: &Stroke, scale: f64, w: usize, h: usize, mut paint: impl FnMut(usize)) {
+    let (r, segs) = segments(s, scale);
+    for (a, b) in segs {
+        let x0 = (a[0].min(b[0]) - r).floor().max(0.0) as usize;
+        let x1 = ((a[0].max(b[0]) + r).ceil().max(0.0) as usize).min(w);
+        let y0 = (a[1].min(b[1]) - r).floor().max(0.0) as usize;
+        let y1 = ((a[1].max(b[1]) + r).ceil().max(0.0) as usize).min(h);
+        for y in y0..y1 {
+            for x in x0..x1 {
+                if segment_distance([x as f64 + 0.5, y as f64 + 0.5], a, b) <= r {
+                    paint(y * w + x);
                 }
             }
         }
     }
+}
+
+/// Pixels covered by `strokes` (of the given kinds) at `scale`.
+pub fn rasterize(strokes: &[&Stroke], kinds: &[StrokeKind], scale: f64, w: usize, h: usize) -> Vec<bool> {
+    let mut m = vec![false; w * h];
+    for s in strokes.iter().filter(|s| kinds.contains(&s.kind)) {
+        sweep(s, scale, w, h, |i| m[i] = true);
+    }
     m
 }
 
-/// Hard constraints: 1 = foreground, 2 = background, 0 = free.
-const HARD_FG: u8 = 1;
-const HARD_BG: u8 = 2;
+/// What a pair of opposing strokes (add / remove) leaves on each pixel.
+const ON: u8 = 1;
+const OFF: u8 = 2;
+
+/// [`ON`] where an `on` stroke covers a pixel, [`OFF`] where an `off` stroke does, 0 elsewhere.
+/// Strokes apply in drawing order, so where they overlap the last one painted wins: a stroke
+/// corrects the ones before it.
+pub fn resolve(strokes: &[&Stroke], on: StrokeKind, off: StrokeKind, scale: f64, w: usize, h: usize) -> Vec<u8> {
+    let mut m = vec![0; w * h];
+    for s in strokes {
+        let v = if s.kind == on {
+            ON
+        } else if s.kind == off {
+            OFF
+        } else {
+            continue;
+        };
+        sweep(s, scale, w, h, |i| m[i] = v);
+    }
+    m
+}
+
+/// Hard constraints: foreground, background, else free.
+const HARD_FG: u8 = ON;
+const HARD_BG: u8 = OFF;
 
 /// Graph-cut energy weights.
 const GAMMA: f64 = 50.0;
@@ -407,7 +487,9 @@ fn beta(img: &[[f32; 3]], free: &[bool], w: usize, h: usize) -> f64 {
 
 /// One min-cut over the `free` pixels; others keep `labels`. `prior`: P(foreground) per pixel
 /// and how much it weighs against the colour models.
-fn cut(img: &[[f32; 3]], w: usize, h: usize, labels: &mut [u8], free: &[bool], hard: &[u8], fg: &Gmm, bg: &Gmm, prior: Option<(&[f32], f64)>) {
+fn cut(img: &[[f32; 3]], size: (usize, usize), labels: &mut [u8], free: &[bool], hard: &[u8], models: (&Gmm, &Gmm), prior: Option<(&[f32], f64)>) {
+    let (w, h) = size;
+    let (fg, bg) = models;
     let mut idx = vec![u32::MAX; w * h];
     let mut nodes = vec![];
     for i in 0..w * h {
@@ -622,6 +704,36 @@ pub struct Prior {
     pub weight: f64,
 }
 
+/// Fit foreground/background colour models from strokes and the propagated matte.
+fn initial_models(rgb: &[[f32; 3]], hard: &[u8], fgs: &[bool], strokes: &[&Stroke], prior: Option<&Prior>, opts: &SegOpts, size: (usize, usize)) -> (Gmm, Gmm) {
+    let (w, h) = size;
+    // Initial colour models: the strokes (and the propagated matte).
+    match prior {
+        Some(p) => {
+            let fgc = samples(rgb, |i| (hard[i] == HARD_FG) || (hard[i] == 0 && p.soft[i] >= 0.5));
+            let bgc = samples(rgb, |i| (hard[i] == HARD_BG) || (hard[i] == 0 && p.soft[i] < 0.5));
+            let f = Gmm::fit(&fgc, COMPONENTS, MAX_SAMPLES);
+            let b = Gmm::fit(&bgc, COMPONENTS, MAX_SAMPLES);
+            (if f.is_empty() { p.fg.clone() } else { f }, if b.is_empty() { p.bg.clone() } else { b })
+        }
+        None => {
+            let fgc = samples(rgb, |i| hard[i] == HARD_FG);
+            let mut bgc = samples(rgb, |i| hard[i] == HARD_BG);
+            if bgc.is_empty() {
+                // No background strokes: what is far from the foreground strokes.
+                let d = matting::distance(fgs, w, h);
+                let r = strokes.iter().filter(|s| s.kind == StrokeKind::Fg).map(|s| s.radius).fold(1.0, f64::max) * opts.scale;
+                let far = (4.0 * r).max(0.25 * w.max(h) as f64) as f32;
+                bgc = samples(rgb, |i| d[i] > far);
+                if bgc.is_empty() {
+                    bgc = samples(rgb, |i| hard[i] != HARD_FG);
+                }
+            }
+            (Gmm::fit(&fgc, COMPONENTS, MAX_SAMPLES), Gmm::fit(&bgc, COMPONENTS, MAX_SAMPLES))
+        }
+    }
+}
+
 /// Segment a frame from its strokes (and a propagated prior): GrabCut iterations on a reduced
 /// copy, then a full-resolution cut in a band around the boundary.
 pub fn segment(img: &Image, strokes: &[&Stroke], prior: Option<&Prior>, opts: &SegOpts, refine_radius: f64) -> FrameSeg {
@@ -630,50 +742,14 @@ pub fn segment(img: &Image, strokes: &[&Stroke], prior: Option<&Prior>, opts: &S
         return FrameSeg::empty(w, h);
     }
     let rgb = rgb_of(img);
-    let fgs = rasterize(strokes, &[StrokeKind::Fg], opts.scale, w, h);
-    let bgs = rasterize(strokes, &[StrokeKind::Bg], opts.scale, w, h);
-    let hard: Vec<u8> = fgs
-        .iter()
-        .zip(&bgs)
-        .map(|(f, b)| {
-            if *b {
-                HARD_BG
-            } else if *f {
-                HARD_FG
-            } else {
-                0
-            }
-        })
-        .collect();
+    let hard = resolve(strokes, StrokeKind::Fg, StrokeKind::Bg, opts.scale, w, h);
+    let fgs: Vec<bool> = hard.iter().map(|v| *v == HARD_FG).collect();
+    let bgs: Vec<bool> = hard.iter().map(|v| *v == HARD_BG).collect();
     // A warped matte is uncertain by about the search radius: blur it. A model's matte is not.
     let soft_prior: Option<Vec<f32>> =
         prior.map(|p| if p.weight > PRIOR { p.soft.clone() } else { matting::gauss(&p.soft, w, h, (opts.search_radius * opts.scale / 4.0).max(1.0)) });
     let pw = prior.map_or(PRIOR, |p| p.weight);
-    // Initial colour models: the strokes (and the propagated matte).
-    let (fg0, bg0) = match prior {
-        Some(p) => {
-            let fgc = samples(&rgb, |i| (hard[i] == HARD_FG) || (hard[i] == 0 && p.soft[i] >= 0.5));
-            let bgc = samples(&rgb, |i| (hard[i] == HARD_BG) || (hard[i] == 0 && p.soft[i] < 0.5));
-            let f = Gmm::fit(&fgc, COMPONENTS, MAX_SAMPLES);
-            let b = Gmm::fit(&bgc, COMPONENTS, MAX_SAMPLES);
-            (if f.is_empty() { p.fg.clone() } else { f }, if b.is_empty() { p.bg.clone() } else { b })
-        }
-        None => {
-            let fgc = samples(&rgb, |i| hard[i] == HARD_FG);
-            let mut bgc = samples(&rgb, |i| hard[i] == HARD_BG);
-            if bgc.is_empty() {
-                // No background strokes: what is far from the foreground strokes.
-                let d = matting::distance(&fgs, w, h);
-                let r = strokes.iter().filter(|s| s.kind == StrokeKind::Fg).map(|s| s.radius).fold(1.0, f64::max) * opts.scale;
-                let far = (4.0 * r).max(0.25 * w.max(h) as f64) as f32;
-                bgc = samples(&rgb, |i| d[i] > far);
-                if bgc.is_empty() {
-                    bgc = samples(&rgb, |i| hard[i] != HARD_FG);
-                }
-            }
-            (Gmm::fit(&fgc, COMPONENTS, MAX_SAMPLES), Gmm::fit(&bgc, COMPONENTS, MAX_SAMPLES))
-        }
-    };
+    let (fg0, bg0) = initial_models(&rgb, &hard, &fgs, strokes, prior, opts, (w, h));
     let iters = if opts.best { 4 } else { 3 };
     let work = if opts.best { 960 } else { 480 };
     let f = w.max(h).div_ceil(work).max(1);
@@ -721,7 +797,7 @@ pub fn segment(img: &Image, strokes: &[&Stroke], prior: Option<&Prior>, opts: &S
         };
         let free = vec![true; cw * ch];
         for it in 0..iters {
-            cut(&crgb, cw, ch, &mut cl, &free, &chard, &fgm, &bgm, cprior.as_deref().map(|c| (c, pw)));
+            cut(&crgb, (cw, ch), &mut cl, &free, &chard, (&fgm, &bgm), cprior.as_deref().map(|c| (c, pw)));
             if it + 1 < iters {
                 let (a, b) = fit_models(&crgb, &cl);
                 if !a.is_empty() && !b.is_empty() {
@@ -743,11 +819,11 @@ pub fn segment(img: &Image, strokes: &[&Stroke], prior: Option<&Prior>, opts: &S
         let sd = matting::signed_distance(&labels, w, h);
         let band = f as f32 + 1.5;
         let free: Vec<bool> = sd.iter().map(|d| d.abs() <= band).collect();
-        cut(&rgb, w, h, &mut labels, &free, &hard, &fgm, &bgm, soft_prior.as_deref().map(|c| (c, pw)));
+        cut(&rgb, (w, h), &mut labels, &free, &hard, (&fgm, &bgm), soft_prior.as_deref().map(|c| (c, pw)));
     } else {
         let free = vec![true; w * h];
         for it in 0..iters {
-            cut(&rgb, w, h, &mut labels, &free, &hard, &fgm, &bgm, soft_prior.as_deref().map(|c| (c, pw)));
+            cut(&rgb, (w, h), &mut labels, &free, &hard, (&fgm, &bgm), soft_prior.as_deref().map(|c| (c, pw)));
             if it + 1 < iters {
                 let (a, b) = fit_models(&rgb, &labels);
                 if !a.is_empty() && !b.is_empty() {
@@ -780,8 +856,7 @@ fn core_of(soft: &[f32], w: usize, h: usize, r: f64) -> Vec<bool> {
 fn finish(_img: &Image, rgb: &[[f32; 3]], labels: Vec<u8>, strokes: &[&Stroke], warped_refine: Option<&[u8]>, opts: &SegOpts, refine_radius: f64) -> FrameSeg {
     let (w, h) = (_img.width as usize, _img.height as usize);
     let (fg, bg) = fit_models(rgb, &labels);
-    let add = rasterize(strokes, &[StrokeKind::Refine], opts.scale, w, h);
-    let erase = rasterize(strokes, &[StrokeKind::RefineErase], opts.scale, w, h);
+    let painted = resolve(strokes, StrokeKind::Refine, StrokeKind::RefineErase, opts.scale, w, h);
     let near: Option<Vec<f32>> = warped_refine.filter(|r| r.iter().any(|v| *v != 0)).map(|_| matting::signed_distance(&labels, w, h));
     let rr = (refine_radius * opts.scale + 2.0) as f32;
     let refine: Vec<u8> = (0..w * h)
@@ -790,7 +865,7 @@ fn finish(_img: &Image, rgb: &[[f32; 3]], labels: Vec<u8>, strokes: &[&Stroke],
                 (Some(r), Some(sd)) => r[i] != 0 && sd[i].abs() <= rr,
                 _ => false,
             };
-            ((carried || add[i]) && !erase[i]) as u8
+            ((carried && painted[i] != OFF) || painted[i] == ON) as u8
         })
         .collect();
     FrameSeg { w, h, matte: labels, refine, fg, bg }
@@ -843,7 +918,7 @@ pub fn propagate(prev_img: &Image, prev: &FrameSeg, next_img: &Image, strokes: &
     let hard = vec![0u8; w * h];
     let soft = matting::gauss(&prior.soft, w, h, (r as f64 / 4.0).max(1.0));
     let (fg, bg) = if prev.fg.is_empty() || prev.bg.is_empty() { fit_models(&rgb, &labels) } else { (prev.fg.clone(), prev.bg.clone()) };
-    cut(&rgb, w, h, &mut labels, &free, &hard, &fg, &bg, Some((&soft, PRIOR)));
+    cut(&rgb, (w, h), &mut labels, &free, &hard, (&fg, &bg), Some((&soft, PRIOR)));
     let seeds = core_of(&prior.soft, w, h, r as f64);
     clean(&mut labels, &seeds, &vec![false; w * h], w, h);
     finish(next_img, &rgb, labels, strokes, Some(&prior.refine), opts, refine_radius)
@@ -869,21 +944,130 @@ fn points_along(s: &Stroke, scale: f64, max: usize) -> Vec<[f32; 2]> {
     out
 }
 
-/// A model's prompt from the strokes: points along the foreground and background strokes, and
-/// the box of a [`StrokeKind::Box`] stroke (matte pixels).
-pub fn stroke_prompt(strokes: &[&Stroke], scale: f64) -> Prompt {
+/// A tracker's prompt from a frame's strokes (points along the foreground and background strokes,
+/// in frame pixels at `scale`).
+///
+/// SAM 2 was trained on a handful of clicks: with sixteen or more points it doubts its own mask
+/// (measured: confidence 0.25 with 16 points, 0.00 with 32, 0.99 with 1 to 7), so this picks at
+/// most [`TRACKER_FG_POINTS`] foreground and [`TRACKER_BG_POINTS`] background points, spread
+/// along the strokes. Like [`stroke_prompt`], later corrections win over earlier paint.
+pub fn tracker_prompt(strokes: &[&Stroke], scale: f64, w: usize, h: usize) -> Prompt {
+    let hard = resolve(strokes, StrokeKind::Fg, StrokeKind::Bg, scale, w, h);
+    let prompt = stroke_prompt(strokes, &hard, scale, w, h);
     let mut points = vec![];
-    for (kind, fg) in [(StrokeKind::Fg, true), (StrokeKind::Bg, false)] {
+    for (fg, max) in [(true, TRACKER_FG_POINTS), (false, TRACKER_BG_POINTS)] {
+        let all: Vec<[f32; 2]> = prompt.points.iter().filter_map(|(p, label)| (*label == fg).then_some(*p)).collect();
+        let n = all.len().min(max);
+        // evenly spaced picks, keeping the first and the last
+        points.extend((0..n).filter_map(|i| all.get(if n > 1 { i * (all.len() - 1) / (n - 1) } else { all.len() / 2 }).map(|p| (*p, fg))));
+    }
+    Prompt { points, ..prompt }
+}
+
+/// [`tracker_prompt`] plus a box around the classic engine's matte of the same strokes. Clicks alone
+/// make SAM 2 pick the part they land on (a torso, not the legs and shoes: measured IoU 0.41 on a
+/// multi-part figure, against 1.00 with the box); the box says how far the object reaches. A box
+/// stroke the user drew wins over the matte's.
+pub fn tracker_prompt_boxed(strokes: &[&Stroke], scale: f64, classic: &FrameSeg) -> Prompt {
+    let mut p = tracker_prompt(strokes, scale, classic.w, classic.h);
+    if p.bbox.is_none() {
+        let (w, h) = (classic.w, classic.h);
+        let (mut x0, mut y0, mut x1, mut y1) = (usize::MAX, usize::MAX, 0usize, 0usize);
+        for (i, v) in classic.matte.iter().enumerate() {
+            if *v != 0 && w > 0 {
+                let (x, y) = (i % w, i / w);
+                (x0, y0, x1, y1) = (x0.min(x), y0.min(y), x1.max(x), y1.max(y));
+            }
+        }
+        if x0 <= x1 {
+            let (mx, my) = (((x1 - x0) as f32 * 0.05).max(4.0), ((y1 - y0) as f32 * 0.05).max(4.0));
+            p.bbox = Some([(x0 as f32 - mx).max(0.0), (y0 as f32 - my).max(0.0), (x1 as f32 + 1.0 + mx).min(w as f32), (y1 as f32 + 1.0 + my).min(h as f32)]);
+        }
+    }
+    p
+}
+
+/// Most foreground / background points a tracker prompt carries.
+pub const TRACKER_FG_POINTS: usize = 3;
+pub const TRACKER_BG_POINTS: usize = 3;
+
+/// A frame's segmentation from a tracker's probability map: the map is the shape prior of the
+/// same graph cut as everywhere else, so the strokes stay hard constraints and the edges snap
+/// to colour. An absent object gives an empty matte (strokes on the frame still win); a map of
+/// the wrong size is ignored.
+pub fn segment_tracked(img: &Image, strokes: &[&Stroke], prob: Vec<f32>, occluded: bool, opts: &SegOpts, refine_radius: f64) -> FrameSeg {
+    let (w, h) = (img.width as usize, img.height as usize);
+    if prob.len() != w * h || w == 0 || h == 0 {
+        return segment(img, strokes, None, opts, refine_radius);
+    }
+    let has_fg = strokes.iter().any(|s| s.kind == StrokeKind::Fg);
+    if (occluded || !prob.iter().any(|p| *p >= 0.5)) && !has_fg {
+        return FrameSeg::empty(w, h);
+    }
+    let prior = Prior { soft: prob, fg: Gmm::default(), bg: Gmm::default(), refine: vec![0; w * h], weight: MODEL_PRIOR };
+    segment(img, strokes, Some(&prior), opts, refine_radius)
+}
+
+/// A model's prompt from the strokes: points along the foreground and background strokes, but
+/// not where a later stroke of the other kind painted over them (`hard`, from [`resolve`]), and
+/// the box of a [`StrokeKind::Box`] stroke (matte pixels). A stroke painted over at every point
+/// sampled along it, but not everywhere, is prompted from the middle of what is left of it.
+pub fn stroke_prompt(strokes: &[&Stroke], hard: &[u8], scale: f64, w: usize, h: usize) -> Prompt {
+    let mut points = vec![];
+    for (kind, own, other) in [(StrokeKind::Fg, HARD_FG, HARD_BG), (StrokeKind::Bg, HARD_BG, HARD_FG)] {
         let ss: Vec<&&Stroke> = strokes.iter().filter(|s| s.kind == kind).collect();
         let per = (16 / ss.len().max(1)).max(1);
         for s in ss {
-            points.extend(points_along(s, scale, per).into_iter().map(|p| (p, fg)));
+            let along = points_along(s, scale, per);
+            let mut kept: Vec<[f32; 2]> = along.iter().copied().filter(|p| owner(hard, w, h, *p) != Some(other)).collect();
+            if kept.is_empty() && !along.is_empty() {
+                kept.extend(deepest_owned(s, hard, own, scale, w, h));
+            }
+            points.extend(kept.into_iter().map(|p| (p, kind == StrokeKind::Fg)));
         }
     }
     let bbox = strokes.iter().filter(|s| s.kind == StrokeKind::Box).find_map(|s| box_of(s, scale));
     Prompt { points, bbox, ..Default::default() }
 }
 
+/// The value of `hard` under the point `p` (`None` outside the frame).
+fn owner(hard: &[u8], w: usize, h: usize, p: [f32; 2]) -> Option<u8> {
+    if !(p[0] >= 0.0 && p[1] >= 0.0) {
+        return None;
+    }
+    let (x, y) = (p[0] as usize, p[1] as usize);
+    if x >= w || y >= h {
+        return None;
+    }
+    hard.get(y * w + x).copied()
+}
+
+/// The centre of the pixel deepest inside what `s` still owns (where `hard` is `own` under it),
+/// if anything.
+fn deepest_owned(s: &Stroke, hard: &[u8], own: u8, scale: f64, w: usize, h: usize) -> Option<[f32; 2]> {
+    let mut owned = vec![];
+    sweep(s, scale, w, h, |i| {
+        if hard.get(i) == Some(&own) {
+            owned.push((i % w, i / w));
+        }
+    });
+    let (x0, x1) = (owned.iter().map(|p| p.0).min()?, owned.iter().map(|p| p.0).max()?);
+    let (y0, y1) = (owned.iter().map(|p| p.1).min()?, owned.iter().map(|p| p.1).max()?);
+    // One pixel of margin all round, so depth is measured to the nearest pixel it doesn't own.
+    let (cw, ch) = (x1 - x0 + 3, y1 - y0 + 3);
+    let at = |(x, y): (usize, usize)| (y - y0 + 1) * cw + (x - x0 + 1);
+    let mut free = vec![true; cw * ch];
+    for p in &owned {
+        if let Some(v) = free.get_mut(at(*p)) {
+            *v = false;
+        }
+    }
+    let depth = matting::distance(&free, cw, ch);
+    let d = |p: &(usize, usize)| depth.get(at(*p)).copied().unwrap_or(0.0);
+    let (x, y) = owned.iter().copied().max_by(|a, b| d(a).total_cmp(&d(b)))?;
+    Some([x as f32 + 0.5, y as f32 + 0.5])
+}
+
 /// The box `[x0, y0, x1, y1]` (matte pixels) of a box stroke: its first two points as opposite
 /// corners; `None` when they are missing, not finite or the box is empty.
 fn box_of(s: &Stroke, scale: f64) -> Option<[f32; 4]> {
@@ -893,8 +1077,18 @@ fn box_of(s: &Stroke, scale: f64) -> Option<[f32; 4]> {
 }
 
 /// Add a prior matte to a prompt: its box (a little larger; unless the prompt has one), up to
-/// four points spread through its core, and the matte itself.
-fn add_prior_prompt(prompt: &mut Prompt, soft: &[f32], w: usize, h: usize) -> bool {
+/// four points spread through its core, and the matte itself, all with this frame's strokes
+/// (`hard`, from [`resolve`]) painted over it.
+fn add_prior_prompt(prompt: &mut Prompt, soft: &[f32], hard: &[u8], w: usize, h: usize) -> bool {
+    let soft: Vec<f32> = soft
+        .iter()
+        .enumerate()
+        .map(|(i, v)| match hard.get(i) {
+            Some(&HARD_FG) => 1.0,
+            Some(&HARD_BG) => 0.0,
+            _ => *v,
+        })
+        .collect();
     let bin: Vec<u8> = soft.iter().map(|v| (*v >= 0.5) as u8).collect();
     let (mut x0, mut y0, mut x1, mut y1) = (usize::MAX, usize::MAX, 0usize, 0usize);
     for (i, v) in bin.iter().enumerate() {
@@ -924,7 +1118,7 @@ fn add_prior_prompt(prompt: &mut Prompt, soft: &[f32], w: usize, h: usize) -> bo
         }
     }
     prompt.points.extend(picks.into_iter().map(|i| ([(i % w) as f32 + 0.5, (i / w) as f32 + 0.5], true)));
-    prompt.mask = Some(soft.to_vec());
+    prompt.mask = Some(soft);
     true
 }
 
@@ -933,9 +1127,10 @@ fn add_prior_prompt(prompt: &mut Prompt, soft: &[f32], w: usize, h: usize) -> bo
 pub fn segment_with(img: &Image, strokes: &[&Stroke], prior: Option<&Prior>, opts: &SegOpts, refine_radius: f64, model: Option<&dyn MaskModel>) -> FrameSeg {
     let (w, h) = (img.width as usize, img.height as usize);
     let Some(m) = model.filter(|_| w > 0 && h > 0) else { return segment(img, strokes, prior, opts, refine_radius) };
-    let mut prompt = stroke_prompt(strokes, opts.scale);
+    let hard = resolve(strokes, StrokeKind::Fg, StrokeKind::Bg, opts.scale, w, h);
+    let mut prompt = stroke_prompt(strokes, &hard, opts.scale, w, h);
     if let Some(p) = prior {
-        add_prior_prompt(&mut prompt, &p.soft, w, h);
+        add_prior_prompt(&mut prompt, &p.soft, &hard, w, h);
     }
     if !prompt.points.iter().any(|(_, fg)| *fg) {
         return segment(img, strokes, prior, opts, refine_radius);
@@ -965,8 +1160,9 @@ pub fn propagate_with(
     let (w, h) = (next_img.width as usize, next_img.height as usize);
     let Some(m) = model.filter(|_| w > 0 && h > 0) else { return propagate(prev_img, prev, next_img, strokes, opts, refine_radius) };
     let prior = warp_prior(prev_img, prev, next_img, opts);
-    let mut prompt = stroke_prompt(strokes, opts.scale);
-    if !add_prior_prompt(&mut prompt, &prior.soft, w, h) {
+    let hard = resolve(strokes, StrokeKind::Fg, StrokeKind::Bg, opts.scale, w, h);
+    let mut prompt = stroke_prompt(strokes, &hard, opts.scale, w, h);
+    if !add_prior_prompt(&mut prompt, &prior.soft, &hard, w, h) {
         return propagate(prev_img, prev, next_img, strokes, opts, refine_radius);
     }
     match m.segment(&rgb_of(next_img), w, h, &prompt) {
diff --git a/crates/track/src/roto/bench.rs b/crates/track/src/roto/bench.rs
new file mode 100644
index 000000000..98ada3903
--- /dev/null
+++ b/crates/track/src/roto/bench.rs
@@ -0,0 +1,447 @@
+//! Roto Brush benchmark: synthetic clips with known mattes (movement, colour change, occlusion,
+//! leaving and re-entering the frame) and the metrics that compare trackers on them.
+//!
+//! Needs no weights: the classical engine always runs, and a trained [`MaskModel`] (MobileSAM,
+//! later SAM 2) is added when the caller has one. `effectcraft-cli bench --roto` prints the table.
+
+use effectcraft_raster::Image;
+use std::sync::Arc;
+
+use effectcraft_segment::{ClipFrame, MaskModel, TrackRequest};
+use serde::Serialize;
+use web_time::Instant;
+
+use super::{FrameSeg, SegOpts, Stroke, StrokeKind, iou, propagate_with, rgb_of, segment_tracked, segment_with, tracker_prompt_boxed};
+
+pub const W: u32 = 200;
+pub const H: u32 = 150;
+const R: f64 = 32.0;
+
+/// A clip with the true matte of the visible object on every frame.
+#[derive(Clone)]
+pub struct Scenario {
+    pub name: String,
+    pub what: String,
+    /// Frame size in pixels (the synthetic clips are `W × H`; a real clip has its own).
+    pub w: usize,
+    pub h: usize,
+    pub frames: Vec<Image>,
+    /// Visible-object matte per frame (`w × h`, 0/1); empty when the object is out of view.
+    pub truth: Vec<Vec<u8>>,
+    /// Frame the strokes are painted on.
+    pub base: usize,
+    pub strokes: Vec<Stroke>,
+}
+
+/// One tracker's result on one scenario.
+#[derive(Clone, Debug, Serialize)]
+pub struct Run {
+    pub scenario: String,
+    pub tracker: String,
+    pub mean_iou: f64,
+    pub min_iou: f64,
+    /// Mean IoU between consecutive mattes minus the same for the truth, as a loss (0 is steady).
+    pub flicker: f64,
+    pub secs_per_frame: f64,
+    /// Mean IoU over the frames after the object's last absence (re-appearance), if it had one.
+    pub after_return: Option<f64>,
+    pub per_frame: Vec<f64>,
+    /// Correction rounds needed before every frame reaches the target IoU (`>N`: not within N); set by
+    /// [`with_fixes`], `None` when not measured.
+    pub fixes: Option<String>,
+    /// The most memory (MB) the tracker held for its memory banks and cached frames (trackers that have none: `None`).
+    pub peak_mb: Option<f64>,
+    /// The matte of every frame (not serialised).
+    #[serde(skip)]
+    pub mattes: Vec<Vec<u8>>,
+}
+
+fn noise(x: f64, y: f64, seed: u32) -> f64 {
+    fn h(i: i64, j: i64, s: u32) -> f64 {
+        let mut v = (i.wrapping_mul(73856093) ^ j.wrapping_mul(19349663) ^ i64::from(s).wrapping_mul(83492791)) as u64;
+        v ^= v >> 13;
+        v = v.wrapping_mul(0x5bd1e995);
+        v ^= v >> 15;
+        (v % 10_000) as f64 / 10_000.0
+    }
+    let mut out = 0.0;
+    for (cell, amp) in [(9.0, 0.6), (3.5, 0.4)] {
+        let (fx, fy) = (x / cell, y / cell);
+        let (i, j) = (fx.floor() as i64, fy.floor() as i64);
+        let (tx, ty) = (fx - i as f64, fy - j as f64);
+        let (sx, sy) = (tx * tx * (3.0 - 2.0 * tx), ty * ty * (3.0 - 2.0 * ty));
+        let a = h(i, j, seed) + (h(i + 1, j, seed) - h(i, j, seed)) * sx;
+        let b = h(i, j + 1, seed) + (h(i + 1, j + 1, seed) - h(i, j + 1, seed)) * sx;
+        out += amp * (a + (b - a) * sy);
+    }
+    out
+}
+
+/// What a frame shows: the disk centre, an optional occluding bar `[x0, y0, x1, y1]` and a
+/// brightness gain applied to the whole frame.
+#[derive(Clone, Copy)]
+struct Look {
+    c: [f64; 2],
+    bar: Option<[f64; 4]>,
+    gain: f32,
+}
+
+fn render(l: Look) -> (Image, Vec<u8>) {
+    let mut img = Image::new(W, H);
+    let mut gt = vec![0u8; (W * H) as usize];
+    for y in 0..H {
+        for x in 0..W {
+            let p = [f64::from(x) + 0.5, f64::from(y) + 0.5];
+            let d = (p[0] - l.c[0]).hypot(p[1] - l.c[1]);
+            let a = (R + 0.5 - d).clamp(0.0, 1.0) as f32;
+            let n = noise(p[0] - l.c[0], p[1] - l.c[1], 11);
+            let f = [(0.75 + 0.25 * n) as f32, (0.35 + 0.3 * n) as f32, (0.1 + 0.15 * n) as f32];
+            let (bn, bm) = (noise(p[0], p[1], 5), noise(p[0] * 1.7, p[1] * 1.7, 9));
+            let b = [(0.05 + 0.25 * bm) as f32, (0.3 + 0.4 * bn) as f32, (0.45 + 0.4 * bm) as f32];
+            let mut px = [0.0f32; 3];
+            for k in 0..3 {
+                px[k] = f[k] * a + b[k] * (1.0 - a);
+            }
+            let under_bar = l.bar.is_some_and(|r| p[0] >= r[0] && p[0] < r[2] && p[1] >= r[1] && p[1] < r[3]);
+            if under_bar {
+                let t = noise(p[0] * 0.8, p[1] * 0.8, 23) as f32;
+                px = [0.15 + 0.1 * t, 0.15 + 0.1 * t, 0.2 + 0.1 * t];
+            }
+            let g = l.gain;
+            img.set(x, y, [(px[0] * g).min(1.0), (px[1] * g).min(1.0), (px[2] * g).min(1.0), 1.0]);
+            if let Some(v) = gt.get_mut((y * W + x) as usize) {
+                *v = (d <= R && !under_bar) as u8;
+            }
+        }
+    }
+    (img, gt)
+}
+
+fn line(kind: StrokeKind, frame: i64, a: [f64; 2], b: [f64; 2], radius: f64) -> Stroke {
+    let pt = |k: u32| {
+        let t = f64::from(k) / 10.0;
+        [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
+    };
+    Stroke { kind, frame, radius, points: (0..=10).map(pt).collect(), object: 0 }
+}
+
+/// The strokes an artist would paint on the base frame: one through the disk, two around it.
+fn strokes_for(c: [f64; 2]) -> Vec<Stroke> {
+    vec![
+        line(StrokeKind::Fg, 0, [c[0] - 18.0, c[1] - 6.0], [c[0] + 18.0, c[1] + 6.0], 5.0),
+        line(StrokeKind::Bg, 0, [c[0] - 50.0, c[1] - 45.0], [c[0] + 50.0, c[1] - 45.0], 5.0),
+        line(StrokeKind::Bg, 0, [c[0] + 50.0, c[1] + 45.0], [c[0] - 45.0, c[1] + 45.0], 5.0),
+    ]
+}
+
+fn scenario(name: &'static str, what: &'static str, n: usize, look: impl Fn(usize) -> Look) -> Scenario {
+    let (mut frames, mut truth) = (Vec::with_capacity(n), Vec::with_capacity(n));
+    for f in 0..n {
+        let (img, gt) = render(look(f));
+        frames.push(img);
+        truth.push(gt);
+    }
+    Scenario { name: name.to_string(), what: what.to_string(), w: W as usize, h: H as usize, frames, truth, base: 0, strokes: strokes_for(look(0).c) }
+}
+
+/// A scenario from the user's own clip: frames and their true mattes (0/1, same size as the frames). The strokes
+/// are made from the first frame with an object: a short foreground stroke through its centre and background
+/// strokes along the top and bottom edges where the truth is empty. Nothing is bundled: the clip stays with the
+/// user (a licensed dataset, say), and so does its licence.
+pub fn scenario_from(name: &str, frames: Vec<Image>, truth: Vec<Vec<u8>>) -> std::result::Result<Scenario, String> {
+    let first = frames.first().ok_or("a clip needs at least one frame")?;
+    let (w, h) = (first.width as usize, first.height as usize);
+    if w == 0
+        || h == 0
+        || frames.len() != truth.len()
+        || frames.iter().any(|f| (f.width as usize, f.height as usize) != (w, h))
+        || truth.iter().any(|t| t.len() != w * h)
+    {
+        return Err("frames and truth masks must be the same size and count".into());
+    }
+    let base = truth.iter().position(|t| t.iter().any(|v| *v != 0)).ok_or("no frame has the object in its truth mask")?;
+    let t = truth.get(base).map(Vec::as_slice).unwrap_or(&[]);
+    let (mut x0, mut x1, mut sx, mut sy, mut n) = (usize::MAX, 0usize, 0.0f64, 0.0f64, 0.0f64);
+    for i in t.iter().enumerate().filter(|(_, v)| **v != 0).map(|(i, _)| i) {
+        let (x, y) = (i % w, i / w);
+        (x0, x1) = (x0.min(x), x1.max(x));
+        sx += x as f64 + 0.5;
+        sy += y as f64 + 0.5;
+        n += 1.0;
+    }
+    let (cx, cy) = (sx / n, sy / n);
+    let reach = (((x1 - x0) as f64) * 0.15).max(2.0);
+    let radius = ((w.min(h) as f64) * 0.03).max(3.0);
+    let mut strokes = vec![line(StrokeKind::Fg, base as i64, [cx - reach, cy], [cx + reach, cy], radius)];
+    for y in [h as f64 * 0.04, h as f64 * 0.96] {
+        let row = y as usize;
+        let free = t.get(row * w..(row + 1) * w).is_some_and(|r| r.iter().all(|v| *v == 0));
+        if free {
+            strokes.push(line(StrokeKind::Bg, base as i64, [w as f64 * 0.05, y], [w as f64 * 0.95, y], radius));
+        }
+    }
+    Ok(Scenario { name: name.to_string(), what: "a clip supplied by the user".to_string(), w, h, frames, truth, base, strokes })
+}
+
+/// The benchmark clips, `n` frames each (at least 12, so every event happens).
+pub fn scenarios(n: usize) -> Vec<Scenario> {
+    let n = n.clamp(12, 240);
+    let k = n as f64 / 24.0;
+    let drift = move |f: usize| {
+        let t = f as f64 / k;
+        [60.0 + 3.1 * t, 70.0 + 1.3 * t + 4.0 * (t * 0.3).sin()]
+    };
+    vec![
+        scenario("move", "disk drifts across a textured background", n, move |f| Look { c: drift(f), bar: None, gain: 1.0 }),
+        scenario("light", "same motion while the whole frame brightens by 40 %", n, move |f| Look {
+            c: drift(f),
+            bar: None,
+            gain: 1.0 + 0.4 * f as f32 / n as f32,
+        }),
+        scenario("occlusion", "a bar crosses and hides most of the disk, then clears it", n, move |f| {
+            let t = f as f64 / n as f64;
+            let c = drift(f);
+            let x = -40.0 + 320.0 * ((t - 0.3) / 0.4).clamp(0.0, 1.0);
+            Look { c, bar: (0.3..0.7).contains(&t).then_some([x - 40.0, 0.0, x + 40.0, f64::from(H)]), gain: 1.0 }
+        }),
+        scenario("reenter", "disk leaves through the right edge and comes back", n, move |f| {
+            let t = f as f64 / n as f64;
+            let x = 60.0 + 190.0 * (1.0 - (2.0 * t - 1.0).powi(2));
+            Look { c: [x, 70.0 + 4.0 * (t * 6.0).sin()], bar: None, gain: 1.0 }
+        }),
+    ]
+}
+
+fn metrics(sc: &Scenario, tracker: &str, mattes: &[Vec<u8>], secs: f64) -> Run {
+    let per_frame: Vec<f64> = mattes.iter().zip(&sc.truth).map(|(m, t)| iou(m, t)).collect();
+    let n = per_frame.len().max(1) as f64;
+    let steady = |v: &[Vec<u8>]| {
+        let pairs: Vec<f64> = v.windows(2).filter_map(|w| Some(iou(w.first()?, w.get(1)?))).collect();
+        pairs.iter().sum::<f64>() / pairs.len().max(1) as f64
+    };
+    let last_gap = sc.truth.iter().rposition(|t| t.iter().all(|v| *v == 0));
+    let after_return = last_gap.and_then(|g| {
+        let tail = per_frame.get(g + 1..)?;
+        (!tail.is_empty()).then(|| tail.iter().sum::<f64>() / tail.len() as f64)
+    });
+    Run {
+        scenario: sc.name.clone(),
+        tracker: tracker.to_string(),
+        mean_iou: per_frame.iter().sum::<f64>() / n,
+        min_iou: per_frame.iter().copied().fold(1.0, f64::min),
+        flicker: (steady(&sc.truth) - steady(mattes)).max(0.0),
+        secs_per_frame: secs / n,
+        after_return,
+        per_frame,
+        fixes: None,
+        peak_mb: None,
+        mattes: mattes.to_vec(),
+    }
+}
+
+/// Segment the base frame from the strokes and propagate to the end of the clip, as the Roto
+/// Brush does, with `model` (or none: the classical engine).
+pub fn run_flow(sc: &Scenario, tracker: &str, model: Option<&dyn MaskModel>) -> Run {
+    let opts = SegOpts::default();
+    let start = Instant::now();
+    let refs: Vec<&Stroke> = sc.strokes.iter().filter(|s| s.frame == sc.base as i64).collect();
+    let mut segs: Vec<Option<FrameSeg>> = vec![None; sc.frames.len()];
+    if let Some(first) = sc.frames.get(sc.base) {
+        let base = segment_with(first, &refs, None, &opts, 0.0, model);
+        if let Some(slot) = segs.get_mut(sc.base) {
+            *slot = Some(base);
+        }
+    }
+    for f in sc.base + 1..sc.frames.len() {
+        let (Some(prev_img), Some(img)) = (sc.frames.get(f - 1), sc.frames.get(f)) else { break };
+        let Some(Some(prev)) = segs.get(f - 1) else { break };
+        let here: Vec<&Stroke> = sc.strokes.iter().filter(|s| s.frame == f as i64).collect();
+        let next = propagate_with(prev_img, prev, img, &here, &opts, 0.0, model);
+        if let Some(slot) = segs.get_mut(f) {
+            *slot = Some(next);
+        }
+    }
+    let secs = start.elapsed().as_secs_f64();
+    let empty = vec![0u8; sc.w * sc.h];
+    let mattes: Vec<Vec<u8>> = segs.into_iter().map(|s| s.map_or_else(|| empty.clone(), |s| s.matte)).collect();
+    metrics(sc, tracker, &mattes, secs)
+}
+
+/// Follow the object through the whole clip with the model's video tracker, as the Roto Brush's
+/// tracking pass does (prompt from the strokes, probability maps refined by the same graph cut).
+/// `None` when the model has no tracker or the tracker fails.
+pub fn run_tracker(sc: &Scenario, tracker: &str, model: &dyn MaskModel) -> Option<Run> {
+    let t = model.tracker()?;
+    let opts = SegOpts::default();
+    let at = |f: usize| -> Vec<&Stroke> { sc.strokes.iter().filter(|s| s.frame == f as i64).collect() };
+    let clip: Vec<Arc<ClipFrame>> = sc.frames.iter().map(|i| Arc::new(ClipFrame { rgb: rgb_of(i), w: i.width as usize, h: i.height as usize })).collect();
+    // a prompt per stroke frame: a few clicks and the box of the classic matte (as Chain::track does)
+    let mut prompts = vec![];
+    for f in 0..sc.frames.len() {
+        let strokes = at(f);
+        let Some(img) = sc.frames.get(f).filter(|_| strokes.iter().any(|s| s.kind == StrokeKind::Fg)) else { continue };
+        prompts.push((f as i64, tracker_prompt_boxed(&strokes, 1.0, &super::segment(img, &strokes, None, &opts, 0.0))));
+    }
+    let req = TrackRequest::single(0, sc.frames.len(), prompts);
+    let start = Instant::now();
+    let mut mattes: Vec<Vec<u8>> = vec![vec![0u8; sc.w * sc.h]; sc.frames.len()];
+    let mut get = |f: i64| usize::try_from(f).ok().and_then(|i| clip.get(i).cloned());
+    let r = t.track(&req, &mut get, &|| false, &mut |_, f, tf| {
+        let (Ok(i), true) = (usize::try_from(f), tf.prob.len() == sc.w * sc.h) else { return };
+        let Some(img) = sc.frames.get(i) else { return };
+        let strokes = at(i);
+        if let Some(slot) = mattes.get_mut(i) {
+            *slot = segment_tracked(img, &strokes, tf.prob, tf.occluded, &opts, 0.0).matte;
+        }
+    });
+    r.ok()?;
+    let mut run = metrics(sc, tracker, &mattes, start.elapsed().as_secs_f64());
+    run.peak_mb = model.peak_state_bytes().map(|b| b as f64 / (1 << 20) as f64);
+    Some(run)
+}
+
+/// The correction a user would paint on frame `f` where `pred` is wrong: a short foreground stroke through
+/// the true object's centre, and a background stroke at the centroid of all false-positive pixels.
+fn correction(sc: &Scenario, f: usize, pred: &[u8]) -> Vec<Stroke> {
+    let truth = sc.truth.get(f).map(Vec::as_slice).unwrap_or(&[]);
+    let centre = |keep: &dyn Fn(usize) -> bool| -> Option<[f64; 2]> {
+        let (mut sx, mut sy, mut n) = (0.0, 0.0, 0.0);
+        for i in (0..truth.len().min(pred.len())).filter(|i| keep(*i)) {
+            sx += (i % sc.w.max(1)) as f64 + 0.5;
+            sy += (i / sc.w.max(1)) as f64 + 0.5;
+            n += 1.0;
+        }
+        (n > 0.0).then(|| [sx / n, sy / n])
+    };
+    let mut out = vec![];
+    if let Some(c) = centre(&|i| truth.get(i).is_some_and(|v| *v != 0)) {
+        out.push(line(StrokeKind::Fg, f as i64, [c[0] - 12.0, c[1]], [c[0] + 12.0, c[1]], 5.0));
+    }
+    if let Some(c) = centre(&|i| pred.get(i).is_some_and(|v| *v != 0) && truth.get(i).is_some_and(|v| *v == 0)) {
+        out.push(line(StrokeKind::Bg, f as i64, [c[0] - 6.0, c[1]], [c[0] + 6.0, c[1]], 6.0));
+    }
+    out
+}
+
+/// Repeat `run` on `sc`, each time painting the correction a user would on the first frame under `target` IoU,
+/// until every frame reaches it or `max` correction rounds were needed. Sets `fixes` on the first run's result:
+/// the number of rounds (each can add foreground and background strokes), or `>max`.
+pub fn with_fixes(sc: &Scenario, target: f64, max: usize, run: &dyn Fn(&Scenario) -> Option<Run>) -> Option<Run> {
+    let mut cur = sc.clone();
+    let mut first: Option<Run> = None;
+    for k in 0..=max {
+        let r = run(&cur)?;
+        let bad = r.per_frame.iter().position(|v| *v < target);
+        let first_run = first.get_or_insert_with(|| r.clone());
+        let Some(f) = bad else {
+            first_run.fixes = Some(k.to_string());
+            break;
+        };
+        if k == max {
+            first_run.fixes = Some(format!(">{max}"));
+            break;
+        }
+        let pred = r.mattes.get(f).cloned().unwrap_or_default();
+        let fix = correction(&cur, f, &pred);
+        if fix.is_empty() {
+            first_run.fixes = Some(format!(">{max}"));
+            break;
+        }
+        cur.strokes.extend(fix);
+    }
+    first
+}
+
+/// A fixed-width table of the runs, grouped by scenario.
+pub fn table(runs: &[Run]) -> String {
+    let mut out = format!(
+        "{:<10} {:<12} {:>8} {:>8} {:>8} {:>10} {:>9} {:>6} {:>7}\n",
+        "clip", "tracker", "meanIoU", "minIoU", "flicker", "after ret.", "s/frame", "fixes", "peakMB"
+    );
+    for r in runs {
+        let back = r.after_return.map_or_else(|| "-".to_string(), |v| format!("{v:.3}"));
+        out.push_str(&format!(
+            "{:<10} {:<12} {:>8.3} {:>8.3} {:>8.3} {:>10} {:>9.3} {:>6} {:>7}\n",
+            r.scenario,
+            r.tracker,
+            r.mean_iou,
+            r.min_iou,
+            r.flicker,
+            back,
+            r.secs_per_frame,
+            r.fixes.as_deref().unwrap_or("-"),
+            r.peak_mb.map_or_else(|| "-".to_string(), |v| format!("{v:.0}"))
+        ));
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn area(v: &[u8]) -> usize {
+        v.iter().filter(|x| **x != 0).count()
+    }
+
+    #[test]
+    fn scenarios_have_the_events_they_claim() {
+        let all = scenarios(24);
+        assert_eq!(all.len(), 4);
+        for s in &all {
+            assert_eq!((s.frames.len(), s.truth.len()), (24, 24), "{}", s.name);
+        }
+        let full = all.first().map(|s| area(&s.truth[0])).unwrap_or(0);
+        assert!(full > 3000, "{full}");
+        let occ = all.iter().find(|s| s.name == "occlusion").map(|s| s.truth.iter().map(|t| area(t)).min().unwrap_or(0)).unwrap_or(full);
+        assert!(occ < full / 2, "occluded minimum {occ} of {full}");
+        let gone = all.iter().find(|s| s.name == "reenter").map(|s| s.truth.iter().filter(|t| area(t) == 0).count()).unwrap_or(0);
+        assert!(gone > 0, "the disk never leaves");
+        assert!(all.iter().find(|s| s.name == "reenter").is_some_and(|s| area(s.truth.last().map_or(&[][..], |v| v)) > 0), "it must come back");
+    }
+
+    #[test]
+    fn classical_tracks_plain_motion_and_the_table_lists_it() {
+        let all = scenarios(24);
+        let Some(sc) = all.first() else { return };
+        let run = run_flow(sc, "classical", None);
+        assert!(run.mean_iou > 0.9, "mean IoU {}", run.mean_iou);
+        assert_eq!(run.per_frame.len(), 24);
+        assert!(table(&[run]).contains("classical"));
+    }
+
+    #[test]
+    fn corrections_are_counted_until_every_frame_reaches_the_target() {
+        let all = scenarios(24);
+        let classical = |s: &Scenario| Some(run_flow(s, "classical", None));
+        // plain motion needs none
+        let easy = all.iter().find(|s| s.name == "move").and_then(|s| with_fixes(s, 0.9, 6, &classical)).unwrap();
+        assert_eq!(easy.fixes.as_deref(), Some("0"));
+        // after the disk has left and returned the classic engine has lost it: it needs a correction (or never gets there)
+        let hard = all.iter().find(|s| s.name == "reenter").and_then(|s| with_fixes(s, 0.9, 6, &classical)).unwrap();
+        assert_ne!(hard.fixes.as_deref(), Some("0"), "{:?}", hard.fixes);
+        assert!(table(&[easy, hard]).contains("fixes"));
+    }
+
+    #[test]
+    fn a_users_clip_becomes_a_scenario_and_bad_ones_are_refused() {
+        let all = scenarios(24);
+        let src = all.iter().find(|s| s.name == "move").unwrap();
+        let sc = scenario_from("mine", src.frames.clone(), src.truth.clone()).unwrap();
+        assert_eq!((sc.w, sc.h, sc.base), (W as usize, H as usize, 0));
+        assert!(sc.strokes.iter().any(|s| s.kind == StrokeKind::Fg) && sc.strokes.iter().any(|s| s.kind == StrokeKind::Bg));
+        let run = run_flow(&sc, "classical", None);
+        assert!(run.mean_iou > 0.9, "{}", run.mean_iou);
+        assert!(scenario_from("x", vec![], vec![]).is_err());
+        assert!(scenario_from("x", src.frames.clone(), src.truth[..3].to_vec()).is_err());
+        assert!(scenario_from("x", src.frames.clone(), vec![vec![0; sc.w * sc.h]; src.frames.len()]).is_err(), "no object anywhere");
+        let mut short = src.truth.clone();
+        short[0].pop();
+        assert!(scenario_from("x", src.frames.clone(), short).is_err());
+    }
+
+    #[test]
+    fn tiny_clip_requests_are_clamped() {
+        assert!(scenarios(0).iter().all(|s| s.frames.len() == 12));
+    }
+}
diff --git a/crates/track/src/roto/matting.rs b/crates/track/src/roto/matting.rs
index 439d9c43e..cb22b680a 100644
--- a/crates/track/src/roto/matting.rs
+++ b/crates/track/src/roto/matting.rs
@@ -200,7 +200,8 @@ pub fn guided_filter(img: &[[f32; 3]], p: &[f32], w: usize, h: usize, r: usize,
 /// (K. He, J. Sun and X. Tang, "Fast Matting Using Large Kernel Matting Laplacian Matrices",
 /// CVPR 2010): `(L·x)ᵢ = Σ_{k∋i} (xᵢ − a_kᵀIᵢ − b_k)` with `(a_k, b_k)` the ridge-regression
 /// fit of `x` to the colours in window k.
-pub fn closed_form(img: &[[f32; 3]], init: &[f32], known: &[bool], w: usize, h: usize, r: usize, eps: f32, iters: usize) -> Vec<f32> {
+pub fn closed_form(img: &[[f32; 3]], init: &[f32], known: &[bool], size: (usize, usize), r: usize, eps: f32, iters: usize) -> Vec<f32> {
+    let (w, h) = size;
     let n = w * h;
     if n == 0 || known.iter().all(|k| *k) {
         return init.to_vec();
diff --git a/crates/track/src/roto/refine.rs b/crates/track/src/roto/refine.rs
index 2a498e286..71f9261b2 100644
--- a/crates/track/src/roto/refine.rs
+++ b/crates/track/src/roto/refine.rs
@@ -123,7 +123,7 @@ pub fn matte_alpha(
             q[j] = if band[j] { q[j].clamp(0.0, 1.0) } else { cp[j] };
         }
         if p.higher_quality {
-            q = matting::closed_form(&cimg, &q, &outside, cw, ch, 1, 1e-5 * (1.0 + p.smooth.max(0.0)) as f32, 50);
+            q = matting::closed_form(&cimg, &q, &outside, (cw, ch), 1, 1e-5 * (1.0 + p.smooth.max(0.0)) as f32, 50);
         }
         // Refine Edge Matte adjustments.
         if p.smooth > 1.0 {
@@ -177,7 +177,8 @@ pub fn matte_alpha(
 /// Decontaminate edge colours of `rgb` in place for the matte `alpha` (see
 /// [`matting::decontaminate`]); returns the decontamination map. `band`: the Refine Edge band
 /// (pixels where decontamination always applies).
-pub fn decontaminate(rgb: &mut [[f32; 3]], alpha: &[f32], band: &[u8], w: usize, h: usize, p: &MatteParams, band_radius: f64, scale: f64) -> Vec<f32> {
+pub fn decontaminate(rgb: &mut [[f32; 3]], alpha: &[f32], band: &[u8], size: (usize, usize), p: &MatteParams, band_radius: f64, scale: f64) -> Vec<f32> {
+    let (w, h) = size;
     if !p.decontaminate {
         return vec![0.0; w * h];
     }
diff --git a/crates/track/src/roto/tests.rs b/crates/track/src/roto/tests.rs
index 3c4645cb2..bfc00df74 100644
--- a/crates/track/src/roto/tests.rs
+++ b/crates/track/src/roto/tests.rs
@@ -65,7 +65,13 @@ pub(crate) fn frame_at(c: [f64; 2]) -> (Image, Vec<u8>) {
 }
 
 fn line(kind: StrokeKind, frame: i64, a: [f64; 2], b: [f64; 2], radius: f64) -> Stroke {
-    Stroke { kind, frame, radius, points: (0..=10).map(|k| [a[0] + (b[0] - a[0]) * k as f64 / 10.0, a[1] + (b[1] - a[1]) * k as f64 / 10.0]).collect() }
+    Stroke {
+        kind,
+        frame,
+        radius,
+        points: (0..=10).map(|k| [a[0] + (b[0] - a[0]) * k as f64 / 10.0, a[1] + (b[1] - a[1]) * k as f64 / 10.0]).collect(),
+        object: 0,
+    }
 }
 
 /// The strokes an artist would paint on frame `f`: one through the disk, one around it.
@@ -182,6 +188,28 @@ fn a_correction_stroke_fixes_a_bad_frame() {
     assert!(iou(&next.matte, &gt2) > 0.93);
 }
 
+/// A stroke corrects the ones painted before it: foreground over an earlier background stroke
+/// restores the area, and background over that removes it again.
+#[test]
+fn later_strokes_override_earlier_ones() {
+    let c = center(0);
+    let (img, gt) = frame_at(c);
+    let spot = [c[0], c[1] + 20.0];
+    let i = spot[1] as usize * W as usize + spot[0] as usize;
+    let red = line(StrokeKind::Bg, 0, [spot[0] - 6.0, spot[1]], [spot[0] + 6.0, spot[1]], 6.0);
+    let green = Stroke { kind: StrokeKind::Fg, ..red.clone() };
+    let seg = |st: &[Stroke]| segment(&img, &st.iter().collect::<Vec<_>>(), None, &SegOpts::default(), 0.0);
+    let mut st = base_strokes(0);
+    st.push(red.clone());
+    assert_eq!(seg(&st).matte[i], 0, "background over the disk removes it");
+    st.push(green);
+    let restored = seg(&st);
+    assert_eq!(restored.matte[i], 1, "foreground over the background stroke restores it");
+    assert!(iou(&restored.matte, &gt) > 0.95, "IoU {}", iou(&restored.matte, &gt));
+    st.push(red);
+    assert_eq!(seg(&st).matte[i], 0, "background again removes it again");
+}
+
 /// A soft-edged disk (alpha ramp over `width` pixels) over a background.
 fn soft_frame(c: [f64; 2], width: f64, fg: [f32; 3], bg: [f32; 3]) -> (Image, Vec<f32>) {
     let mut img = Image::new(W, H);
@@ -209,6 +237,7 @@ fn ring(frame: i64, c: [f64; 2], r: f64, radius: f64) -> Stroke {
         frame,
         radius,
         points: (0..=48).map(|k| k as f64 / 48.0 * std::f64::consts::TAU).map(|a| [c[0] + r * a.cos(), c[1] + r * a.sin()]).collect(),
+        object: 0,
     }
 }
 
@@ -246,7 +275,7 @@ fn refine_edge_recovers_a_soft_edge_and_decontaminates() {
     assert!(frac as f64 > 0.6 * n as f64, "{frac}/{n} fractional");
     // Decontamination: edge pixels' colour is the foreground's, not a blue blend.
     let mut col = rgb.clone();
-    let map = decontaminate(&mut col, &a, &seg.refine, W as usize, H as usize, &p, 9.0, 1.0);
+    let map = decontaminate(&mut col, &a, &seg.refine, (W as usize, H as usize), &p, 9.0, 1.0);
     let (mut blue_before, mut blue_after, mut m) = (0.0f64, 0.0f64, 0usize);
     for i in 0..a.len() {
         if a[i] > 0.2 && a[i] < 0.8 {
@@ -265,6 +294,31 @@ fn refine_edge_recovers_a_soft_edge_and_decontaminates() {
     assert!(a2.iter().zip(&seg.matte).all(|(x, y)| (*x - *y as f32).abs() < 1e-6));
 }
 
+/// Refine Edge strokes correct each other the same way: refine over an earlier erase restores
+/// the band there.
+#[test]
+fn later_refine_strokes_override_earlier_erases() {
+    let c = [100.0, 75.0];
+    let (img, _) = soft_frame(c, 10.0, [0.9, 0.25, 0.1], [0.1, 0.3, 0.9]);
+    let spot = [c[0] + R, c[1]];
+    let i = spot[1] as usize * W as usize + spot[0] as usize;
+    let erase = Stroke { kind: StrokeKind::RefineErase, frame: 0, radius: 6.0, points: vec![spot], object: 0 };
+    let refine = Stroke { kind: StrokeKind::Refine, ..erase.clone() };
+    let band = |st: &[Stroke]| segment(&img, &st.iter().collect::<Vec<_>>(), None, &SegOpts::default(), 9.0).refine[i];
+    let mut st = vec![
+        line(StrokeKind::Fg, 0, [c[0] - 15.0, c[1]], [c[0] + 15.0, c[1]], 5.0),
+        line(StrokeKind::Bg, 0, [c[0] - 60.0, c[1] - 55.0], [c[0] + 60.0, c[1] - 55.0], 5.0),
+        ring(0, c, R, 9.0),
+    ];
+    assert_eq!(band(&st), 1);
+    st.push(erase.clone());
+    assert_eq!(band(&st), 0, "erase removes the band");
+    st.push(refine);
+    assert_eq!(band(&st), 1, "refine over the erase restores it");
+    st.push(erase);
+    assert_eq!(band(&st), 0, "erase again removes it again");
+}
+
 #[test]
 fn reduce_chatter_and_motion_blur_use_the_neighbours() {
     let (w, h) = (40usize, 20usize);
@@ -342,7 +396,7 @@ fn roto_perf_1080p() {
     let mut seg2 = next.clone();
     let c = center(1);
     let ring: Vec<[f64; 2]> = (0..=64).map(|k| k as f64 / 64.0 * std::f64::consts::TAU).map(|t| [(c[0] + R * t.cos()) * s, (c[1] + R * t.sin()) * s]).collect();
-    let st = [Stroke { kind: StrokeKind::Refine, frame: 1, radius: 20.0, points: ring }];
+    let st = [Stroke { kind: StrokeKind::Refine, frame: 1, radius: 20.0, points: ring, object: 0 }];
     let r = rasterize(&st.iter().collect::<Vec<_>>(), &[StrokeKind::Refine], 1.0, 1920, 1080);
     seg2.refine = r.iter().map(|v| *v as u8).collect();
     let rgb = rgb_of(&b);
@@ -373,9 +427,8 @@ impl effectcraft_segment::MaskModel for FakeModel {
 }
 
 /// A grey bar on a two-tone background whose halves match the bar's halves: colour alone can't
-/// find its edge, a model can.
-#[test]
-fn a_model_prior_shapes_the_cut_and_bad_models_are_ignored() {
+/// find its edge, a model can. The frame, its truth and the bar's rectangle.
+fn bar_frame() -> (Image, Vec<u8>, [usize; 4]) {
     let (w, h) = (160usize, 100usize);
     let rect = [40, 30, 120, 70];
     let mut img = Image::new(w as u32, h as u32);
@@ -390,6 +443,12 @@ fn a_model_prior_shapes_the_cut_and_bad_models_are_ignored() {
             gt[y * w + x] = inside as u8;
         }
     }
+    (img, gt, rect)
+}
+
+#[test]
+fn a_model_prior_shapes_the_cut_and_bad_models_are_ignored() {
+    let (img, gt, rect) = bar_frame();
     let st = [line(StrokeKind::Fg, 0, [50.0, 50.0], [110.0, 50.0], 4.0)];
     let refs: Vec<&Stroke> = st.iter().collect();
     let opts = SegOpts::default();
@@ -448,20 +507,218 @@ fn mobilesam_segments_and_propagates_the_disk() {
 /// ignores it; a prior's box does not replace it.
 #[test]
 fn box_stroke_is_the_model_box_prompt() {
-    let fg = Stroke { kind: StrokeKind::Fg, frame: 0, radius: 2.0, points: vec![[50.0, 40.0]] };
-    let bx = Stroke { kind: StrokeKind::Box, frame: 0, radius: 0.0, points: vec![[80.0, 60.0], [20.0, 10.0]] };
-    let p = stroke_prompt(&[&fg, &bx], 0.5);
+    let fg = Stroke { kind: StrokeKind::Fg, frame: 0, radius: 2.0, points: vec![[50.0, 40.0]], object: 0 };
+    let bx = Stroke { kind: StrokeKind::Box, frame: 0, radius: 0.0, points: vec![[80.0, 60.0], [20.0, 10.0]], object: 0 };
+    let p = stroke_prompt(&[&fg, &bx], &[], 0.5, 0, 0);
     assert_eq!(p.bbox, Some([10.0, 5.0, 40.0, 30.0]));
     assert_eq!(p.points, vec![([25.0, 20.0], true)]);
     // Degenerate or non-finite boxes are no prompt.
     for pts in [vec![[20.0, 10.0]], vec![[20.0, 10.0], [20.0, 50.0]], vec![[f64::NAN, 10.0], [80.0, 60.0]]] {
         let b = Stroke { points: pts, ..bx.clone() };
-        assert_eq!(stroke_prompt(&[&fg, &b], 1.0).bbox, None);
+        assert_eq!(stroke_prompt(&[&fg, &b], &[], 1.0, 0, 0).bbox, None);
     }
     assert!(!StrokeKind::Box.is_segmentation());
     assert!(rasterize(&[&bx], &[StrokeKind::Fg, StrokeKind::Bg], 1.0, 100, 80).iter().all(|v| !v));
-    let mut q = stroke_prompt(&[&fg, &bx], 1.0);
+    let mut q = stroke_prompt(&[&fg, &bx], &[], 1.0, 0, 0);
     let soft: Vec<f32> = (0..100 * 80).map(|i| ((i % 100) < 10) as u8 as f32).collect();
-    assert!(add_prior_prompt(&mut q, &soft, 100, 80));
+    assert!(add_prior_prompt(&mut q, &soft, &[], 100, 80));
     assert_eq!(q.bbox, Some([20.0, 10.0, 80.0, 60.0]));
 }
+
+/// A model is never prompted against the latest correction: stroke points that a later stroke
+/// of the other kind painted over are dropped, and the propagated matte's points and mask leave
+/// out what this frame's background strokes removed.
+#[test]
+fn model_prompts_follow_the_latest_stroke() {
+    let green = Stroke { kind: StrokeKind::Fg, frame: 0, radius: 4.0, points: vec![[50.0, 40.0]], object: 0 };
+    let red = Stroke { kind: StrokeKind::Bg, ..green.clone() };
+    let (w, h) = (100, 80);
+    let prompt = |st: &[&Stroke]| stroke_prompt(st, &resolve(st, StrokeKind::Fg, StrokeKind::Bg, 1.0, w, h), 1.0, w, h).points;
+    assert_eq!(prompt(&[&green, &red]), vec![([50.0, 40.0], false)]);
+    assert_eq!(prompt(&[&green, &red, &green]), vec![([50.0, 40.0], true); 2]);
+    let soft: Vec<f32> = (0..w * h).map(|i| ((i % w) < 50) as u8 as f32).collect();
+    let erase = Stroke { kind: StrokeKind::Bg, frame: 0, radius: 15.0, points: vec![[25.0, 40.0]], object: 0 };
+    let hard = resolve(&[&erase], StrokeKind::Fg, StrokeKind::Bg, 1.0, w, h);
+    let mut q = Prompt::default();
+    assert!(add_prior_prompt(&mut q, &soft, &hard, w, h));
+    assert!(!q.points.is_empty());
+    assert!(q.points.iter().all(|(p, fg)| *fg && owner(&hard, w, h, *p) != Some(HARD_BG)), "{:?}", q.points);
+    let mask = q.mask.unwrap();
+    assert!(hard.iter().zip(&mask).all(|(hd, m)| *hd != HARD_BG || *m == 0.0));
+}
+
+/// A stand-in model that counts its calls; its foreground is a fixed rectangle.
+struct CountingModel([usize; 4], std::sync::atomic::AtomicUsize);
+
+impl effectcraft_segment::MaskModel for CountingModel {
+    fn info(&self) -> &'static effectcraft_segment::ModelInfo {
+        &effectcraft_segment::MOBILE_SAM
+    }
+    fn segment(&self, _: &[[f32; 3]], w: usize, h: usize, _: &Prompt) -> Result<Vec<f32>, String> {
+        self.1.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        let [x0, y0, x1, y1] = self.0;
+        Ok((0..w * h).map(|i| ((i % w) >= x0 && (i % w) < x1 && (i / w) >= y0 && (i / w) < y1) as u8 as f32 * 0.98 + 0.01).collect())
+    }
+}
+
+/// A small background correction in the middle of a large foreground dot removes the only point
+/// sampled along the dot, but most of the dot is still foreground: the model is still prompted
+/// with it, from a point inside what is left. A dot painted over completely prompts nothing.
+#[test]
+fn a_correction_keeps_the_model_prompted_with_what_is_left() {
+    let (img, gt, rect) = bar_frame();
+    let (w, h) = (img.width as usize, img.height as usize);
+    let dot = Stroke { kind: StrokeKind::Fg, frame: 0, radius: 15.0, points: vec![[80.0, 50.0]], object: 0 };
+    let tap = Stroke { kind: StrokeKind::Bg, radius: 2.0, ..dot.clone() };
+    let refs = [&dot, &tap];
+    let model = CountingModel(rect, Default::default());
+    let seg = segment_with(&img, &refs, None, &SegOpts::default(), 0.0, Some(&model));
+    assert_eq!(model.1.load(std::sync::atomic::Ordering::Relaxed), 1, "the model was prompted");
+    assert!(iou(&seg.matte, &gt) > 0.95, "IoU {}", iou(&seg.matte, &gt));
+    let hard = resolve(&refs, StrokeKind::Fg, StrokeKind::Bg, 1.0, w, h);
+    let fg: Vec<[f32; 2]> = stroke_prompt(&refs, &hard, 1.0, w, h).points.into_iter().filter(|p| p.1).map(|p| p.0).collect();
+    let [q] = fg.as_slice() else { panic!("one foreground point, got {fg:?}") };
+    let r = (q[0] - 80.0).hypot(q[1] - 50.0);
+    assert!(r > 5.0 && r < 13.0, "{q:?} sits inside what is left of the dot");
+    assert_eq!(hard[q[1] as usize * w + q[0] as usize], HARD_FG);
+    let cover = Stroke { radius: 16.0, ..tap };
+    let refs = [&dot, &cover];
+    let hard = resolve(&refs, StrokeKind::Fg, StrokeKind::Bg, 1.0, w, h);
+    assert!(stroke_prompt(&refs, &hard, 1.0, w, h).points.iter().all(|p| !p.1));
+}
+
+#[test]
+fn tracker_prompts_carry_a_handful_of_points() {
+    let st = base_strokes(0);
+    let refs: Vec<&Stroke> = st.iter().collect();
+    let p = tracker_prompt(&refs, 1.0, W as usize, H as usize);
+    let (fg, bg) = (p.points.iter().filter(|(_, f)| *f).count(), p.points.iter().filter(|(_, f)| !*f).count());
+    assert!((1..=TRACKER_FG_POINTS).contains(&fg) && (1..=TRACKER_BG_POINTS).contains(&bg), "{fg} fg, {bg} bg");
+    // a long, finely sampled stroke still gives at most the limit, and an empty one gives none
+    let long = Stroke { kind: StrokeKind::Fg, frame: 0, radius: 2.0, points: (0..400).map(|i| [i as f64 * 0.4, 50.0]).collect(), object: 0 };
+    assert!(tracker_prompt(&[&long], 1.0, W as usize, H as usize).points.len() <= TRACKER_FG_POINTS);
+    assert!(tracker_prompt(&[], 1.0, W as usize, H as usize).points.is_empty());
+}
+
+/// Tracker clicks follow the same correction order as the classic matte and model prompts.
+#[test]
+fn tracker_prompts_follow_latest_corrections_and_keep_remaining_foreground() {
+    let (w, h) = (100, 80);
+    let green = Stroke { kind: StrokeKind::Fg, frame: 0, radius: 15.0, points: vec![[50.0, 40.0]], object: 0 };
+    let red = Stroke { kind: StrokeKind::Bg, radius: 16.0, ..green.clone() };
+    for strokes in [&[&green, &red][..], &[&red, &green][..]] {
+        let classic = FrameSeg::empty(w, h);
+        for prompt in [tracker_prompt(strokes, 1.0, w, h), tracker_prompt_boxed(strokes, 1.0, &classic)] {
+            let expected = std::ptr::eq(strokes[1], &green);
+            assert_eq!(prompt.points.iter().any(|(_, fg)| *fg), expected, "{:?}", prompt.points);
+            let hard = resolve(strokes, StrokeKind::Fg, StrokeKind::Bg, 1.0, w, h);
+            for (point, fg) in &prompt.points {
+                assert_eq!(owner(&hard, w, h, *point), Some(if *fg { HARD_FG } else { HARD_BG }));
+            }
+            assert!(!prompt.points.is_empty());
+        }
+    }
+    // A small correction removes the sampled centre, while most of the foreground dot remains.
+    let tap = Stroke { radius: 2.0, ..red };
+    let strokes = [&green, &tap];
+    let hard = resolve(&strokes, StrokeKind::Fg, StrokeKind::Bg, 1.0, w, h);
+    for prompt in [tracker_prompt(&strokes, 1.0, w, h), tracker_prompt_boxed(&strokes, 1.0, &FrameSeg::empty(w, h))] {
+        assert!(prompt.points.iter().any(|(_, fg)| *fg));
+        assert!(prompt.points.iter().any(|(_, fg)| !*fg));
+        for (point, fg) in &prompt.points {
+            assert_eq!(owner(&hard, w, h, *point), Some(if *fg { HARD_FG } else { HARD_BG }));
+        }
+        assert!(prompt.points.iter().filter(|(_, fg)| *fg).count() <= TRACKER_FG_POINTS);
+        assert!(prompt.points.iter().filter(|(_, fg)| !*fg).count() <= TRACKER_BG_POINTS);
+    }
+}
+
+#[test]
+fn tracked_segmentation_handles_absent_objects_and_bad_maps() {
+    let (img, gt) = frame_at(center(0));
+    let st = base_strokes(0);
+    let refs: Vec<&Stroke> = st.iter().collect();
+    let opts = SegOpts::default();
+    let n = (W * H) as usize;
+    // a good map (the true disk) reproduces it, with the strokes as constraints
+    let soft: Vec<f32> = gt.iter().map(|v| f32::from(*v)).collect();
+    let seg = segment_tracked(&img, &refs, soft, false, &opts, 0.0);
+    assert!(iou(&seg.matte, &gt) > 0.95);
+    // an absent object (no strokes on the frame) is an empty matte, whatever the map says
+    let none = segment_tracked(&img, &[], vec![1.0; n], true, &opts, 0.0);
+    assert_eq!(none.area(), 0);
+    assert_eq!(segment_tracked(&img, &[], vec![0.0; n], false, &opts, 0.0).area(), 0);
+    // a map of the wrong size is ignored: the strokes alone segment the frame
+    let wrong = segment_tracked(&img, &refs, vec![1.0; 3], false, &opts, 0.0);
+    assert!(iou(&wrong.matte, &gt) > 0.95);
+}
+
+#[test]
+fn tracker_prompts_carry_the_box_of_the_classic_matte() {
+    let (img, gt) = frame_at(center(0));
+    let st = base_strokes(0);
+    let refs: Vec<&Stroke> = st.iter().collect();
+    let classic = segment(&img, &refs, None, &SegOpts::default(), 0.0);
+    let p = tracker_prompt_boxed(&refs, 1.0, &classic);
+    let b = p.bbox.expect("a box");
+    let c = center(0);
+    // the box reaches the disk's edges, with a margin
+    assert!(b[0] <= (c[0] - R) as f32 && b[0] > (c[0] - R) as f32 - 12.0, "{b:?}");
+    assert!(b[2] >= (c[0] + R) as f32 && b[2] < (c[0] + R) as f32 + 12.0, "{b:?}");
+    assert!(b[1] <= (c[1] - R) as f32 && b[3] >= (c[1] + R) as f32, "{b:?}");
+    assert!(iou(&classic.matte, &gt) > 0.95);
+    // no matte, no box; a box the user drew wins
+    let none = tracker_prompt_boxed(&refs, 1.0, &FrameSeg::empty(W as usize, H as usize));
+    assert_eq!(none.bbox, None);
+    let bx = Stroke { kind: StrokeKind::Box, frame: 0, radius: 0.0, points: vec![[10.0, 10.0], [50.0, 60.0]], object: 0 };
+    let mut with_box: Vec<&Stroke> = refs.clone();
+    with_box.push(&bx);
+    assert_eq!(tracker_prompt_boxed(&with_box, 1.0, &classic).bbox, Some([10.0, 10.0, 50.0, 60.0]));
+}
+
+#[test]
+fn strokes_carry_an_object_and_old_data_is_object_zero() {
+    // saved before objects existed: no field, and the field is not written for object 0
+    let old = r#"{"base":0,"span":[0,4],"strokes":[{"kind":"fg","frame":0,"radius":3.0,"points":[[1.0,2.0]]}]}"#;
+    let d = RotoData::from_json(old);
+    assert_eq!(d.strokes.first().map(|s| s.object), Some(0));
+    assert!(!d.to_json().contains("object"), "{}", d.to_json());
+    // the keys of existing projects do not change
+    let same = RotoData::from_json(&d.to_json());
+    assert_eq!(d.chain_keys(1), same.chain_keys(1));
+
+    let mut d = d;
+    d.add(Stroke { kind: StrokeKind::Fg, frame: 0, radius: 3.0, points: vec![[9.0, 9.0]], object: 2 }, 4, [0, 10]);
+    d.add(Stroke { kind: StrokeKind::Bg, frame: 0, radius: 3.0, points: vec![[0.0, 0.0]], object: 2 }, 4, [0, 10]);
+    d.add(Stroke { kind: StrokeKind::Refine, frame: 0, radius: 3.0, points: vec![[5.0, 5.0]], object: 0 }, 4, [0, 10]);
+    assert_eq!(d.objects(), vec![0, 2]);
+    assert!(d.to_json().contains("\"object\":2"));
+    assert_eq!(RotoData::from_json(&d.to_json()), d);
+    // an object's own strokes, plus the Refine Edge strokes that belong to the whole matte
+    assert_eq!(d.strokes_of(0, 2).len(), 3);
+    assert_eq!(d.strokes_of(0, 0).len(), 2);
+    assert!(d.strokes_of(0, 1).len() == 1);
+    // moving a stroke to another object changes the frame keys (the tracked frames are stale)
+    let before = d.chain_keys(1);
+    if let Some(s) = d.strokes.first_mut() {
+        s.object = 1;
+    }
+    assert_ne!(before, d.chain_keys(1));
+}
+
+#[test]
+fn the_union_of_objects_is_their_largest_extent() {
+    let seg = |cells: &[usize]| {
+        let mut s = FrameSeg::empty(4, 1);
+        for c in cells {
+            s.matte[*c] = 255;
+        }
+        s
+    };
+    let u = FrameSeg::union(vec![seg(&[0]), seg(&[2, 3]), seg(&[3])]);
+    assert_eq!(u.matte, vec![255, 0, 255, 255]);
+    assert_eq!(FrameSeg::union(vec![]).w, 0);
+    // a part of another size is ignored
+    let odd = FrameSeg::empty(2, 2);
+    assert_eq!(FrameSeg::union(vec![seg(&[1]), odd]).matte, vec![0, 255, 0, 0]);
+}
diff --git a/crates/track/src/stabilize.rs b/crates/track/src/stabilize.rs
index 9769fcbd0..90cab6aab 100644
--- a/crates/track/src/stabilize.rs
+++ b/crates/track/src/stabilize.rs
@@ -156,10 +156,27 @@ impl Analyzer {
 
     /// Analyse the next frame.
     pub fn push(&mut self, frame: &Frame) {
+        self.push_impl(frame, !self.opts.detailed);
+    }
+
+    fn push_impl(&mut self, frame: &Frame, share_pyramid: bool) {
+        let share_pyramid = share_pyramid && !self.opts.detailed;
         let (max_side, max_feat) = if self.opts.detailed { (960, 700) } else { (480, 350) };
         let factor = analysis_factor(frame.img.width, frame.img.height, max_side);
-        let pyr = GrayPyramid::from_image(frame.img, frame.offset, factor, 3);
-        self.trajectories.push(frame);
+        let mut pyr = GrayPyramid::from_image(frame.img, frame.offset, factor, if share_pyramid { 4 } else { 3 });
+        if share_pyramid {
+            self.trajectories.push_pyramid(self.prev.as_ref(), &pyr);
+        } else {
+            // Detailed analysis uses different downsampling factors for motion and trajectories.
+            self.trajectories.push(frame);
+        }
+        // Motion tracking historically used only three extra levels. Temporarily remove
+        // the trajectory tracker's fourth level without cloning any planes or gradients.
+        let extra = if share_pyramid && pyr.levels.len() > 4 { pyr.levels.pop().zip(pyr.grads.pop()) } else { None };
+        if share_pyramid && let Some(prev) = &mut self.prev {
+            prev.levels.truncate(4);
+            prev.grads.truncate(4);
+        }
         let mut fm = FrameMotion::default();
         if let Some(prev) = &self.prev
             && prev.width() == pyr.width()
@@ -195,6 +212,10 @@ impl Analyzer {
                 fm.points = round_pts(&inl, 48);
             }
         }
+        if let Some((level, grad)) = extra {
+            pyr.levels.push(level);
+            pyr.grads.push(grad);
+        }
         self.frames.push(fm);
         self.prev = Some(pyr);
     }
@@ -833,6 +854,39 @@ mod tests {
         tot / cnt.max(1) as f64
     }
 
+    #[test]
+    fn shared_pyramid_preserves_motion_and_trajectory_bits() {
+        rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap().install(|| {
+            for (size, detailed) in [([321.0, 181.0], false), ([997.0, 565.0], false), ([97.0, 63.0], false), ([1281.0, 721.0], true)] {
+                let mut scene = Scene::new(12);
+                scene.size = size;
+                let mut shared = Analyzer::new(size, AnalyzeOpts { detailed });
+                let mut separate = Analyzer::new(size, AnalyzeOpts { detailed });
+                for k in 0..12 {
+                    // Also cover partial downsample blocks, an offset/size change and the
+                    // resulting reset of active features halfway through the clip.
+                    if k == 6 {
+                        scene.size = [size[0] + 7.0, size[1] + 5.0];
+                    }
+                    let img = scene.frame(k);
+                    let frame = Frame { img: &img, offset: if k < 6 { [2.25, -3.5] } else { [-1.75, 4.5] } };
+                    shared.push(&frame);
+                    separate.push_impl(&frame, false);
+                }
+                let a = shared.finish(0.123456789012345, 1.0 / 24.0);
+                let b = separate.finish(0.123456789012345, 1.0 / 24.0);
+                assert!(!a.tracks.is_empty(), "exercise live trajectories: {size:?}, detailed={detailed}");
+                assert!(a.frames.iter().any(|f| f.features > 0));
+                assert_eq!(a.to_json(), b.to_json(), "{size:?}, detailed={detailed}");
+                for (a, b) in a.frames.iter().zip(&b.frames) {
+                    for (a, b) in a.t.iter().chain(&a.s).chain(&a.h).zip(b.t.iter().chain(&b.s).chain(&b.h)) {
+                        assert_eq!(a.to_bits(), b.to_bits());
+                    }
+                }
+            }
+        });
+    }
+
     #[test]
     fn subspace_warp_beats_perspective_on_parallax() {
         let n = 48;
diff --git a/crates/track/src/tests.rs b/crates/track/src/tests.rs
index 886478d1e..c019996f5 100644
--- a/crates/track/src/tests.rs
+++ b/crates/track/src/tests.rs
@@ -93,6 +93,55 @@ fn dist(a: [f64; 2], b: [f64; 2]) -> f64 {
     ((a[0] - b[0]).powi(2) + (a[1] - b[1]).powi(2)).sqrt()
 }
 
+fn bits(v: &Option<([f64; 2], [f64; 2])>) -> Option<[u64; 4]> {
+    v.map(|(c, a)| [c[0].to_bits(), c[1].to_bits(), a[0].to_bits(), a[1].to_bits()])
+}
+
+#[test]
+fn scorer_matches_ncc_for_integer_offsets() {
+    let pose = Pose { c: [60.0, 50.0], rot: 0.0, scale: 1.0 };
+    let img = frame(120, 100, pose, 20.0, 0.02, 1, None);
+    let crop = Crop::new(&Frame::new(&img), &TrackOptions::default(), [60.0, 50.0], [40.0, 30.0], 1);
+    for (lvl, c, a) in [(0, [30.3, 25.9], [0.97, 0.21]), (0, [12.0, 9.5], [1.2, -0.3]), (1, [20.4, 14.2], [0.8, 0.0]), (0, [30.3, 25.9], [1.0, 0.0])] {
+        let plane = &crop.levels[lvl];
+        let r = [7, 5];
+        let patch = Patch::sample(plane, c, a, r);
+        let sc = Scorer::new(plane, &patch, [c[0] + 0.3, c[1] - 0.45], a);
+        for j in -9..=9 {
+            for i in -9..=9 {
+                let q = [c[0] + 0.3 + i as f64, c[1] - 0.45 + j as f64];
+                assert_eq!(sc.at(i, j).to_bits(), ncc(plane, &patch, q, a).to_bits(), "level {lvl} {a:?} ({i}, {j})");
+            }
+        }
+    }
+}
+
+#[test]
+fn lk_refine_with_a_gradient_window_equals_the_full_gradients() {
+    let pose = Pose { c: [100.0, 90.0], rot: 5.0, scale: 1.05 };
+    let (img0, img1) = (frame(200, 180, pose, 30.0, 0.02, 1, None), frame(200, 180, Pose { c: [103.2, 88.1], rot: 6.5, scale: 1.08 }, 30.0, 0.02, 2, None));
+    let (opts, r) = (TrackOptions::default(), [24, 24]);
+    let (c0, a0) = ([100.0, 90.0], [1.0, 0.0]);
+    let tpl = Crop::new(&Frame::new(&img0), &opts, c0, [60.0, 60.0], 0);
+    let crop = Crop::new(&Frame::new(&img1), &opts, c0, [60.0, 60.0], 0);
+    let plane = &crop.levels[0];
+    let patch = Patch::sample(&tpl.levels[0], tpl.to_level(c0, 0), a0, r);
+    let mid = crop.to_level(c0, 0);
+    // Starts within the window, and far enough off that the iterations leave it (even near the edge).
+    for (d, edge) in [([0.0, 0.0], false), ([1.3, -0.8], false), ([4.0, 5.0], false), ([9.0, -9.0], false), ([0.0, 0.0], true)] {
+        let start = if edge { [4.0, 4.0] } else { [mid[0] + d[0], mid[1] + d[1]] };
+        for shape in [true, false] {
+            let (mut full, mut win) = (Grad::full(plane), Grad::around(plane, start, a0, r));
+            let x = lk_refine(&crop, &mut full, &patch, start, a0, shape);
+            let y = lk_refine(&crop, &mut win, &patch, start, a0, shape);
+            assert_eq!(bits(&x), bits(&y), "{d:?} edge {edge} shape {shape}");
+            // A window that misses the taps altogether is replaced by the full gradients.
+            let mut off = Grad::around(plane, [start[0] + 15.0, start[1] + 15.0], a0, r);
+            assert_eq!(bits(&x), bits(&lk_refine(&crop, &mut off, &patch, start, a0, shape)), "{d:?} edge {edge} shape {shape}: missed window");
+        }
+    }
+}
+
 #[test]
 fn recovers_translation_path_subpixel() {
     let path = |f: usize| {
@@ -114,6 +163,27 @@ fn recovers_translation_path_subpixel() {
     assert!(worst < 0.25, "worst error {worst} px");
 }
 
+#[test]
+fn recovers_after_sudden_jumps_the_prediction_misses() {
+    // Alternating large steps defeat the velocity prediction, so the fine stage must keep its
+    // wider neighbourhood; smooth frames in between use the narrow one.
+    let path = |f: usize| {
+        let t = f as f64;
+        let jump = [0.0, 7.0, -5.0, 9.0, -8.0, 6.0, -7.0, 8.0];
+        let j = jump[f % jump.len()];
+        Pose { c: [120.0 + 1.5 * t + j, 100.0 + 1.1 * t - 0.6 * j], rot: 0.0, scale: 1.0 }
+    };
+    let f0 = frame(360, 260, path(0), 40.0, 0.02, 0, None);
+    let mut tr = Tracker::new(TrackOptions::default(), &[spec(path(0).c, 31.0, 91.0)], &Frame::new(&f0));
+    for f in 1..24 {
+        let img = frame(360, 260, path(f), 40.0, 0.02, f as u32, None);
+        let r = tr.step(&Frame::new(&img))[0];
+        let e = dist(r.center, path(f).c);
+        assert!(e < 0.3, "frame {f}: error {e} px");
+        assert_eq!(r.status, Status::Tracked);
+    }
+}
+
 #[test]
 fn layer_offset_and_channels() {
     let pose = |f: usize| Pose { c: [120.0 + 3.3 * f as f64, 100.0 - 1.7 * f as f64], rot: 0.0, scale: 1.0 };
diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml
index ad9102943..89532edb3 100644
--- a/crates/ui-egui/Cargo.toml
+++ b/crates/ui-egui/Cargo.toml
@@ -11,6 +11,7 @@ workspace = true
 
 [dependencies]
 craft-ui = { workspace = true }
+craft-quit = { workspace = true, features = ["egui"] }
 effectcraft-time = { workspace = true }
 effectcraft-geom = { workspace = true }
 effectcraft-color = { workspace = true }
@@ -33,6 +34,8 @@ kurbo = { workspace = true }
 image = { workspace = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+# Floating panels open in OS windows of their own on desktop; the web keeps them in the page.
+craft-ui = { workspace = true, features = ["native-windows"] }
 craft-update = { workspace = true }
 sys-locale = { workspace = true }
 
@@ -41,7 +44,8 @@ sys-locale = { workspace = true }
 # here documents the requirement (kittest's own dev-dependencies do not propagate to consumers).
 egui = { workspace = true, features = ["default_fonts", "monochrome_emoji_fonts"] }
 egui_kittest = { workspace = true, features = ["eframe", "wgpu"] }
-pollster = "0.4"
+pollster = "1"
+effectcraft-segment = { workspace = true }
 effectcraft-host = { workspace = true }
 exr = { workspace = true }
 
diff --git a/crates/ui-egui/build.rs b/crates/ui-egui/build.rs
index c5276ebf5..e9bca58c7 100644
--- a/crates/ui-egui/build.rs
+++ b/crates/ui-egui/build.rs
@@ -1,8 +1,7 @@
-//! Bake the contributor credits into the binary as static Rust tables (craftrules
-//! standards/contributors.md). Nothing is read at run time.
+//! Bake the contributor credits into the binary as static Rust tables. Nothing is read at run time.
 //!
-//! - contributors/contributors.json: commit stats per GitHub username, generated by craftrules
-//!   scripts/contributors.py, which also marks whose people.toml entry it verified.
+//! - contributors/contributors.json: commit stats per GitHub username, with a mark for whose
+//!   people.toml entry is verified.
 //! - contributors/people.toml: the names people chose for themselves. A name is used only when the
 //!   JSON says the entry was verified (`people_entry`).
 //!
diff --git a/crates/ui-egui/src/a11y.rs b/crates/ui-egui/src/a11y.rs
new file mode 100644
index 000000000..e832d3b97
--- /dev/null
+++ b/crates/ui-egui/src/a11y.rs
@@ -0,0 +1,205 @@
+//! Accessibility helpers (docs/gaps.md gap 25): names, roles and states for the widgets the app
+//! paints itself, and the small pieces of list keyboard handling the panels share.
+//!
+//! egui builds an AccessKit node for every widget that can take the keyboard focus, but a widget
+//! made with `ui.interact` has no name and no role until the panel says what it is. These helpers
+//! write that onto the widget's node *after* the widget is made each frame (egui rebuilds the
+//! tree every pass), and keep whatever egui already put there (its role for a `DragValue`, the
+//! numeric value of a `Slider`).
+//!
+//! Names are the same translated strings the panel draws (`i18n::tr`), never hard-coded English.
+//! `tests/it/ui_accessibility_audit.rs` walks the tree and fails on an unnamed control in the panels
+//! that have had their pass.
+
+use egui::accesskit::{HasPopup, Role, Toggled};
+use egui::{Context, Id, Response};
+
+/// Set `f` on `r`'s AccessKit node (nothing when AccessKit is off). egui only fills a node's
+/// bounds and actions for widgets that can take the keyboard focus; a widget that cannot (the
+/// non-current rows of a list) still needs both, or assistive technology cannot place or click it.
+fn node(r: &Response, f: impl FnOnce(&mut egui::accesskit::Node)) {
+    r.ctx.accesskit_node_builder(r.id, |n| {
+        n.set_bounds(egui::accesskit::Rect { x0: r.rect.min.x.into(), y0: r.rect.min.y.into(), x1: r.rect.max.x.into(), y1: r.rect.max.y.into() });
+        if r.sense.is_focusable() {
+            n.add_action(egui::accesskit::Action::Focus);
+        }
+        if r.sense.senses_click() {
+            n.add_action(egui::accesskit::Action::Click);
+        }
+        f(n);
+    });
+}
+
+/// Give `r`'s node a role and leave its name to the caller.
+pub(crate) fn role(r: &Response, role: Role) {
+    node(r, |n| n.set_role(role));
+}
+
+/// Give `r`'s node a role and a name.
+pub(crate) fn role_name(r: &Response, role: Role, label: &str) {
+    node(r, |n| {
+        n.set_role(role);
+        n.set_label(label);
+    });
+}
+
+/// Name `r`'s node (`label`), keeping the role egui gave it (spin button, slider, text input).
+pub(crate) fn name(r: &Response, label: &str) {
+    node(r, |n| n.set_label(label));
+}
+
+/// Give `r`'s node a current value and keep the name it already has.
+pub(crate) fn value(r: &Response, value: &str) {
+    node(r, |n| n.set_value(value));
+}
+
+/// Name `r`'s node and give it a current value (a spin button's or a text field's text).
+pub(crate) fn name_value(r: &Response, label: &str, value: &str) {
+    node(r, |n| {
+        n.set_label(label);
+        n.set_value(value);
+    });
+}
+
+/// A push button; `enabled` false marks it disabled for assistive technology (it stays visible).
+pub(crate) fn button(r: &Response, label: &str, enabled: bool) {
+    node(r, |n| {
+        n.set_role(Role::Button);
+        n.set_label(label);
+        if !enabled {
+            n.set_disabled();
+        }
+    });
+}
+
+/// A button that opens a menu or popup: `open` is whether it is open now.
+pub(crate) fn menu_button(r: &Response, label: &str, open: bool) {
+    node(r, |n| {
+        n.set_role(Role::Button);
+        n.set_label(label);
+        n.set_has_popup(HasPopup::Menu);
+        n.set_expanded(open);
+    });
+}
+
+/// A button that shows or hides something (a twirl): `expanded` is the state it leads to from.
+pub(crate) fn disclosure(r: &Response, label: &str, expanded: bool) {
+    node(r, |n| {
+        n.set_role(Role::Button);
+        n.set_label(label);
+        n.set_expanded(expanded);
+    });
+}
+
+/// A check box.
+pub(crate) fn check_box(r: &Response, label: &str, checked: bool, enabled: bool) {
+    node(r, |n| {
+        n.set_role(Role::CheckBox);
+        n.set_label(label);
+        n.set_toggled(if checked { Toggled::True } else { Toggled::False });
+        if !enabled {
+            n.set_disabled();
+        }
+    });
+}
+
+/// A drop-down: `label` says what it sets and `value` is what it is set to.
+pub(crate) fn combo_box(r: &Response, label: &str, value: &str, enabled: bool) {
+    node(r, |n| {
+        n.set_role(Role::ComboBox);
+        n.set_label(label);
+        n.set_value(value);
+        n.set_has_popup(HasPopup::Menu);
+        n.set_expanded(false);
+        if !enabled {
+            n.set_disabled();
+        }
+    });
+}
+
+/// A row of a tree: selected, its depth (`level`, 1 at the top), whether it is open (`None` for a
+/// leaf) and its place among its siblings.
+pub(crate) fn tree_item(r: &Response, label: &str, selected: bool, level: usize, expanded: Option<bool>) {
+    node(r, |n| {
+        n.set_role(Role::TreeItem);
+        n.set_label(label);
+        n.set_selected(selected);
+        n.set_level(level);
+        if let Some(open) = expanded {
+            n.set_expanded(open);
+        }
+    });
+}
+
+/// An entry of a flat list: `position` is its 1-based place among `size`.
+pub(crate) fn list_item(r: &Response, label: &str, selected: bool, position: usize, size: usize) {
+    node(r, |n| {
+        n.set_role(Role::ListItem);
+        n.set_label(label);
+        n.set_selected(selected);
+        n.set_position_in_set(position);
+        n.set_size_of_set(size);
+    });
+}
+
+/// An entry of a menu or popup list; `checked` is `Some` for an entry that is on or off.
+pub(crate) fn menu_item(r: &Response, label: &str, checked: Option<bool>) {
+    node(r, |n| {
+        n.set_label(label);
+        match checked {
+            Some(on) => {
+                n.set_role(Role::MenuItemCheckBox);
+                n.set_toggled(if on { Toggled::True } else { Toggled::False });
+            }
+            None => n.set_role(Role::MenuItem),
+        }
+    });
+}
+
+/// A text field with a name (and its text as the value).
+pub(crate) fn text_input(r: &Response, label: &str, text: &str) {
+    node(r, |n| {
+        n.set_role(Role::TextInput);
+        n.set_label(label);
+        n.set_value(text);
+    });
+}
+
+/// A progress bar: `fraction` 0..=1 and the sentence it shows.
+pub(crate) fn progress(r: &Response, label: &str, fraction: f32) {
+    node(r, |n| {
+        n.set_role(Role::ProgressIndicator);
+        n.set_label(label);
+        n.set_min_numeric_value(0.0);
+        n.set_max_numeric_value(1.0);
+        n.set_numeric_value(f64::from(fraction.clamp(0.0, 1.0)));
+    });
+}
+
+// ------------------------------------------------------------------------------------------
+// List keyboard handling
+
+/// Ask for the keyboard focus on widget `id` once it is drawn (a list moves its focus to the row
+/// the arrow keys reached, which may not be focusable, or drawn, until the next pass). `key`
+/// names the list.
+pub(crate) fn focus_next_pass(ctx: &Context, key: &str, id: Id) {
+    let pass = ctx.cumulative_pass_nr();
+    ctx.data_mut(|d| d.insert_temp(Id::unique(("a11y-pending-focus", key)), (id, pass)));
+}
+
+/// True once, for the widget `focus_next_pass` named for list `key`: the caller then requests the
+/// focus. A request nobody answers within a few passes is dropped.
+pub(crate) fn take_pending_focus(ctx: &Context, key: &str, id: Id) -> bool {
+    let slot = Id::unique(("a11y-pending-focus", key));
+    let now = ctx.cumulative_pass_nr();
+    let Some((want, at)) = ctx.data(|d| d.get_temp::<(Id, u64)>(slot)) else { return false };
+    if now > at.saturating_add(4) {
+        ctx.data_mut(|d| d.remove::<(Id, u64)>(slot));
+        return false;
+    }
+    if want != id || now == at {
+        return false;
+    }
+    ctx.data_mut(|d| d.remove::<(Id, u64)>(slot));
+    true
+}
diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs
new file mode 100644
index 000000000..dced78349
--- /dev/null
+++ b/crates/ui-egui/src/app.rs
@@ -0,0 +1,180 @@
+use super::clock::AppClock;
+use super::hooks::Hooks;
+use super::state::{FrameWindow, PlaybackPass, ShotTarget};
+use super::*;
+
+mod clipboard;
+mod files;
+mod frame;
+mod gpu;
+mod input;
+mod playback;
+mod prefetch;
+mod prefs;
+mod screenshot;
+mod viewer_frames;
+mod window;
+
+pub use gpu::{GPU_PREPARING, GpuBuild};
+#[cfg(test)]
+pub(crate) use screenshot::{MAX_PENDING_SHOTS, SCREENSHOT_SETTLE_PASSES, SCREENSHOT_SETTLE_S, SCREENSHOT_TIMEOUT_S};
+
+impl EffectcraftApp {
+    /// The window title as of the last tick (`EffectCraft - <project>`, ` *` while modified). The
+    /// app sends it as `ViewportCommand::Title`, which eframe on the web ignores: that host writes
+    /// it to `document.title`.
+    pub fn window_title(&self) -> &str {
+        &self.window_title
+    }
+
+    /// Build the app around `session`.
+    /// Loads and applies the workspaces saved in the session's config directory (a failed load is reported in
+    /// `ui.status`), initializes the default UI, playback and render state, and registers the frontend's commands as
+    /// shortcutable `UiCommand`s on the session.
+    pub fn new(session: Session) -> Self {
+        let mut ui = UiState::default();
+        let workspace_store = workspace_state::WorkspaceStore::load(session.config.as_deref(), &mut ui);
+        EffectcraftApp {
+            session,
+            ui,
+            workspace_store,
+            tokens: Tokens::for_kind(Default::default()),
+            auto: Default::default(),
+            frames: Frames::default(),
+            playback: Playback::default(),
+            dialog: None,
+            hooks: Hooks::default(),
+            fps: 60.0,
+            clock: AppClock::default(),
+            now: 0.0,
+            last_time: 0.0,
+            styled: false,
+            fonts_ready: false,
+            styled_language: "",
+            focused: true,
+            input_active: false,
+            last_pointer_down: false,
+            draw_geom: None,
+            geometry_epoch: 0,
+            ime_tracker: egui::ImeContextTracker::new(),
+            ui_pass_seq: 0,
+            want_paint: false,
+            synthetic_in_flight: false,
+            synthetic_in_flight_events: vec![],
+            last_viewer_scale: None,
+            control_rx: None,
+            deferred: vec![],
+            synthetic: vec![],
+            forwarded: ForwardedInput::default(),
+            input_waiters: vec![],
+            job_waiters: vec![],
+            pending_screenshots: vec![],
+            shot_bytes: 0,
+            last_activity: (0.0, 0),
+            last_edit: (0.0, 0),
+            toast: None,
+            viewer_tex: None,
+            passive_tex: std::collections::HashMap::new(),
+            viewer_native: None,
+            viewer_shown: None,
+            viewer_image: None,
+            viewer_readback: Default::default(),
+            wgpu: None,
+            gpu: None,
+            gpu_checked: false,
+            #[cfg(not(target_arch = "wasm32"))]
+            gpu_build: None,
+            gpu_failures: None,
+            gpu_failure_applied: None,
+            footage_watcher: None,
+            footage_watch_key: None,
+            device_lost_close: None,
+            dialog_answers: std::sync::mpsc::channel(),
+            file_dialogs: FileDialogsUp::default(),
+            command_inbox: None,
+            pointer_comp: None,
+            dialog_state: Default::default(),
+            integrated_titlebar: false,
+            audio: None,
+            scrub: None,
+            meter: Default::default(),
+            expression_diagnostics: Default::default(),
+            waveforms: Default::default(),
+            last_reveal: None,
+            applied_prefs: None,
+            recovery: None,
+            dock_rects: vec![],
+            native_viewports: vec![],
+            unpublished_viewports: vec![],
+            pending_panel_raise: None,
+            home_thumbs: Default::default(),
+            home_thumb_saved: None,
+            window_title: String::new(),
+            template_thumbs: Default::default(),
+            template_list: None,
+            updates_rt: updates_ui::Runtime::default(),
+        }
+        .with_ui_commands()
+    }
+
+    /// Offer the frontend's commands (tools, timeline navigation…) for keyboard shortcuts.
+    fn with_ui_commands(mut self) -> Self {
+        let cmds = menus::UI_COMMANDS
+            .iter()
+            .map(|c| effectcraft_engine::shortcuts::UiCommand { id: c.id.into(), label: c.label.into(), shortcut: c.shortcut.map(str::to_string), scope: None })
+            .collect();
+        self.session.set_ui_commands(cmds);
+        self
+    }
+
+    pub fn with_control(mut self, rx: Receiver<ControlRequest>) -> Self {
+        self.control_rx = Some(rx);
+        self
+    }
+}
+
+impl eframe::App for EffectcraftApp {
+    fn on_exit(&mut self) {
+        self.save_workspace_state();
+        // Clean exit: no crash recovery next launch (unless the graphics device was lost with
+        // unsaved changes, which are in the auto-save it offers).
+        if self.device_lost_close != Some(true) {
+            self.session.end_recovery();
+        }
+    }
+
+    /// Feed pending synthetic input into `raw_input` only once fonts are ready (so a non-drawing pass never consumes
+    /// a batch), then prepare pointer wrapping; ending a numeric scrub clears the history merge key so the next edit
+    /// starts a new undo step.
+    fn raw_input_hook(&mut self, ctx: &egui::Context, raw_input: &mut egui::RawInput) {
+        raw_input.events.append(&mut self.forwarded.events);
+        raw_input.dropped_files.append(&mut self.forwarded.files);
+        let injected = self.synthetic_in_flight || !self.synthetic.is_empty();
+        // Only a pass that can draw may receive synthetic input: `Context::run_ui` applies
+        // everything the hook feeds to its input state, so a pass that cannot draw (fonts still
+        // installing) would consume a batch it could not put back — putting it back would apply
+        // the click/key state twice. The queue waits here for the first pass that draws.
+        if self.fonts_ready {
+            self.feed_synthetic(raw_input);
+        }
+        if pointer_wrap::prepare_input(ctx, raw_input, injected) {
+            self.session.history.merge_key = None;
+        }
+    }
+
+    /// The logic-only tick: run `tick`, close the IME pass with `finish_ime_logic` and, last, hand a close to the
+    /// platform quit (`panels::unsaved::quit_on_close`). It does not read pass-time
+    /// input state (events, pointer and time are stale here), only the viewport information eframe refreshed.
+    fn logic(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
+        // Never `ctx.input(|i| i.time)` here: `Context::run_logic` leaves events, pointer state and
+        // time at the previous full pass's values (only the viewport information is refreshed).
+        self.tick(ctx, frame);
+        self.finish_ime_logic(ctx);
+        crate::panels::unsaved::quit_on_close(ctx);
+    }
+
+    /// Draw one UI pass through `draw`.
+    fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
+        self.draw(ui, frame);
+    }
+}
diff --git a/crates/ui-egui/src/app/clipboard.rs b/crates/ui-egui/src/app/clipboard.rs
new file mode 100644
index 000000000..23b5080e0
--- /dev/null
+++ b/crates/ui-egui/src/app/clipboard.rs
@@ -0,0 +1,63 @@
+#[cfg(test)]
+use super::*;
+
+/// Put `width` × `height` straight-alpha RGBA8 pixels on the system clipboard (Composition ▸ Copy
+/// Frame to Clipboard). The pixel count is checked first: egui's image constructor panics on a
+/// size that doesn't match its buffer.
+pub(super) fn copy_image(ctx: &egui::Context, width: u32, height: u32, rgba: &[u8]) -> Result<(), String> {
+    let (w, h) = (width as usize, height as usize);
+    if w == 0 || h == 0 || w.checked_mul(h).and_then(|n| n.checked_mul(4)) != Some(rgba.len()) {
+        return Err(format!("cannot copy a malformed {width}×{height} image to the clipboard"));
+    }
+    ctx.copy_image(egui::ColorImage::from_rgba_unmultiplied([w, h], rgba));
+    Ok(())
+}
+
+#[cfg(test)]
+mod copy_frame_tests {
+    use super::*;
+
+    fn copied(output: &egui::FullOutput) -> Vec<&egui::ColorImage> {
+        output
+            .platform_output
+            .commands
+            .iter()
+            .filter_map(|c| match c {
+                egui::OutputCommand::CopyImage(image) => Some(image),
+                _ => None,
+            })
+            .collect()
+    }
+
+    /// Composition ▸ Copy Frame to Clipboard puts the rendered frame on the system clipboard.
+    #[test]
+    fn copy_frame_puts_the_frame_on_the_clipboard() {
+        let mut session = Session::default();
+        session.execute("comp.new", json!({"name": "Copy", "width": 8, "height": 6, "duration": 1})).unwrap();
+        session.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
+        let mut app = EffectcraftApp::new(session);
+        let ctx = egui::Context::default();
+        let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
+            crate::menus::invoke(&mut app, ui.ctx(), "comp.copyFrame", json!({})).unwrap();
+            app.handle_events(ui.ctx());
+        });
+        output.textures_delta.clear();
+        let images = copied(&output);
+        assert_eq!(images.len(), 1);
+        assert_eq!(images[0].size, [8, 6]);
+        assert!(images[0].pixels.iter().all(|p| *p == egui::Color32::from_rgb(255, 0, 0)));
+    }
+
+    /// A malformed image never reaches egui's panicking constructor.
+    #[test]
+    fn a_malformed_image_is_an_error_not_a_crash() {
+        let ctx = egui::Context::default();
+        let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
+            assert!(copy_image(ui.ctx(), 4, 4, &[0; 10]).is_err());
+            assert!(copy_image(ui.ctx(), 0, 4, &[]).is_err());
+            assert!(copy_image(ui.ctx(), u32::MAX, u32::MAX, &[0; 4]).is_err());
+        });
+        output.textures_delta.clear();
+        assert!(copied(&output).is_empty());
+    }
+}
diff --git a/crates/ui-egui/src/app/files.rs b/crates/ui-egui/src/app/files.rs
new file mode 100644
index 000000000..b1beab972
--- /dev/null
+++ b/crates/ui-egui/src/app/files.rs
@@ -0,0 +1,11 @@
+use super::{Dialog, EffectcraftApp};
+
+impl EffectcraftApp {
+    /// Show the crash-recovery dialog for a previous run that didn't exit cleanly.
+    pub fn offer_recovery(&mut self, r: effectcraft_engine::autosave::Recovery) {
+        if r.autosave.is_some() {
+            self.recovery = Some(r);
+            self.dialog = Some(Dialog::Recovery);
+        }
+    }
+}
diff --git a/crates/ui-egui/src/app/frame.rs b/crates/ui-egui/src/app/frame.rs
new file mode 100644
index 000000000..ffbf57257
--- /dev/null
+++ b/crates/ui-egui/src/app/frame.rs
@@ -0,0 +1,585 @@
+use super::clipboard::copy_image;
+use super::window::fit_window;
+use super::*;
+
+impl EffectcraftApp {
+    /// Completed, non-discarded UI passes since launch.
+    pub fn ui_passes(&self) -> u64 {
+        self.ui_pass_seq
+    }
+
+    // ---------------------------------------------------------------- control channel
+
+    pub(crate) fn raise_for_control(&mut self, ctx: &egui::Context) {
+        ctx.request_repaint();
+    }
+
+    /// Handle the control channel for this tick: drain queued requests plus previously deferred ones, run each
+    /// through `control::handle`, answer `Done` immediately, retry `Retry` until its three-second deadline, hold
+    /// input/job/screenshot replies until their event happens and finish job waiters. Retry timeouts and refused
+    /// screenshots are answered as `{"ok": false, "error": ...}`; the receiver is kept for the next tick.
+    fn drain_control(&mut self, ctx: &egui::Context, now: f64) {
+        let Some(rx) = self.control_rx.take() else { return };
+        let mut reqs: Vec<(ControlRequest, f64)> = std::mem::take(&mut self.deferred);
+        while let Ok(req) = rx.try_recv() {
+            reqs.push((req, now + 3.0));
+        }
+        for (req, deadline) in reqs {
+            let reply = req.reply.clone();
+            match control::handle(self, ctx, &req, now) {
+                control::Outcome::Done(v) => {
+                    let _ = reply.send(v);
+                }
+                control::Outcome::Retry(msg) => {
+                    if now < deadline {
+                        self.deferred.push((req, deadline));
+                        ctx.request_repaint();
+                    } else {
+                        let _ = reply.send(json!({"ok": false, "error": msg}));
+                    }
+                }
+                control::Outcome::AfterInput => {
+                    self.input_waiters.push(reply);
+                    // The reply waits for a real UI pass: a hidden window must run one.
+                    self.want_paint = true;
+                }
+                control::Outcome::AwaitJobs(w) => {
+                    self.job_waiters.push((w, reply));
+                    ctx.request_repaint();
+                }
+                control::Outcome::Screenshot { path, target } => {
+                    // A covered or minimized window presents no frames (macOS skips its redraws), so
+                    // a screenshot would never arrive and nothing would tick its timeout. The
+                    // hidden-window capture path (a pending screenshot forces a pass in 0.37) needs
+                    // a native platform run before this gate is removed; the web build never paints
+                    // a hidden tab.
+                    if ctx.input(|i| i.viewport().occluded == Some(true) || i.viewport().minimized == Some(true)) {
+                        let _ = reply.send(json!({"ok": false, "error": "window is covered or minimized: call ui.focus first (render.frame renders comp pixels without the window)"}));
+                        continue;
+                    }
+                    self.admit_screenshot(ctx, path, target, reply);
+                }
+            }
+        }
+        self.control_rx = Some(rx);
+        self.finish_job_waiters(ctx);
+    }
+
+    /// Reply to the control requests whose offloaded jobs ended.
+    fn finish_job_waiters(&mut self, ctx: &egui::Context) {
+        if self.job_waiters.is_empty() {
+            return;
+        }
+        self.session.poll_render();
+        self.session.poll_offload();
+        let waiters = std::mem::take(&mut self.job_waiters);
+        for (w, reply) in waiters {
+            if w.pending(self) {
+                self.job_waiters.push((w, reply));
+            } else {
+                let v = w.finish(self);
+                let _ = reply.send(v);
+            }
+        }
+        if !self.job_waiters.is_empty() {
+            ctx.request_repaint_after(std::time::Duration::from_millis(50));
+        }
+    }
+
+    // ---------------------------------------------------------------- frame
+
+    /// Apply the engine events drained this tick: open a comp, show a toast, open a URL, run a frontend command,
+    /// purge frame caches or copy an image; command and clipboard failures go to `app.ui.status`.
+    pub(crate) fn handle_events(&mut self, ctx: &egui::Context) {
+        for ev in self.session.drain_events() {
+            match ev {
+                effectcraft_engine::Event::OpenComp(c) => {
+                    panels::viewers::on_open_comp(self, c);
+                    self.ui.timeline.pps = None;
+                }
+                effectcraft_engine::Event::Toast { message, .. } => self.toast = Some((message, self.now)),
+                effectcraft_engine::Event::OpenUrl(url) => ctx.open_url(egui::OpenUrl::new_tab(url)),
+                // Frames are keyed by content: an edit keeps those of comps it doesn't touch.
+                effectcraft_engine::Event::ProjectChanged { .. } => {}
+                effectcraft_engine::Event::Frontend { command, params } => {
+                    if let Err(e) = crate::menus::frontend(self, ctx, &command, params) {
+                        self.ui.status = e;
+                    }
+                }
+                effectcraft_engine::Event::PurgeCaches => self.frames.clear(),
+                effectcraft_engine::Event::CopyImage { width, height, rgba } => {
+                    if let Err(e) = copy_image(ctx, width, height, &rgba) {
+                        self.ui.status = e;
+                    }
+                }
+            }
+        }
+    }
+
+    /// The app's only non-paint entry: one tick of background work.
+    ///
+    /// This runs for every eframe logic callback, including the logic-only ticks of a hidden
+    /// window (which never reach [`Self::draw`]). It must therefore do no input handling, no
+    /// layout and no presentation: engine/job queues, autosave, playback, audio, the control
+    /// channel, screenshots and the close guard. Everything here is idempotent for a pass that
+    /// `Context::request_discard` replays.
+    pub fn tick(&mut self, ctx: &egui::Context, frame: &eframe::Frame) {
+        self.now = self.clock.now();
+        // The compositor exists before the first paint and while hidden (device-loss handling
+        // must run there too).
+        self.init_gpu(ctx, frame);
+        self.apply_gpu_failure(ctx);
+        if self.gpu_failure_applied == Some(true) {
+            self.close_after_device_loss(ctx);
+            // On macOS the app quits through `-[NSApplication terminate:]` instead of closing the
+            // window while AppKit's run loop is running (#341).
+            craft_quit::on_close_request(ctx);
+            return;
+        }
+        // Focus comes from the fresh viewport copy; a full pass's `InputState::focused` is only a
+        // fallback (a logic-only tick leaves it at the previous pass's value).
+        let focused = ctx.input(|i| i.viewport().focused.or(Some(i.focused)));
+        self.focused = focused.unwrap_or(self.focused);
+        // The interface language's fallback fonts are installed in `draw` (fonts need a pass), but
+        // commands handled here use the right catalog already.
+        let language = crate::i18n::language(self);
+        crate::i18n::set_current(language);
+        // #1089: a font-menu rescan runs off the UI thread. Poll it on the logic tick so the
+        // status and the menu update even when the window is not painting.
+        crate::panels::text_panels::poll_font_rescan(self, ctx);
+        if self.styled_language != language {
+            self.want_paint = true;
+        }
+        // Frames and worker completions wake the app even while it is hidden.
+        self.frames.set_context(ctx);
+        updates_ui::tick(self, ctx);
+        if self.session.render_job.is_some() {
+            self.session.poll_render();
+            ctx.request_repaint_after(std::time::Duration::from_millis(100));
+        }
+        if self.session.track_job.is_some() {
+            self.session.poll_track();
+            ctx.request_repaint_after(std::time::Duration::from_millis(50));
+        }
+        if self.session.mask_job.is_some() {
+            self.session.poll_mask_track();
+            ctx.request_repaint_after(std::time::Duration::from_millis(50));
+        }
+        // Background tasks (Content-Aware Fill, Scene Edit Detection, imports).
+        if !self.session.tasks.is_empty() {
+            self.session.poll_jobs();
+            ctx.request_repaint_after(std::time::Duration::from_millis(100));
+        }
+        // Analyses running in a worker (the web app).
+        if !self.session.offloaded.is_empty() {
+            self.session.poll_offload();
+            ctx.request_repaint_after(std::time::Duration::from_millis(100));
+        }
+        // Warp Stabilizer: finish analyses and start queued (re-)analyses in the background.
+        if self.session.warp_job.is_some() || !self.session.warp_pending.is_empty() {
+            self.session.poll_warp(true);
+            self.session.poll_roto(true);
+            ctx.request_repaint_after(std::time::Duration::from_millis(100));
+        }
+        // Roto Brush propagation and Object Matte tracking / Freeze: finish jobs (a Freeze writes
+        // its mattes) and start queued ones in the background.
+        if self.session.roto_job.is_some() || !self.session.roto_pending.is_empty() {
+            self.session.poll_roto(true);
+            ctx.request_repaint_after(std::time::Duration::from_millis(100));
+        }
+        // 3D Camera Tracker: likewise (tracking, then solving).
+        if self.session.camera_job.is_some() || !self.session.camera_pending.is_empty() {
+            self.session.poll_camera(true);
+            ctx.request_repaint_after(std::time::Duration::from_millis(100));
+        }
+        self.run_script_tasks(ctx);
+        self.run_dialog_answers();
+        self.handle_events(ctx);
+        if let Some(rx) = self.command_inbox.take() {
+            while let Ok(id) = rx.try_recv() {
+                if let Err(e) = menus::invoke(self, ctx, &id, json!({})) {
+                    self.ui.status = e;
+                }
+            }
+            self.command_inbox = Some(rx);
+        }
+        // A close request (the window's button, Quit, `app.quit`) must be answered while hidden.
+        // An answered file dialog can change the project, so the answers above run first. The host
+        // calls `panels::unsaved::quit_on_close` last in its `logic`.
+        panels::unsaved::on_close_requested(self, ctx);
+        let title = panels::unsaved::window_title(self);
+        if title != self.window_title {
+            ctx.send_viewport_cmd(egui::ViewportCommand::Title(title.clone()));
+            self.window_title = title;
+        }
+        self.tick_autosave(ctx);
+        self.tick_workspace_autosave(ctx);
+        let now = self.now;
+        prefs_live::tick(self, ctx, now);
+        // Playback advances without a paint (its frames and the audio clock are background work).
+        // Idle prefetch keeps its old condition: it only runs once a viewer has drawn.
+        if (self.playback.playing || self.last_viewer_scale.is_some())
+            && let Some(cid) = self.session.active_comp_id()
+        {
+            let (scale, active) = (self.last_viewer_scale.unwrap_or(1.0), self.input_active);
+            self.advance_playback(ctx, scale, now, active, cid);
+        }
+        self.drain_control(ctx, now);
+        // Screenshot completion, deadlines and issuance are app-side work: the callback only
+        // stores pixels and wakes this viewport.
+        self.tick_screenshots(ctx);
+        // Time-based FPS readout over UI passes (a hidden logic-only tick is not a frame).
+        let dt = (now - self.last_time) as f32;
+        if dt > 0.0 && dt < 2.0 {
+            self.fps = self.fps * 0.9 + (1.0 / dt).min(480.0) * 0.1;
+        }
+        self.last_time = now;
+        // A hidden window paints when work needs a UI pass: queued input and waits, a settled
+        // screenshot, or playback into a child viewport.
+        let focused = self.focused;
+        let child_viewports = !self.ui.dock.layout.floating.is_empty() || prefs_live::video_preview_active(self, focused);
+        let paint = self.want_paint
+            || !self.synthetic.is_empty()
+            || !self.input_waiters.is_empty()
+            || self.pending_screenshots.iter().any(|s| s.slot.is_none())
+            || (self.playback.playing && child_viewports);
+        if paint {
+            self.request_hidden_paint(ctx);
+        }
+    }
+
+    /// Ask the host for a UI pass even when the window is minimized or occluded.
+    ///
+    /// Native eframe honours `RequestPaintWhileHidden`; the shared web backend does not carry it
+    /// yet (a browser does not paint a hidden tab), so the web build only requests a normal
+    /// repaint and hidden web screenshots/input remain unqualified.
+    fn request_hidden_paint(&mut self, ctx: &egui::Context) {
+        self.want_paint = false;
+        #[cfg(not(target_arch = "wasm32"))]
+        ctx.send_viewport_cmd(egui::ViewportCommand::RequestPaintWhileHidden);
+        ctx.request_repaint();
+    }
+
+    /// Install the theme and fonts for the current language. Fonts need a real pass: the pass
+    /// that installs them draws nothing, and the next pass draws with them (the two-pass warm-up
+    /// the app has always had). Never call this from a logic-only tick.
+    fn ui_setup(&mut self, ctx: &egui::Context) {
+        panels::viewer_text::install_hooks(ctx);
+        let language = crate::i18n::language(self);
+        crate::i18n::set_current(language);
+        if (!self.styled || self.styled_language != language) && self.synthetic_in_flight {
+            // The install needs a pass that draws nothing, but this pass has already applied a
+            // synthetic batch: defer the theme/font install by one pass instead of dropping the
+            // input (feeds are only put into a pass that can draw).
+            ctx.request_repaint();
+            return;
+        }
+        if !self.styled || self.styled_language != language {
+            theme::install(ctx, &self.tokens, language);
+            self.styled_language = language;
+            if !self.styled {
+                fit_window(ctx);
+                self.styled = true;
+            }
+            self.fonts_ready = false;
+            ctx.request_repaint();
+        } else if !self.fonts_ready {
+            // The pass after the install draws: egui has the new font definitions by now.
+            self.fonts_ready = true;
+            ctx.request_repaint();
+        }
+    }
+
+    /// One UI pass: setup, input-driven shortcuts, layout and painting. Called from
+    /// `eframe::App::ui` and by tests with the root `Ui`.
+    pub fn draw(&mut self, ui: &mut egui::Ui, frame: &eframe::Frame) {
+        panels::viewer_text::begin_ui(ui.ctx());
+        self.draw_inner(ui, frame);
+        // All exits, including fonts/device loss, observe this pass's real custom availability.
+        panels::viewer_text::finish_ime(self, ui);
+    }
+
+    /// Context creators install these hooks before the first full pass.
+    pub fn install_ime_reset_hooks(ctx: &egui::Context) {
+        panels::viewer_text::install_hooks(ctx);
+    }
+
+    /// Host wrappers call this after their last logic mutation, without replaying UI events.
+    pub fn finish_ime_logic(&self, ctx: &egui::Context) {
+        panels::viewer_text::finish_logic(self, ctx);
+    }
+
+    /// One UI pass after the IME begin hook: close on an applied GPU failure, run `ui_setup`, skip drawing until
+    /// fonts are ready, draw the frame, finish pointer wrapping, pump queued wasm frames, record input activity,
+    /// publish the completed pass's geometry and pass sequence, acknowledge applied synthetic input and answer
+    /// `AfterInput` replies only after a non-discarded pass. Requests repaints while frames are in flight.
+    fn draw_inner(&mut self, ui: &mut egui::Ui, frame: &eframe::Frame) {
+        let ctx = ui.ctx().clone();
+        if self.gpu_failure_applied == Some(true) {
+            self.close_after_device_loss(&ctx);
+            return;
+        }
+        self.ui_setup(&ctx);
+        if !self.fonts_ready {
+            // A pass that installs fonts draws nothing. No synthetic batch is in flight here (the
+            // hook feeds input only to a ready app), and events egui already applied are never
+            // fed again: that would double the pointer/key state of one click.
+            ctx.request_repaint();
+            return;
+        }
+        self.frame(ui);
+        #[cfg(not(target_arch = "wasm32"))]
+        pointer_wrap::finish_native(&ctx, frame);
+        // wasm32: no frame threads; render queued frames now, between UI frames.
+        if cfg!(target_arch = "wasm32") && self.frames.pump(std::time::Duration::from_millis(if self.playback.playing { 24 } else { 40 })) {
+            ctx.request_repaint();
+        }
+        // Input belongs to this known UI phase: record it for the next tick.
+        let active = ctx.input(|i| !i.events.is_empty() || i.pointer.any_down() || i.pointer.is_moving());
+        self.input_active = active;
+        self.last_pointer_down = ctx.input(|i| i.pointer.any_down());
+        // Geometry of a completed pass (a discarded pass is laid out again; only the final one
+        // describes the surface the next capture will see). Window position is irrelevant.
+        if !ctx.will_discard() {
+            let rect = ctx.content_rect();
+            let ppp = ctx.pixels_per_point();
+            let changed = self.draw_geom.is_none_or(|g| g.rect.size() != rect.size() || g.ppp != ppp);
+            if changed {
+                self.geometry_epoch = self.geometry_epoch.wrapping_add(1);
+            }
+            self.draw_geom = Some(DrawGeometry { rect, ppp, epoch: self.geometry_epoch });
+            self.ui_pass_seq = self.ui_pass_seq.saturating_add(1);
+        }
+        // A batch is acknowledged once a UI pass applied it, even if layout was later discarded.
+        self.mark_synthetic_applied();
+        // `AfterInput` replies wait for the final (non-discarded) pass that applied the last
+        // synthetic event: a hidden request is answered only after its forced pass, and a pass
+        // egui throws away cannot produce an early success reply.
+        if !ctx.will_discard() && self.synthetic.is_empty() {
+            for w in self.input_waiters.drain(..) {
+                let _ = w.send(json!({"ok": true, "result": null}));
+            }
+        } else if !self.input_waiters.is_empty() {
+            self.want_paint = true;
+            ctx.request_repaint();
+        }
+        if self.frames.inflight() > 0 {
+            ctx.request_repaint_after(std::time::Duration::from_millis(30));
+        }
+    }
+
+    /// The panels, menus, dialogs and overlays of one pass.
+    fn frame(&mut self, ui: &mut egui::Ui) {
+        let ctx = ui.ctx().clone();
+        // Only a viewer that draws in *this* pass records a scale: a closed viewer, the Home
+        // screen or another comp must stop idle prefetch at a stale scale.
+        self.last_viewer_scale = None;
+        self.apply_prefs(&ctx);
+        // Video Preview is a second viewport: only a real pass can update it.
+        prefs_live::frame(self, &ctx);
+        self.auto.begin_frame();
+        panels::viewer_tools::clear_sample_source(&ctx);
+        if let Some(rect) = crate::color_picker::take_automation(&ctx) {
+            self.auto.add("colorPicker.eyedropper", rect, "Eyedropper");
+        }
+        let tab_had_widget_focus = ctx.egui_wants_keyboard_input();
+        menus::handle_shortcuts(self, &ctx);
+        if !ctx.input(|i| i.pointer.primary_down()) {
+            self.ui.viewer.property_interacting = false;
+        }
+        let t = self.tokens;
+        let full = ui.max_rect();
+        if self.dialog.is_some() {
+            ui.disable();
+            // A dialog that edits what is behind it live (Preview) leaves the window at full
+            // brightness: clicks still don't reach it, but the canvas is not greyed out.
+            if self.dialog == Some(Dialog::GradientEditor) || panels::live_preview::active(self) {
+                ui.set_opacity(1.0);
+            }
+        }
+        ui.painter().rect_filled(full, 0.0, t.app_bg);
+        let mut top = full.min.y;
+        if self.ui.show_menu_bar {
+            let mb = egui::Rect::from_min_size(full.min, egui::vec2(full.width(), 24.0));
+            let mut child = ui.new_child(egui::UiBuilder::new().max_rect(mb));
+            child.painter().rect_filled(mb, 0.0, t.header_bg);
+            menus::menu_bar(self, &mut child);
+            top = mb.max.y;
+        }
+        let header_h = 40.0;
+        let header = egui::Rect::from_min_size(egui::pos2(full.min.x, top), egui::vec2(full.width(), header_h));
+        header::show(self, ui, header);
+        let body = egui::Rect::from_min_max(egui::pos2(full.min.x + 4.0, header.max.y + 2.0), egui::pos2(full.max.x - 4.0, full.max.y - 4.0));
+        crate::color_picker::note_dialog(&ctx, self.dialog);
+        // After the shortcuts, menus and header, which can replace the project (New, Open).
+        self.ui.timeline.scope_links(self.session.script_ui.project_epoch);
+        self.dock_area(ui, body);
+        #[cfg(not(target_arch = "wasm32"))]
+        prefs_live::dropped_files(self, ui, full);
+        if !tab_had_widget_focus {
+            menus::handle_tab_shortcut(self, &ctx);
+        }
+        panels::precomp::mini_flowchart(self, &ctx);
+        panels::home::capture_thumbnail(self);
+        panels::dialogs::show(self, &ctx);
+        updates_ui::show(self, &ctx);
+        panels::scriptui_view::sync_panels(self);
+        panels::scriptui_view::show_windows(self, &ctx);
+        panels::learn::coach(self, &ctx);
+        let lift = panels::media_panels::import_card(self, ui, full);
+        self.draw_toast(ui, full, lift);
+    }
+
+    /// Workspace-layout auto-save: a background write that also runs while hidden, once the
+    /// pointer has lifted.
+    fn tick_workspace_autosave(&mut self, ctx: &egui::Context) {
+        if self.session.config.is_none() || !self.workspace_store.has_changes(&self.ui) || self.last_pointer_down {
+            return;
+        }
+        if self.workspace_store.due(self.now) {
+            self.save_workspace_state();
+        }
+        if self.workspace_store.has_changes(&self.ui) {
+            ctx.request_repaint_after(std::time::Duration::from_secs(1));
+        }
+    }
+
+    pub(super) fn save_workspace_state(&mut self) {
+        if let Err(error) = self.workspace_store.save(self.session.config.as_deref(), &self.ui) {
+            if self.workspace_store.error.as_ref() != Some(&error) {
+                log::warn!("{error}");
+                self.ui.status = error.clone();
+            }
+            self.workspace_store.error = Some(error);
+        }
+    }
+
+    /// The status message or the latest toast, bottom left (`lift` points higher while the
+    /// Importing card is there).
+    fn draw_toast(&mut self, ui: &mut egui::Ui, full: egui::Rect, lift: f32) {
+        let now = self.now;
+        let msg = if !self.ui.status.is_empty() {
+            Some(self.ui.status.clone())
+        } else {
+            self.toast.as_ref().filter(|(_, at)| now - at < 4.0).map(|(m, _)| m.clone())
+        };
+        if let Some(m) = msg {
+            let t = &self.tokens;
+            let galley = ui.painter().layout_no_wrap(m.clone(), Tokens::ui(12.0), t.text);
+            let r = egui::Rect::from_min_size(egui::pos2(full.min.x + 16.0, full.max.y - 44.0 - lift), galley.size() + egui::vec2(24.0, 14.0));
+            ui.painter().rect_filled(r, 6.0, t.panel_bg);
+            ui.painter().rect_stroke(r, 6.0, egui::Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside);
+            ui.painter().galley(r.min + egui::vec2(12.0, 7.0), galley, t.text);
+            self.auto.add("toast", r, &m);
+            let resp = ui.interact(r, egui::Id::unique("toast"), egui::Sense::click());
+            if resp.clicked() {
+                self.ui.status.clear();
+                self.toast = None;
+            }
+            // "Preparing the GPU compositor…" stays until the compositor is attached (tens of
+            // seconds on a cold shader cache), not 5 s: `finish_gpu_build` clears it, and the
+            // worker's repaint brings that frame, so nothing needs to tick meanwhile. A click
+            // still dismisses it.
+            if self.ui.status == crate::GPU_PREPARING && self.gpu_initializing() {
+                return;
+            }
+            ui.ctx().request_repaint_after(std::time::Duration::from_millis(500));
+            if !self.ui.status.is_empty() {
+                let since: f64 = ui.data(|d| d.get_temp(egui::Id::unique("status-since")).unwrap_or(now));
+                ui.data_mut(|d| d.insert_temp(egui::Id::unique("status-since"), since));
+                if now - since > 5.0 {
+                    self.ui.status.clear();
+                    ui.data_mut(|d| d.remove::<f64>(egui::Id::unique("status-since")));
+                }
+            }
+        }
+    }
+}
+
+impl EffectcraftApp {
+    /// Scripts' `app.scheduleTask` tasks that are due (repeating ones keep a ScriptUI panel
+    /// fresh): errors as a toast, the last line printed in the status bar, and a repaint when
+    /// the next one is due.
+    fn run_script_tasks(&mut self, ctx: &egui::Context) {
+        if self.session.script_ui.task_hosts.is_empty() {
+            return;
+        }
+        let previous_comp = self.session.active_comp_id();
+        let Some(r) = effectcraft_engine::scriptui::ScriptUi::run_tasks(&mut self.session) else { return };
+        if self.session.active_comp_id().is_some() && self.session.active_comp_id() != previous_comp {
+            self.ui.start_screen = false;
+        }
+        if let Some(msg) = r["errors"].as_array().and_then(|e| e.first()).and_then(|e| e["message"].as_str()) {
+            self.toast = Some((format!("Scheduled script task: {msg}"), self.now));
+        } else if let Some(line) = r["output"].as_array().and_then(|o| o.last()).and_then(|l| l.as_str()) {
+            self.ui.status = line.to_string();
+        }
+        if let Some(next) = r["next"].as_u64() {
+            ctx.request_repaint_after(std::time::Duration::from_millis(next));
+        }
+    }
+
+    /// Auto-save a dirty project when the interval has passed (Settings ▸ Project ▸ Auto-Save).
+    fn tick_autosave(&mut self, ctx: &egui::Context) {
+        // Monotonic app time: a wall-clock jump must not skip or repeat an auto-save.
+        let now = self.now;
+        if let Some(Err(e)) = self.session.autosave_tick(now) {
+            self.ui.status = e.to_string();
+        }
+        if self.session.prefs.auto_save.enabled {
+            ctx.request_repaint_after(std::time::Duration::from_secs(30));
+        }
+        // File ▸ Watch Folder: look for new projects every 10 seconds.
+        if self.session.state.watch_folder.is_some() {
+            let key = egui::Id::unique("watchFolder.lastPoll");
+            let last: f64 = ctx.data(|d| d.get_temp(key)).unwrap_or(0.0);
+            if now - last >= 10.0 {
+                ctx.data_mut(|d| d.insert_temp(key, now));
+                match self.session.execute("file.watchFolder.poll", serde_json::json!({})) {
+                    Ok(r) => {
+                        if let Some(n) = r["rendered"].as_array().map(Vec::len).filter(|n| *n > 0) {
+                            self.ui.status = format!("Watch Folder: rendered {n} project(s)");
+                        }
+                    }
+                    Err(e) => self.ui.status = e.to_string(),
+                }
+            }
+            ctx.request_repaint_after(std::time::Duration::from_secs(10));
+        }
+        self.tick_footage_reload(ctx);
+    }
+
+    /// Settings ▸ Import ▸ Reload Footage Changed on Disk: a worker thread stamps the footage
+    /// files (every two seconds while the window is in front, and as soon as it comes back to
+    /// the front after saving in another app) and wakes this frame only when a stamp changed;
+    /// the changed files are reloaded here. Nothing here asks for a repaint: an idle app with
+    /// unchanged footage stays asleep.
+    fn tick_footage_reload(&mut self, ctx: &egui::Context) {
+        use effectcraft_engine::footage_reload;
+        if let Some(stamps) = self.footage_watcher.as_ref().and_then(footage_reload::Watcher::take)
+            && let Err(e) = footage_reload::apply_stamps(&mut self.session, stamps)
+        {
+            self.ui.status = e.to_string();
+        }
+        let off = self.session.prefs.import.auto_reload_footage == "off" || self.session.project.items.is_empty();
+        if off {
+            if let Some(w) = &mut self.footage_watcher {
+                w.set_watched(Default::default());
+            }
+            self.footage_watch_key = None;
+            return;
+        }
+        if self.footage_watcher.is_none() {
+            let wake = ctx.clone();
+            self.footage_watcher = footage_reload::Watcher::start(self.session.services.clone(), move || wake.request_repaint());
+        }
+        let Some(watcher) = &mut self.footage_watcher else { return };
+        watcher.set_focused(self.focused);
+        // Which files are watched follows the project and the preference, not the frame.
+        let key = (self.session.revision, self.session.prefs.import.auto_reload_footage.clone());
+        if self.footage_watch_key.as_ref() != Some(&key) {
+            self.footage_watch_key = Some(key);
+            watcher.set_watched(footage_reload::watched(&self.session));
+        }
+    }
+}
diff --git a/crates/ui-egui/src/app/gpu.rs b/crates/ui-egui/src/app/gpu.rs
new file mode 100644
index 000000000..225a8727c
--- /dev/null
+++ b/crates/ui-egui/src/app/gpu.rs
@@ -0,0 +1,329 @@
+use super::{Arc, EffectcraftApp, RenderSource, gpu_failure, menus, panels};
+
+/// The status line while the GPU compositor's worker thread is still building its pipelines
+/// (see [`EffectcraftApp::init_gpu`]).
+pub const GPU_PREPARING: &str = "Preparing the GPU compositor… (compositing on the CPU until it is ready)";
+/// What the compositor's worker thread hands back: the compositor, why the device can't run it,
+/// or the payload of a panic in the graphics backend.
+pub type GpuBuild = std::thread::Result<Result<effectcraft_gpu::Gpu, String>>;
+
+impl EffectcraftApp {
+    pub fn render_source(&self) -> RenderSource {
+        RenderSource {
+            project: self.session.project.clone(),
+            footage: self.session.footage.clone(),
+            expr: self.session.expr.clone(),
+            layer_cache: self.session.layer_cache.clone(),
+            gpu: self.gpu.clone(),
+            gpu_display: self.gpu_display(),
+            disk: self.session.disk_cache.clone(),
+        }
+    }
+
+    /// Keep GPU-composited viewer frames on the GPU (drawn from their texture). The browser can't
+    /// read frames back (its thread can't wait for the GPU), so there the viewer shows GPU frames
+    /// directly whenever it draws them plainly (RGB, no exposure, no region of interest); the
+    /// desktop reads them back (see [`frames::RenderSource::gpu_display`]).
+    fn gpu_display(&self) -> bool {
+        let v = &self.session.state.viewer;
+        cfg!(target_arch = "wasm32")
+            && v.channel == effectcraft_engine::viewer::Channel::Rgb
+            && v.exposure == 0.0
+            && self.session.state.region_of_interest.is_none()
+            && self.ui.viewer.extended.is_none()
+    }
+
+    /// The UI draws its panels and handles input such as dropped files. Until the fonts are
+    /// installed (the first frames) it draws nothing, and that input goes unhandled.
+    pub fn is_ready(&self) -> bool {
+        self.fonts_ready
+    }
+
+    /// Provide the executable/embedding host's device notifications. The host installs the
+    /// handlers once; this frontend never replaces handlers on a borrowed device.
+    pub fn set_gpu_failure_bridge(&mut self, bridge: gpu_failure::GpuFailureBridge) {
+        if let Some(gpu) = &self.gpu {
+            bridge.forward_to(gpu.context().device_failure_notifier());
+        }
+        self.gpu_failures = Some(bridge);
+    }
+
+    pub(super) fn apply_gpu_failure(&mut self, ctx: &egui::Context) {
+        let Some(bridge) = &self.gpu_failures else { return };
+        // Readback deadlines can retire the compositor without a host device notification.
+        if let Some(gpu) = &self.gpu
+            && let Err(reason) = gpu.context().check_health()
+        {
+            bridge.report(&reason, false);
+        }
+        let Some(failure) = bridge.failure() else { return };
+        if self.gpu_failure_applied == Some(failure.presentation_lost) {
+            return;
+        }
+        self.gpu_failure_applied = Some(failure.presentation_lost);
+        self.gpu_checked = true;
+        self.frames.retire_gpu();
+        self.session.accel = None;
+        self.session.accel_note = Some(format!("GPU preview retired: {}", failure.reason));
+        self.session.layer_cache.clear();
+        self.gpu = None;
+        if let Some(rs) = &self.wgpu {
+            let mut renderer = rs.renderer.write();
+            if let Some((id, _, _)) = &self.viewer_native {
+                renderer.free_texture(id);
+            }
+            for (_, texture) in self.passive_tex.values() {
+                if let panels::viewers::PassiveTexture::Gpu(id, _) = texture {
+                    renderer.free_texture(id);
+                }
+            }
+        }
+        self.viewer_native = None;
+        self.passive_tex.retain(|_, (_, texture)| matches!(texture, panels::viewers::PassiveTexture::Cpu(_)));
+        self.viewer_shown = self.viewer_tex.as_ref().map(|(texture, key, _)| (texture.id(), *key));
+        self.viewer_image = None;
+        // Old completion closures retain only their detached slot, not the replacement.
+        self.viewer_readback = Default::default();
+        self.wgpu = None;
+        self.ui.status = if failure.presentation_lost {
+            "Graphics device lost. The project is still open; presentation requires restarting the application.".into()
+        } else {
+            "Shared GPU preview disabled; CPU compositing remains available.".into()
+        };
+        log::warn!("GPU preview retired: {}", failure.reason);
+        ctx.request_repaint();
+    }
+
+    /// After the graphics device is lost, eframe's renderer cannot draw again: any mesh makes
+    /// egui-wgpu panic on the main thread when it cannot stage its index buffer (#591). Draw
+    /// nothing from then on, auto-save a project with unsaved changes (keeping the crash
+    /// recovery marker, so the next launch offers it) and close the window.
+    pub(super) fn close_after_device_loss(&mut self, ctx: &egui::Context) {
+        if self.device_lost_close.is_some() {
+            return;
+        }
+        let keep_recovery = self.session.is_dirty();
+        let saved = keep_recovery.then(|| match self.session.autosave_now().and_then(|path| self.session.autosave_wait().map(|()| path)) {
+            Ok(path) => {
+                log::warn!("graphics device lost: auto-saved {path}; the next launch offers to recover it");
+                Ok(path)
+            }
+            Err(e) => {
+                log::error!("graphics device lost: {e}");
+                Err(e.to_string())
+            }
+        });
+        self.device_lost_close = Some(keep_recovery);
+        log::warn!("graphics device lost: closing the window");
+        if let Some(tell) = &self.hooks.device_lost {
+            tell(saved);
+        }
+        ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+    }
+
+    /// Run the commands whose non-blocking file dialogs have been answered.
+    pub(crate) fn run_dialog_answers(&mut self) {
+        while let Ok(answer) = self.dialog_answers.1.try_recv() {
+            self.file_dialogs.answered();
+            menus::dialog_answered(self, answer);
+        }
+    }
+
+    /// Set up the GPU compositor on egui-wgpu's device (once). Without an adapter that runs
+    /// compute shaders (WebGL2, software GL) everything stays on the CPU.
+    ///
+    /// On the desktop the compositor is built on a worker thread. Its compute pipelines (about
+    /// 235 of them) take tens of seconds to compile on a cold shader cache (first launch, after
+    /// an OS update, after an update that changed a shader), and eframe shows the window only
+    /// once the first frame has painted, so building them here kept the window from appearing
+    /// at all. Until the worker is done the viewer composites on the CPU, as it does without a
+    /// GPU, and the status bar says so; the browser has no threads and builds it in place.
+    pub(crate) fn init_gpu(&mut self, ctx: &egui::Context, frame: &eframe::Frame) {
+        #[cfg(not(target_arch = "wasm32"))]
+        if self.gpu_build.is_some() {
+            self.finish_gpu_build(frame.wgpu_render_state());
+            return;
+        }
+        if self.gpu_checked {
+            return;
+        }
+        self.gpu_checked = true;
+        if self.gpu_failures.as_ref().is_some_and(|bridge| bridge.failure().is_some()) {
+            return;
+        }
+        let Some(rs) = frame.wgpu_render_state() else { return };
+        // Help ▸ System Compatibility Report names the adapter and backend the window got.
+        let info = rs.adapter.get_info();
+        self.session.window_adapter = Some(format!(
+            "{} ({:?}, {:?}{})",
+            info.name,
+            info.backend,
+            info.device_type,
+            if info.driver.is_empty() { String::new() } else { format!(", {} {}", info.driver, info.driver_info) }
+        ));
+        #[cfg(not(target_arch = "wasm32"))]
+        if self.spawn_gpu_build(ctx, rs) {
+            return;
+        }
+        // In place (the browser, or no thread to be had): nothing to wake later.
+        let _ = ctx;
+        // Backend validation can panic on shader compilation even when device creation
+        // succeeded. Keep the document and the egui renderer, and use CPU compositing.
+        let built = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| effectcraft_gpu::Gpu::new(&rs.adapter, rs.device.clone(), rs.queue.clone())));
+        self.attach_gpu(built, Some(rs));
+    }
+
+    /// Start building the compositor on a `gpu-compositor` worker thread, which hands its result
+    /// back to [`Self::finish_gpu_build`] and wakes the UI. False when no thread could be spawned
+    /// (the caller then builds it in place).
+    #[cfg(not(target_arch = "wasm32"))]
+    fn spawn_gpu_build(&mut self, ctx: &egui::Context, rs: &eframe::egui_wgpu::RenderState) -> bool {
+        let (tx, rx) = std::sync::mpsc::channel();
+        let (adapter, device, queue) = (rs.adapter.clone(), rs.device.clone(), rs.queue.clone());
+        let gate = self.hooks.before_gpu_build.take();
+        let wake = ctx.clone();
+        let spawned = std::thread::Builder::new().name("gpu-compositor".into()).spawn(move || {
+            // Backend validation can panic on shader compilation even when device creation
+            // succeeded: the panic stays on this thread and arrives as a result.
+            let built = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                if let Some(gate) = gate {
+                    gate();
+                }
+                effectcraft_gpu::Gpu::new(&adapter, device, queue)
+            }));
+            // No receiver: the window closed, or the device failed, while this was running.
+            let _ = tx.send(built);
+            wake.request_repaint();
+        });
+        if let Err(e) = spawned {
+            log::warn!("no worker thread for the GPU compositor ({e}); building it on the UI thread");
+            return false;
+        }
+        self.gpu_build = Some(rx);
+        self.session.accel_note = Some(GPU_PREPARING.into());
+        if self.ui.status.is_empty() {
+            self.ui.status = GPU_PREPARING.into();
+        }
+        true
+    }
+
+    /// Take the worker's result when it has arrived ([`Self::init_gpu`]). `rs`: the window's
+    /// device, which a compositor that built is attached to.
+    #[cfg(not(target_arch = "wasm32"))]
+    fn finish_gpu_build(&mut self, rs: Option<&eframe::egui_wgpu::RenderState>) {
+        let Some(rx) = &self.gpu_build else { return };
+        let built = match rx.try_recv() {
+            Ok(built) => built,
+            Err(std::sync::mpsc::TryRecvError::Empty) => return,
+            Err(std::sync::mpsc::TryRecvError::Disconnected) => {
+                Err(Box::new("the compositor's worker thread ended without a result") as Box<dyn std::any::Any + Send>)
+            }
+        };
+        self.gpu_build = None;
+        if self.ui.status == GPU_PREPARING {
+            self.ui.status.clear();
+        }
+        // The device failed while the compositor was being built: it stays detached, and
+        // `apply_gpu_failure` has already said why the viewer is on the CPU.
+        if self.gpu_failure_applied.is_some() || self.gpu_failures.as_ref().is_some_and(|bridge| bridge.failure().is_some()) {
+            return;
+        }
+        self.attach_gpu(built, rs);
+    }
+
+    /// Attach a built compositor to the viewer, or record why there is none. Keeps the document
+    /// and the egui renderer either way; without a compositor the viewer composites on the CPU.
+    fn attach_gpu(&mut self, built: GpuBuild, rs: Option<&eframe::egui_wgpu::RenderState>) {
+        match built {
+            Ok(Ok(g)) => {
+                if let Some(bridge) = &self.gpu_failures {
+                    bridge.forward_to(g.context().device_failure_notifier());
+                    if bridge.failure().is_some() {
+                        return;
+                    }
+                }
+                let Some(rs) = rs else {
+                    self.session.accel_note = Some("GPU compositor unavailable: the window has no wgpu device".into());
+                    return;
+                };
+                log::info!("GPU compositor: {}", effectcraft_engine::render::Accelerator::name(&g));
+                self.session.accel_note = None;
+                self.session.accel = Some(Arc::new(g.clone()));
+                self.gpu = Some(g);
+                self.wgpu = Some(rs.clone());
+            }
+            Ok(Err(e)) => {
+                log::info!("GPU compositor unavailable: {e}");
+                self.session.accel_note = Some(format!("GPU compositor unavailable: {e}"));
+            }
+            Err(e) => {
+                let reason = e.downcast_ref::<String>().map(String::as_str).or_else(|| e.downcast_ref::<&str>().copied()).unwrap_or("backend panicked");
+                log::warn!("GPU compositor setup failed; using CPU compositing: {reason}");
+                self.session.accel_note = Some(format!("GPU compositor setup failed: {reason}"));
+            }
+        }
+    }
+
+    /// Whether the GPU compositor is still being built on its worker thread (the viewer is on
+    /// the CPU meanwhile). Always false in the browser, which builds it with the first frame.
+    pub fn gpu_initializing(&self) -> bool {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            self.gpu_build.is_some()
+        }
+        #[cfg(target_arch = "wasm32")]
+        {
+            false
+        }
+    }
+
+    /// The viewer shows a frame composited on the GPU (drawn from its wgpu texture).
+    pub fn viewer_on_gpu(&self) -> bool {
+        matches!((&self.viewer_shown, &self.viewer_native), (Some(s), Some(n)) if s.1 == n.1)
+    }
+
+    /// The GPU compositor's adapter, when the viewer has one.
+    pub fn gpu_adapter(&self) -> Option<String> {
+        self.gpu.as_ref().map(effectcraft_engine::render::Accelerator::name)
+    }
+}
+
+#[cfg(test)]
+mod gpu_failure_tests {
+    use super::*;
+    use crate::{FrameKey, ItemId, RenderOpts, Session, Tick, json};
+
+    #[test]
+    fn host_failure_preserves_document_undo_and_cpu_pixels_and_detaches_late_readbacks() {
+        let mut session = Session::default();
+        let comp = ItemId(session.execute("comp.new", json!({"name": "Recovery", "width": 4, "height": 4, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
+        session.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap();
+        let before = session.render(comp, Tick::ZERO, RenderOpts::default());
+        let project = session.project.clone();
+        let revision = session.revision;
+        let prefs = serde_json::to_value(&session.prefs).unwrap();
+        let mut app = EffectcraftApp::new(session);
+        let ctx = egui::Context::default();
+        let bridge = gpu_failure::GpuFailureBridge::new(&ctx);
+        app.set_gpu_failure_bridge(bridge.clone());
+        let late_slot = app.viewer_readback.1.clone();
+        let key = FrameKey { revision, content: 1, comp: comp.0, frame: 0, scale: 1000, view: 0, opts: 0 };
+        app.viewer_readback.0 = Some(key);
+        bridge.report("synthetic host device failure", true);
+        app.apply_gpu_failure(&ctx);
+        assert!(Arc::ptr_eq(&project, &app.session.project));
+        assert_eq!(app.session.revision, revision);
+        assert_eq!(serde_json::to_value(&app.session.prefs).unwrap(), prefs);
+        assert!(app.gpu_checked, "failed device cannot be initialized again next frame");
+        assert!(app.session.accel.is_none());
+        assert!(app.ui.status.contains("presentation requires restarting"));
+        assert_eq!(app.session.render(comp, Tick::ZERO, RenderOpts::default()).data, before.data);
+        *late_slot.lock().unwrap() = Some((key, Arc::new(egui::ColorImage::new([1, 1], vec![egui::Color32::RED]))));
+        assert!(app.viewer_readback.0.is_none());
+        assert!(app.viewer_readback.1.lock().unwrap().is_none(), "a late completion cannot refill the replacement slot");
+        app.session.execute("edit.undo", json!({})).unwrap();
+        assert!(app.session.project.comp(comp).unwrap().layers.is_empty());
+        app.session.execute("edit.redo", json!({})).unwrap();
+        assert_eq!(app.session.render(comp, Tick::ZERO, RenderOpts::default()).data, before.data);
+    }
+}
diff --git a/crates/ui-egui/src/app/input.rs b/crates/ui-egui/src/app/input.rs
new file mode 100644
index 000000000..18a30c254
--- /dev/null
+++ b/crates/ui-egui/src/app/input.rs
@@ -0,0 +1,60 @@
+use super::*;
+
+impl EffectcraftApp {
+    /// Feed this frame's share of the queued synthetic input (control channel `ui.click`,
+    /// `ui.drag`…) into `raw_input`. Pointer events go one per frame so egui sees press → moves
+    /// → release as a real gesture.
+    ///
+    /// Only one batch is ever moved out at a time, even when the host prepares several hidden
+    /// logic-only iterations before the forced UI pass: eframe keeps the last prepared raw input
+    /// and would otherwise apply a whole drag or click as one burst. A batch is released by the
+    /// first UI pass that applies it ([`Self::mark_synthetic_applied`]). Callers must not feed a
+    /// pass that cannot draw (fonts still installing): egui applies what it receives, so putting
+    /// an applied batch back would apply its pointer/key state twice.
+    pub fn feed_synthetic(&mut self, raw_input: &mut egui::RawInput) {
+        if self.synthetic_in_flight || self.synthetic.is_empty() {
+            return;
+        }
+        // Pointer events go one per frame so egui sees press → moves → release as a real drag.
+        let pointer = |e: &egui::Event| matches!(e, egui::Event::PointerMoved(_) | egui::Event::PointerButton { .. } | egui::Event::MouseWheel { .. });
+        let n = if pointer(&self.synthetic[0]) {
+            1
+        } else {
+            self.synthetic
+                .iter()
+                .position(|e| pointer(e) || matches!(e, egui::Event::Key { pressed: false, .. }))
+                .map_or(self.synthetic.len(), |i| if pointer(&self.synthetic[i]) { i.max(1) } else { i + 1 })
+        };
+        let batch: Vec<egui::Event> = self.synthetic.drain(..n).collect();
+        raw_input.events.extend(batch.iter().cloned());
+        self.synthetic_in_flight_events.extend(batch);
+        self.synthetic_in_flight = true;
+    }
+
+    /// Clear the single-pending-batch guard: a UI pass has applied the injected batch.
+    ///
+    /// [`EffectcraftApp::draw`] calls this itself; harnesses that feed synthetic input
+    /// themselves (the headless kittest tests) call it after each pass they ran.
+    pub fn mark_synthetic_applied(&mut self) {
+        self.synthetic_in_flight_events.clear();
+        self.synthetic_in_flight = false;
+    }
+
+    /// The events of the injected batch that no UI pass has applied yet.
+    pub fn pending_synthetic_events(&self) -> &[egui::Event] {
+        &self.synthetic_in_flight_events
+    }
+
+    /// Whether a synthetic batch is waiting for its UI pass.
+    pub fn synthetic_in_flight(&self) -> bool {
+        self.synthetic_in_flight
+    }
+}
+
+impl EffectcraftApp {
+    /// Take the pending synthetic input (from `ui.click`, `ui.key`, …). Hosts that don't call
+    /// [`eframe::App::raw_input_hook`] (the headless test harness) feed these in themselves.
+    pub fn take_synthetic_input(&mut self) -> Vec<egui::Event> {
+        std::mem::take(&mut self.synthetic)
+    }
+}
diff --git a/crates/ui-egui/src/app/playback.rs b/crates/ui-egui/src/app/playback.rs
new file mode 100644
index 000000000..d40bc69ff
--- /dev/null
+++ b/crates/ui-egui/src/app/playback.rs
@@ -0,0 +1,192 @@
+use super::*;
+
+impl EffectcraftApp {
+    // ---------------------------------------------------------------- playback
+
+    pub fn play(&mut self, now: f64) {
+        let sc = self.session.prefs.preview.current;
+        self.play_with(now, sc);
+    }
+
+    /// Start the preview of a Preview panel shortcut (its range, play-from, rate, skip,
+    /// resolution, loop, caching, full screen and include options).
+    pub fn play_with(&mut self, now: f64, sc: effectcraft_engine::preview::PreviewShortcut) {
+        let Some(c) = self.session.active_comp_arc() else { return };
+        let preset = self.session.prefs.preview.get(sc).clone();
+        let plan = effectcraft_engine::preview::plan(&preset, &c, self.session.time());
+        let fr = c.frame_rate;
+        if plan.video {
+            self.session.set_time(fr.tick_of(plan.first));
+        }
+        let restore_max = preset.full_screen.then_some(self.ui.maximized);
+        let viewer = panels::viewers::active_panel(self);
+        if preset.full_screen && self.ui.dock.is_docked(viewer) {
+            self.ui.maximized = Some(viewer);
+        }
+        self.playback = Playback {
+            playing: true,
+            start_wall: now,
+            start_time: fr.tick_of(plan.first),
+            start_frame: plan.first,
+            shown: 0,
+            waiting: false,
+            fps: plan.fps,
+            shortcut: sc,
+            plan: Some(plan),
+            caching: plan.cache_first && plan.video,
+            res: preset.resolution.factor(preset.custom_resolution),
+            overlays: preset.include_overlays,
+            layer_controls: preset.include_layer_controls,
+            restore_max,
+            audio_frame: (!plan.video).then_some(plan.first),
+            audio_held: false,
+            starting: false,
+            starting_since: now,
+            first_cached: None,
+            shown_at: Default::default(),
+        };
+        if !self.playback.caching {
+            if plan.video {
+                let audible = self.audio_plays();
+                self.playback.audio_held = audible;
+                self.playback.starting = audible;
+            } else {
+                self.start_audio(fr.tick_of(plan.first));
+            }
+        }
+    }
+
+    /// The preview includes audio at the comp's frame rate and the comp has something audible.
+    fn audio_plays(&self) -> bool {
+        let (Some(pl), Some(cid)) = (self.playback.plan, self.session.active_comp_id()) else { return false };
+        let Some(c) = self.session.project.comp(cid) else { return false };
+        // A preview at another frame rate plays slower or faster than real time: silent.
+        pl.audio && (pl.fps - c.frame_rate.as_f64()).abs() <= 0.01 && effectcraft_engine::render::audio::comp_has_audio(&self.session.project, cid)
+    }
+
+    /// Start audio preview from comp time `t` when [`Self::audio_plays`] and an output device
+    /// opens.
+    pub(super) fn start_audio(&mut self, t: Tick) {
+        self.audio = None;
+        self.meter.clipped = [false; 2];
+        let (Some(pl), Some(cid)) = (self.playback.plan, self.session.active_comp_id()) else { return };
+        let Some(c) = self.session.project.comp_arc(cid).filter(|_| self.audio_plays()) else { return };
+        let out = audio::AudioOutput::from_prefs(&self.session.prefs);
+        let Some(dev) = self.hooks.audio_device.as_ref().and_then(|f| f(&out)) else { return };
+        let mix = self.session.prefs.audio.preview_sample_rate;
+        let fr = c.frame_rate;
+        match audio::AudioPlayback::start(dev, self.render_source(), cid, t, fr.tick_of(pl.start), fr.tick_of(pl.end + 1), pl.looping, mix) {
+            Ok(a) => self.audio = Some(a),
+            Err(e) => log::warn!("audio preview: {e}"),
+        }
+    }
+
+    /// Audio scrubbing: play the frame of `comp` at `t` (see [`audio::AudioScrub`]), opening the
+    /// output on first use. Silent comps and missing devices do nothing.
+    pub fn scrub_audio(&mut self, comp: ItemId, t: Tick, now: f64) {
+        if self.playback.playing || !effectcraft_engine::render::audio::comp_has_audio(&self.session.project, comp) {
+            return;
+        }
+        if self.scrub.is_none() {
+            let out = audio::AudioOutput::from_prefs(&self.session.prefs);
+            let Some(dev) = self.hooks.audio_device.as_ref().and_then(|f| f(&out)) else { return };
+            match audio::AudioScrub::open(dev, now) {
+                Ok(s) => self.scrub = Some(s),
+                Err(e) => {
+                    log::warn!("audio scrubbing: {e}");
+                    return;
+                }
+            }
+        }
+        let src = self.render_source();
+        let mix = self.session.prefs.audio.preview_sample_rate;
+        if let Some(s) = &mut self.scrub {
+            s.play(&src, comp, t, mix, now);
+        }
+    }
+
+    pub fn stop(&mut self) {
+        let was = std::mem::replace(&mut self.playback.playing, false);
+        self.audio = None;
+        self.playback.caching = false;
+        self.playback.starting = false;
+        if !was {
+            return;
+        }
+        if let Some(m) = self.playback.restore_max.take() {
+            self.ui.maximized = m;
+        }
+        let Some(pl) = self.playback.plan else { return };
+        let move_time = self.session.prefs.preview.get(self.playback.shortcut).move_time_to_preview_time;
+        if !move_time {
+            self.session.set_time(pl.origin);
+        } else if let Some(f) = self.playback.audio_frame
+            && let Some(c) = self.session.active_comp()
+        {
+            let t = c.frame_rate.tick_of(f);
+            self.session.set_time(t);
+        }
+    }
+
+    pub fn toggle_play(&mut self, now: f64) {
+        let sc = self.session.prefs.preview.current;
+        self.toggle_play_with(now, sc);
+    }
+
+    /// A preview shortcut pressed: start its preview, or stop the running one. While Cache
+    /// Before Playback is still rendering, "If caching, play cached frames" plays what is
+    /// cached so far instead of stopping.
+    pub fn toggle_play_with(&mut self, now: f64, sc: effectcraft_engine::preview::PreviewShortcut) {
+        if !self.playback.playing {
+            self.play_with(now, sc);
+            return;
+        }
+        if self.playback.caching && self.session.prefs.preview.get(self.playback.shortcut).play_cached_frames && self.play_cached(now) {
+            return;
+        }
+        self.stop();
+    }
+
+    /// Cut the caching preview down to the frames cached from its first frame on and play them.
+    fn play_cached(&mut self, now: f64) -> bool {
+        let (Some(mut pl), Some(cid)) = (self.playback.plan, self.session.active_comp_id()) else { return false };
+        let scale = self.viewer_shown.as_ref().map(|(_, k)| k.scale as f64 / 1000.0).unwrap_or(1.0);
+        let series = self.frame_series(cid, scale);
+        let mut last = None;
+        let mut f = pl.first;
+        while f <= pl.end && self.frames.is_cached(&FrameKey { frame: f, ..series }) {
+            last = Some(f);
+            f += pl.step;
+        }
+        let Some(last) = last else { return false };
+        pl.end = last;
+        pl.start = pl.first;
+        self.playback.plan = Some(pl);
+        self.playback.caching = false;
+        self.playback.start_wall = now;
+        self.playback.start_frame = pl.first;
+        let t = self.session.active_comp().map(|c| c.frame_rate.tick_of(pl.first)).unwrap_or_default();
+        self.start_audio(t);
+        true
+    }
+
+    /// A preview plays with Video off in the Preview panel (audio only): the current time stays
+    /// put, so the viewer and Timeline say so instead of looking stuck (#1118). The frame under
+    /// the audible sample, when one is known.
+    pub fn video_preview_off(&self) -> Option<Option<i64>> {
+        let p = self.playback.plan.filter(|_| self.playback.playing)?;
+        (!p.video).then_some(self.playback.audio_frame)
+    }
+
+    /// The viewer shows grids, guides and safe margins (hidden while a preview without
+    /// Include Overlays plays).
+    pub fn overlays_visible(&self) -> bool {
+        !self.playback.playing || self.playback.overlays
+    }
+
+    /// The viewer shows layer handles and paths (View ▸ Show Layer Controls, and Include Layer
+    /// Controls while a preview plays).
+    pub fn layer_controls_visible(&self) -> bool {
+        self.ui.viewer.show_layer_controls && (!self.playback.playing || self.playback.layer_controls)
+    }
+}
diff --git a/crates/ui-egui/src/app/prefetch.rs b/crates/ui-egui/src/app/prefetch.rs
new file mode 100644
index 000000000..d351ca411
--- /dev/null
+++ b/crates/ui-egui/src/app/prefetch.rs
@@ -0,0 +1,483 @@
+use super::{EffectcraftApp, FrameKey, FrameWindow, ItemId, PlaybackPass, audio, frames};
+
+/// Seconds without a project change before paused prefetch resumes (see
+/// [`EffectcraftApp::editing`]).
+const EDIT_QUIET: f64 = 0.3;
+
+/// Longest a preview with sound holds its first frame, once that frame is cached, waiting for the
+/// frames ahead (seconds, #947). A frame ahead that never gets cached mustn't hold it for ever:
+/// the sound starts from the first frame anyway, and the preview goes on as a stalled one does.
+const STARTUP_WAIT: f64 = 2.0;
+
+/// Longest a preview with sound holds its first frame in all (seconds, #947). The first frame
+/// itself can take a while (a heavy comp, a busy machine), and [`STARTUP_WAIT`] counts only from
+/// when it is cached; but one that never gets cached (larger than the RAM preview, which the size
+/// estimate can't always tell) mustn't hold it for ever. The preview then goes on as a stalled
+/// one does: its sound starts once the frames are cached.
+const STARTUP_LIMIT: f64 = 10.0;
+
+/// How many frames from the first a preview with sound waits for before it starts (#947): the
+/// prefetch's `ahead`, but no more than its `window` requests from the current frame (offsets
+/// `0..window`), and no more than fit in the RAM preview `budget` (90 %, as for the prefetch) at
+/// `frame_bytes`, the size frames really render at; at least the current frame, which the viewer
+/// always requests. Waiting for a frame that is never requested, or that can't stay cached with
+/// the others, would hold the first frame for ever.
+fn startup_frames(ahead: i64, window: i64, budget: usize, frame_bytes: usize) -> i64 {
+    let fit = (budget as f64 * 0.9 / frame_bytes.max(1) as f64) as i64;
+    ahead.min(window).min(fit).max(1)
+}
+
+impl EffectcraftApp {
+    /// RAM preview: advance at the preview's frame rate when frames are cached; otherwise hold
+    /// and keep rendering ahead (the green cache bar fills, then playback runs in real time).
+    pub(super) fn advance_playback(&mut self, ctx: &egui::Context, scale: f64, now: f64, input_active: bool, cid: ItemId) {
+        let Some(c) = self.session.project.comp_arc(cid) else { return };
+        let fr = c.frame_rate;
+        let plan = self.playback.plan.filter(|_| self.playback.playing);
+        let (wa, wb) = match plan {
+            Some(p) => (p.start, p.end),
+            None => (fr.frame_at(c.work_area.0), fr.frame_at(c.work_area.1 - c.frame_duration())),
+        };
+        let looping = plan.is_none_or(|p| p.looping);
+        let video = plan.is_none_or(|p| p.video);
+        // Prefetch ahead.
+        let cur = fr.frame_at(self.session.time());
+        let ahead = self.prefetch_ahead(ctx, now);
+        let queued = self.frames.inflight();
+        let series = self.frame_series(cid, scale);
+        // The preview's position orders prefetch and eviction (#595).
+        let playhead = plan.filter(|p| p.video).map(|p| frames::Playhead { series, cur, start: p.start, end: p.end, step: p.step, looping: p.looping });
+        self.frames.set_playhead(playhead);
+        let pass = PlaybackPass {
+            ctx,
+            comp: &c,
+            cid,
+            scale,
+            now,
+            frame_rate: fr,
+            series,
+            plan,
+            window: FrameWindow { first: wa, last: wb },
+            cur,
+            video,
+            looping,
+            ahead,
+            queued,
+        };
+        if self.cache_preview(&pass) {
+            return;
+        }
+        let step = plan.map_or(1, |p| p.step);
+        let fit_ahead = self.frames_that_fit(&c, scale) - 1;
+        self.prefetch_playback(&pass, fit_ahead);
+        self.pump_meters(ctx, now);
+        if !self.playback.playing {
+            self.cache_when_idle(ctx, &c, &series, now, input_active, (wa, wb));
+            return;
+        }
+        let fit = self.frames_that_fit(&c, scale);
+        if self.hold_first_frame(&pass, fit) {
+            return;
+        }
+        self.start_held_audio(&pass, fit);
+        if self.advance_audio_clock(&pass, step) {
+            return;
+        }
+        self.advance_frame_clock(&pass, step);
+    }
+
+    /// While paused (scrubbing, editing) the viewer's frame comes first: prefetch only a few
+    /// frames, only once it is done, and not while edits keep coming (a layer dragged in the
+    /// viewer): those frames would be stale at the next step and would hold the CPU and GPU
+    /// the next viewer frame needs.
+    fn prefetch_ahead(&mut self, ctx: &egui::Context, now: f64) -> i64 {
+        if self.playback.playing {
+            (self.frames_parallelism() * 2).max(4) as i64
+        } else if self.frames.urgent_pending() {
+            0
+        } else if let Some(wait) = self.editing(now) {
+            ctx.request_repaint_after(std::time::Duration::from_secs_f64(wait));
+            0
+        } else {
+            // Keep workers available for a newly edited viewer frame. Running obsolete
+            // background renders cannot be preempted by the priority queue.
+            self.frames_parallelism().saturating_sub(1).min(2) as i64
+        }
+    }
+
+    /// Cache Before Playback: the range in play order, then start the clock. A range larger than
+    /// the RAM preview budget is cut to the frames that fit (caching more would evict the first
+    /// ones and never finish). Returns true when this pass handled the preview.
+    fn cache_preview(&mut self, pass: &PlaybackPass<'_>) -> bool {
+        let PlaybackPass { ctx, comp, cid, scale, now, frame_rate: fr, series, plan, ahead, mut queued, .. } = *pass;
+        if !self.playback.caching {
+            return false;
+        }
+        let Some(p) = plan else { return false };
+        let mut all = true;
+        let n = (p.end - p.start) / p.step + 1;
+        let fit = self.frames_that_fit(comp, scale);
+        if n > fit {
+            let mut cut = p;
+            (cut.start, cut.end) = (p.first, (p.first + (fit - 1) * p.step).min(p.end));
+            self.playback.plan = Some(cut);
+            self.toast = Some((format!("Preview cut to {fit} of {n} frames: no more fit in the RAM preview (Settings ▸ Memory & CPU)"), now));
+            ctx.request_repaint();
+            return true;
+        }
+        let order: Vec<i64> = (0..n).filter_map(|k| p.frame_after(p.first, k)).collect();
+        for f in order {
+            if self.frames.is_cached(&FrameKey { frame: f, ..series }) {
+                continue;
+            }
+            all = false;
+            if queued < ahead as usize {
+                self.request_frame(cid, f, scale);
+                queued += 1;
+            }
+        }
+        self.playback.waiting = !all;
+        if all {
+            self.playback.caching = false;
+            self.playback.start_wall = now;
+            self.playback.start_frame = p.first;
+            self.session.set_time(fr.tick_of(p.first));
+            self.start_audio(fr.tick_of(p.first));
+        }
+        ctx.request_repaint();
+        true
+    }
+
+    /// Never further ahead than the RAM preview holds: those frames would evict the ones the
+    /// preview shows first, or be evicted before it gets there (#595). The window starts at the
+    /// first uncached frame ahead: after a loop or a restart the frames just ahead are cached,
+    /// and a window from the playhead left the workers idle until it came near the end of the
+    /// cached run. It stays ahead × 3 frames wide: workers spread over the whole preview render
+    /// frames with different layers at once (on the GPU, an atlas each: #1812).
+    fn prefetch_playback(&self, pass: &PlaybackPass<'_>, fit_ahead: i64) {
+        let PlaybackPass { cid, scale, plan, cur, ahead, series, mut queued, video, .. } = *pass;
+        let FrameWindow { first: wa, last: wb } = pass.window;
+        let frame = |k: i64| match plan {
+            Some(p) => p.frame_after(cur, k),
+            None => {
+                let f = cur + k;
+                Some(if f > wb { wa + (f - wb - 1).rem_euclid((wb - wa + 1).max(1)) } else { f })
+            }
+        };
+        let cached = self.frames.cached_frames(&series);
+        let uncached = |f: i64| cached.binary_search(&f).is_err();
+        let first = match plan.filter(|_| self.playback.playing) {
+            Some(p) => (0..fit_ahead.min((p.end - p.start) / p.step.max(1) + 1))
+                .map_while(|k| frame(k).map(|f| (k, f)))
+                .find(|&(_, f)| uncached(f))
+                .map_or(0, |(k, _)| k),
+            None => 0,
+        };
+        for k in first..(first + ahead * 3).min(fit_ahead) {
+            if queued >= ahead as usize || !video {
+                break;
+            }
+            let Some(f) = frame(k) else { break };
+            if uncached(f) {
+                self.request_frame(cid, f, scale);
+                queued += 1;
+            }
+        }
+    }
+
+    /// Advance the audio or scrub output and feed its latest peaks to the level meter; an idle scrub is closed after
+    /// one second. With no source but an active meter, drive the meter to silence and request a repaint.
+    fn pump_meters(&mut self, ctx: &egui::Context, now: f64) {
+        if let Some(a) = &mut self.audio {
+            a.pump();
+            self.meter.update(a.feed.take_peaks(), now);
+        } else if let Some(s) = &mut self.scrub {
+            // Scrubbing: the meters follow the snippets; an idle second closes the output.
+            s.pump();
+            self.meter.update(s.feed.take_peaks(), now);
+            if now - s.last_used > 1.0 {
+                self.scrub = None;
+            }
+            ctx.request_repaint_after(std::time::Duration::from_millis(50));
+        } else if self.meter.active() {
+            self.meter.update([0.0; 2], now);
+            ctx.request_repaint();
+        }
+    }
+
+    /// Starting a preview with sound: hold the first frame until the frames ahead are cached, then
+    /// start the sound from that same frame (see `Playback::starting`). Without an output device
+    /// the picture plays on its own clock from it. How many frames ahead: only ones
+    /// `prefetch_playback` requests and that fit in the RAM preview at the size they really render
+    /// (an Extended Viewer frame is larger than the comp), so the wait always ends. Returns true
+    /// while it holds the first frame.
+    fn hold_first_frame(&mut self, pass: &PlaybackPass<'_>, fit: i64) -> bool {
+        let PlaybackPass { ctx, comp, scale, now, plan, series, cur, ahead, frame_rate: fr, .. } = *pass;
+        if !self.playback.starting {
+            return false;
+        }
+        let Some(p) = plan else { return false };
+        self.playback.start_wall = now;
+        self.playback.start_frame = cur;
+        // `prefetch_playback` requests every uncached frame of offsets 0..window from here.
+        let window = (ahead * 3).min(fit - 1);
+        let need = self.frames.get(&FrameKey { frame: cur, ..series }).map(|img| {
+            let [w, h] = img.size();
+            startup_frames(ahead, window, self.frames.budget(), w.saturating_mul(h).saturating_mul(4))
+        });
+        if need.is_some() && self.playback.first_cached.is_none() {
+            self.playback.first_cached = Some(now);
+        }
+        // Don't wait for frames the RAM preview can't hold (not even one frame fits), for the
+        // frames ahead longer than STARTUP_WAIT once the first is in, nor longer than
+        // STARTUP_LIMIT in all (a frame that never gets cached).
+        let give_up = (self.frames.budget() as f64) < self.frame_bytes(comp, scale)
+            || self.playback.first_cached.is_some_and(|t| now - t >= STARTUP_WAIT)
+            || now - self.playback.starting_since >= STARTUP_LIMIT;
+        if !give_up && !need.is_some_and(|n| self.cached_ahead(&p, &series, cur, n)) {
+            self.playback.waiting = true;
+            ctx.request_repaint();
+            return true;
+        }
+        self.playback.starting = false;
+        self.playback.waiting = false;
+        // Not on a frame that isn't cached: the stall below would stop the sound at once. The
+        // preview goes on as a stalled one does, and the sound starts once frames are cached.
+        if need.is_some() {
+            self.playback.audio_held = false;
+            self.start_audio(fr.tick_of(cur));
+        }
+        false
+    }
+
+    /// Held sound starts once the frames ahead are cached again after a stall (see
+    /// `Playback::audio_held`): the prefetch window when the silent preview keeps real time, else
+    /// the rest of the preview.
+    fn start_held_audio(&mut self, pass: &PlaybackPass<'_>, fit: i64) {
+        let PlaybackPass { now, plan, series, cur, ahead, frame_rate: fr, .. } = *pass;
+        if !self.playback.audio_held {
+            return;
+        }
+        let Some(p) = plan else { return };
+        if (self.playback.keeps_up(now) && self.cached_ahead(&p, &series, cur, ahead.min(fit))) || self.cached_ahead(&p, &series, cur, fit) {
+            self.playback.audio_held = false;
+            self.playback.start_wall = now;
+            self.playback.start_frame = cur;
+            self.start_audio(fr.tick_of(cur));
+        }
+    }
+
+    /// Audio clock drives playback: show the frame under the audible sample. Returns true when
+    /// the audio path handled this pass (including stopping at the end).
+    fn advance_audio_clock(&mut self, pass: &PlaybackPass<'_>, step: i64) -> bool {
+        let PlaybackPass { ctx, now, series, video, frame_rate: fr, cur, .. } = *pass;
+        let FrameWindow { first: wa, last: wb } = pass.window;
+        let Some(a) = &self.audio else { return false };
+        if a.finished() {
+            if video {
+                self.session.set_time(fr.tick_of(wb));
+            } else {
+                self.playback.audio_frame = Some(wb);
+            }
+            self.stop();
+            return true;
+        }
+        let snap = |f: i64| wa + (f - wa).div_euclid(step) * step;
+        let target = snap(audio::frame_of_sample(a.clock(), a.rate, fr).clamp(wa, wb));
+        if !video {
+            self.playback.audio_frame = Some(target);
+        } else if self.frames.is_cached(&FrameKey { frame: target, ..series }) {
+            self.playback.waiting = false;
+            if target != cur {
+                self.session.set_time(fr.tick_of(target));
+                self.playback.frame_shown(now);
+            }
+        } else {
+            // Rendering can't keep up: rather than skip frames, the sound stops and every
+            // frame shows as it renders until the frames ahead are cached again.
+            self.audio = None;
+            self.playback.audio_held = true;
+            self.playback.waiting = true;
+            // The rate measured before the stall no longer says it keeps up.
+            self.playback.shown_at.clear();
+            self.playback.start_wall = now;
+            self.playback.start_frame = cur;
+        }
+        ctx.request_repaint();
+        true
+    }
+
+    /// The wall clock advances the preview when no audio device drives it, and shows the target
+    /// frame (or holds when it is not cached yet).
+    fn advance_frame_clock(&mut self, pass: &PlaybackPass<'_>, step: i64) {
+        let PlaybackPass { ctx, now, plan, video, looping, frame_rate: fr, cur, series, .. } = *pass;
+        let FrameWindow { first: wa, last: wb } = pass.window;
+        let elapsed = now - self.playback.start_wall;
+        // The plan carries the rate the preview was started with (and `play_with` copies it to
+        // `Playback::fps`). Deriving the frame from the plan keeps a logic-only tick correct even
+        // when a host/test supplies only the plan; a stale duplicate cannot hold playback open.
+        let fps = plan.map_or(self.playback.fps, |p| p.fps);
+        let n = ((elapsed * fps) / step as f64).floor() as i64;
+        let target = match plan {
+            Some(p) => p.frame_after(self.playback.start_frame, n),
+            None => {
+                let t = self.playback.start_frame + n;
+                if t <= wb {
+                    Some(t)
+                } else if looping {
+                    Some(wa + (t - wa).rem_euclid((wb - wa + 1).max(1)))
+                } else {
+                    None
+                }
+            }
+        };
+        let Some(target) = target else {
+            if video {
+                self.session.set_time(fr.tick_of(wb));
+            } else {
+                self.playback.audio_frame = Some(wb);
+            }
+            self.stop();
+            return;
+        };
+        if !video {
+            // Audio-only preview without an audio device: the clock runs, the time stays.
+            self.playback.audio_frame = Some(target);
+            ctx.request_repaint();
+            return;
+        }
+        if self.frames.is_cached(&FrameKey { frame: target, ..series }) {
+            self.playback.waiting = false;
+            if target != cur {
+                self.session.set_time(fr.tick_of(target));
+                self.playback.frame_shown(now);
+            }
+        } else {
+            // Not cached yet: hold the clock at the current frame (cache first, then play).
+            self.playback.waiting = true;
+            let next = plan.and_then(|p| p.frame_after(cur, 1)).unwrap_or(if cur + 1 > wb { wa } else { cur + 1 });
+            if self.frames.is_cached(&FrameKey { frame: next, ..series }) {
+                self.session.set_time(fr.tick_of(next));
+            }
+            self.playback.start_wall = now;
+            self.playback.start_frame = fr.frame_at(self.session.time());
+        }
+        ctx.request_repaint();
+    }
+
+    /// While the project keeps changing (an edit within [`EDIT_QUIET`] seconds), how long until
+    /// it counts as settled.
+    fn editing(&mut self, now: f64) -> Option<f64> {
+        if self.last_edit.1 != self.session.revision {
+            self.last_edit = (now, self.session.revision);
+        }
+        let left = EDIT_QUIET - (now - self.last_edit.0);
+        (left > 0.0).then_some(left)
+    }
+
+    /// Composition ▸ Preview ▸ Cache Frames When Idle: after a second without input or edits,
+    /// render the work area's frames (from the current time on, then from its start) in the
+    /// background, a few at a time, until it is cached or the RAM preview budget is full.
+    fn cache_when_idle(
+        &mut self,
+        ctx: &egui::Context,
+        comp: &effectcraft_engine::project::Comp,
+        series: &FrameKey,
+        now: f64,
+        input_active: bool,
+        (wa, wb): (i64, i64),
+    ) {
+        let active = input_active;
+        if active || self.last_activity.1 != self.session.revision {
+            self.last_activity = (now, self.session.revision);
+        }
+        if !self.ui.cache_when_idle || self.frames.urgent_pending() {
+            return;
+        }
+        let quiet = now - self.last_activity.0;
+        if quiet < 1.0 {
+            ctx.request_repaint_after(std::time::Duration::from_secs_f64(1.0 - quiet));
+            return;
+        }
+        // An empty work area has nothing to cache.
+        let n = wb - wa + 1;
+        if n < 1 {
+            return;
+        }
+        let cur = comp.frame_rate.frame_at(self.session.time()).clamp(wa, wb);
+        let fit = self.frames_that_fit(comp, series.scale as f64 / 1000.0).min(n);
+        // One thread each (`Frames::request_background`), so every frame thread takes one.
+        let slots = self.frames_parallelism().max(1);
+        let mut queued = self.frames.inflight();
+        let scale = series.scale as f64 / 1000.0;
+        let mut pending = false;
+        for k in 0..fit {
+            let f = wa + (cur - wa + k).rem_euclid(n);
+            if self.frames.is_cached(&FrameKey { frame: f, ..*series }) {
+                continue;
+            }
+            pending = true;
+            if queued >= slots {
+                break;
+            }
+            self.request_frame_background(ItemId(series.comp), f, scale);
+            queued += 1;
+        }
+        if pending {
+            ctx.request_repaint_after(std::time::Duration::from_millis(100));
+        }
+    }
+
+    /// How many viewer frames of `comp` at `scale` the RAM preview budget holds (90 % of it,
+    /// at least one).
+    /// The frames of `plan` from `cur` to its end, or as many as fit in the RAM preview, are
+    /// cached: sound can play from `cur` in real time.
+    fn cached_ahead(&self, plan: &effectcraft_engine::preview::PreviewPlan, series: &FrameKey, cur: i64, fit: i64) -> bool {
+        let cached = self.frames.cached_frames(series);
+        (0..fit).map_while(|k| plan.frame_after(cur, k)).take_while(|f| *f >= cur).all(|f| cached.binary_search(&f).is_ok())
+    }
+
+    fn frames_that_fit(&self, comp: &effectcraft_engine::project::Comp, scale: f64) -> i64 {
+        ((self.frames.budget() as f64 * 0.9 / self.frame_bytes(comp, scale)) as i64).max(1)
+    }
+
+    /// Bytes of one comp-sized viewer frame at `scale` (Extended Viewer frames are larger).
+    fn frame_bytes(&self, comp: &effectcraft_engine::project::Comp, scale: f64) -> f64 {
+        let side = |n: u32| (n as f64 * scale).ceil().max(1.0);
+        side(comp.width) * side(comp.height) * 4.0
+    }
+
+    fn frames_parallelism(&self) -> usize {
+        if cfg!(target_arch = "wasm32") {
+            // frame workers render one frame each; without them frames render one at a time
+            // on the UI thread (`Frames::pump`)
+            return self.frames.remote_slots().max(1);
+        }
+        self.frames.parallelism()
+    }
+}
+
+#[cfg(test)]
+mod startup_tests {
+    use super::startup_frames;
+
+    /// The frames a preview with sound waits for are always requested and fit together (#947).
+    #[test]
+    fn startup_waits_only_for_frames_it_requests_and_can_keep() {
+        // A 64×36 frame: 9216 bytes. A 46 080-byte budget fits 4 of them (90 %); the prefetch
+        // window then requests offsets 0..3, so the start needs those 3, not 4 it never asks for.
+        let frame = 64 * 36 * 4;
+        let fit = 4;
+        let window = (32i64 * 3).min(fit - 1);
+        assert_eq!(startup_frames(32, window, 46_080, frame), 3);
+        // A roomy budget: the prefetch's `ahead` frames.
+        assert_eq!(startup_frames(8, 24, 100_000_000, frame), 8);
+        // Extended Viewer: a 160×120 comp renders 320×248 frames. 952 320 bytes fit 11 comp-sized
+        // frames but only 2 real ones (90 %): wait for 2, not 4.
+        assert_eq!(startup_frames(4, 11, 952_320, 320 * 248 * 4), 2);
+        // Nothing fits, or no window: still the current frame, never 0.
+        assert_eq!(startup_frames(8, 0, 0, frame), 1);
+        // A zero frame size counts as 1 byte: no division by zero.
+        assert_eq!(startup_frames(8, 24, 10, 0), 8);
+    }
+}
diff --git a/crates/ui-egui/src/app/prefs.rs b/crates/ui-egui/src/app/prefs.rs
new file mode 100644
index 000000000..6fc424e01
--- /dev/null
+++ b/crates/ui-egui/src/app/prefs.rs
@@ -0,0 +1,166 @@
+use super::{EffectcraftApp, Tokens, json, theme};
+
+impl EffectcraftApp {
+    /// Apply changed settings: theme and brightness, label colours, tool tips, preview caches.
+    pub fn apply_prefs(&mut self, ctx: &egui::Context) {
+        // Sync with System re-applies when the system appearance changes (the host wakes the UI;
+        // nothing polls).
+        let system = if self.session.prefs.appearance.appearance_mode == "auto" { self.system_light(ctx) } else { None };
+        if self.applied_prefs == Some((self.session.prefs_revision, system)) {
+            return;
+        }
+        self.applied_prefs = Some((self.session.prefs_revision, system));
+        let p = &self.session.prefs;
+        self.ui.theme = theme::ThemeKind::from_name(p.appearance.resolved_theme(system)).unwrap_or_default();
+        self.tokens = Tokens::from_prefs(p, self.ui.theme);
+        theme::apply_visuals(ctx, &self.tokens);
+        ctx.set_theme(theme::theme_preference(&p.appearance.appearance_mode, self.ui.theme.is_light()));
+        let tips = p.general.show_tool_tips;
+        ctx.all_styles_mut(|s| s.interaction.tooltip_delay = if tips { 0.5 } else { f32::INFINITY });
+        // Settings ▸ Appearance ▸ UI Scale (#284). egui's own Ctrl+= / Ctrl+- / Ctrl+0 zoom stays
+        // off: Ctrl+0 is Window ▸ Project, and the scale is a setting.
+        ctx.options_mut(|o| o.zoom_with_keyboard = false);
+        ctx.set_zoom_factor(p.appearance.ui_scale as f32 / 100.0);
+        self.ui.cache_when_idle = p.previews.cache_frames_when_idle;
+        self.ui.viewer.fast_preview = p.previews.fast_previews;
+        self.frames.set_budget(p.cache_budgets(self.session.sys_memory).preview);
+    }
+
+    /// Change settings from the UI (applied next frame and saved).
+    pub fn set_pref(&mut self, key: &str, value: serde_json::Value) -> Result<(), String> {
+        self.session.prefs.set(key, value)?;
+        self.session.prefs_changed();
+        self.session.save_prefs();
+        Ok(())
+    }
+
+    /// Show theme `k`: the appearance mode becomes its family's (Dark or Light), and `k` that
+    /// family's theme.
+    pub fn set_theme(&mut self, ctx: &egui::Context, k: theme::ThemeKind) {
+        if let Err(e) = self.set_pref("appearance.theme", json!(k.name())) {
+            self.ui.status = e;
+        }
+        self.apply_prefs(ctx);
+    }
+
+    /// The system appearance: light (`Some(true)`), dark, or unknown. The host's answer (the Linux
+    /// desktop portal) wins over egui's, which Wayland compositors often leave empty.
+    pub fn system_light(&self, ctx: &egui::Context) -> Option<bool> {
+        self.hooks.system_theme.as_ref().and_then(|read| read(ctx)).or_else(|| ctx.system_theme()).map(|t| t == egui::Theme::Light)
+    }
+
+    /// The Tools bar's appearance button (`view.theme.toggle`): Sync with System, then Light, then
+    /// Dark, then Sync with System again. The light and dark theme choices are kept.
+    pub fn cycle_appearance(&mut self, ctx: &egui::Context) {
+        let next = match self.session.prefs.appearance.appearance_mode.as_str() {
+            "auto" => "light",
+            "light" => "dark",
+            _ => "auto",
+        };
+        if let Err(e) = self.set_pref("appearance.appearanceMode", json!(next)) {
+            self.ui.status = e;
+        }
+        self.apply_prefs(ctx);
+    }
+}
+
+#[cfg(test)]
+mod appearance_tests {
+    use super::*;
+    use crate::menus;
+    use crate::theme::ThemeKind;
+
+    fn app() -> EffectcraftApp {
+        EffectcraftApp::new(effectcraft_engine::Session::default())
+    }
+
+    /// The Tools bar's appearance button: Sync with System, Light, Dark, then Sync with System
+    /// again, showing the saved theme of each family without losing either choice.
+    #[test]
+    fn appearance_button_cycles_modes_without_losing_theme_choices() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        app.hooks.system_theme = Some(Box::new(|_| Some(egui::Theme::Dark)));
+        app.set_pref("appearance.darkTheme", json!("darker")).unwrap();
+        app.apply_prefs(&ctx);
+        assert_eq!(app.ui.theme, ThemeKind::Darker);
+        for (mode, shown) in [("auto", ThemeKind::Darker), ("light", ThemeKind::Light), ("dark", ThemeKind::Darker), ("auto", ThemeKind::Darker)] {
+            menus::invoke(&mut app, &ctx, "view.theme.toggle", json!({})).unwrap();
+            assert_eq!(app.session.prefs.appearance.appearance_mode, mode);
+            assert_eq!(app.ui.theme, shown, "{mode}");
+            assert_eq!(app.tokens.kind, shown);
+            assert_eq!(app.session.prefs.appearance.dark_theme, "darker");
+            assert_eq!(app.session.prefs.appearance.light_theme, "light");
+        }
+    }
+
+    /// Sync with System follows the host's answer (the Linux portal) when it changes, and falls
+    /// back to Dark when nothing reports a system appearance.
+    #[test]
+    fn auto_follows_a_stubbed_system_theme() {
+        use std::sync::{Arc, Mutex};
+        let ctx = egui::Context::default();
+        let mut app = app();
+        let system = Arc::new(Mutex::new(Some(egui::Theme::Light)));
+        let read = Arc::clone(&system);
+        app.hooks.system_theme = Some(Box::new(move |_| *read.lock().unwrap_or_else(std::sync::PoisonError::into_inner)));
+        app.set_pref("appearance.appearanceMode", json!("auto")).unwrap();
+        app.apply_prefs(&ctx);
+        assert_eq!(app.ui.theme, ThemeKind::Light);
+        *system.lock().unwrap() = Some(egui::Theme::Dark);
+        app.apply_prefs(&ctx);
+        assert_eq!(app.ui.theme, ThemeKind::Dark, "a system change applies without a settings change");
+        *system.lock().unwrap() = None;
+        app.apply_prefs(&ctx);
+        assert_eq!(app.ui.theme, ThemeKind::Dark);
+        // A fixed mode ignores the system.
+        *system.lock().unwrap() = Some(egui::Theme::Light);
+        app.set_pref("appearance.appearanceMode", json!("dark")).unwrap();
+        app.apply_prefs(&ctx);
+        assert_eq!(app.ui.theme, ThemeKind::Dark);
+    }
+
+    /// Sync with System leaves egui's theme preference at System, so egui never gives the native
+    /// window an appearance of its own (on macOS that stops system appearance changes reaching
+    /// the app, #642); egui's light and dark styles both carry the resolved theme. Fixed modes
+    /// pin the window to their family.
+    #[test]
+    fn auto_mode_leaves_the_native_window_following_the_system() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        app.hooks.system_theme = Some(Box::new(|_| Some(egui::Theme::Light)));
+        app.set_pref("appearance.appearanceMode", json!("auto")).unwrap();
+        app.apply_prefs(&ctx);
+        assert_eq!(app.ui.theme, ThemeKind::Light);
+        assert_eq!(ctx.options(|o| o.theme_preference), egui::ThemePreference::System);
+        for theme in [egui::Theme::Light, egui::Theme::Dark] {
+            assert_eq!(ctx.style_of(theme).visuals.panel_fill, app.tokens.panel_bg, "{theme:?}");
+        }
+        // egui asks the window to follow the system, never to take Light or Dark.
+        let mut out = ctx.run_ui(egui::RawInput::default(), |_| {});
+        out.textures_delta.clear();
+        let cmds = out.viewport_output.values().flat_map(|v| v.commands.iter()).collect::<Vec<_>>();
+        assert!(!cmds.iter().any(|c| matches!(c, egui::ViewportCommand::SetTheme(t) if t != &egui::SystemTheme::SystemDefault)), "{cmds:?}");
+        for (mode, pref) in [("light", egui::ThemePreference::Light), ("dark", egui::ThemePreference::Dark)] {
+            app.set_pref("appearance.appearanceMode", json!(mode)).unwrap();
+            app.apply_prefs(&ctx);
+            assert_eq!(ctx.options(|o| o.theme_preference), pref, "{mode}");
+            assert_eq!(ctx.global_style().visuals.panel_fill, app.tokens.panel_bg, "{mode}");
+        }
+    }
+
+    /// Picking a theme (`view.theme.*`, `ui.set {theme}`) fixes the mode to its family.
+    #[test]
+    fn picking_a_theme_fixes_its_mode() {
+        let ctx = egui::Context::default();
+        let mut app = app();
+        app.set_pref("appearance.appearanceMode", json!("auto")).unwrap();
+        menus::invoke(&mut app, &ctx, "view.theme.light", json!({})).unwrap();
+        assert_eq!(app.session.prefs.appearance.appearance_mode, "light");
+        assert_eq!(app.ui.theme, ThemeKind::Light);
+        menus::invoke(&mut app, &ctx, "view.theme.darker", json!({})).unwrap();
+        assert_eq!(app.session.prefs.appearance.appearance_mode, "dark");
+        assert_eq!(app.session.prefs.appearance.dark_theme, "darker");
+        assert_eq!(app.ui.theme, ThemeKind::Darker);
+    }
+}
diff --git a/crates/ui-egui/src/app/screenshot.rs b/crates/ui-egui/src/app/screenshot.rs
new file mode 100644
index 000000000..bf7dace0d
--- /dev/null
+++ b/crates/ui-egui/src/app/screenshot.rs
@@ -0,0 +1,394 @@
+use super::{DrawGeometry, EffectcraftApp, PendingShot, Sender, ShotTarget, control, json};
+
+/// How long a screenshot request waits for a frame, from admission (app clock seconds).
+pub(crate) const SCREENSHOT_TIMEOUT_S: f64 = 8.0;
+
+/// Seconds between a screenshot's admission and the earliest capture: the UI settles first.
+pub(crate) const SCREENSHOT_SETTLE_S: f64 = 0.35;
+
+/// Final (non-discarded) UI passes a screenshot waits for after admission before it is issued.
+pub(crate) const SCREENSHOT_SETTLE_PASSES: u64 = 3;
+
+/// Geometry changes a queued screenshot may retry before it reports an error.
+const SCREENSHOT_MAX_RETRIES: u32 = 4;
+
+/// Outstanding screenshot requests (queued or waiting for their pixels).
+pub(crate) const MAX_PENDING_SHOTS: usize = 4;
+
+/// One capture's pixels: 128 MiB.
+const MAX_SHOT_BYTES: usize = 128 * 1024 * 1024;
+
+/// Every pending capture's reserved pixels together: 256 MiB.
+const MAX_SHOT_TOTAL_BYTES: usize = 256 * 1024 * 1024;
+
+/// Whether a captured image's dimensions match `rect` at `ppp`.
+///
+/// The surface may be smaller than requested when the adapter-limit fit (fork E2) applies, but a
+/// different aspect ratio means the pixels came from another layout than the one issued.
+fn shot_image_matches(image: &egui::ColorImage, rect: egui::Rect, ppp: f32) -> bool {
+    let [w, h] = image.size;
+    if w == 0 || h == 0 || !ppp.is_finite() || ppp <= 0.0 {
+        return false;
+    }
+    let ew = (rect.width() as f64 * ppp as f64).max(1.0);
+    let eh = (rect.height() as f64 * ppp as f64).max(1.0);
+    let want = ew / eh;
+    let got = w as f64 / h as f64;
+    (got - want).abs() <= 0.02 * want.max(1.0)
+}
+
+impl EffectcraftApp {
+    /// The geometry of the last completed UI pass, if one ran.
+    pub fn draw_geometry(&self) -> Option<DrawGeometry> {
+        self.draw_geom
+    }
+
+    // ---------------------------------------------------------------- screenshots
+
+    /// The root surface geometry a screenshot is admitted against.
+    ///
+    /// The last completed pass's geometry is authoritative. Before any pass, only the viewport's
+    /// `inner_rect` (the client surface a capture returns) is accepted: `outer_rect` also covers
+    /// the title bar and window frame, so a capture issued against it would be cropped and
+    /// validated against a different rectangle than the callback delivers. A request that arrives
+    /// before the geometry is known is refused with an actionable error, and the pass that would
+    /// establish it is requested.
+    fn current_geometry(&self, ctx: &egui::Context) -> Option<DrawGeometry> {
+        if let Some(g) = self.draw_geom {
+            return Some(g);
+        }
+        let rect = ctx.input(|i| i.viewport().inner_rect)?;
+        (rect.width() > 0.0 && rect.height() > 0.0).then_some(DrawGeometry { rect, ppp: ctx.pixels_per_point(), epoch: self.geometry_epoch })
+    }
+
+    /// The point rectangle a request captures: its crop, clamped to the window, or all of it.
+    fn shot_target_rect(geom: &DrawGeometry, crop: Option<[f32; 4]>) -> Option<egui::Rect> {
+        let r = match crop {
+            Some([x, y, w, h]) if [x, y, w, h].iter().all(|v| v.is_finite()) => {
+                egui::Rect::from_min_size(geom.rect.min + egui::vec2(x, y), egui::vec2(w.max(0.0), h.max(0.0))).intersect(geom.rect)
+            }
+            Some(_) => return None,
+            None => geom.rect,
+        };
+        (r.width() > 0.0 && r.height() > 0.0).then_some(r)
+    }
+
+    /// The screen-point crop `target` names right now (a panel's or element's current rectangle),
+    /// or an actionable error when it is not on screen. Resolved at issuance, never stored from
+    /// admission: the UI may move while it settles.
+    fn shot_crop(&self, target: &ShotTarget, geom: &DrawGeometry) -> Result<Option<egui::Rect>, String> {
+        let crop = match target {
+            ShotTarget::Window => None,
+            ShotTarget::Rect(r) => Some(*r),
+            ShotTarget::Panel(p) => {
+                let id = format!("panel.{}", p.id());
+                let found = self.auto.find(&id).ok_or_else(|| format!("the {} panel is not on screen", p.title()))?;
+                Some(found.rect)
+            }
+            ShotTarget::Id(id) => Some(self.auto.find(id).ok_or_else(|| format!("no element `{id}` is on screen"))?.rect),
+        };
+        Self::shot_target_rect(geom, crop).map(Some).ok_or_else(|| "the screenshot area is empty or not a finite rectangle".to_string())
+    }
+
+    /// `target` as a crop relative to `geom`'s origin: what the image's own pixels are cut with.
+    fn shot_relative_crop(&self, target: &ShotTarget, geom: &DrawGeometry) -> Result<Option<[f32; 4]>, String> {
+        let Some(r) = self.shot_crop(target, geom)? else { return Ok(None) };
+        Ok(Some([r.min.x - geom.rect.min.x, r.min.y - geom.rect.min.y, r.width(), r.height()]))
+    }
+
+    /// Pixel bytes `rect` takes at `ppp`, checked (`width * height * 4`).
+    fn shot_pixel_bytes(rect: egui::Rect, ppp: f32) -> Option<usize> {
+        if !ppp.is_finite() || ppp <= 0.0 {
+            return None;
+        }
+        let w = (rect.width() as f64 * ppp as f64).ceil().max(1.0) as usize;
+        let h = (rect.height() as f64 * ppp as f64).ceil().max(1.0) as usize;
+        w.checked_mul(h)?.checked_mul(4)
+    }
+
+    /// Reserve and queue one `ui.screenshot`, or reply with an actionable error.
+    pub(crate) fn admit_screenshot(&mut self, ctx: &egui::Context, path: Option<String>, target: ShotTarget, reply: Sender<serde_json::Value>) {
+        let Some(geom) = self.current_geometry(ctx) else {
+            let _ = reply.send(
+                json!({"ok": false, "error": "the window geometry is not known yet (it is recorded by a completed UI pass; retry after the next frame)"}),
+            );
+            // Ask for the pass that records it.
+            self.want_paint = true;
+            ctx.request_repaint();
+            return;
+        };
+        if self.pending_screenshots.len() >= MAX_PENDING_SHOTS {
+            let _ = reply.send(json!({"ok": false, "error": format!("too many screenshots are pending (at most {MAX_PENDING_SHOTS})")}));
+            return;
+        }
+        if let Err(e) = self.shot_crop(&target, &geom) {
+            let _ = reply.send(json!({"ok": false, "error": e}));
+            return;
+        }
+        // The capture is always the whole surface (the crop is applied when the PNG is written),
+        // so the reservation and the per-image bound follow the surface's actual dimensions.
+        let Some(bytes) = Self::shot_pixel_bytes(geom.rect, geom.ppp) else {
+            let _ = reply.send(json!({"ok": false, "error": "the screenshot area is too large to reserve"}));
+            return;
+        };
+        if bytes > MAX_SHOT_BYTES {
+            let _ = reply
+                .send(json!({"ok": false, "error": format!("the screenshot would need about {bytes} bytes, over the {MAX_SHOT_BYTES}-byte per-image limit")}));
+            return;
+        }
+        if self.shot_bytes.checked_add(bytes).is_none_or(|n| n > MAX_SHOT_TOTAL_BYTES) {
+            let _ = reply.send(json!({"ok": false, "error": format!("the screenshot would exceed the {MAX_SHOT_TOTAL_BYTES}-byte pending-image budget")}));
+            return;
+        }
+        self.shot_bytes += bytes;
+        self.pending_screenshots.push(PendingShot {
+            path,
+            target,
+            crop: None,
+            reply,
+            deadline: self.now + SCREENSHOT_TIMEOUT_S,
+            settle_at: self.now + SCREENSHOT_SETTLE_S,
+            admitted: geom,
+            admitted_pass: self.ui_pass_seq,
+            issued: None,
+            slot: None,
+            reserved_bytes: bytes,
+            attempts: 0,
+        });
+        // A queued capture needs a settled UI pass before it can be issued.
+        self.want_paint = true;
+    }
+
+    /// Re-reserve request `i` against `geom` after a surface change; false when it no longer fits.
+    fn refresh_shot_reservation(&mut self, i: usize, geom: &DrawGeometry) -> bool {
+        let Some(bytes) = Self::shot_pixel_bytes(geom.rect, geom.ppp) else { return false };
+        if bytes > MAX_SHOT_BYTES {
+            return false;
+        }
+        let released = self.shot_bytes.saturating_sub(self.pending_screenshots[i].reserved_bytes);
+        if released.checked_add(bytes).is_none_or(|n| n > MAX_SHOT_TOTAL_BYTES) {
+            return false;
+        }
+        self.shot_bytes = released + bytes;
+        self.pending_screenshots[i].reserved_bytes = bytes;
+        true
+    }
+
+    /// Reply with an error to request `i` and release its reservation.
+    fn fail_shot(&mut self, i: usize, message: impl Into<String>) {
+        let shot = self.pending_screenshots.remove(i);
+        self.shot_bytes = self.shot_bytes.saturating_sub(shot.reserved_bytes);
+        let _ = shot.reply.send(json!({"ok": false, "error": message.into()}));
+    }
+
+    /// Collect completed captures, enforce timeouts and issue every settled request.
+    ///
+    /// Runs from [`Self::tick`] only: the callback stores pixels in its slot and wakes the
+    /// viewport, and everything that can write a file or reply happens here, on the app thread.
+    pub(super) fn tick_screenshots(&mut self, ctx: &egui::Context) {
+        let Some(geom) = self.current_geometry(ctx) else { return };
+        self.drain_completed_screenshots(geom);
+        self.timeout_screenshots();
+        self.issue_screenshots(ctx, geom);
+        // 4. Wake up for the earliest deadline even when no further pass is otherwise needed: an
+        //    issued capture whose callback never arrives (hidden window, display asleep, renderer
+        //    failure) would otherwise never reach its timeout. This is a timer, not a paint
+        //    request: the issued screenshot command already forces the frame it needs.
+        if let Some(next) = self.pending_screenshots.iter().map(|s| s.deadline).reduce(f64::min) {
+            let wait = (next - self.now).max(0.001);
+            ctx.request_repaint_after(std::time::Duration::from_secs_f64(wait));
+        }
+    }
+
+    /// 1. Drain completed slots. A completion whose surface epoch changed since issuance is
+    ///    discarded even if the geometry changed back: it was cropped with another frame's
+    ///    pixels-per-point.
+    fn drain_completed_screenshots(&mut self, geom: DrawGeometry) {
+        let mut i = 0;
+        while i < self.pending_screenshots.len() {
+            let taken = self.pending_screenshots.get(i).and_then(|s| s.slot.as_ref()).and_then(craft_ui::capture::CaptureSlot::take);
+            let Some(result) = taken else {
+                i += 1;
+                continue;
+            };
+            let issued = self.pending_screenshots[i].issued;
+            match result {
+                Ok(image) => {
+                    if issued.is_none_or(|g| g.epoch != geom.epoch) {
+                        self.pending_screenshots[i].slot = None;
+                        self.pending_screenshots[i].issued = None;
+                        if self.pending_screenshots[i].attempts >= SCREENSHOT_MAX_RETRIES {
+                            self.fail_shot(i, "the window resized while the screenshot was being taken");
+                        } else if !self.refresh_shot_reservation(i, &geom) {
+                            self.fail_shot(i, "the resized window is too large to capture within the screenshot budget");
+                        } else {
+                            let settle_at = self.now + SCREENSHOT_SETTLE_S;
+                            let passes = self.ui_pass_seq;
+                            let s = &mut self.pending_screenshots[i];
+                            s.attempts += 1;
+                            s.admitted = geom;
+                            s.admitted_pass = passes;
+                            s.settle_at = settle_at;
+                            i += 1;
+                        }
+                        continue;
+                    }
+                    let Some(issued) = issued else {
+                        i += 1;
+                        continue;
+                    };
+                    if !shot_image_matches(&image, issued.rect, issued.ppp) {
+                        self.fail_shot(i, "the screenshot's pixels do not match the window it was taken from");
+                        continue;
+                    }
+                    // The returned image can be smaller than requested (the E2 adapter-limit fit),
+                    // so the crop uses the image's own scale, never the issued ppp.
+                    let [iw, ih] = image.size;
+                    let (sx, sy) = (iw as f64 / issued.rect.width() as f64, ih as f64 / issued.rect.height() as f64);
+                    if !(sx.is_finite() && sx > 0.0 && sy.is_finite() && sy > 0.0) {
+                        self.fail_shot(i, "the screenshot's size does not describe the window it was taken from");
+                        continue;
+                    }
+                    let shot = self.pending_screenshots.remove(i);
+                    self.shot_bytes = self.shot_bytes.saturating_sub(shot.reserved_bytes);
+                    if let Some(path) = shot.path.as_deref()
+                        && let Err(error) = self.session.refuse_export(path)
+                    {
+                        let _ = shot.reply.send(json!({"ok": false, "error": error.to_string()}));
+                        continue;
+                    }
+                    let r = control::save_screenshot(&image, shot.path.as_deref(), shot.crop, [sx, sy]);
+                    let _ = shot.reply.send(r);
+                }
+                Err(e) => {
+                    self.fail_shot(i, e.to_string());
+                }
+            }
+        }
+    }
+
+    /// 2. Timeouts: a late callback finds its slot cancelled and writes nothing.
+    fn timeout_screenshots(&mut self) {
+        let mut i = 0;
+        while i < self.pending_screenshots.len() {
+            if self.now > self.pending_screenshots[i].deadline {
+                self.fail_shot(i, "no frame was presented (window hidden or display asleep)");
+            } else {
+                i += 1;
+            }
+        }
+    }
+
+    /// 3. Issue settled requests. The command itself requests the paint; a request still
+    ///    waiting for its passes needs `want_paint` so a hidden window keeps painting.
+    fn issue_screenshots(&mut self, ctx: &egui::Context, geom: DrawGeometry) {
+        let mut i = 0;
+        while i < self.pending_screenshots.len() {
+            if self.pending_screenshots[i].slot.is_some() {
+                i += 1;
+                continue;
+            }
+            if geom.epoch != self.pending_screenshots[i].admitted.epoch {
+                if self.pending_screenshots[i].attempts >= SCREENSHOT_MAX_RETRIES {
+                    self.fail_shot(i, "the window kept resizing before the screenshot could be taken");
+                    continue;
+                }
+                if !self.refresh_shot_reservation(i, &geom) {
+                    self.fail_shot(i, "the resized window is too large to capture within the screenshot budget");
+                    continue;
+                }
+                let (now, passes) = (self.now, self.ui_pass_seq);
+                let s = &mut self.pending_screenshots[i];
+                s.attempts += 1;
+                s.admitted = geom;
+                s.admitted_pass = passes;
+                s.settle_at = now + SCREENSHOT_SETTLE_S;
+                self.want_paint = true;
+                i += 1;
+                continue;
+            }
+            let settled = self.ui_pass_seq >= self.pending_screenshots[i].admitted_pass.saturating_add(SCREENSHOT_SETTLE_PASSES)
+                && self.now >= self.pending_screenshots[i].settle_at;
+            if !settled {
+                self.want_paint = true;
+                i += 1;
+                continue;
+            }
+            // Resolve the crop now, against the settled UI: an element that moved since admission
+            // is captured where it is, and its rectangle is relative to this issued surface.
+            let target = self.pending_screenshots[i].target.clone();
+            let crop = match self.shot_relative_crop(&target, &geom) {
+                Ok(c) => c,
+                Err(e) => {
+                    self.fail_shot(i, e);
+                    continue;
+                }
+            };
+            let (slot, callback) = craft_ui::capture::CaptureSlot::new(ctx, egui::ViewportId::ROOT, MAX_SHOT_BYTES);
+            ctx.send_viewport_cmd(egui::ViewportCommand::Screenshot(callback));
+            let s = &mut self.pending_screenshots[i];
+            s.slot = Some(slot);
+            s.issued = Some(geom);
+            s.crop = crop;
+            i += 1;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use effectcraft_engine::Session;
+    use effectcraft_engine::project::{Footage, FootageKind, ItemKind};
+    use std::sync::Arc;
+
+    #[test]
+    fn queued_screenshots_recheck_sources_when_the_capture_completes() {
+        let dir = std::env::temp_dir().join(format!("effectcraft-pending-shot-protection-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        for kind in ["footage", "project", "free"] {
+            let path = dir.join(format!("{kind}.png"));
+            let text = path.to_string_lossy().into_owned();
+            let mut app = EffectcraftApp::new(Session::default());
+            let ctx = egui::Context::default();
+            let geom = DrawGeometry { rect: egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(2.0, 2.0)), ppp: 1.0, epoch: 0 };
+            app.draw_geom = Some(geom);
+            assert!(app.session.refuse_export(&text).is_ok());
+            let (tx, rx) = std::sync::mpsc::channel();
+            app.admit_screenshot(&ctx, Some(text.clone()), ShotTarget::Window, tx);
+            let (slot, callback) = craft_ui::capture::CaptureSlot::new(&ctx, egui::ViewportId::ROOT, MAX_SHOT_BYTES);
+            let shot = app.pending_screenshots.last_mut().unwrap();
+            shot.issued = Some(geom);
+            shot.slot = Some(slot);
+            // The destination becomes protected after admission, before pixels arrive.
+            let original = match kind {
+                "footage" => {
+                    std::fs::write(&path, b"SOURCE FOOTAGE").unwrap();
+                    let footage = Footage { path: text.clone(), kind: FootageKind::Still, ..Default::default() };
+                    Arc::make_mut(&mut app.session.project).add_item("clip", effectcraft_engine::color::Label::None, None, ItemKind::Footage(footage));
+                    Some(std::fs::read(&path).unwrap())
+                }
+                "project" => {
+                    app.session.execute("file.saveAs", json!({"path": text})).unwrap();
+                    Some(std::fs::read(&path).unwrap())
+                }
+                _ => None,
+            };
+            callback.complete(Arc::new(egui::ColorImage::filled([2, 2], egui::Color32::RED)));
+            app.drain_completed_screenshots(geom);
+            let reply = rx.try_recv().unwrap();
+            if let Some(original) = original {
+                assert_eq!(reply["ok"], false, "{kind}: {reply}");
+                assert!(reply["error"].as_str().unwrap_or_default().contains(kind), "{reply}");
+                assert_eq!(std::fs::read(&path).unwrap(), original);
+            } else {
+                assert_eq!(reply["ok"], true, "{reply}");
+                assert!(std::fs::read(&path).unwrap().starts_with(b"\x89PNG\r\n\x1a\n"));
+            }
+            assert!(app.pending_screenshots.is_empty());
+            assert_eq!(app.shot_bytes, 0);
+            std::fs::remove_file(path).unwrap();
+        }
+        std::fs::remove_dir(dir).unwrap();
+    }
+}
diff --git a/crates/ui-egui/src/app/viewer_frames.rs b/crates/ui-egui/src/app/viewer_frames.rs
new file mode 100644
index 000000000..f87db615c
--- /dev/null
+++ b/crates/ui-egui/src/app/viewer_frames.rs
@@ -0,0 +1,184 @@
+use super::*;
+
+impl EffectcraftApp {
+    /// The size of the viewer frame's texture (CPU frames; fitted to the GPU's texture limit).
+    pub fn viewer_texture_size(&self) -> Option<[usize; 2]> {
+        self.viewer_tex.as_ref().map(|(t, _, _)| t.size())
+    }
+
+    /// The viewer's current pixels as 8-bit premultiplied RGBA, reading a GPU frame back the
+    /// first time something asks for it.
+    ///
+    /// The browser can't wait for the GPU: there the first call starts an asynchronous readback
+    /// and returns `None`; a later call (the next frame) has the pixels.
+    pub fn viewer_pixels(&mut self) -> Option<Arc<egui::ColorImage>> {
+        let to_image = |bytes: Vec<u8>, w: u32, h: u32| {
+            let px = bytes.as_chunks::<4>().0.iter().map(|c| egui::Color32::from_rgba_premultiplied(c[0], c[1], c[2], c[3])).collect();
+            Arc::new(egui::ColorImage::new([w as usize, h as usize], px))
+        };
+        if self.viewer_image.is_none()
+            && let (Some((_, key, f)), Some(g)) = (&self.viewer_native, &self.gpu)
+            && self.viewer_shown.as_ref().map(|s| s.1) == Some(*key)
+        {
+            if cfg!(target_arch = "wasm32") {
+                let ready = self.viewer_readback.1.lock().ok().and_then(|mut r| r.take_if(|r| r.0 == *key));
+                if let Some((_, img)) = ready {
+                    self.viewer_image = Some(img);
+                } else if self.viewer_readback.0 != Some(*key) {
+                    self.viewer_readback.0 = Some(*key);
+                    let (slot, k, (w, h)) = (self.viewer_readback.1.clone(), *key, (f.width, f.height));
+                    let ctx = self.frames.context();
+                    g.read_display_async(f, move |bytes| {
+                        if let (Some(b), Ok(mut s)) = (bytes, slot.lock()) {
+                            *s = Some((k, to_image(b, w, h)));
+                        }
+                        if let Some(c) = ctx {
+                            c.request_repaint();
+                        }
+                    });
+                }
+            } else if let Some(bytes) = g.read_display(f) {
+                self.viewer_image = Some(to_image(bytes, f.width, f.height));
+            }
+        }
+        self.viewer_image.clone()
+    }
+
+    /// The viewer's Resolution: the active composition's (saved with the project).
+    pub fn viewer_res(&self) -> state::Resolution {
+        self.session.active_comp().map(|c| c.resolution).unwrap_or_default()
+    }
+
+    /// The render scale used by the viewer right now.
+    pub fn viewer_scale(&self, zoom: f32, ppp: f32) -> f64 {
+        // The preview's Resolution (when not Auto) while it plays.
+        if self.playback.playing
+            && let Some(f) = self.playback.res
+        {
+            return state::Resolution::from_factor(f.into()).scale(zoom, ppp);
+        }
+        // Auto follows the zoom alike while playing and paused, so frames cached while scrubbing
+        // play back, and frames cached by a preview stay on screen when it stops.
+        let res = self.viewer_res();
+        let full = res.scale(zoom, ppp);
+        // Fast Previews ▸ Adaptive Resolution / Fast Draft: lower resolution while dragging.
+        let (_, k) = self.session.state.viewer.fast_previews.render(self.ui.viewer.interacting || self.ui.viewer.property_interacting);
+        if k < 1.0 && res.is_auto() {
+            return full.min((full * 0.5).max(self.session.prefs.adaptive_limit()));
+        }
+        full
+    }
+
+    /// The cache key of viewer frame `frame` of `comp` at `scale` (see [`Self::frame_series`]).
+    pub fn frame_key(&self, comp: ItemId, frame: i64, scale: f64) -> FrameKey {
+        FrameKey { frame, ..self.frame_series(comp, scale) }
+    }
+
+    /// The key of frame 0 of `comp`'s viewer frames at `scale` (the content, view and render
+    /// options are the same for every frame: loops compute this once).
+    pub fn frame_series(&self, comp: ItemId, scale: f64) -> FrameKey {
+        FrameKey {
+            revision: self.session.revision,
+            content: self.frames.content_of(&self.session.project, self.session.revision, comp),
+            comp: comp.0,
+            frame: 0,
+            scale: (scale * 1000.0).round() as u32,
+            view: self.view_hash(comp),
+            opts: frames::opts_hash(&self.frame_opts(comp, scale)) ^ self.roto_model_stamp(),
+        }
+    }
+
+    /// Changes when the Roto Brush model in use does: a frame drawn with the classic fallback while the model loaded
+    /// is not the frame the model gives, so the two must not share a cache entry.
+    fn roto_model_stamp(&self) -> u64 {
+        use std::hash::{Hash, Hasher};
+        let Some(id) = self.session.models_roto_active() else { return 0 };
+        let mut h = std::collections::hash_map::DefaultHasher::new();
+        id.hash(&mut h);
+        h.finish() | 1
+    }
+
+    /// The frame series the viewer of `comp` shows now (its scale, view and options, for the
+    /// comp's current content): what the cache bars count.
+    pub fn shown_series(&self, comp: ItemId) -> FrameKey {
+        let scale = self.viewer_shown.as_ref().filter(|(_, k)| k.comp == comp.0).map_or(1000, |(_, k)| k.scale);
+        self.frame_series(comp, scale as f64 / 1000.0)
+    }
+
+    /// Hash of the comp viewer's 3D view camera (0 for the active camera view).
+    pub fn view_hash(&self, comp: ItemId) -> u64 {
+        use std::hash::{Hash, Hasher};
+        let mut h = std::collections::hash_map::DefaultHasher::new();
+        // The region of interest changes what is rendered too.
+        let roi = self.viewer_region(comp);
+        if let Some(r) = roi {
+            r.map(f64::to_bits).hash(&mut h);
+        }
+        let Some(cam) = self.session.view_camera(comp) else { return if roi.is_some() { h.finish() | 1 } else { 0 } };
+        for row in cam.view.0 {
+            for v in row {
+                v.to_bits().hash(&mut h);
+            }
+        }
+        cam.zoom.to_bits().hash(&mut h);
+        cam.ortho.hash(&mut h);
+        h.finish() | 1
+    }
+
+    /// The comp-space region viewer frames of `comp` cover: the region of interest, else the
+    /// Extended Viewer's area (frame plus pasteboard), else `None` (the whole frame).
+    pub fn viewer_region(&self, comp: ItemId) -> Option<[f64; 4]> {
+        if self.session.active_comp_id() != Some(comp) {
+            return None;
+        }
+        self.session.state.region_of_interest.or(self.ui.viewer.extended)
+    }
+
+    /// Request a prefetch frame render (no-op if cached/in flight).
+    pub fn request_frame(&self, comp: ItemId, frame: i64, scale: f64) {
+        self.request_frame_with(comp, frame, scale, frames::Frames::request);
+    }
+
+    /// Request the frame on screen: rendered before any queued prefetch.
+    pub fn request_frame_urgent(&self, comp: ItemId, frame: i64, scale: f64) {
+        self.request_frame_with(comp, frame, scale, frames::Frames::request_urgent);
+    }
+
+    /// Request a frame nobody waits for (Cache Frames When Idle): rendered on one thread
+    /// (`Frames::request_background`).
+    pub fn request_frame_background(&self, comp: ItemId, frame: i64, scale: f64) {
+        self.request_frame_with(comp, frame, scale, frames::Frames::request_background);
+    }
+
+    /// Render options of viewer frames of `comp` at `scale`.
+    pub fn frame_opts(&self, comp: ItemId, scale: f64) -> RenderOpts {
+        let (draft, _) = self.session.state.viewer.fast_previews.render(self.ui.viewer.interacting || self.ui.viewer.property_interacting);
+        let roi = self.viewer_region(comp);
+        RenderOpts {
+            scale,
+            motion_blur: true,
+            guides: true,
+            draft: self.ui.viewer.fast_preview || draft,
+            view: self.session.view_camera(comp),
+            roi,
+            backend: effectcraft_engine::render::Backend::Auto,
+            nested_switches: self.session.prefs.general.switches_affect_nested_comps,
+            draft_shadows: self.session.prefs.three_d.realtime_shadows,
+            proxy: Default::default(),
+        }
+    }
+
+    fn request_frame_with(
+        &self,
+        comp: ItemId,
+        frame: i64,
+        scale: f64,
+        request: fn(&frames::Frames, &frames::RenderSource, FrameKey, ItemId, Tick, RenderOpts),
+    ) {
+        let Some(c) = self.session.project.comp(comp) else { return };
+        let key = self.frame_key(comp, frame, scale);
+        let t = c.frame_rate.tick_of(frame);
+        let opts = self.frame_opts(comp, scale);
+        request(&self.frames, &self.render_source(), key, comp, t, opts);
+    }
+}
diff --git a/crates/ui-egui/src/app/window.rs b/crates/ui-egui/src/app/window.rs
new file mode 100644
index 000000000..7326b9f32
--- /dev/null
+++ b/crates/ui-egui/src/app/window.rs
@@ -0,0 +1,167 @@
+use super::*;
+
+impl EffectcraftApp {
+    /// Keep the saved workspaces for the next session (see [`EffectcraftApp::new`]): After
+    /// Effects' saved workspaces last until they are deleted (#320). `Err` when they weren't
+    /// written (#696): the change applies for this session and a later save retries it, but until
+    /// then a restart brings back what is on disk.
+    pub(crate) fn store_saved_workspaces(&mut self) -> Result<(), String> {
+        let Err(error) = self.workspace_store.save_now(self.session.config.as_deref(), &self.ui) else { return Ok(()) };
+        let message = format!("Workspace changes couldn't be saved and may be lost after a restart: {error}");
+        log::warn!("{message}");
+        self.ui.status = message.clone();
+        // The raw error, so the background retry doesn't report the same failure again.
+        self.workspace_store.error = Some(error);
+        Err(message)
+    }
+
+    pub fn set_workspace(&mut self, name: &str) {
+        // Learn: the Home screen's Learn tab (tutorials) in the Composition panel. Leaving it for
+        // another workspace closes the Home screen again: it stayed over every workspace until a
+        // project was created (#272).
+        if name == "Learn" {
+            self.ui.start_screen = true;
+            self.ui.home_learn = true;
+            self.ui.home_templates = false;
+        } else if self.ui.workspace == "Learn" {
+            self.ui.start_screen = false;
+            self.ui.home_learn = false;
+        }
+        self.ui.workspace = name.to_string();
+        self.ui.dock = self.ui.saved_workspaces.get(name).cloned().unwrap_or_else(|| dock::Workspace::new(dock::workspace(name)));
+        self.ui.maximized = None;
+    }
+
+    /// Built-in workspaces followed by the saved ones (Window ▸ Workspace ▸ Save as New Workspace).
+    pub fn workspace_names(&self) -> Vec<String> {
+        let mut v: Vec<String> = dock::WORKSPACES.iter().map(|s| s.to_string()).collect();
+        v.extend(self.saved_workspace_names());
+        v
+    }
+
+    /// The workspaces the user saved under a new name (built-ins whose changes were saved are
+    /// not repeated), in name order.
+    pub fn saved_workspace_names(&self) -> Vec<String> {
+        self.ui.saved_workspaces.keys().filter(|k| !dock::WORKSPACES.contains(&k.as_str())).cloned().collect()
+    }
+
+    /// The open Gradient Editor's draft (`panels::gradient_editor`): what OK would set.
+    pub fn gradient_draft(&self) -> &panels::gradient_editor::Draft {
+        &self.dialog_state.gradient
+    }
+
+    /// The open Gradient Editor's draft, to edit (tests and automation; the editor's own fields
+    /// do the same).
+    pub fn gradient_draft_mut(&mut self) -> &mut panels::gradient_editor::Draft {
+        &mut self.dialog_state.gradient
+    }
+
+    /// The open settings dialog's draft and Preview state (`panels::dialogs`): Solid, Camera,
+    /// Light and Composition Settings keep what OK would apply here.
+    pub fn dialog_state(&self) -> &panels::dialogs::DialogState {
+        &self.dialog_state
+    }
+
+    /// The open settings dialog's draft, to edit (tests and automation; the dialog's own fields
+    /// do the same).
+    pub fn dialog_state_mut(&mut self) -> &mut panels::dialogs::DialogState {
+        &mut self.dialog_state
+    }
+
+    /// Show panel `p` (opening it in its usual place if it is closed), bring it to the front and
+    /// give it the focus: Window ▸ `<panel>`.
+    pub fn show_panel(&mut self, p: PanelKind) {
+        if !self.ui.dock.is_floating(p) && self.ui.maximized.is_some_and(|m| m != p) {
+            self.ui.maximized = None;
+        }
+        self.raise_panel(p);
+        self.ui.focused = p;
+    }
+
+    /// Bring panel `p` to the front of its group, opening it if it is closed, without moving the
+    /// focus (a comp opening brings up its viewer, an effect applied brings up Effect Controls).
+    /// A closed panel goes back where it was; one never laid out goes to its usual place: the
+    /// Composition panel in the centre with the Layer panel and other viewers (with none of
+    /// those left, above the Timeline), Layer and the viewers beside the Composition panel, and
+    /// so on.
+    pub fn raise_panel(&mut self, p: PanelKind) {
+        if !self.ui.dock.is_open(p) {
+            let docked = |q: &PanelKind| self.ui.dock.is_docked(*q);
+            let near = match p {
+                PanelKind::Composition => self
+                    .ui
+                    .dock
+                    .panels()
+                    .into_iter()
+                    .find(|q| matches!(q, PanelKind::Layer | PanelKind::Viewer(_) | PanelKind::Flowchart | PanelKind::Footage) && docked(q)),
+                PanelKind::Layer | PanelKind::Flowchart | PanelKind::Viewer(_) => Some(PanelKind::Composition),
+                PanelKind::RenderQueue => Some(PanelKind::Timeline),
+                PanelKind::EffectControls | PanelKind::History => Some(PanelKind::Project),
+                _ => Some(PanelKind::EffectsPresets),
+            }
+            .filter(|q| self.ui.dock.is_open(*q));
+            let mut workspace = self.ui.dock.clone();
+            let known = workspace.hidden.iter().any(|(q, _)| *q == p);
+            let opened = if p == PanelKind::Composition && near.is_none() && !known && self.ui.dock.is_docked(PanelKind::Timeline) {
+                workspace
+                    .apply(
+                        craft_ui::docking::Action::OpenAt {
+                            panel: p,
+                            anchor: PanelKind::Timeline,
+                            placement: craft_ui::docking::Placement::Split(craft_ui::docking::Zone::Top),
+                        },
+                        dock::permissions,
+                    )
+                    .map(|_| ())
+            } else if known {
+                workspace.set_visible(p, true, near, dock::permissions)
+            } else {
+                workspace.apply(craft_ui::docking::Action::Open { panel: p, anchor: near }, dock::permissions).map(|_| ())
+            };
+            match opened {
+                Ok(()) => self.ui.dock = workspace,
+                Err(e) => {
+                    self.ui.status = format!("can't open {}: {e}", p.title());
+                    return;
+                }
+            }
+        }
+        let _ = self.ui.dock.apply(craft_ui::docking::Action::Activate { panel: p }, dock::permissions);
+        if self.ui.dock.is_floating(p) {
+            self.pending_panel_raise = Some(p);
+        }
+    }
+}
+
+/// Maximize a first window that doesn't fit the screen, which fits it to the space beside the
+/// taskbar or dock. The 1680 × 1020 window on a smaller screen is only shrunk to the monitor's
+/// size, so with its title bar it ran under the taskbar and cut menus off at the bottom of the
+/// screen (#269).
+pub(super) fn fit_window(ctx: &egui::Context) {
+    let (monitor, window) = ctx.input(|i| (i.viewport().monitor_size, i.viewport().outer_rect.or(i.viewport().inner_rect)));
+    if let (Some(monitor), Some(window)) = (monitor, window)
+        && overflows_screen(window.size(), monitor)
+    {
+        ctx.send_viewport_cmd(egui::ViewportCommand::Maximized(true));
+    }
+}
+
+/// Whether a window `size` leaves no room on a `monitor` for a taskbar or dock (points).
+fn overflows_screen(size: egui::Vec2, monitor: egui::Vec2) -> bool {
+    const TASKBAR: f32 = 64.0;
+    size.x > monitor.x || size.y > monitor.y - TASKBAR
+}
+
+#[cfg(test)]
+mod fit_window_tests {
+    use super::overflows_screen;
+    use egui::vec2;
+
+    #[test]
+    fn a_window_taller_than_the_screen_beside_its_taskbar_overflows() {
+        // The default window on a 1366 × 768 laptop (shrunk to the monitor) and on 1080p.
+        assert!(overflows_screen(vec2(1366.0, 799.0), vec2(1366.0, 768.0)));
+        assert!(overflows_screen(vec2(1680.0, 1051.0), vec2(1920.0, 1080.0)));
+        assert!(!overflows_screen(vec2(1680.0, 1051.0), vec2(2560.0, 1440.0)));
+    }
+}
diff --git a/crates/ui-egui/src/audio.rs b/crates/ui-egui/src/audio.rs
index 7972e6942..fbfe4b8af 100644
--- a/crates/ui-egui/src/audio.rs
+++ b/crates/ui-egui/src/audio.rs
@@ -532,7 +532,7 @@ mod tests {
         let item = p.add_item("long.flac", Label::SeaFoam, None, ItemKind::Footage(footage));
         let mut comp = Comp::new(64, 36, FrameRate::new(30, 1), Tick::from_seconds_f64(10.0));
         let layer = build::layer(&mut p, &comp, "long.flac", LayerSource::Footage { item }, (0, 0), None);
-        comp.layers = vec![layer];
+        comp.layers = vec![layer].into();
         let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.into()));
         let src = RenderSource {
             project: Arc::new(p),
diff --git a/crates/ui-egui/src/clock.rs b/crates/ui-egui/src/clock.rs
new file mode 100644
index 000000000..184c8421c
--- /dev/null
+++ b/crates/ui-egui/src/clock.rs
@@ -0,0 +1,71 @@
+use super::*;
+
+/// The application's monotonic clock, in seconds.
+///
+/// Neither `ctx.input(|i| i.time)` nor `RawInput::time` is valid in a logic-only tick:
+/// `Context::run_logic` copies only the viewport information, so both are the previous full
+/// pass's values. Playback, auto-save, screenshot deadlines and the control channel measure time
+/// with this clock instead. Native and web use the same [`web_time::Instant`] source; tests
+/// inject [`AppClock::manual`] and advance it.
+#[derive(Clone, Debug)]
+pub struct AppClock {
+    origin: web_time::Instant,
+    manual: Option<f64>,
+}
+
+impl AppClock {
+    /// The host's monotonic clock.
+    pub fn real() -> Self {
+        Self { origin: web_time::Instant::now(), manual: None }
+    }
+
+    /// A clock tests advance explicitly with [`AppClock::advance`].
+    pub fn manual() -> Self {
+        Self { origin: web_time::Instant::now(), manual: Some(0.0) }
+    }
+
+    /// Seconds since the clock started (monotonic on native and in the browser).
+    pub fn now(&self) -> f64 {
+        match self.manual {
+            Some(t) => t,
+            None => self.origin.elapsed().as_secs_f64(),
+        }
+    }
+
+    /// Move a manual clock forward; a real clock ignores this.
+    pub fn advance(&mut self, seconds: f64) {
+        if let Some(t) = &mut self.manual {
+            *t = (*t + seconds.max(0.0)).max(0.0);
+        }
+    }
+
+    /// Whether the clock is test-driven.
+    pub fn is_manual(&self) -> bool {
+        self.manual.is_some()
+    }
+}
+
+impl Default for AppClock {
+    /// The real monotonic clock (`Self::real()`).
+    fn default() -> Self {
+        Self::real()
+    }
+}
+
+impl EffectcraftApp {
+    /// The app clock's value at the last tick.
+    pub fn now(&self) -> f64 {
+        self.now
+    }
+
+    /// The clock itself (tests advance a manual clock).
+    pub fn clock_mut(&mut self) -> &mut AppClock {
+        &mut self.clock
+    }
+
+    /// Use a test-driven clock from now on.
+    pub fn use_manual_clock(&mut self) {
+        self.clock = AppClock::manual();
+        self.now = 0.0;
+    }
+}
diff --git a/crates/ui-egui/src/color_picker.rs b/crates/ui-egui/src/color_picker.rs
index 847e1e541..c75cc0242 100644
--- a/crates/ui-egui/src/color_picker.rs
+++ b/crates/ui-egui/src/color_picker.rs
@@ -1,6 +1,7 @@
 //! The colour picker every colour input opens, laid out like After Effects' Color Picker: a
 //! square and a slider for the channel chosen with the H / S / B / R / G / B buttons, the new
-//! colour over the original, the HSB and RGB values, the hex code, and OK / Cancel.
+//! colour over the original, the HSB and RGB values, the hex code with an eyedropper that samples
+//! the Composition viewer, and OK / Cancel.
 //!
 //! Colours are sRGB components (0–1), as the project stores them. Changes apply as they are made
 //! (After Effects' Preview); Cancel or Escape goes back to the colour the picker opened with.
@@ -30,35 +31,55 @@ pub fn srgb_color_button(ui: &mut Ui, c: &mut [f32; 3]) -> Response {
 }
 
 /// The colour picker as a popup at `pos`, bound to `c`, opened with [`open_popup`]. Returns true
-/// when the colour changed (Cancel, Escape and the original swatch change it back).
+/// when the colour changed (Cancel, Escape and the original swatch change it back; the eyedropper
+/// changes it to the colour it samples).
 pub fn color_popup(ui: &mut Ui, id: egui::Id, pos: egui::Pos2, c: &mut [f32; 3]) -> bool {
     if !popup_is_open(ui, id) {
         return false;
     }
     let orig_id = id.with("original");
     let original = ui.data_mut(|d| *d.get_temp_mut_or_insert_with(orig_id, || *c));
+    // Read before a sample is taken: the press that samples the viewer lands outside the picker, and
+    // must not close it.
+    let armed = armed_for(ui.ctx(), id);
+    let mut sampled = false;
+    if let Some(rgb) = take_sample(ui.ctx(), id)
+        && rgb != *c
+    {
+        *c = rgb;
+        sampled = true;
+    }
     let mut out = Outcome::default();
     let area = egui::Area::new(id.with("area")).order(egui::Order::Foreground).fixed_pos(pos + vec2(0.0, 4.0)).show(ui.ctx(), |ui| {
         egui::Frame::popup(ui.style()).show(ui, |ui| out = color_picker(ui, id, c, original));
     });
-    // Escape is the picker's: consume it, so nothing later this pass takes it too.
+    // Escape is the picker's: consume it, so nothing later this pass takes it too. While the
+    // eyedropper is armed, Escape cancels it and the picker stays open.
     if ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
-        out.close = Some(false);
+        if armed {
+            disarm(ui.ctx(), id);
+        } else {
+            out.close = Some(false);
+        }
     }
+    // A press outside closes the picker, unless it is the armed eyedropper's press on the viewer.
+    let on_viewer = armed && eyedropper_point(ui.ctx()).is_some();
     // A press in the pass that first draws the picker must not close it: an Area's rect is only
     // at its requested position from its second pass on (the first pass reports it at the
     // origin), so the click that just opened the picker would be read as a press outside it and
     // the picker would flash and close in that one frame (#1476).
     let pass_id = id.with("open-pass");
     let drawn_before = ui.data(|d| d.get_temp::<u64>(pass_id)).is_some_and(|p| p < ui.ctx().cumulative_pass_nr());
-    if drawn_before && pressed_outside(ui.ctx(), &area.response) {
+    if drawn_before && pressed_outside(ui.ctx(), &area.response) && !on_viewer {
         out.close.get_or_insert(true);
     }
+    note_overlay(ui.ctx(), area.response.rect);
     if let Some(keep) = out.close {
         if !keep && *c != original {
             *c = original;
             out.changed = true;
         }
+        disarm(ui.ctx(), id);
         ui.data_mut(|d| {
             d.insert_temp(id.with("open"), false);
             d.remove::<[f32; 3]>(orig_id);
@@ -67,6 +88,7 @@ pub fn color_popup(ui: &mut Ui, id: egui::Id, pos: egui::Pos2, c: &mut [f32; 3])
             d.remove::<u64>(open_pass_id());
         });
     } else {
+        refresh_armed(ui.ctx(), id);
         // Still open after this pass: dialogs leave Escape to the picker (see `open_recently`).
         let pass = ui.ctx().cumulative_pass_nr();
         ui.data_mut(|d| {
@@ -74,9 +96,11 @@ pub fn color_popup(ui: &mut Ui, id: egui::Id, pos: egui::Pos2, c: &mut [f32; 3])
             d.insert_temp(open_pass_id(), pass);
         });
     }
-    out.changed
+    out.changed || sampled
 }
 
+/// The `egui::Id` of the pass number in which a colour picker last stayed open, which
+/// [`open_recently`] uses to keep Escape for the picker rather than the dialog under it.
 fn open_pass_id() -> egui::Id {
     egui::Id::unique("color-picker-open-pass")
 }
@@ -90,6 +114,196 @@ pub fn open_recently(ctx: &egui::Context) -> bool {
     pass.is_some_and(|p| p.saturating_add(1) >= ctx.cumulative_pass_nr())
 }
 
+/// The armed eyedropper of a picker: the picker's popup id, the pass it was last drawn in, and the
+/// colour the viewer sampled for it, if one is waiting for the picker's next draw. It lives in the
+/// egui context, since the viewer that samples has no picker in hand.
+#[derive(Clone, Copy)]
+struct Armed {
+    popup: egui::Id,
+    pass: u64,
+    sample: Option<[f32; 3]>,
+    dialog: Option<crate::Dialog>,
+}
+
+fn armed_key() -> egui::Id {
+    egui::Id::unique("color-picker-eyedropper")
+}
+
+fn dialog_key() -> egui::Id {
+    egui::Id::unique("color-picker-dialog")
+}
+
+/// Record the modal before drawing the viewer. A picker may sample behind its own dialog, but
+/// a new, unrelated modal must block it from its very first pass, before its rect is known.
+pub(crate) fn note_dialog(ctx: &egui::Context, dialog: Option<crate::Dialog>) {
+    ctx.data_mut(|data| data.insert_temp(dialog_key(), dialog));
+}
+
+fn current_dialog(ctx: &egui::Context) -> Option<crate::Dialog> {
+    ctx.data(|data| data.get_temp::<Option<crate::Dialog>>(dialog_key())).flatten()
+}
+
+/// The armed eyedropper, if its picker was drawn in this pass or the last: one whose picker stops
+/// being drawn (its dialog gone) lapses.
+fn armed_record(ctx: &egui::Context) -> Option<Armed> {
+    let armed: Option<Armed> = ctx.data(|d| d.get_temp(armed_key()));
+    let pass = ctx.cumulative_pass_nr();
+    armed.filter(|a| a.pass.saturating_add(1) >= pass)
+}
+
+fn armed_for(ctx: &egui::Context, popup: egui::Id) -> bool {
+    armed_record(ctx).is_some_and(|a| a.popup == popup)
+}
+
+/// Some picker's eyedropper is armed: a press on the Composition viewer samples the frame for it.
+pub fn eyedropper_armed(ctx: &egui::Context) -> bool {
+    armed_record(ctx).is_some()
+}
+
+fn arm(ctx: &egui::Context, popup: egui::Id) {
+    let pass = ctx.cumulative_pass_nr();
+    let dialog = current_dialog(ctx);
+    ctx.data_mut(|d| d.insert_temp(armed_key(), Armed { popup, pass, sample: None, dialog }));
+}
+
+fn disarm(ctx: &egui::Context, popup: egui::Id) {
+    let armed: Option<Armed> = ctx.data(|d| d.get_temp(armed_key()));
+    if armed.is_some_and(|a| a.popup == popup) {
+        ctx.data_mut(|d| d.remove::<Armed>(armed_key()));
+    }
+}
+
+/// Keeps `popup`'s eyedropper armed while its picker is drawn.
+fn refresh_armed(ctx: &egui::Context, popup: egui::Id) {
+    if let Some(armed) = armed_record(ctx).filter(|a| a.popup == popup) {
+        let pass = ctx.cumulative_pass_nr();
+        ctx.data_mut(|d| d.insert_temp(armed_key(), Armed { pass, ..armed }));
+    }
+}
+
+/// The colour the viewer sampled for `popup`, once: taking it disarms the eyedropper.
+fn take_sample(ctx: &egui::Context, popup: egui::Id) -> Option<[f32; 3]> {
+    let armed = armed_record(ctx).filter(|a| a.popup == popup)?;
+    let sample = armed.sample?;
+    disarm(ctx, popup);
+    Some(sample)
+}
+
+/// The viewer sampled `rgb` for the armed picker, which takes it on its next draw.
+pub fn deliver_sample(ctx: &egui::Context, rgb: [f32; 3]) {
+    if let Some(armed) = armed_record(ctx) {
+        ctx.data_mut(|d| d.insert_temp(armed_key(), Armed { sample: Some(rgb), ..armed }));
+        ctx.request_repaint();
+    }
+}
+
+fn viewer_key() -> egui::Id {
+    egui::Id::unique("color-picker-viewer")
+}
+
+/// The Composition viewer's rect as it was drawn this pass: where an armed eyedropper samples.
+pub fn note_viewer(ctx: &egui::Context, rect: Rect) {
+    let pass = ctx.cumulative_pass_nr();
+    ctx.data_mut(|d| d.insert_temp(viewer_key(), (pass, rect)));
+}
+
+fn overlay_key() -> egui::Id {
+    egui::Id::unique("color-picker-overlays")
+}
+
+/// A popup or dialog drawn over the viewer: a press inside `rect` is not a sample.
+pub fn note_overlay(ctx: &egui::Context, rect: Rect) {
+    let pass = ctx.cumulative_pass_nr();
+    ctx.data_mut(|d| {
+        // This pass's and the last's: the viewer may be drawn before an overlay in a pass.
+        let mut rects = d.get_temp::<Vec<(u64, Rect)>>(overlay_key()).unwrap_or_default();
+        rects.retain(|(p, _)| p.saturating_add(1) >= pass);
+        rects.push((pass, rect));
+        d.insert_temp(overlay_key(), rects);
+    });
+}
+
+/// Whether `pos` is over a popup or dialog drawn this pass or the last.
+fn overlaid(ctx: &egui::Context, pos: egui::Pos2) -> bool {
+    let pass = ctx.cumulative_pass_nr();
+    let rects: Option<Vec<(u64, Rect)>> = ctx.data(|d| d.get_temp(overlay_key()));
+    rects.unwrap_or_default().iter().any(|(p, r)| p.saturating_add(1) >= pass && r.contains(pos))
+}
+
+/// Where an armed eyedropper samples: the pointer, if it is over the viewer and not over a popup or
+/// dialog. The pointer is read rather than the viewer's responses, since a modal dialog over the
+/// viewer takes its clicks.
+pub fn eyedropper_point(ctx: &egui::Context) -> Option<egui::Pos2> {
+    if armed_record(ctx).is_some_and(|armed| armed.dialog != current_dialog(ctx)) {
+        return None;
+    }
+    let viewer: Option<(u64, Rect)> = ctx.data(|d| d.get_temp(viewer_key()));
+    let viewer = viewer.filter(|(p, _)| p.saturating_add(1) >= ctx.cumulative_pass_nr())?.1;
+    let pos = ctx.input(|i| i.pointer.interact_pos())?;
+    (viewer.contains(pos) && !overlaid(ctx, pos)).then_some(pos)
+}
+
+/// The press that samples for an armed eyedropper this frame, if there is one.
+pub fn sample_press(ctx: &egui::Context) -> Option<egui::Pos2> {
+    if ctx.input(|i| i.pointer.primary_pressed()) { eyedropper_point(ctx) } else { None }
+}
+
+fn automation_key() -> egui::Id {
+    egui::Id::unique("color-picker-eyedropper-rect")
+}
+
+/// The eyedropper's rect, for the automation registry; [`take_automation`] hands it over.
+fn note_automation(ctx: &egui::Context, rect: Rect) {
+    ctx.data_mut(|d| d.insert_temp(automation_key(), rect));
+}
+
+/// The eyedropper rect the last picker drawing noted, once. Pickers have no registry in hand, so the
+/// app registers it each frame.
+pub fn take_automation(ctx: &egui::Context) -> Option<Rect> {
+    ctx.data_mut(|d| {
+        let rect = d.get_temp::<Rect>(automation_key());
+        d.remove::<Rect>(automation_key());
+        rect
+    })
+}
+
+/// The eyedropper of the hex row. A press arms it, or disarms it while armed; the next press on the
+/// Composition viewer then samples the colour under the pointer into this picker.
+fn eyedropper(ui: &mut Ui, popup: egui::Id) {
+    let armed = armed_for(ui.ctx(), popup);
+    let (rect, resp) = ui.allocate_exact_size(vec2(18.0, 18.0), Sense::click());
+    let resp = resp.on_hover_text(tr("Eyedropper: click, then click in the Composition panel"));
+    resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, resp.enabled(), "Eyedropper"));
+    let fill = if armed {
+        ui.visuals().selection.bg_fill
+    } else if resp.hovered() {
+        ui.visuals().widgets.hovered.bg_fill
+    } else {
+        Color32::TRANSPARENT
+    };
+    ui.painter().rect_filled(rect, 2.0, fill);
+    let col = if armed { ui.visuals().selection.stroke.color } else { ui.visuals().strong_text_color() };
+    draw_pipette(ui.painter(), rect, col);
+    if resp.clicked() {
+        if armed {
+            disarm(ui.ctx(), popup);
+        } else {
+            arm(ui.ctx(), popup);
+        }
+    }
+    note_automation(ui.ctx(), rect);
+}
+
+/// A pipette: a diagonal glass tube with a bulb at the top right and a tip at the bottom left, drawn
+/// within `rect`.
+pub fn draw_pipette(p: &egui::Painter, rect: Rect, col: Color32) {
+    let r = rect.shrink(rect.width() * 0.2);
+    let at = |x: f32, y: f32| pos2(r.min.x + x * r.width(), r.min.y + y * r.height());
+    p.line_segment([at(0.08, 0.92), at(0.62, 0.38)], Stroke::new(2.2, col));
+    p.circle_filled(at(0.76, 0.24), r.width() * 0.2, col);
+    p.line_segment([at(0.5, 0.3), at(0.7, 0.5)], Stroke::new(1.4, col));
+}
+
 /// What the picker did this frame.
 #[derive(Default)]
 struct Outcome {
@@ -175,6 +389,12 @@ impl Pick {
 const SQUARE: f32 = 200.0;
 const SLIDER_W: f32 = 16.0;
 
+/// The colour picker popup's contents: saturation/value square, channel slider, number fields for
+/// H/S/B and R/G/B, a hex field and an original-colour swatch, plus OK and Cancel. `*c` is updated
+/// as the UI changes and `original` is what Cancel (or the swatch) restores. The chosen channel
+/// and the HSV/RGB pair are remembered in egui temp data so reopening keeps the hue when
+/// saturation or value reaches zero. Returns what the picker did this frame; it never runs a
+/// command itself.
 fn color_picker(ui: &mut Ui, id: egui::Id, c: &mut [f32; 3], original: [f32; 3]) -> Outcome {
     let state_id = id.with("pick");
     let mut pick = match ui.data(|d| d.get_temp::<([f32; 3], [f32; 3])>(state_id)) {
@@ -247,6 +467,7 @@ fn color_picker(ui: &mut Ui, id: egui::Id, c: &mut [f32; 3], original: [f32; 3])
                 if hex_field(ui, id.with("hex"), &mut rgb) {
                     pick = Pick { hsv: keep_hue(rgb_to_hsv(rgb), pick.hsv), rgb };
                 }
+                eyedropper(ui, id);
             });
         });
     });
@@ -439,3 +660,125 @@ pub fn hsv_to_rgb([h, s, v]: [f32; 3]) -> [f32; 3] {
     };
     [f(5.0), f(3.0), f(1.0)]
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn sampling_viewer() -> egui_kittest::Harness<'static, crate::EffectcraftApp> {
+        let mut session = effectcraft_engine::Session::default();
+        session.execute("comp.new", serde_json::json!({"width": 320, "height": 180, "duration": 2})).unwrap();
+        session.execute("layer.newSolid", serde_json::json!({"color": "#204060"})).unwrap();
+        let mut harness = egui_kittest::Harness::builder().with_size(vec2(1200.0, 800.0)).build_eframe(|_| crate::EffectcraftApp::new(session));
+        settle_sampling_viewer(&mut harness);
+        harness
+    }
+
+    fn settle_sampling_viewer(harness: &mut egui_kittest::Harness<'_, crate::EffectcraftApp>) {
+        for _ in 0..200 {
+            harness.step();
+            if harness.state().frames.inflight() == 0 && harness.state().viewer_image.is_some() {
+                harness.run_steps(3);
+                return;
+            }
+            std::thread::sleep(std::time::Duration::from_millis(5));
+        }
+        panic!("the synthetic viewer frame did not arrive");
+    }
+
+    fn press_sampling_viewer(harness: &mut egui_kittest::Harness<'_, crate::EffectcraftApp>) -> Option<[f32; 3]> {
+        let ctx = harness.ctx.clone();
+        arm(&ctx, egui::Id::unique("test-popup"));
+        let point = crate::panels::viewer::comp_to_screen(&ctx, [20.0, 20.0]).unwrap();
+        harness.event(egui::Event::PointerMoved(point));
+        harness.event(egui::Event::PointerButton { pos: point, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE });
+        harness.step();
+        let sample = ctx.data(|data| data.get_temp::<Armed>(armed_key())).and_then(|armed| armed.sample);
+        harness.event(egui::Event::PointerButton { pos: point, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE });
+        harness.step();
+        sample
+    }
+
+    #[test]
+    fn popup_eyedropper_samples_the_displayed_channel_and_exposure() {
+        let mut harness = sampling_viewer();
+        harness.state_mut().session.state.viewer.channel = effectcraft_engine::viewer::Channel::Green;
+        let green = press_sampling_viewer(&mut harness).unwrap();
+        assert!(green.iter().all(|value| (*value - 64.0 / 255.0).abs() < 0.01), "{green:?}");
+        let options = &mut harness.state_mut().session.state.viewer;
+        options.channel = effectcraft_engine::viewer::Channel::Rgb;
+        options.exposure = 1.0;
+        let exposed = press_sampling_viewer(&mut harness).unwrap();
+        let mut expected = [[32, 64, 96, 255]];
+        effectcraft_engine::viewer::display_transform(&mut expected, effectcraft_engine::viewer::Channel::Rgb, false, 1.0);
+        for (actual, expected) in exposed.iter().zip(expected[0]) {
+            assert!((*actual - expected as f32 / 255.0).abs() < 0.01, "{exposed:?}");
+        }
+    }
+
+    #[test]
+    fn popup_eyedropper_samples_snapshot_and_refuses_wireframe() {
+        let mut harness = sampling_viewer();
+        harness.state_mut().session.execute("view.takeSnapshot", serde_json::json!({})).unwrap();
+        harness.state_mut().session.execute("layer.newSolid", serde_json::json!({"color": "#a0b0c0"})).unwrap();
+        settle_sampling_viewer(&mut harness);
+        harness.event(egui::Event::Key { key: egui::Key::F5, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE });
+        // Let the snapshot texture's discard passes finish before arming this synthetic picker.
+        harness.step();
+        let snapshot = press_sampling_viewer(&mut harness).unwrap();
+        for (actual, expected) in snapshot.iter().zip([32, 64, 96]) {
+            assert!((*actual - expected as f32 / 255.0).abs() < 0.01, "{snapshot:?}");
+        }
+        let options = &mut harness.state_mut().session.state.viewer;
+        options.show_snapshot = false;
+        options.fast_previews = effectcraft_engine::commands::viewer_cmds::FastPreviews::Wireframe;
+        harness.event(egui::Event::Key { key: egui::Key::F5, physical_key: None, pressed: false, repeat: false, modifiers: egui::Modifiers::NONE });
+        assert_eq!(press_sampling_viewer(&mut harness), None, "wireframe must not sample an old pixel frame");
+    }
+
+    #[test]
+    fn a_new_modal_backdrop_cannot_deliver_a_pending_sample() {
+        let mut harness = sampling_viewer();
+        harness.state_mut().dialog = Some(crate::Dialog::About);
+        assert_eq!(press_sampling_viewer(&mut harness), None, "the first modal pass must already exclude its backdrop");
+    }
+
+    #[test]
+    fn a_picker_can_sample_behind_its_own_dialog_but_not_a_new_modal() {
+        let ctx = egui::Context::default();
+        let point = pos2(20.0, 20.0);
+        let mut output = ctx.run_ui(egui::RawInput { events: vec![egui::Event::PointerMoved(point)], ..Default::default() }, |ui| {
+            let ctx = ui.ctx();
+            note_dialog(ctx, Some(crate::Dialog::SolidSettings));
+            note_viewer(ctx, Rect::from_min_size(pos2(0.0, 0.0), vec2(320.0, 180.0)));
+            note_overlay(ctx, Rect::from_min_size(pos2(100.0, 100.0), vec2(120.0, 80.0)));
+            arm(ctx, egui::Id::unique("test-picker"));
+            assert_eq!(eyedropper_point(ctx), Some(point));
+            note_dialog(ctx, Some(crate::Dialog::About));
+            assert_eq!(eyedropper_point(ctx), None);
+        });
+        output.textures_delta.clear();
+    }
+
+    #[test]
+    fn armed_eyedropper_takes_one_sample_then_disarms() {
+        let ctx = egui::Context::default();
+        let popup = egui::Id::unique("test-picker");
+        arm(&ctx, popup);
+        assert!(eyedropper_armed(&ctx));
+        assert_eq!(take_sample(&ctx, popup), None);
+        deliver_sample(&ctx, [0.1, 0.2, 0.3]);
+        assert_eq!(take_sample(&ctx, popup), Some([0.1, 0.2, 0.3]));
+        assert!(!eyedropper_armed(&ctx));
+        assert_eq!(take_sample(&ctx, popup), None);
+    }
+
+    #[test]
+    fn points_over_a_dialog_are_not_samples() {
+        let ctx = egui::Context::default();
+        let dialog = Rect::from_min_size(pos2(100.0, 100.0), vec2(120.0, 80.0));
+        note_overlay(&ctx, dialog);
+        assert!(overlaid(&ctx, pos2(150.0, 150.0)));
+        assert!(!overlaid(&ctx, pos2(20.0, 20.0)));
+    }
+}
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index a481d96ac..86bd20c93 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -9,7 +9,7 @@
 //! - `ui.inspect`: UI state + summary; `ui.elements {prefix?}`: registered widgets (id, label, rect)
 //! - `ui.set {tool?, workspace?, theme?, focused?, viewer?: {zoom, res, pan, grid, …}, timeline?: {pps, start, graphEditor, showModes}}`
 //! - `ui.panel.show {panel}` / `ui.panel.close {panel}`
-//! - `ui.click {id | x,y, button?, count?, modifiers?}` / `ui.move {x,y}` / `ui.scroll {x,y,dx,dy}`
+//! - `ui.click {id | x,y, button?, count?, modifiers?}` / `ui.move {x,y}` / `ui.scroll {x,y,dx,dy,unit?,source?,pinch?}`
 //! - `ui.drag {from:{id|x,y}, to:{id|x,y}, steps?, modifiers?}`: synthetic press-move-release
 //! - `ui.key {key, command?, shift?, alt?, ctrl?}` / `ui.type {text}`
 //! - `ui.viewer.locate {x, y}`: screen point of a comp pixel; `ui.viewer.hit {x, y}`: comp pixel at a screen point
@@ -39,6 +39,8 @@ pub struct ControlRequest {
 }
 
 impl ControlRequest {
+    /// Creates a request for `method` with `params`, returning it with the channel that will
+    /// receive the UI thread's reply.
     pub fn new(method: impl Into<String>, params: Value) -> (Self, std::sync::mpsc::Receiver<Value>) {
         let (tx, rx) = std::sync::mpsc::channel();
         (Self { method: method.into(), params, reply: tx }, rx)
@@ -170,6 +172,10 @@ fn point(app: &EffectcraftApp, p: &Value) -> Result<egui::Pos2, String> {
     Ok(egui::pos2(x as f32, y as f32))
 }
 
+/// Dispatches one control request on the UI thread. Replies are `{"ok": true, "result": …}`
+/// or `{"ok": false, "error": …}`; an unknown method is an error. Some methods answer with
+/// [`Outcome::Retry`], [`Outcome::AfterInput`], [`Outcome::Screenshot`] or
+/// [`Outcome::AwaitJobs`] instead of replying in this call.
 pub fn handle(app: &mut EffectcraftApp, ctx: &egui::Context, req: &ControlRequest, now: f64) -> Outcome {
     let p = &req.params;
     match req.method.as_str() {
@@ -198,6 +204,10 @@ pub fn handle(app: &mut EffectcraftApp, ctx: &egui::Context, req: &ControlReques
     }
 }
 
+/// Runs `engine.execute` or `ui.menu.invoke`. `engine.execute` with a known engine command id
+/// goes through [`execute_engine`] (so a `wait: true` job can be offloaded); every other id,
+/// and every `ui.menu.invoke`, goes through the menu dispatcher. A failure is copied to the
+/// status line.
 fn execute_command(app: &mut EffectcraftApp, ctx: &egui::Context, method: &str, p: &Value) -> Outcome {
     let s = |k: &str| p.get(k).and_then(Value::as_str);
     let Some(id) = s("command").or(s("id")) else { return err("missing `command`") };
@@ -219,6 +229,7 @@ fn execute_command(app: &mut EffectcraftApp, ctx: &egui::Context, method: &str,
     }
 }
 
+/// Replies with `command.list`'s result, forwarding `filter` and `enabledOnly`.
 fn engine_commands(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     match app.session.execute("command.list", json!({"filter": p.get("filter"), "enabledOnly": p.get("enabledOnly")})) {
         Ok(v) => ok(v),
@@ -226,6 +237,8 @@ fn engine_commands(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     }
 }
 
+/// Replies with the automation elements whose id starts with `prefix` (all when empty), as
+/// `{id, label, rect}` records.
 fn elements(app: &EffectcraftApp, p: &Value) -> Outcome {
     let prefix = p.get("prefix").and_then(Value::as_str).unwrap_or("");
     ok(serde_json::to_value(app.auto.query(prefix)).unwrap_or_default())
@@ -237,6 +250,9 @@ fn focus(ctx: &egui::Context) -> Outcome {
     ok(Value::Null)
 }
 
+/// Applies `ui.set` in order: tool, workspace, theme, focused panel, viewer settings, then the
+/// layout fields ([`set_ui_layout`]). An unknown tool, workspace or theme name, or an invalid
+/// viewer value, replies with an error after the earlier fields were already applied.
 fn set_ui(app: &mut EffectcraftApp, ctx: &egui::Context, p: &Value) -> Outcome {
     let s = |k: &str| p.get(k).and_then(Value::as_str);
     if let Some(t) = s("tool") {
@@ -297,6 +313,9 @@ fn set_ui_layout(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     ok(Value::Null)
 }
 
+/// Applies viewer `zoom`, the active comp's `res` (stored in the project), `pan` and the
+/// `grid`, `rulers`, `safeMargins` and `transparencyGrid` toggles. An unknown resolution name
+/// is an error; a resolution change without an active comp is ignored.
 fn apply_viewer(app: &mut EffectcraftApp, v: &Value) -> Result<(), String> {
     if let Some(z) = v.get("zoom") {
         app.ui.viewer.zoom = z.as_f64().map(|z| z as f32);
@@ -328,6 +347,8 @@ fn apply_viewer(app: &mut EffectcraftApp, v: &Value) -> Result<(), String> {
     Ok(())
 }
 
+/// Applies timeline `pps`, `start`, `graphEditor`, `showModes`, `openLayers` and `openGroups`
+/// to the UI state, leaving absent fields unchanged.
 fn apply_timeline(app: &mut EffectcraftApp, tl: &Value) {
     if let Some(v) = tl.get("pps") {
         app.ui.timeline.pps = v.as_f64();
@@ -349,6 +370,8 @@ fn apply_timeline(app: &mut EffectcraftApp, tl: &Value) {
     }
 }
 
+/// Replaces the Project panel's optional columns with the names in `a`, in the canonical
+/// `COLUMNS` order; unknown names are kept, sorted after the known ones.
 fn apply_project_columns(app: &mut EffectcraftApp, a: &[Value]) {
     let mut cols = vec![];
     for k in a.iter().filter_map(Value::as_str) {
@@ -357,6 +380,8 @@ fn apply_project_columns(app: &mut EffectcraftApp, a: &[Value]) {
     app.ui.project_columns = cols;
 }
 
+/// Merges `m` over the current Wiggler/Smoother/Motion Sketch settings by round-tripping them
+/// through JSON. A value of the wrong type is an error and leaves the settings unchanged.
 fn apply_anim_tools(app: &mut EffectcraftApp, m: &serde_json::Map<String, Value>) -> Result<(), String> {
     let mut cur = serde_json::to_value(&app.ui.anim_tools).unwrap_or_default();
     for (k, v) in m {
@@ -371,17 +396,21 @@ fn apply_anim_tools(app: &mut EffectcraftApp, m: &serde_json::Map<String, Value>
     }
 }
 
+/// Shows (`ui.panel.show`) or closes (`ui.panel.close`) the named panel; an unknown panel name
+/// is an error.
 fn panel(app: &mut EffectcraftApp, method: &str, p: &Value) -> Outcome {
     let s = |k: &str| p.get(k).and_then(Value::as_str);
     let Some(panel) = s("panel").and_then(PanelKind::from_name) else { return err("unknown `panel`") };
     if method == "ui.panel.show" {
         app.show_panel(panel);
     } else {
-        app.ui.dock.close(panel);
+        app.close_panel(panel);
     }
     ok(Value::Null)
 }
 
+/// The number of synthetic events a gesture queues: `2 * count + 3` for `ui.click` (`count`
+/// 1..=512), or 3 for `ui.move`. An out-of-range `count` or an overflow is an error.
 fn click_gesture_events(method: &str, p: &Value) -> Result<usize, String> {
     if method != "ui.click" {
         return Ok(3);
@@ -394,6 +423,10 @@ fn click_gesture_events(method: &str, p: &Value) -> Result<usize, String> {
     usize::try_from(count).ok().and_then(|n| n.checked_mul(2)).and_then(|n| n.checked_add(3)).ok_or_else(|| "click event count overflow".to_string())
 }
 
+/// Queues a click or a plain move at `{id}`'s centre (`fx`/`fy` within its rect, default 0.5)
+/// or at `{x, y}`, holding the request's modifiers across the whole gesture. An element that is
+/// not on screen returns [`Outcome::Retry`]; the gesture is size-checked against the 4096-event
+/// queue limit before anything is pushed. Replies [`Outcome::AfterInput`].
 fn click_or_move(app: &mut EffectcraftApp, method: &str, p: &Value) -> Outcome {
     let s = |k: &str| p.get(k).and_then(Value::as_str);
     let pos = match point(app, p) {
@@ -433,6 +466,10 @@ fn click_or_move(app: &mut EffectcraftApp, method: &str, p: &Value) -> Outcome {
     Outcome::AfterInput
 }
 
+/// Queues a primary-button drag from `from` to `to` over `steps` interpolated moves (default
+/// 12, at least 2, at most 2048), with the request's modifiers. Both endpoints are resolved
+/// first (an unseen element returns [`Outcome::Retry`]) and the event count is checked against
+/// the 4096-event queue limit. Replies [`Outcome::AfterInput`].
 fn drag(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     let (Some(from), Some(to)) = (p.get("from"), p.get("to")) else { return err("need `from` and `to`") };
     let (a, b) = match (point(app, from), point(app, to)) {
@@ -463,6 +500,9 @@ fn drag(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     Outcome::AfterInput
 }
 
+/// Queues a move to the target point, a wheel event of `dx`, `dy` (`unit`: points or lines) with
+/// the request's modifiers, a pinch's zoom factor, and a released Extra1 button. Replies
+/// [`Outcome::AfterInput`].
 fn scroll(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     let pos = match point(app, p) {
         Ok(p) => p,
@@ -470,14 +510,23 @@ fn scroll(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     };
     let dx = p.get("dx").and_then(Value::as_f64).unwrap_or(0.0) as f32;
     let dy = p.get("dy").and_then(Value::as_f64).unwrap_or(0.0) as f32;
+    let line = p.get("unit").and_then(Value::as_str) == Some("line");
+    let unit = if line { egui::MouseWheelUnit::Line } else { egui::MouseWheelUnit::Point };
+    // Without a `source`, a scroll in lines is a mouse wheel and one in points comes from an
+    // unnamed device, as on Windows, Linux and the web.
+    let source = match p.get("source").and_then(Value::as_str) {
+        Some("trackpad") => egui::MouseWheelSource::Trackpad,
+        Some("wheel") => egui::MouseWheelSource::Wheel,
+        _ if line => egui::MouseWheelSource::Wheel,
+        _ => egui::MouseWheelSource::Unknown,
+    };
     app.synthetic.push(egui::Event::PointerMoved(pos));
-    app.synthetic.push(egui::Event::MouseWheel {
-        unit: egui::MouseWheelUnit::Point,
-        delta: egui::vec2(dx, dy),
-        modifiers: modifiers(p),
-        phase: egui::TouchPhase::Move,
-        source: egui::MouseWheelSource::Wheel,
-    });
+    if dx != 0.0 || dy != 0.0 {
+        app.synthetic.push(egui::Event::MouseWheel { unit, delta: egui::vec2(dx, dy), modifiers: modifiers(p), phase: egui::TouchPhase::Move, source });
+    }
+    if let Some(pinch) = p.get("pinch").and_then(Value::as_f64).filter(|z| z.is_finite() && *z > 0.0) {
+        app.synthetic.push(egui::Event::Zoom(pinch as f32));
+    }
     app.synthetic.push(egui::Event::PointerButton {
         pos: egui::pos2(-100.0, -100.0),
         button: egui::PointerButton::Extra1,
@@ -487,6 +536,9 @@ fn scroll(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     Outcome::AfterInput
 }
 
+/// Queues a press and release of `key`, whose name may carry a shortcut (`Cmd+Shift+Z`); the
+/// separate `modifiers` flags are added. A `Physical+` prefix makes the key positional. An
+/// unknown key name is an error.
 fn key(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     let s = |k: &str| p.get(k).and_then(Value::as_str);
     let Some(name) = s("key") else { return err("missing `key`") };
@@ -499,6 +551,8 @@ fn key(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     Outcome::AfterInput
 }
 
+/// Queues a text event with `text`, followed by a released F35 key. Missing `text` is an
+/// error.
 fn type_text(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     let Some(text) = p.get("text").and_then(Value::as_str) else { return err("missing `text`") };
     app.synthetic.push(egui::Event::Text(text.to_string()));
@@ -506,6 +560,8 @@ fn type_text(app: &mut EffectcraftApp, p: &Value) -> Outcome {
     Outcome::AfterInput
 }
 
+/// Converts comp pixel `x`, `y` to a screen point with the viewer's current transform, or
+/// returns [`Outcome::Retry`] while the viewer is not visible.
 fn viewer_locate(ctx: &egui::Context, p: &Value) -> Outcome {
     let (Some(x), Some(y)) = (p.get("x").and_then(Value::as_f64), p.get("y").and_then(Value::as_f64)) else {
         return err("need `x`, `y` (comp pixels)");
@@ -516,6 +572,8 @@ fn viewer_locate(ctx: &egui::Context, p: &Value) -> Outcome {
     }
 }
 
+/// Converts a point (`{id}`, or `{x, y}`) to comp pixels; replies with an error when the
+/// viewer is not visible.
 fn viewer_hit(app: &mut EffectcraftApp, ctx: &egui::Context, p: &Value) -> Outcome {
     let pos = match point(app, p) {
         Ok(p) => p,
@@ -527,6 +585,9 @@ fn viewer_hit(app: &mut EffectcraftApp, ctx: &egui::Context, p: &Value) -> Outco
     }
 }
 
+/// Returns the screen point at `time` seconds on the ruler row of layer `layer`'s bar;
+/// without a numeric `time`, returns the bar's centre. Returns [`Outcome::Retry`] when the bar
+/// is unavailable, or a numeric `time` is supplied but the ruler is unavailable or malformed.
 fn timeline_locate(app: &EffectcraftApp, p: &Value) -> Outcome {
     let Some(l) = p.get("layer").and_then(Value::as_u64) else { return err("need `layer` (id)") };
     match crate::panels::timeline::locate(app, l, p.get("time").and_then(Value::as_f64)) {
@@ -535,6 +596,9 @@ fn timeline_locate(app: &EffectcraftApp, p: &Value) -> Outcome {
     }
 }
 
+/// Applies `action` (`play`, `stop`, `status`, else toggle) at `now` and replies with the
+/// playing state, current time in seconds, whether audio is present and the meter's level and
+/// peak in dB.
 fn playback(app: &mut EffectcraftApp, p: &Value, now: f64) -> Outcome {
     let action = p.get("action").and_then(Value::as_str).unwrap_or("toggle");
     match action {
@@ -548,8 +612,19 @@ fn playback(app: &mut EffectcraftApp, p: &Value, now: f64) -> Outcome {
     )
 }
 
+/// Resolves the capture target — a named panel, an element id, or the whole window — and
+/// returns [`Outcome::Retry`] while a requested panel or element is not registered, so a
+/// missing target is never silently captured as the window. Requests a repaint without raising
+/// or focusing the window and returns [`Outcome::Screenshot`]; the target is resolved again
+/// when the capture is issued.
 fn screenshot(app: &mut EffectcraftApp, ctx: &egui::Context, p: &Value) -> Outcome {
     let s = |k: &str| p.get(k).and_then(Value::as_str);
+    // A file the project reads is never the output.
+    if let Some(path) = s("path")
+        && let Err(e) = app.session.refuse_export(path)
+    {
+        return err(e);
+    }
     // The panel/element is an identity, not a rectangle: it is resolved when the capture
     // is issued (after the UI settles), so a panel that moves meanwhile is not cropped
     // with its old rectangle.
@@ -574,11 +649,12 @@ fn screenshot(app: &mut EffectcraftApp, ctx: &egui::Context, p: &Value) -> Outco
             crate::ShotTarget::Window | crate::ShotTarget::Rect(_) => "the element is not on screen".into(),
         });
     }
-    // Bring the window on screen so a frame is presented, without taking keyboard focus.
+    // Request a repaint without raising the window or taking keyboard focus.
     app.raise_for_control(ctx);
     Outcome::Screenshot { path: s("path").map(str::to_string), target }
 }
 
+/// Asks the viewport for an inner size of `width`×`height` pixels (default 1600×1000).
 fn resize(ctx: &egui::Context, p: &Value) -> Outcome {
     let w = p.get("width").and_then(Value::as_f64).unwrap_or(1600.0) as f32;
     let h = p.get("height").and_then(Value::as_f64).unwrap_or(1000.0) as f32;
@@ -586,6 +662,8 @@ fn resize(ctx: &egui::Context, p: &Value) -> Outcome {
     ok(Value::Null)
 }
 
+/// Sends the viewport close request. `force: true` marks the unsaved-changes state as
+/// quitting, so a modified project closes without the save prompt.
 fn quit(app: &mut EffectcraftApp, ctx: &egui::Context, p: &Value) -> Outcome {
     // A modified project asks to save first unless `force: true`.
     if p.get("force").and_then(Value::as_bool).unwrap_or(false) {
@@ -595,11 +673,17 @@ fn quit(app: &mut EffectcraftApp, ctx: &egui::Context, p: &Value) -> Outcome {
     ok(Value::Null)
 }
 
-/// `render.frame {comp?, time?, max_side?, path?, base64?}`: render a comp frame through the session
+/// `render.frame {comp?, time?, max_side?, path?, base64?, write?}`: render a comp frame through the session
 /// (independent of the viewer zoom/resolution) and return it as PNG, written to `path` (default a
-/// temp file) or inline as base64 when `base64: true`.
+/// temp file) or inline as base64 when `base64: true`. `write: true` with `base64: true` does both.
 fn render_frame(app: &EffectcraftApp, p: &Value) -> Outcome {
     let s = &app.session;
+    // A file the project reads is never the output (checked before rendering).
+    if let Some(path) = p.get("path").and_then(Value::as_str)
+        && let Err(e) = s.refuse_export(path)
+    {
+        return err(e);
+    }
     let cid = match s.resolve_comp(p.get("comp")) {
         Ok(c) => c,
         Err(e) => return err(e),
@@ -618,7 +702,7 @@ fn render_frame(app: &EffectcraftApp, p: &Value) -> Outcome {
     let mut out = json!({"comp": cid.0, "time": t.seconds(), "width": w, "height": h});
     // (the web has no file system: inline unless a path is given)
     let inline = p.get("base64").and_then(Value::as_bool).unwrap_or(cfg!(target_arch = "wasm32") && p.get("path").is_none());
-    if inline {
+    if inline && !p.get("write").and_then(Value::as_bool).unwrap_or(false) {
         out["png"] = json!(base64(&png));
         return ok(out);
     }
@@ -627,7 +711,10 @@ fn render_frame(app: &EffectcraftApp, p: &Value) -> Outcome {
         .and_then(Value::as_str)
         .map(str::to_string)
         .unwrap_or_else(|| std::env::temp_dir().join(format!("effectcraft-frame-{}.png", std::process::id())).to_string_lossy().to_string());
-    match std::fs::write(&path, png) {
+    if inline {
+        out["png"] = json!(base64(&png));
+    }
+    match s.write_output(&path, &png) {
         Ok(()) => {
             out["path"] = json!(path);
             ok(out)
@@ -653,6 +740,10 @@ pub fn base64(data: &[u8]) -> String {
     s
 }
 
+/// Builds the `ui.inspect` reply: window size and pixels per point, fps, UI state with the
+/// active comp's viewer resolution, playback and time, active comp, selected layer/key counts,
+/// registered element count, keyboard focus (egui id, rect, automation ids and rect
+/// candidates), fresh window focus, workspace storage error, open dialog and last frame time.
 pub fn inspect(app: &EffectcraftApp, ctx: &egui::Context) -> Value {
     // A logic-only tick refreshes the viewport information but not `InputState`'s screen rect.
     let size = ctx.input(|i| i.viewport().inner_rect).map_or_else(|| ctx.content_rect().size(), |r| r.size());
diff --git a/crates/ui-egui/src/credits.rs b/crates/ui-egui/src/credits.rs
index e69c99ce3..3395f44ca 100644
--- a/crates/ui-egui/src/credits.rs
+++ b/crates/ui-egui/src/credits.rs
@@ -1,7 +1,6 @@
 //! The About window's credits: every contributor (GitHub login always; display and real names only
 //! with recorded consent) and the AI models that helped. The tables are baked into the binary by
-//! build.rs from contributors/contributors.json (craftrules standards/contributors.md); nothing is
-//! read at run time.
+//! build.rs from contributors/contributors.json; nothing is read at run time.
 
 use crate::i18n::{tr, tr_args};
 use std::cmp::Ordering;
@@ -246,7 +245,7 @@ pub fn contributors_ui(ui: &mut egui::Ui, auto: &mut Registry) {
     ui.horizontal_wrapped(|ui| {
         ui.label(tr("Show"));
         for m in NameMode::ALL {
-            let r = ui.selectable_label(v.names == m, m.label());
+            let r = ui.selectable_label(v.names == m, tr(m.label()));
             auto.add(&format!("about.credits.show.{}", m.id()), r.rect, m.label());
             if r.clicked() {
                 v.names = m;
@@ -254,9 +253,9 @@ pub fn contributors_ui(ui: &mut egui::Ui, auto: &mut Registry) {
         }
         ui.separator();
         ui.label(tr("Sort"));
-        let combo = egui::ComboBox::from_id_salt("credits_sort").selected_text(v.key.label().0).show_ui(ui, |ui| {
+        let combo = craft_ui::ComboBox::from_id_salt("credits_sort").selected_text(tr(v.key.label().0)).show_ui(ui, |ui| {
             for k in SortKey::ALL {
-                let r = ui.selectable_label(v.key == k, k.label().0);
+                let r = ui.selectable_label(v.key == k, tr(k.label().0));
                 auto.add(&format!("about.credits.sort.{}", k.id()), r.rect, k.label().0);
                 if r.clicked() {
                     v.key = k;
@@ -309,7 +308,7 @@ fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View, auto: &mut Regi
     egui::Grid::new("credits_table").striped(true).num_columns(SortKey::ALL.len()).show(ui, |ui| {
         for k in SortKey::ALL {
             let arrow = if v.key == k { if v.ascending { " ▲" } else { " ▼" } } else { "" };
-            let r = ui.button(RichText::new(format!("{}{arrow}", k.label().1)).strong()).on_hover_text(k.label().0);
+            let r = ui.button(RichText::new(format!("{}{arrow}", k.label().1)).strong()).on_hover_text(tr(k.label().0));
             auto.add(&format!("about.credits.header.{}", k.id()), r.rect, k.label().0);
             if r.clicked() {
                 if v.key == k {
diff --git a/crates/ui-egui/src/dock.rs b/crates/ui-egui/src/dock.rs
index 3dbc83714..c8ada9bf8 100644
--- a/crates/ui-egui/src/dock.rs
+++ b/crates/ui-egui/src/dock.rs
@@ -1,11 +1,14 @@
-//! Docking: a tree of splits and tab groups. Panels are rounded frames separated by
-//! thin gutters; each group has a tab strip (active tab bright, with a panel menu "≡"); the focused
-//! panel gets a blue outline. Gutters drag to resize; workspaces are serialized trees.
+//! EffectCraft's panels and built-in workspaces in craft-ui's shared docking model
+//! ([`craft_ui::docking`]): splits, tab groups, After Effects' stacked panels and floating
+//! windows. craft-ui owns the layout model, its validation and every transaction; EffectCraft
+//! owns the panel ids, the built-in workspaces and the decorations of its tabs (the comp tabs of
+//! the Timeline, label swatches and viewer locks).
 
 use egui::{Align2, Rect, Sense, Stroke, pos2, vec2};
 use serde::{Deserialize, Serialize};
 
-use craft_ui::layout::{ResizeHandle, ResizeHandleStyle, SplitAxis, SplitSize as SharedSplitSize, split_rect};
+pub use craft_ui::docking::{Floating, Node, PanelState, Permissions, StackEntry};
+pub use craft_ui::layout::{SplitAxis, SplitSize};
 
 use crate::icons::{self, Icon};
 use crate::theme::Tokens;
@@ -134,6 +137,13 @@ impl PanelKind {
     pub fn id(self) -> String {
         format!("{self:?}")
     }
+    /// The shortcut scope of the panel: an additional viewer is a Composition panel.
+    pub fn shortcut_scope(self) -> String {
+        match self {
+            PanelKind::Viewer(_) => PanelKind::Composition.id(),
+            p => p.id(),
+        }
+    }
     pub fn from_name(s: &str) -> Option<PanelKind> {
         let n = s.to_ascii_lowercase().replace([' ', '_', '-', '&'], "");
         Self::ALL.iter().copied().find(|p| format!("{p:?}").to_ascii_lowercase() == n || p.title().to_ascii_lowercase().replace([' ', '&', '-'], "") == n)
@@ -161,117 +171,39 @@ impl PanelKind {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
-pub enum SplitSize {
-    Ratio(f32),
-    /// First child has a fixed size in points.
-    FixedA(f32),
-    /// Second child has a fixed size in points.
-    FixedB(f32),
+/// The docked tree plus floating windows.
+pub type Layout = craft_ui::docking::Layout<PanelKind>;
+/// What a workspace saves: the layout, closed panels with where each goes back, and the lock.
+pub type Workspace = craft_ui::docking::Workspace<PanelKind>;
+
+/// What may happen to a panel. Every panel moves, floats and closes, as in After Effects
+/// (the Composition panel too: Window ▸ Composition reopens it); the last docked group staying
+/// docked is checked per transaction ([`crate::dock_ui`]).
+pub fn permissions(_panel: &PanelKind) -> Permissions {
+    Permissions::default()
 }
 
-impl SplitSize {
-    fn shared(self) -> SharedSplitSize {
-        match self {
-            Self::Ratio(value) => SharedSplitSize::Ratio(value),
-            Self::FixedA(value) => SharedSplitSize::FixedFirst(value),
-            Self::FixedB(value) => SharedSplitSize::FixedSecond(value),
-        }
-    }
+/// A tab group.
+pub fn tabs(p: &[PanelKind], active: usize) -> Node<PanelKind> {
+    Node::Tabs { panels: p.to_vec(), active }
+}
+/// Stacked panels: (panel, open, height). Open entries share the stack's height in proportion to
+/// their heights; an entry without one counts as craft-ui's `DockStyle::min_pane` (40).
+pub fn stack(e: &[(PanelKind, bool, Option<f32>)]) -> Node<PanelKind> {
+    Node::Stack { entries: e.iter().map(|&(panel, open, height)| StackEntry { panel, open, height }).collect() }
+}
+/// Two frames side by side.
+pub fn hsplit(size: SplitSize, a: Node<PanelKind>, b: Node<PanelKind>) -> Node<PanelKind> {
+    Node::Split { axis: SplitAxis::Horizontal, size, first: Box::new(a), second: Box::new(b) }
+}
+/// Two frames one above the other.
+pub fn vsplit(size: SplitSize, a: Node<PanelKind>, b: Node<PanelKind>) -> Node<PanelKind> {
+    Node::Split { axis: SplitAxis::Vertical, size, first: Box::new(a), second: Box::new(b) }
 }
 
-/// One frame in a [`DockNode::Stack`]: a header with one tab per panel (a panel dropped onto a
-/// stacked panel joins its frame as a tab, as in After Effects).
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(from = "StackEntryRepr")]
-pub struct StackEntry {
-    pub panels: Vec<PanelKind>,
-    /// The shown tab.
-    pub active: usize,
-    pub open: bool,
-    /// Content height when open (set by dragging the gaps); `None` = share the remaining height.
-    pub height: Option<f32>,
-}
-
-/// A saved [`StackEntry`]: workspaces saved before stacked frames held tabs name one `panel`.
-#[derive(Deserialize)]
-struct StackEntryRepr {
-    #[serde(default)]
-    panel: Option<PanelKind>,
-    #[serde(default)]
-    panels: Vec<PanelKind>,
-    #[serde(default)]
-    active: usize,
-    open: bool,
-    #[serde(default)]
-    height: Option<f32>,
-}
-
-impl From<StackEntryRepr> for StackEntry {
-    fn from(r: StackEntryRepr) -> StackEntry {
-        let mut panels = r.panels;
-        if let Some(p) = r.panel
-            && !panels.contains(&p)
-        {
-            panels.insert(0, p);
-        }
-        let active = r.active.min(panels.len().saturating_sub(1));
-        StackEntry { panels, active, open: r.open, height: r.height }
-    }
-}
-
-impl StackEntry {
-    /// A frame showing just `panel`.
-    pub fn new(panel: PanelKind, open: bool, height: Option<f32>) -> StackEntry {
-        StackEntry { panels: vec![panel], active: 0, open, height }
-    }
-    pub fn contains(&self, p: PanelKind) -> bool {
-        self.panels.contains(&p)
-    }
-    /// The frame's shown panel.
-    pub fn shown(&self) -> Option<PanelKind> {
-        self.panels.get(self.active).or(self.panels.first()).copied()
-    }
-    /// Show `p` (one of its tabs).
-    fn show(&mut self, p: PanelKind) {
-        if let Some(i) = self.panels.iter().position(|x| *x == p) {
-            self.active = i;
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum DockNode {
-    /// `vertical`: children stacked top/bottom; else side by side.
-    Split {
-        vertical: bool,
-        size: SplitSize,
-        a: Box<DockNode>,
-        b: Box<DockNode>,
-    },
-    Tabs {
-        panels: Vec<PanelKind>,
-        active: usize,
-    },
-    /// After Effects' stacked panels (e.g. the Default workspace's right column): each panel has
-    /// a header row; clicking it expands or collapses the panel in place, and dragging the gap
-    /// between two open panels resizes them.
-    Stack {
-        entries: Vec<StackEntry>,
-    },
-}
-
-fn tabs(p: &[PanelKind], active: usize) -> DockNode {
-    DockNode::Tabs { panels: p.to_vec(), active }
-}
-fn stack(e: &[(PanelKind, bool, Option<f32>)]) -> DockNode {
-    DockNode::Stack { entries: e.iter().map(|&(panel, open, height)| StackEntry::new(panel, open, height)).collect() }
-}
-fn hsplit(size: SplitSize, a: DockNode, b: DockNode) -> DockNode {
-    DockNode::Split { vertical: false, size, a: Box::new(a), b: Box::new(b) }
-}
-fn vsplit(size: SplitSize, a: DockNode, b: DockNode) -> DockNode {
-    DockNode::Split { vertical: true, size, a: Box::new(a), b: Box::new(b) }
+/// A workspace of just `root`, with no floating windows.
+pub fn docked(root: Node<PanelKind>) -> Workspace {
+    Workspace::new(Layout { root: Some(root), floating: Vec::new() })
 }
 
 /// The built-in workspaces: After Effects 2026's (Window ▸ Workspace), less Libraries (an Adobe
@@ -296,24 +228,36 @@ pub const WORKSPACES: &[&str] = &[
     "Undocked Panels",
 ];
 
-/// The floating panels a workspace starts with (Undocked Panels), in points for a window of
-/// about 1680×1020 (they are kept inside the window when drawn).
-pub fn workspace_floating(name: &str) -> Vec<Floating> {
+/// The floating windows a workspace starts with (Undocked Panels), in points for a window of
+/// about 1680×1020 (craft-ui keeps them inside the window when drawn). Each window has a fixed
+/// id, so a built-in layout built again is the same set of windows.
+fn workspace_floating(name: &str) -> Vec<Floating<PanelKind>> {
     use PanelKind::*;
-    let f = |panels: &[PanelKind], rect: [f32; 4]| Floating { panels: panels.to_vec(), active: 0, rect };
+    let f = |id: u64, panels: &[PanelKind], rect: [f32; 4]| Floating::single(panels.to_vec(), 0, rect).with_id(id);
     match name {
         "Undocked Panels" => vec![
-            f(&[Project, EffectControls], [24.0, 110.0, 320.0, 420.0]),
-            f(&[Preview, Info, Audio], [1330.0, 110.0, 320.0, 300.0]),
-            f(&[EffectsPresets, Properties, Character, Paragraph], [1330.0, 430.0, 320.0, 360.0]),
-            f(&[Timeline, RenderQueue], [24.0, 640.0, 1280.0, 340.0]),
+            f(1, &[Project, EffectControls], [24.0, 110.0, 320.0, 420.0]),
+            f(2, &[Preview, Info, Audio], [1330.0, 110.0, 320.0, 300.0]),
+            f(3, &[EffectsPresets, Properties, Character, Paragraph], [1330.0, 430.0, 320.0, 360.0]),
+            f(4, &[Timeline, RenderQueue], [24.0, 640.0, 1280.0, 340.0]),
         ],
         _ => vec![],
     }
 }
 
-/// The default layout of a named workspace.
-pub fn workspace(name: &str) -> DockNode {
+/// The height of a frame's tab strip ([`Tokens::tab_h`]).
+pub const TAB_STRIP: f32 = 30.0;
+/// The height of Default's Preview frame: its tab strip over a 46-point body that fits the
+/// playback controls.
+pub const PREVIEW_FRAME: f32 = TAB_STRIP + 46.0;
+
+/// The built-in layout of a named workspace (an unknown name gets Default's).
+pub fn workspace(name: &str) -> Layout {
+    Layout { root: Some(workspace_root(name)), floating: workspace_floating(name) }
+}
+
+/// The docked tree of a named workspace.
+fn workspace_root(name: &str) -> Node<PanelKind> {
     use PanelKind::*;
     use SplitSize::*;
     let right = |p: &[PanelKind], q: &[PanelKind]| vsplit(Ratio(0.45), tabs(p, 0), tabs(q, 0));
@@ -321,45 +265,45 @@ pub fn workspace(name: &str) -> DockNode {
         "Animation" => vsplit(
             Ratio(0.55),
             hsplit(
-                FixedA(300.0),
+                FixedFirst(300.0),
                 tabs(&[Project, EffectControls], 1),
-                hsplit(FixedB(300.0), tabs(&[Composition, Layer], 0), right(&[Info, Preview, Audio], &[EffectsPresets, Smoother, Wiggler, MotionSketch])),
+                hsplit(FixedSecond(300.0), tabs(&[Composition, Layer], 0), right(&[Info, Preview, Audio], &[EffectsPresets, Smoother, Wiggler, MotionSketch])),
             ),
             tabs(&[Timeline, RenderQueue], 0),
         ),
         "Effects" => vsplit(
             Ratio(0.58),
             hsplit(
-                FixedA(340.0),
+                FixedFirst(340.0),
                 tabs(&[EffectControls, Project], 0),
-                hsplit(FixedB(300.0), tabs(&[Composition, Layer], 0), right(&[Info, Preview], &[EffectsPresets])),
+                hsplit(FixedSecond(300.0), tabs(&[Composition, Layer], 0), right(&[Info, Preview], &[EffectsPresets])),
             ),
             tabs(&[Timeline, RenderQueue], 0),
         ),
         "Motion Tracking" => vsplit(
             Ratio(0.6),
             hsplit(
-                FixedA(300.0),
+                FixedFirst(300.0),
                 tabs(&[Project, EffectControls], 0),
-                hsplit(FixedB(300.0), tabs(&[Layer, Composition], 0), right(&[Info, Preview], &[Tracker])),
+                hsplit(FixedSecond(300.0), tabs(&[Layer, Composition], 0), right(&[Info, Preview], &[Tracker])),
             ),
             tabs(&[Timeline], 0),
         ),
         "Paint" => vsplit(
             Ratio(0.6),
             hsplit(
-                FixedA(300.0),
+                FixedFirst(300.0),
                 tabs(&[Project, EffectControls], 0),
-                hsplit(FixedB(300.0), tabs(&[Layer, Composition], 0), right(&[Paint, Info], &[Brushes, Preview])),
+                hsplit(FixedSecond(300.0), tabs(&[Layer, Composition], 0), right(&[Paint, Info], &[Brushes, Preview])),
             ),
             tabs(&[Timeline], 0),
         ),
         "Text" => vsplit(
             Ratio(0.58),
             hsplit(
-                FixedA(300.0),
+                FixedFirst(300.0),
                 tabs(&[Project, EffectControls], 0),
-                hsplit(FixedB(300.0), tabs(&[Composition], 0), right(&[Character, Paragraph], &[Align, Preview, EffectsPresets])),
+                hsplit(FixedSecond(300.0), tabs(&[Composition], 0), right(&[Character, Paragraph], &[Align, Preview, EffectsPresets])),
             ),
             tabs(&[Timeline], 0),
         ),
@@ -367,31 +311,35 @@ pub fn workspace(name: &str) -> DockNode {
         // Review: a large viewer with the markers and the project beside it.
         "Review" => vsplit(
             Ratio(0.66),
-            hsplit(FixedA(280.0), tabs(&[Project, Markers], 0), hsplit(FixedB(260.0), tabs(&[Composition, Layer], 0), right(&[Preview, Info], &[Audio]))),
+            hsplit(
+                FixedFirst(280.0),
+                tabs(&[Project, Markers], 0),
+                hsplit(FixedSecond(260.0), tabs(&[Composition, Layer], 0), right(&[Preview, Info], &[Audio])),
+            ),
             tabs(&[Timeline, RenderQueue], 0),
         ),
         // Essential Graphics: the Properties panel (After Effects' successor to the Essential
         // Graphics panel) full height on the right, type panels beside the viewer.
         "Essential Graphics" => hsplit(
-            FixedB(320.0),
+            FixedSecond(320.0),
             vsplit(
                 Ratio(0.58),
                 hsplit(
-                    FixedA(280.0),
+                    FixedFirst(280.0),
                     tabs(&[Project, EffectControls], 0),
-                    hsplit(FixedB(260.0), tabs(&[Composition, Layer], 0), right(&[Character, Paragraph], &[Align, Preview])),
+                    hsplit(FixedSecond(260.0), tabs(&[Composition, Layer], 0), right(&[Character, Paragraph], &[Align, Preview])),
                 ),
                 tabs(&[Timeline], 0),
             ),
-            stack(&[(Properties, true, None), (EffectsPresets, false, None)]),
+            tabs(&[Properties, EffectsPresets], 0),
         ),
         // Color: wide Effect Controls for grading effects, Info for colour readouts.
         "Color" => vsplit(
             Ratio(0.6),
             hsplit(
-                FixedA(360.0),
+                FixedFirst(360.0),
                 tabs(&[EffectControls, Project], 0),
-                hsplit(FixedB(340.0), tabs(&[Composition, Layer], 0), right(&[LumetriScopes, Info, Preview], &[EffectsPresets])),
+                hsplit(FixedSecond(340.0), tabs(&[Composition, Layer], 0), right(&[LumetriScopes, Info, Preview], &[EffectsPresets])),
             ),
             tabs(&[Timeline], 0),
         ),
@@ -401,19 +349,19 @@ pub fn workspace(name: &str) -> DockNode {
         "Small Screen" => vsplit(
             Ratio(0.55),
             hsplit(
-                FixedA(240.0),
+                FixedFirst(240.0),
                 tabs(&[Project, EffectControls], 0),
-                hsplit(FixedB(240.0), tabs(&[Composition], 0), tabs(&[Info, Preview, EffectsPresets], 1)),
+                hsplit(FixedSecond(240.0), tabs(&[Composition], 0), tabs(&[Info, Preview, EffectsPresets], 1)),
             ),
             tabs(&[Timeline], 0),
         ),
         "All Panels" => vsplit(
             Ratio(0.55),
             hsplit(
-                FixedA(300.0),
+                FixedFirst(300.0),
                 tabs(&[Project, EffectControls, Flowchart, History, MediaBrowser, Metadata], 0),
                 hsplit(
-                    FixedB(300.0),
+                    FixedSecond(300.0),
                     tabs(&[Composition, Layer, Footage], 0),
                     right(
                         &[Info, Preview, Audio, Align, Character, Paragraph, LumetriScopes],
@@ -439,475 +387,130 @@ pub fn workspace(name: &str) -> DockNode {
         "Standard" => vsplit(
             Ratio(0.56),
             hsplit(
-                FixedA(300.0),
+                FixedFirst(300.0),
                 tabs(&[Project, EffectControls], 0),
-                hsplit(FixedB(290.0), tabs(&[Composition, Layer], 0), right(&[Info, Audio], &[Preview, EffectsPresets])),
+                hsplit(FixedSecond(290.0), tabs(&[Composition, Layer], 0), right(&[Info, Audio], &[Preview, EffectsPresets])),
             ),
             tabs(&[Timeline, RenderQueue], 0),
         ),
         // Default (as in After Effects): Project/Effect Controls | Composition over the Timeline,
-        // and a full-height right column with Preview above the Properties panel.
+        // and a full-height right column: a short Preview frame above the Properties frame.
         _ => hsplit(
-            FixedB(300.0),
-            vsplit(Ratio(0.56), hsplit(FixedA(300.0), tabs(&[Project, EffectControls], 0), tabs(&[Composition, Layer], 0)), tabs(&[Timeline, RenderQueue], 0)),
-            stack(&[(Preview, true, Some(46.0)), (Properties, true, None), (Align, false, None), (Audio, false, None), (EffectsPresets, false, None)]),
+            FixedSecond(300.0),
+            vsplit(
+                Ratio(0.56),
+                hsplit(FixedFirst(300.0), tabs(&[Project, EffectControls], 0), tabs(&[Composition, Layer], 0)),
+                tabs(&[Timeline, RenderQueue], 0),
+            ),
+            vsplit(FixedFirst(PREVIEW_FRAME), tabs(&[Preview], 0), tabs(&[Properties, Align, Audio, EffectsPresets], 0)),
         ),
     }
 }
 
-impl DockNode {
-    /// Every panel in the tree.
-    pub fn panels(&self, out: &mut Vec<PanelKind>) {
-        match self {
-            DockNode::Split { a, b, .. } => {
-                a.panels(out);
-                b.panels(out);
-            }
-            DockNode::Tabs { panels, .. } => out.extend(panels.iter().copied()),
-            DockNode::Stack { entries } => out.extend(entries.iter().flat_map(|e| e.panels.iter().copied())),
-        }
-    }
-    pub fn contains(&self, p: PanelKind) -> bool {
-        let mut v = Vec::new();
-        self.panels(&mut v);
-        v.contains(&p)
-    }
-    /// The tabs of the group `p` is in, in order.
-    pub fn group_of(&self, p: PanelKind) -> Option<&[PanelKind]> {
-        match self {
-            DockNode::Split { a, b, .. } => a.group_of(p).or_else(|| b.group_of(p)),
-            DockNode::Tabs { panels, .. } => panels.contains(&p).then_some(panels.as_slice()),
-            DockNode::Stack { entries } => entries.iter().find(|e| e.contains(p)).map(|e| e.panels.as_slice()),
-        }
-    }
-    /// Make `p` the active tab of its group. Returns false if not present.
-    pub fn activate(&mut self, p: PanelKind) -> bool {
-        if !crate::dock_shared::valid_tree(self) {
-            return false;
-        }
-        match self {
-            DockNode::Split { a, b, .. } => a.activate(p) || b.activate(p),
-            DockNode::Tabs { panels, active } => {
-                if let Some(i) = panels.iter().position(|x| *x == p) {
-                    *active = i;
-                    true
-                } else {
-                    false
-                }
-            }
-            DockNode::Stack { entries } => match entries.iter_mut().find(|e| e.contains(p)) {
-                Some(e) => {
-                    e.show(p);
-                    e.open = true;
-                    true
-                }
-                None => false,
-            },
-        }
-    }
-    /// Expand or collapse a stacked panel's frame (showing `p`). Returns false if `p` is not in
-    /// a stack.
-    pub fn toggle_stacked(&mut self, p: PanelKind) -> bool {
-        if !crate::dock_shared::valid_tree(self) {
-            return false;
-        }
-        match self {
-            DockNode::Split { a, b, .. } => a.toggle_stacked(p) || b.toggle_stacked(p),
-            DockNode::Tabs { .. } => false,
-            DockNode::Stack { entries } => match entries.iter_mut().find(|e| e.contains(p)) {
-                Some(e) => {
-                    e.show(p);
-                    e.open = !e.open;
-                    true
-                }
-                None => false,
-            },
-        }
-    }
+/// Queries on a workspace that EffectCraft's menus, commands and panels ask.
+pub trait WorkspaceExt {
+    /// `p` is in the docked tree.
+    fn is_docked(&self, p: PanelKind) -> bool;
+    /// `p` is in a floating window.
+    fn is_floating(&self, p: PanelKind) -> bool;
+    /// `p` is open, docked or floating.
+    fn is_open(&self, p: PanelKind) -> bool;
+    /// `p` shows: the front tab of its group, an open stacked panel, not in a minimized window.
+    fn is_visible(&self, p: PanelKind) -> bool;
+    /// The panels of the tab group holding `p` (a stacked panel is a group of its own).
+    fn group_of(&self, p: PanelKind) -> Vec<PanelKind>;
+    /// Every open panel, docked first.
+    fn panels(&self) -> Vec<PanelKind>;
+}
 
-    pub fn is_visible(&self, p: PanelKind) -> bool {
-        match self {
-            DockNode::Split { a, b, .. } => a.is_visible(p) || b.is_visible(p),
-            DockNode::Tabs { panels, active } => panels.get(*active) == Some(&p),
-            DockNode::Stack { entries } => entries.iter().any(|e| e.open && e.shown() == Some(p)),
+pub(crate) fn node_panels(node: &Node<PanelKind>, out: &mut Vec<PanelKind>) {
+    match node {
+        Node::Split { first, second, .. } => {
+            node_panels(first, out);
+            node_panels(second, out);
         }
-    }
-    /// Close a panel (remove its tab; empty groups collapse their split).
-    pub fn close(&mut self, p: PanelKind) {
-        if !crate::dock_shared::valid_for_close(self) {
-            return;
-        }
-        if let DockNode::Split { a, b, .. } = self {
-            a.close(p);
-            b.close(p);
-            let empty = |n: &DockNode| match n {
-                DockNode::Tabs { panels, .. } => panels.is_empty(),
-                DockNode::Stack { entries } => entries.is_empty(),
-                DockNode::Split { .. } => false,
-            };
-            if empty(a) {
-                *self = (**b).clone();
-            } else if empty(b) {
-                *self = (**a).clone();
-            }
-        } else if let DockNode::Tabs { panels, active } = self {
-            let shown = panels.get(*active).copied();
-            panels.retain(|x| *x != p);
-            *active = shown.and_then(|shown| panels.iter().position(|x| *x == shown)).unwrap_or((*active).min(panels.len().saturating_sub(1)));
-        } else if let DockNode::Stack { entries } = self {
-            for e in entries.iter_mut() {
-                let shown = e.shown();
-                e.panels.retain(|x| *x != p);
-                e.active = shown.and_then(|shown| e.panels.iter().position(|x| *x == shown)).unwrap_or(e.active.min(e.panels.len().saturating_sub(1)));
-            }
-            entries.retain(|e| !e.panels.is_empty());
-        }
-    }
-    /// Add a panel as a tab next to `near` (or into the first group).
-    pub fn open_near(&mut self, p: PanelKind, near: PanelKind) {
-        if !crate::dock_shared::valid_tree(self) {
-            return;
-        }
-        if self.contains(p) {
-            self.activate(p);
-            return;
-        }
-        fn add(n: &mut DockNode, p: PanelKind, near: PanelKind) -> bool {
-            match n {
-                DockNode::Split { a, b, .. } => add(a, p, near) || add(b, p, near),
-                DockNode::Tabs { panels, active } => {
-                    if panels.contains(&near) {
-                        panels.push(p);
-                        *active = panels.len() - 1;
-                        true
-                    } else {
-                        false
-                    }
-                }
-                DockNode::Stack { entries } => match entries.iter().position(|e| e.contains(near)) {
-                    Some(i) => {
-                        entries.insert(i + 1, StackEntry::new(p, true, None));
-                        true
-                    }
-                    None => false,
-                },
+        Node::Tabs { panels, .. } => out.extend(panels.iter().copied()),
+        Node::Stack { entries } => out.extend(entries.iter().map(|e| e.panel)),
+        Node::Dock { columns, .. } => {
+            for group in columns.iter().flat_map(|c| c.groups.iter()) {
+                out.extend(group.panels.iter().copied());
             }
         }
-        fn add_first(n: &mut DockNode, p: PanelKind) -> bool {
-            match n {
-                DockNode::Split { a, b, .. } => add_first(a, p) || add_first(b, p),
-                DockNode::Tabs { panels, active } if !panels.is_empty() => {
-                    panels.push(p);
-                    *active = panels.len() - 1;
-                    true
-                }
-                DockNode::Stack { entries } if !entries.is_empty() => {
-                    entries.push(StackEntry::new(p, true, None));
-                    true
-                }
-                _ => false,
-            }
-        }
-        if self.panel_count() == 0 {
-            // Every panel was closed: there is no anchor, so the panel becomes the whole dock.
-            *self = tabs(&[p], 0);
-        } else if !add(self, p, near) && !add(self, p, PanelKind::EffectsPresets) && !add(self, p, PanelKind::Project) {
-            // None of the anchors is docked (e.g. Minimal with Timeline closed): use the first group.
-            add_first(self, p);
-        }
+        _ => {}
     }
 }
 
-/// Where a dragged panel tab lands on a group: as a tab (center) or split off to one side.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum Zone {
-    Center,
-    Left,
-    Right,
-    Top,
-    Bottom,
+fn node_group(node: &Node<PanelKind>, p: PanelKind) -> Option<Vec<PanelKind>> {
+    match node {
+        Node::Split { first, second, .. } => node_group(first, p).or_else(|| node_group(second, p)),
+        Node::Tabs { panels, .. } => panels.contains(&p).then(|| panels.clone()),
+        Node::Stack { entries } => entries.iter().any(|e| e.panel == p).then(|| vec![p]),
+        Node::Dock { columns, .. } => columns.iter().flat_map(|c| c.groups.iter()).find(|g| g.panels.contains(&p)).map(|g| g.panels.clone()),
+        _ => None,
+    }
 }
 
-impl Zone {
-    pub(crate) fn shared(self) -> craft_ui::docking::Zone {
-        match self {
-            Self::Center => craft_ui::docking::Zone::Center,
-            Self::Left => craft_ui::docking::Zone::Left,
-            Self::Right => craft_ui::docking::Zone::Right,
-            Self::Top => craft_ui::docking::Zone::Top,
-            Self::Bottom => craft_ui::docking::Zone::Bottom,
+impl WorkspaceExt for Workspace {
+    fn is_docked(&self, p: PanelKind) -> bool {
+        self.layout.root.as_ref().is_some_and(|root| node_group(root, p).is_some())
+    }
+    fn is_floating(&self, p: PanelKind) -> bool {
+        self.layout.floating.iter().any(|w| w.contains(&p))
+    }
+    fn is_open(&self, p: PanelKind) -> bool {
+        self.layout.contains(&p)
+    }
+    fn is_visible(&self, p: PanelKind) -> bool {
+        self.layout.panel_state(&p) == PanelState::Front
+    }
+    fn group_of(&self, p: PanelKind) -> Vec<PanelKind> {
+        self.layout.root.iter().chain(self.layout.floating.iter().map(|w| &w.root)).find_map(|node| node_group(node, p)).unwrap_or_default()
+    }
+    fn panels(&self) -> Vec<PanelKind> {
+        let mut out = Vec::new();
+        for node in self.layout.root.iter().chain(self.layout.floating.iter().map(|w| &w.root)) {
+            node_panels(node, &mut out);
+        }
+        out
+    }
+}
+
+/// Every panel a workspace names: open, or closed with a recorded place.
+pub fn referenced_panels(workspace: &Workspace) -> Vec<PanelKind> {
+    let mut out = workspace.panels();
+    out.extend(workspace.hidden.iter().map(|(p, _)| *p));
+    if let Some(saved) = &workspace.saved {
+        for node in saved.root.iter().chain(saved.floating.iter().map(|w| &w.root)) {
+            node_panels(node, &mut out);
         }
     }
-
-    pub fn from_name(s: &str) -> Option<Zone> {
-        Some(match s.to_ascii_lowercase().as_str() {
-            "center" | "tab" => Zone::Center,
-            "left" => Zone::Left,
-            "right" => Zone::Right,
-            "top" => Zone::Top,
-            "bottom" => Zone::Bottom,
-            _ => return None,
-        })
-    }
+    out
 }
 
-/// The drop zone for a pointer at `pos` over a group `rect` (with a `tab_h` tab strip): the tab
-/// strip and the middle of the group are Center; within a quarter of the size from an edge,
-/// the nearest edge.
-pub fn drop_zone(rect: Rect, tab_h: f32, pos: egui::Pos2) -> Zone {
-    match craft_ui::docking::drop_zone(rect, tab_h, pos) {
-        Some(craft_ui::docking::Zone::Left) => Zone::Left,
-        Some(craft_ui::docking::Zone::Right) => Zone::Right,
-        Some(craft_ui::docking::Zone::Top) => Zone::Top,
-        Some(craft_ui::docking::Zone::Bottom) => Zone::Bottom,
-        _ => Zone::Center,
-    }
-}
-
-/// The shared preview region, or an empty rectangle for invalid geometry.
-pub fn zone_rect(rect: Rect, zone: Zone) -> Rect {
-    craft_ui::docking::zone_rect(rect, zone.shared()).unwrap_or(Rect::NOTHING)
-}
-
-/// A panel group floating over the dock (undocked).
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Floating {
-    pub panels: Vec<PanelKind>,
-    pub active: usize,
-    /// [x, y, w, h] in points.
-    pub rect: [f32; 4],
-}
-
-/// A floating group moved out of the main window into its own native window (which can sit on
-/// another monitor): the group holding `panel` shows there.
-#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
-pub struct PanelWindow {
-    pub panel: PanelKind,
-    /// The window's [x, y] outer position and [w, h] inner size, in desktop points.
-    pub rect: [f32; 4],
-}
-
-/// The smallest and largest native panel window, in points.
-pub const PANEL_WINDOW_MIN: [f32; 2] = [160.0, 100.0];
-pub const PANEL_WINDOW_MAX: f32 = 16_384.0;
-/// The farthest a native panel window may sit from the desktop origin, in points.
-pub const PANEL_WINDOW_MAX_POS: f32 = 100_000.0;
-
-impl PanelWindow {
-    /// The rect made safe to hand to the windowing system: finite, with a size within
-    /// [`PANEL_WINDOW_MIN`]..=[`PANEL_WINDOW_MAX`] and a position within
-    /// ±[`PANEL_WINDOW_MAX_POS`] (hostile workspace files and bad monitor reports included).
-    pub fn sanitized(rect: [f32; 4]) -> [f32; 4] {
-        let finite = |v: f32, fallback: f32| if v.is_finite() { v } else { fallback };
-        let [x, y, w, h] = rect;
-        [
-            finite(x, 0.0).clamp(-PANEL_WINDOW_MAX_POS, PANEL_WINDOW_MAX_POS),
-            finite(y, 0.0).clamp(-PANEL_WINDOW_MAX_POS, PANEL_WINDOW_MAX_POS),
-            finite(w, 420.0).clamp(PANEL_WINDOW_MIN[0], PANEL_WINDOW_MAX),
-            finite(h, 320.0).clamp(PANEL_WINDOW_MIN[1], PANEL_WINDOW_MAX),
-        ]
-    }
-}
-
-impl DockNode {
-    /// Insert panel `p` relative to the group that holds `anchor`: as a tab next to it
-    /// (Center) or in a new group split off to one side. In a stack, the group is `anchor`'s
-    /// frame: Center adds a tab to that frame and Top / Bottom add a frame above or below it
-    /// (#302); Left / Right split the column. `p` is removed from its old place first. Returns
-    /// false (tree unchanged) if `anchor` isn't docked or is `p` itself alone.
-    pub fn dock_panel(&mut self, p: PanelKind, anchor: PanelKind, zone: Zone) -> bool {
-        if !crate::dock_shared::valid_tree(self) || p == anchor || !self.contains(anchor) {
-            return false;
+/// The automation id of the gap below stacked panel `p`: `dock.gutter.<path>s<i>`, with the
+/// stack's split path (`a`/`b` per level) and the entry's index.
+pub fn stack_gutter_id(layout: &Layout, p: PanelKind) -> Option<String> {
+    fn rec(node: &Node<PanelKind>, p: PanelKind, path: &mut String, depth: usize) -> Option<String> {
+        if depth > craft_ui::docking::MAX_DEPTH {
+            return None;
         }
-        let before = self.clone();
-        self.close(p);
-        fn rec(n: &mut DockNode, p: PanelKind, anchor: PanelKind, zone: Zone) -> bool {
-            let here = match n {
-                DockNode::Split { a, b, .. } => return rec(a, p, anchor, zone) || rec(b, p, anchor, zone),
-                DockNode::Tabs { panels, .. } => panels.contains(&anchor),
-                DockNode::Stack { entries } => entries.iter().any(|e| e.contains(anchor)),
-            };
-            if !here {
-                return false;
+        match node {
+            Node::Split { first, second, .. } => {
+                path.push('a');
+                if let Some(id) = rec(first, p, path, depth + 1) {
+                    return Some(id);
+                }
+                path.pop();
+                path.push('b');
+                let found = rec(second, p, path, depth + 1);
+                path.pop();
+                found
             }
-            match (zone, &mut *n) {
-                (Zone::Center, DockNode::Tabs { panels, active }) => {
-                    let i = panels.iter().position(|x| *x == anchor).map_or(panels.len(), |i| i + 1);
-                    panels.insert(i, p);
-                    *active = i;
-                }
-                (Zone::Center, DockNode::Stack { entries }) => {
-                    let Some(e) = entries.iter_mut().find(|e| e.contains(anchor)) else { return false };
-                    let i = e.panels.iter().position(|x| *x == anchor).map_or(e.panels.len(), |i| i + 1);
-                    e.panels.insert(i, p);
-                    e.active = i;
-                    e.open = true;
-                }
-                (Zone::Top | Zone::Bottom, DockNode::Stack { entries }) => {
-                    let Some(i) = entries.iter().position(|e| e.contains(anchor)) else { return false };
-                    let at = if zone == Zone::Top { i } else { i + 1 };
-                    entries.insert(at, StackEntry::new(p, true, None));
-                }
-                (z, node) => {
-                    let new = tabs(&[p], 0);
-                    let old = std::mem::replace(node, tabs(&[], 0));
-                    let vertical = matches!(z, Zone::Top | Zone::Bottom);
-                    let (a, b) = if matches!(z, Zone::Left | Zone::Top) { (new, old) } else { (old, new) };
-                    *node = DockNode::Split { vertical, size: SplitSize::Ratio(0.5), a: Box::new(a), b: Box::new(b) };
-                }
-            }
-            true
-        }
-        if rec(self, p, anchor, zone) {
-            true
-        } else {
-            *self = before;
-            false
-        }
-    }
-
-    /// Move panel `p` into the group that holds `anchor` as a tab before `before` (one of that
-    /// group's panels) or last, and show it. False (tree unchanged) if `anchor` isn't docked.
-    pub fn insert_tab(&mut self, p: PanelKind, anchor: PanelKind, before: Option<PanelKind>) -> bool {
-        if !crate::dock_shared::valid_tree(self) {
-            return false;
-        }
-        if p == anchor || !self.contains(anchor) {
-            return false;
-        }
-        let saved = self.clone();
-        self.close(p);
-        fn rec(n: &mut DockNode, p: PanelKind, anchor: PanelKind, before: Option<PanelKind>) -> bool {
-            match n {
-                DockNode::Split { a, b, .. } => rec(a, p, anchor, before) || rec(b, p, anchor, before),
-                DockNode::Tabs { panels, active } if panels.contains(&anchor) => {
-                    let i = before.and_then(|b| panels.iter().position(|x| *x == b)).unwrap_or(panels.len());
-                    panels.insert(i, p);
-                    *active = i;
-                    true
-                }
-                DockNode::Stack { entries } => {
-                    // A tab of the anchor's frame.
-                    let Some(e) = entries.iter_mut().find(|e| e.contains(anchor)) else { return false };
-                    let i = before.and_then(|b| e.panels.iter().position(|x| *x == b)).unwrap_or(e.panels.len());
-                    e.panels.insert(i, p);
-                    e.active = i;
-                    e.open = true;
-                    true
-                }
-                _ => false,
-            }
-        }
-        if rec(self, p, anchor, before) {
-            true
-        } else {
-            *self = saved;
-            false
-        }
-    }
-
-    /// Path of the group containing `p` (as in [`Group::path`]; stacks add `sN`).
-    pub fn path_of(&self, p: PanelKind) -> Option<String> {
-        fn rec(n: &DockNode, p: PanelKind, path: &str) -> Option<String> {
-            match n {
-                DockNode::Split { a, b, .. } => rec(a, p, &format!("{path}a")).or_else(|| rec(b, p, &format!("{path}b"))),
-                DockNode::Tabs { panels, .. } => panels.contains(&p).then(|| path.to_string()),
-                DockNode::Stack { entries } => entries.iter().position(|e| e.contains(p)).map(|i| format!("{path}s{i}")),
-            }
-        }
-        rec(self, p, "")
-    }
-
-    /// Number of panels in the tree.
-    pub fn panel_count(&self) -> usize {
-        let mut v = vec![];
-        self.panels(&mut v);
-        v.len()
-    }
-}
-
-/// A full layout: the docked tree plus floating panels (what a workspace saves).
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Layout {
-    pub root: DockNode,
-    #[serde(default)]
-    pub floating: Vec<Floating>,
-}
-
-impl Layout {
-    /// Apply a shared transaction without replacing the persisted app schema.
-    pub fn apply(&mut self, action: craft_ui::docking::Action<PanelKind>) -> Result<(), String> {
-        crate::dock_shared::encode(&self.root, &self.floating)?.validate().map_err(|error| error.to_string())?;
-        let moving_to_float = match &action {
-            craft_ui::docking::Action::Float { panel, .. } => Some(*panel),
-            craft_ui::docking::Action::Move { panel, anchor, .. } if self.floating.iter().any(|group| group.panels.contains(anchor)) => Some(*panel),
+            Node::Stack { entries } => entries.iter().position(|e| e.panel == p).map(|i| format!("dock.gutter.{path}s{i}")),
             _ => None,
-        };
-        if moving_to_float.is_some_and(|panel| self.root.contains(panel) && self.root.panel_count() <= 1) {
-            return Err("the last docked panel must remain in the workspace".into());
         }
-        crate::dock_shared::apply(self, action)
     }
-
-    /// Undock an existing panel; the final docked panel stays in the workspace.
-    pub fn float(&mut self, p: PanelKind, rect: [f32; 4]) -> bool {
-        self.apply(craft_ui::docking::Action::Float { panel: p, rect }).is_ok()
-    }
-
-    /// Close an existing floating panel and collapse its empty group.
-    pub fn unfloat(&mut self, p: PanelKind) -> bool {
-        crate::dock_shared::unfloat(self, p)
-    }
-
-    /// Move or reorder a docked/floating tab through the shared transaction.
-    pub fn insert_tab(&mut self, p: PanelKind, anchor: PanelKind, before: Option<PanelKind>) -> bool {
-        if !crate::dock_shared::valid_tree(&self.root) {
-            return false;
-        }
-        self.apply(craft_ui::docking::Action::Move { panel: p, anchor, placement: craft_ui::docking::Placement::Tab { before } }).is_ok()
-    }
-
-    /// Dock a panel beside an anchor; floating destinations accept tabs only.
-    pub fn dock(&mut self, p: PanelKind, anchor: PanelKind, zone: Zone) -> bool {
-        if !crate::dock_shared::valid_tree(&self.root) {
-            return false;
-        }
-        self.apply(craft_ui::docking::Action::Move { panel: p, anchor, placement: craft_ui::docking::Placement::Split(zone.shared()) }).is_ok()
-    }
-
-    pub fn contains(&self, p: PanelKind) -> bool {
-        self.root.contains(p) || self.floating.iter().any(|group| group.panels.contains(&p))
-    }
-}
-
-/// One laid-out tab group.
-pub struct Group {
-    pub path: String,
-    pub rect: Rect,
-    pub content: Rect,
-    pub panels: Vec<PanelKind>,
-    pub active: usize,
-    /// In a [`DockNode::Stack`]: whether the panel is expanded.
-    pub stacked: Option<bool>,
-}
-
-/// Actions produced by interacting with the dock chrome.
-#[derive(Debug, Clone, PartialEq)]
-pub enum DockAction {
-    Activate(PanelKind),
-    /// Expand/collapse a stacked panel.
-    ToggleStacked(PanelKind),
-    Focus(PanelKind),
-    Close(PanelKind),
-    PanelMenu(PanelKind, egui::Pos2),
-    /// A tab started being dragged (re-dock or undock).
-    BeginDrag(PanelKind),
-    /// The tab's lock was toggled (Composition / Timeline viewer lock).
-    ToggleLock(PanelKind),
-    /// A document tab of a panel was clicked (the Timeline's tab of comp `id`).
-    ActivateDoc(PanelKind, u64),
-    /// A document tab's close button (or middle click): close that document (comp `id`).
-    CloseDoc(PanelKind, u64),
+    rec(layout.root.as_ref()?, p, &mut String::new(), 0)
 }
 
 /// One document a panel shows as a tab of its own (the Timeline: one tab per open comp, as in
@@ -916,447 +519,181 @@ pub enum DockAction {
 pub struct DocTab {
     pub id: u64,
     pub title: String,
-    pub deco: Option<TabDeco>,
+    /// The comp's label colour.
+    pub swatch: egui::Color32,
     /// The document the panel shows now.
     pub active: bool,
 }
 
-/// What a group's tabs show: labels, the comp swatch / close / lock decorations and the panels
-/// that show one tab per document.
-pub struct TabInfo<'a> {
-    pub title: &'a dyn Fn(PanelKind) -> String,
-    pub decos: &'a [(PanelKind, TabDeco)],
-    pub docs: &'a [(PanelKind, Vec<DocTab>)],
+/// What the Timeline's comp tabs did this frame.
+#[derive(Debug, Clone, PartialEq)]
+pub enum DocAction {
+    /// Show comp `id`.
+    Activate(u64),
+    /// Close comp `id`'s Timeline (its ×, or a middle click).
+    Close(u64),
 }
 
-/// What drawing a group's chrome produced: actions and where each panel's tabs are (a panel with
-/// document tabs spans all of them; tabs hidden behind the overflow chevron are left out).
-#[derive(Default)]
-pub struct Chrome {
-    pub actions: Vec<DockAction>,
-    pub tabs: Vec<(PanelKind, Rect)>,
+/// Room around a tab's label, as craft-ui gives its dock tabs.
+const TAB_PADDING: f32 = 24.0;
+/// Width of the » button that lists the comp tabs with no room in the strip.
+const DOC_OVERFLOW: f32 = 22.0;
+/// Room for the × after a comp's name. Every comp tab keeps it, so a tab keeps its width when it
+/// is shown or hovered.
+const DOC_CLOSE: f32 = 16.0;
+
+/// A comp tab's text: the label swatch, then the name, as the panel tabs with a swatch show it.
+fn doc_job(doc: &DocTab, font: &egui::FontId, color: egui::Color32) -> egui::text::LayoutJob {
+    let mut job = egui::text::LayoutJob::default();
+    job.append("\u{25a0} ", 0.0, egui::TextFormat::simple(font.clone(), doc.swatch));
+    job.append(&doc.title, 0.0, egui::TextFormat::simple(font.clone(), color));
+    job
 }
 
-/// After Effects-style extras on a tab that shows a composition (Composition, Timeline): a close
-/// button (×), the item's label colour as a small square and the viewer lock.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct TabDeco {
-    pub swatch: egui::Color32,
-    pub locked: bool,
-    /// Close button and lock (Composition, Timeline); Effect Controls shows just the swatch.
-    pub viewer: bool,
+/// The width of one line of `job` at the fonts' current size.
+fn text_width(ctx: &egui::Context, job: egui::text::LayoutJob) -> f32 {
+    ctx.fonts_mut(|f| f.layout_job(job)).size().x
 }
 
-/// Lay out the tree into group rects (with `gap` gutters) and handle gutter dragging.
-pub fn layout(ui: &mut egui::Ui, node: &mut DockNode, rect: Rect, t: &Tokens, path: &str, out: &mut Vec<Group>, reg: &mut crate::automation::Registry) {
-    let mut actions = Vec::new();
-    layout_with_actions(ui, node, rect, t, path, out, reg, &mut actions);
-    for action in actions {
-        crate::dock_shared::apply_tree(node, action);
-    }
+/// The width each comp tab asks for in the Timeline group's tab row.
+pub fn doc_widths(ctx: &egui::Context, docs: &[DocTab], font: &egui::FontId) -> Vec<f32> {
+    docs.iter().map(|d| text_width(ctx, doc_job(d, font, egui::Color32::WHITE)) + TAB_PADDING + DOC_CLOSE).collect()
 }
 
-/// Lay out chrome while returning mutations for the application's UI command route.
-pub fn layout_with_actions(
+/// The × of comp tab `doc` at `rect`, clipped to `clip`; true when clicked. `shown` is the comp
+/// the Timeline shows while it is the group's shown panel. Automation:
+/// `panel.tab.Timeline.<comp>.close`, and `panel.tab.Timeline.close` for the shown comp's.
+fn doc_close(
     ui: &mut egui::Ui,
-    node: &mut DockNode,
     rect: Rect,
-    t: &Tokens,
-    path: &str,
-    out: &mut Vec<Group>,
+    clip: Rect,
+    doc: &DocTab,
+    shown: bool,
+    style: &craft_ui::docking::DockStyle,
     reg: &mut crate::automation::Registry,
-    actions: &mut Vec<craft_ui::docking::Action<PanelKind>>,
-) {
-    layout_inner(ui, node, rect, t, path, &[], out, reg, actions);
+) -> bool {
+    let timeline = PanelKind::Timeline.id();
+    let hit = ui.interact(rect.expand(2.0), egui::Id::unique(("comp-tab-close", doc.id)), Sense::click());
+    hit.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, hit.enabled(), "Close"));
+    let cc = if hit.hovered() { style.text } else { style.inactive_text };
+    let k = 3.5;
+    let painter = ui.painter().with_clip_rect(clip);
+    painter.line_segment([rect.center() + vec2(-k, -k), rect.center() + vec2(k, k)], Stroke::new(1.2, cc));
+    painter.line_segment([rect.center() + vec2(-k, k), rect.center() + vec2(k, -k)], Stroke::new(1.2, cc));
+    reg.add_response(&format!("panel.tab.{timeline}.{}.close", doc.id), &hit, "Close");
+    if shown {
+        reg.add_response(&format!("panel.tab.{timeline}.close"), &hit, "Close");
+    }
+    hit.clicked()
 }
 
-fn layout_inner(
+/// Draw the Timeline's comp tabs into `strip`, the part of the Timeline group's tab row after its
+/// panel tabs. Each is a tab like the panel tabs: the comp's label swatch and name, then a ×
+/// that closes the comp's Timeline: always on the shown comp while the Timeline is the group's
+/// shown panel (`selected`), on the other comp tabs while the pointer is over them. Tabs that do
+/// not fit go to a » menu at the end; the shown comp's tab always stays in the row. Shift+, and
+/// Shift+. step through every open comp. Automation: `panel.tab.Timeline.<comp>`, the ×s (see
+/// [`doc_close`]), `panel.tab.Timeline.more` for », and `panel.tab.Timeline.more.<comp>` for its
+/// items.
+pub fn doc_tabs(
     ui: &mut egui::Ui,
-    node: &mut DockNode,
-    rect: Rect,
-    t: &Tokens,
-    path: &str,
-    tree_path: &[bool],
-    out: &mut Vec<Group>,
+    strip: Rect,
+    docs: &[DocTab],
+    selected: bool,
+    style: &craft_ui::docking::DockStyle,
     reg: &mut crate::automation::Registry,
-    actions: &mut Vec<craft_ui::docking::Action<PanelKind>>,
-) {
-    match node {
-        DockNode::Tabs { panels, active } => {
-            let tab_h = if panels.len() == 1 && panels[0].compact() { 8.0 } else { t.tab_h };
-            let content = Rect::from_min_max(pos2(rect.min.x, rect.min.y + tab_h), rect.max);
-            out.push(Group { path: path.to_string(), rect, content, panels: panels.clone(), active: *active, stacked: None });
-        }
-        DockNode::Stack { entries } => {
-            // A header for every entry; the open panels' bodies share the rest.
-            let head = t.tab_h;
-            let g = t.gap;
-            let n = entries.len() as f32;
-            let avail = rect.height() - n * head - (n - 1.0).max(0.0) * g;
-            let bodies = stack_bodies(entries, avail);
-            let mut y = rect.min.y;
-            let mut drag = None;
-            for (i, e) in entries.iter().enumerate() {
-                let body = bodies.get(i).copied().unwrap_or(0.0);
-                let r = Rect::from_min_max(pos2(rect.min.x, y), pos2(rect.max.x, (y + head + body).min(rect.max.y)));
-                let content = Rect::from_min_max(pos2(r.min.x, r.min.y + head), r.max);
-                let group = format!("{path}s{i}");
-                // The gap below a panel resizes the open panels on either side of it.
-                let above = entries.get(..=i).and_then(|s| s.iter().rposition(|x| x.open));
-                let below = entries.get(i + 1..).and_then(|s| s.iter().position(|x| x.open)).map(|k| i + 1 + k);
-                if let (Some(above), Some(below)) = (above, below) {
-                    let gap = Rect::from_min_max(pos2(rect.min.x, r.max.y), pos2(rect.max.x, r.max.y + g));
-                    if let Some(d) = gutter(ui, gap, true, &group, t, reg) {
-                        drag = Some((above, below, d));
-                    }
-                }
-                out.push(Group { path: group, rect: r, content, panels: e.panels.clone(), active: e.active, stacked: Some(e.open) });
-                y = r.max.y + g;
-            }
-            if let Some((above, below, d)) = drag {
-                let mut proposed = entries.clone();
-                resize_stacked(&mut proposed, &bodies, above, below, d);
-                for (before, after) in entries.iter().zip(proposed) {
-                    if before.height != after.height
-                        && let Some(panel) = after.shown()
-                    {
-                        actions.push(craft_ui::docking::Action::ResizeStack { panel, height: after.height });
-                    }
-                }
-            }
-        }
-        DockNode::Split { vertical, size, a, b } => {
-            let axis = if *vertical { SplitAxis::Vertical } else { SplitAxis::Horizontal };
-            let Some(split) = split_rect(rect, axis, size.shared(), t.gap, 20.0) else { return };
-            let response = resize_handle(split.divider, *vertical, path, t).value(split.first_size(), 0.0..=split.available()).show(ui);
-            reg.add(&format!("dock.gutter.{path}"), response.response.rect, "gutter");
-            if response.delta != 0.0
-                && let Some(resized) = split.resized(size.shared(), response.delta, 40.0)
-            {
-                actions.push(craft_ui::docking::Action::ResizeSplit { path: tree_path.to_vec(), size: resized });
-            }
-            let mut first_path = tree_path.to_vec();
-            first_path.push(false);
-            let mut second_path = tree_path.to_vec();
-            second_path.push(true);
-            layout_inner(ui, a, split.first, t, &format!("{path}a"), &first_path, out, reg, actions);
-            layout_inner(ui, b, split.second, t, &format!("{path}b"), &second_path, out, reg, actions);
-        }
-    }
-}
-
-/// A gap between dock areas that drags to resize them (`vertical`: up and down), with a slightly
-/// larger hit area than the gap. Returns the drag this frame.
-fn gutter(ui: &mut egui::Ui, gap: Rect, vertical: bool, path: &str, t: &Tokens, reg: &mut crate::automation::Registry) -> Option<f32> {
-    let response = resize_handle(gap, vertical, path, t).show(ui);
-    reg.add(&format!("dock.gutter.{path}"), response.response.rect, "gutter");
-    (response.delta != 0.0).then_some(response.delta)
-}
-
-fn resize_handle(gap: Rect, vertical: bool, path: &str, t: &Tokens) -> ResizeHandle<'static> {
-    let axis = if vertical { SplitAxis::Vertical } else { SplitAxis::Horizontal };
-    let style = ResizeHandleStyle { hovered: t.focus.gamma_multiply(0.4), dragged: t.focus.gamma_multiply(0.9), focused: t.focus };
-    let label = if vertical { crate::i18n::tr("Height:") } else { crate::i18n::tr("Width:") };
-    ResizeHandle::new(egui::Id::unique(("dock-gutter", path.to_string())), axis, gap, label, style)
-}
-
-/// The least body height of an open stacked panel (when the stack has room for it).
-const STACK_MIN: f32 = 40.0;
-
-/// An open stacked panel without a height of its own: it shares the room the others leave.
-fn flexible(e: &StackEntry) -> bool {
-    e.open && !e.height.is_some_and(f32::is_finite)
-}
-
-/// The body heights of a stack's panels in `avail` points (headers and gaps taken out). Open
-/// panels with a height keep it and the others share the rest; when no panel takes the rest, or
-/// there is too little room, the heights grow or shrink in proportion (down to [`STACK_MIN`]) so
-/// the open panels fill the stack.
-fn stack_bodies(entries: &[StackEntry], avail: f32) -> Vec<f32> {
-    let avail = if avail.is_finite() { avail.max(0.0) } else { 0.0 };
-    let open = entries.iter().filter(|e| e.open).count();
-    let min = STACK_MIN.min(avail / open.max(1) as f32);
-    let fixed: Vec<f32> = entries.iter().filter(|e| e.open && !flexible(e)).filter_map(|e| e.height).map(|h| h.max(min)).collect();
-    let flex = open.saturating_sub(fixed.len());
-    let k = fixed.len() as f32;
-    // What the panels with a height may take, and how much of it lies above their minimum.
-    let room = avail - flex as f32 * min;
-    let sum: f32 = fixed.iter().sum();
-    let (excess, target) = (sum - k * min, (room - k * min).max(0.0));
-    let fit = flex == 0 || sum > room;
-    let size = |h: f32| match (fit, excess > 0.0) {
-        (false, _) => h,
-        (true, true) => min + (h - min) / excess * target,
-        (true, false) => min + target / k.max(1.0),
-    };
-    let used: f32 = fixed.iter().map(|&h| size(h)).sum();
-    let share = (avail - used).max(0.0) / flex.max(1) as f32;
-    entries
-        .iter()
-        .map(|e| match (e.open, flexible(e)) {
-            (false, _) => 0.0,
-            (true, true) => share,
-            (true, false) => size(e.height.unwrap_or(min).max(min)),
-        })
-        .collect()
-}
-
-/// `v` held to `lo..=hi`, never panicking: when the room is too small for both minimums
-/// (`hi < lo`), `lo` wins; a non-finite `v` gives `lo`.
-#[cfg(test)]
-fn clamp_ordered(v: f32, lo: f32, hi: f32) -> f32 {
-    let lo = if lo.is_finite() { lo } else { 0.0 };
-    let hi = if hi.is_finite() { hi.max(lo) } else { lo };
-    if v.is_finite() { v.max(lo).min(hi) } else { lo }
-}
-
-/// The size of a split's first side in `avail` points (both sides keep 20 pt when there is room).
-/// `f32::clamp` panics when its bounds cross, which a split shorter than 40 pt did (#306).
-#[cfg(test)]
-fn split_first(size: SplitSize, avail: f32) -> f32 {
-    let avail = if avail.is_finite() { avail.max(0.0) } else { 0.0 };
-    let first = match size {
-        SplitSize::Ratio(r) => avail * r,
-        SplitSize::FixedA(px) => px.min(avail - 20.0),
-        SplitSize::FixedB(px) => avail - px.min(avail - 20.0),
-    };
-    let lo = 20.0_f32.min(avail);
-    clamp_ordered(first, lo, avail - 20.0).min(avail)
-}
-
-/// Drag the gap between the open stacked panels `above` and `below` (laid out at `bodies`) by
-/// `d` points: one grows as much as the other shrinks, neither below [`STACK_MIN`]. The new sizes
-/// become the panels' heights, except that the last panel without one keeps sharing the rest
-/// (so the stack still fills its column when the window is resized).
-fn resize_stacked(entries: &mut [StackEntry], bodies: &[f32], above: usize, below: usize, d: f32) {
-    let (Some(&a), Some(&b)) = (bodies.get(above), bodies.get(below)) else { return };
-    let pair = a + b;
-    let lo = STACK_MIN.min(pair / 2.0);
-    let na = (a + d).max(lo).min(pair - lo);
-    for (i, h) in [(above, na), (below, pair - na)] {
-        let last_flexible = entries.iter().filter(|e| flexible(e)).count() == 1;
-        if let Some(e) = entries.get_mut(i)
-            && !(last_flexible && flexible(e))
-        {
-            e.height = Some(h);
-        }
-    }
-}
-
-/// Draw a group's frame + tab strip: one tab per panel, or per document for panels that show
-/// several (the Timeline's comps). Tab labels may name the comp or layer they show (After
-/// Effects style).
-pub fn draw_group_chrome(ui: &mut egui::Ui, g: &Group, t: &Tokens, reg: &mut crate::automation::Registry, info: &TabInfo) -> Chrome {
-    struct Entry {
-        panel: PanelKind,
-        doc: Option<u64>,
-        label: String,
-        deco: Option<TabDeco>,
-        /// The group's shown tab.
-        active: bool,
-        /// The document its panel shows (even behind another tab).
-        shown_doc: bool,
-    }
-    let mut out = Chrome::default();
-    let painter = ui.painter().clone();
-    painter.rect_filled(g.rect, t.radius, t.panel_bg);
-    let active_panel = g.panels.get(g.active).copied();
-    let compact = g.panels.len() == 1 && g.panels[0].compact();
-    if compact {
-        // grip dots
-        let c = pos2(g.rect.center().x, g.rect.min.y + 4.0);
-        for dx in [-4.0, 0.0, 4.0] {
-            painter.circle_filled(c + vec2(dx, 0.0), 1.0, t.text_faint);
-        }
-    } else {
-        let mut entries: Vec<Entry> = vec![];
-        for (pi, p) in g.panels.iter().enumerate() {
-            let shown = pi == g.active;
-            match info.docs.iter().find(|(k, d)| k == p && !d.is_empty()) {
-                Some((_, docs)) => entries.extend(docs.iter().map(|d| Entry {
-                    panel: *p,
-                    doc: Some(d.id),
-                    label: d.title.clone(),
-                    deco: d.deco,
-                    active: shown && d.active,
-                    shown_doc: d.active,
-                })),
-                None => entries.push(Entry {
-                    panel: *p,
-                    doc: None,
-                    label: (info.title)(*p),
-                    deco: info.decos.iter().find(|(k, _)| k == p).map(|(_, d)| *d),
-                    active: shown,
-                    shown_doc: false,
-                }),
-            }
-        }
-        let ai = entries.iter().position(|e| e.active).unwrap_or(0);
-        let strip = Rect::from_min_size(g.rect.min, vec2(g.rect.width(), t.tab_h));
-        if t.gradients {
-            // Settings ▸ Appearance ▸ Use Gradients.
-            crate::theme::gradient_rect(&painter, strip.shrink2(vec2(t.radius, 0.0)), t.grad_top(t.panel_bg), t.panel_bg);
-        }
-        let activate = |e: &Entry| match e.doc {
-            Some(id) => DockAction::ActivateDoc(e.panel, id),
-            None => DockAction::Activate(e.panel),
+) -> Vec<DocAction> {
+    let mut out = Vec::new();
+    let timeline = PanelKind::Timeline.id();
+    let widths = doc_widths(ui.ctx(), docs, &style.font);
+    let active = docs.iter().position(|d| d.active).unwrap_or(0);
+    let fit = craft_ui::tabs::fit_whole(&widths, active, strip.width(), DOC_OVERFLOW);
+    let clip = strip.intersect(ui.clip_rect());
+    let mid = strip.center().y;
+    let mut x = strip.min.x;
+    for (index, width) in &fit.shown {
+        let Some(doc) = docs.get(*index) else { continue };
+        let tab = Rect::from_min_size(pos2(x, strip.min.y), vec2(*width, strip.height()));
+        x += width;
+        let on = selected && doc.active;
+        let color = if on { style.text } else { style.inactive_text };
+        let mut job = doc_job(doc, &style.font, color);
+        job.wrap = egui::text::TextWrapping {
+            max_width: (tab.width() - TAB_PADDING - DOC_CLOSE).max(0.0),
+            max_rows: 1,
+            break_anywhere: true,
+            overflow_character: Some('\u{2026}'),
         };
-        let close = |e: &Entry| match e.doc {
-            Some(id) => DockAction::CloseDoc(e.panel, id),
-            None => DockAction::Close(e.panel),
-        };
-        let mut x = strip.min.x + 12.0;
-        let text_y = strip.min.y + 16.0;
-        for (k, e) in entries.iter().enumerate() {
-            let p = &e.panel;
-            // A collapsed stacked panel's header is plain text (no underline or panel menu).
-            let is_active = k == ai && g.stacked != Some(false);
-            let galley = painter.layout_no_wrap(e.label.clone(), Tokens::ui(12.0), if is_active { t.tab_text_active } else { t.tab_text });
-            let menu_w = if is_active { 20.0 } else { 0.0 };
-            // The lock belongs to the panel: on its shown document's tab only.
-            let lock = e.deco.is_some_and(|d| d.viewer) && (e.doc.is_none() || is_active);
-            // × (active tab only), swatch and lock before the label.
-            let deco_w = match e.deco {
-                Some(d) if d.viewer => (if is_active { 16.0 } else { 0.0 }) + 14.0 + if lock { 16.0 } else { 0.0 },
-                Some(_) => 14.0,
-                None => 0.0,
-            };
-            let w = galley.size().x + 16.0 + menu_w + deco_w;
-            if x + w > strip.max.x - 20.0 && k > ai {
-                let r = Rect::from_min_size(pos2(strip.max.x - 22.0, strip.min.y + 6.0), vec2(18.0, 20.0));
-                let resp = ui.interact(r, egui::Id::unique(("tab-overflow", g.path.clone())), Sense::click());
-                icons::paint(&painter, r.shrink(4.0).translate(vec2(-2.0, 0.0)), Icon::ChevronRight, t.tab_text);
-                icons::paint(&painter, r.shrink(4.0).translate(vec2(2.0, 0.0)), Icon::ChevronRight, t.tab_text);
-                crate::widgets::focus_outline(ui, &resp, t);
-                reg.add_response(&format!("panel.overflow.{}", g.path), &resp, "More tabs");
-                if resp.clicked()
-                    && let Some(next) = entries.get((ai + 1) % entries.len())
-                {
-                    out.actions.push(activate(next));
-                }
-                break;
+        let galley = ui.fonts_mut(|f| f.layout_job(job));
+        let label_end = tab.min.x + TAB_PADDING * 0.5 + galley.size().x;
+        let resp = craft_ui::tabs::Tab::new(egui::Id::unique(("comp-tab", doc.id)), &doc.title, on).focus_stroke(Stroke::new(1.0, style.accent)).show_at(
+            ui,
+            tab,
+            |ui, response| {
+                let painter = ui.painter().with_clip_rect(tab.intersect(clip));
+                painter.rect_filled(tab, 0.0, if on || response.hovered() { style.active_background } else { style.tab_background });
+                painter.galley(pos2(tab.min.x + TAB_PADDING * 0.5, mid - galley.size().y * 0.5), galley.clone(), color);
+            },
+        );
+        let resp = if galley.elided { resp.on_hover_text(&doc.title) } else { resp };
+        reg.add_response(&format!("panel.tab.{timeline}.{}", doc.id), &resp, &doc.title);
+        // After the tab, so the × takes the clicks over it.
+        if on || ui.rect_contains_pointer(tab.intersect(clip)) {
+            let cr = Rect::from_center_size(pos2(label_end + DOC_CLOSE / 2.0, mid), vec2(10.0, 10.0));
+            if doc_close(ui, cr, tab.intersect(clip), doc, on, style, reg) {
+                out.push(DocAction::Close(doc.id));
             }
-            let tab = Rect::from_min_size(pos2(x, strip.min.y), vec2(w, t.tab_h));
-            match out.tabs.iter_mut().find(|(q, _)| q == p) {
-                Some((_, r)) => *r = r.union(tab),
-                None => out.tabs.push((*p, tab)),
-            }
-            let resp = ui.interact(tab, egui::Id::unique(("tab", g.path.clone(), k)), Sense::click_and_drag());
-            if resp.drag_started() {
-                out.actions.push(DockAction::BeginDrag(*p));
-            }
-            // A document tab also answers to the panel's id while it is the shown one.
-            let auto_id = match e.doc {
-                Some(id) => format!("panel.tab.{}.{id}", p.id()),
-                None => format!("panel.tab.{}", p.id()),
-            };
-            reg.add_response(&auto_id, &resp, &e.label);
-            if e.shown_doc {
-                reg.add_response(&format!("panel.tab.{}", p.id()), &resp, &e.label);
-            }
-            let mut label_x = tab.min.x + 8.0;
-            if let Some(d) = e.deco {
-                let mut dx = tab.min.x + 6.0;
-                if is_active && d.viewer {
-                    let cr = Rect::from_center_size(pos2(dx + 5.0, text_y), vec2(10.0, 10.0));
-                    let cresp = ui.interact(cr.expand(2.0), egui::Id::unique(("tab-close", g.path.clone(), k)), Sense::click());
-                    let cc = if cresp.hovered() { t.tab_text_active } else { t.tab_text };
-                    let kk = 3.5;
-                    painter.line_segment([cr.center() + vec2(-kk, -kk), cr.center() + vec2(kk, kk)], Stroke::new(1.2, cc));
-                    painter.line_segment([cr.center() + vec2(-kk, kk), cr.center() + vec2(kk, -kk)], Stroke::new(1.2, cc));
-                    reg.add_response(&format!("panel.tab.{}.close", p.id()), &cresp, "Close");
-                    crate::widgets::focus_outline(ui, &cresp, t);
-                    if cresp.clicked() {
-                        out.actions.push(close(e));
-                    }
-                    dx += 16.0;
-                }
-                let sw = Rect::from_center_size(pos2(dx + 5.0, text_y), vec2(9.0, 9.0));
-                painter.rect_filled(sw, 1.0, d.swatch);
-                dx += 14.0;
-                label_x = dx;
-                if lock {
-                    let lr = Rect::from_center_size(pos2(dx + 6.0, text_y), vec2(12.0, 12.0));
-                    let lresp = ui.interact(lr.expand(2.0), egui::Id::unique(("tab-lock", g.path.clone(), k)), Sense::click());
-                    let lc = if d.locked {
-                        t.tab_text_active
-                    } else if lresp.hovered() {
-                        t.tab_text
-                    } else {
-                        t.text_faint
-                    };
-                    icons::paint(&painter, lr, Icon::Lock, lc);
-                    reg.add_response(&format!("panel.tab.{}.lock", p.id()), &lresp, if d.locked { "Unlock" } else { "Lock" });
-                    crate::widgets::focus_outline(ui, &lresp, t);
-                    if lresp.clicked() {
-                        out.actions.push(DockAction::ToggleLock(*p));
-                    }
-                    label_x = dx + 16.0;
-                }
-            }
-            let label_w = galley.size().x;
-            let col = if is_active || resp.hovered() { t.tab_text_active } else { t.tab_text };
-            painter.galley_with_override_text_color(pos2(label_x, text_y - galley.size().y / 2.0), galley, col);
-            if is_active {
-                let mr = Rect::from_center_size(pos2(label_x + label_w + 12.0, text_y), vec2(12.0, 10.0));
-                let mresp = ui.interact(mr.expand(3.0), egui::Id::unique(("tab-menu", g.path.clone())), Sense::click());
-                reg.add_response(&format!("panel.menu.{}", p.id()), &mresp, "panel menu");
-                let mc = if mresp.hovered() { t.tab_text_active } else { t.tab_text };
-                for dy in [-3.5, 0.0, 3.5] {
-                    painter.line_segment([pos2(mr.min.x, mr.center().y + dy), pos2(mr.max.x, mr.center().y + dy)], Stroke::new(1.5, mc));
-                }
-                let uy = strip.min.y + 23.0;
-                painter.line_segment([pos2(label_x, uy), pos2(mr.max.x, uy)], Stroke::new(1.0, t.tab_text_active));
-                crate::widgets::focus_outline(ui, &mresp, t);
-                if mresp.clicked() {
-                    out.actions.push(DockAction::PanelMenu(*p, mr.left_bottom()));
-                }
-            }
-            crate::widgets::focus_outline(ui, &resp, t);
-            if resp.clicked() {
-                // A stacked frame's shown tab expands / collapses it; another tab shows that
-                // panel (expanding the frame).
-                if g.stacked.is_some() && (k == ai || entries.len() == 1) {
-                    out.actions.push(DockAction::ToggleStacked(*p));
-                } else {
-                    out.actions.push(activate(e));
-                }
-                out.actions.push(DockAction::Focus(*p));
-            }
-            if resp.middle_clicked() {
-                out.actions.push(close(e));
-            }
-            x += w + 8.0;
         }
-        // A stacked panel's whole header bar expands/collapses it, not just its name (as in After
-        // Effects): the frame with its shown tab.
-        if g.stacked.is_some()
-            && let Some(e) = entries.get(ai).or(entries.first())
-        {
-            let rest = Rect::from_min_max(pos2((x - 8.0).max(strip.min.x), strip.min.y), strip.max);
-            if rest.width() > 0.0 {
-                let resp = ui.interact(rest, egui::Id::unique(("tab-rest", g.path.clone())), Sense::click());
-                reg.add(&format!("panel.header.{}", e.panel.id()), rest, &e.label);
-                if resp.clicked() {
-                    out.actions.push(DockAction::ToggleStacked(e.panel));
-                    out.actions.push(DockAction::Focus(e.panel));
-                }
-            }
+        if resp.clicked() {
+            out.push(DocAction::Activate(doc.id));
+        }
+        if resp.middle_clicked() {
+            out.push(DocAction::Close(doc.id));
         }
     }
-    // clicking anywhere in the panel focuses it; a press on another of its tabs waits for that
-    // tab's click, which focuses the panel actually chosen (a text edit stays open in Character)
-    let at = ui.input(|i| i.pointer.interact_pos());
-    if let Some(p) = active_panel
-        && ui.rect_contains_pointer(g.rect)
-        && ui.input(|i| i.pointer.any_pressed())
-        && !out.tabs.iter().any(|(q, r)| *q != p && at.is_some_and(|a| r.contains(a)))
-    {
-        out.actions.push(DockAction::Focus(p));
+    if !fit.overflow.is_empty() && fit.overflow_width > 0.0 {
+        let more = Rect::from_min_size(pos2(x, strip.min.y), vec2(fit.overflow_width, strip.height()));
+        let resp = ui.interact(more, egui::Id::unique("comp-tabs-more"), Sense::click());
+        resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, resp.enabled(), "More compositions"));
+        reg.add_response(&format!("panel.tab.{timeline}.more"), &resp, "More compositions");
+        let color = if resp.hovered() { style.text } else { style.inactive_text };
+        ui.painter().with_clip_rect(more.intersect(clip)).text(more.center(), Align2::CENTER_CENTER, "\u{bb}", style.font.clone(), color);
+        egui::Popup::menu(&resp).show(|ui| {
+            egui::ScrollArea::vertical().max_height(360.0).show(ui, |ui| {
+                for index in &fit.overflow {
+                    let Some(doc) = docs.get(*index) else { continue };
+                    let item = ui.button(doc_job(doc, &style.font, style.text));
+                    item.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, item.enabled(), &doc.title));
+                    reg.add_response(&format!("panel.tab.{timeline}.more.{}", doc.id), &item, &doc.title);
+                    if item.clicked() {
+                        out.push(DocAction::Activate(doc.id));
+                        ui.close();
+                    }
+                }
+            });
+        });
     }
     out
 }
 
+/// A viewer lock button (Composition viewers and the Timeline keep their comp while locked): a
+/// closed padlock while locked, an open one while unlocked.
+/// Returns true when clicked. Automation: `panel.tab.<panel>.lock`.
+pub fn lock_button(ui: &mut egui::Ui, rect: Rect, panel: PanelKind, locked: bool, t: &Tokens, reg: &mut crate::automation::Registry) -> bool {
+    let resp = ui.interact(rect, egui::Id::unique(("tab-lock", panel.id())), Sense::click());
+    let color = if locked {
+        t.tab_text_active
+    } else if resp.hovered() {
+        t.tab_text
+    } else {
+        t.text_faint
+    };
+    icons::paint(ui.painter(), rect.shrink(2.0), if locked { Icon::Lock } else { Icon::LockOpen }, color);
+    reg.add_response(&format!("panel.tab.{}.lock", panel.id()), &resp, if locked { "Unlock" } else { "Lock" });
+    crate::widgets::focus_outline(ui, &resp, t);
+    resp.clicked()
+}
+
 /// Placeholder body for panels that are not implemented yet.
 pub fn placeholder(ui: &mut egui::Ui, rect: Rect, t: &Tokens, text: &str) {
     ui.painter().text(rect.center(), Align2::CENTER_CENTER, text, Tokens::ui(12.0), t.text_faint);
@@ -1365,438 +702,91 @@ pub fn placeholder(ui: &mut egui::Ui, rect: Rect, t: &Tokens, text: &str) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use PanelKind::*;
+    use craft_ui::docking::{Action, Placement, Zone};
+
+    fn apply(w: &mut Workspace, action: Action<PanelKind>) {
+        w.apply(action, permissions).unwrap();
+    }
 
-    /// The original split clamp panicked whenever 0 < available < 40. Run the actual dock
-    /// layout without the app's last-resort panic guard so that regression cannot be hidden.
     #[test]
-    fn tiny_split_layouts_stay_inside_their_parent() {
-        let ctx = egui::Context::default();
-        let tokens = Tokens::for_kind(crate::theme::ThemeKind::Dark);
-        for extent in [20.0, 0.0, 1.0, 5.0, 15.0, 35.0, 39.9, 40.0, 80.0] {
-            for vertical in [false, true] {
-                for size in [SplitSize::Ratio(0.5), SplitSize::FixedA(300.0), SplitSize::FixedB(300.0)] {
-                    let rect = Rect::from_min_size(egui::Pos2::ZERO, egui::Vec2::splat(extent));
-                    let mut node =
-                        DockNode::Split { vertical, size, a: Box::new(tabs(&[PanelKind::Project], 0)), b: Box::new(tabs(&[PanelKind::Composition], 0)) };
-                    let mut groups = vec![];
-                    let mut registry = crate::automation::Registry::default();
-                    let mut output = ctx.run_ui(egui::RawInput::default(), |ui| layout(ui, &mut node, rect, &tokens, "", &mut groups, &mut registry));
-                    output.textures_delta.clear();
-                    assert_eq!(groups.len(), 2);
-                    for group in groups {
-                        assert!(rect.contains_rect(group.rect), "{extent}, {vertical}: {:?}", group.rect);
-                        assert!(group.rect.width() >= 0.0 && group.rect.height() >= 0.0);
-                    }
-                }
+    fn after_effects_workspaces_exist_with_their_core_panels() {
+        for name in WORKSPACES {
+            let w = Workspace::new(workspace(name));
+            w.validate().unwrap_or_else(|e| panic!("{name}: {e}"));
+            assert!(w.is_docked(Composition), "{name}");
+            if *name != "Undocked Panels" {
+                assert!(w.is_docked(Timeline), "{name}");
             }
         }
-    }
-
-    #[test]
-    fn open_near_in_an_empty_dock_makes_the_panel_the_dock() {
-        for p in [PanelKind::Composition, PanelKind::Timeline, PanelKind::Project] {
-            let mut d = tabs(&[], 0);
-            d.open_near(p, PanelKind::EffectsPresets);
-            assert!(d.is_visible(p));
-            assert_eq!(d.panel_count(), 1);
+        let all = Workspace::new(workspace("All Panels"));
+        for p in PanelKind::ALL.iter().filter(|p| !matches!(p, ScriptConsole | EssentialGraphics | MaskInterpolation)) {
+            assert!(all.is_open(*p), "All Panels lacks {p:?}");
         }
-    }
-
-    #[test]
-    fn open_near_without_any_anchor_uses_the_first_group() {
-        let mut d = tabs(&[PanelKind::Composition], 0);
-        d.open_near(PanelKind::Timeline, PanelKind::EffectsPresets);
-        assert!(d.is_visible(PanelKind::Timeline));
-        assert_eq!(d.panel_count(), 2);
-    }
-
-    #[test]
-    fn stacked_panels_toggle_open_close() {
-        use PanelKind::*;
-        let mut d = stack(&[(Preview, true, Some(46.0)), (Properties, true, None), (Align, false, None)]);
-        assert!(d.is_visible(Properties) && !d.is_visible(Align));
-        assert!(d.toggle_stacked(Align));
-        assert!(d.is_visible(Align));
-        assert!(d.toggle_stacked(Align) && !d.is_visible(Align));
-        // Showing a collapsed panel expands it; opening a new panel near one inserts after it.
-        assert!(d.activate(Align) && d.is_visible(Align));
-        d.open_near(Info, Properties);
-        let mut v = vec![];
-        d.panels(&mut v);
-        assert_eq!(v, [Preview, Properties, Info, Align]);
-        d.close(Preview);
-        assert!(!d.contains(Preview));
-        assert!(!d.toggle_stacked(Timeline));
-    }
-
-    fn entry(panel: PanelKind, open: bool, height: Option<f32>) -> StackEntry {
-        StackEntry::new(panel, open, height)
-    }
-
-    fn close_to(a: &[f32], b: &[f32]) -> bool {
-        a.len() == b.len() && a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-3)
-    }
-
-    #[test]
-    fn stacked_panels_fill_their_column() {
-        use PanelKind::*;
-        // A panel with a height keeps it; the open ones without share the rest.
-        let s = [entry(Preview, true, Some(100.0)), entry(Properties, true, None), entry(Align, false, None), entry(Audio, true, None)];
-        assert!(close_to(&stack_bodies(&s, 500.0), &[100.0, 200.0, 0.0, 200.0]));
-        // Too little room: the heights shrink so the others keep their minimum.
-        let s = [entry(Preview, true, Some(500.0)), entry(Properties, true, None)];
-        assert!(close_to(&stack_bodies(&s, 300.0), &[260.0, STACK_MIN]));
-        // Nothing to take the rest: the heights grow in proportion (above the minimum) to fill.
-        let s = [entry(Preview, true, Some(100.0)), entry(Properties, true, Some(300.0)), entry(Align, false, Some(80.0))];
-        assert!(close_to(&stack_bodies(&s, 600.0), &[137.5, 462.5, 0.0]));
-        let s = [entry(Preview, true, Some(46.0)), entry(Properties, false, None)];
-        assert!(close_to(&stack_bodies(&s, 600.0), &[600.0, 0.0]));
-        // Hostile sizes never make a body negative or non-finite.
-        for avail in [-50.0, 0.0, 10.0, f32::NAN, f32::INFINITY] {
-            for h in [None, Some(-5.0), Some(f32::NAN), Some(f32::INFINITY), Some(1e30), Some(f32::MAX)] {
-                let s = [entry(Preview, true, h), entry(Properties, true, Some(60.0)), entry(Align, false, h)];
-                let b = stack_bodies(&s, avail);
-                assert!(b.iter().all(|x| x.is_finite() && *x >= 0.0), "{avail} {h:?}: {b:?}");
+        // No built-in workspace uses accordions: right columns are frames split vertically.
+        fn no_stack(node: &Node<PanelKind>) -> bool {
+            match node {
+                Node::Split { first, second, .. } => no_stack(first) && no_stack(second),
+                Node::Stack { .. } => false,
+                _ => true,
             }
         }
-        assert!(stack_bodies(&[], 100.0).is_empty());
-    }
-
-    #[test]
-    fn dragging_a_stack_gap_trades_height_between_its_neighbours() {
-        use PanelKind::*;
-        let mut s = vec![entry(Preview, true, Some(46.0)), entry(Properties, true, None), entry(Align, false, None)];
-        let bodies = stack_bodies(&s, 800.0);
-        resize_stacked(&mut s, &bodies, 0, 1, 100.0);
-        // Preview keeps its new height; Properties, the only panel without one, takes the rest.
-        assert_eq!(s[0].height, Some(146.0));
-        assert_eq!(s[1].height, None);
-        assert!(close_to(&stack_bodies(&s, 800.0), &[146.0, 654.0, 0.0]));
-        // Neither side goes below the minimum.
-        for (d, want) in [(-1000.0, STACK_MIN), (1000.0, 800.0 - STACK_MIN)] {
-            let bodies = stack_bodies(&s, 800.0);
-            resize_stacked(&mut s, &bodies, 0, 1, d);
-            assert!(close_to(&stack_bodies(&s, 800.0)[..1], &[want]), "{d}");
-        }
-        // Two sharing panels: the upper one gets a height, the lower one keeps sharing.
-        let mut s = vec![entry(Preview, true, None), entry(Align, false, None), entry(Properties, true, None)];
-        let bodies = stack_bodies(&s, 400.0);
-        resize_stacked(&mut s, &bodies, 0, 2, 50.0);
-        assert_eq!((s[0].height, s[2].height), (Some(250.0), None));
-        assert!(close_to(&stack_bodies(&s, 400.0), &[250.0, 0.0, 150.0]));
-        // Out-of-range indices change nothing.
-        let before = s.clone();
-        resize_stacked(&mut s, &bodies, 0, 9, 50.0);
-        assert_eq!(s, before);
-    }
-
-    #[test]
-    fn default_workspace_has_ae_right_column_stack() {
-        let d = workspace("Default");
-        assert!(d.is_visible(PanelKind::Properties) && d.is_visible(PanelKind::Preview));
-        assert!(d.contains(PanelKind::EffectsPresets) && !d.is_visible(PanelKind::EffectsPresets));
-    }
-
-    #[test]
-    fn workspaces_contain_core_panels() {
-        for w in WORKSPACES {
-            let d = workspace(w);
-            let floating: Vec<PanelKind> = workspace_floating(w).into_iter().flat_map(|f| f.panels).collect();
-            assert!(d.contains(PanelKind::Timeline) || floating.contains(&PanelKind::Timeline), "{w}");
-            assert!(d.contains(PanelKind::Composition) || d.contains(PanelKind::Layer), "{w}");
-            // A panel is in one place only.
-            let mut all = vec![];
-            d.panels(&mut all);
-            all.extend(floating);
-            let n = all.len();
-            all.sort_by_key(|p| p.id());
-            all.dedup();
-            assert_eq!(all.len(), n, "{w} has a panel twice");
+        for name in WORKSPACES {
+            let layout = workspace(name);
+            assert!(layout.root.iter().chain(layout.floating.iter().map(|f| &f.root)).all(no_stack), "{name}");
         }
     }
 
     #[test]
-    fn after_effects_workspaces_exist() {
-        // Window ▸ Workspace in After Effects 2026, less Libraries (an Adobe service).
-        for w in [
-            "Default",
-            "Review",
-            "Learn",
-            "Small Screen",
-            "Standard",
-            "All Panels",
-            "Animation",
-            "Essential Graphics",
-            "Color",
-            "Effects",
-            "Minimal",
-            "Motion Tracking",
-            "Paint",
-            "Text",
-            "Undocked Panels",
-        ] {
-            assert!(WORKSPACES.contains(&w), "{w}");
-        }
-        assert!(!WORKSPACES.contains(&"Libraries"));
-        // Layouts differ from Default (except Learn, which is Default plus the Home screen).
-        let def = workspace("Default");
-        for w in WORKSPACES.iter().filter(|w| !matches!(**w, "Default" | "Learn")) {
-            assert_ne!(workspace(w), def, "{w} falls back to Default");
-        }
-        assert!(workspace("Essential Graphics").contains(PanelKind::Properties));
-        assert!(workspace("Color").contains(PanelKind::EffectControls));
-        assert!(!workspace_floating("Undocked Panels").is_empty());
-        // Every built-in workspace is in Window ▸ Workspace.
-        let menu: Vec<String> = effectcraft_engine::menus::entries()
-            .into_iter()
-            .filter(|(_, e)| e.command == "window.workspace")
-            .filter_map(|(_, e)| e.params.get("name").and_then(|v| v.as_str()).map(str::to_string))
-            .collect();
-        for w in WORKSPACES {
-            assert!(menu.iter().any(|m| m == w), "{w} missing from Window > Workspace");
-        }
-    }
-
-    #[test]
-    fn short_splits_lay_out_without_panicking() {
-        // #306: a split 0 < avail < 40 pt tall made `f32::clamp` panic (its bounds crossed).
-        for avail in [0.0, 5.0, 19.0, 20.0, 30.0, 39.0, 40.0, 41.0, -10.0, f32::NAN, f32::INFINITY] {
-            for size in [SplitSize::Ratio(0.5), SplitSize::Ratio(f32::NAN), SplitSize::FixedA(300.0), SplitSize::FixedB(300.0), SplitSize::FixedA(-5.0)] {
-                let f = split_first(size, avail);
-                assert!(f.is_finite() && f >= 0.0, "{size:?} {avail}: {f}");
-                if avail.is_finite() && avail > 0.0 {
-                    assert!(f <= avail, "{size:?} {avail}: {f}");
-                }
-            }
-        }
-        assert_eq!(split_first(SplitSize::FixedA(300.0), 30.0), 20.0);
-        assert_eq!(split_first(SplitSize::Ratio(0.5), 200.0), 100.0);
-        assert_eq!(clamp_ordered(5.0, 40.0, -4.0), 40.0);
-        // Every workspace, laid out in rects too short and too narrow for its minimums.
-        let ctx = egui::Context::default();
-        let t = Tokens::for_kind(crate::theme::ThemeKind::Dark);
-        for w in WORKSPACES {
-            for (wd, ht) in [(30.0, 30.0), (800.0, 36.0), (800.0, 45.0), (36.0, 600.0), (1.0, 1.0), (0.0, 0.0)] {
-                let mut node = workspace(w);
-                let mut frame = ctx.run_ui(egui::RawInput::default(), |ui| {
-                    let mut out = vec![];
-                    let mut reg = crate::automation::Registry::default();
-                    layout(ui, &mut node, Rect::from_min_size(pos2(0.0, 0.0), vec2(wd, ht)), &t, "", &mut out, &mut reg);
-                    assert!(!out.is_empty(), "{w}");
-                });
-                frame.textures_delta.clear();
-            }
-        }
-    }
-
-    #[test]
-    fn drop_zone_math() {
-        let r = Rect::from_min_size(pos2(100.0, 100.0), vec2(400.0, 300.0));
-        let tab = 28.0;
-        assert_eq!(drop_zone(r, tab, pos2(300.0, 110.0)), Zone::Center, "tab strip");
-        assert_eq!(drop_zone(r, tab, r.center()), Zone::Center);
-        assert_eq!(drop_zone(r, tab, pos2(120.0, 250.0)), Zone::Left);
-        assert_eq!(drop_zone(r, tab, pos2(490.0, 250.0)), Zone::Right);
-        assert_eq!(drop_zone(r, tab, pos2(300.0, 140.0)), Zone::Top);
-        assert_eq!(drop_zone(r, tab, pos2(300.0, 390.0)), Zone::Bottom);
-        // Corners go to the nearer edge.
-        assert_eq!(drop_zone(r, tab, pos2(105.0, 395.0)), Zone::Left);
-        assert_eq!(zone_rect(r, Zone::Right), Rect::from_min_max(pos2(300.0, 100.0), r.max));
-        assert_eq!(zone_rect(r, Zone::Top).height(), 150.0);
-        assert_eq!(zone_rect(r, Zone::Center), r);
-    }
-
-    #[test]
-    fn dock_panel_splits_and_inserts_tabs() {
-        use PanelKind::*;
-        let mut d = workspace("Standard");
-        let n = d.panel_count();
-        // Tab next to an anchor.
-        assert!(d.dock_panel(Info, Timeline, Zone::Center));
-        assert_eq!(d.panel_count(), n);
-        let p = d.path_of(Timeline).unwrap();
-        assert_eq!(d.path_of(Info).unwrap(), p);
-        assert!(d.is_visible(Info));
-        // Split to the right of the Composition group: a new single-tab group beside it.
-        assert!(d.dock_panel(Info, Composition, Zone::Right));
-        let comp_path = d.path_of(Composition).unwrap();
-        let info_path = d.path_of(Info).unwrap();
-        assert_eq!(comp_path.len(), info_path.len());
-        assert!(comp_path.ends_with('a') && info_path.ends_with('b'));
-        assert!(d.is_visible(Info));
-        // Top: the new group comes first in a vertical split.
-        assert!(d.dock_panel(Audio, Timeline, Zone::Top));
-        assert!(d.path_of(Audio).unwrap().ends_with('a'));
-        // Dropping a panel on itself or an undocked anchor changes nothing.
-        let before = d.clone();
-        assert!(!d.dock_panel(Audio, Audio, Zone::Left));
-        assert!(!d.dock_panel(Audio, Tracker, Zone::Left));
-        assert_eq!(d, before);
-        // Into a stack: a tab of the anchor's frame (#302).
-        let mut s = workspace("Default");
-        let props = s.path_of(Properties).unwrap();
-        assert!(s.dock_panel(Tracker, Properties, Zone::Center));
-        assert_eq!(s.path_of(Tracker), Some(props.clone()));
-        assert!(s.is_visible(Tracker) && !s.is_visible(Properties));
-        assert!(s.activate(Properties) && s.is_visible(Properties));
-        // Top / Bottom: a frame of its own above / below the anchor's, not a split column.
-        assert!(s.dock_panel(Info, Properties, Zone::Bottom));
-        let below = s.path_of(Info).unwrap();
-        assert_ne!(below, props);
-        assert_eq!(s.path_of(Properties), Some(props.clone()));
-        assert!(s.dock_panel(Info, Properties, Zone::Top));
-        assert_eq!(s.path_of(Info), Some(props.clone()), "above Properties: its frame's index");
-        // Closing a tab keeps the frame; closing the frame's last tab removes it.
-        s.close(Tracker);
-        assert!(s.contains(Properties) && !s.contains(Tracker));
-        // A tab dragged onto a stacked frame's tab strip joins that frame.
-        let mut t = workspace("Default");
-        assert!(t.insert_tab(Info, Preview, None));
-        assert_eq!(t.path_of(Info), t.path_of(Preview));
-        // Moving the only panel of a group collapses its split.
-        let mut m = hsplit(SplitSize::Ratio(0.5), tabs(&[Project], 0), tabs(&[Composition], 0));
-        assert!(m.dock_panel(Project, Composition, Zone::Center));
-        assert_eq!(m, tabs(&[Composition, Project], 1));
-    }
-
-    /// #302: workspaces saved when each stacked frame held one `panel` still load.
-    #[test]
-    fn old_stack_entries_load() {
-        let e: StackEntry = serde_json::from_str(r#"{"panel":"Preview","open":true,"height":46.0}"#).unwrap();
-        assert_eq!(e, StackEntry::new(PanelKind::Preview, true, Some(46.0)));
-        let s = serde_json::to_string(&workspace("Default")).unwrap();
-        assert_eq!(serde_json::from_str::<DockNode>(&s).unwrap(), workspace("Default"));
-    }
-
-    #[test]
-    fn floating_layout_round_trips() {
-        use PanelKind::*;
-        let mut l = Layout { root: workspace("Standard"), floating: vec![] };
-        assert!(l.float(Info, [200.0, 150.0, 320.0, 240.0]));
-        assert!(!l.root.contains(Info) && l.contains(Info));
-        // Tab another panel into the floating group, then dock it back.
-        assert!(l.dock(Audio, Info, Zone::Center));
-        assert_eq!(l.floating[0].panels, [Info, Audio]);
-        assert!(!l.dock(Audio, Info, Zone::Left), "floating groups only take tabs");
-        assert!(l.dock(Info, Timeline, Zone::Bottom));
-        assert_eq!(l.floating[0].panels, [Audio]);
-        assert!(l.root.contains(Info));
-        let s = serde_json::to_string(&l).unwrap();
-        let back: Layout = serde_json::from_str(&s).unwrap();
-        assert_eq!(back, l);
-        // A workspace saved before floating panels existed still loads.
-        let old: Layout = serde_json::from_str(&format!("{{\"root\": {}}}", serde_json::to_string(&l.root).unwrap())).unwrap();
-        assert!(old.floating.is_empty());
-        // The last docked panel can't float.
-        let mut one = Layout { root: tabs(&[Timeline], 0), floating: vec![] };
-        assert!(!one.float(Timeline, [0.0; 4]));
-        assert!(l.unfloat(Audio) && l.floating.is_empty());
-    }
-
-    #[test]
-    fn close_and_open() {
-        let mut d = workspace("Default");
-        d.close(PanelKind::Paragraph);
-        assert!(!d.contains(PanelKind::Paragraph));
-        d.open_near(PanelKind::Tracker, PanelKind::EffectsPresets);
-        assert!(d.is_visible(PanelKind::Tracker));
-        let s = serde_json::to_string(&d).unwrap();
-        let back: DockNode = serde_json::from_str(&s).unwrap();
-        assert_eq!(back, d);
-        assert_eq!(PanelKind::from_name("effects & presets"), Some(PanelKind::EffectsPresets));
-    }
-
-    /// Ported from #630 (Ni-zav): the reporter's reproduction on the Minimal workspace.
-    #[test]
-    fn window_panels_reopen_after_last_panel_is_closed() {
-        use PanelKind::*;
-        for reopen in [Composition, Timeline, Project] {
-            let mut d = workspace("Minimal");
-            d.close(Composition);
-            d.close(Timeline);
-            assert_eq!(d.panel_count(), 0);
-            d.open_near(reopen, EffectsPresets);
-            assert_eq!(d.panel_count(), 1);
-            assert!(d.is_visible(reopen), "{reopen:?} must be visible");
-        }
-        let mut d = tabs(&[Audio], 0);
-        d.open_near(History, Project);
-        assert_eq!(d, tabs(&[Audio, History], 1));
-        let mut d = workspace("Minimal");
-        d.open_near(EffectsPresets, Timeline);
-        assert_eq!(d.path_of(EffectsPresets), d.path_of(Timeline));
-    }
-
-    #[test]
-    fn closing_earlier_inactive_tab_keeps_the_shown_panel() {
-        use PanelKind::*;
-        let mut d = tabs(&[Properties, Align, EffectsPresets], 1);
-        d.close(Properties);
-        assert!(d.is_visible(Align), "closing an inactive tab keeps the shown panel");
-        assert!(!d.is_visible(EffectsPresets));
-        assert_eq!(d.panel_count(), 2);
-    }
-
-    #[test]
-    fn closing_active_tab_keeps_existing_neighbor_choice() {
-        use PanelKind::*;
-        for (active, closed, shown) in [(0, Properties, Align), (1, Align, EffectsPresets), (2, EffectsPresets, Align)] {
-            let mut d = tabs(&[Properties, Align, EffectsPresets], active);
-            d.close(closed);
-            assert!(d.is_visible(shown), "active {active}: {closed:?} -> {shown:?}");
-        }
-    }
-
-    #[test]
-    fn close_normalizes_invalid_active_and_collapses_empty_splits() {
-        use PanelKind::*;
-        let mut d = tabs(&[Properties, Align, EffectsPresets], usize::MAX);
-        d.close(History);
-        assert!(d.is_visible(EffectsPresets));
-        d.close(Properties);
-        assert!(d.is_visible(EffectsPresets));
-        d.close(EffectsPresets);
-        assert!(d.is_visible(Align));
-        d.close(Align);
-        assert_eq!(d, tabs(&[], 0));
-        let mut d = DockNode::Split { vertical: true, size: SplitSize::Ratio(0.5), a: Box::new(tabs(&[Properties], 0)), b: Box::new(tabs(&[Align], 0)) };
-        d.close(Properties);
-        assert_eq!(d, tabs(&[Align], 0));
-        d.close(Align);
-        assert_eq!(d, tabs(&[], 0));
-    }
-
-    #[test]
-    fn removing_earlier_inactive_floating_tab_keeps_the_shown_panel() {
-        use PanelKind::*;
-        let mut layout = Layout {
-            root: tabs(&[Composition], 0),
-            floating: vec![Floating { panels: vec![Properties, Align, EffectsPresets], active: 1, rect: [0.0, 0.0, 300.0, 200.0] }],
+    fn default_right_column_is_a_short_preview_frame_over_the_properties_frame() {
+        let default = workspace("Default");
+        let Some(Node::Split { second, size: SplitSize::FixedSecond(300.0), .. }) = &default.root else { panic!("{default:?}") };
+        let Node::Split { axis: SplitAxis::Vertical, size: SplitSize::FixedFirst(PREVIEW_FRAME), first, second } = second.as_ref() else {
+            panic!("{second:?}")
         };
-        assert!(layout.unfloat(Properties));
-        let f = &layout.floating[0];
-        assert_eq!(f.panels.get(f.active), Some(&Align));
-        assert!(layout.root.is_visible(Composition));
+        assert_eq!(**first, tabs(&[Preview], 0));
+        assert_eq!(**second, tabs(&[Properties, Align, Audio, EffectsPresets], 0));
+        let mut w = Workspace::new(default);
+        assert!(w.is_visible(Preview) && w.is_visible(Properties) && !w.is_visible(Align));
+        // The Properties frame takes tabs; the Preview frame stays a frame of its own.
+        apply(&mut w, Action::Move { panel: Project, anchor: Properties, placement: Placement::Tab { before: None } });
+        assert_eq!(w.group_of(Project), vec![Properties, Align, Audio, EffectsPresets, Project]);
+        assert_eq!(w.group_of(Preview), vec![Preview]);
     }
 
     #[test]
-    fn floating_removal_keeps_active_neighbor_and_handles_invalid_index() {
-        use PanelKind::*;
-        for (active, closed, shown) in
-            [(0, Properties, Align), (1, Align, EffectsPresets), (2, EffectsPresets, Align), (usize::MAX, Properties, EffectsPresets)]
-        {
-            let mut layout = Layout {
-                root: tabs(&[Composition], 0),
-                floating: vec![Floating { panels: vec![Properties, Align, EffectsPresets], active, rect: [0.0, 0.0, 300.0, 200.0] }],
-            };
-            assert!(layout.unfloat(closed));
-            let f = &layout.floating[0];
-            assert_eq!(f.panels.get(f.active), Some(&shown));
-            for p in [Properties, Align, EffectsPresets] {
-                layout.unfloat(p);
-            }
-            assert!(layout.floating.is_empty());
-            assert!(!layout.unfloat(History));
-        }
+    fn panels_split_off_and_join_tab_groups() {
+        let mut w = docked(hsplit(SplitSize::FixedFirst(300.0), tabs(&[Project, EffectControls], 0), tabs(&[Composition, Layer], 0)));
+        apply(&mut w, Action::Move { panel: EffectControls, anchor: Composition, placement: Placement::Split(Zone::Right) });
+        assert_eq!(w.group_of(EffectControls), vec![EffectControls]);
+        assert_eq!(w.group_of(Project), vec![Project]);
+        apply(&mut w, Action::Move { panel: EffectControls, anchor: Composition, placement: Placement::Tab { before: Some(Layer) } });
+        assert_eq!(w.group_of(Composition), vec![Composition, EffectControls, Layer]);
+        assert!(w.is_visible(EffectControls));
+        // A rejected move (onto itself, onto a closed panel) changes nothing.
+        let before = w.clone();
+        assert!(w.apply(Action::Move { panel: Project, anchor: Info, placement: Placement::Split(Zone::Left) }, permissions).is_err());
+        assert_eq!(w, before);
+    }
+
+    #[test]
+    fn closed_panels_reopen_where_they_were_docked_or_floating() {
+        let mut w = Workspace::new(workspace("Standard"));
+        apply(&mut w, Action::Close { panel: Info });
+        assert!(!w.is_open(Info));
+        w.set_visible(Info, true, None, permissions).unwrap();
+        assert_eq!(w.group_of(Info), vec![Info, Audio]);
+        apply(&mut w, Action::Float { panel: Audio, rect: [40.0, 50.0, 300.0, 200.0] });
+        apply(&mut w, Action::Close { panel: Audio });
+        w.set_visible(Audio, true, None, permissions).unwrap();
+        assert!(w.is_floating(Audio));
+        // Closing an earlier, inactive tab keeps the shown panel.
+        let mut w = docked(tabs(&[Properties, Align, EffectsPresets], 2));
+        apply(&mut w, Action::Close { panel: Properties });
+        assert!(w.is_visible(EffectsPresets));
+        // A panel never laid out opens beside its anchor.
+        apply(&mut w, Action::Open { panel: History, anchor: Some(Align) });
+        assert_eq!(w.group_of(History), vec![Align, EffectsPresets, History]);
+        assert_eq!(referenced_panels(&w).iter().filter(|p| **p == Properties).count(), 1, "the closed panel is still known");
     }
 }
diff --git a/crates/ui-egui/src/dock_shared.rs b/crates/ui-egui/src/dock_shared.rs
deleted file mode 100644
index 4f090e219..000000000
--- a/crates/ui-egui/src/dock_shared.rs
+++ /dev/null
@@ -1,312 +0,0 @@
-//! Convert the persisted workspace schema to shared docking transactions.
-
-use craft_ui::docking::{Action, Floating as SharedFloating, Layout as SharedLayout, Node, Placement, StackEntry as SharedStackEntry};
-use craft_ui::layout::{SplitAxis, SplitSize as SharedSplitSize};
-
-use crate::dock::{DockNode, Floating, Layout, PanelKind, SplitSize, StackEntry};
-
-const MAX_DEPTH: usize = 32;
-const MAX_NODES: usize = 4096;
-const MAX_PANELS: usize = 128;
-
-fn encode_node(node: &DockNode, depth: usize, count: &mut usize) -> Result<Node<PanelKind>, String> {
-    *count = count.saturating_add(1);
-    if depth > MAX_DEPTH || *count > MAX_NODES {
-        return Err("workspace dock tree exceeds supported limits".into());
-    }
-    Ok(match node {
-        DockNode::Tabs { panels, active } => {
-            if panels.len() > MAX_PANELS {
-                return Err("too many workspace tabs".into());
-            }
-            Node::Tabs { panels: panels.clone(), active: *active }
-        }
-        DockNode::Stack { entries } => {
-            if entries.len() > MAX_PANELS {
-                return Err("too many workspace stack entries".into());
-            }
-            if entries.iter().any(|entry| entry.panels.is_empty() || entry.active >= entry.panels.len() || entry.panels.len() > MAX_PANELS) {
-                return Err("invalid stacked tab selection".into());
-            }
-            Node::Stack {
-                entries: entries
-                    .iter()
-                    .flat_map(|entry| entry.panels.iter().map(move |panel| SharedStackEntry { panel: *panel, open: entry.open, height: entry.height }))
-                    .collect(),
-            }
-        }
-        DockNode::Split { vertical, size, a, b } => Node::Split {
-            axis: if *vertical { SplitAxis::Vertical } else { SplitAxis::Horizontal },
-            size: match *size {
-                SplitSize::Ratio(value) => SharedSplitSize::Ratio(value),
-                SplitSize::FixedA(value) => SharedSplitSize::FixedFirst(value),
-                SplitSize::FixedB(value) => SharedSplitSize::FixedSecond(value),
-            },
-            first: Box::new(encode_node(a, depth.saturating_add(1), count)?),
-            second: Box::new(encode_node(b, depth.saturating_add(1), count)?),
-        },
-    })
-}
-
-fn decode_node(node: Node<PanelKind>) -> DockNode {
-    match node {
-        Node::Tabs { panels, active } => DockNode::Tabs { panels, active },
-        Node::Stack { entries } => {
-            DockNode::Stack { entries: entries.into_iter().map(|entry| StackEntry::new(entry.panel, entry.open, entry.height)).collect() }
-        }
-        Node::Split { axis, size, first, second } => DockNode::Split {
-            vertical: axis == SplitAxis::Vertical,
-            size: match size {
-                SharedSplitSize::Ratio(value) => SplitSize::Ratio(value),
-                SharedSplitSize::FixedFirst(value) => SplitSize::FixedA(value),
-                SharedSplitSize::FixedSecond(value) => SplitSize::FixedB(value),
-            },
-            a: Box::new(decode_node(*first)),
-            b: Box::new(decode_node(*second)),
-        },
-    }
-}
-
-pub(crate) fn encode(root: &DockNode, floating: &[Floating]) -> Result<SharedLayout<PanelKind>, String> {
-    if floating.len() > MAX_PANELS || floating.iter().any(|group| group.panels.len() > MAX_PANELS) {
-        return Err("too many floating workspace panels".into());
-    }
-    let root = if matches!(root, DockNode::Tabs { panels, active: 0 } if panels.is_empty()) { None } else { Some(encode_node(root, 0, &mut 0)?) };
-    Ok(SharedLayout {
-        root,
-        floating: floating.iter().map(|group| SharedFloating { panels: group.panels.clone(), active: group.active, rect: group.rect }).collect(),
-    })
-}
-
-pub(crate) fn decode(layout: SharedLayout<PanelKind>) -> Layout {
-    Layout {
-        root: layout.root.map(decode_node).unwrap_or_else(|| DockNode::Tabs { panels: vec![], active: 0 }),
-        floating: layout.floating.into_iter().map(|group| Floating { panels: group.panels, active: group.active, rect: group.rect }).collect(),
-    }
-}
-
-/// Restore app-owned accordion tab frames after shared validation/transactions.
-/// The shared model represents individual stack panels; grouping stays in the persisted app schema.
-fn restore_frames(node: &mut DockNode, original: &DockNode) {
-    fn collect(node: &DockNode, out: &mut Vec<StackEntry>) {
-        match node {
-            DockNode::Split { a, b, .. } => {
-                collect(a, out);
-                collect(b, out);
-            }
-            DockNode::Stack { entries } => out.extend(entries.iter().cloned()),
-            DockNode::Tabs { .. } => {}
-        }
-    }
-    fn restore(node: &mut DockNode, frames: &[StackEntry]) {
-        match node {
-            DockNode::Split { a, b, .. } => {
-                restore(a, frames);
-                restore(b, frames);
-            }
-            DockNode::Stack { entries } => {
-                let mut result: Vec<StackEntry> = Vec::new();
-                for entry in std::mem::take(entries) {
-                    let Some(panel) = entry.shown() else { continue };
-                    let old = frames.iter().find(|frame| frame.contains(panel));
-                    if let Some(last) = result.last_mut()
-                        && old.is_some_and(|frame| last.panels.iter().all(|p| frame.contains(*p)))
-                    {
-                        last.panels.push(panel);
-                        if old.and_then(StackEntry::shown) == Some(panel) {
-                            last.active = last.panels.len().saturating_sub(1);
-                        }
-                    } else {
-                        result.push(entry);
-                    }
-                }
-                for entry in &mut result {
-                    if let Some(old) = frames.iter().find(|frame| entry.panels.iter().all(|panel| frame.contains(*panel))) {
-                        entry.active = old
-                            .shown()
-                            .and_then(|shown| entry.panels.iter().position(|panel| *panel == shown))
-                            .unwrap_or(old.active.min(entry.panels.len().saturating_sub(1)));
-                    }
-                }
-                *entries = result;
-            }
-            DockNode::Tabs { .. } => {}
-        }
-    }
-    let mut frames = Vec::new();
-    collect(original, &mut frames);
-    restore(node, &frames);
-}
-
-pub(crate) fn apply(layout: &mut Layout, action: Action<PanelKind>) -> Result<(), String> {
-    let mut shared = encode(&layout.root, &layout.floating)?;
-    // Validate the same shared command first. Native stack insertion then retains tabs inside
-    // their accordion frame, including the existing before/after insertion policy.
-    shared.apply(action.clone()).map_err(|error| error.to_string())?;
-    let mut proposed = decode(shared);
-    restore_frames(&mut proposed.root, &layout.root);
-    match action {
-        Action::Move { panel, anchor, placement } | Action::OpenAt { panel, anchor, placement } if layout.root.contains(anchor) => {
-            fn stacked(node: &DockNode, p: PanelKind) -> bool {
-                match node {
-                    DockNode::Split { a, b, .. } => stacked(a, p) || stacked(b, p),
-                    DockNode::Stack { entries } => entries.iter().any(|e| e.contains(p)),
-                    _ => false,
-                }
-            }
-            if stacked(&layout.root, anchor) {
-                let mut native = layout.clone();
-                native.unfloat(panel);
-                let applied = match placement {
-                    Placement::Tab { before } => native.root.insert_tab(panel, anchor, before),
-                    Placement::Split(zone) => native.root.dock_panel(
-                        panel,
-                        anchor,
-                        match zone {
-                            craft_ui::docking::Zone::Left => crate::dock::Zone::Left,
-                            craft_ui::docking::Zone::Right => crate::dock::Zone::Right,
-                            craft_ui::docking::Zone::Top => crate::dock::Zone::Top,
-                            craft_ui::docking::Zone::Bottom => crate::dock::Zone::Bottom,
-                            craft_ui::docking::Zone::Center => crate::dock::Zone::Center,
-                        },
-                    ),
-                };
-                if !applied {
-                    return Err("stacked panel move failed".into());
-                }
-                proposed = native;
-            }
-        }
-        Action::Activate { panel } => {
-            proposed.root.activate(panel);
-        }
-        Action::SetStackOpen { panel, open } => {
-            fn set(node: &mut DockNode, p: PanelKind, open: bool) {
-                match node {
-                    DockNode::Split { a, b, .. } => {
-                        set(a, p, open);
-                        set(b, p, open);
-                    }
-                    DockNode::Stack { entries } => {
-                        if let Some(e) = entries.iter_mut().find(|e| e.contains(p)) {
-                            e.open = open;
-                        }
-                    }
-                    _ => {}
-                }
-            }
-            set(&mut proposed.root, panel, open);
-        }
-        Action::ResizeStack { panel, height } => {
-            fn set(node: &mut DockNode, p: PanelKind, h: Option<f32>) {
-                match node {
-                    DockNode::Split { a, b, .. } => {
-                        set(a, p, h);
-                        set(b, p, h);
-                    }
-                    DockNode::Stack { entries } => {
-                        if let Some(e) = entries.iter_mut().find(|e| e.contains(p)) {
-                            e.height = h;
-                        }
-                    }
-                    _ => {}
-                }
-            }
-            set(&mut proposed.root, panel, height);
-        }
-        _ => {}
-    }
-    encode(&proposed.root, &proposed.floating)?.validate().map_err(|error| error.to_string())?;
-    *layout = proposed;
-    Ok(())
-}
-
-pub(crate) fn apply_tree(root: &mut DockNode, action: Action<PanelKind>) -> bool {
-    if !valid_tree(root) {
-        return false;
-    }
-    let mut layout = Layout { root: root.clone(), floating: vec![] };
-    if apply(&mut layout, action).is_err() {
-        return false;
-    }
-    *root = layout.root;
-    true
-}
-
-pub(crate) fn valid_tree(root: &DockNode) -> bool {
-    encode(root, &[]).is_ok_and(|shared| shared.validate().is_ok())
-}
-
-pub(crate) fn valid_for_close(root: &DockNode) -> bool {
-    fn normalize(node: &mut Node<PanelKind>) {
-        match node {
-            Node::Tabs { panels, active } => *active = (*active).min(panels.len().saturating_sub(1)),
-            Node::Split { first, second, .. } => {
-                normalize(first);
-                normalize(second);
-            }
-            Node::Stack { .. } => {}
-        }
-    }
-    let Ok(mut shared) = encode(root, &[]) else { return false };
-    if let Some(root) = &mut shared.root {
-        normalize(root);
-    }
-    shared.validate().is_ok()
-}
-
-pub(crate) fn unfloat(layout: &mut Layout, panel: PanelKind) -> bool {
-    let Ok(mut shared) = encode(&layout.root, &layout.floating) else { return false };
-    let mut found = false;
-    for group in &mut shared.floating {
-        if group.panels.contains(&panel) {
-            group.active = group.active.min(group.panels.len().saturating_sub(1));
-            found = true;
-        }
-    }
-    if !found || shared.apply(Action::Close { panel }).is_err() {
-        return false;
-    }
-    let mut proposed = decode(shared);
-    restore_frames(&mut proposed.root, &layout.root);
-    *layout = proposed;
-    true
-}
-
-#[cfg(test)]
-mod stacked_frame_tests {
-    use super::*;
-    use crate::dock::Zone;
-    #[test]
-    fn stacked_tabs_survive_shared_resize_activate_float_and_close() {
-        let mut root = crate::dock::workspace("Default");
-        assert!(root.dock_panel(PanelKind::Info, PanelKind::Properties, Zone::Center));
-        fn group(node: &DockNode) -> Option<&StackEntry> {
-            match node {
-                DockNode::Split { a, b, .. } => group(a).or_else(|| group(b)),
-                DockNode::Stack { entries } => entries.iter().find(|e| e.contains(PanelKind::Properties)),
-                _ => None,
-            }
-        }
-        let before = group(&root).unwrap().clone();
-        assert!(before.contains(PanelKind::Info));
-        let mut layout = Layout { root, floating: vec![] };
-        layout.apply(Action::ResizeSplit { path: vec![], size: SharedSplitSize::Ratio(0.6) }).unwrap();
-        assert_eq!(group(&layout.root).unwrap(), &before);
-        layout.apply(Action::Activate { panel: PanelKind::Properties }).unwrap();
-        assert_eq!(group(&layout.root).unwrap().shown(), Some(PanelKind::Properties));
-        let original_frame = group(&layout.root).unwrap().clone();
-        layout.apply(Action::OpenAt { panel: PanelKind::History, anchor: PanelKind::Properties, placement: Placement::Tab { before: None } }).unwrap();
-        let opened = group(&layout.root).unwrap();
-        assert!(opened.contains(PanelKind::History));
-        assert!(opened.contains(PanelKind::Info));
-        assert_eq!(opened.shown(), Some(PanelKind::History));
-        assert_eq!(opened.height, original_frame.height);
-        layout.apply(Action::Close { panel: PanelKind::History }).unwrap();
-        layout.apply(Action::Float { panel: PanelKind::Info, rect: [20.0, 20.0, 300.0, 300.0] }).unwrap();
-        assert_eq!(group(&layout.root).unwrap().panels, vec![PanelKind::Properties]);
-        layout.apply(Action::Close { panel: PanelKind::Info }).unwrap();
-        assert!(layout.floating.is_empty());
-        assert_eq!(group(&layout.root).unwrap().panels, vec![PanelKind::Properties]);
-    }
-}
diff --git a/crates/ui-egui/src/dock_ui.rs b/crates/ui-egui/src/dock_ui.rs
index 559cb2191..6523ff757 100644
--- a/crates/ui-egui/src/dock_ui.rs
+++ b/crates/ui-egui/src/dock_ui.rs
@@ -1,25 +1,318 @@
-//! The dock area: lays out the docked tree (or the maximized panel), draws each group's chrome
-//! and body, floating (undocked) panel groups over it, and tab drag-and-drop: drag a tab onto a
-//! group to tab it there (center) or split it off to a side (After Effects' drop zones, with a
-//! highlight of where it will land); hold Cmd/Ctrl when releasing, or drop outside every group,
-//! to float it. `` ` `` maximizes the panel under the pointer. A floating group can also move
-//! out of the main window into its own native window ([`EffectcraftApp::set_panel_window`]),
-//! which can sit on another monitor.
+//! EffectCraft's panels in craft-ui's shared docking. craft-ui draws the frames, tab strips,
+//! stacked panels, floating windows, dividers and drop previews and owns the gestures (drag a tab
+//! onto a group to tab it there or split it off to a side; hold Cmd/Ctrl at the release, or drop
+//! outside every group, to float it). EffectCraft draws the panel bodies, the ≡ panel menu, the
+//! Timeline's comp tabs and the viewer locks in each group header, and runs every layout change
+//! through its command path (`window.dockAction`), so pointer, menu and control-channel changes
+//! share one route.
 
-use egui::{Color32, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
+use crate::state::UiState;
+use craft_ui::docking::{
+    Action, Divider, DockArea, DockCommand, DockContent, DockError, DockEvent, DockStyle, FloatSpace, Floating, Hit, Node, ResizeEdge, UiDock,
+};
+use egui::{Rect, Sense, Stroke, StrokeKind, pos2, vec2};
+use serde_json::{Value, json};
 
-use crate::dock::{self, DockAction, DockNode, Group, Layout, PanelKind, PanelWindow};
+use crate::dock::{self, DocAction, DocTab, PanelKind, Workspace, WorkspaceExt as _};
+use crate::icons::{self, Icon};
+use crate::theme::Tokens;
 use crate::{EffectcraftApp, panels};
-use craft_ui::docking::{Action, DropTarget, resolve_drop};
 
-fn drag_id() -> egui::Id {
-    egui::Id::unique("dock-tab-drag")
+/// The dock area's egui id; `DockArea::hit_rects` and `float_space` read by it.
+pub fn area_id() -> egui::Id {
+    egui::Id::unique("effectcraft-docking")
+}
+
+/// Width of the ≡ panel menu button at the end of each tab strip.
+const MENU_W: f32 = 26.0;
+/// Width of the viewer lock before it.
+const LOCK_W: f32 = 18.0;
+
+/// The smallest and largest native panel window, in points.
+pub const PANEL_WINDOW_MIN: [f32; 2] = [160.0, 100.0];
+pub const PANEL_WINDOW_MAX: f32 = 16_384.0;
+/// The farthest a native panel window may sit from the desktop origin, in points.
+pub const PANEL_WINDOW_MAX_POS: f32 = 100_000.0;
+
+/// A native panel window's desktop rect made safe to hand to the windowing system: finite, with
+/// a size within [`PANEL_WINDOW_MIN`]..=[`PANEL_WINDOW_MAX`] and a position within
+/// ±[`PANEL_WINDOW_MAX_POS`] (hostile workspace files and bad monitor reports included).
+pub fn sanitized_window_rect(rect: [f32; 4]) -> [f32; 4] {
+    let finite = |v: f32, fallback: f32| if v.is_finite() { v } else { fallback };
+    let [x, y, w, h] = rect;
+    [
+        finite(x, 0.0).clamp(-PANEL_WINDOW_MAX_POS, PANEL_WINDOW_MAX_POS),
+        finite(y, 0.0).clamp(-PANEL_WINDOW_MAX_POS, PANEL_WINDOW_MAX_POS),
+        finite(w, 420.0).clamp(PANEL_WINDOW_MIN[0], PANEL_WINDOW_MAX),
+        finite(h, 320.0).clamp(PANEL_WINDOW_MIN[1], PANEL_WINDOW_MAX),
+    ]
+}
+
+/// How long to wait for the main window to report its frame before migrated native windows
+/// keep their places as they are, in seconds.
+const FRAME_REPORT_WAIT: f64 = 2.0;
+
+/// Moves the native rects of [`UiState::native_outer`]'s windows from the OS window's outer
+/// position to its content position, by the main window's frame offset (`inner` less `outer`,
+/// the main window's desktop rects): the earlier version's windows had the same OS title bar.
+/// Without a report by [`FRAME_REPORT_WAIT`] (a backend without window positions), the places
+/// stay as they are.
+pub(crate) fn native_outer_to_content(ui: &mut UiState, outer: Option<Rect>, inner: Option<Rect>, now: f64) {
+    let offset = match (outer, inner) {
+        (Some(outer), Some(inner)) if outer.min.is_finite() && inner.min.is_finite() => inner.min - outer.min,
+        _ if now < FRAME_REPORT_WAIT => return,
+        _ => egui::Vec2::ZERO,
+    };
+    let ids = std::mem::take(&mut ui.native_outer);
+    for window in ui.dock.layout.floating.iter_mut().filter(|w| ids.contains(&w.id)) {
+        if let Some([x, y, w, h]) = window.native {
+            window.native = Some(sanitized_window_rect([x + offset.x, y + offset.y, w, h]));
+        }
+    }
+}
+
+/// A new floating group's default rect near the centre of `screen`.
+pub fn default_float_rect(screen: Rect) -> [f32; 4] {
+    let c = screen.center();
+    [c.x - 210.0, c.y - 160.0, 420.0, 320.0]
+}
+
+/// A panel named by its title or id ("Effect Controls", "EffectControls") or its serialized
+/// form (`{"Viewer": 2}`).
+fn panel_param(value: &Value) -> Result<PanelKind, String> {
+    match value.as_str() {
+        Some(name) => PanelKind::from_name(name).ok_or(format!("unknown panel `{name}`")),
+        None => serde_json::from_value::<PanelKind>(value.clone()).map_err(|_| "unknown `panel`".to_string()),
+    }
+}
+
+fn check_raw_action(action: &Action<PanelKind>) -> Result<(), String> {
+    if matches!(action, Action::Open { .. } | Action::OpenAt { .. }) {
+        return Err("use the panel open commands to preserve viewer and ScriptUI lifecycle callbacks".into());
+    }
+    Ok(())
+}
+
+/// The docking commands: `window.dockAction {action}`, craft-ui's `window.panel.*` commands,
+/// `ui.dock` and `ui.dock.reset`. `None` for any other id.
+pub(crate) fn route(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: &Value) -> Option<Result<Value, String>> {
+    match id {
+        "window.dockAction" => Some((|| {
+            let value = params.get("action").cloned().ok_or("missing docking action")?;
+            let action: Action<PanelKind> = serde_json::from_value(value).map_err(|error| format!("invalid docking action: {error}"))?;
+            check_raw_action(&action)?;
+            app.apply_dock(action)?;
+            Ok(Value::Null)
+        })()),
+        "ui.dock.reset" => {
+            let name = app.ui.workspace.clone();
+            app.set_workspace(&name);
+            Some(Ok(json!({"docking": app.ui.dock})))
+        }
+        "ui.dock" => Some((|| {
+            let mut tagged = if params.is_object() { params.clone() } else { json!({}) };
+            if let Some(fields) = tagged.as_object_mut() {
+                fields.insert("command".into(), json!("ui.dock"));
+            }
+            let command: DockCommand<PanelKind> = serde_json::from_value(tagged).map_err(|error| format!("invalid ui.dock params: {error}"))?;
+            app.run_dock_command(ctx, command)?;
+            Ok(json!({"docking": app.ui.dock}))
+        })()),
+        _ if id.starts_with("window.panel.") && DockCommand::<PanelKind>::IDS.contains(&id) => Some((|| {
+            let mut tagged = if params.is_object() { params.clone() } else { json!({}) };
+            if let Some(fields) = tagged.as_object_mut() {
+                fields.insert("command".into(), json!(id));
+                // EffectCraft's panel names ("Effect Controls") as well as craft-ui's ids.
+                for key in ["panel", "anchor", "before"] {
+                    if let Some(name) = fields.get(key).and_then(Value::as_str) {
+                        let panel = PanelKind::from_name(name).ok_or(format!("unknown panel `{name}`"))?;
+                        fields.insert(key.into(), json!(panel));
+                    }
+                }
+            }
+            let command: DockCommand<PanelKind> = serde_json::from_value(tagged).map_err(|error| format!("invalid docking command: {error}"))?;
+            app.run_dock_command(ctx, command)?;
+            Ok(Value::Null)
+        })()),
+        "window.panelWindow" => Some((|| {
+            let panel = panel_param(params.get("panel").ok_or("panelWindow: need `panel`")?).map_err(|e| format!("panelWindow: {e}"))?;
+            let window = match params.get("window") {
+                None | Some(Value::Null) => None,
+                Some(value) => Some(value.as_bool().ok_or("panelWindow: `window` must be true or false")?),
+            };
+            let window = app.set_panel_window(ctx, panel, window)?;
+            Ok(json!({"window": window}))
+        })()),
+        _ => None,
+    }
 }
 
 impl EffectcraftApp {
+    /// A layout action from the dock area or a menu, through the command path the control
+    /// channel uses.
     pub(crate) fn dock_command(&mut self, ctx: &egui::Context, action: Action<PanelKind>) -> Result<(), String> {
         let value = serde_json::to_value(action).map_err(|error| error.to_string())?;
-        crate::menus::invoke(self, ctx, "window.dockAction", serde_json::json!({"action": value})).map(|_| ())
+        crate::menus::invoke(self, ctx, "window.dockAction", json!({"action": value})).map(|_| ())
+    }
+
+    /// Run a craft-ui docking command on the current workspace, all or nothing. Named
+    /// workspaces and Reset are EffectCraft's own (`window.workspace`, `window.resetWorkspace`).
+    pub(crate) fn run_dock_command(&mut self, ctx: &egui::Context, command: DockCommand<PanelKind>) -> Result<(), String> {
+        if let DockCommand::Layout { action } | DockCommand::UiDock(UiDock::Action { action }) = &command {
+            check_raw_action(action)?;
+        }
+        if command.is_app_owned() {
+            if matches!(command, DockCommand::ResetWorkspace {}) {
+                let name = self.ui.workspace.clone();
+                self.set_workspace(&name);
+                return Ok(());
+            }
+            return Err("use the window.workspace commands for named workspaces".into());
+        }
+        // A closed panel opens through EffectCraft's own path, which puts it in its usual place
+        // and runs the viewer and ScriptUI lifecycles.
+        let shown = match &command {
+            DockCommand::Activate { panel } | DockCommand::UiDock(UiDock::Operation(craft_ui::docking::DockOperation::Open { panel })) => Some(*panel),
+            DockCommand::UiDock(UiDock::Operation(craft_ui::docking::DockOperation::Activate { panel })) => Some(*panel),
+            _ => None,
+        };
+        if let Some(panel) = shown.filter(|panel| !self.ui.dock.is_open(*panel)) {
+            self.show_panel(panel);
+            return Ok(());
+        }
+        let space = craft_ui::docking::float_space(ctx, area_id()).unwrap_or_else(|| FloatSpace::new(ctx.content_rect()));
+        match command.to_actions(&self.ui.dock, false, &space) {
+            Ok(actions) => self.apply_dock_all(actions),
+            // Showing a hidden panel at an edge, and Lock, change more than the layout.
+            Err(DockError::NotAllowed) => {
+                let mut workspace = self.ui.dock.clone();
+                let closed = command.apply(&mut workspace, false, &space, dock::permissions).map_err(|error| error.to_string())?;
+                self.commit_workspace(workspace, &closed, true);
+                Ok(())
+            }
+            Err(error) => Err(error.to_string()),
+        }
+    }
+
+    pub fn apply_dock(&mut self, action: Action<PanelKind>) -> Result<(), String> {
+        self.apply_dock_all(vec![action])
+    }
+
+    /// Apply `actions` all or none. No move or float may empty the docked tree, so a floating
+    /// panel always has somewhere to dock back to; closing the last docked panel stays allowed.
+    pub(crate) fn apply_dock_all(&mut self, actions: Vec<Action<PanelKind>>) -> Result<(), String> {
+        let mut workspace = self.ui.dock.clone();
+        let mut relocating = false;
+        let mut closed = Vec::new();
+        for action in actions {
+            relocating |= matches!(
+                &action,
+                Action::Move { .. }
+                    | Action::Float { .. }
+                    | Action::MoveGroup { .. }
+                    | Action::MoveWindow { .. }
+                    | Action::MovePanel { .. }
+                    | Action::MoveColumn { .. }
+            );
+            let closing = matches!(&action, Action::Close { .. } | Action::CloseGroup { .. } | Action::CloseWindow { .. } | Action::CloseOthers { .. });
+            let docked = workspace.layout.root.is_some();
+            closed.extend(workspace.apply(action, dock::permissions).map_err(|error| error.to_string())?);
+            if !closing && docked && workspace.layout.root.is_none() {
+                return Err("the last docked panel must remain in the workspace".into());
+            }
+        }
+        self.commit_workspace(workspace, &closed, relocating);
+        Ok(())
+    }
+
+    /// Take a changed workspace and release the state of the panels it closed: a ScriptUI
+    /// panel's script window closes (its onClose runs), a viewer forgets its comp.
+    fn commit_workspace(&mut self, workspace: Workspace, closed: &[PanelKind], relocating: bool) {
+        self.ui.dock = workspace;
+        for &p in closed {
+            if let PanelKind::ScriptPanel(id) = p
+                && self.session.script_ui.window(id).is_some()
+                && let Err(e) = self.session.execute("scriptui.close", json!({"window": id}))
+            {
+                self.ui.status = e.to_string();
+            }
+            panels::viewers::on_close(self, p);
+        }
+        if relocating || self.ui.maximized.is_some_and(|m| !self.ui.dock.is_docked(m)) {
+            self.ui.maximized = None;
+        }
+    }
+
+    /// Close a panel wherever it is (docked or floating). A rejected close changes nothing.
+    pub fn close_panel(&mut self, p: PanelKind) {
+        if self.ui.dock.is_open(p) {
+            let _ = self.apply_dock(Action::Close { panel: p });
+        }
+    }
+
+    /// Toggle the maximized panel (`p`, or none). Only a docked frame maximizes.
+    pub fn toggle_maximize(&mut self, p: PanelKind) {
+        self.ui.maximized = if self.ui.maximized == Some(p) || !self.ui.dock.is_docked(p) { None } else { Some(p) };
+    }
+
+    /// The panel whose body is under `pos` (from the last frame), else the focused one.
+    pub fn panel_at(&self, pos: Option<egui::Pos2>) -> PanelKind {
+        pos.and_then(|p| self.dock_rects.iter().rev().find(|(_, r)| r.contains(p)).map(|(k, _)| *k)).unwrap_or(self.ui.focused)
+    }
+
+    /// Whether panel `p` is in a floating window with a desktop place: its own OS window on
+    /// desktop (craft-ui `native-windows`); on the web and in embedded viewports the window
+    /// stays in the page and the place is kept for a desktop session.
+    pub fn in_panel_window(&self, p: PanelKind) -> bool {
+        self.ui.dock.layout.floating.iter().any(|w| w.contains(&p) && w.native.is_some())
+    }
+
+    /// Move panel `p` into a floating window of its own, which on desktop is an OS window that
+    /// can go on another monitor, or back into the main window (`window` false), where it joins
+    /// the first docked group. `None` toggles. A docked panel is undocked first, and its window
+    /// opens over the panel's place in the main window. Returns whether `p` is now in a window
+    /// of its own.
+    pub fn set_panel_window(&mut self, ctx: &egui::Context, p: PanelKind, window: Option<bool>) -> Result<bool, String> {
+        let current = self.in_panel_window(p);
+        let window = window.unwrap_or(!current);
+        if window == current {
+            return Ok(current);
+        }
+        if !window {
+            // On desktop every floating window is an OS window, so the way back is docking.
+            let anchor = self.ui.dock.layout.root.as_ref().and_then(|root| {
+                let mut panels = Vec::new();
+                dock::node_panels(root, &mut panels);
+                panels.into_iter().find(|panel| *panel != p)
+            });
+            let actions = match anchor {
+                Some(anchor) => vec![Action::Move { panel: p, anchor, placement: craft_ui::docking::Placement::Tab { before: None } }],
+                // Nothing is docked: the panel becomes the docked layout.
+                None => vec![Action::Close { panel: p }, Action::Open { panel: p, anchor: None }],
+            };
+            let mut workspace = self.ui.dock.clone();
+            // One transaction, so the panel is never reported closed and keeps its state.
+            let closed = workspace.apply_all(actions, dock::permissions).map_err(|_| format!("can't dock {}", p.title()))?;
+            self.commit_workspace(workspace, &closed, true);
+            return Ok(false);
+        }
+        if !self.ui.dock.is_floating(p) {
+            if !self.ui.dock.is_docked(p) {
+                return Err(format!("{} is not open", p.title()));
+            }
+            let rect = default_float_rect(ctx.input_for(egui::ViewportId::ROOT, |i| i.content_rect()));
+            self.apply_dock(Action::Float { panel: p, rect }).map_err(|_| format!("can't undock {}", p.title()))?;
+        }
+        let Some([x, y, w, h]) = self.ui.dock.layout.floating.iter().find(|f| f.contains(&p)).map(|f| f.rect) else {
+            return Err(format!("can't undock {}", p.title()));
+        };
+        let origin = ctx.input_for(egui::ViewportId::ROOT, |i| i.viewport().inner_rect.map(|r| r.min)).unwrap_or(pos2(0.0, 0.0));
+        let rect = sanitized_window_rect([origin.x + x, origin.y + y, w, h]);
+        self.apply_dock(Action::SetNative { panel: p, rect: Some(rect) })?;
+        if self.ui.maximized == Some(p) {
+            self.ui.maximized = None;
+        }
+        Ok(true)
     }
 
     /// Tab labels that name what the panel shows, as After Effects does: "Composition Intro",
@@ -48,119 +341,47 @@ impl EffectcraftApp {
     }
 
     /// A comp's label colour as a tab swatch (faint without a label).
-    fn comp_swatch(&self, cid: effectcraft_engine::project::ItemId) -> Color32 {
+    fn comp_swatch(&self, cid: effectcraft_engine::project::ItemId) -> egui::Color32 {
         match self.session.project.item(cid).map(|i| i.label) {
             Some(l) if l != effectcraft_engine::color::Label::None => self.tokens.label(l),
             _ => self.tokens.text_faint,
         }
     }
 
-    /// The Timeline's tabs: one per open comp, as in After Effects (opening a precomp adds a tab
-    /// next to its parent's instead of replacing it).
-    fn tab_docs(&self) -> Vec<(PanelKind, Vec<dock::DocTab>)> {
+    /// The Timeline's comp tabs: one per open comp, as in After Effects (opening a precomp adds a
+    /// tab next to its parent's instead of replacing it).
+    fn tab_docs(&self) -> Vec<DocTab> {
         let st = &self.session.state;
-        let locked = self.ui.locked_tabs.contains(&PanelKind::Timeline.id());
-        let docs = st
-            .open_comps
+        st.open_comps
             .iter()
             .filter_map(|id| {
                 let it = self.session.project.item(*id).filter(|i| i.as_comp().is_some())?;
-                let deco = dock::TabDeco { swatch: self.comp_swatch(*id), locked, viewer: true };
-                Some(dock::DocTab { id: id.0, title: it.name.clone(), deco: Some(deco), active: st.active_comp == Some(*id) })
+                Some(DocTab { id: id.0, title: it.name.clone(), swatch: self.comp_swatch(*id), active: st.active_comp == Some(*id) })
             })
-            .collect();
-        vec![(PanelKind::Timeline, docs)]
+            .collect()
     }
 
-    /// The Composition and Timeline tabs' close button, label-colour swatch and viewer lock.
-    fn tab_decos(&self) -> Vec<(PanelKind, dock::TabDeco)> {
-        let Some(cid) = self.session.active_comp_id() else { return vec![] };
-        let swatch = self.comp_swatch(cid);
-        let mut v: Vec<(PanelKind, dock::TabDeco)> =
-            vec![(PanelKind::Timeline, dock::TabDeco { swatch, locked: self.ui.locked_tabs.contains(&PanelKind::Timeline.id()), viewer: true })];
-        // Every Composition viewer: its comp's swatch and its own lock.
+    /// The label-colour swatch before a tab's name: each Composition viewer's comp, and Effect
+    /// Controls' (and with Use Label Color for Related Tabs, Properties') selected layer.
+    fn tab_swatches(&self) -> Vec<(PanelKind, egui::Color32)> {
+        let mut v = Vec::new();
         for id in std::iter::once(0).chain(self.ui.viewers.keys().copied().filter(|v| *v != 0)) {
-            let p = panels::viewers::panel(id);
             let swatch = panels::viewers::comp_of(self, id).map_or(self.tokens.text_faint, |c| self.comp_swatch(c));
-            v.push((p, dock::TabDeco { swatch, locked: self.ui.locked_tabs.contains(&p.id()), viewer: true }));
+            v.push((panels::viewers::panel(id), swatch));
         }
-        // Effect Controls carries the selected layer's label colour.
         if let Some(l) = self.session.active_comp().and_then(|c| self.session.state.selected_layers.first().and_then(|id| c.layer(*id)))
             && l.label != effectcraft_engine::color::Label::None
         {
-            v.push((PanelKind::EffectControls, dock::TabDeco { swatch: self.tokens.label(l.label), locked: false, viewer: false }));
+            v.push((PanelKind::EffectControls, self.tokens.label(l.label)));
+            if self.session.prefs.appearance.use_label_color_for_tabs {
+                v.push((PanelKind::Properties, self.tokens.label(l.label)));
+            }
         }
         v
     }
 
-    /// Settings ▸ Appearance ▸ Use Label Color for Related Tabs: the Composition and Timeline
-    /// tabs carry their comp's label colour, Effect Controls and Properties the layer's.
-    fn label_tab_marks(&self, ui: &egui::Ui) {
-        if !self.session.prefs.appearance.use_label_color_for_tabs {
-            return;
-        }
-        let Some(cid) = self.session.active_comp_id() else { return };
-        let comp_label = self.session.project.item(cid).map(|i| i.label);
-        let layer_label = self.session.active_comp().and_then(|c| self.session.state.selected_layers.first().and_then(|l| c.layer(*l))).map(|l| l.label);
-        // (the Composition, Timeline and Effect Controls tabs carry their swatch already)
-        let _ = comp_label;
-        for (p, label) in [(PanelKind::Properties, layer_label)] {
-            let (Some(label), Some(e)) = (label, self.auto.find(&format!("panel.tab.{}", p.id()))) else { continue };
-            if label == effectcraft_engine::color::Label::None {
-                continue;
-            }
-            let r = Rect::from_min_size(pos2(e.rect[0] + 2.0, e.rect[1] + 9.0), vec2(4.0, (e.rect[3] - 16.0).max(6.0)));
-            ui.painter().rect_filled(r, 1.0, self.tokens.label(label));
-        }
-    }
-
-    /// Edit the full layout (docked tree + floating groups) with a [`Layout`] operation.
-    pub fn edit_layout(&mut self, f: impl FnOnce(&mut Layout) -> bool) -> bool {
-        let Ok(shared) = crate::dock_shared::encode(&self.ui.dock, &self.ui.floating) else { return false };
-        if shared.validate().is_err() {
-            return false;
-        }
-        let mut l = Layout { root: self.ui.dock.clone(), floating: self.ui.floating.clone() };
-        if !f(&mut l) {
-            return false;
-        }
-        self.ui.dock = l.root;
-        self.ui.floating = l.floating;
-        if self.ui.maximized.is_some_and(|m| !self.ui.dock.contains(m)) {
-            self.ui.maximized = None;
-        }
-        true
-    }
-
-    /// Close a panel wherever it is (docked or floating).
-    pub fn close_panel(&mut self, p: PanelKind) {
-        // Commit the layout first: rejected closes must not release viewer or script state.
-        if !self.edit_layout(|layout| layout.apply(Action::Close { panel: p }).is_ok()) {
-            return;
-        }
-        // Closing a ScriptUI panel closes its script window (its script's onClose runs).
-        if let PanelKind::ScriptPanel(id) = p
-            && self.session.script_ui.window(id).is_some()
-            && let Err(e) = self.session.execute("scriptui.close", serde_json::json!({"window": id}))
-        {
-            self.ui.status = e.to_string();
-        }
-        panels::viewers::on_close(self, p);
-        if self.ui.maximized == Some(p) {
-            self.ui.maximized = None;
-        }
-    }
-
-    /// Toggle the maximized panel (`p`, or none).
-    pub fn toggle_maximize(&mut self, p: PanelKind) {
-        self.ui.maximized = if self.ui.maximized == Some(p) || !self.ui.dock.contains(p) { None } else { Some(p) };
-    }
-
-    /// The docked panel whose group is under `pos` (from the last frame), else the focused one.
-    pub fn panel_at(&self, pos: Option<egui::Pos2>) -> PanelKind {
-        pos.and_then(|p| self.dock_rects.iter().rev().find(|(_, r)| r.contains(p)).map(|(k, _)| *k)).unwrap_or(self.ui.focused)
-    }
-
+    /// Draw panel `p`'s body in `rect`: register its automation region, put the Composition Navigator above an active
+    /// viewer when a nested-comp flow exists, then call the panel's `show` and (for a viewer) the sketch overlay.
     fn panel_body(&mut self, ui: &mut egui::Ui, p: PanelKind, rect: Rect) {
         self.auto.add(&format!("panel.{}", p.id()), rect, p.title());
         let mut content = rect.shrink(1.0);
@@ -183,54 +404,34 @@ impl EffectcraftApp {
         }
     }
 
-    /// Apply one action after the panel bodies have drawn. A panel-window pass runs this at
-    /// its own pass end so the final IME descriptor sees the post-action state.
-    fn handle_dock_action(&mut self, ctx: &egui::Context, action: DockAction) {
-        match action {
-            DockAction::Activate(p) => {
-                let _ = self.dock_command(ctx, Action::Activate { panel: p });
-            }
-            DockAction::ToggleStacked(p) => {
-                let _ = self.dock_command(ctx, Action::SetStackOpen { panel: p, open: !self.ui.dock.is_visible(p) });
-            }
-            DockAction::Focus(p) => {
-                self.ui.focused = p;
-                panels::viewer_text::panel_clicked(self, ctx, p);
-                // A click in (or on the tab of) another Composition viewer makes it active.
-                if let Some(id) = panels::viewers::id_of(p) {
-                    panels::viewers::activate(self, ctx, id);
-                }
-            }
-            DockAction::Close(p) => {
-                let _ = self.dock_command(ctx, Action::Close { panel: p });
-            }
-            DockAction::PanelMenu(p, pos) => {
-                ctx.data_mut(|d| d.insert_temp(egui::Id::unique("panel-menu"), (p, pos)));
-            }
-            DockAction::BeginDrag(p) => ctx.data_mut(|d| {
-                d.insert_temp(drag_id(), p);
-            }),
-            DockAction::ToggleLock(p) => {
-                if !self.ui.locked_tabs.remove(&p.id()) {
-                    self.ui.locked_tabs.insert(p.id().to_string());
-                }
-            }
-            // The Timeline's comp tabs: show that comp / close its Timeline.
-            DockAction::ActivateDoc(p, id) => {
-                let _ = self.dock_command(ctx, Action::Activate { panel: p });
-                if self.session.state.active_comp.map(|c| c.0) != Some(id) {
-                    let _ = crate::menus::invoke(self, ctx, "comp.open", serde_json::json!({"comp": id}));
-                }
-            }
-            DockAction::CloseDoc(_, id) => {
-                let _ = crate::menus::invoke(self, ctx, "comp.close", serde_json::json!({"comp": id}));
-            }
+    /// A press in a panel (its body, tab or group header) focuses it; another Composition viewer
+    /// also becomes the active one.
+    pub(crate) fn focus_panel(&mut self, ctx: &egui::Context, p: PanelKind) {
+        self.ui.focused = p;
+        panels::viewer_text::panel_clicked(self, ctx, p);
+        if let Some(id) = panels::viewers::id_of(p) {
+            panels::viewers::activate(self, ctx, id);
         }
     }
 
+    /// Whether floating panels' OS windows take no input: a dialog of the app's own or a
+    /// command's OS file dialog is up. egui's `Modal` blocks only the window it is in.
+    pub(crate) fn floats_blocked(&mut self, ctx: &egui::Context) -> bool {
+        let (focused, now) = ctx.input(|i| (i.focused || i.raw.viewports.values().any(|v| v.focused == Some(true)), i.time));
+        let file_dialog = self.file_dialogs.up(focused, now);
+        self.dialog.is_some() || panels::dialogs::modal_open(ctx) || file_dialog
+    }
+
+    /// Draw the Home screen or workspace in `body`. Shared craft-ui docking owns the dock tree,
+    /// group chrome, tab dragging and floating native windows; this adapter draws panel bodies,
+    /// applies the returned events/actions and shows the panel menu.
     pub(crate) fn dock_area(&mut self, ui: &mut egui::Ui, body: Rect) {
         let t = self.tokens;
         let ctx = ui.ctx().clone();
+        if !self.ui.native_outer.is_empty() {
+            let (outer, inner, now) = ctx.input_for(egui::ViewportId::ROOT, |i| (i.viewport().outer_rect, i.viewport().inner_rect, i.time));
+            native_outer_to_content(&mut self.ui, outer, inner, now);
+        }
         if self.ui.start_screen {
             // Home covers the whole workspace, as in After Effects (the panels wait behind it).
             let mut child = ui.new_child(egui::UiBuilder::new().max_rect(body).id_salt("home"));
@@ -238,443 +439,492 @@ impl EffectcraftApp {
             panels::home::show(self, &mut child, body);
             return;
         }
-        // The maximized panel fills the area; the tree is kept as it is.
-        let maximized = self.ui.maximized.filter(|m| self.ui.dock.contains(*m));
-        let mut dock = match maximized {
-            Some(m) => DockNode::Tabs { panels: vec![m], active: 0 },
-            None => std::mem::replace(&mut self.ui.dock, DockNode::Tabs { panels: vec![], active: 0 }),
-        };
-        let mut groups = Vec::new();
-        let mut layout_actions = Vec::new();
-        dock::layout_with_actions(ui, &mut dock, body, &t, "", &mut groups, &mut self.auto, &mut layout_actions);
-        let mut actions = Vec::new();
-        let titles = self.tab_titles();
-        let decos = self.tab_decos();
+        let style = dock_style(ui, &t);
+        let maximized = self.ui.maximized.filter(|m| self.ui.dock.is_docked(*m));
+        let mut area = DockArea::new(area_id()).float_bounds(body).maximized(maximized).locked(self.ui.dock.locked).input_blocked(self.floats_blocked(&ctx));
+        if let Some(panel) = self.pending_panel_raise.take() {
+            area = area.raise_panel(panel);
+        }
+        let layout = self.ui.dock.layout.clone();
+        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(body).id_salt("effectcraft-dock-area"));
+        child.set_clip_rect(body.intersect(ui.clip_rect()));
         let docs = self.tab_docs();
-        let title = |p: PanelKind| {
-            titles.iter().find(|(k, _)| *k == p).map(|(_, s)| s.clone()).unwrap_or_else(|| crate::i18n::command_label("window.panel", p.title()).to_string())
+        let ime = NativeIme::new(&layout.floating, &self.unpublished_viewports);
+        let mut content = EffectContent {
+            titles: self.tab_titles(),
+            swatches: self.tab_swatches(),
+            docs,
+            ctx: ctx.clone(),
+            style: style.clone(),
+            app: self,
+            tokens: t,
+            doc_actions: Vec::new(),
+            locks: Vec::new(),
+            menu: None,
+            bodies: Vec::new(),
+            ime,
         };
-        let info = dock::TabInfo { title: &title, decos: &decos, docs: &docs };
-        // Where each group's tabs are (tab drags show where a tab will land between them).
-        let mut tab_rects: Vec<(String, Vec<(PanelKind, Rect)>)> = vec![];
-        for g in &groups {
-            let c = dock::draw_group_chrome(ui, g, &t, &mut self.auto, &info);
-            actions.extend(c.actions);
-            tab_rects.push((g.path.clone(), c.tabs));
-        }
-        self.label_tab_marks(ui);
-        if maximized.is_none() {
-            self.ui.dock = dock;
-        }
-        self.dock_rects = groups.iter().filter_map(|g| Some((*g.panels.get(g.active)?, g.rect))).collect();
-        for g in &groups {
-            let Some(p) = g.panels.get(g.active).copied() else { continue };
-            if g.content.height() < 2.0 {
-                continue; // a collapsed stacked panel: header only
-            }
-            self.panel_body(ui, p, g.content);
-        }
-        for g in &groups {
-            if g.panels.get(g.active) == Some(&self.ui.focused) {
-                ui.painter().rect_stroke(g.rect, 0.0, Stroke::new(1.0, t.focus), StrokeKind::Inside);
-            }
-        }
-        // Floating groups over the dock.
-        let mut float_groups: Vec<Group> = vec![];
-        let layers = ctx.memory(|memory| memory.layer_ids().collect::<Vec<_>>());
-        let mut floating_order: Vec<_> = (0..self.ui.floating.len()).collect();
-        floating_order.sort_by_key(|index| {
-            self.ui
-                .floating
-                .get(*index)
-                .and_then(|group| group.panels.first())
-                .and_then(|panel| {
-                    let id = egui::Id::unique(("floating-panel", panel.id()));
-                    layers.iter().position(|layer| layer.id == id)
-                })
-                .unwrap_or(usize::MAX)
-        });
-        // A native window is kept only for a panel that still floats. A native viewport that
-        // goes away releases its IME context: its composition must not reappear elsewhere.
-        let ui_state = &mut self.ui;
-        let gone: Vec<egui::ViewportId> = ui_state
-            .panel_windows
-            .iter()
-            .filter(|w| !ui_state.floating.iter().any(|group| group.panels.contains(&w.panel)))
-            .map(|w| panel_window_id(w.panel))
-            .collect();
-        ui_state.panel_windows.retain(|w| ui_state.floating.iter().any(|group| group.panels.contains(&w.panel)));
+        let mut output = area.show_content(&mut child, &layout, &style, &mut content);
+        let EffectContent { doc_actions, locks, menu, bodies, ime, .. } = content;
+        self.dock_rects = bodies;
+        self.unpublished_viewports = ime.unpublished();
+        // A window that closed or docked takes its composition with it.
+        let previous = std::mem::replace(&mut self.native_viewports, ime.begun());
+        let gone: Vec<_> = previous.into_iter().filter(|v| !self.native_viewports.contains(v)).collect();
         for viewport in gone {
             panels::viewer_text::end_viewport(self, &ctx, viewport);
         }
-        for i in floating_order {
-            // Groups in their own native window take no tab drops from the main window.
-            if let Some(window) = self.ui.floating.get(i).and_then(|group| self.panel_window_of(&group.panels)) {
-                self.panel_window(&ctx, i, window, &info);
-                continue;
-            }
-            if let Some((g, tabs)) = self.floating_window(&ctx, i, &info, &mut actions) {
-                tab_rects.push((g.path.clone(), tabs));
-                float_groups.push(g);
+        self.forward_window_input(&ctx, std::mem::take(&mut output.forwarded_events), std::mem::take(&mut output.window_files));
+        if let Some(panel) = output.focused {
+            self.focus_panel(&ctx, panel);
+        }
+        if let Some(error) = output.error {
+            self.ui.status = error.to_string();
+        }
+        for event in output.events {
+            if let DockEvent::ToggleMaximize { panel } = event {
+                self.toggle_maximize(panel);
             }
         }
-        for action in layout_actions {
-            let _ = self.dock_command(&ctx, action);
+        for action in output.actions {
+            if let Err(error) = self.dock_command(&ctx, action) {
+                self.ui.status = error;
+            }
         }
-        for a in actions {
-            self.handle_dock_action(&ctx, a);
+        for p in locks {
+            if !self.ui.locked_tabs.remove(&p.id()) {
+                self.ui.locked_tabs.insert(p.id().to_string());
+            }
         }
-        self.tab_drag(&ctx, &groups, &float_groups, &tab_rects);
+        for action in doc_actions {
+            let result = match action {
+                // The Timeline's comp tabs: show that comp / close its Timeline.
+                DocAction::Activate(id) => {
+                    let _ = self.apply_dock(Action::Activate { panel: PanelKind::Timeline });
+                    self.focus_panel(&ctx, PanelKind::Timeline);
+                    if self.session.state.active_comp.map(|c| c.0) == Some(id) {
+                        Ok(Value::Null)
+                    } else {
+                        crate::menus::invoke(self, &ctx, "comp.open", json!({"comp": id}))
+                    }
+                }
+                DocAction::Close(id) => crate::menus::invoke(self, &ctx, "comp.close", json!({"comp": id})),
+            };
+            if let Err(error) = result {
+                self.ui.status = error;
+            }
+        }
+        if let Some(open) = menu {
+            ctx.data_mut(|d| d.insert_temp::<panels::OpenPanelMenu>(egui::Id::unique("panel-menu"), open));
+            // the owner window draws it on its next pass
+            ctx.request_repaint();
+        }
+        drop_menu_of_closed_window(&ctx, &self.native_viewports);
+        let hits = DockArea::<PanelKind>::hit_rects(&ctx, area_id());
+        self.register_dock_hits(&hits);
         panels::panel_menu_popup(self, ui);
     }
 
-    /// One floating group: a window with a tab strip (drag the empty strip to move it, the
-    /// corner to resize it) and the active panel's body.
-    fn floating_window(
-        &mut self,
-        ctx: &egui::Context,
-        i: usize,
-        info: &dock::TabInfo,
-        actions: &mut Vec<DockAction>,
-    ) -> Option<(Group, Vec<(PanelKind, Rect)>)> {
-        let t = self.tokens;
-        let f = self.ui.floating.get(i)?.clone();
-        let screen = ctx.content_rect();
-        let mut rect = Rect::from_min_size(pos2(f.rect[0], f.rect[1]), vec2(f.rect[2].max(160.0), f.rect[3].max(100.0)));
-        // Keep the strip reachable.
-        rect = rect.translate(vec2(
-            (screen.min.x - rect.min.x).max(0.0) + (screen.max.x - 40.0 - rect.min.x).min(0.0),
-            (screen.min.y - rect.min.y).max(0.0) + (screen.max.y - 30.0 - rect.min.y).min(0.0),
-        ));
-        let id = egui::Id::unique(("floating-panel", f.panels.first().map(|p| p.id()).unwrap_or_default()));
-        let mut group = None;
-        // Not constrained to the window: the group is drawn where its rect says (the clamp above
-        // keeps its strip reachable), so it follows the pointer past the window's edges.
-        egui::Area::new(id).order(egui::Order::Middle).fixed_pos(rect.min).constrain(false).interactable(true).show(ctx, |ui| {
-            let (r, _) = ui.allocate_exact_size(rect.size(), Sense::hover());
-            ui.painter().rect_filled(r.expand(1.0), t.radius, Color32::from_black_alpha(90));
-            let strip = Rect::from_min_size(r.min, vec2(r.width(), t.tab_h));
-            // Move by the strip (tabs, registered later, take precedence over it).
-            // (`id.with("move")` is the id of the `Area`'s own background widget.)
-            let mv = ui.interact(strip, id.with("strip"), Sense::drag());
-            self.auto.add(&format!("panel.float.{i}.move"), strip, "Move floating panel");
-            let mut nr = r;
-            if mv.dragged() {
-                nr = nr.translate(mv.drag_delta());
-            }
-            let g = Group {
-                path: format!("f{i}"),
-                rect: r,
-                content: Rect::from_min_max(pos2(r.min.x, r.min.y + t.tab_h), r.max),
-                panels: f.panels.clone(),
-                active: f.active.min(f.panels.len().saturating_sub(1)),
-                stacked: None,
+    /// Keys and dropped files that reach a floating panel's own OS window go to the main
+    /// window's next frame ([`crate::EffectcraftApp::raw_input_hook`]), so its shortcuts and
+    /// file import handle them. Text is not forwarded, and nothing is while a text field in
+    /// the main window has the keyboard.
+    fn forward_window_input(&mut self, ctx: &egui::Context, events: Vec<egui::Event>, files: Vec<craft_ui::docking::WindowFiles<PanelKind>>) {
+        let typing = ctx.egui_wants_keyboard_input();
+        let events = events.into_iter().filter(|event| !typing && !matches!(event, egui::Event::Text(_) | egui::Event::Ime(_)));
+        self.forwarded.events.extend(events);
+        if handed_over_to_the_timeline(files.iter().map(|window| (window.panel, !window.dropped.is_empty()))) {
+            self.forwarded.dropped_on_timeline = true;
+        }
+        self.forwarded.files.extend(files.into_iter().flat_map(|window| window.dropped));
+        if !self.forwarded.events.is_empty() || !self.forwarded.files.is_empty() {
+            ctx.request_repaint();
+        }
+    }
+
+    /// Automation ids for craft-ui's gesture sources: `panel.tab.<Panel>`, `panel.drag.<Panel>`
+    /// (the group's drag bar), `panel.border.<Panel>` (the top border above its tabs),
+    /// `panel.tabs.more.<Panel>`, `panel.header.<Panel>` (a stacked panel's open/close button),
+    /// `panel.float.<n>.move`, `.close`, `.resize` (bottom-right
+    /// corner) and `.resize.<Edge>`, `dock.gutter.<path>` (`a`/`b` per split level; a stack's gap
+    /// below entry `i` adds `s<i>`), `dock.corner.<outer>.<inner>` where two dividers meet, and
+    /// the same inside floating window `n` as `panel.float.<n>.gutter.…` and `.corner.…`.
+    fn register_dock_hits(&mut self, hits: &[(Hit<PanelKind>, Rect)]) {
+        let window = |panel: &PanelKind| self.ui.dock.layout.floating.iter().position(|window| window.contains(panel));
+        // Tabs are labelled as drawn: "Composition Intro", not "Composition".
+        let titles = self.tab_titles();
+        let title = |panel: &PanelKind| titles.iter().find(|(p, _)| p == panel).map_or_else(|| panel.title().to_string(), |(_, t)| t.clone());
+        let mut found = Vec::new();
+        for (hit, rect) in hits {
+            let entry = match hit {
+                Hit::Tab(panel) => (format!("panel.tab.{}", panel.id()), title(panel)),
+                Hit::DragBar(panel) => (format!("panel.drag.{}", panel.id()), "Move panel group".into()),
+                Hit::Border(panel) => (format!("panel.border.{}", panel.id()), "Move panel group".into()),
+                Hit::Overflow(panel) => (format!("panel.tabs.more.{}", panel.id()), "More tabs".into()),
+                Hit::StackToggle(panel) => (format!("panel.header.{}", panel.id()), title(panel)),
+                Hit::Title(panel) => match window(panel) {
+                    Some(index) => (format!("panel.float.{index}.move"), "Move floating panel".into()),
+                    None => continue,
+                },
+                Hit::Close(panel) => match window(panel) {
+                    Some(index) => (format!("panel.float.{index}.close"), "Close floating panel".into()),
+                    None => continue,
+                },
+                Hit::Resize(panel, edge) => match window(panel) {
+                    Some(index) if *edge == ResizeEdge::BottomRight => (format!("panel.float.{index}.resize"), "Resize floating panel".into()),
+                    Some(index) => (format!("panel.float.{index}.resize.{edge:?}"), "Resize floating panel".into()),
+                    None => continue,
+                },
+                Hit::Divider(Divider::Split(path)) => (format!("dock.gutter.{}", path_id(path)), "gutter".into()),
+                Hit::Divider(Divider::Stack(panel)) => match dock::stack_gutter_id(&self.ui.dock.layout, *panel) {
+                    Some(id) => (id, "gutter".into()),
+                    None => continue,
+                },
+                Hit::Divider(Divider::Intersection(outer, inner)) => (format!("dock.corner.{}.{}", path_id(outer), path_id(inner)), "gutter corner".into()),
+                Hit::Divider(Divider::WindowSplit(panel, path)) => match window(panel) {
+                    Some(index) => (format!("panel.float.{index}.gutter.{}", path_id(path)), "gutter".into()),
+                    None => continue,
+                },
+                Hit::Divider(Divider::WindowIntersection(panel, outer, inner)) => match window(panel) {
+                    Some(index) => (format!("panel.float.{index}.corner.{}.{}", path_id(outer), path_id(inner)), "gutter corner".into()),
+                    None => continue,
+                },
+                _ => continue,
             };
-            let c = dock::draw_group_chrome(ui, &g, &t, &mut self.auto, info);
-            actions.extend(c.actions);
-            if let Some(p) = g.panels.get(g.active).copied() {
-                self.panel_body(ui, p, g.content);
-            }
-            ui.painter().rect_stroke(r, t.radius, Stroke::new(1.0, t.field_border), StrokeKind::Outside);
-            if g.panels.get(g.active) == Some(&self.ui.focused) {
-                ui.painter().rect_stroke(r, t.radius, Stroke::new(1.0, t.focus), StrokeKind::Inside);
-            }
-            // Resize from the corner.
-            let grip = Rect::from_min_max(r.max - vec2(14.0, 14.0), r.max);
-            let rs = ui.interact(grip, id.with("resize"), Sense::click_and_drag());
-            rs.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Splitter, rs.enabled(), crate::i18n::tr("Resize floating panel")));
-            self.auto.add_response(&format!("panel.float.{i}.resize"), &rs, "Resize floating panel");
-            for k in 0..3 {
-                let o = 4.0 + k as f32 * 4.0;
-                ui.painter().line_segment([pos2(r.max.x - o, r.max.y - 2.0), pos2(r.max.x - 2.0, r.max.y - o)], Stroke::new(1.0, t.text_faint));
-            }
-            if rs.hovered() || rs.dragged() {
-                ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeNwSe);
-            }
-            let delta = floating_resize_delta(ui, &rs);
-            if rs.has_focus() {
-                ui.painter().rect_stroke(grip, 2.0, Stroke::new(1.5, t.focus), StrokeKind::Inside);
-            }
-            if delta != egui::Vec2::ZERO {
-                nr = Rect::from_min_size(nr.min, (nr.size() + delta).max(vec2(160.0, 100.0)));
-            }
-            if nr != r
-                && let Some(panel) = f.panels.first().copied()
-            {
-                let _ = self.dock_command(ctx, Action::MoveFloating { panel, rect: [nr.min.x, nr.min.y, nr.width(), nr.height()] });
-            }
-            group = Some((g, c.tabs));
-        });
-        group
-    }
-
-    /// The native window a floating group (its `panels`) shows in, if any.
-    pub(crate) fn panel_window_of(&self, panels: &[PanelKind]) -> Option<PanelWindow> {
-        self.ui.panel_windows.iter().find(|w| panels.contains(&w.panel)).copied()
-    }
-
-    /// Whether panel `p` shows in its own native window.
-    pub fn in_panel_window(&self, p: PanelKind) -> bool {
-        self.ui.floating.iter().any(|group| group.panels.contains(&p) && self.panel_window_of(&group.panels).is_some())
-    }
-
-    /// The viewport panel `p` is drawn in: its native window's, or the main window's (also when
-    /// the platform embeds viewports, as the browser build does).
-    pub(crate) fn panel_viewport(&self, ctx: &egui::Context, p: PanelKind) -> egui::ViewportId {
-        if ctx.embed_viewports() {
-            return egui::ViewportId::ROOT;
+            found.push((entry, *rect, DockArea::hit_id(area_id(), hit)));
         }
-        self.ui
-            .floating
+        // The widget id lets keyboard focus on a divider or grip map to its element.
+        for ((id, label), rect, widget) in found {
+            self.auto.add(&id, rect, &label);
+            if let Some(element) = self.auto.elements.last_mut() {
+                element.response_id = Some(widget);
+            }
+        }
+    }
+}
+
+/// A split path as `a`/`b` per level (first/second child).
+fn path_id(path: &[bool]) -> String {
+    path.iter().map(|second| if *second { 'b' } else { 'a' }).collect()
+}
+
+/// After Effects' window is all frames: drops on all four window edges, Ctrl/Cmd-drag undocks,
+/// a release over no target floats, and a floating window's title bar only moves it.
+fn dock_style(ui: &egui::Ui, t: &Tokens) -> DockStyle {
+    let mut style = DockStyle::from_ui(ui);
+    style.side_edge_zones = true;
+    style.new_dock_zones = false;
+    style.maximize_item = true;
+    style.close_others_item = true;
+    style.command_press_floats = true;
+    style.float_on_empty_drop = true;
+    style.title_bar_docks = false;
+    style.float_hint = true;
+    style.wheel_selects_tabs = true;
+    style.middle_click_closes_tabs = true;
+    style.float_label = "Undock Panel".into();
+    style.float_group_label = "Undock Frame".into();
+    style.close_group_label = "Close Frame".into();
+    style.tab_height = t.tab_h;
+    style.gap = t.gap;
+    style.background = t.panel_bg;
+    style.tab_background = t.panel_bg;
+    style.active_background = t.panel_bg;
+    style.floating_background = t.panel_bg;
+    style.text = t.tab_text_active;
+    style.inactive_text = t.tab_text;
+    style.accent = t.focus;
+    style.font = Tokens::ui(12.0);
+    style
+}
+
+/// Panels with a viewer lock: the Composition viewers and the Timeline keep their comp while
+/// locked.
+fn has_lock(panel: PanelKind) -> bool {
+    matches!(panel, PanelKind::Composition | PanelKind::Viewer(_) | PanelKind::Timeline)
+}
+
+/// EffectCraft's side of the dock area for one frame.
+struct EffectContent<'a> {
+    app: &'a mut EffectcraftApp,
+    tokens: Tokens,
+    titles: Vec<(PanelKind, String)>,
+    swatches: Vec<(PanelKind, egui::Color32)>,
+    docs: Vec<DocTab>,
+    /// Measures the comp tabs for their width in the tab row.
+    ctx: egui::Context,
+    style: DockStyle,
+    doc_actions: Vec<DocAction>,
+    /// Viewer locks clicked.
+    locks: Vec<PanelKind>,
+    /// The ≡ button clicked: its panel, where its menu opens and the viewport it was clicked in.
+    menu: Option<panels::OpenPanelMenu>,
+    /// Where each panel body was drawn, in drawing order (floating windows last).
+    bodies: Vec<(PanelKind, Rect)>,
+    /// Where each native window's IME descriptor is set up and published.
+    ime: NativeIme,
+}
+
+/// Which body of a native floating window publishes its IME descriptor.
+///
+/// Each OS window is an egui pass of its own. `viewer_text::finish_ime` publishes what the pass's
+/// text editor recorded, and with nothing recorded it clears the composition and the preedit. A
+/// window with another group before the Viewer that published after every body would clear the
+/// preedit before the Viewer drew, and the Viewer's publication would then be a new context that
+/// interrupts the composition, every pass. So a window publishes after the body in which its
+/// editor has recorded its geometry and after its last body.
+pub(crate) struct NativeIme {
+    /// The bodies each native window draws this pass, as its layout says.
+    expected: Vec<(egui::ViewportId, usize)>,
+    /// The bodies each native window has drawn so far, in the order the windows began.
+    drawn: Vec<(egui::ViewportId, usize)>,
+    /// Windows that drew their panel menu this pass.
+    menu_drawn: Vec<egui::ViewportId>,
+    /// Windows that published this pass.
+    published: Vec<egui::ViewportId>,
+}
+
+impl NativeIme {
+    /// `unpublished` are the windows that drew last pass but never published: the layout's count
+    /// was too high for them, so they publish after every body this pass.
+    pub(crate) fn new(floating: &[Floating<PanelKind>], unpublished: &[egui::ViewportId]) -> Self {
+        let expected = floating
             .iter()
-            .find(|group| group.panels.contains(&p))
-            .and_then(|group| self.panel_window_of(&group.panels))
-            .map_or(egui::ViewportId::ROOT, |w| panel_window_id(w.panel))
-    }
-
-    /// Move panel `p` (and the floating group it is in) into its own native window, which can be
-    /// placed on another monitor, or back into the main window (`window` false; it floats there
-    /// where it was before). `None` toggles. A docked panel is undocked first. The window opens
-    /// over the place the panel had in the main window. Returns whether `p` is now in a window.
-    pub fn set_panel_window(&mut self, ctx: &egui::Context, p: PanelKind, window: Option<bool>) -> Result<bool, String> {
-        let group_of = |app: &Self| app.ui.floating.iter().find(|group| group.panels.contains(&p)).map(|group| (group.panels.clone(), group.rect));
-        let current = self.in_panel_window(p);
-        let window = window.unwrap_or(!current);
-        if window == current {
-            return Ok(current);
-        }
-        if !window {
-            if let Some((panels, _)) = group_of(self) {
-                self.ui.panel_windows.retain(|w| !panels.contains(&w.panel));
-            }
-            return Ok(false);
-        }
-        if group_of(self).is_none() {
-            if !self.ui.dock.contains(p) {
-                return Err(format!("{} is not open", p.title()));
-            }
-            let rect = default_float_rect(ctx.input_for(egui::ViewportId::ROOT, |i| i.content_rect()));
-            if !self.edit_layout(|layout| layout.float(p, rect)) {
-                return Err(format!("can't undock {}", p.title()));
-            }
-        }
-        let Some((_, [x, y, w, h])) = group_of(self) else { return Err(format!("can't undock {}", p.title())) };
-        // Over the panel's place in the main window (its content's position on the desktop).
-        let origin = ctx.input_for(egui::ViewportId::ROOT, |i| i.viewport().inner_rect.map(|r| r.min)).unwrap_or(pos2(0.0, 0.0));
-        let rect = PanelWindow::sanitized([origin.x + x, origin.y + y, w, h]);
-        ctx.data_mut(|d| d.remove::<[f32; 4]>(panel_window_spawn_id(p)));
-        self.ui.panel_windows.push(PanelWindow { panel: p, rect });
-        if self.ui.maximized == Some(p) {
-            self.ui.maximized = None;
-        }
-        Ok(true)
-    }
-
-    /// One floating group in its own native window: the group's tab strip and active panel fill
-    /// the window. Closing the window brings the group back into the main window.
-    fn panel_window(&mut self, ctx: &egui::Context, i: usize, window: PanelWindow, info: &dock::TabInfo) {
-        let t = self.tokens;
-        let Some(f) = self.ui.floating.get(i).cloned() else { return };
-        let active = f.active.min(f.panels.len().saturating_sub(1));
-        let Some(shown) = f.panels.get(active).copied() else { return };
-        // The window opens at its saved place; after that the window system owns its position and
-        // size (handing them back every frame would fight the user dragging it).
-        let spawn_id = panel_window_spawn_id(window.panel);
-        let spawn = ctx.data_mut(|d| *d.get_temp_mut_or_insert_with(spawn_id, || PanelWindow::sanitized(window.rect)));
-        let builder = egui::ViewportBuilder::default()
-            .with_title((info.title)(shown))
-            .with_position([spawn[0], spawn[1]])
-            .with_inner_size([spawn[2], spawn[3]])
-            .with_min_inner_size(dock::PANEL_WINDOW_MIN);
-        let mut closed = false;
-        let mut placed = None;
-        let mut pass_viewport = None;
-        let mut actions = Vec::new();
-        ctx.show_viewport_immediate(panel_window_id(window.panel), builder, |ui, class| {
-            pass_viewport = Some(ui.ctx().viewport_id());
-            let native = matches!(class, egui::ViewportClass::Immediate | egui::ViewportClass::Deferred);
-            if native {
-                panels::viewer_text::begin_ui(ui.ctx());
-            }
-            egui::CentralPanel::default().frame(egui::Frame::NONE.fill(t.panel_bg)).show(ui, |ui| {
-                let r = ui.max_rect();
-                let g = Group {
-                    path: format!("w{i}"),
-                    rect: r,
-                    content: Rect::from_min_max(pos2(r.min.x, (r.min.y + t.tab_h).min(r.max.y)), r.max),
-                    panels: f.panels.clone(),
-                    active,
-                    stacked: None,
-                };
-                let c = dock::draw_group_chrome(ui, &g, &t, &mut self.auto, info);
-                // Tabs can't be dragged between native windows yet.
-                actions.extend(c.actions.into_iter().filter(|a| !matches!(a, DockAction::BeginDrag(_))));
-                self.panel_body(ui, shown, g.content);
-                if shown == self.ui.focused {
-                    ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.focus), StrokeKind::Inside);
-                }
-                if native {
-                    panels::panel_menu_popup(self, ui);
-                }
-            });
-            // Apply this window's panel/tab actions before publishing its IME descriptor: a
-            // click-away or close in the floating panel must own the pass's final output.
-            for action in actions.drain(..) {
-                self.handle_dock_action(ui.ctx(), action);
-            }
-            panels::viewer_text::finish_ime(self, ui);
-            // An embedded window (no native windows on this platform) reads the main window's
-            // input: its close request and place aren't this window's.
-            if native {
-                closed = ui.input(|i| i.viewport().close_requested());
-                placed = ui.input(|i| {
-                    let v = i.viewport();
-                    let inner = v.inner_rect?;
-                    let min = v.outer_rect.map_or(pos2(window.rect[0], window.rect[1]), |outer| outer.min);
-                    Some([min.x, min.y, inner.width(), inner.height()])
-                });
-            }
-        });
-        if closed {
-            self.ui.panel_windows.retain(|w| !f.panels.contains(&w.panel));
-            if let Some(viewport) = pass_viewport {
-                panels::viewer_text::end_viewport(self, ctx, viewport);
-            }
-            panels::viewer_text::end_viewport(self, ctx, panel_window_id(window.panel));
-            ctx.data_mut(|d| d.remove::<[f32; 4]>(spawn_id));
-            return;
-        }
-        // Remember where the window is, so the workspace reopens it there.
-        if let Some(rect) = placed.map(PanelWindow::sanitized)
-            && rect != window.rect
-            && let Some(w) = self.ui.panel_windows.iter_mut().find(|w| w.panel == window.panel)
-        {
-            w.rect = rect;
-        }
-    }
-
-    /// A tab being dragged. Over a tab strip (or the middle of a group) it shows where the tab
-    /// will land: an insertion mark between two tabs (a drop there reorders a group's own tabs
-    /// too); near a group's edge, the half it will split off. On release it lands there (or
-    /// floats with Cmd/Ctrl or outside every group).
-    fn tab_drag(&mut self, ctx: &egui::Context, groups: &[Group], floats: &[Group], tab_rects: &[(String, Vec<(PanelKind, Rect)>)]) {
-        let Some(p) = ctx.data(|d| d.get_temp::<PanelKind>(drag_id())) else { return };
-        let t = self.tokens;
-        let canceled =
-            ctx.input(|input| input.key_pressed(egui::Key::Escape) || !input.focused || (!input.pointer.primary_down() && !input.pointer.primary_released()));
-        if canceled || (!self.ui.dock.contains(p) && !self.ui.floating.iter().any(|group| group.panels.contains(&p))) {
-            ctx.data_mut(|data| data.remove::<PanelKind>(drag_id()));
-            return;
-        }
-        let Some(pos) = ctx.pointer_latest_pos() else { return };
-        // The shared resolver receives groups in paint order; a floating group occludes the dock.
-        let targets: Vec<_> = groups
-            .iter()
-            .map(|g| (g, false))
-            .chain(floats.iter().map(|g| (g, true)))
-            .filter_map(|(g, floating)| {
-                Some(DropTarget {
-                    anchor: *g.panels.get(g.active)?,
-                    rect: g.rect,
-                    tab_strip: Some(Rect::from_min_max(g.rect.min, pos2(g.rect.max.x, g.content.min.y))),
-                    tabs: {
-                        let mut tabs = tab_rects.iter().find(|(path, _)| *path == g.path).map(|(_, tabs)| tabs.clone()).unwrap_or_default();
-                        for panel in &g.panels {
-                            if !tabs.iter().any(|(candidate, _)| candidate == panel) {
-                                tabs.push((*panel, Rect::NOTHING));
-                            }
-                        }
-                        tabs
-                    },
-                    allow_splits: !floating,
-                    accepts_tabs: true,
-                })
+            .filter_map(|window| {
+                let viewport = window_viewport(window.id)?;
+                let count = if unpublished.contains(&viewport) { 0 } else { window_bodies(window) };
+                Some((viewport, count))
             })
             .collect();
-        let over_group = targets.iter().any(|target| target.rect.contains(pos));
-        let float_drop = ctx.input(|i| i.modifiers.command);
-        let plan = (!float_drop).then(|| resolve_drop(&p, pos, &targets)).flatten();
-        let painter = ctx.layer_painter(egui::LayerId::new(egui::Order::Foreground, egui::Id::unique("dock-drop")));
-        if let Some(proposal) = &plan {
-            let preview = proposal.preview.shrink(2.0);
-            painter.rect_filled(preview, t.radius, t.focus.gamma_multiply(0.18));
-            painter.rect_stroke(preview, t.radius, Stroke::new(2.0, t.focus), StrokeKind::Inside);
-            if let Some(mark) = proposal.insertion {
-                insertion_mark(&painter, mark.center().x, mark, t.focus);
+        Self { expected, drawn: Vec::new(), menu_drawn: Vec::new(), published: Vec::new() }
+    }
+
+    /// Count a body of `viewport` that starts drawing. True for the window's first body: its
+    /// pass sets up the IME before it.
+    pub(crate) fn begin_body(&mut self, viewport: egui::ViewportId) -> bool {
+        match self.drawn.iter_mut().find(|(v, _)| *v == viewport) {
+            Some((_, n)) => {
+                *n = n.saturating_add(1);
+                false
+            }
+            None => {
+                self.drawn.push((viewport, 1));
+                true
             }
         }
-        // Ghost of the dragged tab.
-        let g = painter.layout_no_wrap(crate::i18n::command_label("window.panel", p.title()).to_string(), crate::theme::Tokens::ui(12.0), Color32::WHITE);
-        let gr = Rect::from_min_size(pos + vec2(12.0, 10.0), g.size() + vec2(16.0, 8.0));
-        painter.rect_filled(gr, 4.0, t.focus.gamma_multiply(0.85));
-        painter.galley(gr.min + vec2(8.0, 4.0), g, Color32::WHITE);
-        ctx.set_cursor_icon(egui::CursorIcon::Grabbing);
-        ctx.request_repaint();
-        if ctx.input(|i| i.pointer.primary_released()) {
-            ctx.data_mut(|d| d.remove::<PanelKind>(drag_id()));
-            let ok = match plan {
-                Some(proposal) => self.dock_command(ctx, Action::Move { panel: p, anchor: proposal.anchor, placement: proposal.placement }).is_ok(),
-                None if float_drop || !over_group => {
-                    let r = [pos.x - 40.0, pos.y - 12.0, 420.0, 320.0];
-                    self.dock_command(ctx, Action::Float { panel: p, rect: r }).is_ok()
-                }
-                None => false,
-            };
-            if ok {
-                self.ui.focused = p;
-                self.show_panel(p);
+    }
+
+    /// Whether the body of `viewport` that just drew publishes the IME descriptor: once the
+    /// window's editor has `recorded` its geometry this pass, and after the window's last body.
+    /// A window the layout does not name publishes after every body.
+    pub(crate) fn publishes(&mut self, viewport: egui::ViewportId, recorded: bool) -> bool {
+        let drawn = self.drawn.iter().find(|(v, _)| *v == viewport).map_or(0, |(_, n)| *n);
+        let expected = self.expected.iter().find(|(v, _)| *v == viewport).map_or(0, |(_, n)| *n);
+        let publishes = recorded || drawn >= expected;
+        if publishes && !self.published.contains(&viewport) {
+            self.published.push(viewport);
+        }
+        publishes
+    }
+
+    /// Whether the body of `viewport` that just drew is the one that draws the window's panel
+    /// menu: after the window's last body, once per pass.
+    pub(crate) fn menu_turn(&mut self, viewport: egui::ViewportId) -> bool {
+        let drawn = self.drawn.iter().find(|(v, _)| *v == viewport).map_or(0, |(_, n)| *n);
+        let expected = self.expected.iter().find(|(v, _)| *v == viewport).map_or(0, |(_, n)| *n);
+        let turn = drawn >= expected && !self.menu_drawn.contains(&viewport);
+        if turn {
+            self.menu_drawn.push(viewport);
+        }
+        turn
+    }
+
+    /// The native windows whose pass began.
+    pub(crate) fn begun(&self) -> Vec<egui::ViewportId> {
+        self.drawn.iter().map(|(v, _)| *v).collect()
+    }
+
+    /// The native windows that drew bodies but did not publish.
+    pub(crate) fn unpublished(&self) -> Vec<egui::ViewportId> {
+        self.drawn.iter().map(|(v, _)| *v).filter(|v| !self.published.contains(v)).collect()
+    }
+}
+
+/// A panel menu left open by a panel window that has since closed has nowhere to draw: drop it.
+/// `windows` are the panel windows that drew this pass.
+pub(crate) fn drop_menu_of_closed_window(ctx: &egui::Context, windows: &[egui::ViewportId]) {
+    let id = egui::Id::unique("panel-menu");
+    ctx.data_mut(|d| {
+        if d.get_temp::<panels::OpenPanelMenu>(id).is_some_and(|(_, _, owner)| owner != egui::ViewportId::ROOT && !windows.contains(&owner)) {
+            d.remove::<panels::OpenPanelMenu>(id);
+        }
+    });
+}
+
+/// The OS window craft-ui opens for the floating window `id`.
+#[cfg(not(target_arch = "wasm32"))]
+fn window_viewport(id: u64) -> Option<egui::ViewportId> {
+    Some(DockArea::<PanelKind>::window_viewport(area_id(), id))
+}
+
+/// The web keeps floating windows in the page.
+#[cfg(target_arch = "wasm32")]
+fn window_viewport(_id: u64) -> Option<egui::ViewportId> {
+    None
+}
+
+/// The panel bodies craft-ui draws in a floating window: the active panel of each group and each
+/// open stack entry. A minimized window shows its bar only.
+fn window_bodies(window: &Floating<PanelKind>) -> usize {
+    if window.minimized {
+        return 0;
+    }
+    let mut count = 0usize;
+    let mut nodes = vec![&window.root];
+    while let Some(node) = nodes.pop() {
+        match node {
+            Node::Split { first, second, .. } => nodes.extend([&**first, &**second]),
+            Node::Tabs { panels, active } => count = count.saturating_add(usize::from(panels.get(*active).is_some())),
+            Node::Stack { entries } => count = count.saturating_add(entries.iter().filter(|e| e.open).count()),
+            _ => {}
+        }
+    }
+    count
+}
+
+impl EffectContent<'_> {
+    fn header_width(&self, active: PanelKind, strip_width: f32) -> f32 {
+        let lock = if has_lock(active) { LOCK_W } else { 0.0 };
+        (lock + MENU_W).min(strip_width * 2.0 / 3.0).max(MENU_W)
+    }
+
+    /// Whether the group of `panels` shows comp tabs: it holds the Timeline and comps are open.
+    fn has_doc_tabs(&self, panels: &[PanelKind]) -> bool {
+        panels.contains(&PanelKind::Timeline) && !self.docs.is_empty()
+    }
+}
+
+impl DockContent<PanelKind> for EffectContent<'_> {
+    fn body(&mut self, ui: &mut egui::Ui, panel: &PanelKind) {
+        let t = self.tokens;
+        let rect = ui.max_rect();
+        self.bodies.push((*panel, rect));
+        // A floating panel's OS window is a pass of its own: its text IME descriptor is set up
+        // before its first body and published after its bodies (the main window does both in
+        // `draw`).
+        let viewport = ui.ctx().viewport_id();
+        let native = viewport != egui::ViewportId::ROOT && !ui.ctx().embed_viewports();
+        if native && self.ime.begin_body(viewport) {
+            panels::viewer_text::begin_ui(ui.ctx());
+        }
+        self.app.panel_body(ui, *panel, rect);
+        if native && self.ime.publishes(viewport, panels::viewer_text::ime_recorded(ui.ctx())) {
+            panels::viewer_text::finish_ime(self.app, ui);
+        }
+        // The ≡ menu of a panel in its own OS window is drawn by that window's pass, after its
+        // last body, at that window's coordinates.
+        if native && self.ime.menu_turn(viewport) {
+            panels::panel_menu_area(self.app, ui);
+        }
+        // The body fills its frame; allocating it lets a floated panel keep its full size.
+        ui.allocate_rect(rect, Sense::hover());
+        // Painted after the body so child backgrounds cannot hide the focus outline.
+        if self.app.ui.focused == *panel {
+            ui.painter().rect_stroke(rect, 0.0, Stroke::new(1.0, t.focus), StrokeKind::Inside);
+        }
+    }
+
+    fn logical_label(&self, panel: &PanelKind) -> String {
+        let title = panel.title();
+        // The Window menu names most panels; `Markers` is only in the panel catalog, and the two
+        // panels in neither (`History`, `ScriptUI Panel`) keep their English names.
+        let listed = crate::i18n::command_label("window.panel", title);
+        if listed == title { crate::i18n::tr(title).to_string() } else { listed.to_string() }
+    }
+
+    /// The tab names what the panel shows ("Composition Intro"), after the label swatch of its
+    /// comp or layer. With comps open, the Timeline's own tab is just "Timeline"; each comp has a
+    /// tab of its own after the group's panel tabs.
+    fn label(&mut self, _ui: &egui::Ui, panel: &PanelKind, logical: &str, font: &egui::FontId, color: egui::Color32) -> egui::WidgetText {
+        let title = self.titles.iter().find(|(p, _)| p == panel).map_or(logical, |(_, s)| s.as_str());
+        let Some((_, swatch)) = self.swatches.iter().find(|(p, _)| p == panel) else { return title.into() };
+        let mut job = egui::text::LayoutJob::default();
+        job.append("■ ", 0.0, egui::TextFormat::simple(font.clone(), *swatch));
+        job.append(title, 0.0, egui::TextFormat::simple(font.clone(), color));
+        job.into()
+    }
+
+    fn group_header_width(&self, _panels: &[PanelKind], active: &PanelKind, _floating: bool, strip_width: f32) -> f32 {
+        self.header_width(*active, strip_width)
+    }
+
+    /// The viewer lock and the ≡ panel menu of the shown panel.
+    fn group_header(&mut self, ui: &mut egui::Ui, _panels: &[PanelKind], active: &PanelKind, _floating: bool) {
+        let t = self.tokens;
+        let header = ui.max_rect();
+        let menu = Rect::from_min_max(pos2((header.max.x - MENU_W).max(header.min.x), header.min.y), header.max);
+        if has_lock(*active) {
+            let lock = Rect::from_center_size(pos2(menu.min.x - LOCK_W / 2.0, header.center().y), vec2(14.0, 14.0));
+            let locked = self.app.ui.locked_tabs.contains(&active.id());
+            if dock::lock_button(ui, lock, *active, locked, &t, &mut self.app.auto) {
+                self.locks.push(*active);
             }
         }
+        let rect = Rect::from_center_size(menu.center(), vec2(18.0, 18.0));
+        let response = ui.interact(rect, egui::Id::unique(("panel-menu-button", active.id())), Sense::click());
+        response.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, response.enabled(), "panel menu"));
+        self.app.auto.add_response(&format!("panel.menu.{}", active.id()), &response, "panel menu");
+        let color = if response.hovered() { t.tab_text_active } else { t.tab_text };
+        icons::paint(ui.painter(), Rect::from_center_size(rect.center(), vec2(16.0, 16.0)), Icon::Hamburger, color);
+        crate::widgets::focus_outline(ui, &response, &t);
+        if response.clicked() {
+            self.app.ui.focused = *active;
+            self.menu = Some((*active, rect.left_bottom(), ui.ctx().viewport_id()));
+        }
+    }
+
+    fn group_extra_tabs_width(&self, panels: &[PanelKind], _active: &PanelKind, _floating: bool) -> f32 {
+        if !self.has_doc_tabs(panels) {
+            return 0.0;
+        }
+        dock::doc_widths(&self.ctx, &self.docs, &self.style.font).iter().sum()
+    }
+
+    /// The Timeline's comp tabs, after its group's panel tabs whichever panel is shown.
+    fn group_extra_tabs(&mut self, ui: &mut egui::Ui, panels: &[PanelKind], active: &PanelKind, _floating: bool) {
+        if self.has_doc_tabs(panels) {
+            let selected = *active == PanelKind::Timeline;
+            self.doc_actions.extend(dock::doc_tabs(ui, ui.max_rect(), &self.docs, selected, &self.style, &mut self.app.auto));
+        }
     }
 }
 
-/// The insertion mark of a tab drag: a bar between two tabs at `x`, with caps.
-fn insertion_mark(painter: &egui::Painter, x: f32, strip: Rect, col: Color32) {
-    let (y0, y1) = (strip.min.y + 3.0, strip.max.y - 2.0);
-    painter.line_segment([pos2(x, y0), pos2(x, y1)], Stroke::new(2.5, col));
-    for (y, d) in [(y0, 1.0), (y1, -1.0)] {
-        painter.add(egui::Shape::convex_polygon(vec![pos2(x - 4.5, y), pos2(x + 4.5, y), pos2(x, y + 5.0 * d)], col, Stroke::NONE));
+/// Whether a handed-over *drop* named the Timeline. A floating window reports its hovered files
+/// too, so a drag that only passes over the Timeline window must not count: its flag would survive
+/// and send the next drop somewhere else. The panel comes from the window, which the main window's
+/// pointer can never reach (#2661).
+fn handed_over_to_the_timeline(drops: impl Iterator<Item = (PanelKind, bool)>) -> bool {
+    drops.into_iter().any(|(panel, has_files)| has_files && matches!(panel, PanelKind::Timeline))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// A drop handed over by a floating window says which panel it landed on; only the Timeline
+    /// turns it into a layer instead of a project item. A window that only saw the file hover over
+    /// it carries no files and must not count, or its flag would outlive the drag (#2661).
+    #[test]
+    fn only_a_timeline_drop_is_handed_over_to_the_timeline() {
+        let cases = [
+            (vec![(PanelKind::Timeline, true)], true),
+            (vec![(PanelKind::Project, true)], false),
+            (vec![(PanelKind::Timeline, false)], false),
+            (vec![(PanelKind::Project, true), (PanelKind::Timeline, true)], true),
+            (vec![], false),
+        ];
+        for (windows, want) in cases {
+            assert_eq!(handed_over_to_the_timeline(windows.into_iter()), want, "{want}");
+        }
     }
 }
-
-/// The native window of the floating group whose window entry names `panel`.
-pub fn panel_window_id(panel: PanelKind) -> egui::ViewportId {
-    egui::ViewportId::from_hash_of(("effectcraft-panel-window", panel.id()))
-}
-
-/// Where a native panel window was told to open (kept for as long as it stays open).
-fn panel_window_spawn_id(panel: PanelKind) -> egui::Id {
-    egui::Id::unique(("panel-window-spawn", panel.id()))
-}
-
-/// A new floating group's default rect near the centre of `screen`.
-pub fn default_float_rect(screen: Rect) -> [f32; 4] {
-    let c = screen.center();
-    [c.x - 210.0, c.y - 160.0, 420.0, 320.0]
-}
-
-/// A corner is a two-axis resize control; focused arrows belong to it and Tab moves on.
-fn floating_resize_delta(ui: &mut egui::Ui, response: &egui::Response) -> egui::Vec2 {
-    if response.drag_started() {
-        response.request_focus();
-    }
-    let mut delta = if response.dragged() { response.drag_delta() } else { egui::Vec2::ZERO };
-    if response.has_focus() {
-        ui.memory_mut(|memory| {
-            memory.set_focus_lock_filter(response.id, egui::EventFilter { horizontal_arrows: true, vertical_arrows: true, ..Default::default() })
-        });
-        ui.input_mut(|input| {
-            for (key, amount) in [
-                (egui::Key::ArrowLeft, vec2(-8.0, 0.0)),
-                (egui::Key::ArrowRight, vec2(8.0, 0.0)),
-                (egui::Key::ArrowUp, vec2(0.0, -8.0)),
-                (egui::Key::ArrowDown, vec2(0.0, 8.0)),
-            ] {
-                if input.consume_key(egui::Modifiers::NONE, key) {
-                    delta += amount;
-                }
-            }
-        });
-    }
-    if response.enabled() { delta } else { egui::Vec2::ZERO }
-}
diff --git a/crates/ui-egui/src/frames.rs b/crates/ui-egui/src/frames.rs
index ed00690ac..c79b023b2 100644
--- a/crates/ui-egui/src/frames.rs
+++ b/crates/ui-egui/src/frames.rs
@@ -1,7 +1,8 @@
 //! Background frame rendering and the RAM preview cache.
 //!
 //! Frames render on a dedicated thread pool from immutable `Arc<Project>` snapshots, so the UI
-//! never waits for the compositor. Results land in a memory-budgeted cache keyed by the comp's
+//! never waits for the compositor (a playing preview's frames and idle caching on one thread
+//! each, so the frames started first are done first). Results land in a memory-budgeted cache keyed by the comp's
 //! *content* ([`comp_content`]: the comp and everything it uses), frame, scale, view and render
 //! options; the timeline draws the cached range as the green cache bar. An edit keeps the frames
 //! of every comp it doesn't touch, and undo finds the frames of the state it returns to.
@@ -31,7 +32,7 @@ use effectcraft_engine::project::{Comp, ItemId, ItemKind, LayerSource, Node, Pro
 use effectcraft_engine::render::disk_cache::{self, DiskCache};
 use effectcraft_engine::render::{CancellableFootage, ExprHost, FootageSource, LayerCache, RenderOpts, Renderer};
 use effectcraft_engine::time::Tick;
-use effectcraft_gpu::{DisplayFrame, Gpu};
+use effectcraft_gpu::{DisplayFrame, FrameError, Gpu};
 use rayon::prelude::*;
 
 /// Comp identities (and the project snapshots behind them) the RAM preview keeps frames of.
@@ -317,23 +318,6 @@ pub fn comp_content(project: &Project, comp: ItemId) -> u64 {
     comp_content_with(project, comp, project, |_, c| c)
 }
 
-/// Whether two versions of a comp draw the same pixels. Markers only count when an expression
-/// could read them (`markers_count`).
-fn same_pixels(a: &Comp, b: &Comp, markers_count: bool) -> bool {
-    if markers_count { a.same_pixels(b) } else { a.same_pixels_ignoring_markers(b) }
-}
-
-/// Whether a layer anywhere in the project has an expression, which can read markers.
-fn project_has_expressions(project: &Project) -> bool {
-    fn has_expression(g: &PropGroup) -> bool {
-        g.children.iter().any(|c| match c {
-            Node::Prop(p) => p.expr.is_some(),
-            Node::Group(sub) => has_expression(sub),
-        })
-    }
-    project.items.values().any(|i| matches!(&i.kind, ItemKind::Comp(c) if c.layers.iter().any(|l| has_expression(&l.props))))
-}
-
 /// [`comp_content`] with each comp's version selected for both its sources and its address.
 /// Sources removed by undo are read from `base`.
 fn comp_content_with<'a>(project: &'a Project, comp: ItemId, base: &'a Project, version: impl Fn(ItemId, &'a Arc<Comp>) -> &'a Arc<Comp>) -> u64 {
@@ -473,6 +457,10 @@ pub struct Frames {
     #[cfg(not(target_arch = "wasm32"))]
     /// None if the OS refused the threads: jobs then go to rayon's global pool.
     pool: Option<rayon::ThreadPool>,
+    #[cfg(not(target_arch = "wasm32"))]
+    /// One thread each, for a playing preview's frames and idle caching (see [`Queue::idle_lanes`]). Empty if
+    /// the OS refused the threads: those frames then render on `pool` too.
+    lanes: Vec<rayon::ThreadPool>,
     ctx: Option<egui::Context>,
     /// Render time of the last viewer (urgent) frame in ms, for the Info panel / perf readout.
     pub last_ms: Arc<Mutex<f64>>,
@@ -501,10 +489,25 @@ impl Default for Frames {
     fn default() -> Self {
         #[cfg(not(target_arch = "wasm32"))]
         let threads = std::thread::available_parallelism().map(|n| n.get()).unwrap_or(4).clamp(2, 16);
+        #[cfg(not(target_arch = "wasm32"))]
+        let lanes: Vec<rayon::ThreadPool> = (0..threads)
+            .map_while(|i| {
+                rayon::ThreadPoolBuilder::new()
+                    .num_threads(1)
+                    .thread_name(move |_| format!("ec-preview-{i}"))
+                    .panic_handler(|_| log::error!("a frame render panicked; that frame was skipped"))
+                    .build()
+                    .ok()
+            })
+            .collect();
+        #[cfg(not(target_arch = "wasm32"))]
+        let queue = Queue { idle_lanes: (0..lanes.len()).collect(), lanes: lanes.len(), ..Default::default() };
+        #[cfg(target_arch = "wasm32")]
+        let queue = Queue::default();
         Frames {
             cache: Arc::new(Mutex::new(Cache { map: HashMap::new(), order: VecDeque::new(), bytes: 0, gpu_bytes: 0, budget: 3 << 30, gpu_budget: GPU_BUDGET, playhead: None, scale: None })),
             inflight: Arc::new(Mutex::new(HashSet::new())),
-            queue: Arc::new(Mutex::new(Queue::default())),
+            queue: Arc::new(Mutex::new(queue)),
             #[cfg(not(target_arch = "wasm32"))]
             // A panicking job would abort the whole process (rayon's default for `spawn`): log it
             // and lose only that frame (the panic hook has logged the message).
@@ -514,6 +517,8 @@ impl Default for Frames {
                 .panic_handler(|_| log::error!("a frame render panicked; that frame was skipped"))
                 .build()
                 .ok(),
+            #[cfg(not(target_arch = "wasm32"))]
+            lanes,
             ctx: None,
             last_ms: Arc::new(Mutex::new(0.0)),
             content_keys: Arc::default(),
@@ -534,18 +539,16 @@ impl Default for Frames {
 /// Premultiplied f32 → egui premultiplied Color32 (alpha kept, so the viewer can show the
 /// transparency grid or the comp background colour underneath).
 pub fn to_color_image(img: &effectcraft_engine::render::Image) -> egui::ColorImage {
-    let px: Vec<egui::Color32> = img
-        .data
-        .par_iter()
-        .map(|p| {
-            let a = p[3].clamp(0.0, 1.0);
-            let c = |v: f32| (v.clamp(0.0, a) * 255.0 + 0.5) as u8;
-            egui::Color32::from_rgba_premultiplied(c(p[0]), c(p[1]), c(p[2]), (a * 255.0 + 0.5) as u8)
-        })
-        .collect();
+    let px: Vec<egui::Color32> = img.data.par_iter().map(|p| display_pixel(*p)).collect();
     egui::ColorImage::new([img.width as usize, img.height as usize], px)
 }
 
+pub(crate) fn display_pixel(pixel: [f32; 4]) -> egui::Color32 {
+    let alpha = if pixel[3].is_nan() { 0.0 } else { pixel[3].clamp(0.0, 1.0) };
+    let component = |value: f32| (value.clamp(0.0, alpha) * 255.0 + 0.5) as u8;
+    egui::Color32::from_rgba_premultiplied(component(pixel[0]), component(pixel[1]), component(pixel[2]), (alpha * 255.0 + 0.5) as u8)
+}
+
 /// The whole factor an image of `size` is averaged down by for a texture: at least `min_k`, and
 /// the smallest that fits its sides in `max_side` (frames of comps wider than the GPU's texture
 /// limit, #201).
@@ -762,12 +765,12 @@ impl Frames {
     fn identity(&self, project: &Arc<Project>, comp: ItemId) -> Identity {
         let plain = comp_content(project, comp);
         let Ok(mut bases) = self.bases.lock() else { return (plain, None) };
-        // Markers can only change pixels through expressions, which read them.
-        let markers_count = project_has_expressions(project);
+        // Markers are pixels only to the expressions that read them (#1083).
+        let markers = project.reads_markers();
         if let Some((base_id, base)) = bases.get(&comp.0)
             && *base_id != plain
             && comp_content_with(project, comp, project, |id, c| match base.item(id).map(|i| &i.kind) {
-                Some(ItemKind::Comp(b)) if Arc::ptr_eq(b, c) || same_pixels(b, c, markers_count) => b,
+                Some(ItemKind::Comp(b)) if Arc::ptr_eq(b, c) || b.same_pixels_with(c, markers) => b,
                 _ => c,
             }) == *base_id
         {
@@ -779,7 +782,7 @@ impl Frames {
         if let Some((base_id, base)) = bases.get(&comp.0)
             && let (Some(old), Some(new)) = (base.comp(comp), project.comp(comp))
             && comp_content_with(project, comp, base, |id, c| match base.item(id).map(|i| &i.kind) {
-                Some(ItemKind::Comp(b)) if id == comp || Arc::ptr_eq(b, c) || same_pixels(b, c, markers_count) => b,
+                Some(ItemKind::Comp(b)) if id == comp || Arc::ptr_eq(b, c) || b.same_pixels_with(c, markers) => b,
                 _ => c,
             }) == *base_id
             && let Some((s, e)) = new.changed_span(old)
@@ -928,26 +931,77 @@ impl Frames {
             c.playhead = playhead;
         }
         let Ok(mut q) = self.queue.lock() else { return };
+        // A preview starting or stopping moves the queued prefetch frames between the lanes and
+        // the pool (see [`Queue::idle_lanes`]).
+        #[cfg(not(target_arch = "wasm32"))]
+        let moved = q.playhead.is_some() != playhead.is_some();
         q.playhead = playhead;
-        let Some(p) = playhead else { return };
-        let Ok(mut inf) = self.inflight.lock() else { return };
-        q.jobs.retain(|j| {
-            let gone = !j.urgent && j.key.same_series(&p.series) && p.ahead(&j.key).is_none();
-            if gone {
-                inf.remove(&j.key);
+        if let Some(p) = playhead
+            && let Ok(mut inf) = self.inflight.lock()
+        {
+            q.jobs.retain(|j| {
+                let gone = !j.urgent && j.key.same_series(&p.series) && p.ahead(&j.key).is_none();
+                if gone {
+                    inf.remove(&j.key);
+                }
+                !gone
+            });
+        }
+        #[cfg(not(target_arch = "wasm32"))]
+        if moved {
+            self.start_lanes(&mut q, usize::MAX);
+            let pool_jobs = q.jobs.iter().filter(|j| !q.on_lane(j)).count().min(self.parallelism());
+            drop(q);
+            for _ in 0..pool_jobs {
+                self.start_pool();
             }
-            !gone
-        });
+        }
+    }
+
+    /// Start up to `n` idle lanes on the queued jobs (see [`Queue::idle_lanes`]).
+    #[cfg(not(target_arch = "wasm32"))]
+    fn start_lanes(&self, q: &mut Queue, n: usize) {
+        if self.remote.is_some() {
+            return;
+        }
+        let jobs = q.jobs.iter().filter(|j| q.on_lane(j)).count();
+        for _ in 0..n.min(jobs) {
+            let Some(lane) = q.idle_lanes.pop() else { break };
+            let Some(pool) = self.lanes.get(lane) else { break };
+            let w = self.worker();
+            pool.spawn(move || w.drain(Some(lane)));
+        }
+    }
+
+    /// Have a pool thread render the queued jobs that are the pool's.
+    #[cfg(not(target_arch = "wasm32"))]
+    fn start_pool(&self) {
+        if self.remote.is_some() {
+            return;
+        }
+        let w = self.worker();
+        let job = move || w.drain(None);
+        match &self.pool {
+            Some(pool) => pool.spawn(job),
+            None => rayon::spawn(job),
+        }
     }
 
     /// Queue a prefetch frame (no-op if cached or already queued/rendering).
     pub fn request(&self, src: &RenderSource, key: FrameKey, comp: ItemId, t: Tick, opts: RenderOpts) {
-        self.request_with(src, key, comp, t, opts, false);
+        self.request_with(src, key, comp, t, opts, Want::Prefetch);
+    }
+
+    /// Queue a frame nobody waits for (Cache Frames When Idle): as [`Frames::request`], but it
+    /// renders on a lane, one thread, and leaves the pool to the viewer's frame (see
+    /// [`Queue::idle_lanes`]).
+    pub fn request_background(&self, src: &RenderSource, key: FrameKey, comp: ItemId, t: Tick, opts: RenderOpts) {
+        self.request_with(src, key, comp, t, opts, Want::Background);
     }
 
     /// Queue the frame the viewer is showing: it jumps ahead of every prefetch job.
     pub fn request_urgent(&self, src: &RenderSource, key: FrameKey, comp: ItemId, t: Tick, opts: RenderOpts) {
-        self.request_with(src, key, comp, t, opts, true);
+        self.request_with(src, key, comp, t, opts, Want::Viewer);
     }
 
     /// An urgent (viewer) frame is queued or rendering.
@@ -955,7 +1009,8 @@ impl Frames {
         self.queue.lock().map(|q| q.urgent_running > 0 || q.jobs.iter().any(|j| j.urgent)).unwrap_or(false)
     }
 
-    fn request_with(&self, src: &RenderSource, key: FrameKey, comp: ItemId, t: Tick, opts: RenderOpts, urgent: bool) {
+    fn request_with(&self, src: &RenderSource, key: FrameKey, comp: ItemId, t: Tick, opts: RenderOpts, want: Want) {
+        let urgent = want == Want::Viewer;
         // The frame on screen sets the scale evictions keep: a prefetch or a passive viewer at
         // another zoom must not evict the active viewer's frames.
         let cached = self
@@ -1007,22 +1062,32 @@ impl Frames {
             }
         }
         if !inf.insert(key) {
+            drop(inf);
+            drop(q);
+            // Queued for a lane and now the viewer's frame: it is the pool's.
+            #[cfg(not(target_arch = "wasm32"))]
+            if urgent {
+                self.start_pool();
+            }
             return;
         }
         q.seq += 1;
         let seq = q.seq;
-        q.jobs.push(Job { key, src: src.clone(), comp, t, opts, urgent, seq, cancel: Arc::default() });
+        let job = Job { key, src: src.clone(), comp, t, opts, urgent, background: want == Want::Background, seq, cancel: Arc::default() };
+        // A lane's frame: a busy lane takes the next job when it is done, an idle one starts now.
+        #[cfg(not(target_arch = "wasm32"))]
+        let on_lane = q.on_lane(&job);
+        q.jobs.push(job);
+        #[cfg(not(target_arch = "wasm32"))]
+        if on_lane {
+            self.start_lanes(&mut q, 1);
+        }
         drop(inf);
         drop(q);
+        // One spawn per job; each spawn renders whichever queued jobs matter most right now.
         #[cfg(not(target_arch = "wasm32"))]
-        if self.remote.is_none() {
-            let w = self.worker();
-            // One spawn per job; each spawn renders whichever queued jobs matter most right now.
-            let job = move || w.drain();
-            match &self.pool {
-                Some(pool) => pool.spawn(job),
-                None => rayon::spawn(job),
-            }
+        if !on_lane {
+            self.start_pool();
         }
         #[cfg(target_arch = "wasm32")]
         if let Some(ctx) = &self.ctx {
@@ -1164,7 +1229,7 @@ impl Frames {
         }
         let t0 = web_time::Instant::now();
         let w = self.worker();
-        while w.run_next() {
+        while w.run_next(None) {
             if t0.elapsed() >= budget {
                 break;
             }
@@ -1212,22 +1277,29 @@ impl Worker {
     /// every UI frame, so renders piled up on every thread until memory ran out (#647). A spawn
     /// that lands inside a render returns at once instead; the render below it takes the queued
     /// jobs when it is done, so each thread renders one frame at a time.
+    ///
+    /// `lane`: the lane this runs on (see [`Queue::idle_lanes`]), `None` on the pool.
     #[cfg(not(target_arch = "wasm32"))]
-    fn drain(&self) {
+    fn drain(&self, lane: Option<usize>) {
         if DRAINING.get() {
             return;
         }
         DRAINING.set(true);
         let _reset = Draining;
-        while self.run_next() {}
+        while self.run_next(lane) {}
     }
 
-    /// Render the queued job that matters most right now. `false` when the queue was empty.
-    fn run_next(&self) -> bool {
+    /// Render the queued job that matters most right now, on lane `lane` (`None`: on
+    /// the pool, or the UI thread). `false` when the queue had no job for it; the lane is then
+    /// idle again.
+    fn run_next(&self, lane: Option<usize>) -> bool {
         let Worker { queue, content_keys, .. } = self;
         let job = {
             let Ok(mut q) = queue.lock() else { return false };
-            let Some(i) = q.best() else { return false };
+            let Some(i) = q.next(lane.is_some()) else {
+                q.idle_lanes.extend(lane);
+                return false;
+            };
             let job = q.jobs.swap_remove(i);
             q.running.insert(job.key);
             if job.urgent {
@@ -1318,11 +1390,16 @@ impl Worker {
 
     /// A failed scoped attempt retries on CPU. Retired contexts cannot recover by reducing
     /// their budget; only a healthy device's allocation failure uses the upstream backoff.
-    fn gpu_attempt_failed(&self, gpu: &Gpu, e: &str) {
+    fn gpu_attempt_failed(&self, gpu: &Gpu, e: &FrameError) {
         if gpu.context().check_health().is_err() {
             log::warn!("the GPU context is retired ({e}); the frame renders on the CPU");
             return;
         }
+        // Not memory pressure: keeping fewer GPU frames wouldn't help (#1319).
+        if let FrameError::Validation(_) = e {
+            log::warn!("the GPU rejected the frame ({e}); it renders on the CPU, the next frame tries the GPU again");
+            return;
+        }
         log::warn!("the GPU ran out of memory ({e}); the frame renders on the CPU and fewer GPU frames are kept");
         if let Ok(mut c) = self.cache.lock() {
             c.gpu_out_of_memory();
@@ -1417,6 +1494,14 @@ impl Worker {
     }
 }
 
+/// Who asked for a frame (see [`Frames::request_with`]).
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Want {
+    Viewer,
+    Prefetch,
+    Background,
+}
+
 struct Job {
     key: FrameKey,
     src: RenderSource,
@@ -1424,6 +1509,8 @@ struct Job {
     t: Tick,
     opts: RenderOpts,
     urgent: bool,
+    /// Nobody waits for it (see [`Frames::request_background`]).
+    background: bool,
     seq: u64,
     /// Set when the viewer no longer waits for this frame (see [`Frames::request_urgent`]).
     cancel: Arc<AtomicBool>,
@@ -1446,18 +1533,45 @@ struct Queue {
     seq: u64,
     /// The playing preview, if any: its prefetch renders nearest first.
     playhead: Option<Playhead>,
+    /// How many lanes there are, and the ones not rendering. A lane is one thread that renders
+    /// one frame at a time. The frames of a playing preview and the frames nobody waits for
+    /// (Cache Frames When Idle) render on the lanes; the pool keeps the viewer's frame and the
+    /// few frames prefetched around it while paused. On the pool a frame's parallel work is
+    /// shared: a thread that took a piece of one frame and waited inside it started rendering
+    /// the queued frames on top, and went back to its piece only once the queue was empty. The
+    /// frames a preview started first, the ones right ahead of the playhead, were done last:
+    /// the preview stood still on a gap while the frames further ahead turned green. Idle
+    /// caching left the same gaps, and held up the viewer's frame when it shared a piece.
+    lanes: usize,
+    idle_lanes: Vec<usize>,
 }
 
 impl Queue {
+    /// Whether `j` renders on a lane (else on the pool).
+    fn on_lane(&self, j: &Job) -> bool {
+        self.lanes > 0 && !j.urgent && (j.background || self.playhead.is_some())
+    }
+
+    /// The job a lane (`lane`) or the pool renders next: the [`Queue::best`] of its own.
+    fn next(&self, lane: bool) -> Option<usize> {
+        self.best_of(|j| self.on_lane(j) == lane)
+    }
+
     /// The job that matters most: urgent first (newest), then, while a preview plays, the
     /// prefetch frame it reaches first, then prefetch in request order. In request order alone,
     /// frames asked for again after an eviction (the ones right ahead of the playhead) waited
     /// behind every frame further ahead (#595).
     fn best(&self) -> Option<usize> {
+        self.best_of(|_| true)
+    }
+
+    /// [`Queue::best`] among the jobs `of` accepts.
+    fn best_of(&self, of: impl Fn(&Job) -> bool) -> Option<usize> {
         let p = self.playhead.as_ref();
         self.jobs
             .iter()
             .enumerate()
+            .filter(|(_, j)| of(j))
             .max_by_key(|(_, j)| {
                 let near = if j.urgent { None } else { p.and_then(|p| p.ahead(&j.key)) };
                 (j.urgent, near.is_some(), near.map_or(0, |d| -d), if j.urgent { j.seq as i64 } else { -(j.seq as i64) })
@@ -1467,933 +1581,4 @@ impl Queue {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    struct ProbeDisk {
-        keys: Mutex<HashSet<u128>>,
-        probes: std::sync::atomic::AtomicUsize,
-    }
-
-    impl RemoteFrames for ProbeDisk {
-        fn slots(&self) -> usize {
-            0
-        }
-
-        fn disk(&self) -> bool {
-            true
-        }
-
-        fn disk_contains(&self, key: u128) -> bool {
-            self.probes.fetch_add(1, Ordering::Relaxed);
-            self.keys.lock().unwrap().contains(&key)
-        }
-
-        fn start(&self, _: RemoteJob, _: RemoteDone) {}
-    }
-
-    fn disk_fixture(stored_frames: &[i64]) -> (Frames, RenderSource, FrameKey, RenderOpts, Arc<ProbeDisk>, u128) {
-        let mut session = effectcraft_engine::Session::default();
-        session.execute("comp.new", serde_json::json!({"width": 32, "height": 18, "duration": 1})).unwrap();
-        let comp = session.active_comp_id().unwrap();
-        let opts = RenderOpts::default();
-        let content = 1234;
-        let mut base = key(1, 0, opts_hash(&opts));
-        base.revision = 7;
-        base.comp = comp.0;
-        let disk = Arc::new(ProbeDisk { keys: Mutex::new(HashSet::new()), probes: 0.into() });
-        disk.keys.lock().unwrap().extend(stored_frames.iter().map(|frame| disk_cache::frame_key(content, *frame, base.scale, base.view ^ opts_hash(&opts))));
-        let mut frames = Frames::default();
-        frames.set_remote(Some(disk.clone()));
-        frames.content_keys.lock().unwrap().insert((base.revision, base.comp, 0), content);
-        let source = RenderSource {
-            project: session.project.clone(),
-            footage: session.footage.clone(),
-            expr: None,
-            layer_cache: Arc::default(),
-            gpu: None,
-            gpu_display: false,
-            disk: None,
-        };
-        (frames, source, base, opts, disk, content)
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[test]
-    fn disk_indicator_does_not_hash_on_ui_thread_and_coalesces_edits() {
-        use std::sync::mpsc;
-        use std::time::{Duration, Instant};
-        struct Disk(u128);
-        impl RemoteFrames for Disk {
-            fn slots(&self) -> usize {
-                1
-            }
-            fn disk(&self) -> bool {
-                true
-            }
-            fn disk_contains(&self, key: u128) -> bool {
-                self.0 == key
-            }
-            fn start(&self, _: RemoteJob, done: RemoteDone) {
-                done(Err("test has no renderer".into()));
-            }
-        }
-        let mut s = effectcraft_engine::Session::default();
-        s.execute("comp.new", serde_json::json!({"width":32,"height":18,"duration":1})).unwrap();
-        let cid = s.active_comp_id().unwrap();
-        let opts = RenderOpts::default();
-        let stored = disk_cache::frame_key(disk_cache::comp_content_key(&s.project, cid), 2, 1000, opts_hash(&opts));
-        let mut frames = Frames { pool: Some(rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap()), ..Default::default() };
-        frames.set_remote(Some(Arc::new(Disk(stored))));
-        let (entered, started) = mpsc::channel();
-        let (release, wait) = mpsc::channel();
-        frames.pool.as_ref().unwrap().spawn(move || {
-            entered.send(()).unwrap();
-            wait.recv_timeout(Duration::from_secs(5)).unwrap();
-        });
-        started.recv_timeout(Duration::from_secs(3)).unwrap();
-        let src = RenderSource {
-            project: s.project.clone(),
-            footage: s.footage.clone(),
-            expr: None,
-            layer_cache: Arc::default(),
-            gpu: None,
-            gpu_display: false,
-            disk: None,
-        };
-        let mut base = key(1, 0, 0);
-        base.comp = cid.0;
-        for revision in 1..50 {
-            base.revision = revision;
-            assert!(frames.disk_frames(&src, &base, 0..30, &opts).is_empty());
-        }
-        assert!(frames.content_keys.lock().unwrap().is_empty(), "painting computed a content hash while the worker was blocked");
-        assert_eq!(frames.content_key_jobs.lock().unwrap().pending.len(), 1);
-        release.send(()).unwrap();
-        let until = Instant::now() + Duration::from_secs(3);
-        while !frames.content_keys.lock().unwrap().contains_key(&(base.revision, base.comp, 0)) {
-            assert!(Instant::now() < until);
-            std::thread::sleep(Duration::from_millis(1));
-        }
-        assert_eq!(frames.disk_frames(&src, &base, 0..30, &opts), vec![2], "the blue indicator must return once its key is ready");
-        assert_eq!(frames.content_keys.lock().unwrap().len(), 1, "superseded revisions were hashed");
-    }
-
-    #[test]
-    fn disk_indicator_range_tracks_live_membership() {
-        let (frames, src, base, opts, disk, _) = disk_fixture(&[10, 12]);
-        assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10, 12]);
-        assert_eq!(disk.probes.load(Ordering::Relaxed), 3);
-
-        disk.keys.lock().unwrap().insert(disk_cache::frame_key(1234, 11, base.scale, base.view ^ opts_hash(&opts)));
-        assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10, 11, 12]);
-
-        insert(&frames, FrameKey { frame: 11, ..base });
-        disk.probes.store(0, Ordering::Relaxed);
-        assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10, 12]);
-        assert_eq!(disk.probes.load(Ordering::Relaxed), 2);
-
-        disk.keys.lock().unwrap().remove(&disk_cache::frame_key(1234, 12, base.scale, base.view ^ opts_hash(&opts)));
-        assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10]);
-
-        let mut revised = base;
-        revised.revision += 1;
-        frames.content_keys.lock().unwrap().insert((revised.revision, revised.comp, 0), 5678);
-        assert!(frames.disk_frames(&src, &revised, 10..13, &opts).is_empty());
-
-        let changed = FrameKey { scale: base.scale + 1, ..base };
-        assert!(frames.disk_frames(&src, &changed, 10..13, &opts).is_empty());
-        let changed = FrameKey { view: base.view + 1, ..base };
-        assert!(frames.disk_frames(&src, &changed, 10..13, &opts).is_empty());
-        assert!(frames.disk_frames(&src, &base, 10..13, &RenderOpts { draft: true, ..opts }).is_empty());
-    }
-
-    #[test]
-    fn disk_indicator_range_is_bounded() {
-        let (frames, src, base, opts, disk, _) = disk_fixture(&[0, 1, 99_999]);
-        assert_eq!(frames.disk_frames(&src, &base, -5..2, &opts), vec![0, 1]);
-        assert_eq!(disk.probes.load(Ordering::Relaxed), 2);
-        disk.probes.store(0, Ordering::Relaxed);
-        assert_eq!(frames.disk_frames(&src, &base, 99_999..i64::MAX, &opts), vec![99_999]);
-        assert_eq!(disk.probes.load(Ordering::Relaxed), 1);
-        disk.probes.store(0, Ordering::Relaxed);
-        assert!(frames.disk_frames(&src, &base, 2..2, &opts).is_empty());
-        // Written as a struct literal: `3..2` trips clippy::reversed_empty_ranges.
-        let reversed = std::ops::Range { start: 3, end: 2 };
-        assert!(frames.disk_frames(&src, &base, reversed, &opts).is_empty());
-        assert_eq!(disk.probes.load(Ordering::Relaxed), 0);
-    }
-
-    /// Frames larger than the texture limit are averaged down by a whole factor (#201: an
-    /// 11000×2200 comp at Full resolution against an 8192 limit).
-    #[test]
-    fn frames_over_the_texture_limit_are_averaged_down() {
-        assert_eq!(fitted_size([11000, 2200], 8192), [5500, 1100]);
-        assert_eq!(fitted_size([8192, 100], 8192), [8192, 100]);
-        assert_eq!(fitted_size([30000, 30000], 16384), [15000, 15000]);
-        assert_eq!(fitted_size([0, 0], 0), [0, 0]);
-        // 5×2 (three columns of white, then black) into 2 px: 3×2 blocks (the last one 2×2).
-        let w = egui::Color32::WHITE;
-        let b = egui::Color32::from_rgba_premultiplied(0, 0, 0, 255);
-        let img = egui::ColorImage::new([5, 2], vec![w, w, w, b, b, w, w, w, b, b]);
-        let out = fit_texture(img.clone(), 2);
-        assert_eq!(out.size, [2, 1]);
-        assert_eq!(out.pixels, vec![w, b]);
-        assert_eq!(fit_texture(img.clone(), 5).pixels, img.pixels);
-        let mixed = fit_texture(egui::ColorImage::new([2, 1], vec![w, b]), 1);
-        assert_eq!(mixed.pixels, vec![egui::Color32::from_rgba_premultiplied(128, 128, 128, 255)]);
-    }
-
-    #[test]
-    fn retirement_reaches_existing_workers_and_keeps_cpu_frames_and_completion_live() {
-        let frames = Frames::default();
-        let worker = frames.worker();
-        let first = key(1, 0, 0);
-        insert(&frames, first);
-        frames.retire_gpu();
-        assert!(worker.gpu_retired.load(Ordering::Acquire), "already queued workers share retirement");
-        assert!(frames.is_cached(&first), "healthy materialized CPU frames survive");
-        let next = key(1, 1, 0);
-        frames.inflight.lock().unwrap().insert(next);
-        frames.queue.lock().unwrap().running.insert(next);
-        worker.finish_key(next, false, img(), web_time::Instant::now());
-        assert!(frames.is_cached(&next), "CPU retry can still publish");
-        assert_eq!(frames.inflight(), 0);
-        assert!(frames.queue.lock().unwrap().running.is_empty());
-    }
-
-    fn key(content: u64, frame: i64, opts: u64) -> FrameKey {
-        FrameKey { revision: content, content, comp: 1, frame, scale: 1000, view: 0, opts }
-    }
-
-    fn img() -> FrameImage {
-        FrameImage::Cpu(Arc::new(egui::ColorImage::new([2, 2], vec![egui::Color32::BLACK; 4])))
-    }
-
-    fn insert(f: &Frames, k: FrameKey) {
-        f.cache.lock().unwrap().insert(k, img());
-    }
-
-    /// A frame whose render panics (a GPU out of memory used to, on every frame thread) is
-    /// released, not left "in progress" forever, so the viewer can ask for it again (#106).
-    #[test]
-    fn a_frame_whose_render_panics_is_released() {
-        use effectcraft_engine::Session;
-        use effectcraft_engine::project::{Footage, FootageKind};
-        use effectcraft_engine::render::Image;
-        use serde_json::json;
-        use std::sync::atomic::{AtomicUsize, Ordering};
-        #[derive(Default)]
-        struct Explodes(AtomicUsize);
-        impl FootageSource for Explodes {
-            fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
-                self.0.fetch_add(1, Ordering::SeqCst);
-                panic!("a decoder bug");
-            }
-        }
-        let mut s = Session::default();
-        let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
-        let clip = Footage { kind: FootageKind::Still, width: 8, height: 8, has_video: true, ..Default::default() };
-        let item = Arc::make_mut(&mut s.project).add_item("clip.png", Default::default(), None, ItemKind::Footage(clip));
-        s.execute("layer.addItem", json!({"item": item.0})).unwrap();
-        let footage = Arc::new(Explodes::default());
-        let src = RenderSource {
-            project: s.project.clone(),
-            footage: footage.clone(),
-            expr: None,
-            layer_cache: Arc::default(),
-            gpu: None,
-            gpu_display: false,
-            disk: None,
-        };
-        let f = Frames::default();
-        let key = FrameKey { revision: s.revision, content: f.content_of(&s.project, s.revision, cid), ..key(0, 0, 0) };
-        let key = FrameKey { comp: cid.0, ..key };
-        f.request(&src, key, cid, Tick::ZERO, RenderOpts::default());
-        for _ in 0..1000 {
-            if f.inflight() == 0 {
-                break;
-            }
-            std::thread::sleep(std::time::Duration::from_millis(5));
-        }
-        assert!(footage.0.load(Ordering::SeqCst) > 0, "the render reached the footage");
-        assert_eq!(f.inflight(), 0, "released");
-        assert!(!f.is_cached(&key));
-    }
-
-    /// #647: a pool thread waiting inside a render (on a parallel loop) never starts another
-    /// frame render on top of it. Dragging a layer queues a frame every UI frame; renders used to
-    /// nest on every thread, each holding its buffers, until memory ran out.
-    #[test]
-    fn a_waiting_render_never_starts_another_on_its_thread() {
-        use effectcraft_engine::Session;
-        use effectcraft_engine::project::{Footage, FootageKind};
-        use effectcraft_engine::render::Image;
-        use effectcraft_engine::time::FrameRate;
-        use serde_json::json;
-        use std::cell::Cell;
-        use std::sync::atomic::AtomicUsize;
-        thread_local! {
-            static DEPTH: Cell<usize> = const { Cell::new(0) };
-        }
-        /// A decoder that works in parallel, as the renderer does: its thread joins the loop and
-        /// may wait for the parts other threads took.
-        #[derive(Default)]
-        struct Parallel {
-            calls: AtomicUsize,
-            deepest: AtomicUsize,
-        }
-        impl FootageSource for Parallel {
-            fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
-                let d = DEPTH.get() + 1;
-                DEPTH.set(d);
-                self.deepest.fetch_max(d, Ordering::SeqCst);
-                self.calls.fetch_add(1, Ordering::SeqCst);
-                (0..64).into_par_iter().for_each(|_| std::thread::sleep(std::time::Duration::from_millis(1)));
-                DEPTH.set(d - 1);
-                Some(Arc::new(Image::new(4, 4)))
-            }
-        }
-        let mut s = Session::default();
-        let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 10})).unwrap()["comp"].as_u64().unwrap());
-        let clip = Footage {
-            kind: FootageKind::Video,
-            width: 4,
-            height: 4,
-            has_video: true,
-            frame_rate: FrameRate::FPS_30,
-            duration: Tick::from_seconds_f64(10.0),
-            ..Default::default()
-        };
-        let item = Arc::make_mut(&mut s.project).add_item("clip.mov", Default::default(), None, ItemKind::Footage(clip));
-        s.execute("layer.addItem", json!({"item": item.0})).unwrap();
-        let footage = Arc::new(Parallel::default());
-        let src = RenderSource {
-            project: s.project.clone(),
-            footage: footage.clone(),
-            expr: None,
-            layer_cache: Arc::default(),
-            gpu: None,
-            gpu_display: false,
-            disk: None,
-        };
-        let f = Frames::default();
-        let content = f.content_of(&s.project, s.revision, cid);
-        let frames = 60;
-        for frame in 0..frames {
-            let key = FrameKey { revision: s.revision, content, comp: cid.0, frame, scale: 1000, view: 0, opts: 0 };
-            f.request(&src, key, cid, FrameRate::FPS_30.tick_of(frame), RenderOpts::default());
-        }
-        for _ in 0..4000 {
-            if f.inflight() == 0 {
-                break;
-            }
-            std::thread::sleep(std::time::Duration::from_millis(5));
-        }
-        assert_eq!(f.inflight(), 0, "every queued frame rendered");
-        assert!(footage.calls.load(Ordering::SeqCst) >= frames as usize);
-        assert_eq!(footage.deepest.load(Ordering::SeqCst), 1, "renders nested on a waiting thread");
-    }
-
-    /// #329: scrubbing a long movie, the viewer frame of every step the pointer passed started
-    /// rendering and seeked the movie's decoder in turn; the frame under the pointer waited for
-    /// all of them. A newer viewer frame of another time calls off the one rendering, which is
-    /// not cached (its footage may be missing).
-    #[test]
-    fn a_newer_viewer_frame_calls_off_the_one_rendering() {
-        use effectcraft_engine::Session;
-        use effectcraft_engine::project::{Footage, FootageKind};
-        use effectcraft_engine::render::Image;
-        use effectcraft_engine::time::FrameRate;
-        use serde_json::json;
-        use std::cell::RefCell;
-        thread_local! {
-            static CANCEL: RefCell<Option<Arc<AtomicBool>>> = const { RefCell::new(None) };
-        }
-        /// A movie whose first frames take a long seek, which a called-off read gives up.
-        #[derive(Default)]
-        struct Seeking {
-            seeking: AtomicBool,
-            called_off: AtomicBool,
-        }
-        impl FootageSource for Seeking {
-            fn cancellable(&self, cancel: &Arc<AtomicBool>, f: &mut dyn FnMut()) {
-                let prev = CANCEL.replace(Some(cancel.clone()));
-                f();
-                CANCEL.set(prev);
-            }
-            fn frame(&self, _: ItemId, _: &Footage, t: Tick) -> Option<Arc<Image>> {
-                if t < Tick::from_seconds_f64(0.25) {
-                    self.seeking.store(true, Ordering::SeqCst);
-                    for _ in 0..1000 {
-                        if CANCEL.with_borrow(|c| c.as_ref().is_some_and(|c| c.load(Ordering::SeqCst))) {
-                            self.called_off.store(true, Ordering::SeqCst);
-                            return None;
-                        }
-                        std::thread::sleep(std::time::Duration::from_millis(5));
-                    }
-                }
-                Some(Arc::new(Image::new(4, 4)))
-            }
-        }
-        let mut s = Session::default();
-        let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 10})).unwrap()["comp"].as_u64().unwrap());
-        let clip = Footage {
-            kind: FootageKind::Video,
-            width: 4,
-            height: 4,
-            has_video: true,
-            frame_rate: FrameRate::FPS_30,
-            duration: Tick::from_seconds_f64(10.0),
-            ..Default::default()
-        };
-        let item = Arc::make_mut(&mut s.project).add_item("clip.mov", Default::default(), None, ItemKind::Footage(clip));
-        s.execute("layer.addItem", json!({"item": item.0})).unwrap();
-        let footage = Arc::new(Seeking::default());
-        let src = RenderSource {
-            project: s.project.clone(),
-            footage: footage.clone(),
-            expr: None,
-            layer_cache: Arc::default(),
-            gpu: None,
-            gpu_display: false,
-            disk: None,
-        };
-        let f = Frames::default();
-        let content = f.content_of(&s.project, s.revision, cid);
-        let key = |frame| FrameKey { revision: s.revision, content, comp: cid.0, frame, scale: 1000, view: 0, opts: 0 };
-        f.request_urgent(&src, key(0), cid, Tick::ZERO, RenderOpts::default());
-        for _ in 0..1000 {
-            if footage.seeking.load(Ordering::SeqCst) {
-                break;
-            }
-            std::thread::sleep(std::time::Duration::from_millis(2));
-        }
-        assert!(footage.seeking.load(Ordering::SeqCst), "the first frame's render reached the footage");
-        f.request_urgent(&src, key(150), cid, FrameRate::FPS_30.tick_of(150), RenderOpts::default());
-        for _ in 0..1000 {
-            if f.inflight() == 0 {
-                break;
-            }
-            std::thread::sleep(std::time::Duration::from_millis(5));
-        }
-        assert!(footage.called_off.load(Ordering::SeqCst), "the superseded frame's seek ran on");
-        assert!(f.is_cached(&key(150)), "the newest frame rendered");
-        assert!(!f.is_cached(&key(0)), "a called-off frame is not cached");
-        assert_eq!(f.inflight(), 0, "released");
-    }
-
-    /// #284: scrubbing asks for a viewer frame at every step; a newer one drops the comp's viewer
-    /// frames still waiting (they would all render first), but not prefetch frames or another
-    /// comp's viewer frame.
-    #[test]
-    fn a_newer_viewer_frame_drops_the_ones_still_waiting() {
-        /// Starts nothing, so every request stays queued.
-        struct Idle;
-        impl RemoteFrames for Idle {
-            fn slots(&self) -> usize {
-                0
-            }
-            fn start(&self, _: RemoteJob, _: RemoteDone) {}
-        }
-        let mut f = Frames::default();
-        f.set_remote(Some(Arc::new(Idle)));
-        let src = RenderSource {
-            project: Arc::default(),
-            footage: Arc::new(effectcraft_engine::render::NoFootage),
-            expr: None,
-            layer_cache: Arc::default(),
-            gpu: None,
-            gpu_display: false,
-            disk: None,
-        };
-        let request = |k: FrameKey, urgent: bool| f.request_with(&src, k, ItemId(k.comp), Tick::ZERO, RenderOpts::default(), urgent);
-        let other = FrameKey { comp: 2, ..key(1, 0, 0) };
-        request(other, true);
-        request(key(1, 20, 0), false);
-        for frame in 0..10 {
-            request(key(1, frame, 0), true);
-        }
-        let mut queued: Vec<(u64, i64, bool)> = f.queue.lock().unwrap().jobs.iter().map(|j| (j.key.comp, j.key.frame, j.urgent)).collect();
-        queued.sort();
-        assert_eq!(queued, [(1, 9, true), (1, 20, false), (2, 0, false)]);
-        assert_eq!(f.inflight(), 3, "dropped frames aren't in flight: the viewer can ask again");
-    }
-
-    /// Each time the GPU runs out of memory, half as many GPU frames are kept, down to a floor.
-    #[test]
-    fn running_out_of_video_memory_halves_the_gpu_frame_budget() {
-        let f = Frames::default();
-        let mut c = f.cache.lock().unwrap();
-        assert_eq!(c.gpu_budget, GPU_BUDGET);
-        c.gpu_out_of_memory();
-        assert_eq!(c.gpu_budget, GPU_BUDGET / 2);
-        for _ in 0..20 {
-            c.gpu_out_of_memory();
-        }
-        assert_eq!(c.gpu_budget, MIN_GPU_BUDGET);
-    }
-
-    #[test]
-    fn least_recently_shown_frames_go_first() {
-        let f = Frames::default();
-        f.set_budget(3 * 16);
-        for i in 0..3 {
-            insert(&f, key(1, i, 0));
-        }
-        // Frame 0 is shown again, so frame 1 is now the oldest.
-        assert!(f.get(&key(1, 0, 0)).is_some());
-        insert(&f, key(1, 3, 0));
-        assert!(f.is_cached(&key(1, 0, 0)) && !f.is_cached(&key(1, 1, 0)));
-        assert!(f.is_cached(&key(1, 2, 0)) && f.is_cached(&key(1, 3, 0)));
-    }
-
-    fn playhead(cur: i64, looping: bool) -> Playhead {
-        Playhead { series: key(1, 0, 0), cur, start: 0, end: 99, step: 1, looping }
-    }
-
-    /// #595: a playing preview's cache is full. The frames just ahead of the playhead were
-    /// rendered before the ones just shown, so plain LRU evicted them first and the preview
-    /// played into a gap. Frames the preview no longer reaches go first, then the ones it
-    /// reaches last.
-    #[test]
-    fn a_full_cache_keeps_the_frames_just_ahead_of_the_playhead() {
-        let f = Frames::default();
-        f.set_budget(4 * 16);
-        // Prefetch rendered 11..=13, then 10 was shown (the most recently used).
-        for i in [11, 12, 13, 10] {
-            insert(&f, key(1, i, 0));
-        }
-        let cached = |f: &Frames| f.cached_frames(&key(1, 0, 0));
-        f.set_playhead(Some(playhead(10, false)));
-        // The next frame rendered is the one the preview reaches last: the frames just ahead stay.
-        insert(&f, key(1, 14, 0));
-        assert_eq!(cached(&f), [10, 11, 12, 13]);
-        // Without looping, a frame behind the playhead goes before any frame ahead of it.
-        f.set_playhead(Some(playhead(12, false)));
-        insert(&f, key(1, 14, 0));
-        assert_eq!(cached(&f), [10, 12, 13, 14]);
-        // Looping, the frame just behind is the one reached last.
-        f.set_playhead(Some(playhead(13, true)));
-        insert(&f, key(1, 0, 0));
-        assert_eq!(cached(&f), [0, 10, 13, 14]);
-        // Stopped: least recently shown first again.
-        f.set_playhead(None);
-        insert(&f, key(1, 50, 0));
-        assert!(!f.is_cached(&key(1, 13, 0)) && f.is_cached(&key(1, 50, 0)));
-    }
-
-    /// A frame source that queues jobs and never renders them: the tests check the queue.
-    struct Idle;
-    impl RemoteFrames for Idle {
-        fn slots(&self) -> usize {
-            0
-        }
-        fn start(&self, _: RemoteJob, _: RemoteDone) {}
-    }
-
-    fn idle_source() -> RenderSource {
-        RenderSource {
-            project: Arc::default(),
-            footage: Arc::new(effectcraft_engine::render::NoFootage),
-            expr: None,
-            layer_cache: Arc::default(),
-            gpu: None,
-            gpu_display: false,
-            disk: None,
-        }
-    }
-
-    /// #595: prefetch renders the frames the preview reaches first, whatever order they were
-    /// asked for in (a frame evicted and asked for again waited behind every frame further
-    /// ahead); queued frames the preview no longer reaches are dropped and not left in flight.
-    #[test]
-    fn prefetch_renders_the_frames_the_playhead_reaches_first() {
-        let mut f = Frames::default();
-        f.set_remote(Some(Arc::new(Idle)));
-        let src = idle_source();
-        for frame in [40, 30, 20, 5, 12, 11] {
-            f.request(&src, key(1, frame, 0), ItemId(1), Tick::ZERO, RenderOpts::default());
-        }
-        f.request(&src, FrameKey { comp: 2, ..key(1, 1, 0) }, ItemId(2), Tick::ZERO, RenderOpts::default());
-        f.set_playhead(Some(playhead(10, false)));
-        let mut order = vec![];
-        loop {
-            let mut q = f.queue.lock().unwrap();
-            let Some(i) = q.best() else { break };
-            let j = q.jobs.swap_remove(i);
-            order.push((j.key.comp, j.key.frame));
-        }
-        assert_eq!(order, [(1, 11), (1, 12), (1, 20), (1, 30), (1, 40), (2, 1)]);
-        assert_eq!(f.inflight(), 6, "frame 5, behind the playhead, is no longer in flight");
-    }
-
-    /// The cache is full. A zoom (or preview-resolution) change left the frames of the old
-    /// size to the plain least-recently-shown order, so the frames of the zoom the viewer is back
-    /// at went before the ones of the abandoned zoom. The other size's frames go first, then the
-    /// order is as before.
-    #[test]
-    fn a_size_change_evicts_frames_of_other_sizes_first() {
-        let mut f = Frames::default();
-        f.set_remote(Some(Arc::new(Idle)));
-        f.set_budget(4 * 16);
-        let at = |frame, scale| FrameKey { scale, ..key(1, frame, 0) };
-        // 100% (frames 0..=1) is cached, then 50% (2..=3): the 100% frames are the oldest.
-        for (frame, scale) in [(0, 1000), (1, 1000), (2, 500), (3, 500)] {
-            insert(&f, at(frame, scale));
-        }
-        // A passive viewer at 50% asks for a frame: that doesn't change which size is kept.
-        f.request(&idle_source(), at(9, 500), ItemId(1), Tick::ZERO, RenderOpts::default());
-        // Back at 100%: the viewer asks for frame 4.
-        f.request_urgent(&idle_source(), at(4, 1000), ItemId(1), Tick::ZERO, RenderOpts::default());
-        f.request(&idle_source(), at(10, 500), ItemId(1), Tick::ZERO, RenderOpts::default());
-        insert(&f, at(4, 1000));
-        assert!(
-            f.is_cached(&at(0, 1000)) && f.is_cached(&at(1, 1000)) && !f.is_cached(&at(2, 500)) && f.is_cached(&at(3, 500)),
-            "the first frame of the old size goes, not the cached ones of the current size"
-        );
-        insert(&f, at(5, 1000));
-        assert!(!f.is_cached(&at(3, 500)), "then the last frame of the old size");
-        assert_eq!(f.cached_frames(&at(0, 1000)), [0, 1, 4, 5]);
-        // No other size left: least recently shown first again.
-        insert(&f, at(6, 1000));
-        assert_eq!(f.cached_frames(&at(0, 1000)), [1, 4, 5, 6]);
-    }
-
-    #[test]
-    fn frames_are_keyed_by_content_and_series_are_kept_apart() {
-        let f = Frames::default();
-        insert(&f, key(1, 0, 0));
-        insert(&f, key(2, 0, 0));
-        insert(&f, key(2, 1, 7));
-        // Other content or render options (Draft, shadows…) are another series.
-        assert_eq!(f.cached_frames(&key(2, 0, 0)), vec![0]);
-        assert_eq!(f.cached_frames(&key(2, 0, 7)), vec![1]);
-        // A later revision with the same content finds the frame (an edit elsewhere, an undo).
-        assert!(f.is_cached(&FrameKey { revision: 99, ..key(1, 0, 0) }));
-        assert!(!f.is_cached(&key(3, 0, 0)));
-    }
-
-    #[test]
-    fn live_edits_present_the_newest_completed_revision_without_going_backwards() {
-        let f = Frames::default();
-        let shown = key(1, 0, 0);
-        let newest = key(3, 0, 0);
-        let wanted = key(5, 0, 0);
-        insert(&f, shown);
-        insert(&f, newest);
-        insert(&f, key(2, 0, 0)); // Older worker finishes after the newer one.
-        let displayed = f.get_for_viewer(&wanted, Some(&shown)).unwrap().0;
-        assert_eq!(displayed, newest);
-        assert!(f.get_for_viewer(&wanted, Some(&displayed)).is_none(), "never replay an older completion");
-        insert(&f, wanted);
-        assert_eq!(f.get_for_viewer(&wanted, Some(&displayed)).unwrap().0, wanted, "settle on the exact final edit");
-        // Undo reuses the content of an earlier revision immediately.
-        let undo = FrameKey { revision: 6, ..shown };
-        let reused = f.get_for_viewer(&undo, Some(&wanted)).unwrap().0;
-        assert_eq!(reused.content, shown.content);
-        assert_eq!(reused.revision, undo.revision);
-    }
-
-    #[test]
-    fn live_edits_do_not_substitute_other_times_views_or_render_settings() {
-        let f = Frames::default();
-        let shown = key(1, 0, 0);
-        let wanted = key(3, 0, 0);
-        let done = key(2, 0, 0);
-        for mismatch in [
-            FrameKey { comp: 9, ..done },
-            FrameKey { frame: 1, ..done },
-            FrameKey { scale: 500, ..done },
-            FrameKey { view: 1, ..done },
-            FrameKey { opts: 1, ..done },
-            FrameKey { revision: 4, ..done },
-        ] {
-            f.clear();
-            insert(&f, mismatch);
-            assert!(f.get_for_viewer(&wanted, Some(&shown)).is_none(), "wrong candidate: {mismatch:?}");
-        }
-        f.clear();
-        insert(&f, done);
-        assert!(f.get_for_viewer(&wanted, None).is_none(), "no stale content on opening a viewer");
-        assert!(f.get_for_viewer(&wanted, Some(&FrameKey { comp: 9, ..shown })).is_none());
-        assert!(f.get_for_viewer(&wanted, Some(&FrameKey { frame: 1, ..shown })).is_none());
-        assert!(f.get_for_viewer(&wanted, Some(&FrameKey { view: 1, ..shown })).is_none());
-    }
-
-    #[test]
-    fn an_edit_keeps_the_frames_of_comps_it_does_not_touch() {
-        use effectcraft_engine::Session;
-        use serde_json::json;
-        let mut s = Session::default();
-        let a = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
-        let b = ItemId(s.execute("comp.new", json!({"name": "B", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
-        let f = Frames::default();
-        let at = |s: &Session, c: ItemId| f.content_of(&s.project, s.revision, c);
-        let (a0, b0) = (at(&s, a), at(&s, b));
-        // Edit B: A's content (and frames) stay, B's change.
-        s.execute("layer.newSolid", json!({"comp": b.0, "color": "#ff0000"})).unwrap();
-        assert_eq!(at(&s, a), a0);
-        assert_ne!(at(&s, b), b0);
-        // Undo: B is back to the content its old frames were rendered for.
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(at(&s, b), b0);
-    }
-
-    #[test]
-    fn a_long_drag_keeps_a_bounded_number_of_states() {
-        use effectcraft_engine::Session;
-        use serde_json::json;
-        let mut s = Session::default();
-        let a = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
-        let f = Frames::default();
-        let mut last = None;
-        for i in 0..200 {
-            s.execute("comp.settings", json!({"width": 8 + i, "merge": "drag"})).unwrap();
-            let k = FrameKey { content: f.content_of(&s.project, s.revision, a), ..key(0, 0, 0) };
-            insert(&f, k);
-            last = Some(k);
-        }
-        // The snapshots and the frames kept stay bounded (a dropped identity's frames go with it,
-        // so a later state that reuses its addresses can't be shown an old frame).
-        assert!(f.keepers.lock().unwrap().1.len() <= MAX_KEEPERS);
-        assert!(f.cache.lock().unwrap().map.len() <= MAX_KEEPERS);
-        assert!(f.is_cached(&last.unwrap()), "the current state's frame stays");
-    }
-
-    #[test]
-    fn an_identity_keeps_its_comps_so_an_edit_in_place_still_changes_it() {
-        use effectcraft_engine::Session;
-        use serde_json::json;
-        let mut s = Session::default();
-        let a = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
-        // A project nothing else holds (no undo history): make_mut would edit the comp in place,
-        // at the same address, if the identity hadn't kept a snapshot holding it.
-        let mut p = Arc::new((*s.project).clone());
-        drop(s);
-        let f = Frames::default();
-        let before = f.content_of(&p, 1, a);
-        let comp = Arc::make_mut(&mut p).comp_mut(a).unwrap();
-        comp.width = 16;
-        assert_ne!(f.content_of(&p, 2, a), before);
-    }
-
-    /// Audio, Lock and Shy (and Hide Shy Layers) don't change pixels: toggling them, in the comp
-    /// or a comp it nests, keeps its frames, also when toggled back (#103).
-    #[test]
-    fn audio_lock_and_shy_switches_keep_the_frames() {
-        use effectcraft_engine::Session;
-        use serde_json::json;
-        let mut s = Session::default();
-        let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
-        let inner = ItemId(id(s.execute("comp.new", json!({"name": "Inner", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
-        let solid = id(s.execute("layer.newSolid", json!({"comp": inner.0, "color": "#ff0000"})).unwrap(), "layer");
-        let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
-        let nested = id(s.execute("layer.addItem", json!({"comp": outer.0, "item": inner.0})).unwrap(), "layer");
-        let f = Frames::default();
-        let at = |s: &Session| f.content_of(&s.project, s.revision, outer);
-        let o0 = at(&s);
-        let switch = |s: &mut Session, comp: ItemId, layer: u64, sw: &str, v: bool| {
-            s.execute("layer.setSwitch", json!({"comp": comp.0, "layers": [layer], "switch": sw, "value": v})).unwrap();
-        };
-        for (comp, layer, sw) in [(outer, nested, "audio"), (outer, nested, "lock"), (outer, nested, "shy"), (inner, solid, "audio"), (inner, solid, "shy")] {
-            // Audio off; Lock and Shy on.
-            switch(&mut s, comp, layer, sw, sw != "audio");
-            assert_eq!(at(&s), o0, "{sw} on in {comp:?}");
-        }
-        s.execute("comp.setSwitch", json!({"comp": outer.0, "switch": "hideShy", "value": true})).unwrap();
-        assert_eq!(at(&s), o0, "Hide Shy Layers");
-        switch(&mut s, outer, nested, "audio", true);
-        switch(&mut s, outer, nested, "lock", false);
-        assert_eq!(at(&s), o0, "toggled back");
-        // Switches that change pixels still do.
-        switch(&mut s, inner, solid, "video", false);
-        let o1 = at(&s);
-        assert_ne!(o1, o0, "Video");
-        switch(&mut s, outer, nested, "audio", false);
-        assert_eq!(at(&s), o1, "a mute after a real edit keeps that edit's frames");
-        switch(&mut s, inner, solid, "video", true);
-        assert_ne!(at(&s), o1);
-    }
-
-    /// A cut or trim recaches only the frames of the layers it touched (#1641), and none are
-    /// kept when the change reaches other layers (here a child of the trimmed layer).
-    #[test]
-    fn an_edit_keeps_the_frames_outside_the_layers_it_changed() {
-        use effectcraft_engine::Session;
-        use serde_json::json;
-        let mut s = Session::default();
-        let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
-        let comp = ItemId(id(s.execute("comp.new", json!({"name": "Edit", "width": 8, "height": 8, "duration": 10})).unwrap(), "comp"));
-        let a = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap(), "layer");
-        let b = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#00ff00"})).unwrap(), "layer");
-        s.execute("layer.timing", json!({"layers": [a], "in": 0, "out": 4})).unwrap();
-        s.execute("layer.timing", json!({"layers": [b], "in": 4, "out": 10})).unwrap();
-        let (fr, out) = s.project.comp(comp).map(|c| (c.frame_rate, c.layers.iter().find(|l| l.id.0 == a).unwrap().out_point)).unwrap();
-        let frames: Vec<i64> = (0..fr.frame_at(Tick::from_seconds_f64(10.0))).collect();
-        let f = Frames::default();
-        let cache_all = |s: &Session| {
-            let c = f.content_of(&s.project, s.revision, comp);
-            frames.iter().for_each(|&n| insert(&f, key(c, n, 0)));
-            c
-        };
-        let cached = |c: u64| frames.iter().filter(|&&n| f.is_cached(&key(c, n, 0))).copied().collect::<Vec<_>>();
-        let before = cache_all(&s);
-        s.execute("time.set", json!({"time": 2.0})).unwrap();
-        s.execute("edit.splitLayer", json!({"layers": [a]})).unwrap();
-        let after = f.content_of(&s.project, s.revision, comp);
-        assert_ne!(after, before);
-        let kept: Vec<i64> = (fr.frame_at(out) + 2..frames.len() as i64).collect();
-        assert_eq!(cached(after), kept, "the cut layer's frames (and one either side) render again; the rest stay");
-
-        s.execute("layer.setParent", json!({"layers": [b], "parent": a})).unwrap();
-        let parented = cache_all(&s);
-        s.execute("layer.timing", json!({"layers": [a], "out": 1})).unwrap();
-        assert_eq!(cached(f.content_of(&s.project, s.revision, comp)), Vec::<i64>::new(), "the trimmed layer's child moves everywhere");
-        assert_eq!(cached(parented).len(), frames.len(), "the earlier frames stay for undo");
-    }
-
-    /// Every frame an edit keeps renders as a fresh render of the edited project does: Solo
-    /// hides the other layers at every frame, and a camera reaches the frames whose shutter
-    /// samples it (#1641 review).
-    #[test]
-    fn the_frames_an_edit_keeps_match_a_fresh_render() {
-        use effectcraft_engine::Session;
-        use effectcraft_engine::render::NoFootage;
-        use serde_json::json;
-        // Cache every frame of `comp`, run `edit`, check the frames kept against fresh renders.
-        fn kept(s: &mut Session, comp: ItemId, edit: serde_json::Value) -> Vec<i64> {
-            let (fr, n) = s.project.comp(comp).map(|c| (c.frame_rate, c.frame_rate.frame_at(c.duration))).unwrap();
-            let f = Frames::default();
-            let before = f.content_of(&s.project, s.revision, comp);
-            (0..n).for_each(|i| insert(&f, key(before, i, 0)));
-            let old = s.project.clone();
-            s.execute(edit["cmd"].as_str().unwrap(), edit["params"].clone()).unwrap();
-            let after = f.content_of(&s.project, s.revision, comp);
-            let kept: Vec<i64> = (0..n).filter(|&i| f.is_cached(&key(after, i, 0))).collect();
-            let render = |p, i| Renderer::new(p, &NoFootage, RenderOpts::default()).comp_frame(comp, fr.tick_of(i));
-            for &i in &kept {
-                assert_eq!(render(&old, i), render(&s.project, i), "kept frame {i} draws other pixels now");
-            }
-            kept
-        }
-        let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
-        let mut s = Session::default();
-
-        // Solo on a 2–3 s layer hides the 10 s underlay everywhere; turning it off shows it again.
-        let comp = ItemId(id(s.execute("comp.new", json!({"name": "Solo", "width": 8, "height": 8, "duration": 10})).unwrap(), "comp"));
-        s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap();
-        let short = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#00ff00"})).unwrap(), "layer");
-        s.execute("layer.timing", json!({"layers": [short], "in": 2, "out": 3})).unwrap();
-        let solo = |on: bool| json!({"cmd": "layer.setSwitch", "params": {"layers": [short], "switch": "solo", "value": on}});
-        assert_eq!(kept(&mut s, comp, solo(true)), Vec::<i64>::new());
-        assert_eq!(kept(&mut s, comp, solo(false)), Vec::<i64>::new());
-
-        // A 2–3 s camera over a 4 s motion-blurred 3D layer, shutter 720° at phase 360°: a frame
-        // samples 1 to 3 frames ahead, so moving the camera reaches the 3 frames before it.
-        let comp = ItemId(id(
-            s.execute("comp.new", json!({"name": "Cam", "width": 16, "height": 16, "duration": 4, "frameRate": 30, "shutterAngle": 720, "shutterPhase": 360}))
-                .unwrap(),
-            "comp",
-        ));
-        let plane = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap(), "layer");
-        for sw in ["threeD", "motionBlur"] {
-            s.execute("layer.setSwitch", json!({"layers": [plane], "switch": sw, "value": true})).unwrap();
-        }
-        let cam = id(s.execute("layer.newCamera", json!({"comp": comp.0})).unwrap(), "layer");
-        s.execute("layer.timing", json!({"layers": [cam], "in": 2, "out": 3})).unwrap();
-        let moved =
-            kept(&mut s, comp, json!({"cmd": "prop.set", "params": {"comp": comp.0, "layer": cam, "path": "transform/position", "value": [40, 8, -30]}}));
-        assert!(moved.contains(&0) && moved.contains(&100), "frames far from the camera stay: {moved:?}");
-        assert!(!(56..=91).any(|f| moved.contains(&f)), "frames whose shutter samples the camera render again: {moved:?}");
-    }
-
-    #[test]
-    fn short_solid_additions_and_removals_keep_unaffected_frames() {
-        use effectcraft_engine::Session;
-        use serde_json::json;
-        let mut s = Session::default();
-        let comp = ItemId(s.execute("comp.new", json!({"width": 8, "height": 8, "frameRate": 30, "duration": 20})).unwrap()["comp"].as_u64().unwrap());
-        s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
-        let f = Frames::default();
-        let cache_all = |s: &Session| {
-            let content = f.content_of(&s.project, s.revision, comp);
-            (0..600).for_each(|n| insert(&f, key(content, n, 0)));
-        };
-        let cached = |s: &Session| f.cached_frames(&key(f.content_of(&s.project, s.revision, comp), 0, 0));
-        // 2–3 s, a quarter frame of the default shutter and a frame of rounding either side.
-        let kept: Vec<i64> = (0..=57).chain(92..600).collect();
-        cache_all(&s);
-        let solid = s.execute("layer.newSolid", json!({"color": "#00ff00"})).unwrap()["layer"].as_u64().unwrap();
-        s.execute("layer.timing", json!({"layers": [solid], "in": 2, "out": 3})).unwrap();
-        assert_eq!(cached(&s), kept, "adding a source invalidates only frames 58..=91");
-        cache_all(&s);
-        s.execute("edit.undo", json!({})).unwrap();
-        s.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(cached(&s), (0..600).collect::<Vec<_>>(), "undoing the addition restores every frame");
-        s.execute("edit.redo", json!({})).unwrap();
-        s.execute("edit.redo", json!({})).unwrap();
-        assert_eq!(cached(&s), (0..600).collect::<Vec<_>>(), "redoing the addition restores every frame");
-        s.execute("edit.clear", json!({"layers": [solid]})).unwrap();
-        assert_eq!(cached(&s), kept, "removing its layer invalidates the same span");
-    }
-
-    #[test]
-    fn adding_a_source_does_not_hide_changes_to_existing_dependencies() {
-        use effectcraft_engine::Session;
-        use serde_json::json;
-        for (command, params) in [
-            ("layer.settings", json!({"comp": "Outer", "layer": "Underlay", "color": "#0000ff"})),
-            ("prop.set", json!({"comp": "Inner", "layer": "Inner solid", "path": "transform/opacity", "value": 40})),
-        ] {
-            let mut s = Session::default();
-            let comp = ItemId(
-                s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "frameRate": 30, "duration": 20})).unwrap()["comp"].as_u64().unwrap(),
-            );
-            s.execute("layer.newSolid", json!({"name": "Underlay", "color": "#ff0000"})).unwrap();
-            s.execute("comp.new", json!({"name": "Inner", "width": 8, "height": 8, "duration": 20})).unwrap();
-            s.execute("layer.newSolid", json!({"name": "Inner solid", "color": "#00ff00"})).unwrap();
-            s.execute("comp.open", json!({"comp": "Outer"})).unwrap();
-            s.execute("layer.addItem", json!({"item": "Inner"})).unwrap();
-            let f = Frames::default();
-            let before = f.content_of(&s.project, s.revision, comp);
-            (0..600).for_each(|n| insert(&f, key(before, n, 0)));
-            s.execute(command, params).unwrap();
-            let solid = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
-            s.execute("layer.timing", json!({"layers": [solid], "in": 2, "out": 3})).unwrap();
-            let after = f.content_of(&s.project, s.revision, comp);
-            assert!(f.cached_frames(&key(after, 0, 0)).is_empty(), "{command} changes pixels outside the added layer");
-        }
-    }
-
-    #[test]
-    fn markers_keep_the_frames() {
-        use effectcraft_engine::Session;
-        use serde_json::json;
-        let mut s = Session::default();
-        let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
-        let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
-        let solid = id(s.execute("layer.newSolid", json!({"comp": outer.0, "color": "#ff0000"})).unwrap(), "layer");
-        let f = Frames::default();
-        let at = |s: &Session| f.content_of(&s.project, s.revision, outer);
-        let o0 = at(&s);
-        s.execute("layer.addMarker", json!({"comp": outer.0, "layers": [solid], "time": 0.5, "comment": "beat"})).unwrap();
-        assert_eq!(at(&s), o0, "a marker changes no pixels, so it keeps the frames");
-    }
-
-    #[test]
-    fn markers_count_when_an_expression_can_read_them() {
-        use effectcraft_engine::Session;
-        use serde_json::json;
-        let mut s = Session::default();
-        let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
-        let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
-        let solid = id(s.execute("layer.newSolid", json!({"comp": outer.0, "color": "#ff0000"})).unwrap(), "layer");
-        s.execute("prop.setExpression", json!({"comp": outer.0, "layer": solid, "path": "transform/opacity", "expression": "1"})).unwrap();
-        let f = Frames::default();
-        let at = |s: &Session| f.content_of(&s.project, s.revision, outer);
-        let o0 = at(&s);
-        s.execute("layer.addMarker", json!({"comp": outer.0, "layers": [solid], "time": 0.5, "comment": "beat"})).unwrap();
-        assert_ne!(at(&s), o0, "an expression can read the marker, so the frames change");
-    }
-}
+mod tests;
diff --git a/crates/ui-egui/src/frames/tests.rs b/crates/ui-egui/src/frames/tests.rs
new file mode 100644
index 000000000..d04793f50
--- /dev/null
+++ b/crates/ui-egui/src/frames/tests.rs
@@ -0,0 +1,1086 @@
+use super::*;
+
+#[test]
+fn converting_a_frame_with_nan_alpha_keeps_the_viewer_alive() {
+    let image = effectcraft_engine::render::Image::filled(1, 1, [0.5, 0.25, 0.1, f32::NAN]);
+    assert_eq!(to_color_image(&image).pixels, [egui::Color32::TRANSPARENT]);
+}
+
+struct ProbeDisk {
+    keys: Mutex<HashSet<u128>>,
+    probes: std::sync::atomic::AtomicUsize,
+}
+
+impl RemoteFrames for ProbeDisk {
+    fn slots(&self) -> usize {
+        0
+    }
+
+    fn disk(&self) -> bool {
+        true
+    }
+
+    fn disk_contains(&self, key: u128) -> bool {
+        self.probes.fetch_add(1, Ordering::Relaxed);
+        self.keys.lock().unwrap().contains(&key)
+    }
+
+    fn start(&self, _: RemoteJob, _: RemoteDone) {}
+}
+
+fn disk_fixture(stored_frames: &[i64]) -> (Frames, RenderSource, FrameKey, RenderOpts, Arc<ProbeDisk>, u128) {
+    let mut session = effectcraft_engine::Session::default();
+    session.execute("comp.new", serde_json::json!({"width": 32, "height": 18, "duration": 1})).unwrap();
+    let comp = session.active_comp_id().unwrap();
+    let opts = RenderOpts::default();
+    let content = 1234;
+    let mut base = key(1, 0, opts_hash(&opts));
+    base.revision = 7;
+    base.comp = comp.0;
+    let disk = Arc::new(ProbeDisk { keys: Mutex::new(HashSet::new()), probes: 0.into() });
+    disk.keys.lock().unwrap().extend(stored_frames.iter().map(|frame| disk_cache::frame_key(content, *frame, base.scale, base.view ^ opts_hash(&opts))));
+    let mut frames = Frames::default();
+    frames.set_remote(Some(disk.clone()));
+    frames.content_keys.lock().unwrap().insert((base.revision, base.comp, 0), content);
+    let source = RenderSource {
+        project: session.project.clone(),
+        footage: session.footage.clone(),
+        expr: None,
+        layer_cache: Arc::default(),
+        gpu: None,
+        gpu_display: false,
+        disk: None,
+    };
+    (frames, source, base, opts, disk, content)
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn disk_indicator_does_not_hash_on_ui_thread_and_coalesces_edits() {
+    use std::sync::mpsc;
+    use std::time::{Duration, Instant};
+    struct Disk(u128);
+    impl RemoteFrames for Disk {
+        fn slots(&self) -> usize {
+            1
+        }
+        fn disk(&self) -> bool {
+            true
+        }
+        fn disk_contains(&self, key: u128) -> bool {
+            self.0 == key
+        }
+        fn start(&self, _: RemoteJob, done: RemoteDone) {
+            done(Err("test has no renderer".into()));
+        }
+    }
+    let mut s = effectcraft_engine::Session::default();
+    s.execute("comp.new", serde_json::json!({"width":32,"height":18,"duration":1})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let opts = RenderOpts::default();
+    let stored = disk_cache::frame_key(disk_cache::comp_content_key(&s.project, cid), 2, 1000, opts_hash(&opts));
+    let mut frames = Frames { pool: Some(rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap()), ..Default::default() };
+    frames.set_remote(Some(Arc::new(Disk(stored))));
+    let (entered, started) = mpsc::channel();
+    let (release, wait) = mpsc::channel();
+    frames.pool.as_ref().unwrap().spawn(move || {
+        entered.send(()).unwrap();
+        wait.recv_timeout(Duration::from_secs(5)).unwrap();
+    });
+    started.recv_timeout(Duration::from_secs(3)).unwrap();
+    let src = RenderSource {
+        project: s.project.clone(),
+        footage: s.footage.clone(),
+        expr: None,
+        layer_cache: Arc::default(),
+        gpu: None,
+        gpu_display: false,
+        disk: None,
+    };
+    let mut base = key(1, 0, 0);
+    base.comp = cid.0;
+    for revision in 1..50 {
+        base.revision = revision;
+        assert!(frames.disk_frames(&src, &base, 0..30, &opts).is_empty());
+    }
+    assert!(frames.content_keys.lock().unwrap().is_empty(), "painting computed a content hash while the worker was blocked");
+    assert_eq!(frames.content_key_jobs.lock().unwrap().pending.len(), 1);
+    release.send(()).unwrap();
+    let until = Instant::now() + Duration::from_secs(3);
+    while !frames.content_keys.lock().unwrap().contains_key(&(base.revision, base.comp, 0)) {
+        assert!(Instant::now() < until);
+        std::thread::sleep(Duration::from_millis(1));
+    }
+    assert_eq!(frames.disk_frames(&src, &base, 0..30, &opts), vec![2], "the blue indicator must return once its key is ready");
+    assert_eq!(frames.content_keys.lock().unwrap().len(), 1, "superseded revisions were hashed");
+}
+
+#[test]
+fn disk_indicator_range_tracks_live_membership() {
+    let (frames, src, base, opts, disk, _) = disk_fixture(&[10, 12]);
+    assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10, 12]);
+    assert_eq!(disk.probes.load(Ordering::Relaxed), 3);
+
+    disk.keys.lock().unwrap().insert(disk_cache::frame_key(1234, 11, base.scale, base.view ^ opts_hash(&opts)));
+    assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10, 11, 12]);
+
+    insert(&frames, FrameKey { frame: 11, ..base });
+    disk.probes.store(0, Ordering::Relaxed);
+    assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10, 12]);
+    assert_eq!(disk.probes.load(Ordering::Relaxed), 2);
+
+    disk.keys.lock().unwrap().remove(&disk_cache::frame_key(1234, 12, base.scale, base.view ^ opts_hash(&opts)));
+    assert_eq!(frames.disk_frames(&src, &base, 10..13, &opts), vec![10]);
+
+    let mut revised = base;
+    revised.revision += 1;
+    frames.content_keys.lock().unwrap().insert((revised.revision, revised.comp, 0), 5678);
+    assert!(frames.disk_frames(&src, &revised, 10..13, &opts).is_empty());
+
+    let changed = FrameKey { scale: base.scale + 1, ..base };
+    assert!(frames.disk_frames(&src, &changed, 10..13, &opts).is_empty());
+    let changed = FrameKey { view: base.view + 1, ..base };
+    assert!(frames.disk_frames(&src, &changed, 10..13, &opts).is_empty());
+    assert!(frames.disk_frames(&src, &base, 10..13, &RenderOpts { draft: true, ..opts }).is_empty());
+}
+
+#[test]
+fn disk_indicator_range_is_bounded() {
+    let (frames, src, base, opts, disk, _) = disk_fixture(&[0, 1, 99_999]);
+    assert_eq!(frames.disk_frames(&src, &base, -5..2, &opts), vec![0, 1]);
+    assert_eq!(disk.probes.load(Ordering::Relaxed), 2);
+    disk.probes.store(0, Ordering::Relaxed);
+    assert_eq!(frames.disk_frames(&src, &base, 99_999..i64::MAX, &opts), vec![99_999]);
+    assert_eq!(disk.probes.load(Ordering::Relaxed), 1);
+    disk.probes.store(0, Ordering::Relaxed);
+    assert!(frames.disk_frames(&src, &base, 2..2, &opts).is_empty());
+    // Written as a struct literal: `3..2` trips clippy::reversed_empty_ranges.
+    let reversed = std::ops::Range { start: 3, end: 2 };
+    assert!(frames.disk_frames(&src, &base, reversed, &opts).is_empty());
+    assert_eq!(disk.probes.load(Ordering::Relaxed), 0);
+}
+
+/// Frames larger than the texture limit are averaged down by a whole factor (#201: an
+/// 11000×2200 comp at Full resolution against an 8192 limit).
+#[test]
+fn frames_over_the_texture_limit_are_averaged_down() {
+    assert_eq!(fitted_size([11000, 2200], 8192), [5500, 1100]);
+    assert_eq!(fitted_size([8192, 100], 8192), [8192, 100]);
+    assert_eq!(fitted_size([30000, 30000], 16384), [15000, 15000]);
+    assert_eq!(fitted_size([0, 0], 0), [0, 0]);
+    // 5×2 (three columns of white, then black) into 2 px: 3×2 blocks (the last one 2×2).
+    let w = egui::Color32::WHITE;
+    let b = egui::Color32::from_rgba_premultiplied(0, 0, 0, 255);
+    let img = egui::ColorImage::new([5, 2], vec![w, w, w, b, b, w, w, w, b, b]);
+    let out = fit_texture(img.clone(), 2);
+    assert_eq!(out.size, [2, 1]);
+    assert_eq!(out.pixels, vec![w, b]);
+    assert_eq!(fit_texture(img.clone(), 5).pixels, img.pixels);
+    let mixed = fit_texture(egui::ColorImage::new([2, 1], vec![w, b]), 1);
+    assert_eq!(mixed.pixels, vec![egui::Color32::from_rgba_premultiplied(128, 128, 128, 255)]);
+}
+
+#[test]
+fn retirement_reaches_existing_workers_and_keeps_cpu_frames_and_completion_live() {
+    let frames = Frames::default();
+    let worker = frames.worker();
+    let first = key(1, 0, 0);
+    insert(&frames, first);
+    frames.retire_gpu();
+    assert!(worker.gpu_retired.load(Ordering::Acquire), "already queued workers share retirement");
+    assert!(frames.is_cached(&first), "healthy materialized CPU frames survive");
+    let next = key(1, 1, 0);
+    frames.inflight.lock().unwrap().insert(next);
+    frames.queue.lock().unwrap().running.insert(next);
+    worker.finish_key(next, false, img(), web_time::Instant::now());
+    assert!(frames.is_cached(&next), "CPU retry can still publish");
+    assert_eq!(frames.inflight(), 0);
+    assert!(frames.queue.lock().unwrap().running.is_empty());
+}
+
+fn key(content: u64, frame: i64, opts: u64) -> FrameKey {
+    FrameKey { revision: content, content, comp: 1, frame, scale: 1000, view: 0, opts }
+}
+
+fn img() -> FrameImage {
+    FrameImage::Cpu(Arc::new(egui::ColorImage::new([2, 2], vec![egui::Color32::BLACK; 4])))
+}
+
+fn insert(f: &Frames, k: FrameKey) {
+    f.cache.lock().unwrap().insert(k, img());
+}
+
+/// A frame whose render panics (a GPU out of memory used to, on every frame thread) is
+/// released, not left "in progress" forever, so the viewer can ask for it again (#106).
+#[test]
+fn a_frame_whose_render_panics_is_released() {
+    use effectcraft_engine::Session;
+    use effectcraft_engine::project::{Footage, FootageKind};
+    use effectcraft_engine::render::Image;
+    use serde_json::json;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    #[derive(Default)]
+    struct Explodes(AtomicUsize);
+    impl FootageSource for Explodes {
+        fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
+            self.0.fetch_add(1, Ordering::SeqCst);
+            panic!("a decoder bug");
+        }
+    }
+    let mut s = Session::default();
+    let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
+    let clip = Footage { kind: FootageKind::Still, width: 8, height: 8, has_video: true, ..Default::default() };
+    let item = Arc::make_mut(&mut s.project).add_item("clip.png", Default::default(), None, ItemKind::Footage(clip));
+    s.execute("layer.addItem", json!({"item": item.0})).unwrap();
+    let footage = Arc::new(Explodes::default());
+    let src = RenderSource {
+        project: s.project.clone(),
+        footage: footage.clone(),
+        expr: None,
+        layer_cache: Arc::default(),
+        gpu: None,
+        gpu_display: false,
+        disk: None,
+    };
+    let f = Frames::default();
+    let key = FrameKey { revision: s.revision, content: f.content_of(&s.project, s.revision, cid), ..key(0, 0, 0) };
+    let key = FrameKey { comp: cid.0, ..key };
+    f.request(&src, key, cid, Tick::ZERO, RenderOpts::default());
+    for _ in 0..1000 {
+        if f.inflight() == 0 {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    assert!(footage.0.load(Ordering::SeqCst) > 0, "the render reached the footage");
+    assert_eq!(f.inflight(), 0, "released");
+    assert!(!f.is_cached(&key));
+}
+
+/// #647: a pool thread waiting inside a render (on a parallel loop) never starts another
+/// frame render on top of it. Dragging a layer queues a frame every UI frame; renders used to
+/// nest on every thread, each holding its buffers, until memory ran out.
+#[test]
+fn a_waiting_render_never_starts_another_on_its_thread() {
+    use effectcraft_engine::Session;
+    use effectcraft_engine::project::{Footage, FootageKind};
+    use effectcraft_engine::render::Image;
+    use effectcraft_engine::time::FrameRate;
+    use serde_json::json;
+    use std::cell::Cell;
+    use std::sync::atomic::AtomicUsize;
+    thread_local! {
+        static DEPTH: Cell<usize> = const { Cell::new(0) };
+    }
+    /// A decoder that works in parallel, as the renderer does: its thread joins the loop and
+    /// may wait for the parts other threads took.
+    #[derive(Default)]
+    struct Parallel {
+        calls: AtomicUsize,
+        deepest: AtomicUsize,
+    }
+    impl FootageSource for Parallel {
+        fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
+            let d = DEPTH.get() + 1;
+            DEPTH.set(d);
+            self.deepest.fetch_max(d, Ordering::SeqCst);
+            self.calls.fetch_add(1, Ordering::SeqCst);
+            (0..64).into_par_iter().for_each(|_| std::thread::sleep(std::time::Duration::from_millis(1)));
+            DEPTH.set(d - 1);
+            Some(Arc::new(Image::new(4, 4)))
+        }
+    }
+    let mut s = Session::default();
+    let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 10})).unwrap()["comp"].as_u64().unwrap());
+    let clip = Footage {
+        kind: FootageKind::Video,
+        width: 4,
+        height: 4,
+        has_video: true,
+        frame_rate: FrameRate::FPS_30,
+        duration: Tick::from_seconds_f64(10.0),
+        ..Default::default()
+    };
+    let item = Arc::make_mut(&mut s.project).add_item("clip.mov", Default::default(), None, ItemKind::Footage(clip));
+    s.execute("layer.addItem", json!({"item": item.0})).unwrap();
+    let footage = Arc::new(Parallel::default());
+    let src = RenderSource {
+        project: s.project.clone(),
+        footage: footage.clone(),
+        expr: None,
+        layer_cache: Arc::default(),
+        gpu: None,
+        gpu_display: false,
+        disk: None,
+    };
+    let f = Frames::default();
+    let content = f.content_of(&s.project, s.revision, cid);
+    let frames = 60;
+    for frame in 0..frames {
+        let key = FrameKey { revision: s.revision, content, comp: cid.0, frame, scale: 1000, view: 0, opts: 0 };
+        f.request(&src, key, cid, FrameRate::FPS_30.tick_of(frame), RenderOpts::default());
+    }
+    for _ in 0..4000 {
+        if f.inflight() == 0 {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    assert_eq!(f.inflight(), 0, "every queued frame rendered");
+    assert!(footage.calls.load(Ordering::SeqCst) >= frames as usize);
+    assert_eq!(footage.deepest.load(Ordering::SeqCst), 1, "renders nested on a waiting thread");
+}
+
+/// #329: scrubbing a long movie, the viewer frame of every step the pointer passed started
+/// rendering and seeked the movie's decoder in turn; the frame under the pointer waited for
+/// all of them. A newer viewer frame of another time calls off the one rendering, which is
+/// not cached (its footage may be missing).
+#[test]
+fn a_newer_viewer_frame_calls_off_the_one_rendering() {
+    use effectcraft_engine::Session;
+    use effectcraft_engine::project::{Footage, FootageKind};
+    use effectcraft_engine::render::Image;
+    use effectcraft_engine::time::FrameRate;
+    use serde_json::json;
+    use std::cell::RefCell;
+    thread_local! {
+        static CANCEL: RefCell<Option<Arc<AtomicBool>>> = const { RefCell::new(None) };
+    }
+    /// A movie whose first frames take a long seek, which a called-off read gives up.
+    #[derive(Default)]
+    struct Seeking {
+        seeking: AtomicBool,
+        called_off: AtomicBool,
+    }
+    impl FootageSource for Seeking {
+        fn cancellable(&self, cancel: &Arc<AtomicBool>, f: &mut dyn FnMut()) {
+            let prev = CANCEL.replace(Some(cancel.clone()));
+            f();
+            CANCEL.set(prev);
+        }
+        fn frame(&self, _: ItemId, _: &Footage, t: Tick) -> Option<Arc<Image>> {
+            if t < Tick::from_seconds_f64(0.25) {
+                self.seeking.store(true, Ordering::SeqCst);
+                for _ in 0..1000 {
+                    if CANCEL.with_borrow(|c| c.as_ref().is_some_and(|c| c.load(Ordering::SeqCst))) {
+                        self.called_off.store(true, Ordering::SeqCst);
+                        return None;
+                    }
+                    std::thread::sleep(std::time::Duration::from_millis(5));
+                }
+            }
+            Some(Arc::new(Image::new(4, 4)))
+        }
+    }
+    let mut s = Session::default();
+    let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 10})).unwrap()["comp"].as_u64().unwrap());
+    let clip = Footage {
+        kind: FootageKind::Video,
+        width: 4,
+        height: 4,
+        has_video: true,
+        frame_rate: FrameRate::FPS_30,
+        duration: Tick::from_seconds_f64(10.0),
+        ..Default::default()
+    };
+    let item = Arc::make_mut(&mut s.project).add_item("clip.mov", Default::default(), None, ItemKind::Footage(clip));
+    s.execute("layer.addItem", json!({"item": item.0})).unwrap();
+    let footage = Arc::new(Seeking::default());
+    let src = RenderSource {
+        project: s.project.clone(),
+        footage: footage.clone(),
+        expr: None,
+        layer_cache: Arc::default(),
+        gpu: None,
+        gpu_display: false,
+        disk: None,
+    };
+    let f = Frames::default();
+    let content = f.content_of(&s.project, s.revision, cid);
+    let key = |frame| FrameKey { revision: s.revision, content, comp: cid.0, frame, scale: 1000, view: 0, opts: 0 };
+    f.request_urgent(&src, key(0), cid, Tick::ZERO, RenderOpts::default());
+    for _ in 0..1000 {
+        if footage.seeking.load(Ordering::SeqCst) {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(2));
+    }
+    assert!(footage.seeking.load(Ordering::SeqCst), "the first frame's render reached the footage");
+    f.request_urgent(&src, key(150), cid, FrameRate::FPS_30.tick_of(150), RenderOpts::default());
+    for _ in 0..1000 {
+        if f.inflight() == 0 {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    assert!(footage.called_off.load(Ordering::SeqCst), "the superseded frame's seek ran on");
+    assert!(f.is_cached(&key(150)), "the newest frame rendered");
+    assert!(!f.is_cached(&key(0)), "a called-off frame is not cached");
+    assert_eq!(f.inflight(), 0, "released");
+}
+
+/// #284: scrubbing asks for a viewer frame at every step; a newer one drops the comp's viewer
+/// frames still waiting (they would all render first), but not prefetch frames or another
+/// comp's viewer frame.
+#[test]
+fn a_newer_viewer_frame_drops_the_ones_still_waiting() {
+    /// Starts nothing, so every request stays queued.
+    struct Idle;
+    impl RemoteFrames for Idle {
+        fn slots(&self) -> usize {
+            0
+        }
+        fn start(&self, _: RemoteJob, _: RemoteDone) {}
+    }
+    let mut f = Frames::default();
+    f.set_remote(Some(Arc::new(Idle)));
+    let src = RenderSource {
+        project: Arc::default(),
+        footage: Arc::new(effectcraft_engine::render::NoFootage),
+        expr: None,
+        layer_cache: Arc::default(),
+        gpu: None,
+        gpu_display: false,
+        disk: None,
+    };
+    let request = |k: FrameKey, urgent: bool| {
+        f.request_with(&src, k, ItemId(k.comp), Tick::ZERO, RenderOpts::default(), if urgent { Want::Viewer } else { Want::Prefetch })
+    };
+    let other = FrameKey { comp: 2, ..key(1, 0, 0) };
+    request(other, true);
+    request(key(1, 20, 0), false);
+    for frame in 0..10 {
+        request(key(1, frame, 0), true);
+    }
+    let mut queued: Vec<(u64, i64, bool)> = f.queue.lock().unwrap().jobs.iter().map(|j| (j.key.comp, j.key.frame, j.urgent)).collect();
+    queued.sort();
+    assert_eq!(queued, [(1, 9, true), (1, 20, false), (2, 0, false)]);
+    assert_eq!(f.inflight(), 3, "dropped frames aren't in flight: the viewer can ask again");
+}
+
+/// Each time the GPU runs out of memory, half as many GPU frames are kept, down to a floor.
+#[test]
+fn running_out_of_video_memory_halves_the_gpu_frame_budget() {
+    let f = Frames::default();
+    let mut c = f.cache.lock().unwrap();
+    assert_eq!(c.gpu_budget, GPU_BUDGET);
+    c.gpu_out_of_memory();
+    assert_eq!(c.gpu_budget, GPU_BUDGET / 2);
+    for _ in 0..20 {
+        c.gpu_out_of_memory();
+    }
+    assert_eq!(c.gpu_budget, MIN_GPU_BUDGET);
+}
+
+#[test]
+fn least_recently_shown_frames_go_first() {
+    let f = Frames::default();
+    f.set_budget(3 * 16);
+    for i in 0..3 {
+        insert(&f, key(1, i, 0));
+    }
+    // Frame 0 is shown again, so frame 1 is now the oldest.
+    assert!(f.get(&key(1, 0, 0)).is_some());
+    insert(&f, key(1, 3, 0));
+    assert!(f.is_cached(&key(1, 0, 0)) && !f.is_cached(&key(1, 1, 0)));
+    assert!(f.is_cached(&key(1, 2, 0)) && f.is_cached(&key(1, 3, 0)));
+}
+
+fn playhead(cur: i64, looping: bool) -> Playhead {
+    Playhead { series: key(1, 0, 0), cur, start: 0, end: 99, step: 1, looping }
+}
+
+/// #595: a playing preview's cache is full. The frames just ahead of the playhead were
+/// rendered before the ones just shown, so plain LRU evicted them first and the preview
+/// played into a gap. Frames the preview no longer reaches go first, then the ones it
+/// reaches last.
+#[test]
+fn a_full_cache_keeps_the_frames_just_ahead_of_the_playhead() {
+    let f = Frames::default();
+    f.set_budget(4 * 16);
+    // Prefetch rendered 11..=13, then 10 was shown (the most recently used).
+    for i in [11, 12, 13, 10] {
+        insert(&f, key(1, i, 0));
+    }
+    let cached = |f: &Frames| f.cached_frames(&key(1, 0, 0));
+    f.set_playhead(Some(playhead(10, false)));
+    // The next frame rendered is the one the preview reaches last: the frames just ahead stay.
+    insert(&f, key(1, 14, 0));
+    assert_eq!(cached(&f), [10, 11, 12, 13]);
+    // Without looping, a frame behind the playhead goes before any frame ahead of it.
+    f.set_playhead(Some(playhead(12, false)));
+    insert(&f, key(1, 14, 0));
+    assert_eq!(cached(&f), [10, 12, 13, 14]);
+    // Looping, the frame just behind is the one reached last.
+    f.set_playhead(Some(playhead(13, true)));
+    insert(&f, key(1, 0, 0));
+    assert_eq!(cached(&f), [0, 10, 13, 14]);
+    // Stopped: least recently shown first again.
+    f.set_playhead(None);
+    insert(&f, key(1, 50, 0));
+    assert!(!f.is_cached(&key(1, 13, 0)) && f.is_cached(&key(1, 50, 0)));
+}
+
+/// A frame source that queues jobs and never renders them: the tests check the queue.
+struct Idle;
+impl RemoteFrames for Idle {
+    fn slots(&self) -> usize {
+        0
+    }
+    fn start(&self, _: RemoteJob, _: RemoteDone) {}
+}
+
+fn idle_source() -> RenderSource {
+    RenderSource {
+        project: Arc::default(),
+        footage: Arc::new(effectcraft_engine::render::NoFootage),
+        expr: None,
+        layer_cache: Arc::default(),
+        gpu: None,
+        gpu_display: false,
+        disk: None,
+    }
+}
+
+/// #595: prefetch renders the frames the preview reaches first, whatever order they were
+/// asked for in (a frame evicted and asked for again waited behind every frame further
+/// ahead); queued frames the preview no longer reaches are dropped and not left in flight.
+#[test]
+fn prefetch_renders_the_frames_the_playhead_reaches_first() {
+    let mut f = Frames::default();
+    f.set_remote(Some(Arc::new(Idle)));
+    let src = idle_source();
+    for frame in [40, 30, 20, 5, 12, 11] {
+        f.request(&src, key(1, frame, 0), ItemId(1), Tick::ZERO, RenderOpts::default());
+    }
+    f.request(&src, FrameKey { comp: 2, ..key(1, 1, 0) }, ItemId(2), Tick::ZERO, RenderOpts::default());
+    f.set_playhead(Some(playhead(10, false)));
+    let mut order = vec![];
+    loop {
+        let mut q = f.queue.lock().unwrap();
+        let Some(i) = q.best() else { break };
+        let j = q.jobs.swap_remove(i);
+        order.push((j.key.comp, j.key.frame));
+    }
+    assert_eq!(order, [(1, 11), (1, 12), (1, 20), (1, 30), (1, 40), (2, 1)]);
+    assert_eq!(f.inflight(), 6, "frame 5, behind the playhead, is no longer in flight");
+}
+
+/// A decoder that works in parallel, as the renderer does, in a comp that shows it.
+#[derive(Default)]
+struct ParallelClip {
+    started: std::sync::atomic::AtomicUsize,
+    /// Frames started by the time frame 1 was done.
+    started_at_first: std::sync::atomic::AtomicUsize,
+}
+
+impl FootageSource for ParallelClip {
+    fn frame(&self, _: ItemId, _: &effectcraft_engine::project::Footage, t: Tick) -> Option<Arc<effectcraft_engine::render::Image>> {
+        self.started.fetch_add(1, Ordering::SeqCst);
+        (0..16).into_par_iter().for_each(|_| (0..4).into_par_iter().for_each(|_| std::thread::sleep(std::time::Duration::from_millis(1))));
+        if effectcraft_engine::time::FrameRate::FPS_30.frame_at(t) == 1 {
+            self.started_at_first.store(self.started.load(Ordering::SeqCst), Ordering::SeqCst);
+        }
+        Some(Arc::new(effectcraft_engine::render::Image::new(4, 4)))
+    }
+}
+
+/// A 10 s comp of a [`ParallelClip`]: the frame cache, the clip, the render source, the comp
+/// and the key of its frame 0.
+fn parallel_clip() -> (Frames, Arc<ParallelClip>, RenderSource, ItemId, FrameKey) {
+    use effectcraft_engine::Session;
+    use effectcraft_engine::project::{Footage, FootageKind};
+    use effectcraft_engine::time::FrameRate;
+    use serde_json::json;
+    let mut s = Session::default();
+    let cid = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 10})).unwrap()["comp"].as_u64().unwrap());
+    let clip = Footage {
+        kind: FootageKind::Video,
+        width: 4,
+        height: 4,
+        has_video: true,
+        frame_rate: FrameRate::FPS_30,
+        duration: Tick::from_seconds_f64(10.0),
+        ..Default::default()
+    };
+    let item = Arc::make_mut(&mut s.project).add_item("clip.mov", Default::default(), None, ItemKind::Footage(clip));
+    s.execute("layer.addItem", json!({"item": item.0})).unwrap();
+    let footage = Arc::new(ParallelClip::default());
+    let src = RenderSource {
+        project: s.project.clone(),
+        footage: footage.clone(),
+        expr: None,
+        layer_cache: Arc::default(),
+        gpu: None,
+        gpu_display: false,
+        disk: None,
+    };
+    let f = Frames::default();
+    let series = FrameKey { revision: s.revision, content: f.content_of(&s.project, s.revision, cid), comp: cid.0, frame: 0, scale: 1000, view: 0, opts: 0 };
+    (f, footage, src, cid, series)
+}
+
+fn wait_for_renders(f: &Frames) {
+    for _ in 0..8000 {
+        if f.inflight() == 0 {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    assert_eq!(f.inflight(), 0, "every queued frame rendered");
+}
+
+/// A playing preview's frames render side by side, and each works in parallel: a render
+/// waiting for its own parallel work took over pieces of the frames started after it, and
+/// its frame was done only once theirs were. The frames right ahead of the playhead, started
+/// first, came last: the preview stood still while the frames further ahead turned green.
+/// Cache Frames When Idle left the same gaps.
+#[test]
+fn frames_started_first_are_done_first() {
+    use effectcraft_engine::time::FrameRate;
+    for playing in [true, false] {
+        let (f, footage, src, cid, series) = parallel_clip();
+        let frames = 60;
+        if playing {
+            f.set_playhead(Some(Playhead { series, cur: 0, start: 0, end: 299, step: 1, looping: false }));
+        }
+        for frame in 1..=frames {
+            let (key, t) = (FrameKey { frame, ..series }, FrameRate::FPS_30.tick_of(frame));
+            if playing {
+                f.request(&src, key, cid, t, RenderOpts::default());
+            } else {
+                f.request_background(&src, key, cid, t, RenderOpts::default());
+            }
+            if frame == 1 {
+                // Its parallel work has started (and idle threads have taken pieces of it).
+                std::thread::sleep(std::time::Duration::from_millis(3));
+            }
+        }
+        wait_for_renders(&f);
+        assert_eq!(f.cached_frames(&series).len(), frames as usize);
+        let before = footage.started_at_first.load(Ordering::SeqCst);
+        assert!(before <= 2 * f.parallelism(), "{before} frames were started before the first one was done (playing: {playing})");
+    }
+}
+
+/// Prefetch frames queued when a preview starts or stops, or that become the viewer's
+/// frame, still render: they change hands between the lanes and the pool.
+#[test]
+fn queued_frames_render_when_a_preview_starts_or_stops() {
+    use effectcraft_engine::time::FrameRate;
+    let (f, _, src, cid, series) = parallel_clip();
+    let playhead = Playhead { series, cur: 0, start: 0, end: 299, step: 1, looping: false };
+    let request = |frames: std::ops::Range<i64>| {
+        for frame in frames {
+            f.request(&src, FrameKey { frame, ..series }, cid, FrameRate::FPS_30.tick_of(frame), RenderOpts::default());
+        }
+    };
+    // Queued for the pool, then a preview starts.
+    request(1..40);
+    f.set_playhead(Some(playhead));
+    // Queued for the lanes, then the preview stops.
+    request(40..80);
+    f.set_playhead(None);
+    wait_for_renders(&f);
+    // Queued for the lanes, then the viewer shows one of them.
+    for frame in 80..120 {
+        f.request_background(&src, FrameKey { frame, ..series }, cid, FrameRate::FPS_30.tick_of(frame), RenderOpts::default());
+    }
+    f.request_urgent(&src, FrameKey { frame: 119, ..series }, cid, FrameRate::FPS_30.tick_of(119), RenderOpts::default());
+    wait_for_renders(&f);
+    assert_eq!(f.cached_frames(&series).len(), 119);
+}
+
+/// The cache is full. A zoom (or preview-resolution) change left the frames of the old
+/// size to the plain least-recently-shown order, so the frames of the zoom the viewer is back
+/// at went before the ones of the abandoned zoom. The other size's frames go first, then the
+/// order is as before.
+#[test]
+fn a_size_change_evicts_frames_of_other_sizes_first() {
+    let mut f = Frames::default();
+    f.set_remote(Some(Arc::new(Idle)));
+    f.set_budget(4 * 16);
+    let at = |frame, scale| FrameKey { scale, ..key(1, frame, 0) };
+    // 100% (frames 0..=1) is cached, then 50% (2..=3): the 100% frames are the oldest.
+    for (frame, scale) in [(0, 1000), (1, 1000), (2, 500), (3, 500)] {
+        insert(&f, at(frame, scale));
+    }
+    // A passive viewer at 50% asks for a frame: that doesn't change which size is kept.
+    f.request(&idle_source(), at(9, 500), ItemId(1), Tick::ZERO, RenderOpts::default());
+    // Back at 100%: the viewer asks for frame 4.
+    f.request_urgent(&idle_source(), at(4, 1000), ItemId(1), Tick::ZERO, RenderOpts::default());
+    f.request(&idle_source(), at(10, 500), ItemId(1), Tick::ZERO, RenderOpts::default());
+    insert(&f, at(4, 1000));
+    assert!(
+        f.is_cached(&at(0, 1000)) && f.is_cached(&at(1, 1000)) && !f.is_cached(&at(2, 500)) && f.is_cached(&at(3, 500)),
+        "the first frame of the old size goes, not the cached ones of the current size"
+    );
+    insert(&f, at(5, 1000));
+    assert!(!f.is_cached(&at(3, 500)), "then the last frame of the old size");
+    assert_eq!(f.cached_frames(&at(0, 1000)), [0, 1, 4, 5]);
+    // No other size left: least recently shown first again.
+    insert(&f, at(6, 1000));
+    assert_eq!(f.cached_frames(&at(0, 1000)), [1, 4, 5, 6]);
+}
+
+#[test]
+fn frames_are_keyed_by_content_and_series_are_kept_apart() {
+    let f = Frames::default();
+    insert(&f, key(1, 0, 0));
+    insert(&f, key(2, 0, 0));
+    insert(&f, key(2, 1, 7));
+    // Other content or render options (Draft, shadows…) are another series.
+    assert_eq!(f.cached_frames(&key(2, 0, 0)), vec![0]);
+    assert_eq!(f.cached_frames(&key(2, 0, 7)), vec![1]);
+    // A later revision with the same content finds the frame (an edit elsewhere, an undo).
+    assert!(f.is_cached(&FrameKey { revision: 99, ..key(1, 0, 0) }));
+    assert!(!f.is_cached(&key(3, 0, 0)));
+}
+
+#[test]
+fn live_edits_present_the_newest_completed_revision_without_going_backwards() {
+    let f = Frames::default();
+    let shown = key(1, 0, 0);
+    let newest = key(3, 0, 0);
+    let wanted = key(5, 0, 0);
+    insert(&f, shown);
+    insert(&f, newest);
+    insert(&f, key(2, 0, 0)); // Older worker finishes after the newer one.
+    let displayed = f.get_for_viewer(&wanted, Some(&shown)).unwrap().0;
+    assert_eq!(displayed, newest);
+    assert!(f.get_for_viewer(&wanted, Some(&displayed)).is_none(), "never replay an older completion");
+    insert(&f, wanted);
+    assert_eq!(f.get_for_viewer(&wanted, Some(&displayed)).unwrap().0, wanted, "settle on the exact final edit");
+    // Undo reuses the content of an earlier revision immediately.
+    let undo = FrameKey { revision: 6, ..shown };
+    let reused = f.get_for_viewer(&undo, Some(&wanted)).unwrap().0;
+    assert_eq!(reused.content, shown.content);
+    assert_eq!(reused.revision, undo.revision);
+}
+
+#[test]
+fn live_edits_do_not_substitute_other_times_views_or_render_settings() {
+    let f = Frames::default();
+    let shown = key(1, 0, 0);
+    let wanted = key(3, 0, 0);
+    let done = key(2, 0, 0);
+    for mismatch in [
+        FrameKey { comp: 9, ..done },
+        FrameKey { frame: 1, ..done },
+        FrameKey { scale: 500, ..done },
+        FrameKey { view: 1, ..done },
+        FrameKey { opts: 1, ..done },
+        FrameKey { revision: 4, ..done },
+    ] {
+        f.clear();
+        insert(&f, mismatch);
+        assert!(f.get_for_viewer(&wanted, Some(&shown)).is_none(), "wrong candidate: {mismatch:?}");
+    }
+    f.clear();
+    insert(&f, done);
+    assert!(f.get_for_viewer(&wanted, None).is_none(), "no stale content on opening a viewer");
+    assert!(f.get_for_viewer(&wanted, Some(&FrameKey { comp: 9, ..shown })).is_none());
+    assert!(f.get_for_viewer(&wanted, Some(&FrameKey { frame: 1, ..shown })).is_none());
+    assert!(f.get_for_viewer(&wanted, Some(&FrameKey { view: 1, ..shown })).is_none());
+}
+
+#[test]
+fn an_edit_keeps_the_frames_of_comps_it_does_not_touch() {
+    use effectcraft_engine::Session;
+    use serde_json::json;
+    let mut s = Session::default();
+    let a = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
+    let b = ItemId(s.execute("comp.new", json!({"name": "B", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
+    let f = Frames::default();
+    let at = |s: &Session, c: ItemId| f.content_of(&s.project, s.revision, c);
+    let (a0, b0) = (at(&s, a), at(&s, b));
+    // Edit B: A's content (and frames) stay, B's change.
+    s.execute("layer.newSolid", json!({"comp": b.0, "color": "#ff0000"})).unwrap();
+    assert_eq!(at(&s, a), a0);
+    assert_ne!(at(&s, b), b0);
+    // Undo: B is back to the content its old frames were rendered for.
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(at(&s, b), b0);
+}
+
+#[test]
+fn a_long_drag_keeps_a_bounded_number_of_states() {
+    use effectcraft_engine::Session;
+    use serde_json::json;
+    let mut s = Session::default();
+    let a = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
+    let f = Frames::default();
+    let mut last = None;
+    for i in 0..200 {
+        s.execute("comp.settings", json!({"width": 8 + i, "merge": "drag"})).unwrap();
+        let k = FrameKey { content: f.content_of(&s.project, s.revision, a), ..key(0, 0, 0) };
+        insert(&f, k);
+        last = Some(k);
+    }
+    // The snapshots and the frames kept stay bounded (a dropped identity's frames go with it,
+    // so a later state that reuses its addresses can't be shown an old frame).
+    assert!(f.keepers.lock().unwrap().1.len() <= MAX_KEEPERS);
+    assert!(f.cache.lock().unwrap().map.len() <= MAX_KEEPERS);
+    assert!(f.is_cached(&last.unwrap()), "the current state's frame stays");
+}
+
+#[test]
+fn an_identity_keeps_its_comps_so_an_edit_in_place_still_changes_it() {
+    use effectcraft_engine::Session;
+    use serde_json::json;
+    let mut s = Session::default();
+    let a = ItemId(s.execute("comp.new", json!({"name": "A", "width": 8, "height": 8, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
+    // A project nothing else holds (no undo history): make_mut would edit the comp in place,
+    // at the same address, if the identity hadn't kept a snapshot holding it.
+    let mut p = Arc::new((*s.project).clone());
+    drop(s);
+    let f = Frames::default();
+    let before = f.content_of(&p, 1, a);
+    let comp = Arc::make_mut(&mut p).comp_mut(a).unwrap();
+    comp.width = 16;
+    assert_ne!(f.content_of(&p, 2, a), before);
+}
+
+/// Audio, Lock and Shy (and Hide Shy Layers) don't change pixels: toggling them, in the comp
+/// or a comp it nests, keeps its frames, also when toggled back (#103).
+#[test]
+fn audio_lock_and_shy_switches_keep_the_frames() {
+    use effectcraft_engine::Session;
+    use serde_json::json;
+    let mut s = Session::default();
+    let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
+    let inner = ItemId(id(s.execute("comp.new", json!({"name": "Inner", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
+    let solid = id(s.execute("layer.newSolid", json!({"comp": inner.0, "color": "#ff0000"})).unwrap(), "layer");
+    let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
+    let nested = id(s.execute("layer.addItem", json!({"comp": outer.0, "item": inner.0})).unwrap(), "layer");
+    let f = Frames::default();
+    let at = |s: &Session| f.content_of(&s.project, s.revision, outer);
+    let o0 = at(&s);
+    let switch = |s: &mut Session, comp: ItemId, layer: u64, sw: &str, v: bool| {
+        s.execute("layer.setSwitch", json!({"comp": comp.0, "layers": [layer], "switch": sw, "value": v})).unwrap();
+    };
+    for (comp, layer, sw) in [(outer, nested, "audio"), (outer, nested, "lock"), (outer, nested, "shy"), (inner, solid, "audio"), (inner, solid, "shy")] {
+        // Audio off; Lock and Shy on.
+        switch(&mut s, comp, layer, sw, sw != "audio");
+        assert_eq!(at(&s), o0, "{sw} on in {comp:?}");
+    }
+    s.execute("comp.setSwitch", json!({"comp": outer.0, "switch": "hideShy", "value": true})).unwrap();
+    assert_eq!(at(&s), o0, "Hide Shy Layers");
+    switch(&mut s, outer, nested, "audio", true);
+    switch(&mut s, outer, nested, "lock", false);
+    assert_eq!(at(&s), o0, "toggled back");
+    // Switches that change pixels still do.
+    switch(&mut s, inner, solid, "video", false);
+    let o1 = at(&s);
+    assert_ne!(o1, o0, "Video");
+    switch(&mut s, outer, nested, "audio", false);
+    assert_eq!(at(&s), o1, "a mute after a real edit keeps that edit's frames");
+    switch(&mut s, inner, solid, "video", true);
+    assert_ne!(at(&s), o1);
+}
+
+/// A cut or trim recaches only the frames of the layers it touched (#1641), and none are
+/// kept when the change reaches other layers (here a child of the trimmed layer).
+#[test]
+fn an_edit_keeps_the_frames_outside_the_layers_it_changed() {
+    use effectcraft_engine::Session;
+    use serde_json::json;
+    let mut s = Session::default();
+    let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
+    let comp = ItemId(id(s.execute("comp.new", json!({"name": "Edit", "width": 8, "height": 8, "duration": 10})).unwrap(), "comp"));
+    let a = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap(), "layer");
+    let b = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#00ff00"})).unwrap(), "layer");
+    s.execute("layer.timing", json!({"layers": [a], "in": 0, "out": 4})).unwrap();
+    s.execute("layer.timing", json!({"layers": [b], "in": 4, "out": 10})).unwrap();
+    let (fr, out) = s.project.comp(comp).map(|c| (c.frame_rate, c.layers.iter().find(|l| l.id.0 == a).unwrap().out_point)).unwrap();
+    let frames: Vec<i64> = (0..fr.frame_at(Tick::from_seconds_f64(10.0))).collect();
+    let f = Frames::default();
+    let cache_all = |s: &Session| {
+        let c = f.content_of(&s.project, s.revision, comp);
+        frames.iter().for_each(|&n| insert(&f, key(c, n, 0)));
+        c
+    };
+    let cached = |c: u64| frames.iter().filter(|&&n| f.is_cached(&key(c, n, 0))).copied().collect::<Vec<_>>();
+    let before = cache_all(&s);
+    s.execute("time.set", json!({"time": 2.0})).unwrap();
+    s.execute("edit.splitLayer", json!({"layers": [a]})).unwrap();
+    let after = f.content_of(&s.project, s.revision, comp);
+    assert_ne!(after, before);
+    let kept: Vec<i64> = (fr.frame_at(out) + 2..frames.len() as i64).collect();
+    assert_eq!(cached(after), kept, "the cut layer's frames (and one either side) render again; the rest stay");
+
+    s.execute("layer.setParent", json!({"layers": [b], "parent": a})).unwrap();
+    let parented = cache_all(&s);
+    s.execute("layer.timing", json!({"layers": [a], "out": 1})).unwrap();
+    assert_eq!(cached(f.content_of(&s.project, s.revision, comp)), Vec::<i64>::new(), "the trimmed layer's child moves everywhere");
+    assert_eq!(cached(parented).len(), frames.len(), "the earlier frames stay for undo");
+}
+
+/// Every frame an edit keeps renders as a fresh render of the edited project does: Solo
+/// hides the other layers at every frame, and a camera reaches the frames whose shutter
+/// samples it (#1641 review).
+#[test]
+fn the_frames_an_edit_keeps_match_a_fresh_render() {
+    use effectcraft_engine::Session;
+    use effectcraft_engine::render::NoFootage;
+    use serde_json::json;
+    // Cache every frame of `comp`, run `edit`, check the frames kept against fresh renders.
+    fn kept(s: &mut Session, comp: ItemId, edit: serde_json::Value) -> Vec<i64> {
+        let (fr, n) = s.project.comp(comp).map(|c| (c.frame_rate, c.frame_rate.frame_at(c.duration))).unwrap();
+        let f = Frames::default();
+        let before = f.content_of(&s.project, s.revision, comp);
+        (0..n).for_each(|i| insert(&f, key(before, i, 0)));
+        let old = s.project.clone();
+        s.execute(edit["cmd"].as_str().unwrap(), edit["params"].clone()).unwrap();
+        let after = f.content_of(&s.project, s.revision, comp);
+        let kept: Vec<i64> = (0..n).filter(|&i| f.is_cached(&key(after, i, 0))).collect();
+        let render = |p, i| Renderer::new(p, &NoFootage, RenderOpts::default()).comp_frame(comp, fr.tick_of(i));
+        for &i in &kept {
+            assert_eq!(render(&old, i), render(&s.project, i), "kept frame {i} draws other pixels now");
+        }
+        kept
+    }
+    let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
+    let mut s = Session::default();
+
+    // Solo on a 2–3 s layer hides the 10 s underlay everywhere; turning it off shows it again.
+    let comp = ItemId(id(s.execute("comp.new", json!({"name": "Solo", "width": 8, "height": 8, "duration": 10})).unwrap(), "comp"));
+    s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap();
+    let short = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#00ff00"})).unwrap(), "layer");
+    s.execute("layer.timing", json!({"layers": [short], "in": 2, "out": 3})).unwrap();
+    let solo = |on: bool| json!({"cmd": "layer.setSwitch", "params": {"layers": [short], "switch": "solo", "value": on}});
+    assert_eq!(kept(&mut s, comp, solo(true)), Vec::<i64>::new());
+    assert_eq!(kept(&mut s, comp, solo(false)), Vec::<i64>::new());
+
+    // A 2–3 s camera over a 4 s motion-blurred 3D layer, shutter 720° at phase 360°: a frame
+    // samples 1 to 3 frames ahead, so moving the camera reaches the 3 frames before it.
+    let comp = ItemId(id(
+        s.execute("comp.new", json!({"name": "Cam", "width": 16, "height": 16, "duration": 4, "frameRate": 30, "shutterAngle": 720, "shutterPhase": 360}))
+            .unwrap(),
+        "comp",
+    ));
+    let plane = id(s.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap(), "layer");
+    for sw in ["threeD", "motionBlur"] {
+        s.execute("layer.setSwitch", json!({"layers": [plane], "switch": sw, "value": true})).unwrap();
+    }
+    let cam = id(s.execute("layer.newCamera", json!({"comp": comp.0})).unwrap(), "layer");
+    s.execute("layer.timing", json!({"layers": [cam], "in": 2, "out": 3})).unwrap();
+    let moved = kept(&mut s, comp, json!({"cmd": "prop.set", "params": {"comp": comp.0, "layer": cam, "path": "transform/position", "value": [40, 8, -30]}}));
+    assert!(moved.contains(&0) && moved.contains(&100), "frames far from the camera stay: {moved:?}");
+    assert!(!(56..=91).any(|f| moved.contains(&f)), "frames whose shutter samples the camera render again: {moved:?}");
+}
+
+#[test]
+fn short_solid_additions_and_removals_keep_unaffected_frames() {
+    use effectcraft_engine::Session;
+    use serde_json::json;
+    let mut s = Session::default();
+    let comp = ItemId(s.execute("comp.new", json!({"width": 8, "height": 8, "frameRate": 30, "duration": 20})).unwrap()["comp"].as_u64().unwrap());
+    s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
+    let f = Frames::default();
+    let cache_all = |s: &Session| {
+        let content = f.content_of(&s.project, s.revision, comp);
+        (0..600).for_each(|n| insert(&f, key(content, n, 0)));
+    };
+    let cached = |s: &Session| f.cached_frames(&key(f.content_of(&s.project, s.revision, comp), 0, 0));
+    // 2–3 s, a quarter frame of the default shutter and a frame of rounding either side.
+    let kept: Vec<i64> = (0..=57).chain(92..600).collect();
+    cache_all(&s);
+    let solid = s.execute("layer.newSolid", json!({"color": "#00ff00"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.timing", json!({"layers": [solid], "in": 2, "out": 3})).unwrap();
+    assert_eq!(cached(&s), kept, "adding a source invalidates only frames 58..=91");
+    cache_all(&s);
+    s.execute("edit.undo", json!({})).unwrap();
+    s.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(cached(&s), (0..600).collect::<Vec<_>>(), "undoing the addition restores every frame");
+    s.execute("edit.redo", json!({})).unwrap();
+    s.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(cached(&s), (0..600).collect::<Vec<_>>(), "redoing the addition restores every frame");
+    s.execute("edit.clear", json!({"layers": [solid]})).unwrap();
+    assert_eq!(cached(&s), kept, "removing its layer invalidates the same span");
+}
+
+#[test]
+fn adding_a_source_does_not_hide_changes_to_existing_dependencies() {
+    use effectcraft_engine::Session;
+    use serde_json::json;
+    for (command, params) in [
+        ("layer.settings", json!({"comp": "Outer", "layer": "Underlay", "color": "#0000ff"})),
+        ("prop.set", json!({"comp": "Inner", "layer": "Inner solid", "path": "transform/opacity", "value": 40})),
+    ] {
+        let mut s = Session::default();
+        let comp = ItemId(
+            s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "frameRate": 30, "duration": 20})).unwrap()["comp"].as_u64().unwrap(),
+        );
+        s.execute("layer.newSolid", json!({"name": "Underlay", "color": "#ff0000"})).unwrap();
+        s.execute("comp.new", json!({"name": "Inner", "width": 8, "height": 8, "duration": 20})).unwrap();
+        s.execute("layer.newSolid", json!({"name": "Inner solid", "color": "#00ff00"})).unwrap();
+        s.execute("comp.open", json!({"comp": "Outer"})).unwrap();
+        s.execute("layer.addItem", json!({"item": "Inner"})).unwrap();
+        let f = Frames::default();
+        let before = f.content_of(&s.project, s.revision, comp);
+        (0..600).for_each(|n| insert(&f, key(before, n, 0)));
+        s.execute(command, params).unwrap();
+        let solid = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
+        s.execute("layer.timing", json!({"layers": [solid], "in": 2, "out": 3})).unwrap();
+        let after = f.content_of(&s.project, s.revision, comp);
+        assert!(f.cached_frames(&key(after, 0, 0)).is_empty(), "{command} changes pixels outside the added layer");
+    }
+}
+
+/// Adding, moving or deleting a marker (Num* while a preview plays) keeps the cached frames:
+/// the sound would otherwise stop at the next frame that has to be rendered again (#1083).
+/// Only expressions that read markers make them part of the pixels.
+#[test]
+fn markers_keep_the_frames_unless_an_expression_reads_them() {
+    use effectcraft_engine::Session;
+    use serde_json::json;
+    let mut s = Session::default();
+    let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
+    let inner = ItemId(id(s.execute("comp.new", json!({"name": "Inner", "width": 8, "height": 8, "duration": 2})).unwrap(), "comp"));
+    let solid = id(s.execute("layer.newSolid", json!({"comp": inner.0, "color": "#ff0000"})).unwrap(), "layer");
+    let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "duration": 2})).unwrap(), "comp"));
+    id(s.execute("layer.addItem", json!({"comp": outer.0, "item": inner.0})).unwrap(), "layer");
+    let f = Frames::default();
+    let at = |s: &Session, c: ItemId| f.content_of(&s.project, s.revision, c);
+    let (o0, i0) = (at(&s, outer), at(&s, inner));
+    s.execute("comp.addMarker", json!({"comp": inner.0, "time": 0.5, "comment": "beat"})).unwrap();
+    s.execute("comp.addMarker", json!({"comp": outer.0, "time": 1.0})).unwrap();
+    s.execute("comp.addMarker", json!({"comp": outer.0, "time": 1.5})).unwrap();
+    assert_eq!((at(&s, outer), at(&s, inner)), (o0, i0), "comp markers");
+    s.execute("markers.set", json!({"comp": inner.0, "layer": solid, "new": true, "time": 0.25})).unwrap();
+    assert_eq!((at(&s, outer), at(&s, inner)), (o0, i0), "layer marker");
+    // An expression reading markers makes them count again.
+    s.execute("prop.setExpression", json!({"comp": inner.0, "layer": solid, "path": "transform/opacity", "expression": "thisComp.marker.numKeys"})).unwrap();
+    let (o1, i1) = (at(&s, outer), at(&s, inner));
+    assert_ne!(o1, o0);
+    s.execute("comp.addMarker", json!({"comp": inner.0, "time": 1.0})).unwrap();
+    assert_ne!(at(&s, inner), i1, "marker read by an expression");
+    assert_ne!(at(&s, outer), o1, "marker read by an expression in a nested comp");
+}
+
+/// A protected time marker with a duration sets the comp's timing (Responsive Design), so it
+/// changes the frames even though plain markers do not; and any expression, which can read
+/// markers, makes every marker count.
+#[test]
+fn timing_markers_and_expressions_still_change_the_frames() {
+    use effectcraft_engine::Session;
+    use serde_json::json;
+    let mut s = Session::default();
+    let id = |v: serde_json::Value, k: &str| v[k].as_u64().unwrap();
+    let outer = ItemId(id(s.execute("comp.new", json!({"name": "Outer", "width": 8, "height": 8, "duration": 1})).unwrap(), "comp"));
+    let solid = id(s.execute("layer.newSolid", json!({"comp": outer.0, "color": "#ff0000"})).unwrap(), "layer");
+    let f = Frames::default();
+    let at = |s: &Session| f.content_of(&s.project, s.revision, outer);
+    let o0 = at(&s);
+    s.execute("layer.addMarker", json!({"comp": outer.0, "layers": [solid], "time": 0.5, "comment": "beat"})).unwrap();
+    assert_eq!(at(&s), o0, "a plain marker changes no pixels, so it keeps the frames");
+    s.execute("comp.addMarker", json!({"comp": outer.0, "time": 0.25})).unwrap();
+    s.execute("markers.set", json!({"comp": outer.0, "index": 0, "duration": 0.25, "protected": true})).unwrap();
+    let o1 = at(&s);
+    assert_ne!(o1, o0, "a protected time marker with a duration sets the timing");
+    s.execute("prop.setExpression", json!({"comp": outer.0, "layer": solid, "path": "transform/opacity", "expression": "1"})).unwrap();
+    let o2 = at(&s);
+    s.execute("layer.addMarker", json!({"comp": outer.0, "layers": [solid], "time": 0.75})).unwrap();
+    assert_ne!(at(&s), o2, "an expression can read the marker, so the frames change");
+}
diff --git a/crates/ui-egui/src/header.rs b/crates/ui-egui/src/header.rs
index 2ad3dd20f..140a0bbaf 100644
--- a/crates/ui-egui/src/header.rs
+++ b/crates/ui-egui/src/header.rs
@@ -12,20 +12,33 @@ use crate::widgets;
 use crate::{Dialog, EffectcraftApp};
 use effectcraft_color::BlendMode;
 use effectcraft_engine::commands::shape_tool::{PaintKind, ToolPaint};
+use effectcraft_engine::geom::vec2 as gv2;
 use effectcraft_engine::project::{LayerId, LayerSource, PropGroup};
 use effectcraft_engine::viewer as vw;
 
+/// Draws the Tools bar into `rect`: brand (About), Home, the tool slots with their fly-out
+/// menus and press-and-hold picks, options for the active tool (shape paint, puppet, roto),
+/// Snapping, then Discord, GitHub, website, appearance and workspace controls. Clicks apply
+/// tool, dialog, theme and workspace changes to `app` or run their commands.
 pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let p = ui.painter().clone();
     p.rect_filled(rect, 0.0, t.header_bg);
     p.line_segment([rect.left_bottom(), rect.right_bottom()], Stroke::new(1.0, t.app_bg));
     let cy = rect.center().y;
-    let mut x = rect.min.x + if app.integrated_titlebar && !app.ui.show_menu_bar { 80.0 } else { 10.0 };
+    let x = rect.min.x + if app.integrated_titlebar && !app.ui.show_menu_bar { 80.0 } else { 10.0 };
+    let x = brand_and_home(app, ui, &p, x, cy);
+    let x = tool_slots(app, ui, &p, x, cy);
+    let x = tool_options_bar(app, ui, &p, x + 10.0, cy);
+    let x = snapping_toggle(app, ui, &p, x, cy);
+    right_side(app, ui, &p, rect, x, cy);
+}
 
-    // Brand mark.
+/// The brand mark (About) and the Home button; returns the x after them.
+fn brand_and_home(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, mut x: f32, cy: f32) -> f32 {
+    let t = app.tokens;
     let brand = Rect::from_min_size(pos2(x, cy - 12.0), vec2(24.0, 24.0));
-    paint_logo(&p, brand);
+    paint_logo(p, brand);
     let bresp = ui.interact(brand, egui::Id::unique("brand"), Sense::click());
     app.auto.add_response("header.about", &bresp, "About EffectCraft");
     widgets::focus_outline(ui, &bresp, &t);
@@ -34,7 +47,6 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     x += 32.0;
 
-    // Home.
     let home = Rect::from_min_size(pos2(x, cy - 13.0), vec2(26.0, 26.0));
     let home_response = widgets::icon_button(ui, home, Icon::Home, app.ui.start_screen, &t, egui::Id::unique("tool-home")).on_hover_text(tr("Home"));
     app.auto.add_response("header.home", &home_response, "Home");
@@ -43,78 +55,19 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     x += 30.0;
     p.line_segment([pos2(x, cy - 10.0), pos2(x, cy + 10.0)], Stroke::new(1.0, t.separator));
-    x += 6.0;
+    x + 6.0
+}
 
-    // Tool slots (with group separators after camera tools and pan-behind).
+/// The tool slots (with group separators after camera tools and pan-behind); returns the x after them.
+fn tool_slots(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, mut x: f32, cy: f32) -> f32 {
+    let t = app.tokens;
     let held_id = egui::Id::unique("tool-slot-held");
     if ui.input(|i| i.pointer.any_pressed()) {
         ui.data_mut(|d| d.remove::<egui::Id>(held_id));
     }
     for (si, slot) in Tool::SLOTS.iter().enumerate() {
-        let cur = app.ui.slot_tools.get(si).copied().unwrap_or(slot[0]);
         let r = Rect::from_min_size(pos2(x, cy - 13.0), vec2(26.0, 26.0));
-        let active = slot.contains(&app.ui.tool);
-        let id = egui::Id::unique(("tool-slot", si));
-        let resp = widgets::icon_button(ui, r, cur.icon(), active, &t, id);
-        if slot.len() > 1 {
-            // Flyout corner triangle.
-            p.add(egui::Shape::convex_polygon(
-                vec![pos2(r.max.x - 2.0, r.max.y - 6.0), pos2(r.max.x - 2.0, r.max.y - 2.0), pos2(r.max.x - 6.0, r.max.y - 2.0)],
-                if active { Color32::WHITE } else { t.text_dim },
-                Stroke::NONE,
-            ));
-        }
-        app.auto.add_response(&format!("tools.{cur:?}"), &resp, cur.label());
-        let tip = match cur.shortcut() {
-            Some(s) => format!("{} ({})", cur.label(), crate::menus::shortcut_text(s)),
-            None => cur.label().to_string(),
-        };
-        let resp = resp.on_hover_text(tip);
-        let held = ui.data(|d| d.get_temp::<egui::Id>(held_id)) == Some(id);
-        if resp.clicked() && !held {
-            app.ui.tool = cur;
-        }
-        // Ctrl+double-click Pan Behind: Center Anchor Point in Layer Content.
-        if cur == Tool::PanBehind
-            && resp.double_clicked()
-            && ui.input(|i| i.modifiers.command)
-            && let Err(e) = crate::menus::invoke(app, ui.ctx(), "layer.centerAnchor", json!({}))
-        {
-            app.ui.status = e;
-        }
-        if slot.len() > 1 {
-            let held_for = resp.is_pointer_button_down_on().then(|| ui.input(|i| i.pointer.press_start_time().map(|s| i.time - s))).flatten();
-            if let Some(seconds) = held_for
-                && seconds < 0.35
-            {
-                ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(0.35 - seconds));
-            }
-            let long_press = held_for.is_some_and(|seconds| seconds >= 0.35) && !held;
-            let command = if resp.secondary_clicked() || long_press {
-                if long_press {
-                    ui.data_mut(|d| d.insert_temp(held_id, id));
-                }
-                Some(egui::SetOpenCommand::Bool(true))
-            } else if resp.clicked() && !held {
-                Some(egui::SetOpenCommand::Bool(false))
-            } else {
-                None
-            };
-            let close_behavior = if held && resp.clicked() { egui::PopupCloseBehavior::IgnoreClicks } else { egui::PopupCloseBehavior::CloseOnClickOutside };
-            egui::Popup::menu(&resp).style(crate::widgets::menu_style).open_memory(command).close_behavior(close_behavior).show(|ui| {
-                for tool in slot.iter() {
-                    let row = ui.selectable_label(app.ui.tool == *tool, tool.label());
-                    app.auto.add(&format!("tools.select.{tool:?}"), row.rect, tool.label());
-                    if row.clicked() {
-                        app.ui.tool = *tool;
-                        if let Some(saved) = app.ui.slot_tools.get_mut(si) {
-                            *saved = *tool;
-                        }
-                        ui.close();
-                    }
-                }
-            });
-        }
+        tool_slot(app, ui, p, si, slot, r, held_id);
         x += 28.0;
         if matches!(si, 2 | 5 | 7 | 10 | 13) {
             x += 4.0;
@@ -122,17 +75,148 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             x += 6.0;
         }
     }
+    x
+}
 
-    // Tool options.
-    x += 10.0;
-    // Selected shape layers: the options show their paint and edit it (as in After Effects).
-    let shape_layers: Vec<u64> = app
-        .session
+/// One tool slot button in `r`: select on click, Ctrl+double-click Pan Behind, and the fly-out.
+fn tool_slot(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, si: usize, slot: &[Tool], r: Rect, held_id: egui::Id) {
+    let t = app.tokens;
+    let cur = app.ui.slot_tools.get(si).copied().unwrap_or(slot[0]);
+    let active = slot.contains(&app.ui.tool);
+    let id = egui::Id::unique(("tool-slot", si));
+    let resp = widgets::icon_button(ui, r, cur.icon(), active, &t, id);
+    if slot.len() > 1 {
+        // Flyout corner triangle.
+        p.add(egui::Shape::convex_polygon(
+            vec![pos2(r.max.x - 2.0, r.max.y - 6.0), pos2(r.max.x - 2.0, r.max.y - 2.0), pos2(r.max.x - 6.0, r.max.y - 2.0)],
+            if active { Color32::WHITE } else { t.text_dim },
+            Stroke::NONE,
+        ));
+    }
+    app.auto.add_response(&format!("tools.{cur:?}"), &resp, cur.label());
+    // The drawn tooltip asks the catalog; the automation label above keeps the English name.
+    let label = crate::i18n::tr(cur.label());
+    let tip = match cur.shortcut() {
+        Some(s) => format!("{} ({})", label, crate::menus::shortcut_text(s)),
+        None => label.to_string(),
+    };
+    let resp = resp.on_hover_text(tip);
+    let held = ui.data(|d| d.get_temp::<egui::Id>(held_id)) == Some(id);
+    // Plain click selects the shown tool; Alt/Option-click cycles the flyout slot
+    // (After Effects / Photoshop parity with the Shift+letter key cycle).
+    // Prefer the primary-release event's modifiers: Alt may already be up by the
+    // time this frame reads i.modifiers. When a double-click lands as two releases
+    // in one frame, the earlier release is the first click.
+    let releases: Vec<egui::Modifiers> = ui.input(|i| {
+        i.events
+            .iter()
+            .filter_map(|e| match e {
+                egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, modifiers, .. } if resp.rect.contains(*pos) => {
+                    Some(*modifiers)
+                }
+                _ => None,
+            })
+            .collect()
+    });
+    let click_mods = releases.last().copied().unwrap_or_else(|| ui.input(|i| i.modifiers));
+    let alt = click_mods.alt;
+    let modified = click_mods.alt || click_mods.shift || click_mods.ctrl || click_mods.command;
+    // egui's double-click ignores modifiers: remember whether the previous click
+    // was modified so create-on-double-click only runs for two plain clicks.
+    let prev_mod_id = id.with("click-mod");
+    let prev_modified = match releases.len() {
+        n if n >= 2 => {
+            let m = releases[n - 2];
+            m.alt || m.shift || m.ctrl || m.command
+        }
+        _ => ui.data(|d| d.get_temp::<bool>(prev_mod_id)).unwrap_or(false),
+    };
+    let slot_click = resp.clicked() && !held;
+    if slot_click {
+        let pick = if slot.len() > 1 && alt {
+            let from = if slot.contains(&app.ui.tool) { app.ui.tool } else { cur };
+            let i = slot.iter().position(|t| *t == from).unwrap_or(0);
+            slot[(i + 1) % slot.len()]
+        } else {
+            cur
+        };
+        app.ui.tool = pick;
+        if let Some(saved) = app.ui.slot_tools.get_mut(si) {
+            *saved = pick;
+        }
+    }
+    // Ctrl+double-click Pan Behind: Center Anchor Point in Layer Content.
+    if cur == Tool::PanBehind
+        && resp.double_clicked()
+        && click_mods.command
+        && let Err(e) = crate::menus::invoke(app, ui.ctx(), "layer.centerAnchor", json!({}))
+    {
+        app.ui.status = e;
+    } else if resp.double_clicked()
+        && !modified
+        && !prev_modified
+        && let Some((id, params)) = create_on_double_click(app, cur)
+        && let Err(e) = crate::menus::invoke(app, ui.ctx(), id, params)
+    {
+        app.ui.status = e;
+    }
+    if slot_click {
+        ui.data_mut(|d| d.insert_temp(prev_mod_id, modified));
+    }
+    if slot.len() > 1 {
+        slot_flyout(app, ui, si, slot, &resp, held_id);
+    }
+}
+
+/// The fly-out menu of a multi-tool slot: right-click or press-and-hold opens it.
+fn slot_flyout(app: &mut EffectcraftApp, ui: &mut egui::Ui, si: usize, slot: &[Tool], resp: &egui::Response, held_id: egui::Id) {
+    let id = resp.id;
+    let held = ui.data(|d| d.get_temp::<egui::Id>(held_id)) == Some(id);
+    let held_for = resp.is_pointer_button_down_on().then(|| ui.input(|i| i.pointer.press_start_time().map(|s| i.time - s))).flatten();
+    if let Some(seconds) = held_for
+        && seconds < 0.35
+    {
+        ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(0.35 - seconds));
+    }
+    let long_press = held_for.is_some_and(|seconds| seconds >= 0.35) && !held;
+    let command = if resp.secondary_clicked() || long_press {
+        if long_press {
+            ui.data_mut(|d| d.insert_temp(held_id, id));
+        }
+        Some(egui::SetOpenCommand::Bool(true))
+    } else if resp.clicked() && !held {
+        Some(egui::SetOpenCommand::Bool(false))
+    } else {
+        None
+    };
+    let close_behavior = if held && resp.clicked() { egui::PopupCloseBehavior::IgnoreClicks } else { egui::PopupCloseBehavior::CloseOnClickOutside };
+    egui::Popup::menu(resp).style(crate::widgets::menu_style).open_memory(command).close_behavior(close_behavior).show(|ui| {
+        for tool in slot.iter() {
+            let row = ui.selectable_label(app.ui.tool == *tool, crate::i18n::tr(tool.label()));
+            app.auto.add(&format!("tools.select.{tool:?}"), row.rect, tool.label());
+            if row.clicked() {
+                app.ui.tool = *tool;
+                if let Some(saved) = app.ui.slot_tools.get_mut(si) {
+                    *saved = *tool;
+                }
+                ui.close();
+            }
+        }
+    });
+}
+
+/// The ids of the selected shape layers: the options show their paint and edit it.
+fn selected_shape_layers(app: &EffectcraftApp) -> Vec<u64> {
+    app.session
         .active_comp()
         .map(|c| {
             app.session.state.selected_layers.iter().filter(|id| c.layer(**id).is_some_and(|l| matches!(l.source, LayerSource::Shape))).map(|id| id.0).collect()
         })
-        .unwrap_or_default();
+        .unwrap_or_default()
+}
+
+/// Mirrors the first selected shape layer's paint into the shape tool (as in After Effects).
+fn sync_layer_paint(app: &mut EffectcraftApp, shape_layers: &[u64]) {
     let layer_paint = shape_layers.first().and_then(|id| app.session.active_comp()?.layer(LayerId(*id))).map(|l| {
         let lt = l.layer_time(app.session.time());
         (effectcraft_engine::commands::shape_stroke::first_paint(l, lt), effectcraft_engine::commands::shape_stroke::first_paint_kinds(l, lt))
@@ -150,6 +234,13 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
         tool.stroke_width = width.unwrap_or(0.0);
     }
+}
+
+/// Options for the active tool (shape creation, fill and stroke, puppet, roto); returns the x after them.
+fn tool_options_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, mut x: f32, cy: f32) -> f32 {
+    // Selected shape layers: the options show their paint and edit it (as in After Effects).
+    let shape_layers = selected_shape_layers(app);
+    sync_layer_paint(app, &shape_layers);
     // One undo step per picker session or width drag: end the merge once both are done.
     let picking = ["fill", "stroke"].iter().any(|k| widgets::popup_is_open(ui, picker_id(k)));
     if !picking && !ui.input(|i| i.pointer.any_down()) && app.session.history.merge_key.as_deref().is_some_and(|k| k.starts_with("tool-")) {
@@ -163,27 +254,50 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     // Fill and Stroke, hidden while the tools draw masks.
     let masking = drawing && !shape_layers.is_empty() && app.session.state.shape_tool.creates_mask;
     if (drawing || !shape_layers.is_empty()) && !masking {
-        x = fill_stroke_options(app, ui, &p, &shape_layers, x, cy);
+        x = fill_stroke_options(app, ui, p, &shape_layers, x, cy);
     }
     if app.ui.tool.puppet_kind().is_some() {
-        x = puppet_options(app, ui, &p, x, cy);
+        x = puppet_options(app, ui, p, x, cy);
     }
     if app.ui.tool.roto_kind(false).is_some() {
-        x = roto_options(app, ui, &p, x, cy);
+        x = roto_options(app, ui, p, x, cy);
     }
+    x
+}
+
+/// The Snapping checkbox, its label and options menu; returns the x where it started.
+fn snapping_toggle(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, x: f32, cy: f32) -> f32 {
+    let t = app.tokens;
     let snap = Rect::from_min_size(pos2(x, cy - 10.0), vec2(20.0, 20.0));
     // The engine owns snapping (View ▸ Snapping); the checkbox mirrors it.
     app.ui.snapping = app.session.state.snapping;
-    if widgets::checkbox(ui, snap, app.ui.snapping, &t, egui::Id::unique("snapping")).clicked() {
+    let snap_resp = widgets::checkbox(ui, snap, app.ui.snapping, &t, egui::Id::unique("snapping"));
+    crate::a11y::check_box(&snap_resp, tr("Snapping"), app.ui.snapping, true);
+    if snap_resp.changed() {
         let _ = app.session.execute("view.snapping", serde_json::json!({}));
         app.ui.snapping = app.session.state.snapping;
     }
     app.auto.add("header.snapping", snap, "Snapping");
     let label = p.text(pos2(snap.max.x + 4.0, cy), Align2::LEFT_CENTER, tr("Snapping"), Tokens::ui(12.0), t.text_dim);
     snapping_options(app, ui, Rect::from_min_size(pos2(label.max.x + 2.0, cy - 9.0), vec2(18.0, 18.0)));
+    x
+}
 
-    // Right side: community buttons, workspaces.
-    let mut rx = rect.max.x - 10.0;
+/// Right side: community buttons, appearance and workspaces; `left` is where the tools end.
+fn right_side(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, rect: Rect, left: f32, cy: f32) {
+    let t = app.tokens;
+    let rx = community_buttons(app, ui, p, rect.max.x - 10.0, cy);
+    let mut rx = appearance_button(app, ui, rx, cy);
+    rx -= 10.0;
+    p.line_segment([pos2(rx, cy - 10.0), pos2(rx, cy + 10.0)], Stroke::new(1.0, t.separator));
+    rx -= 10.0;
+    let rx = workspace_menu(app, ui, p, rx, cy);
+    workspace_tabs(app, ui, p, rx, left, cy);
+}
+
+/// The Discord pill and the GitHub and website buttons, right to left from `rx`; returns the new `rx`.
+fn community_buttons(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, mut rx: f32, cy: f32) -> f32 {
+    let t = app.tokens;
     // The pill fits its label (icon, gap, text) with even padding: it was a fixed 104 px with the
     // text at its left, which left a wide gap on the right (#581).
     let label = p.layout_no_wrap(tr("Discord").to_string(), Tokens::semibold(12.0), Color32::WHITE);
@@ -191,7 +305,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let dresp = ui.interact(discord, egui::Id::unique("hdr-discord"), Sense::click());
     let dc = Color32::from_rgb(0x58, 0x65, 0xf2);
     p.rect_filled(discord, 13.0, if dresp.hovered() { dc.gamma_multiply(1.2) } else { dc });
-    icons::paint(&p, Rect::from_center_size(pos2(discord.min.x + 17.0, cy), vec2(14.0, 14.0)), Icon::Chat, Color32::WHITE);
+    icons::paint(p, Rect::from_center_size(pos2(discord.min.x + 17.0, cy), vec2(14.0, 14.0)), Icon::Chat, Color32::WHITE);
     p.galley(pos2(discord.min.x + 30.0, cy - label.size().y / 2.0), label, Color32::WHITE);
     app.auto.add("header.discord", discord, "Join the ArtCraft Discord");
     if dresp.on_hover_text(tr("Join the ArtCraft community on Discord")).clicked() {
@@ -208,7 +322,13 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         app.auto.add(&format!("header.{}", &id[4..]), r, tip);
         rx = r.min.x - 4.0;
     }
-    // Appearance: Sync with System, Light, Dark (a monitor, sun or moon), one click to the next.
+    rx
+}
+
+/// Appearance: Sync with System, Light, Dark (a monitor, sun or moon), one click to the next;
+/// returns the new `rx`.
+fn appearance_button(app: &mut EffectcraftApp, ui: &mut egui::Ui, rx: f32, cy: f32) -> f32 {
+    let t = app.tokens;
     let (icon, mode) = match app.session.prefs.appearance.appearance_mode.as_str() {
         "auto" => (Icon::Monitor, tr("Sync with System")),
         "light" => (Icon::Sun, tr("Light")),
@@ -220,42 +340,47 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     if response.clicked() {
         app.cycle_appearance(ui.ctx());
     }
-    response.context_menu(|ui| {
-        let settings = ui.button(tr("Appearance Settings…"));
-        app.auto.add("header.appearanceSettings", settings.rect, "Appearance Settings…");
-        if settings.clicked() {
-            crate::panels::settings::open(app, "appearance");
-            ui.close();
-        }
-        let favorites = app.session.prefs.appearance.favorite_themes.clone();
-        for options in [effectcraft_engine::prefs::LIGHT_THEMES, effectcraft_engine::prefs::DARK_THEMES] {
-            let group: Vec<_> = options.iter().filter(|(_, id)| favorites.iter().any(|saved| saved == id)).collect();
-            if !group.is_empty() {
-                ui.separator();
-            }
-            for (label, id) in group {
-                let r = ui.selectable_label(app.ui.theme.name() == *id, tr(label));
-                app.auto.add(&format!("header.favoriteTheme.{id}"), r.rect, label);
-                if r.clicked() {
-                    if let Some(kind) = crate::theme::ThemeKind::from_name(id) {
-                        app.set_theme(ui.ctx(), kind);
-                    }
-                    ui.close();
-                }
-            }
-        }
-    });
+    response.context_menu(|ui| appearance_menu(app, ui));
     app.auto.add("header.appearance", r, &tip);
-    rx = r.min.x - 4.0;
-    rx -= 10.0;
-    p.line_segment([pos2(rx, cy - 10.0), pos2(rx, cy + 10.0)], Stroke::new(1.0, t.separator));
-    rx -= 10.0;
-    // Workspace tabs (right to left), with a » menu of all.
+    r.min.x - 4.0
+}
+
+/// The appearance button's context menu: settings and the favorite themes.
+fn appearance_menu(app: &mut EffectcraftApp, ui: &mut egui::Ui) {
+    let settings = ui.button(tr("Appearance Settings…"));
+    app.auto.add("header.appearanceSettings", settings.rect, "Appearance Settings…");
+    if settings.clicked() {
+        crate::panels::settings::open(app, "appearance");
+        ui.close();
+    }
+    let favorites = app.session.prefs.appearance.favorite_themes.clone();
+    for options in [effectcraft_engine::prefs::LIGHT_THEMES, effectcraft_engine::prefs::DARK_THEMES] {
+        let group: Vec<_> = options.iter().filter(|(_, id)| favorites.iter().any(|saved| saved == id)).collect();
+        if !group.is_empty() {
+            ui.separator();
+        }
+        for (label, id) in group {
+            let r = ui.selectable_label(app.ui.theme.name() == *id, tr(label));
+            app.auto.add(&format!("header.favoriteTheme.{id}"), r.rect, label);
+            if r.clicked() {
+                if let Some(kind) = crate::theme::ThemeKind::from_name(id) {
+                    app.set_theme(ui.ctx(), kind);
+                }
+                ui.close();
+            }
+        }
+    }
+}
+
+/// The » button with the menu of all workspaces; returns the new `rx`.
+fn workspace_menu(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, rx: f32, cy: f32) -> f32 {
+    let t = app.tokens;
     let more = Rect::from_min_max(pos2(rx - 20.0, cy - 11.0), pos2(rx, cy + 11.0));
     let mresp = ui.interact(more, egui::Id::unique("ws-more"), Sense::click());
     p.text(more.center(), Align2::CENTER_CENTER, "»", Tokens::ui(15.0), if mresp.hovered() { t.text } else { t.text_dim });
     app.auto.add("header.workspaces", more, "Workspaces");
-    crate::widgets::context_menu(&mresp, |ui| ws_menu(app, ui));
+    let current = app.ui.workspace.clone();
+    crate::widgets::context_menu(&mresp, |ui| ws_menu(app, ui, &current));
     if mresp.clicked() {
         widgets::open_popup(ui, egui::Id::unique("ws-pop"));
     }
@@ -269,15 +394,19 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     ) {
         app.set_workspace(crate::dock::WORKSPACES[i]);
     }
-    rx = more.min.x - 6.0;
-    // After Effects 2026's workspace bar order (right to left here): Default, Review, Learn,
-    // Small Screen, Standard.
+    more.min.x - 6.0
+}
+
+/// Workspace tabs, right to left from `rx`, stopping 120 px right of `left`.
+/// After Effects 2026's order (right to left here): Default, Review, Learn, Small Screen, Standard.
+fn workspace_tabs(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, mut rx: f32, left: f32, cy: f32) {
+    let t = app.tokens;
     let shown = ["Standard", "Small Screen", "Learn", "Review", "Default"];
     for name in shown {
         let g = p.layout_no_wrap(crate::i18n::command_label("window.workspace", name).to_string(), Tokens::ui(12.0), t.text);
         let w = g.size().x + 16.0;
         let r = Rect::from_min_max(pos2(rx - w, cy - 13.0), pos2(rx, cy + 13.0));
-        if r.min.x < x + 120.0 {
+        if r.min.x < left + 120.0 {
             break;
         }
         let active = app.ui.workspace == name;
@@ -298,6 +427,62 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             app.set_workspace(name);
         }
         rx = r.min.x - 2.0;
+        // Right-clicking a workspace opens the same options as the » button, which is where After
+        // Effects keeps them (reset, save, save a copy, edit).
+        let target = name.to_string();
+        crate::widgets::context_menu(&resp, |ui| ws_menu(app, ui, &target));
+    }
+}
+
+/// Double-clicking a creation tool in the Tools bar makes an instance of what it draws, as in
+/// After Effects (#1072): a text layer from the Type tools; from the shape tools, a shape that
+/// fills the comp — into the selected shape layer's Contents, as a mask on the selected layer
+/// (any non-shape layer, or Tool Creates Mask), or as a new shape layer when neither applies.
+fn create_on_double_click(app: &EffectcraftApp, tool: Tool) -> Option<(&'static str, serde_json::Value)> {
+    match tool {
+        // `invoke` turns empty params into an insertion point in the comp centre that starts
+        // editing (#866), which is what double-clicking the Type tool should do.
+        Tool::Type | Tool::TypeVertical => Some(("layer.newText", json!({}))),
+        Tool::Rectangle | Tool::RoundedRect | Tool::Ellipse | Tool::Polygon | Tool::Star => {
+            let kind = match tool {
+                Tool::Rectangle => "rect",
+                Tool::RoundedRect => "rounded",
+                Tool::Ellipse => "ellipse",
+                Tool::Polygon => "polygon",
+                _ => "star",
+            };
+            // Without a comp the command still runs and reports its error on the status line.
+            let Some(comp) = app.session.active_comp() else {
+                return Some(("shape.newShape", json!({"kind": kind})));
+            };
+            let (cw, ch) = (comp.width as f64, comp.height as f64);
+            // Rectangles and ellipses fill the comp; a Polystar's Outer Radius is half the comp
+            // height (Inner Radius: a quarter of it), so it gets a comp-height square.
+            let (w, h) = if matches!(tool, Tool::Polygon | Tool::Star) { (ch, ch) } else { (cw, ch) };
+            // A mask on the selected layer: any non-shape layer (the tool switches to Mask by
+            // itself), or a shape layer while Tool Creates Mask is on — as dragging does.
+            let sel = app.session.state.selected_layers.first().copied().and_then(|id| comp.layer(id));
+            if let Some(l) = sel.filter(|l| l.source.is_av() && (app.session.state.shape_tool.creates_mask || !matches!(l.source, LayerSource::Shape))) {
+                // The box in layer space, so a moved, scaled or rotated layer still gets a
+                // comp-filling mask: all four corners are mapped, and their bounds are the
+                // smallest axis-aligned box around the comp box.
+                let ctx = effectcraft_engine::render::EvalCtx::new(&app.session.project, app.session.active_comp_id()?, comp, app.session.time());
+                let inv = ctx.layer_to_comp(l).0.inverse().unwrap_or(effectcraft_engine::geom::Mat3::IDENTITY);
+                let (x0, y0, x1, y1) = (cw / 2.0 - w / 2.0, ch / 2.0 - h / 2.0, cw / 2.0 + w / 2.0, ch / 2.0 + h / 2.0);
+                let pts = [gv2(x0, y0), gv2(x1, y0), gv2(x1, y1), gv2(x0, y1)].map(|p| inv.apply(p));
+                let (mut lo, mut hi) = ([f64::INFINITY; 2], [f64::NEG_INFINITY; 2]);
+                for p in pts {
+                    lo = [lo[0].min(p.x), lo[1].min(p.y)];
+                    hi = [hi[0].max(p.x), hi[1].max(p.y)];
+                }
+                let rect = [lo[0], lo[1], hi[0] - lo[0], hi[1] - lo[1]];
+                return Some(("layer.addMask", json!({"layer": l.id.0, "shape": kind, "rect": rect})));
+            }
+            // Into the selected shape layer's Contents, else a new shape layer (the engine's own
+            // target), painted with the Tools bar's Fill and Stroke.
+            Some(("shape.newShape", json!({"kind": kind, "size": [w, h]})))
+        }
+        _ => None,
     }
 }
 
@@ -435,7 +620,14 @@ fn fill_stroke_options(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Pa
         x = sr.max.x + 12.0;
     }
     let width = app.session.state.shape_tool.stroke_width;
-    let (r, v, _) = widgets::hot_number_at(ui, pos2(x - 6.0, cy - 9.0), egui::Id::unique("tool-stroke-w"), width, 0.2, (0.0, 1000.0), 0, " px", &t);
+    let (r, v, _) = widgets::hot_number_at(
+        ui,
+        pos2(x - 6.0, cy - 9.0),
+        egui::Id::unique("tool-stroke-w"),
+        width,
+        &widgets::HotSpec { speed: 0.2, range: (0.0, 1000.0), decimals: 0, suffix: " px" },
+        &t,
+    );
     if let Some(v) = v {
         tool_options(app, json!({"strokeWidth": v}));
         paint(app, "strokeWidth", json!(v));
@@ -502,7 +694,14 @@ fn paint_options_popup(app: &mut EffectcraftApp, ui: &mut egui::Ui, shape_layers
             }
             app.auto.add(&format!("header.{key}Options.blend"), blend_rect, "Blend Mode");
             p.text(row(98.0), Align2::LEFT_CENTER, tr("Opacity:"), Tokens::ui(12.0), t.text_dim);
-            let (or, v, _) = widgets::hot_number_at(ui, row(89.0) + vec2(84.0, 0.0), id.with("opacity"), tp.opacity, 0.5, (0.0, 100.0), 0, "%", &t);
+            let (or, v, _) = widgets::hot_number_at(
+                ui,
+                row(89.0) + vec2(84.0, 0.0),
+                id.with("opacity"),
+                tp.opacity,
+                &widgets::HotSpec { speed: 0.5, range: (0.0, 100.0), decimals: 0, suffix: "%" },
+                &t,
+            );
             app.auto.add(&format!("header.{key}Options.opacity"), or, "Opacity");
             if let Some(v) = v {
                 let k_opacity = format!("{key}Opacity");
@@ -573,7 +772,14 @@ fn roto_options(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter,
     let label = tr("Diameter:");
     let lr = p.text(pos2(x, cy), Align2::LEFT_CENTER, label, Tokens::ui(12.0), t.text_dim);
     x = lr.max.x + 6.0;
-    let (r, nv, _) = widgets::hot_number_at(ui, pos2(x, cy - 9.0), egui::Id::unique(("roto-opt", key)), v, 0.5, (1.0, 5000.0), 0, " px", &t);
+    let (r, nv, _) = widgets::hot_number_at(
+        ui,
+        pos2(x, cy - 9.0),
+        egui::Id::unique(("roto-opt", key)),
+        v,
+        &widgets::HotSpec { speed: 0.5, range: (1.0, 5000.0), decimals: 0, suffix: " px" },
+        &t,
+    );
     app.auto.add("header.roto.diameter", r, label);
     if let Some(nv) = nv
         && let Err(e) = app.session.execute("roto.options", json!({key: nv}))
@@ -591,7 +797,7 @@ fn puppet_options(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter
     p.text(pos2(x, cy), Align2::LEFT_CENTER, tr("Mesh:"), Tokens::ui(12.0), t.text_dim);
     x += 40.0;
     let show = Rect::from_min_size(pos2(x, cy - 10.0), vec2(20.0, 20.0));
-    if widgets::checkbox(ui, show, o.show_mesh, &t, egui::Id::unique("puppet-show-mesh")).clicked() {
+    if widgets::checkbox(ui, show, o.show_mesh, &t, egui::Id::unique("puppet-show-mesh")).changed() {
         let _ = app.session.execute("puppet.mesh", json!({"showMesh": !o.show_mesh}));
     }
     app.auto.add("header.puppet.showMesh", show, "Show mesh");
@@ -600,7 +806,14 @@ fn puppet_options(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter
     for (label, key, v, range) in [("Expansion:", "expansion", o.expansion, (-100.0, 200.0)), ("Density:", "density", o.density, (0.0, 100.0))] {
         p.text(pos2(x, cy), Align2::LEFT_CENTER, label, Tokens::ui(12.0), t.text_dim);
         x += if key == "expansion" { 64.0 } else { 52.0 };
-        let (r, nv, _) = widgets::hot_number_at(ui, pos2(x, cy - 9.0), egui::Id::unique(("puppet-opt", key)), v, 0.2, range, 0, "", &t);
+        let (r, nv, _) = widgets::hot_number_at(
+            ui,
+            pos2(x, cy - 9.0),
+            egui::Id::unique(("puppet-opt", key)),
+            v,
+            &widgets::HotSpec { speed: 0.2, range, decimals: 0, suffix: "" },
+            &t,
+        );
         app.auto.add(&format!("header.puppet.{key}"), r, label);
         if let Some(nv) = nv {
             let _ = app.session.execute("puppet.mesh", json!({key: nv, "merge": format!("puppet-opt-{key}")}));
@@ -645,7 +858,7 @@ fn workspace_label(name: &str) -> &str {
     if crate::dock::WORKSPACES.contains(&name) { crate::i18n::command_label("window.workspace", name) } else { name }
 }
 
-fn ws_menu(app: &mut EffectcraftApp, ui: &mut egui::Ui) {
+fn ws_menu(app: &mut EffectcraftApp, ui: &mut egui::Ui, target: &str) {
     for w in app.workspace_names() {
         if ui.selectable_label(app.ui.workspace == w, workspace_label(&w)).clicked() {
             app.set_workspace(&w);
@@ -653,13 +866,41 @@ fn ws_menu(app: &mut EffectcraftApp, ui: &mut egui::Ui) {
         }
     }
     ui.separator();
-    if ui.button(tr("Reset to Saved Layout")).clicked() {
-        let n = app.ui.workspace.clone();
-        app.set_workspace(&n);
+    // The workspace options After Effects puts at the foot of its workspace menu, in its order and
+    // grouping: reset the current layout, save over it, save a copy, then edit the list. All four
+    // are engine commands, so a script drives the same things from the command line.
+    for (id, source) in [
+        ("window.resetWorkspace", "Reset to Saved Layout"),
+        ("window.saveWorkspace", "Save Changes to this Workspace"),
+        ("window.saveWorkspaceAs", "Save as New Workspace..."),
+    ] {
+        if ui.button(crate::i18n::command_label(id, source)).clicked() {
+            // The menu belongs to the tab it was opened on, so resetting or saving from a right
+            // click acts on that workspace. Save As and Edit keep working on the workspace that is
+            // showing: Save As would otherwise switch the layout before the user has named the
+            // copy, and cancelling the dialog would leave the switch behind.
+            let acts_on_its_tab = matches!(id, "window.resetWorkspace" | "window.saveWorkspace");
+            if acts_on_its_tab && app.ui.workspace != target {
+                app.set_workspace(target);
+            }
+            run_workspace_command(app, ui, id);
+            ui.close();
+        }
+    }
+    ui.separator();
+    if ui.button(crate::i18n::command_label("window.editWorkspaces", "Edit Workspaces...")).clicked() {
+        run_workspace_command(app, ui, "window.editWorkspaces");
         ui.close();
     }
 }
 
+/// Runs a workspace command, showing a failure in the status line as the menu bar does.
+fn run_workspace_command(app: &mut EffectcraftApp, ui: &egui::Ui, id: &str) {
+    if let Err(e) = crate::menus::invoke(app, ui.ctx(), id, json!({})) {
+        app.ui.status = e;
+    }
+}
+
 /// The ArtCraft mark as supplied in `docs/brand` (the README's and getartcraft.com's logo; used
 /// unmodified, see `docs/brand/LICENSE-brand.txt`).
 static ARTCRAFT_MARK: &[u8] = include_bytes!("../../../docs/brand/artcraft-mark.png");
@@ -733,4 +974,311 @@ mod tests {
         frame(&mut app, &ctx, 2.1, vec![]);
         assert!(!app.auto.elements.iter().any(|w| w.id == "tools.select.TypeVertical"));
     }
+
+    /// Alt/Option-click cycles a Tools-bar flyout slot without opening the menu.
+    #[test]
+    fn alt_click_cycles_the_type_slot() {
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        let ctx = egui::Context::default();
+        crate::theme::install(&ctx, &app.tokens, crate::i18n::language(&app));
+        frame(&mut app, &ctx, 0.0, vec![]);
+        frame(&mut app, &ctx, 0.1, vec![]);
+        let center = |element: &crate::automation::Element| {
+            let [x, y, w, h] = element.rect;
+            egui::pos2(x + w / 2.0, y + h / 2.0)
+        };
+        let at = center(app.auto.elements.iter().find(|w| w.id == "tools.Type").unwrap());
+        let alt = egui::Modifiers { alt: true, ..Default::default() };
+        let pointer = |pos, pressed, modifiers| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers };
+        app.ui.tool = Tool::Type;
+        app.ui.slot_tools[10] = Tool::Type;
+        frame(&mut app, &ctx, 1.0, vec![egui::Event::ModifiersChanged(alt), egui::Event::PointerMoved(at), pointer(at, true, alt)]);
+        frame(&mut app, &ctx, 1.05, vec![egui::Event::ModifiersChanged(alt), pointer(at, false, alt)]);
+        frame(&mut app, &ctx, 1.1, vec![]);
+        assert_eq!(app.ui.tool, Tool::TypeVertical);
+        assert_eq!(app.ui.slot_tools[10], Tool::TypeVertical);
+        assert!(!app.auto.elements.iter().any(|w| w.id.starts_with("tools.select.")), "Alt-click must not open the flyout");
+        frame(&mut app, &ctx, 1.5, vec![egui::Event::ModifiersChanged(alt), egui::Event::PointerMoved(at), pointer(at, true, alt)]);
+        frame(&mut app, &ctx, 1.55, vec![egui::Event::ModifiersChanged(alt), pointer(at, false, alt)]);
+        frame(&mut app, &ctx, 1.6, vec![]);
+        assert_eq!(app.ui.tool, Tool::Type, "wraps back to Type");
+    }
+
+    /// An Alt-click and a plain click that land as two releases in one frame must not
+    /// create a text layer: the first click was modified.
+    #[test]
+    fn mixed_modifier_same_frame_double_click_does_not_create() {
+        let mut s = effectcraft_engine::Session::default();
+        s.execute("comp.new", json!({"width": 640, "height": 360, "duration": 2})).unwrap();
+        let mut app = EffectcraftApp::new(s);
+        let ctx = egui::Context::default();
+        crate::theme::install(&ctx, &app.tokens, crate::i18n::language(&app));
+        frame(&mut app, &ctx, 0.0, vec![]);
+        frame(&mut app, &ctx, 0.1, vec![]);
+        let e = app.auto.elements.iter().find(|w| w.id == "tools.Type").expect("Type slot");
+        let at = egui::pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0);
+        let alt = egui::Modifiers { alt: true, ..Default::default() };
+        let plain = egui::Modifiers::default();
+        let pointer = |pos, pressed, modifiers| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers };
+        app.ui.tool = Tool::Type;
+        app.ui.slot_tools[10] = Tool::Type;
+        frame(
+            &mut app,
+            &ctx,
+            1.0,
+            vec![egui::Event::PointerMoved(at), pointer(at, true, alt), pointer(at, false, alt), pointer(at, true, plain), pointer(at, false, plain)],
+        );
+        assert!(app.session.active_comp().unwrap().layers.is_empty(), "Alt then plain in one frame must not create");
+        assert!(app.session.state.text_edit.is_none());
+    }
+
+    /// Double-clicking a creation tool in the Tools bar makes an instance of what it draws
+    /// (#1072): with nothing selected a shape layer whose shape fills the comp, into the selected
+    /// shape layer's Contents, a mask on a non-shape layer, a text layer from the Type tools.
+    /// Tools that create nothing stay quiet.
+    #[test]
+    fn double_clicking_creation_tools_makes_instances() {
+        let mut s = effectcraft_engine::Session::default();
+        s.execute("comp.new", json!({"width": 640, "height": 360, "duration": 2})).unwrap();
+        let mut app = EffectcraftApp::new(s);
+        let ctx = egui::Context::default();
+        crate::theme::install(&ctx, &app.tokens, crate::i18n::language(&app));
+        frame(&mut app, &ctx, 0.0, vec![]);
+        frame(&mut app, &ctx, 0.1, vec![]);
+        let pointer = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+        // Both click pairs in one frame, as egui counts a double-click.
+        let double_click = |app: &mut EffectcraftApp, ctx: &egui::Context, t: f64, id: &str| {
+            let e = app.auto.elements.iter().find(|w| w.id == id).unwrap_or_else(|| panic!("no {id}"));
+            let at = egui::pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0);
+            frame(app, ctx, t, vec![egui::Event::PointerMoved(at), pointer(at, true), pointer(at, false), pointer(at, true), pointer(at, false)]);
+        };
+        // Nothing selected: a shape layer with a Rectangle Path 1 the size of the comp.
+        double_click(&mut app, &ctx, 1.0, "tools.Rectangle");
+        {
+            let comp = app.session.active_comp().unwrap();
+            assert_eq!(comp.layers.len(), 1, "the double-click made a layer");
+            let l = &comp.layers[0];
+            assert!(matches!(l.source, LayerSource::Shape), "a shape layer");
+            let size = l.props.prop("contents/Rectangle 1/contents/Rectangle Path 1/size").expect("Rectangle Path 1");
+            assert_eq!(size.value.as_vec2(), [640.0, 360.0], "the rectangle fills the comp");
+        }
+        // The shape layer is selected: the Ellipse goes on top of its Contents, no new layer.
+        app.ui.slot_tools[8] = Tool::Ellipse;
+        frame(&mut app, &ctx, 1.05, vec![]);
+        double_click(&mut app, &ctx, 2.0, "tools.Ellipse");
+        {
+            let comp = app.session.active_comp().unwrap();
+            assert_eq!(comp.layers.len(), 1, "into the selected shape layer's Contents");
+            let l = &comp.layers[0];
+            assert!(l.props.prop("contents/Ellipse 1/contents/Ellipse Path 1/size").is_some(), "the new ellipse is on top");
+            assert!(l.props.prop("contents/Rectangle 1/contents/Rectangle Path 1/size").is_some(), "the rectangle still stands");
+        }
+        // The Type tool: a text layer above the selection, editing started (an insertion point, #866).
+        double_click(&mut app, &ctx, 3.0, "tools.Type");
+        {
+            let comp = app.session.active_comp().unwrap();
+            assert_eq!(comp.layers.len(), 2);
+            assert!(matches!(comp.layers[0].source, LayerSource::Text));
+            assert!(app.session.state.text_edit.is_some(), "the text layer is being edited");
+        }
+        // A non-shape layer is selected, so the Rectangle becomes a comp-filling mask on it.
+        app.ui.slot_tools[8] = Tool::Rectangle;
+        frame(&mut app, &ctx, 3.05, vec![]);
+        double_click(&mut app, &ctx, 4.0, "tools.Rectangle");
+        {
+            let comp = app.session.active_comp().unwrap();
+            assert_eq!(comp.layers.len(), 2, "a mask, not a layer");
+            let p = comp.layers[0].props.prop("masks/Mask 1/path").expect("Mask 1");
+            let sh = p.value.as_path().expect("a mask path");
+            let b = effectcraft_path::bounds(&[effectcraft_path::to_kurbo(sh)]).expect("bounds");
+            // The text layer is anchored top-left and centred in the comp: layer = comp - centre.
+            for (got, want) in [(b.x0, -320.0), (b.y0, -180.0), (b.x1, 320.0), (b.y1, 180.0)] {
+                assert!((got - want).abs() < 1.0, "the mask fills the comp: {got} vs {want}");
+            }
+        }
+        // A tool that creates nothing: no layer, no error.
+        double_click(&mut app, &ctx, 5.0, "tools.Hand");
+        assert_eq!(app.session.active_comp().unwrap().layers.len(), 2, "the Hand tool creates nothing");
+        assert!(app.ui.status.is_empty(), "{}", app.ui.status);
+        // Without a comp the command fails with the status line, never a panic.
+        let mut bare = EffectcraftApp::new(effectcraft_engine::Session::default());
+        let ctx = egui::Context::default();
+        crate::theme::install(&ctx, &bare.tokens, crate::i18n::language(&bare));
+        frame(&mut bare, &ctx, 0.0, vec![]);
+        frame(&mut bare, &ctx, 0.1, vec![]);
+        double_click(&mut bare, &ctx, 1.0, "tools.Rectangle");
+        assert!(!bare.ui.status.is_empty(), "no comp: a status message, not a crash");
+    }
+
+    /// #1765: a double-click on the Ellipse tool with nothing selected makes its own shape layer
+    /// the size of the comp, as the Rectangle does.
+    #[test]
+    fn double_click_ellipse_with_no_selection_makes_a_layer() {
+        let mut s = effectcraft_engine::Session::default();
+        s.execute("comp.new", json!({"width": 640, "height": 360, "duration": 2})).unwrap();
+        let mut app = EffectcraftApp::new(s);
+        let ctx = egui::Context::default();
+        crate::theme::install(&ctx, &app.tokens, crate::i18n::language(&app));
+        frame(&mut app, &ctx, 0.0, vec![]);
+        frame(&mut app, &ctx, 0.1, vec![]);
+        app.ui.slot_tools[8] = Tool::Ellipse;
+        frame(&mut app, &ctx, 1.0, vec![]);
+        let pointer = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+        let e = app.auto.elements.iter().find(|w| w.id == "tools.Ellipse").unwrap_or_else(|| panic!("no tools.Ellipse"));
+        let at = egui::pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0);
+        frame(&mut app, &ctx, 1.1, vec![egui::Event::PointerMoved(at), pointer(at, true), pointer(at, false), pointer(at, true), pointer(at, false)]);
+        let comp = app.session.active_comp().unwrap();
+        assert_eq!(comp.layers.len(), 1, "the double-click made a layer");
+        let l = &comp.layers[0];
+        assert!(matches!(l.source, LayerSource::Shape), "a shape layer");
+        let size = l.props.prop("contents/Ellipse 1/contents/Ellipse Path 1/size").expect("Ellipse Path 1");
+        assert_eq!(size.value.as_vec2(), [640.0, 360.0], "the ellipse fills the comp");
+        assert!(app.ui.status.is_empty(), "{}", app.ui.status);
+    }
+
+    /// Tool Creates Mask on (#1072): a double-click on a shape tool masks the selected shape
+    /// layer instead of adding to its Contents.
+    #[test]
+    fn double_click_masks_a_shape_layer_while_tool_creates_mask() {
+        let mut s = effectcraft_engine::Session::default();
+        s.execute("comp.new", json!({"width": 640, "height": 360, "duration": 2})).unwrap();
+        let mut app = EffectcraftApp::new(s);
+        let ctx = egui::Context::default();
+        crate::theme::install(&ctx, &app.tokens, crate::i18n::language(&app));
+        frame(&mut app, &ctx, 0.0, vec![]);
+        frame(&mut app, &ctx, 0.1, vec![]);
+        let pointer = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+        let double_click = |app: &mut EffectcraftApp, ctx: &egui::Context, t: f64, id: &str| {
+            let e = app.auto.elements.iter().find(|w| w.id == id).unwrap_or_else(|| panic!("no {id}"));
+            let at = egui::pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0);
+            frame(app, ctx, t, vec![egui::Event::PointerMoved(at), pointer(at, true), pointer(at, false), pointer(at, true), pointer(at, false)]);
+        };
+        // A shape layer, selected by the double-click that made it.
+        double_click(&mut app, &ctx, 1.0, "tools.Rectangle");
+        assert_eq!(app.session.active_comp().unwrap().layers.len(), 1);
+        app.session.state.shape_tool.creates_mask = true;
+        app.ui.slot_tools[8] = Tool::Ellipse;
+        frame(&mut app, &ctx, 1.05, vec![]);
+        double_click(&mut app, &ctx, 2.0, "tools.Ellipse");
+        {
+            let comp = app.session.active_comp().unwrap();
+            assert_eq!(comp.layers.len(), 1, "a mask, not a second shape layer");
+            let l = &comp.layers[0];
+            assert!(l.props.prop("masks/Mask 1/path").is_some(), "an ellipse mask");
+            assert!(l.props.prop("contents/Ellipse 1").is_none(), "nothing added to the Contents");
+            let p = l.props.prop("contents/Rectangle 1/contents/Rectangle Path 1/size").expect("the rectangle stands");
+            assert_eq!(p.value.as_vec2(), [640.0, 360.0]);
+        }
+        assert!(app.ui.status.is_empty(), "{}", app.ui.status);
+    }
+
+    /// The shape tools' geometry defaults (#1072): the Rounded Rectangle tool's Roundness is a
+    /// fixed 20, the Polygon tool a 5-point polygon, the Star tool a 5-point star whose Inner
+    /// Radius is a quarter of its Outer Radius.
+    #[test]
+    fn double_click_shape_tool_geometry_defaults() {
+        let mut s = effectcraft_engine::Session::default();
+        s.execute("comp.new", json!({"width": 640, "height": 360, "duration": 2})).unwrap();
+        let mut app = EffectcraftApp::new(s);
+        let ctx = egui::Context::default();
+        crate::theme::install(&ctx, &app.tokens, crate::i18n::language(&app));
+        frame(&mut app, &ctx, 0.0, vec![]);
+        frame(&mut app, &ctx, 0.1, vec![]);
+        let pointer = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+        let double_click = |app: &mut EffectcraftApp, ctx: &egui::Context, t: f64, id: &str| {
+            let e = app.auto.elements.iter().find(|w| w.id == id).unwrap_or_else(|| panic!("no {id}"));
+            let at = egui::pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0);
+            frame(app, ctx, t, vec![egui::Event::PointerMoved(at), pointer(at, true), pointer(at, false), pointer(at, true), pointer(at, false)]);
+        };
+        // Each shape on its own layer: deselect so the next double-click makes a new one.
+        let deselected = |app: &mut EffectcraftApp, ctx: &egui::Context, t: f64| {
+            app.session.execute("edit.deselectAll", json!({})).unwrap();
+            frame(app, ctx, t, vec![]);
+        };
+        // The Rounded Rectangle: Roundness 20, filling the comp.
+        app.ui.slot_tools[8] = Tool::RoundedRect;
+        frame(&mut app, &ctx, 1.0, vec![]);
+        double_click(&mut app, &ctx, 1.1, "tools.RoundedRect");
+        {
+            let comp = app.session.active_comp().unwrap();
+            let g = comp.layers[0].props.group("contents/Rectangle 1/contents/Rectangle Path 1").expect("Rectangle Path 1");
+            assert_eq!(g.prop("roundness").expect("roundness").value.as_f64(), 20.0, "a fixed roundness");
+            assert_eq!(g.prop("size").expect("size").value.as_vec2(), [640.0, 360.0]);
+        }
+        // The Star: 5 points, Outer Radius half the comp height, Inner Radius a quarter.
+        deselected(&mut app, &ctx, 2.0);
+        app.ui.slot_tools[8] = Tool::Star;
+        frame(&mut app, &ctx, 2.05, vec![]);
+        double_click(&mut app, &ctx, 2.1, "tools.Star");
+        {
+            let comp = app.session.active_comp().unwrap();
+            let g = comp.layers[0].props.group("contents/Polystar 1/contents/Polystar Path 1").expect("Polystar Path 1");
+            assert_eq!(g.prop("type").expect("type").value.as_enum(), 0, "Star");
+            assert_eq!(g.prop("points").expect("points").value.as_f64(), 5.0, "5 points");
+            assert_eq!(g.prop("outerRadius").expect("outer").value.as_f64(), 180.0, "half the comp height");
+            assert_eq!(g.prop("innerRadius").expect("inner").value.as_f64(), 90.0, "a quarter of the comp height");
+        }
+        // The Polygon: 5 points, Outer Radius half the comp height, no inner radius.
+        deselected(&mut app, &ctx, 3.0);
+        app.ui.slot_tools[8] = Tool::Polygon;
+        frame(&mut app, &ctx, 3.05, vec![]);
+        double_click(&mut app, &ctx, 3.1, "tools.Polygon");
+        {
+            let comp = app.session.active_comp().unwrap();
+            let g = comp.layers[0].props.group("contents/Polystar 1/contents/Polystar Path 1").expect("Polystar Path 1");
+            assert_eq!(g.prop("type").expect("type").value.as_enum(), 1, "Polygon");
+            assert_eq!(g.prop("points").expect("points").value.as_f64(), 5.0, "5 points");
+            assert_eq!(g.prop("outerRadius").expect("outer").value.as_f64(), 180.0, "half the comp height");
+            assert!(g.prop("innerRadius").is_none(), "a polygon has no inner radius");
+        }
+        assert!(app.ui.status.is_empty(), "{}", app.ui.status);
+    }
+
+    /// A double-clicked shape is painted with the Tools bar's Fill and Stroke (#1072): the
+    /// colours and stroke width the shape tool is set to — and no outline at all when the tool
+    /// has its Stroke off.
+    #[test]
+    fn double_click_paints_with_the_shape_tools_fill_and_stroke() {
+        let mut s = effectcraft_engine::Session::default();
+        s.execute("comp.new", json!({"width": 640, "height": 360, "duration": 2})).unwrap();
+        let mut app = EffectcraftApp::new(s);
+        let ctx = egui::Context::default();
+        crate::theme::install(&ctx, &app.tokens, crate::i18n::language(&app));
+        frame(&mut app, &ctx, 0.0, vec![]);
+        frame(&mut app, &ctx, 0.1, vec![]);
+        let pointer = |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() };
+        let double_click = |app: &mut EffectcraftApp, ctx: &egui::Context, t: f64, id: &str| {
+            let e = app.auto.elements.iter().find(|w| w.id == id).unwrap_or_else(|| panic!("no {id}"));
+            let at = egui::pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0);
+            frame(app, ctx, t, vec![egui::Event::PointerMoved(at), pointer(at, true), pointer(at, false), pointer(at, true), pointer(at, false)]);
+        };
+        // The tool's own Fill and Stroke go onto the created shape.
+        app.session.state.shape_tool.fill.color = [1.0, 0.0, 0.0];
+        app.session.state.shape_tool.stroke.color = [0.0, 1.0, 0.0];
+        app.session.state.shape_tool.stroke_width = 5.0;
+        double_click(&mut app, &ctx, 1.0, "tools.Rectangle");
+        {
+            let comp = app.session.active_comp().unwrap();
+            let g = comp.layers[0].props.group("contents/Rectangle 1/contents").expect("the contents");
+            let fill = g.sub("fill").expect("the fill");
+            assert_eq!(fill.get("color").expect("color").value.as_color(), [1.0, 0.0, 0.0, 1.0], "the tool's Fill");
+            let stroke = g.sub("stroke").expect("the stroke");
+            assert_eq!(stroke.get("color").expect("color").value.as_color(), [0.0, 1.0, 0.0, 1.0], "the tool's Stroke");
+            assert_eq!(stroke.get("width").expect("width").value.as_f64(), 5.0, "the tool's Stroke Width");
+        }
+        // Stroke off ("Keine"): the next shape gets no outline at all, but keeps the Fill.
+        app.session.execute("shape.toolOptions", json!({"stroke": false})).unwrap();
+        app.session.execute("edit.deselectAll", json!({})).unwrap();
+        app.ui.slot_tools[8] = Tool::Ellipse;
+        frame(&mut app, &ctx, 1.05, vec![]);
+        double_click(&mut app, &ctx, 2.0, "tools.Ellipse");
+        {
+            let comp = app.session.active_comp().unwrap();
+            assert_eq!(comp.layers.len(), 2, "a new shape layer");
+            let g = comp.layers[0].props.group("contents/Ellipse 1/contents").expect("the ellipse");
+            assert!(g.sub("stroke").is_none(), "no outline when the tool's Stroke is off");
+            assert_eq!(g.sub("fill").expect("the fill").get("color").expect("color").value.as_color(), [1.0, 0.0, 0.0, 1.0]);
+        }
+        assert!(app.ui.status.is_empty(), "{}", app.ui.status);
+    }
 }
diff --git a/crates/ui-egui/src/hooks.rs b/crates/ui-egui/src/hooks.rs
new file mode 100644
index 000000000..457aeb99a
--- /dev/null
+++ b/crates/ui-egui/src/hooks.rs
@@ -0,0 +1,87 @@
+use super::*;
+
+/// The desktop's light or dark appearance where egui cannot see it (Wayland compositors that send
+/// winit no theme). `None` = the host does not know.
+pub type SystemThemeFn = Box<dyn Fn(&egui::Context) -> Option<egui::Theme>>;
+
+/// A file dialog a host shows without blocking the frame ([`Hooks::file_dialog_async`]).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum FileDialog {
+    /// Files to open or import with these extensions; several when `many`.
+    Open { exts: Vec<String>, many: bool },
+    /// An EffectCraft project to open.
+    OpenProject,
+    /// A folder.
+    Folder,
+    /// Where to save `default` (a file name or path) with extension `ext` (empty: no filter);
+    /// `project`: the project save dialog, given the file name.
+    Save { default: String, ext: String, project: bool },
+}
+
+impl FileDialog {
+    /// The save dialog for `default`, as [`Hooks::save_dialog`] picks it.
+    pub fn save(default: &str) -> Self {
+        let ext = std::path::Path::new(default).extension().map(|e| e.to_string_lossy().to_string()).unwrap_or_default();
+        Self::Save { default: default.to_string(), project: ext.eq_ignore_ascii_case("ecproj"), ext }
+    }
+}
+
+/// Called with the paths a [`FileDialog`] picked (empty: cancelled), from any thread.
+pub type DialogDone = Box<dyn FnOnce(Vec<String>) + Send>;
+
+/// Host hooks provided by the native app (file pickers etc.).
+#[derive(Default)]
+pub struct Hooks {
+    /// The system appearance for Settings ▸ Appearance ▸ Sync with System (the desktop app reads
+    /// the Linux desktop portal); without it, what egui reports.
+    pub system_theme: Option<SystemThemeFn>,
+    pub pick_files: Option<Box<dyn Fn(&[&str]) -> Vec<String>>>,
+    pub pick_save: Option<Box<dyn Fn(&str) -> Option<String>>>,
+    pub pick_open_project: Option<Box<dyn Fn() -> Option<String>>>,
+    /// Opens the audio output for preview playback (the desktop app uses cpal).
+    pub audio_device: Option<audio::AudioDeviceFactory>,
+    /// Lists audio output devices (Settings ▸ Audio).
+    pub audio_devices: Option<Box<dyn Fn() -> Vec<String>>>,
+    /// Picks a folder (Settings paths).
+    pub pick_folder: Option<Box<dyn Fn() -> Option<String>>>,
+    /// Save dialog for other file kinds: (default name or path, extension; empty: no filter). A
+    /// default path opens the dialog in its folder.
+    pub pick_save_file: Option<Box<dyn Fn(&str, &str) -> Option<String>>>,
+    /// The system clipboard's text (native menu Edit ▸ Paste into a text field).
+    pub clipboard_text: Option<Box<dyn Fn() -> Option<String>>>,
+    /// Application actions the OS performs (`app.hide`, `app.hideOthers`, `app.showAll` on
+    /// macOS). Returns false when the host doesn't handle the id.
+    pub app_action: Option<Box<dyn Fn(&str) -> bool>>,
+    /// Shows a command's file dialog without blocking the frame and calls `done` with the
+    /// answer (the host then asks for a repaint). Used in place of the blocking pickers above for
+    /// the commands' dialogs (File ▸ Import, Open, Save As…) where blocking the frame is unsafe or
+    /// leaves the window unresponsive: on macOS a nested modal event loop there aborted the app on
+    /// a drag over the window (#511), and on Linux a blocking desktop-portal dialog never pumps
+    /// events, so the compositor marks the window as not responding (#1275).
+    pub file_dialog_async: Option<Box<dyn Fn(FileDialog, DialogDone)>>,
+    /// Tells the user the graphics device was lost and the window is closing, once. `saved` is
+    /// the auto-save of unsaved changes (`None`: nothing was unsaved), its path or why it failed.
+    pub device_lost: Option<Box<dyn Fn(Option<Result<String, String>>)>>,
+    /// Runs on the worker thread right before the GPU compositor is built (desktop). Tests hold
+    /// it to look at the interface while the compositor is still being prepared, or make it
+    /// panic to check that a failing build never reaches the UI thread.
+    pub before_gpu_build: Option<Box<dyn FnOnce() + Send>>,
+}
+
+impl Hooks {
+    /// The host's save dialog for `default` (a file name or path), offering its extension: the
+    /// project dialog for project files, else [`Hooks::pick_save_file`]. The project dialog is
+    /// the fallback for hosts without that (the web, whose dialog only names the file): on macOS
+    /// a dialog filtered to projects appends `.ecproj` to any other name (#293). `None` when the
+    /// host has no save dialog; `Some(None)` when it was cancelled.
+    pub fn save_dialog(&self, default: &str) -> Option<Option<String>> {
+        let path = std::path::Path::new(default);
+        let ext = path.extension().map(|e| e.to_string_lossy().to_string()).unwrap_or_default();
+        match (&self.pick_save_file, &self.pick_save) {
+            (Some(pick), _) if !ext.eq_ignore_ascii_case("ecproj") => Some(pick(default, &ext)),
+            (_, Some(pick)) => Some(pick(&path.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default())),
+            (Some(pick), None) => Some(pick(default, &ext)),
+            (None, None) => None,
+        }
+    }
+}
diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs
index ccd3059fa..fe676163e 100644
--- a/crates/ui-egui/src/i18n.rs
+++ b/crates/ui-egui/src/i18n.rs
@@ -8,14 +8,14 @@ use crate::EffectcraftApp;
 /// Effect names, keyed by effect id (#821).
 pub(crate) mod effects;
 /// Translations for the panels, tooltips and dialogs below the menu bar (see the module docs).
-mod ui;
+pub(crate) mod ui;
 use effectcraft_engine::menus::{MenuEntry, MenuNode};
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) use ui::catalog_characters;
 pub(crate) use ui::{set_current, tr, tr_args};
 
 /// Every language with a catalog, in the order Settings ▸ General ▸ Language lists them.
-const CATALOG_CODES: [&str; 11] = ["cs", "de", "es", "fr", "pt-br", "ru", "uk", "ka", "ja", "zh-hans", "zh-hant"];
+const CATALOG_CODES: [&str; 13] = ["cs", "de", "es", "fr", "pl", "pt-br", "sv", "ru", "uk", "ka", "ja", "zh-hans", "zh-hant"];
 
 /// The active interface language: the stored preference when it names a catalog, otherwise `en`
 /// (English is the source of every label and needs no lookup).
@@ -66,11 +66,21 @@ pub(crate) fn czech(app: &EffectcraftApp) -> bool {
     language(app) == "cs"
 }
 
+/// The UI is in Polish.
+pub(crate) fn polish(app: &EffectcraftApp) -> bool {
+    language(app) == "pl"
+}
+
 /// The UI is in Georgian.
 pub(crate) fn georgian(app: &EffectcraftApp) -> bool {
     language(app) == "ka"
 }
 
+/// The UI is in Swedish.
+pub(crate) fn swedish(app: &EffectcraftApp) -> bool {
+    language(app) == "sv"
+}
+
 /// Settings ▸ General ▸ Language ▸ Match System: the operating system's interface language
 /// where EffectCraft has it, else English (#229), as After Effects installs in the system's
 /// language. The browser build follows the locales its page passes in ([`set_system_locales`]).
@@ -123,7 +133,7 @@ fn web_draws(language: &str) -> bool {
 
 /// The language EffectCraft shows for a BCP 47 locale (`ja-JP` → `ja`, `zh-Hans-CN` → `zh-hans`,
 /// `zh-TW` → `zh-hant`, `uk-UA` → `uk`, `es-ES` → `es`, `pt-BR` → `pt-br`, `cs-CZ` → `cs`,
-/// `ka-GE` → `ka`).
+/// `ka-GE` → `ka`, `ru-RU` → `ru`, `de-AT` → `de`, `fr-CA` → `fr`, `sv-SE` → `sv`).
 fn supported(locale: Option<&str>) -> &'static str {
     let Some(locale) = locale else { return "en" };
     let mut parts = locale.split(['-', '_']);
@@ -134,7 +144,12 @@ fn supported(locale: Option<&str>) -> &'static str {
         "uk" => "uk",
         "es" => "es",
         "cs" => "cs",
+        "pl" => "pl",
         "ka" => "ka",
+        "ru" => "ru",
+        "de" => "de",
+        "fr" => "fr",
+        "sv" => "sv",
         // The only Portuguese catalog: Brazil's, also for Portugal rather than English.
         "pt" => "pt-br",
         "zh" => {
@@ -145,35 +160,45 @@ fn supported(locale: Option<&str>) -> &'static str {
     }
 }
 
+/// The Windows and Linux sources of *Reveal in Finder* in each catalog that has them, keyed by
+/// language code: the platform names the file manager before the catalog sees the label, so the
+/// macOS row alone leaves the other two in English (#1450).
+const REVEAL_FINDER: &[(&str, &str, &str)] = &[
+    ("uk", "Показати у Провіднику", "Показати у файловому менеджері"),
+    ("de", "Im Explorer anzeigen", "Im Dateimanager anzeigen"),
+    ("cs", "Zobrazit v Průzkumníku", "Zobrazit ve správci souborů"),
+    ("ja", "エクスプローラーで表示", "ファイルマネージャーで表示"),
+    ("pl", "Pokaż w Eksploratorze", "Pokaż w menedżerze plików"),
+    ("ka", "Explorer-ში ჩვენება", "ფაილების მენეჯერში ჩვენება"),
+    ("zh-hans", "在资源管理器中显示", "在文件管理器中显示"),
+    ("zh-hant", "在檔案總管中顯示", "在檔案管理員中顯示"),
+    ("es", "Mostrar en el Explorador", "Mostrar en el gestor de archivos"),
+    ("pt-br", "Mostrar no Explorador", "Mostrar no gerenciador de arquivos"),
+    ("fr", "Afficher dans l’Explorateur", "Afficher dans le gestionnaire de fichiers"),
+    ("ru", "Показать в Проводнике", "Показать в файловом менеджере"),
+];
+
 pub(crate) fn label<'a>(app: &EffectcraftApp, command: &str, source: &'a str) -> &'a str {
     let language = language(app);
-    // The engine names the platform's file manager before the catalog sees the label. These
-    // two commands keep their ids, but on Windows/Linux their source is no longer "Finder".
-    if language == "uk" && matches!(command, "file.revealInFinder" | "layer.revealInFinder") {
+    // The engine names the platform's file manager before the catalog sees the label, so on
+    // Windows and Linux the source is no longer "Finder" and the catalog's row misses. Every
+    // language that names a file manager says so here (#1450); a language with no row keeps the
+    // English source rather than a guess.
+    if matches!(command, "file.revealInFinder" | "layer.revealInFinder")
+        && let Some((_, explorer, manager)) = REVEAL_FINDER.iter().find(|(code, ..)| *code == language)
+    {
+        // Only the Windows and Linux sources are overridden; "Reveal in Finder" keeps going to the
+        // catalog below, which holds the macOS wording.
         match source {
-            "Reveal in Explorer" => return "Показати у Провіднику",
-            "Reveal in File Manager" => return "Показати у файловому менеджері",
+            "Reveal in Explorer" => return explorer,
+            "Reveal in File Manager" => return manager,
             _ => {}
         }
     }
-    if language == "de" && matches!(command, "file.revealInFinder" | "layer.revealInFinder") {
+    if language == "sv" && matches!(command, "file.revealInFinder" | "layer.revealInFinder") {
         match source {
-            "Reveal in Explorer" => return "Im Explorer anzeigen",
-            "Reveal in File Manager" => return "Im Dateimanager anzeigen",
-            _ => {}
-        }
-    }
-    if language == "cs" && matches!(command, "file.revealInFinder" | "layer.revealInFinder") {
-        match source {
-            "Reveal in Explorer" => return "Zobrazit v Průzkumníku",
-            "Reveal in File Manager" => return "Zobrazit ve správci souborů",
-            _ => {}
-        }
-    }
-    if language == "ka" && matches!(command, "file.revealInFinder" | "layer.revealInFinder") {
-        match source {
-            "Reveal in Explorer" => return "Explorer-ში ჩვენება",
-            "Reveal in File Manager" => return "ფაილების მენეჯერში ჩვენება",
+            "Reveal in Explorer" => return "Visa i Utforskaren",
+            "Reveal in File Manager" => return "Visa i filhanteraren",
             _ => {}
         }
     }
@@ -193,7 +218,9 @@ fn menu_catalog(language: &str) -> Option<&'static [(&'static str, &'static str,
         "fr" => FRENCH,
         "de" => GERMAN,
         "cs" => CZECH,
+        "pl" => POLISH,
         "ka" => GEORGIAN,
+        "sv" => SWEDISH,
         _ => return None,
     })
 }
@@ -252,22 +279,36 @@ pub(crate) fn entry(app: &EffectcraftApp, e: &MenuEntry, shown: String) -> Strin
         return effects::name(id, &e.label);
     }
     // Undo/redo names come from the history, so they are formatted per language here rather than
-    // looked up in a catalog. An English (or untranslated) interface keeps the shown label.
-    let (undo, no_undo, redo, no_redo) = match language(app) {
-        "ja" => ("取り消し", "取り消しできません", "やり直し", "やり直しできません"),
-        "zh-hans" => ("撤销", "无可撤销的操作", "重做", "无可重做的操作"),
-        "zh-hant" => ("復原", "沒有可復原的操作", "重做", "沒有可重做的操作"),
-        "uk" => ("Скасувати", "Немає дій для скасування", "Повторити", "Немає дій для повторення"),
-        "es" => ("Deshacer", "No se puede deshacer", "Rehacer", "No se puede rehacer"),
-        "pt-br" => ("Desfazer", "Não há nada para desfazer", "Refazer", "Não há nada para refazer"),
-        "cs" => ("Zpět", "Není co vrátit", "Znovu", "Není co zopakovat"),
+    // looked up in a catalog. A language without this wording keeps the shown undo/redo label, and
+    // the rest of its menu still goes through the catalog below (#1449).
+    let history = match language(app) {
+        "en" => return shown,
+        "ja" => Some(("取り消し", "取り消しできません", "やり直し", "やり直しできません")),
+        "zh-hans" => Some(("撤销", "无可撤销的操作", "重做", "无可重做的操作")),
+        "zh-hant" => Some(("復原", "沒有可復原的操作", "重做", "沒有可重做的操作")),
+        "uk" => Some(("Скасувати", "Немає дій для скасування", "Повторити", "Немає дій для повторення")),
+        "es" => Some(("Deshacer", "No se puede deshacer", "Rehacer", "No se puede rehacer")),
+        "pt-br" => Some(("Desfazer", "Não há nada para desfazer", "Refazer", "Não há nada para refazer")),
+        "cs" => Some(("Zpět", "Není co vrátit", "Znovu", "Není co zopakovat")),
+        "fr" => Some(("Annuler", "Impossible d'annuler", "Rétablir", "Impossible de rétablir")),
+        "de" => Some(("Rückgängig", "Rückgängig nicht möglich", "Wiederholen", "Wiederholen nicht möglich")),
+        "pl" => Some(("Cofnij", "Nie można cofnąć", "Ponów", "Nie można ponowić")),
         // A colon before the history's (untranslated) action name: "დაბრუნება: Comp1".
-        "ka" => ("დაბრუნება:", "დაბრუნება შეუძლებელია", "ხელახლა შესრულება:", "ხელახლა შესრულება შეუძლებელია"),
-        _ => return shown,
+        "ka" => Some(("დაბრუნება:", "დაბრუნება შეუძლებელია", "ხელახლა შესრულება:", "ხელახლა შესრულება შეუძლებელია")),
+        // A colon before the history's (untranslated) action name: "Отменить: Comp1".
+        "ru" => Some(("Отменить:", "Нечего отменять", "Повторить:", "Нечего повторять")),
+        "sv" => Some(("Ångra", "Det går inte att ångra", "Gör om", "Det går inte att göra om")),
+        _ => None,
     };
     match e.command.as_str() {
-        "edit.undo" => app.session.history.undo.last().map(|u| format!("{undo} {}", u.0)).unwrap_or_else(|| no_undo.into()),
-        "edit.redo" => app.session.history.redo.last().map(|u| format!("{redo} {}", u.0)).unwrap_or_else(|| no_redo.into()),
+        "edit.undo" | "edit.redo" => {
+            let Some((undo, no_undo, redo, no_redo)) = history else { return shown };
+            if e.command == "edit.undo" {
+                app.session.history.undo.last().map(|u| format!("{undo} {}", u.0)).unwrap_or_else(|| no_undo.into())
+            } else {
+                app.session.history.redo.last().map(|u| format!("{redo} {}", u.0)).unwrap_or_else(|| no_redo.into())
+            }
+        }
         "window.panel" => {
             let prefix = format!("{}: ", e.label);
             if let Some(name) = shown.strip_prefix(&prefix) {
@@ -293,8 +334,23 @@ pub(crate) fn effect_category(children: &[MenuNode], source: &str) -> Option<Str
     (!children.is_empty() && children.iter().all(|c| matches!(c, MenuNode::Item(e) if e.command == "effect.apply"))).then(|| effects::category(source))
 }
 
+/// Polish names for the Assign Shortcut submenus that carry a workspace's or 3D view's name.
+fn polish_assign_shortcut(source: &str, shown: &str) -> Option<String> {
+    let named = shown.strip_prefix("Assign Shortcut to “")?;
+    match source {
+        "Assign Shortcut to Workspace" => named.strip_suffix("” Workspace").map(|name| format!("Przypisz skrót do obszaru roboczego „{name}”")),
+        "Assign Shortcut to 3D View" => named.strip_suffix('”').map(|name| format!("Przypisz skrót do widoku 3D „{name}”")),
+        _ => None,
+    }
+}
+
 pub(crate) fn submenu(app: &EffectcraftApp, source: &str, shown: String) -> String {
     match language(app) {
+        "pl" => {
+            if let Some(label) = polish_assign_shortcut(source, &shown) {
+                return label;
+            }
+        }
         "cs" => {
             if source == "Assign Shortcut to Workspace" {
                 if let Some(name) = shown.strip_prefix("Assign Shortcut to “").and_then(|s| s.strip_suffix("” Workspace")) {
@@ -383,6 +439,17 @@ pub(crate) fn submenu(app: &EffectcraftApp, source: &str, shown: String) -> Stri
                 return format!("მალსახმობის მინიჭება 3D ხედისთვის „{name}“");
             }
         }
+        "sv" => {
+            if source == "Assign Shortcut to Workspace" {
+                if let Some(name) = shown.strip_prefix("Assign Shortcut to “").and_then(|s| s.strip_suffix("” Workspace")) {
+                    return format!("Tilldela kortkommando till arbetslayouten ”{name}”");
+                }
+            } else if source == "Assign Shortcut to 3D View"
+                && let Some(name) = shown.strip_prefix("Assign Shortcut to “").and_then(|s| s.strip_suffix('”'))
+            {
+                return format!("Tilldela kortkommando till 3D-vyn ”{name}”");
+            }
+        }
         _ => {}
     }
     label(app, "", &shown).into()
@@ -469,6 +536,7 @@ const SIMPLIFIED_CHINESE: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "安装脚本文件..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "安装 ScriptUI 面板..."),
     ("file.runScript", "Run Script File...", "运行脚本文件..."),
+    ("", "Recent Script Files", "最近的脚本文件"),
     ("", "Create Proxy", "创建代理"),
     ("file.createProxy", "Still...", "静止图像..."),
     ("file.createProxy", "Movie...", "影片..."),
@@ -822,6 +890,8 @@ const SIMPLIFIED_CHINESE: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "行落下"),
     ("anim.addKeyframe", "Add Keyframe", "添加关键帧"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "切换定格关键帧"),
+    ("keys.setMuted", "Mute Keyframes", "静音关键帧"),
+    ("keys.setMuted", "Unmute Keyframes", "取消静音关键帧"),
     ("keys.interpolation", "Keyframe Interpolation...", "关键帧插值..."),
     ("keys.velocity", "Keyframe Velocity...", "关键帧速度..."),
     ("", "Keyframe Assistant", "关键帧辅助"),
@@ -1024,6 +1094,642 @@ const SIMPLIFIED_CHINESE: &[(&str, &str, &str)] = &[
     ("file.openDemoProject", "Open Demo Project", "打开示例项目"),
 ];
 
+/// Swedish (`sv`), written from the English source.
+const SWEDISH: &[(&str, &str, &str)] = &[
+    ("", "EffectCraft", "EffectCraft"),
+    ("app.about", "About EffectCraft...", "Om EffectCraft..."),
+    ("", "Settings...", "Inställningar..."),
+    ("app.settings", "General...", "Allmänt..."),
+    ("app.settings", "Startup & Repair...", "Start och reparation..."),
+    ("app.settings", "Project...", "Projekt..."),
+    ("app.settings", "Composition...", "Komposition..."),
+    ("app.settings", "Previews...", "Förhandsgranskningar..."),
+    ("app.settings", "Appearance...", "Utseende..."),
+    ("app.settings", "Grids & Guides...", "Rutnät och stödlinjer..."),
+    ("app.settings", "Labels...", "Etiketter..."),
+    ("app.settings", "Type...", "Text..."),
+    ("app.settings", "Import...", "Importera..."),
+    ("app.settings", "Export...", "Exportera..."),
+    ("app.settings", "Audio...", "Ljud..."),
+    ("app.settings", "Disk...", "Disk..."),
+    ("app.settings", "Memory & CPU...", "Minne och CPU..."),
+    ("app.settings", "Video...", "Video..."),
+    ("app.settings", "3D...", "3D..."),
+    ("app.settings", "Scripting & Expressions...", "Skript och uttryck..."),
+    ("app.hide", "Hide EffectCraft", "Dölj EffectCraft"),
+    ("app.hideOthers", "Hide Others", "Göm övriga"),
+    ("app.showAll", "Show All", "Visa alla"),
+    ("app.quit", "Quit EffectCraft", "Avsluta EffectCraft"),
+    ("", "File", "Arkiv"),
+    ("", "New", "Nytt"),
+    ("file.newProject", "New Project", "Nytt projekt"),
+    ("file.newFromTemplate", "New Project from Template...", "Nytt projekt från mall..."),
+    ("project.newFolder", "New Folder", "Ny mapp"),
+    ("file.open", "Open Project...", "Öppna projekt..."),
+    ("", "Open Recent", "Öppna senaste"),
+    ("file.clearRecent", "Clear Recent Projects", "Rensa senaste projekt"),
+    ("file.close", "Close", "Stäng"),
+    ("file.closeProject", "Close Project", "Stäng projekt"),
+    ("file.save", "Save", "Spara"),
+    ("", "Save As", "Spara som"),
+    ("file.saveAs", "Save As...", "Spara som..."),
+    ("file.saveCopy", "Save a Copy...", "Spara en kopia..."),
+    ("file.saveCopyAsXml", "Save a Copy As XML...", "Spara en kopia som XML..."),
+    ("templates.saveAs", "Save as Template...", "Spara som mall..."),
+    ("file.incrementAndSave", "Increment and Save", "Räkna upp och spara"),
+    ("file.revert", "Revert", "Återgå"),
+    ("", "Import", "Importera"),
+    ("file.import", "File...", "Fil..."),
+    ("file.importMultiple", "Multiple Files...", "Flera filer..."),
+    ("file.importTimeline", "Adobe Premiere Pro Project...", "Adobe Premiere Pro-projekt..."),
+    ("file.importProject", "EffectCraft Project...", "EffectCraft-projekt..."),
+    ("file.importPlaceholder", "Placeholder...", "Platshållare..."),
+    ("file.importSolid", "Solid...", "Enfärgad..."),
+    ("file.importLottie", "Lottie...", "Lottie..."),
+    ("file.importVanishingPoint", "Vanishing Point (.vpe)...", "Fluktpunkt (.vpe)..."),
+    ("essential.importTemplate", "Essential Graphics Template...", "Mall för grundläggande grafik..."),
+    ("", "Import Recent Footage", "Importera senaste material"),
+    ("file.clearRecentFootage", "Clear Recent Footage", "Rensa senaste filmmaterial"),
+    ("", "Export", "Exportera"),
+    ("renderQueue.add", "Add to Render Queue", "Lägg till i renderingskön"),
+    ("file.exportTimeline", "Adobe Premiere Pro Project...", "Adobe Premiere Pro-projekt..."),
+    ("file.exportLottie", "Lottie JSON...", "Lottie JSON..."),
+    ("essential.exportTemplate", "Essential Graphics Template...", "Mall för grundläggande grafik..."),
+    ("app.find", "Find", "Sök"),
+    ("layer.addItem", "Add Footage to Comp", "Lägg till filmmaterial i komposition"),
+    ("file.newCompFromSelection", "New Comp from Selection...", "Ny komposition från markering..."),
+    ("", "Dependencies", "Beroenden"),
+    ("file.collectFiles", "Collect Files...", "Samla filer..."),
+    ("file.consolidateFootage", "Consolidate All Footage", "Konsolidera allt filmmaterial"),
+    ("file.removeUnusedFootage", "Remove Unused Footage", "Ta bort oanvänt filmmaterial"),
+    ("file.reduceProject", "Reduce Project", "Reducera projekt"),
+    ("file.findMissing", "Find Missing Effects", "Sök saknade effekter"),
+    ("file.findMissing", "Find Missing Fonts", "Sök saknade typsnitt"),
+    ("file.findMissing", "Find Missing Footage", "Sök saknat filmmaterial"),
+    ("file.relinkFootage", "Relink Missing Footage...", "Länka om saknat filmmaterial..."),
+    ("file.watchFolder", "Watch Folder...", "Bevakad mapp..."),
+    ("", "Scripts", "Skript"),
+    ("file.installScript", "Install Script File...", "Installera skriptfil..."),
+    ("file.installScriptUIPanel", "Install ScriptUI Panel...", "Installera ScriptUI-panel..."),
+    ("file.runScript", "Run Script File...", "Kör skriptfil..."),
+    ("", "Create Proxy", "Skapa proxy"),
+    ("file.createProxy", "Still...", "Stillbild..."),
+    ("file.createProxy", "Movie...", "Film..."),
+    ("", "Set Proxy", "Ange proxy"),
+    ("file.setProxy", "File...", "Fil..."),
+    ("file.setProxyNone", "None", "Ingen"),
+    ("", "Interpret Footage", "Tolka material"),
+    ("file.interpretFootage", "Main...", "Huvud..."),
+    ("file.interpretProxy", "Proxy...", "Proxy..."),
+    ("file.rememberInterpretation", "Remember Interpretation", "Kom ihåg tolkning"),
+    ("file.applyInterpretation", "Apply Interpretation", "Använd tolkning"),
+    ("", "Replace Footage", "Ersätt material"),
+    ("file.replaceFootage", "File...", "Fil..."),
+    ("file.replaceWithPlaceholder", "Placeholder...", "Platshållare..."),
+    ("file.replaceWithSolid", "Solid...", "Enfärgad..."),
+    ("file.replaceWithLayeredComp", "With Layered Comp", "Med komposition i lager"),
+    ("file.reloadFootage", "Reload Footage", "Läs in filmmaterial igen"),
+    ("file.revealInFinder", "Reveal in Finder", "Visa i Finder"),
+    ("file.projectSettings", "Project Settings...", "Projektinställningar..."),
+    ("app.quit", "Exit", "Avsluta"),
+    ("", "Edit", "Redigera"),
+    ("edit.undo", "Undo", "Ångra"),
+    ("edit.redo", "Redo", "Gör om"),
+    ("", "History", "Historik"),
+    ("app.commandPalette", "Quick Apply...", "Använd snabbt..."),
+    ("edit.cut", "Cut", "Klipp ut"),
+    ("edit.copy", "Copy", "Kopiera"),
+    ("edit.copyWithPropertyLinks", "Copy with Property Links", "Kopiera med egenskapslänkar"),
+    ("edit.copyWithRelativePropertyLinks", "Copy with Relative Property Links", "Kopiera med relativa egenskapslänkar"),
+    ("edit.copyExpressionOnly", "Copy Expression Only", "Kopiera endast uttryck"),
+    ("edit.paste", "Paste", "Klistra in"),
+    ("edit.pasteReversedKeyframes", "Paste Reversed Keyframes", "Klistra in omvända nyckelbildrutor"),
+    ("edit.pasteTextMatchFormatting", "Paste Text and Match Formatting", "Klistra in text och matcha formatering"),
+    ("edit.pasteTextFormattingOnly", "Paste Text Formatting Only", "Klistra in endast textformatering"),
+    ("edit.clear", "Clear", "Rensa"),
+    ("edit.duplicate", "Duplicate", "Duplicera"),
+    ("edit.splitLayer", "Split Layer", "Dela lager"),
+    ("edit.liftWorkArea", "Lift Work Area", "Lyft arbetsområde"),
+    ("edit.extractWorkArea", "Extract Work Area", "Extrahera arbetsområde"),
+    ("edit.selectAll", "Select All", "Markera alla"),
+    ("edit.deselectAll", "Deselect All", "Avmarkera alla"),
+    ("", "Label", "Etikett"),
+    ("edit.selectLabelGroup", "Select Label Group", "Markera etikettgrupp"),
+    ("edit.label", "None", "Ingen"),
+    ("edit.label", "Red", "Röd"),
+    ("edit.label", "Yellow", "Gul"),
+    ("edit.label", "Aqua", "Akvamarin"),
+    ("edit.label", "Pink", "Rosa"),
+    ("edit.label", "Lavender", "Lavendel"),
+    ("edit.label", "Peach", "Persika"),
+    ("edit.label", "Sea Foam", "Havsskum"),
+    ("edit.label", "Blue", "Blå"),
+    ("edit.label", "Green", "Grön"),
+    ("edit.label", "Purple", "Lila"),
+    ("edit.label", "Orange", "Orange"),
+    ("edit.label", "Brown", "Brun"),
+    ("edit.label", "Fuchsia", "Fuchsia"),
+    ("edit.label", "Cyan", "Cyan"),
+    ("edit.label", "Sandstone", "Sandsten"),
+    ("edit.label", "Dark Green", "Mörkgrön"),
+    ("app.settings", "Edit Label Colors...", "Redigera etikettfärger..."),
+    ("", "Select Keyframe Label Group", "Markera etikettgrupp för nyckelbildrutor"),
+    ("keys.selectLabelGroup", "On Selected Layers", "På markerade lager"),
+    ("keys.selectLabelGroup", "On All Layers", "På alla lager"),
+    ("keys.selectLabelGroup", "Visible Keyframes on Selected Layers", "Synliga nyckelbildrutor på markerade lager"),
+    ("keys.selectLabelGroup", "Visible Keyframes on All Layers", "Synliga nyckelbildrutor på alla lager"),
+    ("", "Purge", "Rensa"),
+    ("edit.purge", "All Cache...", "All cache..."),
+    ("edit.purge", "All Memory & Disk Cache...", "Allt minne och all diskcache..."),
+    ("edit.purge", "All Memory", "Allt minne"),
+    ("edit.purge", "All Disk Cache...", "All diskcache..."),
+    ("edit.purge", "All 3D Cache...", "All 3D-cache..."),
+    ("edit.purgeUndo", "Undo", "Ångra"),
+    ("edit.purge", "Image Cache Memory", "Bildcacheminne"),
+    ("edit.purge", "Snapshot", "Ögonblicksbild"),
+    ("edit.editOriginal", "Edit Original...", "Redigera original..."),
+    ("", "Templates", "Mallar"),
+    ("app.templates", "Render Settings...", "Renderingsinställningar..."),
+    ("app.templates", "Output Module...", "Utgångsmodul..."),
+    ("app.keyboardShortcuts", "Keyboard Shortcuts", "Kortkommandon"),
+    ("", "Preferences", "Inställningar"),
+    ("", "Composition", "Komposition"),
+    ("comp.new", "New Composition...", "Ny komposition..."),
+    ("comp.settings", "Composition Settings...", "Kompositionsinställningar..."),
+    ("comp.setPosterTime", "Set Poster Time", "Ange affischtid"),
+    ("comp.trimToWorkArea", "Trim Comp to Work Area", "Trimma komp till arbetsområde"),
+    ("comp.cropToRegionOfInterest", "Crop Comp to Region of Interest", "Beskär komp till intresseregion"),
+    ("comp.cropToLayerBounds", "Crop Comp to Selected Layer(s) Bounds", "Beskär komp till markerade lager(s) gränser"),
+    ("render.addOutputModule", "Add Output Module", "Lägg till utgångsmodul"),
+    ("", "Preview", "Förhandsgranskning"),
+    ("playback.toggle", "Play Current Preview", "Spela upp aktuell förhandsgranskning"),
+    ("playback.cacheWhenIdle", "Cache Frames When Idle", "Cachelagra bildrutor vid inaktivitet"),
+    ("playback.audio", "Audio", "Ljud"),
+    ("", "Save Frame As", "Spara bildruta som"),
+    ("comp.saveFrameAs", "File...", "Fil..."),
+    ("comp.saveFrameAsPsd", "Photoshop Layers...", "Photoshop-lager..."),
+    ("comp.saveFrameAsExr", "ProEXR...", "ProEXR..."),
+    ("comp.copyFrame", "Copy Frame to Clipboard", "Kopiera bildruta till Urklipp"),
+    ("render.preRender", "Pre-render...", "Förrendera..."),
+    ("render.saveCurrentPreview", "Save Current Preview...", "Spara aktuell förhandsgranskning..."),
+    ("comp.openInEssentialGraphics", "Open in Essential Graphics", "Öppna i Grundläggande grafik"),
+    ("", "Responsive Design — Time", "Responsiv design — tid"),
+    ("comp.responsiveTime", "Create Intro", "Skapa intro"),
+    ("comp.responsiveTime", "Create Outro", "Skapa outro"),
+    ("comp.responsiveTime", "Create Protected Region from Work Area", "Skapa skyddad region från arbetsområde"),
+    ("comp.flowchart", "Composition Flowchart", "Kompositionsflödesschema"),
+    ("comp.miniFlowchart", "Composition Mini-Flowchart", "Kompositionens miniflödesschema"),
+    ("", "VR", "VR"),
+    ("comp.vr.createEnvironment", "Create VR Environment...", "Skapa VR-miljö..."),
+    ("comp.vr.extractCubemap", "Extract Cubemap...", "Extrahera kubkarta..."),
+    ("", "Layer", "Lager"),
+    ("layer.newText", "Text", "Text"),
+    ("layer.newSolid", "Solid...", "Enfärgad..."),
+    ("layer.newLight", "Light...", "Ljus..."),
+    ("layer.newCamera", "Camera...", "Kamera..."),
+    ("layer.newNull", "Null Object", "Nullobjekt"),
+    ("layer.newShape", "Shape Layer", "Formlager"),
+    ("layer.newAdjustment", "Adjustment Layer", "Justeringslager"),
+    ("layer.newContentAwareFill", "Content-Aware Fill Layer...", "Innehållsmedvetet fyllningslager..."),
+    ("layer.new3dPrimitive", "Cube", "Kub"),
+    ("layer.new3dPrimitive", "Sphere", "Sfär"),
+    ("layer.new3dPrimitive", "Plane", "Plan"),
+    ("layer.new3dPrimitive", "Torus", "Torus"),
+    ("layer.new3dPrimitive", "Cone", "Kon"),
+    ("layer.new3dPrimitive", "Cylinder", "Cylinder"),
+    ("layer.settings", "Layer Settings...", "Lagerinställningar..."),
+    ("layer.openLayer", "Open Layer", "Öppna lager"),
+    ("layer.openSource", "Open Layer Source", "Öppna lagerkälla"),
+    ("layer.revealInFinder", "Reveal in Finder", "Visa i Finder"),
+    ("", "Mask", "Mask"),
+    ("layer.addMask", "New Mask", "Ny mask"),
+    ("layer.mask.shape", "Mask Shape...", "Maskform..."),
+    ("layer.mask.set", "Mask Feather...", "Maskfjädring..."),
+    ("layer.mask.set", "Mask Opacity...", "Maskopacitet..."),
+    ("layer.mask.set", "Mask Expansion...", "Maskexpansion..."),
+    ("layer.mask.reset", "Reset Mask", "Återställ mask"),
+    ("layer.mask.remove", "Remove Mask", "Ta bort mask"),
+    ("layer.mask.removeAll", "Remove All Masks", "Ta bort alla masker"),
+    ("track.mask", "Track Mask", "Spåra mask"),
+    ("", "Mode", "Läge"),
+    ("layer.mask.mode", "None", "Ingen"),
+    ("layer.mask.mode", "Add", "Addera"),
+    ("layer.mask.mode", "Subtract", "Subtrahera"),
+    ("layer.mask.mode", "Intersect", "Skärning"),
+    ("layer.mask.mode", "Lighten", "Ljusare"),
+    ("layer.mask.mode", "Darken", "Mörkare"),
+    ("layer.mask.mode", "Difference", "Differens"),
+    ("layer.mask.invert", "Inverted", "Inverterad"),
+    ("layer.mask.lock", "Locked", "Låst"),
+    ("", "Motion Blur", "Rörelseoskärpa"),
+    ("layer.mask.motionBlur", "Same As Layer", "Samma som lagret"),
+    ("layer.mask.motionBlur", "On", "På"),
+    ("layer.mask.motionBlur", "Off", "Av"),
+    ("", "Feather Falloff", "Fjädringsavtagande"),
+    ("layer.mask.featherFalloff", "Smooth", "Mjuk"),
+    ("layer.mask.featherFalloff", "Linear", "Linjär"),
+    ("layer.mask.unlockAll", "Unlock All Masks", "Lås upp alla masker"),
+    ("layer.mask.lockOthers", "Lock Other Masks", "Lås andra masker"),
+    ("layer.mask.hideLocked", "Hide Locked Masks", "Dölj låsta masker"),
+    ("", "Mask and Shape Path", "Mask- och formbana"),
+    ("path.rotoBezier", "RotoBezier", "RotoBezier"),
+    ("mask.setClosed", "Closed", "Sluten"),
+    ("path.convertToBezier", "Convert To Bezier Path", "Konvertera till Bezierbana"),
+    ("path.setFirstVertex", "Set First Vertex", "Ange första hörnpunkt"),
+    ("path.freeTransform", "Free Transform Points", "Fri transformering av punkter"),
+    ("", "Quality", "Kvalitet"),
+    ("layer.quality", "Best", "Bästa"),
+    ("layer.quality", "Draft", "Utkast"),
+    ("layer.quality", "Wireframe", "Trådram"),
+    ("layer.sampling", "Bilinear", "Bilinjär"),
+    ("layer.sampling", "Bicubic", "Bikubisk"),
+    ("", "Switches", "Växlar"),
+    ("layer.hideOtherVideo", "Hide Other Video", "Dölj annan video"),
+    ("layer.showAllVideo", "Show All Video", "Visa all video"),
+    ("layer.unlockAll", "Unlock All Layers", "Lås upp alla lager"),
+    ("layer.expressions", "Enable Expressions", "Aktivera uttryck"),
+    ("layer.expressions", "Disable Expressions", "Inaktivera uttryck"),
+    ("layer.setSwitch", "Shy", "Blyg"),
+    ("layer.setSwitch", "Lock", "Lås"),
+    ("layer.setSwitch", "Audio", "Ljud"),
+    ("layer.setSwitch", "Video", "Video"),
+    ("layer.setSwitch", "Solo", "Solo"),
+    ("layer.setSwitch", "Effect", "Effekt"),
+    ("layer.setSwitch", "Collapse", "Komprimera"),
+    ("layer.setSwitch", "Motion Blur", "Rörelseoskärpa"),
+    ("layer.setSwitch", "Adjustment Layer", "Justeringslager"),
+    ("", "Transform", "Transformera"),
+    ("layer.transform", "Reset", "Återställ"),
+    ("layer.setTransform", "Anchor Point...", "Ankarpunkt..."),
+    ("layer.setTransform", "Position...", "Position..."),
+    ("layer.setTransform", "Scale...", "Skala..."),
+    ("layer.setTransform", "Orientation...", "Orientering..."),
+    ("layer.setTransform", "Rotation...", "Rotation..."),
+    ("layer.setTransform", "Opacity...", "Opacitet..."),
+    ("layer.transform", "Flip Horizontal", "Vänd vågrätt"),
+    ("layer.transform", "Flip Vertical", "Vänd lodrätt"),
+    ("layer.transform", "Center In View", "Centrera i vyn"),
+    ("layer.centerAnchor", "Center Anchor Point in Layer Content", "Centrera ankarpunkt i lagerinnehållet"),
+    ("layer.transform", "Fit to Comp", "Anpassa till kompositionen"),
+    ("layer.transform", "Fit to Comp Width", "Anpassa till kompositionens bredd"),
+    ("layer.transform", "Fit to Comp Height", "Anpassa till kompositionens höjd"),
+    ("layer.autoOrient", "Auto-Orient...", "Automatisk orientering..."),
+    ("", "Time", "Tid"),
+    ("layer.enableTimeRemap", "Enable Time Remapping", "Aktivera tidsomvandling"),
+    ("layer.timeReverse", "Time-Reverse Layer", "Tidsomvänd lager"),
+    ("layer.timeStretch", "Time Stretch...", "Tidssträckning..."),
+    ("layer.freezeFrame", "Freeze Frame", "Frys bildruta"),
+    ("layer.freezeOnLastFrame", "Freeze On Last Frame", "Frys på sista bildrutan"),
+    ("layer.alignVideoToData", "Align Video to Data", "Justera video efter data"),
+    ("", "Frame Blending", "Bildblandning"),
+    ("layer.frameBlending", "Off", "Av"),
+    ("layer.frameBlending", "Frame Mix", "Bildrutemix"),
+    ("layer.frameBlending", "Pixel Motion", "Pixelrörelse"),
+    ("layer.setSwitch", "3D Layer", "3D-lager"),
+    ("layer.setSwitch", "Guide Layer", "Hjälplager"),
+    ("layer.environment", "Environment Layer", "Miljölager"),
+    ("", "Markers", "Markörer"),
+    ("layer.addMarker", "Add Marker", "Lägg till markör"),
+    ("layer.updateMarkersFromSource", "Update Markers From Source", "Uppdatera markörer från källan"),
+    ("layer.markersLock", "Lock Markers", "Lås markörer"),
+    ("layer.deleteAllMarkers", "Delete All Markers", "Radera alla markörer"),
+    ("layer.setSwitch", "Preserve Transparency", "Bevara transparens"),
+    ("", "Blending Mode", "Blandningsläge"),
+    ("layer.setBlendMode", "Normal", "Normal"),
+    ("layer.setBlendMode", "Dissolve", "Övertoning"),
+    ("layer.setBlendMode", "Dancing Dissolve", "Dansande övertoning"),
+    ("layer.setBlendMode", "Darken", "Mörkare"),
+    ("layer.setBlendMode", "Multiply", "Multiplicera"),
+    ("layer.setBlendMode", "Color Burn", "Färgefterbelysning"),
+    ("layer.setBlendMode", "Classic Color Burn", "Klassisk färgefterbelysning"),
+    ("layer.setBlendMode", "Linear Burn", "Linjär efterbelysning"),
+    ("layer.setBlendMode", "Darker Color", "Mörkare färg"),
+    ("layer.setBlendMode", "Add", "Addera"),
+    ("layer.setBlendMode", "Lighten", "Ljusare"),
+    ("layer.setBlendMode", "Screen", "Skärm"),
+    ("layer.setBlendMode", "Color Dodge", "Färgskuggning"),
+    ("layer.setBlendMode", "Classic Color Dodge", "Klassisk färgskuggning"),
+    ("layer.setBlendMode", "Linear Dodge", "Linjär skuggning"),
+    ("layer.setBlendMode", "Lighter Color", "Ljusare färg"),
+    ("layer.setBlendMode", "Overlay", "Överlägg"),
+    ("layer.setBlendMode", "Soft Light", "Mjukt ljus"),
+    ("layer.setBlendMode", "Hard Light", "Hårt ljus"),
+    ("layer.setBlendMode", "Linear Light", "Linjärt ljus"),
+    ("layer.setBlendMode", "Vivid Light", "Intensivt ljus"),
+    ("layer.setBlendMode", "Pin Light", "Punktljus"),
+    ("layer.setBlendMode", "Hard Mix", "Hård blandning"),
+    ("layer.setBlendMode", "Difference", "Differens"),
+    ("layer.setBlendMode", "Classic Difference", "Klassisk differens"),
+    ("layer.setBlendMode", "Exclusion", "Uteslutning"),
+    ("layer.setBlendMode", "Subtract", "Subtrahera"),
+    ("layer.setBlendMode", "Divide", "Dividera"),
+    ("layer.setBlendMode", "Hue", "Nyans"),
+    ("layer.setBlendMode", "Saturation", "Mättnad"),
+    ("layer.setBlendMode", "Color", "Färg"),
+    ("layer.setBlendMode", "Luminosity", "Luminositet"),
+    ("layer.setBlendMode", "Stencil Alpha", "Schablon alfa"),
+    ("layer.setBlendMode", "Stencil Luma", "Schablon luma"),
+    ("layer.setBlendMode", "Silhouette Alpha", "Siluett alfa"),
+    ("layer.setBlendMode", "Silhouette Luma", "Siluett luma"),
+    ("layer.setBlendMode", "Alpha Add", "Alfa addera"),
+    ("layer.setBlendMode", "Luminescent Premul", "Luminiscent förmultiplicerad"),
+    ("layer.setBlendMode", "Next Blending Mode", "Nästa blandningsläge"),
+    ("layer.setBlendMode", "Previous Blending Mode", "Föregående blandningsläge"),
+    ("", "Track Matte", "Track matte"),
+    ("layer.trackMatte", "No Track Matte", "Ingen track matte"),
+    ("layer.trackMatte", "Alpha Matte", "Alfamatte"),
+    ("layer.trackMatte", "Alpha Inverted Matte", "Inverterad alfamatte"),
+    ("layer.trackMatte", "Luma Matte", "Lumamatte"),
+    ("layer.trackMatte", "Luma Inverted Matte", "Inverterad lumamatte"),
+    ("layer.trackMatte", "Matte with Layer Above", "Matte med lagret ovanför"),
+    ("layer.trackMatte", "Matte with Layer Below", "Matte med lagret nedanför"),
+    ("", "Layer Styles", "Lagerstilar"),
+    ("layer.style.options", "Layer Style Options...", "Lagerstilsalternativ..."),
+    ("layer.style.convertToEditable", "Convert to Editable Styles", "Konvertera till redigerbara stilar"),
+    ("layer.style.showAll", "Show All", "Visa alla"),
+    ("layer.style.removeAll", "Remove All", "Ta bort alla"),
+    ("layer.style.dropShadow", "Drop Shadow", "Slagskugga"),
+    ("layer.style.innerShadow", "Inner Shadow", "Inre skugga"),
+    ("layer.style.outerGlow", "Outer Glow", "Yttre glöd"),
+    ("layer.style.innerGlow", "Inner Glow", "Inre glöd"),
+    ("layer.style.bevelEmboss", "Bevel and Emboss", "Fasning och relief"),
+    ("layer.style.satin", "Satin", "Satin"),
+    ("layer.style.colorOverlay", "Color Overlay", "Färgöverlägg"),
+    ("layer.style.gradientOverlay", "Gradient Overlay", "Gradientöverlägg"),
+    ("layer.style.stroke", "Stroke", "Kontur"),
+    ("path.groupShapes", "Group Shapes", "Gruppera former"),
+    ("path.ungroupShapes", "Ungroup Shapes", "Avgruppera former"),
+    ("", "Arrange", "Ordna"),
+    ("layer.arrange", "Bring Layer to Front", "Lägg lager överst"),
+    ("layer.arrange", "Bring Layer Forward", "Flytta fram lager"),
+    ("layer.arrange", "Send Layer Backward", "Flytta bak lager"),
+    ("layer.arrange", "Send Layer to Back", "Lägg lager underst"),
+    ("", "Reveal", "Visa"),
+    ("layer.revealSource", "Reveal Layer Source in Project", "Visa lagerkälla i projektet"),
+    ("comp.flowchart", "Reveal Layer in Project Flowchart", "Visa lager i projektflödesschema"),
+    ("comp.revealInProject", "Reveal Composition in Project", "Visa komposition i projekt"),
+    ("layer.revealExpressionErrors", "Reveal Expression Errors", "Visa uttrycksfel"),
+    ("", "Create", "Skapa"),
+    ("layer.create", "Convert to Editable Text", "Konvertera till redigerbar text"),
+    ("layer.create", "Create Shapes from Text", "Skapa former från text"),
+    ("layer.create", "Create Masks from Text", "Skapa masker från text"),
+    ("layer.create", "Create Shapes from Vector Layer", "Skapa former från vektorlager"),
+    ("layer.create", "Create Keyframes from Data", "Skapa nyckelbildrutor från data"),
+    ("layer.create", "Null Controllers for Positional Points", "Null-kontroller för positionspunkter"),
+    ("layer.create", "Null Controllers for Path Points", "Null-kontroller för banpunkter"),
+    ("layer.create", "Nulls Following Path Points", "Nullobjekt som följer banpunkter"),
+    ("layer.create", "Null Tracing Along Path", "Null som spårar längs bana"),
+    ("layer.create", "Create 3D Layer Instance", "Skapa 3D-lagerinstans"),
+    ("", "Camera", "Kamera"),
+    ("camera.fromView", "Create Camera from 3D View", "Skapa kamera från 3D-vy"),
+    ("camera.stereoRig", "Create Stereo 3D Rig", "Skapa stereo-3D-rigg"),
+    ("camera.orbitNull", "Create Orbit Null", "Skapa null för kretsning"),
+    ("camera.fromModel", "Create Cameras from 3D Model", "Skapa kameror från 3D-modell"),
+    ("camera.linkFocusToPoi", "Link Focus Distance to Point of Interest", "Länka fokusavstånd till intressepunkt"),
+    ("camera.linkFocusToLayer", "Link Focus Distance to Layer", "Länka fokusavstånd till lager"),
+    ("camera.setFocusToLayer", "Set Focus Distance to Layer", "Ange fokusavstånd till lager"),
+    ("layer.cameraSettings", "Camera Settings...", "Kamerainställningar..."),
+    ("view.reset3DView", "Reset 3D View", "Återställ 3D-vy"),
+    ("", "Light", "Ljus"),
+    ("light.fromModel", "Create Lights from 3D Model", "Skapa ljus från 3D-modell"),
+    ("light.controlWithCamera", "Control Light with Camera", "Styr ljuset med kameran"),
+    ("light.environmentBackground", "Create Environment Light Background Layer", "Skapa bakgrundslager för miljöljus"),
+    ("", "Material", "Material"),
+    ("material.revealSource", "Reveal Material Source in Project", "Visa materialkällan i projektet"),
+    ("material.reset", "Reset Material", "Återställ material"),
+    ("material.duplicateAssign", "Duplicate and Assign Material", "Duplicera och tilldela material"),
+    ("layer.autoTrace", "Auto-trace...", "Automatisk konturspårning..."),
+    ("layer.precompose", "Pre-compose...", "Förkomponera..."),
+    ("layer.sceneEditDetection", "Scene Edit Detection...", "Identifiering av scensnitt..."),
+    ("", "Effect", "Effekt"),
+    ("window.panel", "Effect Controls", "Effektkontroller"),
+    ("effect.applyLast", "Last Effect", "Senaste effekten"),
+    ("effect.removeAll", "Remove All", "Ta bort alla"),
+    ("effect.manage", "Manage Effects...", "Hantera effekter..."),
+    ("effect.plugins.load", "Load Effect Plug-in...", "Läs in effektplugin..."),
+    ("", "Animation", "Animering"),
+    ("anim.savePreset", "Save Animation Preset...", "Spara animeringsförinställning..."),
+    ("anim.applyPreset", "Apply Animation Preset...", "Använd animeringsförinställning..."),
+    ("", "Recent Animation Presets", "Senaste animeringsförinställningar"),
+    ("anim.clearRecentPresets", "Clear Recent Presets", "Rensa senaste förinställningar"),
+    ("anim.browsePresets", "Browse Presets...", "Bläddra bland förinställningar..."),
+    ("", "Text Animation Presets", "Förinställningar för textanimering"),
+    ("layer.applyTextPreset", "Typewriter", "Skrivmaskin"),
+    ("layer.applyTextPreset", "Fade Up Characters", "Tona upp tecken"),
+    ("layer.applyTextPreset", "Bounce In Words", "Studsa in ord"),
+    ("layer.applyTextPreset", "Tracking In", "Spärrning in"),
+    ("layer.applyTextPreset", "Scramble", "Kasta om"),
+    ("layer.applyTextPreset", "Blur In", "Oskärpa in"),
+    ("layer.applyTextPreset", "Jitter", "Darr"),
+    ("layer.applyTextPreset", "Drop In Lines", "Släpp in rader"),
+    ("anim.addKeyframe", "Add Keyframe", "Lägg till nyckelbildruta"),
+    ("keys.toggleHold", "Toggle Hold Keyframe", "Växla hållen nyckelbildruta"),
+    ("keys.interpolation", "Keyframe Interpolation...", "Interpolering för nyckelbildrutor..."),
+    ("keys.velocity", "Keyframe Velocity...", "Ändringshastighet för nyckelbildrutor..."),
+    ("", "Keyframe Assistant", "Nyckelbildrutsassistent"),
+    ("keys.audioToKeyframes", "Convert Audio to Keyframes", "Konvertera ljud till nyckelbildrutor"),
+    ("prop.convertExpressionToKeyframes", "Convert Expression to Keyframes", "Konvertera uttryck till nyckelbildrutor"),
+    ("keys.easyEase", "Easy Ease", "Mjukt in och ut"),
+    ("keys.easyEaseIn", "Easy Ease In", "Mjukt in"),
+    ("keys.easyEaseOut", "Easy Ease Out", "Mjukt ut"),
+    ("keys.exponentialScale", "Exponential Scale", "Exponentiell skala"),
+    ("keys.rpfCameraImport", "RPF Camera Import", "RPF-kameraimport"),
+    ("layer.sequence", "Sequence Layers...", "Sekvensera lager..."),
+    ("keys.timeReverse", "Time-Reverse Keyframes", "Vänd nyckelbildrutor i tid"),
+    ("", "Animate Text", "Animera text"),
+    ("layer.enablePerChar3D", "Enable Per-character 3D", "Aktivera 3D per tecken"),
+    ("layer.addTextAnimator", "Anchor Point", "Ankarpunkt"),
+    ("layer.addTextAnimator", "Position", "Position"),
+    ("layer.addTextAnimator", "Scale", "Skala"),
+    ("layer.addTextAnimator", "Skew", "Skevning"),
+    ("layer.addTextAnimator", "Rotation", "Rotation"),
+    ("layer.addTextAnimator", "Opacity", "Opacitet"),
+    ("layer.addTextAnimator", "All Transform Properties", "Alla transformeringsegenskaper"),
+    ("", "Fill Color", "Fyllnadsfärg"),
+    ("layer.addTextAnimator", "RGB", "RGB"),
+    ("layer.addTextAnimator", "Hue", "Nyans"),
+    ("layer.addTextAnimator", "Saturation", "Mättnad"),
+    ("layer.addTextAnimator", "Brightness", "Ljusstyrka"),
+    ("", "Stroke Color", "Konturfärg"),
+    ("layer.addTextAnimator", "Stroke Width", "Konturbredd"),
+    ("", "Front", "Fram"),
+    ("", "Bevel", "Fasning"),
+    ("", "Side", "Sida"),
+    ("", "Back", "Tillbaka"),
+    ("layer.addTextAnimator", "Color", "Färg"),
+    ("layer.addTextAnimator", "Tracking", "Spärrning"),
+    ("layer.addTextAnimator", "Line Anchor", "Radankare"),
+    ("layer.addTextAnimator", "Line Spacing", "Radavstånd"),
+    ("layer.addTextAnimator", "Character Offset", "Teckenförskjutning"),
+    ("layer.addTextAnimator", "Character Value", "Teckenvärde"),
+    ("layer.addTextAnimator", "Blur", "Oskärpa"),
+    ("text.animatorFontAxes", "Variable Font Axes", "Axlar för variabla typsnitt"),
+    ("", "Add Text Selector", "Lägg till textväljare"),
+    ("text.addSelector", "Range", "Omfång"),
+    ("text.addSelector", "Wiggly", "Vickande"),
+    ("text.addSelector", "Expression", "Uttryck"),
+    ("text.removeAllAnimators", "Remove All Text Animators", "Ta bort alla textanimatörer"),
+    ("prop.setExpression", "Add Expression", "Lägg till uttryck"),
+    ("essential.addProperty", "Add Property to Essential Graphics", "Lägg till egenskap i Grundläggande grafik"),
+    ("prop.separateDimensions", "Separate Dimensions", "Separera dimensioner"),
+    ("track.camera", "Track Camera", "Spåra kamera"),
+    ("track.warpStabilizer", "Warp Stabilizer VFX", "Warp Stabilizer VFX"),
+    ("track.motion", "Track Motion", "Spåra rörelse"),
+    ("track.stabilize", "Stabilize Motion", "Stabilisera rörelse"),
+    ("track.property", "Track this Property", "Spåra den här egenskapen"),
+    ("anim.reveal", "Reveal Properties with Keyframes", "Visa egenskaper med nyckelbildrutor"),
+    ("anim.reveal", "Reveal Properties with Animation", "Visa egenskaper med animering"),
+    ("anim.reveal", "Reveal All Modified Properties", "Visa alla ändrade egenskaper"),
+    ("", "View", "Visa"),
+    ("view.newViewer", "New Viewer", "Ny visare"),
+    ("view.splitLockedViewer", "Split with New Locked Viewer", "Dela med ny låst visare"),
+    ("view.zoomIn", "Zoom In", "Zooma in"),
+    ("view.zoomOut", "Zoom Out", "Zooma ut"),
+    ("", "Resolution", "Upplösning"),
+    ("view.res.full", "Full", "Full"),
+    ("view.res.half", "Half", "Halv"),
+    ("view.res.third", "Third", "En tredjedel"),
+    ("view.res.quarter", "Quarter", "En fjärdedel"),
+    ("view.res.custom", "Custom...", "Anpassad..."),
+    ("view.displayColorManagement", "Use Display Color Management", "Använd färghantering för bildskärm"),
+    ("", "Simulate Output", "Simulera utgång"),
+    ("view.simulateOutput", "No Output Simulation", "Ingen utdatasimulering"),
+    ("view.simulateOutput", "HDTV (Rec. 709)", "HDTV (Rec. 709)"),
+    ("view.simulateOutput", "SDTV NTSC", "SDTV NTSC"),
+    ("view.simulateOutput", "SDTV PAL", "SDTV PAL"),
+    ("view.simulateOutput", "Legacy Macintosh RGB (Gamma 1.8)", "Äldre Macintosh RGB (gamma 1,8)"),
+    ("view.simulateOutput", "Internet Standard RGB (sRGB)", "Internetstandard-RGB (sRGB)"),
+    ("view.simulateOutput", "UHDTV (Rec. 2020)", "UHDTV (Rec. 2020)"),
+    ("view.simulateOutput", "Display P3", "Display P3"),
+    ("view.simulateOutput", "Linear (1.0 Gamma)", "Linjär (gamma 1,0)"),
+    ("view.customRgb", "My Custom RGB...", "Min anpassade RGB..."),
+    ("view.simulateOutput", "Custom...", "Anpassad..."),
+    ("view.rulers", "Show Rulers", "Visa linjaler"),
+    ("", "Panel Background Color", "Panelens bakgrundsfärg"),
+    ("view.panelBackground", "Black", "Svart"),
+    ("view.panelBackground", "Dark Gray", "Mörkgrå"),
+    ("view.panelBackground", "Medium Gray (Default)", "Mellangrå (standard)"),
+    ("view.panelBackground", "Light Gray", "Ljusgrå"),
+    ("view.panelBackground", "White", "Vit"),
+    ("view.panelBackground", "Custom", "Anpassad"),
+    ("view.panelBackground", "Select Custom Background Color...", "Välj anpassad bakgrundsfärg..."),
+    ("view.guides", "Show Guides", "Visa stödlinjer"),
+    ("view.snapToGuides", "Snap to Guides", "Fäst mot stödlinjer"),
+    ("view.lockGuides", "Lock Guides", "Lås stödlinjer"),
+    ("view.addGuide", "Add Guide...", "Lägg till stödlinje..."),
+    ("view.addPercentGuide", "Add Percentage Guide...", "Lägg till procentstödlinje..."),
+    ("view.convertGuides", "Convert Guides to Percentage", "Konvertera stödlinjer till procent"),
+    ("view.convertGuides", "Convert Guides to Pixels", "Konvertera stödlinjer till pixlar"),
+    ("view.clearGuides", "Clear Guides", "Rensa stödlinjer"),
+    ("view.importGuides", "Import Guides...", "Importera stödlinjer..."),
+    ("view.exportGuides", "Export Guides...", "Exportera stödlinjer..."),
+    ("view.grid", "Show Grid", "Visa rutnät"),
+    ("view.snapToGrid", "Snap to Grid", "Fäst mot rutnät"),
+    ("view.snapping", "Snapping", "Fäst"),
+    ("view.options", "View Options...", "Visningsalternativ..."),
+    ("view.layerControls", "Show Layer Controls", "Visa lagerkontroller"),
+    ("", "Switch View Layout", "Växla vylayout"),
+    ("view.layout", "1 View", "1 vy"),
+    ("view.layout", "2 Views", "2 vyer"),
+    ("view.layout", "4 Views", "4 vyer"),
+    ("view.shareViewOptions", "Share View Options", "Dela visningsalternativ"),
+    ("", "Switch 3D View", "Växla 3D-vy"),
+    ("view.3d.activeCamera", "Active Camera", "Aktiv kamera"),
+    ("view.3d.default", "Default", "Standard"),
+    ("view.3d.front", "Front", "Framifrån"),
+    ("view.3d.left", "Left", "Vänster"),
+    ("view.3d.top", "Top", "Ovanifrån"),
+    ("view.3d.back", "Back", "Bakifrån"),
+    ("view.3d.right", "Right", "Höger"),
+    ("view.3d.bottom", "Bottom", "Underifrån"),
+    ("view.3d.custom1", "Custom View 1", "Anpassad vy 1"),
+    ("view.3d.custom2", "Custom View 2", "Anpassad vy 2"),
+    ("view.3d.custom3", "Custom View 3", "Anpassad vy 3"),
+    ("", "Assign Shortcut to 3D View", "Tilldela kortkommando till 3D-vy"),
+    ("view.3d.last", "Switch to Last 3D View", "Växla till senaste 3D-vy"),
+    ("view.lookAtSelected", "Look at Selected Layers", "Titta på markerade lager"),
+    ("view.lookAtAll", "Look at All Layers", "Titta på alla lager"),
+    ("time.set", "Go to Time...", "Gå till tid..."),
+    ("view.fullScreen", "Enter Full Screen", "Visa i helskärm"),
+    ("", "Window", "Fönster"),
+    ("", "Workspace", "Arbetslayout"),
+    ("window.workspace", "Default", "Standard"),
+    ("window.workspace", "Review", "Granskning"),
+    ("window.workspace", "Learn", "Lär dig"),
+    ("window.workspace", "Small Screen", "Liten skärm"),
+    ("window.workspace", "Standard", "Standard"),
+    ("window.workspace", "All Panels", "Alla paneler"),
+    ("window.workspace", "Animation", "Animering"),
+    ("window.workspace", "Color", "Färg"),
+    ("window.workspace", "Effects", "Effekter"),
+    ("window.workspace", "Essential Graphics", "Grundläggande grafik"),
+    ("window.workspace", "Minimal", "Minimal"),
+    ("window.workspace", "Motion Tracking", "Rörelsespårning"),
+    ("window.workspace", "Paint", "Måla"),
+    ("window.workspace", "Text", "Text"),
+    ("window.workspace", "Undocked Panels", "Odockade paneler"),
+    ("window.resetWorkspace", "Reset to Saved Layout", "Återställ till sparad layout"),
+    ("window.saveWorkspace", "Save Changes to this Workspace", "Spara ändringar i den här arbetslayouten"),
+    ("window.saveWorkspaceAs", "Save as New Workspace...", "Spara som ny arbetslayout..."),
+    ("window.editWorkspaces", "Edit Workspaces...", "Redigera arbetslayouter..."),
+    ("", "Assign Shortcut to Workspace", "Tilldela kortkommando till arbetslayout"),
+    ("window.panel", "Align", "Justera"),
+    ("window.panel", "Audio", "Ljud"),
+    ("window.panel", "Brushes", "Penslar"),
+    ("window.panel", "Character", "Tecken"),
+    ("window.panel", "Content-Aware Fill", "Innehållsmedveten fyllning"),
+    ("window.panel", "Effects & Presets", "Effekter och förinställningar"),
+    ("window.panel", "Essential Graphics", "Grundläggande grafik"),
+    ("window.panel", "Info", "Info"),
+    ("help.inAppTutorials", "Learn", "Lär dig"),
+    ("window.panel", "Lumetri Scopes", "Lumetri-scope"),
+    ("window.panel", "Mask Interpolation", "Maskinterpolering"),
+    ("window.panel", "Media Browser", "Mediebläddrare"),
+    ("window.panel", "Metadata", "Metadata"),
+    ("window.panel", "Motion Sketch", "Rörelseskiss"),
+    ("window.panel", "Paint", "Måla"),
+    ("window.panel", "Paragraph", "Stycke"),
+    ("window.panel", "Preview", "Förhandsgranskning"),
+    ("window.panel", "Progress", "Förlopp"),
+    ("window.panel", "Properties", "Egenskaper"),
+    ("window.panel", "Script Console", "Skriptkonsol"),
+    ("window.panel", "Smoother", "Utjämnare"),
+    ("window.panel", "Tools", "Verktyg"),
+    ("window.panel", "Tracker", "Spårare"),
+    ("window.panel", "Wiggler", "Vickare"),
+    ("window.panel", "Composition", "Komposition"),
+    ("window.panel", "Flowchart", "Flödesschema"),
+    ("window.panel", "Footage", "Filmmaterial"),
+    ("window.panel", "Layer", "Lager"),
+    ("window.panel", "Project", "Projekt"),
+    ("window.panel", "Render Queue", "Renderingskö"),
+    ("window.panel", "Timeline", "Tidslinje"),
+    ("window.panel", "Create Nulls From Paths", "Skapa nullobjekt från banor"),
+    ("window.panel", "VR Comp Editor", "VR-kompositionsredigerare"),
+    ("", "Help", "Hjälp"),
+    ("help.docs", "EffectCraft Help...", "EffectCraft-hjälp..."),
+    ("help.docs", "Scripting Help...", "Hjälp för skript..."),
+    ("help.docs", "Expression Reference...", "Uttrycksreferens..."),
+    ("help.docs", "Effect Reference...", "Effektreferens..."),
+    ("anim.browsePresets", "Animation Presets...", "Animeringsförinställningar..."),
+    ("app.keyboardShortcuts", "Keyboard Shortcuts...", "Kortkommandon..."),
+    ("help.inAppTutorials", "In-App Tutorials...", "Självstudier i appen..."),
+    ("help.onlineTutorials", "Online Tutorials...", "Självstudier online..."),
+    ("help.systemReport", "System Compatibility Report...", "Systemkompatibilitetsrapport..."),
+    ("help.enableLogging", "Enable Logging", "Aktivera loggning"),
+    ("help.revealLogFile", "Reveal Logging File", "Visa loggfil"),
+    ("help.discord", "Join the ArtCraft Discord...", "Gå med i ArtCraft på Discord..."),
+    ("help.reportIssue", "Provide Feedback...", "Ge återkoppling..."),
+    ("help.website", "ArtCraft Website", "ArtCrafts webbplats"),
+    ("help.appPage", "EffectCraft Home Page", "EffectCrafts startsida"),
+    ("help.github", "EffectCraft on GitHub", "EffectCraft på GitHub"),
+    ("file.openDemoProject", "Open Demo Project", "Öppna demoprojekt"),
+    ("", "Recent Script Files", "Senaste skriptfiler"),
+    ("layer.newPrimitive", "3D Primitive...", "3D-primitiv..."),
+    ("keys.setMuted", "Mute Keyframes", "Stäng av nyckelbildrutor"),
+    ("keys.setMuted", "Unmute Keyframes", "Slå på nyckelbildrutor"),
+];
+
 /// Traditional Chinese (zh-hant): the same (command, English label) keys as `JAPANESE`, one
 /// entry per fixed menu row of the engine's menu tree, mirroring `SIMPLIFIED_CHINESE` in the
 /// vocabulary the sibling Craft apps' zh-hant catalogs use.
@@ -1104,6 +1810,7 @@ const TRADITIONAL_CHINESE: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "安裝指令碼檔案..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "安裝 ScriptUI 面板..."),
     ("file.runScript", "Run Script File...", "執行指令碼檔案..."),
+    ("", "Recent Script Files", "最近使用的指令碼檔案"),
     ("", "Create Proxy", "建立代理"),
     ("file.createProxy", "Still...", "靜態影像..."),
     ("file.createProxy", "Movie...", "影片..."),
@@ -1457,6 +2164,8 @@ const TRADITIONAL_CHINESE: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "行落下"),
     ("anim.addKeyframe", "Add Keyframe", "新增關鍵影格"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "切換定格關鍵影格"),
+    ("keys.setMuted", "Mute Keyframes", "靜音關鍵影格"),
+    ("keys.setMuted", "Unmute Keyframes", "取消靜音關鍵影格"),
     ("keys.interpolation", "Keyframe Interpolation...", "關鍵影格插補..."),
     ("keys.velocity", "Keyframe Velocity...", "關鍵影格速度..."),
     ("", "Keyframe Assistant", "關鍵影格輔助"),
@@ -1736,6 +2445,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "スクリプトファイルをインストール..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "ScriptUIパネルをインストール..."),
     ("file.runScript", "Run Script File...", "スクリプトファイルを実行..."),
+    ("", "Recent Script Files", "最近使用したスクリプトファイル"),
     ("", "Create Proxy", "プロキシを作成"),
     ("file.createProxy", "Still...", "静止画..."),
     ("file.createProxy", "Movie...", "ムービー..."),
@@ -1760,23 +2470,23 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("edit.undo", "Undo", "取り消し"),
     ("edit.redo", "Redo", "やり直し"),
     ("", "History", "履歴"),
-    ("app.commandPalette", "Quick Apply...", "クイック適用..."),
+    ("app.commandPalette", "Quick Apply...", "今すぐ適用..."),
     ("edit.cut", "Cut", "カット"),
     ("edit.copy", "Copy", "コピー"),
-    ("edit.copyWithPropertyLinks", "Copy with Property Links", "プロパティリンク付きでコピー"),
-    ("edit.copyWithRelativePropertyLinks", "Copy with Relative Property Links", "相対プロパティリンク付きでコピー"),
+    ("edit.copyWithPropertyLinks", "Copy with Property Links", "プロパティリンクと一緒にコピー"),
+    ("edit.copyWithRelativePropertyLinks", "Copy with Relative Property Links", "相対的なプロパティリンクと一緒にコピー"),
     ("edit.copyExpressionOnly", "Copy Expression Only", "エクスプレッションのみをコピー"),
     ("edit.paste", "Paste", "ペースト"),
-    ("edit.pasteReversedKeyframes", "Paste Reversed Keyframes", "逆順にキーフレームをペースト"),
-    ("edit.pasteTextMatchFormatting", "Paste Text and Match Formatting", "書式を合わせてテキストをペースト"),
-    ("edit.pasteTextFormattingOnly", "Paste Text Formatting Only", "テキストの書式のみをペースト"),
+    ("edit.pasteReversedKeyframes", "Paste Reversed Keyframes", "反転したキーフレームをペースト"),
+    ("edit.pasteTextMatchFormatting", "Paste Text and Match Formatting", "テキストをペーストし書式設定を一致させる"),
+    ("edit.pasteTextFormattingOnly", "Paste Text Formatting Only", "テキスト書式設定のみをペースト"),
     ("edit.clear", "Clear", "消去"),
     ("edit.duplicate", "Duplicate", "複製"),
     ("edit.splitLayer", "Split Layer", "レイヤーを分割"),
-    ("edit.liftWorkArea", "Lift Work Area", "ワークエリアをリフト"),
-    ("edit.extractWorkArea", "Extract Work Area", "ワークエリアを抽出"),
-    ("edit.selectAll", "Select All", "すべてを選択"),
-    ("edit.deselectAll", "Deselect All", "すべての選択を解除"),
+    ("edit.liftWorkArea", "Lift Work Area", "ワークエリアのリフト"),
+    ("edit.extractWorkArea", "Extract Work Area", "ワークエリアの抽出"),
+    ("edit.selectAll", "Select All", "すべて選択"),
+    ("edit.deselectAll", "Deselect All", "すべてを選択解除"),
     ("", "Label", "ラベル"),
     ("edit.selectLabelGroup", "Select Label Group", "ラベルグループを選択"),
     ("edit.label", "None", "なし"),
@@ -1802,7 +2512,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("keys.selectLabelGroup", "On All Layers", "すべてのレイヤー上"),
     ("keys.selectLabelGroup", "Visible Keyframes on Selected Layers", "選択したレイヤー上の表示キーフレーム"),
     ("keys.selectLabelGroup", "Visible Keyframes on All Layers", "すべてのレイヤー上の表示キーフレーム"),
-    ("", "Purge", "キャッシュを消去"),
+    ("", "Purge", "キャッシュの消去"),
     ("edit.purge", "All Cache...", "すべてのキャッシュ..."),
     ("edit.purge", "All Memory & Disk Cache...", "すべてのメモリおよびディスクキャッシュ..."),
     ("edit.purge", "All Memory", "すべてのメモリ"),
@@ -1822,7 +2532,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("comp.settings", "Composition Settings...", "コンポジション設定..."),
     ("comp.setPosterTime", "Set Poster Time", "ポスター時間を設定"),
     ("comp.trimToWorkArea", "Trim Comp to Work Area", "コンポジションをワークエリアにトリミング"),
-    ("comp.cropToRegionOfInterest", "Crop Comp to Region of Interest", "コンポジションを目標範囲にクロップ"),
+    ("comp.cropToRegionOfInterest", "Crop Comp to Region of Interest", "コンポジションを関心領域にクロップ"),
     ("comp.cropToLayerBounds", "Crop Comp to Selected Layer(s) Bounds", "コンポジションを選択レイヤーの境界にクロップ"),
     ("render.addOutputModule", "Add Output Module", "出力モジュールを追加"),
     ("", "Preview", "プレビュー"),
@@ -1855,7 +2565,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("layer.newShape", "Shape Layer", "シェイプレイヤー"),
     ("layer.newAdjustment", "Adjustment Layer", "調整レイヤー"),
     ("layer.newContentAwareFill", "Content-Aware Fill Layer...", "コンテンツに応じた塗りつぶしレイヤー..."),
-    ("layer.newPrimitive", "3D Primitive...", "3D プリミティブ..."),
+    ("layer.newPrimitive", "3D Primitive...", "3Dプリミティブ..."),
     ("layer.new3dPrimitive", "Cube", "立方体"),
     ("layer.new3dPrimitive", "Sphere", "球体"),
     ("layer.new3dPrimitive", "Plane", "平面"),
@@ -1875,7 +2585,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("layer.mask.reset", "Reset Mask", "マスクをリセット"),
     ("layer.mask.remove", "Remove Mask", "マスクを削除"),
     ("layer.mask.removeAll", "Remove All Masks", "すべてのマスクを削除"),
-    ("track.mask", "Track Mask", "マスクをトラック"),
+    ("track.mask", "Track Mask", "マスクをトラッキング"),
     ("", "Mode", "モード"),
     ("layer.mask.mode", "None", "なし"),
     ("layer.mask.mode", "Add", "加算"),
@@ -1940,8 +2650,8 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("layer.transform", "Fit to Comp Height", "コンポジションの高さに合わせる"),
     ("layer.autoOrient", "Auto-Orient...", "自動方向..."),
     ("", "Time", "時間"),
-    ("layer.enableTimeRemap", "Enable Time Remapping", "タイムリマップ使用可能"),
-    ("layer.timeReverse", "Time-Reverse Layer", "時間反転レイヤー"),
+    ("layer.enableTimeRemap", "Enable Time Remapping", "時間リマップを有効化"),
+    ("layer.timeReverse", "Time-Reverse Layer", "レイヤーを時間反転"),
     ("layer.timeStretch", "Time Stretch...", "時間伸縮..."),
     ("layer.freezeFrame", "Freeze Frame", "フレームを固定"),
     ("layer.freezeOnLastFrame", "Freeze On Last Frame", "最後のフレームで固定"),
@@ -2009,7 +2719,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("layer.trackMatte", "Matte with Layer Above", "上のレイヤーをマットにする"),
     ("layer.trackMatte", "Matte with Layer Below", "下のレイヤーをマットにする"),
     ("", "Layer Styles", "レイヤースタイル"),
-    ("layer.style.options", "Layer Style Options...", "レイヤースタイルオプション..."),
+    ("layer.style.options", "Layer Style Options...", "レイヤースタイルのオプション..."),
     ("layer.style.convertToEditable", "Convert to Editable Styles", "編集可能なスタイルに変換"),
     ("layer.style.showAll", "Show All", "すべてを表示"),
     ("layer.style.removeAll", "Remove All", "すべてを削除"),
@@ -2038,7 +2748,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("layer.create", "Convert to Editable Text", "編集可能なテキストに変換"),
     ("layer.create", "Create Shapes from Text", "テキストからシェイプを作成"),
     ("layer.create", "Create Masks from Text", "テキストからマスクを作成"),
-    ("layer.create", "Create Shapes from Vector Layer", "ベクトルレイヤーからシェイプを作成"),
+    ("layer.create", "Create Shapes from Vector Layer", "ベクターレイヤーからシェイプを作成"),
     ("layer.create", "Create Keyframes from Data", "データからキーフレームを作成"),
     ("layer.create", "Null Controllers for Positional Points", "位置のポイント用ヌルコントローラー"),
     ("layer.create", "Null Controllers for Path Points", "パスのポイント用ヌルコントローラー"),
@@ -2088,7 +2798,9 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Jitter", "ジッター"),
     ("layer.applyTextPreset", "Drop In Lines", "行をドロップイン"),
     ("anim.addKeyframe", "Add Keyframe", "キーフレームを追加"),
-    ("keys.toggleHold", "Toggle Hold Keyframe", "停止したキーフレームの切り替え"),
+    ("keys.toggleHold", "Toggle Hold Keyframe", "ホールドキーフレームの切り替え"),
+    ("keys.setMuted", "Mute Keyframes", "キーフレームをミュート"),
+    ("keys.setMuted", "Unmute Keyframes", "キーフレームのミュートを解除"),
     ("keys.interpolation", "Keyframe Interpolation...", "キーフレーム補間法..."),
     ("keys.velocity", "Keyframe Velocity...", "キーフレーム速度..."),
     ("", "Keyframe Assistant", "キーフレーム補助"),
@@ -2102,11 +2814,11 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("layer.sequence", "Sequence Layers...", "シーケンスレイヤー..."),
     ("keys.timeReverse", "Time-Reverse Keyframes", "時間反転キーフレーム"),
     ("", "Animate Text", "テキストをアニメート"),
-    ("layer.enablePerChar3D", "Enable Per-character 3D", "文字ごとの3Dを使用可能にする"),
+    ("layer.enablePerChar3D", "Enable Per-character 3D", "文字単位の 3D 化を使用"),
     ("layer.addTextAnimator", "Anchor Point", "アンカーポイント"),
     ("layer.addTextAnimator", "Position", "位置"),
     ("layer.addTextAnimator", "Scale", "スケール"),
-    ("layer.addTextAnimator", "Skew", "傾斜"),
+    ("layer.addTextAnimator", "Skew", "歪曲"),
     ("layer.addTextAnimator", "Rotation", "回転"),
     ("layer.addTextAnimator", "Opacity", "不透明度"),
     ("layer.addTextAnimator", "All Transform Properties", "すべてのトランスフォームプロパティ"),
@@ -2114,7 +2826,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("layer.addTextAnimator", "RGB", "RGB"),
     ("layer.addTextAnimator", "Hue", "色相"),
     ("layer.addTextAnimator", "Saturation", "彩度"),
-    ("layer.addTextAnimator", "Brightness", "明度"),
+    ("layer.addTextAnimator", "Brightness", "明るさ"),
     ("", "Stroke Color", "線のカラー"),
     ("layer.addTextAnimator", "Stroke Width", "線幅"),
     ("", "Front", "前面"),
@@ -2122,13 +2834,13 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("", "Side", "側面"),
     ("", "Back", "背面"),
     ("layer.addTextAnimator", "Color", "カラー"),
-    ("layer.addTextAnimator", "Tracking", "トラッキング"),
-    ("layer.addTextAnimator", "Line Anchor", "行のアンカー"),
-    ("layer.addTextAnimator", "Line Spacing", "行間"),
+    ("layer.addTextAnimator", "Tracking", "字送り"),
+    ("layer.addTextAnimator", "Line Anchor", "ラインアンカー"),
+    ("layer.addTextAnimator", "Line Spacing", "ラインスペース"),
     ("layer.addTextAnimator", "Character Offset", "文字のオフセット"),
-    ("layer.addTextAnimator", "Character Value", "文字の値"),
+    ("layer.addTextAnimator", "Character Value", "文字コード"),
     ("layer.addTextAnimator", "Blur", "ブラー"),
-    ("text.animatorFontAxes", "Variable Font Axes", "可変フォントの軸"),
+    ("text.animatorFontAxes", "Variable Font Axes", "バリアブルフォント軸"),
     ("", "Add Text Selector", "テキストセレクターを追加"),
     ("text.addSelector", "Range", "範囲"),
     ("text.addSelector", "Wiggly", "ウィグリー"),
@@ -2136,12 +2848,12 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("text.removeAllAnimators", "Remove All Text Animators", "すべてのテキストアニメーターを削除"),
     ("prop.setExpression", "Add Expression", "エクスプレッションを追加"),
     ("essential.addProperty", "Add Property to Essential Graphics", "エッセンシャルグラフィックスにプロパティを追加"),
-    ("prop.separateDimensions", "Separate Dimensions", "次元に分割"),
-    ("track.camera", "Track Camera", "カメラをトラック"),
+    ("prop.separateDimensions", "Separate Dimensions", "次元を分離"),
+    ("track.camera", "Track Camera", "カメラをトラッキング"),
     ("track.warpStabilizer", "Warp Stabilizer VFX", "ワープスタビライザーVFX"),
-    ("track.motion", "Track Motion", "モーションをトラック"),
-    ("track.stabilize", "Stabilize Motion", "モーションをスタビライズ"),
-    ("track.property", "Track this Property", "このプロパティをトラック"),
+    ("track.motion", "Track Motion", "モーションをトラッキング"),
+    ("track.stabilize", "Stabilize Motion", "モーションを安定化"),
+    ("track.property", "Track this Property", "このプロパティをトラッキング"),
     ("anim.reveal", "Reveal Properties with Keyframes", "キーフレームのあるプロパティを表示"),
     ("anim.reveal", "Reveal Properties with Animation", "アニメーションのあるプロパティを表示"),
     ("anim.reveal", "Reveal All Modified Properties", "変更されたすべてのプロパティを表示"),
@@ -2152,9 +2864,9 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("view.zoomOut", "Zoom Out", "ズームアウト"),
     ("", "Resolution", "解像度"),
     ("view.res.full", "Full", "フル画質"),
-    ("view.res.half", "Half", "1/2 画質"),
-    ("view.res.third", "Third", "1/3 画質"),
-    ("view.res.quarter", "Quarter", "1/4 画質"),
+    ("view.res.half", "Half", "1/2画質"),
+    ("view.res.third", "Third", "1/3画質"),
+    ("view.res.quarter", "Quarter", "1/4画質"),
     ("view.res.custom", "Custom...", "カスタム..."),
     ("view.displayColorManagement", "Use Display Color Management", "ディスプレイカラーマネジメントを使用"),
     ("", "Simulate Output", "出力をシミュレート"),
@@ -2200,16 +2912,16 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("view.shareViewOptions", "Share View Options", "表示オプションを共有"),
     ("", "Switch 3D View", "3Dビューを切り替え"),
     ("view.3d.activeCamera", "Active Camera", "アクティブカメラ"),
-    ("view.3d.default", "Default", "初期設定"),
-    ("view.3d.front", "Front", "フロント"),
-    ("view.3d.left", "Left", "レフト"),
-    ("view.3d.top", "Top", "トップ"),
-    ("view.3d.back", "Back", "バック"),
-    ("view.3d.right", "Right", "ライト"),
-    ("view.3d.bottom", "Bottom", "ボトム"),
-    ("view.3d.custom1", "Custom View 1", "カスタムビュー1"),
-    ("view.3d.custom2", "Custom View 2", "カスタムビュー2"),
-    ("view.3d.custom3", "Custom View 3", "カスタムビュー3"),
+    ("view.3d.default", "Default", "デフォルト"),
+    ("view.3d.front", "Front", "フロントビュー"),
+    ("view.3d.left", "Left", "レフトビュー"),
+    ("view.3d.top", "Top", "トップビュー"),
+    ("view.3d.back", "Back", "バックビュー"),
+    ("view.3d.right", "Right", "ライトビュー"),
+    ("view.3d.bottom", "Bottom", "ボトムビュー"),
+    ("view.3d.custom1", "Custom View 1", "カスタムビュー 1"),
+    ("view.3d.custom2", "Custom View 2", "カスタムビュー 2"),
+    ("view.3d.custom3", "Custom View 3", "カスタムビュー 3"),
     ("", "Assign Shortcut to 3D View", "3Dビューにショートカットを割り当て"),
     ("view.3d.last", "Switch to Last 3D View", "最後の3Dビューに切り替え"),
     ("view.lookAtSelected", "Look at Selected Layers", "選択したレイヤーを見る"),
@@ -2221,7 +2933,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("window.workspace", "Default", "初期設定"),
     ("window.workspace", "Review", "レビュー"),
     ("window.workspace", "Learn", "学習"),
-    ("window.workspace", "Small Screen", "小画面"),
+    ("window.workspace", "Small Screen", "小さい画面"),
     ("window.workspace", "Standard", "標準"),
     ("window.workspace", "All Panels", "すべてのパネル"),
     ("window.workspace", "Animation", "アニメーション"),
@@ -2234,7 +2946,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("window.workspace", "Text", "テキスト"),
     ("window.workspace", "Undocked Panels", "ドッキング解除したパネル"),
     ("window.resetWorkspace", "Reset to Saved Layout", "保存したレイアウトにリセット"),
-    ("window.saveWorkspace", "Save Changes to this Workspace", "このワークスペースの変更を保存"),
+    ("window.saveWorkspace", "Save Changes to this Workspace", "このワークスペースへの変更を保存"),
     ("window.saveWorkspaceAs", "Save as New Workspace...", "新規ワークスペースとして保存..."),
     ("window.editWorkspaces", "Edit Workspaces...", "ワークスペースを編集..."),
     ("", "Assign Shortcut to Workspace", "ワークスペースにショートカットを割り当て"),
@@ -2371,6 +3083,7 @@ const UKRAINIAN: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "Встановити файл скрипту..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "Встановити панель ScriptUI..."),
     ("file.runScript", "Run Script File...", "Виконати файл скрипту..."),
+    ("", "Recent Script Files", "Нещодавні файли скриптів"),
     ("", "Create Proxy", "Створити проксі"),
     ("file.createProxy", "Still...", "Зображення..."),
     ("file.createProxy", "Movie...", "Відео..."),
@@ -2724,6 +3437,8 @@ const UKRAINIAN: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Поява рядків згори"),
     ("anim.addKeyframe", "Add Keyframe", "Додати ключовий кадр"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Перемкнути утримання ключового кадру"),
+    ("keys.setMuted", "Mute Keyframes", "Заглушити ключові кадри"),
+    ("keys.setMuted", "Unmute Keyframes", "Зняти заглушення ключових кадрів"),
     ("keys.interpolation", "Keyframe Interpolation...", "Інтерполяція ключових кадрів..."),
     ("keys.velocity", "Keyframe Velocity...", "Швидкість ключових кадрів..."),
     ("", "Keyframe Assistant", "Помічник ключових кадрів"),
@@ -3007,6 +3722,7 @@ const SPANISH: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "Instalar archivo de script..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "Instalar panel de ScriptUI..."),
     ("file.runScript", "Run Script File...", "Ejecutar archivo de script..."),
+    ("", "Recent Script Files", "Archivos de script recientes"),
     ("", "Create Proxy", "Crear proxy"),
     ("file.createProxy", "Still...", "Imagen fija..."),
     ("file.createProxy", "Movie...", "Película..."),
@@ -3360,6 +4076,8 @@ const SPANISH: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Entrada de líneas cayendo"),
     ("anim.addKeyframe", "Add Keyframe", "Añadir fotograma clave"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Conmutar mantener fotograma clave"),
+    ("keys.setMuted", "Mute Keyframes", "Silenciar fotogramas clave"),
+    ("keys.setMuted", "Unmute Keyframes", "Reactivar fotogramas clave"),
     ("keys.interpolation", "Keyframe Interpolation...", "Interpolación de fotogramas clave..."),
     ("keys.velocity", "Keyframe Velocity...", "Velocidad de fotogramas clave..."),
     ("", "Keyframe Assistant", "Asistente de fotogramas clave"),
@@ -3641,6 +4359,7 @@ const PORTUGUESE: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "Instalar arquivo de script..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "Instalar painel ScriptUI..."),
     ("file.runScript", "Run Script File...", "Executar arquivo de script..."),
+    ("", "Recent Script Files", "Arquivos de script recentes"),
     ("", "Create Proxy", "Criar proxy"),
     ("file.createProxy", "Still...", "Imagem fixa..."),
     ("file.createProxy", "Movie...", "Filme..."),
@@ -3994,6 +4713,8 @@ const PORTUGUESE: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Entrar com queda de linhas"),
     ("anim.addKeyframe", "Add Keyframe", "Adicionar quadro-chave"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Alternar quadro-chave de retenção"),
+    ("keys.setMuted", "Mute Keyframes", "Silenciar quadros-chave"),
+    ("keys.setMuted", "Unmute Keyframes", "Reativar quadros-chave"),
     ("keys.interpolation", "Keyframe Interpolation...", "Interpolação de quadro-chave..."),
     ("keys.velocity", "Keyframe Velocity...", "Velocidade do quadro-chave..."),
     ("", "Keyframe Assistant", "Assistente de quadro-chave"),
@@ -4283,6 +5004,7 @@ const RUSSIAN: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "Установить файл скрипта..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "Установить панель ScriptUI..."),
     ("file.runScript", "Run Script File...", "Выполнить файл скрипта..."),
+    ("", "Recent Script Files", "Недавние файлы скриптов"),
     ("", "Create Proxy", "Создать суррогат"),
     ("file.createProxy", "Still...", "Стоп-кадр..."),
     ("file.createProxy", "Movie...", "Видео..."),
@@ -4635,6 +5357,8 @@ const RUSSIAN: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Появление строк сверху"),
     ("anim.addKeyframe", "Add Keyframe", "Добавить ключевой кадр"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Переключить фиксацию ключевого кадра"),
+    ("keys.setMuted", "Mute Keyframes", "Отключить ключевые кадры"),
+    ("keys.setMuted", "Unmute Keyframes", "Включить ключевые кадры"),
     ("keys.interpolation", "Keyframe Interpolation...", "Интерполяция ключевых кадров..."),
     ("keys.velocity", "Keyframe Velocity...", "Скорость ключевых кадров..."),
     ("", "Keyframe Assistant", "Помощник по ключевым кадрам"),
@@ -4917,6 +5641,7 @@ const FRENCH: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "Installer un fichier de script..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "Installer un panneau ScriptUI..."),
     ("file.runScript", "Run Script File...", "Exécuter un fichier de script..."),
+    ("", "Recent Script Files", "Fichiers de script récents"),
     ("", "Create Proxy", "Créer un proxy"),
     ("file.createProxy", "Still...", "Image fixe..."),
     ("file.createProxy", "Movie...", "Vidéo..."),
@@ -5269,6 +5994,8 @@ const FRENCH: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Chute des lignes depuis le haut"),
     ("anim.addKeyframe", "Add Keyframe", "Ajouter une image clé"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Activer/Désactiver l'image clé figée"),
+    ("keys.setMuted", "Mute Keyframes", "Désactiver les images clés"),
+    ("keys.setMuted", "Unmute Keyframes", "Réactiver les images clés"),
     ("keys.interpolation", "Keyframe Interpolation...", "Interpolation des images clés..."),
     ("keys.velocity", "Keyframe Velocity...", "Vitesse des images clés..."),
     ("", "Keyframe Assistant", "Assistant d'images clés"),
@@ -5551,6 +6278,7 @@ const GERMAN: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "Skriptdatei installieren..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "ScriptUI-Bedienfeld installieren..."),
     ("file.runScript", "Run Script File...", "Skriptdatei ausführen..."),
+    ("", "Recent Script Files", "Zuletzt verwendete Skriptdateien"),
     ("", "Create Proxy", "Proxy erstellen"),
     ("file.createProxy", "Still...", "Standbild..."),
     ("file.createProxy", "Movie...", "Film..."),
@@ -5903,6 +6631,8 @@ const GERMAN: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Zeilen fallen ein"),
     ("anim.addKeyframe", "Add Keyframe", "Keyframe hinzufügen"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Halte-Keyframe umschalten"),
+    ("keys.setMuted", "Mute Keyframes", "Keyframes stummschalten"),
+    ("keys.setMuted", "Unmute Keyframes", "Keyframes wieder aktivieren"),
     ("keys.interpolation", "Keyframe Interpolation...", "Keyframe-Interpolation..."),
     ("keys.velocity", "Keyframe Velocity...", "Keyframe-Geschwindigkeit..."),
     ("", "Keyframe Assistant", "Keyframe-Assistent"),
@@ -6102,6 +6832,640 @@ const GERMAN: &[(&str, &str, &str)] = &[
 
 // <<< generated i18n catalogs
 
+/// Polish (pl): original phrase translations of every fixed menu entry.
+const POLISH: &[(&str, &str, &str)] = &[
+    ("", "Front", "Przód"),
+    ("", "Bevel", "Fazowanie"),
+    ("", "Side", "Bok"),
+    ("", "Back", "Tył"),
+    ("layer.addTextAnimator", "Color", "Kolor"),
+    ("", "EffectCraft", "EffectCraft"),
+    ("app.about", "About EffectCraft...", "O programie EffectCraft..."),
+    ("", "Settings...", "Ustawienia..."),
+    ("app.settings", "General...", "Ogólne..."),
+    ("app.settings", "Startup & Repair...", "Uruchamianie i naprawa..."),
+    ("app.settings", "Project...", "Projekt..."),
+    ("app.settings", "Composition...", "Kompozycja..."),
+    ("app.settings", "Previews...", "Podglądy..."),
+    ("app.settings", "Appearance...", "Wygląd..."),
+    ("app.settings", "Grids & Guides...", "Siatki i linie pomocnicze..."),
+    ("app.settings", "Labels...", "Etykiety..."),
+    ("app.settings", "Type...", "Tekst..."),
+    ("app.settings", "Import...", "Import..."),
+    ("app.settings", "Export...", "Eksport..."),
+    ("app.settings", "Audio...", "Audio..."),
+    ("app.settings", "Disk...", "Dysk..."),
+    ("app.settings", "Memory & CPU...", "Pamięć i procesor..."),
+    ("app.settings", "Video...", "Wideo..."),
+    ("app.settings", "3D...", "3D..."),
+    ("app.settings", "Scripting & Expressions...", "Skrypty i wyrażenia..."),
+    ("app.hide", "Hide EffectCraft", "Ukryj EffectCraft"),
+    ("app.hideOthers", "Hide Others", "Ukryj pozostałe"),
+    ("app.showAll", "Show All", "Pokaż wszystko"),
+    ("app.quit", "Quit EffectCraft", "Zakończ EffectCraft"),
+    ("", "File", "Plik"),
+    ("", "New", "Nowy"),
+    ("file.newProject", "New Project", "Nowy projekt"),
+    ("file.newFromTemplate", "New Project from Template...", "Nowy projekt z szablonu..."),
+    ("project.newFolder", "New Folder", "Nowy folder"),
+    ("file.open", "Open Project...", "Otwórz projekt..."),
+    ("", "Open Recent", "Otwórz ostatnie"),
+    ("file.clearRecent", "Clear Recent Projects", "Wyczyść ostatnie projekty"),
+    ("file.close", "Close", "Zamknij"),
+    ("file.closeProject", "Close Project", "Zamknij projekt"),
+    ("file.save", "Save", "Zapisz"),
+    ("", "Save As", "Zapisz jako"),
+    ("file.saveAs", "Save As...", "Zapisz jako..."),
+    ("file.saveCopy", "Save a Copy...", "Zapisz kopię..."),
+    ("file.saveCopyAsXml", "Save a Copy As XML...", "Zapisz kopię jako XML..."),
+    ("templates.saveAs", "Save as Template...", "Zapisz jako szablon..."),
+    ("file.incrementAndSave", "Increment and Save", "Zapisz z kolejnym numerem"),
+    ("file.revert", "Revert", "Przywróć"),
+    ("", "Import", "Importuj"),
+    ("file.import", "File...", "Plik..."),
+    ("file.importMultiple", "Multiple Files...", "Wiele plików..."),
+    ("file.importTimeline", "Adobe Premiere Pro Project...", "Projekt Adobe Premiere Pro..."),
+    ("file.importProject", "EffectCraft Project...", "Projekt EffectCraft..."),
+    ("file.importPlaceholder", "Placeholder...", "Element zastępczy..."),
+    ("file.importSolid", "Solid...", "Plansza..."),
+    ("file.importLottie", "Lottie...", "Lottie..."),
+    ("file.importVanishingPoint", "Vanishing Point (.vpe)...", "Punkt zbiegu (.vpe)..."),
+    ("essential.importTemplate", "Essential Graphics Template...", "Szablon Essential Graphics..."),
+    ("", "Import Recent Footage", "Importuj ostatnie materiały"),
+    ("file.clearRecentFootage", "Clear Recent Footage", "Wyczyść ostatnie materiały"),
+    ("", "Export", "Eksportuj"),
+    ("renderQueue.add", "Add to Render Queue", "Dodaj do kolejki renderowania"),
+    ("file.exportTimeline", "Adobe Premiere Pro Project...", "Projekt Adobe Premiere Pro..."),
+    ("file.exportLottie", "Lottie JSON...", "Lottie JSON..."),
+    ("essential.exportTemplate", "Essential Graphics Template...", "Szablon Essential Graphics..."),
+    ("app.find", "Find", "Znajdź"),
+    ("layer.addItem", "Add Footage to Comp", "Dodaj materiał do kompozycji"),
+    ("file.newCompFromSelection", "New Comp from Selection...", "Nowa kompozycja z zaznaczenia..."),
+    ("", "Dependencies", "Zależności"),
+    ("file.collectFiles", "Collect Files...", "Zbierz pliki..."),
+    ("file.consolidateFootage", "Consolidate All Footage", "Scal wszystkie materiały"),
+    ("file.removeUnusedFootage", "Remove Unused Footage", "Usuń nieużywane materiały"),
+    ("file.reduceProject", "Reduce Project", "Zredukuj projekt"),
+    ("file.findMissing", "Find Missing Effects", "Znajdź brakujące efekty"),
+    ("file.findMissing", "Find Missing Fonts", "Znajdź brakujące czcionki"),
+    ("file.findMissing", "Find Missing Footage", "Znajdź brakujące materiały"),
+    ("file.relinkFootage", "Relink Missing Footage...", "Połącz ponownie brakujące materiały..."),
+    ("file.watchFolder", "Watch Folder...", "Folder obserwowany..."),
+    ("", "Scripts", "Skrypty"),
+    ("file.installScript", "Install Script File...", "Zainstaluj plik skryptu..."),
+    ("file.installScriptUIPanel", "Install ScriptUI Panel...", "Zainstaluj panel ScriptUI..."),
+    ("file.runScript", "Run Script File...", "Uruchom plik skryptu..."),
+    ("", "Create Proxy", "Utwórz proxy"),
+    ("file.createProxy", "Still...", "Klatka..."),
+    ("file.createProxy", "Movie...", "Film..."),
+    ("", "Set Proxy", "Ustaw proxy"),
+    ("file.setProxy", "File...", "Plik..."),
+    ("file.setProxyNone", "None", "Brak"),
+    ("", "Interpret Footage", "Interpretuj materiał"),
+    ("file.interpretFootage", "Main...", "Główny..."),
+    ("file.interpretProxy", "Proxy...", "Proxy..."),
+    ("file.rememberInterpretation", "Remember Interpretation", "Zapamiętaj interpretację"),
+    ("file.applyInterpretation", "Apply Interpretation", "Zastosuj interpretację"),
+    ("", "Replace Footage", "Zastąp materiał"),
+    ("file.replaceFootage", "File...", "Plik..."),
+    ("file.replaceWithPlaceholder", "Placeholder...", "Element zastępczy..."),
+    ("file.replaceWithSolid", "Solid...", "Plansza..."),
+    ("file.replaceWithLayeredComp", "With Layered Comp", "Z warstwową kompozycją"),
+    ("file.reloadFootage", "Reload Footage", "Wczytaj ponownie materiał"),
+    ("file.revealInFinder", "Reveal in Finder", "Pokaż w Finderze"),
+    ("file.projectSettings", "Project Settings...", "Ustawienia projektu..."),
+    ("app.quit", "Exit", "Zakończ"),
+    ("", "Edit", "Edycja"),
+    ("edit.undo", "Undo", "Cofnij"),
+    ("edit.redo", "Redo", "Ponów"),
+    ("", "History", "Historia"),
+    ("app.commandPalette", "Quick Apply...", "Szybkie stosowanie..."),
+    ("edit.cut", "Cut", "Wytnij"),
+    ("edit.copy", "Copy", "Kopiuj"),
+    ("edit.copyWithPropertyLinks", "Copy with Property Links", "Kopiuj z łączami właściwości"),
+    ("edit.copyWithRelativePropertyLinks", "Copy with Relative Property Links", "Kopiuj ze względnymi łączami właściwości"),
+    ("edit.copyExpressionOnly", "Copy Expression Only", "Kopiuj tylko wyrażenie"),
+    ("edit.paste", "Paste", "Wklej"),
+    ("edit.pasteReversedKeyframes", "Paste Reversed Keyframes", "Wklej odwrócone klatki kluczowe"),
+    ("edit.pasteTextMatchFormatting", "Paste Text and Match Formatting", "Wklej tekst i dopasuj formatowanie"),
+    ("edit.pasteTextFormattingOnly", "Paste Text Formatting Only", "Wklej tylko formatowanie tekstu"),
+    ("edit.clear", "Clear", "Wyczyść"),
+    ("edit.duplicate", "Duplicate", "Powiel"),
+    ("edit.splitLayer", "Split Layer", "Podziel warstwę"),
+    ("edit.liftWorkArea", "Lift Work Area", "Wytnij obszar roboczy"),
+    ("edit.extractWorkArea", "Extract Work Area", "Wyodrębnij obszar roboczy"),
+    ("edit.selectAll", "Select All", "Zaznacz wszystko"),
+    ("edit.deselectAll", "Deselect All", "Usuń zaznaczenie"),
+    ("", "Label", "Etykieta"),
+    ("edit.selectLabelGroup", "Select Label Group", "Zaznacz grupę etykiet"),
+    ("edit.label", "None", "Brak"),
+    ("edit.label", "Red", "Czerwony"),
+    ("edit.label", "Yellow", "Żółty"),
+    ("edit.label", "Aqua", "Akwamaryna"),
+    ("edit.label", "Pink", "Różowy"),
+    ("edit.label", "Lavender", "Lawendowy"),
+    ("edit.label", "Peach", "Brzoskwiniowy"),
+    ("edit.label", "Sea Foam", "Morska piana"),
+    ("edit.label", "Blue", "Niebieski"),
+    ("edit.label", "Green", "Zielony"),
+    ("edit.label", "Purple", "Fioletowy"),
+    ("edit.label", "Orange", "Pomarańczowy"),
+    ("edit.label", "Brown", "Brązowy"),
+    ("edit.label", "Fuchsia", "Fuksja"),
+    ("edit.label", "Cyan", "Cyjan"),
+    ("edit.label", "Sandstone", "Piaskowiec"),
+    ("edit.label", "Dark Green", "Ciemnozielony"),
+    ("app.settings", "Edit Label Colors...", "Edytuj kolory etykiet..."),
+    ("", "Select Keyframe Label Group", "Zaznacz grupę etykiet klatek kluczowych"),
+    ("keys.selectLabelGroup", "On Selected Layers", "Na zaznaczonych warstwach"),
+    ("keys.selectLabelGroup", "On All Layers", "Na wszystkich warstwach"),
+    ("keys.selectLabelGroup", "Visible Keyframes on Selected Layers", "Widoczne klatki kluczowe na zaznaczonych warstwach"),
+    ("keys.selectLabelGroup", "Visible Keyframes on All Layers", "Widoczne klatki kluczowe na wszystkich warstwach"),
+    ("", "Purge", "Wyczyść pamięć"),
+    ("edit.purge", "All Cache...", "Całą pamięć podręczną..."),
+    ("edit.purge", "All Memory & Disk Cache...", "Całą pamięć i pamięć dyskową..."),
+    ("edit.purge", "All Memory", "Całą pamięć"),
+    ("edit.purge", "All Disk Cache...", "Całą pamięć dyskową..."),
+    ("edit.purge", "All 3D Cache...", "Całą pamięć 3D..."),
+    ("edit.purgeUndo", "Undo", "Cofanie"),
+    ("edit.purge", "Image Cache Memory", "Pamięć podręczna obrazów"),
+    ("edit.purge", "Snapshot", "Migawka"),
+    ("edit.editOriginal", "Edit Original...", "Edytuj oryginał..."),
+    ("", "Templates", "Szablony"),
+    ("app.templates", "Render Settings...", "Ustawienia renderowania..."),
+    ("app.templates", "Output Module...", "Moduł wyjściowy..."),
+    ("app.keyboardShortcuts", "Keyboard Shortcuts", "Skróty klawiaturowe"),
+    ("", "Preferences", "Preferencje"),
+    ("", "Composition", "Kompozycja"),
+    ("comp.new", "New Composition...", "Nowa kompozycja..."),
+    ("comp.settings", "Composition Settings...", "Ustawienia kompozycji..."),
+    ("comp.setPosterTime", "Set Poster Time", "Ustaw czas plakatu"),
+    ("comp.trimToWorkArea", "Trim Comp to Work Area", "Przytnij kompozycję do obszaru roboczego"),
+    ("comp.cropToRegionOfInterest", "Crop Comp to Region of Interest", "Kadruj kompozycję do obszaru zainteresowania"),
+    ("comp.cropToLayerBounds", "Crop Comp to Selected Layer(s) Bounds", "Kadruj kompozycję do granic zaznaczonych warstw (warstwy)"),
+    ("render.addOutputModule", "Add Output Module", "Dodaj moduł wyjściowy"),
+    ("", "Preview", "Podgląd"),
+    ("playback.toggle", "Play Current Preview", "Odtwórz bieżący podgląd"),
+    ("playback.cacheWhenIdle", "Cache Frames When Idle", "Buforuj klatki w bezczynności"),
+    ("playback.audio", "Audio", "Audio"),
+    ("", "Save Frame As", "Zapisz klatkę jako"),
+    ("comp.saveFrameAs", "File...", "Plik..."),
+    ("comp.saveFrameAsPsd", "Photoshop Layers...", "Warstwy Photoshopa..."),
+    ("comp.saveFrameAsExr", "ProEXR...", "ProEXR..."),
+    ("comp.copyFrame", "Copy Frame to Clipboard", "Kopiuj klatkę do schowka"),
+    ("render.preRender", "Pre-render...", "Wstępne renderowanie..."),
+    ("render.saveCurrentPreview", "Save Current Preview...", "Zapisz bieżący podgląd..."),
+    ("comp.openInEssentialGraphics", "Open in Essential Graphics", "Otwórz w Essential Graphics"),
+    ("", "Responsive Design — Time", "Projekt responsywny — czas"),
+    ("comp.responsiveTime", "Create Intro", "Utwórz intro"),
+    ("comp.responsiveTime", "Create Outro", "Utwórz outro"),
+    ("comp.responsiveTime", "Create Protected Region from Work Area", "Utwórz chroniony obszar z obszaru roboczego"),
+    ("comp.flowchart", "Composition Flowchart", "Schemat kompozycji"),
+    ("comp.miniFlowchart", "Composition Mini-Flowchart", "Miniaturowy schemat kompozycji"),
+    ("", "VR", "VR"),
+    ("comp.vr.createEnvironment", "Create VR Environment...", "Utwórz środowisko VR..."),
+    ("comp.vr.extractCubemap", "Extract Cubemap...", "Wyodrębnij cubemapę..."),
+    ("", "Layer", "Warstwa"),
+    ("layer.newText", "Text", "Tekst"),
+    ("layer.newSolid", "Solid...", "Plansza..."),
+    ("layer.newLight", "Light...", "Światło..."),
+    ("layer.newCamera", "Camera...", "Kamera..."),
+    ("layer.newNull", "Null Object", "Obiekt zerowy"),
+    ("layer.newShape", "Shape Layer", "Warstwa kształtu"),
+    ("layer.newAdjustment", "Adjustment Layer", "Warstwa korekcyjna"),
+    ("layer.newContentAwareFill", "Content-Aware Fill Layer...", "Warstwa wypełnienia z uwzględnieniem zawartości..."),
+    ("layer.new3dPrimitive", "Cube", "Sześcian"),
+    ("layer.new3dPrimitive", "Sphere", "Kula"),
+    ("layer.new3dPrimitive", "Plane", "Płaszczyzna"),
+    ("layer.new3dPrimitive", "Torus", "Torus"),
+    ("layer.new3dPrimitive", "Cone", "Stożek"),
+    ("layer.new3dPrimitive", "Cylinder", "Walec"),
+    ("layer.settings", "Layer Settings...", "Ustawienia warstwy..."),
+    ("layer.openLayer", "Open Layer", "Otwórz warstwę"),
+    ("layer.openSource", "Open Layer Source", "Otwórz źródło warstwy"),
+    ("layer.revealInFinder", "Reveal in Finder", "Pokaż w Finderze"),
+    ("", "Mask", "Maska"),
+    ("layer.addMask", "New Mask", "Nowa maska"),
+    ("layer.mask.shape", "Mask Shape...", "Kształt maski..."),
+    ("layer.mask.set", "Mask Feather...", "Wtapianie maski..."),
+    ("layer.mask.set", "Mask Opacity...", "Krycie maski..."),
+    ("layer.mask.set", "Mask Expansion...", "Rozszerzenie maski..."),
+    ("layer.mask.reset", "Reset Mask", "Resetuj maskę"),
+    ("layer.mask.remove", "Remove Mask", "Usuń maskę"),
+    ("layer.mask.removeAll", "Remove All Masks", "Usuń wszystkie maski"),
+    ("track.mask", "Track Mask", "Śledź maskę"),
+    ("", "Mode", "Tryb"),
+    ("layer.mask.mode", "None", "Brak"),
+    ("layer.mask.mode", "Add", "Dodaj"),
+    ("layer.mask.mode", "Subtract", "Odejmij"),
+    ("layer.mask.mode", "Intersect", "Część wspólna"),
+    ("layer.mask.mode", "Lighten", "Rozjaśnij"),
+    ("layer.mask.mode", "Darken", "Przyciemnij"),
+    ("layer.mask.mode", "Difference", "Różnica"),
+    ("layer.mask.invert", "Inverted", "Odwrócona"),
+    ("layer.mask.lock", "Locked", "Zablokowana"),
+    ("", "Motion Blur", "Rozmycie ruchu"),
+    ("layer.mask.motionBlur", "Same As Layer", "Jak warstwa"),
+    ("layer.mask.motionBlur", "On", "Wł."),
+    ("layer.mask.motionBlur", "Off", "Wył."),
+    ("", "Feather Falloff", "Zanikanie wtapiania"),
+    ("layer.mask.featherFalloff", "Smooth", "Gładkie"),
+    ("layer.mask.featherFalloff", "Linear", "Liniowe"),
+    ("layer.mask.unlockAll", "Unlock All Masks", "Odblokuj wszystkie maski"),
+    ("layer.mask.lockOthers", "Lock Other Masks", "Zablokuj pozostałe maski"),
+    ("layer.mask.hideLocked", "Hide Locked Masks", "Ukryj zablokowane maski"),
+    ("", "Mask and Shape Path", "Ścieżka maski i kształtu"),
+    ("path.rotoBezier", "RotoBezier", "RotoBezier"),
+    ("mask.setClosed", "Closed", "Zamknięta"),
+    ("path.convertToBezier", "Convert To Bezier Path", "Konwertuj na ścieżkę Béziera"),
+    ("path.setFirstVertex", "Set First Vertex", "Ustaw pierwszy wierzchołek"),
+    ("path.freeTransform", "Free Transform Points", "Swobodne przekształcanie punktów"),
+    ("", "Quality", "Jakość"),
+    ("layer.quality", "Best", "Najlepsza"),
+    ("layer.quality", "Draft", "Robocza"),
+    ("layer.quality", "Wireframe", "Szkielet"),
+    ("layer.sampling", "Bilinear", "Dwuliniowa"),
+    ("layer.sampling", "Bicubic", "Dwusześcienna"),
+    ("", "Switches", "Przełączniki"),
+    ("layer.hideOtherVideo", "Hide Other Video", "Ukryj pozostałe wideo"),
+    ("layer.showAllVideo", "Show All Video", "Pokaż całe wideo"),
+    ("layer.unlockAll", "Unlock All Layers", "Odblokuj wszystkie warstwy"),
+    ("layer.expressions", "Enable Expressions", "Włącz wyrażenia"),
+    ("layer.expressions", "Disable Expressions", "Wyłącz wyrażenia"),
+    ("layer.setSwitch", "Shy", "Nieśmiała"),
+    ("layer.setSwitch", "Lock", "Zablokuj"),
+    ("layer.setSwitch", "Audio", "Audio"),
+    ("layer.setSwitch", "Video", "Wideo"),
+    ("layer.setSwitch", "Solo", "Solo"),
+    ("layer.setSwitch", "Effect", "Efekt"),
+    ("layer.setSwitch", "Collapse", "Zwiń"),
+    ("layer.setSwitch", "Motion Blur", "Rozmycie ruchu"),
+    ("layer.setSwitch", "Adjustment Layer", "Warstwa korekcyjna"),
+    ("", "Transform", "Przekształć"),
+    ("layer.transform", "Reset", "Resetuj"),
+    ("layer.setTransform", "Anchor Point...", "Punkt zakotwiczenia..."),
+    ("layer.setTransform", "Position...", "Położenie..."),
+    ("layer.setTransform", "Scale...", "Skala..."),
+    ("layer.setTransform", "Orientation...", "Orientacja..."),
+    ("layer.setTransform", "Rotation...", "Obrót..."),
+    ("layer.setTransform", "Opacity...", "Krycie..."),
+    ("layer.transform", "Flip Horizontal", "Odbij w poziomie"),
+    ("layer.transform", "Flip Vertical", "Odbij w pionie"),
+    ("layer.transform", "Center In View", "Wyśrodkuj w widoku"),
+    ("layer.centerAnchor", "Center Anchor Point in Layer Content", "Wyśrodkuj punkt zakotwiczenia w zawartości warstwy"),
+    ("layer.transform", "Fit to Comp", "Dopasuj do kompozycji"),
+    ("layer.transform", "Fit to Comp Width", "Dopasuj do szerokości kompozycji"),
+    ("layer.transform", "Fit to Comp Height", "Dopasuj do wysokości kompozycji"),
+    ("layer.autoOrient", "Auto-Orient...", "Automatyczna orientacja..."),
+    ("", "Time", "Czas"),
+    ("layer.enableTimeRemap", "Enable Time Remapping", "Włącz przemapowanie czasu"),
+    ("layer.timeReverse", "Time-Reverse Layer", "Odwróć czas warstwy"),
+    ("layer.timeStretch", "Time Stretch...", "Rozciągnięcie czasu..."),
+    ("layer.freezeFrame", "Freeze Frame", "Zamrożenie klatki"),
+    ("layer.freezeOnLastFrame", "Freeze On Last Frame", "Zamroź na ostatniej klatce"),
+    ("layer.alignVideoToData", "Align Video to Data", "Wyrównaj wideo do danych"),
+    ("", "Frame Blending", "Mieszanie klatek"),
+    ("layer.frameBlending", "Off", "Wył."),
+    ("layer.frameBlending", "Frame Mix", "Miks klatek"),
+    ("layer.frameBlending", "Pixel Motion", "Ruch pikseli"),
+    ("layer.setSwitch", "3D Layer", "Warstwa 3D"),
+    ("layer.setSwitch", "Guide Layer", "Warstwa pomocnicza"),
+    ("layer.environment", "Environment Layer", "Warstwa środowiska"),
+    ("", "Markers", "Znaczniki"),
+    ("layer.addMarker", "Add Marker", "Dodaj znacznik"),
+    ("layer.updateMarkersFromSource", "Update Markers From Source", "Aktualizuj znaczniki ze źródła"),
+    ("layer.markersLock", "Lock Markers", "Zablokuj znaczniki"),
+    ("layer.deleteAllMarkers", "Delete All Markers", "Usuń wszystkie znaczniki"),
+    ("layer.setSwitch", "Preserve Transparency", "Zachowaj przezroczystość"),
+    ("", "Blending Mode", "Tryb mieszania"),
+    ("layer.setBlendMode", "Normal", "Normalny"),
+    ("layer.setBlendMode", "Dissolve", "Rozpuszczenie"),
+    ("layer.setBlendMode", "Dancing Dissolve", "Tańczące rozpuszczenie"),
+    ("layer.setBlendMode", "Darken", "Ciemniej"),
+    ("layer.setBlendMode", "Multiply", "Mnożenie"),
+    ("layer.setBlendMode", "Color Burn", "Ściemnianie koloru"),
+    ("layer.setBlendMode", "Classic Color Burn", "Klasyczne ściemnianie koloru"),
+    ("layer.setBlendMode", "Linear Burn", "Ściemnianie liniowe"),
+    ("layer.setBlendMode", "Darker Color", "Ciemniejszy kolor"),
+    ("layer.setBlendMode", "Add", "Dodaj"),
+    ("layer.setBlendMode", "Lighten", "Jaśniej"),
+    ("layer.setBlendMode", "Screen", "Mnożenie odwrotne"),
+    ("layer.setBlendMode", "Color Dodge", "Rozjaśnianie koloru"),
+    ("layer.setBlendMode", "Classic Color Dodge", "Klasyczne rozjaśnianie koloru"),
+    ("layer.setBlendMode", "Linear Dodge", "Rozjaśnianie liniowe"),
+    ("layer.setBlendMode", "Lighter Color", "Jaśniejszy kolor"),
+    ("layer.setBlendMode", "Overlay", "Nakładka"),
+    ("layer.setBlendMode", "Soft Light", "Łagodne światło"),
+    ("layer.setBlendMode", "Hard Light", "Ostre światło"),
+    ("layer.setBlendMode", "Linear Light", "Światło liniowe"),
+    ("layer.setBlendMode", "Vivid Light", "Jaskrawe światło"),
+    ("layer.setBlendMode", "Pin Light", "Światło punktowe"),
+    ("layer.setBlendMode", "Hard Mix", "Twarde mieszanie"),
+    ("layer.setBlendMode", "Difference", "Różnica"),
+    ("layer.setBlendMode", "Classic Difference", "Klasyczna różnica"),
+    ("layer.setBlendMode", "Exclusion", "Wykluczenie"),
+    ("layer.setBlendMode", "Subtract", "Odejmowanie"),
+    ("layer.setBlendMode", "Divide", "Dzielenie"),
+    ("layer.setBlendMode", "Hue", "Barwa"),
+    ("layer.setBlendMode", "Saturation", "Nasycenie"),
+    ("layer.setBlendMode", "Color", "Kolor"),
+    ("layer.setBlendMode", "Luminosity", "Jasność"),
+    ("layer.setBlendMode", "Stencil Alpha", "Szablon alfa"),
+    ("layer.setBlendMode", "Stencil Luma", "Szablon luma"),
+    ("layer.setBlendMode", "Silhouette Alpha", "Sylweta alfa"),
+    ("layer.setBlendMode", "Silhouette Luma", "Sylweta luma"),
+    ("layer.setBlendMode", "Alpha Add", "Dodawanie alfa"),
+    ("layer.setBlendMode", "Luminescent Premul", "Luminescencja premul"),
+    ("layer.setBlendMode", "Next Blending Mode", "Następny tryb mieszania"),
+    ("layer.setBlendMode", "Previous Blending Mode", "Poprzedni tryb mieszania"),
+    ("", "Track Matte", "Matowa ścieżka"),
+    ("layer.trackMatte", "No Track Matte", "Bez matowej ścieżki"),
+    ("layer.trackMatte", "Alpha Matte", "Matowa alfa"),
+    ("layer.trackMatte", "Alpha Inverted Matte", "Odwrócona matowa alfa"),
+    ("layer.trackMatte", "Luma Matte", "Matowa luma"),
+    ("layer.trackMatte", "Luma Inverted Matte", "Odwrócona matowa luma"),
+    ("layer.trackMatte", "Matte with Layer Above", "Matowa z warstwą powyżej"),
+    ("layer.trackMatte", "Matte with Layer Below", "Matowa z warstwą poniżej"),
+    ("", "Layer Styles", "Style warstwy"),
+    ("layer.style.options", "Layer Style Options...", "Opcje stylu warstwy..."),
+    ("layer.style.convertToEditable", "Convert to Editable Styles", "Konwertuj na edytowalne style"),
+    ("layer.style.showAll", "Show All", "Pokaż wszystkie"),
+    ("layer.style.removeAll", "Remove All", "Usuń wszystkie"),
+    ("layer.style.dropShadow", "Drop Shadow", "Cień"),
+    ("layer.style.innerShadow", "Inner Shadow", "Cień wewnętrzny"),
+    ("layer.style.outerGlow", "Outer Glow", "Blask zewnętrzny"),
+    ("layer.style.innerGlow", "Inner Glow", "Blask wewnętrzny"),
+    ("layer.style.bevelEmboss", "Bevel and Emboss", "Faza i płaskorzeźba"),
+    ("layer.style.satin", "Satin", "Satyna"),
+    ("layer.style.colorOverlay", "Color Overlay", "Nakładka koloru"),
+    ("layer.style.gradientOverlay", "Gradient Overlay", "Nakładka gradientu"),
+    ("layer.style.stroke", "Stroke", "Obrys"),
+    ("path.groupShapes", "Group Shapes", "Grupuj kształty"),
+    ("path.ungroupShapes", "Ungroup Shapes", "Rozgrupuj kształty"),
+    ("", "Arrange", "Kolejność"),
+    ("layer.arrange", "Bring Layer to Front", "Przesuń warstwę na wierzch"),
+    ("layer.arrange", "Bring Layer Forward", "Przesuń warstwę do przodu"),
+    ("layer.arrange", "Send Layer Backward", "Przesuń warstwę do tyłu"),
+    ("layer.arrange", "Send Layer to Back", "Przesuń warstwę na spód"),
+    ("", "Reveal", "Pokaż"),
+    ("layer.revealSource", "Reveal Layer Source in Project", "Pokaż źródło warstwy w projekcie"),
+    ("comp.flowchart", "Reveal Layer in Project Flowchart", "Pokaż warstwę w schemacie projektu"),
+    ("comp.revealInProject", "Reveal Composition in Project", "Pokaż kompozycję w projekcie"),
+    ("layer.revealExpressionErrors", "Reveal Expression Errors", "Pokaż błędy wyrażeń"),
+    ("", "Create", "Utwórz"),
+    ("layer.create", "Convert to Editable Text", "Konwertuj na edytowalny tekst"),
+    ("layer.create", "Create Shapes from Text", "Utwórz kształty z tekstu"),
+    ("layer.create", "Create Masks from Text", "Utwórz maski z tekstu"),
+    ("layer.create", "Create Shapes from Vector Layer", "Utwórz kształty z warstwy wektorowej"),
+    ("layer.create", "Create Keyframes from Data", "Utwórz klatki kluczowe z danych"),
+    ("layer.create", "Null Controllers for Positional Points", "Kontrolery zerowe dla punktów położenia"),
+    ("layer.create", "Null Controllers for Path Points", "Kontrolery zerowe dla punktów ścieżki"),
+    ("layer.create", "Nulls Following Path Points", "Obiekty zerowe podążające za punktami ścieżki"),
+    ("layer.create", "Null Tracing Along Path", "Obiekt zerowy wzdłuż ścieżki"),
+    ("layer.create", "Create 3D Layer Instance", "Utwórz instancję warstwy 3D"),
+    ("", "Camera", "Kamera"),
+    ("camera.fromView", "Create Camera from 3D View", "Utwórz kamerę z widoku 3D"),
+    ("camera.stereoRig", "Create Stereo 3D Rig", "Utwórz zestaw stereo 3D"),
+    ("camera.orbitNull", "Create Orbit Null", "Utwórz obiekt zerowy orbity"),
+    ("camera.fromModel", "Create Cameras from 3D Model", "Utwórz kamery z modelu 3D"),
+    ("camera.linkFocusToPoi", "Link Focus Distance to Point of Interest", "Powiąż odległość ostrości z punktem zainteresowania"),
+    ("camera.linkFocusToLayer", "Link Focus Distance to Layer", "Powiąż odległość ostrości z warstwą"),
+    ("camera.setFocusToLayer", "Set Focus Distance to Layer", "Ustaw odległość ostrości na warstwę"),
+    ("layer.cameraSettings", "Camera Settings...", "Ustawienia kamery..."),
+    ("view.reset3DView", "Reset 3D View", "Resetuj widok 3D"),
+    ("", "Light", "Światło"),
+    ("light.fromModel", "Create Lights from 3D Model", "Utwórz światła z modelu 3D"),
+    ("light.controlWithCamera", "Control Light with Camera", "Steruj światłem za pomocą kamery"),
+    ("light.environmentBackground", "Create Environment Light Background Layer", "Utwórz warstwę tła światła otoczenia"),
+    ("", "Material", "Materiał"),
+    ("material.revealSource", "Reveal Material Source in Project", "Pokaż źródło materiału w projekcie"),
+    ("material.reset", "Reset Material", "Resetuj materiał"),
+    ("material.duplicateAssign", "Duplicate and Assign Material", "Powiel i przypisz materiał"),
+    ("layer.autoTrace", "Auto-trace...", "Automatyczne obrysowanie..."),
+    ("layer.precompose", "Pre-compose...", "Utwórz kompozycję wstępną..."),
+    ("layer.sceneEditDetection", "Scene Edit Detection...", "Wykrywanie zmian scen..."),
+    ("", "Effect", "Efekt"),
+    ("window.panel", "Effect Controls", "Ustawienia efektów"),
+    ("effect.applyLast", "Last Effect", "Ostatni efekt"),
+    ("effect.removeAll", "Remove All", "Usuń wszystkie"),
+    ("effect.manage", "Manage Effects...", "Zarządzaj efektami..."),
+    ("effect.plugins.load", "Load Effect Plug-in...", "Wczytaj wtyczkę efektu..."),
+    ("", "Animation", "Animacja"),
+    ("anim.savePreset", "Save Animation Preset...", "Zapisz ustawienie animacji..."),
+    ("anim.applyPreset", "Apply Animation Preset...", "Zastosuj ustawienie animacji..."),
+    ("", "Recent Animation Presets", "Ostatnie ustawienia animacji"),
+    ("anim.clearRecentPresets", "Clear Recent Presets", "Wyczyść ostatnie ustawienia"),
+    ("anim.browsePresets", "Browse Presets...", "Przeglądaj ustawienia..."),
+    ("", "Text Animation Presets", "Ustawienia animacji tekstu"),
+    ("layer.applyTextPreset", "Typewriter", "Maszyna do pisania"),
+    ("layer.applyTextPreset", "Fade Up Characters", "Pojawianie się znaków"),
+    ("layer.applyTextPreset", "Bounce In Words", "Odbijające się słowa"),
+    ("layer.applyTextPreset", "Tracking In", "Zbliżanie liter"),
+    ("layer.applyTextPreset", "Scramble", "Mieszanie znaków"),
+    ("layer.applyTextPreset", "Blur In", "Wyostrzanie z rozmycia"),
+    ("layer.applyTextPreset", "Jitter", "Drganie"),
+    ("layer.applyTextPreset", "Drop In Lines", "Wpadające wiersze"),
+    ("anim.addKeyframe", "Add Keyframe", "Dodaj klatkę kluczową"),
+    ("keys.toggleHold", "Toggle Hold Keyframe", "Przełącz klatkę zatrzymania"),
+    ("keys.interpolation", "Keyframe Interpolation...", "Interpolacja klatek kluczowych..."),
+    ("keys.velocity", "Keyframe Velocity...", "Prędkość klatek kluczowych..."),
+    ("", "Keyframe Assistant", "Asystent klatek kluczowych"),
+    ("keys.audioToKeyframes", "Convert Audio to Keyframes", "Konwertuj audio na klatki kluczowe"),
+    ("prop.convertExpressionToKeyframes", "Convert Expression to Keyframes", "Konwertuj wyrażenie na klatki kluczowe"),
+    ("keys.easyEase", "Easy Ease", "Łagodne przejście"),
+    ("keys.easyEaseIn", "Easy Ease In", "Łagodne wejście"),
+    ("keys.easyEaseOut", "Easy Ease Out", "Łagodne wyjście"),
+    ("keys.exponentialScale", "Exponential Scale", "Skalowanie wykładnicze"),
+    ("keys.rpfCameraImport", "RPF Camera Import", "Import kamery RPF"),
+    ("layer.sequence", "Sequence Layers...", "Ułóż warstwy w sekwencję..."),
+    ("keys.timeReverse", "Time-Reverse Keyframes", "Odwróć czas klatek kluczowych"),
+    ("", "Animate Text", "Animuj tekst"),
+    ("layer.enablePerChar3D", "Enable Per-character 3D", "Włącz 3D dla każdego znaku"),
+    ("layer.addTextAnimator", "Anchor Point", "Punkt zakotwiczenia"),
+    ("layer.addTextAnimator", "Position", "Położenie"),
+    ("layer.addTextAnimator", "Scale", "Skala"),
+    ("layer.addTextAnimator", "Skew", "Pochylenie"),
+    ("layer.addTextAnimator", "Rotation", "Obrót"),
+    ("layer.addTextAnimator", "Opacity", "Krycie"),
+    ("layer.addTextAnimator", "All Transform Properties", "Wszystkie właściwości przekształcenia"),
+    ("", "Fill Color", "Kolor wypełnienia"),
+    ("layer.addTextAnimator", "RGB", "RGB"),
+    ("layer.addTextAnimator", "Hue", "Barwa"),
+    ("layer.addTextAnimator", "Saturation", "Nasycenie"),
+    ("layer.addTextAnimator", "Brightness", "Jasność"),
+    ("", "Stroke Color", "Kolor obrysu"),
+    ("layer.addTextAnimator", "Stroke Width", "Szerokość obrysu"),
+    ("layer.addTextAnimator", "Tracking", "Światło"),
+    ("layer.addTextAnimator", "Line Anchor", "Zakotwiczenie wiersza"),
+    ("layer.addTextAnimator", "Line Spacing", "Odstęp między wierszami"),
+    ("layer.addTextAnimator", "Character Offset", "Przesunięcie znaku"),
+    ("layer.addTextAnimator", "Character Value", "Wartość znaku"),
+    ("layer.addTextAnimator", "Blur", "Rozmycie"),
+    ("text.animatorFontAxes", "Variable Font Axes", "Osie czcionki zmiennej"),
+    ("", "Add Text Selector", "Dodaj selektor tekstu"),
+    ("text.addSelector", "Range", "Zakres"),
+    ("text.addSelector", "Wiggly", "Falowanie"),
+    ("text.addSelector", "Expression", "Wyrażenie"),
+    ("text.removeAllAnimators", "Remove All Text Animators", "Usuń wszystkie animatory tekstu"),
+    ("prop.setExpression", "Add Expression", "Dodaj wyrażenie"),
+    ("essential.addProperty", "Add Property to Essential Graphics", "Dodaj właściwość do Essential Graphics"),
+    ("prop.separateDimensions", "Separate Dimensions", "Rozdziel wymiary"),
+    ("track.camera", "Track Camera", "Śledź kamerę"),
+    ("track.warpStabilizer", "Warp Stabilizer VFX", "Warp Stabilizer VFX"),
+    ("track.motion", "Track Motion", "Śledź ruch"),
+    ("track.stabilize", "Stabilize Motion", "Stabilizuj ruch"),
+    ("track.property", "Track this Property", "Śledź tę właściwość"),
+    ("anim.reveal", "Reveal Properties with Keyframes", "Pokaż właściwości z klatkami kluczowymi"),
+    ("anim.reveal", "Reveal Properties with Animation", "Pokaż właściwości z animacją"),
+    ("anim.reveal", "Reveal All Modified Properties", "Pokaż wszystkie zmienione właściwości"),
+    ("", "View", "Widok"),
+    ("view.newViewer", "New Viewer", "Nowa przeglądarka"),
+    ("view.splitLockedViewer", "Split with New Locked Viewer", "Podziel z nową zablokowaną przeglądarką"),
+    ("view.zoomIn", "Zoom In", "Powiększ"),
+    ("view.zoomOut", "Zoom Out", "Pomniejsz"),
+    ("", "Resolution", "Rozdzielczość"),
+    ("view.res.full", "Full", "Pełna"),
+    ("view.res.half", "Half", "Połowa"),
+    ("view.res.third", "Third", "Jedna trzecia"),
+    ("view.res.quarter", "Quarter", "Jedna czwarta"),
+    ("view.res.custom", "Custom...", "Niestandardowa..."),
+    ("view.displayColorManagement", "Use Display Color Management", "Używaj zarządzania kolorem wyświetlacza"),
+    ("", "Simulate Output", "Symuluj wyjście"),
+    ("view.simulateOutput", "No Output Simulation", "Bez symulacji wyjścia"),
+    ("view.simulateOutput", "HDTV (Rec. 709)", "HDTV (Rec. 709)"),
+    ("view.simulateOutput", "SDTV NTSC", "SDTV NTSC"),
+    ("view.simulateOutput", "SDTV PAL", "SDTV PAL"),
+    ("view.simulateOutput", "Legacy Macintosh RGB (Gamma 1.8)", "Starsze RGB komputerów Macintosh (gamma 1,8)"),
+    ("view.simulateOutput", "Internet Standard RGB (sRGB)", "Standardowe internetowe RGB (sRGB)"),
+    ("view.simulateOutput", "UHDTV (Rec. 2020)", "UHDTV (Rec. 2020)"),
+    ("view.simulateOutput", "Display P3", "Display P3"),
+    ("view.simulateOutput", "Linear (1.0 Gamma)", "Liniowe (gamma 1,0)"),
+    ("view.customRgb", "My Custom RGB...", "Moje niestandardowe RGB..."),
+    ("view.simulateOutput", "Custom...", "Niestandardowe..."),
+    ("view.rulers", "Show Rulers", "Pokaż linijki"),
+    ("", "Panel Background Color", "Kolor tła panelu"),
+    ("view.panelBackground", "Black", "Czarny"),
+    ("view.panelBackground", "Dark Gray", "Ciemnoszary"),
+    ("view.panelBackground", "Medium Gray (Default)", "Średnioszary (domyślny)"),
+    ("view.panelBackground", "Light Gray", "Jasnoszary"),
+    ("view.panelBackground", "White", "Biały"),
+    ("view.panelBackground", "Custom", "Niestandardowy"),
+    ("view.panelBackground", "Select Custom Background Color...", "Wybierz niestandardowy kolor tła..."),
+    ("view.guides", "Show Guides", "Pokaż linie pomocnicze"),
+    ("view.snapToGuides", "Snap to Guides", "Przyciągaj do linii pomocniczych"),
+    ("view.lockGuides", "Lock Guides", "Zablokuj linie pomocnicze"),
+    ("view.addGuide", "Add Guide...", "Dodaj linię pomocniczą..."),
+    ("view.addPercentGuide", "Add Percentage Guide...", "Dodaj procentową linię pomocniczą..."),
+    ("view.convertGuides", "Convert Guides to Percentage", "Konwertuj linie pomocnicze na procenty"),
+    ("view.convertGuides", "Convert Guides to Pixels", "Konwertuj linie pomocnicze na piksele"),
+    ("view.clearGuides", "Clear Guides", "Wyczyść linie pomocnicze"),
+    ("view.importGuides", "Import Guides...", "Importuj linie pomocnicze..."),
+    ("view.exportGuides", "Export Guides...", "Eksportuj linie pomocnicze..."),
+    ("view.grid", "Show Grid", "Pokaż siatkę"),
+    ("view.snapToGrid", "Snap to Grid", "Przyciągaj do siatki"),
+    ("view.snapping", "Snapping", "Przyciąganie"),
+    ("view.options", "View Options...", "Opcje widoku..."),
+    ("view.layerControls", "Show Layer Controls", "Pokaż elementy sterujące warstwy"),
+    ("", "Switch View Layout", "Przełącz układ widoków"),
+    ("view.layout", "1 View", "1 widok"),
+    ("view.layout", "2 Views", "2 widoki"),
+    ("view.layout", "4 Views", "4 widoki"),
+    ("view.shareViewOptions", "Share View Options", "Wspólne opcje widoku"),
+    ("", "Switch 3D View", "Przełącz widok 3D"),
+    ("view.3d.activeCamera", "Active Camera", "Aktywna kamera"),
+    ("view.3d.default", "Default", "Domyślny"),
+    ("view.3d.front", "Front", "Przód"),
+    ("view.3d.left", "Left", "Lewo"),
+    ("view.3d.top", "Top", "Góra"),
+    ("view.3d.back", "Back", "Tył"),
+    ("view.3d.right", "Right", "Prawo"),
+    ("view.3d.bottom", "Bottom", "Dół"),
+    ("view.3d.custom1", "Custom View 1", "Widok niestandardowy 1"),
+    ("view.3d.custom2", "Custom View 2", "Widok niestandardowy 2"),
+    ("view.3d.custom3", "Custom View 3", "Widok niestandardowy 3"),
+    ("", "Assign Shortcut to 3D View", "Przypisz skrót do widoku 3D"),
+    ("view.3d.last", "Switch to Last 3D View", "Przełącz na ostatni widok 3D"),
+    ("view.lookAtSelected", "Look at Selected Layers", "Patrz na zaznaczone warstwy"),
+    ("view.lookAtAll", "Look at All Layers", "Patrz na wszystkie warstwy"),
+    ("time.set", "Go to Time...", "Przejdź do czasu..."),
+    ("view.fullScreen", "Enter Full Screen", "Pełny ekran"),
+    ("", "Window", "Okno"),
+    ("", "Workspace", "Obszar roboczy"),
+    ("window.workspace", "Default", "Domyślny"),
+    ("window.workspace", "Review", "Przegląd"),
+    ("window.workspace", "Learn", "Nauka"),
+    ("window.workspace", "Small Screen", "Mały ekran"),
+    ("window.workspace", "Standard", "Standardowy"),
+    ("window.workspace", "All Panels", "Wszystkie panele"),
+    ("window.workspace", "Animation", "Animacja"),
+    ("window.workspace", "Color", "Kolor"),
+    ("window.workspace", "Effects", "Efekty"),
+    ("window.workspace", "Essential Graphics", "Essential Graphics"),
+    ("window.workspace", "Minimal", "Minimalny"),
+    ("window.workspace", "Motion Tracking", "Śledzenie ruchu"),
+    ("window.workspace", "Paint", "Malowanie"),
+    ("window.workspace", "Text", "Tekst"),
+    ("window.workspace", "Undocked Panels", "Panele odpięte"),
+    ("window.resetWorkspace", "Reset to Saved Layout", "Przywróć zapisany układ"),
+    ("window.saveWorkspace", "Save Changes to this Workspace", "Zapisz zmiany w tym obszarze roboczym"),
+    ("window.saveWorkspaceAs", "Save as New Workspace...", "Zapisz jako nowy obszar roboczy..."),
+    ("window.editWorkspaces", "Edit Workspaces...", "Edytuj obszary robocze..."),
+    ("", "Assign Shortcut to Workspace", "Przypisz skrót do obszaru roboczego"),
+    ("window.panel", "Align", "Wyrównanie"),
+    ("window.panel", "Audio", "Audio"),
+    ("window.panel", "Brushes", "Pędzle"),
+    ("window.panel", "Character", "Znak"),
+    ("window.panel", "Content-Aware Fill", "Wypełnienie z uwzględnieniem zawartości"),
+    ("window.panel", "Effects & Presets", "Efekty i ustawienia"),
+    ("window.panel", "Essential Graphics", "Essential Graphics"),
+    ("window.panel", "Info", "Informacje"),
+    ("help.inAppTutorials", "Learn", "Nauka"),
+    ("window.panel", "Lumetri Scopes", "Zakresy Lumetri"),
+    ("window.panel", "Mask Interpolation", "Interpolacja maski"),
+    ("window.panel", "Media Browser", "Przeglądarka multimediów"),
+    ("window.panel", "Metadata", "Metadane"),
+    ("window.panel", "Motion Sketch", "Szkic ruchu"),
+    ("window.panel", "Paint", "Malowanie"),
+    ("window.panel", "Paragraph", "Akapit"),
+    ("window.panel", "Preview", "Podgląd"),
+    ("window.panel", "Progress", "Postęp"),
+    ("window.panel", "Properties", "Właściwości"),
+    ("window.panel", "Script Console", "Konsola skryptów"),
+    ("window.panel", "Smoother", "Wygładzanie"),
+    ("window.panel", "Tools", "Narzędzia"),
+    ("window.panel", "Tracker", "Śledzenie"),
+    ("window.panel", "Wiggler", "Wahanie"),
+    ("window.panel", "Composition", "Kompozycja"),
+    ("window.panel", "Flowchart", "Schemat"),
+    ("window.panel", "Footage", "Materiał"),
+    ("window.panel", "Layer", "Warstwa"),
+    ("window.panel", "Project", "Projekt"),
+    ("window.panel", "Render Queue", "Kolejka renderowania"),
+    ("window.panel", "Timeline", "Oś czasu"),
+    ("window.panel", "Create Nulls From Paths", "Utwórz obiekty zerowe ze ścieżek"),
+    ("window.panel", "VR Comp Editor", "Edytor kompozycji VR"),
+    ("", "Help", "Pomoc"),
+    ("help.docs", "EffectCraft Help...", "Pomoc EffectCraft..."),
+    ("help.docs", "Scripting Help...", "Pomoc dotycząca skryptów..."),
+    ("help.docs", "Expression Reference...", "Dokumentacja wyrażeń..."),
+    ("help.docs", "Effect Reference...", "Dokumentacja efektów..."),
+    ("anim.browsePresets", "Animation Presets...", "Ustawienia animacji..."),
+    ("app.keyboardShortcuts", "Keyboard Shortcuts...", "Skróty klawiaturowe..."),
+    ("help.inAppTutorials", "In-App Tutorials...", "Samouczki w aplikacji..."),
+    ("help.onlineTutorials", "Online Tutorials...", "Samouczki online..."),
+    ("help.systemReport", "System Compatibility Report...", "Raport zgodności systemu..."),
+    ("help.enableLogging", "Enable Logging", "Włącz rejestrowanie"),
+    ("help.revealLogFile", "Reveal Logging File", "Pokaż plik dziennika"),
+    ("help.discord", "Join the ArtCraft Discord...", "Dołącz do Discorda ArtCraft..."),
+    ("help.reportIssue", "Provide Feedback...", "Prześlij opinię..."),
+    ("help.website", "ArtCraft Website", "Witryna ArtCraft"),
+    ("help.appPage", "EffectCraft Home Page", "Strona główna EffectCraft"),
+    ("help.github", "EffectCraft on GitHub", "EffectCraft w serwisie GitHub"),
+    ("file.openDemoProject", "Open Demo Project", "Otwórz projekt demonstracyjny"),
+    ("", "Recent Script Files", "Ostatnie pliki skryptów"),
+    ("layer.newPrimitive", "3D Primitive...", "Bryła podstawowa 3D..."),
+];
+
 /// Czech (cs): original phrase translations of every fixed menu entry.
 const CZECH: &[(&str, &str, &str)] = &[
     ("", "Front", "Přední strana"),
@@ -6185,6 +7549,7 @@ const CZECH: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "Nainstalovat soubor skriptu..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "Nainstalovat panel ScriptUI..."),
     ("file.runScript", "Run Script File...", "Spustit soubor skriptu..."),
+    ("", "Recent Script Files", "Nedávné soubory skriptů"),
     ("", "Create Proxy", "Vytvořit zástupný soubor"),
     ("file.createProxy", "Still...", "Statický snímek..."),
     ("file.createProxy", "Movie...", "Video..."),
@@ -6538,6 +7903,8 @@ const CZECH: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Spustit řádky shora"),
     ("anim.addKeyframe", "Add Keyframe", "Přidat klíčový snímek"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Přepnout podržení klíčového snímku"),
+    ("keys.setMuted", "Mute Keyframes", "Ztlumit klíčové snímky"),
+    ("keys.setMuted", "Unmute Keyframes", "Obnovit klíčové snímky"),
     ("keys.interpolation", "Keyframe Interpolation...", "Interpolace klíčových snímků..."),
     ("keys.velocity", "Keyframe Velocity...", "Rychlost klíčového snímku..."),
     ("", "Keyframe Assistant", "Pomocník klíčových snímků"),
@@ -6816,6 +8183,7 @@ const GEORGIAN: &[(&str, &str, &str)] = &[
     ("file.installScript", "Install Script File...", "სკრიპტის ფაილის დაყენება..."),
     ("file.installScriptUIPanel", "Install ScriptUI Panel...", "ScriptUI პანელის დაყენება..."),
     ("file.runScript", "Run Script File...", "სკრიპტის ფაილის გაშვება..."),
+    ("", "Recent Script Files", "ბოლო სკრიპტის ფაილები"),
     ("", "Create Proxy", "პროქსის შექმნა"),
     ("file.createProxy", "Still...", "სტატიკური კადრი..."),
     ("file.createProxy", "Movie...", "ვიდეო..."),
@@ -7168,6 +8536,8 @@ const GEORGIAN: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "სტრიქონების ჩამოვარდნა"),
     ("anim.addKeyframe", "Add Keyframe", "საკვანძო კადრის დამატება"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "ფიქსირებული საკვანძო კადრის გადართვა"),
+    ("keys.setMuted", "Mute Keyframes", "საკვანძო კადრების დადუმება"),
+    ("keys.setMuted", "Unmute Keyframes", "საკვანძო კადრების დადუმების მოხსნა"),
     ("keys.interpolation", "Keyframe Interpolation...", "საკვანძო კადრის ინტერპოლაცია..."),
     ("keys.velocity", "Keyframe Velocity...", "საკვანძო კადრის სიჩქარე..."),
     ("", "Keyframe Assistant", "საკვანძო კადრების ასისტენტი"),
@@ -7377,6 +8747,22 @@ mod tests {
     use serde_json::json;
     use std::collections::BTreeSet;
 
+    /// The four options at the foot of the header's workspace menu say what After Effects says,
+    /// read from its workspace button on 2026-10-31: reset, save over this one, save a copy, then
+    /// edit the list.
+    #[test]
+    fn the_workspace_menu_options_use_after_effects_words() {
+        set_current("ja");
+        for (id, en, ja) in [
+            ("window.resetWorkspace", "Reset to Saved Layout", "保存したレイアウトにリセット"),
+            ("window.saveWorkspace", "Save Changes to this Workspace", "このワークスペースへの変更を保存"),
+            ("window.saveWorkspaceAs", "Save as New Workspace...", "新規ワークスペースとして保存..."),
+            ("window.editWorkspaces", "Edit Workspaces...", "ワークスペースを編集..."),
+        ] {
+            assert_eq!(command_label(id, en), ja, "{id}");
+        }
+    }
+
     /// Labels drawn outside the menu bar take the menu bar's row for their command (with `…` for
     /// `...`), else the panel catalog's row, else stay as they are.
     #[test]
@@ -7426,6 +8812,59 @@ mod tests {
         assert_eq!(super::first_supported(Some("ja"), &tags(&[]), super::web_draws), "ja");
     }
 
+    #[test]
+    fn swedish_translates_menus_without_changing_bindings_or_user_names() {
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        app.session.execute("prefs.set", json!({"key": "general.language", "value": "en"})).unwrap();
+        app.session.prefs.push_recent("File.ecproj");
+        let en = crate::native_menu::build(&app);
+        let state = crate::native_menu::state_key(&app);
+        app.session.execute("prefs.set", json!({"key": "general.language", "value": "sv"})).unwrap();
+        let sv = crate::native_menu::build(&app);
+        assert_eq!(language(&app), "sv");
+        assert!(swedish(&app));
+        assert!(!czech(&app));
+        assert_eq!(code("sv"), "sv");
+        assert_ne!(state, crate::native_menu::state_key(&app));
+        let bindings = |menu: &crate::native_menu::NativeMenu| {
+            menu.items().into_iter().map(|i| (i.id.clone(), i.command.clone(), i.params.clone(), i.shortcut.clone(), i.enabled, i.checked)).collect::<Vec<_>>()
+        };
+        assert_eq!(bindings(&en), bindings(&sv));
+        assert!(sv.items().iter().any(|i| i.command == "comp.new" && i.label == "Ny komposition..."));
+        assert!(sv.items().iter().any(|i| i.command == "keys.easyEase" && i.label == "Mjukt in och ut"));
+        assert!(sv.items().iter().any(|i| i.command == "file.openRecent" && i.label == "File.ecproj"));
+        for (source, translated) in
+            [("File", "Arkiv"), ("Edit", "Redigera"), ("Composition", "Komposition"), ("Layer", "Lager"), ("Window", "Fönster"), ("Help", "Hjälp")]
+        {
+            assert_eq!(label(&app, "", source), translated);
+        }
+        assert_eq!(label(&app, "unknown.command", "Text"), "Text");
+        let panel =
+            MenuEntry { label: "Layer".into(), command: "window.panel".into(), params: json!({"panel": "layer"}), shortcut: None, alt_shortcuts: vec![] };
+        assert_eq!(entry(&app, &panel, "Layer: File Åsa".into()), "Lager: File Åsa");
+        assert_eq!(
+            submenu(&app, "Assign Shortcut to Workspace", "Assign Shortcut to “File Åsa” Workspace".into()),
+            "Tilldela kortkommando till arbetslayouten ”File Åsa”"
+        );
+        assert_eq!(submenu(&app, "Assign Shortcut to 3D View", "Assign Shortcut to “Top”".into()), "Tilldela kortkommando till 3D-vyn ”Top”");
+        assert_eq!(submenu(&app, "Assign Shortcut to Workspace", "Assign Shortcut to Workspace".into()), "Tilldela kortkommando till arbetslayout");
+        let undo = MenuEntry { label: "Undo".into(), command: "edit.undo".into(), params: json!({}), shortcut: None, alt_shortcuts: vec![] };
+        assert_eq!(entry(&app, &undo, "Can't Undo".into()), "Det går inte att ångra");
+        app.session.history.undo.push(("File Åsa".into(), app.session.project.clone()));
+        assert_eq!(entry(&app, &undo, "Undo File Åsa".into()), "Ångra File Åsa");
+        for command in ["file.revealInFinder", "layer.revealInFinder"] {
+            for (source, translated) in
+                [("Reveal in Finder", "Visa i Finder"), ("Reveal in Explorer", "Visa i Utforskaren"), ("Reveal in File Manager", "Visa i filhanteraren")]
+            {
+                assert_eq!(label(&app, command, source), translated);
+                assert_eq!(label(&app, "file.openRecent", source), source);
+            }
+        }
+        app.session.history.undo.clear();
+        app.session.execute("prefs.set", json!({"key": "general.language", "value": "en"})).unwrap();
+        assert_eq!(crate::native_menu::build(&app), en);
+    }
+
     fn keys(nodes: &[MenuNode], out: &mut BTreeSet<(String, String)>) {
         for node in nodes {
             match node {
@@ -7488,6 +8927,19 @@ mod tests {
         println!("total: {total}");
     }
 
+    /// Prints the translated-row counts per language, the numbers `docs/localization-parity.md`
+    /// quotes. `cargo xtask i18n-report` runs it with `--nocapture`.
+    #[test]
+    fn catalog_row_counts_report() {
+        println!("Localization catalog rows:");
+        for code in CATALOG_CODES {
+            let menus = menu_catalog(code).map_or(0, |catalog| catalog.len());
+            let panels = ui::translated_rows(code);
+            let effect_names = effects::translated_rows(code);
+            println!("{code}: menus {menus}, panels {panels}, effect names {effect_names}, total {}", menus + panels + effect_names);
+        }
+    }
+
     #[test]
     fn menu_catalogs_have_no_stale_or_duplicate_rows() {
         let mut actual = BTreeSet::new();
@@ -7506,6 +8958,31 @@ mod tests {
         }
     }
 
+    /// Exercise each engine spelling on every host: a macOS-only run must still catch a
+    /// Windows/Linux catalog miss, while filenames and unrelated commands stay untouched.
+    #[test]
+    fn ukrainian_reveal_labels_follow_the_platform_file_manager() {
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        app.session.execute("prefs.set", json!({"key": "general.language", "value": "uk"})).unwrap();
+        for command in ["file.revealInFinder", "layer.revealInFinder"] {
+            for (source, translated) in [
+                ("Reveal in Finder", "Показати у Finder"),
+                ("Reveal in Explorer", "Показати у Провіднику"),
+                ("Reveal in File Manager", "Показати у файловому менеджері"),
+            ] {
+                let e =
+                    MenuEntry { label: source.into(), command: command.into(), params: json!({"item": "My file.mp4"}), shortcut: None, alt_shortcuts: vec![] };
+                assert_eq!(label(&app, command, source), translated);
+                assert_eq!(entry(&app, &e, source.into()), translated);
+                assert_eq!(label(&app, "file.openRecent", source), source);
+            }
+            assert_eq!(label(&app, command, "My file.mp4"), "My file.mp4");
+        }
+        app.session.execute("prefs.set", json!({"key": "general.language", "value": "en"})).unwrap();
+        assert_eq!(label(&app, "file.revealInFinder", "Reveal in Explorer"), "Reveal in Explorer");
+        assert_eq!(label(&app, "layer.revealInFinder", "Reveal in File Manager"), "Reveal in File Manager");
+    }
+
     #[test]
     fn language_changes_native_labels_without_changing_commands_or_parameters() {
         let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
@@ -7526,6 +9003,61 @@ mod tests {
         app.session.execute("prefs.set", json!({"key":"general.language", "value":"en"})).unwrap();
         assert_eq!(label(&app, "", "Composition"), "Composition");
     }
+    /// Every catalog names the platform's file manager: the engine substitutes it for "Finder"
+    /// before the label reaches the catalog, so the macOS row alone leaves Windows and Linux in
+    /// English (#1450).
+    #[test]
+    fn the_reveal_command_names_the_file_manager_in_every_catalog() {
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        for (code, explorer, manager) in REVEAL_FINDER {
+            app.session.execute("prefs.set", json!({"key":"general.language", "value": code})).unwrap();
+            assert_eq!(label(&app, "file.revealInFinder", "Reveal in Explorer"), *explorer, "{code}");
+            assert_eq!(label(&app, "layer.revealInFinder", "Reveal in File Manager"), *manager, "{code}");
+        }
+        // English keeps the source, and the macOS wording still comes from the catalog.
+        app.session.execute("prefs.set", json!({"key":"general.language", "value": "en"})).unwrap();
+        assert_eq!(label(&app, "file.revealInFinder", "Reveal in Explorer"), "Reveal in Explorer");
+        app.session.execute("prefs.set", json!({"key":"general.language", "value": "ja"})).unwrap();
+        assert_eq!(label(&app, "file.revealInFinder", "Reveal in Finder"), "Finderで表示");
+    }
+
+    /// Match System in the browser also picks the Russian, French and German catalogs, in the
+    /// order of the browser's preferences (#1700).
+    #[test]
+    fn browser_preferences_choose_russian_french_and_german() {
+        let tags = |t: &[&str]| t.iter().map(|s| s.to_string()).collect::<Vec<_>>();
+        for (locales, expected) in
+            [(vec!["de-DE", "es-ES"], "de"), (vec!["xx-XX", "fr-CA"], "fr"), (vec!["ru-RU", "cs"], "ru"), (vec!["en-US", "de-DE"], "en"), (vec!["xx-XX"], "en")]
+        {
+            assert_eq!(super::first_supported(None, &tags(&locales), super::web_draws), expected, "{locales:?}");
+        }
+    }
+
+    /// The Edit menu's Undo and Redo name the history's action in the interface language, also in
+    /// the languages added with #1700.
+    #[test]
+    fn undo_and_redo_are_localized_for_russian_french_and_german() {
+        for (language, undo, no_undo, redo, no_redo) in [
+            ("ru", "Отменить:", "Нечего отменять", "Повторить:", "Нечего повторять"),
+            ("fr", "Annuler", "Impossible d'annuler", "Rétablir", "Impossible de rétablir"),
+            ("de", "Rückgängig", "Rückgängig nicht möglich", "Wiederholen", "Wiederholen nicht möglich"),
+        ] {
+            let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+            app.session.execute("prefs.set", json!({"key": "general.language", "value": language})).unwrap();
+            let entry_of = |app: &EffectcraftApp, command: &str| {
+                let (_, e) = effectcraft_engine::menus::entries().into_iter().find(|(_, e)| e.command == command).unwrap();
+                entry(app, e, e.label.clone())
+            };
+            assert_eq!(entry_of(&app, "edit.undo"), no_undo, "{language}");
+            assert_eq!(entry_of(&app, "edit.redo"), no_redo, "{language}");
+            app.session.execute("comp.new", json!({"name": "A", "duration": 1})).unwrap();
+            let action = app.session.history.undo.last().map(|u| u.0.clone()).unwrap();
+            assert_eq!(entry_of(&app, "edit.undo"), format!("{undo} {action}"), "{language}");
+            app.session.execute("edit.undo", json!({})).unwrap();
+            assert_eq!(entry_of(&app, "edit.redo"), format!("{redo} {action}"), "{language}");
+        }
+    }
+
     #[test]
     fn match_system_uses_the_system_language_where_there_is_a_catalog() {
         for (locale, language) in [
@@ -7555,12 +9087,30 @@ mod tests {
             (Some("cs-CZ"), "cs"),
             (Some("cs_CZ.UTF-8"), "cs"),
             (Some("CS_cz.UTF-8"), "cs"),
+            (Some("pl"), "pl"),
+            (Some("pl-PL"), "pl"),
+            (Some("pl_PL.UTF-8"), "pl"),
+            (Some("PL_pl.UTF-8"), "pl"),
             (Some("ka"), "ka"),
             (Some("ka-GE"), "ka"),
             (Some("ka_GE.UTF-8"), "ka"),
+            (Some("ru"), "ru"),
+            (Some("ru-RU"), "ru"),
+            (Some("ru-SK"), "ru"),
+            (Some("ru_RU.UTF-8"), "ru"),
+            (Some("de"), "de"),
+            (Some("de-DE"), "de"),
+            (Some("de_AT.UTF-8"), "de"),
+            (Some("fr"), "fr"),
+            (Some("fr-FR"), "fr"),
+            (Some("fr_CA.UTF-8"), "fr"),
+            (Some("sv"), "sv"),
+            (Some("sv-SE"), "sv"),
+            (Some("sv-FI"), "sv"),
+            (Some("sv_SE.UTF-8"), "sv"),
             (Some("en-US"), "en"),
             (Some("jv-ID"), "en"),
-            (Some("de-DE"), "en"),
+            (Some("nl-NL"), "en"),
             (None, "en"),
         ] {
             assert_eq!(supported(locale), language, "{locale:?}");
@@ -7572,6 +9122,8 @@ mod tests {
         assert_eq!(traditional(&app), system_language() == "zh-hant");
         assert_eq!(spanish(&app), system_language() == "es");
         assert_eq!(czech(&app), system_language() == "cs");
+        assert_eq!(polish(&app), system_language() == "pl");
+        assert_eq!(swedish(&app), system_language() == "sv");
         app.session.execute("prefs.set", json!({"key":"general.language", "value":"ja"})).unwrap();
         assert!(japanese(&app));
         app.session.execute("prefs.set", json!({"key":"general.language", "value":"zh-hans"})).unwrap();
@@ -7598,7 +9150,9 @@ mod tests {
             ("es", SPANISH),
             ("pt-br", PORTUGUESE),
             ("cs", CZECH),
+            ("pl", POLISH),
             ("ka", GEORGIAN),
+            ("sv", SWEDISH),
         ] {
             for (command, en, translated) in catalog {
                 assert_eq!(en.contains("..."), translated.contains("..."), "{code} {command} / {en}: {translated}");
@@ -7609,6 +9163,35 @@ mod tests {
         }
     }
 
+    /// The dock's tab titles are `PanelKind::title()`; the panels the Window menu lists are drawn in
+    /// the interface language through their `(window.panel, title)` rows. `History` and `ScriptUI
+    /// Panel` are in no menu and keep their English names, which is what this pins.
+    #[test]
+    fn the_dock_draws_every_panel_it_can_in_the_interface_language() {
+        use crate::dock::PanelKind;
+        const WITHOUT_A_ROW: &[&str] = &["History", "ScriptUI Panel"];
+        for (name, catalog, code) in [("ja", JAPANESE, "ja"), ("zh-hans", SIMPLIFIED_CHINESE, "zh-hans"), ("zh-hant", TRADITIONAL_CHINESE, "zh-hant")] {
+            // The dock asks both catalogs, so a title may be named by either.
+            ui::set_current(code);
+            for p in PanelKind::ALL {
+                let title = p.title();
+                let in_menu = catalog.iter().any(|(c, en, _)| *c == "window.panel" && *en == title);
+                let in_panel = ui::tr(title) != title;
+                assert_eq!(
+                    in_menu || in_panel,
+                    !WITHOUT_A_ROW.contains(&title),
+                    "{name}: {title} is {}named by a catalog and {}in the exception list",
+                    if in_menu || in_panel { "" } else { "not " },
+                    if WITHOUT_A_ROW.contains(&title) { "" } else { "not " }
+                );
+            }
+        }
+        ui::set_current("en");
+        // The dock asks the catalog rather than drawing the English name.
+        let dock_ui = include_str!("dock_ui.rs");
+        assert!(dock_ui.contains(r#"crate::i18n::command_label("window.panel", title)"#), "dock_ui.rs no longer asks the catalog for the panel titles");
+    }
+
     #[test]
     fn ukrainian_catalog_matches_the_settings_registry() {
         let codes: Vec<_> = effectcraft_engine::prefs::LANGUAGES.iter().map(|(_, code)| *code).filter(|code| !matches!(*code, "system" | "en")).collect();
@@ -7618,6 +9201,35 @@ mod tests {
         assert_eq!(code("unknown"), "en");
     }
 
+    /// Every catalog language draws its menu entries from the catalog, including those with no
+    /// undo/redo wording of their own: choosing Deutsch, Русский or Français left the menus in
+    /// English (#1449).
+    #[test]
+    fn every_catalog_language_translates_menu_entries() {
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        let menu_entry = |command: &str, label: &str| MenuEntry {
+            label: label.into(),
+            command: command.into(),
+            params: serde_json::Value::Null,
+            shortcut: None,
+            alt_shortcuts: Vec::new(),
+        };
+        let new_comp = menu_entry("comp.new", "New Composition...");
+        let undo = menu_entry("edit.undo", "Undo");
+        for code in CATALOG_CODES {
+            app.session.execute("prefs.set", json!({"key":"general.language", "value":code})).unwrap();
+            let drawn = entry(&app, &new_comp, new_comp.label.clone());
+            assert_eq!(drawn, label(&app, "comp.new", "New Composition..."), "{code}");
+            assert_ne!(drawn, new_comp.label, "{code}: the menu entry is drawn in English");
+        }
+        app.session.execute("prefs.set", json!({"key":"general.language", "value":"ru"})).unwrap();
+        assert_eq!(entry(&app, &undo, "Can't Undo".into()), "Нечего отменять");
+        app.session.execute("prefs.set", json!({"key":"general.language", "value":"de"})).unwrap();
+        assert_eq!(entry(&app, &undo, "Can't Undo".into()), "Rückgängig nicht möglich");
+        app.session.execute("prefs.set", json!({"key":"general.language", "value":"en"})).unwrap();
+        assert_eq!(entry(&app, &new_comp, new_comp.label.clone()), "New Composition...");
+    }
+
     #[test]
     fn general_settings_exposes_the_language_automation_id() {
         let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
diff --git a/crates/ui-egui/src/i18n/effects.rs b/crates/ui-egui/src/i18n/effects.rs
index b41430bed..5793225e3 100644
--- a/crates/ui-egui/src/i18n/effects.rs
+++ b/crates/ui-egui/src/i18n/effects.rs
@@ -14,21 +14,28 @@
 //!   the id is stable, so a translation never becomes an orphan.
 //!
 //! Each row repeats the registry's English name so that a rename upstream fails
-//! [`tests::every_row_names_a_registry_effect`] instead of silently pointing a translation at
+//! `tests::every_row_names_a_registry_effect` instead of silently pointing a translation at
 //! another effect. An effect with no row draws the registry's English name; the
 //! `missing_translations_report` test (run by `cargo xtask ci`) lists those per language.
 //!
 //! A language decides for itself which names stay English: After Effects' Japanese interface
-//! leaves the `CC` series, the `VR` set and the `OCIO` set in English, while its Simplified
-//! Chinese one translates them (the `CC` names come from Adobe's Chinese *documentation*, which
-//! names 68 of the 69). Repeating the English name is therefore a language-level choice, not a
-//! missing row.
+//! leaves the `CC` series in English and gives the `VR` and `OCIO` sets a Japanese tail
+//! (`VR ブラー`, `OCIO CDL 変換`), while its Simplified Chinese one translates them (the `CC`
+//! names come from Adobe's Chinese *documentation*, which names 68 of the 69). Repeating the
+//! English name is therefore a language-level choice, not a missing row.
 //!
 //! The Simplified Chinese names come from the installed After Effects 2026 (26.5.0.89)
 //! Simplified Chinese interface, its 21 category folder names included; `Cryptomatte`,
 //! `EXtractoR`, `IDentifier`, `Key Light` and `Unmult` stay in English as brand names, and
 //! `Face Measurements` / `Face Track Points` are EffectCraft's own effects, so their wording is
 //! ours.
+//!
+//! The French names are written from the meaning of the English ones, with the vocabulary of the
+//! French menus; they come from no other application's interface. Brand and coined names
+//! (`Cryptomatte`, `EXtractoR`, `IDentifier`, `Key Light`, `Unmult`, `Lumetri Color`, `Colorama`,
+//! `Minimax`, `Tritone`, `Vibrance`, `Vegas`) and the whole `CC` series stay in English; a series
+//! tag that prefixes a descriptive name (`VR`, `OCIO`, `PS`, `HDR`) stays and follows the
+//! French word order (`Flou VR`, `Transformation CDL OCIO`).
 
 use std::collections::HashMap;
 use std::sync::OnceLock;
@@ -71,6 +78,8 @@ fn catalog(language: &str) -> Option<&'static Catalog> {
     static TRADITIONAL: Catalog = Catalog { rows: TRADITIONAL_CHINESE, categories: TRADITIONAL_CHINESE_CATEGORIES, index: OnceLock::new() };
     static JAPANESE: Catalog = Catalog { rows: JAPANESE_EFFECTS, categories: JAPANESE_CATEGORIES, index: OnceLock::new() };
     static GEORGIAN_CATALOG: Catalog = Catalog { rows: GEORGIAN, categories: GEORGIAN_CATEGORIES, index: OnceLock::new() };
+    static SWEDISH_CATALOG: Catalog = Catalog { rows: SWEDISH, categories: SWEDISH_CATEGORIES, index: OnceLock::new() };
+    static FRENCH_CATALOG: Catalog = Catalog { rows: FRENCH, categories: FRENCH_CATEGORIES, index: OnceLock::new() };
     match language {
         "zh-hans" => Some(&SIMPLIFIED),
         "zh-hant" => Some(&TRADITIONAL),
@@ -78,6 +87,8 @@ fn catalog(language: &str) -> Option<&'static Catalog> {
         // this one catalog instead of inventing a second mechanism.
         "ja" => Some(&JAPANESE),
         "ka" => Some(&GEORGIAN_CATALOG),
+        "sv" => Some(&SWEDISH_CATALOG),
+        "fr" => Some(&FRENCH_CATALOG),
         _ => None,
     }
 }
@@ -87,6 +98,13 @@ pub(crate) fn name(id: &str, english: &str) -> String {
     catalog(current()).and_then(|c| c.row(id)).map_or_else(|| english.to_string(), |(_, translated)| translated.to_string())
 }
 
+/// The number of effect-name rows `language` translates, for the row-count report; 0 when it has
+/// no catalog or when it is English.
+#[cfg(test)]
+pub(super) fn translated_rows(language: &str) -> usize {
+    catalog(language).map_or(0, |c| c.rows.len())
+}
+
 /// The name to draw for an effect group the property tree stores as `stored`: the catalog name,
 /// plus the instance index the engine appends to a repeat (`Gaussian Blur 2` → `高斯模糊 2`).
 ///
@@ -143,6 +161,7 @@ const SIMPLIFIED_CHINESE: &[Row] = &[
     ("ec.3d.fog3d", "Fog 3D", "雾 3D"),
     ("ec.3d.identifier", "IDentifier", "IDentifier"),
     ("ec.3d.idmatte", "ID Matte", "ID 遮罩"),
+    ("ec.3d.instance3d", "3D Layer Instance", "3D 图层实例"),
     ("ec.audio.backwards", "Backwards", "倒放"),
     ("ec.audio.basstreble", "Bass & Treble", "低音和高音"),
     ("ec.audio.compressor", "Compressor", "压缩程序"),
@@ -451,31 +470,329 @@ const TRADITIONAL_CHINESE: &[Row] = &[];
 /// Japanese (`ja`): reserved for the Japanese data point on #821, so both languages share this
 /// one catalog instead of inventing a second mechanism. A translator fills one row per effect,
 /// ids from [`SIMPLIFIED_CHINESE`]; the names Adobe's Japanese interface leaves in English (the
-/// `CC` series, the `VR` set, the `OCIO` set, `Cryptomatte`, `EXtractoR`, `IDentifier`,
-/// `Key Light`, `Unmult`, `Twirl (Legacy)` and the two EffectCraft-only effects) repeat that
-/// English name here rather than being left out.
+/// `CC` series, `Cryptomatte`, `EXtractoR`, `IDentifier` and `Key Light`) repeat that English name
+/// here rather than being left out; the `VR` and `OCIO` sets take a Japanese tail instead, and
+/// `Unmult` keeps its English name in both catalogs. An effect with no row draws its English name
+/// anyway, which is what `Twirl (Legacy)` and the two EffectCraft-only effects would do without
+/// their rows.
 ///
-/// The rows below were read from the installed After Effects 2026 (26.5) Japanese interface
-/// (its generated Effect menu and its Effects & Presets panel).
+/// The rows below come from AE 2026's Japanese interface where it was read directly (its Effect menu
+/// and its Effects & Presets panel) and from Adobe's own Japanese help where the panel was not to
+/// hand. A published glossary is used to cross-check, never as the only source: it normalises the
+/// typography (half-width parentheses where AE draws full-width) and still carries CS6-era names for
+/// the `CC` series, which AE 2026 leaves in English.
 const JAPANESE_EFFECTS: &[Row] = &[
+    // Effects this application adds itself have no interface to read a name from, so they follow
+    // the Chinese catalog's choice to translate them (顔の測定, 顔のトラッキングポイント) rather than
+    // staying English. Unmult stays English: that is what the interface it comes from shows.
+    ("ec.3d.instance3d", "3D Layer Instance", "3Dレイヤーインスタンス"),
+    ("ec.color.broadcast", "Broadcast Colors", "ブロードキャストカラー"),
+    ("ec.control.stereo3d", "Stereo 3D Controls", "ステレオ3Dコントロール"),
+    ("ec.distort.puppet", "Puppet", "パペット"),
+    ("ec.key.screen", "Screen Key", "スクリーンキー"),
+    ("ec.key.unmult", "Unmult", "Unmult"),
+    ("ec.matte.objectmatte", "Object Matte", "オブジェクトマット"),
+    ("ec.matte.rotobrush", "Roto Brush & Refine Edge", "ロトブラシとエッジの調整"),
+    ("ec.paint.paint", "Paint", "ペイント"),
+    ("ec.utility.facemeasurements", "Face Measurements", "顔の測定"),
+    ("ec.utility.facetrackpoints", "Face Track Points", "顔のトラッキングポイント"),
+    ("ec.3d.channelextract", "3D Channel Extract", "3Dチャンネル抽出"),
+    ("ec.3d.cryptomatte", "Cryptomatte", "Cryptomatte"),
+    ("ec.3d.depthmatte", "Depth Matte", "デプスマット"),
+    ("ec.3d.depthoffield", "Depth of Field", "被写界深度"),
+    ("ec.3d.extractor", "EXtractoR", "EXtractoR"),
+    ("ec.3d.fog3d", "Fog 3D", "フォグ3D"),
+    ("ec.3d.identifier", "IDentifier", "IDentifier"),
+    ("ec.3d.idmatte", "ID Matte", "IDマット"),
+    ("ec.audio.backwards", "Backwards", "リバース"),
+    ("ec.audio.basstreble", "Bass & Treble", "バス&トレブル"),
+    ("ec.audio.compressor", "Compressor", "コンプレッサー"),
+    ("ec.audio.delay", "Delay", "ディレイ"),
+    ("ec.audio.distortion", "Distortion", "歪み"),
+    ("ec.audio.flangechorus", "Flange & Chorus", "フランジ&コーラス"),
+    ("ec.audio.gate", "Gate", "ゲート"),
+    ("ec.audio.highlowpass", "High-Low Pass", "ハイパス／ローパス"),
+    ("ec.audio.modulator", "Modulator", "モジュレーター"),
+    ("ec.audio.parametriceq", "Parametric EQ", "パラメトリックEQ"),
+    ("ec.audio.reverb", "Reverb", "リバーブ"),
+    ("ec.audio.stereomixer", "Stereo Mixer", "ステレオミキサー"),
+    ("ec.audio.tone", "Tone", "トーン"),
     ("ec.blur.bilateral", "Bilateral Blur", "ブラー（バイラテラル）"),
     ("ec.blur.cameralens", "Camera Lens Blur", "ブラー（カメラレンズ）"),
+    ("ec.blur.camerashakedeblur", "Camera-Shake Deblur", "カメラぶれ除去"),
+    ("ec.blur.cccross", "CC Cross Blur", "CC Cross Blur"),
+    ("ec.blur.ccradial", "CC Radial Blur", "CC Radial Blur"),
+    ("ec.blur.ccradialfast", "CC Radial Fast Blur", "CC Radial Fast Blur"),
+    ("ec.blur.ccvector", "CC Vector Blur", "CC Vector Blur"),
     ("ec.blur.channel", "Channel Blur", "ブラー（チャンネル）"),
     ("ec.blur.compound", "Compound Blur", "ブラー（合成）"),
     ("ec.blur.directional", "Directional Blur", "ブラー（方向）"),
     ("ec.blur.fastbox", "Fast Box Blur", "高速ボックスブラー"),
     ("ec.blur.gaussian", "Gaussian Blur", "ブラー（ガウス）"),
     ("ec.blur.radial", "Radial Blur", "ブラー（放射状）"),
+    ("ec.blur.reduceflicker", "Reduce Interlace Flicker", "インターレースのちらつき削減"),
+    ("ec.blur.sharpen", "Sharpen", "シャープ"),
+    ("ec.blur.smart", "Smart Blur", "ブラー（詳細）"),
+    ("ec.blur.unsharp", "Unsharp Mask", "アンシャープマスク"),
+    ("ec.channel.arithmetic", "Arithmetic", "アリスマチック"),
+    ("ec.channel.blend", "Blend", "ブレンド"),
+    ("ec.channel.calculations", "Calculations", "計算"),
+    ("ec.channel.cccomposite", "CC Composite", "CC Composite"),
+    ("ec.channel.combiner", "Channel Combiner", "チャンネルコンバイナー"),
+    ("ec.channel.compoundarithmetic", "Compound Arithmetic", "合成アリスマチック"),
+    ("ec.channel.invert", "Invert", "反転"),
+    ("ec.channel.minimax", "Minimax", "最大／最小"),
+    ("ec.channel.removecolormatting", "Remove Color Matting", "カラーマット削除"),
+    ("ec.channel.setchannels", "Set Channels", "チャンネル設定"),
+    ("ec.channel.setmatte", "Set Matte", "マット設定"),
+    ("ec.channel.shiftchannels", "Shift Channels", "チャンネルシフト"),
+    ("ec.channel.solidcomposite", "Solid Composite", "単色合成"),
+    ("ec.color.autocolor", "Auto Color", "自動カラー補正"),
+    ("ec.color.autocontrast", "Auto Contrast", "自動コントラスト"),
+    ("ec.color.autolevels", "Auto Levels", "自動レベル補正"),
+    ("ec.color.blackwhite", "Black & White", "白黒"),
+    ("ec.color.brightnesscontrast", "Brightness & Contrast", "輝度&コントラスト"),
+    ("ec.color.cccolorneutralizer", "CC Color Neutralizer", "CC Color Neutralizer"),
+    ("ec.color.cccoloroffset", "CC Color Offset", "CC Color Offset"),
+    ("ec.color.cckernel", "CC Kernel", "CC Kernel"),
+    ("ec.color.cctoner", "CC Toner", "CC Toner"),
+    ("ec.color.changecolor", "Change Color", "色を変更"),
+    ("ec.color.changetocolor", "Change to Color", "他のカラーへ変更"),
+    ("ec.color.channelmixer", "Channel Mixer", "チャンネルミキサー"),
+    ("ec.color.colorama", "Colorama", "コロラマ"),
+    ("ec.color.colorbalance", "Color Balance", "カラーバランス"),
+    ("ec.color.colorbalancehls", "Color Balance (HLS)", "カラーバランス（HLS）"),
+    ("ec.color.colorlink", "Color Link", "カラーリンク"),
+    ("ec.color.colorstabilizer", "Color Stabilizer", "カラースタビライザー"),
+    ("ec.color.curves", "Curves", "トーンカーブ"),
+    ("ec.color.equalize", "Equalize", "平均化（イコライズ）"),
+    ("ec.color.exposure", "Exposure", "露光量"),
+    ("ec.color.gammapedestalgain", "Gamma/Pedestal/Gain", "ガンマ／ペデスタル／ゲイン"),
+    ("ec.color.huesaturation", "Hue/Saturation", "色相／彩度"),
+    ("ec.color.leavecolor", "Leave Color", "色抜き"),
+    ("ec.color.levels", "Levels", "レベル補正"),
+    ("ec.color.levelsic", "Levels (Individual Controls)", "レベル（個々の制御）"),
     ("ec.color.lumetri", "Lumetri Color", "Lumetri カラー"),
+    ("ec.color.ociocdl", "OCIO CDL Transform", "OCIO CDL 変換"),
+    ("ec.color.ociocolorspace", "OCIO Color Space Transform", "OCIO 色空間変換"),
+    ("ec.color.ociodisplay", "OCIO Display Transform", "OCIO 表示変換"),
+    ("ec.color.ociofile", "OCIO File Transform", "OCIO ファイル変換"),
+    ("ec.color.ociolook", "OCIO Look Transform", "OCIO Look トランスフォーム"),
+    ("ec.color.photofilter", "Photo Filter", "レンズフィルター"),
+    ("ec.color.psarbitrarymap", "PS Arbitrary Map", "PS不定マップ"),
+    ("ec.color.selectivecolor", "Selective Color", "特定色域の選択"),
+    ("ec.color.shadowhighlight", "Shadow/Highlight", "シャドウ・ハイライト"),
+    ("ec.color.tint", "Tint", "色かぶり補正"),
+    ("ec.color.tritone", "Tritone", "トライトーン"),
+    ("ec.color.vibrance", "Vibrance", "自然な彩度"),
+    ("ec.color.videolimiter", "Video Limiter", "ビデオリミッター"),
+    ("ec.control.angle", "Angle Control", "角度制御"),
+    ("ec.control.checkbox", "Checkbox Control", "チェックボックス制御"),
+    ("ec.control.color", "Color Control", "カラー制御"),
+    ("ec.control.dropdown", "Dropdown Menu Control", "ドロップダウンメニュー制御"),
+    ("ec.control.layer", "Layer Control", "レイヤー制御"),
+    ("ec.control.point", "Point Control", "ポイント制御"),
+    ("ec.control.point3d", "3D Point Control", "3D ポイント制御"),
+    ("ec.control.slider", "Slider Control", "スライダー制御"),
+    ("ec.distort.bezierwarp", "Bezier Warp", "ベジェワープ"),
+    ("ec.distort.bulge", "Bulge", "バルジ"),
+    ("ec.distort.ccbender", "CC Bender", "CC Bender"),
+    ("ec.distort.ccbendit", "CC Bend It", "CC Bend It"),
+    ("ec.distort.ccblobbylize", "CC Blobbylize", "CC Blobbylize"),
+    ("ec.distort.ccflomotion", "CC Flo Motion", "CC Flo Motion"),
+    ("ec.distort.ccgriddler", "CC Griddler", "CC Griddler"),
+    ("ec.distort.cclens", "CC Lens", "CC Lens"),
+    ("ec.distort.ccpageturn", "CC Page Turn", "CC Page Turn"),
+    ("ec.distort.ccpowerpin", "CC Power Pin", "CC Power Pin"),
+    ("ec.distort.ccripplepulse", "CC Ripple Pulse", "CC Ripple Pulse"),
+    ("ec.distort.ccslant", "CC Slant", "CC Slant"),
+    ("ec.distort.ccsmear", "CC Smear", "CC Smear"),
+    ("ec.distort.ccsplit", "CC Split", "CC Split"),
+    ("ec.distort.ccsplit2", "CC Split 2", "CC Split 2"),
+    ("ec.distort.cctiler", "CC Tiler", "CC Tiler"),
+    ("ec.distort.cornerpin", "Corner Pin", "コーナーピン"),
+    ("ec.distort.displacementmap", "Displacement Map", "ディスプレイスメントマップ"),
+    ("ec.distort.liquify", "Liquify", "ゆがみ"),
+    ("ec.distort.magnify", "Magnify", "ズーム"),
+    ("ec.distort.meshwarp", "Mesh Warp", "メッシュワープ"),
+    ("ec.distort.mirror", "Mirror", "ミラー"),
+    ("ec.distort.offset", "Offset", "オフセット"),
+    ("ec.distort.opticscompensation", "Optics Compensation", "レンズ補正"),
+    ("ec.distort.polar", "Polar Coordinates", "極座標"),
+    ("ec.distort.reshape", "Reshape", "リシェープ"),
+    ("ec.distort.ripple", "Ripple", "波紋"),
+    ("ec.distort.rollingshutterrepair", "Rolling Shutter Repair", "ローリングシャッターの修復"),
+    ("ec.distort.smear", "Smear", "にじみ"),
+    ("ec.distort.spherize", "Spherize", "球面"),
+    ("ec.distort.transform", "Transform", "トランスフォーム"),
+    ("ec.distort.turbulentdisplace", "Turbulent Displace", "タービュレントディスプレイス"),
+    ("ec.distort.twirl", "Twirl", "回転"),
+    ("ec.distort.twirllegacy", "Twirl (Legacy)", "Twirl (Legacy)"),
+    ("ec.distort.upscale", "Detail-preserving Upscale", "アップスケール（詳細を保持）"),
+    ("ec.distort.warp", "Warp", "ワープ"),
+    ("ec.distort.warpstabilizer", "Warp Stabilizer", "ワープスタビライザー"),
+    ("ec.distort.wavewarp", "Wave Warp", "波形ワープ"),
+    ("ec.generate.advancedlightning", "Advanced Lightning", "稲妻(高度)"),
+    ("ec.generate.audiospectrum", "Audio Spectrum", "オーディオスペクトラム"),
+    ("ec.generate.audiowaveform", "Audio Waveform", "オーディオウェーブフォーム"),
+    ("ec.generate.beam", "Beam", "レーザー"),
+    ("ec.generate.ccgluegun", "CC Glue Gun", "CC Glue Gun"),
+    ("ec.generate.cclightburst", "CC Light Burst 2.5", "CC Light Burst 2.5"),
+    ("ec.generate.cclightrays", "CC Light Rays", "CC Light Rays"),
+    ("ec.generate.cclightsweep", "CC Light Sweep", "CC Light Sweep"),
+    ("ec.generate.ccthreads", "CC Threads", "CC Threads"),
+    ("ec.generate.cellpattern", "Cell Pattern", "セルパターン"),
+    ("ec.generate.checkerboard", "Checkerboard", "チェッカーボード"),
+    ("ec.generate.circle", "Circle", "円"),
+    ("ec.generate.ellipse", "Ellipse", "楕円"),
+    ("ec.generate.eyedropperfill", "Eyedropper Fill", "スポイト塗り"),
+    ("ec.generate.fill", "Fill", "塗り"),
+    ("ec.generate.fourcolor", "4-Color Gradient", "4色グラデーション"),
+    ("ec.generate.fractal", "Fractal", "フラクタル"),
+    ("ec.generate.gradientramp", "Gradient Ramp", "グラデーション"),
+    ("ec.generate.grid", "Grid", "グリッド"),
+    ("ec.generate.lensflare", "Lens Flare", "レンズフレア"),
+    ("ec.generate.paintbucket", "Paint Bucket", "塗りつぶし"),
+    ("ec.generate.radiowaves", "Radio Waves", "電波"),
+    ("ec.generate.scribble", "Scribble", "落書き"),
+    ("ec.generate.stroke", "Stroke", "線"),
+    ("ec.generate.vegas", "Vegas", "ベガス"),
+    ("ec.generate.writeon", "Write-on", "ブラシアニメーション"),
+    ("ec.key.advancedspill", "Advanced Spill Suppressor", "Advanced Spill Suppressor"),
+    ("ec.key.ccsimplewireremoval", "CC Simple Wire Removal", "CC Simple Wire Removal"),
+    ("ec.key.colordifference", "Color Difference Key", "カラー差キー"),
     ("ec.key.colorkey", "Color Key", "カラーキー"),
+    ("ec.key.colorrange", "Color Range", "色範囲"),
+    ("ec.key.differencematte", "Difference Matte", "異なるマット"),
+    ("ec.key.extract", "Extract", "抽出"),
+    ("ec.key.innerouter", "Inner/Outer Key", "インナー／アウターキー"),
+    ("ec.key.keycleaner", "Key Cleaner", "Key Cleaner"),
+    ("ec.key.linearcolor", "Linear Color Key", "リニアカラーキー"),
     ("ec.key.luma", "Luma Key", "ルミナンスキー"),
     ("ec.key.spill", "Spill Suppressor", "スピルサプレッション"),
-    ("ec.obsolete.basic3d", "Basic 3D", "基本 3D"),
+    ("ec.keying.keylight", "Key Light", "Keylight (1.2)"),
+    ("ec.matte.mattechoker", "Matte Choker", "マットチョーク"),
+    ("ec.matte.refinehard", "Refine Hard Matte", "ハードマットを調整"),
+    ("ec.matte.refinesoft", "Refine Soft Matte", "ソフトマットを調整"),
+    ("ec.matte.simplechoker", "Simple Choker", "チョーク"),
+    ("ec.noise.addgrain", "Add Grain", "グレイン（追加）"),
+    ("ec.noise.curlnoise", "Curl Noise", "カールノイズ"),
+    ("ec.noise.dustscratches", "Dust & Scratches", "ダスト&スクラッチ"),
+    ("ec.noise.fractal", "Fractal Noise", "フラクタルノイズ"),
+    ("ec.noise.matchgrain", "Match Grain", "グレイン（マッチ）"),
+    ("ec.noise.median", "Median", "ミディアン"),
+    ("ec.noise.medianlegacy", "Median (Legacy)", "ミディアン（レガシー）"),
+    ("ec.noise.noise", "Noise", "ノイズ"),
+    ("ec.noise.noisealpha", "Noise Alpha", "ノイズアルファ"),
+    ("ec.noise.noisehls", "Noise HLS", "ノイズHLS"),
+    ("ec.noise.noisehlsauto", "Noise HLS Auto", "ノイズHLSオート"),
+    ("ec.noise.removegrain", "Remove Grain", "グレイン（除去）"),
+    ("ec.noise.turbulent", "Turbulent Noise", "タービュレントノイズ"),
+    ("ec.obsolete.basic3d", "Basic 3D", "基本3D"),
     ("ec.obsolete.basictext", "Basic Text", "基本テキスト"),
     ("ec.obsolete.gaussianlegacy", "Gaussian Blur (Legacy)", "ブラー（ガウス）（レガシー）"),
     ("ec.obsolete.lightning", "Lightning", "稲妻"),
+    ("ec.obsolete.mochashape", "Mocha shape", "mocha shape"),
     ("ec.obsolete.pathtext", "Path Text", "パステキスト"),
+    ("ec.perspective.3dglasses", "3D Glasses", "3Dメガネ"),
+    ("ec.perspective.bevelalpha", "Bevel Alpha", "ベベルアルファ"),
+    ("ec.perspective.beveledges", "Bevel Edges", "ベベルエッジ"),
+    ("ec.perspective.cameratracker", "3D Camera Tracker", "3D カメラトラッカー"),
+    ("ec.perspective.cccylinder", "CC Cylinder", "CC Cylinder"),
+    ("ec.perspective.ccenvironment", "CC Environment", "CC Environment"),
+    ("ec.perspective.ccsphere", "CC Sphere", "CC Sphere"),
+    ("ec.perspective.ccspotlight", "CC Spotlight", "CC Spotlight"),
+    ("ec.perspective.dropshadow", "Drop Shadow", "ドロップシャドウ"),
+    ("ec.perspective.radialshadow", "Radial Shadow", "放射状シャドウ"),
+    ("ec.sim.carddance", "Card Dance", "カードダンス"),
+    ("ec.sim.caustics", "Caustics", "コースティック"),
+    ("ec.sim.ccballaction", "CC Ball Action", "CC Ball Action"),
+    ("ec.sim.ccbubbles", "CC Bubbles", "CC Bubbles"),
+    ("ec.sim.ccdrizzle", "CC Drizzle", "CC Drizzle"),
+    ("ec.sim.cchair", "CC Hair", "CC Hair"),
+    ("ec.sim.ccmrmercury", "CC Mr. Mercury", "CC Mr. Mercury"),
+    ("ec.sim.ccparticlesystems2", "CC Particle Systems II", "CC Particle Systems II"),
+    ("ec.sim.ccparticleworld", "CC Particle World", "CC Particle World"),
+    ("ec.sim.ccpixelpolly", "CC Pixel Polly", "CC Pixel Polly"),
+    ("ec.sim.ccrainfall", "CC Rainfall", "CC Rainfall"),
+    ("ec.sim.ccscatterize", "CC Scatterize", "CC Scatterize"),
+    ("ec.sim.ccsnowfall", "CC Snowfall", "CC Snowfall"),
+    ("ec.sim.ccstarburst", "CC Star Burst", "CC Star Burst"),
+    ("ec.sim.foam", "Foam", "泡"),
+    ("ec.sim.particleplayground", "Particle Playground", "パーティクルプレイグラウンド"),
+    ("ec.sim.shatter", "Shatter", "シャター"),
+    ("ec.sim.waveworld", "Wave World", "ウェーブワールド"),
+    ("ec.stylize.brushstrokes", "Brush Strokes", "ブラシストローク"),
+    ("ec.stylize.cartoon", "Cartoon", "カートゥーン"),
+    ("ec.stylize.ccblockload", "CC Block Load", "CC Block Load"),
+    ("ec.stylize.ccburnfilm", "CC Burn Film", "CC Burn Film"),
+    ("ec.stylize.ccglass", "CC Glass", "CC Glass"),
+    ("ec.stylize.cchextile", "CC HexTile", "CC HexTile"),
+    ("ec.stylize.cckaleida", "CC Kaleida", "CC Kaleida"),
+    ("ec.stylize.ccmrsmoothie", "CC Mr. Smoothie", "CC Mr. Smoothie"),
+    ("ec.stylize.ccplastic", "CC Plastic", "CC Plastic"),
+    ("ec.stylize.ccrepetile", "CC RepeTile", "CC RepeTile"),
+    ("ec.stylize.ccthreshold", "CC Threshold", "CC Threshold"),
+    ("ec.stylize.ccthresholdrgb", "CC Threshold RGB", "CC Threshold RGB"),
+    ("ec.stylize.ccvignette", "CC Vignette", "CC Vignette"),
+    ("ec.stylize.coloremboss", "Color Emboss", "カラーエンボス"),
+    ("ec.stylize.emboss", "Emboss", "エンボス"),
+    ("ec.stylize.findedges", "Find Edges", "輪郭検出"),
+    ("ec.stylize.glow", "Glow", "グロー"),
+    ("ec.stylize.mosaic", "Mosaic", "モザイク"),
+    ("ec.stylize.motiontile", "Motion Tile", "モーションタイル"),
+    ("ec.stylize.posterize", "Posterize", "ポスタリゼーション"),
+    ("ec.stylize.roughenedges", "Roughen Edges", "ラフエッジ"),
+    ("ec.stylize.scatter", "Scatter", "拡散"),
+    ("ec.stylize.strobe", "Strobe Light", "ストロボ"),
+    ("ec.stylize.texturize", "Texturize", "テクスチャ"),
+    ("ec.stylize.threshold", "Threshold", "しきい値"),
+    ("ec.text.numbers", "Numbers", "番号"),
+    ("ec.text.timecode", "Timecode", "タイムコード"),
+    ("ec.time.ccforcemotionblur", "CC Force Motion Blur", "CC Force Motion Blur"),
+    ("ec.time.ccwidetime", "CC Wide Time", "CC Wide Time"),
+    ("ec.time.echo", "Echo", "エコー"),
     ("ec.time.pixelmotionblur", "Pixel Motion Blur", "ピクセルモーションブラー"),
+    ("ec.time.posterizetime", "Posterize Time", "ポスタリゼーション時間"),
+    ("ec.time.timedifference", "Time Difference", "時間差"),
+    ("ec.time.timedisplacement", "Time Displacement", "時間置き換え"),
+    ("ec.time.timewarp", "Timewarp", "タイムワープ"),
+    ("ec.transition.blockdissolve", "Block Dissolve", "ブロックディゾルブ"),
+    ("ec.transition.cardwipe", "Card Wipe", "カードワイプ"),
+    ("ec.transition.ccglasswipe", "CC Glass Wipe", "CC Glass Wipe"),
+    ("ec.transition.ccgridwipe", "CC Grid Wipe", "CC Grid Wipe"),
+    ("ec.transition.ccimagewipe", "CC Image Wipe", "CC Image Wipe"),
+    ("ec.transition.ccjaws", "CC Jaws", "CC Jaws"),
+    ("ec.transition.cclightwipe", "CC Light Wipe", "CC Light Wipe"),
+    ("ec.transition.cclinesweep", "CC Line Sweep", "CC Line Sweep"),
+    ("ec.transition.ccradialscalewipe", "CC Radial ScaleWipe", "CC Radial ScaleWipe"),
+    ("ec.transition.ccscalewipe", "CC Scale Wipe", "CC Scale Wipe"),
+    ("ec.transition.cctwister", "CC Twister", "CC Twister"),
+    ("ec.transition.ccwarpomatic", "CC WarpoMatic", "CC WarpoMatic"),
+    ("ec.transition.gradientwipe", "Gradient Wipe", "グラデーションワイプ"),
+    ("ec.transition.iriswipe", "Iris Wipe", "アイリスワイプ"),
+    ("ec.transition.linearwipe", "Linear Wipe", "リニアワイプ"),
+    ("ec.transition.radialwipe", "Radial Wipe", "放射状ワイプ"),
+    ("ec.transition.venetian", "Venetian Blinds", "ブラインド"),
+    ("ec.utility.applylut", "Apply Color LUT", "カラー LUT を適用"),
+    ("ec.utility.ccoverbrights", "CC Overbrights", "CC Overbrights"),
+    ("ec.utility.cineon", "Cineon Converter", "Cineon コンバーター"),
+    ("ec.utility.colorprofileconverter", "Color Profile Converter", "カラープロファイルコンバーター"),
+    ("ec.utility.growbounds", "Grow Bounds", "範囲拡張"),
+    ("ec.utility.hdrcompander", "HDR Compander", "HDR コンパンダー"),
+    ("ec.utility.hdrcompression", "HDR Highlight Compression", "HDR ハイライト圧縮"),
+    ("ec.vr.blur", "VR Blur", "VR ブラー"),
+    ("ec.vr.chromaticaberrations", "VR Chromatic Aberrations", "VR 色収差"),
+    ("ec.vr.colorgradients", "VR Color Gradients", "VR カラーグラデーション"),
+    ("ec.vr.converter", "VR Converter", "VR コンバーター"),
+    ("ec.vr.denoise", "VR De-Noise", "VR ノイズ除去"),
+    ("ec.vr.digitalglitch", "VR Digital Glitch", "VR デジタルグリッチ"),
+    ("ec.vr.fractalnoise", "VR Fractal Noise", "VR フラクタルノイズ"),
+    ("ec.vr.glow", "VR Glow", "VR グロー"),
+    ("ec.vr.planetosphere", "VR Plane to Sphere", "VR 平面として投影"),
+    ("ec.vr.rotatesphere", "VR Rotate Sphere", "VR 回転（球）"),
+    ("ec.vr.sharpen", "VR Sharpen", "VR シャープ"),
+    ("ec.vr.spheretoplane", "VR Sphere to Plane", "VR 球体から平面"),
 ];
 
 /// Traditional Chinese (`zh-hant`) category labels, keyed by the registry's English category.
@@ -490,12 +807,13 @@ const JAPANESE_CATEGORIES: &[(&str, &str)] = &[
     ("Color Correction", "カラー補正"),
     ("Distort", "ディストーション"),
     ("Expression Controls", "式制御"),
+    ("Generate", "描画"),
     ("Immersive Video", "イマーシブビデオ"),
     ("Keying", "キーイング"),
     ("Matte", "マット"),
     ("Noise & Grain", "ノイズ＆グレイン"),
     ("Obsolete", "旧バージョン"),
-    ("Paint", "描画"),
+    ("Paint", "ペイント"),
     ("Perspective", "遠近"),
     ("Simulation", "シミュレーション"),
     ("Stylize", "スタイライズ"),
@@ -519,6 +837,7 @@ const GEORGIAN: &[Row] = &[
     ("ec.3d.fog3d", "Fog 3D", "3D ნისლი"),
     ("ec.3d.identifier", "IDentifier", "IDentifier"),
     ("ec.3d.idmatte", "ID Matte", "ID მატი"),
+    ("ec.3d.instance3d", "3D Layer Instance", "3D Layer Instance"),
     ("ec.audio.backwards", "Backwards", "უკუღმა"),
     ("ec.audio.basstreble", "Bass & Treble", "ბასი და ტრებლი"),
     ("ec.audio.compressor", "Compressor", "კომპრესორი"),
@@ -845,6 +1164,346 @@ const GEORGIAN_CATEGORIES: &[(&str, &str)] = &[
     ("Utility", "დამხმარე"),
 ];
 
+/// French (`fr`): one row per effect, ids from [`SIMPLIFIED_CHINESE`]. Written from the meaning of the
+/// English names, with the terms the French menus use (calque, estampe for a matte, incrustation for
+/// keying). The `CC` series and the brand names stay in English, `VR`, `OCIO`, `PS` and `HDR` keep
+/// their tag after the translated name.
+const FRENCH: &[Row] = &[
+    ("ec.3d.channelextract", "3D Channel Extract", "Extraction de canal 3D"),
+    ("ec.3d.cryptomatte", "Cryptomatte", "Cryptomatte"),
+    ("ec.3d.depthmatte", "Depth Matte", "Estampe de profondeur"),
+    ("ec.3d.depthoffield", "Depth of Field", "Profondeur de champ"),
+    ("ec.3d.extractor", "EXtractoR", "EXtractoR"),
+    ("ec.3d.fog3d", "Fog 3D", "Brouillard 3D"),
+    ("ec.3d.identifier", "IDentifier", "IDentifier"),
+    ("ec.3d.idmatte", "ID Matte", "Estampe par ID"),
+    ("ec.audio.backwards", "Backwards", "À l’envers"),
+    ("ec.audio.basstreble", "Bass & Treble", "Graves et aigus"),
+    ("ec.audio.compressor", "Compressor", "Compresseur"),
+    ("ec.audio.delay", "Delay", "Retard"),
+    ("ec.audio.distortion", "Distortion", "Distorsion"),
+    ("ec.audio.flangechorus", "Flange & Chorus", "Flanger et chorus"),
+    ("ec.audio.gate", "Gate", "Porte de bruit"),
+    ("ec.audio.highlowpass", "High-Low Pass", "Passe-haut/passe-bas"),
+    ("ec.audio.modulator", "Modulator", "Modulateur"),
+    ("ec.audio.parametriceq", "Parametric EQ", "Égaliseur paramétrique"),
+    ("ec.audio.reverb", "Reverb", "Réverbération"),
+    ("ec.audio.stereomixer", "Stereo Mixer", "Mixeur stéréo"),
+    ("ec.audio.tone", "Tone", "Tonalité"),
+    ("ec.blur.bilateral", "Bilateral Blur", "Flou bilatéral"),
+    ("ec.blur.cameralens", "Camera Lens Blur", "Flou de l’objectif de la caméra"),
+    ("ec.blur.camerashakedeblur", "Camera-Shake Deblur", "Correction du flou de bougé de caméra"),
+    ("ec.blur.cccross", "CC Cross Blur", "CC Cross Blur"),
+    ("ec.blur.ccradial", "CC Radial Blur", "CC Radial Blur"),
+    ("ec.blur.ccradialfast", "CC Radial Fast Blur", "CC Radial Fast Blur"),
+    ("ec.blur.ccvector", "CC Vector Blur", "CC Vector Blur"),
+    ("ec.blur.channel", "Channel Blur", "Flou de canal"),
+    ("ec.blur.compound", "Compound Blur", "Flou composé"),
+    ("ec.blur.directional", "Directional Blur", "Flou directionnel"),
+    ("ec.blur.fastbox", "Fast Box Blur", "Flou rectangulaire rapide"),
+    ("ec.blur.gaussian", "Gaussian Blur", "Flou gaussien"),
+    ("ec.blur.radial", "Radial Blur", "Flou radial"),
+    ("ec.blur.reduceflicker", "Reduce Interlace Flicker", "Réduction du scintillement d’entrelacement"),
+    ("ec.blur.sharpen", "Sharpen", "Accentuation"),
+    ("ec.blur.smart", "Smart Blur", "Flou intelligent"),
+    ("ec.blur.unsharp", "Unsharp Mask", "Masque flou"),
+    ("ec.channel.arithmetic", "Arithmetic", "Arithmétique"),
+    ("ec.channel.blend", "Blend", "Fusion"),
+    ("ec.channel.calculations", "Calculations", "Calculs"),
+    ("ec.channel.cccomposite", "CC Composite", "CC Composite"),
+    ("ec.channel.combiner", "Channel Combiner", "Combinateur de canaux"),
+    ("ec.channel.compoundarithmetic", "Compound Arithmetic", "Arithmétique composée"),
+    ("ec.channel.invert", "Invert", "Inversion"),
+    ("ec.channel.minimax", "Minimax", "Minimax"),
+    ("ec.channel.removecolormatting", "Remove Color Matting", "Suppression du fond de couleur"),
+    ("ec.channel.setchannels", "Set Channels", "Définir les canaux"),
+    ("ec.channel.setmatte", "Set Matte", "Définir l’estampe"),
+    ("ec.channel.shiftchannels", "Shift Channels", "Décaler les canaux"),
+    ("ec.channel.solidcomposite", "Solid Composite", "Composite avec solide"),
+    ("ec.color.autocolor", "Auto Color", "Couleur automatique"),
+    ("ec.color.autocontrast", "Auto Contrast", "Contraste automatique"),
+    ("ec.color.autolevels", "Auto Levels", "Niveaux automatiques"),
+    ("ec.color.blackwhite", "Black & White", "Noir et blanc"),
+    ("ec.color.brightnesscontrast", "Brightness & Contrast", "Luminosité et contraste"),
+    ("ec.color.broadcast", "Broadcast Colors", "Couleurs de diffusion"),
+    ("ec.color.cccolorneutralizer", "CC Color Neutralizer", "CC Color Neutralizer"),
+    ("ec.color.cccoloroffset", "CC Color Offset", "CC Color Offset"),
+    ("ec.color.cckernel", "CC Kernel", "CC Kernel"),
+    ("ec.color.cctoner", "CC Toner", "CC Toner"),
+    ("ec.color.changecolor", "Change Color", "Changer la couleur"),
+    ("ec.color.changetocolor", "Change to Color", "Changer en couleur"),
+    ("ec.color.channelmixer", "Channel Mixer", "Mélangeur de canaux"),
+    ("ec.color.colorama", "Colorama", "Colorama"),
+    ("ec.color.colorbalance", "Color Balance", "Balance des couleurs"),
+    ("ec.color.colorbalancehls", "Color Balance (HLS)", "Balance des couleurs (TLS)"),
+    ("ec.color.colorlink", "Color Link", "Lien de couleur"),
+    ("ec.color.colorstabilizer", "Color Stabilizer", "Stabilisateur de couleur"),
+    ("ec.color.curves", "Curves", "Courbes"),
+    ("ec.color.equalize", "Equalize", "Égalisation"),
+    ("ec.color.exposure", "Exposure", "Exposition"),
+    ("ec.color.gammapedestalgain", "Gamma/Pedestal/Gain", "Gamma/Piédestal/Gain"),
+    ("ec.color.huesaturation", "Hue/Saturation", "Teinte/Saturation"),
+    ("ec.color.leavecolor", "Leave Color", "Conserver la couleur"),
+    ("ec.color.levels", "Levels", "Niveaux"),
+    ("ec.color.levelsic", "Levels (Individual Controls)", "Niveaux (contrôles individuels)"),
+    ("ec.color.lumetri", "Lumetri Color", "Lumetri Color"),
+    ("ec.color.ociocdl", "OCIO CDL Transform", "Transformation CDL OCIO"),
+    ("ec.color.ociocolorspace", "OCIO Color Space Transform", "Transformation d’espace colorimétrique OCIO"),
+    ("ec.color.ociodisplay", "OCIO Display Transform", "Transformation d’affichage OCIO"),
+    ("ec.color.ociofile", "OCIO File Transform", "Transformation de fichier OCIO"),
+    ("ec.color.ociolook", "OCIO Look Transform", "Transformation de look OCIO"),
+    ("ec.color.photofilter", "Photo Filter", "Filtre photo"),
+    ("ec.color.psarbitrarymap", "PS Arbitrary Map", "Carte arbitraire PS"),
+    ("ec.color.selectivecolor", "Selective Color", "Couleur sélective"),
+    ("ec.color.shadowhighlight", "Shadow/Highlight", "Ombres/Hautes lumières"),
+    ("ec.color.tint", "Tint", "Coloration"),
+    ("ec.color.tritone", "Tritone", "Tritone"),
+    ("ec.color.vibrance", "Vibrance", "Vibrance"),
+    ("ec.color.videolimiter", "Video Limiter", "Limiteur vidéo"),
+    ("ec.control.angle", "Angle Control", "Contrôle d’angle"),
+    ("ec.control.checkbox", "Checkbox Control", "Contrôle de case à cocher"),
+    ("ec.control.color", "Color Control", "Contrôle de couleur"),
+    ("ec.control.dropdown", "Dropdown Menu Control", "Contrôle de menu déroulant"),
+    ("ec.control.layer", "Layer Control", "Contrôle de calque"),
+    ("ec.control.point", "Point Control", "Contrôle de point"),
+    ("ec.control.point3d", "3D Point Control", "Contrôle de point 3D"),
+    ("ec.control.slider", "Slider Control", "Contrôle de curseur"),
+    ("ec.control.stereo3d", "Stereo 3D Controls", "Contrôles stéréo 3D"),
+    ("ec.distort.bezierwarp", "Bezier Warp", "Déformation Bézier"),
+    ("ec.distort.bulge", "Bulge", "Renflement"),
+    ("ec.distort.ccbender", "CC Bender", "CC Bender"),
+    ("ec.distort.ccbendit", "CC Bend It", "CC Bend It"),
+    ("ec.distort.ccblobbylize", "CC Blobbylize", "CC Blobbylize"),
+    ("ec.distort.ccflomotion", "CC Flo Motion", "CC Flo Motion"),
+    ("ec.distort.ccgriddler", "CC Griddler", "CC Griddler"),
+    ("ec.distort.cclens", "CC Lens", "CC Lens"),
+    ("ec.distort.ccpageturn", "CC Page Turn", "CC Page Turn"),
+    ("ec.distort.ccpowerpin", "CC Power Pin", "CC Power Pin"),
+    ("ec.distort.ccripplepulse", "CC Ripple Pulse", "CC Ripple Pulse"),
+    ("ec.distort.ccslant", "CC Slant", "CC Slant"),
+    ("ec.distort.ccsmear", "CC Smear", "CC Smear"),
+    ("ec.distort.ccsplit", "CC Split", "CC Split"),
+    ("ec.distort.ccsplit2", "CC Split 2", "CC Split 2"),
+    ("ec.distort.cctiler", "CC Tiler", "CC Tiler"),
+    ("ec.distort.cornerpin", "Corner Pin", "Épinglage d’angles"),
+    ("ec.distort.displacementmap", "Displacement Map", "Carte de déplacement"),
+    ("ec.distort.liquify", "Liquify", "Liquéfier"),
+    ("ec.distort.magnify", "Magnify", "Loupe"),
+    ("ec.distort.meshwarp", "Mesh Warp", "Déformation par maillage"),
+    ("ec.distort.mirror", "Mirror", "Miroir"),
+    ("ec.distort.offset", "Offset", "Décalage"),
+    ("ec.distort.opticscompensation", "Optics Compensation", "Compensation optique"),
+    ("ec.distort.polar", "Polar Coordinates", "Coordonnées polaires"),
+    ("ec.distort.puppet", "Puppet", "Marionnette"),
+    ("ec.distort.reshape", "Reshape", "Remodeler"),
+    ("ec.distort.ripple", "Ripple", "Ondulation"),
+    ("ec.distort.rollingshutterrepair", "Rolling Shutter Repair", "Correction de l’obturateur roulant"),
+    ("ec.distort.smear", "Smear", "Étalement"),
+    ("ec.distort.spherize", "Spherize", "Sphérisation"),
+    ("ec.distort.transform", "Transform", "Transformation"),
+    ("ec.distort.turbulentdisplace", "Turbulent Displace", "Déplacement turbulent"),
+    ("ec.distort.twirl", "Twirl", "Tourbillon"),
+    ("ec.distort.twirllegacy", "Twirl (Legacy)", "Tourbillon (hérité)"),
+    ("ec.distort.upscale", "Detail-preserving Upscale", "Agrandissement avec préservation des détails"),
+    ("ec.distort.warp", "Warp", "Déformation"),
+    ("ec.distort.warpstabilizer", "Warp Stabilizer", "Stabilisateur de déformation"),
+    ("ec.distort.wavewarp", "Wave Warp", "Déformation en vague"),
+    ("ec.generate.advancedlightning", "Advanced Lightning", "Foudre avancée"),
+    ("ec.generate.audiospectrum", "Audio Spectrum", "Spectre audio"),
+    ("ec.generate.audiowaveform", "Audio Waveform", "Forme d’onde audio"),
+    ("ec.generate.beam", "Beam", "Faisceau"),
+    ("ec.generate.ccgluegun", "CC Glue Gun", "CC Glue Gun"),
+    ("ec.generate.cclightburst", "CC Light Burst 2.5", "CC Light Burst 2.5"),
+    ("ec.generate.cclightrays", "CC Light Rays", "CC Light Rays"),
+    ("ec.generate.cclightsweep", "CC Light Sweep", "CC Light Sweep"),
+    ("ec.generate.ccthreads", "CC Threads", "CC Threads"),
+    ("ec.generate.cellpattern", "Cell Pattern", "Motif cellulaire"),
+    ("ec.generate.checkerboard", "Checkerboard", "Damier"),
+    ("ec.generate.circle", "Circle", "Cercle"),
+    ("ec.generate.ellipse", "Ellipse", "Ellipse"),
+    ("ec.generate.eyedropperfill", "Eyedropper Fill", "Remplissage par pipette"),
+    ("ec.generate.fill", "Fill", "Remplissage"),
+    ("ec.generate.fourcolor", "4-Color Gradient", "Dégradé à 4 couleurs"),
+    ("ec.generate.fractal", "Fractal", "Fractale"),
+    ("ec.generate.gradientramp", "Gradient Ramp", "Rampe de dégradé"),
+    ("ec.generate.grid", "Grid", "Grille"),
+    ("ec.generate.lensflare", "Lens Flare", "Reflet d’objectif"),
+    ("ec.generate.paintbucket", "Paint Bucket", "Pot de peinture"),
+    ("ec.generate.radiowaves", "Radio Waves", "Ondes radio"),
+    ("ec.generate.scribble", "Scribble", "Gribouillis"),
+    ("ec.generate.stroke", "Stroke", "Contour"),
+    ("ec.generate.vegas", "Vegas", "Vegas"),
+    ("ec.generate.writeon", "Write-on", "Écriture progressive"),
+    ("ec.key.advancedspill", "Advanced Spill Suppressor", "Suppresseur de débordement avancé"),
+    ("ec.key.ccsimplewireremoval", "CC Simple Wire Removal", "CC Simple Wire Removal"),
+    ("ec.key.colordifference", "Color Difference Key", "Incrustation par différence de couleur"),
+    ("ec.key.colorkey", "Color Key", "Incrustation couleur"),
+    ("ec.key.colorrange", "Color Range", "Plage de couleurs"),
+    ("ec.key.differencematte", "Difference Matte", "Estampe de différence"),
+    ("ec.key.extract", "Extract", "Extraction"),
+    ("ec.key.innerouter", "Inner/Outer Key", "Incrustation intérieure/extérieure"),
+    ("ec.key.keycleaner", "Key Cleaner", "Nettoyeur d’incrustation"),
+    ("ec.key.linearcolor", "Linear Color Key", "Incrustation couleur linéaire"),
+    ("ec.key.luma", "Luma Key", "Incrustation de luminance"),
+    ("ec.key.screen", "Screen Key", "Incrustation d’écran"),
+    ("ec.key.spill", "Spill Suppressor", "Suppresseur de débordement"),
+    ("ec.key.unmult", "Unmult", "Unmult"),
+    ("ec.keying.keylight", "Key Light", "Key Light"),
+    ("ec.matte.mattechoker", "Matte Choker", "Réducteur d’estampe"),
+    ("ec.matte.objectmatte", "Object Matte", "Estampe d’objet"),
+    ("ec.matte.refinehard", "Refine Hard Matte", "Affiner l’estampe nette"),
+    ("ec.matte.refinesoft", "Refine Soft Matte", "Affiner l’estampe douce"),
+    ("ec.matte.rotobrush", "Roto Brush & Refine Edge", "Roto Brush et affinage des bords"),
+    ("ec.matte.simplechoker", "Simple Choker", "Réducteur simple"),
+    ("ec.noise.addgrain", "Add Grain", "Ajouter du grain"),
+    ("ec.noise.curlnoise", "Curl Noise", "Bruit curl"),
+    ("ec.noise.dustscratches", "Dust & Scratches", "Poussières et rayures"),
+    ("ec.noise.fractal", "Fractal Noise", "Bruit fractal"),
+    ("ec.noise.matchgrain", "Match Grain", "Assortir le grain"),
+    ("ec.noise.median", "Median", "Médian"),
+    ("ec.noise.medianlegacy", "Median (Legacy)", "Médian (hérité)"),
+    ("ec.noise.noise", "Noise", "Bruit"),
+    ("ec.noise.noisealpha", "Noise Alpha", "Bruit alpha"),
+    ("ec.noise.noisehls", "Noise HLS", "Bruit TLS"),
+    ("ec.noise.noisehlsauto", "Noise HLS Auto", "Bruit TLS automatique"),
+    ("ec.noise.removegrain", "Remove Grain", "Supprimer le grain"),
+    ("ec.noise.turbulent", "Turbulent Noise", "Bruit turbulent"),
+    ("ec.obsolete.basic3d", "Basic 3D", "3D de base"),
+    ("ec.obsolete.basictext", "Basic Text", "Texte de base"),
+    ("ec.obsolete.gaussianlegacy", "Gaussian Blur (Legacy)", "Flou gaussien (hérité)"),
+    ("ec.obsolete.lightning", "Lightning", "Foudre"),
+    ("ec.obsolete.mochashape", "Mocha shape", "Forme Mocha"),
+    ("ec.obsolete.pathtext", "Path Text", "Texte sur tracé"),
+    ("ec.paint.paint", "Paint", "Peinture"),
+    ("ec.perspective.3dglasses", "3D Glasses", "Lunettes 3D"),
+    ("ec.perspective.bevelalpha", "Bevel Alpha", "Biseau alpha"),
+    ("ec.perspective.beveledges", "Bevel Edges", "Biseau des bords"),
+    ("ec.perspective.cameratracker", "3D Camera Tracker", "Suivi de caméra 3D"),
+    ("ec.perspective.cccylinder", "CC Cylinder", "CC Cylinder"),
+    ("ec.perspective.ccenvironment", "CC Environment", "CC Environment"),
+    ("ec.perspective.ccsphere", "CC Sphere", "CC Sphere"),
+    ("ec.perspective.ccspotlight", "CC Spotlight", "CC Spotlight"),
+    ("ec.perspective.dropshadow", "Drop Shadow", "Ombre portée"),
+    ("ec.perspective.radialshadow", "Radial Shadow", "Ombre radiale"),
+    ("ec.sim.carddance", "Card Dance", "Danse de cartes"),
+    ("ec.sim.caustics", "Caustics", "Caustiques"),
+    ("ec.sim.ccballaction", "CC Ball Action", "CC Ball Action"),
+    ("ec.sim.ccbubbles", "CC Bubbles", "CC Bubbles"),
+    ("ec.sim.ccdrizzle", "CC Drizzle", "CC Drizzle"),
+    ("ec.sim.cchair", "CC Hair", "CC Hair"),
+    ("ec.sim.ccmrmercury", "CC Mr. Mercury", "CC Mr. Mercury"),
+    ("ec.sim.ccparticlesystems2", "CC Particle Systems II", "CC Particle Systems II"),
+    ("ec.sim.ccparticleworld", "CC Particle World", "CC Particle World"),
+    ("ec.sim.ccpixelpolly", "CC Pixel Polly", "CC Pixel Polly"),
+    ("ec.sim.ccrainfall", "CC Rainfall", "CC Rainfall"),
+    ("ec.sim.ccscatterize", "CC Scatterize", "CC Scatterize"),
+    ("ec.sim.ccsnowfall", "CC Snowfall", "CC Snowfall"),
+    ("ec.sim.ccstarburst", "CC Star Burst", "CC Star Burst"),
+    ("ec.sim.foam", "Foam", "Mousse"),
+    ("ec.sim.particleplayground", "Particle Playground", "Terrain de jeu de particules"),
+    ("ec.sim.shatter", "Shatter", "Éclatement"),
+    ("ec.sim.waveworld", "Wave World", "Monde des vagues"),
+    ("ec.stylize.brushstrokes", "Brush Strokes", "Coups de pinceau"),
+    ("ec.stylize.cartoon", "Cartoon", "Dessin animé"),
+    ("ec.stylize.ccblockload", "CC Block Load", "CC Block Load"),
+    ("ec.stylize.ccburnfilm", "CC Burn Film", "CC Burn Film"),
+    ("ec.stylize.ccglass", "CC Glass", "CC Glass"),
+    ("ec.stylize.cchextile", "CC HexTile", "CC HexTile"),
+    ("ec.stylize.cckaleida", "CC Kaleida", "CC Kaleida"),
+    ("ec.stylize.ccmrsmoothie", "CC Mr. Smoothie", "CC Mr. Smoothie"),
+    ("ec.stylize.ccplastic", "CC Plastic", "CC Plastic"),
+    ("ec.stylize.ccrepetile", "CC RepeTile", "CC RepeTile"),
+    ("ec.stylize.ccthreshold", "CC Threshold", "CC Threshold"),
+    ("ec.stylize.ccthresholdrgb", "CC Threshold RGB", "CC Threshold RGB"),
+    ("ec.stylize.ccvignette", "CC Vignette", "CC Vignette"),
+    ("ec.stylize.coloremboss", "Color Emboss", "Estampage couleur"),
+    ("ec.stylize.emboss", "Emboss", "Estampage"),
+    ("ec.stylize.findedges", "Find Edges", "Détection des contours"),
+    ("ec.stylize.glow", "Glow", "Lueur"),
+    ("ec.stylize.mosaic", "Mosaic", "Mosaïque"),
+    ("ec.stylize.motiontile", "Motion Tile", "Mosaïque de mouvement"),
+    ("ec.stylize.posterize", "Posterize", "Postérisation"),
+    ("ec.stylize.roughenedges", "Roughen Edges", "Bords irréguliers"),
+    ("ec.stylize.scatter", "Scatter", "Dispersion"),
+    ("ec.stylize.strobe", "Strobe Light", "Lumière stroboscopique"),
+    ("ec.stylize.texturize", "Texturize", "Texturisation"),
+    ("ec.stylize.threshold", "Threshold", "Seuil"),
+    ("ec.text.numbers", "Numbers", "Nombres"),
+    ("ec.text.timecode", "Timecode", "Timecode"),
+    ("ec.time.ccforcemotionblur", "CC Force Motion Blur", "CC Force Motion Blur"),
+    ("ec.time.ccwidetime", "CC Wide Time", "CC Wide Time"),
+    ("ec.time.echo", "Echo", "Écho"),
+    ("ec.time.pixelmotionblur", "Pixel Motion Blur", "Flou de mouvement des pixels"),
+    ("ec.time.posterizetime", "Posterize Time", "Postérisation temporelle"),
+    ("ec.time.timedifference", "Time Difference", "Différence temporelle"),
+    ("ec.time.timedisplacement", "Time Displacement", "Déplacement temporel"),
+    ("ec.time.timewarp", "Timewarp", "Déformation temporelle"),
+    ("ec.transition.blockdissolve", "Block Dissolve", "Fondu par blocs"),
+    ("ec.transition.cardwipe", "Card Wipe", "Volet de cartes"),
+    ("ec.transition.ccglasswipe", "CC Glass Wipe", "CC Glass Wipe"),
+    ("ec.transition.ccgridwipe", "CC Grid Wipe", "CC Grid Wipe"),
+    ("ec.transition.ccimagewipe", "CC Image Wipe", "CC Image Wipe"),
+    ("ec.transition.ccjaws", "CC Jaws", "CC Jaws"),
+    ("ec.transition.cclightwipe", "CC Light Wipe", "CC Light Wipe"),
+    ("ec.transition.cclinesweep", "CC Line Sweep", "CC Line Sweep"),
+    ("ec.transition.ccradialscalewipe", "CC Radial ScaleWipe", "CC Radial ScaleWipe"),
+    ("ec.transition.ccscalewipe", "CC Scale Wipe", "CC Scale Wipe"),
+    ("ec.transition.cctwister", "CC Twister", "CC Twister"),
+    ("ec.transition.ccwarpomatic", "CC WarpoMatic", "CC WarpoMatic"),
+    ("ec.transition.gradientwipe", "Gradient Wipe", "Volet en dégradé"),
+    ("ec.transition.iriswipe", "Iris Wipe", "Volet en iris"),
+    ("ec.transition.linearwipe", "Linear Wipe", "Volet linéaire"),
+    ("ec.transition.radialwipe", "Radial Wipe", "Volet radial"),
+    ("ec.transition.venetian", "Venetian Blinds", "Stores vénitiens"),
+    ("ec.utility.applylut", "Apply Color LUT", "Appliquer une LUT de couleur"),
+    ("ec.utility.ccoverbrights", "CC Overbrights", "CC Overbrights"),
+    ("ec.utility.cineon", "Cineon Converter", "Convertisseur Cineon"),
+    ("ec.utility.colorprofileconverter", "Color Profile Converter", "Convertisseur de profil colorimétrique"),
+    ("ec.utility.facemeasurements", "Face Measurements", "Mesures du visage"),
+    ("ec.utility.facetrackpoints", "Face Track Points", "Points de suivi du visage"),
+    ("ec.utility.growbounds", "Grow Bounds", "Extension des limites"),
+    ("ec.utility.hdrcompander", "HDR Compander", "Compandeur HDR"),
+    ("ec.utility.hdrcompression", "HDR Highlight Compression", "Compression des hautes lumières HDR"),
+    ("ec.vr.blur", "VR Blur", "Flou VR"),
+    ("ec.vr.chromaticaberrations", "VR Chromatic Aberrations", "Aberrations chromatiques VR"),
+    ("ec.vr.colorgradients", "VR Color Gradients", "Dégradés de couleur VR"),
+    ("ec.vr.converter", "VR Converter", "Convertisseur VR"),
+    ("ec.vr.denoise", "VR De-Noise", "Réduction du bruit VR"),
+    ("ec.vr.digitalglitch", "VR Digital Glitch", "Glitch numérique VR"),
+    ("ec.vr.fractalnoise", "VR Fractal Noise", "Bruit fractal VR"),
+    ("ec.vr.glow", "VR Glow", "Lueur VR"),
+    ("ec.vr.planetosphere", "VR Plane to Sphere", "Plan vers sphère VR"),
+    ("ec.vr.rotatesphere", "VR Rotate Sphere", "Rotation de sphère VR"),
+    ("ec.vr.sharpen", "VR Sharpen", "Accentuation VR"),
+    ("ec.vr.spheretoplane", "VR Sphere to Plane", "Sphère vers plan VR"),
+    ("ec.3d.instance3d", "3D Layer Instance", "Instance de calque 3D"),
+];
+
+/// French (`fr`) category labels, keyed by the registry's English category.
+const FRENCH_CATEGORIES: &[(&str, &str)] = &[
+    ("3D Channel", "Canal 3D"),
+    ("Audio", "Audio"),
+    ("Blur & Sharpen", "Flou et netteté"),
+    ("Channel", "Canal"),
+    ("Color Correction", "Correction colorimétrique"),
+    ("Distort", "Déformation"),
+    ("Expression Controls", "Contrôles d’expression"),
+    ("Generate", "Génération"),
+    ("Immersive Video", "Vidéo immersive"),
+    ("Keying", "Incrustation"),
+    ("Matte", "Estampe"),
+    ("Noise & Grain", "Bruit et grain"),
+    ("Obsolete", "Obsolète"),
+    ("Paint", "Peinture"),
+    ("Perspective", "Perspective"),
+    ("Simulation", "Simulation"),
+    ("Stylize", "Stylisation"),
+    ("Text", "Texte"),
+    ("Time", "Temps"),
+    ("Transition", "Transition"),
+    ("Utility", "Utilitaire"),
+];
+
 /// The 21 category folder names the generated Effect menu and Effects & Presets draw, in
 /// Simplified Chinese. Read from the installed After Effects 2026 (26.5.0.89) Simplified Chinese
 /// interface (the checklist's `07-类别` sheet); two of them are the interface's own wording where
@@ -873,6 +1532,343 @@ const SIMPLIFIED_CHINESE_CATEGORIES: &[(&str, &str)] = &[
     ("Utility", "实用工具"),
 ];
 
+/// Swedish (`sv`), written from the English source.
+const SWEDISH: &[Row] = &[
+    ("ec.3d.channelextract", "3D Channel Extract", "Extrahera 3D-kanal"),
+    ("ec.3d.cryptomatte", "Cryptomatte", "Cryptomatte"),
+    ("ec.3d.depthmatte", "Depth Matte", "Djupmatte"),
+    ("ec.3d.depthoffield", "Depth of Field", "Skärpedjup"),
+    ("ec.3d.extractor", "EXtractoR", "EXtractoR"),
+    ("ec.3d.fog3d", "Fog 3D", "3D-dimma"),
+    ("ec.3d.identifier", "IDentifier", "IDentifier"),
+    ("ec.3d.idmatte", "ID Matte", "ID-matte"),
+    ("ec.audio.backwards", "Backwards", "Baklänges"),
+    ("ec.audio.basstreble", "Bass & Treble", "Bas och diskant"),
+    ("ec.audio.compressor", "Compressor", "Kompressor"),
+    ("ec.audio.delay", "Delay", "Delay"),
+    ("ec.audio.distortion", "Distortion", "Distorsion"),
+    ("ec.audio.flangechorus", "Flange & Chorus", "Flanger och chorus"),
+    ("ec.audio.gate", "Gate", "Gate"),
+    ("ec.audio.highlowpass", "High-Low Pass", "Hög-/lågpass"),
+    ("ec.audio.modulator", "Modulator", "Modulator"),
+    ("ec.audio.parametriceq", "Parametric EQ", "Parametrisk EQ"),
+    ("ec.audio.reverb", "Reverb", "Reverb"),
+    ("ec.audio.stereomixer", "Stereo Mixer", "Stereomixer"),
+    ("ec.audio.tone", "Tone", "Ton"),
+    ("ec.blur.bilateral", "Bilateral Blur", "Bilateral oskärpa"),
+    ("ec.blur.cameralens", "Camera Lens Blur", "Kameralinsoskärpa"),
+    ("ec.blur.camerashakedeblur", "Camera-Shake Deblur", "Ta bort oskärpa från kameraskakning"),
+    ("ec.blur.cccross", "CC Cross Blur", "CC Korsoskärpa"),
+    ("ec.blur.ccradial", "CC Radial Blur", "CC Radiell oskärpa"),
+    ("ec.blur.ccradialfast", "CC Radial Fast Blur", "CC Snabb radiell oskärpa"),
+    ("ec.blur.ccvector", "CC Vector Blur", "CC Vektoroskärpa"),
+    ("ec.blur.channel", "Channel Blur", "Kanaloskärpa"),
+    ("ec.blur.compound", "Compound Blur", "Sammansatt oskärpa"),
+    ("ec.blur.directional", "Directional Blur", "Riktad oskärpa"),
+    ("ec.blur.fastbox", "Fast Box Blur", "Snabb rutoskärpa"),
+    ("ec.blur.gaussian", "Gaussian Blur", "Gaussisk oskärpa"),
+    ("ec.blur.radial", "Radial Blur", "Radiell oskärpa"),
+    ("ec.blur.reduceflicker", "Reduce Interlace Flicker", "Minska flimmer från sammanflätning"),
+    ("ec.blur.sharpen", "Sharpen", "Skärpa"),
+    ("ec.blur.smart", "Smart Blur", "Smart oskärpa"),
+    ("ec.blur.unsharp", "Unsharp Mask", "Oskarp mask"),
+    ("ec.channel.arithmetic", "Arithmetic", "Aritmetik"),
+    ("ec.channel.blend", "Blend", "Blanda"),
+    ("ec.channel.calculations", "Calculations", "Beräkningar"),
+    ("ec.channel.cccomposite", "CC Composite", "CC Komposit"),
+    ("ec.channel.combiner", "Channel Combiner", "Kanalkombinerare"),
+    ("ec.channel.compoundarithmetic", "Compound Arithmetic", "Sammansatt aritmetik"),
+    ("ec.channel.invert", "Invert", "Invertera"),
+    ("ec.channel.minimax", "Minimax", "Minimax"),
+    ("ec.channel.removecolormatting", "Remove Color Matting", "Ta bort färgkantbehandling"),
+    ("ec.channel.setchannels", "Set Channels", "Ange kanaler"),
+    ("ec.channel.setmatte", "Set Matte", "Ange matte"),
+    ("ec.channel.shiftchannels", "Shift Channels", "Flytta kanaler"),
+    ("ec.channel.solidcomposite", "Solid Composite", "Enfärgad komposit"),
+    ("ec.color.autocolor", "Auto Color", "Autofärg"),
+    ("ec.color.autocontrast", "Auto Contrast", "Autokontrast"),
+    ("ec.color.autolevels", "Auto Levels", "Autonivåer"),
+    ("ec.color.blackwhite", "Black & White", "Svartvitt"),
+    ("ec.color.brightnesscontrast", "Brightness & Contrast", "Ljusstyrka och kontrast"),
+    ("ec.color.broadcast", "Broadcast Colors", "Broadcast-färger"),
+    ("ec.color.cccolorneutralizer", "CC Color Neutralizer", "CC Färgneutraliserare"),
+    ("ec.color.cccoloroffset", "CC Color Offset", "CC Färgförskjutning"),
+    ("ec.color.cckernel", "CC Kernel", "CC Kärna"),
+    ("ec.color.cctoner", "CC Toner", "CC Toner"),
+    ("ec.color.changecolor", "Change Color", "Ändra färg"),
+    ("ec.color.changetocolor", "Change to Color", "Ändra till färg"),
+    ("ec.color.channelmixer", "Channel Mixer", "Kanalmixer"),
+    ("ec.color.colorama", "Colorama", "Colorama"),
+    ("ec.color.colorbalance", "Color Balance", "Färgbalans"),
+    ("ec.color.colorbalancehls", "Color Balance (HLS)", "Färgbalans (HLS)"),
+    ("ec.color.colorlink", "Color Link", "Färglänk"),
+    ("ec.color.colorstabilizer", "Color Stabilizer", "Färgstabiliserare"),
+    ("ec.color.curves", "Curves", "Kurvor"),
+    ("ec.color.equalize", "Equalize", "Utjämna"),
+    ("ec.color.exposure", "Exposure", "Exponering"),
+    ("ec.color.gammapedestalgain", "Gamma/Pedestal/Gain", "Gamma/svartnivå/förstärkning"),
+    ("ec.color.huesaturation", "Hue/Saturation", "Nyans/mättnad"),
+    ("ec.color.leavecolor", "Leave Color", "Behåll färg"),
+    ("ec.color.levels", "Levels", "Nivåer"),
+    ("ec.color.levelsic", "Levels (Individual Controls)", "Nivåer (individuella kontroller)"),
+    ("ec.color.lumetri", "Lumetri Color", "Lumetri-färg"),
+    ("ec.color.ociocdl", "OCIO CDL Transform", "OCIO CDL-transformering"),
+    ("ec.color.ociocolorspace", "OCIO Color Space Transform", "OCIO färgrymdstransformering"),
+    ("ec.color.ociodisplay", "OCIO Display Transform", "OCIO visningstransformering"),
+    ("ec.color.ociofile", "OCIO File Transform", "OCIO filtransformering"),
+    ("ec.color.ociolook", "OCIO Look Transform", "OCIO look-transformering"),
+    ("ec.color.photofilter", "Photo Filter", "Fotofilter"),
+    ("ec.color.psarbitrarymap", "PS Arbitrary Map", "PS godtycklig mappning"),
+    ("ec.color.selectivecolor", "Selective Color", "Selektiv färg"),
+    ("ec.color.shadowhighlight", "Shadow/Highlight", "Skugga/högdager"),
+    ("ec.color.tint", "Tint", "Färgton"),
+    ("ec.color.tritone", "Tritone", "Tretoning"),
+    ("ec.color.vibrance", "Vibrance", "Lyster"),
+    ("ec.color.videolimiter", "Video Limiter", "Videobegränsare"),
+    ("ec.control.angle", "Angle Control", "Vinkelkontroll"),
+    ("ec.control.checkbox", "Checkbox Control", "Kryssrutekontroll"),
+    ("ec.control.color", "Color Control", "Färgkontroll"),
+    ("ec.control.dropdown", "Dropdown Menu Control", "Kontroll för listmeny"),
+    ("ec.control.layer", "Layer Control", "Lagerkontroll"),
+    ("ec.control.point", "Point Control", "Punktkontroll"),
+    ("ec.control.point3d", "3D Point Control", "3D-punktkontroll"),
+    ("ec.control.slider", "Slider Control", "Skjutreglagekontroll"),
+    ("ec.control.stereo3d", "Stereo 3D Controls", "Stereo 3D-kontroller"),
+    ("ec.distort.bezierwarp", "Bezier Warp", "Bezierförvrängning"),
+    ("ec.distort.bulge", "Bulge", "Utbuktning"),
+    ("ec.distort.ccbender", "CC Bender", "CC Bender"),
+    ("ec.distort.ccbendit", "CC Bend It", "CC Bend It"),
+    ("ec.distort.ccblobbylize", "CC Blobbylize", "CC Blobbylize"),
+    ("ec.distort.ccflomotion", "CC Flo Motion", "CC Flo Motion"),
+    ("ec.distort.ccgriddler", "CC Griddler", "CC Griddler"),
+    ("ec.distort.cclens", "CC Lens", "CC Objektiv"),
+    ("ec.distort.ccpageturn", "CC Page Turn", "CC Sidvändning"),
+    ("ec.distort.ccpowerpin", "CC Power Pin", "CC Power Pin"),
+    ("ec.distort.ccripplepulse", "CC Ripple Pulse", "CC Krusningspuls"),
+    ("ec.distort.ccslant", "CC Slant", "CC Lutning"),
+    ("ec.distort.ccsmear", "CC Smear", "CC Utsmetning"),
+    ("ec.distort.ccsplit", "CC Split", "CC Dela"),
+    ("ec.distort.ccsplit2", "CC Split 2", "CC Dela 2"),
+    ("ec.distort.cctiler", "CC Tiler", "CC Tiler"),
+    ("ec.distort.cornerpin", "Corner Pin", "Hörnförankring"),
+    ("ec.distort.displacementmap", "Displacement Map", "Förskjutningskarta"),
+    ("ec.distort.liquify", "Liquify", "Gör flytande"),
+    ("ec.distort.magnify", "Magnify", "Förstora"),
+    ("ec.distort.meshwarp", "Mesh Warp", "Nätförvrängning"),
+    ("ec.distort.mirror", "Mirror", "Spegel"),
+    ("ec.distort.offset", "Offset", "Förskjutning"),
+    ("ec.distort.opticscompensation", "Optics Compensation", "Optikkompensation"),
+    ("ec.distort.polar", "Polar Coordinates", "Polära koordinater"),
+    ("ec.distort.puppet", "Puppet", "Docka"),
+    ("ec.distort.reshape", "Reshape", "Omforma"),
+    ("ec.distort.ripple", "Ripple", "Krusning"),
+    ("ec.distort.rollingshutterrepair", "Rolling Shutter Repair", "Reparera rullande slutare"),
+    ("ec.distort.smear", "Smear", "Utsmetning"),
+    ("ec.distort.spherize", "Spherize", "Sfärisera"),
+    ("ec.distort.transform", "Transform", "Transformera"),
+    ("ec.distort.turbulentdisplace", "Turbulent Displace", "Turbulent förskjutning"),
+    ("ec.distort.twirl", "Twirl", "Virvel"),
+    ("ec.distort.twirllegacy", "Twirl (Legacy)", "Virvel (äldre)"),
+    ("ec.distort.upscale", "Detail-preserving Upscale", "Detaljbevarande uppskalning"),
+    ("ec.distort.warp", "Warp", "Förvräng"),
+    ("ec.distort.warpstabilizer", "Warp Stabilizer", "Warp Stabilizer"),
+    ("ec.distort.wavewarp", "Wave Warp", "Vågförvrängning"),
+    ("ec.generate.advancedlightning", "Advanced Lightning", "Avancerad blixt"),
+    ("ec.generate.audiospectrum", "Audio Spectrum", "Ljudspektrum"),
+    ("ec.generate.audiowaveform", "Audio Waveform", "Ljudvågform"),
+    ("ec.generate.beam", "Beam", "Stråle"),
+    ("ec.generate.ccgluegun", "CC Glue Gun", "CC Glue Gun"),
+    ("ec.generate.cclightburst", "CC Light Burst 2.5", "CC Ljusutbrott 2.5"),
+    ("ec.generate.cclightrays", "CC Light Rays", "CC Ljusstrålar"),
+    ("ec.generate.cclightsweep", "CC Light Sweep", "CC Ljussvep"),
+    ("ec.generate.ccthreads", "CC Threads", "CC Trådar"),
+    ("ec.generate.cellpattern", "Cell Pattern", "Cellmönster"),
+    ("ec.generate.checkerboard", "Checkerboard", "Schackbräde"),
+    ("ec.generate.circle", "Circle", "Cirkel"),
+    ("ec.generate.ellipse", "Ellipse", "Ellips"),
+    ("ec.generate.eyedropperfill", "Eyedropper Fill", "Pipettfyllning"),
+    ("ec.generate.fill", "Fill", "Fyllning"),
+    ("ec.generate.fourcolor", "4-Color Gradient", "Fyrfärgsgradient"),
+    ("ec.generate.fractal", "Fractal", "Fraktal"),
+    ("ec.generate.gradientramp", "Gradient Ramp", "Gradientramp"),
+    ("ec.generate.grid", "Grid", "Rutnät"),
+    ("ec.generate.lensflare", "Lens Flare", "Linsreflex"),
+    ("ec.generate.paintbucket", "Paint Bucket", "Färghink"),
+    ("ec.generate.radiowaves", "Radio Waves", "Radiovågor"),
+    ("ec.generate.scribble", "Scribble", "Klotter"),
+    ("ec.generate.stroke", "Stroke", "Kontur"),
+    ("ec.generate.vegas", "Vegas", "Vegas"),
+    ("ec.generate.writeon", "Write-on", "Framskrivning"),
+    ("ec.key.advancedspill", "Advanced Spill Suppressor", "Avancerad spilldämpning"),
+    ("ec.key.ccsimplewireremoval", "CC Simple Wire Removal", "CC Enkel trådborttagning"),
+    ("ec.key.colordifference", "Color Difference Key", "Färgdifferensnyckel"),
+    ("ec.key.colorkey", "Color Key", "Färgnyckel"),
+    ("ec.key.colorrange", "Color Range", "Färgomfång"),
+    ("ec.key.differencematte", "Difference Matte", "Differensmatte"),
+    ("ec.key.extract", "Extract", "Extrahera"),
+    ("ec.key.innerouter", "Inner/Outer Key", "Inre/yttre nyckel"),
+    ("ec.key.keycleaner", "Key Cleaner", "Nyckelrensare"),
+    ("ec.key.linearcolor", "Linear Color Key", "Linjär färgnyckel"),
+    ("ec.key.luma", "Luma Key", "Lumanyckel"),
+    ("ec.key.screen", "Screen Key", "Skärmnyckel"),
+    ("ec.key.spill", "Spill Suppressor", "Spilldämpning"),
+    ("ec.key.unmult", "Unmult", "Unmult"),
+    ("ec.keying.keylight", "Key Light", "Key Light"),
+    ("ec.matte.mattechoker", "Matte Choker", "Mattekrympning"),
+    ("ec.matte.objectmatte", "Object Matte", "Objektmatte"),
+    ("ec.matte.refinehard", "Refine Hard Matte", "Förfina hård matte"),
+    ("ec.matte.refinesoft", "Refine Soft Matte", "Förfina mjuk matte"),
+    ("ec.matte.rotobrush", "Roto Brush & Refine Edge", "Rotopensel och förfina kant"),
+    ("ec.matte.simplechoker", "Simple Choker", "Enkel krympning"),
+    ("ec.noise.addgrain", "Add Grain", "Lägg till korn"),
+    ("ec.noise.curlnoise", "Curl Noise", "Curl-brus"),
+    ("ec.noise.dustscratches", "Dust & Scratches", "Damm och repor"),
+    ("ec.noise.fractal", "Fractal Noise", "Fraktalbrus"),
+    ("ec.noise.matchgrain", "Match Grain", "Matcha korn"),
+    ("ec.noise.median", "Median", "Median"),
+    ("ec.noise.medianlegacy", "Median (Legacy)", "Median (äldre)"),
+    ("ec.noise.noise", "Noise", "Brus"),
+    ("ec.noise.noisealpha", "Noise Alpha", "Alfabrus"),
+    ("ec.noise.noisehls", "Noise HLS", "HLS-brus"),
+    ("ec.noise.noisehlsauto", "Noise HLS Auto", "HLS-brus auto"),
+    ("ec.noise.removegrain", "Remove Grain", "Ta bort korn"),
+    ("ec.noise.turbulent", "Turbulent Noise", "Turbulent brus"),
+    ("ec.obsolete.basic3d", "Basic 3D", "Grundläggande 3D"),
+    ("ec.obsolete.basictext", "Basic Text", "Grundläggande text"),
+    ("ec.obsolete.gaussianlegacy", "Gaussian Blur (Legacy)", "Gaussisk oskärpa (äldre)"),
+    ("ec.obsolete.lightning", "Lightning", "Blixt"),
+    ("ec.obsolete.mochashape", "Mocha shape", "Mocha-form"),
+    ("ec.obsolete.pathtext", "Path Text", "Text längs bana"),
+    ("ec.paint.paint", "Paint", "Måla"),
+    ("ec.perspective.3dglasses", "3D Glasses", "3D-glasögon"),
+    ("ec.perspective.bevelalpha", "Bevel Alpha", "Alfafasning"),
+    ("ec.perspective.beveledges", "Bevel Edges", "Fasade kanter"),
+    ("ec.perspective.cameratracker", "3D Camera Tracker", "3D-kameraspårning"),
+    ("ec.perspective.cccylinder", "CC Cylinder", "CC Cylinder"),
+    ("ec.perspective.ccenvironment", "CC Environment", "CC Miljö"),
+    ("ec.perspective.ccsphere", "CC Sphere", "CC Sfär"),
+    ("ec.perspective.ccspotlight", "CC Spotlight", "CC Strålkastare"),
+    ("ec.perspective.dropshadow", "Drop Shadow", "Slagskugga"),
+    ("ec.perspective.radialshadow", "Radial Shadow", "Radiell skugga"),
+    ("ec.sim.carddance", "Card Dance", "Kortdans"),
+    ("ec.sim.caustics", "Caustics", "Kaustik"),
+    ("ec.sim.ccballaction", "CC Ball Action", "CC Bollåtgärd"),
+    ("ec.sim.ccbubbles", "CC Bubbles", "CC Bubblor"),
+    ("ec.sim.ccdrizzle", "CC Drizzle", "CC Duggregn"),
+    ("ec.sim.cchair", "CC Hair", "CC Hår"),
+    ("ec.sim.ccmrmercury", "CC Mr. Mercury", "CC Mr. Mercury"),
+    ("ec.sim.ccparticlesystems2", "CC Particle Systems II", "CC Partikelsystem II"),
+    ("ec.sim.ccparticleworld", "CC Particle World", "CC Partikelvärld"),
+    ("ec.sim.ccpixelpolly", "CC Pixel Polly", "CC Pixel Polly"),
+    ("ec.sim.ccrainfall", "CC Rainfall", "CC Regn"),
+    ("ec.sim.ccscatterize", "CC Scatterize", "CC Utspridning"),
+    ("ec.sim.ccsnowfall", "CC Snowfall", "CC Snöfall"),
+    ("ec.sim.ccstarburst", "CC Star Burst", "CC Stjärnexplosion"),
+    ("ec.sim.foam", "Foam", "Skum"),
+    ("ec.sim.particleplayground", "Particle Playground", "Partikellekplats"),
+    ("ec.sim.shatter", "Shatter", "Krossa"),
+    ("ec.sim.waveworld", "Wave World", "Vågvärld"),
+    ("ec.stylize.brushstrokes", "Brush Strokes", "Penseldrag"),
+    ("ec.stylize.cartoon", "Cartoon", "Tecknat"),
+    ("ec.stylize.ccblockload", "CC Block Load", "CC Blockladdning"),
+    ("ec.stylize.ccburnfilm", "CC Burn Film", "CC Bränn film"),
+    ("ec.stylize.ccglass", "CC Glass", "CC Glas"),
+    ("ec.stylize.cchextile", "CC HexTile", "CC HexTile"),
+    ("ec.stylize.cckaleida", "CC Kaleida", "CC Kaleida"),
+    ("ec.stylize.ccmrsmoothie", "CC Mr. Smoothie", "CC Mr. Smoothie"),
+    ("ec.stylize.ccplastic", "CC Plastic", "CC Plast"),
+    ("ec.stylize.ccrepetile", "CC RepeTile", "CC RepeTile"),
+    ("ec.stylize.ccthreshold", "CC Threshold", "CC Tröskel"),
+    ("ec.stylize.ccthresholdrgb", "CC Threshold RGB", "CC Tröskel RGB"),
+    ("ec.stylize.ccvignette", "CC Vignette", "CC Vinjett"),
+    ("ec.stylize.coloremboss", "Color Emboss", "Färgrelief"),
+    ("ec.stylize.emboss", "Emboss", "Relief"),
+    ("ec.stylize.findedges", "Find Edges", "Hitta kanter"),
+    ("ec.stylize.glow", "Glow", "Glöd"),
+    ("ec.stylize.mosaic", "Mosaic", "Mosaik"),
+    ("ec.stylize.motiontile", "Motion Tile", "Rörlig sida vid sida"),
+    ("ec.stylize.posterize", "Posterize", "Posterisera"),
+    ("ec.stylize.roughenedges", "Roughen Edges", "Ojämna kanter"),
+    ("ec.stylize.scatter", "Scatter", "Spridning"),
+    ("ec.stylize.strobe", "Strobe Light", "Stroboskopljus"),
+    ("ec.stylize.texturize", "Texturize", "Texturera"),
+    ("ec.stylize.threshold", "Threshold", "Tröskel"),
+    ("ec.text.numbers", "Numbers", "Siffror"),
+    ("ec.text.timecode", "Timecode", "Tidskod"),
+    ("ec.time.ccforcemotionblur", "CC Force Motion Blur", "CC Tvinga rörelseoskärpa"),
+    ("ec.time.ccwidetime", "CC Wide Time", "CC Bred tid"),
+    ("ec.time.echo", "Echo", "Eko"),
+    ("ec.time.pixelmotionblur", "Pixel Motion Blur", "Pixelrörelseoskärpa"),
+    ("ec.time.posterizetime", "Posterize Time", "Posterisera tid"),
+    ("ec.time.timedifference", "Time Difference", "Tidsdifferens"),
+    ("ec.time.timedisplacement", "Time Displacement", "Tidsförskjutning"),
+    ("ec.time.timewarp", "Timewarp", "Tidsförvrängning"),
+    ("ec.transition.blockdissolve", "Block Dissolve", "Blockövertoning"),
+    ("ec.transition.cardwipe", "Card Wipe", "Kortridå"),
+    ("ec.transition.ccglasswipe", "CC Glass Wipe", "CC Glasridå"),
+    ("ec.transition.ccgridwipe", "CC Grid Wipe", "CC Rutnätsridå"),
+    ("ec.transition.ccimagewipe", "CC Image Wipe", "CC Bildridå"),
+    ("ec.transition.ccjaws", "CC Jaws", "CC Käftar"),
+    ("ec.transition.cclightwipe", "CC Light Wipe", "CC Ljusridå"),
+    ("ec.transition.cclinesweep", "CC Line Sweep", "CC Linjesvep"),
+    ("ec.transition.ccradialscalewipe", "CC Radial ScaleWipe", "CC Radiell skalridå"),
+    ("ec.transition.ccscalewipe", "CC Scale Wipe", "CC Skalridå"),
+    ("ec.transition.cctwister", "CC Twister", "CC Virvel"),
+    ("ec.transition.ccwarpomatic", "CC WarpoMatic", "CC WarpoMatic"),
+    ("ec.transition.gradientwipe", "Gradient Wipe", "Gradientridå"),
+    ("ec.transition.iriswipe", "Iris Wipe", "Irisridå"),
+    ("ec.transition.linearwipe", "Linear Wipe", "Linjär ridå"),
+    ("ec.transition.radialwipe", "Radial Wipe", "Radiell ridå"),
+    ("ec.transition.venetian", "Venetian Blinds", "Persienner"),
+    ("ec.utility.applylut", "Apply Color LUT", "Använd färg-LUT"),
+    ("ec.utility.ccoverbrights", "CC Overbrights", "CC Överljust"),
+    ("ec.utility.cineon", "Cineon Converter", "Cineon-konverterare"),
+    ("ec.utility.colorprofileconverter", "Color Profile Converter", "Färgprofilkonverterare"),
+    ("ec.utility.facemeasurements", "Face Measurements", "Ansiktsmått"),
+    ("ec.utility.facetrackpoints", "Face Track Points", "Ansiktsspårningspunkter"),
+    ("ec.utility.growbounds", "Grow Bounds", "Väx gränser"),
+    ("ec.utility.hdrcompander", "HDR Compander", "HDR-kompander"),
+    ("ec.utility.hdrcompression", "HDR Highlight Compression", "HDR-högdagerkomprimering"),
+    ("ec.vr.blur", "VR Blur", "VR-oskärpa"),
+    ("ec.vr.chromaticaberrations", "VR Chromatic Aberrations", "VR-kromatiska aberrationer"),
+    ("ec.vr.colorgradients", "VR Color Gradients", "VR-färggradienter"),
+    ("ec.vr.converter", "VR Converter", "VR-konverterare"),
+    ("ec.vr.denoise", "VR De-Noise", "VR-brusreducering"),
+    ("ec.vr.digitalglitch", "VR Digital Glitch", "VR-digitala störningar"),
+    ("ec.vr.fractalnoise", "VR Fractal Noise", "VR-fraktalbrus"),
+    ("ec.vr.glow", "VR Glow", "VR-glöd"),
+    ("ec.vr.planetosphere", "VR Plane to Sphere", "VR-plan till sfär"),
+    ("ec.vr.rotatesphere", "VR Rotate Sphere", "VR-rotera sfär"),
+    ("ec.vr.sharpen", "VR Sharpen", "VR-skärpa"),
+    ("ec.vr.spheretoplane", "VR Sphere to Plane", "VR-sfär till plan"),
+    ("ec.3d.instance3d", "3D Layer Instance", "3D-lagerinstans"),
+];
+
+/// Swedish (`sv`), written from the English source.
+const SWEDISH_CATEGORIES: &[(&str, &str)] = &[
+    ("3D Channel", "3D-kanal"),
+    ("Audio", "Ljud"),
+    ("Blur & Sharpen", "Oskärpa och skärpa"),
+    ("Channel", "Kanal"),
+    ("Color Correction", "Färgkorrigering"),
+    ("Distort", "Förvräng"),
+    ("Expression Controls", "Uttryckskontroller"),
+    ("Generate", "Generera"),
+    ("Immersive Video", "Immersiv video"),
+    ("Keying", "Keying"),
+    ("Matte", "Matte"),
+    ("Noise & Grain", "Brus och korn"),
+    ("Obsolete", "Föråldrade"),
+    ("Paint", "Måla"),
+    ("Perspective", "Perspektiv"),
+    ("Simulation", "Simulering"),
+    ("Stylize", "Stilisera"),
+    ("Text", "Text"),
+    ("Time", "Tid"),
+    ("Transition", "Övergång"),
+    ("Utility", "Verktyg"),
+];
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -908,7 +1904,7 @@ mod tests {
     const PENDING: &[(&str, &[Row])] = &[("zh-hant", TRADITIONAL_CHINESE)];
 
     /// The languages whose tables are being filled in: guarded like [`PENDING`] row by row.
-    const PARTIAL: &[(&str, &[Row])] = &[("ja", JAPANESE_EFFECTS), ("ka", GEORGIAN)];
+    const PARTIAL: &[(&str, &[Row])] = &[("ja", JAPANESE_EFFECTS), ("ka", GEORGIAN), ("sv", SWEDISH), ("fr", FRENCH)];
 
     /// A pending language may lag Simplified Chinese but may not invent ids or disagree about
     /// which effect an id names: a translator fills these tables row by row. While they are
@@ -937,9 +1933,14 @@ mod tests {
     #[test]
     fn every_category_row_names_a_category() {
         let categories = effects::categories();
-        for (language, rows) in
-            [("zh-hans", SIMPLIFIED_CHINESE_CATEGORIES), ("zh-hant", TRADITIONAL_CHINESE_CATEGORIES), ("ja", JAPANESE_CATEGORIES), ("ka", GEORGIAN_CATEGORIES)]
-        {
+        for (language, rows) in [
+            ("zh-hans", SIMPLIFIED_CHINESE_CATEGORIES),
+            ("zh-hant", TRADITIONAL_CHINESE_CATEGORIES),
+            ("ja", JAPANESE_CATEGORIES),
+            ("ka", GEORGIAN_CATEGORIES),
+            ("sv", SWEDISH_CATEGORIES),
+            ("fr", FRENCH_CATEGORIES),
+        ] {
             for (english, translated) in rows {
                 assert!(categories.contains(english), "{language} lists {english}, which is not a category");
                 assert!(!translated.is_empty(), "empty {language} translation for {english}");
@@ -987,6 +1988,29 @@ mod tests {
         set_current("en");
     }
 
+    /// Every Swedish row names an effect the registry has, by the registry's English name; an
+    /// effect without a row draws its English name, so a new effect does not block other work.
+    /// Names and categories draw in Swedish and search finds either name.
+    #[test]
+    fn swedish_rows_match_the_registry() {
+        let registry = effects::registry();
+        for (id, english, translated) in SWEDISH {
+            let Some(spec) = registry.iter().find(|spec| spec.id == *id) else {
+                panic!("Swedish row {id} is not an effect in the registry");
+            };
+            assert_eq!(*english, spec.name, "{id}: the Swedish catalog says {english:?}, the registry {:?}", spec.name);
+            assert!(!translated.is_empty(), "{id}: empty Swedish translation");
+        }
+        set_current("sv");
+        assert_eq!(name("ec.blur.gaussian", "Gaussian Blur"), "Gaussisk oskärpa");
+        assert_eq!(group("ec.blur.gaussian", "Gaussian Blur 2"), "Gaussisk oskärpa 2");
+        assert_eq!(group("ec.blur.gaussian", "My Blur"), "My Blur");
+        assert_eq!(category("Blur & Sharpen"), "Oskärpa och skärpa");
+        assert!(matches("ec.blur.gaussian", "Gaussian Blur", "gaussisk"));
+        assert!(matches("ec.blur.gaussian", "Gaussian Blur", "blur"));
+        set_current("en");
+    }
+
     /// The Effects & Presets search answers to either name, so a Chinese interface can be
     /// searched in Chinese while an English one still finds the effect by its registry name.
     #[test]
@@ -1001,3 +2025,21 @@ mod tests {
         assert!(!matches("ec.blur.gaussian", "Gaussian Blur", "高斯"));
     }
 }
+
+#[cfg(test)]
+mod japanese_category_tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    /// Two categories drawing the same Japanese name would make the Effect menu show one name twice and
+    /// leave the user unable to tell them apart. `描画` was both `Generate` and `Paint` before #2583.
+    #[test]
+    fn no_two_categories_share_a_japanese_name() {
+        let mut seen: HashMap<&str, &str> = HashMap::new();
+        for (english, japanese) in JAPANESE_CATEGORIES {
+            if let Some(other) = seen.insert(japanese, english) {
+                panic!("`{english}` and `{other}` both draw as `{japanese}`");
+            }
+        }
+    }
+}
diff --git a/crates/ui-egui/src/i18n/ui.rs b/crates/ui-egui/src/i18n/ui.rs
index a9c45bb99..dd00b4123 100644
--- a/crates/ui-egui/src/i18n/ui.rs
+++ b/crates/ui-egui/src/i18n/ui.rs
@@ -6,7 +6,7 @@
 //! inventing an id, and a missing row falls back to English instead of to an empty label.
 //!
 //! The language in force is set once per frame, from the same resolved language the fonts are
-//! installed for ([`super::language`], [`set_current`]), so a panel does not have to thread it
+//! installed for (`crate::i18n::language`, [`set_current`]), so a panel does not have to thread it
 //! through every function. It is thread-local: the render threads never draw interface text.
 //!
 //! A row that carries values keeps one `{}` per value and is read with [`tr_args`]; the tests below
@@ -22,7 +22,7 @@ use std::fmt::Display;
 use std::sync::OnceLock;
 
 thread_local! {
-    /// The resolved interface language ("en", "ja", "zh-hans", "zh-hant", "uk", "pt-br", "cs", "es", "ka"); "en" until the first
+    /// The resolved interface language ("en", "ja", "zh-hans", "zh-hant", "uk", "pt-br", "cs", "es", "pl", "ka", "sv", "fr"); "en" until the first
     /// frame sets it.
     static CURRENT: Cell<&'static str> = const { Cell::new("en") };
 }
@@ -50,8 +50,11 @@ const ROWS: &[(&str, &[(&str, &str)])] = &[
     ("pt-br", PORTUGUESE),
     ("cs", CZECH),
     ("es", SPANISH),
+    ("pl", POLISH),
     ("ka", GEORGIAN),
     ("ka", GEORGIAN_PANELS),
+    ("sv", SWEDISH),
+    ("fr", FRENCH),
 ];
 
 /// The catalog for `language`, indexed by English source (built on first use: panels translate
@@ -64,7 +67,10 @@ fn catalog(language: &str) -> Option<&'static Index> {
     static PT_BR: OnceLock<Index> = OnceLock::new();
     static CS: OnceLock<Index> = OnceLock::new();
     static ES: OnceLock<Index> = OnceLock::new();
+    static PL: OnceLock<Index> = OnceLock::new();
     static KA: OnceLock<Index> = OnceLock::new();
+    static SV: OnceLock<Index> = OnceLock::new();
+    static FR: OnceLock<Index> = OnceLock::new();
     let (index, rows) = match language {
         "ja" => (&JA, JAPANESE),
         "zh-hans" => (&HANS, SIMPLIFIED_CHINESE),
@@ -73,8 +79,11 @@ fn catalog(language: &str) -> Option<&'static Index> {
         "pt-br" => (&PT_BR, PORTUGUESE),
         "cs" => (&CS, CZECH),
         "es" => (&ES, SPANISH),
+        "pl" => (&PL, POLISH),
+        "fr" => (&FR, FRENCH),
         // Georgian also reads its own rows for text the other catalogs don't have yet.
         "ka" => return Some(KA.get_or_init(|| GEORGIAN.iter().chain(GEORGIAN_PANELS).copied().collect())),
+        "sv" => (&SV, SWEDISH),
         _ => return None,
     };
     Some(index.get_or_init(|| rows.iter().copied().collect()))
@@ -92,6 +101,13 @@ pub(super) fn missing(language: &str) -> Vec<String> {
     rows.chain(literals).filter(|en| !table.is_some_and(|c| c.contains_key(en.as_str())) && seen.insert(en.clone())).collect()
 }
 
+/// The number of panel/dialog rows `language` translates, for the row-count report; 0 when it has
+/// no catalog or when it is English.
+#[cfg(test)]
+pub(super) fn translated_rows(language: &str) -> usize {
+    catalog(language).map_or(0, Index::len)
+}
+
 /// The string literals `src` passes to `tr(` and `tr_args(`.
 #[cfg(test)]
 fn tr_literals(src: &str) -> Vec<String> {
@@ -163,6 +179,7 @@ pub(crate) fn tr_args(text: &str, args: &[&dyn Display]) -> String {
 
 /// Japanese: the same rows, in the same order, as the Chinese catalogs below.
 const JAPANESE: &[(&str, &str)] = &[
+    ("Click to sample color", "クリックして色をサンプル"),
     ("Appearance Settings…", "外観設定…"),
     ("Add to favorites", "お気に入りに追加"),
     ("Remove from favorites", "お気に入りから削除"),
@@ -180,6 +197,7 @@ const JAPANESE: &[(&str, &str)] = &[
     ("About...", "情報..."),
     ("Active", "使用中"),
     ("Active Camera", "アクティブカメラ"),
+    ("Active Camera ({})", "アクティブカメラ（{}）"),
     ("Alpha", "アルファ"),
     ("Adapt Feature On Every Frame", "フレームごとに特徴を更新"),
     ("Adaptive Sample Limit:", "適応サンプル数の上限:"),
@@ -193,9 +211,10 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Add a shape, fill, stroke or path operation", "シェイプ、塗り、線、またはパス操作を追加"),
     ("Add to Composition", "コンポジションに追加"),
     ("Add to Favorites", "お気に入りに追加"),
-    ("Add:", "追加:"),
+    ("Add:", "追加："),
     ("Adjust Exposure (stops)", "露出を調整（段単位）"),
     ("Adjust composition duration to the time span of the selected layers", "コンポジションのデュレーションを、選択したレイヤーの時間範囲に合わせる"),
+    ("Advanced", "詳細"),
     ("Advanced 3D", "アドバンスド3D"),
     ("Align Layers to:", "レイヤーの整列基準:"),
     ("All six face cameras turn together; the scene is not changed.", "6つの面のカメラがすべて一緒に回転します。シーンは変更されません。"),
@@ -304,7 +323,6 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Duration:", "デュレーション:"),
     ("Edit Gradient…", "グラデーションを編集…"),
     ("Edit Target: {}", "編集対象：{}"),
-    ("Edit in the Timeline", "タイムラインで編集"),
     ("EffectCraft didn't quit normally last time.", "EffectCraftは前回正常に終了しませんでした。"),
     ("Effects", "エフェクト"),
     ("Effects & Presets options", "エフェクト＆プリセットのオプション"),
@@ -384,7 +402,7 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Lighter", "明るく"),
     ("Link Selected Property", "選択したプロパティをリンク"),
     ("Location:", "位置:"),
-    ("Lock Aspect Ratio to {}", "縦横比を {} に固定"),
+    ("Lock Aspect Ratio to {}", "縦横比を{}に固定"),
     ("Lock to Zoom", "ズームにロック"),
     ("Locked: {} — {}", "ロック済み：{} — {}"),
     ("Log:", "ログ:"),
@@ -434,6 +452,7 @@ const JAPANESE: &[(&str, &str)] = &[
     ("No layer selected", "レイヤーが選択されていません"),
     ("No matching effects or presets", "一致するエフェクトまたはプリセットはありません"),
     ("No matching fonts", "一致するフォントはありません"),
+    ("Rescan Fonts", "フォントを再スキャン"),
     ("Variable fonts only", "可変フォントのみ"),
     ("No model credits were built into this copy.", "このビルドにはモデルのクレジットが含まれていません。"),
     ("No nested compositions", "ネストされたコンポジションはありません"),
@@ -443,7 +462,7 @@ const JAPANESE: &[(&str, &str)] = &[
     ("None", "なし"),
     ("Not applied: tick it in the list to add it.", "未適用：リストでチェックを入れると追加されます。"),
     ("Not assigned", "未割り当て"),
-    ("Note: Shadows are only cast from layers with Cast Shadows enabled.", "注意：シャドウは「シャドウを投影」が有効なレイヤーからのみ投影されます。"),
+    ("Note: Shadows are only cast from layers with Cast Shadows enabled.", "注意：「シャドウを落とす」が有効なレイヤーだけがシャドウを落とします。"),
     ("Notify", "通知"),
     ("OK", "OK"),
     ("Offset:", "オフセット:"),
@@ -451,8 +470,8 @@ const JAPANESE: &[(&str, &str)] = &[
     ("One-Node Camera", "1ノードカメラ"),
     ("Opacity:", "不透明度:"),
     ("Open Composition", "コンポジションを開く"),
-    ("used once", "1 回使用"),
-    ("used {} times", "{} 回使用"),
+    ("used once", "1回使用"),
+    ("used {} times", "{}回使用"),
     ("Compositions that use this item", "このアイテムを使用しているコンポジション"),
     ("Open Last Saved Project", "最後に保存したプロジェクトを開く"),
     ("Open New Composition", "新規コンポジションを開く"),
@@ -467,7 +486,9 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Overlay", "オーバーレイ"),
     ("Parameter Name:", "パラメーター名:"),
     ("Parent pick whip: drag onto a layer", "親ピックウィップ：レイヤー上にドラッグ"),
+    ("Track Matte pick whip: drag onto a layer", "トラックマットピックウィップ：レイヤー上にドラッグ"),
     ("Pixel Aspect Ratio:", "ピクセル縦横比:"),
+    ("Play/Stop", "再生/停止"),
     ("Playing on Video Preview", "ビデオプレビューで再生中"),
     ("Post-Render Action: {}", "レンダリング後の処理：{}"),
     ("Preserve frame rate when nested or in render queue", "ネスト時またはレンダーキュー内でフレームレートを保持"),
@@ -523,7 +544,7 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Select a command to change its shortcut.", "ショートカットを変更するコマンドを選択してください。"),
     ("Select a layer to see its effects", "レイヤーを選択するとエフェクトが表示されます"),
     ("Select a layer to see its properties", "レイヤーを選択するとプロパティが表示されます"),
-    ("({}) Selected Objects", "({}) 個の選択されたオブジェクト"),
+    ("({}) Selected Objects", "選択したオブジェクト（{}）"),
     (
         "Select a layer with a mask or shape path (or the path property), or Puppet pins.",
         "マスクまたはシェイプパスのあるレイヤー（またはパスプロパティ）か、パペットピンを選択してください。",
@@ -615,7 +636,12 @@ const JAPANESE: &[(&str, &str)] = &[
     ),
     ("VR Environments", "VR環境"),
     ("Value:", "値:"),
-    ("Variable Font Axes", "可変フォントの軸"),
+    ("Variable Font Axes", "バリアブルフォント軸"),
+    ("Selector: Range", "セレクター: 範囲"),
+    ("Selector: Wiggly", "セレクター: ウィグリー"),
+    ("Selector: Expression", "セレクター: エクスプレッション"),
+    ("Property: {}", "プロパティ: {}"),
+    ("Variable Font Axes: {}", "バリアブルフォント軸: {}"),
     ("Video Codec: {}", "ビデオコーデック：{}"),
     ("View:", "表示:"),
     ("Welcome to EffectCraft", "EffectCraftへようこそ"),
@@ -643,16 +669,16 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Fit", "フィット"),
     ("Fit up to 100%", "100%までフィット"),
     ("Full", "フル画質"),
-    ("Half", "1/2 画質"),
+    ("Half", "1/2画質"),
     ("Only this layer uses this solid.", "この平面を使用するのはこのレイヤーだけです。"),
     ("Proportional Grid", "プロポーショナルグリッド"),
-    ("Quarter", "1/4 画質"),
+    ("Quarter", "1/4画質"),
     ("Region of Interest", "関心領域"),
     ("Reset Exposure", "露出をリセット"),
     ("Show Channel and Color Management Settings", "チャンネルとカラーマネジメント設定を表示"),
     ("Show Snapshot (hold)", "スナップショットを表示（長押し）"),
     ("Take Snapshot", "スナップショットを取得"),
-    ("Third", "1/3 画質"),
+    ("Third", "1/3画質"),
     ("Toggle Mask and Shape Path Visibility", "マスクとシェイプのパスを表示"),
     ("Toggle Transparency Grid", "透明グリッドを切り替え"),
     ("16 bits per channel", "チャンネルあたり16ビット"),
@@ -662,16 +688,16 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Adobe-style built-in", "Adobe標準の組み込み"),
     ("Blue", "青"),
     ("Current Settings", "現在の設定"),
-    ("Disable Per-character 3D", "文字ごとの3Dを無効化"),
+    ("Disable Per-character 3D", "文字単位の 3D 化を使用しない"),
     ("Draft", "ドラフト"),
-    ("Enable Per-character 3D", "文字ごとの3Dを有効化"),
+    ("Enable Per-character 3D", "文字単位の 3D 化を使用"),
     ("Fast Draft", "高速ドラフト"),
-    ("Fast Previews (Draft 3D, Faster Effects)", "高速プレビュー（ドラフト 3D、より高速なエフェクト）"),
+    ("Fast Previews (Draft 3D, Faster Effects)", "高速プレビュー（ドラフト3D、より高速なエフェクト）"),
     ("Green", "緑"),
     ("Import Image Sequence", "画像シーケンスを読み込み"),
     ("Import PDF / Illustrator File", "PDF / Illustratorファイルを読み込み"),
     ("Import Photoshop File", "Photoshopファイルを読み込み"),
-    ("Interpret Unlabeled Alpha As", "ラベルのないアルファを変換"),
+    ("Interpret Unlabeled Alpha As", "ラベルのないアルファの解釈"),
     ("Join the ArtCraft Discord", "ArtCraftのDiscordに参加"),
     ("Mercury GPU Acceleration ({})", "Mercury GPUアクセラレーション（{}）"),
     ("Mercury Software Only", "Mercuryソフトウェアのみ"),
@@ -679,7 +705,7 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Off (Final Quality)", "オフ（最終品質）"),
     ("OpenGL (compatibility)", "OpenGL（互換）"),
     ("Opus Bitrate: {} kbps", "Opusビットレート：{} kbps"),
-    ("RGB Straight", "RGB ストレート"),
+    ("RGB Straight", "RGBストレート"),
     ("Red", "赤"),
     ("Tone map", "トーンマップ"),
     ("Use In-Window Menu Bar on macOS", "macOSでウィンドウ内メニューバーを使用"),
@@ -779,17 +805,17 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Faster", "高速"),
     ("More Accurate", "精度を優先"),
     ("Display Color Space", "表示色空間"),
-    ("GPU Information...", "GPU 情報..."),
+    ("GPU Information...", "GPU情報..."),
     ("Appearance", "外観"),
     ("Brightness", "明るさ"),
-    ("UI Scale", "UI スケール"),
+    ("UI Scale", "UIスケール"),
     ("Labels and Colors", "ラベルとカラー"),
     ("Use Label Color for Layer Handles and Paths", "レイヤーハンドルとパスにラベルカラーを使用"),
     ("Use Label Color for Related Tabs", "ラベルカラーを関連するタブに使用"),
     ("Cycle Mask Colors", "新規マスクに別のカラーを使用"),
     ("Use Gradients", "グラデーションを使用"),
     ("Menu Bar", "メニューバー"),
-    ("Grids & Guides", "グリッド＆ガイド"),
+    ("Grids & Guides", "グリッドとガイド"),
     ("Gridline Every", "グリッドの間隔"),
     ("Subdivisions", "分割数"),
     ("Style", "スタイル"),
@@ -821,7 +847,7 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Ask User", "ユーザーに確認"),
     ("Guess", "推測"),
     ("Ignore", "無視"),
-    ("Straight", "そのまま"),
+    ("Straight", "ストレート"),
     ("Premultiplied", "プリマルチプライ"),
     ("Default Drag Import As", "複数アイテムのドラッグ読み込みの初期設定"),
     ("Footage", "フッテージ"),
@@ -849,8 +875,8 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Media Cache", "メディアキャッシュ"),
     ("Database and Cache Folder", "データベースとキャッシュのフォルダー"),
     ("Conformed Audio Folder", "適合オーディオフォルダー"),
-    ("Memory & CPU", "メモリと CPU"),
-    ("RAM Reserved for Other Applications", "他のアプリケーション用に確保する RAM"),
+    ("Memory & CPU", "メモリとCPU"),
+    ("RAM Reserved for Other Applications", "他のアプリケーション用に確保するRAM"),
     ("Cache Budgets", "キャッシュの割り当て"),
     ("Layer Cache", "レイヤーキャッシュ"),
     ("Footage Frame Cache", "フッテージフレームキャッシュ"),
@@ -864,14 +890,14 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Video Output During Playback", "再生中のビデオ出力"),
     ("Mirror on Computer Monitor", "コンピューターモニターにミラーリング"),
     ("Disable Video Output When in Background", "バックグラウンド動作時のビデオ出力を無効にする"),
-    ("Default 3D Renderer", "既定の 3D レンダラー"),
+    ("Default 3D Renderer", "既定の3Dレンダラー"),
     ("Show 3D Reference Axes", "3D参照軸を表示"),
     ("Extended Viewer", "拡張ビューアー"),
     ("Realtime Shadows in Draft", "ドラフトのリアルタイムシャドウ"),
     ("Scripting & Expressions", "スクリプトとエクスプレッション"),
     ("Application Scripting", "アプリケーションのスクリプト"),
     ("Allow Scripts to Write Files and Access Network", "スクリプトによるファイルへの書き込みとネットワークへのアクセスを許可"),
-    ("Warn User When Executing Files", "ファイルの実行時にカーソルに警告"),
+    ("Warn User When Executing Files", "ファイルの実行時にユーザーに警告"),
     ("Enable JavaScript Debugger", "JavaScript デバッガーを使用"),
     ("Expressions Editor", "エクスプレッションエディター"),
     ("Font Size", "フォントサイズ"),
@@ -880,7 +906,7 @@ const JAPANESE: &[(&str, &str)] = &[
     ("Auto-complete", "オートコンプリート"),
     ("Bracket Matching", "対応する括弧をハイライト"),
     ("Word Wrap", "折り返し"),
-    ("Show Expression Error Banner", "式のエラーがある場合に警告バナーを表示"),
+    ("Show Expression Error Banner", "エクスプレッションのエラーがある場合に警告バナーを表示"),
     (
         "Expressions use the JavaScript engine. Script errors report their file and line in the Script Console; there is no step debugger.",
         "エクスプレッションはJavaScriptエンジンを使用します。スクリプトのエラーはファイルと行をスクリプトコンソールに報告します。ステップ実行デバッガーはありません。",
@@ -898,12 +924,391 @@ const JAPANESE: &[(&str, &str)] = &[
         "トラッカーパネルのフェイストラッキング（輪郭のみと詳細機能）はここで選んだモデルを使用します。モデルはオープンソースで、要求したときだけダウンロードされ、公開されているSHA-256と照合されます。",
     ),
     ("Match System", "システムに合わせる"),
+    ("Default", "デフォルト"),
+    ("Stored, but not used by EffectCraft yet", "保存されますが、EffectCraftではまだ使用されません"),
     ("Total Offset", "合計オフセット"),
     ("Per Layer", "レイヤーごと"),
     ("Track", "トラック"),
+    ("Selection Tool", "選択ツール"),
+    ("Hand Tool", "手のひらツール"),
+    ("Zoom Tool", "ズームツール"),
+    ("Orbit Around Cursor Tool", "カーソルのまわりを周回ツール"),
+    ("Pan Under Cursor Tool", "カーソルの下でパンツール"),
+    ("Dolly Towards Cursor Tool", "カーソルに向かってドリーツール"),
+    ("Rotation Tool", "回転ツール"),
+    ("Pan Behind (Anchor Point) Tool", "アンカーポイントツール"),
+    ("Rectangle Tool", "長方形ツール"),
+    ("Rounded Rectangle Tool", "角丸長方形ツール"),
+    ("Ellipse Tool", "楕円形ツール"),
+    ("Polygon Tool", "多角形ツール"),
+    ("Star Tool", "スターツール"),
+    ("Pen Tool", "ペンツール"),
+    ("Add Vertex Tool", "頂点を追加ツール"),
+    ("Delete Vertex Tool", "頂点を削除ツール"),
+    ("Convert Vertex Tool", "頂点を切り替えツール"),
+    ("Mask Feather Tool", "マスクの境界のぼかしツール"),
+    ("Horizontal Type Tool", "横書き文字ツール"),
+    ("Vertical Type Tool", "縦書き文字ツール"),
+    ("Brush Tool", "ブラシツール"),
+    ("Clone Stamp Tool", "コピースタンプツール"),
+    ("Eraser Tool", "消しゴムツール"),
+    ("Roto Brush Tool", "ロトブラシツール"),
+    ("Refine Edge Tool", "エッジを調整ツール"),
+    ("Object Matte Tool", "オブジェクトマットツール"),
+    ("Puppet Position Pin Tool", "パペット位置ピンツール"),
+    ("Puppet Starch Pin Tool", "パペットスターチピンツール"),
+    ("Puppet Bend Pin Tool", "パペットベンドピンツール"),
+    ("Puppet Advanced Pin Tool", "パペット詳細ピンツール"),
+    ("Puppet Overlap Pin Tool", "パペット重なりピンツール"),
+    ("Shortcut", "ショートカット"),
+    ("Range", "範囲"),
+    ("Play From", "再生開始位置"),
+    ("Force alphabetical order", "アルファベット順を強制"),
+    ("Frame rate (fps)", "フレームレート (fps)"),
+    ("Import Kind", "読み込みの種類"),
+    ("Delay (s)", "遅延 (秒)"),
+    ("Amount (%)", "量 (%)"),
+    ("Cascade (farther pins trail longer)", "カスケード (離れたピンほど長く遅れる)"),
+    ("Speed (%)", "速度 (%)"),
+    ("Use Draft Deformation", "下書き変形を使用"),
+    ("Show Mesh", "メッシュを表示"),
+    ("Scale X (%)", "X方向の拡大率 (%)"),
+    ("Scale Y (%)", "Y方向の拡大率 (%)"),
+    ("Rotation (degrees)", "回転 (度)"),
+    ("Move X", "X移動"),
+    ("Move Y", "Y移動"),
+    ("Position (pixels)", "位置 (ピクセル)"),
+    ("Position (percent of the composition)", "位置 (コンポジションに対する割合)"),
+    ("Use Dimensions From", "使用するサイズの基準"),
+    ("Still Duration (seconds)", "静止画のデュレーション (秒)"),
+    ("Add to Render Queue", "レンダーキューに追加"),
+    ("Sequence Layers", "レイヤーをシーケンス化"),
+    ("Duration (seconds)", "デュレーション (秒)"),
+    ("Matte color (premultiplied)", "マットの色 (プリマルチプライ)"),
+    ("Invert Alpha", "アルファを反転"),
+    ("Assume this frame rate", "このフレームレートとみなす"),
+    ("Separate Fields", "フィールドを分離"),
+    ("Pixel Aspect Ratio", "ピクセル縦横比"),
+    ("Loop (times)", "ループ (回)"),
+    ("Assign Profile", "プロファイルを割り当て"),
+    ("Preserve RGB", "RGBを保持"),
+    ("Interpret As Linear Light", "リニア光として解釈"),
+    ("Start Timecode", "開始タイムコード"),
+    ("Override Start", "開始値を上書き"),
+    ("Time display style", "タイムコード表示"),
+    ("Color engine", "カラーエンジン"),
+    ("Working space", "作業用スペース"),
+    ("Working gamma", "作業用ガンマ"),
+    ("Linearize working space", "作業用スペースをリニア化"),
+    ("Blend colors using 1.0 gamma", "1.0ガンマで色を混合"),
+    ("Output color space", "出力カラースペース"),
+    ("Video rendering and effects", "ビデオのレンダリングとエフェクト"),
+    ("Time Span", "時間範囲"),
+    ("Blur (pixels before auto-trace)", "ブラー (自動トレース前のピクセル)"),
+    ("Tolerance (pixels)", "許容値 (ピクセル)"),
+    ("Threshold (%)", "しきい値 (%)"),
+    ("Minimum Area (pixels)", "最小領域 (ピクセル)"),
+    ("Corner Roundness (%)", "角の丸み (%)"),
+    ("Apply To New Layer", "新しいレイヤーに適用"),
+    ("Sensitivity threshold (0–1, lower finds more)", "感度のしきい値 (0～1、低いほど多く検出)"),
+    ("Time field (empty: automatic)", "時間フィールド (空欄: 自動)"),
+    ("Video start (ISO date-time, hh:mm:ss, timecode; empty: file date)", "ビデオ開始 (ISO日時、hh:mm:ss、タイムコード、空欄: ファイルの日付)"),
+    ("First sample at (comp seconds)", "最初のサンプル位置 (コンポジション秒)"),
+    ("Frame rate", "フレームレート"),
+    ("Color (#rrggbb)", "カラー (#rrggbb)"),
+    ("Embed footage files", "フッテージを埋め込む"),
+    ("Embed up to (MB)", "埋め込み上限 (MB)"),
+    ("Orient Along Path", "パスに沿って向きを設定"),
+    ("Orient Towards Camera", "カメラの方向に向ける"),
+    ("Orient Towards Point of Interest", "対象点の方向に向ける"),
+    ("Single Composition", "単一コンポジション"),
+    ("Multiple Compositions", "複数のコンポジション"),
+    ("Dissolve Front Layer", "前面のレイヤーをディゾルブ"),
+    ("Cross Dissolve Front and Back Layers", "前後のレイヤーをクロスディゾルブ"),
+    ("Interpret Straight - Unmatted", "ストレート (マットなし) として解釈"),
+    ("Interpret Premultiplied - Matted With Color", "プリマルチプライ (色でマット) として解釈"),
+    ("Upper Field First", "偶数フィールド優先"),
+    ("Lower Field First", "奇数フィールド優先"),
+    ("Rec. 2020", "Rec. 2020"),
+    ("Use Source File Timecode", "ソースファイルのタイムコードを使用"),
+    ("Feet + Frames (35mm)", "フィート + フレーム (35mm)"),
+    ("Feet + Frames (16mm)", "フィート + フレーム (16mm)"),
+    ("Current Frame", "現在のフレーム"),
+    ("Work Area", "作業領域"),
+    ("Create Markers", "マーカーを作成"),
+    ("Split Layers", "レイヤーを分割"),
+    ("Split and Precompose", "分割してプリコンポーズ"),
+    ("All layers", "すべてのレイヤー"),
+    ("None (leave them out)", "なし (除外)"),
+    ("Nested sequences", "ネストしたシーケンス"),
+    ("Solid…", "平面…"),
+    ("Light…", "ライト…"),
+    ("Camera…", "カメラ…"),
+    ("Null Object", "ヌルオブジェクト"),
+    ("Shape Layer", "シェイプレイヤー"),
+    ("Adjustment Layer", "調整レイヤー"),
+    ("Layer Settings…", "レイヤー設定…"),
+    ("Create Shapes from Vector Layer", "ベクターレイヤーからシェイプを作成"),
+    ("Create Shapes from Text", "テキストからシェイプを作成"),
+    ("Create Masks from Text", "テキストからマスクを作成"),
+    ("New Mask", "新規マスク"),
+    ("Center In View", "ビューの中央に配置"),
+    ("Fit to Comp", "コンポジションに合わせる"),
+    ("Flip Horizontal", "水平方向に反転"),
+    ("Flip Vertical", "垂直方向に反転"),
+    ("Enable Time Remapping", "時間リマップを有効化"),
+    ("Time-Reverse Layer", "レイヤーを時間反転"),
+    ("Freeze Frame", "フレームを固定"),
+    ("Freeze On Last Frame", "最後のフレームで固定"),
+    ("Add Marker", "マーカーを追加"),
+    ("Bring Layer to Front", "レイヤーを最前面へ"),
+    ("Bring Layer Forward", "レイヤーを前面へ"),
+    ("Send Layer Backward", "レイヤーを背面へ"),
+    ("Send Layer to Back", "レイヤーを最背面へ"),
+    ("Pre-compose…", "プリコンポーズ…"),
+    ("Split Layer", "レイヤーを分割"),
+    ("Layer Style Options...", "レイヤースタイルのオプション..."),
+    ("Convert to Editable Styles", "編集可能なスタイルに変換"),
+    ("Show All", "すべて表示"),
+    ("Remove All", "すべて削除"),
+    ("Separate Dimensions", "次元を分離"),
+    ("Add Property to Essential Graphics", "エッセンシャルグラフィックスにプロパティを追加"),
+    ("Continuous Bezier", "連続ベジェ"),
+    ("Auto Bezier", "自動ベジェ"),
+    ("Lock To Time", "時間に固定"),
+    ("Rove Across Time", "時間をまたいで移動"),
+    ("Anchor Point", "アンカーポイント"),
+    ("All Transform Properties", "すべてのトランスフォームプロパティ"),
+    ("Animate:", "アニメーター："),
+    ("Add property or selector", "プロパティまたはセレクターを追加"),
+    ("Animate text", "テキストをアニメート"),
+    ("Line Anchor", "ラインアンカー"),
+    ("Line Spacing", "ラインスペース"),
+    ("Character Offset", "文字のオフセット"),
+    ("Character Value", "文字コード"),
+    ("Fill Color: RGB", "塗りのカラー: RGB"),
+    ("Fill Color: Hue", "塗りのカラー: 色相"),
+    ("Fill Color: Saturation", "塗りのカラー: 彩度"),
+    ("Fill Color: Brightness", "塗りのカラー: 明るさ"),
+    ("Fill Color: Opacity", "塗りのカラー: 不透明度"),
+    ("Stroke Color: RGB", "線のカラー: RGB"),
+    ("Stroke Color: Hue", "線のカラー: 色相"),
+    ("Stroke Color: Saturation", "線のカラー: 彩度"),
+    ("Stroke Color: Brightness", "線のカラー: 明るさ"),
+    ("Stroke Color: Opacity", "線のカラー: 不透明度"),
+    ("Stroke Width", "線幅"),
+    ("Front: Color", "前面: 色"),
+    ("Bevel: Color", "ベベル: 色"),
+    ("Side: Color", "側面: 色"),
+    ("Back: Color", "背面: 色"),
+    ("Effect Controls", "エフェクトコントロール"),
+    ("Effects & Presets", "エフェクト＆プリセット"),
+    ("Motion Sketch", "モーションスケッチ"),
+    ("Render Queue", "レンダーキュー"),
+    ("Mask Interpolation", "マスク補間"),
+    ("Script Console", "スクリプトコンソール"),
+    ("Essential Graphics", "エッセンシャルグラフィックス"),
+    ("ScriptUI Panel", "ScriptUIパネル"),
+    ("Lumetri Scopes", "Lumetriスコープ"),
+    ("Media Browser", "メディアブラウザー"),
+    ("Content-Aware Fill", "コンテンツに応じた塗りつぶし"),
+    ("Create Nulls From Paths", "パスからヌルを作成"),
+    ("VR Comp Editor", "VRコンポジションエディター"),
+    ("Media Duration", "メディアの長さ"),
+    ("Frame Rate", "フレームレート"),
+    ("Resolution", "解像度"),
+    ("Overlays", "オーバーレイ"),
+    ("Layer Controls", "レイヤーコントロール"),
+    ("Loop", "ループ"),
+    ("Cache Before Playback", "再生前にキャッシュ"),
+    ("Pre-roll", "プリロール"),
+    ("Post-roll", "ポストロール"),
+    ("If caching, play cached frames", "キャッシュ中はキャッシュ済みフレームを再生"),
+    ("File Path", "ファイルパス"),
+    ("Interpret Footage", "フッテージの解釈"),
+    ("Create a new Folder", "新しいフォルダーを作成"),
+    ("Create a new Composition", "新しいコンポジションを作成"),
+    ("First Frame", "最初のフレーム"),
+    ("Previous Frame", "前のフレーム"),
+    ("Next Frame", "次のフレーム"),
+    ("Last Frame", "最後のフレーム"),
+    ("Name (A–Z)", "名前 (A–Z)"),
+    ("Merged PRs", "マージ済みPR"),
+    ("Lines added", "追加行数"),
+    ("Lines deleted", "削除行数"),
+    ("Line delta", "行数の差分"),
+    ("Binary assets added", "追加バイナリ"),
+    ("Binary assets removed", "削除バイナリ"),
+    ("First commit", "最初のコミット"),
+    ("Last commit", "最後のコミット"),
+    ("Display name", "表示名"),
+    ("Real name", "本名"),
+    ("ArtCraft website", "ArtCraftのウェブサイト"),
+    ("Source code on GitHub", "GitHubのソースコード"),
+    ("3D Renderer", "3Dレンダラー"),
+    ("Black", "黒"),
+    ("White", "白"),
+    ("Composition Settings", "コンポジション設定"),
+    ("Preset Name", "プリセット名"),
+    ("Save Preset…", "プリセットを保存…"),
+    ("Delete Preset", "プリセットを削除"),
+    ("Lock Aspect Ratio", "縦横比を固定"),
+    ("Frame Rate presets", "フレームレートのプリセット"),
+    ("Background Color", "背景色"),
+    ("Basic", "基本"),
+    ("Shutter Angle", "シャッター角度"),
+    ("Shutter Phase", "シャッターフェーズ"),
+    ("Samples Per Frame", "フレームあたりのサンプル数"),
+    ("Adaptive Sample Limit", "適応サンプル数の上限"),
+    ("X and Y", "XとY"),
+    ("X only", "Xのみ"),
+    ("Y only", "Yのみ"),
+    ("Track Camera", "カメラをトラッキング"),
+    ("Warp Stabilizer", "ワープスタビライザー"),
+    ("Track Motion", "モーションをトラッキング"),
+    ("Stabilize Motion", "モーションを安定化"),
+    ("Motion Source:", "モーションソース:"),
+    ("Current Track:", "現在のトラック:"),
+    ("Track Type:", "トラックの種類:"),
+    ("Motion Target:", "モーションの適用先:"),
+    ("Track Mask:", "トラックマスク:"),
+    ("Analyze forward", "前方を解析"),
+    ("Analyze backward", "後方を解析"),
+    ("Continue Tracking", "トラッキングを続行"),
+    ("Stop Tracking", "トラッキングを停止"),
+    ("Adapt Feature", "特徴を適応"),
+    ("Extrapolate Motion", "モーションを外挿"),
+    ("Attach Point", "アタッチポイント"),
+    ("Track Name", "トラック名"),
+    ("Motion Tracker Options", "モーショントラッカーのオプション"),
+    ("Motion Tracker Apply Options", "モーショントラッカーの適用オプション"),
+    ("Edit Value Graph", "値グラフを編集"),
+    ("Edit Speed Graph", "速度グラフを編集"),
+    ("Show Reference Graph", "参照グラフを表示"),
+    (
+        "Auto-Select Graph Type (speed graph for spatial properties, else value graph)",
+        "グラフの種類を自動選択 (空間プロパティは速度グラフ、それ以外は値グラフ)",
+    ),
+    ("Auto-zoom graph height", "グラフの高さを自動ズーム"),
+    ("Fit all graphs to view", "すべてのグラフをビューに合わせる"),
+    ("Fit selection to view", "選択項目をビューに合わせる"),
+    ("Snap (key drags snap to the current time and other keys)", "スナップ (キーのドラッグを現在の時間や他のキーに合わせる)"),
+    ("Show Transform Box when multiple keys are selected", "複数のキーを選択したときにトランスフォームボックスを表示"),
+    ("Separate Dimensions (Position)", "次元を分離 (位置)"),
+    ("Convert selected keyframes to Hold", "選択したキーフレームをホールドに変換"),
+    ("Convert selected keyframes to Linear", "選択したキーフレームをリニアに変換"),
+    ("Convert selected keyframes to Auto Bezier", "選択したキーフレームを自動ベジェに変換"),
+    ("Easy Ease (F9)", "イージーイーズ (F9)"),
+    ("Easy Ease In (Shift+F9)", "イージーイーズイン (Shift+F9)"),
+    ("Easy Ease Out (Ctrl+Shift+F9)", "イージーイーズアウト (Ctrl+Shift+F9)"),
+    ("Spatial Path", "空間パス"),
+    ("Temporal Path", "時間パス"),
+    ("All the Same", "すべて同じ"),
+    ("All Independently", "すべて個別"),
+    ("Noise Type:", "ノイズの種類:"),
+    ("Apply To:", "適用先:"),
+    ("Temporal Graph", "時間グラフ"),
+    ("Keyframe Rate:", "キーフレームレート:"),
+    ("Capture speed at:", "速度の記録位置:"),
+    ("Start Capture", "記録を開始"),
+    ("Cancel Capture", "記録をキャンセル"),
+    ("Small Caps", "スモールキャップ"),
+    ("All Small Caps", "すべてスモールキャップ"),
+    ("Superscript / Superior", "上付き文字"),
+    ("Subscript / Inferior", "下付き文字"),
+    ("Standard Ligatures", "標準合字"),
+    ("Discretionary Ligatures", "任意合字"),
+    ("Contextual Alternates", "状況依存の代替字形"),
+    ("Stylistic Alternates", "スタイル代替字形"),
+    ("Titling Alternates", "タイトル用代替字形"),
+    ("Default Figure Style", "既定の数字スタイル"),
+    ("Tabular Lining", "等幅ライニング"),
+    ("Proportional Oldstyle", "プロポーショナルオールドスタイル"),
+    ("Proportional Lining", "プロポーショナルライニング"),
+    ("Tabular Oldstyle", "等幅オールドスタイル"),
+    ("Fill Over Stroke", "線の上に塗り"),
+    ("Stroke Over Fill", "塗りの上に線"),
+    ("Stroke order", "線の順序"),
+    ("Single-line Composer", "単一行コンポーザー"),
+    ("Every-line Composer", "全行コンポーザー"),
+    ("Text direction", "テキストの方向"),
+    ("Recently Used", "最近使用した項目"),
+    ("User Presets", "ユーザープリセット"),
+    ("Remove from Favorites", "お気に入りから削除"),
+    ("Show Animation Presets", "アニメーションプリセットを表示"),
+    ("    Refresh List", "    リストを更新"),
+    ("    Clear Recently Used", "    最近使用した項目を消去"),
+    ("Show 32 bpc Effects Only", "32 bpcのエフェクトのみ表示"),
+    ("Show GPU Accelerated Effects Only", "GPUアクセラレーションのエフェクトのみ表示"),
+    ("Show Effects for All Color Depths", "すべての色深度のエフェクトを表示"),
+    ("* Animation Presets", "* アニメーションプリセット"),
+    ("Select a layer to apply to", "適用するレイヤーを選択してください"),
+    ("Search effects and presets", "エフェクトとプリセットを検索"),
+    ("Building waveform…", "波形を生成中…"),
+    ("No effects. Drag one from Effects & Presets.", "エフェクトがありません。エフェクト&プリセットからドラッグしてください。"),
+    (
+        "Click the ring to add a colour; Alt-click a stop (or drag it off) to remove it",
+        "リングをクリックするとカラーを追加します。Altを押しながらストップをクリック（または外へドラッグ）すると削除します",
+    ),
+    (
+        "Start from a ready-made project. Opening a template makes an untitled copy.",
+        "既成のプロジェクトから開始します。テンプレートを開くと無題のコピーが作成されます。",
+    ),
+    ("Square Pixels", "スクエアピクセル"),
+    ("Alpha Expansion:", "アルファの拡張:"),
+    ("Fill Method:", "塗りの方法:"),
+    ("Edge Blend", "エッジのブレンド"),
+    ("Entire Duration", "全体のデュレーション"),
+    ("Reference Frame:", "参照フレーム:"),
+    ("Use Current Time", "現在の時間を使用"),
+    ("Generate Fill Layer", "塗りレイヤーを生成"),
+    ("Lighting Correction:", "ライティングの補正:"),
+    ("Create Text and Camera", "テキストとカメラを作成"),
+    ("Create Solid and Camera", "平面とカメラを作成"),
+    ("Create Null and Camera", "ヌルとカメラを作成"),
+    ("Create Shadow Catcher, Camera and Light", "シャドウキャッチャー、カメラ、ライトを作成"),
+    ("Unable to solve camera", "カメラを解析できません"),
+    ("Waiting to solve", "解析待ち"),
+    ("Create Camera", "カメラを作成"),
+    ("track point", "トラックポイント"),
+    ("Ruler zero point", "ルーラーの原点"),
+    ("Vertical ruler", "垂直ルーラー"),
+    ("Horizontal ruler", "水平ルーラー"),
+    ("Viewer controls", "ビューアーのコントロール"),
+    ("Resolution/Down Sample Factor", "解像度/ダウンサンプル係数"),
+    ("Adjust Exposure", "露出を調整"),
+    ("Snapshot taken", "スナップショットを撮影しました"),
+    ("Fast Previews", "高速プレビュー"),
+    ("3D View", "3Dビュー"),
+    ("Current time", "現在の時間"),
+    ("Layer Transform", "レイヤーのトランスフォーム"),
+    ("Reset Transform", "トランスフォームをリセット"),
+    ("Text Animation", "テキストアニメーション"),
+    ("Text Animation Presets", "テキストアニメーションのプリセット"),
+    ("EffectCraft on getartcraft.com", "getartcraft.com の EffectCraft"),
+    ("Small Screen", "小さい画面"),
+    ("Tool Creates Shape", "ツールでシェイプを作成"),
+    ("Tool Creates Mask", "ツールでマスクを作成"),
+    ("Blend Mode", "描画モード"),
+    ("Show mesh", "メッシュを表示"),
+    ("Record Options...", "記録オプション..."),
+    ("Apply", "適用"),
+    ("Analyze", "分析"),
+    ("Add Point", "ポイントを追加"),
+    ("Remove Point", "ポイントを削除"),
+    ("Render", "レンダリング"),
+    ("Save Current as Template…", "テンプレートとして保存…"),
+    ("New Composition From Footage", "フッテージから新規コンポジション"),
+    ("Search project", "プロジェクトを検索"),
+    ("Search", "検索"),
+    ("(no composition)", "（コンポジションなし）"),
+    ("per second", "毎秒"),
+    ("Waveform", "波形"),
+    ("steps", "ステップ"),
 ];
 
 const SIMPLIFIED_CHINESE: &[(&str, &str)] = &[
+    ("Click to sample color", "单击以取样颜色"),
     ("Appearance Settings…", "外观设置…"),
     ("Add to favorites", "添加到收藏"),
     ("Remove from favorites", "从收藏中移除"),
@@ -937,6 +1342,7 @@ const SIMPLIFIED_CHINESE: &[(&str, &str)] = &[
     ("Add:", "添加："),
     ("Adjust Exposure (stops)", "调整曝光（光圈级数）"),
     ("Adjust composition duration to the time span of the selected layers", "将合成时长调整为所选图层的时间范围"),
+    ("Advanced", "高级"),
     ("Advanced 3D", "高级 3D"),
     ("Align Layers to:", "将图层对齐到："),
     ("All six face cameras turn together; the scene is not changed.", "六个面摄像机一起旋转；场景不会改变。"),
@@ -1039,7 +1445,6 @@ const SIMPLIFIED_CHINESE: &[(&str, &str)] = &[
     ("Duration:", "持续时间："),
     ("Edit Gradient…", "编辑渐变…"),
     ("Edit Target: {}", "编辑目标：{}"),
-    ("Edit in the Timeline", "在时间轴中编辑"),
     ("EffectCraft didn't quit normally last time.", "EffectCraft 上次未正常退出。"),
     ("Effects", "效果"),
     ("Effects & Presets options", "效果和预设选项"),
@@ -1166,6 +1571,7 @@ const SIMPLIFIED_CHINESE: &[(&str, &str)] = &[
     ("No layer selected", "未选择图层"),
     ("No matching effects or presets", "没有匹配的效果或预设"),
     ("No matching fonts", "没有匹配的字体"),
+    ("Rescan Fonts", "重新扫描字体"),
     ("Variable fonts only", "仅可变字体"),
     ("No model credits were built into this copy.", "此副本未内置模型致谢。"),
     ("No nested compositions", "没有嵌套合成"),
@@ -1199,7 +1605,9 @@ const SIMPLIFIED_CHINESE: &[(&str, &str)] = &[
     ("Overlay", "叠加"),
     ("Parameter Name:", "参数名称："),
     ("Parent pick whip: drag onto a layer", "父级拾取器：拖到图层上"),
+    ("Track Matte pick whip: drag onto a layer", "轨道遮罩拾取器：拖到图层上"),
     ("Pixel Aspect Ratio:", "像素长宽比："),
+    ("Play/Stop", "播放/停止"),
     ("Playing on Video Preview", "在视频预览中播放"),
     ("Post-Render Action: {}", "渲染后动作：{}"),
     ("Preserve frame rate when nested or in render queue", "嵌套或在渲染队列中时保留帧速率"),
@@ -1641,9 +2049,1631 @@ const SIMPLIFIED_CHINESE: &[(&str, &str)] = &[
     ("Total Offset", "总偏移"),
     ("Per Layer", "每个图层"),
     ("Track", "跟踪"),
+    ("Selection Tool", "选择工具"),
+    ("Hand Tool", "抓手工具"),
+    ("Zoom Tool", "缩放工具"),
+    ("Orbit Around Cursor Tool", "绕行摄像机工具"),
+    ("Pan Under Cursor Tool", "平移摄像机工具"),
+    ("Dolly Towards Cursor Tool", "推拉摄像机工具"),
+    ("Rotation Tool", "旋转工具"),
+    ("Pan Behind (Anchor Point) Tool", "向后平移工具"),
+    ("Rectangle Tool", "矩形工具"),
+    ("Rounded Rectangle Tool", "圆角矩形工具"),
+    ("Ellipse Tool", "椭圆工具"),
+    ("Polygon Tool", "多边形工具"),
+    ("Star Tool", "星形工具"),
+    ("Pen Tool", "钢笔工具"),
+    ("Add Vertex Tool", "添加顶点工具"),
+    ("Delete Vertex Tool", "删除顶点工具"),
+    ("Convert Vertex Tool", "转换顶点工具"),
+    ("Mask Feather Tool", "蒙版羽化工具"),
+    ("Horizontal Type Tool", "横排文字工具"),
+    ("Vertical Type Tool", "直排文字工具"),
+    ("Brush Tool", "画笔工具"),
+    ("Clone Stamp Tool", "仿制图章工具"),
+    ("Eraser Tool", "橡皮擦工具"),
+    ("Roto Brush Tool", "Roto 笔刷工具"),
+    ("Refine Edge Tool", "调整边缘工具"),
+    ("Object Matte Tool", "对象遮罩工具"),
+    ("Puppet Position Pin Tool", "人偶位置控点工具"),
+    ("Puppet Starch Pin Tool", "人偶扑粉控点工具"),
+    ("Puppet Bend Pin Tool", "人偶弯曲控点工具"),
+    ("Puppet Advanced Pin Tool", "人偶高级控点工具"),
+    ("Puppet Overlap Pin Tool", "人偶重叠控点工具"),
+    ("Shortcut", "快捷键"),
+    ("Range", "范围"),
+    ("Play From", "从以下位置播放"),
+    ("Frame Rate", "帧速率"),
+    ("Resolution", "分辨率"),
+    ("Overlays", "叠加"),
+    ("Layer Controls", "图层控制"),
+    ("Loop", "循环"),
+    ("Cache Before Playback", "播放前缓存"),
+    ("Pre-roll", "预卷"),
+    ("Post-roll", "后卷"),
+    ("If caching, play cached frames", "缓存时播放已缓存帧"),
+    ("Apply", "应用"),
+    ("Analyze", "分析"),
+    ("Create Camera", "创建摄像机"),
+    ("Add Point", "添加点"),
+    ("Remove Point", "移除点"),
+    ("Render", "渲染"),
+    ("Save Current as Template…", "将当前项存为模板…"),
+    ("New Composition From Footage", "从素材新建合成"),
+    ("Search effects and presets", "搜索效果和预设"),
+    ("Search project", "搜索项目"),
+    ("Search", "搜索"),
+    ("(no composition)", "没有合成"),
+    ("per second", "每秒"),
+    ("Waveform", "波形"),
+    ("steps", "步"),
+    ("Building waveform…", "正在生成波形…"),
+    ("No effects. Drag one from Effects & Presets.", "没有效果。从效果和预设中拖入一个。"),
+    ("Click the ring to add a colour; Alt-click a stop (or drag it off) to remove it", "点击色环添加颜色；按住 Alt 点击色标（或将其拖出）可移除"),
+    ("Start from a ready-made project. Opening a template makes an untitled copy.", "从现成项目开始。打开模板会创建一份未命名副本。"),
+    ("Square Pixels", "方形像素"),
+    ("Basic", "基本"),
+    ("3D Renderer", "3D 渲染器"),
+    ("Black", "黑色"),
+    ("White", "白色"),
+    ("Composition Settings", "合成设置"),
+    ("Force alphabetical order", "强制按字母顺序"),
+    ("Frame rate (fps)", "帧速率 (fps)"),
+    ("Import Kind", "导入类型"),
+    ("Delay (s)", "延迟 (秒)"),
+    ("Amount (%)", "数量 (%)"),
+    ("Cascade (farther pins trail longer)", "级联 (越远的图钉滞后越长)"),
+    ("Speed (%)", "速度 (%)"),
+    ("Use Draft Deformation", "使用草稿变形"),
+    ("Show Mesh", "显示网格"),
+    ("Scale X (%)", "X 缩放 (%)"),
+    ("Scale Y (%)", "Y 缩放 (%)"),
+    ("Rotation (degrees)", "旋转 (度)"),
+    ("Move X", "移动 X"),
+    ("Move Y", "移动 Y"),
+    ("Position (pixels)", "位置 (像素)"),
+    ("Position (percent of the composition)", "位置 (合成百分比)"),
+    ("Use Dimensions From", "尺寸来源"),
+    ("Still Duration (seconds)", "静止图像持续时间 (秒)"),
+    ("Add to Render Queue", "添加到渲染队列"),
+    ("Sequence Layers", "序列图层"),
+    ("Duration (seconds)", "持续时间 (秒)"),
+    ("Matte color (premultiplied)", "遮罩颜色 (预乘)"),
+    ("Invert Alpha", "反转 Alpha"),
+    ("Assume this frame rate", "按此帧速率处理"),
+    ("Separate Fields", "分离场"),
+    ("Pixel Aspect Ratio", "像素长宽比"),
+    ("Loop (times)", "循环 (次)"),
+    ("Assign Profile", "指定配置文件"),
+    ("Preserve RGB", "保留 RGB"),
+    ("Interpret As Linear Light", "解释为线性光"),
+    ("Start Timecode", "开始时间码"),
+    ("Override Start", "覆盖开始"),
+    ("Time display style", "时间显示样式"),
+    ("Color engine", "颜色引擎"),
+    ("Working space", "工作空间"),
+    ("Working gamma", "工作伽马"),
+    ("Linearize working space", "线性化工作空间"),
+    ("Blend colors using 1.0 gamma", "使用 1.0 伽马混合颜色"),
+    ("Output color space", "输出颜色空间"),
+    ("Video rendering and effects", "视频渲染与效果"),
+    ("Time Span", "时间范围"),
+    ("Blur (pixels before auto-trace)", "模糊 (自动描摹前的像素)"),
+    ("Tolerance (pixels)", "容差 (像素)"),
+    ("Threshold (%)", "阈值 (%)"),
+    ("Minimum Area (pixels)", "最小区域 (像素)"),
+    ("Corner Roundness (%)", "角圆度 (%)"),
+    ("Apply To New Layer", "应用到新图层"),
+    ("Sensitivity threshold (0–1, lower finds more)", "灵敏度阈值 (0–1，越低找到的越多)"),
+    ("Time field (empty: automatic)", "时间字段 (为空: 自动)"),
+    ("Video start (ISO date-time, hh:mm:ss, timecode; empty: file date)", "视频开始 (ISO 日期时间、hh:mm:ss、时间码；为空: 文件日期)"),
+    ("First sample at (comp seconds)", "首个采样位置 (合成秒)"),
+    ("Frame rate", "帧速率"),
+    ("Color (#rrggbb)", "颜色 (#rrggbb)"),
+    ("Embed footage files", "嵌入素材文件"),
+    ("Embed up to (MB)", "嵌入上限 (MB)"),
+    ("Orient Along Path", "沿路径定向"),
+    ("Orient Towards Camera", "朝向摄像机"),
+    ("Orient Towards Point of Interest", "朝向目标点"),
+    ("Single Composition", "单个合成"),
+    ("Multiple Compositions", "多个合成"),
+    ("Dissolve Front Layer", "溶解前层"),
+    ("Cross Dissolve Front and Back Layers", "交叉溶解前后层"),
+    ("Interpret Straight - Unmatted", "解释为直接 (未遮罩)"),
+    ("Interpret Premultiplied - Matted With Color", "解释为预乘 (以颜色遮罩)"),
+    ("Upper Field First", "上场优先"),
+    ("Lower Field First", "下场优先"),
+    ("Rec. 2020", "Rec. 2020"),
+    ("Use Source File Timecode", "使用源文件时间码"),
+    ("Feet + Frames (35mm)", "英尺 + 帧 (35mm)"),
+    ("Feet + Frames (16mm)", "英尺 + 帧 (16mm)"),
+    ("Current Frame", "当前帧"),
+    ("Work Area", "工作区域"),
+    ("Create Markers", "创建标记"),
+    ("Split Layers", "拆分图层"),
+    ("Split and Precompose", "拆分并预合成"),
+    ("All layers", "所有图层"),
+    ("None (leave them out)", "无 (不含)"),
+    ("Nested sequences", "嵌套序列"),
+    ("Solid…", "纯色…"),
+    ("Light…", "灯光…"),
+    ("Camera…", "摄像机…"),
+    ("Null Object", "空对象"),
+    ("Shape Layer", "形状图层"),
+    ("Adjustment Layer", "调整图层"),
+    ("Layer Settings…", "图层设置…"),
+    ("Create Shapes from Vector Layer", "从矢量图层创建形状"),
+    ("Create Shapes from Text", "从文本创建形状"),
+    ("Create Masks from Text", "从文本创建遮罩"),
+    ("New Mask", "新建遮罩"),
+    ("Center In View", "在视图中居中"),
+    ("Fit to Comp", "适应合成"),
+    ("Flip Horizontal", "水平翻转"),
+    ("Flip Vertical", "垂直翻转"),
+    ("Enable Time Remapping", "启用时间重映射"),
+    ("Time-Reverse Layer", "时间反向图层"),
+    ("Freeze Frame", "冻结帧"),
+    ("Freeze On Last Frame", "在最后一帧冻结"),
+    ("Add Marker", "添加标记"),
+    ("Bring Layer to Front", "图层置顶"),
+    ("Bring Layer Forward", "图层上移一层"),
+    ("Send Layer Backward", "图层下移一层"),
+    ("Send Layer to Back", "图层置底"),
+    ("Pre-compose…", "预合成…"),
+    ("Split Layer", "拆分图层"),
+    ("Layer Style Options...", "图层样式选项..."),
+    ("Convert to Editable Styles", "转换为可编辑样式"),
+    ("Show All", "全部显示"),
+    ("Remove All", "全部移除"),
+    ("Separate Dimensions", "分离维度"),
+    ("Add Property to Essential Graphics", "将属性添加到基本图形"),
+    ("Continuous Bezier", "连续贝塞尔"),
+    ("Auto Bezier", "自动贝塞尔"),
+    ("Lock To Time", "锁定到时间"),
+    ("Rove Across Time", "跨时间漫游"),
+    ("Anchor Point", "锚点"),
+    ("All Transform Properties", "所有变换属性"),
+    ("Line Anchor", "行锚点"),
+    ("Line Spacing", "行距"),
+    ("Character Offset", "字符偏移"),
+    ("Character Value", "字符值"),
+    ("Fill Color: RGB", "填充颜色: RGB"),
+    ("Fill Color: Hue", "填充颜色: 色相"),
+    ("Fill Color: Saturation", "填充颜色: 饱和度"),
+    ("Fill Color: Brightness", "填充颜色: 亮度"),
+    ("Fill Color: Opacity", "填充颜色: 不透明度"),
+    ("Stroke Color: RGB", "描边颜色: RGB"),
+    ("Stroke Color: Hue", "描边颜色: 色相"),
+    ("Stroke Color: Saturation", "描边颜色: 饱和度"),
+    ("Stroke Color: Brightness", "描边颜色: 亮度"),
+    ("Stroke Color: Opacity", "描边颜色: 不透明度"),
+    ("Stroke Width", "描边宽度"),
+    ("Front: Color", "前面: 颜色"),
+    ("Bevel: Color", "斜面: 颜色"),
+    ("Side: Color", "侧面: 颜色"),
+    ("Back: Color", "背面: 颜色"),
+    ("Effect Controls", "效果控件"),
+    ("Effects & Presets", "效果和预设"),
+    ("Motion Sketch", "运动草图"),
+    ("Render Queue", "渲染队列"),
+    ("Mask Interpolation", "遮罩插值"),
+    ("Script Console", "脚本控制台"),
+    ("Essential Graphics", "基本图形"),
+    ("ScriptUI Panel", "ScriptUI 面板"),
+    ("Lumetri Scopes", "Lumetri 示波器"),
+    ("Media Browser", "媒体浏览器"),
+    ("Content-Aware Fill", "内容识别填充"),
+    ("Create Nulls From Paths", "从路径创建空对象"),
+    ("VR Comp Editor", "VR 合成编辑器"),
+    ("Media Duration", "媒体持续时间"),
+    ("File Path", "文件路径"),
+    ("Interpret Footage", "解释素材"),
+    ("Create a new Folder", "新建文件夹"),
+    ("Create a new Composition", "新建合成"),
+    ("First Frame", "第一帧"),
+    ("Previous Frame", "上一帧"),
+    ("Next Frame", "下一帧"),
+    ("Last Frame", "最后一帧"),
+    ("Name (A–Z)", "名称 (A–Z)"),
+    ("Merged PRs", "已合并 PR"),
+    ("Lines added", "添加的行数"),
+    ("Lines deleted", "删除的行数"),
+    ("Line delta", "行数差异"),
+    ("Binary assets added", "添加的二进制资源"),
+    ("Binary assets removed", "删除的二进制资源"),
+    ("First commit", "首次提交"),
+    ("Last commit", "最近提交"),
+    ("Display name", "显示名称"),
+    ("Real name", "真实姓名"),
+    ("ArtCraft website", "ArtCraft 网站"),
+    ("Source code on GitHub", "GitHub 上的源代码"),
+    ("Preset Name", "预设名称"),
+    ("Save Preset…", "保存预设…"),
+    ("Delete Preset", "删除预设"),
+    ("Lock Aspect Ratio", "锁定长宽比"),
+    ("Frame Rate presets", "帧速率预设"),
+    ("Background Color", "背景颜色"),
+    ("Shutter Angle", "快门角度"),
+    ("Shutter Phase", "快门相位"),
+    ("Samples Per Frame", "每帧采样数"),
+    ("Adaptive Sample Limit", "自适应采样上限"),
+    ("X and Y", "X 和 Y"),
+    ("X only", "仅 X"),
+    ("Y only", "仅 Y"),
+    ("Track Camera", "跟踪摄像机"),
+    ("Warp Stabilizer", "变形稳定器"),
+    ("Track Motion", "跟踪运动"),
+    ("Stabilize Motion", "稳定运动"),
+    ("Motion Source:", "运动源:"),
+    ("Current Track:", "当前跟踪:"),
+    ("Track Type:", "跟踪类型:"),
+    ("Motion Target:", "运动目标:"),
+    ("Track Mask:", "跟踪遮罩:"),
+    ("Analyze forward", "向前分析"),
+    ("Analyze backward", "向后分析"),
+    ("Continue Tracking", "继续跟踪"),
+    ("Stop Tracking", "停止跟踪"),
+    ("Adapt Feature", "自适应特征"),
+    ("Extrapolate Motion", "外推运动"),
+    ("Attach Point", "附加点"),
+    ("Track Name", "跟踪名称"),
+    ("Motion Tracker Options", "运动跟踪器选项"),
+    ("Motion Tracker Apply Options", "运动跟踪器应用选项"),
+    ("Edit Value Graph", "编辑值图表"),
+    ("Edit Speed Graph", "编辑速度图表"),
+    ("Show Reference Graph", "显示参考图表"),
+    ("Auto-Select Graph Type (speed graph for spatial properties, else value graph)", "自动选择图表类型 (空间属性用速度图表，否则用值图表)"),
+    ("Auto-zoom graph height", "自动缩放图表高度"),
+    ("Fit all graphs to view", "使所有图表适合视图"),
+    ("Fit selection to view", "使所选内容适合视图"),
+    ("Snap (key drags snap to the current time and other keys)", "吸附 (关键帧拖动时吸附到当前时间和其他关键帧)"),
+    ("Show Transform Box when multiple keys are selected", "选择多个关键帧时显示变换框"),
+    ("Separate Dimensions (Position)", "分离维度 (位置)"),
+    ("Convert selected keyframes to Hold", "将所选关键帧转换为定格"),
+    ("Convert selected keyframes to Linear", "将所选关键帧转换为线性"),
+    ("Convert selected keyframes to Auto Bezier", "将所选关键帧转换为自动贝塞尔"),
+    ("Easy Ease (F9)", "缓动 (F9)"),
+    ("Easy Ease In (Shift+F9)", "缓入 (Shift+F9)"),
+    ("Easy Ease Out (Ctrl+Shift+F9)", "缓出 (Ctrl+Shift+F9)"),
+    ("Spatial Path", "空间路径"),
+    ("Temporal Path", "时间路径"),
+    ("All the Same", "全部相同"),
+    ("All Independently", "全部独立"),
+    ("Noise Type:", "噪波类型:"),
+    ("Apply To:", "应用到:"),
+    ("Temporal Graph", "时间图表"),
+    ("Keyframe Rate:", "关键帧速率:"),
+    ("Capture speed at:", "速度捕获位置:"),
+    ("Start Capture", "开始捕获"),
+    ("Cancel Capture", "取消捕获"),
+    ("Small Caps", "小型大写字母"),
+    ("All Small Caps", "全部小型大写字母"),
+    ("Superscript / Superior", "上标"),
+    ("Subscript / Inferior", "下标"),
+    ("Standard Ligatures", "标准连字"),
+    ("Discretionary Ligatures", "可选连字"),
+    ("Contextual Alternates", "上下文替换"),
+    ("Stylistic Alternates", "样式替换"),
+    ("Titling Alternates", "标题替换"),
+    ("Default Figure Style", "默认数字样式"),
+    ("Tabular Lining", "等宽线条"),
+    ("Proportional Oldstyle", "比例旧式"),
+    ("Proportional Lining", "比例线条"),
+    ("Tabular Oldstyle", "等宽旧式"),
+    ("Fill Over Stroke", "填充在描边之上"),
+    ("Stroke Over Fill", "描边在填充之上"),
+    ("Stroke order", "描边顺序"),
+    ("Single-line Composer", "单行书写器"),
+    ("Every-line Composer", "逐行书写器"),
+    ("Text direction", "文本方向"),
+    ("Recently Used", "最近使用"),
+    ("User Presets", "用户预设"),
+    ("Remove from Favorites", "从收藏夹移除"),
+    ("Show Animation Presets", "显示动画预设"),
+    ("    Refresh List", "    刷新列表"),
+    ("    Clear Recently Used", "    清除最近使用"),
+    ("Show 32 bpc Effects Only", "仅显示 32 bpc 效果"),
+    ("Show GPU Accelerated Effects Only", "仅显示 GPU 加速效果"),
+    ("Show Effects for All Color Depths", "显示所有颜色深度的效果"),
+    ("* Animation Presets", "* 动画预设"),
+    ("Select a layer to apply to", "请选择要应用到的图层"),
+    ("Alpha Expansion:", "Alpha 扩展:"),
+    ("Fill Method:", "填充方式:"),
+    ("Edge Blend", "边缘混合"),
+    ("Entire Duration", "整个持续时间"),
+    ("Reference Frame:", "参考帧:"),
+    ("Use Current Time", "使用当前时间"),
+    ("Generate Fill Layer", "生成填充图层"),
+    ("Lighting Correction:", "光照校正:"),
+    ("Create Text and Camera", "创建文本和摄像机"),
+    ("Create Solid and Camera", "创建纯色和摄像机"),
+    ("Create Null and Camera", "创建空对象和摄像机"),
+    ("Create Shadow Catcher, Camera and Light", "创建阴影捕捉器、摄像机和灯光"),
+    ("Unable to solve camera", "无法求解摄像机"),
+    ("Waiting to solve", "等待求解"),
+    ("track point", "跟踪点"),
+    ("Ruler zero point", "标尺零点"),
+    ("Vertical ruler", "垂直标尺"),
+    ("Horizontal ruler", "水平标尺"),
+    ("Viewer controls", "查看器控件"),
+    ("Resolution/Down Sample Factor", "分辨率/降采样系数"),
+    ("Adjust Exposure", "调整曝光"),
+    ("Snapshot taken", "已拍摄快照"),
+    ("Fast Previews", "快速预览"),
+    ("3D View", "3D 视图"),
+    ("Current time", "当前时间"),
+    ("Layer Transform", "图层变换"),
+    ("Reset Transform", "重置变换"),
+    ("Text Animation", "文本动画"),
+    ("Text Animation Presets", "文本动画预设"),
+    ("EffectCraft on getartcraft.com", "getartcraft.com 上的 EffectCraft"),
+    ("Small Screen", "小屏幕"),
+    ("Tool Creates Shape", "工具创建形状"),
+    ("Tool Creates Mask", "工具创建遮罩"),
+    ("Blend Mode", "混合模式"),
+    ("Show mesh", "显示网格"),
+    ("Record Options...", "记录选项..."),
+];
+
+/// Swedish (`sv`), written from the English source.
+const SWEDISH: &[(&str, &str)] = &[
+    ("Appearance Settings…", "Utseendeinställningar…"),
+    ("Add to favorites", "Lägg till i favoriter"),
+    ("Remove from favorites", "Ta bort från favoriter"),
+    ("   OK   ", "   OK   "),
+    ("  Delete  ", "  Radera  "),
+    (" Open Auto-Save ", " Öppna autosparad fil "),
+    ("(missing)", "(saknas)"),
+    ("360 View Orientation", "Orientering för 360-vy"),
+    ("3:2 Pulldown: {}", "3:2-pulldown: {}"),
+    (
+        "A clean-room, open-source compositor for motion graphics and visual effects: native on macOS, Windows and Linux, and in the browser. Part of the ArtCraft family of creative apps.",
+        "En clean room-utvecklad kompositör med öppen källkod för rörlig grafik och visuella effekter: inbyggd på macOS, Windows och Linux samt i webbläsaren. Del av ArtCraft-familjen av kreativa program.",
+    ),
+    ("About EffectCraft", "Om EffectCraft"),
+    ("About...", "Om..."),
+    ("Active", "Aktiv"),
+    ("Active Camera", "Aktiv kamera"),
+    ("Alpha", "Alfa"),
+    ("Adapt Feature On Every Frame", "Anpassa spårdetalj i varje bildruta"),
+    ("Adaptive Sample Limit:", "Gräns för adaptiva sampel:"),
+    ("Add Animator", "Lägg till animerare"),
+    ("Add Comment", "Lägg till kommentar"),
+    ("Add Formatting", "Lägg till formatering"),
+    ("Add Group", "Lägg till grupp"),
+    ("Add Mirror", "Lägg till spegel"),
+    ("Add Selected As", "Lägg till markerade som"),
+    ("Add a comment", "Lägg till en kommentar"),
+    ("Add a shape, fill, stroke or path operation", "Lägg till en form, fyllning, kontur eller banoperation"),
+    ("Add to Composition", "Lägg till i komposition"),
+    ("Add to Favorites", "Lägg till i favoriter"),
+    ("Add:", "Lägg till:"),
+    ("Adjust Exposure (stops)", "Justera exponering (stopp)"),
+    ("Adjust composition duration to the time span of the selected layers", "Anpassa kompositionens längd till de markerade lagrens tidsspann"),
+    ("Advanced 3D", "Avancerad 3D"),
+    ("Align Layers to:", "Justera lager mot:"),
+    ("All six face cameras turn together; the scene is not changed.", "Alla sex sidokameror vrids tillsammans; scenen ändras inte."),
+    ("Anchor:", "Ankare:"),
+    ("Aperture", "Bländare"),
+    ("Appearance Mode", "Utseendeläge"),
+    ("Appearance Mode: {}", "Utseendeläge: {}"),
+    ("Apply Dimensions:", "Använd dimensioner:"),
+    ("Apply Motion To:", "Använd rörelse på:"),
+    ("Arrange", "Ordna"),
+    ("Assign", "Tilldela"),
+    ("Auto", "Auto"),
+    ("Auto-saves", "Automatiska sparningar"),
+    ("Back", "Tillbaka"),
+    ("Background Color:", "Bakgrundsfärg:"),
+    ("Blend Mode:", "Blandningsläge:"),
+    ("Blending Mode", "Blandningsläge"),
+    ("Blur", "Oskärpa"),
+    ("Blur Level", "Oskärpenivå"),
+    ("Boundary", "Gräns"),
+    ("Browser Storage", "Webbläsarlagring"),
+    ("Browse…", "Bläddra…"),
+    ("Brush Dynamics", "Penseldynamik"),
+    ("Caching frames…", "Cachelagrar bildrutor…"),
+    ("Cancel", "Avbryt"),
+    ("Casts Shadows", "Kastar skuggor"),
+    ("Change Renderer…", "Byt renderare…"),
+    (
+        "Changing a shortcut creates a custom preset; the default stays as it is.",
+        "Om du ändrar ett kortkommando skapas en anpassad förinställning; standardinställningen förblir som den är.",
+    ),
+    ("Channel", "Kanal"),
+    ("Channel:", "Kanal:"),
+    ("Chapter:", "Kapitel:"),
+    ("Choose...", "Välj..."),
+    ("Classic 3D", "Klassisk 3D"),
+    ("Clear", "Rensa"),
+    ("Clear list", "Rensa listan"),
+    ("Click a key to see its commands.", "Klicka på en tangent för att se dess kommandon."),
+    (
+        "Click above the bar to add an opacity stop, below it to add a color stop.",
+        "Klicka ovanför fältet för att lägga till ett opacitetsstopp och under det för att lägga till ett färgstopp.",
+    ),
+    ("Click adds a point (½ height = no change)", "Klicka för att lägga till en punkt (½ höjd = ingen ändring)"),
+    ("Click adds a point; drag one off to remove", "Klicka för att lägga till en punkt; dra ut en punkt för att ta bort den"),
+    ("Click to make this viewer active", "Klicka för att göra den här visningen aktiv"),
+    ("Click to reveal the expression in the timeline", "Klicka för att visa uttrycket i tidslinjen"),
+    ("Click to show the active composition here", "Klicka för att visa den aktiva kompositionen här"),
+    ("Click, then click in the Composition panel", "Klicka och klicka sedan i panelen Komposition"),
+    ("Clone Options", "Klonalternativ"),
+    ("Clone Source Overlay:", "Överlägg för klonkälla:"),
+    ("Close", "Stäng"),
+    ("Close Panel", "Stäng panel"),
+    ("Close tutorial", "Stäng självstudien"),
+    ("Color", "Färg"),
+    ("Color Depth: {}", "Färgdjup: {}"),
+    ("Color:", "Färg:"),
+    ("Colour map", "Färgkarta"),
+    ("Columns", "Kolumner"),
+    ("Comment:", "Kommentar:"),
+    ("Community", "Gemenskap"),
+    ("Composition", "Komposition"),
+    ("Composition Mini-Flowchart", "Kompositionens miniflödesschema"),
+    ("Composition Name:", "Kompositionsnamn:"),
+    ("Composition Settings ▸ 3D Renderer", "Kompositionsinställningar ▸ 3D-renderare"),
+    ("Composition Settings…", "Kompositionsinställningar…"),
+    ("Composition marker bin: drag a marker to the time ruler", "Kompositionens markörbin: dra en markör till tidslinjalen"),
+    ("Cone Angle", "Konvinkel"),
+    ("Cone Feather", "Konfjädring"),
+    ("Constrain Proportions", "Behåll proportioner"),
+    ("Continuous (Lock Outgoing to Incoming)", "Kontinuerlig (lås utgående till inkommande)"),
+    ("Cue Point", "Referenspunkt"),
+    ("Current Render", "Aktuell rendering"),
+    ("Dark", "Mörk"),
+    ("Dark Theme", "Mörkt tema"),
+    ("Darker", "Mörkare"),
+    ("Default Output:", "Standardutgång:"),
+    ("Default: {}", "Standard: {}"),
+    ("Defaults", "Standardvärden"),
+    ("Delete", "Radera"),
+    ("Delete Selected Points", "Radera markerade punkter"),
+    ("Delete selected project items", "Radera markerade projektobjekt"),
+    ("Delete this template", "Radera den här mallen"),
+    ("Depth of Field", "Skärpedjup"),
+    ("Discord", "Discord"),
+    ("Distribute Layers:", "Fördela lager:"),
+    ("Don't Recover", "Återställ inte"),
+    ("Don't Save", "Spara inte"),
+    ("Double-click a layer to open it in the Layer panel", "Dubbelklicka på ett lager för att öppna det i panelen Lager"),
+    ("Double-click footage in the Project panel to open it here", "Dubbelklicka på material i panelen Projekt för att öppna det här"),
+    ("Double-click to edit the comment", "Dubbelklicka för att redigera kommentaren"),
+    ("Download", "Hämta"),
+    (
+        "Drag properties here from the timeline,\nor use Animation > Add Property to Essential Graphics.",
+        "Dra hit egenskaper från tidslinjen,\neller använd Animering > Lägg till egenskap i Grundläggande grafik.",
+    ),
+    ("Drag to change", "Dra för att ändra"),
+    ("Drag to create a guide", "Dra för att skapa en stödlinje"),
+    ("Drag to slip the source", "Dra för att slip-flytta källan"),
+    ("Drop Frame", "Drop frame"),
+    ("Duplicate", "Duplicera"),
+    ("Duration:", "Längd:"),
+    ("Edit Gradient…", "Redigera gradient…"),
+    ("Edit Target: {}", "Redigeringsmål: {}"),
+    ("EffectCraft didn't quit normally last time.", "EffectCraft avslutades inte normalt förra gången."),
+    ("Effects & Presets options", "Alternativ för Effekter och förinställningar"),
+    ("Copy Presets Folder Path", "Kopiera sökväg till förinställningsmappen"),
+    ("Effects: {}", "Effekter: {}"),
+    ("Empty folder", "Tom mapp"),
+    ("Enable Depth of Field", "Aktivera skärpedjup"),
+    ("Enable Expression", "Aktivera uttryck"),
+    ("Enhance", "Förbättra"),
+    ("Essential Properties — {}", "Grundläggande egenskaper — {}"),
+    ("Event", "Händelse"),
+    ("Export Template…", "Exportera mall…"),
+    ("Export...", "Exportera..."),
+    ("Expression Language Menu", "Meny för uttrycksspråk"),
+    ("Expression pick whip: drag onto a property", "Uttryckets plockpiska: dra till en egenskap"),
+    ("Expression:", "Uttryck:"),
+    ("Eyedropper: click, then click in the Composition panel", "Pipett: klicka och klicka sedan i panelen Komposition"),
+    ("Falloff", "Avtagande"),
+    ("Falloff Distance", "Avstånd för avtagande"),
+    ("Favorites", "Favoriter"),
+    ("Field Render: {}", "Fältrendering: {}"),
+    ("Figures", "Figurer"),
+    ("Fill Target", "Fyllningsmål"),
+    ("Finished", "Klar"),
+    ("Flowchart: {}", "Flödesschema: {}"),
+    ("Focus Distance", "Fokusavstånd"),
+    ("Follow Feature Rotation and Scale", "Följ detaljens rotation och skala"),
+    ("Footage: {}", "Material: {}"),
+    ("Format: {}", "Format: {}"),
+    ("Frame Aspect Ratio: {}", "Bildförhållande för bildruta: {}"),
+    ("Frame Blending: {}", "Bildblandning: {}"),
+    ("Frame Rate:", "Bildfrekvens:"),
+    ("Frame Render Time  {}ms", "Renderingstid per bildruta  {} ms"),
+    ("Frame Target:", "Bildrutemål:"),
+    ("Freeze", "Frys"),
+    ("Grab bag", "Blandat"),
+    ("Gradient Editor", "Gradientredigerare"),
+    ("Grid", "Rutnät"),
+    ("Guide Layers: {}", "Stödlager: {}"),
+    ("Guides", "Stödlinjer"),
+    ("Height:", "Höjd:"),
+    ("Hide This", "Dölj den här"),
+    ("Histogram", "Histogram"),
+    ("Hold In Place", "Håll kvar på plats"),
+    ("Home", "Start"),
+    ("If Confidence is Below", "Om konfidensen är under"),
+    ("Import", "Importera"),
+    ("Import and Add to Composition", "Importera och lägg till i komposition"),
+    ("Import...", "Importera..."),
+    ("Imported media", "Importerade media"),
+    ("Influence:", "Inverkan:"),
+    ("Install from File…", "Installera från fil…"),
+    ("Intensity", "Intensitet"),
+    ("Inverted", "Inverterad"),
+    ("Join the ArtCraft community on Discord", "Gå med i ArtCrafts community på Discord"),
+    ("Key: {}", "Tangent: {}"),
+    ("LEARN", "LÄR DIG"),
+    ("Label", "Etikett"),
+    ("Label Colors and Names:", "Etikettfärger och namn:"),
+    ("Label:", "Etikett:"),
+    ("Latest auto-save: {}", "Senaste autosparning: {}"),
+    ("Layer", "Lager"),
+    ("Layer controls", "Lagerkontroller"),
+    ("Layer:", "Lager:"),
+    ("Layer: {}", "Lager: {}"),
+    ("Learn", "Lär dig"),
+    ("Leave all attributes in \"{}\"", "Lämna alla attribut i \"{}\""),
+    ("Licence: {}", "Licens: {}"),
+    ("Ligatures", "Ligaturer"),
+    ("Light", "Ljus"),
+    ("Light Theme", "Ljust tema"),
+    ("Light Type", "Ljustyp"),
+    ("Lighter", "Ljusare"),
+    ("Link Selected Property", "Länka markerad egenskap"),
+    ("Location:", "Plats:"),
+    ("Lock Aspect Ratio to {}", "Lås bildförhållandet till {}"),
+    ("Lock to Zoom", "Lås till zoom"),
+    ("Locked: {} — {}", "Låst: {} — {}"),
+    ("Log:", "Log:"),
+    ("Loop (Trace Path)", "Loopa (följ bana)"),
+    ("MIT OR Apache-2.0 • Fonts: Inter, JetBrains Mono (OFL)", "MIT OR Apache-2.0 • Typsnitt: Inter, JetBrains Mono (OFL)"),
+    ("Magnification ratio popup", "Meny för förstoringsgrad"),
+    ("Make Comp Size", "Anpassa till kompositionsstorlek"),
+    ("Markers", "Markörer"),
+    ("Masks", "Masker"),
+    ("Maximize Panel", "Maximera panel"),
+    ("Media Replacement", "Ersätt media"),
+    ("Mesh:", "Nät:"),
+    ("Diameter:", "Diameter:"),
+    ("Method Used: {}    Average Error: {} pixels", "Använd metod: {}    Medelfel: {} pixlar"),
+    ("Models folder: {}", "Modellmapp: {}"),
+    ("Modifiers:", "Modifieringstangenter:"),
+    ("More", "Mer"),
+    ("More ArtCraft apps", "Fler ArtCraft-appar"),
+    ("More tutorials", "Fler självstudier"),
+    ("Motion Blur", "Rörelseoskärpa"),
+    ("Motion Blur: {}", "Rörelseoskärpa: {}"),
+    ("Motion Sketch: drag to record", "Rörelseskiss: dra för att spela in"),
+    ("Move Down", "Flytta ned"),
+    ("Move Up", "Flytta upp"),
+    ("Move to Project Root", "Flytta till projektets rot"),
+    ("Name", "Namn"),
+    ("Name:", "Namn:"),
+    ("Navigation", "Navigering"),
+    ("New", "Nytt"),
+    ("New Comp from Selection", "Ny komposition från markering"),
+    ("Replace with Precomposition", "Ersätt med förkomposition"),
+    ("New Duration:", "Ny längd:"),
+    ("New composition name:", "Namn på ny komposition:"),
+    ("New from Render Queue item:", "Ny från objekt i renderingskön:"),
+    ("New from Template", "Ny från mall"),
+    ("Next", "Nästa"),
+    ("Nice work. Pick another tutorial on the Home screen's Learn tab.", "Bra jobbat! Välj en annan självstudie på fliken Lär dig på startskärmen."),
+    (
+        "No VR environments yet. Create one with Composition ▸ VR ▸ Create VR Environment…",
+        "Inga VR-miljöer ännu. Skapa en med Komposition ▸ VR ▸ Skapa VR-miljö…",
+    ),
+    ("No audio layer selected", "Inget ljudlager markerat"),
+    ("No background jobs running", "Inga bakgrundsjobb körs"),
+    ("No composition markers", "Inga kompositionsmarkörer"),
+    ("No contributor data was built into this copy.", "Inga uppgifter om bidragsgivare finns inbyggda i den här kopian."),
+    ("No device list from this host; the system default output is used.", "Värden tillhandahåller ingen enhetslista. Systemets standardutgång används."),
+    ("No layer selected", "Inget lager markerat"),
+    ("No matching effects or presets", "Inga matchande effekter eller förinställningar"),
+    ("No matching fonts", "Inga matchande typsnitt"),
+    ("Variable fonts only", "Endast variabla typsnitt"),
+    ("No model credits were built into this copy.", "Inga modellkrediteringar finns inbyggda i den här kopian."),
+    ("No nested compositions", "Inga kapslade kompositioner"),
+    ("No shortcut", "Inget kortkommando"),
+    ("No unlocked layer selected", "Inget upplåst lager markerat"),
+    ("No video", "Ingen video"),
+    ("None", "Ingen"),
+    ("Not applied: tick it in the list to add it.", "Inte använd: markera den i listan för att lägga till den."),
+    ("Not assigned", "Inte tilldelad"),
+    ("Note: Shadows are only cast from layers with Cast Shadows enabled.", "Obs! Skuggor kastas bara från lager där Kasta skuggor är aktiverat."),
+    ("Notify", "Meddela"),
+    ("OK", "OK"),
+    ("Offset:", "Förskjutning:"),
+    ("On ({}) stop:", "Vid stopp ({}):"),
+    ("One-Node Camera", "Kamera med en nod"),
+    ("Opacity:", "Opacitet:"),
+    ("Open Composition", "Öppna komposition"),
+    ("used once", "används en gång"),
+    ("used {} times", "används {} gånger"),
+    ("Compositions that use this item", "Kompositioner som använder det här objektet"),
+    ("Open Last Saved Project", "Öppna senast sparade projekt"),
+    ("Open New Composition", "Öppna ny komposition"),
+    ("Open Output", "Öppna utdata"),
+    ("Open a composition to build Essential Graphics", "Öppna en komposition för att bygga grundläggande grafik"),
+    ("Open a composition to see its scopes", "Öppna en komposition för att se dess mätinstrument"),
+    ("Open a composition to track motion.", "Öppna en komposition för att spåra rörelse."),
+    ("Opus Tuning: {}", "Opus-optimering: {}"),
+    ("Original Duration:", "Ursprunglig längd:"),
+    ("Output Cycle: {}", "Utdatacykel: {}"),
+    ("Output To:", "Utdata till:"),
+    ("Overlay", "Överlägg"),
+    ("Parameter Name:", "Parameternamn:"),
+    ("Parent pick whip: drag onto a layer", "Överordnad väljare: dra till ett lager"),
+    ("Pixel Aspect Ratio:", "Pixelproportioner:"),
+    ("Playing on Video Preview", "Spelas upp i videoförhandsgranskningen"),
+    ("Post-Render Action: {}", "Åtgärd efter rendering: {}"),
+    ("Preserve frame rate when nested or in render queue", "Bevara bildfrekvensen när den är kapslad eller i renderingskön"),
+    ("Preserve resolution when nested", "Bevara upplösningen när den är kapslad"),
+    ("Preset", "Förinställning"),
+    ("Preset:", "Förinställning:"),
+    ("Presets", "Förinställningar"),
+    ("Previous", "Föregående"),
+    ("Primary:", "Primär:"),
+    ("Process Before Match", "Bearbeta före matchning"),
+    ("Profile: {}", "Profil: {}"),
+    (
+        "Project color depth: click to cycle 8/16/32 bpc, Alt-click for Project Settings",
+        "Projektets färgdjup: klicka för att växla mellan 8/16/32 bpc, Alt-klicka för projektinställningar",
+    ),
+    ("Project: {}", "Projekt: {}"),
+    ("Projects", "Projekt"),
+    ("Property pick whip: drag onto a property", "Egenskapsväljare: dra till en egenskap"),
+    ("Protected Region", "Skyddad region"),
+    ("Proxy Use: {}", "Proxyanvändning: {}"),
+    ("Push All to Comp", "Skjut alla till kompositionen"),
+    ("RGB", "RGB"),
+    ("Radius", "Radie"),
+    ("Rate Control: {}", "Bithastighetsstyrning: {}"),
+    ("Recent", "Senaste"),
+    ("Recording", "Spelar in"),
+    ("Remove", "Ta bort"),
+    ("Rename", "Byt namn"),
+    ("Render: {} ms  •  UI {} fps{}", "Rendering: {} ms  •  UI {} bild/s{}"),
+    ("Renderer:", "Renderare:"),
+    ("Request Persistent Storage", "Begär beständig lagring"),
+    ("Reset", "Återställ"),
+    ("Reset Labels", "Återställ etiketter"),
+    ("Reset Preset", "Återställ förinställning"),
+    ("Reset to Default", "Återställ till standard"),
+    ("Reset to Saved Layout", "Återställ till sparad layout"),
+    ("Resolution/Down Sample Factor Popup", "Meny för upplösning/nedsamplingsfaktor"),
+    ("Restore Panel Size", "Återställ panelstorlek"),
+    ("Reverse the order", "Vänd på ordningen"),
+    ("Revert All", "Återgå för alla"),
+    ("Roman Hanging Punctuation", "Hängande interpunktion (roman)"),
+    ("Roving:", "Rörlig:"),
+    ("Ruler zero point (drag to move, double-click to reset)", "Linjalens nollpunkt (dra för att flytta, dubbelklicka för att återställa)"),
+    ("Rulers", "Linjaler"),
+    ("Run", "Kör"),
+    ("Sample Format: {}", "Samplingsformat: {}"),
+    ("Samples Per Frame:", "Samplingar per bildruta:"),
+    ("Save from #{}", "Spara från #{}"),
+    ("Saved {}", "Sparat {}"),
+    ("Script… (⌘/Ctrl+Enter runs)", "Skript… (⌘/Ctrl+Enter kör)"),
+    ("Search commands or shortcuts", "Sök kommandon eller kortkommandon"),
+    ("Select", "Markera"),
+    ("Select a command to change its shortcut.", "Markera ett kommando för att ändra dess kortkommando."),
+    ("Select a layer to see its effects", "Markera ett lager för att se dess effekter"),
+    ("Select a layer to see its properties", "Markera ett lager för att se dess egenskaper"),
+    ("({}) Selected Objects", "({}) markerade objekt"),
+    (
+        "Select a layer with a mask or shape path (or the path property), or Puppet pins.",
+        "Markera ett lager med en mask- eller formbana (eller banegenskapen) eller marionettnålar.",
+    ),
+    ("Select a text layer", "Markera ett textlager"),
+    ("Select an item in the Project panel", "Markera ett objekt i panelen Projekt"),
+    ("Select animated properties to show them in the Graph Editor", "Markera animerade egenskaper för att visa dem i grafredigeraren"),
+    (
+        "Select the leader pin, then Shift-click the pins that should trail it (hair, cloth, tails)",
+        "Markera ledarnålen och Shift-klicka sedan på nålarna som ska följa efter den (hår, tyg, svansar)",
+    ),
+    ("Set Ground Plane and Origin", "Ange markplan och origo"),
+    ("Set Paint Colors to Black and White (D)", "Ställ in målarfärger på svart och vitt (D)"),
+    ("Settings", "Inställningar"),
+    ("Settings Name:", "Inställningsnamn:"),
+    ("Shadow Darkness", "Skuggmörkhet"),
+    ("Shadow Diffusion", "Skuggdiffusion"),
+    ("Shadows", "Skuggor"),
+    ("Shape…", "Form…"),
+    ("Show", "Visa"),
+    ("Show Layer Name", "Visa lagernamn"),
+    ("Show Source Name", "Visa källnamn"),
+    ("Show me", "Visa mig"),
+    ("Show:", "Visa:"),
+    ("Shutter Angle:", "Slutarvinkel:"),
+    ("Shutter Phase:", "Slutarfas:"),
+    ("Size", "Storlek"),
+    ("Skip", "Hoppa över"),
+    ("Snapping", "Fäst"),
+    ("Snapping options", "Fästalternativ"),
+    ("Snapshot", "Ögonblicksbild"),
+    ("Solo Supported Properties", "Solo för egenskaper som stöds"),
+    ("Solo Switches: {}", "Soloväxlar: {}"),
+    ("Sort", "Sortera"),
+    ("Spacing:", "Avstånd:"),
+    ("Spatial Interpolation:", "Rumslig interpolering:"),
+    ("Speed:", "Hastighet:"),
+    ("Start Timecode:", "Starttidskod:"),
+    ("Start: {}   Duration: {}", "Start: {}   Längd: {}"),
+    ("Step {} of {}: {}", "Steg {} av {}: {}"),
+    ("Stop", "Stoppa"),
+    ("Stop {} at {}°", "Stopp {} vid {}°"),
+    ("Stored in: {}", "Lagras i: {}"),
+    ("Stretch", "Sträck"),
+    ("Stretch Factor:", "Sträckfaktor:"),
+    ("Stylistic Sets", "Stilistiska uppsättningar"),
+    ("Subpixel Positioning", "Subpixelpositionering"),
+    ("Swap Colors", "Byt plats på färger"),
+    ("Swap Paint Colors (X)", "Byt plats på målarfärger (X)"),
+    ("Sync with System", "Synka med systemet"),
+    ("System Default", "Systemstandard"),
+    ("Table", "Tabell"),
+    ("Template name", "Mallnamn"),
+    ("Template: {}\n{}", "Mall: {}\n{}"),
+    ("Temporal Interpolation:", "Tidsinterpolering:"),
+    ("The Media Browser is not available here (use File ▸ Import)", "Mediebläddraren är inte tillgänglig här (använd Arkiv ▸ Importera)"),
+    ("The OpenEXR layer shown in red, green, blue and alpha", "OpenEXR-lagret visas i rött, grönt, blått och alfa"),
+    ("The render queue is empty.", "Renderingskön är tom."),
+    (
+        "These adjacent keyframes cannot interpolate because their stop counts differ.",
+        "De här intilliggande nyckelbildrutorna kan inte interpoleras eftersom de har olika antal stopp.",
+    ),
+    ("This ScriptUI panel has closed", "Den här ScriptUI-panelen har stängts"),
+    ("This change will create a new solid for this layer.", "Den här ändringen skapar ett nytt enfärgat lager för det här lagret."),
+    ("Time", "Tid"),
+    ("Time Stretch…", "Tidssträckning…"),
+    ("Time:", "Tid:"),
+    ("Time: {}", "Tid: {}"),
+    ("Title/Action Safe", "Text-/bildsäkert område"),
+    ("Title/action safe", "Textsäkert/bildsäkert område"),
+    ("Toggle Switches / Modes", "Växla reglage/lägen"),
+    ("Track Name:", "Spårnamn:"),
+    (
+        "Trained models are available in the desktop app; the browser uses the classic engine.",
+        "Tränade modeller finns i skrivbordsappen; webbläsaren använder den klassiska motorn.",
+    ),
+    ("Transform", "Transformera"),
+    ("Transparency grid", "Transparensrutnät"),
+    ("Tutorial complete", "Självstudien är klar"),
+    ("Two-Node Camera", "Kamera med två noder"),
+    ("Type", "Typ"),
+    ("Type a command or effect…", "Skriv ett kommando eller en effekt…"),
+    ("URL:", "URL:"),
+    ("Undock Panel", "Lossa panel"),
+    ("Move Panel to New Window", "Flytta panelen till ett nytt fönster"),
+    ("Move Panel to Main Window", "Flytta panelen till huvudfönstret"),
+    ("Unfreeze", "Tina upp"),
+    ("Unlink {}", "Ta bort länk till {}"),
+    (
+        "Use this option to place the currently selected layers together into a new intermediate composition.",
+        "Använd det här alternativet för att placera de markerade lagren tillsammans i en ny mellanliggande komposition.",
+    ),
+    ("VR Environments", "VR-miljöer"),
+    ("Value:", "Värde:"),
+    ("Variable Font Axes", "Axlar för variabla typsnitt"),
+    ("Video Codec: {}", "Videokodek: {}"),
+    ("View:", "Vy:"),
+    ("Welcome to EffectCraft", "Välkommen till EffectCraft"),
+    ("Width:", "Bredd:"),
+    ("You can undo this.", "Du kan ångra detta."),
+    ("You can't undo this.", "Du kan inte ångra detta."),
+    ("Your changes will be lost if you don't save them.", "Dina ändringar går förlorade om du inte sparar dem."),
+    ("Zoom", "Zoom"),
+    ("built-in", "inbyggd"),
+    ("frames per second", "bilder per sekund"),
+    ("template name", "mallnamn"),
+    ("{} contributors · {} commits", "{} bidragsgivare · {} commits"),
+    ("{} x {}, {}MB per 8bpc frame", "{} x {}, {} MB per bildruta i 8 bpc"),
+    ("{} — coming soon", "{} – kommer snart"),
+    ("{} — double-click to open, {}-click to reveal", "{} – dubbelklicka för att öppna, {}-klicka för att visa i mappen"),
+    ("⌘/Ctrl-drag a pin to record its motion", "⌘/Ctrl-dra en nål för att spela in dess rörelse"),
+    ("▣ {}", "▣ {}"),
+    ("⚠ {} is used by:", "⚠ {} används av:"),
+    ("3D Reference Axes", "3D-referensaxlar"),
+    ("Affect all layers that use this solid", "Påverka alla lager som använder den här enfärgade ytan"),
+    ("Choose grid and guide options", "Välj alternativ för rutnät och stödlinjer"),
+    ("Colorize", "Färglägg"),
+    ("Custom", "Anpassad"),
+    ("Custom...", "Anpassad..."),
+    ("Fit", "Anpassa"),
+    ("Fit up to 100%", "Anpassa upp till 100 %"),
+    ("Full", "Full"),
+    ("Half", "Halv"),
+    ("Only this layer uses this solid.", "Bara det här lagret använder den här enfärgade ytan."),
+    ("Proportional Grid", "Proportionellt rutnät"),
+    ("Quarter", "Fjärdedel"),
+    ("Region of Interest", "Intresseområde"),
+    ("Reset Exposure", "Återställ exponering"),
+    ("Show Channel and Color Management Settings", "Visa inställningar för kanal och färghantering"),
+    ("Show Snapshot (hold)", "Visa ögonblicksbild (håll ned)"),
+    ("Take Snapshot", "Ta ögonblicksbild"),
+    ("Third", "En tredjedel"),
+    ("Toggle Mask and Shape Path Visibility", "Växla synlighet för mask- och formbanor"),
+    ("Toggle Transparency Grid", "Växla transparensrutnät"),
+    ("16 bits per channel", "16 bitar per kanal"),
+    ("32 bits per channel (float)", "32 bitar per kanal (flyttal)"),
+    ("8 bits per channel", "8 bitar per kanal"),
+    ("Adaptive Resolution", "Adaptiv upplösning"),
+    ("Adobe-style built-in", "Inbyggd i Adobe-stil"),
+    ("Blue", "Blå"),
+    ("Current Settings", "Aktuella inställningar"),
+    ("Disable Per-character 3D", "Inaktivera 3D per tecken"),
+    ("Draft", "Utkast"),
+    ("Enable Per-character 3D", "Aktivera 3D per tecken"),
+    ("Fast Draft", "Snabbt utkast"),
+    ("Fast Previews (Draft 3D, Faster Effects)", "Snabba förhandsgranskningar (3D-utkast, snabbare effekter)"),
+    ("Green", "Grön"),
+    ("Import Image Sequence", "Importera bildsekvens"),
+    ("Import PDF / Illustrator File", "Importera PDF-/Illustrator-fil"),
+    ("Import Photoshop File", "Importera Photoshop-fil"),
+    ("Interpret Unlabeled Alpha As", "Tolka omärkt alfa som"),
+    ("Join the ArtCraft Discord", "Gå med i ArtCraft på Discord"),
+    ("Mercury GPU Acceleration ({})", "Mercury GPU-acceleration ({})"),
+    ("Mercury Software Only", "Endast Mercury-programvara"),
+    ("OCIO (built-in ACES config)", "OCIO (inbyggd ACES-konfiguration)"),
+    ("Off (Final Quality)", "Av (slutlig kvalitet)"),
+    ("OpenGL (compatibility)", "OpenGL (kompatibilitet)"),
+    ("Opus Bitrate: {} kbps", "Opus-bithastighet: {} kbit/s"),
+    ("RGB Straight", "RGB (rak)"),
+    ("Red", "Röd"),
+    ("Tone map", "Tonmappning"),
+    ("Use In-Window Menu Bar on macOS", "Använd menyrad i fönstret på macOS"),
+    ("Wireframe", "Trådram"),
+    ("sRGB IEC61966-2.1 (default)", "sRGB IEC61966-2.1 (standard)"),
+    ("New Project", "Nytt projekt"),
+    ("Open Project…", "Öppna projekt…"),
+    ("Templates", "Mallar"),
+    ("EffectCraft home page", "EffectCrafts webbplats"),
+    ("EffectCraft on GitHub", "EffectCraft på GitHub"),
+    ("Motion graphics and visual effects · version {}", "Rörlig grafik och visuella effekter · version {}"),
+    ("New Composition", "Ny komposition"),
+    ("Open Demo Project", "Öppna demoprojekt"),
+    ("Import Footage…", "Importera material…"),
+    ("Filter recent files", "Filtrera senaste filer"),
+    ("NAME", "NAMN"),
+    ("OPENED", "ÖPPNAD"),
+    ("SIZE", "STORLEK"),
+    ("KIND", "TYP"),
+    ("Your recent files will show here", "Dina senaste filer visas här"),
+    ("Create a new project, or open the demo project to look around.", "Skapa ett nytt projekt, eller öppna demoprojektet för att titta runt."),
+    ("No recent files match the filter", "Inga senaste filer matchar filtret"),
+    ("Try another name or folder.", "Prova ett annat namn eller en annan mapp."),
+    ("Just now", "Nyss"),
+    ("Yesterday", "I går"),
+    ("{} minute ago", "för {} minut sedan"),
+    ("{} minutes ago", "för {} minuter sedan"),
+    ("{} hour ago", "för {} timme sedan"),
+    ("{} hours ago", "för {} timmar sedan"),
+    ("{} day ago", "för {} dag sedan"),
+    ("{} days ago", "för {} dagar sedan"),
+    ("EffectCraft project", "EffectCraft-projekt"),
+    ("After Effects project", "After Effects-projekt"),
+    ("Lottie animation", "Lottie-animering"),
+    ("Project", "Projekt"),
+    ("General", "Allmänt"),
+    ("Language", "Språk"),
+    ("Levels of Undo", "Antal ångranivåer"),
+    ("Path Point and Handle Size", "Storlek på banpunkter och handtag"),
+    ("Recent Projects Shown", "Antal senaste projekt som visas"),
+    ("Options", "Alternativ"),
+    ("Show Tool Tips", "Visa verktygstips"),
+    ("Create Layers at Composition Start Time", "Skapa lager vid kompositionens starttid"),
+    ("Switches Affect Nested Comps", "Växlar påverkar kapslade kompositioner"),
+    ("Default Spatial Interpolation to Linear", "Linjär spatial interpolering som standard"),
+    ("Preserve Constant Vertex and Feather Point Count when Editing Masks", "Bevara konstant antal hörn och fjäderpunkter vid redigering av masker"),
+    ("Synchronize Time of All Related Items", "Synkronisera tid för alla relaterade objekt"),
+    ("Expression Pick Whip Writes Compact English", "Uttryckets plockpiska skriver kompakt engelska"),
+    ("Create Split Layers Above Original Layer", "Skapa delade lager ovanför originallagret"),
+    ("Use System Color Picker", "Använd systemets färgväljare"),
+    (
+        "EffectCraft always uses its own colour picker (the same on every platform and the web).",
+        "EffectCraft använder alltid sin egen färgväljare (densamma på alla plattformar och på webben).",
+    ),
+    ("Startup & Repair", "Start och reparation"),
+    ("Show Home Screen When Launching", "Visa startskärmen vid start"),
+    ("Show Home Screen When Opening a Project", "Visa startskärmen när ett projekt öppnas"),
+    ("Offer to Open the Latest Auto-Save After a Crash", "Erbjud att öppna den senaste autosparningen efter en krasch"),
+    ("Window Graphics", "Fönstergrafik"),
+    ("Automatic", "Automatisk"),
+    (
+        "Window Graphics applies from the next launch. When the graphics driver stops EffectCraft as its window opens, the next launch switches to OpenGL.",
+        "Fönstergrafik tillämpas från nästa start. Om grafikdrivrutinen stoppar EffectCraft när fönstret öppnas byter nästa start till OpenGL.",
+    ),
+    ("Repair", "Reparera"),
+    ("Reset Settings", "Återställ inställningar"),
+    ("Reset Keyboard Shortcuts", "Återställ kortkommandon"),
+    ("Empty Disk Cache", "Töm diskcache"),
+    ("New Project Loads Template", "Nytt projekt läser in mall"),
+    ("Template Project", "Mallprojekt"),
+    ("Auto-Save", "Spara automatiskt"),
+    ("Automatically Save Projects", "Spara projekt automatiskt"),
+    ("Save Every", "Spara var"),
+    ("Minutes", "Minuter"),
+    ("Maximum Project Versions", "Maximalt antal projektversioner"),
+    ("Auto-Save Location", "Plats för automatisk sparning"),
+    ("Next to Project", "Bredvid projektet"),
+    ("Custom Location", "Anpassad plats"),
+    ("Save When Starting Render Queue", "Spara när renderingskön startas"),
+    ("Save Now", "Spara nu"),
+    ("Motion Path", "Rörelsebana"),
+    ("All Keyframes", "Alla nyckelbildrutor"),
+    ("No Motion Path", "Ingen rörelsebana"),
+    ("No More Than (Seconds)", "Högst (sekunder)"),
+    ("No More Than (Keyframes)", "Högst (nyckelbildrutor)"),
+    ("Seconds", "Sekunder"),
+    ("Keyframes", "Nyckelbildrutor"),
+    ("Display", "Visning"),
+    ("Show Rendering Progress in Info Panel and Flowchart", "Visa renderingsförlopp i panelen Info och flödesschemat"),
+    ("Hardware Accelerate Composition, Layer and Footage Panels", "Maskinvaruaccelerera panelerna Komposition, Lager och Material"),
+    ("Panels are always drawn by the GPU (wgpu).", "Paneler ritas alltid av GPU:n (wgpu)."),
+    ("Previews", "Förhandsgranskningar"),
+    ("Adaptive Resolution Limit", "Gräns för adaptiv upplösning"),
+    ("Show Internal Wireframes", "Visa interna trådmodeller"),
+    ("Cache Frames When Idle", "Cachelagra bildrutor vid inaktivitet"),
+    ("Viewer Zoom Quality", "Zoomkvalitet i visningsfönstret"),
+    ("Faster", "Snabbare"),
+    ("More Accurate", "Mer exakt"),
+    ("Display Color Space", "Visningsfärgrymd"),
+    ("GPU Information...", "GPU-information..."),
+    ("Appearance", "Utseende"),
+    ("Brightness", "Ljusstyrka"),
+    ("UI Scale", "Gränssnittsskala"),
+    ("Labels and Colors", "Etiketter och färger"),
+    ("Use Label Color for Layer Handles and Paths", "Använd etikettfärg för lagerhandtag och banor"),
+    ("Use Label Color for Related Tabs", "Använd etikettfärg för relaterade flikar"),
+    ("Cycle Mask Colors", "Växla maskfärger"),
+    ("Use Gradients", "Använd gradienter"),
+    ("Menu Bar", "Menyrad"),
+    ("Grids & Guides", "Rutnät och stödlinjer"),
+    ("Gridline Every", "Stödlinje var"),
+    ("Subdivisions", "Underindelningar"),
+    ("Style", "Stil"),
+    ("Lines", "Rader"),
+    ("Dashed Lines", "Streckade linjer"),
+    ("Dots", "Punkter"),
+    ("Horizontal", "Horisontell"),
+    ("Vertical", "Vertikal"),
+    ("Safe Margins", "Säkra marginaler"),
+    ("Action-safe", "Bildsäkert område"),
+    ("Title-safe", "Titelsäker"),
+    ("Labels", "Etiketter"),
+    ("Text Engine", "Textmotor"),
+    ("Latin", "Latin"),
+    ("South Asian and Middle Eastern", "Sydasiatiska och mellanösterländska"),
+    ("Show Font Preview", "Visa förhandsgranskning av typsnitt"),
+    ("Number of Recent Fonts to Display", "Antal senaste typsnitt som visas"),
+    ("Show Font Names in English", "Visa typsnittsnamn på engelska"),
+    ("Still Footage", "Stillbildsmaterial"),
+    ("Length of Composition", "Kompositionens längd"),
+    ("Duration (Seconds)", "Längd (sekunder)"),
+    ("Still Duration", "Stillbildslängd"),
+    ("Sequence Footage", "Sekvensmaterial"),
+    ("Report Missing Frames", "Rapportera saknade bildrutor"),
+    ("Automatically Reload Footage", "Läs in material igen automatiskt"),
+    ("Off", "Av"),
+    ("Non-Sequence Footage", "Material som inte är sekvenser"),
+    ("All Footage", "Allt material"),
+    ("Ask User", "Fråga användaren"),
+    ("Guess", "Gissa"),
+    ("Ignore", "Ignorera"),
+    ("Straight", "Rak"),
+    ("Premultiplied", "Förmultiplicerad"),
+    ("Default Drag Import As", "Standardimport vid dragning"),
+    ("Footage", "Material"),
+    ("Composition - Retain Layer Sizes", "Komposition – behåll lagerstorlekar"),
+    ("Export", "Exportera"),
+    ("Default Output Folder", "Standardmapp för utgång"),
+    ("Segment Sequences", "Segmentera sekvenser"),
+    ("Files per Segment", "Filer per segment"),
+    ("files", "filer"),
+    ("Segment Movie Files", "Segmentera filmfiler"),
+    ("Segment Size", "Segmentstorlek"),
+    ("Append Bit Depth to File Name", "Lägg till bitdjup i filnamnet"),
+    ("Audio", "Ljud"),
+    ("Audio Hardware", "Ljudhårdvara"),
+    ("Preview Sample Rate", "Samplingsfrekvens för förhandsgranskning"),
+    ("Audio Output Mapping", "Mappning av ljudutgång"),
+    ("Left", "Vänster"),
+    ("Right", "Höger"),
+    ("channel", "kanal"),
+    ("Disk", "Disk"),
+    ("Disk Cache", "Diskcache"),
+    ("Enable Disk Cache", "Aktivera diskcache"),
+    ("Maximum Disk Cache Size", "Maximal storlek på diskcache"),
+    ("Disk Cache Folder", "Mapp för diskcache"),
+    ("Media Cache", "Mediecache"),
+    ("Database and Cache Folder", "Databas- och cachemapp"),
+    ("Conformed Audio Folder", "Mapp för konformerat ljud"),
+    ("Memory & CPU", "Minne och processor"),
+    ("RAM Reserved for Other Applications", "RAM reserverat för andra program"),
+    ("Cache Budgets", "Cachebudgetar"),
+    ("Layer Cache", "Lagercache"),
+    ("Footage Frame Cache", "Bildrutecache för material"),
+    ("Preview (RAM) Cache", "Förhandsgranskningscache (RAM)"),
+    ("Reduce Cache Size When System Is Low on Memory", "Minska cachestorleken när systemet har ont om minne"),
+    ("Video", "Video"),
+    ("Enable Video Preview Output", "Aktivera videoutgång för förhandsgranskning"),
+    ("Video Device", "Videoenhet"),
+    ("Floating Window", "Flytande fönster"),
+    ("Full Screen", "Helskärm"),
+    ("Video Output During Playback", "Videoutgång under uppspelning"),
+    ("Mirror on Computer Monitor", "Spegla på datorskärmen"),
+    ("Disable Video Output When in Background", "Inaktivera videoutgång i bakgrunden"),
+    ("Default 3D Renderer", "Standard-3D-renderare"),
+    ("Show 3D Reference Axes", "Visa 3D-referensaxlar"),
+    ("Extended Viewer", "Utökad visare"),
+    ("Realtime Shadows in Draft", "Skuggor i realtid i utkastläge"),
+    ("Scripting & Expressions", "Skript och uttryck"),
+    ("Application Scripting", "Programskriptning"),
+    ("Allow Scripts to Write Files and Access Network", "Tillåt skript att skriva filer och komma åt nätverket"),
+    ("Warn User When Executing Files", "Varna användaren när filer körs"),
+    ("Enable JavaScript Debugger", "Aktivera JavaScript-felsökare"),
+    ("Expressions Editor", "Uttrycksredigerare"),
+    ("Font Size", "Teckenstorlek"),
+    ("Syntax Highlighting", "Syntaxmarkering"),
+    ("Line Numbers", "Radnummer"),
+    ("Auto-complete", "Autokomplettering"),
+    ("Bracket Matching", "Parentesmatchning"),
+    ("Word Wrap", "Radbrytning"),
+    ("Show Expression Error Banner", "Visa fältet för uttrycksfel"),
+    (
+        "Expressions use the JavaScript engine. Script errors report their file and line in the Script Console; there is no step debugger.",
+        "Uttryck använder JavaScript-motorn. Skriptfel rapporterar fil och rad i skriptkonsolen; det finns ingen stegvis felsökare.",
+    ),
+    ("Roto Brush", "Rotopensel"),
+    ("Segmentation Model", "Segmenteringsmodell"),
+    (
+        "Roto Brush 2.0 and 3.0 use the model chosen here (Version 1.0 always uses the classic engine). Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
+        "Rotopensel 2.0 och 3.0 använder modellen som väljs här (version 1.0 använder alltid den klassiska motorn). Modellerna är öppen källkod, laddas bara ned när du ber om det och kontrolleras mot sin publicerade SHA-256.",
+    ),
+    ("Face Tracking", "Ansiktsspårning"),
+    ("Face Model", "Ansiktsmodell"),
+    (
+        "Face tracking in the Tracker panel (Outline Only and Detailed Features) uses the model chosen here. Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
+        "Ansiktsspårning i panelen Spårning (Endast kontur och Detaljerade drag) använder modellen som väljs här. Modellerna är öppen källkod, hämtas bara när du ber om det och kontrolleras mot sin publicerade SHA-256.",
+    ),
+    ("Match System", "Enligt systemet"),
+    ("Default", "Standard"),
+    ("Stored, but not used by EffectCraft yet", "Lagras, men används inte av EffectCraft än"),
+    ("Total Offset", "Total förskjutning"),
+    ("Per Layer", "Per lager"),
+    ("Track", "Spåra"),
+    ("A built-in preset has this name", "En inbyggd förinställning har det här namnet"),
+    ("Cannot import dropped files: {}", "Kan inte importera släppta filer: {}"),
+    ("Cannot open dropped project {}: {}", "Kan inte öppna det släppta projektet {}: {}"),
+    ("Click in the Composition panel to sample text {}", "Klicka i panelen Komposition för att hämta text {}"),
+    ("Click to sample text {}", "Klicka för att hämta text {}"),
+    ("Comment of {}: {}", "Kommentar till {}: {}"),
+    ("Delete Preset", "Radera förinställning"),
+    ("Drop file to import", "Släpp filen för att importera"),
+    ("Drop {} files to import", "Släpp {} filer för att importera"),
+    ("Effects", "Effekter"),
+    ("Label of {}: {}", "Etikett för {}: {}"),
+    ("Mercury GPU Acceleration (no GPU: software)", "Mercury GPU-acceleration (ingen GPU: programvara)"),
+    ("Only one project can be opened per drop; skipped {} more", "Bara ett projekt kan öppnas per släpp; hoppade över {} till"),
+    ("Open in Essential Graphics", "Öppna i Grundläggande grafik"),
+    ("Original color: click to go back to it", "Originalfärg: klicka för att återgå till den"),
+    ("Project color depth: {}", "Projektets färgdjup: {}"),
+    ("Replaces your preset with this name", "Ersätter din förinställning med det här namnet"),
+    ("Resize floating panel", "Ändra storlek på flytande panel"),
+    ("Save Preset…", "Spara förinställning…"),
+    (
+        "Skipped {} dropped file(s) without a local path. Use File ▸ Import ▸ File…",
+        "Hoppade över {} släppta fil(er) utan lokal sökväg. Använd Arkiv ▸ Importera ▸ Fil…",
+    ),
+    ("Sort by {}", "Sortera efter {}"),
+    ("Sort by {}, {}", "Sortera efter {}, {}"),
+    ("Video preview is off (Preview panel): audio only", "Videoförhandsgranskningen är av (panelen Förhandsgranskning): endast ljud"),
+    ("Video preview off: audio only", "Videoförhandsgranskning av: endast ljud"),
+    ("Copy", "Kopiera"),
+    ("Paste", "Klistra in"),
+    ("Edit Value…", "Redigera värde…"),
+    ("Remove Expression", "Ta bort uttryck"),
+    ("Copy Source Path", "Kopiera källsökväg"),
+    ("Resolution:", "Upplösning:"),
+    ("Guide Layer", "Hjälplager"),
+    ("Layer Styles", "Lagerstilar"),
+    ("Check for Updates", "Sök efter uppdateringar"),
+    ("Close font search", "Stäng typsnittssökningen"),
+    ("Search project", "Sök i projektet"),
+    ("Update check is not supported in the web browser.", "Sökning efter uppdateringar stöds inte i webbläsaren."),
+    ("Click to sample color", "Klicka för att ta färgprov"),
+    ("Advanced", "Avancerat"),
+    ("Rescan Fonts", "Skanna om typsnitt"),
+    ("Track Matte pick whip: drag onto a layer", "Track matte-väljare: dra till ett lager"),
+    ("Play/Stop", "Spela/stoppa"),
+    ("Selection Tool", "Markeringsverktyg"),
+    ("Hand Tool", "Handverktyg"),
+    ("Zoom Tool", "Zoomverktyg"),
+    ("Orbit Around Cursor Tool", "Verktyg för att kretsa kring pekaren"),
+    ("Pan Under Cursor Tool", "Verktyg för att panorera under pekaren"),
+    ("Dolly Towards Cursor Tool", "Verktyget Dolly mot pekaren"),
+    ("Rotation Tool", "Rotationsverktyg"),
+    ("Pan Behind (Anchor Point) Tool", "Verktyg för att panorera bakom (ankarpunkt)"),
+    ("Rectangle Tool", "Rektangelverktyg"),
+    ("Rounded Rectangle Tool", "Verktyg för rundad rektangel"),
+    ("Ellipse Tool", "Ellipsverktyg"),
+    ("Polygon Tool", "Polygonverktyg"),
+    ("Star Tool", "Stjärnverktyg"),
+    ("Pen Tool", "Pennverktyg"),
+    ("Add Vertex Tool", "Verktyget Lägg till hörnpunkt"),
+    ("Delete Vertex Tool", "Verktyget Radera hörnpunkt"),
+    ("Convert Vertex Tool", "Verktyget Konvertera hörnpunkt"),
+    ("Mask Feather Tool", "Maskfjädringsverktyg"),
+    ("Horizontal Type Tool", "Horisontellt textverktyg"),
+    ("Vertical Type Tool", "Vertikalt textverktyg"),
+    ("Brush Tool", "Penselverktyg"),
+    ("Clone Stamp Tool", "Klonstämpelverktyg"),
+    ("Eraser Tool", "Suddgummiverktyg"),
+    ("Roto Brush Tool", "Rotopenselverktyg"),
+    ("Refine Edge Tool", "Verktyg för kantförfining"),
+    ("Object Matte Tool", "Objektmatteverktyg"),
+    ("Puppet Position Pin Tool", "Verktyg för positionsnål (docka)"),
+    ("Puppet Starch Pin Tool", "Verktyg för styvhetsnål (docka)"),
+    ("Puppet Bend Pin Tool", "Docknålsverktyg för böjning"),
+    ("Puppet Advanced Pin Tool", "Avancerat docknålsverktyg"),
+    ("Puppet Overlap Pin Tool", "Docknålsverktyg för överlappning"),
+    ("Shortcut", "Kortkommando"),
+    ("Range", "Omfång"),
+    ("Play From", "Spela upp från"),
+    ("Frame Rate", "Bildfrekvens"),
+    ("Resolution", "Upplösning"),
+    ("Overlays", "Överlägg"),
+    ("Layer Controls", "Lagerkontroller"),
+    ("Loop", "Loopa"),
+    ("Cache Before Playback", "Cachelagra före uppspelning"),
+    ("Pre-roll", "Förrullning"),
+    ("Post-roll", "Efterrullning"),
+    ("If caching, play cached frames", "Spela upp cachade bildrutor vid cachning"),
+    ("Apply", "Använd"),
+    ("Analyze", "Analysera"),
+    ("Create Camera", "Skapa kamera"),
+    ("Add Point", "Lägg till punkt"),
+    ("Remove Point", "Ta bort punkt"),
+    ("Render", "Rendera"),
+    ("Save Current as Template…", "Spara aktuellt som mall…"),
+    ("New Composition From Footage", "Ny komposition från material"),
+    ("Search effects and presets", "Sök effekter och förinställningar"),
+    ("Search", "Sök"),
+    ("(no composition)", "(ingen komposition)"),
+    ("per second", "per sekund"),
+    ("Waveform", "Vågform"),
+    ("steps", "steg"),
+    ("Building waveform…", "Skapar vågform…"),
+    ("No effects. Drag one from Effects & Presets.", "Inga effekter. Dra hit en från Effekter och förinställningar."),
+    (
+        "Click the ring to add a colour; Alt-click a stop (or drag it off) to remove it",
+        "Klicka på ringen för att lägga till en färg; Alt-klicka på ett färgstopp (eller dra bort det) för att ta bort det",
+    ),
+    (
+        "Start from a ready-made project. Opening a template makes an untitled copy.",
+        "Börja från ett färdigt projekt. När du öppnar en mall skapas en namnlös kopia.",
+    ),
+    ("Square Pixels", "Kvadratiska pixlar"),
+    ("Basic", "Grundläggande"),
+    ("3D Renderer", "3D-renderare"),
+    ("Black", "Svart"),
+    ("White", "Vit"),
+    ("Composition Settings", "Kompositionsinställningar"),
+    ("Force alphabetical order", "Tvinga bokstavsordning"),
+    ("Frame rate (fps)", "Bildfrekvens (bild/s)"),
+    ("Import Kind", "Importtyp"),
+    ("Delay (s)", "Delay (s)"),
+    ("Amount (%)", "Mängd (%)"),
+    ("Cascade (farther pins trail longer)", "Överlappande (nålar längre bort släpar efter mer)"),
+    ("Speed (%)", "Hastighet (%)"),
+    ("Use Draft Deformation", "Använd utkastdeformation"),
+    ("Show Mesh", "Visa nät"),
+    ("Scale X (%)", "Skala X (%)"),
+    ("Scale Y (%)", "Skala Y (%)"),
+    ("Rotation (degrees)", "Rotation (grader)"),
+    ("Move X", "Flytta X"),
+    ("Move Y", "Flytta Y"),
+    ("Position (pixels)", "Position (pixlar)"),
+    ("Position (percent of the composition)", "Position (procent av kompositionen)"),
+    ("Use Dimensions From", "Använd dimensioner från"),
+    ("Still Duration (seconds)", "Stillbildslängd (sekunder)"),
+    ("Add to Render Queue", "Lägg till i renderingskön"),
+    ("Sequence Layers", "Lägg lager i sekvens"),
+    ("Duration (seconds)", "Längd (sekunder)"),
+    ("Matte color (premultiplied)", "Mattefärg (förmultiplicerad)"),
+    ("Invert Alpha", "Invertera alfa"),
+    ("Assume this frame rate", "Anta denna bildfrekvens"),
+    ("Separate Fields", "Separera fält"),
+    ("Pixel Aspect Ratio", "Pixelbildförhållande"),
+    ("Loop (times)", "Loopa (antal gånger)"),
+    ("Assign Profile", "Tilldela profil"),
+    ("Preserve RGB", "Bevara RGB"),
+    ("Interpret As Linear Light", "Tolka som linjärt ljus"),
+    ("Start Timecode", "Starttidskod"),
+    ("Override Start", "Åsidosätt start"),
+    ("Time display style", "Tidsvisningsformat"),
+    ("Color engine", "Färgmotor"),
+    ("Working space", "Arbetsfärgrymd"),
+    ("Working gamma", "Arbetsgamma"),
+    ("Linearize working space", "Linjärisera arbetsfärgrymden"),
+    ("Blend colors using 1.0 gamma", "Blanda färger med gamma 1,0"),
+    ("Output color space", "Färgrymd för utdata"),
+    ("Video rendering and effects", "Videorendering och effekter"),
+    ("Time Span", "Tidsintervall"),
+    ("Blur (pixels before auto-trace)", "Oskärpa (pixlar före automatisk vektorisering)"),
+    ("Tolerance (pixels)", "Tolerans (pixlar)"),
+    ("Threshold (%)", "Tröskel (%)"),
+    ("Minimum Area (pixels)", "Minsta area (pixlar)"),
+    ("Corner Roundness (%)", "Hörnrundhet (%)"),
+    ("Apply To New Layer", "Använd på nytt lager"),
+    ("Sensitivity threshold (0–1, lower finds more)", "Känslighetströskel (0–1, lägre hittar fler)"),
+    ("Time field (empty: automatic)", "Tidsfält (tomt: automatiskt)"),
+    ("Video start (ISO date-time, hh:mm:ss, timecode; empty: file date)", "Videostart (ISO-datum och tid, hh:mm:ss, tidskod; tom: filens datum)"),
+    ("First sample at (comp seconds)", "Första sampel vid (sekunder i kompositionen)"),
+    ("Frame rate", "Bildfrekvens"),
+    ("Color (#rrggbb)", "Färg (#rrggbb)"),
+    ("Embed footage files", "Bädda in materialfiler"),
+    ("Embed up to (MB)", "Bädda in upp till (MB)"),
+    ("Orient Along Path", "Orientera längs banan"),
+    ("Orient Towards Camera", "Orientera mot kameran"),
+    ("Orient Towards Point of Interest", "Orientera mot intressepunkten"),
+    ("Single Composition", "Enskild komposition"),
+    ("Multiple Compositions", "Flera kompositioner"),
+    ("Dissolve Front Layer", "Övertona främre lager"),
+    ("Cross Dissolve Front and Back Layers", "Korsövertona främre och bakre lager"),
+    ("Interpret Straight - Unmatted", "Tolka som rak – utan matte"),
+    ("Interpret Premultiplied - Matted With Color", "Tolka som förmultiplicerad – mattad med färg"),
+    ("Upper Field First", "Övre fältet först"),
+    ("Lower Field First", "Undre fält först"),
+    ("Rec. 2020", "Rec. 2020"),
+    ("Use Source File Timecode", "Använd källfilens tidskod"),
+    ("Feet + Frames (35mm)", "Fot + bildrutor (35 mm)"),
+    ("Feet + Frames (16mm)", "Fot + bildrutor (16 mm)"),
+    ("Current Frame", "Aktuell bildruta"),
+    ("Work Area", "Arbetsområde"),
+    ("Create Markers", "Skapa markörer"),
+    ("Split Layers", "Dela lager"),
+    ("Split and Precompose", "Dela och förkomponera"),
+    ("All layers", "Alla lager"),
+    ("None (leave them out)", "Ingen (utelämna dem)"),
+    ("Nested sequences", "Kapslade sekvenser"),
+    ("Solid…", "Enfärgat lager…"),
+    ("Light…", "Ljus…"),
+    ("Camera…", "Kamera…"),
+    ("Null Object", "Nullobjekt"),
+    ("Shape Layer", "Formlager"),
+    ("Adjustment Layer", "Justeringslager"),
+    ("Layer Settings…", "Lagerinställningar…"),
+    ("Create Shapes from Vector Layer", "Skapa former från vektorlager"),
+    ("Create Shapes from Text", "Skapa former från text"),
+    ("Create Masks from Text", "Skapa masker från text"),
+    ("New Mask", "Ny mask"),
+    ("Center In View", "Centrera i vyn"),
+    ("Fit to Comp", "Anpassa till kompositionen"),
+    ("Flip Horizontal", "Vänd vågrätt"),
+    ("Flip Vertical", "Vänd lodrätt"),
+    ("Enable Time Remapping", "Aktivera tidsomvandling"),
+    ("Time-Reverse Layer", "Tidsomvänd lager"),
+    ("Freeze Frame", "Frys bildruta"),
+    ("Freeze On Last Frame", "Frys på sista bildrutan"),
+    ("Add Marker", "Lägg till markör"),
+    ("Bring Layer to Front", "Lägg lager överst"),
+    ("Bring Layer Forward", "Flytta fram lager"),
+    ("Send Layer Backward", "Flytta bak lager"),
+    ("Send Layer to Back", "Lägg lager underst"),
+    ("Pre-compose…", "Förkomponera…"),
+    ("Split Layer", "Dela lager"),
+    ("Layer Style Options...", "Lagerstilsalternativ..."),
+    ("Convert to Editable Styles", "Konvertera till redigerbara stilar"),
+    ("Show All", "Visa alla"),
+    ("Remove All", "Ta bort alla"),
+    ("Separate Dimensions", "Separera dimensioner"),
+    ("Add Property to Essential Graphics", "Lägg till egenskap i Grundläggande grafik"),
+    ("Continuous Bezier", "Kontinuerlig bezier"),
+    ("Auto Bezier", "Automatisk bezier"),
+    ("Lock To Time", "Lås till tid"),
+    ("Rove Across Time", "Flytande över tid"),
+    ("Anchor Point", "Ankarpunkt"),
+    ("All Transform Properties", "Alla transformeringsegenskaper"),
+    ("Line Anchor", "Radankare"),
+    ("Line Spacing", "Radavstånd"),
+    ("Character Offset", "Teckenförskjutning"),
+    ("Character Value", "Teckenvärde"),
+    ("Fill Color: RGB", "Fyllningsfärg: RGB"),
+    ("Fill Color: Hue", "Fyllningsfärg: nyans"),
+    ("Fill Color: Saturation", "Fyllningsfärg: mättnad"),
+    ("Fill Color: Brightness", "Fyllningsfärg: ljusstyrka"),
+    ("Fill Color: Opacity", "Fyllningsfärg: opacitet"),
+    ("Stroke Color: RGB", "Konturfärg: RGB"),
+    ("Stroke Color: Hue", "Konturfärg: nyans"),
+    ("Stroke Color: Saturation", "Konturfärg: mättnad"),
+    ("Stroke Color: Brightness", "Konturfärg: ljusstyrka"),
+    ("Stroke Color: Opacity", "Konturfärg: opacitet"),
+    ("Stroke Width", "Konturbredd"),
+    ("Front: Color", "Framsida: färg"),
+    ("Bevel: Color", "Fasning: Färg"),
+    ("Side: Color", "Sida: färg"),
+    ("Back: Color", "Baksida: Färg"),
+    ("Effect Controls", "Effektkontroller"),
+    ("Effects & Presets", "Effekter och förinställningar"),
+    ("Motion Sketch", "Rörelseskiss"),
+    ("Render Queue", "Renderingskö"),
+    ("Mask Interpolation", "Maskinterpolering"),
+    ("Script Console", "Skriptkonsol"),
+    ("Essential Graphics", "Grundläggande grafik"),
+    ("ScriptUI Panel", "ScriptUI-panel"),
+    ("Lumetri Scopes", "Lumetri-scope"),
+    ("Media Browser", "Mediebläddrare"),
+    ("Content-Aware Fill", "Innehållsmedveten fyllning"),
+    ("Create Nulls From Paths", "Skapa nullobjekt från banor"),
+    ("VR Comp Editor", "VR-kompositionsredigerare"),
+    ("Media Duration", "Medielängd"),
+    ("File Path", "Sökväg"),
+    ("Interpret Footage", "Tolka material"),
+    ("Create a new Folder", "Skapa en ny mapp"),
+    ("Create a new Composition", "Skapa en ny komposition"),
+    ("First Frame", "Första bildrutan"),
+    ("Previous Frame", "Föregående bildruta"),
+    ("Next Frame", "Nästa bildruta"),
+    ("Last Frame", "Sista bildrutan"),
+    ("Name (A–Z)", "Namn (A–Ö)"),
+    ("Merged PRs", "Sammanslagna PR:er"),
+    ("Lines added", "Tillagda rader"),
+    ("Lines deleted", "Borttagna rader"),
+    ("Line delta", "Raddifferens"),
+    ("Binary assets added", "Binära resurser tillagda"),
+    ("Binary assets removed", "Binära resurser borttagna"),
+    ("First commit", "Första commit"),
+    ("Last commit", "Senaste commit"),
+    ("Display name", "Visningsnamn"),
+    ("Real name", "Riktigt namn"),
+    ("ArtCraft website", "ArtCrafts webbplats"),
+    ("Source code on GitHub", "Källkod på GitHub"),
+    ("Preset Name", "Namn på förinställning"),
+    ("Lock Aspect Ratio", "Lås proportioner"),
+    ("Frame Rate presets", "Förinställningar för bildfrekvens"),
+    ("Background Color", "Bakgrundsfärg"),
+    ("Shutter Angle", "Slutarvinkel"),
+    ("Shutter Phase", "Slutarfas"),
+    ("Samples Per Frame", "Samplingar per bildruta"),
+    ("Adaptive Sample Limit", "Adaptiv samplingsgräns"),
+    ("X and Y", "X och Y"),
+    ("X only", "Endast X"),
+    ("Y only", "Endast Y"),
+    ("Track Camera", "Spåra kamera"),
+    ("Warp Stabilizer", "Warp Stabilizer"),
+    ("Track Motion", "Spåra rörelse"),
+    ("Stabilize Motion", "Stabilisera rörelse"),
+    ("Motion Source:", "Rörelsekälla:"),
+    ("Current Track:", "Aktuell spårning:"),
+    ("Track Type:", "Spårtyp:"),
+    ("Motion Target:", "Rörelsemål:"),
+    ("Track Mask:", "Spåra mask:"),
+    ("Analyze forward", "Analysera framåt"),
+    ("Analyze backward", "Analysera bakåt"),
+    ("Continue Tracking", "Fortsätt spårning"),
+    ("Stop Tracking", "Stoppa spårning"),
+    ("Adapt Feature", "Anpassa detalj"),
+    ("Extrapolate Motion", "Extrapolera rörelse"),
+    ("Attach Point", "Fästpunkt"),
+    ("Track Name", "Spårnamn"),
+    ("Motion Tracker Options", "Alternativ för rörelsespårare"),
+    ("Motion Tracker Apply Options", "Tillämpningsalternativ för rörelsespårare"),
+    ("Edit Value Graph", "Redigera värdediagram"),
+    ("Edit Speed Graph", "Redigera hastighetsdiagram"),
+    ("Show Reference Graph", "Visa referensdiagram"),
+    (
+        "Auto-Select Graph Type (speed graph for spatial properties, else value graph)",
+        "Välj diagramtyp automatiskt (hastighetsdiagram för rumsliga egenskaper, annars värdediagram)",
+    ),
+    ("Auto-zoom graph height", "Zooma diagramhöjden automatiskt"),
+    ("Fit all graphs to view", "Anpassa alla kurvor till vyn"),
+    ("Fit selection to view", "Anpassa markeringen till vyn"),
+    ("Snap (key drags snap to the current time and other keys)", "Fäst (nyckelbildrutor som dras fästs mot aktuell tid och andra nyckelbildrutor)"),
+    ("Show Transform Box when multiple keys are selected", "Visa transformeringsruta när flera nyckelbildrutor är markerade"),
+    ("Separate Dimensions (Position)", "Separera dimensioner (position)"),
+    ("Convert selected keyframes to Hold", "Konvertera markerade nyckelbildrutor till Håll"),
+    ("Convert selected keyframes to Linear", "Konvertera markerade nyckelbildrutor till Linjär"),
+    ("Convert selected keyframes to Auto Bezier", "Konvertera markerade nyckelbildrutor till Automatisk bezier"),
+    ("Easy Ease (F9)", "Mjukt in och ut (F9)"),
+    ("Easy Ease In (Shift+F9)", "Mjukt in (Shift+F9)"),
+    ("Easy Ease Out (Ctrl+Shift+F9)", "Mjukt ut (Ctrl+Shift+F9)"),
+    ("Spatial Path", "Rumslig bana"),
+    ("Temporal Path", "Temporal bana"),
+    ("All the Same", "Alla likadana"),
+    ("All Independently", "Alla oberoende av varandra"),
+    ("Noise Type:", "Brustyp:"),
+    ("Apply To:", "Använd på:"),
+    ("Temporal Graph", "Temporalt diagram"),
+    ("Keyframe Rate:", "Nyckelbildrutefrekvens:"),
+    ("Capture speed at:", "Spela in hastighet vid:"),
+    ("Start Capture", "Starta inspelning"),
+    ("Cancel Capture", "Avbryt inspelning"),
+    ("Small Caps", "Kapitäler"),
+    ("All Small Caps", "Alla som kapitäler"),
+    ("Superscript / Superior", "Upphöjd / superior"),
+    ("Subscript / Inferior", "Nedsänkt / inferior"),
+    ("Standard Ligatures", "Standardligaturer"),
+    ("Discretionary Ligatures", "Valfria ligaturer"),
+    ("Contextual Alternates", "Kontextuella alternativ"),
+    ("Stylistic Alternates", "Stilistiska alternativ"),
+    ("Titling Alternates", "Rubrikalternativ"),
+    ("Default Figure Style", "Standardfigurstil"),
+    ("Tabular Lining", "Tabellsiffror, versala"),
+    ("Proportional Oldstyle", "Proportionella medievalsiffror"),
+    ("Proportional Lining", "Proportionella versalsiffror"),
+    ("Tabular Oldstyle", "Medievalsiffror i tabellbredd"),
+    ("Fill Over Stroke", "Fyllning över kontur"),
+    ("Stroke Over Fill", "Kontur över fyllning"),
+    ("Stroke order", "Konturordning"),
+    ("Single-line Composer", "Enradssättare"),
+    ("Every-line Composer", "Flerradssättning"),
+    ("Text direction", "Textriktning"),
+    ("Recently Used", "Senast använda"),
+    ("User Presets", "Användarförinställningar"),
+    ("Remove from Favorites", "Ta bort från favoriter"),
+    ("Show Animation Presets", "Visa animeringsförinställningar"),
+    ("    Refresh List", "    Uppdatera listan"),
+    ("    Clear Recently Used", "    Rensa senast använda"),
+    ("Show 32 bpc Effects Only", "Visa endast 32 bpc-effekter"),
+    ("Show GPU Accelerated Effects Only", "Visa endast GPU-accelererade effekter"),
+    ("Show Effects for All Color Depths", "Visa effekter för alla färgdjup"),
+    ("* Animation Presets", "* Animeringsförinställningar"),
+    ("Select a layer to apply to", "Markera ett lager att tillämpa på"),
+    ("Alpha Expansion:", "Alfaexpansion:"),
+    ("Fill Method:", "Fyllningsmetod:"),
+    ("Edge Blend", "Kantblandning"),
+    ("Entire Duration", "Hela längden"),
+    ("Reference Frame:", "Referensbildruta:"),
+    ("Use Current Time", "Använd aktuell tid"),
+    ("Generate Fill Layer", "Generera fyllningslager"),
+    ("Lighting Correction:", "Belysningskorrigering:"),
+    ("Create Text and Camera", "Skapa text och kamera"),
+    ("Create Solid and Camera", "Skapa enfärgat lager och kamera"),
+    ("Create Null and Camera", "Skapa nullobjekt och kamera"),
+    ("Create Shadow Catcher, Camera and Light", "Skapa skuggfångare, kamera och ljus"),
+    ("Unable to solve camera", "Det gick inte att beräkna kameran"),
+    ("Waiting to solve", "Väntar på beräkning"),
+    ("track point", "spårpunkt"),
+    ("Ruler zero point", "Linjalens nollpunkt"),
+    ("Vertical ruler", "Vertikal linjal"),
+    ("Horizontal ruler", "Vågrät linjal"),
+    ("Viewer controls", "Visningskontroller"),
+    ("Resolution/Down Sample Factor", "Upplösning/nedsamplingsfaktor"),
+    ("Adjust Exposure", "Justera exponering"),
+    ("Snapshot taken", "Ögonblicksbild tagen"),
+    ("Fast Previews", "Snabba förhandsgranskningar"),
+    ("3D View", "3D-vy"),
+    ("Current time", "Aktuell tid"),
+    ("Layer Transform", "Lagertransformering"),
+    ("Reset Transform", "Återställ transformering"),
+    ("Text Animation", "Textanimering"),
+    ("Text Animation Presets", "Förinställningar för textanimering"),
+    ("EffectCraft on getartcraft.com", "EffectCraft på getartcraft.com"),
+    ("Small Screen", "Liten skärm"),
+    ("Tool Creates Shape", "Verktyget skapar form"),
+    ("Tool Creates Mask", "Verktyget skapar mask"),
+    ("Blend Mode", "Blandningsläge"),
+    ("Show mesh", "Visa nät"),
+    ("Record Options...", "Inspelningsalternativ..."),
+    ("Export Scene to Blender...", "Exportera scen till Blender..."),
+    (
+        "Hands-on tutorials that run inside EffectCraft. Do each step yourself, or press Show me.",
+        "Praktiska självstudier som körs i EffectCraft. Gör varje steg själv eller tryck på Visa mig.",
+    ),
+    (
+        "JavaScript with the After Effects scripting object model — try app.project.numItems",
+        "JavaScript med objektmodellen för skript i After Effects – prova app.project.numItems",
+    ),
+    ("Label {} color", "Färg för etikett {}"),
+    ("Label {} name", "Namn på etikett {}"),
+    ("Output file name template", "Mall för utdatafilens namn"),
+    ("Output file: {}", "Utdatafil: {}"),
+    ("Preview", "Förhandsgranska"),
+    ("Stroke width presets", "Förinställda konturbredder"),
+    ("Select an item to see its details", "Markera ett objekt för att se dess detaljer"),
+    ("A/V Features", "A/V-funktioner"),
+    ("Keys", "Nycklar"),
+    ("Layer Name", "Lagernamn"),
+    ("Source Name", "Källnamn"),
+    ("Switches", "Växlar"),
+    ("Modes", "Lägen"),
+    ("Track Matte", "Track matte"),
+    ("Parent & Link", "Överordnad och länk"),
+    ("In", "In"),
+    ("Out", "Ut"),
+    ("Render every n-th pixel", "Rendera var n:te pixel"),
+    ("Workspace", "Arbetslayout"),
+    ("Rename to", "Nytt namn"),
+    ("Open", "Öppna"),
+    ("Custom Resolution", "Anpassad upplösning"),
+    ("Panel Background Color", "Panelens bakgrundsfärg"),
+    ("New Workspace", "Ny arbetslayout"),
+    ("Edit Workspaces", "Redigera arbetslayouter"),
+    ("A script wants to open a file", "Ett skript vill öppna en fil"),
+    ("Null Settings", "Null-inställningar"),
+    (
+        "Change the frame rate, alpha and start frame later with File ▸ Interpret Footage.",
+        "Ändra bildfrekvens, alfa och startbildruta senare med Arkiv ▸ Tolka material.",
+    ),
+    ("Page", "Sida"),
+    ("Smoothing", "Utjämning"),
+    ("Top", "Överkant"),
+    ("Mode", "Läge"),
+    ("Frame", "Bildruta"),
+    ("Orientation", "Orientering"),
+    ("Create", "Skapa"),
+    ("Overlap", "Överlappning"),
+    ("Transition", "Övergång"),
+    ("Depth", "Djup"),
+    ("HDR on SDR displays and outputs", "HDR på SDR-skärmar och -utgångar"),
+    ("Invert", "Invertera"),
+    ("Action", "Åtgärd"),
+    ("Data", "Data"),
+    (
+        "Writes Final Cut Pro XML (.xml), which Premiere Pro opens with File ▸ Import. Native .prproj files are not written.",
+        "Skriver Final Cut Pro XML (.xml), som Premiere Pro öppnar med Arkiv ▸ Importera. Ursprungliga .prproj-filer skrivs inte.",
+    ),
+    ("File", "Fil"),
+    ("Format", "Format"),
+    ("Pre-render (ProRes 4444)", "Förrendera (ProRes 4444)"),
+    ("Precomps", "Förkompositioner"),
+    ("Description", "Beskrivning"),
+    ("Category", "Kategori"),
+    ("Use the sRGB curve (ignore Gamma)", "Använd sRGB-kurvan (ignorera gamma)"),
+    ("ICC profile (replaces the numbers)", "ICC-profil (ersätter siffrorna)"),
+    ("Rectangle", "Rektangel"),
+    ("Ellipse", "Ellips"),
+    ("Embedded / sRGB", "Inbäddad / sRGB"),
+    ("Timecode", "Tidskod"),
+    ("Frames", "Bildrutor"),
+    ("Clip", "Klipp"),
+    ("Compand", "Kompander"),
+    ("Luminance", "Luminans"),
+    ("CMX 3600 EDL (.edl, V1 only)", "CMX 3600 EDL (.edl, endast V1)"),
+    ("OMF (.omf, audio)", "OMF (.omf, ljud)"),
+    ("Layers Premiere can't show (text, shapes, effects…)", "Lager som Premiere inte kan visa (text, former, effekter…)"),
+    ("Pre-render", "Förrendera"),
+    ("Puppet Follow-Through", "Dockans eftersläpning"),
+    ("Puppet Record Options", "Inspelningsalternativ för docka"),
+    ("Free Transform Points", "Fri transformering av punkter"),
+    ("Mask Shape", "Maskform"),
+    ("Auto-Orientation", "Automatisk orientering"),
+    ("Go to Time", "Gå till tid"),
+    ("Add Guide", "Lägg till stödlinje"),
+    ("Add Percentage Guide", "Lägg till stödlinje i procent"),
+    ("New Composition from Selection", "Ny komposition från markering"),
+    ("Project Settings", "Projektinställningar"),
+    ("Auto-trace", "Autokonturera"),
+    ("Scene Edit Detection", "Identifiering av scensnitt"),
+    ("Align Video to Data", "Justera video efter data"),
+    ("Export Adobe Premiere Pro Project", "Exportera Adobe Premiere Pro-projekt"),
+    ("New Placeholder", "Ny platshållare"),
+    ("Solid Settings", "Inställningar för enfärgad yta"),
+    ("Save as Template", "Spara som mall"),
+    ("My Custom RGB", "Min anpassade RGB"),
+    ("Start (s)", "Start (s)"),
+    ("Duration (s)", "Längd (s)"),
+    ("Bottom", "Nederkant"),
+    ("Bitrate (kbps)", "Bithastighet (kbit/s)"),
+    ("Frames between key frames (0 = every 2 s)", "Bildrutor mellan nyckelbildrutor (0 = varannan sekund)"),
+    ("Remove this object's strokes", "Ta bort objektets penseldrag"),
+    ("Object {}", "Objekt {}"),
+    ("Object {} ({})", "Objekt {} ({})"),
+    ("Source", "Källa"),
+    ("Active Camera ({})", "Aktiv kamera ({})"),
 ];
 
 const TRADITIONAL_CHINESE: &[(&str, &str)] = &[
+    ("Click to sample color", "按一下以取樣顏色"),
     ("Appearance Settings…", "外觀設定…"),
     ("Add to favorites", "加入最愛"),
     ("Remove from favorites", "從最愛移除"),
@@ -1677,6 +3707,7 @@ const TRADITIONAL_CHINESE: &[(&str, &str)] = &[
     ("Add:", "添加："),
     ("Adjust Exposure (stops)", "調整曝光（光圈級數）"),
     ("Adjust composition duration to the time span of the selected layers", "將合成時長調整為所選圖層的時間範圍"),
+    ("Advanced", "進階"),
     ("Advanced 3D", "高級 3D"),
     ("Align Layers to:", "將圖層對齊到："),
     ("All six face cameras turn together; the scene is not changed.", "六個面攝影機一起旋轉；場景不會改變。"),
@@ -1779,7 +3810,6 @@ const TRADITIONAL_CHINESE: &[(&str, &str)] = &[
     ("Duration:", "持續時間："),
     ("Edit Gradient…", "編輯漸變…"),
     ("Edit Target: {}", "編輯目標：{}"),
-    ("Edit in the Timeline", "在時間軸中編輯"),
     ("EffectCraft didn't quit normally last time.", "EffectCraft 上次未正常結束。"),
     ("Effects", "效果"),
     ("Effects & Presets options", "效果和預設集選項"),
@@ -1906,6 +3936,7 @@ const TRADITIONAL_CHINESE: &[(&str, &str)] = &[
     ("No layer selected", "未選取圖層"),
     ("No matching effects or presets", "沒有匹配的效果或預設集"),
     ("No matching fonts", "沒有符合的字體"),
+    ("Rescan Fonts", "重新掃描字型"),
     ("Variable fonts only", "僅可變字型"),
     ("No model credits were built into this copy.", "此副本未內置模型致謝。"),
     ("No nested compositions", "沒有嵌套合成"),
@@ -1939,7 +3970,9 @@ const TRADITIONAL_CHINESE: &[(&str, &str)] = &[
     ("Overlay", "疊加"),
     ("Parameter Name:", "參數名稱："),
     ("Parent pick whip: drag onto a layer", "上層拾取線：拖到圖層上"),
+    ("Track Matte pick whip: drag onto a layer", "軌道遮罩拾取線：拖到圖層上"),
     ("Pixel Aspect Ratio:", "像素長寬比例："),
+    ("Play/Stop", "播放/停止"),
     ("Playing on Video Preview", "在視訊預覽中播放"),
     ("Post-Render Action: {}", "算圖後動作：{}"),
     ("Preserve frame rate when nested or in render queue", "嵌套或在算圖佇列中時保留影格速率"),
@@ -2327,11 +4360,376 @@ const TRADITIONAL_CHINESE: &[(&str, &str)] = &[
     ("Total Offset", "總偏移"),
     ("Per Layer", "每個圖層"),
     ("Track", "追蹤"),
+    ("Selection Tool", "選取工具"),
+    ("Hand Tool", "手形工具"),
+    ("Zoom Tool", "縮放工具"),
+    ("Orbit Around Cursor Tool", "繞行攝影機工具"),
+    ("Pan Under Cursor Tool", "平移攝影機工具"),
+    ("Dolly Towards Cursor Tool", "推拉攝影機工具"),
+    ("Rotation Tool", "旋轉工具"),
+    ("Pan Behind (Anchor Point) Tool", "向後平移工具"),
+    ("Rectangle Tool", "矩形工具"),
+    ("Rounded Rectangle Tool", "圓角矩形工具"),
+    ("Ellipse Tool", "橢圓工具"),
+    ("Polygon Tool", "多邊形工具"),
+    ("Star Tool", "星形工具"),
+    ("Pen Tool", "筆型工具"),
+    ("Add Vertex Tool", "添加頂點工具"),
+    ("Delete Vertex Tool", "刪除頂點工具"),
+    ("Convert Vertex Tool", "轉換頂點工具"),
+    ("Mask Feather Tool", "遮色片羽化工具"),
+    ("Horizontal Type Tool", "橫排文字工具"),
+    ("Vertical Type Tool", "垂直文字工具"),
+    ("Brush Tool", "筆刷工具"),
+    ("Clone Stamp Tool", "仿製圖章工具"),
+    ("Eraser Tool", "橡皮擦工具"),
+    ("Roto Brush Tool", "Roto 筆刷工具"),
+    ("Refine Edge Tool", "調整邊緣工具"),
+    ("Object Matte Tool", "物件遮色片工具"),
+    ("Puppet Position Pin Tool", "人偶位置控點工具"),
+    ("Puppet Starch Pin Tool", "人偶撲粉控點工具"),
+    ("Puppet Bend Pin Tool", "人偶彎曲控點工具"),
+    ("Puppet Advanced Pin Tool", "人偶高級控點工具"),
+    ("Puppet Overlap Pin Tool", "人偶重疊控點工具"),
+    ("Shortcut", "快速鍵"),
+    ("Range", "範圍"),
+    ("Play From", "從下列位置播放"),
+    ("Frame Rate", "影格速率"),
+    ("Resolution", "解析度"),
+    ("Overlays", "覆疊"),
+    ("Layer Controls", "圖層控制"),
+    ("Loop", "循環"),
+    ("Cache Before Playback", "播放前快取"),
+    ("Pre-roll", "預卷"),
+    ("Post-roll", "後卷"),
+    ("If caching, play cached frames", "快取時播放已快取影格"),
+    ("Apply", "套用"),
+    ("Analyze", "分析"),
+    ("Create Camera", "建立攝影機"),
+    ("Add Point", "添加點"),
+    ("Remove Point", "移除點"),
+    ("Render", "算圖"),
+    ("Save Current as Template…", "將目前項目存為範本…"),
+    ("New Composition From Footage", "從素材新增合成"),
+    ("Search effects and presets", "搜尋效果與預設"),
+    ("Search project", "搜尋專案"),
+    ("Search", "搜尋"),
+    ("(no composition)", "沒有合成"),
+    ("per second", "每秒"),
+    ("Waveform", "波形"),
+    ("steps", "步驟"),
+    ("Building waveform…", "正在產生波形…"),
+    ("No effects. Drag one from Effects & Presets.", "沒有效果。從效果與預設集中拖入一個。"),
+    ("Click the ring to add a colour; Alt-click a stop (or drag it off) to remove it", "點擊色環新增顏色；按住 Alt 點擊色標（或將其拖出）即可移除"),
+    ("Start from a ready-made project. Opening a template makes an untitled copy.", "從現成專案開始。開啟範本會建立一份未命名副本。"),
+    ("Square Pixels", "方形像素"),
+    ("Basic", "基本"),
+    ("3D Renderer", "3D 算圖引擎"),
+    ("Black", "黑色"),
+    ("White", "白色"),
+    ("Composition Settings", "合成設置"),
+    ("Force alphabetical order", "強制依字母順序"),
+    ("Frame rate (fps)", "幀率 (fps)"),
+    ("Import Kind", "匯入類型"),
+    ("Delay (s)", "延遲 (秒)"),
+    ("Amount (%)", "數量 (%)"),
+    ("Cascade (farther pins trail longer)", "階層 (越遠的圖釘延遲越長)"),
+    ("Speed (%)", "速度 (%)"),
+    ("Use Draft Deformation", "使用草稿變形"),
+    ("Show Mesh", "顯示網格"),
+    ("Scale X (%)", "X 縮放 (%)"),
+    ("Scale Y (%)", "Y 縮放 (%)"),
+    ("Rotation (degrees)", "旋轉 (度)"),
+    ("Move X", "移動 X"),
+    ("Move Y", "移動 Y"),
+    ("Position (pixels)", "位置 (像素)"),
+    ("Position (percent of the composition)", "位置 (合成百分比)"),
+    ("Use Dimensions From", "尺寸來源"),
+    ("Still Duration (seconds)", "靜態影像持續時間 (秒)"),
+    ("Add to Render Queue", "新增至轉譯佇列"),
+    ("Sequence Layers", "序列圖層"),
+    ("Duration (seconds)", "持續時間 (秒)"),
+    ("Matte color (premultiplied)", "遮罩顏色 (預乘)"),
+    ("Invert Alpha", "反轉 Alpha"),
+    ("Assume this frame rate", "以此幀率為準"),
+    ("Separate Fields", "分離場"),
+    ("Pixel Aspect Ratio", "像素長寬比"),
+    ("Loop (times)", "循環 (次)"),
+    ("Assign Profile", "指定設定檔"),
+    ("Preserve RGB", "保留 RGB"),
+    ("Interpret As Linear Light", "解譯為線性光"),
+    ("Start Timecode", "開始時間碼"),
+    ("Override Start", "覆寫開始"),
+    ("Time display style", "時間顯示樣式"),
+    ("Color engine", "色彩引擎"),
+    ("Working space", "工作空間"),
+    ("Working gamma", "工作 Gamma"),
+    ("Linearize working space", "線性化工作空間"),
+    ("Blend colors using 1.0 gamma", "使用 1.0 Gamma 混合顏色"),
+    ("Output color space", "輸出色彩空間"),
+    ("Video rendering and effects", "視訊轉譯與效果"),
+    ("Time Span", "時間範圍"),
+    ("Blur (pixels before auto-trace)", "模糊 (自動描摹前的像素)"),
+    ("Tolerance (pixels)", "容差 (像素)"),
+    ("Threshold (%)", "閾值 (%)"),
+    ("Minimum Area (pixels)", "最小區域 (像素)"),
+    ("Corner Roundness (%)", "角圓度 (%)"),
+    ("Apply To New Layer", "套用至新圖層"),
+    ("Sensitivity threshold (0–1, lower finds more)", "靈敏度閾值 (0–1，越低找到的越多)"),
+    ("Time field (empty: automatic)", "時間欄位 (空白: 自動)"),
+    ("Video start (ISO date-time, hh:mm:ss, timecode; empty: file date)", "視訊開始 (ISO 日期時間、hh:mm:ss、時間碼；空白: 檔案日期)"),
+    ("First sample at (comp seconds)", "首個取樣位置 (合成秒)"),
+    ("Frame rate", "幀率"),
+    ("Color (#rrggbb)", "顏色 (#rrggbb)"),
+    ("Embed footage files", "內嵌素材檔案"),
+    ("Embed up to (MB)", "內嵌上限 (MB)"),
+    ("Orient Along Path", "沿路徑定向"),
+    ("Orient Towards Camera", "朝向攝影機"),
+    ("Orient Towards Point of Interest", "朝向目標點"),
+    ("Single Composition", "單一合成"),
+    ("Multiple Compositions", "多個合成"),
+    ("Dissolve Front Layer", "溶解前層"),
+    ("Cross Dissolve Front and Back Layers", "交叉溶解前後層"),
+    ("Interpret Straight - Unmatted", "解譯為直接 (未遮罩)"),
+    ("Interpret Premultiplied - Matted With Color", "解譯為預乘 (以顏色遮罩)"),
+    ("Upper Field First", "上場優先"),
+    ("Lower Field First", "下場優先"),
+    ("Rec. 2020", "Rec. 2020"),
+    ("Use Source File Timecode", "使用來源檔案時間碼"),
+    ("Feet + Frames (35mm)", "英尺 + 幀 (35mm)"),
+    ("Feet + Frames (16mm)", "英尺 + 幀 (16mm)"),
+    ("Current Frame", "目前幀"),
+    ("Work Area", "工作區域"),
+    ("Create Markers", "建立標記"),
+    ("Split Layers", "分割圖層"),
+    ("Split and Precompose", "分割並預合成"),
+    ("All layers", "所有圖層"),
+    ("None (leave them out)", "無 (不含)"),
+    ("Nested sequences", "巢狀序列"),
+    ("Solid…", "純色…"),
+    ("Light…", "燈光…"),
+    ("Camera…", "攝影機…"),
+    ("Null Object", "空物件"),
+    ("Shape Layer", "形狀圖層"),
+    ("Adjustment Layer", "調整圖層"),
+    ("Layer Settings…", "圖層設定…"),
+    ("Create Shapes from Vector Layer", "從向量圖層建立形狀"),
+    ("Create Shapes from Text", "從文字建立形狀"),
+    ("Create Masks from Text", "從文字建立遮罩"),
+    ("New Mask", "新增遮罩"),
+    ("Center In View", "在視圖中置中"),
+    ("Fit to Comp", "符合合成"),
+    ("Flip Horizontal", "水平翻轉"),
+    ("Flip Vertical", "垂直翻轉"),
+    ("Enable Time Remapping", "啟用時間重對應"),
+    ("Time-Reverse Layer", "時間反轉圖層"),
+    ("Freeze Frame", "凍結幀"),
+    ("Freeze On Last Frame", "在最後一幀凍結"),
+    ("Add Marker", "新增標記"),
+    ("Bring Layer to Front", "圖層移至最上層"),
+    ("Bring Layer Forward", "圖層上移一層"),
+    ("Send Layer Backward", "圖層下移一層"),
+    ("Send Layer to Back", "圖層移至最下層"),
+    ("Pre-compose…", "預合成…"),
+    ("Split Layer", "分割圖層"),
+    ("Layer Style Options...", "圖層樣式選項..."),
+    ("Convert to Editable Styles", "轉換為可編輯樣式"),
+    ("Show All", "全部顯示"),
+    ("Remove All", "全部移除"),
+    ("Separate Dimensions", "分離維度"),
+    ("Add Property to Essential Graphics", "將屬性新增至基本圖形"),
+    ("Continuous Bezier", "連續貝茲"),
+    ("Auto Bezier", "自動貝茲"),
+    ("Lock To Time", "鎖定至時間"),
+    ("Rove Across Time", "跨時間漫遊"),
+    ("Anchor Point", "錨點"),
+    ("All Transform Properties", "所有變換屬性"),
+    ("Line Anchor", "行錨點"),
+    ("Line Spacing", "行距"),
+    ("Character Offset", "字元偏移"),
+    ("Character Value", "字元值"),
+    ("Fill Color: RGB", "填色: RGB"),
+    ("Fill Color: Hue", "填色: 色相"),
+    ("Fill Color: Saturation", "填色: 飽和度"),
+    ("Fill Color: Brightness", "填色: 亮度"),
+    ("Fill Color: Opacity", "填色: 不透明度"),
+    ("Stroke Color: RGB", "筆畫顏色: RGB"),
+    ("Stroke Color: Hue", "筆畫顏色: 色相"),
+    ("Stroke Color: Saturation", "筆畫顏色: 飽和度"),
+    ("Stroke Color: Brightness", "筆畫顏色: 亮度"),
+    ("Stroke Color: Opacity", "筆畫顏色: 不透明度"),
+    ("Stroke Width", "筆畫寬度"),
+    ("Front: Color", "前面: 顏色"),
+    ("Bevel: Color", "斜角: 顏色"),
+    ("Side: Color", "側面: 顏色"),
+    ("Back: Color", "背面: 顏色"),
+    ("Effect Controls", "效果控制項"),
+    ("Effects & Presets", "效果與預設集"),
+    ("Motion Sketch", "運動草圖"),
+    ("Render Queue", "轉譯佇列"),
+    ("Mask Interpolation", "遮罩插補"),
+    ("Script Console", "指令碼主控台"),
+    ("Essential Graphics", "基本圖形"),
+    ("ScriptUI Panel", "ScriptUI 面板"),
+    ("Lumetri Scopes", "Lumetri 示波器"),
+    ("Media Browser", "媒體瀏覽器"),
+    ("Content-Aware Fill", "內容感知填色"),
+    ("Create Nulls From Paths", "從路徑建立空物件"),
+    ("VR Comp Editor", "VR 合成編輯器"),
+    ("Media Duration", "媒體持續時間"),
+    ("File Path", "檔案路徑"),
+    ("Interpret Footage", "解譯素材"),
+    ("Create a new Folder", "新增資料夾"),
+    ("Create a new Composition", "新增合成"),
+    ("First Frame", "第一幀"),
+    ("Previous Frame", "上一幀"),
+    ("Next Frame", "下一幀"),
+    ("Last Frame", "最後一幀"),
+    ("Name (A–Z)", "名稱 (A–Z)"),
+    ("Merged PRs", "已合併 PR"),
+    ("Lines added", "新增的行數"),
+    ("Lines deleted", "刪除的行數"),
+    ("Line delta", "行數差異"),
+    ("Binary assets added", "新增的二進位資源"),
+    ("Binary assets removed", "刪除的二進位資源"),
+    ("First commit", "首次提交"),
+    ("Last commit", "最近提交"),
+    ("Display name", "顯示名稱"),
+    ("Real name", "真實姓名"),
+    ("ArtCraft website", "ArtCraft 網站"),
+    ("Source code on GitHub", "GitHub 上的原始碼"),
+    ("Preset Name", "預設集名稱"),
+    ("Save Preset…", "儲存預設集…"),
+    ("Delete Preset", "刪除預設集"),
+    ("Lock Aspect Ratio", "鎖定長寬比"),
+    ("Frame Rate presets", "幀率預設集"),
+    ("Background Color", "背景顏色"),
+    ("Shutter Angle", "快門角度"),
+    ("Shutter Phase", "快門相位"),
+    ("Samples Per Frame", "每幀取樣數"),
+    ("Adaptive Sample Limit", "自適應取樣上限"),
+    ("X and Y", "X 和 Y"),
+    ("X only", "僅 X"),
+    ("Y only", "僅 Y"),
+    ("Track Camera", "追蹤攝影機"),
+    ("Warp Stabilizer", "彎曲穩定器"),
+    ("Track Motion", "追蹤運動"),
+    ("Stabilize Motion", "穩定運動"),
+    ("Motion Source:", "運動來源:"),
+    ("Current Track:", "目前追蹤:"),
+    ("Track Type:", "追蹤類型:"),
+    ("Motion Target:", "運動目標:"),
+    ("Track Mask:", "追蹤遮罩:"),
+    ("Analyze forward", "向前分析"),
+    ("Analyze backward", "向後分析"),
+    ("Continue Tracking", "繼續追蹤"),
+    ("Stop Tracking", "停止追蹤"),
+    ("Adapt Feature", "自適應特徵"),
+    ("Extrapolate Motion", "外推運動"),
+    ("Attach Point", "附加點"),
+    ("Track Name", "追蹤名稱"),
+    ("Motion Tracker Options", "運動追蹤器選項"),
+    ("Motion Tracker Apply Options", "運動追蹤器套用選項"),
+    ("Edit Value Graph", "編輯數值圖表"),
+    ("Edit Speed Graph", "編輯速度圖表"),
+    ("Show Reference Graph", "顯示參考圖表"),
+    ("Auto-Select Graph Type (speed graph for spatial properties, else value graph)", "自動選擇圖表類型 (空間屬性用速度圖表，否則用數值圖表)"),
+    ("Auto-zoom graph height", "自動縮放圖表高度"),
+    ("Fit all graphs to view", "使所有圖表符合視圖"),
+    ("Fit selection to view", "使所選內容符合視圖"),
+    ("Snap (key drags snap to the current time and other keys)", "貼齊 (關鍵影格拖曳時貼齊目前時間和其他關鍵影格)"),
+    ("Show Transform Box when multiple keys are selected", "選擇多個關鍵影格時顯示變換框"),
+    ("Separate Dimensions (Position)", "分離維度 (位置)"),
+    ("Convert selected keyframes to Hold", "將所選關鍵影格轉換為定格"),
+    ("Convert selected keyframes to Linear", "將所選關鍵影格轉換為線性"),
+    ("Convert selected keyframes to Auto Bezier", "將所選關鍵影格轉換為自動貝茲"),
+    ("Easy Ease (F9)", "緩和 (F9)"),
+    ("Easy Ease In (Shift+F9)", "緩入 (Shift+F9)"),
+    ("Easy Ease Out (Ctrl+Shift+F9)", "緩出 (Ctrl+Shift+F9)"),
+    ("Spatial Path", "空間路徑"),
+    ("Temporal Path", "時間路徑"),
+    ("All the Same", "全部相同"),
+    ("All Independently", "全部獨立"),
+    ("Noise Type:", "雜訊類型:"),
+    ("Apply To:", "套用至:"),
+    ("Temporal Graph", "時間圖表"),
+    ("Keyframe Rate:", "關鍵影格率:"),
+    ("Capture speed at:", "速度擷取位置:"),
+    ("Start Capture", "開始擷取"),
+    ("Cancel Capture", "取消擷取"),
+    ("Small Caps", "小型大寫字母"),
+    ("All Small Caps", "全部小型大寫字母"),
+    ("Superscript / Superior", "上標"),
+    ("Subscript / Inferior", "下標"),
+    ("Standard Ligatures", "標準連字"),
+    ("Discretionary Ligatures", "選用連字"),
+    ("Contextual Alternates", "上下文替代"),
+    ("Stylistic Alternates", "樣式替代"),
+    ("Titling Alternates", "標題替代"),
+    ("Default Figure Style", "預設數字樣式"),
+    ("Tabular Lining", "等寬襯線數字"),
+    ("Proportional Oldstyle", "比例舊式"),
+    ("Proportional Lining", "比例襯線數字"),
+    ("Tabular Oldstyle", "等寬舊式"),
+    ("Fill Over Stroke", "填色在筆畫之上"),
+    ("Stroke Over Fill", "筆畫在填色之上"),
+    ("Stroke order", "筆畫順序"),
+    ("Single-line Composer", "單行排版器"),
+    ("Every-line Composer", "逐行排版器"),
+    ("Text direction", "文字方向"),
+    ("Recently Used", "最近使用"),
+    ("User Presets", "使用者預設集"),
+    ("Remove from Favorites", "從我的最愛移除"),
+    ("Show Animation Presets", "顯示動畫預設集"),
+    ("    Refresh List", "    重新整理清單"),
+    ("    Clear Recently Used", "    清除最近使用"),
+    ("Show 32 bpc Effects Only", "僅顯示 32 bpc 效果"),
+    ("Show GPU Accelerated Effects Only", "僅顯示 GPU 加速效果"),
+    ("Show Effects for All Color Depths", "顯示所有色彩深度的效果"),
+    ("* Animation Presets", "* 動畫預設集"),
+    ("Select a layer to apply to", "請選擇要套用的圖層"),
+    ("Alpha Expansion:", "Alpha 擴張:"),
+    ("Fill Method:", "填色方式:"),
+    ("Edge Blend", "邊緣混合"),
+    ("Entire Duration", "整個持續時間"),
+    ("Reference Frame:", "參考幀:"),
+    ("Use Current Time", "使用目前時間"),
+    ("Generate Fill Layer", "產生填色圖層"),
+    ("Lighting Correction:", "光照校正:"),
+    ("Create Text and Camera", "建立文字和攝影機"),
+    ("Create Solid and Camera", "建立純色和攝影機"),
+    ("Create Null and Camera", "建立空物件和攝影機"),
+    ("Create Shadow Catcher, Camera and Light", "建立陰影擷取器、攝影機和燈光"),
+    ("Unable to solve camera", "無法求解攝影機"),
+    ("Waiting to solve", "等待求解"),
+    ("track point", "追蹤點"),
+    ("Ruler zero point", "尺規零點"),
+    ("Vertical ruler", "垂直尺規"),
+    ("Horizontal ruler", "水平尺規"),
+    ("Viewer controls", "檢視器控制項"),
+    ("Resolution/Down Sample Factor", "解析度/降取樣係數"),
+    ("Adjust Exposure", "調整曝光"),
+    ("Snapshot taken", "已拍攝快照"),
+    ("Fast Previews", "快速預覽"),
+    ("3D View", "3D 視圖"),
+    ("Current time", "目前時間"),
+    ("Layer Transform", "圖層變換"),
+    ("Reset Transform", "重設變換"),
+    ("Text Animation", "文字動畫"),
+    ("Text Animation Presets", "文字動畫預設集"),
+    ("EffectCraft on getartcraft.com", "getartcraft.com 上的 EffectCraft"),
+    ("Small Screen", "小螢幕"),
+    ("Tool Creates Shape", "工具建立形狀"),
+    ("Tool Creates Mask", "工具建立遮罩"),
+    ("Blend Mode", "混合模式"),
+    ("Show mesh", "顯示網格"),
+    ("Record Options...", "記錄選項..."),
 ];
 
 /// Ukrainian (uk): original translations of the same interface rows as the Chinese catalogs.
 /// Technical names, key names and substituted project content keep their original spelling.
 const UKRAINIAN: &[(&str, &str)] = &[
+    ("Click to sample color", "Клацніть, щоб узяти зразок кольору"),
     ("Appearance Settings…", "Налаштування вигляду…"),
     ("Add to favorites", "Додати до вибраного"),
     ("Remove from favorites", "Видалити з вибраного"),
@@ -2473,7 +4871,6 @@ const UKRAINIAN: &[(&str, &str)] = &[
     ("Duration:", "Тривалість:"),
     ("Edit Gradient…", "Редагувати градієнт…"),
     ("Edit Target: {}", "Ціль редагування: {}"),
-    ("Edit in the Timeline", "Редагувати на шкалі часу"),
     ("EffectCraft didn't quit normally last time.", "Минулого разу EffectCraft завершив роботу некоректно."),
     ("Effects", "Ефекти"),
     ("Effects & Presets options", "Параметри ефектів і наборів"),
@@ -2606,6 +5003,7 @@ const UKRAINIAN: &[(&str, &str)] = &[
     ("No layer selected", "Шар не виділено"),
     ("No matching effects or presets", "Не знайдено відповідних ефектів або наборів"),
     ("No matching fonts", "Не знайдено відповідних шрифтів"),
+    ("Rescan Fonts", "Повторно сканувати шрифти"),
     ("Variable fonts only", "Лише змінні шрифти"),
     ("No model credits were built into this copy.", "Ця копія не містить відомостей про моделі."),
     ("No nested compositions", "Немає вкладених композицій"),
@@ -2639,6 +5037,7 @@ const UKRAINIAN: &[(&str, &str)] = &[
     ("Overlay", "Накладання"),
     ("Parameter Name:", "Назва параметра:"),
     ("Parent pick whip: drag onto a layer", "Зв’язування батьківського шару: перетягніть на шар"),
+    ("Track Matte pick whip: drag onto a layer", "Зв’язування трекової маски: перетягніть на шар"),
     ("Pixel Aspect Ratio:", "Пропорції пікселя:"),
     ("Playing on Video Preview", "Відтворення на відеоперегляді"),
     ("Post-Render Action: {}", "Дія після рендерингу: {}"),
@@ -2906,6 +5305,8 @@ const UKRAINIAN: &[(&str, &str)] = &[
 
 // Brazilian Portuguese.
 const PORTUGUESE: &[(&str, &str)] = &[
+    ("Click to sample color", "Clique para obter uma amostra de cor"),
+    ("Export Scene to Blender...", "Exportar cena para o Blender..."),
     ("   OK   ", "   OK   "),
     ("  Delete  ", "  Excluir  "),
     (" Open Auto-Save ", " Abrir salvamento automático "),
@@ -3033,7 +5434,6 @@ const PORTUGUESE: &[(&str, &str)] = &[
     ("Duration:", "Duração:"),
     ("Edit Gradient…", "Editar gradiente…"),
     ("Edit Target: {}", "Editar destino: {}"),
-    ("Edit in the Timeline", "Editar na linha do tempo"),
     ("EffectCraft didn't quit normally last time.", "O EffectCraft não foi encerrado normalmente da última vez."),
     ("Effects", "Efeitos"),
     ("Effects & Presets options", "Opções de Efeitos e predefinições"),
@@ -3140,6 +5540,7 @@ const PORTUGUESE: &[(&str, &str)] = &[
     ("New", "Novo"),
     ("New Comp from Selection", "Nova composição a partir da seleção"),
     ("Replace with Precomposition", "Substituir por pré-composição"),
+    ("Rescan Fonts", "Reanalisar fontes"),
     ("used once", "usado uma vez"),
     ("used {} times", "usado {} vezes"),
     ("Compositions that use this item", "Composições que usam este item"),
@@ -3192,6 +5593,7 @@ const PORTUGUESE: &[(&str, &str)] = &[
     ("Output To:", "Saída para:"),
     ("Parameter Name:", "Nome do parâmetro:"),
     ("Parent pick whip: drag onto a layer", "Pick whip de pai: arraste até uma camada"),
+    ("Track Matte pick whip: drag onto a layer", "Pick whip de track matte: arraste até uma camada"),
     ("Pixel Aspect Ratio:", "Proporção de pixel:"),
     ("Playing on Video Preview", "Reproduzindo na visualização de vídeo"),
     ("Post-Render Action: {}", "Ação pós-renderização: {}"),
@@ -3353,10 +5755,1057 @@ const PORTUGUESE: &[(&str, &str)] = &[
     ("⚠ {} is used by:", "⚠ {} é usado por:"),
     ("Total Offset", "Deslocamento total"),
     ("Per Layer", "Por camada"),
+    ("Action-safe", "Área segura de ação"),
+    ("Add to favorites", "Adicionar aos favoritos"),
+    ("All Footage", "Todas as mídias"),
+    ("All Keyframes", "Todos os keyframes"),
+    ("Allow Scripts to Write Files and Access Network", "Permitir que scripts gravem arquivos e acessem a rede"),
+    ("Append Bit Depth to File Name", "Anexar profundidade de bits ao nome do arquivo"),
+    ("Application Scripting", "Scripting do aplicativo"),
+    ("Ask User", "Perguntar ao usuário"),
+    ("Audio Hardware", "Hardware de áudio"),
+    ("Audio Output Mapping", "Mapeamento de saída de áudio"),
+    ("Auto-Save Location", "Local do salvamento automático"),
+    ("Automatic", "Automático"),
+    ("Automatically Reload Footage", "Recarregar mídias automaticamente"),
+    ("Automatically Save Projects", "Salvar projetos automaticamente"),
+    ("Brightness", "Brilho"),
+    ("Cache Budgets", "Orçamentos de cache"),
+    ("Conformed Audio Folder", "Pasta de áudio conformado"),
+    ("Create Layers at Composition Start Time", "Criar camadas no tempo inicial da composição"),
+    ("Create Split Layers Above Original Layer", "Criar camadas divididas acima da camada original"),
+    ("Custom", "Personalizado"),
+    ("Custom Location", "Local personalizado"),
+    ("Cycle Mask Colors", "Alternar cores das máscaras"),
+    ("Dark Theme", "Tema escuro"),
+    ("Dashed Lines", "Linhas tracejadas"),
+    ("Default 3D Renderer", "Renderizador 3D padrão"),
+    ("Default Drag Import As", "Importação padrão ao arrastar como"),
+    ("Default Output Folder", "Pasta de saída padrão"),
+    ("Default Spatial Interpolation to Linear", "Definir interpolação espacial padrão como linear"),
+    ("Disable Video Output When in Background", "Desativar saída de vídeo em segundo plano"),
+    ("Disk Cache Folder", "Pasta de cache do disco"),
+    ("Display Color Space", "Espaço de cores da exibição"),
+    ("Dots", "Pontos"),
+    ("Duration (Seconds)", "Duração (segundos)"),
+    (
+        "EffectCraft always uses its own colour picker (the same on every platform and the web).",
+        "O EffectCraft sempre usa o próprio seletor de cores (o mesmo em todas as plataformas e na web).",
+    ),
+    ("Empty Disk Cache", "Esvaziar cache do disco"),
+    ("Enable Disk Cache", "Ativar cache do disco"),
+    ("Enable JavaScript Debugger", "Ativar depurador JavaScript"),
+    ("Enable Video Preview Output", "Ativar saída de pré-visualização de vídeo"),
+    ("Expression Pick Whip Writes Compact English", "Pick whip de expressão grava inglês compacto"),
+    (
+        "Expressions use the JavaScript engine. Script errors report their file and line in the Script Console; there is no step debugger.",
+        "As expressões usam o mecanismo JavaScript. Erros de script informam o arquivo e a linha no Console de scripts; não há depurador passo a passo.",
+    ),
+    ("Face Model", "Modelo de rosto"),
+    ("Face Tracking", "Rastreamento facial"),
+    (
+        "Face tracking in the Tracker panel (Outline Only and Detailed Features) uses the model chosen here. Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
+        "O rastreamento facial no painel Rastreador (Somente contorno e recursos detalhados) usa o modelo escolhido aqui. Os modelos são de código aberto, baixados somente quando você solicita, e verificados com o SHA-256 publicado.",
+    ),
+    ("Fast Previews (Draft 3D, Faster Effects)", "Pré-visualizações rápidas (3D em rascunho, efeitos mais rápidos)"),
+    ("Files per Segment", "Arquivos por segmento"),
+    ("Fit", "Ajustar"),
+    ("Fit up to 100%", "Ajustar até 100%"),
+    ("Floating Window", "Janela flutuante"),
+    ("Footage Frame Cache", "Cache de quadros de mídia"),
+    ("GPU Information...", "Informações da GPU..."),
+    ("Gridline Every", "Grade a cada"),
+    ("Hardware Accelerate Composition, Layer and Footage Panels", "Aceleração por hardware dos painéis de composição, camada e mídia"),
+    ("Import Photoshop File", "Importar arquivo do Photoshop"),
+    ("Interpret Unlabeled Alpha As", "Interpretar alfa não rotulado como"),
+    ("Keyframes", "Keyframes"),
+    ("Labels and Colors", "Rótulos e cores"),
+    ("Layer Cache", "Cache de camada"),
+    ("Length of Composition", "Duração da composição"),
+    ("Levels of Undo", "Níveis de desfazer"),
+    ("Light Theme", "Tema claro"),
+    ("Match System", "Seguir o sistema"),
+    ("Maximum Disk Cache Size", "Tamanho máximo do cache do disco"),
+    ("Maximum Project Versions", "Máximo de versões do projeto"),
+    ("Media Cache", "Cache de mídia"),
+    ("Menu Bar", "Barra de menus"),
+    ("Minutes", "Minutos"),
+    ("Mirror on Computer Monitor", "Espelhar no monitor do computador"),
+    ("Move Panel to New Window", "Mover painel para nova janela"),
+    ("New Composition", "Nova composição"),
+    ("New Project", "Novo projeto"),
+    ("New Project Loads Template", "Novo projeto carrega modelo"),
+    ("Next to Project", "Ao lado do projeto"),
+    ("No More Than (Keyframes)", "No máximo (keyframes)"),
+    ("No More Than (Seconds)", "No máximo (segundos)"),
+    ("No Motion Path", "Sem caminho de movimento"),
+    ("Non-Sequence Footage", "Mídia que não é sequência"),
+    ("Number of Recent Fonts to Display", "Número de fontes recentes a exibir"),
+    ("Off (Final Quality)", "Desativado (qualidade final)"),
+    ("Offer to Open the Latest Auto-Save After a Crash", "Oferecer para abrir o salvamento automático mais recente após uma falha"),
+    ("OpenGL (compatibility)", "OpenGL (compatibilidade)"),
+    ("Panels are always drawn by the GPU (wgpu).", "Os painéis são sempre desenhados pela GPU (wgpu)."),
+    ("Preserve Constant Vertex and Feather Point Count when Editing Masks", "Preservar o número constante de vértices e pontos de feather ao editar máscaras"),
+    ("Preview (RAM) Cache", "Cache de pré-visualização (RAM)"),
+    ("RAM Reserved for Other Applications", "RAM reservada para outros aplicativos"),
+    ("RGB Straight", "RGB direto"),
+    ("Realtime Shadows in Draft", "Sombras em tempo real no rascunho"),
+    ("Recent Projects Shown", "Projetos recentes exibidos"),
+    ("Red", "Vermelho"),
+    ("Reduce Cache Size When System Is Low on Memory", "Reduzir o tamanho do cache quando o sistema estiver com pouca memória"),
+    ("Remove from favorites", "Remover dos favoritos"),
+    ("Repair", "Reparo"),
+    ("Report Missing Frames", "Relatar quadros ausentes"),
+    ("Reset Keyboard Shortcuts", "Redefinir atalhos de teclado"),
+    ("Reset Settings", "Redefinir configurações"),
+    (
+        "Roto Brush 2.0 and 3.0 use the model chosen here (Version 1.0 always uses the classic engine). Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
+        "Roto Brush 2.0 e 3.0 usam o modelo escolhido aqui (a versão 1.0 sempre usa o mecanismo clássico). Os modelos são de código aberto, baixados somente quando você solicita, e verificados com o SHA-256 publicado.",
+    ),
+    ("Safe Margins", "Margens de segurança"),
+    ("Save Every", "Salvar a cada"),
+    ("Save Now", "Salvar agora"),
+    ("Save When Starting Render Queue", "Salvar ao iniciar a fila de renderização"),
+    ("Segment Movie Files", "Segmentar arquivos de filme"),
+    ("Segment Sequences", "Segmentar sequências"),
+    ("Segment Size", "Tamanho do segmento"),
+    ("Segmentation Model", "Modelo de segmentação"),
+    ("Sequence Footage", "Mídia em sequência"),
+    ("Show 3D Reference Axes", "Mostrar eixos de referência 3D"),
+    ("Show Expression Error Banner", "Mostrar faixa de erro de expressão"),
+    ("Show Font Names in English", "Mostrar nomes de fontes em inglês"),
+    ("Show Font Preview", "Mostrar pré-visualização de fonte"),
+    ("Show Home Screen When Launching", "Mostrar tela inicial ao iniciar"),
+    ("Show Home Screen When Opening a Project", "Mostrar tela inicial ao abrir um projeto"),
+    ("Show Tool Tips", "Mostrar dicas de ferramenta"),
+    ("Startup & Repair", "Inicialização e reparo"),
+    ("Still Footage", "Mídia estática"),
+    ("Stored, but not used by EffectCraft yet", "Armazenado, mas ainda não usado pelo EffectCraft"),
+    ("Subdivisions", "Subdivisões"),
+    ("Switches Affect Nested Comps", "Interruptores afetam composições aninhadas"),
+    ("Synchronize Time of All Related Items", "Sincronizar o tempo de todos os itens relacionados"),
+    ("Template Project", "Projeto de modelo"),
+    ("Title-safe", "Área segura de título"),
+    ("Use In-Window Menu Bar on macOS", "Usar barra de menus na janela no macOS"),
+    ("Use System Color Picker", "Usar seletor de cores do sistema"),
+    ("Video Device", "Dispositivo de vídeo"),
+    ("Video Output During Playback", "Saída de vídeo durante a reprodução"),
+    ("Warn User When Executing Files", "Avisar o usuário ao executar arquivos"),
+    ("Window Graphics", "Gráficos da janela"),
+    (
+        "Window Graphics applies from the next launch. When the graphics driver stops EffectCraft as its window opens, the next launch switches to OpenGL.",
+        "Gráficos da janela vale a partir do próximo início. Quando o driver gráfico interrompe o EffectCraft na abertura da janela, o próximo início muda para OpenGL.",
+    ),
+    ("Wireframe", "Wireframe"),
+    ("Active", "Em uso"),
+    ("NAME", "NOME"),
+    ("Affect all layers that use this solid", "Afetar todas as camadas que usam este sólido"),
+    ("EffectCraft home page", "Página inicial do EffectCraft"),
+    ("Only this layer uses this solid.", "Somente esta camada usa este sólido."),
+    ("KIND", "TIPO"),
+    ("Blue", "Azul"),
+    ("Green", "Verde"),
+    ("Unfreeze", "Descongelar"),
+    ("Export", "Exportar"),
+    ("Auto-complete", "Preenchimento automático"),
+    ("Bracket Matching", "Correspondência de colchetes"),
+    ("Font Size", "Tamanho da fonte"),
+    ("Line Numbers", "Números de linha"),
+    ("Scripting & Expressions", "Scripts e expressões"),
+    ("Syntax Highlighting", "Realce de sintaxe"),
+    ("Word Wrap", "Quebra automática de linha"),
+    ("16 bits per channel", "16 bits por canal"),
+    ("32 bits per channel (float)", "32 bits por canal (ponto flutuante)"),
+    ("8 bits per channel", "8 bits por canal"),
+    ("Adobe-style built-in", "Integrado (estilo Adobe)"),
+    ("Composition - Retain Layer Sizes", "Composição - Manter tamanhos de camada"),
+    ("Guess", "Adivinhar"),
+    ("Import Image Sequence", "Importar sequência de imagens"),
+    ("Import PDF / Illustrator File", "Importar arquivo PDF / Illustrator"),
+    ("Mercury Software Only", "Apenas software Mercury"),
+    ("OCIO (built-in ACES config)", "OCIO (config do ACES integrado)"),
+    ("Still Duration", "Duração da imagem fixa"),
+    ("Straight", "Direto"),
+    ("Tone map", "Mapeamento tonal"),
+    ("sRGB IEC61966-2.1 (default)", "sRGB IEC61966-2.1 (padrão)"),
+    (
+        "Click above the bar to add an opacity stop, below it to add a color stop.",
+        "Clique acima da barra para adicionar uma parada de opacidade, abaixo dela para adicionar uma parada de cor.",
+    ),
+    ("Location:", "Local:"),
+    (
+        "These adjacent keyframes cannot interpolate because their stop counts differ.",
+        "Estes keyframes adjacentes não podem ser interpolados porque os seus números de paradas diferem.",
+    ),
+    ("After Effects project", "Projeto do After Effects"),
+    ("Create a new project, or open the demo project to look around.", "Crie um novo projeto ou abra o projeto de demonstração para explorar."),
+    ("Filter recent files", "Filtrar arquivos recentes"),
+    ("Import Footage…", "Importar mídia…"),
+    ("Just now", "Agora mesmo"),
+    ("Lottie animation", "Animação Lottie"),
+    ("Motion graphics and visual effects · version {}", "Motion graphics e efeitos visuais · versão {}"),
+    ("No recent files match the filter", "Nenhum arquivo recente corresponde ao filtro"),
+    ("OPENED", "ABERTO"),
+    ("Open Demo Project", "Abrir projeto de demonstração"),
+    ("Open Project…", "Abrir projeto…"),
+    ("SIZE", "TAMANHO"),
+    ("Try another name or folder.", "Tente outro nome ou pasta."),
+    ("Yesterday", "Ontem"),
+    ("Your recent files will show here", "Seus arquivos recentes aparecerão aqui"),
+    ("{} day ago", "há {} dia"),
+    ("{} days ago", "há {} dias"),
+    ("{} hour ago", "há {} hora"),
+    ("{} hours ago", "há {} horas"),
+    ("{} minute ago", "há {} minuto"),
+    ("{} minutes ago", "há {} minutos"),
+    ("Show Rendering Progress in Info Panel and Flowchart", "Mostrar progresso de renderização no painel Informações e no fluxograma"),
+    ("Current Settings", "Configurações atuais"),
+    ("Move Panel to Main Window", "Mover painel para a janela principal"),
+    ("Disable Per-character 3D", "Desativar 3D por caractere"),
+    ("Enable Per-character 3D", "Ativar 3D por caractere"),
+    ("Opus Bitrate: {} kbps", "Taxa de bits do Opus: {} kbps"),
+    ("Quarter", "Um quarto"),
+    ("Region of Interest", "Região de interesse"),
+    ("Third", "Um terço"),
+    ("Boundary", "Contorno"),
+    ("Labels", "Rótulos"),
+    ("You can't undo this.", "Você não pode desfazer isto."),
+    ("Latin", "Latino"),
+    ("South Asian and Middle Eastern", "Sul-asiático e do Oriente Médio"),
+    ("Text Engine", "Motor de texto"),
+    ("Variable fonts only", "Apenas fontes variáveis"),
+    ("Expressions Editor", "Editor de expressões"),
+    ("Faster", "Mais rápido"),
+    ("Grids & Guides", "Grades e guias"),
+    ("More Accurate", "Mais preciso"),
+    ("Path Point and Handle Size", "Tamanho dos pontos de caminho e das alças"),
+    ("Show Internal Wireframes", "Mostrar wireframes internos"),
+    ("Viewer Zoom Quality", "Qualidade de zoom do visualizador"),
+    ("Motion Path", "Caminho de movimento"),
+    ("3D Reference Axes", "Eixos de referência 3D"),
+    ("Choose grid and guide options", "Escolher opções de grade e guias"),
+    ("Colorize", "Colorir"),
+    ("Custom...", "Personalizado..."),
+    ("Proportional Grid", "Grade proporcional"),
+    ("Reset Exposure", "Redefinir exposição"),
+    ("Show Channel and Color Management Settings", "Mostrar configurações de canal e de gerenciamento de cores"),
+    ("Show Snapshot (hold)", "Mostrar instantâneo (manter pressionado)"),
+    ("Take Snapshot", "Capturar instantâneo"),
+    ("Toggle Mask and Shape Path Visibility", "Alternar visibilidade das máscaras e dos caminhos de forma"),
+    ("Toggle Transparency Grid", "Alternar grade de transparência"),
+    ("Database and Cache Folder", "Pasta de banco de dados e de cache"),
+    ("Adaptive Resolution", "Resolução adaptável"),
+    ("Adaptive Resolution Limit", "Limite de resolução adaptável"),
+    ("Alpha", "Alfa"),
+    ("Appearance", "Aparência"),
+    ("Appearance Mode", "Modo de aparência"),
+    ("Appearance Mode: {}", "Modo de aparência: {}"),
+    ("Appearance Settings…", "Configurações de aparência…"),
+    ("Audio", "Áudio"),
+    ("Auto-Save", "Auto-salvar"),
+    ("Cache Frames When Idle", "Armazenar quadros em cache quando ocioso"),
+    ("Dark", "Escuro"),
+    ("Default", "Padrão"),
+    ("Disk", "Disco"),
+    ("Disk Cache", "Cache do disco"),
+    ("Display", "Exibição"),
+    ("Draft", "Rascunho"),
+    ("EffectCraft on GitHub", "EffectCraft no GitHub"),
+    ("EffectCraft project", "Projeto do EffectCraft"),
+    ("Extended Viewer", "Visualizador estendido"),
+    ("Fast Draft", "Rascunho rápido"),
+    ("Footage", "Mídia"),
+    ("Freeze", "Congelar"),
+    ("Full", "Integral"),
+    ("Full Screen", "Tela inteira"),
+    ("General", "Geral"),
+    ("Gradient Editor", "Editor de gradiente"),
+    ("Half", "Metade"),
+    ("Horizontal", "Horizontal"),
+    ("Ignore", "Ignorar"),
+    ("Join the ArtCraft Discord", "Entre no Discord da ArtCraft"),
+    ("Language", "Idioma"),
+    ("Left", "Esquerda"),
+    ("Light", "Claro"),
+    ("Lines", "Linhas"),
+    ("Memory & CPU", "Memória e CPU"),
+    ("Mercury GPU Acceleration ({})", "Aceleração de GPU Mercury ({})"),
+    ("Off", "Desativado"),
+    ("Options", "Opções"),
+    ("Overlay", "Sobrepor"),
+    ("Premultiplied", "Pré-multiplicado"),
+    ("Preview Sample Rate", "Taxa de amostragem de pré-visualização"),
+    ("Previews", "Pré-visualizações"),
+    ("Project", "Projeto"),
+    ("RGB", "RGB"),
+    ("Right", "Direita"),
+    ("Roto Brush", "Roto Brush"),
+    ("Seconds", "Segundos"),
+    ("Stop", "Parar"),
+    ("Style", "Estilo"),
+    ("Sync with System", "Sincronizar com o sistema"),
+    ("Templates", "Modelos"),
+    ("Track", "Rastrear"),
+    ("UI Scale", "Escala da interface"),
+    ("Use Gradients", "Usar gradientes"),
+    ("Use Label Color for Layer Handles and Paths", "Usar a cor do rótulo nas alças de camada e nos caminhos"),
+    ("Use Label Color for Related Tabs", "Usar a cor do rótulo nas abas relacionadas"),
+    ("Vertical", "Vertical"),
+    ("Video", "Vídeo"),
+    ("channel", "canal"),
+    ("files", "arquivos"),
+];
+
+/// Polish (pl): original translations covering every row in the Chinese panel catalogs.
+const POLISH: &[(&str, &str)] = &[
+    ("Click to sample color", "Kliknij, aby pobrać próbkę koloru"),
+    ("Appearance Settings…", "Ustawienia wyglądu…"),
+    ("Add to favorites", "Dodaj do ulubionych"),
+    ("Remove from favorites", "Usuń z ulubionych"),
+    ("   OK   ", "   OK   "),
+    ("  Delete  ", "  Usuń  "),
+    (" Open Auto-Save ", " Otwórz autozapis "),
+    ("(missing)", "(brak)"),
+    ("360 View Orientation", "Orientacja widoku 360"),
+    ("3:2 Pulldown: {}", "Pulldown 3:2: {}"),
+    (
+        "A clean-room, open-source compositor for motion graphics and visual effects: native on macOS, Windows and Linux, and in the browser. Part of the ArtCraft family of creative apps.",
+        "Kompozytor grafiki ruchomej i efektów wizualnych, open source i tworzony metodą clean-room: natywny w macOS, Windows i Linuksie oraz w przeglądarce. Część rodziny aplikacji twórczych ArtCraft.",
+    ),
+    ("About EffectCraft", "O programie EffectCraft"),
+    ("About...", "O programie..."),
+    ("Active", "Aktywny"),
+    ("Active Camera", "Aktywna kamera"),
+    ("Alpha", "Alfa"),
+    ("Adapt Feature On Every Frame", "Dostosuj cechę w każdej klatce"),
+    ("Adaptive Sample Limit:", "Adaptacyjny limit próbek:"),
+    ("Add Animator", "Dodaj animator"),
+    ("Add Comment", "Dodaj komentarz"),
+    ("Add Formatting", "Dodaj formatowanie"),
+    ("Add Group", "Dodaj grupę"),
+    ("Add Mirror", "Dodaj lustro"),
+    ("Add Selected As", "Dodaj zaznaczone jako"),
+    ("Add a comment", "Dodaj komentarz"),
+    ("Add a shape, fill, stroke or path operation", "Dodaj kształt, wypełnienie, obrys lub operację na ścieżce"),
+    ("Add to Composition", "Dodaj do kompozycji"),
+    ("Add to Favorites", "Dodaj do ulubionych"),
+    ("Add:", "Dodaj:"),
+    ("Adjust Exposure (stops)", "Dostosuj ekspozycję (EV)"),
+    ("Adjust composition duration to the time span of the selected layers", "Dopasuj czas trwania kompozycji do zakresu czasu zaznaczonych warstw"),
+    ("Advanced 3D", "Zaawansowane 3D"),
+    ("Align Layers to:", "Wyrównaj warstwy do:"),
+    ("All six face cameras turn together; the scene is not changed.", "Wszystkie sześć kamer ścian obraca się razem; scena się nie zmienia."),
+    ("Anchor:", "Zakotwiczenie:"),
+    ("Aperture", "Przysłona"),
+    ("Appearance Mode", "Tryb wyglądu"),
+    ("Appearance Mode: {}", "Tryb wyglądu: {}"),
+    ("Apply Dimensions:", "Zastosuj wymiary:"),
+    ("Apply Motion To:", "Zastosuj ruch do:"),
+    ("Arrange", "Kolejność"),
+    ("Assign", "Przypisz"),
+    ("Auto", "Auto"),
+    ("Auto-saves", "Autozapisy"),
+    ("Back", "Tył"),
+    ("Background Color:", "Kolor tła:"),
+    ("Blend Mode:", "Tryb mieszania:"),
+    ("Blending Mode", "Tryb mieszania"),
+    ("Blur", "Rozmycie"),
+    ("Blur Level", "Poziom rozmycia"),
+    ("Boundary", "Granica"),
+    ("Browser Storage", "Pamięć przeglądarki"),
+    ("Browse…", "Przeglądaj…"),
+    ("Brush Dynamics", "Dynamika pędzla"),
+    ("Caching frames…", "Buforowanie klatek…"),
+    ("Cancel", "Anuluj"),
+    ("Casts Shadows", "Rzuca cienie"),
+    ("Change Renderer…", "Zmień renderer…"),
+    (
+        "Changing a shortcut creates a custom preset; the default stays as it is.",
+        "Zmiana skrótu tworzy niestandardowe ustawienie; domyślne pozostaje bez zmian.",
+    ),
+    ("Channel", "Kanał"),
+    ("Channel:", "Kanał:"),
+    ("Chapter:", "Rozdział:"),
+    ("Choose...", "Wybierz..."),
+    ("Classic 3D", "Klasyczne 3D"),
+    ("Clear", "Wyczyść"),
+    ("Clear list", "Wyczyść listę"),
+    ("Click a key to see its commands.", "Kliknij klawisz, aby zobaczyć jego polecenia."),
+    (
+        "Click above the bar to add an opacity stop, below it to add a color stop.",
+        "Kliknij nad paskiem, aby dodać punkt krycia, pod nim, aby dodać punkt koloru.",
+    ),
+    ("Click adds a point (½ height = no change)", "Kliknięcie dodaje punkt (½ wysokości = bez zmian)"),
+    ("Click adds a point; drag one off to remove", "Kliknięcie dodaje punkt; przeciągnij go poza obszar, aby usunąć"),
+    ("Click to make this viewer active", "Kliknij, aby uaktywnić tę przeglądarkę"),
+    ("Click to reveal the expression in the timeline", "Kliknij, aby pokazać wyrażenie na osi czasu"),
+    ("Click to show the active composition here", "Kliknij, aby pokazać tu aktywną kompozycję"),
+    ("Click, then click in the Composition panel", "Kliknij, a potem kliknij w panelu Kompozycja"),
+    ("Clone Options", "Opcje klonowania"),
+    ("Clone Source Overlay:", "Nakładka źródła klonowania:"),
+    ("Close", "Zamknij"),
+    ("Close Panel", "Zamknij panel"),
+    ("Close tutorial", "Zamknij samouczek"),
+    ("Color", "Kolor"),
+    ("Color Depth: {}", "Głębia kolorów: {}"),
+    ("Color:", "Kolor:"),
+    ("Colour map", "Mapa kolorów"),
+    ("Columns", "Kolumny"),
+    ("Comment:", "Komentarz:"),
+    ("Community", "Społeczność"),
+    ("Composition", "Kompozycja"),
+    ("Composition Mini-Flowchart", "Miniaturowy schemat kompozycji"),
+    ("Composition Name:", "Nazwa kompozycji:"),
+    ("Composition Settings ▸ 3D Renderer", "Ustawienia kompozycji ▸ Renderer 3D"),
+    ("Composition Settings…", "Ustawienia kompozycji…"),
+    ("Composition marker bin: drag a marker to the time ruler", "Pojemnik znaczników kompozycji: przeciągnij znacznik na linijkę czasu"),
+    ("Cone Angle", "Kąt stożka"),
+    ("Cone Feather", "Wtapianie stożka"),
+    ("Constrain Proportions", "Zachowaj proporcje"),
+    ("Continuous (Lock Outgoing to Incoming)", "Ciągły (zablokuj wyjście do wejścia)"),
+    ("Cue Point", "Punkt sygnału"),
+    ("Current Render", "Bieżące renderowanie"),
+    ("Dark", "Ciemny"),
+    ("Dark Theme", "Ciemny motyw"),
+    ("Darker", "Ciemniej"),
+    ("Default Output:", "Domyślne wyjście:"),
+    ("Default: {}", "Domyślnie: {}"),
+    ("Defaults", "Domyślne"),
+    ("Delete", "Usuń"),
+    ("Delete Selected Points", "Usuń zaznaczone punkty"),
+    ("Delete selected project items", "Usuń zaznaczone elementy projektu"),
+    ("Delete this template", "Usuń ten szablon"),
+    ("Depth of Field", "Głębia ostrości"),
+    ("Discord", "Discord"),
+    ("Distribute Layers:", "Rozmieść warstwy:"),
+    ("Don't Recover", "Nie odzyskuj"),
+    ("Don't Save", "Nie zapisuj"),
+    ("Double-click a layer to open it in the Layer panel", "Kliknij dwukrotnie warstwę, aby otworzyć ją w panelu Warstwa"),
+    ("Double-click footage in the Project panel to open it here", "Kliknij dwukrotnie materiał w panelu Projekt, aby otworzyć go tutaj"),
+    ("Double-click to edit the comment", "Kliknij dwukrotnie, aby edytować komentarz"),
+    ("Download", "Pobierz"),
+    (
+        "Drag properties here from the timeline,\nor use Animation > Add Property to Essential Graphics.",
+        "Przeciągnij tu właściwości z osi czasu\nalbo użyj Animacja > Dodaj właściwość do Essential Graphics.",
+    ),
+    ("Drag to change", "Przeciągnij, aby zmienić"),
+    ("Drag to create a guide", "Przeciągnij, aby utworzyć linię pomocniczą"),
+    ("Drag to slip the source", "Przeciągnij, aby przesunąć źródło"),
+    ("Drop Frame", "Z pomijaniem klatek"),
+    ("Duplicate", "Powiel"),
+    ("Duration:", "Czas trwania:"),
+    ("Edit Gradient…", "Edytuj gradient…"),
+    ("Edit Target: {}", "Cel edycji: {}"),
+    ("EffectCraft didn't quit normally last time.", "EffectCraft nie zakończył się poprawnie ostatnim razem."),
+    ("Effects & Presets options", "Opcje efektów i ustawień"),
+    ("Copy Presets Folder Path", "Kopiuj ścieżkę folderu ustawień"),
+    ("Effects: {}", "Efekty: {}"),
+    ("Empty folder", "Pusty folder"),
+    ("Enable Depth of Field", "Włącz głębię ostrości"),
+    ("Enable Expression", "Włącz wyrażenie"),
+    ("Enhance", "Ulepsz"),
+    ("Essential Properties — {}", "Najważniejsze właściwości — {}"),
+    ("Event", "Zdarzenie"),
+    ("Export Template…", "Eksportuj szablon…"),
+    ("Export...", "Eksportuj..."),
+    ("Expression Language Menu", "Menu języka wyrażeń"),
+    ("Expression pick whip: drag onto a property", "Łącznik wyrażenia: przeciągnij na właściwość"),
+    ("Expression:", "Wyrażenie:"),
+    ("Eyedropper: click, then click in the Composition panel", "Kroplomierz: kliknij, a potem kliknij w panelu Kompozycja"),
+    ("Falloff", "Zanikanie"),
+    ("Falloff Distance", "Odległość zanikania"),
+    ("Favorites", "Ulubione"),
+    ("Field Render: {}", "Renderowanie pól: {}"),
+    ("Figures", "Cyfry"),
+    ("Fill Target", "Cel wypełnienia"),
+    ("Finished", "Zakończono"),
+    ("Flowchart: {}", "Schemat: {}"),
+    ("Focus Distance", "Odległość ostrości"),
+    ("Follow Feature Rotation and Scale", "Podążaj za obrotem i skalą cechy"),
+    ("Footage: {}", "Materiał: {}"),
+    ("Format: {}", "Format: {}"),
+    ("Frame Aspect Ratio: {}", "Proporcje klatki: {}"),
+    ("Frame Blending: {}", "Mieszanie klatek: {}"),
+    ("Frame Rate:", "Liczba klatek na sekundę:"),
+    ("Frame Render Time  {}ms", "Czas renderowania klatki  {}ms"),
+    ("Frame Target:", "Cel klatki:"),
+    ("Freeze", "Zamroź"),
+    ("Grab bag", "Różności"),
+    ("Gradient Editor", "Edytor gradientu"),
+    ("Grid", "Siatka"),
+    ("Guide Layers: {}", "Warstwy pomocnicze: {}"),
+    ("Guides", "Linie pomocnicze"),
+    ("Height:", "Wysokość:"),
+    ("Hide This", "Ukryj to"),
+    ("Histogram", "Histogram"),
+    ("Hold In Place", "Zatrzymaj w miejscu"),
+    ("Home", "Start"),
+    ("If Confidence is Below", "Jeśli pewność jest poniżej"),
+    ("Import", "Importuj"),
+    ("Import and Add to Composition", "Importuj i dodaj do kompozycji"),
+    ("Import...", "Importuj..."),
+    ("Imported media", "Zaimportowane multimedia"),
+    ("Influence:", "Wpływ:"),
+    ("Install from File…", "Zainstaluj z pliku…"),
+    ("Intensity", "Natężenie"),
+    ("Inverted", "Odwrócone"),
+    ("Join the ArtCraft community on Discord", "Dołącz do społeczności ArtCraft na Discordzie"),
+    ("Key: {}", "Klawisz: {}"),
+    ("LEARN", "NAUKA"),
+    ("Label", "Etykieta"),
+    ("Label Colors and Names:", "Kolory i nazwy etykiet:"),
+    ("Label:", "Etykieta:"),
+    ("Latest auto-save: {}", "Ostatni autozapis: {}"),
+    ("Layer", "Warstwa"),
+    ("Layer controls", "Elementy sterujące warstwy"),
+    ("Layer:", "Warstwa:"),
+    ("Layer: {}", "Warstwa: {}"),
+    ("Learn", "Nauka"),
+    ("Leave all attributes in \"{}\"", "Zachowaj wszystkie atrybuty w „{}”"),
+    ("Licence: {}", "Licencja: {}"),
+    ("Ligatures", "Ligatury"),
+    ("Light", "Jasny"),
+    ("Light Theme", "Jasny motyw"),
+    ("Light Type", "Typ światła"),
+    ("Lighter", "Jaśniej"),
+    ("Link Selected Property", "Połącz zaznaczoną właściwość"),
+    ("Location:", "Lokalizacja:"),
+    ("Lock Aspect Ratio to {}", "Zablokuj proporcje na {}"),
+    ("Lock to Zoom", "Zablokuj do powiększenia"),
+    ("Locked: {} — {}", "Zablokowano: {} — {}"),
+    ("Log:", "Dziennik:"),
+    ("Loop (Trace Path)", "Pętla (śledź ścieżkę)"),
+    ("MIT OR Apache-2.0 • Fonts: Inter, JetBrains Mono (OFL)", "MIT OR Apache-2.0 • Czcionki: Inter, JetBrains Mono (OFL)"),
+    ("Magnification ratio popup", "Menu współczynnika powiększenia"),
+    ("Make Comp Size", "Ustaw rozmiar kompozycji"),
+    ("Markers", "Znaczniki"),
+    ("Masks", "Maski"),
+    ("Maximize Panel", "Maksymalizuj panel"),
+    ("Media Replacement", "Zamiana multimediów"),
+    ("Mesh:", "Siatka:"),
+    ("Diameter:", "Średnica:"),
+    ("Method Used: {}    Average Error: {} pixels", "Użyta metoda: {}    Średni błąd: {} px"),
+    ("Models folder: {}", "Folder modeli: {}"),
+    ("Modifiers:", "Modyfikatory:"),
+    ("More", "Więcej"),
+    ("More ArtCraft apps", "Więcej aplikacji ArtCraft"),
+    ("More tutorials", "Więcej samouczków"),
+    ("Motion Blur", "Rozmycie ruchu"),
+    ("Motion Blur: {}", "Rozmycie ruchu: {}"),
+    ("Motion Sketch: drag to record", "Szkic ruchu: przeciągnij, aby nagrać"),
+    ("Move Down", "Przesuń w dół"),
+    ("Move Up", "Przesuń w górę"),
+    ("Move to Project Root", "Przenieś do katalogu głównego projektu"),
+    ("Name", "Nazwa"),
+    ("Name:", "Nazwa:"),
+    ("Navigation", "Nawigacja"),
+    ("New", "Nowy"),
+    ("New Comp from Selection", "Nowa kompozycja z zaznaczenia"),
+    ("Replace with Precomposition", "Zastąp kompozycją wstępną"),
+    ("New Duration:", "Nowy czas trwania:"),
+    ("New composition name:", "Nazwa nowej kompozycji:"),
+    ("New from Render Queue item:", "Nowy z elementu kolejki renderowania:"),
+    ("New from Template", "Nowy z szablonu"),
+    ("Next", "Dalej"),
+    ("Nice work. Pick another tutorial on the Home screen's Learn tab.", "Dobra robota. Wybierz kolejny samouczek na karcie Nauka ekranu startowego."),
+    (
+        "No VR environments yet. Create one with Composition ▸ VR ▸ Create VR Environment…",
+        "Brak środowisk VR. Utwórz je poleceniem Kompozycja ▸ VR ▸ Utwórz środowisko VR…",
+    ),
+    ("No audio layer selected", "Nie zaznaczono warstwy audio"),
+    ("No background jobs running", "Brak zadań w tle"),
+    ("No composition markers", "Brak znaczników kompozycji"),
+    ("No contributor data was built into this copy.", "Ta kopia nie zawiera danych o współtwórcach."),
+    ("No device list from this host; the system default output is used.", "Ten system nie podaje listy urządzeń; używane jest domyślne wyjście systemowe."),
+    ("No layer selected", "Nie zaznaczono warstwy"),
+    ("No matching effects or presets", "Brak pasujących efektów lub ustawień"),
+    ("No matching fonts", "Brak pasujących czcionek"),
+    ("Variable fonts only", "Tylko czcionki zmienne"),
+    ("No model credits were built into this copy.", "Ta kopia nie zawiera informacji o modelach."),
+    ("No nested compositions", "Brak zagnieżdżonych kompozycji"),
+    ("No shortcut", "Brak skrótu"),
+    ("No unlocked layer selected", "Nie zaznaczono odblokowanej warstwy"),
+    ("No video", "Brak wideo"),
+    ("None", "Brak"),
+    ("Not applied: tick it in the list to add it.", "Niezastosowany: zaznacz go na liście, aby go dodać."),
+    ("Not assigned", "Nieprzypisany"),
+    ("Note: Shadows are only cast from layers with Cast Shadows enabled.", "Uwaga: cienie rzucają tylko warstwy z włączoną opcją Rzuca cienie."),
+    ("Notify", "Powiadom"),
+    ("OK", "OK"),
+    ("Offset:", "Przesunięcie:"),
+    ("On ({}) stop:", "Punkt na ({}):"),
+    ("One-Node Camera", "Kamera jednowęzłowa"),
+    ("Opacity:", "Krycie:"),
+    ("Open Composition", "Otwórz kompozycję"),
+    ("used once", "użyty raz"),
+    ("used {} times", "użycia: {}"),
+    ("Compositions that use this item", "Kompozycje, które używają tego elementu"),
+    ("Open Last Saved Project", "Otwórz ostatnio zapisany projekt"),
+    ("Open New Composition", "Otwórz nową kompozycję"),
+    ("Open Output", "Otwórz wynik"),
+    ("Open a composition to build Essential Graphics", "Otwórz kompozycję, aby zbudować Essential Graphics"),
+    ("Open a composition to see its scopes", "Otwórz kompozycję, aby zobaczyć jej zakresy"),
+    ("Open a composition to track motion.", "Otwórz kompozycję, aby śledzić ruch."),
+    ("Opus Tuning: {}", "Strojenie Opus: {}"),
+    ("Original Duration:", "Oryginalny czas trwania:"),
+    ("Output Cycle: {}", "Cykl wyjścia: {}"),
+    ("Output To:", "Wyjście do:"),
+    ("Overlay", "Nakładka"),
+    ("Parameter Name:", "Nazwa parametru:"),
+    ("Parent pick whip: drag onto a layer", "Łącznik rodzica: przeciągnij na warstwę"),
+    ("Pixel Aspect Ratio:", "Proporcje piksela:"),
+    ("Playing on Video Preview", "Odtwarzanie w podglądzie wideo"),
+    ("Post-Render Action: {}", "Akcja po renderowaniu: {}"),
+    ("Preserve frame rate when nested or in render queue", "Zachowaj liczbę klatek po zagnieżdżeniu lub w kolejce renderowania"),
+    ("Preserve resolution when nested", "Zachowaj rozdzielczość po zagnieżdżeniu"),
+    ("Preset", "Ustawienie"),
+    ("Preset:", "Ustawienie:"),
+    ("Presets", "Ustawienia"),
+    ("Previous", "Wstecz"),
+    ("Primary:", "Główny:"),
+    ("Process Before Match", "Przetwarzaj przed dopasowaniem"),
+    ("Profile: {}", "Profil: {}"),
+    (
+        "Project color depth: click to cycle 8/16/32 bpc, Alt-click for Project Settings",
+        "Głębia kolorów projektu: kliknij, aby przełączać 8/16/32 bpc, Alt-klik otwiera Ustawienia projektu",
+    ),
+    ("Project: {}", "Projekt: {}"),
+    ("Projects", "Projekty"),
+    ("Property pick whip: drag onto a property", "Łącznik właściwości: przeciągnij na właściwość"),
+    ("Protected Region", "Obszar chroniony"),
+    ("Proxy Use: {}", "Użycie proxy: {}"),
+    ("Push All to Comp", "Wypchnij wszystko do kompozycji"),
+    ("RGB", "RGB"),
+    ("Radius", "Promień"),
+    ("Rate Control: {}", "Kontrola przepływności: {}"),
+    ("Recent", "Ostatnie"),
+    ("Recording", "Nagrywanie"),
+    ("Remove", "Usuń"),
+    ("Rename", "Zmień nazwę"),
+    ("Render: {} ms  •  UI {} fps{}", "Renderowanie: {} ms  •  UI {} fps{}"),
+    ("Renderer:", "Renderer:"),
+    ("Request Persistent Storage", "Poproś o trwałą pamięć"),
+    ("Reset", "Resetuj"),
+    ("Reset Labels", "Resetuj etykiety"),
+    ("Reset Preset", "Resetuj ustawienie"),
+    ("Reset to Default", "Przywróć domyślne"),
+    ("Reset to Saved Layout", "Przywróć zapisany układ"),
+    ("Resolution/Down Sample Factor Popup", "Menu rozdzielczości/współczynnika próbkowania"),
+    ("Restore Panel Size", "Przywróć rozmiar panelu"),
+    ("Reverse the order", "Odwróć kolejność"),
+    ("Revert All", "Przywróć wszystko"),
+    ("Roman Hanging Punctuation", "Interpunkcja wisząca (łacińska)"),
+    ("Roving:", "Wędrujące:"),
+    ("Ruler zero point (drag to move, double-click to reset)", "Punkt zerowy linijki (przeciągnij, aby przesunąć, kliknij dwukrotnie, aby zresetować)"),
+    ("Rulers", "Linijki"),
+    ("Run", "Uruchom"),
+    ("Sample Format: {}", "Format próbek: {}"),
+    ("Samples Per Frame:", "Próbek na klatkę:"),
+    ("Save from #{}", "Zapisz od #{}"),
+    ("Saved {}", "Zapisano {}"),
+    ("Script… (⌘/Ctrl+Enter runs)", "Skrypt… (⌘/Ctrl+Enter uruchamia)"),
+    ("Search commands or shortcuts", "Szukaj poleceń lub skrótów"),
+    ("Select", "Zaznacz"),
+    ("Select a command to change its shortcut.", "Zaznacz polecenie, aby zmienić jego skrót."),
+    ("Select a layer to see its effects", "Zaznacz warstwę, aby zobaczyć jej efekty"),
+    ("Select a layer to see its properties", "Zaznacz warstwę, aby zobaczyć jej właściwości"),
+    ("({}) Selected Objects", "Zaznaczone obiekty ({})"),
+    (
+        "Select a layer with a mask or shape path (or the path property), or Puppet pins.",
+        "Zaznacz warstwę z maską lub ścieżką kształtu (albo właściwość ścieżki) lub pinezki Puppet.",
+    ),
+    ("Select a text layer", "Zaznacz warstwę tekstową"),
+    ("Select an item in the Project panel", "Zaznacz element w panelu Projekt"),
+    ("Select animated properties to show them in the Graph Editor", "Zaznacz animowane właściwości, aby pokazać je w edytorze wykresów"),
+    (
+        "Select the leader pin, then Shift-click the pins that should trail it (hair, cloth, tails)",
+        "Zaznacz pinezkę prowadzącą, a potem Shift-kliknij pinezki, które mają za nią podążać (włosy, tkanina, ogony)",
+    ),
+    ("Set Ground Plane and Origin", "Ustaw płaszczyznę podłoża i początek układu"),
+    ("Set Paint Colors to Black and White (D)", "Ustaw kolory malowania na czarny i biały (D)"),
+    ("Settings", "Ustawienia"),
+    ("Settings Name:", "Nazwa ustawień:"),
+    ("Shadow Darkness", "Ciemność cienia"),
+    ("Shadow Diffusion", "Rozproszenie cienia"),
+    ("Shadows", "Cienie"),
+    ("Shape…", "Kształt…"),
+    ("Show", "Pokaż"),
+    ("Show Layer Name", "Pokaż nazwę warstwy"),
+    ("Show Source Name", "Pokaż nazwę źródła"),
+    ("Show me", "Pokaż mi"),
+    ("Show:", "Pokaż:"),
+    ("Shutter Angle:", "Kąt migawki:"),
+    ("Shutter Phase:", "Faza migawki:"),
+    ("Size", "Rozmiar"),
+    ("Skip", "Pomiń"),
+    ("Snapping", "Przyciąganie"),
+    ("Snapping options", "Opcje przyciągania"),
+    ("Snapshot", "Migawka"),
+    ("Solo Supported Properties", "Solo dla obsługiwanych właściwości"),
+    ("Solo Switches: {}", "Przełączniki solo: {}"),
+    ("Sort", "Sortuj"),
+    ("Spacing:", "Odstęp:"),
+    ("Spatial Interpolation:", "Interpolacja przestrzenna:"),
+    ("Speed:", "Szybkość:"),
+    ("Start Timecode:", "Początkowy kod czasowy:"),
+    ("Start: {}   Duration: {}", "Początek: {}   Czas trwania: {}"),
+    ("Step {} of {}: {}", "Krok {} z {}: {}"),
+    ("Stop", "Zatrzymaj"),
+    ("Stop {} at {}°", "Punkt {} na {}°"),
+    ("Stored in: {}", "Przechowywane w: {}"),
+    ("Stretch", "Rozciągnij"),
+    ("Stretch Factor:", "Współczynnik rozciągnięcia:"),
+    ("Stylistic Sets", "Zestawy stylistyczne"),
+    ("Subpixel Positioning", "Pozycjonowanie podpikselowe"),
+    ("Swap Colors", "Zamień kolory"),
+    ("Swap Paint Colors (X)", "Zamień kolory malowania (X)"),
+    ("Sync with System", "Synchronizuj z systemem"),
+    ("System Default", "Domyślne systemowe"),
+    ("Table", "Tabela"),
+    ("Template name", "Nazwa szablonu"),
+    ("Template: {}\n{}", "Szablon: {}\n{}"),
+    ("Temporal Interpolation:", "Interpolacja czasowa:"),
+    ("The Media Browser is not available here (use File ▸ Import)", "Przeglądarka multimediów nie jest tu dostępna (użyj Plik ▸ Importuj)"),
+    ("The OpenEXR layer shown in red, green, blue and alpha", "Warstwa OpenEXR pokazana w kanałach czerwonym, zielonym, niebieskim i alfa"),
+    ("The render queue is empty.", "Kolejka renderowania jest pusta."),
+    (
+        "These adjacent keyframes cannot interpolate because their stop counts differ.",
+        "Te sąsiednie klatki kluczowe nie mogą być interpolowane, bo mają różną liczbę punktów.",
+    ),
+    ("This ScriptUI panel has closed", "Ten panel ScriptUI został zamknięty"),
+    ("This change will create a new solid for this layer.", "Ta zmiana utworzy nową planszę dla tej warstwy."),
+    ("Time", "Czas"),
+    ("Time Stretch…", "Rozciągnięcie czasu…"),
+    ("Time:", "Czas:"),
+    ("Time: {}", "Czas: {}"),
+    ("Title/Action Safe", "Obszar bezpieczny tytułów/akcji"),
+    ("Title/action safe", "Obszar bezpieczny tytułów/akcji"),
+    ("Toggle Switches / Modes", "Przełącz przełączniki / tryby"),
+    ("Track Name:", "Nazwa ścieżki:"),
+    (
+        "Trained models are available in the desktop app; the browser uses the classic engine.",
+        "Wytrenowane modele są dostępne w aplikacji desktopowej; przeglądarka używa klasycznego silnika.",
+    ),
+    ("Transform", "Przekształć"),
+    ("Transparency grid", "Siatka przezroczystości"),
+    ("Tutorial complete", "Samouczek ukończony"),
+    ("Two-Node Camera", "Kamera dwuwęzłowa"),
+    ("Type", "Typ"),
+    ("Type a command or effect…", "Wpisz polecenie lub efekt…"),
+    ("URL:", "URL:"),
+    ("Undock Panel", "Odepnij panel"),
+    ("Move Panel to New Window", "Przenieś panel do nowego okna"),
+    ("Move Panel to Main Window", "Przenieś panel do głównego okna"),
+    ("Unfreeze", "Odmroź"),
+    ("Unlink {}", "Odłącz {}"),
+    (
+        "Use this option to place the currently selected layers together into a new intermediate composition.",
+        "Użyj tej opcji, aby umieścić zaznaczone warstwy razem w nowej kompozycji pośredniej.",
+    ),
+    ("VR Environments", "Środowiska VR"),
+    ("Value:", "Wartość:"),
+    ("Variable Font Axes", "Osie czcionki zmiennej"),
+    ("Video Codec: {}", "Kodek wideo: {}"),
+    ("View:", "Widok:"),
+    ("Welcome to EffectCraft", "Witaj w EffectCraft"),
+    ("Width:", "Szerokość:"),
+    ("You can undo this.", "Można to cofnąć."),
+    ("You can't undo this.", "Tego nie można cofnąć."),
+    ("Your changes will be lost if you don't save them.", "Jeśli nie zapiszesz zmian, zostaną utracone."),
+    ("Zoom", "Powiększenie"),
+    ("built-in", "wbudowany"),
+    ("frames per second", "klatek na sekundę"),
+    ("template name", "nazwa szablonu"),
+    ("{} contributors · {} commits", "Współtwórcy: {} · commity: {}"),
+    ("{} x {}, {}MB per 8bpc frame", "{} x {}, {} MB na klatkę 8 bpc"),
+    ("{} — coming soon", "{} — wkrótce"),
+    ("{} — double-click to open, {}-click to reveal", "{} — kliknij dwukrotnie, aby otworzyć, {}-klik, aby pokazać w folderze"),
+    ("⌘/Ctrl-drag a pin to record its motion", "⌘/Ctrl-przeciągnij pinezkę, aby nagrać jej ruch"),
+    ("▣ {}", "▣ {}"),
+    ("⚠ {} is used by:", "⚠ {} jest używany przez:"),
+    ("3D Reference Axes", "Osie odniesienia 3D"),
+    ("Affect all layers that use this solid", "Dotyczy wszystkich warstw używających tej planszy"),
+    ("Choose grid and guide options", "Wybierz opcje siatki i linii pomocniczych"),
+    ("Colorize", "Koloryzuj"),
+    ("Custom", "Niestandardowe"),
+    ("Custom...", "Niestandardowe..."),
+    ("Fit", "Dopasuj"),
+    ("Fit up to 100%", "Dopasuj do 100%"),
+    ("Full", "Pełna"),
+    ("Half", "Połowa"),
+    ("Only this layer uses this solid.", "Tylko ta warstwa używa tej planszy."),
+    ("Proportional Grid", "Siatka proporcjonalna"),
+    ("Quarter", "Jedna czwarta"),
+    ("Region of Interest", "Obszar zainteresowania"),
+    ("Reset Exposure", "Resetuj ekspozycję"),
+    ("Show Channel and Color Management Settings", "Pokaż ustawienia kanałów i zarządzania kolorem"),
+    ("Show Snapshot (hold)", "Pokaż migawkę (przytrzymaj)"),
+    ("Take Snapshot", "Zrób migawkę"),
+    ("Third", "Jedna trzecia"),
+    ("Toggle Mask and Shape Path Visibility", "Przełącz widoczność ścieżek masek i kształtów"),
+    ("Toggle Transparency Grid", "Przełącz siatkę przezroczystości"),
+    ("16 bits per channel", "16 bitów na kanał"),
+    ("32 bits per channel (float)", "32 bity na kanał (zmiennoprzecinkowe)"),
+    ("8 bits per channel", "8 bitów na kanał"),
+    ("Adaptive Resolution", "Rozdzielczość adaptacyjna"),
+    ("Adobe-style built-in", "Wbudowany w stylu Adobe"),
+    ("Blue", "Niebieski"),
+    ("Current Settings", "Bieżące ustawienia"),
+    ("Disable Per-character 3D", "Wyłącz 3D dla każdego znaku"),
+    ("Draft", "Robocza"),
+    ("Enable Per-character 3D", "Włącz 3D dla każdego znaku"),
+    ("Fast Draft", "Szybka robocza"),
+    ("Fast Previews (Draft 3D, Faster Effects)", "Szybkie podglądy (robocze 3D, szybsze efekty)"),
+    ("Green", "Zielony"),
+    ("Import Image Sequence", "Importuj sekwencję obrazów"),
+    ("Import PDF / Illustrator File", "Importuj plik PDF / Illustrator"),
+    ("Import Photoshop File", "Importuj plik Photoshopa"),
+    ("Interpret Unlabeled Alpha As", "Interpretuj nieoznaczoną alfę jako"),
+    ("Join the ArtCraft Discord", "Dołącz do Discorda ArtCraft"),
+    ("Mercury GPU Acceleration ({})", "Akceleracja Mercury GPU ({})"),
+    ("Mercury Software Only", "Tylko programowy Mercury"),
+    ("OCIO (built-in ACES config)", "OCIO (wbudowana konfiguracja ACES)"),
+    ("Off (Final Quality)", "Wył. (jakość końcowa)"),
+    ("OpenGL (compatibility)", "OpenGL (zgodność)"),
+    ("Opus Bitrate: {} kbps", "Przepływność Opus: {} kb/s"),
+    ("RGB Straight", "RGB proste"),
+    ("Red", "Czerwony"),
+    ("Tone map", "Mapowanie tonów"),
+    ("Use In-Window Menu Bar on macOS", "Używaj paska menu w oknie w macOS"),
+    ("Wireframe", "Szkielet"),
+    ("sRGB IEC61966-2.1 (default)", "sRGB IEC61966-2.1 (domyślny)"),
+    ("New Project", "Nowy projekt"),
+    ("Open Project…", "Otwórz projekt…"),
+    ("Templates", "Szablony"),
+    ("EffectCraft home page", "Strona główna EffectCraft"),
+    ("EffectCraft on GitHub", "EffectCraft w serwisie GitHub"),
+    ("Motion graphics and visual effects · version {}", "Grafika ruchoma i efekty wizualne · wersja {}"),
+    ("New Composition", "Nowa kompozycja"),
+    ("Open Demo Project", "Otwórz projekt demonstracyjny"),
+    ("Import Footage…", "Importuj materiał…"),
+    ("Filter recent files", "Filtruj ostatnie pliki"),
+    ("NAME", "NAZWA"),
+    ("OPENED", "OTWARTY"),
+    ("SIZE", "ROZMIAR"),
+    ("KIND", "RODZAJ"),
+    ("Your recent files will show here", "Tu pojawią się ostatnie pliki"),
+    ("Create a new project, or open the demo project to look around.", "Utwórz nowy projekt albo otwórz projekt demonstracyjny, aby się rozejrzeć."),
+    ("No recent files match the filter", "Żaden ostatni plik nie pasuje do filtra"),
+    ("Try another name or folder.", "Spróbuj innej nazwy lub folderu."),
+    ("Just now", "Przed chwilą"),
+    ("Yesterday", "Wczoraj"),
+    ("{} minute ago", "{} minutę temu"),
+    ("{} minutes ago", "{} min temu"),
+    ("{} hour ago", "{} godzinę temu"),
+    ("{} hours ago", "{} godz. temu"),
+    ("{} day ago", "{} dzień temu"),
+    ("{} days ago", "{} dni temu"),
+    ("EffectCraft project", "Projekt EffectCraft"),
+    ("After Effects project", "Projekt After Effects"),
+    ("Lottie animation", "Animacja Lottie"),
+    ("Project", "Projekt"),
+    ("General", "Ogólne"),
+    ("Language", "Język"),
+    ("Levels of Undo", "Poziomy cofania"),
+    ("Path Point and Handle Size", "Rozmiar punktów i uchwytów ścieżki"),
+    ("Recent Projects Shown", "Liczba wyświetlanych ostatnich projektów"),
+    ("Options", "Opcje"),
+    ("Show Tool Tips", "Pokazuj podpowiedzi"),
+    ("Create Layers at Composition Start Time", "Twórz warstwy w czasie początku kompozycji"),
+    ("Switches Affect Nested Comps", "Przełączniki wpływają na zagnieżdżone kompozycje"),
+    ("Default Spatial Interpolation to Linear", "Domyślna interpolacja przestrzenna liniowa"),
+    ("Preserve Constant Vertex and Feather Point Count when Editing Masks", "Zachowaj stałą liczbę wierzchołków i punktów wtapiania podczas edycji masek"),
+    ("Synchronize Time of All Related Items", "Synchronizuj czas wszystkich powiązanych elementów"),
+    ("Expression Pick Whip Writes Compact English", "Łącznik wyrażeń zapisuje zwięzły angielski"),
+    ("Create Split Layers Above Original Layer", "Twórz podzielone warstwy nad oryginalną warstwą"),
+    ("Use System Color Picker", "Używaj systemowego próbnika kolorów"),
+    (
+        "EffectCraft always uses its own colour picker (the same on every platform and the web).",
+        "EffectCraft zawsze używa własnego próbnika kolorów (takiego samego na każdej platformie i w przeglądarce).",
+    ),
+    ("Startup & Repair", "Uruchamianie i naprawa"),
+    ("Show Home Screen When Launching", "Pokazuj ekran startowy przy uruchamianiu"),
+    ("Show Home Screen When Opening a Project", "Pokazuj ekran startowy przy otwieraniu projektu"),
+    ("Offer to Open the Latest Auto-Save After a Crash", "Proponuj otwarcie ostatniego autozapisu po awarii"),
+    ("Window Graphics", "Grafika okna"),
+    ("Automatic", "Automatycznie"),
+    (
+        "Window Graphics applies from the next launch. When the graphics driver stops EffectCraft as its window opens, the next launch switches to OpenGL.",
+        "Grafika okna obowiązuje od następnego uruchomienia. Gdy sterownik graficzny zatrzyma EffectCraft przy otwieraniu okna, następne uruchomienie przełączy się na OpenGL.",
+    ),
+    ("Repair", "Naprawa"),
+    ("Reset Settings", "Resetuj ustawienia"),
+    ("Reset Keyboard Shortcuts", "Resetuj skróty klawiaturowe"),
+    ("Empty Disk Cache", "Opróżnij pamięć dyskową"),
+    ("New Project Loads Template", "Nowy projekt wczytuje szablon"),
+    ("Template Project", "Projekt szablonu"),
+    ("Auto-Save", "Autozapis"),
+    ("Automatically Save Projects", "Automatycznie zapisuj projekty"),
+    ("Save Every", "Zapisuj co"),
+    ("Minutes", "min"),
+    ("Maximum Project Versions", "Maksymalna liczba wersji projektu"),
+    ("Auto-Save Location", "Lokalizacja autozapisu"),
+    ("Next to Project", "Obok projektu"),
+    ("Custom Location", "Lokalizacja niestandardowa"),
+    ("Save When Starting Render Queue", "Zapisuj przy uruchamianiu kolejki renderowania"),
+    ("Save Now", "Zapisz teraz"),
+    ("Motion Path", "Ścieżka ruchu"),
+    ("All Keyframes", "Wszystkie klatki kluczowe"),
+    ("No Motion Path", "Bez ścieżki ruchu"),
+    ("No More Than (Seconds)", "Nie więcej niż (sekundy)"),
+    ("No More Than (Keyframes)", "Nie więcej niż (klatki kluczowe)"),
+    ("Seconds", "s"),
+    ("Keyframes", "Klatki kluczowe"),
+    ("Display", "Wyświetlanie"),
+    ("Show Rendering Progress in Info Panel and Flowchart", "Pokazuj postęp renderowania w panelu Informacje i schemacie"),
+    ("Hardware Accelerate Composition, Layer and Footage Panels", "Akceleracja sprzętowa paneli Kompozycja, Warstwa i Materiał"),
+    ("Panels are always drawn by the GPU (wgpu).", "Panele są zawsze rysowane przez GPU (wgpu)."),
+    ("Previews", "Podglądy"),
+    ("Adaptive Resolution Limit", "Limit rozdzielczości adaptacyjnej"),
+    ("Show Internal Wireframes", "Pokazuj wewnętrzne szkielety"),
+    ("Cache Frames When Idle", "Buforuj klatki w bezczynności"),
+    ("Viewer Zoom Quality", "Jakość powiększenia przeglądarki"),
+    ("Faster", "Szybciej"),
+    ("More Accurate", "Dokładniej"),
+    ("Display Color Space", "Przestrzeń kolorów wyświetlacza"),
+    ("GPU Information...", "Informacje o GPU..."),
+    ("Appearance", "Wygląd"),
+    ("Brightness", "Jasność"),
+    ("UI Scale", "Skala interfejsu"),
+    ("Labels and Colors", "Etykiety i kolory"),
+    ("Use Label Color for Layer Handles and Paths", "Używaj koloru etykiety dla uchwytów i ścieżek warstw"),
+    ("Use Label Color for Related Tabs", "Używaj koloru etykiety dla powiązanych kart"),
+    ("Cycle Mask Colors", "Zmieniaj kolejno kolory masek"),
+    ("Use Gradients", "Używaj gradientów"),
+    ("Menu Bar", "Pasek menu"),
+    ("Grids & Guides", "Siatki i linie pomocnicze"),
+    ("Gridline Every", "Linia siatki co"),
+    ("Subdivisions", "Podpodziały"),
+    ("Style", "Styl"),
+    ("Lines", "Linie"),
+    ("Dashed Lines", "Linie przerywane"),
+    ("Dots", "Kropki"),
+    ("Horizontal", "Poziomo"),
+    ("Vertical", "Pionowo"),
+    ("Safe Margins", "Marginesy bezpieczne"),
+    ("Action-safe", "Bezpieczny dla akcji"),
+    ("Title-safe", "Bezpieczny dla tytułów"),
+    ("Labels", "Etykiety"),
+    ("Text Engine", "Silnik tekstu"),
+    ("Latin", "Łaciński"),
+    ("South Asian and Middle Eastern", "Południowoazjatycki i bliskowschodni"),
+    ("Show Font Preview", "Pokazuj podgląd czcionki"),
+    ("Number of Recent Fonts to Display", "Liczba wyświetlanych ostatnich czcionek"),
+    ("Show Font Names in English", "Pokazuj nazwy czcionek po angielsku"),
+    ("Still Footage", "Materiał nieruchomy"),
+    ("Length of Composition", "Długość kompozycji"),
+    ("Duration (Seconds)", "Czas trwania (sekundy)"),
+    ("Still Duration", "Czas trwania obrazu"),
+    ("Sequence Footage", "Materiał sekwencyjny"),
+    ("Report Missing Frames", "Zgłaszaj brakujące klatki"),
+    ("Automatically Reload Footage", "Automatycznie wczytuj ponownie materiał"),
+    ("Off", "Wył."),
+    ("Non-Sequence Footage", "Materiał niesekwencyjny"),
+    ("All Footage", "Wszystkie materiały"),
+    ("Ask User", "Pytaj użytkownika"),
+    ("Guess", "Zgadnij"),
+    ("Ignore", "Ignoruj"),
+    ("Straight", "Prosta"),
+    ("Premultiplied", "Wstępnie mnożona"),
+    ("Default Drag Import As", "Domyślny import przeciągnięciem jako"),
+    ("Footage", "Materiał"),
+    ("Composition - Retain Layer Sizes", "Kompozycja – zachowaj rozmiary warstw"),
+    ("Export", "Eksport"),
+    ("Default Output Folder", "Domyślny folder wyjściowy"),
+    ("Segment Sequences", "Dziel sekwencje na segmenty"),
+    ("Files per Segment", "Pliki na segment"),
+    ("files", "pliki"),
+    ("Segment Movie Files", "Dziel pliki filmowe na segmenty"),
+    ("Segment Size", "Rozmiar segmentu"),
+    ("Append Bit Depth to File Name", "Dodawaj głębię bitową do nazwy pliku"),
+    ("Audio", "Audio"),
+    ("Audio Hardware", "Sprzęt audio"),
+    ("Preview Sample Rate", "Częstotliwość próbkowania podglądu"),
+    ("Audio Output Mapping", "Mapowanie wyjść audio"),
+    ("Left", "Lewy"),
+    ("Right", "Prawy"),
+    ("channel", "kanał"),
+    ("Disk", "Dysk"),
+    ("Disk Cache", "Pamięć dyskowa"),
+    ("Enable Disk Cache", "Włącz pamięć dyskową"),
+    ("Maximum Disk Cache Size", "Maksymalny rozmiar pamięci dyskowej"),
+    ("Disk Cache Folder", "Folder pamięci dyskowej"),
+    ("Media Cache", "Pamięć multimediów"),
+    ("Database and Cache Folder", "Folder bazy danych i pamięci"),
+    ("Conformed Audio Folder", "Folder dopasowanego audio"),
+    ("Memory & CPU", "Pamięć i procesor"),
+    ("RAM Reserved for Other Applications", "Pamięć RAM zarezerwowana dla innych aplikacji"),
+    ("Cache Budgets", "Budżety pamięci podręcznej"),
+    ("Layer Cache", "Pamięć warstw"),
+    ("Footage Frame Cache", "Pamięć klatek materiałów"),
+    ("Preview (RAM) Cache", "Pamięć podglądu (RAM)"),
+    ("Reduce Cache Size When System Is Low on Memory", "Zmniejsz pamięć podręczną, gdy w systemie brakuje pamięci"),
+    ("Video", "Wideo"),
+    ("Enable Video Preview Output", "Włącz wyjście podglądu wideo"),
+    ("Video Device", "Urządzenie wideo"),
+    ("Floating Window", "Okno pływające"),
+    ("Full Screen", "Pełny ekran"),
+    ("Video Output During Playback", "Wyjście wideo podczas odtwarzania"),
+    ("Mirror on Computer Monitor", "Powielaj na monitorze komputera"),
+    ("Disable Video Output When in Background", "Wyłącz wyjście wideo w tle"),
+    ("Default 3D Renderer", "Domyślny renderer 3D"),
+    ("Show 3D Reference Axes", "Pokazuj osie odniesienia 3D"),
+    ("Extended Viewer", "Rozszerzona przeglądarka"),
+    ("Realtime Shadows in Draft", "Cienie w czasie rzeczywistym w trybie roboczym"),
+    ("Scripting & Expressions", "Skrypty i wyrażenia"),
+    ("Application Scripting", "Skrypty aplikacji"),
+    ("Allow Scripts to Write Files and Access Network", "Zezwalaj skryptom na zapis plików i dostęp do sieci"),
+    ("Warn User When Executing Files", "Ostrzegaj przy uruchamianiu plików"),
+    ("Enable JavaScript Debugger", "Włącz debuger JavaScript"),
+    ("Expressions Editor", "Edytor wyrażeń"),
+    ("Font Size", "Rozmiar czcionki"),
+    ("Syntax Highlighting", "Podświetlanie składni"),
+    ("Line Numbers", "Numery wierszy"),
+    ("Auto-complete", "Autouzupełnianie"),
+    ("Bracket Matching", "Dopasowywanie nawiasów"),
+    ("Word Wrap", "Zawijanie wierszy"),
+    ("Show Expression Error Banner", "Pokazuj pasek błędów wyrażeń"),
+    (
+        "Expressions use the JavaScript engine. Script errors report their file and line in the Script Console; there is no step debugger.",
+        "Wyrażenia używają silnika JavaScript. Błędy skryptów podają plik i wiersz w konsoli skryptów; nie ma debugera krokowego.",
+    ),
+    ("Roto Brush", "Pędzel Roto"),
+    ("Segmentation Model", "Model segmentacji"),
+    (
+        "Roto Brush 2.0 and 3.0 use the model chosen here (Version 1.0 always uses the classic engine). Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
+        "Pędzel Roto 2.0 i 3.0 używa wybranego tu modelu (wersja 1.0 zawsze używa klasycznego silnika). Modele są open source, pobierane tylko na Twoje żądanie i sprawdzane z opublikowanym SHA-256.",
+    ),
+    ("Face Tracking", "Śledzenie twarzy"),
+    ("Face Model", "Model twarzy"),
+    (
+        "Face tracking in the Tracker panel (Outline Only and Detailed Features) uses the model chosen here. Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
+        "Śledzenie twarzy w panelu Śledzenie (tylko kontur i szczegółowe cechy) używa wybranego tu modelu. Modele są open source, pobierane tylko na Twoje żądanie i sprawdzane z opublikowanym SHA-256.",
+    ),
+    ("Match System", "Zgodnie z systemem"),
+    ("Default", "Domyślny"),
+    ("Stored, but not used by EffectCraft yet", "Zapisane, ale jeszcze nieużywane przez EffectCraft"),
+    ("Total Offset", "Całkowite przesunięcie"),
+    ("Per Layer", "Na warstwę"),
+    ("Track", "Ścieżka"),
+    ("Copy", "Kopiuj"),
+    ("Paste", "Wklej"),
+    ("Edit Value…", "Edytuj wartość…"),
+    ("Remove Expression", "Usuń wyrażenie"),
+    ("Effects", "Efekty"),
+    ("Copy Source Path", "Kopiuj ścieżkę źródła"),
+    ("Resolution:", "Rozdzielczość:"),
+    ("Guide Layer", "Warstwa pomocnicza"),
+    ("Layer Styles", "Style warstwy"),
 ];
 
 /// Czech (cs): original translations covering every row in the Chinese panel catalogs.
 const CZECH: &[(&str, &str)] = &[
+    ("Click to sample color", "Kliknutím naberete barvu"),
     ("   OK   ", "   OK   "),
     ("  Delete  ", "  Odstranit  "),
     (" Open Auto-Save ", " Otevřít automatickou zálohu "),
@@ -3491,7 +6940,6 @@ const CZECH: &[(&str, &str)] = &[
     ("Duration:", "Délka trvání:"),
     ("Edit Gradient…", "Upravit přechod…"),
     ("Edit Target: {}", "Upravit cíl: {}"),
-    ("Edit in the Timeline", "Upravit na časové ose"),
     ("EffectCraft didn't quit normally last time.", "EffectCraft nebyl při posledním použití ukončen běžným způsobem."),
     ("Effects", "Efekty"),
     ("Effects & Presets options", "Možnosti efektů a přednastavení"),
@@ -3601,6 +7049,7 @@ const CZECH: &[(&str, &str)] = &[
     ("New", "Nový"),
     ("New Comp from Selection", "Nová kompozice z výběru"),
     ("Replace with Precomposition", "Nahradit předkompozicí"),
+    ("Rescan Fonts", "Znovu nalézt písma"),
     ("used once", "použito jednou"),
     ("used {} times", "použito {}×"),
     ("Compositions that use this item", "Kompozice, které tuto položku používají"),
@@ -3651,6 +7100,7 @@ const CZECH: &[(&str, &str)] = &[
     ("Overlay", "Překrytí"),
     ("Parameter Name:", "Název parametru:"),
     ("Parent pick whip: drag onto a layer", "Propojovací nástroj nadřazené vrstvy: přetáhněte na vrstvu"),
+    ("Track Matte pick whip: drag onto a layer", "Propojovací nástroj masky stopy: přetáhněte na vrstvu"),
     ("Pixel Aspect Ratio:", "Poměr stran pixelů:"),
     ("Playing on Video Preview", "Přehrávání ve videonáhledu"),
     ("Post-Render Action: {}", "Akce po vykreslení: {}"),
@@ -3911,6 +7361,7 @@ const CZECH: &[(&str, &str)] = &[
 /// order. Terms follow the Spanish menu catalog (composición, material de archivo, cola de procesamiento,
 /// ajuste preestablecido, método abreviado). Written from the English source.
 const SPANISH: &[(&str, &str)] = &[
+    ("Click to sample color", "Haz clic para tomar una muestra de color"),
     ("Copy Source Path", "Copiar ruta de origen"),
     ("Appearance Settings…", "Ajustes de apariencia…"),
     ("Add to favorites", "Añadir a favoritos"),
@@ -4056,7 +7507,6 @@ const SPANISH: &[(&str, &str)] = &[
     ("Duration:", "Duración:"),
     ("Edit Gradient…", "Editar degradado…"),
     ("Edit Target: {}", "Destino de la edición: {}"),
-    ("Edit in the Timeline", "Editar en la cronología"),
     ("EffectCraft didn't quit normally last time.", "EffectCraft no se cerró normalmente la última vez."),
     ("Effects", "Efectos"),
     ("Effects & Presets options", "Opciones de Efectos y ajustes preestablecidos"),
@@ -4184,6 +7634,7 @@ const SPANISH: &[(&str, &str)] = &[
     ("No layer selected", "No hay ninguna capa seleccionada"),
     ("No matching effects or presets", "No hay efectos ni ajustes preestablecidos que coincidan"),
     ("No matching fonts", "No hay fuentes coincidentes"),
+    ("Rescan Fonts", "Volver a analizar fuentes"),
     ("Variable fonts only", "Solo fuentes variables"),
     ("No model credits were built into this copy.", "No se incluyeron créditos de modelos en esta copia."),
     ("No nested compositions", "No hay composiciones anidadas"),
@@ -4214,6 +7665,7 @@ const SPANISH: &[(&str, &str)] = &[
     ("Overlay", "Superposición"),
     ("Parameter Name:", "Nombre del parámetro:"),
     ("Parent pick whip: drag onto a layer", "Selector de capa padre: arrastra hasta una capa"),
+    ("Track Matte pick whip: drag onto a layer", "Selector de mate de seguimiento: arrastra hasta una capa"),
     ("Pixel Aspect Ratio:", "Relación de aspecto de píxel:"),
     ("Playing on Video Preview", "Reproduciendo en la previsualización de vídeo"),
     ("Post-Render Action: {}", "Acción posterior al procesamiento: {}"),
@@ -4467,6 +7919,7 @@ const SPANISH: &[(&str, &str)] = &[
 
 /// Georgian (ka): every row of the Chinese catalogs, in the same order (the tests keep them in step).
 const GEORGIAN: &[(&str, &str)] = &[
+    ("Click to sample color", "დააწკაპუნეთ ფერის ნიმუშის ასაღებად"),
     ("Appearance Settings…", "იერსახის პარამეტრები…"),
     ("Add to favorites", "რჩეულებში დამატება"),
     ("Remove from favorites", "რჩეულებიდან ამოშლა"),
@@ -4605,7 +8058,6 @@ const GEORGIAN: &[(&str, &str)] = &[
     ("Duration:", "ხანგრძლივობა:"),
     ("Edit Gradient…", "გრადიენტის რედაქტირება…"),
     ("Edit Target: {}", "რედაქტირების სამიზნე: {}"),
-    ("Edit in the Timeline", "რედაქტირება დროის ხაზზე"),
     ("EffectCraft didn't quit normally last time.", "EffectCraft ბოლოს ნორმალურად არ დახურულა."),
     ("Effects", "ეფექტები"),
     ("Effects & Presets options", "ეფექტებისა და პრესეტების პარამეტრები"),
@@ -4977,9 +8429,9 @@ const GEORGIAN: &[(&str, &str)] = &[
     ("Import Image Sequence", "გამოსახულებების თანმიმდევრობის იმპორტი"),
     ("Import PDF / Illustrator File", "PDF / Illustrator ფაილის იმპორტი"),
     ("Import Photoshop File", "Photoshop ფაილის იმპორტი"),
-    ("Interpret Unlabeled Alpha As", "არამონიშნული ალფას ინტერპრეტაცია როგორც"),
-    ("Join the ArtCraft Discord", "შემოუერთდით ArtCraft-ის Discord-ს"),
-    ("Mercury GPU Acceleration ({})", "Mercury GPU აჩქარება ({})"),
+    ("Interpret Unlabeled Alpha As", "უცნობი ალფას ინტერპრეტაცია"),
+    ("Join the ArtCraft Discord", "შემოგვიერთდით Discord-ზე"),
+    ("Mercury GPU Acceleration ({})", "GPU აჩქარება ({})"),
     ("Mercury Software Only", "მხოლოდ Mercury Software"),
     ("OCIO (built-in ACES config)", "OCIO (ჩაშენებული ACES კონფიგურაცია)"),
     ("Off (Final Quality)", "გამორთული (საბოლოო ხარისხი)"),
@@ -4998,7 +8450,7 @@ const GEORGIAN: &[(&str, &str)] = &[
     ("EffectCraft on GitHub", "EffectCraft GitHub-ზე"),
     ("Motion graphics and visual effects · version {}", "მოძრავი გრაფიკა და ვიზუალური ეფექტები · ვერსია {}"),
     ("New Composition", "ახალი კომპოზიცია"),
-    ("Open Demo Project", "სადემონსტრაციო პროექტის გახსნა"),
+    ("Open Demo Project", "დემო-პროექტის გახსნა"),
     ("Import Footage…", "ვიდეომასალის იმპორტი…"),
     ("Filter recent files", "ბოლო ფაილების გაფილტვრა"),
     ("NAME", "სახელი"),
@@ -5024,7 +8476,7 @@ const GEORGIAN: &[(&str, &str)] = &[
     ("General", "ზოგადი"),
     ("Language", "ენა"),
     ("Levels of Undo", "დაბრუნების დონეები"),
-    ("Path Point and Handle Size", "ტრაექტორიის წერტილისა და სახელურის ზომა"),
+    ("Path Point and Handle Size", "წერტილისა და სახელურის ზომა"),
     ("Recent Projects Shown", "ნაჩვენები ბოლო პროექტები"),
     ("Options", "პარამეტრები"),
     ("Show Tool Tips", "მინიშნებების ჩვენება"),
@@ -5063,7 +8515,7 @@ const GEORGIAN: &[(&str, &str)] = &[
     ("Automatically Save Projects", "პროექტების ავტომატური შენახვა"),
     ("Save Every", "შენახვა ყოველ"),
     ("Minutes", "წუთში"),
-    ("Maximum Project Versions", "პროექტის ვერსიების მაქსიმალური რაოდენობა"),
+    ("Maximum Project Versions", "ვერსიების მაქსიმალური რაოდენობა"),
     ("Auto-Save Location", "ავტოშენახვის მდებარეობა"),
     ("Next to Project", "პროექტის გვერდით"),
     ("Custom Location", "სხვა მდებარეობა"),
@@ -5084,7 +8536,7 @@ const GEORGIAN: &[(&str, &str)] = &[
     ("Adaptive Resolution Limit", "ადაპტური გარჩევადობის ზღვარი"),
     ("Show Internal Wireframes", "შიდა კარკასების ჩვენება"),
     ("Cache Frames When Idle", "კადრების ქეშირება უქმობისას"),
-    ("Viewer Zoom Quality", "დამთვალიერებლის მასშტაბირების ხარისხი"),
+    ("Viewer Zoom Quality", "დამთვალიერებლის მასშტაბის ხარისხი"),
     ("Faster", "უფრო სწრაფი"),
     ("More Accurate", "უფრო ზუსტი"),
     ("Display Color Space", "ეკრანის ფერთა სივრცე"),
@@ -5115,7 +8567,7 @@ const GEORGIAN: &[(&str, &str)] = &[
     ("Latin", "ლათინური"),
     ("South Asian and Middle Eastern", "სამხრეთაზიური და ახლო აღმოსავლური"),
     ("Show Font Preview", "შრიფტის წინასწარი ნახვის ჩვენება"),
-    ("Number of Recent Fonts to Display", "საჩვენებელი ბოლო შრიფტების რაოდენობა"),
+    ("Number of Recent Fonts to Display", "ბოლო შრიფტების რაოდენობა"),
     ("Show Font Names in English", "შრიფტების სახელების ინგლისურად ჩვენება"),
     ("Still Footage", "უძრავი ვიდეომასალა"),
     ("Length of Composition", "კომპოზიციის სიგრძე"),
@@ -5123,7 +8575,7 @@ const GEORGIAN: &[(&str, &str)] = &[
     ("Still Duration", "უძრავი კადრის ხანგრძლივობა"),
     ("Sequence Footage", "სეკვენციური ვიდეომასალა"),
     ("Report Missing Frames", "გამოტოვებული კადრების შეტყობინება"),
-    ("Automatically Reload Footage", "ვიდეომასალის ავტომატური ხელახლა ჩატვირთვა"),
+    ("Automatically Reload Footage", "ავტომატური ხელახლა ჩატვირთვა"),
     ("Off", "გამორთული"),
     ("Non-Sequence Footage", "არასეკვენციური ვიდეომასალა"),
     ("All Footage", "მთელი ვიდეომასალა"),
@@ -5132,7 +8584,7 @@ const GEORGIAN: &[(&str, &str)] = &[
     ("Ignore", "უგულებელყოფა"),
     ("Straight", "პირდაპირი"),
     ("Premultiplied", "წინასწარ გამრავლებული"),
-    ("Default Drag Import As", "გადათრევით იმპორტი ნაგულისხმევად როგორც"),
+    ("Default Drag Import As", "გადათრევით იმპორტი როგორც"),
     ("Footage", "ვიდეომასალა"),
     ("Composition - Retain Layer Sizes", "კომპოზიცია - შრეების ზომების შენარჩუნებით"),
     ("Export", "ექსპორტი"),
@@ -5145,7 +8597,7 @@ const GEORGIAN: &[(&str, &str)] = &[
     ("Append Bit Depth to File Name", "ბიტური სიღრმის ფაილის სახელზე დამატება"),
     ("Audio", "აუდიო"),
     ("Audio Hardware", "აუდიოაპარატურა"),
-    ("Preview Sample Rate", "წინასწარი ნახვის დისკრეტიზაციის სიხშირე"),
+    ("Preview Sample Rate", "ნახვის დისკრეტიზაციის სიხშირე"),
     ("Audio Output Mapping", "აუდიოს გამოტანის ასახვა"),
     ("Left", "მარცხენა"),
     ("Right", "მარჯვენა"),
@@ -5220,7 +8672,7 @@ const GEORGIAN: &[(&str, &str)] = &[
 /// exactly the Chinese catalogs' sources; the tests hold these to the same rules.
 const GEORGIAN_PANELS: &[(&str, &str)] = &[
     ("Search project", "პროექტში ძიება"),
-    ("Select an item to see its details", "მონიშნეთ ელემენტი მისი დეტალების სანახავად"),
+    ("Select an item to see its details", "მონიშნეთ ელემენტი დეტალებისთვის"),
     ("Media Duration", "მედიის ხანგრძლივობა"),
     ("Frame Rate", "კადრების სიხშირე"),
     ("File Path", "ფაილის მისამართი"),
@@ -5374,12 +8826,12 @@ const GEORGIAN_PANELS: &[(&str, &str)] = &[
     ("Current Frame", "მიმდინარე კადრი"),
     ("Work Area", "სამუშაო არე"),
     ("Luminance", "სიკაშკაშე"),
-    ("Create Markers", "მარკერების შექმნა"),
+    ("Create Markers", "მარკერები"),
     ("Split Layers", "შრეების დაყოფა"),
     ("Split and Precompose", "დაყოფა და კომპოზიციაში მოთავსება"),
     ("CMX 3600 EDL (.edl, V1 only)", "CMX 3600 EDL (.edl, მხოლოდ V1)"),
     ("OMF (.omf, audio)", "OMF (.omf, აუდიო)"),
-    ("Layers Premiere can't show (text, shapes, effects…)", "შრეები, რომლებსაც Premiere ვერ აჩვენებს (ტექსტი, ფიგურები, ეფექტები…)"),
+    ("Layers Premiere can't show (text, shapes, effects…)", "Premiere-ში უხილავი შრეები"),
     ("All layers", "ყველა შრე"),
     ("None (leave them out)", "არცერთი (გამოტოვება)"),
     ("Nested sequences", "ჩადგმული სეკვენციები"),
@@ -5421,6 +8873,1288 @@ const GEORGIAN_PANELS: &[(&str, &str)] = &[
     ("Solid…", "სოლიდი…"),
 ];
 
+/// French: vouvoiement, infinitive for commands, sentence case; the same source strings as the other
+/// panel catalogs together (the Chinese ones, Georgian's extra panel rows and the literals the converted
+/// panels pass to `tr`). Terms follow the French menu catalog in [`super`] (composition, calque, image
+/// clé, métrage, file d'attente de rendu, chronologie, repère, estampe). A no-break space precedes
+/// `:`, `;`, `?` and `!`, and the apostrophe is the typographic one. Written from the English source.
+const FRENCH: &[(&str, &str)] = &[
+    ("Appearance Settings…", "Paramètres d’apparence…"),
+    ("Add to favorites", "Ajouter aux favoris"),
+    ("Remove from favorites", "Retirer des favoris"),
+    ("   OK   ", "   OK   "),
+    ("  Delete  ", "  Supprimer  "),
+    (" Open Auto-Save ", " Ouvrir l’enregistrement automatique "),
+    ("(missing)", "(manquant)"),
+    ("360 View Orientation", "Orientation de la vue 360°"),
+    ("3:2 Pulldown: {}", "Pulldown 3:2 : {}"),
+    (
+        "A clean-room, open-source compositor for motion graphics and visual effects: native on macOS, Windows and Linux, and in the browser. Part of the ArtCraft family of creative apps.",
+        "Un compositeur open source, développé en salle blanche, pour le motion design et les effets visuels : natif sur macOS, Windows et Linux, ainsi que dans le navigateur. Fait partie de la famille d’applications créatives ArtCraft.",
+    ),
+    ("About EffectCraft", "À propos d’EffectCraft"),
+    ("About...", "À propos..."),
+    ("Active", "Actif"),
+    ("Active Camera", "Caméra active"),
+    ("Alpha", "Alpha"),
+    ("Adapt Feature On Every Frame", "Adapter la caractéristique à chaque image"),
+    ("Adaptive Sample Limit:", "Limite d’échantillons adaptatifs :"),
+    ("Add Animator", "Ajouter un animateur"),
+    ("Add Comment", "Ajouter un commentaire"),
+    ("Add Formatting", "Ajouter une mise en forme"),
+    ("Add Group", "Ajouter un groupe"),
+    ("Add Mirror", "Ajouter un miroir"),
+    ("Add Selected As", "Ajouter la sélection comme"),
+    ("Add a comment", "Ajouter un commentaire"),
+    ("Add a shape, fill, stroke or path operation", "Ajouter une forme, un remplissage, un contour ou une opération sur le tracé"),
+    ("Add to Composition", "Ajouter à la composition"),
+    ("Add to Favorites", "Ajouter aux favoris"),
+    ("Add:", "Ajouter :"),
+    ("Adjust Exposure (stops)", "Ajuster l’exposition (diaphs)"),
+    (
+        "Adjust composition duration to the time span of the selected layers",
+        "Ajuster la durée de la composition à l’intervalle de temps des calques sélectionnés",
+    ),
+    ("Advanced 3D", "3D avancée"),
+    ("Align Layers to:", "Aligner les calques sur :"),
+    ("All six face cameras turn together; the scene is not changed.", "Les six caméras des faces tournent ensemble ; la scène n’est pas modifiée."),
+    ("Anchor:", "Ancrage :"),
+    ("Aperture", "Ouverture"),
+    ("Appearance Mode", "Mode d’apparence"),
+    ("Appearance Mode: {}", "Mode d’apparence : {}"),
+    ("Apply Dimensions:", "Appliquer les dimensions :"),
+    ("Apply Motion To:", "Appliquer le mouvement à :"),
+    ("Arrange", "Disposition"),
+    ("Assign", "Attribuer"),
+    ("Auto", "Auto"),
+    ("Auto-saves", "Enregistrements automatiques"),
+    ("Back", "Retour"),
+    ("Background Color:", "Couleur d’arrière-plan :"),
+    ("Blend Mode:", "Mode de fusion :"),
+    ("Blending Mode", "Mode de fusion"),
+    ("Blur", "Flou"),
+    ("Blur Level", "Niveau de flou"),
+    ("Boundary", "Limite"),
+    ("Browser Storage", "Stockage du navigateur"),
+    ("Browse…", "Parcourir…"),
+    ("Brush Dynamics", "Dynamique du pinceau"),
+    ("Caching frames…", "Mise en cache des images…"),
+    ("Cancel", "Annuler"),
+    ("Casts Shadows", "Projette des ombres"),
+    ("Change Renderer…", "Changer de moteur de rendu…"),
+    (
+        "Changing a shortcut creates a custom preset; the default stays as it is.",
+        "Modifier un raccourci crée un préréglage personnalisé ; le préréglage par défaut reste inchangé.",
+    ),
+    ("Channel", "Canal"),
+    ("Channel:", "Canal :"),
+    ("Chapter:", "Chapitre :"),
+    ("Choose...", "Choisir..."),
+    ("Classic 3D", "3D classique"),
+    ("Clear", "Effacer"),
+    ("Clear list", "Effacer la liste"),
+    ("Click a key to see its commands.", "Cliquez sur une touche pour voir ses commandes."),
+    (
+        "Click above the bar to add an opacity stop, below it to add a color stop.",
+        "Cliquez au-dessus de la barre pour ajouter un point d’arrêt d’opacité, en dessous pour ajouter un point d’arrêt de couleur.",
+    ),
+    ("Click adds a point (½ height = no change)", "Un clic ajoute un point (½ hauteur = aucun changement)"),
+    ("Click adds a point; drag one off to remove", "Un clic ajoute un point ; faites-en glisser un hors de la zone pour le supprimer"),
+    ("Click to make this viewer active", "Cliquez pour activer ce visualiseur"),
+    ("Click to reveal the expression in the timeline", "Cliquez pour révéler l’expression dans la chronologie"),
+    ("Click to show the active composition here", "Cliquez pour afficher ici la composition active"),
+    ("Click, then click in the Composition panel", "Cliquez, puis cliquez dans le panneau Composition"),
+    ("Clone Options", "Options de clonage"),
+    ("Clone Source Overlay:", "Superposition de la source de clonage :"),
+    ("Close", "Fermer"),
+    ("Close Panel", "Fermer le panneau"),
+    ("Close tutorial", "Fermer le tutoriel"),
+    ("Color", "Couleur"),
+    ("Color Depth: {}", "Profondeur de couleur : {}"),
+    ("Color:", "Couleur :"),
+    ("Colour map", "Carte de couleurs"),
+    ("Columns", "Colonnes"),
+    ("Comment:", "Commentaire :"),
+    ("Community", "Communauté"),
+    ("Composition", "Composition"),
+    ("Composition Mini-Flowchart", "Mini-organigramme de composition"),
+    ("Composition Name:", "Nom de la composition :"),
+    ("Composition Settings ▸ 3D Renderer", "Paramètres de composition ▸ Moteur de rendu 3D"),
+    ("Composition Settings…", "Paramètres de composition…"),
+    ("Composition marker bin: drag a marker to the time ruler", "Bac des repères de composition : faites glisser un repère vers la règle temporelle"),
+    ("Cone Angle", "Angle du cône"),
+    ("Cone Feather", "Contour progressif du cône"),
+    ("Constrain Proportions", "Conserver les proportions"),
+    ("Continuous (Lock Outgoing to Incoming)", "Continu (verrouiller la sortie sur l’entrée)"),
+    ("Cue Point", "Point de repère"),
+    ("Current Render", "Rendu en cours"),
+    ("Dark", "Sombre"),
+    ("Dark Theme", "Thème sombre"),
+    ("Darker", "Plus sombre"),
+    ("Default Output:", "Sortie par défaut :"),
+    ("Default: {}", "Par défaut : {}"),
+    ("Defaults", "Valeurs par défaut"),
+    ("Delete", "Supprimer"),
+    ("Delete Selected Points", "Supprimer les points sélectionnés"),
+    ("Delete selected project items", "Supprimer les éléments de projet sélectionnés"),
+    ("Delete this template", "Supprimer ce modèle"),
+    ("Depth of Field", "Profondeur de champ"),
+    ("Discord", "Discord"),
+    ("Distribute Layers:", "Répartir les calques :"),
+    ("Don't Recover", "Ne pas récupérer"),
+    ("Don't Save", "Ne pas enregistrer"),
+    ("Double-click a layer to open it in the Layer panel", "Double-cliquez sur un calque pour l’ouvrir dans le panneau Calque"),
+    ("Double-click footage in the Project panel to open it here", "Double-cliquez sur un métrage dans le panneau Projet pour l’ouvrir ici"),
+    ("Double-click to edit the comment", "Double-cliquez pour modifier le commentaire"),
+    ("Download", "Télécharger"),
+    (
+        "Drag properties here from the timeline,\nor use Animation > Add Property to Essential Graphics.",
+        "Faites glisser des propriétés ici depuis la chronologie,\nou utilisez Animation > Ajouter la propriété aux graphiques essentiels.",
+    ),
+    ("Drag to change", "Faites glisser pour modifier"),
+    ("Drag to create a guide", "Faites glisser pour créer un repère"),
+    ("Drag to slip the source", "Faites glisser pour décaler la source"),
+    ("Drop Frame", "Drop frame"),
+    ("Duplicate", "Dupliquer"),
+    ("Copy", "Copier"),
+    ("Paste", "Coller"),
+    ("Edit Value…", "Modifier la valeur…"),
+    ("Remove Expression", "Supprimer l’expression"),
+    ("Duration:", "Durée :"),
+    ("Edit Gradient…", "Modifier le dégradé…"),
+    ("Edit Target: {}", "Cible de modification : {}"),
+    ("EffectCraft didn't quit normally last time.", "EffectCraft ne s’est pas fermé normalement la dernière fois."),
+    ("Effects", "Effets"),
+    ("Effects & Presets options", "Options d’Effets et programmes"),
+    ("Copy Presets Folder Path", "Copier le chemin du dossier des préréglages"),
+    ("Copy Source Path", "Copier le chemin source"),
+    ("Effects: {}", "Effets : {}"),
+    ("Empty folder", "Dossier vide"),
+    ("Enable Depth of Field", "Activer la profondeur de champ"),
+    ("Enable Expression", "Activer l’expression"),
+    ("Enhance", "Améliorer"),
+    ("Essential Properties — {}", "Propriétés essentielles — {}"),
+    ("Event", "Événement"),
+    ("Export Template…", "Exporter le modèle…"),
+    ("Export...", "Exporter..."),
+    ("Expression Language Menu", "Menu du langage d’expression"),
+    ("Expression pick whip: drag onto a property", "Sélecteur d’expression : faites-le glisser sur une propriété"),
+    ("Expression:", "Expression :"),
+    ("Eyedropper: click, then click in the Composition panel", "Pipette : cliquez, puis cliquez dans le panneau Composition"),
+    ("Falloff", "Atténuation"),
+    ("Falloff Distance", "Distance d’atténuation"),
+    ("Favorites", "Favoris"),
+    ("Field Render: {}", "Rendu des trames : {}"),
+    ("Figures", "Chiffres"),
+    ("Fill Target", "Cible du remplissage"),
+    ("Finished", "Terminé"),
+    ("Flowchart: {}", "Organigramme : {}"),
+    ("Focus Distance", "Distance de mise au point"),
+    ("Follow Feature Rotation and Scale", "Suivre la rotation et l’échelle de la caractéristique"),
+    ("Footage: {}", "Métrage : {}"),
+    ("Format: {}", "Format : {}"),
+    ("Frame Aspect Ratio: {}", "Rapport d’aspect de l’image : {}"),
+    ("Frame Blending: {}", "Fusion d’images : {}"),
+    ("Frame Rate:", "Fréquence d’images :"),
+    ("Resolution:", "Résolution :"),
+    ("Frame Render Time  {}ms", "Temps de rendu de l’image  {} ms"),
+    ("Frame Target:", "Image cible :"),
+    ("Freeze", "Figer"),
+    ("Grab bag", "Divers"),
+    ("Gradient Editor", "Éditeur de dégradé"),
+    ("Grid", "Grille"),
+    ("Guide Layer", "Calque de repère"),
+    ("Guide Layers: {}", "Calques de repère : {}"),
+    ("Guides", "Repères"),
+    ("Height:", "Hauteur :"),
+    ("Hide This", "Masquer ceci"),
+    ("Histogram", "Histogramme"),
+    ("Hold In Place", "Maintenir en place"),
+    ("Home", "Accueil"),
+    ("If Confidence is Below", "Si la confiance est inférieure à"),
+    ("Import", "Importer"),
+    ("Import and Add to Composition", "Importer et ajouter à la composition"),
+    ("Import...", "Importer..."),
+    ("Imported media", "Médias importés"),
+    ("Influence:", "Influence :"),
+    ("Install from File…", "Installer à partir d’un fichier…"),
+    ("Intensity", "Intensité"),
+    ("Inverted", "Inversé"),
+    ("Join the ArtCraft community on Discord", "Rejoindre la communauté ArtCraft sur Discord"),
+    ("Key: {}", "Touche : {}"),
+    ("LEARN", "APPRENTISSAGE"),
+    ("Label", "Étiquette"),
+    ("Label Colors and Names:", "Couleurs et noms des étiquettes :"),
+    ("Label:", "Étiquette :"),
+    ("Latest auto-save: {}", "Dernier enregistrement automatique : {}"),
+    ("Layer", "Calque"),
+    ("Layer controls", "Contrôles de calque"),
+    ("Layer:", "Calque :"),
+    ("Layer: {}", "Calque : {}"),
+    ("Layer Styles", "Styles de calque"),
+    ("Learn", "Apprentissage"),
+    ("Leave all attributes in \"{}\"", "Conserver tous les attributs dans « {} »"),
+    ("Licence: {}", "Licence : {}"),
+    ("Ligatures", "Ligatures"),
+    ("Light", "Clair"),
+    ("Light Theme", "Thème clair"),
+    ("Light Type", "Type de lumière"),
+    ("Lighter", "Plus clair"),
+    ("Link Selected Property", "Lier la propriété sélectionnée"),
+    ("Location:", "Emplacement :"),
+    ("Lock Aspect Ratio to {}", "Verrouiller le rapport d’aspect sur {}"),
+    ("Lock to Zoom", "Verrouiller sur le zoom"),
+    ("Locked: {} — {}", "Verrouillé : {} — {}"),
+    ("Log:", "Journal :"),
+    ("Loop (Trace Path)", "Boucle (suivre le tracé)"),
+    ("MIT OR Apache-2.0 • Fonts: Inter, JetBrains Mono (OFL)", "MIT OR Apache-2.0 • Polices : Inter, JetBrains Mono (OFL)"),
+    ("Magnification ratio popup", "Menu du rapport d’agrandissement"),
+    ("Make Comp Size", "Adopter la taille de la composition"),
+    ("Markers", "Repères"),
+    ("Masks", "Masques"),
+    ("Maximize Panel", "Agrandir le panneau"),
+    ("Media Replacement", "Remplacement de média"),
+    ("Mesh:", "Maillage :"),
+    ("Diameter:", "Diamètre :"),
+    ("Method Used: {}    Average Error: {} pixels", "Méthode utilisée : {}    Erreur moyenne : {} pixels"),
+    ("Models folder: {}", "Dossier des modèles : {}"),
+    ("Modifiers:", "Modificateurs :"),
+    ("More", "Plus"),
+    ("More ArtCraft apps", "Autres applications ArtCraft"),
+    ("More tutorials", "Autres tutoriels"),
+    ("Motion Blur", "Flou de mouvement"),
+    ("Motion Blur: {}", "Flou de mouvement : {}"),
+    ("Motion Sketch: drag to record", "Croquis de mouvement : faites glisser pour enregistrer"),
+    ("Move Down", "Descendre"),
+    ("Move Up", "Monter"),
+    ("Move to Project Root", "Déplacer à la racine du projet"),
+    ("Name", "Nom"),
+    ("Name:", "Nom :"),
+    ("Navigation", "Navigation"),
+    ("New", "Nouveau"),
+    ("New Comp from Selection", "Nouvelle composition à partir de la sélection"),
+    ("Replace with Precomposition", "Remplacer par une précomposition"),
+    ("New Duration:", "Nouvelle durée :"),
+    ("New composition name:", "Nom de la nouvelle composition :"),
+    ("New from Render Queue item:", "Nouveau à partir de l’élément de la file d’attente de rendu :"),
+    ("New from Template", "Nouveau à partir d’un modèle"),
+    ("Next", "Suivant"),
+    (
+        "Nice work. Pick another tutorial on the Home screen's Learn tab.",
+        "Bon travail. Choisissez un autre tutoriel dans l’onglet Apprentissage de l’écran d’accueil.",
+    ),
+    (
+        "No VR environments yet. Create one with Composition ▸ VR ▸ Create VR Environment…",
+        "Aucun environnement VR pour le moment. Créez-en un avec Composition ▸ VR ▸ Créer un environnement VR…",
+    ),
+    ("No audio layer selected", "Aucun calque audio sélectionné"),
+    ("No background jobs running", "Aucune tâche en arrière-plan en cours"),
+    ("No composition markers", "Aucun repère de composition"),
+    ("No contributor data was built into this copy.", "Aucune donnée sur les contributeurs n’est intégrée à cette copie."),
+    (
+        "No device list from this host; the system default output is used.",
+        "Aucune liste de périphériques fournie par cet hôte ; la sortie par défaut du système est utilisée.",
+    ),
+    ("No layer selected", "Aucun calque sélectionné"),
+    ("No matching effects or presets", "Aucun effet ni préréglage correspondant"),
+    ("No matching fonts", "Aucune police correspondante"),
+    ("Variable fonts only", "Polices variables uniquement"),
+    ("No model credits were built into this copy.", "Aucun crédit de modèle n’est intégré à cette copie."),
+    ("No nested compositions", "Aucune composition imbriquée"),
+    ("No shortcut", "Aucun raccourci"),
+    ("No unlocked layer selected", "Aucun calque déverrouillé sélectionné"),
+    ("No video", "Aucune vidéo"),
+    ("None", "Aucun"),
+    ("Not applied: tick it in the list to add it.", "Non appliqué : cochez-le dans la liste pour l’ajouter."),
+    ("Not assigned", "Non attribué"),
+    (
+        "Note: Shadows are only cast from layers with Cast Shadows enabled.",
+        "Remarque : seuls les calques dont l’option Projette des ombres est activée projettent des ombres.",
+    ),
+    ("Notify", "Notifier"),
+    ("OK", "OK"),
+    ("Offset:", "Décalage :"),
+    ("On ({}) stop:", "À l’arrêt ({}) :"),
+    ("One-Node Camera", "Caméra à un nœud"),
+    ("Opacity:", "Opacité :"),
+    ("Open Composition", "Ouvrir la composition"),
+    ("used once", "utilisé une fois"),
+    ("used {} times", "utilisé {} fois"),
+    ("Compositions that use this item", "Compositions qui utilisent cet élément"),
+    ("Open Last Saved Project", "Ouvrir le dernier projet enregistré"),
+    ("Open New Composition", "Ouvrir la nouvelle composition"),
+    ("Open Output", "Ouvrir la sortie"),
+    ("Open a composition to build Essential Graphics", "Ouvrez une composition pour créer des graphiques essentiels"),
+    ("Open a composition to see its scopes", "Ouvrez une composition pour voir ses oscilloscopes"),
+    ("Open a composition to track motion.", "Ouvrez une composition pour suivre un mouvement."),
+    ("Opus Tuning: {}", "Réglage Opus : {}"),
+    ("Original Duration:", "Durée d’origine :"),
+    ("Output Cycle: {}", "Cycle de sortie : {}"),
+    ("Output To:", "Sortie vers :"),
+    ("Overlay", "Superposition"),
+    ("Parameter Name:", "Nom du paramètre :"),
+    ("Parent pick whip: drag onto a layer", "Sélecteur de parent : faites-le glisser sur un calque"),
+    ("Pixel Aspect Ratio:", "Rapport d’aspect des pixels :"),
+    ("Playing on Video Preview", "Lecture sur la prévisualisation vidéo"),
+    ("Post-Render Action: {}", "Action après le rendu : {}"),
+    ("Preserve frame rate when nested or in render queue", "Conserver la fréquence d’images en cas d’imbrication ou dans la file d’attente de rendu"),
+    ("Preserve resolution when nested", "Conserver la résolution en cas d’imbrication"),
+    ("Preset", "Préréglage"),
+    ("Preset:", "Préréglage :"),
+    ("Presets", "Préréglages"),
+    ("Previous", "Précédent"),
+    ("Primary:", "Principal :"),
+    ("Process Before Match", "Traiter avant la mise en correspondance"),
+    ("Profile: {}", "Profil : {}"),
+    (
+        "Project color depth: click to cycle 8/16/32 bpc, Alt-click for Project Settings",
+        "Profondeur de couleur du projet : cliquez pour alterner entre 8/16/32 bpc, Alt-clic pour les paramètres du projet",
+    ),
+    ("Project: {}", "Projet : {}"),
+    ("Projects", "Projets"),
+    ("Property pick whip: drag onto a property", "Sélecteur de propriété : faites-le glisser sur une propriété"),
+    ("Protected Region", "Région protégée"),
+    ("Proxy Use: {}", "Utilisation du proxy : {}"),
+    ("Push All to Comp", "Tout envoyer vers la composition"),
+    ("RGB", "RVB"),
+    ("Radius", "Rayon"),
+    ("Rate Control: {}", "Contrôle du débit : {}"),
+    ("Recent", "Récents"),
+    ("Recording", "Enregistrement"),
+    ("Remove", "Supprimer"),
+    ("Rename", "Renommer"),
+    ("Render: {} ms  •  UI {} fps{}", "Rendu : {} ms  •  Interface {} i/s{}"),
+    ("Renderer:", "Moteur de rendu :"),
+    ("Request Persistent Storage", "Demander un stockage persistant"),
+    ("Reset", "Réinitialiser"),
+    ("Reset Labels", "Réinitialiser les étiquettes"),
+    ("Reset Preset", "Réinitialiser le préréglage"),
+    ("Reset to Default", "Rétablir les valeurs par défaut"),
+    ("Reset to Saved Layout", "Rétablir la disposition enregistrée"),
+    ("Resolution/Down Sample Factor Popup", "Menu de résolution et de facteur de sous-échantillonnage"),
+    ("Restore Panel Size", "Restaurer la taille du panneau"),
+    ("Reverse the order", "Inverser l’ordre"),
+    ("Revert All", "Tout rétablir"),
+    ("Roman Hanging Punctuation", "Ponctuation suspendue romaine"),
+    ("Roving:", "Itinérant :"),
+    ("Ruler zero point (drag to move, double-click to reset)", "Point zéro de la règle (faites glisser pour le déplacer, double-cliquez pour réinitialiser)"),
+    ("Rulers", "Règles"),
+    ("Run", "Exécuter"),
+    ("Sample Format: {}", "Format d’échantillon : {}"),
+    ("Samples Per Frame:", "Échantillons par image :"),
+    ("Save from #{}", "Enregistrer à partir de #{}"),
+    ("Saved {}", "Enregistré {}"),
+    ("Script… (⌘/Ctrl+Enter runs)", "Script… (⌘/Ctrl+Entrée pour exécuter)"),
+    ("Search commands or shortcuts", "Rechercher des commandes ou des raccourcis"),
+    ("Select", "Sélectionner"),
+    ("Select a command to change its shortcut.", "Sélectionnez une commande pour modifier son raccourci."),
+    ("Select a layer to see its effects", "Sélectionnez un calque pour voir ses effets"),
+    ("Select a layer to see its properties", "Sélectionnez un calque pour voir ses propriétés"),
+    ("({}) Selected Objects", "({}) objets sélectionnés"),
+    (
+        "Select a layer with a mask or shape path (or the path property), or Puppet pins.",
+        "Sélectionnez un calque doté d’un masque ou d’un tracé de forme (ou la propriété de tracé), ou des épingles de marionnette.",
+    ),
+    ("Select a text layer", "Sélectionnez un calque de texte"),
+    ("Select an item in the Project panel", "Sélectionnez un élément dans le panneau Projet"),
+    ("Select animated properties to show them in the Graph Editor", "Sélectionnez des propriétés animées pour les afficher dans l’éditeur de courbes"),
+    (
+        "Select the leader pin, then Shift-click the pins that should trail it (hair, cloth, tails)",
+        "Sélectionnez l’épingle principale, puis Maj-clic sur les épingles qui doivent la suivre (cheveux, tissu, queues)",
+    ),
+    ("Set Ground Plane and Origin", "Définir le plan de sol et l’origine"),
+    ("Set Paint Colors to Black and White (D)", "Définir les couleurs de peinture sur noir et blanc (D)"),
+    ("Settings", "Paramètres"),
+    ("Settings Name:", "Nom des paramètres :"),
+    ("Shadow Darkness", "Obscurité de l’ombre"),
+    ("Shadow Diffusion", "Diffusion de l’ombre"),
+    ("Shadows", "Ombres"),
+    ("Shape…", "Forme…"),
+    ("Show", "Afficher"),
+    ("Show Layer Name", "Afficher le nom du calque"),
+    ("Show Source Name", "Afficher le nom de la source"),
+    ("Show me", "Montrez-moi"),
+    ("Show:", "Afficher :"),
+    ("Shutter Angle:", "Angle d’obturation :"),
+    ("Shutter Phase:", "Phase d’obturation :"),
+    ("Size", "Taille"),
+    ("Skip", "Passer"),
+    ("Snapping", "Aimantation"),
+    ("Snapping options", "Options d’aimantation"),
+    ("Snapshot", "Instantané"),
+    ("Solo Supported Properties", "Solo sur les propriétés prises en charge"),
+    ("Solo Switches: {}", "Commutateurs Solo : {}"),
+    ("Sort", "Trier"),
+    ("Spacing:", "Espacement :"),
+    ("Spatial Interpolation:", "Interpolation spatiale :"),
+    ("Speed:", "Vitesse :"),
+    ("Start Timecode:", "Timecode de début :"),
+    ("Start: {}   Duration: {}", "Début : {}   Durée : {}"),
+    ("Step {} of {}: {}", "Étape {} sur {} : {}"),
+    ("Stop", "Arrêter"),
+    ("Stop {} at {}°", "Point d’arrêt {} à {}°"),
+    ("Stored in: {}", "Stocké dans : {}"),
+    ("Stretch", "Étirement"),
+    ("Stretch Factor:", "Facteur d’étirement :"),
+    ("Stylistic Sets", "Jeux stylistiques"),
+    ("Subpixel Positioning", "Positionnement au sous-pixel"),
+    ("Swap Colors", "Permuter les couleurs"),
+    ("Swap Paint Colors (X)", "Permuter les couleurs de peinture (X)"),
+    ("Sync with System", "Synchroniser avec le système"),
+    ("System Default", "Par défaut du système"),
+    ("Table", "Tableau"),
+    ("Template name", "Nom du modèle"),
+    ("Template: {}\n{}", "Modèle : {}\n{}"),
+    ("Temporal Interpolation:", "Interpolation temporelle :"),
+    ("The Media Browser is not available here (use File ▸ Import)", "Le navigateur multimédia n’est pas disponible ici (utilisez Fichier ▸ Importer)"),
+    ("The OpenEXR layer shown in red, green, blue and alpha", "La couche OpenEXR affichée en rouge, vert, bleu et alpha"),
+    ("The render queue is empty.", "La file d’attente de rendu est vide."),
+    (
+        "These adjacent keyframes cannot interpolate because their stop counts differ.",
+        "Ces images clés adjacentes ne peuvent pas être interpolées, car leur nombre de points d’arrêt diffère.",
+    ),
+    ("This ScriptUI panel has closed", "Ce panneau ScriptUI a été fermé"),
+    ("This change will create a new solid for this layer.", "Cette modification créera un nouveau solide pour ce calque."),
+    ("Time", "Temps"),
+    ("Time Stretch…", "Extension temporelle…"),
+    ("Time:", "Temps :"),
+    ("Time: {}", "Temps : {}"),
+    ("Title/Action Safe", "Zones de sécurité titres/action"),
+    ("Title/action safe", "Zones de sécurité titres/action"),
+    ("Toggle Switches / Modes", "Basculer entre commutateurs et modes"),
+    ("Track Name:", "Nom de la piste :"),
+    (
+        "Trained models are available in the desktop app; the browser uses the classic engine.",
+        "Les modèles entraînés sont disponibles dans l’application de bureau ; le navigateur utilise le moteur classique.",
+    ),
+    ("Transform", "Transformation"),
+    ("Transparency grid", "Grille de transparence"),
+    ("Tutorial complete", "Tutoriel terminé"),
+    ("Two-Node Camera", "Caméra à deux nœuds"),
+    ("Type", "Type"),
+    ("Type a command or effect…", "Saisissez une commande ou un effet…"),
+    ("URL:", "URL :"),
+    ("Undock Panel", "Détacher le panneau"),
+    ("Move Panel to New Window", "Déplacer le panneau vers une nouvelle fenêtre"),
+    ("Move Panel to Main Window", "Déplacer le panneau vers la fenêtre principale"),
+    ("Unfreeze", "Dégeler"),
+    ("Unlink {}", "Dissocier {}"),
+    (
+        "Use this option to place the currently selected layers together into a new intermediate composition.",
+        "Utilisez cette option pour regrouper les calques actuellement sélectionnés dans une nouvelle composition intermédiaire.",
+    ),
+    ("VR Environments", "Environnements VR"),
+    ("Value:", "Valeur :"),
+    ("Variable Font Axes", "Axes de police variable"),
+    ("Video Codec: {}", "Codec vidéo : {}"),
+    ("View:", "Affichage :"),
+    ("Welcome to EffectCraft", "Bienvenue dans EffectCraft"),
+    ("Width:", "Largeur :"),
+    ("You can undo this.", "Vous pouvez annuler cette action."),
+    ("You can't undo this.", "Vous ne pouvez pas annuler cette action."),
+    ("Your changes will be lost if you don't save them.", "Vos modifications seront perdues si vous ne les enregistrez pas."),
+    ("Zoom", "Zoom"),
+    ("built-in", "intégré"),
+    ("frames per second", "images par seconde"),
+    ("template name", "nom du modèle"),
+    ("{} contributors · {} commits", "{} contributeurs · {} commits"),
+    ("{} x {}, {}MB per 8bpc frame", "{} x {}, {} Mo par image 8 bpc"),
+    ("{} — coming soon", "{} — bientôt disponible"),
+    ("{} — double-click to open, {}-click to reveal", "{} — double-cliquez pour ouvrir, {}-clic pour révéler"),
+    ("⌘/Ctrl-drag a pin to record its motion", "Glissez une épingle en maintenant ⌘/Ctrl pour enregistrer son mouvement"),
+    ("▣ {}", "▣ {}"),
+    ("⚠ {} is used by:", "⚠ {} est utilisé par :"),
+    ("3D Reference Axes", "Axes de référence 3D"),
+    ("Affect all layers that use this solid", "Affecter tous les calques qui utilisent ce solide"),
+    ("Choose grid and guide options", "Choisir les options de grille et de repères"),
+    ("Colorize", "Coloriser"),
+    ("Custom", "Personnalisée"),
+    ("Custom...", "Personnalisée..."),
+    ("Fit", "Ajuster"),
+    ("Fit up to 100%", "Ajuster jusqu’à 100 %"),
+    ("Full", "Complète"),
+    ("Half", "Moitié"),
+    ("Only this layer uses this solid.", "Seul ce calque utilise ce solide."),
+    ("Proportional Grid", "Grille proportionnelle"),
+    ("Quarter", "Quart"),
+    ("Region of Interest", "Zone d’intérêt"),
+    ("Reset Exposure", "Réinitialiser l’exposition"),
+    ("Show Channel and Color Management Settings", "Afficher les paramètres de canaux et de gestion des couleurs"),
+    ("Show Snapshot (hold)", "Afficher l’instantané (maintenir)"),
+    ("Take Snapshot", "Prendre un instantané"),
+    ("Third", "Tiers"),
+    ("Toggle Mask and Shape Path Visibility", "Afficher/masquer les tracés de masque et de forme"),
+    ("Toggle Transparency Grid", "Afficher/masquer la grille de transparence"),
+    ("16 bits per channel", "16 bits par canal"),
+    ("32 bits per channel (float)", "32 bits par canal (virgule flottante)"),
+    ("8 bits per channel", "8 bits par canal"),
+    ("Adaptive Resolution", "Résolution adaptative"),
+    ("Adobe-style built-in", "Intégré (style Adobe)"),
+    ("Blue", "Bleu"),
+    ("Current Settings", "Paramètres actuels"),
+    ("Disable Per-character 3D", "Désactiver la 3D par caractère"),
+    ("Draft", "Brouillon"),
+    ("Enable Per-character 3D", "Activer la 3D par caractère"),
+    ("Fast Draft", "Brouillon rapide"),
+    ("Fast Previews (Draft 3D, Faster Effects)", "Aperçus rapides (3D brouillon, effets plus rapides)"),
+    ("Green", "Vert"),
+    ("Import Image Sequence", "Importer une séquence d’images"),
+    ("Import PDF / Illustrator File", "Importer un fichier PDF / Illustrator"),
+    ("Import Photoshop File", "Importer un fichier Photoshop"),
+    ("Interpret Unlabeled Alpha As", "Interpréter l’alpha non étiqueté comme"),
+    ("Join the ArtCraft Discord", "Rejoindre le Discord ArtCraft"),
+    ("Mercury GPU Acceleration ({})", "Accélération GPU Mercury ({})"),
+    ("Mercury Software Only", "Mercury, logiciel uniquement"),
+    ("OCIO (built-in ACES config)", "OCIO (configuration ACES intégrée)"),
+    ("Off (Final Quality)", "Désactivé (qualité finale)"),
+    ("OpenGL (compatibility)", "OpenGL (compatibilité)"),
+    ("Opus Bitrate: {} kbps", "Débit Opus : {} kb/s"),
+    ("RGB Straight", "RVB direct"),
+    ("Red", "Rouge"),
+    ("Tone map", "Mappage tonal"),
+    ("Use In-Window Menu Bar on macOS", "Utiliser la barre de menus dans la fenêtre sous macOS"),
+    ("Wireframe", "Fil de fer"),
+    ("sRGB IEC61966-2.1 (default)", "sRGB IEC61966-2.1 (par défaut)"),
+    ("New Project", "Nouveau projet"),
+    ("Open Project…", "Ouvrir un projet…"),
+    ("Templates", "Modèles"),
+    ("EffectCraft home page", "Page d’accueil EffectCraft"),
+    ("EffectCraft on GitHub", "EffectCraft sur GitHub"),
+    ("Motion graphics and visual effects · version {}", "Motion design et effets visuels · version {}"),
+    ("New Composition", "Nouvelle composition"),
+    ("Open Demo Project", "Ouvrir le projet de démonstration"),
+    ("Import Footage…", "Importer un métrage…"),
+    ("Filter recent files", "Filtrer les fichiers récents"),
+    ("NAME", "NOM"),
+    ("OPENED", "OUVERT LE"),
+    ("SIZE", "TAILLE"),
+    ("KIND", "TYPE"),
+    ("Your recent files will show here", "Vos fichiers récents s’afficheront ici"),
+    ("Create a new project, or open the demo project to look around.", "Créez un projet ou ouvrez le projet de démonstration pour explorer."),
+    ("No recent files match the filter", "Aucun fichier récent ne correspond au filtre"),
+    ("Try another name or folder.", "Essayez un autre nom ou dossier."),
+    ("Just now", "À l’instant"),
+    ("Yesterday", "Hier"),
+    ("{} minute ago", "Il y a {} minute"),
+    ("{} minutes ago", "Il y a {} minutes"),
+    ("{} hour ago", "Il y a {} heure"),
+    ("{} hours ago", "Il y a {} heures"),
+    ("{} day ago", "Il y a {} jour"),
+    ("{} days ago", "Il y a {} jours"),
+    ("EffectCraft project", "Projet EffectCraft"),
+    ("After Effects project", "Projet After Effects"),
+    ("Lottie animation", "Animation Lottie"),
+    ("Project", "Projet"),
+    ("General", "Général"),
+    ("Language", "Langue"),
+    ("Levels of Undo", "Niveaux d’annulation"),
+    ("Path Point and Handle Size", "Taille des points de tracé et des poignées"),
+    ("Recent Projects Shown", "Nombre de projets récents affichés"),
+    ("Options", "Options"),
+    ("Show Tool Tips", "Afficher les info-bulles"),
+    ("Create Layers at Composition Start Time", "Créer les calques au début de la composition"),
+    ("Switches Affect Nested Comps", "Les commutateurs affectent les compositions imbriquées"),
+    ("Default Spatial Interpolation to Linear", "Interpolation spatiale linéaire par défaut"),
+    (
+        "Preserve Constant Vertex and Feather Point Count when Editing Masks",
+        "Conserver un nombre constant de sommets et de points de contour progressif lors de la modification des masques",
+    ),
+    ("Synchronize Time of All Related Items", "Synchroniser le temps de tous les éléments liés"),
+    ("Expression Pick Whip Writes Compact English", "Le sélecteur d’expression écrit un anglais compact"),
+    ("Create Split Layers Above Original Layer", "Créer les calques fractionnés au-dessus du calque d’origine"),
+    ("Use System Color Picker", "Utiliser le sélecteur de couleurs du système"),
+    (
+        "EffectCraft always uses its own colour picker (the same on every platform and the web).",
+        "EffectCraft utilise toujours son propre sélecteur de couleurs (le même sur toutes les plateformes et sur le web).",
+    ),
+    ("Startup & Repair", "Démarrage et réparation"),
+    ("Show Home Screen When Launching", "Afficher l’écran d’accueil au lancement"),
+    ("Show Home Screen When Opening a Project", "Afficher l’écran d’accueil à l’ouverture d’un projet"),
+    ("Offer to Open the Latest Auto-Save After a Crash", "Proposer d’ouvrir le dernier enregistrement automatique après un plantage"),
+    ("Window Graphics", "Graphismes de la fenêtre"),
+    ("Automatic", "Automatique"),
+    (
+        "Window Graphics applies from the next launch. When the graphics driver stops EffectCraft as its window opens, the next launch switches to OpenGL.",
+        "Le réglage Graphismes de la fenêtre s’applique à partir du prochain lancement. Si le pilote graphique arrête EffectCraft à l’ouverture de sa fenêtre, le lancement suivant bascule sur OpenGL.",
+    ),
+    ("Repair", "Réparation"),
+    ("Reset Settings", "Réinitialiser les préférences"),
+    ("Reset Keyboard Shortcuts", "Réinitialiser les raccourcis clavier"),
+    ("Empty Disk Cache", "Vider le cache disque"),
+    ("New Project Loads Template", "Un nouveau projet charge un modèle"),
+    ("Template Project", "Projet modèle"),
+    ("Auto-Save", "Enregistrement automatique"),
+    ("Automatically Save Projects", "Enregistrer automatiquement les projets"),
+    ("Save Every", "Enregistrer toutes les"),
+    ("Minutes", "Minutes"),
+    ("Maximum Project Versions", "Nombre maximal de versions du projet"),
+    ("Auto-Save Location", "Emplacement de l’enregistrement automatique"),
+    ("Next to Project", "À côté du projet"),
+    ("Custom Location", "Emplacement personnalisé"),
+    ("Save When Starting Render Queue", "Enregistrer au démarrage de la file d’attente de rendu"),
+    ("Save Now", "Enregistrer maintenant"),
+    ("Motion Path", "Trajectoire de mouvement"),
+    ("All Keyframes", "Toutes les images clés"),
+    ("No Motion Path", "Aucune trajectoire de mouvement"),
+    ("No More Than (Seconds)", "Pas plus de (secondes)"),
+    ("No More Than (Keyframes)", "Pas plus de (images clés)"),
+    ("Seconds", "Secondes"),
+    ("Keyframes", "Images clés"),
+    ("Display", "Affichage"),
+    ("Show Rendering Progress in Info Panel and Flowchart", "Afficher la progression du rendu dans le panneau Informations et l’organigramme"),
+    ("Hardware Accelerate Composition, Layer and Footage Panels", "Accélération matérielle des panneaux Composition, Calque et Métrage"),
+    ("Panels are always drawn by the GPU (wgpu).", "Les panneaux sont toujours dessinés par le GPU (wgpu)."),
+    ("Previews", "Prévisualisations"),
+    ("Adaptive Resolution Limit", "Limite de résolution adaptative"),
+    ("Show Internal Wireframes", "Afficher les fils de fer internes"),
+    ("Cache Frames When Idle", "Mettre en cache les images en cas d’inactivité"),
+    ("Viewer Zoom Quality", "Qualité du zoom du visualiseur"),
+    ("Faster", "Plus rapide"),
+    ("More Accurate", "Plus précis"),
+    ("Display Color Space", "Espace colorimétrique d’affichage"),
+    ("GPU Information...", "Informations sur le GPU..."),
+    ("Appearance", "Apparence"),
+    ("Brightness", "Luminosité"),
+    ("UI Scale", "Échelle de l’interface"),
+    ("Labels and Colors", "Étiquettes et couleurs"),
+    ("Use Label Color for Layer Handles and Paths", "Utiliser la couleur d’étiquette pour les poignées et les tracés des calques"),
+    ("Use Label Color for Related Tabs", "Utiliser la couleur d’étiquette pour les onglets associés"),
+    ("Cycle Mask Colors", "Alterner les couleurs des masques"),
+    ("Use Gradients", "Utiliser les dégradés"),
+    ("Menu Bar", "Barre de menus"),
+    ("Grids & Guides", "Grilles et repères"),
+    ("Gridline Every", "Ligne de grille toutes les"),
+    ("Subdivisions", "Subdivisions"),
+    ("Style", "Style"),
+    ("Lines", "Lignes"),
+    ("Dashed Lines", "Lignes en tirets"),
+    ("Dots", "Points"),
+    ("Horizontal", "Horizontal"),
+    ("Vertical", "Vertical"),
+    ("Safe Margins", "Marges de sécurité"),
+    ("Action-safe", "Sécurité action"),
+    ("Title-safe", "Sécurité titres"),
+    ("Labels", "Étiquettes"),
+    ("Text Engine", "Moteur de texte"),
+    ("Latin", "Latin"),
+    ("South Asian and Middle Eastern", "Asie du Sud et Moyen-Orient"),
+    ("Show Font Preview", "Afficher l’aperçu des polices"),
+    ("Number of Recent Fonts to Display", "Nombre de polices récentes à afficher"),
+    ("Show Font Names in English", "Afficher les noms des polices en anglais"),
+    ("Still Footage", "Métrage fixe"),
+    ("Length of Composition", "Durée de la composition"),
+    ("Duration (Seconds)", "Durée (secondes)"),
+    ("Still Duration", "Durée de l’image fixe"),
+    ("Sequence Footage", "Métrage en séquence"),
+    ("Report Missing Frames", "Signaler les images manquantes"),
+    ("Automatically Reload Footage", "Recharger automatiquement le métrage"),
+    ("Off", "Désactivé"),
+    ("Non-Sequence Footage", "Métrage hors séquence"),
+    ("All Footage", "Tout le métrage"),
+    ("Ask User", "Demander à l’utilisateur"),
+    ("Guess", "Deviner"),
+    ("Ignore", "Ignorer"),
+    ("Straight", "Direct"),
+    ("Premultiplied", "Prémultiplié"),
+    ("Default Drag Import As", "Importation par glisser par défaut en tant que"),
+    ("Footage", "Métrage"),
+    ("Composition - Retain Layer Sizes", "Composition – conserver les tailles des calques"),
+    ("Export", "Exportation"),
+    ("Default Output Folder", "Dossier de sortie par défaut"),
+    ("Segment Sequences", "Segmenter les séquences"),
+    ("Files per Segment", "Fichiers par segment"),
+    ("files", "fichiers"),
+    ("Segment Movie Files", "Segmenter les fichiers vidéo"),
+    ("Segment Size", "Taille du segment"),
+    ("Append Bit Depth to File Name", "Ajouter la profondeur de bits au nom du fichier"),
+    ("Audio", "Audio"),
+    ("Audio Hardware", "Matériel audio"),
+    ("Preview Sample Rate", "Fréquence d’échantillonnage de l’aperçu"),
+    ("Audio Output Mapping", "Affectation des sorties audio"),
+    ("Left", "Gauche"),
+    ("Right", "Droite"),
+    ("channel", "canal"),
+    ("Disk", "Disque"),
+    ("Disk Cache", "Cache disque"),
+    ("Enable Disk Cache", "Activer le cache disque"),
+    ("Maximum Disk Cache Size", "Taille maximale du cache disque"),
+    ("Disk Cache Folder", "Dossier du cache disque"),
+    ("Media Cache", "Cache des médias"),
+    ("Database and Cache Folder", "Dossier de la base de données et du cache"),
+    ("Conformed Audio Folder", "Dossier de l’audio conformé"),
+    ("Memory & CPU", "Mémoire et CPU"),
+    ("RAM Reserved for Other Applications", "Mémoire vive réservée aux autres applications"),
+    ("Cache Budgets", "Budgets de cache"),
+    ("Layer Cache", "Cache des calques"),
+    ("Footage Frame Cache", "Cache des images du métrage"),
+    ("Preview (RAM) Cache", "Cache de prévisualisation (RAM)"),
+    ("Reduce Cache Size When System Is Low on Memory", "Réduire la taille du cache quand le système manque de mémoire"),
+    ("Video", "Vidéo"),
+    ("Enable Video Preview Output", "Activer la sortie de prévisualisation vidéo"),
+    ("Video Device", "Périphérique vidéo"),
+    ("Floating Window", "Fenêtre flottante"),
+    ("Full Screen", "Plein écran"),
+    ("Video Output During Playback", "Sortie vidéo pendant la lecture"),
+    ("Mirror on Computer Monitor", "Dupliquer sur l’écran de l’ordinateur"),
+    ("Disable Video Output When in Background", "Désactiver la sortie vidéo en arrière-plan"),
+    ("Default 3D Renderer", "Moteur de rendu 3D par défaut"),
+    ("Show 3D Reference Axes", "Afficher les axes de référence 3D"),
+    ("Extended Viewer", "Visualiseur étendu"),
+    ("Realtime Shadows in Draft", "Ombres en temps réel en mode brouillon"),
+    ("Scripting & Expressions", "Scripts et expressions"),
+    ("Application Scripting", "Scripts de l’application"),
+    ("Allow Scripts to Write Files and Access Network", "Autoriser les scripts à écrire des fichiers et à accéder au réseau"),
+    ("Warn User When Executing Files", "Avertir l’utilisateur à l’exécution de fichiers"),
+    ("Enable JavaScript Debugger", "Activer le débogueur JavaScript"),
+    ("Expressions Editor", "Éditeur d’expressions"),
+    ("Font Size", "Taille de police"),
+    ("Syntax Highlighting", "Coloration syntaxique"),
+    ("Line Numbers", "Numéros de ligne"),
+    ("Auto-complete", "Complétion automatique"),
+    ("Bracket Matching", "Appariement des parenthèses"),
+    ("Word Wrap", "Retour automatique à la ligne"),
+    ("Show Expression Error Banner", "Afficher le bandeau d’erreur d’expression"),
+    (
+        "Expressions use the JavaScript engine. Script errors report their file and line in the Script Console; there is no step debugger.",
+        "Les expressions utilisent le moteur JavaScript. Les erreurs de script indiquent leur fichier et leur ligne dans la console de scripts ; il n’existe pas de débogueur pas à pas.",
+    ),
+    ("Roto Brush", "Roto Brush"),
+    ("Segmentation Model", "Modèle de segmentation"),
+    (
+        "Roto Brush 2.0 and 3.0 use the model chosen here (Version 1.0 always uses the classic engine). Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
+        "Roto Brush 2.0 et 3.0 utilisent le modèle choisi ici (la version 1.0 utilise toujours le moteur classique). Les modèles sont open source, ne sont téléchargés que sur votre demande et sont vérifiés d’après leur empreinte SHA-256 publiée.",
+    ),
+    ("Face Tracking", "Suivi du visage"),
+    ("Face Model", "Modèle de visage"),
+    (
+        "Face tracking in the Tracker panel (Outline Only and Detailed Features) uses the model chosen here. Models are open source, downloaded only when you ask, and checked against their published SHA-256.",
+        "Le suivi du visage du panneau Suivi (Outline Only et Detailed Features) utilise le modèle choisi ici. Les modèles sont open source, ne sont téléchargés que sur votre demande et sont vérifiés d’après leur empreinte SHA-256 publiée.",
+    ),
+    ("Match System", "Langue du système"),
+    ("Total Offset", "Décalage total"),
+    ("Per Layer", "Par calque"),
+    ("Track", "Suivre"),
+    ("Default", "Par défaut"),
+    ("Stored, but not used by EffectCraft yet", "Enregistré, mais pas encore utilisé par EffectCraft"),
+    ("Search project", "Rechercher dans le projet"),
+    ("Select an item to see its details", "Sélectionnez un élément pour voir ses détails"),
+    ("Media Duration", "Durée du média"),
+    ("Frame Rate", "Fréquence d’images"),
+    ("File Path", "Chemin du fichier"),
+    ("Comment", "Commentaire"),
+    ("A/V Features", "Fonctions A/V"),
+    ("Keys", "Clés"),
+    ("Layer Name", "Nom du calque"),
+    ("Source Name", "Nom de la source"),
+    ("Switches", "Commutateurs"),
+    ("Modes", "Modes"),
+    ("Track Matte", "Estampe"),
+    ("Parent & Link", "Parent et lien"),
+    ("In", "Entrée"),
+    ("Out", "Sortie"),
+    ("Duration", "Durée"),
+    ("Original color: click to go back to it", "Couleur d’origine : cliquez pour y revenir"),
+    ("Resize floating panel", "Redimensionner le panneau flottant"),
+    ("Render every n-th pixel", "Rendre un pixel sur n"),
+    ("Color (#rrggbb)", "Couleur (#rrggbb)"),
+    ("Workspace", "Espace de travail"),
+    ("Rename to", "Renommer en"),
+    ("Open", "Ouvrir"),
+    ("Custom Resolution", "Résolution personnalisée"),
+    ("Panel Background Color", "Couleur d’arrière-plan du panneau"),
+    ("New Workspace", "Nouvel espace de travail"),
+    ("Edit Workspaces", "Modifier les espaces de travail"),
+    ("A script wants to open a file", "Un script veut ouvrir un fichier"),
+    ("Drop file to import", "Déposez le fichier pour l’importer"),
+    ("Drop {} files to import", "Déposez {} fichiers pour les importer"),
+    (
+        "Skipped {} dropped file(s) without a local path. Use File ▸ Import ▸ File…",
+        "{} fichier(s) déposé(s) sans chemin local ignoré(s). Utilisez Fichier ▸ Importer ▸ Fichier…",
+    ),
+    ("Only one project can be opened per drop; skipped {} more", "Un seul projet peut être ouvert par dépôt ; {} de plus ignoré(s)"),
+    ("Cannot open dropped project {}: {}", "Impossible d’ouvrir le projet déposé {} : {}"),
+    ("Cannot import dropped files: {}", "Impossible d’importer les fichiers déposés : {}"),
+    ("A built-in preset has this name", "Un préréglage intégré porte ce nom"),
+    ("Replaces your preset with this name", "Remplace votre préréglage portant ce nom"),
+    ("Save Preset…", "Enregistrer le préréglage…"),
+    ("Delete Preset", "Supprimer le préréglage"),
+    ("Null Settings", "Paramètres de l’objet nul"),
+    ("Click to sample text {}", "Cliquez pour échantillonner le texte {}"),
+    ("Force alphabetical order", "Forcer l’ordre alphabétique"),
+    ("Frame rate (fps)", "Fréquence d’images (i/s)"),
+    (
+        "Change the frame rate, alpha and start frame later with File ▸ Interpret Footage.",
+        "Modifiez plus tard la fréquence d’images, l’alpha et l’image de début avec Fichier ▸ Interpréter le métrage.",
+    ),
+    ("Import Kind", "Type d’importation"),
+    ("Page", "Page"),
+    ("Delay (s)", "Délai (s)"),
+    ("Amount (%)", "Quantité (%)"),
+    ("Cascade (farther pins trail longer)", "En cascade (les épingles éloignées traînent plus longtemps)"),
+    ("Speed (%)", "Vitesse (%)"),
+    ("Smoothing", "Lissage"),
+    ("Use Draft Deformation", "Utiliser la déformation brouillon"),
+    ("Show Mesh", "Afficher le maillage"),
+    ("Scale X (%)", "Échelle X (%)"),
+    ("Scale Y (%)", "Échelle Y (%)"),
+    ("Rotation (degrees)", "Rotation (degrés)"),
+    ("Move X", "Déplacement X"),
+    ("Move Y", "Déplacement Y"),
+    ("Top", "Haut"),
+    ("Width", "Largeur"),
+    ("Height", "Hauteur"),
+    ("Shape", "Forme"),
+    ("Mode", "Mode"),
+    ("Frame", "Image"),
+    ("Orientation", "Orientation"),
+    ("Position (pixels)", "Position (pixels)"),
+    ("Position (percent of the composition)", "Position (pourcentage de la composition)"),
+    ("Create", "Créer"),
+    ("Use Dimensions From", "Utiliser les dimensions de"),
+    ("Still Duration (seconds)", "Durée de l’image fixe (secondes)"),
+    ("Add to Render Queue", "Ajouter à la file d’attente de rendu"),
+    ("Sequence Layers", "Enchaîner les calques"),
+    ("Overlap", "Chevauchement"),
+    ("Duration (seconds)", "Durée (secondes)"),
+    ("Transition", "Transition"),
+    ("Matte color (premultiplied)", "Couleur de fond (prémultipliée)"),
+    ("Invert Alpha", "Inverser l’alpha"),
+    ("Assume this frame rate", "Supposer cette fréquence d’images"),
+    ("Separate Fields", "Séparer les trames"),
+    ("Pixel Aspect Ratio", "Rapport d’aspect des pixels"),
+    ("Loop (times)", "Boucle (fois)"),
+    ("Assign Profile", "Attribuer un profil"),
+    ("Preserve RGB", "Conserver le RVB"),
+    ("Interpret As Linear Light", "Interpréter comme lumière linéaire"),
+    ("Start Timecode", "Timecode de début"),
+    ("Override Start", "Remplacer le début"),
+    ("Depth", "Profondeur"),
+    ("Time display style", "Style d’affichage du temps"),
+    ("Color engine", "Moteur colorimétrique"),
+    ("Working space", "Espace colorimétrique de travail"),
+    ("Working gamma", "Gamma de travail"),
+    ("Linearize working space", "Linéariser l’espace colorimétrique de travail"),
+    ("Blend colors using 1.0 gamma", "Fusionner les couleurs avec un gamma de 1,0"),
+    ("HDR on SDR displays and outputs", "HDR sur les écrans et sorties SDR"),
+    ("Output color space", "Espace colorimétrique de sortie"),
+    ("Video rendering and effects", "Rendu vidéo et effets"),
+    ("Time Span", "Intervalle de temps"),
+    ("Invert", "Inverser"),
+    ("Blur (pixels before auto-trace)", "Flou (pixels avant le tracé automatique)"),
+    ("Tolerance (pixels)", "Tolérance (pixels)"),
+    ("Threshold (%)", "Seuil (%)"),
+    ("Minimum Area (pixels)", "Surface minimale (pixels)"),
+    ("Corner Roundness (%)", "Arrondi des angles (%)"),
+    ("Apply To New Layer", "Appliquer à un nouveau calque"),
+    ("Action", "Action"),
+    ("Sensitivity threshold (0–1, lower finds more)", "Seuil de sensibilité (0–1, plus bas = plus de résultats)"),
+    ("Data", "Données"),
+    ("Time field (empty: automatic)", "Champ de temps (vide : automatique)"),
+    ("Video start (ISO date-time, hh:mm:ss, timecode; empty: file date)", "Début de la vidéo (date-heure ISO, hh:mm:ss, timecode ; vide : date du fichier)"),
+    ("First sample at (comp seconds)", "Premier échantillon à (secondes de composition)"),
+    (
+        "Writes Final Cut Pro XML (.xml), which Premiere Pro opens with File ▸ Import. Native .prproj files are not written.",
+        "Écrit un XML Final Cut Pro (.xml), que Premiere Pro ouvre avec Fichier ▸ Importer. Les fichiers .prproj natifs ne sont pas écrits.",
+    ),
+    ("File", "Fichier"),
+    ("Format", "Format"),
+    ("Pre-render (ProRes 4444)", "Prérendu (ProRes 4444)"),
+    ("Precomps", "Précompositions"),
+    ("Frame rate", "Fréquence d’images"),
+    ("Description", "Description"),
+    ("Category", "Catégorie"),
+    ("Embed footage files", "Intégrer les fichiers de métrage"),
+    ("Embed up to (MB)", "Intégrer jusqu’à (Mo)"),
+    ("Use the sRGB curve (ignore Gamma)", "Utiliser la courbe sRVB (ignorer le gamma)"),
+    ("ICC profile (replaces the numbers)", "Profil ICC (remplace les valeurs)"),
+    ("Rectangle", "Rectangle"),
+    ("Ellipse", "Ellipse"),
+    ("Orient Along Path", "Orienter le long du tracé"),
+    ("Orient Towards Camera", "Orienter vers la caméra"),
+    ("Orient Towards Point of Interest", "Orienter vers le point d’intérêt"),
+    ("Single Composition", "Composition unique"),
+    ("Multiple Compositions", "Plusieurs compositions"),
+    ("Dissolve Front Layer", "Fondu du calque avant"),
+    ("Cross Dissolve Front and Back Layers", "Fondu enchaîné des calques avant et arrière"),
+    ("Interpret Straight - Unmatted", "Interpréter comme direct – sans fond"),
+    ("Interpret Premultiplied - Matted With Color", "Interpréter comme prémultiplié – sur fond coloré"),
+    ("Upper Field First", "Trame supérieure en premier"),
+    ("Lower Field First", "Trame inférieure en premier"),
+    ("Embedded / sRGB", "Intégré / sRVB"),
+    ("Use Source File Timecode", "Utiliser le timecode du fichier source"),
+    ("Timecode", "Timecode"),
+    ("Frames", "Images"),
+    ("Feet + Frames (35mm)", "Pieds + images (35 mm)"),
+    ("Feet + Frames (16mm)", "Pieds + images (16 mm)"),
+    ("Clip", "Écrêtage"),
+    ("Compand", "Compandage"),
+    ("Current Frame", "Image actuelle"),
+    ("Work Area", "Zone de travail"),
+    ("Luminance", "Luminance"),
+    ("Create Markers", "Créer des repères"),
+    ("Split Layers", "Fractionner les calques"),
+    ("Split and Precompose", "Fractionner et précomposer"),
+    ("CMX 3600 EDL (.edl, V1 only)", "CMX 3600 EDL (.edl, V1 uniquement)"),
+    ("OMF (.omf, audio)", "OMF (.omf, audio)"),
+    ("Layers Premiere can't show (text, shapes, effects…)", "Calques que Premiere ne peut pas afficher (texte, formes, effets…)"),
+    ("All layers", "Tous les calques"),
+    ("None (leave them out)", "Aucun (les exclure)"),
+    ("Nested sequences", "Séquences imbriquées"),
+    ("Pre-render", "Prérendu"),
+    ("Puppet Follow-Through", "Prolongement de la marionnette"),
+    ("Puppet Record Options", "Options d’enregistrement de la marionnette"),
+    ("Free Transform Points", "Transformation libre des points"),
+    ("Mask Shape", "Forme du masque"),
+    ("Auto-Orientation", "Orientation automatique"),
+    ("Go to Time", "Accéder au temps"),
+    ("Add Guide", "Ajouter un repère"),
+    ("Add Percentage Guide", "Ajouter un repère en pourcentage"),
+    ("New Composition from Selection", "Nouvelle composition à partir de la sélection"),
+    ("Project Settings", "Paramètres du projet"),
+    ("Auto-trace", "Tracé automatique"),
+    ("Scene Edit Detection", "Détection des coupes de scène"),
+    ("Align Video to Data", "Aligner la vidéo sur les données"),
+    ("Export Adobe Premiere Pro Project", "Exporter un projet Adobe Premiere Pro"),
+    ("New Placeholder", "Nouvel espace réservé"),
+    ("Solid Settings", "Paramètres du solide"),
+    ("Save as Template", "Enregistrer en tant que modèle"),
+    ("My Custom RGB", "Mon RVB personnalisé"),
+    ("Mercury GPU Acceleration (no GPU: software)", "Accélération GPU Mercury (aucun GPU : logiciel)"),
+    ("Sort by {}, {}", "Trier par {}, {}"),
+    ("Sort by {}", "Trier par {}"),
+    ("Label of {}: {}", "Étiquette de {} : {}"),
+    ("Comment of {}: {}", "Commentaire de {} : {}"),
+    ("Project color depth: {}", "Profondeur de couleur du projet : {}"),
+    ("Start (s)", "Début (s)"),
+    ("Duration (s)", "Durée (s)"),
+    ("Frames per second", "Images par seconde"),
+    ("Bottom", "Bas"),
+    ("Bitrate (kbps)", "Débit (kb/s)"),
+    ("Frames between key frames (0 = every 2 s)", "Images entre les images clés (0 = toutes les 2 s)"),
+    ("Click in the Composition panel to sample text {}", "Cliquez dans le panneau Composition pour échantillonner le texte {}"),
+    ("Video preview off: audio only", "Prévisualisation vidéo désactivée : audio uniquement"),
+    ("Open in Essential Graphics", "Ouvrir dans Graphiques essentiels"),
+    ("Video preview is off (Preview panel): audio only", "La prévisualisation vidéo est désactivée (panneau Prévisualisation) : audio uniquement"),
+    ("Solid…", "Solide…"),
+    ("Click to sample color", "Cliquez pour échantillonner la couleur"),
+    ("Advanced", "Avancé"),
+    ("Rescan Fonts", "Réanalyser les polices"),
+    ("Track Matte pick whip: drag onto a layer", "Sélecteur d’estampe : faites glisser vers un calque"),
+    ("Play/Stop", "Lecture/Arrêt"),
+    ("Selection Tool", "Outil Sélection"),
+    ("Hand Tool", "Outil Main"),
+    ("Zoom Tool", "Outil Zoom"),
+    ("Orbit Around Cursor Tool", "Outil Orbite autour du curseur"),
+    ("Pan Under Cursor Tool", "Outil Panoramique sous le curseur"),
+    ("Dolly Towards Cursor Tool", "Outil Travelling vers le curseur"),
+    ("Rotation Tool", "Outil Rotation"),
+    ("Pan Behind (Anchor Point) Tool", "Outil Déplacement derrière (point d’ancrage)"),
+    ("Rectangle Tool", "Outil Rectangle"),
+    ("Rounded Rectangle Tool", "Outil Rectangle arrondi"),
+    ("Ellipse Tool", "Outil Ellipse"),
+    ("Polygon Tool", "Outil Polygone"),
+    ("Star Tool", "Outil Étoile"),
+    ("Pen Tool", "Outil Plume"),
+    ("Add Vertex Tool", "Outil Ajout de sommet"),
+    ("Delete Vertex Tool", "Outil Suppression de sommet"),
+    ("Convert Vertex Tool", "Outil Conversion de sommet"),
+    ("Mask Feather Tool", "Outil Contour progressif du masque"),
+    ("Horizontal Type Tool", "Outil Texte horizontal"),
+    ("Vertical Type Tool", "Outil Texte vertical"),
+    ("Brush Tool", "Outil Pinceau"),
+    ("Clone Stamp Tool", "Outil Tampon de duplication"),
+    ("Eraser Tool", "Outil Gomme"),
+    ("Roto Brush Tool", "Outil Pinceau de rotoscopie"),
+    ("Refine Edge Tool", "Outil Affinage des contours"),
+    ("Object Matte Tool", "Outil Estampe d’objet"),
+    ("Puppet Position Pin Tool", "Outil Épingle de position de marionnette"),
+    ("Puppet Starch Pin Tool", "Outil Épingle de rigidité de marionnette"),
+    ("Puppet Bend Pin Tool", "Outil Épingle de courbure de marionnette"),
+    ("Puppet Advanced Pin Tool", "Outil Épingle avancée de marionnette"),
+    ("Puppet Overlap Pin Tool", "Outil Épingle de chevauchement de marionnette"),
+    ("Shortcut", "Raccourci"),
+    ("Range", "Plage"),
+    ("Play From", "Lire à partir de"),
+    ("Rec. 2020", "Rec. 2020"),
+    ("Light…", "Lumière…"),
+    ("Camera…", "Caméra…"),
+    ("Null Object", "Objet nul"),
+    ("Shape Layer", "Calque de forme"),
+    ("Adjustment Layer", "Calque de réglage"),
+    ("Layer Settings…", "Paramètres du calque…"),
+    ("Create Shapes from Vector Layer", "Créer des formes à partir du calque vectoriel"),
+    ("Create Shapes from Text", "Créer des formes à partir du texte"),
+    ("Create Masks from Text", "Créer des masques à partir du texte"),
+    ("New Mask", "Nouveau masque"),
+    ("Center In View", "Centrer dans la vue"),
+    ("Fit to Comp", "Ajuster à la composition"),
+    ("Flip Horizontal", "Miroir horizontal"),
+    ("Flip Vertical", "Miroir vertical"),
+    ("Enable Time Remapping", "Activer le remappage temporel"),
+    ("Time-Reverse Layer", "Inverser le temps du calque"),
+    ("Freeze Frame", "Image figée"),
+    ("Freeze On Last Frame", "Figer à la dernière image"),
+    ("Add Marker", "Ajouter un repère"),
+    ("Bring Layer to Front", "Placer le calque au premier plan"),
+    ("Bring Layer Forward", "Avancer le calque d’un cran"),
+    ("Send Layer Backward", "Reculer le calque d’un cran"),
+    ("Send Layer to Back", "Placer le calque à l’arrière-plan"),
+    ("Pre-compose…", "Précomposer…"),
+    ("Split Layer", "Fractionner le calque"),
+    ("Layer Style Options...", "Options de style de calque..."),
+    ("Convert to Editable Styles", "Convertir en styles modifiables"),
+    ("Show All", "Tout afficher"),
+    ("Remove All", "Tout supprimer"),
+    ("Separate Dimensions", "Dissocier les dimensions"),
+    ("Add Property to Essential Graphics", "Ajouter la propriété aux graphiques essentiels"),
+    ("Continuous Bezier", "Bézier continu"),
+    ("Auto Bezier", "Bézier automatique"),
+    ("Lock To Time", "Verrouiller sur le temps"),
+    ("Rove Across Time", "Répartir dans le temps"),
+    ("Anchor Point", "Point d’ancrage"),
+    ("All Transform Properties", "Toutes les propriétés de transformation"),
+    ("Line Anchor", "Ancrage de ligne"),
+    ("Line Spacing", "Interligne"),
+    ("Character Offset", "Décalage de caractère"),
+    ("Character Value", "Valeur de caractère"),
+    ("Fill Color: RGB", "Couleur de remplissage : RVB"),
+    ("Fill Color: Hue", "Couleur de remplissage : teinte"),
+    ("Fill Color: Saturation", "Couleur de remplissage : saturation"),
+    ("Fill Color: Brightness", "Couleur de remplissage : luminosité"),
+    ("Fill Color: Opacity", "Couleur de remplissage : opacité"),
+    ("Stroke Color: RGB", "Couleur du contour : RVB"),
+    ("Stroke Color: Hue", "Couleur du contour : teinte"),
+    ("Stroke Color: Saturation", "Couleur du contour : saturation"),
+    ("Stroke Color: Brightness", "Couleur du contour : luminosité"),
+    ("Stroke Color: Opacity", "Couleur du contour : opacité"),
+    ("Stroke Width", "Épaisseur du contour"),
+    ("Front: Color", "Face avant : couleur"),
+    ("Bevel: Color", "Biseau : couleur"),
+    ("Side: Color", "Côté : couleur"),
+    ("Back: Color", "Face arrière : couleur"),
+    ("Effect Controls", "Contrôles d’effets"),
+    ("Effects & Presets", "Effets et préréglages"),
+    ("Motion Sketch", "Croquis de mouvement"),
+    ("Render Queue", "File d’attente de rendu"),
+    ("Mask Interpolation", "Interpolation de masque"),
+    ("Script Console", "Console de scripts"),
+    ("Essential Graphics", "Graphiques essentiels"),
+    ("ScriptUI Panel", "Panneau ScriptUI"),
+    ("Lumetri Scopes", "Scopes Lumetri"),
+    ("Media Browser", "Explorateur de médias"),
+    ("Content-Aware Fill", "Remplissage adapté au contenu"),
+    ("Create Nulls From Paths", "Créer des objets nuls à partir de tracés"),
+    ("VR Comp Editor", "Éditeur de composition VR"),
+    ("Resolution", "Résolution"),
+    ("Overlays", "Incrustations"),
+    ("Layer Controls", "Contrôles de calque"),
+    ("Loop", "Boucle"),
+    ("Cache Before Playback", "Mettre en cache avant la lecture"),
+    ("Pre-roll", "Pré-roulement"),
+    ("Post-roll", "Post-roulement"),
+    ("If caching, play cached frames", "En cas de mise en cache, lire les images en cache"),
+    ("Interpret Footage", "Interpréter le métrage"),
+    ("Create a new Folder", "Créer un nouveau dossier"),
+    ("Create a new Composition", "Créer une nouvelle composition"),
+    ("First Frame", "Première image"),
+    ("Previous Frame", "Image précédente"),
+    ("Next Frame", "Image suivante"),
+    ("Last Frame", "Dernière image"),
+    ("Name (A–Z)", "Nom (A–Z)"),
+    ("Merged PRs", "PR fusionnées"),
+    ("Lines added", "Lignes ajoutées"),
+    ("Lines deleted", "Lignes supprimées"),
+    ("Line delta", "Écart de lignes"),
+    ("Binary assets added", "Ressources binaires ajoutées"),
+    ("Binary assets removed", "Ressources binaires supprimées"),
+    ("First commit", "Premier commit"),
+    ("Last commit", "Dernier commit"),
+    ("Display name", "Nom affiché"),
+    ("Real name", "Vrai nom"),
+    ("ArtCraft website", "Site web d’ArtCraft"),
+    ("Source code on GitHub", "Code source sur GitHub"),
+    ("3D Renderer", "Moteur de rendu 3D"),
+    ("Black", "Noir"),
+    ("White", "Blanc"),
+    ("Composition Settings", "Paramètres de composition"),
+    ("Preset Name", "Nom du préréglage"),
+    ("Lock Aspect Ratio", "Verrouiller le rapport d’aspect"),
+    ("Frame Rate presets", "Préréglages de fréquence d’images"),
+    ("Background Color", "Couleur d’arrière-plan"),
+    ("Basic", "Général"),
+    ("Shutter Angle", "Angle d’obturation"),
+    ("Shutter Phase", "Phase d’obturation"),
+    ("Samples Per Frame", "Échantillons par image"),
+    ("Adaptive Sample Limit", "Limite d’échantillons adaptatifs"),
+    ("X and Y", "X et Y"),
+    ("X only", "X uniquement"),
+    ("Y only", "Y uniquement"),
+    ("Track Camera", "Suivi de caméra"),
+    ("Warp Stabilizer", "Stabilisateur de déformation"),
+    ("Track Motion", "Suivi du mouvement"),
+    ("Stabilize Motion", "Stabiliser le mouvement"),
+    ("Motion Source:", "Source du mouvement :"),
+    ("Current Track:", "Piste actuelle :"),
+    ("Track Type:", "Type de suivi :"),
+    ("Motion Target:", "Cible du mouvement :"),
+    ("Track Mask:", "Suivi du masque :"),
+    ("Analyze forward", "Analyser vers l’avant"),
+    ("Analyze backward", "Analyser vers l’arrière"),
+    ("Continue Tracking", "Poursuivre le suivi"),
+    ("Stop Tracking", "Arrêter le suivi"),
+    ("Adapt Feature", "Adapter la caractéristique"),
+    ("Extrapolate Motion", "Extrapoler le mouvement"),
+    ("Attach Point", "Point de rattachement"),
+    ("Track Name", "Nom de la piste"),
+    ("Motion Tracker Options", "Options du suivi de mouvement"),
+    ("Motion Tracker Apply Options", "Options d’application du suivi de mouvement"),
+    ("Edit Value Graph", "Modifier la courbe de valeur"),
+    ("Edit Speed Graph", "Modifier la courbe de vitesse"),
+    ("Show Reference Graph", "Afficher la courbe de référence"),
+    (
+        "Auto-Select Graph Type (speed graph for spatial properties, else value graph)",
+        "Sélection automatique du type de courbe (vitesse pour les propriétés spatiales, valeur sinon)",
+    ),
+    ("Auto-zoom graph height", "Zoom automatique sur la hauteur du graphique"),
+    ("Fit all graphs to view", "Ajuster tous les graphiques à la vue"),
+    ("Fit selection to view", "Ajuster la sélection à la vue"),
+    (
+        "Snap (key drags snap to the current time and other keys)",
+        "Aimantation (les images clés déplacées s’alignent sur le temps courant et les autres images clés)",
+    ),
+    ("Show Transform Box when multiple keys are selected", "Afficher le cadre de transformation lorsque plusieurs images clés sont sélectionnées"),
+    ("Separate Dimensions (Position)", "Dissocier les dimensions (position)"),
+    ("Convert selected keyframes to Hold", "Convertir les images clés sélectionnées en images figées"),
+    ("Convert selected keyframes to Linear", "Convertir les images clés sélectionnées en linéaire"),
+    ("Convert selected keyframes to Auto Bezier", "Convertir les images clés sélectionnées en Bézier automatique"),
+    ("Easy Ease (F9)", "Lissage (F9)"),
+    ("Easy Ease In (Shift+F9)", "Lissage entrant (Maj+F9)"),
+    ("Easy Ease Out (Ctrl+Shift+F9)", "Lissage sortant (Ctrl+Maj+F9)"),
+    ("Spatial Path", "Trajectoire spatiale"),
+    ("Temporal Path", "Trajectoire temporelle"),
+    ("All the Same", "Tous identiques"),
+    ("All Independently", "Tous indépendants"),
+    ("Noise Type:", "Type de bruit :"),
+    ("Apply To:", "Appliquer à :"),
+    ("Temporal Graph", "Courbe temporelle"),
+    ("Keyframe Rate:", "Fréquence des images clés :"),
+    ("Capture speed at:", "Vitesse de capture à :"),
+    ("Start Capture", "Démarrer la capture"),
+    ("Cancel Capture", "Annuler la capture"),
+    ("Small Caps", "Petites capitales"),
+    ("All Small Caps", "Tout en petites capitales"),
+    ("Superscript / Superior", "Exposant / supérieur"),
+    ("Subscript / Inferior", "Indice / inférieur"),
+    ("Standard Ligatures", "Ligatures standard"),
+    ("Discretionary Ligatures", "Ligatures facultatives"),
+    ("Contextual Alternates", "Alternatives contextuelles"),
+    ("Stylistic Alternates", "Alternatives stylistiques"),
+    ("Titling Alternates", "Alternatives de titrage"),
+    ("Default Figure Style", "Style de chiffres par défaut"),
+    ("Tabular Lining", "Chiffres alignés tabulaires"),
+    ("Proportional Oldstyle", "Chiffres elzéviriens proportionnels"),
+    ("Proportional Lining", "Chiffres alignés proportionnels"),
+    ("Tabular Oldstyle", "Chiffres elzéviriens tabulaires"),
+    ("Fill Over Stroke", "Remplissage sur le contour"),
+    ("Stroke Over Fill", "Contour sur le remplissage"),
+    ("Stroke order", "Ordre du contour"),
+    ("Single-line Composer", "Composeur de ligne unique"),
+    ("Every-line Composer", "Composeur de toutes les lignes"),
+    ("Text direction", "Direction du texte"),
+    ("Recently Used", "Récemment utilisés"),
+    ("User Presets", "Préréglages utilisateur"),
+    ("Remove from Favorites", "Retirer des favoris"),
+    ("Show Animation Presets", "Afficher les animations prédéfinies"),
+    ("    Refresh List", "    Actualiser la liste"),
+    ("    Clear Recently Used", "    Effacer les éléments récemment utilisés"),
+    ("Show 32 bpc Effects Only", "Afficher uniquement les effets 32 bpc"),
+    ("Show GPU Accelerated Effects Only", "Afficher uniquement les effets accélérés par GPU"),
+    ("Show Effects for All Color Depths", "Afficher les effets pour toutes les profondeurs de couleur"),
+    ("* Animation Presets", "* Animations prédéfinies"),
+    ("Select a layer to apply to", "Sélectionnez un calque auquel appliquer"),
+    ("Search effects and presets", "Rechercher des effets et des préréglages"),
+    ("Building waveform…", "Création de la forme d’onde…"),
+    ("No effects. Drag one from Effects & Presets.", "Aucun effet. Faites-en glisser un depuis Effets et préréglages."),
+    (
+        "Click the ring to add a colour; Alt-click a stop (or drag it off) to remove it",
+        "Cliquez sur l’anneau pour ajouter une couleur ; Alt-clic sur un point d’arrêt (ou faites-le glisser hors du dégradé) pour le supprimer",
+    ),
+    (
+        "Start from a ready-made project. Opening a template makes an untitled copy.",
+        "Partez d’un projet prêt à l’emploi. L’ouverture d’un modèle crée une copie sans titre.",
+    ),
+    ("Square Pixels", "Pixels carrés"),
+    ("Alpha Expansion:", "Expansion de l’alpha :"),
+    ("Fill Method:", "Méthode de remplissage :"),
+    ("Edge Blend", "Fusion des bords"),
+    ("Entire Duration", "Durée entière"),
+    ("Reference Frame:", "Image de référence :"),
+    ("Use Current Time", "Utiliser le temps courant"),
+    ("Generate Fill Layer", "Générer un calque de remplissage"),
+    ("Lighting Correction:", "Correction de l’éclairage :"),
+    ("Create Text and Camera", "Créer un texte et une caméra"),
+    ("Create Solid and Camera", "Créer un solide et une caméra"),
+    ("Create Null and Camera", "Créer un objet nul et une caméra"),
+    ("Create Shadow Catcher, Camera and Light", "Créer un récepteur d’ombres, une caméra et une lumière"),
+    ("Unable to solve camera", "Impossible de résoudre la caméra"),
+    ("Waiting to solve", "En attente de résolution"),
+    ("Create Camera", "Créer une caméra"),
+    ("track point", "point de suivi"),
+    ("Ruler zero point", "Point zéro de la règle"),
+    ("Vertical ruler", "Règle verticale"),
+    ("Horizontal ruler", "Règle horizontale"),
+    ("Viewer controls", "Contrôles du visualiseur"),
+    ("Resolution/Down Sample Factor", "Résolution et facteur de sous-échantillonnage"),
+    ("Adjust Exposure", "Ajuster l’exposition"),
+    ("Snapshot taken", "Instantané pris"),
+    ("Fast Previews", "Aperçus rapides"),
+    ("3D View", "Vue 3D"),
+    ("Current time", "Temps courant"),
+    ("Layer Transform", "Transformation du calque"),
+    ("Reset Transform", "Réinitialiser la transformation"),
+    ("Text Animation", "Animation de texte"),
+    ("Text Animation Presets", "Animations de texte prédéfinies"),
+    ("EffectCraft on getartcraft.com", "EffectCraft sur getartcraft.com"),
+    ("Small Screen", "Petit écran"),
+    ("Tool Creates Shape", "L’outil crée une forme"),
+    ("Tool Creates Mask", "L’outil crée un masque"),
+    ("Blend Mode", "Mode de fusion"),
+    ("Show mesh", "Afficher le maillage"),
+    ("Record Options...", "Options d’enregistrement..."),
+    ("Apply", "Appliquer"),
+    ("Analyze", "Analyser"),
+    ("Add Point", "Ajouter un point"),
+    ("Remove Point", "Supprimer le point"),
+    ("Render", "Rendu"),
+    ("Save Current as Template…", "Enregistrer l’actuel comme modèle…"),
+    ("New Composition From Footage", "Nouvelle composition à partir d’un métrage"),
+    ("Search", "Rechercher"),
+    ("(no composition)", "(aucune composition)"),
+    ("per second", "par seconde"),
+    ("Waveform", "Forme d’onde"),
+    ("steps", "étapes"),
+    ("Export Scene to Blender...", "Exporter la scène vers Blender..."),
+    ("Preview", "Prévisualisation"),
+    (
+        "Hands-on tutorials that run inside EffectCraft. Do each step yourself, or press Show me.",
+        "Des tutoriels pratiques qui se déroulent dans EffectCraft. Réalisez chaque étape vous-même, ou appuyez sur Montrez-moi.",
+    ),
+    ("Remove this object's strokes", "Supprimer les traits de cet objet"),
+    ("Object {}", "Objet {}"),
+    ("Object {} ({})", "Objet {} ({})"),
+    ("Output file name template", "Modèle de nom du fichier de sortie"),
+    ("Output file: {}", "Fichier de sortie : {}"),
+    (
+        "JavaScript with the After Effects scripting object model — try app.project.numItems",
+        "JavaScript avec le modèle d’objets de script After Effects — essayez app.project.numItems",
+    ),
+    ("Source", "Source"),
+    ("Label {} color", "Couleur de l’étiquette {}"),
+    ("Label {} name", "Nom de l’étiquette {}"),
+    ("Stroke width presets", "Préréglages d’épaisseur du contour"),
+    ("Close font search", "Fermer la recherche de polices"),
+];
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -5433,8 +10167,15 @@ mod tests {
         ("dock.rs", include_str!("../dock.rs")),
         ("dock_ui.rs", include_str!("../dock_ui.rs")),
         ("header.rs", include_str!("../header.rs")),
-        ("menus.rs", include_str!("../menus.rs")),
+        ("menus/bar.rs", include_str!("../menus/bar.rs")),
+        ("menus/commands.rs", include_str!("../menus/commands.rs")),
+        ("menus/entries.rs", include_str!("../menus/entries.rs")),
+        ("menus/frontend.rs", include_str!("../menus/frontend.rs")),
+        ("menus/invoke.rs", include_str!("../menus/invoke.rs")),
+        ("menus/shortcuts.rs", include_str!("../menus/shortcuts.rs")),
+        ("state.rs", include_str!("../state.rs")),
         ("prefs_live.rs", include_str!("../prefs_live.rs")),
+        ("updates_ui.rs", include_str!("../updates_ui.rs")),
         ("widgets.rs", include_str!("../widgets.rs")),
         ("panels/anim_tools.rs", include_str!("../panels/anim_tools.rs")),
         ("panels/camera_tracker_ui.rs", include_str!("../panels/camera_tracker_ui.rs")),
@@ -5444,7 +10185,11 @@ mod tests {
         ("panels/gradient_editor.rs", include_str!("../panels/gradient_editor.rs")),
         ("panels/dialogs.rs", include_str!("../panels/dialogs.rs")),
         ("panels/dialogs_3d.rs", include_str!("../panels/dialogs_3d.rs")),
-        ("panels/effect_controls.rs", include_str!("../panels/effect_controls.rs")),
+        ("panels/effect_controls/common.rs", include_str!("../panels/effect_controls/common.rs")),
+        ("panels/effect_controls/editors.rs", include_str!("../panels/effect_controls/editors.rs")),
+        ("panels/effect_controls/panel.rs", include_str!("../panels/effect_controls/panel.rs")),
+        ("panels/effect_controls/rows.rs", include_str!("../panels/effect_controls/rows.rs")),
+        ("panels/effect_controls/viewer.rs", include_str!("../panels/effect_controls/viewer.rs")),
         ("panels/effects_presets.rs", include_str!("../panels/effects_presets.rs")),
         ("panels/essential.rs", include_str!("../panels/essential.rs")),
         ("panels/expr_bar.rs", include_str!("../panels/expr_bar.rs")),
@@ -5462,7 +10207,7 @@ mod tests {
         ("panels/markers_ui.rs", include_str!("../panels/markers_ui.rs")),
         ("panels/media_panels.rs", include_str!("../panels/media_panels.rs")),
         ("panels/misc.rs", include_str!("../panels/misc.rs")),
-        ("panels/mod.rs", include_str!("../panels/mod.rs")),
+        ("panels.rs", include_str!("../panels.rs")),
         ("panels/paint_panels.rs", include_str!("../panels/paint_panels.rs")),
         ("panels/path_vr_panels.rs", include_str!("../panels/path_vr_panels.rs")),
         ("panels/precomp.rs", include_str!("../panels/precomp.rs")),
@@ -5482,13 +10227,22 @@ mod tests {
         ("panels/tracker.rs", include_str!("../panels/tracker.rs")),
         ("panels/unsaved.rs", include_str!("../panels/unsaved.rs")),
         ("panels/viewer.rs", include_str!("../panels/viewer.rs")),
+        ("panels/viewer/frame.rs", include_str!("../panels/viewer/frame.rs")),
+        ("panels/viewer/geometry.rs", include_str!("../panels/viewer/geometry.rs")),
+        ("panels/viewer/gesture.rs", include_str!("../panels/viewer/gesture.rs")),
+        ("panels/viewer/shapes.rs", include_str!("../panels/viewer/shapes.rs")),
+        ("panels/viewer/tools.rs", include_str!("../panels/viewer/tools.rs")),
+        ("panels/viewer/view.rs", include_str!("../panels/viewer/view.rs")),
         ("panels/viewer_tools.rs", include_str!("../panels/viewer_tools.rs")),
         ("panels/viewers.rs", include_str!("../panels/viewers.rs")),
         // Text the interface draws but does not own: the settings pages and the viewer's channel
         // and Fast Previews lists come from the engine as data, so their source strings live here.
-        ("engine settings pages", include_str!("../../../engine/src/prefs.rs")),
+        ("engine settings pages", include_str!("../../../engine/src/settings/prefs/dialog.rs")),
+        ("engine settings choices", include_str!("../../../engine/src/settings/prefs/choices.rs")),
         ("engine viewer channels", include_str!("../../../engine/src/viewer.rs")),
-        ("engine viewer commands", include_str!("../../../engine/src/commands/viewer_cmds.rs")),
+        ("engine viewer commands", include_str!("../../../engine/src/cmd/viewer_cmds.rs")),
+        // The text animator menu's labels come from the engine as data, like the settings pages.
+        ("engine text animator kinds", include_str!("../../../project/src/build.rs")),
     ];
 
     fn catalogs() -> Vec<(&'static str, &'static str)> {
@@ -5500,6 +10254,55 @@ mod tests {
         rows.iter().find(|(source, _)| *source == en).map_or(en, |(_, translated)| *translated)
     }
 
+    #[test]
+    fn the_toolbar_asks_the_catalog_for_the_tool_names() {
+        let header = include_str!("../header.rs");
+        for call in ["crate::i18n::tr(tool.label())", "crate::i18n::tr(cur.label())"] {
+            assert!(header.contains(call), "header.rs no longer draws {call}");
+        }
+        assert!(
+            header.contains("app.auto.add(&format!(\"tools.select.{tool:?}\"), row.rect, tool.label())"),
+            "the automation label must stay the English tool name"
+        );
+    }
+
+    #[test]
+    fn the_preview_panel_labels_are_translated() {
+        // The Preview panel draws these from a local closure, a check table and a roll tuple, none of
+        // which the call-shape scan sees; they had no rows at all.
+        for key in [
+            "Shortcut",
+            "Range",
+            "Play From",
+            "Frame Rate",
+            "Resolution",
+            "Overlays",
+            "Layer Controls",
+            "Loop",
+            "Cache Before Playback",
+            "Pre-roll",
+            "Post-roll",
+            "If caching, play cached frames",
+        ] {
+            for (name, table) in [("Simplified", SIMPLIFIED_CHINESE), ("Traditional", TRADITIONAL_CHINESE)] {
+                let value = table.iter().find(|(k, _)| *k == key).map(|(_, v)| *v);
+                assert!(value.is_some_and(|v| !v.is_empty()), "{key} has no {name} row");
+            }
+        }
+        // A row is not a translation until the panel asks for it: the labels drawn one by one carry
+        // `tr(..)`, and the table and the roll tuple wrap the text they read at the call.
+        let source = include_str!("../panels/misc.rs");
+        for literal in ["Shortcut", "Range", "Play From", "Frame Rate", "Resolution", "Full Screen", "If caching, play cached frames"] {
+            assert!(source.contains(&format!("tr(\"{literal}\")")), "{literal} is drawn without asking the catalog");
+        }
+        for call in ["check_row(app, ui, &p, pos2(cx, cy), key, tr(text), on)", "Align2::LEFT_CENTER, tr(text),"] {
+            assert!(source.contains(call), "{call} no longer asks the catalog");
+        }
+        for table in ["\"Overlays\"", "\"Layer Controls\"", "\"Loop\"", "\"Cache Before Playback\"", "\"Pre-roll\"", "\"Post-roll\""] {
+            assert!(source.contains(table), "{table} is not in the panel");
+        }
+    }
+
     /// A row that translates nothing, repeats a source string, or changes the number of values the
     /// English source carries is a bug in the catalog itself.
     #[test]
@@ -5546,6 +10349,35 @@ mod tests {
         set_current("en");
     }
 
+    /// Swedish panels translate, fill values in order and keep project content.
+    #[test]
+    fn swedish_panels_translate_and_keep_project_content() {
+        set_current("sv");
+        assert_eq!(tr("Composition Name:"), "Kompositionsnamn:");
+        assert_eq!(tr("Cancel"), "Avbryt");
+        assert_eq!(tr("my layer.mp4"), "my layer.mp4");
+        assert_eq!(tr_args("Proxy Use: {}", &[&"Best"]), "Proxyanvändning: Best");
+        assert_eq!(tr_args("Step {} of {}: {}", &[&1, &3, &"Colour"]), "Steg 1 av 3: Colour");
+        set_current("en");
+        assert_eq!(tr("Cancel"), "Cancel");
+    }
+
+    /// French sets a no-break space before `:`, `;`, `?` and `!`, never a plain one, and keeps the
+    /// project's own text untouched.
+    #[test]
+    fn french_panels_translate_and_keep_the_punctuation_rule() {
+        for (en, fr) in FRENCH {
+            assert!(!fr.contains(" :") && !fr.contains(" ;") && !fr.contains(" ?") && !fr.contains(" !"), "{en:?}: plain space before a high punctuation mark");
+        }
+        set_current("fr");
+        assert_eq!(tr("Composition Name:"), "Nom de la composition\u{a0}:");
+        assert_eq!(tr("Cancel"), "Annuler");
+        assert_eq!(tr("my layer.mp4"), "my layer.mp4");
+        assert_eq!(tr_args("Step {} of {}: {}", &[&1, &3, &"Colour"]), "Étape 1 sur 3\u{a0}: Colour");
+        set_current("en");
+        assert_eq!(tr("Cancel"), "Cancel");
+    }
+
     /// Values fill the placeholders in order, and a missing value is dropped instead of panicking.
     #[test]
     fn tr_args_fills_values_in_order() {
@@ -5559,10 +10391,321 @@ mod tests {
         assert_eq!(tr_args("Proxy Use: {}", &[]), "Proxy Use: ");
     }
 
+    /// Japanese reads its own rows: values fill the placeholders in order, and a name that is not a
+    /// row (a layer or file name) stays verbatim.
+    #[test]
+    fn japanese_rows_translate_the_panels() {
+        set_current("ja");
+        assert_eq!(tr("Composition Name:"), "コンポジション名:");
+        // The panel/dialog second step: panel tabs, form labels, context menus and messages.
+        assert_eq!(tr("Effect Controls"), "エフェクトコントロール");
+        assert_eq!(tr("Media Duration"), "メディアの長さ");
+        assert_eq!(tr("Bring Layer to Front"), "レイヤーを最前面へ");
+        assert_eq!(tr("All Transform Properties"), "すべてのトランスフォームプロパティ");
+        assert_eq!(tr("Fill Color: RGB"), "塗りのカラー: RGB");
+        assert_eq!(tr("Lines added"), "追加行数");
+        // The composition-settings tabs and the Preview transport pass these through `tr` as
+        // variables, so a missing row would fall back to English unnoticed.
+        assert_eq!(tr("Basic"), "基本");
+        assert_eq!(tr("Advanced"), "詳細");
+        assert_eq!(tr("Play/Stop"), "再生/停止");
+        assert_eq!(tr("my layer.mp4"), "my layer.mp4");
+        assert_eq!(tr_args("Proxy Use: {}", &[&"Best"]), "プロキシの使用：Best");
+        assert_eq!(tr_args("Step {} of {}: {}", &[&1, &3, &"Colour"]), "ステップ1/3：Colour");
+        set_current("en");
+    }
+
     /// Every row is asked for by a converted panel: a leftover row is stale, because the panel's
     /// English source changed or went away. A string a helper draws for the panel (a toolbar
     /// tooltip, a popup item, a checkbox label) is looked up inside that helper, so its English
     /// source only appears as a literal there.
+    #[test]
+    fn helper_and_painter_labels_are_translated() {
+        /// The `widgets.rs` helpers that draw a label, and which argument holds it.
+        const HELPER_LABELS: &[(&str, usize)] =
+            &[("text_button", 2), ("search_field", 3), ("text_field", 3), ("dropdown", 2), ("dropdown_tip", 2), ("text_fit", 3), ("check_label", 1)];
+        /// Literals that draw as they are: a brand, a value, a separator, a unit, and the kerning
+        /// sample pair the Character panel shows.
+        const VERBATIM: &[&str] = &["EffectCraft", "32", "dB", "···", "×", "V/A"];
+
+        /// The top-level arguments of a call, given the text after its `(`. A call split over
+        /// several lines is still one argument list, so this walks past newlines until the
+        /// parenthesis closes. It understands the two string forms a label can be written in - a
+        /// plain one with escapes and a raw one (`r"…"`, `r#"…"#`) - so a comma or parenthesis
+        /// inside either is not mistaken for code.
+        fn args_of(s: &str) -> Vec<&str> {
+            #[derive(Clone, Copy)]
+            enum Mode {
+                Code,
+                Str(bool),
+                Raw(usize),
+            }
+            let cs: Vec<(usize, char)> = s.char_indices().collect();
+            let (mut out, mut depth, mut start, mut end) = (Vec::new(), 0i32, None, s.len());
+            let mut mode = Mode::Code;
+            let mut k = 0;
+            while k < cs.len() {
+                let (i, c) = cs[k];
+                match mode {
+                    Mode::Raw(hashes) => {
+                        if c == '"' {
+                            let mut n = 0;
+                            while cs.get(k + 1 + n).is_some_and(|(_, h)| *h == '#') {
+                                n += 1;
+                            }
+                            if n >= hashes {
+                                mode = Mode::Code;
+                                k += n;
+                            }
+                        }
+                    }
+                    Mode::Str(escaped) => {
+                        mode = if c == '"' && !escaped { Mode::Code } else { Mode::Str(c == '\\' && !escaped) };
+                    }
+                    Mode::Code => match c {
+                        '"' => {
+                            mode = Mode::Str(false);
+                            if start.is_none() {
+                                start = Some(i);
+                            }
+                        }
+                        'r' if start.is_none() && cs.get(k + 1).is_some_and(|(_, n)| *n == '#' || *n == '"') => {
+                            let mut n = 0;
+                            while cs.get(k + 1 + n).is_some_and(|(_, h)| *h == '#') {
+                                n += 1;
+                            }
+                            if cs.get(k + 1 + n).is_some_and(|(_, q)| *q == '"') {
+                                mode = Mode::Raw(n);
+                                start = Some(i);
+                                k += n + 1;
+                            }
+                        }
+                        '(' | '[' | '{' => depth += 1,
+                        ')' | ']' | '}' => {
+                            if depth == 0 {
+                                end = i;
+                                break;
+                            }
+                            depth -= 1;
+                        }
+                        ',' if depth == 0 => {
+                            if let Some(st) = start {
+                                out.push(s[st..i].trim());
+                            }
+                            start = None;
+                        }
+                        c if !c.is_whitespace() && start.is_none() => start = Some(i),
+                        _ => {}
+                    },
+                }
+                k += 1;
+            }
+            if let Some(st) = start {
+                out.push(s[st..end].trim());
+            }
+            out
+        }
+
+        /// The text a literal argument draws: a plain string with its escapes undone, or a raw
+        /// string with none. `None` when the argument is not one literal (a concatenation, a call).
+        fn literal_text(arg: &str) -> Option<String> {
+            if let Some(rest) = arg.strip_prefix('r') {
+                let hashes = rest.chars().take_while(|c| *c == '#').count();
+                // An identifier that starts with `r` (`result`) is not a raw string: the quote has
+                // to follow the `#`s.
+                if rest.chars().nth(hashes) != Some('"') {
+                    return None;
+                }
+                let close = format!("\"{}", "#".repeat(hashes));
+                return arg.get(1 + hashes + 1..)?.strip_suffix(&close).map(str::to_string);
+            }
+            let body = arg.strip_prefix('"')?.strip_suffix('"')?;
+            // Decode the escapes that matter for the exemption: a literal written as `"\u{bb}"` is
+            // one character (`»`), not six.
+            let mut out = String::new();
+            let mut it = body.chars().peekable();
+            while let Some(c) = it.next() {
+                if c != '\\' {
+                    if c == '"' {
+                        return None; // two literals side by side
+                    }
+                    out.push(c);
+                    continue;
+                }
+                match it.next()? {
+                    '"' => out.push('"'),
+                    '\\' => out.push('\\'),
+                    'n' => out.push('\n'),
+                    't' => out.push('\t'),
+                    'x' => {
+                        let hex: String = it.by_ref().take(2).collect();
+                        let byte = u8::from_str_radix(&hex, 16).ok()?;
+                        out.push(char::from(byte));
+                    }
+                    'u' => {
+                        if it.next() != Some('{') {
+                            return None;
+                        }
+                        let hex: String = it.by_ref().take_while(|c| *c != '}').collect();
+                        out.push(char::from_u32(u32::from_str_radix(&hex, 16).ok()?)?);
+                    }
+                    other => {
+                        out.push('\\');
+                        out.push(other);
+                    }
+                }
+            }
+            Some(out)
+        }
+
+        /// `source` with comments blanked and the *contents* of every string literal blanked too,
+        /// with offsets, newlines and the quotes kept. Call tokens are looked for in this text, so a
+        /// `widgets::…(` or `.text(` that only appears inside a doc string or a sample is not
+        /// mistaken for a call; the argument list is then read from the original at that offset.
+        fn code_only(source: &str) -> String {
+            #[derive(Clone, Copy)]
+            enum Mode {
+                Code,
+                Str(bool),
+                Raw(usize),
+                Comment,
+            }
+            let cs: Vec<(usize, char)> = source.char_indices().collect();
+            // Byte-for-byte: a blanked character becomes as many spaces as its UTF-8 length, so
+            // every offset found here indexes the original source as well.
+            let mut out: Vec<u8> = Vec::with_capacity(source.len());
+            let keep = |out: &mut Vec<u8>, c: char| out.extend_from_slice(c.encode_utf8(&mut [0; 4]).as_bytes());
+            let blank = |out: &mut Vec<u8>, c: char| out.extend(std::iter::repeat_n(b' ', c.len_utf8()));
+            let mut mode = Mode::Code;
+            let mut k = 0;
+            while k < cs.len() {
+                let (_, c) = cs[k];
+                match mode {
+                    Mode::Comment => {
+                        if c == '\n' {
+                            mode = Mode::Code;
+                            keep(&mut out, c);
+                        } else {
+                            blank(&mut out, c);
+                        }
+                    }
+                    Mode::Raw(hashes) => {
+                        if c == '"' {
+                            let mut n = 0;
+                            while cs.get(k + 1 + n).is_some_and(|(_, h)| *h == '#') {
+                                n += 1;
+                            }
+                            if n >= hashes {
+                                keep(&mut out, c);
+                                for j in 1..=n {
+                                    keep(&mut out, cs[k + j].1);
+                                }
+                                mode = Mode::Code;
+                                k += n;
+                            } else {
+                                blank(&mut out, c);
+                            }
+                        } else {
+                            blank(&mut out, c);
+                        }
+                    }
+                    Mode::Str(escaped) => {
+                        if c == '"' && !escaped {
+                            mode = Mode::Code;
+                            keep(&mut out, c);
+                        } else {
+                            mode = Mode::Str(c == '\\' && !escaped);
+                            blank(&mut out, c);
+                        }
+                    }
+                    Mode::Code => match c {
+                        '"' => {
+                            mode = Mode::Str(false);
+                            keep(&mut out, c);
+                        }
+                        '/' if out.last() == Some(&b'/') => {
+                            // The first `/` stays; this one becomes a space. Both are one byte, so
+                            // the mask keeps its length and every offset still indexes the source.
+                            blank(&mut out, c);
+                            mode = Mode::Comment;
+                        }
+                        'r' if matches!(cs.get(k + 1), Some((_, n)) if *n == '#' || *n == '"') => {
+                            let mut n = 0;
+                            while cs.get(k + 1 + n).is_some_and(|(_, h)| *h == '#') {
+                                n += 1;
+                            }
+                            if cs.get(k + 1 + n).is_some_and(|(_, q)| *q == '"') {
+                                keep(&mut out, c);
+                                for j in 1..=n {
+                                    keep(&mut out, cs[k + j].1);
+                                }
+                                keep(&mut out, '"');
+                                mode = Mode::Raw(n);
+                                k += n + 1;
+                            } else {
+                                keep(&mut out, c);
+                            }
+                        }
+                        _ => keep(&mut out, c),
+                    },
+                }
+                k += 1;
+            }
+            debug_assert_eq!(out.len(), source.len(), "the mask must keep every byte offset");
+            String::from_utf8(out).expect("mask keeps UTF-8 boundaries")
+        }
+
+        for (path, source) in CONVERTED {
+            // The test module draws nothing; it holds sample strings. A test-only helper above it
+            // (`#[cfg(test)] pub(crate) fn press_key` in `dialogs.rs`) is kept in the scanned range,
+            // because production code follows it.
+            let cut = source
+                .match_indices("#[cfg(test)]")
+                .find(|(at, _)| source[at + "#[cfg(test)]".len()..].lines().take(3).any(|l| l.trim_start().starts_with("mod ")))
+                .map_or(source.len(), |(at, _)| at);
+            let source = &source[..cut];
+            let code = code_only(source);
+            let line_of = |at: usize| code[..at].matches('\n').count() + 1;
+            let check = |at: usize, arg: &str, what: &str| {
+                // A single character is a symbol or a glyph, not interface text - the same exemption
+                // the call-shape scan above makes. A call that already asks the catalog is not a
+                // literal here at all.
+                if let Some(text) = literal_text(arg)
+                    && text.chars().count() >= 2
+                    && !VERBATIM.contains(&text.as_str())
+                {
+                    panic!("{path}:{}: the interface text {arg} that {what} draws is not in the catalog", line_of(at));
+                }
+            };
+            for (call, index) in HELPER_LABELS {
+                let marker = format!("widgets::{call}(");
+                for (at, _) in code.match_indices(&marker) {
+                    if let Some(arg) = args_of(&source[at + marker.len()..]).get(*index) {
+                        check(at, arg, &format!("widgets::{call}"));
+                    }
+                }
+            }
+            for (at, _) in code.match_indices(".text(") {
+                if let Some(arg) = args_of(&source[at + ".text(".len()..]).get(2) {
+                    check(at, arg, "Painter::text");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn the_composition_settings_labels_are_translated() {
+        // The Composition Settings dialog (and New Composition) draws these from a `(label, value)`
+        // table, a tab array and a `match` arm, which the call-shape scan cannot see (#1451). They
+        // used to have no row in any catalog, so every interface drew them in English.
+        for key in ["Square Pixels", "Basic", "Advanced", "3D Renderer", "Black", "White", "Composition Settings"] {
+            for (name, table) in [("Simplified", SIMPLIFIED_CHINESE), ("Traditional", TRADITIONAL_CHINESE)] {
+                let value = table.iter().find(|(k, _)| *k == key).map(|(_, v)| *v);
+                assert!(value.is_some_and(|v| !v.is_empty()), "{key} has an empty {name} row");
+            }
+        }
+    }
+
     #[test]
     fn every_row_is_used_by_a_converted_panel() {
         for (en, _) in catalogs() {
diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rs
index 949ea3771..eec054fff 100644
--- a/crates/ui-egui/src/icons.rs
+++ b/crates/ui-egui/src/icons.rs
@@ -48,6 +48,8 @@ pub enum Icon {
     Speaker,
     Solo,
     Lock,
+    /// An open padlock: the shackle lifted clear of the body on the right.
+    LockOpen,
     Shy,
     Collapse,
     Quality,
@@ -110,6 +112,8 @@ pub enum Icon {
     Fullscreen,
     Channel,
     Exposure,
+    /// Stroke width: three bars, thin to thick.
+    StrokeWidth,
     // links
     Chat,
     Globe,
@@ -160,6 +164,14 @@ impl Pen16<'_> {
     fn dot(&self, x: f32, y: f32, r: f32) {
         self.painter.circle_filled(self.p(x, y), r * self.s(), self.color);
     }
+    /// A filled dot in its own colour, for the icons that are coloured in After Effects too (the
+    /// channel picker's red, green and blue). The tint's alpha is kept, so a dimmed button stays
+    /// dimmed.
+    fn dot_colored(&self, x: f32, y: f32, r: f32, color: Color32) {
+        // `gamma_multiply` keeps the premultiplied channels consistent, so a dimmed tint dims the
+        // circle instead of darkening it twice.
+        self.painter.circle_filled(self.p(x, y), r * self.s(), color.gamma_multiply(self.color.a() as f32 / 255.0));
+    }
     fn rect(&self, x0: f32, y0: f32, x1: f32, y1: f32) {
         let r = Rect::from_min_max(self.p(x0, y0), self.p(x1, y1));
         self.painter.rect_stroke(r, 1.0 * self.s(), Stroke::new(self.width * self.s(), self.color), egui::StrokeKind::Middle);
@@ -402,6 +414,12 @@ pub fn paint(painter: &Painter, rect: Rect, icon: Icon, color: Color32) {
             pen.arc(8.0, 7.0, 3.0, 180.0, 360.0);
             pen.dot(8.0, 10.5, 1.0);
         }
+        LockOpen => {
+            pen.rect(3.5, 7.0, 12.5, 14.0);
+            pen.arc(8.0, 4.0, 3.0, 180.0, 360.0);
+            pen.line(&[(5.0, 4.0), (5.0, 7.0)]);
+            pen.dot(8.0, 10.5, 1.0);
+        }
         Shy => {
             pen.circle(8.0, 8.0, 5.8);
             pen.dot(6.0, 7.0, 0.8);
@@ -540,6 +558,11 @@ pub fn paint(painter: &Painter, rect: Rect, icon: Icon, color: Color32) {
             }
             pen.circle(8.0, 8.0, 4.2);
         }
+        StrokeWidth => {
+            pen.rect_fill(2.5, 3.0, 13.5, 3.75);
+            pen.rect_fill(2.5, 6.5, 13.5, 8.0);
+            pen.rect_fill(2.5, 10.5, 13.5, 13.0);
+        }
         Hamburger => {
             for y in [4.5, 8.0, 11.5] {
                 pen.line(&[(3.0, y), (13.0, y)]);
@@ -638,9 +661,11 @@ pub fn paint(painter: &Painter, rect: Rect, icon: Icon, color: Color32) {
             pen.line(&[(6.0, 14.0), (2.0, 14.0), (2.0, 10.0)]);
         }
         Channel => {
-            pen.circle(6.0, 6.5, 3.6);
-            pen.circle(10.0, 6.5, 3.6);
-            pen.circle(8.0, 10.0, 3.6);
+            // After Effects draws this one in colour: red, green and blue, as the channels it picks
+            // between. The circles keep the geometry this icon already had; only their fill changes.
+            pen.dot_colored(6.0, 6.5, 3.6, Color32::from_rgb(226, 58, 58));
+            pen.dot_colored(10.0, 6.5, 3.6, Color32::from_rgb(58, 200, 88));
+            pen.dot_colored(8.0, 10.0, 3.6, Color32::from_rgb(64, 120, 235));
         }
         Exposure => {
             pen.circle(8.0, 8.0, 5.5);
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 0dbdfdfbf..ca8c1fb01 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -7,6 +7,17 @@
 
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
+pub(crate) mod a11y;
+
+/// EffectCraft as craft-update knows it, with its 128 px icon and accent colour: the update
+/// prompt shows both, and an AppImage's menu entry gets the icon.
+#[cfg(not(target_arch = "wasm32"))]
+pub const UPDATE_APP: craft_update::app::App = craft_update::app::App {
+    icon_png: Some(include_bytes!("../../../assets/app-icon/hicolor/128x128/apps/ai.storyteller.effectcraft.png")),
+    accent: Some([0xe0, 0x36, 0x8f]),
+    ..craft_update::suite::EFFECTCRAFT
+};
+
 pub mod audio;
 pub mod automation;
 pub mod bench;
@@ -14,7 +25,6 @@ pub mod color_picker;
 pub mod control;
 pub mod credits;
 pub mod dock;
-mod dock_shared;
 pub mod dock_ui;
 mod expression_diagnostics;
 pub mod frames;
@@ -38,7 +48,7 @@ use std::sync::Arc;
 use std::sync::mpsc::{Receiver, Sender};
 
 pub use control::ControlRequest;
-use dock::PanelKind;
+use dock::{PanelKind, WorkspaceExt as _};
 use effectcraft_engine::Session;
 use effectcraft_engine::project::ItemId;
 use effectcraft_engine::render::RenderOpts;
@@ -48,74 +58,16 @@ use serde_json::json;
 use state::UiState;
 use theme::Tokens;
 
-/// How long a screenshot request waits for a frame, from admission (app clock seconds).
-const SCREENSHOT_TIMEOUT_S: f64 = 8.0;
-/// Seconds between a screenshot's admission and the earliest capture: the UI settles first.
-const SCREENSHOT_SETTLE_S: f64 = 0.35;
-/// Final (non-discarded) UI passes a screenshot waits for after admission before it is issued.
-const SCREENSHOT_SETTLE_PASSES: u64 = 3;
-/// Geometry changes a queued screenshot may retry before it reports an error.
-const SCREENSHOT_MAX_RETRIES: u32 = 4;
-/// Outstanding screenshot requests (queued or waiting for their pixels).
-const MAX_PENDING_SHOTS: usize = 4;
-/// One capture's pixels: 128 MiB.
-const MAX_SHOT_BYTES: usize = 128 * 1024 * 1024;
-/// Every pending capture's reserved pixels together: 256 MiB.
-const MAX_SHOT_TOTAL_BYTES: usize = 256 * 1024 * 1024;
-/// Seconds without a project change before paused prefetch resumes (see
-/// [`EffectcraftApp::editing`]).
-const EDIT_QUIET: f64 = 0.3;
+mod app;
+mod clock;
+mod hooks;
 
-/// The application's monotonic clock, in seconds.
-///
-/// Neither `ctx.input(|i| i.time)` nor `RawInput::time` is valid in a logic-only tick:
-/// `Context::run_logic` copies only the viewport information, so both are the previous full
-/// pass's values. Playback, auto-save, screenshot deadlines and the control channel measure time
-/// with this clock instead. Native and web use the same [`web_time::Instant`] source; tests
-/// inject [`AppClock::manual`] and advance it.
-#[derive(Clone, Debug)]
-pub struct AppClock {
-    origin: web_time::Instant,
-    manual: Option<f64>,
-}
-
-impl AppClock {
-    /// The host's monotonic clock.
-    pub fn real() -> Self {
-        Self { origin: web_time::Instant::now(), manual: None }
-    }
-
-    /// A clock tests advance explicitly with [`AppClock::advance`].
-    pub fn manual() -> Self {
-        Self { origin: web_time::Instant::now(), manual: Some(0.0) }
-    }
-
-    /// Seconds since the clock started (monotonic on native and in the browser).
-    pub fn now(&self) -> f64 {
-        match self.manual {
-            Some(t) => t,
-            None => self.origin.elapsed().as_secs_f64(),
-        }
-    }
-
-    /// Move a manual clock forward; a real clock ignores this.
-    pub fn advance(&mut self, seconds: f64) {
-        if let Some(t) = &mut self.manual {
-            *t = (*t + seconds.max(0.0)).max(0.0);
-        }
-    }
-
-    /// Whether the clock is test-driven.
-    pub fn is_manual(&self) -> bool {
-        self.manual.is_some()
-    }
-}
-
-impl Default for AppClock {
-    fn default() -> Self {
-        Self::real()
-    }
-}
+pub use app::{GPU_PREPARING, GpuBuild};
+#[cfg(test)]
+use app::{MAX_PENDING_SHOTS, SCREENSHOT_SETTLE_PASSES, SCREENSHOT_SETTLE_S, SCREENSHOT_TIMEOUT_S};
+pub use clock::AppClock;
+pub use hooks::{DialogDone, FileDialog, Hooks, SystemThemeFn};
+pub use state::ShotTarget;
 
 /// The root surface geometry of the last completed (non-discarded) UI pass.
 ///
@@ -129,39 +81,6 @@ pub struct DrawGeometry {
     pub epoch: u64,
 }
 
-/// Whether a captured image's dimensions match `rect` at `ppp`.
-///
-/// The surface may be smaller than requested when the adapter-limit fit (fork E2) applies, but a
-/// different aspect ratio means the pixels came from another layout than the one issued.
-fn shot_image_matches(image: &egui::ColorImage, rect: egui::Rect, ppp: f32) -> bool {
-    let [w, h] = image.size;
-    if w == 0 || h == 0 || !ppp.is_finite() || ppp <= 0.0 {
-        return false;
-    }
-    let ew = (rect.width() as f64 * ppp as f64).max(1.0);
-    let eh = (rect.height() as f64 * ppp as f64).max(1.0);
-    let want = ew / eh;
-    let got = w as f64 / h as f64;
-    (got - want).abs() <= 0.02 * want.max(1.0)
-}
-
-/// What a `ui.screenshot` captures.
-///
-/// A panel or element is an identity, not a rectangle: it is resolved again when the capture is
-/// issued, after the settle passes, so a panel that moved or resized while the UI settled is
-/// captured where it is now (never with the rectangle from request admission).
-#[derive(Clone, Debug, PartialEq)]
-pub enum ShotTarget {
-    /// The whole root surface.
-    Window,
-    /// A fixed rectangle in logical points, relative to the root surface's top-left corner.
-    Rect([f32; 4]),
-    /// One dock panel's automation rectangle (`panel.<id>`).
-    Panel(PanelKind),
-    /// One automation element id's rectangle.
-    Id(String),
-}
-
 /// One `ui.screenshot` request: its reply, its admission reservation and its completion slot.
 struct PendingShot {
     path: Option<String>,
@@ -239,35 +158,6 @@ pub enum Dialog {
     DeleteTemplate,
 }
 
-/// The desktop's light or dark appearance where egui cannot see it (Wayland compositors that send
-/// winit no theme). `None` = the host does not know.
-pub type SystemThemeFn = Box<dyn Fn(&egui::Context) -> Option<egui::Theme>>;
-
-/// A file dialog a host shows without blocking the frame ([`Hooks::file_dialog_async`]).
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum FileDialog {
-    /// Files to open or import with these extensions; several when `many`.
-    Open { exts: Vec<String>, many: bool },
-    /// An EffectCraft project to open.
-    OpenProject,
-    /// A folder.
-    Folder,
-    /// Where to save `default` (a file name or path) with extension `ext` (empty: no filter);
-    /// `project`: the project save dialog, given the file name.
-    Save { default: String, ext: String, project: bool },
-}
-
-impl FileDialog {
-    /// The save dialog for `default`, as [`Hooks::save_dialog`] picks it.
-    pub fn save(default: &str) -> Self {
-        let ext = std::path::Path::new(default).extension().map(|e| e.to_string_lossy().to_string()).unwrap_or_default();
-        Self::Save { default: default.to_string(), project: ext.eq_ignore_ascii_case("ecproj"), ext }
-    }
-}
-
-/// Called with the paths a [`FileDialog`] picked (empty: cancelled), from any thread.
-pub type DialogDone = Box<dyn FnOnce(Vec<String>) + Send>;
-
 /// A non-blocking file dialog's answer for the command that asked (`menus::dialog_answered`).
 pub(crate) struct DialogAnswer {
     pub command: String,
@@ -276,59 +166,6 @@ pub(crate) struct DialogAnswer {
     pub paths: Vec<String>,
 }
 
-/// Host hooks provided by the native app (file pickers etc.).
-#[derive(Default)]
-pub struct Hooks {
-    /// The system appearance for Settings ▸ Appearance ▸ Sync with System (the desktop app reads
-    /// the Linux desktop portal); without it, what egui reports.
-    pub system_theme: Option<SystemThemeFn>,
-    pub pick_files: Option<Box<dyn Fn(&[&str]) -> Vec<String>>>,
-    pub pick_save: Option<Box<dyn Fn(&str) -> Option<String>>>,
-    pub pick_open_project: Option<Box<dyn Fn() -> Option<String>>>,
-    /// Opens the audio output for preview playback (the desktop app uses cpal).
-    pub audio_device: Option<audio::AudioDeviceFactory>,
-    /// Lists audio output devices (Settings ▸ Audio).
-    pub audio_devices: Option<Box<dyn Fn() -> Vec<String>>>,
-    /// Picks a folder (Settings paths).
-    pub pick_folder: Option<Box<dyn Fn() -> Option<String>>>,
-    /// Save dialog for other file kinds: (default name or path, extension; empty: no filter). A
-    /// default path opens the dialog in its folder.
-    pub pick_save_file: Option<Box<dyn Fn(&str, &str) -> Option<String>>>,
-    /// The system clipboard's text (native menu Edit ▸ Paste into a text field).
-    pub clipboard_text: Option<Box<dyn Fn() -> Option<String>>>,
-    /// Application actions the OS performs (`app.hide`, `app.hideOthers`, `app.showAll` on
-    /// macOS). Returns false when the host doesn't handle the id.
-    pub app_action: Option<Box<dyn Fn(&str) -> bool>>,
-    /// Shows a command's file dialog without blocking the frame and calls `done` with the
-    /// answer (the host then asks for a repaint). Used in place of the blocking pickers above for
-    /// the commands' dialogs (File ▸ Import, Open, Save As…) where blocking the frame is unsafe or
-    /// leaves the window unresponsive: on macOS a nested modal event loop there aborted the app on
-    /// a drag over the window (#511), and on Linux a blocking desktop-portal dialog never pumps
-    /// events, so the compositor marks the window as not responding (#1275).
-    pub file_dialog_async: Option<Box<dyn Fn(FileDialog, DialogDone)>>,
-    /// Tells the user the graphics device was lost and the window is closing, once. `saved` is
-    /// the auto-save of unsaved changes (`None`: nothing was unsaved), its path or why it failed.
-    pub device_lost: Option<Box<dyn Fn(Option<Result<String, String>>)>>,
-}
-
-impl Hooks {
-    /// The host's save dialog for `default` (a file name or path), offering its extension: the
-    /// project dialog for project files, else [`Hooks::pick_save_file`]. The project dialog is
-    /// the fallback for hosts without that (the web, whose dialog only names the file): on macOS
-    /// a dialog filtered to projects appends `.ecproj` to any other name (#293). `None` when the
-    /// host has no save dialog; `Some(None)` when it was cancelled.
-    pub fn save_dialog(&self, default: &str) -> Option<Option<String>> {
-        let path = std::path::Path::new(default);
-        let ext = path.extension().map(|e| e.to_string_lossy().to_string()).unwrap_or_default();
-        match (&self.pick_save_file, &self.pick_save) {
-            (Some(pick), _) if !ext.eq_ignore_ascii_case("ecproj") => Some(pick(default, &ext)),
-            (_, Some(pick)) => Some(pick(&path.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default())),
-            (Some(pick), None) => Some(pick(default, &ext)),
-            (None, None) => None,
-        }
-    }
-}
-
 #[derive(Default)]
 pub struct Playback {
     pub playing: bool,
@@ -359,6 +196,17 @@ pub struct Playback {
     /// fits in the RAM preview) is cached, so it never plays over skipped frames (#103), or
     /// sooner once the silent preview keeps real time with the frames ahead cached (#208).
     pub audio_held: bool,
+    /// Starting a preview with sound (#947): the playhead stays on the first frame while the
+    /// frames ahead render (the prefetch window, at most what fits in the RAM preview), then
+    /// sound and picture start together from it. Without this the picture played on silently
+    /// while they rendered and the sound started at the later frame, so the opening was lost.
+    /// A stall later on still falls back to [`Playback::audio_held`].
+    pub starting: bool,
+    /// When the preview started (seconds): [`Playback::starting`] gives up after `STARTUP_LIMIT`.
+    pub starting_since: f64,
+    /// When the first frame was cached while [`Playback::starting`] (seconds): the wait for the
+    /// frames ahead gives up `STARTUP_WAIT` after it.
+    pub first_cached: Option<f64>,
     /// When the last frames were shown (seconds, the last second's worth): the achieved rate.
     pub shown_at: std::collections::VecDeque<f64>,
 }
@@ -441,6 +289,8 @@ pub struct EffectcraftApp {
     pub(crate) control_rx: Option<Receiver<ControlRequest>>,
     pub(crate) deferred: Vec<(ControlRequest, f64)>,
     pub(crate) synthetic: Vec<egui::Event>,
+    /// Input from floating panels' own OS windows for the main window's next frame.
+    pub(crate) forwarded: ForwardedInput,
     pub(crate) input_waiters: Vec<Sender<serde_json::Value>>,
     /// Control requests waiting for an offloaded job (`wait: true` in the browser).
     pub(crate) job_waiters: Vec<(control::JobWaiter, Sender<serde_json::Value>)>,
@@ -472,13 +322,24 @@ pub struct EffectcraftApp {
     /// The GPU compositor on that device (None: no usable adapter → CPU only).
     pub(crate) gpu: Option<effectcraft_gpu::Gpu>,
     gpu_checked: bool,
+    /// The GPU compositor being built on a worker thread (desktop): the window opens at once and
+    /// composites on the CPU until the worker's result lands ([`Self::init_gpu`]).
+    #[cfg(not(target_arch = "wasm32"))]
+    gpu_build: Option<Receiver<GpuBuild>>,
     gpu_failures: Option<gpu_failure::GpuFailureBridge>,
     gpu_failure_applied: Option<bool>,
+    /// Settings ▸ Import ▸ Reload Footage Changed on Disk: the worker that stamps the footage
+    /// files, started with the first project that has items ([`Self::tick_footage_reload`]).
+    footage_watcher: Option<effectcraft_engine::footage_reload::Watcher>,
+    /// The project revision and preference the watched set was last computed for.
+    footage_watch_key: Option<(u64, String)>,
     /// The graphics device was lost and the window is closing (see `close_after_device_loss`);
     /// `true` keeps crash recovery for the next launch.
     device_lost_close: Option<bool>,
     /// Answers of file dialogs shown without blocking ([`Hooks::file_dialog_async`]).
     pub(crate) dialog_answers: (Sender<DialogAnswer>, Receiver<DialogAnswer>),
+    /// Those dialogs that are up, for blocking floating panels' OS windows meanwhile.
+    pub(crate) file_dialogs: FileDialogsUp,
     /// Commands from the native menu bar.
     pub command_inbox: Option<Receiver<String>>,
     /// Pointer position in comp pixels (Info panel).
@@ -505,6 +366,13 @@ pub struct EffectcraftApp {
     /// Docked groups laid out last frame: (active panel, group rect) — `~` maximizes the one
     /// under the pointer.
     pub(crate) dock_rects: Vec<(PanelKind, egui::Rect)>,
+    /// The floating panels' OS windows that drew a panel last frame; one that is gone releases
+    /// its IME state.
+    pub(crate) native_viewports: Vec<egui::ViewportId>,
+    /// The native windows that drew a panel last frame without publishing their IME descriptor.
+    pub(crate) unpublished_viewports: Vec<egui::ViewportId>,
+    /// A floating panel shown by a command: its window comes to the front next frame.
+    pub(crate) pending_panel_raise: Option<PanelKind>,
     /// Home screen: recent-project thumbnail textures by path (None = no thumbnail).
     pub(crate) home_thumbs: std::collections::HashMap<String, Option<egui::TextureHandle>>,
     /// The (project path, saved revision) whose thumbnail was stored last.
@@ -520,2134 +388,64 @@ pub struct EffectcraftApp {
 /// The saved workspaces in the settings store ([`effectcraft_engine::config::ConfigStore`]).
 pub const WORKSPACES_FILE: &str = "workspaces.json";
 
-#[derive(serde::Serialize, serde::Deserialize)]
-struct SavedWorkspaces {
-    #[serde(default)]
-    workspaces: std::collections::BTreeMap<String, dock::DockNode>,
-    #[serde(default)]
-    floating: std::collections::BTreeMap<String, Vec<dock::Floating>>,
+/// Non-blocking file dialogs ([`Hooks::file_dialog_async`]) that are up. While one is, the dock
+/// area blocks floating panels' OS windows, as it does for a modal dialog; otherwise craft-ui
+/// takes the app for inactive while the dialog has the keyboard, and hides floating palettes.
+///
+/// A dialog can end without answering: on macOS a sheet whose window goes away ends without its
+/// completion handler. A dialog is taken for gone, so floating windows never stay blocked, once
+/// one of the app's windows has the keyboard again after none had it, or when one has kept it
+/// for [`FileDialogsUp::UNSEEN`] since the dialog was asked for, so the dialog never showed.
+#[derive(Default)]
+pub(crate) struct FileDialogsUp {
+    count: usize,
+    /// When the oldest dialog up was first checked ([`FileDialogsUp::up`]).
+    since: Option<f64>,
+    /// None of the app's windows had the keyboard since then.
+    left: bool,
 }
 
-/// The comp frames a playback pass covers (`first..=last`).
-#[derive(Clone, Copy, Debug)]
-struct FrameWindow {
-    first: i64,
-    last: i64,
-}
+impl FileDialogsUp {
+    /// Seconds a dialog has to take the keyboard from the app's windows. The desktop portal can
+    /// take a moment to show the first dialog on Linux.
+    const UNSEEN: f64 = 2.0;
 
-/// The inputs of one playback pass: the viewer series it renders, the preview plan and
-/// position, and the frame range and clock settings its steps share. `queued` is a snapshot of
-/// the in-flight render count that each step copies. Built once in `advance_playback`.
-#[derive(Clone, Copy)]
-struct PlaybackPass<'a> {
-    ctx: &'a egui::Context,
-    comp: &'a effectcraft_engine::project::Comp,
-    cid: ItemId,
-    scale: f64,
-    now: f64,
-    frame_rate: effectcraft_engine::time::FrameRate,
-    series: FrameKey,
-    plan: Option<effectcraft_engine::preview::PreviewPlan>,
-    window: FrameWindow,
-    cur: i64,
-    video: bool,
-    looping: bool,
-    ahead: i64,
-    queued: usize,
-}
-
-impl EffectcraftApp {
-    pub fn new(session: Session) -> Self {
-        let mut ui = UiState::default();
-        let workspace_store = workspace_state::WorkspaceStore::load(session.config.as_deref(), &mut ui);
-        EffectcraftApp {
-            session,
-            ui,
-            workspace_store,
-            tokens: Tokens::for_kind(Default::default()),
-            auto: Default::default(),
-            frames: Frames::default(),
-            playback: Playback::default(),
-            dialog: None,
-            hooks: Hooks::default(),
-            fps: 60.0,
-            clock: AppClock::default(),
-            now: 0.0,
-            last_time: 0.0,
-            styled: false,
-            fonts_ready: false,
-            styled_language: "",
-            focused: true,
-            input_active: false,
-            last_pointer_down: false,
-            draw_geom: None,
-            geometry_epoch: 0,
-            ime_tracker: egui::ImeContextTracker::new(),
-            ui_pass_seq: 0,
-            want_paint: false,
-            synthetic_in_flight: false,
-            synthetic_in_flight_events: vec![],
-            last_viewer_scale: None,
-            control_rx: None,
-            deferred: vec![],
-            synthetic: vec![],
-            input_waiters: vec![],
-            job_waiters: vec![],
-            pending_screenshots: vec![],
-            shot_bytes: 0,
-            last_activity: (0.0, 0),
-            last_edit: (0.0, 0),
-            toast: None,
-            viewer_tex: None,
-            passive_tex: std::collections::HashMap::new(),
-            viewer_native: None,
-            viewer_shown: None,
-            viewer_image: None,
-            viewer_readback: Default::default(),
-            wgpu: None,
-            gpu: None,
-            gpu_checked: false,
-            gpu_failures: None,
-            gpu_failure_applied: None,
-            device_lost_close: None,
-            dialog_answers: std::sync::mpsc::channel(),
-            command_inbox: None,
-            pointer_comp: None,
-            dialog_state: Default::default(),
-            integrated_titlebar: false,
-            audio: None,
-            scrub: None,
-            meter: Default::default(),
-            expression_diagnostics: Default::default(),
-            waveforms: Default::default(),
-            last_reveal: None,
-            applied_prefs: None,
-            recovery: None,
-            dock_rects: vec![],
-            home_thumbs: Default::default(),
-            home_thumb_saved: None,
-            window_title: String::new(),
-            template_thumbs: Default::default(),
-            template_list: None,
-            updates_rt: updates_ui::Runtime::default(),
+    pub(crate) fn opened(&mut self) {
+        if self.count == 0 {
+            *self = Self::default();
         }
-        .with_ui_commands()
+        self.count = self.count.saturating_add(1);
     }
 
-    /// Keep the saved workspaces for the next session (see [`EffectcraftApp::new`]): After
-    /// Effects' saved workspaces last until they are deleted (#320). `Err` when they weren't
-    /// written (#696): the change applies for this session and a later save retries it, but until
-    /// then a restart brings back what is on disk.
-    pub(crate) fn store_saved_workspaces(&mut self) -> Result<(), String> {
-        let Err(error) = self.workspace_store.save_now(self.session.config.as_deref(), &self.ui) else { return Ok(()) };
-        let message = format!("Workspace changes couldn't be saved and may be lost after a restart: {error}");
-        log::warn!("{message}");
-        self.ui.status = message.clone();
-        // The raw error, so the background retry doesn't report the same failure again.
-        self.workspace_store.error = Some(error);
-        Err(message)
+    pub(crate) fn answered(&mut self) {
+        self.count = self.count.saturating_sub(1);
     }
 
-    /// Offer the frontend's commands (tools, timeline navigation…) for keyboard shortcuts.
-    fn with_ui_commands(mut self) -> Self {
-        let cmds = menus::UI_COMMANDS
-            .iter()
-            .map(|c| effectcraft_engine::shortcuts::UiCommand { id: c.id.into(), label: c.label.into(), shortcut: c.shortcut.map(str::to_string) })
-            .collect();
-        self.session.set_ui_commands(cmds);
-        self
-    }
-
-    /// Show the crash-recovery dialog for a previous run that didn't exit cleanly.
-    pub fn offer_recovery(&mut self, r: effectcraft_engine::autosave::Recovery) {
-        if r.autosave.is_some() {
-            self.recovery = Some(r);
-            self.dialog = Some(Dialog::Recovery);
-        }
-    }
-
-    /// Apply changed settings: theme and brightness, label colours, tool tips, preview caches.
-    pub fn apply_prefs(&mut self, ctx: &egui::Context) {
-        // Sync with System re-applies when the system appearance changes (the host wakes the UI;
-        // nothing polls).
-        let system = if self.session.prefs.appearance.appearance_mode == "auto" { self.system_light(ctx) } else { None };
-        if self.applied_prefs == Some((self.session.prefs_revision, system)) {
-            return;
-        }
-        self.applied_prefs = Some((self.session.prefs_revision, system));
-        let p = &self.session.prefs;
-        self.ui.theme = theme::ThemeKind::from_name(p.appearance.resolved_theme(system)).unwrap_or_default();
-        self.tokens = Tokens::from_prefs(p, self.ui.theme);
-        theme::apply_visuals(ctx, &self.tokens);
-        ctx.set_theme(theme::theme_preference(&p.appearance.appearance_mode, self.ui.theme.is_light()));
-        let tips = p.general.show_tool_tips;
-        ctx.all_styles_mut(|s| s.interaction.tooltip_delay = if tips { 0.5 } else { f32::INFINITY });
-        // Settings ▸ Appearance ▸ UI Scale (#284). egui's own Ctrl+= / Ctrl+- / Ctrl+0 zoom stays
-        // off: Ctrl+0 is Window ▸ Project, and the scale is a setting.
-        ctx.options_mut(|o| o.zoom_with_keyboard = false);
-        ctx.set_zoom_factor(p.appearance.ui_scale as f32 / 100.0);
-        self.ui.cache_when_idle = p.previews.cache_frames_when_idle;
-        self.ui.viewer.fast_preview = p.previews.fast_previews;
-        self.frames.set_budget(p.cache_budgets(self.session.sys_memory).preview);
-    }
-
-    /// Change settings from the UI (applied next frame and saved).
-    pub fn set_pref(&mut self, key: &str, value: serde_json::Value) -> Result<(), String> {
-        self.session.prefs.set(key, value)?;
-        self.session.prefs_changed();
-        self.session.save_prefs();
-        Ok(())
-    }
-
-    pub fn with_control(mut self, rx: Receiver<ControlRequest>) -> Self {
-        self.control_rx = Some(rx);
-        self
-    }
-
-    /// Show theme `k`: the appearance mode becomes its family's (Dark or Light), and `k` that
-    /// family's theme.
-    pub fn set_theme(&mut self, ctx: &egui::Context, k: theme::ThemeKind) {
-        if let Err(e) = self.set_pref("appearance.theme", json!(k.name())) {
-            self.ui.status = e;
-        }
-        self.apply_prefs(ctx);
-    }
-
-    /// The system appearance: light (`Some(true)`), dark, or unknown. The host's answer (the Linux
-    /// desktop portal) wins over egui's, which Wayland compositors often leave empty.
-    pub fn system_light(&self, ctx: &egui::Context) -> Option<bool> {
-        self.hooks.system_theme.as_ref().and_then(|read| read(ctx)).or_else(|| ctx.system_theme()).map(|t| t == egui::Theme::Light)
-    }
-
-    /// The Tools bar's appearance button (`view.theme.toggle`): Sync with System, then Light, then
-    /// Dark, then Sync with System again. The light and dark theme choices are kept.
-    pub fn cycle_appearance(&mut self, ctx: &egui::Context) {
-        let next = match self.session.prefs.appearance.appearance_mode.as_str() {
-            "auto" => "light",
-            "light" => "dark",
-            _ => "auto",
-        };
-        if let Err(e) = self.set_pref("appearance.appearanceMode", json!(next)) {
-            self.ui.status = e;
-        }
-        self.apply_prefs(ctx);
-    }
-
-    pub fn set_workspace(&mut self, name: &str) {
-        // Learn: the Home screen's Learn tab (tutorials) in the Composition panel. Leaving it for
-        // another workspace closes the Home screen again: it stayed over every workspace until a
-        // project was created (#272).
-        if name == "Learn" {
-            self.ui.start_screen = true;
-            self.ui.home_learn = true;
-            self.ui.home_templates = false;
-        } else if self.ui.workspace == "Learn" {
-            self.ui.start_screen = false;
-            self.ui.home_learn = false;
-        }
-        self.ui.workspace = name.to_string();
-        self.ui.dock = self.ui.saved_workspaces.get(name).cloned().unwrap_or_else(|| dock::workspace(name));
-        self.ui.floating = self.ui.saved_floating.get(name).cloned().unwrap_or_else(|| dock::workspace_floating(name));
-        self.ui.maximized = None;
-    }
-
-    /// Built-in workspaces followed by the saved ones (Window ▸ Workspace ▸ Save as New Workspace).
-    pub fn workspace_names(&self) -> Vec<String> {
-        let mut v: Vec<String> = dock::WORKSPACES.iter().map(|s| s.to_string()).collect();
-        v.extend(self.saved_workspace_names());
-        v
-    }
-
-    /// The workspaces the user saved under a new name (built-ins whose changes were saved are
-    /// not repeated), in name order.
-    pub fn saved_workspace_names(&self) -> Vec<String> {
-        self.ui.saved_workspaces.keys().filter(|k| !dock::WORKSPACES.contains(&k.as_str())).cloned().collect()
-    }
-
-    /// The open Gradient Editor's draft (`panels::gradient_editor`): what OK would set.
-    pub fn gradient_draft(&self) -> &panels::gradient_editor::Draft {
-        &self.dialog_state.gradient
-    }
-
-    /// The open Gradient Editor's draft, to edit (tests and automation; the editor's own fields
-    /// do the same).
-    pub fn gradient_draft_mut(&mut self) -> &mut panels::gradient_editor::Draft {
-        &mut self.dialog_state.gradient
-    }
-
-    /// Feed this frame's share of the queued synthetic input (control channel `ui.click`,
-    /// `ui.drag`…) into `raw_input`. Pointer events go one per frame so egui sees press → moves
-    /// → release as a real gesture.
-    ///
-    /// Only one batch is ever moved out at a time, even when the host prepares several hidden
-    /// logic-only iterations before the forced UI pass: eframe keeps the last prepared raw input
-    /// and would otherwise apply a whole drag or click as one burst. A batch is released by the
-    /// first UI pass that applies it ([`Self::mark_synthetic_applied`]). Callers must not feed a
-    /// pass that cannot draw (fonts still installing): egui applies what it receives, so putting
-    /// an applied batch back would apply its pointer/key state twice.
-    pub fn feed_synthetic(&mut self, raw_input: &mut egui::RawInput) {
-        if self.synthetic_in_flight || self.synthetic.is_empty() {
-            return;
-        }
-        // Pointer events go one per frame so egui sees press → moves → release as a real drag.
-        let pointer = |e: &egui::Event| matches!(e, egui::Event::PointerMoved(_) | egui::Event::PointerButton { .. } | egui::Event::MouseWheel { .. });
-        let n = if pointer(&self.synthetic[0]) {
-            1
-        } else {
-            self.synthetic
-                .iter()
-                .position(|e| pointer(e) || matches!(e, egui::Event::Key { pressed: false, .. }))
-                .map_or(self.synthetic.len(), |i| if pointer(&self.synthetic[i]) { i.max(1) } else { i + 1 })
-        };
-        let batch: Vec<egui::Event> = self.synthetic.drain(..n).collect();
-        raw_input.events.extend(batch.iter().cloned());
-        self.synthetic_in_flight_events.extend(batch);
-        self.synthetic_in_flight = true;
-    }
-
-    /// Clear the single-pending-batch guard: a UI pass has applied the injected batch.
-    ///
-    /// [`EffectcraftApp::draw`] calls this itself; harnesses that feed synthetic input
-    /// themselves (the headless kittest tests) call it after each pass they ran.
-    pub fn mark_synthetic_applied(&mut self) {
-        self.synthetic_in_flight_events.clear();
-        self.synthetic_in_flight = false;
-    }
-
-    /// The events of the injected batch that no UI pass has applied yet.
-    pub fn pending_synthetic_events(&self) -> &[egui::Event] {
-        &self.synthetic_in_flight_events
-    }
-
-    /// Whether a synthetic batch is waiting for its UI pass.
-    pub fn synthetic_in_flight(&self) -> bool {
-        self.synthetic_in_flight
-    }
-
-    /// The app clock's value at the last tick.
-    pub fn now(&self) -> f64 {
-        self.now
-    }
-
-    /// The clock itself (tests advance a manual clock).
-    pub fn clock_mut(&mut self) -> &mut AppClock {
-        &mut self.clock
-    }
-
-    /// Use a test-driven clock from now on.
-    pub fn use_manual_clock(&mut self) {
-        self.clock = AppClock::manual();
-        self.now = 0.0;
-    }
-
-    /// Completed, non-discarded UI passes since launch.
-    pub fn ui_passes(&self) -> u64 {
-        self.ui_pass_seq
-    }
-
-    /// The geometry of the last completed UI pass, if one ran.
-    pub fn draw_geometry(&self) -> Option<DrawGeometry> {
-        self.draw_geom
-    }
-
-    /// Show panel `p` (opening it in its usual place if it is closed), bring it to the front and
-    /// give it the focus: Window ▸ <panel>.
-    pub fn show_panel(&mut self, p: PanelKind) {
-        if !self.ui.floating.iter().any(|f| f.panels.contains(&p)) && self.ui.maximized.is_some_and(|m| m != p) {
-            self.ui.maximized = None;
-        }
-        self.raise_panel(p);
-        self.ui.focused = p;
-    }
-
-    /// Bring panel `p` to the front of its group, opening it in its usual place if it is closed,
-    /// without moving the focus (a comp opening brings up its viewer, an effect applied brings up
-    /// Effect Controls).
-    pub fn raise_panel(&mut self, p: PanelKind) {
-        if self.ui.floating.iter().any(|group| group.panels.contains(&p)) {
-            self.edit_layout(|layout| layout.apply(craft_ui::docking::Action::Activate { panel: p }).is_ok());
-            return;
-        }
-        if !self.ui.dock.contains(p) {
-            // The Composition panel lives in the centre, with the Layer panel and other viewers;
-            // with none of those left, above the Timeline.
-            let centre = |d: &dock::DockNode| {
-                let mut v = Vec::new();
-                d.panels(&mut v);
-                v.into_iter().find(|q| matches!(q, PanelKind::Layer | PanelKind::Viewer(_) | PanelKind::Flowchart | PanelKind::Footage))
-            };
-            let near = match p {
-                PanelKind::Composition => match centre(&self.ui.dock) {
-                    Some(q) => q,
-                    None if self.ui.dock.dock_panel(p, PanelKind::Timeline, dock::Zone::Top) => {
-                        self.ui.dock.activate(p);
-                        return;
-                    }
-                    None => PanelKind::EffectsPresets,
-                },
-                PanelKind::Layer | PanelKind::Flowchart | PanelKind::Viewer(_) => PanelKind::Composition,
-                PanelKind::RenderQueue => PanelKind::Timeline,
-                PanelKind::EffectControls | PanelKind::History => PanelKind::Project,
-                _ => PanelKind::EffectsPresets,
-            };
-            self.ui.dock.open_near(p, near);
-        }
-        self.ui.dock.activate(p);
-    }
-
-    pub fn render_source(&self) -> RenderSource {
-        RenderSource {
-            project: self.session.project.clone(),
-            footage: self.session.footage.clone(),
-            expr: self.session.expr.clone(),
-            layer_cache: self.session.layer_cache.clone(),
-            gpu: self.gpu.clone(),
-            gpu_display: self.gpu_display(),
-            disk: self.session.disk_cache.clone(),
-        }
-    }
-
-    /// Keep GPU-composited viewer frames on the GPU (drawn from their texture). The browser can't
-    /// read frames back (its thread can't wait for the GPU), so there the viewer shows GPU frames
-    /// directly whenever it draws them plainly (RGB, no exposure, no region of interest); the
-    /// desktop reads them back (see [`frames::RenderSource::gpu_display`]).
-    fn gpu_display(&self) -> bool {
-        let v = &self.session.state.viewer;
-        cfg!(target_arch = "wasm32")
-            && v.channel == effectcraft_engine::viewer::Channel::Rgb
-            && v.exposure == 0.0
-            && self.session.state.region_of_interest.is_none()
-            && self.ui.viewer.extended.is_none()
-    }
-
-    /// The UI draws its panels and handles input such as dropped files. Until the fonts are
-    /// installed (the first frames) it draws nothing, and that input goes unhandled.
-    pub fn is_ready(&self) -> bool {
-        self.fonts_ready
-    }
-
-    /// Provide the executable/embedding host's device notifications. The host installs the
-    /// handlers once; this frontend never replaces handlers on a borrowed device.
-    pub fn set_gpu_failure_bridge(&mut self, bridge: gpu_failure::GpuFailureBridge) {
-        if let Some(gpu) = &self.gpu {
-            bridge.forward_to(gpu.context().device_failure_notifier());
-        }
-        self.gpu_failures = Some(bridge);
-    }
-
-    fn apply_gpu_failure(&mut self, ctx: &egui::Context) {
-        let Some(bridge) = &self.gpu_failures else { return };
-        // Readback deadlines can retire the compositor without a host device notification.
-        if let Some(gpu) = &self.gpu
-            && let Err(reason) = gpu.context().check_health()
-        {
-            bridge.report(&reason, false);
-        }
-        let Some(failure) = bridge.failure() else { return };
-        if self.gpu_failure_applied == Some(failure.presentation_lost) {
-            return;
-        }
-        self.gpu_failure_applied = Some(failure.presentation_lost);
-        self.gpu_checked = true;
-        self.frames.retire_gpu();
-        self.session.accel = None;
-        self.session.accel_note = Some(format!("GPU preview retired: {}", failure.reason));
-        self.session.layer_cache.clear();
-        self.gpu = None;
-        if let Some(rs) = &self.wgpu {
-            let mut renderer = rs.renderer.write();
-            if let Some((id, _, _)) = &self.viewer_native {
-                renderer.free_texture(id);
-            }
-            for (_, texture) in self.passive_tex.values() {
-                if let panels::viewers::PassiveTexture::Gpu(id, _) = texture {
-                    renderer.free_texture(id);
-                }
-            }
-        }
-        self.viewer_native = None;
-        self.passive_tex.retain(|_, (_, texture)| matches!(texture, panels::viewers::PassiveTexture::Cpu(_)));
-        self.viewer_shown = self.viewer_tex.as_ref().map(|(texture, key, _)| (texture.id(), *key));
-        self.viewer_image = None;
-        // Old completion closures retain only their detached slot, not the replacement.
-        self.viewer_readback = Default::default();
-        self.wgpu = None;
-        self.ui.status = if failure.presentation_lost {
-            "Graphics device lost. The project is still open; presentation requires restarting the application.".into()
-        } else {
-            "Shared GPU preview disabled; CPU compositing remains available.".into()
-        };
-        log::warn!("GPU preview retired: {}", failure.reason);
-        ctx.request_repaint();
-    }
-
-    /// After the graphics device is lost, eframe's renderer cannot draw again: any mesh makes
-    /// egui-wgpu panic on the main thread when it cannot stage its index buffer (#591). Draw
-    /// nothing from then on, auto-save a project with unsaved changes (keeping the crash
-    /// recovery marker, so the next launch offers it) and close the window.
-    fn close_after_device_loss(&mut self, ctx: &egui::Context) {
-        if self.device_lost_close.is_some() {
-            return;
-        }
-        let keep_recovery = self.session.is_dirty();
-        let saved = keep_recovery.then(|| match self.session.autosave_now().and_then(|path| self.session.autosave_wait().map(|()| path)) {
-            Ok(path) => {
-                log::warn!("graphics device lost: auto-saved {path}; the next launch offers to recover it");
-                Ok(path)
-            }
-            Err(e) => {
-                log::error!("graphics device lost: {e}");
-                Err(e.to_string())
-            }
-        });
-        self.device_lost_close = Some(keep_recovery);
-        log::warn!("graphics device lost: closing the window");
-        if let Some(tell) = &self.hooks.device_lost {
-            tell(saved);
-        }
-        ctx.send_viewport_cmd(egui::ViewportCommand::Close);
-    }
-
-    /// Run the commands whose non-blocking file dialogs have been answered.
-    pub(crate) fn run_dialog_answers(&mut self) {
-        while let Ok(answer) = self.dialog_answers.1.try_recv() {
-            menus::dialog_answered(self, answer);
-        }
-    }
-
-    /// Set up the GPU compositor on egui-wgpu's device (once). Without an adapter that runs
-    /// compute shaders (WebGL2, software GL) everything stays on the CPU.
-    pub(crate) fn init_gpu(&mut self, frame: &eframe::Frame) {
-        if self.gpu_checked {
-            return;
-        }
-        self.gpu_checked = true;
-        if self.gpu_failures.as_ref().is_some_and(|bridge| bridge.failure().is_some()) {
-            return;
-        }
-        let Some(rs) = frame.wgpu_render_state() else { return };
-        // Help ▸ System Compatibility Report names the adapter and backend the window got.
-        let info = rs.adapter.get_info();
-        self.session.window_adapter = Some(format!(
-            "{} ({:?}, {:?}{})",
-            info.name,
-            info.backend,
-            info.device_type,
-            if info.driver.is_empty() { String::new() } else { format!(", {} {}", info.driver, info.driver_info) }
-        ));
-        // Backend validation can panic on shader compilation even when device creation
-        // succeeded. Keep the document and the egui renderer, and use CPU compositing.
-        let gpu = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| effectcraft_gpu::Gpu::new(&rs.adapter, rs.device.clone(), rs.queue.clone())));
-        match gpu {
-            Ok(Ok(g)) => {
-                if let Some(bridge) = &self.gpu_failures {
-                    bridge.forward_to(g.context().device_failure_notifier());
-                    if bridge.failure().is_some() {
-                        return;
-                    }
-                }
-                log::info!("GPU compositor: {}", effectcraft_engine::render::Accelerator::name(&g));
-                self.session.accel = Some(Arc::new(g.clone()));
-                self.gpu = Some(g);
-                self.wgpu = Some(rs.clone());
-            }
-            Ok(Err(e)) => {
-                log::info!("GPU compositor unavailable: {e}");
-                self.session.accel_note = Some(format!("GPU compositor unavailable: {e}"));
-            }
-            Err(e) => {
-                let reason = e.downcast_ref::<String>().map(String::as_str).or_else(|| e.downcast_ref::<&str>().copied()).unwrap_or("backend panicked");
-                log::warn!("GPU compositor setup failed; using CPU compositing: {reason}");
-                self.session.accel_note = Some(format!("GPU compositor setup failed: {reason}"));
-            }
-        }
-    }
-
-    /// The viewer shows a frame composited on the GPU (drawn from its wgpu texture).
-    pub fn viewer_on_gpu(&self) -> bool {
-        matches!((&self.viewer_shown, &self.viewer_native), (Some(s), Some(n)) if s.1 == n.1)
-    }
-
-    /// The GPU compositor's adapter, when the viewer has one.
-    pub fn gpu_adapter(&self) -> Option<String> {
-        self.gpu.as_ref().map(effectcraft_engine::render::Accelerator::name)
-    }
-
-    /// The size of the viewer frame's texture (CPU frames; fitted to the GPU's texture limit).
-    pub fn viewer_texture_size(&self) -> Option<[usize; 2]> {
-        self.viewer_tex.as_ref().map(|(t, _, _)| t.size())
-    }
-
-    /// The viewer's current pixels as 8-bit premultiplied RGBA, reading a GPU frame back the
-    /// first time something asks for it.
-    ///
-    /// The browser can't wait for the GPU: there the first call starts an asynchronous readback
-    /// and returns `None`; a later call (the next frame) has the pixels.
-    pub fn viewer_pixels(&mut self) -> Option<Arc<egui::ColorImage>> {
-        let to_image = |bytes: Vec<u8>, w: u32, h: u32| {
-            let px = bytes.as_chunks::<4>().0.iter().map(|c| egui::Color32::from_rgba_premultiplied(c[0], c[1], c[2], c[3])).collect();
-            Arc::new(egui::ColorImage::new([w as usize, h as usize], px))
-        };
-        if self.viewer_image.is_none()
-            && let (Some((_, key, f)), Some(g)) = (&self.viewer_native, &self.gpu)
-            && self.viewer_shown.as_ref().map(|s| s.1) == Some(*key)
-        {
-            if cfg!(target_arch = "wasm32") {
-                let ready = self.viewer_readback.1.lock().ok().and_then(|mut r| r.take_if(|r| r.0 == *key));
-                if let Some((_, img)) = ready {
-                    self.viewer_image = Some(img);
-                } else if self.viewer_readback.0 != Some(*key) {
-                    self.viewer_readback.0 = Some(*key);
-                    let (slot, k, (w, h)) = (self.viewer_readback.1.clone(), *key, (f.width, f.height));
-                    let ctx = self.frames.context();
-                    g.read_display_async(f, move |bytes| {
-                        if let (Some(b), Ok(mut s)) = (bytes, slot.lock()) {
-                            *s = Some((k, to_image(b, w, h)));
-                        }
-                        if let Some(c) = ctx {
-                            c.request_repaint();
-                        }
-                    });
-                }
-            } else if let Some(bytes) = g.read_display(f) {
-                self.viewer_image = Some(to_image(bytes, f.width, f.height));
-            }
-        }
-        self.viewer_image.clone()
-    }
-
-    /// The viewer's Resolution: the active composition's (saved with the project).
-    pub fn viewer_res(&self) -> state::Resolution {
-        self.session.active_comp().map(|c| c.resolution).unwrap_or_default()
-    }
-
-    /// The render scale used by the viewer right now.
-    pub fn viewer_scale(&self, zoom: f32, ppp: f32) -> f64 {
-        // The preview's Resolution (when not Auto) while it plays.
-        if self.playback.playing
-            && let Some(f) = self.playback.res
-        {
-            return state::Resolution::from_factor(f.into()).scale(zoom, ppp);
-        }
-        // Auto follows the zoom alike while playing and paused, so frames cached while scrubbing
-        // play back, and frames cached by a preview stay on screen when it stops.
-        let res = self.viewer_res();
-        let full = res.scale(zoom, ppp);
-        // Fast Previews ▸ Adaptive Resolution / Fast Draft: lower resolution while dragging.
-        let (_, k) = self.session.state.viewer.fast_previews.render(self.ui.viewer.interacting || self.ui.viewer.property_interacting);
-        if k < 1.0 && res.is_auto() {
-            return full.min((full * 0.5).max(self.session.prefs.adaptive_limit()));
-        }
-        full
-    }
-
-    /// The cache key of viewer frame `frame` of `comp` at `scale` (see [`Self::frame_series`]).
-    pub fn frame_key(&self, comp: ItemId, frame: i64, scale: f64) -> FrameKey {
-        FrameKey { frame, ..self.frame_series(comp, scale) }
-    }
-
-    /// The key of frame 0 of `comp`'s viewer frames at `scale` (the content, view and render
-    /// options are the same for every frame: loops compute this once).
-    pub fn frame_series(&self, comp: ItemId, scale: f64) -> FrameKey {
-        FrameKey {
-            revision: self.session.revision,
-            content: self.frames.content_of(&self.session.project, self.session.revision, comp),
-            comp: comp.0,
-            frame: 0,
-            scale: (scale * 1000.0).round() as u32,
-            view: self.view_hash(comp),
-            opts: frames::opts_hash(&self.frame_opts(comp, scale)),
-        }
-    }
-
-    /// The frame series the viewer of `comp` shows now (its scale, view and options, for the
-    /// comp's current content): what the cache bars count.
-    pub fn shown_series(&self, comp: ItemId) -> FrameKey {
-        let scale = self.viewer_shown.as_ref().filter(|(_, k)| k.comp == comp.0).map_or(1000, |(_, k)| k.scale);
-        self.frame_series(comp, scale as f64 / 1000.0)
-    }
-
-    /// Hash of the comp viewer's 3D view camera (0 for the active camera view).
-    pub fn view_hash(&self, comp: ItemId) -> u64 {
-        use std::hash::{Hash, Hasher};
-        let mut h = std::collections::hash_map::DefaultHasher::new();
-        // The region of interest changes what is rendered too.
-        let roi = self.viewer_region(comp);
-        if let Some(r) = roi {
-            r.map(f64::to_bits).hash(&mut h);
-        }
-        let Some(cam) = self.session.view_camera(comp) else { return if roi.is_some() { h.finish() | 1 } else { 0 } };
-        for row in cam.view.0 {
-            for v in row {
-                v.to_bits().hash(&mut h);
-            }
-        }
-        cam.zoom.to_bits().hash(&mut h);
-        cam.ortho.hash(&mut h);
-        h.finish() | 1
-    }
-
-    /// The comp-space region viewer frames of `comp` cover: the region of interest, else the
-    /// Extended Viewer's area (frame plus pasteboard), else `None` (the whole frame).
-    pub fn viewer_region(&self, comp: ItemId) -> Option<[f64; 4]> {
-        if self.session.active_comp_id() != Some(comp) {
-            return None;
-        }
-        self.session.state.region_of_interest.or(self.ui.viewer.extended)
-    }
-
-    /// Request a prefetch frame render (no-op if cached/in flight).
-    pub fn request_frame(&self, comp: ItemId, frame: i64, scale: f64) {
-        self.request_frame_with(comp, frame, scale, false);
-    }
-
-    /// Request the frame on screen: rendered before any queued prefetch.
-    pub fn request_frame_urgent(&self, comp: ItemId, frame: i64, scale: f64) {
-        self.request_frame_with(comp, frame, scale, true);
-    }
-
-    /// Render options of viewer frames of `comp` at `scale`.
-    pub fn frame_opts(&self, comp: ItemId, scale: f64) -> RenderOpts {
-        let (draft, _) = self.session.state.viewer.fast_previews.render(self.ui.viewer.interacting || self.ui.viewer.property_interacting);
-        let roi = self.viewer_region(comp);
-        RenderOpts {
-            scale,
-            motion_blur: true,
-            guides: true,
-            draft: self.ui.viewer.fast_preview || draft,
-            view: self.session.view_camera(comp),
-            roi,
-            backend: effectcraft_engine::render::Backend::Auto,
-            nested_switches: self.session.prefs.general.switches_affect_nested_comps,
-            draft_shadows: self.session.prefs.three_d.realtime_shadows,
-            proxy: Default::default(),
-        }
-    }
-
-    fn request_frame_with(&self, comp: ItemId, frame: i64, scale: f64, urgent: bool) {
-        let Some(c) = self.session.project.comp(comp) else { return };
-        let key = self.frame_key(comp, frame, scale);
-        let t = c.frame_rate.tick_of(frame);
-        let opts = self.frame_opts(comp, scale);
-        if urgent {
-            self.frames.request_urgent(&self.render_source(), key, comp, t, opts);
-        } else {
-            self.frames.request(&self.render_source(), key, comp, t, opts);
-        }
-    }
-
-    // ---------------------------------------------------------------- playback
-
-    pub fn play(&mut self, now: f64) {
-        let sc = self.session.prefs.preview.current;
-        self.play_with(now, sc);
-    }
-
-    /// Start the preview of a Preview panel shortcut (its range, play-from, rate, skip,
-    /// resolution, loop, caching, full screen and include options).
-    pub fn play_with(&mut self, now: f64, sc: effectcraft_engine::preview::PreviewShortcut) {
-        let Some(c) = self.session.active_comp_arc() else { return };
-        let preset = self.session.prefs.preview.get(sc).clone();
-        let plan = effectcraft_engine::preview::plan(&preset, &c, self.session.time());
-        let fr = c.frame_rate;
-        if plan.video {
-            self.session.set_time(fr.tick_of(plan.first));
-        }
-        let restore_max = preset.full_screen.then_some(self.ui.maximized);
-        let viewer = panels::viewers::active_panel(self);
-        if preset.full_screen && self.ui.dock.contains(viewer) {
-            self.ui.maximized = Some(viewer);
-        }
-        self.playback = Playback {
-            playing: true,
-            start_wall: now,
-            start_time: fr.tick_of(plan.first),
-            start_frame: plan.first,
-            shown: 0,
-            waiting: false,
-            fps: plan.fps,
-            shortcut: sc,
-            plan: Some(plan),
-            caching: plan.cache_first && plan.video,
-            res: preset.resolution.factor(preset.custom_resolution),
-            overlays: preset.include_overlays,
-            layer_controls: preset.include_layer_controls,
-            restore_max,
-            audio_frame: (!plan.video).then_some(plan.first),
-            audio_held: false,
-            shown_at: Default::default(),
-        };
-        if !self.playback.caching {
-            if plan.video {
-                self.playback.audio_held = self.audio_plays();
-            } else {
-                self.start_audio(fr.tick_of(plan.first));
-            }
-        }
-    }
-
-    /// The preview includes audio at the comp's frame rate and the comp has something audible.
-    fn audio_plays(&self) -> bool {
-        let (Some(pl), Some(cid)) = (self.playback.plan, self.session.active_comp_id()) else { return false };
-        let Some(c) = self.session.project.comp(cid) else { return false };
-        // A preview at another frame rate plays slower or faster than real time: silent.
-        pl.audio && (pl.fps - c.frame_rate.as_f64()).abs() <= 0.01 && effectcraft_engine::render::audio::comp_has_audio(&self.session.project, cid)
-    }
-
-    /// Start audio preview from comp time `t` when [`Self::audio_plays`] and an output device
-    /// opens.
-    fn start_audio(&mut self, t: Tick) {
-        self.audio = None;
-        self.meter.clipped = [false; 2];
-        let (Some(pl), Some(cid)) = (self.playback.plan, self.session.active_comp_id()) else { return };
-        let Some(c) = self.session.project.comp_arc(cid).filter(|_| self.audio_plays()) else { return };
-        let out = audio::AudioOutput::from_prefs(&self.session.prefs);
-        let Some(dev) = self.hooks.audio_device.as_ref().and_then(|f| f(&out)) else { return };
-        let mix = self.session.prefs.audio.preview_sample_rate;
-        let fr = c.frame_rate;
-        match audio::AudioPlayback::start(dev, self.render_source(), cid, t, fr.tick_of(pl.start), fr.tick_of(pl.end + 1), pl.looping, mix) {
-            Ok(a) => self.audio = Some(a),
-            Err(e) => log::warn!("audio preview: {e}"),
-        }
-    }
-
-    /// Audio scrubbing: play the frame of `comp` at `t` (see [`audio::AudioScrub`]), opening the
-    /// output on first use. Silent comps and missing devices do nothing.
-    pub fn scrub_audio(&mut self, comp: ItemId, t: Tick, now: f64) {
-        if self.playback.playing || !effectcraft_engine::render::audio::comp_has_audio(&self.session.project, comp) {
-            return;
-        }
-        if self.scrub.is_none() {
-            let out = audio::AudioOutput::from_prefs(&self.session.prefs);
-            let Some(dev) = self.hooks.audio_device.as_ref().and_then(|f| f(&out)) else { return };
-            match audio::AudioScrub::open(dev, now) {
-                Ok(s) => self.scrub = Some(s),
-                Err(e) => {
-                    log::warn!("audio scrubbing: {e}");
-                    return;
-                }
-            }
-        }
-        let src = self.render_source();
-        let mix = self.session.prefs.audio.preview_sample_rate;
-        if let Some(s) = &mut self.scrub {
-            s.play(&src, comp, t, mix, now);
-        }
-    }
-
-    pub fn stop(&mut self) {
-        let was = std::mem::replace(&mut self.playback.playing, false);
-        self.audio = None;
-        self.playback.caching = false;
-        if !was {
-            return;
-        }
-        if let Some(m) = self.playback.restore_max.take() {
-            self.ui.maximized = m;
-        }
-        let Some(pl) = self.playback.plan else { return };
-        let move_time = self.session.prefs.preview.get(self.playback.shortcut).move_time_to_preview_time;
-        if !move_time {
-            self.session.set_time(pl.origin);
-        } else if let Some(f) = self.playback.audio_frame
-            && let Some(c) = self.session.active_comp()
-        {
-            let t = c.frame_rate.tick_of(f);
-            self.session.set_time(t);
-        }
-    }
-
-    pub fn toggle_play(&mut self, now: f64) {
-        let sc = self.session.prefs.preview.current;
-        self.toggle_play_with(now, sc);
-    }
-
-    /// A preview shortcut pressed: start its preview, or stop the running one. While Cache
-    /// Before Playback is still rendering, "If caching, play cached frames" plays what is
-    /// cached so far instead of stopping.
-    pub fn toggle_play_with(&mut self, now: f64, sc: effectcraft_engine::preview::PreviewShortcut) {
-        if !self.playback.playing {
-            self.play_with(now, sc);
-            return;
-        }
-        if self.playback.caching && self.session.prefs.preview.get(self.playback.shortcut).play_cached_frames && self.play_cached(now) {
-            return;
-        }
-        self.stop();
-    }
-
-    /// Cut the caching preview down to the frames cached from its first frame on and play them.
-    fn play_cached(&mut self, now: f64) -> bool {
-        let (Some(mut pl), Some(cid)) = (self.playback.plan, self.session.active_comp_id()) else { return false };
-        let scale = self.viewer_shown.as_ref().map(|(_, k)| k.scale as f64 / 1000.0).unwrap_or(1.0);
-        let series = self.frame_series(cid, scale);
-        let mut last = None;
-        let mut f = pl.first;
-        while f <= pl.end && self.frames.is_cached(&FrameKey { frame: f, ..series }) {
-            last = Some(f);
-            f += pl.step;
-        }
-        let Some(last) = last else { return false };
-        pl.end = last;
-        pl.start = pl.first;
-        self.playback.plan = Some(pl);
-        self.playback.caching = false;
-        self.playback.start_wall = now;
-        self.playback.start_frame = pl.first;
-        let t = self.session.active_comp().map(|c| c.frame_rate.tick_of(pl.first)).unwrap_or_default();
-        self.start_audio(t);
-        true
-    }
-
-    /// A preview plays with Video off in the Preview panel (audio only): the current time stays
-    /// put, so the viewer and Timeline say so instead of looking stuck (#1118). The frame under
-    /// the audible sample, when one is known.
-    pub fn video_preview_off(&self) -> Option<Option<i64>> {
-        let p = self.playback.plan.filter(|_| self.playback.playing)?;
-        (!p.video).then_some(self.playback.audio_frame)
-    }
-
-    /// The viewer shows grids, guides and safe margins (hidden while a preview without
-    /// Include Overlays plays).
-    pub fn overlays_visible(&self) -> bool {
-        !self.playback.playing || self.playback.overlays
-    }
-
-    /// The viewer shows layer handles and paths (View ▸ Show Layer Controls, and Include Layer
-    /// Controls while a preview plays).
-    pub fn layer_controls_visible(&self) -> bool {
-        self.ui.viewer.show_layer_controls && (!self.playback.playing || self.playback.layer_controls)
-    }
-
-    /// RAM preview: advance at the preview's frame rate when frames are cached; otherwise hold
-    /// and keep rendering ahead (the green cache bar fills, then playback runs in real time).
-    fn advance_playback(&mut self, ctx: &egui::Context, scale: f64, now: f64, input_active: bool, cid: ItemId) {
-        let Some(c) = self.session.project.comp_arc(cid) else { return };
-        let fr = c.frame_rate;
-        let plan = self.playback.plan.filter(|_| self.playback.playing);
-        let (wa, wb) = match plan {
-            Some(p) => (p.start, p.end),
-            None => (fr.frame_at(c.work_area.0), fr.frame_at(c.work_area.1 - c.frame_duration())),
-        };
-        let looping = plan.is_none_or(|p| p.looping);
-        let video = plan.is_none_or(|p| p.video);
-        // Prefetch ahead.
-        let cur = fr.frame_at(self.session.time());
-        let ahead = self.prefetch_ahead(ctx, now);
-        let queued = self.frames.inflight();
-        let series = self.frame_series(cid, scale);
-        // The preview's position orders prefetch and eviction (#595).
-        let playhead = plan.filter(|p| p.video).map(|p| frames::Playhead { series, cur, start: p.start, end: p.end, step: p.step, looping: p.looping });
-        self.frames.set_playhead(playhead);
-        let pass = PlaybackPass {
-            ctx,
-            comp: &c,
-            cid,
-            scale,
-            now,
-            frame_rate: fr,
-            series,
-            plan,
-            window: FrameWindow { first: wa, last: wb },
-            cur,
-            video,
-            looping,
-            ahead,
-            queued,
-        };
-        if self.cache_preview(&pass) {
-            return;
-        }
-        let step = plan.map_or(1, |p| p.step);
-        let fit_ahead = self.frames_that_fit(&c, scale) - 1;
-        self.prefetch_playback(&pass, fit_ahead);
-        self.pump_meters(ctx, now);
-        if !self.playback.playing {
-            self.cache_when_idle(ctx, &c, &series, now, input_active, (wa, wb));
-            return;
-        }
-        let fit = self.frames_that_fit(&c, scale);
-        self.start_held_audio(&pass, fit);
-        if self.advance_audio_clock(&pass, step) {
-            return;
-        }
-        self.advance_frame_clock(&pass, step);
-    }
-
-    /// While paused (scrubbing, editing) the viewer's frame comes first: prefetch only a few
-    /// frames, only once it is done, and not while edits keep coming (a layer dragged in the
-    /// viewer): those frames would be stale at the next step and would hold the CPU and GPU
-    /// the next viewer frame needs.
-    fn prefetch_ahead(&mut self, ctx: &egui::Context, now: f64) -> i64 {
-        if self.playback.playing {
-            (self.frames_parallelism() * 2).max(4) as i64
-        } else if self.frames.urgent_pending() {
-            0
-        } else if let Some(wait) = self.editing(now) {
-            ctx.request_repaint_after(std::time::Duration::from_secs_f64(wait));
-            0
-        } else {
-            // Keep workers available for a newly edited viewer frame. Running obsolete
-            // background renders cannot be preempted by the priority queue.
-            self.frames_parallelism().saturating_sub(1).min(2) as i64
-        }
-    }
-
-    /// Cache Before Playback: the range in play order, then start the clock. A range larger than
-    /// the RAM preview budget is cut to the frames that fit (caching more would evict the first
-    /// ones and never finish). Returns true when this pass handled the preview.
-    fn cache_preview(&mut self, pass: &PlaybackPass<'_>) -> bool {
-        let PlaybackPass { ctx, comp, cid, scale, now, frame_rate: fr, series, plan, ahead, mut queued, .. } = *pass;
-        if !self.playback.caching {
+    /// Whether a dialog is up at `now`, `focused`: whether one of the app's windows has the
+    /// keyboard.
+    pub(crate) fn up(&mut self, focused: bool, now: f64) -> bool {
+        if self.count == 0 {
             return false;
         }
-        let Some(p) = plan else { return false };
-        let mut all = true;
-        let n = (p.end - p.start) / p.step + 1;
-        let fit = self.frames_that_fit(comp, scale);
-        if n > fit {
-            let mut cut = p;
-            (cut.start, cut.end) = (p.first, (p.first + (fit - 1) * p.step).min(p.end));
-            self.playback.plan = Some(cut);
-            self.toast = Some((format!("Preview cut to {fit} of {n} frames: no more fit in the RAM preview (Settings ▸ Memory & CPU)"), now));
-            ctx.request_repaint();
-            return true;
-        }
-        let order: Vec<i64> = (0..n).filter_map(|k| p.frame_after(p.first, k)).collect();
-        for f in order {
-            if self.frames.is_cached(&FrameKey { frame: f, ..series }) {
-                continue;
-            }
-            all = false;
-            if queued < ahead as usize {
-                self.request_frame(cid, f, scale);
-                queued += 1;
-            }
-        }
-        self.playback.waiting = !all;
-        if all {
-            self.playback.caching = false;
-            self.playback.start_wall = now;
-            self.playback.start_frame = p.first;
-            self.session.set_time(fr.tick_of(p.first));
-            self.start_audio(fr.tick_of(p.first));
-        }
-        ctx.request_repaint();
-        true
-    }
-
-    /// Never further ahead than the RAM preview holds: those frames would evict the ones the
-    /// preview shows first, or be evicted before it gets there (#595). The window starts at the
-    /// first uncached frame ahead: after a loop or a restart the frames just ahead are cached,
-    /// and a window from the playhead left the workers idle until it came near the end of the
-    /// cached run. It stays ahead × 3 frames wide: workers spread over the whole preview render
-    /// frames with different layers at once (on the GPU, an atlas each: #1812).
-    fn prefetch_playback(&self, pass: &PlaybackPass<'_>, fit_ahead: i64) {
-        let PlaybackPass { cid, scale, plan, cur, ahead, series, mut queued, video, .. } = *pass;
-        let FrameWindow { first: wa, last: wb } = pass.window;
-        let frame = |k: i64| match plan {
-            Some(p) => p.frame_after(cur, k),
-            None => {
-                let f = cur + k;
-                Some(if f > wb { wa + (f - wb - 1).rem_euclid((wb - wa + 1).max(1)) } else { f })
-            }
-        };
-        let cached = self.frames.cached_frames(&series);
-        let uncached = |f: i64| cached.binary_search(&f).is_err();
-        let first = match plan.filter(|_| self.playback.playing) {
-            Some(p) => (0..fit_ahead.min((p.end - p.start) / p.step.max(1) + 1))
-                .map_while(|k| frame(k).map(|f| (k, f)))
-                .find(|&(_, f)| uncached(f))
-                .map_or(0, |(k, _)| k),
-            None => 0,
-        };
-        for k in first..(first + ahead * 3).min(fit_ahead) {
-            if queued >= ahead as usize || !video {
-                break;
-            }
-            let Some(f) = frame(k) else { break };
-            if uncached(f) {
-                self.request_frame(cid, f, scale);
-                queued += 1;
-            }
-        }
-    }
-
-    fn pump_meters(&mut self, ctx: &egui::Context, now: f64) {
-        if let Some(a) = &mut self.audio {
-            a.pump();
-            self.meter.update(a.feed.take_peaks(), now);
-        } else if let Some(s) = &mut self.scrub {
-            // Scrubbing: the meters follow the snippets; an idle second closes the output.
-            s.pump();
-            self.meter.update(s.feed.take_peaks(), now);
-            if now - s.last_used > 1.0 {
-                self.scrub = None;
-            }
-            ctx.request_repaint_after(std::time::Duration::from_millis(50));
-        } else if self.meter.active() {
-            self.meter.update([0.0; 2], now);
-            ctx.request_repaint();
-        }
-    }
-
-    /// Held sound starts once the frames ahead are cached (see `Playback::audio_held`): the
-    /// prefetch window when the silent preview keeps real time, else the rest of the preview.
-    fn start_held_audio(&mut self, pass: &PlaybackPass<'_>, fit: i64) {
-        let PlaybackPass { now, plan, series, cur, ahead, frame_rate: fr, .. } = *pass;
-        if !self.playback.audio_held {
-            return;
-        }
-        let Some(p) = plan else { return };
-        if (self.playback.keeps_up(now) && self.cached_ahead(&p, &series, cur, ahead.min(fit))) || self.cached_ahead(&p, &series, cur, fit) {
-            self.playback.audio_held = false;
-            self.playback.start_wall = now;
-            self.playback.start_frame = cur;
-            self.start_audio(fr.tick_of(cur));
-        }
-    }
-
-    /// Audio clock drives playback: show the frame under the audible sample. Returns true when
-    /// the audio path handled this pass (including stopping at the end).
-    fn advance_audio_clock(&mut self, pass: &PlaybackPass<'_>, step: i64) -> bool {
-        let PlaybackPass { ctx, now, series, video, frame_rate: fr, cur, .. } = *pass;
-        let FrameWindow { first: wa, last: wb } = pass.window;
-        let Some(a) = &self.audio else { return false };
-        if a.finished() {
-            if video {
-                self.session.set_time(fr.tick_of(wb));
-            } else {
-                self.playback.audio_frame = Some(wb);
-            }
-            self.stop();
-            return true;
-        }
-        let snap = |f: i64| wa + (f - wa).div_euclid(step) * step;
-        let target = snap(audio::frame_of_sample(a.clock(), a.rate, fr).clamp(wa, wb));
-        if !video {
-            self.playback.audio_frame = Some(target);
-        } else if self.frames.is_cached(&FrameKey { frame: target, ..series }) {
-            self.playback.waiting = false;
-            if target != cur {
-                self.session.set_time(fr.tick_of(target));
-                self.playback.frame_shown(now);
-            }
-        } else {
-            // Rendering can't keep up: rather than skip frames, the sound stops and every
-            // frame shows as it renders until the frames ahead are cached again.
-            self.audio = None;
-            self.playback.audio_held = true;
-            self.playback.waiting = true;
-            // The rate measured before the stall no longer says it keeps up.
-            self.playback.shown_at.clear();
-            self.playback.start_wall = now;
-            self.playback.start_frame = cur;
-        }
-        ctx.request_repaint();
-        true
-    }
-
-    /// The wall clock advances the preview when no audio device drives it, and shows the target
-    /// frame (or holds when it is not cached yet).
-    fn advance_frame_clock(&mut self, pass: &PlaybackPass<'_>, step: i64) {
-        let PlaybackPass { ctx, now, plan, video, looping, frame_rate: fr, cur, series, .. } = *pass;
-        let FrameWindow { first: wa, last: wb } = pass.window;
-        let elapsed = now - self.playback.start_wall;
-        // The plan carries the rate the preview was started with (and `play_with` copies it to
-        // `Playback::fps`). Deriving the frame from the plan keeps a logic-only tick correct even
-        // when a host/test supplies only the plan; a stale duplicate cannot hold playback open.
-        let fps = plan.map_or(self.playback.fps, |p| p.fps);
-        let n = ((elapsed * fps) / step as f64).floor() as i64;
-        let target = match plan {
-            Some(p) => p.frame_after(self.playback.start_frame, n),
-            None => {
-                let t = self.playback.start_frame + n;
-                if t <= wb {
-                    Some(t)
-                } else if looping {
-                    Some(wa + (t - wa).rem_euclid((wb - wa + 1).max(1)))
-                } else {
-                    None
-                }
-            }
-        };
-        let Some(target) = target else {
-            if video {
-                self.session.set_time(fr.tick_of(wb));
-            } else {
-                self.playback.audio_frame = Some(wb);
-            }
-            self.stop();
-            return;
-        };
-        if !video {
-            // Audio-only preview without an audio device: the clock runs, the time stays.
-            self.playback.audio_frame = Some(target);
-            ctx.request_repaint();
-            return;
-        }
-        if self.frames.is_cached(&FrameKey { frame: target, ..series }) {
-            self.playback.waiting = false;
-            if target != cur {
-                self.session.set_time(fr.tick_of(target));
-                self.playback.frame_shown(now);
-            }
-        } else {
-            // Not cached yet: hold the clock at the current frame (cache first, then play).
-            self.playback.waiting = true;
-            let next = plan.and_then(|p| p.frame_after(cur, 1)).unwrap_or(if cur + 1 > wb { wa } else { cur + 1 });
-            if self.frames.is_cached(&FrameKey { frame: next, ..series }) {
-                self.session.set_time(fr.tick_of(next));
-            }
-            self.playback.start_wall = now;
-            self.playback.start_frame = fr.frame_at(self.session.time());
-        }
-        ctx.request_repaint();
-    }
-
-    /// While the project keeps changing (an edit within [`EDIT_QUIET`] seconds), how long until
-    /// it counts as settled.
-    fn editing(&mut self, now: f64) -> Option<f64> {
-        if self.last_edit.1 != self.session.revision {
-            self.last_edit = (now, self.session.revision);
-        }
-        let left = EDIT_QUIET - (now - self.last_edit.0);
-        (left > 0.0).then_some(left)
-    }
-
-    /// Composition ▸ Preview ▸ Cache Frames When Idle: after a second without input or edits,
-    /// render the work area's frames (from the current time on, then from its start) in the
-    /// background, a few at a time, until it is cached or the RAM preview budget is full.
-    fn cache_when_idle(
-        &mut self,
-        ctx: &egui::Context,
-        comp: &effectcraft_engine::project::Comp,
-        series: &FrameKey,
-        now: f64,
-        input_active: bool,
-        (wa, wb): (i64, i64),
-    ) {
-        let active = input_active;
-        if active || self.last_activity.1 != self.session.revision {
-            self.last_activity = (now, self.session.revision);
-        }
-        if !self.ui.cache_when_idle || self.frames.urgent_pending() {
-            return;
-        }
-        let quiet = now - self.last_activity.0;
-        if quiet < 1.0 {
-            ctx.request_repaint_after(std::time::Duration::from_secs_f64(1.0 - quiet));
-            return;
-        }
-        // An empty work area has nothing to cache.
-        let n = wb - wa + 1;
-        if n < 1 {
-            return;
-        }
-        let cur = comp.frame_rate.frame_at(self.session.time()).clamp(wa, wb);
-        let fit = self.frames_that_fit(comp, series.scale as f64 / 1000.0).min(n);
-        let slots = (self.frames_parallelism() / 2).max(1);
-        let mut queued = self.frames.inflight();
-        let scale = series.scale as f64 / 1000.0;
-        let mut pending = false;
-        for k in 0..fit {
-            let f = wa + (cur - wa + k).rem_euclid(n);
-            if self.frames.is_cached(&FrameKey { frame: f, ..*series }) {
-                continue;
-            }
-            pending = true;
-            if queued >= slots {
-                break;
-            }
-            self.request_frame(ItemId(series.comp), f, scale);
-            queued += 1;
-        }
-        if pending {
-            ctx.request_repaint_after(std::time::Duration::from_millis(100));
-        }
-    }
-
-    /// How many viewer frames of `comp` at `scale` the RAM preview budget holds (90 % of it,
-    /// at least one).
-    /// The frames of `plan` from `cur` to its end, or as many as fit in the RAM preview, are
-    /// cached: sound can play from `cur` in real time.
-    fn cached_ahead(&self, plan: &effectcraft_engine::preview::PreviewPlan, series: &FrameKey, cur: i64, fit: i64) -> bool {
-        let cached = self.frames.cached_frames(series);
-        (0..fit).map_while(|k| plan.frame_after(cur, k)).take_while(|f| *f >= cur).all(|f| cached.binary_search(&f).is_ok())
-    }
-
-    fn frames_that_fit(&self, comp: &effectcraft_engine::project::Comp, scale: f64) -> i64 {
-        let side = |n: u32| (n as f64 * scale).ceil().max(1.0);
-        let frame = side(comp.width) * side(comp.height) * 4.0;
-        ((self.frames.budget() as f64 * 0.9 / frame) as i64).max(1)
-    }
-
-    fn frames_parallelism(&self) -> usize {
-        if cfg!(target_arch = "wasm32") {
-            // frame workers render one frame each; without them frames render one at a time
-            // on the UI thread (`Frames::pump`)
-            return self.frames.remote_slots().max(1);
-        }
-        self.frames.parallelism()
-    }
-
-    // ---------------------------------------------------------------- control channel
-
-    pub(crate) fn raise_for_control(&mut self, ctx: &egui::Context) {
-        ctx.request_repaint();
-    }
-
-    fn drain_control(&mut self, ctx: &egui::Context, now: f64) {
-        let Some(rx) = self.control_rx.take() else { return };
-        let mut reqs: Vec<(ControlRequest, f64)> = std::mem::take(&mut self.deferred);
-        while let Ok(req) = rx.try_recv() {
-            reqs.push((req, now + 3.0));
-        }
-        for (req, deadline) in reqs {
-            let reply = req.reply.clone();
-            match control::handle(self, ctx, &req, now) {
-                control::Outcome::Done(v) => {
-                    let _ = reply.send(v);
-                }
-                control::Outcome::Retry(msg) => {
-                    if now < deadline {
-                        self.deferred.push((req, deadline));
-                        ctx.request_repaint();
-                    } else {
-                        let _ = reply.send(json!({"ok": false, "error": msg}));
-                    }
-                }
-                control::Outcome::AfterInput => {
-                    self.input_waiters.push(reply);
-                    // The reply waits for a real UI pass: a hidden window must run one.
-                    self.want_paint = true;
-                }
-                control::Outcome::AwaitJobs(w) => {
-                    self.job_waiters.push((w, reply));
-                    ctx.request_repaint();
-                }
-                control::Outcome::Screenshot { path, target } => {
-                    // A covered or minimized window presents no frames (macOS skips its redraws), so
-                    // a screenshot would never arrive and nothing would tick its timeout. The
-                    // hidden-window capture path (a pending screenshot forces a pass in 0.37) needs
-                    // a native platform run before this gate is removed; the web build never paints
-                    // a hidden tab.
-                    if ctx.input(|i| i.viewport().occluded == Some(true) || i.viewport().minimized == Some(true)) {
-                        let _ = reply.send(json!({"ok": false, "error": "window is covered or minimized: call ui.focus first (render.frame renders comp pixels without the window)"}));
-                        continue;
-                    }
-                    self.admit_screenshot(ctx, path, target, reply);
-                }
-            }
-        }
-        self.control_rx = Some(rx);
-        self.finish_job_waiters(ctx);
-    }
-
-    /// Reply to the control requests whose offloaded jobs ended.
-    fn finish_job_waiters(&mut self, ctx: &egui::Context) {
-        if self.job_waiters.is_empty() {
-            return;
-        }
-        self.session.poll_render();
-        self.session.poll_offload();
-        let waiters = std::mem::take(&mut self.job_waiters);
-        for (w, reply) in waiters {
-            if w.pending(self) {
-                self.job_waiters.push((w, reply));
-            } else {
-                let v = w.finish(self);
-                let _ = reply.send(v);
-            }
-        }
-        if !self.job_waiters.is_empty() {
-            ctx.request_repaint_after(std::time::Duration::from_millis(50));
-        }
-    }
-
-    // ---------------------------------------------------------------- screenshots
-
-    /// The root surface geometry a screenshot is admitted against.
-    ///
-    /// The last completed pass's geometry is authoritative. Before any pass, only the viewport's
-    /// `inner_rect` (the client surface a capture returns) is accepted: `outer_rect` also covers
-    /// the title bar and window frame, so a capture issued against it would be cropped and
-    /// validated against a different rectangle than the callback delivers. A request that arrives
-    /// before the geometry is known is refused with an actionable error, and the pass that would
-    /// establish it is requested.
-    fn current_geometry(&self, ctx: &egui::Context) -> Option<DrawGeometry> {
-        if let Some(g) = self.draw_geom {
-            return Some(g);
-        }
-        let rect = ctx.input(|i| i.viewport().inner_rect)?;
-        (rect.width() > 0.0 && rect.height() > 0.0).then_some(DrawGeometry { rect, ppp: ctx.pixels_per_point(), epoch: self.geometry_epoch })
-    }
-
-    /// The point rectangle a request captures: its crop, clamped to the window, or all of it.
-    fn shot_target_rect(geom: &DrawGeometry, crop: Option<[f32; 4]>) -> Option<egui::Rect> {
-        let r = match crop {
-            Some([x, y, w, h]) if [x, y, w, h].iter().all(|v| v.is_finite()) => {
-                egui::Rect::from_min_size(geom.rect.min + egui::vec2(x, y), egui::vec2(w.max(0.0), h.max(0.0))).intersect(geom.rect)
-            }
-            Some(_) => return None,
-            None => geom.rect,
-        };
-        (r.width() > 0.0 && r.height() > 0.0).then_some(r)
-    }
-
-    /// The screen-point crop `target` names right now (a panel's or element's current rectangle),
-    /// or an actionable error when it is not on screen. Resolved at issuance, never stored from
-    /// admission: the UI may move while it settles.
-    fn shot_crop(&self, target: &ShotTarget, geom: &DrawGeometry) -> Result<Option<egui::Rect>, String> {
-        let crop = match target {
-            ShotTarget::Window => None,
-            ShotTarget::Rect(r) => Some(*r),
-            ShotTarget::Panel(p) => {
-                let id = format!("panel.{}", p.id());
-                let found = self.auto.find(&id).ok_or_else(|| format!("the {} panel is not on screen", p.title()))?;
-                Some(found.rect)
-            }
-            ShotTarget::Id(id) => Some(self.auto.find(id).ok_or_else(|| format!("no element `{id}` is on screen"))?.rect),
-        };
-        Self::shot_target_rect(geom, crop).map(Some).ok_or_else(|| "the screenshot area is empty or not a finite rectangle".to_string())
-    }
-
-    /// `target` as a crop relative to `geom`'s origin: what the image's own pixels are cut with.
-    fn shot_relative_crop(&self, target: &ShotTarget, geom: &DrawGeometry) -> Result<Option<[f32; 4]>, String> {
-        let Some(r) = self.shot_crop(target, geom)? else { return Ok(None) };
-        Ok(Some([r.min.x - geom.rect.min.x, r.min.y - geom.rect.min.y, r.width(), r.height()]))
-    }
-
-    /// Pixel bytes `rect` takes at `ppp`, checked (`width * height * 4`).
-    fn shot_pixel_bytes(rect: egui::Rect, ppp: f32) -> Option<usize> {
-        if !ppp.is_finite() || ppp <= 0.0 {
-            return None;
-        }
-        let w = (rect.width() as f64 * ppp as f64).ceil().max(1.0) as usize;
-        let h = (rect.height() as f64 * ppp as f64).ceil().max(1.0) as usize;
-        w.checked_mul(h)?.checked_mul(4)
-    }
-
-    /// Reserve and queue one `ui.screenshot`, or reply with an actionable error.
-    fn admit_screenshot(&mut self, ctx: &egui::Context, path: Option<String>, target: ShotTarget, reply: Sender<serde_json::Value>) {
-        let Some(geom) = self.current_geometry(ctx) else {
-            let _ = reply.send(
-                json!({"ok": false, "error": "the window geometry is not known yet (it is recorded by a completed UI pass; retry after the next frame)"}),
-            );
-            // Ask for the pass that records it.
-            self.want_paint = true;
-            ctx.request_repaint();
-            return;
-        };
-        if self.pending_screenshots.len() >= MAX_PENDING_SHOTS {
-            let _ = reply.send(json!({"ok": false, "error": format!("too many screenshots are pending (at most {MAX_PENDING_SHOTS})")}));
-            return;
-        }
-        if let Err(e) = self.shot_crop(&target, &geom) {
-            let _ = reply.send(json!({"ok": false, "error": e}));
-            return;
-        }
-        // The capture is always the whole surface (the crop is applied when the PNG is written),
-        // so the reservation and the per-image bound follow the surface's actual dimensions.
-        let Some(bytes) = Self::shot_pixel_bytes(geom.rect, geom.ppp) else {
-            let _ = reply.send(json!({"ok": false, "error": "the screenshot area is too large to reserve"}));
-            return;
-        };
-        if bytes > MAX_SHOT_BYTES {
-            let _ = reply
-                .send(json!({"ok": false, "error": format!("the screenshot would need about {bytes} bytes, over the {MAX_SHOT_BYTES}-byte per-image limit")}));
-            return;
-        }
-        if self.shot_bytes.checked_add(bytes).is_none_or(|n| n > MAX_SHOT_TOTAL_BYTES) {
-            let _ = reply.send(json!({"ok": false, "error": format!("the screenshot would exceed the {MAX_SHOT_TOTAL_BYTES}-byte pending-image budget")}));
-            return;
-        }
-        self.shot_bytes += bytes;
-        self.pending_screenshots.push(PendingShot {
-            path,
-            target,
-            crop: None,
-            reply,
-            deadline: self.now + SCREENSHOT_TIMEOUT_S,
-            settle_at: self.now + SCREENSHOT_SETTLE_S,
-            admitted: geom,
-            admitted_pass: self.ui_pass_seq,
-            issued: None,
-            slot: None,
-            reserved_bytes: bytes,
-            attempts: 0,
-        });
-        // A queued capture needs a settled UI pass before it can be issued.
-        self.want_paint = true;
-    }
-
-    /// Re-reserve request `i` against `geom` after a surface change; false when it no longer fits.
-    fn refresh_shot_reservation(&mut self, i: usize, geom: &DrawGeometry) -> bool {
-        let Some(bytes) = Self::shot_pixel_bytes(geom.rect, geom.ppp) else { return false };
-        if bytes > MAX_SHOT_BYTES {
-            return false;
-        }
-        let released = self.shot_bytes.saturating_sub(self.pending_screenshots[i].reserved_bytes);
-        if released.checked_add(bytes).is_none_or(|n| n > MAX_SHOT_TOTAL_BYTES) {
-            return false;
-        }
-        self.shot_bytes = released + bytes;
-        self.pending_screenshots[i].reserved_bytes = bytes;
-        true
-    }
-
-    /// Reply with an error to request `i` and release its reservation.
-    fn fail_shot(&mut self, i: usize, message: impl Into<String>) {
-        let shot = self.pending_screenshots.remove(i);
-        self.shot_bytes = self.shot_bytes.saturating_sub(shot.reserved_bytes);
-        let _ = shot.reply.send(json!({"ok": false, "error": message.into()}));
-    }
-
-    /// Collect completed captures, enforce timeouts and issue every settled request.
-    ///
-    /// Runs from [`Self::tick`] only: the callback stores pixels in its slot and wakes the
-    /// viewport, and everything that can write a file or reply happens here, on the app thread.
-    fn tick_screenshots(&mut self, ctx: &egui::Context) {
-        let Some(geom) = self.current_geometry(ctx) else { return };
-        self.drain_completed_screenshots(geom);
-        self.timeout_screenshots();
-        self.issue_screenshots(ctx, geom);
-        // 4. Wake up for the earliest deadline even when no further pass is otherwise needed: an
-        //    issued capture whose callback never arrives (hidden window, display asleep, renderer
-        //    failure) would otherwise never reach its timeout. This is a timer, not a paint
-        //    request: the issued screenshot command already forces the frame it needs.
-        if let Some(next) = self.pending_screenshots.iter().map(|s| s.deadline).reduce(f64::min) {
-            let wait = (next - self.now).max(0.001);
-            ctx.request_repaint_after(std::time::Duration::from_secs_f64(wait));
-        }
-    }
-
-    /// 1. Drain completed slots. A completion whose surface epoch changed since issuance is
-    ///    discarded even if the geometry changed back: it was cropped with another frame's
-    ///    pixels-per-point.
-    fn drain_completed_screenshots(&mut self, geom: DrawGeometry) {
-        let mut i = 0;
-        while i < self.pending_screenshots.len() {
-            let taken = self.pending_screenshots.get(i).and_then(|s| s.slot.as_ref()).and_then(craft_ui::capture::CaptureSlot::take);
-            let Some(result) = taken else {
-                i += 1;
-                continue;
-            };
-            let issued = self.pending_screenshots[i].issued;
-            match result {
-                Ok(image) => {
-                    if issued.is_none_or(|g| g.epoch != geom.epoch) {
-                        self.pending_screenshots[i].slot = None;
-                        self.pending_screenshots[i].issued = None;
-                        if self.pending_screenshots[i].attempts >= SCREENSHOT_MAX_RETRIES {
-                            self.fail_shot(i, "the window resized while the screenshot was being taken");
-                        } else if !self.refresh_shot_reservation(i, &geom) {
-                            self.fail_shot(i, "the resized window is too large to capture within the screenshot budget");
-                        } else {
-                            let settle_at = self.now + SCREENSHOT_SETTLE_S;
-                            let passes = self.ui_pass_seq;
-                            let s = &mut self.pending_screenshots[i];
-                            s.attempts += 1;
-                            s.admitted = geom;
-                            s.admitted_pass = passes;
-                            s.settle_at = settle_at;
-                            i += 1;
-                        }
-                        continue;
-                    }
-                    let Some(issued) = issued else {
-                        i += 1;
-                        continue;
-                    };
-                    if !shot_image_matches(&image, issued.rect, issued.ppp) {
-                        self.fail_shot(i, "the screenshot's pixels do not match the window it was taken from");
-                        continue;
-                    }
-                    // The returned image can be smaller than requested (the E2 adapter-limit fit),
-                    // so the crop uses the image's own scale, never the issued ppp.
-                    let [iw, ih] = image.size;
-                    let (sx, sy) = (iw as f64 / issued.rect.width() as f64, ih as f64 / issued.rect.height() as f64);
-                    if !(sx.is_finite() && sx > 0.0 && sy.is_finite() && sy > 0.0) {
-                        self.fail_shot(i, "the screenshot's size does not describe the window it was taken from");
-                        continue;
-                    }
-                    let shot = self.pending_screenshots.remove(i);
-                    self.shot_bytes = self.shot_bytes.saturating_sub(shot.reserved_bytes);
-                    let r = control::save_screenshot(&image, shot.path.as_deref(), shot.crop, [sx, sy]);
-                    let _ = shot.reply.send(r);
-                }
-                Err(e) => {
-                    self.fail_shot(i, e.to_string());
-                }
-            }
-        }
-    }
-
-    /// 2. Timeouts: a late callback finds its slot cancelled and writes nothing.
-    fn timeout_screenshots(&mut self) {
-        let mut i = 0;
-        while i < self.pending_screenshots.len() {
-            if self.now > self.pending_screenshots[i].deadline {
-                self.fail_shot(i, "no frame was presented (window hidden or display asleep)");
-            } else {
-                i += 1;
-            }
-        }
-    }
-
-    /// 3. Issue settled requests. The command itself requests the paint; a request still
-    ///    waiting for its passes needs `want_paint` so a hidden window keeps painting.
-    fn issue_screenshots(&mut self, ctx: &egui::Context, geom: DrawGeometry) {
-        let mut i = 0;
-        while i < self.pending_screenshots.len() {
-            if self.pending_screenshots[i].slot.is_some() {
-                i += 1;
-                continue;
-            }
-            if geom.epoch != self.pending_screenshots[i].admitted.epoch {
-                if self.pending_screenshots[i].attempts >= SCREENSHOT_MAX_RETRIES {
-                    self.fail_shot(i, "the window kept resizing before the screenshot could be taken");
-                    continue;
-                }
-                if !self.refresh_shot_reservation(i, &geom) {
-                    self.fail_shot(i, "the resized window is too large to capture within the screenshot budget");
-                    continue;
-                }
-                let (now, passes) = (self.now, self.ui_pass_seq);
-                let s = &mut self.pending_screenshots[i];
-                s.attempts += 1;
-                s.admitted = geom;
-                s.admitted_pass = passes;
-                s.settle_at = now + SCREENSHOT_SETTLE_S;
-                self.want_paint = true;
-                i += 1;
-                continue;
-            }
-            let settled = self.ui_pass_seq >= self.pending_screenshots[i].admitted_pass.saturating_add(SCREENSHOT_SETTLE_PASSES)
-                && self.now >= self.pending_screenshots[i].settle_at;
-            if !settled {
-                self.want_paint = true;
-                i += 1;
-                continue;
-            }
-            // Resolve the crop now, against the settled UI: an element that moved since admission
-            // is captured where it is, and its rectangle is relative to this issued surface.
-            let target = self.pending_screenshots[i].target.clone();
-            let crop = match self.shot_relative_crop(&target, &geom) {
-                Ok(c) => c,
-                Err(e) => {
-                    self.fail_shot(i, e);
-                    continue;
-                }
-            };
-            let (slot, callback) = craft_ui::capture::CaptureSlot::new(ctx, egui::ViewportId::ROOT, MAX_SHOT_BYTES);
-            ctx.send_viewport_cmd(egui::ViewportCommand::Screenshot(callback));
-            let s = &mut self.pending_screenshots[i];
-            s.slot = Some(slot);
-            s.issued = Some(geom);
-            s.crop = crop;
-            i += 1;
-        }
-    }
-
-    // ---------------------------------------------------------------- frame
-
-    fn handle_events(&mut self, ctx: &egui::Context) {
-        for ev in self.session.drain_events() {
-            match ev {
-                effectcraft_engine::Event::OpenComp(c) => {
-                    panels::viewers::on_open_comp(self, c);
-                    self.ui.timeline.pps = None;
-                }
-                effectcraft_engine::Event::Toast { message, .. } => self.toast = Some((message, self.now)),
-                effectcraft_engine::Event::OpenUrl(url) => ctx.open_url(egui::OpenUrl::new_tab(url)),
-                // Frames are keyed by content: an edit keeps those of comps it doesn't touch.
-                effectcraft_engine::Event::ProjectChanged { .. } => {}
-                effectcraft_engine::Event::Frontend { command, params } => {
-                    if let Err(e) = crate::menus::frontend(self, ctx, &command, params) {
-                        self.ui.status = e;
-                    }
-                }
-                effectcraft_engine::Event::PurgeCaches => self.frames.clear(),
-                effectcraft_engine::Event::CopyImage { width, height, rgba } => {
-                    if let Err(e) = copy_image(ctx, width, height, &rgba) {
-                        self.ui.status = e;
-                    }
-                }
-            }
-        }
-    }
-
-    /// The app's only non-paint entry: one tick of background work.
-    ///
-    /// This runs for every eframe logic callback, including the logic-only ticks of a hidden
-    /// window (which never reach [`Self::draw`]). It must therefore do no input handling, no
-    /// layout and no presentation: engine/job queues, autosave, playback, audio, the control
-    /// channel, screenshots and the close guard. Everything here is idempotent for a pass that
-    /// `Context::request_discard` replays.
-    pub fn tick(&mut self, ctx: &egui::Context, frame: &eframe::Frame) {
-        self.now = self.clock.now();
-        // The compositor exists before the first paint and while hidden (device-loss handling
-        // must run there too).
-        self.init_gpu(frame);
-        self.apply_gpu_failure(ctx);
-        if self.gpu_failure_applied == Some(true) {
-            self.close_after_device_loss(ctx);
-            return;
-        }
-        // Focus comes from the fresh viewport copy; a full pass's `InputState::focused` is only a
-        // fallback (a logic-only tick leaves it at the previous pass's value).
-        let focused = ctx.input(|i| i.viewport().focused.or(Some(i.focused)));
-        self.focused = focused.unwrap_or(self.focused);
-        // The interface language's fallback fonts are installed in `draw` (fonts need a pass), but
-        // commands handled here use the right catalog already.
-        let language = crate::i18n::language(self);
-        crate::i18n::set_current(language);
-        if self.styled_language != language {
-            self.want_paint = true;
-        }
-        // Frames and worker completions wake the app even while it is hidden.
-        self.frames.set_context(ctx);
-        updates_ui::tick(self, ctx);
-        if self.session.render_job.is_some() {
-            self.session.poll_render();
-            ctx.request_repaint_after(std::time::Duration::from_millis(100));
-        }
-        if self.session.track_job.is_some() {
-            self.session.poll_track();
-            ctx.request_repaint_after(std::time::Duration::from_millis(50));
-        }
-        if self.session.mask_job.is_some() {
-            self.session.poll_mask_track();
-            ctx.request_repaint_after(std::time::Duration::from_millis(50));
-        }
-        // Background tasks (Content-Aware Fill, Scene Edit Detection, imports).
-        if !self.session.tasks.is_empty() {
-            self.session.poll_jobs();
-            ctx.request_repaint_after(std::time::Duration::from_millis(100));
-        }
-        // Analyses running in a worker (the web app).
-        if !self.session.offloaded.is_empty() {
-            self.session.poll_offload();
-            ctx.request_repaint_after(std::time::Duration::from_millis(100));
-        }
-        // Warp Stabilizer: finish analyses and start queued (re-)analyses in the background.
-        if self.session.warp_job.is_some() || !self.session.warp_pending.is_empty() {
-            self.session.poll_warp(true);
-            self.session.poll_roto(true);
-            ctx.request_repaint_after(std::time::Duration::from_millis(100));
-        }
-        // Roto Brush propagation and Object Matte tracking / Freeze: finish jobs (a Freeze writes
-        // its mattes) and start queued ones in the background.
-        if self.session.roto_job.is_some() || !self.session.roto_pending.is_empty() {
-            self.session.poll_roto(true);
-            ctx.request_repaint_after(std::time::Duration::from_millis(100));
-        }
-        // 3D Camera Tracker: likewise (tracking, then solving).
-        if self.session.camera_job.is_some() || !self.session.camera_pending.is_empty() {
-            self.session.poll_camera(true);
-            ctx.request_repaint_after(std::time::Duration::from_millis(100));
-        }
-        self.run_script_tasks(ctx);
-        self.run_dialog_answers();
-        self.handle_events(ctx);
-        if let Some(rx) = self.command_inbox.take() {
-            while let Ok(id) = rx.try_recv() {
-                if let Err(e) = menus::invoke(self, ctx, &id, json!({})) {
-                    self.ui.status = e;
-                }
-            }
-            self.command_inbox = Some(rx);
-        }
-        // A close request (the window's button, Quit, `app.quit`) must be answered while hidden.
-        panels::unsaved::on_close_requested(self, ctx);
-        let title = panels::unsaved::window_title(self);
-        if title != self.window_title {
-            ctx.send_viewport_cmd(egui::ViewportCommand::Title(title.clone()));
-            self.window_title = title;
-        }
-        self.tick_autosave(ctx);
-        self.tick_workspace_autosave(ctx);
-        let now = self.now;
-        prefs_live::tick(self, ctx, now);
-        // Playback advances without a paint (its frames and the audio clock are background work).
-        // Idle prefetch keeps its old condition: it only runs once a viewer has drawn.
-        if (self.playback.playing || self.last_viewer_scale.is_some())
-            && let Some(cid) = self.session.active_comp_id()
-        {
-            let (scale, active) = (self.last_viewer_scale.unwrap_or(1.0), self.input_active);
-            self.advance_playback(ctx, scale, now, active, cid);
-        }
-        self.drain_control(ctx, now);
-        // Screenshot completion, deadlines and issuance are app-side work: the callback only
-        // stores pixels and wakes this viewport.
-        self.tick_screenshots(ctx);
-        // Time-based FPS readout over UI passes (a hidden logic-only tick is not a frame).
-        let dt = (now - self.last_time) as f32;
-        if dt > 0.0 && dt < 2.0 {
-            self.fps = self.fps * 0.9 + (1.0 / dt).min(480.0) * 0.1;
-        }
-        self.last_time = now;
-        // A hidden window paints when work needs a UI pass: queued input and waits, a settled
-        // screenshot, or playback into a child viewport.
-        let focused = self.focused;
-        let child_viewports = !self.ui.floating.is_empty() || prefs_live::video_preview_active(self, focused);
-        let paint = self.want_paint
-            || !self.synthetic.is_empty()
-            || !self.input_waiters.is_empty()
-            || self.pending_screenshots.iter().any(|s| s.slot.is_none())
-            || (self.playback.playing && child_viewports);
-        if paint {
-            self.request_hidden_paint(ctx);
-        }
-    }
-
-    /// Ask the host for a UI pass even when the window is minimized or occluded.
-    ///
-    /// Native eframe honours `RequestPaintWhileHidden`; the shared web backend does not carry it
-    /// yet (a browser does not paint a hidden tab), so the web build only requests a normal
-    /// repaint and hidden web screenshots/input remain unqualified.
-    fn request_hidden_paint(&mut self, ctx: &egui::Context) {
-        self.want_paint = false;
-        #[cfg(not(target_arch = "wasm32"))]
-        ctx.send_viewport_cmd(egui::ViewportCommand::RequestPaintWhileHidden);
-        ctx.request_repaint();
-    }
-
-    /// Install the theme and fonts for the current language. Fonts need a real pass: the pass
-    /// that installs them draws nothing, and the next pass draws with them (the two-pass warm-up
-    /// the app has always had). Never call this from a logic-only tick.
-    fn ui_setup(&mut self, ctx: &egui::Context) {
-        panels::viewer_text::install_hooks(ctx);
-        let language = crate::i18n::language(self);
-        crate::i18n::set_current(language);
-        if (!self.styled || self.styled_language != language) && self.synthetic_in_flight {
-            // The install needs a pass that draws nothing, but this pass has already applied a
-            // synthetic batch: defer the theme/font install by one pass instead of dropping the
-            // input (feeds are only put into a pass that can draw).
-            ctx.request_repaint();
-            return;
-        }
-        if !self.styled || self.styled_language != language {
-            theme::install(ctx, &self.tokens, language);
-            self.styled_language = language;
-            if !self.styled {
-                fit_window(ctx);
-                self.styled = true;
-            }
-            self.fonts_ready = false;
-            ctx.request_repaint();
-        } else if !self.fonts_ready {
-            // The pass after the install draws: egui has the new font definitions by now.
-            self.fonts_ready = true;
-            ctx.request_repaint();
-        }
-    }
-
-    /// One UI pass: setup, input-driven shortcuts, layout and painting. Called from
-    /// `eframe::App::ui` and by tests with the root `Ui`.
-    pub fn draw(&mut self, ui: &mut egui::Ui, frame: &eframe::Frame) {
-        panels::viewer_text::begin_ui(ui.ctx());
-        self.draw_inner(ui, frame);
-        // All exits, including fonts/device loss, observe this pass's real custom availability.
-        panels::viewer_text::finish_ime(self, ui);
-    }
-
-    /// Context creators install these hooks before the first full pass.
-    pub fn install_ime_reset_hooks(ctx: &egui::Context) {
-        panels::viewer_text::install_hooks(ctx);
-    }
-
-    /// Host wrappers call this after their last logic mutation, without replaying UI events.
-    pub fn finish_ime_logic(&self, ctx: &egui::Context) {
-        panels::viewer_text::finish_logic(self, ctx);
-    }
-
-    fn draw_inner(&mut self, ui: &mut egui::Ui, frame: &eframe::Frame) {
-        let ctx = ui.ctx().clone();
-        if self.gpu_failure_applied == Some(true) {
-            self.close_after_device_loss(&ctx);
-            return;
-        }
-        self.ui_setup(&ctx);
-        if !self.fonts_ready {
-            // A pass that installs fonts draws nothing. No synthetic batch is in flight here (the
-            // hook feeds input only to a ready app), and events egui already applied are never
-            // fed again: that would double the pointer/key state of one click.
-            ctx.request_repaint();
-            return;
-        }
-        self.frame(ui);
-        #[cfg(not(target_arch = "wasm32"))]
-        pointer_wrap::finish_native(&ctx, frame);
-        // wasm32: no frame threads; render queued frames now, between UI frames.
-        if cfg!(target_arch = "wasm32") && self.frames.pump(std::time::Duration::from_millis(if self.playback.playing { 24 } else { 40 })) {
-            ctx.request_repaint();
-        }
-        // Input belongs to this known UI phase: record it for the next tick.
-        let active = ctx.input(|i| !i.events.is_empty() || i.pointer.any_down() || i.pointer.is_moving());
-        self.input_active = active;
-        self.last_pointer_down = ctx.input(|i| i.pointer.any_down());
-        // Geometry of a completed pass (a discarded pass is laid out again; only the final one
-        // describes the surface the next capture will see). Window position is irrelevant.
-        if !ctx.will_discard() {
-            let rect = ctx.content_rect();
-            let ppp = ctx.pixels_per_point();
-            let changed = self.draw_geom.is_none_or(|g| g.rect.size() != rect.size() || g.ppp != ppp);
-            if changed {
-                self.geometry_epoch = self.geometry_epoch.wrapping_add(1);
-            }
-            self.draw_geom = Some(DrawGeometry { rect, ppp, epoch: self.geometry_epoch });
-            self.ui_pass_seq = self.ui_pass_seq.saturating_add(1);
-        }
-        // A batch is acknowledged once a UI pass applied it, even if layout was later discarded.
-        self.mark_synthetic_applied();
-        // `AfterInput` replies wait for the final (non-discarded) pass that applied the last
-        // synthetic event: a hidden request is answered only after its forced pass, and a pass
-        // egui throws away cannot produce an early success reply.
-        if !ctx.will_discard() && self.synthetic.is_empty() {
-            for w in self.input_waiters.drain(..) {
-                let _ = w.send(json!({"ok": true, "result": null}));
-            }
-        } else if !self.input_waiters.is_empty() {
-            self.want_paint = true;
-            ctx.request_repaint();
-        }
-        if self.frames.inflight() > 0 {
-            ctx.request_repaint_after(std::time::Duration::from_millis(30));
-        }
-    }
-
-    /// The panels, menus, dialogs and overlays of one pass.
-    fn frame(&mut self, ui: &mut egui::Ui) {
-        let ctx = ui.ctx().clone();
-        // Only a viewer that draws in *this* pass records a scale: a closed viewer, the Home
-        // screen or another comp must stop idle prefetch at a stale scale.
-        self.last_viewer_scale = None;
-        self.apply_prefs(&ctx);
-        // Video Preview is a second viewport: only a real pass can update it.
-        prefs_live::frame(self, &ctx);
-        self.auto.begin_frame();
-        let tab_had_widget_focus = ctx.egui_wants_keyboard_input();
-        menus::handle_shortcuts(self, &ctx);
-        if !ctx.input(|i| i.pointer.primary_down()) {
-            self.ui.viewer.property_interacting = false;
-        }
-        let t = self.tokens;
-        let full = ui.max_rect();
-        if self.dialog.is_some() {
-            ui.disable();
-        }
-        ui.painter().rect_filled(full, 0.0, t.app_bg);
-        let mut top = full.min.y;
-        if self.ui.show_menu_bar {
-            let mb = egui::Rect::from_min_size(full.min, egui::vec2(full.width(), 24.0));
-            let mut child = ui.new_child(egui::UiBuilder::new().max_rect(mb));
-            child.painter().rect_filled(mb, 0.0, t.header_bg);
-            menus::menu_bar(self, &mut child);
-            top = mb.max.y;
-        }
-        let header_h = 40.0;
-        let header = egui::Rect::from_min_size(egui::pos2(full.min.x, top), egui::vec2(full.width(), header_h));
-        header::show(self, ui, header);
-        let body = egui::Rect::from_min_max(egui::pos2(full.min.x + 4.0, header.max.y + 2.0), egui::pos2(full.max.x - 4.0, full.max.y - 4.0));
-        self.dock_area(ui, body);
-        #[cfg(not(target_arch = "wasm32"))]
-        prefs_live::dropped_files(self, ui, full);
-        if !tab_had_widget_focus {
-            menus::handle_tab_shortcut(self, &ctx);
-        }
-        panels::precomp::mini_flowchart(self, &ctx);
-        panels::home::capture_thumbnail(self);
-        panels::dialogs::show(self, &ctx);
-        updates_ui::show(self, &ctx);
-        panels::scriptui_view::sync_panels(self);
-        panels::scriptui_view::show_windows(self, &ctx);
-        panels::learn::coach(self, &ctx);
-        let lift = panels::media_panels::import_card(self, ui, full);
-        self.draw_toast(ui, full, lift);
-    }
-
-    /// Workspace-layout auto-save: a background write that also runs while hidden, once the
-    /// pointer has lifted.
-    fn tick_workspace_autosave(&mut self, ctx: &egui::Context) {
-        if self.session.config.is_none() || !self.workspace_store.has_changes(&self.ui) || self.last_pointer_down {
-            return;
-        }
-        if self.workspace_store.due(self.now) {
-            self.save_workspace_state();
-        }
-        if self.workspace_store.has_changes(&self.ui) {
-            ctx.request_repaint_after(std::time::Duration::from_secs(1));
-        }
-    }
-
-    fn save_workspace_state(&mut self) {
-        if let Err(error) = self.workspace_store.save(self.session.config.as_deref(), &self.ui) {
-            if self.workspace_store.error.as_ref() != Some(&error) {
-                log::warn!("{error}");
-                self.ui.status = error.clone();
-            }
-            self.workspace_store.error = Some(error);
-        }
-    }
-
-    /// The status message or the latest toast, bottom left (`lift` points higher while the
-    /// Importing card is there).
-    fn draw_toast(&mut self, ui: &mut egui::Ui, full: egui::Rect, lift: f32) {
-        let now = self.now;
-        let msg = if !self.ui.status.is_empty() {
-            Some(self.ui.status.clone())
-        } else {
-            self.toast.as_ref().filter(|(_, at)| now - at < 4.0).map(|(m, _)| m.clone())
-        };
-        if let Some(m) = msg {
-            let t = &self.tokens;
-            let galley = ui.painter().layout_no_wrap(m.clone(), Tokens::ui(12.0), t.text);
-            let r = egui::Rect::from_min_size(egui::pos2(full.min.x + 16.0, full.max.y - 44.0 - lift), galley.size() + egui::vec2(24.0, 14.0));
-            ui.painter().rect_filled(r, 6.0, t.panel_bg);
-            ui.painter().rect_stroke(r, 6.0, egui::Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside);
-            ui.painter().galley(r.min + egui::vec2(12.0, 7.0), galley, t.text);
-            self.auto.add("toast", r, &m);
-            let resp = ui.interact(r, egui::Id::unique("toast"), egui::Sense::click());
-            if resp.clicked() {
-                self.ui.status.clear();
-                self.toast = None;
-            }
-            ui.ctx().request_repaint_after(std::time::Duration::from_millis(500));
-            if !self.ui.status.is_empty() {
-                let since: f64 = ui.data(|d| d.get_temp(egui::Id::unique("status-since")).unwrap_or(now));
-                ui.data_mut(|d| d.insert_temp(egui::Id::unique("status-since"), since));
-                if now - since > 5.0 {
-                    self.ui.status.clear();
-                    ui.data_mut(|d| d.remove::<f64>(egui::Id::unique("status-since")));
-                }
-            }
+        let since = *self.since.get_or_insert(now);
+        if !focused {
+            self.left = true;
+        } else if self.left || now - since >= Self::UNSEEN {
+            *self = Self::default();
         }
+        self.count > 0
     }
 }
 
-impl EffectcraftApp {
-    /// Scripts' `app.scheduleTask` tasks that are due (repeating ones keep a ScriptUI panel
-    /// fresh): errors as a toast, the last line printed in the status bar, and a repaint when
-    /// the next one is due.
-    fn run_script_tasks(&mut self, ctx: &egui::Context) {
-        if self.session.script_ui.task_hosts.is_empty() {
-            return;
-        }
-        let previous_comp = self.session.active_comp_id();
-        let Some(r) = effectcraft_engine::scriptui::ScriptUi::run_tasks(&mut self.session) else { return };
-        if self.session.active_comp_id().is_some() && self.session.active_comp_id() != previous_comp {
-            self.ui.start_screen = false;
-        }
-        if let Some(msg) = r["errors"].as_array().and_then(|e| e.first()).and_then(|e| e["message"].as_str()) {
-            self.toast = Some((format!("Scheduled script task: {msg}"), self.now));
-        } else if let Some(line) = r["output"].as_array().and_then(|o| o.last()).and_then(|l| l.as_str()) {
-            self.ui.status = line.to_string();
-        }
-        if let Some(next) = r["next"].as_u64() {
-            ctx.request_repaint_after(std::time::Duration::from_millis(next));
-        }
-    }
-
-    /// Auto-save a dirty project when the interval has passed (Settings ▸ Project ▸ Auto-Save).
-    fn tick_autosave(&mut self, ctx: &egui::Context) {
-        // Monotonic app time: a wall-clock jump must not skip or repeat an auto-save.
-        let now = self.now;
-        if let Some(Err(e)) = self.session.autosave_tick(now) {
-            self.ui.status = e.to_string();
-        }
-        if self.session.prefs.auto_save.enabled {
-            ctx.request_repaint_after(std::time::Duration::from_secs(30));
-        }
-        // File ▸ Watch Folder: look for new projects every 10 seconds.
-        if self.session.state.watch_folder.is_some() {
-            let key = egui::Id::unique("watchFolder.lastPoll");
-            let last: f64 = ctx.data(|d| d.get_temp(key)).unwrap_or(0.0);
-            if now - last >= 10.0 {
-                ctx.data_mut(|d| d.insert_temp(key, now));
-                match self.session.execute("file.watchFolder.poll", serde_json::json!({})) {
-                    Ok(r) => {
-                        if let Some(n) = r["rendered"].as_array().map(Vec::len).filter(|n| *n > 0) {
-                            self.ui.status = format!("Watch Folder: rendered {n} project(s)");
-                        }
-                    }
-                    Err(e) => self.ui.status = e.to_string(),
-                }
-            }
-            ctx.request_repaint_after(std::time::Duration::from_secs(10));
-        }
-        self.tick_footage_reload(ctx, now);
-    }
-
-    /// Settings ▸ Import ▸ Reload Footage Changed on Disk: every two seconds, and as soon as the
-    /// window comes back to the front (after saving in another app), stamp the footage files on a
-    /// worker thread and reload the ones that changed.
-    fn tick_footage_reload(&mut self, ctx: &egui::Context, now: f64) {
-        use effectcraft_engine::footage_reload;
-        if let Some(Err(e)) = footage_reload::poll_scan(&mut self.session) {
-            self.ui.status = e.to_string();
-        }
-        let (last_key, focus_key) = (egui::Id::unique("footageReload.lastScan"), egui::Id::unique("footageReload.focused"));
-        let focused = self.focused;
-        let was_focused: bool = ctx.data(|d| d.get_temp(focus_key)).unwrap_or(focused);
-        ctx.data_mut(|d| d.insert_temp(focus_key, focused));
-        if self.session.prefs.import.auto_reload_footage == "off" || self.session.project.items.is_empty() {
-            return;
-        }
-        let last: f64 = ctx.data(|d| d.get_temp(last_key)).unwrap_or(0.0);
-        if now - last >= 2.0 || (focused && !was_focused) {
-            ctx.data_mut(|d| d.insert_temp(last_key, now));
-            footage_reload::start_scan(&mut self.session);
-        }
-        if self.session.footage_scan.is_some() {
-            ctx.request_repaint_after(std::time::Duration::from_millis(100));
-        } else {
-            ctx.request_repaint_after(std::time::Duration::from_secs(2));
-        }
-    }
-
-    /// Take the pending synthetic input (from `ui.click`, `ui.key`, …). Hosts that don't call
-    /// [`eframe::App::raw_input_hook`] (the headless test harness) feed these in themselves.
-    pub fn take_synthetic_input(&mut self) -> Vec<egui::Event> {
-        std::mem::take(&mut self.synthetic)
-    }
-}
-
-impl eframe::App for EffectcraftApp {
-    fn on_exit(&mut self) {
-        self.save_workspace_state();
-        // Clean exit: no crash recovery next launch (unless the graphics device was lost with
-        // unsaved changes, which are in the auto-save it offers).
-        if self.device_lost_close != Some(true) {
-            self.session.end_recovery();
-        }
-    }
-
-    fn raw_input_hook(&mut self, ctx: &egui::Context, raw_input: &mut egui::RawInput) {
-        let injected = self.synthetic_in_flight || !self.synthetic.is_empty();
-        // Only a pass that can draw may receive synthetic input: `Context::run_ui` applies
-        // everything the hook feeds to its input state, so a pass that cannot draw (fonts still
-        // installing) would consume a batch it could not put back — putting it back would apply
-        // the click/key state twice. The queue waits here for the first pass that draws.
-        if self.fonts_ready {
-            self.feed_synthetic(raw_input);
-        }
-        if pointer_wrap::prepare_input(ctx, raw_input, injected) {
-            self.session.history.merge_key = None;
-        }
-    }
-
-    fn logic(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        // Never `ctx.input(|i| i.time)` here: `Context::run_logic` leaves events, pointer state and
-        // time at the previous full pass's values (only the viewport information is refreshed).
-        self.tick(ctx, frame);
-        self.finish_ime_logic(ctx);
-    }
-
-    fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {
-        self.draw(ui, frame);
-    }
+/// Keys and dropped files from floating panels' OS windows (craft-ui `DockOutput`).
+#[derive(Default)]
+pub(crate) struct ForwardedInput {
+    pub(crate) events: Vec<egui::Event>,
+    pub(crate) files: Vec<egui::DroppedFileHandle>,
+    /// Files handed over by a floating window whose panel under the pointer was the Timeline. The
+    /// paths lose the window they came from, so this keeps the one thing the import still needs
+    /// (#2661); each drop clears it.
+    pub(crate) dropped_on_timeline: bool,
 }
 
 /// Record the scale the viewer drew at (called by the viewer panel each pass).
@@ -2658,753 +456,5 @@ pub(crate) fn note_viewer_scale(app: &mut EffectcraftApp, scale: f64) {
     app.last_viewer_scale = Some(scale);
 }
 
-/// Put `width` × `height` straight-alpha RGBA8 pixels on the system clipboard (Composition ▸ Copy
-/// Frame to Clipboard). The pixel count is checked first: egui's image constructor panics on a
-/// size that doesn't match its buffer.
-fn copy_image(ctx: &egui::Context, width: u32, height: u32, rgba: &[u8]) -> Result<(), String> {
-    let (w, h) = (width as usize, height as usize);
-    if w == 0 || h == 0 || w.checked_mul(h).and_then(|n| n.checked_mul(4)) != Some(rgba.len()) {
-        return Err(format!("cannot copy a malformed {width}×{height} image to the clipboard"));
-    }
-    ctx.copy_image(egui::ColorImage::from_rgba_unmultiplied([w, h], rgba));
-    Ok(())
-}
-
-/// Maximize a first window that doesn't fit the screen, which fits it to the space beside the
-/// taskbar or dock. The 1680 × 1020 window on a smaller screen is only shrunk to the monitor's
-/// size, so with its title bar it ran under the taskbar and cut menus off at the bottom of the
-/// screen (#269).
-fn fit_window(ctx: &egui::Context) {
-    let (monitor, window) = ctx.input(|i| (i.viewport().monitor_size, i.viewport().outer_rect.or(i.viewport().inner_rect)));
-    if let (Some(monitor), Some(window)) = (monitor, window)
-        && overflows_screen(window.size(), monitor)
-    {
-        ctx.send_viewport_cmd(egui::ViewportCommand::Maximized(true));
-    }
-}
-
-/// Whether a window `size` leaves no room on a `monitor` for a taskbar or dock (points).
-fn overflows_screen(size: egui::Vec2, monitor: egui::Vec2) -> bool {
-    const TASKBAR: f32 = 64.0;
-    size.x > monitor.x || size.y > monitor.y - TASKBAR
-}
-
 #[cfg(test)]
-mod fit_window_tests {
-    use super::overflows_screen;
-    use egui::vec2;
-
-    #[test]
-    fn a_window_taller_than_the_screen_beside_its_taskbar_overflows() {
-        // The default window on a 1366 × 768 laptop (shrunk to the monitor) and on 1080p.
-        assert!(overflows_screen(vec2(1366.0, 799.0), vec2(1366.0, 768.0)));
-        assert!(overflows_screen(vec2(1680.0, 1051.0), vec2(1920.0, 1080.0)));
-        assert!(!overflows_screen(vec2(1680.0, 1051.0), vec2(2560.0, 1440.0)));
-    }
-}
-
-#[cfg(test)]
-mod copy_frame_tests {
-    use super::*;
-
-    fn copied(output: &egui::FullOutput) -> Vec<&egui::ColorImage> {
-        output
-            .platform_output
-            .commands
-            .iter()
-            .filter_map(|c| match c {
-                egui::OutputCommand::CopyImage(image) => Some(image),
-                _ => None,
-            })
-            .collect()
-    }
-
-    /// Composition ▸ Copy Frame to Clipboard puts the rendered frame on the system clipboard.
-    #[test]
-    fn copy_frame_puts_the_frame_on_the_clipboard() {
-        let mut session = Session::default();
-        session.execute("comp.new", json!({"name": "Copy", "width": 8, "height": 6, "duration": 1})).unwrap();
-        session.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
-        let mut app = EffectcraftApp::new(session);
-        let ctx = egui::Context::default();
-        let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
-            crate::menus::invoke(&mut app, ui.ctx(), "comp.copyFrame", json!({})).unwrap();
-            app.handle_events(ui.ctx());
-        });
-        output.textures_delta.clear();
-        let images = copied(&output);
-        assert_eq!(images.len(), 1);
-        assert_eq!(images[0].size, [8, 6]);
-        assert!(images[0].pixels.iter().all(|p| *p == egui::Color32::from_rgb(255, 0, 0)));
-    }
-
-    /// A malformed image never reaches egui's panicking constructor.
-    #[test]
-    fn a_malformed_image_is_an_error_not_a_crash() {
-        let ctx = egui::Context::default();
-        let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
-            assert!(copy_image(ui.ctx(), 4, 4, &[0; 10]).is_err());
-            assert!(copy_image(ui.ctx(), 0, 4, &[]).is_err());
-            assert!(copy_image(ui.ctx(), u32::MAX, u32::MAX, &[0; 4]).is_err());
-        });
-        output.textures_delta.clear();
-        assert!(copied(&output).is_empty());
-    }
-}
-
-#[cfg(test)]
-mod gpu_failure_tests {
-    use super::*;
-
-    #[test]
-    fn host_failure_preserves_document_undo_and_cpu_pixels_and_detaches_late_readbacks() {
-        let mut session = Session::default();
-        let comp = ItemId(session.execute("comp.new", json!({"name": "Recovery", "width": 4, "height": 4, "duration": 1})).unwrap()["comp"].as_u64().unwrap());
-        session.execute("layer.newSolid", json!({"comp": comp.0, "color": "#ff0000"})).unwrap();
-        let before = session.render(comp, Tick::ZERO, RenderOpts::default());
-        let project = session.project.clone();
-        let revision = session.revision;
-        let prefs = serde_json::to_value(&session.prefs).unwrap();
-        let mut app = EffectcraftApp::new(session);
-        let ctx = egui::Context::default();
-        let bridge = gpu_failure::GpuFailureBridge::new(&ctx);
-        app.set_gpu_failure_bridge(bridge.clone());
-        let late_slot = app.viewer_readback.1.clone();
-        let key = FrameKey { revision, content: 1, comp: comp.0, frame: 0, scale: 1000, view: 0, opts: 0 };
-        app.viewer_readback.0 = Some(key);
-        bridge.report("synthetic host device failure", true);
-        app.apply_gpu_failure(&ctx);
-        assert!(Arc::ptr_eq(&project, &app.session.project));
-        assert_eq!(app.session.revision, revision);
-        assert_eq!(serde_json::to_value(&app.session.prefs).unwrap(), prefs);
-        assert!(app.gpu_checked, "failed device cannot be initialized again next frame");
-        assert!(app.session.accel.is_none());
-        assert!(app.ui.status.contains("presentation requires restarting"));
-        assert_eq!(app.session.render(comp, Tick::ZERO, RenderOpts::default()).data, before.data);
-        *late_slot.lock().unwrap() = Some((key, Arc::new(egui::ColorImage::new([1, 1], vec![egui::Color32::RED]))));
-        assert!(app.viewer_readback.0.is_none());
-        assert!(app.viewer_readback.1.lock().unwrap().is_none(), "a late completion cannot refill the replacement slot");
-        app.session.execute("edit.undo", json!({})).unwrap();
-        assert!(app.session.project.comp(comp).unwrap().layers.is_empty());
-        app.session.execute("edit.redo", json!({})).unwrap();
-        assert_eq!(app.session.render(comp, Tick::ZERO, RenderOpts::default()).data, before.data);
-    }
-}
-
-#[cfg(test)]
-mod appearance_tests {
-    use super::*;
-    use crate::theme::ThemeKind;
-
-    fn app() -> EffectcraftApp {
-        EffectcraftApp::new(effectcraft_engine::Session::default())
-    }
-
-    /// The Tools bar's appearance button: Sync with System, Light, Dark, then Sync with System
-    /// again, showing the saved theme of each family without losing either choice.
-    #[test]
-    fn appearance_button_cycles_modes_without_losing_theme_choices() {
-        let ctx = egui::Context::default();
-        let mut app = app();
-        app.hooks.system_theme = Some(Box::new(|_| Some(egui::Theme::Dark)));
-        app.set_pref("appearance.darkTheme", json!("darker")).unwrap();
-        app.apply_prefs(&ctx);
-        assert_eq!(app.ui.theme, ThemeKind::Darker);
-        for (mode, shown) in [("auto", ThemeKind::Darker), ("light", ThemeKind::Light), ("dark", ThemeKind::Darker), ("auto", ThemeKind::Darker)] {
-            menus::invoke(&mut app, &ctx, "view.theme.toggle", json!({})).unwrap();
-            assert_eq!(app.session.prefs.appearance.appearance_mode, mode);
-            assert_eq!(app.ui.theme, shown, "{mode}");
-            assert_eq!(app.tokens.kind, shown);
-            assert_eq!(app.session.prefs.appearance.dark_theme, "darker");
-            assert_eq!(app.session.prefs.appearance.light_theme, "light");
-        }
-    }
-
-    /// Sync with System follows the host's answer (the Linux portal) when it changes, and falls
-    /// back to Dark when nothing reports a system appearance.
-    #[test]
-    fn auto_follows_a_stubbed_system_theme() {
-        use std::sync::{Arc, Mutex};
-        let ctx = egui::Context::default();
-        let mut app = app();
-        let system = Arc::new(Mutex::new(Some(egui::Theme::Light)));
-        let read = Arc::clone(&system);
-        app.hooks.system_theme = Some(Box::new(move |_| *read.lock().unwrap_or_else(std::sync::PoisonError::into_inner)));
-        app.set_pref("appearance.appearanceMode", json!("auto")).unwrap();
-        app.apply_prefs(&ctx);
-        assert_eq!(app.ui.theme, ThemeKind::Light);
-        *system.lock().unwrap() = Some(egui::Theme::Dark);
-        app.apply_prefs(&ctx);
-        assert_eq!(app.ui.theme, ThemeKind::Dark, "a system change applies without a settings change");
-        *system.lock().unwrap() = None;
-        app.apply_prefs(&ctx);
-        assert_eq!(app.ui.theme, ThemeKind::Dark);
-        // A fixed mode ignores the system.
-        *system.lock().unwrap() = Some(egui::Theme::Light);
-        app.set_pref("appearance.appearanceMode", json!("dark")).unwrap();
-        app.apply_prefs(&ctx);
-        assert_eq!(app.ui.theme, ThemeKind::Dark);
-    }
-
-    /// Sync with System leaves egui's theme preference at System, so egui never gives the native
-    /// window an appearance of its own (on macOS that stops system appearance changes reaching
-    /// the app, #642); egui's light and dark styles both carry the resolved theme. Fixed modes
-    /// pin the window to their family.
-    #[test]
-    fn auto_mode_leaves_the_native_window_following_the_system() {
-        let ctx = egui::Context::default();
-        let mut app = app();
-        app.hooks.system_theme = Some(Box::new(|_| Some(egui::Theme::Light)));
-        app.set_pref("appearance.appearanceMode", json!("auto")).unwrap();
-        app.apply_prefs(&ctx);
-        assert_eq!(app.ui.theme, ThemeKind::Light);
-        assert_eq!(ctx.options(|o| o.theme_preference), egui::ThemePreference::System);
-        for theme in [egui::Theme::Light, egui::Theme::Dark] {
-            assert_eq!(ctx.style_of(theme).visuals.panel_fill, app.tokens.panel_bg, "{theme:?}");
-        }
-        // egui asks the window to follow the system, never to take Light or Dark.
-        let mut out = ctx.run_ui(egui::RawInput::default(), |_| {});
-        out.textures_delta.clear();
-        let cmds = out.viewport_output.values().flat_map(|v| v.commands.iter()).collect::<Vec<_>>();
-        assert!(!cmds.iter().any(|c| matches!(c, egui::ViewportCommand::SetTheme(t) if t != &egui::SystemTheme::SystemDefault)), "{cmds:?}");
-        for (mode, pref) in [("light", egui::ThemePreference::Light), ("dark", egui::ThemePreference::Dark)] {
-            app.set_pref("appearance.appearanceMode", json!(mode)).unwrap();
-            app.apply_prefs(&ctx);
-            assert_eq!(ctx.options(|o| o.theme_preference), pref, "{mode}");
-            assert_eq!(ctx.global_style().visuals.panel_fill, app.tokens.panel_bg, "{mode}");
-        }
-    }
-
-    /// Picking a theme (`view.theme.*`, `ui.set {theme}`) fixes the mode to its family.
-    #[test]
-    fn picking_a_theme_fixes_its_mode() {
-        let ctx = egui::Context::default();
-        let mut app = app();
-        app.set_pref("appearance.appearanceMode", json!("auto")).unwrap();
-        menus::invoke(&mut app, &ctx, "view.theme.light", json!({})).unwrap();
-        assert_eq!(app.session.prefs.appearance.appearance_mode, "light");
-        assert_eq!(app.ui.theme, ThemeKind::Light);
-        menus::invoke(&mut app, &ctx, "view.theme.darker", json!({})).unwrap();
-        assert_eq!(app.session.prefs.appearance.appearance_mode, "dark");
-        assert_eq!(app.session.prefs.appearance.dark_theme, "darker");
-        assert_eq!(app.ui.theme, ThemeKind::Darker);
-    }
-}
-
-#[cfg(test)]
-mod lifecycle_tests {
-    //! The logic-only / UI-pass split: queue work in `tick`, input, layout and setup in `draw`.
-    //!
-    //! The driver mirrors eframe's order for a hidden window: `raw_input_hook` prepares the raw
-    //! input, a logic-only iteration runs `tick`, and a forced pass runs `draw` with the same
-    //! prepared input. Nothing may depend on `current_pass_index`, which is zero in both.
-
-    use super::*;
-    use effectcraft_engine::config::{ConfigStore, MemoryConfig};
-
-    fn app_with_comp() -> EffectcraftApp {
-        let mut session = Session::default();
-        session.execute("comp.new", json!({"name": "Lifecycle", "width": 64, "height": 36, "duration": 1})).unwrap();
-        session.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
-        let mut app = EffectcraftApp::new(session);
-        app.ui.start_screen = false;
-        app.ui.show_menu_bar = false;
-        app.use_manual_clock();
-        app
-    }
-
-    fn raw(size: egui::Vec2) -> egui::RawInput {
-        egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), ..Default::default() }
-    }
-
-    fn tick_with(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, raw: &egui::RawInput) -> egui::LogicOutput {
-        ctx.run_logic(raw, |ctx| app.tick(ctx, frame))
-    }
-
-    fn hidden_tick(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) {
-        let _ = tick_with(app, ctx, frame, &raw(egui::vec2(800.0, 480.0)));
-    }
-
-    /// One host iteration that ends in a UI pass (the forced hidden pass, or a visible frame).
-    fn pass(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, raw: &mut egui::RawInput) -> egui::FullOutput {
-        eframe::App::raw_input_hook(app, ctx, raw);
-        let mut out = ctx.run_ui(raw.take(), |ui| app.draw(ui, frame));
-        out.textures_delta.clear();
-        out
-    }
-
-    fn ready(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) -> DrawGeometry {
-        // The first pass installs the fonts, the second draws with them.
-        for _ in 0..3 {
-            let mut raw = raw(egui::vec2(800.0, 480.0));
-            pass(app, ctx, frame, &mut raw);
-        }
-        assert!(app.is_ready(), "fonts are ready after the warm-up passes");
-        app.draw_geometry().expect("a completed pass records its geometry")
-    }
-
-    fn send(app: &mut EffectcraftApp, method: &str, params: serde_json::Value) -> std::sync::mpsc::Receiver<serde_json::Value> {
-        let (request, reply) = ControlRequest::new(method, params);
-        let (tx, rx) = std::sync::mpsc::channel();
-        tx.send(request).unwrap();
-        app.control_rx = Some(rx);
-        reply
-    }
-
-    #[test]
-    fn a_logic_only_tick_installs_no_fonts_and_records_no_geometry() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        hidden_tick(&mut app, &ctx, &frame);
-        assert!(!app.is_ready(), "fonts need a real pass, not a logic-only tick");
-        assert!(app.draw_geometry().is_none(), "a logic-only tick is not a frame");
-        assert_eq!(app.ui_passes(), 0);
-    }
-
-    #[test]
-    fn a_control_command_that_needs_no_ui_completes_without_a_pass() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        let reply = send(&mut app, "engine.execute", json!({"command": "comp.new", "params": {"name": "Queued", "width": 32, "height": 18, "duration": 1}}));
-        hidden_tick(&mut app, &ctx, &frame);
-        let value = reply.try_recv().expect("a command that needs no UI is answered by the tick");
-        assert_eq!(value["ok"], true, "{value}");
-        assert_eq!(app.ui_passes(), 0);
-    }
-
-    #[test]
-    fn a_pass_that_cannot_draw_receives_no_synthetic_input() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        assert!(!app.is_ready(), "a fresh app installs its fonts in its first pass");
-        let reply = send(&mut app, "ui.click", json!({"x": 40, "y": 40}));
-        hidden_tick(&mut app, &ctx, &frame);
-        assert!(reply.try_recv().is_err(), "a click is not answered before its UI pass");
-        // The font-install pass cannot draw. It must not receive the click: `run_ui` applies what
-        // the hook feeds, and a batch cannot be put back without applying its pointer state twice.
-        let mut setup = raw(egui::vec2(800.0, 480.0));
-        eframe::App::raw_input_hook(&mut app, &ctx, &mut setup);
-        assert!(setup.events.is_empty(), "a pass that cannot draw gets no synthetic input");
-        assert_eq!(app.synthetic.len(), 5, "the whole gesture still waits for a drawing pass");
-        assert!(app.pending_synthetic_events().is_empty());
-        let mut setup_pass = ctx.run_ui(setup.take(), |ui| app.draw(ui, &frame));
-        setup_pass.textures_delta.clear();
-        assert!(!app.is_ready(), "the pass that installs the fonts draws nothing");
-        // Once fonts are ready the click reaches the UI exactly once, one event per pass.
-        let mut passes = 0;
-        while reply.try_recv().is_err() {
-            passes += 1;
-            assert!(passes < 40, "the click must be applied within a few passes");
-            let mut raw = raw(egui::vec2(800.0, 480.0));
-            pass(&mut app, &ctx, &frame, &mut raw);
-        }
-        assert!(reply.try_recv().is_err(), "the reply is sent once");
-        assert!(app.pending_synthetic_events().is_empty());
-        assert!(app.synthetic.is_empty(), "every event was applied once");
-    }
-
-    #[test]
-    fn one_pending_synthetic_batch_is_never_duplicated_while_hidden() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        ready(&mut app, &ctx, &frame);
-        let reply = send(&mut app, "ui.click", json!({"x": 40, "y": 40}));
-        hidden_tick(&mut app, &ctx, &frame);
-        assert!(reply.try_recv().is_err(), "a click is not answered before its UI pass");
-        // Several hidden host iterations: eframe keeps the first prepared input; only its one
-        // event may reach the raw input, and a later hook must not add another.
-        let mut first = raw(egui::vec2(800.0, 480.0));
-        eframe::App::raw_input_hook(&mut app, &ctx, &mut first);
-        assert_eq!(first.events.len(), 1, "the first event of the gesture is fed");
-        let mut second = raw(egui::vec2(800.0, 480.0));
-        eframe::App::raw_input_hook(&mut app, &ctx, &mut second);
-        assert!(second.events.is_empty(), "an unapplied batch blocks the next event");
-        assert_eq!(app.pending_synthetic_events().len(), 1);
-        // The pass that applies the batch acknowledges it once; it is never fed again.
-        pass(&mut app, &ctx, &frame, &mut first);
-        assert!(app.pending_synthetic_events().is_empty());
-        // Drive real passes until the gesture is applied: exactly one reply, no lost events.
-        let mut passes = 0;
-        while reply.try_recv().is_err() {
-            passes += 1;
-            assert!(passes < 40, "the click must be applied within a few passes");
-            let mut raw = raw(egui::vec2(800.0, 480.0));
-            pass(&mut app, &ctx, &frame, &mut raw);
-        }
-        assert!(app.pending_synthetic_events().is_empty());
-        assert!(app.synthetic.is_empty());
-        assert!(reply.try_recv().is_err(), "the reply is sent once");
-    }
-
-    #[test]
-    fn geometry_epoch_tracks_size_and_scale_but_not_window_position() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        let first = ready(&mut app, &ctx, &frame);
-        let mut moved = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::pos2(120.0, 80.0), first.rect.size())), ..Default::default() };
-        pass(&mut app, &ctx, &frame, &mut moved);
-        assert_eq!(app.draw_geometry().unwrap().epoch, first.epoch, "moving the window does not change a capture");
-        let mut resized = raw(egui::vec2(1024.0, 640.0));
-        pass(&mut app, &ctx, &frame, &mut resized);
-        let after_resize = app.draw_geometry().unwrap();
-        assert!(after_resize.epoch > first.epoch, "a resize advances the epoch");
-        let mut back = raw(egui::vec2(800.0, 480.0));
-        pass(&mut app, &ctx, &frame, &mut back);
-        assert!(app.draw_geometry().unwrap().epoch > after_resize.epoch, "changing back is another change, not the old epoch");
-    }
-
-    #[test]
-    fn only_a_viewer_that_draws_records_a_prefetch_scale() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        ready(&mut app, &ctx, &frame);
-        assert!(app.last_viewer_scale.is_some(), "the visible viewer recorded the scale it drew at");
-        // The Home screen draws no viewer: the old comp's scale must not keep idle prefetch alive.
-        app.ui.start_screen = true;
-        let mut input = raw(egui::vec2(800.0, 480.0));
-        pass(&mut app, &ctx, &frame, &mut input);
-        assert!(app.last_viewer_scale.is_none(), "no viewer drew, so there is no scale to prefetch at");
-        // Back to the comp: the next pass records it again.
-        app.ui.start_screen = false;
-        let mut input = raw(egui::vec2(800.0, 480.0));
-        pass(&mut app, &ctx, &frame, &mut input);
-        assert!(app.last_viewer_scale.is_some());
-    }
-
-    #[test]
-    fn playback_advances_on_a_logic_only_tick() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        app.playback.playing = true;
-        app.playback.plan = Some(effectcraft_engine::preview::PreviewPlan {
-            start: 1,
-            end: 1,
-            first: 1,
-            step: 1,
-            fps: 24.0,
-            looping: false,
-            cache_first: false,
-            video: false,
-            audio: false,
-            origin: Tick::ZERO,
-        });
-        app.playback.start_wall = 0.0;
-        app.playback.start_frame = 1;
-        app.clock_mut().advance(1.0);
-        hidden_tick(&mut app, &ctx, &frame);
-        assert!(!app.playback.playing, "a one-frame preview ends without any UI pass");
-        assert_eq!(app.playback.audio_frame, Some(1), "the audio-only playhead reached the plan's end");
-        assert_eq!(app.ui_passes(), 0);
-    }
-
-    #[test]
-    fn workspace_layout_autosave_writes_on_a_hidden_tick() {
-        let store = Arc::new(MemoryConfig::default());
-        let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });
-        app.ui.start_screen = false;
-        app.use_manual_clock();
-        app.ui.focused = PanelKind::Timeline;
-        app.clock_mut().advance(2.0);
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        hidden_tick(&mut app, &ctx, &frame);
-        assert!(store.read(WORKSPACES_FILE).is_some(), "the layout is saved while the window is hidden");
-        assert_eq!(app.ui_passes(), 0);
-    }
-
-    #[test]
-    fn the_close_guard_answers_a_close_request_without_a_pass() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        assert!(app.session.is_dirty(), "creating a comp and a layer leaves unsaved changes");
-        let mut raw = raw(egui::vec2(800.0, 480.0));
-        raw.viewports.insert(egui::ViewportId::ROOT, egui::ViewportInfo { events: vec![egui::ViewportEvent::Close], ..Default::default() });
-        let out = tick_with(&mut app, &ctx, &frame, &raw);
-        assert!(app.dialog.is_some(), "a hidden close request opens the unsaved-changes prompt");
-        let cancel = out.viewport_commands.values().flatten().any(|c| matches!(c, egui::ViewportCommand::CancelClose));
-        assert!(cancel, "the window stays open while the prompt is asking");
-        assert_eq!(app.ui_passes(), 0);
-    }
-
-    // ---------------------------------------------------------------- screenshots
-
-    fn screenshot_request(
-        app: &mut EffectcraftApp,
-        ctx: &egui::Context,
-        path: Option<&str>,
-        target: ShotTarget,
-    ) -> std::sync::mpsc::Receiver<serde_json::Value> {
-        let (tx, rx) = std::sync::mpsc::channel();
-        app.admit_screenshot(ctx, path.map(str::to_string), target, tx);
-        rx
-    }
-
-    fn shot_callbacks(out: &egui::LogicOutput) -> Vec<egui::ScreenshotCallback> {
-        out.viewport_commands
-            .values()
-            .flatten()
-            .filter_map(|c| match c {
-                egui::ViewportCommand::Screenshot(cb) => Some(cb.clone()),
-                _ => None,
-            })
-            .collect()
-    }
-
-    /// Three settled passes and the settle delay, then the tick that issues the capture.
-    fn issue_shot(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) -> egui::ScreenshotCallback {
-        issue_shot_at(app, ctx, frame, egui::vec2(800.0, 480.0))
-    }
-
-    fn issue_shot_at(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, size: egui::Vec2) -> egui::ScreenshotCallback {
-        for _ in 0..SCREENSHOT_SETTLE_PASSES {
-            let mut raw = raw(size);
-            pass(app, ctx, frame, &mut raw);
-        }
-        app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);
-        let out = tick_with(app, ctx, frame, &raw(size));
-        let cbs = shot_callbacks(&out);
-        assert_eq!(cbs.len(), 1, "one settled screenshot is issued once");
-        cbs.into_iter().next().unwrap()
-    }
-
-    fn image(width: usize, height: usize) -> Arc<egui::ColorImage> {
-        Arc::new(egui::ColorImage::new([width, height], vec![egui::Color32::from_rgb(10, 20, 30); width.checked_mul(height).unwrap()]))
-    }
-
-    #[test]
-    fn a_screenshot_is_issued_only_after_settled_passes_and_writes_from_the_tick() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        ready(&mut app, &ctx, &frame);
-        let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-ok.png", std::process::id()));
-        let _ = std::fs::remove_file(&path);
-        let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);
-        // Not settled: a tick issues nothing and asks for passes instead.
-        let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));
-        assert!(shot_callbacks(&out).is_empty(), "no capture before the UI settles");
-        assert_eq!(out.viewport_commands.values().flatten().filter(|c| matches!(c, egui::ViewportCommand::RequestPaintWhileHidden)).count(), 1);
-        let cb = issue_shot(&mut app, &ctx, &frame);
-        assert!(reply.try_recv().is_err(), "the callback must not write or reply itself");
-        cb.complete(image(800, 480));
-        hidden_tick(&mut app, &ctx, &frame);
-        let value = reply.try_recv().expect("the tick drains the completed slot and replies");
-        assert_eq!(value["ok"], true, "{value}");
-        assert!(path.exists(), "{value}");
-        assert_eq!(value["result"]["width"], 800);
-        assert_eq!(value["result"]["height"], 480);
-        assert_eq!(app.shot_bytes, 0, "the reservation is released");
-        let _ = std::fs::remove_file(&path);
-    }
-
-    #[test]
-    fn a_resize_between_issue_and_completion_rejects_the_pixels_and_retries() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        ready(&mut app, &ctx, &frame);
-        let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-retry.png", std::process::id()));
-        let _ = std::fs::remove_file(&path);
-        let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);
-        let first = issue_shot(&mut app, &ctx, &frame);
-        let size = egui::vec2(1024.0, 640.0);
-        let mut resized = raw(size);
-        pass(&mut app, &ctx, &frame, &mut resized);
-        first.complete(image(800, 480));
-        let _ = tick_with(&mut app, &ctx, &frame, &raw(size));
-        assert!(reply.try_recv().is_err(), "pixels from the old surface epoch are discarded");
-        assert!(!path.exists(), "a stale image is never written");
-        // The retry is issued against the new geometry and the new image is accepted.
-        let second = issue_shot_at(&mut app, &ctx, &frame, size);
-        second.complete(image(1024, 640));
-        let _ = tick_with(&mut app, &ctx, &frame, &raw(size));
-        let value = reply.try_recv().expect("the retried capture replies");
-        assert_eq!(value["ok"], true, "{value}");
-        assert_eq!(value["result"]["width"], 1024);
-        let _ = std::fs::remove_file(&path);
-    }
-
-    #[test]
-    fn screenshot_admission_bounds_requests_and_a_timeout_releases_its_reservation() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        ready(&mut app, &ctx, &frame);
-        let mut replies = Vec::new();
-        for _ in 0..MAX_PENDING_SHOTS {
-            replies.push(screenshot_request(&mut app, &ctx, None, ShotTarget::Rect([0.0, 0.0, 4.0, 4.0])));
-        }
-        let refused = screenshot_request(&mut app, &ctx, None, ShotTarget::Rect([0.0, 0.0, 4.0, 4.0]));
-        let value = refused.try_recv().expect("the fifth request is refused immediately");
-        assert_eq!(value["ok"], false, "{value}");
-        // Every queued request times out on a hidden window that presents no frame; each one
-        // releases its reservation exactly once.
-        app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);
-        hidden_tick(&mut app, &ctx, &frame);
-        for reply in replies {
-            let value = reply.try_recv().expect("a timed-out request gets an actionable reply");
-            assert_eq!(value["ok"], false, "{value}");
-            assert!(value["error"].as_str().is_some_and(|e| e.contains("no frame")), "{value}");
-        }
-        assert_eq!(app.shot_bytes, 0);
-        assert!(app.pending_screenshots.is_empty());
-    }
-
-    #[test]
-    fn a_late_callback_after_cancellation_writes_nothing_and_replies_once() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        ready(&mut app, &ctx, &frame);
-        let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-late.png", std::process::id()));
-        let _ = std::fs::remove_file(&path);
-        let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);
-        let late = issue_shot(&mut app, &ctx, &frame);
-        app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);
-        hidden_tick(&mut app, &ctx, &frame);
-        let timeout = reply.try_recv().expect("the request times out");
-        assert_eq!(timeout["ok"], false, "{timeout}");
-        late.complete(image(800, 480));
-        hidden_tick(&mut app, &ctx, &frame);
-        assert!(reply.try_recv().is_err(), "a late completion sends no second reply");
-        assert!(!path.exists(), "a late completion writes no file");
-        assert_eq!(app.shot_bytes, 0);
-    }
-
-    /// Every repaint delay requested on `ctx` (what a host uses to wake the app).
-    fn wake_requests(ctx: &egui::Context) -> Arc<std::sync::Mutex<Vec<std::time::Duration>>> {
-        let wakes: Arc<std::sync::Mutex<Vec<std::time::Duration>>> = Arc::default();
-        let record = Arc::clone(&wakes);
-        ctx.set_repaint_observer(move |i| record.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push(i.delay));
-        wakes
-    }
-
-    #[test]
-    fn an_issued_capture_schedules_a_wake_up_for_its_deadline() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        ready(&mut app, &ctx, &frame);
-        let reply = screenshot_request(&mut app, &ctx, None, ShotTarget::Window);
-        for _ in 0..SCREENSHOT_SETTLE_PASSES {
-            let mut raw = raw(egui::vec2(800.0, 480.0));
-            pass(&mut app, &ctx, &frame, &mut raw);
-        }
-        app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);
-        // Record the repaint requests of the tick that issues the capture only.
-        let wakes = wake_requests(&ctx);
-        let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));
-        assert_eq!(shot_callbacks(&out).len(), 1, "the settled capture is issued once");
-        let delays = wakes.lock().unwrap_or_else(std::sync::PoisonError::into_inner).clone();
-        // The deadline is 8 s after admission; the capture was issued ~0.31 s in, so the app must
-        // ask for a wake-up close to that timeout, not only for the next paint.
-        let deadline_wake = delays.iter().any(|d| d.as_secs_f64() > 7.0 && d.as_secs_f64() <= SCREENSHOT_TIMEOUT_S);
-        assert!(deadline_wake, "an issued capture asks the host to wake for its timeout: {delays:?}");
-        // The callback never arrives (a hidden window or a display asleep). The host wakes at the
-        // requested delay; without this wake-up the timeout below could never be evaluated.
-        app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);
-        hidden_tick(&mut app, &ctx, &frame);
-        let value = reply.try_recv().expect("the deadline wake-up produces the timeout reply");
-        assert_eq!(value["ok"], false, "{value}");
-        assert!(value["error"].as_str().is_some_and(|e| e.contains("no frame")), "{value}");
-        assert_eq!(app.shot_bytes, 0);
-        assert!(app.pending_screenshots.is_empty());
-    }
-
-    #[test]
-    fn a_downscaled_capture_is_cropped_with_the_images_own_scale() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        let geom = ready(&mut app, &ctx, &frame);
-        assert_eq!((geom.rect.width(), geom.rect.height(), geom.ppp), (800.0, 480.0, 1.0));
-        // The adapter-limit fit (E2) returned half the requested pixels. Left red, right blue.
-        let fitted =
-            Arc::new(egui::ColorImage::new([400, 240], (0..400 * 240).map(|i| if i % 400 < 200 { egui::Color32::RED } else { egui::Color32::BLUE }).collect()));
-        let dir = std::env::temp_dir();
-        for (name, crop, want) in [("left", [0.0, 0.0, 400.0, 240.0], egui::Color32::RED), ("right", [400.0, 0.0, 400.0, 240.0], egui::Color32::BLUE)] {
-            let path = dir.join(format!("effectcraft-shot-{}-scale-{name}.png", std::process::id()));
-            let _ = std::fs::remove_file(&path);
-            let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Rect(crop));
-            let cb = issue_shot(&mut app, &ctx, &frame);
-            cb.complete(Arc::clone(&fitted));
-            hidden_tick(&mut app, &ctx, &frame);
-            let value = reply.try_recv().expect("the downscaled capture replies");
-            assert_eq!(value["ok"], true, "{value}");
-            assert_eq!(value["result"]["width"], 200, "{value}");
-            assert_eq!(value["result"]["height"], 120, "{value}");
-            let png = std::fs::read(&path).expect("the PNG is written");
-            let decoded = image::load_from_memory(&png).expect("our PNG decodes").to_rgba8();
-            assert_eq!((decoded.width(), decoded.height()), (200, 120), "{value}");
-            let px = decoded.get_pixel(100, 60).0;
-            assert!(px[0] == want.r() && px[1] == want.g() && px[2] == want.b(), "{name}: {px:?} is not from its half of the fitted image");
-            let _ = std::fs::remove_file(&path);
-        }
-    }
-
-    #[test]
-    fn a_capture_before_any_pass_never_uses_the_window_frame_rect() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        // Only the outer (title bar included) rectangle is known: it is not the captured surface.
-        let outer = egui::Rect::from_min_size(egui::pos2(0.0, -30.0), egui::vec2(800.0, 510.0));
-        let mut raw = egui::RawInput::default();
-        raw.viewports.insert(egui::ViewportId::ROOT, egui::ViewportInfo { outer_rect: Some(outer), ..Default::default() });
-        let _ = tick_with(&mut app, &ctx, &frame, &raw);
-        let (tx, reply) = std::sync::mpsc::channel();
-        app.admit_screenshot(&ctx, None, ShotTarget::Window, tx);
-        let value = reply.try_recv().expect("the request is answered now");
-        assert_eq!(value["ok"], false, "{value}");
-        assert!(value["error"].as_str().is_some_and(|e| e.contains("geometry is not known")), "{value}");
-        assert!(app.pending_screenshots.is_empty(), "nothing was reserved against the wrong rectangle");
-        assert_eq!(app.shot_bytes, 0);
-        assert!(app.want_paint, "the pass that records the geometry is requested");
-    }
-
-    #[test]
-    fn an_element_that_moves_while_the_ui_settles_is_captured_where_it_is() {
-        let ctx = egui::Context::default();
-        let frame = eframe::Frame::_new_kittest();
-        let mut app = app_with_comp();
-        let geom = ready(&mut app, &ctx, &frame);
-        // Any registered panel: the crop follows this element's rectangle.
-        let panel = app.auto.previous.iter().chain(app.auto.elements.iter()).find(|e| e.id.starts_with("panel.")).map(|e| e.id.clone());
-        let panel = panel.expect("a dock panel is on screen after a completed pass");
-        let reply = screenshot_request(&mut app, &ctx, None, ShotTarget::Id(panel.clone()));
-        for _ in 0..SCREENSHOT_SETTLE_PASSES {
-            let mut raw = raw(egui::vec2(800.0, 480.0));
-            pass(&mut app, &ctx, &frame, &mut raw);
-        }
-        // The panel moves after its last draw: the crop must follow it, not the admission rect.
-        let moved = [40.0, 30.0, 300.0, 200.0];
-        for list in [&mut app.auto.previous, &mut app.auto.elements] {
-            if let Some(e) = list.iter_mut().find(|e| e.id == panel) {
-                e.rect = moved;
-            }
-        }
-        app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);
-        let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));
-        assert_eq!(shot_callbacks(&out).len(), 1, "the settled capture is issued once");
-        let crop = app.pending_screenshots.first().and_then(|s| s.crop).expect("the element crop is resolved at issuance");
-        assert!((crop[0] - (moved[0] - geom.rect.min.x)).abs() < 0.01, "{crop:?}");
-        assert!((crop[1] - (moved[1] - geom.rect.min.y)).abs() < 0.01, "{crop:?}");
-        assert!((crop[2] - moved[2]).abs() < 0.01 && (crop[3] - moved[3]).abs() < 0.01, "{crop:?}");
-        // Let it complete and reply, so the request does not outlive the test.
-        if let Some(cb) = shot_callbacks(&out).into_iter().next() {
-            cb.complete(image(800, 480));
-        }
-        hidden_tick(&mut app, &ctx, &frame);
-        let value = reply.try_recv().expect("the capture replies");
-        assert_eq!(value["ok"], true, "{value}");
-        assert_eq!((value["result"]["width"].as_u64(), value["result"]["height"].as_u64()), (Some(300), Some(200)), "{value}");
-    }
-}
+mod lifecycle_tests;
diff --git a/crates/ui-egui/src/lifecycle_tests.rs b/crates/ui-egui/src/lifecycle_tests.rs
new file mode 100644
index 000000000..6c9eb85d2
--- /dev/null
+++ b/crates/ui-egui/src/lifecycle_tests.rs
@@ -0,0 +1,509 @@
+//! The logic-only / UI-pass split: queue work in `tick`, input, layout and setup in `draw`.
+//!
+//! The driver mirrors eframe's order for a hidden window: `raw_input_hook` prepares the raw
+//! input, a logic-only iteration runs `tick`, and a forced pass runs `draw` with the same
+//! prepared input. Nothing may depend on `current_pass_index`, which is zero in both.
+
+use super::*;
+use effectcraft_engine::config::{ConfigStore, MemoryConfig};
+
+fn app_with_comp() -> EffectcraftApp {
+    let mut session = Session::default();
+    session.execute("comp.new", json!({"name": "Lifecycle", "width": 64, "height": 36, "duration": 1})).unwrap();
+    session.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
+    let mut app = EffectcraftApp::new(session);
+    app.ui.start_screen = false;
+    app.ui.show_menu_bar = false;
+    app.use_manual_clock();
+    app
+}
+
+fn raw(size: egui::Vec2) -> egui::RawInput {
+    egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, size)), ..Default::default() }
+}
+
+fn tick_with(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, raw: &egui::RawInput) -> egui::LogicOutput {
+    ctx.run_logic(raw, |ctx| app.tick(ctx, frame))
+}
+
+fn hidden_tick(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) {
+    let _ = tick_with(app, ctx, frame, &raw(egui::vec2(800.0, 480.0)));
+}
+
+/// One host iteration that ends in a UI pass (the forced hidden pass, or a visible frame).
+fn pass(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, raw: &mut egui::RawInput) -> egui::FullOutput {
+    eframe::App::raw_input_hook(app, ctx, raw);
+    let mut out = ctx.run_ui(raw.take(), |ui| app.draw(ui, frame));
+    out.textures_delta.clear();
+    out
+}
+
+fn ready(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) -> DrawGeometry {
+    // The first pass installs the fonts, the second draws with them.
+    for _ in 0..3 {
+        let mut raw = raw(egui::vec2(800.0, 480.0));
+        pass(app, ctx, frame, &mut raw);
+    }
+    assert!(app.is_ready(), "fonts are ready after the warm-up passes");
+    app.draw_geometry().expect("a completed pass records its geometry")
+}
+
+fn send(app: &mut EffectcraftApp, method: &str, params: serde_json::Value) -> std::sync::mpsc::Receiver<serde_json::Value> {
+    let (request, reply) = ControlRequest::new(method, params);
+    let (tx, rx) = std::sync::mpsc::channel();
+    tx.send(request).unwrap();
+    app.control_rx = Some(rx);
+    reply
+}
+
+#[test]
+fn a_logic_only_tick_installs_no_fonts_and_records_no_geometry() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    hidden_tick(&mut app, &ctx, &frame);
+    assert!(!app.is_ready(), "fonts need a real pass, not a logic-only tick");
+    assert!(app.draw_geometry().is_none(), "a logic-only tick is not a frame");
+    assert_eq!(app.ui_passes(), 0);
+}
+
+#[test]
+fn a_control_command_that_needs_no_ui_completes_without_a_pass() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    let reply = send(&mut app, "engine.execute", json!({"command": "comp.new", "params": {"name": "Queued", "width": 32, "height": 18, "duration": 1}}));
+    hidden_tick(&mut app, &ctx, &frame);
+    let value = reply.try_recv().expect("a command that needs no UI is answered by the tick");
+    assert_eq!(value["ok"], true, "{value}");
+    assert_eq!(app.ui_passes(), 0);
+}
+
+#[test]
+fn a_pass_that_cannot_draw_receives_no_synthetic_input() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    assert!(!app.is_ready(), "a fresh app installs its fonts in its first pass");
+    let reply = send(&mut app, "ui.click", json!({"x": 40, "y": 40}));
+    hidden_tick(&mut app, &ctx, &frame);
+    assert!(reply.try_recv().is_err(), "a click is not answered before its UI pass");
+    // The font-install pass cannot draw. It must not receive the click: `run_ui` applies what
+    // the hook feeds, and a batch cannot be put back without applying its pointer state twice.
+    let mut setup = raw(egui::vec2(800.0, 480.0));
+    eframe::App::raw_input_hook(&mut app, &ctx, &mut setup);
+    assert!(setup.events.is_empty(), "a pass that cannot draw gets no synthetic input");
+    assert_eq!(app.synthetic.len(), 5, "the whole gesture still waits for a drawing pass");
+    assert!(app.pending_synthetic_events().is_empty());
+    let mut setup_pass = ctx.run_ui(setup.take(), |ui| app.draw(ui, &frame));
+    setup_pass.textures_delta.clear();
+    assert!(!app.is_ready(), "the pass that installs the fonts draws nothing");
+    // Once fonts are ready the click reaches the UI exactly once, one event per pass.
+    let mut passes = 0;
+    while reply.try_recv().is_err() {
+        passes += 1;
+        assert!(passes < 40, "the click must be applied within a few passes");
+        let mut raw = raw(egui::vec2(800.0, 480.0));
+        pass(&mut app, &ctx, &frame, &mut raw);
+    }
+    assert!(reply.try_recv().is_err(), "the reply is sent once");
+    assert!(app.pending_synthetic_events().is_empty());
+    assert!(app.synthetic.is_empty(), "every event was applied once");
+}
+
+#[test]
+fn one_pending_synthetic_batch_is_never_duplicated_while_hidden() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    ready(&mut app, &ctx, &frame);
+    let reply = send(&mut app, "ui.click", json!({"x": 40, "y": 40}));
+    hidden_tick(&mut app, &ctx, &frame);
+    assert!(reply.try_recv().is_err(), "a click is not answered before its UI pass");
+    // Several hidden host iterations: eframe keeps the first prepared input; only its one
+    // event may reach the raw input, and a later hook must not add another.
+    let mut first = raw(egui::vec2(800.0, 480.0));
+    eframe::App::raw_input_hook(&mut app, &ctx, &mut first);
+    assert_eq!(first.events.len(), 1, "the first event of the gesture is fed");
+    let mut second = raw(egui::vec2(800.0, 480.0));
+    eframe::App::raw_input_hook(&mut app, &ctx, &mut second);
+    assert!(second.events.is_empty(), "an unapplied batch blocks the next event");
+    assert_eq!(app.pending_synthetic_events().len(), 1);
+    // The pass that applies the batch acknowledges it once; it is never fed again.
+    pass(&mut app, &ctx, &frame, &mut first);
+    assert!(app.pending_synthetic_events().is_empty());
+    // Drive real passes until the gesture is applied: exactly one reply, no lost events.
+    let mut passes = 0;
+    while reply.try_recv().is_err() {
+        passes += 1;
+        assert!(passes < 40, "the click must be applied within a few passes");
+        let mut raw = raw(egui::vec2(800.0, 480.0));
+        pass(&mut app, &ctx, &frame, &mut raw);
+    }
+    assert!(app.pending_synthetic_events().is_empty());
+    assert!(app.synthetic.is_empty());
+    assert!(reply.try_recv().is_err(), "the reply is sent once");
+}
+
+#[test]
+fn geometry_epoch_tracks_size_and_scale_but_not_window_position() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    let first = ready(&mut app, &ctx, &frame);
+    let mut moved = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::pos2(120.0, 80.0), first.rect.size())), ..Default::default() };
+    pass(&mut app, &ctx, &frame, &mut moved);
+    assert_eq!(app.draw_geometry().unwrap().epoch, first.epoch, "moving the window does not change a capture");
+    let mut resized = raw(egui::vec2(1024.0, 640.0));
+    pass(&mut app, &ctx, &frame, &mut resized);
+    let after_resize = app.draw_geometry().unwrap();
+    assert!(after_resize.epoch > first.epoch, "a resize advances the epoch");
+    let mut back = raw(egui::vec2(800.0, 480.0));
+    pass(&mut app, &ctx, &frame, &mut back);
+    assert!(app.draw_geometry().unwrap().epoch > after_resize.epoch, "changing back is another change, not the old epoch");
+}
+
+#[test]
+fn only_a_viewer_that_draws_records_a_prefetch_scale() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    ready(&mut app, &ctx, &frame);
+    assert!(app.last_viewer_scale.is_some(), "the visible viewer recorded the scale it drew at");
+    // The Home screen draws no viewer: the old comp's scale must not keep idle prefetch alive.
+    app.ui.start_screen = true;
+    let mut input = raw(egui::vec2(800.0, 480.0));
+    pass(&mut app, &ctx, &frame, &mut input);
+    assert!(app.last_viewer_scale.is_none(), "no viewer drew, so there is no scale to prefetch at");
+    // Back to the comp: the next pass records it again.
+    app.ui.start_screen = false;
+    let mut input = raw(egui::vec2(800.0, 480.0));
+    pass(&mut app, &ctx, &frame, &mut input);
+    assert!(app.last_viewer_scale.is_some());
+}
+
+#[test]
+fn playback_advances_on_a_logic_only_tick() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    app.playback.playing = true;
+    app.playback.plan = Some(effectcraft_engine::preview::PreviewPlan {
+        start: 1,
+        end: 1,
+        first: 1,
+        step: 1,
+        fps: 24.0,
+        looping: false,
+        cache_first: false,
+        video: false,
+        audio: false,
+        origin: Tick::ZERO,
+    });
+    app.playback.start_wall = 0.0;
+    app.playback.start_frame = 1;
+    app.clock_mut().advance(1.0);
+    hidden_tick(&mut app, &ctx, &frame);
+    assert!(!app.playback.playing, "a one-frame preview ends without any UI pass");
+    assert_eq!(app.playback.audio_frame, Some(1), "the audio-only playhead reached the plan's end");
+    assert_eq!(app.ui_passes(), 0);
+}
+
+#[test]
+fn workspace_layout_autosave_writes_on_a_hidden_tick() {
+    let store = Arc::new(MemoryConfig::default());
+    let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });
+    app.ui.start_screen = false;
+    app.use_manual_clock();
+    app.ui.focused = PanelKind::Timeline;
+    app.clock_mut().advance(2.0);
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    hidden_tick(&mut app, &ctx, &frame);
+    assert!(store.read(WORKSPACES_FILE).is_some(), "the layout is saved while the window is hidden");
+    assert_eq!(app.ui_passes(), 0);
+}
+
+#[test]
+fn the_close_guard_answers_a_close_request_without_a_pass() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    assert!(app.session.is_dirty(), "creating a comp and a layer leaves unsaved changes");
+    let mut raw = raw(egui::vec2(800.0, 480.0));
+    raw.viewports.insert(egui::ViewportId::ROOT, egui::ViewportInfo { events: vec![egui::ViewportEvent::Close], ..Default::default() });
+    let out = tick_with(&mut app, &ctx, &frame, &raw);
+    assert!(app.dialog.is_some(), "a hidden close request opens the unsaved-changes prompt");
+    let cancel = out.viewport_commands.values().flatten().any(|c| matches!(c, egui::ViewportCommand::CancelClose));
+    assert!(cancel, "the window stays open while the prompt is asking");
+    assert_eq!(app.ui_passes(), 0);
+}
+
+// ---------------------------------------------------------------- screenshots
+
+fn screenshot_request(app: &mut EffectcraftApp, ctx: &egui::Context, path: Option<&str>, target: ShotTarget) -> std::sync::mpsc::Receiver<serde_json::Value> {
+    let (tx, rx) = std::sync::mpsc::channel();
+    app.admit_screenshot(ctx, path.map(str::to_string), target, tx);
+    rx
+}
+
+fn shot_callbacks(out: &egui::LogicOutput) -> Vec<egui::ScreenshotCallback> {
+    out.viewport_commands
+        .values()
+        .flatten()
+        .filter_map(|c| match c {
+            egui::ViewportCommand::Screenshot(cb) => Some(cb.clone()),
+            _ => None,
+        })
+        .collect()
+}
+
+/// Three settled passes and the settle delay, then the tick that issues the capture.
+fn issue_shot(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame) -> egui::ScreenshotCallback {
+    issue_shot_at(app, ctx, frame, egui::vec2(800.0, 480.0))
+}
+
+fn issue_shot_at(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, size: egui::Vec2) -> egui::ScreenshotCallback {
+    for _ in 0..SCREENSHOT_SETTLE_PASSES {
+        let mut raw = raw(size);
+        pass(app, ctx, frame, &mut raw);
+    }
+    app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);
+    let out = tick_with(app, ctx, frame, &raw(size));
+    let cbs = shot_callbacks(&out);
+    assert_eq!(cbs.len(), 1, "one settled screenshot is issued once");
+    cbs.into_iter().next().unwrap()
+}
+
+fn image(width: usize, height: usize) -> Arc<egui::ColorImage> {
+    Arc::new(egui::ColorImage::new([width, height], vec![egui::Color32::from_rgb(10, 20, 30); width.checked_mul(height).unwrap()]))
+}
+
+#[test]
+fn a_screenshot_is_issued_only_after_settled_passes_and_writes_from_the_tick() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    ready(&mut app, &ctx, &frame);
+    let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-ok.png", std::process::id()));
+    let _ = std::fs::remove_file(&path);
+    let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);
+    // Not settled: a tick issues nothing and asks for passes instead.
+    let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));
+    assert!(shot_callbacks(&out).is_empty(), "no capture before the UI settles");
+    assert_eq!(out.viewport_commands.values().flatten().filter(|c| matches!(c, egui::ViewportCommand::RequestPaintWhileHidden)).count(), 1);
+    let cb = issue_shot(&mut app, &ctx, &frame);
+    assert!(reply.try_recv().is_err(), "the callback must not write or reply itself");
+    cb.complete(image(800, 480));
+    hidden_tick(&mut app, &ctx, &frame);
+    let value = reply.try_recv().expect("the tick drains the completed slot and replies");
+    assert_eq!(value["ok"], true, "{value}");
+    assert!(path.exists(), "{value}");
+    assert_eq!(value["result"]["width"], 800);
+    assert_eq!(value["result"]["height"], 480);
+    assert_eq!(app.shot_bytes, 0, "the reservation is released");
+    let _ = std::fs::remove_file(&path);
+}
+
+#[test]
+fn a_resize_between_issue_and_completion_rejects_the_pixels_and_retries() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    ready(&mut app, &ctx, &frame);
+    let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-retry.png", std::process::id()));
+    let _ = std::fs::remove_file(&path);
+    let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);
+    let first = issue_shot(&mut app, &ctx, &frame);
+    let size = egui::vec2(1024.0, 640.0);
+    let mut resized = raw(size);
+    pass(&mut app, &ctx, &frame, &mut resized);
+    first.complete(image(800, 480));
+    let _ = tick_with(&mut app, &ctx, &frame, &raw(size));
+    assert!(reply.try_recv().is_err(), "pixels from the old surface epoch are discarded");
+    assert!(!path.exists(), "a stale image is never written");
+    // The retry is issued against the new geometry and the new image is accepted.
+    let second = issue_shot_at(&mut app, &ctx, &frame, size);
+    second.complete(image(1024, 640));
+    let _ = tick_with(&mut app, &ctx, &frame, &raw(size));
+    let value = reply.try_recv().expect("the retried capture replies");
+    assert_eq!(value["ok"], true, "{value}");
+    assert_eq!(value["result"]["width"], 1024);
+    let _ = std::fs::remove_file(&path);
+}
+
+#[test]
+fn screenshot_admission_bounds_requests_and_a_timeout_releases_its_reservation() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    ready(&mut app, &ctx, &frame);
+    let mut replies = Vec::new();
+    for _ in 0..MAX_PENDING_SHOTS {
+        replies.push(screenshot_request(&mut app, &ctx, None, ShotTarget::Rect([0.0, 0.0, 4.0, 4.0])));
+    }
+    let refused = screenshot_request(&mut app, &ctx, None, ShotTarget::Rect([0.0, 0.0, 4.0, 4.0]));
+    let value = refused.try_recv().expect("the fifth request is refused immediately");
+    assert_eq!(value["ok"], false, "{value}");
+    // Every queued request times out on a hidden window that presents no frame; each one
+    // releases its reservation exactly once.
+    app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);
+    hidden_tick(&mut app, &ctx, &frame);
+    for reply in replies {
+        let value = reply.try_recv().expect("a timed-out request gets an actionable reply");
+        assert_eq!(value["ok"], false, "{value}");
+        assert!(value["error"].as_str().is_some_and(|e| e.contains("no frame")), "{value}");
+    }
+    assert_eq!(app.shot_bytes, 0);
+    assert!(app.pending_screenshots.is_empty());
+}
+
+#[test]
+fn a_late_callback_after_cancellation_writes_nothing_and_replies_once() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    ready(&mut app, &ctx, &frame);
+    let path = std::env::temp_dir().join(format!("effectcraft-shot-{}-late.png", std::process::id()));
+    let _ = std::fs::remove_file(&path);
+    let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Window);
+    let late = issue_shot(&mut app, &ctx, &frame);
+    app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);
+    hidden_tick(&mut app, &ctx, &frame);
+    let timeout = reply.try_recv().expect("the request times out");
+    assert_eq!(timeout["ok"], false, "{timeout}");
+    late.complete(image(800, 480));
+    hidden_tick(&mut app, &ctx, &frame);
+    assert!(reply.try_recv().is_err(), "a late completion sends no second reply");
+    assert!(!path.exists(), "a late completion writes no file");
+    assert_eq!(app.shot_bytes, 0);
+}
+
+/// Every repaint delay requested on `ctx` (what a host uses to wake the app).
+fn wake_requests(ctx: &egui::Context) -> Arc<std::sync::Mutex<Vec<std::time::Duration>>> {
+    let wakes: Arc<std::sync::Mutex<Vec<std::time::Duration>>> = Arc::default();
+    let record = Arc::clone(&wakes);
+    ctx.set_repaint_observer(move |i| record.lock().unwrap_or_else(std::sync::PoisonError::into_inner).push(i.delay));
+    wakes
+}
+
+#[test]
+fn an_issued_capture_schedules_a_wake_up_for_its_deadline() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    ready(&mut app, &ctx, &frame);
+    let reply = screenshot_request(&mut app, &ctx, None, ShotTarget::Window);
+    for _ in 0..SCREENSHOT_SETTLE_PASSES {
+        let mut raw = raw(egui::vec2(800.0, 480.0));
+        pass(&mut app, &ctx, &frame, &mut raw);
+    }
+    app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);
+    // Record the repaint requests of the tick that issues the capture only.
+    let wakes = wake_requests(&ctx);
+    let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));
+    assert_eq!(shot_callbacks(&out).len(), 1, "the settled capture is issued once");
+    let delays = wakes.lock().unwrap_or_else(std::sync::PoisonError::into_inner).clone();
+    // The deadline is 8 s after admission; the capture was issued ~0.31 s in, so the app must
+    // ask for a wake-up close to that timeout, not only for the next paint.
+    let deadline_wake = delays.iter().any(|d| d.as_secs_f64() > 7.0 && d.as_secs_f64() <= SCREENSHOT_TIMEOUT_S);
+    assert!(deadline_wake, "an issued capture asks the host to wake for its timeout: {delays:?}");
+    // The callback never arrives (a hidden window or a display asleep). The host wakes at the
+    // requested delay; without this wake-up the timeout below could never be evaluated.
+    app.clock_mut().advance(SCREENSHOT_TIMEOUT_S + 1.0);
+    hidden_tick(&mut app, &ctx, &frame);
+    let value = reply.try_recv().expect("the deadline wake-up produces the timeout reply");
+    assert_eq!(value["ok"], false, "{value}");
+    assert!(value["error"].as_str().is_some_and(|e| e.contains("no frame")), "{value}");
+    assert_eq!(app.shot_bytes, 0);
+    assert!(app.pending_screenshots.is_empty());
+}
+
+#[test]
+fn a_downscaled_capture_is_cropped_with_the_images_own_scale() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    let geom = ready(&mut app, &ctx, &frame);
+    assert_eq!((geom.rect.width(), geom.rect.height(), geom.ppp), (800.0, 480.0, 1.0));
+    // The adapter-limit fit (E2) returned half the requested pixels. Left red, right blue.
+    let fitted =
+        Arc::new(egui::ColorImage::new([400, 240], (0..400 * 240).map(|i| if i % 400 < 200 { egui::Color32::RED } else { egui::Color32::BLUE }).collect()));
+    let dir = std::env::temp_dir();
+    for (name, crop, want) in [("left", [0.0, 0.0, 400.0, 240.0], egui::Color32::RED), ("right", [400.0, 0.0, 400.0, 240.0], egui::Color32::BLUE)] {
+        let path = dir.join(format!("effectcraft-shot-{}-scale-{name}.png", std::process::id()));
+        let _ = std::fs::remove_file(&path);
+        let reply = screenshot_request(&mut app, &ctx, path.to_str(), ShotTarget::Rect(crop));
+        let cb = issue_shot(&mut app, &ctx, &frame);
+        cb.complete(Arc::clone(&fitted));
+        hidden_tick(&mut app, &ctx, &frame);
+        let value = reply.try_recv().expect("the downscaled capture replies");
+        assert_eq!(value["ok"], true, "{value}");
+        assert_eq!(value["result"]["width"], 200, "{value}");
+        assert_eq!(value["result"]["height"], 120, "{value}");
+        let png = std::fs::read(&path).expect("the PNG is written");
+        let decoded = image::load_from_memory(&png).expect("our PNG decodes").to_rgba8();
+        assert_eq!((decoded.width(), decoded.height()), (200, 120), "{value}");
+        let px = decoded.get_pixel(100, 60).0;
+        assert!(px[0] == want.r() && px[1] == want.g() && px[2] == want.b(), "{name}: {px:?} is not from its half of the fitted image");
+        let _ = std::fs::remove_file(&path);
+    }
+}
+
+#[test]
+fn a_capture_before_any_pass_never_uses_the_window_frame_rect() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    // Only the outer (title bar included) rectangle is known: it is not the captured surface.
+    let outer = egui::Rect::from_min_size(egui::pos2(0.0, -30.0), egui::vec2(800.0, 510.0));
+    let mut raw = egui::RawInput::default();
+    raw.viewports.insert(egui::ViewportId::ROOT, egui::ViewportInfo { outer_rect: Some(outer), ..Default::default() });
+    let _ = tick_with(&mut app, &ctx, &frame, &raw);
+    let (tx, reply) = std::sync::mpsc::channel();
+    app.admit_screenshot(&ctx, None, ShotTarget::Window, tx);
+    let value = reply.try_recv().expect("the request is answered now");
+    assert_eq!(value["ok"], false, "{value}");
+    assert!(value["error"].as_str().is_some_and(|e| e.contains("geometry is not known")), "{value}");
+    assert!(app.pending_screenshots.is_empty(), "nothing was reserved against the wrong rectangle");
+    assert_eq!(app.shot_bytes, 0);
+    assert!(app.want_paint, "the pass that records the geometry is requested");
+}
+
+#[test]
+fn an_element_that_moves_while_the_ui_settles_is_captured_where_it_is() {
+    let ctx = egui::Context::default();
+    let frame = eframe::Frame::_new_kittest();
+    let mut app = app_with_comp();
+    let geom = ready(&mut app, &ctx, &frame);
+    // Any registered panel: the crop follows this element's rectangle.
+    let panel = app.auto.previous.iter().chain(app.auto.elements.iter()).find(|e| e.id.starts_with("panel.")).map(|e| e.id.clone());
+    let panel = panel.expect("a dock panel is on screen after a completed pass");
+    let reply = screenshot_request(&mut app, &ctx, None, ShotTarget::Id(panel.clone()));
+    for _ in 0..SCREENSHOT_SETTLE_PASSES {
+        let mut raw = raw(egui::vec2(800.0, 480.0));
+        pass(&mut app, &ctx, &frame, &mut raw);
+    }
+    // The panel moves after its last draw: the crop must follow it, not the admission rect.
+    let moved = [40.0, 30.0, 300.0, 200.0];
+    for list in [&mut app.auto.previous, &mut app.auto.elements] {
+        if let Some(e) = list.iter_mut().find(|e| e.id == panel) {
+            e.rect = moved;
+        }
+    }
+    app.clock_mut().advance(SCREENSHOT_SETTLE_S + 0.01);
+    let out = tick_with(&mut app, &ctx, &frame, &raw(egui::vec2(800.0, 480.0)));
+    assert_eq!(shot_callbacks(&out).len(), 1, "the settled capture is issued once");
+    let crop = app.pending_screenshots.first().and_then(|s| s.crop).expect("the element crop is resolved at issuance");
+    assert!((crop[0] - (moved[0] - geom.rect.min.x)).abs() < 0.01, "{crop:?}");
+    assert!((crop[1] - (moved[1] - geom.rect.min.y)).abs() < 0.01, "{crop:?}");
+    assert!((crop[2] - moved[2]).abs() < 0.01 && (crop[3] - moved[3]).abs() < 0.01, "{crop:?}");
+    // Let it complete and reply, so the request does not outlive the test.
+    if let Some(cb) = shot_callbacks(&out).into_iter().next() {
+        cb.complete(image(800, 480));
+    }
+    hidden_tick(&mut app, &ctx, &frame);
+    let value = reply.try_recv().expect("the capture replies");
+    assert_eq!(value["ok"], true, "{value}");
+    assert_eq!((value["result"]["width"].as_u64(), value["result"]["height"].as_u64()), (Some(300), Some(200)), "{value}");
+}
diff --git a/crates/ui-egui/src/menu_keys.rs b/crates/ui-egui/src/menu_keys.rs
index 71e3b6425..49d07301c 100644
--- a/crates/ui-egui/src/menu_keys.rs
+++ b/crates/ui-egui/src/menu_keys.rs
@@ -60,15 +60,24 @@ struct KeyOpened {
     pointer: Option<Pos2>,
 }
 
+/// The temp-data id of the [`FirstEntry`] depth to highlight after a keyboard-opened menu is
+/// first drawn.
 fn pending_id() -> Id {
     Id::unique("menu-keys-first")
 }
+
+/// The temp-data id of the [`KeyOpened`] record: submenus opened from the keyboard and the
+/// pointer position they were opened at.
 fn opened_id() -> Id {
     Id::unique("menu-keys-opened")
 }
+
+/// The temp-data id of the flag saying the menu bar currently holds the keyboard.
 fn active_id() -> Id {
     Id::unique("menu-keys-active")
 }
+
+/// The temp-data id of the `(armed, held)` Alt-key state used to detect an Alt tap.
 fn alt_id() -> Id {
     Id::unique("menu-keys-alt")
 }
diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs
index 2e7b32931..cb28b0bcd 100644
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@ -8,10 +8,31 @@
 use serde_json::{Value, json};
 
 use crate::EffectcraftApp;
-use crate::dock::PanelKind;
+use crate::dock::{PanelKind, WorkspaceExt as _};
 use crate::state::{Resolution, Tool};
 use effectcraft_engine::menus::{MenuEntry, MenuNode};
 
+mod bar;
+mod commands;
+mod entries;
+mod frontend;
+mod invoke;
+mod shortcuts;
+
+pub use bar::menu_bar;
+pub(crate) use bar::{dyn_ctx, entry_for, menu_contents, submenu_at};
+pub use commands::UI_COMMANDS;
+pub use entries::{MenuItem, menu_items, menus};
+pub(crate) use entries::{entry_checked, entry_enabled, entry_label, entry_shortcut, menu_choice, panel_shown};
+pub use frontend::frontend;
+#[cfg(test)]
+use frontend::zoom_step;
+pub(crate) use frontend::{dialog_answered, run_engine};
+pub use invoke::{invoke, panel_command_id, reveal};
+#[cfg(test)]
+use shortcuts::modifiers_at_start;
+pub use shortcuts::{Binding, bindings, chord_matches, forwardable_during_text_edit, handle_shortcuts, handle_tab_shortcut, parse_shortcut, shortcut_text};
+
 pub struct UiCommand {
     pub id: &'static str,
     pub label: &'static str,
@@ -19,2710 +40,5 @@ pub struct UiCommand {
     pub shortcut: Option<&'static str>,
 }
 
-macro_rules! uic {
-    ($id:literal, $label:literal, [$($m:literal),*], $sc:expr) => {
-        UiCommand { id: $id, label: $label, menu: &[$($m),*], shortcut: $sc }
-    };
-}
-
-/// UI-only commands (not in the AE menus; shortcuts and the command palette).
-pub const UI_COMMANDS: &[UiCommand] = &[
-    uic!("window.dockAction", "Docking Action", [], None),
-    uic!("playback.ramPreview", "Preview (Numpad 0)", [], Some("Num0")),
-    uic!("playback.preview.shiftSpacebar", "Preview (Shift+Spacebar)", [], Some("Shift+Space")),
-    uic!("playback.preview.shiftNumpad0", "Preview (Shift+Numpad 0)", [], Some("Shift+Num0")),
-    uic!("playback.preview.altNumpad0", "Preview (Alt+Numpad 0)", [], Some("Alt+Num0")),
-    uic!("playback.stop", "Stop", [], None),
-    uic!("view.fit", "Fit", [], Some("Shift+/")),
-    uic!("view.actualSize", "100%", [], Some("/")),
-    uic!("view.fitUpTo100", "Fit up to 100%", [], Some("Alt+/")),
-    uic!("view.nextItem", "Next Composition in Viewer", [], Some("Shift+.")),
-    uic!("view.previousItem", "Previous Composition in Viewer", [], Some("Shift+,")),
-    uic!("viewer.nudge.up", "Move Selected Layers Up 1 Pixel at Current Magnification", [], Some("ArrowUp")),
-    uic!("viewer.nudge.down", "Move Selected Layers Down 1 Pixel at Current Magnification", [], Some("ArrowDown")),
-    uic!("viewer.nudge.left", "Move Selected Layers Left 1 Pixel at Current Magnification", [], Some("ArrowLeft")),
-    uic!("viewer.nudge.right", "Move Selected Layers Right 1 Pixel at Current Magnification", [], Some("ArrowRight")),
-    uic!("viewer.nudge.up10", "Move Selected Layers Up 10 Pixels at Current Magnification", [], Some("Shift+ArrowUp")),
-    uic!("viewer.nudge.down10", "Move Selected Layers Down 10 Pixels at Current Magnification", [], Some("Shift+ArrowDown")),
-    uic!("viewer.nudge.left10", "Move Selected Layers Left 10 Pixels at Current Magnification", [], Some("Shift+ArrowLeft")),
-    uic!("viewer.nudge.right10", "Move Selected Layers Right 10 Pixels at Current Magnification", [], Some("Shift+ArrowRight")),
-    uic!("view.safeMargins", "Title/Action Safe", [], Some("'")),
-    uic!("view.transparencyGrid", "Transparency Grid", [], None),
-    uic!("view.fastPreviews", "Fast Previews", [], None),
-    uic!("view.theme.toggle", "Next Appearance Mode", [], None),
-    uic!("view.theme.dark", "Theme: Dark", [], None),
-    uic!("view.theme.darker", "Theme: Darker", [], None),
-    uic!("view.theme.light", "Theme: Light", [], None),
-    uic!("timeline.zoomIn", "Zoom In Time", [], Some("=")),
-    uic!("timeline.zoomOut", "Zoom Out Time", [], Some("-")),
-    uic!("timeline.zoomFit", "Zoom to Fit Comp", [], Some("Shift+;")),
-    uic!("timeline.scrollToTime", "Scroll to Current Time", [], Some("D")),
-    uic!("timeline.scrollToLayer", "Scroll Topmost Selected Layer to Top", [], Some("X")),
-    uic!("timeline.parentColumn", "Show/Hide Parent Column", [], Some("Shift+F4")),
-    uic!("timeline.zoomFrameToggle", "Zoom In to Frame Level / Out to the Whole Comp", [], Some(";")),
-    uic!("timeline.graphEditor", "Graph Editor", [], Some("Shift+F3")),
-    uic!("timeline.switchesModes", "Toggle Switches / Modes", [], Some("F4")),
-    uic!("timeline.workAreaBegin", "Set Work Area Begin", [], Some("B")),
-    uic!("timeline.workAreaEnd", "Set Work Area End", [], Some("N")),
-    uic!("timeline.moveInToTime", "Move Layer In Point to Current Time", [], Some("[")),
-    uic!("timeline.moveOutToTime", "Move Layer Out Point to Current Time", [], Some("]")),
-    uic!("timeline.trimInToTime", "Trim Layer In Point to Current Time", [], Some("Alt+[")),
-    uic!("timeline.trimOutToTime", "Trim Layer Out Point to Current Time", [], Some("Alt+]")),
-    uic!("timeline.reveal.position", "Reveal Position", [], Some("P")),
-    uic!("timeline.reveal.scale", "Reveal Scale", [], Some("S")),
-    uic!("timeline.reveal.rotation", "Reveal Rotation", [], Some("R")),
-    uic!("timeline.reveal.opacity", "Reveal Opacity", [], Some("T")),
-    uic!("timeline.reveal.anchor", "Reveal Anchor Point", [], Some("A")),
-    uic!("timeline.reveal.effects", "Reveal Effects", [], Some("E")),
-    uic!("timeline.reveal.masks", "Reveal Masks", [], Some("M")),
-    uic!("timeline.reveal.feather", "Reveal Mask Feather", [], Some("F")),
-    uic!("timeline.reveal.levels", "Reveal Audio Levels (press twice: Waveform)", [], Some("L")),
-    uic!("timeline.reveal.timeRemap", "Reveal Time Remap", [], None),
-    uic!("timeline.reveal.expressions", "Reveal Expressions", [], None),
-    uic!("timeline.reveal.maskOpacity", "Reveal Mask Opacity", [], None),
-    uic!("timeline.reveal.maskPath", "Reveal Mask Path", [], None),
-    uic!("timeline.reveal.material", "Reveal Material Options", [], None),
-    uic!("timeline.reveal.paint", "Reveal Paint, Roto Brush and Puppet", [], None),
-    uic!("timeline.reveal.selected", "Reveal Selected Properties", [], None),
-    uic!("timeline.reveal.missingEffects", "Reveal Missing Effects", [], None),
-    uic!("timeline.reveal.waveform", "Reveal Audio Waveform", [], None),
-    uic!("timeline.revealAdd.position", "Add Position to Revealed Properties", [], Some("Shift+P")),
-    uic!("timeline.revealAdd.scale", "Add Scale to Revealed Properties", [], Some("Shift+S")),
-    uic!("timeline.revealAdd.rotation", "Add Rotation to Revealed Properties", [], Some("Shift+R")),
-    uic!("timeline.revealAdd.opacity", "Add Opacity to Revealed Properties", [], Some("Shift+T")),
-    uic!("timeline.revealAdd.anchor", "Add Anchor Point to Revealed Properties", [], Some("Shift+A")),
-    uic!("timeline.revealAdd.effects", "Add Effects to Revealed Properties", [], Some("Shift+E")),
-    uic!("timeline.revealAdd.masks", "Add Masks to Revealed Properties", [], Some("Shift+M")),
-    uic!("timeline.revealAdd.feather", "Add Mask Feather to Revealed Properties", [], Some("Shift+F")),
-    uic!("timeline.revealAdd.levels", "Add Audio Levels to Revealed Properties", [], Some("Shift+L")),
-    uic!("timeline.revealAdd.animated", "Add Animated Properties to Revealed Properties", [], Some("Shift+U")),
-    uic!("timeline.column", "Show/Hide Timeline Column", [], None),
-    uic!("timeline.sourceName", "Source Name / Layer Name", [], None),
-    uic!("timeline.search", "Search Timeline", [], None),
-    uic!("flowchart.options", "Flowchart Options", [], None),
-    uic!("flowchart.graph", "Flowchart Graph", [], None),
-    uic!("timeline.collapseAll", "Collapse All", [], None),
-    uic!("timeline.twirlSelected", "Twirl Selected Layers Open / Closed", [], Some("Cmd+`")),
-    uic!("timeline.keyAt.anchor", "Add or Remove Anchor Point Keyframe", [], Some("Alt+Shift+A")),
-    uic!("timeline.keyAt.position", "Add or Remove Position Keyframe", [], Some("Alt+Shift+P")),
-    uic!("timeline.keyAt.scale", "Add or Remove Scale Keyframe", [], Some("Alt+Shift+S")),
-    uic!("timeline.keyAt.rotation", "Add or Remove Rotation Keyframe", [], Some("Alt+Shift+R")),
-    uic!("timeline.keyAt.opacity", "Add or Remove Opacity Keyframe", [], Some("Alt+Shift+T")),
-    uic!("tool.selection", "Selection Tool", [], Some("V")),
-    uic!("tool.hand", "Hand Tool", [], Some("H")),
-    uic!("tool.zoom", "Zoom Tool", [], Some("Z")),
-    uic!("tool.orbit", "Orbit Tool", [], Some("1")),
-    uic!("tool.panCamera", "Pan Camera Tool", [], Some("2")),
-    uic!("tool.dolly", "Dolly Tool", [], Some("3")),
-    uic!("tool.camera", "Camera Tools", [], Some("C")),
-    uic!("tool.rotate", "Rotation Tool", [], Some("W")),
-    uic!("tool.panBehind", "Pan Behind Tool", [], Some("Y")),
-    uic!("tool.shape", "Shape Tools", [], Some("Q")),
-    uic!("tool.pen", "Pen Tool", [], Some("G")),
-    uic!("tool.type", "Type Tools", [], Some("Cmd+T")),
-    uic!("tool.brush", "Brush Tools", [], Some("Cmd+B")),
-    uic!("tool.rotoBrush", "Roto Brush & Refine Edge Tools", [], Some("Alt+W")),
-    uic!("tool.puppet", "Puppet Tools", [], Some("Cmd+P")),
-    uic!("app.newComp", "New Composition...", [], None),
-    uic!("app.compSettings", "Composition Settings...", [], None),
-    uic!("app.solidSettings", "New Solid...", [], None),
-    uic!("app.home", "Home", [], None),
-    uic!("markers.dialog", "Marker Settings...", [], None),
-    uic!("window.maximizePanel", "Maximize Panel Under Pointer", [], Some("`")),
-    uic!("window.maximizeApp", "Maximize or Restore Application Window", [], Some("Cmd+\\")),
-    uic!("window.toggleCompTimeline", "Switch Between Composition and Timeline Panel", [], Some("\\")),
-    uic!("window.nextPanel", "Next Panel in Frame", [], Some("Alt+Shift+.")),
-    uic!("window.previousPanel", "Previous Panel in Frame", [], Some("Alt+Shift+,")),
-    uic!("window.closeAll", "Close Panel or All Viewers", [], Some("Cmd+Shift+W")),
-    uic!("window.dockPanel", "Dock Panel", [], None),
-    uic!("window.floatPanel", "Undock Panel", [], None),
-    uic!("window.closePanel", "Close Panel", [], None),
-    uic!("window.panelWindow", "Move Panel to New Window", [], None),
-];
-
-pub fn panel_command_id(p: PanelKind) -> String {
-    format!("window.panel.{}", p.id())
-}
-
-/// The reveal shortcuts (P, S, R, T, A, E, M, F, L…). `add` (Shift+key) adds the property to
-/// (or removes it from) those already revealed instead of replacing them.
-pub fn reveal(app: &mut EffectcraftApp, kind: &str, now: f64, add: bool) {
-    // The double-press shortcuts: the same key again within 0.6 s reveals its second set (LL
-    // Waveform, TT Mask Opacity, MM all mask properties, EE Expressions, RR Time Remap, AA
-    // Material Options, PP paint / Roto Brush / Puppet, SS selected properties, FF missing
-    // effects). A single M shows Mask Path.
-    let double = |k: &str| -> Option<&'static str> {
-        Some(match k {
-            "levels" => "waveform",
-            "opacity" => "maskOpacity",
-            "masks" => "masks",
-            "effects" => "expressions",
-            "rotation" => "timeRemap",
-            "anchor" => "material",
-            "position" => "paint",
-            "scale" => "selected",
-            "feather" => "missingEffects",
-            _ => return None,
-        })
-    };
-    let pressed = kind;
-    // (With Shift a second press removes the property again instead.)
-    let again = !add && matches!(app.last_reveal.take(), Some((k, t)) if k == pressed && now - t < 0.6);
-    app.last_reveal = Some((if again { String::new() } else { pressed.to_string() }, now));
-    let kind = match (again, double(pressed)) {
-        (true, Some(d)) => {
-            // The second press replaces what the first one revealed.
-            let first = if pressed == "masks" { "maskPath" } else { pressed };
-            app.ui.timeline.reveal.retain(|k| k != first);
-            d
-        }
-        _ if pressed == "masks" => "maskPath",
-        _ => pressed,
-    };
-    let targets = reveal_targets(app);
-    let tl = &mut app.ui.timeline;
-    let present = tl.reveal.iter().any(|k| k == kind);
-    let mut kinds = tl.reveal.clone();
-    if add {
-        if present {
-            kinds.retain(|k| k != kind);
-        } else {
-            kinds.retain(|k| k != "props" || !tl.reveal_props.is_empty());
-            kinds.push(kind.to_string());
-        }
-    } else if present && kinds.len() == 1 {
-        kinds.clear();
-    } else {
-        kinds = vec![kind.to_string()];
-    }
-    tl.apply_reveal(&targets, kinds.clone());
-    crate::panels::timeline::open_revealed(app, &targets, &kinds);
-}
-
-/// Show Time Remap on the layers of a `layer.enableTimeRemap` (`layers` by id, else the
-/// selected ones) that have it now.
-fn reveal_time_remap(app: &mut EffectcraftApp, params: &Value) {
-    let asked: Vec<u64> = match params.get("layers").and_then(Value::as_array) {
-        Some(a) => a.iter().filter_map(Value::as_u64).collect(),
-        None => app.session.state.selected_layers.iter().map(|l| l.0).collect(),
-    };
-    let Some(comp) = app.session.active_comp() else { return };
-    let layers: Vec<u64> = comp.layers.iter().filter(|l| asked.contains(&l.id.0) && l.props.get("timeRemap").is_some()).map(|l| l.id.0).collect();
-    if !layers.is_empty() {
-        app.ui.timeline.apply_reveal(&layers, vec!["timeRemap".into()]);
-    }
-}
-
-/// After Alt+Shift+P (A, S, R, T) the Timeline shows the property on each layer it keyed, as in
-/// After Effects: added to what a reveal shortcut shows, else with the layer's Transform twirled
-/// open, else alone like P.
-fn reveal_keyed(app: &mut EffectcraftApp, keyed: &Value, kind: &str) {
-    let layers: std::collections::BTreeSet<u64> = keyed.as_array().into_iter().flatten().filter_map(|k| k.get("layer").and_then(Value::as_u64)).collect();
-    let Some(comp) = app.session.active_comp() else { return };
-    let tl = &mut app.ui.timeline;
-    for id in layers {
-        let shown = tl.layer_reveal.get(&id).filter(|k| !k.is_empty()).cloned();
-        match shown {
-            Some(mut kinds) => {
-                if !kinds.iter().any(|k| k == kind) {
-                    kinds.push(kind.to_string());
-                    tl.layer_reveal.insert(id, kinds);
-                }
-            }
-            None if tl.open_layers.contains(&id) => {
-                if let Some(tr) = comp.layer(effectcraft_engine::project::LayerId(id)).and_then(|l| l.transform()) {
-                    tl.open_groups.insert(tr.uid);
-                }
-            }
-            None => {
-                tl.open_layers.insert(id);
-                tl.layer_reveal.insert(id, vec![kind.to_string()]);
-            }
-        }
-    }
-}
-
-/// The layers a reveal shortcut acts on: the selected ones, else every layer of the active comp.
-fn reveal_targets(app: &EffectcraftApp) -> Vec<u64> {
-    if app.session.state.selected_layers.is_empty() {
-        app.session.active_comp().map(|c| c.layers.iter().map(|l| l.id.0).collect()).unwrap_or_default()
-    } else {
-        app.session.state.selected_layers.iter().map(|l| l.0).collect()
-    }
-}
-
-/// The arrow keys nudge the selected layers 1 pixel at the viewer's magnification (`up`,
-/// `down`, `left`, `right`), 10 with Shift (`up10`…), as After Effects does, so zoomed in
-/// they move by fractions of a comp pixel. From any panel except Project (which owns the
-/// arrow keys for its own keyboard navigation, #961); not while typing, with a dialog or
-/// menu open. With mask points selected the arrows move the points instead (#1288).
-fn nudge(app: &mut EffectcraftApp, ctx: &egui::Context, dir: &str) -> Result<Value, String> {
-    let (side, n) = match dir.strip_suffix("10") {
-        Some(side) => (side, 10.0),
-        None => (dir, 1.0),
-    };
-    let (x, y) = match side {
-        "up" => (0.0, -n),
-        "down" => (0.0, n),
-        "left" => (-n, 0.0),
-        "right" => (n, 0.0),
-        _ => return Err(format!("unknown nudge `{dir}`")),
-    };
-    let st = &app.session.state;
-    if app.ui.focused == PanelKind::Project || (st.selected_layers.is_empty() && st.selected_vertices.is_empty()) || st.text_edit.is_some() {
-        return Ok(Value::Null);
-    }
-    // Screen pixels per comp pixel.
-    let zoom = (app.ui.viewer.zoom.unwrap_or_else(|| crate::panels::viewer::last_fit(ctx)) * ctx.pixels_per_point()) as f64;
-    let k = if zoom.is_finite() && zoom > 1e-6 { 1.0 / zoom } else { 1.0 };
-    if let Some(layer) = st.selected_vertices.first().map(|v| v.layer) {
-        let d = vertex_delta(app, layer, [x * k, y * k]);
-        return run_engine(app, ctx, "mask.moveVertices", json!({"delta": d}));
-    }
-    run_engine(app, ctx, "layer.nudge", json!({"x": x * k, "y": y * k}))
-}
-
-/// A comp-space step `d` in the layer space of `layer`, where mask points live. Like a drag of
-/// the points in the viewer, every selected point takes the first one's layer space.
-fn vertex_delta(app: &EffectcraftApp, layer: effectcraft_engine::project::LayerId, d: [f64; 2]) -> [f64; 2] {
-    use effectcraft_engine::geom::vec2;
-    let s = &app.session;
-    let (Some(cid), Some(comp)) = (s.active_comp_id(), s.active_comp()) else { return d };
-    let Some(l) = comp.layer(layer) else { return d };
-    let ectx = effectcraft_engine::render::EvalCtx { project: &s.project, comp_id: cid, comp, time: s.time(), expr: s.expr.as_deref(), footage: None };
-    let (l2c, _) = crate::panels::viewer::l2c(&ectx, l);
-    l2c.inverse().map_or(d, |inv| {
-        let v = inv.apply_vec(vec2(d[0], d[1]));
-        [v.x, v.y]
-    })
-}
-
-fn no_params(p: &Value) -> bool {
-    p.as_object().is_none_or(|m| m.is_empty())
-}
-
-/// `{"comp": id}` and nothing else: Composition Settings opens on that comp instead of
-/// applying no settings to it.
-fn only_comp(p: &Value) -> Option<effectcraft_engine::project::ItemId> {
-    let m = p.as_object().filter(|m| m.len() == 1)?;
-    m.get("comp")?.as_u64().map(effectcraft_engine::project::ItemId)
-}
-
-/// Execute a UI or engine command by id.
-pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: Value) -> Result<Value, String> {
-    if matches!(id, "effects.copyPresetsFolderPath" | "mediaBrowser.copySourcePath") {
-        return frontend(app, ctx, id, params);
-    }
-    // Layer ▸ New ▸ Text (menu, shortcut, context menus) puts an insertion point in the centre of
-    // the comp, as After Effects does, so typing goes into Source Text rather than running
-    // shortcuts (#866). `engine.execute` keeps the headless default.
-    if id == "layer.newText" && no_params(&params) {
-        return run_engine(app, ctx, id, json!({"text": "", "edit": true}));
-    }
-    // A new folder (File ▸ New, its shortcut, the Project panel's button and context menu) opens
-    // with its name ready to type, as in After Effects (#1658). The command selects it.
-    // `engine.execute` keeps the headless default.
-    if id == "project.newFolder" && no_params(&params) {
-        let r = run_engine(app, ctx, id, params);
-        if r.is_ok() {
-            app.show_panel(PanelKind::Project);
-            crate::panels::project::begin_rename(app, ctx);
-        }
-        return r;
-    }
-    // The Project-panel focus redirects apply only while no text edit is open: creating a text
-    // layer leaves focus on Project while the insertion point lives in the comp, so during an
-    // edit these commands address the text context — redirected, Deselect All would clear a
-    // project selection the user is not looking at and silently swallow the edit's own end.
-    if no_params(&params) && app.ui.focused == PanelKind::Project && app.session.state.text_edit.is_none() {
-        match id {
-            "edit.duplicate" => return run_engine(app, ctx, "project.duplicate", json!({})),
-            "edit.selectAll" => {
-                let items: Vec<u64> = crate::panels::project::visible_rows(app)
-                    .into_iter()
-                    .filter(|(id, _)| app.ui.project_search.is_empty() || app.session.project.item(*id).is_some_and(|it| !it.is_folder()))
-                    .map(|(id, _)| id.0)
-                    .collect();
-                return run_engine(app, ctx, "project.select", json!({"items":items}));
-            }
-            "edit.deselectAll" => return run_engine(app, ctx, "project.select", json!({"items":[]})),
-            "edit.cut" | "edit.copy" | "edit.paste" | "edit.copyWithPropertyLinks" | "edit.copyWithRelativePropertyLinks" | "edit.copyExpressionOnly" => {
-                return Err("Project clipboard actions are not supported yet".into());
-            }
-            _ => {}
-        }
-    }
-    // Edit ▸ Paste with SVG markup on the system clipboard pastes it as a shape layer (After
-    // Effects 26.3). Copying in the app replaces the system clipboard with a note naming what
-    // was copied, so SVG there was copied after anything copied in the app.
-    if id == "edit.paste" && no_params(&params) && app.session.state.text_edit.is_none() {
-        let text = ctx.data_mut(|d| d.remove_temp::<String>(system_paste_id())).or_else(|| app.hooks.clipboard_text.as_ref().and_then(|f| f()));
-        if let Some(svg) = text.filter(|t| effectcraft_engine::vector::is_svg_text(t)) {
-            return run_engine(app, ctx, "edit.pasteSvg", json!({"svg": svg}));
-        }
-    }
-    // Clear follows panel focus, including the Edit menu and keyboard shortcut.
-    if id == "edit.clear" && params.as_object().is_some_and(|p| p.is_empty()) && app.ui.focused == PanelKind::Project {
-        // Through `invoke`, so deleting items that compositions use still asks first (M3.16).
-        return invoke(app, ctx, "project.delete", json!({}));
-    }
-    if id == "edit.clear" && params.as_object().is_some_and(|p| p.is_empty()) && app.ui.focused == PanelKind::RenderQueue {
-        let selected = ctx.data(|d| d.get_temp::<(Vec<u64>, Option<u64>)>(egui::Id::unique("rq-ui"))).and_then(|(_, id)| id);
-        return match selected {
-            Some(item) => run_engine(app, ctx, "renderQueue.remove", json!({"item": item})),
-            None => Err("select a Render Queue item first".into()),
-        };
-    }
-    // Shift+Delete deletes the Project panel's selection without asking; it does nothing in the
-    // other panels.
-    if id == "project.deleteWithoutConfirmation" {
-        if app.ui.focused != PanelKind::Project {
-            return Ok(Value::Null);
-        }
-        return crate::panels::delete_items::delete_confirmed(app, ctx, json!({}));
-    }
-    let now = app.now();
-    // Closing a modified project asks to save it first; the command runs once answered.
-    if crate::panels::unsaved::guard(app, id, &params) {
-        return Ok(json!({"dialog": "unsavedChanges"}));
-    }
-    // Deleting Project items that compositions use asks first, as in After Effects.
-    if crate::panels::delete_items::guard(app, id, &params) {
-        return Ok(json!({"dialog": "deleteItems"}));
-    }
-    // J / K and Select All Keyframes act on what the Timeline shows (its revealed properties).
-    if matches!(id, "time.nextKey" | "time.previousKey" | "keys.selectAll")
-        && ["visible", "layers", "layer", "prop"].iter().all(|k| params.get(*k).is_none())
-        && let Some(c) = app.session.active_comp_arc()
-    {
-        let mut p = if params.is_object() { params.clone() } else { json!({}) };
-        p["visible"] = json!(crate::panels::timeline::visible_props(app, &c));
-        return run_engine(app, ctx, id, p);
-    }
-    // New Camera/Light and Camera/Light Settings without parameters open their dialogs.
-    if crate::panels::dialogs_3d::route(app, id, &params)? {
-        return Ok(Value::Null);
-    }
-    // New 3D Primitive without parameters opens its dialog.
-    if crate::panels::primitive_dialog::route(app, id, &params)? {
-        return Ok(Value::Null);
-    }
-    // Layer Settings on a solid, adjustment layer or null opens its settings dialog.
-    if crate::panels::dialogs::route_layer_settings(app, id, &params)? {
-        return Ok(Value::Null);
-    }
-    // Layer ▸ Layer Styles ▸ <style> from the menu adds the style and opens the dialog on it.
-    if crate::panels::layer_styles_dialog::route(app, id, &params)? {
-        return Ok(Value::Null);
-    }
-    // Legacy per-panel / per-workspace ids (`window.panel.Project`, `window.workspace.default`).
-    if let Some(rest) = id.strip_prefix("window.panel.") {
-        return frontend(app, ctx, "window.panel", json!({"panel": rest}));
-    }
-    if let Some(ws) = id.strip_prefix("window.workspace.") {
-        if ws == "reset" {
-            return frontend(app, ctx, "window.resetWorkspace", json!({}));
-        }
-        return frontend(app, ctx, "window.workspace", json!({"name": ws}));
-    }
-    if let Some(t) = id.strip_prefix("tool.") {
-        // C cycles through the camera tools.
-        if t == "camera" {
-            let tools = [Tool::Orbit, Tool::PanCamera, Tool::Dolly];
-            let next = match tools.iter().position(|x| *x == app.ui.tool) {
-                Some(i) => tools[(i + 1) % tools.len()],
-                None => Tool::Orbit,
-            };
-            app.ui.tool = next;
-            return Ok(json!({"tool": next}));
-        }
-        // Slot shortcuts cycle through the slot's tools.
-        let slot = match t {
-            "shape" => Some(8),
-            "pen" => Some(9),
-            "type" => Some(10),
-            "brush" => Some(11),
-            "rotoBrush" => Some(14),
-            "puppet" => Some(15),
-            _ => None,
-        };
-        if let Some(si) = slot {
-            let tools: Vec<Tool> = match si {
-                11 => vec![Tool::Brush, Tool::Clone, Tool::Eraser],
-                _ => crate::state::Tool::SLOTS[si].to_vec(),
-            };
-            let cur = tools.iter().position(|x| *x == app.ui.tool);
-            let next = match cur {
-                Some(i) => tools[(i + 1) % tools.len()],
-                None => app.ui.slot_tools.get(si).copied().filter(|x| tools.contains(x)).unwrap_or(tools[0]),
-            };
-            app.ui.tool = next;
-            if si < app.ui.slot_tools.len() && si != 11 {
-                app.ui.slot_tools[si] = next;
-            }
-            return Ok(json!({"tool": next}));
-        }
-        let tool = Tool::from_name(t).ok_or_else(|| format!("unknown tool `{t}`"))?;
-        app.ui.tool = tool;
-        return Ok(json!({"tool": tool}));
-    }
-    if let Some(dir) = id.strip_prefix("viewer.nudge.") {
-        return nudge(app, ctx, dir);
-    }
-    if let Some(k) = id.strip_prefix("timeline.reveal.") {
-        if k == "animated" {
-            return run_engine(app, ctx, "anim.reveal", json!({"kind": "keyframes"}));
-        }
-        reveal(app, k, now, false);
-        return Ok(Value::Null);
-    }
-    if let Some(k) = id.strip_prefix("timeline.keyAt.") {
-        let r = run_engine(app, ctx, "keys.toggleTransform", json!({"prop": k}))?;
-        reveal_keyed(app, &r, k);
-        return Ok(r);
-    }
-    if let Some(k) = id.strip_prefix("timeline.revealAdd.") {
-        reveal(app, k, now, true);
-        return Ok(json!({"revealed": app.ui.timeline.reveal}));
-    }
-    // U reveals keyframed properties; UU (pressed twice quickly) all modified properties; U
-    // again later hides them.
-    if id == "anim.reveal" && params.get("kind").and_then(Value::as_str) == Some("keyframes") {
-        let last = app.last_reveal.take();
-        app.last_reveal = Some(("keyframes".into(), now));
-        match last {
-            Some((k, t)) if k == "keyframes" && now - t < 0.6 => {
-                return run_engine(app, ctx, "anim.reveal", json!({"kind": "modified"}));
-            }
-            Some((k, _)) if k == "keyframes" && app.ui.timeline.reveal == ["props"] => {
-                let targets = reveal_targets(app);
-                app.ui.timeline.apply_reveal(&targets, vec![]);
-                return Ok(json!({"revealed": 0}));
-            }
-            _ => {}
-        }
-    }
-    if id == "window.dockAction" {
-        let value = params.get("action").cloned().ok_or("missing docking action")?;
-        let action: craft_ui::docking::Action<PanelKind> = serde_json::from_value(value).map_err(|error| format!("invalid docking action: {error}"))?;
-        if matches!(&action, craft_ui::docking::Action::Open { .. } | craft_ui::docking::Action::OpenAt { .. }) {
-            return Err("use the panel open commands to preserve viewer and ScriptUI lifecycle callbacks".into());
-        }
-        if let craft_ui::docking::Action::Close { panel } = &action {
-            let mut layout = crate::dock_shared::encode(&app.ui.dock, &app.ui.floating)?;
-            layout.apply(action.clone()).map_err(|error| error.to_string())?;
-            app.close_panel(*panel);
-            return Ok(Value::Null);
-        }
-        let mut error = None;
-        if !app.edit_layout(|layout| match layout.apply(action) {
-            Ok(()) => true,
-            Err(reason) => {
-                error = Some(reason);
-                false
-            }
-        }) {
-            return Err(error.unwrap_or_else(|| "invalid docking layout".into()));
-        }
-        return Ok(Value::Null);
-    }
-    // Multiple monitors: {panel, window?: bool} moves a panel into its own native window (or
-    // back into the main window; no `window` toggles).
-    if id == "window.panelWindow" {
-        // A panel name ("Info", "Effect Controls") or its serialized form ({"Viewer": 2}).
-        let value = params.get("panel").ok_or("panelWindow: need `panel`")?;
-        let panel = match value.as_str() {
-            Some(name) => PanelKind::from_name(name).ok_or(format!("unknown panel `{name}`"))?,
-            None => serde_json::from_value::<PanelKind>(value.clone()).map_err(|_| "panelWindow: unknown `panel`".to_string())?,
-        };
-        let window = match params.get("window") {
-            None | Some(Value::Null) => None,
-            Some(value) => Some(value.as_bool().ok_or("panelWindow: `window` must be true or false")?),
-        };
-        let window = app.set_panel_window(ctx, panel, window)?;
-        return Ok(json!({"window": window}));
-    }
-    // A UI-only command (not in the engine's menus), so `frontend` gets it from here.
-    if id == "window.maximizeApp" {
-        return frontend(app, ctx, id, params);
-    }
-    // Docking: {panel, anchor, zone: center|left|right|top|bottom}, {panel, rect?}, {panel?}.
-    if let Some(op) = id.strip_prefix("window.").filter(|o| matches!(*o, "maximizePanel" | "dockPanel" | "floatPanel" | "closePanel")) {
-        let panel_of = |k: &str| params.get(k).and_then(Value::as_str).map(|s| PanelKind::from_name(s).ok_or(format!("unknown panel `{s}`")));
-        match op {
-            "maximizePanel" => {
-                let p = match panel_of("panel") {
-                    Some(p) => p?,
-                    None => app.panel_at(ctx.pointer_hover_pos()),
-                };
-                app.toggle_maximize(p);
-                return Ok(json!({"maximized": app.ui.maximized}));
-            }
-            "closePanel" => {
-                let p = panel_of("panel").ok_or("closePanel: need `panel`")??;
-                app.close_panel(p);
-                return Ok(Value::Null);
-            }
-            "floatPanel" => {
-                let p = panel_of("panel").ok_or("floatPanel: need `panel`")??;
-                let r = match params.get("rect") {
-                    Some(value) => serde_json::from_value::<[f32; 4]>(value.clone()).map_err(|_| "rect must contain four finite numbers")?,
-                    None => crate::dock_ui::default_float_rect(ctx.content_rect()),
-                };
-                if !app.edit_layout(|l| l.float(p, r)) {
-                    return Err(format!("can't undock {}", p.title()));
-                }
-                return Ok(Value::Null);
-            }
-            _ => {
-                let p = panel_of("panel").ok_or("dockPanel: need `panel`")??;
-                let anchor = panel_of("anchor").ok_or("dockPanel: need `anchor` (a docked panel)")??;
-                let zone = params
-                    .get("zone")
-                    .and_then(Value::as_str)
-                    .map_or(Some(crate::dock::Zone::Center), crate::dock::Zone::from_name)
-                    .ok_or("zone: center|left|right|top|bottom")?;
-                if !app.edit_layout(|l| l.dock(p, anchor, zone)) {
-                    return Err(format!("can't dock {} at {} ({zone:?})", p.title(), anchor.title()));
-                }
-                app.show_panel(p);
-                return Ok(Value::Null);
-            }
-        }
-    }
-    if id == "markers.dialog" {
-        // The Composition/Layer Marker dialog (double-click a marker): {layer?, index}.
-        let index = params.get("index").and_then(Value::as_u64).ok_or("markers.dialog: need `index`")? as usize;
-        let layer = params.get("layer").and_then(Value::as_u64);
-        crate::panels::markers_ui::open_dialog(app, crate::panels::markers_ui::MarkerRef { layer, index })?;
-        return Ok(json!({"dialog": id}));
-    }
-
-    if id == "view.theme.toggle" {
-        app.cycle_appearance(ctx);
-        return Ok(json!({"appearanceMode": app.session.prefs.appearance.appearance_mode}));
-    }
-    if let Some(th) = id.strip_prefix("view.theme.") {
-        let k = crate::theme::ThemeKind::from_name(th).ok_or("unknown theme")?;
-        app.set_theme(ctx, k);
-        return Ok(Value::Null);
-    }
-    let timing = |app: &mut EffectcraftApp, op: &str| app.session.execute("layer.timing", json!({"op": op})).map_err(|e| e.to_string());
-    match id {
-        "playback.ramPreview" => {
-            app.toggle_play_with(now, effectcraft_engine::preview::PreviewShortcut::Numpad0);
-            return Ok(json!({"playing": app.playback.playing}));
-        }
-        "playback.preview.shiftSpacebar" | "playback.preview.shiftNumpad0" | "playback.preview.altNumpad0" => {
-            let sc = effectcraft_engine::preview::PreviewShortcut::parse(id.trim_start_matches("playback.preview.")).ok_or("unknown preview shortcut")?;
-            app.toggle_play_with(now, sc);
-            return Ok(json!({"playing": app.playback.playing}));
-        }
-        "playback.stop" => {
-            app.stop();
-            return Ok(Value::Null);
-        }
-        // The focused Layer panel has its own magnification; otherwise the Composition viewer.
-        "view.fit" if app.ui.focused == PanelKind::Layer => {
-            app.ui.layer_zoom = None;
-            app.ui.layer_pan = [0.0, 0.0];
-            return Ok(Value::Null);
-        }
-        "view.fit" => {
-            app.ui.viewer.zoom = None;
-            app.ui.viewer.fit_up_to_100 = false;
-            app.ui.viewer.pan = [0.0, 0.0];
-            return Ok(Value::Null);
-        }
-        "timeline.scrollToTime" => app.ui.timeline.scroll_to = Some(crate::state::ScrollTo::Time),
-        "timeline.scrollToLayer" => app.ui.timeline.scroll_to = Some(crate::state::ScrollTo::Layer),
-        "timeline.parentColumn" => {
-            let on = !crate::panels::timeline::column_visible(&app.ui.timeline, "parent");
-            crate::panels::timeline::set_column(&mut app.ui.timeline, "parent", on)?;
-            return Ok(json!({"parent": on}));
-        }
-        "view.fitUpTo100" => {
-            app.ui.viewer.zoom = None;
-            app.ui.viewer.fit_up_to_100 = true;
-            app.ui.viewer.pan = [0.0, 0.0];
-            return Ok(Value::Null);
-        }
-        // Shift+, / Shift+.: the previous / next open composition (the viewer's tabs).
-        "view.nextItem" | "view.previousItem" => {
-            let open = app.session.state.open_comps.clone();
-            let Some(i) = app.session.state.active_comp.and_then(|c| open.iter().position(|o| *o == c)) else { return Ok(Value::Null) };
-            let step = if id == "view.nextItem" { 1 } else { open.len().saturating_sub(1) };
-            let Some(next) = open.get((i + step) % open.len().max(1)).copied().filter(|n| Some(*n) != app.session.state.active_comp) else {
-                return Ok(Value::Null);
-            };
-            return run_engine(app, ctx, "comp.open", json!({"comp": next.0}));
-        }
-        // \\: between the Composition viewer and the Timeline.
-        "window.toggleCompTimeline" => {
-            let to = if app.ui.focused == PanelKind::Timeline { crate::panels::viewers::active_panel(app) } else { PanelKind::Timeline };
-            app.show_panel(to);
-            return Ok(json!({"focused": to.id()}));
-        }
-        // Alt+Shift+, / Alt+Shift+.: the previous / next tab of the focused panel's group.
-        "window.nextPanel" | "window.previousPanel" => {
-            let focused = app.ui.focused;
-            let group: Vec<PanelKind> = match app.ui.floating.iter().find(|f| f.panels.contains(&focused)) {
-                Some(f) => f.panels.clone(),
-                None => app.ui.dock.group_of(focused).map(<[PanelKind]>::to_vec).unwrap_or_default(),
-            };
-            let Some(i) = group.iter().position(|p| *p == focused) else { return Ok(Value::Null) };
-            let step = if id == "window.nextPanel" { 1 } else { group.len().saturating_sub(1) };
-            if let Some(next) = group.get((i + step) % group.len().max(1)).copied() {
-                app.show_panel(next);
-            }
-            return Ok(json!({"focused": app.ui.focused.id()}));
-        }
-        // Ctrl+Shift+W: with a viewer or the Timeline active, every open composition closes;
-        // any other panel closes itself.
-        "window.closeAll" => {
-            let focused = app.ui.focused;
-            if matches!(focused, PanelKind::Composition | PanelKind::Timeline | PanelKind::Viewer(_)) {
-                for c in app.session.state.open_comps.clone() {
-                    run_engine(app, ctx, "comp.close", json!({"comp": c.0}))?;
-                }
-            } else {
-                app.close_panel(focused);
-            }
-            return Ok(Value::Null);
-        }
-        "view.actualSize" if app.ui.focused == PanelKind::Layer => {
-            app.ui.layer_zoom = Some(1.0 / ctx.pixels_per_point());
-            app.ui.layer_pan = [0.0, 0.0];
-            return Ok(Value::Null);
-        }
-        "view.actualSize" => {
-            app.ui.viewer.zoom = Some(1.0 / ctx.pixels_per_point());
-            app.ui.viewer.pan = [0.0, 0.0];
-            return Ok(Value::Null);
-        }
-        "view.safeMargins" => app.ui.viewer.safe_margins = !app.ui.viewer.safe_margins,
-        "view.transparencyGrid" => app.ui.viewer.transparency_grid = !app.ui.viewer.transparency_grid,
-        "view.fastPreviews" => {
-            // With a mode: Fast Previews ▸ Off / Adaptive Resolution / Draft / Fast Draft /
-            // Wireframe; without: toggle Draft quality (Settings ▸ Previews).
-            if params.get("mode").is_some() {
-                return run_engine(app, ctx, "view.fastPreviewMode", params);
-            }
-            let on = !app.ui.viewer.fast_preview;
-            app.set_pref("previews.fastPreviews", json!(on))?;
-            app.ui.viewer.fast_preview = on;
-        }
-        "timeline.zoomIn" | "timeline.zoomOut" => {
-            let k = if id == "timeline.zoomIn" { crate::panels::timeline::ZOOM_STEP } else { 1.0 / crate::panels::timeline::ZOOM_STEP };
-            crate::panels::timeline::zoom(app, ctx, k);
-            return Ok(Value::Null);
-        }
-        "timeline.zoomFit" => crate::panels::timeline::toggle_fit_zoom(app, ctx),
-        "timeline.zoomFrameToggle" => crate::panels::timeline::toggle_frame_zoom(app, ctx),
-        "timeline.column" => {
-            let col = params.get("column").and_then(Value::as_str).ok_or("timeline.column: need `column`")?;
-            let on = params.get("visible").and_then(Value::as_bool).unwrap_or(!crate::panels::timeline::column_visible(&app.ui.timeline, col));
-            crate::panels::timeline::set_column(&mut app.ui.timeline, col, on)?;
-            let shown: Vec<&str> =
-                crate::panels::timeline::COLUMNS.iter().map(|c| c.0).filter(|c| crate::panels::timeline::column_visible(&app.ui.timeline, c)).collect();
-            return Ok(json!({"columns": shown}));
-        }
-        "timeline.sourceName" => {
-            let tl = &mut app.ui.timeline;
-            tl.source_name = params.get("value").and_then(Value::as_bool).unwrap_or(!tl.source_name);
-            return Ok(json!({"sourceName": tl.source_name}));
-        }
-        "flowchart.options" | "flowchart.graph" => return crate::panels::flowchart::command(app, id, &params),
-        "timeline.search" => {
-            app.ui.timeline.search = params.get("query").and_then(Value::as_str).unwrap_or_default().to_string();
-            app.show_panel(PanelKind::Timeline);
-        }
-        "timeline.graphEditor" => app.ui.timeline.graph_editor = !app.ui.timeline.graph_editor,
-        "timeline.switchesModes" => app.ui.timeline.show_modes = !app.ui.timeline.show_modes,
-        "timeline.collapseAll" => {
-            app.ui.timeline.open_layers.clear();
-            app.ui.timeline.open_groups.clear();
-            app.ui.timeline.reveal.clear();
-            app.ui.timeline.layer_reveal.clear();
-        }
-        // Ctrl+`: twirl the selected layers open (all closed ones) or closed (all open). From a
-        // reveal shortcut's view it opens their full property trees.
-        "timeline.twirlSelected" => {
-            let sel: Vec<u64> = app.session.state.selected_layers.iter().map(|l| l.0).collect();
-            let tl = &mut app.ui.timeline;
-            let revealing = sel.iter().any(|l| tl.layer_reveal.contains_key(l));
-            tl.reveal.clear();
-            for l in &sel {
-                tl.layer_reveal.remove(l);
-            }
-            if !revealing && sel.iter().all(|l| tl.open_layers.contains(l)) {
-                for l in &sel {
-                    tl.open_layers.remove(l);
-                }
-            } else {
-                tl.open_layers.extend(sel);
-            }
-        }
-        "timeline.workAreaBegin" => return app.session.execute("comp.workArea", json!({"set": "begin"})).map_err(|e| e.to_string()),
-        "timeline.workAreaEnd" => return app.session.execute("comp.workArea", json!({"set": "end"})).map_err(|e| e.to_string()),
-        "timeline.moveInToTime" => return timing(app, "moveInToTime"),
-        "timeline.moveOutToTime" => return timing(app, "moveOutToTime"),
-        "timeline.trimInToTime" => return timing(app, "trimInToTime"),
-        "timeline.trimOutToTime" => return timing(app, "trimOutToTime"),
-        "app.home" => app.ui.start_screen = !app.ui.start_screen,
-        "app.newComp" | "comp.new" if no_params(&params) => crate::panels::dialogs::open_new_comp(app),
-        "app.compSettings" | "comp.settings" if no_params(&params) => crate::panels::dialogs::open_comp_settings(app)?,
-        "app.compSettings" | "comp.settings" if only_comp(&params).is_some() => {
-            crate::panels::dialogs::open_comp_settings_for(app, only_comp(&params).ok_or("missing `comp`")?)?
-        }
-        "app.solidSettings" | "layer.newSolid" if no_params(&params) => crate::panels::dialogs::open_new_solid(app)?,
-        "keys.velocity" if no_params(&params) => crate::panels::key_dialogs::open_velocity(app)?,
-        "keys.interpolation" if no_params(&params) => crate::panels::key_dialogs::open_interpolation(app)?,
-        "layer.timeStretch" if no_params(&params) => crate::panels::key_dialogs::open_time_stretch(app)?,
-        _ => {
-            if id == "renderQueue.render" && params.get("wait").is_none() {
-                // The UI renders in the background; the panel shows progress.
-                let mut p = params.clone();
-                if let Some(m) = p.as_object_mut() {
-                    m.insert("wait".into(), json!(false));
-                } else {
-                    p = json!({"wait": false});
-                }
-                app.show_panel(PanelKind::RenderQueue);
-                return app.session.execute(id, p).map_err(|e| e.to_string());
-            }
-            if id == "renderQueue.add" {
-                let r = app.session.execute(id, params).map_err(|e| e.to_string());
-                match &r {
-                    Ok(_) => app.show_panel(PanelKind::RenderQueue),
-                    Err(e) => app.ui.status = e.clone(),
-                }
-                return r;
-            }
-            if let Some(r) = file_dialog(app, id, &params) {
-                return r;
-            }
-            if id == "layer.precompose" && params.get("name").is_none() {
-                crate::panels::precomp::open(app, &params)?;
-                return Ok(json!({"dialog": id}));
-            }
-            if crate::panels::dialogs::open_form(app, id, &params) {
-                return Ok(json!({"dialog": id}));
-            }
-            if id == "renderQueue.render" && params.get("wait").is_none() {
-                // The UI renders in the background; the panel shows progress.
-                let mut p = params.clone();
-                if let Some(m) = p.as_object_mut() {
-                    m.insert("wait".into(), json!(false));
-                } else {
-                    p = json!({"wait": false});
-                }
-                app.show_panel(PanelKind::RenderQueue);
-                return app.session.execute(id, p).map_err(|e| e.to_string());
-            }
-            if id == "renderQueue.add" {
-                let r = app.session.execute(id, params).map_err(|e| e.to_string());
-                match &r {
-                    Ok(_) => app.show_panel(PanelKind::RenderQueue),
-                    Err(e) => app.ui.status = e.clone(),
-                }
-                return r;
-            }
-            // An effect added to a layer (Effect menu, Last Effect, dropped on a layer) brings
-            // up Effect Controls on that layer, as in After Effects.
-            if matches!(id, "effect.apply" | "effect.applyLast") {
-                let r = run_engine(app, ctx, id, params.clone());
-                if let Ok(applied) = &r {
-                    crate::panels::effect_controls::reveal_applied(app, &params);
-                    crate::panels::effect_controls::choose_files_after_apply(app, applied);
-                }
-                return r;
-            }
-            // Enabling time remapping twirls its layers open on Time Remap and its two keys.
-            if id == "layer.enableTimeRemap" {
-                let r = run_engine(app, ctx, id, params.clone());
-                if r.as_ref().is_ok_and(|on| on.as_bool() == Some(true)) {
-                    reveal_time_remap(app, &params);
-                }
-                return r;
-            }
-            if id == "layer.rename" && params.get("name").is_none() {
-                crate::panels::timeline::begin_rename(app, ctx);
-                return Ok(Value::Null);
-            }
-            return run_engine(app, ctx, id, params);
-        }
-    }
-    Ok(Value::Null)
-}
-
-/// Run an engine command and perform the frontend events it emitted right away.
-/// Commands that fill the internal clipboard.
-const COPY_COMMANDS: &[&str] =
-    &["edit.copy", "edit.cut", "edit.copyWithPropertyLinks", "edit.copyWithRelativePropertyLinks", "edit.copyExpressionOnly", "keys.copy", "effect.copy"];
-
-/// A line for the system clipboard naming what EffectCraft copied. The system clipboard must
-/// hold something: with nothing on it, the windowing layer sends no paste event for Ctrl+V.
-fn clipboard_note(s: &effectcraft_engine::Session) -> String {
-    let st = &s.state;
-    let n = |n: usize, one: &str, many: &str| format!("EffectCraft: {n} {}", if n == 1 { one } else { many });
-    if st.clip_is_keys && !st.key_clipboard.is_empty() {
-        n(st.key_clipboard.iter().map(|c| c.keys.len()).sum(), "keyframe", "keyframes")
-    } else if !st.effect_clipboard.is_empty() {
-        n(st.effect_clipboard.len(), "effect", "effects")
-    } else if !st.contents_clipboard.is_empty() {
-        n(st.contents_clipboard.len(), "shape item", "shape items")
-    } else if st.link_clipboard.is_some() {
-        "EffectCraft: property links".into()
-    } else {
-        n(st.clipboard.len(), "layer", "layers")
-    }
-}
-
-pub(crate) fn run_engine(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: Value) -> Result<Value, String> {
-    // Events already queued belong to earlier invocations (`engine.execute` defers them).
-    let queued = app.session.events.len();
-    let mut r = app.session.execute(id, params).map_err(|e| e.to_string());
-    if let Err(e) = &r {
-        app.ui.status = e.clone();
-    } else if COPY_COMMANDS.contains(&id) && app.session.state.text_edit.is_none() {
-        ctx.copy_text(clipboard_note(&app.session));
-    }
-    let events = app.session.drain_events();
-    for (index, ev) in events.into_iter().enumerate() {
-        match ev {
-            effectcraft_engine::Event::Frontend { command, params } => {
-                if let Err(e) = frontend(app, ctx, &command, params) {
-                    app.ui.status = e.clone();
-                    // A frontend-only command's own failure is the command's result (#696: a
-                    // workspace save that didn't reach disk reported success). An earlier
-                    // invocation's failure only sets the status.
-                    if index >= queued && command == id && r.is_ok() {
-                        r = Err(e);
-                    }
-                }
-            }
-            other => app.session.events.push(other),
-        }
-    }
-    r
-}
-
-fn toggle(slot: &mut bool, p: &Value) -> Value {
-    *slot = p.get("value").and_then(Value::as_bool).unwrap_or(!*slot);
-    json!(*slot)
-}
-
-/// Perform a frontend command (from `Event::Frontend`).
-pub fn frontend(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, p: Value) -> Result<Value, String> {
-    let now = app.now();
-    let v = &mut app.ui.viewer;
-    Ok(match id {
-        "mediaBrowser.copySourcePath" => {
-            let path = p.get("path").and_then(Value::as_str).filter(|path| !path.is_empty()).ok_or("A source path is required")?;
-            ctx.copy_text(path.to_string());
-            json!({"path": path})
-        }
-        "effects.copyPresetsFolderPath" => {
-            if cfg!(target_arch = "wasm32") {
-                return Err("The web app has no local presets folder".into());
-            }
-            let path = crate::panels::effects_presets::presets_dir().filter(|path| !path.as_os_str().is_empty()).ok_or("No presets folder is configured")?;
-            let path = std::path::absolute(path).map_err(|e| format!("Cannot resolve the presets folder path: {e}"))?;
-            let path = path.to_str().ok_or("The presets folder path is not valid UTF-8")?;
-            ctx.copy_text(path.to_string());
-            json!({"path": path})
-        }
-        "app.checkForUpdates" | "help.checkForUpdates" => {
-            crate::updates_ui::check(app);
-            Value::Null
-        }
-        "app.about" => {
-            app.dialog = Some(crate::Dialog::About);
-            Value::Null
-        }
-        // Window ▸ <ScriptUI panel>: dock (or bring forward) the panel the script built.
-        // Audio scrubbing: one frame of audio at `time` (default the current time).
-        "playback.scrubAudio" => {
-            let cid = app.session.active_comp_id().ok_or("no composition")?;
-            let t = p.get("time").and_then(Value::as_f64).map_or(app.session.time(), effectcraft_engine::time::Tick::from_seconds_f64);
-            app.scrub_audio(cid, t, now);
-            json!({"playing": app.scrub.is_some()})
-        }
-        // View ▸ New Viewer.
-        "view.newViewer" => json!({"viewer": crate::panels::viewers::new_viewer(app)}),
-        // Reveal Layer Source / Reveal Composition: show the Project panel on the item, opening
-        // its folders and clearing the search so the row is visible.
-        "project.reveal" => {
-            let ids: Vec<effectcraft_engine::project::ItemId> = p
-                .get("items")
-                .and_then(Value::as_array)
-                .map(|items| items.iter().filter_map(Value::as_u64).map(effectcraft_engine::project::ItemId).collect())
-                .or_else(|| p.get("item").and_then(Value::as_u64).map(|item| vec![effectcraft_engine::project::ItemId(item)]))
-                .unwrap_or_default();
-            crate::panels::project::reveal(app, ctx, &ids);
-            json!({"items": ids.iter().map(|item| item.0).collect::<Vec<_>>()})
-        }
-        // Run by id (control channel, MCP): the Project panel's selection, whatever has focus.
-        "project.deleteWithoutConfirmation" => crate::panels::delete_items::delete_confirmed(app, ctx, json!({}))?,
-        // A gradient property's "Edit Gradient…" (the Timeline's value): the Gradient Editor.
-        "prop.editGradient" => crate::panels::gradient_editor::open(app, &p)?,
-        "window.scriptPanel" => {
-            let id = p.get("window").and_then(Value::as_u64).ok_or("no ScriptUI panel window")? as u32;
-            app.show_panel(PanelKind::ScriptPanel(id));
-            json!({"window": id})
-        }
-        "layer.style.options" => {
-            crate::panels::layer_styles_dialog::open(app, &p)?;
-            Value::Null
-        }
-        "app.settings" => {
-            let page = p.get("page").and_then(Value::as_str).unwrap_or("general");
-            crate::panels::settings::open(app, effectcraft_engine::prefs::page_id(page).unwrap_or("general"));
-            Value::Null
-        }
-        "app.gpuInfo" => {
-            crate::panels::dialogs::info(
-                app,
-                "GPU Information",
-                &format!(
-                    "{}Layer cache: {} MB  •  Preview cache: {} MB.",
-                    effectcraft_engine::sysinfo::gpu_summary(&app.session),
-                    app.session.layer_cache.budget() >> 20,
-                    app.frames.budget() >> 20
-                ),
-            );
-            Value::Null
-        }
-        "app.hide" | "app.hideOthers" | "app.showAll" => {
-            // The desktop app asks macOS (NSApplication hide / hideOtherApplications /
-            // unhideAllApplications); elsewhere Hide minimizes and the others don't apply.
-            if app.hooks.app_action.as_ref().is_some_and(|f| f(id)) {
-                return Ok(Value::Null);
-            }
-            match id {
-                "app.hide" => ctx.send_viewport_cmd(egui::ViewportCommand::Minimized(true)),
-                _ => return Err(format!("`{id}` is only available on macOS")),
-            }
-            Value::Null
-        }
-        "app.quit" => {
-            ctx.send_viewport_cmd(egui::ViewportCommand::Close);
-            Value::Null
-        }
-        "app.commandPalette" => {
-            app.dialog_state.palette_query = p.get("query").and_then(Value::as_str).unwrap_or_default().to_string();
-            app.dialog_state.palette_sel = 0;
-            app.dialog = Some(crate::Dialog::CommandPalette);
-            Value::Null
-        }
-        "app.keyboardShortcuts" => {
-            crate::panels::shortcut_editor::open(app);
-            Value::Null
-        }
-        "app.templates" => {
-            let kind = p.get("kind").and_then(Value::as_str).unwrap_or("renderSettings");
-            crate::panels::rq_templates::open(app, ctx, kind);
-            Value::Null
-        }
-        "renderQueue.notify" => {
-            // Render finished with Notify on: a toast, the dock/taskbar attention request, and the
-            // host's system sound (the desktop app handles `renderQueue.notify`).
-            let msg = p.get("message").and_then(Value::as_str).unwrap_or("Render finished").to_string();
-            app.toast = Some((msg, now));
-            ctx.send_viewport_cmd(egui::ViewportCommand::RequestUserAttention(egui::UserAttentionType::Informational));
-            if let Some(f) = app.hooks.app_action.as_ref() {
-                f("renderQueue.notify");
-            }
-            Value::Null
-        }
-        "app.find" => {
-            if let Some(q) = p.get("query").and_then(Value::as_str) {
-                app.ui.project_search = q.to_string();
-            }
-            app.show_panel(PanelKind::Project);
-            Value::Null
-        }
-        "playback.toggle" => {
-            // The play button and Spacebar: `{shortcut?}` picks which Preview panel shortcut's
-            // options to play with (default Spacebar).
-            let sc = match p.get("shortcut").and_then(Value::as_str) {
-                Some(k) => effectcraft_engine::preview::PreviewShortcut::parse(k).ok_or_else(|| format!("unknown preview shortcut `{k}`"))?,
-                None => effectcraft_engine::preview::PreviewShortcut::Spacebar,
-            };
-            app.toggle_play_with(now, sc);
-            json!({"playing": app.playback.playing, "shortcut": sc.id()})
-        }
-        "playback.cacheWhenIdle" => {
-            let r = toggle(&mut app.ui.cache_when_idle, &p);
-            app.set_pref("previews.cacheFramesWhenIdle", r.clone())?;
-            r
-        }
-        "playback.audio" => {
-            // Include Audio of the shortcut shown in the Preview panel.
-            let mut on = app.session.prefs.preview.active().include_audio;
-            let r = toggle(&mut on, &p);
-            app.session.execute("playback.settings.set", json!({"includeAudio": on})).map_err(|e| e.to_string())?;
-            if !on {
-                app.audio = None;
-            }
-            r
-        }
-        // Zoom In / Zoom Out act on the focused viewer: the Layer panel when it has focus, else
-        // the Composition viewer.
-        "view.zoomIn" | "view.zoomOut" if app.ui.focused == PanelKind::Layer => {
-            let cur = app.ui.layer_zoom.unwrap_or_else(|| crate::panels::layer_panel::last_fit(ctx));
-            // The Layer panel zooms in points (pixels-per-point 1).
-            let next = zoom_step(cur, 1.0, id == "view.zoomIn");
-            app.ui.layer_zoom = Some(next);
-            json!({"zoom": next, "panel": "layer"})
-        }
-        "view.zoomIn" | "view.zoomOut" => {
-            let ppp = ctx.pixels_per_point();
-            let cur = v.zoom.unwrap_or_else(|| crate::panels::viewer::last_fit(ctx));
-            let next = zoom_step(cur, ppp, id == "view.zoomIn");
-            v.zoom = Some(next);
-            json!({"zoom": next})
-        }
-        // View ▸ Resolution ▸ Custom without a factor (the engine sets the comp's resolution).
-        "view.res.custom" => {
-            let cur = match app.viewer_res() {
-                Resolution::Custom(n) => f64::from(n),
-                _ => 2.0,
-            };
-            crate::panels::dialogs::form(
-                app,
-                "Custom Resolution",
-                "view.res.custom",
-                json!({}),
-                vec![crate::panels::dialogs::Field::num("factor", "Render every n-th pixel", cur)],
-            );
-            Value::Null
-        }
-        "view.rulers" => toggle(&mut v.rulers, &p),
-        "view.guides" => toggle(&mut v.guides, &p),
-        "view.snapToGuides" => toggle(&mut v.snap_guides, &p),
-        "view.lockGuides" => toggle(&mut v.lock_guides, &p),
-        "view.grid" => toggle(&mut v.grid, &p),
-        "view.snapToGrid" => toggle(&mut v.snap_grid, &p),
-        "view.layerControls" => toggle(&mut v.show_layer_controls, &p),
-        "view.options" => {
-            app.dialog = Some(crate::Dialog::ViewOptions);
-            Value::Null
-        }
-        "view.panelBackground" => {
-            if p.get("pick").and_then(Value::as_bool) == Some(true) {
-                let [r, g, b] = v.custom_pasteboard;
-                crate::panels::dialogs::form(
-                    app,
-                    "Panel Background Color",
-                    "view.panelBackground",
-                    json!({}),
-                    vec![crate::panels::dialogs::Field::text("color", "Color (#rrggbb)", &format!("#{r:02x}{g:02x}{b:02x}"))],
-                );
-                return Ok(Value::Null);
-            }
-            let c = p.get("color").and_then(Value::as_str).unwrap_or("mediumGray");
-            v.pasteboard = match c {
-                "black" => Some([0, 0, 0]),
-                "darkGray" => Some([0x2a, 0x2a, 0x2a]),
-                "mediumGray" => None,
-                "lightGray" => Some([0xb4, 0xb4, 0xb4]),
-                "white" => Some([0xff, 0xff, 0xff]),
-                "custom" => Some(v.custom_pasteboard),
-                hex => {
-                    let c = effectcraft_engine::color::Rgba::from_hex(hex).ok_or_else(|| format!("unknown colour `{hex}`"))?;
-                    let rgb = [(c.r * 255.0).round() as u8, (c.g * 255.0).round() as u8, (c.b * 255.0).round() as u8];
-                    v.custom_pasteboard = rgb;
-                    Some(rgb)
-                }
-            };
-            Value::Null
-        }
-        // Ctrl+\ / Cmd+\, as in After Effects (#336): `{maximized}`, the window's new state.
-        "window.maximizeApp" => {
-            let maximized = !ctx.input(|i| i.viewport().maximized.unwrap_or(false));
-            ctx.send_viewport_cmd(egui::ViewportCommand::Maximized(maximized));
-            json!({"maximized": maximized})
-        }
-        "view.fullScreen" => {
-            let full = ctx.input(|i| i.viewport().fullscreen.unwrap_or(false));
-            ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(!full));
-            json!(!full)
-        }
-        "window.panel" => {
-            let name = p.get("panel").and_then(Value::as_str).unwrap_or_default();
-            if name.eq_ignore_ascii_case("tools") {
-                app.ui.status = "The Tools panel is the toolbar in the header".into();
-                return Ok(Value::Null);
-            }
-            let panel = PanelKind::from_name(name).ok_or_else(|| format!("unknown panel `{name}`"))?;
-            app.show_panel(panel);
-            Value::Null
-        }
-        "window.workspace" => {
-            let want = p.get("name").and_then(Value::as_str).unwrap_or("Default").to_ascii_lowercase().replace(' ', "");
-            let name = app
-                .workspace_names()
-                .into_iter()
-                .find(|w| w.to_ascii_lowercase().replace(' ', "") == want)
-                .ok_or_else(|| format!("unknown workspace `{want}`"))?;
-            app.set_workspace(&name);
-            json!({"workspace": name})
-        }
-        "window.resetWorkspace" => {
-            let name = app.ui.workspace.clone();
-            app.set_workspace(&name);
-            Value::Null
-        }
-        "window.saveWorkspace" => {
-            let name = app.ui.workspace.clone();
-            app.ui.saved_workspaces.insert(name.clone(), app.ui.dock.clone());
-            app.ui.saved_floating.insert(name.clone(), app.ui.floating.clone());
-            app.store_saved_workspaces()?;
-            json!({"workspace": name})
-        }
-        "window.saveWorkspaceAs" => {
-            let Some(name) = p.get("name").and_then(Value::as_str).map(str::trim).filter(|n| !n.is_empty()).map(str::to_string) else {
-                crate::panels::dialogs::form(
-                    app,
-                    "New Workspace",
-                    "window.saveWorkspaceAs",
-                    json!({}),
-                    vec![crate::panels::dialogs::Field::text("name", "Name", "Untitled Workspace")],
-                );
-                return Ok(Value::Null);
-            };
-            app.ui.saved_workspaces.insert(name.clone(), app.ui.dock.clone());
-            app.ui.saved_floating.insert(name.clone(), app.ui.floating.clone());
-            app.ui.workspace = name.clone();
-            app.store_saved_workspaces()?;
-            json!({"workspace": name})
-        }
-        "window.editWorkspaces" => {
-            let Some(name) = p.get("name").and_then(Value::as_str).map(str::to_string) else {
-                let cur = app.ui.workspace.clone();
-                crate::panels::dialogs::form(
-                    app,
-                    "Edit Workspaces",
-                    "window.editWorkspaces",
-                    json!({}),
-                    vec![
-                        crate::panels::dialogs::Field::text("name", "Workspace", &cur),
-                        crate::panels::dialogs::Field::text("rename", "Rename to", &cur),
-                        crate::panels::dialogs::Field::bool("delete", "Delete", false),
-                    ],
-                );
-                return Ok(Value::Null);
-            };
-            let builtin = crate::dock::WORKSPACES.contains(&name.as_str());
-            if p.get("delete").and_then(Value::as_bool) == Some(true) {
-                app.ui.saved_floating.remove(&name);
-                if app.ui.saved_workspaces.remove(&name).is_none() && !builtin {
-                    return Err(format!("no workspace `{name}`"));
-                }
-                // Leave the deleted workspace first: a current workspace needs a definition.
-                if app.ui.workspace == name {
-                    app.set_workspace("Default");
-                }
-                app.store_saved_workspaces()?;
-                return Ok(json!({"deleted": name}));
-            }
-            if let Some(new) = p.get("rename").and_then(Value::as_str).map(str::trim).filter(|n| !n.is_empty() && *n != name) {
-                if builtin {
-                    return Err(format!("`{name}` is a built-in workspace: save it as a new workspace instead"));
-                }
-                let dock = app.ui.saved_workspaces.remove(&name).ok_or_else(|| format!("no workspace `{name}`"))?;
-                app.ui.saved_workspaces.insert(new.to_string(), dock);
-                if let Some(f) = app.ui.saved_floating.remove(&name) {
-                    app.ui.saved_floating.insert(new.to_string(), f);
-                }
-                if app.ui.workspace == name {
-                    app.ui.workspace = new.to_string();
-                }
-                app.store_saved_workspaces()?;
-                return Ok(json!({"renamed": new}));
-            }
-            json!({"workspaces": app.workspace_names()})
-        }
-        "view.lookAt" => {
-            let r: Vec<f64> = p.get("rect").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_f64).collect()).unwrap_or_default();
-            if r.len() == 4 {
-                let map: Option<crate::panels::viewer::ViewerMap> = ctx.data(|d| d.get_temp(egui::Id::unique("viewer-map")));
-                if let Some(m) = map {
-                    let (rw, rh) = (((r[2] - r[0]) as f32).max(1.0), ((r[3] - r[1]) as f32).max(1.0));
-                    let zoom = ((m.area.width() - 40.0) / rw).min((m.area.height() - 40.0) / rh).clamp(0.015, 32.0);
-                    let rc = [(r[0] + r[2]) as f32 / 2.0, (r[1] + r[3]) as f32 / 2.0];
-                    let v = &mut app.ui.viewer;
-                    v.zoom = Some(zoom);
-                    v.pan = [m.comp[0] * zoom / 2.0 - rc[0] * zoom, m.comp[1] * zoom / 2.0 - rc[1] * zoom];
-                }
-            }
-            Value::Null
-        }
-        "comp.flowchart" => {
-            // Chart the active comp; Layer ▸ Reveal ▸ Reveal Layer in Project Flowchart shows
-            // layers and selects the layer's node.
-            app.ui.flowchart.root = app.session.active_comp_id().map(|c| c.0);
-            if let (Some(c), Some(l)) = (app.session.active_comp_id(), app.session.state.selected_layers.first()) {
-                app.ui.flowchart.layers = true;
-                app.ui.flowchart.selected = Some(format!("layer:{}:{}", c.0, l.0));
-            }
-            app.show_panel(PanelKind::Flowchart);
-            Value::Null
-        }
-        "comp.miniFlowchart" => {
-            let at = ctx.input(|i| i.pointer.hover_pos()).unwrap_or_else(|| ctx.content_rect().center());
-            app.ui.mini_flowchart = Some([at.x, at.y]);
-            Value::Null
-        }
-        "track.editTargetDialog" => {
-            crate::panels::tracker::open_target(app)?;
-            Value::Null
-        }
-        "track.optionsDialog" => {
-            crate::panels::tracker::open_options(app)?;
-            Value::Null
-        }
-        "layer.openLayer" => {
-            let id = p.get("layer").and_then(Value::as_u64).or_else(|| app.session.state.selected_layers.first().map(|l| l.0));
-            // Another layer opens at Fit.
-            if id != app.ui.layer_panel {
-                app.ui.layer_zoom = None;
-                app.ui.layer_pan = [0.0, 0.0];
-            }
-            app.ui.layer_panel = id;
-            app.ui.layer_view = None;
-            app.show_panel(PanelKind::Layer);
-            Value::Null
-        }
-        "app.confirmExecute" => {
-            // Settings ▸ Scripting ▸ Warn User When Executing Files.
-            let path = p.get("path").and_then(Value::as_str).unwrap_or_default().to_string();
-            crate::panels::forms::form(
-                app,
-                "A script wants to open a file",
-                "file.executeFile",
-                json!({"path": path, "confirmed": true}),
-                vec![crate::panels::forms::Field::text("path", "Open", &path)],
-            );
-            Value::Null
-        }
-        "app.showReport" => {
-            let title = p.get("title").and_then(Value::as_str).unwrap_or("Report").to_string();
-            let text = p.get("text").and_then(Value::as_str).unwrap_or_default().to_string();
-            crate::panels::dialogs::info(app, &title, &text);
-            Value::Null
-        }
-        "window.assignWorkspaceShortcut" => {
-            let mut q = p.clone();
-            q["workspace"] = json!(app.ui.workspace);
-            return run_engine(app, ctx, "window.assignWorkspaceShortcut", q);
-        }
-        "file.interpretFootage" => {
-            // Import ▸ Interpret Unlabeled Alpha As: Ask User.
-            if let Some(i) = p.get("item").and_then(Value::as_u64) {
-                app.session.state.project_selection = vec![effectcraft_engine::project::ItemId(i)];
-            }
-            crate::panels::dialogs::open_form(app, "file.interpretFootage", &json!({}));
-            Value::Null
-        }
-        // Help ▸ In-App Tutorials: the Home screen's Learn tab.
-        "help.inAppTutorials" => {
-            app.ui.start_screen = true;
-            app.ui.home_learn = true;
-            app.ui.home_templates = false;
-            Value::Null
-        }
-        // File ▸ New ▸ New Project from Template…: the Home screen's Templates tab.
-        "file.newFromTemplate" => {
-            app.ui.start_screen = true;
-            app.ui.home_learn = false;
-            app.ui.home_templates = true;
-            Value::Null
-        }
-        "effect.manage" | "anim.browsePresets" => {
-            app.show_panel(PanelKind::EffectsPresets);
-            Value::Null
-        }
-        "timeline.revealProps" => {
-            let props = p.get("props").and_then(Value::as_array).cloned().unwrap_or_default();
-            let uids = |k: &str| -> Vec<u64> { props.iter().filter_map(|x| x.get(k).and_then(Value::as_u64)).collect() };
-            let (found, with_props) = (uids("prop"), uids("layer"));
-            // The layers it looked at (`layers`), else those it found something on. Layers that
-            // have nothing to show close; the others' reveals stay.
-            let targets: Vec<u64> = match p.get("layers").and_then(Value::as_array) {
-                Some(l) => l.iter().filter_map(Value::as_u64).collect(),
-                None => with_props.clone(),
-            };
-            // The targets' earlier picks go (U after UU shows the keyframed ones only).
-            let comp = app.session.active_comp_arc();
-            let theirs = |u: u64| {
-                comp.as_ref().is_some_and(|c| {
-                    targets
-                        .iter()
-                        .filter_map(|l| c.layer(effectcraft_engine::project::LayerId(*l)))
-                        .any(|l| l.props.find(u).is_some() || l.props.find_group(u).is_some())
-                })
-            };
-            let tl = &mut app.ui.timeline;
-            tl.reveal_props.retain(|u| !theirs(*u));
-            tl.reveal_props.extend(found.iter().copied());
-            let (shown, hidden): (Vec<u64>, Vec<u64>) = targets.into_iter().partition(|l| with_props.contains(l));
-            tl.apply_reveal(&hidden, vec![]);
-            if !shown.is_empty() {
-                tl.apply_reveal(&shown, vec!["props".into()]);
-            }
-            // Properties inside effects (puppet pins…) show under their effect, twirled open.
-            for (layer, prop) in props.iter().filter_map(|x| Some((x.get("layer")?.as_u64()?, x.get("prop")?.as_u64()?))) {
-                crate::panels::timeline::open_effect_paths(app, layer, &[prop]);
-            }
-            json!({"revealed": found.len()})
-        }
-        _ => return Err(format!("`{id}` is not a frontend command")),
-    })
-}
-
-/// Commands that need a file or folder path: ask the host's file dialog when `params` lacks one.
-fn file_dialog(app: &mut EffectcraftApp, id: &str, params: &Value) -> Option<Result<Value, String>> {
-    enum Ask {
-        Folder,
-        Import,
-        OpenProject,
-        Save(&'static str),
-        Open(&'static [&'static str]),
-    }
-    let (key, ask) = match id {
-        "file.import" | "file.importMultiple" => ("paths", Ask::Import),
-        "file.open" => ("path", Ask::OpenProject),
-        "file.save" if app.session.path.is_none() => ("path", Ask::Save("Untitled Project.ecproj")),
-        "file.saveAs" | "file.saveCopy" => ("path", Ask::Save("Untitled Project.ecproj")),
-        "comp.saveFrameAs" => ("path", Ask::Save("Frame.png")),
-        "comp.saveFrameAsPsd" => ("path", Ask::Save("Frame.psd")),
-        "comp.saveFrameAsExr" => ("path", Ask::Save("Frame.exr")),
-        "file.watchFolder" if params.get("stop").is_none() => ("folder", Ask::Save("Watch Folder")),
-        "anim.savePreset" => ("path", Ask::Save("Preset.ecpreset")),
-        "anim.applyPreset" => ("path", Ask::Open(&["ecpreset", "json"])),
-        "view.exportGuides" => ("path", Ask::Save("Guides.json")),
-        "view.importGuides" => ("path", Ask::Open(&["json"])),
-        "file.exportLottie" => ("path", Ask::Save("Animation.json")),
-        "file.importLottie" => ("path", Ask::Open(&["json", "lottie"])),
-        "file.importProject" => ("path", Ask::Open(&["ecproj", "ecprojx"])),
-        "file.importTimeline" => ("path", Ask::Open(&["xml", "fcpxml", "otio", "edl", "aaf", "omf"])),
-        "render.saveCurrentPreview" => ("path", Ask::Save("Preview.mp4")),
-        "file.runScript" if params.get("name").is_none() => ("path", Ask::Open(&["jsx", "js", "jsonl", "json", "txt"])),
-        "file.installScript" | "file.installScriptUIPanel" => ("path", Ask::Open(&["jsx", "js"])),
-        "effect.plugins.load" if params.get("folder").is_none() => ("path", Ask::Open(&["wasm", "wat"])),
-        "file.replaceFootage" => ("path", Ask::Import),
-        "file.relinkFootage" => ("folder", Ask::Folder),
-        "file.collectFiles" => ("folder", Ask::Save("Collected Files")),
-        "file.saveCopyAsXml" => ("path", Ask::Save("Untitled Project.ecprojx")),
-        "keys.rpfCameraImport" => ("path", Ask::Open(&["json", "csv", "txt"])),
-        "essential.exportTemplate" => ("path", Ask::Save("Template.ectemplate")),
-        "essential.importTemplate" => ("path", Ask::Open(&["ectemplate"])),
-        "file.setProxy" => {
-            ("path", Ask::Open(&["mp4", "mov", "m4v", "mkv", "webm", "mxf", "png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "tga", "exr"]))
-        }
-        _ => return None,
-    };
-    if params.get(key).is_some()
-        || params.get("path").is_some()
-        || params.get("paths").is_some()
-        || params.get("steps").is_some()
-        || params.get("preset").is_some()
-    {
-        return None;
-    }
-    const MEDIA: &[&str] = &[
-        "mp4", "mov", "m4v", "mkv", "webm", "mxf", "png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "exr", "dpx", "cin", "wav", "aif", "aiff", "mp3",
-        "flac", "ogg", "opus", "svg", "pdf", "ai", "eps", "psd", "psb", "tga", "hdr", "gltf", "glb", "obj", "stl", "fbx", "json", "csv", "tsv",
-    ];
-    // A host whose blocking dialogs are unsafe inside this frame shows the dialog without
-    // blocking — macOS: the nested event loop re-entered winit's handler on a drag over the
-    // window and aborted the app (#511); Linux: the desktop portal's answer never gets pumped,
-    // so the compositor marks the window as not responding (#1275) — and the command continues
-    // when the answer arrives.
-    if let Some(spawn) = app.hooks.file_dialog_async.as_ref() {
-        let request = match ask {
-            Ask::Folder => crate::FileDialog::Folder,
-            Ask::Import => crate::FileDialog::Open { exts: MEDIA.iter().map(|e| e.to_string()).collect(), many: key == "paths" },
-            Ask::OpenProject => crate::FileDialog::OpenProject,
-            Ask::Open(exts) => crate::FileDialog::Open { exts: exts.iter().map(|e| e.to_string()).collect(), many: false },
-            Ask::Save(default) => crate::FileDialog::save(default),
-        };
-        let tx = app.dialog_answers.0.clone();
-        let answer = crate::DialogAnswer { command: id.to_string(), key, params: params.clone(), paths: Vec::new() };
-        spawn(
-            request,
-            Box::new(move |paths| {
-                let _ = tx.send(crate::DialogAnswer { paths, ..answer });
-            }),
-        );
-        return Some(Ok(json!({"dialog": id})));
-    }
-    let picked: Option<Value> = match ask {
-        Ask::Folder => {
-            let Some(f) = app.hooks.pick_folder.as_ref() else { return Some(Err("no folder dialog available (pass `folder`)".into())) };
-            f().map(Value::from)
-        }
-        Ask::Import => {
-            let Some(f) = app.hooks.pick_files.as_ref() else { return Some(Err("no file dialog available (pass `paths`)".into())) };
-            picked_value(key, f(MEDIA))
-        }
-        Ask::OpenProject => {
-            let Some(f) = app.hooks.pick_open_project.as_ref() else { return Some(Err("no file dialog available (pass `path`)".into())) };
-            f().map(|s| json!(s))
-        }
-        Ask::Open(exts) => {
-            let Some(f) = app.hooks.pick_files.as_ref() else { return Some(Err("no file dialog available (pass `path`)".into())) };
-            f(exts).first().map(|s| json!(s))
-        }
-        Ask::Save(default) => {
-            let Some(picked) = app.hooks.save_dialog(default) else { return Some(Err("no file dialog available (pass `path`)".into())) };
-            picked.map(|s| json!(s))
-        }
-    };
-    let Some(v) = picked else { return Some(Ok(Value::Null)) };
-    Some(run_with_picked(app, id, key, params, v))
-}
-
-/// The dialog's answer as the command's `key` parameter (`None`: cancelled).
-fn picked_value(key: &str, paths: Vec<String>) -> Option<Value> {
-    match (paths.is_empty(), key) {
-        (true, _) => None,
-        (false, "paths") => Some(json!(paths)),
-        (false, _) => paths.into_iter().next().map(Value::from),
-    }
-}
-
-/// A file dialog shown without blocking ([`crate::Hooks::file_dialog_async`]) answered: run its
-/// command with the picked path (nothing when it was cancelled).
-pub(crate) fn dialog_answered(app: &mut EffectcraftApp, answer: crate::DialogAnswer) {
-    let Some(v) = picked_value(answer.key, answer.paths) else { return };
-    if let Err(e) = run_with_picked(app, &answer.command, answer.key, &answer.params, v) {
-        app.ui.status = e;
-    }
-}
-
-/// Run command `id` with the path picked for it in parameter `key`.
-fn run_with_picked(app: &mut EffectcraftApp, id: &str, key: &str, params: &Value, v: Value) -> Result<Value, String> {
-    let mut p = params.as_object().cloned().unwrap_or_default();
-    p.insert(key.to_string(), v);
-    // Picked files import in the background, with the Importing card showing progress (#270).
-    if matches!(id, "file.import" | "file.importMultiple") {
-        p.insert("background".into(), Value::Bool(true));
-    }
-    // Photoshop files ask how to import them first; numbered stills whether to import them as an
-    // image sequence.
-    let picked = Value::Object(p.clone());
-    if id == "file.import" && crate::panels::dialogs::open_form(app, id, &picked)
-        || matches!(id, "file.import" | "file.importMultiple") && crate::panels::forms::open_import_sequence(app, &picked)
-    {
-        return Ok(json!({"dialog": id}));
-    }
-    // Save (untitled) becomes Save As.
-    let id = if id == "file.save" { "file.saveAs" } else { id };
-    let r = app.session.execute(id, Value::Object(p)).map_err(|e| e.to_string());
-    if let Err(e) = &r {
-        app.ui.status = e.clone();
-    }
-    r
-}
-
-/// A menu entry for display / `ui.menu.list`.
-#[derive(Clone, Debug, serde::Serialize)]
-pub struct MenuItem {
-    pub id: String,
-    pub label: String,
-    pub path: Vec<String>,
-    pub shortcut: Option<String>,
-    pub enabled: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub checked: Option<bool>,
-    /// Parameters bound to the entry (e.g. the effect for Effect menu items).
-    #[serde(skip_serializing_if = "Value::is_null")]
-    pub params: Value,
-}
-
-/// Top-level menus in order.
-pub fn menus() -> Vec<&'static str> {
-    effectcraft_engine::menus::top_level()
-}
-
-pub(crate) fn entry_label(app: &EffectcraftApp, e: &MenuEntry) -> String {
-    let shown = match e.command.as_str() {
-        "edit.undo" => app.session.history.undo.last().map(|u| format!("Undo {}", u.0)).unwrap_or_else(|| "Can't Undo".into()),
-        "edit.redo" => app.session.history.redo.last().map(|u| format!("Redo {}", u.0)).unwrap_or_else(|| "Can't Redo".into()),
-        // Window ▸ Layer: the layer open in the Layer panel.
-        "window.panel" if e.params.get("panel").and_then(Value::as_str) == Some("layer") => {
-            let name = app
-                .ui
-                .layer_panel
-                .and_then(|id| app.session.active_comp().and_then(|c| c.layer(effectcraft_engine::project::LayerId(id))))
-                .map(|l| l.name.clone());
-            format!("Layer: {}", name.unwrap_or_else(|| "(none)".into()))
-        }
-        _ => effectcraft_engine::menus::entry_label(&app.session, e),
-    };
-    crate::i18n::entry(app, e, shown)
-}
-
-/// The entry's shortcut in the active keyboard shortcut preset.
-pub(crate) fn entry_shortcut(app: &EffectcraftApp, e: &MenuEntry) -> Option<String> {
-    app.session.shortcuts().shortcut_of(&e.command, &e.params).map(str::to_string)
-}
-
-/// Whether panel `p` is on screen: the front tab of a floating window, or of a docked group
-/// (an open frame in a stack) that a maximized panel does not cover.
-pub(crate) fn panel_shown(app: &EffectcraftApp, p: PanelKind) -> bool {
-    if app.ui.floating.iter().any(|f| f.panels.get(f.active) == Some(&p)) {
-        return true;
-    }
-    match app.ui.maximized.filter(|m| app.ui.dock.contains(*m)) {
-        Some(m) => m == p,
-        None => app.ui.dock.is_visible(p),
-    }
-}
-
-/// The command a menu entry runs when chosen from a menu: Window ▸ <panel> closes a panel whose
-/// entry is checked, as in After Effects (#1630). Shortcuts and agents calling `window.panel`
-/// still only show the panel.
-pub(crate) fn menu_choice(app: &EffectcraftApp, id: String, params: Value) -> (String, Value) {
-    if id == "window.panel"
-        && let Some(p) = params.get("panel").and_then(Value::as_str).and_then(PanelKind::from_name)
-        && panel_shown(app, p)
-    {
-        return ("window.closePanel".into(), params);
-    }
-    (id, params)
-}
-
-/// Check-mark state of frontend toggles (engine state is answered by the engine).
-pub(crate) fn entry_checked(app: &EffectcraftApp, e: &MenuEntry) -> Option<bool> {
-    let v = &app.ui.viewer;
-    let pstr = |k: &str| e.params.get(k).and_then(Value::as_str);
-    match e.command.as_str() {
-        "view.rulers" => Some(v.rulers),
-        "view.guides" => Some(v.guides),
-        "view.snapToGuides" => Some(v.snap_guides),
-        "view.lockGuides" => Some(v.lock_guides),
-        "view.grid" => Some(v.grid),
-        "view.snapToGrid" => Some(v.snap_grid),
-        "view.layerControls" => Some(v.show_layer_controls),
-        "playback.cacheWhenIdle" => Some(app.ui.cache_when_idle),
-        "playback.audio" => Some(app.session.prefs.preview.active().include_audio),
-        "window.workspace" => Some(pstr("name").is_some_and(|n| n == app.ui.workspace)),
-        // The Tools panel is the header toolbar: always on screen.
-        "window.panel" => Some(pstr("panel").is_some_and(|n| n.eq_ignore_ascii_case("tools") || PanelKind::from_name(n).is_some_and(|p| panel_shown(app, p)))),
-        "view.panelBackground" if e.params.get("pick").is_none() => {
-            let cur = match v.pasteboard {
-                None => "mediumGray",
-                Some([0, 0, 0]) => "black",
-                Some([0x2a, 0x2a, 0x2a]) => "darkGray",
-                Some([0xb4, 0xb4, 0xb4]) => "lightGray",
-                Some([0xff, 0xff, 0xff]) => "white",
-                Some(_) => "custom",
-            };
-            Some(pstr("color") == Some(cur))
-        }
-        _ => effectcraft_engine::menus::checked(&app.session, &e.command, &e.params),
-    }
-}
-
-pub(crate) fn entry_enabled(app: &EffectcraftApp, e: &MenuEntry) -> bool {
-    // The Project-panel enabled rules mirror the invoke redirects, so they stand down for the
-    // same reason (see the redirect block): while a text edit is open the menu items must be
-    // enabled by what their routed command can do, or the menu grays out commands that work.
-    if app.ui.focused == PanelKind::Project && app.session.state.text_edit.is_none() {
-        match e.command.as_str() {
-            "edit.duplicate" => {
-                return !app.session.state.project_selection.is_empty()
-                    && app.session.state.project_selection.iter().all(|id| app.session.project.item(*id).is_some_and(|i| !i.is_folder()));
-            }
-            "edit.selectAll" => return !app.session.project.items.is_empty(),
-            "edit.deselectAll" => return !app.session.state.project_selection.is_empty(),
-            "edit.cut" | "edit.copy" | "edit.paste" | "edit.copyWithPropertyLinks" | "edit.copyWithRelativePropertyLinks" | "edit.copyExpressionOnly" => {
-                return false;
-            }
-            _ => {}
-        }
-    }
-    if e.command == "edit.clear" && app.ui.focused == PanelKind::Project {
-        return app.session.is_enabled("project.delete");
-    }
-    if e.command == "edit.clear" && app.ui.focused == PanelKind::RenderQueue {
-        return !app.session.is_rendering() && !app.session.project.render_queue.is_empty();
-    }
-    if e.command == "window.panel" {
-        return true;
-    }
-    app.session.is_enabled(&e.command)
-}
-
-/// Every menu entry, flattened with its submenu path.
-pub fn menu_items(app: &EffectcraftApp) -> Vec<MenuItem> {
-    effectcraft_engine::menus::entries()
-        .into_iter()
-        .map(|(path, e)| MenuItem {
-            id: e.command.clone(),
-            label: entry_label(app, e),
-            path,
-            shortcut: entry_shortcut(app, e),
-            enabled: entry_enabled(app, e),
-            checked: entry_checked(app, e),
-            params: e.params.clone(),
-        })
-        .collect()
-}
-
-/// Shortcut text in this OS's notation (`⇧⌘K` on macOS, `Ctrl+Shift+K` elsewhere).
-pub fn shortcut_text(s: &str) -> String {
-    if cfg!(target_os = "macos") {
-        let mut out = String::new();
-        let parts: Vec<&str> = match s.strip_suffix("++") {
-            Some(head) => vec![head, "+"],
-            None => s.split('+').collect(),
-        };
-        let (mods, key) = parts.split_at(parts.len().saturating_sub(1));
-        for m in mods {
-            out.push_str(match *m {
-                "Ctrl" => "⌃",
-                "Alt" => "⌥",
-                "Shift" => "⇧",
-                "Cmd" => "⌘",
-                x => x,
-            });
-        }
-        out.push_str(match key.first().copied().unwrap_or("") {
-            "Space" => "Space",
-            "Escape" => "Esc",
-            "Home" => "↖",
-            k => k,
-        });
-        out
-    } else {
-        s.replace("Cmd", "Ctrl")
-    }
-}
-
-/// Parse "Cmd+Shift+K" into modifiers + key.
-pub fn parse_shortcut(s: &str) -> Option<(egui::Modifiers, egui::Key)> {
-    let mut m = egui::Modifiers::NONE;
-    let mut key = None;
-    // The plus key itself is written `+` or `Cmd++`.
-    let (head, plus) = match s.strip_suffix("++") {
-        Some(h) => (h, true),
-        None if s == "+" => ("", true),
-        None => (s, false),
-    };
-    let mut parts: Vec<&str> = if head.is_empty() { vec![] } else { head.split('+').collect() };
-    if plus {
-        parts.push("+");
-    }
-    for p in parts {
-        match p {
-            "Cmd" => {
-                m.command = true;
-                m.mac_cmd = cfg!(target_os = "macos");
-                if !cfg!(target_os = "macos") {
-                    m.ctrl = true;
-                }
-            }
-            "Physical" => {}
-            "Shift" => m.shift = true,
-            "Alt" => m.alt = true,
-            "Ctrl" => m.ctrl = true,
-            k => {
-                key = match k {
-                    ";" => Some(egui::Key::Semicolon),
-                    "'" => Some(egui::Key::Quote),
-                    "," => Some(egui::Key::Comma),
-                    "." => Some(egui::Key::Period),
-                    "/" => Some(egui::Key::Slash),
-                    "\\" => Some(egui::Key::Backslash),
-                    "=" => Some(egui::Key::Equals),
-                    "-" => Some(egui::Key::Minus),
-                    "`" => Some(egui::Key::Backtick),
-                    "[" => Some(egui::Key::OpenBracket),
-                    "]" => Some(egui::Key::CloseBracket),
-                    "Num0" => Some(egui::Key::Num0),
-                    "Num*" => None,
-                    _ => egui::Key::from_name(k),
-                }
-            }
-        }
-    }
-    key.map(|k| (m, k))
-}
-
-/// The key some keyboards report for a shifted punctuation key (`Shift+=` arrives as `+`).
-fn shifted_alias(k: egui::Key) -> Option<egui::Key> {
-    use egui::Key::*;
-    Some(match k {
-        Equals => Plus,
-        Semicolon => Colon,
-        OpenBracket => OpenCurlyBracket,
-        CloseBracket => CloseCurlyBracket,
-        Slash => Questionmark,
-        Backslash => Pipe,
-        _ => return None,
-    })
-}
-
-/// A key binding: modifiers, key, command id and bound params.
-pub type Binding = (egui::Modifiers, egui::Key, String, Value);
-
-/// All bindings of the active keyboard shortcut preset, most modifiers first.
-pub fn bindings(session: &effectcraft_engine::Session) -> Vec<Binding> {
-    let mut v: Vec<Binding> = Vec::new();
-    for (sc, b) in session.shortcuts().bindings() {
-        if sc.starts_with("Physical+") {
-            continue;
-        }
-        // Off macOS `Cmd` is Ctrl, so a custom Ctrl+Cmd shortcut would
-        // steal the plain Cmd one: such macOS-only shortcuts aren't bound there.
-        if !cfg!(target_os = "macos") && sc.split('+').any(|p| p == "Ctrl") && sc.split('+').any(|p| p == "Cmd") {
-            continue;
-        }
-        if let Some((m, k)) = parse_shortcut(sc) {
-            if m.shift
-                && let Some(alias) = shifted_alias(k)
-            {
-                v.push((m, alias, b.command.clone(), b.params.clone()));
-            }
-            v.push((m, k, b.command.clone(), b.params.clone()));
-        }
-    }
-    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
-}
-
-fn mods_match(want: egui::Modifiers, got: egui::Modifiers) -> bool {
-    want.command == got.command && want.shift == got.shift && want.alt == got.alt && (want.ctrl == got.ctrl || got.command && cfg!(not(target_os = "macos")))
-}
-
-/// Whether the `key`+`mods` chord is the current binding of `command` in the active preset
-/// (so callers that must match a shortcut themselves — like the viewer's text editor, which
-/// holds the keyboard while the shortcut dispatcher is skipped — follow rebinds).
-/// `Physical+`-only bindings never match here, exactly as for the app-wide dispatcher.
-pub fn chord_matches(session: &effectcraft_engine::Session, command: &str, key: egui::Key, mods: egui::Modifiers) -> bool {
-    bindings(session).into_iter().any(|(m, k, id, _)| id == command && k == key && mods_match(m, mods))
-}
-
-/// Whether a Deselect All chord matched by [`chord_matches`] may run while a text editor holds
-/// the keyboard. Chords carrying Cmd/Ctrl/Alt are command chords (the editor treats them as
-/// such for undo and the rest), and function keys never type, so those forward from the editor;
-/// a chord that could instead produce a character — a bare or Shift-only letter, digit or
-/// punctuation key, as from a pathological bare-letter rebinding — stays with the editor so
-/// typing keeps working, the same invariant the app-wide dispatcher honors by skipping
-/// focused text fields.
-pub fn forwardable_during_text_edit(mods: egui::Modifiers, key: egui::Key) -> bool {
-    mods.command || mods.ctrl || mods.alt || (egui::Key::F1..=egui::Key::F35).contains(&key)
-}
-
-/// Set (egui temp data) from a plain Spacebar press until its release while a tap would still
-/// run the Spacebar shortcut.
-/// The system clipboard's text of this frame's paste event, for the Edit ▸ Paste it runs.
-fn system_paste_id() -> egui::Id {
-    egui::Id::unique("menus-system-paste")
-}
-
-fn space_tap_id() -> egui::Id {
-    egui::Id::unique("spacebar-tap")
-}
-
-/// The modifiers held when this frame's input began: the state the last pass ended with, if it
-/// ran this (egui keeps only the state after the frame's events). Records this pass's state.
-fn modifiers_at_start(ctx: &egui::Context) -> Option<egui::Modifiers> {
-    let id = egui::Id::unique("shortcut-modifiers");
-    let pass = ctx.cumulative_pass_nr();
-    let now = ctx.input(|i| i.modifiers);
-    ctx.data_mut(|d| {
-        let last = d.get_temp::<(u64, egui::Modifiers, Option<egui::Modifiers>)>(id);
-        if let Some((p, _, start)) = last
-            && p == pass
-        {
-            return start;
-        }
-        let start = last.and_then(|(p, m, _)| (p.checked_add(1) == Some(pass)).then_some(m));
-        d.insert_temp(id, (pass, now, start));
-        start
-    })
-}
-
-/// Only Shift held (Shift+Delete, not Ctrl/Alt+Shift+Delete).
-fn only_shift(m: egui::Modifiers) -> bool {
-    m.shift && !m.alt && !m.ctrl && !m.command && !m.mac_cmd
-}
-
-/// Dispatch keyboard shortcuts (skipped while typing in a text field).
-pub fn handle_shortcuts(app: &mut EffectcraftApp, ctx: &egui::Context) {
-    handle_shortcuts_impl(app, ctx, false);
-}
-
-/// Tab can acquire widget focus while the current frame is drawn. Dispatch its application
-/// binding only afterward, and only when no widget owned focus before or after layout.
-pub fn handle_tab_shortcut(app: &mut EffectcraftApp, ctx: &egui::Context) {
-    if ctx.input(|i| i.key_pressed(egui::Key::Tab)) {
-        handle_shortcuts_impl(app, ctx, true);
-    }
-}
-
-fn handle_shortcuts_impl(app: &mut EffectcraftApp, ctx: &egui::Context, tab_only: bool) {
-    let start = modifiers_at_start(ctx);
-    // Dialog cancellation owns Escape even when a text field has keyboard focus.
-    if !tab_only && app.dialog.is_some() && ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
-        // A popup or colour picker takes Escape first (the picker goes back to its original colour).
-        if crate::panels::shortcut_editor::recording(app)
-            || crate::panels::shortcut_editor::confirming(app)
-            || egui::Popup::is_any_open(ctx)
-            || crate::color_picker::open_recently(ctx)
-        {
-            return;
-        }
-        ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape));
-        if app.dialog == Some(crate::Dialog::LayerStyles) {
-            crate::panels::layer_styles_dialog::finish(app, false);
-        } else if app.dialog == Some(crate::Dialog::Info) {
-            crate::panels::forms::close_info(app);
-        } else {
-            if app.dialog == Some(crate::Dialog::Settings)
-                && let Some(p) = app.dialog_state.prefs_snapshot.take()
-            {
-                app.session.prefs = p;
-                app.session.prefs_changed();
-            }
-            if app.dialog == Some(crate::Dialog::UnsavedChanges) {
-                app.dialog_state.unsaved.command = None;
-            }
-            app.dialog = None;
-        }
-        return;
-    }
-    // A mouse button down while Spacebar is held belongs to the Hand tool: its release won't
-    // preview.
-    if ctx.input(|i| i.pointer.any_down()) || ctx.egui_wants_keyboard_input() {
-        ctx.data_mut(|d| d.remove::<bool>(space_tap_id()));
-    }
-    // While a menu or popup list is open, keys go to it, not to the app (Space must not start a
-    // preview behind the menu, #279).
-    if ctx.egui_wants_keyboard_input() || crate::widgets::any_menu_open(ctx) {
-        return;
-    }
-    // Text editing in the viewer takes the clipboard events itself.
-    let clipboard = app.session.state.text_edit.is_none();
-    let project = app.ui.focused == PanelKind::Project;
-    // The paste event's text: Edit ▸ Paste pastes SVG markup as a shape layer.
-    let pasted =
-        if clipboard { ctx.input(|i| i.events.iter().rev().find_map(|e| if let egui::Event::Paste(t) = e { Some(t.clone()) } else { None })) } else { None };
-    let mut events: Vec<(egui::Key, egui::Modifiers, bool, Option<egui::Key>)> = ctx.input(|i| {
-        // The windowing layer turns Ctrl+C / Ctrl+X / Ctrl+V into clipboard events instead of
-        // key presses: map them back to the keys (with the modifiers held) so Edit ▸ Copy, Cut,
-        // Paste and their variants (Ctrl+Alt+C…) run. Clipboard events carry no modifiers and
-        // `i.modifiers` is the state after all of the frame's events, so each is read with the
-        // modifiers where it is in the stream: walk the events from the frame's starting state.
-        // `None` when that isn't known.
-        let changed = i.events.iter().any(|e| matches!(e, egui::Event::ModifiersChanged(_) | egui::Event::WindowFocused(false)));
-        let mut at = if changed { start } else { Some(i.modifiers) };
-        let held = |at: Option<egui::Modifiers>| at.filter(|m| m.command).unwrap_or(egui::Modifiers::COMMAND);
-        let mut out = Vec::new();
-        for e in &i.events {
-            match e {
-                egui::Event::ModifiersChanged(m) => at = Some(*m),
-                // egui forgets the modifiers held when the window loses focus.
-                egui::Event::WindowFocused(false) => at = Some(egui::Modifiers::NONE),
-                egui::Event::Key { key, physical_key, pressed: true, modifiers, repeat, .. }
-                    if !*repeat
-                        || matches!(
-                            key,
-                            egui::Key::PageUp | egui::Key::PageDown | egui::Key::ArrowLeft | egui::Key::ArrowRight | egui::Key::ArrowUp | egui::Key::ArrowDown
-                        ) =>
-                {
-                    out.push((*key, *modifiers, true, *physical_key));
-                }
-                egui::Event::Key { key: egui::Key::Space, pressed: false, .. } => out.push((egui::Key::Space, egui::Modifiers::NONE, false, None)),
-                egui::Event::Copy if clipboard => out.push((egui::Key::C, held(at), true, None)),
-                // On Windows, Shift+Delete is the old Cut key and arrives as Cut too. The Project
-                // panel has no clipboard: there a Cut with only Shift held is Shift+Delete (Delete
-                // Project Items Without Confirmation). Never when the modifiers aren't known.
-                egui::Event::Cut if clipboard && project && at.is_some_and(only_shift) => {
-                    out.push((egui::Key::Delete, egui::Modifiers::SHIFT, true, None));
-                }
-                egui::Event::Cut if clipboard => out.push((egui::Key::X, held(at), true, None)),
-                egui::Event::Paste(_) if clipboard => out.push((egui::Key::V, held(at), true, None)),
-                _ => {}
-            }
-        }
-        out
-    });
-    events.retain(|(key, _, _, _)| (*key == egui::Key::Tab) == tab_only);
-    // Numpad * (or `*` typed with Shift+8): Add Marker (#275). egui has no key for it, so it
-    // comes as text.
-    if !tab_only && clipboard && app.dialog.is_none() && ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::Text(t) if t == "*"))) {
-        let bound = app.session.shortcuts().bindings().into_iter().find(|(k, _)| *k == "Num*").map(|(_, b)| (b.command.clone(), b.params.clone()));
-        // As in After Effects, it marks the selected layers; only with none selected does it add
-        // a composition marker (#976).
-        let bound = bound.map(|(id, params)| {
-            if id == "comp.addMarker" && !app.session.state.selected_layers.is_empty() { ("layer.addMarker".to_owned(), params) } else { (id, params) }
-        });
-        if let Some((id, params)) = bound
-            && let Err(e) = invoke(app, ctx, &id, if params.is_null() { json!({}) } else { params })
-        {
-            app.ui.status = e;
-        }
-    }
-    if events.is_empty() {
-        return;
-    }
-    let binds = bindings(&app.session);
-    for (key, mods, pressed, physical_key) in events {
-        // Plain Spacebar runs its shortcut (Play Current Preview) on the release: held, it is
-        // the Hand tool (After Effects), and a drag with it must not start or stop playback.
-        if key == egui::Key::Space && (!pressed || !mods.any()) {
-            if pressed {
-                if app.dialog.is_none() {
-                    ctx.data_mut(|d| d.insert_temp(space_tap_id(), true));
-                }
-                continue;
-            }
-            if !ctx.data_mut(|d| d.remove_temp::<bool>(space_tap_id())).unwrap_or(false) {
-                continue;
-            }
-        }
-        // Escape closes dialogs.
-        if key == egui::Key::Escape && app.dialog.is_some() {
-            // Escape while recording a shortcut cancels the recording, not the editor; so does
-            // Escape in its Delete Preset prompt.
-            if crate::panels::shortcut_editor::recording(app) || crate::panels::shortcut_editor::confirming(app) {
-                continue;
-            }
-            if app.dialog == Some(crate::Dialog::Info) {
-                crate::panels::forms::close_info(app);
-                continue;
-            }
-            // Escape in Settings is Cancel: restore the settings from when it opened.
-            if app.dialog == Some(crate::Dialog::Settings)
-                && let Some(p) = app.dialog_state.prefs_snapshot.take()
-            {
-                app.session.prefs = p;
-                app.session.prefs_changed();
-            }
-            app.dialog = None;
-            continue;
-        }
-        if app.dialog.is_some() {
-            continue;
-        }
-        // Enter in the Project panel renames the selected item (handled by the panel).
-        if key == egui::Key::Enter && !mods.any() && app.ui.focused == PanelKind::Project {
-            continue;
-        }
-        // The Project panel has its own selection; a previously selected Timeline layer
-        // must not be deleted while the Project panel has focus.
-        if matches!(key, egui::Key::Delete | egui::Key::Backspace) && !mods.any() {
-            if matches!(app.ui.focused, PanelKind::Composition | PanelKind::Viewer(_)) && !app.session.state.camera_points.is_empty() {
-                if let Err(e) = run_engine(app, ctx, "camera.deletePoints", json!({})) {
-                    app.ui.status = e;
-                }
-                ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, key));
-                continue;
-            }
-            // The queue panel consumes the event after its selection state is drawn.
-            if app.ui.focused == PanelKind::RenderQueue {
-                continue;
-            }
-            let _ = invoke(app, ctx, "edit.clear", json!({}));
-            continue;
-        }
-        // Explicit physical bindings distinguish keys that a layout reports with the same
-        // logical name (for example AZERTY's minus and right parenthesis).
-        let physical = physical_key.and_then(|key| {
-            app.session.shortcuts().bindings().into_iter().find_map(|(sc, b)| {
-                let (m, k) = parse_shortcut(sc.strip_prefix("Physical+")?)?;
-                (k == key && mods_match(m, mods)).then(|| (b.command.clone(), b.params.clone()))
-            })
-        });
-        if let Some((id, params)) = physical {
-            if let Err(e) = invoke(app, ctx, &id, if params.is_null() { json!({}) } else { params }) {
-                app.ui.status = e;
-            }
-            continue;
-        }
-        if let Some((_, _, id, params)) = binds.iter().filter(|(m, k, ..)| *k == key && mods_match(*m, mods)).min_by_key(|(_, _, id, params)| {
-            // The focused panel wins over an application command sharing its chord.
-            let key = effectcraft_engine::shortcuts::binding_key(id, params);
-            app.session.shortcuts().find(&key).is_none_or(|b| b.scope != app.ui.focused.id())
-        }) {
-            let (id, params) = (id.clone(), if params.is_null() { json!({}) } else { params.clone() });
-            if id == "edit.paste"
-                && let Some(t) = &pasted
-            {
-                ctx.data_mut(|d| d.insert_temp(system_paste_id(), t.clone()));
-            }
-            if let Err(e) = invoke(app, ctx, &id, params) {
-                app.ui.status = e;
-            }
-            ctx.data_mut(|d| d.remove_temp::<String>(system_paste_id()));
-        }
-    }
-}
-
-/// The id under which [`menu_bar`] remembers which of its menus was open at the end of the last
-/// frame (its title's open look, and the hover that switches between the titles).
-fn open_menu_id() -> egui::Id {
-    egui::Id::unique("menu-bar-open")
-}
-
-/// The id under which [`menu_bar`] remembers a title press still in progress (press-and-browse).
-fn browse_menu_id() -> egui::Id {
-    egui::Id::unique("menu-bar-browse")
-}
-
-/// Draw the in-window menu bar (the engine's AE menu tree).
-///
-/// The titles open on the press, not the release (native menu bars): while one is held the menus
-/// can be browsed by moving onto them, and releasing over an entry chooses it. Hovering another
-/// title switches the open menu to it, and the open one closes on a press outside it or when the
-/// window loses focus. The pointer leaving the window — onto the OS title bar, directly above the
-/// bar — closes nothing, however long: the platform forwards none of the title bar's clicks to
-/// egui (only the cursor leaving), so there is no click to close on and a graze must not drop the
-/// menu. The closing press itself still reaches the widget under it, as a click does in After
-/// Effects.
-pub fn menu_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui) {
-    let ctx = ui.ctx().clone();
-    let mut clicked: Option<(String, Value)> = None;
-    let mut nav = crate::menu_keys::Nav::default();
-    // The open menu as of the last frame: the titles are drawn before this frame can open or
-    // close anything, and what happened last frame is what they must react to.
-    let open_prev: Option<usize> = ctx.data(|d| d.get_temp(open_menu_id())).flatten();
-    if ctx.data(|d| d.get_temp(browse_menu_id())).unwrap_or(false) {
-        nav.set_browsing();
-    }
-    let mut drawn = 0;
-    ui.horizontal_centered(|ui| {
-        ui.add_space(6.0);
-        egui::MenuBar::new().config(egui::containers::menu::MenuConfig::new().style(crate::widgets::menu_style)).ui(ui, |ui| {
-            for node in effectcraft_engine::menus::menu_bar() {
-                let MenuNode::Submenu { label, children } = node else { continue };
-                // The open title takes the open button's look while its menu is up (as in AE).
-                let inactive = ui.style().visuals.widgets.inactive;
-                if open_prev == Some(drawn) {
-                    ui.style_mut().visuals.widgets.inactive = ui.style().visuals.widgets.open;
-                }
-                let mut response = ui.add(egui::Button::new(crate::i18n::label(app, "", label)));
-                ui.style_mut().visuals.widgets.inactive = inactive;
-                // A press on a title opens its menu at once (a second press on the open one closes
-                // it), and while it is held the menus below are browsable. The keyboard and the
-                // accessibility activation report `clicked` without the primary button (the press
-                // then happened somewhere else), and toggle the menu. Hovering another title
-                // switches to it once the pointer has moved: merely resting there must not take a
-                // keyboard-driven menu over.
-                let moved = ctx.input(|i| i.pointer.delta() != egui::Vec2::ZERO);
-                // With the button down elsewhere nothing is hovered, so the title under the
-                // pointer takes the highlight by hand: the hover-switch to it shows, one frame
-                // later like egui's own hover (the open title keeps its open look).
-                if moved && response.contains_pointer() && open_prev.is_some_and(|p| p != drawn) {
-                    response = response.highlight();
-                }
-                let pressed = ctx.input(|i| i.pointer.button_pressed(egui::PointerButton::Primary)) && response.hovered();
-                let cmd = if pressed {
-                    nav.set_browsing();
-                    Some(egui::SetOpenCommand::Bool(open_prev != Some(drawn)))
-                } else if response.clicked() && !response.clicked_by(egui::PointerButton::Primary) {
-                    Some(egui::SetOpenCommand::Toggle)
-                } else if moved && response.enabled() && response.contains_pointer() && open_prev.is_some_and(|p| p != drawn) {
-                    Some(egui::SetOpenCommand::Bool(true))
-                } else {
-                    None
-                };
-                let inner = egui::Popup::menu(&response)
-                    .close_behavior(egui::PopupCloseBehavior::IgnoreClicks)
-                    .style(crate::widgets::menu_style)
-                    .open_memory(cmd)
-                    .show(|ui| {
-                        ui.set_min_width(if label == "Effect" { 200.0 } else { 280.0 });
-                        let browsing = nav.browsing();
-                        crate::widgets::menu_scroll(ui, browsing, |ui| menu_nodes(app, ui, children, &mut clicked, &mut nav, 0));
-                    });
-                nav.top(&response);
-                // The titles and the open menus: a press inside them is not an outside press.
-                nav.cover(response.rect);
-                if let Some(inner) = &inner {
-                    nav.cover(inner.response.rect);
-                }
-                app.auto.add(&format!("menu.{label}"), response.rect, label);
-                drawn += 1;
-            }
-        });
-    });
-    crate::menu_keys::handle(&ctx, &nav);
-    // egui leaves the closing to us (`IgnoreClicks`), so the menus close here: at once on a press
-    // outside them (the press itself still reaches the widget below) and when the window loses
-    // focus. The pointer leaving the window closes nothing: moving onto the OS title bar fires
-    // the cursor-left event and the platform forwards none of its clicks to egui, so there is no
-    // click to close on — and a graze or a stay must not drop the menu, as in native apps.
-    if let Some(top) = nav.open_popup(&ctx) {
-        let focus_lost = ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::WindowFocused(false))));
-        let outside_press = ctx.input(|i| i.pointer.any_pressed() && i.pointer.interact_pos().is_some_and(|p| !nav.covers(p)));
-        if focus_lost || outside_press {
-            egui::Popup::close_id(&ctx, top);
-        }
-    }
-    if let Some((id, params)) = clicked.map(|(id, params)| menu_choice(app, id, params))
-        && let Err(e) = invoke(app, &ctx, &id, if params.is_null() { json!({}) } else { params })
-    {
-        app.ui.status = e;
-    }
-    // What the next frame starts from: the open title, and a title press still in progress.
-    let open = nav.open_index(&ctx);
-    let browsing = open.is_some() && nav.browsing() && ctx.input(|i| i.pointer.primary_down());
-    ctx.data_mut(|d| {
-        d.insert_temp(open_menu_id(), open);
-        d.insert_temp(browse_menu_id(), browsing);
-    });
-}
-
-/// The entries of top-level menu `name` (the Effect menu is the Effect Controls panel's context
-/// menu); returns the chosen command and its params.
-pub(crate) fn menu_contents(app: &mut EffectcraftApp, ui: &mut egui::Ui, name: &str) -> Option<(String, Value)> {
-    let mut clicked = None;
-    if let Some(MenuNode::Submenu { children, .. }) =
-        effectcraft_engine::menus::menu_bar().iter().find(|n| matches!(n, MenuNode::Submenu { label, .. } if label == name))
-    {
-        menu_nodes(app, ui, children, &mut clicked, &mut crate::menu_keys::Nav::default(), 0);
-    }
-    clicked.map(|(id, params)| (id, if params.is_null() { json!({}) } else { params }))
-}
-
-/// The entries `nodes` of a menu `depth` submenus deep, registered with `nav` for the keyboard.
-fn menu_nodes(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    nodes: &[MenuNode],
-    clicked: &mut Option<(String, Value)>,
-    nav: &mut crate::menu_keys::Nav,
-    depth: usize,
-) {
-    for n in nodes {
-        match n {
-            MenuNode::Separator => {
-                ui.separator();
-            }
-            MenuNode::Dynamic { name } => {
-                // Recent projects / footage / presets, undo history, shortcut slots, viewers,
-                // saved workspaces.
-                let ws = app.ui.workspace.clone();
-                let saved = app.saved_workspace_names();
-                let (entries, empty) = effectcraft_engine::menus::dynamic(&app.session, name, &dyn_ctx(&ws, &saved));
-                if entries.is_empty()
-                    && let Some(e) = empty
-                {
-                    ui.add_enabled(false, egui::Button::new((gutter(false), e)));
-                }
-                for (i, e) in entries.iter().enumerate() {
-                    let tip = match name.as_str() {
-                        "recentProjects" => app.session.prefs.recent_projects.get(i).cloned(),
-                        "recentFootage" => app.session.prefs.recent_footage.get(i).cloned(),
-                        "recentPresets" => app.session.prefs.recent_presets.get(i).cloned(),
-                        _ => None,
-                    };
-                    let r = ui.add_enabled(entry_enabled(app, e), egui::Button::new((gutter(entry_checked(app, e) == Some(true)), e.label.as_str())));
-                    let r = match &tip {
-                        Some(t) => r.on_hover_text(t),
-                        None => r,
-                    };
-                    let r = browse_hover(nav, r);
-                    app.auto.add(&format!("menu.{name}.{i}"), r.rect, &e.label);
-                    nav.entry(ui, depth, &r, false);
-                    if r.clicked() || browse_pick(nav, ui, &r) {
-                        *clicked = Some((e.command.clone(), e.params.clone()));
-                        ui.close();
-                    }
-                }
-            }
-            MenuNode::Submenu { label, children } => {
-                let ws = app.ui.workspace.clone();
-                // The generated Effect menu's category submenus draw the catalog's name (#821);
-                // every other submenu goes through the menu catalog.
-                let shown = crate::i18n::effect_category(children, label)
-                    .unwrap_or_else(|| crate::i18n::submenu(app, label, effectcraft_engine::menus::submenu_label(&app.session, label, &dyn_ctx(&ws, &[]))));
-                let browsing = nav.browsing();
-                let egui::InnerResponse { inner, response } = ui.menu_button((gutter(false), shown.as_str()), |ui| {
-                    ui.set_min_width(if children.len() > 30 { 200.0 } else { 240.0 });
-                    crate::widgets::menu_scroll(ui, browsing, |ui| menu_nodes(app, ui, children, clicked, nav, depth + 1));
-                });
-                let response = browse_hover(nav, response);
-                nav.entry(ui, depth, &response, true);
-                if inner.is_some() {
-                    // `ui.menu_button` drops the popup's own response on the floor: read it back,
-                    // so that a press inside this submenu doesn't count as an outside press.
-                    let sub = egui::containers::menu::SubMenu::id_from_widget_id(response.id);
-                    if let Some(resp) = ui.ctx().read_response(sub) {
-                        nav.cover(resp.rect);
-                    }
-                    nav.opened(depth, &response);
-                }
-            }
-            MenuNode::Item(e) => {
-                let r = browse_hover(nav, menu_entry(app, ui, e));
-                nav.entry(ui, depth, &r, false);
-                if r.clicked() || browse_pick(nav, ui, &r) {
-                    *clicked = Some((e.command.clone(), e.params.clone()));
-                    ui.close();
-                }
-            }
-        }
-    }
-}
-
-/// The row `r` highlighted while the bar is mid press-and-browse: with a button down egui reports
-/// nothing as hovered — which would leave browsing with no hover feedback at all — so the row
-/// under the pointer takes the highlight by hand. It reads as the hover look one frame later,
-/// exactly egui's own hover latency; disabled rows ignore it (`Noninteractive`), as in native
-/// menus. Context menus use their own [`crate::menu_keys::Nav`], where the bar never browses.
-fn browse_hover(nav: &crate::menu_keys::Nav, r: egui::Response) -> egui::Response {
-    if nav.browsing() && r.contains_pointer() { r.highlight() } else { r }
-}
-
-/// Whether a press-and-browse (a menu-bar title still held down) releases over entry `r`, which
-/// then chooses it like a click does. egui reports neither for it: the release is far from the
-/// press, so there is no click, and nothing but the pressed widget is hovered while a button is
-/// down, so the row has to be tested by the pointer being over it.
-fn browse_pick(nav: &crate::menu_keys::Nav, ui: &egui::Ui, r: &egui::Response) -> bool {
-    nav.browsing() && r.enabled() && r.contains_pointer() && ui.input(|i| i.pointer.button_released(egui::PointerButton::Primary))
-}
-
-/// The menu bar's submenu at `path` (`["File", "Interpret Footage"]`) in a panel's context menu,
-/// with the menu bar's labels, shortcuts and enabled state; a chosen entry goes to `clicked`.
-pub(crate) fn submenu_at(app: &mut EffectcraftApp, ui: &mut egui::Ui, path: &[&str], clicked: &mut Option<(String, Value)>) {
-    let mut nodes = effectcraft_engine::menus::menu_bar();
-    let mut found = None;
-    for label in path {
-        let Some(n) = nodes.iter().find(|n| matches!(n, MenuNode::Submenu { label: l, .. } if l == label)) else { return };
-        if let MenuNode::Submenu { children, .. } = n {
-            nodes = children;
-        }
-        found = Some(n);
-    }
-    if let Some(n) = found {
-        menu_nodes(app, ui, std::slice::from_ref(n), clicked, &mut crate::menu_keys::Nav::default(), 0);
-    }
-    if let Some((_, p)) = clicked.as_mut()
-        && p.is_null()
-    {
-        *p = json!({});
-    }
-}
-
-/// The menu bar's entry for `command` in a panel's context menu (see [`submenu_at`]).
-pub(crate) fn entry_for(app: &EffectcraftApp, ui: &mut egui::Ui, command: &str, clicked: &mut Option<(String, Value)>) {
-    if let Some((_, e)) = effectcraft_engine::menus::entries().into_iter().find(|(_, e)| e.command == command)
-        && menu_entry(app, ui, e).clicked()
-    {
-        *clicked = Some((e.command.clone(), e.params_or_empty()));
-        ui.close();
-    }
-}
-
-/// Frontend state for dynamic menus (the current workspace and the saved ones).
-pub(crate) fn dyn_ctx<'a>(workspace: &'a str, saved_workspaces: &'a [String]) -> effectcraft_engine::menus::DynCtx<'a> {
-    effectcraft_engine::menus::DynCtx { workspace: Some(workspace), saved_workspaces }
-}
-
-/// The check-mark column every menu row reserves (like macOS / After Effects menus).
-fn gutter(checked: bool) -> egui::Atom<'static> {
-    use egui::AtomExt;
-    (if checked { "✔" } else { "" }).atom_size(egui::vec2(14.0, 14.0))
-}
-
-fn menu_entry(app: &EffectcraftApp, ui: &mut egui::Ui, e: &MenuEntry) -> egui::Response {
-    let (label, check, enabled) = (entry_label(app, e), gutter(entry_checked(app, e) == Some(true)), entry_enabled(app, e));
-    // Edit ▸ Label's entries show the label's colour before its name.
-    if e.command == "edit.label"
-        && let Some(l) = e.params.get("label").and_then(Value::as_str).and_then(effectcraft_engine::color::Label::from_name)
-    {
-        let out = ui.add_enabled_ui(enabled, |ui| egui::Button::new((check, crate::widgets::label_swatch(), label)).atom_ui(ui)).inner;
-        crate::widgets::paint_label_swatch(ui, &out, l, &app.tokens);
-        return out.response;
-    }
-    let mut b = egui::Button::new((check, label));
-    if let Some(s) = entry_shortcut(app, e) {
-        b = b.shortcut_text(shortcut_text(&s));
-    }
-    ui.add_enabled(enabled, b)
-}
-
-/// View ▸ Zoom In / Zoom Out: the next standard magnification (as a share of screen pixels, so
-/// 100 % is one comp pixel per screen pixel at any display scaling) above or below `cur`, which is
-/// in points per comp pixel like the result (#882).
-fn zoom_step(cur: f32, ppp: f32, zoom_in: bool) -> f32 {
-    const STEPS: [f32; 16] = [0.015, 0.03, 0.0625, 0.125, 0.25, 0.333, 0.5, 0.66, 1.0, 1.5, 2.0, 3.0, 4.0, 8.0, 16.0, 32.0];
-    let ppp = if ppp.is_finite() && ppp > 0.0 { ppp } else { 1.0 };
-    let shown = cur * ppp;
-    let next = if zoom_in {
-        STEPS.iter().copied().find(|s| *s > shown + 1e-3).unwrap_or(32.0)
-    } else {
-        STEPS.iter().rev().copied().find(|s| *s < shown - 1e-3).unwrap_or(0.015)
-    };
-    next / ppp
-}
-
 #[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// #882: at 125 % / 150 % display scaling Zoom In reaches 100 % (one comp pixel per screen
-    /// pixel), not 100 % in points (125 % / 150 % on screen).
-    #[test]
-    fn zoom_steps_land_on_whole_screen_magnifications() {
-        for ppp in [1.0f32, 1.25, 1.5, 2.0] {
-            let at_100 = zoom_step(0.7 / ppp, ppp, true);
-            assert!((at_100 * ppp - 1.0).abs() < 1e-6, "ppp {ppp}: {}", at_100 * ppp);
-            assert!((zoom_step(at_100, ppp, true) * ppp - 1.5).abs() < 1e-6);
-            assert!((zoom_step(at_100, ppp, false) * ppp - 0.66).abs() < 1e-6);
-        }
-        assert!(zoom_step(1.0, 0.0, true).is_finite());
-    }
-
-    #[test]
-    fn shortcut_passes_share_frame_start_modifiers() {
-        let ctx = egui::Context::default();
-        let mut starts = Vec::new();
-        let mut output = ctx.run_ui(egui::RawInput { events: vec![egui::Event::ModifiersChanged(egui::Modifiers::SHIFT)], ..Default::default() }, |ui| {
-            let ctx = ui.ctx();
-            starts.push(modifiers_at_start(ctx));
-            starts.push(modifiers_at_start(ctx));
-        });
-        output.textures_delta.clear();
-        assert_eq!(starts, vec![None, None]);
-        starts.clear();
-        let mut output = ctx.run_ui(egui::RawInput { events: vec![egui::Event::ModifiersChanged(egui::Modifiers::NONE)], ..Default::default() }, |ui| {
-            let ctx = ui.ctx();
-            starts.push(modifiers_at_start(ctx));
-            starts.push(modifiers_at_start(ctx));
-        });
-        output.textures_delta.clear();
-        assert_eq!(starts, vec![Some(egui::Modifiers::SHIFT), Some(egui::Modifiers::SHIFT)]);
-    }
-
-    #[test]
-    fn every_ui_shortcut_parses() {
-        for c in UI_COMMANDS {
-            if let Some(sc) = c.shortcut {
-                assert!(parse_shortcut(sc).is_some() || sc == "Num*", "{sc}");
-            }
-        }
-        for (_, e) in effectcraft_engine::menus::entries() {
-            if let Some(sc) = &e.shortcut {
-                assert!(parse_shortcut(sc).is_some() || sc == "Num*", "{} ({sc})", e.label);
-            }
-        }
-    }
-
-    #[test]
-    fn full_screen_default_is_platform_specific() {
-        let app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        let full_screen = app.session.shortcuts().shortcut_of("view.fullScreen", &Value::Null);
-        if cfg!(target_os = "macos") {
-            assert_eq!(full_screen, Some("Ctrl+Cmd+F"));
-        } else {
-            assert_eq!(full_screen, None);
-            assert_eq!(app.session.shortcuts().shortcut_of("window.maximizeApp", &Value::Null), Some("Cmd+\\"));
-        }
-    }
-
-    #[test]
-    fn ui_and_menu_shortcuts_do_not_collide() {
-        let app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        let mut seen: std::collections::BTreeMap<(String, String), (String, String)> = Default::default();
-        for (m, k, id, params) in bindings(&app.session) {
-            let key = (format!("{m:?}"), format!("{k:?}"));
-            let target = (id.clone(), params.to_string());
-            if let Some(prev) = seen.get(&key) {
-                assert_eq!(prev, &target, "{key:?} bound to {prev:?} and {target:?}");
-            } else {
-                seen.insert(key, target);
-            }
-        }
-    }
-
-    /// #336: Ctrl+\ (Cmd+\ on macOS) maximizes the application window, and again restores
-    /// it, as in After Effects.
-    #[test]
-    fn ctrl_backslash_maximizes_or_restores_the_window() {
-        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        let (m, k) = parse_shortcut("Cmd+\\").unwrap();
-        assert!(m.command && k == egui::Key::Backslash, "{m:?} {k:?}");
-        assert!(bindings(&app.session).iter().any(|b| (b.0, b.1) == (m, k) && b.2 == "window.maximizeApp"));
-        let ctx = egui::Context::default();
-        let run = |app: &mut EffectcraftApp, maximized: bool| {
-            let input = egui::RawInput {
-                viewports: std::iter::once((egui::ViewportId::ROOT, egui::ViewportInfo { maximized: Some(maximized), ..Default::default() })).collect(),
-                ..Default::default()
-            };
-            let mut r = Value::Null;
-            let mut out = ctx.run_ui(input, |ui| r = invoke(app, ui.ctx(), "window.maximizeApp", json!({})).unwrap());
-            out.textures_delta.clear();
-            let cmds = out.viewport_output.get(&egui::ViewportId::ROOT).map(|v| v.commands.clone()).unwrap_or_default();
-            (r, cmds)
-        };
-        let (r, cmds) = run(&mut app, false);
-        assert_eq!(r, json!({"maximized": true}));
-        assert!(cmds.contains(&egui::ViewportCommand::Maximized(true)), "{cmds:?}");
-        let (r, cmds) = run(&mut app, true);
-        assert_eq!(r, json!({"maximized": false}));
-        assert!(cmds.contains(&egui::ViewportCommand::Maximized(false)), "{cmds:?}");
-    }
-
-    /// The default keys of the keyboard-only commands parse and reach them.
-    #[test]
-    fn keyboard_only_commands_are_bound() {
-        let app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        for (id, keys) in [
-            ("time.workAreaStart", "Shift+Home"),
-            ("time.workAreaEnd", "Shift+End"),
-            ("time.previousInOut", "Cmd+Alt+Shift+ArrowLeft"),
-            ("time.nextInOut", "Cmd+Alt+Shift+ArrowRight"),
-            ("comp.workAreaToSelection", "Cmd+Alt+B"),
-            ("comp.activateRecent", "Shift+Escape"),
-            ("keys.deselectAll", "Shift+F2"),
-            ("keys.deselectAll", "Cmd+Alt+Shift+A"),
-            ("layer.extendSelectionNext", "Cmd+Shift+ArrowDown"),
-            ("layer.moveInToStart", "Alt+Home"),
-            ("layer.moveEarlier", "Alt+PageUp"),
-            ("layer.moveLater10", "Alt+Shift+PageDown"),
-            ("layer.stretchInToTime", "Cmd+Shift+,"),
-            ("layer.stretchOutToTime", "Cmd+Alt+,"),
-            ("layer.mask.selectNext", "Alt+`"),
-            ("layer.mask.selectPrevious", "Alt+Shift+`"),
-            ("layer.castsShadows", "Alt+Shift+C"),
-            ("timeline.scrollToTime", "D"),
-            ("timeline.scrollToLayer", "X"),
-            ("timeline.parentColumn", "Shift+F4"),
-            ("view.fitUpTo100", "Alt+/"),
-            ("view.nextItem", "Shift+."),
-            ("view.previousItem", "Shift+,"),
-            ("window.toggleCompTimeline", "\\"),
-            ("window.nextPanel", "Alt+Shift+."),
-            ("window.previousPanel", "Alt+Shift+,"),
-            ("window.closeAll", "Cmd+Shift+W"),
-            ("tool.camera", "C"),
-        ] {
-            assert!(bindings(&app.session).into_iter().any(|x| x.2 == id && Some((x.0, x.1)) == parse_shortcut(keys)), "{id} on {keys}");
-        }
-    }
-
-    #[test]
-    fn timeline_keys_scroll_and_toggle_the_parent_column() {
-        let ctx = egui::Context::default();
-        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        let run = |app: &mut EffectcraftApp, id: &str| invoke(app, &ctx, id, json!({})).unwrap();
-        // D and X leave a scroll for the Timeline to do when it is drawn.
-        run(&mut app, "timeline.scrollToTime");
-        assert_eq!(app.ui.timeline.scroll_to, Some(crate::state::ScrollTo::Time));
-        run(&mut app, "timeline.scrollToLayer");
-        assert_eq!(app.ui.timeline.scroll_to, Some(crate::state::ScrollTo::Layer));
-        // Shift+F4 shows and hides the Parent column.
-        let parent = crate::panels::timeline::column_visible(&app.ui.timeline, "parent");
-        run(&mut app, "timeline.parentColumn");
-        assert_eq!(crate::panels::timeline::column_visible(&app.ui.timeline, "parent"), !parent);
-        run(&mut app, "timeline.parentColumn");
-        assert_eq!(crate::panels::timeline::column_visible(&app.ui.timeline, "parent"), parent);
-    }
-
-    #[test]
-    fn viewer_keys_fit_and_step_through_open_comps() {
-        let ctx = egui::Context::default();
-        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        let run = |app: &mut EffectcraftApp, id: &str| invoke(app, &ctx, id, json!({})).unwrap();
-        let new = |app: &mut EffectcraftApp, name: &str| app.session.execute("comp.new", json!({"name": name, "duration": 4})).unwrap()["comp"].as_u64();
-        let active = |app: &EffectcraftApp| app.session.state.active_comp.map(|c| c.0);
-        // With one composition open there is nothing to step to.
-        let a = new(&mut app, "A");
-        run(&mut app, "view.nextItem");
-        assert_eq!(active(&app), a);
-        // Shift+, / Shift+.: through the open compositions, wrapping.
-        let b = new(&mut app, "B");
-        assert_eq!(active(&app), b);
-        run(&mut app, "view.nextItem");
-        assert_eq!(active(&app), a);
-        run(&mut app, "view.previousItem");
-        assert_eq!(active(&app), b);
-        // Alt+/ fits the viewer without magnifying past 100 %; Shift+/ fits fully again.
-        app.ui.viewer.zoom = Some(3.0);
-        run(&mut app, "view.fitUpTo100");
-        assert!(app.ui.viewer.zoom.is_none() && app.ui.viewer.fit_up_to_100);
-        run(&mut app, "view.fit");
-        assert!(!app.ui.viewer.fit_up_to_100);
-    }
-
-    #[test]
-    fn panel_keys_switch_cycle_and_close() {
-        let ctx = egui::Context::default();
-        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        let run = |app: &mut EffectcraftApp, id: &str| invoke(app, &ctx, id, json!({})).unwrap();
-        for name in ["A", "B"] {
-            app.session.execute("comp.new", json!({"name": name, "duration": 4})).unwrap();
-        }
-        // \\ switches between the Timeline and the Composition viewer.
-        app.ui.focused = PanelKind::Timeline;
-        run(&mut app, "window.toggleCompTimeline");
-        assert_eq!(app.ui.focused, PanelKind::Composition);
-        run(&mut app, "window.toggleCompTimeline");
-        assert_eq!(app.ui.focused, PanelKind::Timeline);
-        // Alt+Shift+. / Alt+Shift+,: the tabs of the focused panel's group, wrapping.
-        let group = app.ui.dock.group_of(PanelKind::Timeline).unwrap().to_vec();
-        assert!(group.len() > 1, "{group:?}");
-        run(&mut app, "window.nextPanel");
-        assert_eq!(app.ui.focused, group[(group.iter().position(|p| *p == PanelKind::Timeline).unwrap() + 1) % group.len()]);
-        run(&mut app, "window.previousPanel");
-        assert_eq!(app.ui.focused, PanelKind::Timeline);
-        // Ctrl+Shift+W with the Timeline active closes every composition.
-        run(&mut app, "window.closeAll");
-        assert!(app.session.state.open_comps.is_empty());
-        // With another panel active it closes that panel.
-        app.show_panel(PanelKind::Project);
-        run(&mut app, "window.closeAll");
-        assert!(!app.ui.dock.contains(PanelKind::Project));
-    }
-
-    #[test]
-    fn c_cycles_the_camera_tools() {
-        let ctx = egui::Context::default();
-        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        app.ui.tool = Tool::Selection;
-        let mut seen = vec![];
-        for _ in 0..4 {
-            invoke(&mut app, &ctx, "tool.camera", json!({})).unwrap();
-            seen.push(app.ui.tool);
-        }
-        assert_eq!(seen, [Tool::Orbit, Tool::PanCamera, Tool::Dolly, Tool::Orbit]);
-    }
-
-    #[test]
-    fn dispatch_uses_the_active_custom_preset() {
-        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        let find = |app: &EffectcraftApp, id: &str| bindings(&app.session).into_iter().filter(|b| b.2 == id).map(|b| (b.0, b.1)).collect::<Vec<_>>();
-        let (m, k) = parse_shortcut("Cmd+Alt+Shift+Y").unwrap();
-        assert!(find(&app, "layer.newNull").contains(&(m, k)));
-        // A UI command rebound in a custom preset.
-        app.session.execute("shortcuts.set", json!({"command": "tool.hand", "keys": "Ctrl+Alt+H"})).unwrap();
-        assert_eq!(app.session.keymaps.active, "Custom");
-        let (m2, k2) = parse_shortcut("Ctrl+Alt+H").unwrap();
-        assert_eq!(find(&app, "tool.hand"), vec![(m2, k2)]);
-        app.session.execute("shortcuts.set", json!({"command": "layer.newNull", "keys": "F6"})).unwrap();
-        assert_eq!(find(&app, "layer.newNull"), vec![(egui::Modifiers::NONE, egui::Key::F6)]);
-        // The menus show the preset's shortcut.
-        let item = menu_items(&app).into_iter().find(|i| i.id == "layer.newNull").unwrap();
-        assert_eq!(item.shortcut.as_deref(), Some("F6"));
-        // Back to the default preset.
-        app.session.execute("shortcuts.preset", json!({"op": "select", "name": effectcraft_engine::shortcuts::DEFAULT_PRESET})).unwrap();
-        assert!(find(&app, "layer.newNull").contains(&(m, k)));
-    }
-
-    #[test]
-    fn renamed_label_shows_in_the_label_menu() {
-        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        app.set_pref("labels.1.name", json!("Sunflower")).unwrap();
-        let labels: Vec<String> = menu_items(&app).into_iter().filter(|i| i.id == "edit.label").map(|i| i.label).collect();
-        assert!(labels.contains(&"Sunflower".to_string()), "{labels:?}");
-        assert!(!labels.contains(&"Yellow".to_string()));
-    }
-
-    /// Saving anything but a project asks the save dialog for that file's extension (#293): the
-    /// project dialog, filtered to `.ecproj`, made macOS append `.ecproj` (`Frame.png.ecproj`).
-    /// Hosts with only the project dialog (the web) still get it, given the file name.
-    #[test]
-    fn save_dialogs_offer_the_file_extension() {
-        use std::cell::RefCell;
-        use std::rc::Rc;
-        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        app.session.execute("comp.new", json!({"name": "A", "width": 64, "height": 36, "frameRate": 30, "duration": 1})).unwrap();
-        let ctx = egui::Context::default();
-        let asked: Rc<RefCell<Vec<String>>> = Rc::default();
-        let (a, b) = (asked.clone(), asked.clone());
-        app.hooks.pick_save = Some(Box::new(move |name: &str| {
-            a.borrow_mut().push(format!("project {name}"));
-            None
-        }));
-        app.hooks.pick_save_file = Some(Box::new(move |name: &str, ext: &str| {
-            b.borrow_mut().push(format!("file {name} [{ext}]"));
-            None
-        }));
-        for id in ["comp.saveFrameAs", "render.saveCurrentPreview", "file.exportLottie", "file.saveCopyAsXml", "file.collectFiles", "file.saveAs"] {
-            invoke(&mut app, &ctx, id, json!({})).unwrap();
-        }
-        assert_eq!(
-            *asked.borrow(),
-            [
-                "file Frame.png [png]",
-                "file Preview.mp4 [mp4]",
-                "file Animation.json [json]",
-                "file Untitled Project.ecprojx [ecprojx]",
-                "file Collected Files []",
-                "project Untitled Project.ecproj",
-            ]
-        );
-        // Without the other dialog, the project one names any file.
-        app.hooks.pick_save_file = None;
-        asked.borrow_mut().clear();
-        invoke(&mut app, &ctx, "comp.saveFrameAs", json!({})).unwrap();
-        assert_eq!(*asked.borrow(), ["project Frame.png"]);
-    }
-
-    /// #511: with a host's non-blocking dialogs, a command's file dialog opens without running
-    /// a nested event loop inside the frame (a drag over the window then aborted the app on
-    /// macOS); the command runs on a later frame with the answer, and a cancelled one not at all.
-    #[test]
-    fn file_dialogs_can_answer_on_a_later_frame() {
-        use std::sync::{Arc, Mutex};
-        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        app.session.execute("comp.new", json!({"name": "A", "width": 64, "height": 36, "frameRate": 30, "duration": 1})).unwrap();
-        let ctx = egui::Context::default();
-        app.hooks.pick_save = Some(Box::new(|_: &str| panic!("the blocking dialog is not used")));
-        let pending: Arc<Mutex<Vec<(crate::FileDialog, crate::DialogDone)>>> = Arc::default();
-        let queue = pending.clone();
-        app.hooks.file_dialog_async = Some(Box::new(move |dialog, done| queue.lock().unwrap().push((dialog, done))));
-        assert_eq!(invoke(&mut app, &ctx, "file.saveAs", json!({})).unwrap(), json!({"dialog": "file.saveAs"}));
-        let (dialog, done) = pending.lock().unwrap().pop().expect("a dialog was shown");
-        assert_eq!(dialog, crate::FileDialog::Save { default: "Untitled Project.ecproj".into(), ext: "ecproj".into(), project: true });
-        assert!(app.session.path.is_none(), "nothing saved until the dialog answers");
-        let dir = std::env::temp_dir().join(format!("ec-dialog-answer-{}", std::process::id()));
-        std::fs::create_dir_all(&dir).unwrap();
-        let path = dir.join("Answered.ecproj");
-        // Answered from another thread, as the host's dialog does.
-        std::thread::spawn(move || done(vec![path.to_string_lossy().to_string()])).join().unwrap();
-        app.run_dialog_answers();
-        assert_eq!(app.session.path.as_deref(), Some(dir.join("Answered.ecproj").to_string_lossy().as_ref()));
-        assert!(dir.join("Answered.ecproj").is_file());
-        // Cancelled: nothing runs.
-        invoke(&mut app, &ctx, "comp.saveFrameAs", json!({})).unwrap();
-        let (dialog, done) = pending.lock().unwrap().pop().expect("a dialog was shown");
-        assert_eq!(dialog, crate::FileDialog::Save { default: "Frame.png".into(), ext: "png".into(), project: false });
-        done(Vec::new());
-        app.run_dialog_answers();
-        assert!(!dir.join("Frame.png").exists());
-        let _ = std::fs::remove_dir_all(&dir);
-    }
-
-    #[test]
-    fn tga_is_available_in_import_replace_and_proxy_dialogs() {
-        use std::sync::{Arc, Mutex};
-        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
-        let ctx = egui::Context::default();
-        let pending = Arc::new(Mutex::new(Vec::new()));
-        let queue = pending.clone();
-        app.hooks.file_dialog_async = Some(Box::new(move |dialog, _done| queue.lock().unwrap().push(dialog)));
-        for command in ["file.import", "file.importMultiple", "file.replaceFootage", "file.setProxy"] {
-            assert_eq!(invoke(&mut app, &ctx, command, json!({})).unwrap(), json!({"dialog": command}));
-            let crate::FileDialog::Open { exts, .. } = pending.lock().unwrap().pop().unwrap() else { panic!("not an open dialog") };
-            assert!(exts.iter().any(|ext| ext == "tga"), "{command}: {exts:?}");
-        }
-    }
-
-    #[test]
-    fn menu_items_cover_the_tree() {
-        assert_eq!(menus().last(), Some(&"Help"));
-        assert!(effectcraft_engine::menus::entries().len() > 500);
-    }
-}
+mod tests;
diff --git a/crates/ui-egui/src/menus/bar.rs b/crates/ui-egui/src/menus/bar.rs
new file mode 100644
index 000000000..ec9ab9170
--- /dev/null
+++ b/crates/ui-egui/src/menus/bar.rs
@@ -0,0 +1,311 @@
+use super::entries::{entry_checked, entry_enabled, entry_label, entry_shortcut, menu_choice};
+use super::invoke::invoke;
+use super::shortcuts::shortcut_text;
+use super::{EffectcraftApp, MenuEntry, MenuNode, Value, json};
+
+/// The id under which [`menu_bar`] remembers which of its menus was open at the end of the last
+/// frame (its title's open look, and the hover that switches between the titles).
+fn open_menu_id() -> egui::Id {
+    egui::Id::unique("menu-bar-open")
+}
+
+/// The id under which [`menu_bar`] remembers a title press still in progress (press-and-browse).
+fn browse_menu_id() -> egui::Id {
+    egui::Id::unique("menu-bar-browse")
+}
+
+/// The id under which [`menu_bar`] remembers where it last saw the pointer (`None`: outside the
+/// window).
+fn last_pointer_id() -> egui::Id {
+    egui::Id::unique("menu-bar-last-pointer")
+}
+
+/// Draw the in-window menu bar (the engine's AE menu tree).
+///
+/// The titles open on the press, not the release (native menu bars): while one is held the menus
+/// can be browsed by moving onto them, and releasing over an entry chooses it. Hovering another
+/// title switches the open menu to it, and the open one closes on a press outside it or when the
+/// window loses focus. The pointer leaving the window — onto the OS title bar, directly above the
+/// bar — closes nothing, however long: the platform forwards none of the title bar's clicks to
+/// egui (only the cursor leaving), so there is no click to close on and a graze must not drop the
+/// menu. The closing press itself still reaches the widget under it, as a click does in After
+/// Effects.
+pub fn menu_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui) {
+    let ctx = ui.ctx().clone();
+    let mut clicked: Option<(String, Value)> = None;
+    let mut nav = crate::menu_keys::Nav::default();
+    // The open menu as of the last frame: the titles are drawn before this frame can open or
+    // close anything, and what happened last frame is what they must react to.
+    let open_prev: Option<usize> = ctx.data(|d| d.get_temp(open_menu_id())).flatten();
+    if ctx.data(|d| d.get_temp(browse_menu_id())).unwrap_or(false) {
+        nav.set_browsing();
+    }
+    // Whether the pointer has moved since the last frame. Kept by position rather than egui's
+    // `delta`, which is zero for the first position after the pointer comes back into the window:
+    // coming back in over another title must switch to it too (#1290).
+    let pointer = ctx.pointer_hover_pos();
+    let last = ctx.data_mut(|d| std::mem::replace(d.get_temp_mut_or(last_pointer_id(), None), pointer));
+    let moved = pointer.is_some() && pointer != last;
+    let mut drawn = 0;
+    ui.horizontal_centered(|ui| {
+        ui.add_space(6.0);
+        egui::MenuBar::new().config(egui::containers::menu::MenuConfig::new().style(crate::widgets::menu_style)).ui(ui, |ui| {
+            for node in effectcraft_engine::menus::menu_bar() {
+                let MenuNode::Submenu { label, children } = node else { continue };
+                // The open title takes the open button's look while its menu is up (as in AE).
+                let inactive = ui.style().visuals.widgets.inactive;
+                if open_prev == Some(drawn) {
+                    ui.style_mut().visuals.widgets.inactive = ui.style().visuals.widgets.open;
+                }
+                let mut response = ui.add(egui::Button::new(crate::i18n::label(app, "", label)));
+                ui.style_mut().visuals.widgets.inactive = inactive;
+                // A press on a title opens its menu at once (a second press on the open one closes
+                // it), and while it is held the menus below are browsable. The keyboard and the
+                // accessibility activation report `clicked` without the primary button (the press
+                // then happened somewhere else), and toggle the menu. Hovering another title
+                // switches to it once the pointer has moved: merely resting there must not take a
+                // keyboard-driven menu over.
+                // With the button down elsewhere nothing is hovered, so the title under the
+                // pointer takes the highlight by hand: the hover-switch to it shows, one frame
+                // later like egui's own hover (the open title keeps its open look).
+                if moved && response.contains_pointer() && open_prev.is_some_and(|p| p != drawn) {
+                    response = response.highlight();
+                }
+                let pressed = ctx.input(|i| i.pointer.button_pressed(egui::PointerButton::Primary)) && response.hovered();
+                let cmd = if pressed {
+                    nav.set_browsing();
+                    Some(egui::SetOpenCommand::Bool(open_prev != Some(drawn)))
+                } else if response.clicked() && !response.clicked_by(egui::PointerButton::Primary) {
+                    Some(egui::SetOpenCommand::Toggle)
+                } else if moved && response.enabled() && response.contains_pointer() && open_prev.is_some_and(|p| p != drawn) {
+                    Some(egui::SetOpenCommand::Bool(true))
+                } else {
+                    None
+                };
+                let inner = egui::Popup::menu(&response)
+                    .close_behavior(egui::PopupCloseBehavior::IgnoreClicks)
+                    .style(crate::widgets::menu_style)
+                    .open_memory(cmd)
+                    .show(|ui| {
+                        ui.set_min_width(if label == "Effect" { 200.0 } else { 280.0 });
+                        let browsing = nav.browsing();
+                        crate::widgets::menu_scroll(ui, browsing, |ui| menu_nodes(app, ui, children, &mut clicked, &mut nav, 0));
+                    });
+                nav.top(&response);
+                // The titles and the open menus: a press inside them is not an outside press.
+                nav.cover(response.rect);
+                if let Some(inner) = &inner {
+                    nav.cover(inner.response.rect);
+                }
+                app.auto.add(&format!("menu.{label}"), response.rect, label);
+                drawn += 1;
+            }
+        });
+    });
+    crate::menu_keys::handle(&ctx, &nav);
+    // egui leaves the closing to us (`IgnoreClicks`), so the menus close here: at once on a press
+    // outside them (the press itself still reaches the widget below) and when the window loses
+    // focus. The pointer leaving the window closes nothing: moving onto the OS title bar fires
+    // the cursor-left event and the platform forwards none of its clicks to egui, so there is no
+    // click to close on — and a graze or a stay must not drop the menu, as in native apps.
+    if let Some(top) = nav.open_popup(&ctx) {
+        let focus_lost = ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::WindowFocused(false))));
+        let outside_press = ctx.input(|i| i.pointer.any_pressed() && i.pointer.interact_pos().is_some_and(|p| !nav.covers(p)));
+        if focus_lost || outside_press {
+            egui::Popup::close_id(&ctx, top);
+        }
+    }
+    if let Some((id, params)) = clicked.map(|(id, params)| menu_choice(app, id, params))
+        && let Err(e) = invoke(app, &ctx, &id, if params.is_null() { json!({}) } else { params })
+    {
+        app.ui.status = e;
+    }
+    // What the next frame starts from: the open title, and a title press still in progress.
+    let open = nav.open_index(&ctx);
+    let browsing = open.is_some() && nav.browsing() && ctx.input(|i| i.pointer.primary_down());
+    ctx.data_mut(|d| {
+        d.insert_temp(open_menu_id(), open);
+        d.insert_temp(browse_menu_id(), browsing);
+    });
+}
+
+/// The entries of top-level menu `name` (the Effect menu is the Effect Controls panel's context
+/// menu); returns the chosen command and its params.
+pub(crate) fn menu_contents(app: &mut EffectcraftApp, ui: &mut egui::Ui, name: &str) -> Option<(String, Value)> {
+    let mut clicked = None;
+    if let Some(MenuNode::Submenu { children, .. }) =
+        effectcraft_engine::menus::menu_bar().iter().find(|n| matches!(n, MenuNode::Submenu { label, .. } if label == name))
+    {
+        menu_nodes(app, ui, children, &mut clicked, &mut crate::menu_keys::Nav::default(), 0);
+    }
+    clicked.map(|(id, params)| (id, if params.is_null() { json!({}) } else { params }))
+}
+
+/// The entries `nodes` of a menu `depth` submenus deep, registered with `nav` for the keyboard.
+fn menu_nodes(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    nodes: &[MenuNode],
+    clicked: &mut Option<(String, Value)>,
+    nav: &mut crate::menu_keys::Nav,
+    depth: usize,
+) {
+    for n in nodes {
+        match n {
+            MenuNode::Separator => {
+                ui.separator();
+            }
+            MenuNode::Dynamic { name } => {
+                // Recent projects / footage / presets, undo history, shortcut slots, viewers,
+                // saved workspaces.
+                let ws = app.ui.workspace.clone();
+                let saved = app.saved_workspace_names();
+                let (nodes, empty) = effectcraft_engine::menus::dynamic_nodes(&app.session, name, &dyn_ctx(&ws, &saved));
+                if nodes.is_empty()
+                    && let Some(e) = empty
+                {
+                    ui.add_enabled(false, egui::Button::new((gutter(false), e)));
+                }
+                for (i, n) in nodes.iter().enumerate() {
+                    // A folder of scripts or panels: a submenu.
+                    let MenuNode::Item(e) = n else {
+                        menu_nodes(app, ui, std::slice::from_ref(n), clicked, nav, depth);
+                        continue;
+                    };
+                    let tip = match name.as_str() {
+                        "recentProjects" => app.session.prefs.recent_projects.get(i).cloned(),
+                        "recentFootage" => app.session.prefs.recent_footage.get(i).cloned(),
+                        "recentPresets" => app.session.prefs.recent_presets.get(i).cloned(),
+                        "recentScripts" => app.session.prefs.recent_scripts.get(i).map(|r| r.text().to_string()),
+                        _ => None,
+                    };
+                    let mut b = egui::Button::new((gutter(entry_checked(app, e) == Some(true)), e.label.as_str()));
+                    // File ▸ Scripts entries show the key a script was given.
+                    if let Some(s) = entry_shortcut(app, e) {
+                        b = b.shortcut_text(shortcut_text(&s));
+                    }
+                    let r = ui.add_enabled(entry_enabled(app, e), b);
+                    let r = match &tip {
+                        Some(t) => r.on_hover_text(t),
+                        None => r,
+                    };
+                    let r = browse_hover(nav, r);
+                    app.auto.add(&format!("menu.{name}.{i}"), r.rect, &e.label);
+                    nav.entry(ui, depth, &r, false);
+                    if r.clicked() || browse_pick(nav, ui, &r) {
+                        *clicked = Some((e.command.clone(), e.params.clone()));
+                        ui.close();
+                    }
+                }
+            }
+            MenuNode::Submenu { label, children } => {
+                let ws = app.ui.workspace.clone();
+                // The generated Effect menu's category submenus draw the catalog's name (#821);
+                // every other submenu goes through the menu catalog.
+                let shown = crate::i18n::effect_category(children, label)
+                    .unwrap_or_else(|| crate::i18n::submenu(app, label, effectcraft_engine::menus::submenu_label(&app.session, label, &dyn_ctx(&ws, &[]))));
+                let browsing = nav.browsing();
+                let egui::InnerResponse { inner, response } = ui.menu_button((gutter(false), shown.as_str()), |ui| {
+                    ui.set_min_width(if children.len() > 30 { 200.0 } else { 240.0 });
+                    crate::widgets::menu_scroll(ui, browsing, |ui| menu_nodes(app, ui, children, clicked, nav, depth + 1));
+                });
+                let response = browse_hover(nav, response);
+                nav.entry(ui, depth, &response, true);
+                if inner.is_some() {
+                    // `ui.menu_button` drops the popup's own response on the floor: read it back,
+                    // so that a press inside this submenu doesn't count as an outside press.
+                    let sub = egui::containers::menu::SubMenu::id_from_widget_id(response.id);
+                    if let Some(resp) = ui.ctx().read_response(sub) {
+                        nav.cover(resp.rect);
+                    }
+                    nav.opened(depth, &response);
+                }
+            }
+            MenuNode::Item(e) => {
+                let r = browse_hover(nav, menu_entry(app, ui, e));
+                nav.entry(ui, depth, &r, false);
+                if r.clicked() || browse_pick(nav, ui, &r) {
+                    *clicked = Some((e.command.clone(), e.params.clone()));
+                    ui.close();
+                }
+            }
+        }
+    }
+}
+
+/// The row `r` highlighted while the bar is mid press-and-browse: with a button down egui reports
+/// nothing as hovered — which would leave browsing with no hover feedback at all — so the row
+/// under the pointer takes the highlight by hand. It reads as the hover look one frame later,
+/// exactly egui's own hover latency; disabled rows ignore it (`Noninteractive`), as in native
+/// menus. Context menus use their own [`crate::menu_keys::Nav`], where the bar never browses.
+fn browse_hover(nav: &crate::menu_keys::Nav, r: egui::Response) -> egui::Response {
+    if nav.browsing() && r.contains_pointer() { r.highlight() } else { r }
+}
+
+/// Whether a press-and-browse (a menu-bar title still held down) releases over entry `r`, which
+/// then chooses it like a click does. egui reports neither for it: the release is far from the
+/// press, so there is no click, and nothing but the pressed widget is hovered while a button is
+/// down, so the row has to be tested by the pointer being over it.
+fn browse_pick(nav: &crate::menu_keys::Nav, ui: &egui::Ui, r: &egui::Response) -> bool {
+    nav.browsing() && r.enabled() && r.contains_pointer() && ui.input(|i| i.pointer.button_released(egui::PointerButton::Primary))
+}
+
+/// The menu bar's submenu at `path` (`["File", "Interpret Footage"]`) in a panel's context menu,
+/// with the menu bar's labels, shortcuts and enabled state; a chosen entry goes to `clicked`.
+pub(crate) fn submenu_at(app: &mut EffectcraftApp, ui: &mut egui::Ui, path: &[&str], clicked: &mut Option<(String, Value)>) {
+    let mut nodes = effectcraft_engine::menus::menu_bar();
+    let mut found = None;
+    for label in path {
+        let Some(n) = nodes.iter().find(|n| matches!(n, MenuNode::Submenu { label: l, .. } if l == label)) else { return };
+        if let MenuNode::Submenu { children, .. } = n {
+            nodes = children;
+        }
+        found = Some(n);
+    }
+    if let Some(n) = found {
+        menu_nodes(app, ui, std::slice::from_ref(n), clicked, &mut crate::menu_keys::Nav::default(), 0);
+    }
+    if let Some((_, p)) = clicked.as_mut()
+        && p.is_null()
+    {
+        *p = json!({});
+    }
+}
+
+/// The menu bar's entry for `command` in a panel's context menu (see [`submenu_at`]).
+pub(crate) fn entry_for(app: &EffectcraftApp, ui: &mut egui::Ui, command: &str, clicked: &mut Option<(String, Value)>) {
+    if let Some((_, e)) = effectcraft_engine::menus::entries().into_iter().find(|(_, e)| e.command == command)
+        && menu_entry(app, ui, e).clicked()
+    {
+        *clicked = Some((e.command.clone(), e.params_or_empty()));
+        ui.close();
+    }
+}
+
+/// Frontend state for dynamic menus (the current workspace and the saved ones).
+pub(crate) fn dyn_ctx<'a>(workspace: &'a str, saved_workspaces: &'a [String]) -> effectcraft_engine::menus::DynCtx<'a> {
+    effectcraft_engine::menus::DynCtx { workspace: Some(workspace), saved_workspaces }
+}
+
+/// The check-mark column every menu row reserves (like macOS / After Effects menus).
+fn gutter(checked: bool) -> egui::Atom<'static> {
+    use egui::AtomExt;
+    (if checked { "✔" } else { "" }).atom_size(egui::vec2(14.0, 14.0))
+}
+
+fn menu_entry(app: &EffectcraftApp, ui: &mut egui::Ui, e: &MenuEntry) -> egui::Response {
+    let (label, check, enabled) = (entry_label(app, e), gutter(entry_checked(app, e) == Some(true)), entry_enabled(app, e));
+    // Edit ▸ Label's entries show the label's colour before its name.
+    if e.command == "edit.label"
+        && let Some(l) = e.params.get("label").and_then(Value::as_str).and_then(effectcraft_engine::color::Label::from_name)
+    {
+        let out = ui.add_enabled_ui(enabled, |ui| egui::Button::new((check, crate::widgets::label_swatch(), label)).atom_ui(ui)).inner;
+        crate::widgets::paint_label_swatch(ui, &out, l, &app.tokens);
+        return out.response;
+    }
+    let mut b = egui::Button::new((check, label));
+    if let Some(s) = entry_shortcut(app, e) {
+        b = b.shortcut_text(shortcut_text(&s));
+    }
+    ui.add_enabled(enabled, b)
+}
diff --git a/crates/ui-egui/src/menus/commands.rs b/crates/ui-egui/src/menus/commands.rs
new file mode 100644
index 000000000..c162bbd3a
--- /dev/null
+++ b/crates/ui-egui/src/menus/commands.rs
@@ -0,0 +1,122 @@
+use super::UiCommand;
+
+macro_rules! uic {
+    ($id:literal, $label:literal, [$($m:literal),*], $sc:expr) => {
+        UiCommand { id: $id, label: $label, menu: &[$($m),*], shortcut: $sc }
+    };
+}
+
+/// UI-only commands (not in the AE menus; shortcuts and the command palette).
+pub const UI_COMMANDS: &[UiCommand] = &[
+    uic!("window.dockAction", "Docking Action", [], None),
+    uic!("playback.ramPreview", "Preview (Numpad 0)", [], Some("Num0")),
+    uic!("playback.preview.shiftSpacebar", "Preview (Shift+Spacebar)", [], Some("Shift+Space")),
+    uic!("playback.preview.shiftNumpad0", "Preview (Shift+Numpad 0)", [], Some("Shift+Num0")),
+    uic!("playback.preview.altNumpad0", "Preview (Alt+Numpad 0)", [], Some("Alt+Num0")),
+    uic!("playback.stop", "Stop", [], None),
+    uic!("view.fit", "Fit", [], Some("Shift+/")),
+    uic!("view.actualSize", "100%", [], Some("/")),
+    uic!("view.fitUpTo100", "Fit up to 100%", [], Some("Alt+/")),
+    uic!("view.nextItem", "Next Composition in Viewer", [], Some("Shift+.")),
+    uic!("view.previousItem", "Previous Composition in Viewer", [], Some("Shift+,")),
+    uic!("viewer.nudge.up", "Move Selected Layers Up 1 Pixel at Current Magnification", [], Some("ArrowUp")),
+    uic!("viewer.nudge.down", "Move Selected Layers Down 1 Pixel at Current Magnification", [], Some("ArrowDown")),
+    uic!("viewer.nudge.left", "Move Selected Layers Left 1 Pixel at Current Magnification", [], Some("ArrowLeft")),
+    uic!("viewer.nudge.right", "Move Selected Layers Right 1 Pixel at Current Magnification", [], Some("ArrowRight")),
+    uic!("viewer.nudge.up10", "Move Selected Layers Up 10 Pixels at Current Magnification", [], Some("Shift+ArrowUp")),
+    uic!("viewer.nudge.down10", "Move Selected Layers Down 10 Pixels at Current Magnification", [], Some("Shift+ArrowDown")),
+    uic!("viewer.nudge.left10", "Move Selected Layers Left 10 Pixels at Current Magnification", [], Some("Shift+ArrowLeft")),
+    uic!("viewer.nudge.right10", "Move Selected Layers Right 10 Pixels at Current Magnification", [], Some("Shift+ArrowRight")),
+    uic!("view.safeMargins", "Title/Action Safe", [], Some("'")),
+    uic!("view.transparencyGrid", "Transparency Grid", [], None),
+    uic!("view.fastPreviews", "Fast Previews", [], None),
+    uic!("view.theme.toggle", "Next Appearance Mode", [], None),
+    uic!("view.theme.dark", "Theme: Dark", [], None),
+    uic!("view.theme.darker", "Theme: Darker", [], None),
+    uic!("view.theme.light", "Theme: Light", [], None),
+    uic!("timeline.zoomIn", "Zoom In Time", [], Some("=")),
+    uic!("timeline.zoomOut", "Zoom Out Time", [], Some("-")),
+    uic!("timeline.zoomFit", "Zoom to Fit Comp", [], Some("Shift+;")),
+    uic!("timeline.scrollToTime", "Scroll to Current Time", [], Some("D")),
+    uic!("timeline.scrollToLayer", "Scroll Topmost Selected Layer to Top", [], Some("X")),
+    uic!("timeline.parentColumn", "Show/Hide Parent Column", [], Some("Shift+F4")),
+    uic!("timeline.zoomFrameToggle", "Zoom In to Frame Level / Out to the Whole Comp", [], Some(";")),
+    uic!("timeline.graphEditor", "Graph Editor", [], Some("Shift+F3")),
+    uic!("timeline.switchesModes", "Toggle Switches / Modes", [], Some("F4")),
+    uic!("timeline.workAreaBegin", "Set Work Area Begin", [], Some("B")),
+    uic!("timeline.workAreaEnd", "Set Work Area End", [], Some("N")),
+    uic!("timeline.moveInToTime", "Move Layer In Point to Current Time", [], Some("[")),
+    uic!("timeline.moveOutToTime", "Move Layer Out Point to Current Time", [], Some("]")),
+    uic!("timeline.trimInToTime", "Trim Layer In Point to Current Time", [], Some("Alt+[")),
+    uic!("timeline.trimOutToTime", "Trim Layer Out Point to Current Time", [], Some("Alt+]")),
+    uic!("timeline.reveal.position", "Reveal Position", [], Some("P")),
+    uic!("timeline.reveal.scale", "Reveal Scale", [], Some("S")),
+    uic!("timeline.reveal.rotation", "Reveal Rotation", [], Some("R")),
+    uic!("timeline.reveal.opacity", "Reveal Opacity", [], Some("T")),
+    uic!("timeline.reveal.anchor", "Reveal Anchor Point", [], Some("A")),
+    uic!("timeline.reveal.effects", "Reveal Effects", [], Some("E")),
+    uic!("timeline.reveal.masks", "Reveal Masks", [], Some("M")),
+    uic!("timeline.reveal.feather", "Reveal Mask Feather", [], Some("F")),
+    uic!("timeline.reveal.levels", "Reveal Audio Levels (press twice: Waveform)", [], Some("L")),
+    uic!("timeline.reveal.timeRemap", "Reveal Time Remap", [], None),
+    uic!("timeline.reveal.expressions", "Reveal Expressions", [], None),
+    uic!("timeline.reveal.maskOpacity", "Reveal Mask Opacity", [], None),
+    uic!("timeline.reveal.maskPath", "Reveal Mask Path", [], None),
+    uic!("timeline.reveal.material", "Reveal Material Options", [], None),
+    uic!("timeline.reveal.paint", "Reveal Paint, Roto Brush and Puppet", [], None),
+    uic!("timeline.reveal.selected", "Reveal Selected Properties", [], None),
+    uic!("timeline.reveal.missingEffects", "Reveal Missing Effects", [], None),
+    uic!("timeline.reveal.waveform", "Reveal Audio Waveform", [], None),
+    uic!("timeline.revealAdd.position", "Add Position to Revealed Properties", [], Some("Shift+P")),
+    uic!("timeline.revealAdd.scale", "Add Scale to Revealed Properties", [], Some("Shift+S")),
+    uic!("timeline.revealAdd.rotation", "Add Rotation to Revealed Properties", [], Some("Shift+R")),
+    uic!("timeline.revealAdd.opacity", "Add Opacity to Revealed Properties", [], Some("Shift+T")),
+    uic!("timeline.revealAdd.anchor", "Add Anchor Point to Revealed Properties", [], Some("Shift+A")),
+    uic!("timeline.revealAdd.effects", "Add Effects to Revealed Properties", [], Some("Shift+E")),
+    uic!("timeline.revealAdd.masks", "Add Masks to Revealed Properties", [], Some("Shift+M")),
+    uic!("timeline.revealAdd.feather", "Add Mask Feather to Revealed Properties", [], Some("Shift+F")),
+    uic!("timeline.revealAdd.levels", "Add Audio Levels to Revealed Properties", [], Some("Shift+L")),
+    uic!("timeline.revealAdd.animated", "Add Animated Properties to Revealed Properties", [], Some("Shift+U")),
+    uic!("timeline.column", "Show/Hide Timeline Column", [], None),
+    uic!("timeline.sourceName", "Source Name / Layer Name", [], None),
+    uic!("timeline.search", "Search Timeline", [], None),
+    uic!("flowchart.options", "Flowchart Options", [], None),
+    uic!("flowchart.graph", "Flowchart Graph", [], None),
+    uic!("timeline.collapseAll", "Collapse All", [], None),
+    uic!("timeline.twirlSelected", "Twirl Selected Layers Open / Closed", [], Some("Cmd+`")),
+    uic!("timeline.keyAt.anchor", "Add or Remove Anchor Point Keyframe", [], Some("Alt+Shift+A")),
+    uic!("timeline.keyAt.position", "Add or Remove Position Keyframe", [], Some("Alt+Shift+P")),
+    uic!("timeline.keyAt.scale", "Add or Remove Scale Keyframe", [], Some("Alt+Shift+S")),
+    uic!("timeline.keyAt.rotation", "Add or Remove Rotation Keyframe", [], Some("Alt+Shift+R")),
+    uic!("timeline.keyAt.opacity", "Add or Remove Opacity Keyframe", [], Some("Alt+Shift+T")),
+    uic!("tool.selection", "Selection Tool", [], Some("V")),
+    uic!("tool.hand", "Hand Tool", [], Some("H")),
+    uic!("tool.zoom", "Zoom Tool", [], Some("Z")),
+    uic!("tool.orbit", "Orbit Tool", [], Some("1")),
+    uic!("tool.panCamera", "Pan Camera Tool", [], Some("2")),
+    uic!("tool.dolly", "Dolly Tool", [], Some("3")),
+    uic!("tool.camera", "Camera Tools", [], Some("C")),
+    uic!("tool.rotate", "Rotation Tool", [], Some("W")),
+    uic!("tool.panBehind", "Pan Behind Tool", [], Some("Y")),
+    uic!("tool.shape", "Shape Tools", [], Some("Q")),
+    uic!("tool.pen", "Pen Tool", [], Some("G")),
+    uic!("tool.type", "Type Tools", [], Some("Cmd+T")),
+    uic!("tool.brush", "Brush Tools", [], Some("Cmd+B")),
+    uic!("tool.rotoBrush", "Roto Brush & Refine Edge Tools", [], Some("Alt+W")),
+    uic!("tool.puppet", "Puppet Tools", [], Some("Cmd+P")),
+    uic!("app.newComp", "New Composition...", [], None),
+    uic!("app.compSettings", "Composition Settings...", [], None),
+    uic!("app.solidSettings", "New Solid...", [], None),
+    uic!("app.home", "Home", [], None),
+    uic!("markers.dialog", "Marker Settings...", [], None),
+    uic!("window.maximizePanel", "Maximize Panel Under Pointer", [], Some("`")),
+    uic!("window.maximizeApp", "Maximize or Restore Application Window", [], Some("Cmd+\\")),
+    uic!("window.toggleCompTimeline", "Switch Between Composition and Timeline Panel", [], Some("\\")),
+    uic!("window.nextPanel", "Next Panel in Frame", [], Some("Alt+Shift+.")),
+    uic!("window.previousPanel", "Previous Panel in Frame", [], Some("Alt+Shift+,")),
+    uic!("window.closeAll", "Close Panel or All Viewers", [], Some("Cmd+Shift+W")),
+    uic!("window.dockPanel", "Dock Panel", [], None),
+    uic!("window.floatPanel", "Undock Panel", [], None),
+    uic!("window.closePanel", "Close Panel", [], None),
+    uic!("window.panelWindow", "Move Panel to New Window", [], None),
+];
diff --git a/crates/ui-egui/src/menus/entries.rs b/crates/ui-egui/src/menus/entries.rs
new file mode 100644
index 000000000..3391e47bd
--- /dev/null
+++ b/crates/ui-egui/src/menus/entries.rs
@@ -0,0 +1,151 @@
+use super::*;
+
+/// A menu entry for display / `ui.menu.list`.
+#[derive(Clone, Debug, serde::Serialize)]
+pub struct MenuItem {
+    pub id: String,
+    pub label: String,
+    pub path: Vec<String>,
+    pub shortcut: Option<String>,
+    pub enabled: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub checked: Option<bool>,
+    /// Parameters bound to the entry (e.g. the effect for Effect menu items).
+    #[serde(skip_serializing_if = "Value::is_null")]
+    pub params: Value,
+}
+
+/// Top-level menus in order.
+pub fn menus() -> Vec<&'static str> {
+    effectcraft_engine::menus::top_level()
+}
+
+pub(crate) fn entry_label(app: &EffectcraftApp, e: &MenuEntry) -> String {
+    let shown = match e.command.as_str() {
+        "edit.undo" => app.session.history.undo.last().map(|u| format!("Undo {}", u.0)).unwrap_or_else(|| "Can't Undo".into()),
+        "edit.redo" => app.session.history.redo.last().map(|u| format!("Redo {}", u.0)).unwrap_or_else(|| "Can't Redo".into()),
+        // Window ▸ Layer: the layer open in the Layer panel.
+        "window.panel" if e.params.get("panel").and_then(Value::as_str) == Some("layer") => {
+            let name = app
+                .ui
+                .layer_panel
+                .and_then(|id| app.session.active_comp().and_then(|c| c.layer(effectcraft_engine::project::LayerId(id))))
+                .map(|l| l.name.clone());
+            format!("Layer: {}", name.unwrap_or_else(|| "(none)".into()))
+        }
+        _ => effectcraft_engine::menus::entry_label(&app.session, e),
+    };
+    crate::i18n::entry(app, e, shown)
+}
+
+/// The entry's shortcut in the active keyboard shortcut preset.
+pub(crate) fn entry_shortcut(app: &EffectcraftApp, e: &MenuEntry) -> Option<String> {
+    app.session.shortcuts().shortcut_of(&e.command, &e.params).map(str::to_string)
+}
+
+/// Whether panel `p` is on screen: the front tab of a floating window, or of a docked group
+/// (an open frame in a stack) that a maximized panel does not cover.
+pub(crate) fn panel_shown(app: &EffectcraftApp, p: PanelKind) -> bool {
+    if app.ui.dock.is_floating(p) {
+        return app.ui.dock.is_visible(p);
+    }
+    match app.ui.maximized.filter(|m| app.ui.dock.is_docked(*m)) {
+        Some(m) => m == p,
+        None => app.ui.dock.is_visible(p),
+    }
+}
+
+/// The command a menu entry runs when chosen from a menu: Window ▸ `<panel>` closes a panel whose
+/// entry is checked, as in After Effects (#1630). Shortcuts and agents calling `window.panel`
+/// still only show the panel.
+pub(crate) fn menu_choice(app: &EffectcraftApp, id: String, params: Value) -> (String, Value) {
+    if id == "window.panel"
+        && let Some(p) = params.get("panel").and_then(Value::as_str).and_then(PanelKind::from_name)
+        && panel_shown(app, p)
+    {
+        return ("window.closePanel".into(), params);
+    }
+    (id, params)
+}
+
+/// Check-mark state of frontend toggles (engine state is answered by the engine).
+pub(crate) fn entry_checked(app: &EffectcraftApp, e: &MenuEntry) -> Option<bool> {
+    let v = &app.ui.viewer;
+    let pstr = |k: &str| e.params.get(k).and_then(Value::as_str);
+    match e.command.as_str() {
+        "view.rulers" => Some(v.rulers),
+        "view.guides" => Some(v.guides),
+        "view.snapToGuides" => Some(v.snap_guides),
+        "view.lockGuides" => Some(v.lock_guides),
+        "view.grid" => Some(v.grid),
+        "view.snapToGrid" => Some(v.snap_grid),
+        "view.layerControls" => Some(v.show_layer_controls),
+        "playback.cacheWhenIdle" => Some(app.ui.cache_when_idle),
+        "playback.audio" => Some(app.session.prefs.preview.active().include_audio),
+        "window.workspace" => Some(pstr("name").is_some_and(|n| n == app.ui.workspace)),
+        // The Tools panel is the header toolbar: always on screen.
+        "window.panel" => Some(pstr("panel").is_some_and(|n| n.eq_ignore_ascii_case("tools") || PanelKind::from_name(n).is_some_and(|p| panel_shown(app, p)))),
+        "view.panelBackground" if e.params.get("pick").is_none() => {
+            let cur = match v.pasteboard {
+                None => "mediumGray",
+                Some([0, 0, 0]) => "black",
+                Some([0x2a, 0x2a, 0x2a]) => "darkGray",
+                Some([0xb4, 0xb4, 0xb4]) => "lightGray",
+                Some([0xff, 0xff, 0xff]) => "white",
+                Some(_) => "custom",
+            };
+            Some(pstr("color") == Some(cur))
+        }
+        _ => effectcraft_engine::menus::checked(&app.session, &e.command, &e.params),
+    }
+}
+
+pub(crate) fn entry_enabled(app: &EffectcraftApp, e: &MenuEntry) -> bool {
+    // The Project-panel enabled rules mirror the invoke redirects, so they stand down for the
+    // same reason (see the redirect block): while a text edit is open the menu items must be
+    // enabled by what their routed command can do, or the menu grays out commands that work.
+    if app.ui.focused == PanelKind::Project && app.session.state.text_edit.is_none() {
+        match e.command.as_str() {
+            "edit.duplicate" => {
+                return !app.session.state.project_selection.is_empty()
+                    && app.session.state.project_selection.iter().all(|id| app.session.project.item(*id).is_some_and(|i| !i.is_folder()));
+            }
+            "edit.selectAll" => return !app.session.project.items.is_empty(),
+            "edit.deselectAll" => return !app.session.state.project_selection.is_empty(),
+            "edit.cut" | "edit.copy" | "edit.paste" | "edit.copyWithPropertyLinks" | "edit.copyWithRelativePropertyLinks" | "edit.copyExpressionOnly" => {
+                return false;
+            }
+            _ => {}
+        }
+    }
+    if e.command == "edit.clear" && app.ui.focused == PanelKind::Project {
+        // An open text edit stands down: Clear must not delete the comp being typed into (#2227).
+        return app.session.state.text_edit.is_none() && app.session.is_enabled("project.delete");
+    }
+    if e.command == "edit.clear" && app.ui.focused == PanelKind::RenderQueue {
+        return !app.session.is_rendering() && !app.session.project.render_queue.is_empty();
+    }
+    if e.command == "file.close" && super::invoke::no_params(&e.params) && app.ui.focused == PanelKind::RenderQueue {
+        return !app.ui.dock.locked;
+    }
+    if e.command == "window.panel" {
+        return true;
+    }
+    app.session.is_enabled(&e.command)
+}
+
+/// Every menu entry, flattened with its submenu path.
+pub fn menu_items(app: &EffectcraftApp) -> Vec<MenuItem> {
+    effectcraft_engine::menus::entries()
+        .into_iter()
+        .map(|(path, e)| MenuItem {
+            id: e.command.clone(),
+            label: entry_label(app, e),
+            path,
+            shortcut: entry_shortcut(app, e),
+            enabled: entry_enabled(app, e),
+            checked: entry_checked(app, e),
+            params: e.params.clone(),
+        })
+        .collect()
+}
diff --git a/crates/ui-egui/src/menus/frontend.rs b/crates/ui-egui/src/menus/frontend.rs
new file mode 100644
index 000000000..71bf8214b
--- /dev/null
+++ b/crates/ui-egui/src/menus/frontend.rs
@@ -0,0 +1,724 @@
+use super::{EffectcraftApp, PanelKind, Resolution, Value, json};
+
+/// Run an engine command and perform the frontend events it emitted right away.
+/// Commands that fill the internal clipboard.
+const COPY_COMMANDS: &[&str] =
+    &["edit.copy", "edit.cut", "edit.copyWithPropertyLinks", "edit.copyWithRelativePropertyLinks", "edit.copyExpressionOnly", "keys.copy", "effect.copy"];
+
+/// Text for the system clipboard: copied keyframes and values as After Effects keyframe text,
+/// for other applications (#1908), else a line naming what EffectCraft copied. The system
+/// clipboard must hold something: with nothing on it, the windowing layer sends no paste event
+/// for Ctrl+V. Paste in EffectCraft uses its own clipboard either way.
+fn clipboard_text(s: &effectcraft_engine::Session) -> String {
+    let st = &s.state;
+    if let Some(text) = &st.keyframe_text {
+        return text.clone();
+    }
+    let n = |n: usize, one: &str, many: &str| format!("EffectCraft: {n} {}", if n == 1 { one } else { many });
+    if st.clip_is_keys && !st.key_clipboard.is_empty() {
+        n(st.key_clipboard.iter().map(|c| c.keys.len()).sum(), "keyframe", "keyframes")
+    } else if !st.effect_clipboard.is_empty() {
+        n(st.effect_clipboard.len(), "effect", "effects")
+    } else if !st.contents_clipboard.is_empty() {
+        n(st.contents_clipboard.len(), "shape item", "shape items")
+    } else if !st.mask_clipboard.is_empty() {
+        n(st.mask_clipboard.len(), "mask", "masks")
+    } else if st.link_clipboard.is_some() {
+        "EffectCraft: property links".into()
+    } else {
+        n(st.clipboard.len(), "layer", "layers")
+    }
+}
+
+pub(crate) fn run_engine(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: Value) -> Result<Value, String> {
+    // Events already queued belong to earlier invocations (`engine.execute` defers them).
+    let queued = app.session.events.len();
+    let mut r = app.session.execute(id, params).map_err(|e| e.to_string());
+    if let Err(e) = &r {
+        app.ui.status = e.clone();
+    } else if COPY_COMMANDS.contains(&id) && app.session.state.text_edit.is_none() {
+        ctx.copy_text(clipboard_text(&app.session));
+    }
+    let events = app.session.drain_events();
+    for (index, ev) in events.into_iter().enumerate() {
+        match ev {
+            effectcraft_engine::Event::Frontend { command, params } => {
+                if let Err(e) = frontend(app, ctx, &command, params) {
+                    app.ui.status = e.clone();
+                    // A frontend-only command's own failure is the command's result (#696: a
+                    // workspace save that didn't reach disk reported success). An earlier
+                    // invocation's failure only sets the status.
+                    if index >= queued && command == id && r.is_ok() {
+                        r = Err(e);
+                    }
+                }
+            }
+            other => app.session.events.push(other),
+        }
+    }
+    r
+}
+
+fn toggle(slot: &mut bool, p: &Value) -> Value {
+    *slot = p.get("value").and_then(Value::as_bool).unwrap_or(!*slot);
+    json!(*slot)
+}
+
+/// Perform a frontend command (from `Event::Frontend`).
+pub fn frontend(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, p: Value) -> Result<Value, String> {
+    let now = app.now();
+    let v = &mut app.ui.viewer;
+    Ok(match id {
+        "mediaBrowser.copySourcePath" => {
+            let path = p.get("path").and_then(Value::as_str).filter(|path| !path.is_empty()).ok_or("A source path is required")?;
+            ctx.copy_text(path.to_string());
+            json!({"path": path})
+        }
+        "effects.copyPresetsFolderPath" => {
+            if cfg!(target_arch = "wasm32") {
+                return Err("The web app has no local presets folder".into());
+            }
+            let path = crate::panels::effects_presets::presets_dir().filter(|path| !path.as_os_str().is_empty()).ok_or("No presets folder is configured")?;
+            let path = std::path::absolute(path).map_err(|e| format!("Cannot resolve the presets folder path: {e}"))?;
+            let path = path.to_str().ok_or("The presets folder path is not valid UTF-8")?;
+            ctx.copy_text(path.to_string());
+            json!({"path": path})
+        }
+        "app.checkForUpdates" | "help.checkForUpdates" => {
+            crate::updates_ui::check(app);
+            Value::Null
+        }
+        "app.about" => {
+            app.dialog = Some(crate::Dialog::About);
+            Value::Null
+        }
+        // Window ▸ <ScriptUI panel>: dock (or bring forward) the panel the script built.
+        // Audio scrubbing: one frame of audio at `time` (default the current time).
+        "playback.scrubAudio" => {
+            let cid = app.session.active_comp_id().ok_or("no composition")?;
+            let t = p.get("time").and_then(Value::as_f64).map_or(app.session.time(), effectcraft_engine::time::Tick::from_seconds_f64);
+            app.scrub_audio(cid, t, now);
+            json!({"playing": app.scrub.is_some()})
+        }
+        // View ▸ New Viewer.
+        "view.newViewer" => json!({"viewer": crate::panels::viewers::new_viewer(app)}),
+        // Reveal Layer Source / Reveal Composition: show the Project panel on the item, opening
+        // its folders and clearing the search so the row is visible.
+        "project.reveal" => {
+            let ids: Vec<effectcraft_engine::project::ItemId> = p
+                .get("items")
+                .and_then(Value::as_array)
+                .map(|items| items.iter().filter_map(Value::as_u64).map(effectcraft_engine::project::ItemId).collect())
+                .or_else(|| p.get("item").and_then(Value::as_u64).map(|item| vec![effectcraft_engine::project::ItemId(item)]))
+                .unwrap_or_default();
+            crate::panels::project::reveal(app, ctx, &ids);
+            json!({"items": ids.iter().map(|item| item.0).collect::<Vec<_>>()})
+        }
+        // Run by id (control channel, MCP): the Project panel's selection, whatever has focus.
+        "project.deleteWithoutConfirmation" => crate::panels::delete_items::delete_confirmed(app, ctx, json!({}))?,
+        // A gradient property's "Edit Gradient…" (the Timeline's value): the Gradient Editor.
+        "prop.editGradient" => crate::panels::gradient_editor::open(app, &p)?,
+        "window.scriptPanel" => {
+            let id = p.get("window").and_then(Value::as_u64).ok_or("no ScriptUI panel window")? as u32;
+            app.show_panel(PanelKind::ScriptPanel(id));
+            json!({"window": id})
+        }
+        "layer.style.options" => {
+            crate::panels::layer_styles_dialog::open(app, &p)?;
+            Value::Null
+        }
+        "app.settings" => {
+            let page = p.get("page").and_then(Value::as_str).unwrap_or("general");
+            crate::panels::settings::open(app, effectcraft_engine::prefs::page_id(page).unwrap_or("general"));
+            Value::Null
+        }
+        "app.gpuInfo" => {
+            crate::panels::dialogs::info(
+                app,
+                "GPU Information",
+                &format!(
+                    "{}Layer cache: {} MB  •  Preview cache: {} MB.",
+                    effectcraft_engine::sysinfo::gpu_summary(&app.session),
+                    app.session.layer_cache.budget() >> 20,
+                    app.frames.budget() >> 20
+                ),
+            );
+            Value::Null
+        }
+        "app.hide" | "app.hideOthers" | "app.showAll" => {
+            // The desktop app asks macOS (NSApplication hide / hideOtherApplications /
+            // unhideAllApplications); elsewhere Hide minimizes and the others don't apply.
+            if app.hooks.app_action.as_ref().is_some_and(|f| f(id)) {
+                return Ok(Value::Null);
+            }
+            match id {
+                "app.hide" => ctx.send_viewport_cmd(egui::ViewportCommand::Minimized(true)),
+                _ => return Err(format!("`{id}` is only available on macOS")),
+            }
+            Value::Null
+        }
+        "app.quit" => {
+            ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+            Value::Null
+        }
+        "app.commandPalette" => {
+            app.dialog_state.palette_query = p.get("query").and_then(Value::as_str).unwrap_or_default().to_string();
+            app.dialog_state.palette_sel = 0;
+            app.dialog = Some(crate::Dialog::CommandPalette);
+            Value::Null
+        }
+        "app.keyboardShortcuts" => {
+            crate::panels::shortcut_editor::open(app);
+            Value::Null
+        }
+        "app.templates" => {
+            let kind = p.get("kind").and_then(Value::as_str).unwrap_or("renderSettings");
+            crate::panels::rq_templates::open(app, ctx, kind);
+            Value::Null
+        }
+        "renderQueue.notify" => {
+            // Render finished with Notify on: a toast, the dock/taskbar attention request, and the
+            // host's system sound (the desktop app handles `renderQueue.notify`).
+            let msg = p.get("message").and_then(Value::as_str).unwrap_or("Render finished").to_string();
+            app.toast = Some((msg, now));
+            ctx.send_viewport_cmd(egui::ViewportCommand::RequestUserAttention(egui::UserAttentionType::Informational));
+            if let Some(f) = app.hooks.app_action.as_ref() {
+                f("renderQueue.notify");
+            }
+            Value::Null
+        }
+        "app.find" => {
+            if let Some(q) = p.get("query").and_then(Value::as_str) {
+                app.ui.project_search = q.to_string();
+            }
+            app.show_panel(PanelKind::Project);
+            Value::Null
+        }
+        "playback.toggle" => {
+            // The play button and Spacebar: `{shortcut?}` picks which Preview panel shortcut's
+            // options to play with (default Spacebar).
+            let sc = match p.get("shortcut").and_then(Value::as_str) {
+                Some(k) => effectcraft_engine::preview::PreviewShortcut::parse(k).ok_or_else(|| format!("unknown preview shortcut `{k}`"))?,
+                None => effectcraft_engine::preview::PreviewShortcut::Spacebar,
+            };
+            app.toggle_play_with(now, sc);
+            json!({"playing": app.playback.playing, "shortcut": sc.id()})
+        }
+        "playback.cacheWhenIdle" => {
+            let r = toggle(&mut app.ui.cache_when_idle, &p);
+            app.set_pref("previews.cacheFramesWhenIdle", r.clone())?;
+            r
+        }
+        "playback.audio" => {
+            // Include Audio of the shortcut shown in the Preview panel.
+            let mut on = app.session.prefs.preview.active().include_audio;
+            let r = toggle(&mut on, &p);
+            app.session.execute("playback.settings.set", json!({"includeAudio": on})).map_err(|e| e.to_string())?;
+            if !on {
+                app.audio = None;
+            }
+            r
+        }
+        // Zoom In / Zoom Out act on the focused viewer: the Layer panel when it has focus, else
+        // the Composition viewer.
+        "view.zoomIn" | "view.zoomOut" if app.ui.focused == PanelKind::Layer => {
+            let cur = app.ui.layer_zoom.unwrap_or_else(|| crate::panels::layer_panel::last_fit(ctx));
+            // The Layer panel zooms in points (pixels-per-point 1).
+            let next = zoom_step(cur, 1.0, id == "view.zoomIn");
+            app.ui.layer_zoom = Some(next);
+            json!({"zoom": next, "panel": "layer"})
+        }
+        "view.zoomIn" | "view.zoomOut" => {
+            let ppp = ctx.pixels_per_point();
+            let cur = v.zoom.unwrap_or_else(|| crate::panels::viewer::last_fit(ctx));
+            let next = zoom_step(cur, ppp, id == "view.zoomIn");
+            v.zoom = Some(next);
+            json!({"zoom": next})
+        }
+        // View ▸ Resolution ▸ Custom without a factor (the engine sets the comp's resolution).
+        "view.res.custom" => {
+            let cur = match app.viewer_res() {
+                Resolution::Custom(n) => f64::from(n),
+                _ => 2.0,
+            };
+            crate::panels::dialogs::form(
+                app,
+                "Custom Resolution",
+                "view.res.custom",
+                json!({}),
+                vec![crate::panels::dialogs::Field::num("factor", "Render every n-th pixel", cur)],
+            );
+            Value::Null
+        }
+        "view.rulers" => toggle(&mut v.rulers, &p),
+        "view.guides" => toggle(&mut v.guides, &p),
+        "view.snapToGuides" => toggle(&mut v.snap_guides, &p),
+        "view.lockGuides" => toggle(&mut v.lock_guides, &p),
+        "view.grid" => toggle(&mut v.grid, &p),
+        "view.snapToGrid" => toggle(&mut v.snap_grid, &p),
+        "view.layerControls" => toggle(&mut v.show_layer_controls, &p),
+        "view.options" => {
+            app.dialog = Some(crate::Dialog::ViewOptions);
+            Value::Null
+        }
+        "view.panelBackground" => {
+            if p.get("pick").and_then(Value::as_bool) == Some(true) {
+                let [r, g, b] = v.custom_pasteboard;
+                crate::panels::dialogs::form(
+                    app,
+                    "Panel Background Color",
+                    "view.panelBackground",
+                    json!({}),
+                    vec![crate::panels::dialogs::Field::text("color", "Color (#rrggbb)", &format!("#{r:02x}{g:02x}{b:02x}"))],
+                );
+                return Ok(Value::Null);
+            }
+            let c = p.get("color").and_then(Value::as_str).unwrap_or("mediumGray");
+            v.pasteboard = match c {
+                "black" => Some([0, 0, 0]),
+                "darkGray" => Some([0x2a, 0x2a, 0x2a]),
+                "mediumGray" => None,
+                "lightGray" => Some([0xb4, 0xb4, 0xb4]),
+                "white" => Some([0xff, 0xff, 0xff]),
+                "custom" => Some(v.custom_pasteboard),
+                hex => {
+                    let c = effectcraft_engine::color::Rgba::from_hex(hex).ok_or_else(|| format!("unknown colour `{hex}`"))?;
+                    let rgb = [(c.r * 255.0).round() as u8, (c.g * 255.0).round() as u8, (c.b * 255.0).round() as u8];
+                    v.custom_pasteboard = rgb;
+                    Some(rgb)
+                }
+            };
+            Value::Null
+        }
+        // Ctrl+\ / Cmd+\, as in After Effects (#336): `{maximized}`, the window's new state.
+        "window.maximizeApp" => {
+            let maximized = !ctx.input(|i| i.viewport().maximized.unwrap_or(false));
+            ctx.send_viewport_cmd(egui::ViewportCommand::Maximized(maximized));
+            json!({"maximized": maximized})
+        }
+        "view.fullScreen" => {
+            let full = ctx.input(|i| i.viewport().fullscreen.unwrap_or(false));
+            ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(!full));
+            json!(!full)
+        }
+        "window.panel" => {
+            let name = p.get("panel").and_then(Value::as_str).unwrap_or_default();
+            if name.eq_ignore_ascii_case("tools") {
+                app.ui.status = "The Tools panel is the toolbar in the header".into();
+                return Ok(Value::Null);
+            }
+            let panel = PanelKind::from_name(name).ok_or_else(|| format!("unknown panel `{name}`"))?;
+            app.show_panel(panel);
+            Value::Null
+        }
+        "window.workspace" => {
+            let want = p.get("name").and_then(Value::as_str).unwrap_or("Default").to_ascii_lowercase().replace(' ', "");
+            let name = app
+                .workspace_names()
+                .into_iter()
+                .find(|w| w.to_ascii_lowercase().replace(' ', "") == want)
+                .ok_or_else(|| format!("unknown workspace `{want}`"))?;
+            app.set_workspace(&name);
+            json!({"workspace": name})
+        }
+        "window.resetWorkspace" => {
+            let name = app.ui.workspace.clone();
+            app.set_workspace(&name);
+            Value::Null
+        }
+        "window.saveWorkspace" => {
+            crate::workspace_state::ensure_positions_ready(&app.ui)?;
+            let name = app.ui.workspace.clone();
+            app.ui.saved_workspaces.insert(name.clone(), app.ui.dock.clone());
+            app.store_saved_workspaces()?;
+            json!({"workspace": name})
+        }
+        "window.saveWorkspaceAs" => {
+            let Some(name) = p.get("name").and_then(Value::as_str).map(str::trim).filter(|n| !n.is_empty()).map(str::to_string) else {
+                crate::panels::dialogs::form(
+                    app,
+                    "New Workspace",
+                    "window.saveWorkspaceAs",
+                    json!({}),
+                    vec![crate::panels::dialogs::Field::text("name", "Name", "Untitled Workspace")],
+                );
+                return Ok(Value::Null);
+            };
+            crate::workspace_state::ensure_positions_ready(&app.ui)?;
+            app.ui.saved_workspaces.insert(name.clone(), app.ui.dock.clone());
+            app.ui.workspace = name.clone();
+            app.store_saved_workspaces()?;
+            json!({"workspace": name})
+        }
+        "window.editWorkspaces" => {
+            let Some(name) = p.get("name").and_then(Value::as_str).map(str::to_string) else {
+                let cur = app.ui.workspace.clone();
+                crate::panels::dialogs::form(
+                    app,
+                    "Edit Workspaces",
+                    "window.editWorkspaces",
+                    json!({}),
+                    vec![
+                        crate::panels::dialogs::Field::text("name", "Workspace", &cur),
+                        crate::panels::dialogs::Field::text("rename", "Rename to", &cur),
+                        crate::panels::dialogs::Field::bool("delete", "Delete", false),
+                    ],
+                );
+                return Ok(Value::Null);
+            };
+            let builtin = crate::dock::WORKSPACES.contains(&name.as_str());
+            if p.get("delete").and_then(Value::as_bool) == Some(true) {
+                crate::workspace_state::ensure_positions_ready(&app.ui)?;
+                if app.ui.saved_workspaces.remove(&name).is_none() && !builtin {
+                    return Err(format!("no workspace `{name}`"));
+                }
+                // Leave the deleted workspace first: a current workspace needs a definition.
+                if app.ui.workspace == name {
+                    app.set_workspace("Default");
+                }
+                app.store_saved_workspaces()?;
+                return Ok(json!({"deleted": name}));
+            }
+            if let Some(new) = p.get("rename").and_then(Value::as_str).map(str::trim).filter(|n| !n.is_empty() && *n != name) {
+                if builtin {
+                    return Err(format!("`{name}` is a built-in workspace: save it as a new workspace instead"));
+                }
+                crate::workspace_state::ensure_positions_ready(&app.ui)?;
+                let dock = app.ui.saved_workspaces.remove(&name).ok_or_else(|| format!("no workspace `{name}`"))?;
+                app.ui.saved_workspaces.insert(new.to_string(), dock);
+                if app.ui.workspace == name {
+                    app.ui.workspace = new.to_string();
+                }
+                app.store_saved_workspaces()?;
+                return Ok(json!({"renamed": new}));
+            }
+            json!({"workspaces": app.workspace_names()})
+        }
+        "view.lookAt" => {
+            let r: Vec<f64> = p.get("rect").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_f64).collect()).unwrap_or_default();
+            if r.len() == 4 {
+                let map: Option<crate::panels::viewer::ViewerMap> = ctx.data(|d| d.get_temp(egui::Id::unique("viewer-map")));
+                if let Some(m) = map {
+                    let (rw, rh) = (((r[2] - r[0]) as f32).max(1.0), ((r[3] - r[1]) as f32).max(1.0));
+                    let zoom = ((m.area.width() - 40.0) / rw).min((m.area.height() - 40.0) / rh).clamp(0.015, 32.0);
+                    let rc = [(r[0] + r[2]) as f32 / 2.0, (r[1] + r[3]) as f32 / 2.0];
+                    let v = &mut app.ui.viewer;
+                    v.zoom = Some(zoom);
+                    v.pan = [m.comp[0] * zoom / 2.0 - rc[0] * zoom, m.comp[1] * zoom / 2.0 - rc[1] * zoom];
+                }
+            }
+            Value::Null
+        }
+        "comp.flowchart" => {
+            // Chart the active comp; Layer ▸ Reveal ▸ Reveal Layer in Project Flowchart shows
+            // layers and selects the layer's node.
+            app.ui.flowchart.root = app.session.active_comp_id().map(|c| c.0);
+            if let (Some(c), Some(l)) = (app.session.active_comp_id(), app.session.state.selected_layers.first()) {
+                app.ui.flowchart.layers = true;
+                app.ui.flowchart.selected = Some(format!("layer:{}:{}", c.0, l.0));
+            }
+            app.show_panel(PanelKind::Flowchart);
+            Value::Null
+        }
+        "comp.miniFlowchart" => {
+            let at = ctx.input(|i| i.pointer.hover_pos()).unwrap_or_else(|| ctx.content_rect().center());
+            app.ui.mini_flowchart = Some([at.x, at.y]);
+            Value::Null
+        }
+        "track.editTargetDialog" => {
+            crate::panels::tracker::open_target(app)?;
+            Value::Null
+        }
+        "track.optionsDialog" => {
+            crate::panels::tracker::open_options(app)?;
+            Value::Null
+        }
+        "layer.openLayer" => {
+            let id = p.get("layer").and_then(Value::as_u64).or_else(|| app.session.state.selected_layers.first().map(|l| l.0));
+            // Another layer opens at Fit.
+            if id != app.ui.layer_panel {
+                app.ui.layer_zoom = None;
+                app.ui.layer_pan = [0.0, 0.0];
+            }
+            app.ui.layer_panel = id;
+            app.ui.layer_view = None;
+            app.show_panel(PanelKind::Layer);
+            Value::Null
+        }
+        "app.confirmExecute" => {
+            // Settings ▸ Scripting ▸ Warn User When Executing Files.
+            let path = p.get("path").and_then(Value::as_str).unwrap_or_default().to_string();
+            crate::panels::forms::form(
+                app,
+                "A script wants to open a file",
+                "file.executeFile",
+                json!({"path": path, "confirmed": true}),
+                vec![crate::panels::forms::Field::text("path", "Open", &path)],
+            );
+            Value::Null
+        }
+        "app.showReport" => {
+            let title = p.get("title").and_then(Value::as_str).unwrap_or("Report").to_string();
+            let text = p.get("text").and_then(Value::as_str).unwrap_or_default().to_string();
+            crate::panels::dialogs::info(app, &title, &text);
+            Value::Null
+        }
+        "window.assignWorkspaceShortcut" => {
+            let mut q = p.clone();
+            q["workspace"] = json!(app.ui.workspace);
+            return run_engine(app, ctx, "window.assignWorkspaceShortcut", q);
+        }
+        "file.interpretFootage" => {
+            // Import ▸ Interpret Unlabeled Alpha As: Ask User.
+            if let Some(i) = p.get("item").and_then(Value::as_u64) {
+                app.session.state.project_selection = vec![effectcraft_engine::project::ItemId(i)];
+            }
+            crate::panels::dialogs::open_form(app, "file.interpretFootage", &json!({}));
+            Value::Null
+        }
+        // Help ▸ In-App Tutorials: the Home screen's Learn tab.
+        "help.inAppTutorials" => {
+            app.ui.start_screen = true;
+            app.ui.home_learn = true;
+            app.ui.home_templates = false;
+            Value::Null
+        }
+        // File ▸ New ▸ New Project from Template…: the Home screen's Templates tab.
+        "file.newFromTemplate" => {
+            app.ui.start_screen = true;
+            app.ui.home_learn = false;
+            app.ui.home_templates = true;
+            Value::Null
+        }
+        "effect.manage" => {
+            app.show_panel(PanelKind::EffectsPresets);
+            Value::Null
+        }
+        "anim.browsePresets" => {
+            app.ui.effects_search.clear();
+            app.ui.effects_view.presets = true;
+            app.ui.effects_open.insert("presets".into());
+            ctx.data_mut(|data| data.insert_temp(egui::Id::unique(crate::panels::effects_presets::REVEAL_PRESETS_ID), true));
+            app.show_panel(PanelKind::EffectsPresets);
+            Value::Null
+        }
+        "timeline.revealProps" => {
+            let props = p.get("props").and_then(Value::as_array).cloned().unwrap_or_default();
+            let uids = |k: &str| -> Vec<u64> { props.iter().filter_map(|x| x.get(k).and_then(Value::as_u64)).collect() };
+            let (found, with_props) = (uids("prop"), uids("layer"));
+            // The layers it looked at (`layers`), else those it found something on. Layers that
+            // have nothing to show close; the others' reveals stay.
+            let targets: Vec<u64> = match p.get("layers").and_then(Value::as_array) {
+                Some(l) => l.iter().filter_map(Value::as_u64).collect(),
+                None => with_props.clone(),
+            };
+            // The targets' earlier picks go (U after UU shows the keyframed ones only).
+            let comp = app.session.active_comp_arc();
+            let theirs = |u: u64| {
+                comp.as_ref().is_some_and(|c| {
+                    targets
+                        .iter()
+                        .filter_map(|l| c.layer(effectcraft_engine::project::LayerId(*l)))
+                        .any(|l| l.props.find(u).is_some() || l.props.find_group(u).is_some())
+                })
+            };
+            let tl = &mut app.ui.timeline;
+            tl.reveal_props.retain(|u| !theirs(*u));
+            tl.reveal_props.extend(found.iter().copied());
+            let (shown, hidden): (Vec<u64>, Vec<u64>) = targets.into_iter().partition(|l| with_props.contains(l));
+            tl.apply_reveal(&hidden, vec![]);
+            if !shown.is_empty() {
+                tl.apply_reveal(&shown, vec!["props".into()]);
+            }
+            // Properties inside effects (puppet pins…) show under their effect, twirled open.
+            for (layer, prop) in props.iter().filter_map(|x| Some((x.get("layer")?.as_u64()?, x.get("prop")?.as_u64()?))) {
+                crate::panels::timeline::open_effect_paths(app, layer, &[prop]);
+            }
+            json!({"revealed": found.len()})
+        }
+        _ => return Err(format!("`{id}` is not a frontend command")),
+    })
+}
+
+/// Commands that need a file or folder path: ask the host's file dialog when `params` lacks one.
+pub(super) fn file_dialog(app: &mut EffectcraftApp, id: &str, params: &Value) -> Option<Result<Value, String>> {
+    enum Ask {
+        Folder,
+        Import,
+        OpenProject,
+        Save(std::borrow::Cow<'static, str>),
+        Open(&'static [&'static str]),
+        /// A movie, or a file with one of these extensions.
+        OpenFootage(&'static [&'static str]),
+    }
+    // Save As, Save a Copy and Save a Copy As XML start from the open project's file, in its
+    // folder, as After Effects does (#2788); an untitled project starts from Untitled Project.
+    // Save a Copy adds ` copy` (`suffix`): it never writes over the open project's file.
+    let project_as = |suffix: &str, ext: &str| -> std::borrow::Cow<'static, str> {
+        let Some(path) = app.session.path.as_deref().map(std::path::Path::new) else { return format!("Untitled Project{suffix}.{ext}").into() };
+        let stem = path.file_stem().map(|s| s.to_string_lossy().into_owned()).unwrap_or_else(|| "Untitled Project".into());
+        path.with_file_name(format!("{stem}{suffix}.{ext}")).to_string_lossy().into_owned().into()
+    };
+    let (key, ask) = match id {
+        "file.import" | "file.importMultiple" => ("paths", Ask::Import),
+        "file.open" => ("path", Ask::OpenProject),
+        "file.save" if app.session.path.is_none() => ("path", Ask::Save(project_as("", "ecproj"))),
+        "file.saveAs" => ("path", Ask::Save(project_as("", "ecproj"))),
+        "file.saveCopy" => ("path", Ask::Save(project_as(" copy", "ecproj"))),
+        "comp.saveFrameAs" => ("path", Ask::Save("Frame.png".into())),
+        "comp.saveFrameAsPsd" => ("path", Ask::Save("Frame.psd".into())),
+        "comp.saveFrameAsExr" => ("path", Ask::Save("Frame.exr".into())),
+        "file.watchFolder" if params.get("stop").is_none() => ("folder", Ask::Save("Watch Folder".into())),
+        "anim.savePreset" => ("path", Ask::Save("Preset.ecpreset".into())),
+        "anim.applyPreset" => ("path", Ask::Open(&["ecpreset", "json"])),
+        "view.exportGuides" => ("path", Ask::Save("Guides.json".into())),
+        "view.importGuides" => ("path", Ask::Open(&["json"])),
+        "camera.exportBlender" => ("path", Ask::Save("Tracked Scene.py".into())),
+        "file.exportLottie" => ("path", Ask::Save("Animation.json".into())),
+        "file.importLottie" => ("path", Ask::Open(&["json", "lottie"])),
+        "file.importProject" => ("path", Ask::Open(&["ecproj", "ecprojx"])),
+        "file.importTimeline" => ("path", Ask::Open(&["xml", "fcpxml", "otio", "edl", "aaf", "omf"])),
+        "render.saveCurrentPreview" => ("path", Ask::Save("Preview.mp4".into())),
+        "file.runScript" if params.get("name").is_none() && params.get("recent").is_none() => ("path", Ask::Open(&["jsx", "js", "jsonl", "json", "txt"])),
+        "file.installScript" | "file.installScriptUIPanel" => ("path", Ask::Open(&["jsx", "js"])),
+        "effect.plugins.load" if params.get("folder").is_none() => ("path", Ask::Open(&["wasm", "wat"])),
+        "file.replaceFootage" => ("path", Ask::Import),
+        "file.relinkFootage" => ("folder", Ask::Folder),
+        "file.collectFiles" => ("folder", Ask::Save("Collected Files".into())),
+        // An open XML project gets ` copy` too: the copy never writes over the open file.
+        "file.saveCopyAsXml" => {
+            let xml = app.session.path.as_deref().and_then(|p| std::path::Path::new(p).extension()).is_some_and(|e| e.eq_ignore_ascii_case("ecprojx"));
+            ("path", Ask::Save(project_as(if xml { " copy" } else { "" }, "ecprojx")))
+        }
+        "keys.rpfCameraImport" => ("path", Ask::Open(&["json", "csv", "txt"])),
+        "essential.exportTemplate" => ("path", Ask::Save("Template.ectemplate".into())),
+        "essential.importTemplate" => ("path", Ask::Open(&["ectemplate"])),
+        "file.setProxy" => ("path", Ask::OpenFootage(&["png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "tga", "exr"])),
+        _ => return None,
+    };
+    if params.get(key).is_some()
+        || params.get("path").is_some()
+        || params.get("paths").is_some()
+        || params.get("steps").is_some()
+        || params.get("preset").is_some()
+    {
+        return None;
+    }
+    // Importable files besides movies.
+    const MEDIA: &[&str] = &[
+        "png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "exr", "dpx", "cin", "wav", "aif", "aiff", "mp3", "flac", "ogg", "opus", "svg", "pdf", "ai",
+        "eps", "psd", "psb", "tga", "hdr", "gltf", "glb", "obj", "stl", "fbx", "json", "csv", "tsv",
+    ];
+    let footage = |more: &[&'static str]| effectcraft_project::VIDEO_EXTENSIONS.iter().chain(more).copied().collect::<Vec<_>>();
+    // A host whose blocking dialogs are unsafe inside this frame shows the dialog without
+    // blocking — macOS: the nested event loop re-entered winit's handler on a drag over the
+    // window and aborted the app (#511); Linux: the desktop portal's answer never gets pumped,
+    // so the compositor marks the window as not responding (#1275) — and the command continues
+    // when the answer arrives.
+    if let Some(spawn) = app.hooks.file_dialog_async.as_ref() {
+        let request = match ask {
+            Ask::Folder => crate::FileDialog::Folder,
+            Ask::Import => crate::FileDialog::Open { exts: footage(MEDIA).iter().map(|e| e.to_string()).collect(), many: key == "paths" },
+            Ask::OpenProject => crate::FileDialog::OpenProject,
+            Ask::Open(exts) => crate::FileDialog::Open { exts: exts.iter().map(|e| e.to_string()).collect(), many: false },
+            Ask::OpenFootage(more) => crate::FileDialog::Open { exts: footage(more).iter().map(|e| e.to_string()).collect(), many: false },
+            Ask::Save(default) => crate::FileDialog::save(&default),
+        };
+        let tx = app.dialog_answers.0.clone();
+        let answer = crate::DialogAnswer { command: id.to_string(), key, params: params.clone(), paths: Vec::new() };
+        app.file_dialogs.opened();
+        spawn(
+            request,
+            Box::new(move |paths| {
+                let _ = tx.send(crate::DialogAnswer { paths, ..answer });
+            }),
+        );
+        return Some(Ok(json!({"dialog": id})));
+    }
+    let picked: Option<Value> = match ask {
+        Ask::Folder => {
+            let Some(f) = app.hooks.pick_folder.as_ref() else { return Some(Err("no folder dialog available (pass `folder`)".into())) };
+            f().map(Value::from)
+        }
+        Ask::Import => {
+            let Some(f) = app.hooks.pick_files.as_ref() else { return Some(Err("no file dialog available (pass `paths`)".into())) };
+            picked_value(key, f(&footage(MEDIA)))
+        }
+        Ask::OpenProject => {
+            let Some(f) = app.hooks.pick_open_project.as_ref() else { return Some(Err("no file dialog available (pass `path`)".into())) };
+            f().map(|s| json!(s))
+        }
+        Ask::Open(exts) => {
+            let Some(f) = app.hooks.pick_files.as_ref() else { return Some(Err("no file dialog available (pass `path`)".into())) };
+            f(exts).first().map(|s| json!(s))
+        }
+        Ask::OpenFootage(more) => {
+            let Some(f) = app.hooks.pick_files.as_ref() else { return Some(Err("no file dialog available (pass `path`)".into())) };
+            f(&footage(more)).first().map(|s| json!(s))
+        }
+        Ask::Save(default) => {
+            let Some(picked) = app.hooks.save_dialog(&default) else { return Some(Err("no file dialog available (pass `path`)".into())) };
+            picked.map(|s| json!(s))
+        }
+    };
+    let Some(v) = picked else { return Some(Ok(Value::Null)) };
+    Some(run_with_picked(app, id, key, params, v))
+}
+
+/// The dialog's answer as the command's `key` parameter (`None`: cancelled).
+fn picked_value(key: &str, paths: Vec<String>) -> Option<Value> {
+    match (paths.is_empty(), key) {
+        (true, _) => None,
+        (false, "paths") => Some(json!(paths)),
+        (false, _) => paths.into_iter().next().map(Value::from),
+    }
+}
+
+/// A file dialog shown without blocking ([`crate::Hooks::file_dialog_async`]) answered: run its
+/// command with the picked path (nothing when it was cancelled).
+pub(crate) fn dialog_answered(app: &mut EffectcraftApp, answer: crate::DialogAnswer) {
+    let Some(v) = picked_value(answer.key, answer.paths) else { return };
+    if let Err(e) = run_with_picked(app, &answer.command, answer.key, &answer.params, v) {
+        app.ui.status = e;
+    }
+}
+
+/// Run command `id` with the path picked for it in parameter `key`.
+fn run_with_picked(app: &mut EffectcraftApp, id: &str, key: &str, params: &Value, v: Value) -> Result<Value, String> {
+    let mut p = params.as_object().cloned().unwrap_or_default();
+    p.insert(key.to_string(), v);
+    // Picked files import in the background, with the Importing card showing progress (#270).
+    if matches!(id, "file.import" | "file.importMultiple") {
+        p.insert("background".into(), Value::Bool(true));
+    }
+    // Photoshop files ask how to import them first; numbered stills whether to import them as an
+    // image sequence.
+    let picked = Value::Object(p.clone());
+    if id == "file.import" && crate::panels::dialogs::open_form(app, id, &picked)
+        || matches!(id, "file.import" | "file.importMultiple") && crate::panels::forms::open_import_sequence(app, &picked)
+    {
+        return Ok(json!({"dialog": id}));
+    }
+    // Save (untitled) becomes Save As.
+    let id = if id == "file.save" { "file.saveAs" } else { id };
+    let r = app.session.execute(id, Value::Object(p)).map_err(|e| e.to_string());
+    if let Err(e) = &r {
+        app.ui.status = e.clone();
+    }
+    r
+}
+
+/// View ▸ Zoom In / Zoom Out: the next standard magnification (as a share of screen pixels, so
+/// 100 % is one comp pixel per screen pixel at any display scaling) above or below `cur`, which is
+/// in points per comp pixel like the result (#882).
+pub(super) fn zoom_step(cur: f32, ppp: f32, zoom_in: bool) -> f32 {
+    const STEPS: [f32; 16] = [0.015, 0.03, 0.0625, 0.125, 0.25, 0.333, 0.5, 0.66, 1.0, 1.5, 2.0, 3.0, 4.0, 8.0, 16.0, 32.0];
+    let ppp = if ppp.is_finite() && ppp > 0.0 { ppp } else { 1.0 };
+    let shown = cur * ppp;
+    let next = if zoom_in {
+        STEPS.iter().copied().find(|s| *s > shown + 1e-3).unwrap_or(32.0)
+    } else {
+        STEPS.iter().rev().copied().find(|s| *s < shown - 1e-3).unwrap_or(0.015)
+    };
+    next / ppp
+}
diff --git a/crates/ui-egui/src/menus/invoke.rs b/crates/ui-egui/src/menus/invoke.rs
new file mode 100644
index 000000000..6ee3e2bb9
--- /dev/null
+++ b/crates/ui-egui/src/menus/invoke.rs
@@ -0,0 +1,724 @@
+use super::frontend::{file_dialog, frontend, run_engine};
+use super::shortcuts::system_paste_id;
+use super::*;
+
+pub fn panel_command_id(p: PanelKind) -> String {
+    format!("window.panel.{}", p.id())
+}
+
+/// The reveal shortcuts (P, S, R, T, A, E, M, F, L…). `add` (Shift+key) adds the property to
+/// (or removes it from) those already revealed instead of replacing them.
+pub fn reveal(app: &mut EffectcraftApp, kind: &str, now: f64, add: bool) {
+    // The double-press shortcuts: the same key again within 0.6 s reveals its second set (LL
+    // Waveform, TT Mask Opacity, MM all mask properties, EE Expressions, RR Time Remap, AA
+    // Material Options, PP paint / Roto Brush / Puppet, SS selected properties, FF missing
+    // effects). A single M shows Mask Path.
+    let double = |k: &str| -> Option<&'static str> {
+        Some(match k {
+            "levels" => "waveform",
+            "opacity" => "maskOpacity",
+            "masks" => "masks",
+            "effects" => "expressions",
+            "rotation" => "timeRemap",
+            "anchor" => "material",
+            "position" => "paint",
+            "scale" => "selected",
+            "feather" => "missingEffects",
+            _ => return None,
+        })
+    };
+    let pressed = kind;
+    // (With Shift a second press removes the property again instead.)
+    let again = !add && matches!(app.last_reveal.take(), Some((k, t)) if k == pressed && now - t < 0.6);
+    app.last_reveal = Some((if again { String::new() } else { pressed.to_string() }, now));
+    let kind = match (again, double(pressed)) {
+        (true, Some(d)) => {
+            // The second press replaces what the first one revealed.
+            let first = if pressed == "masks" { "maskPath" } else { pressed };
+            app.ui.timeline.reveal.retain(|k| k != first);
+            d
+        }
+        _ if pressed == "masks" => "maskPath",
+        _ => pressed,
+    };
+    let targets = reveal_targets(app);
+    let tl = &mut app.ui.timeline;
+    let present = tl.reveal.iter().any(|k| k == kind);
+    let mut kinds = tl.reveal.clone();
+    if add {
+        if present {
+            kinds.retain(|k| k != kind);
+        } else {
+            kinds.retain(|k| k != "props" || !tl.reveal_props.is_empty());
+            kinds.push(kind.to_string());
+        }
+    } else if present && kinds.len() == 1 {
+        kinds.clear();
+    } else {
+        kinds = vec![kind.to_string()];
+    }
+    tl.apply_reveal(&targets, kinds.clone());
+    crate::panels::timeline::open_revealed(app, &targets, &kinds);
+}
+
+/// Show Time Remap on the layers of a `layer.enableTimeRemap` (`layers` by id, else the
+/// selected ones) that have it now.
+fn reveal_time_remap(app: &mut EffectcraftApp, params: &Value) {
+    let asked: Vec<u64> = match params.get("layers").and_then(Value::as_array) {
+        Some(a) => a.iter().filter_map(Value::as_u64).collect(),
+        None => app.session.state.selected_layers.iter().map(|l| l.0).collect(),
+    };
+    let Some(comp) = app.session.active_comp() else { return };
+    let layers: Vec<u64> = comp.layers.iter().filter(|l| asked.contains(&l.id.0) && l.props.get("timeRemap").is_some()).map(|l| l.id.0).collect();
+    if !layers.is_empty() {
+        app.ui.timeline.apply_reveal(&layers, vec!["timeRemap".into()]);
+    }
+}
+
+/// After Alt+Shift+P (A, S, R, T) the Timeline shows the property on each layer it keyed, as in
+/// After Effects: added to what a reveal shortcut shows, else with the layer's Transform twirled
+/// open, else alone like P.
+fn reveal_keyed(app: &mut EffectcraftApp, keyed: &Value, kind: &str) {
+    let layers: std::collections::BTreeSet<u64> = keyed.as_array().into_iter().flatten().filter_map(|k| k.get("layer").and_then(Value::as_u64)).collect();
+    let Some(comp) = app.session.active_comp() else { return };
+    let tl = &mut app.ui.timeline;
+    for id in layers {
+        let shown = tl.layer_reveal.get(&id).filter(|k| !k.is_empty()).cloned();
+        match shown {
+            Some(mut kinds) => {
+                if !kinds.iter().any(|k| k == kind) {
+                    kinds.push(kind.to_string());
+                    tl.layer_reveal.insert(id, kinds);
+                }
+            }
+            None if tl.open_layers.contains(&id) => {
+                if let Some(tr) = comp.layer(effectcraft_engine::project::LayerId(id)).and_then(|l| l.transform()) {
+                    tl.open_groups.insert(tr.uid);
+                }
+            }
+            None => {
+                tl.open_layers.insert(id);
+                tl.layer_reveal.insert(id, vec![kind.to_string()]);
+            }
+        }
+    }
+}
+
+/// The layers a reveal shortcut acts on: the selected ones, else every layer of the active comp.
+fn reveal_targets(app: &EffectcraftApp) -> Vec<u64> {
+    if app.session.state.selected_layers.is_empty() {
+        app.session.active_comp().map(|c| c.layers.iter().map(|l| l.id.0).collect()).unwrap_or_default()
+    } else {
+        app.session.state.selected_layers.iter().map(|l| l.0).collect()
+    }
+}
+
+/// The arrow keys nudge the selected layers 1 pixel at the viewer's magnification (`up`,
+/// `down`, `left`, `right`), 10 with Shift (`up10`…), as After Effects does, so zoomed in
+/// they move by fractions of a comp pixel. From any panel except Project, Effects & Presets and Render Queue (which own the
+/// arrow keys for its own keyboard navigation, #961); not while typing, with a dialog or
+/// menu open. With mask points selected the arrows move the points instead (#1288).
+fn nudge(app: &mut EffectcraftApp, ctx: &egui::Context, dir: &str) -> Result<Value, String> {
+    let (side, n) = match dir.strip_suffix("10") {
+        Some(side) => (side, 10.0),
+        None => (dir, 1.0),
+    };
+    let (x, y) = match side {
+        "up" => (0.0, -n),
+        "down" => (0.0, n),
+        "left" => (-n, 0.0),
+        "right" => (n, 0.0),
+        _ => return Err(format!("unknown nudge `{dir}`")),
+    };
+    let st = &app.session.state;
+    if matches!(app.ui.focused, PanelKind::Project | PanelKind::EffectsPresets | PanelKind::RenderQueue)
+        || (st.selected_layers.is_empty() && st.selected_vertices.is_empty())
+        || st.text_edit.is_some()
+    {
+        return Ok(Value::Null);
+    }
+    // Screen pixels per comp pixel.
+    let zoom = (app.ui.viewer.zoom.unwrap_or_else(|| crate::panels::viewer::last_fit(ctx)) * ctx.pixels_per_point()) as f64;
+    let k = if zoom.is_finite() && zoom > 1e-6 { 1.0 / zoom } else { 1.0 };
+    if let Some(layer) = st.selected_vertices.first().map(|v| v.layer) {
+        let d = vertex_delta(app, layer, [x * k, y * k]);
+        return run_engine(app, ctx, "mask.moveVertices", json!({"delta": d}));
+    }
+    run_engine(app, ctx, "layer.nudge", json!({"x": x * k, "y": y * k}))
+}
+
+/// A comp-space step `d` in the layer space of `layer`, where mask points live. Like a drag of
+/// the points in the viewer, every selected point takes the first one's layer space.
+fn vertex_delta(app: &EffectcraftApp, layer: effectcraft_engine::project::LayerId, d: [f64; 2]) -> [f64; 2] {
+    use effectcraft_engine::geom::vec2;
+    let s = &app.session;
+    let (Some(cid), Some(comp)) = (s.active_comp_id(), s.active_comp()) else { return d };
+    let Some(l) = comp.layer(layer) else { return d };
+    let ectx = effectcraft_engine::render::EvalCtx {
+        project: &s.project,
+        comp_id: cid,
+        comp,
+        time: s.time(),
+        expr: s.expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
+    let (l2c, _) = crate::panels::viewer::l2c(&ectx, l);
+    l2c.inverse().map_or(d, |inv| {
+        let v = inv.apply_vec(vec2(d[0], d[1]));
+        [v.x, v.y]
+    })
+}
+
+pub(super) fn no_params(p: &Value) -> bool {
+    p.as_object().is_none_or(|m| m.is_empty())
+}
+
+/// `{"comp": id}` and nothing else: Composition Settings opens on that comp instead of
+/// applying no settings to it.
+fn only_comp(p: &Value) -> Option<effectcraft_engine::project::ItemId> {
+    let m = p.as_object().filter(|m| m.len() == 1)?;
+    m.get("comp")?.as_u64().map(effectcraft_engine::project::ItemId)
+}
+
+/// Execute a UI or engine command by id.
+pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: Value) -> Result<Value, String> {
+    if matches!(id, "effects.copyPresetsFolderPath" | "mediaBrowser.copySourcePath") {
+        return frontend(app, ctx, id, params);
+    }
+    // Layer ▸ New ▸ Text (menu, shortcut, context menus) puts an insertion point in the centre of
+    // the comp, as After Effects does, so typing goes into Source Text rather than running
+    // shortcuts (#866). `engine.execute` keeps the headless default.
+    if id == "layer.newText" && no_params(&params) {
+        return run_engine(app, ctx, id, json!({"text": "", "edit": true}));
+    }
+    // A new folder (File ▸ New, its shortcut, the Project panel's button and context menu) opens
+    // with its name ready to type, as in After Effects (#1658). The command selects it.
+    // `engine.execute` keeps the headless default.
+    if id == "project.newFolder" && no_params(&params) {
+        let r = run_engine(app, ctx, id, params);
+        if r.is_ok() {
+            app.show_panel(PanelKind::Project);
+            crate::panels::project::begin_rename(app, ctx);
+        }
+        return r;
+    }
+    // The Project-panel focus redirects apply only while no text edit is open: creating a text
+    // layer leaves focus on Project while the insertion point lives in the comp, so during an
+    // edit these commands address the text context — redirected, Deselect All would clear a
+    // project selection the user is not looking at and silently swallow the edit's own end.
+    if no_params(&params) && app.ui.focused == PanelKind::Project && app.session.state.text_edit.is_none() {
+        match id {
+            "edit.duplicate" => return run_engine(app, ctx, "project.duplicate", json!({})),
+            "edit.selectAll" => {
+                let items: Vec<u64> = crate::panels::project::visible_rows(app)
+                    .into_iter()
+                    .filter(|(id, _)| app.ui.project_search.is_empty() || app.session.project.item(*id).is_some_and(|it| !it.is_folder()))
+                    .map(|(id, _)| id.0)
+                    .collect();
+                return run_engine(app, ctx, "project.select", json!({"items":items}));
+            }
+            "edit.deselectAll" => return run_engine(app, ctx, "project.select", json!({"items":[]})),
+            "edit.cut" | "edit.copy" | "edit.paste" | "edit.copyWithPropertyLinks" | "edit.copyWithRelativePropertyLinks" | "edit.copyExpressionOnly" => {
+                return Err("Project clipboard actions are not supported yet".into());
+            }
+            _ => {}
+        }
+    }
+    // Close follows panel focus too: with the Render Queue active, Cmd+W closes that panel and
+    // leaves the active composition open (it used to close the composition next to it).
+    if id == "file.close" && no_params(&params) && app.ui.focused == PanelKind::RenderQueue {
+        app.apply_dock(craft_ui::docking::Action::Close { panel: PanelKind::RenderQueue })?;
+        // The focus goes to a panel that is still there, so the next Close acts on the composition
+        // instead of on the queue that is gone.
+        let next = [PanelKind::Timeline, PanelKind::Composition, PanelKind::Project].into_iter().find(|p| panel_shown(app, *p)).unwrap_or(PanelKind::Project);
+        app.show_panel(next);
+        app.focus_panel(ctx, next);
+        // Activating a passive viewer emits OpenComp, which raises Timeline. Finish that routing
+        // before restoring the destination panel, including when they share the same tab group.
+        app.handle_events(ctx);
+        app.show_panel(next);
+        return Ok(Value::Null);
+    }
+    // Edit ▸ Paste with SVG markup on the system clipboard pastes it as a shape layer (After
+    // Effects 26.3). Copying in the app replaces the system clipboard with a note naming what
+    // was copied, so SVG there was copied after anything copied in the app.
+    if id == "edit.paste" && no_params(&params) && app.session.state.text_edit.is_none() {
+        let text = ctx.data_mut(|d| d.remove_temp::<String>(system_paste_id())).or_else(|| app.hooks.clipboard_text.as_ref().and_then(|f| f()));
+        if let Some(svg) = text.filter(|t| effectcraft_engine::vector::is_svg_text(t)) {
+            return run_engine(app, ctx, "edit.pasteSvg", json!({"svg": svg}));
+        }
+    }
+    // Clear follows panel focus, including the Edit menu and keyboard shortcut. An open text
+    // edit stands down: the user is working in a composition, and the Project-panel redirect
+    // would delete it without asking when nothing uses it (#2227).
+    if id == "edit.clear" && params.as_object().is_some_and(|p| p.is_empty()) && app.ui.focused == PanelKind::Project {
+        if app.session.state.text_edit.is_some() {
+            return Ok(Value::Null);
+        }
+        // Through `invoke`, so deleting items that compositions use still asks first (M3.16).
+        return invoke(app, ctx, "project.delete", json!({}));
+    }
+    if id == "edit.clear" && params.as_object().is_some_and(|p| p.is_empty()) && app.ui.focused == PanelKind::RenderQueue {
+        let selected = ctx.data(|d| d.get_temp::<(Vec<u64>, Option<u64>)>(egui::Id::unique("rq-ui"))).and_then(|(_, id)| id);
+        return match selected {
+            Some(item) => run_engine(app, ctx, "renderQueue.remove", json!({"item": item})),
+            None => Err("select a Render Queue item first".into()),
+        };
+    }
+    // Shift+Delete deletes the Project panel's selection without asking; it does nothing in the
+    // other panels.
+    if id == "project.deleteWithoutConfirmation" {
+        if app.ui.focused != PanelKind::Project {
+            return Ok(Value::Null);
+        }
+        return crate::panels::delete_items::delete_confirmed(app, ctx, json!({}));
+    }
+    let now = app.now();
+    // Closing a modified project asks to save it first; the command runs once answered.
+    if crate::panels::unsaved::guard(app, id, &params) {
+        return Ok(json!({"dialog": "unsavedChanges"}));
+    }
+    // Deleting Project items that compositions use asks first, as in After Effects.
+    if crate::panels::delete_items::guard(app, id, &params) {
+        return Ok(json!({"dialog": "deleteItems"}));
+    }
+    // J / K and Select All Keyframes act on what the Timeline shows (its revealed properties).
+    if matches!(id, "time.nextKey" | "time.previousKey" | "keys.selectAll")
+        && ["visible", "layers", "layer", "prop"].iter().all(|k| params.get(*k).is_none())
+        && let Some(c) = app.session.active_comp_arc()
+    {
+        let mut p = if params.is_object() { params.clone() } else { json!({}) };
+        p["visible"] = json!(crate::panels::timeline::visible_props(app, &c));
+        return run_engine(app, ctx, id, p);
+    }
+    // New Camera/Light and Camera/Light Settings without parameters open their dialogs.
+    if crate::panels::dialogs_3d::route(app, id, &params)? {
+        return Ok(Value::Null);
+    }
+    // New 3D Primitive without parameters opens its dialog.
+    if crate::panels::primitive_dialog::route(app, id, &params)? {
+        return Ok(Value::Null);
+    }
+    // Layer Settings on a solid, adjustment layer or null opens its settings dialog.
+    if crate::panels::dialogs::route_layer_settings(app, id, &params)? {
+        return Ok(Value::Null);
+    }
+    // Layer ▸ Layer Styles ▸ <style> from the menu adds the style and opens the dialog on it.
+    if crate::panels::layer_styles_dialog::route(app, id, &params)? {
+        return Ok(Value::Null);
+    }
+    // Shared docking: `window.dockAction`, craft-ui's `window.panel.*` commands, `ui.dock`,
+    // `ui.dock.reset` and `window.panelWindow`.
+    if let Some(result) = crate::dock_ui::route(app, ctx, id, &params) {
+        return result;
+    }
+    // Legacy per-panel / per-workspace ids (`window.panel.Project`, `window.workspace.default`).
+    if let Some(rest) = id.strip_prefix("window.panel.") {
+        return frontend(app, ctx, "window.panel", json!({"panel": rest}));
+    }
+    if let Some(ws) = id.strip_prefix("window.workspace.") {
+        if ws == "reset" {
+            return frontend(app, ctx, "window.resetWorkspace", json!({}));
+        }
+        return frontend(app, ctx, "window.workspace", json!({"name": ws}));
+    }
+    if let Some(t) = id.strip_prefix("tool.") {
+        // C cycles through the camera tools.
+        if t == "camera" {
+            let tools = [Tool::Orbit, Tool::PanCamera, Tool::Dolly];
+            let next = match tools.iter().position(|x| *x == app.ui.tool) {
+                Some(i) => tools[(i + 1) % tools.len()],
+                None => Tool::Orbit,
+            };
+            app.ui.tool = next;
+            return Ok(json!({"tool": next}));
+        }
+        // Slot shortcuts cycle through the slot's tools.
+        let slot = match t {
+            "shape" => Some(8),
+            "pen" => Some(9),
+            "type" => Some(10),
+            "brush" => Some(11),
+            "rotoBrush" => Some(14),
+            "puppet" => Some(15),
+            _ => None,
+        };
+        if let Some(si) = slot {
+            let tools: Vec<Tool> = match si {
+                11 => vec![Tool::Brush, Tool::Clone, Tool::Eraser],
+                _ => crate::state::Tool::SLOTS[si].to_vec(),
+            };
+            let cur = tools.iter().position(|x| *x == app.ui.tool);
+            let next = match cur {
+                Some(i) => tools[(i + 1) % tools.len()],
+                None => app.ui.slot_tools.get(si).copied().filter(|x| tools.contains(x)).unwrap_or(tools[0]),
+            };
+            app.ui.tool = next;
+            if si < app.ui.slot_tools.len() && si != 11 {
+                app.ui.slot_tools[si] = next;
+            }
+            return Ok(json!({"tool": next}));
+        }
+        let tool = Tool::from_name(t).ok_or_else(|| format!("unknown tool `{t}`"))?;
+        app.ui.tool = tool;
+        return Ok(json!({"tool": tool}));
+    }
+    if let Some(dir) = id.strip_prefix("viewer.nudge.") {
+        return nudge(app, ctx, dir);
+    }
+    if let Some(k) = id.strip_prefix("timeline.reveal.") {
+        if k == "animated" {
+            return run_engine(app, ctx, "anim.reveal", json!({"kind": "keyframes"}));
+        }
+        reveal(app, k, now, false);
+        return Ok(Value::Null);
+    }
+    if let Some(k) = id.strip_prefix("timeline.keyAt.") {
+        let r = run_engine(app, ctx, "keys.toggleTransform", json!({"prop": k}))?;
+        reveal_keyed(app, &r, k);
+        return Ok(r);
+    }
+    if let Some(k) = id.strip_prefix("timeline.revealAdd.") {
+        reveal(app, k, now, true);
+        return Ok(json!({"revealed": app.ui.timeline.reveal}));
+    }
+    // U reveals keyframed properties; UU (pressed twice quickly) all modified properties; U
+    // again later hides them.
+    if id == "anim.reveal" && params.get("kind").and_then(Value::as_str) == Some("keyframes") {
+        let last = app.last_reveal.take();
+        app.last_reveal = Some(("keyframes".into(), now));
+        match last {
+            Some((k, t)) if k == "keyframes" && now - t < 0.6 => {
+                return run_engine(app, ctx, "anim.reveal", json!({"kind": "modified"}));
+            }
+            Some((k, _)) if k == "keyframes" && app.ui.timeline.reveal == ["props"] => {
+                let targets = reveal_targets(app);
+                app.ui.timeline.apply_reveal(&targets, vec![]);
+                return Ok(json!({"revealed": 0}));
+            }
+            _ => {}
+        }
+    }
+    // A UI-only command (not in the engine's menus), so `frontend` gets it from here.
+    if id == "window.maximizeApp" {
+        return frontend(app, ctx, id, params);
+    }
+    // Docking: {panel, anchor, zone: center|left|right|top|bottom}, {panel, rect?}, {panel?}.
+    if let Some(op) = id.strip_prefix("window.").filter(|o| matches!(*o, "maximizePanel" | "dockPanel" | "floatPanel" | "closePanel")) {
+        let panel_of = |k: &str| params.get(k).and_then(Value::as_str).map(|s| PanelKind::from_name(s).ok_or(format!("unknown panel `{s}`")));
+        match op {
+            "maximizePanel" => {
+                let p = match panel_of("panel") {
+                    Some(p) => p?,
+                    None => app.panel_at(ctx.pointer_hover_pos()),
+                };
+                app.toggle_maximize(p);
+                return Ok(json!({"maximized": app.ui.maximized}));
+            }
+            "closePanel" => {
+                let p = panel_of("panel").ok_or("closePanel: need `panel`")??;
+                if app.ui.dock.is_open(p) {
+                    app.apply_dock(craft_ui::docking::Action::Close { panel: p })?;
+                }
+                return Ok(Value::Null);
+            }
+            "floatPanel" => {
+                let p = panel_of("panel").ok_or("floatPanel: need `panel`")??;
+                let r = match params.get("rect") {
+                    Some(value) => serde_json::from_value::<[f32; 4]>(value.clone()).map_err(|_| "rect must contain four finite numbers")?,
+                    None => crate::dock_ui::default_float_rect(ctx.content_rect()),
+                };
+                app.apply_dock(craft_ui::docking::Action::Float { panel: p, rect: r }).map_err(|e| format!("can't undock {}: {e}", p.title()))?;
+                return Ok(Value::Null);
+            }
+            _ => {
+                // craft-ui's `window.panel.dock`: zones center/tab, left/right/top/bottom (a split
+                // beside the anchor), above/below; without an anchor a side zone docks along that
+                // edge of the whole workspace.
+                let p = panel_of("panel").ok_or("dockPanel: need `panel`")??;
+                let mut command = json!({"command": "window.panel.dock", "panel": p});
+                if let Some(anchor) = panel_of("anchor") {
+                    command["anchor"] = json!(anchor?);
+                    command["zone"] = json!("center");
+                }
+                if let Some(zone) = params.get("zone") {
+                    let zone = zone.as_str().ok_or("zone: center|tab|left|right|top|bottom|above|below")?.to_ascii_lowercase();
+                    if command.get("anchor").is_some() || zone != "center" {
+                        command["zone"] = json!(zone);
+                    }
+                }
+                if let Some(before) = panel_of("before") {
+                    command["before"] = json!(before?);
+                }
+                let command: craft_ui::docking::DockCommand<PanelKind> =
+                    serde_json::from_value(command).map_err(|e| format!("dockPanel: zone: center|tab|left|right|top|bottom|above|below ({e})"))?;
+                app.run_dock_command(ctx, command).map_err(|e| format!("can't dock {}: {e}", p.title()))?;
+                app.show_panel(p);
+                return Ok(Value::Null);
+            }
+        }
+    }
+    if id == "markers.dialog" {
+        // The Composition/Layer Marker dialog (double-click a marker): {layer?, index}.
+        let index = params.get("index").and_then(Value::as_u64).ok_or("markers.dialog: need `index`")? as usize;
+        let layer = params.get("layer").and_then(Value::as_u64);
+        crate::panels::markers_ui::open_dialog(app, crate::panels::markers_ui::MarkerRef { layer, index })?;
+        return Ok(json!({"dialog": id}));
+    }
+
+    if id == "view.theme.toggle" {
+        app.cycle_appearance(ctx);
+        return Ok(json!({"appearanceMode": app.session.prefs.appearance.appearance_mode}));
+    }
+    if let Some(th) = id.strip_prefix("view.theme.") {
+        let k = crate::theme::ThemeKind::from_name(th).ok_or("unknown theme")?;
+        app.set_theme(ctx, k);
+        return Ok(Value::Null);
+    }
+    let timing = |app: &mut EffectcraftApp, op: &str| app.session.execute("layer.timing", json!({"op": op})).map_err(|e| e.to_string());
+    match id {
+        "playback.ramPreview" => {
+            app.toggle_play_with(now, effectcraft_engine::preview::PreviewShortcut::Numpad0);
+            return Ok(json!({"playing": app.playback.playing}));
+        }
+        "playback.preview.shiftSpacebar" | "playback.preview.shiftNumpad0" | "playback.preview.altNumpad0" => {
+            let sc = effectcraft_engine::preview::PreviewShortcut::parse(id.trim_start_matches("playback.preview.")).ok_or("unknown preview shortcut")?;
+            app.toggle_play_with(now, sc);
+            return Ok(json!({"playing": app.playback.playing}));
+        }
+        "playback.stop" => {
+            app.stop();
+            return Ok(Value::Null);
+        }
+        // The focused Layer panel has its own magnification; otherwise the Composition viewer.
+        "view.fit" if app.ui.focused == PanelKind::Layer => {
+            app.ui.layer_zoom = None;
+            app.ui.layer_pan = [0.0, 0.0];
+            return Ok(Value::Null);
+        }
+        "view.fit" => {
+            app.ui.viewer.zoom = None;
+            app.ui.viewer.fit_up_to_100 = false;
+            app.ui.viewer.pan = [0.0, 0.0];
+            return Ok(Value::Null);
+        }
+        "timeline.scrollToTime" => app.ui.timeline.scroll_to = Some(crate::state::ScrollTo::Time),
+        "timeline.scrollToLayer" => app.ui.timeline.scroll_to = Some(crate::state::ScrollTo::Layer),
+        "timeline.parentColumn" => {
+            let on = !crate::panels::timeline::column_visible(&app.ui.timeline, "parent");
+            crate::panels::timeline::set_column(&mut app.ui.timeline, "parent", on)?;
+            return Ok(json!({"parent": on}));
+        }
+        "view.fitUpTo100" => {
+            app.ui.viewer.zoom = None;
+            app.ui.viewer.fit_up_to_100 = true;
+            app.ui.viewer.pan = [0.0, 0.0];
+            return Ok(Value::Null);
+        }
+        // Shift+, / Shift+.: the previous / next open composition (the viewer's tabs).
+        "view.nextItem" | "view.previousItem" => {
+            let open = app.session.state.open_comps.clone();
+            let Some(i) = app.session.state.active_comp.and_then(|c| open.iter().position(|o| *o == c)) else { return Ok(Value::Null) };
+            let step = if id == "view.nextItem" { 1 } else { open.len().saturating_sub(1) };
+            let Some(next) = open.get((i + step) % open.len().max(1)).copied().filter(|n| Some(*n) != app.session.state.active_comp) else {
+                return Ok(Value::Null);
+            };
+            return run_engine(app, ctx, "comp.open", json!({"comp": next.0}));
+        }
+        // \\: between the Composition viewer and the Timeline.
+        "window.toggleCompTimeline" => {
+            let to = if app.ui.focused == PanelKind::Timeline { crate::panels::viewers::active_panel(app) } else { PanelKind::Timeline };
+            app.show_panel(to);
+            return Ok(json!({"focused": to.id()}));
+        }
+        // Alt+Shift+, / Alt+Shift+.: the previous / next tab of the focused panel's group.
+        "window.nextPanel" | "window.previousPanel" => {
+            let focused = app.ui.focused;
+            let group = app.ui.dock.group_of(focused);
+            let Some(i) = group.iter().position(|p| *p == focused) else { return Ok(Value::Null) };
+            let step = if id == "window.nextPanel" { 1 } else { group.len().saturating_sub(1) };
+            if let Some(next) = group.get((i + step) % group.len().max(1)).copied() {
+                app.show_panel(next);
+            }
+            return Ok(json!({"focused": app.ui.focused.id()}));
+        }
+        // Ctrl+Shift+W: with a viewer or the Timeline active, every open composition closes;
+        // any other panel closes itself.
+        "window.closeAll" => {
+            let focused = app.ui.focused;
+            if matches!(focused, PanelKind::Composition | PanelKind::Timeline | PanelKind::Viewer(_)) {
+                for c in app.session.state.open_comps.clone() {
+                    run_engine(app, ctx, "comp.close", json!({"comp": c.0}))?;
+                }
+            } else {
+                app.close_panel(focused);
+            }
+            return Ok(Value::Null);
+        }
+        "view.actualSize" if app.ui.focused == PanelKind::Layer => {
+            app.ui.layer_zoom = Some(1.0 / ctx.pixels_per_point());
+            app.ui.layer_pan = [0.0, 0.0];
+            return Ok(Value::Null);
+        }
+        "view.actualSize" => {
+            app.ui.viewer.zoom = Some(1.0 / ctx.pixels_per_point());
+            app.ui.viewer.pan = [0.0, 0.0];
+            return Ok(Value::Null);
+        }
+        "view.safeMargins" => app.ui.viewer.safe_margins = !app.ui.viewer.safe_margins,
+        "view.transparencyGrid" => app.ui.viewer.transparency_grid = !app.ui.viewer.transparency_grid,
+        "view.fastPreviews" => {
+            // With a mode: Fast Previews ▸ Off / Adaptive Resolution / Draft / Fast Draft /
+            // Wireframe; without: toggle Draft quality (Settings ▸ Previews).
+            if params.get("mode").is_some() {
+                return run_engine(app, ctx, "view.fastPreviewMode", params);
+            }
+            let on = !app.ui.viewer.fast_preview;
+            app.set_pref("previews.fastPreviews", json!(on))?;
+            app.ui.viewer.fast_preview = on;
+        }
+        "timeline.zoomIn" | "timeline.zoomOut" => {
+            let k = if id == "timeline.zoomIn" { crate::panels::timeline::ZOOM_STEP } else { 1.0 / crate::panels::timeline::ZOOM_STEP };
+            crate::panels::timeline::zoom(app, ctx, k);
+            return Ok(Value::Null);
+        }
+        "timeline.zoomFit" => crate::panels::timeline::toggle_fit_zoom(app, ctx),
+        "timeline.zoomFrameToggle" => crate::panels::timeline::toggle_frame_zoom(app, ctx),
+        "timeline.column" => {
+            let col = params.get("column").and_then(Value::as_str).ok_or("timeline.column: need `column`")?;
+            let on = params.get("visible").and_then(Value::as_bool).unwrap_or(!crate::panels::timeline::column_visible(&app.ui.timeline, col));
+            crate::panels::timeline::set_column(&mut app.ui.timeline, col, on)?;
+            let shown: Vec<&str> =
+                crate::panels::timeline::COLUMNS.iter().map(|c| c.0).filter(|c| crate::panels::timeline::column_visible(&app.ui.timeline, c)).collect();
+            return Ok(json!({"columns": shown}));
+        }
+        "timeline.sourceName" => {
+            let tl = &mut app.ui.timeline;
+            tl.source_name = params.get("value").and_then(Value::as_bool).unwrap_or(!tl.source_name);
+            return Ok(json!({"sourceName": tl.source_name}));
+        }
+        "flowchart.options" | "flowchart.graph" => return crate::panels::flowchart::command(app, id, &params),
+        "timeline.search" => {
+            app.ui.timeline.search = params.get("query").and_then(Value::as_str).unwrap_or_default().to_string();
+            app.show_panel(PanelKind::Timeline);
+        }
+        "timeline.graphEditor" => app.ui.timeline.graph_editor = !app.ui.timeline.graph_editor,
+        "timeline.switchesModes" => app.ui.timeline.show_modes = !app.ui.timeline.show_modes,
+        "timeline.collapseAll" => {
+            app.ui.timeline.open_layers.clear();
+            app.ui.timeline.open_groups.clear();
+            app.ui.timeline.reveal.clear();
+            app.ui.timeline.layer_reveal.clear();
+        }
+        // Ctrl+`: twirl the selected layers open (all closed ones) or closed (all open). From a
+        // reveal shortcut's view it opens their full property trees.
+        "timeline.twirlSelected" => {
+            let sel: Vec<u64> = app.session.state.selected_layers.iter().map(|l| l.0).collect();
+            let tl = &mut app.ui.timeline;
+            let revealing = sel.iter().any(|l| tl.layer_reveal.contains_key(l));
+            tl.reveal.clear();
+            for l in &sel {
+                tl.layer_reveal.remove(l);
+            }
+            if !revealing && sel.iter().all(|l| tl.open_layers.contains(l)) {
+                for l in &sel {
+                    tl.open_layers.remove(l);
+                }
+            } else {
+                tl.open_layers.extend(sel);
+            }
+        }
+        "timeline.workAreaBegin" => return app.session.execute("comp.workArea", json!({"set": "begin"})).map_err(|e| e.to_string()),
+        "timeline.workAreaEnd" => return app.session.execute("comp.workArea", json!({"set": "end"})).map_err(|e| e.to_string()),
+        "timeline.moveInToTime" => return timing(app, "moveInToTime"),
+        "timeline.moveOutToTime" => return timing(app, "moveOutToTime"),
+        "timeline.trimInToTime" => return timing(app, "trimInToTime"),
+        "timeline.trimOutToTime" => return timing(app, "trimOutToTime"),
+        "app.home" => app.ui.start_screen = !app.ui.start_screen,
+        "app.newComp" | "comp.new" if no_params(&params) => crate::panels::dialogs::open_new_comp(app),
+        "app.compSettings" | "comp.settings" if no_params(&params) => crate::panels::dialogs::open_comp_settings(app)?,
+        "app.compSettings" | "comp.settings" if only_comp(&params).is_some() => {
+            crate::panels::dialogs::open_comp_settings_for(app, only_comp(&params).ok_or("missing `comp`")?)?
+        }
+        "app.solidSettings" | "layer.newSolid" if no_params(&params) => crate::panels::dialogs::open_new_solid(app)?,
+        "keys.velocity" if no_params(&params) => crate::panels::key_dialogs::open_velocity(app)?,
+        "keys.interpolation" if no_params(&params) => crate::panels::key_dialogs::open_interpolation(app)?,
+        "layer.timeStretch" if no_params(&params) => crate::panels::key_dialogs::open_time_stretch(app)?,
+        _ => {
+            if id == "renderQueue.render" && params.get("wait").is_none() {
+                // The UI renders in the background; the panel shows progress.
+                let mut p = params.clone();
+                if let Some(m) = p.as_object_mut() {
+                    m.insert("wait".into(), json!(false));
+                } else {
+                    p = json!({"wait": false});
+                }
+                app.show_panel(PanelKind::RenderQueue);
+                return app.session.execute(id, p).map_err(|e| e.to_string());
+            }
+            if id == "renderQueue.add" {
+                let r = app.session.execute(id, params).map_err(|e| e.to_string());
+                match &r {
+                    Ok(_) => app.show_panel(PanelKind::RenderQueue),
+                    Err(e) => app.ui.status = e.clone(),
+                }
+                return r;
+            }
+            if let Some(r) = file_dialog(app, id, &params) {
+                return r;
+            }
+            if id == "layer.precompose" && params.get("name").is_none() {
+                crate::panels::precomp::open(app, &params)?;
+                return Ok(json!({"dialog": id}));
+            }
+            if crate::panels::dialogs::open_form(app, id, &params) {
+                return Ok(json!({"dialog": id}));
+            }
+            if id == "renderQueue.render" && params.get("wait").is_none() {
+                // The UI renders in the background; the panel shows progress.
+                let mut p = params.clone();
+                if let Some(m) = p.as_object_mut() {
+                    m.insert("wait".into(), json!(false));
+                } else {
+                    p = json!({"wait": false});
+                }
+                app.show_panel(PanelKind::RenderQueue);
+                return app.session.execute(id, p).map_err(|e| e.to_string());
+            }
+            if id == "renderQueue.add" {
+                let r = app.session.execute(id, params).map_err(|e| e.to_string());
+                match &r {
+                    Ok(_) => app.show_panel(PanelKind::RenderQueue),
+                    Err(e) => app.ui.status = e.clone(),
+                }
+                return r;
+            }
+            // An effect added to a layer (Effect menu, Last Effect, dropped on a layer) brings
+            // up Effect Controls on that layer, as in After Effects.
+            if matches!(id, "effect.apply" | "effect.applyLast") {
+                let r = run_engine(app, ctx, id, params.clone());
+                if let Ok(applied) = &r {
+                    crate::panels::effect_controls::reveal_applied(app, &params);
+                    crate::panels::effect_controls::choose_files_after_apply(app, applied);
+                }
+                return r;
+            }
+            // Enabling time remapping twirls its layers open on Time Remap and its two keys.
+            if id == "layer.enableTimeRemap" {
+                let r = run_engine(app, ctx, id, params.clone());
+                if r.as_ref().is_ok_and(|on| on.as_bool() == Some(true)) {
+                    reveal_time_remap(app, &params);
+                }
+                return r;
+            }
+            if id == "layer.rename" && params.get("name").is_none() {
+                crate::panels::timeline::begin_rename(app, ctx);
+                return Ok(Value::Null);
+            }
+            return run_engine(app, ctx, id, params);
+        }
+    }
+    Ok(Value::Null)
+}
diff --git a/crates/ui-egui/src/menus/shortcuts.rs b/crates/ui-egui/src/menus/shortcuts.rs
new file mode 100644
index 000000000..4ef1e64fb
--- /dev/null
+++ b/crates/ui-egui/src/menus/shortcuts.rs
@@ -0,0 +1,463 @@
+use super::frontend::run_engine;
+use super::invoke::invoke;
+use super::{EffectcraftApp, PanelKind, Value, json};
+use crate::state::Tool;
+
+/// Shortcut text in this OS's notation (`⇧⌘K` on macOS, `Ctrl+Shift+K` elsewhere).
+pub fn shortcut_text(s: &str) -> String {
+    if cfg!(target_os = "macos") {
+        let mut out = String::new();
+        let parts: Vec<&str> = match s.strip_suffix("++") {
+            Some(head) => vec![head, "+"],
+            None => s.split('+').collect(),
+        };
+        let (mods, key) = parts.split_at(parts.len().saturating_sub(1));
+        for m in mods {
+            out.push_str(match *m {
+                "Ctrl" => "⌃",
+                "Alt" => "⌥",
+                "Shift" => "⇧",
+                "Cmd" => "⌘",
+                x => x,
+            });
+        }
+        out.push_str(match key.first().copied().unwrap_or("") {
+            "Space" => "Space",
+            "Escape" => "Esc",
+            "Home" => "↖",
+            k => k,
+        });
+        out
+    } else {
+        s.replace("Cmd", "Ctrl")
+    }
+}
+
+/// Parse "Cmd+Shift+K" into modifiers + key.
+pub fn parse_shortcut(s: &str) -> Option<(egui::Modifiers, egui::Key)> {
+    let mut m = egui::Modifiers::NONE;
+    let mut key = None;
+    // The plus key itself is written `+` or `Cmd++`.
+    let (head, plus) = match s.strip_suffix("++") {
+        Some(h) => (h, true),
+        None if s == "+" => ("", true),
+        None => (s, false),
+    };
+    let mut parts: Vec<&str> = if head.is_empty() { vec![] } else { head.split('+').collect() };
+    if plus {
+        parts.push("+");
+    }
+    for p in parts {
+        match p {
+            "Cmd" => {
+                m.command = true;
+                m.mac_cmd = cfg!(target_os = "macos");
+                if !cfg!(target_os = "macos") {
+                    m.ctrl = true;
+                }
+            }
+            "Physical" => {}
+            "Shift" => m.shift = true,
+            "Alt" => m.alt = true,
+            "Ctrl" => m.ctrl = true,
+            k => {
+                key = match k {
+                    ";" => Some(egui::Key::Semicolon),
+                    "'" => Some(egui::Key::Quote),
+                    "," => Some(egui::Key::Comma),
+                    "." => Some(egui::Key::Period),
+                    "/" => Some(egui::Key::Slash),
+                    "\\" => Some(egui::Key::Backslash),
+                    "=" => Some(egui::Key::Equals),
+                    "-" => Some(egui::Key::Minus),
+                    "`" => Some(egui::Key::Backtick),
+                    "[" => Some(egui::Key::OpenBracket),
+                    "]" => Some(egui::Key::CloseBracket),
+                    "Num0" => Some(egui::Key::Num0),
+                    "Num*" => None,
+                    _ => egui::Key::from_name(k),
+                }
+            }
+        }
+    }
+    key.map(|k| (m, k))
+}
+
+/// The key some keyboards report for a shifted punctuation key (`Shift+=` arrives as `+`).
+fn shifted_alias(k: egui::Key) -> Option<egui::Key> {
+    use egui::Key::*;
+    Some(match k {
+        Equals => Plus,
+        Semicolon => Colon,
+        OpenBracket => OpenCurlyBracket,
+        CloseBracket => CloseCurlyBracket,
+        Slash => Questionmark,
+        Backslash => Pipe,
+        _ => return None,
+    })
+}
+
+/// A key binding: modifiers, key, command id and bound params.
+pub type Binding = (egui::Modifiers, egui::Key, String, Value);
+
+/// All bindings of the active keyboard shortcut preset, most modifiers first.
+pub fn bindings(session: &effectcraft_engine::Session) -> Vec<Binding> {
+    let mut v: Vec<Binding> = Vec::new();
+    for (sc, b) in session.shortcuts().bindings() {
+        if sc.starts_with("Physical+") {
+            continue;
+        }
+        // Off macOS `Cmd` is Ctrl, so a custom Ctrl+Cmd shortcut would
+        // steal the plain Cmd one: such macOS-only shortcuts aren't bound there.
+        if !cfg!(target_os = "macos") && sc.split('+').any(|p| p == "Ctrl") && sc.split('+').any(|p| p == "Cmd") {
+            continue;
+        }
+        if let Some((m, k)) = parse_shortcut(sc) {
+            if m.shift
+                && let Some(alias) = shifted_alias(k)
+            {
+                v.push((m, alias, b.command.clone(), b.params.clone()));
+            }
+            v.push((m, k, b.command.clone(), b.params.clone()));
+        }
+    }
+    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
+}
+
+fn mods_match(want: egui::Modifiers, got: egui::Modifiers) -> bool {
+    want.command == got.command && want.shift == got.shift && want.alt == got.alt && (want.ctrl == got.ctrl || got.command && cfg!(not(target_os = "macos")))
+}
+
+/// Whether the `key`+`mods` chord is the current binding of `command` in the active preset
+/// (so callers that must match a shortcut themselves — like the viewer's text editor, which
+/// holds the keyboard while the shortcut dispatcher is skipped — follow rebinds).
+/// `Physical+`-only bindings never match here, exactly as for the app-wide dispatcher.
+pub fn chord_matches(session: &effectcraft_engine::Session, command: &str, key: egui::Key, mods: egui::Modifiers) -> bool {
+    bindings(session).into_iter().any(|(m, k, id, _)| id == command && k == key && mods_match(m, mods))
+}
+
+/// Whether a Deselect All or Duplicate chord matched by [`chord_matches`] may run while a text
+/// editor holds the keyboard. Chords carrying Cmd/Ctrl/Alt are command chords (the editor treats them as
+/// such for undo and the rest), and function keys never type, so those forward from the editor;
+/// a chord that could instead produce a character — a bare or Shift-only letter, digit or
+/// punctuation key, as from a pathological bare-letter rebinding — stays with the editor so
+/// typing keeps working, the same invariant the app-wide dispatcher honors by skipping
+/// focused text fields.
+pub fn forwardable_during_text_edit(mods: egui::Modifiers, key: egui::Key) -> bool {
+    mods.command || mods.ctrl || mods.alt || (egui::Key::F1..=egui::Key::F35).contains(&key)
+}
+
+/// Set (egui temp data) from a plain Spacebar press until its release while a tap would still
+/// run the Spacebar shortcut.
+/// The system clipboard's text of this frame's paste event, for the Edit ▸ Paste it runs.
+pub(super) fn system_paste_id() -> egui::Id {
+    egui::Id::unique("menus-system-paste")
+}
+
+/// The temp-data id of the flag set by a plain Space press and taken on its release, so a tap
+/// runs the Space shortcut while holding Space stays the Hand tool.
+fn space_tap_id() -> egui::Id {
+    egui::Id::unique("spacebar-tap")
+}
+
+/// The modifiers held when this frame's input began: the state the last pass ended with, if it
+/// ran this (egui keeps only the state after the frame's events). Records this pass's state.
+pub(super) fn modifiers_at_start(ctx: &egui::Context) -> Option<egui::Modifiers> {
+    let id = egui::Id::unique("shortcut-modifiers");
+    let pass = ctx.cumulative_pass_nr();
+    let now = ctx.input(|i| i.modifiers);
+    ctx.data_mut(|d| {
+        let last = d.get_temp::<(u64, egui::Modifiers, Option<egui::Modifiers>)>(id);
+        if let Some((p, _, start)) = last
+            && p == pass
+        {
+            return start;
+        }
+        let start = last.and_then(|(p, m, _)| (p.checked_add(1) == Some(pass)).then_some(m));
+        d.insert_temp(id, (pass, now, start));
+        start
+    })
+}
+
+/// The shortcut contexts active now (`effectcraft_engine::shortcuts::CONTEXT_SCOPES`): text
+/// being edited in the viewer, a paint tool or a camera tool active, a mask selected.
+pub fn active_contexts(app: &EffectcraftApp) -> Vec<&'static str> {
+    let mut out = vec![];
+    if app.session.state.text_edit.is_some() {
+        out.push("TextEditing");
+    }
+    match app.ui.tool {
+        Tool::Brush | Tool::Clone | Tool::Eraser => out.push("Paint"),
+        Tool::Orbit | Tool::PanCamera | Tool::Dolly => out.push("Camera"),
+        _ => {}
+    }
+    if app.session.selected_mask().is_some() {
+        out.push("Mask");
+    }
+    out
+}
+
+/// Only Shift held (Shift+Delete, not Ctrl/Alt+Shift+Delete).
+fn only_shift(m: egui::Modifiers) -> bool {
+    m.shift && !m.alt && !m.ctrl && !m.command && !m.mac_cmd
+}
+
+/// Dispatch keyboard shortcuts (skipped while typing in a text field).
+pub fn handle_shortcuts(app: &mut EffectcraftApp, ctx: &egui::Context) {
+    handle_shortcuts_impl(app, ctx, false);
+}
+
+/// Tab can acquire widget focus while the current frame is drawn. Dispatch its application
+/// binding only afterward, and only when no widget owned focus before or after layout.
+pub fn handle_tab_shortcut(app: &mut EffectcraftApp, ctx: &egui::Context) {
+    if ctx.input(|i| i.key_pressed(egui::Key::Tab)) {
+        handle_shortcuts_impl(app, ctx, true);
+    }
+}
+
+/// Escape with a dialog open: close the popup/picker first, else cancel the dialog.
+fn escape_dialog(app: &mut EffectcraftApp, ctx: &egui::Context) {
+    // A popup or colour picker takes Escape first (the picker goes back to its original colour).
+    if crate::panels::shortcut_editor::recording(app)
+        || crate::panels::shortcut_editor::confirming(app)
+        || egui::Popup::is_any_open(ctx)
+        || crate::color_picker::open_recently(ctx)
+    {
+        return;
+    }
+    ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape));
+    if app.dialog == Some(crate::Dialog::LayerStyles) {
+        crate::panels::layer_styles_dialog::finish(app, false);
+    } else if app.dialog == Some(crate::Dialog::GradientEditor) {
+        // Escape is Cancel: the preview rolls back.
+        crate::panels::gradient_editor::finish(app, false, ctx);
+    } else if app.dialog == Some(crate::Dialog::Info) {
+        crate::panels::forms::close_info(app);
+    } else {
+        if app.dialog == Some(crate::Dialog::Settings)
+            && let Some(p) = app.dialog_state.prefs_snapshot.take()
+        {
+            app.session.prefs = p;
+            app.session.prefs_changed();
+        }
+        if app.dialog == Some(crate::Dialog::UnsavedChanges) {
+            app.dialog_state.unsaved.command = None;
+        }
+        // Escape is Cancel: a Preview that edited the project rolls back.
+        crate::panels::live_preview::cancel(app);
+        app.dialog = None;
+    }
+}
+
+/// Escape with a dialog open: it is Cancel. Escape while recording a shortcut cancels the
+/// recording, not the editor; so does Escape in its Delete Preset prompt.
+fn cancel_dialog(app: &mut EffectcraftApp, ctx: &egui::Context) {
+    if crate::panels::shortcut_editor::recording(app) || crate::panels::shortcut_editor::confirming(app) {
+        return;
+    }
+    if app.dialog == Some(crate::Dialog::Info) {
+        crate::panels::forms::close_info(app);
+        return;
+    }
+    if app.dialog == Some(crate::Dialog::GradientEditor) {
+        crate::panels::gradient_editor::finish(app, false, ctx);
+        return;
+    }
+    // Escape in Settings is Cancel: restore the settings from when it opened.
+    if app.dialog == Some(crate::Dialog::Settings)
+        && let Some(p) = app.dialog_state.prefs_snapshot.take()
+    {
+        app.session.prefs = p;
+        app.session.prefs_changed();
+    }
+    crate::panels::live_preview::cancel(app);
+    app.dialog = None;
+}
+
+type KeyEvent = (egui::Key, egui::Modifiers, bool, Option<egui::Key>);
+
+/// The frame's key presses, with clipboard events mapped back to Ctrl+C / X / V.
+fn collect_key_events(ctx: &egui::Context, start: Option<egui::Modifiers>, clipboard: bool, project: bool) -> Vec<KeyEvent> {
+    ctx.input(|i| {
+        // The windowing layer turns Ctrl+C / Ctrl+X / Ctrl+V into clipboard events instead of
+        // key presses: map them back to the keys (with the modifiers held) so Edit ▸ Copy, Cut,
+        // Paste and their variants (Ctrl+Alt+C…) run. Clipboard events carry no modifiers and
+        // `i.modifiers` is the state after all of the frame's events, so each is read with the
+        // modifiers where it is in the stream: walk the events from the frame's starting state.
+        // `None` when that isn't known.
+        let changed = i.events.iter().any(|e| matches!(e, egui::Event::ModifiersChanged(_) | egui::Event::WindowFocused(false)));
+        let mut at = if changed { start } else { Some(i.modifiers) };
+        let held = |at: Option<egui::Modifiers>| at.filter(|m| m.command).unwrap_or(egui::Modifiers::COMMAND);
+        let mut out = Vec::new();
+        for e in &i.events {
+            match e {
+                egui::Event::ModifiersChanged(m) => at = Some(*m),
+                // egui forgets the modifiers held when the window loses focus.
+                egui::Event::WindowFocused(false) => at = Some(egui::Modifiers::NONE),
+                egui::Event::Key { key, physical_key, pressed: true, modifiers, repeat, .. }
+                    if !*repeat
+                        || matches!(
+                            key,
+                            egui::Key::PageUp | egui::Key::PageDown | egui::Key::ArrowLeft | egui::Key::ArrowRight | egui::Key::ArrowUp | egui::Key::ArrowDown
+                        ) =>
+                {
+                    out.push((*key, *modifiers, true, *physical_key));
+                }
+                egui::Event::Key { key: egui::Key::Space, pressed: false, .. } => out.push((egui::Key::Space, egui::Modifiers::NONE, false, None)),
+                egui::Event::Copy if clipboard => out.push((egui::Key::C, held(at), true, None)),
+                // On Windows, Shift+Delete is the old Cut key and arrives as Cut too. The Project
+                // panel has no clipboard: there a Cut with only Shift held is Shift+Delete (Delete
+                // Project Items Without Confirmation). Never when the modifiers aren't known.
+                egui::Event::Cut if clipboard && project && at.is_some_and(only_shift) => {
+                    out.push((egui::Key::Delete, egui::Modifiers::SHIFT, true, None));
+                }
+                egui::Event::Cut if clipboard => out.push((egui::Key::X, held(at), true, None)),
+                egui::Event::Paste(_) if clipboard => out.push((egui::Key::V, held(at), true, None)),
+                _ => {}
+            }
+        }
+        out
+    })
+}
+
+/// Numpad * (or `*` typed with Shift+8): Add Marker (#275). egui has no key for it, so it
+/// comes as text.
+fn numpad_star_marker(app: &mut EffectcraftApp, ctx: &egui::Context) {
+    if !ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::Text(t) if t == "*"))) {
+        return;
+    }
+    let bound = app.session.shortcuts().bindings().into_iter().find(|(k, _)| *k == "Num*").map(|(_, b)| (b.command.clone(), b.params.clone()));
+    // As in After Effects, it marks the selected layers; only with none selected does it add
+    // a composition marker (#976).
+    let bound =
+        bound.map(
+            |(id, params)| {
+                if id == "comp.addMarker" && !app.session.state.selected_layers.is_empty() { ("layer.addMarker".to_owned(), params) } else { (id, params) }
+            },
+        );
+    if let Some((id, params)) = bound
+        && let Err(e) = invoke(app, ctx, &id, if params.is_null() { json!({}) } else { params })
+    {
+        app.ui.status = e;
+    }
+}
+
+/// Panels that handle Enter themselves (rename, apply, open the row).
+fn panel_owns_enter(kind: PanelKind) -> bool {
+    matches!(kind, PanelKind::Project | PanelKind::EffectsPresets | PanelKind::RenderQueue)
+}
+
+fn handle_shortcuts_impl(app: &mut EffectcraftApp, ctx: &egui::Context, tab_only: bool) {
+    let start = modifiers_at_start(ctx);
+    if !tab_only && app.dialog.is_some() && ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
+        escape_dialog(app, ctx);
+        return;
+    }
+    // A mouse button down while Spacebar is held belongs to the Hand tool: its release won't
+    // preview.
+    if ctx.input(|i| i.pointer.any_down()) || ctx.egui_wants_keyboard_input() {
+        ctx.data_mut(|d| d.remove::<bool>(space_tap_id()));
+    }
+    // While a menu or popup list is open, keys go to it, not to the app (Space must not start a
+    // preview behind the menu, #279).
+    if ctx.egui_wants_keyboard_input() || crate::widgets::any_menu_open(ctx) {
+        return;
+    }
+    // Text editing in the viewer takes the clipboard events itself.
+    let clipboard = app.session.state.text_edit.is_none();
+    let project = app.ui.focused == PanelKind::Project;
+    // The paste event's text: Edit ▸ Paste pastes SVG markup as a shape layer.
+    let pasted =
+        if clipboard { ctx.input(|i| i.events.iter().rev().find_map(|e| if let egui::Event::Paste(t) = e { Some(t.clone()) } else { None })) } else { None };
+    let mut events = collect_key_events(ctx, start, clipboard, project);
+    events.retain(|(key, _, _, _)| (*key == egui::Key::Tab) == tab_only);
+    if !tab_only && clipboard && app.dialog.is_none() {
+        numpad_star_marker(app, ctx);
+    }
+    if events.is_empty() {
+        return;
+    }
+    let binds = bindings(&app.session);
+    for (key, mods, pressed, physical_key) in events {
+        // (Per event: a shortcut can change the tool, the selection or the focused panel.)
+        let (focused, contexts) = (app.ui.focused.shortcut_scope(), active_contexts(app));
+        // Plain Spacebar runs its shortcut (Play Current Preview) on the release: held, it is
+        // the Hand tool (After Effects), and a drag with it must not start or stop playback.
+        if key == egui::Key::Space && (!pressed || !mods.any()) {
+            if pressed {
+                if app.dialog.is_none() {
+                    ctx.data_mut(|d| d.insert_temp(space_tap_id(), true));
+                }
+                continue;
+            }
+            if !ctx.data_mut(|d| d.remove_temp::<bool>(space_tap_id())).unwrap_or(false) {
+                continue;
+            }
+        }
+        // Escape closes dialogs.
+        if key == egui::Key::Escape && app.dialog.is_some() {
+            cancel_dialog(app, ctx);
+            continue;
+        }
+        if app.dialog.is_some() {
+            continue;
+        }
+        // Enter in the Project panel renames the selected item (handled by the panel).
+        // In Effects & Presets and the Render Queue Enter applies or opens the row (handled by the
+        // panel), not the layer rename.
+        if key == egui::Key::Enter && !mods.any() && panel_owns_enter(app.ui.focused) {
+            continue;
+        }
+        // The Project panel has its own selection; a previously selected Timeline layer
+        // must not be deleted while the Project panel has focus.
+        if matches!(key, egui::Key::Delete | egui::Key::Backspace) && !mods.any() {
+            if matches!(app.ui.focused, PanelKind::Composition | PanelKind::Viewer(_)) && !app.session.state.camera_points.is_empty() {
+                if let Err(e) = run_engine(app, ctx, "camera.deletePoints", json!({})) {
+                    app.ui.status = e;
+                }
+                ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, key));
+                continue;
+            }
+            // The queue panel consumes the event after its selection state is drawn.
+            if app.ui.focused == PanelKind::RenderQueue {
+                continue;
+            }
+            let _ = invoke(app, ctx, "edit.clear", json!({}));
+            continue;
+        }
+        // The narrowest active scope wins a chord: an active context, the focused panel, the
+        // application. A context's shortcut doesn't run outside it. Explicit physical bindings
+        // distinguish keys that a layout reports with the same logical name (for example AZERTY's
+        // minus and right parenthesis); they win over logical ones of the same scope rank.
+        let table = app.session.shortcuts();
+        let scope_of = |id: &str, params: &Value| {
+            let key = effectcraft_engine::shortcuts::binding_key(id, params);
+            table.find(&key).map_or(effectcraft_engine::shortcuts::APP_SCOPE, |b| b.scope.as_str())
+        };
+        let physical = table.bindings().into_iter().filter_map(|(sc, b)| {
+            let (m, k) = parse_shortcut(sc.strip_prefix("Physical+")?)?;
+            (Some(k) == physical_key && mods_match(m, mods)).then_some((b.scope.as_str(), true, (&b.command, &b.params)))
+        });
+        let logical = binds.iter().filter(|(m, k, ..)| *k == key && mods_match(*m, mods)).map(|(_, _, id, params)| (scope_of(id, params), false, (id, params)));
+        let chosen = match effectcraft_engine::shortcuts::pick(physical.chain(logical), &focused, &contexts) {
+            Ok(c) => c.map(|(id, params)| (id.clone(), if params.is_null() { json!({}) } else { params.clone() })),
+            Err(scopes) => {
+                let panels: Vec<String> = scopes.iter().map(|s| effectcraft_engine::shortcuts::scope_label(s)).collect();
+                app.ui.status = format!("This shortcut belongs to {}: focus one of them", panels.join(" and "));
+                None
+            }
+        };
+        if let Some((id, params)) = chosen {
+            if id == "edit.paste"
+                && let Some(t) = &pasted
+            {
+                ctx.data_mut(|d| d.insert_temp(system_paste_id(), t.clone()));
+            }
+            if let Err(e) = invoke(app, ctx, &id, params) {
+                app.ui.status = e;
+            }
+            ctx.data_mut(|d| d.remove_temp::<String>(system_paste_id()));
+        }
+    }
+}
diff --git a/crates/ui-egui/src/menus/tests.rs b/crates/ui-egui/src/menus/tests.rs
new file mode 100644
index 000000000..0ed3fe7ad
--- /dev/null
+++ b/crates/ui-egui/src/menus/tests.rs
@@ -0,0 +1,639 @@
+use super::*;
+
+/// #882: at 125 % / 150 % display scaling Zoom In reaches 100 % (one comp pixel per screen
+/// pixel), not 100 % in points (125 % / 150 % on screen).
+#[test]
+fn zoom_steps_land_on_whole_screen_magnifications() {
+    for ppp in [1.0f32, 1.25, 1.5, 2.0] {
+        let at_100 = zoom_step(0.7 / ppp, ppp, true);
+        assert!((at_100 * ppp - 1.0).abs() < 1e-6, "ppp {ppp}: {}", at_100 * ppp);
+        assert!((zoom_step(at_100, ppp, true) * ppp - 1.5).abs() < 1e-6);
+        assert!((zoom_step(at_100, ppp, false) * ppp - 0.66).abs() < 1e-6);
+    }
+    assert!(zoom_step(1.0, 0.0, true).is_finite());
+}
+
+#[test]
+fn shortcut_passes_share_frame_start_modifiers() {
+    let ctx = egui::Context::default();
+    let mut starts = Vec::new();
+    let mut output = ctx.run_ui(egui::RawInput { events: vec![egui::Event::ModifiersChanged(egui::Modifiers::SHIFT)], ..Default::default() }, |ui| {
+        let ctx = ui.ctx();
+        starts.push(modifiers_at_start(ctx));
+        starts.push(modifiers_at_start(ctx));
+    });
+    output.textures_delta.clear();
+    assert_eq!(starts, vec![None, None]);
+    starts.clear();
+    let mut output = ctx.run_ui(egui::RawInput { events: vec![egui::Event::ModifiersChanged(egui::Modifiers::NONE)], ..Default::default() }, |ui| {
+        let ctx = ui.ctx();
+        starts.push(modifiers_at_start(ctx));
+        starts.push(modifiers_at_start(ctx));
+    });
+    output.textures_delta.clear();
+    assert_eq!(starts, vec![Some(egui::Modifiers::SHIFT), Some(egui::Modifiers::SHIFT)]);
+}
+
+#[test]
+fn every_ui_shortcut_parses() {
+    for c in UI_COMMANDS {
+        if let Some(sc) = c.shortcut {
+            assert!(parse_shortcut(sc).is_some() || sc == "Num*", "{sc}");
+        }
+    }
+    for (_, e) in effectcraft_engine::menus::entries() {
+        if let Some(sc) = &e.shortcut {
+            assert!(parse_shortcut(sc).is_some() || sc == "Num*", "{} ({sc})", e.label);
+        }
+    }
+}
+
+#[test]
+fn full_screen_default_is_platform_specific() {
+    let app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let full_screen = app.session.shortcuts().shortcut_of("view.fullScreen", &Value::Null);
+    if cfg!(target_os = "macos") {
+        assert_eq!(full_screen, Some("Ctrl+Cmd+F"));
+    } else {
+        assert_eq!(full_screen, None);
+        assert_eq!(app.session.shortcuts().shortcut_of("window.maximizeApp", &Value::Null), Some("Cmd+\\"));
+    }
+}
+
+#[test]
+fn ui_and_menu_shortcuts_do_not_collide() {
+    let app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let mut seen: std::collections::BTreeMap<(String, String), (String, String)> = Default::default();
+    for (m, k, id, params) in bindings(&app.session) {
+        let key = (format!("{m:?}"), format!("{k:?}"));
+        let target = (id.clone(), params.to_string());
+        if let Some(prev) = seen.get(&key) {
+            assert_eq!(prev, &target, "{key:?} bound to {prev:?} and {target:?}");
+        } else {
+            seen.insert(key, target);
+        }
+    }
+}
+
+/// #336: Ctrl+\ (Cmd+\ on macOS) maximizes the application window, and again restores
+/// it, as in After Effects.
+#[test]
+fn ctrl_backslash_maximizes_or_restores_the_window() {
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let (m, k) = parse_shortcut("Cmd+\\").unwrap();
+    assert!(m.command && k == egui::Key::Backslash, "{m:?} {k:?}");
+    assert!(bindings(&app.session).iter().any(|b| (b.0, b.1) == (m, k) && b.2 == "window.maximizeApp"));
+    let ctx = egui::Context::default();
+    let run = |app: &mut EffectcraftApp, maximized: bool| {
+        let input = egui::RawInput {
+            viewports: std::iter::once((egui::ViewportId::ROOT, egui::ViewportInfo { maximized: Some(maximized), ..Default::default() })).collect(),
+            ..Default::default()
+        };
+        let mut r = Value::Null;
+        let mut out = ctx.run_ui(input, |ui| r = invoke(app, ui.ctx(), "window.maximizeApp", json!({})).unwrap());
+        out.textures_delta.clear();
+        let cmds = out.viewport_output.get(&egui::ViewportId::ROOT).map(|v| v.commands.clone()).unwrap_or_default();
+        (r, cmds)
+    };
+    let (r, cmds) = run(&mut app, false);
+    assert_eq!(r, json!({"maximized": true}));
+    assert!(cmds.contains(&egui::ViewportCommand::Maximized(true)), "{cmds:?}");
+    let (r, cmds) = run(&mut app, true);
+    assert_eq!(r, json!({"maximized": false}));
+    assert!(cmds.contains(&egui::ViewportCommand::Maximized(false)), "{cmds:?}");
+}
+
+/// The default keys of the keyboard-only commands parse and reach them.
+#[test]
+fn keyboard_only_commands_are_bound() {
+    let app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    for (id, keys) in [
+        ("time.workAreaStart", "Shift+Home"),
+        ("time.workAreaEnd", "Shift+End"),
+        ("time.previousInOut", "Cmd+Alt+Shift+ArrowLeft"),
+        ("time.nextInOut", "Cmd+Alt+Shift+ArrowRight"),
+        ("comp.workAreaToSelection", "Cmd+Alt+B"),
+        ("comp.activateRecent", "Shift+Escape"),
+        ("keys.deselectAll", "Shift+F2"),
+        ("keys.deselectAll", "Cmd+Alt+Shift+A"),
+        ("layer.extendSelectionNext", "Cmd+Shift+ArrowDown"),
+        ("layer.moveInToStart", "Alt+Home"),
+        ("layer.moveEarlier", "Alt+PageUp"),
+        ("layer.moveLater10", "Alt+Shift+PageDown"),
+        ("layer.stretchInToTime", "Cmd+Shift+,"),
+        ("layer.stretchOutToTime", "Cmd+Alt+,"),
+        ("layer.mask.selectNext", "Alt+`"),
+        ("layer.mask.selectPrevious", "Alt+Shift+`"),
+        ("layer.castsShadows", "Alt+Shift+C"),
+        ("timeline.scrollToTime", "D"),
+        ("timeline.scrollToLayer", "X"),
+        ("timeline.parentColumn", "Shift+F4"),
+        ("view.fitUpTo100", "Alt+/"),
+        ("view.nextItem", "Shift+."),
+        ("view.previousItem", "Shift+,"),
+        ("window.toggleCompTimeline", "\\"),
+        ("window.nextPanel", "Alt+Shift+."),
+        ("window.previousPanel", "Alt+Shift+,"),
+        ("window.closeAll", "Cmd+Shift+W"),
+        ("tool.camera", "C"),
+    ] {
+        assert!(bindings(&app.session).into_iter().any(|x| x.2 == id && Some((x.0, x.1)) == parse_shortcut(keys)), "{id} on {keys}");
+    }
+}
+
+#[test]
+fn timeline_keys_scroll_and_toggle_the_parent_column() {
+    let ctx = egui::Context::default();
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let run = |app: &mut EffectcraftApp, id: &str| invoke(app, &ctx, id, json!({})).unwrap();
+    // D and X leave a scroll for the Timeline to do when it is drawn.
+    run(&mut app, "timeline.scrollToTime");
+    assert_eq!(app.ui.timeline.scroll_to, Some(crate::state::ScrollTo::Time));
+    run(&mut app, "timeline.scrollToLayer");
+    assert_eq!(app.ui.timeline.scroll_to, Some(crate::state::ScrollTo::Layer));
+    // Shift+F4 shows and hides the Parent column.
+    let parent = crate::panels::timeline::column_visible(&app.ui.timeline, "parent");
+    run(&mut app, "timeline.parentColumn");
+    assert_eq!(crate::panels::timeline::column_visible(&app.ui.timeline, "parent"), !parent);
+    run(&mut app, "timeline.parentColumn");
+    assert_eq!(crate::panels::timeline::column_visible(&app.ui.timeline, "parent"), parent);
+}
+
+#[test]
+fn viewer_keys_fit_and_step_through_open_comps() {
+    let ctx = egui::Context::default();
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let run = |app: &mut EffectcraftApp, id: &str| invoke(app, &ctx, id, json!({})).unwrap();
+    let new = |app: &mut EffectcraftApp, name: &str| app.session.execute("comp.new", json!({"name": name, "duration": 4})).unwrap()["comp"].as_u64();
+    let active = |app: &EffectcraftApp| app.session.state.active_comp.map(|c| c.0);
+    // With one composition open there is nothing to step to.
+    let a = new(&mut app, "A");
+    run(&mut app, "view.nextItem");
+    assert_eq!(active(&app), a);
+    // Shift+, / Shift+.: through the open compositions, wrapping.
+    let b = new(&mut app, "B");
+    assert_eq!(active(&app), b);
+    run(&mut app, "view.nextItem");
+    assert_eq!(active(&app), a);
+    run(&mut app, "view.previousItem");
+    assert_eq!(active(&app), b);
+    // Alt+/ fits the viewer without magnifying past 100 %; Shift+/ fits fully again.
+    app.ui.viewer.zoom = Some(3.0);
+    run(&mut app, "view.fitUpTo100");
+    assert!(app.ui.viewer.zoom.is_none() && app.ui.viewer.fit_up_to_100);
+    run(&mut app, "view.fit");
+    assert!(!app.ui.viewer.fit_up_to_100);
+}
+
+#[test]
+fn panel_keys_switch_cycle_and_close() {
+    let ctx = egui::Context::default();
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let run = |app: &mut EffectcraftApp, id: &str| invoke(app, &ctx, id, json!({})).unwrap();
+    for name in ["A", "B"] {
+        app.session.execute("comp.new", json!({"name": name, "duration": 4})).unwrap();
+    }
+    // \\ switches between the Timeline and the Composition viewer.
+    app.ui.focused = PanelKind::Timeline;
+    run(&mut app, "window.toggleCompTimeline");
+    assert_eq!(app.ui.focused, PanelKind::Composition);
+    run(&mut app, "window.toggleCompTimeline");
+    assert_eq!(app.ui.focused, PanelKind::Timeline);
+    // Alt+Shift+. / Alt+Shift+,: the tabs of the focused panel's group, wrapping.
+    let group = app.ui.dock.group_of(PanelKind::Timeline);
+    assert!(group.len() > 1, "{group:?}");
+    run(&mut app, "window.nextPanel");
+    assert_eq!(app.ui.focused, group[(group.iter().position(|p| *p == PanelKind::Timeline).unwrap() + 1) % group.len()]);
+    run(&mut app, "window.previousPanel");
+    assert_eq!(app.ui.focused, PanelKind::Timeline);
+    // Ctrl+Shift+W with the Timeline active closes every composition.
+    run(&mut app, "window.closeAll");
+    assert!(app.session.state.open_comps.is_empty());
+    // With another panel active it closes that panel.
+    app.show_panel(PanelKind::Project);
+    run(&mut app, "window.closeAll");
+    assert!(!app.ui.dock.is_open(PanelKind::Project));
+}
+
+#[test]
+fn c_cycles_the_camera_tools() {
+    let ctx = egui::Context::default();
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    app.ui.tool = Tool::Selection;
+    let mut seen = vec![];
+    for _ in 0..4 {
+        invoke(&mut app, &ctx, "tool.camera", json!({})).unwrap();
+        seen.push(app.ui.tool);
+    }
+    assert_eq!(seen, [Tool::Orbit, Tool::PanCamera, Tool::Dolly, Tool::Orbit]);
+}
+
+#[test]
+fn dispatch_uses_the_active_custom_preset() {
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let find = |app: &EffectcraftApp, id: &str| bindings(&app.session).into_iter().filter(|b| b.2 == id).map(|b| (b.0, b.1)).collect::<Vec<_>>();
+    let (m, k) = parse_shortcut("Cmd+Alt+Shift+Y").unwrap();
+    assert!(find(&app, "layer.newNull").contains(&(m, k)));
+    // A UI command rebound in a custom preset.
+    app.session.execute("shortcuts.set", json!({"command": "tool.hand", "keys": "Ctrl+Alt+H"})).unwrap();
+    assert_eq!(app.session.keymaps.active, "Custom");
+    let (m2, k2) = parse_shortcut("Ctrl+Alt+H").unwrap();
+    assert_eq!(find(&app, "tool.hand"), vec![(m2, k2)]);
+    app.session.execute("shortcuts.set", json!({"command": "layer.newNull", "keys": "F6"})).unwrap();
+    assert_eq!(find(&app, "layer.newNull"), vec![(egui::Modifiers::NONE, egui::Key::F6)]);
+    // The menus show the preset's shortcut.
+    let item = menu_items(&app).into_iter().find(|i| i.id == "layer.newNull").unwrap();
+    assert_eq!(item.shortcut.as_deref(), Some("F6"));
+    // Back to the default preset.
+    app.session.execute("shortcuts.preset", json!({"op": "select", "name": effectcraft_engine::shortcuts::DEFAULT_PRESET})).unwrap();
+    assert!(find(&app, "layer.newNull").contains(&(m, k)));
+}
+
+#[test]
+fn renamed_label_shows_in_the_label_menu() {
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    app.set_pref("labels.1.name", json!("Sunflower")).unwrap();
+    let labels: Vec<String> = menu_items(&app).into_iter().filter(|i| i.id == "edit.label").map(|i| i.label).collect();
+    assert!(labels.contains(&"Sunflower".to_string()), "{labels:?}");
+    assert!(!labels.contains(&"Yellow".to_string()));
+}
+
+/// Saving anything but a project asks the save dialog for that file's extension (#293): the
+/// project dialog, filtered to `.ecproj`, made macOS append `.ecproj` (`Frame.png.ecproj`).
+/// Hosts with only the project dialog (the web) still get it, given the file name.
+#[test]
+fn save_dialogs_offer_the_file_extension() {
+    use std::cell::RefCell;
+    use std::rc::Rc;
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    app.session.execute("comp.new", json!({"name": "A", "width": 64, "height": 36, "frameRate": 30, "duration": 1})).unwrap();
+    let ctx = egui::Context::default();
+    let asked: Rc<RefCell<Vec<String>>> = Rc::default();
+    let (a, b) = (asked.clone(), asked.clone());
+    app.hooks.pick_save = Some(Box::new(move |name: &str| {
+        a.borrow_mut().push(format!("project {name}"));
+        None
+    }));
+    app.hooks.pick_save_file = Some(Box::new(move |name: &str, ext: &str| {
+        b.borrow_mut().push(format!("file {name} [{ext}]"));
+        None
+    }));
+    for id in ["comp.saveFrameAs", "render.saveCurrentPreview", "file.exportLottie", "file.saveCopyAsXml", "file.collectFiles", "file.saveAs"] {
+        invoke(&mut app, &ctx, id, json!({})).unwrap();
+    }
+    assert_eq!(
+        *asked.borrow(),
+        [
+            "file Frame.png [png]",
+            "file Preview.mp4 [mp4]",
+            "file Animation.json [json]",
+            "file Untitled Project.ecprojx [ecprojx]",
+            "file Collected Files []",
+            "project Untitled Project.ecproj",
+        ]
+    );
+    // Without the other dialog, the project one names any file.
+    app.hooks.pick_save_file = None;
+    asked.borrow_mut().clear();
+    invoke(&mut app, &ctx, "comp.saveFrameAs", json!({})).unwrap();
+    assert_eq!(*asked.borrow(), ["project Frame.png"]);
+}
+
+/// #2788: Save As, Save a Copy (`<name> copy`) and Save a Copy As XML start from the open
+/// project's name (in its folder), not Untitled Project.
+#[test]
+fn save_as_dialogs_start_from_the_open_project() {
+    use std::cell::RefCell;
+    use std::rc::Rc;
+    use std::sync::{Arc, Mutex};
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    app.session.execute("comp.new", json!({"name": "A", "width": 64, "height": 36, "frameRate": 30, "duration": 1})).unwrap();
+    let ctx = egui::Context::default();
+    let dir = std::env::temp_dir().join(format!("ec-save-as-name-{}", std::process::id()));
+    let project = dir.join("Intro.ecproj");
+    app.session.path = Some(project.to_string_lossy().to_string());
+    let asked: Rc<RefCell<Vec<String>>> = Rc::default();
+    let (a, b) = (asked.clone(), asked.clone());
+    app.hooks.pick_save = Some(Box::new(move |name: &str| {
+        a.borrow_mut().push(format!("project {name}"));
+        None
+    }));
+    app.hooks.pick_save_file = Some(Box::new(move |name: &str, ext: &str| {
+        b.borrow_mut().push(format!("file {name} [{ext}]"));
+        None
+    }));
+    for id in ["file.saveAs", "file.saveCopy", "file.saveCopyAsXml"] {
+        invoke(&mut app, &ctx, id, json!({})).unwrap();
+    }
+    let xml = dir.join("Intro.ecprojx").to_string_lossy().to_string();
+    // Save a Copy names another file: it would refuse to write over the open project.
+    assert_eq!(*asked.borrow(), ["project Intro.ecproj".to_string(), "project Intro copy.ecproj".into(), format!("file {xml} [ecprojx]")]);
+    // An open XML project's XML copy is another file too.
+    app.session.path = Some(dir.join("Intro.ecprojx").to_string_lossy().to_string());
+    asked.borrow_mut().clear();
+    invoke(&mut app, &ctx, "file.saveCopyAsXml", json!({})).unwrap();
+    let copy = dir.join("Intro copy.ecprojx").to_string_lossy().to_string();
+    assert_eq!(*asked.borrow(), [format!("file {copy} [ecprojx]")]);
+    app.session.path = Some(project.to_string_lossy().to_string());
+    // The non-blocking dialog gets the whole path, so it opens in the project's folder.
+    let pending: Arc<Mutex<Vec<crate::FileDialog>>> = Arc::default();
+    let queue = pending.clone();
+    app.hooks.file_dialog_async = Some(Box::new(move |dialog, _done| queue.lock().unwrap().push(dialog)));
+    invoke(&mut app, &ctx, "file.saveAs", json!({})).unwrap();
+    let dialog = pending.lock().unwrap().pop().expect("a dialog was shown");
+    assert_eq!(dialog, crate::FileDialog::Save { default: project.to_string_lossy().to_string(), ext: "ecproj".into(), project: true });
+}
+
+/// File ▸ Scripts ▸ Recent Script Files and its key run a script again without a file dialog.
+#[test]
+fn recent_script_files_run_without_a_dialog() {
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let ctx = egui::Context::default();
+    let dir = std::env::temp_dir().join(format!("ec-recent-script-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let script = dir.join("New Comp.jsonl");
+    std::fs::write(&script, r#"{"command": "comp.new", "params": {"name": "From Script", "width": 64, "height": 36, "frameRate": 30, "duration": 1}}"#)
+        .unwrap();
+    app.session.execute("file.runScript", json!({"path": script.to_string_lossy()})).unwrap();
+    let (m, k, id, params) =
+        bindings(&app.session).into_iter().find(|b| b.2 == "file.runScript" && b.3 == json!({"recent": 0})).expect("the most recent script has a key");
+    assert_eq!((m, k), parse_shortcut("Cmd+Alt+Shift+D").unwrap());
+    assert_eq!(invoke(&mut app, &ctx, &id, params).unwrap()["steps"], 1);
+    assert_eq!(app.session.project.items.values().filter(|i| i.name.starts_with("From Script")).count(), 2);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// #511: with a host's non-blocking dialogs, a command's file dialog opens without running
+/// a nested event loop inside the frame (a drag over the window then aborted the app on
+/// macOS); the command runs on a later frame with the answer, and a cancelled one not at all.
+#[test]
+fn file_dialogs_can_answer_on_a_later_frame() {
+    use std::sync::{Arc, Mutex};
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    app.session.execute("comp.new", json!({"name": "A", "width": 64, "height": 36, "frameRate": 30, "duration": 1})).unwrap();
+    let ctx = egui::Context::default();
+    app.hooks.pick_save = Some(Box::new(|_: &str| panic!("the blocking dialog is not used")));
+    let pending: Arc<Mutex<Vec<(crate::FileDialog, crate::DialogDone)>>> = Arc::default();
+    let queue = pending.clone();
+    app.hooks.file_dialog_async = Some(Box::new(move |dialog, done| queue.lock().unwrap().push((dialog, done))));
+    assert_eq!(invoke(&mut app, &ctx, "file.saveAs", json!({})).unwrap(), json!({"dialog": "file.saveAs"}));
+    let (dialog, done) = pending.lock().unwrap().pop().expect("a dialog was shown");
+    assert_eq!(dialog, crate::FileDialog::Save { default: "Untitled Project.ecproj".into(), ext: "ecproj".into(), project: true });
+    assert!(app.session.path.is_none(), "nothing saved until the dialog answers");
+    let dir = std::env::temp_dir().join(format!("ec-dialog-answer-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("Answered.ecproj");
+    // Answered from another thread, as the host's dialog does.
+    std::thread::spawn(move || done(vec![path.to_string_lossy().to_string()])).join().unwrap();
+    app.run_dialog_answers();
+    assert_eq!(app.session.path.as_deref(), Some(dir.join("Answered.ecproj").to_string_lossy().as_ref()));
+    assert!(dir.join("Answered.ecproj").is_file());
+    // Cancelled: nothing runs.
+    invoke(&mut app, &ctx, "comp.saveFrameAs", json!({})).unwrap();
+    let (dialog, done) = pending.lock().unwrap().pop().expect("a dialog was shown");
+    assert_eq!(dialog, crate::FileDialog::Save { default: "Frame.png".into(), ext: "png".into(), project: false });
+    done(Vec::new());
+    app.run_dialog_answers();
+    assert!(!dir.join("Frame.png").exists());
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// While a command's OS file dialog is up, floating panels' OS windows are blocked, as for
+/// a modal dialog; a dialog that ends, answered or not, unblocks them, and Save As opens a
+/// dialog again. A macOS sheet can end without answering (its window went away): once one of
+/// the app's windows has the keyboard again, or keeps it as if no dialog showed, floating
+/// windows are not left blocked.
+#[test]
+fn file_dialogs_block_floating_windows_only_while_up() {
+    use std::sync::{Arc, Mutex};
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let ctx = egui::Context::default();
+    let pending: Arc<Mutex<Vec<crate::DialogDone>>> = Arc::default();
+    let queue = pending.clone();
+    app.hooks.file_dialog_async = Some(Box::new(move |_dialog, done| queue.lock().unwrap().push(done)));
+    let blocked = |app: &mut EffectcraftApp, focused: bool, time: f64| {
+        let input = egui::RawInput { focused, time: Some(time), ..Default::default() };
+        let mut out = false;
+        ctx.run_ui(input, |ui| out = app.floats_blocked(ui.ctx())).textures_delta.clear();
+        out
+    };
+    assert!(!blocked(&mut app, true, 0.0));
+    // Cancelled.
+    invoke(&mut app, &ctx, "file.saveAs", json!({})).unwrap();
+    assert!(blocked(&mut app, true, 0.1), "blocked while the dialog takes the keyboard");
+    assert!(blocked(&mut app, false, 0.2));
+    let done = pending.lock().unwrap().pop().expect("a dialog was shown");
+    done(Vec::new());
+    app.run_dialog_answers();
+    assert!(!blocked(&mut app, false, 0.3));
+    // Save As asks again; the sheet ends without answering.
+    invoke(&mut app, &ctx, "file.saveAs", json!({})).unwrap();
+    assert_eq!(pending.lock().unwrap().len(), 1, "Save As opens a dialog again");
+    assert!(blocked(&mut app, true, 1.0));
+    assert!(blocked(&mut app, false, 1.1));
+    assert!(blocked(&mut app, false, 9.0), "a dialog may stay up for long");
+    assert!(!blocked(&mut app, true, 9.1), "an app window has the keyboard again");
+    // A dialog that never takes the keyboard.
+    invoke(&mut app, &ctx, "file.saveAs", json!({})).unwrap();
+    assert!(blocked(&mut app, true, 10.0));
+    assert!(blocked(&mut app, true, 11.0));
+    assert!(!blocked(&mut app, true, 12.5));
+    // Answers of dialogs taken for gone arrive late: nothing stays blocked.
+    for done in pending.lock().unwrap().drain(..) {
+        done(Vec::new());
+    }
+    app.run_dialog_answers();
+    assert!(!blocked(&mut app, false, 13.0));
+    invoke(&mut app, &ctx, "file.saveAs", json!({})).unwrap();
+    assert!(blocked(&mut app, false, 13.1), "a later dialog blocks again");
+}
+
+#[test]
+fn tga_is_available_in_import_replace_and_proxy_dialogs() {
+    use std::sync::{Arc, Mutex};
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let ctx = egui::Context::default();
+    let pending = Arc::new(Mutex::new(Vec::new()));
+    let queue = pending.clone();
+    app.hooks.file_dialog_async = Some(Box::new(move |dialog, _done| queue.lock().unwrap().push(dialog)));
+    for command in ["file.import", "file.importMultiple", "file.replaceFootage", "file.setProxy"] {
+        assert_eq!(invoke(&mut app, &ctx, command, json!({})).unwrap(), json!({"dialog": command}));
+        let crate::FileDialog::Open { exts, .. } = pending.lock().unwrap().pop().unwrap() else { panic!("not an open dialog") };
+        assert!(exts.iter().any(|ext| ext == "tga"), "{command}: {exts:?}");
+    }
+}
+
+/// Cmd+W with the Render Queue focused closes the queue; the composition next to it stays
+/// open (it used to be closed, and the queue stayed).
+#[test]
+fn cmd_w_in_the_render_queue_closes_the_queue_not_the_comp() {
+    let ctx = egui::Context::default();
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let a = app.session.execute("comp.new", json!({"name": "A", "duration": 4})).unwrap()["comp"].as_u64();
+    app.show_panel(PanelKind::RenderQueue);
+    assert_eq!(app.ui.focused, PanelKind::RenderQueue);
+    invoke(&mut app, &ctx, "file.close", json!({})).unwrap();
+    assert!(!app.ui.dock.is_visible(PanelKind::RenderQueue));
+    assert_eq!(app.session.state.active_comp.map(|c| c.0), a);
+    assert_eq!(app.session.state.open_comps.len(), 1);
+    // The focus left the closed queue: the next Close closes the composition.
+    assert_ne!(app.ui.focused, PanelKind::RenderQueue);
+    invoke(&mut app, &ctx, "file.close", json!({})).unwrap();
+    assert_eq!(app.session.state.open_comps.len(), 0, "a second Close acts on the composition");
+}
+
+#[test]
+fn file_close_is_available_for_an_empty_render_queue_without_a_comp() {
+    for params in [Value::Null, json!({})] {
+        let ctx = egui::Context::default();
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        assert!(app.session.active_comp().is_none());
+        app.show_panel(PanelKind::RenderQueue);
+        assert!(menu_items(&app).iter().find(|item| item.id == "file.close").unwrap().enabled);
+        invoke(&mut app, &ctx, "file.close", params).unwrap();
+        assert!(!app.ui.dock.is_open(PanelKind::RenderQueue));
+    }
+}
+
+#[test]
+fn closing_the_render_queue_reveals_the_panel_receiving_focus() {
+    for maximized in [false, true] {
+        let ctx = egui::Context::default();
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        app.close_panel(PanelKind::Timeline);
+        app.close_panel(PanelKind::Composition);
+        app.show_panel(PanelKind::EffectControls);
+        assert!(!app.ui.dock.is_visible(PanelKind::Project));
+        app.show_panel(PanelKind::RenderQueue);
+        if maximized {
+            app.apply_dock(craft_ui::docking::Action::Float { panel: PanelKind::RenderQueue, rect: [50.0, 60.0, 400.0, 200.0] }).unwrap();
+            app.toggle_maximize(PanelKind::EffectControls);
+            app.ui.focused = PanelKind::RenderQueue;
+            assert!(app.ui.dock.is_floating(PanelKind::RenderQueue));
+        }
+        invoke(&mut app, &ctx, "file.close", json!({})).unwrap();
+        assert_eq!(app.ui.focused, PanelKind::Project);
+        assert!(app.ui.dock.is_visible(app.ui.focused), "focus must belong to a front tab");
+        assert_eq!(app.ui.maximized, None, "the focused docked panel must be on screen");
+    }
+}
+
+/// Closing a floating queue must focus the viewer that is actually shown, retaining maximization.
+#[test]
+fn closing_a_floating_queue_preserves_the_maximized_composition() {
+    let mut session = effectcraft_engine::Session::default();
+    session.execute("comp.new", json!({"name": "A", "width": 32, "height": 32, "duration": 2})).unwrap();
+    let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_eframe(|_| EffectcraftApp::new(session));
+    h.run_steps(3);
+    let ctx = h.ctx.clone();
+    let app = h.state_mut();
+    app.show_panel(PanelKind::Composition);
+    app.show_panel(PanelKind::RenderQueue);
+    app.apply_dock(craft_ui::docking::Action::Float { panel: PanelKind::RenderQueue, rect: [50.0, 60.0, 400.0, 200.0] }).unwrap();
+    app.toggle_maximize(PanelKind::Composition);
+    app.ui.focused = PanelKind::RenderQueue;
+    assert!(app.ui.dock.is_visible(PanelKind::Timeline), "the hidden underlying tab triggers the regression");
+    assert!(!panel_shown(app, PanelKind::Timeline));
+    invoke(app, &ctx, "file.close", json!({})).unwrap();
+    h.run_steps(3);
+    assert_eq!(h.state().ui.focused, PanelKind::Composition);
+    assert_eq!(h.state().ui.maximized, Some(PanelKind::Composition));
+    assert!(!h.state().ui.dock.is_open(PanelKind::RenderQueue));
+    assert_eq!(h.state().session.state.open_comps.len(), 1);
+}
+
+#[test]
+fn queue_close_preserves_state_when_workspace_is_locked() {
+    let ctx = egui::Context::default();
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    app.session.execute("comp.new", json!({"name": "A", "duration": 2})).unwrap();
+    app.show_panel(PanelKind::RenderQueue);
+    app.ui.dock.locked = true;
+    let workspace = app.ui.dock.clone();
+    let comp = app.session.active_comp_id();
+    for _ in 0..2 {
+        assert!(invoke(&mut app, &ctx, "file.close", Value::Null).is_err());
+        assert_eq!(app.ui.dock, workspace);
+        assert_eq!(app.ui.focused, PanelKind::RenderQueue);
+        assert_eq!(app.session.active_comp_id(), comp);
+    }
+    assert!(!menu_items(&app).iter().find(|item| item.id == "file.close").unwrap().enabled);
+    app.ui.dock.locked = false;
+    invoke(&mut app, &ctx, "file.close", Value::Null).unwrap();
+    assert!(!app.ui.dock.is_open(PanelKind::RenderQueue));
+}
+
+#[test]
+fn queue_close_preserves_viewer_command_target() {
+    let ctx = egui::Context::default();
+    let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+    let a = app.session.execute("comp.new", json!({"name": "A", "duration": 2})).unwrap()["comp"].as_u64().unwrap();
+    let b = app.session.execute("comp.new", json!({"name": "B", "duration": 2})).unwrap()["comp"].as_u64().unwrap();
+    app.show_panel(PanelKind::Viewer(1));
+    app.ui.viewers.insert(0, Some(a));
+    app.ui.viewers.insert(1, Some(b));
+    app.ui.active_viewer = 1;
+    app.apply_dock(craft_ui::docking::Action::Move {
+        panel: PanelKind::Timeline,
+        anchor: PanelKind::Composition,
+        placement: craft_ui::docking::Placement::Tab { before: None },
+    })
+    .unwrap();
+    app.close_panel(PanelKind::Timeline);
+    app.show_panel(PanelKind::Composition);
+    app.show_panel(PanelKind::RenderQueue);
+    assert_eq!(app.session.active_comp_id().map(|id| id.0), Some(b));
+    invoke(&mut app, &ctx, "file.close", json!({})).unwrap();
+    assert_eq!(app.ui.focused, PanelKind::Composition);
+    assert_eq!(app.ui.active_viewer, 0);
+    assert_eq!(app.session.active_comp_id().map(|id| id.0), Some(a));
+    invoke(&mut app, &ctx, "file.close", json!({})).unwrap();
+    assert!(!app.session.state.open_comps.iter().any(|id| id.0 == a));
+    assert!(app.session.state.open_comps.iter().any(|id| id.0 == b));
+}
+
+#[test]
+fn queue_close_keeps_passive_viewer_focus_across_frames() {
+    let mut session = effectcraft_engine::Session::default();
+    let a = session.execute("comp.new", json!({"name": "A", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
+    let b = session.execute("comp.new", json!({"name": "B", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
+    let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1200.0, 800.0)).build_eframe(|_| EffectcraftApp::new(session));
+    h.run_steps(3);
+    let ctx = h.ctx.clone();
+    let app = h.state_mut();
+    app.show_panel(PanelKind::Viewer(1));
+    app.ui.viewers.insert(0, Some(a));
+    app.ui.viewers.insert(1, Some(b));
+    app.ui.active_viewer = 1;
+    app.apply_dock(craft_ui::docking::Action::Move {
+        panel: PanelKind::Timeline,
+        anchor: PanelKind::Composition,
+        placement: craft_ui::docking::Placement::Tab { before: None },
+    })
+    .unwrap();
+    app.close_panel(PanelKind::Timeline);
+    app.show_panel(PanelKind::Composition);
+    app.show_panel(PanelKind::RenderQueue);
+    invoke(app, &ctx, "file.close", Value::Null).unwrap();
+    h.run_steps(4);
+    let app = h.state_mut();
+    assert_eq!(app.ui.focused, PanelKind::Composition);
+    assert_eq!(app.ui.active_viewer, 0);
+    assert_eq!(app.session.active_comp_id().map(|id| id.0), Some(a));
+    assert!(app.ui.dock.is_visible(PanelKind::Composition));
+    assert!(!app.ui.dock.is_open(PanelKind::RenderQueue));
+    invoke(app, &ctx, "file.close", json!({})).unwrap();
+    assert!(!app.session.state.open_comps.iter().any(|id| id.0 == a));
+    assert!(app.session.state.open_comps.iter().any(|id| id.0 == b));
+    // A later explicit Open still routes normally, rather than inheriting a deferred focus override.
+    invoke(app, &ctx, "comp.open", json!({"comp": b})).unwrap();
+    h.run_steps(3);
+    assert!(h.state().ui.dock.is_visible(PanelKind::Timeline));
+    assert_eq!(h.state().session.active_comp_id().map(|id| id.0), Some(b));
+}
+
+#[test]
+fn menu_items_cover_the_tree() {
+    assert_eq!(menus().last(), Some(&"Help"));
+    assert!(effectcraft_engine::menus::entries().len() > 500);
+}
diff --git a/crates/ui-egui/src/native_menu.rs b/crates/ui-egui/src/native_menu.rs
index 7d7046ed3..1d892b38a 100644
--- a/crates/ui-egui/src/native_menu.rs
+++ b/crates/ui-egui/src/native_menu.rs
@@ -126,8 +126,40 @@ impl NativeMenu {
     }
 }
 
+/// The native menu spec as the menu bar shows it now: [`build`], with the Edit items a text field
+/// takes ([`edits_text`]) enabled while one has the keyboard ([`text_field_window`]). Paste
+/// otherwise follows the project clipboard and would be greyed out with nothing copied there,
+/// while the field can paste.
+pub fn build_now(app: &EffectcraftApp, ctx: &egui::Context) -> NativeMenu {
+    fn enable(app: &EffectcraftApp, nodes: &mut [NativeNode]) {
+        for node in nodes {
+            match node {
+                NativeNode::Item(item) if edits_text(&item.command) => {
+                    item.enabled = true;
+                    let source = match item.command.as_str() {
+                        "edit.undo" => Some("Undo"),
+                        "edit.redo" => Some("Redo"),
+                        _ => None,
+                    };
+                    if let Some(source) = source {
+                        item.label = crate::i18n::label(app, &item.command, source).into();
+                    }
+                }
+                NativeNode::Submenu { children, .. } => enable(app, children),
+                _ => {}
+            }
+        }
+    }
+    let mut menu = build(app);
+    if text_field_window(ctx).is_some() {
+        enable(app, &mut menu.menus);
+    }
+    menu
+}
+
 /// Build the native menu spec for the app's current state.
 pub fn build(app: &EffectcraftApp) -> NativeMenu {
+    /// Append the native nodes of `nodes` to `out`; item ids start with `path`.
     fn rec(app: &EffectcraftApp, nodes: &[MenuNode], path: &str, out: &mut Vec<NativeNode>) {
         let mut services_added = false;
         for (i, n) in nodes.iter().enumerate() {
@@ -138,8 +170,8 @@ pub fn build(app: &EffectcraftApp) -> NativeMenu {
                     // Recent projects / footage / presets, undo history, shortcut slots, viewers,
                     // saved workspaces.
                     let saved = app.saved_workspace_names();
-                    let (entries, empty) = effectcraft_engine::menus::dynamic(&app.session, name, &crate::menus::dyn_ctx(&app.ui.workspace, &saved));
-                    if entries.is_empty()
+                    let (nodes, empty) = effectcraft_engine::menus::dynamic_nodes(&app.session, name, &crate::menus::dyn_ctx(&app.ui.workspace, &saved));
+                    if nodes.is_empty()
                         && let Some(e) = empty
                     {
                         out.push(NativeNode::Item(NativeItem {
@@ -153,14 +185,20 @@ pub fn build(app: &EffectcraftApp) -> NativeMenu {
                             checked: None,
                         }));
                     }
-                    for (k, e) in entries.iter().enumerate() {
+                    for (k, n) in nodes.iter().enumerate() {
+                        // A folder of scripts or panels: a submenu.
+                        let MenuNode::Item(e) = n else {
+                            rec(app, std::slice::from_ref(n), &format!("{id}.d{k}"), out);
+                            continue;
+                        };
                         out.push(NativeNode::Item(NativeItem {
                             id: format!("{id}.d{k}"),
                             label: e.label.clone(),
                             command: e.command.clone(),
                             params: e.params.clone(),
-                            shortcut: None,
-                            accelerator: None,
+                            // File ▸ Scripts entries show the key a script was given.
+                            shortcut: crate::menus::entry_shortcut(app, e),
+                            accelerator: crate::menus::entry_shortcut(app, e).as_deref().and_then(accelerator),
                             enabled: crate::menus::entry_enabled(app, e),
                             checked: crate::menus::entry_checked(app, e),
                         }));
@@ -206,8 +244,12 @@ pub fn build(app: &EffectcraftApp) -> NativeMenu {
                                     "Serviços"
                                 } else if crate::i18n::czech(app) {
                                     "Služby"
+                                } else if crate::i18n::polish(app) {
+                                    "Usługi"
                                 } else if crate::i18n::georgian(app) {
                                     "სერვისები"
+                                } else if crate::i18n::swedish(app) {
+                                    "Tjänster"
                                 } else {
                                     "Services"
                                 }
@@ -319,10 +361,16 @@ pub fn state_key(app: &EffectcraftApp) -> u64 {
     s.journal.last().map(|j| &j.0).hash(&mut h);
     s.prefs.recent_projects.hash(&mut h);
     (&s.prefs.recent_footage, &s.prefs.recent_presets).hash(&mut h);
+    s.prefs.recent_scripts.hash(&mut h);
     s.history.undo.iter().for_each(|(l, _)| l.hash(&mut h));
     s.state.open_comps.hash(&mut h);
     s.active_comp_id().and_then(|c| s.state.views3d.get(&c)).map(|v| format!("{:?}", v.current)).hash(&mut h);
-    s.shortcuts().keys.len().hash(&mut h);
+    // Each binding's keys: a key changed to another one gives the item a new accelerator.
+    let shortcuts = s.shortcuts();
+    for b in &shortcuts.bindables {
+        b.key.hash(&mut h);
+        shortcuts.keys.get(&b.key).hash(&mut h);
+    }
     s.keymaps.active.hash(&mut h);
     let v = &app.ui.viewer;
     (v.rulers, v.guides, v.snap_guides, v.lock_guides, v.grid, v.snap_grid, v.show_layer_controls, v.pasteboard).hash(&mut h);
@@ -332,9 +380,23 @@ pub fn state_key(app: &EffectcraftApp) -> u64 {
     h.finish()
 }
 
-/// Commands that act on a focused text field instead (Edit menu while typing): the egui event to
-/// send in their place.
-fn text_field_event(command: &str, clipboard: Option<String>) -> Option<Vec<egui::Event>> {
+/// The window whose text field has the keyboard: a floating panel's own OS window, or the main
+/// window, where any widget that holds the keyboard counts (the Viewer's text editor is not an
+/// egui text field).
+pub fn text_field_window(ctx: &egui::Context) -> Option<egui::ViewportId> {
+    craft_ui::docking::typing_window(ctx).or_else(|| ctx.egui_wants_keyboard_input().then_some(egui::ViewportId::ROOT))
+}
+
+/// Whether a focused text field takes the menu command `command` ([`activate`]): the native menu
+/// keeps such items enabled while one has the keyboard, whatever the project allows.
+pub fn edits_text(command: &str) -> bool {
+    text_field_event(command).is_some()
+}
+
+/// Commands that act on a focused text field instead (Edit menu while typing): the egui events
+/// to send in their place. Paste is a Cmd+V press, which the field's window turns into a request
+/// for the clipboard text.
+fn text_field_event(command: &str) -> Option<Vec<egui::Event>> {
     let key = |k: egui::Key, shift: bool| egui::Event::Key {
         key: k,
         physical_key: None,
@@ -345,7 +407,7 @@ fn text_field_event(command: &str, clipboard: Option<String>) -> Option<Vec<egui
     Some(match command {
         "edit.copy" => vec![egui::Event::Copy],
         "edit.cut" => vec![egui::Event::Cut],
-        "edit.paste" => vec![egui::Event::Paste(clipboard?)],
+        "edit.paste" => vec![key(egui::Key::V, false)],
         "edit.selectAll" => vec![key(egui::Key::A, false)],
         "edit.undo" => vec![key(egui::Key::Z, false)],
         "edit.redo" => vec![key(egui::Key::Z, true)],
@@ -353,8 +415,43 @@ fn text_field_event(command: &str, clipboard: Option<String>) -> Option<Vec<egui
     })
 }
 
+/// Hand a text field's Edit command to the window `window` whose field has the keyboard. The
+/// main window gets the clipboard text itself and the events through the synthetic queue; a
+/// floating panel's OS window gets each key pressed and released, and asks for the clipboard
+/// text on Cmd+V (`craft_ui::docking::send_keys`).
+fn send_to_text_field(app: &mut EffectcraftApp, ctx: &egui::Context, window: egui::ViewportId, events: Vec<egui::Event>) {
+    if window == egui::ViewportId::ROOT {
+        for event in events {
+            match event {
+                egui::Event::Key { key: egui::Key::V, .. } => {
+                    if let Some(text) = app.hooks.clipboard_text.as_ref().and_then(|f| f()) {
+                        app.synthetic.push(egui::Event::Paste(text));
+                    }
+                }
+                event => app.synthetic.push(event),
+            }
+        }
+        ctx.request_repaint();
+        return;
+    }
+    let events = events
+        .into_iter()
+        .flat_map(|event| {
+            let release = match &event {
+                egui::Event::Key { key, physical_key, modifiers, .. } => {
+                    Some(egui::Event::Key { key: *key, physical_key: *physical_key, pressed: false, repeat: false, modifiers: *modifiers })
+                }
+                _ => None,
+            };
+            std::iter::once(event).chain(release)
+        })
+        .collect();
+    craft_ui::docking::send_keys(ctx, window, events);
+}
+
 /// Run a native menu item (by id) the way the in-window menu bar does. While a text field has
-/// the keyboard, Edit ▸ Cut/Copy/Paste/Select All/Undo/Redo edit the text instead.
+/// the keyboard ([`text_field_window`]), Edit ▸ Cut/Copy/Paste/Select All/Undo/Redo edit the
+/// text instead.
 pub fn activate(app: &mut EffectcraftApp, ctx: &egui::Context, menu: &NativeMenu, id: &str) -> Result<Value, String> {
     let item = menu.find(id).ok_or_else(|| format!("no native menu item `{id}`"))?;
     let (command, params) = (item.command.clone(), item.params.clone());
@@ -369,13 +466,12 @@ pub fn activate(app: &mut EffectcraftApp, ctx: &egui::Context, menu: &NativeMenu
         ctx.request_repaint();
         return Ok(Value::Null);
     }
-    if ctx.egui_wants_keyboard_input() {
-        let clip = if command == "edit.paste" { app.hooks.clipboard_text.as_ref().and_then(|f| f()) } else { None };
-        if let Some(events) = text_field_event(&command, clip) {
-            app.synthetic.extend(events);
-            ctx.request_repaint();
-            return Ok(Value::Null);
-        }
+    // The menu bar takes the Edit menu's key equivalents before any window sees them: while a
+    // text field has the keyboard, in the main window or a floating panel's own window, the
+    // field gets the key and the project command does not run.
+    if let (Some(window), Some(events)) = (text_field_window(ctx), text_field_event(&command)) {
+        send_to_text_field(app, ctx, window, events);
+        return Ok(Value::Null);
     }
     let params = if params.is_null() { json!({}) } else { params };
     let (command, params) = crate::menus::menu_choice(app, command, params);
@@ -471,6 +567,27 @@ mod tests {
         assert_eq!(translated, ["Служби", "Приховати EffectCraft", "Приховати решту", "Показати все"]);
     }
 
+    #[test]
+    fn swedish_translates_macos_predefined_items() {
+        if !cfg!(target_os = "macos") {
+            return;
+        }
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        app.session.execute("prefs.set", json!({"key": "general.language", "value": "sv"})).unwrap();
+        fn labels(nodes: &[NativeNode], out: &mut Vec<String>) {
+            for node in nodes {
+                match node {
+                    NativeNode::Predefined { label, .. } => out.push(label.clone()),
+                    NativeNode::Submenu { children, .. } => labels(children, out),
+                    _ => {}
+                }
+            }
+        }
+        let mut translated = vec![];
+        labels(&build(&app).menus, &mut translated);
+        assert_eq!(translated, ["Tjänster", "Dölj EffectCraft", "Göm övriga", "Visa alla"]);
+    }
+
     #[test]
     fn czech_translates_macos_predefined_items() {
         if !cfg!(target_os = "macos") {
@@ -492,6 +609,27 @@ mod tests {
         assert_eq!(translated, ["Služby", "Skrýt EffectCraft", "Skrýt ostatní", "Zobrazit vše"]);
     }
 
+    #[test]
+    fn polish_translates_macos_predefined_items() {
+        if !cfg!(target_os = "macos") {
+            return;
+        }
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        app.session.execute("prefs.set", json!({"key": "general.language", "value": "pl"})).unwrap();
+        fn labels(nodes: &[NativeNode], out: &mut Vec<String>) {
+            for node in nodes {
+                match node {
+                    NativeNode::Predefined { label, .. } => out.push(label.clone()),
+                    NativeNode::Submenu { children, .. } => labels(children, out),
+                    _ => {}
+                }
+            }
+        }
+        let mut translated = vec![];
+        labels(&build(&app).menus, &mut translated);
+        assert_eq!(translated, ["Usługi", "Ukryj EffectCraft", "Ukryj pozostałe", "Pokaż wszystko"]);
+    }
+
     #[test]
     fn georgian_translates_macos_predefined_items() {
         if !cfg!(target_os = "macos") {
@@ -605,7 +743,7 @@ mod tests {
         assert_ne!(state_key(&app), k0);
         // A tab behind another one, a closed panel and panels under a maximized one are not shown.
         assert_eq!((checked(&app, "renderQueue"), checked(&app, "timeline")), (Some(true), Some(false)));
-        app.ui.dock.close(PanelKind::RenderQueue);
+        app.close_panel(PanelKind::RenderQueue);
         assert_eq!((checked(&app, "renderQueue"), checked(&app, "timeline")), (Some(false), Some(true)));
         app.ui.maximized = Some(PanelKind::Timeline);
         assert_eq!((checked(&app, "timeline"), checked(&app, "project")), (Some(true), Some(false)));
@@ -636,6 +774,24 @@ mod tests {
         assert!(spec2.items().iter().any(|i| i.command == "file.openRecent" && i.label == "Recent Test.ecproj"));
     }
 
+    /// A script's key changed to another key changes the key, so the File ▸ Scripts entry gets
+    /// the new accelerator even though the number of bindings stays the same.
+    #[test]
+    fn a_changed_shortcut_changes_the_state_key() {
+        let mut app = app();
+        let script = json!({"name": "Rename Layers.jsx"});
+        let b = app.session.shortcuts().find(&effectcraft_engine::shortcuts::binding_key("file.runScript", &script)).cloned().unwrap();
+        app.session.keymaps.set(&b, &["Cmd+Alt+Shift+F7".to_string()]).unwrap();
+        app.session.shortcuts_changed();
+        let k0 = state_key(&app);
+        app.session.keymaps.set(&b, &["Cmd+Alt+Shift+F8".to_string()]).unwrap();
+        app.session.shortcuts_changed();
+        assert_ne!(state_key(&app), k0);
+        let spec = build(&app);
+        let entry = spec.items().into_iter().find(|i| i.command == "file.runScript" && i.params == script).unwrap();
+        assert_eq!(entry.shortcut.as_deref(), Some("Cmd+Alt+Shift+F8"));
+    }
+
     /// #1630: a checked Window menu entry closes its panel; an unchecked one opens it.
     #[test]
     fn window_menu_entry_toggles_its_panel() {
@@ -648,9 +804,9 @@ mod tests {
             activate(app, &ctx, &spec, &id).unwrap();
         };
         choose(&mut app);
-        assert!(app.ui.dock.contains(PanelKind::Align));
+        assert!(crate::dock::WorkspaceExt::is_open(&app.ui.dock, PanelKind::Align));
         choose(&mut app);
-        assert!(!app.ui.dock.contains(PanelKind::Align));
+        assert!(!crate::dock::WorkspaceExt::is_open(&app.ui.dock, PanelKind::Align));
     }
 
     #[test]
@@ -663,8 +819,48 @@ mod tests {
         activate(&mut app, &ctx, &spec, &id).unwrap();
         assert_eq!(app.session.active_comp().unwrap().layers.len(), n + 1);
         assert!(activate(&mut app, &ctx, &spec, "m.999").is_err());
-        assert!(text_field_event("edit.copy", None).is_some());
-        assert!(text_field_event("edit.paste", None).is_none());
-        assert!(text_field_event("layer.newNull", None).is_none());
+        assert!(edits_text("edit.copy") && edits_text("edit.paste"));
+        assert!(!edits_text("layer.newNull"));
+    }
+    /// #2459: while a text field has the keyboard the Edit menu's Undo and Redo act on the field and
+    /// read plain "Undo" / "Redo"; the project history labels come back once focus leaves.
+    #[test]
+    fn a_focused_text_field_gets_plain_undo_and_redo_labels() {
+        fn label(menu: &NativeMenu, id: &str) -> String {
+            menu.items().into_iter().find(|i| i.command == id).map(|i| i.label.to_string()).unwrap_or_default()
+        }
+        for (language, undo, redo) in [("en", "Undo", "Redo"), ("ja", "取り消し", "やり直し")] {
+            let mut app = app();
+            app.session.execute("prefs.set", json!({"key": "general.language", "value": language})).unwrap();
+            app.session.execute("layer.newNull", json!({})).unwrap();
+            app.session.execute("layer.newNull", json!({})).unwrap();
+            app.session.execute("edit.undo", json!({})).unwrap();
+            let ctx = egui::Context::default();
+            let history = label(&build_now(&app, &ctx), "edit.undo");
+            let redo_history = label(&build_now(&app, &ctx), "edit.redo");
+            assert!(history.starts_with(undo) && history != undo, "{history}");
+            assert!(redo_history.starts_with(redo) && redo_history != redo, "{redo_history}");
+            let mut text = String::new();
+            let mut id = None;
+            for _ in 0..2 {
+                let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
+                    let r = ui.text_edit_singleline(&mut text);
+                    r.request_focus();
+                    id = Some(r.id);
+                });
+                out.textures_delta.clear();
+            }
+            assert!(text_field_window(&ctx).is_some());
+            let typing = build_now(&app, &ctx);
+            assert_eq!(label(&typing, "edit.undo"), undo);
+            assert_eq!(label(&typing, "edit.redo"), redo);
+            assert!(typing.items().into_iter().any(|i| i.command == "edit.undo" && i.enabled));
+            assert!(typing.items().into_iter().any(|i| i.command == "edit.redo" && i.enabled));
+            ctx.memory_mut(|m| m.surrender_focus(id.unwrap_or(egui::Id::NULL)));
+            assert!(text_field_window(&ctx).is_none());
+            let after = build_now(&app, &ctx);
+            assert_eq!(label(&after, "edit.undo"), history);
+            assert_eq!(label(&after, "edit.redo"), redo_history);
+        }
     }
 }
diff --git a/crates/ui-egui/src/panels/mod.rs b/crates/ui-egui/src/panels.rs
similarity index 54%
rename from crates/ui-egui/src/panels/mod.rs
rename to crates/ui-egui/src/panels.rs
index 5327ab170..933f90c71 100644
--- a/crates/ui-egui/src/panels/mod.rs
+++ b/crates/ui-egui/src/panels.rs
@@ -27,6 +27,7 @@ pub mod key_dialogs;
 pub mod layer_panel;
 pub mod layer_styles_dialog;
 pub mod learn;
+pub mod live_preview;
 pub mod markers_ui;
 pub mod media_panels;
 pub mod misc;
@@ -35,6 +36,7 @@ pub mod paint_panels;
 pub mod panel_kit;
 pub mod path_vr_panels;
 pub mod precomp;
+pub(crate) mod preview_merge;
 pub mod primitive_dialog;
 pub mod project;
 pub mod properties;
@@ -122,8 +124,10 @@ impl PresetRef {
 
 /// Layers carried by a Project item drag. Dragging a selected item uses the
 /// complete selection, while dragging an unselected item uses only that item.
-/// Folders and data files are not composition layers.
-pub(crate) fn project_drop_items(app: &EffectcraftApp, dragged: u64) -> Vec<u64> {
+/// Folders and data files are not composition layers, and the composition the
+/// drop lands in is left out of a selection: it cannot contain itself, and one
+/// such item would make the engine refuse the whole drop (#2589).
+pub(crate) fn project_drop_items(app: &EffectcraftApp, dragged: u64, target: Option<effectcraft_engine::project::ItemId>) -> Vec<u64> {
     use effectcraft_engine::project::{FootageKind, ItemId, ItemKind};
 
     let selected = &app.session.state.project_selection;
@@ -131,12 +135,16 @@ pub(crate) fn project_drop_items(app: &EffectcraftApp, dragged: u64) -> Vec<u64>
         selected.iter().map(|id| id.0).collect()
     } else {
         // One unselected item goes through as is, so a folder or data file still gets the
-        // engine's error instead of a silent no-op.
-        return vec![dragged];
+        // engine's error instead of a silent no-op. The composition the drop lands in is the
+        // one case that never reaches it, selected or not (#2589).
+        return if Some(ItemId(dragged)) == target { Vec::new() } else { vec![dragged] };
     };
     candidates
         .into_iter()
         .filter(|id| {
+            if Some(ItemId(*id)) == target {
+                return false;
+            }
             app.session.project.item(ItemId(*id)).is_some_and(|item| match &item.kind {
                 ItemKind::Comp(_) | ItemKind::Solid(_) => true,
                 ItemKind::Footage(f) => f.kind != FootageKind::Data,
@@ -175,6 +183,82 @@ pub(crate) fn space_hand(ctx: &egui::Context) -> bool {
     ctx.input(|i| i.key_down(egui::Key::Space)) && !ctx.egui_wants_keyboard_input()
 }
 
+/// What a scroll gesture over a viewer (Composition, Layer) does this frame.
+pub(crate) struct ViewerScroll {
+    /// Points to pan by: a two-finger trackpad scroll.
+    pub pan: egui::Vec2,
+    /// Factor to zoom by around the pointer: a pinch, Ctrl/Cmd+scroll, a mouse wheel, or
+    /// Alt + a trackpad scroll.
+    pub zoom: f32,
+    /// The gesture came from a trackpad (or is still the smoothed tail of one).
+    pub trackpad: bool,
+    /// Unmodified mouse-wheel lines this frame. Zero for a trackpad, a point-unit wheel, or
+    /// Ctrl/Cmd/Alt+wheel.
+    pub wheel_lines: f32,
+    /// This frame has a Ctrl/Cmd/Alt mouse-wheel event, which keeps zooming.
+    pub wheel_modified: bool,
+}
+
+/// Splits the frame's scroll input into a viewer pan and a zoom: a mouse wheel zooms and a
+/// trackpad's two-finger scroll pans.
+///
+/// Where the platform names the device (`MouseWheelSource`, macOS), that decides. Elsewhere a
+/// wheel scrolls in lines, but in a browser and with some high-resolution wheels it scrolls in
+/// points like a trackpad does, so the unit alone doesn't tell them apart. A scroll in points is
+/// a trackpad's once it has shown what a wheel can't do: a touch phase, movement on both axes at
+/// once, or a pinch. That holds until a wheel scrolls in lines. Until then the vertical part
+/// zooms; the horizontal part always pans.
+pub(crate) fn viewer_scroll(ctx: &egui::Context) -> ViewerScroll {
+    let id = egui::Id::unique("viewer-scroll-trackpad");
+    // The scroll is smoothed over the frames after its event, so the device is remembered.
+    let was: bool = ctx.data(|d| d.get_temp(id)).unwrap_or(false);
+    let trackpad = ctx.input(|i| {
+        i.events.iter().fold(was, |t, e| match e {
+            egui::Event::MouseWheel { source: egui::MouseWheelSource::Trackpad | egui::MouseWheelSource::Momentum, .. } => true,
+            egui::Event::MouseWheel { source: egui::MouseWheelSource::Wheel, .. } => false,
+            egui::Event::MouseWheel { unit: egui::MouseWheelUnit::Point, delta, phase, modifiers, .. } => {
+                // Shift turns a wheel's scroll sideways, which is still one axis.
+                t || *phase == egui::TouchPhase::Start || (delta.x != 0.0 && delta.y != 0.0 && !modifiers.shift)
+            }
+            egui::Event::MouseWheel { .. } => false,
+            egui::Event::Zoom(_) => true,
+            _ => t,
+        })
+    });
+    if trackpad != was {
+        ctx.data_mut(|d| d.insert_temp(id, trackpad));
+    }
+    let (scroll, pinch, alt) = ctx.input(|i| (i.smooth_scroll_delta, i.zoom_delta(), i.modifiers.alt));
+    let pinch = if pinch.is_finite() && pinch > 0.0 { pinch } else { 1.0 };
+    let scroll = if scroll.x.is_finite() && scroll.y.is_finite() { scroll } else { egui::Vec2::ZERO };
+    let (wheel_lines, wheel_modified) = ctx.input(|i| {
+        let mut lines = 0.0;
+        let mut modified = false;
+        if !trackpad {
+            for event in &i.events {
+                if let egui::Event::MouseWheel { unit: egui::MouseWheelUnit::Line, delta, modifiers, source, .. } = event
+                    && !matches!(source, egui::MouseWheelSource::Trackpad | egui::MouseWheelSource::Momentum)
+                {
+                    if modifiers.command || modifiers.ctrl || modifiers.alt {
+                        modified = true;
+                    } else {
+                        lines += delta.y;
+                    }
+                }
+            }
+        }
+        (lines, modified)
+    });
+    let (pan, zoom) = if trackpad && !alt {
+        (scroll, pinch)
+    } else if alt {
+        (egui::Vec2::ZERO, pinch * (scroll.y / 300.0).exp())
+    } else {
+        (egui::vec2(scroll.x, 0.0), pinch * (scroll.y / 300.0).exp())
+    };
+    ViewerScroll { pan, zoom, trackpad, wheel_lines, wheel_modified }
+}
+
 pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: PanelKind, rect: Rect) {
     match p {
         PanelKind::Composition => viewers::show(app, ui, 0, rect),
@@ -216,29 +300,47 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: PanelKind, rect: Rec
     }
 }
 
-/// The ≡ panel menu (opened from a tab).
+/// The open ≡ panel menu: the panel, where it opens and the viewport that owns the click.
+pub(crate) type OpenPanelMenu = (PanelKind, egui::Pos2, egui::ViewportId);
+
+/// The main window's pass of the ≡ panel menu (opened from a tab).
 pub fn panel_menu_popup(app: &mut EffectcraftApp, ui: &mut egui::Ui) {
+    panel_menu_area(app, ui);
+}
+
+/// The ≡ panel menu, drawn in the viewport that owns the click that opened it: a panel in its own
+/// OS window opens its menu in that window, at that window's coordinates, instead of in the main
+/// window.
+pub(crate) fn panel_menu_area(app: &mut EffectcraftApp, ui: &mut egui::Ui) {
     let id = egui::Id::unique("panel-menu");
-    let Some((panel, pos)) = ui.ctx().data(|d| d.get_temp::<(PanelKind, egui::Pos2)>(id)) else { return };
-    // The menu opens in the window that shows the panel (a panel can have its own window).
-    if app.panel_viewport(ui.ctx(), panel) != ui.ctx().viewport_id() {
+    let viewport = ui.ctx().viewport_id();
+    let Some((panel, pos, owner)) = ui.ctx().data(|d| d.get_temp::<OpenPanelMenu>(id)) else { return };
+    if owner != viewport {
+        // a press in another window dismisses the menu, as a press elsewhere in its own does
+        if ui.ctx().input(|i| i.pointer.any_pressed()) {
+            ui.ctx().data_mut(|d| d.remove::<OpenPanelMenu>(id));
+        }
         return;
     }
     let mut close = false;
     let area = egui::Area::new(id.with("area")).order(egui::Order::Foreground).fixed_pos(pos).show(ui.ctx(), |ui| {
         egui::Frame::popup(ui.style()).show(ui, |ui| {
-            ui.set_min_width(200.0);
+            // a small window (a floated panel can be narrower than the menu) gets the menu at its width
+            let width = (ui.ctx().content_rect().width() - 16.0).max(0.0);
+            ui.set_min_width(200.0_f32.min(width));
+            ui.set_max_width(width);
             if ui.button(tr("Close Panel")).clicked() {
                 let _ = app.dock_command(ui.ctx(), craft_ui::docking::Action::Close { panel });
                 close = true;
             }
-            let floating = app.ui.floating.iter().any(|f| f.panels.contains(&panel));
+            let floating = crate::dock::WorkspaceExt::is_floating(&app.ui.dock, panel);
             if !floating && ui.button(tr("Undock Panel")).clicked() {
                 let r = crate::dock_ui::default_float_rect(ui.ctx().content_rect());
                 let _ = app.dock_command(ui.ctx(), craft_ui::docking::Action::Float { panel, rect: r });
                 close = true;
             }
-            // Multiple monitors: a native window of its own, which can go on another screen.
+            // Multiple monitors: an OS window of its own, which can go on another screen. Where
+            // egui embeds viewports (the web), floating windows stay in the page.
             if !ui.ctx().embed_viewports() {
                 let windowed = app.in_panel_window(panel);
                 if ui.button(if windowed { tr("Move Panel to Main Window") } else { tr("Move Panel to New Window") }).clicked() {
@@ -284,13 +386,13 @@ pub fn panel_menu_popup(app: &mut EffectcraftApp, ui: &mut egui::Ui) {
                     }
                 }
                 _ => {
-                    ui.label(egui::RichText::new(panel.title()).weak());
+                    ui.label(egui::RichText::new(crate::i18n::label(app, "window.panel", panel.title())).weak());
                 }
             }
         });
     });
     if close || crate::widgets::pressed_outside(ui.ctx(), &area.response) {
-        ui.ctx().data_mut(|d| d.remove::<(PanelKind, egui::Pos2)>(id));
+        ui.ctx().data_mut(|d| d.remove::<OpenPanelMenu>(id));
     }
 }
 
@@ -308,3 +410,108 @@ mod preset_drop_tests {
         assert_eq!(PresetRef::Text("typewriter".into()).command(), ("layer.applyTextPreset", json!({"preset": "typewriter"})));
     }
 }
+
+#[cfg(test)]
+mod panel_menu_viewport_tests {
+    use super::*;
+    use effectcraft_engine::Session;
+
+    fn menu_id() -> egui::Id {
+        egui::Id::unique("panel-menu")
+    }
+
+    fn open(ctx: &egui::Context, owner: egui::ViewportId) {
+        ctx.data_mut(|d| d.insert_temp::<OpenPanelMenu>(menu_id(), (PanelKind::Timeline, egui::pos2(20.0, 20.0), owner)));
+    }
+
+    fn is_open(ctx: &egui::Context) -> bool {
+        ctx.data(|d| d.get_temp::<OpenPanelMenu>(menu_id())).is_some()
+    }
+
+    /// One pass of `viewport` (a window `width` wide) that draws the menu as the app does: the
+    /// main window through `panel_menu_popup`, a panel's own window through `panel_menu_area`.
+    /// Returns where the menu was drawn in that pass.
+    fn pass(app: &mut EffectcraftApp, ctx: &egui::Context, viewport: egui::ViewportId, width: f32, events: Vec<egui::Event>) -> Option<egui::Rect> {
+        let mut viewports = egui::ViewportIdMap::default();
+        viewports.insert(viewport, egui::ViewportInfo::default());
+        let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(width, 400.0));
+        let raw = egui::RawInput { viewport_id: viewport, viewports, screen_rect: Some(screen), events, ..Default::default() };
+        let mut drawn = None;
+        let mut out = ctx.run_ui(raw, |ui| {
+            if viewport == egui::ViewportId::ROOT {
+                panel_menu_popup(app, ui);
+            } else {
+                panel_menu_area(app, ui);
+            }
+            drawn = ui.ctx().memory(|m| m.area_rect(menu_id().with("area")));
+        });
+        out.textures_delta.clear();
+        drawn
+    }
+
+    fn window() -> egui::ViewportId {
+        egui::ViewportId::from_hash_of("panel-window")
+    }
+
+    fn press(pos: egui::Pos2) -> Vec<egui::Event> {
+        vec![
+            egui::Event::PointerMoved(pos),
+            egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE },
+        ]
+    }
+
+    #[test]
+    fn a_floating_panels_menu_is_drawn_in_its_own_window_not_the_main_one() {
+        let mut app = EffectcraftApp::new(Session::default());
+        let ctx = egui::Context::default();
+        open(&ctx, window());
+        assert_eq!(pass(&mut app, &ctx, egui::ViewportId::ROOT, 1000.0, vec![]), None, "the main window does not draw it");
+        assert!(is_open(&ctx), "and does not drop it");
+        let rect = pass(&mut app, &ctx, window(), 1000.0, vec![]).expect("the panel's window draws it");
+        assert!((rect.min.x - 20.0).abs() < 1.0, "it opens at the window-local position: {rect:?}");
+    }
+
+    #[test]
+    fn a_main_window_panels_menu_stays_in_the_main_window() {
+        let mut app = EffectcraftApp::new(Session::default());
+        let ctx = egui::Context::default();
+        open(&ctx, egui::ViewportId::ROOT);
+        assert!(pass(&mut app, &ctx, window(), 1000.0, vec![]).is_none());
+        assert!(pass(&mut app, &ctx, egui::ViewportId::ROOT, 1000.0, vec![]).is_some());
+    }
+
+    #[test]
+    fn a_floating_panels_menu_fits_a_window_narrower_than_the_menu() {
+        let mut app = EffectcraftApp::new(Session::default());
+        let ctx = egui::Context::default();
+        open(&ctx, window());
+        let rect = pass(&mut app, &ctx, window(), 160.0, vec![]).unwrap();
+        assert!(rect.max.x <= 160.5, "the menu fits the 160 pt window: {rect:?}");
+    }
+
+    #[test]
+    fn a_press_in_another_window_closes_a_floating_panels_menu() {
+        let mut app = EffectcraftApp::new(Session::default());
+        let ctx = egui::Context::default();
+        open(&ctx, window());
+        pass(&mut app, &ctx, window(), 1000.0, vec![]);
+        assert!(is_open(&ctx));
+        pass(&mut app, &ctx, egui::ViewportId::ROOT, 1000.0, press(egui::pos2(600.0, 300.0)));
+        assert!(!is_open(&ctx), "a click in the main window dismisses it");
+    }
+
+    #[test]
+    fn a_menu_left_in_a_closed_window_is_dropped() {
+        let ctx = egui::Context::default();
+        let other = egui::ViewportId::from_hash_of("other-window");
+        open(&ctx, window());
+        crate::dock_ui::drop_menu_of_closed_window(&ctx, &[other]);
+        assert!(!is_open(&ctx), "its window is gone");
+        open(&ctx, window());
+        crate::dock_ui::drop_menu_of_closed_window(&ctx, &[window()]);
+        assert!(is_open(&ctx), "its window is still there");
+        open(&ctx, egui::ViewportId::ROOT);
+        crate::dock_ui::drop_menu_of_closed_window(&ctx, &[]);
+        assert!(is_open(&ctx), "the main window is always there");
+    }
+}
diff --git a/crates/ui-egui/src/panels/anim_tools.rs b/crates/ui-egui/src/panels/anim_tools.rs
index 17a69b807..67ae71c0b 100644
--- a/crates/ui-egui/src/panels/anim_tools.rs
+++ b/crates/ui-egui/src/panels/anim_tools.rs
@@ -31,17 +31,21 @@ fn choice(app: &mut EffectcraftApp, ui: &mut egui::Ui, r: Rect, auto: &str, opti
     widgets::popup_menu(ui, id, r.left_bottom(), &opts, Some(cur)).filter(|i| *i != cur)
 }
 
-fn number(app: &mut EffectcraftApp, ui: &mut egui::Ui, at: egui::Pos2, auto: &str, v: f64, speed: f64, range: (f64, f64), dec: usize, suffix: &str) -> f64 {
+/// A drag-to-change number field for an anim-tool setting: `v` clamped to `range`, `speed` points
+/// per pixel, `dec` decimals and a `suffix`; returns the new value, or `v` when it did not change.
+fn number(app: &mut EffectcraftApp, ui: &mut egui::Ui, at: egui::Pos2, auto: &str, v: f64, spec: widgets::HotSpec) -> f64 {
     let t = app.tokens;
-    let (r, nv, _) = widgets::hot_number_at(ui, at, egui::Id::unique(("animtool-n", auto)), v, speed, range, dec, suffix, &t);
+    let (r, nv, _) = widgets::hot_number_at(ui, at, egui::Id::unique(("animtool-n", auto)), v, &spec, &t);
     app.auto.add(auto, r, &format!("{v}"));
     nv.unwrap_or(v)
 }
 
+/// A checkbox at `at` with its `text` label drawn to its right; returns the state to store, i.e.
+/// `!on` when it was clicked and `on` otherwise.
 fn checkbox(app: &mut EffectcraftApp, ui: &mut egui::Ui, at: egui::Pos2, auto: &str, text: &str, on: bool) -> bool {
     let t = app.tokens;
     let r = Rect::from_min_size(at, vec2(16.0, 16.0));
-    let clicked = widgets::checkbox(ui, r, on, &t, egui::Id::unique(("animtool-cb", auto))).clicked();
+    let clicked = widgets::checkbox(ui, r, on, &t, egui::Id::unique(("animtool-cb", auto))).changed();
     ui.painter().text(pos2(r.max.x + 6.0, r.center().y), Align2::LEFT_CENTER, text, Tokens::ui(12.0), t.text);
     app.auto.add(auto, r, text);
     if clicked { !on } else { on }
@@ -101,15 +105,29 @@ pub fn wiggler(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     y += ROW + 4.0;
     label(&p, x0, y, "Frequency:", &t);
-    st.wiggle_frequency = number(app, ui, pos2(xv, y), "wiggler.frequency", st.wiggle_frequency, 0.1, (0.1, 100.0), 1, " per second");
+    st.wiggle_frequency = number(
+        app,
+        ui,
+        pos2(xv, y),
+        "wiggler.frequency",
+        st.wiggle_frequency,
+        widgets::HotSpec { speed: 0.1, range: (0.1, 100.0), decimals: 1, suffix: " per second" },
+    );
     y += ROW;
     label(&p, x0, y, "Magnitude:", &t);
-    st.wiggle_magnitude = number(app, ui, pos2(xv, y), "wiggler.magnitude", st.wiggle_magnitude, 0.5, (0.0, 100_000.0), 1, "");
+    st.wiggle_magnitude = number(
+        app,
+        ui,
+        pos2(xv, y),
+        "wiggler.magnitude",
+        st.wiggle_magnitude,
+        widgets::HotSpec { speed: 0.5, range: (0.0, 100_000.0), decimals: 1, suffix: "" },
+    );
     y += ROW + 8.0;
     app.ui.anim_tools = st.clone();
     let b = Rect::from_min_size(pos2(rect.max.x - 92.0, y), vec2(80.0, 24.0));
     let enabled = app.session.state.selected_keys.len() >= 2;
-    if widgets::text_button(ui, b, "Apply", enabled, &t, egui::Id::unique("wg-apply")).clicked() {
+    if widgets::text_button(ui, b, crate::i18n::tr("Apply"), enabled, &t, egui::Id::unique("wg-apply")).clicked() {
         let params = json!({
             "apply": if st.wiggle_spatial { "spatial" } else { "temporal" },
             "noise": if st.wiggle_smooth { "smooth" } else { "jagged" },
@@ -145,12 +163,19 @@ pub fn smoother(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     p.text(pos2(xv, y + 9.0), Align2::LEFT_CENTER, txt, Tokens::ui(12.0), t.text);
     y += ROW;
     label(&p, x0, y, "Tolerance:", &t);
-    let tol = number(app, ui, pos2(xv, y), "smoother.tolerance", app.ui.anim_tools.smooth_tolerance, 0.05, (0.0, 10_000.0), 2, "");
+    let tol = number(
+        app,
+        ui,
+        pos2(xv, y),
+        "smoother.tolerance",
+        app.ui.anim_tools.smooth_tolerance,
+        widgets::HotSpec { speed: 0.05, range: (0.0, 10_000.0), decimals: 2, suffix: "" },
+    );
     app.ui.anim_tools.smooth_tolerance = tol;
     y += ROW + 8.0;
     let b = Rect::from_min_size(pos2(rect.max.x - 92.0, y), vec2(80.0, 24.0));
     let enabled = app.session.state.selected_keys.len() >= 3;
-    if widgets::text_button(ui, b, "Apply", enabled, &t, egui::Id::unique("sm-apply")).clicked() {
+    if widgets::text_button(ui, b, crate::i18n::tr("Apply"), enabled, &t, egui::Id::unique("sm-apply")).clicked() {
         apply(app, "keys.smooth", json!({"tolerance": tol}));
     }
     app.auto.add("smoother.apply", b, "Apply");
@@ -166,10 +191,24 @@ pub fn motion_sketch(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let mut y = rect.min.y + 10.0;
     let mut st = app.ui.anim_tools.clone();
     label(&p, x0, y, "Capture speed at:", &t);
-    st.sketch_speed = number(app, ui, pos2(xv, y), "motionSketch.captureSpeed", st.sketch_speed, 1.0, (1.0, 10_000.0), 0, " %");
+    st.sketch_speed = number(
+        app,
+        ui,
+        pos2(xv, y),
+        "motionSketch.captureSpeed",
+        st.sketch_speed,
+        widgets::HotSpec { speed: 1.0, range: (1.0, 10_000.0), decimals: 0, suffix: " %" },
+    );
     y += ROW;
     label(&p, x0, y, "Smoothing:", &t);
-    st.sketch_smoothing = number(app, ui, pos2(xv, y), "motionSketch.smoothing", st.sketch_smoothing, 0.1, (0.0, 100.0), 1, "");
+    st.sketch_smoothing = number(
+        app,
+        ui,
+        pos2(xv, y),
+        "motionSketch.smoothing",
+        st.sketch_smoothing,
+        widgets::HotSpec { speed: 0.1, range: (0.0, 100.0), decimals: 1, suffix: "" },
+    );
     y += ROW + 2.0;
     p.text(pos2(x0, y + 8.0), Align2::LEFT_CENTER, tr("Show:"), Tokens::ui(12.0), t.text_dim);
     y += ROW - 6.0;
@@ -218,6 +257,8 @@ struct Capture {
     points: Vec<[f64; 3]>,
 }
 
+/// The `egui::Id` of the Motion Sketch capture in progress ([`Capture`]): its start time and the
+/// recorded points.
 fn capture_id() -> egui::Id {
     egui::Id::unique("motion-sketch-capture")
 }
@@ -322,12 +363,19 @@ pub fn mask_interpolation(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rec
         changes.insert("keyframeRate".into(), if i == 0 { json!("auto") } else { json!(fps) });
     }
     if let Some(r) = o.keyframe_rate {
-        let nr = number(app, ui, pos2(xv + 78.0, y), "maskInterp.rate", r, 0.5, (0.1, 1000.0), 1, " per second");
+        let nr = number(
+            app,
+            ui,
+            pos2(xv + 78.0, y),
+            "maskInterp.rate",
+            r,
+            widgets::HotSpec { speed: 0.5, range: (0.1, 1000.0), decimals: 1, suffix: " per second" },
+        );
         if (nr - r).abs() > 1e-9 {
             changes.insert("keyframeRate".into(), json!(nr));
         }
     } else {
-        p.text(pos2(xv + 78.0, y + 9.0), Align2::LEFT_CENTER, "per second", Tokens::ui(12.0), t.text_dim);
+        p.text(pos2(xv + 78.0, y + 9.0), Align2::LEFT_CENTER, crate::i18n::tr("per second"), Tokens::ui(12.0), t.text_dim);
     }
     y += ROW;
     let mut check = |app: &mut EffectcraftApp, y: f32, key: &str, text: &str, on: bool| {
@@ -340,13 +388,20 @@ pub fn mask_interpolation(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rec
     check(app, y, "linearVertexPaths", "Use \"Linear\" Vertex Paths", o.linear_vertex_paths);
     y += ROW;
     label(&p, x0, y, "Bending Resistance:", &t);
-    let br = number(app, ui, pos2(xv, y), "maskInterp.bendingResistance", o.bending_resistance, 0.5, (0.0, 100.0), 0, "");
+    let br = number(
+        app,
+        ui,
+        pos2(xv, y),
+        "maskInterp.bendingResistance",
+        o.bending_resistance,
+        widgets::HotSpec { speed: 0.5, range: (0.0, 100.0), decimals: 0, suffix: "" },
+    );
     if (br - o.bending_resistance).abs() > 1e-9 {
         changes.insert("bendingResistance".into(), json!(br));
     }
     y += ROW;
     label(&p, x0, y, "Quality:", &t);
-    let q = number(app, ui, pos2(xv, y), "maskInterp.quality", o.quality, 0.5, (0.0, 100.0), 0, "");
+    let q = number(app, ui, pos2(xv, y), "maskInterp.quality", o.quality, widgets::HotSpec { speed: 0.5, range: (0.0, 100.0), decimals: 0, suffix: "" });
     if (q - o.quality).abs() > 1e-9 {
         changes.insert("quality".into(), json!(q));
     }
@@ -357,7 +412,8 @@ pub fn mask_interpolation(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rec
     }
     y += ROW;
     if let Some(v) = o.add_vertices {
-        let nv = number(app, ui, pos2(x0 + 22.0, y), "maskInterp.addVertices", v, 0.2, (0.1, 2000.0), 1, "");
+        let nv =
+            number(app, ui, pos2(x0 + 22.0, y), "maskInterp.addVertices", v, widgets::HotSpec { speed: 0.2, range: (0.1, 2000.0), decimals: 1, suffix: "" });
         if (nv - v).abs() > 1e-9 {
             changes.insert("addVertices".into(), json!(nv));
         }
@@ -398,7 +454,7 @@ pub fn mask_interpolation(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rec
     }
     let b = Rect::from_min_size(pos2(rect.max.x - 92.0, y), vec2(80.0, 24.0));
     let enabled = app.session.state.selected_keys.len() >= 2;
-    if widgets::text_button(ui, b, "Apply", enabled, &t, egui::Id::unique("mi-apply")).clicked() {
+    if widgets::text_button(ui, b, crate::i18n::tr("Apply"), enabled, &t, egui::Id::unique("mi-apply")).clicked() {
         match app.session.execute("mask.interpolate", json!({})) {
             Ok(r) => app.ui.status = format!("Mask Interpolation: {} keyframes added ({} vertices)", r["keys"], r["vertices"]),
             Err(e) => app.ui.status = e.to_string(),
diff --git a/crates/ui-egui/src/panels/camera_tracker_ui.rs b/crates/ui-egui/src/panels/camera_tracker_ui.rs
index bca98ea4b..80932f490 100644
--- a/crates/ui-egui/src/panels/camera_tracker_ui.rs
+++ b/crates/ui-egui/src/panels/camera_tracker_ui.rs
@@ -413,12 +413,12 @@ pub fn editor(
     let b1 = Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 4.0), vec2(84.0, 22.0));
     let b2 = Rect::from_min_size(pos2(b1.max.x + 8.0, b1.min.y), vec2(84.0, 22.0));
     let b3 = Rect::from_min_size(pos2(b2.max.x + 8.0, b1.min.y), vec2(110.0, 22.0));
-    if widgets::text_button(ui, b1, "Analyze", false, &t, egui::Id::unique(("ct-analyze", g.uid))).clicked() && !busy {
+    if widgets::text_button(ui, b1, crate::i18n::tr("Analyze"), false, &t, egui::Id::unique(("ct-analyze", g.uid))).clicked() && !busy {
         actions.push(("camera.analyze".into(), me.clone()));
     }
     app.auto.add(&format!("effectControls.cameraTracker.{}.analyze", g.uid), b1, "Analyze");
     if running {
-        if widgets::text_button(ui, b2, "Cancel", false, &t, egui::Id::unique(("ct-cancel", g.uid))).clicked() {
+        if widgets::text_button(ui, b2, crate::i18n::tr("Cancel"), false, &t, egui::Id::unique(("ct-cancel", g.uid))).clicked() {
             actions.push(("camera.cancel".into(), json!({})));
         }
         app.auto.add(&format!("effectControls.cameraTracker.{}.cancel", g.uid), b2, "Cancel");
@@ -426,10 +426,15 @@ pub fn editor(
     let params = effectcraft_engine::camera_track::static_params(g);
     let solve = ct::solve(&params);
     if solve.is_some() {
-        if widgets::text_button(ui, b3, "Create Camera", false, &t, egui::Id::unique(("ct-camera", g.uid))).clicked() {
+        if widgets::text_button(ui, b3, crate::i18n::tr("Create Camera"), false, &t, egui::Id::unique(("ct-camera", g.uid))).clicked() {
             actions.push(("camera.create".into(), me.clone()));
         }
         app.auto.add(&format!("effectControls.cameraTracker.{}.createCamera", g.uid), b3, "Create Camera");
+        let export = Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 70.0), vec2(218.0, 22.0));
+        if widgets::text_button(ui, export, tr("Export Scene to Blender..."), false, &t, egui::Id::unique(("ct-blender", g.uid))).clicked() && !busy {
+            actions.push(("camera.exportBlender".into(), me.clone()));
+        }
+        app.auto.add(&format!("effectControls.cameraTracker.{}.exportBlender", g.uid), export, "Export Scene to Blender...");
     }
     let status = match app.session.camera_progress() {
         Some(pr) if running => pr.banner(),
@@ -457,4 +462,4 @@ pub fn editor(
 }
 
 /// Height of [`editor`].
-pub const EDITOR_HEIGHT: f32 = 68.0;
+pub const EDITOR_HEIGHT: f32 = 100.0;
diff --git a/crates/ui-egui/src/panels/comp_settings.rs b/crates/ui-egui/src/panels/comp_settings.rs
index 6aff37823..7e49d8a7d 100644
--- a/crates/ui-egui/src/panels/comp_settings.rs
+++ b/crates/ui-egui/src/panels/comp_settings.rs
@@ -181,6 +181,8 @@ fn timecode_field(ui: &mut egui::Ui, buf: &mut Option<String>, secs: &mut f64, r
     r
 }
 
+/// The temp-data id of the one-shot flag that makes the Save Preset name field take focus when
+/// it is next drawn.
 fn name_focus_id() -> egui::Id {
     egui::Id::unique("comp-preset-name-focus")
 }
@@ -244,36 +246,18 @@ fn matches(d: &CompDraft, w: u32, h: u32, par: f64, fps: f64) -> bool {
     w == d.width && h == d.height && (par - d.pixel_aspect).abs() < 1e-3 && (fps - d.fps).abs() < 1e-3
 }
 
-/// Draw the dialog. Returns `Some(params)` when OK is pressed, `Some(Null)` on Cancel. `custom`
-/// are the presets the user saved; saving or deleting one pushes its engine command to `cmds`.
-pub fn show(
+/// The controls of one tab.
+fn tab_body(
     ui: &mut egui::Ui,
+    tab: Tab,
     d: &mut CompDraft,
     t: &Tokens,
     auto: &mut Registry,
     custom: &[CompPreset],
     cmds: &mut Vec<(&'static str, serde_json::Value)>,
-) -> Option<serde_json::Value> {
-    let mut out = None;
-    ui.horizontal(|ui| {
-        ui.label(tr("Composition Name:"));
-        let r = ui.add(egui::TextEdit::singleline(&mut d.name).desired_width(300.0));
-        crate::widgets::focus_on_open(ui.ctx(), &r, &d.name);
-        auto.add("dialog.comp.name", r.rect, "Composition Name");
-    });
-    ui.add_space(8.0);
-    ui.horizontal(|ui| {
-        for (tab, label, key) in [(Tab::Basic, "Basic", "basic"), (Tab::Advanced, "Advanced", "advanced"), (Tab::Renderer, "3D Renderer", "renderer")] {
-            let r = ui.selectable_label(d.tab == tab, label);
-            auto.add(&format!("dialog.comp.tab.{key}"), r.rect, label);
-            if r.clicked() {
-                d.tab = tab;
-            }
-        }
-    });
-    ui.separator();
+) {
     let rate = FrameRate::from_f64(d.fps);
-    match d.tab {
+    match tab {
         Tab::Basic => {
             egui::Grid::new("comp-basic").num_columns(2).spacing([12.0, 9.0]).show(ui, |ui| {
                 ui.label(tr("Preset:"));
@@ -284,7 +268,7 @@ pub fn show(
                     .or_else(|| PRESETS.iter().find(|(_, w, h, par, f)| matches(d, *w, *h, *par, *f)).map(|p| p.0))
                     .unwrap_or("Custom");
                 ui.horizontal(|ui| {
-                    let r = egui::ComboBox::from_id_salt("comp-preset").width(300.0).selected_text(current).show_ui(ui, |ui| {
+                    let r = craft_ui::ComboBox::from_id_salt("comp-preset").width(300.0).selected_text(current).show_ui(ui, |ui| {
                         // Your own presets first, then the built-in ones.
                         for q in custom {
                             if ui.selectable_label(q.name == current, &q.name).clicked() {
@@ -325,8 +309,8 @@ pub fn show(
                     let (ow, oh) = (d.width, d.height);
                     let r = ui.add(crate::widgets::drag_value(egui::DragValue::new(&mut d.width).range(4..=30000).suffix(" px")));
                     auto.add("dialog.comp.width", r.rect, "Width");
-                    let lbl = format!("Lock Aspect Ratio to {}", aspect_label(ow as f64, oh as f64));
-                    let r = ui.checkbox(&mut d.lock_aspect, lbl);
+                    let lbl = tr_args("Lock Aspect Ratio to {}", &[&(aspect_label(ow as f64, oh as f64))]);
+                    let r = crate::widgets::labelled_checkbox(ui, &mut d.lock_aspect, lbl);
                     auto.add("dialog.comp.lockAspect", r.rect, "Lock Aspect Ratio");
                     if d.lock_aspect && ow != d.width && ow > 0 {
                         d.height = ((d.width as f64) * oh as f64 / ow as f64).round().max(4.0) as u32;
@@ -346,11 +330,11 @@ pub fn show(
                     let cur = PIXEL_ASPECTS
                         .iter()
                         .find(|(_, v)| (v - d.pixel_aspect).abs() < 1e-3)
-                        .map(|p| p.0.to_string())
+                        .map(|p| tr(p.0).to_string())
                         .unwrap_or_else(|| format!("{:.2}", d.pixel_aspect));
-                    let r = egui::ComboBox::from_id_salt("comp-par").width(220.0).selected_text(cur).show_ui(ui, |ui| {
+                    let r = craft_ui::ComboBox::from_id_salt("comp-par").width(220.0).selected_text(cur).show_ui(ui, |ui| {
                         for (name, v) in PIXEL_ASPECTS {
-                            if ui.selectable_label((v - d.pixel_aspect).abs() < 1e-3, *name).clicked() {
+                            if ui.selectable_label((v - d.pixel_aspect).abs() < 1e-3, tr(name)).clicked() {
                                 d.pixel_aspect = *v;
                             }
                         }
@@ -367,7 +351,7 @@ pub fn show(
                     // Any rate can be typed; the list holds the common ones.
                     let r = ui.add(crate::widgets::drag_value(egui::DragValue::new(&mut d.fps).range(1.0..=999.0).speed(0.01).max_decimals(3)));
                     auto.add("dialog.comp.frameRate", r.rect, "Frame Rate");
-                    let r = egui::ComboBox::from_id_salt("comp-fps").width(18.0).selected_text("").show_ui(ui, |ui| {
+                    let r = craft_ui::ComboBox::from_id_salt("comp-fps").width(18.0).selected_text("").show_ui(ui, |ui| {
                         for f in FRAME_RATES {
                             if ui.selectable_label((d.fps - f).abs() < 1e-3, format!("{f}")).clicked() {
                                 d.fps = *f;
@@ -385,7 +369,7 @@ pub fn show(
                 // the frame it renders beside it.
                 ui.label(tr("Resolution:"));
                 ui.horizontal(|ui| {
-                    let r = egui::ComboBox::from_id_salt("comp-resolution").width(90.0).selected_text(tr(d.resolution.label())).show_ui(ui, |ui| {
+                    let r = craft_ui::ComboBox::from_id_salt("comp-resolution").width(90.0).selected_text(tr(d.resolution.label())).show_ui(ui, |ui| {
                         for res in Resolution::ALL {
                             ui.selectable_value(&mut d.resolution, res, tr(res.label()));
                         }
@@ -418,7 +402,7 @@ pub fn show(
                 ui.horizontal(|ui| {
                     let r = crate::widgets::srgb_color_button(ui, &mut d.bg);
                     auto.add("dialog.comp.background", r.rect, "Background Color");
-                    ui.label(color_name(d.bg));
+                    ui.label(tr(color_name(d.bg)));
                 });
                 ui.end_row();
             });
@@ -442,11 +426,11 @@ pub fn show(
                 });
                 ui.end_row();
                 ui.label("");
-                let r = ui.checkbox(&mut d.preserve_frame_rate, tr("Preserve frame rate when nested or in render queue"));
+                let r = crate::widgets::labelled_checkbox(ui, &mut d.preserve_frame_rate, tr("Preserve frame rate when nested or in render queue"));
                 auto.add("dialog.comp.preserveFrameRate", r.rect, "Preserve frame rate when nested or in render queue");
                 ui.end_row();
                 ui.label("");
-                let r = ui.checkbox(&mut d.preserve_resolution, tr("Preserve resolution when nested"));
+                let r = crate::widgets::labelled_checkbox(ui, &mut d.preserve_resolution, tr("Preserve resolution when nested"));
                 auto.add("dialog.comp.preserveResolution", r.rect, "Preserve resolution when nested");
                 ui.end_row();
                 ui.label(egui::RichText::new(tr("Motion Blur")).strong());
@@ -472,7 +456,7 @@ pub fn show(
         Tab::Renderer => {
             ui.horizontal(|ui| {
                 ui.label(tr("Renderer:"));
-                let r = egui::ComboBox::from_id_salt("comp-renderer").selected_text(tr(if d.advanced_3d { "Advanced 3D" } else { "Classic 3D" })).show_ui(
+                let r = craft_ui::ComboBox::from_id_salt("comp-renderer").selected_text(tr(if d.advanced_3d { "Advanced 3D" } else { "Classic 3D" })).show_ui(
                     ui,
                     |ui| {
                         ui.selectable_value(&mut d.advanced_3d, false, tr("Classic 3D"));
@@ -483,6 +467,55 @@ pub fn show(
             });
         }
     }
+}
+
+/// The height `tab` would take at `top`, from laying it out unseen: it follows the font, the
+/// language and the scale. Nothing it registers or changes is kept.
+fn tab_height(ui: &mut egui::Ui, tab: Tab, d: &CompDraft, t: &Tokens, custom: &[CompPreset], top: f32) -> f32 {
+    let rect = egui::Rect::from_min_size(egui::pos2(ui.max_rect().left(), top), vec2(ui.max_rect().width(), 0.0));
+    let mut child = ui.new_child(egui::UiBuilder::new().max_rect(rect).id_salt("comp-tab-measure").invisible());
+    tab_body(&mut child, tab, &mut d.clone(), t, &mut Registry::default(), custom, &mut Vec::new());
+    child.cursor().top() - top
+}
+
+/// Draw the dialog. Returns `Some(params)` when OK is pressed, `Some(Null)` on Cancel. `custom`
+/// are the presets the user saved; saving or deleting one pushes its engine command to `cmds`.
+pub fn show(
+    ui: &mut egui::Ui,
+    d: &mut CompDraft,
+    t: &Tokens,
+    auto: &mut Registry,
+    custom: &[CompPreset],
+    cmds: &mut Vec<(&'static str, serde_json::Value)>,
+    preview: Option<&mut bool>,
+) -> Option<serde_json::Value> {
+    let mut out = None;
+    ui.horizontal(|ui| {
+        ui.label(tr("Composition Name:"));
+        let r = ui.add(egui::TextEdit::singleline(&mut d.name).desired_width(300.0));
+        crate::widgets::focus_on_open(ui.ctx(), &r, &d.name);
+        auto.add("dialog.comp.name", r.rect, "Composition Name");
+    });
+    ui.add_space(8.0);
+    ui.horizontal(|ui| {
+        for (tab, label, key) in [(Tab::Basic, "Basic", "basic"), (Tab::Advanced, "Advanced", "advanced"), (Tab::Renderer, "3D Renderer", "renderer")] {
+            let r = ui.selectable_label(d.tab == tab, tr(label));
+            auto.add(&format!("dialog.comp.tab.{key}"), r.rect, label);
+            if r.clicked() {
+                d.tab = tab;
+            }
+        }
+    });
+    ui.separator();
+    // Every tab takes the height of the tallest one, so Cancel and OK stay put between tabs.
+    let body_top = ui.cursor().top();
+    tab_body(ui, d.tab, d, t, auto, custom, cmds);
+    let shown = ui.cursor().top() - body_top;
+    let tallest = [Tab::Basic, Tab::Advanced, Tab::Renderer]
+        .into_iter()
+        .filter(|tab| *tab != d.tab)
+        .fold(shown, |h, tab| h.max(tab_height(ui, tab, d, t, custom, body_top)));
+    ui.add_space((tallest - shown).max(0.0));
     ui.add_space(14.0);
     ui.horizontal(|ui| {
         ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
@@ -496,6 +529,9 @@ pub fn show(
             if r.clicked() {
                 out = Some(serde_json::Value::Null);
             }
+            if let Some(on) = preview {
+                super::live_preview::checkbox(ui, auto, on, "dialog.comp.preview");
+            }
         });
     });
     out
diff --git a/crates/ui-egui/src/panels/dialogs.rs b/crates/ui-egui/src/panels/dialogs.rs
index 99496a218..ac26bd0c1 100644
--- a/crates/ui-egui/src/panels/dialogs.rs
+++ b/crates/ui-egui/src/panels/dialogs.rs
@@ -66,6 +66,8 @@ pub struct DialogState {
     pub delete_items: super::delete_items::Pending,
     /// The Gradient Editor's draft and the property it edits.
     pub gradient: super::gradient_editor::Draft,
+    /// Preview of the settings dialog being edited (Solid, Camera, Light, Composition Settings).
+    pub live: super::live_preview::LivePreview,
     /// The user template the Delete Template prompt asks about: its id and name.
     pub delete_template: Option<(String, String)>,
 }
@@ -76,6 +78,7 @@ pub fn open_new_comp(app: &mut EffectcraftApp) {
     app.dialog_state.comp =
         CompDraft { name: format!("Comp {n}"), tab: super::comp_settings::Tab::Basic, start_tc: None, dur_tc: None, preset_name: None, ..last };
     app.dialog_state.editing_existing = false;
+    app.dialog_state.live = Default::default();
     app.dialog = Some(Dialog::NewComp);
 }
 
@@ -109,6 +112,7 @@ pub fn open_comp_settings_for(app: &mut EffectcraftApp, cid: ItemId) -> Result<(
     app.dialog_state.editing_existing = true;
     app.dialog_state.editing_comp = Some(cid);
     app.dialog = Some(Dialog::CompSettings);
+    super::live_preview::begin(app, Dialog::CompSettings);
     Ok(())
 }
 
@@ -123,6 +127,7 @@ pub fn open_new_solid(app: &mut EffectcraftApp) -> Result<(), String> {
     if d.solid_color == [0.0; 3] {
         d.solid_color = [0.2, 0.45, 0.85];
     }
+    d.live = Default::default();
     app.dialog = Some(Dialog::SolidSettings);
     Ok(())
 }
@@ -138,6 +143,7 @@ fn open_solid_settings(app: &mut EffectcraftApp, layer: u64, item: ItemId) -> Re
     (d.solid_name, d.solid_color, d.solid_size, d.solid_pixel_aspect) = (name, so.color, [so.width, so.height], so.pixel_aspect);
     (d.solid_layer, d.solid_shared, d.solid_affect_all) = (Some(layer), users > 1, false);
     app.dialog = Some(Dialog::SolidSettings);
+    super::live_preview::begin(app, Dialog::SolidSettings);
     Ok(())
 }
 
@@ -170,6 +176,18 @@ pub(crate) fn modal_space(ctx: &egui::Context) -> egui::Vec2 {
     (ctx.content_rect().size() - vec2(48.0, 48.0)).max(vec2(120.0, 80.0))
 }
 
+fn modal_pass_id() -> egui::Id {
+    egui::Id::unique("effectcraft-modal-pass")
+}
+
+/// Whether a modal dialog showed in this pass or the one before: egui's `Modal` blocks input
+/// only in its own window, so floating panels in OS windows of their own are blocked by the
+/// dock area while this holds. Dialogs draw after the dock, so the previous pass counts.
+pub(crate) fn modal_open(ctx: &egui::Context) -> bool {
+    let shown = ctx.data(|d| d.get_temp::<u64>(modal_pass_id()));
+    shown.is_some_and(|pass| pass.saturating_add(1) >= ctx.cumulative_pass_nr_for(egui::ViewportId::ROOT))
+}
+
 pub(crate) fn modal(ctx: &egui::Context, title: &str, size: egui::Vec2, t: &Tokens, body: impl FnOnce(&mut egui::Ui)) {
     modal_with_scroll(ctx, title, size, t, false, body);
 }
@@ -178,6 +196,31 @@ pub(crate) fn modal_vertical(ctx: &egui::Context, title: &str, size: egui::Vec2,
     modal_with_scroll(ctx, title, size, t, true, body);
 }
 
+/// Where a modal dialog opens and whether it dims the window behind it. The default is the middle
+/// of the window over a dimmed backdrop.
+#[derive(Clone, Copy, Debug)]
+pub struct Placement {
+    /// The opening position as a fraction of the room the dialog can move in, from the middle
+    /// `(0, 0)` to the bottom right `(1, 1)`.
+    pub start: egui::Vec2,
+    /// Dim the window behind the dialog.
+    pub dim: bool,
+}
+
+impl Default for Placement {
+    fn default() -> Self {
+        Placement { start: vec2(0.0, 0.0), dim: true }
+    }
+}
+
+/// [`modal`] at `place`: a dialog that edits what is behind it keeps the canvas in view.
+pub(crate) fn modal_placed(ctx: &egui::Context, title: &str, size: egui::Vec2, t: &Tokens, place: Placement, body: impl FnOnce(&mut egui::Ui)) {
+    let max_height = (modal_space(ctx).y - 84.0).max(40.0);
+    modal_fit_placed(ctx, title, size, t, place, |ui, _| {
+        egui::ScrollArea::both().max_height(max_height).auto_shrink([false, true]).show(ui, body);
+    });
+}
+
 fn modal_with_scroll(ctx: &egui::Context, title: &str, size: egui::Vec2, t: &Tokens, vertical_only: bool, body: impl FnOnce(&mut egui::Ui)) {
     let max_height = (modal_space(ctx).y - 84.0).max(40.0);
     modal_fit(ctx, title, size, t, |ui, _| {
@@ -190,16 +233,23 @@ fn modal_with_scroll(ctx: &egui::Context, title: &str, size: egui::Vec2, t: &Tok
 /// only its content: `body` gets the height left under the title, with `size` kept within the
 /// window.
 pub(crate) fn modal_fit(ctx: &egui::Context, title: &str, size: egui::Vec2, t: &Tokens, body: impl FnOnce(&mut egui::Ui, f32)) {
+    modal_fit_placed(ctx, title, size, t, Placement::default(), body);
+}
+
+/// [`modal_fit`] at `place`.
+pub(crate) fn modal_fit_placed(ctx: &egui::Context, title: &str, size: egui::Vec2, t: &Tokens, place: Placement, body: impl FnOnce(&mut egui::Ui, f32)) {
+    let pass = ctx.cumulative_pass_nr_for(egui::ViewportId::ROOT);
+    ctx.data_mut(|d| d.insert_temp(modal_pass_id(), pass));
     let size = size.min(modal_space(ctx));
     let id = egui::Id::unique(("modal", title));
     // Dragging the title row moves the dialog off what it edits. The offset is kept within the
     // window, so dragging back never has to undo a part the dialog could not follow.
     let offset_id = id.with("offset");
     let room = ((ctx.content_rect().size() - size) * 0.5).max(vec2(0.0, 0.0));
-    let offset = ctx.data(|d| d.get_temp::<egui::Vec2>(offset_id)).unwrap_or_default().clamp(-room, room);
+    let offset = ctx.data(|d| d.get_temp::<egui::Vec2>(offset_id)).unwrap_or(room * place.start).clamp(-room, room);
     egui::Modal::new(id)
         .area(egui::Modal::default_area(id).anchor(Align2::CENTER_CENTER, offset))
-        .backdrop_color(Color32::from_black_alpha(120))
+        .backdrop_color(Color32::from_black_alpha(if place.dim { 120 } else { 0 }))
         .frame(egui::Frame::window(&ctx.style_of(ctx.theme())).fill(t.panel_bg).inner_margin(egui::Margin::same(18)))
         .show(ctx, |ui| {
             ui.set_width(size.x - 36.0);
@@ -207,7 +257,7 @@ pub(crate) fn modal_fit(ctx: &egui::Context, title: &str, size: egui::Vec2, t: &
             // The id stays keyed on the untranslated source, so switching language cannot move it.
             let head = ui.label(egui::RichText::new(tr(title)).font(Tokens::semibold(15.0)).color(t.tab_text_active));
             let row = Rect::from_x_y_ranges(ui.max_rect().x_range(), head.rect.y_range());
-            let grip = ui.interact(row, id.with("grip"), Sense::drag()).on_hover_cursor(egui::CursorIcon::Grab);
+            let grip = ui.interact(row, id.with("grip"), Sense::DRAG).on_hover_cursor(egui::CursorIcon::Grab);
             if grip.dragged() {
                 let moved = (offset + grip.drag_delta()).clamp(-room, room);
                 ui.ctx().data_mut(|d| d.insert_temp(offset_id, moved));
@@ -215,6 +265,8 @@ pub(crate) fn modal_fit(ctx: &egui::Context, title: &str, size: egui::Vec2, t: &
             ui.add_space(10.0);
             let title_h = ui.cursor().top() - ui.min_rect().top();
             body(ui, (size.y - 36.0 - title_h).max(40.0));
+            // A colour picker's eyedropper samples the viewer under the dialog, but not the dialog itself.
+            crate::color_picker::note_overlay(ui.ctx(), ui.min_rect().expand(18.0));
         });
 }
 
@@ -273,6 +325,10 @@ const ABOUT_TABS: [(&str, &str); 3] = [("About", "about"), ("Contributors", "con
 /// Height of the Contributors / Models tab bodies (they scroll inside it).
 const CREDITS_HEIGHT: f32 = 380.0;
 
+/// The About dialog: tabs for the name/version/blurb, the contributors and the models (the last
+/// two scroll in a fixed-height body), the licence and bundled-font line, and Close. The tab is
+/// kept in egui temp data. A command the About body asked for is run once the modal has been
+/// built; Close clears `app.dialog`.
 fn about(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
     let mut close = false;
     let mut cmd: Option<&str> = None;
@@ -385,9 +441,15 @@ fn comp_settings(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens, exis
     let mut result = None;
     let custom = app.session.prefs.comp_presets.clone();
     let mut cmds = Vec::new();
-    modal(ctx, "Composition Settings", vec2(600.0, 470.0), t, |ui| {
-        result = super::comp_settings::show(ui, &mut d, t, &mut app.auto, &custom, &mut cmds);
+    // The title keys the modal id and its drag offset; `modal_fit` translates the heading itself,
+    // so passing the source keeps the dialog in place when the interface language changes.
+    let live = existing && super::live_preview::active(app);
+    let place = super::live_preview::place(app);
+    let mut preview = app.dialog_state.live.on;
+    modal_placed(ctx, "Composition Settings", vec2(600.0, 470.0), t, place, |ui| {
+        result = super::comp_settings::show(ui, &mut d, t, &mut app.auto, &custom, &mut cmds, live.then_some(&mut preview));
     });
+    app.dialog_state.live.on = preview;
     if d.preset_name.is_some() {
         // Save Preset asks for the name in its own window over the dialog, as After Effects does.
         result = None;
@@ -405,11 +467,25 @@ fn comp_settings(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens, exis
     }
     app.dialog_state.comp = d;
     match result {
-        Some(serde_json::Value::Null) => app.dialog = None,
+        Some(serde_json::Value::Null) => {
+            super::live_preview::cancel(app);
+            app.dialog = None;
+        }
         Some(mut params) => {
             if existing && let (Some(cid), Some(m)) = (app.dialog_state.editing_comp, params.as_object_mut()) {
                 m.insert("comp".into(), json!(cid.0));
             }
+            // A preview already made the edit (one undo step): OK keeps it.
+            if existing && super::live_preview::keep(app, "comp.settings", params.clone()) {
+                // The Resolution is not part of the command, so the preview never applied it.
+                if let Some(cid) = app.dialog_state.editing_comp
+                    && let Err(e) = set_resolution(app, cid.0, app.dialog_state.comp.resolution)
+                {
+                    app.ui.status = e.to_string();
+                }
+                app.dialog = None;
+                return;
+            }
             let r = if existing { app.session.execute("comp.settings", params) } else { app.session.execute("comp.new", params) };
             let cid = if existing { app.dialog_state.editing_comp.map(|c| c.0) } else { r.as_ref().ok().and_then(|v| v["comp"].as_u64()) };
             let r = match cid {
@@ -424,7 +500,15 @@ fn comp_settings(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens, exis
             }
             app.dialog = None;
         }
-        None => {}
+        None => {
+            if existing && let Some(cid) = app.dialog_state.editing_comp {
+                let mut params = super::comp_settings::params(&app.dialog_state.comp);
+                if let Some(m) = params.as_object_mut() {
+                    m.insert("comp".into(), json!(cid.0));
+                }
+                super::live_preview::sync(app, "comp.settings", params);
+            }
+        }
     }
 }
 
@@ -481,8 +565,11 @@ fn solid(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
     let comp_size = app.session.active_comp().map(|c| (c.width, c.height)).unwrap_or((1920, 1080));
     let lock_id = egui::Id::unique("solid-lock-aspect");
     let mut lock = ctx.data(|m| m.get_temp::<bool>(lock_id)).unwrap_or(true);
+    let live = super::live_preview::active(app);
+    let place = super::live_preview::place(app);
+    let mut preview = app.dialog_state.live.on;
     let auto = &mut app.auto;
-    modal(ctx, "Solid Settings", vec2(480.0, if editing.is_some() { 430.0 } else { 390.0 }), t, |ui| {
+    modal_placed(ctx, "Solid Settings", vec2(480.0, if editing.is_some() { 430.0 } else { 390.0 }), t, place, |ui| {
         ui.horizontal(|ui| {
             ui.label(tr("Name:"));
             let r = ui.add(egui::TextEdit::singleline(&mut name).desired_width(320.0));
@@ -497,7 +584,11 @@ fn solid(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             ui.horizontal(|ui| {
                 let r = ui.add(crate::widgets::drag_value(egui::DragValue::new(&mut size[0]).range(1..=30000).suffix(" px")));
                 auto.add("dialog.solid.width", r.rect, "Width");
-                let r = ui.checkbox(&mut lock, tr_args("Lock Aspect Ratio to {}", &[&(super::comp_settings::aspect_label(ow as f64, oh as f64))]));
+                let r = crate::widgets::labelled_checkbox(
+                    ui,
+                    &mut lock,
+                    tr_args("Lock Aspect Ratio to {}", &[&(super::comp_settings::aspect_label(ow as f64, oh as f64))]),
+                );
                 auto.add("dialog.solid.lockAspect", r.rect, "Lock Aspect Ratio");
             });
             ui.end_row();
@@ -518,7 +609,7 @@ fn solid(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                 .find(|(_, v)| (v - par).abs() < 1e-3)
                 .map(|p| p.0.to_string())
                 .unwrap_or_else(|| format!("{par:.2}"));
-            let r = egui::ComboBox::from_id_salt("solid-par").width(240.0).selected_text(cur).show_ui(ui, |ui| {
+            let r = craft_ui::ComboBox::from_id_salt("solid-par").width(240.0).selected_text(cur).show_ui(ui, |ui| {
                 for (label, v) in super::comp_settings::PIXEL_ASPECTS {
                     if ui.selectable_label((v - par).abs() < 1e-3, *label).clicked() {
                         par = *v;
@@ -553,7 +644,7 @@ fn solid(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
         if editing.is_some() {
             ui.add_space(8.0);
             let r = ui
-                .add_enabled(shared, egui::Checkbox::new(&mut affect_all, tr("Affect all layers that use this solid")))
+                .add_enabled(shared, crate::widgets::DragCheckbox::new(&mut affect_all, tr("Affect all layers that use this solid")))
                 .on_disabled_hover_text(tr("Only this layer uses this solid."));
             auto.add("dialog.solid.affectAll", r.rect, "Affect all layers that use this solid");
             if shared && !affect_all {
@@ -568,16 +659,28 @@ fn solid(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             let r = ui.button(tr("Cancel"));
             auto.add("dialog.solid.cancel", r.rect, "Cancel");
             close = r.clicked();
+            if live {
+                super::live_preview::checkbox(ui, auto, &mut preview, "dialog.solid.preview");
+            }
         });
     });
     ctx.data_mut(|m| m.insert_temp(lock_id, lock));
     let ds = &mut app.dialog_state;
+    ds.live.on = preview;
     (ds.solid_name, ds.solid_color, ds.solid_size, ds.solid_pixel_aspect, ds.solid_affect_all) = (name, color, size, par, affect_all);
+    let (command, params) = (solid_command(ds), solid_params(ds));
     if ok || ui_enter(ctx) {
-        if let Err(e) = app.session.execute(solid_command(ds), solid_params(ds)) {
+        // A preview already made the edit (one undo step): OK keeps it.
+        if !super::live_preview::keep(app, command, params.clone())
+            && let Err(e) = app.session.execute(command, params)
+        {
             app.ui.status = e.to_string();
         }
         close = true;
+    } else if close {
+        super::live_preview::cancel(app);
+    } else {
+        super::live_preview::sync(app, command, params);
     }
     if close {
         app.dialog = None;
@@ -689,6 +792,29 @@ fn palette(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
 mod tests {
     use super::*;
 
+    #[test]
+    fn modal_open_holds_from_a_shown_dialog_until_the_pass_after_it_closes() {
+        let (app, ctx) = app();
+        let t = app.tokens;
+        // Asked as the dock asks it: during the pass, before the dialogs draw.
+        let pass = |show: bool| {
+            let mut open = false;
+            let mut output = ctx.run_ui(egui::RawInput::default(), |ui| {
+                open = modal_open(ui.ctx());
+                if show {
+                    modal(ui.ctx(), "Test", vec2(200.0, 100.0), &t, |_| {});
+                }
+            });
+            output.textures_delta.clear();
+            open
+        };
+        assert!(!pass(false));
+        assert!(!pass(true), "the first pass of a dialog finds none shown yet");
+        assert!(pass(true));
+        assert!(pass(false), "the pass after the last one shown still counts");
+        assert!(!pass(false));
+    }
+
     fn app() -> (EffectcraftApp, egui::Context) {
         let ctx = egui::Context::default();
         let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
diff --git a/crates/ui-egui/src/panels/dialogs_3d.rs b/crates/ui-egui/src/panels/dialogs_3d.rs
index 01fd5b9e8..16137b599 100644
--- a/crates/ui-egui/src/panels/dialogs_3d.rs
+++ b/crates/ui-egui/src/panels/dialogs_3d.rs
@@ -44,12 +44,19 @@ pub struct LightDraft {
 
 const FALLOFFS: [&str; 3] = ["None", "Smooth", "Inverse Square Clamped"];
 
-/// Whether a light type has Falloff and Shadows options. Ambient and Environment lights come
-/// from no one place, so they have neither.
+/// Whether a light type has Falloff options (distance attenuation): image-based Environment
+/// lights and Ambient come from no one place, so they have none.
 fn falls_off(kind: LightKind) -> bool {
     !matches!(kind, LightKind::Ambient | LightKind::Environment)
 }
 
+/// Whether a light type has Shadows options in the dialog. After Effects' Light Settings shows
+/// Cast Shadows (with Shadow Darkness and Diffusion) for every light but Ambient — an
+/// Environment light's shadow comes from its image, not a falloff.
+fn casts_shadows(kind: LightKind) -> bool {
+    kind != LightKind::Ambient
+}
+
 fn comp_w(app: &EffectcraftApp) -> f64 {
     app.session.active_comp().map(|c| c.width as f64).unwrap_or(1920.0)
 }
@@ -92,8 +99,14 @@ pub fn open_camera(app: &mut EffectcraftApp, layer: Option<u64>) -> Result<(), S
             }
         }
     };
+    let editing = d.layer.is_some();
     app.dialog_state.camera = d;
     app.dialog = Some(Dialog::CameraSettings);
+    if editing {
+        super::live_preview::begin(app, Dialog::CameraSettings);
+    } else {
+        app.dialog_state.live = Default::default();
+    }
     Ok(())
 }
 
@@ -142,13 +155,19 @@ pub fn open_light(app: &mut EffectcraftApp, layer: Option<u64>) -> Result<(), St
             }
         }
     };
+    let editing = d.layer.is_some();
     app.dialog_state.light = d;
     app.dialog = Some(Dialog::LightSettings);
+    if editing {
+        super::live_preview::begin(app, Dialog::LightSettings);
+    } else {
+        app.dialog_state.live = Default::default();
+    }
     Ok(())
 }
 
-fn buttons(ui: &mut egui::Ui, t: &Tokens, ok: &mut bool, close: &mut bool) -> (egui::Rect, egui::Rect) {
-    let mut r = (egui::Rect::NOTHING, egui::Rect::NOTHING);
+fn buttons(ui: &mut egui::Ui, t: &Tokens, ok: &mut bool, close: &mut bool, preview: Option<&mut bool>) -> (egui::Rect, egui::Rect, egui::Rect) {
+    let mut r = (egui::Rect::NOTHING, egui::Rect::NOTHING, egui::Rect::NOTHING);
     ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
         let b = ui.add(egui::Button::new(egui::RichText::new(tr("   OK   ")).color(Color32::WHITE)).fill(t.accent));
         r.0 = b.rect;
@@ -160,6 +179,9 @@ fn buttons(ui: &mut egui::Ui, t: &Tokens, ok: &mut bool, close: &mut bool) -> (e
         if c.clicked() {
             *close = true;
         }
+        if let Some(on) = preview {
+            r.2 = ui.checkbox(on, tr("Preview")).rect;
+        }
     });
     r
 }
@@ -168,11 +190,14 @@ pub fn camera(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
     let w = comp_w(app);
     let mut d = app.dialog_state.camera.clone();
     let (mut ok, mut close) = (false, false);
-    let mut rects = (egui::Rect::NOTHING, egui::Rect::NOTHING);
-    super::dialogs::modal(ctx, "Camera Settings", vec2(520.0, 420.0), t, |ui| {
+    let mut rects = (egui::Rect::NOTHING, egui::Rect::NOTHING, egui::Rect::NOTHING);
+    let live = super::live_preview::active(app);
+    let place = super::live_preview::place(app);
+    let mut preview = app.dialog_state.live.on;
+    super::dialogs::modal_placed(ctx, "Camera Settings", vec2(520.0, 420.0), t, place, |ui| {
         egui::Grid::new("cam-grid").num_columns(2).spacing([14.0, 9.0]).show(ui, |ui| {
             ui.label(tr("Type"));
-            egui::ComboBox::from_id_salt("cam-type").selected_text(if d.two_node { "Two-Node Camera" } else { "One-Node Camera" }).show_ui(ui, |ui| {
+            craft_ui::ComboBox::from_id_salt("cam-type").selected_text(if d.two_node { "Two-Node Camera" } else { "One-Node Camera" }).show_ui(ui, |ui| {
                 ui.selectable_value(&mut d.two_node, true, tr("Two-Node Camera"));
                 ui.selectable_value(&mut d.two_node, false, tr("One-Node Camera"));
             });
@@ -184,7 +209,7 @@ pub fn camera(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             ui.label(tr("Preset"));
             let focal = focal_for_zoom(w, d.zoom);
             let cur = PRESETS.iter().find(|(_, f)| (f - focal).abs() < 1e-6).map(|(n, _)| *n).unwrap_or("Custom");
-            egui::ComboBox::from_id_salt("cam-preset").selected_text(cur).show_ui(ui, |ui| {
+            craft_ui::ComboBox::from_id_salt("cam-preset").selected_text(cur).show_ui(ui, |ui| {
                 for (n, f) in PRESETS {
                     if ui.selectable_label(cur == n, n).clicked() {
                         d.zoom = zoom_for_focal(w, f);
@@ -206,12 +231,12 @@ pub fn camera(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             });
             ui.end_row();
             ui.label(tr("Depth of Field"));
-            ui.checkbox(&mut d.dof, tr("Enable Depth of Field"));
+            crate::widgets::labelled_checkbox(ui, &mut d.dof, tr("Enable Depth of Field"));
             ui.end_row();
             ui.label(tr("Focus Distance"));
             ui.horizontal(|ui| {
                 ui.add_enabled(!d.lock_to_zoom, crate::widgets::drag_value(egui::DragValue::new(&mut d.focus).range(0.0..=100000.0).suffix(" px")));
-                ui.checkbox(&mut d.lock_to_zoom, tr("Lock to Zoom"));
+                crate::widgets::labelled_checkbox(ui, &mut d.lock_to_zoom, tr("Lock to Zoom"));
             });
             ui.end_row();
             ui.label(tr("Aperture"));
@@ -222,53 +247,73 @@ pub fn camera(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             ui.end_row();
         });
         ui.add_space(14.0);
-        rects = buttons(ui, t, &mut ok, &mut close);
+        rects = buttons(ui, t, &mut ok, &mut close, live.then_some(&mut preview));
     });
+    app.dialog_state.live.on = preview;
     if d.lock_to_zoom {
         d.focus = d.zoom;
     }
     app.auto.add("dialog.camera.ok", rects.0, "OK");
     app.auto.add("dialog.camera.cancel", rects.1, "Cancel");
+    if live {
+        app.auto.add("dialog.camera.preview", rects.2, "Preview");
+    }
     app.dialog_state.camera = d.clone();
+    let (id, p) = camera_command(&d);
     if ok || super::dialogs::ui_enter(ctx) {
-        let mut p = json!({
-            "name": d.name,
-            "type": if d.two_node { "twoNode" } else { "oneNode" },
-            "zoom": d.zoom,
-            "dof": d.dof,
-            "focusDistance": d.focus,
-            "aperture": d.aperture,
-            "blurLevel": d.blur,
-        });
-        let id = match d.layer {
-            Some(l) => {
-                p["layer"] = json!(l);
-                "layer.cameraSettings"
-            }
-            None => "layer.newCamera",
-        };
-        if let Err(e) = app.session.execute(id, p) {
+        // A preview already made the edit (one undo step): OK keeps it.
+        if !super::live_preview::keep(app, id, p.clone())
+            && let Err(e) = app.session.execute(id, p)
+        {
             app.ui.status = e.to_string();
         }
         close = true;
+    } else if close {
+        super::live_preview::cancel(app);
+    } else {
+        super::live_preview::sync(app, id, p);
     }
     if close {
         app.dialog = None;
     }
 }
 
+/// The command Camera Settings' OK runs, and its parameters.
+fn camera_command(d: &CameraDraft) -> (&'static str, Value) {
+    let mut p = json!({
+        "name": d.name,
+        "type": if d.two_node { "twoNode" } else { "oneNode" },
+        "zoom": d.zoom,
+        "dof": d.dof,
+        "focusDistance": d.focus,
+        "aperture": d.aperture,
+        "blurLevel": d.blur,
+    });
+    let id = match d.layer {
+        Some(l) => {
+            p["layer"] = json!(l);
+            "layer.cameraSettings"
+        }
+        None => "layer.newCamera",
+    };
+    (id, p)
+}
+
 pub fn light(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
     let mut d = app.dialog_state.light.clone();
     let (mut ok, mut close) = (false, false);
-    let mut rects = (egui::Rect::NOTHING, egui::Rect::NOTHING);
-    super::dialogs::modal(ctx, "Light Settings", vec2(480.0, 470.0), t, |ui| {
+    let mut rects = (egui::Rect::NOTHING, egui::Rect::NOTHING, egui::Rect::NOTHING);
+    let live = super::live_preview::active(app);
+    let place = super::live_preview::place(app);
+    let mut preview = app.dialog_state.live.on;
+    super::dialogs::modal_placed(ctx, "Light Settings", vec2(480.0, 470.0), t, place, |ui| {
         egui::Grid::new("light-grid").num_columns(2).spacing([14.0, 9.0]).show(ui, |ui| {
             ui.label(tr("Name"));
             let r = ui.add(egui::TextEdit::singleline(&mut d.name).desired_width(220.0));
             crate::widgets::focus_on_open(ui.ctx(), &r, &d.name);
             ui.end_row();
             ui.label(tr("Light Type"));
-            let combo = egui::ComboBox::from_id_salt("light-type").selected_text(tr(d.kind.label())).show_ui(ui, |ui| {
+            let combo = craft_ui::ComboBox::from_id_salt("light-type").selected_text(tr(d.kind.label())).show_ui(ui, |ui| {
                 for (i, k) in LightKind::ALL.into_iter().enumerate() {
                     let item = ui.selectable_value(&mut d.kind, k, tr(k.label()));
                     app.auto.add(&format!("dialog.light.typeItem.{i}"), item.rect, k.label());
@@ -292,7 +337,7 @@ pub fn light(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             }
             if falls_off(d.kind) {
                 ui.label(tr("Falloff"));
-                egui::ComboBox::from_id_salt("light-falloff").selected_text(FALLOFFS[d.falloff.min(2)]).show_ui(ui, |ui| {
+                craft_ui::ComboBox::from_id_salt("light-falloff").selected_text(FALLOFFS[d.falloff.min(2)]).show_ui(ui, |ui| {
                     for (i, f) in FALLOFFS.iter().enumerate() {
                         ui.selectable_value(&mut d.falloff, i, *f);
                     }
@@ -306,8 +351,11 @@ pub fn light(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                     ui.add(crate::widgets::drag_value(egui::DragValue::new(&mut d.falloff_distance).range(0.0..=100000.0).suffix(" px")));
                     ui.end_row();
                 }
+            }
+            if casts_shadows(d.kind) {
                 ui.label(tr("Shadows"));
-                ui.checkbox(&mut d.casts_shadows, tr("Casts Shadows"));
+                let cb = crate::widgets::labelled_checkbox(ui, &mut d.casts_shadows, tr("Casts Shadows"));
+                app.auto.add_response("dialog.light.casts", &cb, "Casts Shadows");
                 ui.end_row();
                 ui.label(tr("Shadow Darkness"));
                 ui.add_enabled(d.casts_shadows, crate::widgets::drag_value(egui::DragValue::new(&mut d.shadow_darkness).range(0.0..=100.0).suffix(" %")));
@@ -318,52 +366,71 @@ pub fn light(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             }
         });
         ui.add_space(14.0);
-        if falls_off(d.kind) {
+        if casts_shadows(d.kind) {
             ui.label(egui::RichText::new(tr("Note: Shadows are only cast from layers with Cast Shadows enabled.")).font(Tokens::ui(11.0)).color(t.text_dim));
             ui.add_space(8.0);
         }
-        rects = buttons(ui, t, &mut ok, &mut close);
+        rects = buttons(ui, t, &mut ok, &mut close, live.then_some(&mut preview));
     });
+    app.dialog_state.live.on = preview;
     app.auto.add("dialog.light.ok", rects.0, "OK");
     app.auto.add("dialog.light.cancel", rects.1, "Cancel");
+    if live {
+        app.auto.add("dialog.light.preview", rects.2, "Preview");
+    }
     app.dialog_state.light = d.clone();
+    let (id, p) = light_command(&d);
     if ok || super::dialogs::ui_enter(ctx) {
-        let kind = d.kind;
-        let mut p = json!({
-            "name": d.name,
-            "kind": kind.label(),
-            "color": [d.color[0], d.color[1], d.color[2]],
-            "intensity": d.intensity,
-        });
-        if kind == LightKind::Spot {
-            p["coneAngle"] = json!(d.cone_angle);
-            p["coneFeather"] = json!(d.cone_feather);
-        }
-        if falls_off(kind) {
-            p["falloff"] = json!(d.falloff);
-            p["radius"] = json!(d.radius);
-            p["falloffDistance"] = json!(d.falloff_distance);
-            p["castsShadows"] = json!(d.casts_shadows);
-            p["shadowDarkness"] = json!(d.shadow_darkness);
-            p["shadowDiffusion"] = json!(d.shadow_diffusion);
-        }
-        let id = match d.layer {
-            Some(l) => {
-                p["layer"] = json!(l);
-                "layer.lightSettings"
-            }
-            None => "layer.newLight",
-        };
-        if let Err(e) = app.session.execute(id, p) {
+        // A preview already made the edit (one undo step): OK keeps it.
+        if !super::live_preview::keep(app, id, p.clone())
+            && let Err(e) = app.session.execute(id, p)
+        {
             app.ui.status = e.to_string();
         }
         close = true;
+    } else if close {
+        super::live_preview::cancel(app);
+    } else {
+        super::live_preview::sync(app, id, p);
     }
     if close {
         app.dialog = None;
     }
 }
 
+/// The command Light Settings' OK runs, and its parameters.
+fn light_command(d: &LightDraft) -> (&'static str, Value) {
+    let kind = d.kind;
+    let mut p = json!({
+        "name": d.name,
+        "kind": kind.label(),
+        "color": [d.color[0], d.color[1], d.color[2]],
+        "intensity": d.intensity,
+    });
+    if kind == LightKind::Spot {
+        p["coneAngle"] = json!(d.cone_angle);
+        p["coneFeather"] = json!(d.cone_feather);
+    }
+    if falls_off(kind) {
+        p["falloff"] = json!(d.falloff);
+        p["radius"] = json!(d.radius);
+        p["falloffDistance"] = json!(d.falloff_distance);
+    }
+    if casts_shadows(kind) {
+        p["castsShadows"] = json!(d.casts_shadows);
+        p["shadowDarkness"] = json!(d.shadow_darkness);
+        p["shadowDiffusion"] = json!(d.shadow_diffusion);
+    }
+    let id = match d.layer {
+        Some(l) => {
+            p["layer"] = json!(l);
+            "layer.lightSettings"
+        }
+        None => "layer.newLight",
+    };
+    (id, p)
+}
+
 /// Menu/shortcut routing: commands that open a 3D settings dialog when invoked without params.
 /// Returns true when a dialog was opened.
 pub fn route(app: &mut EffectcraftApp, id: &str, params: &Value) -> Result<bool, String> {
diff --git a/crates/ui-egui/src/panels/effect_controls.rs b/crates/ui-egui/src/panels/effect_controls.rs
index f0c023448..d9706f147 100644
--- a/crates/ui-egui/src/panels/effect_controls.rs
+++ b/crates/ui-egui/src/panels/effect_controls.rs
@@ -28,1644 +28,14 @@ use crate::state::FxPick;
 use crate::theme::Tokens;
 use crate::{EffectcraftApp, widgets};
 
-type Actions = Vec<(String, serde_json::Value)>;
+mod common;
+mod editors;
+mod panel;
+mod rows;
+mod viewer;
 
-const ROW: f32 = 20.0;
-const DIAL_ROW: f32 = 64.0;
-// The effect title starts at 44 pt. Each level's names sit one tree step farther in;
-// reserve the same icon gutter for properties and groups so sibling names align.
-const PARAM_NAME_X: f32 = 58.0;
-const TREE_INDENT: f32 = 14.0;
-
-/// Selecting any descendant activates its owning effect without replacing the property
-/// selection used by keyframe editing, copy and delete.
-fn effect_active(g: &PropGroup, layer: effectcraft_engine::project::LayerId, selected: &[(effectcraft_engine::project::LayerId, u64)]) -> bool {
-    fn contains(g: &PropGroup, uid: u64, depth: usize) -> bool {
-        if g.uid == uid {
-            return true;
-        }
-        if depth >= 16 {
-            return false;
-        }
-        g.children.iter().any(|n| n.uid() == uid || matches!(n, Node::Group(child) if contains(child, uid, depth + 1)))
-    }
-    selected.iter().any(|(l, uid)| *l == layer && contains(g, *uid, 0))
-}
-
-fn selected_layer(app: &EffectcraftApp) -> Option<Layer> {
-    let comp = app.session.active_comp()?;
-    let id = app.session.state.selected_layers.first()?;
-    comp.layer(*id).cloned()
-}
-
-/// An effect was just applied (`effect.apply` / `effect.applyLast` with `params`): Effect
-/// Controls comes up (opened if closed, brought to the front, the focus left where it is) on the
-/// layer the effect went to, with the new effect selected, as in After Effects.
-pub fn reveal_applied(app: &mut EffectcraftApp, params: &serde_json::Value) {
-    // `effect.apply` selects the new effect on (the last of) the layers it went to.
-    let target = app.session.state.selected_props.last().map(|(l, _)| *l);
-    if let Some(l) = target
-        && !app.session.state.selected_layers.contains(&l)
-        && params.get("comp").is_none()
-        && app.session.active_comp().is_some_and(|c| c.layer(l).is_some())
-    {
-        // Show that layer (dropped on an unselected one), keeping the new effect selected.
-        let props = app.session.state.selected_props.clone();
-        match app.session.execute("layer.select", json!({"layers": [l.0]})) {
-            Ok(_) => app.session.state.selected_props = props,
-            Err(e) => app.ui.status = e.to_string(),
-        }
-    }
-    app.raise_panel(crate::dock::PanelKind::EffectControls);
-}
-
-/// After Effects asks for an effect's file as it applies it (Apply Color LUT opens the file
-/// dialog for its LUT). For the instances `effect.apply` made (`applied`, its result), open the
-/// file dialog for their first empty file parameter and set the file on each; cancelling
-/// leaves the effect without one. Does nothing without a file dialog (tests, agents).
-pub fn choose_files_after_apply(app: &mut EffectcraftApp, applied: &serde_json::Value) {
-    let Some(pick) = app.hooks.pick_files.as_ref() else { return };
-    let Some(comp) = app.session.active_comp() else { return };
-    let uids: Vec<u64> = applied.get("effects").and_then(|v| v.as_array()).map(|a| a.iter().filter_map(|v| v.as_u64()).collect()).unwrap_or_default();
-    let mut targets = vec![];
-    let mut filters: Vec<String> = vec![];
-    for uid in uids {
-        for l in &comp.layers {
-            let Some(g) = l.props.find_group(uid) else { continue };
-            let mut found = None;
-            g.walk("", &mut |_, pr| {
-                if found.is_none()
-                    && let ParamUi::File { filters } = &pr.ui
-                    && matches!(&pr.value, Value::Str(s) if s.trim().is_empty())
-                {
-                    found = Some((pr.uid, filters.clone()));
-                }
-            });
-            if let Some((prop, f)) = found {
-                targets.push((l.id.0, prop));
-                filters = f;
-            }
-        }
-    }
-    if targets.is_empty() {
-        return;
-    }
-    let exts: Vec<&str> = filters.iter().map(String::as_str).collect();
-    let Some(path) = pick(&exts).into_iter().next() else { return };
-    for (layer, prop) in targets {
-        if let Err(e) = app.session.execute("prop.set", json!({"layer": layer, "prop": prop, "value": path})) {
-            app.ui.status = e.to_string();
-        }
-    }
-}
-
-/// An undo-merge key for one gesture on `id`: a new key each time a drag starts, so separate
-/// drags are separate undo steps while one drag is one step.
-pub(crate) fn gesture_key(ui: &egui::Ui, id: egui::Id, started: bool) -> String {
-    let kid = id.with("gesture");
-    let n: u64 = if started {
-        let n = ui.data(|d| d.get_temp::<u64>(kid)).unwrap_or(0) + 1;
-        ui.data_mut(|d| d.insert_temp(kid, n));
-        n
-    } else {
-        ui.data(|d| d.get_temp::<u64>(kid)).unwrap_or(0)
-    };
-    format!("{id:?}-{n}")
-}
-
-fn triangle(p: &egui::Painter, c: egui::Pos2, left: bool, col: Color32) {
-    let (dx, h) = (if left { -3.5 } else { 3.5 }, 4.0);
-    p.add(egui::Shape::convex_polygon(vec![pos2(c.x + dx, c.y), pos2(c.x - dx, c.y - h), pos2(c.x - dx, c.y + h)], col, Stroke::NONE));
-}
-
-/// ◀ ◆ ▶ at the right end of an animated parameter's row.
-fn key_navigator(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    p: &egui::Painter,
-    layer: &Layer,
-    prop: &Property,
-    ectx: &EvalCtx,
-    r: Rect,
-    actions: &mut Actions,
-) {
-    let t = app.tokens;
-    let cy = r.center().y;
-    let uid = prop.uid;
-    let half = ectx.comp.frame_duration().0 / 2;
-    let on_key = prop.keys.iter().any(|k| (layer.comp_time(k.time).0 - ectx.time.0).abs() <= half);
-    for (what, dx) in [("prev", -44.0), ("key", -32.0), ("next", -20.0)] {
-        let cr = Rect::from_center_size(pos2(r.max.x + dx, cy), vec2(12.0, 16.0));
-        let resp = ui.interact(cr, egui::Id::unique(("ec-nav", uid, what)), Sense::click());
-        let col = if resp.hovered() { t.text } else { t.text_dim };
-        match what {
-            "prev" => triangle(p, cr.center(), true, col),
-            "next" => triangle(p, cr.center(), false, col),
-            _ => {
-                let kr = Rect::from_center_size(cr.center(), vec2(10.0, 10.0));
-                if on_key {
-                    icons::paint(p, kr, Icon::Keyframe, t.keyframe);
-                } else {
-                    let c = kr.center();
-                    let d = 4.5;
-                    p.add(egui::Shape::closed_line(
-                        vec![pos2(c.x, c.y - d), pos2(c.x + d, c.y), pos2(c.x, c.y + d), pos2(c.x - d, c.y)],
-                        Stroke::new(1.0, col),
-                    ));
-                }
-            }
-        }
-        app.auto.add(&format!("effectControls.prop.{uid}.{what}Key"), cr, &prop.name);
-        if resp.clicked() {
-            match what {
-                "prev" => actions.push(("time.go".into(), json!({"to": "prevKey", "prop": uid}))),
-                "next" => actions.push(("time.go".into(), json!({"to": "nextKey", "prop": uid}))),
-                _ => actions.push(("prop.toggleKey".into(), json!({"layer": layer.id.0, "prop": uid, "selected": true}))),
-            }
-        }
-    }
-}
-
-/// Toggle a viewer pick (crosshair / eyedropper) for a parameter (also the Timeline's colour
-/// eyedroppers).
-pub(crate) fn toggle_pick(app: &mut EffectcraftApp, kind: &str, layer: &Layer, prop: &Property) {
-    let pick = FxPick { kind: kind.into(), layer: layer.id.0, prop: prop.uid, name: prop.name.clone() };
-    if app.ui.fx_pick.as_ref() == Some(&pick) {
-        app.ui.fx_pick = None;
-    } else {
-        app.ui.fx_pick = Some(pick);
-        app.ui.text_color_pick = None;
-        app.ui.status = if kind == "point" {
-            format!("Click in the Composition panel to set {}", prop.name)
-        } else {
-            format!("Click in the Composition panel to sample {}", prop.name)
-        };
-    }
-}
-
-/// One property row: stopwatch, name, value control (and the keyframe navigator). Returns the
-/// value fields of a vector, one per dimension, for the pick whip.
-#[allow(clippy::too_many_arguments)]
-fn prop_row(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    p: &egui::Painter,
-    layer: &Layer,
-    group: &PropGroup,
-    prop: &Property,
-    ectx: &EvalCtx,
-    r: Rect,
-    indent: f32,
-    actions: &mut Actions,
-) -> Vec<Rect> {
-    let t = app.tokens;
-    let mut dims = vec![];
-    let cy = r.center().y;
-    let uid = prop.uid;
-    if ui.input(|i| i.pointer.primary_pressed()) && ui.rect_contains_pointer(r) {
-        let add = ui.input(|i| i.modifiers.shift || i.modifiers.command);
-        actions.push(("prop.select".into(), json!({"layer": layer.id.0, "prop": uid, "add": add})));
-    }
-    let swr = Rect::from_center_size(pos2(r.min.x + indent, cy), vec2(14.0, 14.0));
-    if !prop.static_only && !matches!(prop.ui, ParamUi::Hidden) {
-        let resp = ui.interact(swr, egui::Id::unique(("ec-sw", uid)), Sense::click());
-        icons::paint(
-            p,
-            swr,
-            Icon::Stopwatch,
-            if prop.is_animated() {
-                t.hot_text
-            } else if resp.hovered() {
-                t.text
-            } else {
-                t.text_dim
-            },
-        );
-        app.auto.add(&format!("effectControls.prop.{uid}.stopwatch"), swr, &prop.name);
-        if resp.clicked() {
-            actions.push(("prop.toggleAnimation".into(), json!({"layer": layer.id.0, "prop": uid, "selected": true})));
-        }
-    }
-    if prop.is_animated() {
-        key_navigator(app, ui, p, layer, prop, ectx, r, actions);
-    }
-    let value = ectx.value(layer, prop);
-    // Keep a shared value column while names and their icons follow the group hierarchy.
-    // Extremely deep groups still leave a little name space before their value.
-    let vx = (r.min.x + r.width() * 0.48).max(r.min.x + PARAM_NAME_X + 124.0).max(swr.max.x + 40.0);
-    // A vector's values end before the keyframe navigator: in a narrow panel they move left over
-    // the name (cut short) instead of running under the navigator (#271).
-    let vx = match &value {
-        Value::Vec2(_) | Value::Vec3(_) => {
-            let point = if matches!(prop.ui, ParamUi::Point | ParamUi::Point3) { 22.0 } else { 0.0 };
-            let fields: f32 = value
-                .components()
-                .iter()
-                .take(shown_dims(layer, prop, &value))
-                .map(|v| p.layout_no_wrap(format!("{v:.1}"), Tokens::ui(12.0), t.hot_text).size().x + 12.0)
-                .sum();
-            let right = r.max.x - if prop.is_animated() { 52.0 } else { 8.0 };
-            vx.min(right - point - fields + 8.0).max(swr.max.x + 60.0)
-        }
-        _ => vx,
-    };
-    let name_clip = Rect::from_min_max(pos2(swr.max.x + 6.0, r.min.y), pos2(vx - 6.0, r.max.y));
-    app.auto.add(&format!("effectControls.prop.{uid}.name"), name_clip, &prop.name);
-    p.with_clip_rect(name_clip.intersect(p.clip_rect())).text(pos2(swr.max.x + 6.0, cy), Align2::LEFT_CENTER, &prop.name, Tokens::ui(12.0), t.text);
-    let name_response = ui.interact(name_clip, egui::Id::unique(("ec-prop-name", uid)), Sense::click());
-    if name_response.double_clicked() {
-        app.ui.timeline.search.clear();
-        app.ui.timeline.scroll_to = Some(crate::state::ScrollTo::Property(uid));
-        if let Err(e) = crate::menus::frontend(app, ui.ctx(), "timeline.revealProps", json!({"props": [{"layer": layer.id.0, "prop": uid}]})) {
-            app.ui.status = e;
-        }
-        app.show_panel(crate::dock::PanelKind::Timeline);
-    }
-    app.auto.add(&format!("effectControls.prop.{uid}.name"), name_clip, &prop.name);
-    let merge = format!("ec-{uid}");
-    // With several layers selected the edit applies to the same effect property of each (#491).
-    let scrub = ui.ctx().dragged_id().is_some() && ui.input(|i| i.pointer.is_decidedly_dragging());
-    let set = |actions: &mut Actions, v: serde_json::Value| {
-        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": uid, "value": v, "merge": merge, "selected": true, "offset": scrub})))
-    };
-    let twirl_open = |app: &mut EffectcraftApp, ui: &mut egui::Ui| {
-        let open = app.ui.fx_slider_open.contains(&uid);
-        let tw = Rect::from_center_size(pos2(swr.min.x - 9.0, cy), vec2(10.0, 10.0));
-        if widgets::twirl(ui, tw, open, egui::Id::unique(("ec-stw", uid)), &t).clicked() {
-            if open {
-                app.ui.fx_slider_open.remove(&uid);
-            } else {
-                app.ui.fx_slider_open.insert(uid);
-            }
-        }
-        app.auto.add(&format!("effectControls.prop.{uid}.twirl"), tw, &prop.name);
-    };
-    match &value {
-        Value::Scalar(v) if matches!(prop.ui, ParamUi::Mask) => {
-            // A mask of this layer ("Path" popup).
-            let mut opts = vec!["None".to_string()];
-            if let Some(m) = layer.masks() {
-                opts.extend(m.groups().map(|g| g.name.clone()));
-            }
-            let i = v.round().max(0.0) as usize;
-            let label = opts.get(i).cloned().unwrap_or_else(|| format!("Mask {i}"));
-            let dr = Rect::from_min_size(pos2(vx, cy - 9.0), vec2((r.max.x - vx - 56.0).clamp(80.0, 200.0), 18.0));
-            let pop = egui::Id::unique(("ec-mpop", uid));
-            if widgets::dropdown(ui, dr, &label, &t, egui::Id::unique(("ec-m", uid))).clicked() {
-                widgets::open_popup(ui, pop);
-            }
-            app.auto.add(&format!("effectControls.prop.{uid}.value"), dr, &prop.name);
-            if let Some(ni) = widgets::popup_menu(ui, pop, dr.left_bottom(), &opts, Some(i)) {
-                set(actions, json!(ni as f64));
-            }
-        }
-        Value::Scalar(v) if matches!(prop.ui, ParamUi::Angle) => {
-            let (rr, dr, nv) = fw::angle_field(ui, pos2(vx, cy - 9.0), egui::Id::unique(("ec-v", uid)), *v, 1, &t);
-            app.auto.add(&format!("effectControls.prop.{uid}.value"), rr.union(dr), &fw::format_angle(*v, 1));
-            app.auto.add(&format!("effectControls.prop.{uid}.revolutions"), rr, &prop.name);
-            if let Some(nv) = nv {
-                set(actions, json!(nv));
-            }
-            twirl_open(app, ui);
-        }
-        Value::Scalar(v) => {
-            let (min, max, dec) = match &prop.ui {
-                ParamUi::Slider { min, max, decimals, .. } => (*min, *max, *decimals as usize),
-                _ => (-1e9, 1e9, 1),
-            };
-            let suffix = match prop.ui {
-                ParamUi::Percent => "%",
-                _ => "",
-            };
-            let speed = widgets::slider_scrub_speed(&prop.ui);
-            let (vr, nv, _) = widgets::hot_number_at(
-                ui,
-                pos2(vx, cy - 9.0),
-                egui::Id::unique(("ec-v", uid)),
-                *v,
-                speed,
-                (min, max),
-                dec.max(if dec == 0 { 0 } else { 1 }),
-                suffix,
-                &t,
-            );
-            app.auto.add(&format!("effectControls.prop.{uid}.value"), vr, &prop.name);
-            if let Some(nv) = nv {
-                set(actions, json!(nv));
-            }
-            // AE hides a slider param's slider until its twirl is opened (see `slider_row`).
-            if matches!(prop.ui, ParamUi::Slider { .. }) {
-                twirl_open(app, ui);
-            }
-        }
-        Value::Vec2(_) | Value::Vec3(_) => {
-            let c = value.components();
-            let n = shown_dims(layer, prop, &value);
-            let mut x = vx;
-            if matches!(prop.ui, ParamUi::Point | ParamUi::Point3) {
-                let cr = Rect::from_center_size(pos2(x + 8.0, cy), vec2(18.0, 18.0));
-                let active = app.ui.fx_pick.as_ref().is_some_and(|k| k.prop == uid && k.kind == "point");
-                if fw::crosshair_button(ui, cr, active, egui::Id::unique(("ec-xh", uid)), &t)
-                    .on_hover_text(crate::i18n::tr("Click, then click in the Composition panel"))
-                    .clicked()
-                {
-                    toggle_pick(app, "point", layer, prop);
-                }
-                app.auto.add(&format!("effectControls.prop.{uid}.crosshair"), cr, &prop.name);
-                x += 22.0;
-            }
-            for d in 0..n.min(c.len()) {
-                let (vr, nv, _) = widgets::hot_number_at(ui, pos2(x, cy - 9.0), egui::Id::unique(("ec-v", uid, d)), c[d], 1.0, (-1e9, 1e9), 1, "", &t);
-                app.auto.add(&format!("effectControls.prop.{uid}.value.{d}"), vr, &prop.name);
-                dims.push(vr);
-                if let Some(nv) = nv {
-                    let mut nc = c.clone();
-                    nc[d] = nv;
-                    set(actions, json!(nc));
-                    // Typed into this component only: other selected layers keep the rest of
-                    // their own value (#1434).
-                    if let Some((_, a)) = actions.last_mut() {
-                        a["dims"] = json!([d]);
-                    }
-                }
-                x = vr.max.x + 8.0;
-            }
-        }
-        Value::Color(c) => {
-            let sr = Rect::from_min_size(pos2(vx, cy - 8.0), vec2(30.0, 16.0));
-            let pop = egui::Id::unique(("ec-cpop", uid));
-            if widgets::swatch(ui, sr, [c[0] as f32, c[1] as f32, c[2] as f32, 1.0], egui::Id::unique(("ec-c", uid)), &t).clicked() {
-                widgets::open_popup(ui, pop);
-            }
-            app.auto.add(&format!("effectControls.prop.{uid}.value"), sr, &prop.name);
-            let er = Rect::from_center_size(pos2(sr.max.x + 14.0, cy), vec2(18.0, 18.0));
-            let active = app.ui.fx_pick.as_ref().is_some_and(|k| k.prop == uid && k.kind == "color");
-            if fw::eyedropper_button(ui, er, active, egui::Id::unique(("ec-eye", uid)), &t)
-                .on_hover_text(crate::i18n::tr("Eyedropper: click, then click in the Composition panel"))
-                .clicked()
-            {
-                toggle_pick(app, "color", layer, prop);
-            }
-            app.auto.add(&format!("effectControls.prop.{uid}.eyedropper"), er, &prop.name);
-            let mut rgb = [c[0] as f32, c[1] as f32, c[2] as f32];
-            if crate::widgets::color_popup(ui, pop, sr.left_bottom(), &mut rgb) {
-                set(actions, json!([rgb[0], rgb[1], rgb[2], 1.0]));
-            }
-        }
-        Value::Bool(b) => {
-            let cr = Rect::from_min_size(pos2(vx, cy - 8.0), vec2(16.0, 16.0));
-            if widgets::checkbox(ui, cr, *b, &t, egui::Id::unique(("ec-b", uid))).clicked() {
-                set(actions, json!(!b));
-            }
-            p.text(pos2(cr.max.x + 6.0, cy), Align2::LEFT_CENTER, &prop.name, Tokens::ui(12.0), t.text_dim);
-            app.auto.add(&format!("effectControls.prop.{uid}.value"), cr, &prop.name);
-        }
-        Value::Enum(i) => {
-            if let ParamUi::Popup { options } = &prop.ui {
-                let widest = options.iter().map(|o| p.layout_no_wrap(o.clone(), Tokens::ui(11.5), t.text).size().x).fold(0.0, f32::max);
-                let dr = Rect::from_min_size(pos2(vx, cy - 9.0), vec2((widest + 30.0).clamp(80.0, (r.max.x - vx - 56.0).max(80.0)), 18.0));
-                let pop = egui::Id::unique(("ec-epop", uid));
-                if widgets::dropdown(ui, dr, options.get(*i as usize).map(String::as_str).unwrap_or(""), &t, egui::Id::unique(("ec-e", uid))).clicked() {
-                    widgets::open_popup(ui, pop);
-                }
-                app.auto.add(&format!("effectControls.prop.{uid}.value"), dr, &prop.name);
-                if let Some(ni) = widgets::popup_menu(ui, pop, dr.left_bottom(), options, Some(*i as usize)) {
-                    set(actions, json!(ni));
-                }
-            }
-        }
-        Value::Layer(l) => {
-            let comp = app.session.active_comp_arc();
-            if let Some(comp) = comp {
-                let dr = Rect::from_min_size(pos2(vx, cy - 9.0), vec2(((r.max.x - vx) * 0.55).clamp(90.0, 170.0), 18.0));
-                if let Some(chosen) = widgets::layer_picker(ui, dr, &comp.layers, *l, &t, egui::Id::unique(("ec-l", uid))) {
-                    set(actions, chosen.map(|id| json!(id)).unwrap_or(serde_json::Value::Null));
-                }
-                app.auto.add(&format!("effectControls.prop.{uid}.value"), dr, &prop.name);
-                // Source / Masks / Effects & Masks (the hidden companion parameter).
-                if let Some(src) = group.get(&effectcraft_engine::effects::layer_source_id(&prop.match_id)) {
-                    let si = src.value.as_enum() as usize;
-                    let opts: Vec<String> = effectcraft_engine::effects::LAYER_SOURCE_OPTIONS.iter().map(|s| s.to_string()).collect();
-                    let sr = Rect::from_min_size(pos2(dr.max.x + 6.0, cy - 9.0), vec2(((r.max.x - dr.max.x) - 64.0).clamp(70.0, 120.0), 18.0));
-                    let spop = egui::Id::unique(("ec-lspop", uid));
-                    if widgets::dropdown(ui, sr, opts.get(si).map(String::as_str).unwrap_or(""), &t, egui::Id::unique(("ec-ls", uid))).clicked() {
-                        widgets::open_popup(ui, spop);
-                    }
-                    app.auto.add(&format!("effectControls.prop.{uid}.source"), sr, &src.name);
-                    if let Some(ni) = widgets::popup_menu(ui, spop, sr.left_bottom(), &opts, Some(si)) {
-                        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": src.uid, "value": ni})));
-                    }
-                }
-            }
-        }
-        // EXtractoR's red / green / blue / alpha: a popup of the footage's OpenEXR channels (#295).
-        Value::Str(s) if super::fx_editors::is_extractor_channel(group, prop) => {
-            let dr = Rect::from_min_size(pos2(vx, cy - 9.0), vec2((r.max.x - vx - 56.0).clamp(80.0, 200.0), 18.0));
-            super::fx_editors::channel_popup(app, ui, layer, prop, s, dr, actions);
-        }
-        // A file parameter (Apply Color LUT's LUT, an OCIO config): its file name and Choose…,
-        // as in After Effects.
-        Value::Str(s) if matches!(prop.ui, ParamUi::File { .. }) => {
-            let bw = 70.0;
-            let br = Rect::from_min_size(pos2(vx, cy - 9.0), vec2(bw, 18.0));
-            if widgets::text_button(ui, br, crate::i18n::tr("Choose..."), false, &t, egui::Id::unique(("ec-file", uid))).clicked() {
-                let filters: Vec<&str> = match &prop.ui {
-                    ParamUi::File { filters } => filters.iter().map(String::as_str).collect(),
-                    _ => vec![],
-                };
-                match app.hooks.pick_files.as_ref() {
-                    Some(pick) => {
-                        if let Some(path) = pick(&filters).into_iter().next() {
-                            actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": uid, "value": path})));
-                        }
-                    }
-                    None => app.ui.status = "no file dialog available: set the path with prop.set".into(),
-                }
-            }
-            app.auto.add(&format!("effectControls.prop.{uid}.choose"), br, &prop.name);
-            let shown = if s.trim().is_empty() {
-                crate::i18n::tr("None").to_string()
-            } else if s.contains('\n') {
-                prop.name.clone()
-            } else {
-                effectcraft_engine::sequence::file_name(s)
-            };
-            let nr = Rect::from_min_max(pos2(br.max.x + 8.0, r.min.y), pos2(r.max.x - 8.0, r.max.y));
-            let np = p.with_clip_rect(nr.intersect(p.clip_rect()));
-            np.text(pos2(nr.min.x, cy), Align2::LEFT_CENTER, &shown, Tokens::ui(12.0), if s.trim().is_empty() { t.text_dim } else { t.text });
-            let hover = ui.interact(nr, egui::Id::unique(("ec-file-name", uid)), Sense::hover());
-            if !s.trim().is_empty() && !s.contains('\n') {
-                hover.on_hover_text(s.as_str());
-            }
-            app.auto.add(&format!("effectControls.prop.{uid}.value"), nr, &shown);
-        }
-        // A text parameter (Cryptomatte's Selection, Colorama's Output Cycle, config names):
-        // typed in a field, set when it loses the focus (Esc keeps the old text).
-        Value::Str(s) if matches!(prop.ui, ParamUi::Text) => {
-            let fr = Rect::from_min_size(pos2(vx, cy - 9.0), vec2((r.max.x - vx - 12.0).clamp(80.0, 320.0), 18.0));
-            let bid = egui::Id::unique(("ec-text", uid));
-            let mut buf: String = ui.data(|d| d.get_temp(bid)).unwrap_or_else(|| s.clone());
-            let resp = widgets::text_field(ui, fr, &mut buf, "", &t);
-            // The field has no visible hint: give the screen reader the parameter's name.
-            resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::TextInput, ui.is_enabled(), &prop.name));
-            app.auto.add(&format!("effectControls.prop.{uid}.value"), fr, &prop.name);
-            if resp.lost_focus() {
-                if buf != *s && !ui.input(|i| i.key_pressed(egui::Key::Escape)) {
-                    actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": uid, "value": buf})));
-                }
-                ui.data_mut(|d| d.remove::<String>(bid));
-            } else if resp.has_focus() {
-                ui.data_mut(|d| d.insert_temp(bid, buf));
-            }
-        }
-        Value::Gradient(g) => {
-            let gr = Rect::from_min_size(pos2(vx, cy - 7.0), vec2((r.max.x - vx - 56.0).clamp(60.0, 180.0), 14.0));
-            let n = 48;
-            for k in 0..n {
-                let f = k as f64 / (n - 1) as f64;
-                let c = gradient_at(g, f);
-                let x0 = gr.min.x + gr.width() * k as f32 / n as f32;
-                let x1 = gr.min.x + gr.width() * (k + 1) as f32 / n as f32;
-                p.rect_filled(Rect::from_min_max(pos2(x0, gr.min.y), pos2(x1, gr.max.y)), 0.0, c);
-            }
-            p.rect_stroke(gr, 2.0, Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside);
-            app.auto.add(&format!("effectControls.prop.{uid}.value"), gr, &prop.name);
-        }
-        _ => {}
-    }
-    dims
-}
-
-/// How many of a vector parameter's values show (a 3D point's Z only on a 3D layer).
-fn shown_dims(layer: &Layer, prop: &Property, value: &Value) -> usize {
-    let n = value.components().len();
-    if prop.shown_dims > 0 && !(layer.is_3d() && n == 3) { prop.shown_dims as usize } else { n }
-}
-
-/// Colour of a gradient at `f` (colour stops only).
-fn gradient_at(g: &effectcraft_engine::keyframe::Gradient, f: f64) -> Color32 {
-    let stops = &g.colors;
-    let c = if stops.is_empty() {
-        [0.0, 0.0, 0.0, 1.0]
-    } else if f <= stops[0].0 {
-        stops[0].1
-    } else if f >= stops[stops.len() - 1].0 {
-        stops[stops.len() - 1].1
-    } else {
-        let i = stops.iter().position(|s| s.0 > f).unwrap_or(stops.len() - 1).max(1);
-        let (a, b) = (stops[i - 1], stops[i]);
-        let k = ((f - a.0) / (b.0 - a.0).max(1e-9)) as f32;
-        [0, 1, 2, 3].map(|j| a.1[j] + (b.1[j] - a.1[j]) * k)
-    };
-    Color32::from_rgb((c[0].clamp(0.0, 1.0) * 255.0) as u8, (c[1].clamp(0.0, 1.0) * 255.0) as u8, (c[2].clamp(0.0, 1.0) * 255.0) as u8)
-}
-
-/// The twirled-open slider under a slider param: track, knob and the slider range's ends.
-#[allow(clippy::too_many_arguments)]
-fn slider_row(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    p: &egui::Painter,
-    layer: &Layer,
-    prop: &Property,
-    ectx: &EvalCtx,
-    r: Rect,
-    x0: f32,
-    actions: &mut Actions,
-) {
-    let t = app.tokens;
-    let ParamUi::Slider { slider_min, slider_max, decimals, .. } = prop.ui else { return };
-    let Value::Scalar(v) = ectx.value(layer, prop) else { return };
-    let uid = prop.uid;
-    let tr = Rect::from_min_max(pos2(r.min.x + x0, r.min.y + 8.0), pos2(r.max.x - 16.0, r.min.y + 12.0));
-    if tr.width() < 40.0 {
-        return;
-    }
-    p.rect_filled(tr, 2.0, t.field_bg);
-    let f = ((v - slider_min) / (slider_max - slider_min)).clamp(0.0, 1.0) as f32;
-    p.rect_filled(Rect::from_min_max(tr.min, pos2(tr.min.x + tr.width() * f, tr.max.y)), 2.0, t.accent.gamma_multiply(0.7));
-    p.circle_filled(pos2(tr.min.x + tr.width() * f, tr.center().y), 5.0, t.text);
-    let dec = decimals as usize;
-    p.text(pos2(tr.min.x, tr.max.y + 4.0), Align2::LEFT_TOP, format!("{slider_min:.dec$}"), Tokens::ui(10.5), t.text_dim);
-    p.text(pos2(tr.max.x, tr.max.y + 4.0), Align2::RIGHT_TOP, format!("{slider_max:.dec$}"), Tokens::ui(10.5), t.text_dim);
-    let sresp = ui.interact(tr.expand2(vec2(4.0, 6.0)), egui::Id::unique(("ec-slider", uid)), Sense::click_and_drag());
-    app.auto.add(&format!("effectControls.prop.{uid}.slider"), tr, &prop.name);
-    if (sresp.dragged() || sresp.clicked())
-        && let Some(pt) = sresp.interact_pointer_pos()
-    {
-        let f = ((pt.x - tr.min.x) / tr.width()).clamp(0.0, 1.0) as f64;
-        actions.push((
-            "prop.set".into(),
-            json!({"layer": layer.id.0, "prop": uid, "value": slider_min + (slider_max - slider_min) * f, "merge": format!("ec-{uid}")}),
-        ));
-    }
-}
-
-/// The twirled-open angle dial under an angle param.
-#[allow(clippy::too_many_arguments)]
-fn dial_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, layer: &Layer, prop: &Property, ectx: &EvalCtx, r: Rect, x0: f32, actions: &mut Actions) {
-    let t = app.tokens;
-    let Value::Scalar(v) = ectx.value(layer, prop) else { return };
-    let uid = prop.uid;
-    let d = (r.height() - 12.0).min(52.0);
-    let dr = Rect::from_min_size(pos2(r.min.x + x0 + 40.0, r.min.y + 6.0), vec2(d, d));
-    let id = egui::Id::unique(("ec-dial", uid));
-    let (resp, nv) = fw::angle_dial(ui, dr, v, id, &t);
-    app.auto.add(&format!("effectControls.prop.{uid}.dial"), dr, &prop.name);
-    if let Some(nv) = nv {
-        let key = gesture_key(ui, id, resp.drag_started() || resp.clicked());
-        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": uid, "value": nv, "merge": key})));
-    }
-}
-
-/// The effect instance a row belongs to, for conditional visibility
-/// ([`effectcraft_engine::effects::catalog::param_shown`]): effect id, the instance's root
-/// group and the spec-id path of the group being drawn (`""` or `cameraPosition/`).
-struct FxScope<'a> {
-    effect: &'a str,
-    root: &'a PropGroup,
-    path: String,
-}
-
-impl<'a> FxScope<'a> {
-    fn sub(&self, m: &str) -> FxScope<'a> {
-        FxScope { effect: self.effect, root: self.root, path: format!("{}{m}/", self.path) }
-    }
-    /// Whether child `m` of the current group is shown.
-    fn shown(&self, layer: &Layer, ectx: &EvalCtx, m: &str) -> bool {
-        let root = self.root;
-        let value = |id: &str| -> Option<Value> {
-            let mut g = root;
-            let mut parts = id.split('/').peekable();
-            while let Some(part) = parts.next() {
-                if parts.peek().is_none() {
-                    return g.get(part).map(|p| ectx.value(layer, p));
-                }
-                g = g.sub(part)?;
-            }
-            None
-        };
-        effectcraft_engine::effects::catalog::param_shown(self.effect, &format!("{}{m}", self.path), &value)
-    }
-}
-
-/// Twirl `g` closed (it was `open`) or open; with `all` (Alt/Cmd-click) every group under it follows.
-fn toggle_closed(app: &mut EffectcraftApp, g: &PropGroup, open: bool, all: bool) {
-    fn walk(g: &PropGroup, out: &mut Vec<u64>) {
-        for sg in g.groups() {
-            out.push(sg.uid);
-            walk(sg, out);
-        }
-    }
-    let mut uids = vec![g.uid];
-    if all {
-        walk(g, &mut uids);
-    }
-    for u in uids {
-        if open {
-            app.ui.fx_closed.insert(u);
-        } else {
-            app.ui.fx_closed.remove(&u);
-        }
-    }
-}
-
-#[allow(clippy::too_many_arguments)]
-fn group_rows(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    p: &egui::Painter,
-    layer: &Layer,
-    g: &PropGroup,
-    ectx: &EvalCtx,
-    rect: Rect,
-    y: &mut f32,
-    depth: usize,
-    fx: &FxScope,
-    actions: &mut Actions,
-) {
-    let t = app.tokens;
-    for c in &g.children {
-        let r = Rect::from_min_size(pos2(rect.min.x, *y), vec2(rect.width(), ROW));
-        match c {
-            Node::Prop(pr) => {
-                if matches!(pr.ui, ParamUi::Hidden) || pr.three_d_only && !layer.is_3d() || !fx.shown(layer, ectx, &pr.match_id) {
-                    continue;
-                }
-                *y += ROW;
-                let indent = PARAM_NAME_X - 13.0 + TREE_INDENT * depth as f32;
-                let visible = !(r.max.y < rect.min.y || r.min.y > rect.max.y);
-                if visible {
-                    app.auto.add(&format!("effectControls.row.{}", pr.uid), r, &pr.name);
-                    let dims = prop_row(app, ui, p, layer, g, pr, ectx, r, indent, actions);
-                    // A Timeline pick whip can be dropped here (After Effects).
-                    super::timeline::whip_target(ui.ctx(), r.intersect(rect), layer.id.0, pr.uid, dims);
-                }
-                if app.ui.fx_slider_open.contains(&pr.uid) {
-                    if matches!(pr.ui, ParamUi::Angle) {
-                        let sr = Rect::from_min_size(pos2(rect.min.x, *y), vec2(rect.width(), DIAL_ROW));
-                        *y += DIAL_ROW;
-                        if sr.max.y >= rect.min.y && sr.min.y <= rect.max.y {
-                            dial_row(app, ui, layer, pr, ectx, sr, indent + 22.0, actions);
-                        }
-                    } else if matches!(pr.ui, ParamUi::Slider { .. }) {
-                        let sr = Rect::from_min_size(pos2(rect.min.x, *y), vec2(rect.width(), 34.0));
-                        *y += 34.0;
-                        if sr.max.y >= rect.min.y && sr.min.y <= rect.max.y {
-                            slider_row(app, ui, p, layer, pr, ectx, sr, indent + 22.0, actions);
-                        }
-                    }
-                }
-            }
-            Node::Group(sg) => {
-                // Paint strokes live in the Timeline only (AE's Paint shows Paint on Transparent).
-                if effectcraft_engine::effects::paint::is_paint(g) || !fx.shown(layer, ectx, &sg.match_id) {
-                    continue;
-                }
-                *y += ROW;
-                let open = !app.ui.fx_closed.contains(&sg.uid);
-                let tw = Rect::from_center_size(pos2(r.min.x + PARAM_NAME_X - 12.0 + TREE_INDENT * depth as f32, r.center().y), vec2(12.0, 12.0));
-                if r.max.y >= rect.min.y && r.min.y <= rect.max.y {
-                    app.auto.add(&format!("effectControls.row.{}", sg.uid), r, &sg.name);
-                    app.auto.add(&format!("effectControls.group.{}.twirl", sg.uid), tw, &sg.name);
-                    if widgets::twirl(ui, tw, open, egui::Id::unique(("ec-g", sg.uid)), &t).clicked() {
-                        toggle_closed(app, sg, open, ui.input(|i| i.modifiers.alt || i.modifiers.command));
-                    }
-                    let name = p.text(pos2(tw.max.x + 6.0, r.center().y), Align2::LEFT_CENTER, &sg.name, Tokens::ui(12.0), t.text);
-                    app.auto.add(&format!("effectControls.group.{}.name", sg.uid), name, &sg.name);
-                }
-                if open {
-                    let sub = fx.sub(&sg.match_id);
-                    // A visual editor for the group's hidden parameters (Lumetri curves, …).
-                    let eh = super::fx_editors::inline_height(fx.effect, &sub.path, rect.width());
-                    if eh > 0.0 {
-                        let er = Rect::from_min_size(pos2(rect.min.x, *y), vec2(rect.width(), eh));
-                        *y += eh;
-                        if er.max.y >= rect.min.y && er.min.y <= rect.max.y {
-                            super::fx_editors::inline_editor(app, ui, p, layer, fx.root, sg, fx.effect, &sub.path, ectx, er, actions);
-                        }
-                    }
-                    group_rows(app, ui, p, layer, sg, ectx, rect, y, depth + 1, &sub, actions);
-                }
-            }
-        }
-    }
-}
-
-/// Warp Stabilizer's Analyze / Cancel buttons and analysis status.
-fn warp_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, layer: &Layer, g: &PropGroup, r: Rect, actions: &mut Actions) {
-    let t = app.tokens;
-    let running = app.session.warp_target().is_some_and(|(_, l, u)| l == layer.id && u == g.uid) && app.session.is_warp_analyzing();
-    let busy = app.session.is_warp_analyzing();
-    let b1 = Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 4.0), vec2(84.0, 22.0));
-    let b2 = Rect::from_min_size(pos2(b1.max.x + 8.0, b1.min.y), vec2(84.0, 22.0));
-    if widgets::text_button(ui, b1, "Analyze", false, &t, egui::Id::unique(("warp-analyze", g.uid))).clicked() && !busy {
-        actions.push(("warp.analyze".into(), json!({"layer": layer.id.0, "effect": g.uid})));
-    }
-    app.auto.add(&format!("effectControls.warp.{}.analyze", g.uid), b1, "Analyze");
-    if running {
-        if widgets::text_button(ui, b2, "Cancel", false, &t, egui::Id::unique(("warp-cancel", g.uid))).clicked() {
-            actions.push(("warp.cancel".into(), json!({})));
-        }
-        app.auto.add(&format!("effectControls.warp.{}.cancel", g.uid), b2, "Cancel");
-    }
-    let analysed = matches!(g.get(effectcraft_engine::effects::warp_stab::ANALYSIS).map(|p| &p.value), Some(Value::Str(s)) if !s.is_empty());
-    let status = match app.session.warp_progress() {
-        Some(pr) if running => pr.banner(),
-        _ if analysed => "Analysis complete".to_string(),
-        _ if app.session.warp_pending.iter().any(|(_, l, u)| *l == layer.id && *u == g.uid) => "Waiting to analyze".to_string(),
-        _ => "Not analyzed: click Analyze".to_string(),
-    };
-    p.text(pos2(r.min.x + 24.0, r.min.y + 38.0), Align2::LEFT_CENTER, status, Tokens::ui(11.5), t.text_dim);
-}
-
-/// Roto Brush & Refine Edge: Freeze / Unfreeze and Propagate buttons and the segmentation status.
-fn roto_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, layer: &Layer, g: &PropGroup, r: Rect, actions: &mut Actions) {
-    use effectcraft_engine::effects::roto as fx;
-    let t = app.tokens;
-    let params = effectcraft_engine::effects::flatten_params(g, &mut |pr| pr.value.clone());
-    let frozen = fx::is_frozen(&params);
-    let d = fx::data(&params);
-    let running = app.session.roto_target().is_some_and(|(_, l, u, _)| l == layer.id && u == g.uid) && app.session.is_roto_running();
-    let b1 = Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 4.0), vec2(84.0, 22.0));
-    let b2 = Rect::from_min_size(pos2(b1.max.x + 8.0, b1.min.y), vec2(84.0, 22.0));
-    let label = if frozen { "Unfreeze" } else { "Freeze" };
-    if widgets::text_button(ui, b1, label, frozen, &t, egui::Id::unique(("roto-freeze-ec", g.uid))).clicked() && !running {
-        let id = if frozen { "roto.unfreeze" } else { "roto.freeze" };
-        actions.push((id.into(), json!({"layer": layer.id.0, "effect": g.uid})));
-    }
-    app.auto.add(&format!("effectControls.roto.{}.freeze", g.uid), b1, label);
-    let (l2, id2) = if running { ("Stop", "roto.cancel") } else { ("Propagate", "roto.propagate") };
-    if widgets::text_button(ui, b2, l2, false, &t, egui::Id::unique(("roto-prop-ec", g.uid))).clicked() && !frozen {
-        actions.push((id2.into(), json!({"layer": layer.id.0, "effect": g.uid})));
-    }
-    app.auto.add(&format!("effectControls.roto.{}.propagate", g.uid), b2, l2);
-    let status = match (app.session.roto_progress(), d.base) {
-        (Some(pr), _) if running => pr.banner(),
-        (_, None) => "No strokes: paint with the Roto Brush tool (Alt+W) in the Layer panel".to_string(),
-        (_, Some(b)) => format!("Base frame {b}, span {}–{}{}", d.span[0], d.span[1], if frozen { " (frozen)" } else { "" }),
-    };
-    p.text(pos2(r.min.x + 24.0, r.min.y + 38.0), Align2::LEFT_CENTER, status, Tokens::ui(11.5), t.text_dim);
-}
-
-/// Object Matte: Freeze / Unfreeze and Track / Stop buttons (the background job that computes
-/// the matte over the tracked frames) and its status.
-fn object_matte_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, layer: &Layer, g: &PropGroup, r: Rect, actions: &mut Actions) {
-    use effectcraft_engine::effects::object_matte as om;
-    let t = app.tokens;
-    let params = effectcraft_engine::effects::flatten_params(g, &mut |pr| pr.value.clone());
-    let frozen = om::is_frozen(&params);
-    let mine = app.session.roto_target().is_some_and(|(_, l, u, _)| l == layer.id && u == g.uid);
-    let running = mine && app.session.is_roto_running();
-    let busy = app.session.is_roto_running();
-    let b1 = Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 4.0), vec2(84.0, 22.0));
-    let b2 = Rect::from_min_size(pos2(b1.max.x + 8.0, b1.min.y), vec2(84.0, 22.0));
-    let label = if frozen { "Unfreeze" } else { "Freeze" };
-    if widgets::text_button(ui, b1, crate::i18n::tr(label), frozen, &t, egui::Id::unique(("om-freeze-ec", g.uid))).clicked() && !busy {
-        let id = if frozen { "objectMatte.unfreeze" } else { "objectMatte.freeze" };
-        actions.push((id.into(), json!({"layer": layer.id.0, "effect": g.uid})));
-    }
-    app.auto.add(&format!("effectControls.objectMatte.{}.freeze", g.uid), b1, label);
-    let (l2, id2) = if running { ("Stop", "roto.cancel") } else { ("Track", "objectMatte.propagate") };
-    if widgets::text_button(ui, b2, crate::i18n::tr(l2), false, &t, egui::Id::unique(("om-track-ec", g.uid))).clicked() && !frozen && (running || !busy) {
-        actions.push((id2.into(), json!({"layer": layer.id.0, "effect": g.uid})));
-    }
-    app.auto.add(&format!("effectControls.objectMatte.{}.track", g.uid), b2, l2);
-    let base = om::reference_frame(&params);
-    let status = match app.session.roto_progress() {
-        Some(pr) if running => pr.banner(),
-        _ if frozen => format!("Frozen from reference frame {base}"),
-        _ if app.session.roto_pending.iter().any(|(_, l, u)| *l == layer.id && *u == g.uid) => "Waiting to track".to_string(),
-        _ => format!("Reference frame {base}: Track computes the matte ahead of playback"),
-    };
-    p.text(pos2(r.min.x + 24.0, r.min.y + 38.0), Align2::LEFT_CENTER, &status, Tokens::ui(11.5), t.text_dim);
-    app.auto.add(
-        &format!("effectControls.objectMatte.{}.status", g.uid),
-        Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 30.0), vec2(r.width() - 24.0, 16.0)),
-        &status,
-    );
-}
-
-// ---------------------------------------------------------------------------------------------
-// Curves / Levels editors
-
-/// Height of the custom editor shown under an effect's header (0 when none).
-fn editor_height(effect: &str, g: &PropGroup, width: f32) -> f32 {
-    match effect {
-        super::fx_editors::GLOW | super::fx_editors::RESHAPE | super::fx_editors::EXTRACTOR => super::fx_editors::header_height(effect, g, width),
-        "ec.color.curves" => 34.0 + curves_size(width) + 26.0,
-        effectcraft_engine::effects::warp_stab::ID => 50.0,
-        effectcraft_engine::effects::camera_tracker::ID => super::camera_tracker_ui::EDITOR_HEIGHT,
-        effectcraft_engine::effects::roto::ID | effectcraft_engine::effects::object_matte::ID => 50.0,
-        "ec.color.levels" | "ec.color.levelsic" => 34.0 + 80.0 + 58.0,
-        "ec.color.autolevels" | "ec.color.autocontrast" | "ec.color.autocolor" => 24.0 + 80.0 + 12.0,
-        _ => 0.0,
-    }
-}
-
-fn curves_size(width: f32) -> f32 {
-    (width - 72.0).clamp(120.0, 256.0)
-}
-
-/// Cached histogram of the displayed frame (recomputed when the frame changes).
-fn frame_histogram(app: &mut EffectcraftApp, ctx: &egui::Context) -> Option<std::sync::Arc<[[u32; 256]; 5]>> {
-    let img = app.viewer_pixels()?;
-    let key = std::sync::Arc::as_ptr(&img) as usize;
-    let id = egui::Id::unique("ec-histogram");
-    if let Some((k, h)) = ctx.data(|d| d.get_temp::<(usize, std::sync::Arc<[[u32; 256]; 5]>)>(id))
-        && k == key
-    {
-        return Some(h);
-    }
-    let h = std::sync::Arc::new(fw::histogram(&img));
-    ctx.data_mut(|d| d.insert_temp(id, (key, h.clone())));
-    Some(h)
-}
-
-fn channel_color(ch: usize) -> Color32 {
-    match ch {
-        1 => Color32::from_rgb(0xe0, 0x50, 0x50),
-        2 => Color32::from_rgb(0x50, 0xc8, 0x60),
-        3 => Color32::from_rgb(0x50, 0x80, 0xf0),
-        4 => Color32::from_gray(0x90),
-        _ => Color32::from_gray(0xb8),
-    }
-}
-
-/// A "Channel: [RGB ▾]" popup; returns the chosen channel.
-#[allow(clippy::too_many_arguments)]
-fn channel_popup(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    p: &egui::Painter,
-    x: f32,
-    cy: f32,
-    cur: usize,
-    names: &[&str],
-    id: egui::Id,
-    auto: &str,
-) -> Option<usize> {
-    let t = app.tokens;
-    p.text(pos2(x, cy), Align2::LEFT_CENTER, crate::i18n::tr("Channel:"), Tokens::ui(12.0), t.text_dim);
-    let dr = Rect::from_min_size(pos2(x + 58.0, cy - 9.0), vec2(80.0, 18.0));
-    let pop = id.with("pop");
-    if widgets::dropdown(ui, dr, names.get(cur).copied().unwrap_or(""), &t, id).clicked() {
-        widgets::open_popup(ui, pop);
-    }
-    app.auto.add(auto, dr, "Channel");
-    let opts: Vec<String> = names.iter().map(|s| s.to_string()).collect();
-    widgets::popup_menu(ui, pop, dr.left_bottom(), &opts, Some(cur))
-}
-
-/// Curves: channel popup, Bezier/pencil mode, Reset, and the graph bound to the channel's
-/// hidden point-list parameter.
-#[allow(clippy::too_many_arguments)]
-fn curves_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, layer: &Layer, g: &PropGroup, ectx: &EvalCtx, r: Rect, actions: &mut Actions) {
-    let t = app.tokens;
-    let euid = g.uid;
-    // The channel lives in the effect's hidden Channel parameter (UI state for instances
-    // saved before it existed).
-    let chan_prop = g.get("channel");
-    let ch = match chan_prop {
-        Some(pr) => ectx.value(layer, pr).as_enum() as usize,
-        None => app.ui.fx_curve_channel.get(&euid).copied().unwrap_or(0),
-    }
-    .min(4);
-    let x0 = r.min.x + 30.0;
-    let cy = r.min.y + 17.0;
-    let names: [&str; 5] = [crate::i18n::tr("RGB"), crate::i18n::tr("Red"), crate::i18n::tr("Green"), crate::i18n::tr("Blue"), crate::i18n::tr("Alpha")];
-    if let Some(n) = channel_popup(app, ui, p, x0, cy, ch, &names, egui::Id::unique(("ec-cch", euid)), &format!("effectControls.effect.{euid}.curves.channel"))
-    {
-        match chan_prop {
-            Some(pr) => actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": pr.uid, "value": n}))),
-            None => {
-                app.ui.fx_curve_channel.insert(euid, n);
-            }
-        }
-    }
-    let pencil = app.ui.fx_curve_pencil.contains(&euid);
-    let mr = Rect::from_min_size(pos2(x0 + 146.0, cy - 9.0), vec2(56.0, 18.0));
-    if widgets::dropdown(ui, mr, if pencil { "Pencil" } else { "Bezier" }, &t, egui::Id::unique(("ec-cmode", euid))).clicked() {
-        if pencil {
-            app.ui.fx_curve_pencil.remove(&euid);
-        } else {
-            app.ui.fx_curve_pencil.insert(euid);
-        }
-    }
-    app.auto.add(&format!("effectControls.effect.{euid}.curves.mode"), mr, "Curve mode");
-    let Some(prop) = g.get(fw::CURVE_CHANNELS[ch].0) else { return };
-    let cur = match ectx.value(layer, prop) {
-        Value::Str(s) => fw::CurvePoints::parse(&s),
-        _ => fw::CurvePoints::identity(),
-    };
-    let rr = Rect::from_min_size(pos2(mr.max.x + 8.0, cy - 9.0), vec2(44.0, 18.0));
-    let rresp = ui.interact(rr, egui::Id::unique(("ec-creset", euid)), Sense::click());
-    p.text(rr.center(), Align2::CENTER_CENTER, crate::i18n::tr("Reset"), Tokens::ui(11.5), if rresp.hovered() { t.hot_text } else { t.text_dim });
-    app.auto.add(&format!("effectControls.effect.{euid}.curves.reset"), rr, "Reset curve");
-    if rresp.clicked() {
-        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": prop.uid, "value": fw::CurvePoints::identity().format()})));
-    }
-    let size = curves_size(r.width());
-    let gr = Rect::from_min_size(pos2(x0 + 8.0, r.min.y + 38.0), vec2(size, size));
-    // Input/output gradients along the axes.
-    let col = channel_color(ch);
-    p.rect_filled(Rect::from_min_max(pos2(gr.min.x, gr.max.y + 3.0), pos2(gr.max.x, gr.max.y + 8.0)), 0.0, col.gamma_multiply(0.5));
-    let id = egui::Id::unique(("ec-curves", euid, ch));
-    let (resp, edit) = fw::curves_graph(ui, gr, &cur, ch, pencil, true, id, &t);
-    app.auto.add(&format!("effectControls.effect.{euid}.curves.graph"), gr, "Curves");
-    let started = resp.drag_started() || resp.clicked();
-    if let Some(np) = edit.changed {
-        let key = gesture_key(ui, id, started);
-        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": prop.uid, "value": np.format(), "merge": key})));
-    }
-    p.text(
-        pos2(gr.min.x, gr.max.y + 18.0),
-        Align2::LEFT_CENTER,
-        if pencil { "Drag to draw the curve" } else { "Click adds a point; drag one off to remove" },
-        Tokens::ui(10.5),
-        t.text_faint,
-    );
-}
-
-/// Levels parameter ids for a channel: input black, input white, gamma, output black, output white.
-fn levels_ids(effect: &str, ch: usize) -> [String; 5] {
-    if effect == "ec.color.levels" {
-        return effectcraft_engine::effects::levels_channel_ids(ch);
-    }
-    // Levels (Individual Controls) nests each channel's controls in its twirl-down group.
-    let pre = fw::LEVELS_CHANNELS[ch.min(4)].0;
-    ["InBlack", "InWhite", "Gamma", "OutBlack", "OutWhite"].map(|s| format!("{pre}/{pre}{s}"))
-}
-
-/// Levels: (channel popup,) histogram, input black/gamma/white triangles, output bar with
-/// black/white triangles.
-#[allow(clippy::too_many_arguments)]
-fn levels_editor(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    p: &egui::Painter,
-    layer: &Layer,
-    g: &PropGroup,
-    effect: &str,
-    ectx: &EvalCtx,
-    r: Rect,
-    actions: &mut Actions,
-) {
-    let t = app.tokens;
-    let euid = g.uid;
-    let x0 = r.min.x + 30.0;
-    let cy = r.min.y + 17.0;
-    // Levels keeps its channel in the Channel parameter; Levels (Individual Controls) shows
-    // every channel and the popup only picks the histogram.
-    let ch = if effect == "ec.color.levelsic" {
-        app.ui.fx_levels_channel.get(&euid).copied().unwrap_or(0).min(4)
-    } else {
-        g.get("channel").map(|pr| ectx.value(layer, pr).as_enum() as usize).unwrap_or(0).min(4)
-    };
-    if effect == "ec.color.levelsic" {
-        let names: [&str; 5] = [crate::i18n::tr("RGB"), crate::i18n::tr("Red"), crate::i18n::tr("Green"), crate::i18n::tr("Blue"), crate::i18n::tr("Alpha")];
-        if let Some(n) =
-            channel_popup(app, ui, p, x0, cy, ch, &names, egui::Id::unique(("ec-lch", euid)), &format!("effectControls.effect.{euid}.levels.channel"))
-        {
-            app.ui.fx_levels_channel.insert(euid, n);
-        }
-    } else {
-        p.text(pos2(x0, cy), Align2::LEFT_CENTER, crate::i18n::tr("Histogram"), Tokens::ui(12.0), t.text_dim);
-    }
-    let w = (r.width() - 72.0).clamp(120.0, 256.0);
-    let hr = Rect::from_min_size(pos2(x0 + 8.0, r.min.y + 34.0), vec2(w, 80.0));
-    match frame_histogram(app, ui.ctx()) {
-        // Channel 0 (RGB) shows luminance; the others their own channel.
-        Some(h) => fw::draw_histogram(p, hr, &h[ch], channel_color(ch)),
-        None => {
-            p.rect_filled(hr, 0.0, Color32::from_rgb(0x1c, 0x1c, 0x1c));
-        }
-    }
-    app.auto.add(&format!("effectControls.effect.{euid}.levels.histogram"), hr, "Histogram");
-    let ids = levels_ids(effect, ch);
-    let val = |id: &str| g.prop(id).map(|pr| ectx.value(layer, pr).as_f64()).unwrap_or(0.0);
-    let (ib, iw, gm, ob, ow) = (val(&ids[0]), val(&ids[1]), val(&ids[2]), val(&ids[3]), val(&ids[4]));
-    let mut set = |ui: &egui::Ui, id: &str, v: f64, started: bool| {
-        if let Some(pr) = g.prop(id) {
-            let key = gesture_key(ui, egui::Id::unique(("ec-lv", euid, id)), started);
-            actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": pr.uid, "value": v, "merge": key})));
-        }
-    };
-    let track = Rect::from_min_size(pos2(hr.min.x, hr.max.y + 1.0), vec2(w, 10.0));
-    let started = |ui: &egui::Ui| ui.input(|i| i.pointer.any_pressed());
-    let (r0, nv) = fw::level_handle(ui, track, ib, Color32::BLACK, egui::Id::unique(("ec-lib", euid, ch)), &t);
-    app.auto.add(&format!("effectControls.effect.{euid}.levels.inBlack"), r0, "Input Black");
-    if let Some(v) = nv {
-        set(ui, &ids[0], v.min(iw - 0.005), started(ui));
-    }
-    let gx = fw::gamma_handle(ib, iw, gm);
-    let (r1, nv) = fw::level_handle(ui, track, gx, Color32::from_gray(128), egui::Id::unique(("ec-lg", euid, ch)), &t);
-    app.auto.add(&format!("effectControls.effect.{euid}.levels.gamma"), r1, "Gamma");
-    if let Some(v) = nv {
-        set(ui, &ids[2], (fw::gamma_from_handle(ib, iw, v) * 100.0).round() / 100.0, started(ui));
-    }
-    let (r2, nv) = fw::level_handle(ui, track, iw, Color32::WHITE, egui::Id::unique(("ec-liw", euid, ch)), &t);
-    app.auto.add(&format!("effectControls.effect.{euid}.levels.inWhite"), r2, "Input White");
-    if let Some(v) = nv {
-        set(ui, &ids[1], v.max(ib + 0.005), started(ui));
-    }
-    // Output: a black→white bar with its two triangles.
-    let bar = Rect::from_min_size(pos2(hr.min.x, track.max.y + 10.0), vec2(w, 9.0));
-    let n = 32;
-    for k in 0..n {
-        let v = (k as f32 / (n - 1) as f32 * 255.0) as u8;
-        let x0 = bar.min.x + bar.width() * k as f32 / n as f32;
-        let x1 = bar.min.x + bar.width() * (k + 1) as f32 / n as f32;
-        p.rect_filled(Rect::from_min_max(pos2(x0, bar.min.y), pos2(x1, bar.max.y)), 0.0, Color32::from_gray(v));
-    }
-    let otrack = Rect::from_min_size(pos2(bar.min.x, bar.max.y + 1.0), vec2(w, 10.0));
-    let (r3, nv) = fw::level_handle(ui, otrack, ob, Color32::BLACK, egui::Id::unique(("ec-lob", euid, ch)), &t);
-    app.auto.add(&format!("effectControls.effect.{euid}.levels.outBlack"), r3, "Output Black");
-    if let Some(v) = nv {
-        set(ui, &ids[3], v, started(ui));
-    }
-    let (r4, nv) = fw::level_handle(ui, otrack, ow, Color32::WHITE, egui::Id::unique(("ec-low", euid, ch)), &t);
-    app.auto.add(&format!("effectControls.effect.{euid}.levels.outWhite"), r4, "Output White");
-    if let Some(v) = nv {
-        set(ui, &ids[4], v, started(ui));
-    }
-}
-
-/// Auto Levels / Auto Contrast / Auto Color: the histogram they work from.
-fn histogram_only(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, g: &PropGroup, r: Rect) {
-    let t = app.tokens;
-    let x0 = r.min.x + 30.0;
-    p.text(pos2(x0, r.min.y + 12.0), Align2::LEFT_CENTER, crate::i18n::tr("Histogram"), Tokens::ui(12.0), t.text_dim);
-    let w = (r.width() - 72.0).clamp(120.0, 256.0);
-    let hr = Rect::from_min_size(pos2(x0 + 8.0, r.min.y + 24.0), vec2(w, 80.0));
-    match frame_histogram(app, ui.ctx()) {
-        Some(h) => {
-            fw::draw_histogram(p, hr, &h[1], channel_color(1).gamma_multiply(0.6));
-            fw::draw_histogram_overlay(p, hr, &h[2], channel_color(2).gamma_multiply(0.6));
-            fw::draw_histogram_overlay(p, hr, &h[3], channel_color(3).gamma_multiply(0.6));
-        }
-        None => {
-            p.rect_filled(hr, 0.0, Color32::from_rgb(0x1c, 0x1c, 0x1c));
-        }
-    }
-    app.auto.add(&format!("effectControls.effect.{}.histogram", g.uid), hr, "Histogram");
-}
-
-// ---------------------------------------------------------------------------------------------
-
-/// Open the rename field on effect `uid` (Enter with the effect selected), name selected.
-pub fn start_rename(ctx: &egui::Context, uid: u64, name: &str) {
-    let id = egui::Id::unique(("ec-rename", uid));
-    ctx.data_mut(|d| d.insert_temp(id, name.to_string()));
-    ctx.data_mut(|d| d.insert_temp(id.with("select"), true));
-    ctx.memory_mut(|m| m.request_focus(id.with("field")));
-}
-
-pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
-    let t = app.tokens;
-    let p = ui.painter().with_clip_rect(rect);
-    let ctx = ui.ctx().clone();
-    let Some(layer) = selected_layer(app) else {
-        p.text(rect.center(), Align2::CENTER_CENTER, crate::i18n::tr("Select a layer to see its effects"), Tokens::ui(12.0), t.text_faint);
-        return;
-    };
-    let Some(cid) = app.session.active_comp_id() else { return };
-    let comp = app.session.project.comp_arc(cid).unwrap_or_else(|| effectcraft_engine::project::Comp::new(1, 1, Default::default(), Default::default()).into());
-    let comp_name = app.session.project.item(cid).map(|i| i.name.clone()).unwrap_or_default();
-    let snap_project = app.session.project.clone();
-    let snap_expr = app.session.expr.clone();
-    let ectx = EvalCtx { project: &snap_project, comp_id: cid, comp: &comp, time: app.session.time(), expr: snap_expr.as_deref(), footage: None };
-    let hdr = Rect::from_min_size(rect.min, vec2(rect.width(), 24.0));
-    p.text(pos2(hdr.min.x + 10.0, hdr.center().y), Align2::LEFT_CENTER, format!("{} • {}", comp_name, layer.name), Tokens::ui(11.5), t.text_dim);
-    p.line_segment([hdr.left_bottom(), hdr.right_bottom()], Stroke::new(1.0, t.separator));
-    let body = Rect::from_min_max(pos2(rect.min.x, hdr.max.y), rect.max);
-    let scroll = widgets::PanelScroll::begin(ui, egui::Id::unique("ec-scroll"), body);
-    let mut y = body.min.y + 4.0 - scroll.offset;
-    let mut actions: Actions = vec![];
-    let bp = p.with_clip_rect(body);
-    // Rows scroll under the header: clip their widgets (and hit tests) to the body.
-    let panel_clip = ui.clip_rect();
-    ui.set_clip_rect(body.intersect(panel_clip));
-    let fx: Vec<PropGroup> = layer.effects().map(|f| f.groups().cloned().collect()).unwrap_or_default();
-    if fx.is_empty() {
-        bp.text(
-            pos2(body.center().x, body.min.y + 40.0),
-            Align2::CENTER_CENTER,
-            "No effects. Drag one from Effects & Presets.",
-            Tokens::ui(12.0),
-            t.text_faint,
-        );
-    }
-    // Clicking empty space deselects the effects.
-    let bg = ui.interact(body, egui::Id::unique("ec-bg"), Sense::click());
-    if bg.clicked() {
-        app.session.state.selected_props.retain(|(l, u)| !(*l == layer.id && fx.iter().any(|g| effect_active(g, layer.id, &[(*l, *u)]))));
-    }
-    let has_clip = !app.session.state.effect_clipboard.is_empty();
-    let drag_id = egui::Id::unique("ec-drag-effect");
-    let dragging: Option<u64> = ctx.data(|d| d.get_temp(drag_id));
-    // Header tops, for drag-to-reorder.
-    let mut tops: Vec<(u64, f32)> = vec![];
-    for (fi, g) in fx.iter().enumerate() {
-        let GroupKind::Effect { effect } = &g.kind else { continue };
-        // The header draws the effect's name in the interface language; the automation labels
-        // below keep the property tree's name, which is the registry's English name (#821).
-        let shown = crate::i18n::effects::group(effect, &g.name);
-        let r = Rect::from_min_size(pos2(body.min.x, y), vec2(body.width(), ROW + 2.0));
-        tops.push((g.uid, r.min.y));
-        y += ROW + 2.0;
-        let open = !app.ui.fx_closed.contains(&g.uid);
-        let selected = app.session.state.selected_props.iter().any(|(l, u)| *l == layer.id && *u == g.uid);
-        let active = effect_active(g, layer.id, &app.session.state.selected_props);
-        bp.rect_filled(r, 0.0, if active { t.fx_header_active } else { t.fx_header });
-        // The effect's colour label (26.5): a bar on the header's left edge.
-        if let Some(lab) = g.label.filter(|l| *l != effectcraft_engine::color::Label::None) {
-            let [lr, lg, lb] = app.session.prefs.label_rgb(lab);
-            bp.rect_filled(Rect::from_min_size(r.min, vec2(4.0, r.height())), 0.0, Color32::from_rgb(lr, lg, lb));
-            app.auto.add(
-                &format!("effectControls.effect.{}.label", g.uid),
-                Rect::from_min_size(r.min, vec2(4.0, r.height())),
-                &app.session.prefs.label_name(lab),
-            );
-        }
-        let fxr = Rect::from_center_size(pos2(r.min.x + 14.0, r.center().y), vec2(16.0, 16.0));
-        if widgets::icon_toggle(ui, fxr, Icon::Fx, g.enabled, &t, egui::Id::unique(("ec-fx", g.uid)), Sense::click()).clicked() {
-            actions.push(("effect.toggle".into(), json!({"layer": layer.id.0, "effect": g.uid})));
-        }
-        app.auto.add(&format!("effectControls.effect.{}.fx", g.uid), fxr, &g.name);
-        let tw = Rect::from_center_size(pos2(r.min.x + 32.0, r.center().y), vec2(12.0, 12.0));
-        if widgets::twirl(ui, tw, open, egui::Id::unique(("ec-tw", g.uid)), &t).clicked() {
-            toggle_closed(app, g, open, ui.input(|i| i.modifiers.alt || i.modifiers.command));
-        }
-        app.auto.add(&format!("effectControls.effect.{}.twirl", g.uid), tw, &g.name);
-        let rename_id = egui::Id::unique(("ec-rename", g.uid));
-        let editing: Option<String> = ctx.data(|d| d.get_temp(rename_id));
-        let reset = Rect::from_min_size(pos2(r.max.x - 96.0, r.center().y - 9.0), vec2(40.0, 18.0));
-        if let Some(mut value) = editing.as_ref().cloned() {
-            let name_rect = Rect::from_min_max(pos2(tw.max.x + 6.0, r.min.y + 2.0), pos2(reset.min.x - 6.0, r.max.y - 2.0));
-            let response = ui.put(name_rect, egui::TextEdit::singleline(&mut value).id(rename_id.with("field")).font(Tokens::semibold(12.0)));
-            // Focus the field the frame it first exists: focusing an id not yet on screen leaves
-            // the accessibility tree with a focus it doesn't contain.
-            if ctx.data_mut(|d| d.remove_temp::<bool>(rename_id.with("start"))).is_some() {
-                crate::widgets::select_all(&ctx, response.id, &value);
-                response.request_focus();
-            }
-            app.auto.add(&format!("effectControls.effect.{}.nameEdit", g.uid), name_rect, "Effect name");
-            if ctx.data_mut(|d| d.remove_temp::<bool>(rename_id.with("select"))).unwrap_or(false) {
-                widgets::select_all(&ctx, response.id, &value);
-            }
-            // Escape cancels. egui drops the field's focus on Escape in the same frame, so the
-            // key is checked on the focus being lost as well as held.
-            let escape = (response.has_focus() || response.lost_focus()) && ui.input(|i| i.key_pressed(egui::Key::Escape));
-            let commit = response.lost_focus() || (response.has_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)));
-            if escape || commit {
-                ctx.data_mut(|d| d.remove::<String>(rename_id));
-                // The field opens with the drawn name, so committing it unchanged is not a rename.
-                if !escape && !value.trim().is_empty() && value != shown {
-                    actions.push(("prop.renameGroup".into(), json!({"layer": layer.id.0, "prop": g.uid, "name": value})));
-                }
-            } else {
-                ctx.data_mut(|d| d.insert_temp(rename_id, value));
-            }
-        } else {
-            let name = bp.text(pos2(tw.max.x + 6.0, r.center().y), Align2::LEFT_CENTER, &shown, Tokens::semibold(12.0), t.text);
-            app.auto.add(&format!("effectControls.effect.{}.name", g.uid), name, &g.name);
-        }
-        let rresp = ui.interact(reset, egui::Id::unique(("ec-reset", g.uid)), Sense::click());
-        bp.text(reset.center(), Align2::CENTER_CENTER, crate::i18n::tr("Reset"), Tokens::ui(11.5), if rresp.hovered() { t.hot_text } else { t.text_dim });
-        app.auto.add(&format!("effectControls.effect.{}.reset", g.uid), reset, "Reset");
-        if rresp.clicked() {
-            actions.push(("effect.reset".into(), json!({"layer": layer.id.0, "effect": g.uid})));
-        }
-        // About…: the effect's name and category (AE's About dialog).
-        let about = Rect::from_min_size(pos2(r.max.x - 50.0, r.center().y - 9.0), vec2(44.0, 18.0));
-        let aresp = ui.interact(about, egui::Id::unique(("ec-about", g.uid)), Sense::click());
-        bp.text(about.center(), Align2::CENTER_CENTER, crate::i18n::tr("About..."), Tokens::ui(11.5), if aresp.hovered() { t.hot_text } else { t.text_dim });
-        app.auto.add(&format!("effectControls.effect.{}.about", g.uid), about, "About");
-        let apop = egui::Id::unique(("ec-about-pop", g.uid));
-        if aresp.clicked() {
-            widgets::open_popup(ui, apop);
-        }
-        if let Some(spec) = effectcraft_engine::effects::find(effect) {
-            let lines = vec![
-                crate::i18n::effects::name(spec.id, spec.name),
-                format!("Category: {}", crate::i18n::effects::category(spec.category)),
-                "EffectCraft built-in effect (MIT OR Apache-2.0)".to_string(),
-            ];
-            let _ = widgets::popup_menu(ui, apop, about.left_bottom(), &lines, None);
-        }
-        let hresp = ui.interact(
-            Rect::from_min_max(pos2(tw.max.x, r.min.y), pos2(reset.min.x - 4.0, r.max.y)),
-            egui::Id::unique(("ec-hdr", g.uid)),
-            if editing.is_some() { Sense::hover() } else { Sense::click_and_drag() },
-        );
-        if hresp.double_clicked() {
-            ctx.data_mut(|d| d.insert_temp(rename_id, shown.clone()));
-            ctx.data_mut(|d| d.insert_temp(rename_id.with("start"), true));
-        }
-        hresp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, true, active, &shown));
-        app.auto.add(&format!("effectControls.effect.{}", g.uid), r, &g.name);
-        if hresp.clicked() || hresp.drag_started() || hresp.secondary_clicked() {
-            let add = ui.input(|i| i.modifiers.shift || i.modifiers.command);
-            if add && hresp.clicked() {
-                if selected {
-                    app.session.state.selected_props.retain(|(l, u)| !(*l == layer.id && *u == g.uid));
-                } else {
-                    app.session.state.selected_props.push((layer.id, g.uid));
-                }
-            } else if !selected || hresp.clicked() {
-                app.session.state.selected_props = vec![(layer.id, g.uid)];
-            }
-        }
-        if hresp.drag_started() {
-            ctx.data_mut(|d| d.insert_temp(drag_id, g.uid));
-        }
-        crate::widgets::context_menu(&hresp, |ui| {
-            let lid = layer.id.0;
-            let mut picked_label: Option<usize> = None;
-            let mut item = |ui: &mut egui::Ui, label: &str, enabled: bool, cmd: &str, params: serde_json::Value| {
-                if ui.add_enabled(enabled, egui::Button::new(crate::i18n::context_item(cmd, &params, label))).clicked() {
-                    actions.push((cmd.into(), params));
-                    ui.close();
-                }
-            };
-            item(ui, "Copy", true, "effect.copy", json!({"layer": lid, "effect": g.uid}));
-            item(ui, "Paste", has_clip, "effect.paste", json!({"layers": [lid]}));
-            item(ui, "Duplicate", true, "effect.duplicate", json!({"layer": lid, "effect": g.uid}));
-            if ui.button(crate::i18n::tr("Rename")).clicked() {
-                ctx.data_mut(|d| d.insert_temp(rename_id, shown.clone()));
-                ctx.data_mut(|d| d.insert_temp(rename_id.with("start"), true));
-                ui.close();
-            }
-            ui.separator();
-            ui.menu_button(crate::i18n::tr("Label"), |ui| {
-                let cur = g.label.unwrap_or(effectcraft_engine::color::Label::None);
-                for (i, l) in effectcraft_engine::color::Label::ALL.into_iter().enumerate() {
-                    if widgets::label_entry(ui, l, &app.session.prefs.label_name(l), l == cur, &t).clicked() {
-                        picked_label = Some(i);
-                        ui.close();
-                    }
-                }
-            });
-            item(ui, "Reset", true, "effect.reset", json!({"layer": lid, "effect": g.uid}));
-            item(ui, "Remove", true, "effect.remove", json!({"layer": lid, "effect": g.uid}));
-            ui.separator();
-            item(ui, "Move Up", fi > 0, "effect.reorder", json!({"layer": lid, "effect": g.uid, "index": fi.max(1)}));
-            item(ui, "Move Down", fi + 1 < fx.len(), "effect.reorder", json!({"layer": lid, "effect": g.uid, "index": fi + 2}));
-            if let Some(i) = picked_label {
-                actions.push(("effect.setLabel".into(), json!({"layer": lid, "effect": g.uid, "label": i})));
-            }
-        });
-        // What the effect can't render as asked (an OCIO config it can't read, transforms it
-        // passes through), under its name.
-        if let Some(w) = effectcraft_engine::effects::warning(g, &mut |pr| ectx.value(&layer, pr)) {
-            let galley = bp.layout(format!("⚠ {w}"), Tokens::ui(11.0), t.warning, (body.width() - 20.0).max(60.0));
-            let wr = Rect::from_min_size(pos2(body.min.x + 10.0, y + 3.0), galley.size());
-            bp.galley(wr.min, galley, t.warning);
-            app.auto.add(&format!("effectControls.effect.{}.warning", g.uid), wr, &w);
-            y += wr.height() + 6.0;
-        }
-        if open {
-            let eh = editor_height(effect, g, body.width());
-            if eh > 0.0 {
-                let er = Rect::from_min_size(pos2(body.min.x, y), vec2(body.width(), eh));
-                y += eh;
-                if er.max.y >= body.min.y && er.min.y <= body.max.y {
-                    // Curves, Levels and other custom editors do not use prop_row.
-                    // Clicking their controls must activate the owner as well.
-                    if ui.input(|i| i.pointer.primary_pressed()) && ui.rect_contains_pointer(er) {
-                        actions.push(("prop.select".into(), json!({"layer":layer.id.0,"prop":g.uid})));
-                    }
-                    match effect.as_str() {
-                        "ec.color.curves" => curves_editor(app, ui, &bp, &layer, g, &ectx, er, &mut actions),
-                        effectcraft_engine::effects::warp_stab::ID => warp_editor(app, ui, &bp, &layer, g, er, &mut actions),
-                        effectcraft_engine::effects::camera_tracker::ID => super::camera_tracker_ui::editor(app, ui, &bp, &layer, g, er, &mut actions),
-                        effectcraft_engine::effects::roto::ID => roto_editor(app, ui, &bp, &layer, g, er, &mut actions),
-                        effectcraft_engine::effects::object_matte::ID => object_matte_editor(app, ui, &bp, &layer, g, er, &mut actions),
-                        "ec.color.levels" | "ec.color.levelsic" => levels_editor(app, ui, &bp, &layer, g, effect, &ectx, er, &mut actions),
-                        super::fx_editors::GLOW | super::fx_editors::RESHAPE | super::fx_editors::EXTRACTOR => {
-                            super::fx_editors::header_editor(app, ui, &bp, &layer, g, effect, &ectx, er, &mut actions)
-                        }
-                        _ => histogram_only(app, ui, &bp, g, er),
-                    }
-                }
-            }
-            let scope = FxScope { effect: effect.as_str(), root: g, path: String::new() };
-            group_rows(app, ui, &bp, &layer, g, &ectx, body, &mut y, 0, &scope, &mut actions);
-            if effect == "ec.color.tint" {
-                let r = Rect::from_min_size(pos2(body.min.x + PARAM_NAME_X, y + 2.0), vec2(120.0, ROW));
-                let label = crate::i18n::tr("Swap Colors");
-                let resp = widgets::text_button(ui, r, label, false, &t, egui::Id::unique(("ec-tint-swap", g.uid)));
-                app.auto.add_response(&format!("effectControls.effect.{}.swapColors", g.uid), &resp, label);
-                if resp.clicked() {
-                    actions.push(("prop.select".into(), json!({"layer": layer.id.0, "prop": g.uid})));
-                    actions.push(("effect.swapTintColors".into(), json!({"layer": layer.id.0, "effect": g.uid})));
-                }
-                y += ROW + 4.0;
-            }
-        }
-        y += 4.0;
-    }
-    // Drag an effect header to reorder: insertion line between headers.
-    if let Some(du) = dragging {
-        if let Some(pos) = ctx.pointer_interact_pos() {
-            let slot = tops.iter().position(|(_, ty)| pos.y < *ty + (ROW + 2.0) / 2.0).unwrap_or(tops.len());
-            let ly = tops.get(slot).map(|(_, ty)| *ty).unwrap_or(y - 4.0);
-            bp.line_segment([pos2(body.min.x + 4.0, ly), pos2(body.max.x - 4.0, ly)], Stroke::new(2.0, t.accent));
-            if ctx.input(|i| i.pointer.any_released()) {
-                if let Some(from) = tops.iter().position(|(u, _)| *u == du) {
-                    let to = if slot > from { slot - 1 } else { slot };
-                    if to != from {
-                        actions.push(("effect.reorder".into(), json!({"layer": layer.id.0, "effect": du, "index": to + 1})));
-                    }
-                }
-                ctx.data_mut(|d| d.remove::<u64>(drag_id));
-            }
-        }
-        if !ctx.input(|i| i.pointer.any_down()) {
-            ctx.data_mut(|d| d.remove::<u64>(drag_id));
-        }
-    }
-    // Right-click anywhere a control has no menu of its own: the Effect menu, which applies to
-    // the selected layers (After Effects). Drawn after the rows, whose menus open first.
-    let menu_id = bg.id.with("effect-menu");
-    let open = ui.input(|i| i.pointer.secondary_clicked())
-        && ui.rect_contains_pointer(body)
-        && (!egui::Popup::is_any_open(&ctx) || egui::Popup::is_id_open(&ctx, menu_id));
-    egui::Popup::context_menu(&bg).style(crate::widgets::menu_style).id(menu_id).open_memory(open.then_some(egui::SetOpenCommand::Bool(true))).show(|ui| {
-        ui.set_min_width(200.0);
-        actions.extend(crate::menus::menu_contents(app, ui, "Effect"));
-    });
-    ui.set_clip_rect(panel_clip);
-    let content_h = y + scroll.offset - body.min.y;
-    scroll.end(ui, &mut app.auto, "effectControls.scroll", content_h, &t);
-    // Drop effects and animation presets here.
-    if let Some(payload) = egui::DragAndDrop::payload::<crate::panels::DragPayload>(&ctx)
-        && ui.rect_contains_pointer(rect)
-        && let Some((id, params)) = match payload.as_ref() {
-            crate::panels::DragPayload::Effect(e) => Some(("effect.apply", json!({"effect": e, "layers": [layer.id.0]}))),
-            crate::panels::DragPayload::Preset { preset, .. } => Some(preset.apply_to(layer.id.0)),
-            _ => None,
-        }
-    {
-        p.rect_stroke(rect, 0.0, Stroke::new(2.0, t.accent), egui::StrokeKind::Inside);
-        if ctx.input(|i| i.pointer.any_released()) {
-            actions.push((id.into(), params));
-            egui::DragAndDrop::clear_payload(&ctx);
-        }
-    }
-    if ui.input(|i| i.pointer.primary_down()) && actions.iter().any(|(id, _)| id == "prop.set") {
-        app.ui.viewer.property_interacting = true;
-        ctx.request_repaint();
-    }
-    for (id, params) in actions {
-        if let Err(e) = crate::menus::invoke(app, &ctx, &id, params) {
-            app.ui.status = e;
-        }
-    }
-}
-
-// ---------------------------------------------------------------------------------------------
-// Viewer hook
-
-/// Collect point controls through visible parameter groups. Hidden optional slots do not
-/// leave stray viewport handles. The depth cap also bounds malformed project trees.
-fn visible_points<'a>(g: &'a PropGroup, scope: &FxScope<'_>, layer: &Layer, ectx: &EvalCtx, depth: usize, out: &mut Vec<&'a Property>) {
-    if depth > 16 {
-        return;
-    }
-    for node in &g.children {
-        match node {
-            Node::Prop(p) if matches!(p.ui, ParamUi::Point) && scope.shown(layer, ectx, &p.match_id) => out.push(p),
-            Node::Group(child) if child.enabled && scope.shown(layer, ectx, &child.match_id) => {
-                visible_points(child, &scope.sub(&child.match_id), layer, ectx, depth + 1, out)
-            }
-            _ => {}
-        }
-    }
-}
-
-/// Effect Controls' part of the Composition viewer, called by the viewer after its own
-/// interaction (so these controls sit on top):
-///
-/// - while a crosshair pick is armed, its handle previews the cursor position without editing
-///   the property; the next click sets the point in layer space, and Esc cancels;
-/// - an eyedropper pick samples the frame's colour on click;
-/// - otherwise, the point parameters of the selected effects are drawn as draggable ⊕ controls.
-///
-/// `l2c` is the viewer's layer→comp matrix (it knows the 3D view).
-pub fn viewer_hook(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    painter: &egui::Painter,
-    map: &super::viewer::ViewerMap,
-    ectx: &EvalCtx,
-    l2c: &dyn Fn(&EvalCtx, &Layer) -> Mat3,
-) {
-    let t = app.tokens;
-    let ctx = ui.ctx().clone();
-    let mut actions: Actions = vec![];
-    let mut point_preview = None;
-    if let Some(pick) = app.ui.fx_pick.clone() {
-        let Some(layer) = ectx.comp.layer(effectcraft_engine::project::LayerId(pick.layer)).cloned() else {
-            app.ui.fx_pick = None;
-            return;
-        };
-        // Keyers pick from their input (the shown frame is already keyed): `effect.pickColor`.
-        let keyer = (pick.kind == "color")
-            .then(|| layer.effects()?.groups().find(|g| g.find(pick.prop).is_some()))
-            .flatten()
-            .filter(|g| effectcraft_engine::effects::find(&g.match_id).is_some_and(|s| s.category == "Keying"))
-            .map(|g| g.uid);
-        if pick.kind == "color" && keyer.is_none() {
-            // GPU frames: read the shown frame back for sampling.
-            app.viewer_pixels();
-        }
-        let resp = ui.interact(map.area, egui::Id::unique("viewer-fx-pick"), Sense::click());
-        app.auto.add("viewer.fxPick", map.area, &pick.name);
-        let hint = if pick.kind == "point" { format!("Click to set {}", pick.name) } else { format!("Click to sample {}", pick.name) };
-        let chip = Rect::from_min_size(map.area.min + vec2(10.0, 10.0), vec2(220.0, 22.0));
-        painter.rect_filled(chip, 11.0, Color32::from_black_alpha(180));
-        painter.text(chip.center(), Align2::CENTER_CENTER, hint, Tokens::ui(11.5), t.text);
-        if let Some(hp) = resp.hover_pos() {
-            ctx.set_cursor_icon(egui::CursorIcon::Crosshair);
-            let c = map.to_comp(hp);
-            app.pointer_comp = Some([c[0] as f32, c[1] as f32]);
-            if pick.kind == "point" && fw::comp_to_layer(&l2c(ectx, &layer), c).is_some() {
-                point_preview = Some(hp);
-            }
-            if pick.kind == "color"
-                && keyer.is_none()
-                && let Some(img) = &app.viewer_image
-                && let Some(s) = fw::sample_frame(img, super::viewer_tools::shown_region(&ctx, map.comp), c)
-            {
-                let sw = Rect::from_min_size(hp + vec2(14.0, 14.0), vec2(26.0, 18.0));
-                painter.rect_filled(sw, 2.0, Color32::from_rgb((s[0] * 255.0) as u8, (s[1] * 255.0) as u8, (s[2] * 255.0) as u8));
-                painter.rect_stroke(sw, 2.0, Stroke::new(1.0, Color32::WHITE), egui::StrokeKind::Outside);
-            }
-        }
-        // No frame to sample yet (it is still rendering, or its readback is pending): the click
-        // leaves the eyedropper armed instead of using it up without a colour.
-        let unsampled = pick.kind == "color" && keyer.is_none() && app.viewer_image.is_none();
-        if resp.clicked()
-            && !unsampled
-            && let Some(pos) = resp.interact_pointer_pos()
-        {
-            let c = map.to_comp(pos);
-            // Effect points and the keyer's input are in effect space.
-            let m = super::viewer::from_effect_space(ectx, &layer, l2c(ectx, &layer));
-            if pick.kind == "point" {
-                if let Some(lp) = fw::comp_to_layer(&m, c) {
-                    actions.push(("prop.set".into(), json!({"layer": pick.layer, "prop": pick.prop, "value": [lp[0], lp[1]]})));
-                }
-            } else if let Some(fx) = keyer {
-                // Ctrl/Cmd+click averages the 5 × 5 pixels around the point.
-                if let Some(lp) = fw::comp_to_layer(&m, c) {
-                    let average = ui.input(|i| i.modifiers.command);
-                    actions.push((
-                        "effect.pickColor".into(),
-                        json!({"layer": pick.layer, "effect": fx, "prop": pick.prop, "x": lp[0], "y": lp[1], "average": average}),
-                    ));
-                }
-            } else if let Some(img) = &app.viewer_image
-                && let Some(s) = fw::sample_frame(img, super::viewer_tools::shown_region(&ctx, map.comp), c)
-            {
-                actions.push(("prop.set".into(), json!({"layer": pick.layer, "prop": pick.prop, "value": [s[0], s[1], s[2], 1.0]})));
-            }
-            app.ui.fx_pick = None;
-            app.ui.status.clear();
-        }
-        if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
-            app.ui.fx_pick = None;
-            app.ui.status.clear();
-        }
-    }
-    if let Some(pick) = app.ui.text_color_pick.clone() {
-        if ectx.comp.layer(effectcraft_engine::project::LayerId(pick.layer)).is_none() {
-            app.ui.text_color_pick = None;
-            app.ui.status.clear();
-        } else {
-            app.viewer_pixels();
-            let resp = ui.interact(map.area, egui::Id::unique("viewer-text-color-pick"), Sense::click());
-            app.auto.add("viewer.textColorPick", map.area, &pick.field);
-            let chip = Rect::from_min_size(map.area.min + vec2(10.0, 10.0), vec2(220.0, 22.0));
-            painter.rect_filled(chip, 11.0, Color32::from_black_alpha(180));
-            painter.text(chip.center(), Align2::CENTER_CENTER, crate::i18n::tr_args("Click to sample text {}", &[&pick.field]), Tokens::ui(11.5), t.text);
-            if let Some(pos) = resp.hover_pos() {
-                ctx.set_cursor_icon(egui::CursorIcon::Crosshair);
-                let c = map.to_comp(pos);
-                app.pointer_comp = Some([c[0] as f32, c[1] as f32]);
-                if let Some(img) = &app.viewer_image
-                    && let Some(s) = fw::sample_frame(img, super::viewer_tools::shown_region(&ctx, map.comp), c)
-                {
-                    let sw = Rect::from_min_size(pos + vec2(14.0, 14.0), vec2(26.0, 18.0));
-                    painter.rect_filled(sw, 2.0, Color32::from_rgb((s[0] * 255.0) as u8, (s[1] * 255.0) as u8, (s[2] * 255.0) as u8));
-                    painter.rect_stroke(sw, 2.0, Stroke::new(1.0, Color32::WHITE), egui::StrokeKind::Outside);
-                }
-            }
-            if resp.clicked()
-                && let Some(pos) = resp.interact_pointer_pos()
-                && let Some(img) = &app.viewer_image
-                && let Some(s) = fw::sample_frame(img, super::viewer_tools::shown_region(&ctx, map.comp), map.to_comp(pos))
-            {
-                let mut params = json!({"layer": pick.layer});
-                params[&pick.field] = json!([s[0], s[1], s[2]]);
-                if let Some(range) = pick.range {
-                    params["range"] = json!(range);
-                }
-                actions.push(("layer.setText".into(), params));
-                app.ui.text_color_pick = None;
-                app.ui.status.clear();
-            }
-            if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
-                app.ui.text_color_pick = None;
-                app.ui.status.clear();
-            }
-        }
-    }
-    let picking = app.ui.fx_pick.is_some() || app.ui.text_color_pick.is_some();
-    let point_pick = app.ui.fx_pick.clone().filter(|p| p.kind == "point");
-    if app.ui.viewer.show_layer_controls || point_pick.is_some() {
-        // ⊕ controls for the point parameters of the selected effects.
-        let mut sel = app.session.state.selected_props.clone();
-        if let Some(pick) = &point_pick {
-            sel.push((effectcraft_engine::project::LayerId(pick.layer), pick.prop));
-        }
-        let selected = app.session.state.selected_layers.clone();
-        for layer in ectx
-            .comp
-            .layers
-            .iter()
-            .filter(|l| (selected.contains(&l.id) || point_pick.as_ref().is_some_and(|p| p.layer == l.id.0)) && l.is_active_at(ectx.time))
-        {
-            let Some(fx) = layer.effects() else { continue };
-            let m = l2c(ectx, layer);
-            // Masks are in layer space, effect points in effect space.
-            let fm = super::viewer::from_effect_space(ectx, layer, m);
-            let picked_prop = point_pick.as_ref().filter(|p| p.layer == layer.id.0).map(|p| p.prop);
-            for g in fx.groups().filter(|g| g.enabled && effect_active(g, layer.id, &sel)) {
-                // Puppet owns its pin handles and hit testing. Generic crosshairs would
-                // overlap the pins and steal their selection/rotation/scale gestures.
-                if matches!(&g.kind, GroupKind::Effect { effect } if effect == effectcraft_engine::effects::puppet::ID) {
-                    continue;
-                }
-                if !picking && app.ui.viewer.show_layer_controls && matches!(&g.kind, GroupKind::Effect { effect } if effect == super::fx_editors::RESHAPE) {
-                    super::fx_editors::reshape_overlay(app, ui, painter, map, ectx, layer, g, &m, &mut actions);
-                }
-                if !picking && app.ui.viewer.show_layer_controls && matches!(&g.kind, GroupKind::Effect { effect } if effect == super::fx_editors::MESH_WARP) {
-                    super::fx_editors::mesh_warp_overlay(app, ui, painter, map, ectx, layer, g, &fm, &mut actions);
-                }
-                let scope = FxScope { effect: &g.match_id, root: g, path: String::new() };
-                let mut pts = Vec::new();
-                visible_points(g, &scope, layer, ectx, 0, &mut pts);
-                // An explicit pick stays visible even when View > Show Layer Controls is off.
-                if !app.ui.viewer.show_layer_controls {
-                    pts.retain(|pr| picked_prop == Some(pr.uid));
-                }
-                let screen: Vec<egui::Pos2> = pts
-                    .iter()
-                    .map(|pr| {
-                        if picked_prop == Some(pr.uid)
-                            && let Some(pos) = point_preview
-                        {
-                            return pos;
-                        }
-                        let v = ectx.value(layer, pr).as_vec2();
-                        map.to_screen(fw::layer_to_comp(&fm, v))
-                    })
-                    .collect();
-                // Gradient Ramp and friends: a guide between start and end points.
-                if screen.len() == 2 && matches!(&g.kind, GroupKind::Effect { effect } if effect.contains("gradient") || effect.contains("ramp")) {
-                    painter.line_segment([screen[0], screen[1]], Stroke::new(1.0, Color32::from_white_alpha(110)));
-                }
-                for (pr, s) in pts.iter().zip(screen) {
-                    let hr = Rect::from_center_size(s, vec2(16.0, 16.0));
-                    let id = egui::Id::unique(("viewer-fx-pt", pr.uid));
-                    // The picker owns the click. Preview handles must not steal it or start a drag.
-                    let resp = (!picking).then(|| ui.interact(hr, id, Sense::drag()));
-                    let col = if picked_prop == Some(pr.uid) || resp.as_ref().is_some_and(|r| r.hovered() || r.dragged()) { t.accent } else { Color32::WHITE };
-                    fw::draw_crosshair(painter, s + vec2(1.0, 1.0), 5.0, Color32::from_black_alpha(160));
-                    fw::draw_crosshair(painter, s, 5.0, col);
-                    app.auto.add(&format!("viewer.effectPoint.{}", pr.uid), hr, &pr.name);
-                    let Some(resp) = resp else { continue };
-                    if resp.hovered() {
-                        ctx.set_cursor_icon(egui::CursorIcon::Move);
-                        resp.clone().on_hover_text(format!("{}: {}", crate::i18n::effects::group(&g.match_id, &g.name), pr.name));
-                    }
-                    if resp.dragged()
-                        && let Some(pos) = resp.interact_pointer_pos()
-                        && let Some(lp) = fw::comp_to_layer(&fm, map.to_comp(pos))
-                    {
-                        let key = gesture_key(ui, id, resp.drag_started());
-                        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": pr.uid, "value": [lp[0], lp[1]], "merge": key})));
-                    }
-                }
-            }
-        }
-    }
-    for (id, params) in actions {
-        if let Err(e) = crate::menus::invoke(app, &ctx, &id, params) {
-            app.ui.status = e;
-        }
-    }
-}
+pub(crate) use common::gesture_key;
+pub use common::{choose_files_after_apply, reveal_applied};
+pub use panel::{show, start_rename};
+pub(crate) use rows::toggle_pick;
+pub use viewer::viewer_hook;
diff --git a/crates/ui-egui/src/panels/effect_controls/common.rs b/crates/ui-egui/src/panels/effect_controls/common.rs
new file mode 100644
index 000000000..ab46a07ac
--- /dev/null
+++ b/crates/ui-egui/src/panels/effect_controls/common.rs
@@ -0,0 +1,109 @@
+use super::{EffectcraftApp, Layer, Node, ParamUi, PropGroup, Value, json};
+
+pub(super) type Actions = Vec<(String, serde_json::Value)>;
+
+pub(super) const ROW: f32 = 20.0;
+
+pub(super) const DIAL_ROW: f32 = 64.0;
+
+// The effect title starts at 44 pt. Each level's names sit one tree step farther in;
+// reserve the same icon gutter for properties and groups so sibling names align.
+pub(super) const PARAM_NAME_X: f32 = 58.0;
+
+pub(super) const TREE_INDENT: f32 = 14.0;
+
+/// Selecting any descendant activates its owning effect without replacing the property
+/// selection used by keyframe editing, copy and delete.
+pub(super) fn effect_active(g: &PropGroup, layer: effectcraft_engine::project::LayerId, selected: &[(effectcraft_engine::project::LayerId, u64)]) -> bool {
+    fn contains(g: &PropGroup, uid: u64, depth: usize) -> bool {
+        if g.uid == uid {
+            return true;
+        }
+        if depth >= 16 {
+            return false;
+        }
+        g.children.iter().any(|n| n.uid() == uid || matches!(n, Node::Group(child) if contains(child, uid, depth + 1)))
+    }
+    selected.iter().any(|(l, uid)| *l == layer && contains(g, *uid, 0))
+}
+
+pub(super) fn selected_layer(app: &EffectcraftApp) -> Option<Layer> {
+    let comp = app.session.active_comp()?;
+    let id = app.session.state.selected_layers.first()?;
+    comp.layer(*id).cloned()
+}
+
+/// An effect was just applied (`effect.apply` / `effect.applyLast` with `params`): Effect
+/// Controls comes up (opened if closed, brought to the front, the focus left where it is) on the
+/// layer the effect went to, with the new effect selected, as in After Effects.
+pub fn reveal_applied(app: &mut EffectcraftApp, params: &serde_json::Value) {
+    // `effect.apply` selects the new effect on (the last of) the layers it went to.
+    let target = app.session.state.selected_props.last().map(|(l, _)| *l);
+    if let Some(l) = target
+        && !app.session.state.selected_layers.contains(&l)
+        && params.get("comp").is_none()
+        && app.session.active_comp().is_some_and(|c| c.layer(l).is_some())
+    {
+        // Show that layer (dropped on an unselected one), keeping the new effect selected.
+        let props = app.session.state.selected_props.clone();
+        match app.session.execute("layer.select", json!({"layers": [l.0]})) {
+            Ok(_) => app.session.state.selected_props = props,
+            Err(e) => app.ui.status = e.to_string(),
+        }
+    }
+    app.raise_panel(crate::dock::PanelKind::EffectControls);
+}
+
+/// After Effects asks for an effect's file as it applies it (Apply Color LUT opens the file
+/// dialog for its LUT). For the instances `effect.apply` made (`applied`, its result), open the
+/// file dialog for their first empty file parameter and set the file on each; cancelling
+/// leaves the effect without one. Does nothing without a file dialog (tests, agents).
+pub fn choose_files_after_apply(app: &mut EffectcraftApp, applied: &serde_json::Value) {
+    let Some(pick) = app.hooks.pick_files.as_ref() else { return };
+    let Some(comp) = app.session.active_comp() else { return };
+    let uids: Vec<u64> = applied.get("effects").and_then(|v| v.as_array()).map(|a| a.iter().filter_map(|v| v.as_u64()).collect()).unwrap_or_default();
+    let mut targets = vec![];
+    let mut filters: Vec<String> = vec![];
+    for uid in uids {
+        for l in &comp.layers {
+            let Some(g) = l.props.find_group(uid) else { continue };
+            let mut found = None;
+            g.walk("", &mut |_, pr| {
+                if found.is_none()
+                    && let ParamUi::File { filters } = &pr.ui
+                    && matches!(&pr.value, Value::Str(s) if s.trim().is_empty())
+                {
+                    found = Some((pr.uid, filters.clone()));
+                }
+            });
+            if let Some((prop, f)) = found {
+                targets.push((l.id.0, prop));
+                filters = f;
+            }
+        }
+    }
+    if targets.is_empty() {
+        return;
+    }
+    let exts: Vec<&str> = filters.iter().map(String::as_str).collect();
+    let Some(path) = pick(&exts).into_iter().next() else { return };
+    for (layer, prop) in targets {
+        if let Err(e) = app.session.execute("prop.set", json!({"layer": layer, "prop": prop, "value": path})) {
+            app.ui.status = e.to_string();
+        }
+    }
+}
+
+/// An undo-merge key for one gesture on `id`: a new key each time a drag starts, so separate
+/// drags are separate undo steps while one drag is one step.
+pub(crate) fn gesture_key(ui: &egui::Ui, id: egui::Id, started: bool) -> String {
+    let kid = id.with("gesture");
+    let n: u64 = if started {
+        let n = ui.data(|d| d.get_temp::<u64>(kid)).unwrap_or(0) + 1;
+        ui.data_mut(|d| d.insert_temp(kid, n));
+        n
+    } else {
+        ui.data(|d| d.get_temp::<u64>(kid)).unwrap_or(0)
+    };
+    format!("{id:?}-{n}")
+}
diff --git a/crates/ui-egui/src/panels/effect_controls/editors.rs b/crates/ui-egui/src/panels/effect_controls/editors.rs
new file mode 100644
index 000000000..bd566cb7f
--- /dev/null
+++ b/crates/ui-egui/src/panels/effect_controls/editors.rs
@@ -0,0 +1,380 @@
+use super::common::{Actions, gesture_key};
+use super::{Align2, Color32, EffectcraftApp, EvalCtx, Layer, PropGroup, Rect, Sense, Tokens, Value, fw, json, pos2, vec2, widgets};
+
+/// Warp Stabilizer's Analyze / Cancel buttons and analysis status.
+pub(super) fn warp_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, layer: &Layer, g: &PropGroup, r: Rect, actions: &mut Actions) {
+    let t = app.tokens;
+    let running = app.session.warp_target().is_some_and(|(_, l, u)| l == layer.id && u == g.uid) && app.session.is_warp_analyzing();
+    let busy = app.session.is_warp_analyzing();
+    let b1 = Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 4.0), vec2(84.0, 22.0));
+    let b2 = Rect::from_min_size(pos2(b1.max.x + 8.0, b1.min.y), vec2(84.0, 22.0));
+    if widgets::text_button(ui, b1, crate::i18n::tr("Analyze"), false, &t, egui::Id::unique(("warp-analyze", g.uid))).clicked() && !busy {
+        actions.push(("warp.analyze".into(), json!({"layer": layer.id.0, "effect": g.uid})));
+    }
+    app.auto.add(&format!("effectControls.warp.{}.analyze", g.uid), b1, "Analyze");
+    if running {
+        if widgets::text_button(ui, b2, crate::i18n::tr("Cancel"), false, &t, egui::Id::unique(("warp-cancel", g.uid))).clicked() {
+            actions.push(("warp.cancel".into(), json!({})));
+        }
+        app.auto.add(&format!("effectControls.warp.{}.cancel", g.uid), b2, "Cancel");
+    }
+    let analysed = matches!(g.get(effectcraft_engine::effects::warp_stab::ANALYSIS).map(|p| &p.value), Some(Value::Str(s)) if !s.is_empty());
+    let status = match app.session.warp_progress() {
+        Some(pr) if running => pr.banner(),
+        _ if analysed => "Analysis complete".to_string(),
+        _ if app.session.warp_pending.iter().any(|(_, l, u)| *l == layer.id && *u == g.uid) => "Waiting to analyze".to_string(),
+        _ => "Not analyzed: click Analyze".to_string(),
+    };
+    p.text(pos2(r.min.x + 24.0, r.min.y + 38.0), Align2::LEFT_CENTER, status, Tokens::ui(11.5), t.text_dim);
+}
+
+/// Roto Brush & Refine Edge: Freeze / Unfreeze and Propagate buttons and the segmentation status.
+pub(super) fn roto_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, layer: &Layer, g: &PropGroup, r: Rect, actions: &mut Actions) {
+    use effectcraft_engine::effects::roto as fx;
+    let t = app.tokens;
+    let params = effectcraft_engine::effects::flatten_params(g, &mut |pr| pr.value.clone());
+    let frozen = fx::is_frozen(&params);
+    let d = fx::data(&params);
+    let running = app.session.roto_target().is_some_and(|(_, l, u, _)| l == layer.id && u == g.uid) && app.session.is_roto_running();
+    let b1 = Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 4.0), vec2(84.0, 22.0));
+    let b2 = Rect::from_min_size(pos2(b1.max.x + 8.0, b1.min.y), vec2(84.0, 22.0));
+    let label = if frozen { "Unfreeze" } else { "Freeze" };
+    if widgets::text_button(ui, b1, label, frozen, &t, egui::Id::unique(("roto-freeze-ec", g.uid))).clicked() && !running {
+        let id = if frozen { "roto.unfreeze" } else { "roto.freeze" };
+        actions.push((id.into(), json!({"layer": layer.id.0, "effect": g.uid})));
+    }
+    app.auto.add(&format!("effectControls.roto.{}.freeze", g.uid), b1, label);
+    let (l2, id2) = if running { ("Stop", "roto.cancel") } else { ("Propagate", "roto.propagate") };
+    if widgets::text_button(ui, b2, l2, false, &t, egui::Id::unique(("roto-prop-ec", g.uid))).clicked() && !frozen {
+        actions.push((id2.into(), json!({"layer": layer.id.0, "effect": g.uid})));
+    }
+    app.auto.add(&format!("effectControls.roto.{}.propagate", g.uid), b2, l2);
+    let status = match (app.session.roto_progress(), d.base) {
+        (Some(pr), _) if running => pr.banner(),
+        (_, None) => "No strokes: paint with the Roto Brush tool (Alt+W) in the Layer panel".to_string(),
+        (_, Some(b)) => format!("Base frame {b}, span {}–{}{}", d.span[0], d.span[1], if frozen { " (frozen)" } else { "" }),
+    };
+    p.text(pos2(r.min.x + 24.0, r.min.y + 38.0), Align2::LEFT_CENTER, status, Tokens::ui(11.5), t.text_dim);
+}
+
+/// Object Matte: Freeze / Unfreeze and Track / Stop buttons (the background job that computes
+/// the matte over the tracked frames) and its status.
+pub(super) fn object_matte_editor(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    p: &egui::Painter,
+    layer: &Layer,
+    g: &PropGroup,
+    r: Rect,
+    actions: &mut Actions,
+) {
+    use effectcraft_engine::effects::object_matte as om;
+    let t = app.tokens;
+    let params = effectcraft_engine::effects::flatten_params(g, &mut |pr| pr.value.clone());
+    let frozen = om::is_frozen(&params);
+    let mine = app.session.roto_target().is_some_and(|(_, l, u, _)| l == layer.id && u == g.uid);
+    let running = mine && app.session.is_roto_running();
+    let busy = app.session.is_roto_running();
+    let b1 = Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 4.0), vec2(84.0, 22.0));
+    let b2 = Rect::from_min_size(pos2(b1.max.x + 8.0, b1.min.y), vec2(84.0, 22.0));
+    let label = if frozen { "Unfreeze" } else { "Freeze" };
+    if widgets::text_button(ui, b1, crate::i18n::tr(label), frozen, &t, egui::Id::unique(("om-freeze-ec", g.uid))).clicked() && !busy {
+        let id = if frozen { "objectMatte.unfreeze" } else { "objectMatte.freeze" };
+        actions.push((id.into(), json!({"layer": layer.id.0, "effect": g.uid})));
+    }
+    app.auto.add(&format!("effectControls.objectMatte.{}.freeze", g.uid), b1, label);
+    let (l2, id2) = if running { ("Stop", "roto.cancel") } else { ("Track", "objectMatte.propagate") };
+    if widgets::text_button(ui, b2, crate::i18n::tr(l2), false, &t, egui::Id::unique(("om-track-ec", g.uid))).clicked() && !frozen && (running || !busy) {
+        actions.push((id2.into(), json!({"layer": layer.id.0, "effect": g.uid})));
+    }
+    app.auto.add(&format!("effectControls.objectMatte.{}.track", g.uid), b2, l2);
+    let base = om::reference_frame(&params);
+    let status = match app.session.roto_progress() {
+        Some(pr) if running => pr.banner(),
+        _ if frozen => format!("Frozen from reference frame {base}"),
+        _ if app.session.roto_pending.iter().any(|(_, l, u)| *l == layer.id && *u == g.uid) => "Waiting to track".to_string(),
+        _ => format!("Reference frame {base}: Track computes the matte ahead of playback"),
+    };
+    p.text(pos2(r.min.x + 24.0, r.min.y + 38.0), Align2::LEFT_CENTER, &status, Tokens::ui(11.5), t.text_dim);
+    app.auto.add(
+        &format!("effectControls.objectMatte.{}.status", g.uid),
+        Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 30.0), vec2(r.width() - 24.0, 16.0)),
+        &status,
+    );
+}
+
+// ---------------------------------------------------------------------------------------------
+// Curves / Levels editors
+
+/// Height of the custom editor shown under an effect's header (0 when none).
+pub(super) fn editor_height(effect: &str, g: &PropGroup, width: f32) -> f32 {
+    match effect {
+        crate::panels::fx_editors::GLOW | crate::panels::fx_editors::RESHAPE | crate::panels::fx_editors::EXTRACTOR => {
+            crate::panels::fx_editors::header_height(effect, g, width)
+        }
+        "ec.color.curves" => 34.0 + curves_size(width) + 26.0,
+        effectcraft_engine::effects::warp_stab::ID => 50.0,
+        effectcraft_engine::effects::camera_tracker::ID => crate::panels::camera_tracker_ui::EDITOR_HEIGHT,
+        effectcraft_engine::effects::roto::ID | effectcraft_engine::effects::object_matte::ID => 50.0,
+        "ec.color.levels" | "ec.color.levelsic" => 34.0 + 80.0 + 58.0,
+        "ec.color.autolevels" | "ec.color.autocontrast" | "ec.color.autocolor" => 24.0 + 80.0 + 12.0,
+        _ => 0.0,
+    }
+}
+
+fn curves_size(width: f32) -> f32 {
+    (width - 72.0).clamp(120.0, 256.0)
+}
+
+/// Cached histogram of the displayed frame (recomputed when the frame changes).
+fn frame_histogram(app: &mut EffectcraftApp, ctx: &egui::Context) -> Option<std::sync::Arc<[[u32; 256]; 5]>> {
+    let img = app.viewer_pixels()?;
+    let key = std::sync::Arc::as_ptr(&img) as usize;
+    let id = egui::Id::unique("ec-histogram");
+    if let Some((k, h)) = ctx.data(|d| d.get_temp::<(usize, std::sync::Arc<[[u32; 256]; 5]>)>(id))
+        && k == key
+    {
+        return Some(h);
+    }
+    let h = std::sync::Arc::new(fw::histogram(&img));
+    ctx.data_mut(|d| d.insert_temp(id, (key, h.clone())));
+    Some(h)
+}
+
+fn channel_color(ch: usize) -> Color32 {
+    match ch {
+        1 => Color32::from_rgb(0xe0, 0x50, 0x50),
+        2 => Color32::from_rgb(0x50, 0xc8, 0x60),
+        3 => Color32::from_rgb(0x50, 0x80, 0xf0),
+        4 => Color32::from_gray(0x90),
+        _ => Color32::from_gray(0xb8),
+    }
+}
+
+/// A "Channel: [RGB ▾]" popup; returns the chosen channel.
+#[allow(clippy::too_many_arguments)]
+fn channel_popup(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    p: &egui::Painter,
+    x: f32,
+    cy: f32,
+    cur: usize,
+    names: &[&str],
+    id: egui::Id,
+    auto: &str,
+) -> Option<usize> {
+    let t = app.tokens;
+    p.text(pos2(x, cy), Align2::LEFT_CENTER, crate::i18n::tr("Channel:"), Tokens::ui(12.0), t.text_dim);
+    let dr = Rect::from_min_size(pos2(x + 58.0, cy - 9.0), vec2(80.0, 18.0));
+    let pop = id.with("pop");
+    if widgets::dropdown(ui, dr, names.get(cur).copied().unwrap_or(""), &t, id).clicked() {
+        widgets::open_popup(ui, pop);
+    }
+    app.auto.add(auto, dr, "Channel");
+    let opts: Vec<String> = names.iter().map(|s| s.to_string()).collect();
+    widgets::popup_menu(ui, pop, dr.left_bottom(), &opts, Some(cur))
+}
+
+/// Curves: channel popup, Bezier/pencil mode, Reset, and the graph bound to the channel's
+/// hidden point-list parameter.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn curves_editor(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    p: &egui::Painter,
+    layer: &Layer,
+    g: &PropGroup,
+    ectx: &EvalCtx,
+    r: Rect,
+    actions: &mut Actions,
+) {
+    let t = app.tokens;
+    let euid = g.uid;
+    // The channel lives in the effect's hidden Channel parameter (UI state for instances
+    // saved before it existed).
+    let chan_prop = g.get("channel");
+    let ch = match chan_prop {
+        Some(pr) => ectx.value(layer, pr).as_enum() as usize,
+        None => app.ui.fx_curve_channel.get(&euid).copied().unwrap_or(0),
+    }
+    .min(4);
+    let x0 = r.min.x + 30.0;
+    let cy = r.min.y + 17.0;
+    let names: [&str; 5] = [crate::i18n::tr("RGB"), crate::i18n::tr("Red"), crate::i18n::tr("Green"), crate::i18n::tr("Blue"), crate::i18n::tr("Alpha")];
+    if let Some(n) = channel_popup(app, ui, p, x0, cy, ch, &names, egui::Id::unique(("ec-cch", euid)), &format!("effectControls.effect.{euid}.curves.channel"))
+    {
+        match chan_prop {
+            Some(pr) => actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": pr.uid, "value": n}))),
+            None => {
+                app.ui.fx_curve_channel.insert(euid, n);
+            }
+        }
+    }
+    let pencil = app.ui.fx_curve_pencil.contains(&euid);
+    let mr = Rect::from_min_size(pos2(x0 + 146.0, cy - 9.0), vec2(56.0, 18.0));
+    if widgets::dropdown(ui, mr, if pencil { "Pencil" } else { "Bezier" }, &t, egui::Id::unique(("ec-cmode", euid))).clicked() {
+        if pencil {
+            app.ui.fx_curve_pencil.remove(&euid);
+        } else {
+            app.ui.fx_curve_pencil.insert(euid);
+        }
+    }
+    app.auto.add(&format!("effectControls.effect.{euid}.curves.mode"), mr, "Curve mode");
+    let Some(prop) = g.get(fw::CURVE_CHANNELS[ch].0) else { return };
+    let cur = match ectx.value(layer, prop) {
+        Value::Str(s) => fw::CurvePoints::parse(&s),
+        _ => fw::CurvePoints::identity(),
+    };
+    let rr = Rect::from_min_size(pos2(mr.max.x + 8.0, cy - 9.0), vec2(44.0, 18.0));
+    let rresp = ui.interact(rr, egui::Id::unique(("ec-creset", euid)), Sense::click());
+    p.text(rr.center(), Align2::CENTER_CENTER, crate::i18n::tr("Reset"), Tokens::ui(11.5), if rresp.hovered() { t.hot_text } else { t.text_dim });
+    app.auto.add(&format!("effectControls.effect.{euid}.curves.reset"), rr, "Reset curve");
+    if rresp.clicked() {
+        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": prop.uid, "value": fw::CurvePoints::identity().format()})));
+    }
+    let size = curves_size(r.width());
+    let gr = Rect::from_min_size(pos2(x0 + 8.0, r.min.y + 38.0), vec2(size, size));
+    // Input/output gradients along the axes.
+    let col = channel_color(ch);
+    p.rect_filled(Rect::from_min_max(pos2(gr.min.x, gr.max.y + 3.0), pos2(gr.max.x, gr.max.y + 8.0)), 0.0, col.gamma_multiply(0.5));
+    let id = egui::Id::unique(("ec-curves", euid, ch));
+    let (resp, edit) = fw::curves_graph(ui, gr, &cur, ch, fw::CurveMode { pencil, natural: true }, id, &t);
+    app.auto.add(&format!("effectControls.effect.{euid}.curves.graph"), gr, "Curves");
+    let started = resp.drag_started() || resp.clicked();
+    if let Some(np) = edit.changed {
+        let key = gesture_key(ui, id, started);
+        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": prop.uid, "value": np.format(), "merge": key})));
+    }
+    p.text(
+        pos2(gr.min.x, gr.max.y + 18.0),
+        Align2::LEFT_CENTER,
+        if pencil { "Drag to draw the curve" } else { "Click adds a point; drag one off to remove" },
+        Tokens::ui(10.5),
+        t.text_faint,
+    );
+}
+
+/// Levels parameter ids for a channel: input black, input white, gamma, output black, output white.
+fn levels_ids(effect: &str, ch: usize) -> [String; 5] {
+    if effect == "ec.color.levels" {
+        return effectcraft_engine::effects::levels_channel_ids(ch);
+    }
+    // Levels (Individual Controls) nests each channel's controls in its twirl-down group.
+    let pre = fw::LEVELS_CHANNELS[ch.min(4)].0;
+    ["InBlack", "InWhite", "Gamma", "OutBlack", "OutWhite"].map(|s| format!("{pre}/{pre}{s}"))
+}
+
+/// Levels: (channel popup,) histogram, input black/gamma/white triangles, output bar with
+/// black/white triangles.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn levels_editor(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    p: &egui::Painter,
+    layer: &Layer,
+    g: &PropGroup,
+    effect: &str,
+    ectx: &EvalCtx,
+    r: Rect,
+    actions: &mut Actions,
+) {
+    let t = app.tokens;
+    let euid = g.uid;
+    let x0 = r.min.x + 30.0;
+    let cy = r.min.y + 17.0;
+    // Levels keeps its channel in the Channel parameter; Levels (Individual Controls) shows
+    // every channel and the popup only picks the histogram.
+    let ch = if effect == "ec.color.levelsic" {
+        app.ui.fx_levels_channel.get(&euid).copied().unwrap_or(0).min(4)
+    } else {
+        g.get("channel").map(|pr| ectx.value(layer, pr).as_enum() as usize).unwrap_or(0).min(4)
+    };
+    if effect == "ec.color.levelsic" {
+        let names: [&str; 5] = [crate::i18n::tr("RGB"), crate::i18n::tr("Red"), crate::i18n::tr("Green"), crate::i18n::tr("Blue"), crate::i18n::tr("Alpha")];
+        if let Some(n) =
+            channel_popup(app, ui, p, x0, cy, ch, &names, egui::Id::unique(("ec-lch", euid)), &format!("effectControls.effect.{euid}.levels.channel"))
+        {
+            app.ui.fx_levels_channel.insert(euid, n);
+        }
+    } else {
+        p.text(pos2(x0, cy), Align2::LEFT_CENTER, crate::i18n::tr("Histogram"), Tokens::ui(12.0), t.text_dim);
+    }
+    let w = (r.width() - 72.0).clamp(120.0, 256.0);
+    let hr = Rect::from_min_size(pos2(x0 + 8.0, r.min.y + 34.0), vec2(w, 80.0));
+    match frame_histogram(app, ui.ctx()) {
+        // Channel 0 (RGB) shows luminance; the others their own channel.
+        Some(h) => fw::draw_histogram(p, hr, &h[ch], channel_color(ch)),
+        None => {
+            p.rect_filled(hr, 0.0, Color32::from_rgb(0x1c, 0x1c, 0x1c));
+        }
+    }
+    app.auto.add(&format!("effectControls.effect.{euid}.levels.histogram"), hr, "Histogram");
+    let ids = levels_ids(effect, ch);
+    let val = |id: &str| g.prop(id).map(|pr| ectx.value(layer, pr).as_f64()).unwrap_or(0.0);
+    let (ib, iw, gm, ob, ow) = (val(&ids[0]), val(&ids[1]), val(&ids[2]), val(&ids[3]), val(&ids[4]));
+    let mut set = |ui: &egui::Ui, id: &str, v: f64, started: bool| {
+        if let Some(pr) = g.prop(id) {
+            let key = gesture_key(ui, egui::Id::unique(("ec-lv", euid, id)), started);
+            actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": pr.uid, "value": v, "merge": key})));
+        }
+    };
+    let track = Rect::from_min_size(pos2(hr.min.x, hr.max.y + 1.0), vec2(w, 10.0));
+    let started = |ui: &egui::Ui| ui.input(|i| i.pointer.any_pressed());
+    let (r0, nv) = fw::level_handle(ui, track, ib, Color32::BLACK, egui::Id::unique(("ec-lib", euid, ch)), &t);
+    app.auto.add(&format!("effectControls.effect.{euid}.levels.inBlack"), r0, "Input Black");
+    if let Some(v) = nv {
+        set(ui, &ids[0], v.min(iw - 0.005), started(ui));
+    }
+    let gx = fw::gamma_handle(ib, iw, gm);
+    let (r1, nv) = fw::level_handle(ui, track, gx, Color32::from_gray(128), egui::Id::unique(("ec-lg", euid, ch)), &t);
+    app.auto.add(&format!("effectControls.effect.{euid}.levels.gamma"), r1, "Gamma");
+    if let Some(v) = nv {
+        set(ui, &ids[2], (fw::gamma_from_handle(ib, iw, v) * 100.0).round() / 100.0, started(ui));
+    }
+    let (r2, nv) = fw::level_handle(ui, track, iw, Color32::WHITE, egui::Id::unique(("ec-liw", euid, ch)), &t);
+    app.auto.add(&format!("effectControls.effect.{euid}.levels.inWhite"), r2, "Input White");
+    if let Some(v) = nv {
+        set(ui, &ids[1], v.max(ib + 0.005), started(ui));
+    }
+    // Output: a black→white bar with its two triangles.
+    let bar = Rect::from_min_size(pos2(hr.min.x, track.max.y + 10.0), vec2(w, 9.0));
+    let n = 32;
+    for k in 0..n {
+        let v = (k as f32 / (n - 1) as f32 * 255.0) as u8;
+        let x0 = bar.min.x + bar.width() * k as f32 / n as f32;
+        let x1 = bar.min.x + bar.width() * (k + 1) as f32 / n as f32;
+        p.rect_filled(Rect::from_min_max(pos2(x0, bar.min.y), pos2(x1, bar.max.y)), 0.0, Color32::from_gray(v));
+    }
+    let otrack = Rect::from_min_size(pos2(bar.min.x, bar.max.y + 1.0), vec2(w, 10.0));
+    let (r3, nv) = fw::level_handle(ui, otrack, ob, Color32::BLACK, egui::Id::unique(("ec-lob", euid, ch)), &t);
+    app.auto.add(&format!("effectControls.effect.{euid}.levels.outBlack"), r3, "Output Black");
+    if let Some(v) = nv {
+        set(ui, &ids[3], v, started(ui));
+    }
+    let (r4, nv) = fw::level_handle(ui, otrack, ow, Color32::WHITE, egui::Id::unique(("ec-low", euid, ch)), &t);
+    app.auto.add(&format!("effectControls.effect.{euid}.levels.outWhite"), r4, "Output White");
+    if let Some(v) = nv {
+        set(ui, &ids[4], v, started(ui));
+    }
+}
+
+/// Auto Levels / Auto Contrast / Auto Color: the histogram they work from.
+pub(super) fn histogram_only(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, g: &PropGroup, r: Rect) {
+    let t = app.tokens;
+    let x0 = r.min.x + 30.0;
+    p.text(pos2(x0, r.min.y + 12.0), Align2::LEFT_CENTER, crate::i18n::tr("Histogram"), Tokens::ui(12.0), t.text_dim);
+    let w = (r.width() - 72.0).clamp(120.0, 256.0);
+    let hr = Rect::from_min_size(pos2(x0 + 8.0, r.min.y + 24.0), vec2(w, 80.0));
+    match frame_histogram(app, ui.ctx()) {
+        Some(h) => {
+            fw::draw_histogram(p, hr, &h[1], channel_color(1).gamma_multiply(0.6));
+            fw::draw_histogram_overlay(p, hr, &h[2], channel_color(2).gamma_multiply(0.6));
+            fw::draw_histogram_overlay(p, hr, &h[3], channel_color(3).gamma_multiply(0.6));
+        }
+        None => {
+            p.rect_filled(hr, 0.0, Color32::from_rgb(0x1c, 0x1c, 0x1c));
+        }
+    }
+    app.auto.add(&format!("effectControls.effect.{}.histogram", g.uid), hr, "Histogram");
+}
diff --git a/crates/ui-egui/src/panels/effect_controls/panel.rs b/crates/ui-egui/src/panels/effect_controls/panel.rs
new file mode 100644
index 000000000..122a6abf7
--- /dev/null
+++ b/crates/ui-egui/src/panels/effect_controls/panel.rs
@@ -0,0 +1,386 @@
+use super::common::{Actions, PARAM_NAME_X, ROW, effect_active, selected_layer};
+use super::editors::{curves_editor, editor_height, histogram_only, levels_editor, object_matte_editor, roto_editor, warp_editor};
+use super::rows::{FxScope, group_rows, toggle_closed};
+use super::{Align2, Color32, EffectcraftApp, EvalCtx, GroupKind, Icon, Layer, PropGroup, Rect, Sense, Stroke, Tokens, json, pos2, vec2, widgets};
+
+// ---------------------------------------------------------------------------------------------
+
+/// Open the rename field on effect `uid` (Enter with the effect selected), name selected.
+pub fn start_rename(ctx: &egui::Context, uid: u64, name: &str) {
+    let id = egui::Id::unique(("ec-rename", uid));
+    ctx.data_mut(|d| d.insert_temp(id, name.to_string()));
+    ctx.data_mut(|d| d.insert_temp(id.with("select"), true));
+    ctx.memory_mut(|m| m.request_focus(id.with("field")));
+}
+
+/// Where an effect header's parts sit, for its rename field.
+struct EffectHdr<'a> {
+    g: &'a PropGroup,
+    shown: &'a str,
+    r: Rect,
+    tw: Rect,
+    reset: Rect,
+    rename_id: egui::Id,
+    layer_id: u64,
+}
+
+/// The effect header's name field while renaming: Enter or blur commits, Escape cancels.
+fn rename_field(app: &mut EffectcraftApp, ui: &mut egui::Ui, h: &EffectHdr, mut value: String, actions: &mut Actions) {
+    let EffectHdr { g, shown, r, tw, reset, rename_id, layer_id } = *h;
+    let ctx = ui.ctx().clone();
+    let name_rect = Rect::from_min_max(pos2(tw.max.x + 6.0, r.min.y + 2.0), pos2(reset.min.x - 6.0, r.max.y - 2.0));
+    let response = ui.put(name_rect, egui::TextEdit::singleline(&mut value).id(rename_id.with("field")).font(Tokens::semibold(12.0)));
+    // Focus the field the frame it first exists: focusing an id not yet on screen leaves
+    // the accessibility tree with a focus it doesn't contain.
+    if ctx.data_mut(|d| d.remove_temp::<bool>(rename_id.with("start"))).is_some() {
+        crate::widgets::select_all(&ctx, response.id, &value);
+        response.request_focus();
+    }
+    app.auto.add(&format!("effectControls.effect.{}.nameEdit", g.uid), name_rect, "Effect name");
+    if ctx.data_mut(|d| d.remove_temp::<bool>(rename_id.with("select"))).unwrap_or(false) {
+        widgets::select_all(&ctx, response.id, &value);
+    }
+    // Escape cancels. egui drops the field's focus on Escape in the same frame, so the
+    // key is checked on the focus being lost as well as held.
+    let escape = (response.has_focus() || response.lost_focus()) && ui.input(|i| i.key_pressed(egui::Key::Escape));
+    let commit = response.lost_focus() || (response.has_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)));
+    if escape || commit {
+        ctx.data_mut(|d| d.remove::<String>(rename_id));
+        // The field opens with the drawn name, so committing it unchanged is not a rename.
+        if !escape && !value.trim().is_empty() && value != shown {
+            actions.push(("prop.renameGroup".into(), json!({"layer": layer_id, "prop": g.uid, "name": value})));
+        }
+    } else {
+        ctx.data_mut(|d| d.insert_temp(rename_id, value));
+    }
+}
+
+struct EditorCx<'a> {
+    bp: &'a egui::Painter,
+    layer: &'a Layer,
+    ectx: &'a EvalCtx<'a>,
+}
+
+/// An effect's custom editor (curves, levels, roto...), or the histogram-only fallback.
+fn effect_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &EditorCx, g: &PropGroup, er: Rect, actions: &mut Actions) {
+    let GroupKind::Effect { effect } = &g.kind else { return };
+    match effect.as_str() {
+        "ec.color.curves" => curves_editor(app, ui, cx.bp, cx.layer, g, cx.ectx, er, actions),
+        effectcraft_engine::effects::warp_stab::ID => warp_editor(app, ui, cx.bp, cx.layer, g, er, actions),
+        effectcraft_engine::effects::camera_tracker::ID => crate::panels::camera_tracker_ui::editor(app, ui, cx.bp, cx.layer, g, er, actions),
+        effectcraft_engine::effects::roto::ID => roto_editor(app, ui, cx.bp, cx.layer, g, er, actions),
+        effectcraft_engine::effects::object_matte::ID => object_matte_editor(app, ui, cx.bp, cx.layer, g, er, actions),
+        "ec.color.levels" | "ec.color.levelsic" => levels_editor(app, ui, cx.bp, cx.layer, g, effect, cx.ectx, er, actions),
+        crate::panels::fx_editors::GLOW | crate::panels::fx_editors::RESHAPE | crate::panels::fx_editors::EXTRACTOR => {
+            crate::panels::fx_editors::header_editor(app, ui, cx.bp, cx.layer, g, effect, cx.ectx, er, actions)
+        }
+        _ => histogram_only(app, ui, cx.bp, g, er),
+    }
+}
+
+struct ReorderDrag<'a> {
+    tops: &'a [(u64, f32)],
+    y: f32,
+    du: u64,
+    drag_id: egui::Id,
+    layer_id: u64,
+}
+
+/// Drag an effect header to reorder: the insertion line between headers, and the drop.
+fn reorder_drag(ctx: &egui::Context, bp: &egui::Painter, body: Rect, t: &Tokens, st: &ReorderDrag, actions: &mut Actions) {
+    let ReorderDrag { tops, y, du, drag_id, layer_id } = *st;
+    if let Some(pos) = ctx.pointer_interact_pos() {
+        let slot = tops.iter().position(|(_, ty)| pos.y < *ty + (ROW + 2.0) / 2.0).unwrap_or(tops.len());
+        let ly = tops.get(slot).map(|(_, ty)| *ty).unwrap_or(y - 4.0);
+        bp.line_segment([pos2(body.min.x + 4.0, ly), pos2(body.max.x - 4.0, ly)], Stroke::new(2.0, t.accent));
+        if ctx.input(|i| i.pointer.any_released()) {
+            if let Some(from) = tops.iter().position(|(u, _)| *u == du) {
+                let to = if slot > from { slot - 1 } else { slot };
+                if to != from {
+                    actions.push(("effect.reorder".into(), json!({"layer": layer_id, "effect": du, "index": to + 1})));
+                }
+            }
+            ctx.data_mut(|d| d.remove::<u64>(drag_id));
+        }
+    }
+    if !ctx.input(|i| i.pointer.any_down()) {
+        ctx.data_mut(|d| d.remove::<u64>(drag_id));
+    }
+}
+
+/// Drop effects and animation presets here.
+fn drop_payload(ui: &egui::Ui, rect: Rect, p: &egui::Painter, t: &Tokens, layer_id: u64, actions: &mut Actions) {
+    let ctx = ui.ctx().clone();
+    if let Some(payload) = egui::DragAndDrop::payload::<crate::panels::DragPayload>(&ctx)
+        && ui.rect_contains_pointer(rect)
+        && let Some((id, params)) = match payload.as_ref() {
+            crate::panels::DragPayload::Effect(e) => Some(("effect.apply", json!({"effect": e, "layers": [layer_id]}))),
+            crate::panels::DragPayload::Preset { preset, .. } => Some(preset.apply_to(layer_id)),
+            _ => None,
+        }
+    {
+        p.rect_stroke(rect, 0.0, Stroke::new(2.0, t.accent), egui::StrokeKind::Inside);
+        if ctx.input(|i| i.pointer.any_released()) {
+            actions.push((id.into(), params));
+            egui::DragAndDrop::clear_payload(&ctx);
+        }
+    }
+}
+
+fn about_button(app: &mut EffectcraftApp, ui: &mut egui::Ui, bp: &egui::Painter, t: &Tokens, effect: &str, g: &PropGroup, r: Rect) {
+    // About…: the effect's name and category (AE's About dialog).
+    let about = Rect::from_min_size(pos2(r.max.x - 50.0, r.center().y - 9.0), vec2(44.0, 18.0));
+    let aresp = ui.interact(about, egui::Id::unique(("ec-about", g.uid)), Sense::click());
+    bp.text(about.center(), Align2::CENTER_CENTER, crate::i18n::tr("About..."), Tokens::ui(11.5), if aresp.hovered() { t.hot_text } else { t.text_dim });
+    app.auto.add(&format!("effectControls.effect.{}.about", g.uid), about, "About");
+    let apop = egui::Id::unique(("ec-about-pop", g.uid));
+    if aresp.clicked() {
+        widgets::open_popup(ui, apop);
+    }
+    if let Some(spec) = effectcraft_engine::effects::find(effect) {
+        let lines = vec![
+            crate::i18n::effects::name(spec.id, spec.name),
+            format!("Category: {}", crate::i18n::effects::category(spec.category)),
+            "EffectCraft built-in effect (MIT OR Apache-2.0)".to_string(),
+        ];
+        let _ = widgets::popup_menu(ui, apop, about.left_bottom(), &lines, None);
+    }
+}
+
+/// The Effect Controls panel for the selected layer: a header with the comp and layer names, then
+/// one header per effect (Fx toggle, twirl, rename, Reset, About, label bar, reorder drag and its
+/// right-click menu) followed by that effect's custom editor and its property rows. Dragging
+/// effects or presets onto the panel applies them; a right-click on empty space opens the Effect
+/// menu. The rows read from a snapshot of the project, and every edit is queued and run through
+/// [`crate::menus::invoke`], with failures reported in `app.ui.status`.
+pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let t = app.tokens;
+    let p = ui.painter().with_clip_rect(rect);
+    let ctx = ui.ctx().clone();
+    let Some(layer) = selected_layer(app) else {
+        p.text(rect.center(), Align2::CENTER_CENTER, crate::i18n::tr("Select a layer to see its effects"), Tokens::ui(12.0), t.text_faint);
+        return;
+    };
+    let Some(cid) = app.session.active_comp_id() else { return };
+    let comp = app.session.project.comp_arc(cid).unwrap_or_else(|| effectcraft_engine::project::Comp::new(1, 1, Default::default(), Default::default()).into());
+    let comp_name = app.session.project.item(cid).map(|i| i.name.clone()).unwrap_or_default();
+    let snap_project = app.session.project.clone();
+    let snap_expr = app.session.expr.clone();
+    let ectx = EvalCtx {
+        project: &snap_project,
+        comp_id: cid,
+        comp: &comp,
+        time: app.session.time(),
+        expr: snap_expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
+    let hdr = Rect::from_min_size(rect.min, vec2(rect.width(), 24.0));
+    p.text(pos2(hdr.min.x + 10.0, hdr.center().y), Align2::LEFT_CENTER, format!("{} • {}", comp_name, layer.name), Tokens::ui(11.5), t.text_dim);
+    p.line_segment([hdr.left_bottom(), hdr.right_bottom()], Stroke::new(1.0, t.separator));
+    let body = Rect::from_min_max(pos2(rect.min.x, hdr.max.y), rect.max);
+    let scroll = widgets::PanelScroll::begin(ui, egui::Id::unique("ec-scroll"), body);
+    let mut y = body.min.y + 4.0 - scroll.offset;
+    let mut actions: Actions = vec![];
+    let bp = p.with_clip_rect(body);
+    // Rows scroll under the header: clip their widgets (and hit tests) to the body.
+    let panel_clip = ui.clip_rect();
+    ui.set_clip_rect(body.intersect(panel_clip));
+    let fx: Vec<PropGroup> = layer.effects().map(|f| f.groups().cloned().collect()).unwrap_or_default();
+    if fx.is_empty() {
+        bp.text(
+            pos2(body.center().x, body.min.y + 40.0),
+            Align2::CENTER_CENTER,
+            crate::i18n::tr("No effects. Drag one from Effects & Presets."),
+            Tokens::ui(12.0),
+            t.text_faint,
+        );
+    }
+    // Clicking empty space deselects the effects.
+    let bg = ui.interact(body, egui::Id::unique("ec-bg"), Sense::click());
+    if bg.clicked() {
+        app.session.state.selected_props.retain(|(l, u)| !(*l == layer.id && fx.iter().any(|g| effect_active(g, layer.id, &[(*l, *u)]))));
+    }
+    let has_clip = !app.session.state.effect_clipboard.is_empty();
+    let drag_id = egui::Id::unique("ec-drag-effect");
+    let dragging: Option<u64> = ctx.data(|d| d.get_temp(drag_id));
+    // Header tops, for drag-to-reorder.
+    let mut tops: Vec<(u64, f32)> = vec![];
+    for (fi, g) in fx.iter().enumerate() {
+        let GroupKind::Effect { effect } = &g.kind else { continue };
+        // The header draws the effect's name in the interface language; the automation labels
+        // below keep the property tree's name, which is the registry's English name (#821).
+        let shown = crate::i18n::effects::group(effect, &g.name);
+        let r = Rect::from_min_size(pos2(body.min.x, y), vec2(body.width(), ROW + 2.0));
+        tops.push((g.uid, r.min.y));
+        y += ROW + 2.0;
+        let open = !app.ui.fx_closed.contains(&g.uid);
+        let selected = app.session.state.selected_props.iter().any(|(l, u)| *l == layer.id && *u == g.uid);
+        let active = effect_active(g, layer.id, &app.session.state.selected_props);
+        bp.rect_filled(r, 0.0, if active { t.fx_header_active } else { t.fx_header });
+        // The effect's colour label (26.5): a bar on the header's left edge.
+        if let Some(lab) = g.label.filter(|l| *l != effectcraft_engine::color::Label::None) {
+            let [lr, lg, lb] = app.session.prefs.label_rgb(lab);
+            bp.rect_filled(Rect::from_min_size(r.min, vec2(4.0, r.height())), 0.0, Color32::from_rgb(lr, lg, lb));
+            app.auto.add(
+                &format!("effectControls.effect.{}.label", g.uid),
+                Rect::from_min_size(r.min, vec2(4.0, r.height())),
+                &app.session.prefs.label_name(lab),
+            );
+        }
+        let fxr = Rect::from_center_size(pos2(r.min.x + 14.0, r.center().y), vec2(16.0, 16.0));
+        if widgets::icon_toggle(ui, fxr, Icon::Fx, g.enabled, &t, egui::Id::unique(("ec-fx", g.uid)), Sense::click()).clicked() {
+            actions.push(("effect.toggle".into(), json!({"layer": layer.id.0, "effect": g.uid})));
+        }
+        app.auto.add(&format!("effectControls.effect.{}.fx", g.uid), fxr, &g.name);
+        let tw = Rect::from_center_size(pos2(r.min.x + 32.0, r.center().y), vec2(12.0, 12.0));
+        if widgets::twirl(ui, tw, open, egui::Id::unique(("ec-tw", g.uid)), &t).clicked() {
+            toggle_closed(app, g, open, ui.input(|i| i.modifiers.alt || i.modifiers.command));
+        }
+        app.auto.add(&format!("effectControls.effect.{}.twirl", g.uid), tw, &g.name);
+        let rename_id = egui::Id::unique(("ec-rename", g.uid));
+        let editing: Option<String> = ctx.data(|d| d.get_temp(rename_id));
+        let reset = Rect::from_min_size(pos2(r.max.x - 96.0, r.center().y - 9.0), vec2(40.0, 18.0));
+        let hdr_cx = EffectHdr { g, shown: &shown, r, tw, reset, rename_id, layer_id: layer.id.0 };
+        if let Some(value) = editing.as_ref().cloned() {
+            rename_field(app, ui, &hdr_cx, value, &mut actions);
+        } else {
+            let name = bp.text(pos2(tw.max.x + 6.0, r.center().y), Align2::LEFT_CENTER, &shown, Tokens::semibold(12.0), t.text);
+            app.auto.add(&format!("effectControls.effect.{}.name", g.uid), name, &g.name);
+        }
+        let rresp = ui.interact(reset, egui::Id::unique(("ec-reset", g.uid)), Sense::click());
+        bp.text(reset.center(), Align2::CENTER_CENTER, crate::i18n::tr("Reset"), Tokens::ui(11.5), if rresp.hovered() { t.hot_text } else { t.text_dim });
+        app.auto.add(&format!("effectControls.effect.{}.reset", g.uid), reset, "Reset");
+        if rresp.clicked() {
+            actions.push(("effect.reset".into(), json!({"layer": layer.id.0, "effect": g.uid})));
+        }
+        about_button(app, ui, &bp, &t, effect, g, r);
+        let hresp = ui.interact(
+            Rect::from_min_max(pos2(tw.max.x, r.min.y), pos2(reset.min.x - 4.0, r.max.y)),
+            egui::Id::unique(("ec-hdr", g.uid)),
+            if editing.is_some() { Sense::hover() } else { Sense::click_and_drag() },
+        );
+        if hresp.double_clicked() {
+            ctx.data_mut(|d| d.insert_temp(rename_id, shown.clone()));
+            ctx.data_mut(|d| d.insert_temp(rename_id.with("start"), true));
+        }
+        hresp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, true, active, &shown));
+        app.auto.add(&format!("effectControls.effect.{}", g.uid), r, &g.name);
+        if hresp.clicked() || hresp.drag_started() || hresp.secondary_clicked() {
+            let add = ui.input(|i| i.modifiers.shift || i.modifiers.command);
+            if add && hresp.clicked() {
+                if selected {
+                    app.session.state.selected_props.retain(|(l, u)| !(*l == layer.id && *u == g.uid));
+                } else {
+                    app.session.state.selected_props.push((layer.id, g.uid));
+                }
+            } else if !selected || hresp.clicked() {
+                app.session.state.selected_props = vec![(layer.id, g.uid)];
+            }
+        }
+        if hresp.drag_started() {
+            ctx.data_mut(|d| d.insert_temp(drag_id, g.uid));
+        }
+        crate::widgets::context_menu(&hresp, |ui| {
+            let lid = layer.id.0;
+            let mut picked_label: Option<usize> = None;
+            let mut item = |ui: &mut egui::Ui, label: &str, enabled: bool, cmd: &str, params: serde_json::Value| {
+                if ui.add_enabled(enabled, egui::Button::new(crate::i18n::context_item(cmd, &params, label))).clicked() {
+                    actions.push((cmd.into(), params));
+                    ui.close();
+                }
+            };
+            item(ui, "Copy", true, "effect.copy", json!({"layer": lid, "effect": g.uid}));
+            item(ui, "Paste", has_clip, "effect.paste", json!({"layers": [lid]}));
+            item(ui, "Duplicate", true, "effect.duplicate", json!({"layer": lid, "effect": g.uid}));
+            if ui.button(crate::i18n::tr("Rename")).clicked() {
+                ctx.data_mut(|d| d.insert_temp(rename_id, shown.clone()));
+                ctx.data_mut(|d| d.insert_temp(rename_id.with("start"), true));
+                ui.close();
+            }
+            ui.separator();
+            ui.menu_button(crate::i18n::tr("Label"), |ui| {
+                let cur = g.label.unwrap_or(effectcraft_engine::color::Label::None);
+                for (i, l) in effectcraft_engine::color::Label::ALL.into_iter().enumerate() {
+                    if widgets::label_entry(ui, l, &app.session.prefs.label_name(l), l == cur, &t).clicked() {
+                        picked_label = Some(i);
+                        ui.close();
+                    }
+                }
+            });
+            item(ui, "Reset", true, "effect.reset", json!({"layer": lid, "effect": g.uid}));
+            item(ui, "Remove", true, "effect.remove", json!({"layer": lid, "effect": g.uid}));
+            ui.separator();
+            item(ui, "Move Up", fi > 0, "effect.reorder", json!({"layer": lid, "effect": g.uid, "index": fi.max(1)}));
+            item(ui, "Move Down", fi + 1 < fx.len(), "effect.reorder", json!({"layer": lid, "effect": g.uid, "index": fi + 2}));
+            if let Some(i) = picked_label {
+                actions.push(("effect.setLabel".into(), json!({"layer": lid, "effect": g.uid, "label": i})));
+            }
+        });
+        // What the effect can't render as asked (an OCIO config it can't read, transforms it
+        // passes through), under its name.
+        if let Some(w) = effectcraft_engine::effects::warning(g, &mut |pr| ectx.value(&layer, pr)) {
+            let galley = bp.layout(format!("⚠ {w}"), Tokens::ui(11.0), t.warning, (body.width() - 20.0).max(60.0));
+            let wr = Rect::from_min_size(pos2(body.min.x + 10.0, y + 3.0), galley.size());
+            bp.galley(wr.min, galley, t.warning);
+            app.auto.add(&format!("effectControls.effect.{}.warning", g.uid), wr, &w);
+            y += wr.height() + 6.0;
+        }
+        if open {
+            let eh = editor_height(effect, g, body.width());
+            if eh > 0.0 {
+                let er = Rect::from_min_size(pos2(body.min.x, y), vec2(body.width(), eh));
+                y += eh;
+                if er.max.y >= body.min.y && er.min.y <= body.max.y {
+                    // Curves, Levels and other custom editors do not use prop_row.
+                    // Clicking their controls must activate the owner as well.
+                    if ui.input(|i| i.pointer.primary_pressed()) && ui.rect_contains_pointer(er) {
+                        actions.push(("prop.select".into(), json!({"layer":layer.id.0,"prop":g.uid})));
+                    }
+                    effect_editor(app, ui, &EditorCx { bp: &bp, layer: &layer, ectx: &ectx }, g, er, &mut actions);
+                }
+            }
+            let scope = FxScope { effect: effect.as_str(), root: g, path: String::new() };
+            group_rows(app, ui, &bp, &layer, g, &ectx, body, &mut y, 0, &scope, &mut actions);
+            if effect == "ec.color.tint" {
+                let r = Rect::from_min_size(pos2(body.min.x + PARAM_NAME_X, y + 2.0), vec2(120.0, ROW));
+                let label = crate::i18n::tr("Swap Colors");
+                let resp = widgets::text_button(ui, r, label, false, &t, egui::Id::unique(("ec-tint-swap", g.uid)));
+                app.auto.add_response(&format!("effectControls.effect.{}.swapColors", g.uid), &resp, label);
+                if resp.clicked() {
+                    actions.push(("prop.select".into(), json!({"layer": layer.id.0, "prop": g.uid})));
+                    actions.push(("effect.swapTintColors".into(), json!({"layer": layer.id.0, "effect": g.uid})));
+                }
+                y += ROW + 4.0;
+            }
+        }
+        y += 4.0;
+    }
+    if let Some(du) = dragging {
+        reorder_drag(&ctx, &bp, body, &t, &ReorderDrag { tops: &tops, y, du, drag_id, layer_id: layer.id.0 }, &mut actions);
+    }
+    // Right-click anywhere a control has no menu of its own: the Effect menu, which applies to
+    // the selected layers (After Effects). Drawn after the rows, whose menus open first.
+    let menu_id = bg.id.with("effect-menu");
+    let open = ui.input(|i| i.pointer.secondary_clicked())
+        && ui.rect_contains_pointer(body)
+        && (!egui::Popup::is_any_open(&ctx) || egui::Popup::is_id_open(&ctx, menu_id));
+    egui::Popup::context_menu(&bg).style(crate::widgets::menu_style).id(menu_id).open_memory(open.then_some(egui::SetOpenCommand::Bool(true))).show(|ui| {
+        ui.set_min_width(200.0);
+        actions.extend(crate::menus::menu_contents(app, ui, "Effect"));
+    });
+    ui.set_clip_rect(panel_clip);
+    let content_h = y + scroll.offset - body.min.y;
+    scroll.end(ui, &mut app.auto, "effectControls.scroll", content_h, &t);
+    drop_payload(ui, rect, &p, &t, layer.id.0, &mut actions);
+    if ui.input(|i| i.pointer.primary_down()) && actions.iter().any(|(id, _)| id == "prop.set") {
+        app.ui.viewer.property_interacting = true;
+        ctx.request_repaint();
+    }
+    for (id, params) in actions {
+        if let Err(e) = crate::menus::invoke(app, &ctx, &id, params) {
+            app.ui.status = e;
+        }
+    }
+}
diff --git a/crates/ui-egui/src/panels/effect_controls/rows.rs b/crates/ui-egui/src/panels/effect_controls/rows.rs
new file mode 100644
index 000000000..665922fcf
--- /dev/null
+++ b/crates/ui-egui/src/panels/effect_controls/rows.rs
@@ -0,0 +1,743 @@
+use super::common::{Actions, DIAL_ROW, PARAM_NAME_X, ROW, TREE_INDENT, gesture_key};
+use super::{
+    Align2, Color32, EffectcraftApp, EvalCtx, FxPick, Icon, Layer, Node, ParamUi, PropGroup, Property, Rect, Sense, Stroke, Tokens, Value, fw, icons, json,
+    pos2, vec2, widgets,
+};
+
+fn triangle(p: &egui::Painter, c: egui::Pos2, left: bool, col: Color32) {
+    let (dx, h) = (if left { -3.5 } else { 3.5 }, 4.0);
+    p.add(egui::Shape::convex_polygon(vec![pos2(c.x + dx, c.y), pos2(c.x - dx, c.y - h), pos2(c.x - dx, c.y + h)], col, Stroke::NONE));
+}
+
+/// The layer and whether the time is on a key, for the key navigator.
+#[derive(Clone, Copy)]
+struct KeyNav {
+    layer_id: u64,
+    on_key: bool,
+}
+
+/// ◀ ◆ ▶ at the right end of an animated parameter's row.
+fn key_navigator(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, nav: KeyNav, prop: &Property, r: Rect, actions: &mut Actions) {
+    let KeyNav { layer_id, on_key } = nav;
+    let t = app.tokens;
+    let cy = r.center().y;
+    let uid = prop.uid;
+    for (what, dx) in [("prev", -44.0), ("key", -32.0), ("next", -20.0)] {
+        let cr = Rect::from_center_size(pos2(r.max.x + dx, cy), vec2(12.0, 16.0));
+        let resp = ui.interact(cr, egui::Id::unique(("ec-nav", uid, what)), Sense::click());
+        let col = if resp.hovered() { t.text } else { t.text_dim };
+        match what {
+            "prev" => triangle(p, cr.center(), true, col),
+            "next" => triangle(p, cr.center(), false, col),
+            _ => {
+                let kr = Rect::from_center_size(cr.center(), vec2(10.0, 10.0));
+                if on_key {
+                    icons::paint(p, kr, Icon::Keyframe, t.keyframe);
+                } else {
+                    let c = kr.center();
+                    let d = 4.5;
+                    p.add(egui::Shape::closed_line(
+                        vec![pos2(c.x, c.y - d), pos2(c.x + d, c.y), pos2(c.x, c.y + d), pos2(c.x - d, c.y)],
+                        Stroke::new(1.0, col),
+                    ));
+                }
+            }
+        }
+        app.auto.add(&format!("effectControls.prop.{uid}.{what}Key"), cr, &prop.name);
+        if resp.clicked() {
+            match what {
+                "prev" => actions.push(("time.go".into(), json!({"to": "prevKey", "prop": uid}))),
+                "next" => actions.push(("time.go".into(), json!({"to": "nextKey", "prop": uid}))),
+                _ => actions.push(("prop.toggleKey".into(), json!({"layer": layer_id, "prop": uid, "selected": true}))),
+            }
+        }
+    }
+}
+
+/// Toggle a viewer pick (crosshair / eyedropper) for a parameter (also the Timeline's colour
+/// eyedroppers).
+pub(crate) fn toggle_pick(app: &mut EffectcraftApp, kind: &str, layer: &Layer, prop: &Property) {
+    let pick = FxPick { kind: kind.into(), layer: layer.id.0, prop: prop.uid, name: prop.name.clone() };
+    if app.ui.fx_pick.as_ref() == Some(&pick) {
+        app.ui.fx_pick = None;
+    } else {
+        app.ui.fx_pick = Some(pick);
+        app.ui.text_color_pick = None;
+        app.ui.status = if kind == "point" {
+            format!("Click in the Composition panel to set {}", prop.name)
+        } else {
+            format!("Click in the Composition panel to sample {}", prop.name)
+        };
+    }
+}
+
+/// What the value controls of one property row share.
+#[derive(Clone, Copy)]
+struct PropCx<'a> {
+    p: &'a egui::Painter,
+    layer: &'a Layer,
+    group: &'a PropGroup,
+    prop: &'a Property,
+    r: Rect,
+    vx: f32,
+    cy: f32,
+    swr: Rect,
+    t: Tokens,
+    uid: u64,
+    scrub: bool,
+}
+
+impl PropCx<'_> {
+    /// The tokens of the value fields: red while an expression drives the parameter (#1306).
+    fn value_tokens(&self) -> Tokens {
+        self.t.for_value(self.prop.has_expression())
+    }
+
+    /// Queues the `prop.set` of one edit; consecutive edits of the parameter (a scrub) are one undo step.
+    fn set(&self, actions: &mut Actions, v: serde_json::Value) {
+        self.push(actions, v, Some(format!("ec-{}", self.uid)));
+    }
+
+    /// Queues the `prop.set` of a discrete choice (a pop-up pick, a check box): its own undo step,
+    /// never merged with the parameter's previous edit (#2152).
+    fn set_step(&self, actions: &mut Actions, v: serde_json::Value) {
+        self.push(actions, v, None);
+    }
+
+    fn push(&self, actions: &mut Actions, v: serde_json::Value, merge: Option<String>) {
+        let (layer, uid, scrub) = (self.layer, self.uid, self.scrub);
+        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": uid, "value": v, "merge": merge, "selected": true, "offset": scrub})))
+    }
+
+    fn twirl_open(&self, app: &mut EffectcraftApp, ui: &mut egui::Ui) {
+        let PropCx { swr, cy, uid, prop, t, .. } = self;
+        let (cy, uid) = (*cy, *uid);
+        let open = app.ui.fx_slider_open.contains(&uid);
+        let tw = Rect::from_center_size(pos2(swr.min.x - 9.0, cy), vec2(10.0, 10.0));
+        if widgets::twirl(ui, tw, open, egui::Id::unique(("ec-stw", uid)), t).clicked() {
+            if open {
+                app.ui.fx_slider_open.remove(&uid);
+            } else {
+                app.ui.fx_slider_open.insert(uid);
+            }
+        }
+        app.auto.add(&format!("effectControls.prop.{uid}.twirl"), tw, &prop.name);
+    }
+}
+
+/// One property row: stopwatch, name, value control (and the keyframe navigator). Returns the
+/// value fields of a vector, one per dimension, for the pick whip.
+#[allow(clippy::too_many_arguments)]
+fn prop_row(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    p: &egui::Painter,
+    layer: &Layer,
+    group: &PropGroup,
+    prop: &Property,
+    ectx: &EvalCtx,
+    r: Rect,
+    indent: f32,
+    actions: &mut Actions,
+) -> Vec<Rect> {
+    let t = app.tokens;
+    let mut dims = vec![];
+    let cy = r.center().y;
+    let uid = prop.uid;
+    if ui.input(|i| i.pointer.primary_pressed()) && ui.rect_contains_pointer(r) {
+        let add = ui.input(|i| i.modifiers.shift || i.modifiers.command);
+        actions.push(("prop.select".into(), json!({"layer": layer.id.0, "prop": uid, "add": add})));
+    }
+    let swr = Rect::from_center_size(pos2(r.min.x + indent, cy), vec2(14.0, 14.0));
+    if !prop.static_only && !matches!(prop.ui, ParamUi::Hidden) {
+        let resp = ui.interact(swr, egui::Id::unique(("ec-sw", uid)), Sense::click());
+        icons::paint(
+            p,
+            swr,
+            Icon::Stopwatch,
+            if prop.is_animated() {
+                t.hot_text
+            } else if resp.hovered() {
+                t.text
+            } else {
+                t.text_dim
+            },
+        );
+        app.auto.add(&format!("effectControls.prop.{uid}.stopwatch"), swr, &prop.name);
+        if resp.clicked() {
+            actions.push(("prop.toggleAnimation".into(), json!({"layer": layer.id.0, "prop": uid, "selected": true})));
+        }
+    }
+    if prop.is_animated() {
+        let half = ectx.comp.frame_duration().0 / 2;
+        let on_key = prop.keys.iter().any(|k| (layer.comp_time(k.time).0 - ectx.time.0).abs() <= half);
+        key_navigator(app, ui, p, KeyNav { layer_id: layer.id.0, on_key }, prop, r, actions);
+    }
+    let value = ectx.value(layer, prop);
+    // Keep a shared value column while names and their icons follow the group hierarchy.
+    // Extremely deep groups still leave a little name space before their value.
+    let vx = (r.min.x + r.width() * 0.48).max(r.min.x + PARAM_NAME_X + 124.0).max(swr.max.x + 40.0);
+    // A vector's values end before the keyframe navigator: in a narrow panel they move left over
+    // the name (cut short) instead of running under the navigator (#271).
+    let vx = match &value {
+        Value::Vec2(_) | Value::Vec3(_) => {
+            let point = if matches!(prop.ui, ParamUi::Point | ParamUi::Point3) { 22.0 } else { 0.0 };
+            let fields: f32 = value
+                .components()
+                .iter()
+                .take(shown_dims(layer, prop, &value))
+                .map(|v| p.layout_no_wrap(format!("{v:.1}"), Tokens::ui(12.0), t.hot_text).size().x + 12.0)
+                .sum();
+            let right = r.max.x - if prop.is_animated() { 52.0 } else { 8.0 };
+            vx.min(right - point - fields + 8.0).max(swr.max.x + 60.0)
+        }
+        _ => vx,
+    };
+    let name_clip = Rect::from_min_max(pos2(swr.max.x + 6.0, r.min.y), pos2(vx - 6.0, r.max.y));
+    app.auto.add(&format!("effectControls.prop.{uid}.name"), name_clip, &prop.name);
+    p.with_clip_rect(name_clip.intersect(p.clip_rect())).text(pos2(swr.max.x + 6.0, cy), Align2::LEFT_CENTER, &prop.name, Tokens::ui(12.0), t.text);
+    let name_response = ui.interact(name_clip, egui::Id::unique(("ec-prop-name", uid)), Sense::click());
+    if name_response.double_clicked() {
+        app.ui.timeline.search.clear();
+        app.ui.timeline.scroll_to = Some(crate::state::ScrollTo::Property(uid));
+        if let Err(e) = crate::menus::frontend(app, ui.ctx(), "timeline.revealProps", json!({"props": [{"layer": layer.id.0, "prop": uid}]})) {
+            app.ui.status = e;
+        }
+        app.show_panel(crate::dock::PanelKind::Timeline);
+    }
+    app.auto.add(&format!("effectControls.prop.{uid}.name"), name_clip, &prop.name);
+    // With several layers selected the edit applies to the same effect property of each (#491).
+    let scrub = ui.ctx().dragged_id().is_some() && ui.input(|i| i.pointer.is_decidedly_dragging());
+    let cx = PropCx { p, layer, group, prop, r, vx, cy, swr, t, uid, scrub };
+    match &value {
+        Value::Scalar(_) if matches!(prop.ui, ParamUi::Mask) => value_mask(app, ui, &cx, &value, actions),
+        Value::Scalar(_) if matches!(prop.ui, ParamUi::Angle) => value_angle(app, ui, &cx, &value, actions),
+        Value::Scalar(_) => value_scalar(app, ui, &cx, &value, actions),
+        Value::Vec2(_) | Value::Vec3(_) => dims = value_vector(app, ui, &cx, &value, actions),
+        Value::Color(_) => value_color(app, ui, &cx, &value, actions),
+        Value::Bool(_) => value_toggle(app, ui, &cx, &value, actions),
+        Value::Enum(_) => value_popup(app, ui, &cx, &value, actions),
+        Value::Layer(_) => value_layer_ref(app, ui, &cx, &value, actions),
+        // EXtractoR's red / green / blue / alpha: a popup of the footage's OpenEXR channels (#295).
+        Value::Str(_) if crate::panels::fx_editors::is_extractor_channel(group, prop) => value_extractor(app, ui, &cx, &value, actions),
+        // A file parameter (Apply Color LUT's LUT, an OCIO config): its file name and Choose…,
+        // as in After Effects.
+        Value::Str(_) if matches!(prop.ui, ParamUi::File { .. }) => value_file(app, ui, &cx, &value, actions),
+        // A text parameter (Cryptomatte's Selection, Colorama's Output Cycle, config names):
+        // typed in a field, set when it loses the focus (Esc keeps the old text).
+        Value::Str(_) if matches!(prop.ui, ParamUi::Text) => value_text(app, ui, &cx, &value, actions),
+        Value::Gradient(_) => value_gradient(app, &cx, &value),
+        _ => {}
+    }
+    dims
+}
+
+fn value_mask(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) {
+    let Value::Scalar(v) = value else {
+        return;
+    };
+    let PropCx { t, uid, cy, vx, r, layer, prop, .. } = *cx;
+    // A mask of this layer ("Path" popup).
+    let mut opts = vec!["None".to_string()];
+    if let Some(m) = layer.masks() {
+        opts.extend(m.groups().map(|g| g.name.clone()));
+    }
+    let i = v.round().max(0.0) as usize;
+    let label = opts.get(i).cloned().unwrap_or_else(|| format!("Mask {i}"));
+    let dr = Rect::from_min_size(pos2(vx, cy - 9.0), vec2((r.max.x - vx - 56.0).clamp(80.0, 200.0), 18.0));
+    let pop = egui::Id::unique(("ec-mpop", uid));
+    if widgets::dropdown(ui, dr, &label, &t, egui::Id::unique(("ec-m", uid))).clicked() {
+        widgets::open_popup(ui, pop);
+    }
+    app.auto.add(&format!("effectControls.prop.{uid}.value"), dr, &prop.name);
+    if let Some(ni) = widgets::popup_menu(ui, pop, dr.left_bottom(), &opts, Some(i)) {
+        cx.set_step(actions, json!(ni as f64));
+    }
+}
+
+fn value_angle(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) {
+    let Value::Scalar(v) = value else {
+        return;
+    };
+    let PropCx { uid, cy, vx, prop, .. } = *cx;
+    let (rr, dr, nv) = fw::angle_field(ui, pos2(vx, cy - 9.0), egui::Id::unique(("ec-v", uid)), *v, 1, &cx.value_tokens());
+    app.auto.add(&format!("effectControls.prop.{uid}.value"), rr.union(dr), &fw::format_angle(*v, 1));
+    app.auto.add(&format!("effectControls.prop.{uid}.revolutions"), rr, &prop.name);
+    if let Some(nv) = nv {
+        cx.set(actions, json!(nv));
+    }
+    cx.twirl_open(app, ui);
+}
+
+fn value_scalar(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) {
+    let Value::Scalar(v) = value else {
+        return;
+    };
+    let PropCx { uid, cy, vx, prop, .. } = *cx;
+    let (min, max, dec) = match &prop.ui {
+        ParamUi::Slider { min, max, decimals, .. } => (*min, *max, *decimals as usize),
+        _ => (-1e9, 1e9, 1),
+    };
+    let suffix = match prop.ui {
+        ParamUi::Percent => "%",
+        _ => "",
+    };
+    let speed = widgets::slider_scrub_speed(&prop.ui);
+    let (vr, nv, _) = widgets::hot_number_at(
+        ui,
+        pos2(vx, cy - 9.0),
+        egui::Id::unique(("ec-v", uid)),
+        *v,
+        &widgets::HotSpec { speed, range: (min, max), decimals: dec.max(if dec == 0 { 0 } else { 1 }), suffix },
+        &cx.value_tokens(),
+    );
+    app.auto.add(&format!("effectControls.prop.{uid}.value"), vr, &prop.name);
+    if let Some(nv) = nv {
+        cx.set(actions, json!(nv));
+    }
+    // AE hides a slider param's slider until its twirl is opened (see `slider_row`).
+    if matches!(prop.ui, ParamUi::Slider { .. }) {
+        cx.twirl_open(app, ui);
+    }
+}
+
+fn value_vector(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) -> Vec<Rect> {
+    let mut dims = vec![];
+    let PropCx { t, uid, cy, vx, layer, prop, .. } = *cx;
+    let c = value.components();
+    let n = shown_dims(layer, prop, value);
+    let vt = cx.value_tokens();
+    let mut x = vx;
+    if matches!(prop.ui, ParamUi::Point | ParamUi::Point3) {
+        let cr = Rect::from_center_size(pos2(x + 8.0, cy), vec2(18.0, 18.0));
+        let active = app.ui.fx_pick.as_ref().is_some_and(|k| k.prop == uid && k.kind == "point");
+        if fw::crosshair_button(ui, cr, active, egui::Id::unique(("ec-xh", uid)), &t)
+            .on_hover_text(crate::i18n::tr("Click, then click in the Composition panel"))
+            .clicked()
+        {
+            toggle_pick(app, "point", layer, prop);
+        }
+        app.auto.add(&format!("effectControls.prop.{uid}.crosshair"), cr, &prop.name);
+        x += 22.0;
+    }
+    for d in 0..n.min(c.len()) {
+        let (vr, nv, _) = widgets::hot_number_at(
+            ui,
+            pos2(x, cy - 9.0),
+            egui::Id::unique(("ec-v", uid, d)),
+            c[d],
+            &widgets::HotSpec { speed: 1.0, range: (-1e9, 1e9), decimals: 1, suffix: "" },
+            &vt,
+        );
+        app.auto.add(&format!("effectControls.prop.{uid}.value.{d}"), vr, &prop.name);
+        dims.push(vr);
+        if let Some(nv) = nv {
+            let mut nc = c.clone();
+            nc[d] = nv;
+            cx.set(actions, json!(nc));
+            // Typed into this component only: other selected layers keep the rest of
+            // their own value (#1434).
+            if let Some((_, a)) = actions.last_mut() {
+                a["dims"] = json!([d]);
+            }
+        }
+        x = vr.max.x + 8.0;
+    }
+    dims
+}
+
+fn value_color(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) {
+    let Value::Color(c) = value else {
+        return;
+    };
+    let PropCx { t, uid, cy, vx, layer, prop, .. } = *cx;
+    let sr = Rect::from_min_size(pos2(vx, cy - 8.0), vec2(30.0, 16.0));
+    let pop = egui::Id::unique(("ec-cpop", uid));
+    if widgets::swatch(ui, sr, [c[0] as f32, c[1] as f32, c[2] as f32, 1.0], egui::Id::unique(("ec-c", uid)), &t).clicked() {
+        widgets::open_popup(ui, pop);
+    }
+    app.auto.add(&format!("effectControls.prop.{uid}.value"), sr, &prop.name);
+    let er = Rect::from_center_size(pos2(sr.max.x + 14.0, cy), vec2(18.0, 18.0));
+    let active = app.ui.fx_pick.as_ref().is_some_and(|k| k.prop == uid && k.kind == "color");
+    if fw::eyedropper_button(ui, er, active, egui::Id::unique(("ec-eye", uid)), &t)
+        .on_hover_text(crate::i18n::tr("Eyedropper: click, then click in the Composition panel"))
+        .clicked()
+    {
+        toggle_pick(app, "color", layer, prop);
+    }
+    app.auto.add(&format!("effectControls.prop.{uid}.eyedropper"), er, &prop.name);
+    let mut rgb = [c[0] as f32, c[1] as f32, c[2] as f32];
+    if crate::widgets::color_popup(ui, pop, sr.left_bottom(), &mut rgb) {
+        cx.set(actions, json!([rgb[0], rgb[1], rgb[2], 1.0]));
+    }
+}
+
+fn value_toggle(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) {
+    let Value::Bool(b) = value else {
+        return;
+    };
+    let PropCx { t, uid, cy, vx, p, prop, .. } = *cx;
+    let cr = Rect::from_min_size(pos2(vx, cy - 8.0), vec2(16.0, 16.0));
+    if widgets::checkbox(ui, cr, *b, &t, egui::Id::unique(("ec-b", uid))).changed() {
+        cx.set_step(actions, json!(!b));
+    }
+    p.text(pos2(cr.max.x + 6.0, cy), Align2::LEFT_CENTER, &prop.name, Tokens::ui(12.0), t.text_dim);
+    app.auto.add(&format!("effectControls.prop.{uid}.value"), cr, &prop.name);
+}
+
+fn value_popup(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) {
+    let Value::Enum(i) = value else {
+        return;
+    };
+    let PropCx { t, uid, cy, vx, r, p, prop, .. } = *cx;
+    if let ParamUi::Popup { options } = &prop.ui {
+        let widest = options.iter().map(|o| p.layout_no_wrap(o.clone(), Tokens::ui(11.5), t.text).size().x).fold(0.0, f32::max);
+        let dr = Rect::from_min_size(pos2(vx, cy - 9.0), vec2((widest + 30.0).clamp(80.0, (r.max.x - vx - 56.0).max(80.0)), 18.0));
+        let pop = egui::Id::unique(("ec-epop", uid));
+        if widgets::dropdown(ui, dr, options.get(*i as usize).map(String::as_str).unwrap_or(""), &t, egui::Id::unique(("ec-e", uid))).clicked() {
+            widgets::open_popup(ui, pop);
+        }
+        app.auto.add(&format!("effectControls.prop.{uid}.value"), dr, &prop.name);
+        if let Some(ni) = widgets::popup_menu(ui, pop, dr.left_bottom(), options, Some(*i as usize)) {
+            cx.set_step(actions, json!(ni));
+        }
+    }
+}
+
+fn value_layer_ref(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) {
+    let Value::Layer(l) = value else {
+        return;
+    };
+    let PropCx { t, uid, cy, vx, r, layer, prop, group, .. } = *cx;
+    let comp = app.session.active_comp_arc();
+    if let Some(comp) = comp {
+        let dr = Rect::from_min_size(pos2(vx, cy - 9.0), vec2(((r.max.x - vx) * 0.55).clamp(90.0, 170.0), 18.0));
+        if let Some(chosen) = widgets::layer_picker(ui, dr, &comp.layers, *l, &t, egui::Id::unique(("ec-l", uid))) {
+            cx.set_step(actions, chosen.map(|id| json!(id)).unwrap_or(serde_json::Value::Null));
+        }
+        app.auto.add(&format!("effectControls.prop.{uid}.value"), dr, &prop.name);
+        // Source / Masks / Effects & Masks (the hidden companion parameter).
+        if let Some(src) = group.get(&effectcraft_engine::effects::layer_source_id(&prop.match_id)) {
+            let si = src.value.as_enum() as usize;
+            let opts: Vec<String> = effectcraft_engine::effects::LAYER_SOURCE_OPTIONS.iter().map(|s| s.to_string()).collect();
+            let sr = Rect::from_min_size(pos2(dr.max.x + 6.0, cy - 9.0), vec2(((r.max.x - dr.max.x) - 64.0).clamp(70.0, 120.0), 18.0));
+            let spop = egui::Id::unique(("ec-lspop", uid));
+            if widgets::dropdown(ui, sr, opts.get(si).map(String::as_str).unwrap_or(""), &t, egui::Id::unique(("ec-ls", uid))).clicked() {
+                widgets::open_popup(ui, spop);
+            }
+            app.auto.add(&format!("effectControls.prop.{uid}.source"), sr, &src.name);
+            if let Some(ni) = widgets::popup_menu(ui, spop, sr.left_bottom(), &opts, Some(si)) {
+                actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": src.uid, "value": ni})));
+            }
+        }
+    }
+}
+
+fn value_extractor(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) {
+    let Value::Str(s) = value else {
+        return;
+    };
+    let PropCx { cy, vx, r, layer, prop, .. } = *cx;
+    let dr = Rect::from_min_size(pos2(vx, cy - 9.0), vec2((r.max.x - vx - 56.0).clamp(80.0, 200.0), 18.0));
+    crate::panels::fx_editors::channel_popup(app, ui, layer, prop, s, dr, actions);
+}
+
+fn value_file(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) {
+    let Value::Str(s) = value else {
+        return;
+    };
+    let PropCx { t, uid, cy, vx, r, p, layer, prop, .. } = *cx;
+    let bw = 70.0;
+    let br = Rect::from_min_size(pos2(vx, cy - 9.0), vec2(bw, 18.0));
+    if widgets::text_button(ui, br, crate::i18n::tr("Choose..."), false, &t, egui::Id::unique(("ec-file", uid))).clicked() {
+        let filters: Vec<&str> = match &prop.ui {
+            ParamUi::File { filters } => filters.iter().map(String::as_str).collect(),
+            _ => vec![],
+        };
+        match app.hooks.pick_files.as_ref() {
+            Some(pick) => {
+                if let Some(path) = pick(&filters).into_iter().next() {
+                    actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": uid, "value": path})));
+                }
+            }
+            None => app.ui.status = "no file dialog available: set the path with prop.set".into(),
+        }
+    }
+    app.auto.add(&format!("effectControls.prop.{uid}.choose"), br, &prop.name);
+    let shown = if s.trim().is_empty() {
+        crate::i18n::tr("None").to_string()
+    } else if s.contains('\n') {
+        prop.name.clone()
+    } else {
+        effectcraft_engine::sequence::file_name(s)
+    };
+    let nr = Rect::from_min_max(pos2(br.max.x + 8.0, r.min.y), pos2(r.max.x - 8.0, r.max.y));
+    let np = p.with_clip_rect(nr.intersect(p.clip_rect()));
+    np.text(pos2(nr.min.x, cy), Align2::LEFT_CENTER, &shown, Tokens::ui(12.0), if s.trim().is_empty() { t.text_dim } else { t.text });
+    let hover = ui.interact(nr, egui::Id::unique(("ec-file-name", uid)), Sense::hover());
+    if !s.trim().is_empty() && !s.contains('\n') {
+        hover.on_hover_text(s);
+    }
+    app.auto.add(&format!("effectControls.prop.{uid}.value"), nr, &shown);
+}
+
+fn value_text(app: &mut EffectcraftApp, ui: &mut egui::Ui, cx: &PropCx, value: &Value, actions: &mut Actions) {
+    let Value::Str(s) = value else {
+        return;
+    };
+    let PropCx { t, uid, cy, vx, r, layer, prop, .. } = *cx;
+    let fr = Rect::from_min_size(pos2(vx, cy - 9.0), vec2((r.max.x - vx - 12.0).clamp(80.0, 320.0), 18.0));
+    let bid = egui::Id::unique(("ec-text", uid));
+    let mut buf: String = ui.data(|d| d.get_temp(bid)).unwrap_or_else(|| s.to_owned());
+    let resp = widgets::text_field(ui, fr, &mut buf, "", &t);
+    // The field has no visible hint: give the screen reader the parameter's name.
+    resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::TextInput, ui.is_enabled(), &prop.name));
+    app.auto.add(&format!("effectControls.prop.{uid}.value"), fr, &prop.name);
+    if resp.lost_focus() {
+        if buf != *s && !ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+            actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": uid, "value": buf})));
+        }
+        ui.data_mut(|d| d.remove::<String>(bid));
+    } else if resp.has_focus() {
+        ui.data_mut(|d| d.insert_temp(bid, buf));
+    }
+}
+
+fn value_gradient(app: &mut EffectcraftApp, cx: &PropCx, value: &Value) {
+    let Value::Gradient(g) = value else {
+        return;
+    };
+    let PropCx { t, uid, cy, vx, r, p, prop, .. } = *cx;
+    let gr = Rect::from_min_size(pos2(vx, cy - 7.0), vec2((r.max.x - vx - 56.0).clamp(60.0, 180.0), 14.0));
+    let n = 48;
+    for k in 0..n {
+        let f = k as f64 / (n - 1) as f64;
+        let c = gradient_at(g, f);
+        let x0 = gr.min.x + gr.width() * k as f32 / n as f32;
+        let x1 = gr.min.x + gr.width() * (k + 1) as f32 / n as f32;
+        p.rect_filled(Rect::from_min_max(pos2(x0, gr.min.y), pos2(x1, gr.max.y)), 0.0, c);
+    }
+    p.rect_stroke(gr, 2.0, Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside);
+    app.auto.add(&format!("effectControls.prop.{uid}.value"), gr, &prop.name);
+}
+
+/// How many of a vector parameter's values show (a 3D point's Z only on a 3D layer).
+fn shown_dims(layer: &Layer, prop: &Property, value: &Value) -> usize {
+    let n = value.components().len();
+    if prop.shown_dims > 0 && !(layer.is_3d() && n == 3) { prop.shown_dims as usize } else { n }
+}
+
+/// Colour of a gradient at `f` (colour stops only).
+fn gradient_at(g: &effectcraft_engine::keyframe::Gradient, f: f64) -> Color32 {
+    let stops = &g.colors;
+    let c = if stops.is_empty() {
+        [0.0, 0.0, 0.0, 1.0]
+    } else if f <= stops[0].0 {
+        stops[0].1
+    } else if f >= stops[stops.len() - 1].0 {
+        stops[stops.len() - 1].1
+    } else {
+        let i = stops.iter().position(|s| s.0 > f).unwrap_or(stops.len() - 1).max(1);
+        let (a, b) = (stops[i - 1], stops[i]);
+        let k = ((f - a.0) / (b.0 - a.0).max(1e-9)) as f32;
+        [0, 1, 2, 3].map(|j| a.1[j] + (b.1[j] - a.1[j]) * k)
+    };
+    Color32::from_rgb((c[0].clamp(0.0, 1.0) * 255.0) as u8, (c[1].clamp(0.0, 1.0) * 255.0) as u8, (c[2].clamp(0.0, 1.0) * 255.0) as u8)
+}
+
+/// The twirled-open slider under a slider param: track, knob and the slider range's ends.
+#[allow(clippy::too_many_arguments)]
+fn slider_row(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    p: &egui::Painter,
+    layer: &Layer,
+    prop: &Property,
+    ectx: &EvalCtx,
+    r: Rect,
+    x0: f32,
+    actions: &mut Actions,
+) {
+    let t = app.tokens;
+    let ParamUi::Slider { slider_min, slider_max, decimals, .. } = prop.ui else { return };
+    let Value::Scalar(v) = ectx.value(layer, prop) else { return };
+    let uid = prop.uid;
+    let tr = Rect::from_min_max(pos2(r.min.x + x0, r.min.y + 8.0), pos2(r.max.x - 16.0, r.min.y + 12.0));
+    if tr.width() < 40.0 {
+        return;
+    }
+    p.rect_filled(tr, 2.0, t.field_bg);
+    let f = ((v - slider_min) / (slider_max - slider_min)).clamp(0.0, 1.0) as f32;
+    p.rect_filled(Rect::from_min_max(tr.min, pos2(tr.min.x + tr.width() * f, tr.max.y)), 2.0, t.accent.gamma_multiply(0.7));
+    p.circle_filled(pos2(tr.min.x + tr.width() * f, tr.center().y), 5.0, t.text);
+    let dec = decimals as usize;
+    p.text(pos2(tr.min.x, tr.max.y + 4.0), Align2::LEFT_TOP, format!("{slider_min:.dec$}"), Tokens::ui(10.5), t.text_dim);
+    p.text(pos2(tr.max.x, tr.max.y + 4.0), Align2::RIGHT_TOP, format!("{slider_max:.dec$}"), Tokens::ui(10.5), t.text_dim);
+    let sresp = ui.interact(tr.expand2(vec2(4.0, 6.0)), egui::Id::unique(("ec-slider", uid)), Sense::click_and_drag());
+    app.auto.add(&format!("effectControls.prop.{uid}.slider"), tr, &prop.name);
+    if (sresp.dragged() || sresp.clicked())
+        && let Some(pt) = sresp.interact_pointer_pos()
+    {
+        let f = ((pt.x - tr.min.x) / tr.width()).clamp(0.0, 1.0) as f64;
+        actions.push((
+            "prop.set".into(),
+            json!({"layer": layer.id.0, "prop": uid, "value": slider_min + (slider_max - slider_min) * f, "merge": format!("ec-{uid}")}),
+        ));
+    }
+}
+
+/// The twirled-open angle dial under an angle param.
+#[allow(clippy::too_many_arguments)]
+fn dial_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, layer: &Layer, prop: &Property, ectx: &EvalCtx, r: Rect, x0: f32, actions: &mut Actions) {
+    let t = app.tokens;
+    let Value::Scalar(v) = ectx.value(layer, prop) else { return };
+    let uid = prop.uid;
+    let d = (r.height() - 12.0).min(52.0);
+    let dr = Rect::from_min_size(pos2(r.min.x + x0 + 40.0, r.min.y + 6.0), vec2(d, d));
+    let id = egui::Id::unique(("ec-dial", uid));
+    let (resp, nv) = fw::angle_dial(ui, dr, v, id, &t);
+    app.auto.add(&format!("effectControls.prop.{uid}.dial"), dr, &prop.name);
+    if let Some(nv) = nv {
+        let key = gesture_key(ui, id, resp.drag_started() || resp.clicked());
+        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": uid, "value": nv, "merge": key})));
+    }
+}
+
+/// The effect instance a row belongs to, for conditional visibility
+/// ([`effectcraft_engine::effects::catalog::param_shown`]): effect id, the instance's root
+/// group and the spec-id path of the group being drawn (`""` or `cameraPosition/`).
+pub(super) struct FxScope<'a> {
+    pub(super) effect: &'a str,
+    pub(super) root: &'a PropGroup,
+    pub(super) path: String,
+}
+
+impl<'a> FxScope<'a> {
+    pub(super) fn sub(&self, m: &str) -> FxScope<'a> {
+        FxScope { effect: self.effect, root: self.root, path: format!("{}{m}/", self.path) }
+    }
+    /// Whether child `m` of the current group is shown.
+    pub(super) fn shown(&self, layer: &Layer, ectx: &EvalCtx, m: &str) -> bool {
+        let root = self.root;
+        let value = |id: &str| -> Option<Value> {
+            let mut g = root;
+            let mut parts = id.split('/').peekable();
+            while let Some(part) = parts.next() {
+                if parts.peek().is_none() {
+                    return g.get(part).map(|p| ectx.value(layer, p));
+                }
+                g = g.sub(part)?;
+            }
+            None
+        };
+        effectcraft_engine::effects::catalog::param_shown(self.effect, &format!("{}{m}", self.path), &value)
+    }
+}
+
+/// Twirl `g` closed (it was `open`) or open; with `all` (Alt/Cmd-click) every group under it follows.
+pub(super) fn toggle_closed(app: &mut EffectcraftApp, g: &PropGroup, open: bool, all: bool) {
+    fn walk(g: &PropGroup, out: &mut Vec<u64>) {
+        for sg in g.groups() {
+            out.push(sg.uid);
+            walk(sg, out);
+        }
+    }
+    let mut uids = vec![g.uid];
+    if all {
+        walk(g, &mut uids);
+    }
+    for u in uids {
+        if open {
+            app.ui.fx_closed.insert(u);
+        } else {
+            app.ui.fx_closed.remove(&u);
+        }
+    }
+}
+
+/// Lays out one property group's rows below `*y` (which it advances), recursing into open
+/// subgroups: one row per visible property with its controls, plus the dial or slider row when its
+/// slider is open, and an inline editor for groups that have one. Rows scrolled out of `rect` are
+/// skipped without being drawn or registered, though their height is still counted. Pick-whip
+/// drops are registered for each visible property; edits go on `actions`.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn group_rows(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    p: &egui::Painter,
+    layer: &Layer,
+    g: &PropGroup,
+    ectx: &EvalCtx,
+    rect: Rect,
+    y: &mut f32,
+    depth: usize,
+    fx: &FxScope,
+    actions: &mut Actions,
+) {
+    let t = app.tokens;
+    for c in &g.children {
+        let r = Rect::from_min_size(pos2(rect.min.x, *y), vec2(rect.width(), ROW));
+        match c {
+            Node::Prop(pr) => {
+                if matches!(pr.ui, ParamUi::Hidden) || pr.three_d_only && !layer.is_3d() || !fx.shown(layer, ectx, &pr.match_id) {
+                    continue;
+                }
+                *y += ROW;
+                let indent = PARAM_NAME_X - 13.0 + TREE_INDENT * depth as f32;
+                let visible = !(r.max.y < rect.min.y || r.min.y > rect.max.y);
+                if visible {
+                    app.auto.add(&format!("effectControls.row.{}", pr.uid), r, &pr.name);
+                    let dims = prop_row(app, ui, p, layer, g, pr, ectx, r, indent, actions);
+                    // A Timeline pick whip can be dropped here (After Effects).
+                    crate::panels::timeline::whip_target(ui.ctx(), r.intersect(rect), layer.id.0, pr.uid, dims);
+                }
+                if app.ui.fx_slider_open.contains(&pr.uid) {
+                    if matches!(pr.ui, ParamUi::Angle) {
+                        let sr = Rect::from_min_size(pos2(rect.min.x, *y), vec2(rect.width(), DIAL_ROW));
+                        *y += DIAL_ROW;
+                        if sr.max.y >= rect.min.y && sr.min.y <= rect.max.y {
+                            dial_row(app, ui, layer, pr, ectx, sr, indent + 22.0, actions);
+                        }
+                    } else if matches!(pr.ui, ParamUi::Slider { .. }) {
+                        let sr = Rect::from_min_size(pos2(rect.min.x, *y), vec2(rect.width(), 34.0));
+                        *y += 34.0;
+                        if sr.max.y >= rect.min.y && sr.min.y <= rect.max.y {
+                            slider_row(app, ui, p, layer, pr, ectx, sr, indent + 22.0, actions);
+                        }
+                    }
+                }
+            }
+            Node::Group(sg) => {
+                // Paint strokes live in the Timeline only (AE's Paint shows Paint on Transparent).
+                if effectcraft_engine::effects::paint::is_paint(g) || !fx.shown(layer, ectx, &sg.match_id) {
+                    continue;
+                }
+                *y += ROW;
+                let open = !app.ui.fx_closed.contains(&sg.uid);
+                let tw = Rect::from_center_size(pos2(r.min.x + PARAM_NAME_X - 12.0 + TREE_INDENT * depth as f32, r.center().y), vec2(12.0, 12.0));
+                if r.max.y >= rect.min.y && r.min.y <= rect.max.y {
+                    app.auto.add(&format!("effectControls.row.{}", sg.uid), r, &sg.name);
+                    app.auto.add(&format!("effectControls.group.{}.twirl", sg.uid), tw, &sg.name);
+                    if widgets::twirl(ui, tw, open, egui::Id::unique(("ec-g", sg.uid)), &t).clicked() {
+                        toggle_closed(app, sg, open, ui.input(|i| i.modifiers.alt || i.modifiers.command));
+                    }
+                    let name = p.text(pos2(tw.max.x + 6.0, r.center().y), Align2::LEFT_CENTER, &sg.name, Tokens::ui(12.0), t.text);
+                    app.auto.add(&format!("effectControls.group.{}.name", sg.uid), name, &sg.name);
+                }
+                if open {
+                    let sub = fx.sub(&sg.match_id);
+                    // A visual editor for the group's hidden parameters (Lumetri curves, …).
+                    let eh = crate::panels::fx_editors::inline_height(fx.effect, &sub.path, rect.width());
+                    if eh > 0.0 {
+                        let er = Rect::from_min_size(pos2(rect.min.x, *y), vec2(rect.width(), eh));
+                        *y += eh;
+                        if er.max.y >= rect.min.y && er.min.y <= rect.max.y {
+                            crate::panels::fx_editors::inline_editor(app, ui, p, layer, fx.root, sg, fx.effect, &sub.path, ectx, er, actions);
+                        }
+                    }
+                    group_rows(app, ui, p, layer, sg, ectx, rect, y, depth + 1, &sub, actions);
+                }
+            }
+        }
+    }
+}
diff --git a/crates/ui-egui/src/panels/effect_controls/viewer.rs b/crates/ui-egui/src/panels/effect_controls/viewer.rs
new file mode 100644
index 000000000..6f59d8c96
--- /dev/null
+++ b/crates/ui-egui/src/panels/effect_controls/viewer.rs
@@ -0,0 +1,321 @@
+use std::ops::ControlFlow;
+
+use super::common::{Actions, effect_active, gesture_key};
+use super::rows::FxScope;
+use super::{
+    Align2, Color32, EffectcraftApp, EvalCtx, GroupKind, Layer, Mat3, Node, ParamUi, PropGroup, Property, Rect, Sense, Stroke, Tokens, fw, json, vec2,
+};
+
+// ---------------------------------------------------------------------------------------------
+// Viewer hook
+
+/// Collect point controls through visible parameter groups. Hidden optional slots do not
+/// leave stray viewport handles. The depth cap also bounds malformed project trees.
+fn visible_points<'a>(g: &'a PropGroup, scope: &FxScope<'_>, layer: &Layer, ectx: &EvalCtx, depth: usize, out: &mut Vec<&'a Property>) {
+    if depth > 16 {
+        return;
+    }
+    for node in &g.children {
+        match node {
+            Node::Prop(p) if matches!(p.ui, ParamUi::Point) && scope.shown(layer, ectx, &p.match_id) => out.push(p),
+            Node::Group(child) if child.enabled && scope.shown(layer, ectx, &child.match_id) => {
+                visible_points(child, &scope.sub(&child.match_id), layer, ectx, depth + 1, out)
+            }
+            _ => {}
+        }
+    }
+}
+
+/// An armed crosshair / eyedropper pick: the hint chip, the cursor preview, and the click that
+/// sets or samples. `Break` when the picked layer is gone; `Continue` carries the point preview.
+fn fx_pick_session(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    painter: &egui::Painter,
+    map: &crate::panels::viewer::ViewerMap,
+    ectx: &EvalCtx,
+    l2c: &dyn Fn(&EvalCtx, &Layer) -> Mat3,
+    actions: &mut Actions,
+) -> ControlFlow<(), Option<egui::Pos2>> {
+    let t = app.tokens;
+    let ctx = ui.ctx().clone();
+    let mut point_preview = None;
+    let Some(pick) = app.ui.fx_pick.clone() else {
+        return ControlFlow::Continue(None);
+    };
+    let Some(layer) = ectx.comp.layer(effectcraft_engine::project::LayerId(pick.layer)).cloned() else {
+        app.ui.fx_pick = None;
+        return ControlFlow::Break(());
+    };
+    // Keyers pick from their input (the shown frame is already keyed): `effect.pickColor`.
+    let keyer = (pick.kind == "color")
+        .then(|| layer.effects()?.groups().find(|g| g.find(pick.prop).is_some()))
+        .flatten()
+        .filter(|g| effectcraft_engine::effects::find(&g.match_id).is_some_and(|s| s.category == "Keying"))
+        .map(|g| g.uid);
+    if pick.kind == "color" && keyer.is_none() {
+        // GPU frames: read the shown frame back for sampling.
+        app.viewer_pixels();
+    }
+    let resp = ui.interact(map.area, egui::Id::unique("viewer-fx-pick"), Sense::click());
+    app.auto.add("viewer.fxPick", map.area, &pick.name);
+    let hint = if pick.kind == "point" { format!("Click to set {}", pick.name) } else { format!("Click to sample {}", pick.name) };
+    let chip = Rect::from_min_size(map.area.min + vec2(10.0, 10.0), vec2(220.0, 22.0));
+    painter.rect_filled(chip, 11.0, Color32::from_black_alpha(180));
+    painter.text(chip.center(), Align2::CENTER_CENTER, hint, Tokens::ui(11.5), t.text);
+    if let Some(hp) = resp.hover_pos() {
+        ctx.set_cursor_icon(egui::CursorIcon::Crosshair);
+        let c = map.to_comp(hp);
+        app.pointer_comp = Some([c[0] as f32, c[1] as f32]);
+        if pick.kind == "point" && fw::comp_to_layer(&l2c(ectx, &layer), c).is_some() {
+            point_preview = Some(hp);
+        }
+        if pick.kind == "color"
+            && keyer.is_none()
+            && let Some(img) = &app.viewer_image
+            && let Some(s) = fw::sample_frame(img, crate::panels::viewer_tools::shown_region(&ctx, map.comp), c)
+        {
+            let sw = Rect::from_min_size(hp + vec2(14.0, 14.0), vec2(26.0, 18.0));
+            painter.rect_filled(sw, 2.0, Color32::from_rgb((s[0] * 255.0) as u8, (s[1] * 255.0) as u8, (s[2] * 255.0) as u8));
+            painter.rect_stroke(sw, 2.0, Stroke::new(1.0, Color32::WHITE), egui::StrokeKind::Outside);
+        }
+    }
+    // No frame to sample yet (it is still rendering, or its readback is pending): the click
+    // leaves the eyedropper armed instead of using it up without a colour.
+    let unsampled = pick.kind == "color" && keyer.is_none() && app.viewer_image.is_none();
+    if resp.clicked()
+        && !unsampled
+        && let Some(pos) = resp.interact_pointer_pos()
+    {
+        let c = map.to_comp(pos);
+        // Effect points and the keyer's input are in effect space.
+        let m = crate::panels::viewer::from_effect_space(ectx, &layer, l2c(ectx, &layer));
+        if pick.kind == "point" {
+            if let Some(lp) = fw::comp_to_layer(&m, c) {
+                actions.push(("prop.set".into(), json!({"layer": pick.layer, "prop": pick.prop, "value": [lp[0], lp[1]]})));
+            }
+        } else if let Some(fx) = keyer {
+            // Ctrl/Cmd+click averages the 5 × 5 pixels around the point.
+            if let Some(lp) = fw::comp_to_layer(&m, c) {
+                let average = ui.input(|i| i.modifiers.command);
+                actions.push((
+                    "effect.pickColor".into(),
+                    json!({"layer": pick.layer, "effect": fx, "prop": pick.prop, "x": lp[0], "y": lp[1], "average": average}),
+                ));
+            }
+        } else if let Some(img) = &app.viewer_image
+            && let Some(s) = fw::sample_frame(img, crate::panels::viewer_tools::shown_region(&ctx, map.comp), c)
+        {
+            actions.push(("prop.set".into(), json!({"layer": pick.layer, "prop": pick.prop, "value": [s[0], s[1], s[2], 1.0]})));
+        }
+        app.ui.fx_pick = None;
+        app.ui.status.clear();
+    }
+    if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+        app.ui.fx_pick = None;
+        app.ui.status.clear();
+    }
+
+    ControlFlow::Continue(point_preview)
+}
+
+/// Shared hint chip and sampled-color swatch for text and popup eyedroppers.
+fn color_pick_preview(app: &EffectcraftApp, painter: &egui::Painter, map: &crate::panels::viewer::ViewerMap, hint: &str, pointer: Option<egui::Pos2>) {
+    let chip = Rect::from_min_size(map.area.min + vec2(10.0, 10.0), vec2(220.0, 22.0));
+    painter.rect_filled(chip, 11.0, Color32::from_black_alpha(180));
+    painter.text(chip.center(), Align2::CENTER_CENTER, hint, Tokens::ui(11.5), app.tokens.text);
+    if let Some(pos) = pointer
+        && let Some(sample) = crate::panels::viewer_tools::sample_displayed(app, painter.ctx(), map.to_comp(pos))
+    {
+        let swatch = Rect::from_min_size(pos + vec2(14.0, 14.0), vec2(26.0, 18.0));
+        painter.rect_filled(swatch, 2.0, Color32::from_rgb((sample[0] * 255.0) as u8, (sample[1] * 255.0) as u8, (sample[2] * 255.0) as u8));
+        painter.rect_stroke(swatch, 2.0, Stroke::new(1.0, Color32::WHITE), egui::StrokeKind::Outside);
+    }
+}
+
+/// An armed text-colour pick: sample the shown frame on click, Esc cancels.
+fn text_color_pick(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    painter: &egui::Painter,
+    map: &crate::panels::viewer::ViewerMap,
+    ectx: &EvalCtx,
+    actions: &mut Actions,
+) {
+    let ctx = ui.ctx().clone();
+    let Some(pick) = app.ui.text_color_pick.clone() else {
+        return;
+    };
+    if ectx.comp.layer(effectcraft_engine::project::LayerId(pick.layer)).is_none() {
+        app.ui.text_color_pick = None;
+        app.ui.status.clear();
+    } else {
+        app.viewer_pixels();
+        let resp = ui.interact(map.area, egui::Id::unique("viewer-text-color-pick"), Sense::click());
+        app.auto.add("viewer.textColorPick", map.area, &pick.field);
+        color_pick_preview(app, painter, map, &crate::i18n::tr_args("Click to sample text {}", &[&pick.field]), resp.hover_pos());
+        if let Some(pos) = resp.hover_pos() {
+            ctx.set_cursor_icon(egui::CursorIcon::Crosshair);
+            let c = map.to_comp(pos);
+            app.pointer_comp = Some([c[0] as f32, c[1] as f32]);
+        }
+        if resp.clicked()
+            && let Some(pos) = resp.interact_pointer_pos()
+            && let Some(s) = crate::panels::viewer_tools::sample_displayed(app, &ctx, map.to_comp(pos))
+        {
+            let mut params = json!({"layer": pick.layer});
+            params[&pick.field] = json!([s[0], s[1], s[2]]);
+            if let Some(range) = pick.range {
+                params["range"] = json!(range);
+            }
+            actions.push(("layer.setText".into(), params));
+            app.ui.text_color_pick = None;
+            app.ui.status.clear();
+        }
+        if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+            app.ui.text_color_pick = None;
+            app.ui.status.clear();
+        }
+    }
+}
+
+/// A colour picker's eyedropper is armed (its popup stays open): the viewer shows the colour under
+/// the pointer, and the next press on it samples the frame into the picker. The press is read from
+/// the pointer, since a modal dialog over the viewer takes its clicks.
+fn popup_eyedropper(app: &mut EffectcraftApp, ui: &mut egui::Ui, painter: &egui::Painter, map: &crate::panels::viewer::ViewerMap) {
+    let ctx = ui.ctx().clone();
+    if !crate::color_picker::eyedropper_armed(&ctx) {
+        return;
+    }
+    let _ = ui.interact(map.area, egui::Id::unique("viewer-popup-eyedropper"), Sense::click());
+    // The sampling surface, apart from the picker's button that arms it (`colorPicker.eyedropper`).
+    app.auto.add("viewer.colorPickerEyedropper", map.area, "Sample color");
+    ctx.set_cursor_icon(egui::CursorIcon::Crosshair);
+    app.viewer_pixels();
+    color_pick_preview(app, painter, map, crate::i18n::tr("Click to sample color"), crate::color_picker::eyedropper_point(&ctx));
+    if let Some(pos) = crate::color_picker::sample_press(&ctx)
+        && let Some(s) = crate::panels::viewer_tools::sample_displayed(app, &ctx, map.to_comp(pos))
+    {
+        crate::color_picker::deliver_sample(&ctx, [s[0], s[1], s[2]]);
+    }
+}
+
+/// Effect Controls' part of the Composition viewer, called by the viewer after its own
+/// interaction (so these controls sit on top):
+///
+/// - while a crosshair pick is armed, its handle previews the cursor position without editing
+///   the property; the next click sets the point in layer space, and Esc cancels;
+/// - an eyedropper pick samples the frame's colour on click;
+/// - otherwise, the point parameters of the selected effects are drawn as draggable ⊕ controls.
+///
+/// `l2c` is the viewer's layer→comp matrix (it knows the 3D view).
+pub fn viewer_hook(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    painter: &egui::Painter,
+    map: &crate::panels::viewer::ViewerMap,
+    ectx: &EvalCtx,
+    l2c: &dyn Fn(&EvalCtx, &Layer) -> Mat3,
+) {
+    let t = app.tokens;
+    let ctx = ui.ctx().clone();
+    crate::color_picker::note_viewer(&ctx, map.area);
+    let mut actions: Actions = vec![];
+    let point_preview = match fx_pick_session(app, ui, painter, map, ectx, l2c, &mut actions) {
+        ControlFlow::Break(()) => return,
+        ControlFlow::Continue(p) => p,
+    };
+    text_color_pick(app, ui, painter, map, ectx, &mut actions);
+    popup_eyedropper(app, ui, painter, map);
+    let picking = app.ui.fx_pick.is_some() || app.ui.text_color_pick.is_some();
+    let point_pick = app.ui.fx_pick.clone().filter(|p| p.kind == "point");
+    if app.ui.viewer.show_layer_controls || point_pick.is_some() {
+        // ⊕ controls for the point parameters of the selected effects.
+        let mut sel = app.session.state.selected_props.clone();
+        if let Some(pick) = &point_pick {
+            sel.push((effectcraft_engine::project::LayerId(pick.layer), pick.prop));
+        }
+        let selected = app.session.state.selected_layers.clone();
+        for layer in ectx
+            .comp
+            .layers
+            .iter()
+            .filter(|l| (selected.contains(&l.id) || point_pick.as_ref().is_some_and(|p| p.layer == l.id.0)) && l.is_active_at(ectx.time))
+        {
+            let Some(fx) = layer.effects() else { continue };
+            let m = l2c(ectx, layer);
+            // Masks are in layer space, effect points in effect space.
+            let fm = crate::panels::viewer::from_effect_space(ectx, layer, m);
+            let picked_prop = point_pick.as_ref().filter(|p| p.layer == layer.id.0).map(|p| p.prop);
+            for g in fx.groups().filter(|g| g.enabled && effect_active(g, layer.id, &sel)) {
+                // Puppet owns its pin handles and hit testing. Generic crosshairs would
+                // overlap the pins and steal their selection/rotation/scale gestures.
+                if matches!(&g.kind, GroupKind::Effect { effect } if effect == effectcraft_engine::effects::puppet::ID) {
+                    continue;
+                }
+                if !picking
+                    && app.ui.viewer.show_layer_controls
+                    && matches!(&g.kind, GroupKind::Effect { effect } if effect == crate::panels::fx_editors::RESHAPE)
+                {
+                    crate::panels::fx_editors::reshape_overlay(app, ui, painter, map, ectx, layer, g, &m, &mut actions);
+                }
+                if !picking
+                    && app.ui.viewer.show_layer_controls
+                    && matches!(&g.kind, GroupKind::Effect { effect } if effect == crate::panels::fx_editors::MESH_WARP)
+                {
+                    crate::panels::fx_editors::mesh_warp_overlay(app, ui, painter, map, ectx, layer, g, &fm, &mut actions);
+                }
+                let scope = FxScope { effect: &g.match_id, root: g, path: String::new() };
+                let mut pts = Vec::new();
+                visible_points(g, &scope, layer, ectx, 0, &mut pts);
+                // An explicit pick stays visible even when View > Show Layer Controls is off.
+                if !app.ui.viewer.show_layer_controls {
+                    pts.retain(|pr| picked_prop == Some(pr.uid));
+                }
+                let screen: Vec<egui::Pos2> = pts
+                    .iter()
+                    .map(|pr| {
+                        if picked_prop == Some(pr.uid)
+                            && let Some(pos) = point_preview
+                        {
+                            return pos;
+                        }
+                        let v = ectx.value(layer, pr).as_vec2();
+                        map.to_screen(fw::layer_to_comp(&fm, v))
+                    })
+                    .collect();
+                // Gradient Ramp and friends: a guide between start and end points.
+                if screen.len() == 2 && matches!(&g.kind, GroupKind::Effect { effect } if effect.contains("gradient") || effect.contains("ramp")) {
+                    painter.line_segment([screen[0], screen[1]], Stroke::new(1.0, Color32::from_white_alpha(110)));
+                }
+                for (pr, s) in pts.iter().zip(screen) {
+                    let hr = Rect::from_center_size(s, vec2(16.0, 16.0));
+                    let id = egui::Id::unique(("viewer-fx-pt", pr.uid));
+                    // The picker owns the click. Preview handles must not steal it or start a drag.
+                    let resp = (!picking).then(|| ui.interact(hr, id, Sense::drag()));
+                    let col = if picked_prop == Some(pr.uid) || resp.as_ref().is_some_and(|r| r.hovered() || r.dragged()) { t.accent } else { Color32::WHITE };
+                    fw::draw_crosshair(painter, s + vec2(1.0, 1.0), 5.0, Color32::from_black_alpha(160));
+                    fw::draw_crosshair(painter, s, 5.0, col);
+                    app.auto.add(&format!("viewer.effectPoint.{}", pr.uid), hr, &pr.name);
+                    let Some(resp) = resp else { continue };
+                    if resp.hovered() {
+                        ctx.set_cursor_icon(egui::CursorIcon::Move);
+                        resp.clone().on_hover_text(format!("{}: {}", crate::i18n::effects::group(&g.match_id, &g.name), pr.name));
+                    }
+                    if resp.dragged()
+                        && let Some(pos) = resp.interact_pointer_pos()
+                        && let Some(lp) = fw::comp_to_layer(&fm, map.to_comp(pos))
+                    {
+                        let key = gesture_key(ui, id, resp.drag_started());
+                        actions.push(("prop.set".into(), json!({"layer": layer.id.0, "prop": pr.uid, "value": [lp[0], lp[1]], "merge": key})));
+                    }
+                }
+            }
+        }
+    }
+    for (id, params) in actions {
+        if let Err(e) = crate::menus::invoke(app, &ctx, &id, params) {
+            app.ui.status = e;
+        }
+    }
+}
diff --git a/crates/ui-egui/src/panels/effects_presets.rs b/crates/ui-egui/src/panels/effects_presets.rs
index 3e4bd9275..db2e4d83e 100644
--- a/crates/ui-egui/src/panels/effects_presets.rs
+++ b/crates/ui-egui/src/panels/effects_presets.rs
@@ -10,6 +10,7 @@ use egui::{Align2, Color32, Rect, Sense, Stroke, pos2, vec2};
 use serde_json::json;
 use std::sync::Arc;
 
+use crate::a11y;
 use crate::icons::{self, Icon};
 use crate::panels::{DragPayload, PresetRef};
 use crate::theme::Tokens;
@@ -17,6 +18,7 @@ use crate::{EffectcraftApp, widgets};
 
 const ROW_H: f32 = 21.0;
 const RECENT_MAX: usize = 8;
+pub(crate) const REVEAL_PRESETS_ID: &str = "fx-reveal-presets";
 
 /// A user animation preset file.
 #[derive(Clone, Debug, PartialEq)]
@@ -106,12 +108,70 @@ fn highlighted(p: &egui::Painter, pos: egui::Pos2, name: &str, query: &str, t: &
     p.text(pos, Align2::LEFT_CENTER, name, Tokens::ui(12.0), t.text);
 }
 
+#[derive(Clone)]
 enum Apply {
     Effect(String),
     /// A text, built-in (Transitions…) or user file animation preset.
     Preset(PresetRef),
 }
 
+/// One row of the list as drawn this pass, including the rows scrolled out of view: what the
+/// arrow keys, Home / End and Enter work on (the rows are painted by hand, so this is the list).
+struct NavRow {
+    id: egui::Id,
+    /// The favourite star's widget, for an effect row.
+    star: Option<egui::Id>,
+    parent: Option<egui::Id>,
+    /// Where the row starts in the scrolled content.
+    top: f32,
+    /// A folder: (its key, open, forced open by a search).
+    folder: Option<(String, bool, bool)>,
+    /// What Enter applies, for an effect or preset row.
+    apply: Option<Apply>,
+}
+
+/// The list's keyboard state: the rows drawn, and the row the keys work from (the "cursor":
+/// selected, and the one Tab stop of the list).
+struct Nav {
+    rows: Vec<NavRow>,
+    /// The open folders on the way down to the row being drawn, by level.
+    stack: Vec<egui::Id>,
+    cursor: Option<egui::Id>,
+    /// The scroll offset and the list's top, to place rows in the content.
+    offset: f32,
+    list_top: f32,
+}
+
+impl Nav {
+    /// The row `id` is the list's Tab stop: the cursor row, or the first row while there is none.
+    fn tab_stop(&self, id: egui::Id) -> bool {
+        match self.cursor {
+            Some(c) => c == id,
+            None => self.rows.is_empty(),
+        }
+    }
+
+    /// Record the row drawn at `y`; returns whether it is the cursor row.
+    fn push(&mut self, id: egui::Id, y: f32, level: usize, folder: Option<(String, bool, bool)>, apply: Option<Apply>) -> bool {
+        let parent = level.checked_sub(2).and_then(|i| self.stack.get(i)).copied();
+        if folder.is_some() {
+            self.stack.truncate(level.saturating_sub(1));
+            self.stack.push(id);
+        }
+        self.rows.push(NavRow { id, star: None, parent, top: y - self.list_top + self.offset, folder, apply });
+        self.cursor == Some(id)
+    }
+}
+
+fn cursor_id() -> egui::Id {
+    egui::Id::unique("fx-cursor")
+}
+
+/// The accessible name of a folder: what the row shows, in the interface language.
+fn folder_name(label: &str) -> &str {
+    tr(label)
+}
+
 /// A folder row; returns whether it is open.
 #[allow(clippy::too_many_arguments)]
 fn folder_row(
@@ -120,8 +180,10 @@ fn folder_row(
     lp: &egui::Painter,
     list: Rect,
     y: &mut f32,
+    nav: &mut Nav,
     key: &str,
     label: &str,
+    level: usize,
     indent: f32,
     forced_open: bool,
     icon: Option<Icon>,
@@ -129,12 +191,18 @@ fn folder_row(
     let t = app.tokens;
     let open = forced_open || app.ui.effects_open.contains(key);
     let r = Rect::from_min_size(pos2(list.min.x, *y), vec2(list.width(), ROW_H));
+    let id = egui::Id::unique(("fxcat", key));
+    let tab = nav.tab_stop(id);
+    let selected = nav.push(id, *y, level, Some((key.to_string(), open, forced_open)), None);
     *y += ROW_H;
     if r.max.y < list.min.y || r.min.y > list.max.y {
         return open;
     }
-    let resp = ui.interact(r.intersect(list), egui::Id::unique(("fxcat", key)), Sense::click());
-    if resp.hovered() {
+    let shown = folder_name(label);
+    let resp = ui.interact(r.intersect(list), id, if tab { Sense::click() } else { Sense::CLICK });
+    if selected {
+        lp.rect_filled(r, 0.0, t.row_selected);
+    } else if resp.hovered() {
         lp.rect_filled(r, 0.0, t.hover);
     }
     let tw = Rect::from_center_size(pos2(r.min.x + 12.0 + indent, r.center().y), vec2(12.0, 12.0));
@@ -145,18 +213,62 @@ fn folder_row(
         Some(i) => icons::paint(lp, ic, i, t.text_dim),
         None => icons::paint(lp, ic, Icon::Folder, Color32::from_rgb(0xc8, 0xb0, 0x58)),
     }
-    lp.text(pos2(r.min.x + 40.0 + indent, r.center().y), Align2::LEFT_CENTER, label, Tokens::ui(12.0), t.text);
+    lp.text(pos2(r.min.x + 40.0 + indent, r.center().y), Align2::LEFT_CENTER, shown, Tokens::ui(12.0), t.text);
     app.auto.add(&format!("effects.category.{key}"), r, label);
-    if resp.clicked() && !forced_open {
-        if open {
-            app.ui.effects_open.remove(key);
-        } else {
-            app.ui.effects_open.insert(key.to_string());
+    a11y::tree_item(&resp, shown, selected, level, Some(open));
+    row_focus(app, ui, lp, &resp, r, id);
+    if resp.clicked() {
+        nav_click(ui.ctx(), app, id);
+        if !forced_open {
+            if open {
+                app.ui.effects_open.remove(key);
+            } else {
+                app.ui.effects_open.insert(key.to_string());
+            }
         }
     }
     open
 }
 
+/// What every row does with the keyboard focus: the focus ring, the panel taking the focus, the
+/// list owning its keys, and moving the focus here when the arrow keys asked for it.
+fn row_focus(app: &mut EffectcraftApp, ui: &egui::Ui, lp: &egui::Painter, resp: &egui::Response, r: Rect, id: egui::Id) {
+    let ctx = ui.ctx();
+    if a11y::take_pending_focus(ctx, "fx", id) {
+        resp.request_focus();
+    }
+    if resp.gained_focus() {
+        app.ui.focused = crate::dock::PanelKind::EffectsPresets;
+    }
+    if resp.has_focus() {
+        lp.rect_stroke(r.shrink(0.5), 0.0, Stroke::new(1.0, app.tokens.accent), egui::StrokeKind::Inside);
+    }
+}
+
+/// A click on a row moves the cursor there and gives the panel the keyboard.
+fn nav_click(ctx: &egui::Context, app: &mut EffectcraftApp, id: egui::Id) {
+    ctx.data_mut(|d| d.insert_temp(cursor_id(), id));
+    app.ui.focused = crate::dock::PanelKind::EffectsPresets;
+}
+
+/// Number of visible rows before Animation Presets in the current panel state.
+fn rows_before_presets(favorites: usize, recent: usize, searching: bool, favorites_open: bool, recent_open: bool) -> usize {
+    let mut rows = 0usize;
+    if favorites > 0 {
+        rows = rows.saturating_add(1);
+        if searching || favorites_open {
+            rows = rows.saturating_add(favorites);
+        }
+    }
+    if !searching && recent > 0 {
+        rows = rows.saturating_add(1);
+        if recent_open {
+            rows = rows.saturating_add(recent);
+        }
+    }
+    rows
+}
+
 /// An effect row (fx icon, highlighted name, favourite star, 32 bpc badge).
 #[allow(clippy::too_many_arguments)]
 fn effect_row(
@@ -165,7 +277,9 @@ fn effect_row(
     lp: &egui::Painter,
     list: Rect,
     y: &mut f32,
+    nav: &mut Nav,
     e: &'static effectcraft_engine::effects::EffectSpec,
+    level: usize,
     indent: f32,
     query: &str,
     auto_prefix: &str,
@@ -174,13 +288,22 @@ fn effect_row(
     let t = app.tokens;
     let ctx = ui.ctx().clone();
     let r = Rect::from_min_size(pos2(list.min.x, *y), vec2(list.width(), ROW_H));
+    let id = egui::Id::unique((auto_prefix, e.id));
+    let star_id = egui::Id::unique((auto_prefix, e.id, "star"));
+    let tab = nav.tab_stop(id);
+    let selected = nav.push(id, *y, level, None, Some(Apply::Effect(e.id.to_string())));
+    if let Some(row) = nav.rows.last_mut() {
+        row.star = Some(star_id);
+    }
     *y += ROW_H;
     if r.max.y < list.min.y || r.min.y > list.max.y {
         return;
     }
     let star = Rect::from_center_size(pos2(r.max.x - 38.0, r.center().y), vec2(16.0, 16.0));
-    let resp = ui.interact(r.intersect(list), egui::Id::unique((auto_prefix, e.id)), Sense::click_and_drag());
-    if resp.hovered() {
+    let resp = ui.interact(r.intersect(list), id, if tab { Sense::click_and_drag() } else { Sense::CLICK | Sense::DRAG });
+    if selected {
+        lp.rect_filled(r, 0.0, t.row_selected);
+    } else if resp.hovered() {
         lp.rect_filled(r, 0.0, t.hover);
     }
     icons::paint(lp, Rect::from_center_size(pos2(r.min.x + 44.0 + indent, r.center().y), vec2(12.0, 12.0)), Icon::Fx, t.text_dim);
@@ -192,20 +315,32 @@ fn effect_row(
         lp.text(pos2(r.max.x - 10.0, r.center().y), Align2::RIGHT_CENTER, "32", Tokens::ui(9.5), t.text_faint);
     }
     app.auto.add(&format!("{auto_prefix}.{}", e.id), r, e.name);
-    // Favourite star (always shown when starred, else on hover).
+    a11y::tree_item(&resp, &shown, selected, level, None);
+    row_focus(app, ui, lp, &resp, r, id);
+    // Favourite star (always shown when starred, else on hover or with the keyboard focus).
     let fav = app.session.prefs.is_effect_favorite(e.id);
-    let sresp = ui.interact(star.intersect(list), egui::Id::unique((auto_prefix, e.id, "star")), Sense::click());
-    if fav || resp.hovered() || sresp.hovered() {
+    let sresp = ui.interact(star.intersect(list), star_id, if tab { Sense::click() } else { Sense::CLICK });
+    if fav || resp.hovered() || sresp.hovered() || sresp.has_focus() {
         let gold = Color32::from_rgb(0xe8, 0xc0, 0x40);
         filled_star(lp, star.center(), 6.0, fav.then_some(gold), if fav || sresp.hovered() { gold } else { t.text_faint });
     }
     app.auto.add(&format!("{auto_prefix}.{}.star", e.id), star, if fav { "Remove from Favorites" } else { "Add to Favorites" });
+    a11y::button(&sresp, &format!("{}: {shown}", tr(if fav { "Remove from favorites" } else { "Add to favorites" })), true);
+    if sresp.gained_focus() {
+        app.ui.focused = crate::dock::PanelKind::EffectsPresets;
+    }
+    if sresp.has_focus() {
+        widgets::focus_outline(ui, &sresp, &t);
+    }
     if sresp.clicked() {
         // Kept in the settings, so the stars are there next time (#1692).
         app.session.prefs.toggle_effect_favorite(e.id);
         app.session.save_prefs();
         return;
     }
+    if resp.clicked() {
+        nav_click(&ctx, app, id);
+    }
     if resp.double_clicked() {
         *apply = Some(Apply::Effect(e.id.to_string()));
     }
@@ -222,6 +357,7 @@ fn preset_row(
     lp: &egui::Painter,
     list: Rect,
     y: &mut f32,
+    nav: &mut Nav,
     name: &str,
     auto_id: &str,
     query: &str,
@@ -230,17 +366,27 @@ fn preset_row(
 ) {
     let t = app.tokens;
     let r = Rect::from_min_size(pos2(list.min.x, *y), vec2(list.width(), ROW_H));
+    let id = egui::Id::unique(("fxpreset", auto_id));
+    let tab = nav.tab_stop(id);
+    let selected = nav.push(id, *y, 3, None, Some(Apply::Preset(preset.clone())));
     *y += ROW_H;
     if r.max.y < list.min.y || r.min.y > list.max.y {
         return;
     }
-    let resp = ui.interact(r.intersect(list), egui::Id::unique(("fxpreset", auto_id)), Sense::click_and_drag());
-    if resp.hovered() {
+    let resp = ui.interact(r.intersect(list), id, if tab { Sense::click_and_drag() } else { Sense::CLICK | Sense::DRAG });
+    if selected {
+        lp.rect_filled(r, 0.0, t.row_selected);
+    } else if resp.hovered() {
         lp.rect_filled(r, 0.0, t.hover);
     }
     icons::paint(lp, Rect::from_center_size(pos2(r.min.x + 58.0, r.center().y), vec2(12.0, 12.0)), Icon::Keyframe, t.text_dim);
     highlighted(lp, pos2(r.min.x + 70.0, r.center().y), name, query, &t);
     app.auto.add(auto_id, r, name);
+    a11y::tree_item(&resp, name, selected, 3, None);
+    row_focus(app, ui, lp, &resp, r, id);
+    if resp.clicked() {
+        nav_click(ui.ctx(), app, id);
+    }
     if resp.drag_started() {
         egui::DragAndDrop::set_payload(ui.ctx(), DragPayload::Preset { preset: preset.clone(), name: name.to_string() });
     }
@@ -249,6 +395,120 @@ fn preset_row(
     }
 }
 
+/// The list's keys. With a row focused (Tab, a screen reader): Up / Down move between rows,
+/// Home / End go to the first / last, Page Up / Page Down a page, Right opens a folder (then steps
+/// into it) and Left closes it (then steps out to it), Enter and Space apply the row or open /
+/// close the folder. With the mouse's last click in the panel and no widget focused, the arrows
+/// and Enter work the same, so the list is operable without a mouse either way. The focus follows
+/// the cursor, so a screen reader reads each row as it is reached. Returns what to apply.
+fn list_keys(app: &mut EffectcraftApp, ctx: &egui::Context, nav: &Nav, list: Rect) -> Option<Apply> {
+    use egui::Key;
+    // A cursor whose row is gone (a search hid it): the first row is the Tab stop again.
+    if let Some(c) = nav.cursor
+        && !nav.rows.iter().any(|r| r.id == c)
+    {
+        ctx.data_mut(|d| d.remove::<egui::Id>(cursor_id()));
+        ctx.request_repaint();
+    }
+    let focused = ctx.memory(|m| m.focused());
+    let on_row = focused.is_some_and(|f| nav.rows.iter().any(|r| r.id == f || r.star == Some(f)));
+    let by_mouse = focused.is_none() && app.ui.focused == crate::dock::PanelKind::EffectsPresets;
+    if (!on_row && !by_mouse) || app.dialog.is_some() || widgets::any_menu_open(ctx) {
+        return None;
+    }
+    let keys: Vec<Key> = ctx.input(|i| {
+        i.events
+            .iter()
+            .filter_map(|e| match e {
+                egui::Event::Key { key, pressed: true, modifiers, .. } if !modifiers.any() => Some(*key),
+                _ => None,
+            })
+            .collect()
+    });
+    let page = ((list.height() / ROW_H).floor() as usize).saturating_sub(1).max(1);
+    // The row with the keyboard focus is where the keys start (the first Tab lands on a row
+    // before anything is selected); otherwise the cursor.
+    let focus_row = focused.and_then(|f| nav.rows.iter().find(|r| r.id == f || r.star == Some(f))).map(|r| r.id);
+    let mut cursor = focus_row.or_else(|| nav.cursor.filter(|c| nav.rows.iter().any(|r| r.id == *c)));
+    let mut apply = None;
+    let mut moved = false;
+    for key in keys {
+        let at = cursor.and_then(|c| nav.rows.iter().position(|r| r.id == c));
+        let last = nav.rows.len().checked_sub(1)?;
+        let to = match key {
+            Key::ArrowDown => Some(at.map_or(0, |a| a.saturating_add(1).min(last))),
+            Key::ArrowUp => Some(at.map_or(last, |a| a.saturating_sub(1))),
+            Key::Home if on_row => Some(0),
+            Key::End if on_row => Some(last),
+            Key::PageDown if on_row => Some(at.map_or(0, |a| a.saturating_add(page).min(last))),
+            Key::PageUp if on_row => Some(at.map_or(last, |a| a.saturating_sub(page))),
+            Key::ArrowRight | Key::ArrowLeft | Key::Enter | Key::Space if at.is_some() => {
+                let row = at.and_then(|a| nav.rows.get(a))?;
+                let toggle = |app: &mut EffectcraftApp, open: bool| {
+                    if let Some((k, _, forced)) = &row.folder
+                        && !forced
+                    {
+                        if open {
+                            app.ui.effects_open.insert(k.clone());
+                        } else {
+                            app.ui.effects_open.remove(k);
+                        }
+                    }
+                };
+                match (key, &row.folder) {
+                    (Key::ArrowRight, Some((_, false, _))) => {
+                        toggle(app, true);
+                        None
+                    }
+                    (Key::ArrowRight, Some((_, true, _))) => at.map(|a| a.saturating_add(1).min(last)),
+                    (Key::ArrowLeft, Some((_, true, false))) => {
+                        toggle(app, false);
+                        None
+                    }
+                    (Key::ArrowLeft, _) => row.parent.and_then(|p| nav.rows.iter().position(|r| r.id == p)),
+                    (Key::Enter, Some((_, open, _))) | (Key::Space, Some((_, open, _))) if on_row || key == Key::Enter => {
+                        toggle(app, !*open);
+                        None
+                    }
+                    (Key::Enter, None) => {
+                        apply = row.apply.clone();
+                        None
+                    }
+                    (Key::Space, None) if on_row => {
+                        apply = row.apply.clone();
+                        None
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        };
+        if let Some(to) = to
+            && let Some(row) = nav.rows.get(to)
+        {
+            cursor = Some(row.id);
+            moved = true;
+        }
+    }
+    if moved && let Some(c) = cursor {
+        ctx.data_mut(|d| d.insert_temp(cursor_id(), c));
+        // Scroll the row into view.
+        if let Some(row) = nav.rows.iter().find(|r| r.id == c) {
+            widgets::PanelScroll::reveal(ctx, egui::Id::unique("fx-scroll"), row.top, row.top + ROW_H, list.height());
+        }
+        app.ui.focused = crate::dock::PanelKind::EffectsPresets;
+        if on_row {
+            a11y::focus_next_pass(ctx, "fx", c);
+        }
+        ctx.request_repaint();
+    }
+    // The arrows are the list's, not egui's spatial focus moves.
+    if on_row {
+        ctx.memory_mut(|m| m.move_focus(egui::FocusDirection::None));
+    }
+    apply
+}
+
 /// User preset files, rescanned every few seconds (and on Refresh List).
 fn user_presets(ctx: &egui::Context, force: bool, scan: impl FnOnce() -> Vec<PresetFile>) -> Arc<Vec<PresetFile>> {
     let id = egui::Id::unique("fx-user-presets");
@@ -264,25 +524,15 @@ fn user_presets(ctx: &egui::Context, force: bool, scan: impl FnOnce() -> Vec<Pre
     v
 }
 
-pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
-    let t = app.tokens;
-    let ctx = ui.ctx().clone();
-    let p = ui.painter().clone();
-    // Track the last applied effect (menus, drag and drop, the control channel) as recently used.
-    if let Some(last) = app.session.state.last_effect.clone()
-        && app.ui.effects_recent.first() != Some(&last)
-    {
-        push_recent(&mut app.ui.effects_recent, &last);
-    }
-    let sr = Rect::from_min_size(rect.min + vec2(8.0, 8.0), vec2(rect.width() - 44.0, 24.0));
-    let mut q = app.ui.effects_search.clone();
-    widgets::search_field(ui, sr, &mut q, "Search effects and presets", &t);
-    app.ui.effects_search = q.clone();
-    app.auto.add("effects.search", sr, "Search");
+/// The "Effects & Presets options" hamburger menu beside the search field; returns whether
+/// "Refresh List" was picked.
+fn contents_menu(app: &mut EffectcraftApp, ui: &mut egui::Ui, ctx: &egui::Context, rect: Rect, sr: Rect, t: &Tokens) -> bool {
     // Contents menu.
     let mr = Rect::from_center_size(pos2(rect.max.x - 18.0, sr.center().y), vec2(22.0, 22.0));
     let mpop = egui::Id::unique("fx-contents-menu");
-    if widgets::icon_button(ui, mr, Icon::Hamburger, false, &t, egui::Id::unique("fx-menu")).on_hover_text(tr("Effects & Presets options")).clicked() {
+    let menu_resp = widgets::icon_button(ui, mr, Icon::Hamburger, false, t, egui::Id::unique("fx-menu")).on_hover_text(tr("Effects & Presets options"));
+    a11y::menu_button(&menu_resp, tr("Effects & Presets options"), widgets::popup_is_open(ui, mpop));
+    if menu_resp.clicked() {
         widgets::open_popup(ui, mpop);
     }
     app.auto.add("effects.menu", mr, "Effects & Presets options");
@@ -315,6 +565,12 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     ui.separator();
                 } else {
                     let resp = ui.selectable_label(false, label);
+                    // The ✓ and the padding are the menu's drawing: say it as a state.
+                    let checkable = matches!(i, 0 | 1 | 2 | 4 | 6 | 7);
+                    a11y::menu_item(&resp, label.trim_start_matches('✓').trim(), checkable.then(|| label.starts_with('✓')));
+                    if i == 0 {
+                        widgets::focus_when_opened(ui, mpop, &resp);
+                    }
                     if label == &copy_label {
                         app.auto.add("effects.copyPresetsFolderPath", resp.rect, "Copy Presets Folder Path");
                     }
@@ -329,10 +585,13 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         None
     };
     if let Some(i) = choice {
+        if widgets::by_keyboard(ui) {
+            menu_resp.request_focus();
+        }
         let v = &mut app.ui.effects_view;
         match i {
             i if menu.get(i) == Some(&copy_label) => {
-                if let Err(e) = crate::menus::invoke(app, &ctx, "effects.copyPresetsFolderPath", json!({})) {
+                if let Err(e) = crate::menus::invoke(app, ctx, "effects.copyPresetsFolderPath", json!({})) {
                     app.ui.status = e;
                 }
             }
@@ -347,14 +606,43 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             _ => {}
         }
     }
+    force_scan
+}
+
+/// The Effects & Presets panel: search, a contents menu (colour-depth and GPU filters, whether
+/// presets show, categories or one alphabetical list, refresh and clear of the recently used
+/// list), then Favourites, Recently Used, Animation Presets and the effects by category or
+/// alphabetically, filtered by the query. Picking an effect or preset applies it to the selection
+/// (`effect.apply` or the preset's own command); applying an effect also records it as recently
+/// used and opens Effect Controls. Without a selected layer it only reports that in
+/// `app.ui.status`.
+pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let t = app.tokens;
+    let ctx = ui.ctx().clone();
+    let p = ui.painter().clone();
+    // Track the last applied effect (menus, drag and drop, the control channel) as recently used.
+    if let Some(last) = app.session.state.last_effect.clone()
+        && app.ui.effects_recent.first() != Some(&last)
+    {
+        push_recent(&mut app.ui.effects_recent, &last);
+    }
+    let sr = Rect::from_min_size(rect.min + vec2(8.0, 8.0), vec2(rect.width() - 44.0, 24.0));
+    let mut q = app.ui.effects_search.clone();
+    let search_hint = tr("Search effects and presets");
+    let search = widgets::search_field(ui, sr, &mut q, search_hint, &t);
+    a11y::text_input(&search, search_hint, &q);
+    app.ui.effects_search = q.clone();
+    app.auto.add("effects.search", sr, "Search");
+    let force_scan = contents_menu(app, ui, &ctx, rect, sr, &t);
     let view = app.ui.effects_view.clone();
     let list = Rect::from_min_max(pos2(rect.min.x, sr.max.y + 6.0), rect.max);
     let lp = p.with_clip_rect(list);
-    let scroll = widgets::PanelScroll::begin(ui, egui::Id::unique("fx-scroll"), list);
+    let mut scroll = widgets::PanelScroll::begin(ui, egui::Id::unique("fx-scroll"), list);
     let query = q.trim().to_lowercase();
     let searching = !query.is_empty();
     let mut y = list.min.y - scroll.offset;
     let mut apply: Option<Apply> = None;
+    let mut nav = Nav { rows: vec![], stack: vec![], cursor: ctx.data(|d| d.get_temp::<egui::Id>(cursor_id())), offset: scroll.offset, list_top: list.min.y };
     let reg = effectcraft_engine::effects::all();
     let keep = |e: &effectcraft_engine::effects::EffectSpec| {
         depth_keeps(&view.depth, e)
@@ -364,17 +652,27 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
 
     // Favorites and Recently Used.
     let favs: Vec<_> = app.session.prefs.effects_favorites.iter().filter_map(|id| lookup(id)).filter(|e| keep(e)).collect();
-    if !favs.is_empty() && folder_row(app, ui, &lp, list, &mut y, "favorites", "Favorites", 0.0, searching, Some(Icon::Star)) {
+    let recent: Vec<_> = app.ui.effects_recent.iter().filter_map(|id| lookup(id)).filter(|e| keep(e)).collect();
+    let reveal_presets = ctx.data_mut(|data| data.remove_temp::<bool>(egui::Id::unique(REVEAL_PRESETS_ID))).unwrap_or(false);
+    if reveal_presets {
+        // These rows come before Animation Presets. Scroll past expanded lists so the section is
+        // visible even when Favorites or Recently Used is long.
+        let preceding_rows =
+            rows_before_presets(favs.len(), recent.len(), searching, app.ui.effects_open.contains("favorites"), app.ui.effects_open.contains("recent"));
+        scroll.offset = ROW_H * preceding_rows as f32;
+        y = list.min.y - scroll.offset;
+        nav.offset = scroll.offset;
+    }
+    if !favs.is_empty() && folder_row(app, ui, &lp, list, &mut y, &mut nav, "favorites", "Favorites", 1, 0.0, searching, Some(Icon::Star)) {
         let mut favs = favs;
         favs.sort_by_key(|e| e.name);
         for e in favs {
-            effect_row(app, ui, &lp, list, &mut y, e, 0.0, &query, "effects.favorites", &mut apply);
+            effect_row(app, ui, &lp, list, &mut y, &mut nav, e, 2, 0.0, &query, "effects.favorites", &mut apply);
         }
     }
-    let recent: Vec<_> = app.ui.effects_recent.iter().filter_map(|id| lookup(id)).filter(|e| keep(e)).collect();
-    if !recent.is_empty() && !searching && folder_row(app, ui, &lp, list, &mut y, "recent", "Recently Used", 0.0, false, None) {
+    if !recent.is_empty() && !searching && folder_row(app, ui, &lp, list, &mut y, &mut nav, "recent", "Recently Used", 1, 0.0, false, None) {
         for e in recent {
-            effect_row(app, ui, &lp, list, &mut y, e, 0.0, &query, "effects.recent", &mut apply);
+            effect_row(app, ui, &lp, list, &mut y, &mut nav, e, 2, 0.0, &query, "effects.recent", &mut apply);
         }
     }
 
@@ -393,21 +691,45 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         let user = user_presets(&ctx, force_scan, || presets_dir().map(|d| scan_presets(&d)).unwrap_or_default());
         let files: Vec<&PresetFile> = user.iter().filter(|f| query.is_empty() || f.name.to_lowercase().contains(&query)).collect();
         let any = !text.is_empty() || !builtin.is_empty() || !files.is_empty();
-        if any && folder_row(app, ui, &lp, list, &mut y, "presets", "* Animation Presets", 0.0, searching, None) {
-            if !text.is_empty() && folder_row(app, ui, &lp, list, &mut y, "presets/Text", "Text", 14.0, searching, None) {
+        if any && folder_row(app, ui, &lp, list, &mut y, &mut nav, "presets", "* Animation Presets", 1, 0.0, searching, None) {
+            if !text.is_empty() && folder_row(app, ui, &lp, list, &mut y, &mut nav, "presets/Text", "Text", 2, 14.0, searching, None) {
                 for (id, name) in text {
-                    preset_row(app, ui, &lp, list, &mut y, &name, &format!("effects.preset.text.{id}"), &query, PresetRef::Text(id.clone()), &mut apply);
+                    preset_row(
+                        app,
+                        ui,
+                        &lp,
+                        list,
+                        &mut y,
+                        &mut nav,
+                        &name,
+                        &format!("effects.preset.text.{id}"),
+                        &query,
+                        PresetRef::Text(id.clone()),
+                        &mut apply,
+                    );
                 }
             }
             for cat in &categories {
-                if !folder_row(app, ui, &lp, list, &mut y, &format!("presets/{cat}"), cat, 14.0, searching, None) {
+                if !folder_row(app, ui, &lp, list, &mut y, &mut nav, &format!("presets/{cat}"), cat, 2, 14.0, searching, None) {
                     continue;
                 }
                 for (id, name, _) in builtin.iter().filter(|(_, _, c)| c == cat) {
-                    preset_row(app, ui, &lp, list, &mut y, name, &format!("effects.preset.builtin.{id}"), &query, PresetRef::Builtin(id.clone()), &mut apply);
+                    preset_row(
+                        app,
+                        ui,
+                        &lp,
+                        list,
+                        &mut y,
+                        &mut nav,
+                        name,
+                        &format!("effects.preset.builtin.{id}"),
+                        &query,
+                        PresetRef::Builtin(id.clone()),
+                        &mut apply,
+                    );
                 }
             }
-            if !files.is_empty() && folder_row(app, ui, &lp, list, &mut y, "presets/User", "User Presets", 14.0, searching, None) {
+            if !files.is_empty() && folder_row(app, ui, &lp, list, &mut y, &mut nav, "presets/User", "User Presets", 2, 14.0, searching, None) {
                 for f in files {
                     preset_row(
                         app,
@@ -415,6 +737,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                         &lp,
                         list,
                         &mut y,
+                        &mut nav,
                         &f.name,
                         &format!("effects.preset.file.{}", f.name),
                         &query,
@@ -431,23 +754,26 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         let mut all: Vec<_> = reg.iter().filter(|e| keep(e)).collect();
         all.sort_by_key(|e| e.name.to_lowercase());
         for e in all {
-            effect_row(app, ui, &lp, list, &mut y, e, -16.0, &query, "effects.item", &mut apply);
+            effect_row(app, ui, &lp, list, &mut y, &mut nav, e, 1, -16.0, &query, "effects.item", &mut apply);
         }
     } else {
         let mut cats: Vec<&str> = effectcraft_engine::effects::categories();
         cats.retain(|c| reg.iter().any(|e| e.category == *c));
         for cat in cats {
-            let items: Vec<_> = reg.iter().filter(|e| e.category == cat && keep(e)).collect();
+            let mut items: Vec<_> = reg.iter().filter(|e| e.category == cat && keep(e)).collect();
             if items.is_empty() {
                 continue;
             }
+            // After Effects lists a category by the effect's English name, whatever the interface
+            // language draws; the registry's own order is packing order, which reads as random.
+            items.sort_by_key(|e| e.name.to_lowercase());
             // The folder draws the category in the interface language; `cat` stays the key (the
             // open/closed state and the automation id are the registry's English name).
-            if !folder_row(app, ui, &lp, list, &mut y, cat, &crate::i18n::effects::category(cat), 0.0, searching, None) {
+            if !folder_row(app, ui, &lp, list, &mut y, &mut nav, cat, &crate::i18n::effects::category(cat), 1, 0.0, searching, None) {
                 continue;
             }
             for e in items {
-                effect_row(app, ui, &lp, list, &mut y, e, 0.0, &query, "effects.item", &mut apply);
+                effect_row(app, ui, &lp, list, &mut y, &mut nav, e, 2, 0.0, &query, "effects.item", &mut apply);
             }
         }
     }
@@ -456,6 +782,9 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     let content = y + scroll.offset - list.min.y;
     scroll.end(ui, &mut app.auto, "effects.scroll", content, &t);
+    if let Some(a) = list_keys(app, &ctx, &nav, list) {
+        apply = Some(a);
+    }
     if let Some(name) = egui::DragAndDrop::payload::<DragPayload>(&ctx).and_then(|p| match p.as_ref() {
         DragPayload::Effect(id) => Some(effectcraft_engine::effects::find(id).map(|e| crate::i18n::effects::name(e.id, e.name)).unwrap_or_default()),
         DragPayload::Preset { name, .. } => Some(name.clone()),
diff --git a/crates/ui-egui/src/panels/essential.rs b/crates/ui-egui/src/panels/essential.rs
index 19fba3358..02e077508 100644
--- a/crates/ui-egui/src/panels/essential.rs
+++ b/crates/ui-egui/src/panels/essential.rs
@@ -56,6 +56,11 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
 }
 
+/// The Essential Graphics panel's contents for the Primary (else active) comp: its name and Solo
+/// toggle, the template name, the controls list with its drop target for Timeline properties, the
+/// Add Formatting / Add Selected As / Media Replacement / Export Template buttons and the selected
+/// instance's properties. Returns the `essential.*` commands to run directly and the ones that go
+/// through the menu/frontend layer; with no comp it shows a hint and returns empty lists.
 fn body(app: &mut EffectcraftApp, ui: &mut egui::Ui) -> (Actions, Actions) {
     let t = app.tokens;
     let ctx = ui.ctx().clone();
@@ -71,7 +76,7 @@ fn body(app: &mut EffectcraftApp, ui: &mut egui::Ui) -> (Actions, Actions) {
     // ---- Primary + Solo.
     ui.horizontal(|ui| {
         ui.label(RichText::new(tr("Primary:")).color(t.text_dim));
-        let r = egui::ComboBox::from_id_salt("eg-primary").selected_text(&comp_name).width(150.0).show_ui(ui, |ui| {
+        let r = craft_ui::ComboBox::from_id_salt("eg-primary").selected_text(&comp_name).width(150.0).show_ui(ui, |ui| {
             for (id, _) in project.comps() {
                 let name = project.item(*id).map(|i| i.name.clone()).unwrap_or_default();
                 if ui.selectable_label(*id == cid, name).clicked() {
@@ -357,7 +362,7 @@ fn value_widget(app: &mut EffectcraftApp, ui: &mut egui::Ui, auto: &str, ty: Opt
         }
         ControlType::Checkbox => {
             let mut on = v.as_bool();
-            let r = ui.checkbox(&mut on, "");
+            let r = crate::widgets::labelled_checkbox(ui, &mut on, "");
             if r.changed() {
                 out = Some(json!(on));
             }
@@ -369,7 +374,7 @@ fn value_widget(app: &mut EffectcraftApp, ui: &mut egui::Ui, auto: &str, ty: Opt
                 _ => vec![],
             };
             let cur = v.as_enum() as usize;
-            let r = egui::ComboBox::from_id_salt(("eg-dd", auto)).selected_text(opts.get(cur).cloned().unwrap_or_default()).show_ui(ui, |ui| {
+            let r = craft_ui::ComboBox::from_id_salt(("eg-dd", auto)).selected_text(opts.get(cur).cloned().unwrap_or_default()).show_ui(ui, |ui| {
                 for (i, o) in opts.iter().enumerate() {
                     if ui.selectable_label(i == cur, o).clicked() {
                         out = Some(json!(i));
@@ -432,7 +437,7 @@ fn value_widget(app: &mut EffectcraftApp, ui: &mut egui::Ui, auto: &str, ty: Opt
             let fams = effectcraft_engine::text::fonts::families();
             let mut d = (**doc).clone();
             let mut changed = false;
-            let r1 = egui::ComboBox::from_id_salt(("eg-font", auto)).selected_text(&d.font).width(110.0).show_ui(ui, |ui| {
+            let r1 = craft_ui::ComboBox::from_id_salt(("eg-font", auto)).selected_text(&d.font).width(110.0).show_ui(ui, |ui| {
                 for (f, _) in &fams {
                     if ui.selectable_label(*f == d.font, f).clicked() {
                         d.font = f.clone();
@@ -441,7 +446,7 @@ fn value_widget(app: &mut EffectcraftApp, ui: &mut egui::Ui, auto: &str, ty: Opt
                 }
             });
             let styles: Vec<String> = fams.iter().find(|(f, _)| *f == d.font).map(|(_, st)| st.clone()).unwrap_or_default();
-            let r2 = egui::ComboBox::from_id_salt(("eg-style", auto)).selected_text(&d.style).width(70.0).show_ui(ui, |ui| {
+            let r2 = craft_ui::ComboBox::from_id_salt(("eg-style", auto)).selected_text(&d.style).width(70.0).show_ui(ui, |ui| {
                 for st in &styles {
                     if ui.selectable_label(*st == d.style, st).clicked() {
                         d.style = st.clone();
@@ -527,7 +532,7 @@ fn instance(app: &mut EffectcraftApp, ui: &mut egui::Ui, actions: &mut Actions)
                         .filter(|i| matches!(&i.kind, ItemKind::Footage(f) if f.has_video))
                         .map(|i| (i.id, i.name.clone()))
                         .collect();
-                    let r = egui::ComboBox::from_id_salt(("eg-media", layer.id.0, c.id)).selected_text(cur_name).show_ui(ui, |ui| {
+                    let r = craft_ui::ComboBox::from_id_salt(("eg-media", layer.id.0, c.id)).selected_text(cur_name).show_ui(ui, |ui| {
                         for (id, name) in &items {
                             if ui.selectable_label(*id == cur, name).clicked() {
                                 actions.push(("essential.set".into(), json!({"layer": layer.id.0, "control": c.id, "item": id.0})));
diff --git a/crates/ui-egui/src/panels/expr_bar.rs b/crates/ui-egui/src/panels/expr_bar.rs
index e40d0a2d0..ce098efa0 100644
--- a/crates/ui-egui/src/panels/expr_bar.rs
+++ b/crates/ui-egui/src/panels/expr_bar.rs
@@ -23,6 +23,8 @@ struct Cache {
     current: usize,
 }
 
+/// The `egui::Id` under which the error bar's cache for composition `cid` is kept: this pass's
+/// failing expressions and which one is shown.
 fn cache_id(cid: ItemId) -> egui::Id {
     egui::Id::unique(("expr-error-bar", cid.0))
 }
@@ -46,6 +48,11 @@ pub fn height(app: &mut EffectcraftApp, ctx: &egui::Context, cid: ItemId) -> f32
     if errors(app, ctx, cid).errors.is_empty() { 0.0 } else { HEIGHT }
 }
 
+/// Draws the expression error strip for composition `cid` in `rect`: a warning, the shown error's
+/// description and ◀ n/m ▶ buttons to step through the failing expressions. Clicking the message
+/// selects that layer and property, reveals it in the Timeline and opens its expression. Does
+/// nothing when every expression evaluates. Stepping and clicking only change UI state (the
+/// cached index, selection and Timeline state), never the document.
 pub fn draw(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect, cid: ItemId) {
     let t = app.tokens;
     let ctx = ui.ctx().clone();
diff --git a/crates/ui-egui/src/panels/expr_editor.rs b/crates/ui-egui/src/panels/expr_editor.rs
index f342d5636..6d742dc4e 100644
--- a/crates/ui-egui/src/panels/expr_editor.rs
+++ b/crates/ui-egui/src/panels/expr_editor.rs
@@ -111,6 +111,7 @@ pub const COMPLETIONS: &[&str] = &[
     "ease",
     "easeIn",
     "easeOut",
+    "bezier",
     "clamp",
     "random",
     "gaussRandom",
@@ -331,8 +332,16 @@ fn layout(text: &str, font: FontId, base: Color32, sx: &Syntax, p: &Scripting, b
     job
 }
 
+/// The scripting preferences, text colour and row count an [`editor`] is drawn with.
+pub struct EditorOpts<'a> {
+    pub prefs: &'a Scripting,
+    pub color: Color32,
+    pub rows: usize,
+}
+
 /// The editor: returns the response; `buf` is edited in place.
-pub fn editor(ui: &mut egui::Ui, id: egui::Id, buf: &mut String, rect: Rect, p: &Scripting, color: Color32, rows: usize, t: &Tokens) -> egui::Response {
+pub fn editor(ui: &mut egui::Ui, id: egui::Id, buf: &mut String, rect: Rect, opts: EditorOpts, t: &Tokens) -> egui::Response {
+    let EditorOpts { prefs: p, color, rows } = opts;
     let size = (p.editor_font_size.clamp(8, 40) as f32) * 0.9;
     let font = Tokens::mono(size);
     // Line numbers in a gutter on the left.
diff --git a/crates/ui-egui/src/panels/flowchart.rs b/crates/ui-egui/src/panels/flowchart.rs
index c7019492f..89cc3493e 100644
--- a/crates/ui-egui/src/panels/flowchart.rs
+++ b/crates/ui-egui/src/panels/flowchart.rs
@@ -250,7 +250,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let p = ui.painter().with_clip_rect(rect);
     p.rect_filled(rect, 0.0, t.tl_bg);
     let Some(rid) = root(app) else {
-        p.text(rect.center(), Align2::CENTER_CENTER, "(no composition)", Tokens::ui(12.0), t.text_faint);
+        p.text(rect.center(), Align2::CENTER_CENTER, crate::i18n::tr("(no composition)"), Tokens::ui(12.0), t.text_faint);
         return;
     };
     // ---- toolbar: switches and direction.
diff --git a/crates/ui-egui/src/panels/footage_panel.rs b/crates/ui-egui/src/panels/footage_panel.rs
index 31d9beeda..ef6458475 100644
--- a/crates/ui-egui/src/panels/footage_panel.rs
+++ b/crates/ui-egui/src/panels/footage_panel.rs
@@ -1,7 +1,8 @@
 //! The Footage panel (double-click footage in the Project panel): the source on its own time
 //! ruler, play / pause, In and Out marks, and the Edit Target buttons — Overlay Edit and Ripple
 //! Insert Edit — that cut the marked range into the active composition at its current time.
-//! Everything runs `footage.*` commands (state in `EditorState::footage_panel`).
+//! Time, marks and edits run `footage.*` commands (state in `EditorState::footage_panel`);
+//! the Play/Pause flag is local egui state.
 
 use crate::i18n::{tr, tr_args};
 use effectcraft_engine::project::{FootageKind, ItemKind};
@@ -13,6 +14,11 @@ use super::panel_kit as kit;
 use crate::EffectcraftApp;
 use crate::theme::Tokens;
 
+/// The Footage panel for the item opened into it: the frame at the panel's current time (cached
+/// per item, time and session revision), a ruler with the in/out span and CTI that scrubs on click
+/// or drag, Play/Pause, set In/Out, and Ripple Insert / Overlay Edit into the active comp. A solid
+/// shows its colour, footage without video says so, and an empty panel explains how to open one.
+/// Time changes run `footage.*` commands; the panel's Play/Pause flag is local egui state.
 pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let ctx = ui.ctx().clone();
@@ -62,7 +68,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         let cached: Option<((u64, i64, u64), egui::TextureHandle, [u32; 2])> = ctx.data(|d| d.get_temp(tid));
         let tex = match cached {
             Some((k, tex, size)) if k == key => Some((tex, size)),
-            _ => app.session.footage.frame(view.item, f, view.time).map(|img| {
+            _ => effectcraft_engine::commands::footage_panel::frame(&app.session, view.item, f, view.time).map(|img| {
                 let ci = egui::ColorImage::from_rgba_unmultiplied([img.width as usize, img.height as usize], &img.to_rgba8());
                 let tex = crate::frames::load_fitted(&ctx, "footage-panel", ci, egui::TextureOptions::LINEAR);
                 ctx.data_mut(|d| d.insert_temp(tid, (key, tex.clone(), [img.width, img.height])));
diff --git a/crates/ui-egui/src/panels/forms.rs b/crates/ui-egui/src/panels/forms.rs
index 942bd9fe0..65d825b45 100644
--- a/crates/ui-egui/src/panels/forms.rs
+++ b/crates/ui-egui/src/panels/forms.rs
@@ -152,7 +152,7 @@ fn is_pdf(p: &Value) -> bool {
 }
 
 /// File ▸ Import ▸ File… picked numbered stills that import as image sequences: ask, as After
-/// Effects' "<format> Sequence" checkbox in its Import dialog does (rfd's native dialog can't
+/// Effects' `<format> Sequence` checkbox in its Import dialog does (rfd's native dialog can't
 /// carry a checkbox), with Force Alphabetical Order and the frame rate. `p`: the import's
 /// parameters. Returns whether the dialog opened. The checkbox starts off, as in After Effects:
 /// unticked, the picked files import as stills. Dropped files and agents' `file.import` don't
@@ -206,6 +206,304 @@ fn value_fields(name: &str, v: &effectcraft_engine::keyframe::Value) -> Option<V
     })
 }
 
+/// The New Composition from Selection dialog's title and fields.
+fn new_comp_from_selection_form(s: &effectcraft_engine::Session) -> (String, Vec<Field>) {
+    let names: Vec<(String, Value)> =
+        s.state.project_selection.iter().enumerate().filter_map(|(i, id)| s.project.item(*id).map(|it| (it.name.clone(), json!(i)))).collect();
+    let names: Vec<(&str, Value)> = names.iter().map(|(n, v)| (n.as_str(), v.clone())).collect();
+    let still = if s.prefs.import.still_footage == "seconds" { s.prefs.import.still_seconds } else { 10.0 };
+    (
+        "New Composition from Selection".into(),
+        vec![
+            Field::choice("single", "Create", &[("Single Composition", json!(true)), ("Multiple Compositions", json!(false))], 0),
+            Field::choice("dimensionsFrom", "Use Dimensions From", &names, 0),
+            Field::num("duration", "Still Duration (seconds)", still),
+            Field::bool("addToRenderQueue", "Add to Render Queue", false),
+            Field::bool("sequence", "Sequence Layers", false),
+            Field::bool("overlap", "Overlap", false),
+            Field::num("overlapDuration", "Duration (seconds)", 1.0),
+            Field::choice(
+                "transition",
+                "Transition",
+                &[("Off", json!("off")), ("Dissolve Front Layer", json!("dissolveFront")), ("Cross Dissolve Front and Back Layers", json!("crossDissolve"))],
+                0,
+            ),
+        ],
+    )
+}
+
+/// The Interpret Footage dialog for the selected footage (or its proxy), if there is one.
+fn interpret_footage_form(s: &effectcraft_engine::Session, proxy: bool, base: &mut Value) -> Option<(String, Vec<Field>)> {
+    let f = s.state.project_selection.first().and_then(|i| s.project.item(*i)).and_then(|it| match (&it.kind, &it.proxy) {
+        (_, Some(px)) if proxy => Some(px.footage.clone()),
+        (effectcraft_engine::project::ItemKind::Footage(f), _) if !proxy => Some(f.clone()),
+        _ => None,
+    });
+    let f = f?;
+    let hex = |c: [f32; 3]| format!("#{:02x}{:02x}{:02x}", (c[0] * 255.0).round() as u8, (c[1] * 255.0).round() as u8, (c[2] * 255.0).round() as u8);
+    let mut fields = vec![
+        // Main Options ▸ Alpha.
+        Field::choice(
+            "alpha",
+            "Alpha",
+            &[
+                ("Interpret Straight - Unmatted", json!("straight")),
+                ("Interpret Premultiplied - Matted With Color", json!("premultiplied")),
+                ("Ignore", json!("ignore")),
+                ("Guess", json!("guess")),
+            ],
+            f.alpha as usize,
+        ),
+        Field::text("matteColor", "Matte color (premultiplied)", &hex(f.premul_color)),
+        Field::bool("invertAlpha", "Invert Alpha", f.invert_alpha),
+        // Main Options ▸ Frame Rate, Fields and Pulldown, Other Options.
+        Field::num("frameRate", "Assume this frame rate", f.frame_rate.as_f64()),
+        Field::choice(
+            "fields",
+            "Separate Fields",
+            &[("Off", json!("off")), ("Upper Field First", json!("upper")), ("Lower Field First", json!("lower"))],
+            f.fields as usize,
+        ),
+        Field::num("pixelAspect", "Pixel Aspect Ratio", f.pixel_aspect),
+        Field::num("loop", "Loop (times)", f.loop_count as f64),
+        // Color.
+        Field::choice(
+            "colorProfile",
+            "Assign Profile",
+            &[
+                ("Embedded / sRGB", json!("auto")),
+                ("sRGB IEC61966-2.1", json!("srgb")),
+                ("HDTV (Rec. 709)", json!("rec709")),
+                ("Rec. 2020", json!("rec2020")),
+                ("Display P3", json!("p3")),
+                ("ACEScg", json!("acescg")),
+                ("ACES2065-1", json!("aces2065")),
+                ("Rec. 2100 PQ", json!("rec2100pq")),
+                ("Rec. 2100 HLG", json!("rec2100hlg")),
+            ],
+            f.color_profile.map_or(0, |c| 1 + effectcraft_engine::project::ColorSpace::ALL.iter().position(|x| *x == c).unwrap_or(0)),
+        ),
+        Field::bool("preserveRgb", "Preserve RGB", f.preserve_rgb),
+        Field::bool("linearLight", "Interpret As Linear Light", f.linear_light),
+    ];
+    // Color ▸ Cineon Settings (DPX and Cineon files). The converted points show in the
+    // footage's Units, and `pointUnits` reads them back in those units when Units changes.
+    if f.is_cineon_file() {
+        use effectcraft_engine::project::CineonUnits;
+        let c = f.cineon;
+        let units: Vec<(&str, Value)> = CineonUnits::ALL.iter().map(|u| (u.label(), json!(u.id()))).collect();
+        fields.extend([
+            Field::note("cineonSettings", "Cineon Settings"),
+            Field::bool("logConversion", "Logarithmic Conversion", c.log_conversion),
+            Field::num("convertedBlack", "Converted Black Point", c.units.from_ten_bit(f64::from(c.converted_black))),
+            Field::num("convertedWhite", "Converted White Point", c.units.from_ten_bit(f64::from(c.converted_white))),
+            Field::num("tenBitBlack", "10 Bit Black Point", f64::from(c.black)),
+            Field::num("tenBitWhite", "10 Bit White Point", f64::from(c.white)),
+            Field::num("currentGamma", "Current Gamma", f64::from(c.gamma)),
+            Field::num("highlightRolloff", "Highlight Rolloff", f64::from(c.rolloff)),
+            Field::choice("cineonUnits", "Units", &units, CineonUnits::ALL.iter().position(|u| *u == c.units).unwrap_or(0)),
+        ]);
+        if !base.is_object() {
+            *base = json!({});
+        }
+        if let Some(m) = base.as_object_mut() {
+            m.insert("pointUnits".into(), json!(c.units.id()));
+        }
+    }
+    // After Frame Rate: an image sequence's frames (missing ones show colour bars, as in
+    // After Effects), then Start Timecode.
+    let mut timing = Vec::new();
+    if f.kind == effectcraft_engine::project::FootageKind::Sequence {
+        let gaps = match effectcraft_engine::sequence::missing_report(&f.sequence) {
+            _ if f.alphabetical => "files in alphabetical order".into(),
+            Some(gaps) => format!("{gaps} shown as color bars"),
+            None => "no missing frames".into(),
+        };
+        timing.push(Field::note("sequenceInfo", &format!("Image sequence: {} files, {} frames; {gaps}.", f.sequence.len(), f.sequence_frames())));
+    }
+    if f.kind != effectcraft_engine::project::FootageKind::Still {
+        timing.push(Field::choice(
+            "overrideStart",
+            "Start Timecode",
+            &[("Use Source File Timecode", json!(false)), ("Override Start", json!(true))],
+            usize::from(f.start_timecode.is_some()),
+        ));
+        timing.push(Field::text("startTimecode", "Override Start", &f.timecode(0)));
+    }
+    let at = fields.iter().position(|x| x.key == "frameRate").map_or(fields.len(), |i| i + 1);
+    fields.splice(at..at, timing);
+    Some((if proxy { "Interpret Footage: Proxy".into() } else { "Interpret Footage".into() }, fields))
+}
+
+/// The Project Settings dialog's title and fields.
+fn project_settings_form(s: &effectcraft_engine::Session) -> (String, Vec<Field>) {
+    let st = &s.project.settings;
+    // The catalogue row is `Mercury GPU Acceleration ({})`, so the value goes through
+    // tr_args: wrapping the assembled string in tr() would look up the backend's name.
+    let gpu_label = match &s.accel {
+        Some(a) => tr_args("Mercury GPU Acceleration ({})", &[&a.name()]),
+        None => tr("Mercury GPU Acceleration (no GPU: software)").to_string(),
+    };
+    let depth = match st.bit_depth.label() {
+        l if l.starts_with("16") => 1,
+        l if l.starts_with("32") => 2,
+        _ => 0,
+    };
+    (
+        "Project Settings".into(),
+        vec![
+            Field::choice(
+                "bitDepth",
+                "Depth",
+                &[("8 bits per channel", json!(8)), ("16 bits per channel", json!(16)), ("32 bits per channel (float)", json!(32))],
+                depth,
+            ),
+            Field::choice(
+                "timeDisplay",
+                "Time display style",
+                &[
+                    ("Timecode", json!("timecode")),
+                    ("Frames", json!("frames")),
+                    ("Feet + Frames (35mm)", json!("feet35")),
+                    ("Feet + Frames (16mm)", json!("feet16")),
+                ],
+                {
+                    use effectcraft_engine::project::TimeDisplayStyle as T;
+                    match st.time_display {
+                        T::Timecode => 0,
+                        T::Frames => 1,
+                        T::Feet35 => 2,
+                        T::Feet16 => 3,
+                    }
+                },
+            ),
+            // Time Display Style ▸ Frames ▸ Frame Count (also numbers Feet + Frames).
+            Field::choice("frameStart", "Frame count", &[("Start at 0", json!(0)), ("Start at 1", json!(1))], usize::from(st.frame_start == 1)),
+            Field::choice(
+                "colorEngine",
+                "Color engine",
+                &[("Adobe-style built-in", json!("adobe")), ("OCIO (built-in ACES config)", json!("ocio"))],
+                usize::from(st.color_engine == effectcraft_engine::project::ColorEngine::Ocio),
+            ),
+            Field::choice(
+                "workingSpace",
+                "Working space",
+                &[
+                    ("None", json!("none")),
+                    ("sRGB IEC61966-2.1", json!("srgb")),
+                    ("HDTV (Rec. 709)", json!("rec709")),
+                    ("Rec. 2020", json!("rec2020")),
+                    ("Display P3", json!("p3")),
+                    ("ACEScg", json!("acescg")),
+                    ("ACES2065-1", json!("aces2065")),
+                ],
+                st.working_space.map_or(0, |c| 1 + effectcraft_engine::project::ColorSpace::WORKING.iter().position(|x| *x == c).unwrap_or(0)),
+            ),
+            // With Working Space None (After Effects' Working Gamma, 2.2 or 2.4).
+            Field::choice("workingGamma", "Working gamma", &[("2.2", json!(2.2)), ("2.4", json!(2.4))], usize::from(st.working_gamma_24())),
+            Field::bool("linearize", "Linearize working space", st.linearize),
+            Field::bool("blendLinear", "Blend colors using 1.0 gamma", st.blend_linear),
+            Field::choice(
+                "hdr",
+                "HDR on SDR displays and outputs",
+                &[("Clip", json!("clip")), ("Compand", json!("compand")), ("Tone map", json!("toneMap"))],
+                st.hdr as usize,
+            ),
+            Field::choice(
+                "outputSpace",
+                "Output color space",
+                &[
+                    ("sRGB IEC61966-2.1 (default)", json!("default")),
+                    ("HDTV (Rec. 709)", json!("rec709")),
+                    ("Rec. 2020", json!("rec2020")),
+                    ("Display P3", json!("p3")),
+                    ("Rec. 2100 PQ (HDR)", json!("rec2100pq")),
+                    ("Rec. 2100 HLG (HDR)", json!("rec2100hlg")),
+                ],
+                {
+                    use effectcraft_engine::project::ColorSpace as C;
+                    match st.output_space {
+                        Some(C::Rec709) => 1,
+                        Some(C::Rec2020) => 2,
+                        Some(C::DisplayP3) => 3,
+                        Some(C::Rec2100Pq) => 4,
+                        Some(C::Rec2100Hlg) => 5,
+                        _ => 0,
+                    }
+                },
+            ),
+            // Video Rendering and Effects ▸ Use.
+            Field::choice(
+                "renderer",
+                "Video rendering and effects",
+                &[(gpu_label.as_str(), json!("gpu")), ("Mercury Software Only", json!("software"))],
+                usize::from(!st.gpu_acceleration),
+            ),
+        ],
+    )
+}
+
+/// The Export Adobe Premiere Pro Project dialog's title and fields.
+fn export_timeline_form(s: &effectcraft_engine::Session) -> (String, Vec<Field>) {
+    let name = s.active_comp_id().and_then(|c| s.project.item(c)).map(|i| i.name.clone()).unwrap_or_else(|| "Composition".into());
+    let dir = s.path.as_deref().and_then(|p| std::path::Path::new(p).parent()).map(|d| d.to_path_buf()).unwrap_or_default();
+    let path = dir.join(format!("{name}.xml")).to_string_lossy().to_string();
+    (
+        "Export Adobe Premiere Pro Project".into(),
+        vec![
+            Field::note("note", "Writes Final Cut Pro XML (.xml), which Premiere Pro opens with File ▸ Import. Native .prproj files are not written."),
+            Field::save_path("path", "File", &path),
+            Field::choice(
+                "format",
+                "Format",
+                &[
+                    ("Final Cut Pro XML (.xml) – Premiere Pro", json!("xml")),
+                    ("FCPXML (.fcpxml)", json!("fcpxml")),
+                    ("OpenTimelineIO (.otio)", json!("otio")),
+                    ("CMX 3600 EDL (.edl, V1 only)", json!("edl")),
+                    ("AAF (.aaf)", json!("aaf")),
+                    ("OMF (.omf, audio)", json!("omf")),
+                ],
+                0,
+            ),
+            Field::choice(
+                "prerender",
+                "Pre-render (ProRes 4444)",
+                &[
+                    ("Layers Premiere can't show (text, shapes, effects…)", json!("unsupported")),
+                    ("All layers", json!("all")),
+                    ("None (leave them out)", json!("none")),
+                ],
+                0,
+            ),
+            Field::choice("precomps", "Precomps", &[("Nested sequences", json!("nest")), ("Pre-render", json!("prerender"))], 0),
+        ],
+    )
+}
+
+/// The Layer ▸ Transform value dialog for the property named by `p` (default Position).
+fn transform_form(p: &Value, layer: Option<&effectcraft_engine::project::Layer>, lt: effectcraft_engine::time::Tick) -> (String, Vec<Field>) {
+    let prop = p.get("prop").and_then(Value::as_str).unwrap_or("position");
+    let cur = layer.and_then(|l| l.transform()).and_then(|tr| tr.get(if prop == "anchorPoint" { "anchor" } else { prop })).map(|pr| pr.value_at(lt));
+    let v = cur.map(|c| c.as_vec3()).unwrap_or([0.0; 3]);
+    let three = layer.is_some_and(|l| l.is_3d());
+    let title = match prop {
+        "anchor" => "Anchor Point",
+        "position" => "Position",
+        "scale" => "Scale",
+        "orientation" => "Orientation",
+        "rotation" => "Rotation",
+        _ => "Opacity",
+    };
+    let fields = match prop {
+        "rotation" | "opacity" => vec![Field::num("value", if prop == "rotation" { "Degrees" } else { "Opacity (%)" }, v[0])],
+        "orientation" => vec![Field::num("value[0]", "X", v[0]), Field::num("value[1]", "Y", v[1]), Field::num("value[2]", "Z", v[2])],
+        _ if three => vec![Field::num("value[0]", "X", v[0]), Field::num("value[1]", "Y", v[1]), Field::num("value[2]", "Z", v[2])],
+        _ => vec![Field::num("value[0]", "X", v[0]), Field::num("value[1]", "Y", v[1])],
+    };
+    (title.into(), fields)
+}
+
 /// If `id` is a dialog command invoked without its parameters, open its form and return true.
 pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
     let s = &app.session;
@@ -213,7 +511,7 @@ pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
     let layer = comp.and_then(|c| s.state.selected_layers.first().and_then(|l| c.layer(*l)));
     let t = s.time();
     let lt = layer.map(|l| l.layer_time(t)).unwrap_or(t);
-    let base = p.clone();
+    let mut base = p.clone();
     let (title, fields): (String, Vec<Field>) = match id {
         // Photoshop files: Import Kind (Footage / Composition / – Retain Layer Sizes). Dropped
         // files start at Settings ▸ Import ▸ Default Drag Import As.
@@ -281,27 +579,7 @@ pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
             let Some(fields) = value_fields(&pr.name, &pr.value_at(l.layer_time(t))) else { return false };
             (pr.name.clone(), fields)
         }
-        "layer.setTransform" if !has(p, &["value"]) => {
-            let prop = p.get("prop").and_then(Value::as_str).unwrap_or("position");
-            let cur = layer.and_then(|l| l.transform()).and_then(|tr| tr.get(if prop == "anchorPoint" { "anchor" } else { prop })).map(|pr| pr.value_at(lt));
-            let v = cur.map(|c| c.as_vec3()).unwrap_or([0.0; 3]);
-            let three = layer.is_some_and(|l| l.is_3d());
-            let title = match prop {
-                "anchor" => "Anchor Point",
-                "position" => "Position",
-                "scale" => "Scale",
-                "orientation" => "Orientation",
-                "rotation" => "Rotation",
-                _ => "Opacity",
-            };
-            let fields = match prop {
-                "rotation" | "opacity" => vec![Field::num("value", if prop == "rotation" { "Degrees" } else { "Opacity (%)" }, v[0])],
-                "orientation" => vec![Field::num("value[0]", "X", v[0]), Field::num("value[1]", "Y", v[1]), Field::num("value[2]", "Z", v[2])],
-                _ if three => vec![Field::num("value[0]", "X", v[0]), Field::num("value[1]", "Y", v[1]), Field::num("value[2]", "Z", v[2])],
-                _ => vec![Field::num("value[0]", "X", v[0]), Field::num("value[1]", "Y", v[1])],
-            };
-            (title.into(), fields)
-        }
+        "layer.setTransform" if !has(p, &["value"]) => transform_form(p, layer, lt),
         "path.freeTransform" if !has(p, &["scale", "rotation", "offset"]) => (
             "Free Transform Points".into(),
             vec![
@@ -377,32 +655,7 @@ pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
         "file.newCompFromSelection"
             if s.state.project_selection.len() > 1 && !has(p, &["single", "dimensionsFrom", "duration", "sequence", "addToRenderQueue"]) =>
         {
-            let names: Vec<(String, Value)> =
-                s.state.project_selection.iter().enumerate().filter_map(|(i, id)| s.project.item(*id).map(|it| (it.name.clone(), json!(i)))).collect();
-            let names: Vec<(&str, Value)> = names.iter().map(|(n, v)| (n.as_str(), v.clone())).collect();
-            let still = if s.prefs.import.still_footage == "seconds" { s.prefs.import.still_seconds } else { 10.0 };
-            (
-                "New Composition from Selection".into(),
-                vec![
-                    Field::choice("single", "Create", &[("Single Composition", json!(true)), ("Multiple Compositions", json!(false))], 0),
-                    Field::choice("dimensionsFrom", "Use Dimensions From", &names, 0),
-                    Field::num("duration", "Still Duration (seconds)", still),
-                    Field::bool("addToRenderQueue", "Add to Render Queue", false),
-                    Field::bool("sequence", "Sequence Layers", false),
-                    Field::bool("overlap", "Overlap", false),
-                    Field::num("overlapDuration", "Duration (seconds)", 1.0),
-                    Field::choice(
-                        "transition",
-                        "Transition",
-                        &[
-                            ("Off", json!("off")),
-                            ("Dissolve Front Layer", json!("dissolveFront")),
-                            ("Cross Dissolve Front and Back Layers", json!("crossDissolve")),
-                        ],
-                        0,
-                    ),
-                ],
-            )
+            new_comp_from_selection_form(s)
         }
         "layer.sequence" if !has(p, &["overlap"]) => (
             "Sequence Layers".into(),
@@ -422,191 +675,36 @@ pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
             ],
         ),
         "file.interpretFootage" | "file.interpretProxy"
-            if !has(p, &["frameRate", "alpha", "loop", "pixelAspect", "colorProfile", "fields", "invertAlpha", "matteColor", "linearLight", "startFrame"]) =>
+            if !has(
+                p,
+                &[
+                    "frameRate",
+                    "alpha",
+                    "loop",
+                    "pixelAspect",
+                    "colorProfile",
+                    "fields",
+                    "invertAlpha",
+                    "matteColor",
+                    "linearLight",
+                    "startFrame",
+                    "logConversion",
+                    "cineonUnits",
+                    "pointUnits",
+                    "convertedBlack",
+                    "convertedWhite",
+                    "tenBitBlack",
+                    "tenBitWhite",
+                    "currentGamma",
+                    "highlightRolloff",
+                ],
+            ) =>
         {
             let proxy = id == "file.interpretProxy";
-            let f = s.state.project_selection.first().and_then(|i| s.project.item(*i)).and_then(|it| match (&it.kind, &it.proxy) {
-                (_, Some(px)) if proxy => Some(px.footage.clone()),
-                (effectcraft_engine::project::ItemKind::Footage(f), _) if !proxy => Some(f.clone()),
-                _ => None,
-            });
-            let Some(f) = f else { return false };
-            let hex = |c: [f32; 3]| format!("#{:02x}{:02x}{:02x}", (c[0] * 255.0).round() as u8, (c[1] * 255.0).round() as u8, (c[2] * 255.0).round() as u8);
-            let mut fields = vec![
-                // Main Options ▸ Alpha.
-                Field::choice(
-                    "alpha",
-                    "Alpha",
-                    &[
-                        ("Interpret Straight - Unmatted", json!("straight")),
-                        ("Interpret Premultiplied - Matted With Color", json!("premultiplied")),
-                        ("Ignore", json!("ignore")),
-                        ("Guess", json!("guess")),
-                    ],
-                    f.alpha as usize,
-                ),
-                Field::text("matteColor", "Matte color (premultiplied)", &hex(f.premul_color)),
-                Field::bool("invertAlpha", "Invert Alpha", f.invert_alpha),
-                // Main Options ▸ Frame Rate, Fields and Pulldown, Other Options.
-                Field::num("frameRate", "Assume this frame rate", f.frame_rate.as_f64()),
-                Field::choice(
-                    "fields",
-                    "Separate Fields",
-                    &[("Off", json!("off")), ("Upper Field First", json!("upper")), ("Lower Field First", json!("lower"))],
-                    f.fields as usize,
-                ),
-                Field::num("pixelAspect", "Pixel Aspect Ratio", f.pixel_aspect),
-                Field::num("loop", "Loop (times)", f.loop_count as f64),
-                // Color.
-                Field::choice(
-                    "colorProfile",
-                    "Assign Profile",
-                    &[
-                        ("Embedded / sRGB", json!("auto")),
-                        ("sRGB IEC61966-2.1", json!("srgb")),
-                        ("HDTV (Rec. 709)", json!("rec709")),
-                        ("Rec. 2020", json!("rec2020")),
-                        ("Display P3", json!("p3")),
-                        ("ACEScg", json!("acescg")),
-                        ("ACES2065-1", json!("aces2065")),
-                        ("Rec. 2100 PQ", json!("rec2100pq")),
-                        ("Rec. 2100 HLG", json!("rec2100hlg")),
-                    ],
-                    f.color_profile.map_or(0, |c| 1 + effectcraft_engine::project::ColorSpace::ALL.iter().position(|x| *x == c).unwrap_or(0)),
-                ),
-                Field::bool("preserveRgb", "Preserve RGB", f.preserve_rgb),
-                Field::bool("linearLight", "Interpret As Linear Light", f.linear_light),
-            ];
-            // After Frame Rate: an image sequence's frames (missing ones show colour bars, as in
-            // After Effects), then Start Timecode.
-            let mut timing = Vec::new();
-            if f.kind == effectcraft_engine::project::FootageKind::Sequence {
-                let gaps = match effectcraft_engine::sequence::missing_report(&f.sequence) {
-                    _ if f.alphabetical => "files in alphabetical order".into(),
-                    Some(gaps) => format!("{gaps} shown as color bars"),
-                    None => "no missing frames".into(),
-                };
-                timing.push(Field::note("sequenceInfo", &format!("Image sequence: {} files, {} frames; {gaps}.", f.sequence.len(), f.sequence_frames())));
-            }
-            if f.kind != effectcraft_engine::project::FootageKind::Still {
-                timing.push(Field::choice(
-                    "overrideStart",
-                    "Start Timecode",
-                    &[("Use Source File Timecode", json!(false)), ("Override Start", json!(true))],
-                    usize::from(f.start_timecode.is_some()),
-                ));
-                timing.push(Field::text("startTimecode", "Override Start", &f.timecode(0)));
-            }
-            let at = fields.iter().position(|x| x.key == "frameRate").map_or(fields.len(), |i| i + 1);
-            fields.splice(at..at, timing);
-            (if proxy { "Interpret Footage: Proxy".into() } else { "Interpret Footage".into() }, fields)
-        }
-        "file.projectSettings" if p.as_object().is_none_or(|m| m.is_empty()) => {
-            let st = &s.project.settings;
-            // The catalogue row is `Mercury GPU Acceleration ({})`, so the value goes through
-            // tr_args: wrapping the assembled string in tr() would look up the backend's name.
-            let gpu_label = match &s.accel {
-                Some(a) => tr_args("Mercury GPU Acceleration ({})", &[&a.name()]),
-                None => tr("Mercury GPU Acceleration (no GPU: software)").to_string(),
-            };
-            let depth = match st.bit_depth.label() {
-                l if l.starts_with("16") => 1,
-                l if l.starts_with("32") => 2,
-                _ => 0,
-            };
-            (
-                "Project Settings".into(),
-                vec![
-                    Field::choice(
-                        "bitDepth",
-                        "Depth",
-                        &[("8 bits per channel", json!(8)), ("16 bits per channel", json!(16)), ("32 bits per channel (float)", json!(32))],
-                        depth,
-                    ),
-                    Field::choice(
-                        "timeDisplay",
-                        "Time display style",
-                        &[
-                            ("Timecode", json!("timecode")),
-                            ("Frames", json!("frames")),
-                            ("Feet + Frames (35mm)", json!("feet35")),
-                            ("Feet + Frames (16mm)", json!("feet16")),
-                        ],
-                        {
-                            use effectcraft_engine::project::TimeDisplayStyle as T;
-                            match st.time_display {
-                                T::Timecode => 0,
-                                T::Frames => 1,
-                                T::Feet35 => 2,
-                                T::Feet16 => 3,
-                            }
-                        },
-                    ),
-                    // Time Display Style ▸ Frames ▸ Frame Count (also numbers Feet + Frames).
-                    Field::choice("frameStart", "Frame count", &[("Start at 0", json!(0)), ("Start at 1", json!(1))], usize::from(st.frame_start == 1)),
-                    Field::choice(
-                        "colorEngine",
-                        "Color engine",
-                        &[("Adobe-style built-in", json!("adobe")), ("OCIO (built-in ACES config)", json!("ocio"))],
-                        usize::from(st.color_engine == effectcraft_engine::project::ColorEngine::Ocio),
-                    ),
-                    Field::choice(
-                        "workingSpace",
-                        "Working space",
-                        &[
-                            ("None", json!("none")),
-                            ("sRGB IEC61966-2.1", json!("srgb")),
-                            ("HDTV (Rec. 709)", json!("rec709")),
-                            ("Rec. 2020", json!("rec2020")),
-                            ("Display P3", json!("p3")),
-                            ("ACEScg", json!("acescg")),
-                            ("ACES2065-1", json!("aces2065")),
-                        ],
-                        st.working_space.map_or(0, |c| 1 + effectcraft_engine::project::ColorSpace::WORKING.iter().position(|x| *x == c).unwrap_or(0)),
-                    ),
-                    // With Working Space None (After Effects' Working Gamma, 2.2 or 2.4).
-                    Field::choice("workingGamma", "Working gamma", &[("2.2", json!(2.2)), ("2.4", json!(2.4))], usize::from(st.working_gamma_24())),
-                    Field::bool("linearize", "Linearize working space", st.linearize),
-                    Field::bool("blendLinear", "Blend colors using 1.0 gamma", st.blend_linear),
-                    Field::choice(
-                        "hdr",
-                        "HDR on SDR displays and outputs",
-                        &[("Clip", json!("clip")), ("Compand", json!("compand")), ("Tone map", json!("toneMap"))],
-                        st.hdr as usize,
-                    ),
-                    Field::choice(
-                        "outputSpace",
-                        "Output color space",
-                        &[
-                            ("sRGB IEC61966-2.1 (default)", json!("default")),
-                            ("HDTV (Rec. 709)", json!("rec709")),
-                            ("Rec. 2020", json!("rec2020")),
-                            ("Display P3", json!("p3")),
-                            ("Rec. 2100 PQ (HDR)", json!("rec2100pq")),
-                            ("Rec. 2100 HLG (HDR)", json!("rec2100hlg")),
-                        ],
-                        {
-                            use effectcraft_engine::project::ColorSpace as C;
-                            match st.output_space {
-                                Some(C::Rec709) => 1,
-                                Some(C::Rec2020) => 2,
-                                Some(C::DisplayP3) => 3,
-                                Some(C::Rec2100Pq) => 4,
-                                Some(C::Rec2100Hlg) => 5,
-                                _ => 0,
-                            }
-                        },
-                    ),
-                    // Video Rendering and Effects ▸ Use.
-                    Field::choice(
-                        "renderer",
-                        "Video rendering and effects",
-                        &[(gpu_label.as_str(), json!("gpu")), ("Mercury Software Only", json!("software"))],
-                        usize::from(!st.gpu_acceleration),
-                    ),
-                ],
-            )
+            let Some(form) = interpret_footage_form(s, proxy, &mut base) else { return false };
+            form
         }
+        "file.projectSettings" if p.as_object().is_none_or(|m| m.is_empty()) => project_settings_form(s),
         "layer.autoTrace" if !has(p, &["channel", "timeSpan", "threshold"]) => (
             "Auto-trace".into(),
             vec![
@@ -663,40 +761,14 @@ pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
         }
         // File ▸ Export ▸ Adobe Premiere Pro Project…: Final Cut Pro XML (or FCPXML / OTIO / EDL).
         "file.exportTimeline" if !has(p, &["path"]) => {
-            let name = s.active_comp_id().and_then(|c| s.project.item(c)).map(|i| i.name.clone()).unwrap_or_else(|| "Composition".into());
-            let dir = s.path.as_deref().and_then(|p| std::path::Path::new(p).parent()).map(|d| d.to_path_buf()).unwrap_or_default();
-            let path = dir.join(format!("{name}.xml")).to_string_lossy().to_string();
-            (
-                "Export Adobe Premiere Pro Project".into(),
-                vec![
-                    Field::note("note", "Writes Final Cut Pro XML (.xml), which Premiere Pro opens with File ▸ Import. Native .prproj files are not written."),
-                    Field::save_path("path", "File", &path),
-                    Field::choice(
-                        "format",
-                        "Format",
-                        &[
-                            ("Final Cut Pro XML (.xml) – Premiere Pro", json!("xml")),
-                            ("FCPXML (.fcpxml)", json!("fcpxml")),
-                            ("OpenTimelineIO (.otio)", json!("otio")),
-                            ("CMX 3600 EDL (.edl, V1 only)", json!("edl")),
-                            ("AAF (.aaf)", json!("aaf")),
-                            ("OMF (.omf, audio)", json!("omf")),
-                        ],
-                        0,
-                    ),
-                    Field::choice(
-                        "prerender",
-                        "Pre-render (ProRes 4444)",
-                        &[
-                            ("Layers Premiere can't show (text, shapes, effects…)", json!("unsupported")),
-                            ("All layers", json!("all")),
-                            ("None (leave them out)", json!("none")),
-                        ],
-                        0,
-                    ),
-                    Field::choice("precomps", "Precomps", &[("Nested sequences", json!("nest")), ("Pre-render", json!("prerender"))], 0),
-                ],
-            )
+            // Its pre-renders run as a job in Window ▸ Progress, not with the window waiting (#2269).
+            match base.as_object_mut() {
+                Some(m) => {
+                    m.insert("background".into(), json!(true));
+                }
+                None => base = json!({"background": true}),
+            }
+            export_timeline_form(s)
         }
         "file.importPlaceholder" | "file.replaceWithPlaceholder" if p.as_object().is_none_or(|m| m.is_empty()) => (
             "New Placeholder".into(),
@@ -825,12 +897,12 @@ fn form_grid(ui: &mut egui::Ui, f: &mut Form, regs: &mut Vec<(String, egui::Rect
                     .inner
                     .rect
                 }
-                FieldKind::Bool(b) => ui.checkbox(b, "").rect,
+                FieldKind::Bool(b) => crate::widgets::labelled_checkbox(ui, b, "").rect,
                 FieldKind::Choice { options, sel } => {
                     let cur = options.get(*sel).map(|o| o.0.clone()).unwrap_or_default();
                     // The column keeps its width: a long choice (a GPU adapter's name) ends in an
                     // ellipsis instead of widening the form past the dialog (#978).
-                    egui::ComboBox::from_id_salt(("form", fl.key.as_str()))
+                    craft_ui::ComboBox::from_id_salt(("form", fl.key.as_str()))
                         .selected_text(tr(&cur))
                         .width(240.0)
                         .truncate()
@@ -955,13 +1027,13 @@ pub fn show_view_options(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Toke
     let mut close = false;
     super::dialogs::modal(ctx, "View Options", vec2(360.0, 330.0), t, |ui| {
         let v = &mut app.ui.viewer;
-        ui.checkbox(&mut v.show_layer_controls, tr("Layer controls"));
-        ui.checkbox(&mut v.show_masks, tr("Masks"));
-        ui.checkbox(&mut v.rulers, tr("Rulers"));
-        ui.checkbox(&mut v.guides, tr("Guides"));
-        ui.checkbox(&mut v.grid, tr("Grid"));
-        ui.checkbox(&mut v.safe_margins, tr("Title/action safe"));
-        ui.checkbox(&mut v.transparency_grid, tr("Transparency grid"));
+        crate::widgets::labelled_checkbox(ui, &mut v.show_layer_controls, tr("Layer controls"));
+        crate::widgets::labelled_checkbox(ui, &mut v.show_masks, tr("Masks"));
+        crate::widgets::labelled_checkbox(ui, &mut v.rulers, tr("Rulers"));
+        crate::widgets::labelled_checkbox(ui, &mut v.guides, tr("Guides"));
+        crate::widgets::labelled_checkbox(ui, &mut v.grid, tr("Grid"));
+        crate::widgets::labelled_checkbox(ui, &mut v.safe_margins, tr("Title/action safe"));
+        crate::widgets::labelled_checkbox(ui, &mut v.transparency_grid, tr("Transparency grid"));
         ui.add_space(12.0);
         ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
             if ui.add(egui::Button::new(egui::RichText::new(tr("   OK   ")).color(Color32::WHITE)).fill(t.accent)).clicked() {
@@ -1054,8 +1126,90 @@ mod tests {
         let params = app.dialog_state.form.params();
         assert!(params.get("note").is_none());
         assert_eq!(params["format"], "xml");
-        let r = app.session.execute("file.exportTimeline", params).unwrap();
-        assert_eq!(r["path"], path.as_str());
+        assert_eq!(params["background"], true, "the dialog exports in the background");
+        assert!(app.session.execute("file.exportTimeline", params).unwrap()["job"].is_string());
+        app.session.wait_jobs();
+        let done = app.session.job_log.last().unwrap();
+        assert_eq!((done.status.as_str(), &done.result["path"]), ("done", &json!(path)));
         assert!(std::fs::read_to_string(&path).unwrap().contains("<xmeml"));
     }
+
+    #[test]
+    fn interpretation_menu_applies_explicit_cineon_parameters_without_a_dialog() {
+        use effectcraft_engine::project::{Footage, FootageKind, ItemKind, Proxy};
+        for command in ["file.interpretFootage", "file.interpretProxy"] {
+            let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+            let footage = Footage { path: "/m/scan.dpx".into(), kind: FootageKind::Still, width: 4, height: 4, has_video: true, ..Default::default() };
+            let project = std::sync::Arc::make_mut(&mut app.session.project);
+            let item = project.add_item("scan.dpx", Default::default(), None, ItemKind::Footage(footage.clone()));
+            project.item_mut(item).unwrap().proxy = Some(Box::new(Proxy { footage, enabled: true }));
+            app.session.state.project_selection = vec![item];
+            let ctx = egui::Context::default();
+            for params in [
+                json!({"logConversion": true}),
+                json!({"cineonUnits": "10bit"}),
+                json!({"pointUnits": "10bit"}),
+                json!({"convertedBlack": 10.0}),
+                json!({"convertedWhite": 900.0}),
+                json!({"tenBitBlack": 90.0}),
+                json!({"tenBitWhite": 690.0}),
+                json!({"currentGamma": 2.2}),
+                json!({"highlightRolloff": 30.0}),
+            ] {
+                crate::menus::invoke(&mut app, &ctx, command, params.clone()).unwrap();
+                assert!(app.dialog.is_none(), "{command}: {params}");
+            }
+            let item = app.session.project.item(item).unwrap();
+            let footage = if command == "file.interpretProxy" {
+                &item.proxy.as_ref().unwrap().footage
+            } else {
+                let ItemKind::Footage(footage) = &item.kind else { panic!("not footage") };
+                footage
+            };
+            assert!(footage.cineon.log_conversion);
+            assert_eq!(footage.cineon.gamma, 2.2);
+            assert_eq!(footage.cineon.converted_white, 900.0);
+        }
+    }
+
+    /// Interpret Footage shows Cineon Settings for DPX footage only. The converted points show in
+    /// the footage's Units, and choosing other Units reads the shown values in the old ones.
+    #[test]
+    fn interpret_footage_shows_cineon_settings_for_dpx() {
+        use effectcraft_engine::project::{CineonUnits, Footage, FootageKind, ItemKind};
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        let still =
+            |path: &str| ItemKind::Footage(Footage { path: path.into(), kind: FootageKind::Still, width: 4, height: 4, has_video: true, ..Default::default() });
+        let project = std::sync::Arc::make_mut(&mut app.session.project);
+        let dpx = project.add_item("scan.dpx", Default::default(), None, still("/m/scan.dpx"));
+        let png = project.add_item("still.png", Default::default(), None, still("/m/still.png"));
+        let keys = |app: &EffectcraftApp| app.dialog_state.form.fields.iter().map(|f| f.key.clone()).collect::<Vec<_>>();
+        app.session.state.project_selection = vec![png];
+        assert!(open_form(&mut app, "file.interpretFootage", &json!({})));
+        assert!(!keys(&app).iter().any(|k| k == "logConversion"), "{:?}", keys(&app));
+        app.session.state.project_selection = vec![dpx];
+        assert!(open_form(&mut app, "file.interpretFootage", &json!({})));
+        for k in ["logConversion", "convertedBlack", "convertedWhite", "tenBitBlack", "tenBitWhite", "currentGamma", "highlightRolloff", "cineonUnits"] {
+            assert!(keys(&app).iter().any(|x| x == k), "{k}: {:?}", keys(&app));
+        }
+        // Units ▸ 8-bit with Converted White Point still showing 1023 (10-bit).
+        let form = &mut app.dialog_state.form;
+        for f in form.fields.iter_mut() {
+            match (f.key.as_str(), &mut f.kind) {
+                ("cineonUnits", FieldKind::Choice { sel, .. }) => *sel = 1,
+                ("logConversion", FieldKind::Bool(b)) => *b = true,
+                _ => {}
+            }
+        }
+        let params = form.params();
+        assert_eq!((params["pointUnits"].as_str(), params["cineonUnits"].as_str()), (Some("10bit"), Some("8bit")), "{params}");
+        app.session.execute("file.interpretFootage", params).unwrap();
+        let Some(ItemKind::Footage(f)) = app.session.project.item(dpx).map(|i| &i.kind) else { panic!("not footage") };
+        assert!(f.cineon.log_conversion && f.cineon.units == CineonUnits::EightBit, "{:?}", f.cineon);
+        assert!((f.cineon.converted_white - 1023.0).abs() < 1e-3, "{:?}", f.cineon);
+        // Opened again, the point shows in 8-bit units.
+        assert!(open_form(&mut app, "file.interpretFootage", &json!({})));
+        let white = app.dialog_state.form.fields.iter().find(|f| f.key == "convertedWhite").map(|f| f.kind.clone());
+        assert!(matches!(white, Some(FieldKind::Number { value, .. }) if (value - 255.0).abs() < 1e-6), "{white:?}");
+    }
 }
diff --git a/crates/ui-egui/src/panels/fx_editors.rs b/crates/ui-egui/src/panels/fx_editors.rs
index 7ee11b714..85b6be25f 100644
--- a/crates/ui-egui/src/panels/fx_editors.rs
+++ b/crates/ui-egui/src/panels/fx_editors.rs
@@ -66,19 +66,9 @@ fn register_points(app: &mut EffectcraftApp, prefix: &str, gr: Rect, pts: &[[f32
 }
 
 /// Small coloured tabs (`names[i]`, swatch `cols[i]`); returns the clicked one.
-fn tabs(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    p: &egui::Painter,
-    x0: f32,
-    cy: f32,
-    cur: usize,
-    names: &[&str],
-    cols: &[Color32],
-    id: &str,
-) -> Option<usize> {
+fn tabs(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, at: Pos2, cur: usize, (names, cols): (&[&str], &[Color32]), id: &str) -> Option<usize> {
     let t = app.tokens;
-    let mut x = x0;
+    let (mut x, cy) = (at.x, at.y);
     let mut out = None;
     for (i, name) in names.iter().enumerate() {
         let w = if cols.is_empty() { 16.0 + name.chars().count() as f32 * 6.2 } else { 20.0 };
@@ -111,6 +101,8 @@ fn tabs(
     out
 }
 
+/// A small "Reset" link centred in `r`, registered under the automation id `id`; returns whether
+/// it was clicked.
 fn reset_link(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, r: Rect, id: &str) -> bool {
     let t = app.tokens;
     let resp = ui.interact(r, egui::Id::unique(id), Sense::click());
@@ -162,6 +154,10 @@ pub fn inline_editor(
 
 const RGB_CURVES: [(&str, &str); 4] = [("master", "Master"), ("red", "Red"), ("green", "Green"), ("blue", "Blue")];
 
+/// The Lumetri RGB Curves editor for effect group `g`: channel tabs (Master, Red, Green, Blue),
+/// the selected channel's curve graph with its Reset, and the point positions registered for
+/// automation. A curve edit or Reset is queued on `actions` as a `prop.set` of that channel's
+/// curve string; the visible channel is remembered in `app.ui.fx_curve_channel` per group.
 #[allow(clippy::too_many_arguments)]
 fn rgb_curves(
     app: &mut EffectcraftApp,
@@ -182,7 +178,7 @@ fn rgb_curves(
     let cy = r.min.y + 15.0;
     let cols = [Color32::from_gray(0xe8), Color32::from_rgb(0xf0, 0x50, 0x50), Color32::from_rgb(0x50, 0xd0, 0x60), Color32::from_rgb(0x50, 0x80, 0xff)];
     let names: Vec<&str> = RGB_CURVES.iter().map(|c| c.1).collect();
-    if let Some(n) = tabs(app, ui, p, x0, cy, ch, &names, &cols, &format!("{prefix}.channel")) {
+    if let Some(n) = tabs(app, ui, p, pos2(x0, cy), ch, (&names, &cols), &format!("{prefix}.channel")) {
         app.ui.fx_curve_channel.insert(g.uid, n);
     }
     let id = RGB_CURVES[ch].0;
@@ -193,7 +189,7 @@ fn rgb_curves(
     }
     let gr = Rect::from_min_size(pos2(x0, r.min.y + 30.0), vec2(size, size));
     let gid = egui::Id::unique(("lumetri-rgb", euid, ch));
-    let (resp, edit) = fw::curves_graph(ui, gr, &cur, ch, false, false, gid, &t);
+    let (resp, edit) = fw::curves_graph(ui, gr, &cur, ch, fw::CurveMode { pencil: false, natural: false }, gid, &t);
     app.auto.add(&format!("{prefix}.graph"), gr, "RGB Curves");
     register_points(app, &prefix, gr, &cur.0);
     let key = gesture_key(ui, gid, resp.drag_started() || resp.clicked());
@@ -269,6 +265,11 @@ fn hue_color(h: f32) -> Color32 {
     Color32::from(c)
 }
 
+/// The Lumetri Hue/Saturation Curves editor for effect group `g`: tabs for the Hue vs Sat,
+/// Hue vs Hue, Hue vs Luma, Luma vs Sat and Sat vs Sat curves, drawn as a neutral-relative offset
+/// curve over the axis' colour band, with point drag/add/remove gestures and a Reset. Changes are
+/// queued on `actions` as a `prop.set` of the selected curve's point list; the visible tab is kept
+/// in `app.ui.fx_curve_channel` per group.
 #[allow(clippy::too_many_arguments)]
 fn huesat_curves(
     app: &mut EffectcraftApp,
@@ -288,7 +289,7 @@ fn huesat_curves(
     let x0 = r.min.x + 38.0;
     let cy = r.min.y + 15.0;
     let names: Vec<&str> = HUESAT.iter().map(|c| c.1).collect();
-    if let Some(n) = tabs(app, ui, p, x0, cy, k, &names, &[], &format!("{prefix}.curve")) {
+    if let Some(n) = tabs(app, ui, p, pos2(x0, cy), k, (&names, &[]), &format!("{prefix}.curve")) {
         app.ui.fx_curve_channel.insert(g.uid, n);
     }
     let (id, name, axis, periodic) = HUESAT[k];
@@ -441,6 +442,12 @@ fn wheel_point(c: Pos2, radius: f32, phase: f32) -> Pos2 {
     pos2(c.x + radius * a.sin(), c.y - radius * a.cos())
 }
 
+/// Colorama's Output Cycle wheel for effect group `g`: the palette drawn as a ring with its stops.
+/// Clicking the ring adds a stop with the colour there, dragging moves one, and Alt-clicking or
+/// dragging one off removes it while another stop remains; the selected stop's colour can be
+/// edited below. A change queues
+/// the rewritten palette on `actions`, and for a preset palette also switches the effect to the
+/// custom palette in the same undo step.
 #[allow(clippy::too_many_arguments)]
 fn colorama_wheel(
     app: &mut EffectcraftApp,
@@ -593,7 +600,7 @@ fn colorama_wheel(
     p.text(
         pos2(sr.min.x, sr.max.y + 9.0),
         Align2::LEFT_CENTER,
-        "Click the ring to add a colour; Alt-click a stop (or drag it off) to remove it",
+        crate::i18n::tr("Click the ring to add a colour; Alt-click a stop (or drag it off) to remove it"),
         Tokens::ui(10.5),
         t.text_faint,
     );
@@ -657,6 +664,10 @@ pub fn join_map(m: &[fw::CurvePoints; 3]) -> String {
     m.iter().map(|c| c.format()).collect::<Vec<_>>().join(" | ")
 }
 
+/// Glow's Colour Map for effect group `g`: a strip showing the gradient the glow uses (A/B colours,
+/// or the arbitrary map sampled through the loop settings). In arbitrary-map mode it also draws the
+/// RGB curve tabs and the selected channel's graph with a Reset; edits queue a `prop.set` of
+/// `arbitraryMap` on `actions`.
 #[allow(clippy::too_many_arguments)]
 fn glow_map(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, layer: &Layer, g: &PropGroup, ectx: &EvalCtx, r: Rect, actions: &mut Actions) {
     let t = app.tokens;
@@ -703,7 +714,7 @@ fn glow_map(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, laye
     }
     let ch = app.ui.fx_curve_channel.get(&euid).copied().unwrap_or(0).min(2);
     let cols = [Color32::from_rgb(0xf0, 0x50, 0x50), Color32::from_rgb(0x50, 0xd0, 0x60), Color32::from_rgb(0x50, 0x80, 0xff)];
-    if let Some(n) = tabs(app, ui, p, x0, r.min.y + 15.0, ch, &["Red", "Green", "Blue"], &cols, &format!("{prefix}.channel")) {
+    if let Some(n) = tabs(app, ui, p, pos2(x0, r.min.y + 15.0), ch, (&["Red", "Green", "Blue"], &cols), &format!("{prefix}.channel")) {
         app.ui.fx_curve_channel.insert(euid, n);
     }
     if reset_link(app, ui, p, Rect::from_min_size(pos2(x0 + size - 44.0, r.min.y + 6.0), vec2(44.0, 18.0)), &format!("{prefix}.reset")) {
@@ -713,7 +724,7 @@ fn glow_map(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, laye
     }
     let gr = Rect::from_min_size(pos2(x0, r.min.y + 30.0), vec2(size, size));
     let gid = egui::Id::unique(("glow-map", euid, ch));
-    let (resp, edit) = fw::curves_graph(ui, gr, &map[ch], ch + 1, false, false, gid, &t);
+    let (resp, edit) = fw::curves_graph(ui, gr, &map[ch], ch + 1, fw::CurveMode { pencil: false, natural: false }, gid, &t);
     app.auto.add(&format!("{prefix}.graph"), gr, "Arbitrary Map");
     register_points(app, &prefix, gr, &map[ch].0);
     let key = gesture_key(ui, gid, resp.drag_started() || resp.clicked());
@@ -769,6 +780,10 @@ pub fn add_pair(v: &[(f64, f64)]) -> (f64, f64) {
     ((a.0 + ds * 0.5).rem_euclid(1.0), (a.1 + gap * 0.5).rem_euclid(1.0))
 }
 
+/// Reshape's correspondence buttons: Add Point appends a pair at the widest destination-fraction
+/// gap (or `(0, 0)` for an empty list), Remove Point drops the last stored pair, and Clear removes
+/// all pairs. A status line says whether points are automatic. Each change
+/// queues a `prop.set` of the `correspondencePoints` string on `actions`.
 #[allow(clippy::too_many_arguments)]
 fn reshape_buttons(
     app: &mut EffectcraftApp,
@@ -786,19 +801,19 @@ fn reshape_buttons(
     let b1 = Rect::from_min_size(pos2(r.min.x + 24.0, r.min.y + 4.0), vec2(84.0, 22.0));
     let b2 = Rect::from_min_size(pos2(b1.max.x + 8.0, b1.min.y), vec2(96.0, 22.0));
     let b3 = Rect::from_min_size(pos2(b2.max.x + 8.0, b1.min.y), vec2(56.0, 22.0));
-    if widgets::text_button(ui, b1, "Add Point", false, &t, egui::Id::unique(("reshape-add", euid))).clicked() {
+    if widgets::text_button(ui, b1, crate::i18n::tr("Add Point"), false, &t, egui::Id::unique(("reshape-add", euid))).clicked() {
         let mut v = pairs.clone();
         v.push(add_pair(&pairs));
         set_str(actions, layer, g, "correspondencePoints", format_pairs(&v), None);
     }
     app.auto.add(&format!("effectControls.effect.{euid}.reshape.add"), b1, "Add Point");
-    if widgets::text_button(ui, b2, "Remove Point", false, &t, egui::Id::unique(("reshape-remove", euid))).clicked() && !pairs.is_empty() {
+    if widgets::text_button(ui, b2, crate::i18n::tr("Remove Point"), false, &t, egui::Id::unique(("reshape-remove", euid))).clicked() && !pairs.is_empty() {
         let mut v = pairs.clone();
         v.pop();
         set_str(actions, layer, g, "correspondencePoints", format_pairs(&v), None);
     }
     app.auto.add(&format!("effectControls.effect.{euid}.reshape.remove"), b2, "Remove Point");
-    if widgets::text_button(ui, b3, "Clear", false, &t, egui::Id::unique(("reshape-clear", euid))).clicked() && !pairs.is_empty() {
+    if widgets::text_button(ui, b3, crate::i18n::tr("Clear"), false, &t, egui::Id::unique(("reshape-clear", euid))).clicked() && !pairs.is_empty() {
         set_str(actions, layer, g, "correspondencePoints", String::new(), None);
     }
     app.auto.add(&format!("effectControls.effect.{euid}.reshape.clear"), b3, "Clear");
diff --git a/crates/ui-egui/src/panels/fx_widgets.rs b/crates/ui-egui/src/panels/fx_widgets.rs
index 974352e51..b3140d394 100644
--- a/crates/ui-egui/src/panels/fx_widgets.rs
+++ b/crates/ui-egui/src/panels/fx_widgets.rs
@@ -59,7 +59,8 @@ pub fn angle_field(ui: &mut egui::Ui, at: Pos2, id: egui::Id, v: f64, decimals:
     let (rev, deg) = split_angle(v);
     let (rr, new_rev, _) = widgets::hot_int_at(ui, at, id.with("rev"), rev, 0.1, "x", t);
     let sign = ui.painter().text(pos2(rr.max.x - 2.0, rr.center().y), Align2::LEFT_CENTER, if deg < 0.0 { "-" } else { "+" }, Tokens::ui(12.0), t.hot_text);
-    let (dr, new_deg, _) = widgets::hot_number_at(ui, pos2(sign.max.x - 2.0, at.y), id, deg.abs(), 0.5, (-1e9, 1e9), decimals, "°", t);
+    let (dr, new_deg, _) =
+        widgets::hot_number_at(ui, pos2(sign.max.x - 2.0, at.y), id, deg.abs(), &widgets::HotSpec { speed: 0.5, range: (-1e9, 1e9), decimals, suffix: "°" }, t);
     let dragging = new_deg.is_some() && ui.ctx().is_being_dragged(id);
     let out = match (new_rev, new_deg) {
         (Some(r), _) => Some(r as f64 * 360.0 + deg),
@@ -171,12 +172,7 @@ pub fn eyedropper_button(ui: &mut egui::Ui, rect: Rect, active: bool, id: egui::
     } else {
         t.text_dim
     };
-    // A pipette: a diagonal glass tube with a bulb at the top right and a tip at the bottom left.
-    let r = rect.shrink(rect.width() * 0.2);
-    let at = |x: f32, y: f32| pos2(r.min.x + x * r.width(), r.min.y + y * r.height());
-    p.line_segment([at(0.08, 0.92), at(0.62, 0.38)], Stroke::new(2.2, col));
-    p.circle_filled(at(0.76, 0.24), r.width() * 0.2, col);
-    p.line_segment([at(0.5, 0.3), at(0.7, 0.5)], Stroke::new(1.4, col));
+    crate::color_picker::draw_pipette(p, rect, col);
     resp
 }
 
@@ -200,14 +196,21 @@ pub fn layer_to_comp(l2c: &Mat3, p: [f64; 2]) -> [f64; 2] {
 /// `region` ([x, y, w, h] in comp pixels: the whole comp, or the region of interest or Extended
 /// Viewer area it was rendered for), maybe at a reduced resolution. `None` outside it.
 pub fn frame_pixel(img: &egui::ColorImage, region: [f64; 4], pt: [f64; 2]) -> Option<Color32> {
+    img.pixels.get(frame_pixel_index(img.size, region, pt)?).copied()
+}
+
+pub(crate) fn frame_pixel_index(size: [usize; 2], region: [f64; 4], pt: [f64; 2]) -> Option<usize> {
+    if size.contains(&0) {
+        return None;
+    }
     let [x, y, w, h] = region;
     let (fx, fy) = ((pt[0] - x) / w, (pt[1] - y) / h);
     if !(0.0..1.0).contains(&fx) || !(0.0..1.0).contains(&fy) {
         return None;
     }
-    let sx = ((fx * img.size[0] as f64).floor() as usize).min(img.size[0].saturating_sub(1));
-    let sy = ((fy * img.size[1] as f64).floor() as usize).min(img.size[1].saturating_sub(1));
-    img.pixels.get(sy.checked_mul(img.size[0])?.checked_add(sx)?).copied()
+    let sx = ((fx * size[0] as f64).floor() as usize).min(size[0].saturating_sub(1));
+    let sy = ((fy * size[1] as f64).floor() as usize).min(size[1].saturating_sub(1));
+    sy.checked_mul(size[0])?.checked_add(sx)
 }
 
 /// Straight RGBA (0..1) of the displayed frame at comp point `pt` ([`frame_pixel`]).
@@ -325,23 +328,56 @@ pub struct CurveEdit {
     pub done: bool,
 }
 
+/// How the Curves graph takes input: `pencil` draws freehand, `natural` picks the natural spline.
+#[derive(Clone, Copy)]
+pub struct CurveMode {
+    pub pencil: bool,
+    pub natural: bool,
+}
+
 /// The Curves graph: grid, identity diagonal, the curve, its points. Click adds a point, drag
 /// moves one, dragging a point off the graph (or Alt-clicking it) removes it. In pencil mode a
-/// drag draws the curve freehand. `natural` draws the natural spline the Curves effect renders
-/// (`Curve::parse_natural`) instead of the monotone one.
+/// drag draws the curve freehand. `mode.natural` draws the natural spline the Curves effect
+/// renders (`Curve::parse_natural`) instead of the monotone one.
 pub fn curves_graph(
     ui: &mut egui::Ui,
     rect: Rect,
     pts: &CurvePoints,
     channel: usize,
-    pencil: bool,
-    natural: bool,
+    mode: CurveMode,
     id: egui::Id,
     t: &Tokens,
 ) -> (egui::Response, CurveEdit) {
     let resp = ui.interact(rect.expand(6.0), id, Sense::click_and_drag());
     let p = ui.painter().with_clip_rect(rect.expand(8.0));
     p.rect_filled(rect, 0.0, Color32::from_rgb(0x1c, 0x1c, 0x1c));
+    draw_curve_grid(&p, rect, t);
+    let col = curve_channel_color(channel);
+    let spline =
+        if mode.natural { effectcraft_engine::effects::Curve::parse_natural(&pts.format()) } else { effectcraft_engine::effects::Curve::parse(&pts.format()) };
+    let eval = |x: f32| spline.as_ref().map(|c| c.eval(x)).unwrap_or(x);
+    let line: Vec<Pos2> = (0..=96)
+        .map(|i| {
+            let x = i as f32 / 96.0;
+            curve_to_screen(rect, x, eval(x).clamp(0.0, 1.0))
+        })
+        .collect();
+    p.add(egui::Shape::line(line, Stroke::new(1.5, col)));
+    let drag_id = id.with("drag");
+    let dragging: Option<usize> = ui.data(|d| d.get_temp(drag_id));
+    draw_curve_points(&p, rect, pts, col, dragging);
+    if mode.pencil {
+        let edit = curve_pencil(ui, &resp, rect, id, &eval);
+        return (resp, edit);
+    }
+    let mut edit = CurveEdit::default();
+    curve_drag(ui, &resp, rect, pts, drag_id, dragging, &mut edit);
+    let alt = ui.input(|i| i.modifiers.alt);
+    curve_click(&resp, rect, pts, alt, &mut edit);
+    (resp, edit)
+}
+
+fn draw_curve_grid(p: &egui::Painter, rect: Rect, t: &Tokens) {
     for k in 1..4 {
         let f = k as f32 / 4.0;
         let x = rect.min.x + rect.width() * f;
@@ -351,37 +387,29 @@ pub fn curves_graph(
     }
     p.line_segment([rect.left_bottom(), rect.right_top()], Stroke::new(1.0, Color32::from_white_alpha(40)));
     p.rect_stroke(rect, 0.0, Stroke::new(1.0, t.field_border), StrokeKind::Outside);
-    let col = match channel {
+}
+
+fn curve_channel_color(channel: usize) -> Color32 {
+    match channel {
         1 => Color32::from_rgb(0xf0, 0x60, 0x60),
         2 => Color32::from_rgb(0x60, 0xe0, 0x70),
         3 => Color32::from_rgb(0x60, 0x90, 0xff),
         4 => Color32::from_gray(0xb0),
         _ => Color32::from_gray(0xe8),
-    };
-    let to_s = |x: f32, y: f32| pos2(rect.min.x + x * rect.width(), rect.max.y - y * rect.height());
-    let to_g = |s: Pos2| [((s.x - rect.min.x) / rect.width()), ((rect.max.y - s.y) / rect.height())];
-    let spline =
-        if natural { effectcraft_engine::effects::Curve::parse_natural(&pts.format()) } else { effectcraft_engine::effects::Curve::parse(&pts.format()) };
-    let seed = || {
-        (0..=64)
-            .map(|i| {
-                let x = i as f32 / 64.0;
-                spline.as_ref().map(|c| c.eval(x)).unwrap_or(x)
-            })
-            .collect::<Vec<f32>>()
-    };
-    let line: Vec<Pos2> = (0..=96)
-        .map(|i| {
-            let x = i as f32 / 96.0;
-            to_s(x, spline.as_ref().map(|c| c.eval(x)).unwrap_or(x).clamp(0.0, 1.0))
-        })
-        .collect();
-    p.add(egui::Shape::line(line, Stroke::new(1.5, col)));
-    let drag_id = id.with("drag");
-    let pencil_id = id.with("pencil");
-    let dragging: Option<usize> = ui.data(|d| d.get_temp(drag_id));
+    }
+}
+
+fn curve_to_screen(rect: Rect, x: f32, y: f32) -> Pos2 {
+    pos2(rect.min.x + x * rect.width(), rect.max.y - y * rect.height())
+}
+
+fn screen_to_curve(rect: Rect, s: Pos2) -> [f32; 2] {
+    [((s.x - rect.min.x) / rect.width()), ((rect.max.y - s.y) / rect.height())]
+}
+
+fn draw_curve_points(p: &egui::Painter, rect: Rect, pts: &CurvePoints, col: Color32, dragging: Option<usize>) {
     for (i, q) in pts.0.iter().enumerate() {
-        let s = to_s(q[0], q[1]);
+        let s = curve_to_screen(rect, q[0], q[1]);
         let r = Rect::from_center_size(s, vec2(7.0, 7.0));
         if dragging == Some(i) {
             p.rect_filled(r, 0.0, col);
@@ -390,33 +418,41 @@ pub fn curves_graph(
             p.rect_stroke(r, 0.0, Stroke::new(1.2, col), StrokeKind::Inside);
         }
     }
+}
+
+/// Pencil mode: a drag overwrites the sampled curve under the pointer.
+fn curve_pencil(ui: &mut egui::Ui, resp: &egui::Response, rect: Rect, id: egui::Id, eval: &dyn Fn(f32) -> f32) -> CurveEdit {
+    let pencil_id = id.with("pencil");
+    let seed = || (0..=64).map(|i| eval(i as f32 / 64.0)).collect::<Vec<f32>>();
     let mut edit = CurveEdit::default();
-    let hit_r = 7.0 / rect.width();
-    let alt = ui.input(|i| i.modifiers.alt);
-    if pencil {
-        if resp.drag_started() {
-            ui.data_mut(|d| d.insert_temp(pencil_id, seed()));
-        }
-        if (resp.dragged() || resp.clicked())
-            && let Some(pt) = resp.interact_pointer_pos()
-        {
-            let mut samples: Vec<f32> = ui.data(|d| d.get_temp(pencil_id)).unwrap_or_else(seed);
-            let g = to_g(pt);
-            let i = (g[0].clamp(0.0, 1.0) * 64.0).round() as usize;
-            samples[i.min(64)] = g[1].clamp(0.0, 1.0);
-            ui.data_mut(|d| d.insert_temp(pencil_id, samples.clone()));
-            edit.changed = Some(CurvePoints::from_samples(&samples));
-        }
-        if resp.drag_stopped() {
-            ui.data_mut(|d| d.remove::<Vec<f32>>(pencil_id));
-            edit.done = true;
-        }
-        return (resp, edit);
+    if resp.drag_started() {
+        ui.data_mut(|d| d.insert_temp(pencil_id, seed()));
     }
+    if (resp.dragged() || resp.clicked())
+        && let Some(pt) = resp.interact_pointer_pos()
+    {
+        let mut samples: Vec<f32> = ui.data(|d| d.get_temp(pencil_id)).unwrap_or_else(seed);
+        let g = screen_to_curve(rect, pt);
+        let i = (g[0].clamp(0.0, 1.0) * 64.0).round() as usize;
+        samples[i.min(64)] = g[1].clamp(0.0, 1.0);
+        ui.data_mut(|d| d.insert_temp(pencil_id, samples.clone()));
+        edit.changed = Some(CurvePoints::from_samples(&samples));
+    }
+    if resp.drag_stopped() {
+        ui.data_mut(|d| d.remove::<Vec<f32>>(pencil_id));
+        edit.done = true;
+    }
+    edit
+}
+
+/// Drag a point to move it, or drag from empty space to insert one; dropping a point well off
+/// the graph removes it.
+fn curve_drag(ui: &mut egui::Ui, resp: &egui::Response, rect: Rect, pts: &CurvePoints, drag_id: egui::Id, dragging: Option<usize>, edit: &mut CurveEdit) {
+    let hit_r = 7.0 / rect.width();
     if resp.drag_started()
         && let Some(pt) = ui.input(|i| i.pointer.press_origin())
     {
-        let g = to_g(pt);
+        let g = screen_to_curve(rect, pt);
         let i = match pts.hit(g[0], g[1], hit_r) {
             Some(i) => i,
             None => {
@@ -430,7 +466,7 @@ pub fn curves_graph(
     } else if resp.dragged()
         && let (Some(i), Some(pt)) = (dragging, resp.interact_pointer_pos())
     {
-        let g = to_g(pt);
+        let g = screen_to_curve(rect, pt);
         let mut np = pts.clone();
         np.move_point(i, g[0], g[1]);
         if np != *pts {
@@ -449,10 +485,15 @@ pub fn curves_graph(
         ui.data_mut(|d| d.remove::<usize>(drag_id));
         edit.done = true;
     }
+}
+
+/// A click adds a point on empty space; Alt-clicking a point removes it.
+fn curve_click(resp: &egui::Response, rect: Rect, pts: &CurvePoints, alt: bool, edit: &mut CurveEdit) {
     if resp.clicked()
         && let Some(pt) = resp.interact_pointer_pos()
     {
-        let g = to_g(pt);
+        let g = screen_to_curve(rect, pt);
+        let hit_r = 7.0 / rect.width();
         let mut np = pts.clone();
         match pts.hit(g[0], g[1], hit_r) {
             Some(i) if alt => {
@@ -468,7 +509,6 @@ pub fn curves_graph(
         }
         edit.done = true;
     }
-    (resp, edit)
 }
 
 // ---------------------------------------------------------------------------------------------
diff --git a/crates/ui-egui/src/panels/gradient_editor.rs b/crates/ui-egui/src/panels/gradient_editor.rs
index 9db4d6163..0f0bbe412 100644
--- a/crates/ui-egui/src/panels/gradient_editor.rs
+++ b/crates/ui-egui/src/panels/gradient_editor.rs
@@ -3,14 +3,18 @@
 //! Opacity stops sit above the preview bar and colour stops below it. Click above or below the
 //! bar to add a stop (it takes that track's value there), drag a stop to move it, edit the
 //! selected stop's location, opacity or colour, and Delete removes it (never the last stop of a
-//! track). The editor works on a draft: OK sets the property once with `prop.set` at the time it
-//! opened (one undo step, nothing at all when nothing changed); Cancel and Escape leave it as it
-//! was.
+//! track). The editor works on a draft. With **Preview** on (the default, as in After Effects) each
+//! edit is applied to the property at once, with `prop.set` at the time the editor opened and one
+//! merged undo step, so the canvas shows the gradient as it is edited; OK keeps it, Cancel and
+//! Escape roll it back to the checkpoint taken when the editor opened. With Preview off, OK sets
+//! the property once (one undo step, nothing at all when nothing changed). The dialog opens at
+//! the lower right of the window and does not dim it, so the canvas stays in view.
 //!
 //! Automation ids: `dialog.gradient.bar`, `dialog.gradient.addOpacity`, `dialog.gradient.addColor`,
 //! `dialog.gradient.opacityStop.<i>`, `dialog.gradient.colorStop.<i>` (in order along the bar),
 //! `dialog.gradient.location`, `dialog.gradient.opacity`, `dialog.gradient.color`,
-//! `dialog.gradient.delete`, `dialog.gradient.ok`, `dialog.gradient.cancel`.
+//! `dialog.gradient.delete`, `dialog.gradient.preview`, `dialog.gradient.ok`,
+//! `dialog.gradient.cancel`.
 
 use effectcraft_engine::keyframe::{Gradient, Value};
 use effectcraft_engine::project::{ItemId, LayerId};
@@ -18,6 +22,8 @@ use egui::{Color32, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
 use serde_json::{Value as Json, json};
 
 use crate::i18n::tr;
+use crate::panels::layer_styles_dialog::{Checkpoint, checkpoint};
+use crate::panels::preview_merge::{self, Applied};
 use crate::theme::Tokens;
 use crate::{Dialog, EffectcraftApp};
 
@@ -58,6 +64,14 @@ pub struct Draft {
     pub baseline: Gradient,
     /// Stop counts (colour, opacity) of the keyframes just before and after the edit time.
     pub neighbors: Vec<(usize, usize)>,
+    /// Preview: edits are applied to the property as they are made.
+    pub preview: bool,
+    /// The gradient the property was last given by the preview, if it has been.
+    pub applied: Option<Gradient>,
+    /// The project as the preview left it, to tell edits made since from the preview's.
+    applied_at: Option<Applied>,
+    /// The project and undo history as the editor opened, for Cancel.
+    checkpoint: Option<Checkpoint>,
     next_id: u64,
 }
 
@@ -220,7 +234,10 @@ pub fn open(app: &mut EffectcraftApp, p: &Json) -> Result<Json, String> {
     let before = prop.keys.iter().rev().find(|k| k.time < lt).and_then(|k| counts(&k.value));
     let after = prop.keys.iter().find(|k| k.time > lt).and_then(|k| counts(&k.value));
     let target = Target { comp: cid.0, layer: lid, prop: uid, time: ct.seconds() };
-    app.dialog_state.gradient = Draft::new(&g, Some(target), before.into_iter().chain(after).collect());
+    let mut draft = Draft::new(&g, Some(target), before.into_iter().chain(after).collect());
+    draft.preview = true;
+    draft.checkpoint = Some(checkpoint(app));
+    app.dialog_state.gradient = draft;
     app.dialog = Some(Dialog::GradientEditor);
     Ok(json!({"dialog": "gradientEditor"}))
 }
@@ -228,9 +245,14 @@ pub fn open(app: &mut EffectcraftApp, p: &Json) -> Result<Json, String> {
 /// Set the property to the draft: one `prop.set` at the time the editor opened, in composition
 /// time, or nothing when the draft is unchanged (so OK adds no keyframe).
 fn commit(app: &mut EffectcraftApp, ctx: &egui::Context) {
-    app.dialog = None;
+    close(app);
     let d = std::mem::take(&mut app.dialog_state.gradient);
     let g = d.gradient();
+    // The preview already set the property to this draft, in one merged undo step: OK keeps it.
+    if d.applied.as_ref() == Some(&g) {
+        app.session.history.merge_key = None;
+        return;
+    }
     let Some(tg) = d.target else { return };
     if g == d.baseline {
         return;
@@ -241,18 +263,79 @@ fn commit(app: &mut EffectcraftApp, ctx: &egui::Context) {
     }
 }
 
-fn to_color32(c: [f32; 4]) -> Color32 {
+/// Close the editor without keeping the preview: the project and undo history go back to how they
+/// were when it opened (nothing happens when the preview never changed the property).
+pub fn finish(app: &mut EffectcraftApp, ok: bool, ctx: &egui::Context) {
+    if ok {
+        // An edit made in the same frame as OK is not in the last preview yet.
+        sync_preview(app, ctx);
+        commit(app, ctx);
+        return;
+    }
+    let d = std::mem::take(&mut app.dialog_state.gradient);
+    if d.applied.is_some()
+        && let Some(cp) = d.checkpoint
+    {
+        preview_merge::rollback(app, cp, d.applied_at.as_ref());
+    }
+    app.session.history.merge_key = None;
+    close(app);
+}
+
+/// Close the editor: back to the Layer Style dialog when it opened from there (#2057).
+fn close(app: &mut EffectcraftApp) {
+    app.dialog = std::mem::take(&mut app.dialog_state.layer_style.gradient_open).then_some(Dialog::LayerStyles);
+}
+
+/// Keep the property in step with the draft while Preview is on: apply a changed draft with one
+/// merged undo step, and roll back to the checkpoint when Preview goes off or the draft is back to
+/// how it opened.
+fn sync_preview(app: &mut EffectcraftApp, ctx: &egui::Context) {
+    let d = &app.dialog_state.gradient;
+    let Some(tg) = d.target.clone() else { return };
+    let g = d.gradient();
+    let want = d.preview && g != d.baseline;
+    if want && d.applied.as_ref() != Some(&g) {
+        let params = json!({
+            "comp": tg.comp, "layer": tg.layer, "prop": tg.prop, "time": tg.time, "timeBase": "comp",
+            "value": Value::Gradient(g.clone()).to_json(), "merge": format!("gradient-editor-{}", tg.prop),
+        });
+        match crate::menus::invoke(app, ctx, "prop.set", params) {
+            Ok(_) => {
+                app.dialog_state.gradient.applied = Some(g);
+                app.dialog_state.gradient.applied_at = Some(preview_merge::applied(app));
+            }
+            Err(e) => app.ui.status = e,
+        }
+    } else if !want
+        && d.applied.is_some()
+        && let Some(cp) = d.checkpoint.clone()
+    {
+        let at = app.dialog_state.gradient.applied_at.take();
+        preview_merge::rollback(app, cp, at.as_ref());
+        app.dialog_state.gradient.applied = None;
+    }
+}
+
+pub(super) fn to_color32(c: [f32; 4]) -> Color32 {
     let b = |v: f32| (v.clamp(0.0, 1.0) * 255.0).round() as u8;
     Color32::from_rgba_unmultiplied(b(c[0]), b(c[1]), b(c[2]), b(c[3]))
 }
 
+/// The Gradient Editor dialog for the gradient in `app.dialog_state.gradient`: a stop track for
+/// the opacity and colour tracks over a checkerboard preview, the selected stop's location,
+/// opacity or colour and a Delete button (when its track has more than one stop), the
+/// mismatched-stop-count warning, and OK/Cancel. Dragging moves stops, Delete/Backspace removes the
+/// selected one unless a widget wants keyboard input. OK runs the commit path; Cancel closes the dialog and drops the
+/// draft. With no gradient target it closes the dialog.
 pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
     if app.dialog_state.gradient.target.is_none() {
         app.dialog = None;
         return;
     }
     let mut answer: Option<bool> = None;
-    super::dialogs::modal(ctx, tr("Gradient Editor"), vec2(520.0, 270.0), t, |ui| {
+    // At the lower right, undimmed: the canvas it edits stays in view (After Effects).
+    super::dialogs::modal_placed(ctx, tr("Gradient Editor"), vec2(520.0, 270.0), t, super::live_preview::PLACE, |ui| {
         let w = ui.available_width().max(200.0);
         let (area, _) = ui.allocate_exact_size(vec2(w, 72.0), Sense::hover());
         let bar = Rect::from_min_max(pos2(area.min.x + 8.0, area.min.y + 22.0), pos2(area.max.x - 8.0, area.min.y + 48.0));
@@ -410,6 +493,10 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             if r.clicked() {
                 answer = Some(true);
             }
+            let mut preview = app.dialog_state.gradient.preview;
+            let r = ui.checkbox(&mut preview, tr("Preview"));
+            app.auto.add("dialog.gradient.preview", r.rect, "Preview");
+            app.dialog_state.gradient.preview = preview;
         });
     });
     // Delete / Backspace remove the selected stop, but not while typing in a field.
@@ -421,12 +508,8 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
         app.dialog_state.gradient.remove(track, id);
     }
     match answer {
-        Some(true) => commit(app, ctx),
-        Some(false) => {
-            app.dialog = None;
-            app.dialog_state.gradient = Draft::default();
-        }
-        None => {}
+        Some(ok) => finish(app, ok, ctx),
+        None => sync_preview(app, ctx),
     }
 }
 
diff --git a/crates/ui-egui/src/panels/graph.rs b/crates/ui-egui/src/panels/graph.rs
index fa082040c..be18999d4 100644
--- a/crates/ui-egui/src/panels/graph.rs
+++ b/crates/ui-egui/src/panels/graph.rs
@@ -48,9 +48,21 @@ struct KeyPt {
     t: f64,
     v: f64,
     sel: bool,
+    muted: bool,
     handles: Vec<Handle>,
 }
 
+/// A graph key's fill and edge colours: muted keys stay visible and selectable, dimmed.
+fn key_colors(t: &Tokens, edge: Color32, k: &KeyPt) -> (Color32, Color32) {
+    let fill = match (k.muted, k.sel) {
+        (true, true) => t.keyframe_selected.gamma_multiply(0.5),
+        (true, false) => Color32::from_gray(0x70),
+        (false, true) => t.keyframe_selected,
+        (false, false) => Color32::from_gray(0xe0),
+    };
+    (fill, if k.muted { edge.gamma_multiply(0.4) } else { edge })
+}
+
 struct Curve<'a> {
     layer: &'a Layer,
     prop: &'a Property,
@@ -153,7 +165,7 @@ fn curves<'a>(app: &EffectcraftApp, comp: &'a Comp, ectx: &EvalCtx, tm: TMap, pl
                     let dt = e.influence * dur * if out_side { 1.0 } else { -1.0 };
                     let (hv, show) = if speed { (e.speed.abs(), true) } else { (k.value.components().get(d).copied().unwrap_or(0.0) + e.speed * dt, !spatial) };
                     let bezier = if out_side { k.out_interp == Interp::Bezier } else { k.in_interp == Interp::Bezier };
-                    if ks && show && (bezier || speed) {
+                    if ks && !k.muted && show && (bezier || speed) {
                         handles.push(Handle { out: out_side, t: kt + dt, v: hv, speed: e.speed, dur });
                     }
                 }
@@ -162,7 +174,7 @@ fn curves<'a>(app: &EffectcraftApp, comp: &'a Comp, ectx: &EvalCtx, tm: TMap, pl
                 } else {
                     k.value.components().get(d).copied().unwrap_or(0.0)
                 };
-                keys.push(KeyPt { idx: i, time: k.time, t: kt, v, sel: ks, handles });
+                keys.push(KeyPt { idx: i, time: k.time, t: kt, v, sel: ks, muted: k.muted, handles });
             }
             out.push(Curve { layer: l, prop: pr, dim: d, color, pts, keys, editable: !spatial });
         }
@@ -189,6 +201,9 @@ const MORE_POPUP: &str = "graph-more";
 impl ButtonBar {
     const MORE_W: f32 = 24.0;
 
+    /// A bar starting 8 points into `bar`, stopping short of its right end by the "»" button's
+    /// width. It takes the id picked from the "»" menu in the previous frame, so the button whose
+    /// id that was reports a click on the frame after the pick.
     fn new(ctx: &egui::Context, bar: Rect) -> Self {
         let chosen = ctx.data_mut(|d| d.remove_temp::<String>(egui::Id::unique(MORE_POPUP).with("chosen")));
         ButtonBar { x: bar.min.x + 8.0, limit: bar.max.x - 8.0 - Self::MORE_W - 4.0, hidden: Vec::new(), chosen }
@@ -218,7 +233,7 @@ impl ButtonBar {
         let chosen = widgets::popup_list(ui, pid, pos, r, rows, 0, |ui| {
             let mut chosen = None;
             for (id, label, on, tip) in &self.hidden {
-                let item = ui.selectable_label(*on, label.as_str()).on_hover_text(tip.as_str());
+                let item = ui.selectable_label(*on, crate::i18n::tr(label)).on_hover_text(crate::i18n::tr(tip));
                 app.auto.add(&format!("timeline.graph.more.{id}"), item.rect, tip);
                 if item.clicked() {
                     chosen = Some(id.clone());
@@ -233,26 +248,31 @@ impl ButtonBar {
     }
 }
 
-fn text_button(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    p: &egui::Painter,
-    bar: &mut ButtonBar,
-    y: f32,
-    label: &str,
+/// One text button of the Graph Editor's button bar at the bar's current `x`, in the toolbar row
+/// at `y`: draws it, registers it for automation and advances the bar. Once a button does not fit
+/// (or a previous one overflowed), the button goes to the "»" menu instead and only the id the
+/// menu picked reports a click. Returns whether this button was chosen.
+/// One bar button for [`text_button`]: label, lit state, automation id and tooltip.
+struct BarBtn<'a> {
+    label: &'a str,
     on: bool,
-    id: &str,
-    tip: &str,
-) -> bool {
+    id: &'a str,
+    tip: &'a str,
+}
+
+fn text_button(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, bar: &mut ButtonBar, y: f32, btn: BarBtn) -> bool {
+    let BarBtn { label, on, id, tip } = btn;
     let t = app.tokens;
-    let w = p.layout_no_wrap(label.to_string(), Tokens::ui(11.0), t.text).size().x + 14.0;
+    let (shown, shown_tip) = (crate::i18n::tr(label), crate::i18n::tr(tip));
+    let w = p.layout_no_wrap(shown.to_string(), Tokens::ui(11.0), t.text).size().x + 14.0;
     // Once one button overflows, the rest follow it into the menu (they keep their order).
     if !bar.hidden.is_empty() || bar.x + w > bar.limit {
+        // The menu translates these English labels when it draws them; automation keeps them.
         bar.hidden.push((id.to_string(), label.to_string(), on, tip.to_string()));
         return bar.chosen.as_deref() == Some(id);
     }
     let r = Rect::from_min_size(pos2(bar.x, y - 9.0), vec2(w, 18.0));
-    let resp = ui.interact(r, egui::Id::unique(("graph-btn", id)), Sense::click()).on_hover_text(tip);
+    let resp = ui.interact(r, egui::Id::unique(("graph-btn", id)), Sense::click()).on_hover_text(shown_tip);
     p.rect_filled(
         r,
         3.0,
@@ -264,41 +284,50 @@ fn text_button(
             Color32::from_rgb(0x2c, 0x2c, 0x2c)
         },
     );
-    p.text(r.center(), Align2::CENTER_CENTER, label, Tokens::ui(11.0), if on { Color32::WHITE } else { t.text });
+    p.text(r.center(), Align2::CENTER_CENTER, shown, Tokens::ui(11.0), if on { Color32::WHITE } else { t.text });
     app.auto.add(&format!("timeline.graph.{id}"), r, tip);
     bar.x += w + 4.0;
     resp.clicked()
 }
 
-/// Draw the Graph Editor into `area` (the right side of the Timeline) and queue edits.
-pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, comp: &Comp, ectx: &EvalCtx, tm: TMap, area: Rect, actions: &mut Actions) {
-    let t = app.tokens;
-    let ctx = ui.ctx().clone();
-    let footer_h = 28.0;
-    let plot = Rect::from_min_max(area.min + vec2(0.0, 6.0), pos2(area.max.x, area.max.y - footer_h));
-    let bar = Rect::from_min_max(pos2(area.min.x, area.max.y - footer_h), area.max);
-    // Background first so keys and handles (added later) sit on top for hit-testing.
-    let bg = ui.interact(plot, egui::Id::unique("graph-bg"), Sense::click_and_drag());
-    p.rect_filled(area, 0.0, Color32::from_rgb(0x1d, 0x1d, 0x1d));
-    app.auto.add("timeline.graph", plot, &app.ui.timeline.graph_mode.clone());
-    let speed = speed_graph(app, comp);
-    let cs = curves(app, comp, ectx, tm, plot, speed);
-    // Just opened, or the graph type changed (value and speed have different units): frame the
-    // graphs (Fit Selection to View, else Fit All Graphs to View).
-    let was_speed_id = egui::Id::unique("graph-was-speed");
-    let type_changed = ctx.data(|d| d.get_temp::<bool>(was_speed_id)).is_some_and(|was| was != speed);
-    ctx.data_mut(|d| d.insert_temp(was_speed_id, speed));
-    if ctx.data_mut(|d| d.remove_temp::<bool>(fit_pending_id())).unwrap_or(false) || type_changed {
-        if cs.iter().any(|c| c.keys.iter().any(|k| k.sel)) {
-            fit_selection(app, &cs, tm, plot, speed);
-        } else {
-            fit_all(app);
+/// What the Graph Editor draws: the composition, its evaluation context and the time mapping.
+#[derive(Clone, Copy)]
+pub(crate) struct GraphView<'a> {
+    pub comp: &'a Comp,
+    pub ectx: &'a EvalCtx<'a>,
+    pub tm: TMap,
+}
+
+/// Show Reference Graph: the other graph type, faint, scaled to the plot.
+fn reference_graph(app: &EffectcraftApp, view: GraphView, plot: Rect, speed: bool, pc: &egui::Painter) {
+    let GraphView { comp, ectx, tm } = view;
+    let other = curves(app, comp, ectx, tm, plot, !speed);
+    let (mut rlo, mut rhi) = (f64::INFINITY, f64::NEG_INFINITY);
+    for c in &other {
+        for (_, v) in &c.pts {
+            rlo = rlo.min(*v);
+            rhi = rhi.max(*v);
         }
     }
+    if rlo.is_finite() {
+        let span = (rhi - rlo).max(1e-9);
+        let lines: Vec<(Color32, Vec<Pos2>)> = other
+            .iter()
+            .map(|c| {
+                (
+                    c.color,
+                    c.pts.iter().map(|(ct, v)| pos2(tm.x(*ct), plot.max.y - ((v - rlo) / span) as f32 * plot.height() * 0.9 - plot.height() * 0.05)).collect(),
+                )
+            })
+            .collect();
+        super::graph_tools::reference_graph(pc, plot, &lines);
+    }
+}
 
-    // Vertical range: auto-zoom to the curves + handles, or the stored manual range.
+/// The value range that fits every curve point and key handle (with a margin).
+fn auto_range(cs: &[Curve], speed: bool) -> (f64, f64) {
     let (mut lo, mut hi) = (f64::INFINITY, f64::NEG_INFINITY);
-    for c in &cs {
+    for c in cs {
         for (_, v) in &c.pts {
             lo = lo.min(*v);
             hi = hi.max(*v);
@@ -320,7 +349,78 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
         hi = lo + 1.0;
     }
     let pad = (hi - lo) * 0.08;
-    let auto = (lo - pad, hi + pad);
+    (lo - pad, hi + pad)
+}
+
+/// Background: a click deselects keys, a drag box-selects the keys inside it.
+fn box_select(ui: &egui::Ui, pc: &egui::Painter, bg: &egui::Response, key_screens: &[(serde_json::Value, Pos2)], accent: Color32, actions: &mut Actions) {
+    let ctx = ui.ctx().clone();
+    if bg.clicked() {
+        actions.push(("keys.select".into(), json!({"keys": []})));
+    }
+    if bg.dragged()
+        && let (Some(o), Some(cur)) = (ctx.input(|i| i.pointer.press_origin()), bg.interact_pointer_pos())
+    {
+        let br = Rect::from_two_pos(o, cur);
+        pc.rect_filled(br, 0.0, accent.gamma_multiply(0.12));
+        pc.rect_stroke(br, 0.0, Stroke::new(1.0, accent), StrokeKind::Middle);
+        ctx.data_mut(|d| d.insert_temp(egui::Id::unique("graph-box"), br));
+    }
+    if bg.drag_stopped()
+        && let Some(br) = ctx.data(|d| d.get_temp::<Rect>(egui::Id::unique("graph-box")))
+    {
+        ctx.data_mut(|d| d.remove::<Rect>(egui::Id::unique("graph-box")));
+        let keys: Vec<serde_json::Value> = key_screens.iter().filter(|(_, sp)| br.contains(*sp)).map(|(k, _)| k.clone()).collect();
+        actions.push(("keys.select".into(), json!({"keys": keys, "add": ui.input(|i| i.modifiers.shift)})));
+    }
+}
+
+/// Wheel over the graph with Ctrl zooms the value axis `(lo, hi)` (turns auto-zoom off).
+fn wheel_zoom(app: &mut EffectcraftApp, ui: &egui::Ui, plot: Rect, (lo, hi): (f64, f64)) {
+    if ui.rect_contains_pointer(plot) {
+        let (dy, zoom) = ui.input(|i| (i.smooth_scroll_delta.y, i.modifiers.ctrl || i.modifiers.command));
+        if zoom && dy.abs() > 0.0 {
+            let k = (-dy as f64 / 200.0).exp();
+            let mid = (lo + hi) / 2.0;
+            app.ui.timeline.graph_auto_zoom = false;
+            app.ui.timeline.graph_range = Some((mid - (mid - lo) * k, mid + (hi - mid) * k));
+        }
+    }
+}
+
+/// Just opened, or the graph type changed (value and speed have different units): frame the
+/// graphs (Fit Selection to View, else Fit All Graphs to View).
+fn fit_on_open(app: &mut EffectcraftApp, ctx: &egui::Context, cs: &[Curve], tm: TMap, plot: Rect, speed: bool) {
+    let was_speed_id = egui::Id::unique("graph-was-speed");
+    let type_changed = ctx.data(|d| d.get_temp::<bool>(was_speed_id)).is_some_and(|was| was != speed);
+    ctx.data_mut(|d| d.insert_temp(was_speed_id, speed));
+    if ctx.data_mut(|d| d.remove_temp::<bool>(fit_pending_id())).unwrap_or(false) || type_changed {
+        if cs.iter().any(|c| c.keys.iter().any(|k| k.sel)) {
+            fit_selection(app, cs, tm, plot, speed);
+        } else {
+            fit_all(app);
+        }
+    }
+}
+
+/// Draw the Graph Editor into `area` (the right side of the Timeline) and queue edits.
+pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, view: GraphView, area: Rect, actions: &mut Actions) {
+    let GraphView { comp, ectx, tm } = view;
+    let t = app.tokens;
+    let ctx = ui.ctx().clone();
+    let footer_h = 28.0;
+    let plot = Rect::from_min_max(area.min + vec2(0.0, 6.0), pos2(area.max.x, area.max.y - footer_h));
+    let bar = Rect::from_min_max(pos2(area.min.x, area.max.y - footer_h), area.max);
+    // Background first so keys and handles (added later) sit on top for hit-testing.
+    let bg = ui.interact(plot, egui::Id::unique("graph-bg"), Sense::click_and_drag());
+    p.rect_filled(area, 0.0, Color32::from_rgb(0x1d, 0x1d, 0x1d));
+    app.auto.add("timeline.graph", plot, &app.ui.timeline.graph_mode.clone());
+    let speed = speed_graph(app, comp);
+    let cs = curves(app, comp, ectx, tm, plot, speed);
+    fit_on_open(app, &ctx, &cs, tm, plot, speed);
+
+    // Vertical range: auto-zoom to the curves + handles, or the stored manual range.
+    let auto = auto_range(&cs, speed);
     // While a key or handle is being dragged the scale stays put (no feedback loop).
     let drag_id = egui::Id::unique("graph-dragging");
     let dragging = ctx.data(|d| d.get_temp::<bool>(drag_id)).unwrap_or(false) && ctx.input(|i| i.pointer.any_down());
@@ -351,32 +451,8 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
         );
     }
 
-    // Show Reference Graph: the other graph type, faint, scaled to the plot.
     if app.ui.timeline.graph_reference && !cs.is_empty() {
-        let other = curves(app, comp, ectx, tm, plot, !speed);
-        let (mut rlo, mut rhi) = (f64::INFINITY, f64::NEG_INFINITY);
-        for c in &other {
-            for (_, v) in &c.pts {
-                rlo = rlo.min(*v);
-                rhi = rhi.max(*v);
-            }
-        }
-        if rlo.is_finite() {
-            let span = (rhi - rlo).max(1e-9);
-            let lines: Vec<(Color32, Vec<Pos2>)> = other
-                .iter()
-                .map(|c| {
-                    (
-                        c.color,
-                        c.pts
-                            .iter()
-                            .map(|(ct, v)| pos2(tm.x(*ct), plot.max.y - ((v - rlo) / span) as f32 * plot.height() * 0.9 - plot.height() * 0.05))
-                            .collect(),
-                    )
-                })
-                .collect();
-            super::graph_tools::reference_graph(&pc, plot, &lines);
-        }
+        reference_graph(app, view, plot, speed, &pc);
     }
     // Curves.
     for c in &cs {
@@ -394,6 +470,7 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
     let mut key_screens: Vec<(serde_json::Value, Pos2)> = vec![];
     for c in &cs {
         let (lid, uid, d) = (c.layer.id, c.prop.uid, c.dim);
+        let unlocked = !c.layer.switches.locked;
         for k in &c.keys {
             let kp = pos2(tm.x(k.t), ymap(k.v));
             // In the speed graph an end key rises with the handle being dragged; skipping it once it
@@ -415,9 +492,10 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
                 app.auto.add(&format!("timeline.graph.handle.{uid}.{d}.{}.{side}", k.idx), hr, "Bezier handle");
                 // The same side's handles of every selected key move with it, by as much as the
                 // pointer moved (After Effects), in one undo step.
-                if hresp.drag_started() {
+                if unlocked && hresp.drag_started() {
                     let grabs: Vec<HandleGrab> = cs
                         .iter()
+                        .filter(|c2| !c2.layer.switches.locked)
                         .flat_map(|c2| {
                             c2.keys.iter().flat_map(move |k2| {
                                 k2.handles.iter().filter(|h2| h2.out == h.out).map(move |h2| HandleGrab {
@@ -437,7 +515,8 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
                     let press = ui.input(|i| i.pointer.press_origin()).unwrap_or(hp);
                     ctx.data_mut(|dd| dd.insert_temp::<HandleDrag>(handle_drag_id(), (press, grabs)));
                 }
-                if hresp.dragged()
+                if unlocked
+                    && hresp.dragged()
                     && let Some(pt) = hresp.interact_pointer_pos()
                     && let Some((press, grabs)) = ctx.data(|dd| dd.get_temp::<HandleDrag>(handle_drag_id()))
                 {
@@ -460,15 +539,15 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
                 }
             }
             // The key itself.
-            let col = if k.sel { t.keyframe_selected } else { Color32::from_gray(0xe0) };
+            let (col, edge) = key_colors(&t, c.color, k);
             pc.rect_filled(Rect::from_center_size(kp, vec2(7.0, 7.0)), 0.0, col);
-            pc.rect_stroke(Rect::from_center_size(kp, vec2(7.0, 7.0)), 0.0, Stroke::new(1.0, c.color), StrokeKind::Outside);
+            pc.rect_stroke(Rect::from_center_size(kp, vec2(7.0, 7.0)), 0.0, Stroke::new(1.0, edge), StrokeKind::Outside);
             let kr = Rect::from_center_size(kp, vec2(11.0, 11.0));
             let kresp = ui.interact(kr, egui::Id::unique(("gkey", uid, d, k.idx)), Sense::click_and_drag());
             app.auto.add(&format!("timeline.graph.key.{uid}.{d}.{}", k.idx), kr, &c.prop.name);
             let mods = ui.input(|i| i.modifiers);
             let key = &c.prop.keys[k.idx];
-            if kresp.clicked() && mods.command {
+            if unlocked && kresp.clicked() && mods.command {
                 // Ctrl+click: Linear ↔ Auto Bezier; Ctrl+Alt+click: Hold on / off (as in the Timeline).
                 actions.push(("keys.select".into(), json!({"keys": [kjson.clone()]})));
                 if mods.alt {
@@ -477,20 +556,22 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
                     let linear = key.in_interp == Interp::Linear && key.out_interp == Interp::Linear;
                     actions.push(("keys.interpolation".into(), json!({"interpolation": if linear { "autoBezier" } else { "linear" }})));
                 }
-            } else if kresp.clicked() && mods.shift {
+            } else if unlocked && kresp.clicked() && mods.shift {
                 actions.push(("keys.select".into(), json!({"keys": [kjson.clone()], "toggle": true})));
-            } else if (kresp.clicked() || kresp.drag_started()) && !k.sel {
+            } else if unlocked && (kresp.clicked() || kresp.drag_started() || kresp.secondary_clicked()) && !k.sel {
                 actions.push(("keys.select".into(), json!({"keys": [kjson.clone()], "add": mods.shift})));
             }
             // A drag moves every selected key, by how far the pointer went from where the button
             // went down (the key doesn't jump under the pointer); Shift keeps it to the time or
             // the value axis, whichever moved more.
-            if kresp.drag_started()
+            if unlocked
+                && kresp.drag_started()
                 && let Some(o) = ui.input(|i| i.pointer.press_origin())
             {
                 ctx.data_mut(|dd| dd.insert_temp(key_grab_id(), KeyGrab { press: o, t: k.t }));
             }
-            if kresp.dragged()
+            if unlocked
+                && kresp.dragged()
                 && let Some(pt) = kresp.interact_pointer_pos()
                 && let Some(g) = ctx.data(|dd| dd.get_temp::<KeyGrab>(key_grab_id()))
             {
@@ -511,42 +592,26 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
                 ctx.data_mut(|dd| dd.insert_temp(drag_id, false));
                 actions.push(("__endMerge".into(), json!({})));
             }
+            // Right-click: the Timeline's key menu, with the same commands.
+            crate::widgets::context_menu(&kresp, |ui| super::timeline::key_menu(ui, app, c.layer, c.prop, key, k.sel, actions));
         }
     }
 
     super::graph_tools::transform_box(app, ui, &pc, &sel_keys, tm, &ymap, &vmap, speed, true, actions);
 
-    // Background: click deselects keys, drag box-selects.
-    if bg.clicked() {
-        actions.push(("keys.select".into(), json!({"keys": []})));
-    }
-    if bg.dragged()
-        && let (Some(o), Some(cur)) = (ctx.input(|i| i.pointer.press_origin()), bg.interact_pointer_pos())
-    {
-        let br = Rect::from_two_pos(o, cur);
-        pc.rect_filled(br, 0.0, t.accent.gamma_multiply(0.12));
-        pc.rect_stroke(br, 0.0, Stroke::new(1.0, t.accent), StrokeKind::Middle);
-        ctx.data_mut(|d| d.insert_temp(egui::Id::unique("graph-box"), br));
-    }
-    if bg.drag_stopped()
-        && let Some(br) = ctx.data(|d| d.get_temp::<Rect>(egui::Id::unique("graph-box")))
-    {
-        ctx.data_mut(|d| d.remove::<Rect>(egui::Id::unique("graph-box")));
-        let keys: Vec<serde_json::Value> = key_screens.iter().filter(|(_, sp)| br.contains(*sp)).map(|(k, _)| k.clone()).collect();
-        actions.push(("keys.select".into(), json!({"keys": keys, "add": ui.input(|i| i.modifiers.shift)})));
-    }
-    // Wheel over the graph with Alt/Ctrl zooms the value axis (turns auto-zoom off).
-    if ui.rect_contains_pointer(plot) {
-        let (dy, zoom) = ui.input(|i| (i.smooth_scroll_delta.y, i.modifiers.ctrl || i.modifiers.command));
-        if zoom && dy.abs() > 0.0 {
-            let k = (-dy as f64 / 200.0).exp();
-            let mid = (lo + hi) / 2.0;
-            app.ui.timeline.graph_auto_zoom = false;
-            app.ui.timeline.graph_range = Some((mid - (mid - lo) * k, mid + (hi - mid) * k));
-        }
+    box_select(ui, &pc, &bg, &key_screens, t.accent, actions);
+    wheel_zoom(app, ui, plot, (lo, hi));
+    if button_bar(app, ui, p, comp, bar, speed, actions) {
+        fit_selection(app, &cs, tm, plot, speed);
     }
+}
 
-    // Button bar.
+/// The footer button bar: graph type, display toggles, fit, snap and keyframe interpolation.
+/// Returns whether Fit Selection was pressed.
+fn button_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, comp: &Comp, bar: Rect, speed: bool, actions: &mut Actions) -> bool {
+    let t = app.tokens;
+    let ctx = ui.ctx().clone();
+    let mut fit_sel = false;
     p.rect_filled(bar, 0.0, t.panel_bg);
     p.line_segment([bar.left_top(), bar.right_top()], Stroke::new(1.0, t.separator));
     let y = bar.center().y;
@@ -559,48 +624,71 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
         p,
         &mut buttons,
         y,
-        "Auto",
-        auto_type,
-        "autoSelectGraphType",
-        "Auto-Select Graph Type (speed graph for spatial properties, else value graph)",
+        BarBtn {
+            label: "Auto",
+            on: auto_type,
+            id: "autoSelectGraphType",
+            tip: "Auto-Select Graph Type (speed graph for spatial properties, else value graph)",
+        },
     ) {
         app.ui.timeline.graph_mode = if auto_type { if speed { "speed" } else { "value" } } else { "auto" }.into();
     }
     // Choosing a graph type turns Auto-Select off, as in After Effects.
-    if text_button(app, ui, p, &mut buttons, y, "Value", !speed, "valueGraph", "Edit Value Graph") {
+    if text_button(app, ui, p, &mut buttons, y, BarBtn { label: "Value", on: !speed, id: "valueGraph", tip: "Edit Value Graph" }) {
         app.ui.timeline.graph_mode = "value".into();
     }
-    if text_button(app, ui, p, &mut buttons, y, "Speed", speed, "speedGraph", "Edit Speed Graph") {
+    if text_button(app, ui, p, &mut buttons, y, BarBtn { label: "Speed", on: speed, id: "speedGraph", tip: "Edit Speed Graph" }) {
         app.ui.timeline.graph_mode = "speed".into();
     }
     buttons.x += 6.0;
-    if text_button(app, ui, p, &mut buttons, y, "Selected", show_sel, "showSelected", "Show Selected Properties (else all animated properties)") {
+    if text_button(
+        app,
+        ui,
+        p,
+        &mut buttons,
+        y,
+        BarBtn { label: "Selected", on: show_sel, id: "showSelected", tip: "Show Selected Properties (else all animated properties)" },
+    ) {
         app.ui.timeline.graph_show_selected = !show_sel;
     }
-    if text_button(app, ui, p, &mut buttons, y, "Auto-zoom", auto_on, "autoZoom", "Auto-zoom graph height") {
+    if text_button(app, ui, p, &mut buttons, y, BarBtn { label: "Auto-zoom", on: auto_on, id: "autoZoom", tip: "Auto-zoom graph height" }) {
         app.ui.timeline.graph_auto_zoom = !auto_on;
     }
-    if text_button(app, ui, p, &mut buttons, y, "Fit", false, "fit", "Fit all graphs to view") {
+    if text_button(app, ui, p, &mut buttons, y, BarBtn { label: "Fit", on: false, id: "fit", tip: "Fit all graphs to view" }) {
         fit_all(app);
     }
-    if text_button(app, ui, p, &mut buttons, y, "Fit Selection", false, "fitSelection", "Fit selection to view") {
-        fit_selection(app, &cs, tm, plot, speed);
+    if text_button(app, ui, p, &mut buttons, y, BarBtn { label: "Fit Selection", on: false, id: "fitSelection", tip: "Fit selection to view" }) {
+        fit_sel = true;
     }
     buttons.x += 6.0;
     let (snap, reference, tbox) = (app.ui.timeline.graph_snap, app.ui.timeline.graph_reference, app.ui.timeline.graph_transform_box);
-    if text_button(app, ui, p, &mut buttons, y, "Snap", snap, "snap", "Snap (key drags snap to the current time and other keys)") {
+    if text_button(app, ui, p, &mut buttons, y, BarBtn { label: "Snap", on: snap, id: "snap", tip: "Snap (key drags snap to the current time and other keys)" })
+    {
         app.ui.timeline.graph_snap = !snap;
     }
-    if text_button(app, ui, p, &mut buttons, y, "Reference", reference, "reference", "Show Reference Graph") {
+    if text_button(app, ui, p, &mut buttons, y, BarBtn { label: "Reference", on: reference, id: "reference", tip: "Show Reference Graph" }) {
         app.ui.timeline.graph_reference = !reference;
     }
-    if text_button(app, ui, p, &mut buttons, y, "Transform Box", tbox, "transformBox", "Show Transform Box when multiple keys are selected") {
+    if text_button(
+        app,
+        ui,
+        p,
+        &mut buttons,
+        y,
+        BarBtn { label: "Transform Box", on: tbox, id: "transformBox", tip: "Show Transform Box when multiple keys are selected" },
+    ) {
         app.ui.timeline.graph_transform_box = !tbox;
     }
     buttons.x += 6.0;
     let pos_sel = app.session.state.selected_props.iter().find_map(|(l, u)| super::timeline::is_position(comp.layer(*l)?, *u).then_some(l.0));
-    if text_button(app, ui, p, &mut buttons, y, "Separate Dimensions", false, "separateDimensions", "Separate Dimensions (Position)")
-        && let Some(l) = pos_sel.or(app.session.state.selected_layers.first().map(|l| l.0))
+    if text_button(
+        app,
+        ui,
+        p,
+        &mut buttons,
+        y,
+        BarBtn { label: "Separate Dimensions", on: false, id: "separateDimensions", tip: "Separate Dimensions (Position)" },
+    ) && let Some(l) = pos_sel.or(app.session.state.selected_layers.first().map(|l| l.0))
     {
         actions.push(("prop.separateDimensions".into(), json!({"layer": l})));
     }
@@ -614,11 +702,12 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
         ("Ease Out", "keys.easyEaseOut", json!({}), "Easy Ease Out (Ctrl+Shift+F9)"),
     ] {
         let id = cmd.trim_start_matches("keys.").to_string() + label.split_whitespace().next().unwrap_or("");
-        if text_button(app, ui, p, &mut buttons, y, label, false, &id, tip) {
+        if text_button(app, ui, p, &mut buttons, y, BarBtn { label, on: false, id: &id, tip }) {
             actions.push((cmd.into(), params));
         }
     }
     buttons.more(app, ui, p, bar);
+    fit_sel
 }
 
 /// Fit All Graphs to View: the whole comp in time, auto-zoomed values.
@@ -627,6 +716,8 @@ fn fit_all(app: &mut EffectcraftApp) {
     app.ui.timeline.pps = None;
 }
 
+/// The `egui::Id` of the one-shot flag [`track_open`] sets when the Graph Editor is switched on,
+/// so [`show`] frames all graphs on its next pass, once the plot rectangle is known.
 fn fit_pending_id() -> egui::Id {
     egui::Id::unique("graph-fit-pending")
 }
@@ -739,6 +830,8 @@ struct KeyGrab {
     t: f64,
 }
 
+/// The `egui::Id` of the key drag in progress ([`KeyGrab`]): where the button went down and the
+/// grabbed key's comp time when it did.
 fn key_grab_id() -> egui::Id {
     egui::Id::unique("graph-key-grab")
 }
@@ -786,6 +879,8 @@ impl HandleGrab {
 /// A handle drag: where the button went down, and the handles that move.
 type HandleDrag = (Pos2, Vec<HandleGrab>);
 
+/// The `egui::Id` of the Bezier handle drag in progress ([`HandleDrag`]): the press position and
+/// the handles the drag moves.
 fn handle_drag_id() -> egui::Id {
     egui::Id::unique("graph-handle-drag")
 }
diff --git a/crates/ui-egui/src/panels/graph_tools.rs b/crates/ui-egui/src/panels/graph_tools.rs
index ee5d7543f..7950d4a66 100644
--- a/crates/ui-egui/src/panels/graph_tools.rs
+++ b/crates/ui-egui/src/panels/graph_tools.rs
@@ -34,6 +34,7 @@ struct BoxDrag {
     last: [f64; 2],
 }
 
+/// The `egui::Id` of the transform-box drag in progress ([`BoxDrag`]).
 fn box_id() -> egui::Id {
     egui::Id::unique("graph-transform-box")
 }
@@ -254,6 +255,7 @@ struct AltScale {
     span: Option<f64>,
 }
 
+/// The `egui::Id` of the Timeline Alt-drag group scale in progress ([`AltScale`]).
 fn alt_id() -> egui::Id {
     egui::Id::unique("timeline-alt-scale")
 }
diff --git a/crates/ui-egui/src/panels/info.rs b/crates/ui-egui/src/panels/info.rs
index a075087d3..86a1e6444 100644
--- a/crates/ui-egui/src/panels/info.rs
+++ b/crates/ui-egui/src/panels/info.rs
@@ -6,6 +6,11 @@ use egui::{Align2, Color32, Rect, pos2, vec2};
 use crate::theme::Tokens;
 use crate::{EffectcraftApp, widgets};
 
+/// The Info panel: the colour and alpha under the pointer (sampled from the shown viewer frame,
+/// read back for GPU frames) with its position and a swatch, then the selected layers, the current
+/// time, the duration/In/Out of a single selected layer, the achieved preview frame rate, the
+/// render time and queue state (when the preference asks for it) and the selected keyframe's
+/// property, time and value. Read-only: it draws and scrolls but changes no document state.
 pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let p = ui.painter().with_clip_rect(rect);
diff --git a/crates/ui-egui/src/panels/key_dialogs.rs b/crates/ui-egui/src/panels/key_dialogs.rs
index 73f76aaaa..2a5579837 100644
--- a/crates/ui-egui/src/panels/key_dialogs.rs
+++ b/crates/ui-egui/src/panels/key_dialogs.rs
@@ -125,8 +125,16 @@ fn buttons(ui: &mut egui::Ui, app: &mut EffectcraftApp, t: &Tokens, prefix: &str
     (ok, cancel)
 }
 
-fn drag(ui: &mut egui::Ui, app: &mut EffectcraftApp, id: &str, v: &mut f64, speed: f64, range: std::ops::RangeInclusive<f64>, suffix: &str, enabled: bool) {
-    let r = ui.add_enabled(enabled, crate::widgets::drag_value(egui::DragValue::new(v).speed(speed).range(range).max_decimals(2).suffix(suffix)));
+/// Drag speed, clamp range and suffix of a [`drag`] field.
+struct DragSpec<'a> {
+    speed: f64,
+    range: std::ops::RangeInclusive<f64>,
+    suffix: &'a str,
+}
+
+fn drag(ui: &mut egui::Ui, app: &mut EffectcraftApp, id: &str, v: &mut f64, spec: DragSpec, enabled: bool) {
+    let r =
+        ui.add_enabled(enabled, crate::widgets::drag_value(egui::DragValue::new(v).speed(spec.speed).range(spec.range).max_decimals(2).suffix(spec.suffix)));
     app.auto.add(id, r.rect, id);
 }
 
@@ -147,20 +155,20 @@ pub fn velocity(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                     ui.horizontal(|ui| {
                         ui.label(tr("Speed:"));
                         let v = if out { &mut d.out_speed[dim] } else { &mut d.in_speed[dim] };
-                        drag(ui, app, &format!("dialog.velocity.{side}Speed.{dim}"), v, 1.0, -1e7..=1e7, "", enabled);
+                        drag(ui, app, &format!("dialog.velocity.{side}Speed.{dim}"), v, DragSpec { speed: 1.0, range: -1e7..=1e7, suffix: "" }, enabled);
                         ui.label(egui::RichText::new(&d.units).color(t.text_dim));
                     });
                     ui.horizontal(|ui| {
                         ui.label(tr("Influence:"));
                         let v = if out { &mut d.out_inf[dim] } else { &mut d.in_inf[dim] };
-                        drag(ui, app, &format!("dialog.velocity.{side}Influence.{dim}"), v, 0.2, 0.1..=100.0, " %", enabled);
+                        drag(ui, app, &format!("dialog.velocity.{side}Influence.{dim}"), v, DragSpec { speed: 0.2, range: 0.1..=100.0, suffix: " %" }, enabled);
                     });
                     ui.end_row();
                 }
             });
             ui.add_space(8.0);
         }
-        let r = ui.checkbox(&mut d.continuous, tr("Continuous (Lock Outgoing to Incoming)"));
+        let r = crate::widgets::labelled_checkbox(ui, &mut d.continuous, tr("Continuous (Lock Outgoing to Incoming)"));
         app.auto.add("dialog.velocity.continuous", r.rect, "Continuous");
         if d.continuous {
             d.out_speed = d.in_speed.clone();
@@ -191,7 +199,7 @@ pub fn velocity(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
 fn combo(ui: &mut egui::Ui, app: &mut EffectcraftApp, id: &str, sel: &mut usize, opts: &[&str], enabled: bool) {
     ui.add_enabled_ui(enabled, |ui| {
         // The options are the English source strings; the automation id and label stay English.
-        let r = egui::ComboBox::from_id_salt(id).width(200.0).selected_text(tr(opts[*sel])).show_ui(ui, |ui| {
+        let r = craft_ui::ComboBox::from_id_salt(id).width(200.0).selected_text(tr(opts[*sel])).show_ui(ui, |ui| {
             for (i, o) in opts.iter().enumerate() {
                 ui.selectable_value(sel, i, tr(o));
             }
@@ -254,14 +262,14 @@ pub fn time_stretch(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             ui.end_row();
             ui.label(tr("Stretch Factor:"));
             let before = d.percent;
-            drag(ui, app, "dialog.timeStretch.percent", &mut d.percent, 0.5, -10000.0..=10000.0, " %", true);
+            drag(ui, app, "dialog.timeStretch.percent", &mut d.percent, DragSpec { speed: 0.5, range: -10000.0..=10000.0, suffix: " %" }, true);
             if (before - d.percent).abs() > 1e-9 && d.orig_percent.abs() > 1e-9 {
                 d.duration = d.orig_duration * d.percent.abs() / d.orig_percent.abs();
             }
             ui.end_row();
             ui.label(tr("New Duration:"));
             let before = d.duration;
-            drag(ui, app, "dialog.timeStretch.duration", &mut d.duration, 0.05, 0.01..=100000.0, " s", true);
+            drag(ui, app, "dialog.timeStretch.duration", &mut d.duration, DragSpec { speed: 0.05, range: 0.01..=100000.0, suffix: " s" }, true);
             if (before - d.duration).abs() > 1e-9 && d.orig_duration > 1e-9 {
                 d.percent = d.orig_percent.signum() * d.orig_percent.abs() * d.duration / d.orig_duration;
             }
diff --git a/crates/ui-egui/src/panels/layer_panel.rs b/crates/ui-egui/src/panels/layer_panel.rs
index 2ebb2dee0..8e4f3502f 100644
--- a/crates/ui-egui/src/panels/layer_panel.rs
+++ b/crates/ui-egui/src/panels/layer_panel.rs
@@ -40,10 +40,14 @@ struct Tex {
     rect: [f64; 4],
 }
 
+/// The `egui::Id` of the cached render of the layer shown in this panel ([`Tex`]), with the key
+/// the image was made from.
 fn tex_id() -> egui::Id {
     egui::Id::unique("layer-panel-tex")
 }
 
+/// The `egui::Id` under which the panel's last Fit magnification is kept, so View ▸ Zoom In/Out
+/// can start from it (see [`last_fit`]).
 fn fit_id() -> egui::Id {
     egui::Id::unique("layer-panel-fit")
 }
@@ -83,6 +87,157 @@ fn default_view(layer: &Layer, tool: Tool) -> usize {
     }
 }
 
+/// The layer's rendered view `view` at `scale`, cached in egui's temp data per revision, layer,
+/// time, view and scale (the layer cache makes repeats cheap).
+fn render_tex(
+    app: &EffectcraftApp,
+    ctx: &egui::Context,
+    cid: effectcraft_engine::project::ItemId,
+    comp: &effectcraft_engine::project::Comp,
+    layer: &Layer,
+    view: usize,
+    scale: f64,
+) -> Option<Tex> {
+    let time = app.session.time();
+    let key = (app.session.revision, layer.id.0, time.0, view, (scale * 1000.0) as u32);
+    let cached: Option<Tex> = ctx.data(|d| d.get_temp(tex_id()));
+    match cached {
+        Some(c) if c.key == key => Some(c),
+        _ => {
+            let ectx = EvalCtx {
+                project: &app.session.project,
+                comp_id: cid,
+                comp,
+                time,
+                expr: app.session.expr.as_deref(),
+                footage: None,
+                property_overrides: &[],
+                media_overrides: &[],
+            };
+            let mut r = Renderer::new(&app.session.project, &*app.session.footage, RenderOpts { scale, ..Default::default() });
+            r.expr = app.session.expr.as_deref();
+            r.cache = Some(&app.session.layer_cache);
+            r.layer_input(&ectx, layer, view).map(|buf| {
+                let img = crate::frames::to_color_image(&buf.img);
+                let x0 = -buf.offset[0] / buf.scale;
+                let y0 = -buf.offset[1] / buf.scale;
+                let rect = [x0, y0, x0 + buf.img.width as f64 / buf.scale, y0 + buf.img.height as f64 / buf.scale];
+                let tex = crate::frames::load_fitted(ctx, "layer-panel", img, egui::TextureOptions::LINEAR);
+                let c = Tex { key, tex, rect };
+                ctx.data_mut(|d| d.insert_temp(tex_id(), c.clone()));
+                c
+            })
+        }
+    }
+}
+
+/// What [`paint_stroke`] needs about the brush and the layer <-> screen mapping.
+#[derive(Clone, Copy)]
+struct StrokeCtx<'a> {
+    layer: u64,
+    kind: &'a str,
+    zoom: f64,
+    did: egui::Id,
+    diameter: f64,
+    color: [f64; 4],
+    to_layer: &'a dyn Fn(Pos2) -> [f64; 2],
+    to_screen: &'a dyn Fn([f64; 2]) -> Pos2,
+}
+
+/// Records a paint stroke's layer-space points while dragging, previews it, and runs
+/// `paint.stroke` on release (or on a click).
+fn paint_stroke(app: &mut EffectcraftApp, ui: &egui::Ui, painter: &egui::Painter, resp: &egui::Response, sc: &StrokeCtx) {
+    let StrokeCtx { layer, kind, zoom, did, diameter, color, to_layer, to_screen } = *sc;
+    let ctx = ui.ctx().clone();
+    let now = ui.input(|i| i.time);
+    if resp.drag_started()
+        && let Some(pos) = ui.input(|i| i.pointer.press_origin()).or(resp.interact_pointer_pos())
+    {
+        ctx.data_mut(|d| d.insert_temp(did, Drag { layer, points: vec![to_layer(pos)], started: now }));
+    }
+    if let Some(mut d) = ctx.data(|d| d.get_temp::<Drag>(did)) {
+        if let Some(pos) = resp.interact_pointer_pos() {
+            let lp = to_layer(pos);
+            let last = d.points.last().copied().unwrap_or(lp);
+            if (lp[0] - last[0]).hypot(lp[1] - last[1]) * zoom >= 1.0 {
+                d.points.push(lp);
+                ctx.data_mut(|dd| dd.insert_temp(did, d.clone()));
+            }
+        }
+        // Live preview of the stroke.
+        let col = if kind == "eraser" {
+            Color32::from_white_alpha(140)
+        } else {
+            Color32::from_rgba_unmultiplied((color[0] * 255.0) as u8, (color[1] * 255.0) as u8, (color[2] * 255.0) as u8, 200)
+        };
+        let width = ((diameter * zoom) as f32).max(1.0);
+        let pts: Vec<Pos2> = d.points.iter().map(|q| to_screen(*q)).collect();
+        if pts.len() == 1 {
+            painter.circle_filled(pts[0], width / 2.0, col);
+        } else {
+            painter.add(egui::Shape::line(pts, Stroke::new(width, col)));
+        }
+        if resp.drag_stopped() {
+            ctx.data_mut(|dd| dd.remove::<Drag>(did));
+            let pts: Vec<[f64; 2]> = d.points.clone();
+            let r = app.session.execute("paint.stroke", json!({"layer": d.layer, "kind": kind, "points": pts, "duration": (now - d.started).max(0.0)}));
+            if let Err(e) = r {
+                app.ui.status = e.to_string();
+            }
+        }
+    }
+    if resp.clicked()
+        && let Some(pos) = resp.interact_pointer_pos()
+    {
+        let r = app.session.execute("paint.stroke", json!({"layer": layer, "kind": kind, "points": [to_layer(pos)], "duration": 0.0}));
+        if let Err(e) = r {
+            app.ui.status = e.to_string();
+        }
+    }
+}
+
+/// The bottom bar: the magnification menu and the View menu over `names` (Masks, then the
+/// effects). Returns where the View dropdown ends.
+fn bottom_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, bar: Rect, names: &[String], view: usize, (zoom, fit): (f64, f32)) -> f32 {
+    let t = app.tokens;
+    p.rect_filled(bar, 0.0, t.panel_bg);
+    let mr = Rect::from_min_size(pos2(bar.min.x + 8.0, bar.center().y - 10.0), vec2(80.0, 20.0));
+    if let Some((z, up)) = super::viewer_tools::magnification_menu(
+        app,
+        ui,
+        mr,
+        "layer-mag",
+        "layerPanel.magnification",
+        "layerMagnification",
+        zoom as f32,
+        app.ui.layer_zoom,
+        false,
+    ) {
+        // The Layer panel keeps no fit mode: Fit up to 100% is the fit, at most 100 %.
+        app.ui.layer_zoom = if up { Some(fit.min(1.0 / ui.ctx().pixels_per_point())) } else { z };
+        app.ui.layer_pan = [0.0, 0.0];
+    }
+    let vx = mr.max.x + 10.0;
+    p.text(pos2(vx, bar.center().y), Align2::LEFT_CENTER, tr("View:"), Tokens::ui(12.0), t.text_dim);
+    let vr = Rect::from_min_size(pos2(vx + 36.0, bar.center().y - 10.0), vec2(150.0, 20.0));
+    let pop = egui::Id::unique("layer-view-pop");
+    if widgets::dropdown(ui, vr, &names[view.min(names.len() - 1)], &t, egui::Id::unique("layer-view")).clicked() {
+        widgets::open_popup(ui, pop);
+    }
+    app.auto.add("layerPanel.view", vr, "View");
+    if let Some(i) = widgets::popup_menu(ui, pop, vr.left_bottom(), names, Some(view)) {
+        app.ui.layer_view = Some(i);
+    }
+    vr.max.x
+}
+
+/// The Layer panel: one layer in its own space with its masks and effects up to the View menu's
+/// choice, rendered synchronously at a zoom/pan the panel keeps (the last Fit magnification is
+/// published for the View menu). Wheel or pinch zooms about the pointer, the Hand tool or
+/// Space-drag pans, and the Zoom tool clicks zoom. The paint tools record a stroke's layer-space
+/// points while dragging and run `paint.stroke` on release (or on a click); Alt-click with the
+/// Clone Stamp sets its source. With a Roto Brush effect it hands the canvas to
+/// [`super::roto_tool`]. Without a current layer it shows how to open one.
 pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let ctx = ui.ctx().clone();
@@ -119,44 +274,17 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     };
     let origin = area.center() + pan - vec2((lw * zoom / 2.0) as f32, (lh * zoom / 2.0) as f32);
 
-    // Bottom bar: magnification and View menus.
-    p.rect_filled(bar, 0.0, t.panel_bg);
-    let mr = Rect::from_min_size(pos2(bar.min.x + 8.0, bar.center().y - 10.0), vec2(80.0, 20.0));
-    if let Some((z, up)) = super::viewer_tools::magnification_menu(
-        app,
-        ui,
-        mr,
-        "layer-mag",
-        "layerPanel.magnification",
-        "layerMagnification",
-        zoom as f32,
-        app.ui.layer_zoom,
-        false,
-    ) {
-        // The Layer panel keeps no fit mode: Fit up to 100% is the fit, at most 100 %.
-        app.ui.layer_zoom = if up { Some(fit.min(1.0 / ui.ctx().pixels_per_point())) } else { z };
-        app.ui.layer_pan = [0.0, 0.0];
-    }
-    let vx = mr.max.x + 10.0;
-    p.text(pos2(vx, bar.center().y), Align2::LEFT_CENTER, tr("View:"), Tokens::ui(12.0), t.text_dim);
     let mut names = vec!["Masks".to_string()];
     if let Some(fx) = layer.effects() {
         names.extend(fx.groups().map(|g| g.name.clone()));
     }
-    let vr = Rect::from_min_size(pos2(vx + 36.0, bar.center().y - 10.0), vec2(150.0, 20.0));
-    let pop = egui::Id::unique("layer-view-pop");
-    if widgets::dropdown(ui, vr, &names[view.min(names.len() - 1)], &t, egui::Id::unique("layer-view")).clicked() {
-        widgets::open_popup(ui, pop);
-    }
-    app.auto.add("layerPanel.view", vr, "View");
-    if let Some(i) = widgets::popup_menu(ui, pop, vr.left_bottom(), &names, Some(view)) {
-        app.ui.layer_view = Some(i);
-    }
+    let vr_right = bottom_bar(app, ui, &p, bar, &names, view, (zoom, fit));
+
     let tc = super::timecode(&app.session, &comp, time);
     p.text(pos2(bar.max.x - 10.0, bar.center().y), Align2::RIGHT_CENTER, tc, Tokens::mono(12.0), t.timecode);
     // Roto Brush: view / Freeze buttons and the segmentation span bar.
     if roto.is_some() {
-        super::roto_tool::bar_buttons(app, ui, &p, bar, vr.max.x + 12.0, &layer);
+        super::roto_tool::bar_buttons(app, ui, &p, bar, vr_right + 12.0, &layer);
         let sb = Rect::from_min_max(pos2(rect.min.x, canvas_bottom), pos2(rect.max.x, bar.min.y));
         super::roto_tool::span_bar(app, ui, &p, sb, &comp, &layer);
     }
@@ -179,27 +307,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     } else {
         0.25
     };
-    let key = (app.session.revision, layer.id.0, time.0, view, (scale * 1000.0) as u32);
-    let cached: Option<Tex> = ctx.data(|d| d.get_temp(tex_id()));
-    let tex = match cached {
-        Some(c) if c.key == key => Some(c),
-        _ => {
-            let ectx = EvalCtx { project: &app.session.project, comp_id: cid, comp: &comp, time, expr: app.session.expr.as_deref(), footage: None };
-            let mut r = Renderer::new(&app.session.project, &*app.session.footage, RenderOpts { scale, ..Default::default() });
-            r.expr = app.session.expr.as_deref();
-            r.cache = Some(&app.session.layer_cache);
-            r.layer_input(&ectx, &layer, view).map(|buf| {
-                let img = crate::frames::to_color_image(&buf.img);
-                let x0 = -buf.offset[0] / buf.scale;
-                let y0 = -buf.offset[1] / buf.scale;
-                let rect = [x0, y0, x0 + buf.img.width as f64 / buf.scale, y0 + buf.img.height as f64 / buf.scale];
-                let tex = crate::frames::load_fitted(&ctx, "layer-panel", img, egui::TextureOptions::LINEAR);
-                let c = Tex { key, tex, rect };
-                ctx.data_mut(|d| d.insert_temp(tex_id(), c.clone()));
-                c
-            })
-        }
-    };
+    let tex = render_tex(app, &ctx, cid, &comp, &layer, view, scale);
     if let Some(tx) = &tex {
         let r = Rect::from_min_max(to_screen([tx.rect[0], tx.rect[1]]), to_screen([tx.rect[2], tx.rect[3]]));
         painter.image(tx.tex.id(), r, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
@@ -211,13 +319,17 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     app.auto.add("layerPanel.canvas", frame, &layer.name);
     app.auto.add("layerPanel.area", area, "Layer panel");
 
-    // Navigation (as the Composition panel): the wheel / pinch zooms around the pointer with any
-    // tool; the Hand tool or Space-drag pans and the Zoom tool clicks zoom in (Alt: out).
+    // Navigation (as the Composition panel): the wheel / pinch zooms around the pointer and a
+    // two-finger trackpad scroll pans with any tool; the Hand tool or Space-drag pans and the
+    // Zoom tool clicks zoom in (Alt: out).
     let hovered = ui.rect_contains_pointer(area);
     if let Some(hp) = ui.input(|i| i.pointer.hover_pos()).filter(|_| hovered) {
-        let scroll = ui.input(|i| i.smooth_scroll_delta.y + i.zoom_delta().ln() * 300.0);
-        if scroll.is_finite() && scroll.abs() > 0.1 {
-            zoom_at(app, area, [lw, lh], hp, to_layer(hp), zoom as f32 * (scroll / 300.0).exp());
+        let scroll = super::viewer_scroll(&ctx);
+        if (scroll.zoom - 1.0).abs() > 3e-4 {
+            zoom_at(app, area, [lw, lh], hp, to_layer(hp), zoom as f32 * scroll.zoom);
+        } else if scroll.pan != egui::Vec2::ZERO {
+            app.ui.layer_zoom.get_or_insert(zoom as f32);
+            app.ui.layer_pan = [pan.x + scroll.pan.x, pan.y + scroll.pan.y];
         }
     }
     // A middle-drag pans with any tool; painting and Roto Brush strokes don't run meanwhile.
@@ -260,7 +372,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     // Interaction: Roto Brush / Refine Edge.
     if app.ui.tool.roto_kind(false).is_some() {
-        super::roto_tool::interact(app, ui, &painter, area, &layer, zoom, &to_screen, &to_layer);
+        super::roto_tool::interact(app, ui, &painter, area, &layer, zoom, super::roto_tool::LayerXform { to_screen: &to_screen, to_layer: &to_layer });
         return;
     }
     // Interaction: paint tools.
@@ -303,7 +415,6 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         painter.line_segment([s - vec2(0.0, 6.0), s + vec2(0.0, 6.0)], Stroke::new(1.0, Color32::WHITE));
     }
     let mods = ui.input(|i| i.modifiers);
-    let now = ui.input(|i| i.time);
     // Alt/Option-click with the Clone Stamp sets the source.
     if app.ui.tool == Tool::Clone
         && mods.alt
@@ -317,49 +428,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     if let Some(kind) = kind
         && !mods.alt
     {
-        if resp.drag_started()
-            && let Some(pos) = ui.input(|i| i.pointer.press_origin()).or(resp.interact_pointer_pos())
-        {
-            ctx.data_mut(|d| d.insert_temp(did, Drag { layer: layer.id.0, points: vec![to_layer(pos)], started: now }));
-        }
-        if let Some(mut d) = ctx.data(|d| d.get_temp::<Drag>(did)) {
-            if let Some(pos) = resp.interact_pointer_pos() {
-                let lp = to_layer(pos);
-                let last = d.points.last().copied().unwrap_or(lp);
-                if (lp[0] - last[0]).hypot(lp[1] - last[1]) * zoom >= 1.0 {
-                    d.points.push(lp);
-                    ctx.data_mut(|dd| dd.insert_temp(did, d.clone()));
-                }
-            }
-            // Live preview of the stroke.
-            let col = if kind == "eraser" {
-                Color32::from_white_alpha(140)
-            } else {
-                Color32::from_rgba_unmultiplied((o.color[0] * 255.0) as u8, (o.color[1] * 255.0) as u8, (o.color[2] * 255.0) as u8, 200)
-            };
-            let width = ((o.diameter * zoom) as f32).max(1.0);
-            let pts: Vec<Pos2> = d.points.iter().map(|q| to_screen(*q)).collect();
-            if pts.len() == 1 {
-                painter.circle_filled(pts[0], width / 2.0, col);
-            } else {
-                painter.add(egui::Shape::line(pts, Stroke::new(width, col)));
-            }
-            if resp.drag_stopped() {
-                ctx.data_mut(|dd| dd.remove::<Drag>(did));
-                let pts: Vec<[f64; 2]> = d.points.clone();
-                let r = app.session.execute("paint.stroke", json!({"layer": d.layer, "kind": kind, "points": pts, "duration": (now - d.started).max(0.0)}));
-                if let Err(e) = r {
-                    app.ui.status = e.to_string();
-                }
-            }
-        }
-        if resp.clicked()
-            && let Some(pos) = resp.interact_pointer_pos()
-        {
-            let r = app.session.execute("paint.stroke", json!({"layer": layer.id.0, "kind": kind, "points": [to_layer(pos)], "duration": 0.0}));
-            if let Err(e) = r {
-                app.ui.status = e.to_string();
-            }
-        }
+        let stroke = StrokeCtx { layer: layer.id.0, kind, zoom, did, diameter: o.diameter, color: o.color, to_layer: &to_layer, to_screen: &to_screen };
+        paint_stroke(app, ui, &painter, &resp, &stroke);
     }
 }
diff --git a/crates/ui-egui/src/panels/layer_styles_dialog.rs b/crates/ui-egui/src/panels/layer_styles_dialog.rs
index e687dffa1..09b775e30 100644
--- a/crates/ui-egui/src/panels/layer_styles_dialog.rs
+++ b/crates/ui-egui/src/panels/layer_styles_dialog.rs
@@ -7,7 +7,8 @@
 use crate::i18n::tr;
 use effectcraft_engine::commands::text_edit::active_editor_snapshot;
 use effectcraft_engine::keyframe::Value as KV;
-use effectcraft_engine::project::styles::{BLENDING, STYLES};
+use effectcraft_engine::project::build::Ids;
+use effectcraft_engine::project::styles::{BLENDING, GROUP, STYLES, blending_options};
 use effectcraft_engine::project::{Layer, LayerId, ParamUi, Property};
 use egui::vec2;
 use serde_json::{Value, json};
@@ -22,12 +23,15 @@ pub struct LayerStyleState {
     pub selected: String,
     pub undo_mark: usize,
     checkpoint: Option<Checkpoint>,
+    /// The Gradient Editor opened from this dialog: closing it comes back here (#2057).
+    pub gradient_open: bool,
 }
 
+/// The project and undo history as a dialog found them, for a Cancel that rolls its live edits back.
 #[derive(Clone)]
-struct Checkpoint {
-    project: std::sync::Arc<effectcraft_engine::project::Project>,
-    history: effectcraft_engine::history::History,
+pub(crate) struct Checkpoint {
+    pub(crate) project: std::sync::Arc<effectcraft_engine::project::Project>,
+    pub(crate) history: effectcraft_engine::history::History,
 }
 
 impl std::fmt::Debug for Checkpoint {
@@ -36,7 +40,7 @@ impl std::fmt::Debug for Checkpoint {
     }
 }
 
-fn checkpoint(app: &mut EffectcraftApp) -> Checkpoint {
+pub(crate) fn checkpoint(app: &mut EffectcraftApp) -> Checkpoint {
     app.session.history.merge_key = None;
     Checkpoint { project: app.session.project.clone(), history: app.session.history.clone() }
 }
@@ -56,12 +60,13 @@ pub fn open(app: &mut EffectcraftApp, params: &Value) -> Result<(), String> {
         return Err(format!("unknown layer style `{style}`"));
     }
     let checkpoint = checkpoint(app);
-    app.dialog_state.layer_style = LayerStyleState { layer, selected: style, undo_mark: app.session.history.undo.len(), checkpoint: Some(checkpoint) };
+    app.dialog_state.layer_style =
+        LayerStyleState { layer, selected: style, undo_mark: app.session.history.undo.len(), checkpoint: Some(checkpoint), gradient_open: false };
     app.dialog = Some(Dialog::LayerStyles);
     Ok(())
 }
 
-/// Menu routing: choosing one of the Layer ▸ Layer Styles ▸ <style> items (no parameters) adds
+/// Menu routing: choosing one of the Layer ▸ Layer Styles ▸ `<style>` items (no parameters) adds
 /// the style as usual and opens the dialog on it.
 pub fn route(app: &mut EffectcraftApp, id: &str, params: &Value) -> Result<bool, String> {
     let Some(style) = id.strip_prefix("layer.style.").filter(|s| STYLES.iter().any(|x| x.0 == *s)) else { return Ok(false) };
@@ -87,11 +92,11 @@ fn control(ui: &mut egui::Ui, p: &Property, v: &KV) -> Option<Value> {
     match (v, &p.ui) {
         (KV::Bool(b), _) => {
             let mut on = *b;
-            ui.checkbox(&mut on, "").changed().then(|| json!(on))
+            crate::widgets::labelled_checkbox(ui, &mut on, "").changed().then(|| json!(on))
         }
         (KV::Enum(i), ParamUi::Popup { options }) => {
             let mut sel = *i as usize;
-            egui::ComboBox::from_id_salt(("ls-popup", p.uid)).selected_text(options.get(sel).cloned().unwrap_or_default()).show_ui(ui, |ui| {
+            craft_ui::ComboBox::from_id_salt(("ls-popup", p.uid)).selected_text(options.get(sel).cloned().unwrap_or_default()).show_ui(ui, |ui| {
                 for (k, o) in options.iter().enumerate() {
                     ui.selectable_value(&mut sel, k, o);
                 }
@@ -116,10 +121,6 @@ fn control(ui: &mut egui::Ui, p: &Property, v: &KV) -> Option<Value> {
             let changed = crate::widgets::srgb_color_button(ui, &mut rgb).changed();
             changed.then(|| json!(rgb))
         }
-        (KV::Gradient(_), _) => {
-            ui.label(egui::RichText::new(tr("Edit in the Timeline")).weak());
-            None
-        }
         _ => {
             ui.label(egui::RichText::new(format!("{v:?}").chars().take(24).collect::<String>()).weak());
             None
@@ -134,6 +135,10 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
     };
     let lid = l.id.0;
     let styles = l.layer_styles().cloned();
+    // Shown only: its uids are never stored in the project.
+    let mut next = app.session.project.next_id;
+    let blending_template =
+        if styles.is_none() && l.can_have_styles() { app.session.active_comp().map(|c| blending_options(&mut Ids(&mut next), &c.global_light)) } else { None };
     let sel = app.dialog_state.layer_style.selected.clone();
     let time = app.session.time();
     let lt = l.layer_time(time);
@@ -171,7 +176,7 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                             if id != BLENDING {
                                 let g = styles.as_ref().and_then(|s| s.sub(id));
                                 let mut on = g.is_some_and(|g| g.enabled);
-                                if ui.checkbox(&mut on, "").changed() {
+                                if crate::widgets::labelled_checkbox(ui, &mut on, "").changed() {
                                     if g.is_none() {
                                         actions.push(("layer.style.add".into(), json!({"layers": [lid], "style": id})));
                                     } else {
@@ -198,7 +203,10 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                 let head = ui.label(egui::RichText::new(name).font(Tokens::semibold(13.0)));
                 app.auto.add("dialog.layerStyle.page", head.rect, &sel);
                 ui.add_space(6.0);
-                let Some(g) = styles.as_ref().and_then(|s| s.sub(&sel)) else {
+                // A layer with no styles still shows Blending Options, with the values the Layer
+                // Styles group would start from; the first change creates the group (#1389).
+                let missing = blending_template.as_ref().filter(|_| sel == BLENDING && styles.is_none());
+                let Some(g) = styles.as_ref().and_then(|s| s.sub(&sel)).or(missing) else {
                     ui.label(egui::RichText::new(tr("Not applied: tick it in the list to add it.")).weak());
                     return;
                 };
@@ -219,14 +227,35 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                                 }
                                 let lbl = ui.label(&p.name);
                                 let v = p.value_at(lt);
-                                let edit = ui.scope(|ui| control(ui, p, &v));
-                                if let Some(nv) = edit.inner {
-                                    actions.push((
-                                        "prop.set".into(),
-                                        json!({"layer": lid, "prop": p.uid, "value": nv, "merge": format!("layer-style-dialog-{}", p.uid)}),
-                                    ));
+                                if matches!(v, KV::Gradient(_)) {
+                                    // The Gradient Editor, over this dialog (a style the dialog
+                                    // only shows has no property to edit yet).
+                                    let path = g.match_path_of(p.uid).unwrap_or_default();
+                                    let r = ui.add_enabled(missing.is_none(), egui::Button::new(tr("Edit Gradient…")));
+                                    if r.clicked() {
+                                        actions.push(("prop.editGradient".into(), json!({"layer": lid, "prop": p.uid})));
+                                        app.dialog_state.layer_style.gradient_open = true;
+                                    }
+                                    app.auto.add(&format!("dialog.layerStyle.value.{sel}/{path}"), r.rect, &p.name);
+                                    ui.end_row();
+                                    return;
                                 }
+                                let edit = ui.scope(|ui| control(ui, p, &v));
                                 let path = g.match_path_of(p.uid).unwrap_or_default();
+                                if let Some(nv) = edit.inner {
+                                    // Keyed by path, not uid: the group created by the first
+                                    // change and the rest of the drag stay one undo step.
+                                    let merge = format!("layer-style-dialog-{lid}-{sel}/{path}");
+                                    if missing.is_some() {
+                                        actions.push(("layer.style.add".into(), json!({"layers": [lid], "style": BLENDING, "merge": merge})));
+                                        actions.push((
+                                            "prop.set".into(),
+                                            json!({"layer": lid, "path": format!("{GROUP}/{BLENDING}/{path}"), "value": nv, "merge": merge}),
+                                        ));
+                                    } else {
+                                        actions.push(("prop.set".into(), json!({"layer": lid, "prop": p.uid, "value": nv, "merge": merge})));
+                                    }
+                                }
                                 app.auto.add(&format!("dialog.layerStyle.prop.{sel}/{path}"), lbl.rect, &p.name);
                                 app.auto.add(&format!("dialog.layerStyle.value.{sel}/{path}"), edit.response.rect, &p.name);
                                 ui.end_row();
@@ -258,25 +287,32 @@ pub fn finish(app: &mut EffectcraftApp, ok: bool) {
     if let Some(checkpoint) = app.dialog_state.layer_style.checkpoint.take()
         && !ok
     {
-        let changed = !std::sync::Arc::ptr_eq(&app.session.project, &checkpoint.project);
-        if changed {
-            // Snapshot only when Cancel has something to restore: opening and cancelling without
-            // edits must not copy the whole TextDoc.
-            let edited = active_editor_snapshot(&app.session);
-            app.session.project = checkpoint.project;
-            app.session.history = checkpoint.history;
-            app.session.sanitize_after_replacement(edited.as_ref());
-            app.session.bump();
-        } else {
-            // No edit was committed, so nothing can have become invalid. In particular, do not
-            // call sanitize_state here: its text-edit cleanup clones the whole TextDoc.
-            app.session.history = checkpoint.history;
-        }
+        restore(app, checkpoint);
     }
     app.session.history.merge_key = None;
     app.dialog = None;
 }
 
+/// Put the project and undo history back as `checkpoint` has them (nothing happens when nothing
+/// changed since).
+pub(crate) fn restore(app: &mut EffectcraftApp, checkpoint: Checkpoint) {
+    let changed = !std::sync::Arc::ptr_eq(&app.session.project, &checkpoint.project);
+    if changed {
+        // Snapshot only when Cancel has something to restore: opening and cancelling without
+        // edits must not copy the whole TextDoc.
+        let edited = active_editor_snapshot(&app.session);
+        app.session.project = checkpoint.project;
+        app.session.history = checkpoint.history;
+        app.session.sanitize_after_replacement(edited.as_ref());
+        app.session.bump();
+    } else {
+        // No edit was committed, so nothing can have become invalid. In particular, do not
+        // call sanitize_state here: its text-edit cleanup clones the whole TextDoc.
+        app.session.history = checkpoint.history;
+    }
+    app.session.history.merge_key = None;
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/ui-egui/src/panels/learn.rs b/crates/ui-egui/src/panels/learn.rs
index a3c4a85f6..fcb98cce1 100644
--- a/crates/ui-egui/src/panels/learn.rs
+++ b/crates/ui-egui/src/panels/learn.rs
@@ -18,7 +18,7 @@ pub fn home_tab(app: &mut EffectcraftApp, ui: &mut egui::Ui, area: Rect) {
     p.text(
         pos2(x, y + 26.0),
         Align2::LEFT_CENTER,
-        "Hands-on tutorials that run inside EffectCraft. Do each step yourself, or press Show me.",
+        crate::i18n::tr("Hands-on tutorials that run inside EffectCraft. Do each step yourself, or press Show me."),
         Tokens::ui(11.5),
         t.text_faint,
     );
@@ -38,7 +38,7 @@ pub fn home_tab(app: &mut EffectcraftApp, ui: &mut egui::Ui, area: Rect) {
         p.circle_filled(badge.center(), 22.0, t.accent.gamma_multiply(0.25));
         p.circle_stroke(badge.center(), 22.0, Stroke::new(1.5, t.accent));
         p.text(badge.center() - vec2(0.0, 5.0), Align2::CENTER_CENTER, tut.steps.len().to_string(), Tokens::semibold(15.0), Color32::WHITE);
-        p.text(badge.center() + vec2(0.0, 10.0), Align2::CENTER_CENTER, "steps", Tokens::ui(9.0), t.text_dim);
+        p.text(badge.center() + vec2(0.0, 10.0), Align2::CENTER_CENTER, crate::i18n::tr("steps"), Tokens::ui(9.0), t.text_dim);
         let tx = badge.max.x + 16.0;
         p.text(pos2(tx, r.min.y + 22.0), Align2::LEFT_CENTER, &tut.title, Tokens::semibold(14.0), Color32::WHITE);
         p.text(pos2(tx, r.min.y + 40.0), Align2::LEFT_CENTER, format!("{} min", tut.minutes), Tokens::ui(11.0), t.text_faint);
diff --git a/crates/ui-egui/src/panels/live_preview.rs b/crates/ui-egui/src/panels/live_preview.rs
new file mode 100644
index 000000000..83d0d2836
--- /dev/null
+++ b/crates/ui-egui/src/panels/live_preview.rs
@@ -0,0 +1,129 @@
+//! Preview for the settings dialogs that edit something that already exists (Solid Settings on a
+//! solid layer, Camera Settings, Light Settings, Composition Settings): After Effects' Preview
+//! checkbox. Each change of the draft is applied to the project at once, so the canvas shows it
+//! while it is made; OK keeps it and Cancel and Escape take it back.
+//!
+//! Every step goes back to the checkpoint taken when the dialog opened (the project and its undo
+//! history) and then runs the dialog's command once with the draft's parameters. So the project is
+//! always "as it opened, plus one command": OK leaves exactly one undo step, whatever was tried
+//! meanwhile, and Cancel only has to put the checkpoint back. With Preview off nothing is applied
+//! until OK, and switching it off takes back what was applied.
+//!
+//! While a preview is active the dialog opens at the lower right of the window, without the dark
+//! backdrop, and the window behind it is not greyed out, so the canvas stays in view.
+
+use egui::vec2;
+use serde_json::Value;
+
+use crate::panels::dialogs::Placement;
+use crate::panels::layer_styles_dialog::{Checkpoint, checkpoint};
+use crate::panels::preview_merge::{self, Applied};
+use crate::{Dialog, EffectcraftApp};
+
+/// Where a previewing dialog opens: the lower right, undimmed.
+pub const PLACE: Placement = Placement { start: vec2(0.75, 0.8), dim: false };
+
+/// The state of the one dialog being previewed (only one dialog is open at a time).
+#[derive(Clone, Debug, Default)]
+pub struct LivePreview {
+    /// The dialog this belongs to; a preview left over from another one is ignored.
+    dialog: Option<Dialog>,
+    /// The Preview checkbox.
+    pub on: bool,
+    checkpoint: Option<Checkpoint>,
+    /// The draft's parameters when the dialog opened: nothing is applied while it equals them.
+    baseline: Option<Value>,
+    /// The command and parameters the preview last applied.
+    applied: Option<(&'static str, Value)>,
+    /// The project as that command left it, to tell edits made since from the preview's.
+    applied_at: Option<Applied>,
+}
+
+impl LivePreview {
+    fn active_for(&self, dialog: Option<Dialog>) -> bool {
+        self.checkpoint.is_some() && self.dialog.is_some() && self.dialog == dialog
+    }
+}
+
+/// Start previewing for `dialog`, which has just opened on an existing item (Preview on).
+pub fn begin(app: &mut EffectcraftApp, dialog: Dialog) {
+    app.dialog_state.live = LivePreview { dialog: Some(dialog), on: true, checkpoint: Some(checkpoint(app)), ..Default::default() };
+}
+
+/// The dialog that is open is previewing.
+pub fn active(app: &EffectcraftApp) -> bool {
+    app.dialog_state.live.active_for(app.dialog)
+}
+
+/// Where the open dialog goes: the lower right, undimmed, while it previews; else the middle.
+pub fn place(app: &EffectcraftApp) -> Placement {
+    if active(app) { PLACE } else { Placement::default() }
+}
+
+/// Keep the project in step with the draft: `command` with `params` is what OK would run. The
+/// first call (the draft as it opened) only notes it.
+pub fn sync(app: &mut EffectcraftApp, command: &'static str, params: Value) {
+    if !active(app) {
+        return;
+    }
+    let live = &app.dialog_state.live;
+    if live.baseline.is_none() {
+        app.dialog_state.live.baseline = Some(params);
+        return;
+    }
+    let want = live.on && live.baseline.as_ref() != Some(&params);
+    let is_applied = live.applied.is_some();
+    if want {
+        if live.applied.as_ref().is_some_and(|(c, p)| *c == command && *p == params) {
+            return;
+        }
+        if is_applied {
+            put_back(app);
+        }
+        match app.session.execute(command, params.clone()) {
+            Ok(_) => {
+                app.dialog_state.live.applied = Some((command, params));
+                app.dialog_state.live.applied_at = Some(preview_merge::applied(app));
+            }
+            Err(e) => app.ui.status = e.to_string(),
+        }
+    } else if is_applied {
+        put_back(app);
+    }
+}
+
+/// The project as the dialog found it.
+fn put_back(app: &mut EffectcraftApp) {
+    if let Some(cp) = app.dialog_state.live.checkpoint.clone() {
+        let at = app.dialog_state.live.applied_at.take();
+        // Only what the preview did is taken back: an edit made while the dialog was open stays.
+        preview_merge::rollback(app, cp, at.as_ref());
+    }
+    app.dialog_state.live.applied = None;
+    app.dialog_state.live.applied_at = None;
+}
+
+/// OK: the preview's result is the edit. The preview is first brought up to `command` with
+/// `params`, the draft as OK found it (an edit made in the same frame as OK is not in the last
+/// preview). Returns whether the project then already has the edit (the caller must not run the
+/// command again); otherwise the caller runs it, as without a preview.
+pub fn keep(app: &mut EffectcraftApp, command: &'static str, params: Value) -> bool {
+    sync(app, command, params);
+    let kept = active(app) && app.dialog_state.live.applied.is_some();
+    app.dialog_state.live = LivePreview::default();
+    kept
+}
+
+/// Cancel and Escape: take back whatever the preview applied.
+pub fn cancel(app: &mut EffectcraftApp) {
+    if active(app) {
+        put_back(app);
+    }
+    app.dialog_state.live = LivePreview::default();
+}
+
+/// The Preview checkbox, when the open dialog previews; `id` is its automation id.
+pub fn checkbox(ui: &mut egui::Ui, auto: &mut crate::automation::Registry, on: &mut bool, id: &str) {
+    let r = ui.checkbox(on, crate::i18n::tr("Preview"));
+    auto.add(id, r.rect, "Preview");
+}
diff --git a/crates/ui-egui/src/panels/markers_ui.rs b/crates/ui-egui/src/panels/markers_ui.rs
index ff5fa0005..54f06d6b6 100644
--- a/crates/ui-egui/src/panels/markers_ui.rs
+++ b/crates/ui-egui/src/panels/markers_ui.rs
@@ -155,7 +155,7 @@ pub fn dialog(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             ui.end_row();
         });
         ui.add_space(8.0);
-        let r = ui.checkbox(&mut d.cue, tr("Cue Point"));
+        let r = crate::widgets::labelled_checkbox(ui, &mut d.cue, tr("Cue Point"));
         app.auto.add("dialog.marker.cue", r.rect, "Cue Point");
         ui.add_enabled_ui(d.cue, |ui| {
             ui.horizontal(|ui| {
@@ -191,13 +191,13 @@ pub fn dialog(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
         });
         ui.add_space(8.0);
         ui.horizontal(|ui| {
-            let r = ui.checkbox(&mut d.protected, tr("Protected Region"));
+            let r = crate::widgets::labelled_checkbox(ui, &mut d.protected, tr("Protected Region"));
             app.auto.add("dialog.marker.protected", r.rect, "Protected Region");
             ui.add_space(20.0);
             ui.label(tr("Label:"));
             let labels = effectcraft_engine::color::Label::ALL;
             let cur = labels.get(d.label).copied().unwrap_or_default();
-            let r = egui::ComboBox::from_id_salt("dialog.marker.label").selected_text(app.session.prefs.label_name(cur)).show_ui(ui, |ui| {
+            let r = craft_ui::ComboBox::from_id_salt("dialog.marker.label").selected_text(app.session.prefs.label_name(cur)).show_ui(ui, |ui| {
                 for (i, l) in labels.into_iter().enumerate() {
                     if crate::widgets::label_entry(ui, l, &app.session.prefs.label_name(l), d.label == i, &app.tokens).clicked() {
                         d.label = i;
@@ -243,6 +243,8 @@ pub fn dialog(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
 
 // ---------------------------------------------------------------- timeline drawing + gestures
 
+/// The `egui::Id` of a marker drag in progress: the dragged marker's layer and index (updated as
+/// the marker moves) and whether Alt was held when the drag started.
 fn drag_state_id() -> egui::Id {
     egui::Id::unique("marker-drag")
 }
@@ -283,8 +285,8 @@ fn marker(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, comp:
     let x = tm.x(comp_t);
     let col = marker_color(&t, m.label);
     let h = (y1 - y0).min(10.0);
-    if m.duration > Tick(0) {
-        let xe = tm.x(comp_t + m.duration.seconds());
+    let end = (m.duration > Tick(0)).then(|| tm.x(comp_t + m.duration.seconds()));
+    if let Some(xe) = end {
         let bar = Rect::from_min_max(pos2(x, y0 + 1.0), pos2(xe, y0 + h - 1.0));
         p.rect_filled(bar, 1.0, col.gamma_multiply(if m.protected { 0.35 } else { 0.5 }));
         if m.protected {
@@ -294,11 +296,16 @@ fn marker(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, comp:
                 hx += 5.0;
             }
         }
-        p.line_segment([pos2(xe, y0), pos2(xe, y0 + h)], Stroke::new(1.0, col));
     }
-    p.add(egui::Shape::convex_polygon(marker_shape(x, y0, h), col, Stroke::NONE));
     if !m.comment.is_empty() {
-        p.text(pos2(x + 7.0, y0 + h / 2.0), Align2::LEFT_CENTER, m.comment.lines().next().unwrap_or_default(), Tokens::ui(10.0), t.text);
+        // The name sits in a small outlined box beside the flag, as in After Effects. It is drawn in the theme's field
+        // colours, so it follows Dark, Darker and Light.
+        let galley = p.layout_no_wrap(m.comment.lines().next().unwrap_or_default().to_string(), Tokens::ui(10.0), t.text);
+        let box_w = galley.size().x + 8.0;
+        let box_x = name_box_x(x, box_w, end, p.clip_rect());
+        let box_rect = Rect::from_min_size(pos2(box_x, y0), vec2(box_w, h.max(galley.size().y + 2.0)));
+        p.rect(box_rect, t.radius_sm, t.field_bg, Stroke::new(1.0, t.field_border), egui::StrokeKind::Inside);
+        p.galley(pos2(box_rect.min.x + 4.0, box_rect.center().y - galley.size().y / 2.0), galley, t.text);
     }
     let hit = Rect::from_min_max(pos2(x - 5.0, y0 - 1.0), pos2(x + 5.0, y1));
     let id = egui::Id::unique(("marker", r.layer, r.index));
@@ -366,10 +373,39 @@ fn marker(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, comp:
         run(ui, "Delete This Marker", "markers.delete", r.params(), app);
         if let Some(l) = r.layer {
             run(ui, "Delete All Markers", "layer.deleteAllMarkers", json!({"layers": [l]}), app);
+        } else {
+            run(ui, "Delete All Markers", "comp.deleteAllMarkers", json!({}), app);
         }
     });
 }
 
+fn name_box_x(x: f32, width: f32, end: Option<f32>, clip: Rect) -> f32 {
+    let start = x + 6.0;
+    let right = match end {
+        Some(end) if end > start && end < start + width => end + 3.0,
+        _ => start,
+    };
+    if right + width <= clip.right() {
+        return right;
+    }
+    let left = x - 6.0 - width;
+    if left >= clip.left() {
+        return left;
+    }
+    start
+}
+
+/// Flags and duration handles sit above every name box in their marker strip.
+fn marker_glyphs(p: &egui::Painter, tokens: &Tokens, tm: TMap, marker: &Marker, time: f64, y0: f32, y1: f32) {
+    let color = marker_color(tokens, marker.label);
+    let h = (y1 - y0).min(10.0);
+    p.add(egui::Shape::convex_polygon(marker_shape(tm.x(time), y0, h), color, Stroke::NONE));
+    if marker.duration > Tick(0) {
+        let end = tm.x(time + marker.duration.seconds());
+        p.line_segment([pos2(end, y0), pos2(end, y0 + h)], Stroke::new(1.0, color));
+    }
+}
+
 /// Composition markers in the ruler strip `[y0, y1]`, protected regions over `rows`.
 pub(crate) fn comp_markers(app: &mut EffectcraftApp, ui: &mut egui::Ui, comp: &Comp, tm: TMap, strip: Rect, rows: Rect) {
     let p = ui.painter().with_clip_rect(strip);
@@ -383,6 +419,9 @@ pub(crate) fn comp_markers(app: &mut EffectcraftApp, ui: &mut egui::Ui, comp: &C
     for (i, m) in comp.markers.iter().enumerate() {
         marker(app, ui, &p, comp, tm, m, m.time.seconds(), MarkerRef { layer: None, index: i }, strip.min.y, strip.max.y);
     }
+    for m in &comp.markers {
+        marker_glyphs(&p, &app.tokens, tm, m, m.time.seconds(), strip.min.y, strip.max.y);
+    }
 }
 
 /// The composition marker bin at the right end of the time ruler (`bin`), as in After Effects
@@ -424,6 +463,9 @@ pub(crate) fn layer_markers(app: &mut EffectcraftApp, ui: &mut egui::Ui, clip: R
     for (i, m) in layer.markers.iter().enumerate() {
         marker(app, ui, &p, comp, tm, m, layer.comp_time(m.time).seconds(), MarkerRef { layer: Some(layer.id.0), index: i }, r.min.y + 3.0, r.max.y - 3.0);
     }
+    for m in &layer.markers {
+        marker_glyphs(&p, &app.tokens, tm, m, layer.comp_time(m.time).seconds(), r.min.y + 3.0, r.max.y - 3.0);
+    }
 }
 
 /// The nested comp's markers on a precomp layer's bar (`markers.nested`).
@@ -473,6 +515,21 @@ fn nested_markers(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter
 mod tests {
     use super::*;
 
+    #[test]
+    fn duration_name_box_stays_visible_near_the_right_clip_edge() {
+        let clip = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 20.0));
+        let x = name_box_x(70.0, 20.0, Some(85.0), clip);
+        assert!(x >= clip.left() && x + 20.0 <= clip.right());
+        assert!(x + 20.0 < 70.0 - 4.0, "the left-hand box must not cover its own marker flag");
+        assert!(85.0 < x || 85.0 > x + 20.0, "the end cap must remain outside the box");
+        assert_eq!(name_box_x(20.0, 20.0, Some(35.0), clip), 38.0);
+        for end in [None, Some(72.0), Some(110.0)] {
+            let x = name_box_x(90.0, 20.0, end, clip);
+            assert!(x >= clip.left() && x + 20.0 <= clip.right(), "all right-edge names must remain visible: {end:?}");
+            assert!(x + 20.0 < 90.0 - 4.0);
+        }
+    }
+
     #[test]
     fn marker_dialog_reads_and_writes_every_field() {
         let mut s = effectcraft_engine::Session::default();
diff --git a/crates/ui-egui/src/panels/media_panels.rs b/crates/ui-egui/src/panels/media_panels.rs
index 28ac5b2c0..ffe2cc1f7 100644
--- a/crates/ui-egui/src/panels/media_panels.rs
+++ b/crates/ui-egui/src/panels/media_panels.rs
@@ -63,6 +63,33 @@ fn thumbnail(app: &EffectcraftApp, ctx: &egui::Context, path: &str, budget: &mut
     thumb
 }
 
+/// The Favorites column: one clickable row per place, the current folder `dir` highlighted.
+fn places_column(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, side: Rect, places: &[(String, String)], dir: &str) {
+    let t = app.tokens;
+    let mut fy = side.min.y + 22.0;
+    for (i, (name, path)) in places.iter().enumerate() {
+        let r = Rect::from_min_size(pos2(side.min.x, fy), vec2(side.width(), 20.0));
+        let resp = ui.interact(r, egui::Id::unique(("mb-fav", i)), Sense::click());
+        if path == dir {
+            p.rect_filled(r, 0.0, t.row_selected);
+        } else if resp.hovered() {
+            p.rect_filled(r, 0.0, t.hover);
+        }
+        p.text(pos2(r.min.x + 14.0, r.center().y), Align2::LEFT_CENTER, name, Tokens::ui(12.0), t.text);
+        app.auto.add(&format!("mediaBrowser.place.{i}"), r, name);
+        if resp.clicked() {
+            kit::exec(app, "mediaBrowser.go", json!({"path": path}));
+        }
+        fy += 20.0;
+    }
+}
+
+/// The Media Browser panel: a toolbar (up, home, favourite, "Media only" filter and the browser's
+/// own actions), the current path, the favourite places and a tile grid of the folder's entries
+/// with thumbnails for images and videos. Double-click opens a folder or imports a file; files
+/// drag out as [`DragPayload::Files`] and a context menu copies paths, imports (optionally into the
+/// comp) or adds a favourite. The listing is cached per folder and filter for a second, and every
+/// change runs a `mediaBrowser.*` command.
 pub fn media_browser(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let ctx = ui.ctx().clone();
@@ -130,26 +157,11 @@ pub fn media_browser(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let side = Rect::from_min_max(pos2(rect.min.x, rect.min.y + 54.0), pos2(rect.min.x + 160.0_f32.min(rect.width() * 0.3), rect.max.y));
     p.line_segment([side.right_top(), side.right_bottom()], Stroke::new(1.0, t.separator));
     p.text(pos2(side.min.x + 10.0, side.min.y + 10.0), Align2::LEFT_CENTER, tr("Favorites"), Tokens::semibold(11.5), t.text_dim);
-    let mut fy = side.min.y + 22.0;
     let mut places: Vec<(String, String)> = b.places();
     places.extend(
         st.favorites.iter().map(|f| (std::path::Path::new(f).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| f.clone()), f.clone())),
     );
-    for (i, (name, path)) in places.iter().enumerate() {
-        let r = Rect::from_min_size(pos2(side.min.x, fy), vec2(side.width(), 20.0));
-        let resp = ui.interact(r, egui::Id::unique(("mb-fav", i)), Sense::click());
-        if *path == dir {
-            p.rect_filled(r, 0.0, t.row_selected);
-        } else if resp.hovered() {
-            p.rect_filled(r, 0.0, t.hover);
-        }
-        p.text(pos2(r.min.x + 14.0, r.center().y), Align2::LEFT_CENTER, name, Tokens::ui(12.0), t.text);
-        app.auto.add(&format!("mediaBrowser.place.{i}"), r, name);
-        if resp.clicked() {
-            kit::exec(app, "mediaBrowser.go", json!({"path": path}));
-        }
-        fy += 20.0;
-    }
+    places_column(app, ui, &p, side, &places, &dir);
     // Files.
     let list = Rect::from_min_max(pos2(side.max.x + 1.0, side.min.y), rect.max);
     let entries = match entries.as_ref() {
diff --git a/crates/ui-egui/src/panels/misc.rs b/crates/ui-egui/src/panels/misc.rs
index b0ec5e570..73a0b3a1c 100644
--- a/crates/ui-egui/src/panels/misc.rs
+++ b/crates/ui-egui/src/panels/misc.rs
@@ -11,7 +11,8 @@ use crate::{EffectcraftApp, widgets};
 
 pub fn placeholder(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect, p: PanelKind) {
     let t = app.tokens;
-    ui.painter().text(rect.center(), Align2::CENTER_CENTER, tr_args("{} — coming soon", &[&(p.title())]), Tokens::ui(12.0), t.text_faint);
+    let name = crate::i18n::label(app, "window.panel", p.title());
+    ui.painter().text(rect.center(), Align2::CENTER_CENTER, tr_args("{} — coming soon", &[&name]), Tokens::ui(12.0), t.text_faint);
 }
 
 /// Preview panel: transport controls, the shortcut whose options are shown, and that
@@ -42,7 +43,10 @@ pub fn preview(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     for (icon, cmd, tip) in buttons {
         let r = Rect::from_min_size(pos2(x, y), vec2(bw, 28.0));
         let icon = if cmd == "playback.toggle" && app.playback.playing { Icon::Pause } else { icon };
-        if widgets::icon_button(ui, r, icon, cmd == "playback.toggle" && app.playback.playing, &t, egui::Id::unique(("pv", cmd))).on_hover_text(tip).clicked() {
+        if widgets::icon_button(ui, r, icon, cmd == "playback.toggle" && app.playback.playing, &t, egui::Id::unique(("pv", cmd)))
+            .on_hover_text(tr(tip))
+            .clicked()
+        {
             // The play button plays with the options of the shortcut shown below.
             let params = if cmd == "playback.toggle" { json!({"shortcut": current.id()}) } else { json!({}) };
             let _ = crate::menus::invoke(app, &ctx, cmd, params);
@@ -61,7 +65,7 @@ pub fn preview(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let mut yy = y + 46.0;
 
     // Shortcut.
-    label(yy, "Shortcut");
+    label(yy, tr("Shortcut"));
     let names: Vec<String> = PreviewShortcut::ALL.iter().map(|s| s.label().to_string()).collect();
     if let Some(i) = dropdown_row(
         app,
@@ -91,14 +95,14 @@ pub fn preview(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         let row = if i < 4 { i / 2 } else { i - 2 };
         let cx = x0 + col as f32 * 110.0 - 2.0;
         let cy = yy + row as f32 * 22.0;
-        if check_row(app, ui, &p, pos2(cx, cy), key, text, on) {
+        if check_row(app, ui, &p, pos2(cx, cy), key, tr(text), on) {
             changes.push(json!({"shortcut": current.id(), key: !on}));
         }
     }
     yy += 4.0 * 22.0 + 6.0;
 
     // Range (and the pre/post-roll of Play Around Current Time).
-    label(yy, "Range");
+    label(yy, tr("Range"));
     let ranges: Vec<String> = PreviewRange::ALL.iter().map(|r| r.label().to_string()).collect();
     let range_ids = ["workArea", "workAreaExtended", "entireDuration", "aroundCurrentTime"];
     if let Some(i) = dropdown_row(
@@ -116,8 +120,15 @@ pub fn preview(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     if o.range == PreviewRange::AroundCurrentTime {
         for (k, (key, text, v)) in [("preRoll", "Pre-roll", o.pre_roll), ("postRoll", "Post-roll", o.post_roll)].into_iter().enumerate() {
             let lx = xv + k as f32 * 100.0;
-            p.text(pos2(lx, yy), Align2::LEFT_CENTER, text, Tokens::ui(11.5), t.text_dim);
-            let (r, nv, _) = widgets::hot_number_at(ui, pos2(lx + 52.0, yy - 9.0), egui::Id::unique(("pv-roll", key)), v, 0.05, (0.0, 600.0), 1, "s", &t);
+            p.text(pos2(lx, yy), Align2::LEFT_CENTER, tr(text), Tokens::ui(11.5), t.text_dim);
+            let (r, nv, _) = widgets::hot_number_at(
+                ui,
+                pos2(lx + 52.0, yy - 9.0),
+                egui::Id::unique(("pv-roll", key)),
+                v,
+                &widgets::HotSpec { speed: 0.05, range: (0.0, 600.0), decimals: 1, suffix: "s" },
+                &t,
+            );
             app.auto.add(&format!("preview.{key}"), r, text);
             if let Some(nv) = nv {
                 changes.push(json!({"shortcut": current.id(), key: nv}));
@@ -127,7 +138,7 @@ pub fn preview(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
 
     // Play From.
-    label(yy, "Play From");
+    label(yy, tr("Play From"));
     let froms: Vec<String> = PlayFrom::ALL.iter().map(|f| f.label().to_string()).collect();
     if let Some(i) = dropdown_row(
         app,
@@ -144,7 +155,7 @@ pub fn preview(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
 
     // Frame Rate, Skip, Resolution.
     let comp_fps = app.session.active_comp().map(|c| c.frame_rate.as_f64());
-    label(yy, "Frame Rate");
+    label(yy, tr("Frame Rate"));
     const RATES: [f64; 12] = [8.0, 10.0, 12.0, 12.5, 15.0, 23.976, 24.0, 25.0, 29.97, 30.0, 50.0, 60.0];
     let auto = format!("({:.2}) Auto", comp_fps.unwrap_or(0.0));
     let mut rates = vec![auto.clone()];
@@ -160,13 +171,20 @@ pub fn preview(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     let sx = xv + 106.0;
     p.text(pos2(sx, yy), Align2::LEFT_CENTER, tr("Skip"), Tokens::ui(12.0), t.text_dim);
-    let (r, nv, _) = widgets::hot_number_at(ui, pos2(sx + 30.0, yy - 9.0), egui::Id::unique("pv-skip"), o.skip as f64, 0.1, (0.0, 99.0), 0, "", &t);
+    let (r, nv, _) = widgets::hot_number_at(
+        ui,
+        pos2(sx + 30.0, yy - 9.0),
+        egui::Id::unique("pv-skip"),
+        o.skip as f64,
+        &widgets::HotSpec { speed: 0.1, range: (0.0, 99.0), decimals: 0, suffix: "" },
+        &t,
+    );
     app.auto.add("preview.skip", r, "Skip");
     if let Some(nv) = nv {
         changes.push(json!({"shortcut": current.id(), "skip": nv.round() as u32}));
     }
     yy += 24.0;
-    label(yy, "Resolution");
+    label(yy, tr("Resolution"));
     let ress: Vec<String> = PreviewResolution::ALL.iter().map(|r| r.label().to_string()).collect();
     let res_ids = ["auto", "full", "half", "third", "quarter", "custom"];
     if let Some(i) = dropdown_row(
@@ -181,15 +199,21 @@ pub fn preview(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         changes.push(json!({"shortcut": current.id(), "resolution": res_ids[i]}));
     }
     if o.resolution == PreviewResolution::Custom {
-        let (r, nv, _) =
-            widgets::hot_number_at(ui, pos2(xv + 106.0, yy - 9.0), egui::Id::unique("pv-custom-res"), o.custom_resolution as f64, 0.1, (1.0, 40.0), 0, "", &t);
+        let (r, nv, _) = widgets::hot_number_at(
+            ui,
+            pos2(xv + 106.0, yy - 9.0),
+            egui::Id::unique("pv-custom-res"),
+            o.custom_resolution as f64,
+            &widgets::HotSpec { speed: 0.1, range: (1.0, 40.0), decimals: 0, suffix: "" },
+            &t,
+        );
         app.auto.add("preview.customResolution", r, "Custom Resolution");
         if let Some(nv) = nv {
             changes.push(json!({"shortcut": current.id(), "customResolution": nv.round() as u32}));
         }
     }
     yy += 24.0;
-    if check_row(app, ui, &p, pos2(x0 - 2.0, yy), "fullScreen", "Full Screen", o.full_screen) {
+    if check_row(app, ui, &p, pos2(x0 - 2.0, yy), "fullScreen", tr("Full Screen"), o.full_screen) {
         changes.push(json!({"shortcut": current.id(), "fullScreen": !o.full_screen}));
     }
     yy += 24.0;
@@ -197,7 +221,7 @@ pub fn preview(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     // What stopping does.
     p.text(pos2(x0, yy), Align2::LEFT_CENTER, tr_args("On ({}) stop:", &[&(current.label())]), Tokens::ui(11.5), t.text_dim);
     yy += 20.0;
-    if check_row(app, ui, &p, pos2(x0 - 2.0, yy), "playCachedFrames", "If caching, play cached frames", o.play_cached_frames) {
+    if check_row(app, ui, &p, pos2(x0 - 2.0, yy), "playCachedFrames", tr("If caching, play cached frames"), o.play_cached_frames) {
         changes.push(json!({"shortcut": current.id(), "playCachedFrames": !o.play_cached_frames}));
     }
     yy += 22.0;
@@ -240,7 +264,7 @@ fn fmt_rate(r: f64) -> String {
 fn check_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, at: egui::Pos2, key: &str, text: &str, on: bool) -> bool {
     let t = app.tokens;
     let r = Rect::from_min_size(pos2(at.x, at.y - 8.0), vec2(16.0, 16.0));
-    let clicked = widgets::checkbox(ui, r, on, &t, egui::Id::unique(("pv-check", key))).clicked();
+    let clicked = widgets::checkbox(ui, r, on, &t, egui::Id::unique(("pv-check", key))).changed();
     p.text(pos2(r.max.x + 5.0, at.y), Align2::LEFT_CENTER, text, Tokens::ui(12.0), t.text);
     app.auto.add(&format!("preview.{key}"), r, text);
     clicked
@@ -362,6 +386,10 @@ pub fn audio(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
 }
 
+/// The History panel: every state of the session's branching history, indented under the state it
+/// grew from, with the current state highlighted and future/abandoned branches dimmed. Only the
+/// rows in view are drawn; the current state is scrolled into view when it changes. Clicking a
+/// state runs `edit.history.goto`, reporting a failure in `app.ui.status`.
 pub fn history(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let p = ui.painter().with_clip_rect(rect);
@@ -419,6 +447,9 @@ pub fn history(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
 }
 
+/// The Markers panel: the active comp's markers in time order, each with its timecode and comment;
+/// clicking a row moves the current time to that marker. Shows a hint when the comp has none and
+/// draws nothing without an active comp.
 pub fn markers(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let p = ui.painter().with_clip_rect(rect);
diff --git a/crates/ui-egui/src/panels/paint_panels.rs b/crates/ui-egui/src/panels/paint_panels.rs
index eba7ecce7..edf12ed7a 100644
--- a/crates/ui-egui/src/panels/paint_panels.rs
+++ b/crates/ui-egui/src/panels/paint_panels.rs
@@ -36,11 +36,21 @@ fn number(
     let t = app.tokens;
     p.text(pos2(x, y + 9.0), Align2::LEFT_CENTER, label, Tokens::ui(11.5), if enabled { t.text_dim } else { t.text_faint });
     let lw = p.layout_no_wrap(label.to_string(), Tokens::ui(11.5), t.text).size().x;
-    let (r, nv, _) = widgets::hot_number_at(ui, pos2(x + lw + 6.0, y), egui::Id::unique(("paint-num", key)), v, 0.5, range, 0, suffix, &t);
+    let (r, nv, _) = widgets::hot_number_at(
+        ui,
+        pos2(x + lw + 6.0, y),
+        egui::Id::unique(("paint-num", key)),
+        v,
+        &widgets::HotSpec { speed: 0.5, range, decimals: 0, suffix },
+        &t,
+    );
     app.auto.add(key, r, label);
     nv.filter(|_| enabled)
 }
 
+/// A label at `x`, `y` and, to its right, a dropdown over `options` with `cur` selected. The
+/// dropdown only opens while `enabled`; otherwise only its label is dimmed. Returns the index
+/// picked from the open menu, if any.
 #[allow(clippy::too_many_arguments)]
 fn popup_row(
     app: &mut EffectcraftApp,
@@ -66,6 +76,7 @@ fn popup_row(
     widgets::popup_menu(ui, pop, r.left_bottom(), options, Some(cur))
 }
 
+/// The RGB components of an RGBA paint colour as `f32`, for the swatches and the colour picker.
 fn rgb(c: [f64; 4]) -> [f32; 3] {
     [c[0] as f32, c[1] as f32, c[2] as f32]
 }
@@ -79,6 +90,52 @@ fn paint_swap_icon(p: &egui::Painter, rect: Rect, color: Color32) {
     p.arrow(pos2(right, bottom), vec2(left - right, 0.0), stroke);
 }
 
+/// The foreground-over-background swatches (each opens a colour popup) with Swap and Reset.
+fn colour_swatches(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, x0: f32, y: f32, color: [f64; 4], background: [f64; 4]) {
+    let t = app.tokens;
+    let fg = Rect::from_min_size(pos2(x0, y), vec2(26.0, 20.0));
+    let bg = Rect::from_min_size(pos2(x0 + 14.0, y + 10.0), vec2(26.0, 20.0));
+    widgets::swatch(ui, bg, [background[0] as f32, background[1] as f32, background[2] as f32, 1.0], egui::Id::unique("paint-bg"), &t);
+    let bresp = ui.interact(Rect::from_min_max(pos2(fg.max.x, bg.min.y), bg.max), egui::Id::unique("paint-bg-hit"), Sense::click());
+    if bresp.clicked() {
+        widgets::open_popup(ui, egui::Id::unique("paint-bg-pop"));
+    }
+    if widgets::swatch(ui, fg, [color[0] as f32, color[1] as f32, color[2] as f32, 1.0], egui::Id::unique("paint-fg"), &t).clicked() {
+        widgets::open_popup(ui, egui::Id::unique("paint-fg-pop"));
+    }
+    app.auto.add("paint.color", fg, "Foreground color");
+    app.auto.add("paint.background", bg, "Background color");
+    let mut fc = rgb(color);
+    if crate::widgets::color_popup(ui, egui::Id::unique("paint-fg-pop"), fg.left_bottom(), &mut fc) {
+        set(app, json!({"color": [fc[0], fc[1], fc[2], 1.0]}));
+    }
+    let mut bc = rgb(background);
+    if crate::widgets::color_popup(ui, egui::Id::unique("paint-bg-pop"), bg.left_bottom(), &mut bc) {
+        set(app, json!({"background": [bc[0], bc[1], bc[2], 1.0]}));
+    }
+    let swap = Rect::from_min_size(pos2(x0 + 46.0, y), vec2(18.0, 14.0));
+    let sresp = ui.interact(swap, egui::Id::unique("paint-swap"), Sense::click());
+    // Two arrows (foreground over background): drawn, so the icon does not depend on a font
+    // carrying U+21C4 (the bundled fonts do not).
+    paint_swap_icon(p, swap, if sresp.hovered() { t.text } else { t.text_dim });
+    app.auto.add("paint.swapColors", swap, "Swap colors");
+    if sresp.on_hover_text(tr("Swap Paint Colors (X)")).clicked() {
+        set(app, json!({"color": background, "background": color}));
+    }
+    let reset = Rect::from_min_size(pos2(x0 + 46.0, y + 18.0), vec2(18.0, 14.0));
+    let rresp = ui.interact(reset, egui::Id::unique("paint-reset-colors"), Sense::click());
+    p.rect_filled(Rect::from_min_size(reset.min + vec2(4.0, 3.0), vec2(7.0, 6.0)), 0.0, Color32::WHITE);
+    p.rect_stroke(Rect::from_min_size(reset.min + vec2(8.0, 6.0), vec2(7.0, 6.0)), 0.0, Stroke::new(1.0, t.text_dim), StrokeKind::Inside);
+    app.auto.add("paint.resetColors", reset, "Default colors");
+    if rresp.on_hover_text(tr("Set Paint Colors to Black and White (D)")).clicked() {
+        set(app, json!({"color": [1.0, 1.0, 1.0, 1.0], "background": [0.0, 0.0, 0.0, 1.0]}));
+    }
+}
+
+/// The Paint panel: opacity and flow, foreground/background colours with swap and reset, mode,
+/// channels, duration, erase mode and the Clone Stamp options. Every change is sent as a
+/// `paint.options` command. Mode and Channels are disabled for the Eraser; Erase is enabled
+/// only for it. The Clone Options heading is dimmed for other tools, but its controls stay enabled.
 pub fn paint(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let p = ui.painter().with_clip_rect(rect);
@@ -98,43 +155,7 @@ pub fn paint(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     y += 28.0;
     // Colour swatches (foreground over background) with swap / reset.
-    let fg = Rect::from_min_size(pos2(x0, y), vec2(26.0, 20.0));
-    let bg = Rect::from_min_size(pos2(x0 + 14.0, y + 10.0), vec2(26.0, 20.0));
-    widgets::swatch(ui, bg, [o.background[0] as f32, o.background[1] as f32, o.background[2] as f32, 1.0], egui::Id::unique("paint-bg"), &t);
-    let bresp = ui.interact(Rect::from_min_max(pos2(fg.max.x, bg.min.y), bg.max), egui::Id::unique("paint-bg-hit"), Sense::click());
-    if bresp.clicked() {
-        widgets::open_popup(ui, egui::Id::unique("paint-bg-pop"));
-    }
-    if widgets::swatch(ui, fg, [o.color[0] as f32, o.color[1] as f32, o.color[2] as f32, 1.0], egui::Id::unique("paint-fg"), &t).clicked() {
-        widgets::open_popup(ui, egui::Id::unique("paint-fg-pop"));
-    }
-    app.auto.add("paint.color", fg, "Foreground color");
-    app.auto.add("paint.background", bg, "Background color");
-    let mut fc = rgb(o.color);
-    if crate::widgets::color_popup(ui, egui::Id::unique("paint-fg-pop"), fg.left_bottom(), &mut fc) {
-        set(app, json!({"color": [fc[0], fc[1], fc[2], 1.0]}));
-    }
-    let mut bc = rgb(o.background);
-    if crate::widgets::color_popup(ui, egui::Id::unique("paint-bg-pop"), bg.left_bottom(), &mut bc) {
-        set(app, json!({"background": [bc[0], bc[1], bc[2], 1.0]}));
-    }
-    let swap = Rect::from_min_size(pos2(x0 + 46.0, y), vec2(18.0, 14.0));
-    let sresp = ui.interact(swap, egui::Id::unique("paint-swap"), Sense::click());
-    // Two arrows (foreground over background): drawn, so the icon does not depend on a font
-    // carrying U+21C4 (the bundled fonts do not).
-    paint_swap_icon(&p, swap, if sresp.hovered() { t.text } else { t.text_dim });
-    app.auto.add("paint.swapColors", swap, "Swap colors");
-    if sresp.on_hover_text(tr("Swap Paint Colors (X)")).clicked() {
-        set(app, json!({"color": o.background, "background": o.color}));
-    }
-    let reset = Rect::from_min_size(pos2(x0 + 46.0, y + 18.0), vec2(18.0, 14.0));
-    let rresp = ui.interact(reset, egui::Id::unique("paint-reset-colors"), Sense::click());
-    p.rect_filled(Rect::from_min_size(reset.min + vec2(4.0, 3.0), vec2(7.0, 6.0)), 0.0, Color32::WHITE);
-    p.rect_stroke(Rect::from_min_size(reset.min + vec2(8.0, 6.0), vec2(7.0, 6.0)), 0.0, Stroke::new(1.0, t.text_dim), StrokeKind::Inside);
-    app.auto.add("paint.resetColors", reset, "Default colors");
-    if rresp.on_hover_text(tr("Set Paint Colors to Black and White (D)")).clicked() {
-        set(app, json!({"color": [1.0, 1.0, 1.0, 1.0], "background": [0.0, 0.0, 0.0, 1.0]}));
-    }
+    colour_swatches(app, ui, &p, x0, y, o.color, o.background);
     y += 40.0;
 
     // Mode / Channels / Duration.
@@ -159,10 +180,7 @@ pub fn paint(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             pos2(x0 + w - 52.0, y + 1.0),
             egui::Id::unique("paint-custom-frames"),
             o.custom_frames as f64,
-            0.2,
-            (1.0, 10000.0),
-            0,
-            " f",
+            &widgets::HotSpec { speed: 0.2, range: (1.0, 10000.0), decimals: 0, suffix: " f" },
             &t,
         );
         app.auto.add("paint.customFrames", r, "Custom duration (frames)");
@@ -221,7 +239,7 @@ pub fn paint(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             .enumerate()
     {
         let r = Rect::from_min_size(pos2(x0 + i as f32 * (w / 2.0), y), vec2(18.0, 20.0));
-        if widgets::checkbox(ui, r, on, &t, egui::Id::unique(key)).clicked() {
+        if widgets::checkbox(ui, r, on, &t, egui::Id::unique(key)).changed() {
             set(app, json!({k: !on}));
         }
         p.text(pos2(r.max.x + 4.0, r.center().y), Align2::LEFT_CENTER, label, Tokens::ui(11.5), t.text_dim);
@@ -231,7 +249,14 @@ pub fn paint(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let off = o.clone_offset.unwrap_or([0.0, 0.0]);
     p.text(pos2(x0, y + 9.0), Align2::LEFT_CENTER, tr("Offset:"), Tokens::ui(11.5), t.text_dim);
     for (d, v) in off.iter().enumerate() {
-        let (r, nv, _) = widgets::hot_number_at(ui, pos2(x0 + 56.0 + d as f32 * 64.0, y), egui::Id::unique(("clone-off", d)), *v, 1.0, (-1e5, 1e5), 0, "", &t);
+        let (r, nv, _) = widgets::hot_number_at(
+            ui,
+            pos2(x0 + 56.0 + d as f32 * 64.0, y),
+            egui::Id::unique(("clone-off", d)),
+            *v,
+            &widgets::HotSpec { speed: 1.0, range: (-1e5, 1e5), decimals: 0, suffix: "" },
+            &t,
+        );
         app.auto.add(&format!("paint.cloneOffset.{d}"), r, "Clone offset");
         if let Some(nv) = nv {
             let mut no = off;
@@ -248,7 +273,7 @@ pub fn paint(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     y += 26.0;
     let r = Rect::from_min_size(pos2(x0, y), vec2(18.0, 20.0));
-    if widgets::checkbox(ui, r, o.show_overlay, &t, egui::Id::unique("paint.showOverlay")).clicked() {
+    if widgets::checkbox(ui, r, o.show_overlay, &t, egui::Id::unique("paint.showOverlay")).changed() {
         set(app, json!({"showOverlay": !o.show_overlay}));
     }
     app.auto.add("paint.showOverlay", r, "Clone Source Overlay");
@@ -257,7 +282,7 @@ pub fn paint(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         set(app, json!({"overlayOpacity": nv}));
     }
     let dr = Rect::from_min_size(pos2(x0 + w - 18.0, y), vec2(18.0, 20.0));
-    if widgets::checkbox(ui, dr, o.overlay_difference, &t, egui::Id::unique("paint.overlayDifference")).clicked() {
+    if widgets::checkbox(ui, dr, o.overlay_difference, &t, egui::Id::unique("paint.overlayDifference")).changed() {
         set(app, json!({"overlayDifference": !o.overlay_difference}));
     }
     app.auto.add("paint.overlayDifference", dr, "Difference mode overlay");
@@ -286,6 +311,9 @@ fn tip_preview(p: &egui::Painter, r: Rect, diameter: f64, angle: f64, roundness:
     }
 }
 
+/// The Brushes panel: a grid of built-in brush presets (each runs `paint.brushPreset`), a tip
+/// preview, diameter/angle/roundness/hardness/spacing fields and the size/opacity/flow pressure
+/// options. Values are sent as `paint.options` commands and failures land in `app.ui.status`.
 pub fn brushes(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let p = ui.painter().with_clip_rect(rect);
@@ -343,7 +371,14 @@ pub fn brushes(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     // Spacing (checkbox in AE turns spacing on; we always space dabs, so it shows the value).
     p.text(pos2(x0, y + 9.0), Align2::LEFT_CENTER, tr("Spacing:"), Tokens::ui(11.5), t.text_dim);
     let _ = r;
-    let (sr, nv, _) = widgets::hot_number_at(ui, pos2(x0 + 58.0, y), egui::Id::unique("brushes-spacing"), o.spacing, 0.5, (1.0, 1000.0), 0, " %", &t);
+    let (sr, nv, _) = widgets::hot_number_at(
+        ui,
+        pos2(x0 + 58.0, y),
+        egui::Id::unique("brushes-spacing"),
+        o.spacing,
+        &widgets::HotSpec { speed: 0.5, range: (1.0, 1000.0), decimals: 0, suffix: " %" },
+        &t,
+    );
     app.auto.add("brushes.spacing", sr, "Spacing");
     if let Some(nv) = nv {
         set(app, json!({"spacing": nv}));
diff --git a/crates/ui-egui/src/panels/panel_kit.rs b/crates/ui-egui/src/panels/panel_kit.rs
index 99554ec57..c1d88a417 100644
--- a/crates/ui-egui/src/panels/panel_kit.rs
+++ b/crates/ui-egui/src/panels/panel_kit.rs
@@ -23,7 +23,7 @@ pub fn dropdown(app: &mut EffectcraftApp, ui: &mut egui::Ui, r: Rect, auto: &str
 pub fn checkbox(app: &mut EffectcraftApp, ui: &mut egui::Ui, at: egui::Pos2, auto: &str, text: &str, on: bool) -> bool {
     let t = app.tokens;
     let r = Rect::from_min_size(at, vec2(16.0, 16.0));
-    let clicked = widgets::checkbox(ui, r, on, &t, egui::Id::unique(("kit-cb", auto))).clicked();
+    let clicked = widgets::checkbox(ui, r, on, &t, egui::Id::unique(("kit-cb", auto))).changed();
     ui.painter().text(pos2(r.max.x + 6.0, r.center().y), Align2::LEFT_CENTER, text, Tokens::ui(12.0), t.text);
     let full = Rect::from_min_size(at, vec2(22.0 + text.len() as f32 * 6.5, 16.0));
     app.auto.add(auto, full, text);
@@ -47,7 +47,7 @@ pub fn label(ui: &egui::Ui, at: egui::Pos2, text: &str, t: &Tokens) {
 #[allow(clippy::too_many_arguments)]
 pub fn number(app: &mut EffectcraftApp, ui: &mut egui::Ui, at: egui::Pos2, auto: &str, v: f64, speed: f64, range: (f64, f64), dec: usize, suffix: &str) -> f64 {
     let t = app.tokens;
-    let (r, nv, _) = widgets::hot_number_at(ui, at, egui::Id::unique(("kit-n", auto)), v, speed, range, dec, suffix, &t);
+    let (r, nv, _) = widgets::hot_number_at(ui, at, egui::Id::unique(("kit-n", auto)), v, &widgets::HotSpec { speed, range, decimals: dec, suffix }, &t);
     app.auto.add(auto, r, &format!("{v}"));
     nv.unwrap_or(v)
 }
diff --git a/crates/ui-egui/src/panels/path_vr_panels.rs b/crates/ui-egui/src/panels/path_vr_panels.rs
index 680d9f5a0..fcba902e4 100644
--- a/crates/ui-egui/src/panels/path_vr_panels.rs
+++ b/crates/ui-egui/src/panels/path_vr_panels.rs
@@ -54,7 +54,7 @@ pub fn create_nulls(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             acts.push((id, if id == "paths.tracePath" { json!({"loop": looping}) } else { json!({}) }));
         }
     }
-    let r = ui.checkbox(&mut looping, tr("Loop (Trace Path)"));
+    let r = crate::widgets::labelled_checkbox(&mut ui, &mut looping, tr("Loop (Trace Path)"));
     app.auto.add("createNulls.loop", r.rect, "Loop");
     ui.data_mut(|d| d.insert_temp(loop_id, looping));
     run(app, &ctx, acts);
diff --git a/crates/ui-egui/src/panels/precomp.rs b/crates/ui-egui/src/panels/precomp.rs
index 7c1750d5e..6ec9072f3 100644
--- a/crates/ui-egui/src/panels/precomp.rs
+++ b/crates/ui-egui/src/panels/precomp.rs
@@ -141,11 +141,11 @@ pub fn dialog(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
         );
         ui.add_space(4.0);
         ui.add_enabled_ui(!d.leave, |ui| {
-            let r = ui.checkbox(&mut d.adjust, tr("Adjust composition duration to the time span of the selected layers"));
+            let r = crate::widgets::labelled_checkbox(ui, &mut d.adjust, tr("Adjust composition duration to the time span of the selected layers"));
             app.auto.add("dialog.precompose.adjust", r.rect, "Adjust composition duration");
         });
         ui.add_space(8.0);
-        let r = ui.checkbox(&mut d.open, tr("Open New Composition"));
+        let r = crate::widgets::labelled_checkbox(ui, &mut d.open, tr("Open New Composition"));
         app.auto.add("dialog.precompose.open", r.rect, "Open New Composition");
         ui.add_space(14.0);
         ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
diff --git a/crates/ui-egui/src/panels/preview_merge.rs b/crates/ui-egui/src/panels/preview_merge.rs
new file mode 100644
index 000000000..ab41e3167
--- /dev/null
+++ b/crates/ui-egui/src/panels/preview_merge.rs
@@ -0,0 +1,204 @@
+//! Taking a dialog's Preview back without taking other edits with it.
+//!
+//! A previewing dialog (Camera, Light, Solid, Composition Settings, the Gradient Editor) puts the
+//! project and undo history back to a checkpoint when it is cancelled or Preview goes off. If the
+//! project changed in the meantime for another reason (a camera analysis finishing, a script, the
+//! control channel), swapping the checkpoint in would throw that edit away. This module undoes
+//! only what the preview did: a three-way merge of the checkpoint (before the preview), the project
+//! right after the preview (`Applied`) and the project now. Whatever the preview did not touch
+//! stays as it is now; what only the preview touched goes back to the checkpoint; what both touched
+//! keeps the other edit.
+
+use std::collections::BTreeSet;
+use std::sync::Arc;
+
+use effectcraft_engine::commands::text_edit::active_editor_snapshot;
+use effectcraft_engine::project::{Comp, Item, ItemId, ItemKind, Layer, LayerId, Project};
+
+use crate::EffectcraftApp;
+use crate::panels::layer_styles_dialog::{Checkpoint, restore};
+
+/// The project right after a preview was applied, and the undo depth then.
+#[derive(Clone)]
+pub(crate) struct Applied {
+    project: Arc<Project>,
+    undo_len: usize,
+}
+
+impl std::fmt::Debug for Applied {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Applied").field("undo_len", &self.undo_len).finish_non_exhaustive()
+    }
+}
+
+/// Note the project as the preview that has just been applied left it.
+pub(crate) fn applied(app: &EffectcraftApp) -> Applied {
+    Applied { project: app.session.project.clone(), undo_len: app.session.history.undo.len() }
+}
+
+/// Put the project back as `checkpoint` has it, minus nothing but the preview: when the project is
+/// still what the preview made (or nothing says what that was) the checkpoint is simply restored.
+pub(crate) fn rollback(app: &mut EffectcraftApp, checkpoint: Checkpoint, applied: Option<&Applied>) {
+    let Some(applied) = applied.filter(|a| !Arc::ptr_eq(&a.project, &app.session.project)) else {
+        restore(app, checkpoint);
+        return;
+    };
+    let merged = merge(&checkpoint.project, &applied.project, &app.session.project);
+    // One step for what was done meanwhile, from the project before the dialog: Undo takes it back.
+    let label = app.session.history.undo.get(applied.undo_len).map(|(label, _)| label.clone()).unwrap_or_else(|| "Edit".to_string());
+    let mut history = checkpoint.history;
+    history.undo.push((label, checkpoint.project));
+    history.redo.clear();
+    history.merge_key = None;
+    let edited = active_editor_snapshot(&app.session);
+    app.session.project = Arc::new(merged);
+    app.session.history = history;
+    app.session.sanitize_after_replacement(edited.as_ref());
+    app.session.bump();
+}
+
+/// `now` without the changes between `before` and `after`, keeping any other change.
+fn merge(before: &Project, after: &Project, now: &Project) -> Project {
+    let mut merged = now.clone();
+    let ids: BTreeSet<ItemId> = before.items.keys().chain(after.items.keys()).chain(now.items.keys()).copied().collect();
+    for id in ids {
+        match item(before.items.get(&id), after.items.get(&id), now.items.get(&id)) {
+            Some(it) => {
+                merged.items.insert(id, it);
+            }
+            None => {
+                merged.items.remove(&id);
+            }
+        }
+    }
+    merged
+}
+
+/// The three-way choice for one value: untouched by the preview keeps `now`, touched only by the
+/// preview goes back to `before`, touched by both is `both`.
+fn pick<T: PartialEq + Clone>(before: Option<&T>, after: Option<&T>, now: Option<&T>, both: impl FnOnce() -> Option<T>) -> Option<T> {
+    if after == before {
+        now.cloned()
+    } else if now == after {
+        before.cloned()
+    } else {
+        both()
+    }
+}
+
+fn item(before: Option<&Item>, after: Option<&Item>, now: Option<&Item>) -> Option<Item> {
+    pick(before, after, now, || {
+        if let (Some(b), Some(a), Some(n)) = (before, after, now)
+            && let (ItemKind::Comp(bc), ItemKind::Comp(ac), ItemKind::Comp(nc)) = (&b.kind, &a.kind, &n.kind)
+        {
+            let mut merged = n.clone();
+            // Name, folder and the like: only a preview that changed the item itself and nothing else
+            // is taken back; the comp's own contents are merged below.
+            merged.kind = ItemKind::Comp(Arc::new(comp(bc, ac, nc)));
+            return Some(merged);
+        }
+        now.cloned()
+    })
+}
+
+fn bare(c: &Comp) -> Comp {
+    let mut b = c.clone();
+    b.layers.clear();
+    b
+}
+
+fn layer_of(c: &Comp, id: LayerId) -> Option<&Layer> {
+    c.layers.iter().find(|l| l.id == id)
+}
+
+fn comp(before: &Comp, after: &Comp, now: &Comp) -> Comp {
+    // The comp's own settings, apart from its layers.
+    let mut merged = pick(Some(&bare(before)), Some(&bare(after)), Some(&bare(now)), || Some(bare(now))).unwrap_or_else(|| bare(now));
+    let merge_layer = |id: LayerId| pick(layer_of(before, id), layer_of(after, id), layer_of(now, id), || layer_of(now, id).cloned());
+    // Layers as they stand now, in their order, then the ones the preview removed put back.
+    let mut layers: Vec<Layer> = now.layers.iter().filter_map(|l| merge_layer(l.id)).collect();
+    for (at, l) in before.layers.iter().enumerate() {
+        if layer_of(now, l.id).is_none()
+            && let Some(back) = merge_layer(l.id)
+        {
+            layers.insert(at.min(layers.len()), back);
+        }
+    }
+    merged.layers = layers.into();
+    merged
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Dialog;
+    use crate::panels::live_preview;
+    use effectcraft_engine::Session;
+    use serde_json::json;
+
+    fn app_with_light() -> (EffectcraftApp, u64) {
+        let mut s = Session::default();
+        s.execute("comp.new", json!({"name": "Scene", "width": 320, "height": 180, "duration": 1})).unwrap();
+        let light = s.execute("layer.newLight", json!({"kind": "Point"})).unwrap()["layer"].as_u64().unwrap();
+        (EffectcraftApp::new(s), light)
+    }
+
+    fn name_of(app: &EffectcraftApp, layer: u64) -> String {
+        app.session.active_comp().unwrap().layer(LayerId(layer)).unwrap().name.clone()
+    }
+
+    fn layer_count(app: &EffectcraftApp) -> usize {
+        app.session.active_comp().unwrap().layers.len()
+    }
+
+    /// The preview renames the light; a null is added meanwhile (what a finished background job
+    /// would do). Cancel takes the rename back and keeps the null, with one undo step for it.
+    #[test]
+    fn cancelling_a_preview_keeps_an_edit_made_while_it_was_open() {
+        let (mut app, light) = app_with_light();
+        let original = name_of(&app, light);
+        app.dialog = Some(Dialog::LightSettings);
+        live_preview::begin(&mut app, Dialog::LightSettings);
+        let rename = |name: &str| json!({"layer": light, "name": name});
+        live_preview::sync(&mut app, "layer.rename", rename(&original));
+        live_preview::sync(&mut app, "layer.rename", rename("Previewed"));
+        assert_eq!(name_of(&app, light), "Previewed");
+        let layers = layer_count(&app);
+        app.session.execute("layer.newNull", json!({})).unwrap();
+        live_preview::cancel(&mut app);
+        assert_eq!(name_of(&app, light), original, "the preview is taken back");
+        assert_eq!(layer_count(&app), layers + 1, "the other edit stays");
+        assert!(app.session.undo());
+        assert_eq!(layer_count(&app), layers, "and has its own undo step");
+        assert_eq!(name_of(&app, light), original);
+    }
+
+    /// With nothing else done meanwhile the checkpoint is restored as before.
+    #[test]
+    fn cancelling_an_undisturbed_preview_restores_the_checkpoint() {
+        let (mut app, light) = app_with_light();
+        let original = name_of(&app, light);
+        let steps = app.session.history.undo.len();
+        app.dialog = Some(Dialog::LightSettings);
+        live_preview::begin(&mut app, Dialog::LightSettings);
+        live_preview::sync(&mut app, "layer.rename", json!({"layer": light, "name": original}));
+        live_preview::sync(&mut app, "layer.rename", json!({"layer": light, "name": "Previewed"}));
+        live_preview::cancel(&mut app);
+        assert_eq!(name_of(&app, light), original);
+        assert_eq!(app.session.history.undo.len(), steps);
+    }
+
+    /// An item both the preview and another edit changed keeps the other edit.
+    #[test]
+    fn a_layer_both_edits_changed_keeps_the_other_edit() {
+        let (mut app, light) = app_with_light();
+        let original = name_of(&app, light);
+        app.dialog = Some(Dialog::LightSettings);
+        live_preview::begin(&mut app, Dialog::LightSettings);
+        live_preview::sync(&mut app, "layer.rename", json!({"layer": light, "name": original}));
+        live_preview::sync(&mut app, "layer.rename", json!({"layer": light, "name": "Previewed"}));
+        app.session.execute("layer.rename", json!({"layer": light, "name": "Renamed elsewhere"})).unwrap();
+        live_preview::cancel(&mut app);
+        assert_eq!(name_of(&app, light), "Renamed elsewhere");
+    }
+}
diff --git a/crates/ui-egui/src/panels/primitive_dialog.rs b/crates/ui-egui/src/panels/primitive_dialog.rs
index a3483a976..3711c6a80 100644
--- a/crates/ui-egui/src/panels/primitive_dialog.rs
+++ b/crates/ui-egui/src/panels/primitive_dialog.rs
@@ -58,7 +58,7 @@ pub fn dialog(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
     super::dialogs::modal(ctx, "New 3D Primitive", vec2(420.0, 300.0), t, |ui| {
         egui::Grid::new("primitive-grid").num_columns(2).spacing([14.0, 9.0]).show(ui, |ui| {
             ui.label(tr("Type"));
-            let combo = egui::ComboBox::from_id_salt("primitive-type").selected_text(tr(d.kind.label())).show_ui(ui, |ui| {
+            let combo = craft_ui::ComboBox::from_id_salt("primitive-type").selected_text(tr(d.kind.label())).show_ui(ui, |ui| {
                 for (i, k) in PrimitiveKind::ALL.into_iter().enumerate() {
                     let item = ui.selectable_value(&mut d.kind, k, tr(k.label()));
                     app.auto.add(&format!("dialog.primitive.typeItem.{i}"), item.rect, k.label());
diff --git a/crates/ui-egui/src/panels/project.rs b/crates/ui-egui/src/panels/project.rs
index a18fe1966..f84a49d84 100644
--- a/crates/ui-egui/src/panels/project.rs
+++ b/crates/ui-egui/src/panels/project.rs
@@ -191,6 +191,8 @@ fn fit(r: Rect, w: f32, h: f32) -> Rect {
 
 /// An inline text edit in progress: (item, field `name`|`comment`, text).
 type Editing = (u64, String, String);
+/// The `egui::Id` of the Project panel's inline edit in progress ([`Editing`]): the item, which
+/// field (`name` or `comment`) and the text being typed.
 fn edit_id() -> egui::Id {
     egui::Id::unique("proj-inline-edit")
 }
@@ -379,12 +381,9 @@ pub(crate) fn reveal(app: &mut EffectcraftApp, ctx: &egui::Context, items: &[Ite
     app.show_panel(crate::dock::PanelKind::Project);
 }
 
-pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+/// The selected item's thumbnail and details (with the comps that use it), or a hint.
+fn details_header(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, ctx: &egui::Context, head: Rect) {
     let t = app.tokens;
-    let p = ui.painter().clone();
-    let ctx = ui.ctx().clone();
-    // Preview header.
-    let head = Rect::from_min_size(rect.min, vec2(rect.width(), 74.0));
     let sel = app.session.state.project_selection.first().copied();
     if let Some(it) = sel.and_then(|i| app.session.project.item(i)).cloned() {
         let thumb = Rect::from_min_size(head.min + vec2(10.0, 10.0), vec2(96.0, 54.0));
@@ -393,12 +392,12 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             ItemKind::Solid(s) => {
                 p.rect_filled(thumb.shrink(4.0), 2.0, Color32::from_rgb((s.color[0] * 255.0) as u8, (s.color[1] * 255.0) as u8, (s.color[2] * 255.0) as u8));
             }
-            _ => match thumbnail(app, &ctx, &it) {
+            _ => match thumbnail(app, ctx, &it) {
                 Some(tex) => {
                     let [w, h] = tex.size();
                     p.image(tex.id(), fit(thumb, w as f32, h as f32), Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
                 }
-                None => icons::paint(&p, Rect::from_center_size(thumb.center(), vec2(24.0, 24.0)), item_icon(&it), t.text_dim),
+                None => icons::paint(p, Rect::from_center_size(thumb.center(), vec2(24.0, 24.0)), item_icon(&it), t.text_dim),
             },
         }
         app.auto.add("project.thumbnail", thumb, &it.name);
@@ -411,7 +410,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         let count = users.iter().fold(0usize, |n, (_, k)| n.saturating_add(*k));
         let name_y = thumb.min.y + 6.0;
         if count == 0 {
-            let r = widgets::text_fit(&p, pos2(tx, name_y), Align2::LEFT_CENTER, &it.name, Tokens::semibold(12.0), max_w, t.text);
+            let r = widgets::text_fit(p, pos2(tx, name_y), Align2::LEFT_CENTER, &it.name, Tokens::semibold(12.0), max_w, t.text);
             app.auto.add("project.details.name", r, &it.name);
         } else {
             let used = if count == 1 { crate::i18n::tr("used once").to_owned() } else { crate::i18n::tr_args("used {} times", &[&count]) };
@@ -420,17 +419,17 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             let arrow_w = 14.0;
             // The name gives way first, but keeps at least half the room; the count is cut after it.
             let name_max = (max_w - arrow_w - used_w).max(max_w * 0.5);
-            let r = widgets::text_fit(&p, pos2(tx, name_y), Align2::LEFT_CENTER, &it.name, Tokens::semibold(12.0), name_max, t.text);
+            let r = widgets::text_fit(p, pos2(tx, name_y), Align2::LEFT_CENTER, &it.name, Tokens::semibold(12.0), name_max, t.text);
             app.auto.add("project.details.name", r, &it.name);
             let ar = Rect::from_min_size(pos2(r.max.x + 1.0, name_y - 7.0), vec2(arrow_w, 14.0));
             let tip = crate::i18n::tr("Compositions that use this item");
             let aresp = ui.interact(ar, egui::Id::unique("proj-used-in"), Sense::click()).on_hover_text(tip);
-            icons::paint(&p, Rect::from_center_size(ar.center(), vec2(9.0, 9.0)), Icon::ChevronDown, if aresp.hovered() { t.text } else { t.text_dim });
+            icons::paint(p, Rect::from_center_size(ar.center(), vec2(9.0, 9.0)), Icon::ChevronDown, if aresp.hovered() { t.text } else { t.text_dim });
             app.auto.add("project.details.usedIn", ar, tip);
             // The comma sits right after the arrow (its glyph ends short of the hit area).
             let ux = ar.max.x - 3.0;
             let room = (head.max.x - 10.0 - ux).max(0.0);
-            let ur = widgets::text_fit(&p, pos2(ux, name_y), Align2::LEFT_CENTER, &used, Tokens::ui(11.0), room, t.text_dim);
+            let ur = widgets::text_fit(p, pos2(ux, name_y), Align2::LEFT_CENTER, &used, Tokens::ui(11.0), room, t.text_dim);
             app.auto.add("project.details.used", ur, &used);
             let names: Vec<(u64, String, usize)> =
                 users.iter().map(|(cid, n)| (cid.0, app.session.project.item(*cid).map(|c| c.name.clone()).unwrap_or_default(), *n)).collect();
@@ -447,7 +446,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 }
             });
             if let Some(cid) = open
-                && let Err(e) = crate::menus::invoke(app, &ctx, "comp.open", json!({"comp": cid}))
+                && let Err(e) = crate::menus::invoke(app, ctx, "comp.open", json!({"comp": cid}))
             {
                 app.ui.status = e;
             }
@@ -464,23 +463,37 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             lines.push(f.codec.clone());
         }
         for (i, l) in lines.iter().enumerate() {
-            let r = widgets::text_fit(&p, pos2(tx, thumb.min.y + 22.0 + 13.0 * i as f32), Align2::LEFT_CENTER, l, Tokens::ui(11.0), max_w, t.text_dim);
+            let r = widgets::text_fit(p, pos2(tx, thumb.min.y + 22.0 + 13.0 * i as f32), Align2::LEFT_CENTER, l, Tokens::ui(11.0), max_w, t.text_dim);
             app.auto.add(&format!("project.details.{i}"), r, l);
         }
     } else {
         let hint = "Select an item to see its details";
-        let r = widgets::text_fit(&p, head.center(), Align2::CENTER_CENTER, crate::i18n::tr(hint), Tokens::ui(11.0), head.width() - 20.0, t.text_faint);
+        let r = widgets::text_fit(p, head.center(), Align2::CENTER_CENTER, crate::i18n::tr(hint), Tokens::ui(11.0), head.width() - 20.0, t.text_faint);
         app.auto.add("project.details.hint", r, hint);
     }
-    // Search.
-    let sr = Rect::from_min_size(pos2(rect.min.x + 8.0, head.max.y + 2.0), vec2(rect.width() - 16.0, 22.0));
-    let mut q = app.ui.project_search.clone();
-    widgets::search_field(ui, sr, &mut q, crate::i18n::tr("Search project"), &t);
-    app.ui.project_search = q;
-    app.auto.add("project.search", sr, "Search");
-    // Column header: Name, Label, then the visible optional columns.
-    let hdr = Rect::from_min_size(pos2(rect.min.x, sr.max.y + 6.0), vec2(rect.width(), 20.0));
-    p.line_segment([hdr.left_bottom(), hdr.right_bottom()], Stroke::new(1.0, t.separator));
+}
+
+/// Column positions: Name and Label, then the visible optional columns (scrolled by `hscroll`).
+struct Columns {
+    cols: Vec<(&'static str, &'static str, f32, f32)>,
+    name_w: f32,
+    label_x: f32,
+    opt_x0: f32,
+    /// How far the optional columns overflow the panel.
+    overflow: f32,
+    hscroll: f32,
+    /// Where the last column ends.
+    end_x: f32,
+}
+
+impl Columns {
+    /// `r` cut off under the frozen Name and Label columns.
+    fn opt_clip(&self, r: Rect) -> Rect {
+        Rect::from_min_max(pos2(r.min.x.max(self.opt_x0 - 4.0), r.min.y), r.max)
+    }
+}
+
+fn layout_columns(app: &mut EffectcraftApp, rect: Rect) -> Columns {
     let name_w = (rect.width() * 0.40).clamp(120.0, 260.0);
     let label_x = rect.min.x + name_w + 14.0;
     let mut cols: Vec<(&'static str, &'static str, f32, f32)> = vec![("name", "Name", rect.min.x + 26.0, name_w - 26.0), ("label", "", label_x - 8.0, 18.0)];
@@ -498,11 +511,18 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             x += w + 4.0;
         }
     }
-    let opt_clip = |r: Rect| Rect::from_min_max(pos2(r.min.x.max(opt_x0 - 4.0), r.min.y), r.max);
+    Columns { cols, name_w, label_x, opt_x0, overflow, hscroll, end_x: x }
+}
+
+/// The column header row: sort labels with the sort arrow, and the Columns menu.
+fn draw_header(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, hdr: Rect, cl: &Columns) {
+    let t = app.tokens;
+    let Columns { cols, label_x, end_x, .. } = cl;
+    let (label_x, end_x) = (*label_x, *end_x);
     let hp = p.with_clip_rect(hdr);
-    for (key, label, x, w) in &cols {
+    for (key, label, x, w) in cols {
         let hr = Rect::from_min_size(pos2(x - 4.0, hdr.min.y), vec2(*w, hdr.height()));
-        let hr = if matches!(*key, "name" | "label") { hr } else { opt_clip(hr) };
+        let hr = if matches!(*key, "name" | "label") { hr } else { cl.opt_clip(hr) };
         if hr.width() <= 0.0 {
             continue;
         }
@@ -546,446 +566,207 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
         column_menu(app, &resp);
     }
-    let hresp = ui.interact(Rect::from_min_max(pos2(x, hdr.min.y), hdr.max), egui::Id::unique("proj-hdr-rest"), Sense::CLICK);
+    let hresp = ui.interact(Rect::from_min_max(pos2(end_x, hdr.min.y), hdr.max), egui::Id::unique("proj-hdr-rest"), Sense::CLICK);
     column_menu(app, &hresp);
     app.auto.add("project.columns", hdr, "Columns (right-click to show or hide)");
-    // Rows.
-    let footer_h = 28.0;
-    let list = Rect::from_min_max(pos2(rect.min.x, hdr.max.y), pos2(rect.max.x, rect.max.y - footer_h));
-    let lp = p.with_clip_rect(list);
-    // The list's empty area (under the rows and the scroll bar, which take their own clicks):
-    // a click deselects, a drag draws a selection box, a double-click imports, as in After
-    // Effects (File ▸ Import ▸ File...).
-    // Not a Tab stop: the keyboard reaches the rows, and nothing else here takes a key.
-    let empty = ui.interact(list, egui::Id::unique("proj-empty"), Sense::CLICK | Sense::DRAG);
-    app.auto.add("project.empty", list, "Double-click to import files; drag to select items; right-click for project actions");
-    if overflow > 0.0 && ui.rect_contains_pointer(list) {
-        let (dx, dy, shift) = ui.input(|i| (i.smooth_scroll_delta.x, i.smooth_scroll_delta.y, i.modifiers.shift));
-        let d = if dx.abs() > 0.0 {
-            dx
-        } else if shift {
-            dy
-        } else {
-            0.0
-        };
-        app.ui.project_hscroll = (app.ui.project_hscroll - d).clamp(0.0, overflow);
+}
+
+/// An item row's context menu: Composition Settings, Delete, Rename, Duplicate, labels and the
+/// footage commands.
+fn item_menu(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    ctx: &egui::Context,
+    it: &effectcraft_engine::project::Item,
+    id: ItemId,
+    selected: bool,
+    actions: &mut Vec<(String, serde_json::Value)>,
+) {
+    let t = app.tokens;
+    let footage = matches!(it.kind, ItemKind::Footage(_));
+    // First on a comp, as in After Effects; for this comp, not the viewer's (#1058).
+    if matches!(it.kind, ItemKind::Comp(_)) && ui.button(crate::i18n::tr("Composition Settings…")).clicked() {
+        actions.push(("comp.settings".into(), json!({"comp": id.0})));
+        ui.close();
     }
-    let moved = keyboard_nav(app, &ctx);
-    let rows = visible_rows(app);
-    // Enter renames the selected item (Project panel focused, not typing).
-    if app.ui.focused == crate::dock::PanelKind::Project
-        && app.dialog.is_none()
-        && keys_reach_rows(app, &ctx)
-        && ctx.data(|d| d.get_temp::<Editing>(edit_id())).is_none()
-        && ctx.input(|i| i.key_pressed(egui::Key::Enter))
-    {
-        begin_rename(app, &ctx);
+    if ui.button(crate::i18n::tr("Delete")).clicked() {
+        actions.push(("project.delete".into(), json!({"items": targets(app, id, selected)})));
+        ui.close();
     }
-    let editing: Option<Editing> = ctx.data(|d| d.get_temp(edit_id()));
-    let dragging = egui::DragAndDrop::payload::<DragPayload>(&ctx).and_then(|p| match *p {
-        DragPayload::Item(i) => Some(i),
-        _ => None,
+    if matches!(it.kind, ItemKind::Comp(_)) && ui.button(crate::i18n::tr("Open Composition")).clicked() {
+        actions.push(("comp.open".into(), json!({"comp": id.0})));
+        ui.close();
+    }
+    if ui.button(crate::i18n::tr("Rename")).clicked() {
+        ctx.data_mut(|d| d.insert_temp::<Editing>(edit_id(), (id.0, "name".into(), it.name.clone())));
+        ui.close();
+    }
+    let duplicate_items = targets(app, id, selected);
+    // Like Edit > Duplicate: folders disable the whole operation, including mixed selections.
+    let can_duplicate = !duplicate_items.is_empty() && duplicate_items.iter().all(|id| app.session.project.item(ItemId(*id)).is_some_and(|i| !i.is_folder()));
+    let mut duplicate = egui::Button::new(crate::i18n::tr("Duplicate"));
+    if let Some(shortcut) = app.session.shortcuts().shortcut_of("edit.duplicate", &serde_json::Value::Null) {
+        duplicate = duplicate.shortcut_text(crate::menus::shortcut_text(shortcut));
+    }
+    let response = ui.add_enabled(can_duplicate, duplicate);
+    app.auto.add("project.context.duplicate", response.rect, "Duplicate");
+    if response.clicked() {
+        actions.push(("project.duplicate".into(), json!({"items": duplicate_items})));
+        ui.close();
+    }
+    if it.parent.is_some() && ui.button(crate::i18n::tr("Move to Project Root")).clicked() {
+        actions.push(("project.move".into(), json!({"items": targets(app, id, selected), "folder": null})));
+        ui.close();
+    }
+    // A composition cannot contain itself, so its own row offers nothing to add to (#2589).
+    if !it.is_folder() {
+        let add = ui.add_enabled(app.session.state.active_comp != Some(id), egui::Button::new(crate::i18n::tr("Add to Composition")));
+        app.auto.add("project.context.addToComposition", add.rect, "Add to Composition");
+        if add.clicked() {
+            actions.push(("layer.addItem".into(), json!({"item": id.0})));
+            ui.close();
+        }
+    }
+    // File ▸ New Comp from Selection on the selection (the right-clicked row joins it
+    // above): several items ask how in its dialog, as in After Effects (#360).
+    if ui.button(crate::i18n::tr("New Comp from Selection")).clicked() {
+        actions.push(("file.newCompFromSelection".into(), json!({})));
+        ui.close();
+    }
+    // File ▸ Replace Footage ▸ With Precomposition: every layer using the item uses a
+    // new composition holding it instead. The label says how many layers that changes.
+    let uses: usize = app.session.project.item_users(id).iter().map(|(_, n)| n).sum();
+    let label = match uses {
+        0 => crate::i18n::tr("Replace with Precomposition").to_owned(),
+        1 => format!("{} ({})", crate::i18n::tr("Replace with Precomposition"), crate::i18n::tr("used once")),
+        n => format!("{} ({})", crate::i18n::tr("Replace with Precomposition"), crate::i18n::tr_args("used {} times", &[&n])),
+    };
+    if (footage || matches!(it.kind, ItemKind::Solid(_))) && ui.button(label).clicked() {
+        actions.push(("file.replaceWithPrecomp".into(), json!({"item": id.0})));
+        ui.close();
+    }
+    ui.separator();
+    ui.menu_button(crate::i18n::tr("Label"), |ui| {
+        for l in Label::ALL {
+            if widgets::label_entry(ui, l, &app.session.prefs.label_name(l), l == it.label, &t).clicked() {
+                actions.push(("project.setLabel".into(), json!({"items": targets(app, id, selected), "label": label_index(l)})));
+                ui.close();
+            }
+        }
     });
-    let hover_y = ctx.pointer_hover_pos().filter(|p| list.contains(*p)).map(|p| p.y);
-    let mut drop_row: Option<ItemId> = None;
-    let mut actions: Vec<(String, serde_json::Value)> = vec![];
-    // Vertical scrolling: only the rows in view are drawn (and registered), so a project with
-    // thousands of items costs what one screenful does.
-    let content_h = rows.len() as f32 * ROW_H;
-    let max_scroll = (content_h - list.height() + ROW_H).max(0.0);
-    if ui.rect_contains_pointer(list) {
-        let (dy, shift) = ui.input(|i| (i.smooth_scroll_delta.y, i.modifiers.shift));
-        if !shift && dy != 0.0 {
-            app.ui.project_scroll -= dy;
-        }
+    // Footage: the File menu's footage commands (Interpret Footage, Replace Footage…).
+    if footage {
+        let mut chosen = None;
+        crate::menus::submenu_at(app, ui, &["File", "Interpret Footage"], &mut chosen);
+        crate::menus::submenu_at(app, ui, &["File", "Replace Footage"], &mut chosen);
+        crate::menus::entry_for(app, ui, "file.reloadFootage", &mut chosen);
+        crate::menus::entry_for(app, ui, "file.revealInFinder", &mut chosen);
+        actions.extend(chosen);
     }
-    // A selection made elsewhere (a command, an agent, the viewer) scrolls into view.
-    let sel_key = selection_seen_id();
-    let sel_now = app.session.state.project_selection.last().map(|i| i.0);
-    if ctx.data(|d| d.get_temp::<Option<u64>>(sel_key)) != Some(sel_now) {
-        ctx.data_mut(|d| d.insert_temp(sel_key, sel_now));
-        if let Some(row) = sel_now.and_then(|s| rows.iter().position(|(id, _)| id.0 == s)) {
-            let top = row as f32 * ROW_H;
-            if top < app.ui.project_scroll {
-                app.ui.project_scroll = top;
-            } else if top + ROW_H > app.ui.project_scroll + list.height() {
-                app.ui.project_scroll = top + ROW_H - list.height();
-            }
-        }
+}
+
+/// The inline rename / comment field over `cell` when it is item `id`'s `field` being edited;
+/// returns whether it took the cell.
+fn cell_edit(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    actions: &mut Vec<(String, serde_json::Value)>,
+    editing: &Option<Editing>,
+    id: u64,
+    field: &str,
+    cell: Rect,
+) -> bool {
+    let ctx = ui.ctx().clone();
+    let Some((eid, ef, mut buf)) = editing.clone().filter(|(e, f, _)| *e == id && f == field) else { return false };
+    let mut child = ui.new_child(egui::UiBuilder::new().max_rect(cell));
+    // The field keeps Tab (egui would move the keyboard to the next widget, where Enter no
+    // longer renames, #881): Tab commits like Enter and gives the keyboard back to the panel.
+    let filter = egui::EventFilter { tab: true, horizontal_arrows: true, vertical_arrows: true, ..Default::default() };
+    let resp = child.add(egui::TextEdit::singleline(&mut buf).desired_width(cell.width()).font(Tokens::ui(12.0)).event_filter(filter));
+    app.auto.add(&format!("project.item.{}.{field}Edit", id), cell, field);
+    let tab = resp.has_focus() && ctx.input(|i| i.key_pressed(egui::Key::Tab));
+    if tab {
+        resp.surrender_focus();
     }
-    // The arrow keys' item scrolls into view (Shift+Up extends upward, past the selection's end).
-    if let Some(row) = moved.and_then(|m| rows.iter().position(|(id, _)| *id == m)) {
-        let top = row as f32 * ROW_H;
-        // Not `clamp`: a panel shorter than a row would make its bounds cross. The row's top wins.
-        app.ui.project_scroll = app.ui.project_scroll.max(top + ROW_H - list.height()).min(top);
-    }
-    app.ui.project_scroll = app.ui.project_scroll.clamp(0.0, max_scroll);
-    let scroll = app.ui.project_scroll;
-    let first = ((scroll / ROW_H).floor() as usize).min(rows.len());
-    let mut y = list.min.y - (scroll - first as f32 * ROW_H);
-    let project = app.session.project.clone();
-    for (i, (id, depth)) in rows.iter().enumerate().skip(first) {
-        let Some(it) = project.item(*id) else { continue };
-        let r = Rect::from_min_size(pos2(list.min.x, y), vec2(list.width(), ROW_H));
-        y += ROW_H;
-        if r.min.y > list.max.y {
-            break;
-        }
-        if hover_y.is_some_and(|hy| hy >= r.min.y && hy < r.max.y) {
-            drop_row = Some(*id);
-        }
-        let selected = app.session.state.project_selection.contains(id);
-        lp.rect_filled(
-            r,
-            0.0,
-            // Flat rows like After Effects' Project panel (no stripes).
-            if selected { t.row_selected } else { t.row },
-        );
-        // The row's click / drag area goes first, so the twirl, proxy, label and comment widgets
-        // on top of it take their own clicks.
-        let mut resp = ui.interact(r.intersect(list), row_id(*id), Sense::click_and_drag());
-        app.auto.add(&format!("project.item.{}", id.0), r, &it.name);
-        // For screen readers: a tree item named by the item and its type, with its selection,
-        // depth and (a folder) open state. One Tab stop per row; the panel's keys then apply.
-        let open = it.is_folder().then(|| app.ui.project_open_folders.contains(&id.0) || !app.ui.project_search.is_empty());
-        resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::TreeItem, true, format!("{}, {}", it.name, crate::i18n::tr(it.type_name()))));
-        ctx.accesskit_node_builder(resp.id, |n| {
-            n.set_selected(selected);
-            n.set_level(depth.saturating_add(1));
-            if let Some(open) = open {
-                n.set_expanded(open);
-            }
-        });
-        if resp.has_focus() {
-            ctx.data_mut(|d| d.insert_temp(focused_row_id(), *id));
-        }
-        if resp.gained_focus() {
-            app.ui.focused = crate::dock::PanelKind::Project;
-        }
-        let _ = i;
-        let x0 = r.min.x + 8.0 + 14.0 * *depth as f32;
-        if it.is_folder() {
-            let open = app.ui.project_open_folders.contains(&id.0);
-            let tw = Rect::from_center_size(pos2(x0 + 4.0, r.center().y), vec2(12.0, 12.0));
-            let tresp = widgets::twirl(ui, tw, open, egui::Id::unique(("pf", id.0)), &t);
-            tresp.widget_info(|| {
-                let name = crate::i18n::tr_args(if open { "Close folder {}" } else { "Open folder {}" }, &[&it.name]);
-                egui::WidgetInfo::labeled(egui::Role::Button, true, name)
-            });
-            if tresp.clicked() {
-                // Alt/Cmd-click twirls every folder inside it too.
-                let mut ids = vec![*id];
-                if ui.input(|i| i.modifiers.alt || i.modifiers.command) {
-                    let mut at = 0;
-                    while let Some(f) = ids.get(at).copied() {
-                        ids.extend(app.session.project.children(Some(f)).into_iter().filter(|c| c.is_folder()).map(|c| c.id));
-                        at += 1;
-                    }
-                }
-                for f in ids {
-                    if open {
-                        app.ui.project_open_folders.remove(&f.0);
-                    } else {
-                        app.ui.project_open_folders.insert(f.0);
-                    }
-                }
-            }
-            app.auto.add(&format!("project.item.{}.twirl", id.0), tw, &it.name);
-        }
-        icons::paint(&lp, Rect::from_center_size(pos2(x0 + 18.0, r.center().y), vec2(14.0, 14.0)), item_icon(it), t.text_dim);
-        // Proxy indicator: filled = the proxy is used, hollow = set but off. Click to switch.
-        if let Some(px) = it.proxy.as_ref() {
-            let pr = Rect::from_center_size(pos2(x0 + 4.0, r.center().y), vec2(9.0, 9.0));
-            if px.enabled {
-                lp.rect_filled(pr, 1.0, t.text);
+    if resp.lost_focus() || tab {
+        ctx.data_mut(|d| d.remove::<Editing>(edit_id()));
+        if !ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
+            let (cmd, params) = if ef == "name" {
+                ("project.rename", json!({"item": eid, "name": buf}))
             } else {
-                lp.rect_stroke(pr, 1.0, Stroke::new(1.0, t.text), egui::StrokeKind::Inside);
-            }
-            let presp = ui.interact(pr.expand(2.0).intersect(list), egui::Id::unique(("pproxy", id.0)), Sense::click()).on_hover_text(format!(
-                "Proxy: {} ({})",
-                px.footage.path,
-                if px.enabled { "in use" } else { "off" }
-            ));
-            app.auto.add(&format!("project.item.{}.proxy", id.0), pr, if px.enabled { "Proxy in use" } else { "Proxy off" });
-            presp.widget_info(|| {
-                let name = crate::i18n::tr_args(if px.enabled { "Proxy of {}: in use" } else { "Proxy of {}: off" }, &[&it.name]);
-                egui::WidgetInfo::labeled(egui::Role::Button, true, name)
-            });
-            if presp.clicked() {
-                actions.push(("file.useProxy".into(), json!({"item": id.0})));
-            }
-        }
-        // Footage that can't be decoded (no decoder for its codec / profile): a warning marker
-        // at the end of the name cell, the reason on hover.
-        let problem = match &it.kind {
-            ItemKind::Footage(f) => app.session.footage.problem(f),
-            _ => None,
-        };
-        let name_clip =
-            Rect::from_min_max(pos2(x0 + 30.0, r.min.y), pos2(r.min.x + name_w + 4.0 - if problem.is_some() { 16.0 } else { 0.0 }, r.max.y)).intersect(list);
-        if let Some(why) = &problem {
-            let m = Rect::from_center_size(pos2(r.min.x + name_w - 8.0, r.center().y), vec2(13.0, 12.0));
-            lp.add(egui::Shape::convex_polygon(vec![m.center_top(), m.right_bottom(), m.left_bottom()], t.warning, Stroke::NONE));
-            lp.text(m.center() + vec2(0.0, 1.5), Align2::CENTER_CENTER, "!", Tokens::semibold(9.0), Color32::BLACK);
-            ui.interact(m.expand(2.0).intersect(list), egui::Id::unique(("pproblem", id.0)), Sense::hover()).on_hover_text(why.as_str());
-            app.auto.add(&format!("project.item.{}.problem", id.0), m, why);
-        }
-        let name_rect = Rect::from_min_max(pos2(x0 + 28.0, r.min.y + 2.0), pos2(r.min.x + name_w + 2.0, r.max.y - 2.0));
-        // Inline edits (rename / comment).
-        let cell_edit = |app: &mut EffectcraftApp, ui: &mut egui::Ui, actions: &mut Vec<(String, serde_json::Value)>, field: &str, cell: Rect| -> bool {
-            let Some((eid, ef, mut buf)) = editing.clone().filter(|(e, f, _)| *e == id.0 && f == field) else { return false };
-            let mut child = ui.new_child(egui::UiBuilder::new().max_rect(cell));
-            // The field keeps Tab (egui would move the keyboard to the next widget, where Enter no
-            // longer renames, #881): Tab commits like Enter and gives the keyboard back to the panel.
-            let filter = egui::EventFilter { tab: true, horizontal_arrows: true, vertical_arrows: true, ..Default::default() };
-            let resp = child.add(egui::TextEdit::singleline(&mut buf).desired_width(cell.width()).font(Tokens::ui(12.0)).event_filter(filter));
-            app.auto.add(&format!("project.item.{}.{field}Edit", id.0), cell, field);
-            let tab = resp.has_focus() && ctx.input(|i| i.key_pressed(egui::Key::Tab));
-            if tab {
-                resp.surrender_focus();
-            }
-            if resp.lost_focus() || tab {
-                ctx.data_mut(|d| d.remove::<Editing>(edit_id()));
-                if !ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
-                    let (cmd, params) = if ef == "name" {
-                        ("project.rename", json!({"item": eid, "name": buf}))
-                    } else {
-                        ("project.setComment", json!({"items": [eid], "comment": buf}))
-                    };
-                    actions.push((cmd.into(), params));
-                }
-            } else {
-                widgets::keep_focus(&ctx, &resp, &buf);
-                ctx.data_mut(|d| d.insert_temp::<Editing>(edit_id(), (eid, ef, buf)));
-            }
-            true
-        };
-        if !cell_edit(app, ui, &mut actions, "name", name_rect) {
-            // The selected item's name sits in a light cell with dark text.
-            if selected {
-                let g = lp.layout_no_wrap(it.name.clone(), Tokens::ui(12.0), Color32::BLACK);
-                let cell = Rect::from_min_max(pos2(x0 + 27.0, r.min.y + 1.0), pos2((x0 + 33.0 + g.size().x).min(name_clip.max.x), r.max.y - 1.0));
-                lp.with_clip_rect(name_clip.expand2(vec2(3.0, 0.0))).rect_filled(cell, 0.0, Color32::from_rgb(0xa6, 0xa6, 0xa6));
-            }
-            // Long names end in "…" before the label column instead of being cut mid-glyph.
-            widgets::text_fit(
-                &lp.with_clip_rect(name_clip),
-                pos2(x0 + 30.0, r.center().y),
-                Align2::LEFT_CENTER,
-                &it.name,
-                Tokens::ui(12.0),
-                name_clip.max.x - (x0 + 30.0) - 2.0,
-                if selected { Color32::from_gray(0x16) } else { t.text },
-            );
-        }
-        // Label swatch: click for the label colour menu.
-        let sw = Rect::from_center_size(pos2(label_x, r.center().y), vec2(10.0, 10.0));
-        lp.rect_filled(sw, 2.0, t.label(it.label));
-        let sresp = ui.interact(sw.expand(3.0).intersect(list), egui::Id::unique(("plabel", id.0)), Sense::click());
-        app.auto.add(&format!("project.item.{}.label", id.0), sw, it.label.name());
-        sresp.widget_info(|| {
-            let name = crate::i18n::tr_args("Label of {}: {}", &[&it.name, &app.session.prefs.label_name(it.label)]);
-            egui::WidgetInfo::labeled(egui::Role::Button, true, name)
-        });
-        let pop = egui::Id::unique(("plabel-pop", id.0));
-        if sresp.clicked() || sresp.secondary_clicked() {
-            widgets::open_popup(ui, pop);
-        }
-        if let Some(l) = widgets::label_popup(ui, pop, sw.left_bottom(), it.label, |l| app.session.prefs.label_name(l), &t) {
-            actions.push(("project.setLabel".into(), json!({"items": targets(app, *id, selected), "label": label_index(l)})));
-        }
-        // Optional columns.
-        for (key, _, cx, w) in cols.iter().skip(2) {
-            let cell = opt_clip(Rect::from_min_size(pos2(*cx, r.min.y), vec2(*w, r.height())).intersect(list));
-            if cell.width() <= 0.0 {
-                continue;
-            }
-            let cp = lp.with_clip_rect(cell);
-            let txt = match *key {
-                "type" => it.type_name().to_string(),
-                "size" => file_size(it).map(fmt_size).unwrap_or_default(),
-                "duration" => it.duration().map(|d| fmt_dur(d.seconds(), it.frame_rate().map(|r| r.as_f64()).unwrap_or(30.0))).unwrap_or_default(),
-                "fps" => it.frame_rate().map(|f| format!("{:.2}", f.as_f64())).unwrap_or_default(),
-                "path" => file_path(it).to_string(),
-                "comment" => {
-                    let cr = Rect::from_min_size(pos2(*cx - 2.0, r.min.y + 2.0), vec2(*w, r.height() - 4.0));
-                    if cell_edit(app, ui, &mut actions, "comment", cr) {
-                        continue;
-                    }
-                    let cresp = ui.interact(cell, egui::Id::unique(("pcomment", id.0)), Sense::CLICK);
-                    app.auto.add(&format!("project.item.{}.comment", id.0), cell, &it.comment);
-                    cresp.widget_info(|| {
-                        egui::WidgetInfo::labeled(egui::Role::Unknown, true, crate::i18n::tr_args("Comment of {}: {}", &[&it.name, &it.comment]))
-                    });
-                    if cresp.double_clicked() {
-                        ctx.data_mut(|d| d.insert_temp::<Editing>(edit_id(), (id.0, "comment".into(), it.comment.clone())));
-                    } else {
-                        // Other clicks select the row and open its context menu.
-                        resp = resp.union(cresp);
-                    }
-                    it.comment.clone()
-                }
-                _ => String::new(),
+                ("project.setComment", json!({"items": [eid], "comment": buf}))
             };
-            let align = if *key == "fps" { Align2::RIGHT_CENTER } else { Align2::LEFT_CENTER };
-            let tx = if *key == "fps" { cx + w - 6.0 } else { *cx };
-            cp.text(pos2(tx, r.center().y), align, txt, Tokens::ui(11.5), t.text_dim);
+            actions.push((cmd.into(), params));
         }
-        if dragging.is_some_and(|d| d != id.0) && drop_row == Some(*id) && it.is_folder() {
-            lp.rect_stroke(r.shrink(1.0), 2.0, Stroke::new(1.5, t.accent), egui::StrokeKind::Inside);
-        }
-        // The row with keyboard focus (Tab, or the arrow keys after it) shows a focus ring.
-        if ctx.memory(|m| m.has_focus(row_id(*id))) {
-            lp.rect_stroke(r.shrink(0.5), 0.0, Stroke::new(1.0, t.accent), egui::StrokeKind::Inside);
-        }
-        // Part of the row: not a second Tab stop.
-        let nresp = ui.interact(name_clip, egui::Id::unique(("pname", id.0)), Sense::CLICK | Sense::DRAG);
-        app.auto.add(&format!("project.item.{}.name", id.0), name_clip, &it.name);
-        let resp = resp.union(nresp);
-        if resp.clicked() {
-            let m = ui.input(|i| i.modifiers);
-            let anchor_key = anchor_id();
-            ctx.data_mut(|d| d.insert_temp(cursor_id(), *id));
-            let anchor = ctx.data(|d| d.get_temp::<ItemId>(anchor_key)).or_else(|| app.session.state.project_selection.first().copied());
-            if m.shift
-                && let Some(a) = anchor.and_then(|a| rows.iter().position(|(i, _)| *i == a))
-            {
-                let b = rows.iter().position(|(i, _)| i == id).unwrap_or(a);
-                app.session.state.project_selection = rows.get(a.min(b)..=a.max(b)).unwrap_or_default().iter().map(|(i, _)| *i).collect();
-            } else if m.command {
-                if app.session.state.project_selection.contains(id) {
-                    app.session.state.project_selection.retain(|i| i != id);
-                } else {
-                    app.session.state.project_selection.push(*id);
-                }
-                ctx.data_mut(|d| d.insert_temp(anchor_key, *id));
-            } else {
-                app.session.state.project_selection = vec![*id];
-                ctx.data_mut(|d| d.insert_temp(anchor_key, *id));
-            }
-        }
-        // Double-click opens the item, as in After Effects (a comp gets its own Timeline tab and
-        // the viewer); Enter or the context menu renames.
-        if resp.double_clicked() {
-            match &it.kind {
-                ItemKind::Comp(_) => actions.push(("comp.open".into(), json!({"comp": id.0}))),
-                ItemKind::Folder if !app.ui.project_open_folders.remove(&id.0) => {
-                    app.ui.project_open_folders.insert(id.0);
-                }
-                // Footage (not data) and solids open in the Footage panel.
-                ItemKind::Footage(f) if f.kind != effectcraft_engine::project::FootageKind::Data => {
-                    actions.push(("footage.open".into(), json!({"item": id.0})))
-                }
-                ItemKind::Solid(_) => actions.push(("footage.open".into(), json!({"item": id.0}))),
-                _ => {}
-            }
-        }
-        if resp.drag_started() {
-            egui::DragAndDrop::set_payload(&ctx, DragPayload::Item(id.0));
-        }
-        // Right-clicking an item selects it (After Effects): the menu's File commands act on the
-        // selection.
-        if resp.secondary_clicked() && !selected {
-            app.session.state.project_selection = vec![*id];
-        }
-        let footage = matches!(it.kind, ItemKind::Footage(_));
-        crate::widgets::context_menu(&resp, |ui| {
-            // First on a comp, as in After Effects; for this comp, not the viewer's (#1058).
-            if matches!(it.kind, ItemKind::Comp(_)) && ui.button(crate::i18n::tr("Composition Settings…")).clicked() {
-                actions.push(("comp.settings".into(), json!({"comp": id.0})));
-                ui.close();
-            }
-            if ui.button(crate::i18n::tr("Delete")).clicked() {
-                actions.push(("project.delete".into(), json!({"items": targets(app, *id, selected)})));
-                ui.close();
-            }
-            if matches!(it.kind, ItemKind::Comp(_)) && ui.button(crate::i18n::tr("Open Composition")).clicked() {
-                actions.push(("comp.open".into(), json!({"comp": id.0})));
-                ui.close();
-            }
-            if ui.button(crate::i18n::tr("Rename")).clicked() {
-                ctx.data_mut(|d| d.insert_temp::<Editing>(edit_id(), (id.0, "name".into(), it.name.clone())));
-                ui.close();
-            }
-            let duplicate_items = targets(app, *id, selected);
-            // Like Edit > Duplicate: folders disable the whole operation, including mixed selections.
-            let can_duplicate =
-                !duplicate_items.is_empty() && duplicate_items.iter().all(|id| app.session.project.item(ItemId(*id)).is_some_and(|i| !i.is_folder()));
-            let mut duplicate = egui::Button::new(crate::i18n::tr("Duplicate"));
-            if let Some(shortcut) = app.session.shortcuts().shortcut_of("edit.duplicate", &serde_json::Value::Null) {
-                duplicate = duplicate.shortcut_text(crate::menus::shortcut_text(shortcut));
-            }
-            let response = ui.add_enabled(can_duplicate, duplicate);
-            app.auto.add("project.context.duplicate", response.rect, "Duplicate");
-            if response.clicked() {
-                actions.push(("project.duplicate".into(), json!({"items": duplicate_items})));
-                ui.close();
-            }
-            if it.parent.is_some() && ui.button(crate::i18n::tr("Move to Project Root")).clicked() {
-                actions.push(("project.move".into(), json!({"items": targets(app, *id, selected), "folder": null})));
-                ui.close();
-            }
-            if !it.is_folder() && ui.button(crate::i18n::tr("Add to Composition")).clicked() {
-                actions.push(("layer.addItem".into(), json!({"item": id.0})));
-                ui.close();
-            }
-            // File ▸ New Comp from Selection on the selection (the right-clicked row joins it
-            // above): several items ask how in its dialog, as in After Effects (#360).
-            if ui.button(crate::i18n::tr("New Comp from Selection")).clicked() {
-                actions.push(("file.newCompFromSelection".into(), json!({})));
-                ui.close();
-            }
-            // File ▸ Replace Footage ▸ With Precomposition: every layer using the item uses a
-            // new composition holding it instead. The label says how many layers that changes.
-            let uses: usize = app.session.project.item_users(*id).iter().map(|(_, n)| n).sum();
-            let label = match uses {
-                0 => crate::i18n::tr("Replace with Precomposition").to_owned(),
-                1 => format!("{} ({})", crate::i18n::tr("Replace with Precomposition"), crate::i18n::tr("used once")),
-                n => format!("{} ({})", crate::i18n::tr("Replace with Precomposition"), crate::i18n::tr_args("used {} times", &[&n])),
-            };
-            if (footage || matches!(it.kind, ItemKind::Solid(_))) && ui.button(label).clicked() {
-                actions.push(("file.replaceWithPrecomp".into(), json!({"item": id.0})));
-                ui.close();
-            }
-            ui.separator();
-            ui.menu_button(crate::i18n::tr("Label"), |ui| {
-                for l in Label::ALL {
-                    if widgets::label_entry(ui, l, &app.session.prefs.label_name(l), l == it.label, &t).clicked() {
-                        actions.push(("project.setLabel".into(), json!({"items": targets(app, *id, selected), "label": label_index(l)})));
-                        ui.close();
-                    }
-                }
-            });
-            // Footage: the File menu's footage commands (Interpret Footage, Replace Footage…).
-            if footage {
-                let mut chosen = None;
-                crate::menus::submenu_at(app, ui, &["File", "Interpret Footage"], &mut chosen);
-                crate::menus::submenu_at(app, ui, &["File", "Replace Footage"], &mut chosen);
-                crate::menus::entry_for(app, ui, "file.reloadFootage", &mut chosen);
-                crate::menus::entry_for(app, ui, "file.revealInFinder", &mut chosen);
-                actions.extend(chosen);
-            }
-        });
+    } else {
+        widgets::keep_focus(&ctx, &resp, &buf);
+        ctx.data_mut(|d| d.insert_temp::<Editing>(edit_id(), (eid, ef, buf)));
     }
-    // The scroll bars, over the rows (which would take their presses otherwise).
-    if overflow > 0.0 {
-        let track = Rect::from_min_max(pos2(opt_x0, list.max.y - 5.0), pos2(rect.max.x - 4.0, list.max.y - 1.0));
-        app.ui.project_hscroll = widgets::scroll_bar(ui, &mut app.auto, "project.hscroll", track, hscroll, overflow, &t);
+    true
+}
+
+/// A click on item `id`'s row: plain selects it, Shift extends from the anchor and Cmd toggles.
+fn select_click(app: &mut EffectcraftApp, ui: &egui::Ui, ctx: &egui::Context, id: ItemId, rows: &[(ItemId, usize)]) {
+    let m = ui.input(|i| i.modifiers);
+    let anchor_key = anchor_id();
+    ctx.data_mut(|d| d.insert_temp(cursor_id(), id));
+    let anchor = ctx.data(|d| d.get_temp::<ItemId>(anchor_key)).or_else(|| app.session.state.project_selection.first().copied());
+    if m.shift
+        && let Some(a) = anchor.and_then(|a| rows.iter().position(|(i, _)| *i == a))
+    {
+        let b = rows.iter().position(|(i, _)| *i == id).unwrap_or(a);
+        app.session.state.project_selection = rows.get(a.min(b)..=a.max(b)).unwrap_or_default().iter().map(|(i, _)| *i).collect();
+    } else if m.command {
+        if app.session.state.project_selection.contains(&id) {
+            app.session.state.project_selection.retain(|i| *i != id);
+        } else {
+            app.session.state.project_selection.push(id);
+        }
+        ctx.data_mut(|d| d.insert_temp(anchor_key, id));
+    } else {
+        app.session.state.project_selection = vec![id];
+        ctx.data_mut(|d| d.insert_temp(anchor_key, id));
     }
-    if max_scroll > 0.0 {
-        let track = Rect::from_min_max(pos2(rect.max.x - 6.0, list.min.y + 1.0), pos2(rect.max.x - 2.0, list.max.y - 7.0));
-        app.ui.project_scroll = widgets::scroll_bar(ui, &mut app.auto, "project.vscroll", track, scroll, max_scroll, &t);
+}
+
+/// Double-click opens the item, as in After Effects: a comp in its Timeline and the viewer, a
+/// folder toggles, footage (not data) and solids open in the Footage panel.
+fn open_item(app: &mut EffectcraftApp, it: &effectcraft_engine::project::Item, id: ItemId, actions: &mut Vec<(String, serde_json::Value)>) {
+    match &it.kind {
+        ItemKind::Comp(_) => actions.push(("comp.open".into(), json!({"comp": id.0}))),
+        ItemKind::Folder if !app.ui.project_open_folders.remove(&id.0) => {
+            app.ui.project_open_folders.insert(id.0);
+        }
+        // Footage (not data) and solids open in the Footage panel.
+        ItemKind::Footage(f) if f.kind != effectcraft_engine::project::FootageKind::Data => actions.push(("footage.open".into(), json!({"item": id.0}))),
+        ItemKind::Solid(_) => actions.push(("footage.open".into(), json!({"item": id.0}))),
+        _ => {}
     }
+}
+
+/// What the pointer is doing over the list: the item being dragged, the row under it, whether it
+/// is over the list at all.
+struct DropState {
+    dragging: Option<u64>,
+    row: Option<ItemId>,
+    hovering: bool,
+}
+
+/// Dragging an item or files over the list: drop outlines, moving items into folders, importing
+/// files and the drag ghost.
+fn drop_targets(app: &mut EffectcraftApp, ctx: &egui::Context, lp: &egui::Painter, list: Rect, ds: DropState, actions: &mut Vec<(String, serde_json::Value)>) {
+    let t = app.tokens;
+    let DropState { dragging, row, hovering } = ds;
     // Dropping a dragged item on the list: into the folder under the pointer (or the folder of
     // the item under it), or the project root below the rows.
     if let Some(iid) = dragging
-        && hover_y.is_some()
+        && hovering
     {
-        if drop_row.is_none() {
+        if row.is_none() {
             lp.rect_stroke(list.shrink(1.0), 0.0, Stroke::new(1.0, t.accent.gamma_multiply(0.6)), egui::StrokeKind::Inside);
         }
-        if ctx.input(|i| i.pointer.any_released()) && drop_row != Some(ItemId(iid)) {
-            let folder = drop_folder(&app.session.project, drop_row);
+        if ctx.input(|i| i.pointer.any_released()) && row != Some(ItemId(iid)) {
+            let folder = drop_folder(&app.session.project, row);
             let cur = app.session.project.item(ItemId(iid)).and_then(|i| i.parent);
             if folder != cur {
                 let moving: Vec<u64> = if app.session.state.project_selection.contains(&ItemId(iid)) {
@@ -998,21 +779,21 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     app.ui.project_open_folders.insert(f.0);
                 }
             }
-            egui::DragAndDrop::clear_payload(&ctx);
+            egui::DragAndDrop::clear_payload(ctx);
         }
     }
     // Files dragged from the Media Browser: import.
-    if let Some(DragPayload::Files(paths)) = egui::DragAndDrop::payload::<DragPayload>(&ctx).as_deref()
-        && hover_y.is_some()
+    if let Some(DragPayload::Files(paths)) = egui::DragAndDrop::payload::<DragPayload>(ctx).as_deref()
+        && hovering
     {
         lp.rect_stroke(list.shrink(1.0), 0.0, Stroke::new(1.0, t.accent.gamma_multiply(0.6)), egui::StrokeKind::Inside);
         if ctx.input(|i| i.pointer.any_released()) {
             actions.push(("mediaBrowser.import".into(), json!({"paths": paths})));
-            egui::DragAndDrop::clear_payload(&ctx);
+            egui::DragAndDrop::clear_payload(ctx);
         }
     }
     // Drag ghost.
-    if let Some(DragPayload::Item(iid)) = egui::DragAndDrop::payload::<DragPayload>(&ctx).as_deref()
+    if let Some(DragPayload::Item(iid)) = egui::DragAndDrop::payload::<DragPayload>(ctx).as_deref()
         && let Some(pos) = ctx.pointer_hover_pos()
         && let Some(it) = app.session.project.item(ItemId(*iid))
     {
@@ -1022,8 +803,12 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         painter.rect_filled(r, 4.0, Color32::from_rgba_premultiplied(40, 40, 40, 230));
         painter.galley(r.min + vec2(8.0, 4.0), g, t.text);
     }
-    // Footer.
-    let foot = Rect::from_min_max(pos2(rect.min.x, rect.max.y - footer_h), rect.max);
+}
+
+/// The footer: Interpret Footage, New Folder, New Composition, the colour depth and the trash.
+fn footer(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, foot: Rect, actions: &mut Vec<(String, serde_json::Value)>) {
+    let t = app.tokens;
+    let ctx = ui.ctx().clone();
     p.line_segment([foot.left_top(), foot.right_top()], Stroke::new(1.0, t.separator));
     let mut x = foot.min.x + 8.0;
     for (icon, id, tip) in [
@@ -1032,7 +817,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         (Icon::NewComp, "newComp", "Create a new Composition"),
     ] {
         let r = Rect::from_min_size(pos2(x, foot.min.y + 3.0), vec2(22.0, 22.0));
-        let resp = widgets::icon_button(ui, r, icon, false, &t, egui::Id::unique(("pfoot", id))).on_hover_text(tip);
+        let resp = widgets::icon_button(ui, r, icon, false, &t, egui::Id::unique(("pfoot", id))).on_hover_text(crate::i18n::tr(tip));
         app.auto.add(&format!("project.{id}"), r, tip);
         resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, crate::i18n::tr(tip)));
         if resp.clicked() {
@@ -1085,23 +870,102 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         actions.push(("project.delete".into(), json!({})));
     }
     app.auto.add("project.delete", tr, "Delete");
-    if empty.double_clicked() {
-        actions.push(("file.import".into(), json!({})));
-    }
-    crate::widgets::context_menu(&empty, |ui| {
-        for (key, label, command) in
-            [("newComp", "New Composition…", "comp.new"), ("newFolder", "New Folder", "project.newFolder"), ("import", "Import File…", "file.import")]
-        {
-            let response = ui.button(label);
-            app.auto.add(&format!("project.context.{key}"), response.rect, label);
-            if response.clicked() {
-                actions.push((command.into(), json!({})));
-                ui.close();
-            }
+}
+
+/// The optional columns of a row (type, size, duration, fps, path, comment). Returns the comment
+/// cell's response so its clicks select the row and open its context menu.
+fn optional_cells(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    g: &RowGeom,
+    it: &effectcraft_engine::project::Item,
+    cl: &Columns,
+    editing: &Option<Editing>,
+    actions: &mut Vec<(String, serde_json::Value)>,
+) -> Option<egui::Response> {
+    let t = app.tokens;
+    let ctx = ui.ctx().clone();
+    let RowGeom { lp, list, r, .. } = *g;
+    let mut extra = None;
+    for (key, _, cx, w) in cl.cols.iter().skip(2) {
+        let cell = cl.opt_clip(Rect::from_min_size(pos2(*cx, r.min.y), vec2(*w, r.height())).intersect(list));
+        if cell.width() <= 0.0 {
+            continue;
         }
-    });
-    // Selection box over the rows it touches (#203); Shift or Cmd/Ctrl adds to the selection.
-    let adding = ui.input(|i| i.modifiers.shift || i.modifiers.command);
+        let cp = lp.with_clip_rect(cell);
+        let txt = match *key {
+            "type" => it.type_name().to_string(),
+            "size" => file_size(it).map(fmt_size).unwrap_or_default(),
+            "duration" => it.duration().map(|d| fmt_dur(d.seconds(), it.frame_rate().map(|r| r.as_f64()).unwrap_or(30.0))).unwrap_or_default(),
+            "fps" => it.frame_rate().map(|f| format!("{:.2}", f.as_f64())).unwrap_or_default(),
+            "path" => file_path(it).to_string(),
+            "comment" => {
+                let cr = Rect::from_min_size(pos2(*cx - 2.0, r.min.y + 2.0), vec2(*w, r.height() - 4.0));
+                if cell_edit(app, ui, actions, editing, it.id.0, "comment", cr) {
+                    continue;
+                }
+                let cresp = ui.interact(cell, egui::Id::unique(("pcomment", it.id.0)), Sense::CLICK);
+                app.auto.add(&format!("project.item.{}.comment", it.id.0), cell, &it.comment);
+                cresp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Unknown, true, crate::i18n::tr_args("Comment of {}: {}", &[&it.name, &it.comment])));
+                if cresp.double_clicked() {
+                    ctx.data_mut(|d| d.insert_temp::<Editing>(edit_id(), (it.id.0, "comment".into(), it.comment.clone())));
+                } else {
+                    // Other clicks select the row and open its context menu.
+                    extra = Some(cresp);
+                }
+                it.comment.clone()
+            }
+            _ => String::new(),
+        };
+        let align = if *key == "fps" { Align2::RIGHT_CENTER } else { Align2::LEFT_CENTER };
+        let tx = if *key == "fps" { cx + w - 6.0 } else { *cx };
+        cp.text(pos2(tx, r.center().y), align, txt, Tokens::ui(11.5), t.text_dim);
+    }
+    extra
+}
+
+/// Shift+wheel / trackpad over the list scrolls the optional columns sideways.
+fn hscroll_wheel(app: &mut EffectcraftApp, ui: &egui::Ui, list: Rect, overflow: f32) {
+    if overflow > 0.0 && ui.rect_contains_pointer(list) {
+        let (dx, dy, shift) = ui.input(|i| (i.smooth_scroll_delta.x, i.smooth_scroll_delta.y, i.modifiers.shift));
+        let d = if dx.abs() > 0.0 {
+            dx
+        } else if shift {
+            dy
+        } else {
+            0.0
+        };
+        app.ui.project_hscroll = (app.ui.project_hscroll - d).clamp(0.0, overflow);
+    }
+}
+
+/// Enter renames the selected item (Project panel focused, not typing).
+fn enter_renames(app: &mut EffectcraftApp, ctx: &egui::Context) {
+    if app.ui.focused == crate::dock::PanelKind::Project
+        && app.dialog.is_none()
+        && keys_reach_rows(app, ctx)
+        && ctx.data(|d| d.get_temp::<Editing>(edit_id())).is_none()
+        && ctx.input(|i| i.key_pressed(egui::Key::Enter))
+    {
+        begin_rename(app, ctx);
+    }
+}
+
+/// The warning marker at the end of the name cell for footage that can't be decoded.
+fn problem_marker(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &RowGeom, name_w: f32, id: ItemId, why: &str) {
+    let t = app.tokens;
+    let RowGeom { lp, list, r, .. } = *g;
+    let m = Rect::from_center_size(pos2(r.min.x + name_w - 8.0, r.center().y), vec2(13.0, 12.0));
+    lp.add(egui::Shape::convex_polygon(vec![m.center_top(), m.right_bottom(), m.left_bottom()], t.warning, Stroke::NONE));
+    lp.text(m.center() + vec2(0.0, 1.5), Align2::CENTER_CENTER, "!", Tokens::semibold(9.0), Color32::BLACK);
+    ui.interact(m.expand(2.0).intersect(list), egui::Id::unique(("pproblem", id.0)), Sense::hover()).on_hover_text(why);
+    app.auto.add(&format!("project.item.{}.problem", id.0), m, why);
+}
+
+/// Selection box over the rows it touches (#203); Shift or Cmd/Ctrl adds to the selection.
+fn marquee_select(app: &mut EffectcraftApp, ctx: &egui::Context, lp: &egui::Painter, list: Rect, empty: &egui::Response, rows: &[(ItemId, usize)]) {
+    let t = app.tokens;
+    let adding = ctx.input(|i| i.modifiers.shift || i.modifiers.command);
     if empty.clicked() && !adding {
         app.session.state.project_selection.clear();
     }
@@ -1135,6 +999,330 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         }
     }
+}
+
+/// Where a row is drawn: its clipped painter, the list, the row rectangle and the indented x.
+#[derive(Clone, Copy)]
+struct RowGeom<'a> {
+    lp: &'a egui::Painter,
+    list: Rect,
+    r: Rect,
+    x0: f32,
+}
+
+/// Vertical scrolling: only the rows in view are drawn (and registered), so a project with
+/// thousands of items costs what one screenful does. Returns the scroll offset and its maximum.
+fn update_scroll(app: &mut EffectcraftApp, ui: &egui::Ui, ctx: &egui::Context, list: Rect, rows: &[(ItemId, usize)], moved: Option<ItemId>) -> (f32, f32) {
+    let content_h = rows.len() as f32 * ROW_H;
+    let max_scroll = (content_h - list.height() + ROW_H).max(0.0);
+    if ui.rect_contains_pointer(list) {
+        let (dy, shift) = ui.input(|i| (i.smooth_scroll_delta.y, i.modifiers.shift));
+        if !shift && dy != 0.0 {
+            app.ui.project_scroll -= dy;
+        }
+    }
+    // A selection made elsewhere (a command, an agent, the viewer) scrolls into view.
+    let sel_key = selection_seen_id();
+    let sel_now = app.session.state.project_selection.last().map(|i| i.0);
+    if ctx.data(|d| d.get_temp::<Option<u64>>(sel_key)) != Some(sel_now) {
+        ctx.data_mut(|d| d.insert_temp(sel_key, sel_now));
+        if let Some(row) = sel_now.and_then(|s| rows.iter().position(|(id, _)| id.0 == s)) {
+            let top = row as f32 * ROW_H;
+            if top < app.ui.project_scroll {
+                app.ui.project_scroll = top;
+            } else if top + ROW_H > app.ui.project_scroll + list.height() {
+                app.ui.project_scroll = top + ROW_H - list.height();
+            }
+        }
+    }
+    // The arrow keys' item scrolls into view (Shift+Up extends upward, past the selection's end).
+    if let Some(row) = moved.and_then(|m| rows.iter().position(|(id, _)| *id == m)) {
+        let top = row as f32 * ROW_H;
+        // Not `clamp`: a panel shorter than a row would make its bounds cross. The row's top wins.
+        app.ui.project_scroll = app.ui.project_scroll.max(top + ROW_H - list.height()).min(top);
+    }
+    app.ui.project_scroll = app.ui.project_scroll.clamp(0.0, max_scroll);
+    (app.ui.project_scroll, max_scroll)
+}
+
+/// The folder's open / close twirl (Alt / Cmd-click twirls every folder inside it too).
+fn folder_twirl(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &RowGeom, it: &effectcraft_engine::project::Item) {
+    let t = app.tokens;
+    let RowGeom { r, x0, .. } = *g;
+    let open = app.ui.project_open_folders.contains(&it.id.0);
+    let tw = Rect::from_center_size(pos2(x0 + 4.0, r.center().y), vec2(12.0, 12.0));
+    let tresp = widgets::twirl(ui, tw, open, egui::Id::unique(("pf", it.id.0)), &t);
+    tresp.widget_info(|| {
+        let name = crate::i18n::tr_args(if open { "Close folder {}" } else { "Open folder {}" }, &[&it.name]);
+        egui::WidgetInfo::labeled(egui::Role::Button, true, name)
+    });
+    if tresp.clicked() {
+        // Alt/Cmd-click twirls every folder inside it too.
+        let mut ids = vec![it.id];
+        if ui.input(|i| i.modifiers.alt || i.modifiers.command) {
+            let mut at = 0;
+            while let Some(f) = ids.get(at).copied() {
+                ids.extend(app.session.project.children(Some(f)).into_iter().filter(|c| c.is_folder()).map(|c| c.id));
+                at += 1;
+            }
+        }
+        for f in ids {
+            if open {
+                app.ui.project_open_folders.remove(&f.0);
+            } else {
+                app.ui.project_open_folders.insert(f.0);
+            }
+        }
+    }
+    app.auto.add(&format!("project.item.{}.twirl", it.id.0), tw, &it.name);
+}
+
+/// Proxy indicator: filled = the proxy is used, hollow = set but off. Click to switch.
+fn proxy_indicator(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    g: &RowGeom,
+    it: &effectcraft_engine::project::Item,
+    actions: &mut Vec<(String, serde_json::Value)>,
+) {
+    let t = app.tokens;
+    let RowGeom { lp, list, r, x0 } = *g;
+    if let Some(px) = it.proxy.as_ref() {
+        let pr = Rect::from_center_size(pos2(x0 + 4.0, r.center().y), vec2(9.0, 9.0));
+        if px.enabled {
+            lp.rect_filled(pr, 1.0, t.text);
+        } else {
+            lp.rect_stroke(pr, 1.0, Stroke::new(1.0, t.text), egui::StrokeKind::Inside);
+        }
+        let presp = ui.interact(pr.expand(2.0).intersect(list), egui::Id::unique(("pproxy", it.id.0)), Sense::click()).on_hover_text(format!(
+            "Proxy: {} ({})",
+            px.footage.path,
+            if px.enabled { "in use" } else { "off" }
+        ));
+        app.auto.add(&format!("project.item.{}.proxy", it.id.0), pr, if px.enabled { "Proxy in use" } else { "Proxy off" });
+        presp.widget_info(|| {
+            let name = crate::i18n::tr_args(if px.enabled { "Proxy of {}: in use" } else { "Proxy of {}: off" }, &[&it.name]);
+            egui::WidgetInfo::labeled(egui::Role::Button, true, name)
+        });
+        if presp.clicked() {
+            actions.push(("file.useProxy".into(), json!({"item": it.id.0})));
+        }
+    }
+}
+
+/// The label swatch: click for the label colour menu.
+fn label_swatch(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    g: &RowGeom,
+    it: &effectcraft_engine::project::Item,
+    label_x: f32,
+    selected: bool,
+    actions: &mut Vec<(String, serde_json::Value)>,
+) {
+    let t = app.tokens;
+    let RowGeom { lp, list, r, .. } = *g;
+    let sw = Rect::from_center_size(pos2(label_x, r.center().y), vec2(10.0, 10.0));
+    lp.rect_filled(sw, 2.0, t.label(it.label));
+    let sresp = ui.interact(sw.expand(3.0).intersect(list), egui::Id::unique(("plabel", it.id.0)), Sense::click());
+    app.auto.add(&format!("project.item.{}.label", it.id.0), sw, it.label.name());
+    sresp.widget_info(|| {
+        let name = crate::i18n::tr_args("Label of {}: {}", &[&it.name, &app.session.prefs.label_name(it.label)]);
+        egui::WidgetInfo::labeled(egui::Role::Button, true, name)
+    });
+    let pop = egui::Id::unique(("plabel-pop", it.id.0));
+    if sresp.clicked() || sresp.secondary_clicked() {
+        widgets::open_popup(ui, pop);
+    }
+    if let Some(l) = widgets::label_popup(ui, pop, sw.left_bottom(), it.label, |l| app.session.prefs.label_name(l), &t) {
+        actions.push(("project.setLabel".into(), json!({"items": targets(app, it.id, selected), "label": label_index(l)})));
+    }
+}
+
+/// The Project panel: the selected item's thumbnail and details (with the comps that use it), the
+/// search field, sortable column headers, and the item rows (folders, comps, footage and solids)
+/// with selection, Shift/Cmd ranges, keyboard navigation, inline rename, drag-and-drop move,
+/// marquee selection and context menus. Only the rows in view are drawn. File commands are queued
+/// and run through [`crate::menus::invoke`] at the end, with failures shown in `app.ui.status`.
+pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let t = app.tokens;
+    let p = ui.painter().clone();
+    let ctx = ui.ctx().clone();
+    // Preview header.
+    let head = Rect::from_min_size(rect.min, vec2(rect.width(), 74.0));
+    details_header(app, ui, &p, &ctx, head);
+    // Search.
+    let sr = Rect::from_min_size(pos2(rect.min.x + 8.0, head.max.y + 2.0), vec2(rect.width() - 16.0, 22.0));
+    let mut q = app.ui.project_search.clone();
+    widgets::search_field(ui, sr, &mut q, crate::i18n::tr("Search project"), &t);
+    app.ui.project_search = q;
+    app.auto.add("project.search", sr, "Search");
+    // Column header: Name, Label, then the visible optional columns.
+    let hdr = Rect::from_min_size(pos2(rect.min.x, sr.max.y + 6.0), vec2(rect.width(), 20.0));
+    p.line_segment([hdr.left_bottom(), hdr.right_bottom()], Stroke::new(1.0, t.separator));
+    let cl = layout_columns(app, rect);
+    let (name_w, label_x, opt_x0, overflow, hscroll) = (cl.name_w, cl.label_x, cl.opt_x0, cl.overflow, cl.hscroll);
+    draw_header(app, ui, &p, hdr, &cl);
+    // Rows.
+    let footer_h = 28.0;
+    let list = Rect::from_min_max(pos2(rect.min.x, hdr.max.y), pos2(rect.max.x, rect.max.y - footer_h));
+    let lp = p.with_clip_rect(list);
+    // The list's empty area (under the rows and the scroll bar, which take their own clicks):
+    // a click deselects, a drag draws a selection box, a double-click imports, as in After
+    // Effects (File ▸ Import ▸ File...).
+    // Not a Tab stop: the keyboard reaches the rows, and nothing else here takes a key.
+    let empty = ui.interact(list, egui::Id::unique("proj-empty"), Sense::CLICK | Sense::DRAG);
+    app.auto.add("project.empty", list, "Double-click to import files; drag to select items; right-click for project actions");
+    hscroll_wheel(app, ui, list, overflow);
+    let moved = keyboard_nav(app, &ctx);
+    let rows = visible_rows(app);
+    enter_renames(app, &ctx);
+    let editing: Option<Editing> = ctx.data(|d| d.get_temp(edit_id()));
+    let dragging = egui::DragAndDrop::payload::<DragPayload>(&ctx).and_then(|p| match *p {
+        DragPayload::Item(i) => Some(i),
+        _ => None,
+    });
+    let hover_y = ctx.pointer_hover_pos().filter(|p| list.contains(*p)).map(|p| p.y);
+    let mut drop_row: Option<ItemId> = None;
+    let mut actions: Vec<(String, serde_json::Value)> = vec![];
+    let (scroll, max_scroll) = update_scroll(app, ui, &ctx, list, &rows, moved);
+    let first = ((scroll / ROW_H).floor() as usize).min(rows.len());
+    let mut y = list.min.y - (scroll - first as f32 * ROW_H);
+    let project = app.session.project.clone();
+    for (i, (id, depth)) in rows.iter().enumerate().skip(first) {
+        let Some(it) = project.item(*id) else { continue };
+        let r = Rect::from_min_size(pos2(list.min.x, y), vec2(list.width(), ROW_H));
+        y += ROW_H;
+        if r.min.y > list.max.y {
+            break;
+        }
+        if hover_y.is_some_and(|hy| hy >= r.min.y && hy < r.max.y) {
+            drop_row = Some(*id);
+        }
+        let selected = app.session.state.project_selection.contains(id);
+        lp.rect_filled(
+            r,
+            0.0,
+            // Flat rows like After Effects' Project panel (no stripes).
+            if selected { t.row_selected } else { t.row },
+        );
+        // The row's click / drag area goes first, so the twirl, proxy, label and comment widgets
+        // on top of it take their own clicks.
+        let mut resp = ui.interact(r.intersect(list), row_id(*id), Sense::click_and_drag());
+        app.auto.add(&format!("project.item.{}", id.0), r, &it.name);
+        // For screen readers: a tree item named by the item and its type, with its selection,
+        // depth and (a folder) open state. One Tab stop per row; the panel's keys then apply.
+        let open = it.is_folder().then(|| app.ui.project_open_folders.contains(&id.0) || !app.ui.project_search.is_empty());
+        resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::TreeItem, true, format!("{}, {}", it.name, crate::i18n::tr(it.type_name()))));
+        ctx.accesskit_node_builder(resp.id, |n| {
+            n.set_selected(selected);
+            n.set_level(depth.saturating_add(1));
+            if let Some(open) = open {
+                n.set_expanded(open);
+            }
+        });
+        if resp.has_focus() {
+            ctx.data_mut(|d| d.insert_temp(focused_row_id(), *id));
+        }
+        if resp.gained_focus() {
+            app.ui.focused = crate::dock::PanelKind::Project;
+        }
+        let _ = i;
+        let x0 = r.min.x + 8.0 + 14.0 * *depth as f32;
+        let g = RowGeom { lp: &lp, list, r, x0 };
+        if it.is_folder() {
+            folder_twirl(app, ui, &g, it);
+        }
+        icons::paint(&lp, Rect::from_center_size(pos2(x0 + 18.0, r.center().y), vec2(14.0, 14.0)), item_icon(it), t.text_dim);
+        proxy_indicator(app, ui, &g, it, &mut actions);
+        // Footage (or the proxy in use) that can't be decoded (no decoder for its codec /
+        // profile): a warning marker at the end of the name cell, the reason on hover.
+        let problem = app.session.footage.item_problem(it);
+        let name_clip =
+            Rect::from_min_max(pos2(x0 + 30.0, r.min.y), pos2(r.min.x + name_w + 4.0 - if problem.is_some() { 16.0 } else { 0.0 }, r.max.y)).intersect(list);
+        if let Some(why) = &problem {
+            problem_marker(app, ui, &g, name_w, it.id, why);
+        }
+        let name_rect = Rect::from_min_max(pos2(x0 + 28.0, r.min.y + 2.0), pos2(r.min.x + name_w + 2.0, r.max.y - 2.0));
+        if !cell_edit(app, ui, &mut actions, &editing, id.0, "name", name_rect) {
+            // The selected item's name sits in a light cell with dark text.
+            if selected {
+                let g = lp.layout_no_wrap(it.name.clone(), Tokens::ui(12.0), Color32::BLACK);
+                let cell = Rect::from_min_max(pos2(x0 + 27.0, r.min.y + 1.0), pos2((x0 + 33.0 + g.size().x).min(name_clip.max.x), r.max.y - 1.0));
+                lp.with_clip_rect(name_clip.expand2(vec2(3.0, 0.0))).rect_filled(cell, 0.0, Color32::from_rgb(0xa6, 0xa6, 0xa6));
+            }
+            // Long names end in "…" before the label column instead of being cut mid-glyph.
+            widgets::text_fit(
+                &lp.with_clip_rect(name_clip),
+                pos2(x0 + 30.0, r.center().y),
+                Align2::LEFT_CENTER,
+                &it.name,
+                Tokens::ui(12.0),
+                name_clip.max.x - (x0 + 30.0) - 2.0,
+                if selected { Color32::from_gray(0x16) } else { t.text },
+            );
+        }
+        label_swatch(app, ui, &g, it, label_x, selected, &mut actions);
+        if let Some(extra) = optional_cells(app, ui, &g, it, &cl, &editing, &mut actions) {
+            resp = resp.union(extra);
+        }
+        if dragging.is_some_and(|d| d != id.0) && drop_row == Some(*id) && it.is_folder() {
+            lp.rect_stroke(r.shrink(1.0), 2.0, Stroke::new(1.5, t.accent), egui::StrokeKind::Inside);
+        }
+        // The row with keyboard focus (Tab, or the arrow keys after it) shows a focus ring.
+        if ctx.memory(|m| m.has_focus(row_id(*id))) {
+            lp.rect_stroke(r.shrink(0.5), 0.0, Stroke::new(1.0, t.accent), egui::StrokeKind::Inside);
+        }
+        // Part of the row: not a second Tab stop.
+        let nresp = ui.interact(name_clip, egui::Id::unique(("pname", id.0)), Sense::CLICK | Sense::DRAG);
+        app.auto.add(&format!("project.item.{}.name", id.0), name_clip, &it.name);
+        let resp = resp.union(nresp);
+        if resp.clicked() {
+            select_click(app, ui, &ctx, *id, &rows);
+        }
+        // Double-click opens the item, as in After Effects (a comp gets its own Timeline tab and
+        // the viewer); Enter or the context menu renames.
+        if resp.double_clicked() {
+            open_item(app, it, *id, &mut actions);
+        }
+        if resp.drag_started() {
+            egui::DragAndDrop::set_payload(&ctx, DragPayload::Item(id.0));
+        }
+        // Right-clicking an item selects it (After Effects): the menu's File commands act on the
+        // selection.
+        if resp.secondary_clicked() && !selected {
+            app.session.state.project_selection = vec![*id];
+        }
+        crate::widgets::context_menu(&resp, |ui| item_menu(app, ui, &ctx, it, *id, selected, &mut actions));
+    }
+    // The scroll bars, over the rows (which would take their presses otherwise).
+    if overflow > 0.0 {
+        let track = Rect::from_min_max(pos2(opt_x0, list.max.y - 5.0), pos2(rect.max.x - 4.0, list.max.y - 1.0));
+        app.ui.project_hscroll = widgets::scroll_bar(ui, &mut app.auto, "project.hscroll", track, hscroll, overflow, &t);
+    }
+    if max_scroll > 0.0 {
+        let track = Rect::from_min_max(pos2(rect.max.x - 6.0, list.min.y + 1.0), pos2(rect.max.x - 2.0, list.max.y - 7.0));
+        app.ui.project_scroll = widgets::scroll_bar(ui, &mut app.auto, "project.vscroll", track, scroll, max_scroll, &t);
+    }
+    drop_targets(app, &ctx, &lp, list, DropState { dragging, row: drop_row, hovering: hover_y.is_some() }, &mut actions);
+    let foot = Rect::from_min_max(pos2(rect.min.x, rect.max.y - footer_h), rect.max);
+    footer(app, ui, &p, foot, &mut actions);
+    if empty.double_clicked() {
+        actions.push(("file.import".into(), json!({})));
+    }
+    crate::widgets::context_menu(&empty, |ui| {
+        for (key, label, command) in
+            [("newComp", "New Composition…", "comp.new"), ("newFolder", "New Folder", "project.newFolder"), ("import", "Import File…", "file.import")]
+        {
+            let response = ui.button(label);
+            app.auto.add(&format!("project.context.{key}"), response.rect, label);
+            if response.clicked() {
+                actions.push((command.into(), json!({})));
+                ui.close();
+            }
+        }
+    });
+    marquee_select(app, &ctx, &lp, list, &empty, &rows);
     for (id, params) in actions {
         if let Err(e) = crate::menus::invoke(app, &ctx, &id, params) {
             app.ui.status = e;
@@ -1158,7 +1346,7 @@ fn column_menu(app: &mut EffectcraftApp, resp: &egui::Response) {
         ui.label(egui::RichText::new(crate::i18n::tr("Columns")).weak());
         for (key, label, _) in COLUMNS {
             let mut on = app.ui.project_columns.iter().any(|c| c == key);
-            if ui.checkbox(&mut on, crate::i18n::tr(label)).changed() {
+            if crate::widgets::labelled_checkbox(ui, &mut on, crate::i18n::tr(label)).changed() {
                 set_column(&mut app.ui.project_columns, key, on);
             }
         }
diff --git a/crates/ui-egui/src/panels/properties.rs b/crates/ui-egui/src/panels/properties.rs
index c9d759c16..4ef57b1ab 100644
--- a/crates/ui-egui/src/panels/properties.rs
+++ b/crates/ui-egui/src/panels/properties.rs
@@ -51,6 +51,12 @@ fn decimals(v: f64) -> usize {
     if (v - v.round()).abs() < 1e-6 { 0 } else { 1 }
 }
 
+/// The Properties panel for the first selected layer: "N Selected Objects" when several are
+/// selected, the Layer Transform section (with Reset) and, for a text layer, the text, paragraph
+/// and Text Animation sections that edit the range being edited in the viewer. Rows are evaluated
+/// against a snapshot of the project; every row edit is queued and run through
+/// [`crate::menus::invoke`] at the end (range-scoped for `layer.setText`), with failures reported
+/// in `app.ui.status`. Without a selected layer it shows a hint.
 pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let p = ui.painter().with_clip_rect(rect);
@@ -64,7 +70,16 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let project = app.session.project.clone();
     let expr = app.session.expr.clone();
     let now = app.session.time();
-    let ectx = EvalCtx { project: &project, comp_id: cid, comp: &comp, time: now, expr: expr.as_deref(), footage: None };
+    let ectx = EvalCtx {
+        project: &project,
+        comp_id: cid,
+        comp: &comp,
+        time: now,
+        expr: expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     let x0 = rect.min.x + PAD;
     let w = rect.width() - 2.0 * PAD;
     let scroll = widgets::PanelScroll::begin(ui, egui::Id::unique("props-scroll"), rect);
@@ -85,7 +100,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
 
     // ---------------------------------------------------------------- Layer Transform
     if let Some(tr) = layer.transform().cloned() {
-        section_header(app, ui, &p, x0, w, y, "Layer Transform", "properties.transform");
+        section_header(app, &p, x0, w, y, "Layer Transform", "properties.transform");
         let rr = Rect::from_min_size(pos2(x0 + w - 40.0, y), vec2(40.0, ROW_H));
         let resp = ui.interact(rr, egui::Id::unique("props-reset"), Sense::click());
         p.text(rr.right_center(), Align2::RIGHT_CENTER, crate::i18n::tr("Reset"), Tokens::ui(12.0), if resp.hovered() { t.accent_hover } else { t.accent });
@@ -118,7 +133,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         divider(&p, x0, w, y - 4.0, &t);
         y = paragraph_section(app, ui, &p, &layer, &doc, x0, w, y + 4.0, &mut actions);
         divider(&p, x0, w, y - 4.0, &t);
-        section_header(app, ui, &p, x0, w, y + 4.0, "Text Animation", "properties.textAnimation");
+        section_header(app, &p, x0, w, y + 4.0, "Text Animation", "properties.textAnimation");
         y += ROW_H + 10.0;
         // Both buttons grow with their (translated) labels; English keeps its 116 / 84 px.
         let text_w = |s: &str| p.layout_no_wrap(s.to_string(), Tokens::ui(12.0), t.text).size().x;
@@ -174,11 +189,10 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
 }
 
-fn section_header(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, x0: f32, w: f32, y: f32, title: &str, auto: &str) {
+fn section_header(app: &mut EffectcraftApp, p: &egui::Painter, x0: f32, w: f32, y: f32, title: &str, auto: &str) {
     let t = app.tokens;
     p.text(pos2(x0, y + ROW_H / 2.0), Align2::LEFT_CENTER, title, Tokens::semibold(12.0), t.text);
     let r = Rect::from_min_size(pos2(x0, y), vec2(w, ROW_H));
-    let _ = ui;
     app.auto.add(auto, r, title);
 }
 
@@ -195,6 +209,8 @@ fn triangle(p: &egui::Painter, c: egui::Pos2, left: bool, col: Color32) {
 #[allow(clippy::too_many_arguments)]
 fn transform_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, layer: &Layer, pr: &Property, ectx: &EvalCtx, r: Rect, actions: &mut Actions) {
     let t = app.tokens;
+    // The values themselves: red while an expression drives the property (#1306).
+    let vt = t.for_value(pr.has_expression());
     let cy = r.center().y;
     let uid = pr.uid;
     let lid = layer.id.0;
@@ -248,6 +264,7 @@ fn transform_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter,
     let vx = r.min.x + (r.width() * 0.5).max(130.0);
     let label = Rect::from_min_max(pos2(r.min.x + 42.0, r.min.y), pos2(vx - 20.0, r.max.y));
     let resp = ui.interact(label, egui::Id::unique(("props-label", uid)), Sense::click());
+    crate::a11y::role_name(&resp, egui::accesskit::Role::Button, &pr.name);
     app.auto.add(&format!("{base}.label"), label, &pr.name);
     if resp.double_clicked() {
         app.ui.timeline.search.clear();
@@ -271,7 +288,7 @@ fn transform_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter,
     match &value {
         Value::Scalar(v) if pr.name == "Rotation" || pr.name.ends_with(" Rotation") => {
             let (_, deg) = super::fx_widgets::split_angle(*v);
-            let (rr, dr, nv) = super::fx_widgets::angle_field(ui, pos2(vx, cy - 9.0), egui::Id::unique(("props-v", uid)), *v, decimals(deg), &t);
+            let (rr, dr, nv) = super::fx_widgets::angle_field(ui, pos2(vx, cy - 9.0), egui::Id::unique(("props-v", uid)), *v, decimals(deg), &vt);
             app.auto.add(&format!("{base}.value"), dr, &pr.name);
             app.auto.add(&format!("{base}.revolutions"), rr, &pr.name);
             if let Some(nv) = nv {
@@ -280,7 +297,14 @@ fn transform_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter,
         }
         Value::Scalar(v) => {
             let range = if pr.name == "Opacity" { (0.0, 100.0) } else { (-1e9, 1e9) };
-            let (vr, nv, _) = widgets::hot_number_at(ui, pos2(vx, cy - 9.0), egui::Id::unique(("props-v", uid)), *v, 0.5, range, decimals(*v), suffix, &t);
+            let (vr, nv, _) = widgets::hot_number_at(
+                ui,
+                pos2(vx, cy - 9.0),
+                egui::Id::unique(("props-v", uid)),
+                *v,
+                &widgets::HotSpec { speed: 0.5, range, decimals: decimals(*v), suffix },
+                &vt,
+            );
             app.auto.add(&format!("{base}.value"), vr, &pr.name);
             if let Some(nv) = nv {
                 set(actions, json!(nv));
@@ -305,8 +329,14 @@ fn transform_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter,
                 }
             }
             for d in 0..n.min(c.len()) {
-                let (vr, nv, _) =
-                    widgets::hot_number_at(ui, pos2(x, cy - 9.0), egui::Id::unique(("props-v", uid, d)), c[d], 1.0, (-1e9, 1e9), decimals(c[d]), suffix, &t);
+                let (vr, nv, _) = widgets::hot_number_at(
+                    ui,
+                    pos2(x, cy - 9.0),
+                    egui::Id::unique(("props-v", uid, d)),
+                    c[d],
+                    &widgets::HotSpec { speed: 1.0, range: (-1e9, 1e9), decimals: decimals(c[d]), suffix },
+                    &vt,
+                );
                 app.auto.add(&format!("{base}.value.{d}"), vr, &pr.name);
                 if let Some(nv) = nv {
                     let mut nc = c.clone();
@@ -352,7 +382,7 @@ fn text_section(
         v["layer"] = json!(lid);
         actions.push(("layer.setText".into(), v));
     };
-    section_header(app, ui, p, x0, w, y, "Text", "properties.text");
+    section_header(app, p, x0, w, y, "Text", "properties.text");
     y += ROW_H + 4.0;
     // Font family and style.
     let fr = Rect::from_min_size(pos2(x0, y), vec2(w, 22.0));
@@ -377,7 +407,14 @@ fn text_section(
     let col2 = x0 + w / 2.0;
     let field = |app: &mut EffectcraftApp, ui: &mut egui::Ui, x: f32, y: f32, glyph: &str, key: &str, v: f64, range: (f64, f64), suffix: &str| {
         p.text(pos2(x, y + 9.0), Align2::LEFT_CENTER, glyph, Tokens::semibold(11.0), t.text_dim);
-        let (r, nv, _) = widgets::hot_number_at(ui, pos2(x + 26.0, y), egui::Id::unique(("props-text", key)), v, 0.5, range, decimals(v), suffix, &t);
+        let (r, nv, _) = widgets::hot_number_at(
+            ui,
+            pos2(x + 26.0, y),
+            egui::Id::unique(("props-text", key)),
+            v,
+            &widgets::HotSpec { speed: 0.5, range, decimals: decimals(v), suffix },
+            &t,
+        );
         app.auto.add(&format!("properties.text.{key}"), r, key);
         nv
     };
@@ -420,7 +457,7 @@ fn text_section(
     for (i, (key, label, on, c)) in [("fill", "Fill", doc.apply_fill, doc.fill), ("stroke", "Stroke", doc.apply_stroke, doc.stroke)].into_iter().enumerate() {
         let ry = y + i as f32 * 24.0;
         let cr = Rect::from_min_size(pos2(x0, ry + 2.0), vec2(14.0, 14.0));
-        if widgets::checkbox(ui, cr, on, &t, egui::Id::unique(("props-apply", key))).clicked() {
+        if widgets::checkbox(ui, cr, on, &t, egui::Id::unique(("props-apply", key))).changed() {
             let k = if key == "fill" { "applyFill" } else { "applyStroke" };
             set(actions, json!({k: !on}));
         }
@@ -456,7 +493,7 @@ fn paragraph_section(
     actions: &mut Actions,
 ) -> f32 {
     let t = app.tokens;
-    section_header(app, ui, p, x0, w, y, "Paragraph", "properties.paragraph");
+    section_header(app, p, x0, w, y, "Paragraph", "properties.paragraph");
     y += ROW_H + 4.0;
     for (i, (j, key)) in ALIGNS.into_iter().enumerate() {
         let r = Rect::from_min_size(pos2(x0 + i as f32 * 26.0, y), vec2(22.0, 22.0));
diff --git a/crates/ui-egui/src/panels/render_queue.rs b/crates/ui-egui/src/panels/render_queue.rs
index ae5436296..21dc828ca 100644
--- a/crates/ui-egui/src/panels/render_queue.rs
+++ b/crates/ui-egui/src/panels/render_queue.rs
@@ -20,6 +20,7 @@ use effectcraft_engine::project::render_templates::RenderTemplates;
 use egui::{Align2, Color32, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
 use serde_json::{Value, json};
 
+use crate::a11y;
 use crate::theme::Tokens;
 use crate::widgets::check_label as mark;
 use crate::{EffectcraftApp, widgets};
@@ -64,6 +65,11 @@ pub fn utc_stamp(unix: u64) -> String {
     format!("{y:04}-{}", t.format("%m-%d %H:%M:%S"))
 }
 
+/// A queue item's row: its click area, keyboard focus and accessibility node.
+fn row_id(item: u64) -> egui::Id {
+    egui::Id::unique(("rq-row", item))
+}
+
 fn status_color(t: &Tokens, s: &RenderStatus) -> Color32 {
     match s {
         RenderStatus::Done => Color32::from_rgb(0x6c, 0xc0, 0x6c),
@@ -415,15 +421,21 @@ fn pick_output(app: &EffectcraftApp, it: &RenderQueueItem) -> Option<Option<Stri
     app.hooks.save_dialog(&app.session.resolve_output(it).unwrap_or_default())
 }
 
-pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+/// A `renderQueue.*` command queued while drawing, run after the frame.
+type Action = (&'static str, Value);
+
+/// What the panel's sections read: the queue, the running render (if any) and the formats.
+#[derive(Clone, Copy)]
+struct RqView<'a> {
+    queue: &'a [RenderQueueItem],
+    progress: Option<&'a effectcraft_engine::render_queue::JobState>,
+    rendering: bool,
+    available: &'a [OutputFormat],
+}
+
+/// Comps dragged from the Project over the panel: an outline while hovering, queued on release.
+fn queue_drop(app: &EffectcraftApp, ui: &egui::Ui, rect: Rect, p: &egui::Painter, rendering: bool, actions: &mut Vec<Action>) {
     let t = app.tokens;
-    let p = ui.painter().with_clip_rect(rect);
-    let queue: Vec<RenderQueueItem> = app.session.project.render_queue.clone();
-    let progress = app.session.render_progress();
-    let rendering = app.session.is_rendering();
-    let available = app.session.exporter.as_ref().map(|e| e.formats()).unwrap_or_default();
-    let mut actions: Vec<(&'static str, Value)> = Vec::new();
-    app.auto.add("renderQueue.drop", rect, "Drop compositions to queue");
     if !rendering
         && let Some(crate::panels::DragPayload::Item(id)) = egui::DragAndDrop::payload::<crate::panels::DragPayload>(ui.ctx()).as_deref()
         && app.session.project.comp(effectcraft_engine::project::ItemId(*id)).is_some()
@@ -443,23 +455,43 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             p.rect_stroke(rect.shrink(2.0), 0.0, Stroke::new(2.0, t.accent), StrokeKind::Inside);
         }
     }
-    let mut forms: Vec<(RenderQueueItem, String)> = Vec::new();
-    let state_id = egui::Id::unique("rq-ui");
-    let (mut open, mut selected): (Vec<u64>, Option<u64>) = ui.data(|d| d.get_temp(state_id).unwrap_or_default());
+}
 
-    // ---------------------------------------------------------- Current Render strip
-    let top = Rect::from_min_size(rect.min, vec2(rect.width(), TOP_H));
-    p.rect_filled(top, 0.0, t.tl_ruler_bg);
-    let x0 = rect.min.x + 12.0;
+/// Elapsed and estimated remaining seconds at UI time `now`. The job reports them as frames
+/// finish; between reports they count on from the last one, as a clock does, so a slow frame
+/// doesn't read as a stalled render (#2593).
+fn live_times(ctx: &egui::Context, pr: &effectcraft_engine::render_queue::JobState, now: f64) -> (f64, Option<f64>) {
+    let report = (pr.current, pr.done, pr.item_elapsed.to_bits());
+    let since = ctx.data_mut(|d| {
+        let seen = d.get_temp_mut_or_insert_with(egui::Id::unique("rq-progress-seen"), || (report, now));
+        if seen.0 != report {
+            *seen = (report, now);
+        }
+        seen.1
+    });
+    let dt = if pr.finished { 0.0 } else { (now - since).max(0.0) };
+    (pr.item_elapsed + dt, pr.remaining.map(|r| (r - dt).max(0.0)))
+}
+
+/// The Current Render strip inside `top`: title, elapsed / remaining time, Render, Stop, Notify
+/// and the progress bar.
+fn current_render_strip(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, top: Rect, rq: &RqView, actions: &mut Vec<Action>) {
+    let t = app.tokens;
+    let RqView { queue, progress, rendering, available } = *rq;
+    let x0 = top.min.x + 12.0;
     p.text(pos2(x0, top.min.y + 16.0), Align2::LEFT_CENTER, tr("Current Render"), Tokens::semibold(12.5), t.text);
     let cur_item = progress.as_ref().and_then(|p| p.current).and_then(|id| queue.iter().find(|i| i.id == id));
     let cur_name = cur_item.and_then(|i| app.session.project.item(i.comp)).map(|i| i.name.clone());
     if let Some(pr) = &progress {
-        let rem = pr.remaining.map(hms).unwrap_or_else(|| "–".into());
+        let (elapsed, remaining) = live_times(ui.ctx(), pr, ui.input(|i| i.time));
+        if rendering {
+            ui.ctx().request_repaint_after(std::time::Duration::from_millis(500));
+        }
+        let rem = remaining.map(hms).unwrap_or_else(|| "–".into());
         p.text(
             pos2(top.max.x - 12.0, top.min.y + 16.0),
             Align2::RIGHT_CENTER,
-            format!("Elapsed: {}     Est. Remain: {rem}", hms(pr.item_elapsed)),
+            format!("Elapsed: {}     Est. Remain: {rem}", hms(elapsed)),
             Tokens::ui(11.5),
             t.text_dim,
         );
@@ -468,20 +500,25 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let render_b = Rect::from_min_size(pos2(top.max.x - 12.0 - bw, top.min.y + 34.0), vec2(bw, 26.0));
     let stop_b = Rect::from_min_size(pos2(render_b.min.x - 8.0 - bw, render_b.min.y), vec2(bw, 26.0));
     let can_render = !rendering && queue.iter().any(RenderQueueItem::is_queued) && !available.is_empty();
-    if widgets::text_button(ui, render_b, "Render", can_render, &t, egui::Id::unique("rq-render")).clicked() && can_render {
+    let render_label = tr("Render");
+    let render_resp = widgets::text_button(ui, render_b, render_label, can_render, &t, egui::Id::unique("rq-render"));
+    a11y::button(&render_resp, render_label, can_render);
+    if render_resp.clicked() && can_render {
         actions.push(("renderQueue.render", json!({"wait": false})));
     }
     app.auto.add("renderQueue.render", render_b, "Render");
     // Notify (sound + notification when the queue finishes).
     let notify = app.session.project.render_prefs.notify;
     let nb = Rect::from_min_size(pos2(render_b.min.x - 8.0 - 2.0 * bw - 8.0, render_b.min.y + 4.0), vec2(18.0, 18.0));
-    if widgets::checkbox(ui, nb, notify, &t, egui::Id::unique("rq-notify")).clicked() {
+    let notify_resp = widgets::checkbox(ui, nb, notify, &t, egui::Id::unique("rq-notify"));
+    a11y::check_box(&notify_resp, tr("Notify"), notify, true);
+    if notify_resp.changed() {
         actions.push(("renderQueue.setNotify", json!({"notify": !notify})));
     }
     p.text(pos2(nb.max.x + 5.0, nb.center().y), Align2::LEFT_CENTER, tr("Notify"), Tokens::ui(11.5), t.text_dim);
     app.auto.add("renderQueue.notify", nb, if notify { "Notify: on" } else { "Notify: off" });
     if rendering {
-        if widgets::text_button(ui, stop_b, "Stop", false, &t, egui::Id::unique("rq-stop")).clicked() {
+        if widgets::text_button(ui, stop_b, crate::i18n::tr("Stop"), false, &t, egui::Id::unique("rq-stop")).clicked() {
             actions.push(("renderQueue.stop", json!({})));
         }
         app.auto.add("renderQueue.stop", stop_b, "Stop");
@@ -508,8 +545,308 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         }
     };
-    p.text(pos2(bar.min.x + 8.0, bar.center().y), Align2::LEFT_CENTER, bar_text, Tokens::ui(11.5), t.text);
+    p.text(pos2(bar.min.x + 8.0, bar.center().y), Align2::LEFT_CENTER, &bar_text, Tokens::ui(11.5), t.text);
     app.auto.add("renderQueue.progress", bar, &format!("{:.0}%", frac * 100.0));
+    a11y::progress(&ui.interact(bar, egui::Id::unique("rq-progress"), Sense::hover()), &bar_text, frac);
+}
+
+/// The footer: the message line and the totals.
+fn footer(p: &egui::Painter, rect: Rect, rq: &RqView, t: &Tokens) {
+    let RqView { queue, progress, rendering, .. } = *rq;
+    let foot = Rect::from_min_max(pos2(rect.min.x, rect.max.y - FOOT_H), rect.max);
+    p.rect_filled(foot, 0.0, t.tl_ruler_bg);
+    p.line_segment([foot.left_top(), foot.right_top()], Stroke::new(1.0, t.separator));
+    let msg = match &progress {
+        Some(pr) if rendering => format!("Message: Rendering {} of {}", (pr.items_done + 1).min(pr.items_total), pr.items_total),
+        _ => {
+            let done = queue.iter().filter(|i| i.status == RenderStatus::Done).count();
+            format!("Message: {done} of {} done", queue.len())
+        }
+    };
+    p.text(pos2(foot.min.x + 12.0, foot.center().y), Align2::LEFT_CENTER, msg, Tokens::ui(11.0), t.text_dim);
+    let started = queue.iter().filter(|i| i.started.is_some()).count();
+    let total: f64 = queue.iter().filter_map(|i| i.render_time).sum();
+    p.text(
+        pos2(foot.max.x - 12.0, foot.center().y),
+        Align2::RIGHT_CENTER,
+        format!("Renders Started: {started}     Total Time Elapsed: {}", hms(progress.as_ref().filter(|_| rendering).map(|p| p.elapsed).unwrap_or(total))),
+        Tokens::ui(11.0),
+        t.text_dim,
+    );
+}
+
+/// An item row's context menu: Duplicate, Remove and Move Up / Down (row `k` of `len`).
+fn row_menu(ui: &mut egui::Ui, actions: &mut Vec<Action>, item_id: u64, k: usize, len: usize) {
+    if ui.button(tr("Duplicate")).clicked() {
+        actions.push(("renderQueue.duplicate", json!({"item": item_id})));
+        ui.close();
+    }
+    if ui.button(tr("Remove")).clicked() {
+        actions.push(("renderQueue.remove", json!({"item": item_id})));
+        ui.close();
+    }
+    if k > 0 && ui.button(tr("Move Up")).clicked() {
+        actions.push(("renderQueue.move", json!({"item": item_id, "to": k})));
+        ui.close();
+    }
+    if k + 1 < len && ui.button(tr("Move Down")).clicked() {
+        actions.push(("renderQueue.move", json!({"item": item_id, "to": k + 2})));
+        ui.close();
+    }
+}
+
+/// Log: Errors Only / Plus Settings / Plus Per Frame Info.
+fn log_dropdown(app: &mut EffectcraftApp, ui: &mut egui::Ui, row: &ItemRow, it: &RenderQueueItem, actions: &mut Vec<Action>) {
+    let ItemRow { lp, r, n, rendering, .. } = *row;
+    let t = app.tokens;
+    let aid = |s: &str| format!("renderQueue.item.{n}.{s}");
+    let ld = Rect::from_min_size(pos2(r.max.x - 190.0, r.min.y + 3.0), vec2(150.0, ROW_H - 6.0));
+    lp.text(pos2(ld.min.x - 6.0, r.center().y), Align2::RIGHT_CENTER, tr("Log:"), Tokens::ui(11.5), t.text_dim);
+    let lid = egui::Id::unique(("rq-log", it.id));
+    let log_resp = widgets::dropdown(ui, ld, it.log.label(), &t, lid);
+    a11y::combo_box(&log_resp, tr("Log:").trim_end_matches(':'), it.log.label(), !rendering);
+    if log_resp.clicked() && !rendering {
+        widgets::open_popup(ui, lid);
+    }
+    let llabels: Vec<String> = RenderLog::ALL.iter().map(|l| mark(it.log == *l, l.label())).collect();
+    if let Some(i) = widgets::popup_menu(ui, lid, ld.left_bottom(), &llabels, None) {
+        if widgets::by_keyboard(ui) {
+            log_resp.request_focus();
+        }
+        actions.push(("renderQueue.setLog", json!({"item": it.id, "log": RenderLog::ALL[i].label()})));
+    }
+    app.auto.add(&aid("log"), ld, it.log.label());
+}
+
+/// Where an item row's expanded line is drawn.
+#[derive(Clone, Copy)]
+struct ItemRow<'a> {
+    lp: &'a egui::Painter,
+    list: Rect,
+    r: Rect,
+    /// The item's 1-based position in the queue.
+    n: usize,
+    rendering: bool,
+}
+
+/// The expanded "Output To" line: the template menu, and the file name (click to choose it or
+/// edit the template in place).
+fn output_to(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    row: &ItemRow,
+    it: &RenderQueueItem,
+    dd_right: f32,
+    editing: &mut Option<(u64, String)>,
+    actions: &mut Vec<Action>,
+) {
+    let ItemRow { lp, list, r, n, rendering } = *row;
+    let t = app.tokens;
+    let aid = |s: &str| format!("renderQueue.item.{n}.{s}");
+    let ox = dd_right + 14.0;
+    lp.text(pos2(ox, r.center().y), Align2::LEFT_CENTER, tr("Output To:"), Tokens::ui(11.5), t.text_dim);
+    let odd = Rect::from_min_size(pos2(ox + 62.0, r.min.y + 3.0), vec2(22.0, ROW_H - 6.0));
+    let oid = egui::Id::unique(("rq-out", it.id));
+    let out_resp = widgets::dropdown(ui, odd, "", &t, oid);
+    a11y::combo_box(
+        &out_resp,
+        tr("Output To:").trim_end_matches(':'),
+        &app.session.resolve_output(it).unwrap_or_else(|| "Not yet specified".into()),
+        !rendering,
+    );
+    if out_resp.clicked() && !rendering {
+        widgets::open_popup(ui, oid);
+    }
+    app.auto.add(&aid("outputTo"), odd, "Output To");
+    let omenu = output_to_menu(it);
+    let olabels: Vec<String> = omenu.iter().map(|(l, _)| l.clone()).collect();
+    if let Some(i) = widgets::popup_menu(ui, oid, odd.left_bottom(), &olabels, None) {
+        if widgets::by_keyboard(ui) {
+            out_resp.request_focus();
+        }
+        if omenu[i].1.get("choose").is_some() {
+            match pick_output(app, it) {
+                Some(Some(path)) => actions.push(("renderQueue.setOutput", json!({"item": it.id, "path": path}))),
+                Some(None) => {}
+                None => *editing = Some((it.id, it.output.output.clone())),
+            }
+        } else {
+            let mut params = omenu[i].1.clone();
+            params["item"] = json!(it.id);
+            actions.push(("renderQueue.setOutput", params));
+        }
+    }
+    let path_rect = Rect::from_min_max(pos2(odd.max.x + 6.0, r.min.y + 2.0), pos2(r.max.x - 8.0, r.max.y - 2.0));
+    if editing.as_ref().is_some_and(|(id, _)| *id == it.id) {
+        let mut buf = editing.as_ref().map(|(_, b)| b.clone()).unwrap_or_default();
+        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(path_rect));
+        let resp = child.add(egui::TextEdit::singleline(&mut buf).desired_width(path_rect.width()).font(Tokens::ui(11.5)));
+        a11y::text_input(&resp, tr("Output file name template"), &buf);
+        if resp.lost_focus() {
+            if ui.input(|i| i.key_pressed(egui::Key::Enter)) && !buf.trim().is_empty() {
+                actions.push(("renderQueue.setOutput", json!({"item": it.id, "path": buf.trim()})));
+            }
+            *editing = None;
+        } else {
+            widgets::keep_focus(ui.ctx(), &resp, &buf);
+            *editing = Some((it.id, buf));
+        }
+    } else {
+        let shown = app.session.resolve_output(it).unwrap_or_else(|| "Not yet specified".into());
+        let resp = ui.interact(path_rect, egui::Id::unique(("rq-path", it.id)), Sense::click());
+        a11y::button(&resp, &tr_args("Output file: {}", &[&shown]), !rendering);
+        let col = if resp.hovered() { t.accent_hover } else { t.hot_text };
+        lp.with_clip_rect(path_rect.intersect(list)).text(pos2(path_rect.min.x, r.center().y), Align2::LEFT_CENTER, &shown, Tokens::ui(11.5), col);
+        // Clicking the file name opens the save dialog (Output Movie To); Alt-click, or a
+        // host without one, edits the name template in place.
+        let dialog = app.hooks.pick_save_file.is_some();
+        if resp.clicked() && !rendering {
+            let picked = if ui.input(|i| i.modifiers.alt) { None } else { pick_output(app, it) };
+            match picked {
+                Some(Some(path)) => actions.push(("renderQueue.setOutput", json!({"item": it.id, "path": path}))),
+                Some(None) => {}
+                None => *editing = Some((it.id, it.output.output.clone())),
+            }
+        }
+        let how = if dialog { "Click to choose where to save; Alt-click to edit the template" } else { "Click to edit" };
+        resp.on_hover_text(tr_args("Template: {}\n{}", &[&it.output.output, &how]));
+        app.auto.add(&aid("outputPath"), path_rect, &shown);
+    }
+}
+
+/// Delete removes the selected item when the panel has focus (`allowed`: not editing a path and
+/// not rendering).
+fn delete_selected(app: &EffectcraftApp, ui: &egui::Ui, allowed: bool, on_row: bool, selected: &mut Option<u64>, actions: &mut Vec<Action>) {
+    if app.ui.focused == crate::dock::PanelKind::RenderQueue
+        && allowed
+        && let Some(id) = *selected
+        && app.dialog.is_none()
+        && !crate::widgets::any_menu_open(ui.ctx())
+        && ui.input(|i| i.key_pressed(egui::Key::Delete) || i.key_pressed(egui::Key::Backspace))
+        // (A focused queue row is not typing; any other focused widget may be.)
+        && (on_row || !ui.ctx().egui_wants_keyboard_input())
+    {
+        actions.push(("renderQueue.remove", json!({"item": id})));
+        *selected = None;
+    }
+}
+
+// Keyboard: Up / Down move between the queued items, Home / End go to the first / last, Right
+// and Left open and close the item's settings, Enter and Space do the same (Space only with a
+// row focused: otherwise it plays the preview). The focus follows the selection.
+///
+/// Returns whether a queue row has keyboard focus.
+fn list_keys(
+    app: &mut EffectcraftApp,
+    ctx: &egui::Context,
+    queue: &[RenderQueueItem],
+    (open, selected): (&mut Vec<u64>, &mut Option<u64>),
+    can_navigate: bool,
+    tops: &[(u64, f32)],
+    list_h: f32,
+) -> bool {
+    let focused = ctx.memory(|m| m.focused());
+    let on_row = focused.is_some_and(|f| queue.iter().any(|i| row_id(i.id) == f));
+    let by_mouse = focused.is_none() && app.ui.focused == crate::dock::PanelKind::RenderQueue;
+    if (on_row || by_mouse) && can_navigate && app.dialog.is_none() && !widgets::any_menu_open(ctx) {
+        let keys: Vec<egui::Key> = ctx.input(|i| {
+            i.events
+                .iter()
+                .filter_map(|e| match e {
+                    egui::Event::Key { key, pressed: true, modifiers, .. } if !modifiers.any() => Some(*key),
+                    _ => None,
+                })
+                .collect()
+        });
+        let mut moved = None;
+        for key in keys {
+            use egui::Key;
+            let at = (*selected).and_then(|s| queue.iter().position(|i| i.id == s));
+            let Some(last) = queue.len().checked_sub(1) else { break };
+            let to = match key {
+                Key::ArrowDown => Some(at.map_or(0, |a| a.saturating_add(1).min(last))),
+                Key::ArrowUp => Some(at.map_or(last, |a| a.saturating_sub(1))),
+                Key::Home if on_row => Some(0),
+                Key::End if on_row => Some(last),
+                _ => None,
+            };
+            if let Some(item) = to.and_then(|to| queue.get(to)) {
+                *selected = Some(item.id);
+                moved = Some(item.id);
+                continue;
+            }
+            let Some(item) = (*selected).filter(|s| queue.iter().any(|i| i.id == *s)) else { continue };
+            match key {
+                Key::ArrowRight if !open.contains(&item) => open.push(item),
+                Key::ArrowLeft => open.retain(|i| *i != item),
+                Key::Enter | Key::Space if on_row || key == Key::Enter => {
+                    if open.contains(&item) {
+                        open.retain(|i| *i != item);
+                    } else {
+                        open.push(item);
+                    }
+                }
+                _ => {}
+            }
+        }
+        if let Some(item) = moved {
+            if let Some((_, top)) = tops.iter().find(|(id, _)| *id == item) {
+                widgets::PanelScroll::reveal(ctx, egui::Id::unique("rq-scroll"), *top, *top + ROW_H, list_h);
+            }
+            app.ui.focused = crate::dock::PanelKind::RenderQueue;
+            if on_row {
+                a11y::focus_next_pass(ctx, "rq", row_id(item));
+            }
+            ctx.request_repaint();
+        }
+        // The arrows are the queue's, not egui's spatial focus moves.
+        if on_row {
+            ctx.memory_mut(|m| m.move_focus(egui::FocusDirection::None));
+        }
+    }
+    on_row
+}
+
+/// An item's Status cell: its state, or the percentage while it is the one rendering.
+fn status_text(it: &RenderQueueItem, progress: Option<&effectcraft_engine::render_queue::JobState>, rendering: bool) -> String {
+    match progress.filter(|p| rendering && p.current == Some(it.id)) {
+        Some(pr) => format!("Rendering {:.0}%", if pr.total > 0 { pr.done as f64 * 100.0 / pr.total as f64 } else { 0.0 }),
+        None => it.status.label().to_string(),
+    }
+}
+
+/// An item's Render Time cell: the running time while it renders, else its last render time.
+fn render_time_text(it: &RenderQueueItem, progress: Option<&effectcraft_engine::render_queue::JobState>, rendering: bool) -> String {
+    match progress.filter(|p| rendering && p.current == Some(it.id)) {
+        Some(p) => hms(p.item_elapsed),
+        None => it.render_time.map(|s| if s < 60.0 { format!("{s:.1} s") } else { hms(s) }).unwrap_or_else(|| "-".into()),
+    }
+}
+
+/// The Render Queue panel: the Current Render strip (elapsed and remaining time, Render/Stop and
+/// Notify, plus the progress bar), the column header, the queued items with their output template,
+/// status and timings, and the footer totals. Comps dragged from the Project are queued on
+/// release. The open items and the selected item are kept in egui temp data; output-template forms
+/// open through a small form, and every change runs a `renderQueue.*` command.
+pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let t = app.tokens;
+    let p = ui.painter().with_clip_rect(rect);
+    let queue: Vec<RenderQueueItem> = app.session.project.render_queue.clone();
+    let progress = app.session.render_progress();
+    let rendering = app.session.is_rendering();
+    let available = app.session.exporter.as_ref().map(|e| e.formats()).unwrap_or_default();
+    let mut actions: Vec<Action> = Vec::new();
+    let rq = RqView { queue: &queue, progress: progress.as_ref(), rendering, available: &available };
+    app.auto.add("renderQueue.drop", rect, "Drop compositions to queue");
+    queue_drop(app, ui, rect, &p, rendering, &mut actions);
+    let mut forms: Vec<(RenderQueueItem, String)> = Vec::new();
+    let state_id = egui::Id::unique("rq-ui");
+    let (mut open, mut selected): (Vec<u64>, Option<u64>) = ui.data(|d| d.get_temp(state_id).unwrap_or_default());
+
+    // ---------------------------------------------------------- Current Render strip
+    let top = Rect::from_min_size(rect.min, vec2(rect.width(), TOP_H));
+    p.rect_filled(top, 0.0, t.tl_ruler_bg);
+    current_render_strip(app, ui, &p, top, &rq, &mut actions);
 
     // ---------------------------------------------------------- column header
     let head = Rect::from_min_size(pos2(rect.min.x, top.max.y), vec2(rect.width(), HEAD_H));
@@ -546,6 +883,9 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     if queue.is_empty() {
         lp.text(pos2(list.center().x, list.min.y + 30.0), Align2::CENTER_CENTER, tr("The render queue is empty."), Tokens::ui(12.0), t.text_faint);
     }
+    let ctx = ui.ctx().clone();
+    // Where each item's row starts in the scrolled content, for the keys.
+    let mut tops: Vec<(u64, f32)> = Vec::new();
     let editing_id = egui::Id::unique("rq-edit-output");
     let mut editing: Option<(u64, String)> = ui.data(|d| d.get_temp(editing_id));
     for (k, it) in queue.iter().enumerate() {
@@ -565,34 +905,27 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 t.row_alt
             },
         );
-        let row_resp = ui.interact(row, egui::Id::unique(("rq-row", it.id)), Sense::click());
-        if row_resp.clicked() {
+        let row_resp = ui.interact(row, row_id(it.id), Sense::click());
+        tops.push((it.id, row.min.y - list.min.y + scroll.offset));
+        if a11y::take_pending_focus(&ctx, "rq", row_resp.id) {
+            row_resp.request_focus();
+        }
+        if row_resp.clicked() || row_resp.gained_focus() {
             selected = Some(it.id);
             app.ui.focused = crate::dock::PanelKind::RenderQueue;
         }
-        let item_id = it.id;
-        crate::widgets::context_menu(&row_resp, |ui| {
-            if ui.button(tr("Duplicate")).clicked() {
-                actions.push(("renderQueue.duplicate", json!({"item": item_id})));
-                ui.close();
-            }
-            if ui.button(tr("Remove")).clicked() {
-                actions.push(("renderQueue.remove", json!({"item": item_id})));
-                ui.close();
-            }
-            if k > 0 && ui.button(tr("Move Up")).clicked() {
-                actions.push(("renderQueue.move", json!({"item": item_id, "to": n - 1})));
-                ui.close();
-            }
-            if n < queue.len() && ui.button(tr("Move Down")).clicked() {
-                actions.push(("renderQueue.move", json!({"item": item_id, "to": n + 1})));
-                ui.close();
-            }
-        });
+        if row_resp.has_focus() {
+            lp.rect_stroke(row.shrink(0.5), 0.0, Stroke::new(1.0, t.accent), StrokeKind::Inside);
+        }
+        let comp_item = app.session.project.item(it.comp);
+        let name = comp_item.map(|i| i.name.clone()).unwrap_or_else(|| "(missing composition)".into());
+        crate::widgets::context_menu(&row_resp, |ui| row_menu(ui, &mut actions, it.id, k, queue.len()));
         app.auto.add(&aid("row"), row, &format!("#{n}"));
         let is_open = open.contains(&it.id);
         let tw = Rect::from_center_size(pos2(cx_twirl + 8.0, row.center().y), vec2(14.0, 14.0));
-        if widgets::twirl(ui, tw, is_open, egui::Id::unique(("rq-twirl", it.id)), &t).clicked() {
+        let tw_resp = widgets::twirl(ui, tw, is_open, egui::Id::unique(("rq-twirl", it.id)), &t);
+        a11y::disclosure(&tw_resp, &tr_args(if is_open { "Hide details of {}" } else { "Show details of {}" }, &[&name]), is_open);
+        if tw_resp.clicked() {
             if is_open {
                 open.retain(|i| *i != it.id);
             } else {
@@ -601,37 +934,27 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
         app.auto.add(&aid("twirl"), tw, "Twirl");
         let cb = Rect::from_center_size(pos2(cx_render + 20.0, row.center().y), vec2(18.0, 18.0));
-        if widgets::checkbox(ui, cb, it.render, &t, egui::Id::unique(("rq-cb", it.id))).clicked() && !rendering {
+        let cb_resp = ui.add_enabled_ui(!rendering, |ui| widgets::checkbox(ui, cb, it.render, &t, egui::Id::unique(("rq-cb", it.id)))).inner;
+        a11y::check_box(&cb_resp, &format!("{}: {name}", tr("Render")), it.render, !rendering);
+        if cb_resp.changed() && !rendering {
             actions.push(("renderQueue.setRender", json!({"item": it.id, "render": !it.render})));
         }
         app.auto.add(&aid("render"), cb, if it.render { "Render: on" } else { "Render: off" });
-        let comp_item = app.session.project.item(it.comp);
         let label_col = comp_item.map(|i| t.label(i.label)).unwrap_or(t.text_faint);
         lp.rect_filled(Rect::from_center_size(pos2(cx_label + 6.0, row.center().y), vec2(10.0, 10.0)), 2.0, label_col);
         lp.text(pos2(cx_num + 2.0, row.center().y), Align2::LEFT_CENTER, n.to_string(), Tokens::ui(12.0), t.text_dim);
-        let name = comp_item.map(|i| i.name.clone()).unwrap_or_else(|| "(missing composition)".into());
         lp.text(pos2(cx_name + 2.0, row.center().y), Align2::LEFT_CENTER, &name, Tokens::ui(12.0), t.text);
-        let status = if rendering && let Some(pr) = progress.as_ref().filter(|p| p.current == Some(it.id)) {
-            format!("Rendering {:.0}%", if pr.total > 0 { pr.done as f64 * 100.0 / pr.total as f64 } else { 0.0 })
-        } else {
-            it.status.label().to_string()
-        };
+        let status = status_text(it, progress.as_ref(), rendering);
         let st_rect = Rect::from_min_size(pos2(cx_status, row.min.y), vec2(w_status, ROW_H));
         lp.text(pos2(cx_status + 2.0, row.center().y), Align2::LEFT_CENTER, &status, Tokens::ui(12.0), status_color(&t, &it.status));
         if let RenderStatus::Failed(e) = &it.status {
             ui.interact(st_rect, egui::Id::unique(("rq-st", it.id)), Sense::hover()).on_hover_text(e);
         }
         app.auto.add(&aid("status"), st_rect, &status);
-        if let Some(s) = it.started {
-            lp.text(pos2(cx_started + 2.0, row.center().y), Align2::LEFT_CENTER, utc_stamp(s), Tokens::ui(11.5), t.text_dim);
-        } else {
-            lp.text(pos2(cx_started + 2.0, row.center().y), Align2::LEFT_CENTER, "-", Tokens::ui(11.5), t.text_faint);
-        }
-        let rt = if progress.as_ref().and_then(|p| p.current) == Some(it.id) && rendering {
-            progress.as_ref().map(|p| hms(p.item_elapsed)).unwrap_or_default()
-        } else {
-            it.render_time.map(|s| if s < 60.0 { format!("{s:.1} s") } else { hms(s) }).unwrap_or_else(|| "-".into())
-        };
+        a11y::tree_item(&row_resp, &format!("{n}. {name}, {status}"), is_sel, 1, Some(is_open));
+        let (started, started_col) = it.started.map_or(("-".to_string(), t.text_faint), |s| (utc_stamp(s), t.text_dim));
+        lp.text(pos2(cx_started + 2.0, row.center().y), Align2::LEFT_CENTER, started, Tokens::ui(11.5), started_col);
+        let rt = render_time_text(it, progress.as_ref(), rendering);
         lp.text(pos2(cx_time + 2.0, row.center().y), Align2::LEFT_CENTER, rt, Tokens::ui(11.5), t.text_dim);
 
         if !is_open {
@@ -653,11 +976,16 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             let dd = Rect::from_min_size(pos2(ix + 70.0, r.min.y + 3.0), vec2(220.0, ROW_H - 6.0));
             let did = egui::Id::unique(("rq-dd", it.id, sub));
             let shown: String = if summary.chars().count() > 31 { summary.chars().take(30).chain(std::iter::once('…')).collect() } else { summary.clone() };
-            if widgets::dropdown(ui, dd, &shown, &t, did).clicked() && !rendering {
+            let dd_resp = widgets::dropdown(ui, dd, &shown, &t, did);
+            a11y::combo_box(&dd_resp, label.trim_end_matches(':'), &summary, !rendering);
+            if dd_resp.clicked() && !rendering {
                 widgets::open_popup(ui, did);
             }
             let labels: Vec<String> = menu.iter().map(|(l, _)| l.clone()).collect();
             if let Some(i) = widgets::popup_menu(ui, did, dd.left_bottom(), &labels, None) {
+                if widgets::by_keyboard(ui) {
+                    dd_resp.request_focus();
+                }
                 let mut params = menu[i].1.clone();
                 if let Some(f) = params.get("form").and_then(Value::as_str) {
                     forms.push((it.clone(), f.to_string()));
@@ -681,78 +1009,10 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     );
                     lp.text(pos2(dd.max.x + 14.0, r.center().y), Align2::LEFT_CENTER, info, Tokens::ui(11.0), t.text_faint);
                 }
-                // Log: Errors Only / Plus Settings / Plus Per Frame Info.
-                let ld = Rect::from_min_size(pos2(r.max.x - 190.0, r.min.y + 3.0), vec2(150.0, ROW_H - 6.0));
-                lp.text(pos2(ld.min.x - 6.0, r.center().y), Align2::RIGHT_CENTER, tr("Log:"), Tokens::ui(11.5), t.text_dim);
-                let lid = egui::Id::unique(("rq-log", it.id));
-                if widgets::dropdown(ui, ld, it.log.label(), &t, lid).clicked() && !rendering {
-                    widgets::open_popup(ui, lid);
-                }
-                let llabels: Vec<String> = RenderLog::ALL.iter().map(|l| mark(it.log == *l, l.label())).collect();
-                if let Some(i) = widgets::popup_menu(ui, lid, ld.left_bottom(), &llabels, None) {
-                    actions.push(("renderQueue.setLog", json!({"item": it.id, "log": RenderLog::ALL[i].label()})));
-                }
-                app.auto.add(&aid("log"), ld, it.log.label());
+                log_dropdown(app, ui, &ItemRow { lp: &lp, list, r, n, rendering }, it, &mut actions);
                 continue;
             }
-            // Output To.
-            let ox = dd.max.x + 14.0;
-            lp.text(pos2(ox, r.center().y), Align2::LEFT_CENTER, tr("Output To:"), Tokens::ui(11.5), t.text_dim);
-            let odd = Rect::from_min_size(pos2(ox + 62.0, r.min.y + 3.0), vec2(22.0, ROW_H - 6.0));
-            let oid = egui::Id::unique(("rq-out", it.id));
-            if widgets::dropdown(ui, odd, "", &t, oid).clicked() && !rendering {
-                widgets::open_popup(ui, oid);
-            }
-            app.auto.add(&aid("outputTo"), odd, "Output To");
-            let omenu = output_to_menu(it);
-            let olabels: Vec<String> = omenu.iter().map(|(l, _)| l.clone()).collect();
-            if let Some(i) = widgets::popup_menu(ui, oid, odd.left_bottom(), &olabels, None) {
-                if omenu[i].1.get("choose").is_some() {
-                    match pick_output(app, it) {
-                        Some(Some(path)) => actions.push(("renderQueue.setOutput", json!({"item": it.id, "path": path}))),
-                        Some(None) => {}
-                        None => editing = Some((it.id, it.output.output.clone())),
-                    }
-                } else {
-                    let mut params = omenu[i].1.clone();
-                    params["item"] = json!(it.id);
-                    actions.push(("renderQueue.setOutput", params));
-                }
-            }
-            let path_rect = Rect::from_min_max(pos2(odd.max.x + 6.0, r.min.y + 2.0), pos2(r.max.x - 8.0, r.max.y - 2.0));
-            if editing.as_ref().is_some_and(|(id, _)| *id == it.id) {
-                let mut buf = editing.as_ref().map(|(_, b)| b.clone()).unwrap_or_default();
-                let mut child = ui.new_child(egui::UiBuilder::new().max_rect(path_rect));
-                let resp = child.add(egui::TextEdit::singleline(&mut buf).desired_width(path_rect.width()).font(Tokens::ui(11.5)));
-                if resp.lost_focus() {
-                    if ui.input(|i| i.key_pressed(egui::Key::Enter)) && !buf.trim().is_empty() {
-                        actions.push(("renderQueue.setOutput", json!({"item": it.id, "path": buf.trim()})));
-                    }
-                    editing = None;
-                } else {
-                    widgets::keep_focus(ui.ctx(), &resp, &buf);
-                    editing = Some((it.id, buf));
-                }
-            } else {
-                let shown = app.session.resolve_output(it).unwrap_or_else(|| "Not yet specified".into());
-                let resp = ui.interact(path_rect, egui::Id::unique(("rq-path", it.id)), Sense::click());
-                let col = if resp.hovered() { t.accent_hover } else { t.hot_text };
-                lp.with_clip_rect(path_rect.intersect(list)).text(pos2(path_rect.min.x, r.center().y), Align2::LEFT_CENTER, &shown, Tokens::ui(11.5), col);
-                // Clicking the file name opens the save dialog (Output Movie To); Alt-click, or a
-                // host without one, edits the name template in place.
-                let dialog = app.hooks.pick_save_file.is_some();
-                if resp.clicked() && !rendering {
-                    let picked = if ui.input(|i| i.modifiers.alt) { None } else { pick_output(app, it) };
-                    match picked {
-                        Some(Some(path)) => actions.push(("renderQueue.setOutput", json!({"item": it.id, "path": path}))),
-                        Some(None) => {}
-                        None => editing = Some((it.id, it.output.output.clone())),
-                    }
-                }
-                let how = if dialog { "Click to choose where to save; Alt-click to edit the template" } else { "Click to edit" };
-                resp.on_hover_text(tr_args("Template: {}\n{}", &[&it.output.output, &how]));
-                app.auto.add(&aid("outputPath"), path_rect, &shown);
-            }
+            output_to(app, ui, &ItemRow { lp: &lp, list, r, n, rendering }, it, dd.max.x, &mut editing, &mut actions);
         }
     }
     ui.set_clip_rect(panel_clip);
@@ -765,44 +1025,15 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         None => d.remove::<(u64, String)>(editing_id),
     });
 
-    // Delete removes the selected item when the panel has focus.
-    if app.ui.focused == crate::dock::PanelKind::RenderQueue
-        && editing.is_none()
-        && !rendering
-        && let Some(id) = selected
-        && app.dialog.is_none()
-        && ui.input(|i| i.key_pressed(egui::Key::Delete) || i.key_pressed(egui::Key::Backspace))
-        && !ui.ctx().egui_wants_keyboard_input()
-    {
-        actions.push(("renderQueue.remove", json!({"item": id})));
-        selected = None;
-    }
+    let on_row = list_keys(app, &ctx, &queue, (&mut open, &mut selected), editing.is_none(), &tops, list.height());
+
+    delete_selected(app, ui, editing.is_none() && !rendering, on_row, &mut selected, &mut actions);
 
     // ---------------------------------------------------------- footer
-    let foot = Rect::from_min_max(pos2(rect.min.x, rect.max.y - FOOT_H), rect.max);
-    p.rect_filled(foot, 0.0, t.tl_ruler_bg);
-    p.line_segment([foot.left_top(), foot.right_top()], Stroke::new(1.0, t.separator));
-    let msg = match &progress {
-        Some(pr) if rendering => format!("Message: Rendering {} of {}", (pr.items_done + 1).min(pr.items_total), pr.items_total),
-        _ => {
-            let done = queue.iter().filter(|i| i.status == RenderStatus::Done).count();
-            format!("Message: {done} of {} done", queue.len())
-        }
-    };
-    p.text(pos2(foot.min.x + 12.0, foot.center().y), Align2::LEFT_CENTER, msg, Tokens::ui(11.0), t.text_dim);
-    let started = queue.iter().filter(|i| i.started.is_some()).count();
-    let total: f64 = queue.iter().filter_map(|i| i.render_time).sum();
-    p.text(
-        pos2(foot.max.x - 12.0, foot.center().y),
-        Align2::RIGHT_CENTER,
-        format!("Renders Started: {started}     Total Time Elapsed: {}", hms(progress.as_ref().filter(|_| rendering).map(|p| p.elapsed).unwrap_or(total))),
-        Tokens::ui(11.0),
-        t.text_dim,
-    );
+    footer(&p, rect, &rq, &t);
 
     open.retain(|id| queue.iter().any(|i| i.id == *id));
     ui.data_mut(|d| d.insert_temp(state_id, (open, selected)));
-    let ctx = ui.ctx().clone();
     for (it, f) in forms {
         open_menu_form(app, &it, &f);
     }
@@ -825,4 +1056,26 @@ mod tests {
         assert_eq!(super::utc_stamp(u64::MAX), "584554051223-11-09 07:00:15");
         assert_eq!(super::hms(3725.4), "1:02:05");
     }
+
+    /// #2593: between progress reports the times count on from the last report, and a new
+    /// report starts the count again.
+    #[test]
+    fn render_times_tick_between_reports() {
+        let ctx = egui::Context::default();
+        let mut pr = effectcraft_engine::render_queue::JobState {
+            current: Some(1),
+            done: 2,
+            total: 10,
+            item_elapsed: 20.0,
+            remaining: Some(80.0),
+            ..Default::default()
+        };
+        assert_eq!(super::live_times(&ctx, &pr, 100.0), (20.0, Some(80.0)));
+        assert_eq!(super::live_times(&ctx, &pr, 103.0), (23.0, Some(77.0)));
+        assert_eq!(super::live_times(&ctx, &pr, 300.0).1, Some(0.0), "never below zero");
+        (pr.done, pr.item_elapsed, pr.remaining) = (3, 31.0, Some(72.0));
+        assert_eq!(super::live_times(&ctx, &pr, 301.0), (31.0, Some(72.0)));
+        pr.finished = true;
+        assert_eq!(super::live_times(&ctx, &pr, 400.0), (31.0, Some(72.0)), "a finished job stands still");
+    }
 }
diff --git a/crates/ui-egui/src/panels/roto_tool.rs b/crates/ui-egui/src/panels/roto_tool.rs
index 52175899c..194bba26a 100644
--- a/crates/ui-egui/src/panels/roto_tool.rs
+++ b/crates/ui-egui/src/panels/roto_tool.rs
@@ -8,7 +8,7 @@ use effectcraft_engine::render::{EvalCtx, RenderOpts, Renderer};
 use egui::{Align2, Color32, Pos2, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
 use serde_json::json;
 
-use crate::i18n::tr;
+use crate::i18n::{tr, tr_args};
 use crate::theme::Tokens;
 use crate::{EffectcraftApp, widgets};
 
@@ -21,6 +21,42 @@ fn roto_group(layer: &Layer) -> Option<&effectcraft_engine::project::PropGroup>
     layer.effects()?.groups().nth(roto_index(layer)?)
 }
 
+/// The colour of object `o`'s outline: object 0 keeps the chosen boundary colour, the others cycle through a palette.
+pub fn object_color(o: u32, base: [f64; 3]) -> Color32 {
+    const PALETTE: [[u8; 3]; 8] =
+        [[60, 200, 255], [255, 170, 40], [150, 230, 60], [180, 110, 255], [255, 225, 60], [40, 210, 170], [255, 90, 80], [90, 130, 255]];
+    if o == 0 {
+        return c32(base, 255);
+    }
+    let [r, g, b] = PALETTE[(o as usize - 1) % PALETTE.len()];
+    Color32::from_rgb(r, g, b)
+}
+
+/// Sample the layer-grid matte at each input pixel centre, including cropping and preview scale.
+fn object_mask_in_input(seg: &fx::FrameSeg, inp: &effectcraft_engine::effects::Buf) -> Vec<bool> {
+    let width = inp.img.width as usize;
+    if width == 0 || !inp.scale.is_finite() || inp.scale <= 0.0 || inp.offset.iter().any(|v| !v.is_finite()) {
+        return vec![false; inp.img.data.len()];
+    }
+    inp.img
+        .data
+        .iter()
+        .enumerate()
+        .map(|(i, _)| {
+            let x = ((i % width) as f64 + 0.5 - inp.offset[0]) / inp.scale;
+            let y = ((i / width) as f64 + 0.5 - inp.offset[1]) / inp.scale;
+            if x < 0.0 || y < 0.0 || x >= seg.w as f64 || y >= seg.h as f64 {
+                return false;
+            }
+            (y.floor() as usize)
+                .checked_mul(seg.w)
+                .and_then(|row| row.checked_add(x.floor() as usize))
+                .and_then(|index| seg.matte.get(index))
+                .is_some_and(|m| *m != 0)
+        })
+        .collect()
+}
+
 /// A stroke being drawn.
 #[derive(Clone, Debug)]
 struct Drag {
@@ -69,7 +105,16 @@ pub fn draw_overlay(
     let ov = match cached {
         Some(c) if c.key == key => Some(c),
         _ => {
-            let ectx = EvalCtx { project: &app.session.project, comp_id: cid, comp, time, expr: app.session.expr.as_deref(), footage: None };
+            let ectx = EvalCtx {
+                project: &app.session.project,
+                comp_id: cid,
+                comp,
+                time,
+                expr: app.session.expr.as_deref(),
+                footage: None,
+                property_overrides: &[],
+                media_overrides: &[],
+            };
             let mut r = Renderer::new(&app.session.project, &*app.session.footage, RenderOpts { scale, ..Default::default() });
             r.expr = app.session.expr.as_deref();
             r.cache = Some(&app.session.layer_cache);
@@ -85,6 +130,19 @@ pub fn draw_overlay(
             let alpha: Vec<f32> = (0..w * h).map(|i| a_at((i % w) as i64, (i / w) as i64)).collect();
             let inside = |x: i64, y: i64| x >= 0 && y >= 0 && x < w as i64 && y < h as i64 && alpha[y as usize * w + x as usize] >= 0.5;
             let mut px = vec![Color32::TRANSPARENT; w * h];
+            // With several objects the boundary view outlines each in its own colour.
+            let per_object: Vec<(Color32, Vec<bool>)> = match (o.view.as_str(), roto_group(layer)) {
+                ("alphaBoundary", Some(g)) => {
+                    let params = effectcraft_engine::effects::flatten_params(g, &mut |p| p.value.clone());
+                    let size = effectcraft_engine::roto::layer_size(&app.session.project, comp, layer);
+                    let f = fx::frame_of(layer.layer_time(time).seconds(), comp.frame_rate.as_f64());
+                    fx::object_mattes(&params, size, comp.frame_rate.as_f64(), f)
+                        .into_iter()
+                        .map(|(obj, seg)| (object_color(obj, o.boundary_color), object_mask_in_input(&seg, &inp)))
+                        .collect()
+                }
+                _ => vec![],
+            };
             let bc = c32(o.boundary_color, 255);
             let oc = c32(o.overlay_color, (o.overlay_opacity / 100.0 * 255.0).clamp(0.0, 255.0) as u8);
             // View Search Region: the band around the boundary (yellow).
@@ -108,7 +166,30 @@ pub fn draw_overlay(
                         _ => {
                             let me = a >= 0.5;
                             let edge = me && [(-1, 0), (1, 0), (0, -1), (0, 1)].iter().any(|(dx, dy)| !inside(x + dx, y + dy));
-                            if edge { bc } else { Color32::TRANSPARENT }
+                            if per_object.is_empty() {
+                                if edge { bc } else { Color32::TRANSPARENT }
+                            } else {
+                                // the outline of every object whose own matte has an edge here
+                                let inside_of = |m: &Vec<bool>, x: i64, y: i64| {
+                                    x >= 0
+                                        && y >= 0
+                                        && x < w as i64
+                                        && y < h as i64
+                                        && (y as usize)
+                                            .checked_mul(w)
+                                            .and_then(|row| row.checked_add(x as usize))
+                                            .and_then(|index| m.get(index))
+                                            .copied()
+                                            .unwrap_or(false)
+                                };
+                                per_object
+                                    .iter()
+                                    .rev()
+                                    .find(|(_, m)| {
+                                        inside_of(m, x, y) && [(-1, 0), (1, 0), (0, -1), (0, 1)].iter().any(|(dx, dy)| !inside_of(m, x + dx, y + dy))
+                                    })
+                                    .map_or(Color32::TRANSPARENT, |(c, _)| *c)
+                            }
                         }
                     };
                     if let Some((sd, r)) = &search {
@@ -135,17 +216,15 @@ pub fn draw_overlay(
     }
 }
 
+/// The layer <-> screen mappings [`interact`] works with.
+pub struct LayerXform<'a> {
+    pub to_screen: &'a dyn Fn([f64; 2]) -> Pos2,
+    pub to_layer: &'a dyn Fn(Pos2) -> [f64; 2],
+}
+
 /// Pointer handling for the Roto Brush / Refine Edge tools. Returns true when it handled input.
-pub fn interact(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    painter: &egui::Painter,
-    area: Rect,
-    layer: &Layer,
-    zoom: f64,
-    to_screen: &dyn Fn([f64; 2]) -> Pos2,
-    to_layer: &dyn Fn(Pos2) -> [f64; 2],
-) -> bool {
+pub fn interact(app: &mut EffectcraftApp, ui: &mut egui::Ui, painter: &egui::Painter, area: Rect, layer: &Layer, zoom: f64, xf: LayerXform) -> bool {
+    let LayerXform { to_screen, to_layer } = xf;
     let ctx = ui.ctx().clone();
     let mods = ui.input(|i| i.modifiers);
     let Some(kind) = app.ui.tool.roto_kind(mods.alt) else { return false };
@@ -236,6 +315,20 @@ fn run_stroke(app: &mut EffectcraftApp, layer: u64, kind: &str, points: &[[f64;
     }
 }
 
+/// The span bar's colour for a frame a tracker followed: green when it is sure, amber when it is
+/// doubtful, red when it is not, slate when the object was absent.
+pub(crate) fn trust_color(confidence: f32, occluded: bool) -> Color32 {
+    if occluded {
+        Color32::from_rgb(110, 118, 150)
+    } else if confidence >= 0.85 {
+        Color32::from_rgb(70, 200, 90)
+    } else if confidence >= 0.5 {
+        Color32::from_rgb(230, 180, 50)
+    } else {
+        Color32::from_rgb(220, 70, 60)
+    }
+}
+
 /// The segmentation span bar (above the panel's bottom bar): the layer's frames, the span, the
 /// base frame (yellow), computed frames (green) and stroke frames. Click to go to a frame; drag
 /// the span's ends to change it.
@@ -257,10 +350,17 @@ pub fn span_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter,
         let sp = Rect::from_min_max(pos2(x_of(d.span[0] as f64), track.min.y), pos2(x_of(d.span[1] as f64 + 1.0), track.max.y));
         let frozen = fx::is_frozen(&params);
         p.rect_filled(sp, 2.0, if frozen { Color32::from_rgb(60, 110, 190) } else { Color32::from_rgb(90, 90, 96) });
+        // Computed frames: green, or (frames a tracker followed) coloured by its confidence, with
+        // frames where the object was absent in slate.
+        let trust = app.session.roto_trust(cid, layer.id, uid);
         for (f, done) in app.session.roto_computed(cid, layer.id, uid) {
             if done {
-                let cr = Rect::from_min_max(pos2(x_of(f as f64), track.max.y - 4.0), pos2(x_of(f as f64 + 1.0), track.max.y));
-                p.rect_filled(cr, 0.0, Color32::from_rgb(70, 200, 90));
+                let (color, h) = match trust.get(&f) {
+                    Some(t) => (trust_color(t.confidence, t.occluded), 6.0),
+                    None => (Color32::from_rgb(70, 200, 90), 4.0),
+                };
+                let cr = Rect::from_min_max(pos2(x_of(f as f64), track.max.y - h), pos2(x_of(f as f64 + 1.0), track.max.y));
+                p.rect_filled(cr, 0.0, color);
             }
         }
         for f in d.stroke_frames() {
@@ -345,6 +445,45 @@ pub fn bar_buttons(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
     }
     app.auto.add("layerPanel.roto.freeze", r, label);
     x += 80.0;
+    // Objects: strokes belong to the current object; with a tracker each is followed on its own and the mattes are united.
+    let objects = fx::data(&params).objects();
+    let current = app.session.state.roto.object;
+    let known = objects.contains(&current);
+    let r = Rect::from_min_size(pos2(x, bar.center().y - 10.0), vec2(104.0, 20.0));
+    let strokes = fx::data(&params).strokes.iter().filter(|st| st.object == current && st.kind.is_segmentation()).count();
+    let label = if strokes == 0 { tr_args("Object {}", &[&(current + 1)]) } else { tr_args("Object {} ({})", &[&(current + 1), &strokes]) };
+    if widgets::text_button(ui, r, &label, false, &t, egui::Id::unique(("roto-object", uid))).clicked() {
+        // cycle through the objects that have strokes (and the empty one being drawn)
+        let mut all = objects.clone();
+        if !known {
+            all.push(current);
+            all.sort_unstable();
+        }
+        let next = all.iter().copied().find(|o| *o > current).or_else(|| all.first().copied()).unwrap_or(0);
+        let _ = app.session.execute("roto.options", json!({"object": next}));
+    }
+    p.circle_filled(pos2(r.min.x + 9.0, r.center().y), 4.0, object_color(current, app.session.state.roto.boundary_color));
+    app.auto.add("layerPanel.roto.object", r, &label);
+    x += 108.0;
+    let r = Rect::from_min_size(pos2(x, bar.center().y - 10.0), vec2(26.0, 20.0));
+    if widgets::text_button(ui, r, "+", false, &t, egui::Id::unique(("roto-object-new", uid))).clicked() {
+        let next = objects.iter().copied().chain([current]).max().map_or(0, |m| m + 1);
+        let _ = app.session.execute("roto.options", json!({"object": next}));
+    }
+    app.auto.add("layerPanel.roto.newObject", r, "New object");
+    x += 30.0;
+    // remove the current object's strokes (the object stays selected; with none left it is simply empty)
+    if strokes > 0 {
+        let r = Rect::from_min_size(pos2(x, bar.center().y - 10.0), vec2(26.0, 20.0));
+        let c = widgets::text_button(ui, r, "×", false, &t, egui::Id::unique(("roto-object-clear", uid))).on_hover_text(tr("Remove this object's strokes"));
+        if c.clicked()
+            && let Err(e) = app.session.execute("roto.clearStrokes", json!({"layer": layer.id.0, "effect": uid, "object": current}))
+        {
+            app.ui.status = e.to_string();
+        }
+        app.auto.add("layerPanel.roto.clearObject", r, "Remove object strokes");
+        x += 30.0;
+    }
     if running {
         let r = Rect::from_min_size(pos2(x, bar.center().y - 10.0), vec2(60.0, 20.0));
         if widgets::text_button(ui, r, tr("Stop"), false, &t, egui::Id::unique("roto-stop")).clicked() {
@@ -356,3 +495,39 @@ pub fn bar_buttons(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn per_object_outlines_follow_cropped_padded_and_scaled_input_coordinates() {
+        use effectcraft_engine::{effects::Buf, raster::Image};
+        let seg = fx::FrameSeg { w: 4, h: 2, matte: vec![0, 0, 255, 255, 0, 0, 255, 255], refine: vec![0; 8], ..Default::default() };
+        for (offset, scale, expected) in [
+            ([-2.0, 0.0], 1.0, vec![true, true]),
+            ([0.0, 0.0], 0.5, vec![false, true]),
+            ([-1.0, 0.0], 0.5, vec![true, false]),
+            ([2.0, 0.0], 1.0, vec![false, false]),
+        ] {
+            let inp = Buf { img: Image::new(2, 1), offset, scale };
+            assert_eq!(object_mask_in_input(&seg, &inp), expected, "offset={offset:?}, scale={scale}");
+        }
+        let inp = Buf { img: Image::new(6, 4), offset: [1.0, 1.0], scale: 1.0 };
+        let expected: Vec<bool> = (0..24).map(|i| matches!((i % 6, i / 6), (3 | 4, 1 | 2))).collect();
+        assert_eq!(object_mask_in_input(&seg, &inp), expected);
+    }
+
+    #[test]
+    fn confidence_colours_run_from_green_to_red_and_absent_is_slate() {
+        let (g, a, r, s) = (trust_color(0.99, false), trust_color(0.6, false), trust_color(0.1, false), trust_color(0.99, true));
+        assert_eq!(g, Color32::from_rgb(70, 200, 90));
+        assert_eq!(a, Color32::from_rgb(230, 180, 50));
+        assert_eq!(r, Color32::from_rgb(220, 70, 60));
+        assert_eq!(s, Color32::from_rgb(110, 118, 150));
+        // the boundaries
+        assert_eq!(trust_color(0.85, false), g);
+        assert_eq!(trust_color(0.5, false), a);
+        assert_eq!(trust_color(f32::NAN, false), r);
+    }
+}
diff --git a/crates/ui-egui/src/panels/rq_templates.rs b/crates/ui-egui/src/panels/rq_templates.rs
index 3a8791a49..93a458aae 100644
--- a/crates/ui-egui/src/panels/rq_templates.rs
+++ b/crates/ui-egui/src/panels/rq_templates.rs
@@ -11,6 +11,7 @@ use effectcraft_engine::project::render_templates::{RenderTemplates, TemplateKin
 use egui::{Color32, vec2};
 use serde_json::{Value, json};
 
+use crate::a11y;
 use crate::theme::Tokens;
 use crate::{Dialog, EffectcraftApp};
 
@@ -21,6 +22,8 @@ struct State {
     new_name: String,
 }
 
+/// The `egui::Id` of the render-settings / output-module template dialog's state ([`State`]):
+/// which kind it edits, the selected template and the name being typed.
 fn state_id() -> egui::Id {
     egui::Id::unique("rq-templates-dialog")
 }
@@ -58,11 +61,12 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                 ui.label(slot.label());
                 let cur = templates.default_name(k, slot);
                 let mut pick = cur.clone();
-                let r = egui::ComboBox::from_id_salt(("tpl-def", slot.label())).selected_text(&cur).width(300.0).show_ui(ui, |ui| {
+                let r = craft_ui::ComboBox::from_id_salt(("tpl-def", slot.label())).selected_text(&cur).width(300.0).show_ui(ui, |ui| {
                     for n in &list {
                         ui.selectable_value(&mut pick, n.clone(), n);
                     }
                 });
+                a11y::combo_box(&r.response, slot.label(), &cur, true);
                 app.auto.add(&format!("templates.default.{slot:?}"), r.response.rect, &cur);
                 if pick != cur {
                     actions.push(("renderQueue.setTemplateDefault", json!({"kind": kind, "slot": format!("{slot:?}"), "name": pick})));
@@ -75,11 +79,12 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
         ui.label(egui::RichText::new(tr("Settings")).font(Tokens::semibold(12.5)).color(t.text));
         ui.horizontal(|ui| {
             ui.label(tr("Settings Name:"));
-            let r = egui::ComboBox::from_id_salt("tpl-select").selected_text(&st.selected).width(300.0).show_ui(ui, |ui| {
+            let r = craft_ui::ComboBox::from_id_salt("tpl-select").selected_text(&st.selected).width(300.0).show_ui(ui, |ui| {
                 for n in &list {
                     ui.selectable_value(&mut st.selected, n.clone(), n);
                 }
             });
+            a11y::combo_box(&r.response, tr("Settings Name:").trim_end_matches(':'), &st.selected, true);
             app.auto.add("templates.select", r.response.rect, &st.selected);
         });
         let builtin = RenderTemplates::is_builtin(k, &st.selected)
@@ -135,6 +140,7 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
         ui.horizontal(|ui| {
             ui.label(tr("New from Render Queue item:"));
             let r = ui.add(egui::TextEdit::singleline(&mut st.new_name).hint_text(tr("template name")).desired_width(180.0));
+            a11y::text_input(&r, tr("template name"), &st.new_name);
             app.auto.add("templates.newName", r.rect, &st.new_name);
             let item = queue.last().map(|i| i.id);
             let ok = item.is_some() && !st.new_name.trim().is_empty();
diff --git a/crates/ui-egui/src/panels/scopes_panel.rs b/crates/ui-egui/src/panels/scopes_panel.rs
index c832061e8..726639598 100644
--- a/crates/ui-egui/src/panels/scopes_panel.rs
+++ b/crates/ui-egui/src/panels/scopes_panel.rs
@@ -38,6 +38,10 @@ struct Cached {
     tex: Option<egui::TextureHandle>,
 }
 
+/// The Scopes panel: the scope kind, colour standard, 8-bit/Float scale and Clamp Signal controls,
+/// then the chosen scope for the active comp's frame at the current time, cached per revision,
+/// comp, time, settings and plot size (drawn as a texture, or bars for the histogram) over its
+/// graticule. The controls update `app.ui.scopes`; the scope itself is only computed and drawn.
 pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let p = ui.painter().with_clip_rect(rect);
diff --git a/crates/ui-egui/src/panels/script_console.rs b/crates/ui-egui/src/panels/script_console.rs
index 4d0f1eb9d..7a2cecd30 100644
--- a/crates/ui-egui/src/panels/script_console.rs
+++ b/crates/ui-egui/src/panels/script_console.rs
@@ -74,6 +74,9 @@ pub fn run(app: &mut EffectcraftApp, ctx: &egui::Context) {
     con.input.clear();
 }
 
+/// The Script Console panel: the output log (newest lines at the bottom, coloured by kind), the
+/// multi-line script input and Run/Clear. Run — the button or ⌘/Ctrl+Enter while typing — hands the
+/// input to the script runner; Clear only empties the log. The input text and log are UI state.
 pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let input_h = 86.0;
@@ -99,7 +102,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         p.text(
             out_rect.center(),
             Align2::CENTER_CENTER,
-            "JavaScript with the After Effects scripting object model — try app.project.numItems",
+            crate::i18n::tr("JavaScript with the After Effects scripting object model — try app.project.numItems"),
             Tokens::ui(12.0),
             t.text_faint,
         );
diff --git a/crates/ui-egui/src/panels/scriptui_view.rs b/crates/ui-egui/src/panels/scriptui_view.rs
index a9fda57cc..753b2884e 100644
--- a/crates/ui-egui/src/panels/scriptui_view.rs
+++ b/crates/ui-egui/src/panels/scriptui_view.rs
@@ -15,7 +15,7 @@ use egui::{Align2, Color32, Rect, Sense, Stroke, StrokeKind, UiBuilder, pos2, ve
 use serde_json::{Value, json};
 
 use crate::EffectcraftApp;
-use crate::dock::PanelKind;
+use crate::dock::{PanelKind, WorkspaceExt as _};
 use crate::theme::Tokens;
 
 enum Act {
@@ -26,6 +26,8 @@ enum Act {
     Close(u32),
     /// A mouse event (`scriptui.mouse` parameters without window and widget).
     Mouse(u32, u32, Value),
+    /// A docked panel's new size (`scriptui.resize`).
+    Resize(u32, [f32; 2]),
 }
 
 fn rect_of(origin: egui::Pos2, b: [f64; 4]) -> Rect {
@@ -81,6 +83,11 @@ fn draw_children(app: &mut EffectcraftApp, ui: &mut egui::Ui, origin: egui::Pos2
     }
 }
 
+/// Draws ScriptUI widget `w` of window `win` at its bounds offset by `origin`, registering it for
+/// automation, and recurses into containers. Widgets with an `onDraw` handler are painted by the
+/// script (replacing the default look, or on top of it when it called `drawOSControl()`) while
+/// buttons, checkboxes and radios still take clicks. Edits and clicks are appended to `acts` for
+/// [`perform`]; while a field or slider is in use its live value lives in egui temp data.
 fn draw_widget(app: &mut EffectcraftApp, ui: &mut egui::Ui, origin: egui::Pos2, win: u32, w: &Widget, acts: &mut Vec<Act>) {
     let t = app.tokens;
     let services = app.session.services.clone();
@@ -209,7 +216,7 @@ fn draw_widget(app: &mut EffectcraftApp, ui: &mut egui::Ui, origin: egui::Pos2,
             let mut pick: Option<usize> = None;
             ui.add_enabled_ui(w.enabled, |ui| {
                 ui.scope_builder(UiBuilder::new().max_rect(rect), |ui| {
-                    egui::ComboBox::from_id_salt(id).selected_text(cur).width(rect.width() - 8.0).show_ui(ui, |ui| {
+                    craft_ui::ComboBox::from_id_salt(id).selected_text(cur).width(rect.width() - 8.0).show_ui(ui, |ui| {
                         for (i, it) in w.items.iter().enumerate() {
                             if it == "-" {
                                 ui.separator();
@@ -256,20 +263,22 @@ fn draw_widget(app: &mut EffectcraftApp, ui: &mut egui::Ui, origin: egui::Pos2,
     }
 }
 
+/// A draw-list colour (`None` is the theme colour). Script colours are display (sRGB) values
+/// in 0..1, as in After Effects, not linear light: `[43/255, 43/255, 43/255, 1]` is RGB 43.
+fn draw_color(c: &Option<[f32; 4]>, theme: Color32) -> Color32 {
+    c.map_or(theme, super::gradient_editor::to_color32)
+}
+
 /// Paint an onDraw draw list in `rect` (control coordinates → screen).
 fn paint_draw(ui: &egui::Ui, rect: Rect, ops: &[DrawOp], t: &Tokens, services: &dyn Services) {
     let p = ui.painter().with_clip_rect(rect.intersect(ui.clip_rect()));
-    let col = |c: &Option<[f32; 4]>, theme: Color32| match c {
-        Some(c) => egui::Rgba::from_rgba_unmultiplied(c[0], c[1], c[2], c[3]).into(),
-        None => theme,
-    };
     let at = |x: f64, y: f64| rect.min + vec2(x as f32, y as f32);
     for op in ops {
         match op {
             DrawOp::Fill { color, path } => {
                 // Any path shape (concave, self-intersecting, with holes): non-zero winding
                 // triangles, not egui's convex-only polygon fill.
-                let c = col(color, t.field_bg);
+                let c = draw_color(color, t.field_bg);
                 let mut mesh = egui::Mesh::default();
                 for tri in PathSeg::fill_triangles(path, 48, false) {
                     let base = mesh.vertices.len() as u32;
@@ -283,14 +292,14 @@ fn paint_draw(ui: &egui::Ui, rect: Rect, ops: &[DrawOp], t: &Tokens, services: &
                 }
             }
             DrawOp::Stroke { color, width, path } => {
-                let s = Stroke::new(*width as f32, col(color, t.text));
+                let s = Stroke::new(*width as f32, draw_color(color, t.text));
                 for (pts, closed) in PathSeg::polylines(path, 48) {
                     let pts: Vec<egui::Pos2> = pts.iter().map(|q| at(q[0], q[1])).collect();
                     p.add(if closed { egui::Shape::closed_line(pts, s) } else { egui::Shape::line(pts, s) });
                 }
             }
             DrawOp::Text { text, color, x, y, size, .. } => {
-                p.text(at(*x, *y), Align2::LEFT_TOP, text, Tokens::ui(*size as f32), col(color, t.text));
+                p.text(at(*x, *y), Align2::LEFT_TOP, text, Tokens::ui(*size as f32), draw_color(color, t.text));
             }
             DrawOp::Image { image, x, y, w, h } => {
                 let tex = image.as_ref().and_then(|i| image_texture(ui.ctx(), i, services));
@@ -388,7 +397,11 @@ fn mouse_events(ui: &egui::Ui, origin: egui::Pos2, area: Rect, win: u32, root: &
         return;
     }
     let mut st: MouseTrack = ui.data(|d| d.get_temp(id)).unwrap_or_default();
-    let (latest, events, mods, time) = ui.input(|i| (i.pointer.latest_pos(), i.events.clone(), i.modifiers, i.time));
+    let (latest, events, mods, time, held) = ui.input(|i| {
+        let held = |b: egui::PointerButton, bit: u8| if i.pointer.button_down(b) { bit } else { 0 };
+        let held = held(egui::PointerButton::Primary, 1) | held(egui::PointerButton::Secondary, 2) | held(egui::PointerButton::Middle, 4);
+        (i.pointer.latest_pos(), i.events.clone(), i.modifiers, i.time, held)
+    });
     let ctx = ui.ctx();
     let layer = ui.layer_id();
     let target = |p: egui::Pos2| -> Option<&Widget> {
@@ -407,7 +420,7 @@ fn mouse_events(ui: &egui::Ui, origin: egui::Pos2, area: Rect, win: u32, root: &
             w.id,
             json!({
                 "type": ty, "x": p.x - at.x, "y": p.y - at.y, "screenX": p.x, "screenY": p.y,
-                "button": button, "detail": detail,
+                "button": button, "buttons": held, "detail": detail,
                 "altKey": mods.alt, "ctrlKey": mods.ctrl, "shiftKey": mods.shift, "metaKey": mods.mac_cmd,
             }),
         ));
@@ -424,10 +437,15 @@ fn mouse_events(ui: &egui::Ui, origin: egui::Pos2, area: Rect, win: u32, root: &
         }
         st.hover = now_id;
     }
-    if let Some((w, p)) = now
-        && st.at != Some(p)
-    {
-        send(w, "mousemove", p, 0, 0, acts);
+    // While a button is held, the control it was pressed on keeps getting the moves, inside or
+    // outside the window, as in After Effects (#2584).
+    let captured = st.down.and_then(|(c, _)| root.find(c));
+    if let Some(p) = latest.filter(|p| st.at != Some(*p)) {
+        match (captured, now) {
+            (Some(c), _) => send(c, "mousemove", p, 0, 0, acts),
+            (None, Some((w, _))) => send(w, "mousemove", p, 0, 0, acts),
+            (None, None) => {}
+        }
     }
     st.at = latest;
     // Presses and releases.
@@ -439,7 +457,9 @@ fn mouse_events(ui: &egui::Ui, origin: egui::Pos2, area: Rect, win: u32, root: &
             egui::PointerButton::Secondary => 2,
             _ => continue,
         };
-        let Some(w) = target(*pos) else {
+        // A release goes to the control the button was pressed on, wherever the pointer is.
+        let pressed_on = st.down.filter(|(_, db)| !*pressed && *db == b).and_then(|(c, _)| root.find(c));
+        let Some(w) = pressed_on.or_else(|| target(*pos)) else {
             if !pressed {
                 st.down = None;
             }
@@ -453,7 +473,8 @@ fn mouse_events(ui: &egui::Ui, origin: egui::Pos2, area: Rect, win: u32, root: &
             send(w, "mousedown", *pos, b, st.clicks, acts);
         } else {
             send(w, "mouseup", *pos, b, st.clicks, acts);
-            if st.down == Some((w.id, b)) && b == 0 && w.enabled && w.mouse.iter().any(|m| m == "click") {
+            let over = target(*pos).is_some_and(|t| t.id == w.id);
+            if over && st.down == Some((w.id, b)) && b == 0 && w.enabled && w.mouse.iter().any(|m| m == "click") {
                 // The click with the pointer's details, after mousedown / mouseup, in place of
                 // the plain click the control reported.
                 acts.retain(|a| !matches!(a, Act::Click(aw, ac) if *aw == win && *ac == w.id));
@@ -471,6 +492,9 @@ fn snug(r: Rect, text: &str) -> Rect {
     Rect::from_min_size(r.min, vec2(w, r.height()))
 }
 
+/// Runs the actions collected while drawing a ScriptUI window as `scriptui.*` commands, in order.
+/// A reply carrying an `error` becomes a toast with the script's message; otherwise a non-empty
+/// `output` becomes the status line (its last line). Command failures also go to `app.ui.status`.
 fn perform(app: &mut EffectcraftApp, ctx: &egui::Context, acts: Vec<Act>) {
     for a in acts {
         let (cmd, p) = match a {
@@ -478,6 +502,7 @@ fn perform(app: &mut EffectcraftApp, ctx: &egui::Context, acts: Vec<Act>) {
             Act::Set(w, id, v) => ("scriptui.set", json!({"window": w, "widget": id, "value": v})),
             Act::Changing(w, id, v) => ("scriptui.set", json!({"window": w, "widget": id, "value": v, "changing": true})),
             Act::Close(w) => ("scriptui.close", json!({"window": w})),
+            Act::Resize(w, [x, y]) => ("scriptui.resize", json!({"window": w, "size": [x, y]})),
             Act::Mouse(w, id, mut v) => {
                 if let Some(o) = v.as_object_mut() {
                     o.insert("window".into(), json!(w));
@@ -546,7 +571,7 @@ pub fn show_windows(app: &mut EffectcraftApp, ctx: &egui::Context) {
     perform(app, ctx, acts);
 }
 
-/// A dockable ScriptUI panel's content (Window ▸ <panel>.jsx).
+/// A dockable ScriptUI panel's content (Window ▸ `<panel>.jsx`).
 pub fn panel(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect, id: u32) {
     let t = app.tokens;
     let Some(mut w) = app.session.script_ui.window(id).cloned() else {
@@ -560,6 +585,14 @@ pub fn panel(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect, id: u32) {
     // A modal script dialog blocks the panels too.
     let modal = app.session.script_ui.windows.iter().any(|w| w.modal);
     let mut acts = vec![];
+    // The script learns its dock's size when it changes (#2585), as After Effects tells a
+    // docked panel: its window takes the size and onResize runs.
+    let dock = [rect.width().round(), rect.height().round()];
+    let told = egui::Id::unique(("scriptui-dock-size", id));
+    if ui.data(|d| d.get_temp::<[f32; 2]>(told)) != Some(dock) && dock[0] >= 1.0 && dock[1] >= 1.0 {
+        ui.data_mut(|d| d.insert_temp(told, dock));
+        acts.push(Act::Resize(id, dock));
+    }
     let content = rect;
     egui::ScrollArea::both().id_salt(("scriptui-panel", id)).max_width(content.width()).max_height(content.height()).show(ui, |ui| {
         let (r, _) = ui.allocate_exact_size(vec2(w.root.bounds[2] as f32, w.root.bounds[3] as f32), Sense::hover());
@@ -579,12 +612,7 @@ pub fn panel_title(app: &EffectcraftApp, id: u32) -> Option<String> {
 /// Close the dock panels whose script window has gone (the script closed it, or a saved
 /// workspace from an earlier run).
 pub fn sync_panels(app: &mut EffectcraftApp) {
-    let mut all = vec![];
-    app.ui.dock.panels(&mut all);
-    for f in &app.ui.floating {
-        all.extend(f.panels.iter().copied());
-    }
-    for p in all {
+    for p in app.ui.dock.panels() {
         if let PanelKind::ScriptPanel(id) = p
             && app.session.script_ui.window(id).is_none()
         {
@@ -592,3 +620,47 @@ pub fn sync_panels(app: &mut EffectcraftApp) {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Script colours are sRGB, not linear: `#2B2B2B` drew as RGB 114 when read as linear light.
+    #[test]
+    fn draw_colours_are_srgb() {
+        let v = 43.0 / 255.0;
+        assert_eq!(draw_color(&Some([v, v, v, 1.0]), Color32::RED), Color32::from_rgb(43, 43, 43));
+        let orange = [242.0 / 255.0, 140.0 / 255.0, 40.0 / 255.0, 1.0];
+        assert_eq!(draw_color(&Some(orange), Color32::RED), Color32::from_rgb(242, 140, 40));
+        assert_eq!(draw_color(&None, Color32::RED), Color32::RED, "no colour is the theme colour");
+    }
+
+    /// fillPath, strokePath and drawString all paint the script's colour as sRGB.
+    #[test]
+    fn paint_draw_paints_srgb_colours() {
+        let v = 43.0 / 255.0;
+        let color = Some([v, v, v, 1.0]);
+        let path = vec![PathSeg::R { x: 0.0, y: 0.0, w: 10.0, h: 10.0 }];
+        let ops = [
+            DrawOp::Fill { color, path: path.clone() },
+            DrawOp::Stroke { color, width: 1.0, path },
+            DrawOp::Text { text: "Hi".into(), color, x: 0.0, y: 0.0, size: 12.0, style: String::new() },
+        ];
+        let t = Tokens::for_kind(crate::theme::ThemeKind::Dark);
+        let mut out = egui::Context::default().run_ui(egui::RawInput::default(), |ui| {
+            paint_draw(ui, Rect::from_min_size(pos2(0.0, 0.0), vec2(50.0, 50.0)), &ops, &t, &effectcraft_engine::FsServices);
+        });
+        out.textures_delta.clear();
+        let want = Color32::from_rgb(43, 43, 43);
+        let (mut fill, mut stroke, mut text) = (false, false, false);
+        for s in out.shapes {
+            match s.shape {
+                egui::Shape::Mesh(m) => fill |= m.vertices.iter().all(|v| v.color == want),
+                egui::Shape::Path(p) => stroke |= matches!(p.stroke.color, egui::epaint::ColorMode::Solid(c) if c == want),
+                egui::Shape::Text(t) => text |= t.fallback_color == want,
+                _ => {}
+            }
+        }
+        assert!(fill && stroke && text, "fill {fill}, stroke {stroke}, text {text}");
+    }
+}
diff --git a/crates/ui-egui/src/panels/settings.rs b/crates/ui-egui/src/panels/settings.rs
index a60272b4b..69f7623dd 100644
--- a/crates/ui-egui/src/panels/settings.rs
+++ b/crates/ui-egui/src/panels/settings.rs
@@ -13,6 +13,7 @@ use effectcraft_engine::segment::Task;
 use egui::{Color32, RichText, vec2};
 use serde_json::{Value, json};
 
+use crate::a11y;
 use crate::theme::{ThemeKind, Tokens};
 use crate::{Dialog, EffectcraftApp};
 
@@ -78,7 +79,8 @@ fn page_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, page: &Page, cur: &Value
                 ui.horizontal(|ui| {
                     ui.add_sized(vec2(label_w, 18.0), egui::Label::new(tr("Default Output:")));
                     let shown = if sel.is_empty() { tr("System Default").to_string() } else { sel.clone() };
-                    let r = egui::ComboBox::from_id_salt(("settings", key)).selected_text(shown).width(260.0).show_ui(ui, |ui| {
+                    let shown_name = shown.clone();
+                    let r = craft_ui::ComboBox::from_id_salt(("settings", key)).selected_text(shown).width(260.0).show_ui(ui, |ui| {
                         if ui.selectable_label(sel.is_empty(), tr("System Default")).clicked() {
                             acts.push(Act::Set(key.into(), json!("")));
                         }
@@ -88,6 +90,7 @@ fn page_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, page: &Page, cur: &Value
                             }
                         }
                     });
+                    a11y::combo_box(&r.response, tr("Default Output:").trim_end_matches(':'), &shown_name, true);
                     reg(app, &format!("settings.{key}"), &r.response, "Default Output");
                 });
                 if devices.is_empty() {
@@ -103,10 +106,12 @@ fn page_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, page: &Page, cur: &Value
                 let id = format!("settings.{key}");
                 let tip = (!live).then(|| tr("Stored, but not used by EffectCraft yet"));
                 let mut resp: Option<egui::Response> = None;
+                // What the control is set to, for assistive technology.
+                let mut value_text = String::new();
                 match kind {
                     Kind::Bool => {
                         let mut b = v.as_bool().unwrap_or(false);
-                        let r = ui.checkbox(&mut b, tr(label));
+                        let r = crate::widgets::labelled_checkbox(ui, &mut b, tr(label));
                         if r.changed() {
                             acts.push(Act::Set(key.into(), json!(b)));
                         }
@@ -117,15 +122,20 @@ fn page_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, page: &Page, cur: &Value
                             ui.add_sized(vec2(label_w, 18.0), egui::Label::new(format!("{}:", tr(label))).truncate());
                             let r = match kind {
                                 Kind::Int(lo, hi, unit) => {
-                                    let mut x = v.as_i64().unwrap_or(0);
-                                    // A typed number applies once entered: typing 85 into UI Scale
-                                    // doesn't resize the interface to 75 % at its first digit.
+                                    // A dragged value applies on release, and a typed one once
+                                    // entered: UI Scale doesn't resize the interface under the
+                                    // pointer mid-drag (#2582) or at a typed number's first digit.
+                                    let held = egui::Id::unique(("settings-drag", key));
+                                    let mut x = ui.data(|d| d.get_temp::<i64>(held)).unwrap_or_else(|| v.as_i64().unwrap_or(0));
                                     let drag = egui::DragValue::new(&mut x).range(lo..=hi).speed(0.25).update_while_editing(false);
                                     let r = ui.add(crate::widgets::drag_value(drag));
                                     if !unit.is_empty() {
                                         ui.label(RichText::new(tr(unit)).color(t.text_dim));
                                     }
-                                    if r.changed() {
+                                    if r.dragged() {
+                                        ui.data_mut(|d| d.insert_temp(held, x));
+                                    } else if r.changed() || r.drag_stopped() {
+                                        ui.data_mut(|d| d.remove::<i64>(held));
                                         acts.push(Act::Set(key.into(), json!(x)));
                                     }
                                     r
@@ -157,7 +167,8 @@ fn page_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, page: &Page, cur: &Value
                                 Kind::Choice(opts) => {
                                     let curv = v.as_str().map_or_else(|| v.to_string(), str::to_string);
                                     let shown = opts.iter().find(|o| o.1 == curv).map(|o| o.0).unwrap_or(curv.as_str()).to_string();
-                                    egui::ComboBox::from_id_salt(("settings", key))
+                                    value_text = tr(&shown).to_string();
+                                    craft_ui::ComboBox::from_id_salt(("settings", key))
                                         .selected_text(tr(&shown))
                                         .width(220.0)
                                         .show_ui(ui, |ui| {
@@ -172,6 +183,7 @@ fn page_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, page: &Page, cur: &Value
                                 Kind::Text | Kind::Path => {
                                     let mut s = v.as_str().unwrap_or("").to_string();
                                     let r = ui.add(egui::TextEdit::singleline(&mut s).desired_width(if kind == Kind::Path { 230.0 } else { 260.0 }));
+                                    value_text = s.clone();
                                     if r.changed() {
                                         acts.push(Act::Set(key.into(), json!(s)));
                                     }
@@ -189,6 +201,7 @@ fn page_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, page: &Page, cur: &Value
                                     let mut f = c.map(|v| v as f32 / 255.0);
                                     let r = crate::widgets::srgb_color_button(ui, &mut f);
                                     let rgb = if r.changed() { srgb_bytes(f) } else { c };
+                                    value_text = hex(rgb);
                                     ui.label(RichText::new(hex(rgb)).monospace().color(t.text_dim));
                                     if rgb != c {
                                         acts.push(Act::Set(key.into(), json!(hex(rgb))));
@@ -202,6 +215,17 @@ fn page_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, page: &Page, cur: &Value
                         });
                     }
                 }
+                if let Some(r) = &resp {
+                    // The field's label is drawn beside it, not on it: give the control its name.
+                    let name = tr(label);
+                    match kind {
+                        Kind::Bool => {}
+                        Kind::Choice(_) => a11y::combo_box(r, name, &value_text, true),
+                        Kind::Text | Kind::Path => a11y::text_input(r, name, &value_text),
+                        Kind::Color => a11y::name_value(r, name, &value_text),
+                        _ => a11y::name(r, name),
+                    }
+                }
                 if let Some(r) = resp {
                     let r = match tip {
                         Some(tip) => r.on_hover_text(tip),
@@ -302,19 +326,20 @@ fn theme_preview(ui: &mut egui::Ui, kind: ThemeKind, width: f32) {
     painter.line_segment([pos2(cti, graph.top()), pos2(cti, graph.bottom())], egui::Stroke::new(1.0, p.cti));
 }
 
+/// What [`theme_card`] shows: the setting `key`, the translated `title`, whether the family is
+/// `active`, the `cur`rent theme and the `options` (value, label) to pick from.
+struct ThemeFamily<'a> {
+    key: &'a str,
+    title: &'a str,
+    active: bool,
+    cur: &'a str,
+    options: &'a [(&'a str, &'a str)],
+}
+
 /// One theme family's card: its (translated) name, Active when the appearance shows it now, a preview of the
 /// chosen theme and a radio button per theme.
-fn theme_card(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    t: &Tokens,
-    key: &str,
-    title: &str,
-    active: bool,
-    cur: &str,
-    options: &[(&str, &str)],
-    acts: &mut Vec<Act>,
-) {
+fn theme_card(app: &mut EffectcraftApp, ui: &mut egui::Ui, t: &Tokens, fam: ThemeFamily, acts: &mut Vec<Act>) {
+    let ThemeFamily { key, title, active, cur, options } = fam;
     egui::Frame::new()
         .fill(t.field_bg)
         .stroke(egui::Stroke::new(1.0, if active { t.accent } else { t.field_border }))
@@ -378,7 +403,7 @@ fn appearance_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, cur: &Value, t: &T
     ui.horizontal(|ui| {
         ui.add_sized(vec2(250.0, 18.0), egui::Label::new(format!("{}:", tr("Appearance Mode"))).truncate());
         let shown = APPEARANCE_MODES.iter().find(|(_, v)| *v == mode).map_or(mode.as_str(), |(l, _)| *l);
-        let r = egui::ComboBox::from_id_salt(("settings", "appearance.appearanceMode"))
+        let r = craft_ui::ComboBox::from_id_salt(("settings", "appearance.appearanceMode"))
             .selected_text(tr(shown))
             .width(220.0)
             .show_ui(ui, |ui| {
@@ -389,6 +414,7 @@ fn appearance_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, cur: &Value, t: &T
                 }
             })
             .response;
+        a11y::combo_box(&r, tr("Appearance Mode"), tr(shown), true);
         reg(app, "settings.appearance.appearanceMode", &r, "Appearance Mode");
     });
     ui.add_space(6.0);
@@ -396,8 +422,20 @@ fn appearance_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, cur: &Value, t: &T
     let light_active = mode == "light" || (mode == "auto" && system_light == Some(true));
     ui.columns(2, |cols| {
         let [l, d] = cols else { return };
-        theme_card(app, l, t, "appearance.lightTheme", tr("Light Theme"), light_active, &light, LIGHT_THEMES, acts);
-        theme_card(app, d, t, "appearance.darkTheme", tr("Dark Theme"), !light_active, &dark, DARK_THEMES, acts);
+        theme_card(
+            app,
+            l,
+            t,
+            ThemeFamily { key: "appearance.lightTheme", title: tr("Light Theme"), active: light_active, cur: &light, options: LIGHT_THEMES },
+            acts,
+        );
+        theme_card(
+            app,
+            d,
+            t,
+            ThemeFamily { key: "appearance.darkTheme", title: tr("Dark Theme"), active: !light_active, cur: &dark, options: DARK_THEMES },
+            acts,
+        );
     });
     ui.add_space(6.0);
 }
@@ -451,6 +489,9 @@ fn models_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, t: &Tokens, acts: &mut
                 ui.label(RichText::new(state).color(if active { t.accent } else { t.text_dim }));
             });
             ui.label(RichText::new(m["description"].as_str().unwrap_or_default()).color(t.text_dim));
+            if let Some(hint) = m["hint"].as_str() {
+                ui.label(RichText::new(hint).color(if m["recommended"].as_bool().unwrap_or(false) { t.accent } else { t.text_dim }));
+            }
             if let Some(by) = m["authors"].as_str() {
                 ui.label(RichText::new(format!("By {by}")).color(t.text_dim));
             }
@@ -467,12 +508,19 @@ fn models_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, t: &Tokens, acts: &mut
                         }
                     }
                 }
+                if let (Some(source), Some(file)) = (m["source"].as_str(), m["sourceFile"].as_str()) {
+                    let response = ui.link(file).on_hover_text(crate::i18n::tr("Source"));
+                    reg(app, &format!("settings.{prefix}.source.{id}"), &response, file);
+                    if response.clicked() {
+                        ui.ctx().open_url(egui::OpenUrl::new_tab(source));
+                    }
+                }
             });
             if classic {
                 return;
             }
             ui.horizontal(|ui| {
-                if !installed && !web {
+                if !installed && !web && m["url"].as_str().is_some_and(|url| !url.is_empty()) {
                     let r = ui.add_enabled(busy.is_none(), egui::Button::new(tr("Download")));
                     reg(app, &format!("settings.{prefix}.download.{id}"), &r, "Download");
                     if r.clicked() {
@@ -600,12 +648,14 @@ fn labels_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, cur: &Value, acts: &mu
             let mut f = c.map(|v| v as f32 / 255.0);
             let r = crate::widgets::srgb_color_button(ui, &mut f);
             let rgb = if r.changed() { srgb_bytes(f) } else { c };
+            a11y::name_value(&r, &tr_args("Label {} color", &[&(i + 1)]), &hex(rgb));
             app.auto.add(&format!("settings.labels.{i}.color"), r.rect, "label colour");
             if rgb != c {
                 acts.push(Act::Set(format!("labels.{i}.color"), json!(hex(rgb))));
             }
             let mut name = l["name"].as_str().unwrap_or("").to_string();
             let r = ui.add_sized(vec2(160.0, 20.0), egui::TextEdit::singleline(&mut name));
+            a11y::text_input(&r, &tr_args("Label {} name", &[&(i + 1)]), &name);
             app.auto.add(&format!("settings.labels.{i}.name"), r.rect, "label name");
             if r.changed() {
                 acts.push(Act::Set(format!("labels.{i}.name"), json!(name)));
@@ -671,11 +721,21 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
             ui.vertical(|ui| {
                 ui.set_width(page_width + 4.0);
                 egui::ScrollArea::vertical().id_salt("settings-pages").max_height(body_h).auto_shrink([false, false]).show(ui, |ui| {
+                    // One Tab stop for the list (the open page); Up / Down / Home / End move
+                    // between the pages and the focus goes with them.
                     // The rows touch, so the pointer never falls between two of them.
                     ui.spacing_mut().item_spacing.y = 0.0;
-                    for p in &all {
-                        let (r, resp) = ui.allocate_exact_size(vec2(page_width, 24.0), egui::Sense::click());
+                    let ctx = ui.ctx().clone();
+                    let page_item = |id: &str| egui::Id::unique(("settings-page", id.to_string()));
+                    let on_list = all.iter().any(|q| ctx.memory(|m| m.has_focus(page_item(q.id))));
+                    for (n, p) in all.iter().enumerate() {
                         let sel = page == p.id;
+                        let r = ui.allocate_space(vec2(page_width, 24.0)).1;
+                        let resp = ui.interact(r, page_item(p.id), if sel { egui::Sense::click() } else { egui::Sense::CLICK });
+                        a11y::list_item(&resp, crate::i18n::settings_page_title(p.title), sel, n + 1, all.len());
+                        if a11y::take_pending_focus(&ctx, "settings", resp.id) {
+                            resp.request_focus();
+                        }
                         if sel {
                             ui.painter().rect_filled(r, 3.0, t.accent);
                         } else if resp.hovered() {
@@ -690,11 +750,44 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                             (page_width - 20.0).max(0.0),
                             if sel { Color32::WHITE } else { t.text },
                         );
+                        if resp.has_focus() {
+                            ui.painter().rect_stroke(r.shrink(1.0), 3.0, egui::Stroke::new(2.0, t.text), egui::StrokeKind::Inside);
+                        }
                         app.auto.add(&format!("settings.page.{}", p.id), r, p.title);
                         if resp.on_hover_text(crate::i18n::settings_page_title(p.title)).clicked() {
                             page = p.id.to_string();
                         }
                     }
+                    if on_list {
+                        let at = all.iter().position(|q| q.id == page).unwrap_or(0);
+                        let last = all.len().saturating_sub(1);
+                        let mut to = at;
+                        for key in ctx.input(|i| {
+                            i.events
+                                .iter()
+                                .filter_map(|e| match e {
+                                    egui::Event::Key { key, pressed: true, modifiers, .. } if !modifiers.any() => Some(*key),
+                                    _ => None,
+                                })
+                                .collect::<Vec<_>>()
+                        }) {
+                            to = match key {
+                                egui::Key::ArrowDown => to.saturating_add(1).min(last),
+                                egui::Key::ArrowUp => to.saturating_sub(1),
+                                egui::Key::Home => 0,
+                                egui::Key::End => last,
+                                _ => to,
+                            };
+                        }
+                        if to != at
+                            && let Some(q) = all.get(to)
+                        {
+                            page = q.id.to_string();
+                            a11y::focus_next_pass(&ctx, "settings", page_item(q.id));
+                        }
+                        // The arrows are the list's, not egui's spatial focus moves.
+                        ctx.memory_mut(|m| m.move_focus(egui::FocusDirection::None));
+                    }
                 });
             });
             ui.separator();
@@ -790,9 +883,9 @@ pub fn recovery(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                 if m < 1 {
                     "less than a minute ago".to_string()
                 } else if m < 120 {
-                    format!("{m} minutes ago")
+                    tr_args("{} minutes ago", &[&m])
                 } else {
-                    format!("{} hours ago", m / 60)
+                    tr_args("{} hours ago", &[&(m / 60)])
                 }
             });
             ui.label(tr_args("Latest auto-save: {}", &[&a]));
@@ -838,3 +931,28 @@ pub fn recovery(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
         app.ui.status = e;
     }
 }
+
+#[cfg(all(test, not(target_arch = "wasm32")))]
+mod tests {
+    use super::*;
+
+    /// Install-only models must not offer a download that the command will reject.
+    #[test]
+    fn sam2_settings_offer_file_installation_without_downloads() {
+        let mut app = EffectcraftApp::new(effectcraft_engine::Session::default());
+        let ctx = egui::Context::default();
+        let tokens = app.tokens;
+        let mut actions = vec![];
+        let mut output = ctx
+            .run_ui(egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(900.0, 2200.0))), ..Default::default() }, |ui| {
+                models_ui(&mut app, ui, &tokens, &mut actions, Task::Mask)
+            });
+        output.textures_delta.clear();
+        for id in ["sam2.1-hiera-tiny", "sam2.1-hiera-small", "sam2.1-hiera-base-plus", "sam2.1-hiera-large"] {
+            assert!(app.auto.find(&format!("settings.roto.download.{id}")).is_none());
+            assert!(app.auto.find(&format!("settings.roto.install.{id}")).is_some());
+            assert_eq!(app.auto.find(&format!("settings.roto.source.{id}")).unwrap().label, "model.safetensors");
+        }
+        assert!(actions.is_empty());
+    }
+}
diff --git a/crates/ui-egui/src/panels/shortcut_editor.rs b/crates/ui-egui/src/panels/shortcut_editor.rs
index 6b8e194f3..e4bf313ac 100644
--- a/crates/ui-egui/src/panels/shortcut_editor.rs
+++ b/crates/ui-egui/src/panels/shortcut_editor.rs
@@ -17,7 +17,7 @@
 //! `shortcuts.resetPreset`, `shortcuts.close`.
 
 use crate::i18n::{tr, tr_args};
-use effectcraft_engine::shortcuts::{APP_SCOPE, Bindable, DEFAULT_PRESET, normalize};
+use effectcraft_engine::shortcuts::{APP_SCOPE, Bindable, DEFAULT_PRESET, normalize, scope_label};
 use egui::{Align2, Color32, Rect, RichText, Sense, Stroke, StrokeKind, pos2, vec2};
 use serde_json::{Value, json};
 
@@ -49,6 +49,8 @@ const PANEL_COLOR: Color32 = Color32::from_rgb(0x3f, 0xa8, 0x6c);
 
 pub fn open(app: &mut EffectcraftApp) {
     app.dialog_state.shortcuts = EditorState::default();
+    // Scripts copied into the Scripts folder since the table was built are listed too.
+    app.session.scripts_changed();
     app.dialog = Some(Dialog::Shortcuts);
 }
 
@@ -200,6 +202,12 @@ const SIDE_KEYS: &[(&str, &str, f32, f32)] = &[
     ("→", "ArrowRight", 2.0, 5.0),
 ];
 
+/// The Keyboard Shortcuts dialog: while a shortcut field listens it records the next key
+/// combination (dropping those key events so the field does not type them), the preset bar switches
+/// keymaps, the drawn keyboard lists what the selected key runs, and the command list and editor
+/// remove, assign and reset bindings, warning about conflicts. Enter is OK unless a rename field, a
+/// preset menu or the delete confirmation is open. The collected `shortcuts.*` commands are run
+/// with the session when the frame ends; OK closes the dialog.
 pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
     let mut st = std::mem::take(&mut app.dialog_state.shortcuts);
     let mut run: Vec<(String, Value)> = vec![];
@@ -258,7 +266,7 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
         // ---- preset bar
         ui.horizontal(|ui| {
             ui.label(tr("Preset:"));
-            let r = egui::ComboBox::from_id_salt("sc-preset").selected_text(&active).width(220.0).show_ui(ui, |ui| {
+            let r = craft_ui::ComboBox::from_id_salt("sc-preset").selected_text(&active).width(220.0).show_ui(ui, |ui| {
                 for n in &presets {
                     if ui.selectable_label(*n == active, n).clicked() {
                         run.push(("shortcuts.preset".into(), json!({"op": "select", "name": n})));
@@ -509,7 +517,7 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                     return;
                 };
                 ui.label(RichText::new(&b.label).font(Tokens::semibold(13.0)).color(t.tab_text_active));
-                ui.label(RichText::new(format!("{} • {}", b.command, b.scope)).color(t.text_faint));
+                ui.label(RichText::new(format!("{} • {}", b.command, scope_label(&b.scope))).color(t.text_faint));
                 ui.add_space(6.0);
                 let keys = table.keys.get(&b.key).cloned().unwrap_or_default();
                 if keys.is_empty() {
@@ -557,7 +565,7 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
                         ui.add_space(4.0);
                         ui.label(RichText::new(tr_args("⚠ {} is used by:", &[&(crate::menus::shortcut_text(&k))])).color(t.warning));
                         for c in conflicts.iter().take(4) {
-                            ui.label(RichText::new(format!("   {} ({})", c.label, c.scope)).color(t.warning));
+                            ui.label(RichText::new(format!("   {} ({})", c.label, scope_label(&c.scope))).color(t.warning));
                         }
                     }
                 }
diff --git a/crates/ui-egui/src/panels/templates.rs b/crates/ui-egui/src/panels/templates.rs
index ff8778a15..5a1ac35a0 100644
--- a/crates/ui-egui/src/panels/templates.rs
+++ b/crates/ui-egui/src/panels/templates.rs
@@ -62,14 +62,14 @@ pub fn home_tab(app: &mut EffectcraftApp, ui: &mut egui::Ui, area: Rect) {
     p.text(
         pos2(x, y + 26.0),
         Align2::LEFT_CENTER,
-        "Start from a ready-made project. Opening a template makes an untitled copy.",
+        crate::i18n::tr("Start from a ready-made project. Opening a template makes an untitled copy."),
         Tokens::ui(11.5),
         t.text_faint,
     );
     // Save the open project as a user template.
     let can_save = app.session.project.comps().next().is_some();
     let sr = Rect::from_min_size(pos2(area.max.x - 210.0, y - 4.0), vec2(210.0, 28.0));
-    let save = widgets::text_button(ui, sr, "Save Current as Template…", false, &t, egui::Id::unique("home-templates-save")).clicked();
+    let save = widgets::text_button(ui, sr, crate::i18n::tr("Save Current as Template…"), false, &t, egui::Id::unique("home-templates-save")).clicked();
     app.auto.add("home.templates.saveCurrent", sr, "Save Current as Template…");
     if save {
         if can_save {
diff --git a/crates/ui-egui/src/panels/text_panels.rs b/crates/ui-egui/src/panels/text_panels.rs
index 34dc4cce9..0ab0f10ec 100644
--- a/crates/ui-egui/src/panels/text_panels.rs
+++ b/crates/ui-egui/src/panels/text_panels.rs
@@ -3,7 +3,7 @@
 //! otherwise they apply to the whole selected text layer.
 
 use crate::i18n::tr;
-use effectcraft_engine::keyframe::{BaselineOption, Composer, Direction, FigureStyle, FigureWidth, Justify, Kerning, TextDoc};
+use effectcraft_engine::keyframe::{BaselineOption, Composer, Direction, FigureStyle, FigureWidth, Justify, Kerning, LineJoin, TextDoc};
 use effectcraft_engine::render::EvalCtx;
 use egui::{Align2, Rect, Sense, pos2, vec2};
 use serde_json::json;
@@ -57,11 +57,24 @@ pub fn text_target(app: &EffectcraftApp) -> Option<TextTarget> {
         .iter()
         .filter_map(|id| comp.layer(*id))
         .find(|l| matches!(l.source, effectcraft_engine::project::LayerSource::Text))?;
-    let ectx = EvalCtx { project: &app.session.project, comp_id: cid, comp, time: app.session.time(), expr: app.session.expr.as_deref(), footage: None };
+    let ectx = EvalCtx {
+        project: &app.session.project,
+        comp_id: cid,
+        comp,
+        time: app.session.time(),
+        expr: app.session.expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
     effectcraft_engine::render::text::source_text(&ectx, layer).map(|d| TextTarget { layer: layer.id.0, doc: d, range: None })
 }
 
-fn toggle(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, r: Rect, id: &str, label: &str, on: bool, bold: bool) -> bool {
+/// A small toggle button at `r` showing `label` (semibold 13 when `bold`, else 12), filled with
+/// the accent while `on`; returns whether it was clicked. It only reports the click: the caller
+/// decides the new state.
+fn toggle(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, r: Rect, id: &str, look: (&str, bool, bool)) -> bool {
+    let (label, on, bold) = look;
     let t = app.tokens;
     let resp = ui.interact(r, egui::Id::unique(("text-toggle", id)), Sense::click());
     p.rect_filled(
@@ -81,6 +94,191 @@ fn toggle(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, r: Rec
     resp.clicked()
 }
 
+/// Position of the numeric grid (`x0`, top `y`, width `w`) and whether edits are collected.
+#[derive(Clone, Copy)]
+struct Grid {
+    x0: f32,
+    y: f32,
+    w: f32,
+    enabled: bool,
+}
+
+/// Numeric fields in AE's two-column grid (Kerning is a popup, at row 1 left).
+fn numeric_fields(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, g: Grid, doc: &TextDoc, actions: &mut Vec<serde_json::Value>) {
+    let t = app.tokens;
+    let Grid { x0, y, w, enabled } = g;
+    let fields: [(&str, &str, f64, (f64, f64), &str); 10] = [
+        ("size", "T", doc.size, (1.0, 2000.0), " px"),
+        ("leading", "A", doc.leading.unwrap_or(doc.size * 1.2), (0.0, 5000.0), " px"),
+        ("", "", 0.0, (0.0, 0.0), ""),
+        ("tracking", "VA", doc.tracking, (-1000.0, 10000.0), ""),
+        ("strokeWidth", "W", doc.stroke_width, (0.0, 500.0), " px"),
+        ("", "", 0.0, (0.0, 0.0), ""),
+        ("vScale", "↕T", doc.v_scale, (1.0, 1000.0), " %"),
+        ("hScale", "↔T", doc.h_scale, (1.0, 1000.0), " %"),
+        ("baselineShift", "A↑", doc.baseline_shift, (-1000.0, 1000.0), " px"),
+        ("tsume", "Ts", doc.tsume, (0.0, 100.0), " %"),
+    ];
+    for (i, (key, glyph, v, range, suffix)) in fields.into_iter().enumerate() {
+        if key.is_empty() {
+            continue;
+        }
+        let col = i % 2;
+        let row = i / 2;
+        let fx = x0 + col as f32 * (w / 2.0);
+        let fy = y + row as f32 * 28.0;
+        let stroke = key == "strokeWidth";
+        if stroke {
+            // The stroke-width icon, as in After Effects, not a letter that reads as "width".
+            crate::icons::paint(p, Rect::from_min_size(pos2(fx, fy + 1.0), vec2(18.0, 18.0)), crate::icons::Icon::StrokeWidth, t.text_dim);
+        } else {
+            p.text(pos2(fx, fy + 9.0), Align2::LEFT_CENTER, glyph, Tokens::semibold(11.0), t.text_dim);
+        }
+        // Fractional stroke widths (the 0.25 / 0.5 / 0.75 presets) show their decimals.
+        let decimals = if stroke && v.fract().abs() > 1e-9 { 2 } else { 0 };
+        let (r, nv, _) =
+            widgets::hot_number_at(ui, pos2(fx + 26.0, fy), egui::Id::unique(("char", key)), v, &widgets::HotSpec { speed: 0.5, range, decimals, suffix }, &t);
+        app.auto.add(&format!("character.{key}"), r, key);
+        if stroke {
+            stroke_width_presets(app, ui, r, enabled, actions);
+        }
+        if let Some(nv) = nv
+            && enabled
+        {
+            actions.push(json!({key: nv, "merge": format!("char-{key}")}));
+        }
+    }
+}
+
+/// The stroke width's presets menu beside its value (`r`), as in After Effects.
+fn stroke_width_presets(app: &mut EffectcraftApp, ui: &mut egui::Ui, r: Rect, enabled: bool, actions: &mut Vec<serde_json::Value>) {
+    const PRESETS: [f64; 22] = [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0];
+    let t = app.tokens;
+    let br = Rect::from_min_size(pos2(r.max.x + 4.0, r.min.y + 2.0), vec2(16.0, 16.0));
+    let pop = egui::Id::unique("char-stroke-width-pop");
+    if widgets::icon_button(ui, br, crate::icons::Icon::ChevronDown, false, &t, egui::Id::unique("char-stroke-width-presets"))
+        .on_hover_text(tr("Stroke width presets"))
+        .clicked()
+        && enabled
+    {
+        widgets::open_popup(ui, pop);
+    }
+    app.auto.add("character.strokeWidth.presets", br, "Stroke width presets");
+    let labels: Vec<String> = PRESETS.iter().map(|v| format!("{v} px")).collect();
+    if let Some(v) = widgets::popup_menu(ui, pop, br.left_bottom(), &labels, None).and_then(|i| PRESETS.get(i)) {
+        actions.push(json!({"strokeWidth": v}));
+    }
+}
+
+/// Kerning: Metrics / Optical / a manual value (grid row 1, left).
+fn kerning_field(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, g: Grid, doc: &TextDoc, actions: &mut Vec<serde_json::Value>) {
+    let t = app.tokens;
+    let Grid { x0, y, w, enabled } = g;
+    let fy = y + 28.0;
+    p.text(pos2(x0, fy + 9.0), Align2::LEFT_CENTER, "V/A", Tokens::semibold(11.0), t.text_dim);
+    let label = match doc.kerning {
+        Kerning::Metrics => "Metrics".to_string(),
+        Kerning::Optical => "Optical".to_string(),
+        Kerning::Manual(v) => format!("{v:.0}"),
+    };
+    let kr = Rect::from_min_size(pos2(x0 + 26.0, fy), vec2((w / 2.0 - 32.0).max(50.0), 20.0));
+    let kpop = egui::Id::unique("char-kerning-pop");
+    if widgets::dropdown(ui, kr, &label, &t, egui::Id::unique("char-kerning")).clicked() && enabled {
+        widgets::open_popup(ui, kpop);
+    }
+    app.auto.add("character.kerning", kr, "Kerning");
+    let opts: Vec<String> = ["Metrics", "Optical", "0", "-50", "-25", "-10", "10", "25", "50", "100"].iter().map(|s| s.to_string()).collect();
+    if let Some(i) = widgets::popup_menu(ui, kpop, kr.left_bottom(), &opts, None) {
+        let v = match i {
+            0 => json!("metrics"),
+            1 => json!("optical"),
+            _ => json!(opts[i].parse::<f64>().unwrap_or(0.0)),
+        };
+        actions.push(json!({"kerning": v}));
+    }
+}
+
+/// Stroke order (grid row 2, right): per character (Fill Over Stroke / Stroke Over Fill), or for
+/// the whole layer, which is the layer's More Options > Fill & Stroke (`fill_stroke`, see
+/// [`layer_fill_stroke`]). Returns the layer order picked, if any.
+fn stroke_order_field(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    g: Grid,
+    doc: &TextDoc,
+    fill_stroke: u32,
+    actions: &mut Vec<serde_json::Value>,
+) -> Option<u32> {
+    let t = app.tokens;
+    let Grid { x0, y, w, enabled } = g;
+    let fx = x0 + w / 2.0;
+    let fy = y + 2.0 * 28.0;
+    let dr = Rect::from_min_size(pos2(fx, fy), vec2(w / 2.0, 20.0));
+    let labels: Vec<String> =
+        ["Fill Over Stroke", "Stroke Over Fill", "-", "All Fills Over All Strokes", "All Strokes Over All Fills"].iter().map(|s| s.to_string()).collect();
+    let current = match fill_stroke {
+        1 => 3,
+        2 => 4,
+        _ => doc.stroke_over_fill as usize,
+    };
+    let pop = egui::Id::unique("char-stroke-order-pop");
+    if widgets::dropdown(ui, dr, &labels[current], &t, egui::Id::unique("char-stroke-order")).clicked() && enabled {
+        widgets::open_popup(ui, pop);
+    }
+    app.auto.add("character.strokeOverFill", dr, "Stroke order");
+    match widgets::popup_menu(ui, pop, dr.left_bottom(), &labels, Some(current)) {
+        Some(i @ (3 | 4)) => Some(i as u32 - 2),
+        Some(i) => {
+            actions.push(json!({"strokeOverFill": i == 1}));
+            // A per-character order puts the layer back on the Per Character Palette, or it
+            // would have no visible effect.
+            (fill_stroke != 0).then_some(0)
+        }
+        None => None,
+    }
+}
+
+/// Line Join of the stroke: Miter / Round / Bevel (grid row 5, under the stroke width).
+fn line_join_field(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painter, g: Grid, doc: &TextDoc, actions: &mut Vec<serde_json::Value>) {
+    let Grid { x0, y, w, enabled } = g;
+    let bw = (w - 2.0 * 4.0) / 3.0;
+    for (i, (key, label, join)) in
+        [("miter", "Miter", LineJoin::Miter), ("round", "Round", LineJoin::Round), ("bevel", "Bevel", LineJoin::Bevel)].into_iter().enumerate()
+    {
+        let r = Rect::from_min_size(pos2(x0 + i as f32 * (bw + 4.0), y + 5.0 * 28.0), vec2(bw, 22.0));
+        if toggle(app, ui, p, r, &format!("character.lineJoin.{key}"), (label, doc.line_join == join, false)) && enabled {
+            actions.push(json!({"lineJoin": key}));
+        }
+    }
+}
+
+/// Sets the layer's More Options > Fill & Stroke to `v` together with the per-character order
+/// it changes, as one undo step.
+fn apply_layer_fill_stroke(app: &mut EffectcraftApp, ctx: &egui::Context, tt: &TextTarget, v: u32, actions: Vec<serde_json::Value>) {
+    let set = json!({"command": "prop.set", "params": {"layer": tt.layer, "path": "text/moreOptions/fillStroke", "value": v}});
+    let steps: Vec<serde_json::Value> =
+        std::iter::once(set).chain(actions.into_iter().map(|a| json!({"command": "layer.setText", "params": tt.params(a)}))).collect();
+    if let Err(e) = crate::menus::invoke(app, ctx, "engine.batch", json!({"steps": steps, "label": "Stroke Order"})) {
+        app.ui.status = e;
+    }
+}
+
+/// A text layer's More Options > Fill & Stroke in the active comp: 0 per character palette,
+/// 1 all fills over all strokes, 2 all strokes over all fills.
+fn layer_fill_stroke(app: &EffectcraftApp, layer: u64) -> u32 {
+    let (Some(comp), Some(cid)) = (app.session.active_comp(), app.session.active_comp_id()) else { return 0 };
+    let Some(l) = comp.layer(effectcraft_engine::project::LayerId(layer)) else { return 0 };
+    let Some(more) = l.props.sub("text").and_then(|t| t.sub("moreOptions")) else { return 0 };
+    let ectx = EvalCtx { expr: app.session.expr.as_deref(), ..EvalCtx::new(&app.session.project, cid, comp, app.session.time()) };
+    ectx.e(l, more, "fillStroke")
+}
+
+/// The Character panel for the text being edited (or the selected text layer): font family and
+/// style, size, leading, tracking, stroke, scale, baseline shift and other numeric fields, kerning,
+/// fill/stroke colours with eyedroppers, style toggles, OpenType features and variable-font axes.
+/// Without a text target the panel is inert — no edit is collected and it asks for a text layer.
+/// Edits are collected and, when a target exists, sent as `layer.setText` commands scoped to the
+/// edited range; failures show in `app.ui.status`.
 pub fn character(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let p = ui.painter().with_clip_rect(rect);
@@ -113,82 +311,18 @@ pub fn character(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         actions.push(json!({"style": st}));
     }
     y += 34.0;
-    // Numeric fields in AE's two-column grid (Kerning is a popup, at row 1 right).
-    let fields: [(&str, &str, f64, (f64, f64), &str); 10] = [
-        ("size", "T", doc.size, (1.0, 2000.0), " px"),
-        ("leading", "A", doc.leading.unwrap_or(doc.size * 1.2), (0.0, 5000.0), " px"),
-        ("", "", 0.0, (0.0, 0.0), ""),
-        ("tracking", "VA", doc.tracking, (-1000.0, 10000.0), ""),
-        ("strokeWidth", "W", doc.stroke_width, (0.0, 500.0), " px"),
-        ("", "", 0.0, (0.0, 0.0), ""),
-        ("vScale", "↕T", doc.v_scale, (1.0, 1000.0), " %"),
-        ("hScale", "↔T", doc.h_scale, (1.0, 1000.0), " %"),
-        ("baselineShift", "A↑", doc.baseline_shift, (-1000.0, 1000.0), " px"),
-        ("tsume", "Ts", doc.tsume, (0.0, 100.0), " %"),
-    ];
-    for (i, (key, glyph, v, range, suffix)) in fields.into_iter().enumerate() {
-        if key.is_empty() {
-            continue;
-        }
-        let col = i % 2;
-        let row = i / 2;
-        let fx = x0 + col as f32 * (w / 2.0);
-        let fy = y + row as f32 * 28.0;
-        p.text(pos2(fx, fy + 9.0), Align2::LEFT_CENTER, glyph, Tokens::semibold(11.0), t.text_dim);
-        let (r, nv, _) = widgets::hot_number_at(ui, pos2(fx + 26.0, fy), egui::Id::unique(("char", key)), v, 0.5, range, 0, suffix, &t);
-        app.auto.add(&format!("character.{key}"), r, key);
-        if let Some(nv) = nv
-            && enabled
-        {
-            actions.push(json!({key: nv, "merge": format!("char-{key}")}));
-        }
-    }
-    // Kerning: Metrics / Optical / a manual value (row 1, left).
-    {
-        let fy = y + 28.0;
-        p.text(pos2(x0, fy + 9.0), Align2::LEFT_CENTER, "V/A", Tokens::semibold(11.0), t.text_dim);
-        let label = match doc.kerning {
-            Kerning::Metrics => "Metrics".to_string(),
-            Kerning::Optical => "Optical".to_string(),
-            Kerning::Manual(v) => format!("{v:.0}"),
-        };
-        let kr = Rect::from_min_size(pos2(x0 + 26.0, fy), vec2((w / 2.0 - 32.0).max(50.0), 20.0));
-        let kpop = egui::Id::unique("char-kerning-pop");
-        if widgets::dropdown(ui, kr, &label, &t, egui::Id::unique("char-kerning")).clicked() && enabled {
-            widgets::open_popup(ui, kpop);
-        }
-        app.auto.add("character.kerning", kr, "Kerning");
-        let opts: Vec<String> = ["Metrics", "Optical", "0", "-50", "-25", "-10", "10", "25", "50", "100"].iter().map(|s| s.to_string()).collect();
-        if let Some(i) = widgets::popup_menu(ui, kpop, kr.left_bottom(), &opts, None) {
-            let v = match i {
-                0 => json!("metrics"),
-                1 => json!("optical"),
-                _ => json!(opts[i].parse::<f64>().unwrap_or(0.0)),
-            };
-            actions.push(json!({"kerning": v}));
-        }
-    }
-    // Stroke Over Fill / Fill Over Stroke (row 2, right).
-    {
-        let fx = x0 + w / 2.0;
-        let fy = y + 2.0 * 28.0;
-        let dr = Rect::from_min_size(pos2(fx, fy), vec2(w / 2.0, 20.0));
-        let labels = vec!["Fill Over Stroke".to_string(), "Stroke Over Fill".to_string()];
-        let pop = egui::Id::unique("char-stroke-order-pop");
-        if widgets::dropdown(ui, dr, &labels[doc.stroke_over_fill as usize], &t, egui::Id::unique("char-stroke-order")).clicked() && enabled {
-            widgets::open_popup(ui, pop);
-        }
-        app.auto.add("character.strokeOverFill", dr, "Stroke order");
-        if let Some(i) = widgets::popup_menu(ui, pop, dr.left_bottom(), &labels, Some(doc.stroke_over_fill as usize)) {
-            actions.push(json!({"strokeOverFill": i == 1}));
-        }
-    }
-    y += 5.0 * 28.0 + 8.0;
+    let grid = Grid { x0, y, w, enabled };
+    numeric_fields(app, ui, &p, grid, &doc, &mut actions);
+    kerning_field(app, ui, &p, grid, &doc, &mut actions);
+    let fill_stroke = target.as_ref().map_or(0, |tt| layer_fill_stroke(app, tt.layer));
+    let layer_fill_stroke_pick = stroke_order_field(app, ui, grid, &doc, fill_stroke, &mut actions);
+    line_join_field(app, ui, &p, grid, &doc, &mut actions);
+    y += 6.0 * 28.0 + 8.0;
     // Fill / stroke swatches with their enable boxes.
     for (i, (key, label, on, c)) in [("fill", "Fill", doc.apply_fill, doc.fill), ("stroke", "Stroke", doc.apply_stroke, doc.stroke)].into_iter().enumerate() {
         let fx = x0 + i as f32 * (w / 2.0);
         let cr = Rect::from_min_size(pos2(fx, y + 3.0), vec2(14.0, 14.0));
-        if widgets::checkbox(ui, cr, on, &t, egui::Id::unique(("char-apply", key))).clicked() && enabled {
+        if ui.add_enabled_ui(enabled, |ui| widgets::checkbox(ui, cr, on, &t, egui::Id::unique(("char-apply", key)))).inner.changed() && enabled {
             actions.push(json!({if key == "fill" { "applyFill" } else { "applyStroke" }: !on}));
         }
         app.auto.add(&format!("character.{key}.enabled"), cr, label);
@@ -204,7 +338,8 @@ pub fn character(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
         let er = Rect::from_min_size(pos2(fs.max.x + 4.0, y + 1.0), vec2(18.0, 18.0));
         let active = app.ui.text_color_pick.as_ref().is_some_and(|pick| pick.layer == target.as_ref().map_or(0, |tt| tt.layer) && pick.field == key);
-        let eye = super::fx_widgets::eyedropper_button(ui, er, active, egui::Id::unique(("char-eye", key)), &t);
+        let eye = super::fx_widgets::eyedropper_button(ui, er, active, egui::Id::unique(("char-eye", key)), &t)
+            .on_hover_text(tr("Eyedropper: click, then click in the Composition panel"));
         app.auto.add(&format!("character.{key}.eyedropper"), er, &format!("{label} eyedropper"));
         if eye.clicked() {
             if active {
@@ -233,14 +368,14 @@ pub fn character(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let bw = ((w - 5.0 * 4.0) / 6.0).clamp(22.0, 30.0);
     for (i, (key, label, on, bold)) in toggles.into_iter().enumerate() {
         let r = Rect::from_min_size(pos2(x0 + i as f32 * (bw + 4.0), y), vec2(bw, 24.0));
-        if toggle(app, ui, &p, r, &format!("character.{key}"), label, on, bold) && enabled {
+        if toggle(app, ui, &p, r, &format!("character.{key}"), (label, on, bold)) && enabled {
             actions.push(json!({key: !on}));
         }
     }
     y += 32.0;
     // Ligatures.
     let lr = Rect::from_min_size(pos2(x0, y), vec2(14.0, 14.0));
-    if widgets::checkbox(ui, lr, doc.ligatures, &t, egui::Id::unique("char-ligatures")).clicked() && enabled {
+    if ui.add_enabled_ui(enabled, |ui| widgets::checkbox(ui, lr, doc.ligatures, &t, egui::Id::unique("char-ligatures"))).inner.changed() && enabled {
         actions.push(json!({"ligatures": !doc.ligatures}));
     }
     app.auto.add("character.ligatures", lr, "Ligatures");
@@ -264,7 +399,7 @@ pub fn character(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 .enumerate()
         {
             let cr = Rect::from_min_size(pos2(x0 + i as f32 * 120.0, y), vec2(14.0, 14.0));
-            if widgets::checkbox(ui, cr, on, &t, egui::Id::unique(("char-vert", key))).clicked() && enabled {
+            if ui.add_enabled_ui(enabled, |ui| widgets::checkbox(ui, cr, on, &t, egui::Id::unique(("char-vert", key)))).inner.changed() && enabled {
                 actions.push(json!({key: !on}));
             }
             app.auto.add(&format!("character.{key}"), cr, label);
@@ -287,8 +422,14 @@ pub fn character(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             let tag = a.tag.trim_end().to_string();
             let v = doc.variations.iter().chain(&instance).find(|(t2, _)| t2.trim_end() == tag).map(|(_, v)| *v).unwrap_or(a.default);
             p.text(pos2(fx, fy + 9.0), Align2::LEFT_CENTER, &tag, Tokens::semibold(10.5), t.text_dim);
-            let (r, nv, _) =
-                widgets::hot_number_at(ui, pos2(fx + 34.0, fy), egui::Id::unique(("char-axis", &tag)), v as f64, 1.0, (a.min as f64, a.max as f64), 0, "", &t);
+            let (r, nv, _) = widgets::hot_number_at(
+                ui,
+                pos2(fx + 34.0, fy),
+                egui::Id::unique(("char-axis", &tag)),
+                v as f64,
+                &widgets::HotSpec { speed: 1.0, range: (a.min as f64, a.max as f64), decimals: 0, suffix: "" },
+                &t,
+            );
             app.auto.add(&format!("character.axis.{tag}"), r, &a.name);
             if let Some(nv) = nv
                 && enabled
@@ -312,6 +453,9 @@ pub fn character(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         _ => {}
     }
     let Some(tt) = target else { return };
+    if let Some(v) = layer_fill_stroke_pick {
+        apply_layer_fill_stroke(app, &ctx, &tt, v, std::mem::take(&mut actions));
+    }
     for a in actions {
         if let Err(e) = crate::menus::invoke(app, &ctx, "layer.setText", tt.params(a)) {
             app.ui.status = e;
@@ -452,6 +596,10 @@ pub fn paint_justify_glyph(p: &egui::Painter, r: Rect, j: Justify, c: egui::Colo
     }
 }
 
+/// The Paragraph panel: alignment, left/right/first-line indents, space before and after,
+/// paragraph direction (when the text engine allows it), the composer, and Roman hanging
+/// punctuation. Edits are queued and sent as `layer.setText` for the edited range when a text
+/// target exists; failures show in `app.ui.status`.
 pub fn paragraph(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let p = ui.painter().with_clip_rect(rect);
@@ -504,7 +652,14 @@ pub fn paragraph(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         let fx = x0 + (i % 2) as f32 * (w / 2.0);
         let fy = y + (i / 2) as f32 * 28.0;
         p.text(pos2(fx, fy + 9.0), Align2::LEFT_CENTER, glyph, Tokens::semibold(11.0), t.text_dim);
-        let (r, nv, _) = widgets::hot_number_at(ui, pos2(fx + 26.0, fy), egui::Id::unique(("para-f", key)), v, 0.5, (-5000.0, 5000.0), 0, " px", &t);
+        let (r, nv, _) = widgets::hot_number_at(
+            ui,
+            pos2(fx + 26.0, fy),
+            egui::Id::unique(("para-f", key)),
+            v,
+            &widgets::HotSpec { speed: 0.5, range: (-5000.0, 5000.0), decimals: 0, suffix: " px" },
+            &t,
+        );
         app.auto.add(&format!("paragraph.{key}"), r, key);
         if let Some(nv) = nv
             && enabled
@@ -547,7 +702,7 @@ pub fn paragraph(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     y += 30.0;
     let hr = Rect::from_min_size(pos2(x0, y), vec2(14.0, 14.0));
-    if widgets::checkbox(ui, hr, doc.hanging_punctuation, &t, egui::Id::unique("para-hanging")).clicked() && enabled {
+    if ui.add_enabled_ui(enabled, |ui| widgets::checkbox(ui, hr, doc.hanging_punctuation, &t, egui::Id::unique("para-hanging"))).inner.changed() && enabled {
         actions.push(json!({"hangingPunctuation": !doc.hanging_punctuation}));
     }
     app.auto.add("paragraph.hangingPunctuation", hr, "Roman Hanging Punctuation");
@@ -572,6 +727,17 @@ struct FontSearch {
 }
 
 /// Shared font menu for Character and Properties: search, recent fonts and previews.
+/// Finish a font rescan started from the font menu and report how many faces it added.
+/// While the scan is still walking font folders, ask for another frame so the menu updates.
+pub(crate) fn poll_font_rescan(app: &mut EffectcraftApp, ctx: &egui::Context) {
+    if effectcraft_engine::text::fonts::rescan_busy() {
+        ctx.request_repaint_after(std::time::Duration::from_millis(100));
+    }
+    if let Some(n) = effectcraft_engine::text::fonts::poll_rescan() {
+        app.ui.status = format!("{} +{n}", tr("Rescan Fonts"));
+    }
+}
+
 pub(super) fn font_picker(app: &mut EffectcraftApp, ui: &mut egui::Ui, id: egui::Id, rect: Rect, current: &str, auto: &str, enabled: bool) -> Option<String> {
     let state_id = id.with("search-state");
     app.auto.add(auto, rect, "Font family");
@@ -622,130 +788,139 @@ pub(super) fn font_picker(app: &mut EffectcraftApp, ui: &mut egui::Ui, id: egui:
         return None;
     }
     app.auto.add(&format!("{auto}.toggle"), arrow, "Close font list");
-    let mut chosen = None;
-    let screen = ui.ctx().content_rect();
-    let below = screen.bottom() - rect.bottom() - 16.0;
-    let above = below < 100.0 && rect.top() - screen.top() > below;
-    let max_height = (if above { rect.top() - screen.top() - 16.0 } else { below }).clamp(28.0, 380.0);
-    let anchor = if above { rect.left_top() } else { rect.left_bottom() };
-    let pivot = if above { Align2::LEFT_BOTTOM } else { Align2::LEFT_TOP };
     widgets::note_open_popup_list(ui.ctx());
-    let area = egui::Area::new(id.with("area")).order(egui::Order::Foreground).pivot(pivot).fixed_pos(anchor).show(ui.ctx(), |ui| {
-        egui::Frame::popup(ui.style()).show(ui, |ui| {
-            ui.set_width(rect.width().max(180.0));
-            // Filter row: a checkbox that keeps only the variable fonts.
-            let filter_h = 22.0;
-            let row = ui.add_sized([ui.available_width(), filter_h], egui::Button::selectable(false, ""));
-            let box_rect = Rect::from_min_size(row.rect.min, vec2(18.0, filter_h));
-            let label_rect = Rect::from_min_max(pos2(box_rect.max.x + 2.0, row.rect.min.y), row.rect.max);
-            let boxed = widgets::checkbox(ui, box_rect, only_variable, &t, id.with("variable-check"));
-            ui.painter().text(label_rect.left_center(), Align2::LEFT_CENTER, tr("Variable fonts only"), Tokens::ui(11.5), t.text);
-            app.auto.add(&format!("{auto}.variable"), row.rect, "Variable fonts only");
-            let toggled = row.clicked() || boxed.clicked();
-            if toggled {
-                only_variable = !only_variable;
-                ui.data_mut(|d| d.insert_temp(variable_id, only_variable));
-                // Typing goes on into the search field.
-                ui.memory_mut(|m| m.request_focus(search_id));
+    let changed = search.changed();
+    let mut open = true;
+    // The search lives in the field; the menu's header is the filter row, its list the fonts.
+    let menu = craft_ui::combo::Menu::new(ui, &search)
+        .open(&mut open)
+        .height(380.0)
+        .close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside)
+        .style(egui::style::StyleModifier::default());
+    let app_ref = &mut *app;
+    let header = |ui: &mut egui::Ui| {
+        ui.set_width(rect.width().max(180.0));
+        // Filter row: a checkbox that keeps only the variable fonts.
+        let filter_h = 22.0;
+        let row = ui.add_sized([ui.available_width(), filter_h], widgets::DragCheckbox::new(&mut only_variable, tr("Variable fonts only")));
+        app_ref.auto.add(&format!("{auto}.variable"), row.rect, "Variable fonts only");
+        // #1089: fonts installed after launch appear without restarting. The button is its own
+        // row: the popup is only 180 px wide, so a control pinned to the filter row covers
+        // "Variable fonts only". The scan itself runs off the UI thread (`poll_font_rescan`).
+        let rescan_h = 22.0;
+        let (resc, _) = ui.allocate_exact_size(vec2(ui.available_width(), rescan_h), egui::Sense::hover());
+        if widgets::text_button(ui, resc, tr("Rescan Fonts"), false, &t, id.with("rescan")).clicked() && effectcraft_engine::text::fonts::start_rescan() {
+            app_ref.ui.status = format!("{}…", tr("Rescan Fonts"));
+        }
+        app_ref.auto.add(&format!("{auto}.rescan"), resc, "Rescan Fonts");
+        let toggled = row.changed();
+        if toggled {
+            ui.data_mut(|d| d.insert_temp(variable_id, only_variable));
+        }
+        // The native checkbox can take focus on release after changing on press.
+        // Typing goes on into the search field after either event.
+        if toggled || row.clicked() {
+            ui.memory_mut(|m| m.request_focus(search_id));
+        }
+        let query = state.query.trim().to_lowercase();
+        let mut seen = std::collections::HashSet::new();
+        let filtered: Vec<_> = rows
+            .iter()
+            .filter(|r| {
+                !r.family.is_empty()
+                    && (!only_variable || r.variable)
+                    && (query.is_empty() || ((r.family.to_lowercase().contains(&query) || r.display.to_lowercase().contains(&query)) && seen.insert(&r.family)))
+            })
+            .collect();
+        if fresh {
+            state.selected = filtered.iter().position(|r| r.family == current).unwrap_or(0);
+        }
+        if changed || toggled {
+            state.selected = 0;
+        }
+        let last = filtered.len().saturating_sub(1);
+        state.selected = state.selected.min(last);
+        if down {
+            state.selected = state.selected.saturating_add(1).min(last);
+        }
+        if up {
+            state.selected = state.selected.saturating_sub(1);
+        }
+        let entered = if enter { filtered.get(state.selected).map(|r| r.family.clone()) } else { None };
+        (app_ref, filtered, query.is_empty(), state.selected, changed || toggled, entered)
+    };
+    let list = |ui: &mut egui::Ui,
+                (app, filtered, all, selected, restart, entered): (
+        &mut EffectcraftApp,
+        Vec<&effectcraft_engine::FontRow>,
+        bool,
+        usize,
+        bool,
+        Option<String>,
+    )| {
+        if restart {
+            ui.scroll_to_cursor(Some(egui::Align::TOP));
+        }
+        let mut chosen = entered;
+        if filtered.is_empty() {
+            let r = ui.label(tr("No matching fonts"));
+            app.auto.add(&format!("{auto}.empty"), r.rect, "No matching fonts");
+        }
+        let mut was_recent = false;
+        for (index, r) in filtered.iter().enumerate() {
+            if all && was_recent && !r.recent {
+                ui.separator();
             }
-            let query = state.query.trim().to_lowercase();
-            let mut seen = std::collections::HashSet::new();
-            let filtered: Vec<_> = rows
-                .iter()
-                .filter(|r| {
-                    !r.family.is_empty()
-                        && (!only_variable || r.variable)
-                        && (query.is_empty()
-                            || ((r.family.to_lowercase().contains(&query) || r.display.to_lowercase().contains(&query)) && seen.insert(&r.family)))
-                })
-                .collect();
-            if fresh {
-                state.selected = filtered.iter().position(|r| r.family == current).unwrap_or(0);
+            was_recent = r.recent;
+            let row_width = ui.available_width();
+            let label_width = if preview { (row_width - 100.0).max(40.0) } else { row_width };
+            let resp = ui.add_sized([row_width, 24.0], egui::Button::selectable(index == selected, ""));
+            resp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, ui.is_enabled(), index == selected, &r.display));
+            let label_rect = Rect::from_min_size(resp.rect.min + vec2(5.0, 0.0), vec2(label_width - 5.0, resp.rect.height()));
+            let name = drawn_font_name(ui.ctx(), r);
+            ui.painter().with_clip_rect(label_rect.intersect(ui.clip_rect())).text(
+                label_rect.left_center(),
+                Align2::LEFT_CENTER,
+                name,
+                Tokens::ui(12.0),
+                t.text,
+            );
+            if ui.is_rect_visible(resp.rect) {
+                app.auto.add(&format!("{auto}.option.{}", r.family), resp.rect, &r.display);
             }
-            if search.changed() || toggled {
-                state.selected = 0;
+            if index == selected && (fresh || up || down) {
+                resp.scroll_to_me(None);
             }
-            let last = filtered.len().saturating_sub(1);
-            state.selected = state.selected.min(last);
-            if down {
-                state.selected = state.selected.saturating_add(1).min(last);
-            }
-            if up {
-                state.selected = state.selected.saturating_sub(1);
-            }
-            if enter {
-                chosen = filtered.get(state.selected).map(|r| r.family.clone());
-            }
-            // Give the result list its actual height even when the previous query had
-            // only one row. A cached tiny Area must not collapse a reopened long list.
-            let filter_room = filter_h + ui.spacing().item_spacing.y;
-            let height = (filtered.len() as f32 * (24.0 + ui.spacing().item_spacing.y) + 16.0).clamp(28.0, (max_height - filter_room).max(28.0));
-            // A minimum, from below the filter row (a maximum would move the cursor back up).
-            ui.set_min_height(height);
-            let mut scroll = egui::ScrollArea::vertical().id_salt(id.with("results")).max_height(height).min_scrolled_height(height);
-            if search.changed() || toggled {
-                scroll = scroll.vertical_scroll_offset(0.0);
-            }
-            scroll.show(ui, |ui| {
-                if filtered.is_empty() {
-                    let r = ui.label(tr("No matching fonts"));
-                    app.auto.add(&format!("{auto}.empty"), r.rect, "No matching fonts");
+            if preview && ui.is_rect_visible(resp.rect) {
+                let key = egui::Id::unique(("font-preview", &r.family));
+                let lines: std::sync::Arc<Vec<Vec<[f32; 2]>>> = match ui.data(|d| d.get_temp(key)) {
+                    Some(l) => l,
+                    None => {
+                        let l = std::sync::Arc::new(effectcraft_engine::font_preview(&r.family, 14.0));
+                        ui.data_mut(|d| d.insert_temp(key, l.clone()));
+                        l
+                    }
+                };
+                // Scaled and placed to fit the row's preview column, and clipped to the row (#577).
+                let room = Rect::from_min_max(pos2(resp.rect.max.x - 95.0, resp.rect.min.y + 1.0), pos2(resp.rect.max.x - 6.0, resp.rect.max.y - 1.0));
+                if let Some((k, o)) = fit_preview(&lines, room, resp.rect.center().y + 5.0) {
+                    let painter = ui.painter().with_clip_rect(resp.rect.intersect(ui.clip_rect()));
+                    for poly in lines.iter() {
+                        let pts: Vec<egui::Pos2> =
+                            poly.iter().filter(|p| p[0].is_finite() && p[1].is_finite()).map(|p| (o + vec2(p[0], p[1]) * k).to_pos2()).collect();
+                        painter.add(egui::Shape::line(pts, egui::Stroke::new(1.0, t.text_dim)));
+                    }
                 }
-                let mut was_recent = false;
-                for (index, r) in filtered.iter().enumerate() {
-                    if query.is_empty() && was_recent && !r.recent {
-                        ui.separator();
-                    }
-                    was_recent = r.recent;
-                    let row_width = ui.available_width();
-                    let label_width = if preview { (row_width - 100.0).max(40.0) } else { row_width };
-                    let resp = ui.add_sized([row_width, 24.0], egui::Button::selectable(index == state.selected, ""));
-                    resp.widget_info(|| egui::WidgetInfo::selected(egui::Role::Button, ui.is_enabled(), index == state.selected, &r.display));
-                    let label_rect = Rect::from_min_size(resp.rect.min + vec2(5.0, 0.0), vec2(label_width - 5.0, resp.rect.height()));
-                    ui.painter().with_clip_rect(label_rect.intersect(ui.clip_rect())).text(
-                        label_rect.left_center(),
-                        Align2::LEFT_CENTER,
-                        &r.display,
-                        Tokens::ui(12.0),
-                        t.text,
-                    );
-                    if ui.is_rect_visible(resp.rect) {
-                        app.auto.add(&format!("{auto}.option.{}", r.family), resp.rect, &r.display);
-                    }
-                    if index == state.selected && (fresh || up || down) {
-                        resp.scroll_to_me(None);
-                    }
-                    if preview && ui.is_rect_visible(resp.rect) {
-                        let key = egui::Id::unique(("font-preview", &r.family));
-                        let lines: std::sync::Arc<Vec<Vec<[f32; 2]>>> = match ui.data(|d| d.get_temp(key)) {
-                            Some(l) => l,
-                            None => {
-                                let l = std::sync::Arc::new(effectcraft_engine::font_preview(&r.family, 14.0));
-                                ui.data_mut(|d| d.insert_temp(key, l.clone()));
-                                l
-                            }
-                        };
-                        // Scaled and placed to fit the row's preview column, and clipped to the row (#577).
-                        let room = Rect::from_min_max(pos2(resp.rect.max.x - 95.0, resp.rect.min.y + 1.0), pos2(resp.rect.max.x - 6.0, resp.rect.max.y - 1.0));
-                        if let Some((k, o)) = fit_preview(&lines, room, resp.rect.center().y + 5.0) {
-                            let painter = ui.painter().with_clip_rect(resp.rect.intersect(ui.clip_rect()));
-                            for poly in lines.iter() {
-                                let pts: Vec<egui::Pos2> =
-                                    poly.iter().filter(|p| p[0].is_finite() && p[1].is_finite()).map(|p| (o + vec2(p[0], p[1]) * k).to_pos2()).collect();
-                                painter.add(egui::Shape::line(pts, egui::Stroke::new(1.0, t.text_dim)));
-                            }
-                        }
-                    }
-                    if resp.clicked() {
-                        chosen = Some(r.family.clone());
-                    }
-                    resp.on_hover_text(&r.display);
-                }
-            });
-        });
-    });
-    let outside = widgets::pressed_outside(ui.ctx(), &area.response) && !ui.input(|i| i.pointer.interact_pos().is_some_and(|p| rect.contains(p)));
-    if chosen.is_some() || outside || escape {
+            }
+            if resp.clicked() {
+                chosen = Some(r.family.clone());
+            }
+            resp.on_hover_text(name);
+        }
+        chosen
+    };
+    let chosen = menu.show_ui_with_header(header, list).flatten();
+    if chosen.is_some() || !open || escape {
         ui.data_mut(|d| {
             d.insert_temp(id.with("open"), false);
             d.remove::<FontSearch>(state_id);
@@ -886,6 +1061,13 @@ fn align_glyph(p: &egui::Painter, r: Rect, op: &str, distribute: bool, t: &Token
     }
 }
 
+/// The name a font menu row draws: the font's own-language name when the interface fonts have a
+/// glyph for each of its characters, else its English family name. A Simplified Chinese name
+/// such as 微软雅黑 can have characters that the Han face of an English interface lacks.
+fn drawn_font_name<'a>(ctx: &egui::Context, row: &'a effectcraft_engine::FontRow) -> &'a str {
+    if ctx.fonts_mut(|f| f.has_glyphs(&Tokens::ui(12.0), &row.display)) { &row.display } else { &row.family }
+}
+
 /// Where a font's "Sample" outlines (`lines`, baseline at y = 0) go in `room`: `(scale, origin)`,
 /// a point `p` landing at `origin + p * scale`. At their natural size on `baseline` when they fit;
 /// fonts with large or odd metrics are scaled down (never up) and moved inside, so no preview
@@ -944,4 +1126,17 @@ mod tests {
         assert!(fit_preview(&[], room, baseline).is_none());
         assert!(fit_preview(&[vec![[f32::NAN, 1.0]]], room, baseline).is_none());
     }
+
+    /// A font menu row draws the font's own-language name when the interface fonts have its
+    /// glyphs, and the English family name when they do not.
+    #[test]
+    fn font_menu_rows_draw_a_name_the_interface_fonts_have() {
+        let ctx = egui::Context::default();
+        crate::theme::install(&ctx, &Tokens::for_kind(Default::default()), "en");
+        ctx.run_ui(Default::default(), |_| {}).textures_delta.clear();
+        let row = |display: &str| effectcraft_engine::FontRow { family: "Menu Name Test".into(), display: display.into(), recent: false, variable: false };
+        // U+F1234 is in a private use plane that no interface font maps.
+        assert_eq!(drawn_font_name(&ctx, &row("Menu \u{F1234}")), "Menu Name Test");
+        assert_eq!(drawn_font_name(&ctx, &row("Nom du menu")), "Nom du menu");
+    }
 }
diff --git a/crates/ui-egui/src/panels/timeline.rs b/crates/ui-egui/src/panels/timeline.rs
index 238071bda..246084cc1 100644
--- a/crates/ui-egui/src/panels/timeline.rs
+++ b/crates/ui-egui/src/panels/timeline.rs
@@ -15,8 +15,9 @@ use effectcraft_engine::render::EvalCtx;
 use effectcraft_engine::time::Tick;
 use egui::{Align2, Color32, Pos2, Rect, Sense, Stroke, StrokeKind, pos2, vec2};
 use serde_json::json;
+use std::sync::Arc;
 
-use crate::i18n::tr;
+use crate::i18n::{tr, tr_args};
 use crate::icons::{self, Icon};
 use crate::theme::Tokens;
 use crate::{EffectcraftApp, widgets};
@@ -157,35 +158,57 @@ fn with_expr_rows(rows: Vec<Row>, comp: &Comp, tl: &crate::state::TimelineState,
 }
 
 /// A pick-whip drag in progress: (kind, layer, prop uid, start point). The kinds are the
-/// layer's parent pick whip, an expression's and a property's (Parent & Link column).
+/// layer's parent pick whip, an expression's, a property's (Parent & Link column) and the layer's
+/// track matte pick whip.
 type PickWhip = (u8, u64, u64, Pos2);
 const WHIP_PARENT: u8 = 0;
 const WHIP_EXPR: u8 = 1;
 const WHIP_PROP: u8 = 2;
+const WHIP_MATTE: u8 = 3;
 
+/// The `egui::Id` under which a pick-whip drag in progress ([`PickWhip`]) is kept during the
+/// drag.
 fn pick_whip_id() -> egui::Id {
     egui::Id::unique("tl-pickwhip")
 }
 
+/// The layers a layer pick whip (parent, track matte) links, taken as its drag starts.
+fn whip_layers_id() -> egui::Id {
+    egui::Id::unique("tl-pickwhip-layers")
+}
+
+/// The automation id, label and hover hint of a pick whip.
+struct WhipText<'a> {
+    auto: &'a str,
+    label: &'a str,
+    hint: &'a str,
+}
+
 /// A pick whip at `rect`: dragging it starts a pick whip of `kind` from `layer`'s `prop` (0 for
 /// the layer's own), drawn and dropped at the end of [`show`].
-#[allow(clippy::too_many_arguments)]
 fn pick_whip(
     app: &mut EffectcraftApp,
     ui: &egui::Ui,
     p: &egui::Painter,
     rect: Rect,
     (kind, layer, prop): (u8, u64, u64),
-    auto: &str,
-    label: &str,
-    hint: &str,
+    text: WhipText<'_>,
 ) -> egui::Response {
+    let WhipText { auto, label, hint } = text;
     let resp = ui.interact(rect, egui::Id::unique(("pick-whip", kind, layer, prop)), Sense::drag()).on_hover_text(hint);
     icons::paint(p, rect.shrink(1.0), Icon::PickWhip, if resp.hovered() || resp.dragged() { app.tokens.text } else { app.tokens.text_dim });
     app.auto.add(auto, rect, label);
     if resp.drag_started() {
         let state: PickWhip = (kind, layer, prop, rect.center());
-        ui.ctx().data_mut(|d| d.insert_temp(pick_whip_id(), state));
+        let selected = &app.session.state.selected_layers;
+        let layers = match (kind, app.session.active_comp()) {
+            (WHIP_MATTE, Some(comp)) => video_targets(comp, LayerId(layer), selected),
+            _ => edited_layers(LayerId(layer), selected),
+        };
+        ui.ctx().data_mut(|d| {
+            d.insert_temp(pick_whip_id(), state);
+            d.insert_temp(whip_layers_id(), layers);
+        });
     }
     resp
 }
@@ -194,6 +217,8 @@ fn pick_whip(
 /// (row, layer, prop uid, its value fields per dimension), and the pass they were shown in.
 type WhipTargets = (u64, Vec<(Rect, u64, u64, Vec<Rect>)>);
 
+/// The `egui::Id` of the drop targets other panels register for a pick-whip drag
+/// ([`whip_target`]); [`show`] clears it when the whip is released or dropped.
 fn whip_targets_id() -> egui::Id {
     egui::Id::unique("tl-pickwhip-targets")
 }
@@ -263,6 +288,8 @@ fn centered_on(span: f64, duration: f64, cti: f64) -> f64 {
 /// it (characters): the pick whip's reference goes in there.
 type WhipInto = (String, [usize; 2]);
 
+/// The `egui::Id` under which the expression text captured by an expression pick whip
+/// ([`WhipInto`]) is held for property `prop` until that editor is drawn again.
 fn whip_into_id(prop: u64) -> egui::Id {
     egui::Id::unique(("tl-pickwhip-into", prop))
 }
@@ -279,6 +306,8 @@ struct ExprFocus {
     pass: u64,
 }
 
+/// The `egui::Id` of the pending [`ExprFocus`]: which expression editor takes the keyboard on
+/// its next draw, and what to select in it.
 fn expr_focus_id() -> egui::Id {
     egui::Id::unique("tl-expr-focus")
 }
@@ -560,6 +589,8 @@ fn ruler_label(fno: i64, fps_i: i64, settings: &effectcraft_engine::project::Pro
     }
 }
 
+/// The `egui::Id` under which [`show`] records this frame's time mapping as `(x0, start, pps)`,
+/// i.e. the [`TMap`] fields it lays the ruler and graph out with.
 fn tl_map_id() -> egui::Id {
     egui::Id::unique("timeline-map")
 }
@@ -713,6 +744,8 @@ fn group_rename_id() -> egui::Id {
     egui::Id::unique("tl-group-rename")
 }
 
+/// The `egui::Id` of the one-shot flag that makes the open layer rename field take the keyboard
+/// on its first frame (see [`start_rename`]).
 fn rename_focus_id() -> egui::Id {
     egui::Id::unique("tl-rename-focus")
 }
@@ -777,12 +810,11 @@ fn display_name(app: &EffectcraftApp, l: &Layer) -> String {
 /// layer whose names contain `q` (lowercase), each with its enclosing groups. A matching group
 /// brings its whole contents.
 fn search_rows(l: &Layer, q: &str) -> Vec<Row> {
-    /// The row for a group in search results: depth, its effect's enabled flag, and the eye
-    /// switch for layer-style groups (not Blending Options).
+    /// The row for a group in search results: depth, its effect's enabled flag, and its eye
+    /// switch ([`eye_of`]).
     fn group_row(l: &Layer, g: &PropGroup, depth: usize, parent: &PropGroup) -> Row {
         let fx = matches!(g.kind, GroupKind::Effect { .. }).then_some(g.enabled);
-        let eye =
-            (parent.match_id == effectcraft_engine::project::styles::GROUP && g.match_id != effectcraft_engine::project::styles::BLENDING).then_some(g.enabled);
+        let eye = eye_of(parent, g);
         Row { layer: l.id, depth, kind: RowKind::Group { uid: g.uid, name: g.name.clone(), open: true, has_children: !g.children.is_empty(), fx, eye } }
     }
     /// Every visible child of `g` at `depth`, groups recursed into whole — a matching group
@@ -1217,6 +1249,14 @@ fn collect_props(g: &PropGroup, out: &mut Vec<u64>, f: &dyn Fn(&Property) -> boo
 /// in `open`, text animators list their selectors and properties directly (as in AE), and a
 /// shape group's inner Contents (AE's elided `ADBE Vectors Group`) is skipped so its items
 /// list directly under the group.
+/// The eye switch of group `g` inside `parent`, as in After Effects: layer styles (not Blending
+/// Options) and every item in a shape layer's Contents (#959), which the renderer skips when off.
+fn eye_of(parent: &PropGroup, g: &PropGroup) -> Option<bool> {
+    let style = parent.match_id == effectcraft_engine::project::styles::GROUP && g.match_id != effectcraft_engine::project::styles::BLENDING;
+    let shape_item = parent.match_id == "contents" && g.match_id != "transform";
+    (style || shape_item).then_some(g.enabled)
+}
+
 fn push_group(rows: &mut Vec<Row>, l: &Layer, g: &PropGroup, depth: usize, open: &std::collections::BTreeSet<u64>) {
     for c in &g.children {
         match c {
@@ -1232,9 +1272,7 @@ fn push_group(rows: &mut Vec<Row>, l: &Layer, g: &PropGroup, depth: usize, open:
             Node::Group(sg) => {
                 let o = open.contains(&sg.uid);
                 let fx = matches!(sg.kind, GroupKind::Effect { .. }).then_some(sg.enabled);
-                // Layer style groups have eye switches (not Blending Options).
-                let eye = (g.match_id == effectcraft_engine::project::styles::GROUP && sg.match_id != effectcraft_engine::project::styles::BLENDING)
-                    .then_some(sg.enabled);
+                let eye = eye_of(g, sg);
                 rows.push(Row {
                     layer: l.id,
                     depth,
@@ -1275,10 +1313,31 @@ fn layer_icon(l: &Layer, project: &effectcraft_engine::project::Project) -> Icon
 }
 
 /// Layers being dragged to a new place in the stack (timeline rows).
+#[derive(Clone)]
+struct LayerDrag {
+    comp: ItemId,
+    owner: egui::Id,
+    layers: Vec<u64>,
+}
+
 fn layer_drag_id() -> egui::Id {
     egui::Id::unique("tl-layer-drag")
 }
 
+/// An effect, mask, shape item or text animator being dragged to a new place among its
+/// siblings (#2210).
+#[derive(Clone)]
+struct GroupDrag {
+    comp: ItemId,
+    owner: egui::Id,
+    layer: LayerId,
+    uid: u64,
+}
+
+fn group_drag_id() -> egui::Id {
+    egui::Id::unique("tl-group-drag")
+}
+
 /// A keyframe drag in progress: where the pointer started, the grabbed key's comp time
 /// (seconds), how many frames the selected keys have moved so far and, for a Quick Offset
 /// (Ctrl/Cmd+Alt), how many layers it staggers.
@@ -1290,6 +1349,8 @@ struct KeyDrag {
     quick: Option<usize>,
 }
 
+/// The `egui::Id` of the keyframe drag in progress ([`KeyDrag`]): its start, the grabbed key's
+/// time and how far the selection has moved so far.
 fn key_drag_id() -> egui::Id {
     egui::Id::unique("tl-key-drag")
 }
@@ -1304,6 +1365,7 @@ struct QuickBar {
     applied: i64,
 }
 
+/// The `egui::Id` of a Quick Offset drag of layer bars in progress ([`QuickBar`]).
 fn quick_bar_id() -> egui::Id {
     egui::Id::unique("tl-quick-bar")
 }
@@ -1345,6 +1407,8 @@ struct SwitchDrag {
     merge: String,
 }
 
+/// The `egui::Id` of the switch press-and-drag in progress ([`SwitchDrag`]): the switch, the
+/// state the press gave it and the undo step the drag folds into.
 fn switch_drag_id() -> egui::Id {
     egui::Id::unique("tl-switch-drag")
 }
@@ -1365,8 +1429,9 @@ fn switch_gesture(ui: &egui::Ui, resp: &egui::Response, row: Rect, switch: &'sta
     (a.min(b) < row.max.y && a.max(b) >= row.min.y).then_some((d.value, d.merge))
 }
 
-/// The layers an edit made on `layer`'s row applies to (a switch, its label, its blending mode):
-/// the selection when the row is selected, else that layer alone, as in After Effects.
+/// The layers an edit made on `layer`'s row applies to (a switch, its label, its blending mode,
+/// its parent or track matte, moving its bar): the selection when the row is selected, else that
+/// layer alone, as in After Effects (#1260).
 fn edited_layers(layer: LayerId, selected: &[LayerId]) -> Vec<u64> {
     if selected.contains(&layer) { selected.iter().map(|l| l.0).collect() } else { vec![layer.0] }
 }
@@ -1392,18 +1457,16 @@ fn switch_targets(comp: &Comp, project: &Project, selected: &[LayerId], layer: u
     edited_layers(LayerId(layer), selected).into_iter().filter(|l| comp.layer(LayerId(*l)).is_some_and(|l| switch_applies(l, name, project))).collect()
 }
 
-/// The layers a Modes column edit on `layer`'s row (its blending mode, Preserve Transparency)
-/// acts on: [`edited_layers`] that have video.
-fn mode_targets(comp: &Comp, layer: LayerId, selected: &[LayerId]) -> Vec<u64> {
+/// The layers a Modes column edit (blending mode, Preserve Transparency) or a Track Matte edit
+/// on `layer`'s row acts on: [`edited_layers`] that have video. Selected nulls, cameras and
+/// lights (no Modes or Track Matte on their rows) are left out.
+fn video_targets(comp: &Comp, layer: LayerId, selected: &[LayerId]) -> Vec<u64> {
     edited_layers(layer, selected).into_iter().filter(|l| comp.layer(LayerId(*l)).is_some_and(|l| l.source.is_av())).collect()
 }
 
-/// A layer's switch (A/V Features and Switches columns) in `row`, with the
-/// [`switch_gesture`].
-#[allow(clippy::too_many_arguments)]
-fn layer_switch(
-    ui: &mut egui::Ui,
-    t: &Tokens,
+/// Where and what a layer switch is: its cell, icon, state and the switch it sets.
+#[derive(Clone, Copy)]
+struct SwitchSpec {
     row: Rect,
     br: Rect,
     icon: Icon,
@@ -1412,11 +1475,20 @@ fn layer_switch(
     layer: u64,
     name: &'static str,
     others: bool,
+}
+
+/// A layer's switch (A/V Features and Switches columns) in `row`, with the
+/// [`switch_gesture`].
+fn layer_switch(
+    ui: &mut egui::Ui,
+    t: &Tokens,
+    spec: &SwitchSpec,
     comp: &Comp,
     project: &Project,
     selected: &[LayerId],
     actions: &mut Vec<(String, serde_json::Value)>,
 ) {
+    let SwitchSpec { row, br, icon, on, id, layer, name, others } = *spec;
     let resp = widgets::icon_toggle(ui, br, icon, on, t, id, Sense::click_and_drag());
     // Alt-click on an A/V feature sets the layer apart: the other layers go off (or locked),
     // and come back on the next Alt-click. With several layers selected, the whole selection is
@@ -1438,6 +1510,8 @@ fn layer_switch(
     }
 }
 
+/// The `egui::Id` under which composition `comp` remembers the layer the last click selected, so
+/// a following Shift-click can select the range from there ([`shift_range`]).
 fn anchor_id(comp: ItemId) -> egui::Id {
     egui::Id::unique(("timeline-selection-anchor", comp.0))
 }
@@ -1454,15 +1528,15 @@ fn shift_range(ctx: &egui::Context, cid: ItemId, comp: &Comp, rows: &[Row], sele
     let anchor = ctx.data(|d| d.get_temp::<LayerId>(anchor_id(cid))).or_else(|| selected.first().copied())?;
     let a = comp.layers.iter().position(|l| l.id == anchor)?;
     let b = comp.layers.iter().position(|l| l.id == layer)?;
-    let span = comp.layers.get(a.min(b)..=a.max(b))?;
-    Some(span.iter().filter(|l| !l.switches.locked && rows.iter().any(|r| r.layer == l.id)).map(|l| l.id.0).collect())
+    let span = comp.layers.iter().skip(a.min(b)).take(a.max(b) - a.min(b) + 1);
+    Some(span.filter(|l| !l.switches.locked && rows.iter().any(|r| r.layer == l.id)).map(|l| l.id.0).collect())
 }
 
 /// Set on the frame the reorder drag is released.
 /// Where layers dropped at height `py` land among the visible layer rows: above the first row
 /// whose middle is below it (its index in `layer_rows`), else below the last row. Returns that
 /// and the y of the line that shows it (`top` without rows).
-fn insertion(layer_rows: &[(Rect, LayerId)], py: f32, top: f32) -> (Option<usize>, f32) {
+fn insertion<T>(layer_rows: &[(Rect, T)], py: f32, top: f32) -> (Option<usize>, f32) {
     let at = layer_rows.iter().position(|(r, _)| py < r.center().y);
     let y = match at {
         Some(i) => layer_rows.get(i).map_or(top, |(r, _)| r.min.y),
@@ -1471,8 +1545,18 @@ fn insertion(layer_rows: &[(Rect, LayerId)], py: f32, top: f32) -> (Option<usize
     (at, y)
 }
 
-fn layer_drop_id() -> egui::Id {
-    egui::Id::unique("tl-layer-drop")
+/// Resolve a visible insertion boundary through the full outline, including offscreen layers.
+fn layer_drop_target(rows: &[Row], visible: &[(Rect, LayerId)], at: Option<usize>, moving: &[u64]) -> Option<LayerId> {
+    let (anchor, after) = match at {
+        Some(i) => (visible.get(i)?.1, false),
+        None => (visible.last()?.1, true),
+    };
+    rows.iter()
+        .filter(|row| matches!(row.kind, RowKind::Layer))
+        .skip_while(|row| row.layer != anchor)
+        .skip(usize::from(after))
+        .find(|row| !moving.contains(&row.layer.0))
+        .map(|row| row.layer)
 }
 
 /// Whether a Project item can replace a layer's source (the same set `layer.replaceSource`
@@ -1487,7 +1571,7 @@ fn replaceable_item(it: &effectcraft_engine::project::Item) -> bool {
 
 /// The Alt/Option-drag target: the layer under the pointer can take this item as its source, and
 /// the item wouldn't put the composition inside itself.
-fn replace_source_target(app: &EffectcraftApp, cid: ItemId, item: ItemId, lid: LayerId, comp: &Comp) -> bool {
+pub(crate) fn replace_source_target(app: &EffectcraftApp, cid: ItemId, item: ItemId, lid: LayerId, comp: &Comp) -> bool {
     app.session.project.item(item).is_some_and(replaceable_item)
         && !app.session.project.comp_contains(item, cid)
         && comp
@@ -1495,46 +1579,108 @@ fn replace_source_target(app: &EffectcraftApp, cid: ItemId, item: ItemId, lid: L
             .is_some_and(|l| !l.switches.locked && matches!(l.source, LayerSource::Footage { .. } | LayerSource::Comp { .. } | LayerSource::Solid { .. }))
 }
 
-pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+/// The frame's layout and state shared by the Timeline's drawing steps.
+struct Tl {
+    t: Tokens,
+    cid: ItemId,
+    time: Tick,
+    fr: effectcraft_engine::time::FrameRate,
+    rect: Rect,
+    header_h: f32,
+    colhdr_h: f32,
+    footer_h: f32,
+    vis: Vis,
+    left_w: f32,
+    overflow: f32,
+    oscroll: f32,
+    cw: Cols,
+    graph_x0: f32,
+    graph_x1: f32,
+    fit_pps: f64,
+    pps: f64,
+    scroll_to: Option<crate::state::ScrollTo>,
+    tm: TMap,
+    top: f32,
+    rows_rect: Rect,
+    ruler: Rect,
+    bin: Rect,
+    tc_rect: Rect,
+    wa_row: Rect,
+    fd: f64,
+    rh: f32,
+    max_scroll: f32,
+    ctx: egui::Context,
+    comp: Arc<Comp>,
+    p: egui::Painter,
+    rows: Arc<Vec<Row>>,
+    actions: Vec<(String, serde_json::Value)>,
+}
+
+/// [`Tl`] plus what the layer rows and the interactions after them share.
+struct Rw {
+    tl: Tl,
+    lp: egui::Painter,
+    gp: egui::Painter,
+    graph_on: bool,
+    full_clip: Rect,
+    left_clip: Rect,
+    right_clip: Rect,
+    empty_rect: Rect,
+    outline_rect: Rect,
+    empty: egui::Response,
+    outline_empty: egui::Response,
+    selected: Vec<LayerId>,
+    sel_keys: Vec<effectcraft_engine::KeyRef>,
+    ui_actions: Vec<UiAct>,
+    hit_rows: Vec<(Rect, Row)>,
+    dim_hits: Vec<(u64, Vec<Rect>)>,
+}
+
+/// One visible row: what the per-kind drawing steps need to know about it.
+struct RowCtx<'a> {
+    row: &'a Row,
+    layer: &'a Layer,
+    r: Rect,
+    left: Rect,
+    cy: f32,
+    is_sel: bool,
+    ri: usize,
+    indent: f32,
+}
+
+/// The responses of a layer bar's body and its two trim edges.
+struct BarResps {
+    body: egui::Response,
+    lin: egui::Response,
+    lout: egui::Response,
+}
+
+/// An expression row's property, expression and editor ids.
+#[derive(Clone, Copy)]
+struct ExprRow<'a> {
+    prop: &'a Property,
+    ex: &'a effectcraft_engine::project::Expression,
+    buf_id: egui::Id,
+    edit_id: egui::Id,
+}
+
+/// A keyframe marker's hit result.
+struct KeyHit<'a> {
+    k: &'a effectcraft_engine::keyframe::Keyframe,
+    ct: Tick,
+    ks: bool,
+    kresp: egui::Response,
+    mods: egui::Modifiers,
+    this_key: serde_json::Value,
+}
+
+/// Computes this frame's layout: zoom, scroll and the panel's regions.
+fn layout(app: &mut EffectcraftApp, ui: &egui::Ui, rect: Rect, cid: ItemId, comp: &Arc<Comp>) -> Tl {
     let t = app.tokens;
     let ctx = ui.ctx().clone();
-    let Some(cid) = app.session.active_comp_id() else {
-        ui.painter().text(rect.center(), Align2::CENTER_CENTER, "(no composition)", Tokens::ui(12.0), t.text_faint);
-        // Dropping footage into an empty Timeline should create its first composition,
-        // just like dropping onto the Project panel's New Composition button (#649).
-        if let Some(crate::panels::DragPayload::Item(dragged)) = egui::DragAndDrop::payload::<crate::panels::DragPayload>(&ctx).as_deref()
-            && ui.rect_contains_pointer(rect)
-        {
-            let items: Vec<ItemId> = crate::panels::project_drop_items(app, *dragged)
-                .into_iter()
-                .map(ItemId)
-                .filter(|id| {
-                    app.session.project.item(*id).is_some_and(|item| match &item.kind {
-                        effectcraft_engine::project::ItemKind::Footage(footage) => footage.kind != effectcraft_engine::project::FootageKind::Data,
-                        effectcraft_engine::project::ItemKind::Solid(_) | effectcraft_engine::project::ItemKind::Comp(_) => true,
-                        _ => false,
-                    })
-                })
-                .collect();
-            if !items.is_empty() {
-                ui.painter().rect_stroke(rect.shrink(2.0), 0.0, Stroke::new(2.0, t.accent), StrokeKind::Inside);
-                app.auto.add("timeline.newCompDrop", rect, "Drop footage to create a composition");
-                if ctx.input(|i| i.pointer.any_released()) {
-                    app.session.state.project_selection = items;
-                    if let Err(e) = crate::menus::invoke(app, &ctx, "file.newCompFromSelection", json!({})) {
-                        app.ui.status = e;
-                    }
-                    egui::DragAndDrop::clear_payload(&ctx);
-                }
-            }
-        }
-        return;
-    };
-    let Some(comp) = app.session.project.comp_arc(cid) else { return };
     let p = ui.painter().clone();
     let time = app.session.time();
     let fr = comp.frame_rate;
-
     // Geometry.
     let header_h = 48.0;
     let ruler_h = 34.0;
@@ -1552,7 +1698,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let graph_x0 = rect.min.x + left_w + 1.0;
     let graph_x1 = rect.max.x - GUTTER_W;
     ctx.data_mut(|d| d.insert_temp(egui::Id::unique("timeline-graph-area"), (graph_x0, graph_x1 - graph_x0)));
-    let fit_pps = fit_pps(graph_x1 - graph_x0, &comp);
+    let fit_pps = fit_pps(graph_x1 - graph_x0, comp);
     let pps = app.ui.timeline.pps.unwrap_or(fit_pps);
     if app.ui.timeline.pps.is_none() {
         app.ui.timeline.start = 0.0;
@@ -1576,17 +1722,444 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let top = rect.min.y;
     let rows_top = top + header_h + colhdr_h;
     let rows_rect = Rect::from_min_max(pos2(rect.min.x, rows_top), pos2(rect.max.x, rect.max.y - footer_h));
-    let graph_rect = Rect::from_min_max(pos2(graph_x0, top + header_h - ruler_h + colhdr_h), pos2(rect.max.x, rect.max.y - footer_h));
     p.rect_filled(Rect::from_min_max(pos2(graph_x0, top), rect.max), 0.0, t.tl_bg);
     p.line_segment([pos2(graph_x0 - 1.0, top), pos2(graph_x0 - 1.0, rect.max.y)], Stroke::new(1.0, t.app_bg));
 
-    let mut actions: Vec<(String, serde_json::Value)> = Vec::new();
-    if !ui.input(|i| i.pointer.primary_down()) {
-        ctx.data_mut(|d| d.remove::<SwitchDrag>(switch_drag_id()));
-    }
-    // ---- header (left): time display, search, switches.
-    let tc = crate::panels::timecode(&app.session, &comp, time);
+    let ruler = Rect::from_min_max(pos2(graph_x0, top + header_h - ruler_h), pos2(rect.max.x, top + header_h));
+    // The composition marker bin, at the right end of the ruler above the layers' scroll bar.
+    let bin = Rect::from_min_max(pos2(graph_x1 + 2.0, ruler.max.y - 16.0), pos2(rect.max.x - 2.0, ruler.max.y - 2.0));
     let tc_rect = Rect::from_min_size(pos2(rect.min.x + 12.0, top + 6.0), vec2(150.0, 24.0));
+    let wa_row = Rect::from_min_max(pos2(graph_x0, top + header_h), pos2(rect.max.x, top + header_h + colhdr_h));
+    let fd = comp.frame_duration().seconds();
+    Tl {
+        t,
+        cid,
+        time,
+        fr,
+        rect,
+        header_h,
+        colhdr_h,
+        footer_h,
+        vis,
+        left_w,
+        overflow,
+        oscroll,
+        cw,
+        graph_x0,
+        graph_x1,
+        fit_pps,
+        pps,
+        scroll_to,
+        tm,
+        top,
+        rows_rect,
+        ruler,
+        bin,
+        tc_rect,
+        wa_row,
+        fd,
+        rh: t.row_h,
+        max_scroll: 0.0,
+        ctx,
+        comp: comp.clone(),
+        p,
+        rows: Arc::new(Vec::new()),
+        actions: Vec::new(),
+    }
+}
+
+/// Without an active composition: a hint, and dropping footage creates the first composition.
+fn empty_timeline(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let t = app.tokens;
+    let ctx = ui.ctx().clone();
+    ui.painter().text(rect.center(), Align2::CENTER_CENTER, crate::i18n::tr("(no composition)"), Tokens::ui(12.0), t.text_faint);
+    // Dropping footage into an empty Timeline should create its first composition,
+    // just like dropping onto the Project panel's New Composition button (#649).
+    if let Some(crate::panels::DragPayload::Item(dragged)) = egui::DragAndDrop::payload::<crate::panels::DragPayload>(&ctx).as_deref()
+        && ui.rect_contains_pointer(rect)
+    {
+        let items: Vec<ItemId> = crate::panels::project_drop_items(app, *dragged, None)
+            .into_iter()
+            .map(ItemId)
+            .filter(|id| {
+                app.session.project.item(*id).is_some_and(|item| match &item.kind {
+                    effectcraft_engine::project::ItemKind::Footage(footage) => footage.kind != effectcraft_engine::project::FootageKind::Data,
+                    effectcraft_engine::project::ItemKind::Solid(_) | effectcraft_engine::project::ItemKind::Comp(_) => true,
+                    _ => false,
+                })
+            })
+            .collect();
+        if !items.is_empty() {
+            ui.painter().rect_stroke(rect.shrink(2.0), 0.0, Stroke::new(2.0, t.accent), StrokeKind::Inside);
+            app.auto.add("timeline.newCompDrop", rect, "Drop footage to create a composition");
+            if ctx.input(|i| i.pointer.any_released()) {
+                app.session.state.project_selection = items;
+                if let Err(e) = crate::menus::invoke(app, &ctx, "file.newCompFromSelection", json!({})) {
+                    app.ui.status = e;
+                }
+                egui::DragAndDrop::clear_payload(&ctx);
+            }
+        }
+    }
+}
+
+/// Starts the rows pass: the clipped painters and the background responses.
+fn begin_rows(app: &mut EffectcraftApp, ui: &mut egui::Ui, tl: Tl) -> Rw {
+    let rows_rect = tl.rows_rect;
+    let graph_x0 = tl.graph_x0;
+    let rect = tl.rect;
+    let lp = tl.p.with_clip_rect(rows_rect.intersect(Rect::from_min_max(rows_rect.min, pos2(graph_x0 - 1.0, rows_rect.max.y))));
+    let gp = tl.p.with_clip_rect(rows_rect.intersect(Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max)));
+    let graph_on = app.ui.timeline.graph_editor;
+    super::graph::track_open(ui.ctx(), graph_on);
+    let full_clip = ui.clip_rect();
+    let left_clip = full_clip.intersect(Rect::from_min_max(pos2(rect.min.x, rows_rect.min.y), pos2(graph_x0 - 1.0, rows_rect.max.y)));
+    let right_clip = full_clip.intersect(Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max));
+    // Registered before the rows so keys, bars and editors on top of it get the pointer first.
+    let empty_rect = if graph_on { Rect::NOTHING } else { Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max) };
+    let empty = ui.interact(empty_rect, egui::Id::unique("tl-graph-bg"), Sense::click_and_drag());
+    let outline_rect = Rect::from_min_max(rows_rect.min, pos2(graph_x0 - 1.0, rows_rect.max.y));
+    let outline_empty = ui.interact(outline_rect, egui::Id::unique("tl-layer-bg"), Sense::click_and_drag());
+    app.auto.add("timeline.layerMarquee", outline_rect, "Drag empty outline to select layers");
+    Rw {
+        lp,
+        gp,
+        graph_on,
+        full_clip,
+        left_clip,
+        right_clip,
+        empty_rect,
+        outline_rect,
+        empty,
+        outline_empty,
+        selected: app.session.state.selected_layers.clone(),
+        sel_keys: app.session.state.selected_keys.clone(),
+        ui_actions: Vec::new(),
+        hit_rows: Vec::new(),
+        dim_hits: Vec::new(),
+        tl,
+    }
+}
+
+/// The Timeline panel for the active composition inside `rect`: draws the header, ruler, work
+/// area and cache bars, the layer rows with their switch and value cells, the time graph and its
+/// keys, and the footer; and turns this frame's clicks, drags and drops into commands. Without an
+/// active comp it shows a hint, and dropping footage on it creates a composition. Most edits
+/// use [`crate::menus::invoke`]; time, switch and work-area gestures call `Session::execute`
+/// directly and ignore errors. Reported failures go to `app.ui.status`. UI state (scroll, zoom,
+/// open rows and the drags in progress) lives in
+/// `app.ui.timeline` and egui's temp data.
+pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let Some(cid) = app.session.active_comp_id() else {
+        empty_timeline(app, ui, rect);
+        return;
+    };
+    let Some(comp) = app.session.project.comp_arc(cid) else { return };
+    let mut tl = layout(app, ui, rect, cid, &comp);
+    let g = &mut tl;
+    if !ui.input(|i| i.pointer.primary_down()) {
+        g.ctx.data_mut(|d| d.remove::<SwitchDrag>(switch_drag_id()));
+    }
+    header_timecode(app, ui, g);
+    header_search_and_switches(app, ui, g);
+    time_navigator(app, ui, g);
+    ruler_background(app, g);
+    work_area_bar(app, ui, g);
+    cache_bars(app, g);
+    ruler_ticks(app, g);
+    ruler_scrub(app, ui, g);
+    column_header_icons(app, g);
+    column_header_interact(app, ui, g);
+    let rows = Arc::new(with_expr_rows(build_rows(app, &comp), &comp, &app.ui.timeline, &g.ctx));
+    let total_h: f32 = rows.iter().map(|r| row_height(r, g.rh)).sum();
+    g.max_scroll = (total_h - g.rows_rect.height() + g.rh).max(0.0);
+    g.rows = rows;
+    reveal_scroll(app, g);
+    wheel_zoom_scroll(app, ui, g);
+    pick_whip_edge_scroll(app, g);
+    let snap_project = app.session.project.clone();
+    let snap_expr = app.session.expr.clone();
+    let ectx = EvalCtx {
+        project: &snap_project,
+        comp_id: cid,
+        comp: &comp,
+        time: g.time,
+        expr: snap_expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
+    let mut rw = begin_rows(app, ui, tl);
+    let g = &mut rw;
+    draw_rows(app, ui, g, &ectx);
+    ui.set_clip_rect(g.full_clip);
+    background_menus(app, ui, g);
+    outline_marquee(ui, g);
+    pick_whip_drag(g);
+    alt_scale_and_graph(app, ui, g, &ectx);
+    graph_empty_area(ui, g);
+    layer_reorder_drag(ui, g);
+    group_reorder_drag(ui, g);
+    quick_offset_follow(g);
+    key_drag_follow(app, g);
+    key_box_select(app, ui, g);
+    current_time_indicator(app, g);
+    let footer = footer_bar(app, ui, g);
+    footer_zoom(app, ui, g, footer);
+    comp_markers_ui(app, ui, g);
+    hand_tool_pan(app, ui, g);
+    drop_targets(app, ui, g);
+    let Rw { tl, ui_actions, .. } = rw;
+    apply_ui_acts(app, &tl.comp, ui_actions);
+    apply_actions(app, ui, &tl.ctx, tl.actions);
+}
+
+/// Applies the UI-only changes the frame collected (twirls, time, ending an undo merge).
+fn apply_ui_acts(app: &mut EffectcraftApp, comp: &Comp, ui_actions: Vec<UiAct>) {
+    for a in ui_actions {
+        match a {
+            UiAct::ToggleLayer(id, all) => {
+                let tl = &mut app.ui.timeline;
+                // Twirled by hand, the layer shows its whole tree again.
+                tl.reveal.clear();
+                tl.layer_reveal.remove(&id);
+                tl.full_groups.remove(&id);
+                let open = !tl.open_layers.contains(&id);
+                if open {
+                    tl.open_layers.insert(id);
+                } else {
+                    tl.open_layers.remove(&id);
+                }
+                if all && let Some(l) = comp.layer(LayerId(id)) {
+                    let mut uids = vec![];
+                    walk_groups(&l.props, &mut uids);
+                    for u in uids {
+                        if open {
+                            tl.open_groups.insert(u);
+                        } else {
+                            tl.open_groups.remove(&u);
+                        }
+                    }
+                }
+            }
+            UiAct::ToggleGroup(layer, uid, all) => {
+                let tl = &mut app.ui.timeline;
+                tl.toggle_group(layer, uid);
+                let open = tl.open_groups.contains(&uid);
+                if all && let Some(g) = comp.layer(LayerId(layer)).and_then(|l| find_group(&l.props, uid)) {
+                    let mut uids = vec![];
+                    walk_groups(g, &mut uids);
+                    for u in uids {
+                        if open {
+                            tl.open_groups.insert(u);
+                        } else {
+                            tl.open_groups.remove(&u);
+                        }
+                    }
+                }
+            }
+            UiAct::SetTime(tt) => app.session.set_time(tt),
+            UiAct::EndMerge => app.session.history.merge_key = None,
+            UiAct::ChangeRenderer => {
+                if super::dialogs::open_comp_settings(app).is_ok() {
+                    app.dialog_state.comp.tab = super::comp_settings::Tab::Renderer;
+                }
+            }
+        }
+    }
+}
+
+/// Runs the commands the frame collected through [`crate::menus::invoke`].
+fn apply_actions(app: &mut EffectcraftApp, ui: &mut egui::Ui, ctx: &egui::Context, actions: Vec<(String, serde_json::Value)>) {
+    if ui.input(|i| i.pointer.primary_down()) && actions.iter().any(|(id, _)| id == "prop.set") {
+        app.ui.viewer.property_interacting = true;
+        ctx.request_repaint();
+    }
+    for (id, params) in actions {
+        if id == "__endMerge" {
+            app.session.history.merge_key = None;
+            continue;
+        }
+        if let Err(e) = crate::menus::invoke(app, ctx, &id, params) {
+            app.ui.status = e;
+        }
+    }
+}
+
+/// Draws the visible rows, top to bottom, each by its kind.
+fn draw_rows(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, ectx: &EvalCtx<'_>) {
+    let comp = g.tl.comp.clone();
+    let rows = g.tl.rows.clone();
+    let (rect, rows_rect, rh, cw_name) = (g.tl.rect, g.tl.rows_rect, g.tl.rh, g.tl.cw.name);
+    let mut y = rows_rect.min.y - app.ui.timeline.scroll_y;
+    // Rows stripe by their index among the rows that are not expression editors, so adding or
+    // removing an expression leaves every other row's stripe alone; an editor takes the index
+    // (and so the stripe) of its property's row, the one just above.
+    let mut striped = 0usize;
+    for row in rows.iter() {
+        let ri = if matches!(row.kind, RowKind::Expr { .. }) {
+            striped.saturating_sub(1)
+        } else {
+            striped += 1;
+            striped - 1
+        };
+        // Outline widgets never spill into the time graph (narrow timelines).
+        ui.set_clip_rect(g.left_clip);
+        let hh = row_height(row, rh);
+        let r = Rect::from_min_size(pos2(rect.min.x, y), vec2(rect.width(), hh));
+        y += hh;
+        if r.max.y < rows_rect.min.y || r.min.y > rows_rect.max.y {
+            continue;
+        }
+        g.hit_rows.push((r, row.clone()));
+        let Some(layer) = comp.layer(row.layer) else { continue };
+        let rc = RowCtx {
+            row,
+            layer,
+            r,
+            left: Rect::from_min_max(r.min, pos2(g.tl.graph_x0 - 1.0, r.max.y)),
+            cy: r.min.y + rh / 2.0,
+            is_sel: g.selected.contains(&layer.id),
+            ri,
+            indent: cw_name + 6.0 + 14.0 * row.depth as f32,
+        };
+        match &row.kind {
+            RowKind::Layer => layer_row(app, ui, g, &rc),
+            RowKind::Group { .. } => group_row(app, ui, g, &rc),
+            RowKind::Waveform { .. } => waveform_row(app, g, &rc),
+            RowKind::Expr { .. } => expr_row(app, ui, g, &rc),
+            RowKind::Prop { .. } => prop_row(app, ui, g, &rc, ectx),
+        }
+    }
+}
+
+/// A layer row: switches, label, name, cells and the layer bar.
+fn layer_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    layer_row_background(g, rc);
+    layer_av_switches(app, ui, g, rc);
+    layer_label_swatch(app, ui, g, rc);
+    layer_number_and_cells(app, ui, g, rc);
+    let (row_resp, name_x) = layer_twirl_and_icon(app, ui, g, rc);
+    layer_name(app, ui, g, rc, name_x);
+    layer_row_actions(app, ui, g, rc, &row_resp);
+    layer_switches(app, ui, g, rc);
+    if app.ui.timeline.show_modes && rc.layer.source.is_av() {
+        layer_mode_cell(app, ui, g, rc);
+        layer_matte_cell(app, ui, g, rc);
+    }
+    if g.tl.vis.parent {
+        layer_parent_cell(app, ui, g, rc);
+    }
+    ui.set_clip_rect(g.right_clip);
+    if !g.graph_on {
+        layer_bar(app, ui, g, rc);
+    }
+}
+
+/// The layer's duration bar: source extent, move and trim, markers.
+fn layer_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let (bar, lc) = layer_bar_paint(g, rc);
+    layer_source_extent(app, ui, g, rc, bar, lc);
+    let bars = layer_bar_hits(app, ui, g, rc, bar);
+    let quick = layer_quick_offset_begin(ui, g, rc, &bars.body);
+    layer_bar_drag(g, rc, &bars, quick);
+    layer_bar_markers(app, ui, g, rc);
+}
+
+/// A group row (effect, mask, shape group, layer style).
+fn group_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let shown = group_background(app, g, rc);
+    group_switches(app, ui, g, rc);
+    group_name(app, ui, g, rc, &shown);
+    group_popups(app, ui, g, rc);
+    group_mask_mode(ui, g, rc);
+    group_row_click(app, ui, g, rc);
+}
+
+/// An expression row: its controls and the editor.
+fn expr_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let RowKind::Expr { uid, .. } = &rc.row.kind else { return };
+    let Some(prop) = rc.layer.props.find(*uid) else { return };
+    let Some(ex) = prop.expr.as_ref() else { return };
+    let st = ExprRow { prop, ex, buf_id: expr_buf_id(*uid), edit_id: egui::Id::unique(("expr-edit", uid)) };
+    expr_controls(app, ui, g, rc, &st);
+    expr_language_menu(app, ui, g, rc, &st);
+    expr_editor_cell(app, ui, g, rc, &st);
+}
+
+/// A property row: keyframe navigator, stopwatch, name, value editors and the keyframes.
+fn prop_row(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, ectx: &EvalCtx<'_>) {
+    let RowKind::Prop { uid } = &rc.row.kind else { return };
+    let Some(prop) = rc.layer.props.find(*uid) else { return };
+    prop_background(app, g, rc, prop);
+    prop_key_navigator(app, ui, g, rc, prop);
+    prop_stopwatch(app, ui, g, rc, prop);
+    let name_x = prop_name(app, ui, g, rc, prop);
+    prop_value_cell(app, ui, g, rc, ectx, prop, name_x);
+    prop_expression_hint(app, ui, g, rc, prop);
+    if !g.graph_on {
+        for k in &prop.keys {
+            key_marker(app, ui, g, rc, prop, k);
+        }
+    }
+}
+
+/// One keyframe marker: its look, selection, menu and drag.
+fn key_marker(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, prop: &Property, k: &effectcraft_engine::keyframe::Keyframe) {
+    let RowKind::Prop { uid } = &rc.row.kind else { return };
+    let ct = rc.layer.comp_time(k.time);
+    let x = g.tl.tm.x(ct.seconds());
+    if x < g.tl.graph_x0 - 8.0 || x > g.tl.rect.max.x + 8.0 {
+        return;
+    }
+    let kref = effectcraft_engine::KeyRef { layer: rc.layer.id, prop: *uid, time: k.time };
+    let ks = g.sel_keys.contains(&kref);
+    let kr = key_paint(g, rc, k, x, ks);
+    let kresp = key_hit(app, ui, g, rc, prop, k, kr);
+    let mods = ui.input(|i| i.modifiers);
+    let this_key = json!({"keys": [{"layer": rc.layer.id.0, "prop": uid, "time": k.time.seconds()}], "selectProperties": true});
+    let kh = KeyHit { k, ct, ks, kresp, mods, this_key };
+    key_select(g, &kh);
+    key_double_click(g, rc, prop, &kh);
+    key_context_menu(app, g, rc, prop, &kh);
+    key_drag_begin(app, g, &kh);
+}
+
+/// Drop targets: effects and presets on a layer, footage and files into the stack.
+fn drop_targets(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw) {
+    let ctx = g.tl.ctx.clone();
+    let rows_rect = g.tl.rows_rect;
+    if let Some(payload) = egui::DragAndDrop::payload::<crate::panels::DragPayload>(&ctx)
+        && !matches!(*payload, crate::panels::DragPayload::Property { .. })
+        && let Some(ptr) = ctx.input(|i| i.pointer.hover_pos()).filter(|_| ui.rect_contains_pointer(rows_rect))
+    {
+        let released = ctx.input(|i| i.pointer.any_released());
+        // Alt/Option-drag from the Project panel replaces the source of the layer under the
+        // pointer (After Effects). The shortcut replaces every selected layer instead.
+        let alt_item = ctx.input(|i| i.modifiers.alt) && matches!(payload.as_ref(), crate::panels::DragPayload::Item(_));
+        if alt_item {
+            drop_replace_source(app, g, &payload, ptr, released);
+        } else if matches!(payload.as_ref(), crate::panels::DragPayload::Effect(_) | crate::panels::DragPayload::Preset { .. }) {
+            drop_on_layer(app, g, &payload, ptr, released);
+        } else {
+            drop_insert_layers(app, g, &payload, ptr, released);
+        }
+        if released {
+            egui::DragAndDrop::clear_payload(&ctx);
+        }
+    }
+}
+
+/// The header's time display: click to switch style, drag to scrub, double-click to type a time.
+fn header_timecode(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Tl) {
+    let t = g.t;
+    let time = g.time;
+    let fr = g.fr;
+    let tc_rect = g.tc_rect;
+    let ctx = g.ctx.clone();
+    let comp = g.comp.clone();
+    let p = g.p.clone();
+    let tc = crate::panels::timecode(&app.session, &comp, time);
     let tc_resp = ui.interact(tc_rect, egui::Id::unique("tl-timecode"), Sense::click_and_drag());
     p.text(tc_rect.left_center(), Align2::LEFT_CENTER, &tc, Tokens::semibold(16.0), t.timecode);
     // Under it the other style (frames under timecode, timecode under frames) and the rate.
@@ -1628,9 +2201,19 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             ctx.data_mut(|d| d.insert_temp(egui::Id::unique("tl-tc-edit"), buf));
         }
     }
+}
+
+/// The header's search field and the composition switches.
+fn header_search_and_switches(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Tl) {
+    let t = g.t;
+    let rect = g.rect;
+    let left_w = g.left_w;
+    let top = g.top;
+    let tc_rect = g.tc_rect;
+    let comp = g.comp.clone();
     let sr = Rect::from_min_size(pos2(tc_rect.max.x + 14.0, top + 12.0), vec2((left_w - 420.0).clamp(120.0, 220.0), 22.0));
     let mut search = app.ui.timeline.search.clone();
-    widgets::search_field(ui, sr, &mut search, "Search", &t);
+    widgets::search_field(ui, sr, &mut search, crate::i18n::tr("Search"), &t);
     app.ui.timeline.search = search;
     app.auto.add("timeline.search", sr, "Search");
     let mut bx = rect.min.x + left_w - 10.0;
@@ -1656,11 +2239,20 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
         bx -= 28.0;
     }
+}
 
-    // ---- ruler (right).
-    let ruler = Rect::from_min_max(pos2(graph_x0, top + header_h - ruler_h), pos2(rect.max.x, top + header_h));
-    // The composition marker bin, at the right end of the ruler above the layers' scroll bar.
-    let bin = Rect::from_min_max(pos2(graph_x1 + 2.0, ruler.max.y - 16.0), pos2(rect.max.x - 2.0, ruler.max.y - 2.0));
+/// The time navigator: the visible span as a bar with end handles.
+fn time_navigator(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Tl) {
+    let t = g.t;
+    let graph_x0 = g.graph_x0;
+    let graph_x1 = g.graph_x1;
+    let fit_pps = g.fit_pps;
+    let pps = g.pps;
+    let tm = g.tm;
+    let top = g.top;
+    let ctx = g.ctx.clone();
+    let comp = g.comp.clone();
+    let p = g.p.clone();
     let nav = Rect::from_min_max(pos2(graph_x0 + 6.0, top + 6.0), pos2(graph_x1, top + 14.0));
     // Time navigator: the visible span as a grey bar with blue end handles (as in After
     // Effects), over a dark track.
@@ -1701,12 +2293,31 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             set_zoom(&mut app.ui.timeline, &comp, span_px / span.max(min_span), fit_pps, keep_t, keep_px);
         }
     }
+}
+
+fn ruler_background(app: &mut EffectcraftApp, g: &Tl) {
+    let t = g.t;
+    let tm = g.tm;
+    let ruler = g.ruler;
+    let p = g.p.clone();
     p.rect_filled(ruler, 0.0, t.tl_ruler_bg);
     app.auto.add("timeline.ruler", ruler, &format!("{},{}", tm.start, tm.pps));
+}
+
+/// The work area bar beside the column headers, with its begin / end handles.
+fn work_area_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Tl) {
+    let t = g.t;
+    let fr = g.fr;
+    let pps = g.pps;
+    let tm = g.tm;
+    let wa_row = g.wa_row;
+    let ctx = g.ctx.clone();
+    let comp = g.comp.clone();
+    let p = g.p.clone();
+    let actions = &mut g.actions;
     // Work area bar: below the ruler, beside the column headers (After Effects' layout), with
     // blue begin / end handles; the cache bar runs under it. Dragging the bar moves the work
     // area, the handles move its ends; Shift snaps (#252).
-    let wa_row = Rect::from_min_max(pos2(graph_x0, top + header_h), pos2(rect.max.x, top + header_h + colhdr_h));
     let (wa0, wa1) = (comp.work_area.0.seconds(), comp.work_area.1.seconds());
     let wa = Rect::from_min_max(pos2(tm.x(wa0), wa_row.min.y + 3.0), pos2(tm.x(wa1), wa_row.max.y - 6.0));
     p.with_clip_rect(wa_row).rect_filled(wa, 0.0, t.tl_work_area_bar);
@@ -1747,6 +2358,9 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         p.rect_filled(handle, 2.0, t.accent);
         let resp = ui.interact(hr, egui::Id::unique(("wa", set)), Sense::drag());
         app.auto.add(&format!("timeline.workArea.{set}"), hr, set);
+        if resp.dragged() || resp.hovered() {
+            ctx.set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
+        }
         if resp.dragged()
             && let Some(pt) = resp.interact_pointer_pos()
         {
@@ -1759,10 +2373,20 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             let _ = app.session.execute("comp.workArea", json!({key: secs, "merge": "wa-drag"}));
         }
     }
+}
+
+/// The RAM (green) and disk (blue) cache bars under the work area.
+fn cache_bars(app: &mut EffectcraftApp, g: &Tl) {
+    let t = g.t;
+    let cid = g.cid;
+    let tm = g.tm;
+    let wa_row = g.wa_row;
+    let fd = g.fd;
+    let comp = g.comp.clone();
+    let p = g.p.clone();
     // Cache bar (green: cached frames of what the viewer shows: its resolution, view and options).
     let series = app.shown_series(cid);
     let cached = app.frames.cached_frames(&series);
-    let fd = comp.frame_duration().seconds();
     let cy0 = wa_row.max.y - 4.0;
     let mut run: Option<(i64, i64)> = None;
     let draw_run = |a: i64, b: i64| {
@@ -1811,6 +2435,20 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             draw_blue(a, b);
         }
     }
+}
+
+/// The ruler's tick marks and labels.
+fn ruler_ticks(app: &mut EffectcraftApp, g: &Tl) {
+    let t = g.t;
+    let fr = g.fr;
+    let graph_x0 = g.graph_x0;
+    let graph_x1 = g.graph_x1;
+    let pps = g.pps;
+    let tm = g.tm;
+    let ruler = g.ruler;
+    let bin = g.bin;
+    let fd = g.fd;
+    let p = g.p.clone();
     // Ticks + labels.
     // Label spacing in whole frames (AE: `00:15f`-style seconds:frames labels).
     let fps_i = fr.as_f64().round().max(1.0) as i64;
@@ -1839,6 +2477,17 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
         s += secs_per_label;
     }
+}
+
+/// Scrubbing in the ruler: the current time follows the pointer.
+fn ruler_scrub(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Tl) {
+    let graph_x0 = g.graph_x0;
+    let graph_x1 = g.graph_x1;
+    let pps = g.pps;
+    let tm = g.tm;
+    let ruler = g.ruler;
+    let bin = g.bin;
+    let comp = g.comp.clone();
     // Scrub in the ruler: the current time jumps to the pointer as soon as the button goes down
     // (After Effects), then follows it.
     let rresp = ui.interact(
@@ -1897,8 +2546,19 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             app.scrub_audio(cid, t, now);
         }
     }
+}
 
-    // ---- column headers (right-click: show/hide columns; click the name header: Source/Layer Name).
+/// The column headers' background, icons and titles.
+fn column_header_icons(app: &mut EffectcraftApp, g: &Tl) {
+    let t = g.t;
+    let rect = g.rect;
+    let header_h = g.header_h;
+    let colhdr_h = g.colhdr_h;
+    let vis = g.vis;
+    let graph_x0 = g.graph_x0;
+    let top = g.top;
+    let p = g.p.clone();
+    let cw = &g.cw;
     let ch = Rect::from_min_max(pos2(rect.min.x, top + header_h), pos2(rect.max.x, top + header_h + colhdr_h));
     p.rect_filled(Rect::from_min_max(ch.min, pos2(graph_x0 - 1.0, ch.max.y)), 0.0, t.panel_bg);
     p.line_segment([pos2(rect.min.x, ch.max.y), pos2(rect.max.x, ch.max.y)], Stroke::new(1.0, t.separator));
@@ -1948,6 +2608,20 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             htext(x + 6.0, s);
         }
     }
+}
+
+/// Column header clicks, automation ids and the right-click column menu.
+fn column_header_interact(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Tl) {
+    let rect = g.rect;
+    let header_h = g.header_h;
+    let colhdr_h = g.colhdr_h;
+    let vis = g.vis;
+    let graph_x0 = g.graph_x0;
+    let top = g.top;
+    let ctx = g.ctx.clone();
+    let cw = &g.cw;
+    let actions = &mut g.actions;
+    let ch = Rect::from_min_max(pos2(rect.min.x, top + header_h), pos2(rect.max.x, top + header_h + colhdr_h));
     let hdr_rect = Rect::from_min_max(ch.min, pos2(graph_x0 - 1.0, ch.max.y));
     let hresp = ui.interact(hdr_rect, egui::Id::unique("tl-colhdr"), Sense::click());
     app.auto.add("timeline.header", hdr_rect, "Columns (right-click)");
@@ -1972,12 +2646,12 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     if hresp.clicked()
         && let Some(pt) = hresp.interact_pointer_pos()
-        && column_at(&cw, pt.x) == Some("name")
+        && column_at(cw, pt.x) == Some("name")
     {
         app.ui.timeline.source_name = !app.ui.timeline.source_name;
     }
     if hresp.secondary_clicked() {
-        let under = hresp.interact_pointer_pos().and_then(|pt| column_at(&cw, pt.x));
+        let under = hresp.interact_pointer_pos().and_then(|pt| column_at(cw, pt.x));
         ctx.data_mut(|d| d.insert_temp(egui::Id::unique("tl-colhdr-under"), under.unwrap_or("")));
     }
     crate::widgets::context_menu(&hresp, |ui| {
@@ -2002,12 +2676,16 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
     });
     let _ = cw.end;
+}
 
-    // ---- rows.
-    let rows = with_expr_rows(build_rows(app, &comp), &comp, &app.ui.timeline, &ctx);
-    let rh = t.row_h;
-    let total_h: f32 = rows.iter().map(|r| row_height(r, rh)).sum();
-    let max_scroll = (total_h - rows_rect.height() + rh).max(0.0);
+/// Scrolls an expression editor or the requested layer / property into view.
+fn reveal_scroll(app: &mut EffectcraftApp, g: &Tl) {
+    let scroll_to = g.scroll_to;
+    let rows_rect = g.rows_rect;
+    let rh = g.rh;
+    let ctx = g.ctx.clone();
+    let comp = g.comp.clone();
+    let rows = &g.rows;
     // An expression editor asked to take the keyboard comes into view; a request whose
     // expression didn't appear, or that wasn't taken within a few passes, is dropped (it never
     // takes the keyboard later).
@@ -2033,6 +2711,18 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     {
         app.ui.timeline.scroll_y = rows.iter().take(i).map(|r| row_height(r, rh)).sum();
     }
+}
+
+/// Mouse wheel and pinch over the rows: zoom time or scroll.
+fn wheel_zoom_scroll(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Tl) {
+    let overflow = g.overflow;
+    let graph_x0 = g.graph_x0;
+    let fit_pps = g.fit_pps;
+    let pps = g.pps;
+    let tm = g.tm;
+    let rows_rect = g.rows_rect;
+    let max_scroll = g.max_scroll;
+    let comp = g.comp.clone();
     if ui.rect_contains_pointer(rows_rect) {
         let (dy, dx, zoom) = ui.input(|i| (i.smooth_scroll_delta.y, i.smooth_scroll_delta.x, i.modifiers.alt));
         // Ctrl/Cmd+wheel and a trackpad pinch reach egui as a zoom factor rather than a scroll
@@ -2058,6 +2748,15 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         }
     }
+}
+
+/// A held pick whip near the top or bottom scrolls the rows.
+fn pick_whip_edge_scroll(app: &mut EffectcraftApp, g: &Tl) {
+    let rect = g.rect;
+    let rows_rect = g.rows_rect;
+    let rh = g.rh;
+    let max_scroll = g.max_scroll;
+    let ctx = g.ctx.clone();
     // A pick whip held near the top or bottom of the layers (or past it) scrolls them, as in
     // After Effects.
     if ctx.data(|d| d.get_temp::<PickWhip>(pick_whip_id())).is_some()
@@ -2070,1095 +2769,1508 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
     }
     app.ui.timeline.scroll_y = app.ui.timeline.scroll_y.clamp(0.0, max_scroll);
-    let snap_project = app.session.project.clone();
-    let snap_expr = app.session.expr.clone();
-    let ectx = EvalCtx { project: &snap_project, comp_id: cid, comp: &comp, time, expr: snap_expr.as_deref(), footage: None };
-    let lp = p.with_clip_rect(rows_rect.intersect(Rect::from_min_max(rows_rect.min, pos2(graph_x0 - 1.0, rows_rect.max.y))));
-    let gp = p.with_clip_rect(rows_rect.intersect(Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max)));
-    let mut y = rows_rect.min.y - app.ui.timeline.scroll_y;
-    let selected = app.session.state.selected_layers.clone();
-    let sel_keys = app.session.state.selected_keys.clone();
-    let mut ui_actions: Vec<UiAct> = Vec::new();
-    let idx_of = |id: LayerId| comp.index_of(id).unwrap_or(0);
-    let graph_on = app.ui.timeline.graph_editor;
-    super::graph::track_open(ui.ctx(), graph_on);
-    let full_clip = ui.clip_rect();
-    let left_clip = full_clip.intersect(Rect::from_min_max(pos2(rect.min.x, rows_rect.min.y), pos2(graph_x0 - 1.0, rows_rect.max.y)));
-    let right_clip = full_clip.intersect(Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max));
-    // Registered before the rows so keys, bars and editors on top of it get the pointer first.
-    let empty_rect = if graph_on { Rect::NOTHING } else { Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max) };
-    let empty = ui.interact(empty_rect, egui::Id::unique("tl-graph-bg"), Sense::click_and_drag());
-    let outline_rect = Rect::from_min_max(rows_rect.min, pos2(graph_x0 - 1.0, rows_rect.max.y));
-    let outline_empty = ui.interact(outline_rect, egui::Id::unique("tl-layer-bg"), Sense::click_and_drag());
-    app.auto.add("timeline.layerMarquee", outline_rect, "Drag empty outline to select layers");
-    let mut hit_rows: Vec<(Rect, Row)> = vec![];
-    // The value fields of multi-dimension properties (per dimension), for the pick whip.
-    let mut dim_hits: Vec<(u64, Vec<Rect>)> = vec![];
-    // Rows stripe by their index among the rows that are not expression editors, so adding or
-    // removing an expression leaves every other row's stripe alone; an editor takes the index
-    // (and so the stripe) of its property's row, the one just above.
-    let mut striped = 0usize;
-    for row in rows.iter() {
-        let ri = if matches!(row.kind, RowKind::Expr { .. }) {
-            striped.saturating_sub(1)
-        } else {
-            striped += 1;
-            striped - 1
-        };
-        // Outline widgets never spill into the time graph (narrow timelines).
-        ui.set_clip_rect(left_clip);
-        let hh = row_height(row, rh);
-        let r = Rect::from_min_size(pos2(rect.min.x, y), vec2(rect.width(), hh));
-        y += hh;
-        if r.max.y < rows_rect.min.y || r.min.y > rows_rect.max.y {
+}
+
+fn layer_row_background(g: &Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let rect = g.tl.rect;
+    let graph_x0 = g.tl.graph_x0;
+    let lp = g.lp.clone();
+    let gp = g.gp.clone();
+    let r = rc.r;
+    let left = rc.left;
+    let is_sel = rc.is_sel;
+    lp.rect_filled(left, 0.0, if is_sel { t.row_selected } else { t.row_alt });
+    gp.rect_filled(Rect::from_min_max(pos2(graph_x0, r.min.y), r.max), 0.0, if is_sel { t.tl_graph_selected } else { t.tl_bg });
+    lp.line_segment([pos2(rect.min.x, r.max.y - 0.5), pos2(graph_x0, r.max.y - 0.5)], Stroke::new(1.0, t.app_bg));
+    gp.line_segment([pos2(graph_x0, r.max.y - 0.5), pos2(r.max.x, r.max.y - 0.5)], Stroke::new(1.0, t.app_bg));
+}
+
+/// The A/V feature switches (video, audio, solo, lock).
+fn layer_av_switches(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let vis = g.tl.vis;
+    let comp = g.tl.comp.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let selected = &g.selected;
+    let layer = rc.layer;
+    let r = rc.r;
+    let cy = rc.cy;
+    let sw = &layer.switches;
+    // Every layer has the Video switch (the eye), nulls, cameras and lights included,
+    // as in After Effects: it hides a null's outline in the viewer and turns a camera or
+    // light off.
+    let av_items: [(Icon, bool, &str, bool); 4] = [
+        (Icon::Eye, sw.video, "video", switch_applies(layer, "video", &app.session.project)),
+        (Icon::Speaker, sw.audio, "audio", switch_applies(layer, "audio", &app.session.project)),
+        (Icon::Solo, sw.solo, "solo", switch_applies(layer, "solo", &app.session.project)),
+        (Icon::Lock, sw.locked, "lock", switch_applies(layer, "lock", &app.session.project)),
+    ];
+    for (i, (icon, on, name, applicable)) in av_items.into_iter().enumerate() {
+        let br = Rect::from_center_size(pos2(cw.av + 10.0 + 18.0 * i as f32, cy), vec2(15.0, 15.0));
+        if !applicable || !vis.av {
             continue;
         }
-        hit_rows.push((r, row.clone()));
-        let Some(layer) = comp.layer(row.layer) else { continue };
-        let is_sel = selected.contains(&layer.id);
-        let left = Rect::from_min_max(r.min, pos2(graph_x0 - 1.0, r.max.y));
-        let cy = r.min.y + rh / 2.0;
-        match &row.kind {
-            RowKind::Layer => {
-                // After Effects draws layer rows as one flat tone separated by dark hairlines
-                // (outline and time graph alike), not as alternating stripes.
-                let _ = ri;
-                lp.rect_filled(left, 0.0, if is_sel { t.row_selected } else { t.row_alt });
-                gp.rect_filled(Rect::from_min_max(pos2(graph_x0, r.min.y), r.max), 0.0, if is_sel { t.tl_graph_selected } else { t.tl_bg });
-                lp.line_segment([pos2(rect.min.x, r.max.y - 0.5), pos2(graph_x0, r.max.y - 0.5)], Stroke::new(1.0, t.app_bg));
-                gp.line_segment([pos2(graph_x0, r.max.y - 0.5), pos2(r.max.x, r.max.y - 0.5)], Stroke::new(1.0, t.app_bg));
-                // A/V features.
-                let sw = &layer.switches;
-                // Every layer has the Video switch (the eye), nulls, cameras and lights included,
-                // as in After Effects: it hides a null's outline in the viewer and turns a camera or
-                // light off.
-                let av_items: [(Icon, bool, &str, bool); 4] = [
-                    (Icon::Eye, sw.video, "video", switch_applies(layer, "video", &app.session.project)),
-                    (Icon::Speaker, sw.audio, "audio", switch_applies(layer, "audio", &app.session.project)),
-                    (Icon::Solo, sw.solo, "solo", switch_applies(layer, "solo", &app.session.project)),
-                    (Icon::Lock, sw.locked, "lock", switch_applies(layer, "lock", &app.session.project)),
-                ];
-                for (i, (icon, on, name, applicable)) in av_items.into_iter().enumerate() {
-                    let br = Rect::from_center_size(pos2(cw.av + 10.0 + 18.0 * i as f32, cy), vec2(15.0, 15.0));
-                    if !applicable || !vis.av {
-                        continue;
-                    }
-                    lp.rect_filled(br.shrink(0.5), 1.0, t.switch_well);
-                    layer_switch(
-                        ui,
-                        &t,
-                        r,
-                        br,
-                        icon,
-                        on,
-                        egui::Id::unique(("av", layer.id.0, i)),
-                        layer.id.0,
-                        name,
-                        true,
-                        &comp,
-                        &app.session.project,
-                        &selected,
-                        &mut actions,
-                    );
-                    app.auto.add(&format!("timeline.layer.{}.{name}", layer.id.0), br, name);
-                }
-                // Label swatch.
-                if vis.label {
-                    let lr = Rect::from_center_size(pos2(cw.label + 10.0, cy), vec2(12.0, 12.0));
-                    lp.rect_filled(lr, 2.0, t.label(layer.label));
-                    let lresp = ui.interact(lr, egui::Id::unique(("label", layer.id.0)), Sense::click());
-                    app.auto.add(&format!("timeline.layer.{}.label", layer.id.0), lr, layer.label.name());
-                    // Click (or right-click) the swatch for the label menu (After Effects).
-                    let pop = egui::Id::unique(("label-pop", layer.id.0));
-                    if lresp.clicked() || lresp.secondary_clicked() {
-                        widgets::open_popup(ui, pop);
-                    }
-                    if let Some(lab) = widgets::label_popup(ui, pop, lr.left_bottom(), layer.label, |l| app.session.prefs.label_name(l), &t) {
-                        actions.push(("edit.label".into(), json!({"layers": edited_layers(layer.id, &selected), "label": lab.name()})));
-                    }
-                }
-                if vis.num {
-                    lp.text(pos2(cw.num + 13.0, cy), Align2::CENTER_CENTER, format!("{}", idx_of(layer.id)), Tokens::ui(11.5), t.text_dim);
-                }
-                layer_cells(app, ui, &lp, &cw, &comp, layer, r, cy, &mut actions);
-                // Row click → select; double-click → rename; drag → reorder. Registered before the
-                // twirl and the name field so those sit on top and get their clicks.
-                let row_x0 = if vis.num { cw.num } else { cw.name + 16.0 };
-                let row_resp = ui.interact(
-                    Rect::from_min_max(pos2(row_x0, r.min.y), pos2(cw.name_end, r.max.y)),
-                    egui::Id::unique(("row", layer.id.0)),
-                    Sense::click_and_drag(),
-                );
-                // Twirl + icon + name.
-                let tw = Rect::from_center_size(pos2(cw.name + 8.0, cy), vec2(14.0, 14.0));
-                let open = app.ui.timeline.open_layers.contains(&layer.id.0);
-                if widgets::twirl(ui, tw, open, egui::Id::unique(("twirl", layer.id.0)), &t).clicked() {
-                    ui_actions.push(UiAct::ToggleLayer(layer.id.0, ui.input(|i| i.modifiers.alt || i.modifiers.command)));
-                }
-                app.auto.add(&format!("timeline.layer.{}.twirl", layer.id.0), tw, "twirl");
-                icons::paint(&lp, Rect::from_center_size(pos2(cw.name + 24.0, cy), vec2(13.0, 13.0)), layer_icon(layer, &app.session.project), t.text_dim);
-                // A guide layer carries a guide mark before its name (After Effects).
-                let name_x = if layer.switches.guide {
-                    let mark = Rect::from_center_size(pos2(cw.name + 40.0, cy), vec2(11.0, 11.0));
-                    icons::paint(&lp, mark, Icon::Grid, t.text_dim);
-                    app.auto.add(&format!("timeline.layer.{}.guide", layer.id.0), mark, "Guide Layer");
-                    cw.name + 50.0
-                } else {
-                    cw.name + 34.0
-                };
-                let name_rect = Rect::from_min_max(pos2(name_x, r.min.y), pos2(cw.name_end - 4.0, r.max.y));
-                let rename_id = egui::Id::unique("tl-rename");
-                let renaming: Option<(u64, String)> = ctx.data(|d| d.get_temp(rename_id));
-                if let Some((rl, mut buf)) = renaming.filter(|(rl, _)| *rl == layer.id.0) {
-                    let mut child = ui.new_child(egui::UiBuilder::new().max_rect(name_rect.shrink2(vec2(0.0, 2.0))));
-                    let er = child.add(egui::TextEdit::singleline(&mut buf).font(Tokens::ui(12.0)).desired_width(name_rect.width()));
-                    app.auto.add(&format!("timeline.layer.{rl}.nameEdit"), er.rect, &buf);
-                    if ctx.data_mut(|d| d.remove_temp::<bool>(rename_focus_id())).unwrap_or(false) {
-                        // Just started: focus the field with the whole name selected.
-                        er.request_focus();
-                        widgets::select_all(&ctx, er.id, &buf);
-                    }
-                    if er.lost_focus() {
-                        if !ui.input(|i| i.key_pressed(egui::Key::Escape)) {
-                            actions.push(("layer.rename".into(), json!({"layer": rl, "name": buf})));
-                        }
-                        ctx.data_mut(|d| d.remove::<(u64, String)>(rename_id));
-                    } else {
-                        ctx.data_mut(|d| d.insert_temp(rename_id, (rl, buf)));
-                    }
-                } else {
-                    // The selected layer's name sits in a light cell with dark text.
-                    let name_col = if is_sel { Color32::from_gray(0x16) } else { t.text };
-                    if is_sel {
-                        let g = lp.layout_no_wrap(display_name(app, layer), Tokens::ui(12.0), name_col);
-                        let cell = Rect::from_min_max(
-                            pos2(name_rect.min.x - 3.0, r.min.y + 1.0),
-                            pos2((name_rect.min.x + g.size().x + 4.0).max(cw.name_end - 4.0).min(cw.name_end - 2.0), r.max.y - 1.0),
-                        );
-                        lp.rect_filled(cell, 0.0, SELECTED_NAME_BG);
-                    }
-                    let lpn = lp.with_clip_rect(name_rect.intersect(lp.clip_rect()));
-                    lpn.text(pos2(name_rect.min.x, cy), Align2::LEFT_CENTER, display_name(app, layer), Tokens::ui(12.0), name_col);
-                }
-                // Locked layers can't be selected or moved (unlock them with the lock switch).
-                let locked = layer.switches.locked;
-                if row_resp.drag_started() && !locked {
-                    // The selected layers move together; an unselected row moves alone.
-                    let moving: Vec<u64> =
-                        if is_sel { comp.layers.iter().filter(|l| selected.contains(&l.id)).map(|l| l.id.0).collect() } else { vec![layer.id.0] };
-                    ctx.data_mut(|d| d.insert_temp(layer_drag_id(), moving));
-                }
-                if row_resp.drag_stopped() {
-                    ctx.data_mut(|d| d.insert_temp(layer_drop_id(), true));
-                }
-                app.auto.add(&format!("timeline.layer.{}.row", layer.id.0), left, &layer.name);
-                if row_resp.clicked() && !locked {
-                    let m = ui.input(|i| i.modifiers);
-                    if let Some(layers) = m.shift.then(|| shift_range(&ctx, cid, &comp, &rows, &selected, layer.id)).flatten() {
-                        actions.push(("layer.select".into(), json!({"layers": layers})));
-                    } else {
-                        actions.push(("layer.select".into(), json!({"layers": [layer.id.0], "toggle": m.command})));
-                        set_anchor(&ctx, cid, layer.id);
-                    }
-                }
-                if row_resp.double_clicked() {
-                    match double_click_action(layer) {
-                        Some(a) => actions.push(a),
-                        None => start_rename(&ctx, layer.id.0, &layer.name),
-                    }
-                }
-                layer_context_menu(&row_resp, &comp, layer, &selected, LayerMenuCaps::of(&app.session.project, layer), &mut app.auto, &mut actions);
-                // Switches.
-                let sws: [(Icon, bool, &str, bool); 8] = [
-                    (Icon::Shy, sw.shy, "shy", switch_applies(layer, "shy", &app.session.project)),
-                    (Icon::Collapse, sw.collapse, "collapse", switch_applies(layer, "collapse", &app.session.project)),
-                    (
-                        Icon::Quality,
-                        sw.quality == effectcraft_engine::project::Quality::Best,
-                        "quality",
-                        switch_applies(layer, "quality", &app.session.project),
-                    ),
-                    (Icon::Fx, sw.effects, "fx", switch_applies(layer, "fx", &app.session.project)),
-                    (
-                        Icon::FrameBlend,
-                        sw.frame_blend != effectcraft_engine::project::FrameBlend::Off,
-                        "frameBlend",
-                        switch_applies(layer, "frameBlend", &app.session.project),
-                    ),
-                    (Icon::MotionBlur, sw.motion_blur, "motionBlur", switch_applies(layer, "motionBlur", &app.session.project)),
-                    (Icon::Adjustment, sw.adjustment, "adjustment", switch_applies(layer, "adjustment", &app.session.project)),
-                    (Icon::Cube, layer.is_3d(), "threeD", switch_applies(layer, "threeD", &app.session.project)),
-                ];
-                for (i, (icon, on, name, applicable)) in sws.into_iter().enumerate() {
-                    if !applicable || !vis.switches {
-                        continue;
-                    }
-                    let br = Rect::from_center_size(pos2(cw.switches + SW * i as f32 + SW / 2.0, cy), vec2(16.0, 16.0));
-                    lp.rect_filled(br.shrink(1.0), 1.0, t.switch_well);
-                    layer_switch(
-                        ui,
-                        &t,
-                        r,
-                        br,
-                        icon,
-                        on,
-                        egui::Id::unique(("sw", layer.id.0, i)),
-                        layer.id.0,
-                        name,
-                        false,
-                        &comp,
-                        &app.session.project,
-                        &selected,
-                        &mut actions,
-                    );
-                    app.auto.add(&format!("timeline.layer.{}.switch.{name}", layer.id.0), br, name);
-                }
-                // Modes.
-                if app.ui.timeline.show_modes && layer.source.is_av() {
-                    let mr = Rect::from_min_size(pos2(cw.mode + 2.0, cy - 9.0), vec2(80.0, 18.0));
-                    let mresp = widgets::dropdown(ui, mr, layer.blend_mode.label(), &t, egui::Id::unique(("mode", layer.id.0)));
-                    app.auto.add(&format!("timeline.layer.{}.mode", layer.id.0), mr, "Mode");
-                    let pop = egui::Id::unique(("mode-pop", layer.id.0));
-                    if mresp.clicked() {
-                        widgets::open_popup(ui, pop);
-                    }
-                    let opts: Vec<String> = BlendMode::ALL
-                        .iter()
-                        .flat_map(|m| if m.ends_group() { vec![m.label().to_string(), "-".to_string()] } else { vec![m.label().to_string()] })
-                        .collect();
-                    if let Some(i) = widgets::popup_menu(ui, pop, mr.left_bottom(), &opts, opts.iter().position(|o| o == layer.blend_mode.label())) {
-                        actions.push(("layer.setBlendMode".into(), json!({"layers": mode_targets(&comp, layer.id, &selected), "mode": opts[i]})));
-                    }
-                    let tr = Rect::from_center_size(pos2(cw.mode + 76.0 + 6.0, cy), vec2(14.0, 14.0));
-                    app.auto.add(&format!("timeline.layer.{}.preserveTransparency", layer.id.0), tr, "Preserve Transparency");
-                    if widgets::checkbox(ui, tr, layer.preserve_transparency, &t, egui::Id::unique(("pt", layer.id.0))).clicked() {
-                        // The click gives the selection the state the clicked row toggles to,
-                        // whatever the first selected layer's value (as the switches do).
-                        actions.push((
-                            "layer.setSwitch".into(),
-                            json!({
-                                "layers": mode_targets(&comp, layer.id, &selected),
-                                "switch": "preserveTransparency",
-                                "value": !layer.preserve_transparency
-                            }),
-                        ));
-                    }
-                    // Track matte: layer picker + kind.
-                    let mr = Rect::from_min_size(pos2(cw.trkmat + 2.0, cy - 9.0), vec2(104.0, 18.0));
-                    let label = match layer.track_matte {
-                        Some(m) => comp.layer(m.layer).map(|l| format!("{} {}", idx_of(l.id), l.name)).unwrap_or("None".into()),
-                        None => "No Track Matte".into(),
-                    };
-                    // The cell is too narrow for the mode as well: it is in the tooltip and ticked in the menu.
-                    let tip = layer.track_matte.map(|m| format!("{label} · {}", crate::i18n::tr(m.kind.label())));
-                    let tresp = widgets::dropdown_tip(ui, mr, &label, tip.as_deref(), &t, egui::Id::unique(("trkmat", layer.id.0)));
-                    app.auto.add(&format!("timeline.layer.{}.trackMatte", layer.id.0), mr, "Track Matte");
-                    let pop = egui::Id::unique(("trk-pop", layer.id.0));
-                    if tresp.clicked() {
-                        widgets::open_popup(ui, pop);
-                    }
-                    // The menu lists every layer: built only while it is open (per visible row
-                    // it made a big comp's timeline quadratic).
-                    let mut opts = vec!["No Track Matte".to_string(), "-".to_string()];
-                    let mut candidates: Vec<&Layer> = vec![];
-                    if widgets::popup_is_open(ui, pop) {
-                        for (i, l) in comp.layers.iter().enumerate().filter(|(_, l)| l.id != layer.id && l.source.is_av()) {
-                            opts.push(format!("{}. {}", i + 1, l.name));
-                            candidates.push(l);
-                        }
-                        opts.push("-".into());
-                        for k in MatteKind::ALL {
-                            opts.push(k.label().into());
-                        }
-                    }
-                    let current = layer.track_matte.and_then(|m| opts.iter().position(|o| o == m.kind.label()));
-                    if let Some(i) = widgets::popup_menu(ui, pop, mr.left_bottom(), &opts, current) {
-                        let ids: Vec<LayerId> = candidates.iter().map(|l| l.id).collect();
-                        if let Some(a) = opts.get(i).and_then(|o| track_matte_pick(layer, &ids, i, o)) {
-                            actions.push(a);
-                        }
-                    }
-                    if layer.track_matte.is_some() {
-                        let kr = Rect::from_center_size(pos2(mr.max.x - 26.0, cy), vec2(10.0, 10.0));
-                        let _ = kr;
-                    }
-                }
-                // Parent.
-                if vis.parent {
-                    pick_whip(
-                        app,
-                        ui,
-                        &lp,
-                        Rect::from_center_size(pos2(cw.parent + 9.0, cy), vec2(15.0, 15.0)),
-                        (WHIP_PARENT, layer.id.0, 0),
-                        &format!("timeline.layer.{}.pickWhip", layer.id.0),
-                        "Parent pick whip",
-                        crate::i18n::tr("Parent pick whip: drag onto a layer"),
-                    );
-                    let pr_rect = Rect::from_min_size(pos2(cw.parent + 20.0, cy - 9.0), vec2(94.0, 18.0));
-                    let plabel = layer.parent.and_then(|p| comp.layer(p)).map(|l| format!("{}. {}", idx_of(l.id), l.name)).unwrap_or_else(|| "None".into());
-                    let presp = widgets::dropdown(ui, pr_rect, &plabel, &t, egui::Id::unique(("parent", layer.id.0)));
-                    app.auto.add(&format!("timeline.layer.{}.parent", layer.id.0), pr_rect, "Parent");
-                    let pop = egui::Id::unique(("par-pop", layer.id.0));
-                    if presp.clicked() {
-                        widgets::open_popup(ui, pop);
-                    }
-                    let mut cands: Vec<&Layer> = vec![];
-                    let mut popts = vec!["None".to_string(), "-".to_string()];
-                    if widgets::popup_is_open(ui, pop) {
-                        for (i, l) in comp.layers.iter().enumerate().filter(|(_, l)| l.id != layer.id) {
-                            popts.push(format!("{}. {}", i + 1, l.name));
-                            cands.push(l);
-                        }
-                    }
-                    if let Some(i) = widgets::popup_menu(ui, pop, pr_rect.left_bottom(), &popts, None) {
-                        let par = if i == 0 { serde_json::Value::Null } else { json!(cands[i - 2].id.0) };
-                        actions.push(("layer.setParent".into(), json!({"layers": [layer.id.0], "parent": par})));
-                    }
-                }
-                // Layer bar.
-                ui.set_clip_rect(right_clip);
-                if !graph_on {
-                    let x_in = tm.x(layer.in_point.seconds());
-                    let x_out = tm.x(layer.out_point.seconds());
-                    let bar = Rect::from_min_max(pos2(x_in, r.min.y + 1.0), pos2(x_out, r.max.y - 1.0));
-                    let lc = t.label(layer.label);
-                    let fill = bar_color(lc, is_sel);
-                    gp.rect_filled(bar, 0.0, fill);
-                    if is_sel {
-                        gp.rect_stroke(bar, 0.0, Stroke::new(1.0, Color32::from_white_alpha(90)), StrokeKind::Inside);
-                    }
-                    // Source extent (e.g. trimmed footage) shown faint.
-                    if let LayerSource::Footage { .. } | LayerSource::Comp { .. } = layer.source
-                        && let Some(d) = layer.source.item().and_then(|i| app.session.project.item(i)).and_then(|i| i.duration())
-                    {
-                        let xs = tm.x(layer.start_time.seconds());
-                        let xe = tm.x(layer.comp_time(d).seconds());
-                        let ghost = Rect::from_min_max(pos2(xs.min(xe), r.min.y + 9.0), pos2(xs.max(xe), r.max.y - 9.0));
-                        gp.rect_filled(ghost, 1.0, lc.gamma_multiply(0.18));
-                        // The bar past the source's end (its last frame held) or before its start
-                        // is striped, so the source's own span shows (#290). Time remapping
-                        // decides what shows there itself.
-                        if layer.props.get("timeRemap").is_none() {
-                            for (side, part) in [
-                                ("beforeSource", Rect::from_min_max(bar.min, pos2(ghost.min.x, bar.max.y))),
-                                ("afterSource", Rect::from_min_max(pos2(ghost.max.x, bar.min.y), bar.max)),
-                            ] {
-                                if part.width() >= 1.0 {
-                                    stripes(&gp, part, lc);
-                                    app.auto.add(&format!("timeline.layer.{}.bar.{side}", layer.id.0), part, "Past the source");
-                                }
-                            }
-                        }
-                        // Dragging the source bar outside the in/out span slips the source.
-                        for (side, gr) in [
-                            ("l", Rect::from_min_max(ghost.min, pos2(bar.min.x, ghost.max.y))),
-                            ("r", Rect::from_min_max(pos2(bar.max.x, ghost.min.y), ghost.max)),
-                        ] {
-                            if gr.width() < 2.0 {
-                                continue;
-                            }
-                            let gresp = ui
-                                .interact(gr, egui::Id::unique(("ghost", side, layer.id.0)), Sense::click_and_drag())
-                                .on_hover_text(crate::i18n::tr("Drag to slip the source"));
-                            // Outside the bar it is empty track area: a plain click deselects.
-                            if gresp.clicked() && !ui.input(|i| i.modifiers.shift || i.modifiers.command) {
-                                actions.push(("layer.select".into(), json!({"layers": []})));
-                            }
-                            app.auto.add(&format!("timeline.layer.{}.source{}", layer.id.0, side), gr, "Slip");
-                            if gresp.hovered() || gresp.dragged() {
-                                ctx.set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
-                            }
-                            let acc_id = egui::Id::unique(("slip-acc", layer.id.0));
-                            if gresp.dragged() {
-                                let mut acc: f32 = ctx.data(|d| d.get_temp(acc_id).unwrap_or(0.0));
-                                acc += gresp.drag_delta().x;
-                                let frames = ((acc as f64 / pps) / fd).trunc() as i64;
-                                if frames != 0 {
-                                    acc -= (frames as f64 * fd * pps) as f32;
-                                    actions.push((
-                                        "layer.slip".into(),
-                                        json!({"layers": [layer.id.0], "frames": frames, "merge": format!("slip-{}", layer.id.0)}),
-                                    ));
-                                }
-                                ctx.data_mut(|d| d.insert_temp(acc_id, acc));
-                            }
-                            if gresp.drag_stopped() {
-                                ctx.data_mut(|d| d.remove::<f32>(acc_id));
-                                ui_actions.push(UiAct::EndMerge);
-                            }
-                        }
-                    }
-                    app.auto.add(&format!("timeline.layer.{}.bar", layer.id.0), bar, &layer.name);
-                    // Interactions: move body, trim edges.
-                    let (body_r, in_r, out_r) = trim_zones(bar);
-                    let body = ui.interact(body_r, egui::Id::unique(("bar", layer.id.0)), Sense::click_and_drag());
-                    let lin = ui.interact(in_r, egui::Id::unique(("bar-in", layer.id.0)), Sense::drag());
-                    let lout = ui.interact(out_r, egui::Id::unique(("bar-out", layer.id.0)), Sense::drag());
-                    app.auto.add(&format!("timeline.layer.{}.bar.in", layer.id.0), in_r, "Trim In");
-                    app.auto.add(&format!("timeline.layer.{}.bar.out", layer.id.0), out_r, "Trim Out");
-                    if lin.hovered() || lout.hovered() || lin.dragged() || lout.dragged() {
-                        trim_cursor(&ctx);
-                    }
-                    if body.double_clicked()
-                        && let Some(a) = double_click_action(layer)
-                    {
-                        actions.push(a);
-                    }
-                    let shift = ui.input(|i| i.modifiers.shift);
-                    if let Some(layers) = (body.clicked() && shift).then(|| shift_range(&ctx, cid, &comp, &rows, &selected, layer.id)).flatten() {
-                        // Shift-click: the layers from the last one clicked to this one, as in
-                        // the layer outline.
-                        actions.push(("layer.select".into(), json!({"layers": layers})));
-                    } else {
-                        if (body.clicked() || body.drag_started()) && !is_sel {
-                            actions.push(("layer.select".into(), json!({"layers": [layer.id.0], "add": shift})));
-                        }
-                        if (body.clicked() || body.drag_started()) && !shift {
-                            set_anchor(&ctx, cid, layer.id);
-                        }
-                    }
-                    layer_context_menu(&body, &comp, layer, &selected, LayerMenuCaps::of(&app.session.project, layer), &mut app.auto, &mut actions);
-                    let drag_key = format!("bar-{}", layer.id.0);
-                    // Ctrl/Cmd+Alt dragging a selected bar: Quick Offset (#1012), chosen as the
-                    // drag starts and followed below the rows until the button is released.
-                    let mods = ui.input(|i| i.modifiers);
-                    if body.drag_started()
-                        && is_sel
-                        && mods.command
-                        && mods.alt
-                        && let Some(n) = quick_offset_layers(&comp, selected.iter().copied())
-                        && let Some(p) = ctx.input(|i| i.pointer.press_origin())
-                    {
-                        ctx.data_mut(|d| d.insert_temp(quick_bar_id(), QuickBar { layer: layer.id, origin_x: p.x, layers: n, applied: 0 }));
-                    }
-                    let quick = ctx.data(|d| d.get_temp::<QuickBar>(quick_bar_id())).is_some_and(|q| q.layer == layer.id);
-                    for (resp, kind) in [(&body, "move"), (&lin, "in"), (&lout, "out")] {
-                        if kind == "move" && quick {
-                            continue;
-                        }
-                        if resp.dragged() {
-                            let acc_id = egui::Id::unique(("bar-acc", layer.id.0, kind));
-                            let mut acc: f32 = ctx.data(|d| d.get_temp(acc_id).unwrap_or(0.0));
-                            acc += resp.drag_delta().x;
-                            let frames = ((acc as f64 / pps) / fd).trunc() as i64;
-                            if frames != 0 {
-                                acc -= (frames as f64 * fd * pps) as f32;
-                                let d = frames as f64 * fd;
-                                // Moving or trimming a selected layer acts on the whole
-                                // selection; each layer trims from its own in/out point.
-                                let targets = if is_sel { json!(selected.iter().map(|l| l.0).collect::<Vec<_>>()) } else { json!([layer.id.0]) };
-                                let params = match kind {
-                                    "move" => json!({"layers": targets, "delta": d, "merge": drag_key}),
-                                    "in" => json!({"layers": targets, "inDelta": d, "merge": drag_key}),
-                                    _ => json!({"layers": targets, "outDelta": d, "merge": drag_key}),
-                                };
-                                actions.push(("layer.timing".into(), params));
-                            }
-                            ctx.data_mut(|d| d.insert_temp(acc_id, acc));
-                        }
-                        if resp.drag_stopped() {
-                            ctx.data_mut(|d| d.remove::<f32>(egui::Id::unique(("bar-acc", layer.id.0, kind))));
-                            ui_actions.push(UiAct::EndMerge);
-                        }
-                    }
-                    // Markers on the layer (drag, Alt-drag duration, Cmd-click delete, dialog).
-                    let gclip = rows_rect.intersect(Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max));
-                    super::markers_ui::layer_markers(app, ui, gclip, &comp, layer, tm, r);
-                }
+        lp.rect_filled(br.shrink(0.5), 1.0, t.switch_well);
+        layer_switch(
+            ui,
+            &t,
+            &SwitchSpec { row: r, br, icon, on, id: egui::Id::unique(("av", layer.id.0, i)), layer: layer.id.0, name, others: true },
+            &comp,
+            &app.session.project,
+            selected,
+            &mut *actions,
+        );
+        app.auto.add(&format!("timeline.layer.{}.{name}", layer.id.0), br, name);
+    }
+}
+
+/// The label swatch and its colour menu.
+fn layer_label_swatch(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let vis = g.tl.vis;
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let selected = &g.selected;
+    let layer = rc.layer;
+    let cy = rc.cy;
+    // Label swatch.
+    if vis.label {
+        let lr = Rect::from_center_size(pos2(cw.label + 10.0, cy), vec2(12.0, 12.0));
+        lp.rect_filled(lr, 2.0, t.label(layer.label));
+        let lresp = ui.interact(lr, egui::Id::unique(("label", layer.id.0)), Sense::click());
+        app.auto.add(&format!("timeline.layer.{}.label", layer.id.0), lr, layer.label.name());
+        // Click (or right-click) the swatch for the label menu (After Effects).
+        let pop = egui::Id::unique(("label-pop", layer.id.0));
+        if lresp.clicked() || lresp.secondary_clicked() {
+            widgets::open_popup(ui, pop);
+        }
+        if let Some(lab) = widgets::label_popup(ui, pop, lr.left_bottom(), layer.label, |l| app.session.prefs.label_name(l), &t) {
+            actions.push(("edit.label".into(), json!({"layers": edited_layers(layer.id, selected), "label": lab.name()})));
+        }
+    }
+}
+
+fn layer_number_and_cells(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let vis = g.tl.vis;
+    let comp = g.tl.comp.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let layer = rc.layer;
+    let cy = rc.cy;
+    if vis.num {
+        lp.text(pos2(cw.num + 13.0, cy), Align2::CENTER_CENTER, format!("{}", comp.index_of(layer.id).unwrap_or(0)), Tokens::ui(11.5), t.text_dim);
+    }
+    layer_cells(app, ui, &lp, cw, &comp, rc, &mut *actions);
+}
+
+/// The row's click target, twirl, icon and guide mark; returns the row response and the name's x.
+fn layer_twirl_and_icon(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) -> (egui::Response, f32) {
+    let t = g.tl.t;
+    let vis = g.tl.vis;
+    let cw = &g.tl.cw;
+    let lp = g.lp.clone();
+    let ui_actions = &mut g.ui_actions;
+    let layer = rc.layer;
+    let r = rc.r;
+    let cy = rc.cy;
+    // Row click → select; double-click → rename; drag → reorder. Registered before the
+    // twirl and the name field so those sit on top and get their clicks.
+    let row_x0 = if vis.num { cw.num } else { cw.name + 16.0 };
+    let row_resp =
+        ui.interact(Rect::from_min_max(pos2(row_x0, r.min.y), pos2(cw.name_end, r.max.y)), egui::Id::unique(("row", layer.id.0)), Sense::click_and_drag());
+    // Twirl + icon + name.
+    let tw = Rect::from_center_size(pos2(cw.name + 8.0, cy), vec2(14.0, 14.0));
+    let open = app.ui.timeline.open_layers.contains(&layer.id.0);
+    if widgets::twirl(ui, tw, open, egui::Id::unique(("twirl", layer.id.0)), &t).clicked() {
+        ui_actions.push(UiAct::ToggleLayer(layer.id.0, ui.input(|i| i.modifiers.alt || i.modifiers.command)));
+    }
+    app.auto.add(&format!("timeline.layer.{}.twirl", layer.id.0), tw, "twirl");
+    icons::paint(&lp, Rect::from_center_size(pos2(cw.name + 24.0, cy), vec2(13.0, 13.0)), layer_icon(layer, &app.session.project), t.text_dim);
+    // A guide layer carries a guide mark before its name (After Effects).
+    let name_x = if layer.switches.guide {
+        let mark = Rect::from_center_size(pos2(cw.name + 40.0, cy), vec2(11.0, 11.0));
+        icons::paint(&lp, mark, Icon::Grid, t.text_dim);
+        app.auto.add(&format!("timeline.layer.{}.guide", layer.id.0), mark, "Guide Layer");
+        cw.name + 50.0
+    } else {
+        cw.name + 34.0
+    };
+    (row_resp, name_x)
+}
+
+/// The layer name: the rename field or the (selected) name cell.
+fn layer_name(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, name_x: f32) {
+    let t = g.tl.t;
+    let ctx = g.tl.ctx.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let layer = rc.layer;
+    let r = rc.r;
+    let cy = rc.cy;
+    let is_sel = rc.is_sel;
+    let name_rect = Rect::from_min_max(pos2(name_x, r.min.y), pos2(cw.name_end - 4.0, r.max.y));
+    let rename_id = egui::Id::unique("tl-rename");
+    let renaming: Option<(u64, String)> = ctx.data(|d| d.get_temp(rename_id));
+    if let Some((rl, mut buf)) = renaming.filter(|(rl, _)| *rl == layer.id.0) {
+        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(name_rect.shrink2(vec2(0.0, 2.0))));
+        let er = child.add(egui::TextEdit::singleline(&mut buf).font(Tokens::ui(12.0)).desired_width(name_rect.width()));
+        app.auto.add(&format!("timeline.layer.{rl}.nameEdit"), er.rect, &buf);
+        if ctx.data_mut(|d| d.remove_temp::<bool>(rename_focus_id())).unwrap_or(false) {
+            // Just started: focus the field with the whole name selected.
+            er.request_focus();
+            widgets::select_all(&ctx, er.id, &buf);
+        }
+        if er.lost_focus() {
+            if !ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+                actions.push(("layer.rename".into(), json!({"layer": rl, "name": buf})));
             }
-            RowKind::Group { uid, name, open, has_children, fx, eye } => {
-                // The row draws an effect's name in the interface language (#821); `name` stays
-                // the property tree's, which the automation labels below keep. Any other group
-                // (a mask, a shape group, a layer style) draws its own name.
-                let group = layer.props.find_group(*uid);
-                let shown = match group.and_then(|g| match &g.kind {
-                    GroupKind::Effect { effect } => Some(effect.as_str()),
-                    _ => None,
-                }) {
-                    Some(effect) => crate::i18n::effects::group(effect, name),
-                    None => name.clone(),
-                };
-                // Selected groups (an effect, a mask, a shape group…) highlight like selected
-                // property rows.
-                let sel_group = app.session.state.selected_props.contains(&(layer.id, *uid));
-                lp.rect_filled(
-                    left,
-                    0.0,
-                    if sel_group {
-                        t.row_selected
-                    } else if ri % 2 == 0 {
-                        t.row
-                    } else {
-                        t.row_alt
-                    },
-                );
-                gp.rect_filled(Rect::from_min_max(pos2(graph_x0, r.min.y), r.max), 0.0, t.tl_bg);
-                // An effect's colour label (26.5): the same bar the Effect Controls header wears,
-                // on the row's left edge.
-                if let Some(lab) =
-                    group.filter(|g| matches!(g.kind, GroupKind::Effect { .. })).and_then(|g| g.label).filter(|l| *l != effectcraft_engine::color::Label::None)
-                {
-                    let [lr, lg, lb] = app.session.prefs.label_rgb(lab);
-                    let bar = Rect::from_min_size(left.min, vec2(4.0, left.height()));
-                    lp.rect_filled(bar, 0.0, Color32::from_rgb(lr, lg, lb));
-                    app.auto.add(&format!("timeline.group.{uid}.label"), bar, &app.session.prefs.label_name(lab));
-                }
-                let indent = cw.name + 6.0 + 14.0 * row.depth as f32;
-                if *has_children {
-                    let tw = Rect::from_center_size(pos2(indent, cy), vec2(13.0, 13.0));
-                    if widgets::twirl(ui, tw, *open, egui::Id::unique(("gtw", uid)), &t).clicked() {
-                        // Alt/Cmd-click twirls the whole tree under the group (as on a layer).
-                        ui_actions.push(UiAct::ToggleGroup(layer.id.0, *uid, ui.input(|i| i.modifiers.alt || i.modifiers.command)));
-                    }
-                    app.auto.add(&format!("timeline.group.{uid}.twirl"), tw, name);
-                }
-                if let Some(en) = fx {
-                    let fr_ = Rect::from_center_size(pos2(cw.switches + SW * 3.0 + SW / 2.0, cy), vec2(16.0, 16.0));
-                    if widgets::icon_toggle(ui, fr_, Icon::Fx, *en, &t, egui::Id::unique(("gfx", uid)), Sense::click()).clicked() {
-                        actions.push(("effect.toggle".into(), json!({"layer": layer.id.0, "effect": uid})));
-                    }
-                    app.auto.add(&format!("timeline.group.{uid}.fx"), fr_, name);
-                }
-                if let Some(en) = eye {
-                    // Layer style eye switch in the A/V column, like AE.
-                    let er = Rect::from_center_size(pos2(cw.av + 10.0, cy), vec2(15.0, 15.0));
-                    lp.rect_stroke(er.shrink(1.5), 2.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
-                    if widgets::icon_toggle(ui, er, Icon::Eye, *en, &t, egui::Id::unique(("geye", uid)), Sense::click()).clicked() {
-                        actions.push(("layer.style.toggle".into(), json!({"layer": layer.id.0, "style": uid})));
-                    }
-                    app.auto.add(&format!("timeline.group.{uid}.eye"), er, name);
-                }
-                let group_edit: Option<(u64, u64, String)> = ctx.data(|d| d.get_temp(group_rename_id()));
-                if let Some((_, _, mut buf)) = group_edit.filter(|(rl, ru, _)| *rl == layer.id.0 && ru == uid) {
-                    let field = Rect::from_min_max(pos2(indent + 8.0, r.min.y + 2.0), pos2((cw.switches - 4.0).max(indent + 60.0), r.max.y - 2.0));
-                    let mut child = ui.new_child(egui::UiBuilder::new().max_rect(field));
-                    let er = child.add(egui::TextEdit::singleline(&mut buf).font(Tokens::ui(12.0)).desired_width(field.width()));
-                    app.auto.add(&format!("timeline.group.{uid}.nameEdit"), er.rect, &buf);
-                    if ctx.data_mut(|d| d.remove_temp::<bool>(rename_focus_id())).unwrap_or(false) {
-                        er.request_focus();
-                        widgets::select_all(&ctx, er.id, &buf);
-                    }
-                    if er.lost_focus() {
-                        if !ui.input(|i| i.key_pressed(egui::Key::Escape)) && !buf.trim().is_empty() && buf != *name {
-                            actions.push(("prop.renameGroup".into(), json!({"layer": layer.id.0, "prop": uid, "name": buf})));
-                        }
-                        ctx.data_mut(|d| d.remove::<(u64, u64, String)>(group_rename_id()));
-                    } else {
-                        ctx.data_mut(|d| d.insert_temp(group_rename_id(), (layer.id.0, *uid, buf)));
-                    }
-                } else {
-                    lp.text(pos2(indent + 10.0, cy), Align2::LEFT_CENTER, &shown, Tokens::ui(12.0), t.text);
-                }
-                text_anim_popups(app, ui, &lp, layer, *uid, cw.switches, cy, &mut actions);
-                shape_add_popup(app, ui, &lp, layer, *uid, cw.switches, cy, &mut actions);
-                if *uid == GEOM_BIT | layer.id.0 {
-                    let lr = lp.text(pos2(cw.switches + 6.0, cy), Align2::LEFT_CENTER, crate::i18n::tr("Change Renderer…"), Tokens::ui(11.5), t.accent);
-                    let resp = ui
-                        .interact(lr, egui::Id::unique(("tl-change-renderer", layer.id.0)), Sense::click())
-                        .on_hover_text(crate::i18n::tr("Composition Settings ▸ 3D Renderer"));
-                    if resp.hovered() {
-                        ctx.set_cursor_icon(egui::CursorIcon::PointingHand);
-                    }
-                    app.auto.add(&format!("timeline.layer.{}.changeRenderer", layer.id.0), lr, "Change Renderer…");
-                    if resp.clicked() {
-                        ui_actions.push(UiAct::ChangeRenderer);
-                    }
-                }
-                dash_buttons(app, ui, &lp, layer, *uid, cw.switches, cy, &mut actions);
-                // Mask mode + inverted inline.
-                if let Some(g) = layer.props.find_group(*uid)
-                    && let GroupKind::Mask { mode, inverted, .. } = g.kind
-                {
-                    let mr = Rect::from_min_size(pos2(cw.switches + 4.0, cy - 9.0), vec2(80.0, 18.0));
-                    let pop = egui::Id::unique(("maskmode", uid));
-                    if widgets::dropdown(ui, mr, mode.label(), &t, egui::Id::unique(("mm", uid))).clicked() {
-                        widgets::open_popup(ui, pop);
-                    }
-                    let opts: Vec<String> = effectcraft_engine::project::MaskMode::ALL.iter().map(|m| m.label().to_string()).collect();
-                    if let Some(i) = widgets::popup_menu(ui, pop, mr.left_bottom(), &opts, None) {
-                        actions.push(("layer.setMask".into(), json!({"layer": layer.id.0, "mask": uid, "mode": opts[i]})));
-                    }
-                    let ir = Rect::from_min_size(pos2(mr.max.x + 8.0, cy - 8.0), vec2(16.0, 16.0));
-                    if widgets::checkbox(ui, ir, inverted, &t, egui::Id::unique(("minv", uid))).clicked() {
-                        actions.push(("layer.setMask".into(), json!({"layer": layer.id.0, "mask": uid, "inverted": !inverted})));
-                    }
-                    lp.text(pos2(ir.max.x + 4.0, cy), Align2::LEFT_CENTER, crate::i18n::tr("Inverted"), Tokens::ui(11.0), t.text_dim);
-                }
-                let gr_rect = Rect::from_min_max(pos2(indent + 8.0, r.min.y), pos2(cw.switches, r.max.y));
-                let gr = ui.interact(gr_rect, egui::Id::unique(("grow", uid)), Sense::click());
-                app.auto.add(&format!("timeline.group.{uid}.name"), gr_rect, name);
-                if gr.clicked() && uid & (WAVE_BIT | GEOM_BIT) == 0 {
-                    actions.push(("prop.select".into(), json!({"layer": layer.id.0, "prop": uid, "selectKeys": false})));
-                }
-                if gr.double_clicked() {
-                    if fx.is_some() {
-                        // An effect's name: open it in Effect Controls (as in After Effects).
-                        actions.push(("layer.select".into(), json!({"layers": [layer.id.0]})));
-                        actions.push(("prop.select".into(), json!({"layer": layer.id.0, "prop": uid, "selectKeys": false})));
-                        actions.push(("window.panel".into(), json!({"panel": "EffectControls"})));
-                    } else {
-                        ui_actions.push(UiAct::ToggleGroup(layer.id.0, *uid, false));
-                    }
-                }
+            ctx.data_mut(|d| d.remove::<(u64, String)>(rename_id));
+        } else {
+            ctx.data_mut(|d| d.insert_temp(rename_id, (rl, buf)));
+        }
+    } else {
+        // The selected layer's name sits in a light cell with dark text.
+        let name_col = if is_sel { Color32::from_gray(0x16) } else { t.text };
+        if is_sel {
+            let g = lp.layout_no_wrap(display_name(app, layer), Tokens::ui(12.0), name_col);
+            let cell = Rect::from_min_max(
+                pos2(name_rect.min.x - 3.0, r.min.y + 1.0),
+                pos2((name_rect.min.x + g.size().x + 4.0).max(cw.name_end - 4.0).min(cw.name_end - 2.0), r.max.y - 1.0),
+            );
+            lp.rect_filled(cell, 0.0, SELECTED_NAME_BG);
+        }
+        let lpn = lp.with_clip_rect(name_rect.intersect(lp.clip_rect()));
+        lpn.text(pos2(name_rect.min.x, cy), Align2::LEFT_CENTER, display_name(app, layer), Tokens::ui(12.0), name_col);
+    }
+}
+
+/// Row click, drag, double-click and context menu.
+fn layer_row_actions(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, row_resp: &egui::Response) {
+    let cid = g.tl.cid;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let rows = &g.tl.rows;
+    let actions = &mut g.tl.actions;
+    let selected = &g.selected;
+    let layer = rc.layer;
+    let left = rc.left;
+    let is_sel = rc.is_sel;
+    // Locked layers can't be selected or moved (unlock them with the lock switch).
+    let locked = layer.switches.locked;
+    if row_resp.drag_started_by(egui::PointerButton::Primary) && !locked {
+        // The selected layers move together; an unselected row moves alone.
+        let moving: Vec<u64> = if is_sel { comp.layers.iter().filter(|l| selected.contains(&l.id)).map(|l| l.id.0).collect() } else { vec![layer.id.0] };
+        ctx.data_mut(|d| d.insert_temp(layer_drag_id(), LayerDrag { comp: cid, owner: row_resp.id, layers: moving }));
+    }
+    app.auto.add(&format!("timeline.layer.{}.row", layer.id.0), left, &layer.name);
+    if row_resp.clicked() && !locked {
+        let m = ui.input(|i| i.modifiers);
+        if let Some(layers) = m.shift.then(|| shift_range(&ctx, cid, &comp, rows, selected, layer.id)).flatten() {
+            actions.push(("layer.select".into(), json!({"layers": layers})));
+        } else {
+            actions.push(("layer.select".into(), json!({"layers": [layer.id.0], "toggle": m.command})));
+            set_anchor(&ctx, cid, layer.id);
+        }
+    }
+    if row_resp.double_clicked() {
+        match double_click_action(layer) {
+            Some(a) => actions.push(a),
+            None => start_rename(&ctx, layer.id.0, &layer.name),
+        }
+    }
+    layer_context_menu(row_resp, &comp, layer, selected, LayerMenuCaps::of(&app.session.project, layer), &mut app.auto, &mut *actions);
+}
+
+/// The eight layer switches.
+fn layer_switches(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let vis = g.tl.vis;
+    let comp = g.tl.comp.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let selected = &g.selected;
+    let layer = rc.layer;
+    let r = rc.r;
+    let cy = rc.cy;
+    let sw = &layer.switches;
+    let sws: [(Icon, bool, &str, bool); 8] = [
+        (Icon::Shy, sw.shy, "shy", switch_applies(layer, "shy", &app.session.project)),
+        (Icon::Collapse, sw.collapse, "collapse", switch_applies(layer, "collapse", &app.session.project)),
+        (Icon::Quality, sw.quality == effectcraft_engine::project::Quality::Best, "quality", switch_applies(layer, "quality", &app.session.project)),
+        (Icon::Fx, sw.effects, "fx", switch_applies(layer, "fx", &app.session.project)),
+        (
+            Icon::FrameBlend,
+            sw.frame_blend != effectcraft_engine::project::FrameBlend::Off,
+            "frameBlend",
+            switch_applies(layer, "frameBlend", &app.session.project),
+        ),
+        (Icon::MotionBlur, sw.motion_blur, "motionBlur", switch_applies(layer, "motionBlur", &app.session.project)),
+        (Icon::Adjustment, sw.adjustment, "adjustment", switch_applies(layer, "adjustment", &app.session.project)),
+        (Icon::Cube, layer.is_3d(), "threeD", switch_applies(layer, "threeD", &app.session.project)),
+    ];
+    for (i, (icon, on, name, applicable)) in sws.into_iter().enumerate() {
+        if !applicable || !vis.switches {
+            continue;
+        }
+        let br = Rect::from_center_size(pos2(cw.switches + SW * i as f32 + SW / 2.0, cy), vec2(16.0, 16.0));
+        lp.rect_filled(br.shrink(1.0), 1.0, t.switch_well);
+        layer_switch(
+            ui,
+            &t,
+            &SwitchSpec { row: r, br, icon, on, id: egui::Id::unique(("sw", layer.id.0, i)), layer: layer.id.0, name, others: false },
+            &comp,
+            &app.session.project,
+            selected,
+            &mut *actions,
+        );
+        app.auto.add(&format!("timeline.layer.{}.switch.{name}", layer.id.0), br, name);
+    }
+}
+
+/// The blend mode dropdown and Preserve Transparency.
+fn layer_mode_cell(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let comp = g.tl.comp.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let selected = &g.selected;
+    let layer = rc.layer;
+    let cy = rc.cy;
+    let mr = Rect::from_min_size(pos2(cw.mode + 2.0, cy - 9.0), vec2(80.0, 18.0));
+    let mresp = widgets::dropdown(ui, mr, layer.blend_mode.label(), &t, egui::Id::unique(("mode", layer.id.0)));
+    app.auto.add(&format!("timeline.layer.{}.mode", layer.id.0), mr, "Mode");
+    let pop = egui::Id::unique(("mode-pop", layer.id.0));
+    if mresp.clicked() {
+        widgets::open_popup(ui, pop);
+    }
+    let opts: Vec<String> =
+        BlendMode::ALL.iter().flat_map(|m| if m.ends_group() { vec![m.label().to_string(), "-".to_string()] } else { vec![m.label().to_string()] }).collect();
+    if let Some(i) = widgets::popup_menu(ui, pop, mr.left_bottom(), &opts, opts.iter().position(|o| o == layer.blend_mode.label())) {
+        actions.push(("layer.setBlendMode".into(), json!({"layers": video_targets(&comp, layer.id, selected), "mode": opts[i]})));
+    }
+    let tr = Rect::from_center_size(pos2(cw.mode + 76.0 + 6.0, cy), vec2(14.0, 14.0));
+    app.auto.add(&format!("timeline.layer.{}.preserveTransparency", layer.id.0), tr, "Preserve Transparency");
+    if widgets::checkbox(ui, tr, layer.preserve_transparency, &t, egui::Id::unique(("pt", layer.id.0))).changed() {
+        // The click gives the selection the state the clicked row toggles to,
+        // whatever the first selected layer's value (as the switches do).
+        actions.push((
+            "layer.setSwitch".into(),
+            json!({
+                "layers": video_targets(&comp, layer.id, selected),
+                "switch": "preserveTransparency",
+                "value": !layer.preserve_transparency
+            }),
+        ));
+    }
+}
+
+/// The track matte picker.
+fn layer_matte_cell(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let comp = g.tl.comp.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let selected = &g.selected;
+    let layer = rc.layer;
+    let cy = rc.cy;
+    // Track matte: a pick whip, then the layer picker with the mode. Like the parent, they set
+    // the matte of every selected layer when the row is selected (#1260).
+    pick_whip(
+        app,
+        ui,
+        &lp,
+        Rect::from_center_size(pos2(cw.trkmat + 9.0, cy), vec2(15.0, 15.0)),
+        (WHIP_MATTE, layer.id.0, 0),
+        WhipText {
+            auto: &format!("timeline.layer.{}.trackMattePickWhip", layer.id.0),
+            label: "Track Matte pick whip",
+            hint: crate::i18n::tr("Track Matte pick whip: drag onto a layer"),
+        },
+    );
+    let mr = Rect::from_min_size(pos2(cw.trkmat + 20.0, cy - 9.0), vec2(88.0, 18.0));
+    let label = match layer.track_matte {
+        Some(m) => comp.layer(m.layer).map(|l| format!("{} {}", comp.index_of(l.id).unwrap_or(0), l.name)).unwrap_or("None".into()),
+        None => "No Track Matte".into(),
+    };
+    // The cell is too narrow for the mode as well: it is in the tooltip and ticked in the menu.
+    let tip = layer.track_matte.map(|m| format!("{label} · {}", crate::i18n::tr(m.kind.label())));
+    let tresp = widgets::dropdown_tip(ui, mr, &label, tip.as_deref(), &t, egui::Id::unique(("trkmat", layer.id.0)));
+    app.auto.add(&format!("timeline.layer.{}.trackMatte", layer.id.0), mr, "Track Matte");
+    let pop = egui::Id::unique(("trk-pop", layer.id.0));
+    if tresp.clicked() {
+        widgets::open_popup(ui, pop);
+    }
+    // The menu lists every layer: built only while it is open (per visible row
+    // it made a big comp's timeline quadratic).
+    let mut opts = vec!["No Track Matte".to_string(), "-".to_string()];
+    let mut candidates: Vec<&Layer> = vec![];
+    if widgets::popup_is_open(ui, pop) {
+        for (i, l) in comp.layers.iter().enumerate().filter(|(_, l)| l.id != layer.id && l.source.is_av()) {
+            opts.push(format!("{}. {}", i + 1, l.name));
+            candidates.push(l);
+        }
+        opts.push("-".into());
+        for k in MatteKind::ALL {
+            opts.push(k.label().into());
+        }
+    }
+    let current = layer.track_matte.and_then(|m| opts.iter().position(|o| o == m.kind.label()));
+    if let Some(i) = widgets::popup_menu(ui, pop, mr.left_bottom(), &opts, current) {
+        let ids: Vec<LayerId> = candidates.iter().map(|l| l.id).collect();
+        if let Some(a) = opts.get(i).and_then(|o| track_matte_pick(&video_targets(&comp, layer.id, selected), &ids, i, o)) {
+            actions.push(a);
+        }
+    }
+    if layer.track_matte.is_some() {
+        let kr = Rect::from_center_size(pos2(mr.max.x - 26.0, cy), vec2(10.0, 10.0));
+        let _ = kr;
+    }
+}
+
+/// The parent pick whip and dropdown.
+fn layer_parent_cell(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let comp = g.tl.comp.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let selected = &g.selected;
+    let layer = rc.layer;
+    let cy = rc.cy;
+    pick_whip(
+        app,
+        ui,
+        &lp,
+        Rect::from_center_size(pos2(cw.parent + 9.0, cy), vec2(15.0, 15.0)),
+        (WHIP_PARENT, layer.id.0, 0),
+        WhipText {
+            auto: &format!("timeline.layer.{}.pickWhip", layer.id.0),
+            label: "Parent pick whip",
+            hint: crate::i18n::tr("Parent pick whip: drag onto a layer"),
+        },
+    );
+    let pr_rect = Rect::from_min_size(pos2(cw.parent + 20.0, cy - 9.0), vec2(94.0, 18.0));
+    let plabel = layer.parent.and_then(|p| comp.layer(p)).map(|l| format!("{}. {}", comp.index_of(l.id).unwrap_or(0), l.name)).unwrap_or_else(|| "None".into());
+    let presp = widgets::dropdown(ui, pr_rect, &plabel, &t, egui::Id::unique(("parent", layer.id.0)));
+    app.auto.add(&format!("timeline.layer.{}.parent", layer.id.0), pr_rect, "Parent");
+    let pop = egui::Id::unique(("par-pop", layer.id.0));
+    if presp.clicked() {
+        widgets::open_popup(ui, pop);
+    }
+    let mut cands: Vec<&Layer> = vec![];
+    let mut popts = vec!["None".to_string(), "-".to_string()];
+    if widgets::popup_is_open(ui, pop) {
+        for (i, l) in comp.layers.iter().enumerate().filter(|(_, l)| l.id != layer.id) {
+            popts.push(format!("{}. {}", i + 1, l.name));
+            cands.push(l);
+        }
+    }
+    if let Some(i) = widgets::popup_menu(ui, pop, pr_rect.left_bottom(), &popts, None) {
+        let par = cands.get(i.wrapping_sub(2)).map(|l| l.id.0);
+        // (The new parent itself, if selected, stays as it is.)
+        let layers: Vec<u64> = edited_layers(layer.id, selected).into_iter().filter(|l| Some(*l) != par).collect();
+        actions.push(("layer.setParent".into(), json!({"layers": layers, "parent": par})));
+    }
+}
+
+/// Paints the layer bar; returns it and its label colour.
+fn layer_bar_paint(g: &Rw, rc: &RowCtx<'_>) -> (Rect, Color32) {
+    let t = g.tl.t;
+    let tm = g.tl.tm;
+    let gp = g.gp.clone();
+    let layer = rc.layer;
+    let r = rc.r;
+    let is_sel = rc.is_sel;
+    let x_in = tm.x(layer.in_point.seconds());
+    let x_out = tm.x(layer.out_point.seconds());
+    let bar = Rect::from_min_max(pos2(x_in, r.min.y + 1.0), pos2(x_out, r.max.y - 1.0));
+    let lc = t.label(layer.label);
+    let fill = bar_color(lc, is_sel);
+    gp.rect_filled(bar, 0.0, fill);
+    if is_sel {
+        gp.rect_stroke(bar, 0.0, Stroke::new(1.0, Color32::from_white_alpha(90)), StrokeKind::Inside);
+    }
+    (bar, lc)
+}
+
+/// Dragging the source bar outside the in/out span slips the source.
+fn slip_source_handles(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, ghost: Rect, bar: Rect) {
+    let pps = g.tl.pps;
+    let fd = g.tl.fd;
+    let ctx = g.tl.ctx.clone();
+    let actions = &mut g.tl.actions;
+    let ui_actions = &mut g.ui_actions;
+    let layer = rc.layer;
+    // Dragging the source bar outside the in/out span slips the source.
+    for (side, gr) in [("l", Rect::from_min_max(ghost.min, pos2(bar.min.x, ghost.max.y))), ("r", Rect::from_min_max(pos2(bar.max.x, ghost.min.y), ghost.max))] {
+        if gr.width() < 2.0 {
+            continue;
+        }
+        let gresp =
+            ui.interact(gr, egui::Id::unique(("ghost", side, layer.id.0)), Sense::click_and_drag()).on_hover_text(crate::i18n::tr("Drag to slip the source"));
+        // Outside the bar it is empty track area: a plain click deselects.
+        if gresp.clicked() && !ui.input(|i| i.modifiers.shift || i.modifiers.command) {
+            actions.push(("layer.select".into(), json!({"layers": []})));
+        }
+        app.auto.add(&format!("timeline.layer.{}.source{}", layer.id.0, side), gr, "Slip");
+        if gresp.hovered() || gresp.dragged() {
+            ctx.set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
+        }
+        let acc_id = egui::Id::unique(("slip-acc", layer.id.0));
+        if gresp.dragged() {
+            let mut acc: f32 = ctx.data(|d| d.get_temp(acc_id).unwrap_or(0.0));
+            acc += gresp.drag_delta().x;
+            let frames = ((acc as f64 / pps) / fd).trunc() as i64;
+            if frames != 0 {
+                acc -= (frames as f64 * fd * pps) as f32;
+                actions.push(("layer.slip".into(), json!({"layers": [layer.id.0], "frames": frames, "merge": format!("slip-{}", layer.id.0)})));
             }
-            RowKind::Waveform { item } => {
-                lp.rect_filled(left, 0.0, if ri % 2 == 0 { t.row } else { t.row_alt });
-                let indent = cw.name + 6.0 + 14.0 * row.depth as f32;
-                lp.text(pos2(indent + 10.0, cy), Align2::LEFT_CENTER, "Waveform", Tokens::ui(12.0), t.text);
-                let wr = Rect::from_min_max(pos2(graph_x0, r.min.y), r.max);
-                gp.rect_filled(wr, 0.0, t.tl_bg);
-                app.auto.add(&format!("timeline.layer.{}.waveform", layer.id.0), wr, "Waveform");
-                match super::waveform::summary(app, &ctx, ItemId(*item)) {
-                    Some(s) => super::waveform::draw(&gp, wr.shrink2(vec2(0.0, 2.0)), &tm, layer, &s, Color32::from_rgb(0x5f, 0xc8, 0x8a)),
-                    None => {
-                        gp.text(
-                            pos2(tm.x(layer.in_point.seconds()).max(wr.min.x) + 6.0, wr.center().y),
-                            Align2::LEFT_CENTER,
-                            "Building waveform…",
-                            Tokens::ui(11.0),
-                            t.text_faint,
-                        );
-                    }
-                }
-            }
-            RowKind::Expr { uid, lines } => {
-                let Some(prop) = layer.props.find(*uid) else { continue };
-                let Some(ex) = prop.expr.clone() else { continue };
-                let (buf_id, edit_id) = (expr_buf_id(*uid), egui::Id::unique(("expr-edit", uid)));
-                // The same background as its property's row, selection included.
-                let sel_prop = app.session.state.selected_props.contains(&(layer.id, *uid));
-                lp.rect_filled(
-                    left,
-                    0.0,
-                    if sel_prop {
-                        t.row_selected
-                    } else if ri % 2 == 0 {
-                        t.row
-                    } else {
-                        t.row_alt
-                    },
-                );
-                let indent = cw.name + 6.0 + 14.0 * row.depth as f32;
-                lp.text(pos2(indent + 12.0, cy), Align2::LEFT_CENTER, crate::i18n::tr("Expression:"), Tokens::ui(11.5), t.text_dim);
-                lp.text(pos2(indent + 82.0, cy), Align2::LEFT_CENTER, &prop.name, Tokens::ui(11.5), t.text);
-                // "=" enable switch and the property pick whip (AE's expression controls).
-                let en_r = Rect::from_center_size(pos2(cw.switches + 10.0, cy), vec2(16.0, 16.0));
-                let en = ui.interact(en_r, egui::Id::unique(("expr-en", uid)), Sense::click()).on_hover_text(crate::i18n::tr("Enable Expression"));
-                lp.rect_stroke(en_r.shrink(1.0), 2.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
-                let expr_col = t.expr_text;
-                lp.text(
-                    en_r.center(),
-                    Align2::CENTER_CENTER,
-                    if ex.enabled { "=" } else { "≠" },
-                    Tokens::semibold(13.0),
-                    if ex.enabled { expr_col } else { t.text_dim },
-                );
-                app.auto.add(&format!("timeline.prop.{uid}.exprEnable"), en_r, "Enable Expression");
-                if en.clicked() {
-                    actions.push(("prop.setExpression".into(), json!({"layer": layer.id.0, "prop": uid, "enabled": !ex.enabled})));
-                }
-                let pw = pick_whip(
-                    app,
-                    ui,
-                    &lp,
-                    Rect::from_center_size(pos2(cw.switches + 30.0, cy), vec2(15.0, 15.0)),
-                    (WHIP_EXPR, layer.id.0, *uid),
-                    &format!("timeline.prop.{uid}.pickWhip"),
-                    "Expression pick whip",
-                    crate::i18n::tr("Expression pick whip: drag onto a property"),
-                );
-                if pw.is_pointer_button_down_on() && ui.input(|i| i.pointer.primary_pressed()) {
-                    // Pressed while the expression is being edited (its text is buffered while
-                    // the editor has the focus): the reference will go in at the cursor,
-                    // replacing the selection (#284).
-                    let into = ctx.data(|d| d.get_temp::<String>(buf_id)).map(|buf| {
-                        let n = buf.chars().count();
-                        let sel = egui::text_edit::TextEditState::load(&ctx, edit_id)
-                            .and_then(|st| st.cursor.char_range())
-                            .map_or([n, n], |r| [r.primary.index.0.min(r.secondary.index.0).min(n), r.primary.index.0.max(r.secondary.index.0).min(n)]);
-                        (buf, sel)
-                    });
-                    ctx.data_mut(|d| {
-                        if let Some(into) = into {
-                            d.insert_temp(whip_into_id(*uid), into);
-                        } else {
-                            d.remove::<WhipInto>(whip_into_id(*uid));
-                        }
-                    });
-                }
-                // Syntax errors: warning in the outline (the expression is disabled).
-                if let Some(check) = app.session.expr_check
-                    && let Err(e) = check(&ex.text)
-                {
-                    let wr = Rect::from_center_size(pos2(cw.switches + 50.0, cy), vec2(14.0, 14.0));
-                    lp.text(wr.center(), Align2::CENTER_CENTER, "⚠", Tokens::ui(12.0), Color32::from_rgb(0xf0, 0xa0, 0x30));
-                    let _ = ui.interact(wr, egui::Id::unique(("expr-err", uid)), Sense::hover()).on_hover_text(e);
-                }
-                // ⓕ: the Expression Language menu inserts at the cursor.
-                let lang_r = Rect::from_center_size(pos2(cw.switches + 70.0, cy), vec2(16.0, 16.0));
-                let lang = ui.interact(lang_r, egui::Id::unique(("expr-lang", uid)), Sense::click()).on_hover_text(crate::i18n::tr("Expression Language Menu"));
-                lp.circle_stroke(lang_r.center(), 6.5, Stroke::new(1.0, if lang.hovered() { t.text } else { t.text_dim }));
-                lp.text(lang_r.center(), Align2::CENTER_CENTER, "f", Tokens::semibold(10.0), if lang.hovered() { t.text } else { t.text_dim });
-                app.auto.add(&format!("timeline.prop.{uid}.exprLanguage"), lang_r, "Expression Language Menu");
-                let mut picked: Option<&'static str> = None;
-                egui::Popup::menu(&lang).style(crate::widgets::menu_style).show(|ui| {
-                    for (cat, items) in effectcraft_engine::commands::expr_tools::language_menu() {
-                        ui.menu_button(cat, |ui| {
-                            widgets::menu_scroll(ui, false, |ui| {
-                                for (label, text) in items {
-                                    if ui.button(label).clicked() {
-                                        picked = Some(text);
-                                        ui.close();
-                                    }
-                                }
-                            })
-                        });
-                    }
-                });
-                if let Some(text) = picked {
-                    let cur: String = ctx.data(|d| d.get_temp(buf_id)).unwrap_or_else(|| ex.text.clone());
-                    let at = egui::text_edit::TextEditState::load(&ctx, edit_id)
-                        .and_then(|st| st.cursor.char_range())
-                        .map(|r| r.primary.index.0)
-                        .unwrap_or(cur.chars().count())
-                        .min(cur.chars().count());
-                    let byte = cur.char_indices().nth(at).map(|(b, _)| b).unwrap_or(cur.len());
-                    let mut next = cur.clone();
-                    next.insert_str(byte, text);
-                    actions.push(("prop.setExpression".into(), json!({"layer": layer.id.0, "prop": uid, "expression": next})));
-                    ctx.data_mut(|d| d.remove::<String>(buf_id));
-                }
-                // The editor in the time-graph area.
-                ui.set_clip_rect(right_clip);
-                gp.rect_filled(Rect::from_min_max(pos2(graph_x0, r.min.y), r.max), 0.0, t.expr_bg);
-                let er = Rect::from_min_max(pos2(graph_x0 + 8.0, r.min.y + 3.0), pos2(rect.max.x - 14.0, r.max.y - 3.0));
-                let mut buf: String = ctx.data(|d| d.get_temp(buf_id)).unwrap_or_else(|| ex.text.clone());
-                if let Some(f) = ctx.data(|d| d.get_temp::<ExprFocus>(expr_focus_id())).filter(|f| f.prop == *uid) {
-                    // Asked for once (a pick whip put a reference in, or an Alt-click added the
-                    // expression): editing starts in the expression as it is now.
-                    ctx.data_mut(|d| d.remove::<ExprFocus>(expr_focus_id()));
-                    buf = ex.text.clone();
-                    let n = buf.chars().count();
-                    let [a, b] = f.select.map(|before_end| egui::text::CCursor::new(n.saturating_sub(before_end)));
-                    let mut st = egui::text_edit::TextEditState::load(&ctx, edit_id).unwrap_or_default();
-                    st.cursor.set_char_range(Some(egui::text::CCursorRange::two(a, b)));
-                    st.store(&ctx, edit_id);
-                    ctx.memory_mut(|m| m.request_focus(edit_id));
-                }
-                // Settings ▸ Scripting & Expressions ▸ Expressions Editor.
-                let sp = app.session.prefs.scripting.clone();
-                let resp = super::expr_editor::editor(ui, edit_id, &mut buf, er, &sp, if ex.enabled { expr_col } else { t.text_dim }, *lines, &t);
-                app.auto.add(&format!("timeline.prop.{uid}.expression"), er, &prop.name);
-                // Its bottom edge drags to set its height in whole lines, as in After Effects.
-                let edge = Rect::from_min_max(pos2(er.min.x, r.max.y - 4.0), pos2(er.max.x, r.max.y));
-                let eresp = ui.interact(edge, egui::Id::unique(("expr-edge", uid)), Sense::drag());
-                app.auto.add(&format!("timeline.prop.{uid}.expressionHeight"), edge, "Expression field height");
-                if eresp.hovered() || eresp.dragged() {
-                    ctx.set_cursor_icon(egui::CursorIcon::ResizeVertical);
-                }
-                if let Some(py) = eresp.interact_pointer_pos().filter(|_| eresp.dragged()).map(|p| p.y) {
-                    let n = ((py - r.min.y) / rh).round().clamp(1.0, EXPR_MAX_LINES as f32);
-                    app.ui.timeline.expr_lines.insert(*uid, n as usize);
-                }
-                let commit = resp.has_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter) && (i.modifiers.command || i.modifiers.ctrl));
-                if commit {
-                    resp.surrender_focus();
-                }
-                if resp.has_focus() && !commit {
-                    ctx.data_mut(|d| d.insert_temp(buf_id, buf));
-                } else {
-                    if (resp.lost_focus() || commit) && buf.trim_end() != ex.text {
-                        actions.push(("prop.setExpression".into(), json!({"layer": layer.id.0, "prop": uid, "expression": buf.trim_end()})));
-                    }
-                    ctx.data_mut(|d| d.remove::<String>(buf_id));
-                }
-            }
-            RowKind::Prop { uid } => {
-                let Some(prop) = layer.props.find(*uid) else { continue };
-                app.auto.add(&format!("timeline.prop.{uid}.row"), r, &prop.name);
-                let sel_prop = app.session.state.selected_props.contains(&(layer.id, *uid));
-                lp.rect_filled(
-                    left,
-                    0.0,
-                    if sel_prop {
-                        t.row_selected
-                    } else if ri % 2 == 0 {
-                        t.row
-                    } else {
-                        t.row_alt
-                    },
-                );
-                gp.rect_filled(Rect::from_min_max(pos2(graph_x0, r.min.y), r.max), 0.0, t.tl_bg);
-                let indent = cw.name + 6.0 + 14.0 * row.depth as f32;
-                // Keyframe navigator (in the A/V column, like AE).
-                // (in the Keys column when it is shown).
-                if prop.is_animated() && (vis.keys || vis.av) {
-                    let lt = layer.layer_time(time);
-                    let at_key = effectcraft_engine::keyframe::key_at(&prop.keys, lt).is_some();
-                    let nav_x = if vis.keys { cw.keys + 12.0 } else { cw.av + 18.0 };
-                    let prev = Rect::from_center_size(pos2(nav_x, cy), vec2(12.0, 14.0));
-                    let mid = Rect::from_center_size(pos2(nav_x + 16.0, cy), vec2(14.0, 14.0));
-                    let next = Rect::from_center_size(pos2(nav_x + 32.0, cy), vec2(12.0, 14.0));
-                    icons::paint(&lp, prev.shrink(2.0), Icon::ChevronLeft, t.text_dim);
-                    icons::paint(&lp, next.shrink(2.0), Icon::ChevronRight, t.text_dim);
-                    let kc = if at_key { t.keyframe_selected } else { Color32::TRANSPARENT };
-                    lp.add(egui::Shape::convex_polygon(
-                        vec![mid.center() + vec2(0.0, -5.0), mid.center() + vec2(5.0, 0.0), mid.center() + vec2(0.0, 5.0), mid.center() + vec2(-5.0, 0.0)],
-                        kc,
-                        Stroke::new(1.0, t.text_dim),
-                    ));
-                    if ui.interact(prev, egui::Id::unique(("kprev", uid)), Sense::click()).clicked()
-                        && let Some(k) = prop.keys.iter().rev().find(|k| layer.comp_time(k.time).0 < time.0 - fr.frame_duration().0 / 2)
-                    {
-                        ui_actions.push(UiAct::SetTime(layer.comp_time(k.time)));
-                    }
-                    if ui.interact(next, egui::Id::unique(("knext", uid)), Sense::click()).clicked()
-                        && let Some(k) = prop.keys.iter().find(|k| layer.comp_time(k.time).0 > time.0 + fr.frame_duration().0 / 2)
-                    {
-                        ui_actions.push(UiAct::SetTime(layer.comp_time(k.time)));
-                    }
-                    if ui.interact(mid, egui::Id::unique(("kmid", uid)), Sense::click()).clicked() {
-                        actions.push(("prop.toggleKey".into(), json!({"layer": layer.id.0, "prop": uid})));
-                    }
-                    app.auto.add(&format!("timeline.prop.{uid}.addKey"), mid, "Add or remove keyframe");
-                }
-                // Stopwatch: Alt+click adds an expression; a press toggles the animation, and
-                // dragging on over other stopwatches gives them the same state (#284).
-                if !prop.static_only {
-                    let swr = Rect::from_center_size(pos2(indent, cy), vec2(15.0, 15.0));
-                    let resp = ui.interact(swr, egui::Id::unique(("stopwatch", uid)), Sense::click_and_drag());
-                    let col = if prop.is_animated() {
-                        t.hot_text
-                    } else if resp.hovered() {
-                        t.text
-                    } else {
-                        t.text_dim
-                    };
-                    icons::paint(&lp, swr, Icon::Stopwatch, col);
-                    app.auto.add(&format!("timeline.prop.{uid}.stopwatch"), swr, &prop.name);
-                    if ui.input(|i| i.modifiers.alt) {
-                        if resp.clicked() {
-                            actions.push(("prop.setExpression".into(), json!({"layer": layer.id.0, "prop": uid})));
-                            if prop.expr.is_none() {
-                                // Adding one: its editor opens, comes into view and takes the
-                                // keyboard with the new expression selected (#1072).
-                                app.ui.timeline.expr_closed.remove(uid);
-                                focus_expression(&ctx, *uid, [usize::MAX, 0]);
-                            } else if ctx.data(|d| d.get_temp::<ExprFocus>(expr_focus_id())).is_some_and(|f| f.prop == *uid) {
-                                // Removing it: nothing is left to take the keyboard.
-                                ctx.data_mut(|d| d.remove::<ExprFocus>(expr_focus_id()));
-                            }
-                        }
-                    } else if let Some((value, merge)) = switch_gesture(ui, &resp, r, "stopwatch", prop.is_animated()) {
-                        actions.push(("prop.toggleAnimation".into(), json!({"layer": layer.id.0, "prop": uid, "value": value, "merge": merge})));
-                    } else if resp.clicked() && !resp.clicked_by(egui::PointerButton::Primary) {
-                        // Keyboard or accessibility activation.
-                        actions.push(("prop.toggleAnimation".into(), json!({"layer": layer.id.0, "prop": uid})));
-                    }
-                }
-                let name_x = indent + 12.0;
-                // 3D layers show Rotation as "Z Rotation" next to X/Y Rotation.
-                let is_tr_rot = layer.transform().and_then(|t| t.get("rotation")).is_some_and(|r| r.uid == prop.uid);
-                let base = if is_tr_rot && prop.name == "Rotation" && layer.is_3d() { "Z Rotation".to_string() } else { prop.name.clone() };
-                let pname = if prop.has_expression() { format!("{base}  =") } else { base };
-                lp.text(pos2(name_x, cy), Align2::LEFT_CENTER, &pname, Tokens::ui(12.0), if prop.has_expression() { t.expr_text } else { t.text });
-                let name_rect = Rect::from_min_max(pos2(name_x, r.min.y), pos2(cw.switches - 2.0, r.max.y));
-                let name_resp = ui.interact(name_rect, egui::Id::unique(("pname", uid)), Sense::click_and_drag());
-                app.auto.add(&format!("timeline.prop.{uid}.name"), name_rect, &prop.name);
-                if name_resp.drag_started() {
-                    // Drop on the Essential Graphics panel to expose the property.
-                    egui::DragAndDrop::set_payload(&ctx, crate::panels::DragPayload::Property { layer: layer.id.0, prop: *uid });
-                }
-                if name_resp.dragged() {
-                    egui::Tooltip::always_open(ctx.clone(), ui.layer_id(), egui::Id::unique("prop-drag-tip"), egui::PopupAnchor::Pointer)
-                        .show(|ui| ui.label(&prop.name));
-                }
-                if name_resp.clicked() {
-                    actions.push(("prop.select".into(), json!({"layer": layer.id.0, "prop": uid, "add": ui.input(|i| i.modifiers.shift)})));
-                }
-                crate::widgets::context_menu(&name_resp, |ui| prop_menu(ui, &mut app.auto, cid, layer, prop, &mut actions));
-                // Value editors.
-                let value = ectx.value(layer, prop);
-                let vx = (cw.switches + 4.0).max(name_x + 120.0);
-                let dims = value_editor(app, ui, &lp, layer, prop, &value, pos2(vx, cy), &mut actions);
-                if !dims.is_empty() {
-                    dim_hits.push((*uid, dims));
-                }
-                // The property pick whip (Parent & Link column, AE CC 2018 and later): dropped on
-                // a property it links this one to it, adding the expression if there is none.
-                if vis.parent && !prop.static_only {
-                    pick_whip(
-                        app,
-                        ui,
-                        &lp,
-                        Rect::from_center_size(pos2(cw.parent + 9.0, cy), vec2(15.0, 15.0)),
-                        (WHIP_PROP, layer.id.0, *uid),
-                        &format!("timeline.prop.{uid}.propertyPickWhip"),
-                        "Property pick whip",
-                        crate::i18n::tr("Property pick whip: drag onto a property"),
-                    );
-                }
-                ui.set_clip_rect(right_clip);
-                // Expression text row hint.
-                if let Some(e) = prop.expr.as_ref().filter(|e| e.enabled && app.ui.timeline.expr_closed.contains(uid)) {
-                    gp.text(
-                        pos2(graph_x0 + 8.0, cy),
-                        Align2::LEFT_CENTER,
-                        format!("= {}", e.text.lines().next().unwrap_or("")),
-                        Tokens::mono(11.0),
-                        t.expr_text,
-                    );
-                }
-                // Keyframes.
-                if !graph_on {
-                    for k in &prop.keys {
-                        let ct = layer.comp_time(k.time);
-                        let x = tm.x(ct.seconds());
-                        if x < graph_x0 - 8.0 || x > rect.max.x + 8.0 {
-                            continue;
-                        }
-                        let kref = effectcraft_engine::KeyRef { layer: layer.id, prop: *uid, time: k.time };
-                        let ks = sel_keys.contains(&kref);
-                        let icon = k.icon();
-                        let c = pos2(x, cy);
-                        // Labelled keys take their label colour (brighter when selected).
-                        let kcol = match effectcraft_engine::color::Label::ALL.get(k.label as usize).filter(|_| k.label > 0) {
-                            Some(l) => {
-                                let c = t.label(*l);
-                                if ks { c } else { c.gamma_multiply(0.75) }
-                            }
-                            None if ks => t.keyframe_selected,
-                            None => t.keyframe,
-                        };
-                        if k.roving {
-                            // Roving keys: a small dot (their time follows their neighbours).
-                            gp.circle_filled(c, 2.5, kcol);
-                        } else {
-                            icons::keyframe(&gp, c, 11.0, icon.left, icon.right, kcol);
-                        }
-                        let kr = Rect::from_center_size(c, vec2(12.0, 14.0));
-                        let kresp = ui.interact(kr, egui::Id::unique(("key", uid, k.time.0)), Sense::click_and_drag());
-                        app.auto.add(&format!("timeline.key.{uid}.{}", fr.frame_at(ct)), kr, &format!("{} key", prop.name));
-                        // Exact (layer-time ticks): keys a Quick Offset puts on subframes can share a frame.
-                        app.auto.add(&format!("timeline.keyAt.{uid}.{}", k.time.0), kr, &format!("{} key", prop.name));
-                        let mods = ui.input(|i| i.modifiers);
-                        let this_key = json!({"keys": [{"layer": layer.id.0, "prop": uid, "time": k.time.seconds()}], "selectProperties": true});
-                        if kresp.clicked() && mods.command {
-                            // Ctrl+click: Linear ↔ Auto Bezier; Ctrl+Alt+click: Hold on / off.
-                            actions.push(("keys.select".into(), this_key.clone()));
-                            if mods.alt {
-                                actions.push(("keys.toggleHold".into(), json!({})));
-                            } else {
-                                let linear = k.in_interp == Interp::Linear && k.out_interp == Interp::Linear;
-                                actions.push(("keys.interpolation".into(), json!({"interpolation": if linear { "autoBezier" } else { "linear" }})));
-                            }
-                        } else if kresp.clicked() && mods.shift {
-                            // Shift+click: in or out of the selection.
-                            let mut p = this_key.clone();
-                            p["toggle"] = json!(true);
-                            actions.push(("keys.select".into(), p));
-                        } else if (kresp.clicked() || kresp.drag_started()) && !ks {
-                            let mut p = this_key.clone();
-                            p["add"] = json!(mods.shift);
-                            actions.push(("keys.select".into(), p));
-                        }
-                        if kresp.double_clicked() {
-                            // Edit the key's value (numeric properties), as After Effects does.
-                            if matches!(k.value, Value::Scalar(_) | Value::Vec2(_) | Value::Vec3(_)) {
-                                actions.push(("keys.set".into(), json!({"layer": layer.id.0, "prop": uid, "time": k.time.seconds()})));
-                            } else {
-                                ui_actions.push(UiAct::SetTime(ct));
-                            }
-                        }
-                        crate::widgets::context_menu(&kresp, |ui| {
-                            for (lbl, cmd, params) in [
-                                ("Edit Value…", "keys.set", json!({"layer": layer.id.0, "prop": uid, "time": k.time.seconds()})),
-                                ("-", "", json!({})),
-                                ("Copy", "keys.copy", json!({})),
-                                ("Paste", "keys.paste", json!({})),
-                                ("-", "", json!({})),
-                                ("Select Equal Keyframes", "keys.selectEqual", json!({})),
-                                ("Select Previous Keyframes", "keys.selectPrevious", json!({})),
-                                ("Select Following Keyframes", "keys.selectFollowing", json!({})),
-                                ("-", "", json!({})),
-                                ("Keyframe Interpolation…", "keys.interpolation", json!({})),
-                                ("Keyframe Velocity…", "keys.velocity", json!({})),
-                                ("Toggle Hold Keyframe", "keys.toggleHold", json!({})),
-                                ("Rove Across Time", "keys.interpolation", json!({"roving": !k.roving})),
-                                ("-", "", json!({})),
-                                ("Easy Ease", "keys.easyEase", json!({})),
-                                ("Easy Ease In", "keys.easyEaseIn", json!({})),
-                                ("Easy Ease Out", "keys.easyEaseOut", json!({})),
-                                ("Time-Reverse Keyframes", "keys.timeReverse", json!({})),
-                                ("-", "", json!({})),
-                                ("Linear", "keys.interpolation", json!({"interpolation": "linear"})),
-                                ("Bezier", "keys.interpolation", json!({"interpolation": "bezier"})),
-                                ("Auto Bezier", "keys.interpolation", json!({"interpolation": "autoBezier"})),
-                                ("Select All Keyframes", "keys.selectAll", json!({})),
-                                ("Delete", "keys.delete", json!({})),
-                            ] {
-                                if lbl == "Select All Keyframes" {
-                                    // Keyframe colour labels.
-                                    ui.menu_button(crate::i18n::tr("Label"), |ui| {
-                                        for (i, l) in effectcraft_engine::color::Label::ALL.into_iter().enumerate() {
-                                            if widgets::label_entry(ui, l, &app.session.prefs.label_name(l), k.label as usize == i, &t).clicked() {
-                                                if !ks {
-                                                    actions.push((
-                                                        "keys.select".into(),
-                                                        json!({"keys": [{"layer": layer.id.0, "prop": uid, "time": k.time.seconds()}]}),
-                                                    ));
-                                                }
-                                                actions.push(("keys.setLabel".into(), json!({"label": i})));
-                                                ui.close();
-                                            }
-                                        }
-                                    });
-                                }
-                                if lbl == "-" {
-                                    ui.separator();
-                                    continue;
-                                }
-                                if lbl == "Rove Across Time" && !prop.spatial {
-                                    continue;
-                                }
-                                if lbl == "Edit Value…" && !matches!(k.value, Value::Scalar(_) | Value::Vec2(_) | Value::Vec3(_)) {
-                                    continue;
-                                }
-                                if ui.button(lbl).clicked() {
-                                    if !ks {
-                                        actions.push(("keys.select".into(), json!({"keys": [{"layer": layer.id.0, "prop": uid, "time": k.time.seconds()}]})));
-                                    }
-                                    actions.push((cmd.into(), params));
-                                    ui.close();
-                                }
-                            }
-                        });
-                        // Alt-drag the first or last key of a selected group: scale the group in time.
-                        if kresp.drag_started()
-                            && mods.alt
-                            && !mods.command
-                            && let Some(c) = app.session.active_comp_arc()
-                        {
-                            super::graph_tools::alt_scale_begin(app, &ctx, &c, ct.seconds());
-                        }
-                        // A plain drag moves the selected keys. The timeline follows it (below): this
-                        // widget's id changes with the key's time, so its own drag would end after
-                        // the first frame of movement.
-                        // (From where the button went down: a drag starts a few pixels later.)
-                        if kresp.drag_started()
-                            && !super::graph_tools::alt_scale_active(&ctx)
-                            && let Some(p) = ctx.input(|i| i.pointer.press_origin())
-                        {
-                            // Ctrl/Cmd+Alt: Quick Offset of the selected keys' layers (#1012).
-                            let quick = (mods.command && mods.alt && ks).then(|| quick_offset_layers(&comp, sel_keys.iter().map(|k| k.layer))).flatten();
-                            ctx.data_mut(|d| d.insert_temp(key_drag_id(), KeyDrag { origin_x: p.x, anchor: ct.seconds(), applied: 0, quick }));
-                        }
-                    }
+            ctx.data_mut(|d| d.insert_temp(acc_id, acc));
+        }
+        if gresp.drag_stopped() {
+            ctx.data_mut(|d| d.remove::<f32>(acc_id));
+            ui_actions.push(UiAct::EndMerge);
+        }
+    }
+}
+
+/// The source extent behind the bar (striped past its ends).
+fn layer_source_extent(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, bar: Rect, lc: Color32) {
+    let tm = g.tl.tm;
+    let gp = g.gp.clone();
+    let layer = rc.layer;
+    let r = rc.r;
+    if let LayerSource::Footage { .. } | LayerSource::Comp { .. } = layer.source
+        && let Some(d) = layer.source.item().and_then(|i| app.session.project.item(i)).and_then(|i| i.duration())
+    {
+        let xs = tm.x(layer.start_time.seconds());
+        let xe = tm.x(layer.comp_time(d).seconds());
+        let ghost = Rect::from_min_max(pos2(xs.min(xe), r.min.y + 9.0), pos2(xs.max(xe), r.max.y - 9.0));
+        gp.rect_filled(ghost, 1.0, lc.gamma_multiply(0.18));
+        // The bar past the source's end (its last frame held) or before its start
+        // is striped, so the source's own span shows (#290). Time remapping
+        // decides what shows there itself.
+        if layer.props.get("timeRemap").is_none() {
+            for (side, part) in [
+                ("beforeSource", Rect::from_min_max(bar.min, pos2(ghost.min.x, bar.max.y))),
+                ("afterSource", Rect::from_min_max(pos2(ghost.max.x, bar.min.y), bar.max)),
+            ] {
+                if part.width() >= 1.0 {
+                    stripes(&gp, part, lc);
+                    app.auto.add(&format!("timeline.layer.{}.bar.{side}", layer.id.0), part, "Past the source");
                 }
             }
         }
+        slip_source_handles(app, ui, g, rc, ghost, bar);
     }
+}
+
+/// The bar's move body and trim edges, click selection.
+fn layer_bar_hits(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, bar: Rect) -> BarResps {
+    let cid = g.tl.cid;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let rows = &g.tl.rows;
+    let actions = &mut g.tl.actions;
+    let selected = &g.selected;
+    let layer = rc.layer;
+    let is_sel = rc.is_sel;
+    app.auto.add(&format!("timeline.layer.{}.bar", layer.id.0), bar, &layer.name);
+    // Interactions: move body, trim edges.
+    let (body_r, in_r, out_r) = trim_zones(bar);
+    let body = ui.interact(body_r, egui::Id::unique(("bar", layer.id.0)), Sense::click_and_drag());
+    let lin = ui.interact(in_r, egui::Id::unique(("bar-in", layer.id.0)), Sense::drag());
+    let lout = ui.interact(out_r, egui::Id::unique(("bar-out", layer.id.0)), Sense::drag());
+    app.auto.add(&format!("timeline.layer.{}.bar.in", layer.id.0), in_r, "Trim In");
+    app.auto.add(&format!("timeline.layer.{}.bar.out", layer.id.0), out_r, "Trim Out");
+    if lin.hovered() || lout.hovered() || lin.dragged() || lout.dragged() {
+        trim_cursor(&ctx);
+    }
+    if body.double_clicked()
+        && let Some(a) = double_click_action(layer)
+    {
+        actions.push(a);
+    }
+    let shift = ui.input(|i| i.modifiers.shift);
+    if let Some(layers) = (body.clicked() && shift).then(|| shift_range(&ctx, cid, &comp, rows, selected, layer.id)).flatten() {
+        // Shift-click: the layers from the last one clicked to this one, as in
+        // the layer outline.
+        actions.push(("layer.select".into(), json!({"layers": layers})));
+    } else {
+        if (body.clicked() || body.drag_started()) && !is_sel {
+            actions.push(("layer.select".into(), json!({"layers": [layer.id.0], "add": shift})));
+        }
+        if (body.clicked() || body.drag_started()) && !shift {
+            set_anchor(&ctx, cid, layer.id);
+        }
+    }
+    layer_context_menu(&body, &comp, layer, selected, LayerMenuCaps::of(&app.session.project, layer), &mut app.auto, &mut *actions);
+    BarResps { body, lin, lout }
+}
+
+fn layer_quick_offset_begin(ui: &mut egui::Ui, g: &Rw, rc: &RowCtx<'_>, body: &egui::Response) -> bool {
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let selected = &g.selected;
+    let layer = rc.layer;
+    let is_sel = rc.is_sel;
+    let mods = ui.input(|i| i.modifiers);
+    if body.drag_started()
+        && is_sel
+        && mods.command
+        && mods.alt
+        && let Some(n) = quick_offset_layers(&comp, selected.iter().copied())
+        && let Some(p) = ctx.input(|i| i.pointer.press_origin())
+    {
+        ctx.data_mut(|d| d.insert_temp(quick_bar_id(), QuickBar { layer: layer.id, origin_x: p.x, layers: n, applied: 0 }));
+    }
+    ctx.data(|d| d.get_temp::<QuickBar>(quick_bar_id())).is_some_and(|q| q.layer == layer.id)
+}
+
+/// Moving and trimming a layer bar by whole frames.
+fn layer_bar_drag(g: &mut Rw, rc: &RowCtx<'_>, bars: &BarResps, quick: bool) {
+    let BarResps { body, lin, lout } = bars;
+    let pps = g.tl.pps;
+    let fd = g.tl.fd;
+    let ctx = g.tl.ctx.clone();
+    let actions = &mut g.tl.actions;
+    let selected = &g.selected;
+    let ui_actions = &mut g.ui_actions;
+    let layer = rc.layer;
+    let drag_key = format!("bar-{}", layer.id.0);
+    for (resp, kind) in [(&body, "move"), (&lin, "in"), (&lout, "out")] {
+        if kind == "move" && quick {
+            continue;
+        }
+        if resp.dragged() {
+            let acc_id = egui::Id::unique(("bar-acc", layer.id.0, kind));
+            let mut acc: f32 = ctx.data(|d| d.get_temp(acc_id).unwrap_or(0.0));
+            acc += resp.drag_delta().x;
+            let frames = ((acc as f64 / pps) / fd).trunc() as i64;
+            if frames != 0 {
+                acc -= (frames as f64 * fd * pps) as f32;
+                let d = frames as f64 * fd;
+                // Moving or trimming a selected layer acts on the whole
+                // selection; each layer trims from its own in/out point.
+                let targets = json!(edited_layers(layer.id, selected));
+                let params = match kind {
+                    "move" => json!({"layers": targets, "delta": d, "merge": drag_key}),
+                    "in" => json!({"layers": targets, "inDelta": d, "merge": drag_key}),
+                    _ => json!({"layers": targets, "outDelta": d, "merge": drag_key}),
+                };
+                actions.push(("layer.timing".into(), params));
+            }
+            ctx.data_mut(|d| d.insert_temp(acc_id, acc));
+        }
+        if resp.drag_stopped() {
+            ctx.data_mut(|d| d.remove::<f32>(egui::Id::unique(("bar-acc", layer.id.0, kind))));
+            ui_actions.push(UiAct::EndMerge);
+        }
+    }
+}
+
+fn layer_bar_markers(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Rw, rc: &RowCtx<'_>) {
+    let graph_x0 = g.tl.graph_x0;
+    let tm = g.tl.tm;
+    let rows_rect = g.tl.rows_rect;
+    let comp = g.tl.comp.clone();
+    let layer = rc.layer;
+    let r = rc.r;
+    let gclip = rows_rect.intersect(Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max));
+    super::markers_ui::layer_markers(app, ui, gclip, &comp, layer, tm, r);
+}
+
+/// The group row's background and effect label bar; returns the name to draw.
+fn group_background(app: &mut EffectcraftApp, g: &Rw, rc: &RowCtx<'_>) -> String {
+    let t = g.tl.t;
+    let graph_x0 = g.tl.graph_x0;
+    let lp = g.lp.clone();
+    let gp = g.gp.clone();
+    let layer = rc.layer;
+    let r = rc.r;
+    let left = rc.left;
+    let ri = rc.ri;
+    let RowKind::Group { uid, name, .. } = &rc.row.kind else { return String::new() };
+    let group = layer.props.find_group(*uid);
+    let shown = match group.and_then(|g| match &g.kind {
+        GroupKind::Effect { effect } => Some(effect.as_str()),
+        _ => None,
+    }) {
+        Some(effect) => crate::i18n::effects::group(effect, name),
+        None => name.clone(),
+    };
+    // Selected groups (an effect, a mask, a shape group…) highlight like selected
+    // property rows.
+    let sel_group = app.session.state.selected_props.contains(&(layer.id, *uid));
+    lp.rect_filled(
+        left,
+        0.0,
+        if sel_group {
+            t.row_selected
+        } else if ri.is_multiple_of(2) {
+            t.row
+        } else {
+            t.row_alt
+        },
+    );
+    gp.rect_filled(Rect::from_min_max(pos2(graph_x0, r.min.y), r.max), 0.0, t.tl_bg);
+    // An effect's colour label (26.5): the same bar the Effect Controls header wears,
+    // on the row's left edge.
+    if let Some(lab) =
+        group.filter(|g| matches!(g.kind, GroupKind::Effect { .. })).and_then(|g| g.label).filter(|l| *l != effectcraft_engine::color::Label::None)
+    {
+        let [lr, lg, lb] = app.session.prefs.label_rgb(lab);
+        let bar = Rect::from_min_size(left.min, vec2(4.0, left.height()));
+        lp.rect_filled(bar, 0.0, Color32::from_rgb(lr, lg, lb));
+        app.auto.add(&format!("timeline.group.{uid}.label"), bar, &app.session.prefs.label_name(lab));
+    }
+    shown
+}
+
+/// The group's twirl, effect switch and style eye.
+fn group_switches(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let ui_actions = &mut g.ui_actions;
+    let layer = rc.layer;
+    let cy = rc.cy;
+    let indent = rc.indent;
+    let RowKind::Group { uid, name, open, has_children, fx, eye, .. } = &rc.row.kind else { return };
+    if *has_children {
+        let tw = Rect::from_center_size(pos2(indent, cy), vec2(13.0, 13.0));
+        if widgets::twirl(ui, tw, *open, egui::Id::unique(("gtw", uid)), &t).clicked() {
+            // Alt/Cmd-click twirls the whole tree under the group (as on a layer).
+            ui_actions.push(UiAct::ToggleGroup(layer.id.0, *uid, ui.input(|i| i.modifiers.alt || i.modifiers.command)));
+        }
+        app.auto.add(&format!("timeline.group.{uid}.twirl"), tw, name);
+    }
+    if let Some(en) = fx {
+        let fr_ = Rect::from_center_size(pos2(cw.switches + SW * 3.0 + SW / 2.0, cy), vec2(16.0, 16.0));
+        if widgets::icon_toggle(ui, fr_, Icon::Fx, *en, &t, egui::Id::unique(("gfx", uid)), Sense::click()).clicked() {
+            actions.push(("effect.toggle".into(), json!({"layer": layer.id.0, "effect": uid})));
+        }
+        app.auto.add(&format!("timeline.group.{uid}.fx"), fr_, name);
+    }
+    if let Some(en) = eye {
+        // A layer style's or shape item's eye switch in the A/V column, like AE.
+        let er = Rect::from_center_size(pos2(cw.av + 10.0, cy), vec2(15.0, 15.0));
+        lp.rect_stroke(er.shrink(1.5), 2.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
+        if widgets::icon_toggle(ui, er, Icon::Eye, *en, &t, egui::Id::unique(("geye", uid)), Sense::click()).clicked() {
+            let style = layer.props.sub(effectcraft_engine::project::styles::GROUP).is_some_and(|s| s.find_group(*uid).is_some());
+            actions.push(if style {
+                ("layer.style.toggle".into(), json!({"layer": layer.id.0, "style": uid}))
+            } else {
+                ("prop.setGroupEnabled".into(), json!({"layer": layer.id.0, "prop": uid, "value": !*en}))
+            });
+        }
+        app.auto.add(&format!("timeline.group.{uid}.eye"), er, name);
+    }
+}
+
+/// The group name, or its rename field.
+fn group_name(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, shown: &str) {
+    let t = g.tl.t;
+    let ctx = g.tl.ctx.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let layer = rc.layer;
+    let r = rc.r;
+    let cy = rc.cy;
+    let indent = rc.indent;
+    let RowKind::Group { uid, name, .. } = &rc.row.kind else { return };
+    let group_edit: Option<(u64, u64, String)> = ctx.data(|d| d.get_temp(group_rename_id()));
+    if let Some((_, _, mut buf)) = group_edit.filter(|(rl, ru, _)| *rl == layer.id.0 && ru == uid) {
+        let field = Rect::from_min_max(pos2(indent + 8.0, r.min.y + 2.0), pos2((cw.switches - 4.0).max(indent + 60.0), r.max.y - 2.0));
+        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(field));
+        let er = child.add(egui::TextEdit::singleline(&mut buf).font(Tokens::ui(12.0)).desired_width(field.width()));
+        app.auto.add(&format!("timeline.group.{uid}.nameEdit"), er.rect, &buf);
+        if ctx.data_mut(|d| d.remove_temp::<bool>(rename_focus_id())).unwrap_or(false) {
+            er.request_focus();
+            widgets::select_all(&ctx, er.id, &buf);
+        }
+        if er.lost_focus() {
+            if !ui.input(|i| i.key_pressed(egui::Key::Escape)) && !buf.trim().is_empty() && buf != *name {
+                actions.push(("prop.renameGroup".into(), json!({"layer": layer.id.0, "prop": uid, "name": buf})));
+            }
+            ctx.data_mut(|d| d.remove::<(u64, u64, String)>(group_rename_id()));
+        } else {
+            ctx.data_mut(|d| d.insert_temp(group_rename_id(), (layer.id.0, *uid, buf)));
+        }
+    } else {
+        lp.text(pos2(indent + 10.0, cy), Align2::LEFT_CENTER, shown, Tokens::ui(12.0), t.text);
+    }
+}
+
+/// Add / animate popups, Change Renderer and dash buttons.
+fn group_popups(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let ctx = g.tl.ctx.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let ui_actions = &mut g.ui_actions;
+    let layer = rc.layer;
+    let cy = rc.cy;
+    let RowKind::Group { uid, .. } = &rc.row.kind else { return };
+    text_anim_popups(app, ui, &lp, layer, *uid, pos2(cw.switches, cy), &mut *actions);
+    shape_add_popup(app, ui, &lp, layer, *uid, pos2(cw.switches, cy), &mut *actions);
+    if *uid == GEOM_BIT | layer.id.0 {
+        let lr = lp.text(pos2(cw.switches + 6.0, cy), Align2::LEFT_CENTER, crate::i18n::tr("Change Renderer…"), Tokens::ui(11.5), t.accent);
+        let resp = ui
+            .interact(lr, egui::Id::unique(("tl-change-renderer", layer.id.0)), Sense::click())
+            .on_hover_text(crate::i18n::tr("Composition Settings ▸ 3D Renderer"));
+        if resp.hovered() {
+            ctx.set_cursor_icon(egui::CursorIcon::PointingHand);
+        }
+        app.auto.add(&format!("timeline.layer.{}.changeRenderer", layer.id.0), lr, "Change Renderer…");
+        if resp.clicked() {
+            ui_actions.push(UiAct::ChangeRenderer);
+        }
+    }
+    dash_buttons(app, ui, &lp, layer, *uid, pos2(cw.switches, cy), &mut *actions);
+}
+
+/// Mask mode and inverted, inline.
+fn group_mask_mode(ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let layer = rc.layer;
+    let cy = rc.cy;
+    let RowKind::Group { uid, .. } = &rc.row.kind else { return };
+    // Mask mode + inverted inline.
+    if let Some(g) = layer.props.find_group(*uid)
+        && let GroupKind::Mask { mode, inverted, .. } = g.kind
+    {
+        let mr = Rect::from_min_size(pos2(cw.switches + 4.0, cy - 9.0), vec2(80.0, 18.0));
+        let pop = egui::Id::unique(("maskmode", uid));
+        if widgets::dropdown(ui, mr, mode.label(), &t, egui::Id::unique(("mm", uid))).clicked() {
+            widgets::open_popup(ui, pop);
+        }
+        let opts: Vec<String> = effectcraft_engine::project::MaskMode::ALL.iter().map(|m| m.label().to_string()).collect();
+        if let Some(i) = widgets::popup_menu(ui, pop, mr.left_bottom(), &opts, None) {
+            actions.push(("layer.setMask".into(), json!({"layer": layer.id.0, "mask": uid, "mode": opts[i]})));
+        }
+        let ir = Rect::from_min_size(pos2(mr.max.x + 8.0, cy - 8.0), vec2(16.0, 16.0));
+        if widgets::checkbox(ui, ir, inverted, &t, egui::Id::unique(("minv", uid))).changed() {
+            actions.push(("layer.setMask".into(), json!({"layer": layer.id.0, "mask": uid, "inverted": !inverted})));
+        }
+        lp.text(pos2(ir.max.x + 4.0, cy), Align2::LEFT_CENTER, crate::i18n::tr("Inverted"), Tokens::ui(11.0), t.text_dim);
+    }
+}
+
+/// Group row click and double-click.
+fn group_row_click(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>) {
+    let cid = g.tl.cid;
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let ui_actions = &mut g.ui_actions;
+    let layer = rc.layer;
+    let r = rc.r;
+    let indent = rc.indent;
+    let RowKind::Group { uid, name, fx, .. } = &rc.row.kind else { return };
+    let gr_rect = Rect::from_min_max(pos2(indent + 8.0, r.min.y), pos2(cw.switches, r.max.y));
+    // Effects, masks, shape items and animators drag to a new place among their siblings.
+    let movable = !layer.switches.locked && layer.props.find_group(*uid).is_some_and(PropGroup::is_instance);
+    let gr = ui.interact(gr_rect, egui::Id::unique(("grow", uid)), if movable { Sense::click_and_drag() } else { Sense::click() });
+    if movable && gr.drag_started_by(egui::PointerButton::Primary) {
+        ui.ctx().data_mut(|d| d.insert_temp(group_drag_id(), GroupDrag { comp: cid, owner: gr.id, layer: layer.id, uid: *uid }));
+    }
+    app.auto.add(&format!("timeline.group.{uid}.name"), gr_rect, name);
+    if gr.clicked() && uid & (WAVE_BIT | GEOM_BIT) == 0 {
+        // Shift or Cmd/Ctrl adds the group to the selection, or takes a selected one out, as
+        // property rows and Effect Controls headers do (#2552: several effects and styles for
+        // one animation preset).
+        let add = ui.input(|i| i.modifiers.shift || i.modifiers.command);
+        if add && app.session.state.selected_props.contains(&(layer.id, *uid)) {
+            actions.push(("prop.deselect".into(), json!({"layer": layer.id.0, "prop": uid})));
+        } else {
+            actions.push(("prop.select".into(), json!({"layer": layer.id.0, "prop": uid, "selectKeys": false, "add": add})));
+        }
+    }
+    if gr.double_clicked() {
+        if fx.is_some() {
+            // An effect's name: open it in Effect Controls (as in After Effects).
+            actions.push(("layer.select".into(), json!({"layers": [layer.id.0]})));
+            actions.push(("prop.select".into(), json!({"layer": layer.id.0, "prop": uid, "selectKeys": false})));
+            actions.push(("window.panel".into(), json!({"panel": "EffectControls"})));
+        } else {
+            ui_actions.push(UiAct::ToggleGroup(layer.id.0, *uid, false));
+        }
+    }
+}
+
+fn waveform_row(app: &mut EffectcraftApp, g: &Rw, rc: &RowCtx<'_>) {
+    let t = g.tl.t;
+    let graph_x0 = g.tl.graph_x0;
+    let tm = g.tl.tm;
+    let ctx = g.tl.ctx.clone();
+    let cw = &g.tl.cw;
+    let lp = g.lp.clone();
+    let gp = g.gp.clone();
+    let row = rc.row;
+    let layer = rc.layer;
+    let r = rc.r;
+    let left = rc.left;
+    let cy = rc.cy;
+    let ri = rc.ri;
+    let RowKind::Waveform { item, .. } = &rc.row.kind else { return };
+    lp.rect_filled(left, 0.0, if ri.is_multiple_of(2) { t.row } else { t.row_alt });
+    let indent = cw.name + 6.0 + 14.0 * row.depth as f32;
+    lp.text(pos2(indent + 10.0, cy), Align2::LEFT_CENTER, crate::i18n::tr("Waveform"), Tokens::ui(12.0), t.text);
+    let wr = Rect::from_min_max(pos2(graph_x0, r.min.y), r.max);
+    gp.rect_filled(wr, 0.0, t.tl_bg);
+    app.auto.add(&format!("timeline.layer.{}.waveform", layer.id.0), wr, "Waveform");
+    match super::waveform::summary(app, &ctx, ItemId(*item)) {
+        Some(s) => super::waveform::draw(&gp, wr.shrink2(vec2(0.0, 2.0)), &tm, layer, &s, Color32::from_rgb(0x5f, 0xc8, 0x8a)),
+        None => {
+            gp.text(
+                pos2(tm.x(layer.in_point.seconds()).max(wr.min.x) + 6.0, wr.center().y),
+                Align2::LEFT_CENTER,
+                crate::i18n::tr("Building waveform…"),
+                Tokens::ui(11.0),
+                t.text_faint,
+            );
+        }
+    }
+}
+
+/// The expression row's outline side: enable, pick whip and syntax warning.
+fn expr_controls(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, st: &ExprRow<'_>) {
+    let ExprRow { prop, ex, buf_id, edit_id, .. } = *st;
+    let t = g.tl.t;
+    let ctx = g.tl.ctx.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let row = rc.row;
+    let layer = rc.layer;
+    let left = rc.left;
+    let cy = rc.cy;
+    let ri = rc.ri;
+    let RowKind::Expr { uid, .. } = &rc.row.kind else { return };
+    let sel_prop = app.session.state.selected_props.contains(&(layer.id, *uid));
+    lp.rect_filled(
+        left,
+        0.0,
+        if sel_prop {
+            t.row_selected
+        } else if ri.is_multiple_of(2) {
+            t.row
+        } else {
+            t.row_alt
+        },
+    );
+    let indent = cw.name + 6.0 + 14.0 * row.depth as f32;
+    lp.text(pos2(indent + 12.0, cy), Align2::LEFT_CENTER, crate::i18n::tr("Expression:"), Tokens::ui(11.5), t.text_dim);
+    lp.text(pos2(indent + 82.0, cy), Align2::LEFT_CENTER, &prop.name, Tokens::ui(11.5), t.text);
+    // "=" enable switch and the property pick whip (AE's expression controls).
+    let en_r = Rect::from_center_size(pos2(cw.switches + 10.0, cy), vec2(16.0, 16.0));
+    let en = ui.interact(en_r, egui::Id::unique(("expr-en", uid)), Sense::click()).on_hover_text(crate::i18n::tr("Enable Expression"));
+    lp.rect_stroke(en_r.shrink(1.0), 2.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
+    let expr_col = t.expr_text;
+    lp.text(en_r.center(), Align2::CENTER_CENTER, if ex.enabled { "=" } else { "≠" }, Tokens::semibold(13.0), if ex.enabled { expr_col } else { t.text_dim });
+    app.auto.add(&format!("timeline.prop.{uid}.exprEnable"), en_r, "Enable Expression");
+    if en.clicked() {
+        actions.push(("prop.setExpression".into(), json!({"layer": layer.id.0, "prop": uid, "enabled": !ex.enabled})));
+    }
+    let pw = pick_whip(
+        app,
+        ui,
+        &lp,
+        Rect::from_center_size(pos2(cw.switches + 30.0, cy), vec2(15.0, 15.0)),
+        (WHIP_EXPR, layer.id.0, *uid),
+        WhipText {
+            auto: &format!("timeline.prop.{uid}.pickWhip"),
+            label: "Expression pick whip",
+            hint: crate::i18n::tr("Expression pick whip: drag onto a property"),
+        },
+    );
+    if pw.is_pointer_button_down_on() && ui.input(|i| i.pointer.primary_pressed()) {
+        // Pressed while the expression is being edited (its text is buffered while
+        // the editor has the focus): the reference will go in at the cursor,
+        // replacing the selection (#284).
+        let into = ctx.data(|d| d.get_temp::<String>(buf_id)).map(|buf| {
+            let n = buf.chars().count();
+            let sel = egui::text_edit::TextEditState::load(&ctx, edit_id)
+                .and_then(|st| st.cursor.char_range())
+                .map_or([n, n], |r| [r.primary.index.0.min(r.secondary.index.0).min(n), r.primary.index.0.max(r.secondary.index.0).min(n)]);
+            (buf, sel)
+        });
+        ctx.data_mut(|d| {
+            if let Some(into) = into {
+                d.insert_temp(whip_into_id(*uid), into);
+            } else {
+                d.remove::<WhipInto>(whip_into_id(*uid));
+            }
+        });
+    }
+    // Syntax errors: warning in the outline (the expression is disabled).
+    if let Some(check) = app.session.expr_check
+        && let Err(e) = check(&ex.text)
+    {
+        let wr = Rect::from_center_size(pos2(cw.switches + 50.0, cy), vec2(14.0, 14.0));
+        lp.text(wr.center(), Align2::CENTER_CENTER, "⚠", Tokens::ui(12.0), Color32::from_rgb(0xf0, 0xa0, 0x30));
+        let _ = ui.interact(wr, egui::Id::unique(("expr-err", uid)), Sense::hover()).on_hover_text(e);
+    }
+}
+
+/// The Expression Language menu inserts at the cursor.
+fn expr_language_menu(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, st: &ExprRow<'_>) {
+    let ExprRow { ex, buf_id, edit_id, .. } = *st;
+    let t = g.tl.t;
+    let ctx = g.tl.ctx.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let layer = rc.layer;
+    let cy = rc.cy;
+    let RowKind::Expr { uid, .. } = &rc.row.kind else { return };
+    // ⓕ: the Expression Language menu inserts at the cursor.
+    let lang_r = Rect::from_center_size(pos2(cw.switches + 70.0, cy), vec2(16.0, 16.0));
+    let lang = ui.interact(lang_r, egui::Id::unique(("expr-lang", uid)), Sense::click()).on_hover_text(crate::i18n::tr("Expression Language Menu"));
+    lp.circle_stroke(lang_r.center(), 6.5, Stroke::new(1.0, if lang.hovered() { t.text } else { t.text_dim }));
+    lp.text(lang_r.center(), Align2::CENTER_CENTER, "f", Tokens::semibold(10.0), if lang.hovered() { t.text } else { t.text_dim });
+    app.auto.add(&format!("timeline.prop.{uid}.exprLanguage"), lang_r, "Expression Language Menu");
+    let mut picked: Option<&'static str> = None;
+    egui::Popup::menu(&lang).style(crate::widgets::menu_style).show(|ui| {
+        for (cat, items) in effectcraft_engine::commands::expr_tools::language_menu() {
+            ui.menu_button(cat, |ui| {
+                widgets::menu_scroll(ui, false, |ui| {
+                    for (label, text) in items {
+                        if ui.button(label).clicked() {
+                            picked = Some(text);
+                            ui.close();
+                        }
+                    }
+                })
+            });
+        }
+    });
+    if let Some(text) = picked {
+        let cur: String = ctx.data(|d| d.get_temp(buf_id)).unwrap_or_else(|| ex.text.clone());
+        let at = egui::text_edit::TextEditState::load(&ctx, edit_id)
+            .and_then(|st| st.cursor.char_range())
+            .map(|r| r.primary.index.0)
+            .unwrap_or(cur.chars().count())
+            .min(cur.chars().count());
+        let byte = cur.char_indices().nth(at).map(|(b, _)| b).unwrap_or(cur.len());
+        let mut next = cur.clone();
+        next.insert_str(byte, text);
+        actions.push(("prop.setExpression".into(), json!({"layer": layer.id.0, "prop": uid, "expression": next})));
+        ctx.data_mut(|d| d.remove::<String>(buf_id));
+    }
+}
+
+/// The expression editor in the time-graph area.
+fn expr_editor_cell(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, st: &ExprRow<'_>) {
+    let ExprRow { prop, ex, buf_id, edit_id, .. } = *st;
+    let t = g.tl.t;
+    let rect = g.tl.rect;
+    let graph_x0 = g.tl.graph_x0;
+    let rh = g.tl.rh;
+    let ctx = g.tl.ctx.clone();
+    let actions = &mut g.tl.actions;
+    let right_clip = g.right_clip;
+    let gp = g.gp.clone();
+    let layer = rc.layer;
+    let r = rc.r;
+    let RowKind::Expr { uid, lines, .. } = &rc.row.kind else { return };
+    let expr_col = t.expr_text;
+    // The editor in the time-graph area.
+    ui.set_clip_rect(right_clip);
+    gp.rect_filled(Rect::from_min_max(pos2(graph_x0, r.min.y), r.max), 0.0, t.expr_bg);
+    let er = Rect::from_min_max(pos2(graph_x0 + 8.0, r.min.y + 3.0), pos2(rect.max.x - 14.0, r.max.y - 3.0));
+    let mut buf: String = ctx.data(|d| d.get_temp(buf_id)).unwrap_or_else(|| ex.text.clone());
+    if let Some(f) = ctx.data(|d| d.get_temp::<ExprFocus>(expr_focus_id())).filter(|f| f.prop == *uid) {
+        // Asked for once (a pick whip put a reference in, or an Alt-click added the
+        // expression): editing starts in the expression as it is now.
+        ctx.data_mut(|d| d.remove::<ExprFocus>(expr_focus_id()));
+        buf = ex.text.clone();
+        let n = buf.chars().count();
+        let [a, b] = f.select.map(|before_end| egui::text::CCursor::new(n.saturating_sub(before_end)));
+        let mut st = egui::text_edit::TextEditState::load(&ctx, edit_id).unwrap_or_default();
+        st.cursor.set_char_range(Some(egui::text::CCursorRange::two(a, b)));
+        st.store(&ctx, edit_id);
+        ctx.memory_mut(|m| m.request_focus(edit_id));
+    }
+    // Settings ▸ Scripting & Expressions ▸ Expressions Editor.
+    let sp = app.session.prefs.scripting.clone();
+    let resp = super::expr_editor::editor(
+        ui,
+        edit_id,
+        &mut buf,
+        er,
+        super::expr_editor::EditorOpts { prefs: &sp, color: if ex.enabled { expr_col } else { t.text_dim }, rows: *lines },
+        &t,
+    );
+    app.auto.add(&format!("timeline.prop.{uid}.expression"), er, &prop.name);
+    // Its bottom edge drags to set its height in whole lines, as in After Effects.
+    let edge = Rect::from_min_max(pos2(er.min.x, r.max.y - 4.0), pos2(er.max.x, r.max.y));
+    let eresp = ui.interact(edge, egui::Id::unique(("expr-edge", uid)), Sense::drag());
+    app.auto.add(&format!("timeline.prop.{uid}.expressionHeight"), edge, "Expression field height");
+    if eresp.hovered() || eresp.dragged() {
+        ctx.set_cursor_icon(egui::CursorIcon::ResizeVertical);
+    }
+    if let Some(py) = eresp.interact_pointer_pos().filter(|_| eresp.dragged()).map(|p| p.y) {
+        let n = ((py - r.min.y) / rh).round().clamp(1.0, EXPR_MAX_LINES as f32);
+        app.ui.timeline.expr_lines.insert(*uid, n as usize);
+    }
+    let commit = resp.has_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter) && (i.modifiers.command || i.modifiers.ctrl));
+    if commit {
+        resp.surrender_focus();
+    }
+    if resp.has_focus() && !commit {
+        ctx.data_mut(|d| d.insert_temp(buf_id, buf));
+    } else {
+        if (resp.lost_focus() || commit) && buf.trim_end() != ex.text {
+            actions.push(("prop.setExpression".into(), json!({"layer": layer.id.0, "prop": uid, "expression": buf.trim_end()})));
+        }
+        ctx.data_mut(|d| d.remove::<String>(buf_id));
+    }
+}
+
+fn prop_background(app: &mut EffectcraftApp, g: &Rw, rc: &RowCtx<'_>, prop: &Property) {
+    let t = g.tl.t;
+    let graph_x0 = g.tl.graph_x0;
+    let lp = g.lp.clone();
+    let gp = g.gp.clone();
+    let layer = rc.layer;
+    let r = rc.r;
+    let left = rc.left;
+    let ri = rc.ri;
+    let uid = &prop.uid;
+
+    app.auto.add(&format!("timeline.prop.{uid}.row"), r, &prop.name);
+    let sel_prop = app.session.state.selected_props.contains(&(layer.id, *uid));
+    lp.rect_filled(
+        left,
+        0.0,
+        if sel_prop {
+            t.row_selected
+        } else if ri.is_multiple_of(2) {
+            t.row
+        } else {
+            t.row_alt
+        },
+    );
+    gp.rect_filled(Rect::from_min_max(pos2(graph_x0, r.min.y), r.max), 0.0, t.tl_bg);
+}
+
+/// The keyframe navigator (previous, toggle, next).
+fn prop_key_navigator(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, prop: &Property) {
+    let t = g.tl.t;
+    let time = g.tl.time;
+    let fr = g.tl.fr;
+    let vis = g.tl.vis;
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let ui_actions = &mut g.ui_actions;
+    let layer = rc.layer;
+    let cy = rc.cy;
+    let uid = &prop.uid;
+
+    // Keyframe navigator (in the A/V column, like AE).
+    // (in the Keys column when it is shown).
+    if prop.is_animated() && (vis.keys || vis.av) {
+        let lt = layer.layer_time(time);
+        let at_key = effectcraft_engine::keyframe::key_at(&prop.keys, lt).is_some();
+        let nav_x = if vis.keys { cw.keys + 12.0 } else { cw.av + 18.0 };
+        let prev = Rect::from_center_size(pos2(nav_x, cy), vec2(12.0, 14.0));
+        let mid = Rect::from_center_size(pos2(nav_x + 16.0, cy), vec2(14.0, 14.0));
+        let next = Rect::from_center_size(pos2(nav_x + 32.0, cy), vec2(12.0, 14.0));
+        icons::paint(&lp, prev.shrink(2.0), Icon::ChevronLeft, t.text_dim);
+        icons::paint(&lp, next.shrink(2.0), Icon::ChevronRight, t.text_dim);
+        let kc = if at_key { t.keyframe_selected } else { Color32::TRANSPARENT };
+        lp.add(egui::Shape::convex_polygon(
+            vec![mid.center() + vec2(0.0, -5.0), mid.center() + vec2(5.0, 0.0), mid.center() + vec2(0.0, 5.0), mid.center() + vec2(-5.0, 0.0)],
+            kc,
+            Stroke::new(1.0, t.text_dim),
+        ));
+        if ui.interact(prev, egui::Id::unique(("kprev", uid)), Sense::click()).clicked()
+            && let Some(k) = prop.keys.iter().rev().find(|k| layer.comp_time(k.time).0 < time.0 - fr.frame_duration().0 / 2)
+        {
+            ui_actions.push(UiAct::SetTime(layer.comp_time(k.time)));
+        }
+        if ui.interact(next, egui::Id::unique(("knext", uid)), Sense::click()).clicked()
+            && let Some(k) = prop.keys.iter().find(|k| layer.comp_time(k.time).0 > time.0 + fr.frame_duration().0 / 2)
+        {
+            ui_actions.push(UiAct::SetTime(layer.comp_time(k.time)));
+        }
+        if ui.interact(mid, egui::Id::unique(("kmid", uid)), Sense::click()).clicked() {
+            actions.push(("prop.toggleKey".into(), json!({"layer": layer.id.0, "prop": uid})));
+        }
+        app.auto.add(&format!("timeline.prop.{uid}.addKey"), mid, "Add or remove keyframe");
+    }
+}
+
+/// The stopwatch.
+fn prop_stopwatch(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, prop: &Property) {
+    let t = g.tl.t;
+    let ctx = g.tl.ctx.clone();
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let layer = rc.layer;
+    let r = rc.r;
+    let cy = rc.cy;
+    let indent = rc.indent;
+    let uid = &prop.uid;
+
+    // Stopwatch: Alt+click adds an expression; a press toggles the animation, and
+    // dragging on over other stopwatches gives them the same state (#284).
+    if !prop.static_only {
+        let swr = Rect::from_center_size(pos2(indent, cy), vec2(15.0, 15.0));
+        let resp = ui.interact(swr, egui::Id::unique(("stopwatch", uid)), Sense::click_and_drag());
+        let col = if prop.is_animated() {
+            t.hot_text
+        } else if resp.hovered() {
+            t.text
+        } else {
+            t.text_dim
+        };
+        icons::paint(&lp, swr, Icon::Stopwatch, col);
+        app.auto.add(&format!("timeline.prop.{uid}.stopwatch"), swr, &prop.name);
+        if ui.input(|i| i.modifiers.alt) {
+            if resp.clicked() {
+                actions.push(("prop.setExpression".into(), json!({"layer": layer.id.0, "prop": uid})));
+                if prop.expr.is_none() {
+                    // Adding one: its editor opens, comes into view and takes the
+                    // keyboard with the new expression selected (#1072).
+                    app.ui.timeline.expr_closed.remove(uid);
+                    focus_expression(&ctx, *uid, [usize::MAX, 0]);
+                } else if ctx.data(|d| d.get_temp::<ExprFocus>(expr_focus_id())).is_some_and(|f| f.prop == *uid) {
+                    // Removing it: nothing is left to take the keyboard.
+                    ctx.data_mut(|d| d.remove::<ExprFocus>(expr_focus_id()));
+                }
+            }
+        } else if let Some((value, merge)) = switch_gesture(ui, &resp, r, "stopwatch", prop.is_animated()) {
+            actions.push(("prop.toggleAnimation".into(), json!({"layer": layer.id.0, "prop": uid, "value": value, "merge": merge})));
+        } else if resp.clicked() && !resp.clicked_by(egui::PointerButton::Primary) {
+            // Keyboard or accessibility activation.
+            actions.push(("prop.toggleAnimation".into(), json!({"layer": layer.id.0, "prop": uid})));
+        }
+    }
+}
+
+/// The property name; returns its x.
+fn prop_name(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, prop: &Property) -> f32 {
+    let t = g.tl.t;
+    let cid = g.tl.cid;
+    let ctx = g.tl.ctx.clone();
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let layer = rc.layer;
+    let r = rc.r;
+    let cy = rc.cy;
+    let indent = rc.indent;
+    let uid = &prop.uid;
+
+    let name_x = indent + 12.0;
+    // 3D layers show Rotation as "Z Rotation" next to X/Y Rotation.
+    let is_tr_rot = layer.transform().and_then(|t| t.get("rotation")).is_some_and(|r| r.uid == prop.uid);
+    let base = if is_tr_rot && prop.name == "Rotation" && layer.is_3d() { "Z Rotation".to_string() } else { prop.name.clone() };
+    let pname = if prop.has_expression() { format!("{base}  =") } else { base };
+    lp.text(pos2(name_x, cy), Align2::LEFT_CENTER, &pname, Tokens::ui(12.0), if prop.has_expression() { t.expr_text } else { t.text });
+    let name_rect = Rect::from_min_max(pos2(name_x, r.min.y), pos2(cw.switches - 2.0, r.max.y));
+    let name_resp = ui.interact(name_rect, egui::Id::unique(("pname", uid)), Sense::click_and_drag());
+    app.auto.add(&format!("timeline.prop.{uid}.name"), name_rect, &prop.name);
+    if name_resp.drag_started() {
+        // Drop on the Essential Graphics panel to expose the property.
+        egui::DragAndDrop::set_payload(&ctx, crate::panels::DragPayload::Property { layer: layer.id.0, prop: *uid });
+    }
+    if name_resp.dragged() {
+        egui::Tooltip::always_open(ctx.clone(), ui.layer_id(), egui::Id::unique("prop-drag-tip"), egui::PopupAnchor::Pointer).show(|ui| ui.label(&prop.name));
+    }
+    if name_resp.clicked() {
+        actions.push(("prop.select".into(), json!({"layer": layer.id.0, "prop": uid, "add": ui.input(|i| i.modifiers.shift)})));
+    }
+    crate::widgets::context_menu(&name_resp, |ui| prop_menu(ui, &mut app.auto, cid, layer, prop, &mut *actions));
+    name_x
+}
+
+/// The value editors and the property pick whip.
+fn prop_value_cell(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, rc: &RowCtx<'_>, ectx: &EvalCtx<'_>, prop: &Property, name_x: f32) {
+    let vis = g.tl.vis;
+    let cw = &g.tl.cw;
+    let actions = &mut g.tl.actions;
+    let lp = g.lp.clone();
+    let dim_hits = &mut g.dim_hits;
+    let layer = rc.layer;
+    let cy = rc.cy;
+    let uid = &prop.uid;
+
+    let value = ectx.value(layer, prop);
+    let vx = (cw.switches + 4.0).max(name_x + 120.0);
+    let ve = ValueEdit::new(ui, &lp, layer, prop, pos2(vx, cy));
+    let dims = value_editor(app, ui, &ve, &value, &mut *actions);
+    if !dims.is_empty() {
+        dim_hits.push((*uid, dims));
+    }
+    // The property pick whip (Parent & Link column, AE CC 2018 and later): dropped on
+    // a property it links this one to it, adding the expression if there is none.
+    if vis.parent && !prop.static_only {
+        pick_whip(
+            app,
+            ui,
+            &lp,
+            Rect::from_center_size(pos2(cw.parent + 9.0, cy), vec2(15.0, 15.0)),
+            (WHIP_PROP, layer.id.0, *uid),
+            WhipText {
+                auto: &format!("timeline.prop.{uid}.propertyPickWhip"),
+                label: "Property pick whip",
+                hint: crate::i18n::tr("Property pick whip: drag onto a property"),
+            },
+        );
+    }
+}
+
+/// The one-line expression hint when its editor is closed.
+fn prop_expression_hint(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Rw, rc: &RowCtx<'_>, prop: &Property) {
+    let t = g.tl.t;
+    let graph_x0 = g.tl.graph_x0;
+    let right_clip = g.right_clip;
+    let gp = g.gp.clone();
+    let cy = rc.cy;
+    let uid = &prop.uid;
+
+    ui.set_clip_rect(right_clip);
+    // Expression text row hint.
+    if let Some(e) = prop.expr.as_ref().filter(|e| e.enabled && app.ui.timeline.expr_closed.contains(uid)) {
+        gp.text(pos2(graph_x0 + 8.0, cy), Align2::LEFT_CENTER, format!("= {}", e.text.lines().next().unwrap_or("")), Tokens::mono(11.0), t.expr_text);
+    }
+}
+
+/// Key click selection and interpolation shortcuts.
+fn key_select(g: &mut Rw, kh: &KeyHit<'_>) {
+    let KeyHit { k, ks, mods, ref kresp, ref this_key, .. } = *kh;
+    let actions = &mut g.tl.actions;
+    if kresp.clicked() && mods.command {
+        // Ctrl+click: Linear ↔ Auto Bezier; Ctrl+Alt+click: Hold on / off.
+        actions.push(("keys.select".into(), this_key.clone()));
+        if mods.alt {
+            actions.push(("keys.toggleHold".into(), json!({})));
+        } else {
+            let linear = k.in_interp == Interp::Linear && k.out_interp == Interp::Linear;
+            actions.push(("keys.interpolation".into(), json!({"interpolation": if linear { "autoBezier" } else { "linear" }})));
+        }
+    } else if kresp.clicked() && mods.shift {
+        // Shift+click: in or out of the selection.
+        let mut p = this_key.clone();
+        p["toggle"] = json!(true);
+        actions.push(("keys.select".into(), p));
+    } else if (kresp.clicked() || kresp.drag_started()) && !ks {
+        let mut p = this_key.clone();
+        p["add"] = json!(mods.shift);
+        actions.push(("keys.select".into(), p));
+    }
+}
+
+fn key_double_click(g: &mut Rw, rc: &RowCtx<'_>, prop: &Property, kh: &KeyHit<'_>) {
+    let KeyHit { k, ct, ref kresp, .. } = *kh;
+    let actions = &mut g.tl.actions;
+    let ui_actions = &mut g.ui_actions;
+    let layer = rc.layer;
+    let uid = &prop.uid;
+
+    if kresp.double_clicked() {
+        // Edit the key's value (numeric properties), as After Effects does.
+        if matches!(k.value, Value::Scalar(_) | Value::Vec2(_) | Value::Vec3(_)) {
+            actions.push(("keys.set".into(), json!({"layer": layer.id.0, "prop": uid, "time": k.time.seconds()})));
+        } else {
+            ui_actions.push(UiAct::SetTime(ct));
+        }
+    }
+}
+
+/// The keyframe right-click menu.
+fn key_context_menu(app: &mut EffectcraftApp, g: &mut Rw, rc: &RowCtx<'_>, prop: &Property, kh: &KeyHit<'_>) {
+    let KeyHit { k, ks, ref kresp, .. } = *kh;
+    let actions = &mut g.tl.actions;
+    let layer = rc.layer;
+    crate::widgets::context_menu(kresp, |ui| key_menu(ui, app, layer, prop, k, ks, actions));
+}
+
+/// The commands of a keyframe's right-click menu, for the Timeline and the Graph Editor alike. They act
+/// on the selected keys, so a menu opened on an unselected key selects it first. A locked layer's keys
+/// can still be copied and selected, but not edited.
+pub(crate) fn key_menu(
+    ui: &mut egui::Ui,
+    app: &EffectcraftApp,
+    layer: &Layer,
+    prop: &Property,
+    k: &effectcraft_engine::keyframe::Keyframe,
+    selected: bool,
+    actions: &mut Vec<(String, serde_json::Value)>,
+) {
+    let t = app.tokens;
+    let locked = layer.switches.locked;
+    let uid = &prop.uid;
+    let this_key = json!({"layer": layer.id.0, "prop": uid, "time": k.time.seconds()});
+    for (lbl, cmd, params) in [
+        ("Edit Value…", "keys.set", this_key.clone()),
+        ("-", "", json!({})),
+        ("Copy", "keys.copy", json!({})),
+        ("Paste", "keys.paste", json!({})),
+        ("-", "", json!({})),
+        ("Select Equal Keyframes", "keys.selectEqual", json!({})),
+        ("Select Previous Keyframes", "keys.selectPrevious", json!({})),
+        ("Select Following Keyframes", "keys.selectFollowing", json!({})),
+        ("-", "", json!({})),
+        ("Keyframe Interpolation…", "keys.interpolation", json!({})),
+        ("Keyframe Velocity…", "keys.velocity", json!({})),
+        ("Toggle Hold Keyframe", "keys.toggleHold", json!({})),
+        (if k.muted { "Unmute Keyframes" } else { "Mute Keyframes" }, "keys.setMuted", json!({"muted": !k.muted})),
+        ("Rove Across Time", "keys.interpolation", json!({"roving": !k.roving})),
+        ("-", "", json!({})),
+        ("Easy Ease", "keys.easyEase", json!({})),
+        ("Easy Ease In", "keys.easyEaseIn", json!({})),
+        ("Easy Ease Out", "keys.easyEaseOut", json!({})),
+        ("Time-Reverse Keyframes", "keys.timeReverse", json!({})),
+        ("-", "", json!({})),
+        ("Linear", "keys.interpolation", json!({"interpolation": "linear"})),
+        ("Bezier", "keys.interpolation", json!({"interpolation": "bezier"})),
+        ("Auto Bezier", "keys.interpolation", json!({"interpolation": "autoBezier"})),
+        ("Select All Keyframes", "keys.selectAll", json!({})),
+        ("Delete", "keys.delete", json!({})),
+    ] {
+        if lbl == "Select All Keyframes" {
+            // Keyframe colour labels.
+            ui.add_enabled_ui(!locked, |ui| {
+                ui.menu_button(crate::i18n::tr("Label"), |ui| {
+                    for (i, l) in effectcraft_engine::color::Label::ALL.into_iter().enumerate() {
+                        if widgets::label_entry(ui, l, &app.session.prefs.label_name(l), k.label as usize == i, &t).clicked() {
+                            if !selected {
+                                actions.push(("keys.select".into(), json!({"keys": [this_key.clone()]})));
+                            }
+                            actions.push(("keys.setLabel".into(), json!({"label": i})));
+                            ui.close();
+                        }
+                    }
+                });
+            });
+        }
+        if lbl == "-" {
+            ui.separator();
+            continue;
+        }
+        if lbl == "Rove Across Time" && !prop.spatial {
+            continue;
+        }
+        if lbl == "Edit Value…" && !matches!(k.value, Value::Scalar(_) | Value::Vec2(_) | Value::Vec3(_)) {
+            continue;
+        }
+        let edits = !matches!(cmd, "keys.copy" | "keys.selectEqual" | "keys.selectPrevious" | "keys.selectFollowing" | "keys.selectAll");
+        // An unselected key is selected before the command runs, and locked keys cannot be selected.
+        let unselectable = locked && !selected && cmd != "keys.selectAll";
+        if ui.add_enabled(!(unselectable || locked && edits), egui::Button::new(crate::i18n::context_item(cmd, &params, lbl))).clicked() {
+            if !selected {
+                actions.push(("keys.select".into(), json!({"keys": [this_key.clone()]})));
+            }
+            actions.push((cmd.into(), params));
+            ui.close();
+        }
+    }
+}
+
+/// Starts a key drag (or Alt-scale).
+fn key_drag_begin(app: &mut EffectcraftApp, g: &Rw, kh: &KeyHit<'_>) {
+    let KeyHit { ct, ks, mods, ref kresp, .. } = *kh;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let sel_keys = &g.sel_keys;
+    // Alt-drag the first or last key of a selected group: scale the group in time.
+    if kresp.drag_started()
+        && mods.alt
+        && !mods.command
+        && let Some(c) = app.session.active_comp_arc()
+    {
+        super::graph_tools::alt_scale_begin(app, &ctx, &c, ct.seconds());
+    }
+    // A plain drag moves the selected keys. The timeline follows it (below): this
+    // widget's id changes with the key's time, so its own drag would end after
+    // the first frame of movement.
+    // (From where the button went down: a drag starts a few pixels later.)
+    if kresp.drag_started()
+        && !super::graph_tools::alt_scale_active(&ctx)
+        && let Some(p) = ctx.input(|i| i.pointer.press_origin())
+    {
+        // Ctrl/Cmd+Alt: Quick Offset of the selected keys' layers (#1012).
+        let quick = (mods.command && mods.alt && ks).then(|| quick_offset_layers(&comp, sel_keys.iter().map(|k| k.layer))).flatten();
+        ctx.data_mut(|d| d.insert_temp(key_drag_id(), KeyDrag { origin_x: p.x, anchor: ct.seconds(), applied: 0, quick }));
+    }
+}
+
+/// Paints one keyframe marker; returns its hit rect.
+fn key_paint(g: &Rw, rc: &RowCtx<'_>, k: &effectcraft_engine::keyframe::Keyframe, x: f32, ks: bool) -> Rect {
+    let t = g.tl.t;
+    let gp = g.gp.clone();
+    let cy = rc.cy;
+    let icon = k.icon();
+    let c = pos2(x, cy);
+    // Labelled keys take their label colour (brighter when selected).
+    let kcol = match effectcraft_engine::color::Label::ALL.get(k.label as usize).filter(|_| k.label > 0) {
+        Some(l) => {
+            let c = t.label(*l);
+            if ks { c } else { c.gamma_multiply(0.75) }
+        }
+        None if ks => t.keyframe_selected,
+        None => t.keyframe,
+    };
+    // Muted keys stay visible and editable but no longer drive the value.
+    let kcol = if k.muted { kcol.gamma_multiply(0.35) } else { kcol };
+    if k.roving {
+        // Roving keys: a small dot (their time follows their neighbours).
+        gp.circle_filled(c, 2.5, kcol);
+    } else {
+        icons::keyframe(&gp, c, 11.0, icon.left, icon.right, kcol);
+    }
+    Rect::from_center_size(c, vec2(12.0, 14.0))
+}
+
+/// The key's hit target and automation ids.
+fn key_hit(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    g: &Rw,
+    rc: &RowCtx<'_>,
+    prop: &Property,
+    k: &effectcraft_engine::keyframe::Keyframe,
+    kr: Rect,
+) -> egui::Response {
+    let fr = g.tl.fr;
+    let layer = rc.layer;
+    let uid = &prop.uid;
+    let ct = layer.comp_time(k.time);
+    let kresp = ui.interact(kr, egui::Id::unique(("key", uid, k.time.0)), Sense::click_and_drag());
+    app.auto.add(&format!("timeline.key.{uid}.{}", fr.frame_at(ct)), kr, &format!("{} key", prop.name));
+    // Exact (layer-time ticks): keys a Quick Offset puts on subframes can share a frame.
+    app.auto.add(&format!("timeline.keyAt.{uid}.{}", k.time.0), kr, &format!("{} key", prop.name));
+    kresp
+}
+
+/// Right-click menus on the empty outline and graph areas.
+fn background_menus(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw) {
+    let actions = &mut g.tl.actions;
+    let graph_on = g.graph_on;
+    let full_clip = g.full_clip;
+    let empty_rect = g.empty_rect;
+    let empty = g.empty.clone();
+    let outline_empty = g.outline_empty.clone();
     ui.set_clip_rect(full_clip);
     // The background responses sit below rows, bars and editors, preserving their menus.
     if !graph_on {
@@ -3199,6 +4311,18 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         });
     }
+}
+
+/// Click and marquee-select on the empty outline.
+fn outline_marquee(ui: &mut egui::Ui, g: &mut Rw) {
+    let t = g.tl.t;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let actions = &mut g.tl.actions;
+    let outline_rect = g.outline_rect;
+    let lp = g.lp.clone();
+    let outline_empty = g.outline_empty.clone();
+    let hit_rows = &mut g.hit_rows;
     if outline_empty.clicked() && !ui.input(|i| i.modifiers.shift || i.modifiers.command) {
         actions.push(("layer.select".into(), json!({"layers": []})));
     }
@@ -3223,6 +4347,17 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         actions.push(("layer.select".into(), json!({"layers": layers, "add": ui.input(|i| i.modifiers.shift || i.modifiers.command)})));
     }
     // Pick whips: a line follows the pointer; releasing over a row links to it (an expression's
+}
+
+/// A pick whip in flight: its line, the target and the link on release.
+fn pick_whip_drag(g: &mut Rw) {
+    let t = g.tl.t;
+    let graph_x0 = g.tl.graph_x0;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let actions = &mut g.tl.actions;
+    let hit_rows = &mut g.hit_rows;
+    let dim_hits = &mut g.dim_hits;
     // or a property's, also over a property in Effect Controls).
     if let Some((kind, src_layer, src_prop, start)) = ctx.data(|d| d.get_temp::<PickWhip>(pick_whip_id())) {
         let ptr = ctx.input(|i| i.pointer.latest_pos()).unwrap_or(start);
@@ -3232,7 +4367,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         let target = hit_rows.iter().find(|(r, _)| r.contains(ptr)).map(|(r, row)| (*r, row.clone()));
         // Shown this pass or the last one (Effect Controls may draw after the Timeline).
         let pass = ctx.cumulative_pass_nr();
-        let elsewhere = (target.is_none() && kind != WHIP_PARENT)
+        let elsewhere = (target.is_none() && !matches!(kind, WHIP_PARENT | WHIP_MATTE))
             .then(|| ctx.data(|d| d.get_temp::<WhipTargets>(whip_targets_id())))
             .flatten()
             .filter(|(p, _)| p.saturating_add(1) >= pass)
@@ -3243,10 +4378,13 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             fg.rect_stroke(*tr, 0.0, Stroke::new(1.0, t.accent), StrokeKind::Inside);
         }
         if ctx.input(|i| !i.pointer.any_down()) {
-            ctx.data_mut(|d| {
+            let whip_layers = ctx.data_mut(|d| {
                 d.remove::<PickWhip>(pick_whip_id());
                 d.remove::<WhipTargets>(whip_targets_id());
+                d.remove_temp::<Vec<u64>>(whip_layers_id())
             });
+            // The layers a layer pick whip links, less the one it was dropped on.
+            let linked = |onto: u64| -> Vec<u64> { whip_layers.clone().unwrap_or_else(|| vec![src_layer]).into_iter().filter(|l| *l != onto).collect() };
             let into = (kind == WHIP_EXPR).then(|| ctx.data_mut(|d| d.remove_temp::<WhipInto>(whip_into_id(src_prop)))).flatten();
             // The property dropped on, and the value (dimension) if on one of them: `position[0]`.
             let dim = |fields: &[Rect]| fields.iter().position(|r| r.contains(ptr));
@@ -3259,7 +4397,11 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             };
             match (kind, target, prop_target) {
                 (WHIP_PARENT, Some((_, row)), _) if row.layer.0 != src_layer => {
-                    actions.push(("layer.setParent".into(), json!({"layers": [src_layer], "parent": row.layer.0})));
+                    actions.push(("layer.setParent".into(), json!({"layers": linked(row.layer.0), "parent": row.layer.0})));
+                }
+                // Each layer keeps its own matte mode.
+                (WHIP_MATTE, Some((_, row)), _) if row.layer.0 != src_layer && comp.layer(row.layer).is_some_and(|l| l.source.is_av()) => {
+                    actions.push(("layer.setTrackMatte".into(), json!({"layers": linked(row.layer.0), "matte": row.layer.0, "kind": "preserve"})));
                 }
                 // The property pick whip replaces the expression with the reference (or adds one),
                 // as the expression pick whip does when its expression isn't being edited.
@@ -3268,6 +4410,10 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     if let Some(d) = d {
                         params["target"]["dimension"] = json!(d);
                     }
+                    // Alt held as it drops: an effect's properties by their index (#1072).
+                    if ctx.input(|i| i.modifiers.alt) {
+                        params["byIndex"] = json!(true);
+                    }
                     if let Some((text, [a, b])) = into {
                         // Into the expression being edited, which goes on being edited.
                         params["expression"] = json!(text);
@@ -3282,16 +4428,42 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
     }
     // Alt-drag key group scaling (follows the pointer until release).
+}
+
+fn alt_scale_and_graph(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw, ectx: &EvalCtx<'_>) {
+    let graph_x0 = g.tl.graph_x0;
+    let tm = g.tl.tm;
+    let rows_rect = g.tl.rows_rect;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let actions = &mut g.tl.actions;
+    let graph_on = g.graph_on;
+    let gp = g.gp.clone();
     if let Some(c) = app.session.active_comp_arc() {
-        super::graph_tools::alt_scale_update(app, &ctx, &c, tm, &mut actions);
+        super::graph_tools::alt_scale_update(app, &ctx, &c, tm, &mut *actions);
     }
     // Graph editor.
     if graph_on {
-        super::graph::show(app, ui, &gp, &comp, &ectx, tm, Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max), &mut actions);
+        super::graph::show(
+            app,
+            ui,
+            &gp,
+            super::graph::GraphView { comp: &comp, ectx, tm },
+            Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max),
+            &mut *actions,
+        );
     }
     // A plain click on empty track area (beside a layer's bar, on a property row's empty span or
     // below the last row) deselects the layers and their keys and properties, as in After
-    // Effects; Shift / Cmd keep the selection. Drag: box-select keys.
+}
+
+/// Click / marquee on empty track area.
+fn graph_empty_area(ui: &mut egui::Ui, g: &mut Rw) {
+    let t = g.tl.t;
+    let ctx = g.tl.ctx.clone();
+    let actions = &mut g.tl.actions;
+    let gp = g.gp.clone();
+    let empty = g.empty.clone();
     if empty.clicked() && !ui.input(|i| i.modifiers.shift || i.modifiers.command) {
         actions.push(("layer.select".into(), json!({"layers": []})));
     }
@@ -3303,17 +4475,43 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         gp.rect_stroke(br, 0.0, Stroke::new(1.0, t.accent), StrokeKind::Middle);
         ctx.data_mut(|d| d.insert_temp(egui::Id::unique("tl-box"), br));
     }
-    // Layer reorder drag: a line where the layers will land; the release moves them there.
-    if let Some(moving) = ctx.data(|d| d.get_temp::<Vec<u64>>(layer_drag_id())) {
-        let dropped = ctx.data_mut(|d| d.remove_temp::<bool>(layer_drop_id())).unwrap_or(false);
+}
+
+/// Layer reorder drag: a line where the layers land.
+fn layer_reorder_drag(ui: &mut egui::Ui, g: &mut Rw) {
+    let cid = g.tl.cid;
+    let t = g.tl.t;
+    let rect = g.tl.rect;
+    let graph_x0 = g.tl.graph_x0;
+    let rows_rect = g.tl.rows_rect;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let p = g.tl.p.clone();
+    let actions = &mut g.tl.actions;
+    let hit_rows = &mut g.hit_rows;
+    // The origin row can scroll out of view, so finish the gesture here, independently of
+    // its Response. Disabled UI, Escape or lost ownership cancels; only a primary release drops layers.
+    if let Some(drag) = ctx.data(|d| d.get_temp::<LayerDrag>(layer_drag_id())) {
+        let (down, released, escape) =
+            ctx.input(|i| (i.pointer.primary_down(), i.pointer.button_released(egui::PointerButton::Primary), i.key_pressed(egui::Key::Escape)));
+        let dropped = ctx.drag_stopped_id() == Some(drag.owner) && released;
+        let valid = ui.is_enabled()
+            && drag.comp == cid
+            && drag.layers.iter().all(|id| comp.layer(LayerId(*id)).is_some())
+            && !escape
+            && (dropped || (down && ctx.dragged_id() == Some(drag.owner)));
+        if dropped || !valid {
+            ctx.data_mut(|d| d.remove::<LayerDrag>(layer_drag_id()));
+        }
+        let moving = &drag.layers;
         let layer_rows: Vec<(Rect, LayerId)> = hit_rows.iter().filter(|(_, r)| matches!(r.kind, RowKind::Layer)).map(|(rr, r)| (*rr, r.layer)).collect();
         if let Some(py) = ui.input(|i| i.pointer.interact_pos().or(i.pointer.latest_pos())).map(|p| p.y)
+            && valid
             && !layer_rows.is_empty()
         {
             let (at, line_y) = insertion(&layer_rows, py, rows_rect.min.y);
-            let target = at.and_then(|i| layer_rows[i..].iter().find(|(_, l)| !moving.contains(&l.0)).map(|(_, l)| *l));
+            let target = layer_drop_target(&g.tl.rows, &layer_rows, at, moving);
             if dropped {
-                ctx.data_mut(|d| d.remove::<Vec<u64>>(layer_drag_id()));
                 // Only when the order changes (no empty undo step for a drop in place).
                 let mut order: Vec<u64> = comp.layers.iter().map(|l| l.id.0).filter(|id| !moving.contains(id)).collect();
                 let at = target.and_then(|t| order.iter().position(|id| *id == t.0)).unwrap_or(order.len());
@@ -3329,12 +4527,63 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 ctx.set_cursor_icon(egui::CursorIcon::Grabbing);
                 p.with_clip_rect(rows_rect).line_segment([pos2(rect.min.x, line_y), pos2(graph_x0, line_y)], Stroke::new(2.0, t.accent));
             }
-        } else if dropped {
-            ctx.data_mut(|d| d.remove::<Vec<u64>>(layer_drag_id()));
         }
     }
     // Quick Offset of layer bars: the last selected layer moves by whole frames with the pointer
-    // until the button is released, wherever the bar's row has scrolled to.
+}
+
+/// Group reorder drag (#2210): a line where the dragged effect, mask or shape item lands among
+/// its siblings; the drop moves it there (`prop.moveGroup`). Escape cancels.
+fn group_reorder_drag(ui: &mut egui::Ui, g: &mut Rw) {
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let Some(drag) = ctx.data(|d| d.get_temp::<GroupDrag>(group_drag_id())) else { return };
+    let (down, released, escape) =
+        ctx.input(|i| (i.pointer.primary_down(), i.pointer.button_released(egui::PointerButton::Primary), i.key_pressed(egui::Key::Escape)));
+    let dropped = ctx.drag_stopped_id() == Some(drag.owner) && released;
+    let parent = comp.layer(drag.layer).and_then(|l| l.props.parent_of(drag.uid));
+    let valid = ui.is_enabled() && drag.comp == g.tl.cid && parent.is_some() && !escape && (dropped || (down && ctx.dragged_id() == Some(drag.owner)));
+    if dropped || !valid {
+        ctx.data_mut(|d| d.remove::<GroupDrag>(group_drag_id()));
+    }
+    let Some(parent) = parent.filter(|_| valid) else { return };
+    let siblings: Vec<u64> = parent.children.iter().map(Node::uid).collect();
+    let rows: Vec<(Rect, u64)> = g
+        .hit_rows
+        .iter()
+        .filter_map(|(r, row)| match &row.kind {
+            RowKind::Group { uid, .. } if row.layer == drag.layer && siblings.contains(uid) => Some((*r, *uid)),
+            _ => None,
+        })
+        .collect();
+    let Some(py) = ui.input(|i| i.pointer.interact_pos().or(i.pointer.latest_pos())).map(|p| p.y) else { return };
+    if rows.is_empty() {
+        return;
+    }
+    let (at, line_y) = insertion(&rows, py, g.tl.rows_rect.min.y);
+    if !dropped {
+        ctx.set_cursor_icon(egui::CursorIcon::Grabbing);
+        g.tl.p.with_clip_rect(g.tl.rows_rect).line_segment([pos2(g.tl.rect.min.x, line_y), pos2(g.tl.graph_x0, line_y)], Stroke::new(2.0, g.tl.t.accent));
+        return;
+    }
+    // The sibling the drop lands before (or after, below the last visible one).
+    let Some(&(_, anchor)) = at.map_or(rows.last(), |i| rows.get(i)) else { return };
+    let from = siblings.iter().position(|u| *u == drag.uid);
+    let rest: Vec<u64> = siblings.iter().copied().filter(|u| *u != drag.uid).collect();
+    let to = if anchor == drag.uid { from } else { rest.iter().position(|u| *u == anchor).map(|i| i + usize::from(at.is_none())) };
+    if let Some(to) = to.filter(|to| Some(*to) != from) {
+        g.tl.actions.push(("prop.moveGroup".into(), json!({"layer": drag.layer.0, "prop": drag.uid, "index": to + 1})));
+    }
+}
+
+/// Quick Offset of layer bars follows the pointer.
+fn quick_offset_follow(g: &mut Rw) {
+    let t = g.tl.t;
+    let pps = g.tl.pps;
+    let fd = g.tl.fd;
+    let ctx = g.tl.ctx.clone();
+    let actions = &mut g.tl.actions;
+    let ui_actions = &mut g.ui_actions;
     if let Some(mut q) = ctx.data(|d| d.get_temp::<QuickBar>(quick_bar_id())) {
         let (down, ptr) = ctx.input(|i| (i.pointer.primary_down(), i.pointer.latest_pos()));
         match ptr.filter(|_| down) {
@@ -3356,7 +4605,19 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
     // Keyframe drag: the selected keys move by whole frames with the pointer until it is
     // released (one undo step); Shift snaps the grabbed key to the current time, the work area
-    // and composition markers.
+}
+
+/// The key drag moves the selected keys by whole frames.
+fn key_drag_follow(app: &mut EffectcraftApp, g: &mut Rw) {
+    let t = g.tl.t;
+    let time = g.tl.time;
+    let pps = g.tl.pps;
+    let fd = g.tl.fd;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let rows = &g.tl.rows;
+    let actions = &mut g.tl.actions;
+    let ui_actions = &mut g.ui_actions;
     if let Some(mut kd) = ctx.data(|d| d.get_temp::<KeyDrag>(key_drag_id())) {
         let (down, ptr, shift) = ctx.input(|i| (i.pointer.primary_down(), i.pointer.latest_pos(), i.modifiers.shift));
         match ptr.filter(|_| down) {
@@ -3367,7 +4628,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     // not the moving keys themselves.
                     let moving: Vec<f64> =
                         app.session.state.selected_keys.iter().filter_map(|k| comp.layer(k.layer).map(|l| l.comp_time(k.time).seconds())).collect();
-                    let mut cands = snap_candidates(&comp, &rows);
+                    let mut cands = snap_candidates(&comp, rows);
                     cands.retain(|c| !moving.iter().any(|m| (m - c).abs() < 1e-9));
                     cands.push(time.seconds());
                     target = snap_time(&cands, target, 8.0 / pps);
@@ -3398,13 +4659,25 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         }
     }
+}
+
+/// Releasing the key marquee selects the keys inside it.
+fn key_box_select(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &mut Rw) {
+    let tm = g.tl.tm;
+    let rows_rect = g.tl.rows_rect;
+    let rh = g.tl.rh;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let rows = &g.tl.rows;
+    let actions = &mut g.tl.actions;
+    let empty = g.empty.clone();
     if empty.drag_stopped()
         && let Some(br) = ctx.data(|d| d.get_temp::<Rect>(egui::Id::unique("tl-box")))
     {
         ctx.data_mut(|d| d.remove::<Rect>(egui::Id::unique("tl-box")));
         let mut keys = vec![];
         let mut yy = rows_rect.min.y - app.ui.timeline.scroll_y;
-        for row in &rows {
+        for row in rows.iter() {
             let cy = yy + rh / 2.0;
             yy += row_height(row, rh);
             if let RowKind::Prop { uid } = row.kind
@@ -3429,8 +4702,17 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             actions.push(("keys.select".into(), json!({"keys": keys, "add": mods.shift, "selectProperties": true})));
         }
     }
+}
 
-    // CTI.
+fn current_time_indicator(app: &mut EffectcraftApp, g: &Rw) {
+    let t = g.tl.t;
+    let time = g.tl.time;
+    let rect = g.tl.rect;
+    let graph_x0 = g.tl.graph_x0;
+    let tm = g.tl.tm;
+    let rows_rect = g.tl.rows_rect;
+    let ruler = g.tl.ruler;
+    let p = g.tl.p.clone();
     let cx = tm.x(time.seconds());
     if cx >= graph_x0 && cx <= rect.max.x {
         p.line_segment([pos2(cx, ruler.min.y + 12.0), pos2(cx, rows_rect.max.y)], Stroke::new(1.0, t.cti));
@@ -3444,9 +4726,19 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         p.add(egui::Shape::convex_polygon(head, t.cti, Stroke::NONE));
         app.auto.add("timeline.cti", Rect::from_center_size(pos2(cx, ruler.center().y), vec2(12.0, 20.0)), "Current time indicator");
     }
-    let _ = graph_rect;
+}
 
-    // Footer.
+/// The footer: scroll bars, the switches / modes toggle and render time.
+fn footer_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Rw) -> Rect {
+    let t = g.tl.t;
+    let rect = g.tl.rect;
+    let footer_h = g.tl.footer_h;
+    let overflow = g.tl.overflow;
+    let oscroll = g.tl.oscroll;
+    let graph_x0 = g.tl.graph_x0;
+    let rows_rect = g.tl.rows_rect;
+    let max_scroll = g.tl.max_scroll;
+    let p = g.tl.p.clone();
     let footer = Rect::from_min_max(pos2(rect.min.x, rect.max.y - footer_h), rect.max);
     p.rect_filled(footer, 0.0, t.panel_bg);
     p.line_segment([footer.left_top(), footer.right_top()], Stroke::new(1.0, t.separator));
@@ -3482,6 +4774,20 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         t.text_faint,
     );
     // Zoom slider.
+    footer
+}
+
+/// The zoom buttons and slider.
+fn footer_zoom(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Rw, footer: Rect) {
+    let t = g.tl.t;
+    let time = g.tl.time;
+    let rect = g.tl.rect;
+    let graph_x0 = g.tl.graph_x0;
+    let fit_pps = g.tl.fit_pps;
+    let pps = g.tl.pps;
+    let tm = g.tl.tm;
+    let comp = g.tl.comp.clone();
+    let p = g.tl.p.clone();
     let zs = Rect::from_min_max(pos2(graph_x0 + 30.0, footer.center().y - 2.0), pos2((graph_x0 + 230.0).min(rect.max.x - 30.0), footer.center().y + 2.0));
     // Zoom out / zoom in buttons either side of the slider: the `-` / `=` steps. Everything here
     // zooms around the CTI and sets the one time zoom the layer bars and the Graph Editor share.
@@ -3513,16 +4819,34 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         let f = ((pt.x - zs.min.x) / zs.width().max(1.0)).clamp(0.0, 1.0) as f64;
         set_zoom(&mut app.ui.timeline, &comp, fit_pps * (maxpps / fit_pps).powf(f), fit_pps, cti, cti_px);
     }
+}
 
+fn comp_markers_ui(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Rw) {
+    let graph_x0 = g.tl.graph_x0;
+    let tm = g.tl.tm;
+    let rows_rect = g.tl.rows_rect;
+    let ruler = g.tl.ruler;
+    let bin = g.tl.bin;
+    let comp = g.tl.comp.clone();
     // Composition markers in the ruler; protected regions shade the layer rows.
     let mstrip = Rect::from_min_max(pos2(graph_x0, ruler.max.y - 12.0), pos2(bin.min.x, ruler.max.y));
     let mrows = rows_rect.intersect(Rect::from_min_max(pos2(graph_x0, rows_rect.min.y), rows_rect.max));
     super::markers_ui::comp_markers(app, ui, &comp, tm, mstrip, mrows);
     super::markers_ui::marker_bin(app, ui, &comp, tm, bin, mstrip);
+}
 
-    // Spacebar held: the Hand tool. Dragging pans the rows vertically as well as scrolling the
-    // time graph in time when zoomed in (registered last, so it takes the drag from the bars,
-    // keys and markers there).
+/// Spacebar held: the Hand tool.
+fn hand_tool_pan(app: &mut EffectcraftApp, ui: &mut egui::Ui, g: &Rw) {
+    let rect = g.tl.rect;
+    let graph_x0 = g.tl.graph_x0;
+    let graph_x1 = g.tl.graph_x1;
+    let pps = g.tl.pps;
+    let tm = g.tl.tm;
+    let rows_rect = g.tl.rows_rect;
+    let ruler = g.tl.ruler;
+    let max_scroll = g.tl.max_scroll;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
     if super::space_hand(&ctx) {
         let area = Rect::from_min_max(pos2(graph_x0, ruler.min.y), pos2(rect.max.x, rows_rect.max.y));
         let hand = ui.interact(area, egui::Id::unique("tl-hand"), Sense::drag());
@@ -3540,184 +4864,130 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         }
     }
+}
 
-    // Drop targets: effects and animation presets from Effects & Presets go on the layer under the
-    // pointer. Footage and
-    // comps from the Project panel and files from the Media Browser go where they are dropped: a
-    // line shows the place in the stack, and over the time graph a marker shows the In point too
-    // (Shift: at the current time).
-    if let Some(payload) = egui::DragAndDrop::payload::<crate::panels::DragPayload>(&ctx)
-        && !matches!(*payload, crate::panels::DragPayload::Property { .. })
-        && let Some(ptr) = ctx.input(|i| i.pointer.hover_pos()).filter(|_| ui.rect_contains_pointer(rows_rect))
-    {
-        let released = ctx.input(|i| i.pointer.any_released());
-        // Alt/Option-drag from the Project panel replaces the source of the layer under the
-        // pointer (After Effects). The shortcut replaces every selected layer instead.
-        let alt_item = ctx.input(|i| i.modifiers.alt) && matches!(payload.as_ref(), crate::panels::DragPayload::Item(_));
-        if alt_item {
-            if let crate::panels::DragPayload::Item(id) = payload.as_ref() {
-                let target = hit_rows.iter().find(|(r, _)| ptr.y >= r.min.y && ptr.y < r.max.y).map(|(_, row)| row.layer);
-                if let Some(l) = target
-                    && replace_source_target(app, cid, ItemId(*id), l, &comp)
-                    && let Some(span) = hit_rows.iter().filter(|(_, row)| row.layer == l).map(|(r, _)| *r).reduce(|a, b| a.union(b))
-                {
-                    let lit = span.intersect(rows_rect);
-                    let rp = p.with_clip_rect(rows_rect);
-                    rp.rect_filled(lit, 0.0, t.accent.gamma_multiply(0.18));
-                    rp.rect_stroke(lit, 0.0, Stroke::new(2.0, t.accent), StrokeKind::Inside);
-                    app.auto.add("timeline.replaceSourceTarget", lit, "Replace the layer's source");
-                    if released {
-                        actions.push(("layer.replaceSource".into(), json!({"layers": [l.0], "item": *id, "fixExpressions": false})));
-                    }
-                }
-            }
-        } else if matches!(payload.as_ref(), crate::panels::DragPayload::Effect(_) | crate::panels::DragPayload::Preset { .. }) {
-            let target = hit_rows.iter().find(|(r, _)| ptr.y >= r.min.y && ptr.y < r.max.y).map(|(_, row)| row.layer);
-            // The layer the effect would land on (its row and its open properties) is the one
-            // that lights up, not the whole timeline.
-            if let Some(l) = target
-                && let Some(span) = hit_rows.iter().filter(|(_, row)| row.layer == l).map(|(r, _)| *r).reduce(|a, b| a.union(b))
-            {
-                let lit = span.intersect(rows_rect);
-                let rp = p.with_clip_rect(rows_rect);
-                rp.rect_filled(lit, 0.0, t.accent.gamma_multiply(0.18));
-                rp.rect_stroke(lit, 0.0, Stroke::new(2.0, t.accent), StrokeKind::Inside);
-                app.auto.add("timeline.dropTarget", lit, "Drop target layer");
-            }
-            if released && let Some(l) = target {
-                match payload.as_ref() {
-                    crate::panels::DragPayload::Effect(e) => actions.push(("effect.apply".into(), json!({"effect": e, "layers": [l.0]}))),
-                    crate::panels::DragPayload::Preset { preset, .. } => {
-                        let (id, params) = preset.apply_to(l.0);
-                        actions.push((id.into(), params));
-                    }
-                    _ => {}
-                }
-            }
-        } else {
-            let layer_rows: Vec<(Rect, LayerId)> = hit_rows.iter().filter(|(_, r)| matches!(r.kind, RowKind::Layer)).map(|(rr, r)| (*rr, r.layer)).collect();
-            let (at, line_y) = insertion(&layer_rows, ptr.y, rows_rect.min.y);
-            let index = match at.and_then(|i| layer_rows.get(i)) {
-                Some((_, l)) => comp.index_of(*l).unwrap_or(1),
-                None => layer_rows.last().and_then(|(_, l)| comp.index_of(*l)).unwrap_or(comp.layers.len()) + 1,
-            };
-            let start = (ptr.x >= graph_x0 && !graph_on).then(|| {
-                let t = if ctx.input(|i| i.modifiers.shift) { time } else { Tick::from_seconds_f64(tm.t(ptr.x)) };
-                comp.frame_rate.snap_nearest(t).clamp(Tick::ZERO, comp.duration - comp.frame_duration())
-            });
+/// Alt-drag of an item over a layer: replace its source.
+fn drop_replace_source(app: &mut EffectcraftApp, g: &mut Rw, payload: &std::sync::Arc<crate::panels::DragPayload>, ptr: Pos2, released: bool) {
+    let t = g.tl.t;
+    let cid = g.tl.cid;
+    let rows_rect = g.tl.rows_rect;
+    let comp = g.tl.comp.clone();
+    let p = g.tl.p.clone();
+    let actions = &mut g.tl.actions;
+    let hit_rows = &mut g.hit_rows;
+    if let crate::panels::DragPayload::Item(id) = payload.as_ref() {
+        let target = hit_rows.iter().find(|(r, _)| ptr.y >= r.min.y && ptr.y < r.max.y).map(|(_, row)| row.layer);
+        if let Some(l) = target
+            && replace_source_target(app, cid, ItemId(*id), l, &comp)
+            && let Some(span) = hit_rows.iter().filter(|(_, row)| row.layer == l).map(|(r, _)| *r).reduce(|a, b| a.union(b))
+        {
+            let lit = span.intersect(rows_rect);
             let rp = p.with_clip_rect(rows_rect);
-            rp.line_segment([pos2(rect.min.x, line_y), pos2(rows_rect.max.x, line_y)], Stroke::new(2.0, t.accent));
-            if let Some(s) = start {
-                let x = tm.x(s.seconds());
-                rp.line_segment([pos2(x, rows_rect.min.y), pos2(x, rows_rect.max.y)], Stroke::new(1.0, t.accent));
-                // The In point's time in a tag beside the marker.
-                let g = rp.layout_no_wrap(super::timecode(&app.session, &comp, s), Tokens::ui(11.0), Color32::WHITE);
-                let tag = Align2::LEFT_BOTTOM.anchor_size(pos2(x + 4.0, line_y - 3.0), g.size());
-                rp.rect_filled(tag.expand(2.0), 2.0, t.accent);
-                rp.galley(tag.min, g, Color32::WHITE);
-            }
+            rp.rect_filled(lit, 0.0, t.accent.gamma_multiply(0.18));
+            rp.rect_stroke(lit, 0.0, Stroke::new(2.0, t.accent), StrokeKind::Inside);
+            app.auto.add("timeline.replaceSourceTarget", lit, "Replace the layer's source");
             if released {
-                let time = json!(start.map(Tick::seconds));
-                match payload.as_ref() {
-                    crate::panels::DragPayload::Item(id) => {
-                        // Insert each selected item at the drop point, in selection order.
-                        for (offset, item) in crate::panels::project_drop_items(app, *id).into_iter().enumerate() {
-                            actions.push(("layer.addItem".into(), json!({"item": item, "index": index.saturating_add(offset), "time": time.clone()})));
-                        }
-                    }
-                    crate::panels::DragPayload::Files(paths) => {
-                        actions.push(("mediaBrowser.import".into(), json!({"paths": paths, "addToComp": true, "index": index, "time": time})))
-                    }
-                    crate::panels::DragPayload::Effect(_) | crate::panels::DragPayload::Preset { .. } | crate::panels::DragPayload::Property { .. } => {}
-                }
+                actions.push(("layer.replaceSource".into(), json!({"layers": [l.0], "item": *id, "fixExpressions": false})));
             }
         }
-        if released {
-            egui::DragAndDrop::clear_payload(&ctx);
-        }
     }
+}
 
-    // Apply.
-    for a in ui_actions {
-        match a {
-            UiAct::ToggleLayer(id, all) => {
-                let tl = &mut app.ui.timeline;
-                // Twirled by hand, the layer shows its whole tree again.
-                tl.reveal.clear();
-                tl.layer_reveal.remove(&id);
-                tl.full_groups.remove(&id);
-                let open = !tl.open_layers.contains(&id);
-                if open {
-                    tl.open_layers.insert(id);
-                } else {
-                    tl.open_layers.remove(&id);
-                }
-                if all && let Some(l) = comp.layer(LayerId(id)) {
-                    let mut uids = vec![];
-                    walk_groups(&l.props, &mut uids);
-                    for u in uids {
-                        if open {
-                            tl.open_groups.insert(u);
-                        } else {
-                            tl.open_groups.remove(&u);
-                        }
-                    }
-                }
-            }
-            UiAct::ToggleGroup(layer, uid, all) => {
-                let tl = &mut app.ui.timeline;
-                tl.toggle_group(layer, uid);
-                let open = tl.open_groups.contains(&uid);
-                if all && let Some(g) = comp.layer(LayerId(layer)).and_then(|l| find_group(&l.props, uid)) {
-                    let mut uids = vec![];
-                    walk_groups(g, &mut uids);
-                    for u in uids {
-                        if open {
-                            tl.open_groups.insert(u);
-                        } else {
-                            tl.open_groups.remove(&u);
-                        }
-                    }
-                }
-            }
-            UiAct::SetTime(tt) => app.session.set_time(tt),
-            UiAct::EndMerge => app.session.history.merge_key = None,
-            UiAct::ChangeRenderer => {
-                if super::dialogs::open_comp_settings(app).is_ok() {
-                    app.dialog_state.comp.tab = super::comp_settings::Tab::Renderer;
-                }
+/// Effects and presets drop onto the layer under the pointer.
+fn drop_on_layer(app: &mut EffectcraftApp, g: &mut Rw, payload: &std::sync::Arc<crate::panels::DragPayload>, ptr: Pos2, released: bool) {
+    let t = g.tl.t;
+    let rows_rect = g.tl.rows_rect;
+    let p = g.tl.p.clone();
+    let actions = &mut g.tl.actions;
+    let hit_rows = &mut g.hit_rows;
+    let target = hit_rows.iter().find(|(r, _)| ptr.y >= r.min.y && ptr.y < r.max.y).map(|(_, row)| row.layer);
+    // The layer the effect would land on (its row and its open properties) is the one
+    // that lights up, not the whole timeline.
+    if let Some(l) = target
+        && let Some(span) = hit_rows.iter().filter(|(_, row)| row.layer == l).map(|(r, _)| *r).reduce(|a, b| a.union(b))
+    {
+        let lit = span.intersect(rows_rect);
+        let rp = p.with_clip_rect(rows_rect);
+        rp.rect_filled(lit, 0.0, t.accent.gamma_multiply(0.18));
+        rp.rect_stroke(lit, 0.0, Stroke::new(2.0, t.accent), StrokeKind::Inside);
+        app.auto.add("timeline.dropTarget", lit, "Drop target layer");
+    }
+    if released && let Some(l) = target {
+        match payload.as_ref() {
+            crate::panels::DragPayload::Effect(e) => actions.push(("effect.apply".into(), json!({"effect": e, "layers": [l.0]}))),
+            crate::panels::DragPayload::Preset { preset, .. } => {
+                let (id, params) = preset.apply_to(l.0);
+                actions.push((id.into(), params));
             }
+            _ => {}
         }
     }
-    if ui.input(|i| i.pointer.primary_down()) && actions.iter().any(|(id, _)| id == "prop.set") {
-        app.ui.viewer.property_interacting = true;
-        ctx.request_repaint();
+}
+
+/// Footage and files drop into the stack: a line shows the place.
+fn drop_insert_layers(app: &mut EffectcraftApp, g: &mut Rw, payload: &std::sync::Arc<crate::panels::DragPayload>, ptr: Pos2, released: bool) {
+    let t = g.tl.t;
+    let time = g.tl.time;
+    let rect = g.tl.rect;
+    let graph_x0 = g.tl.graph_x0;
+    let tm = g.tl.tm;
+    let rows_rect = g.tl.rows_rect;
+    let ctx = g.tl.ctx.clone();
+    let comp = g.tl.comp.clone();
+    let p = g.tl.p.clone();
+    let actions = &mut g.tl.actions;
+    let graph_on = g.graph_on;
+    let hit_rows = &mut g.hit_rows;
+    let layer_rows: Vec<(Rect, LayerId)> = hit_rows.iter().filter(|(_, r)| matches!(r.kind, RowKind::Layer)).map(|(rr, r)| (*rr, r.layer)).collect();
+    let (at, line_y) = insertion(&layer_rows, ptr.y, rows_rect.min.y);
+    let index = match at.and_then(|i| layer_rows.get(i)) {
+        Some((_, l)) => comp.index_of(*l).unwrap_or(1),
+        None => layer_rows.last().and_then(|(_, l)| comp.index_of(*l)).unwrap_or(comp.layers.len()) + 1,
+    };
+    let start = (ptr.x >= graph_x0 && !graph_on).then(|| {
+        let t = if ctx.input(|i| i.modifiers.shift) { time } else { Tick::from_seconds_f64(tm.t(ptr.x)) };
+        comp.frame_rate.snap_nearest(t).clamp(Tick::ZERO, comp.duration - comp.frame_duration())
+    });
+    let rp = p.with_clip_rect(rows_rect);
+    rp.line_segment([pos2(rect.min.x, line_y), pos2(rows_rect.max.x, line_y)], Stroke::new(2.0, t.accent));
+    if let Some(s) = start {
+        let x = tm.x(s.seconds());
+        rp.line_segment([pos2(x, rows_rect.min.y), pos2(x, rows_rect.max.y)], Stroke::new(1.0, t.accent));
+        // The In point's time in a tag beside the marker.
+        let g = rp.layout_no_wrap(super::timecode(&app.session, &comp, s), Tokens::ui(11.0), Color32::WHITE);
+        let tag = Align2::LEFT_BOTTOM.anchor_size(pos2(x + 4.0, line_y - 3.0), g.size());
+        rp.rect_filled(tag.expand(2.0), 2.0, t.accent);
+        rp.galley(tag.min, g, Color32::WHITE);
     }
-    for (id, params) in actions {
-        if id == "__endMerge" {
-            app.session.history.merge_key = None;
-            continue;
-        }
-        if let Err(e) = crate::menus::invoke(app, &ctx, &id, params) {
-            app.ui.status = e;
+    if released {
+        let time = json!(start.map(Tick::seconds));
+        match payload.as_ref() {
+            crate::panels::DragPayload::Item(id) => {
+                // Insert each selected item at the drop point, in selection order.
+                for (offset, item) in crate::panels::project_drop_items(app, *id, Some(g.tl.cid)).into_iter().enumerate() {
+                    actions.push(("layer.addItem".into(), json!({"item": item, "index": index.saturating_add(offset), "time": time.clone()})));
+                }
+            }
+            crate::panels::DragPayload::Files(paths) => {
+                actions.push(("mediaBrowser.import".into(), json!({"paths": paths, "addToComp": true, "index": index, "time": time})))
+            }
+            crate::panels::DragPayload::Effect(_) | crate::panels::DragPayload::Preset { .. } | crate::panels::DragPayload::Property { .. } => {}
         }
     }
 }
 
 /// The optional per-layer cells: Comment (double-click to edit), In / Out / Duration (drag to
 /// change by frames), Stretch (click: Time Stretch dialog).
-#[allow(clippy::too_many_arguments)]
 fn layer_cells(
     app: &mut EffectcraftApp,
     ui: &mut egui::Ui,
     lp: &egui::Painter,
     cw: &Cols,
     comp: &Comp,
-    layer: &Layer,
-    r: Rect,
-    cy: f32,
+    rc: &RowCtx<'_>,
     actions: &mut Vec<(String, serde_json::Value)>,
 ) {
+    let (layer, r, cy) = (rc.layer, rc.r, rc.cy);
     let t = app.tokens;
     let ctx = ui.ctx().clone();
     let lid = layer.id.0;
@@ -3831,17 +5101,16 @@ fn find_group(g: &PropGroup, uid: u64) -> Option<&PropGroup> {
 }
 
 /// A stroke's Dashes "+" / "−" buttons (add or remove a Dash/Gap pair).
-#[allow(clippy::too_many_arguments)]
 fn dash_buttons(
     app: &mut EffectcraftApp,
     ui: &mut egui::Ui,
     p: &egui::Painter,
     layer: &Layer,
     uid: u64,
-    x: f32,
-    cy: f32,
+    at: Pos2,
     actions: &mut Vec<(String, serde_json::Value)>,
 ) {
+    let (x, cy) = (at.x, at.y);
     if !matches!(layer.source, LayerSource::Shape) || layer.props.find_group(uid).is_none_or(|g| g.match_id != "dashes") {
         return;
     }
@@ -3889,22 +5158,22 @@ const SHAPE_ADD_ITEMS: &[(&str, &str)] = &[
     ("trim", "Trim Paths"),
     ("twist", "Twist"),
     ("wiggle", "Wiggle Paths"),
+    ("wiggler", "Wiggle Transform"),
     ("zigzag", "Zig Zag"),
 ];
 
 /// A shape layer's Contents "Add:" pop-up menu: adds a shape, paint or path operation to the
 /// selected shape group, else to the layer's contents.
-#[allow(clippy::too_many_arguments)]
 fn shape_add_popup(
     app: &mut EffectcraftApp,
     ui: &mut egui::Ui,
     p: &egui::Painter,
     layer: &Layer,
     uid: u64,
-    x: f32,
-    cy: f32,
+    at: Pos2,
     actions: &mut Vec<(String, serde_json::Value)>,
 ) {
+    let (x, cy) = (at.x, at.y);
     if !matches!(layer.source, LayerSource::Shape) || layer.props.sub("contents").is_none_or(|c| c.uid != uid) {
         return;
     }
@@ -3937,17 +5206,16 @@ fn shape_add_popup(
 }
 
 /// The Text group's "Animate:" and an animator's "Add:" pop-up menus (AE's twirl-down menus).
-#[allow(clippy::too_many_arguments)]
 fn text_anim_popups(
     app: &mut EffectcraftApp,
     ui: &mut egui::Ui,
     p: &egui::Painter,
     layer: &Layer,
     uid: u64,
-    x: f32,
-    cy: f32,
+    at: Pos2,
     actions: &mut Vec<(String, serde_json::Value)>,
 ) {
+    let (x, cy) = (at.x, at.y);
     use effectcraft_engine::project::build::TEXT_ANIMATOR_KINDS;
     if !matches!(layer.source, LayerSource::Text) {
         return;
@@ -3959,13 +5227,18 @@ fn text_anim_popups(
         "animator" => ("Add:", "add"),
         _ => return,
     };
-    p.text(pos2(x + 6.0, cy), Align2::LEFT_CENTER, label, Tokens::ui(11.5), t.text_dim);
-    let br = Rect::from_center_size(pos2(x + 6.0 + if key == "add" { 34.0 } else { 62.0 }, cy), vec2(16.0, 16.0));
-    let resp = ui.interact(br, egui::Id::unique(("tl-textanim", uid)), Sense::click()).on_hover_text(if key == "add" {
+    // The label is the English source; the drawn text is the catalog's, so the row reads
+    // アニメーター： as Animation ▸ Animate Text does. The button follows the width the label
+    // actually takes, since a translation is rarely as wide as the English it replaces.
+    let galley = p.layout_no_wrap(tr(label).to_string(), Tokens::ui(11.5), t.text_dim);
+    let text_w = galley.size().x;
+    p.galley(pos2(x + 6.0, cy - galley.size().y / 2.0), galley, t.text_dim);
+    let br = Rect::from_center_size(pos2(x + 6.0 + text_w + 10.0, cy), vec2(16.0, 16.0));
+    let resp = ui.interact(br, egui::Id::unique(("tl-textanim", uid)), Sense::click()).on_hover_text(tr(if key == "add" {
         "Add property or selector"
     } else {
         "Animate text"
-    });
+    }));
     icons::paint(p, br.shrink(3.0), Icon::ChevronRight, if resp.hovered() { t.text } else { t.text_dim });
     app.auto.add(&format!("timeline.group.{uid}.{key}"), br, label);
     let pop = egui::Id::unique(("tl-textanim-pop", uid));
@@ -3981,7 +5254,11 @@ fn text_anim_popups(
         opts.push("-".into());
         acts.push((String::new(), json!(null)));
         for (k, l) in TEXT_ANIMATOR_KINDS {
-            opts.push(l.to_string());
+            // The engine names these. `command_label` asks the menu for the row Animation ▸ Animate
+            // Text uses and falls back to the panel catalog, which holds the split names the menu
+            // does not list (`Fill Color: RGB` and the other colour rows), so no item is left in
+            // English. A separator is not a label.
+            opts.push(if *k == "-" { "-".into() } else { crate::i18n::command_label("layer.addTextAnimator", l).to_string() });
             acts.push(if *k == "-" { (String::new(), json!(null)) } else { ("layer.addTextAnimator".into(), json!({"layer": layer.id.0, "property": k})) });
         }
         // Variable Font Axes of the layer's font.
@@ -3993,19 +5270,19 @@ fn text_anim_popups(
                 acts.push((String::new(), json!(null)));
             }
             for a in axes {
-                opts.push(format!("Variable Font Axes: {}", a.name));
+                opts.push(tr_args("Variable Font Axes: {}", &[&a.name]));
                 acts.push(("text.animatorFontAxes".into(), json!({"layer": layer.id.0, "axis": a.tag})));
             }
         }
     } else {
         for (kind, l) in [("range", "Selector: Range"), ("wiggly", "Selector: Wiggly"), ("expression", "Selector: Expression")] {
-            opts.push(l.into());
+            opts.push(tr(l).to_string());
             acts.push(("layer.addTextSelector".into(), json!({"layer": layer.id.0, "animator": uid, "kind": kind})));
         }
         opts.push("-".into());
         acts.push((String::new(), json!(null)));
         for (k, l) in TEXT_ANIMATOR_KINDS {
-            opts.push(if *k == "-" { "-".into() } else { format!("Property: {l}") });
+            opts.push(if *k == "-" { "-".into() } else { tr_args("Property: {}", &[&crate::i18n::command_label("layer.addTextAnimator", l)]) });
             acts.push(if *k == "-" {
                 (String::new(), json!(null))
             } else {
@@ -4020,19 +5297,21 @@ fn text_anim_popups(
     }
 }
 
-/// The command for the Track Matte menu item `i` (`choice`) of `layer`, whose menu lists "No Track
-/// Matte", a separator, the matte `candidates`, a separator and the modes. A mode without a matte
-/// layer takes the layer above, like Layer ▸ Track Matte (#864: it used to do nothing).
-fn track_matte_pick(layer: &Layer, candidates: &[LayerId], i: usize, choice: &str) -> Option<(String, serde_json::Value)> {
+/// The command for the Track Matte menu item `i` (`choice`) of a row, setting `layers`' mattes,
+/// whose menu lists "No Track Matte", a separator, the matte `candidates`, a separator and the
+/// modes. A new matte layer keeps each layer's mode (the matte itself, if among them, is left
+/// out); a mode without a matte layer takes the layer above, like Layer ▸ Track Matte (#864: it
+/// used to do nothing).
+fn track_matte_pick(layers: &[u64], candidates: &[LayerId], i: usize, choice: &str) -> Option<(String, serde_json::Value)> {
     if i == 0 {
-        return Some(("layer.setTrackMatte".into(), json!({"layer": layer.id.0, "matte": null})));
+        return Some(("layer.setTrackMatte".into(), json!({"layers": layers, "matte": null})));
     }
     if let Some(m) = i.checked_sub(2).and_then(|j| candidates.get(j)) {
-        let kind = layer.track_matte.map(|m| m.kind).unwrap_or_default();
-        return Some(("layer.setTrackMatte".into(), json!({"layer": layer.id.0, "matte": m.0, "kind": kind_name(kind)})));
+        let layers: Vec<u64> = layers.iter().copied().filter(|l| *l != m.0).collect();
+        return (!layers.is_empty()).then(|| ("layer.setTrackMatte".into(), json!({"layers": layers, "matte": m.0, "kind": "preserve"})));
     }
     let k = MatteKind::ALL.into_iter().find(|k| k.label() == choice)?;
-    Some(("layer.trackMatte".into(), json!({"layers": [layer.id.0], "op": kind_name(k)})))
+    Some(("layer.trackMatte".into(), json!({"layers": layers, "op": kind_name(k)})))
 }
 
 fn kind_name(k: MatteKind) -> &'static str {
@@ -4128,7 +5407,6 @@ impl LayerMenuCaps {
 /// A layer row's or bar's context menu. As in After Effects, right-clicking a layer that is part
 /// of the selection keeps the selection and the menu acts on all of it; right-clicking an
 /// unselected layer selects only that layer.
-#[allow(clippy::too_many_arguments)]
 fn layer_context_menu(
     resp: &egui::Response,
     comp: &Comp,
@@ -4305,738 +5583,288 @@ fn fmt_num(v: f64, d: usize) -> String {
     format!("{v:.d$}")
 }
 
-/// Inline value editor for a property row; pushes `prop.set` actions. Returns the rects of a
-/// multi-dimension value's fields, one per dimension (none for other values).
-fn value_editor(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    p: &egui::Painter,
-    layer: &Layer,
-    prop: &Property,
-    value: &Value,
+/// What the property value editors share: where to draw, what they edit, and how a change is
+/// worded as a `prop.set` command.
+struct ValueEdit<'a> {
+    p: &'a egui::Painter,
+    layer: &'a Layer,
+    prop: &'a Property,
     at: Pos2,
-    actions: &mut Vec<(String, serde_json::Value)>,
-) -> Vec<Rect> {
-    let t = app.tokens;
-    let uid = prop.uid;
-    let mut dims = vec![];
-    let merge = format!("scrub-{uid}");
-    // With several layers selected the edit applies to all of them (#491): a scrub by the same
-    // change, a typed value as it is.
-    let scrub = ui.ctx().dragged_id().is_some() && ui.input(|i| i.pointer.is_decidedly_dragging());
-    // Proportional Scrubbing (After Effects 26.2): Ctrl+Alt (Cmd+Opt) spreads the change over the
-    // selected layers by selection order, the first unchanged and the last by all of it.
-    let proportional = scrub && ui.input(|i| widgets::proportional_scrub(i.modifiers));
-    let set = |actions: &mut Vec<(String, serde_json::Value)>, v: serde_json::Value| {
+    uid: u64,
+    merge: String,
+    scrub: bool,
+    proportional: bool,
+}
+
+impl<'a> ValueEdit<'a> {
+    /// The editor of `prop` on `layer` at `at`; `ui` says whether a scrub is under way.
+    fn new(ui: &egui::Ui, p: &'a egui::Painter, layer: &'a Layer, prop: &'a Property, at: Pos2) -> Self {
+        let uid = prop.uid;
+        // With several layers selected the edit applies to all of them (#491): a scrub by the same
+        // change, a typed value as it is.
+        let scrub = ui.ctx().dragged_id().is_some() && ui.input(|i| i.pointer.is_decidedly_dragging());
+        // Proportional Scrubbing (After Effects 26.2): Ctrl+Alt (Cmd+Opt) spreads the change over the
+        // selected layers by selection order, the first unchanged and the last by all of it.
+        let proportional = scrub && ui.input(|i| widgets::proportional_scrub(i.modifiers));
+        Self { p, layer, prop, at, uid, merge: format!("scrub-{uid}"), scrub, proportional }
+    }
+
+    /// Queues the `prop.set` of one edit; consecutive edits of the property (a scrub) are one undo step.
+    fn set(&self, actions: &mut Vec<(String, serde_json::Value)>, v: serde_json::Value) {
+        self.push(actions, v, Some(&self.merge));
+    }
+
+    /// Queues the `prop.set` of a discrete choice (a drop-down pick, a check box): its own undo
+    /// step, never merged with the property's previous edit (#2152).
+    fn set_step(&self, actions: &mut Vec<(String, serde_json::Value)>, v: serde_json::Value) {
+        self.push(actions, v, None);
+    }
+
+    fn push(&self, actions: &mut Vec<(String, serde_json::Value)>, v: serde_json::Value, merge: Option<&str>) {
         actions.push((
             "prop.set".into(),
-            json!({"layer": layer.id.0, "prop": uid, "value": v, "merge": merge, "selected": true, "offset": scrub, "proportional": proportional}),
+            json!({"layer": self.layer.id.0, "prop": self.uid, "value": v, "merge": merge, "selected": true, "offset": self.scrub, "proportional": self.proportional}),
         ))
-    };
-    let is_3d = layer.is_3d();
-    let mut x = at.x;
-    let y = at.y - 9.0;
+    }
+}
+
+/// Inline value editor for a property row; pushes `prop.set` actions. Returns the rects of a
+/// multi-dimension value's fields, one per dimension (none for other values).
+fn value_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, ve: &ValueEdit<'_>, value: &Value, actions: &mut Vec<(String, serde_json::Value)>) -> Vec<Rect> {
     match value {
-        Value::Scalar(v) => {
-            let (min, max, dec, speed) = match &prop.ui {
-                ParamUi::Slider { min, max, decimals, .. } => (*min, *max, *decimals as usize, widgets::slider_scrub_speed(&prop.ui)),
-                ParamUi::Percent => (-1e6, 1e6, 1, 0.5),
-                _ => (-1e9, 1e9, 1, 1.0),
-            };
-            if matches!(prop.ui, ParamUi::Angle) {
-                let (rr, dr, nv) = super::fx_widgets::angle_field(ui, pos2(x, y), egui::Id::unique(("v", uid, 0)), *v, 1, &t);
-                app.auto.add(&format!("timeline.prop.{uid}.value"), dr, &prop.name);
-                app.auto.add(&format!("timeline.prop.{uid}.revolutions"), rr, &prop.name);
-                if let Some(nv) = nv {
-                    set(actions, json!(nv));
-                }
-            } else {
-                // A Range Selector's Start, End and Offset count characters with Units = Index (#1814).
-                let pct = (matches!(prop.ui, ParamUi::Percent) || prop.match_id == "opacity") && !effectcraft_engine::render::text::in_index_units(layer, uid);
-                let suffix = if pct { "%" } else { "" };
-                let (r, nv, _) = widgets::hot_number_at(ui, pos2(x, y), egui::Id::unique(("v", uid, 0)), *v, speed, (min, max), dec.max(1), suffix, &t);
-                app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
-                if let Some(nv) = nv {
-                    set(actions, json!(nv));
-                }
-            }
-        }
-        Value::Vec2(_) | Value::Vec3(_) => {
-            let c = value.components();
-            let n = if prop.shown_dims > 0 && !(is_3d && c.len() == 3) { prop.shown_dims as usize } else { c.len() };
-            let pct = matches!(prop.ui, ParamUi::Percent);
-            // Mask Feather: two linked values, never negative (as in After Effects, #203).
-            let feather = prop.match_id == "feather" && layer.props.parent_of(uid).is_some_and(|g| matches!(g.kind, GroupKind::Mask { .. }));
-            let range = if feather { (0.0, 1e9) } else { (-1e9, 1e9) };
-            // Scale and Mask Feather: the chain link (Constrain Proportions, on by default).
-            let linkable = feather || (pct && prop.match_id == "scale");
-            let linked = linkable && !app.ui.timeline.unlinked.contains(&uid);
-            if linkable {
-                let lr = Rect::from_center_size(pos2(x + 7.0, at.y), vec2(14.0, 14.0));
-                let resp = ui.interact(lr, egui::Id::unique(("tl-link", uid)), Sense::click()).on_hover_text(crate::i18n::tr("Constrain Proportions"));
-                icons::paint(p, lr, Icon::Link, if linked { t.accent } else { t.text_faint });
-                app.auto.add(&format!("timeline.prop.{uid}.link"), lr, "Constrain Proportions");
-                if resp.clicked() && !app.ui.timeline.unlinked.remove(&uid) {
-                    app.ui.timeline.unlinked.insert(uid);
-                }
-                x += 18.0;
-            }
-            for d in 0..n.min(c.len()) {
-                let suffix = if pct && d + 1 == n { "%" } else { "" };
-                let (r, nv, _) =
-                    widgets::hot_number_at(ui, pos2(x, y), egui::Id::unique(("v", uid, d)), c[d], if pct { 0.5 } else { 1.0 }, range, 1, suffix, &t);
-                app.auto.add(&format!("timeline.prop.{uid}.value.{d}"), r, &prop.name);
-                dims.push(r);
-                if let Some(nv) = nv {
-                    let mut nc = c.clone();
-                    // Alt edits one value of a linked pair (Ctrl+Alt is a proportional scrub).
-                    let shown = if linked && !ui.input(|i| i.modifiers.alt && !widgets::proportional_scrub(i.modifiers)) { n.min(c.len()) } else { 1 };
-                    let from = if shown == 1 { d } else { 0 };
-                    for (e, v) in widgets::constrained(c.get(from..from + shown).unwrap_or_default(), d - from, nv).into_iter().enumerate() {
-                        if let Some(slot) = nc.get_mut(from + e) {
-                            *slot = v;
-                        }
-                    }
-                    set(actions, json!(nc));
-                    // Typed into these components only: other selected layers keep the rest of
-                    // their own value (#1434).
-                    if let Some((_, a)) = actions.last_mut() {
-                        a["dims"] = json!((from..from + shown).collect::<Vec<_>>());
-                    }
-                }
-                x = r.max.x + if d + 1 < n { 2.0 } else { 0.0 };
-                if d + 1 < n {
-                    p.text(pos2(x, at.y), Align2::LEFT_CENTER, ",", Tokens::ui(12.0), t.hot_text);
-                    x += 6.0;
-                }
-            }
-        }
-        Value::Color(c) => {
-            let r = Rect::from_min_size(pos2(x, at.y - 7.0), vec2(26.0, 14.0));
-            let resp = widgets::swatch(ui, r, [c[0] as f32, c[1] as f32, c[2] as f32, 1.0], egui::Id::unique(("sw", uid)), &t);
-            app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
-            let pop = egui::Id::unique(("cpop", uid));
-            if resp.clicked() {
-                widgets::open_popup(ui, pop);
-            }
-            // The eyedropper after the swatch samples the Composition panel (shape Fill and
-            // Stroke colours, text and effect colours), as in After Effects' Timeline (#633).
-            let er = Rect::from_center_size(pos2(r.max.x + 12.0, at.y), vec2(16.0, 16.0));
-            let active = app.ui.fx_pick.as_ref().is_some_and(|k| k.prop == uid && k.kind == "color");
-            if super::fx_widgets::eyedropper_button(ui, er, active, egui::Id::unique(("tl-eye", uid)), &t)
-                .on_hover_text(crate::i18n::tr("Eyedropper: click, then click in the Composition panel"))
-                .clicked()
-            {
-                super::effect_controls::toggle_pick(app, "color", layer, prop);
-            }
-            app.auto.add(&format!("timeline.prop.{uid}.eyedropper"), er, &prop.name);
-            let mut rgb = [c[0] as f32, c[1] as f32, c[2] as f32];
-            if crate::widgets::color_popup(ui, pop, r.left_bottom(), &mut rgb) {
-                set(actions, json!([rgb[0], rgb[1], rgb[2], 1.0]));
-            }
-        }
-        Value::Bool(b) => {
-            let r = Rect::from_min_size(pos2(x, at.y - 8.0), vec2(16.0, 16.0));
-            if widgets::checkbox(ui, r, *b, &t, egui::Id::unique(("cb", uid))).clicked() {
-                set(actions, json!(!b));
-            }
-            app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
-        }
-        Value::Enum(i) => {
-            // Text Path Options ▸ Path lists the layer's masks.
-            let mask_opts: Option<Vec<String>> = layer
-                .props
-                .prop("text/pathOptions/path")
-                .filter(|q| q.uid == uid)
-                .map(|_| std::iter::once("None".to_string()).chain(layer.masks().into_iter().flat_map(|m| m.groups().map(|g| g.name.clone()))).collect());
-            let ui_opts = mask_opts.map(|options| ParamUi::Popup { options });
-            if let ParamUi::Popup { options } = ui_opts.as_ref().unwrap_or(&prop.ui) {
-                let r = Rect::from_min_size(pos2(x, at.y - 9.0), vec2(150.0, 18.0));
-                let label = options.get(*i as usize).cloned().unwrap_or_default();
-                let pop = egui::Id::unique(("epop", uid));
-                if widgets::dropdown(ui, r, &label, &t, egui::Id::unique(("en", uid))).clicked() {
-                    widgets::open_popup(ui, pop);
-                }
-                app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
-                if let Some(ni) = widgets::popup_menu(ui, pop, r.left_bottom(), options, Some(*i as usize)) {
-                    set(actions, json!(ni));
-                }
-            } else {
-                p.text(pos2(x, at.y), Align2::LEFT_CENTER, fmt_num(*i as f64, 0), Tokens::ui(12.0), t.hot_text);
-            }
-        }
+        Value::Scalar(_) => scalar_editor(app, ui, ve, actions, value),
+        Value::Vec2(_) | Value::Vec3(_) => return vector_editor(app, ui, ve, actions, value),
+        Value::Color(_) => color_editor(app, ui, ve, actions, value),
+        Value::Bool(_) => bool_editor(app, ui, ve, actions, value),
+        Value::Enum(_) => enum_editor(app, ui, ve, actions, value),
+        Value::Layer(_) => layer_editor(app, ui, ve, actions, value),
+        Value::Gradient(_) => gradient_editor(app, ui, ve, actions),
         Value::Path(_) => {
-            p.text(pos2(x, at.y), Align2::LEFT_CENTER, crate::i18n::tr("Shape…"), Tokens::ui(12.0), t.hot_text);
+            ve.p.text(pos2(ve.at.x, ve.at.y), Align2::LEFT_CENTER, crate::i18n::tr("Shape…"), Tokens::ui(12.0), app.tokens.hot_text);
         }
         Value::Text(_) => {}
-        Value::Layer(l) => {
-            // Layer references (a light's Source, a Displacement Map's layer…) pick from the
-            // comp's layers, as in Effect Controls; the choice is written through the same
-            // undoable prop.set as the other value arms.
-            let r = Rect::from_min_size(pos2(x, at.y - 9.0), vec2(150.0, 18.0));
-            if let Some(comp) = app.session.active_comp_arc()
-                && let Some(chosen) = widgets::layer_picker(ui, r, &comp.layers, *l, &t, egui::Id::unique(("tl-lay", uid)))
-            {
-                set(actions, chosen.map(|id| json!(id)).unwrap_or(serde_json::Value::Null));
-            }
-            app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
-        }
-        Value::Gradient(_) => {
-            // Opens the Gradient Editor at the current time (#612).
-            let r = p.text(pos2(x, at.y), Align2::LEFT_CENTER, crate::i18n::tr("Edit Gradient…"), Tokens::ui(12.0), t.hot_text);
-            let resp = ui.interact(r.expand(2.0), egui::Id::unique(("gradient-edit", uid)), Sense::click());
-            if resp.hovered() {
-                ui.ctx().set_cursor_icon(egui::CursorIcon::PointingHand);
-            }
-            app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
-            if resp.clicked() {
-                actions.push(("prop.editGradient".into(), json!({"layer": layer.id.0, "prop": uid})));
-            }
-        }
         Value::Str(s) => {
-            p.text(pos2(x, at.y), Align2::LEFT_CENTER, s.chars().take(30).collect::<String>(), Tokens::ui(12.0), t.text_dim);
+            ve.p.text(pos2(ve.at.x, ve.at.y), Align2::LEFT_CENTER, s.chars().take(30).collect::<String>(), Tokens::ui(12.0), app.tokens.text_dim);
+        }
+    }
+    Vec::new()
+}
+
+/// A number: scrubbable hot text, or the angle field.
+fn scalar_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, ve: &ValueEdit<'_>, actions: &mut Vec<(String, serde_json::Value)>, value: &Value) {
+    let Value::Scalar(v) = value else { return };
+    let (layer, prop, at, uid) = (ve.layer, ve.prop, ve.at, ve.uid);
+    // The values themselves: red while an expression drives the property (#1306).
+    let vt = app.tokens.for_value(prop.has_expression());
+    let (x, y) = (at.x, at.y - 9.0);
+    let (min, max, dec, speed) = match &prop.ui {
+        ParamUi::Slider { min, max, decimals, .. } => (*min, *max, *decimals as usize, widgets::slider_scrub_speed(&prop.ui)),
+        ParamUi::Percent => (-1e6, 1e6, 1, 0.5),
+        _ => (-1e9, 1e9, 1, 1.0),
+    };
+    if matches!(prop.ui, ParamUi::Angle) {
+        let (rr, dr, nv) = super::fx_widgets::angle_field(ui, pos2(x, y), egui::Id::unique(("v", uid, 0)), *v, 1, &vt);
+        app.auto.add(&format!("timeline.prop.{uid}.value"), dr, &prop.name);
+        app.auto.add(&format!("timeline.prop.{uid}.revolutions"), rr, &prop.name);
+        if let Some(nv) = nv {
+            ve.set(actions, json!(nv));
+        }
+    } else {
+        // A Range Selector's Start, End and Offset count characters with Units = Index (#1814).
+        let pct = (matches!(prop.ui, ParamUi::Percent) || prop.match_id == "opacity") && !effectcraft_engine::render::text::in_index_units(layer, uid);
+        let suffix = if pct { "%" } else { "" };
+        let (r, nv, _) = widgets::hot_number_at(
+            ui,
+            pos2(x, y),
+            egui::Id::unique(("v", uid, 0)),
+            *v,
+            &widgets::HotSpec { speed, range: (min, max), decimals: dec.max(1), suffix },
+            &vt,
+        );
+        app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
+        if let Some(nv) = nv {
+            ve.set(actions, json!(nv));
+        }
+    }
+}
+
+/// A multi-dimension value: one hot-text field per dimension, with the link chain. Returns their rects.
+fn vector_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, ve: &ValueEdit<'_>, actions: &mut Vec<(String, serde_json::Value)>, value: &Value) -> Vec<Rect> {
+    let (p, layer, prop, at, uid) = (ve.p, ve.layer, ve.prop, ve.at, ve.uid);
+    let t = app.tokens;
+    let vt = t.for_value(prop.has_expression());
+    let (mut x, y) = (at.x, at.y - 9.0);
+    let is_3d = layer.is_3d();
+    let mut dims = vec![];
+    let c = value.components();
+    let n = if prop.shown_dims > 0 && !(is_3d && c.len() == 3) { prop.shown_dims as usize } else { c.len() };
+    let pct = matches!(prop.ui, ParamUi::Percent);
+    // Mask Feather: two linked values, never negative (as in After Effects, #203).
+    let feather = prop.match_id == "feather" && layer.props.parent_of(uid).is_some_and(|g| matches!(g.kind, GroupKind::Mask { .. }));
+    let range = if feather { (0.0, 1e9) } else { (-1e9, 1e9) };
+    // Audio Levels link their two channels too, off by default, by the same dB change (#2485).
+    let levels = prop.match_id == "levels" && layer.props.parent_of(uid).is_some_and(|g| g.match_id == "audio");
+    // Scale and Mask Feather: the chain link (Constrain Proportions, on by default).
+    // Rectangle and Ellipse Path Size have it too, off by default (#2489).
+    let size = prop.match_id == "size" && layer.props.parent_of(uid).is_some_and(|g| matches!(g.match_id.as_str(), "rect" | "ellipse"));
+    let linkable = feather || size || levels || (pct && prop.match_id == "scale");
+    let linked = linkable && app.ui.timeline.is_linked(uid, !(size || levels));
+    if linkable {
+        let lr = Rect::from_center_size(pos2(x + 7.0, at.y), vec2(14.0, 14.0));
+        let label = if levels { "Link Channels" } else { "Constrain Proportions" };
+        let resp = ui.interact(lr, egui::Id::unique(("tl-link", uid)), Sense::click()).on_hover_text(crate::i18n::tr(label));
+        icons::paint(p, lr, Icon::Link, if linked { t.accent } else { t.text_faint });
+        app.auto.add(&format!("timeline.prop.{uid}.link"), lr, label);
+        if resp.clicked() {
+            app.ui.timeline.toggle_link(uid, !(size || levels));
+        }
+        x += 18.0;
+    }
+    for d in 0..n.min(c.len()) {
+        let suffix = if pct && d + 1 == n { "%" } else { "" };
+        let (r, nv, _) = widgets::hot_number_at(
+            ui,
+            pos2(x, y),
+            egui::Id::unique(("v", uid, d)),
+            c[d],
+            &widgets::HotSpec { speed: if pct { 0.5 } else { 1.0 }, range, decimals: 1, suffix },
+            &vt,
+        );
+        app.auto.add(&format!("timeline.prop.{uid}.value.{d}"), r, &prop.name);
+        dims.push(r);
+        if let Some(nv) = nv {
+            let mut nc = c.clone();
+            // Alt edits one value of a linked pair (Ctrl+Alt is a proportional scrub).
+            let shown = if linked && !ui.input(|i| i.modifiers.alt && !widgets::proportional_scrub(i.modifiers)) { n.min(c.len()) } else { 1 };
+            let from = if shown == 1 { d } else { 0 };
+            let link = if levels { widgets::shifted } else { widgets::constrained };
+            for (e, v) in link(c.get(from..from + shown).unwrap_or_default(), d - from, nv).into_iter().enumerate() {
+                if let Some(slot) = nc.get_mut(from + e) {
+                    *slot = v;
+                }
+            }
+            ve.set(actions, json!(nc));
+            // Typed into these components only: other selected layers keep the rest of
+            // their own value (#1434).
+            // Linked Audio Levels: the typed channel, the other following by that layer's own
+            // change, so each keeps its balance (#2485).
+            if let Some((_, a)) = actions.last_mut() {
+                if levels {
+                    a["dims"] = json!([d]);
+                    a["follow"] = json!((from..from + shown).filter(|&e| e != d).collect::<Vec<_>>());
+                } else {
+                    a["dims"] = json!((from..from + shown).collect::<Vec<_>>());
+                }
+            }
+        }
+        x = r.max.x + if d + 1 < n { 2.0 } else { 0.0 };
+        if d + 1 < n {
+            p.text(pos2(x, at.y), Align2::LEFT_CENTER, ",", Tokens::ui(12.0), vt.hot_text);
+            x += 6.0;
         }
     }
     dims
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// Alt/Option-drag takes the same Project items `layer.replaceSource` does: compositions,
-    /// footage and solids, never folders, data files or 3D models.
-    #[test]
-    fn replace_source_takes_visual_items_only() {
-        use effectcraft_engine::color::Label;
-        use effectcraft_engine::project::{Comp, Footage, Project, Solid};
-        use effectcraft_engine::time::{FrameRate, Tick};
-        let mut p = Project::default();
-        let l = Label::None;
-        let comp = p.add_item("C", l, None, ItemKind::Comp(Comp::new(10, 10, FrameRate::FPS_30, Tick::from_seconds_f64(1.0)).into()));
-        let folder = p.add_item("F", l, None, ItemKind::Folder);
-        let still = p.add_item("S", l, None, ItemKind::Footage(Footage { kind: FootageKind::Still, ..Default::default() }));
-        let data = p.add_item("D", l, None, ItemKind::Footage(Footage { kind: FootageKind::Data, ..Default::default() }));
-        let model = p.add_item("M", l, None, ItemKind::Footage(Footage { kind: FootageKind::Model, ..Default::default() }));
-        let solid = p.add_item("So", l, None, ItemKind::Solid(Solid { color: [0.0; 3], width: 10, height: 10, pixel_aspect: 1.0 }));
-        for (id, ok) in [(comp, true), (still, true), (solid, true), (folder, false), (data, false), (model, false)] {
-            assert_eq!(replaceable_item(p.item(id).unwrap()), ok, "{id:?}");
-        }
+/// A colour: swatch, eyedropper and picker.
+fn color_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, ve: &ValueEdit<'_>, actions: &mut Vec<(String, serde_json::Value)>, value: &Value) {
+    let Value::Color(c) = value else { return };
+    let (layer, prop, at, uid) = (ve.layer, ve.prop, ve.at, ve.uid);
+    let t = app.tokens;
+    let x = at.x;
+    let r = Rect::from_min_size(pos2(x, at.y - 7.0), vec2(26.0, 14.0));
+    let resp = widgets::swatch(ui, r, [c[0] as f32, c[1] as f32, c[2] as f32, 1.0], egui::Id::unique(("sw", uid)), &t);
+    app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
+    let pop = egui::Id::unique(("cpop", uid));
+    if resp.clicked() {
+        widgets::open_popup(ui, pop);
     }
-
-    /// Alt/Cmd-click twirls Audio's Waveform row (not in the property tree) with the rest.
-    #[test]
-    fn the_waveform_row_twirls_with_its_tree() {
-        let mut root = PropGroup::new(1, "", "");
-        let mut audio = PropGroup::new(2, "audio", "Audio");
-        audio.children.push(PropGroup::new(3, "x", "X").into());
-        root.children.push(audio.into());
-        let mut uids = vec![];
-        walk_groups(&root, &mut uids);
-        assert_eq!(uids, vec![2, WAVE_BIT | 2, 3]);
-        let mut uids = vec![];
-        walk_groups(find_group(&root, 2).unwrap(), &mut uids);
-        assert_eq!(uids, vec![WAVE_BIT | 2, 3]);
+    // The eyedropper after the swatch samples the Composition panel (shape Fill and
+    // Stroke colours, text and effect colours), as in After Effects' Timeline (#633).
+    let er = Rect::from_center_size(pos2(r.max.x + 12.0, at.y), vec2(16.0, 16.0));
+    let active = app.ui.fx_pick.as_ref().is_some_and(|k| k.prop == uid && k.kind == "color");
+    if super::fx_widgets::eyedropper_button(ui, er, active, egui::Id::unique(("tl-eye", uid)), &t)
+        .on_hover_text(crate::i18n::tr("Eyedropper: click, then click in the Composition panel"))
+        .clicked()
+    {
+        super::effect_controls::toggle_pick(app, "color", layer, prop);
     }
-
-    /// #710: with Time Display set to Frames the ruler labels are frame numbers (as under the
-    /// CTI, from Start Numbering Frames At); otherwise seconds:frames.
-    #[test]
-    fn ruler_labels_follow_the_time_display_style() {
-        use effectcraft_engine::project::{ProjectSettings, TimeDisplayStyle};
-        let mut st = ProjectSettings { time_display: TimeDisplayStyle::Timecode, frame_start: 0, ..ProjectSettings::default() };
-        assert_eq!(ruler_label(15, 30, &st), "00:15f");
-        assert_eq!(ruler_label(45, 30, &st), "01:15f");
-        assert_eq!(ruler_label(30 * 3600 + 31, 30, &st), "60:01:01f");
-        st.time_display = TimeDisplayStyle::Frames;
-        assert_eq!(ruler_label(0, 30, &st), "00000");
-        assert_eq!(ruler_label(45, 30, &st), "00045");
-        st.frame_start = 1;
-        assert_eq!(ruler_label(45, 30, &st), "00046");
-        assert_eq!(ruler_label(i64::MAX, 30, &st), format!("{:05}", i64::MAX));
-    }
-
-    /// #468: playback pages the view to the CTI; a scrub past either end scrolls that way.
-    #[test]
-    fn the_view_pages_to_the_cti() {
-        assert_eq!(page_to_cti(10.0, 5.0, 60.0, 12.0), 10.0, "in view: unchanged");
-        assert_eq!(page_to_cti(10.0, 5.0, 60.0, 16.0), 16.0, "past the right end: the page from the CTI");
-        assert_eq!(page_to_cti(10.0, 5.0, 60.0, 3.0), 3.0, "before the start");
-        assert_eq!(page_to_cti(10.0, 5.0, 60.0, 58.0), 55.0, "not past the comp's end");
-        assert_eq!(page_to_cti(10.0, 80.0, 60.0, 95.0), 0.0);
-        assert_eq!(page_to_cti(10.0, f64::NAN, 60.0, 95.0), 10.0);
-        assert_eq!(edge_scroll_speed_x(100.0, 500.0, 300.0), 0.0);
-        assert!(edge_scroll_speed_x(100.0, 500.0, 501.0) > 0.0 && edge_scroll_speed_x(100.0, 500.0, 99.0) < 0.0);
-        assert!(edge_scroll_speed_x(100.0, 500.0, 600.0) > edge_scroll_speed_x(100.0, 500.0, 520.0));
-    }
-
-    /// #864: picking only a mode in a layer's Track Matte menu sets a matte (the layer above);
-    /// it used to close the menu and change nothing.
-    #[test]
-    fn a_track_matte_mode_without_a_matte_takes_the_layer_above() {
-        let mut s = effectcraft_engine::Session::default();
-        s.execute("comp.new", json!({"name": "T", "width": 64, "height": 64, "duration": 1})).unwrap();
-        for name in ["Chain Bottom", "Matte", "Chain Top"] {
-            s.execute("layer.newSolid", json!({"name": name, "color": "#ffffff", "width": 64, "height": 64})).unwrap();
-        }
-        let find = |s: &effectcraft_engine::Session, n: &str| s.active_comp().unwrap().layers.iter().find(|l| l.name == n).unwrap().clone();
-        let (bottom, matte, top) = (find(&s, "Chain Bottom"), find(&s, "Matte"), find(&s, "Chain Top"));
-        let candidates = [top.id, matte.id];
-        let pick = |s: &mut effectcraft_engine::Session, name: &str, i: usize, choice: &str| {
-            let (id, params) = track_matte_pick(&find(s, name), &candidates, i, choice).expect("a menu item is an action");
-            s.execute(&id, params)
-        };
-        pick(&mut s, "Chain Bottom", 5, "Alpha Inverted Matte").unwrap();
-        let m = find(&s, "Chain Bottom").track_matte.expect("a matte");
-        assert_eq!((m.layer, m.kind), (matte.id, MatteKind::AlphaInverted));
-        assert!(!find(&s, "Matte").switches.video, "the matte layer is hidden");
-        // A mode change keeps the matte layer; a matte change keeps the mode.
-        pick(&mut s, "Chain Bottom", 6, "Luma Matte").unwrap();
-        assert_eq!(find(&s, "Chain Bottom").track_matte.map(|m| (m.layer, m.kind)), Some((matte.id, MatteKind::Luma)));
-        pick(&mut s, "Chain Bottom", 2, "1. Chain Top").unwrap();
-        assert_eq!(find(&s, "Chain Bottom").track_matte.map(|m| (m.layer, m.kind)), Some((top.id, MatteKind::Luma)));
-        assert!(s.undo());
-        assert_eq!(find(&s, "Chain Bottom").track_matte.map(|m| m.layer), Some(matte.id), "one undo step per pick");
-        // The top layer has nothing above it: an error for the status bar, not a silent no-op.
-        assert!(pick(&mut s, "Chain Top", 5, "Alpha Matte").is_err());
-        pick(&mut s, "Chain Bottom", 0, "No Track Matte").unwrap();
-        assert!(find(&s, "Chain Bottom").track_matte.is_none());
-        assert!(track_matte_pick(&bottom, &candidates, 1, "-").is_none(), "a separator does nothing");
-    }
-
-    /// #957: vector footage gets the Continuously Rasterize switch; raster footage does not.
-    #[test]
-    fn collapse_switch_shows_for_vector_footage_only() {
-        use effectcraft_engine::color::Label;
-        use effectcraft_engine::project::{Footage, ItemKind, Project};
-        let mut p = Project::default();
-        let mut layer_for = |name: &str, codec: &str| {
-            let footage = Footage { path: name.into(), codec: codec.into(), ..Default::default() };
-            let item = p.add_item(name, Label::SeaFoam, None, ItemKind::Footage(footage));
-            let comp = Comp::new(64, 36, effectcraft_engine::time::FrameRate::new(30, 1), Tick::from_seconds_f64(1.0));
-            effectcraft_engine::project::build::layer(&mut p, &comp, name, LayerSource::Footage { item }, (0, 0), None)
-        };
-        let svg = layer_for("logo.svg", "SVG");
-        let png = layer_for("photo.png", "PNG");
-        assert!(collapse_applies(&svg, &p));
-        assert!(!collapse_applies(&png, &p));
-    }
-
-    /// A comp with two solids; "Box" has an animated Position and a Gaussian Blur.
-    fn app() -> EffectcraftApp {
-        let mut s = effectcraft_engine::Session::default();
-        s.execute("comp.new", json!({"name": "T", "width": 320, "height": 180, "duration": 4})).unwrap();
-        s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080", "width": 320, "height": 180})).unwrap();
-        s.execute("layer.newSolid", json!({"name": "Box", "color": "#e04020", "width": 40, "height": 40})).unwrap();
-        let comp = s.active_comp().unwrap();
-        let bx = comp.layers.iter().find(|l| l.name == "Box").unwrap().id.0;
-        s.execute("layer.select", json!({"layers": [bx]})).unwrap();
-        s.execute("effect.apply", json!({"effect": "ec.blur.gaussian"})).unwrap();
-        let pos = s.active_comp().unwrap().layer(LayerId(bx)).unwrap().transform().unwrap().get("position").unwrap().uid;
-        s.execute("prop.toggleAnimation", json!({"layer": bx, "prop": pos})).unwrap();
-        EffectcraftApp::new(s)
-    }
-
-    fn labels(app: &EffectcraftApp) -> Vec<String> {
-        let comp = app.session.active_comp().unwrap().clone();
-        build_rows(app, &comp)
-            .into_iter()
-            .map(|r| {
-                let l = comp.layer(r.layer).unwrap();
-                match r.kind {
-                    RowKind::Layer => l.name.clone(),
-                    RowKind::Group { name, .. } => format!("{}>{name}", "  ".repeat(r.depth)),
-                    RowKind::Prop { uid } => format!("{}{}", "  ".repeat(r.depth), l.props.find(uid).unwrap().name),
-                    _ => "?".into(),
-                }
-            })
-            .collect()
-    }
-
-    #[test]
-    fn search_filters_layers_and_reveals_matching_properties() {
-        let mut app = app();
-        app.ui.timeline.search = "opac".into();
-        let rows = labels(&app);
-        // Both layers have Transform > Opacity; nothing else shows.
-        assert_eq!(rows.iter().filter(|r| r.trim() == "Opacity").count(), 2, "{rows:?}");
-        assert!(rows.iter().any(|r| r.trim() == ">Transform"), "{rows:?}");
-        assert!(!rows.iter().any(|r| r.trim() == "Position"), "{rows:?}");
-        // A layer name match shows the layer alone; a group match brings its contents.
-        app.ui.timeline.search = "plate".into();
-        assert_eq!(labels(&app), vec!["Plate".to_string()]);
-        app.ui.timeline.search = "GAUSSIAN".into();
-        let rows = labels(&app);
-        assert_eq!(rows[0], "Box");
-        assert!(rows.iter().any(|r| r.trim() == ">Effects") && rows.iter().any(|r| r.trim() == "Blurriness"), "{rows:?}");
-        assert!(!rows.contains(&"Plate".to_string()));
-        // Nothing matches → no rows.
-        app.ui.timeline.search = "zzz".into();
-        assert!(labels(&app).is_empty());
-        // Through the command.
-        let ctx = egui::Context::default();
-        crate::menus::invoke(&mut app, &ctx, "timeline.search", json!({"query": "scale"})).unwrap();
-        assert!(labels(&app).iter().any(|r| r.trim() == "Scale"));
-    }
-
-    /// A shape group's inner Contents (AE's elided `ADBE Vectors Group`) draws no row: the
-    /// search shows the full row hierarchy with the group's items — path, fill and Transform —
-    /// listing directly under the group, and the only "Contents" row the layer's own.
-    #[test]
-    fn shape_group_inner_contents_is_elided() {
-        let mut s = effectcraft_engine::Session::default();
-        s.execute("comp.new", json!({"name": "T", "width": 320, "height": 180, "duration": 4})).unwrap();
-        s.execute("layer.newShape", json!({"kind": "rect"})).unwrap();
-        let mut app = EffectcraftApp::new(s);
-        app.ui.timeline.search = "rect".into();
-        assert_eq!(
-            labels(&app),
-            [
-                "Shape Layer 1",
-                "  >Contents",
-                "    >Rectangle 1",
-                "      >Rectangle Path 1",
-                "        Size",
-                "        Position",
-                "        Roundness",
-                "      >Fill 1",
-                "        Composite",
-                "        Fill Rule",
-                "        Color",
-                "        Opacity",
-                "      >Transform",
-                "        Anchor Point",
-                "        Position",
-                "        Scale",
-                "        Skew",
-                "        Skew Axis",
-                "        Rotation",
-                "        Opacity",
-            ]
-            .iter()
-            .map(|r| r.to_string())
-            .collect::<Vec<_>>()
-        );
-    }
-
-    #[test]
-    fn columns_toggle_and_layout() {
-        let mut app = app();
-        let tl = &mut app.ui.timeline;
-        assert!(column_visible(tl, "switches") && !column_visible(tl, "comment") && !column_visible(tl, "modes"));
-        set_column(tl, "comment", true).unwrap();
-        set_column(tl, "stretch", true).unwrap();
-        set_column(tl, "keys", false).unwrap();
-        set_column(tl, "label", false).unwrap();
-        set_column(tl, "modes", true).unwrap();
-        assert!(tl.show_modes && column_visible(tl, "comment") && !column_visible(tl, "label"));
-        assert!(set_column(tl, "name", false).is_err());
-        assert!(set_column(tl, "bogus", true).is_err());
-        let vis = Vis::of(tl);
-        let cw = cols(0.0, 1400.0, vis);
-        // Hidden columns take no room; visible ones are in After Effects' order.
-        assert_eq!(cw.keys, cw.label);
-        assert_eq!(cw.label, cw.num);
-        assert!(cw.name < cw.comment && cw.comment < cw.switches && cw.switches < cw.mode && cw.parent < cw.stretch);
-        assert_eq!(column_at(&cw, cw.comment + 5.0), Some("comment"));
-        assert_eq!(column_at(&cw, cw.name + 5.0), Some("name"));
-        assert_eq!(column_at(&cw, cw.stretch + 5.0), Some("stretch"));
-        // Through the command (as agents do).
-        let ctx = egui::Context::default();
-        let r = crate::menus::invoke(&mut app, &ctx, "timeline.column", json!({"column": "duration"})).unwrap();
-        assert!(r["columns"].as_array().unwrap().iter().any(|c| c == "duration"));
-        crate::menus::invoke(&mut app, &ctx, "timeline.column", json!({"column": "duration", "visible": false})).unwrap();
-        assert!(!column_visible(&app.ui.timeline, "duration"));
-        crate::menus::invoke(&mut app, &ctx, "timeline.sourceName", json!({})).unwrap();
-        assert!(app.ui.timeline.source_name);
-    }
-
-    #[test]
-    fn reveal_keys_add_with_shift_and_uu_reveals_modified() {
-        let mut app = app();
-        let ctx = egui::Context::default();
-        crate::menus::invoke(&mut app, &ctx, "timeline.reveal.opacity", json!({})).unwrap();
-        assert_eq!(app.ui.timeline.reveal, vec!["opacity"]);
-        crate::menus::invoke(&mut app, &ctx, "timeline.revealAdd.scale", json!({})).unwrap();
-        crate::menus::invoke(&mut app, &ctx, "timeline.revealAdd.effects", json!({})).unwrap();
-        assert_eq!(app.ui.timeline.reveal, vec!["opacity", "scale", "effects"]);
-        let rows = labels(&app);
-        assert!(rows.iter().any(|r| r.trim() == "Scale") && rows.iter().any(|r| r.trim() == "Opacity"), "{rows:?}");
-        assert!(rows.iter().any(|r| r.trim() == ">Gaussian Blur"), "{rows:?}");
-        // Tree order: Scale before Opacity.
-        let si = rows.iter().position(|r| r.trim() == "Scale").unwrap();
-        let oi = rows.iter().position(|r| r.trim() == "Opacity").unwrap();
-        assert!(si < oi);
-        // Shift+S again removes Scale.
-        crate::menus::invoke(&mut app, &ctx, "timeline.revealAdd.scale", json!({})).unwrap();
-        assert_eq!(app.ui.timeline.reveal, vec!["opacity", "effects"]);
-        // U: keyframed properties (Position); UU (twice quickly): every modified property.
-        crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
-        let n_keys = app.ui.timeline.reveal_props.len();
-        assert_eq!(app.ui.timeline.reveal, vec!["props"]);
-        assert!(n_keys >= 1);
-        let bx = app.session.state.selected_layers[0].0;
-        app.session.execute("prop.set", json!({"layer": bx, "path": "effects/#1/blurriness", "value": 12})).unwrap();
-        crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
-        assert!(app.ui.timeline.reveal_props.len() > n_keys, "UU reveals modified properties too");
-    }
-
-    #[test]
-    fn scroll_to_time_centres_the_current_time_inside_the_comp() {
-        assert_eq!(centered_on(4.0, 10.0, 5.0), 3.0);
-        // Near the ends the view stops at the comp's start and end.
-        assert_eq!(centered_on(4.0, 10.0, 1.0), 0.0);
-        assert_eq!(centered_on(4.0, 10.0, 9.5), 6.0);
-        // A span longer than the comp, and bad numbers, start at zero.
-        assert_eq!(centered_on(20.0, 10.0, 5.0), 0.0);
-        assert_eq!(centered_on(f64::NAN, 10.0, 5.0), 0.0);
-    }
-
-    /// U and the other reveal shortcuts act on the selected layers only: other layers keep their
-    /// twirl state and their own reveal (#160).
-    #[test]
-    fn reveal_shortcuts_leave_unselected_layers_alone() {
-        let mut app = app();
-        let ctx = egui::Context::default();
-        let comp = app.session.active_comp().unwrap().clone();
-        let id = |n: &str| comp.layers.iter().find(|l| l.name == n).unwrap().id.0;
-        let (plate, bx) = (id("Plate"), id("Box"));
-        let select = |app: &mut EffectcraftApp, l: u64| app.session.execute("layer.select", json!({"layers": [l]})).unwrap();
-        // Plate shows Scale (S); then U on Box.
-        select(&mut app, plate);
-        crate::menus::invoke(&mut app, &ctx, "timeline.reveal.scale", json!({})).unwrap();
-        select(&mut app, bx);
-        crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
-        let tl = &app.ui.timeline;
-        assert!(tl.open_layers.contains(&plate) && tl.open_layers.contains(&bx), "{:?}", tl.open_layers);
-        assert_eq!(tl.layer_reveal.get(&plate), Some(&vec!["scale".to_string()]), "Plate keeps its reveal");
-        assert_eq!(tl.layer_reveal.get(&bx), Some(&vec!["props".to_string()]));
-        let rows = labels(&app);
-        let at = |n: &str| rows.iter().position(|r| r == n).unwrap();
-        assert_eq!(rows[at("Plate") + 1].trim(), "Scale", "{rows:?}");
-        assert_eq!(rows[at("Box") + 1].trim(), "Position", "{rows:?}");
-        // UU (modified): the effect's changed parameter only, under the effect twirled open.
-        // Then U later: Box shows its keyframed properties only again.
-        app.session.execute("prop.set", json!({"layer": bx, "path": "effects/#1/blurriness", "value": 12})).unwrap();
-        crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
-        let rows = labels(&app);
-        let fx = rows.iter().position(|r| r.trim().ends_with("Gaussian Blur")).unwrap_or_else(|| panic!("UU shows the effect: {rows:?}"));
-        assert_eq!(rows[fx + 1].trim(), "Blurriness", "{rows:?}");
-        assert!(!rows.iter().any(|r| r.trim() == "Blur Dimensions"), "unchanged parameters stay hidden: {rows:?}");
-        // Collapsed and expanded by hand, the effect shows all its parameters; UU filters again.
-        let fx_uid = app.session.active_comp().unwrap().layer(LayerId(bx)).unwrap().effects().unwrap().groups().next().unwrap().uid;
-        app.ui.timeline.toggle_group(bx, fx_uid);
-        assert!(!labels(&app).iter().any(|r| r.trim() == "Blurriness"), "collapsed");
-        app.ui.timeline.toggle_group(bx, fx_uid);
-        let rows = labels(&app);
-        assert!(rows.iter().any(|r| r.trim() == "Blurriness") && rows.iter().any(|r| r.trim() == "Blur Dimensions"), "{rows:?}");
-        app.last_reveal = Some(("keyframes".into(), f64::MAX));
-        crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
-        assert!(!labels(&app).iter().any(|r| r.trim() == "Blur Dimensions"), "UU again shows the changed ones only");
-        app.last_reveal = Some(("keyframes".into(), -10.0));
-        crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
-        app.last_reveal = Some(("keyframes".into(), -10.0));
-        crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
-        let rows = labels(&app);
-        assert!(!rows.iter().any(|r| r.trim() == ">Gaussian Blur") && rows.iter().any(|r| r.trim() == "Position"), "{rows:?}");
-        // U again on Box (later than a double press) hides only Box's.
-        app.last_reveal = Some(("keyframes".into(), -10.0));
-        crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
-        let tl = &app.ui.timeline;
-        assert!(!tl.open_layers.contains(&bx) && tl.open_layers.contains(&plate), "{:?}", tl.open_layers);
-        // A layer twirled open by hand shows its whole tree, whatever was revealed elsewhere.
-        app.session.execute("layer.select", json!({"layers": []})).unwrap();
-        app.ui.timeline.open_layers.insert(bx);
-        let rows = labels(&app);
-        assert!(rows.iter().any(|r| r.trim() == ">Transform"), "{rows:?}");
-    }
-
-    /// U and UU show Time Remap on a layer with time remapping enabled.
-    #[test]
-    fn u_and_uu_reveal_time_remap() {
-        let mut s = effectcraft_engine::Session::default();
-        let inner = s.execute("comp.new", json!({"name": "Inner", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
-        s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();
-        let nested = s.execute("layer.addItem", json!({"item": inner})).unwrap()["layer"].as_u64().unwrap();
-        let mut app = EffectcraftApp::new(s);
-        let ctx = egui::Context::default();
-        crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({"layers": [nested]})).unwrap();
-        app.session.execute("layer.select", json!({"layers": [nested]})).unwrap();
-        for uu in [false, true] {
-            app.ui.timeline.layer_reveal.clear();
-            app.last_reveal = uu.then(|| ("keyframes".into(), f64::MAX));
-            crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
-            assert_eq!(app.ui.timeline.layer_reveal.get(&nested), Some(&vec!["props".to_string()]), "UU: {uu}");
-            let rows = labels(&app);
-            let at = rows.iter().position(|r| r == "Inner").unwrap();
-            assert_eq!(rows[at + 1].trim(), "Time Remap", "UU: {uu}: {rows:?}");
-        }
-    }
-
-    /// U shows Time Remap while remapping is enabled even after its keys are deleted (#990):
-    /// enabling remapping is itself the modification.
-    #[test]
-    fn u_reveals_keyless_time_remap() {
-        let mut s = effectcraft_engine::Session::default();
-        let inner = s.execute("comp.new", json!({"name": "Inner", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
-        s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();
-        let nested = s.execute("layer.addItem", json!({"item": inner})).unwrap()["layer"].as_u64().unwrap();
-        let mut app = EffectcraftApp::new(s);
-        let ctx = egui::Context::default();
-        crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({"layers": [nested]})).unwrap();
-        let uid = app.session.active_comp().unwrap().layer(LayerId(nested)).unwrap().props.prop("timeRemap").unwrap().uid;
-        for _ in 0..2 {
-            let t = app.session.active_comp().unwrap().layer(LayerId(nested)).unwrap().props.prop("timeRemap").unwrap().keys[0].time.seconds();
-            app.session.execute("keys.select", json!({"keys": [{"layer": nested, "prop": uid, "time": t}]})).unwrap();
-            app.session.execute("edit.clear", json!({})).unwrap();
-        }
-        assert!(app.session.active_comp().unwrap().layer(LayerId(nested)).unwrap().props.prop("timeRemap").unwrap().keys.is_empty());
-        app.session.execute("layer.select", json!({"layers": [nested]})).unwrap();
-        crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
-        assert_eq!(app.ui.timeline.layer_reveal.get(&nested), Some(&vec!["props".to_string()]));
-        let rows = labels(&app);
-        let at = rows.iter().position(|r| r == "Inner").unwrap();
-        assert_eq!(rows[at + 1].trim(), "Time Remap", "{rows:?}");
-    }
-
-    /// Enabling time remapping twirls the layer open on Time Remap (#157); disabling it reveals
-    /// nothing.
-    #[test]
-    fn enabling_time_remapping_reveals_time_remap() {
-        let mut s = effectcraft_engine::Session::default();
-        let inner = s.execute("comp.new", json!({"name": "Inner", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
-        s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();
-        s.execute("layer.newSolid", json!({"name": "Other"})).unwrap();
-        let nested = s.execute("layer.addItem", json!({"item": inner})).unwrap()["layer"].as_u64().unwrap();
-        let mut app = EffectcraftApp::new(s);
-        let ctx = egui::Context::default();
-        crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({"layers": [nested]})).unwrap();
-        assert_eq!(app.ui.timeline.layer_reveal.get(&nested), Some(&vec!["timeRemap".to_string()]));
-        let rows = labels(&app);
-        let at = rows.iter().position(|r| r == "Inner").unwrap();
-        assert_eq!(rows[at + 1].trim(), "Time Remap", "{rows:?}");
-        // Through the selection (the Layer menu), turning it off again: nothing new is revealed.
-        app.session.execute("layer.select", json!({"layers": [nested]})).unwrap();
-        app.ui.timeline.layer_reveal.clear();
-        crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({})).unwrap();
-        assert!(app.ui.timeline.layer_reveal.is_empty());
-    }
-
-    #[test]
-    fn cti_snaps_to_the_nearest_candidate() {
-        assert_eq!(snap_time(&[0.0, 1.0, 2.0], 1.04, 0.1), 1.0);
-        assert_eq!(snap_time(&[0.0, 1.0, 2.0], 1.5, 0.1), 1.5);
-        assert_eq!(snap_time(&[1.0, 1.1], 1.06, 0.1), 1.1);
-        let app = app();
-        let comp = app.session.active_comp().unwrap().clone();
-        let c = snap_candidates(&comp, &build_rows(&app, &comp));
-        assert!(c.contains(&comp.duration.seconds()) && c.contains(&0.0));
-    }
-
-    /// Every string drawn by one frame of `draw`.
-    fn drawn_text(mut draw: impl FnMut(&mut egui::Ui)) -> Vec<String> {
-        fn collect(shape: &egui::Shape, out: &mut Vec<String>) {
-            match shape {
-                egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
-                egui::Shape::Vec(v) => v.iter().for_each(|s| collect(s, out)),
-                _ => {}
-            }
-        }
-        let ctx = egui::Context::default();
-        ctx.run_ui(Default::default(), |ui| draw(ui)).textures_delta.clear();
-        let mut frame = ctx.run_ui(Default::default(), |ui| draw(ui));
-        frame.textures_delta.clear();
-        let mut out = Vec::new();
-        frame.shapes.iter().for_each(|c| collect(&c.shape, &mut out));
-        out
-    }
-
-    /// #1308: the layer context menu draws its items in the interface language, from the menu
-    /// bar's rows for the same commands (whose ellipsis is `...`), and its Effects submenu draws
-    /// the categories the Effect menu does; the actions it records stay the same.
-    #[test]
-    fn the_layer_context_menu_draws_in_the_interface_language() {
-        let caps = LayerMenuCaps { vector: true, text: false, source: true };
-        let (mut auto, mut actions) = (crate::automation::Registry::default(), Vec::new());
-        crate::i18n::set_current("zh-hans");
-        let menu = drawn_text(|ui| layer_menu(ui, &[7], caps, (&mut auto, "t"), &mut actions));
-        let effects = drawn_text(|ui| effects_submenu(ui, &[7], &mut |_: &mut egui::Ui, _: &str, _: &str, _: serde_json::Value| {}));
-        crate::i18n::set_current("en");
-        let english = drawn_text(|ui| layer_menu(ui, &[7], caps, (&mut auto, "t"), &mut actions));
-        for label in ["新建", "图层设置...", "在项目中显示图层源", "从矢量图层创建形状", "预合成...", "重复", "拆分图层", "删除"]
-        {
-            assert!(menu.iter().any(|t| t == label), "{label} missing from {menu:?}");
-        }
-        assert!(!menu.iter().any(|t| t.is_ascii()), "English left in {menu:?}");
-        assert!(effects.iter().any(|t| t == "模糊和锐化"), "{effects:?}");
-        assert!(!effects.iter().any(|t| t == "Blur & Sharpen"), "{effects:?}");
-        for label in ["Layer Settings…", "Reveal Layer Source in Project", "Duplicate", "Delete"] {
-            assert!(english.iter().any(|t| t == label), "{label} missing from {english:?}");
-        }
-        assert!(actions.is_empty());
-    }
-
-    /// The property context menu draws its items in the interface language too: the commands the
-    /// menu bar has from its rows, Reset, Edit Value… and Remove Expression from the panel catalog.
-    /// The automation labels stay English.
-    #[test]
-    fn the_property_context_menu_draws_in_the_interface_language() {
-        let mut s = effectcraft_engine::Session::default();
-        s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();
-        let l = s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080"})).unwrap()["layer"].as_u64().unwrap();
-        let opacity = s.active_comp().unwrap().layer(LayerId(l)).unwrap().props.prop("transform/opacity").unwrap().uid;
-        s.execute("prop.setExpression", json!({"layer": l, "prop": opacity})).unwrap();
-        let comp = s.active_comp_id().unwrap();
-        let layer = s.active_comp().unwrap().layer(LayerId(l)).unwrap().clone();
-        let (position, opacity) = (layer.props.prop("transform/position").unwrap(), layer.props.prop("transform/opacity").unwrap());
-        let (mut auto, mut actions) = (crate::automation::Registry::default(), Vec::new());
-        let mut menu = |language| {
-            crate::i18n::set_current(language);
-            let mut drawn = drawn_text(|ui| prop_menu(ui, &mut auto, comp, &layer, position, &mut actions));
-            drawn.extend(drawn_text(|ui| prop_menu(ui, &mut auto, comp, &layer, opacity, &mut actions)));
-            drawn
-        };
-        let chinese = menu("zh-hans");
-        let english = menu("en");
-        for label in ["重置", "编辑值…", "单独尺寸", "添加表达式", "移除表达式", "向基本图形添加属性"] {
-            assert!(chinese.iter().any(|t| t == label), "{label} missing from {chinese:?}");
-        }
-        assert!(!chinese.iter().any(|t| t.is_ascii()), "English left in {chinese:?}");
-        for label in ["Reset", "Edit Value…", "Separate Dimensions", "Remove Expression", "Add Property to Essential Graphics"] {
-            assert!(english.iter().any(|t| t == label), "{label} missing from {english:?}");
-        }
-        assert!(auto.elements.iter().any(|e| e.label == "Remove Expression"), "the automation label stays English");
-        assert!(actions.is_empty());
-    }
-
-    /// UI fidelity (M13.5): compact After Effects-like rows and muted label-coloured bars.
-    #[test]
-    fn rows_and_bars_follow_after_effects_proportions() {
-        let t = crate::theme::Tokens::for_kind(crate::theme::ThemeKind::Dark);
-        assert_eq!(t.row_h, 19.0);
-        let red = t.label(effectcraft_engine::color::Label::Red);
-        let bar = bar_color(red, false);
-        // Muted: darker and less saturated than the label, still reddish.
-        assert!(bar.r() < red.r() && bar.r() > bar.g() + 30 && bar.g() >= red.g().min(0x3a) - 1);
-        let sel = bar_color(red, true);
-        assert!(sel.r() > bar.r());
-    }
-
-    #[test]
-    fn disk_bar_range_covers_partial_frames() {
-        let clip = Rect::from_min_max(pos2(0.0, 0.0), pos2(2.0, 1.0));
-        let tm = TMap { x0: 0.0, start: 10.25, pps: 1.0 };
-        assert_eq!(disk_bar_range(&tm, clip, 1.0, 100), 10..13);
-
-        let exact = TMap { start: 10.0, ..tm };
-        assert_eq!(disk_bar_range(&exact, clip, 1.0, 100), 10..12);
-        let off_comp = TMap { start: 200.0, ..tm };
-        assert_eq!(disk_bar_range(&off_comp, clip, 1.0, 100), 100..100);
-        assert_eq!(disk_bar_range(&tm, clip, f64::NAN, 100), 0..0);
-        assert_eq!(disk_bar_range(&TMap { pps: 0.0, ..tm }, clip, 1.0, 100), 0..0);
-        assert_eq!(disk_bar_range(&TMap { start: f64::NAN, ..tm }, clip, 1.0, 100), 0..0);
-        assert_eq!(disk_bar_range(&tm, Rect::from_min_max(pos2(2.0, 0.0), pos2(2.0, 1.0)), 1.0, 100), 0..0);
-        let above_limit = TMap { start: 100_001.0, ..tm };
-        assert_eq!(disk_bar_range(&above_limit, clip, 1.0, i64::MAX), 100_000..100_000);
+    app.auto.add(&format!("timeline.prop.{uid}.eyedropper"), er, &prop.name);
+    let mut rgb = [c[0] as f32, c[1] as f32, c[2] as f32];
+    if crate::widgets::color_popup(ui, pop, r.left_bottom(), &mut rgb) {
+        ve.set(actions, json!([rgb[0], rgb[1], rgb[2], 1.0]));
     }
 }
+
+/// A checkbox.
+fn bool_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, ve: &ValueEdit<'_>, actions: &mut Vec<(String, serde_json::Value)>, value: &Value) {
+    let Value::Bool(b) = value else { return };
+    let (prop, at, uid) = (ve.prop, ve.at, ve.uid);
+    let t = app.tokens;
+    let x = at.x;
+    let r = Rect::from_min_size(pos2(x, at.y - 8.0), vec2(16.0, 16.0));
+    if widgets::checkbox(ui, r, *b, &t, egui::Id::unique(("cb", uid))).changed() {
+        ve.set_step(actions, json!(!b));
+    }
+    app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
+}
+
+/// A popup (or the number when the property has no options).
+fn enum_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, ve: &ValueEdit<'_>, actions: &mut Vec<(String, serde_json::Value)>, value: &Value) {
+    let Value::Enum(i) = value else { return };
+    let (p, layer, prop, at, uid) = (ve.p, ve.layer, ve.prop, ve.at, ve.uid);
+    let t = app.tokens;
+    let x = at.x;
+    if let Some(options) = layer.popup_options(prop) {
+        let r = Rect::from_min_size(pos2(x, at.y - 9.0), vec2(150.0, 18.0));
+        let label = options.get(*i as usize).cloned().unwrap_or_default();
+        let pop = egui::Id::unique(("epop", uid));
+        if widgets::dropdown(ui, r, &label, &t, egui::Id::unique(("en", uid))).clicked() {
+            widgets::open_popup(ui, pop);
+        }
+        app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
+        if let Some(ni) = widgets::popup_menu(ui, pop, r.left_bottom(), &options, Some(*i as usize)) {
+            ve.set_step(actions, json!(ni));
+        }
+    } else {
+        p.text(pos2(x, at.y), Align2::LEFT_CENTER, fmt_num(*i as f64, 0), Tokens::ui(12.0), t.for_value(prop.has_expression()).hot_text);
+    }
+}
+
+/// A layer reference picker.
+fn layer_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, ve: &ValueEdit<'_>, actions: &mut Vec<(String, serde_json::Value)>, value: &Value) {
+    let Value::Layer(l) = value else { return };
+    let (prop, at, uid) = (ve.prop, ve.at, ve.uid);
+    let t = app.tokens;
+    let x = at.x;
+    // Layer references (a light's Source, a Displacement Map's layer…) pick from the
+    // comp's layers, as in Effect Controls; the choice is written through the same
+    // undoable prop.set as the other value arms.
+    let r = Rect::from_min_size(pos2(x, at.y - 9.0), vec2(150.0, 18.0));
+    if let Some(comp) = app.session.active_comp_arc()
+        && let Some(chosen) = widgets::layer_picker(ui, r, &comp.layers, *l, &t, egui::Id::unique(("tl-lay", uid)))
+    {
+        ve.set_step(actions, chosen.map(|id| json!(id)).unwrap_or(serde_json::Value::Null));
+    }
+    app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
+}
+
+/// Opens the Gradient Editor at the current time (#612).
+fn gradient_editor(app: &mut EffectcraftApp, ui: &mut egui::Ui, ve: &ValueEdit<'_>, actions: &mut Vec<(String, serde_json::Value)>) {
+    let (p, layer, prop, at, uid) = (ve.p, ve.layer, ve.prop, ve.at, ve.uid);
+    let t = app.tokens;
+    let x = at.x;
+    // Opens the Gradient Editor at the current time (#612).
+    let r = p.text(pos2(x, at.y), Align2::LEFT_CENTER, crate::i18n::tr("Edit Gradient…"), Tokens::ui(12.0), t.hot_text);
+    let resp = ui.interact(r.expand(2.0), egui::Id::unique(("gradient-edit", uid)), Sense::click());
+    if resp.hovered() {
+        ui.ctx().set_cursor_icon(egui::CursorIcon::PointingHand);
+    }
+    app.auto.add(&format!("timeline.prop.{uid}.value"), r, &prop.name);
+    if resp.clicked() {
+        actions.push(("prop.editGradient".into(), json!({"layer": layer.id.0, "prop": uid})));
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/ui-egui/src/panels/timeline/tests.rs b/crates/ui-egui/src/panels/timeline/tests.rs
new file mode 100644
index 000000000..ebcbfa8b9
--- /dev/null
+++ b/crates/ui-egui/src/panels/timeline/tests.rs
@@ -0,0 +1,640 @@
+use super::*;
+
+/// Alt/Option-drag takes the same Project items `layer.replaceSource` does: compositions,
+/// footage and solids, never folders, data files or 3D models.
+#[test]
+fn replace_source_takes_visual_items_only() {
+    use effectcraft_engine::color::Label;
+    use effectcraft_engine::project::{Comp, Footage, Project, Solid};
+    use effectcraft_engine::time::{FrameRate, Tick};
+    let mut p = Project::default();
+    let l = Label::None;
+    let comp = p.add_item("C", l, None, ItemKind::Comp(Comp::new(10, 10, FrameRate::FPS_30, Tick::from_seconds_f64(1.0)).into()));
+    let folder = p.add_item("F", l, None, ItemKind::Folder);
+    let still = p.add_item("S", l, None, ItemKind::Footage(Footage { kind: FootageKind::Still, ..Default::default() }));
+    let data = p.add_item("D", l, None, ItemKind::Footage(Footage { kind: FootageKind::Data, ..Default::default() }));
+    let model = p.add_item("M", l, None, ItemKind::Footage(Footage { kind: FootageKind::Model, ..Default::default() }));
+    let solid = p.add_item("So", l, None, ItemKind::Solid(Solid { color: [0.0; 3], width: 10, height: 10, pixel_aspect: 1.0 }));
+    for (id, ok) in [(comp, true), (still, true), (solid, true), (folder, false), (data, false), (model, false)] {
+        assert_eq!(replaceable_item(p.item(id).unwrap()), ok, "{id:?}");
+    }
+}
+
+/// Alt/Cmd-click twirls Audio's Waveform row (not in the property tree) with the rest.
+#[test]
+fn the_waveform_row_twirls_with_its_tree() {
+    let mut root = PropGroup::new(1, "", "");
+    let mut audio = PropGroup::new(2, "audio", "Audio");
+    audio.children.push(PropGroup::new(3, "x", "X").into());
+    root.children.push(audio.into());
+    let mut uids = vec![];
+    walk_groups(&root, &mut uids);
+    assert_eq!(uids, vec![2, WAVE_BIT | 2, 3]);
+    let mut uids = vec![];
+    walk_groups(find_group(&root, 2).unwrap(), &mut uids);
+    assert_eq!(uids, vec![WAVE_BIT | 2, 3]);
+}
+
+/// #710: with Time Display set to Frames the ruler labels are frame numbers (as under the
+/// CTI, from Start Numbering Frames At); otherwise seconds:frames.
+#[test]
+fn ruler_labels_follow_the_time_display_style() {
+    use effectcraft_engine::project::{ProjectSettings, TimeDisplayStyle};
+    let mut st = ProjectSettings { time_display: TimeDisplayStyle::Timecode, frame_start: 0, ..ProjectSettings::default() };
+    assert_eq!(ruler_label(15, 30, &st), "00:15f");
+    assert_eq!(ruler_label(45, 30, &st), "01:15f");
+    assert_eq!(ruler_label(30 * 3600 + 31, 30, &st), "60:01:01f");
+    st.time_display = TimeDisplayStyle::Frames;
+    assert_eq!(ruler_label(0, 30, &st), "00000");
+    assert_eq!(ruler_label(45, 30, &st), "00045");
+    st.frame_start = 1;
+    assert_eq!(ruler_label(45, 30, &st), "00046");
+    assert_eq!(ruler_label(i64::MAX, 30, &st), format!("{:05}", i64::MAX));
+}
+
+/// #468: playback pages the view to the CTI; a scrub past either end scrolls that way.
+#[test]
+fn the_view_pages_to_the_cti() {
+    assert_eq!(page_to_cti(10.0, 5.0, 60.0, 12.0), 10.0, "in view: unchanged");
+    assert_eq!(page_to_cti(10.0, 5.0, 60.0, 16.0), 16.0, "past the right end: the page from the CTI");
+    assert_eq!(page_to_cti(10.0, 5.0, 60.0, 3.0), 3.0, "before the start");
+    assert_eq!(page_to_cti(10.0, 5.0, 60.0, 58.0), 55.0, "not past the comp's end");
+    assert_eq!(page_to_cti(10.0, 80.0, 60.0, 95.0), 0.0);
+    assert_eq!(page_to_cti(10.0, f64::NAN, 60.0, 95.0), 10.0);
+    assert_eq!(edge_scroll_speed_x(100.0, 500.0, 300.0), 0.0);
+    assert!(edge_scroll_speed_x(100.0, 500.0, 501.0) > 0.0 && edge_scroll_speed_x(100.0, 500.0, 99.0) < 0.0);
+    assert!(edge_scroll_speed_x(100.0, 500.0, 600.0) > edge_scroll_speed_x(100.0, 500.0, 520.0));
+}
+
+/// #864: picking only a mode in a layer's Track Matte menu sets a matte (the layer above);
+/// it used to close the menu and change nothing.
+#[test]
+fn a_track_matte_mode_without_a_matte_takes_the_layer_above() {
+    let mut s = effectcraft_engine::Session::default();
+    s.execute("comp.new", json!({"name": "T", "width": 64, "height": 64, "duration": 1})).unwrap();
+    for name in ["Chain Bottom", "Matte", "Chain Top"] {
+        s.execute("layer.newSolid", json!({"name": name, "color": "#ffffff", "width": 64, "height": 64})).unwrap();
+    }
+    let find = |s: &effectcraft_engine::Session, n: &str| s.active_comp().unwrap().layers.iter().find(|l| l.name == n).unwrap().clone();
+    let (bottom, matte, top) = (find(&s, "Chain Bottom"), find(&s, "Matte"), find(&s, "Chain Top"));
+    let candidates = [top.id, matte.id];
+    let pick = |s: &mut effectcraft_engine::Session, name: &str, i: usize, choice: &str| {
+        let (id, params) = track_matte_pick(&[find(s, name).id.0], &candidates, i, choice).expect("a menu item is an action");
+        s.execute(&id, params)
+    };
+    pick(&mut s, "Chain Bottom", 5, "Alpha Inverted Matte").unwrap();
+    let m = find(&s, "Chain Bottom").track_matte.expect("a matte");
+    assert_eq!((m.layer, m.kind), (matte.id, MatteKind::AlphaInverted));
+    assert!(!find(&s, "Matte").switches.video, "the matte layer is hidden");
+    // A mode change keeps the matte layer; a matte change keeps the mode.
+    pick(&mut s, "Chain Bottom", 6, "Luma Matte").unwrap();
+    assert_eq!(find(&s, "Chain Bottom").track_matte.map(|m| (m.layer, m.kind)), Some((matte.id, MatteKind::Luma)));
+    pick(&mut s, "Chain Bottom", 2, "1. Chain Top").unwrap();
+    assert_eq!(find(&s, "Chain Bottom").track_matte.map(|m| (m.layer, m.kind)), Some((top.id, MatteKind::Luma)));
+    assert!(s.undo());
+    assert_eq!(find(&s, "Chain Bottom").track_matte.map(|m| m.layer), Some(matte.id), "one undo step per pick");
+    // The top layer has nothing above it: an error for the status bar, not a silent no-op.
+    assert!(pick(&mut s, "Chain Top", 5, "Alpha Matte").is_err());
+    pick(&mut s, "Chain Bottom", 0, "No Track Matte").unwrap();
+    assert!(find(&s, "Chain Bottom").track_matte.is_none());
+    assert!(track_matte_pick(&[bottom.id.0], &candidates, 1, "-").is_none(), "a separator does nothing");
+}
+
+/// #957: vector footage gets the Continuously Rasterize switch; raster footage does not.
+#[test]
+fn collapse_switch_shows_for_vector_footage_only() {
+    use effectcraft_engine::color::Label;
+    use effectcraft_engine::project::{Footage, ItemKind, Project};
+    let mut p = Project::default();
+    let mut layer_for = |name: &str, codec: &str| {
+        let footage = Footage { path: name.into(), codec: codec.into(), ..Default::default() };
+        let item = p.add_item(name, Label::SeaFoam, None, ItemKind::Footage(footage));
+        let comp = Comp::new(64, 36, effectcraft_engine::time::FrameRate::new(30, 1), Tick::from_seconds_f64(1.0));
+        effectcraft_engine::project::build::layer(&mut p, &comp, name, LayerSource::Footage { item }, (0, 0), None)
+    };
+    let svg = layer_for("logo.svg", "SVG");
+    let png = layer_for("photo.png", "PNG");
+    assert!(collapse_applies(&svg, &p));
+    assert!(!collapse_applies(&png, &p));
+}
+
+/// A comp with two solids; "Box" has an animated Position and a Gaussian Blur.
+fn app() -> EffectcraftApp {
+    let mut s = effectcraft_engine::Session::default();
+    s.execute("comp.new", json!({"name": "T", "width": 320, "height": 180, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080", "width": 320, "height": 180})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Box", "color": "#e04020", "width": 40, "height": 40})).unwrap();
+    let comp = s.active_comp().unwrap();
+    let bx = comp.layers.iter().find(|l| l.name == "Box").unwrap().id.0;
+    s.execute("layer.select", json!({"layers": [bx]})).unwrap();
+    s.execute("effect.apply", json!({"effect": "ec.blur.gaussian"})).unwrap();
+    let pos = s.active_comp().unwrap().layer(LayerId(bx)).unwrap().transform().unwrap().get("position").unwrap().uid;
+    s.execute("prop.toggleAnimation", json!({"layer": bx, "prop": pos})).unwrap();
+    EffectcraftApp::new(s)
+}
+
+fn labels(app: &EffectcraftApp) -> Vec<String> {
+    let comp = app.session.active_comp().unwrap().clone();
+    build_rows(app, &comp)
+        .into_iter()
+        .map(|r| {
+            let l = comp.layer(r.layer).unwrap();
+            match r.kind {
+                RowKind::Layer => l.name.clone(),
+                RowKind::Group { name, .. } => format!("{}>{name}", "  ".repeat(r.depth)),
+                RowKind::Prop { uid } => format!("{}{}", "  ".repeat(r.depth), l.props.find(uid).unwrap().name),
+                _ => "?".into(),
+            }
+        })
+        .collect()
+}
+
+#[test]
+fn search_filters_layers_and_reveals_matching_properties() {
+    let mut app = app();
+    app.ui.timeline.search = "opac".into();
+    let rows = labels(&app);
+    // Both layers have Transform > Opacity; nothing else shows.
+    assert_eq!(rows.iter().filter(|r| r.trim() == "Opacity").count(), 2, "{rows:?}");
+    assert!(rows.iter().any(|r| r.trim() == ">Transform"), "{rows:?}");
+    assert!(!rows.iter().any(|r| r.trim() == "Position"), "{rows:?}");
+    // A layer name match shows the layer alone; a group match brings its contents.
+    app.ui.timeline.search = "plate".into();
+    assert_eq!(labels(&app), vec!["Plate".to_string()]);
+    app.ui.timeline.search = "GAUSSIAN".into();
+    let rows = labels(&app);
+    assert_eq!(rows[0], "Box");
+    assert!(rows.iter().any(|r| r.trim() == ">Effects") && rows.iter().any(|r| r.trim() == "Blurriness"), "{rows:?}");
+    assert!(!rows.contains(&"Plate".to_string()));
+    // Nothing matches → no rows.
+    app.ui.timeline.search = "zzz".into();
+    assert!(labels(&app).is_empty());
+    // Through the command.
+    let ctx = egui::Context::default();
+    crate::menus::invoke(&mut app, &ctx, "timeline.search", json!({"query": "scale"})).unwrap();
+    assert!(labels(&app).iter().any(|r| r.trim() == "Scale"));
+}
+
+/// A shape group's inner Contents (AE's elided `ADBE Vectors Group`) draws no row: the
+/// search shows the full row hierarchy with the group's items — path, fill and Transform —
+/// listing directly under the group, and the only "Contents" row the layer's own.
+#[test]
+fn shape_group_inner_contents_is_elided() {
+    let mut s = effectcraft_engine::Session::default();
+    s.execute("comp.new", json!({"name": "T", "width": 320, "height": 180, "duration": 4})).unwrap();
+    s.execute("layer.newShape", json!({"kind": "rect"})).unwrap();
+    let mut app = EffectcraftApp::new(s);
+    app.ui.timeline.search = "rect".into();
+    assert_eq!(
+        labels(&app),
+        [
+            "Shape Layer 1",
+            "  >Contents",
+            "    >Rectangle 1",
+            "      >Rectangle Path 1",
+            "        Size",
+            "        Position",
+            "        Roundness",
+            "        Per-Corner Roundness",
+            "        Top Left Roundness",
+            "        Top Right Roundness",
+            "        Bottom Right Roundness",
+            "        Bottom Left Roundness",
+            "      >Fill 1",
+            "        Composite",
+            "        Fill Rule",
+            "        Color",
+            "        Opacity",
+            "      >Transform",
+            "        Anchor Point",
+            "        Position",
+            "        Scale",
+            "        Skew",
+            "        Skew Axis",
+            "        Rotation",
+            "        Opacity",
+        ]
+        .iter()
+        .map(|r| r.to_string())
+        .collect::<Vec<_>>()
+    );
+}
+
+#[test]
+fn columns_toggle_and_layout() {
+    let mut app = app();
+    let tl = &mut app.ui.timeline;
+    assert!(column_visible(tl, "switches") && !column_visible(tl, "comment") && !column_visible(tl, "modes"));
+    set_column(tl, "comment", true).unwrap();
+    set_column(tl, "stretch", true).unwrap();
+    set_column(tl, "keys", false).unwrap();
+    set_column(tl, "label", false).unwrap();
+    set_column(tl, "modes", true).unwrap();
+    assert!(tl.show_modes && column_visible(tl, "comment") && !column_visible(tl, "label"));
+    assert!(set_column(tl, "name", false).is_err());
+    assert!(set_column(tl, "bogus", true).is_err());
+    let vis = Vis::of(tl);
+    let cw = cols(0.0, 1400.0, vis);
+    // Hidden columns take no room; visible ones are in After Effects' order.
+    assert_eq!(cw.keys, cw.label);
+    assert_eq!(cw.label, cw.num);
+    assert!(cw.name < cw.comment && cw.comment < cw.switches && cw.switches < cw.mode && cw.parent < cw.stretch);
+    assert_eq!(column_at(&cw, cw.comment + 5.0), Some("comment"));
+    assert_eq!(column_at(&cw, cw.name + 5.0), Some("name"));
+    assert_eq!(column_at(&cw, cw.stretch + 5.0), Some("stretch"));
+    // Through the command (as agents do).
+    let ctx = egui::Context::default();
+    let r = crate::menus::invoke(&mut app, &ctx, "timeline.column", json!({"column": "duration"})).unwrap();
+    assert!(r["columns"].as_array().unwrap().iter().any(|c| c == "duration"));
+    crate::menus::invoke(&mut app, &ctx, "timeline.column", json!({"column": "duration", "visible": false})).unwrap();
+    assert!(!column_visible(&app.ui.timeline, "duration"));
+    crate::menus::invoke(&mut app, &ctx, "timeline.sourceName", json!({})).unwrap();
+    assert!(app.ui.timeline.source_name);
+}
+
+#[test]
+fn reveal_keys_add_with_shift_and_uu_reveals_modified() {
+    let mut app = app();
+    let ctx = egui::Context::default();
+    crate::menus::invoke(&mut app, &ctx, "timeline.reveal.opacity", json!({})).unwrap();
+    assert_eq!(app.ui.timeline.reveal, vec!["opacity"]);
+    crate::menus::invoke(&mut app, &ctx, "timeline.revealAdd.scale", json!({})).unwrap();
+    crate::menus::invoke(&mut app, &ctx, "timeline.revealAdd.effects", json!({})).unwrap();
+    assert_eq!(app.ui.timeline.reveal, vec!["opacity", "scale", "effects"]);
+    let rows = labels(&app);
+    assert!(rows.iter().any(|r| r.trim() == "Scale") && rows.iter().any(|r| r.trim() == "Opacity"), "{rows:?}");
+    assert!(rows.iter().any(|r| r.trim() == ">Gaussian Blur"), "{rows:?}");
+    // Tree order: Scale before Opacity.
+    let si = rows.iter().position(|r| r.trim() == "Scale").unwrap();
+    let oi = rows.iter().position(|r| r.trim() == "Opacity").unwrap();
+    assert!(si < oi);
+    // Shift+S again removes Scale.
+    crate::menus::invoke(&mut app, &ctx, "timeline.revealAdd.scale", json!({})).unwrap();
+    assert_eq!(app.ui.timeline.reveal, vec!["opacity", "effects"]);
+    // U: keyframed properties (Position); UU (twice quickly): every modified property.
+    crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
+    let n_keys = app.ui.timeline.reveal_props.len();
+    assert_eq!(app.ui.timeline.reveal, vec!["props"]);
+    assert!(n_keys >= 1);
+    let bx = app.session.state.selected_layers[0].0;
+    app.session.execute("prop.set", json!({"layer": bx, "path": "effects/#1/blurriness", "value": 12})).unwrap();
+    crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
+    assert!(app.ui.timeline.reveal_props.len() > n_keys, "UU reveals modified properties too");
+}
+
+#[test]
+fn scroll_to_time_centres_the_current_time_inside_the_comp() {
+    assert_eq!(centered_on(4.0, 10.0, 5.0), 3.0);
+    // Near the ends the view stops at the comp's start and end.
+    assert_eq!(centered_on(4.0, 10.0, 1.0), 0.0);
+    assert_eq!(centered_on(4.0, 10.0, 9.5), 6.0);
+    // A span longer than the comp, and bad numbers, start at zero.
+    assert_eq!(centered_on(20.0, 10.0, 5.0), 0.0);
+    assert_eq!(centered_on(f64::NAN, 10.0, 5.0), 0.0);
+}
+
+/// U and the other reveal shortcuts act on the selected layers only: other layers keep their
+/// twirl state and their own reveal (#160).
+#[test]
+fn reveal_shortcuts_leave_unselected_layers_alone() {
+    let mut app = app();
+    let ctx = egui::Context::default();
+    let comp = app.session.active_comp().unwrap().clone();
+    let id = |n: &str| comp.layers.iter().find(|l| l.name == n).unwrap().id.0;
+    let (plate, bx) = (id("Plate"), id("Box"));
+    let select = |app: &mut EffectcraftApp, l: u64| app.session.execute("layer.select", json!({"layers": [l]})).unwrap();
+    // Plate shows Scale (S); then U on Box.
+    select(&mut app, plate);
+    crate::menus::invoke(&mut app, &ctx, "timeline.reveal.scale", json!({})).unwrap();
+    select(&mut app, bx);
+    crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
+    let tl = &app.ui.timeline;
+    assert!(tl.open_layers.contains(&plate) && tl.open_layers.contains(&bx), "{:?}", tl.open_layers);
+    assert_eq!(tl.layer_reveal.get(&plate), Some(&vec!["scale".to_string()]), "Plate keeps its reveal");
+    assert_eq!(tl.layer_reveal.get(&bx), Some(&vec!["props".to_string()]));
+    let rows = labels(&app);
+    let at = |n: &str| rows.iter().position(|r| r == n).unwrap();
+    assert_eq!(rows[at("Plate") + 1].trim(), "Scale", "{rows:?}");
+    assert_eq!(rows[at("Box") + 1].trim(), "Position", "{rows:?}");
+    // UU (modified): the effect's changed parameter only, under the effect twirled open.
+    // Then U later: Box shows its keyframed properties only again.
+    app.session.execute("prop.set", json!({"layer": bx, "path": "effects/#1/blurriness", "value": 12})).unwrap();
+    crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
+    let rows = labels(&app);
+    let fx = rows.iter().position(|r| r.trim().ends_with("Gaussian Blur")).unwrap_or_else(|| panic!("UU shows the effect: {rows:?}"));
+    assert_eq!(rows[fx + 1].trim(), "Blurriness", "{rows:?}");
+    assert!(!rows.iter().any(|r| r.trim() == "Blur Dimensions"), "unchanged parameters stay hidden: {rows:?}");
+    // Collapsed and expanded by hand, the effect shows all its parameters; UU filters again.
+    let fx_uid = app.session.active_comp().unwrap().layer(LayerId(bx)).unwrap().effects().unwrap().groups().next().unwrap().uid;
+    app.ui.timeline.toggle_group(bx, fx_uid);
+    assert!(!labels(&app).iter().any(|r| r.trim() == "Blurriness"), "collapsed");
+    app.ui.timeline.toggle_group(bx, fx_uid);
+    let rows = labels(&app);
+    assert!(rows.iter().any(|r| r.trim() == "Blurriness") && rows.iter().any(|r| r.trim() == "Blur Dimensions"), "{rows:?}");
+    app.last_reveal = Some(("keyframes".into(), f64::MAX));
+    crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
+    assert!(!labels(&app).iter().any(|r| r.trim() == "Blur Dimensions"), "UU again shows the changed ones only");
+    app.last_reveal = Some(("keyframes".into(), -10.0));
+    crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
+    app.last_reveal = Some(("keyframes".into(), -10.0));
+    crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
+    let rows = labels(&app);
+    assert!(!rows.iter().any(|r| r.trim() == ">Gaussian Blur") && rows.iter().any(|r| r.trim() == "Position"), "{rows:?}");
+    // U again on Box (later than a double press) hides only Box's.
+    app.last_reveal = Some(("keyframes".into(), -10.0));
+    crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
+    let tl = &app.ui.timeline;
+    assert!(!tl.open_layers.contains(&bx) && tl.open_layers.contains(&plate), "{:?}", tl.open_layers);
+    // A layer twirled open by hand shows its whole tree, whatever was revealed elsewhere.
+    app.session.execute("layer.select", json!({"layers": []})).unwrap();
+    app.ui.timeline.open_layers.insert(bx);
+    let rows = labels(&app);
+    assert!(rows.iter().any(|r| r.trim() == ">Transform"), "{rows:?}");
+}
+
+/// U and UU show Time Remap on a layer with time remapping enabled.
+#[test]
+fn u_and_uu_reveal_time_remap() {
+    let mut s = effectcraft_engine::Session::default();
+    let inner = s.execute("comp.new", json!({"name": "Inner", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
+    s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();
+    let nested = s.execute("layer.addItem", json!({"item": inner})).unwrap()["layer"].as_u64().unwrap();
+    let mut app = EffectcraftApp::new(s);
+    let ctx = egui::Context::default();
+    crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({"layers": [nested]})).unwrap();
+    app.session.execute("layer.select", json!({"layers": [nested]})).unwrap();
+    for uu in [false, true] {
+        app.ui.timeline.layer_reveal.clear();
+        app.last_reveal = uu.then(|| ("keyframes".into(), f64::MAX));
+        crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
+        assert_eq!(app.ui.timeline.layer_reveal.get(&nested), Some(&vec!["props".to_string()]), "UU: {uu}");
+        let rows = labels(&app);
+        let at = rows.iter().position(|r| r == "Inner").unwrap();
+        assert_eq!(rows[at + 1].trim(), "Time Remap", "UU: {uu}: {rows:?}");
+    }
+}
+
+/// U shows Time Remap while remapping is enabled even after its keys are deleted (#990):
+/// enabling remapping is itself the modification.
+#[test]
+fn u_reveals_keyless_time_remap() {
+    let mut s = effectcraft_engine::Session::default();
+    let inner = s.execute("comp.new", json!({"name": "Inner", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
+    s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();
+    let nested = s.execute("layer.addItem", json!({"item": inner})).unwrap()["layer"].as_u64().unwrap();
+    let mut app = EffectcraftApp::new(s);
+    let ctx = egui::Context::default();
+    crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({"layers": [nested]})).unwrap();
+    let uid = app.session.active_comp().unwrap().layer(LayerId(nested)).unwrap().props.prop("timeRemap").unwrap().uid;
+    for _ in 0..2 {
+        let t = app.session.active_comp().unwrap().layer(LayerId(nested)).unwrap().props.prop("timeRemap").unwrap().keys[0].time.seconds();
+        app.session.execute("keys.select", json!({"keys": [{"layer": nested, "prop": uid, "time": t}]})).unwrap();
+        app.session.execute("edit.clear", json!({})).unwrap();
+    }
+    assert!(app.session.active_comp().unwrap().layer(LayerId(nested)).unwrap().props.prop("timeRemap").unwrap().keys.is_empty());
+    app.session.execute("layer.select", json!({"layers": [nested]})).unwrap();
+    crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();
+    assert_eq!(app.ui.timeline.layer_reveal.get(&nested), Some(&vec!["props".to_string()]));
+    let rows = labels(&app);
+    let at = rows.iter().position(|r| r == "Inner").unwrap();
+    assert_eq!(rows[at + 1].trim(), "Time Remap", "{rows:?}");
+}
+
+/// Enabling time remapping twirls the layer open on Time Remap (#157); disabling it reveals
+/// nothing.
+#[test]
+fn enabling_time_remapping_reveals_time_remap() {
+    let mut s = effectcraft_engine::Session::default();
+    let inner = s.execute("comp.new", json!({"name": "Inner", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
+    s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Other"})).unwrap();
+    let nested = s.execute("layer.addItem", json!({"item": inner})).unwrap()["layer"].as_u64().unwrap();
+    let mut app = EffectcraftApp::new(s);
+    let ctx = egui::Context::default();
+    crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({"layers": [nested]})).unwrap();
+    assert_eq!(app.ui.timeline.layer_reveal.get(&nested), Some(&vec!["timeRemap".to_string()]));
+    let rows = labels(&app);
+    let at = rows.iter().position(|r| r == "Inner").unwrap();
+    assert_eq!(rows[at + 1].trim(), "Time Remap", "{rows:?}");
+    // Through the selection (the Layer menu), turning it off again: nothing new is revealed.
+    app.session.execute("layer.select", json!({"layers": [nested]})).unwrap();
+    app.ui.timeline.layer_reveal.clear();
+    crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({})).unwrap();
+    assert!(app.ui.timeline.layer_reveal.is_empty());
+}
+
+#[test]
+fn cti_snaps_to_the_nearest_candidate() {
+    assert_eq!(snap_time(&[0.0, 1.0, 2.0], 1.04, 0.1), 1.0);
+    assert_eq!(snap_time(&[0.0, 1.0, 2.0], 1.5, 0.1), 1.5);
+    assert_eq!(snap_time(&[1.0, 1.1], 1.06, 0.1), 1.1);
+    let app = app();
+    let comp = app.session.active_comp().unwrap().clone();
+    let c = snap_candidates(&comp, &build_rows(&app, &comp));
+    assert!(c.contains(&comp.duration.seconds()) && c.contains(&0.0));
+}
+
+/// Every string drawn by one frame of `draw`.
+fn drawn_text(mut draw: impl FnMut(&mut egui::Ui)) -> Vec<String> {
+    fn collect(shape: &egui::Shape, out: &mut Vec<String>) {
+        match shape {
+            egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
+            egui::Shape::Vec(v) => v.iter().for_each(|s| collect(s, out)),
+            _ => {}
+        }
+    }
+    let ctx = egui::Context::default();
+    ctx.run_ui(Default::default(), |ui| draw(ui)).textures_delta.clear();
+    let mut frame = ctx.run_ui(Default::default(), |ui| draw(ui));
+    frame.textures_delta.clear();
+    let mut out = Vec::new();
+    frame.shapes.iter().for_each(|c| collect(&c.shape, &mut out));
+    out
+}
+
+/// #1308: the layer context menu draws its items in the interface language, from the menu
+/// bar's rows for the same commands (whose ellipsis is `...`), and its Effects submenu draws
+/// the categories the Effect menu does; the actions it records stay the same.
+#[test]
+fn the_layer_context_menu_draws_in_the_interface_language() {
+    let caps = LayerMenuCaps { vector: true, text: false, source: true };
+    let (mut auto, mut actions) = (crate::automation::Registry::default(), Vec::new());
+    crate::i18n::set_current("zh-hans");
+    let menu = drawn_text(|ui| layer_menu(ui, &[7], caps, (&mut auto, "t"), &mut actions));
+    let effects = drawn_text(|ui| effects_submenu(ui, &[7], &mut |_: &mut egui::Ui, _: &str, _: &str, _: serde_json::Value| {}));
+    crate::i18n::set_current("en");
+    let english = drawn_text(|ui| layer_menu(ui, &[7], caps, (&mut auto, "t"), &mut actions));
+    for label in ["新建", "图层设置...", "在项目中显示图层源", "从矢量图层创建形状", "预合成...", "重复", "拆分图层", "删除"]
+    {
+        assert!(menu.iter().any(|t| t == label), "{label} missing from {menu:?}");
+    }
+    assert!(!menu.iter().any(|t| t.is_ascii()), "English left in {menu:?}");
+    assert!(effects.iter().any(|t| t == "模糊和锐化"), "{effects:?}");
+    assert!(!effects.iter().any(|t| t == "Blur & Sharpen"), "{effects:?}");
+    for label in ["Layer Settings…", "Reveal Layer Source in Project", "Duplicate", "Delete"] {
+        assert!(english.iter().any(|t| t == label), "{label} missing from {english:?}");
+    }
+    assert!(actions.is_empty());
+}
+
+/// The property context menu draws its items in the interface language too: the commands the
+/// menu bar has from its rows, Reset, Edit Value… and Remove Expression from the panel catalog.
+/// The automation labels stay English.
+#[test]
+fn the_property_context_menu_draws_in_the_interface_language() {
+    let mut s = effectcraft_engine::Session::default();
+    s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();
+    let l = s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080"})).unwrap()["layer"].as_u64().unwrap();
+    let opacity = s.active_comp().unwrap().layer(LayerId(l)).unwrap().props.prop("transform/opacity").unwrap().uid;
+    s.execute("prop.setExpression", json!({"layer": l, "prop": opacity})).unwrap();
+    let comp = s.active_comp_id().unwrap();
+    let layer = s.active_comp().unwrap().layer(LayerId(l)).unwrap().clone();
+    let (position, opacity) = (layer.props.prop("transform/position").unwrap(), layer.props.prop("transform/opacity").unwrap());
+    let (mut auto, mut actions) = (crate::automation::Registry::default(), Vec::new());
+    let mut menu = |language| {
+        crate::i18n::set_current(language);
+        let mut drawn = drawn_text(|ui| prop_menu(ui, &mut auto, comp, &layer, position, &mut actions));
+        drawn.extend(drawn_text(|ui| prop_menu(ui, &mut auto, comp, &layer, opacity, &mut actions)));
+        drawn
+    };
+    let chinese = menu("zh-hans");
+    let english = menu("en");
+    for label in ["重置", "编辑值…", "单独尺寸", "添加表达式", "移除表达式", "向基本图形添加属性"] {
+        assert!(chinese.iter().any(|t| t == label), "{label} missing from {chinese:?}");
+    }
+    assert!(!chinese.iter().any(|t| t.is_ascii()), "English left in {chinese:?}");
+    for label in ["Reset", "Edit Value…", "Separate Dimensions", "Remove Expression", "Add Property to Essential Graphics"] {
+        assert!(english.iter().any(|t| t == label), "{label} missing from {english:?}");
+    }
+    assert!(auto.elements.iter().any(|e| e.label == "Remove Expression"), "the automation label stays English");
+    assert!(actions.is_empty());
+}
+
+/// UI fidelity (M13.5): compact After Effects-like rows and muted label-coloured bars.
+#[test]
+fn rows_and_bars_follow_after_effects_proportions() {
+    let t = crate::theme::Tokens::for_kind(crate::theme::ThemeKind::Dark);
+    assert_eq!(t.row_h, 19.0);
+    let red = t.label(effectcraft_engine::color::Label::Red);
+    let bar = bar_color(red, false);
+    // Muted: darker and less saturated than the label, still reddish.
+    assert!(bar.r() < red.r() && bar.r() > bar.g() + 30 && bar.g() >= red.g().min(0x3a) - 1);
+    let sel = bar_color(red, true);
+    assert!(sel.r() > bar.r());
+}
+
+#[test]
+fn disk_bar_range_covers_partial_frames() {
+    let clip = Rect::from_min_max(pos2(0.0, 0.0), pos2(2.0, 1.0));
+    let tm = TMap { x0: 0.0, start: 10.25, pps: 1.0 };
+    assert_eq!(disk_bar_range(&tm, clip, 1.0, 100), 10..13);
+
+    let exact = TMap { start: 10.0, ..tm };
+    assert_eq!(disk_bar_range(&exact, clip, 1.0, 100), 10..12);
+    let off_comp = TMap { start: 200.0, ..tm };
+    assert_eq!(disk_bar_range(&off_comp, clip, 1.0, 100), 100..100);
+    assert_eq!(disk_bar_range(&tm, clip, f64::NAN, 100), 0..0);
+    assert_eq!(disk_bar_range(&TMap { pps: 0.0, ..tm }, clip, 1.0, 100), 0..0);
+    assert_eq!(disk_bar_range(&TMap { start: f64::NAN, ..tm }, clip, 1.0, 100), 0..0);
+    assert_eq!(disk_bar_range(&tm, Rect::from_min_max(pos2(2.0, 0.0), pos2(2.0, 1.0)), 1.0, 100), 0..0);
+    let above_limit = TMap { start: 100_001.0, ..tm };
+    assert_eq!(disk_bar_range(&above_limit, clip, 1.0, i64::MAX), 100_000..100_000);
+}
+
+/// The keyframe menu is one for the Timeline and the Graph Editor: its commands are drawn in the
+/// interface language, and a locked layer's keys can be copied and selected but not edited.
+#[test]
+fn the_key_menu_is_translated_and_cannot_edit_a_locked_layers_keys() {
+    use egui_kittest::Harness;
+    use egui_kittest::kittest::{NodeT, Queryable};
+    let mut s = effectcraft_engine::Session::default();
+    s.execute("comp.new", json!({"name": "C", "width": 64, "height": 64, "duration": 2})).unwrap();
+    let id = s.execute("layer.newSolid", json!({"name": "Box", "color": "#fff"})).unwrap()["layer"].as_u64().unwrap();
+    for (t, v) in [(0.0, 0), (1.0, 50)] {
+        s.execute("prop.addKey", json!({"layer": id, "path": "transform/opacity", "time": t, "value": v})).unwrap();
+    }
+    let app = EffectcraftApp::new(s);
+    let layer = app.session.active_comp().unwrap().layer(LayerId(id)).unwrap().clone();
+    let prop = layer.props.prop("transform/opacity").unwrap().clone();
+    let key = prop.keys[0].clone();
+    let enabled = |locked: bool, selected: bool, label: &str| {
+        let mut layer = layer.clone();
+        layer.switches.locked = locked;
+        let mut actions = vec![];
+        let mut h = Harness::new_ui(|ui| key_menu(ui, &app, &layer, &prop, &key, selected, &mut actions));
+        h.run();
+        !h.get_by_label(label).accesskit_node().is_disabled()
+    };
+    for label in [
+        "Copy",
+        "Select Equal Keyframes",
+        "Select All Keyframes",
+        "Delete",
+        "Edit Value…",
+        "Easy Ease",
+        "Time-Reverse Keyframes",
+        "Keyframe Velocity…",
+        "Mute Keyframes",
+    ] {
+        assert!(enabled(false, true, label), "{label} on an unlocked layer");
+    }
+    for label in ["Copy", "Select Equal Keyframes", "Select All Keyframes"] {
+        assert!(enabled(true, true, label), "{label} is still available on a locked layer");
+    }
+    for label in ["Delete", "Edit Value…", "Easy Ease", "Time-Reverse Keyframes", "Keyframe Velocity…", "Mute Keyframes", "Linear"] {
+        assert!(!enabled(true, true, label), "{label} is off on a locked layer");
+        assert!(!enabled(true, false, label), "{label} is off on an unselected locked key");
+    }
+    for label in ["Copy", "Select Equal Keyframes", "Select Previous Keyframes", "Select Following Keyframes"] {
+        assert!(!enabled(true, false, label), "{label} requires selecting the clicked key");
+    }
+    assert!(enabled(true, false, "Select All Keyframes"));
+    // The labels follow the interface language.
+    crate::i18n::set_current("es");
+    let copy = crate::i18n::context_item("keys.copy", &json!({}), "Copy");
+    assert_ne!(copy, "Copy", "the catalog translates Copy");
+    assert!(enabled(false, true, &copy));
+    crate::i18n::set_current("en");
+}
+
+#[test]
+fn a_key_menu_edit_selects_the_clicked_key_before_applying_the_command() {
+    use egui_kittest::{Harness, kittest::Queryable};
+    let mut s = effectcraft_engine::Session::default();
+    s.execute("comp.new", json!({"width": 64, "height": 64, "duration": 2})).unwrap();
+    let id = s.execute("layer.newSolid", json!({"color": "#fff"})).unwrap()["layer"].as_u64().unwrap();
+    for (time, value) in [(0.0, 0), (1.0, 50)] {
+        s.execute("prop.addKey", json!({"layer": id, "path": "transform/opacity", "time": time, "value": value})).unwrap();
+    }
+    let layer = s.active_comp().unwrap().layer(LayerId(id)).unwrap().clone();
+    let prop = layer.props.prop("transform/opacity").unwrap().clone();
+    s.execute("keys.select", json!({"keys": [{"layer": id, "prop": prop.uid, "time": 1.0}]})).unwrap();
+    let mut app = EffectcraftApp::new(s);
+    let mut actions = vec![];
+    {
+        let mut h = Harness::new_ui(|ui| key_menu(ui, &app, &layer, &prop, &prop.keys[0], false, &mut actions));
+        h.run();
+        h.get_by_label("Easy Ease").click();
+        h.run();
+    }
+    assert_eq!(actions.iter().map(|(command, _)| command.as_str()).collect::<Vec<_>>(), ["keys.select", "keys.easyEase"]);
+    for (command, params) in actions {
+        app.session.execute(&command, params).unwrap();
+    }
+    let keys = &app.session.active_comp().unwrap().layer(LayerId(id)).unwrap().props.find(prop.uid).unwrap().keys;
+    assert_ne!(keys[0], prop.keys[0], "the clicked key was eased");
+    assert_eq!(keys[1], prop.keys[1], "the previously selected key was not edited");
+    assert_eq!(app.session.state.selected_keys.len(), 1);
+    assert_eq!(app.session.state.selected_keys[0].time, prop.keys[0].time);
+}
+
+#[test]
+fn layer_drop_target_skips_moving_layers_beyond_the_viewport() {
+    let mut rows: Vec<Row> = (1..=6).map(|id| Row { layer: LayerId(id), depth: 0, kind: RowKind::Layer }).collect();
+    rows.insert(4, Row { layer: LayerId(4), depth: 1, kind: RowKind::Prop { uid: 0 } });
+    let visible: Vec<_> = (2..=4).map(|id| (Rect::NOTHING, LayerId(id))).collect();
+    for at in [Some(2), None] {
+        assert_eq!(layer_drop_target(&rows, &visible, at, &[1, 4, 5]), Some(LayerId(6)), "skip moving headers and their properties across the viewport edge");
+        assert_eq!(layer_drop_target(&rows, &visible, at, &[1, 4, 5, 6]), None, "the stack ends when no stationary layer follows");
+    }
+}
diff --git a/crates/ui-egui/src/panels/tracker.rs b/crates/ui-egui/src/panels/tracker.rs
index 2013d4daf..8d50b4860 100644
--- a/crates/ui-egui/src/panels/tracker.rs
+++ b/crates/ui-egui/src/panels/tracker.rs
@@ -51,6 +51,8 @@ fn current(app: &EffectcraftApp) -> Option<(LayerId, Uid)> {
     l.trackers().next().map(|(g, _)| (l.id, g.uid))
 }
 
+/// The `egui::Id` of the Motion Source dropdown's transient state; picking a new source removes
+/// whatever is stored under it, so the choice starts fresh.
 fn source_id() -> egui::Id {
     egui::Id::unique("tracker-motion-source")
 }
@@ -113,6 +115,37 @@ fn analyze_glyph(p: &egui::Painter, r: Rect, forward: bool, frame: bool, stop: b
     }
 }
 
+/// The two button rows at `y`: Track Camera / Warp Stabilizer, then Track Motion / Stabilize Motion.
+fn top_buttons(app: &mut EffectcraftApp, ui: &mut egui::Ui, ctx: &egui::Context, x0: f32, y: f32, half: f32, source: Option<LayerId>) {
+    let can_track = app.session.active_comp().is_some() && source.is_some();
+    // Track Camera / Warp Stabilizer and Track Motion / Stabilize Motion.
+    let r1 = Rect::from_min_size(pos2(x0, y), vec2(half, 22.0));
+    let r2 = Rect::from_min_size(pos2(x0 + half + 6.0, y), vec2(half, 22.0));
+    let src_p = source.map(|l| json!({"layer": l.0})).unwrap_or_else(|| json!({}));
+    let can_camera = app.session.is_enabled("track.camera") && !app.session.is_camera_analyzing();
+    if button(app, ui, r1, "Track Camera", can_camera, "tracker.trackCamera") {
+        run(app, ctx, "track.camera", json!({}));
+    }
+    let can_warp = app.session.is_enabled("track.warpStabilizer") && !app.session.is_warp_analyzing();
+    if button(app, ui, r2, "Warp Stabilizer", can_warp, "tracker.warpStabilizer") {
+        run(app, ctx, "track.warpStabilizer", json!({}));
+    }
+    let y = y + 28.0;
+    let r1 = Rect::from_min_size(pos2(x0, y), vec2(half, 22.0));
+    let r2 = Rect::from_min_size(pos2(x0 + half + 6.0, y), vec2(half, 22.0));
+    if button(app, ui, r1, "Track Motion", can_track, "tracker.trackMotion") {
+        run(app, ctx, "track.motion", src_p.clone());
+    }
+    if button(app, ui, r2, "Stabilize Motion", can_track, "tracker.stabilizeMotion") {
+        run(app, ctx, "track.stabilize", src_p.clone());
+    }
+}
+
+/// The Tracker panel: the camera/warp and motion/stabilize buttons, Motion Source and Current
+/// Track pickers, the track type and its channels, Motion Target with Edit Target and Options, the
+/// four Analyze buttons (the one whose direction is running offers Stop), Reset and Apply, and the
+/// analysis progress. With a mask selected it switches to its mask-tracking mode. Every change runs a
+/// `track.*` command; while an analysis is running it polls the job and asks for repaints.
 pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let t = app.tokens;
     let ctx = ui.ctx().clone();
@@ -125,33 +158,11 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let w = (rect.width() - 20.0).max(120.0);
     let half = (w - 6.0) / 2.0;
     let mut y = rect.min.y + 10.0;
-    let has_comp = app.session.active_comp().is_some();
     let source = motion_source(app);
     let cur = current(app);
-    let can_track = has_comp && source.is_some();
 
-    // Track Camera / Warp Stabilizer and Track Motion / Stabilize Motion.
-    let r1 = Rect::from_min_size(pos2(x0, y), vec2(half, 22.0));
-    let r2 = Rect::from_min_size(pos2(x0 + half + 6.0, y), vec2(half, 22.0));
-    let src_p = source.map(|l| json!({"layer": l.0})).unwrap_or_else(|| json!({}));
-    let can_camera = app.session.is_enabled("track.camera") && !app.session.is_camera_analyzing();
-    if button(app, ui, r1, "Track Camera", can_camera, "tracker.trackCamera") {
-        run(app, &ctx, "track.camera", json!({}));
-    }
-    let can_warp = app.session.is_enabled("track.warpStabilizer") && !app.session.is_warp_analyzing();
-    if button(app, ui, r2, "Warp Stabilizer", can_warp, "tracker.warpStabilizer") {
-        run(app, &ctx, "track.warpStabilizer", json!({}));
-    }
-    y += 28.0;
-    let r1 = Rect::from_min_size(pos2(x0, y), vec2(half, 22.0));
-    let r2 = Rect::from_min_size(pos2(x0 + half + 6.0, y), vec2(half, 22.0));
-    if button(app, ui, r1, "Track Motion", can_track, "tracker.trackMotion") {
-        run(app, &ctx, "track.motion", src_p.clone());
-    }
-    if button(app, ui, r2, "Stabilize Motion", can_track, "tracker.stabilizeMotion") {
-        run(app, &ctx, "track.stabilize", src_p.clone());
-    }
-    y += 34.0;
+    top_buttons(app, ui, &ctx, x0, y, half, source);
+    y += 62.0;
     let Some(comp) = app.session.active_comp_arc() else {
         p.text(pos2(x0, y + 8.0), Align2::LEFT_CENTER, crate::i18n::tr("Open a composition to track motion."), Tokens::ui(12.0), t.text_faint);
         return;
@@ -246,10 +257,10 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         ("scale", "Scale", settings.as_ref().is_some_and(|s| s.scale)),
     ] {
         let cr = Rect::from_min_size(pos2(xx, y + 2.0), vec2(16.0, 16.0));
-        let resp = widgets::checkbox(ui, cr, on && transformish, &t, egui::Id::unique(("tracker-cb", key)));
+        let resp = ui.add_enabled_ui(transformish, |ui| widgets::checkbox(ui, cr, on && transformish, &t, egui::Id::unique(("tracker-cb", key)))).inner;
         app.auto.add(&format!("tracker.{key}"), cr, text);
         p.text(pos2(cr.max.x + 4.0, cr.center().y), Align2::LEFT_CENTER, text, Tokens::ui(12.0), if transformish { t.text } else { t.text_faint });
-        if resp.clicked() && transformish {
+        if resp.changed() && transformish {
             run(app, &ctx, "track.setType", with(json!({ key: !on })));
         }
         xx += 84.0;
@@ -506,20 +517,20 @@ pub fn options_dialog(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens)
         ui.add_space(8.0);
         ui.label(egui::RichText::new(crate::i18n::tr("Process Before Match")).font(Tokens::medium(12.5)));
         ui.horizontal(|ui| {
-            let r = ui.checkbox(&mut d.blur_on, crate::i18n::tr("Blur"));
+            let r = crate::widgets::labelled_checkbox(ui, &mut d.blur_on, crate::i18n::tr("Blur"));
             app.auto.add("dialog.trackOptions.blurOn", r.rect, "Blur");
             let r =
                 ui.add_enabled(d.blur_on, crate::widgets::drag_value(egui::DragValue::new(&mut d.opts.blur).speed(0.1).range(0.5..=50.0).suffix(" pixels")));
             app.auto.add("dialog.trackOptions.blur", r.rect, "Blur pixels");
-            let r = ui.checkbox(&mut d.opts.enhance, crate::i18n::tr("Enhance"));
+            let r = crate::widgets::labelled_checkbox(ui, &mut d.opts.enhance, crate::i18n::tr("Enhance"));
             app.auto.add("dialog.trackOptions.enhance", r.rect, "Enhance");
         });
         ui.add_space(8.0);
-        let r = ui.checkbox(&mut d.opts.subpixel, crate::i18n::tr("Subpixel Positioning"));
+        let r = crate::widgets::labelled_checkbox(ui, &mut d.opts.subpixel, crate::i18n::tr("Subpixel Positioning"));
         app.auto.add("dialog.trackOptions.subpixel", r.rect, "Subpixel Positioning");
-        let r = ui.checkbox(&mut d.opts.adapt_every_frame, crate::i18n::tr("Adapt Feature On Every Frame"));
+        let r = crate::widgets::labelled_checkbox(ui, &mut d.opts.adapt_every_frame, crate::i18n::tr("Adapt Feature On Every Frame"));
         app.auto.add("dialog.trackOptions.adaptEveryFrame", r.rect, "Adapt Feature On Every Frame");
-        let r = ui.checkbox(&mut d.opts.track_shape, crate::i18n::tr("Follow Feature Rotation and Scale"));
+        let r = crate::widgets::labelled_checkbox(ui, &mut d.opts.track_shape, crate::i18n::tr("Follow Feature Rotation and Scale"));
         app.auto.add("dialog.trackOptions.trackShape", r.rect, "Follow Feature Rotation and Scale");
         ui.add_space(8.0);
         ui.horizontal(|ui| {
@@ -530,7 +541,7 @@ pub fn options_dialog(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens)
                 (LowConfidence::Adapt, "Adapt Feature"),
             ];
             let cur = actions.iter().find(|(a, _)| *a == d.opts.action).map(|(_, l)| *l).unwrap_or("Adapt Feature");
-            let r = egui::ComboBox::from_id_salt("track-action")
+            let r = craft_ui::ComboBox::from_id_salt("track-action")
                 .selected_text(cur)
                 .show_ui(ui, |ui| {
                     for (a, l) in actions {
@@ -583,7 +594,7 @@ pub fn target_dialog(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens)
         ui.horizontal(|ui| {
             ui.label(crate::i18n::tr("Layer:"));
             let cur = d.target.and_then(|id| layers.iter().find(|(l, _)| *l == id)).map(|(_, n)| n.clone()).unwrap_or_else(|| "None".into());
-            let r = egui::ComboBox::from_id_salt("track-target")
+            let r = craft_ui::ComboBox::from_id_salt("track-target")
                 .selected_text(cur)
                 .width(240.0)
                 .show_ui(ui, |ui| {
@@ -615,8 +626,8 @@ pub fn apply_dialog(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
     super::dialogs::modal(ctx, "Motion Tracker Apply Options", vec2(380.0, 170.0), t, |ui| {
         ui.horizontal(|ui| {
             ui.label(crate::i18n::tr("Apply Dimensions:"));
-            let labels = ["X and Y", "X only", "Y only"];
-            let r = egui::ComboBox::from_id_salt("track-apply-dims")
+            let labels = [crate::i18n::tr("X and Y"), crate::i18n::tr("X only"), crate::i18n::tr("Y only")];
+            let r = craft_ui::ComboBox::from_id_salt("track-apply-dims")
                 .selected_text(labels[d.dims.min(2)])
                 .show_ui(ui, |ui| {
                     for (i, l) in labels.iter().enumerate() {
diff --git a/crates/ui-egui/src/panels/unsaved.rs b/crates/ui-egui/src/panels/unsaved.rs
index 05f719fa9..7befef4e2 100644
--- a/crates/ui-egui/src/panels/unsaved.rs
+++ b/crates/ui-egui/src/panels/unsaved.rs
@@ -16,7 +16,16 @@ use crate::theme::Tokens;
 use crate::{Dialog, EffectcraftApp};
 
 /// Commands that replace or close the open project (Quit is asked when the window closes).
-const CLOSING: &[&str] = &["file.newProject", "file.open", "file.openRecent", "file.closeProject", "file.revert", "file.openDemoProject", "templates.create"];
+const CLOSING: &[&str] = &[
+    "file.newProject",
+    "file.open",
+    "file.openRecent",
+    "file.closeProject",
+    "file.revert",
+    "file.openDemoProject",
+    "templates.create",
+    "file.runShutdownScripts",
+];
 
 /// The command waiting on the prompt, and whether the user already answered it.
 #[derive(Clone, Debug, Default)]
@@ -58,6 +67,15 @@ pub fn on_close_requested(app: &mut EffectcraftApp, ctx: &egui::Context) {
     }
 }
 
+/// On macOS a close that nothing held open quits through `-[NSApplication terminate:]` instead:
+/// closing the window while AppKit's run loop is running crashes on a Mac with a Touch Bar
+/// (#341). `on_exit` still runs. A desktop host calls it last in `logic`, after
+/// `EffectcraftApp::tick` (which runs [`on_close_requested`]) and its own work. Returns whether
+/// that quit was scheduled; other platforms close the window as before.
+pub fn quit_on_close(ctx: &egui::Context) -> bool {
+    craft_quit::on_close_request(ctx)
+}
+
 /// The project's display name: its file name, or `Untitled Project.ecproj`.
 pub fn project_name(app: &EffectcraftApp) -> String {
     app.session
@@ -207,11 +225,46 @@ mod tests {
         out.viewport_output.get(&egui::ViewportId::ROOT).is_some_and(|v| v.commands.contains(&egui::ViewportCommand::CancelClose))
     }
 
+    /// One frame of the dialogs with the window's close button pressed, through
+    /// [`on_close_requested`] and then [`quit_on_close`] as the app runs them; returns whether the
+    /// close was canceled and whether the platform quit was scheduled.
+    fn close_frame(app: &mut EffectcraftApp, ctx: &egui::Context) -> (bool, bool) {
+        let mut raw = egui::RawInput::default();
+        raw.viewports.entry(egui::ViewportId::ROOT).or_default().events.push(egui::ViewportEvent::Close);
+        let mut quits = false;
+        let mut out = ctx.run_ui(raw, |ui| {
+            app.auto.begin_frame();
+            on_close_requested(app, ui.ctx());
+            quits = quit_on_close(ui.ctx());
+            crate::panels::dialogs::show(app, ui.ctx());
+        });
+        out.textures_delta.clear();
+        let canceled = out.viewport_output.get(&egui::ViewportId::ROOT).is_some_and(|v| v.commands.contains(&egui::ViewportCommand::CancelClose));
+        (canceled, quits)
+    }
+
     fn modified(app: &mut EffectcraftApp) {
         app.session.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64})).unwrap();
         assert!(app.session.is_dirty());
     }
 
+    #[test]
+    fn shutdown_scripts_prompt_before_discarding_unsaved_work() {
+        let (mut app, ctx) = app();
+        modified(&mut app);
+        let result = crate::menus::invoke(&mut app, &ctx, "file.runShutdownScripts", json!({})).unwrap();
+        assert_eq!(result, json!({"dialog": "unsavedChanges"}));
+        assert_eq!(app.session.project.comps().count(), 1);
+        assert!(app.session.is_dirty());
+        answer_with(&mut app, &ctx, Answer::Cancel);
+        assert_eq!(app.session.project.comps().count(), 1);
+        assert!(app.session.is_dirty());
+        crate::menus::invoke(&mut app, &ctx, "file.runShutdownScripts", json!({})).unwrap();
+        answer_with(&mut app, &ctx, Answer::Discard);
+        assert_eq!(app.session.project.comps().count(), 0);
+        assert!(!app.session.is_dirty() && app.dialog.is_none());
+    }
+
     #[test]
     fn closing_a_modified_project_asks_and_cancel_keeps_it() {
         let (mut app, ctx) = app();
@@ -340,4 +393,81 @@ mod tests {
         assert!(!app.session.is_dirty());
         assert!(!frame(&mut app, &ctx, true));
     }
+
+    /// Closing the window while AppKit's run loop is running crashes on a Mac with a Touch Bar
+    /// (#341). On macOS the close is canceled and the app quits through
+    /// `-[NSApplication terminate:]`. Other platforms close the window.
+    #[test]
+    fn closing_a_saved_project_quits_through_the_platform_on_macos() {
+        let (mut app, ctx) = app();
+        let macos = cfg!(target_os = "macos");
+        assert_eq!(close_frame(&mut app, &ctx), (macos, macos));
+        assert!(app.dialog.is_none(), "nothing to ask");
+    }
+
+    #[test]
+    fn closing_a_modified_project_asks_before_the_platform_quit() {
+        let (mut app, ctx) = app();
+        modified(&mut app);
+        assert_eq!(close_frame(&mut app, &ctx), (true, false), "the prompt holds the window and nothing quits");
+        assert_eq!(app.dialog, Some(Dialog::UnsavedChanges));
+        answer_with(&mut app, &ctx, Answer::Cancel);
+        assert!(app.session.is_dirty() && !app.dialog_state.unsaved.quitting);
+        assert_eq!(close_frame(&mut app, &ctx), (true, false), "asked again after Cancel");
+        answer_with(&mut app, &ctx, Answer::Discard);
+        let macos = cfg!(target_os = "macos");
+        assert_eq!(close_frame(&mut app, &ctx), (macos, macos), "Don't Save quits");
+    }
+
+    /// While the window is minimized or hidden, eframe runs `App::logic` without `App::ui` and
+    /// still handles a close: `logic` asks about a modified project.
+    #[test]
+    fn a_close_while_only_logic_runs_asks_about_a_modified_project() {
+        let (mut app, ctx) = app();
+        modified(&mut app);
+        let mut raw = egui::RawInput::default();
+        raw.viewports.entry(egui::ViewportId::ROOT).or_default().events.push(egui::ViewportEvent::Close);
+        let mut frame = eframe::Frame::_new_kittest();
+        let out = ctx.run_logic(&raw, |ctx| eframe::App::logic(&mut app, ctx, &mut frame));
+        let canceled = out.viewport_commands.get(&egui::ViewportId::ROOT).is_some_and(|c| c.contains(&egui::ViewportCommand::CancelClose));
+        assert!(canceled, "the close is canceled");
+        assert_eq!(app.dialog, Some(Dialog::UnsavedChanges));
+    }
+
+    /// A file dialog answered in the frame that closes the window runs its command before the
+    /// close decision, so a change it makes is asked about.
+    #[test]
+    fn a_dialog_answer_runs_before_the_close_decision() {
+        let (mut app, ctx) = app();
+        assert!(!app.session.is_dirty());
+        let answer = crate::DialogAnswer { command: "comp.new".into(), key: "name", params: json!({"width": 64, "height": 64}), paths: vec!["Main".into()] };
+        app.dialog_answers.0.send(answer).unwrap();
+        let mut raw = egui::RawInput::default();
+        raw.viewports.entry(egui::ViewportId::ROOT).or_default().events.push(egui::ViewportEvent::Close);
+        let mut frame = eframe::Frame::_new_kittest();
+        let out = ctx.run_logic(&raw, |ctx| eframe::App::logic(&mut app, ctx, &mut frame));
+        let canceled = out.viewport_commands.get(&egui::ViewportId::ROOT).is_some_and(|c| c.contains(&egui::ViewportCommand::CancelClose));
+        assert!(app.session.is_dirty(), "the answer ran");
+        assert!(canceled, "the close is canceled");
+        assert_eq!(app.dialog, Some(Dialog::UnsavedChanges));
+    }
+
+    /// The tick makes the close decision and leaves the platform quit to the host, which runs it
+    /// last in `logic`, after its own work (the desktop host shows the file dialogs asked for).
+    /// On macOS `logic` cancels the close and quits; other platforms close the window.
+    #[test]
+    fn the_platform_quit_runs_after_the_tick() {
+        let (mut app, ctx) = app();
+        let mut raw = egui::RawInput::default();
+        raw.viewports.entry(egui::ViewportId::ROOT).or_default().events.push(egui::ViewportEvent::Close);
+        let frame = eframe::Frame::_new_kittest();
+        let canceled =
+            |out: &egui::LogicOutput| out.viewport_commands.get(&egui::ViewportId::ROOT).is_some_and(|c| c.contains(&egui::ViewportCommand::CancelClose));
+        let out = ctx.run_logic(&raw, |ctx| app.tick(ctx, &frame));
+        assert!(!canceled(&out), "the tick leaves a saved project's close to the host");
+        let mut frame = eframe::Frame::_new_kittest();
+        let out = ctx.run_logic(&raw, |ctx| eframe::App::logic(&mut app, ctx, &mut frame));
+        assert_eq!(canceled(&out), cfg!(target_os = "macos"), "logic quits through the platform on macOS");
+        assert!(app.dialog.is_none(), "nothing to ask");
+    }
 }
diff --git a/crates/ui-egui/src/panels/viewer.rs b/crates/ui-egui/src/panels/viewer.rs
index f43518bab..bb7b2d075 100644
--- a/crates/ui-egui/src/panels/viewer.rs
+++ b/crates/ui-egui/src/panels/viewer.rs
@@ -18,6 +18,27 @@ use crate::state::Tool;
 use crate::theme::Tokens;
 use crate::{EffectcraftApp, widgets};
 
+/// A 3D view's name in the interface's language: the View menu's row for its `view.3d.*` command,
+/// else the panel catalog, else the English source. The menu's rows carry After Effects' words —
+/// フロントビュー rather than フロント — so the viewer's dropdown and the comp's view label read
+/// the same names as View ▸ Switch 3D View.
+pub(crate) fn view3d_label(v: View3D) -> &'static str {
+    let id = match v {
+        View3D::ActiveCamera => "view.3d.activeCamera",
+        View3D::Default => "view.3d.default",
+        View3D::Front => "view.3d.front",
+        View3D::Left => "view.3d.left",
+        View3D::Top => "view.3d.top",
+        View3D::Back => "view.3d.back",
+        View3D::Right => "view.3d.right",
+        View3D::Bottom => "view.3d.bottom",
+        View3D::Custom1 => "view.3d.custom1",
+        View3D::Custom2 => "view.3d.custom2",
+        View3D::Custom3 => "view.3d.custom3",
+    };
+    crate::i18n::command_label(id, v.label())
+}
+
 /// Viewer mapping published each frame (for the control channel and other panels).
 #[derive(Clone, Copy, Debug)]
 pub struct ViewerMap {
@@ -37,6 +58,7 @@ impl ViewerMap {
     }
 }
 
+/// The `egui::Id` under which the last pass's `ViewerMap` is published.
 fn map_id() -> egui::Id {
     egui::Id::unique("viewer-map")
 }
@@ -56,717 +78,65 @@ pub fn last_fit(ctx: &egui::Context) -> f32 {
     ctx.data(|d| d.get_temp::<f32>(egui::Id::unique("viewer-fit"))).unwrap_or(0.5)
 }
 
-/// What a drag in the viewer is doing.
-#[derive(Clone, Debug)]
-enum Gesture {
-    /// Per layer: start position and the parent-space change per comp pixel of drag in x and y.
-    Move {
-        layers: Vec<(LayerId, [f64; 3], [f64; 3], [f64; 3])>,
-        start: [f64; 2],
-        /// The grabbed layer's feature nearest the pointer (comp px at the start): it snaps.
-        snap_src: Option<[f64; 2]>,
-    },
-    Camera {
-        tool: Tool,
-    },
-    /// A bounding-box handle: scales about the anchor point so the grabbed point follows the
-    /// pointer (corners both axes, edges one), relative to the layer as the drag began; the
-    /// handle snaps.
-    Scale {
-        layer: LayerId,
-        start_scale: [f64; 3],
-        /// The grabbed point relative to the anchor, in layer pixels.
-        start_local: [f64; 2],
-        /// The handle's point relative to the anchor, in layer pixels.
-        handle: [f64; 2],
-        anchor: [f64; 2],
-        axes: [bool; 2],
-        /// Layer pixels → comp as the drag began, and its inverse.
-        l2c: Mat3,
-        inv: Mat3,
-        /// The other selected layers and their scales as the drag began: they scale by the same
-        /// ratio about their own anchor points, as in After Effects (#491).
-        others: Vec<(LayerId, [f64; 3])>,
-    },
-    Rotate {
-        layer: LayerId,
-        center: Pos2,
-        /// The pointer's angle about the centre on the last frame (degrees, as atan2 gives it).
-        last_angle: f64,
-        /// The turn so far, summed frame by frame so it keeps counting past a full revolution in
-        /// either direction (After Effects: 1x +0.0°, −1x −90.0°…) instead of wrapping at ±180°.
-        turned: f64,
-        start_rot: f64,
-        /// The other selected layers and their rotations: they turn by the same angle.
-        others: Vec<(LayerId, f64)>,
-    },
-    Anchor {
-        layer: LayerId,
-        start_anchor: [f64; 3],
-        start_pos: [f64; 3],
-        start: [f64; 2],
-        inv: Mat3,
-        l2p: Mat3,
-        /// The layer's own snap targets as the drag began (its box and path vertices).
-        own: Vec<effectcraft_engine::viewer::SnapTarget>,
-        /// Alt held as the drag began: the anchor point moves alone, so the layer shifts.
-        anchor_only: bool,
-    },
-    Pan {
-        start_pan: [f32; 2],
-    },
-    Create {
-        tool: Tool,
-        start: [f64; 2],
-    },
-    Marquee {
-        start: Pos2,
-    },
-    /// Dragging selected mask / shape path vertices: press point, the grabbed vertex (comp px,
-    /// it snaps), the comp-space move applied so far and comp → path space.
-    Vertices {
-        start: [f64; 2],
-        src: [f64; 2],
-        applied: [f64; 2],
-        inv: Mat3,
-        layer: LayerId,
-    },
-    /// Dragging a vertex's Bezier tangent (both sides symmetric unless Alt breaks them).
-    Tangent {
-        layer: LayerId,
-        mask: u64,
-        index: usize,
-        out: bool,
-        vertex: [f64; 2],
-        inv: Mat3,
-    },
-    /// Dragging a Puppet pin (comp → layer matrix inverse).
-    PuppetPin {
-        layer: LayerId,
-        pin: u64,
-        inv: Mat3,
-    },
-    /// Rotating an Advanced / Bend pin by its ring: the pin's screen centre, the pointer's last
-    /// angle (radians) and the rotation so far (°, accumulated so it can pass a full turn).
-    PuppetRotate {
-        layer: LayerId,
-        pin: u64,
-        center: Pos2,
-        last: f32,
-        rotation: f64,
-    },
-    /// Scaling an Advanced / Bend pin by its square: the pin's screen centre, the press distance
-    /// from it and the scale at the press (1 = 100 %).
-    PuppetScale {
-        layer: LayerId,
-        pin: u64,
-        center: Pos2,
-        start: f32,
-        scale: f64,
-    },
-    /// Puppet tools: a marquee selecting pins (dragged outside the layer's art, or Alt-dragged).
-    PinMarquee {
-        start: Pos2,
-    },
-    /// Object Matte tool: a box around the object (screen point where the drag began).
-    ObjectMatteBox {
-        start: Pos2,
-    },
-    /// Puppet tool Record mode (⌘/Ctrl-drag a pin): the drag is sampled in real time (seconds
-    /// since it began, effect space) and becomes keyframes on release (`puppet.recordPin`); the
-    /// current time runs along while recording.
-    PuppetRecord {
-        layer: LayerId,
-        pin: u64,
-        /// Other selected pins of the layer, moving with the dragged one.
-        others: Vec<u64>,
-        inv: Mat3,
-        began: f64,
-        cti: Tick,
-        samples: Vec<(f64, [f64; 2])>,
-    },
-    /// Pen tool: pulling the tangents of the vertex just placed.
-    Pen {
-        layer: LayerId,
-        mask: u64,
-        index: usize,
-        vertex: [f64; 2],
-        inv: Mat3,
-        press: Pos2,
-    },
-    /// Dragging a track point's feature/search region, a corner or its attach point.
-    Track {
-        layer: LayerId,
-        tracker: u64,
-        drag: super::tracker::Drag,
-    },
-    /// Motion paths, free transform, Mask Feather, guides and the region of interest
-    /// (`viewer_overlays`).
-    Overlay(ov::Drag),
-}
-
-/// Pen tool path in progress: (layer, mask uid).
-fn pen_id() -> egui::Id {
-    egui::Id::unique("viewer-pen")
-}
-
 use super::viewer_overlays::{self as ov, VertexHit};
 use super::viewer_tools as vt;
 
-const HANDLE: f32 = 7.0;
-/// How close (screen points) the pointer must be to a path vertex or tangent handle to grab it.
-const VERTEX_GRAB: f32 = 6.0;
-
-/// The reach of a path vertex at `pos` (#1042): a vertex marker sitting under, or just beside, a
-/// bounding-box handle would lose the press to the handle (the handle reaches further than the
-/// vertex), so wherever a box handle is in range the vertex reaches as far as the handle does.
-/// Vertices then win in the handle's whole zone, as in After Effects.
-fn vertex_grab_radius(pos: Pos2, handles: impl IntoIterator<Item = Pos2>) -> f32 {
-    if handles.into_iter().any(|h| h.distance(pos) < HANDLE + 2.0) { HANDLE + 2.0 } else { VERTEX_GRAB }
-}
-/// Shown when a Roto Brush tool is used in the Composition panel (#753).
-const ROTO_HINT: &str = "The Roto Brush works in the Layer panel. Double-click the layer to open it.";
-
 thread_local! {
     /// The 3D view camera of the viewer being drawn (None = the comp's active camera).
     static VIEW_CAM: std::cell::Cell<Option<CameraState>> = const { std::cell::Cell::new(None) };
 }
 
-/// Region of interest handles on screen: corners (0–3, clockwise from top-left) then edge
-/// midpoints (4 top, 5 right, 6 bottom, 7 left).
-fn roi_handles(r: Rect) -> [Pos2; 8] {
-    [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom(), r.center_top(), r.right_center(), r.center_bottom(), r.left_center()]
-}
-
-/// A drag starting on a region of interest handle: the ROI redrawn from the opposite corner (or
-/// edge, with the other axis kept).
-fn roi_drag(app: &EffectcraftApp, map: &ViewerMap, comp_rect: Rect, zoom: f32, press: Pos2) -> Option<ov::Drag> {
-    let [rx, ry, rw, rh] = app.session.state.region_of_interest?;
-    let r = Rect::from_min_size(comp_rect.min + vec2(rx as f32 * zoom, ry as f32 * zoom), vec2(rw as f32 * zoom, rh as f32 * zoom));
-    let i = roi_handles(r).iter().position(|h| h.distance(press) < 6.0)?;
-    let (x0, y0, x1, y1) = (rx, ry, rx + rw, ry + rh);
-    let _ = map;
-    Some(match i {
-        0 => ov::Drag::Roi { start: [x1, y1], keep: [None, None] },
-        1 => ov::Drag::Roi { start: [x0, y1], keep: [None, None] },
-        2 => ov::Drag::Roi { start: [x0, y0], keep: [None, None] },
-        3 => ov::Drag::Roi { start: [x1, y0], keep: [None, None] },
-        4 => ov::Drag::Roi { start: [x1, y1], keep: [Some(x0), None] },
-        5 => ov::Drag::Roi { start: [x0, y0], keep: [None, Some(y1)] },
-        6 => ov::Drag::Roi { start: [x0, y0], keep: [Some(x1), None] },
-        _ => ov::Drag::Roi { start: [x1, y0], keep: [None, Some(y1)] },
-    })
-}
-
-/// The camera the viewer shows (view camera or the comp's active camera).
-fn cam_state(ctx: &EvalCtx) -> CameraState {
-    VIEW_CAM.with(|c| c.get()).unwrap_or_else(|| three_d::active_camera(ctx))
-}
-
-/// Layer → comp (viewer) matrix through the current 3D view.
-pub(crate) fn l2c(ctx: &EvalCtx, layer: &Layer) -> (Mat3, f64) {
-    match VIEW_CAM.with(|c| c.get()) {
-        Some(cam) if layer.is_3d() => (three_d::layer_to_view(ctx, layer, &cam), 0.0),
-        _ => ctx.layer_to_comp(layer),
-    }
-}
-
-/// `l2c` (layer → comp) applied from effect space instead: effect points and Puppet pins,
-/// measured from the top-left of the layer's effect bounds (see `effect_bounds`).
-pub(crate) fn from_effect_space(ctx: &EvalCtx, layer: &Layer, l2c: Mat3) -> Mat3 {
-    let o = ctx.effect_bounds(layer).1;
-    l2c * Mat3::translate(gv2(o[0], o[1]))
-}
-
-/// Effect space → comp (viewer) matrix through the current 3D view.
-pub(crate) fn fx2c(ctx: &EvalCtx, layer: &Layer) -> Mat3 {
-    from_effect_space(ctx, layer, l2c(ctx, layer).0)
-}
-
-/// The selected, unlocked layers of `comp` other than `layer` (when `layer` is one of them): a
-/// handle or Rotation tool drag on one changes them all.
-fn selected_others<'a>(app: &EffectcraftApp, comp: &'a Comp, layer: LayerId) -> Vec<&'a Layer> {
-    let sel = &app.session.state.selected_layers;
-    if !sel.contains(&layer) {
-        return vec![];
-    }
-    sel.iter().filter(|id| **id != layer).filter_map(|id| comp.layer(*id)).filter(|l| !l.switches.locked && l.transform().is_some()).collect()
-}
-
-/// The least homogeneous depth (`w`: the distance in front of a perspective camera in pixels, 1
-/// for 2D layers and orthographic views) a viewer outline is drawn at: points at or behind the
-/// camera would flip through infinity and draw long lines across the viewer (#572).
-const NEAR_W: f64 = 0.5;
-
-/// `p` through the homography `m` before the perspective divide: (x, y, w).
-fn homogeneous(m: &Mat3, p: [f64; 2]) -> [f64; 3] {
-    let r = |i: usize| m.0.get(i).map_or(0.0, |row| row[0] * p[0] + row[1] * p[1] + row[2]);
-    [r(0), r(1), r(2)]
-}
-
-/// The closed polygon `poly` (layer pixels) through `m`, clipped to the part in front of the
-/// camera's near plane (comp pixels; empty when none of it is).
-fn project_clipped(m: &Mat3, poly: &[[f64; 2]]) -> Vec<[f64; 2]> {
-    let h: Vec<[f64; 3]> = poly.iter().map(|p| homogeneous(m, *p)).collect();
-    let mut out = vec![];
-    for (i, a) in h.iter().enumerate() {
-        let Some(b) = h.get((i + 1) % h.len()) else { continue };
-        let (ina, inb) = (a[2] >= NEAR_W, b[2] >= NEAR_W);
-        if ina {
-            out.push(*a);
-        }
-        if ina != inb {
-            let t = (NEAR_W - a[2]) / (b[2] - a[2]);
-            out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, NEAR_W]);
-        }
-    }
-    out.iter().map(|q| [q[0] / q[2], q[1] / q[2]]).filter(|q| q[0].is_finite() && q[1].is_finite()).collect()
-}
-
-/// The segment a → b (world space) through the projection `pc`, clipped at the near plane.
-fn project_segment(pc: &effectcraft_engine::geom::Mat4, a: effectcraft_engine::geom::Vec3, b: effectcraft_engine::geom::Vec3) -> Option<[[f64; 2]; 2]> {
-    let h = |p: effectcraft_engine::geom::Vec3| {
-        let r = |i: usize| pc.0.get(i).map_or(0.0, |row| row[0] * p.x + row[1] * p.y + row[2] * p.z + row[3]);
-        [r(0), r(1), r(3)]
-    };
-    let (mut ha, mut hb) = (h(a), h(b));
-    if ha[2] < NEAR_W && hb[2] < NEAR_W {
-        return None;
-    }
-    let cut = |p: [f64; 3], q: [f64; 3]| {
-        let t = (NEAR_W - p[2]) / (q[2] - p[2]);
-        [p[0] + (q[0] - p[0]) * t, p[1] + (q[1] - p[1]) * t, NEAR_W]
-    };
-    if ha[2] < NEAR_W {
-        ha = cut(ha, hb);
-    } else if hb[2] < NEAR_W {
-        hb = cut(hb, ha);
-    }
-    let d = |q: [f64; 3]| [q[0] / q[2], q[1] / q[2]];
-    let s = [d(ha), d(hb)];
-    s.iter().flatten().all(|v| v.is_finite()).then_some(s)
-}
-
-/// The content box corners (layer pixels) of `layer`.
-fn box_corners(b: [f64; 4]) -> [[f64; 2]; 4] {
-    [[b[0], b[1]], [b[2], b[1]], [b[2], b[3]], [b[0], b[3]]]
-}
-
-/// Layer → comp matrix and its bounds quad (in comp pixels). None for a 3D layer reaching to or
-/// behind the camera (its quad would flip; [`layer_outline`] draws the part in front).
-pub(crate) fn layer_quad(ctx: &EvalCtx, layer: &Layer) -> Option<(Mat3, [[f64; 2]; 4], [f64; 4])> {
-    let b = effectcraft_engine::render::content_bounds(ctx, layer)?;
-    let (m, _) = l2c(ctx, layer);
-    let corners = box_corners(b);
-    if corners.iter().any(|p| homogeneous(&m, *p)[2] < NEAR_W) {
-        return None;
-    }
-    let pts = corners.map(|p| {
-        let q = m.apply(gv2(p[0], p[1]));
-        [q.x, q.y]
-    });
-    Some((m, pts, b))
-}
-
-/// The outline of a layer's content box in comp pixels, clipped at the camera's near plane.
-pub(crate) fn layer_outline(ctx: &EvalCtx, layer: &Layer) -> Vec<[f64; 2]> {
-    let Some(b) = effectcraft_engine::render::content_bounds(ctx, layer) else { return vec![] };
-    project_clipped(&l2c(ctx, layer).0, &box_corners(b))
-}
-
-/// Which axes a bounding-box handle scales: corners (0–3) both; the top and bottom edges (4, 6)
-/// y; the right and left edges (5, 7) x.
-fn handle_axes(handle: usize) -> [bool; 2] {
-    match handle {
-        4 | 6 => [false, true],
-        5 | 7 => [true, false],
-        _ => [true, true],
-    }
-}
-
-/// A bounding-box handle's point in layer pixels (`b`: the content box; handles as in
-/// [`handle_axes`], the corners clockwise from the top left, then the top, right, bottom and
-/// left edges' midpoints).
-fn handle_point(b: [f64; 4], handle: usize) -> [f64; 2] {
-    let (cx, cy) = ((b[0] + b[2]) / 2.0, (b[1] + b[3]) / 2.0);
-    match handle {
-        0 => [b[0], b[1]],
-        1 => [b[2], b[1]],
-        2 => [b[2], b[3]],
-        3 => [b[0], b[3]],
-        4 => [cx, b[1]],
-        5 => [b[2], cy],
-        6 => [cx, b[3]],
-        _ => [b[0], cy],
-    }
-}
-
-/// The resize cursor over bounding-box handle `handle` of the on-screen box `sq` (corners
-/// clockwise from the top left, handles as in [`handle_point`]): along the direction the handle
-/// scales, so it turns with the layer, as in After Effects. A corner points between its two
-/// edges (the box's diagonal whatever its proportions), an edge handle across its edge.
-fn handle_cursor(sq: &[Pos2], handle: usize) -> egui::CursorIcon {
-    let at = |k: usize| sq.get(k % 4).copied().unwrap_or(Pos2::ZERO);
-    let dir = if handle < 4 {
-        let c = at(handle);
-        (c - at(handle + 3)).normalized() + (c - at(handle + 1)).normalized()
-    } else {
-        let e = at(handle - 3) - at(handle - 4);
-        vec2(-e.y, e.x)
-    };
-    // Screen y points down: 45° is the south-east diagonal.
-    let a = dir.y.atan2(dir.x).to_degrees().rem_euclid(180.0);
-    if !(22.5..157.5).contains(&a) {
-        egui::CursorIcon::ResizeHorizontal
-    } else if a < 67.5 {
-        egui::CursorIcon::ResizeNwSe
-    } else if a < 112.5 {
-        egui::CursorIcon::ResizeVertical
-    } else {
-        egui::CursorIcon::ResizeNeSw
-    }
-}
-
-/// The scale ratio (x, y) that puts the point grabbed at `start` (relative to the anchor, layer
-/// pixels) under the pointer at `cur`. `uniform` (Shift on a corner) keeps the aspect ratio,
-/// following the pointer along the handle's diagonal. Dragging past the anchor flips the layer,
-/// as in After Effects; an axis whose grabbed point sits on the anchor keeps its scale.
-fn drag_ratio(start: [f64; 2], cur: [f64; 2], axes: [bool; 2], uniform: bool) -> [f64; 2] {
-    if uniform {
-        let d2 = start[0] * start[0] + start[1] * start[1];
-        let f = if d2 > 1e-6 { (cur[0] * start[0] + cur[1] * start[1]) / d2 } else { 1.0 };
-        return [f, f];
-    }
-    [0, 1].map(|k| if axes[k] && start[k].abs() > 1e-3 { cur[k] / start[k] } else { 1.0 })
-}
-
-/// Snap a handle drag (#252): the handle (`h`, layer pixels from the anchor point `a` as the
-/// drag began; `l2c` that layer space → comp) at scale ratio `f` goes through `snap` (a comp
-/// point → its correction), and the ratio that puts the handle where it snapped comes back.
-/// A `uniform` drag slides the handle along its line from the anchor point to the nearer snapped
-/// line; otherwise each scaled axis takes the snapped point.
-fn snap_handle(f: [f64; 2], h: [f64; 2], a: [f64; 2], l2c: &Mat3, axes: [bool; 2], uniform: bool, snap: impl FnOnce([f64; 2]) -> [f64; 2]) -> [f64; 2] {
-    let at = |f: [f64; 2]| {
-        let q = l2c.apply(gv2(a[0] + f[0] * h[0], a[1] + f[1] * h[1]));
-        [q.x, q.y]
-    };
-    let p = at(f);
-    let c = snap(p);
-    let s = [p[0] + c[0], p[1] + c[1]];
-    if uniform {
-        let o = at([0.0; 2]);
-        let d = [p[0] - o[0], p[1] - o[1]];
-        let k = [0, 1].into_iter().filter(|k| c[*k] != 0.0 && d[*k].abs() > 1e-9).min_by(|x, y| c[*x].abs().total_cmp(&c[*y].abs()));
-        return k.map_or(f, |k| f.map(|v| v * (s[k] - o[k]) / d[k]));
-    }
-    let Some(inv) = l2c.inverse().filter(|_| c != [0.0; 2]) else { return f };
-    let q = inv.apply(gv2(s[0], s[1]));
-    let q = [q.x - a[0], q.y - a[1]];
-    [0, 1].map(|k| if axes[k] && h[k].abs() > 1e-9 { q[k] / h[k] } else { f[k] })
-}
-
-/// The turn from angle `from` to angle `to` (degrees), wrapped to (−180°, 180°]: the shortest way
-/// round, so summing it frame by frame follows the pointer across atan2's ±180° seam and past full
-/// revolutions. Non-finite input turns by nothing.
-fn turn_delta(from: f64, to: f64) -> f64 {
-    let d = to - from;
-    if !d.is_finite() {
-        return 0.0;
-    }
-    let w = (d + 180.0).rem_euclid(360.0) - 180.0;
-    if w <= -180.0 { w + 360.0 } else { w }
-}
-
-/// The Rotation tool's value: the rotation as the drag began plus the turn so far (which may span
-/// revolutions), snapped to 45° steps with Shift.
-fn rotate_value(start_rot: f64, turned: f64, shift: bool) -> f64 {
-    let r = start_rot + turned;
-    let r = if r.is_finite() { r } else { start_rot };
-    if shift { (r / 45.0).round() * 45.0 } else { r }
-}
-
-/// A drag `d` (comp pixels), kept to the axis it moves along most when `shift` is held.
-fn one_axis(d: [f64; 2], shift: bool) -> [f64; 2] {
-    if !shift {
-        d
-    } else if d[0].abs() > d[1].abs() {
-        [d[0], 0.0]
-    } else {
-        [0.0, d[1]]
-    }
-}
-
-fn point_in_quad(p: [f64; 2], q: &[[f64; 2]; 4]) -> bool {
-    let mut sign = 0.0;
-    for i in 0..4 {
-        let a = q[i];
-        let b = q[(i + 1) % 4];
-        let c = (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
-        if c.abs() < 1e-9 {
-            continue;
-        }
-        if sign == 0.0 {
-            sign = c.signum();
-        } else if c.signum() != sign {
-            return false;
-        }
-    }
-    true
-}
-
-/// Separating-axis test: a marquee may cross a layer without containing any corner.
-fn quad_intersects_box(q: &[[f64; 2]; 4], a: [f64; 2], b: [f64; 2]) -> bool {
-    if q.iter().flatten().chain(a.iter()).chain(b.iter()).any(|v| !v.is_finite()) {
-        return false;
-    }
-    let lo = [a[0].min(b[0]), a[1].min(b[1])];
-    let hi = [a[0].max(b[0]), a[1].max(b[1])];
-    let rect = [lo, [hi[0], lo[1]], hi, [lo[0], hi[1]]];
-    let axes = [[1.0, 0.0], [0.0, 1.0]].into_iter().chain((0..4).map(|i| {
-        let j = (i + 1) % 4;
-        [q[j][1] - q[i][1], q[i][0] - q[j][0]]
-    }));
-    for axis in axes {
-        let project = |p: &[f64; 2]| p[0] * axis[0] + p[1] * axis[1];
-        let (qmin, qmax) = q.iter().map(project).fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), v| (lo.min(v), hi.max(v)));
-        let (rmin, rmax) = rect.iter().map(project).fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), v| (lo.min(v), hi.max(v)));
-        if qmax < rmin || rmax < qmin {
-            return false;
-        }
-    }
-    true
-}
-
-/// Parent-space linear inverse (to convert a comp-space drag delta into a position delta).
-fn parent_inverse(ctx: &EvalCtx, layer: &Layer) -> Mat3 {
-    match layer.parent.and_then(|p| ctx.comp.layer(p)) {
-        Some(p) => {
-            let w = ctx.world_matrix(p);
-            let m = Mat3([[w.0[0][0], w.0[0][1], 0.0], [w.0[1][0], w.0[1][1], 0.0], [0.0, 0.0, 1.0]]);
-            m.inverse().unwrap_or(Mat3::IDENTITY)
-        }
-        None => Mat3::IDENTITY,
-    }
-}
-
-/// Draw the extra views of a 2- or 4-view layout and return the main view's rectangle.
-fn aux_views(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    comp: &effectcraft_engine::project::Comp,
+/// Draw the Composition viewer in `rect` and handle its input for one pass.
+/// Publishes the fit magnification and `ViewerMap`, requests and draws the frame, then paints the nav breadcrumbs,
+/// view layout, guides/grid, layer boxes, handles, anchors, 3D gizmos, motion paths, masks, puppet pins and tracker
+/// overlays and records their automation regions. Pointer and drop gestures run engine commands
+/// (move/scale/rotate/anchor/camera/shape/mask/guide edits, picks, marquees); failures worth showing go to
+/// `app.ui.status`, while per-frame drag updates ignore errors so a gesture is not aborted mid-drag. With no active
+/// composition it draws `empty_state` and returns.
+/// What the passes of one viewer frame share (see [`show`]).
+struct Vw<'a> {
+    t: Tokens,
     cid: effectcraft_engine::project::ItemId,
-    full: Rect,
-    bg: Color32,
-) -> Rect {
-    let n = app.session.state.view_layout;
-    if n < 2 {
-        return full;
-    }
-    let gap = 2.0;
-    let views = app.session.state.views3d.get(&cid).cloned().unwrap_or_default();
-    let (main, aux): (Rect, Vec<(Rect, View3D)>) = if n == 2 {
-        let mid = full.center().x;
-        (
-            Rect::from_min_max(pos2(mid + gap / 2.0, full.min.y), full.max),
-            vec![(Rect::from_min_max(full.min, pos2(mid - gap / 2.0, full.max.y)), views.pane(0))],
-        )
-    } else {
-        let c = full.center();
-        let q = |x0: f32, y0: f32, x1: f32, y1: f32| Rect::from_min_max(pos2(x0, y0), pos2(x1, y1));
-        (
-            q(c.x + gap / 2.0, c.y + gap / 2.0, full.max.x, full.max.y),
-            vec![
-                (q(full.min.x, full.min.y, c.x - gap / 2.0, c.y - gap / 2.0), views.pane(0)),
-                (q(c.x + gap / 2.0, full.min.y, full.max.x, c.y - gap / 2.0), views.pane(1)),
-                (q(full.min.x, c.y + gap / 2.0, c.x - gap / 2.0, full.max.y), views.pane(2)),
-            ],
-        )
-    };
-    let ctx = ui.ctx().clone();
-    let p = ui.painter().clone();
-    p.rect_filled(full, 0.0, Color32::from_black_alpha(200));
-    let t = app.session.time();
-    let (cw, ch) = (comp.width as f32, comp.height as f32);
-    let share = app.session.state.share_view_options;
-    // The camera and light wireframes of each view (as in After Effects, where every view of the
-    // layout shows them), evaluated on a snapshot of the project.
-    let snap_project = app.session.project.clone();
-    let snap_expr = app.session.expr.clone();
-    let ectx = EvalCtx { project: &snap_project, comp_id: cid, comp, time: t, expr: snap_expr.as_deref(), footage: None };
-    let selected = app.session.state.selected_layers.clone();
-    let mut picked: Option<(usize, View3D)> = None;
-    for (i, (r, v)) in aux.into_iter().enumerate() {
-        p.rect_filled(r, 0.0, bg);
-        let fit = ((r.width() - 20.0) / cw).min((r.height() - 20.0) / ch).max(0.01);
-        let cr = Rect::from_center_size(r.center(), vec2(cw * fit, ch * fit));
-        let scale = (fit * ctx.pixels_per_point()).min(1.0) as f64;
-        // The Active Camera pane renders through the comp's own camera; the others through their
-        // view camera.
-        let through_active = v == View3D::ActiveCamera;
-        let cam = if through_active { three_d::active_camera(&ectx) } else { views.cam(v, comp.width as f64, comp.height as f64).state() };
-        let key = {
-            use std::hash::{Hash, Hasher};
-            let mut h = std::collections::hash_map::DefaultHasher::new();
-            (app.session.revision, cid.0, t.0, i, scale.to_bits(), format!("{cam:?}")).hash(&mut h);
-            h.finish()
-        };
-        let id = egui::Id::unique(("viewer-aux", i));
-        let cached: Option<(u64, egui::TextureHandle)> = ctx.data(|d| d.get_temp(id));
-        let tex = match cached {
-            Some((k, tex)) if k == key => tex,
-            _ => {
-                let opts = effectcraft_engine::render::RenderOpts {
-                    scale,
-                    view: (comp.has_3d() && !through_active).then_some(cam),
-                    draft: true,
-                    ..Default::default()
-                };
-                let img = app.session.render(cid, t, opts);
-                let tex = crate::frames::load_fitted(&ctx, format!("viewer-aux-{i}"), crate::frames::to_color_image(&img), egui::TextureOptions::LINEAR);
-                ctx.data_mut(|d| d.insert_temp(id, (key, tex.clone())));
-                tex
-            }
-        };
-        let b = comp.background;
-        p.rect_filled(cr, 0.0, Color32::from_rgb((b[0] * 255.0) as u8, (b[1] * 255.0) as u8, (b[2] * 255.0) as u8));
-        p.image(tex.id(), cr, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
-        p.rect_stroke(cr, 0.0, Stroke::new(1.0, Color32::from_black_alpha(160)), StrokeKind::Outside);
-        if share && app.ui.viewer.safe_margins {
-            for k in [0.9, 0.8] {
-                p.rect_stroke(Rect::from_center_size(cr.center(), cr.size() * k), 0.0, Stroke::new(1.0, Color32::from_white_alpha(120)), StrokeKind::Middle);
-            }
-        }
-        if comp.has_3d() {
-            let map = ViewerMap { origin: cr.min, zoom: fit, comp: [cw, ch], area: r };
-            draw_rigs(app, &p.with_clip_rect(r), &map, &ectx, &selected, cam, through_active, Some(v.id()));
-        }
-        let label = if comp.has_3d() { v.label() } else { crate::i18n::tr("Active Camera") };
-        p.text(r.left_bottom() + vec2(8.0, -8.0), Align2::LEFT_BOTTOM, label, Tokens::ui(11.0), Color32::from_white_alpha(200));
-        app.auto.add(&format!("viewer.view.{}", v.id()), r, label);
-        if comp.has_3d()
-            && let Some(chosen) = pane_selector(app, ui, i + 1, r, v)
-        {
-            picked = Some((i + 1, chosen));
-        }
-    }
-    if let Some((pane, v)) = picked
-        && let Err(e) = app.session.execute("view.setPaneView", json!({"pane": pane, "view": v.id(), "comp": cid.0}))
-    {
-        app.ui.status = e.to_string();
-    }
-    main
-}
-
-/// The view selector in the top-left corner of pane `pane` (1 to 3) of a multi-view layout, a
-/// popup of every 3D view like the toolbar's 3D View menu. Returns the view chosen this frame.
-fn pane_selector(app: &mut EffectcraftApp, ui: &mut egui::Ui, pane: usize, area: Rect, current: View3D) -> Option<View3D> {
-    let t = app.tokens;
-    let r = Rect::from_min_size(area.min + vec2(6.0, 6.0), vec2(124.0, 20.0));
-    let pid = egui::Id::unique(("viewer-pane-view", pane));
-    let response = widgets::dropdown(ui, r, crate::i18n::tr(current.label()), &t, pid);
-    if response.clicked() {
-        let open = widgets::popup_is_open(ui, pid);
-        ui.data_mut(|d| d.insert_temp(pid.with("open"), !open));
-    }
-    app.auto.add_response(&format!("viewer.view.{pane}.type"), &response, "View of pane");
-    if !widgets::popup_is_open(ui, pid) {
-        return None;
-    }
-    let chosen = widgets::popup_list(ui, pid, r.left_bottom() + vec2(0.0, 2.0), r, View3D::ALL.len(), 0, |ui| {
-        ui.set_min_width(124.0);
-        let mut chosen = None;
-        for (k, v) in View3D::ALL.iter().enumerate() {
-            let item = ui.selectable_label(*v == current, crate::i18n::tr(v.label()));
-            app.auto.add(&format!("viewer.view.{pane}.typeItem.{k}"), item.rect, v.label());
-            if item.clicked() {
-                chosen = Some(*v);
-            }
-        }
-        chosen
-    });
-    chosen.filter(|v| *v != current)
-}
-
-/// View ▸ Split with New Locked Viewer: the locked viewer on the left of the Composition panel
-/// (its comp and 3D view stay put whatever comp is active). Returns the main viewer's rectangle.
-fn locked_pane(app: &mut EffectcraftApp, ui: &mut egui::Ui, full: Rect, bg: Color32) -> Rect {
-    let Some(lv) = app.session.state.locked_viewer else { return full };
-    let Some(comp) = app.session.project.comp_arc(lv.comp) else { return full };
-    let name = app.session.project.item(lv.comp).map(|i| i.name.clone()).unwrap_or_default();
-    let gap = 2.0;
-    let mid = full.center().x;
-    let r = Rect::from_min_max(full.min, pos2(mid - gap / 2.0, full.max.y));
-    let main = Rect::from_min_max(pos2(mid + gap / 2.0, full.min.y), full.max);
-    let ctx = ui.ctx().clone();
-    let p = ui.painter().clone();
-    p.rect_filled(Rect::from_min_max(pos2(r.max.x, full.min.y), pos2(main.min.x, full.max.y)), 0.0, Color32::from_black_alpha(200));
-    p.rect_filled(r, 0.0, bg);
-    let (cw, ch) = (comp.width as f32, comp.height as f32);
-    let fit = ((r.width() - 20.0) / cw).min((r.height() - 44.0) / ch).max(0.01);
-    let cr = Rect::from_center_size(r.center(), vec2(cw * fit, ch * fit));
-    let scale = (fit * ctx.pixels_per_point()).min(1.0) as f64;
-    let t = app.session.time_of(lv.comp);
-    let cam = (lv.view != View3D::ActiveCamera && comp.has_3d())
-        .then(|| app.session.state.views3d.get(&lv.comp).cloned().unwrap_or_default().cam(lv.view, comp.width as f64, comp.height as f64).state());
-    let dc = effectcraft_engine::viewer::DisplayColor::of(&app.session);
-    // The display conversion's inputs, keyed as in the main viewer's texture caches.
-    let dc_key = format!("{cam:?}{}", super::viewer_tools::display_key(app, dc.is_some()));
-    let key = {
-        use std::hash::{Hash, Hasher};
-        let mut h = std::collections::hash_map::DefaultHasher::new();
-        (app.session.revision, lv.comp.0, t.0, scale.to_bits(), dc_key).hash(&mut h);
-        h.finish()
-    };
-    let id = egui::Id::unique("viewer-locked");
-    let cached: Option<(u64, egui::TextureHandle)> = ctx.data(|d| d.get_temp(id));
-    let tex = match cached {
-        Some((k, tex)) if k == key => tex,
-        _ => {
-            let opts = effectcraft_engine::render::RenderOpts { scale, view: cam, ..Default::default() };
-            let img = app.session.render(lv.comp, t, opts);
-            let mut ci = crate::frames::to_color_image(&img);
-            if let Some(dc) = dc {
-                let mut px: Vec<[u8; 4]> = ci.pixels.iter().map(|c| c.to_array()).collect();
-                dc.apply(&mut px);
-                ci = egui::ColorImage::new(ci.size, px.into_iter().map(|a| Color32::from_rgba_premultiplied(a[0], a[1], a[2], a[3])).collect());
-            }
-            let tex = crate::frames::load_fitted(&ctx, "viewer-locked", ci, egui::TextureOptions::LINEAR);
-            ctx.data_mut(|d| d.insert_temp(id, (key, tex.clone())));
-            tex
-        }
-    };
-    let b = comp.background;
-    p.rect_filled(cr, 0.0, Color32::from_rgb((b[0] * 255.0) as u8, (b[1] * 255.0) as u8, (b[2] * 255.0) as u8));
-    p.image(tex.id(), cr, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
-    p.rect_stroke(cr, 0.0, Stroke::new(1.0, Color32::from_black_alpha(160)), StrokeKind::Outside);
-    let label = crate::i18n::tr_args("Locked: {} — {}", &[&name, &(if comp.has_3d() { lv.view.label() } else { crate::i18n::tr("Active Camera") })]);
-    p.text(r.left_top() + vec2(8.0, 8.0), Align2::LEFT_TOP, &label, Tokens::ui(11.0), Color32::from_white_alpha(210));
-    app.auto.add("viewer.locked", r, &label);
-    // Close the locked viewer.
-    let close = Rect::from_min_size(pos2(r.max.x - 26.0, r.min.y + 4.0), vec2(20.0, 20.0));
-    let resp = ui.interact(close, egui::Id::unique("viewer-locked-close"), Sense::click());
-    p.text(close.center(), Align2::CENTER_CENTER, "\u{00d7}", Tokens::ui(14.0), if resp.hovered() { Color32::WHITE } else { Color32::from_white_alpha(170) });
-    app.auto.add("viewer.locked.close", close, "Close Locked Viewer");
-    if resp.clicked() {
-        let _ = app.session.execute("view.closeLockedViewer", serde_json::json!({}));
-    }
-    main
-}
-
-pub(crate) fn checker(p: &egui::Painter, r: Rect) {
-    let s = 10.0;
-    p.rect_filled(r, 0.0, Color32::from_gray(0xcc));
-    let mut y = r.min.y;
-    let mut row = 0;
-    while y < r.max.y {
-        let mut x = r.min.x + if row % 2 == 0 { 0.0 } else { s };
-        while x < r.max.x {
-            p.rect_filled(Rect::from_min_max(pos2(x, y), pos2((x + s).min(r.max.x), (y + s).min(r.max.y))), 0.0, Color32::from_gray(0x99));
-            x += 2.0 * s;
-        }
-        y += s;
-        row += 1;
-    }
+    nav: Rect,
+    bar: Rect,
+    err_bar: Rect,
+    err_h: f32,
+    pasteboard: Color32,
+    area: Rect,
+    outer: Rect,
+    comp_rect: Rect,
+    zoom: f32,
+    ppp: f32,
+    cw: f32,
+    ch: f32,
+    map: ViewerMap,
+    time: Tick,
+    overlays: bool,
+    mods: egui::Modifiers,
+    space_pan: bool,
+    text_owns: bool,
+    gid: egui::Id,
+    track_cur: Option<(LayerId, effectcraft_engine::project::Uid)>,
+    has_3d: bool,
+    ctx: egui::Context,
+    comp_name: String,
+    p: egui::Painter,
+    painter: egui::Painter,
+    selected: Vec<LayerId>,
+    sel_vertices: Vec<effectcraft_engine::VertexRef>,
+    ft: Option<ov::FtBox>,
+    comp: &'a Comp,
+    gesture: Option<Gesture>,
+    handle_hits: Vec<(LayerId, usize, Pos2, egui::CursorIcon)>,
+    axis_hits: Vec<(LayerId, [Pos2; 2], [f64; 3], [f64; 3])>,
+    vertex_hits: Vec<VertexHit>,
+    vertex_marks: Vec<ov::VertexMark>,
+    key_hits: Vec<ov::KeyHit>,
+    motion_frames: Vec<ov::PathFrame>,
+    paths: Vec<ov::PathInfo>,
+    track_hits: Vec<super::tracker::Hit>,
+    pin_hits: Vec<super::puppet_tool::PinHit>,
+    puppet_layers: Vec<(&'a Layer, super::puppet_tool::Overlay)>,
 }
 
 pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
@@ -780,7 +150,84 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let comp_name = app.session.project.item(cid).map(|i| i.name.clone()).unwrap_or_default();
     let p = ui.painter().clone();
     VIEW_CAM.with(|c| c.set(app.session.view_camera(cid)));
+    let mut v = Vw {
+        t,
+        cid,
+        nav: Rect::NOTHING,
+        bar: Rect::NOTHING,
+        err_bar: Rect::NOTHING,
+        err_h: 0.0,
+        pasteboard: Color32::BLACK,
+        area: Rect::NOTHING,
+        outer: Rect::NOTHING,
+        comp_rect: Rect::NOTHING,
+        zoom: 1.0,
+        ppp: 1.0,
+        cw: 0.0,
+        ch: 0.0,
+        map: ViewerMap { origin: Pos2::ZERO, zoom: 1.0, comp: [0.0; 2], area: Rect::NOTHING },
+        time: Tick::ZERO,
+        overlays: false,
+        mods: egui::Modifiers::NONE,
+        space_pan: false,
+        text_owns: false,
+        gid: egui::Id::unique("viewer-gesture"),
+        track_cur: None,
+        has_3d: false,
+        ctx: ctx.clone(),
+        comp_name,
+        painter: p.clone(),
+        p,
+        selected: vec![],
+        sel_vertices: vec![],
+        ft: None,
+        comp: &comp,
+        gesture: None,
+        handle_hits: vec![],
+        axis_hits: vec![],
+        vertex_hits: vec![],
+        vertex_marks: vec![],
+        key_hits: vec![],
+        motion_frames: vec![],
+        paths: vec![],
+        track_hits: vec![],
+        pin_hits: vec![],
+        puppet_layers: vec![],
+    };
+    phase_nav(app, ui, rect, &mut v);
+    phase_layout(app, ui, rect, &mut v);
+    phase_frame(app, &mut v);
+    let snap_project = app.session.project.clone();
+    let snap_expr = app.session.expr.clone();
+    let ectx = EvalCtx {
+        project: &snap_project,
+        comp_id: cid,
+        comp: &comp,
+        time: v.time,
+        expr: snap_expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
+    phase_guides(app, &ectx, &mut v);
+    phase_layers(app, ui, &ectx, &mut v);
+    phase_scene(app, &ectx, &mut v);
+    phase_rigs(app, ui, &ectx, &mut v);
+    let resp = phase_menu(app, ui, &ectx, &mut v);
+    phase_hover(app, ui, &ectx, &resp, &mut v);
+    phase_press(app, ui, &ectx, &resp, &mut v);
+    phase_dragstart(app, ui, &ectx, &resp, &mut v);
+    phase_drag(app, ui, &ectx, &resp, &mut v);
+    phase_stopped(app, ui, &ectx, &resp, &mut v);
+    phase_clicked(app, &ectx, &resp, &mut v);
+    phase_dblclick(app, &ectx, &resp, &mut v);
+    phase_tail(app, ui, &ectx, &mut v);
+}
 
+fn phase_nav(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect, v: &mut Vw<'_>) {
+    let t = v.t;
+    let cid = v.cid;
+    let p = v.p.clone();
     // Navigator bar (open comps as breadcrumbs). After Effects shows a single breadcrumb row:
     // when the Composition Navigator (nested comp flow) is above the viewer, this row is left
     // out.
@@ -813,7 +260,16 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
         x = r.max.x + 4.0;
     }
+    v.nav = nav;
+}
 
+fn phase_layout(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect, v: &mut Vw<'_>) {
+    let t = v.t;
+    let cid = v.cid;
+    let nav = v.nav;
+    let ctx = v.ctx.clone();
+    let p = v.p.clone();
+    let comp = v.comp;
     // Bottom control bar.
     let bar_h = 36.0;
     let bar = Rect::from_min_max(pos2(rect.min.x, rect.max.y - bar_h), rect.max);
@@ -825,7 +281,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     // View ▸ Switch View Layout: extra views (Top / Front / Right) beside the main view, which
     // keeps the overlays and the interaction.
     let full = locked_pane(app, ui, full, pasteboard);
-    let area = aux_views(app, ui, &comp, cid, full, pasteboard);
+    let area = aux_views(app, ui, comp, cid, full, pasteboard);
     p.rect_filled(area, 0.0, pasteboard);
     // View ▸ Show Rulers takes a strip on the top and left.
     let outer = area;
@@ -848,8 +304,30 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let painter = p.with_clip_rect(area);
     // Settings ▸ 3D ▸ Extended Viewer: custom 3D views (and Draft 3D) render the visible
     // pasteboard too, so 3D layers reaching past the comp frame stay visible there.
-    app.ui.viewer.extended = extended_region(app, &comp, cid, map);
+    app.ui.viewer.extended = extended_region(app, comp, cid, map);
+    v.bar = bar;
+    v.err_bar = err_bar;
+    v.err_h = err_h;
+    v.pasteboard = pasteboard;
+    v.area = area;
+    v.outer = outer;
+    v.comp_rect = comp_rect;
+    v.zoom = zoom;
+    v.ppp = ppp;
+    v.cw = cw;
+    v.ch = ch;
+    v.map = map;
+    v.painter = painter;
+}
 
+fn phase_frame(app: &mut EffectcraftApp, v: &mut Vw<'_>) {
+    let cid = v.cid;
+    let comp_rect = v.comp_rect;
+    let zoom = v.zoom;
+    let ppp = v.ppp;
+    let ctx = v.ctx.clone();
+    let painter = v.painter.clone();
+    let comp = v.comp;
     // Frame.
     let scale = app.viewer_scale(zoom, ppp);
     if !app.playback.playing {
@@ -882,11 +360,21 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         let bg = comp.background;
         painter.rect_filled(comp_rect, 0.0, Color32::from_rgb((bg[0] * 255.0) as u8, (bg[1] * 255.0) as u8, (bg[2] * 255.0) as u8));
     }
-    let snap_project = app.session.project.clone();
-    let snap_expr = app.session.expr.clone();
-    let ectx = EvalCtx { project: &snap_project, comp_id: cid, comp: &comp, time, expr: snap_expr.as_deref(), footage: None };
+    v.time = time;
+}
+
+fn phase_guides(app: &mut EffectcraftApp, ectx: &EvalCtx, v: &mut Vw<'_>) {
+    let cid = v.cid;
+    let area = v.area;
+    let comp_rect = v.comp_rect;
+    let zoom = v.zoom;
+    let map = v.map;
+    let ctx = v.ctx.clone();
+    let comp_name = v.comp_name.clone();
+    let painter = v.painter.clone();
+    let comp = v.comp;
     // The frame (or snapshot) through Show Channel and exposure; ROI frames cover the region.
-    vt::draw_frame(app, &ctx, &painter, comp_rect, cid, &ectx);
+    vt::draw_frame(app, &ctx, &painter, comp_rect, cid, ectx);
     if app.ui.viewer.extended.is_some() {
         // The comp frame outlined over the extended render.
         painter.rect_stroke(comp_rect, 0.0, Stroke::new(1.0, Color32::from_gray(150)), StrokeKind::Outside);
@@ -972,17 +460,30 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
         app.auto.add("viewer.regionOfInterest", r, "Region of interest");
     }
+    v.overlays = overlays;
+}
+
+fn phase_layers(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, v: &mut Vw<'_>) {
+    let t = v.t;
+    let zoom = v.zoom;
+    let cw = v.cw;
+    let ch = v.ch;
+    let map = v.map;
+    let time = v.time;
+    let ctx = v.ctx.clone();
+    let painter = v.painter.clone();
+    let mut handle_hits = std::mem::take(&mut v.handle_hits);
+    let mut axis_hits = std::mem::take(&mut v.axis_hits);
+    let mut vertex_hits = std::mem::take(&mut v.vertex_hits);
+    let mut vertex_marks = std::mem::take(&mut v.vertex_marks);
+    let mut key_hits = std::mem::take(&mut v.key_hits);
+    let mut motion_frames = std::mem::take(&mut v.motion_frames);
+    let mut paths = std::mem::take(&mut v.paths);
+    let comp = v.comp;
     // Overlays + interaction.
     let selected = app.session.state.selected_layers.clone();
     // Bounding-box handles: (layer, handle, screen point, its resize cursor).
-    let mut handle_hits: Vec<(LayerId, usize, Pos2, egui::CursorIcon)> = Vec::new();
     // 3D gizmo arrows: (layer, grabbable screen segment, position change per comp px in x and y).
-    let mut axis_hits: Vec<(LayerId, [Pos2; 2], [f64; 3], [f64; 3])> = Vec::new();
-    let mut vertex_hits: Vec<VertexHit> = Vec::new();
-    let mut vertex_marks: Vec<ov::VertexMark> = Vec::new();
-    let mut key_hits: Vec<ov::KeyHit> = Vec::new();
-    let mut motion_frames: Vec<ov::PathFrame> = Vec::new();
-    let mut paths: Vec<ov::PathInfo> = Vec::new();
     let sel_vertices = app.session.state.selected_vertices.clone();
     // Pen path in progress ends when the tool changes or its mask is gone; Esc / Enter also end
     // free transform.
@@ -1005,7 +506,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         for l in comp.layers.iter().filter(|l| {
             matches!(l.source, LayerSource::Null) && !selected.contains(&l.id) && l.is_active_at(time) && l.switches.video && (!any_solo || l.switches.solo)
         }) {
-            let outline = layer_outline(&ectx, l);
+            let outline = layer_outline(ectx, l);
             if outline.len() > 2 {
                 let col = if label_handles { t.label(l.label) } else { t.accent };
                 painter.add(egui::Shape::closed_line(outline.into_iter().map(|p| map.to_screen(p)).collect(), Stroke::new(1.0, col)));
@@ -1019,12 +520,12 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         for l in comp.layers.iter().filter(|l| selected.contains(&l.id) && l.is_active_at(time) && (l.switches.video || l.source.is_av())) {
             let col = if label_handles { t.label(l.label) } else { t.accent };
             // Motion path of animated position (keyframes and spatial tangents are draggable).
-            ov::motion_path(app, &painter, &map, &ectx, l, col, &mut key_hits, &mut motion_frames);
+            ov::motion_path(app, &painter, &map, ectx, l, col, &mut key_hits, &mut motion_frames);
             // Masks and shape paths.
             if app.ui.viewer.show_masks {
                 let pen = ui.data(|d| d.get_temp::<(LayerId, u64)>(pen_id()));
                 let hover = ui.input(|i| i.pointer.hover_pos());
-                ov::draw_paths(app, &painter, &map, &ectx, l, col, &sel_vertices, pen, hover, &mut vertex_hits, &mut vertex_marks, &mut paths);
+                ov::draw_paths(app, &painter, &map, ectx, l, col, &sel_vertices, pen, hover, &mut vertex_hits, &mut vertex_marks, &mut paths);
             }
             // Settings ▸ Previews ▸ Show Internal Wireframes: outlines of the layers inside a
             // selected collapsed precomp.
@@ -1033,7 +534,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 && let effectcraft_engine::project::LayerSource::Comp { item } = &l.source
                 && let Some(nc) = app.session.project.comp(*item)
             {
-                let (outer, _) = l2c(&ectx, l);
+                let (outer, _) = l2c(ectx, l);
                 let nctx = EvalCtx::new(&app.session.project, *item, nc, ectx.nested_time(l));
                 for nl in nc.layers.iter().filter(|nl| nl.is_active_at(nctx.time) && !nl.is_3d()) {
                     if let Some((_, q, _)) = layer_quad(&nctx, nl) {
@@ -1056,9 +557,9 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             if editing_path {
                 continue;
             }
-            let Some((m, q, _)) = layer_quad(&ectx, l) else {
+            let Some((m, q, _)) = layer_quad(ectx, l) else {
                 // A 3D layer reaching past the camera: the part of its box in front of it.
-                let outline = layer_outline(&ectx, l);
+                let outline = layer_outline(ectx, l);
                 if outline.len() > 2 {
                     painter.add(egui::Shape::closed_line(outline.iter().map(|p| map.to_screen(*p)).collect(), Stroke::new(1.0, col)));
                     continue;
@@ -1093,10 +594,10 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 // 3D axis gizmo.
                 if l.is_3d() {
                     let w = ectx.world_matrix(l);
-                    let pc = cam_state(&ectx).projection(cw as f64, ch as f64) * w;
+                    let pc = cam_state(ectx).projection(cw as f64, ch as f64) * w;
                     let a3 = effectcraft_engine::geom::vec3(a[0], a[1], a[2]);
                     let len = 60.0 / zoom as f64;
-                    let pinv = parent_world_inverse(&ectx, l);
+                    let pinv = parent_world_inverse(ectx, l);
                     for (axis, col, name) in [
                         (effectcraft_engine::geom::vec3(len, 0.0, 0.0), Color32::from_rgb(0xe0, 0x50, 0x50), "x"),
                         (effectcraft_engine::geom::vec3(0.0, len, 0.0), Color32::from_rgb(0x60, 0xd0, 0x60), "y"),
@@ -1125,7 +626,31 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         }
     }
+    v.handle_hits = handle_hits;
+    v.axis_hits = axis_hits;
+    v.vertex_hits = vertex_hits;
+    v.vertex_marks = vertex_marks;
+    v.key_hits = key_hits;
+    v.motion_frames = motion_frames;
+    v.paths = paths;
+    v.selected = selected;
+    v.sel_vertices = sel_vertices;
+}
 
+fn phase_scene(app: &mut EffectcraftApp, ectx: &EvalCtx, v: &mut Vw<'_>) {
+    let t = v.t;
+    let cid = v.cid;
+    let area = v.area;
+    let comp_rect = v.comp_rect;
+    let cw = v.cw;
+    let ch = v.ch;
+    let map = v.map;
+    let time = v.time;
+    let painter = v.painter.clone();
+    let selected = v.selected.clone();
+    let vertex_marks = std::mem::take(&mut v.vertex_marks);
+    let mut track_hits = std::mem::take(&mut v.track_hits);
+    let comp = v.comp;
     // Path points last, over the boxes' handles (#1042).
     ov::draw_vertex_marks(&painter, &vertex_marks, app.session.prefs.general.path_point_size as f32 + 1.0);
 
@@ -1134,7 +659,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     let has_3d = comp.layers.iter().any(|l| l.is_3d() && l.is_active_at(time));
     if has_3d && app.session.prefs.three_d.extended_viewer {
         for l in comp.layers.iter().filter(|l| l.is_3d() && l.is_active_at(time) && l.has_video()) {
-            let q = layer_outline(&ectx, l);
+            let q = layer_outline(ectx, l);
             if q.len() > 2 {
                 let sq: Vec<Pos2> = q.iter().map(|p| map.to_screen(*p)).collect();
                 let outside = sq.iter().any(|p| !comp_rect.contains(*p));
@@ -1145,7 +670,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         }
     }
     if has_3d && app.session.prefs.three_d.show_reference_axes {
-        let pc = cam_state(&ectx).projection(cw as f64, ch as f64);
+        let pc = cam_state(ectx).projection(cw as f64, ch as f64);
         let o3 = effectcraft_engine::geom::vec3(cw as f64 / 2.0, ch as f64 / 2.0, 0.0);
         let o = pc.apply(o3);
         let corner = pos2(area.min.x + 34.0, area.max.y - 34.0);
@@ -1164,7 +689,6 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     }
 
     // Track points of the current track (Tracker panel) on its layer, while that layer is selected.
-    let mut track_hits = vec![];
     let track_cur = super::tracker::viewer_track(app);
     if app.layer_controls_visible()
         && let Some((tl, tu)) = track_cur
@@ -1172,7 +696,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         && let Some(layer) = comp.layer(tl)
         && layer.is_active_at(time)
     {
-        let (m, _) = l2c(&ectx, layer);
+        let (m, _) = l2c(ectx, layer);
         track_hits = super::tracker::draw_overlay(app, &painter, &map, &m, layer, tu, time);
     }
 
@@ -1184,7 +708,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         && let Some(layer) = comp.layer(wl)
         && layer.is_active_at(time)
     {
-        let (m, _) = l2c(&ectx, layer);
+        let (m, _) = l2c(ectx, layer);
         let (w, h) = effectcraft_engine::render::source_size(&app.session.project, layer);
         let c = m.apply(effectcraft_engine::geom::vec2(w as f64 / 2.0, h as f64 / 2.0));
         let at = map.to_screen([c.x, c.y]);
@@ -1196,17 +720,10 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         app.auto.add("viewer.warpBanner", r, &text);
     }
 
-    // Footage that can't be decoded (no decoder for its codec / profile): say why on the layer
-    // instead of leaving a black picture.
-    let mut notices = 0;
-    for layer in comp.layers.iter().filter(|l| l.is_active_at(time) && l.switches.video) {
-        let effectcraft_engine::project::LayerSource::Footage { item } = &layer.source else { continue };
-        let Some(effectcraft_engine::project::ItemKind::Footage(f)) = app.session.project.item(*item).map(|i| &i.kind) else { continue };
-        let Some(why) = app.session.footage.problem(f) else { continue };
-        if notices >= 3 {
-            break;
-        }
-        let (m, _) = l2c(&ectx, layer);
+    // Footage (or the proxy in use for footage or a precomp) that can't be decoded (no decoder
+    // for its codec / profile): say why on the layer instead of leaving a black picture.
+    for (notices, (layer, why)) in footage_problems(app, ectx, comp, time).into_iter().enumerate() {
+        let (m, _) = l2c(ectx, layer);
         let (w, h) = effectcraft_engine::render::source_size(&app.session.project, layer);
         let c = m.apply(effectcraft_engine::geom::vec2(w as f64 / 2.0, h as f64 / 2.0));
         let at = map.to_screen([c.x, c.y]);
@@ -1217,29 +734,58 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         painter.rect_stroke(r, 3.0, Stroke::new(1.0, t.warning), StrokeKind::Inside);
         painter.galley(pos2(r.min.x + 12.0, r.center().y - galley.size().y / 2.0), galley, Color32::WHITE);
         app.auto.add(&format!("viewer.footageProblem.{}", layer.id.0), r, &text);
-        notices += 1;
     }
+    v.vertex_marks = vertex_marks;
+    v.track_hits = track_hits;
+    v.track_cur = track_cur;
+    v.has_3d = has_3d;
+}
 
+/// Up to three layers active at `time` whose footage, or the proxy in use for footage or a
+/// precomp, can't be decoded, each with the reason.
+fn footage_problems<'c>(app: &EffectcraftApp, ectx: &EvalCtx, comp: &'c Comp, time: Tick) -> Vec<(&'c Layer, String)> {
+    comp.layers
+        .iter()
+        .filter(|l| l.is_active_at(time) && l.switches.video)
+        .filter_map(|layer| {
+            let (LayerSource::Footage { item } | LayerSource::Comp { item }) = &layer.source else { return None };
+            Some((layer, ectx.project.item(*item).and_then(|i| app.session.footage.item_problem(i))?))
+        })
+        .take(3)
+        .collect()
+}
+
+fn phase_rigs(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, v: &mut Vw<'_>) {
+    let t = v.t;
+    let cid = v.cid;
+    let area = v.area;
+    let map = v.map;
+    let time = v.time;
+    let ctx = v.ctx.clone();
+    let painter = v.painter.clone();
+    let selected = v.selected.clone();
+    let paths = std::mem::take(&mut v.paths);
+    let mut pin_hits = std::mem::take(&mut v.pin_hits);
+    let mut puppet_layers = std::mem::take(&mut v.puppet_layers);
+    let comp = v.comp;
     // Free transform box of a path (double-click a path with the Selection tool).
     let ft = ov::draw_free_transform(app, &ctx, &painter, &map, &paths);
 
     // Cameras and lights (wireframes) and the 3D view name.
     if comp.has_3d() {
         let through_active = VIEW_CAM.with(|c| c.get()).is_none();
-        draw_rigs(app, &painter, &map, &ectx, &selected, cam_state(&ectx), through_active, None);
+        draw_rigs(app, &painter, &map, ectx, &selected, cam_state(ectx), through_active, None);
         let view = app.session.state.views3d.get(&cid).map(|v| v.current).unwrap_or_default();
         let label = match (view, comp.active_camera(time)) {
-            (View3D::ActiveCamera, Some(c)) => format!("Active Camera ({})", c.name),
-            (v, _) => v.label().to_string(),
+            (View3D::ActiveCamera, Some(c)) => crate::i18n::tr_args("Active Camera ({})", &[&c.name]),
+            (v, _) => view3d_label(v).to_string(),
         };
         painter.text(area.left_top() + vec2(12.0, 10.0), Align2::LEFT_TOP, label, Tokens::ui(12.0), t.text_dim);
     }
 
     // Puppet pins and meshes of the selected layers (Puppet tools).
-    let mut pin_hits: Vec<super::puppet_tool::PinHit> = vec![];
     // The selected layers with a Puppet effect, top of the stack first (the layers the Puppet
     // tools work on).
-    let mut puppet_layers: Vec<(&Layer, super::puppet_tool::Overlay)> = vec![];
     if app.ui.tool.puppet_kind().is_some() {
         let sel_props: Vec<u64> = app.session.state.selected_props.iter().map(|(_, u)| *u).collect();
         for lid in &selected {
@@ -1247,7 +793,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 && let Some(ov) = super::puppet_tool::overlay(app, &ctx, cid, l, time)
             {
                 let hover = ui.input(|i| i.pointer.hover_pos());
-                pin_hits.extend(super::puppet_tool::draw(&painter, &map, &ectx, l, &ov, app.session.state.puppet.show_mesh, &sel_props, hover));
+                pin_hits.extend(super::puppet_tool::draw(&painter, &map, ectx, l, &ov, app.session.state.puppet.show_mesh, &sel_props, hover));
                 puppet_layers.push((l, ov));
             }
         }
@@ -1261,17 +807,21 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         }
     }
-    // The layer a Puppet tool press works on: while selected layers are rigged, only those
-    // ([`super::puppet_tool::target`]); otherwise the layer under the pointer, selected.
-    let puppet_layer = |app: &mut EffectcraftApp, cpt: [f64; 2]| -> Option<LayerId> {
-        if puppet_layers.is_empty() {
-            return pick(app, &ectx, cpt, false);
-        }
-        super::puppet_tool::target(&ectx, &puppet_layers, cpt, |l| layers_at(&ectx, cpt).any(|h| h.id == l.id))
-    };
+    v.paths = paths;
+    v.pin_hits = pin_hits;
+    v.puppet_layers = puppet_layers;
+    v.ft = ft;
+}
 
+fn phase_menu(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, v: &mut Vw<'_>) -> egui::Response {
+    let cid = v.cid;
+    let area = v.area;
+    let map = v.map;
+    let ctx = v.ctx.clone();
+    let painter = v.painter.clone();
+    let comp = v.comp;
     // Project items, files and effects dropped on the viewer.
-    super::viewer_drop::show(app, ui, &painter, &map, &ectx);
+    super::viewer_drop::show(app, ui, &painter, &map, ectx);
 
     // Interaction.
     let resp = ui.interact(area, egui::Id::unique("viewer-interact"), Sense::click_and_drag());
@@ -1281,9 +831,9 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     {
         // Picking an already selected layer preserves the group; an unselected hit
         // becomes the target, using the same visible/unlocked hit test as left-click.
-        pick(app, &ectx, map.to_comp(pos), false);
+        pick(app, ectx, map.to_comp(pos), false);
         let point = map.to_comp(pos);
-        let hits: Vec<(u64, String)> = layers_at(&ectx, point).map(|l| (l.id.0, l.name.clone())).collect();
+        let hits: Vec<(u64, String)> = layers_at(ectx, point).map(|l| (l.id.0, l.name.clone())).collect();
         ui.data_mut(|d| d.insert_temp(menu_hits_id, hits));
     }
     let context_layers: Vec<u64> =
@@ -1338,6 +888,44 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             app.ui.status = e;
         }
     }
+    resp
+}
+
+/// Frames to step when wheel scrubbing is on, or `None` when this gesture should zoom or pan.
+/// A scrub notch's smoothed tail stays a scrub after the wheel event itself is gone, so that
+/// tail does not zoom or pan (#1218).
+fn wheel_scrub_frames(ctx: &egui::Context, pref: bool, scroll: &super::ViewerScroll) -> Option<i64> {
+    let tail_id = egui::Id::unique("viewer-wheel-scrub-tail");
+    let was_tail: bool = ctx.data(|d| d.get_temp(tail_id)).unwrap_or(false);
+    let moving = scroll.pan != egui::Vec2::ZERO || (scroll.zoom - 1.0).abs() > 3e-4;
+    let scrub = pref && !scroll.trackpad && !scroll.wheel_modified && (scroll.wheel_lines.abs() >= 0.01 || (was_tail && moving));
+    ctx.data_mut(|d| {
+        if scrub {
+            d.insert_temp(tail_id, true);
+        } else {
+            d.remove::<bool>(tail_id);
+        }
+    });
+    scrub.then_some((scroll.wheel_lines.round() as i64).clamp(-30, 30))
+}
+
+fn phase_hover(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
+    let area = v.area;
+    let zoom = v.zoom;
+    let cw = v.cw;
+    let ch = v.ch;
+    let map = v.map;
+    let ctx = v.ctx.clone();
+    let painter = v.painter.clone();
+    let handle_hits = std::mem::take(&mut v.handle_hits);
+    let axis_hits = std::mem::take(&mut v.axis_hits);
+    let vertex_hits = std::mem::take(&mut v.vertex_hits);
+    let key_hits = std::mem::take(&mut v.key_hits);
+    let motion_frames = std::mem::take(&mut v.motion_frames);
+    let paths = std::mem::take(&mut v.paths);
+    let track_hits = std::mem::take(&mut v.track_hits);
+    let pin_hits = std::mem::take(&mut v.pin_hits);
+    let comp = v.comp;
     // Path vertices and tangent handles take the press before the bounding-box handles (#1042).
     let vertex_at = |pos: Pos2, tangents: bool| -> Option<VertexHit> {
         let reach = vertex_grab_radius(pos, handle_hits.iter().map(|(_, _, h, _)| *h));
@@ -1372,7 +960,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 // The tool draws its own crosshair (and the layer it would matte) while no box
                 // is being dragged.
                 if ui.data(|d| d.get_temp::<Gesture>(egui::Id::unique("viewer-gesture"))).is_none() {
-                    super::object_matte_tool::hover(app, &painter, &map, &ectx, hp);
+                    super::object_matte_tool::hover(app, &painter, &map, ectx, hp);
                 }
                 egui::CursorIcon::None
             }
@@ -1386,7 +974,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             _ => {
                 if super::tracker::hit_at(&track_hits, hp).is_some() || key_hits.iter().any(|h| h.pos.distance(hp) < 6.0) {
                     egui::CursorIcon::Move
-                } else if let Some((_, vertical)) = vt::guide_at(app, &comp, &map, hp) {
+                } else if let Some((_, vertical)) = vt::guide_at(app, comp, &map, hp) {
                     if vertical { egui::CursorIcon::ResizeHorizontal } else { egui::CursorIcon::ResizeVertical }
                 } else if vertex_at(hp, true).or_else(|| vertex_at(hp, false)).is_some() {
                     // A path point under a box handle is grabbed first: no resize cursor.
@@ -1401,11 +989,23 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         };
         ctx.set_cursor_icon(cursor);
-        // Scroll wheel zooms around the pointer.
-        let scroll = ui.input(|i| i.smooth_scroll_delta.y + i.zoom_delta().ln() * 300.0);
-        if scroll.abs() > 0.1 && area.contains(hp) {
-            let k = (scroll / 300.0).exp();
-            let nz = (zoom * k).clamp(0.01, 32.0);
+        // The mouse wheel and a trackpad pinch zoom around the pointer; a two-finger trackpad
+        // scroll pans. With general.viewerWheelScrubbing, an unmodified wheel steps frames
+        // instead, including the smoothed tail of that notch so it does not zoom or pan (#1218).
+        let scroll = super::viewer_scroll(&ctx);
+        let scrub = wheel_scrub_frames(&ctx, app.session.prefs.general.viewer_wheel_scrubbing, &scroll);
+        if let Some(frames) = scrub {
+            if frames != 0 && area.contains(hp) {
+                if app.playback.playing {
+                    let _ = crate::menus::invoke(app, &ctx, "playback.stop", json!({}));
+                }
+                let _ = app.session.execute("time.step", json!({"frames": frames}));
+            }
+        } else if scroll.pan != egui::Vec2::ZERO && area.contains(hp) {
+            app.ui.viewer.pan = [app.ui.viewer.pan[0] + scroll.pan.x, app.ui.viewer.pan[1] + scroll.pan.y];
+        }
+        if scrub.is_none() && (scroll.zoom - 1.0).abs() > 3e-4 && area.contains(hp) {
+            let nz = (zoom * scroll.zoom).clamp(0.01, 32.0);
             let before = map.to_comp(hp);
             let new_origin = hp - vec2(before[0] as f32 * nz, before[1] as f32 * nz);
             let new_center = new_origin + vec2(cw * nz / 2.0, ch * nz / 2.0);
@@ -1416,6 +1016,24 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     } else {
         app.pointer_comp = None;
     }
+    v.handle_hits = handle_hits;
+    v.axis_hits = axis_hits;
+    v.vertex_hits = vertex_hits;
+    v.key_hits = key_hits;
+    v.motion_frames = motion_frames;
+    v.paths = paths;
+    v.track_hits = track_hits;
+    v.pin_hits = pin_hits;
+    v.gid = gid;
+}
+
+fn phase_press(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
+    let map = v.map;
+    let ctx = v.ctx.clone();
+    let painter = v.painter.clone();
+    let key_hits = std::mem::take(&mut v.key_hits);
+    let motion_frames = std::mem::take(&mut v.motion_frames);
+    let paths = std::mem::take(&mut v.paths);
     app.ui.viewer.interacting = resp.dragged();
     let mods = ui.input(|i| i.modifiers);
     let space_pan = super::space_hand(&ctx);
@@ -1427,7 +1045,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         && ui.input(|i| i.pointer.primary_pressed())
         && let Some(pos) = ui.input(|i| i.pointer.press_origin())
     {
-        pen_press(app, ui, &ectx, &map, &paths, ov::motion_frame_at(&motion_frames, &key_hits, pos), pos, mods);
+        pen_press(app, ui, ectx, &map, &paths, ov::motion_frame_at(&motion_frames, &key_hits, pos), pos, mods);
     }
     // A pen click (press + release without a drag) ends its tangent gesture on release.
     if ui.input(|i| i.pointer.primary_released())
@@ -1437,7 +1055,45 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         ui.data_mut(|d| d.remove::<Gesture>(egui::Id::unique("viewer-gesture")));
     }
     // On-canvas text editing (Type tool, double-click a text layer) owns its clicks and drags.
-    let text_owns = super::viewer_text::hook(app, ui, &painter, &map, &ectx, &resp, space_pan);
+    let text_owns = super::viewer_text::hook(app, ui, &painter, &map, ectx, resp, space_pan);
+    v.key_hits = key_hits;
+    v.motion_frames = motion_frames;
+    v.paths = paths;
+    v.mods = mods;
+    v.space_pan = space_pan;
+    v.text_owns = text_owns;
+}
+
+fn phase_dragstart(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
+    let comp_rect = v.comp_rect;
+    let zoom = v.zoom;
+    let map = v.map;
+    let time = v.time;
+    let mods = v.mods;
+    let space_pan = v.space_pan;
+    let text_owns = v.text_owns;
+    let gid = v.gid;
+    let track_cur = v.track_cur;
+    let ft = std::mem::take(&mut v.ft);
+    let handle_hits = std::mem::take(&mut v.handle_hits);
+    let axis_hits = std::mem::take(&mut v.axis_hits);
+    let vertex_hits = std::mem::take(&mut v.vertex_hits);
+    let key_hits = std::mem::take(&mut v.key_hits);
+    let paths = std::mem::take(&mut v.paths);
+    let track_hits = std::mem::take(&mut v.track_hits);
+    let pin_hits = std::mem::take(&mut v.pin_hits);
+    let puppet_layers = std::mem::take(&mut v.puppet_layers);
+    let comp = v.comp;
+    let vertex_at = |pos: Pos2, tangents: bool| -> Option<VertexHit> {
+        let reach = vertex_grab_radius(pos, handle_hits.iter().map(|(_, _, h, _)| *h));
+        vertex_hits.iter().rev().filter(|h| h.tangent.is_some() == tangents).find(|h| h.pos.distance(pos) < reach).copied()
+    };
+    let puppet_layer = |app: &mut EffectcraftApp, cpt: [f64; 2]| -> Option<LayerId> {
+        if puppet_layers.is_empty() {
+            return pick(app, ectx, cpt, false);
+        }
+        super::puppet_tool::target(ectx, &puppet_layers, cpt, |l| layers_at(ectx, cpt).any(|h| h.id == l.id))
+    };
     if resp.drag_started()
         && !text_owns
         && let Some(pos) = resp.interact_pointer_pos()
@@ -1457,8 +1113,8 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             Tool::Selection if key_hits.iter().any(|h| h.pos.distance(press) < 6.0) => {
                 ov::begin_key_drag(app, &key_hits, press, map.to_comp(press), mods.shift).map(Gesture::Overlay)
             }
-            Tool::Selection if vt::guide_at(app, &comp, &map, press).is_some() => {
-                vt::guide_at(app, &comp, &map, press).map(|(index, vertical)| Gesture::Overlay(ov::Drag::Guide { index, vertical }))
+            Tool::Selection if vt::guide_at(app, comp, &map, press).is_some() => {
+                vt::guide_at(app, comp, &map, press).map(|(index, vertical)| Gesture::Overlay(ov::Drag::Guide { index, vertical }))
             }
             // Alt-drag a vertex with the Selection tool (or drag one with Convert Vertex): pull
             // new tangents out of it.
@@ -1468,9 +1124,9 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     Gesture::Pen { layer: h.layer, mask: h.mask, index: h.index, vertex: h.vertex, inv, press }
                 })
             }
-            Tool::MaskFeather => ov::begin_feather(app, &ectx, &paths, &map, press).map(Gesture::Overlay),
-            Tool::Rotate => pick(app, &ectx, cpt, mods.shift).map(|l| {
-                let others = selected_others(app, &comp, l).into_iter().filter_map(|o| Some((o.id, ectx.f(o, o.transform()?, "rotation", 0.0)))).collect();
+            Tool::MaskFeather => ov::begin_feather(app, ectx, &paths, &map, press).map(Gesture::Overlay),
+            Tool::Rotate => pick(app, ectx, cpt, mods.shift).map(|l| {
+                let others = selected_others(app, comp, l).into_iter().filter_map(|o| Some((o.id, ectx.f(o, o.transform()?, "rotation", 0.0)))).collect();
                 let layer = comp.layer(l).cloned();
                 let center = layer
                     .as_ref()
@@ -1487,10 +1143,10 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     others,
                 }
             }),
-            Tool::PanBehind => pick(app, &ectx, cpt, false).and_then(|l| {
+            Tool::PanBehind => pick(app, ectx, cpt, false).and_then(|l| {
                 let layer = comp.layer(l)?;
                 let tr = layer.transform()?;
-                let (l2c, _) = l2c(&ectx, layer);
+                let (l2c, _) = l2c(ectx, layer);
                 let l2p = ectx.local_matrix(layer);
                 let l2p = Mat3([[l2p.0[0][0], l2p.0[0][1], 0.0], [l2p.0[1][0], l2p.0[1][1], 0.0], [0.0, 0.0, 1.0]]);
                 Some(Gesture::Anchor {
@@ -1501,7 +1157,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     start: map.to_comp(press),
                     inv: l2c.inverse().unwrap_or(Mat3::IDENTITY),
                     l2p,
-                    own: effectcraft_engine::viewer::layer_targets(&ectx, layer, false, app.session.state.snap_features),
+                    own: effectcraft_engine::viewer::layer_targets(ectx, layer, false, app.session.state.snap_features),
                     anchor_only: mods.alt,
                 })
             }),
@@ -1527,7 +1183,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     PinPart::Center => {}
                 }
                 let l = comp.layer(h.layer)?;
-                let inv = fx2c(&ectx, l).inverse()?;
+                let inv = fx2c(ectx, l).inverse()?;
                 if mods.command {
                     let lp = inv.apply(gv2(cpt[0], cpt[1]));
                     let began = ui.input(|i| i.time);
@@ -1547,7 +1203,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 let hit = super::tracker::hit_at(&track_hits, press);
                 track_cur.zip(hit).and_then(|((tl, tu), hit)| {
                     let layer = comp.layer(tl)?;
-                    let (m, _) = l2c(&ectx, layer);
+                    let (m, _) = l2c(ectx, layer);
                     super::tracker::begin_drag(layer, tu, time, &m, hit, map.to_comp(press)).map(|drag| Gesture::Track { layer: tl, tracker: tu, drag })
                 })
             }
@@ -1587,11 +1243,11 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     let layer = comp.layer(lid).cloned();
                     layer.and_then(|layer| {
                         let tr = layer.transform()?;
-                        let (l2c, _) = l2c(&ectx, &layer);
+                        let (l2c, _) = l2c(ectx, &layer);
                         let inv = l2c.inverse()?;
                         let a = ectx.v3(&layer, tr, "anchor", [0.0; 3]);
                         let lp = inv.apply(gv2(cpt[0], cpt[1]));
-                        let hp = handle_point(effectcraft_engine::render::content_bounds(&ectx, &layer)?, hi);
+                        let hp = handle_point(effectcraft_engine::render::content_bounds(ectx, &layer)?, hi);
                         Some(Gesture::Scale {
                             layer: lid,
                             start_scale: ectx.v3(&layer, tr, "scale", [100.0; 3]),
@@ -1601,13 +1257,13 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                             axes: handle_axes(hi),
                             l2c,
                             inv,
-                            others: selected_others(app, &comp, lid)
+                            others: selected_others(app, comp, lid)
                                 .into_iter()
                                 .filter_map(|o| Some((o.id, ectx.v3(o, o.transform()?, "scale", [100.0; 3]))))
                                 .collect(),
                         })
                     })
-                } else if let Some(l) = pick(app, &ectx, cpt, mods.shift) {
+                } else if let Some(l) = pick(app, ectx, cpt, mods.shift) {
                     let layers: Vec<(LayerId, [f64; 3], [f64; 3], [f64; 3])> = app
                         .session
                         .state
@@ -1617,12 +1273,12 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                         .filter(|l| !l.switches.locked)
                         .filter_map(|l| {
                             let p0 = ectx.v3(l, l.transform()?, "position", [0.0; 3]);
-                            let (ax, ay) = drag_axes(&ectx, l);
+                            let (ax, ay) = drag_axes(ectx, l);
                             Some((l.id, p0, ax, ay))
                         })
                         .collect();
                     // Snap the grabbed layer's feature nearest the pointer (AE's snap handle).
-                    let snap_src = comp.layer(l).map(|layer| effectcraft_engine::viewer::layer_features(&ectx, layer)).and_then(|f| {
+                    let snap_src = comp.layer(l).map(|layer| effectcraft_engine::viewer::layer_features(ectx, layer)).and_then(|f| {
                         let c = map.to_comp(press);
                         f.into_iter().min_by(|a, b| {
                             let da = (a[0] - c[0]).powi(2) + (a[1] - c[1]).powi(2);
@@ -1651,8 +1307,61 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             ui.data_mut(|d| d.insert_temp(gid, g));
         }
     }
+    v.ft = ft;
+    v.handle_hits = handle_hits;
+    v.axis_hits = axis_hits;
+    v.vertex_hits = vertex_hits;
+    v.key_hits = key_hits;
+    v.paths = paths;
+    v.track_hits = track_hits;
+    v.pin_hits = pin_hits;
+    v.puppet_layers = puppet_layers;
+}
+
+/// Auto-pan (#999): a mask vertex, tangent or Pen drag held at (or past) the edge of the view
+/// pans it, as in After Effects, so the point moves on past what was visible. Returns the map
+/// of the panned view.
+fn edge_pan(app: &mut EffectcraftApp, ctx: &egui::Context, g: &Gesture, map: ViewerMap, pos: Pos2) -> ViewerMap {
+    if !matches!(g, Gesture::Vertices { .. } | Gesture::Tangent { .. } | Gesture::Pen { .. }) {
+        return map;
+    }
+    let d = edge_pan_speed(map.area, pos) * ctx.input(|i| i.stable_dt).min(0.1);
+    if d == egui::Vec2::ZERO {
+        return map;
+    }
+    app.ui.viewer.pan = [app.ui.viewer.pan[0] + d.x, app.ui.viewer.pan[1] + d.y];
+    ctx.request_repaint();
+    ViewerMap { origin: map.origin + d, ..map }
+}
+
+/// How fast (points per second, per axis) the view pans under a drag at `pos`: within 24 points
+/// of an edge of `area`, or past it, toward that edge and faster the further out.
+fn edge_pan_speed(area: Rect, pos: Pos2) -> egui::Vec2 {
+    const ZONE: f32 = 24.0;
+    let axis = |p: f32, lo: f32, hi: f32| {
+        let depth = if p < lo + ZONE {
+            lo + ZONE - p
+        } else if p > hi - ZONE {
+            hi - ZONE - p
+        } else {
+            0.0
+        };
+        (depth / ZONE).clamp(-3.0, 3.0) * 400.0
+    };
+    vec2(axis(pos.x, area.min.x, area.max.x), axis(pos.y, area.min.y, area.max.y))
+}
+
+fn phase_drag(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
+    let t = v.t;
+    let zoom = v.zoom;
+    let map = v.map;
+    let mods = v.mods;
+    let gid = v.gid;
+    let ctx = v.ctx.clone();
+    let painter = v.painter.clone();
     let gesture: Option<Gesture> = ui.data(|d| d.get_temp(gid));
     if let (Some(g), Some(pos)) = (gesture.clone(), resp.interact_pointer_pos()) {
+        let map = edge_pan(app, &ctx, &g, map, pos);
         let cpt = map.to_comp(pos);
         let merge = format!("viewer-drag-{}", ui.data(|d| d.get_temp::<u64>(egui::Id::unique("viewer-drag-n")).unwrap_or(0)));
         match g {
@@ -1667,7 +1376,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 let mut d = one_axis([cpt[0] - start[0], cpt[1] - start[1]], mods.shift);
                 if let Some(src) = snap_src {
                     let ids: Vec<LayerId> = layers.iter().map(|x| x.0).collect();
-                    let c = vt::snap(app, &ctx, &ectx, &map, &ids, &[[src[0] + d[0], src[1] + d[1]]], mods);
+                    let c = vt::snap(app, &ctx, ectx, &map, &ids, &[[src[0] + d[0], src[1] + d[1]]], mods);
                     d = [d[0] + c[0], d[1] + c[1]];
                     if vt::snapping_on(app, mods) {
                         vt::draw_handle(&painter, map.to_screen([src[0] + d[0], src[1] + d[1]]));
@@ -1684,7 +1393,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 let f = drag_ratio(start_local, [lp.x - anchor[0], lp.y - anchor[1]], axes, uniform);
                 // The handle snaps (to the comp's and other layers' edges, corners and centres),
                 // so a layer scales exactly to them, e.g. to the comp's size.
-                let f = snap_handle(f, handle, anchor, &l2c, axes, uniform, |p| vt::snap(app, &ctx, &ectx, &map, &[layer], &[p], mods));
+                let f = snap_handle(f, handle, anchor, &l2c, axes, uniform, |p| vt::snap(app, &ctx, ectx, &map, &[layer], &[p], mods));
                 for (lid, s0) in std::iter::once((layer, start_scale)).chain(others) {
                     let v = [s0[0] * f[0], s0[1] * f[1], s0[2]];
                     let _ = app.session.execute("prop.set", json!({"layer": lid.0, "path": "transform/scale", "value": v, "merge": merge}));
@@ -1710,7 +1419,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 let d = one_axis([cpt[0] - start[0], cpt[1] - start[1]], mods.shift);
                 let anchor_c = inv.inverse().map(|m| m.apply(gv2(start_anchor[0], start_anchor[1]))).unwrap_or(gv2(start[0], start[1]));
                 let want = [anchor_c.x + d[0], anchor_c.y + d[1]];
-                let sc = vt::snap_with(app, &ctx, &ectx, &map, &[layer], &[want], mods, &own);
+                let sc = vt::snap_with(app, &ctx, ectx, &map, &vt::SnapQuery { exclude: &[layer], sources: &[want], mods, extra: &own });
                 let a = inv.apply(gv2(start[0], start[1]));
                 let b = inv.apply(gv2(start[0] + d[0] + sc[0], start[1] + d[1] + sc[1]));
                 let dl = gv2(b.x - a.x, b.y - a.y);
@@ -1743,9 +1452,10 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 }
             }
             Gesture::Vertices { start, src, applied, inv, layer } => {
-                // The grabbed vertex snaps (to other layers' vertices and features, guides, grid).
-                let want = [cpt[0] - start[0], cpt[1] - start[1]];
-                let c = vt::snap(app, &ctx, &ectx, &map, &[layer], &[[src[0] + want[0], src[1] + want[1]]], mods);
+                // The grabbed vertex snaps (to other layers' vertices and features, guides, grid);
+                // Shift keeps it to one axis, as a layer move does (#1964).
+                let want = one_axis([cpt[0] - start[0], cpt[1] - start[1]], mods.shift);
+                let c = vt::snap(app, &ctx, ectx, &map, &[layer], &[[src[0] + want[0], src[1] + want[1]]], mods);
                 let total = [want[0] + c[0], want[1] + c[1]];
                 let d = inv.apply_vec(gv2(total[0] - applied[0], total[1] - applied[1]));
                 if d.x != 0.0 || d.y != 0.0 {
@@ -1764,7 +1474,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     painter.rect_stroke(r, 0.0, Stroke::new(1.0, Color32::WHITE), StrokeKind::Middle);
                 }
                 d => {
-                    let mut snapper = |a: &EffectcraftApp, p: [f64; 2], l: LayerId| vt::snap(a, &ctx, &ectx, &map, &[l], &[p], mods);
+                    let mut snapper = |a: &EffectcraftApp, p: [f64; 2], l: LayerId| vt::snap(a, &ctx, ectx, &map, &[l], &[p], mods);
                     if let Some(nd) = ov::update(app, &d, cpt, pos, mods, &merge, zoom, &mut snapper) {
                         ui.data_mut(|dd| dd.insert_temp(gid, Gesture::Overlay(nd)));
                     }
@@ -1845,6 +1555,20 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         }
     }
+    v.gesture = gesture;
+}
+
+fn phase_stopped(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
+    let area = v.area;
+    let comp_rect = v.comp_rect;
+    let map = v.map;
+    let time = v.time;
+    let mods = v.mods;
+    let gid = v.gid;
+    let vertex_hits = std::mem::take(&mut v.vertex_hits);
+    let pin_hits = std::mem::take(&mut v.pin_hits);
+    let gesture = v.gesture.clone();
+    let comp = v.comp;
     if resp.drag_stopped() {
         if let (Some(g), Some(pos)) = (gesture, resp.interact_pointer_pos()) {
             match g {
@@ -1878,7 +1602,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     }
                 }
                 Gesture::PuppetPin { layer, pin, .. } => super::puppet_tool::reveal_pin(app, layer, pin),
-                Gesture::ObjectMatteBox { start } => super::object_matte_tool::apply(app, &ectx, &map, start, Some(pos), mods.shift),
+                Gesture::ObjectMatteBox { start } => super::object_matte_tool::apply(app, ectx, &map, start, Some(pos), mods.shift),
                 Gesture::Create { tool, start } => {
                     let end = map.to_comp(pos);
                     create_shape(app, tool, start, end, mods);
@@ -1911,8 +1635,8 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 Gesture::Marquee { start } => {
                     let a = map.to_comp(start);
                     let b = map.to_comp(pos);
-                    let hits: Vec<u64> = selectable_layers(&comp, time)
-                        .filter(|l| layer_quad(&ectx, l).is_some_and(|(_, q, _)| quad_intersects_box(&q, a, b)))
+                    let hits: Vec<u64> = selectable_layers(comp, time)
+                        .filter(|l| layer_quad(ectx, l).is_some_and(|(_, q, _)| quad_intersects_box(&q, a, b)))
                         .map(|l| l.id.0)
                         .collect();
                     let _ = app.session.execute("layer.select", json!({"layers": hits, "toggle": mods.shift}));
@@ -1926,6 +1650,38 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             d.insert_temp(egui::Id::unique("viewer-drag-n"), n + 1);
         });
     }
+    v.vertex_hits = vertex_hits;
+    v.pin_hits = pin_hits;
+}
+
+fn phase_clicked(app: &mut EffectcraftApp, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
+    let area = v.area;
+    let zoom = v.zoom;
+    let cw = v.cw;
+    let ch = v.ch;
+    let map = v.map;
+    let mods = v.mods;
+    let text_owns = v.text_owns;
+    let ctx = v.ctx.clone();
+    let ft = std::mem::take(&mut v.ft);
+    let handle_hits = std::mem::take(&mut v.handle_hits);
+    let vertex_hits = std::mem::take(&mut v.vertex_hits);
+    let key_hits = std::mem::take(&mut v.key_hits);
+    let motion_frames = std::mem::take(&mut v.motion_frames);
+    let paths = std::mem::take(&mut v.paths);
+    let pin_hits = std::mem::take(&mut v.pin_hits);
+    let puppet_layers = std::mem::take(&mut v.puppet_layers);
+    let comp = v.comp;
+    let vertex_at = |pos: Pos2, tangents: bool| -> Option<VertexHit> {
+        let reach = vertex_grab_radius(pos, handle_hits.iter().map(|(_, _, h, _)| *h));
+        vertex_hits.iter().rev().filter(|h| h.tangent.is_some() == tangents).find(|h| h.pos.distance(pos) < reach).copied()
+    };
+    let puppet_layer = |app: &mut EffectcraftApp, cpt: [f64; 2]| -> Option<LayerId> {
+        if puppet_layers.is_empty() {
+            return pick(app, ectx, cpt, false);
+        }
+        super::puppet_tool::target(ectx, &puppet_layers, cpt, |l| layers_at(ectx, cpt).any(|h| h.id == l.id))
+    };
     if resp.clicked()
         && !text_owns
         && let Some(pos) = resp.interact_pointer_pos()
@@ -1966,8 +1722,9 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                     let _ = app.session.execute("mask.convertVertex", json!({"layer": h.layer.0, "mask": h.mask, "index": h.index}));
                 } else if let Some(k) = ov::motion_key_at(&key_hits, pos) {
                     // A key showing direction handles becomes Linear; one without, Auto Bezier.
+                    // Separated X / Y Position have no spatial interpolation to convert.
                     let curved = key_hits.iter().any(|h| h.tangent.is_some() && h.layer == k.layer && h.prop == k.prop && h.time == k.time);
-                    if select_motion_key(app, &k) {
+                    if k.axes.is_none() && select_motion_key(app, &k) {
                         let spatial = if curved { "linear" } else { "autoBezier" };
                         let _ = app.session.execute("keys.interpolation", json!({"spatial": spatial}));
                     }
@@ -1982,13 +1739,13 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
                 // Clicking away from the free-transform box ends it.
                 ov::end_free_transform(&ctx);
             }
-            Tool::ObjectMatte => super::object_matte_tool::apply(app, &ectx, &map, pos, None, mods.shift),
+            Tool::ObjectMatte => super::object_matte_tool::apply(app, ectx, &map, pos, None, mods.shift),
             t if t.puppet_kind().is_some() => {
                 if let Some((h, _)) = super::puppet_tool::hit(&pin_hits, pos) {
                     // Click selects the pin; Shift-click adds or removes it.
                     let _ = app.session.execute("puppet.selectPins", json!({"layer": h.layer.0, "pins": [h.pin], "toggle": mods.shift}));
                 } else if let Some(l) = puppet_layer(app, cpt).and_then(|l| comp.layer(l))
-                    && let Some(inv) = fx2c(&ectx, l).inverse()
+                    && let Some(inv) = fx2c(ectx, l).inverse()
                 {
                     let lp = inv.apply(gv2(cpt[0], cpt[1]));
                     match app.session.execute("puppet.addPin", json!({"layer": l.id.0, "kind": t.puppet_kind(), "position": [lp.x, lp.y]})) {
@@ -2009,13 +1766,13 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
             // The Roto Brush paints in the Layer panel only: select as usual and say so.
             rt if rt.roto_kind(false).is_some() => {
-                if pick(app, &ectx, cpt, mods.shift).is_none() {
+                if pick(app, ectx, cpt, mods.shift).is_none() {
                     let _ = app.session.execute("edit.deselectAll", json!({}));
                 }
                 app.ui.status = crate::i18n::tr(ROTO_HINT).to_string();
             }
             _ => {
-                if pick(app, &ectx, cpt, mods.shift).is_none() {
+                if pick(app, ectx, cpt, mods.shift).is_none() {
                     let _ = app.session.execute("edit.deselectAll", json!({}));
                 } else if !mods.shift && !app.session.state.selected_vertices.is_empty() && ov::segment_at(&paths, &map, pos, 6.0).is_none() {
                     // A click away from the paths, even on their layer, deselects the mask
@@ -2025,6 +1782,28 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         }
     }
+    v.ft = ft;
+    v.handle_hits = handle_hits;
+    v.vertex_hits = vertex_hits;
+    v.key_hits = key_hits;
+    v.motion_frames = motion_frames;
+    v.paths = paths;
+    v.pin_hits = pin_hits;
+    v.puppet_layers = puppet_layers;
+}
+
+fn phase_dblclick(app: &mut EffectcraftApp, ectx: &EvalCtx, resp: &egui::Response, v: &mut Vw<'_>) {
+    let map = v.map;
+    let text_owns = v.text_owns;
+    let ctx = v.ctx.clone();
+    let handle_hits = std::mem::take(&mut v.handle_hits);
+    let vertex_hits = std::mem::take(&mut v.vertex_hits);
+    let paths = std::mem::take(&mut v.paths);
+    let comp = v.comp;
+    let vertex_at = |pos: Pos2, tangents: bool| -> Option<VertexHit> {
+        let reach = vertex_grab_radius(pos, handle_hits.iter().map(|(_, _, h, _)| *h));
+        vertex_hits.iter().rev().filter(|h| h.tangent.is_some() == tangents).find(|h| h.pos.distance(pos) < reach).copied()
+    };
     if resp.double_clicked()
         && !text_owns
         && app.ui.tool == Tool::Selection
@@ -2046,7 +1825,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
     {
         let cpt = map.to_comp(pos);
         let roto = app.ui.tool.roto_kind(false).is_some();
-        if let Some(l) = pick(app, &ectx, cpt, false).and_then(|l| comp.layer(l)) {
+        if let Some(l) = pick(app, ectx, cpt, false).and_then(|l| comp.layer(l)) {
             match &l.source {
                 effectcraft_engine::project::LayerSource::Comp { item } => app.session.open_comp(*item),
                 // With a Roto Brush tool, double-clicking a layer opens it in the Layer panel,
@@ -2062,15 +1841,34 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
             }
         }
     }
+    v.handle_hits = handle_hits;
+    v.vertex_hits = vertex_hits;
+    v.paths = paths;
+}
+
+fn phase_tail(app: &mut EffectcraftApp, ui: &mut egui::Ui, ectx: &EvalCtx, v: &mut Vw<'_>) {
+    let t = v.t;
+    let cid = v.cid;
+    let bar = v.bar;
+    let err_bar = v.err_bar;
+    let err_h = v.err_h;
+    let area = v.area;
+    let outer = v.outer;
+    let zoom = v.zoom;
+    let map = v.map;
+    let time = v.time;
+    let ctx = v.ctx.clone();
+    let painter = v.painter.clone();
+    let comp = v.comp;
     // 3D Camera Tracker points, targets and their menu (on top of the viewer's gestures while
     // the effect is selected), and its analysis banner.
-    super::camera_tracker_ui::viewer_hook(app, ui, &painter, &map, &ectx, &|c, l| l2c(c, l).0);
+    super::camera_tracker_ui::viewer_hook(app, ui, &painter, &map, ectx, &|c, l| l2c(c, l).0);
     // Effect point controls and crosshair/eyedropper picks (on top of the viewer's gestures).
-    crate::panels::effect_controls::viewer_hook(app, ui, &painter, &map, &ectx, &|c, l| l2c(c, l).0);
+    crate::panels::effect_controls::viewer_hook(app, ui, &painter, &map, ectx, &|c, l| l2c(c, l).0);
     // Selected shape gradients' start and end points (#612).
-    crate::panels::gradient_handles::viewer_hook(app, ui, &painter, &map, &ectx, &|c, l| l2c(c, l).0);
+    crate::panels::gradient_handles::viewer_hook(app, ui, &painter, &map, ectx, &|c, l| l2c(c, l).0);
     // Selected text Range Selectors' Start and End bars (#1011).
-    crate::panels::text_range_handles::viewer_hook(app, ui, &painter, &map, &ectx, &|c, l| l2c(c, l).0);
+    crate::panels::text_range_handles::viewer_hook(app, ui, &painter, &map, ectx, &|c, l| l2c(c, l).0);
 
     // Status chips (render time / caching).
     if app.playback.playing && app.playback.waiting {
@@ -2085,844 +1883,39 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
         ui.ctx().data_mut(|d| d.insert_temp(egui::Id::unique("viewer-video-off-chip"), r));
     }
 
-    vt::draw_snap(&ctx, &painter, &map, &ectx);
+    vt::draw_snap(&ctx, &painter, &map, ectx);
     vt::rulers(app, ui, &map, outer, area);
-    vt::bottom_bar(app, ui, bar, zoom, time, &comp);
+    vt::bottom_bar(app, ui, bar, zoom, time, comp);
     if err_h > 0.0 {
         super::expr_bar::draw(app, ui, err_bar, cid);
     }
 }
-
-/// The position change per comp pixel of drag (x, y) that moves a layer by `dir` when the
-/// pointer covers the axis' on-screen vector `s` (comp px); drag across the axis is ignored.
-fn axis_drag(dir: [f64; 3], s: [f64; 2]) -> ([f64; 3], [f64; 3]) {
-    let n = (s[0] * s[0] + s[1] * s[1]).max(1e-12);
-    (dir.map(|v| v * s[0] / n), dir.map(|v| v * s[1] / n))
-}
-
-/// The gizmo arrow under screen point `p`.
-fn axis_at(hits: &[(LayerId, [Pos2; 2], [f64; 3], [f64; 3])], p: Pos2) -> Option<(LayerId, [Pos2; 2], [f64; 3], [f64; 3])> {
-    let dist = |[a, b]: [Pos2; 2]| {
-        let ab = b - a;
-        let t = ((p - a).dot(ab) / ab.length_sq().max(1e-6)).clamp(0.0, 1.0);
-        p.distance(a + ab * t)
-    };
-    hits.iter().filter(|h| dist(h.1) < 6.0).min_by(|a, b| dist(a.1).total_cmp(&dist(b.1))).copied()
-}
-
-/// World to parent space for a 3D layer (identity without a parent).
-fn parent_world_inverse(ctx: &EvalCtx, l: &Layer) -> effectcraft_engine::geom::Mat4 {
-    match l.parent.and_then(|p| ctx.comp.layer(p)) {
-        Some(p) => ctx.world_matrix(p).inverse().unwrap_or_default(),
-        None => effectcraft_engine::geom::Mat4::IDENTITY,
-    }
-}
-
-/// Parent-space position change per comp pixel of drag (x and y) for a layer: 2D layers map
-/// through the parent transform; 3D layers move in the view plane at their depth.
-fn drag_axes(ctx: &EvalCtx, l: &Layer) -> ([f64; 3], [f64; 3]) {
-    if !l.is_3d() {
-        let inv = parent_inverse(ctx, l);
-        let a = inv.apply_vec(gv2(1.0, 0.0));
-        let b = inv.apply_vec(gv2(0.0, 1.0));
-        return ([a.x, a.y, 0.0], [b.x, b.y, 0.0]);
-    }
-    let cam = cam_state(ctx);
-    let anchor = l.transform().map(|tr| ctx.v3(l, tr, "anchor", [0.0; 3])).unwrap_or([0.0; 3]);
-    let wp = ctx.world_matrix(l).apply(anchor.into());
-    let k = if cam.ortho { 1.0 / cam.zoom.max(1e-9) } else { cam.depth(wp).max(1.0) / cam.zoom.max(1e-9) };
-    let pinv = parent_world_inverse(ctx, l);
-    let a = pinv.apply_vec(cam.right() * k);
-    let b = pinv.apply_vec(cam.down() * k);
-    ([a.x, a.y, a.z], [b.x, b.y, b.z])
-}
-
-/// Wireframes of cameras (frustum, point of interest) and lights (position, direction) as seen
-/// through the current 3D view.
-/// Camera and light wireframes seen through `cam` (`through_active`: `cam` is the active camera,
-/// which is then not drawn). `pane` names the automation ids: `None` for the main view
-/// (`viewer.camera.<id>`), `Some(view)` for a view of a 2- or 4-view layout
-/// (`viewer.view.<view>.camera.<id>`).
-#[allow(clippy::too_many_arguments)]
-fn draw_rigs(
-    app: &mut EffectcraftApp,
-    painter: &egui::Painter,
-    map: &ViewerMap,
-    ectx: &EvalCtx,
-    selected: &[LayerId],
-    cam: CameraState,
-    through_active: bool,
-    pane: Option<&str>,
-) {
-    use effectcraft_engine::geom::Vec3;
-    use effectcraft_engine::project::{LayerSource, LightKind};
-    let (w, h) = (ectx.comp.width as f64, ectx.comp.height as f64);
-    let active = ectx.comp.active_camera(ectx.time).map(|c| c.id);
-    let prefix = pane.map(|v| format!("viewer.view.{v}.")).unwrap_or_else(|| "viewer.".to_string());
-    let proj = |p: Vec3| cam.project(w, h, p).map(|v| map.to_screen([v.x, v.y]));
-    let seg = |a: Vec3, b: Vec3, stroke: Stroke| {
-        if let (Some(x), Some(y)) = (proj(a), proj(b)) {
-            painter.line_segment([x, y], stroke);
-        }
-    };
-    for l in ectx.comp.layers.iter().filter(|l| (l.is_camera() || l.is_light()) && l.is_active_at(ectx.time)) {
-        let sel = selected.contains(&l.id);
-        let col = app.tokens.label(l.label).gamma_multiply(if sel { 1.0 } else { 0.6 });
-        let stroke = Stroke::new(if sel { 1.5 } else { 1.0 }, col);
-        let (eye, fwd, down) = three_d::camera::layer_frame(ectx, l);
-        let poi = |l: &Layer| -> Option<Vec3> {
-            let pr = l.transform()?.get("poi").filter(|_| three_d::camera::is_two_node(l))?;
-            Some(three_d::camera::parent_world(ectx, l).apply(ectx.value(l, pr).as_vec3().into()))
-        };
-        if l.is_camera() {
-            if through_active && Some(l.id) == active {
-                continue;
-            }
-            let zoom = l.props.prop("cameraOptions/zoom").map(|p| ectx.value(l, p).as_f64()).unwrap_or(1000.0);
-            let right = down.cross(fwd);
-            // Frustum to a plane at a quarter of the zoom distance.
-            let k = 0.25;
-            let c = eye + fwd * (zoom * k);
-            let corners = [(-1.0, -1.0), (1.0, -1.0), (1.0, 1.0), (-1.0, 1.0)].map(|(sx, sy)| c + right * (sx * w * 0.5 * k) + down * (sy * h * 0.5 * k));
-            for i in 0..4 {
-                seg(eye, corners[i], stroke);
-                seg(corners[i], corners[(i + 1) % 4], stroke);
-            }
-            if let Some(poi) = poi(l) {
-                seg(eye, poi, Stroke::new(1.0, col.gamma_multiply(0.6)));
-                if let Some(s) = proj(poi) {
-                    painter.circle_stroke(s, 4.0, stroke);
-                }
-            }
-            if let Some(s) = proj(eye) {
-                app.auto.add(&format!("{prefix}camera.{}", l.id.0), Rect::from_center_size(s, vec2(14.0, 14.0)), &l.name);
-            }
-        } else {
-            let LayerSource::Light { kind } = l.source else { continue };
-            if kind == LightKind::Ambient {
-                continue;
-            }
-            let Some(s) = proj(eye) else { continue };
-            painter.circle_stroke(s, 6.0, stroke);
-            for i in 0..8 {
-                let a = i as f32 * std::f32::consts::FRAC_PI_4;
-                let d = vec2(a.cos(), a.sin());
-                painter.line_segment([s + d * 8.0, s + d * 12.0], stroke);
-            }
-            if matches!(kind, LightKind::Spot | LightKind::Parallel) {
-                let target = poi(l).unwrap_or(eye + fwd * 300.0);
-                seg(eye, target, Stroke::new(1.0, col.gamma_multiply(0.7)));
-                if let Some(q) = proj(target) {
-                    painter.circle_stroke(q, 3.0, stroke);
-                }
-            }
-            app.auto.add(&format!("{prefix}light.{}", l.id.0), Rect::from_center_size(s, vec2(16.0, 16.0)), &l.name);
-        }
-    }
-}
-
-/// Pen tool press at `pos`: continue the path in progress (pressing its first vertex closes it),
-/// resume an open path whose last vertex is pressed, add a vertex on a visible path's segment, or
-/// start a new path: a mask on the selected footage/solid layer (or shape layer, with Tool Creates
-/// Mask), a shape path (Shape n group with the Tools bar's Fill and Stroke) on the selected shape
-/// layer, or a new shape layer when nothing is selected. The placed point snaps.
-/// Add a Position keyframe at a motion path's frame, keeping the path where it is.
-fn add_motion_key(app: &mut EffectcraftApp, f: ov::PathFrame) {
-    if let Err(e) = app.session.execute("prop.addKey", json!({"layer": f.layer.0, "prop": f.prop, "time": f.time.seconds()})) {
-        app.ui.status = e.to_string();
-    }
-}
-
-/// Select only the motion path's keyframe `k` (what the vertex tools act on).
-fn select_motion_key(app: &mut EffectcraftApp, k: &ov::KeyHit) -> bool {
-    app.session.execute("keys.select", json!({"keys": [{"layer": k.layer.0, "prop": k.prop, "time": k.time.seconds()}]})).is_ok()
-}
-
-/// The pointer for a Pen slot tool: the tool's own pen, the Pen showing Add Vertex's over a path
-/// it would add a point to (After Effects).
-fn pen_cursor_icon(tool: Tool, over_path: bool) -> crate::icons::Icon {
-    use crate::icons::Icon;
-    match tool {
-        Tool::Pen if over_path => Icon::PenAdd,
-        Tool::PenAdd => Icon::PenAdd,
-        Tool::PenDelete => Icon::PenDelete,
-        Tool::PenConvert => Icon::PenConvert,
-        Tool::MaskFeather => Icon::MaskFeather,
-        _ => Icon::Pen,
-    }
-}
-
-/// Paint pen pointer `icon` with its tip at `at`, outlined for any background.
-fn pen_cursor(ctx: &egui::Context, at: Pos2, icon: crate::icons::Icon) {
-    use crate::icons::Icon;
-    // Where each glyph's tip sits in its 16 × 16 box.
-    let tip = match icon {
-        Icon::PenAdd | Icon::PenDelete | Icon::MaskFeather => vec2(6.0, 2.5),
-        Icon::PenConvert => vec2(8.0, 3.5),
-        _ => vec2(8.0, 1.8),
-    };
-    let painter = ctx.layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::unique("viewer-pen-cursor")));
-    let rect = Rect::from_min_size(at - tip, vec2(16.0, 16.0));
-    for d in [vec2(-1.0, 0.0), vec2(1.0, 0.0), vec2(0.0, -1.0), vec2(0.0, 1.0)] {
-        crate::icons::paint(&painter, rect.translate(d), icon, Color32::BLACK);
-    }
-    crate::icons::paint(&painter, rect, icon, Color32::WHITE);
-}
-
-#[allow(clippy::too_many_arguments)]
-fn pen_press(
-    app: &mut EffectcraftApp,
-    ui: &mut egui::Ui,
-    ectx: &EvalCtx,
-    map: &ViewerMap,
-    paths: &[ov::PathInfo],
-    motion_frame: Option<ov::PathFrame>,
-    pos: Pos2,
-    mods: egui::Modifiers,
-) {
-    use effectcraft_engine::project::LayerSource;
-    let gid = egui::Id::unique("viewer-gesture");
-    let current: Option<(LayerId, u64)> = ui.data(|d| d.get_temp(pen_id()));
-    let c0 = map.to_comp(pos);
-    let corr = vt::snap(app, ui.ctx(), ectx, map, &[], &[c0], mods);
-    let c = [c0[0] + corr[0], c0[1] + corr[1]];
-    if let Some((lid, uid)) = current
-        && let Some(p) = ov::path_of(ectx, lid, uid)
-        && let Some(inv) = p.m.inverse()
-    {
-        let n = p.sp.vertices.len();
-        let first = p.sp.vertices.first().map(|v| {
-            let q = p.m.apply(gv2(v[0], v[1]));
-            map.to_screen([q.x, q.y])
-        });
-        if n >= 2 && first.is_some_and(|f| f.distance(pos) < 8.0) {
-            let _ = app.session.execute("mask.setClosed", json!({"layer": lid.0, "mask": uid, "closed": true}));
-            ui.data_mut(|d| {
-                d.remove::<(LayerId, u64)>(pen_id());
-                d.remove::<Gesture>(gid);
-            });
-            return;
-        }
-        // Shift keeps the new segment at a multiple of 45° from the vertex before it (#1544).
-        let last = p.sp.vertices.last().map(|v| p.m.apply(gv2(v[0], v[1])));
-        let c = match last {
-            Some(q) if mods.shift => constrain_45([q.x, q.y], c),
-            _ => c,
-        };
-        let lp = inv.apply(gv2(c[0], c[1]));
-        let lp = [lp.x, lp.y];
-        if let Ok(v) = app.session.execute("mask.addVertex", json!({"layer": lid.0, "mask": uid, "point": lp})) {
-            let index = v.as_u64().unwrap_or(0) as usize;
-            ui.data_mut(|d| d.insert_temp(gid, Gesture::Pen { layer: lid, mask: uid, index, vertex: lp, inv, press: pos }));
-        }
-        return;
-    }
-    // Clicking the last vertex of an open path (e.g. after Esc ended it) resumes drawing it.
-    if let Some(cur) = ov::open_end_at(paths, map, pos, 8.0) {
-        ui.data_mut(|d| d.insert_temp(pen_id(), cur));
-        return;
-    }
-    // On a visible path's segment the Pen adds a vertex there; on a motion path, a keyframe.
-    if let Some(f) = motion_frame {
-        add_motion_key(app, f);
-        return;
-    }
-    if let Some((l, m, seg, t)) = ov::segment_at(paths, map, pos, 5.0) {
-        let _ = app.session.execute("mask.insertVertex", json!({"layer": l.0, "mask": m, "segment": seg, "t": t}));
-        return;
-    }
-    let target = app
-        .session
-        .state
-        .selected_layers
-        .iter()
-        .copied()
-        .find(|id| ectx.comp.layer(*id).is_some_and(|l| !l.switches.locked && (l.masks().is_some() || matches!(l.source, LayerSource::Shape))));
-    let layer = target.and_then(|id| ectx.comp.layer(id));
-    let (lid, uid, inv) = match layer {
-        Some(l) if !matches!(l.source, LayerSource::Shape) || app.session.state.shape_tool.creates_mask => {
-            let Some(inv) = l2c(ectx, l).0.inverse() else { return };
-            let lp = inv.apply(gv2(c[0], c[1]));
-            let Ok(v) = app.session.execute("mask.new", json!({"layer": l.id.0, "vertices": [[lp.x, lp.y]]})) else { return };
-            let Some(mask) = v["mask"].as_u64() else { return };
-            (l.id, mask, inv)
-        }
-        Some(l) => {
-            let Some(inv) = l2c(ectx, l).0.inverse() else { return };
-            let lp = inv.apply(gv2(c[0], c[1]));
-            let r = app.session.execute("shape.newPath", json!({"layer": l.id.0, "vertices": [[lp.x, lp.y]], "space": "layer"}));
-            let Some(path) = r.ok().and_then(|v| v["path"].as_u64()) else { return };
-            (l.id, path, inv)
-        }
-        None => {
-            // A new shape layer at the comp centre (unrotated: comp → layer is a translation).
-            let r = app.session.execute("shape.newPath", json!({"vertices": [c], "space": "comp"}));
-            let Some(v) = r.ok() else { return };
-            let (Some(l), Some(path)) = (v["layer"].as_u64(), v["path"].as_u64()) else { return };
-            let inv = Mat3::translate(gv2(-(ectx.comp.width as f64) / 2.0, -(ectx.comp.height as f64) / 2.0));
-            (LayerId(l), path, inv)
-        }
-    };
-    let lp = inv.apply(gv2(c[0], c[1]));
-    ui.data_mut(|d| {
-        d.insert_temp(pen_id(), (lid, uid));
-        d.insert_temp(gid, Gesture::Pen { layer: lid, mask: uid, index: 0, vertex: [lp.x, lp.y], inv, press: pos });
-    });
-}
-
-/// `to` moved onto the nearest line through `from` at a multiple of 45° (horizontal, vertical or
-/// diagonal), as far along it as `to` lies: the Pen's Shift-click.
-fn constrain_45(from: [f64; 2], to: [f64; 2]) -> [f64; 2] {
-    let (dx, dy) = (to[0] - from[0], to[1] - from[1]);
-    if !(dx.is_finite() && dy.is_finite()) || (dx == 0.0 && dy == 0.0) {
-        return to;
-    }
-    let step = std::f64::consts::FRAC_PI_4;
-    let a = (dy.atan2(dx) / step).round() * step;
-    let (ux, uy) = (a.cos(), a.sin());
-    let along = dx * ux + dy * uy;
-    [from[0] + ux * along, from[1] + uy * along]
-}
-
-/// Visible, unlocked layers eligible for viewer hit tests, in front-to-back order.
-/// Solo scope matches the renderer: any soloed AV layer activates it at every time (as in After
-/// Effects), even when hidden, locked or outside its in-out range.
-pub(crate) fn selectable_layers(comp: &Comp, time: Tick) -> impl Iterator<Item = &Layer> {
-    let any_solo = comp.layers.iter().any(|l| l.switches.solo && l.source.is_av());
-    comp.layers
-        .iter()
-        .filter(move |l| l.is_active_at(time) && l.switches.video && !l.switches.locked && !l.is_camera() && !l.is_light() && (!any_solo || l.switches.solo))
-}
-
-/// Selectable layers under a comp point, front to back.
-pub(crate) fn layers_at<'a, 'b>(ectx: &'b EvalCtx<'a>, cpt: [f64; 2]) -> impl Iterator<Item = &'a Layer> + 'b {
-    selectable_layers(ectx.comp, ectx.time).filter(move |l| layer_quad(ectx, l).is_some_and(|(_, q, _)| point_in_quad(cpt, &q)))
-}
-
-/// Topmost selectable layer under a comp point.
-pub(crate) fn layer_at<'a>(ectx: &EvalCtx<'a>, cpt: [f64; 2]) -> Option<&'a Layer> {
-    layers_at(ectx, cpt).next()
-}
-
-/// The layer a press at a comp point acts on, selected (Shift toggles the topmost layer). As in
-/// After Effects, a selected layer under the point comes before the layers in front of it, so it
-/// can be dragged where they cover it; otherwise the topmost layer (#230).
-pub(crate) fn pick(app: &mut EffectcraftApp, ectx: &EvalCtx, cpt: [f64; 2], toggle: bool) -> Option<LayerId> {
-    if toggle {
-        let hit = layer_at(ectx, cpt)?.id;
-        let _ = app.session.execute("layer.select", json!({"layers": [hit.0], "toggle": true}));
-        return Some(hit);
-    }
-    let selected = &app.session.state.selected_layers;
-    let hits: Vec<LayerId> = layers_at(ectx, cpt).map(|l| l.id).collect();
-    let hit = *hits.iter().find(|id| selected.contains(id)).or(hits.first())?;
-    if !selected.contains(&hit) {
-        let _ = app.session.execute("layer.select", json!({"layers": [hit.0]}));
-    }
-    Some(hit)
-}
-
-/// Where a shape drag is going to land: a mask on the selected layer, a group inside it, or a new
-/// shape layer.
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum ShapeTarget {
-    Mask,
-    IntoLayer,
-    NewLayer,
-}
-
-impl ShapeTarget {
-    /// What the drag will make and where, named the way the ghost captions it.
-    fn label(self, layer_name: &str) -> String {
-        match self {
-            ShapeTarget::Mask => format!("Mask on “{layer_name}”"),
-            ShapeTarget::IntoLayer => format!("Into “{layer_name}”"),
-            ShapeTarget::NewLayer => "New shape layer".to_string(),
-        }
-    }
-}
-
-/// A shape drag as it stands, after the Tools' normalisations: the path it will make and where it
-/// will land.
-struct ShapeDrag {
-    /// The `shape.newShape` / `layer.addMask` kind for the tool.
-    kind: &'static str,
-    /// Comp-space centre and size, what the drag will make.
-    centre: [f64; 2],
-    size: [f64; 2],
-    target: ShapeTarget,
-    /// The selected layer's name and the index its next mask would take, for the ghost's caption
-    /// and colour.
-    layer_name: String,
-    mask_index: usize,
-}
-
-/// The kind `tool` draws, as `shape.newShape` / `layer.addMask` name it.
-fn shape_kind(tool: Tool) -> &'static str {
-    match tool {
-        Tool::Rectangle => "rect",
-        Tool::RoundedRect => "rounded",
-        Tool::Ellipse => "ellipse",
-        Tool::Polygon => "polygon",
-        _ => "star",
-    }
-}
-
-/// What a shape tool drag from `start` to `end` makes, or `None` while it is too small to make
-/// anything. Alt (Option) draws from the press point and Shift squares the box; the live ghost and
-/// [`create_shape`] both go through this, so the drag always shows what it will commit.
-fn shape_drag(app: &EffectcraftApp, tool: Tool, start: [f64; 2], end: [f64; 2], mods: egui::Modifiers) -> Option<ShapeDrag> {
-    let comp = app.session.active_comp()?;
-    let selected = app.session.state.selected_layers.first().copied();
-    let sel = selected.and_then(|id| comp.layer(id));
-    // A footage, solid or other non-shape layer selected, or a shape layer with Tool Creates
-    // Mask: a mask on that layer. Otherwise the engine's own target: the first selected unlocked
-    // shape layer, else a new one.
-    let target = match sel {
-        Some(l) if l.source.is_av() && (app.session.state.shape_tool.creates_mask || !matches!(l.source, LayerSource::Shape)) => (ShapeTarget::Mask, Some(l)),
-        _ => match effectcraft_engine::commands::shape_tool::selected_shape_target(&app.session, comp).and_then(|id| comp.layer(id)) {
-            Some(l) => (ShapeTarget::IntoLayer, Some(l)),
-            None => (ShapeTarget::NewLayer, None),
-        },
-    };
-    let (target, layer) = target;
-    let mask_index = if target == ShapeTarget::Mask { layer.and_then(|l| l.masks()).map_or(0, |m| m.groups().count()) } else { 0 };
-    let (mut w, mut h) = ((end[0] - start[0]).abs(), (end[1] - start[1]).abs());
-    // Ctrl/Cmd draws from the press point as the centre, as in After Effects.
-    if mods.command {
-        w *= 2.0;
-        h *= 2.0;
-    }
-    if w < 2.0 && h < 2.0 {
-        return None;
-    }
-    if mods.shift {
-        let m = w.max(h);
-        w = m;
-        h = m;
-    }
-    Some(ShapeDrag {
-        kind: shape_kind(tool),
-        centre: if mods.command { start } else { [start[0].min(end[0]) + w / 2.0, start[1].min(end[1]) + h / 2.0] },
-        size: [w, h],
-        target,
-        layer_name: layer.map_or_else(String::new, |l| l.name.clone()),
-        mask_index,
-    })
-}
-
-/// The Tools bar's paint colour as bytes, dimmed by `alpha` so the comp shows through the ghost.
-fn paint_rgb(c: [f32; 3], opacity: f64, alpha: f32) -> Color32 {
-    let f = |k: f32| (k.clamp(0.0, 1.0) * 255.0).round() as u8;
-    Color32::from_rgb(f(c[0]), f(c[1]), f(c[2])).gamma_multiply((opacity.clamp(0.0, 100.0) / 100.0) as f32 * alpha)
-}
-
-/// Draw a shape drag as it will land: the tool's own path, filled with the Tools bar's Fill and
-/// outlined in its Stroke (or the mask colour, for a mask), captioned with where it goes.
-fn draw_shape_ghost(painter: &egui::Painter, map: &ViewerMap, app: &EffectcraftApp, d: &ShapeDrag, t: &Tokens) {
-    // The engine's own geometry for the kind, so the ghost is the shape and not a stand-in for it.
-    let Some(sp) = effectcraft_engine::commands::shape_tool::mask_path(d.kind, d.centre, d.size) else { return };
-    let mut pts = ov::flatten(&sp, &Mat3::IDENTITY, map);
-    if pts.first() == pts.last() {
-        pts.pop();
-    }
-    if pts.len() < 3 {
-        return;
-    }
-    let tool = &app.session.state.shape_tool;
-    let (fill, line) = match d.target {
-        ShapeTarget::Mask => {
-            let [r, g, b] = effectcraft_engine::prefs::mask_color(app.session.prefs.appearance.cycle_mask_colors, d.mask_index);
-            (Color32::from_rgb(r, g, b).gamma_multiply(0.25), Color32::from_rgb(r, g, b))
-        }
-        _ => {
-            let stroke_on = tool.stroke.kind != PaintKind::None && tool.stroke_width > 0.0;
-            (
-                if tool.fill.kind == PaintKind::None { Color32::TRANSPARENT } else { paint_rgb(tool.fill.color, tool.fill.opacity, 0.45) },
-                if stroke_on { paint_rgb(tool.stroke.color, tool.stroke.opacity, 1.0) } else { t.accent },
-            )
-        }
-    };
-    let Some(bounds) = bounds_of(&pts) else { return };
-    // A screen-width outline reads at every zoom, where a comp-pixel hairline does not.
-    painter.add(egui::Shape::Path(egui::epaint::PathShape { points: pts, closed: true, fill, stroke: Stroke::new(1.5, line).into() }));
-    // Caption it with where the shape lands: a mask, a group in the selected shape layer or a
-    // new layer.
-    let font = Tokens::ui(11.0);
-    let galley = painter.layout_no_wrap(d.target.label(&d.layer_name), font, line);
-    let caption = Rect::from_min_size(pos2(bounds.left(), bounds.top() - 5.0 - galley.size().y), galley.size());
-    painter.rect_filled(caption.expand(3.0), 2.0, Color32::from_black_alpha(150));
-    painter.galley(caption.min, galley, line);
-}
-
-/// The bounds of points on screen, or `None` for an empty set.
-fn bounds_of(pts: &[Pos2]) -> Option<Rect> {
-    let first = *pts.first()?;
-    let mut r = Rect::from_min_max(first, first);
-    for p in pts.iter().skip(1) {
-        r.extend_with(*p);
-    }
-    Some(r)
-}
-
-fn create_shape(app: &mut EffectcraftApp, tool: Tool, a: [f64; 2], b: [f64; 2], mods: egui::Modifiers) {
-    let Some(d) = shape_drag(app, tool, a, b, mods) else { return };
-    let (kind, (w, h), (cx, cy)) = (d.kind, (d.size[0], d.size[1]), (d.centre[0], d.centre[1]));
-    // A mask on the selected layer, as the ghost showed.
-    if d.target == ShapeTarget::Mask {
-        // In layer space: invert the layer transform.
-        let sel_layer = app.session.state.selected_layers.first().copied().and_then(|id| app.session.active_comp().and_then(|c| c.layer(id)).cloned());
-        if let Some(l) = sel_layer
-            && let Some(comp) = app.session.active_comp_arc()
-        {
-            let ectx = EvalCtx {
-                project: &app.session.project,
-                comp_id: app.session.active_comp_id().unwrap_or_default(),
-                comp: &comp,
-                time: app.session.time(),
-                expr: None,
-                footage: None,
-            };
-            let inv = l2c(&ectx, &l).0.inverse().unwrap_or(Mat3::IDENTITY);
-            let p0 = inv.apply(gv2(cx - w / 2.0, cy - h / 2.0));
-            let p1 = inv.apply(gv2(cx + w / 2.0, cy + h / 2.0));
-            let rect = [p0.x.min(p1.x), p0.y.min(p1.y), (p1.x - p0.x).abs(), (p1.y - p0.y).abs()];
-            if let Err(e) = app.session.execute("layer.addMask", json!({"layer": l.id.0, "shape": kind, "rect": rect})) {
-                app.ui.status = e.to_string();
-            }
-        }
-        return;
-    }
-    // Into the selected shape layer's Contents as a new group (as in After Effects), else a new
-    // shape layer; painted with the Tools bar's Fill and Stroke.
-    if let Err(e) = app.session.execute("shape.newShape", json!({"kind": kind, "size": [w, h], "position": [cx, cy]})) {
-        app.ui.status = e.to_string();
-    }
-}
-
-fn empty_state(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
-    let t = app.tokens;
-    let p = ui.painter().clone();
-    p.rect_filled(rect, 0.0, t.pasteboard);
-    let c = rect.center();
-    p.text(c - vec2(0.0, 40.0), Align2::CENTER_CENTER, crate::i18n::tr("Composition"), Tokens::semibold(16.0), t.text);
-    let b1 = Rect::from_center_size(c + vec2(0.0, 0.0), vec2(220.0, 30.0));
-    if widgets::text_button(ui, b1, "New Composition", true, &t, egui::Id::unique("empty-newcomp")).clicked() {
-        crate::panels::dialogs::open_new_comp(app);
-    }
-    app.auto.add("viewer.empty.newComp", b1, "New Composition");
-    let b2 = Rect::from_center_size(c + vec2(0.0, 40.0), vec2(220.0, 30.0));
-    if widgets::text_button(ui, b2, "New Composition From Footage", false, &t, egui::Id::unique("empty-fromfootage")).clicked() {
-        let _ = crate::menus::invoke(app, &ui.ctx().clone(), "file.import", json!({}));
-    }
-    app.auto.add("viewer.empty.import", b2, "New Composition From Footage");
-    // A Project item dropped on the empty viewer creates the first composition,
-    // just like dropping it onto an empty Timeline (#684). Multiple selected
-    // items use the existing New Comp from Selection dialog.
-    let ctx = ui.ctx().clone();
-    if let Some(crate::panels::DragPayload::Item(dragged)) = egui::DragAndDrop::payload::<crate::panels::DragPayload>(&ctx).as_deref()
-        && ui.rect_contains_pointer(rect)
-    {
-        let items: Vec<effectcraft_engine::project::ItemId> = crate::panels::project_drop_items(app, *dragged)
-            .into_iter()
-            .map(effectcraft_engine::project::ItemId)
-            .filter(|id| {
-                app.session.project.item(*id).is_some_and(|item| match &item.kind {
-                    effectcraft_engine::project::ItemKind::Footage(f) => f.kind != effectcraft_engine::project::FootageKind::Data,
-                    effectcraft_engine::project::ItemKind::Solid(_) | effectcraft_engine::project::ItemKind::Comp(_) => true,
-                    _ => false,
-                })
-            })
-            .collect();
-        if !items.is_empty() {
-            p.rect_stroke(rect.shrink(2.0), 0.0, Stroke::new(2.0, t.accent), StrokeKind::Inside);
-            app.auto.add("viewer.newCompDrop", rect, "Drop footage to create a composition");
-            if ctx.input(|i| i.pointer.any_released()) {
-                app.session.state.project_selection = items;
-                if let Err(e) = crate::menus::invoke(app, &ctx, "file.newCompFromSelection", json!({})) {
-                    app.ui.status = e;
-                }
-                egui::DragAndDrop::clear_payload(&ctx);
-            }
-        }
-    }
-}
-
-/// `#rrggbb` → sRGB bytes.
-/// A grid or guide line in the Grids & Guides style: `lines`, `dashed` or `dots`.
-pub(crate) fn styled_line(painter: &egui::Painter, pts: [Pos2; 2], stroke: Stroke, style: &str) {
-    match style {
-        "dashed" => {
-            painter.add(egui::Shape::dashed_line(&pts, stroke, 6.0, 4.0));
-        }
-        "dots" => {
-            painter.add(egui::Shape::dotted_line(&pts, stroke.color, 4.0, stroke.width.max(1.0) * 0.75));
-        }
-        _ => {
-            painter.line_segment(pts, stroke);
-        }
-    }
-}
-
-/// `p` (points) moved to the nearest physical pixel corner at `ppp` pixels per point.
-pub(crate) fn snap_to_pixels(p: Pos2, ppp: f32) -> Pos2 {
-    if !(ppp.is_finite() && ppp > 0.0 && p.x.is_finite() && p.y.is_finite()) {
-        return p;
-    }
-    pos2((p.x * ppp).round() / ppp, (p.y * ppp).round() / ppp)
-}
-
-/// Texture filtering for Viewer Zoom Quality: More Accurate = bilinear, Faster = nearest. As in
-/// After Effects, a magnified frame (above 100 %, or a lower Resolution) always shows its pixels
-/// as blocks, never smoothed, in either mode (#882).
-pub(crate) fn zoom_texture_options(smooth: bool) -> egui::TextureOptions {
-    if smooth { egui::TextureOptions { magnification: egui::TextureFilter::Nearest, ..egui::TextureOptions::LINEAR } } else { egui::TextureOptions::NEAREST }
-}
-
-/// The sampler GPU frames (mipmapped display textures) are drawn with: More Accurate filters
-/// bilinearly within and between mip levels, so a frame shown below 100 % is averaged instead of
-/// skipping pixels (#417); Faster takes the nearest pixel of the full-size frame. Magnified, both
-/// show the nearest pixel (#882).
-pub(crate) fn zoom_sampler(smooth: bool) -> eframe::wgpu::SamplerDescriptor<'static> {
-    use eframe::wgpu::{FilterMode, MipmapFilterMode, SamplerDescriptor};
-    let label = Some("viewer frame");
-    if smooth {
-        SamplerDescriptor {
-            label,
-            mag_filter: FilterMode::Nearest,
-            min_filter: FilterMode::Linear,
-            mipmap_filter: MipmapFilterMode::Linear,
-            ..Default::default()
-        }
-    } else {
-        SamplerDescriptor { label, lod_max_clamp: 0.0, ..Default::default() }
-    }
-}
-
-/// The whole factor a CPU frame is averaged down by for its texture when `pixels` of it are drawn
-/// over `screen` screen pixels: about one texel per screen pixel, so bilinear filtering never
-/// skips frame pixels — the CPU frames' counterpart of the GPU frames' mip levels (#417). Faster
-/// keeps every pixel.
-pub(crate) fn minify_factor(smooth: bool, pixels: f64, screen: f64) -> usize {
-    let k = (pixels / screen + 1e-3).floor();
-    if smooth && k >= 1.0 { k.min(256.0) as usize } else { 1 }
-}
-
 pub(crate) use crate::widgets::hex_rgb;
 
-/// The Extended Viewer's render region for this frame (see [`ViewerState::extended`]):
-/// Settings ▸ 3D ▸ Extended Viewer on, the comp has 3D layers and the view is a custom 3D view
-/// (or Draft 3D is on), and part of the visible viewer lies outside the comp frame.
-///
-/// [`ViewerState::extended`]: crate::state::ViewerState::extended
-pub(crate) fn extended_region(
-    app: &EffectcraftApp,
-    comp: &effectcraft_engine::project::Comp,
-    cid: effectcraft_engine::project::ItemId,
-    map: ViewerMap,
-) -> Option<[f64; 4]> {
-    if !app.session.prefs.three_d.extended_viewer || !comp.has_3d() || app.session.state.region_of_interest.is_some() {
-        return None;
-    }
-    let view = app.session.state.views3d.get(&cid).map(|v| v.current).unwrap_or_default();
-    if view == View3D::ActiveCamera && !comp.draft_3d {
-        return None;
-    }
-    let a = map.to_comp(map.area.min);
-    let b = map.to_comp(map.area.max);
-    effectcraft_engine::render::extended_region(comp.width, comp.height, [a[0], a[1], b[0], b[1]], 1.0)
-}
+mod frame;
+mod geometry;
+mod gesture;
+mod shapes;
+mod tools;
+mod view;
 
-fn rect_of(map: &ViewerMap, r: Option<[f64; 4]>) -> Rect {
-    let [x, y, w, h] = r.unwrap_or_default();
-    Rect::from_min_max(map.to_screen([x, y]), map.to_screen([x + w, y + h]))
-}
-
-/// Put a rendered frame on screen: CPU pixels go into an egui texture, averaged down by `minify`
-/// (see [`minify_factor`]); GPU frames are drawn straight from their wgpu texture (registered with
-/// egui-wgpu, no readback).
-fn show_frame(app: &mut EffectcraftApp, ctx: &egui::Context, key: crate::frames::FrameKey, img: crate::frames::FrameImage, minify: usize) {
-    use crate::frames::FrameImage;
-    // Settings ▸ Previews ▸ Viewer Zoom Quality.
-    let smooth = app.session.prefs.viewer_zoom_smooth();
-    let opts = zoom_texture_options(smooth);
-    match img {
-        FrameImage::Cpu(img) => {
-            // Frames wider or taller than the GPU's texture limit go up averaged down too (#201).
-            let max = crate::frames::max_texture_side(ctx);
-            let fitted = crate::frames::fit_shared_texture_by(&img, max, minify);
-            match &mut app.viewer_tex {
-                Some((tex, k, m)) if tex.size() == fitted.size() => {
-                    tex.set(fitted, opts);
-                    (*k, *m) = (key, minify);
-                }
-                _ => app.viewer_tex = Some((ctx.load_texture("viewer-frame", fitted, opts), key, minify)),
-            }
-            app.viewer_shown = app.viewer_tex.as_ref().map(|(t, k, _)| (t.id(), *k));
-            app.viewer_image = Some(img);
-            vt::set_texture_roi(ctx, app.session.state.region_of_interest.or(app.ui.viewer.extended));
-        }
-        FrameImage::Gpu(f) => {
-            let Some(rs) = &app.wgpu else { return };
-            let view = f.texture.create_view(&Default::default());
-            let mut ren = rs.renderer.write();
-            let id = match &app.viewer_native {
-                Some((id, _, _)) => {
-                    ren.update_egui_texture_from_wgpu_texture_with_sampler_options(&rs.device, &view, zoom_sampler(smooth), *id);
-                    *id
-                }
-                None => ren.register_native_texture_with_sampler_options(&rs.device, &view, zoom_sampler(smooth)),
-            };
-            drop(ren);
-            app.viewer_native = Some((id, key, f));
-            app.viewer_shown = Some((id, key));
-            // Pixels are read back on demand (viewer_pixels).
-            app.viewer_image = None;
-        }
-    }
-}
+use frame::{empty_state, rect_of, show_frame};
+pub(crate) use frame::{extended_region, minify_factor, snap_to_pixels, styled_line, zoom_sampler, zoom_texture_options};
+#[cfg(test)]
+use geometry::{box_corners, project_clipped};
+use geometry::{
+    cam_state, drag_ratio, handle_axes, handle_cursor, handle_point, one_axis, project_segment, quad_intersects_box, rotate_value, selected_others,
+    snap_handle, turn_delta,
+};
+pub(crate) use geometry::{from_effect_space, fx2c, l2c, layer_outline, layer_quad};
+use gesture::{Gesture, HANDLE, ROTO_HINT, pen_id, roi_drag, roi_handles, vertex_grab_radius};
+use shapes::{create_shape, draw_shape_ghost, shape_drag};
+pub(crate) use shapes::{layer_at, layer_at_including_locked, layers_at, pick, selectable_layers};
+#[cfg(test)]
+use tools::constrain_45;
+use tools::{add_motion_key, axis_at, axis_drag, drag_axes, draw_rigs, parent_world_inverse, pen_cursor, pen_cursor_icon, pen_press, select_motion_key};
+pub(crate) use view::checker;
+use view::{aux_views, locked_pane};
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use effectcraft_engine::geom::{Mat4, vec3};
-
-    /// #1544: Shift-clicking with the Pen keeps the new segment horizontal, vertical or diagonal.
-    #[test]
-    fn pen_shift_click_keeps_the_segment_at_45_degrees() {
-        let near = |a: [f64; 2], b: [f64; 2]| (a[0] - b[0]).abs() < 1e-9 && (a[1] - b[1]).abs() < 1e-9;
-        let from = [100.0, 100.0];
-        assert!(near(constrain_45(from, [104.0, 180.0]), [100.0, 180.0]), "straight down");
-        assert!(near(constrain_45(from, [30.0, 97.0]), [30.0, 100.0]), "left");
-        assert!(near(constrain_45(from, [150.0, 46.0]), [152.0, 48.0]), "up and right, on the diagonal");
-        assert!(near(constrain_45(from, from), from), "on the vertex");
-        assert!(constrain_45(from, [f64::NAN, 3.0])[0].is_nan(), "a non-finite point stays as it is");
-    }
-
-    /// The Rotation tool counts past a full turn in both directions, as in After Effects: the
-    /// pointer going round the anchor 1.5 turns clockwise gives 540°, then back 2 turns gives
-    /// −180°, with no jump where atan2 wraps from 180° to −180°.
-    #[test]
-    fn rotate_tool_accumulates_revolutions() {
-        // Screen y points down, so a growing atan2 angle is clockwise on screen.
-        let drag = |start: f64, steps: &[f64]| {
-            let (mut last, mut turned, mut out) = (start, 0.0, vec![]);
-            for &a in steps {
-                // atan2's range: (−180°, 180°].
-                let a = (a + 180.0).rem_euclid(360.0) - 180.0;
-                turned += turn_delta(last, a);
-                last = a;
-                out.push(turned);
-            }
-            (last, turned, out)
-        };
-        let cw: Vec<f64> = (1..=54).map(|i| i as f64 * 10.0).collect();
-        let (last, turned, seq) = drag(0.0, &cw);
-        assert!((turned - 540.0).abs() < 1e-9, "{turned}");
-        assert!(seq.windows(2).all(|w| (w[1] - w[0] - 10.0).abs() < 1e-9), "no jump: {seq:?}");
-        assert!((rotate_value(0.0, turned, false) - 540.0).abs() < 1e-9);
-        let ccw: Vec<f64> = (1..=72).map(|i| 540.0 - i as f64 * 10.0).collect();
-        let (_, back, seq) = drag(last, &ccw);
-        assert!(seq.windows(2).all(|w| (w[1] - w[0] + 10.0).abs() < 1e-9), "no jump: {seq:?}");
-        let total = turned + back;
-        assert!((total + 180.0).abs() < 1e-9, "{total}");
-        assert!((rotate_value(30.0, total, false) + 150.0).abs() < 1e-9);
-        // Shift snaps the accumulated value, not a wrapped one.
-        assert_eq!(rotate_value(0.0, 400.0, true), 405.0);
-        assert_eq!(rotate_value(0.0, -400.0, true), -405.0);
-        // Across the seam: 170° → −170° is +20°, and back is −20°; exactly half a turn is +180°.
-        assert!((turn_delta(170.0, -170.0) - 20.0).abs() < 1e-9);
-        assert!((turn_delta(-170.0, 170.0) + 20.0).abs() < 1e-9);
-        assert_eq!(turn_delta(0.0, 180.0), 180.0);
-        assert_eq!(turn_delta(0.0, -180.0), 180.0);
-        // Never crash or poison the value on non-finite input.
-        assert_eq!(turn_delta(f64::NAN, 10.0), 0.0);
-        assert_eq!(turn_delta(0.0, f64::INFINITY), 0.0);
-        assert_eq!(rotate_value(15.0, f64::NAN, false), 15.0);
-    }
-
-    /// #1042: a path vertex lying under, or just beside, a bounding-box handle is grabbed
-    /// instead of the handle; away from every handle the reach is unchanged.
-    #[test]
-    fn vertex_reaches_as_far_as_a_box_handle_over_it() {
-        let handle = pos2(100.0, 100.0);
-        let vertex = pos2(100.0, 100.0);
-        // The press lands 8 points off the vertex, still on the handle's square.
-        let press = pos2(108.0, 100.0);
-        let pick = |p: Pos2, handles: &[Pos2]| vertex.distance(p) < vertex_grab_radius(p, handles.iter().copied());
-        assert!(handle.distance(press) < HANDLE + 2.0, "the handle would take this press");
-        assert!(pick(press, &[handle]), "the vertex wins over the handle");
-        assert!(!pick(press, &[]), "no handle there: the usual reach");
-        assert!(pick(pos2(105.0, 100.0), &[]));
-        assert!(!pick(pos2(120.0, 100.0), &[handle]), "past the handle: nothing");
-    }
-
-    /// #882: the frame's corner sits on a physical pixel at any display scaling, so 100 % maps
-    /// comp pixels 1:1 onto screen pixels.
-    #[test]
-    fn frame_origin_snaps_to_physical_pixels() {
-        for ppp in [1.0f32, 1.25, 1.5, 1.75, 2.0] {
-            for p in [pos2(-201.12, 72.4), pos2(689.8, 239.75), pos2(0.3, -0.37)] {
-                let s = snap_to_pixels(p, ppp);
-                for v in [s.x * ppp, s.y * ppp] {
-                    assert!((v - v.round()).abs() < 1e-3, "ppp {ppp}: {p:?} → {s:?}");
-                }
-                assert!((s - p).length() <= 0.71 / ppp, "moved by at most half a pixel: {p:?} → {s:?}");
-            }
-        }
-        assert_eq!(snap_to_pixels(pos2(1.3, 2.0), 0.0), pos2(1.3, 2.0));
-    }
-
-    /// #882: a magnified frame shows its pixels as blocks in both Zoom Quality modes; More
-    /// Accurate only smooths when the frame is shown smaller.
-    #[test]
-    fn magnified_frames_are_never_smoothed() {
-        use eframe::wgpu::FilterMode;
-        for smooth in [true, false] {
-            assert_eq!(zoom_texture_options(smooth).magnification, egui::TextureFilter::Nearest);
-            assert_eq!(zoom_sampler(smooth).mag_filter, FilterMode::Nearest);
-        }
-        assert_eq!(zoom_texture_options(true).minification, egui::TextureFilter::Linear);
-        assert_eq!(zoom_sampler(true).min_filter, FilterMode::Linear);
-    }
-
-    /// A perspective-like homography: w = 100 + y (the plane crosses the camera at y = −100).
-    fn tilted() -> Mat3 {
-        Mat3([[100.0, 0.0, 0.0], [0.0, 100.0, 0.0], [0.0, 1.0, 100.0]])
-    }
-
-    /// #572: a box reaching behind the camera is clipped at the near plane instead of flipping
-    /// through infinity into long lines.
-    #[test]
-    fn outlines_clip_at_the_near_plane() {
-        let m = tilted();
-        let front = project_clipped(&m, &box_corners([-50.0, -50.0, 50.0, 50.0]));
-        assert_eq!(front.len(), 4);
-        let crossing = project_clipped(&m, &box_corners([-50.0, -150.0, 50.0, 50.0]));
-        assert_eq!(crossing.len(), 4, "{crossing:?}");
-        // Nothing flipped through infinity: a corner behind the camera (y = −150, w = −50) would
-        // land at y = +300 if it were projected as is; clipped at the near plane it runs off far
-        // above (negative y) instead, and the front corners stay where they were.
-        assert!(crossing.iter().all(|p| p[0].is_finite() && p[1].is_finite() && p[1] < 34.0), "{crossing:?}");
-        assert!(project_clipped(&m, &box_corners([-50.0, -400.0, 50.0, -200.0])).is_empty(), "wholly behind");
-    }
-
-    #[test]
-    fn axis_drag_follows_the_arrow_and_ignores_drag_across_it() {
-        let (ax, ay) = axis_drag([0.0, 0.0, 60.0], [24.0, -24.0]);
-        let at = |d: [f64; 2]| [0, 1, 2].map(|i| ax[i] * d[0] + ay[i] * d[1]);
-        assert_eq!(at([24.0, -24.0]), [0.0, 0.0, 60.0]);
-        assert_eq!(at([-12.0, 12.0]), [0.0, 0.0, -30.0]);
-        assert_eq!(at([10.0, 10.0]), [0.0, 0.0, 0.0]);
-    }
-
-    #[test]
-    fn gizmo_segments_clip_at_the_near_plane() {
-        // w = 100 + z.
-        let pc = Mat4([[100.0, 0.0, 0.0, 0.0], [0.0, 100.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 1.0, 100.0]]);
-        let s = project_segment(&pc, vec3(10.0, 0.0, 0.0), vec3(10.0, 0.0, -300.0)).unwrap();
-        assert_eq!(s[0], [10.0, 0.0]);
-        assert!(s[1][0] > 10.0 && s[1][0].is_finite(), "toward the camera it grows, never flips: {s:?}");
-        assert!(project_segment(&pc, vec3(0.0, 0.0, -200.0), vec3(0.0, 0.0, -300.0)).is_none());
-    }
-}
+mod tests;
diff --git a/crates/ui-egui/src/panels/viewer/frame.rs b/crates/ui-egui/src/panels/viewer/frame.rs
new file mode 100644
index 000000000..e0d2a3bc8
--- /dev/null
+++ b/crates/ui-egui/src/panels/viewer/frame.rs
@@ -0,0 +1,183 @@
+use super::{Align2, EffectcraftApp, Pos2, Rect, Stroke, StrokeKind, Tokens, View3D, ViewerMap, json, pos2, vec2, vt, widgets};
+
+/// Draw the no-composition viewer with New Composition and New Composition From Footage buttons, accepting Project
+/// items dropped on it to create the first composition.
+pub(super) fn empty_state(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    let t = app.tokens;
+    let p = ui.painter().clone();
+    p.rect_filled(rect, 0.0, t.pasteboard);
+    let c = rect.center();
+    p.text(c - vec2(0.0, 40.0), Align2::CENTER_CENTER, crate::i18n::tr("Composition"), Tokens::semibold(16.0), t.text);
+    let b1 = Rect::from_center_size(c + vec2(0.0, 0.0), vec2(220.0, 30.0));
+    if widgets::text_button(ui, b1, crate::i18n::tr("New Composition"), true, &t, egui::Id::unique("empty-newcomp")).clicked() {
+        crate::panels::dialogs::open_new_comp(app);
+    }
+    app.auto.add("viewer.empty.newComp", b1, "New Composition");
+    let b2 = Rect::from_center_size(c + vec2(0.0, 40.0), vec2(220.0, 30.0));
+    if widgets::text_button(ui, b2, crate::i18n::tr("New Composition From Footage"), false, &t, egui::Id::unique("empty-fromfootage")).clicked() {
+        let _ = crate::menus::invoke(app, &ui.ctx().clone(), "file.import", json!({"newComp": true}));
+    }
+    app.auto.add("viewer.empty.import", b2, "New Composition From Footage");
+    // A Project item dropped on the empty viewer creates the first composition,
+    // just like dropping it onto an empty Timeline (#684). Multiple selected
+    // items use the existing New Comp from Selection dialog.
+    let ctx = ui.ctx().clone();
+    if let Some(crate::panels::DragPayload::Item(dragged)) = egui::DragAndDrop::payload::<crate::panels::DragPayload>(&ctx).as_deref()
+        && ui.rect_contains_pointer(rect)
+    {
+        let items: Vec<effectcraft_engine::project::ItemId> = crate::panels::project_drop_items(app, *dragged, None)
+            .into_iter()
+            .map(effectcraft_engine::project::ItemId)
+            .filter(|id| {
+                app.session.project.item(*id).is_some_and(|item| match &item.kind {
+                    effectcraft_engine::project::ItemKind::Footage(f) => f.kind != effectcraft_engine::project::FootageKind::Data,
+                    effectcraft_engine::project::ItemKind::Solid(_) | effectcraft_engine::project::ItemKind::Comp(_) => true,
+                    _ => false,
+                })
+            })
+            .collect();
+        if !items.is_empty() {
+            p.rect_stroke(rect.shrink(2.0), 0.0, Stroke::new(2.0, t.accent), StrokeKind::Inside);
+            app.auto.add("viewer.newCompDrop", rect, "Drop footage to create a composition");
+            if ctx.input(|i| i.pointer.any_released()) {
+                app.session.state.project_selection = items;
+                if let Err(e) = crate::menus::invoke(app, &ctx, "file.newCompFromSelection", json!({})) {
+                    app.ui.status = e;
+                }
+                egui::DragAndDrop::clear_payload(&ctx);
+            }
+        }
+    }
+}
+
+/// `#rrggbb` → sRGB bytes.
+/// A grid or guide line in the Grids & Guides style: `lines`, `dashed` or `dots`.
+pub(crate) fn styled_line(painter: &egui::Painter, pts: [Pos2; 2], stroke: Stroke, style: &str) {
+    match style {
+        "dashed" => {
+            painter.add(egui::Shape::dashed_line(&pts, stroke, 6.0, 4.0));
+        }
+        "dots" => {
+            painter.add(egui::Shape::dotted_line(&pts, stroke.color, 4.0, stroke.width.max(1.0) * 0.75));
+        }
+        _ => {
+            painter.line_segment(pts, stroke);
+        }
+    }
+}
+
+/// `p` (points) moved to the nearest physical pixel corner at `ppp` pixels per point.
+pub(crate) fn snap_to_pixels(p: Pos2, ppp: f32) -> Pos2 {
+    if !(ppp.is_finite() && ppp > 0.0 && p.x.is_finite() && p.y.is_finite()) {
+        return p;
+    }
+    pos2((p.x * ppp).round() / ppp, (p.y * ppp).round() / ppp)
+}
+
+/// Texture filtering for Viewer Zoom Quality: More Accurate = bilinear, Faster = nearest. As in
+/// After Effects, a magnified frame (above 100 %, or a lower Resolution) always shows its pixels
+/// as blocks, never smoothed, in either mode (#882).
+pub(crate) fn zoom_texture_options(smooth: bool) -> egui::TextureOptions {
+    if smooth { egui::TextureOptions { magnification: egui::TextureFilter::Nearest, ..egui::TextureOptions::LINEAR } } else { egui::TextureOptions::NEAREST }
+}
+
+/// The sampler GPU frames (mipmapped display textures) are drawn with: More Accurate filters
+/// bilinearly within and between mip levels, so a frame shown below 100 % is averaged instead of
+/// skipping pixels (#417); Faster takes the nearest pixel of the full-size frame. Magnified, both
+/// show the nearest pixel (#882).
+pub(crate) fn zoom_sampler(smooth: bool) -> eframe::wgpu::SamplerDescriptor<'static> {
+    use eframe::wgpu::{FilterMode, MipmapFilterMode, SamplerDescriptor};
+    let label = Some("viewer frame");
+    if smooth {
+        SamplerDescriptor {
+            label,
+            mag_filter: FilterMode::Nearest,
+            min_filter: FilterMode::Linear,
+            mipmap_filter: MipmapFilterMode::Linear,
+            ..Default::default()
+        }
+    } else {
+        SamplerDescriptor { label, lod_max_clamp: 0.0, ..Default::default() }
+    }
+}
+
+/// The whole factor a CPU frame is averaged down by for its texture when `pixels` of it are drawn
+/// over `screen` screen pixels: about one texel per screen pixel, so bilinear filtering never
+/// skips frame pixels — the CPU frames' counterpart of the GPU frames' mip levels (#417). Faster
+/// keeps every pixel.
+pub(crate) fn minify_factor(smooth: bool, pixels: f64, screen: f64) -> usize {
+    let k = (pixels / screen + 1e-3).floor();
+    if smooth && k >= 1.0 { k.min(256.0) as usize } else { 1 }
+}
+
+/// The Extended Viewer's render region for this frame (see [`ViewerState::extended`]):
+/// Settings ▸ 3D ▸ Extended Viewer on, the comp has 3D layers and the view is a custom 3D view
+/// (or Draft 3D is on), and part of the visible viewer lies outside the comp frame.
+///
+/// [`ViewerState::extended`]: crate::state::ViewerState::extended
+pub(crate) fn extended_region(
+    app: &EffectcraftApp,
+    comp: &effectcraft_engine::project::Comp,
+    cid: effectcraft_engine::project::ItemId,
+    map: ViewerMap,
+) -> Option<[f64; 4]> {
+    if !app.session.prefs.three_d.extended_viewer || !comp.has_3d() || app.session.state.region_of_interest.is_some() {
+        return None;
+    }
+    let view = app.session.state.views3d.get(&cid).map(|v| v.current).unwrap_or_default();
+    if view == View3D::ActiveCamera && !comp.draft_3d {
+        return None;
+    }
+    let a = map.to_comp(map.area.min);
+    let b = map.to_comp(map.area.max);
+    effectcraft_engine::render::extended_region(comp.width, comp.height, [a[0], a[1], b[0], b[1]], 1.0)
+}
+
+pub(super) fn rect_of(map: &ViewerMap, r: Option<[f64; 4]>) -> Rect {
+    let [x, y, w, h] = r.unwrap_or_default();
+    Rect::from_min_max(map.to_screen([x, y]), map.to_screen([x + w, y + h]))
+}
+
+/// Put a rendered frame on screen: CPU pixels go into an egui texture, averaged down by `minify`
+/// (see [`minify_factor`]); GPU frames are drawn straight from their wgpu texture (registered with
+/// egui-wgpu, no readback).
+pub(super) fn show_frame(app: &mut EffectcraftApp, ctx: &egui::Context, key: crate::frames::FrameKey, img: crate::frames::FrameImage, minify: usize) {
+    use crate::frames::FrameImage;
+    // Settings ▸ Previews ▸ Viewer Zoom Quality.
+    let smooth = app.session.prefs.viewer_zoom_smooth();
+    let opts = zoom_texture_options(smooth);
+    match img {
+        FrameImage::Cpu(img) => {
+            // Frames wider or taller than the GPU's texture limit go up averaged down too (#201).
+            let max = crate::frames::max_texture_side(ctx);
+            let fitted = crate::frames::fit_shared_texture_by(&img, max, minify);
+            match &mut app.viewer_tex {
+                Some((tex, k, m)) if tex.size() == fitted.size() => {
+                    tex.set(fitted, opts);
+                    (*k, *m) = (key, minify);
+                }
+                _ => app.viewer_tex = Some((ctx.load_texture("viewer-frame", fitted, opts), key, minify)),
+            }
+            app.viewer_shown = app.viewer_tex.as_ref().map(|(t, k, _)| (t.id(), *k));
+            app.viewer_image = Some(img);
+            vt::set_texture_roi(ctx, app.session.state.region_of_interest.or(app.ui.viewer.extended));
+        }
+        FrameImage::Gpu(f) => {
+            let Some(rs) = &app.wgpu else { return };
+            let view = f.texture.create_view(&Default::default());
+            let mut ren = rs.renderer.write();
+            let id = match &app.viewer_native {
+                Some((id, _, _)) => {
+                    ren.update_egui_texture_from_wgpu_texture_with_sampler_options(&rs.device, &view, zoom_sampler(smooth), *id);
+                    *id
+                }
+                None => ren.register_native_texture_with_sampler_options(&rs.device, &view, zoom_sampler(smooth)),
+            };
+            drop(ren);
+            app.viewer_native = Some((id, key, f));
+            app.viewer_shown = Some((id, key));
+            // Pixels are read back on demand (viewer_pixels).
+            app.viewer_image = None;
+        }
+    }
+}
diff --git a/crates/ui-egui/src/panels/viewer/geometry.rs b/crates/ui-egui/src/panels/viewer/geometry.rs
new file mode 100644
index 000000000..847332bcf
--- /dev/null
+++ b/crates/ui-egui/src/panels/viewer/geometry.rs
@@ -0,0 +1,304 @@
+use super::{CameraState, Comp, EffectcraftApp, EvalCtx, Layer, LayerId, Mat3, Pos2, VIEW_CAM, gv2, three_d, vec2};
+
+/// The camera the viewer shows (view camera or the comp's active camera).
+pub(super) fn cam_state(ctx: &EvalCtx) -> CameraState {
+    VIEW_CAM.with(|c| c.get()).unwrap_or_else(|| three_d::active_camera(ctx))
+}
+
+/// Layer → comp (viewer) matrix through the current 3D view.
+pub(crate) fn l2c(ctx: &EvalCtx, layer: &Layer) -> (Mat3, f64) {
+    match VIEW_CAM.with(|c| c.get()) {
+        Some(cam) if layer.is_3d() => (three_d::layer_to_view(ctx, layer, &cam), 0.0),
+        _ => ctx.layer_to_comp(layer),
+    }
+}
+
+/// `l2c` (layer → comp) applied from effect space instead: effect points and Puppet pins,
+/// measured from the top-left of the layer's effect bounds (see `effect_bounds`).
+pub(crate) fn from_effect_space(ctx: &EvalCtx, layer: &Layer, l2c: Mat3) -> Mat3 {
+    let o = ctx.effect_bounds(layer).1;
+    l2c * Mat3::translate(gv2(o[0], o[1]))
+}
+
+/// Effect space → comp (viewer) matrix through the current 3D view.
+pub(crate) fn fx2c(ctx: &EvalCtx, layer: &Layer) -> Mat3 {
+    from_effect_space(ctx, layer, l2c(ctx, layer).0)
+}
+
+/// The selected, unlocked layers of `comp` other than `layer` (when `layer` is one of them): a
+/// handle or Rotation tool drag on one changes them all.
+pub(super) fn selected_others<'a>(app: &EffectcraftApp, comp: &'a Comp, layer: LayerId) -> Vec<&'a Layer> {
+    let sel = &app.session.state.selected_layers;
+    if !sel.contains(&layer) {
+        return vec![];
+    }
+    sel.iter().filter(|id| **id != layer).filter_map(|id| comp.layer(*id)).filter(|l| !l.switches.locked && l.transform().is_some()).collect()
+}
+
+/// The least homogeneous depth (`w`: the distance in front of a perspective camera in pixels, 1
+/// for 2D layers and orthographic views) a viewer outline is drawn at: points at or behind the
+/// camera would flip through infinity and draw long lines across the viewer (#572).
+const NEAR_W: f64 = 0.5;
+
+/// `p` through the homography `m` before the perspective divide: (x, y, w).
+fn homogeneous(m: &Mat3, p: [f64; 2]) -> [f64; 3] {
+    let r = |i: usize| m.0.get(i).map_or(0.0, |row| row[0] * p[0] + row[1] * p[1] + row[2]);
+    [r(0), r(1), r(2)]
+}
+
+/// The closed polygon `poly` (layer pixels) through `m`, clipped to the part in front of the
+/// camera's near plane (comp pixels; empty when none of it is).
+pub(super) fn project_clipped(m: &Mat3, poly: &[[f64; 2]]) -> Vec<[f64; 2]> {
+    let h: Vec<[f64; 3]> = poly.iter().map(|p| homogeneous(m, *p)).collect();
+    let mut out = vec![];
+    for (i, a) in h.iter().enumerate() {
+        let Some(b) = h.get((i + 1) % h.len()) else { continue };
+        let (ina, inb) = (a[2] >= NEAR_W, b[2] >= NEAR_W);
+        if ina {
+            out.push(*a);
+        }
+        if ina != inb {
+            let t = (NEAR_W - a[2]) / (b[2] - a[2]);
+            out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, NEAR_W]);
+        }
+    }
+    out.iter().map(|q| [q[0] / q[2], q[1] / q[2]]).filter(|q| q[0].is_finite() && q[1].is_finite()).collect()
+}
+
+/// The segment a → b (world space) through the projection `pc`, clipped at the near plane.
+pub(super) fn project_segment(
+    pc: &effectcraft_engine::geom::Mat4,
+    a: effectcraft_engine::geom::Vec3,
+    b: effectcraft_engine::geom::Vec3,
+) -> Option<[[f64; 2]; 2]> {
+    let h = |p: effectcraft_engine::geom::Vec3| {
+        let r = |i: usize| pc.0.get(i).map_or(0.0, |row| row[0] * p.x + row[1] * p.y + row[2] * p.z + row[3]);
+        [r(0), r(1), r(3)]
+    };
+    let (mut ha, mut hb) = (h(a), h(b));
+    if ha[2] < NEAR_W && hb[2] < NEAR_W {
+        return None;
+    }
+    let cut = |p: [f64; 3], q: [f64; 3]| {
+        let t = (NEAR_W - p[2]) / (q[2] - p[2]);
+        [p[0] + (q[0] - p[0]) * t, p[1] + (q[1] - p[1]) * t, NEAR_W]
+    };
+    if ha[2] < NEAR_W {
+        ha = cut(ha, hb);
+    } else if hb[2] < NEAR_W {
+        hb = cut(hb, ha);
+    }
+    let d = |q: [f64; 3]| [q[0] / q[2], q[1] / q[2]];
+    let s = [d(ha), d(hb)];
+    s.iter().flatten().all(|v| v.is_finite()).then_some(s)
+}
+
+/// The content box corners (layer pixels) of `layer`.
+pub(super) fn box_corners(b: [f64; 4]) -> [[f64; 2]; 4] {
+    [[b[0], b[1]], [b[2], b[1]], [b[2], b[3]], [b[0], b[3]]]
+}
+
+/// Layer → comp matrix and its bounds quad (in comp pixels). None for a 3D layer reaching to or
+/// behind the camera (its quad would flip; [`layer_outline`] draws the part in front).
+pub(crate) fn layer_quad(ctx: &EvalCtx, layer: &Layer) -> Option<(Mat3, [[f64; 2]; 4], [f64; 4])> {
+    let b = effectcraft_engine::render::content_bounds(ctx, layer)?;
+    let (m, _) = l2c(ctx, layer);
+    let corners = box_corners(b);
+    if corners.iter().any(|p| homogeneous(&m, *p)[2] < NEAR_W) {
+        return None;
+    }
+    let pts = corners.map(|p| {
+        let q = m.apply(gv2(p[0], p[1]));
+        [q.x, q.y]
+    });
+    Some((m, pts, b))
+}
+
+/// The outline of a layer's content box in comp pixels, clipped at the camera's near plane.
+pub(crate) fn layer_outline(ctx: &EvalCtx, layer: &Layer) -> Vec<[f64; 2]> {
+    let Some(b) = effectcraft_engine::render::content_bounds(ctx, layer) else { return vec![] };
+    project_clipped(&l2c(ctx, layer).0, &box_corners(b))
+}
+
+/// Which axes a bounding-box handle scales: corners (0–3) both; the top and bottom edges (4, 6)
+/// y; the right and left edges (5, 7) x.
+pub(super) fn handle_axes(handle: usize) -> [bool; 2] {
+    match handle {
+        4 | 6 => [false, true],
+        5 | 7 => [true, false],
+        _ => [true, true],
+    }
+}
+
+/// A bounding-box handle's point in layer pixels (`b`: the content box; handles as in
+/// [`handle_axes`], the corners clockwise from the top left, then the top, right, bottom and
+/// left edges' midpoints).
+pub(super) fn handle_point(b: [f64; 4], handle: usize) -> [f64; 2] {
+    let (cx, cy) = ((b[0] + b[2]) / 2.0, (b[1] + b[3]) / 2.0);
+    match handle {
+        0 => [b[0], b[1]],
+        1 => [b[2], b[1]],
+        2 => [b[2], b[3]],
+        3 => [b[0], b[3]],
+        4 => [cx, b[1]],
+        5 => [b[2], cy],
+        6 => [cx, b[3]],
+        _ => [b[0], cy],
+    }
+}
+
+/// The resize cursor over bounding-box handle `handle` of the on-screen box `sq` (corners
+/// clockwise from the top left, handles as in [`handle_point`]): along the direction the handle
+/// scales, so it turns with the layer, as in After Effects. A corner points between its two
+/// edges (the box's diagonal whatever its proportions), an edge handle across its edge.
+pub(super) fn handle_cursor(sq: &[Pos2], handle: usize) -> egui::CursorIcon {
+    let at = |k: usize| sq.get(k % 4).copied().unwrap_or(Pos2::ZERO);
+    let dir = if handle < 4 {
+        let c = at(handle);
+        (c - at(handle + 3)).normalized() + (c - at(handle + 1)).normalized()
+    } else {
+        let e = at(handle - 3) - at(handle - 4);
+        vec2(-e.y, e.x)
+    };
+    // Screen y points down: 45° is the south-east diagonal.
+    let a = dir.y.atan2(dir.x).to_degrees().rem_euclid(180.0);
+    if !(22.5..157.5).contains(&a) {
+        egui::CursorIcon::ResizeHorizontal
+    } else if a < 67.5 {
+        egui::CursorIcon::ResizeNwSe
+    } else if a < 112.5 {
+        egui::CursorIcon::ResizeVertical
+    } else {
+        egui::CursorIcon::ResizeNeSw
+    }
+}
+
+/// The scale ratio (x, y) that puts the point grabbed at `start` (relative to the anchor, layer
+/// pixels) under the pointer at `cur`. `uniform` (Shift on a corner) keeps the aspect ratio,
+/// following the pointer along the handle's diagonal. Dragging past the anchor flips the layer,
+/// as in After Effects; an axis whose grabbed point sits on the anchor keeps its scale.
+pub(super) fn drag_ratio(start: [f64; 2], cur: [f64; 2], axes: [bool; 2], uniform: bool) -> [f64; 2] {
+    if uniform {
+        let d2 = start[0] * start[0] + start[1] * start[1];
+        let f = if d2 > 1e-6 { (cur[0] * start[0] + cur[1] * start[1]) / d2 } else { 1.0 };
+        return [f, f];
+    }
+    [0, 1].map(|k| if axes[k] && start[k].abs() > 1e-3 { cur[k] / start[k] } else { 1.0 })
+}
+
+/// Snap a handle drag (#252): the handle (`h`, layer pixels from the anchor point `a` as the
+/// drag began; `l2c` that layer space → comp) at scale ratio `f` goes through `snap` (a comp
+/// point → its correction), and the ratio that puts the handle where it snapped comes back.
+/// A `uniform` drag slides the handle along its line from the anchor point to the nearer snapped
+/// line; otherwise each scaled axis takes the snapped point.
+pub(super) fn snap_handle(
+    f: [f64; 2],
+    h: [f64; 2],
+    a: [f64; 2],
+    l2c: &Mat3,
+    axes: [bool; 2],
+    uniform: bool,
+    snap: impl FnOnce([f64; 2]) -> [f64; 2],
+) -> [f64; 2] {
+    let at = |f: [f64; 2]| {
+        let q = l2c.apply(gv2(a[0] + f[0] * h[0], a[1] + f[1] * h[1]));
+        [q.x, q.y]
+    };
+    let p = at(f);
+    let c = snap(p);
+    let s = [p[0] + c[0], p[1] + c[1]];
+    if uniform {
+        let o = at([0.0; 2]);
+        let d = [p[0] - o[0], p[1] - o[1]];
+        let k = [0, 1].into_iter().filter(|k| c[*k] != 0.0 && d[*k].abs() > 1e-9).min_by(|x, y| c[*x].abs().total_cmp(&c[*y].abs()));
+        return k.map_or(f, |k| f.map(|v| v * (s[k] - o[k]) / d[k]));
+    }
+    let Some(inv) = l2c.inverse().filter(|_| c != [0.0; 2]) else { return f };
+    let q = inv.apply(gv2(s[0], s[1]));
+    let q = [q.x - a[0], q.y - a[1]];
+    [0, 1].map(|k| if axes[k] && h[k].abs() > 1e-9 { q[k] / h[k] } else { f[k] })
+}
+
+/// The turn from angle `from` to angle `to` (degrees), wrapped to (−180°, 180°]: the shortest way
+/// round, so summing it frame by frame follows the pointer across atan2's ±180° seam and past full
+/// revolutions. Non-finite input turns by nothing.
+pub(super) fn turn_delta(from: f64, to: f64) -> f64 {
+    let d = to - from;
+    if !d.is_finite() {
+        return 0.0;
+    }
+    let w = (d + 180.0).rem_euclid(360.0) - 180.0;
+    if w <= -180.0 { w + 360.0 } else { w }
+}
+
+/// The Rotation tool's value: the rotation as the drag began plus the turn so far (which may span
+/// revolutions), snapped to 45° steps with Shift.
+pub(super) fn rotate_value(start_rot: f64, turned: f64, shift: bool) -> f64 {
+    let r = start_rot + turned;
+    let r = if r.is_finite() { r } else { start_rot };
+    if shift { (r / 45.0).round() * 45.0 } else { r }
+}
+
+/// A drag `d` (comp pixels), kept to the axis it moves along most when `shift` is held.
+pub(super) fn one_axis(d: [f64; 2], shift: bool) -> [f64; 2] {
+    if !shift {
+        d
+    } else if d[0].abs() > d[1].abs() {
+        [d[0], 0.0]
+    } else {
+        [0.0, d[1]]
+    }
+}
+
+pub(super) fn point_in_quad(p: [f64; 2], q: &[[f64; 2]; 4]) -> bool {
+    let mut sign = 0.0;
+    for i in 0..4 {
+        let a = q[i];
+        let b = q[(i + 1) % 4];
+        let c = (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
+        if c.abs() < 1e-9 {
+            continue;
+        }
+        if sign == 0.0 {
+            sign = c.signum();
+        } else if c.signum() != sign {
+            return false;
+        }
+    }
+    true
+}
+
+/// Separating-axis test: a marquee may cross a layer without containing any corner.
+pub(super) fn quad_intersects_box(q: &[[f64; 2]; 4], a: [f64; 2], b: [f64; 2]) -> bool {
+    if q.iter().flatten().chain(a.iter()).chain(b.iter()).any(|v| !v.is_finite()) {
+        return false;
+    }
+    let lo = [a[0].min(b[0]), a[1].min(b[1])];
+    let hi = [a[0].max(b[0]), a[1].max(b[1])];
+    let rect = [lo, [hi[0], lo[1]], hi, [lo[0], hi[1]]];
+    let axes = [[1.0, 0.0], [0.0, 1.0]].into_iter().chain((0..4).map(|i| {
+        let j = (i + 1) % 4;
+        [q[j][1] - q[i][1], q[i][0] - q[j][0]]
+    }));
+    for axis in axes {
+        let project = |p: &[f64; 2]| p[0] * axis[0] + p[1] * axis[1];
+        let (qmin, qmax) = q.iter().map(project).fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), v| (lo.min(v), hi.max(v)));
+        let (rmin, rmax) = rect.iter().map(project).fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), v| (lo.min(v), hi.max(v)));
+        if qmax < rmin || rmax < qmin {
+            return false;
+        }
+    }
+    true
+}
+
+/// Parent-space linear inverse (to convert a comp-space drag delta into a position delta).
+pub(super) fn parent_inverse(ctx: &EvalCtx, layer: &Layer) -> Mat3 {
+    match layer.parent.and_then(|p| ctx.comp.layer(p)) {
+        Some(p) => {
+            let w = ctx.world_matrix(p);
+            let m = Mat3([[w.0[0][0], w.0[0][1], 0.0], [w.0[1][0], w.0[1][1], 0.0], [0.0, 0.0, 1.0]]);
+            m.inverse().unwrap_or(Mat3::IDENTITY)
+        }
+        None => Mat3::IDENTITY,
+    }
+}
diff --git a/crates/ui-egui/src/panels/viewer/gesture.rs b/crates/ui-egui/src/panels/viewer/gesture.rs
new file mode 100644
index 000000000..db024e720
--- /dev/null
+++ b/crates/ui-egui/src/panels/viewer/gesture.rs
@@ -0,0 +1,197 @@
+use super::{EffectcraftApp, LayerId, Mat3, Pos2, Rect, Tick, Tool, ViewerMap, ov, vec2};
+
+/// What a drag in the viewer is doing.
+#[derive(Clone, Debug)]
+pub(super) enum Gesture {
+    /// Per layer: start position and the parent-space change per comp pixel of drag in x and y.
+    Move {
+        layers: Vec<(LayerId, [f64; 3], [f64; 3], [f64; 3])>,
+        start: [f64; 2],
+        /// The grabbed layer's feature nearest the pointer (comp px at the start): it snaps.
+        snap_src: Option<[f64; 2]>,
+    },
+    Camera {
+        tool: Tool,
+    },
+    /// A bounding-box handle: scales about the anchor point so the grabbed point follows the
+    /// pointer (corners both axes, edges one), relative to the layer as the drag began; the
+    /// handle snaps.
+    Scale {
+        layer: LayerId,
+        start_scale: [f64; 3],
+        /// The grabbed point relative to the anchor, in layer pixels.
+        start_local: [f64; 2],
+        /// The handle's point relative to the anchor, in layer pixels.
+        handle: [f64; 2],
+        anchor: [f64; 2],
+        axes: [bool; 2],
+        /// Layer pixels → comp as the drag began, and its inverse.
+        l2c: Mat3,
+        inv: Mat3,
+        /// The other selected layers and their scales as the drag began: they scale by the same
+        /// ratio about their own anchor points, as in After Effects (#491).
+        others: Vec<(LayerId, [f64; 3])>,
+    },
+    Rotate {
+        layer: LayerId,
+        center: Pos2,
+        /// The pointer's angle about the centre on the last frame (degrees, as atan2 gives it).
+        last_angle: f64,
+        /// The turn so far, summed frame by frame so it keeps counting past a full revolution in
+        /// either direction (After Effects: 1x +0.0°, −1x −90.0°…) instead of wrapping at ±180°.
+        turned: f64,
+        start_rot: f64,
+        /// The other selected layers and their rotations: they turn by the same angle.
+        others: Vec<(LayerId, f64)>,
+    },
+    Anchor {
+        layer: LayerId,
+        start_anchor: [f64; 3],
+        start_pos: [f64; 3],
+        start: [f64; 2],
+        inv: Mat3,
+        l2p: Mat3,
+        /// The layer's own snap targets as the drag began (its box and path vertices).
+        own: Vec<effectcraft_engine::viewer::SnapTarget>,
+        /// Alt held as the drag began: the anchor point moves alone, so the layer shifts.
+        anchor_only: bool,
+    },
+    Pan {
+        start_pan: [f32; 2],
+    },
+    Create {
+        tool: Tool,
+        start: [f64; 2],
+    },
+    Marquee {
+        start: Pos2,
+    },
+    /// Dragging selected mask / shape path vertices: press point, the grabbed vertex (comp px,
+    /// it snaps), the comp-space move applied so far and comp → path space.
+    Vertices {
+        start: [f64; 2],
+        src: [f64; 2],
+        applied: [f64; 2],
+        inv: Mat3,
+        layer: LayerId,
+    },
+    /// Dragging a vertex's Bezier tangent (both sides symmetric unless Alt breaks them).
+    Tangent {
+        layer: LayerId,
+        mask: u64,
+        index: usize,
+        out: bool,
+        vertex: [f64; 2],
+        inv: Mat3,
+    },
+    /// Dragging a Puppet pin (comp → layer matrix inverse).
+    PuppetPin {
+        layer: LayerId,
+        pin: u64,
+        inv: Mat3,
+    },
+    /// Rotating an Advanced / Bend pin by its ring: the pin's screen centre, the pointer's last
+    /// angle (radians) and the rotation so far (°, accumulated so it can pass a full turn).
+    PuppetRotate {
+        layer: LayerId,
+        pin: u64,
+        center: Pos2,
+        last: f32,
+        rotation: f64,
+    },
+    /// Scaling an Advanced / Bend pin by its square: the pin's screen centre, the press distance
+    /// from it and the scale at the press (1 = 100 %).
+    PuppetScale {
+        layer: LayerId,
+        pin: u64,
+        center: Pos2,
+        start: f32,
+        scale: f64,
+    },
+    /// Puppet tools: a marquee selecting pins (dragged outside the layer's art, or Alt-dragged).
+    PinMarquee {
+        start: Pos2,
+    },
+    /// Object Matte tool: a box around the object (screen point where the drag began).
+    ObjectMatteBox {
+        start: Pos2,
+    },
+    /// Puppet tool Record mode (⌘/Ctrl-drag a pin): the drag is sampled in real time (seconds
+    /// since it began, effect space) and becomes keyframes on release (`puppet.recordPin`); the
+    /// current time runs along while recording.
+    PuppetRecord {
+        layer: LayerId,
+        pin: u64,
+        /// Other selected pins of the layer, moving with the dragged one.
+        others: Vec<u64>,
+        inv: Mat3,
+        began: f64,
+        cti: Tick,
+        samples: Vec<(f64, [f64; 2])>,
+    },
+    /// Pen tool: pulling the tangents of the vertex just placed.
+    Pen {
+        layer: LayerId,
+        mask: u64,
+        index: usize,
+        vertex: [f64; 2],
+        inv: Mat3,
+        press: Pos2,
+    },
+    /// Dragging a track point's feature/search region, a corner or its attach point.
+    Track {
+        layer: LayerId,
+        tracker: u64,
+        drag: crate::panels::tracker::Drag,
+    },
+    /// Motion paths, free transform, Mask Feather, guides and the region of interest
+    /// (`viewer_overlays`).
+    Overlay(ov::Drag),
+}
+
+/// Pen tool path in progress: (layer, mask uid).
+pub(super) fn pen_id() -> egui::Id {
+    egui::Id::unique("viewer-pen")
+}
+
+pub(super) const HANDLE: f32 = 7.0;
+
+/// How close (screen points) the pointer must be to a path vertex or tangent handle to grab it.
+const VERTEX_GRAB: f32 = 6.0;
+
+/// The reach of a path vertex at `pos` (#1042): a vertex marker sitting under, or just beside, a
+/// bounding-box handle would lose the press to the handle (the handle reaches further than the
+/// vertex), so wherever a box handle is in range the vertex reaches as far as the handle does.
+/// Vertices then win in the handle's whole zone, as in After Effects.
+pub(super) fn vertex_grab_radius(pos: Pos2, handles: impl IntoIterator<Item = Pos2>) -> f32 {
+    if handles.into_iter().any(|h| h.distance(pos) < HANDLE + 2.0) { HANDLE + 2.0 } else { VERTEX_GRAB }
+}
+
+/// Shown when a Roto Brush tool is used in the Composition panel (#753).
+pub(super) const ROTO_HINT: &str = "The Roto Brush works in the Layer panel. Double-click the layer to open it.";
+
+/// Region of interest handles on screen: corners (0–3, clockwise from top-left) then edge
+/// midpoints (4 top, 5 right, 6 bottom, 7 left).
+pub(super) fn roi_handles(r: Rect) -> [Pos2; 8] {
+    [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom(), r.center_top(), r.right_center(), r.center_bottom(), r.left_center()]
+}
+
+/// A drag starting on a region of interest handle: the ROI redrawn from the opposite corner (or
+/// edge, with the other axis kept).
+pub(super) fn roi_drag(app: &EffectcraftApp, map: &ViewerMap, comp_rect: Rect, zoom: f32, press: Pos2) -> Option<ov::Drag> {
+    let [rx, ry, rw, rh] = app.session.state.region_of_interest?;
+    let r = Rect::from_min_size(comp_rect.min + vec2(rx as f32 * zoom, ry as f32 * zoom), vec2(rw as f32 * zoom, rh as f32 * zoom));
+    let i = roi_handles(r).iter().position(|h| h.distance(press) < 6.0)?;
+    let (x0, y0, x1, y1) = (rx, ry, rx + rw, ry + rh);
+    let _ = map;
+    Some(match i {
+        0 => ov::Drag::Roi { start: [x1, y1], keep: [None, None] },
+        1 => ov::Drag::Roi { start: [x0, y1], keep: [None, None] },
+        2 => ov::Drag::Roi { start: [x0, y0], keep: [None, None] },
+        3 => ov::Drag::Roi { start: [x1, y0], keep: [None, None] },
+        4 => ov::Drag::Roi { start: [x1, y1], keep: [Some(x0), None] },
+        5 => ov::Drag::Roi { start: [x0, y0], keep: [None, Some(y1)] },
+        6 => ov::Drag::Roi { start: [x0, y0], keep: [Some(x1), None] },
+        _ => ov::Drag::Roi { start: [x1, y0], keep: [None, Some(y1)] },
+    })
+}
diff --git a/crates/ui-egui/src/panels/viewer/shapes.rs b/crates/ui-egui/src/panels/viewer/shapes.rs
new file mode 100644
index 000000000..0cd579883
--- /dev/null
+++ b/crates/ui-egui/src/panels/viewer/shapes.rs
@@ -0,0 +1,238 @@
+use super::geometry::{l2c, layer_quad, point_in_quad};
+use super::{
+    Color32, Comp, EffectcraftApp, EvalCtx, Layer, LayerId, LayerSource, Mat3, PaintKind, Pos2, Rect, Stroke, Tick, Tokens, Tool, ViewerMap, gv2, json, ov,
+    pos2,
+};
+
+/// Visible layers eligible for viewer hit tests, locked or not, in front-to-back order.
+/// Solo scope matches the renderer: any soloed AV layer activates it at every time (as in After
+/// Effects), even when hidden, locked or outside its in-out range.
+fn hit_testable_layers(comp: &Comp, time: Tick) -> impl Iterator<Item = &Layer> {
+    let any_solo = comp.layers.iter().any(|l| l.switches.solo && l.source.is_av());
+    comp.layers.iter().filter(move |l| l.is_active_at(time) && l.switches.video && !l.is_camera() && !l.is_light() && (!any_solo || l.switches.solo))
+}
+
+/// Visible, unlocked layers eligible for viewer hit tests, in front-to-back order.
+pub(crate) fn selectable_layers(comp: &Comp, time: Tick) -> impl Iterator<Item = &Layer> {
+    hit_testable_layers(comp, time).filter(|l| !l.switches.locked)
+}
+
+/// Selectable layers under a comp point, front to back.
+pub(crate) fn layers_at<'a, 'b>(ectx: &'b EvalCtx<'a>, cpt: [f64; 2]) -> impl Iterator<Item = &'a Layer> + 'b {
+    selectable_layers(ectx.comp, ectx.time).filter(move |l| layer_quad(ectx, l).is_some_and(|(_, q, _)| point_in_quad(cpt, &q)))
+}
+
+/// Topmost selectable layer under a comp point.
+pub(crate) fn layer_at<'a>(ectx: &EvalCtx<'a>, cpt: [f64; 2]) -> Option<&'a Layer> {
+    layers_at(ectx, cpt).next()
+}
+
+/// Topmost visible layer under a comp point, locked or not. An Alt-drop uses it so a locked layer in
+/// front is refused rather than skipped, which would replace the layer behind it.
+pub(crate) fn layer_at_including_locked<'a>(ectx: &EvalCtx<'a>, cpt: [f64; 2]) -> Option<&'a Layer> {
+    // A layer scaled to nothing has a degenerate quad that `point_in_quad` accepts everywhere.
+    hit_testable_layers(ectx.comp, ectx.time).find(|l| layer_quad(ectx, l).is_some_and(|(_, q, _)| quad_area(&q) > 1e-9 && point_in_quad(cpt, &q)))
+}
+
+/// Area of a quad (shoelace formula); zero when its corners coincide or are collinear.
+fn quad_area(q: &[[f64; 2]; 4]) -> f64 {
+    (0..4).map(|i| q[i][0] * q[(i + 1) % 4][1] - q[(i + 1) % 4][0] * q[i][1]).sum::<f64>().abs() / 2.0
+}
+
+/// The layer a press at a comp point acts on, selected (Shift toggles the topmost layer). As in
+/// After Effects, a selected layer under the point comes before the layers in front of it, so it
+/// can be dragged where they cover it; otherwise the topmost layer (#230).
+pub(crate) fn pick(app: &mut EffectcraftApp, ectx: &EvalCtx, cpt: [f64; 2], toggle: bool) -> Option<LayerId> {
+    if toggle {
+        let hit = layer_at(ectx, cpt)?.id;
+        let _ = app.session.execute("layer.select", json!({"layers": [hit.0], "toggle": true}));
+        return Some(hit);
+    }
+    let selected = &app.session.state.selected_layers;
+    let hits: Vec<LayerId> = layers_at(ectx, cpt).map(|l| l.id).collect();
+    let hit = *hits.iter().find(|id| selected.contains(id)).or(hits.first())?;
+    if !selected.contains(&hit) {
+        let _ = app.session.execute("layer.select", json!({"layers": [hit.0]}));
+    }
+    Some(hit)
+}
+
+/// Where a shape drag is going to land: a mask on the selected layer, a group inside it, or a new
+/// shape layer.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum ShapeTarget {
+    Mask,
+    IntoLayer,
+    NewLayer,
+}
+
+impl ShapeTarget {
+    /// What the drag will make and where, named the way the ghost captions it.
+    fn label(self, layer_name: &str) -> String {
+        match self {
+            ShapeTarget::Mask => format!("Mask on “{layer_name}”"),
+            ShapeTarget::IntoLayer => format!("Into “{layer_name}”"),
+            ShapeTarget::NewLayer => "New shape layer".to_string(),
+        }
+    }
+}
+
+/// A shape drag as it stands, after the Tools' normalisations: the path it will make and where it
+/// will land.
+pub(super) struct ShapeDrag {
+    /// The `shape.newShape` / `layer.addMask` kind for the tool.
+    kind: &'static str,
+    /// Comp-space centre and size, what the drag will make.
+    centre: [f64; 2],
+    size: [f64; 2],
+    target: ShapeTarget,
+    /// The selected layer's name and the index its next mask would take, for the ghost's caption
+    /// and colour.
+    layer_name: String,
+    mask_index: usize,
+}
+
+/// The kind `tool` draws, as `shape.newShape` / `layer.addMask` name it.
+fn shape_kind(tool: Tool) -> &'static str {
+    match tool {
+        Tool::Rectangle => "rect",
+        Tool::RoundedRect => "rounded",
+        Tool::Ellipse => "ellipse",
+        Tool::Polygon => "polygon",
+        _ => "star",
+    }
+}
+
+/// What a shape tool drag from `start` to `end` makes, or `None` while it is too small to make
+/// anything. Alt (Option) draws from the press point and Shift squares the box; the live ghost and
+/// [`create_shape`] both go through this, so the drag always shows what it will commit.
+pub(super) fn shape_drag(app: &EffectcraftApp, tool: Tool, start: [f64; 2], end: [f64; 2], mods: egui::Modifiers) -> Option<ShapeDrag> {
+    let comp = app.session.active_comp()?;
+    let selected = app.session.state.selected_layers.first().copied();
+    let sel = selected.and_then(|id| comp.layer(id));
+    // A footage, solid or other non-shape layer selected, or a shape layer with Tool Creates
+    // Mask: a mask on that layer. Otherwise the engine's own target: the first selected unlocked
+    // shape layer, else a new one.
+    let target = match sel {
+        Some(l) if l.source.is_av() && (app.session.state.shape_tool.creates_mask || !matches!(l.source, LayerSource::Shape)) => (ShapeTarget::Mask, Some(l)),
+        _ => match effectcraft_engine::commands::shape_tool::selected_shape_target(&app.session, comp).and_then(|id| comp.layer(id)) {
+            Some(l) => (ShapeTarget::IntoLayer, Some(l)),
+            None => (ShapeTarget::NewLayer, None),
+        },
+    };
+    let (target, layer) = target;
+    let mask_index = if target == ShapeTarget::Mask { layer.and_then(|l| l.masks()).map_or(0, |m| m.groups().count()) } else { 0 };
+    let (mut w, mut h) = ((end[0] - start[0]).abs(), (end[1] - start[1]).abs());
+    // Ctrl/Cmd draws from the press point as the centre, as in After Effects.
+    if mods.command {
+        w *= 2.0;
+        h *= 2.0;
+    }
+    if w < 2.0 && h < 2.0 {
+        return None;
+    }
+    if mods.shift {
+        let m = w.max(h);
+        w = m;
+        h = m;
+    }
+    Some(ShapeDrag {
+        kind: shape_kind(tool),
+        centre: if mods.command { start } else { [start[0].min(end[0]) + w / 2.0, start[1].min(end[1]) + h / 2.0] },
+        size: [w, h],
+        target,
+        layer_name: layer.map_or_else(String::new, |l| l.name.clone()),
+        mask_index,
+    })
+}
+
+/// The Tools bar's paint colour as bytes, dimmed by `alpha` so the comp shows through the ghost.
+fn paint_rgb(c: [f32; 3], opacity: f64, alpha: f32) -> Color32 {
+    let f = |k: f32| (k.clamp(0.0, 1.0) * 255.0).round() as u8;
+    Color32::from_rgb(f(c[0]), f(c[1]), f(c[2])).gamma_multiply((opacity.clamp(0.0, 100.0) / 100.0) as f32 * alpha)
+}
+
+/// Draw a shape drag as it will land: the tool's own path, filled with the Tools bar's Fill and
+/// outlined in its Stroke (or the mask colour, for a mask), captioned with where it goes.
+pub(super) fn draw_shape_ghost(painter: &egui::Painter, map: &ViewerMap, app: &EffectcraftApp, d: &ShapeDrag, t: &Tokens) {
+    // The engine's own geometry for the kind, so the ghost is the shape and not a stand-in for it.
+    let Some(sp) = effectcraft_engine::commands::shape_tool::mask_path(d.kind, d.centre, d.size) else { return };
+    let mut pts = ov::flatten(&sp, &Mat3::IDENTITY, map);
+    if pts.first() == pts.last() {
+        pts.pop();
+    }
+    if pts.len() < 3 {
+        return;
+    }
+    let tool = &app.session.state.shape_tool;
+    let (fill, line) = match d.target {
+        ShapeTarget::Mask => {
+            let [r, g, b] = effectcraft_engine::prefs::mask_color(app.session.prefs.appearance.cycle_mask_colors, d.mask_index);
+            (Color32::from_rgb(r, g, b).gamma_multiply(0.25), Color32::from_rgb(r, g, b))
+        }
+        _ => {
+            let stroke_on = tool.stroke.kind != PaintKind::None && tool.stroke_width > 0.0;
+            (
+                if tool.fill.kind == PaintKind::None { Color32::TRANSPARENT } else { paint_rgb(tool.fill.color, tool.fill.opacity, 0.45) },
+                if stroke_on { paint_rgb(tool.stroke.color, tool.stroke.opacity, 1.0) } else { t.accent },
+            )
+        }
+    };
+    let Some(bounds) = bounds_of(&pts) else { return };
+    // A screen-width outline reads at every zoom, where a comp-pixel hairline does not.
+    painter.add(egui::Shape::Path(egui::epaint::PathShape { points: pts, closed: true, fill, stroke: Stroke::new(1.5, line).into() }));
+    // Caption it with where the shape lands: a mask, a group in the selected shape layer or a
+    // new layer.
+    let font = Tokens::ui(11.0);
+    let galley = painter.layout_no_wrap(d.target.label(&d.layer_name), font, line);
+    let caption = Rect::from_min_size(pos2(bounds.left(), bounds.top() - 5.0 - galley.size().y), galley.size());
+    painter.rect_filled(caption.expand(3.0), 2.0, Color32::from_black_alpha(150));
+    painter.galley(caption.min, galley, line);
+}
+
+/// The bounds of points on screen, or `None` for an empty set.
+fn bounds_of(pts: &[Pos2]) -> Option<Rect> {
+    let first = *pts.first()?;
+    let mut r = Rect::from_min_max(first, first);
+    for p in pts.iter().skip(1) {
+        r.extend_with(*p);
+    }
+    Some(r)
+}
+
+pub(super) fn create_shape(app: &mut EffectcraftApp, tool: Tool, a: [f64; 2], b: [f64; 2], mods: egui::Modifiers) {
+    let Some(d) = shape_drag(app, tool, a, b, mods) else { return };
+    let (kind, (w, h), (cx, cy)) = (d.kind, (d.size[0], d.size[1]), (d.centre[0], d.centre[1]));
+    // A mask on the selected layer, as the ghost showed.
+    if d.target == ShapeTarget::Mask {
+        // In layer space: invert the layer transform.
+        let sel_layer = app.session.state.selected_layers.first().copied().and_then(|id| app.session.active_comp().and_then(|c| c.layer(id)).cloned());
+        if let Some(l) = sel_layer
+            && let Some(comp) = app.session.active_comp_arc()
+        {
+            let ectx = EvalCtx {
+                project: &app.session.project,
+                comp_id: app.session.active_comp_id().unwrap_or_default(),
+                comp: &comp,
+                time: app.session.time(),
+                expr: None,
+                footage: None,
+                property_overrides: &[],
+                media_overrides: &[],
+            };
+            let inv = l2c(&ectx, &l).0.inverse().unwrap_or(Mat3::IDENTITY);
+            let p0 = inv.apply(gv2(cx - w / 2.0, cy - h / 2.0));
+            let p1 = inv.apply(gv2(cx + w / 2.0, cy + h / 2.0));
+            let rect = [p0.x.min(p1.x), p0.y.min(p1.y), (p1.x - p0.x).abs(), (p1.y - p0.y).abs()];
+            if let Err(e) = app.session.execute("layer.addMask", json!({"layer": l.id.0, "shape": kind, "rect": rect})) {
+                app.ui.status = e.to_string();
+            }
+        }
+        return;
+    }
+    // Into the selected shape layer's Contents as a new group (as in After Effects), else a new
+    // shape layer; painted with the Tools bar's Fill and Stroke.
+    if let Err(e) = app.session.execute("shape.newShape", json!({"kind": kind, "size": [w, h], "position": [cx, cy]})) {
+        app.ui.status = e.to_string();
+    }
+}
diff --git a/crates/ui-egui/src/panels/viewer/tests.rs b/crates/ui-egui/src/panels/viewer/tests.rs
new file mode 100644
index 000000000..da56dc008
--- /dev/null
+++ b/crates/ui-egui/src/panels/viewer/tests.rs
@@ -0,0 +1,164 @@
+use super::*;
+use effectcraft_engine::geom::{Mat4, vec3};
+
+/// #1544: Shift-clicking with the Pen keeps the new segment horizontal, vertical or diagonal.
+#[test]
+fn pen_shift_click_keeps_the_segment_at_45_degrees() {
+    let near = |a: [f64; 2], b: [f64; 2]| (a[0] - b[0]).abs() < 1e-9 && (a[1] - b[1]).abs() < 1e-9;
+    let from = [100.0, 100.0];
+    assert!(near(constrain_45(from, [104.0, 180.0]), [100.0, 180.0]), "straight down");
+    assert!(near(constrain_45(from, [30.0, 97.0]), [30.0, 100.0]), "left");
+    assert!(near(constrain_45(from, [150.0, 46.0]), [152.0, 48.0]), "up and right, on the diagonal");
+    assert!(near(constrain_45(from, from), from), "on the vertex");
+    assert!(constrain_45(from, [f64::NAN, 3.0])[0].is_nan(), "a non-finite point stays as it is");
+}
+
+/// The Rotation tool counts past a full turn in both directions, as in After Effects: the
+/// pointer going round the anchor 1.5 turns clockwise gives 540°, then back 2 turns gives
+/// −180°, with no jump where atan2 wraps from 180° to −180°.
+#[test]
+fn rotate_tool_accumulates_revolutions() {
+    // Screen y points down, so a growing atan2 angle is clockwise on screen.
+    let drag = |start: f64, steps: &[f64]| {
+        let (mut last, mut turned, mut out) = (start, 0.0, vec![]);
+        for &a in steps {
+            // atan2's range: (−180°, 180°].
+            let a = (a + 180.0).rem_euclid(360.0) - 180.0;
+            turned += turn_delta(last, a);
+            last = a;
+            out.push(turned);
+        }
+        (last, turned, out)
+    };
+    let cw: Vec<f64> = (1..=54).map(|i| i as f64 * 10.0).collect();
+    let (last, turned, seq) = drag(0.0, &cw);
+    assert!((turned - 540.0).abs() < 1e-9, "{turned}");
+    assert!(seq.windows(2).all(|w| (w[1] - w[0] - 10.0).abs() < 1e-9), "no jump: {seq:?}");
+    assert!((rotate_value(0.0, turned, false) - 540.0).abs() < 1e-9);
+    let ccw: Vec<f64> = (1..=72).map(|i| 540.0 - i as f64 * 10.0).collect();
+    let (_, back, seq) = drag(last, &ccw);
+    assert!(seq.windows(2).all(|w| (w[1] - w[0] + 10.0).abs() < 1e-9), "no jump: {seq:?}");
+    let total = turned + back;
+    assert!((total + 180.0).abs() < 1e-9, "{total}");
+    assert!((rotate_value(30.0, total, false) + 150.0).abs() < 1e-9);
+    // Shift snaps the accumulated value, not a wrapped one.
+    assert_eq!(rotate_value(0.0, 400.0, true), 405.0);
+    assert_eq!(rotate_value(0.0, -400.0, true), -405.0);
+    // Across the seam: 170° → −170° is +20°, and back is −20°; exactly half a turn is +180°.
+    assert!((turn_delta(170.0, -170.0) - 20.0).abs() < 1e-9);
+    assert!((turn_delta(-170.0, 170.0) + 20.0).abs() < 1e-9);
+    assert_eq!(turn_delta(0.0, 180.0), 180.0);
+    assert_eq!(turn_delta(0.0, -180.0), 180.0);
+    // Never crash or poison the value on non-finite input.
+    assert_eq!(turn_delta(f64::NAN, 10.0), 0.0);
+    assert_eq!(turn_delta(0.0, f64::INFINITY), 0.0);
+    assert_eq!(rotate_value(15.0, f64::NAN, false), 15.0);
+}
+
+/// #1042: a path vertex lying under, or just beside, a bounding-box handle is grabbed
+/// instead of the handle; away from every handle the reach is unchanged.
+#[test]
+fn vertex_reaches_as_far_as_a_box_handle_over_it() {
+    let handle = pos2(100.0, 100.0);
+    let vertex = pos2(100.0, 100.0);
+    // The press lands 8 points off the vertex, still on the handle's square.
+    let press = pos2(108.0, 100.0);
+    let pick = |p: Pos2, handles: &[Pos2]| vertex.distance(p) < vertex_grab_radius(p, handles.iter().copied());
+    assert!(handle.distance(press) < HANDLE + 2.0, "the handle would take this press");
+    assert!(pick(press, &[handle]), "the vertex wins over the handle");
+    assert!(!pick(press, &[]), "no handle there: the usual reach");
+    assert!(pick(pos2(105.0, 100.0), &[]));
+    assert!(!pick(pos2(120.0, 100.0), &[handle]), "past the handle: nothing");
+}
+
+/// #882: the frame's corner sits on a physical pixel at any display scaling, so 100 % maps
+/// comp pixels 1:1 onto screen pixels.
+#[test]
+fn frame_origin_snaps_to_physical_pixels() {
+    for ppp in [1.0f32, 1.25, 1.5, 1.75, 2.0] {
+        for p in [pos2(-201.12, 72.4), pos2(689.8, 239.75), pos2(0.3, -0.37)] {
+            let s = snap_to_pixels(p, ppp);
+            for v in [s.x * ppp, s.y * ppp] {
+                assert!((v - v.round()).abs() < 1e-3, "ppp {ppp}: {p:?} → {s:?}");
+            }
+            assert!((s - p).length() <= 0.71 / ppp, "moved by at most half a pixel: {p:?} → {s:?}");
+        }
+    }
+    assert_eq!(snap_to_pixels(pos2(1.3, 2.0), 0.0), pos2(1.3, 2.0));
+}
+
+/// #882: a magnified frame shows its pixels as blocks in both Zoom Quality modes; More
+/// Accurate only smooths when the frame is shown smaller.
+#[test]
+fn magnified_frames_are_never_smoothed() {
+    use eframe::wgpu::FilterMode;
+    for smooth in [true, false] {
+        assert_eq!(zoom_texture_options(smooth).magnification, egui::TextureFilter::Nearest);
+        assert_eq!(zoom_sampler(smooth).mag_filter, FilterMode::Nearest);
+    }
+    assert_eq!(zoom_texture_options(true).minification, egui::TextureFilter::Linear);
+    assert_eq!(zoom_sampler(true).min_filter, FilterMode::Linear);
+}
+
+/// A perspective-like homography: w = 100 + y (the plane crosses the camera at y = −100).
+fn tilted() -> Mat3 {
+    Mat3([[100.0, 0.0, 0.0], [0.0, 100.0, 0.0], [0.0, 1.0, 100.0]])
+}
+
+/// #572: a box reaching behind the camera is clipped at the near plane instead of flipping
+/// through infinity into long lines.
+#[test]
+fn outlines_clip_at_the_near_plane() {
+    let m = tilted();
+    let front = project_clipped(&m, &box_corners([-50.0, -50.0, 50.0, 50.0]));
+    assert_eq!(front.len(), 4);
+    let crossing = project_clipped(&m, &box_corners([-50.0, -150.0, 50.0, 50.0]));
+    assert_eq!(crossing.len(), 4, "{crossing:?}");
+    // Nothing flipped through infinity: a corner behind the camera (y = −150, w = −50) would
+    // land at y = +300 if it were projected as is; clipped at the near plane it runs off far
+    // above (negative y) instead, and the front corners stay where they were.
+    assert!(crossing.iter().all(|p| p[0].is_finite() && p[1].is_finite() && p[1] < 34.0), "{crossing:?}");
+    assert!(project_clipped(&m, &box_corners([-50.0, -400.0, 50.0, -200.0])).is_empty(), "wholly behind");
+}
+
+#[test]
+fn axis_drag_follows_the_arrow_and_ignores_drag_across_it() {
+    let (ax, ay) = axis_drag([0.0, 0.0, 60.0], [24.0, -24.0]);
+    let at = |d: [f64; 2]| [0, 1, 2].map(|i| ax[i] * d[0] + ay[i] * d[1]);
+    assert_eq!(at([24.0, -24.0]), [0.0, 0.0, 60.0]);
+    assert_eq!(at([-12.0, 12.0]), [0.0, 0.0, -30.0]);
+    assert_eq!(at([10.0, 10.0]), [0.0, 0.0, 0.0]);
+}
+
+#[test]
+fn gizmo_segments_clip_at_the_near_plane() {
+    // w = 100 + z.
+    let pc = Mat4([[100.0, 0.0, 0.0, 0.0], [0.0, 100.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 1.0, 100.0]]);
+    let s = project_segment(&pc, vec3(10.0, 0.0, 0.0), vec3(10.0, 0.0, -300.0)).unwrap();
+    assert_eq!(s[0], [10.0, 0.0]);
+    assert!(s[1][0] > 10.0 && s[1][0].is_finite(), "toward the camera it grows, never flips: {s:?}");
+    assert!(project_segment(&pc, vec3(0.0, 0.0, -200.0), vec3(0.0, 0.0, -300.0)).is_none());
+}
+
+/// #999: a vertex drag pans the view only near or past the edge, toward it, faster further out.
+#[test]
+fn edge_pan_speed_moves_toward_the_edge() {
+    let area = Rect::from_min_max(pos2(100.0, 50.0), pos2(900.0, 650.0));
+    assert_eq!(edge_pan_speed(area, pos2(500.0, 350.0)), egui::Vec2::ZERO);
+    let left = edge_pan_speed(area, pos2(105.0, 350.0));
+    assert!(left.x > 0.0 && left.y == 0.0, "near the left edge the view moves right to show more: {left:?}");
+    assert!(edge_pan_speed(area, pos2(20.0, 350.0)).x > left.x, "faster past the edge");
+    let corner = edge_pan_speed(area, pos2(950.0, 700.0));
+    assert!(corner.x < 0.0 && corner.y < 0.0, "{corner:?}");
+}
+
+/// Every 3D view names its own `view.3d.*` command: a typo in that mapping would fall back to the
+/// English label silently, which is what the viewer showed before (#2691).
+#[test]
+fn every_3d_view_finds_its_japanese_row() {
+    crate::i18n::ui::set_current("ja");
+    for v in View3D::ALL {
+        assert_ne!(view3d_label(v), v.label(), "{v:?} has no Japanese row");
+    }
+    crate::i18n::ui::set_current("en");
+}
diff --git a/crates/ui-egui/src/panels/viewer/tools.rs b/crates/ui-egui/src/panels/viewer/tools.rs
new file mode 100644
index 000000000..da4245e85
--- /dev/null
+++ b/crates/ui-egui/src/panels/viewer/tools.rs
@@ -0,0 +1,302 @@
+use super::geometry::{cam_state, l2c, parent_inverse};
+use super::gesture::{Gesture, pen_id};
+use super::{CameraState, Color32, EffectcraftApp, EvalCtx, Layer, LayerId, Mat3, Pos2, Rect, Stroke, Tool, ViewerMap, gv2, json, ov, three_d, vec2, vt};
+
+/// The position change per comp pixel of drag (x, y) that moves a layer by `dir` when the
+/// pointer covers the axis' on-screen vector `s` (comp px); drag across the axis is ignored.
+pub(super) fn axis_drag(dir: [f64; 3], s: [f64; 2]) -> ([f64; 3], [f64; 3]) {
+    let n = (s[0] * s[0] + s[1] * s[1]).max(1e-12);
+    (dir.map(|v| v * s[0] / n), dir.map(|v| v * s[1] / n))
+}
+
+/// The gizmo arrow under screen point `p`.
+pub(super) fn axis_at(hits: &[(LayerId, [Pos2; 2], [f64; 3], [f64; 3])], p: Pos2) -> Option<(LayerId, [Pos2; 2], [f64; 3], [f64; 3])> {
+    let dist = |[a, b]: [Pos2; 2]| {
+        let ab = b - a;
+        let t = ((p - a).dot(ab) / ab.length_sq().max(1e-6)).clamp(0.0, 1.0);
+        p.distance(a + ab * t)
+    };
+    hits.iter().filter(|h| dist(h.1) < 6.0).min_by(|a, b| dist(a.1).total_cmp(&dist(b.1))).copied()
+}
+
+/// World to parent space for a 3D layer (identity without a parent).
+pub(super) fn parent_world_inverse(ctx: &EvalCtx, l: &Layer) -> effectcraft_engine::geom::Mat4 {
+    match l.parent.and_then(|p| ctx.comp.layer(p)) {
+        Some(p) => ctx.world_matrix(p).inverse().unwrap_or_default(),
+        None => effectcraft_engine::geom::Mat4::IDENTITY,
+    }
+}
+
+/// Parent-space position change per comp pixel of drag (x and y) for a layer: 2D layers map
+/// through the parent transform; 3D layers move in the view plane at their depth.
+pub(super) fn drag_axes(ctx: &EvalCtx, l: &Layer) -> ([f64; 3], [f64; 3]) {
+    if !l.is_3d() {
+        let inv = parent_inverse(ctx, l);
+        let a = inv.apply_vec(gv2(1.0, 0.0));
+        let b = inv.apply_vec(gv2(0.0, 1.0));
+        return ([a.x, a.y, 0.0], [b.x, b.y, 0.0]);
+    }
+    let cam = cam_state(ctx);
+    let anchor = l.transform().map(|tr| ctx.v3(l, tr, "anchor", [0.0; 3])).unwrap_or([0.0; 3]);
+    let wp = ctx.world_matrix(l).apply(anchor.into());
+    let k = if cam.ortho { 1.0 / cam.zoom.max(1e-9) } else { cam.depth(wp).max(1.0) / cam.zoom.max(1e-9) };
+    let pinv = parent_world_inverse(ctx, l);
+    let a = pinv.apply_vec(cam.right() * k);
+    let b = pinv.apply_vec(cam.down() * k);
+    ([a.x, a.y, a.z], [b.x, b.y, b.z])
+}
+
+/// Wireframes of cameras (frustum, point of interest) and lights (position, direction) as seen
+/// through the current 3D view.
+/// Camera and light wireframes seen through `cam` (`through_active`: `cam` is the active camera,
+/// which is then not drawn). `pane` names the automation ids: `None` for the main view
+/// (`viewer.camera.<id>`), `Some(view)` for a view of a 2- or 4-view layout
+/// (`viewer.view.<view>.camera.<id>`).
+#[allow(clippy::too_many_arguments)]
+pub(super) fn draw_rigs(
+    app: &mut EffectcraftApp,
+    painter: &egui::Painter,
+    map: &ViewerMap,
+    ectx: &EvalCtx,
+    selected: &[LayerId],
+    cam: CameraState,
+    through_active: bool,
+    pane: Option<&str>,
+) {
+    use effectcraft_engine::geom::Vec3;
+    use effectcraft_engine::project::{LayerSource, LightKind};
+    let (w, h) = (ectx.comp.width as f64, ectx.comp.height as f64);
+    let active = ectx.comp.active_camera(ectx.time).map(|c| c.id);
+    let prefix = pane.map(|v| format!("viewer.view.{v}.")).unwrap_or_else(|| "viewer.".to_string());
+    let proj = |p: Vec3| cam.project(w, h, p).map(|v| map.to_screen([v.x, v.y]));
+    let seg = |a: Vec3, b: Vec3, stroke: Stroke| {
+        if let (Some(x), Some(y)) = (proj(a), proj(b)) {
+            painter.line_segment([x, y], stroke);
+        }
+    };
+    for l in ectx.comp.layers.iter().filter(|l| (l.is_camera() || l.is_light()) && l.is_active_at(ectx.time)) {
+        let sel = selected.contains(&l.id);
+        let col = app.tokens.label(l.label).gamma_multiply(if sel { 1.0 } else { 0.6 });
+        let stroke = Stroke::new(if sel { 1.5 } else { 1.0 }, col);
+        let (eye, fwd, down) = three_d::camera::layer_frame(ectx, l);
+        let poi = |l: &Layer| -> Option<Vec3> {
+            let pr = l.transform()?.get("poi").filter(|_| three_d::camera::is_two_node(l))?;
+            Some(three_d::camera::parent_world(ectx, l).apply(ectx.value(l, pr).as_vec3().into()))
+        };
+        if l.is_camera() {
+            if through_active && Some(l.id) == active {
+                continue;
+            }
+            let zoom = l.props.prop("cameraOptions/zoom").map(|p| ectx.value(l, p).as_f64()).unwrap_or(1000.0);
+            let right = down.cross(fwd);
+            // Frustum to a plane at a quarter of the zoom distance.
+            let k = 0.25;
+            let c = eye + fwd * (zoom * k);
+            let corners = [(-1.0, -1.0), (1.0, -1.0), (1.0, 1.0), (-1.0, 1.0)].map(|(sx, sy)| c + right * (sx * w * 0.5 * k) + down * (sy * h * 0.5 * k));
+            for i in 0..4 {
+                seg(eye, corners[i], stroke);
+                seg(corners[i], corners[(i + 1) % 4], stroke);
+            }
+            if let Some(poi) = poi(l) {
+                seg(eye, poi, Stroke::new(1.0, col.gamma_multiply(0.6)));
+                if let Some(s) = proj(poi) {
+                    painter.circle_stroke(s, 4.0, stroke);
+                }
+            }
+            if let Some(s) = proj(eye) {
+                app.auto.add(&format!("{prefix}camera.{}", l.id.0), Rect::from_center_size(s, vec2(14.0, 14.0)), &l.name);
+            }
+        } else {
+            let LayerSource::Light { kind } = l.source else { continue };
+            if kind == LightKind::Ambient {
+                continue;
+            }
+            let Some(s) = proj(eye) else { continue };
+            painter.circle_stroke(s, 6.0, stroke);
+            for i in 0..8 {
+                let a = i as f32 * std::f32::consts::FRAC_PI_4;
+                let d = vec2(a.cos(), a.sin());
+                painter.line_segment([s + d * 8.0, s + d * 12.0], stroke);
+            }
+            if matches!(kind, LightKind::Spot | LightKind::Parallel) {
+                let target = poi(l).unwrap_or(eye + fwd * 300.0);
+                seg(eye, target, Stroke::new(1.0, col.gamma_multiply(0.7)));
+                if let Some(q) = proj(target) {
+                    painter.circle_stroke(q, 3.0, stroke);
+                }
+            }
+            app.auto.add(&format!("{prefix}light.{}", l.id.0), Rect::from_center_size(s, vec2(16.0, 16.0)), &l.name);
+        }
+    }
+}
+
+/// Pen tool press at `pos`: continue the path in progress (pressing its first vertex closes it),
+/// resume an open path whose last vertex is pressed, add a vertex on a visible path's segment, or
+/// start a new path: a mask on the selected footage/solid layer (or shape layer, with Tool Creates
+/// Mask), a shape path (Shape n group with the Tools bar's Fill and Stroke) on the selected shape
+/// layer, or a new shape layer when nothing is selected. The placed point snaps.
+/// Add a Position keyframe at a motion path's frame, keeping the path where it is.
+pub(super) fn add_motion_key(app: &mut EffectcraftApp, f: ov::PathFrame) {
+    // Separated dimensions: the key goes on X and Y Position.
+    for prop in f.axes.map_or_else(|| vec![f.prop], Vec::from) {
+        if let Err(e) = app.session.execute("prop.addKey", json!({"layer": f.layer.0, "prop": prop, "time": f.time.seconds()})) {
+            app.ui.status = e.to_string();
+        }
+    }
+}
+
+/// Select only the motion path's keyframe `k` (what the vertex tools act on; with separated
+/// dimensions, the X and Y Position keys at its time).
+pub(super) fn select_motion_key(app: &mut EffectcraftApp, k: &ov::KeyHit) -> bool {
+    app.session.execute("keys.select", json!({"keys": k.select_entries()})).is_ok()
+}
+
+/// The pointer for a Pen slot tool: the tool's own pen, the Pen showing Add Vertex's over a path
+/// it would add a point to (After Effects).
+pub(super) fn pen_cursor_icon(tool: Tool, over_path: bool) -> crate::icons::Icon {
+    use crate::icons::Icon;
+    match tool {
+        Tool::Pen if over_path => Icon::PenAdd,
+        Tool::PenAdd => Icon::PenAdd,
+        Tool::PenDelete => Icon::PenDelete,
+        Tool::PenConvert => Icon::PenConvert,
+        Tool::MaskFeather => Icon::MaskFeather,
+        _ => Icon::Pen,
+    }
+}
+
+/// Paint pen pointer `icon` with its tip at `at`, outlined for any background.
+pub(super) fn pen_cursor(ctx: &egui::Context, at: Pos2, icon: crate::icons::Icon) {
+    use crate::icons::Icon;
+    // Where each glyph's tip sits in its 16 × 16 box.
+    let tip = match icon {
+        Icon::PenAdd | Icon::PenDelete | Icon::MaskFeather => vec2(6.0, 2.5),
+        Icon::PenConvert => vec2(8.0, 3.5),
+        _ => vec2(8.0, 1.8),
+    };
+    let painter = ctx.layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::unique("viewer-pen-cursor")));
+    let rect = Rect::from_min_size(at - tip, vec2(16.0, 16.0));
+    for d in [vec2(-1.0, 0.0), vec2(1.0, 0.0), vec2(0.0, -1.0), vec2(0.0, 1.0)] {
+        crate::icons::paint(&painter, rect.translate(d), icon, Color32::BLACK);
+    }
+    crate::icons::paint(&painter, rect, icon, Color32::WHITE);
+}
+
+/// Handle a Pen-tool press at `pos`: close the current path when its first vertex is hit; otherwise append a snapped
+/// (Shift: 45-degree) vertex, resume an open path's end, add a motion-path keyframe, insert a vertex on a visible
+/// path segment, or start a new mask/shape path on the selected layer or a new shape layer. Records the resulting
+/// path id and tangent gesture in context data for the drag that follows.
+#[allow(clippy::too_many_arguments)]
+pub(super) fn pen_press(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    ectx: &EvalCtx,
+    map: &ViewerMap,
+    paths: &[ov::PathInfo],
+    motion_frame: Option<ov::PathFrame>,
+    pos: Pos2,
+    mods: egui::Modifiers,
+) {
+    use effectcraft_engine::project::LayerSource;
+    let gid = egui::Id::unique("viewer-gesture");
+    let current: Option<(LayerId, u64)> = ui.data(|d| d.get_temp(pen_id()));
+    let c0 = map.to_comp(pos);
+    let corr = vt::snap(app, ui.ctx(), ectx, map, &[], &[c0], mods);
+    let c = [c0[0] + corr[0], c0[1] + corr[1]];
+    if let Some((lid, uid)) = current
+        && let Some(p) = ov::path_of(ectx, lid, uid)
+        && let Some(inv) = p.m.inverse()
+    {
+        let n = p.sp.vertices.len();
+        let first = p.sp.vertices.first().map(|v| {
+            let q = p.m.apply(gv2(v[0], v[1]));
+            map.to_screen([q.x, q.y])
+        });
+        if n >= 2 && first.is_some_and(|f| f.distance(pos) < 8.0) {
+            let _ = app.session.execute("mask.setClosed", json!({"layer": lid.0, "mask": uid, "closed": true}));
+            ui.data_mut(|d| {
+                d.remove::<(LayerId, u64)>(pen_id());
+                d.remove::<Gesture>(gid);
+            });
+            return;
+        }
+        // Shift keeps the new segment at a multiple of 45° from the vertex before it (#1544).
+        let last = p.sp.vertices.last().map(|v| p.m.apply(gv2(v[0], v[1])));
+        let c = match last {
+            Some(q) if mods.shift => constrain_45([q.x, q.y], c),
+            _ => c,
+        };
+        let lp = inv.apply(gv2(c[0], c[1]));
+        let lp = [lp.x, lp.y];
+        if let Ok(v) = app.session.execute("mask.addVertex", json!({"layer": lid.0, "mask": uid, "point": lp})) {
+            let index = v.as_u64().unwrap_or(0) as usize;
+            ui.data_mut(|d| d.insert_temp(gid, Gesture::Pen { layer: lid, mask: uid, index, vertex: lp, inv, press: pos }));
+        }
+        return;
+    }
+    // Clicking the last vertex of an open path (e.g. after Esc ended it) resumes drawing it.
+    if let Some(cur) = ov::open_end_at(paths, map, pos, 8.0) {
+        ui.data_mut(|d| d.insert_temp(pen_id(), cur));
+        return;
+    }
+    // On a visible path's segment the Pen adds a vertex there; on a motion path, a keyframe.
+    if let Some(f) = motion_frame {
+        add_motion_key(app, f);
+        return;
+    }
+    if let Some((l, m, seg, t)) = ov::segment_at(paths, map, pos, 5.0) {
+        let _ = app.session.execute("mask.insertVertex", json!({"layer": l.0, "mask": m, "segment": seg, "t": t}));
+        return;
+    }
+    let target = app
+        .session
+        .state
+        .selected_layers
+        .iter()
+        .copied()
+        .find(|id| ectx.comp.layer(*id).is_some_and(|l| !l.switches.locked && (l.masks().is_some() || matches!(l.source, LayerSource::Shape))));
+    let layer = target.and_then(|id| ectx.comp.layer(id));
+    let (lid, uid, inv) = match layer {
+        Some(l) if !matches!(l.source, LayerSource::Shape) || app.session.state.shape_tool.creates_mask => {
+            let Some(inv) = l2c(ectx, l).0.inverse() else { return };
+            let lp = inv.apply(gv2(c[0], c[1]));
+            let Ok(v) = app.session.execute("mask.new", json!({"layer": l.id.0, "vertices": [[lp.x, lp.y]]})) else { return };
+            let Some(mask) = v["mask"].as_u64() else { return };
+            (l.id, mask, inv)
+        }
+        Some(l) => {
+            let Some(inv) = l2c(ectx, l).0.inverse() else { return };
+            let lp = inv.apply(gv2(c[0], c[1]));
+            let r = app.session.execute("shape.newPath", json!({"layer": l.id.0, "vertices": [[lp.x, lp.y]], "space": "layer"}));
+            let Some(path) = r.ok().and_then(|v| v["path"].as_u64()) else { return };
+            (l.id, path, inv)
+        }
+        None => {
+            // A new shape layer at the comp centre (unrotated: comp → layer is a translation).
+            let r = app.session.execute("shape.newPath", json!({"vertices": [c], "space": "comp"}));
+            let Some(v) = r.ok() else { return };
+            let (Some(l), Some(path)) = (v["layer"].as_u64(), v["path"].as_u64()) else { return };
+            let inv = Mat3::translate(gv2(-(ectx.comp.width as f64) / 2.0, -(ectx.comp.height as f64) / 2.0));
+            (LayerId(l), path, inv)
+        }
+    };
+    let lp = inv.apply(gv2(c[0], c[1]));
+    ui.data_mut(|d| {
+        d.insert_temp(pen_id(), (lid, uid));
+        d.insert_temp(gid, Gesture::Pen { layer: lid, mask: uid, index: 0, vertex: [lp.x, lp.y], inv, press: pos });
+    });
+}
+
+/// `to` moved onto the nearest line through `from` at a multiple of 45° (horizontal, vertical or
+/// diagonal), as far along it as `to` lies: the Pen's Shift-click.
+pub(super) fn constrain_45(from: [f64; 2], to: [f64; 2]) -> [f64; 2] {
+    let (dx, dy) = (to[0] - from[0], to[1] - from[1]);
+    if !(dx.is_finite() && dy.is_finite()) || (dx == 0.0 && dy == 0.0) {
+        return to;
+    }
+    let step = std::f64::consts::FRAC_PI_4;
+    let a = (dy.atan2(dx) / step).round() * step;
+    let (ux, uy) = (a.cos(), a.sin());
+    let along = dx * ux + dy * uy;
+    [from[0] + ux * along, from[1] + uy * along]
+}
diff --git a/crates/ui-egui/src/panels/viewer/view.rs b/crates/ui-egui/src/panels/viewer/view.rs
new file mode 100644
index 000000000..60a68c57c
--- /dev/null
+++ b/crates/ui-egui/src/panels/viewer/view.rs
@@ -0,0 +1,232 @@
+use super::tools::draw_rigs;
+use super::{Align2, Color32, EffectcraftApp, EvalCtx, Rect, Sense, Stroke, StrokeKind, Tokens, View3D, ViewerMap, json, pos2, three_d, vec2, widgets};
+
+/// Draw the extra views of a 2- or 4-view layout and return the main view's rectangle.
+pub(super) fn aux_views(
+    app: &mut EffectcraftApp,
+    ui: &mut egui::Ui,
+    comp: &effectcraft_engine::project::Comp,
+    cid: effectcraft_engine::project::ItemId,
+    full: Rect,
+    bg: Color32,
+) -> Rect {
+    let n = app.session.state.view_layout;
+    if n < 2 {
+        return full;
+    }
+    let gap = 2.0;
+    let views = app.session.state.views3d.get(&cid).cloned().unwrap_or_default();
+    let (main, aux): (Rect, Vec<(Rect, View3D)>) = if n == 2 {
+        let mid = full.center().x;
+        (
+            Rect::from_min_max(pos2(mid + gap / 2.0, full.min.y), full.max),
+            vec![(Rect::from_min_max(full.min, pos2(mid - gap / 2.0, full.max.y)), views.pane(0))],
+        )
+    } else {
+        let c = full.center();
+        let q = |x0: f32, y0: f32, x1: f32, y1: f32| Rect::from_min_max(pos2(x0, y0), pos2(x1, y1));
+        (
+            q(c.x + gap / 2.0, c.y + gap / 2.0, full.max.x, full.max.y),
+            vec![
+                (q(full.min.x, full.min.y, c.x - gap / 2.0, c.y - gap / 2.0), views.pane(0)),
+                (q(c.x + gap / 2.0, full.min.y, full.max.x, c.y - gap / 2.0), views.pane(1)),
+                (q(full.min.x, c.y + gap / 2.0, c.x - gap / 2.0, full.max.y), views.pane(2)),
+            ],
+        )
+    };
+    let ctx = ui.ctx().clone();
+    let p = ui.painter().clone();
+    p.rect_filled(full, 0.0, Color32::from_black_alpha(200));
+    let t = app.session.time();
+    let (cw, ch) = (comp.width as f32, comp.height as f32);
+    let share = app.session.state.share_view_options;
+    // The camera and light wireframes of each view (as in After Effects, where every view of the
+    // layout shows them), evaluated on a snapshot of the project.
+    let snap_project = app.session.project.clone();
+    let snap_expr = app.session.expr.clone();
+    let ectx = EvalCtx {
+        project: &snap_project,
+        comp_id: cid,
+        comp,
+        time: t,
+        expr: snap_expr.as_deref(),
+        footage: None,
+        property_overrides: &[],
+        media_overrides: &[],
+    };
+    let selected = app.session.state.selected_layers.clone();
+    let mut picked: Option<(usize, View3D)> = None;
+    for (i, (r, v)) in aux.into_iter().enumerate() {
+        p.rect_filled(r, 0.0, bg);
+        let fit = ((r.width() - 20.0) / cw).min((r.height() - 20.0) / ch).max(0.01);
+        let cr = Rect::from_center_size(r.center(), vec2(cw * fit, ch * fit));
+        let scale = (fit * ctx.pixels_per_point()).min(1.0) as f64;
+        // The Active Camera pane renders through the comp's own camera; the others through their
+        // view camera.
+        let through_active = v == View3D::ActiveCamera;
+        let cam = if through_active { three_d::active_camera(&ectx) } else { views.cam(v, comp.width as f64, comp.height as f64).state() };
+        let key = {
+            use std::hash::{Hash, Hasher};
+            let mut h = std::collections::hash_map::DefaultHasher::new();
+            (app.session.revision, cid.0, t.0, i, scale.to_bits(), format!("{cam:?}")).hash(&mut h);
+            h.finish()
+        };
+        let id = egui::Id::unique(("viewer-aux", i));
+        let cached: Option<(u64, egui::TextureHandle)> = ctx.data(|d| d.get_temp(id));
+        let tex = match cached {
+            Some((k, tex)) if k == key => tex,
+            _ => {
+                let opts = effectcraft_engine::render::RenderOpts {
+                    scale,
+                    view: (comp.has_3d() && !through_active).then_some(cam),
+                    draft: true,
+                    ..Default::default()
+                };
+                let img = app.session.render(cid, t, opts);
+                let tex = crate::frames::load_fitted(&ctx, format!("viewer-aux-{i}"), crate::frames::to_color_image(&img), egui::TextureOptions::LINEAR);
+                ctx.data_mut(|d| d.insert_temp(id, (key, tex.clone())));
+                tex
+            }
+        };
+        let b = comp.background;
+        p.rect_filled(cr, 0.0, Color32::from_rgb((b[0] * 255.0) as u8, (b[1] * 255.0) as u8, (b[2] * 255.0) as u8));
+        p.image(tex.id(), cr, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
+        p.rect_stroke(cr, 0.0, Stroke::new(1.0, Color32::from_black_alpha(160)), StrokeKind::Outside);
+        if share && app.ui.viewer.safe_margins {
+            for k in [0.9, 0.8] {
+                p.rect_stroke(Rect::from_center_size(cr.center(), cr.size() * k), 0.0, Stroke::new(1.0, Color32::from_white_alpha(120)), StrokeKind::Middle);
+            }
+        }
+        if comp.has_3d() {
+            let map = ViewerMap { origin: cr.min, zoom: fit, comp: [cw, ch], area: r };
+            draw_rigs(app, &p.with_clip_rect(r), &map, &ectx, &selected, cam, through_active, Some(v.id()));
+        }
+        let label = if comp.has_3d() { super::view3d_label(v) } else { crate::i18n::tr("Active Camera") };
+        p.text(r.left_bottom() + vec2(8.0, -8.0), Align2::LEFT_BOTTOM, label, Tokens::ui(11.0), Color32::from_white_alpha(200));
+        app.auto.add(&format!("viewer.view.{}", v.id()), r, label);
+        if comp.has_3d()
+            && let Some(chosen) = pane_selector(app, ui, i + 1, r, v)
+        {
+            picked = Some((i + 1, chosen));
+        }
+    }
+    if let Some((pane, v)) = picked
+        && let Err(e) = app.session.execute("view.setPaneView", json!({"pane": pane, "view": v.id(), "comp": cid.0}))
+    {
+        app.ui.status = e.to_string();
+    }
+    main
+}
+
+/// The view selector in the top-left corner of pane `pane` (1 to 3) of a multi-view layout, a
+/// popup of every 3D view like the toolbar's 3D View menu. Returns the view chosen this frame.
+fn pane_selector(app: &mut EffectcraftApp, ui: &mut egui::Ui, pane: usize, area: Rect, current: View3D) -> Option<View3D> {
+    let t = app.tokens;
+    let r = Rect::from_min_size(area.min + vec2(6.0, 6.0), vec2(124.0, 20.0));
+    let pid = egui::Id::unique(("viewer-pane-view", pane));
+    let response = widgets::dropdown(ui, r, super::view3d_label(current), &t, pid);
+    if response.clicked() {
+        let open = widgets::popup_is_open(ui, pid);
+        ui.data_mut(|d| d.insert_temp(pid.with("open"), !open));
+    }
+    app.auto.add_response(&format!("viewer.view.{pane}.type"), &response, "View of pane");
+    if !widgets::popup_is_open(ui, pid) {
+        return None;
+    }
+    let chosen = widgets::popup_list(ui, pid, r.left_bottom() + vec2(0.0, 2.0), r, View3D::ALL.len(), 0, |ui| {
+        ui.set_min_width(124.0);
+        let mut chosen = None;
+        for (k, v) in View3D::ALL.iter().enumerate() {
+            let item = ui.selectable_label(*v == current, super::view3d_label(*v));
+            app.auto.add(&format!("viewer.view.{pane}.typeItem.{k}"), item.rect, v.label());
+            if item.clicked() {
+                chosen = Some(*v);
+            }
+        }
+        chosen
+    });
+    chosen.filter(|v| *v != current)
+}
+
+/// View ▸ Split with New Locked Viewer: the locked viewer on the left of the Composition panel
+/// (its comp and 3D view stay put whatever comp is active). Returns the main viewer's rectangle.
+pub(super) fn locked_pane(app: &mut EffectcraftApp, ui: &mut egui::Ui, full: Rect, bg: Color32) -> Rect {
+    let Some(lv) = app.session.state.locked_viewer else { return full };
+    let Some(comp) = app.session.project.comp_arc(lv.comp) else { return full };
+    let name = app.session.project.item(lv.comp).map(|i| i.name.clone()).unwrap_or_default();
+    let gap = 2.0;
+    let mid = full.center().x;
+    let r = Rect::from_min_max(full.min, pos2(mid - gap / 2.0, full.max.y));
+    let main = Rect::from_min_max(pos2(mid + gap / 2.0, full.min.y), full.max);
+    let ctx = ui.ctx().clone();
+    let p = ui.painter().clone();
+    p.rect_filled(Rect::from_min_max(pos2(r.max.x, full.min.y), pos2(main.min.x, full.max.y)), 0.0, Color32::from_black_alpha(200));
+    p.rect_filled(r, 0.0, bg);
+    let (cw, ch) = (comp.width as f32, comp.height as f32);
+    let fit = ((r.width() - 20.0) / cw).min((r.height() - 44.0) / ch).max(0.01);
+    let cr = Rect::from_center_size(r.center(), vec2(cw * fit, ch * fit));
+    let scale = (fit * ctx.pixels_per_point()).min(1.0) as f64;
+    let t = app.session.time_of(lv.comp);
+    let cam = (lv.view != View3D::ActiveCamera && comp.has_3d())
+        .then(|| app.session.state.views3d.get(&lv.comp).cloned().unwrap_or_default().cam(lv.view, comp.width as f64, comp.height as f64).state());
+    let dc = effectcraft_engine::viewer::DisplayColor::of(&app.session);
+    // The display conversion's inputs, keyed as in the main viewer's texture caches.
+    let dc_key = format!("{cam:?}{}", crate::panels::viewer_tools::display_key(app, dc.is_some()));
+    let key = {
+        use std::hash::{Hash, Hasher};
+        let mut h = std::collections::hash_map::DefaultHasher::new();
+        (app.session.revision, lv.comp.0, t.0, scale.to_bits(), dc_key).hash(&mut h);
+        h.finish()
+    };
+    let id = egui::Id::unique("viewer-locked");
+    let cached: Option<(u64, egui::TextureHandle)> = ctx.data(|d| d.get_temp(id));
+    let tex = match cached {
+        Some((k, tex)) if k == key => tex,
+        _ => {
+            let opts = effectcraft_engine::render::RenderOpts { scale, view: cam, ..Default::default() };
+            let img = app.session.render(lv.comp, t, opts);
+            let mut ci = crate::frames::to_color_image(&img);
+            if let Some(dc) = dc {
+                let mut px: Vec<[u8; 4]> = ci.pixels.iter().map(|c| c.to_array()).collect();
+                dc.apply(&mut px);
+                ci = egui::ColorImage::new(ci.size, px.into_iter().map(|a| Color32::from_rgba_premultiplied(a[0], a[1], a[2], a[3])).collect());
+            }
+            let tex = crate::frames::load_fitted(&ctx, "viewer-locked", ci, egui::TextureOptions::LINEAR);
+            ctx.data_mut(|d| d.insert_temp(id, (key, tex.clone())));
+            tex
+        }
+    };
+    let b = comp.background;
+    p.rect_filled(cr, 0.0, Color32::from_rgb((b[0] * 255.0) as u8, (b[1] * 255.0) as u8, (b[2] * 255.0) as u8));
+    p.image(tex.id(), cr, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
+    p.rect_stroke(cr, 0.0, Stroke::new(1.0, Color32::from_black_alpha(160)), StrokeKind::Outside);
+    let label =
+        crate::i18n::tr_args("Locked: {} — {}", &[&name, &(if comp.has_3d() { super::view3d_label(lv.view) } else { crate::i18n::tr("Active Camera") })]);
+    p.text(r.left_top() + vec2(8.0, 8.0), Align2::LEFT_TOP, &label, Tokens::ui(11.0), Color32::from_white_alpha(210));
+    app.auto.add("viewer.locked", r, &label);
+    // Close the locked viewer.
+    let close = Rect::from_min_size(pos2(r.max.x - 26.0, r.min.y + 4.0), vec2(20.0, 20.0));
+    let resp = ui.interact(close, egui::Id::unique("viewer-locked-close"), Sense::click());
+    p.text(close.center(), Align2::CENTER_CENTER, "\u{00d7}", Tokens::ui(14.0), if resp.hovered() { Color32::WHITE } else { Color32::from_white_alpha(170) });
+    app.auto.add("viewer.locked.close", close, "Close Locked Viewer");
+    if resp.clicked() {
+        let _ = app.session.execute("view.closeLockedViewer", serde_json::json!({}));
+    }
+    main
+}
+
+pub(crate) fn checker(p: &egui::Painter, r: Rect) {
+    let s = 10.0;
+    p.rect_filled(r, 0.0, Color32::from_gray(0xcc));
+    let mut y = r.min.y;
+    let mut row = 0;
+    while y < r.max.y {
+        let mut x = r.min.x + if row % 2 == 0 { 0.0 } else { s };
+        while x < r.max.x {
+            p.rect_filled(Rect::from_min_max(pos2(x, y), pos2((x + s).min(r.max.x), (y + s).min(r.max.y))), 0.0, Color32::from_gray(0x99));
+            x += 2.0 * s;
+        }
+        y += s;
+        row += 1;
+    }
+}
diff --git a/crates/ui-egui/src/panels/viewer_drop.rs b/crates/ui-egui/src/panels/viewer_drop.rs
index 44364a49d..aadd2c122 100644
--- a/crates/ui-egui/src/panels/viewer_drop.rs
+++ b/crates/ui-egui/src/panels/viewer_drop.rs
@@ -1,7 +1,8 @@
 //! Dropping onto the Composition viewer: footage, comps and solids from the
 //! Project panel and files from the Media Browser become layers centred where they are dropped
 //! (#85), and an effect or animation preset from Effects & Presets goes on the layer under the
-//! pointer, outlined while it is dragged (#88). Agents do the same with `layer.addItem {position}`,
+//! pointer, outlined while it is dragged (#88). Alt/Option-dropping a Project item replaces the source of
+//! the layer under the pointer instead, as in the Timeline (#2173). Agents do the same with `layer.addItem {position}`,
 //! `mediaBrowser.import {position}`, `effect.apply {layers}` and the preset commands.
 
 use effectcraft_engine::project::{ItemId, ItemKind};
@@ -10,7 +11,7 @@ use egui::{Rect, Stroke, StrokeKind, vec2};
 use serde_json::{Value, json};
 
 use super::DragPayload;
-use super::viewer::{ViewerMap, layer_at, layer_quad};
+use super::viewer::{ViewerMap, layer_at, layer_at_including_locked, layer_quad};
 use crate::EffectcraftApp;
 
 /// While something is dragged over the viewer, show where it goes; drop it on release.
@@ -23,6 +24,9 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &egui::Ui, painter: &egui::Pain
     let Some(ptr) = ctx.input(|i| i.pointer.hover_pos()).filter(|_| ui.rect_contains_pointer(map.area)) else { return };
     let stroke = Stroke::new(2.0, app.tokens.accent);
     let at = map.to_comp(ptr);
+    // Alt/Option-drop of a Project item replaces the source of the layer under the pointer (After
+    // Effects), as in the Timeline; it never adds a layer.
+    let alt_item = ctx.input(|i| i.modifiers.alt) && matches!(payload.as_ref(), DragPayload::Item(_));
     let actions: Vec<(&str, Value)> = match payload.as_ref() {
         DragPayload::Effect(effect) => layer_at(ectx, at)
             .map(|l| {
@@ -42,6 +46,7 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &egui::Ui, painter: &egui::Pain
             })
             .into_iter()
             .collect(),
+        DragPayload::Item(item) if alt_item => alt_replace(app, ectx, painter, map, stroke, at, *item).into_iter().collect(),
         DragPayload::Item(item) => {
             // The layer's frame, centred on the pointer.
             if let Some([w, h]) = app.session.project.item(ItemId(*item)).and_then(|it| frame_size(&it.kind, ectx.comp.pixel_aspect)) {
@@ -49,13 +54,17 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &egui::Ui, painter: &egui::Pain
             }
             // New layers go above the current selection, so insert in reverse
             // to preserve the order of the dragged Project items.
-            crate::panels::project_drop_items(app, *item).into_iter().rev().map(|item| ("layer.addItem", json!({"item": item, "position": at}))).collect()
+            crate::panels::project_drop_items(app, *item, app.session.state.active_comp)
+                .into_iter()
+                .rev()
+                .map(|item| ("layer.addItem", json!({"item": item, "position": at})))
+                .collect()
         }
         DragPayload::Files(paths) => vec![("mediaBrowser.import", json!({"paths": paths, "addToComp": true, "position": at}))],
         DragPayload::Property { .. } => vec![],
     };
     // Layer drops outline the target layer; the others outline the whole viewer.
-    let layer_drop = matches!(payload.as_ref(), DragPayload::Effect(_) | DragPayload::Preset { .. });
+    let layer_drop = alt_item || matches!(payload.as_ref(), DragPayload::Effect(_) | DragPayload::Preset { .. });
     if !layer_drop && !actions.is_empty() {
         painter.rect_stroke(map.area, 0.0, stroke, StrokeKind::Inside);
     }
@@ -80,3 +89,21 @@ fn frame_size(kind: &ItemKind, comp_pixel_aspect: f64) -> Option<[f32; 2]> {
     let stretch = if comp_pixel_aspect > 0.0 && pixel_aspect > 0.0 { pixel_aspect / comp_pixel_aspect } else { 1.0 };
     (w > 0 && h > 0).then_some([(w as f64 * stretch) as f32, h as f32])
 }
+
+/// The `layer.replaceSource` for an Alt/Option-drop of Project item `item` at comp point `at`: the
+/// topmost layer there, outlined, if it can take the item as its source (a locked one cannot).
+fn alt_replace(
+    app: &EffectcraftApp,
+    ectx: &EvalCtx,
+    painter: &egui::Painter,
+    map: &ViewerMap,
+    stroke: Stroke,
+    at: [f64; 2],
+    item: u64,
+) -> Option<(&'static str, Value)> {
+    let layer = layer_at_including_locked(ectx, at).filter(|l| super::timeline::replace_source_target(app, ectx.comp_id, ItemId(item), l.id, ectx.comp))?;
+    if let Some((_, q, _)) = layer_quad(ectx, layer) {
+        painter.add(egui::Shape::closed_line(q.iter().map(|c| map.to_screen(*c)).collect(), stroke));
+    }
+    Some(("layer.replaceSource", json!({"layers": [layer.id.0], "item": item, "fixExpressions": false})))
+}
diff --git a/crates/ui-egui/src/panels/viewer_overlays.rs b/crates/ui-egui/src/panels/viewer_overlays.rs
index fea6bf78b..00c07425d 100644
--- a/crates/ui-egui/src/panels/viewer_overlays.rs
+++ b/crates/ui-egui/src/panels/viewer_overlays.rs
@@ -7,7 +7,7 @@
 
 use effectcraft_engine::geom::{Mat3, vec2 as gv2};
 use effectcraft_engine::keyframe::ShapePath;
-use effectcraft_engine::project::{GroupKind, Layer, LayerId};
+use effectcraft_engine::project::{GroupKind, Layer, LayerId, Property};
 use effectcraft_engine::render::EvalCtx;
 use effectcraft_engine::time::Tick;
 use effectcraft_engine::{KeyRef, VertexRef};
@@ -132,17 +132,52 @@ pub(crate) fn path_of(ectx: &EvalCtx, layer: LayerId, uid: u64) -> Option<PathIn
 /// The path on screen: `sp` through `m` and the viewer map, flattened, with the closing point
 /// repeated for a closed path.
 pub(crate) fn flatten(sp: &ShapePath, m: &Mat3, map: &ViewerMap) -> Vec<Pos2> {
-    let k = effectcraft_engine::render::kurbo_path(sp);
+    let mut k = effectcraft_engine::render::kurbo_path(sp);
+    // A path-space tolerance becomes visible corners when the viewer or a layer/group is
+    // magnified. Flatten affine paths in screen space so the error stays below half a point.
+    // Projective transforms must still map the flattened points: projecting Bezier control
+    // points would change the curve rather than just its tessellation.
+    let screen_space = m.is_affine();
+    if screen_space {
+        let z = f64::from(map.zoom);
+        k.apply_affine(kurbo::Affine::new([
+            m.0[0][0] * z,
+            m.0[1][0] * z,
+            m.0[0][1] * z,
+            m.0[1][1] * z,
+            m.0[0][2] * z + f64::from(map.origin.x),
+            m.0[1][2] * z + f64::from(map.origin.y),
+        ]));
+    }
+    if !k.is_finite() {
+        return Vec::new();
+    }
+    let bounds = k.control_box();
+    if [bounds.x0, bounds.y0, bounds.x1, bounds.y1].iter().any(|v| v.abs() > f64::from(f32::MAX)) {
+        return Vec::new();
+    }
+    // Bound subdivision work even for extreme finite scales from a malformed project. For
+    // ordinary on-screen paths the tolerance remains half a point.
+    let tolerance = (bounds.width().max(bounds.height()) / 1_000_000.0).max(0.5);
     let mut pts: Vec<Pos2> = vec![];
-    kurbo::flatten(k.iter(), 0.5, |el| match el {
+    kurbo::flatten(k.iter(), tolerance, |el| match el {
         kurbo::PathEl::MoveTo(q) | kurbo::PathEl::LineTo(q) => {
-            let c = m.apply(gv2(q.x, q.y));
-            pts.push(map.to_screen([c.x, c.y]));
+            let p = if screen_space {
+                egui::pos2(q.x as f32, q.y as f32)
+            } else {
+                let c = m.apply(gv2(q.x, q.y));
+                map.to_screen([c.x, c.y])
+            };
+            if p.is_finite() {
+                pts.push(p);
+            }
         }
         _ => {}
     });
-    if sp.closed && !pts.is_empty() {
-        pts.push(pts[0]);
+    if sp.closed
+        && let Some(first) = pts.first().copied()
+    {
+        pts.push(first);
     }
     pts
 }
@@ -274,6 +309,23 @@ pub(crate) struct KeyHit {
     pub value: [f64; 3],
     /// Parent space → comp.
     pub p2c: Mat3,
+    /// Separated dimensions: X and Y Position's uids, and whether each has a key at `time`.
+    pub axes: Option<[(u64, bool); 2]>,
+}
+
+impl KeyHit {
+    /// The keys this dot stands for: Position's, or the X and Y Position keys at its time.
+    pub(crate) fn key_refs(&self) -> Vec<KeyRef> {
+        match self.axes {
+            Some(axes) => axes.iter().filter(|(_, has)| *has).map(|&(prop, _)| KeyRef { layer: self.layer, prop, time: self.time }).collect(),
+            None => vec![KeyRef { layer: self.layer, prop: self.prop, time: self.time }],
+        }
+    }
+
+    /// [`Self::key_refs`] as `keys.select` entries.
+    pub(crate) fn select_entries(&self) -> Vec<serde_json::Value> {
+        self.key_refs().iter().map(|k| json!({"layer": k.layer.0, "prop": k.prop, "time": k.time.seconds()})).collect()
+    }
 }
 
 /// A frame on a motion path (one of its dots): where the Pen and Add Vertex tools add a
@@ -285,6 +337,21 @@ pub(crate) struct PathFrame {
     /// Layer time of the frame.
     pub time: Tick,
     pub pos: Pos2,
+    /// Separated dimensions: X and Y Position's uids, which get the key instead of `prop`.
+    pub axes: Option<[u64; 2]>,
+}
+
+/// Layer times of the keys of separated X and Y Position together, in order.
+fn separated_key_times(x: &Property, y: &Property) -> Vec<Tick> {
+    let mut times: Vec<Tick> = x.keys.iter().chain(y.keys.iter()).map(|k| k.time).collect();
+    times.sort();
+    times.dedup();
+    times
+}
+
+/// Separated X and Y Position at layer time `t` (z 0: motion paths are for 2D layers).
+fn separated_value(x: &Property, y: &Property, t: Tick) -> [f64; 3] {
+    [x.value_at(t).as_f64(), y.value_at(t).as_f64(), 0.0]
 }
 
 /// The keyframe dot on a motion path under `pos`.
@@ -326,73 +393,96 @@ pub(crate) fn motion_path(
     hits: &mut Vec<KeyHit>,
     frames: &mut Vec<PathFrame>,
 ) {
-    let Some(pos) = l.transform().and_then(|tr| tr.get("position")) else { return };
-    if pos.keys.len() < 2 || l.is_3d() {
+    let Some(tr) = l.transform() else { return };
+    let Some(pos) = tr.get("position") else { return };
+    // Separate Dimensions: the layer follows X / Y Position, so the path is drawn from their keys.
+    let sep = tr.get("positionX").zip(tr.get("positionY"));
+    let key_times: Vec<Tick> = match sep {
+        Some((x, y)) => separated_key_times(x, y),
+        None => pos.keys.iter().map(|k| k.time).collect(),
+    };
+    if key_times.len() < 2 || l.is_3d() {
         return;
     }
+    let prop = sep.map_or(pos.uid, |(x, _)| x.uid);
+    let frame_axes = sep.map(|(x, y)| [x.uid, y.uid]);
+    let value_at = |t: Tick| match sep {
+        Some((x, y)) => separated_value(x, y, t),
+        None => pos.value_at(t).as_vec3(),
+    };
     let p2c = parent_to_comp(ectx, l);
     let to_scr = |v: [f64; 3]| {
         let c = p2c.apply(gv2(v[0], v[1]));
         map.to_screen([c.x, c.y])
     };
     // Settings ▸ Composition ▸ Motion Path: all keyframes, none, or a window around the CTI.
-    let times: Vec<Tick> = pos.keys.iter().map(|k| k.time).collect();
-    let Some((lt0, lt1)) = app.session.prefs.motion_path_span(&times, l.layer_time(ectx.time)) else { return };
+    let Some((lt0, lt1)) = app.session.prefs.motion_path_span(&key_times, l.layer_time(ectx.time)) else { return };
     let fd = ectx.comp.frame_duration();
     let mut pts = vec![];
     let mut lt = lt0;
     while lt <= lt1 && pts.len() < 20_000 {
-        let q = to_scr(pos.value_at(lt).as_vec3());
-        frames.push(PathFrame { layer: l.id, prop: pos.uid, time: lt, pos: q });
+        let q = to_scr(value_at(lt));
+        frames.push(PathFrame { layer: l.id, prop, time: lt, pos: q, axes: frame_axes });
         pts.push(q);
         lt += fd;
     }
-    pts.push(to_scr(pos.value_at(lt1).as_vec3()));
+    pts.push(to_scr(value_at(lt1)));
     let faint = col.gamma_multiply(0.8);
     painter.add(egui::Shape::line(pts.clone(), Stroke::new(1.0, faint)));
     for q in &pts {
         painter.circle_filled(*q, 1.2, faint);
     }
     let sel = &app.session.state.selected_keys;
-    for (i, k) in pos.keys.iter().enumerate() {
-        if k.time < lt0 || k.time > lt1 {
+    for (i, kt) in key_times.iter().enumerate() {
+        if *kt < lt0 || *kt > lt1 {
             continue;
         }
-        let v = k.value.as_vec3();
+        // The combined Position key at this time; none with separated dimensions.
+        let key = pos.keys.get(i).filter(|_| sep.is_none());
+        let v = key.map_or_else(|| value_at(*kt), |k| k.value.as_vec3());
         let s = to_scr(v);
-        // Auto-Bezier keys show handles on a side the path leaves straight too (a two-key path's
-        // ends), to drag it into a curve; Linear keys (no tangents) show none.
-        let (tin, tout) = if k.spatial_auto {
-            effectcraft_engine::keyframe::spatial_handles(&pos.keys, i)
-        } else {
-            effectcraft_engine::keyframe::spatial_tangents(&pos.keys, i)
-        };
-        for (out, tg) in [(false, tin), (true, tout)] {
-            let has = (out && i + 1 < pos.keys.len()) || (!out && i > 0);
-            if !has || (tg[0] == 0.0 && tg[1] == 0.0) {
-                continue;
+        let axes = sep.map(|(x, y)| [x, y].map(|a| (a.uid, a.keys.iter().any(|k| k.time == *kt))));
+        let hit = KeyHit { layer: l.id, prop, time: *kt, pos: s, tangent: None, value: v, p2c, axes };
+        let selected = hit.key_refs().iter().any(|k| sel.contains(k));
+        // A muted position key is off the motion path: no tangents, and a dimmed point.
+        let kc = if key.is_some_and(|k| k.muted) { col.gamma_multiply(if selected { 0.55 } else { 0.35 }) } else { col };
+        // Separated X / Y have no spatial tangents.
+        if let Some(k) = key.filter(|k| !k.muted) {
+            // Auto-Bezier keys show handles on a side the path leaves straight too (a two-key path's
+            // ends), to drag it into a curve; Linear keys (no tangents) show none.
+            let (tin, tout) = if k.spatial_auto {
+                effectcraft_engine::keyframe::spatial_handles(&pos.keys, i)
+            } else {
+                effectcraft_engine::keyframe::spatial_tangents(&pos.keys, i)
+            };
+            for (out, tg) in [(false, tin), (true, tout)] {
+                let has = (out && i + 1 < pos.keys.len()) || (!out && i > 0);
+                if !has || (tg[0] == 0.0 && tg[1] == 0.0) {
+                    continue;
+                }
+                let h = to_scr([v[0] + tg[0], v[1] + tg[1], v[2] + tg[2]]);
+                painter.line_segment([s, h], Stroke::new(1.0, kc));
+                painter.circle_filled(h, 3.0, kc);
+                let side = if out { "out" } else { "in" };
+                app.auto.add(&format!("viewer.motionPath.{}.{i}.{side}", l.id.0), Rect::from_center_size(h, vec2(8.0, 8.0)), "Spatial tangent");
+                hits.push(KeyHit { layer: l.id, prop, time: *kt, pos: h, tangent: Some(out), value: v, p2c, axes: None });
             }
-            let h = to_scr([v[0] + tg[0], v[1] + tg[1], v[2] + tg[2]]);
-            painter.line_segment([s, h], Stroke::new(1.0, col));
-            painter.circle_filled(h, 3.0, col);
-            let side = if out { "out" } else { "in" };
-            app.auto.add(&format!("viewer.motionPath.{}.{i}.{side}", l.id.0), Rect::from_center_size(h, vec2(8.0, 8.0)), "Spatial tangent");
-            hits.push(KeyHit { layer: l.id, prop: pos.uid, time: k.time, pos: h, tangent: Some(out), value: v, p2c });
         }
         let r = Rect::from_center_size(s, vec2(7.0, 7.0));
-        if sel.contains(&KeyRef { layer: l.id, prop: pos.uid, time: k.time }) {
-            painter.rect_filled(r, 0.0, col);
+        if selected {
+            painter.rect_filled(r, 0.0, kc);
         } else {
             painter.rect_filled(r, 0.0, Color32::from_black_alpha(140));
-            painter.rect_stroke(r, 0.0, Stroke::new(1.0, col), StrokeKind::Inside);
+            painter.rect_stroke(r, 0.0, Stroke::new(1.0, kc), StrokeKind::Inside);
         }
         app.auto.add(&format!("viewer.motionPath.{}.{i}", l.id.0), r.expand(2.0), "Position keyframe");
-        hits.push(KeyHit { layer: l.id, prop: pos.uid, time: k.time, pos: s, tangent: None, value: v, p2c });
+        hits.push(hit);
     }
 }
 
 // ---------------------------------------------------------------- free transform
 
+/// The `egui::Id` under which the free-transform target (layer and mask or path id) is stored.
 fn ft_id() -> egui::Id {
     egui::Id::unique("viewer-free-transform")
 }
@@ -503,7 +593,7 @@ fn point_in_quad(p: Pos2, q: &[Pos2; 4]) -> bool {
 #[derive(Clone, Debug)]
 pub(crate) enum Drag {
     /// A motion-path keyframe: its value moves with the pointer (parent space).
-    Key { layer: LayerId, prop: u64, time: Tick, start: [f64; 3], press: [f64; 2], inv: Mat3 },
+    Key { layer: LayerId, prop: u64, time: Tick, start: [f64; 3], press: [f64; 2], inv: Mat3, axes: Option<[u64; 2]> },
     /// A spatial tangent handle of a motion-path key.
     KeyTangent { layer: LayerId, prop: u64, time: Tick, out: bool, key: [f64; 3], inv: Mat3 },
     /// Free transform: 0 move, 1 scale (anchor, axes), 2 rotate about `anchor`.
@@ -528,11 +618,17 @@ pub(crate) fn begin_key_drag(app: &mut EffectcraftApp, hits: &[KeyHit], press: P
     match h.tangent {
         Some(out) => Some(Drag::KeyTangent { layer: h.layer, prop: h.prop, time: h.time, out, key: h.value, inv }),
         None => {
-            let k = KeyRef { layer: h.layer, prop: h.prop, time: h.time };
-            if !app.session.state.selected_keys.contains(&k) || shift {
-                let _ = app.session.execute("keys.select", json!({"keys": [{"layer": h.layer.0, "prop": h.prop, "time": h.time.seconds()}], "add": shift}));
+            // Separated dimensions: both X and Y need a key here before the drag moves them.
+            let mut h = *h;
+            for (uid, has) in h.axes.iter_mut().flatten().filter(|(_, has)| !*has) {
+                let _ = app.session.execute("prop.addKey", json!({"layer": h.layer.0, "prop": *uid, "time": h.time.seconds()}));
+                *has = true;
             }
-            Some(Drag::Key { layer: h.layer, prop: h.prop, time: h.time, start: h.value, press: cpt, inv })
+            if !h.key_refs().iter().all(|k| app.session.state.selected_keys.contains(k)) || shift {
+                let _ = app.session.execute("keys.select", json!({"keys": h.select_entries(), "add": shift}));
+            }
+            let axes = h.axes.map(|a| a.map(|(uid, _)| uid));
+            Some(Drag::Key { layer: h.layer, prop: h.prop, time: h.time, start: h.value, press: cpt, inv, axes })
         }
     }
 }
@@ -598,17 +694,22 @@ pub(crate) fn update(
     snap: &mut dyn FnMut(&EffectcraftApp, [f64; 2], LayerId) -> [f64; 2],
 ) -> Option<Drag> {
     match d.clone() {
-        Drag::Key { layer, prop, time, start, press, inv } => {
+        Drag::Key { layer, prop, time, start, press, inv, axes } => {
             // Snap the key's on-screen position like a layer drag.
             let start_c = inv.inverse().map(|m| m.apply(gv2(start[0], start[1]))).map(|v| [v.x, v.y]).unwrap_or([start[0], start[1]]);
             let mut target = [start_c[0] + cpt[0] - press[0], start_c[1] + cpt[1] - press[1]];
             let s = snap(app, target, layer);
             target = [target[0] + s[0], target[1] + s[1]];
             let p = inv.apply(gv2(target[0], target[1]));
-            let v = json!([p.x, p.y, start[2]]);
-            let r = app.session.execute("keys.set", json!({"layer": layer.0, "prop": prop, "time": time.seconds(), "value": v, "merge": merge}));
-            if let Err(e) = r {
-                app.ui.status = e.to_string();
+            let edits = match axes {
+                Some([ux, uy]) => vec![(ux, json!(p.x)), (uy, json!(p.y))],
+                None => vec![(prop, json!([p.x, p.y, start[2]]))],
+            };
+            for (uid, v) in edits {
+                let r = app.session.execute("keys.set", json!({"layer": layer.0, "prop": uid, "time": time.seconds(), "value": v, "merge": merge}));
+                if let Err(e) = r {
+                    app.ui.status = e.to_string();
+                }
             }
             None
         }
@@ -673,12 +774,153 @@ pub(crate) fn update(
 mod tests {
     use super::*;
 
+    fn scalar_prop(uid: u64, keys: &[(i64, f64)]) -> Property {
+        use effectcraft_engine::keyframe::{Keyframe, Value};
+        let mut p = Property::new(uid, "positionX", "X Position", Value::Scalar(0.0));
+        p.keys = keys.iter().map(|&(t, v)| Keyframe::new(Tick(t), Value::Scalar(v))).collect();
+        p
+    }
+
+    /// #2242: with separated dimensions the motion path follows the keys of X and Y Position.
+    #[test]
+    fn separated_motion_path_uses_x_and_y_keys() {
+        let x = scalar_prop(1, &[(0, 10.0), (100, 30.0)]);
+        let y = scalar_prop(2, &[(0, 0.0), (50, 20.0), (100, 0.0)]);
+        assert_eq!(separated_key_times(&x, &y), vec![Tick(0), Tick(50), Tick(100)]);
+        let mid = separated_value(&x, &y, Tick(50));
+        assert!((mid[0] - 20.0).abs() < 1e-9 && (mid[1] - 20.0).abs() < 1e-9 && mid[2] == 0.0, "{mid:?}");
+        assert_eq!(separated_value(&x, &y, Tick(100)), [30.0, 0.0, 0.0]);
+    }
+
+    /// #2242: a separated dot selects the X and Y keys at its time, not the nearest X key.
+    #[test]
+    fn separated_key_dot_refers_to_its_axis_keys() {
+        let mut h = KeyHit {
+            layer: LayerId(7),
+            prop: 1,
+            time: Tick(50),
+            pos: Pos2::ZERO,
+            tangent: None,
+            value: [0.0; 3],
+            p2c: Mat3::IDENTITY,
+            axes: Some([(1, false), (2, true)]),
+        };
+        assert_eq!(h.key_refs(), vec![KeyRef { layer: LayerId(7), prop: 2, time: Tick(50) }]);
+        h.axes = None;
+        assert_eq!(h.key_refs(), vec![KeyRef { layer: LayerId(7), prop: 1, time: Tick(50) }]);
+    }
+
     fn info(vertices: Vec<[f64; 2]>, closed: bool) -> PathInfo {
         let n = vertices.len();
         let sp = ShapePath { vertices, in_tangents: vec![[0.0; 2]; n], out_tangents: vec![[0.0; 2]; n], closed, feather: Vec::new() };
         PathInfo { layer: LayerId(3), uid: 7, m: Mat3::IDENTITY, sp, is_mask: true, feather: Vec::new() }
     }
 
+    fn circle() -> ShapePath {
+        let r = 38.0;
+        let h = r * 0.552_284_749_830_793_6;
+        ShapePath {
+            vertices: vec![[0.0, -r], [r, 0.0], [0.0, r], [-r, 0.0]],
+            in_tangents: vec![[-h, 0.0], [0.0, -h], [h, 0.0], [0.0, h]],
+            out_tangents: vec![[h, 0.0], [0.0, h], [-h, 0.0], [0.0, -h]],
+            closed: true,
+            feather: Vec::new(),
+        }
+    }
+
+    /// Measure the actual screen-space error against dense samples of the original cubics,
+    /// independently of the tessellator's chosen subdivisions.
+    fn screen_error(sp: &ShapePath, m: &Mat3, map: &ViewerMap, points: &[Pos2]) -> f32 {
+        let mut worst = 0.0_f32;
+        for i in 0..sp.vertices.len() {
+            let Some(c) = segment(sp, i) else { continue };
+            for step in 0..=1024 {
+                let q = cubic(c[0], c[1], c[2], c[3], f64::from(step) / 1024.0);
+                let q = m.apply(gv2(q[0], q[1]));
+                let p = map.to_screen([q.x, q.y]);
+                let distance = points
+                    .windows(2)
+                    .map(|pair| {
+                        let a = pair[0];
+                        let v = pair[1] - a;
+                        let t = if v.length_sq() > 0.0 { ((p - a).dot(v) / v.length_sq()).clamp(0.0, 1.0) } else { 0.0 };
+                        p.distance(a + v * t)
+                    })
+                    .fold(f32::INFINITY, f32::min);
+                worst = worst.max(distance);
+            }
+        }
+        worst
+    }
+
+    #[test]
+    fn curve_overlay_stays_smooth_at_viewer_magnifications() {
+        let sp = circle();
+        let mut counts = Vec::new();
+        for zoom in [0.5, 1.0, 5.0] {
+            let map = ViewerMap { origin: egui::pos2(121.25, 210.5), zoom, comp: [640.0, 400.0], area: Rect::EVERYTHING };
+            let points = flatten(&sp, &Mat3::IDENTITY, &map);
+            let error = screen_error(&sp, &Mat3::IDENTITY, &map, &points);
+            assert!(error <= 0.51, "{zoom}x: {error} screen points from the curve");
+            assert_eq!(points.first(), points.last(), "closed paths keep their closing edge");
+            for v in &sp.vertices {
+                let anchor = map.to_screen(*v);
+                assert!(points.iter().any(|p| p.distance(anchor) < 0.001), "original vertex missing at {zoom}x");
+            }
+            counts.push(points.len());
+        }
+        assert!(counts[0] < counts[1] && counts[1] < counts[2], "tessellation follows visible curve size: {counts:?}");
+    }
+
+    #[test]
+    fn curve_overlay_accounts_for_nonuniform_layer_and_group_transforms() {
+        let sp = circle();
+        let layer = Mat3::translate(gv2(70.0, 50.0)) * Mat3::rotate_deg(27.0) * Mat3::scale(gv2(3.2, 0.8));
+        let group = Mat3::rotate_deg(-19.0) * Mat3::skew_deg(25.0, 11.0) * Mat3::scale(gv2(0.7, 2.5));
+        let m = layer * group;
+        for zoom in [0.5, 1.0, 5.0] {
+            let map = ViewerMap { origin: egui::pos2(121.25, 210.5), zoom, comp: [640.0, 400.0], area: Rect::EVERYTHING };
+            let points = flatten(&sp, &m, &map);
+            let error = screen_error(&sp, &m, &map, &points);
+            assert!(error <= 0.51, "{zoom}x transformed path: {error} screen points from the curve");
+        }
+    }
+
+    #[test]
+    fn open_overlay_preserves_its_transformed_endpoints() {
+        let sp = info(vec![[10.0, 20.0], [50.0, 60.0]], false).sp;
+        let m = Mat3::translate(gv2(70.0, 50.0)) * Mat3::rotate_deg(27.0) * Mat3::scale(gv2(3.2, 0.8));
+        let map = ViewerMap { origin: egui::pos2(121.25, 210.5), zoom: 5.0, comp: [640.0, 400.0], area: Rect::EVERYTHING };
+        let points = flatten(&sp, &m, &map);
+        assert_ne!(points.first(), points.last(), "an open path must not gain a closing edge");
+        for (point, vertex) in [points.first(), points.last()].into_iter().zip([sp.vertices.first(), sp.vertices.last()]) {
+            let q = m.apply(gv2(vertex.unwrap()[0], vertex.unwrap()[1]));
+            assert!(point.unwrap().distance(map.to_screen([q.x, q.y])) < 0.001);
+        }
+    }
+
+    #[test]
+    fn invalid_overlay_coordinates_are_not_tessellated() {
+        let sp = circle();
+        for zoom in [f32::NAN, f32::INFINITY] {
+            let map = ViewerMap { origin: Pos2::ZERO, zoom, comp: [640.0, 400.0], area: Rect::EVERYTHING };
+            assert!(flatten(&sp, &Mat3::IDENTITY, &map).is_empty());
+        }
+        let map = ViewerMap { origin: Pos2::ZERO, zoom: 5.0, comp: [640.0, 400.0], area: Rect::EVERYTHING };
+        assert!(flatten(&sp, &Mat3::scale(gv2(f64::INFINITY, 1.0)), &map).is_empty());
+    }
+
+    #[test]
+    fn extreme_finite_overlay_scales_keep_subdivision_bounded() {
+        let map = ViewerMap { origin: Pos2::ZERO, zoom: 5.0, comp: [640.0, 400.0], area: Rect::EVERYTHING };
+        let sp = circle();
+        let points = flatten(&sp, &Mat3::scale(gv2(1e12, 1e12)), &map);
+        assert!(!points.is_empty());
+        assert!(points.len() < 10_000, "extreme scales must not allocate millions of vertices");
+        assert!(points.iter().all(|p| p.is_finite()));
+        assert!(flatten(&sp, &Mat3::scale(gv2(1e300, 1e300)), &map).is_empty());
+    }
+
     /// #912: clicking the last vertex of an open path with the Pen resumes that path.
     #[test]
     fn pen_resumes_an_open_path_at_its_last_vertex() {
diff --git a/crates/ui-egui/src/panels/viewer_text.rs b/crates/ui-egui/src/panels/viewer_text.rs
index c410d8e74..d4a5c8ccf 100644
--- a/crates/ui-egui/src/panels/viewer_text.rs
+++ b/crates/ui-egui/src/panels/viewer_text.rs
@@ -40,9 +40,12 @@ enum Drag {
     Resize { layer: LayerId, handle: usize, start_box: [f64; 4] },
 }
 
+/// The `egui::Id` under which the in-progress text drag (selection, creation or box resize) is kept between frames.
 fn drag_id() -> egui::Id {
     egui::Id::unique("viewer-text-drag")
 }
+/// The `egui::Id` of the invisible focusable widget that owns keyboard and IME focus while on-canvas text editing is
+/// active.
 fn focus_id() -> egui::Id {
     egui::Id::unique("viewer-text-focus")
 }
@@ -97,6 +100,8 @@ enum ImeComposition {
 struct OutputContext(egui::Id, u64, egui::IMEPurpose);
 
 impl From<&egui::output::IMEOutput> for OutputContext {
+    /// Copy the owner, context generation and purpose out of egui's IME output so they can be cached and compared
+    /// cheaply.
     fn from(output: &egui::output::IMEOutput) -> Self {
         Self(output.owner, output.context_generation, output.purpose)
     }
@@ -111,33 +116,43 @@ struct ResetGuard {
     suspended: bool,
 }
 
+/// The `egui::Id` under which this viewport's `ResetGuard` is stored.
 fn reset_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("effectcraft.ime.reset", viewport))
 }
+/// The `egui::Id` holding whether this viewport is currently inside a full UI pass (set by the pass hooks).
 fn mode_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("effectcraft.ime.ui-pass", viewport))
 }
+/// The `egui::Id` holding the last committed IME mutation stamp accepted for this viewport.
 fn committed_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("effectcraft.ime.committed", viewport))
 }
+/// The `egui::Id` holding the frame number whose text-editor keyboard events were already consumed.
 fn input_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("effectcraft.ime.input-frame", viewport))
 }
+/// The `egui::Id` holding whether this viewport may request an IME reset in the current pass.
 fn admission_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("effectcraft.ime.can-request", viewport))
 }
 
+/// Allow or forbid IME reset requests for the current viewport's pass by storing `allowed` in context data.
 fn set_admission(ctx: &egui::Context, allowed: bool) {
     let id = admission_id(ctx.viewport_id());
     ctx.data_mut(|data| data.insert_temp(id, allowed));
 }
 
+/// Whether the window can receive input: focused, not minimized and not occluded. Unknown viewport flags count as
+/// available.
 fn window_available(ctx: &egui::Context) -> bool {
     ctx.input(|input| {
         input.focused && input.viewport().focused.unwrap_or(true) && input.viewport().minimized != Some(true) && input.viewport().occluded != Some(true)
     })
 }
 
+/// Install the per-pass IME hooks on `ctx` once: the begin hook marks a full UI pass and the end hook clears it.
+/// Later calls do nothing.
 pub(crate) fn install_hooks(ctx: &egui::Context) {
     let id = egui::Id::unique("effectcraft.ime.hooks-installed");
     let first = ctx.data_mut(|data| {
@@ -167,11 +182,15 @@ pub(crate) fn install_hooks(ctx: &egui::Context) {
     );
 }
 
+/// Read the current viewport's pending reset guard, if any.
 fn read_reset(ctx: &egui::Context) -> Option<ResetGuard> {
     let id = reset_id(ctx.viewport_id());
     ctx.data(|data| data.get_temp(id))
 }
 
+/// Record a reset for the current viewport: request a fresh IME fence when this pass is admitted, then store the
+/// destination selection, committed stamp and output identity and mark the composition stale. An unadmitted pass
+/// stores a suspended guard instead.
 fn request_reset_with_output(app: &EffectcraftApp, ctx: &egui::Context, output: Option<OutputContext>) {
     let viewport = ctx.viewport_id();
     let allowed = ctx.data(|data| data.get_temp::<bool>(admission_id(viewport)).unwrap_or(false));
@@ -183,11 +202,14 @@ fn request_reset_with_output(app: &EffectcraftApp, ctx: &egui::Context, output:
     });
 }
 
+/// Re-request a reset for the current viewport, keeping the output identity published earlier in the pass.
 fn request_reset(app: &EffectcraftApp, ctx: &egui::Context) {
     let output = read_reset(ctx).and_then(|guard| guard.output);
     request_reset_with_output(app, ctx, output);
 }
 
+/// Re-request the reset when an unsuspended guard's destination selection or committed stamp no longer matches the
+/// app.
 fn sync_reset(app: &EffectcraftApp, ctx: &egui::Context) {
     if let Some(guard) = read_reset(ctx)
         && !guard.suspended
@@ -197,6 +219,7 @@ fn sync_reset(app: &EffectcraftApp, ctx: &egui::Context) {
     }
 }
 
+/// Retire the guard's request id locally and suspend it, so only a later eligible pass can request a new fence.
 fn suspend_reset(ctx: &egui::Context) {
     if let Some(mut guard) = read_reset(ctx) {
         guard.request = None;
@@ -206,6 +229,8 @@ fn suspend_reset(ctx: &egui::Context) {
     }
 }
 
+/// Accept `request` only when it is this viewport's current, unsuspended request and the destination and stamp still
+/// match; then sync target and selection, clear the composition and preview and remember the selection.
 fn complete_reset(app: &EffectcraftApp, ui: &egui::Ui, request: egui::ImeResetId) {
     if !read_reset(ui.ctx()).is_some_and(|guard| !guard.suspended && guard.request == Some(request)) {
         return;
@@ -228,6 +253,8 @@ fn complete_reset(app: &EffectcraftApp, ui: &egui::Ui, request: egui::ImeResetId
     }
 }
 
+/// Withhold custom IME controls for this pass: suspend the reset guard and drop every `ImeResetCompleted` event.
+/// No custom mutation route can be waiting for completion here; stock text widgets keep their keys and text events.
 fn unavailable_controls(ui: &egui::Ui) {
     suspend_reset(ui.ctx());
     // No custom mutation route runs here, so controls can only be obsolete. Stock text/keys
@@ -235,12 +262,22 @@ fn unavailable_controls(ui: &egui::Ui) {
     ui.ctx().input_mut(|input| input.events.retain(|event| !matches!(event, egui::Event::ImeResetCompleted { .. })));
 }
 
+/// Start a UI pass: revoke IME reset admission and clear the geometry published by the previous pass.
 pub(crate) fn begin_ui(ctx: &egui::Context) {
     set_admission(ctx, false);
     let id = ime_geometry_id(ctx.viewport_id());
     ctx.data_mut(|data| data.remove::<ImeGeometry>(id));
 }
 
+/// Whether the text editor recorded its IME geometry in this pass of the current viewport.
+pub(crate) fn ime_recorded(ctx: &egui::Context) -> bool {
+    let viewport = ctx.viewport_id();
+    let pass = ctx.cumulative_pass_nr_for(viewport);
+    ctx.data(|d| d.get_temp::<ImeGeometry>(ime_geometry_id(viewport))).is_some_and(|(p, _, _)| p == pass)
+}
+
+/// Close a logic-only tick: when no full UI pass ran, revoke admission and resync and suspend the reset guard so a
+/// hidden tick never publishes IME state.
 pub(crate) fn finish_logic(app: &EffectcraftApp, ctx: &egui::Context) {
     let id = mode_id(ctx.viewport_id());
     if !ctx.data(|data| data.get_temp::<bool>(id).unwrap_or(false)) {
@@ -259,30 +296,40 @@ struct SurroundingCache {
     value: Option<ImeSurrounding>,
 }
 
+/// The `egui::Id` under which this viewport's visible IME pre-edit preview is stored.
 fn ime_preedit_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("viewer-text-preedit", viewport))
 }
+/// The `egui::Id` under which this viewport's in-flight IME composition state is stored.
 fn ime_composition_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("viewer-text-ime-composition", viewport))
 }
+/// The `egui::Id` under which the current pass number, text region and caret rectangle are stored for the
+/// viewport IME publisher.
 fn ime_geometry_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("viewer-text-ime-geometry", viewport))
 }
+/// The `egui::Id` under which the last text-edit target given keyboard focus is stored.
 fn ime_seen_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("viewer-text-seen", viewport))
 }
+/// The `egui::Id` under which the last `ImeOwner` observed by `sync_ime_target` is stored.
 fn ime_target_seen_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("viewer-text-ime-target", viewport))
 }
+/// The `egui::Id` under which the last accepted IME selection is stored.
 fn ime_selection_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("viewer-text-ime-selection", viewport))
 }
+/// The `egui::Id` under which the last published IME owner and context generation are stored.
 fn ime_last_context_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("viewer-text-ime-last-context", viewport))
 }
+/// The `egui::Id` under which the bounded IME surrounding-text snapshot and its cache key are stored.
 fn ime_surrounding_cache_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("viewer-text-ime-surrounding", viewport))
 }
+/// The `egui::Id` under which the typing merge counter is stored.
 fn typing_key_id(viewport: egui::ViewportId) -> egui::Id {
     egui::Id::unique(("viewer-text-typing", viewport))
 }
@@ -299,6 +346,8 @@ fn ime_target(app: &EffectcraftApp) -> Option<egui::ImeTarget> {
     Some(egui::ImeTarget::new(egui::Id::unique(("effectcraft-ime-text", comp.0, edit.layer.0)), edit.session))
 }
 
+/// The layer and edit-session token of the active text edit, or `None` when no editor is open. Caret, selection and
+/// text are deliberately excluded.
 fn ime_owner(app: &EffectcraftApp) -> Option<ImeOwner> {
     let edit = app.session.state.text_edit.as_ref()?;
     Some(ImeOwner { layer: edit.layer, session: edit.session })
@@ -331,6 +380,9 @@ fn ime_surrounding_cached(app: &EffectcraftApp, ctx: &egui::Context) -> Option<I
     value
 }
 
+/// The committed-text stamp an IME receipt compares against: the bounded snapshot when it is available, else the
+/// editor revision marked unavailable. It deliberately does not use the global project revision, so an unrelated edit
+/// leaves a wide selection's stamp unchanged.
 fn ime_stamp(app: &EffectcraftApp, ctx: &egui::Context) -> egui::ImeMutationStamp {
     match ime_surrounding_cached(app, ctx) {
         Some(w) => egui::ImeMutationStamp::from_committed(&w.text, w.cursor, w.anchor, None),
@@ -372,16 +424,19 @@ fn note_ime_application_change(app: &mut EffectcraftApp, ctx: &egui::Context) {
     app.ime_tracker.note_application_change(viewport, frame, target);
 }
 
+/// Drop this viewport's visible pre-edit preview.
 fn clear_preedit(ui: &egui::Ui) {
     let viewport = ui.ctx().viewport_id();
     ui.data_mut(|d| d.remove::<Preedit>(ime_preedit_id(viewport)));
 }
 
+/// Read this viewport's in-flight IME composition state.
 fn read_ime_composition(ui: &egui::Ui) -> Option<ImeComposition> {
     let viewport = ui.ctx().viewport_id();
     ui.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(viewport)))
 }
 
+/// Store this viewport's composition state, or remove it with `None`.
 fn set_ime_composition(ui: &egui::Ui, composition: Option<ImeComposition>) {
     let viewport = ui.ctx().viewport_id();
     ui.data_mut(|d| match composition {
@@ -427,6 +482,7 @@ fn sync_ime_target(ui: &egui::Ui, app: &EffectcraftApp) {
     ui.data_mut(|d| d.insert_temp(ime_target_seen_id(viewport), current));
 }
 
+/// The active text edit's owner, anchor and caret, or `None` when no editor is open.
 fn ime_selection(app: &EffectcraftApp) -> Option<ImeSelection> {
     let edit = app.session.state.text_edit.as_ref()?;
     Some(ImeSelection { owner: ime_owner(app)?, anchor: edit.anchor, caret: edit.caret })
@@ -458,6 +514,7 @@ fn sync_ime_selection(ui: &egui::Ui, app: &EffectcraftApp) {
     remember_ime_selection(ui, app);
 }
 
+/// Truncate a pre-edit preview to `MAX_IME_TEXT_BYTES` on a character boundary, so no character is split.
 fn bounded_preedit(mut text: String) -> String {
     if text.len() > MAX_IME_TEXT_BYTES {
         let mut end = MAX_IME_TEXT_BYTES;
@@ -469,6 +526,7 @@ fn bounded_preedit(mut text: String) -> String {
     text
 }
 
+/// Read this viewport's visible pre-edit preview, whatever owner it belongs to.
 fn read_preedit(ui: &egui::Ui) -> Option<Preedit> {
     let viewport = ui.ctx().viewport_id();
     ui.data(|d| d.get_temp::<Preedit>(ime_preedit_id(viewport)))
@@ -495,17 +553,19 @@ fn ime_event_is_stale(ui: &egui::Ui, owner: ImeOwner) -> bool {
     }
 }
 
+/// The pre-edit text to draw, only when it belongs to the current edit owner and is non-empty.
 fn visible_preedit(ui: &egui::Ui, app: &EffectcraftApp) -> Option<String> {
     let owner = ime_owner(app)?;
     let p = read_preedit(ui)?;
     (p.owner == owner && !p.text.is_empty()).then_some(p.text)
 }
 
-/// Publish the settled descriptor for one completed viewport pass.
+/// Publish the descriptor from this viewport's current text state and recorded geometry.
 ///
-/// This runs at the very end of a root pass (after dock actions, ScriptUI, learn and dialogs)
-/// and at the end of each panel-window pass after that window's actions. The overlay only
-/// records geometry; it never publishes early with a snapshot that a later action can replace.
+/// The root viewport publishes after dock actions, ScriptUI, learn and dialogs. Native panel
+/// windows publish after the IME-owning body records geometry and again after their last body;
+/// publication can therefore precede later bodies in that window. The overlay only records
+/// geometry; this function resolves the current owner and availability when it publishes.
 pub(crate) fn finish_ime(app: &mut EffectcraftApp, ui: &egui::Ui) {
     let ctx = ui.ctx();
     let viewport = ctx.viewport_id();
@@ -750,6 +810,91 @@ fn typing_key(ui: &egui::Ui, bump: bool) -> String {
     format!("text-typing-{n}")
 }
 
+/// A press inside the edited text layer: grab a box handle, place the caret (shift extends from
+/// `shift_anchor`), or, outside the text, commit the edit. Returns the drag it starts, if any.
+fn press_on_edited(app: &mut EffectcraftApp, ui: &egui::Ui, map: &ViewerMap, e: &Edited, pos: Pos2, shift_anchor: Option<usize>) -> Option<Drag> {
+    if let Some(h) = e.handles().iter().position(|h| e.to_screen(map, *h).distance(pos) < 7.0) {
+        let b = e.doc.box_size.unwrap_or([0.0; 2]);
+        return Some(Drag::Resize { layer: e.layer.id, handle: h, start_box: [e.doc.box_pos[0], e.doc.box_pos[1], b[0], b[1]] });
+    }
+    if e.contains(map, pos) {
+        let ci = e.hit(map, pos);
+        exec(app, "text.setSelection", json!({"anchor": shift_anchor.unwrap_or(ci), "caret": ci}));
+        typing_key(ui, true);
+        return Some(Drag::Select { layer: e.layer.id });
+    }
+    // Clicking elsewhere commits the edit.
+    exec(app, "text.endEdit", json!({}));
+    None
+}
+
+/// A press with the Type tool that missed the edited text: edit the text layer under it, or
+/// start creating a new one.
+fn press_type_tool(app: &mut EffectcraftApp, ectx: &EvalCtx, map: &ViewerMap, pos: Pos2, tool: Tool) -> Drag {
+    if let Some(e) = text_layer_at(app, ectx, map, pos, true) {
+        let ci = e.hit(map, pos);
+        exec(app, "text.edit", json!({"layer": e.layer.id.0, "caret": ci}));
+        Drag::Select { layer: e.layer.id }
+    } else {
+        Drag::Create { start: map.to_comp(pos), vertical: tool == Tool::TypeVertical }
+    }
+}
+
+/// The paragraph box after dragging `handle` by (`dx`, `dy`) in layer space.
+fn resized_box(start_box: [f64; 4], handle: usize, dx: f64, dy: f64) -> [f64; 4] {
+    let [mut x0, mut y0, w, h] = start_box;
+    let (mut x1, mut y1) = (x0 + w, y0 + h);
+    if matches!(handle, 0 | 6 | 7) {
+        x0 += dx;
+    }
+    if matches!(handle, 2..=4) {
+        x1 += dx;
+    }
+    if matches!(handle, 0..=2) {
+        y0 += dy;
+    }
+    if matches!(handle, 4..=6) {
+        y1 += dy;
+    }
+    [x0.min(x1), y0.min(y1), (x1 - x0).abs().max(4.0), (y1 - y0).abs().max(4.0)]
+}
+
+/// Keyboard routing for the text editor: while a session is live, keep the focus on it and feed
+/// it this frame's keys; otherwise release the IME and the focus.
+fn keyboard_focus(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
+    if app.session.state.text_edit.is_some() && app.dialog.is_none() && ui.is_enabled() {
+        // Register after pointer handling so new edits take focus in this frame. An inactive
+        // editor must not take Tab focus and immediately surrender it before viewer controls.
+        ui.interact(Rect::from_min_size(rect.min, vec2(1.0, 1.0)), focus_id(), egui::Sense::focusable_noninteractive());
+        ui.memory_mut(|m| {
+            m.set_focus_lock_filter(focus_id(), egui::EventFilter { tab: true, horizontal_arrows: true, vertical_arrows: true, escape: true });
+        });
+        // A session started elsewhere (menu, agent, Properties) takes the keyboard once…
+        let seen = ime_seen_id(ui.ctx().viewport_id());
+        let key = app.session.state.text_edit.as_ref().map(|e| (e.layer.0, e.session));
+        // …and gets it back when a click in the viewer or a formatting panel left nothing holding
+        // it; not merely because nothing has the focus (#831).
+        let regain = ui.memory(|m| m.focused().is_none()) && keeps_text_edit(app.ui.focused);
+        if ui.data(|d| d.get_temp::<Option<(u64, u64)>>(seen)).flatten() != key || regain {
+            ui.data_mut(|d| d.insert_temp(seen, key));
+            ui.memory_mut(|m| m.request_focus(focus_id()));
+        }
+        if ui.memory(|m| m.has_focus(focus_id())) {
+            keyboard(app, ui, rect);
+        }
+    } else {
+        // Resolve the viewport before taking the data lock: `viewport_id()`
+        // acquires the same context lock that `data_mut` holds.
+        let viewport = ui.ctx().viewport_id();
+        ui.data_mut(|d| d.insert_temp::<Option<(u64, u64)>>(ime_seen_id(viewport), None));
+        invalidate_ime_composition(ui, app);
+        clear_preedit(ui);
+        if ui.memory(|m| m.has_focus(focus_id())) {
+            ui.memory_mut(|m| m.surrender_focus(focus_id()));
+        }
+    }
+}
+
 /// Viewer hook: draws the edit overlay and handles text pointer and keyboard input. Returns
 /// true when it owns this frame's pointer interaction (the viewer then skips its own gestures).
 pub fn hook(
@@ -798,7 +943,6 @@ pub fn hook(
         }
     });
     let pointer = ui.input(|i| i.pointer.interact_pos());
-    let handle_hit = |e: &Edited, s: Pos2| e.handles().iter().position(|h| e.to_screen(map, *h).distance(s) < 7.0);
 
     // ---- press
     if pressed
@@ -810,30 +954,14 @@ pub fn hook(
     {
         let mut handled = false;
         if let Some(e) = &cur {
-            if let Some(h) = handle_hit(e, pos) {
-                let b = e.doc.box_size.unwrap_or([0.0; 2]);
-                drag = Some(Drag::Resize { layer: e.layer.id, handle: h, start_box: [e.doc.box_pos[0], e.doc.box_pos[1], b[0], b[1]] });
+            let shift_anchor = if mods.shift { Some(editing.as_ref().map_or_else(|| e.hit(map, pos), |sel| sel.anchor)) } else { None };
+            if let Some(d) = press_on_edited(app, ui, map, e, pos, shift_anchor) {
+                drag = Some(d);
                 handled = true;
-            } else if e.contains(map, pos) {
-                let ci = e.hit(map, pos);
-                let anchor = if mods.shift { editing.as_ref().map_or(ci, |sel| sel.anchor) } else { ci };
-                exec(app, "text.setSelection", json!({"anchor": anchor, "caret": ci}));
-                typing_key(ui, true);
-                drag = Some(Drag::Select { layer: e.layer.id });
-                handled = true;
-            } else {
-                // Clicking elsewhere commits the edit.
-                exec(app, "text.endEdit", json!({}));
             }
         }
         if !handled && type_tool {
-            if let Some(e) = text_layer_at(app, ectx, map, pos, true) {
-                let ci = e.hit(map, pos);
-                exec(app, "text.edit", json!({"layer": e.layer.id.0, "caret": ci}));
-                drag = Some(Drag::Select { layer: e.layer.id });
-            } else {
-                drag = Some(Drag::Create { start: map.to_comp(pos), vertical: tool == Tool::TypeVertical });
-            }
+            drag = Some(press_type_tool(app, ectx, map, pos, tool));
             handled = true;
         }
         if handled {
@@ -888,22 +1016,7 @@ pub fn hook(
             {
                 let (px, py) = e.to_layer(map, p);
                 let (qx, qy) = e.to_layer(map, q);
-                let (dx, dy) = (px - qx, py - qy);
-                let [mut x0, mut y0, w, h] = start_box;
-                let (mut x1, mut y1) = (x0 + w, y0 + h);
-                if matches!(handle, 0 | 6 | 7) {
-                    x0 += dx;
-                }
-                if matches!(handle, 2..=4) {
-                    x1 += dx;
-                }
-                if matches!(handle, 0..=2) {
-                    y0 += dy;
-                }
-                if matches!(handle, 4..=6) {
-                    y1 += dy;
-                }
-                let bx = [x0.min(x1), y0.min(y1), (x1 - x0).abs().max(4.0), (y1 - y0).abs().max(4.0)];
+                let bx = resized_box(start_box, handle, px - qx, py - qy);
                 exec(app, "layer.setText", json!({"layer": layer.0, "box": bx, "merge": format!("text-box-{}", layer.0)}));
             }
         }
@@ -949,37 +1062,7 @@ pub fn hook(
     // composition's identity as a stale guard before this pass's IME events are read.
     sync_ime_target(ui, app);
     sync_ime_selection(ui, app);
-    if app.session.state.text_edit.is_some() && app.dialog.is_none() && ui.is_enabled() {
-        // Register after pointer handling so new edits take focus in this frame. An inactive
-        // editor must not take Tab focus and immediately surrender it before viewer controls.
-        ui.interact(Rect::from_min_size(resp.rect.min, vec2(1.0, 1.0)), focus_id(), egui::Sense::focusable_noninteractive());
-        ui.memory_mut(|m| {
-            m.set_focus_lock_filter(focus_id(), egui::EventFilter { tab: true, horizontal_arrows: true, vertical_arrows: true, escape: true });
-        });
-        // A session started elsewhere (menu, agent, Properties) takes the keyboard once…
-        let seen = ime_seen_id(ui.ctx().viewport_id());
-        let key = app.session.state.text_edit.as_ref().map(|e| (e.layer.0, e.session));
-        // …and gets it back when a click in the viewer or a formatting panel left nothing holding
-        // it; not merely because nothing has the focus (#831).
-        let regain = ui.memory(|m| m.focused().is_none()) && keeps_text_edit(app.ui.focused);
-        if ui.data(|d| d.get_temp::<Option<(u64, u64)>>(seen)).flatten() != key || regain {
-            ui.data_mut(|d| d.insert_temp(seen, key));
-            ui.memory_mut(|m| m.request_focus(focus_id()));
-        }
-        if ui.memory(|m| m.has_focus(focus_id())) {
-            keyboard(app, ui, resp.rect);
-        }
-    } else {
-        // Resolve the viewport before taking the data lock: `viewport_id()`
-        // acquires the same context lock that `data_mut` holds.
-        let viewport = ui.ctx().viewport_id();
-        ui.data_mut(|d| d.insert_temp::<Option<(u64, u64)>>(ime_seen_id(viewport), None));
-        invalidate_ime_composition(ui, app);
-        clear_preedit(ui);
-        if ui.memory(|m| m.has_focus(focus_id())) {
-            ui.memory_mut(|m| m.surrender_focus(focus_id()));
-        }
-    }
+    keyboard_focus(app, ui, resp.rect);
 
     // ---- overlay
     if let Some(s) = app.session.state.text_edit.clone()
@@ -1159,111 +1242,7 @@ fn keyboard(app: &mut EffectcraftApp, ui: &mut egui::Ui, viewer: Rect) {
                 }
                 typing_key(ui, true);
             }
-            egui::Event::Key { key, pressed: true, modifiers: m, .. } => {
-                use egui::Key;
-                let cmd = m.command;
-                let mv = |app: &mut EffectcraftApp, to: &str| {
-                    exec(app, "text.moveCaret", json!({"to": to, "extend": m.shift}));
-                };
-                match key {
-                    Key::ArrowLeft | Key::ArrowRight if m.alt => {
-                        // Kerning at the caret, tracking over a selection.
-                        let step = if cmd { 100.0 } else { 20.0 } * if key == Key::ArrowLeft { -1.0 } else { 1.0 };
-                        let doc = layer_doc(&app.session, sel.layer).unwrap_or_default();
-                        if sel.is_empty() {
-                            if sel.caret < doc.char_len() {
-                                let cur = match doc.style_at(sel.caret).kerning {
-                                    Kerning::Manual(v) => v,
-                                    _ => 0.0,
-                                };
-                                exec(
-                                    app,
-                                    "layer.setText",
-                                    json!({"layer": sel.layer.0, "range": [sel.caret, sel.caret + 1], "kerning": cur + step, "merge": format!("text-kern-{}", sel.caret)}),
-                                );
-                            }
-                        } else {
-                            let r = sel.range();
-                            let cur = doc.style_at(r.start).tracking;
-                            exec(app, "layer.setText", json!({"layer": sel.layer.0, "range": [r.start, r.end], "tracking": cur + step, "merge": "text-track"}));
-                        }
-                    }
-                    Key::ArrowLeft => mv(app, if cmd { "wordLeft" } else { "left" }),
-                    Key::ArrowRight => mv(app, if cmd { "wordRight" } else { "right" }),
-                    Key::ArrowUp => mv(app, if cmd { "paraUp" } else { "up" }),
-                    Key::ArrowDown => mv(app, if cmd { "paraDown" } else { "down" }),
-                    Key::Home => mv(app, if cmd { "start" } else { "lineStart" }),
-                    Key::End => mv(app, if cmd { "end" } else { "lineEnd" }),
-                    Key::Backspace => {
-                        let k = typing_key(ui, false);
-                        let before = ime_stamp(app, &ctx);
-                        if exec(app, "text.delete", json!({"word": cmd || m.alt, "merge": k})).is_some() {
-                            note_ime_application_edit(app, &ctx, before);
-                        }
-                    }
-                    Key::Delete => {
-                        let k = typing_key(ui, false);
-                        let before = ime_stamp(app, &ctx);
-                        if exec(app, "text.delete", json!({"direction": "forward", "word": cmd || m.alt, "merge": k})).is_some() {
-                            note_ime_application_edit(app, &ctx, before);
-                        }
-                    }
-                    Key::Enter if cmd => {
-                        exec(app, "text.endEdit", json!({}));
-                    }
-                    Key::Enter => {
-                        let k = typing_key(ui, false);
-                        let before = ime_stamp(app, &ctx);
-                        if exec(app, "text.insert", json!({"text": "\n", "merge": k})).is_some() {
-                            note_ime_application_edit(app, &ctx, before);
-                        }
-                    }
-                    Key::Tab => {
-                        let k = typing_key(ui, false);
-                        let before = ime_stamp(app, &ctx);
-                        if exec(app, "text.insert", json!({"text": "\t", "merge": k})).is_some() {
-                            note_ime_application_edit(app, &ctx, before);
-                        }
-                    }
-                    Key::Escape => {
-                        exec(app, "text.endEdit", json!({}));
-                    }
-                    // The editor owns exactly Cmd/Ctrl+A (Select All) and Cmd/Ctrl+Z with or
-                    // without Shift (Undo, Redo). Other modifiers on those keys aren't editing
-                    // chords, so they fall through to the binding match below: Shift+A is
-                    // Deselect All's default, and Alt variants are free for a rebound one.
-                    Key::A if cmd && !m.shift && !m.alt => {
-                        exec(app, "text.setSelection", json!({"select": "all"}));
-                    }
-                    Key::Z if cmd && !m.alt => {
-                        let before = ime_stamp(app, &ctx);
-                        if crate::menus::invoke(app, &ctx, if m.shift { "edit.redo" } else { "edit.undo" }, json!({})).is_ok() {
-                            note_ime_application_edit(app, &ctx, before);
-                        }
-                    }
-                    Key::Comma | Key::Period if cmd && m.shift => {
-                        let doc = layer_doc(&app.session, sel.layer).unwrap_or_default();
-                        let r = sel.range();
-                        let size = sel.pending.as_ref().map_or_else(|| doc.style_at(r.start).size, |p| p.size);
-                        let ns = (size + if key == Key::Period { 2.0 } else { -2.0 }).max(1.0);
-                        exec(app, "layer.setText", json!({"layer": sel.layer.0, "range": [r.start, r.end], "size": ns}));
-                    }
-                    // The app-wide shortcut dispatcher is skipped while this editor holds the
-                    // keyboard, so the Deselect All chord (Cmd/Ctrl+Shift+A or F2 by default)
-                    // must be matched here and run through the command dispatcher like undo
-                    // above. Matching the command's current binding, not a fixed key, keeps
-                    // rebound shortcuts working and gives every route one final state; the
-                    // forwarding test also refuses chords a focused editor must never surrender
-                    // (see `forwardable_during_text_edit`).
-                    _ if crate::menus::chord_matches(&app.session, "edit.deselectAll", key, m) && crate::menus::forwardable_during_text_edit(m, key) => {
-                        let _ = crate::menus::invoke(app, &ctx, "edit.deselectAll", json!({}));
-                    }
-                    _ => {}
-                }
-                if !matches!(key, Key::Backspace | Key::Delete | Key::Enter | Key::Tab) {
-                    typing_key(ui, true);
-                }
-            }
+            egui::Event::Key { key, pressed: true, modifiers: m, .. } => key_event(app, ui, &ctx, &sel, key, m),
             _ => {}
         }
         let route_ended = app.session.state.text_edit.is_none() || app.dialog.is_some();
@@ -1284,6 +1263,125 @@ fn keyboard(app: &mut EffectcraftApp, ui: &mut egui::Ui, viewer: Rect) {
     }
 }
 
+/// An application key press in the edited text: caret moves, deletes, insertions, formatting and
+/// the editor's own chords.
+fn key_event(
+    app: &mut EffectcraftApp,
+    ui: &egui::Ui,
+    ctx: &egui::Context,
+    sel: &effectcraft_engine::commands::text_edit::TextEdit,
+    key: egui::Key,
+    m: egui::Modifiers,
+) {
+    use egui::Key;
+    let cmd = m.command;
+    let mv = |app: &mut EffectcraftApp, to: &str| {
+        exec(app, "text.moveCaret", json!({"to": to, "extend": m.shift}));
+    };
+    match key {
+        Key::ArrowLeft | Key::ArrowRight if m.alt => {
+            // Kerning at the caret, tracking over a selection.
+            let step = if cmd { 100.0 } else { 20.0 } * if key == Key::ArrowLeft { -1.0 } else { 1.0 };
+            let doc = layer_doc(&app.session, sel.layer).unwrap_or_default();
+            if sel.is_empty() {
+                if sel.caret < doc.char_len() {
+                    let cur = match doc.style_at(sel.caret).kerning {
+                        Kerning::Manual(v) => v,
+                        _ => 0.0,
+                    };
+                    exec(
+                        app,
+                        "layer.setText",
+                        json!({"layer": sel.layer.0, "range": [sel.caret, sel.caret + 1], "kerning": cur + step, "merge": format!("text-kern-{}", sel.caret)}),
+                    );
+                }
+            } else {
+                let r = sel.range();
+                let cur = doc.style_at(r.start).tracking;
+                exec(app, "layer.setText", json!({"layer": sel.layer.0, "range": [r.start, r.end], "tracking": cur + step, "merge": "text-track"}));
+            }
+        }
+        Key::ArrowLeft => mv(app, if cmd { "wordLeft" } else { "left" }),
+        Key::ArrowRight => mv(app, if cmd { "wordRight" } else { "right" }),
+        Key::ArrowUp => mv(app, if cmd { "paraUp" } else { "up" }),
+        Key::ArrowDown => mv(app, if cmd { "paraDown" } else { "down" }),
+        Key::Home => mv(app, if cmd { "start" } else { "lineStart" }),
+        Key::End => mv(app, if cmd { "end" } else { "lineEnd" }),
+        Key::Backspace => {
+            let k = typing_key(ui, false);
+            let before = ime_stamp(app, ctx);
+            if exec(app, "text.delete", json!({"word": cmd || m.alt, "merge": k})).is_some() {
+                note_ime_application_edit(app, ctx, before);
+            }
+        }
+        Key::Delete => {
+            let k = typing_key(ui, false);
+            let before = ime_stamp(app, ctx);
+            if exec(app, "text.delete", json!({"direction": "forward", "word": cmd || m.alt, "merge": k})).is_some() {
+                note_ime_application_edit(app, ctx, before);
+            }
+        }
+        Key::Enter if cmd => {
+            exec(app, "text.endEdit", json!({}));
+        }
+        Key::Enter => {
+            let k = typing_key(ui, false);
+            let before = ime_stamp(app, ctx);
+            if exec(app, "text.insert", json!({"text": "\n", "merge": k})).is_some() {
+                note_ime_application_edit(app, ctx, before);
+            }
+        }
+        Key::Tab => {
+            let k = typing_key(ui, false);
+            let before = ime_stamp(app, ctx);
+            if exec(app, "text.insert", json!({"text": "\t", "merge": k})).is_some() {
+                note_ime_application_edit(app, ctx, before);
+            }
+        }
+        Key::Escape => {
+            exec(app, "text.endEdit", json!({}));
+        }
+        // The editor owns exactly Cmd/Ctrl+A (Select All) and Cmd/Ctrl+Z with or
+        // without Shift (Undo, Redo). Other modifiers on those keys aren't editing
+        // chords, so they fall through to the binding match below: Shift+A is
+        // Deselect All's default, and Alt variants are free for a rebound one.
+        Key::A if cmd && !m.shift && !m.alt => {
+            exec(app, "text.setSelection", json!({"select": "all"}));
+        }
+        Key::Z if cmd && !m.alt => {
+            let before = ime_stamp(app, ctx);
+            if crate::menus::invoke(app, ctx, if m.shift { "edit.redo" } else { "edit.undo" }, json!({})).is_ok() {
+                note_ime_application_edit(app, ctx, before);
+            }
+        }
+        Key::Comma | Key::Period if cmd && m.shift => {
+            let doc = layer_doc(&app.session, sel.layer).unwrap_or_default();
+            let r = sel.range();
+            let size = sel.pending.as_ref().map_or_else(|| doc.style_at(r.start).size, |p| p.size);
+            let ns = (size + if key == Key::Period { 2.0 } else { -2.0 }).max(1.0);
+            exec(app, "layer.setText", json!({"layer": sel.layer.0, "range": [r.start, r.end], "size": ns}));
+        }
+        // The app-wide shortcut dispatcher is skipped while this editor holds the
+        // keyboard, so commands that end the edit by moving the selection — Deselect
+        // All (Cmd/Ctrl+Shift+A or F2 by default) and Duplicate (Cmd/Ctrl+D) — must be
+        // matched here and run through the command dispatcher like undo above.
+        // Matching each command's current binding, not a fixed key, keeps rebound
+        // shortcuts working and gives every route one final state; a chord bound to
+        // both commands resolves in list order. The forwarding test also refuses
+        // chords a focused editor must never surrender (see
+        // `forwardable_during_text_edit`).
+        _ if crate::menus::forwardable_during_text_edit(m, key)
+            && let Some(cmd_id) = ["edit.deselectAll", "edit.duplicate"].into_iter().find(|id| crate::menus::chord_matches(&app.session, id, key, m)) =>
+        {
+            let _ = crate::menus::invoke(app, ctx, cmd_id, json!({}));
+        }
+        _ => {}
+    }
+    if !matches!(key, Key::Backspace | Key::Delete | Key::Enter | Key::Tab) {
+        typing_key(ui, true);
+    }
+}
+
 /// Delete the text an IME marks for replacement around the editor's selection.
 ///
 /// `before`/`after` count UTF-8 bytes (`DeleteSurroundingBytes`, what winit reports) or
@@ -1298,6 +1396,9 @@ fn ime_delete(app: &mut EffectcraftApp, ui: &egui::Ui, before: usize, after: usi
     exec(app, "text.deleteSurrounding", json!({"before": before, "after": after, "bytes": bytes, "merge": k})).is_some()
 }
 
+/// Paint the paragraph box and handles, selection, caret or pre-edit for `e`; register the editor's and box handles'
+/// automation regions; request the caret-blink repaint; and record the pass's text and caret rectangles for the IME
+/// finalizer.
 fn draw(app: &mut EffectcraftApp, ui: &mut egui::Ui, painter: &egui::Painter, map: &ViewerMap, e: &Edited, sel: std::ops::Range<usize>, caret: usize) {
     let t = app.tokens;
     let to_s = |p: Point| e.to_screen(map, (p.x, p.y));
@@ -1352,7 +1453,7 @@ fn draw(app: &mut EffectcraftApp, ui: &mut egui::Ui, painter: &egui::Painter, ma
     let rect = Rect::from_points(&quad);
     app.auto.add("viewer.textEdit", rect, &format!("Editing {}", e.layer.name));
     let cursor_rect = Rect::from_two_pos(sa, sb).expand2(vec2(1.0, 0.0));
-    // The outgoing IME descriptor is published by the pass-end finalizer, with this actual
+    // The viewport IME publisher uses this actual
     // caret geometry and the edited layer's committed `TextDoc` (never the bidi or pre-edit
     // display text). An available-empty document stays distinct from unavailable.
     let viewport = ui.ctx().viewport_id();
@@ -1361,736 +1462,4 @@ fn draw(app: &mut EffectcraftApp, ui: &mut egui::Ui, painter: &egui::Painter, ma
 }
 
 #[cfg(test)]
-mod tests {
-    //! Incoming IME edits on the custom text editor (the Type tool's own session, not a stock
-    //! `TextEdit`). Winit reports the bytes around the selection *before* the commit it belongs
-    //! to, so the deletion and the insert must share one undo step.
-
-    use super::*;
-    use effectcraft_engine::Session;
-    use effectcraft_engine::commands::text_edit::TextEdit;
-    use serde_json::json;
-
-    fn editor(text: &str, anchor: usize, caret: usize) -> (EffectcraftApp, LayerId) {
-        let mut s = Session::default();
-        s.execute("comp.new", json!({"name": "IME", "width": 160, "height": 90, "duration": 1})).unwrap();
-        let layer = s.execute("layer.newText", json!({"text": text})).unwrap()["layer"].as_u64().unwrap();
-        let lid = LayerId(layer);
-        s.state.text_edit = Some(TextEdit { layer: lid, anchor, caret, ..Default::default() });
-        (EffectcraftApp::new(s), lid)
-    }
-
-    fn doc_text(app: &EffectcraftApp, lid: LayerId) -> String {
-        layer_doc(&app.session, lid).map(|d| d.text).unwrap_or_default()
-    }
-
-    fn feed(app: &mut EffectcraftApp, events: Vec<egui::Event>) {
-        let ctx = egui::Context::default();
-        let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0))), events, ..Default::default() };
-        let mut out = ctx.run_ui(raw, |ui| keyboard(app, ui, egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0))));
-        out.textures_delta.clear();
-    }
-
-    #[test]
-    fn preedit_preview_is_bounded_on_a_character_boundary() {
-        let text = "é".repeat(MAX_IME_TEXT_BYTES);
-        let capped = bounded_preedit(text);
-        assert!(capped.len() <= MAX_IME_TEXT_BYTES);
-        assert!(capped.is_char_boundary(capped.len()));
-        assert_eq!(capped.len() % "é".len(), 0, "the cap never leaves half a character");
-    }
-
-    /// Ending the edit from another panel clears this viewport's pre-edit. The production path
-    /// used to resolve `viewport_id()` (a context read lock) inside `data_mut` (a write lock);
-    /// that nested context access deadlocked every pass that drew the viewer.
-    #[test]
-    fn ending_an_edit_from_another_panel_clears_the_preedit() {
-        let (mut app, lid) = editor("abc", 0, 0);
-        let session = app.session.state.text_edit.as_ref().map_or(1, |e| e.session);
-        let ctx = egui::Context::default();
-        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
-            let viewport = ui.ctx().viewport_id();
-            let preedit = Preedit { owner: ImeOwner { layer: lid, session }, text: "x".into() };
-            ui.data_mut(|d| d.insert_temp(ime_preedit_id(viewport), preedit));
-            panel_clicked(&mut app, ui.ctx(), PanelKind::Timeline);
-            let viewport = ui.ctx().viewport_id();
-            assert!(ui.data(|d| d.get_temp::<Preedit>(ime_preedit_id(viewport))).is_none(), "the ended edit leaves no preview behind");
-        });
-        out.textures_delta.clear();
-        assert!(app.session.state.text_edit.is_none(), "a click in the Timeline ends the text edit");
-    }
-
-    #[test]
-    fn ime_delete_surrounding_bytes_and_the_commit_are_one_undo_step() {
-        // "café😀": the last character is four bytes, so a byte-count deletion that treated bytes
-        // as characters would corrupt the document.
-        let (mut app, lid) = editor("café😀", 5, 5);
-        feed(
-            &mut app,
-            vec![
-                egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 4, after_bytes: 0 }),
-                egui::Event::Ime(egui::ImeEvent::Commit("X".into())),
-            ],
-        );
-        assert_eq!(doc_text(&app, lid), "caféX", "the emoji is replaced by the committed text");
-        app.session.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(doc_text(&app, lid), "café😀", "the replacement is one undo step");
-    }
-
-    #[test]
-    fn ime_delete_surrounding_chars_keeps_the_selection_for_the_commit() {
-        // Stock egui deletes the characters around the selection, not the selection itself: the
-        // commit that follows replaces "bcd", it does not insert next to a deleted document.
-        let (mut app, lid) = editor("abcdef", 1, 4);
-        feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 99 })]);
-        assert_eq!(doc_text(&app, lid), "bcd", "one character before and everything after go");
-        let sel = app.session.state.text_edit.clone().expect("editing continues");
-        assert_eq!(sel.range(), 0..3, "the selected text is still selected");
-        // A deletion-only batch (no commit) leaves "bcd", not an empty document.
-        app.session.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(doc_text(&app, lid), "abcdef", "clamped deletion is still one undo step");
-
-        // Delete surround + commit: the commit replaces the kept selection.
-        let (mut app, lid) = editor("abcdef", 1, 4);
-        feed(
-            &mut app,
-            vec![
-                egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 99 }),
-                egui::Event::Ime(egui::ImeEvent::Commit("XY".into())),
-            ],
-        );
-        assert_eq!(doc_text(&app, lid), "XY", "the commit replaces the selection");
-        app.session.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(doc_text(&app, lid), "abcdef", "the deletion and its commit are one undo step");
-    }
-
-    /// One UI pass with the editor focused, events applied, and the overlay's observation.
-    struct ImePass {
-        ctx: egui::Context,
-        viewport: egui::ViewportId,
-        rect: egui::Rect,
-    }
-
-    impl ImePass {
-        fn new(viewport: egui::ViewportId) -> Self {
-            let ctx = egui::Context::default();
-            install_hooks(&ctx);
-            Self { ctx, viewport, rect: egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0)) }
-        }
-
-        /// Run one `Context` frame. `overlay` is false for a pass in which the viewer (and so
-        /// the edit overlay) never drew; `discard` forces a second pass of the same frame.
-        fn frame(&mut self, app: &mut EffectcraftApp, events: Vec<egui::Event>, overlay: bool, discard: bool) -> Option<egui::output::IMEOutput> {
-            let ctx = self.ctx.clone();
-            let rect = self.rect;
-            let viewport = self.viewport;
-            let mut viewports = egui::ViewportIdMap::default();
-            viewports.insert(self.viewport, egui::ViewportInfo::default());
-            let raw = egui::RawInput { viewport_id: self.viewport, viewports, screen_rect: Some(rect), events, ..Default::default() };
-            let mut asked = false;
-            let mut out = ctx.run_ui(raw, |ui| {
-                begin_ui(ui.ctx());
-                ui.interact(rect, focus_id(), egui::Sense::focusable_noninteractive());
-                ui.memory_mut(|m| m.request_focus(focus_id()));
-                sync_ime_target(ui, app);
-                keyboard(app, ui, rect);
-                if overlay {
-                    let pass = ui.ctx().cumulative_pass_nr_for(viewport);
-                    ui.data_mut(|d| d.insert_temp(ime_geometry_id(viewport), (pass, rect, rect)));
-                }
-                finish_ime(app, ui);
-                if discard && !asked {
-                    asked = true;
-                    ui.ctx().request_discard("ime pass test");
-                }
-            });
-            out.textures_delta.clear();
-            out.platform_output.ime
-        }
-    }
-
-    fn ime_text(ime: &egui::output::IMEOutput) -> (&str, usize, usize) {
-        let p = ime.surrounding_text.available().expect("committed surrounding text");
-        (p.text.as_str(), p.cursor, p.anchor)
-    }
-
-    #[test]
-    fn discarded_custom_request_then_home_rearms_the_identical_caret() {
-        let (mut app, lid) = editor("abcd", 4, 4);
-        app.ui.start_screen = false;
-        app.ui.tool = Tool::Type;
-        app.ui.focused = PanelKind::Composition;
-        let ctx = egui::Context::default();
-        install_hooks(&ctx);
-        let mut frame = eframe::Frame::_new_kittest();
-        let raw = || egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 800.0))), ..Default::default() };
-        for _ in 0..3 {
-            let mut output = ctx.run_ui(raw(), |ui| {
-                eframe::App::logic(&mut app, ui.ctx(), &mut frame);
-                app.draw(ui, &frame);
-            });
-            output.textures_delta.clear();
-        }
-        let mut input = raw();
-        input.events.push(egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None }));
-        let mut output = ctx.run_ui(input, |ui| {
-            eframe::App::logic(&mut app, ui.ctx(), &mut frame);
-            app.draw(ui, &frame);
-        });
-        output.textures_delta.clear();
-        assert!(output.platform_output.ime.is_some());
-        app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();
-        let selection = app.session.state.text_edit.clone();
-        let mut passes = 0;
-        let mut discarded = None;
-        let mut output = ctx.run_ui(raw(), |ui| {
-            passes += 1;
-            if passes > 1 {
-                app.ui.start_screen = true;
-            }
-            eframe::App::logic(&mut app, ui.ctx(), &mut frame);
-            app.draw(ui, &frame);
-            if passes == 1 {
-                assert!(ui.ctx().output(|output| output.ime.is_some()));
-                discarded = read_reset(ui.ctx()).and_then(|guard| guard.request);
-                ui.ctx().request_discard("custom IME descriptor discarded before Home");
-            }
-        });
-        output.textures_delta.clear();
-        assert!(passes >= 2);
-        let first = discarded.expect("the actual discarded custom pass requested a fence");
-        assert!(output.platform_output.ime.is_none());
-        assert!(read_reset(&ctx).unwrap().suspended);
-        assert!(read_reset(&ctx).unwrap().request.is_none());
-        assert_eq!(app.session.state.text_edit, selection, "Home did not move the model caret");
-        app.ui.start_screen = false;
-        let mut output = ctx.run_ui(raw(), |ui| {
-            eframe::App::logic(&mut app, ui.ctx(), &mut frame);
-            app.draw(ui, &frame);
-        });
-        output.textures_delta.clear();
-        let second = output.platform_output.ime.unwrap().reset_request.expect("same caret reactivation publishes a new real ID");
-        assert_ne!(first, second);
-        let mut output = ctx.run_ui(raw(), |ui| {
-            eframe::App::logic(&mut app, ui.ctx(), &mut frame);
-            app.draw(ui, &frame);
-        });
-        output.textures_delta.clear();
-        assert!(output.platform_output.ime.unwrap().reset_request.is_none());
-        let mut input = raw();
-        input.events.extend([
-            egui::Event::ImeResetCompleted { request_id: first },
-            egui::Event::Ime(egui::ImeEvent::Commit("X".into())),
-            egui::Event::ImeResetCompleted { request_id: second },
-            egui::Event::Ime(egui::ImeEvent::Preedit { text: "が".into(), active_range_chars: None }),
-            egui::Event::Ime(egui::ImeEvent::Commit("が".into())),
-        ]);
-        let mut output = ctx.run_ui(input, |ui| {
-            eframe::App::logic(&mut app, ui.ctx(), &mut frame);
-            app.draw(ui, &frame);
-        });
-        output.textures_delta.clear();
-        assert_eq!(doc_text(&app, lid), "aがbcd");
-    }
-
-    #[test]
-    fn viewport_fences_and_duplicate_completion_keep_their_exact_lifetime() {
-        let (mut app, lid) = editor("abcd", 4, 4);
-        let mut root = ImePass::new(egui::ViewportId::ROOT);
-        let mut detached = ImePass::new(egui::ViewportId::from_hash_of("effect-ime-detached"));
-        let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });
-        root.frame(&mut app, vec![preview()], true, false);
-        detached.frame(&mut app, vec![preview()], true, false);
-        app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();
-        let first = root.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();
-        let second = detached.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();
-        assert_ne!(first, second);
-        detached.frame(&mut app, vec![egui::Event::ImeResetCompleted { request_id: first }, egui::Event::Ime(egui::ImeEvent::Commit("X".into()))], true, false);
-        assert_eq!(doc_text(&app, lid), "abcd");
-        let pending = detached.ctx.data(|data| data.get_temp::<ResetGuard>(reset_id(detached.viewport))).unwrap().request;
-        assert_eq!(pending, Some(second), "a root marker cannot release the detached viewport's full ID");
-        let output = detached
-            .frame(
-                &mut app,
-                vec![
-                    egui::Event::ImeResetCompleted { request_id: second },
-                    preview(),
-                    egui::Event::ImeResetCompleted { request_id: second },
-                    egui::Event::Ime(egui::ImeEvent::Commit("が".into())),
-                ],
-                true,
-                false,
-            )
-            .unwrap();
-        assert_eq!(doc_text(&app, lid), "aがbcd");
-        assert!(output.reset_request.is_none(), "a duplicate control cannot reconstruct the cleared guard");
-        // An actual context-generation change at unchanged selection still supersedes a wait.
-        root.frame(&mut app, vec![], true, false);
-        let replaced = root.frame(&mut app, vec![], false, false);
-        assert!(replaced.is_none());
-        let replacement = root.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();
-        assert_ne!(first, replacement);
-    }
-
-    #[test]
-    fn ime_descriptor_sends_committed_text_and_preserves_a_reversed_selection() {
-        let (mut app, _) = editor("café😀", 2, 5);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        let first = pass.frame(&mut app, vec![], true, false).expect("the focused editor owns IME");
-        assert_eq!(first.owner, ime_target(&app).expect("an edit target").owner);
-        assert!(first.context_generation > 0);
-        assert_eq!(ime_text(&first), ("café😀", 9, 2), "UTF-8 bytes, with the caret's direction kept");
-        assert_eq!(first.change_cause, egui::ImeChangeCause::Other, "starting a context is application origin");
-        assert_eq!((first.rect, first.cursor_rect), (pass.rect, pass.rect), "the real caret geometry");
-
-        let again = pass.frame(&mut app, vec![], true, false).expect("still editing");
-        assert_eq!(again.context_generation, first.context_generation, "an unchanged pass keeps the context");
-        assert_eq!(again.surrounding_text, first.surrounding_text);
-    }
-
-    #[test]
-    fn accepted_ime_commit_is_input_method_and_ordinary_typing_is_other() {
-        let (mut app, lid) = editor("ab", 2, 2);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        let first = pass.frame(&mut app, vec![], true, false).expect("editing");
-        let generation = first.context_generation;
-
-        let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false).expect("still editing");
-        assert_eq!(doc_text(&app, lid), "ab日");
-        assert_eq!(ime_text(&commit), ("ab日", 5, 5));
-        assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod, "only the accepted commit earns it");
-        assert_eq!(commit.context_generation, generation, "an ordinary text change is not a new context");
-
-        let typed = pass.frame(&mut app, vec![egui::Event::Text("x".into())], true, false).expect("still editing");
-        assert_eq!(doc_text(&app, lid), "ab日x");
-        assert_eq!(typed.change_cause, egui::ImeChangeCause::Other, "typing is application work");
-        assert_eq!(typed.context_generation, generation);
-    }
-
-    #[test]
-    fn ime_delete_and_commit_chain_is_input_method_with_a_reversed_selection() {
-        let (mut app, lid) = editor("abcdef", 4, 1);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        pass.frame(&mut app, vec![], true, false).expect("editing");
-
-        let deleted = pass
-            .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 1 })], true, false)
-            .expect("still editing");
-        assert_eq!(doc_text(&app, lid), "bcdf", "one character goes before and one after the selection");
-        assert_eq!(ime_text(&deleted), ("bcdf", 0, 3), "the selected text and its reversed direction stay");
-        assert_eq!(deleted.change_cause, egui::ImeChangeCause::InputMethod);
-
-        let committed = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("X".into()))], true, false).expect("still editing");
-        assert_eq!(doc_text(&app, lid), "Xf", "the commit replaces the kept selection");
-        assert_eq!(committed.change_cause, egui::ImeChangeCause::InputMethod, "the delete and commit are one accepted chain");
-        app.session.execute("edit.undo", json!({})).unwrap();
-        assert_eq!(doc_text(&app, lid), "abcdef", "the replacement is one undo step");
-    }
-
-    #[test]
-    fn an_application_edit_in_the_same_frame_dominates_the_ime_cause() {
-        // Application edit before the IME commit.
-        let (mut app, lid) = editor("ab", 2, 2);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        pass.frame(&mut app, vec![], true, false).expect("editing");
-        let mixed = pass
-            .frame(&mut app, vec![egui::Event::Text("x".into()), egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false)
-            .expect("still editing");
-        assert_eq!(doc_text(&app, lid), "abx日");
-        assert_eq!(mixed.change_cause, egui::ImeChangeCause::Other, "the earlier application edit dominates");
-
-        // Application edit after the IME commit.
-        let (mut app, lid) = editor("ab", 2, 2);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        pass.frame(&mut app, vec![], true, false).expect("editing");
-        let mixed = pass
-            .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into())), egui::Event::Text("x".into())], true, false)
-            .expect("still editing");
-        assert_eq!(doc_text(&app, lid), "ab日x");
-        assert_eq!(mixed.change_cause, egui::ImeChangeCause::Other, "the later application edit dominates");
-    }
-
-    #[test]
-    fn preedit_is_excluded_from_the_committed_snapshot_and_keeps_the_context() {
-        let (mut app, lid) = editor("ab", 2, 2);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        let first = pass.frame(&mut app, vec![], true, false).expect("editing");
-
-        let preview = pass
-            .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)
-            .expect("still editing");
-        assert_eq!(doc_text(&app, lid), "ab", "the pre-edit never enters the document");
-        assert_eq!(ime_text(&preview), ("ab", 2, 2), "only committed text is sent");
-        assert_eq!(preview.context_generation, first.context_generation, "pre-edit updates keep the composition");
-
-        let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("に".into()))], true, false).expect("still editing");
-        assert_eq!(doc_text(&app, lid), "abに");
-        assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod, "clearing the pre-edit and committing is IME work");
-        assert_eq!(commit.context_generation, first.context_generation);
-    }
-
-    #[test]
-    fn empty_and_unavailable_surrounding_text_are_distinct() {
-        let (mut app, _) = editor("", 0, 0);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        let empty = pass.frame(&mut app, vec![], true, false).expect("editing");
-        assert_eq!(ime_text(&empty), ("", 0, 0), "an available-empty document is not unavailable");
-
-        let text = "a".repeat(5000);
-        let (mut app, _) = editor(&text, 0, 5000);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        let wide = pass.frame(&mut app, vec![], true, false).expect("editing");
-        assert!(matches!(wide.surrounding_text, egui::output::IMESurroundingText::Unavailable), "a selection wider than the limit is unavailable");
-        assert_eq!(wide.owner, ime_target(&app).expect("an edit target").owner, "identity survives unavailable text");
-    }
-
-    #[test]
-    fn an_unrelated_undo_keeps_a_wide_selection_composition() {
-        // A selection wider than the IME limit reports unavailable surrounding text, whose
-        // receipt identity is a revision. That revision must follow the editor, not the whole
-        // project: undoing an unrelated opacity change used to look like an editor mutation and
-        // cancel an active composition.
-        let text = "a".repeat(5000);
-        let (mut app, lid) = editor(&text, 0, 5000);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        let first = pass.frame(&mut app, vec![], true, false).expect("editing");
-        assert!(matches!(first.surrounding_text, egui::output::IMESurroundingText::Unavailable), "the wide selection is unavailable");
-
-        let composing = pass
-            .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)
-            .expect("still editing");
-        assert_eq!(composing.context_generation, first.context_generation, "the pre-edit keeps the context");
-        let owner = ime_owner(&app).expect("an editor owner");
-        assert!(matches!(
-            pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),
-            Some(ImeComposition::Active(active)) if active == owner
-        ));
-
-        app.session.execute("prop.set", json!({"layer": lid.0, "path": "transform/opacity", "value": 50})).unwrap();
-        app.session.execute("edit.undo", json!({})).unwrap();
-        let after = pass.frame(&mut app, vec![], true, false).expect("still editing");
-        assert_eq!(after.context_generation, first.context_generation, "an unrelated undo does not start a new context");
-        assert!(
-            matches!(
-                pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),
-                Some(ImeComposition::Active(active)) if active == owner
-            ),
-            "the wide-selection composition survives an unrelated undo"
-        );
-        assert!(read_reset(&pass.ctx).is_none(), "no IME reset was requested");
-
-        // The composition is still the live one: its commit is accepted and earns the
-        // input-method cause rather than being poisoned as leftover application work.
-        let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("x".into()))], true, false).expect("still editing");
-        assert_eq!(doc_text(&app, lid), "x", "the preserved composition commits into the wide selection");
-        assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod);
-    }
-
-    #[test]
-    fn a_failed_batch_with_a_transient_edit_does_not_revive_a_wide_selection_composition() {
-        // The final document equals the pre-batch one, but the intermediate insert/delete was a
-        // real document change. Its IME revision must stay the high-water mark; otherwise the
-        // active wide-selection composition would look current and accept its old commit.
-        let text = "a".repeat(5000);
-        let (mut app, lid) = editor(&text, 0, 5000);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        pass.frame(&mut app, vec![], true, false).expect("editing");
-        pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)
-            .expect("still editing");
-        let owner = ime_owner(&app).expect("an editor owner");
-        assert!(matches!(
-            pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),
-            Some(ImeComposition::Active(active)) if active == owner
-        ));
-
-        let r = app.session.execute(
-            "engine.batch",
-            json!({"atomic": true, "steps": [
-                {"command": "text.insert", "params": {"text": "x", "range": [5000, 5000]}},
-                {"command": "text.delete", "params": {}},
-                {"command": "no.suchCommand", "params": {}}
-            ]}),
-        );
-        assert!(r.is_err());
-        assert_eq!(doc_text(&app, lid), text, "the batch restored the final document");
-
-        pass.frame(&mut app, vec![], true, false).expect("still editing");
-        assert!(read_reset(&pass.ctx).is_some(), "the advanced revision retires the old IME context");
-        assert!(
-            matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),
-            "the failed batch's transient edit leaves the old composition stale"
-        );
-        let stale = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");
-        assert_eq!(doc_text(&app, lid), text, "the stale composition cannot commit into the restored document");
-        assert_ne!(stale.change_cause, egui::ImeChangeCause::InputMethod, "a rejected commit earns no IME receipt");
-    }
-
-    #[test]
-    fn a_wide_content_change_invalidates_the_active_composition() {
-        let text = "a".repeat(5000);
-        let (mut app, lid) = editor(&text, 0, 5000);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        pass.frame(&mut app, vec![], true, false).expect("editing");
-        pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)
-            .expect("still editing");
-
-        let replaced = "b".repeat(5000);
-        app.session.execute("layer.setText", json!({"layer": lid.0, "text": replaced})).unwrap();
-        let after = pass.frame(&mut app, vec![], true, false).expect("still editing");
-        assert_eq!(doc_text(&app, lid), replaced);
-        assert!(after.should_interrupt_composition, "replacing the wide document starts a new IME context");
-        assert!(
-            matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),
-            "the old composition is stale after the content change"
-        );
-        pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");
-        assert_eq!(doc_text(&app, lid), replaced, "a delayed commit from the old document is rejected");
-    }
-
-    #[test]
-    fn a_wide_selection_change_invalidates_the_active_composition() {
-        let text = "a".repeat(5000);
-        let (mut app, lid) = editor(&text, 0, 5000);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        pass.frame(&mut app, vec![], true, false).expect("editing");
-        pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)
-            .expect("still editing");
-
-        // Still wider than the IME window limit, so this exercises the unavailable-text
-        // selection identity rather than merely making the surrounding text available.
-        app.session.execute("text.setSelection", json!({"start": 0, "end": 4500})).unwrap();
-        pass.frame(&mut app, vec![], true, false).expect("still editing");
-        assert!(read_reset(&pass.ctx).is_some(), "an application selection change retires the composition");
-        assert!(
-            matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),
-            "the old composition cannot follow the selection"
-        );
-        pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");
-        assert_eq!(doc_text(&app, lid), text, "the stale composition cannot mutate the wide selection");
-    }
-
-    #[test]
-    fn replaced_edit_session_and_hidden_passes_start_a_new_context() {
-        let (mut app, _) = editor("text", 4, 4);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        let before = pass.frame(&mut app, vec![], true, false).expect("editing");
-        if let Some(edit) = app.session.state.text_edit.as_mut() {
-            edit.session = edit.session.wrapping_add(1);
-        }
-        let replaced = pass.frame(&mut app, vec![], true, false).expect("editing");
-        assert!(replaced.context_generation > before.context_generation, "a recreated target does not inherit the old context");
-        assert_eq!(replaced.change_cause, egui::ImeChangeCause::Other);
-        assert!(replaced.should_interrupt_composition, "a new replacement epoch cancels the platform composition");
-
-        let (mut app, _) = editor("abc", 3, 3);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        let visible = pass.frame(&mut app, vec![], true, false).expect("editing");
-        assert!(pass.frame(&mut app, vec![], false, false).is_none(), "a hidden editor reports no IME owner");
-        let back = pass.frame(&mut app, vec![], true, false).expect("editing again");
-        assert!(back.context_generation > visible.context_generation, "reappearing starts exactly one new context");
-    }
-
-    #[test]
-    fn preedit_from_a_replaced_target_cannot_commit_into_the_new_session() {
-        let (mut app, first) = editor("A", 1, 1);
-        let second = app.session.execute("layer.newText", json!({"text": "B"})).unwrap()["layer"].as_u64().unwrap();
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "か".into(), active_range_chars: None })], true, false)
-            .expect("editing the first layer");
-
-        app.session.execute("text.edit", json!({"layer": second, "caret": 1})).unwrap();
-        let switched = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false).expect("editing the second layer");
-        assert_eq!(doc_text(&app, LayerId(second)), "B", "a delayed commit from the old composition is ignored");
-        assert_eq!(doc_text(&app, first), "A", "the old layer is not changed either");
-        assert_eq!(switched.owner, ime_target(&app).expect("second target").owner);
-        assert!(switched.should_interrupt_composition, "the target switch interrupts the old composition");
-    }
-
-    #[test]
-    fn hidden_pass_clears_this_viewports_preedit_preview() {
-        let (mut app, _) = editor("ab", 2, 2);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false).expect("editing");
-        assert!(pass.ctx.data(|d| d.get_temp::<Preedit>(ime_preedit_id(pass.viewport))).is_some());
-        assert!(pass.frame(&mut app, vec![], false, false).is_none());
-        assert!(pass.ctx.data(|d| d.get_temp::<Preedit>(ime_preedit_id(pass.viewport))).is_none(), "a pass without the overlay clears this viewport's preview");
-    }
-
-    #[test]
-    fn a_discarded_pass_keeps_the_frame_cause_and_the_context() {
-        let (mut app, lid) = editor("ab", 2, 2);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        let first = pass.frame(&mut app, vec![], true, false).expect("editing");
-        let committed = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, true).expect("the final pass of the frame");
-        assert_eq!(doc_text(&app, lid), "ab日", "the discarded pass did not replay the event");
-        assert_eq!(committed.change_cause, egui::ImeChangeCause::InputMethod, "an unchanged later pass keeps the frame's cause");
-        assert_eq!(committed.context_generation, first.context_generation, "both passes are one context");
-    }
-
-    #[test]
-    fn two_viewports_keep_independent_ime_contexts() {
-        let (mut app, _) = editor("ab", 2, 2);
-        let mut first = ImePass::new(egui::ViewportId::ROOT);
-        let mut second = ImePass::new(egui::ViewportId::from_hash_of("ime-test-second-viewport"));
-        let one = first.frame(&mut app, vec![], true, false).expect("editing in the first viewport");
-        let two = second.frame(&mut app, vec![], true, false).expect("editing in the second viewport");
-        assert_ne!(one.context_generation, two.context_generation, "each viewport has its own generation");
-        let again = first.frame(&mut app, vec![], true, false).expect("editing in the first viewport");
-        assert_eq!(again.context_generation, one.context_generation, "the second viewport did not disturb the first");
-    }
-
-    /// Draw one real `EffectcraftApp::draw` pass, so `draw`'s all-exit finalizer runs.
-    fn draw_app_pass(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, events: Vec<egui::Event>) -> egui::FullOutput {
-        let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 800.0))), events, ..Default::default() };
-        let mut out = ctx.run_ui(raw, |ui| app.draw(ui, frame));
-        out.textures_delta.clear();
-        out
-    }
-
-    /// One headless pass with the custom viewer and a real stock `TextEdit` side by side.
-    ///
-    /// The first call focuses the custom editor before `keyboard` (the outside press arrives
-    /// there). The second call leaves the stock field's focus alone, so the stock descriptor
-    /// is published by the same `output.ime` writer that an unrelated field would use.
-    fn stock_pass(
-        pass: &mut ImePass,
-        app: &mut EffectcraftApp,
-        events: Vec<egui::Event>,
-        stock: &mut String,
-        custom_focus: bool,
-    ) -> Option<egui::output::IMEOutput> {
-        let ctx = pass.ctx.clone();
-        let viewport = pass.viewport;
-        let custom = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(160.0, 90.0));
-        let stock_rect = egui::Rect::from_min_size(egui::pos2(180.0, 30.0), egui::vec2(120.0, 24.0));
-        let stock_id = egui::Id::unique("effectcraft-ime-test-stock");
-        let mut viewports = egui::ViewportIdMap::default();
-        viewports.insert(viewport, egui::ViewportInfo::default());
-        let raw = egui::RawInput { viewport_id: viewport, viewports, screen_rect: Some(pass.rect), events, ..Default::default() };
-        let mut out = ctx.run_ui(raw, |ui| {
-            begin_ui(ui.ctx());
-            if custom_focus {
-                ui.interact(custom, focus_id(), egui::Sense::focusable_noninteractive());
-                ui.memory_mut(|m| m.request_focus(focus_id()));
-                sync_ime_target(ui, app);
-                keyboard(app, ui, custom);
-            } else {
-                // The stock field holds focus after the outside press; keep that ownership while
-                // the second pass publishes the actual stock descriptor.
-                ui.memory_mut(|m| m.request_focus(stock_id));
-            }
-            let _ = ui.put(stock_rect, egui::TextEdit::singleline(stock).id(stock_id));
-            finish_ime(app, ui);
-        });
-        out.textures_delta.clear();
-        out.platform_output.ime
-    }
-
-    #[test]
-    fn outside_pointer_to_stock_allocates_no_new_request_and_defers_the_replacement() {
-        let (mut app, lid) = editor("abcd", 4, 4);
-        let mut pass = ImePass::new(egui::ViewportId::ROOT);
-        let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });
-        pass.frame(&mut app, vec![preview()], true, false).expect("the custom editor starts a composition");
-        app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();
-        let first = pass.frame(&mut app, vec![], true, false).expect("the caret change publishes a request").reset_request.expect("the real request ID");
-        // Complete the first interruption, then start a fresh composition with no waiting guard.
-        pass.frame(&mut app, vec![egui::Event::ImeResetCompleted { request_id: first }], true, false);
-        let active = pass.frame(&mut app, vec![preview()], true, false).expect("a fresh composition");
-        assert!(active.reset_request.is_none(), "a fresh composition does not wait on an old request");
-        assert_eq!(doc_text(&app, lid), "abcd");
-
-        // The press outside the viewer also gives the stock field focus. It must not allocate a
-        // new request: core would attach that request to the stock descriptor next pass.
-        let outside = egui::pos2(240.0, 42.0);
-        let mut stock = String::new();
-        stock_pass(
-            &mut pass,
-            &mut app,
-            vec![
-                egui::Event::PointerMoved(outside),
-                egui::Event::PointerButton { pos: outside, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE },
-            ],
-            &mut stock,
-            true,
-        );
-        let guard = pass.ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(pass.viewport))).expect("the custom guard is retired locally");
-        assert!(guard.suspended && guard.request.is_none(), "the outside press retires the old request without allocating another");
-        let stock_ime = stock_pass(&mut pass, &mut app, vec![], &mut stock, false).expect("the actual stock field owns IME");
-        assert_ne!(stock_ime.owner, ime_target(&app).expect("the custom target is still live").owner);
-        assert!(stock_ime.reset_request.is_none(), "a new outside-press request would surface on the stock output");
-        assert_eq!(doc_text(&app, lid), "abcd");
-
-        // Returning to a confirmed eligible custom output allocates the one replacement.
-        let replacement = pass.frame(&mut app, vec![], true, false).expect("the custom editor owns IME again").reset_request.expect("the deferred replacement");
-        assert_ne!(first, replacement);
-        assert!(pass.frame(&mut app, vec![], true, false).expect("still editing").reset_request.is_none(), "the replacement is one-shot");
-    }
-
-    #[test]
-    fn fonts_and_device_loss_all_exit_finalizers_suspend_without_allocating() {
-        let (mut app, _lid) = editor("abcd", 1, 1);
-        app.ui.start_screen = false;
-        app.ui.tool = Tool::Type;
-        app.ui.focused = PanelKind::Composition;
-        app.show_panel(PanelKind::Composition);
-        let ctx = egui::Context::default();
-        install_hooks(&ctx);
-        let frame = eframe::Frame::_new_kittest();
-        let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });
-        // The first pass installs fonts and the next draws the real viewer.
-        for _ in 0..3 {
-            draw_app_pass(&mut app, &ctx, &frame, vec![]);
-        }
-        draw_app_pass(&mut app, &ctx, &frame, vec![preview()]);
-        app.session.execute("text.setSelection", json!({"caret": 2})).unwrap();
-        let first = draw_app_pass(&mut app, &ctx, &frame, vec![])
-            .platform_output
-            .ime
-            .expect("the normal pass publishes the custom descriptor")
-            .reset_request
-            .expect("one request for the caret interruption");
-
-        // A real font-install pass draws nothing, but `draw` still reaches the finalizer.
-        app.styled = false;
-        let fonts = draw_app_pass(&mut app, &ctx, &frame, vec![]);
-        assert!(!app.is_ready(), "the font-install pass cannot draw");
-        assert!(fonts.platform_output.ime.is_none(), "no custom descriptor is published");
-        let guard = ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(egui::ViewportId::ROOT))).expect("the waiting guard");
-        assert!(guard.suspended && guard.request.is_none(), "the all-exit finalizer retired it without allocating");
-        let second = draw_app_pass(&mut app, &ctx, &frame, vec![])
-            .platform_output
-            .ime
-            .expect("returning to a drawing pass publishes the custom descriptor")
-            .reset_request
-            .expect("the deferred request");
-        assert_ne!(first, second);
-
-        // The device-loss early return is the other all-exit path. Preset the close bookkeeping
-        // so this test does not autosave; the pass must still retire the waiting guard.
-        app.gpu_failure_applied = Some(true);
-        app.device_lost_close = Some(true);
-        let lost = draw_app_pass(&mut app, &ctx, &frame, vec![]);
-        assert!(lost.platform_output.ime.is_none(), "a lost renderer publishes no descriptor");
-        let guard = ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(egui::ViewportId::ROOT))).expect("the waiting guard");
-        assert!(guard.suspended && guard.request.is_none(), "the device-loss finalizer retired it without allocating");
-        app.gpu_failure_applied = None;
-        let third = draw_app_pass(&mut app, &ctx, &frame, vec![])
-            .platform_output
-            .ime
-            .expect("a drawing pass publishes the custom descriptor again")
-            .reset_request
-            .expect("the deferred request is one-shot");
-        assert_ne!(third, second);
-    }
-
-    #[test]
-    fn ime_delete_without_a_session_or_with_an_empty_range_does_nothing() {
-        let (mut app, lid) = editor("abc", 1, 1);
-        feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 0, after_bytes: 0 })]);
-        assert_eq!(doc_text(&app, lid), "abc");
-        app.session.state.text_edit = None;
-        feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 2, after_bytes: 0 })]);
-        assert_eq!(doc_text(&app, lid), "abc");
-    }
-}
+mod tests;
diff --git a/crates/ui-egui/src/panels/viewer_text/tests.rs b/crates/ui-egui/src/panels/viewer_text/tests.rs
new file mode 100644
index 000000000..be3e84b2c
--- /dev/null
+++ b/crates/ui-egui/src/panels/viewer_text/tests.rs
@@ -0,0 +1,812 @@
+//! Incoming IME edits on the custom text editor (the Type tool's own session, not a stock
+//! `TextEdit`). Winit reports the bytes around the selection *before* the commit it belongs
+//! to, so the deletion and the insert must share one undo step.
+
+use super::*;
+use effectcraft_engine::Session;
+use effectcraft_engine::commands::text_edit::TextEdit;
+use serde_json::json;
+
+fn editor(text: &str, anchor: usize, caret: usize) -> (EffectcraftApp, LayerId) {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "IME", "width": 160, "height": 90, "duration": 1})).unwrap();
+    let layer = s.execute("layer.newText", json!({"text": text})).unwrap()["layer"].as_u64().unwrap();
+    let lid = LayerId(layer);
+    s.state.text_edit = Some(TextEdit { layer: lid, anchor, caret, ..Default::default() });
+    (EffectcraftApp::new(s), lid)
+}
+
+fn doc_text(app: &EffectcraftApp, lid: LayerId) -> String {
+    layer_doc(&app.session, lid).map(|d| d.text).unwrap_or_default()
+}
+
+fn feed(app: &mut EffectcraftApp, events: Vec<egui::Event>) {
+    let ctx = egui::Context::default();
+    let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0))), events, ..Default::default() };
+    let mut out = ctx.run_ui(raw, |ui| keyboard(app, ui, egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0))));
+    out.textures_delta.clear();
+}
+
+#[test]
+fn preedit_preview_is_bounded_on_a_character_boundary() {
+    let text = "é".repeat(MAX_IME_TEXT_BYTES);
+    let capped = bounded_preedit(text);
+    assert!(capped.len() <= MAX_IME_TEXT_BYTES);
+    assert!(capped.is_char_boundary(capped.len()));
+    assert_eq!(capped.len() % "é".len(), 0, "the cap never leaves half a character");
+}
+
+/// Ending the edit from another panel clears this viewport's pre-edit. The production path
+/// used to resolve `viewport_id()` (a context read lock) inside `data_mut` (a write lock);
+/// that nested context access deadlocked every pass that drew the viewer.
+#[test]
+fn ending_an_edit_from_another_panel_clears_the_preedit() {
+    let (mut app, lid) = editor("abc", 0, 0);
+    let session = app.session.state.text_edit.as_ref().map_or(1, |e| e.session);
+    let ctx = egui::Context::default();
+    let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
+        let viewport = ui.ctx().viewport_id();
+        let preedit = Preedit { owner: ImeOwner { layer: lid, session }, text: "x".into() };
+        ui.data_mut(|d| d.insert_temp(ime_preedit_id(viewport), preedit));
+        panel_clicked(&mut app, ui.ctx(), PanelKind::Timeline);
+        let viewport = ui.ctx().viewport_id();
+        assert!(ui.data(|d| d.get_temp::<Preedit>(ime_preedit_id(viewport))).is_none(), "the ended edit leaves no preview behind");
+    });
+    out.textures_delta.clear();
+    assert!(app.session.state.text_edit.is_none(), "a click in the Timeline ends the text edit");
+}
+
+#[test]
+fn ime_delete_surrounding_bytes_and_the_commit_are_one_undo_step() {
+    // "café😀": the last character is four bytes, so a byte-count deletion that treated bytes
+    // as characters would corrupt the document.
+    let (mut app, lid) = editor("café😀", 5, 5);
+    feed(
+        &mut app,
+        vec![
+            egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 4, after_bytes: 0 }),
+            egui::Event::Ime(egui::ImeEvent::Commit("X".into())),
+        ],
+    );
+    assert_eq!(doc_text(&app, lid), "caféX", "the emoji is replaced by the committed text");
+    app.session.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(doc_text(&app, lid), "café😀", "the replacement is one undo step");
+}
+
+#[test]
+fn ime_delete_surrounding_chars_keeps_the_selection_for_the_commit() {
+    // Stock egui deletes the characters around the selection, not the selection itself: the
+    // commit that follows replaces "bcd", it does not insert next to a deleted document.
+    let (mut app, lid) = editor("abcdef", 1, 4);
+    feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 99 })]);
+    assert_eq!(doc_text(&app, lid), "bcd", "one character before and everything after go");
+    let sel = app.session.state.text_edit.clone().expect("editing continues");
+    assert_eq!(sel.range(), 0..3, "the selected text is still selected");
+    // A deletion-only batch (no commit) leaves "bcd", not an empty document.
+    app.session.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(doc_text(&app, lid), "abcdef", "clamped deletion is still one undo step");
+
+    // Delete surround + commit: the commit replaces the kept selection.
+    let (mut app, lid) = editor("abcdef", 1, 4);
+    feed(
+        &mut app,
+        vec![egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 99 }), egui::Event::Ime(egui::ImeEvent::Commit("XY".into()))],
+    );
+    assert_eq!(doc_text(&app, lid), "XY", "the commit replaces the selection");
+    app.session.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(doc_text(&app, lid), "abcdef", "the deletion and its commit are one undo step");
+}
+
+/// One UI pass with the editor focused, events applied, and the overlay's observation.
+struct ImePass {
+    ctx: egui::Context,
+    viewport: egui::ViewportId,
+    rect: egui::Rect,
+}
+
+impl ImePass {
+    fn new(viewport: egui::ViewportId) -> Self {
+        let ctx = egui::Context::default();
+        install_hooks(&ctx);
+        Self { ctx, viewport, rect: egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(320.0, 180.0)) }
+    }
+
+    /// Run one `Context` frame. `overlay` is false for a pass in which the viewer (and so
+    /// the edit overlay) never drew; `discard` forces a second pass of the same frame.
+    fn frame(&mut self, app: &mut EffectcraftApp, events: Vec<egui::Event>, overlay: bool, discard: bool) -> Option<egui::output::IMEOutput> {
+        let ctx = self.ctx.clone();
+        let rect = self.rect;
+        let viewport = self.viewport;
+        let mut viewports = egui::ViewportIdMap::default();
+        viewports.insert(self.viewport, egui::ViewportInfo::default());
+        let raw = egui::RawInput { viewport_id: self.viewport, viewports, screen_rect: Some(rect), events, ..Default::default() };
+        let mut asked = false;
+        let mut out = ctx.run_ui(raw, |ui| {
+            begin_ui(ui.ctx());
+            ui.interact(rect, focus_id(), egui::Sense::focusable_noninteractive());
+            ui.memory_mut(|m| m.request_focus(focus_id()));
+            sync_ime_target(ui, app);
+            keyboard(app, ui, rect);
+            if overlay {
+                let pass = ui.ctx().cumulative_pass_nr_for(viewport);
+                ui.data_mut(|d| d.insert_temp(ime_geometry_id(viewport), (pass, rect, rect)));
+            }
+            finish_ime(app, ui);
+            if discard && !asked {
+                asked = true;
+                ui.ctx().request_discard("ime pass test");
+            }
+        });
+        out.textures_delta.clear();
+        out.platform_output.ime
+    }
+}
+
+/// One native floating window holding the Timeline's group and then the Viewer's.
+fn two_group_window() -> craft_ui::docking::Floating<PanelKind> {
+    let groups = vec![craft_ui::docking::Group::new(vec![PanelKind::Timeline], 0), craft_ui::docking::Group::new(vec![PanelKind::Viewer(1)], 0)];
+    craft_ui::docking::Floating::stack(groups, [0.0, 0.0, 320.0, 360.0]).expect("two groups make a window")
+}
+
+impl ImePass {
+    /// One pass of a native window with a body that edits no text and the Viewer's editor,
+    /// in the order given, publishing as `NativeIme` decides or, with `every`, after each
+    /// body. Returns the descriptor and the preedit the pass ended with.
+    fn window(
+        &mut self,
+        app: &mut EffectcraftApp,
+        window: &craft_ui::docking::Floating<PanelKind>,
+        events: Vec<egui::Event>,
+        viewer_first: bool,
+        every: bool,
+    ) -> (Option<egui::output::IMEOutput>, Option<String>) {
+        let ctx = self.ctx.clone();
+        let (rect, viewport) = (self.rect, self.viewport);
+        let mut viewports = egui::ViewportIdMap::default();
+        viewports.insert(viewport, egui::ViewportInfo::default());
+        let raw = egui::RawInput { viewport_id: viewport, viewports, screen_rect: Some(rect), events, ..Default::default() };
+        let mut preedit = None;
+        let mut out = ctx.run_ui(raw, |ui| {
+            let mut ime = crate::dock_ui::NativeIme::new(std::slice::from_ref(window), &[]);
+            let order = if viewer_first { [true, false] } else { [false, true] };
+            for viewer in order {
+                if ime.begin_body(viewport) {
+                    begin_ui(ui.ctx());
+                }
+                if viewer {
+                    ui.interact(rect, focus_id(), egui::Sense::focusable_noninteractive());
+                    ui.memory_mut(|m| m.request_focus(focus_id()));
+                    sync_ime_target(ui, app);
+                    keyboard(app, ui, rect);
+                    let pass = ui.ctx().cumulative_pass_nr_for(viewport);
+                    ui.data_mut(|d| d.insert_temp(ime_geometry_id(viewport), (pass, rect, rect)));
+                }
+                if ime.publishes(viewport, ime_recorded(ui.ctx())) || every {
+                    finish_ime(app, ui);
+                }
+            }
+            assert!(ime.unpublished().is_empty(), "the window published");
+            preedit = read_preedit(ui).map(|p| p.text);
+        });
+        out.textures_delta.clear();
+        (out.platform_output.ime, preedit)
+    }
+}
+
+#[test]
+fn native_window_with_a_group_before_the_viewer_keeps_the_composition() {
+    let window = two_group_window();
+    let viewport = craft_ui::docking::DockArea::<PanelKind>::window_viewport(crate::dock_ui::area_id(), window.id);
+    let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });
+    for viewer_first in [false, true] {
+        let (mut app, _) = editor("abcd", 4, 4);
+        let mut pass = ImePass::new(viewport);
+        let (first, preedit) = pass.window(&mut app, &window, vec![preview()], viewer_first, false);
+        let first = first.expect("the editor publishes");
+        assert_eq!(preedit.as_deref(), Some("é"));
+        for _ in 0..2 {
+            let (ime, preedit) = pass.window(&mut app, &window, vec![], viewer_first, false);
+            let ime = ime.expect("the editor keeps publishing");
+            assert!(!ime.should_interrupt_composition, "viewer first: {viewer_first}");
+            assert_eq!((ime.owner, ime.context_generation), (first.owner, first.context_generation), "the same IME context");
+            assert_eq!(preedit.as_deref(), Some("é"), "the preedit survives the other body");
+        }
+    }
+    // Publishing after the body drawn before the Viewer clears the preedit and interrupts.
+    let (mut app, _) = editor("abcd", 4, 4);
+    let mut pass = ImePass::new(viewport);
+    pass.window(&mut app, &window, vec![preview()], false, true);
+    let (ime, preedit) = pass.window(&mut app, &window, vec![], false, true);
+    assert!(ime.expect("the editor publishes").should_interrupt_composition);
+    assert_eq!(preedit, None);
+    // A window that drew fewer bodies than its layout counts publishes after every body in
+    // its next pass.
+    let mut ime = crate::dock_ui::NativeIme::new(std::slice::from_ref(&window), &[]);
+    ime.begin_body(viewport);
+    assert!(!ime.publishes(viewport, false));
+    let unpublished = ime.unpublished();
+    assert_eq!(unpublished, vec![viewport]);
+    let mut ime = crate::dock_ui::NativeIme::new(std::slice::from_ref(&window), &unpublished);
+    ime.begin_body(viewport);
+    assert!(ime.publishes(viewport, false));
+}
+
+fn ime_text(ime: &egui::output::IMEOutput) -> (&str, usize, usize) {
+    let p = ime.surrounding_text.available().expect("committed surrounding text");
+    (p.text.as_str(), p.cursor, p.anchor)
+}
+
+#[test]
+fn discarded_custom_request_then_home_rearms_the_identical_caret() {
+    let (mut app, lid) = editor("abcd", 4, 4);
+    app.ui.start_screen = false;
+    app.ui.tool = Tool::Type;
+    app.ui.focused = PanelKind::Composition;
+    let ctx = egui::Context::default();
+    install_hooks(&ctx);
+    let mut frame = eframe::Frame::_new_kittest();
+    let raw = || egui::RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 800.0))), ..Default::default() };
+    for _ in 0..3 {
+        let mut output = ctx.run_ui(raw(), |ui| {
+            eframe::App::logic(&mut app, ui.ctx(), &mut frame);
+            app.draw(ui, &frame);
+        });
+        output.textures_delta.clear();
+    }
+    let mut input = raw();
+    input.events.push(egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None }));
+    let mut output = ctx.run_ui(input, |ui| {
+        eframe::App::logic(&mut app, ui.ctx(), &mut frame);
+        app.draw(ui, &frame);
+    });
+    output.textures_delta.clear();
+    assert!(output.platform_output.ime.is_some());
+    app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();
+    let selection = app.session.state.text_edit.clone();
+    let mut passes = 0;
+    let mut discarded = None;
+    let mut output = ctx.run_ui(raw(), |ui| {
+        passes += 1;
+        if passes > 1 {
+            app.ui.start_screen = true;
+        }
+        eframe::App::logic(&mut app, ui.ctx(), &mut frame);
+        app.draw(ui, &frame);
+        if passes == 1 {
+            assert!(ui.ctx().output(|output| output.ime.is_some()));
+            discarded = read_reset(ui.ctx()).and_then(|guard| guard.request);
+            ui.ctx().request_discard("custom IME descriptor discarded before Home");
+        }
+    });
+    output.textures_delta.clear();
+    assert!(passes >= 2);
+    let first = discarded.expect("the actual discarded custom pass requested a fence");
+    assert!(output.platform_output.ime.is_none());
+    assert!(read_reset(&ctx).unwrap().suspended);
+    assert!(read_reset(&ctx).unwrap().request.is_none());
+    assert_eq!(app.session.state.text_edit, selection, "Home did not move the model caret");
+    app.ui.start_screen = false;
+    let mut output = ctx.run_ui(raw(), |ui| {
+        eframe::App::logic(&mut app, ui.ctx(), &mut frame);
+        app.draw(ui, &frame);
+    });
+    output.textures_delta.clear();
+    let second = output.platform_output.ime.unwrap().reset_request.expect("same caret reactivation publishes a new real ID");
+    assert_ne!(first, second);
+    let mut output = ctx.run_ui(raw(), |ui| {
+        eframe::App::logic(&mut app, ui.ctx(), &mut frame);
+        app.draw(ui, &frame);
+    });
+    output.textures_delta.clear();
+    assert!(output.platform_output.ime.unwrap().reset_request.is_none());
+    let mut input = raw();
+    input.events.extend([
+        egui::Event::ImeResetCompleted { request_id: first },
+        egui::Event::Ime(egui::ImeEvent::Commit("X".into())),
+        egui::Event::ImeResetCompleted { request_id: second },
+        egui::Event::Ime(egui::ImeEvent::Preedit { text: "が".into(), active_range_chars: None }),
+        egui::Event::Ime(egui::ImeEvent::Commit("が".into())),
+    ]);
+    let mut output = ctx.run_ui(input, |ui| {
+        eframe::App::logic(&mut app, ui.ctx(), &mut frame);
+        app.draw(ui, &frame);
+    });
+    output.textures_delta.clear();
+    assert_eq!(doc_text(&app, lid), "aがbcd");
+}
+
+#[test]
+fn viewport_fences_and_duplicate_completion_keep_their_exact_lifetime() {
+    let (mut app, lid) = editor("abcd", 4, 4);
+    let mut root = ImePass::new(egui::ViewportId::ROOT);
+    let mut detached = ImePass::new(egui::ViewportId::from_hash_of("effect-ime-detached"));
+    let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });
+    root.frame(&mut app, vec![preview()], true, false);
+    detached.frame(&mut app, vec![preview()], true, false);
+    app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();
+    let first = root.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();
+    let second = detached.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();
+    assert_ne!(first, second);
+    detached.frame(&mut app, vec![egui::Event::ImeResetCompleted { request_id: first }, egui::Event::Ime(egui::ImeEvent::Commit("X".into()))], true, false);
+    assert_eq!(doc_text(&app, lid), "abcd");
+    let pending = detached.ctx.data(|data| data.get_temp::<ResetGuard>(reset_id(detached.viewport))).unwrap().request;
+    assert_eq!(pending, Some(second), "a root marker cannot release the detached viewport's full ID");
+    let output = detached
+        .frame(
+            &mut app,
+            vec![
+                egui::Event::ImeResetCompleted { request_id: second },
+                preview(),
+                egui::Event::ImeResetCompleted { request_id: second },
+                egui::Event::Ime(egui::ImeEvent::Commit("が".into())),
+            ],
+            true,
+            false,
+        )
+        .unwrap();
+    assert_eq!(doc_text(&app, lid), "aがbcd");
+    assert!(output.reset_request.is_none(), "a duplicate control cannot reconstruct the cleared guard");
+    // An actual context-generation change at unchanged selection still supersedes a wait.
+    root.frame(&mut app, vec![], true, false);
+    let replaced = root.frame(&mut app, vec![], false, false);
+    assert!(replaced.is_none());
+    let replacement = root.frame(&mut app, vec![], true, false).unwrap().reset_request.unwrap();
+    assert_ne!(first, replacement);
+}
+
+#[test]
+fn ime_descriptor_sends_committed_text_and_preserves_a_reversed_selection() {
+    let (mut app, _) = editor("café😀", 2, 5);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    let first = pass.frame(&mut app, vec![], true, false).expect("the focused editor owns IME");
+    assert_eq!(first.owner, ime_target(&app).expect("an edit target").owner);
+    assert!(first.context_generation > 0);
+    assert_eq!(ime_text(&first), ("café😀", 9, 2), "UTF-8 bytes, with the caret's direction kept");
+    assert_eq!(first.change_cause, egui::ImeChangeCause::Other, "starting a context is application origin");
+    assert_eq!((first.rect, first.cursor_rect), (pass.rect, pass.rect), "the real caret geometry");
+
+    let again = pass.frame(&mut app, vec![], true, false).expect("still editing");
+    assert_eq!(again.context_generation, first.context_generation, "an unchanged pass keeps the context");
+    assert_eq!(again.surrounding_text, first.surrounding_text);
+}
+
+#[test]
+fn accepted_ime_commit_is_input_method_and_ordinary_typing_is_other() {
+    let (mut app, lid) = editor("ab", 2, 2);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    let first = pass.frame(&mut app, vec![], true, false).expect("editing");
+    let generation = first.context_generation;
+
+    let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), "ab日");
+    assert_eq!(ime_text(&commit), ("ab日", 5, 5));
+    assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod, "only the accepted commit earns it");
+    assert_eq!(commit.context_generation, generation, "an ordinary text change is not a new context");
+
+    let typed = pass.frame(&mut app, vec![egui::Event::Text("x".into())], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), "ab日x");
+    assert_eq!(typed.change_cause, egui::ImeChangeCause::Other, "typing is application work");
+    assert_eq!(typed.context_generation, generation);
+}
+
+#[test]
+fn ime_delete_and_commit_chain_is_input_method_with_a_reversed_selection() {
+    let (mut app, lid) = editor("abcdef", 4, 1);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    pass.frame(&mut app, vec![], true, false).expect("editing");
+
+    let deleted = pass
+        .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurrounding { before_chars: 1, after_chars: 1 })], true, false)
+        .expect("still editing");
+    assert_eq!(doc_text(&app, lid), "bcdf", "one character goes before and one after the selection");
+    assert_eq!(ime_text(&deleted), ("bcdf", 0, 3), "the selected text and its reversed direction stay");
+    assert_eq!(deleted.change_cause, egui::ImeChangeCause::InputMethod);
+
+    let committed = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("X".into()))], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), "Xf", "the commit replaces the kept selection");
+    assert_eq!(committed.change_cause, egui::ImeChangeCause::InputMethod, "the delete and commit are one accepted chain");
+    app.session.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(doc_text(&app, lid), "abcdef", "the replacement is one undo step");
+}
+
+#[test]
+fn an_application_edit_in_the_same_frame_dominates_the_ime_cause() {
+    // Application edit before the IME commit.
+    let (mut app, lid) = editor("ab", 2, 2);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    pass.frame(&mut app, vec![], true, false).expect("editing");
+    let mixed =
+        pass.frame(&mut app, vec![egui::Event::Text("x".into()), egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), "abx日");
+    assert_eq!(mixed.change_cause, egui::ImeChangeCause::Other, "the earlier application edit dominates");
+
+    // Application edit after the IME commit.
+    let (mut app, lid) = editor("ab", 2, 2);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    pass.frame(&mut app, vec![], true, false).expect("editing");
+    let mixed =
+        pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into())), egui::Event::Text("x".into())], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), "ab日x");
+    assert_eq!(mixed.change_cause, egui::ImeChangeCause::Other, "the later application edit dominates");
+}
+
+#[test]
+fn preedit_is_excluded_from_the_committed_snapshot_and_keeps_the_context() {
+    let (mut app, lid) = editor("ab", 2, 2);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    let first = pass.frame(&mut app, vec![], true, false).expect("editing");
+
+    let preview = pass
+        .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)
+        .expect("still editing");
+    assert_eq!(doc_text(&app, lid), "ab", "the pre-edit never enters the document");
+    assert_eq!(ime_text(&preview), ("ab", 2, 2), "only committed text is sent");
+    assert_eq!(preview.context_generation, first.context_generation, "pre-edit updates keep the composition");
+
+    let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("に".into()))], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), "abに");
+    assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod, "clearing the pre-edit and committing is IME work");
+    assert_eq!(commit.context_generation, first.context_generation);
+}
+
+#[test]
+fn empty_and_unavailable_surrounding_text_are_distinct() {
+    let (mut app, _) = editor("", 0, 0);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    let empty = pass.frame(&mut app, vec![], true, false).expect("editing");
+    assert_eq!(ime_text(&empty), ("", 0, 0), "an available-empty document is not unavailable");
+
+    let text = "a".repeat(5000);
+    let (mut app, _) = editor(&text, 0, 5000);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    let wide = pass.frame(&mut app, vec![], true, false).expect("editing");
+    assert!(matches!(wide.surrounding_text, egui::output::IMESurroundingText::Unavailable), "a selection wider than the limit is unavailable");
+    assert_eq!(wide.owner, ime_target(&app).expect("an edit target").owner, "identity survives unavailable text");
+}
+
+#[test]
+fn an_unrelated_undo_keeps_a_wide_selection_composition() {
+    // A selection wider than the IME limit reports unavailable surrounding text, whose
+    // receipt identity is a revision. That revision must follow the editor, not the whole
+    // project: undoing an unrelated opacity change used to look like an editor mutation and
+    // cancel an active composition.
+    let text = "a".repeat(5000);
+    let (mut app, lid) = editor(&text, 0, 5000);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    let first = pass.frame(&mut app, vec![], true, false).expect("editing");
+    assert!(matches!(first.surrounding_text, egui::output::IMESurroundingText::Unavailable), "the wide selection is unavailable");
+
+    let composing = pass
+        .frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false)
+        .expect("still editing");
+    assert_eq!(composing.context_generation, first.context_generation, "the pre-edit keeps the context");
+    let owner = ime_owner(&app).expect("an editor owner");
+    assert!(matches!(
+        pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),
+        Some(ImeComposition::Active(active)) if active == owner
+    ));
+
+    app.session.execute("prop.set", json!({"layer": lid.0, "path": "transform/opacity", "value": 50})).unwrap();
+    app.session.execute("edit.undo", json!({})).unwrap();
+    let after = pass.frame(&mut app, vec![], true, false).expect("still editing");
+    assert_eq!(after.context_generation, first.context_generation, "an unrelated undo does not start a new context");
+    assert!(
+        matches!(
+            pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),
+            Some(ImeComposition::Active(active)) if active == owner
+        ),
+        "the wide-selection composition survives an unrelated undo"
+    );
+    assert!(read_reset(&pass.ctx).is_none(), "no IME reset was requested");
+
+    // The composition is still the live one: its commit is accepted and earns the
+    // input-method cause rather than being poisoned as leftover application work.
+    let commit = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("x".into()))], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), "x", "the preserved composition commits into the wide selection");
+    assert_eq!(commit.change_cause, egui::ImeChangeCause::InputMethod);
+}
+
+#[test]
+fn a_failed_batch_with_a_transient_edit_does_not_revive_a_wide_selection_composition() {
+    // The final document equals the pre-batch one, but the intermediate insert/delete was a
+    // real document change. Its IME revision must stay the high-water mark; otherwise the
+    // active wide-selection composition would look current and accept its old commit.
+    let text = "a".repeat(5000);
+    let (mut app, lid) = editor(&text, 0, 5000);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    pass.frame(&mut app, vec![], true, false).expect("editing");
+    pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false).expect("still editing");
+    let owner = ime_owner(&app).expect("an editor owner");
+    assert!(matches!(
+        pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))),
+        Some(ImeComposition::Active(active)) if active == owner
+    ));
+
+    let r = app.session.execute(
+        "engine.batch",
+        json!({"atomic": true, "steps": [
+            {"command": "text.insert", "params": {"text": "x", "range": [5000, 5000]}},
+            {"command": "text.delete", "params": {}},
+            {"command": "no.suchCommand", "params": {}}
+        ]}),
+    );
+    assert!(r.is_err());
+    assert_eq!(doc_text(&app, lid), text, "the batch restored the final document");
+
+    pass.frame(&mut app, vec![], true, false).expect("still editing");
+    assert!(read_reset(&pass.ctx).is_some(), "the advanced revision retires the old IME context");
+    assert!(
+        matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),
+        "the failed batch's transient edit leaves the old composition stale"
+    );
+    let stale = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), text, "the stale composition cannot commit into the restored document");
+    assert_ne!(stale.change_cause, egui::ImeChangeCause::InputMethod, "a rejected commit earns no IME receipt");
+}
+
+#[test]
+fn a_wide_content_change_invalidates_the_active_composition() {
+    let text = "a".repeat(5000);
+    let (mut app, lid) = editor(&text, 0, 5000);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    pass.frame(&mut app, vec![], true, false).expect("editing");
+    pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false).expect("still editing");
+
+    let replaced = "b".repeat(5000);
+    app.session.execute("layer.setText", json!({"layer": lid.0, "text": replaced})).unwrap();
+    let after = pass.frame(&mut app, vec![], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), replaced);
+    assert!(after.should_interrupt_composition, "replacing the wide document starts a new IME context");
+    assert!(
+        matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),
+        "the old composition is stale after the content change"
+    );
+    pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), replaced, "a delayed commit from the old document is rejected");
+}
+
+#[test]
+fn a_wide_selection_change_invalidates_the_active_composition() {
+    let text = "a".repeat(5000);
+    let (mut app, lid) = editor(&text, 0, 5000);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    pass.frame(&mut app, vec![], true, false).expect("editing");
+    pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false).expect("still editing");
+
+    // Still wider than the IME window limit, so this exercises the unavailable-text
+    // selection identity rather than merely making the surrounding text available.
+    app.session.execute("text.setSelection", json!({"start": 0, "end": 4500})).unwrap();
+    pass.frame(&mut app, vec![], true, false).expect("still editing");
+    assert!(read_reset(&pass.ctx).is_some(), "an application selection change retires the composition");
+    assert!(
+        matches!(pass.ctx.data(|d| d.get_temp::<ImeComposition>(ime_composition_id(pass.viewport))), Some(ImeComposition::Stale)),
+        "the old composition cannot follow the selection"
+    );
+    pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("z".into()))], true, false).expect("still editing");
+    assert_eq!(doc_text(&app, lid), text, "the stale composition cannot mutate the wide selection");
+}
+
+#[test]
+fn replaced_edit_session_and_hidden_passes_start_a_new_context() {
+    let (mut app, _) = editor("text", 4, 4);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    let before = pass.frame(&mut app, vec![], true, false).expect("editing");
+    if let Some(edit) = app.session.state.text_edit.as_mut() {
+        edit.session = edit.session.wrapping_add(1);
+    }
+    let replaced = pass.frame(&mut app, vec![], true, false).expect("editing");
+    assert!(replaced.context_generation > before.context_generation, "a recreated target does not inherit the old context");
+    assert_eq!(replaced.change_cause, egui::ImeChangeCause::Other);
+    assert!(replaced.should_interrupt_composition, "a new replacement epoch cancels the platform composition");
+
+    let (mut app, _) = editor("abc", 3, 3);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    let visible = pass.frame(&mut app, vec![], true, false).expect("editing");
+    assert!(pass.frame(&mut app, vec![], false, false).is_none(), "a hidden editor reports no IME owner");
+    let back = pass.frame(&mut app, vec![], true, false).expect("editing again");
+    assert!(back.context_generation > visible.context_generation, "reappearing starts exactly one new context");
+}
+
+#[test]
+fn preedit_from_a_replaced_target_cannot_commit_into_the_new_session() {
+    let (mut app, first) = editor("A", 1, 1);
+    let second = app.session.execute("layer.newText", json!({"text": "B"})).unwrap()["layer"].as_u64().unwrap();
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "か".into(), active_range_chars: None })], true, false)
+        .expect("editing the first layer");
+
+    app.session.execute("text.edit", json!({"layer": second, "caret": 1})).unwrap();
+    let switched = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, false).expect("editing the second layer");
+    assert_eq!(doc_text(&app, LayerId(second)), "B", "a delayed commit from the old composition is ignored");
+    assert_eq!(doc_text(&app, first), "A", "the old layer is not changed either");
+    assert_eq!(switched.owner, ime_target(&app).expect("second target").owner);
+    assert!(switched.should_interrupt_composition, "the target switch interrupts the old composition");
+}
+
+#[test]
+fn hidden_pass_clears_this_viewports_preedit_preview() {
+    let (mut app, _) = editor("ab", 2, 2);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Preedit { text: "に".into(), active_range_chars: None })], true, false).expect("editing");
+    assert!(pass.ctx.data(|d| d.get_temp::<Preedit>(ime_preedit_id(pass.viewport))).is_some());
+    assert!(pass.frame(&mut app, vec![], false, false).is_none());
+    assert!(pass.ctx.data(|d| d.get_temp::<Preedit>(ime_preedit_id(pass.viewport))).is_none(), "a pass without the overlay clears this viewport's preview");
+}
+
+#[test]
+fn a_discarded_pass_keeps_the_frame_cause_and_the_context() {
+    let (mut app, lid) = editor("ab", 2, 2);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    let first = pass.frame(&mut app, vec![], true, false).expect("editing");
+    let committed = pass.frame(&mut app, vec![egui::Event::Ime(egui::ImeEvent::Commit("日".into()))], true, true).expect("the final pass of the frame");
+    assert_eq!(doc_text(&app, lid), "ab日", "the discarded pass did not replay the event");
+    assert_eq!(committed.change_cause, egui::ImeChangeCause::InputMethod, "an unchanged later pass keeps the frame's cause");
+    assert_eq!(committed.context_generation, first.context_generation, "both passes are one context");
+}
+
+#[test]
+fn two_viewports_keep_independent_ime_contexts() {
+    let (mut app, _) = editor("ab", 2, 2);
+    let mut first = ImePass::new(egui::ViewportId::ROOT);
+    let mut second = ImePass::new(egui::ViewportId::from_hash_of("ime-test-second-viewport"));
+    let one = first.frame(&mut app, vec![], true, false).expect("editing in the first viewport");
+    let two = second.frame(&mut app, vec![], true, false).expect("editing in the second viewport");
+    assert_ne!(one.context_generation, two.context_generation, "each viewport has its own generation");
+    let again = first.frame(&mut app, vec![], true, false).expect("editing in the first viewport");
+    assert_eq!(again.context_generation, one.context_generation, "the second viewport did not disturb the first");
+}
+
+/// Draw one real `EffectcraftApp::draw` pass, so `draw`'s all-exit finalizer runs.
+fn draw_app_pass(app: &mut EffectcraftApp, ctx: &egui::Context, frame: &eframe::Frame, events: Vec<egui::Event>) -> egui::FullOutput {
+    let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 800.0))), events, ..Default::default() };
+    let mut out = ctx.run_ui(raw, |ui| app.draw(ui, frame));
+    out.textures_delta.clear();
+    out
+}
+
+/// One headless pass with the custom viewer and a real stock `TextEdit` side by side.
+///
+/// The first call focuses the custom editor before `keyboard` (the outside press arrives
+/// there). The second call leaves the stock field's focus alone, so the stock descriptor
+/// is published by the same `output.ime` writer that an unrelated field would use.
+fn stock_pass(
+    pass: &mut ImePass,
+    app: &mut EffectcraftApp,
+    events: Vec<egui::Event>,
+    stock: &mut String,
+    custom_focus: bool,
+) -> Option<egui::output::IMEOutput> {
+    let ctx = pass.ctx.clone();
+    let viewport = pass.viewport;
+    let custom = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(160.0, 90.0));
+    let stock_rect = egui::Rect::from_min_size(egui::pos2(180.0, 30.0), egui::vec2(120.0, 24.0));
+    let stock_id = egui::Id::unique("effectcraft-ime-test-stock");
+    let mut viewports = egui::ViewportIdMap::default();
+    viewports.insert(viewport, egui::ViewportInfo::default());
+    let raw = egui::RawInput { viewport_id: viewport, viewports, screen_rect: Some(pass.rect), events, ..Default::default() };
+    let mut out = ctx.run_ui(raw, |ui| {
+        begin_ui(ui.ctx());
+        if custom_focus {
+            ui.interact(custom, focus_id(), egui::Sense::focusable_noninteractive());
+            ui.memory_mut(|m| m.request_focus(focus_id()));
+            sync_ime_target(ui, app);
+            keyboard(app, ui, custom);
+        } else {
+            // The stock field holds focus after the outside press; keep that ownership while
+            // the second pass publishes the actual stock descriptor.
+            ui.memory_mut(|m| m.request_focus(stock_id));
+        }
+        let _ = ui.put(stock_rect, egui::TextEdit::singleline(stock).id(stock_id));
+        finish_ime(app, ui);
+    });
+    out.textures_delta.clear();
+    out.platform_output.ime
+}
+
+#[test]
+fn outside_pointer_to_stock_allocates_no_new_request_and_defers_the_replacement() {
+    let (mut app, lid) = editor("abcd", 4, 4);
+    let mut pass = ImePass::new(egui::ViewportId::ROOT);
+    let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });
+    pass.frame(&mut app, vec![preview()], true, false).expect("the custom editor starts a composition");
+    app.session.execute("text.setSelection", json!({"caret": 1})).unwrap();
+    let first = pass.frame(&mut app, vec![], true, false).expect("the caret change publishes a request").reset_request.expect("the real request ID");
+    // Complete the first interruption, then start a fresh composition with no waiting guard.
+    pass.frame(&mut app, vec![egui::Event::ImeResetCompleted { request_id: first }], true, false);
+    let active = pass.frame(&mut app, vec![preview()], true, false).expect("a fresh composition");
+    assert!(active.reset_request.is_none(), "a fresh composition does not wait on an old request");
+    assert_eq!(doc_text(&app, lid), "abcd");
+
+    // The press outside the viewer also gives the stock field focus. It must not allocate a
+    // new request: core would attach that request to the stock descriptor next pass.
+    let outside = egui::pos2(240.0, 42.0);
+    let mut stock = String::new();
+    stock_pass(
+        &mut pass,
+        &mut app,
+        vec![
+            egui::Event::PointerMoved(outside),
+            egui::Event::PointerButton { pos: outside, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE },
+        ],
+        &mut stock,
+        true,
+    );
+    let guard = pass.ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(pass.viewport))).expect("the custom guard is retired locally");
+    assert!(guard.suspended && guard.request.is_none(), "the outside press retires the old request without allocating another");
+    let stock_ime = stock_pass(&mut pass, &mut app, vec![], &mut stock, false).expect("the actual stock field owns IME");
+    assert_ne!(stock_ime.owner, ime_target(&app).expect("the custom target is still live").owner);
+    assert!(stock_ime.reset_request.is_none(), "a new outside-press request would surface on the stock output");
+    assert_eq!(doc_text(&app, lid), "abcd");
+
+    // Returning to a confirmed eligible custom output allocates the one replacement.
+    let replacement = pass.frame(&mut app, vec![], true, false).expect("the custom editor owns IME again").reset_request.expect("the deferred replacement");
+    assert_ne!(first, replacement);
+    assert!(pass.frame(&mut app, vec![], true, false).expect("still editing").reset_request.is_none(), "the replacement is one-shot");
+}
+
+#[test]
+fn fonts_and_device_loss_all_exit_finalizers_suspend_without_allocating() {
+    let (mut app, _lid) = editor("abcd", 1, 1);
+    app.ui.start_screen = false;
+    app.ui.tool = Tool::Type;
+    app.ui.focused = PanelKind::Composition;
+    app.show_panel(PanelKind::Composition);
+    let ctx = egui::Context::default();
+    install_hooks(&ctx);
+    let frame = eframe::Frame::_new_kittest();
+    let preview = || egui::Event::Ime(egui::ImeEvent::Preedit { text: "é".into(), active_range_chars: None });
+    // The first pass installs fonts and the next draws the real viewer.
+    for _ in 0..3 {
+        draw_app_pass(&mut app, &ctx, &frame, vec![]);
+    }
+    draw_app_pass(&mut app, &ctx, &frame, vec![preview()]);
+    app.session.execute("text.setSelection", json!({"caret": 2})).unwrap();
+    let first = draw_app_pass(&mut app, &ctx, &frame, vec![])
+        .platform_output
+        .ime
+        .expect("the normal pass publishes the custom descriptor")
+        .reset_request
+        .expect("one request for the caret interruption");
+
+    // A real font-install pass draws nothing, but `draw` still reaches the finalizer.
+    app.styled = false;
+    let fonts = draw_app_pass(&mut app, &ctx, &frame, vec![]);
+    assert!(!app.is_ready(), "the font-install pass cannot draw");
+    assert!(fonts.platform_output.ime.is_none(), "no custom descriptor is published");
+    let guard = ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(egui::ViewportId::ROOT))).expect("the waiting guard");
+    assert!(guard.suspended && guard.request.is_none(), "the all-exit finalizer retired it without allocating");
+    let second = draw_app_pass(&mut app, &ctx, &frame, vec![])
+        .platform_output
+        .ime
+        .expect("returning to a drawing pass publishes the custom descriptor")
+        .reset_request
+        .expect("the deferred request");
+    assert_ne!(first, second);
+
+    // The device-loss early return is the other all-exit path. Preset the close bookkeeping
+    // so this test does not autosave; the pass must still retire the waiting guard.
+    app.gpu_failure_applied = Some(true);
+    app.device_lost_close = Some(true);
+    let lost = draw_app_pass(&mut app, &ctx, &frame, vec![]);
+    assert!(lost.platform_output.ime.is_none(), "a lost renderer publishes no descriptor");
+    let guard = ctx.data(|d| d.get_temp::<ResetGuard>(reset_id(egui::ViewportId::ROOT))).expect("the waiting guard");
+    assert!(guard.suspended && guard.request.is_none(), "the device-loss finalizer retired it without allocating");
+    app.gpu_failure_applied = None;
+    let third = draw_app_pass(&mut app, &ctx, &frame, vec![])
+        .platform_output
+        .ime
+        .expect("a drawing pass publishes the custom descriptor again")
+        .reset_request
+        .expect("the deferred request is one-shot");
+    assert_ne!(third, second);
+}
+
+#[test]
+fn ime_delete_without_a_session_or_with_an_empty_range_does_nothing() {
+    let (mut app, lid) = editor("abc", 1, 1);
+    feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 0, after_bytes: 0 })]);
+    assert_eq!(doc_text(&app, lid), "abc");
+    app.session.state.text_edit = None;
+    feed(&mut app, vec![egui::Event::Ime(egui::ImeEvent::DeleteSurroundingBytes { before_bytes: 2, after_bytes: 0 })]);
+    assert_eq!(doc_text(&app, lid), "abc");
+}
diff --git a/crates/ui-egui/src/panels/viewer_tools.rs b/crates/ui-egui/src/panels/viewer_tools.rs
index bde1869fd..316729d46 100644
--- a/crates/ui-egui/src/panels/viewer_tools.rs
+++ b/crates/ui-egui/src/panels/viewer_tools.rs
@@ -24,6 +24,7 @@ use crate::{EffectcraftApp, widgets};
 pub(crate) const SNAP_PX: f64 = 8.0;
 const SNAP_COLOR: Color32 = Color32::from_rgb(0xff, 0xd2, 0x3c);
 
+/// The `egui::Id` under which this frame's snap feedback is stored until `draw_snap` consumes it.
 fn snap_id() -> egui::Id {
     egui::Id::unique("viewer-snap")
 }
@@ -47,20 +48,21 @@ pub(crate) fn snap(
     sources: &[[f64; 2]],
     mods: egui::Modifiers,
 ) -> [f64; 2] {
-    snap_with(app, ctx, ectx, map, exclude, sources, mods, &[])
+    snap_with(app, ctx, ectx, map, &SnapQuery { exclude, sources, mods, extra: &[] })
 }
 
-/// [`snap`] with `extra` layer targets (the Pan Behind layer's own box).
-pub(crate) fn snap_with(
-    app: &EffectcraftApp,
-    ctx: &egui::Context,
-    ectx: &EvalCtx,
-    map: &ViewerMap,
-    exclude: &[LayerId],
-    sources: &[[f64; 2]],
-    mods: egui::Modifiers,
-    extra: &[vw::SnapTarget],
-) -> [f64; 2] {
+/// What [`snap_with`] snaps: the dragged features and the layers to ignore, plus `extra` layer
+/// targets (the Pan Behind layer's own box).
+pub(crate) struct SnapQuery<'a> {
+    pub exclude: &'a [LayerId],
+    pub sources: &'a [[f64; 2]],
+    pub mods: egui::Modifiers,
+    pub extra: &'a [vw::SnapTarget],
+}
+
+/// [`snap`] with extra layer targets.
+pub(crate) fn snap_with(app: &EffectcraftApp, ctx: &egui::Context, ectx: &EvalCtx, map: &ViewerMap, q: &SnapQuery) -> [f64; 2] {
+    let SnapQuery { exclude, sources, mods, extra } = *q;
     let layers = snapping_on(app, mods);
     let v = &app.ui.viewer;
     let guides = v.snap_guides && v.guides;
@@ -318,11 +320,13 @@ pub(crate) fn proportional_grid(app: &EffectcraftApp, painter: &egui::Painter, c
 
 // ---------------------------------------------------------------- the displayed frame
 
-/// Remember the region of interest the displayed texture was rendered with.
+/// Store the displayed texture's Region of Interest or Extended Viewer area unchanged.
 pub(crate) fn set_texture_roi(ctx: &egui::Context, roi: Option<[f64; 4]>) {
     ctx.data_mut(|d| d.insert_temp(egui::Id::unique("viewer-tex-roi"), roi));
 }
 
+/// The comp region (`[x, y, w, h]` in pixels) used for the texture: Region of Interest or Extended Viewer area,
+/// or `None` when no explicit region is stored, meaning the whole comp.
 fn texture_roi(ctx: &egui::Context) -> Option<[f64; 4]> {
     ctx.data(|d| d.get_temp::<Option<[f64; 4]>>(egui::Id::unique("viewer-tex-roi"))).flatten()
 }
@@ -362,6 +366,7 @@ pub(crate) fn display_key(app: &EffectcraftApp, has_conversion: bool) -> String
 /// is set), or the snapshot while Show Snapshot is on / F5 is held, through Show Channel and the
 /// exposure. Fast Previews ▸ Wireframe draws layer outlines instead.
 pub(crate) fn draw_frame(app: &mut EffectcraftApp, ctx: &egui::Context, painter: &egui::Painter, comp_rect: Rect, cid: ItemId, ectx: &EvalCtx) {
+    clear_sample_source(ctx);
     let opts = app.session.state.viewer.clone();
     let snap = showing_snapshot(app, ctx);
     // Settings ▸ Video ▸ Mirror on Computer Monitor off: playback goes to Video Preview only.
@@ -389,6 +394,8 @@ pub(crate) fn draw_frame(app: &mut EffectcraftApp, ctx: &egui::Context, painter:
     let dc = vw::DisplayColor::of(&app.session);
     let dc_key = display_key(app, dc.is_some());
     let plain = opts.channel == Channel::Rgb && opts.exposure == 0.0 && dc.is_none();
+    let display = SampleDisplay { channel: opts.channel, colorized: opts.colorized, exposure: opts.exposure, conversion: dc.clone() };
+    let region = shown_region(ctx, [ectx.comp.width as f32, ectx.comp.height as f32]);
     let uv = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
     if snap {
         let Some(s) = app.session.snapshot.clone() else { return };
@@ -411,6 +418,12 @@ pub(crate) fn draw_frame(app: &mut EffectcraftApp, ctx: &egui::Context, painter:
             }
         };
         painter.image(tex.id(), comp_rect, uv, Color32::WHITE);
+        note_sample_source(
+            ctx,
+            SampleSource::Snapshot(s.image.clone()),
+            [0.0, 0.0, ectx.comp.width as f64, ectx.comp.height as f64],
+            (!plain).then_some(display),
+        );
         painter.text(comp_rect.left_top() + vec2(6.0, 6.0), Align2::LEFT_TOP, crate::i18n::tr("Snapshot"), Tokens::ui(11.0), SNAP_COLOR);
         return;
     }
@@ -424,6 +437,9 @@ pub(crate) fn draw_frame(app: &mut EffectcraftApp, ctx: &egui::Context, painter:
                 ctx.request_repaint();
             }
             painter.image(id, comp_rect, uv, Color32::WHITE);
+            if let Some((_, key)) = app.viewer_shown {
+                note_sample_source(ctx, SampleSource::Gpu(key), region, None);
+            }
             return;
         }
         comp_rect
@@ -440,6 +456,9 @@ pub(crate) fn draw_frame(app: &mut EffectcraftApp, ctx: &egui::Context, painter:
         if plain {
             let uv = app.viewer_image.as_ref().map_or(uv, |src| fitted_uv(ctx, src.size, minify));
             painter.image(tex.id(), rect, uv, Color32::WHITE);
+            if let Some(image) = app.viewer_image.clone() {
+                note_sample_source(ctx, SampleSource::Cpu(image), region, None);
+            }
             return;
         }
         rect
@@ -466,6 +485,71 @@ pub(crate) fn draw_frame(app: &mut EffectcraftApp, ctx: &egui::Context, painter:
         }
     };
     painter.image(tex.id(), rect, fitted_uv(ctx, src.size, minify), Color32::WHITE);
+    note_sample_source(ctx, SampleSource::Cpu(src), region, Some(display));
+}
+
+#[derive(Clone)]
+enum SampleSource {
+    Cpu(std::sync::Arc<egui::ColorImage>),
+    Gpu(crate::frames::FrameKey),
+    Snapshot(std::sync::Arc<effectcraft_engine::render::Image>),
+}
+
+#[derive(Clone)]
+struct SampleDisplay {
+    channel: Channel,
+    colorized: bool,
+    exposure: f32,
+    conversion: Option<vw::DisplayColor>,
+}
+
+#[derive(Clone)]
+struct DisplayedSample {
+    pass: u64,
+    source: SampleSource,
+    region: [f64; 4],
+    display: Option<SampleDisplay>,
+}
+
+fn sample_source_id() -> egui::Id {
+    egui::Id::unique("viewer-displayed-sample-source")
+}
+
+pub(crate) fn clear_sample_source(ctx: &egui::Context) {
+    ctx.data_mut(|data| data.remove::<DisplayedSample>(sample_source_id()));
+}
+
+fn note_sample_source(ctx: &egui::Context, source: SampleSource, region: [f64; 4], display: Option<SampleDisplay>) {
+    let sample = DisplayedSample { pass: ctx.cumulative_pass_nr(), source, region, display };
+    ctx.data_mut(|data| data.insert_temp(sample_source_id(), sample));
+}
+
+/// Sample only a frame actually drawn this pass, with that draw's channel, exposure and
+/// display conversion. Hidden and wireframe views deliberately have no sample source.
+pub(crate) fn sample_displayed(app: &EffectcraftApp, ctx: &egui::Context, point: [f64; 2]) -> Option<[f32; 4]> {
+    let sample = ctx.data(|data| data.get_temp::<DisplayedSample>(sample_source_id()))?;
+    if sample.pass != ctx.cumulative_pass_nr() {
+        return None;
+    }
+    let pixel = match sample.source {
+        SampleSource::Cpu(image) => super::fx_widgets::frame_pixel(&image, sample.region, point)?,
+        SampleSource::Gpu(key) => {
+            if app.viewer_shown.map(|(_, shown)| shown) != Some(key) {
+                return None;
+            }
+            super::fx_widgets::frame_pixel(app.viewer_image.as_ref()?, sample.region, point)?
+        }
+        SampleSource::Snapshot(image) => {
+            let index = super::fx_widgets::frame_pixel_index([image.width as usize, image.height as usize], sample.region, point)?;
+            crate::frames::display_pixel(*image.data.get(index)?)
+        }
+    };
+    let image = egui::ColorImage::new([1, 1], vec![pixel]);
+    let image = match sample.display {
+        Some(display) => transformed(&image, display.channel, display.colorized, display.exposure, display.conversion),
+        None => image,
+    };
+    super::fx_widgets::sample_frame(&image, [0.0, 0.0, 1.0, 1.0], [0.5, 0.5])
 }
 
 /// The texture coordinates of a frame of `size` in its texture, fitted with at least `minify`
@@ -505,6 +589,7 @@ fn popup(app: &mut EffectcraftApp, ui: &mut egui::Ui, id: &str, anchor: Rect, it
     })
 }
 
+/// Flip the open flag of the popup with `id`; the caller that owns the popup reads the same flag.
 fn toggle_popup(ui: &egui::Ui, id: &str) {
     let pid = egui::Id::unique(id).with("open");
     let open: bool = ui.data(|d| d.get_temp(pid).unwrap_or(false));
@@ -584,8 +669,8 @@ pub(crate) fn resolution_label(res: Resolution, scale: f64) -> String {
 }
 
 /// The Composition panel's bottom bar, in After Effects 2026 order: magnification, resolution,
-/// transparency grid, mask and shape path visibility, region of interest, grid and guide
-/// options, show channel, reset exposure, exposure, take / show snapshot, Fast Previews, the 3D
+/// Fast Previews, transparency grid, mask and shape path visibility, region of interest, grid and
+/// guide options, show channel, reset exposure, exposure, take / show snapshot, the 3D
 /// renderer and view, and the current time.
 pub(crate) fn bottom_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui, bar: Rect, zoom: f32, time: Tick, comp: &Comp) {
     let t = app.tokens;
@@ -616,6 +701,31 @@ pub(crate) fn bottom_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui, bar: Rect,
     });
 }
 
+/// The exposure drag field (stops) at `er`; a change runs `view.exposure`.
+fn exposure_field(app: &mut EffectcraftApp, ui: &mut egui::Ui, er: Rect, stops: f64) {
+    let mut ev = stops;
+    let resp = ui.put(
+        er,
+        crate::widgets::drag_value(
+            egui::DragValue::new(&mut ev)
+                .speed(0.05)
+                .range(-40.0..=40.0)
+                .fixed_decimals(1)
+                .custom_formatter(|v, _| if v == 0.0 { "0.0".into() } else { format!("{v:+.1}") }),
+        ),
+    );
+    let resp = resp.on_hover_text(crate::i18n::tr("Adjust Exposure (stops)"));
+    app.auto.add_response("viewer.exposure", &resp, "Adjust Exposure");
+    if resp.changed() {
+        let _ = app.session.execute("view.exposure", json!({"stops": ev}));
+    }
+}
+
+/// Lay out the viewer's control row from `bar.min.x`: magnification, resolution, Fast Previews,
+/// transparency, mask, ROI, grid/guide, channel/colour management, exposure, snapshot, 3D
+/// renderer/view and Extended Viewer, timecode and render-time indicators, running commands or
+/// toggling viewer UI state. Returns the width the row occupies, at least `bar.width()`, for the
+/// horizontal scroll area.
 fn bottom_bar_contents(app: &mut EffectcraftApp, ui: &mut egui::Ui, bar: Rect, zoom: f32, time: Tick, comp: &Comp) -> f32 {
     let t = app.tokens;
     let p = ui.painter().clone();
@@ -670,6 +780,16 @@ fn bottom_bar_contents(app: &mut EffectcraftApp, ui: &mut egui::Ui, bar: Rect, z
         *x += 24.0;
         (resp.clicked(), r)
     };
+    // Fast Previews.
+    let fp = app.session.state.viewer.fast_previews;
+    let (clicked, fr) = tog(ui, &mut app.auto, &mut x, Icon::Sparkle, fp != FastPreviews::Off || app.ui.viewer.fast_preview, "fastPreviews", "Fast Previews");
+    if clicked {
+        toggle_popup(ui, "vw-fast-pop");
+    }
+    let items: Vec<(String, bool)> = FastPreviews::ALL.iter().map(|m| (m.label().to_string(), fp == *m)).collect();
+    if let Some(i) = popup(app, ui, "vw-fast-pop", fr, &items, "fastPreviewsItem") {
+        let _ = app.session.execute("view.fastPreviewMode", json!({"mode": FastPreviews::ALL[i].id()}));
+    }
     if tog(ui, &mut app.auto, &mut x, Icon::Checker, app.ui.viewer.transparency_grid, "transparency", "Toggle Transparency Grid").0 {
         app.ui.viewer.transparency_grid = !app.ui.viewer.transparency_grid;
     }
@@ -735,22 +855,7 @@ fn bottom_bar_contents(app: &mut EffectcraftApp, ui: &mut egui::Ui, bar: Rect, z
         let _ = app.session.execute("view.resetExposure", json!({}));
     }
     let er = Rect::from_min_size(pos2(x, cy - 10.0), vec2(42.0, 20.0));
-    let mut ev = vo.exposure as f64;
-    let resp = ui.put(
-        er,
-        crate::widgets::drag_value(
-            egui::DragValue::new(&mut ev)
-                .speed(0.05)
-                .range(-40.0..=40.0)
-                .fixed_decimals(1)
-                .custom_formatter(|v, _| if v == 0.0 { "0.0".into() } else { format!("{v:+.1}") }),
-        ),
-    );
-    let resp = resp.on_hover_text(crate::i18n::tr("Adjust Exposure (stops)"));
-    app.auto.add_response("viewer.exposure", &resp, "Adjust Exposure");
-    if resp.changed() {
-        let _ = app.session.execute("view.exposure", json!({"stops": ev}));
-    }
+    exposure_field(app, ui, er, vo.exposure as f64);
     x = er.max.x + 4.0;
     // Snapshots.
     if tog(ui, &mut app.auto, &mut x, Icon::Snapshot, false, "snapshot", "Take Snapshot").0 {
@@ -767,16 +872,6 @@ fn bottom_bar_contents(app: &mut EffectcraftApp, ui: &mut egui::Ui, bar: Rect, z
     if app.session.snapshot.is_some() && held != app.session.state.viewer.show_snapshot {
         let _ = app.session.execute("view.showSnapshot", json!({"value": held}));
     }
-    // Fast Previews.
-    let fp = vo.fast_previews;
-    let (clicked, fr) = tog(ui, &mut app.auto, &mut x, Icon::Sparkle, fp != FastPreviews::Off || app.ui.viewer.fast_preview, "fastPreviews", "Fast Previews");
-    if clicked {
-        toggle_popup(ui, "vw-fast-pop");
-    }
-    let items: Vec<(String, bool)> = FastPreviews::ALL.iter().map(|m| (m.label().to_string(), fp == *m)).collect();
-    if let Some(i) = popup(app, ui, "vw-fast-pop", fr, &items, "fastPreviewsItem") {
-        let _ = app.session.execute("view.fastPreviewMode", json!({"mode": FastPreviews::ALL[i].id()}));
-    }
     x += 4.0;
     // 3D renderer + view.
     if comp.has_3d() {
@@ -801,13 +896,13 @@ fn bottom_bar_contents(app: &mut EffectcraftApp, ui: &mut egui::Ui, bar: Rect, z
         let cid = app.session.active_comp_id();
         let cur = cid.and_then(|c| app.session.state.views3d.get(&c)).map(|v| v.current).unwrap_or_default();
         let r = Rect::from_min_size(pos2(x, cy - 10.0), vec2(118.0, 20.0));
-        let response = widgets::dropdown(ui, r, cur.label(), &t, egui::Id::unique("vw-cam"));
+        let response = widgets::dropdown(ui, r, crate::panels::viewer::view3d_label(cur), &t, egui::Id::unique("vw-cam"));
         if response.clicked() {
             toggle_popup(ui, "vw-cam-pop");
         }
         app.auto.add_response("viewer.view3d", &response, "3D View");
         use effectcraft_engine::render::three_d::View3D;
-        let items: Vec<(String, bool)> = View3D::ALL.iter().map(|v| (v.label().to_string(), *v == cur)).collect();
+        let items: Vec<(String, bool)> = View3D::ALL.iter().map(|v| (crate::panels::viewer::view3d_label(*v).to_string(), *v == cur)).collect();
         if let Some(i) = popup(app, ui, "vw-cam-pop", r, &items, "view3dItem") {
             let _ = app.session.execute("view.set3DView", json!({"view": View3D::ALL[i].id()}));
         }
diff --git a/crates/ui-egui/src/panels/viewers.rs b/crates/ui-egui/src/panels/viewers.rs
index 097cbeced..e8be901b9 100644
--- a/crates/ui-egui/src/panels/viewers.rs
+++ b/crates/ui-egui/src/panels/viewers.rs
@@ -14,7 +14,7 @@ use egui::{Align2, Color32, Rect, Sense, pos2, vec2};
 use serde_json::json;
 
 use crate::EffectcraftApp;
-use crate::dock::PanelKind;
+use crate::dock::{PanelKind, WorkspaceExt as _};
 use crate::frames::{FrameImage, FrameKey};
 use crate::theme::Tokens;
 
@@ -59,7 +59,7 @@ pub fn locked(app: &EffectcraftApp, id: u32) -> bool {
 /// Viewer `id`'s panel is docked or floating.
 fn open(app: &EffectcraftApp, id: u32) -> bool {
     let p = panel(id);
-    app.ui.dock.contains(p) || app.ui.floating.iter().any(|f| f.panels.contains(&p))
+    app.ui.dock.is_open(p)
 }
 
 /// The comp viewer `id` shows: the active comp in the active viewer, else its own.
@@ -241,7 +241,7 @@ pub fn on_open_comp(app: &mut EffectcraftApp, comp: ItemId) {
     // The comp's viewer and its Timeline tab come to the front (unless locked), reopened if they
     // were closed (as in After Effects).
     for p in [active_panel(app), PanelKind::Timeline] {
-        let closed = !app.ui.dock.contains(p) && !app.ui.floating.iter().any(|f| f.panels.contains(&p));
+        let closed = !app.ui.dock.is_open(p);
         if closed || !app.ui.locked_tabs.contains(&p.id()) {
             app.raise_panel(p);
         }
@@ -267,8 +267,8 @@ fn add_viewer(app: &mut EffectcraftApp, near: u32) -> u32 {
     let id = app.ui.viewers.keys().copied().max().unwrap_or(0).saturating_add(1).max(1);
     app.ui.viewers.insert(id, None);
     let p = panel(id);
-    let anchor = if app.ui.dock.contains(panel(near)) { panel(near) } else { PanelKind::Composition };
-    app.ui.dock.open_near(p, anchor);
+    let anchor = [panel(near), PanelKind::Composition].into_iter().find(|q| app.ui.dock.is_open(*q));
+    let _ = app.ui.dock.apply(craft_ui::docking::Action::Open { panel: p, anchor }, crate::dock::permissions);
     id
 }
 
diff --git a/crates/ui-egui/src/pointer_wrap.rs b/crates/ui-egui/src/pointer_wrap.rs
index 705c38be2..53748bd7e 100644
--- a/crates/ui-egui/src/pointer_wrap.rs
+++ b/crates/ui-egui/src/pointer_wrap.rs
@@ -12,6 +12,7 @@ struct State {
     disabled: bool,
 }
 
+/// The temp-data id of the [`State`] that tracks a numeric scrub across monitor edges.
 fn state_id() -> Id {
     Id::unique("numeric-pointer-wrap")
 }
@@ -176,356 +177,4 @@ pub(crate) fn finish_native(ctx: &Context, frame: &eframe::Frame) {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use egui::{Event, Id, Modifiers, PointerButton, pos2, vec2};
-
-    struct Scrub {
-        ctx: Context,
-        value: f64,
-        bounds: Rect,
-        time: f64,
-        accept_warp: bool,
-        warps: Vec<Pos2>,
-        standard: bool,
-        ordinary: bool,
-        angle: bool,
-        angle_rects: Option<(Rect, Rect)>,
-        modifiers: Modifiers,
-        injected: bool,
-    }
-
-    impl Scrub {
-        fn new() -> Self {
-            Self {
-                ctx: Context::default(),
-                value: 0.0,
-                bounds: Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0)),
-                time: 0.0,
-                accept_warp: true,
-                warps: Vec::new(),
-                standard: false,
-                ordinary: false,
-                angle: false,
-                angle_rects: None,
-                modifiers: Modifiers::NONE,
-                injected: false,
-            }
-        }
-
-        fn frame(&mut self, events: Vec<Event>, focused: bool) {
-            self.time += 0.02;
-            let mut raw = RawInput {
-                screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))),
-                time: Some(self.time),
-                events,
-                focused,
-                ..Default::default()
-            };
-            raw.events.push(Event::ModifiersChanged(self.modifiers));
-            prepare_input(&self.ctx, &mut raw, self.injected);
-            let mut out = self.ctx.run_ui(raw, |ui| {
-                if self.standard {
-                    ui.put(
-                        Rect::from_min_size(pos2(100.0, 100.0), vec2(60.0, 20.0)),
-                        crate::widgets::drag_value(egui::DragValue::new(&mut self.value).speed(1.0).max_decimals(3)),
-                    );
-                } else if self.ordinary {
-                    ui.interact(Rect::from_min_size(pos2(100.0, 100.0), vec2(60.0, 20.0)), Id::unique("ordinary"), egui::Sense::drag());
-                } else if self.angle {
-                    let (rr, dr, value) = crate::panels::fx_widgets::angle_field(
-                        ui,
-                        pos2(100.0, 100.0),
-                        Id::unique("scrub"),
-                        self.value,
-                        1,
-                        &crate::theme::Tokens::for_kind(crate::theme::ThemeKind::Dark),
-                    );
-                    self.angle_rects = Some((rr, dr));
-                    if let Some(v) = value {
-                        self.value = v;
-                    }
-                } else {
-                    let (_, value, _) = crate::widgets::hot_number_at(
-                        ui,
-                        pos2(100.0, 100.0),
-                        Id::unique("scrub"),
-                        self.value,
-                        1.0,
-                        (-1e9, 1e9),
-                        1,
-                        "",
-                        &crate::theme::Tokens::for_kind(crate::theme::ThemeKind::Dark),
-                    );
-                    if let Some(v) = value {
-                        self.value = v;
-                    }
-                }
-                finish_frame(ui.ctx(), self.bounds, |p| {
-                    self.warps.push(p);
-                    self.accept_warp.then_some(p)
-                });
-            });
-            out.textures_delta.clear();
-        }
-
-        fn move_to(&mut self, p: Pos2) {
-            self.frame(vec![Event::PointerMoved(p)], true);
-        }
-
-        fn begin(&mut self) {
-            self.frame(vec![], true);
-            let p = pos2(105.0, 108.0);
-            self.frame(
-                vec![Event::PointerMoved(p), Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }],
-                true,
-            );
-            self.move_to(p + vec2(10.0, 0.0));
-        }
-    }
-
-    #[test]
-    fn angle_degrees_continue_across_zero_and_repeated_monitor_wraps() {
-        for initial in [0.0, 359.5, -359.5, 720.0, -720.0] {
-            for direction in [-1.0, 1.0] {
-                let mut s = Scrub::new();
-                s.angle = true;
-                s.value = initial;
-                s.frame(vec![], true);
-                let p = s.angle_rects.unwrap().1.center();
-                s.frame(
-                    vec![Event::PointerMoved(p), Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }],
-                    true,
-                );
-                let mut last = p;
-                let mut expected = initial;
-                // Feed small real movements, including zero/whole-turn crossings, then
-                // the synthetic OS warp. Every real pixel contributes exactly once.
-                for step in 0..800 {
-                    let direction = if step < 400 { direction } else { -direction };
-                    let next = pos2((last.x + direction * 13.0).clamp(1.0, 799.0), last.y);
-                    expected += f64::from(next.x - last.x) * 0.5;
-                    let count = s.warps.len();
-                    s.move_to(next);
-                    assert!((s.value - expected).abs() < 1e-6, "initial={initial}, direction={direction}, actual={}, expected={expected}", s.value);
-                    last = next;
-                    if s.warps.len() > count {
-                        last = *s.warps.last().unwrap();
-                        s.move_to(last);
-                        assert!((s.value - expected).abs() < 1e-6, "the teleport must not reset the angle");
-                    }
-                }
-                assert!(s.warps.len() >= 5);
-            }
-        }
-    }
-
-    #[test]
-    fn numeric_drag_wraps_repeatedly_without_counting_the_teleport() {
-        let mut s = Scrub::new();
-        s.begin();
-        for _ in 0..5 {
-            s.move_to(pos2(799.0, 108.0));
-            let target = *s.warps.last().expect("numeric drag must wrap at the monitor edge");
-            assert!(target.x < 16.0);
-            let before = s.value;
-            s.move_to(target);
-            assert_eq!(s.value, before, "the warp itself must not change the value");
-            s.move_to(target + vec2(20.0, 0.0));
-            assert_eq!(s.value, before + 20.0);
-        }
-        assert_eq!(s.warps.len(), 5);
-        s.move_to(pos2(0.0, 108.0));
-        let target = *s.warps.last().unwrap();
-        assert!(target.x > 780.0);
-        let before = s.value;
-        s.move_to(target - vec2(3.0, 0.0));
-        assert_eq!(s.value, before - 3.0, "coalesced movement after a left-edge warp is preserved");
-    }
-
-    /// An agent's `ui.drag` over the control channel scrubs the value but never moves the user's
-    /// real cursor, even at the window's (monitor's) edge.
-    #[test]
-    fn injected_drags_never_warp_the_real_cursor() {
-        let mut s = Scrub::new();
-        s.injected = true;
-        s.begin();
-        s.move_to(pos2(799.0, 108.0));
-        assert!(s.warps.is_empty());
-    }
-
-    #[test]
-    fn normal_pointer_movement_does_not_warp() {
-        let mut s = Scrub::new();
-        s.move_to(pos2(799.0, 108.0));
-        assert!(s.warps.is_empty());
-    }
-
-    #[test]
-    fn standard_editor_wraps_at_top_bottom_and_corner_without_a_value_jump() {
-        let mut s = Scrub::new();
-        s.standard = true;
-        s.begin();
-        for edge in [pos2(200.0, 0.0), pos2(200.0, 599.0), pos2(799.0, 599.0)] {
-            s.move_to(edge);
-            let target = *s.warps.last().unwrap();
-            assert_ne!(target, edge);
-            let before = s.value;
-            s.move_to(target);
-            assert_eq!(s.value, before);
-            s.move_to(target + vec2(5.0, -5.0));
-            assert_eq!(s.value, before + 10.0);
-        }
-    }
-
-    #[test]
-    fn release_and_focus_loss_end_wrapping_and_restore_normal_hit_testing() {
-        for lose_focus in [false, true] {
-            let mut s = Scrub::new();
-            s.begin();
-            s.move_to(pos2(799.0, 108.0));
-            let target = *s.warps.last().unwrap();
-            s.move_to(target);
-            let value = s.value;
-            let events = if lose_focus {
-                vec![Event::WindowFocused(false)]
-            } else {
-                vec![Event::PointerButton { pos: target, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }]
-            };
-            s.frame(events, !lose_focus);
-            s.move_to(pos2(799.0, 108.0));
-            assert_eq!(s.warps.len(), 1);
-            assert_eq!(s.value, value);
-            assert_eq!(s.ctx.input(|i| i.pointer.latest_pos()), Some(pos2(799.0, 108.0)));
-            s.begin();
-            s.move_to(pos2(799.0, 108.0));
-            assert_eq!(s.warps.len(), 2, "the next independent drag still wraps");
-        }
-    }
-
-    #[test]
-    fn object_drag_does_not_wrap_and_failed_warp_is_not_retried() {
-        let mut s = Scrub::new();
-        s.ordinary = true;
-        s.begin();
-        s.move_to(pos2(799.0, 108.0));
-        assert!(s.warps.is_empty());
-
-        let mut s = Scrub::new();
-        s.accept_warp = false;
-        s.begin();
-        s.move_to(pos2(799.0, 108.0));
-        for _ in 0..3 {
-            s.move_to(pos2(799.0, 108.0));
-        }
-        assert_eq!(s.warps.len(), 1);
-        let value = s.value;
-        s.move_to(pos2(779.0, 108.0));
-        assert_eq!(s.value, value - 20.0);
-    }
-
-    #[test]
-    fn modifiers_keep_their_sensitivity_after_wrapping() {
-        for (modifiers, multiplier) in [(Modifiers::SHIFT, 10.0), (Modifiers::COMMAND, 0.1)] {
-            let mut s = Scrub::new();
-            s.modifiers = modifiers;
-            s.begin();
-            s.move_to(pos2(799.0, 108.0));
-            let target = *s.warps.last().unwrap();
-            let value = s.value;
-            s.move_to(target + vec2(10.0, 0.0));
-            assert!((s.value - value - 10.0 * multiplier).abs() < 1e-8);
-        }
-    }
-
-    #[test]
-    fn monitor_rect_can_extend_beyond_the_app_and_have_a_negative_origin() {
-        let mut s = Scrub::new();
-        s.bounds = Rect::from_min_size(pos2(-200.0, -100.0), vec2(1200.0, 800.0));
-        s.begin();
-        s.move_to(pos2(999.0, 108.0));
-        let target = *s.warps.last().unwrap();
-        assert_eq!(target, pos2(-192.0, 108.0));
-        let value = s.value;
-        s.frame(vec![Event::PointerGone, Event::PointerMoved(target)], true);
-        assert_eq!(s.value, value);
-        s.move_to(target + vec2(10.0, 0.0));
-        assert_eq!(s.value, value + 10.0);
-    }
-
-    #[test]
-    fn real_properties_and_angle_drags_keep_each_gesture_in_one_undo_step() {
-        use crate::{EffectcraftApp, dock::PanelKind};
-        use effectcraft_engine::project::LayerId;
-        use eframe::App;
-        use serde_json::json;
-
-        for angle in [false, true] {
-            let mut session = effectcraft_host::session();
-            session.execute("comp.new", json!({"width": 32, "height": 16})).unwrap();
-            let lid = session.execute("layer.newSolid", json!({"width": 8, "height": 8})).unwrap()["layer"].as_u64().unwrap();
-            let path = if angle { "transform/rotation" } else { "transform/position" };
-            let prop = session.active_comp().unwrap().layer(LayerId(lid)).unwrap().props.prop(path).unwrap();
-            let uid = prop.uid;
-            let original = prop.value.clone();
-            let undo = session.history.undo.len();
-            let panel = PanelKind::Properties;
-            let id = if angle { format!("properties.prop.{uid}.value") } else { format!("properties.prop.{uid}.value.0") };
-            let mut app = EffectcraftApp::new(session);
-            app.show_panel(panel);
-            app.toggle_maximize(panel);
-            let ctx = Context::default();
-            let bounds = Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 1000.0));
-            let mut frame = eframe::Frame::_new_kittest();
-            let mut time = 0.0;
-            let mut step = |app: &mut EffectcraftApp, events| {
-                time += 1.0 / 60.0;
-                let mut raw = RawInput { screen_rect: Some(bounds), time: Some(time), events, ..Default::default() };
-                app.raw_input_hook(&ctx, &mut raw);
-                let mut warp = None;
-                let mut out = ctx.run_ui(raw, |ui| {
-                    app.logic(ui.ctx(), &mut frame);
-                    app.ui(ui, &mut frame);
-                    finish_frame(ui.ctx(), bounds, |p| {
-                        warp = Some(p);
-                        Some(p)
-                    });
-                });
-                out.textures_delta.clear();
-                warp
-            };
-            for _ in 0..4 {
-                step(&mut app, vec![]);
-            }
-            for gesture in 1..=2 {
-                let direction = if gesture == 1 { -1.0 } else { 1.0 };
-                let r = app.auto.find(&id).unwrap().rect;
-                let p = pos2(r[0] + r[2] / 2.0, r[1] + r[3] / 2.0);
-                step(
-                    &mut app,
-                    vec![Event::PointerMoved(p), Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }],
-                );
-                step(&mut app, vec![Event::PointerMoved(p + vec2(direction * 10.0, 0.0))]);
-                let mut last = p;
-                for _ in 0..3 {
-                    let edge = if direction < 0.0 { 1.0 } else { 1599.0 };
-                    let target = step(&mut app, vec![Event::PointerMoved(pos2(edge, p.y))]).expect("real property scrubs wrap");
-                    let before = app.session.active_comp().unwrap().layer(LayerId(lid)).unwrap().props.find(uid).unwrap().value.clone();
-                    step(&mut app, vec![Event::PointerMoved(target)]);
-                    assert_eq!(app.session.active_comp().unwrap().layer(LayerId(lid)).unwrap().props.find(uid).unwrap().value, before);
-                    last = target + vec2(direction * 10.0, 0.0);
-                    step(&mut app, vec![Event::PointerMoved(last)]);
-                    if angle {
-                        let value = app.session.active_comp().unwrap().layer(LayerId(lid)).unwrap().props.find(uid).unwrap().value.as_f64();
-                        assert!((value - before.as_f64() - f64::from(direction) * 5.0).abs() < 1e-6);
-                    }
-                }
-                step(&mut app, vec![Event::PointerButton { pos: last, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }]);
-                assert_eq!(app.session.history.undo.len(), undo + gesture, "each drag is one undo step: {panel:?}");
-            }
-            app.session.execute("edit.undo", json!({})).unwrap();
-            app.session.execute("edit.undo", json!({})).unwrap();
-            assert_eq!(app.session.active_comp().unwrap().layer(LayerId(lid)).unwrap().props.find(uid).unwrap().value, original);
-        }
-    }
-}
+mod tests;
diff --git a/crates/ui-egui/src/pointer_wrap/tests.rs b/crates/ui-egui/src/pointer_wrap/tests.rs
new file mode 100644
index 000000000..314f7ad3d
--- /dev/null
+++ b/crates/ui-egui/src/pointer_wrap/tests.rs
@@ -0,0 +1,343 @@
+use super::*;
+use egui::{Event, Id, Modifiers, PointerButton, pos2, vec2};
+
+struct Scrub {
+    ctx: Context,
+    value: f64,
+    bounds: Rect,
+    time: f64,
+    accept_warp: bool,
+    warps: Vec<Pos2>,
+    standard: bool,
+    ordinary: bool,
+    angle: bool,
+    angle_rects: Option<(Rect, Rect)>,
+    modifiers: Modifiers,
+    injected: bool,
+}
+
+impl Scrub {
+    fn new() -> Self {
+        Self {
+            ctx: Context::default(),
+            value: 0.0,
+            bounds: Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0)),
+            time: 0.0,
+            accept_warp: true,
+            warps: Vec::new(),
+            standard: false,
+            ordinary: false,
+            angle: false,
+            angle_rects: None,
+            modifiers: Modifiers::NONE,
+            injected: false,
+        }
+    }
+
+    fn frame(&mut self, events: Vec<Event>, focused: bool) {
+        self.time += 0.02;
+        let mut raw =
+            RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0))), time: Some(self.time), events, focused, ..Default::default() };
+        raw.events.push(Event::ModifiersChanged(self.modifiers));
+        prepare_input(&self.ctx, &mut raw, self.injected);
+        let mut out = self.ctx.run_ui(raw, |ui| {
+            if self.standard {
+                ui.put(
+                    Rect::from_min_size(pos2(100.0, 100.0), vec2(60.0, 20.0)),
+                    crate::widgets::drag_value(egui::DragValue::new(&mut self.value).speed(1.0).max_decimals(3)),
+                );
+            } else if self.ordinary {
+                ui.interact(Rect::from_min_size(pos2(100.0, 100.0), vec2(60.0, 20.0)), Id::unique("ordinary"), egui::Sense::drag());
+            } else if self.angle {
+                let (rr, dr, value) = crate::panels::fx_widgets::angle_field(
+                    ui,
+                    pos2(100.0, 100.0),
+                    Id::unique("scrub"),
+                    self.value,
+                    1,
+                    &crate::theme::Tokens::for_kind(crate::theme::ThemeKind::Dark),
+                );
+                self.angle_rects = Some((rr, dr));
+                if let Some(v) = value {
+                    self.value = v;
+                }
+            } else {
+                let (_, value, _) = crate::widgets::hot_number_at(
+                    ui,
+                    pos2(100.0, 100.0),
+                    Id::unique("scrub"),
+                    self.value,
+                    &crate::widgets::HotSpec { speed: 1.0, range: (-1e9, 1e9), decimals: 1, suffix: "" },
+                    &crate::theme::Tokens::for_kind(crate::theme::ThemeKind::Dark),
+                );
+                if let Some(v) = value {
+                    self.value = v;
+                }
+            }
+            finish_frame(ui.ctx(), self.bounds, |p| {
+                self.warps.push(p);
+                self.accept_warp.then_some(p)
+            });
+        });
+        out.textures_delta.clear();
+    }
+
+    fn move_to(&mut self, p: Pos2) {
+        self.frame(vec![Event::PointerMoved(p)], true);
+    }
+
+    fn begin(&mut self) {
+        self.frame(vec![], true);
+        let p = pos2(105.0, 108.0);
+        self.frame(
+            vec![Event::PointerMoved(p), Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }],
+            true,
+        );
+        self.move_to(p + vec2(10.0, 0.0));
+    }
+}
+
+#[test]
+fn angle_degrees_continue_across_zero_and_repeated_monitor_wraps() {
+    for initial in [0.0, 359.5, -359.5, 720.0, -720.0] {
+        for direction in [-1.0, 1.0] {
+            let mut s = Scrub::new();
+            s.angle = true;
+            s.value = initial;
+            s.frame(vec![], true);
+            let p = s.angle_rects.unwrap().1.center();
+            s.frame(
+                vec![Event::PointerMoved(p), Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }],
+                true,
+            );
+            let mut last = p;
+            let mut expected = initial;
+            // Feed small real movements, including zero/whole-turn crossings, then
+            // the synthetic OS warp. Every real pixel contributes exactly once.
+            for step in 0..800 {
+                let direction = if step < 400 { direction } else { -direction };
+                let next = pos2((last.x + direction * 13.0).clamp(1.0, 799.0), last.y);
+                expected += f64::from(next.x - last.x) * 0.5;
+                let count = s.warps.len();
+                s.move_to(next);
+                assert!((s.value - expected).abs() < 1e-6, "initial={initial}, direction={direction}, actual={}, expected={expected}", s.value);
+                last = next;
+                if s.warps.len() > count {
+                    last = *s.warps.last().unwrap();
+                    s.move_to(last);
+                    assert!((s.value - expected).abs() < 1e-6, "the teleport must not reset the angle");
+                }
+            }
+            assert!(s.warps.len() >= 5);
+        }
+    }
+}
+
+#[test]
+fn numeric_drag_wraps_repeatedly_without_counting_the_teleport() {
+    let mut s = Scrub::new();
+    s.begin();
+    for _ in 0..5 {
+        s.move_to(pos2(799.0, 108.0));
+        let target = *s.warps.last().expect("numeric drag must wrap at the monitor edge");
+        assert!(target.x < 16.0);
+        let before = s.value;
+        s.move_to(target);
+        assert_eq!(s.value, before, "the warp itself must not change the value");
+        s.move_to(target + vec2(20.0, 0.0));
+        assert_eq!(s.value, before + 20.0);
+    }
+    assert_eq!(s.warps.len(), 5);
+    s.move_to(pos2(0.0, 108.0));
+    let target = *s.warps.last().unwrap();
+    assert!(target.x > 780.0);
+    let before = s.value;
+    s.move_to(target - vec2(3.0, 0.0));
+    assert_eq!(s.value, before - 3.0, "coalesced movement after a left-edge warp is preserved");
+}
+
+/// An agent's `ui.drag` over the control channel scrubs the value but never moves the user's
+/// real cursor, even at the window's (monitor's) edge.
+#[test]
+fn injected_drags_never_warp_the_real_cursor() {
+    let mut s = Scrub::new();
+    s.injected = true;
+    s.begin();
+    s.move_to(pos2(799.0, 108.0));
+    assert!(s.warps.is_empty());
+}
+
+#[test]
+fn normal_pointer_movement_does_not_warp() {
+    let mut s = Scrub::new();
+    s.move_to(pos2(799.0, 108.0));
+    assert!(s.warps.is_empty());
+}
+
+#[test]
+fn standard_editor_wraps_at_top_bottom_and_corner_without_a_value_jump() {
+    let mut s = Scrub::new();
+    s.standard = true;
+    s.begin();
+    for edge in [pos2(200.0, 0.0), pos2(200.0, 599.0), pos2(799.0, 599.0)] {
+        s.move_to(edge);
+        let target = *s.warps.last().unwrap();
+        assert_ne!(target, edge);
+        let before = s.value;
+        s.move_to(target);
+        assert_eq!(s.value, before);
+        s.move_to(target + vec2(5.0, -5.0));
+        assert_eq!(s.value, before + 10.0);
+    }
+}
+
+#[test]
+fn release_and_focus_loss_end_wrapping_and_restore_normal_hit_testing() {
+    for lose_focus in [false, true] {
+        let mut s = Scrub::new();
+        s.begin();
+        s.move_to(pos2(799.0, 108.0));
+        let target = *s.warps.last().unwrap();
+        s.move_to(target);
+        let value = s.value;
+        let events = if lose_focus {
+            vec![Event::WindowFocused(false)]
+        } else {
+            vec![Event::PointerButton { pos: target, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }]
+        };
+        s.frame(events, !lose_focus);
+        s.move_to(pos2(799.0, 108.0));
+        assert_eq!(s.warps.len(), 1);
+        assert_eq!(s.value, value);
+        assert_eq!(s.ctx.input(|i| i.pointer.latest_pos()), Some(pos2(799.0, 108.0)));
+        s.begin();
+        s.move_to(pos2(799.0, 108.0));
+        assert_eq!(s.warps.len(), 2, "the next independent drag still wraps");
+    }
+}
+
+#[test]
+fn object_drag_does_not_wrap_and_failed_warp_is_not_retried() {
+    let mut s = Scrub::new();
+    s.ordinary = true;
+    s.begin();
+    s.move_to(pos2(799.0, 108.0));
+    assert!(s.warps.is_empty());
+
+    let mut s = Scrub::new();
+    s.accept_warp = false;
+    s.begin();
+    s.move_to(pos2(799.0, 108.0));
+    for _ in 0..3 {
+        s.move_to(pos2(799.0, 108.0));
+    }
+    assert_eq!(s.warps.len(), 1);
+    let value = s.value;
+    s.move_to(pos2(779.0, 108.0));
+    assert_eq!(s.value, value - 20.0);
+}
+
+#[test]
+fn modifiers_keep_their_sensitivity_after_wrapping() {
+    for (modifiers, multiplier) in [(Modifiers::SHIFT, 10.0), (Modifiers::COMMAND, 0.1)] {
+        let mut s = Scrub::new();
+        s.modifiers = modifiers;
+        s.begin();
+        s.move_to(pos2(799.0, 108.0));
+        let target = *s.warps.last().unwrap();
+        let value = s.value;
+        s.move_to(target + vec2(10.0, 0.0));
+        assert!((s.value - value - 10.0 * multiplier).abs() < 1e-8);
+    }
+}
+
+#[test]
+fn monitor_rect_can_extend_beyond_the_app_and_have_a_negative_origin() {
+    let mut s = Scrub::new();
+    s.bounds = Rect::from_min_size(pos2(-200.0, -100.0), vec2(1200.0, 800.0));
+    s.begin();
+    s.move_to(pos2(999.0, 108.0));
+    let target = *s.warps.last().unwrap();
+    assert_eq!(target, pos2(-192.0, 108.0));
+    let value = s.value;
+    s.frame(vec![Event::PointerGone, Event::PointerMoved(target)], true);
+    assert_eq!(s.value, value);
+    s.move_to(target + vec2(10.0, 0.0));
+    assert_eq!(s.value, value + 10.0);
+}
+
+#[test]
+fn real_properties_and_angle_drags_keep_each_gesture_in_one_undo_step() {
+    use crate::{EffectcraftApp, dock::PanelKind};
+    use effectcraft_engine::project::LayerId;
+    use eframe::App;
+    use serde_json::json;
+
+    for angle in [false, true] {
+        let mut session = effectcraft_host::session();
+        session.execute("comp.new", json!({"width": 32, "height": 16})).unwrap();
+        let lid = session.execute("layer.newSolid", json!({"width": 8, "height": 8})).unwrap()["layer"].as_u64().unwrap();
+        let path = if angle { "transform/rotation" } else { "transform/position" };
+        let prop = session.active_comp().unwrap().layer(LayerId(lid)).unwrap().props.prop(path).unwrap();
+        let uid = prop.uid;
+        let original = prop.value.clone();
+        let undo = session.history.undo.len();
+        let panel = PanelKind::Properties;
+        let id = if angle { format!("properties.prop.{uid}.value") } else { format!("properties.prop.{uid}.value.0") };
+        let mut app = EffectcraftApp::new(session);
+        app.show_panel(panel);
+        app.toggle_maximize(panel);
+        let ctx = Context::default();
+        let bounds = Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 1000.0));
+        let mut frame = eframe::Frame::_new_kittest();
+        let mut time = 0.0;
+        let mut step = |app: &mut EffectcraftApp, events| {
+            time += 1.0 / 60.0;
+            let mut raw = RawInput { screen_rect: Some(bounds), time: Some(time), events, ..Default::default() };
+            app.raw_input_hook(&ctx, &mut raw);
+            let mut warp = None;
+            let mut out = ctx.run_ui(raw, |ui| {
+                app.logic(ui.ctx(), &mut frame);
+                app.ui(ui, &mut frame);
+                finish_frame(ui.ctx(), bounds, |p| {
+                    warp = Some(p);
+                    Some(p)
+                });
+            });
+            out.textures_delta.clear();
+            warp
+        };
+        for _ in 0..4 {
+            step(&mut app, vec![]);
+        }
+        for gesture in 1..=2 {
+            let direction = if gesture == 1 { -1.0 } else { 1.0 };
+            let r = app.auto.find(&id).unwrap().rect;
+            let p = pos2(r[0] + r[2] / 2.0, r[1] + r[3] / 2.0);
+            step(
+                &mut app,
+                vec![Event::PointerMoved(p), Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }],
+            );
+            step(&mut app, vec![Event::PointerMoved(p + vec2(direction * 10.0, 0.0))]);
+            let mut last = p;
+            for _ in 0..3 {
+                let edge = if direction < 0.0 { 1.0 } else { 1599.0 };
+                let target = step(&mut app, vec![Event::PointerMoved(pos2(edge, p.y))]).expect("real property scrubs wrap");
+                let before = app.session.active_comp().unwrap().layer(LayerId(lid)).unwrap().props.find(uid).unwrap().value.clone();
+                step(&mut app, vec![Event::PointerMoved(target)]);
+                assert_eq!(app.session.active_comp().unwrap().layer(LayerId(lid)).unwrap().props.find(uid).unwrap().value, before);
+                last = target + vec2(direction * 10.0, 0.0);
+                step(&mut app, vec![Event::PointerMoved(last)]);
+                if angle {
+                    let value = app.session.active_comp().unwrap().layer(LayerId(lid)).unwrap().props.find(uid).unwrap().value.as_f64();
+                    assert!((value - before.as_f64() - f64::from(direction) * 5.0).abs() < 1e-6);
+                }
+            }
+            step(&mut app, vec![Event::PointerButton { pos: last, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }]);
+            assert_eq!(app.session.history.undo.len(), undo + gesture, "each drag is one undo step: {panel:?}");
+        }
+        app.session.execute("edit.undo", json!({})).unwrap();
+        app.session.execute("edit.undo", json!({})).unwrap();
+        assert_eq!(app.session.active_comp().unwrap().layer(LayerId(lid)).unwrap().props.find(uid).unwrap().value, original);
+    }
+}
diff --git a/crates/ui-egui/src/prefs_live.rs b/crates/ui-egui/src/prefs_live.rs
index ee222c892..b456dc7ce 100644
--- a/crates/ui-egui/src/prefs_live.rs
+++ b/crates/ui-egui/src/prefs_live.rs
@@ -63,6 +63,10 @@ pub fn dropped_files(app: &mut EffectcraftApp, ui: &egui::Ui, bounds: Rect) {
         errors.push(crate::i18n::tr_args("Skipped {} dropped file(s) without a local path. Use File ▸ Import ▸ File…", &[&skipped]));
     }
 
+    // Taken once per drop frame, so a handed-over flag cannot survive into a later, unrelated
+    // drop (#2661).
+    let handed_by_a_floating_window = std::mem::take(&mut app.forwarded.dropped_on_timeline);
+
     let (proj, rest): (Vec<String>, Vec<String>) = paths.into_iter().partition(|p| {
         let l = p.to_ascii_lowercase();
         l.ends_with(".ecproj") || l.ends_with(".ecprojx")
@@ -86,7 +90,18 @@ pub fn dropped_files(app: &mut EffectcraftApp, ui: &egui::Ui, bounds: Rect) {
             .find(|e| e.id == "viewer.area")
             .map(|e| Rect::from_min_size(egui::pos2(e.rect[0], e.rect[1]), egui::vec2(e.rect[2], e.rect[3])));
 
-        let at = if proj.is_empty() {
+        // Dropping a file on the Timeline adds it to the composition the panel shows, as it does
+        // on the viewer (#2588); the import decides the layer's position.
+        let over_timeline = handed_by_a_floating_window
+            || ctx.input(|i| i.pointer.hover_pos()).is_some_and(|p| {
+                app.auto
+                    .elements
+                    .iter()
+                    .find(|e| e.id == "panel.Timeline")
+                    .is_some_and(|e| Rect::from_min_size(egui::pos2(e.rect[0], e.rect[1]), egui::vec2(e.rect[2], e.rect[3])).contains(p))
+            });
+
+        let at = if proj.is_empty() && !over_timeline {
             ctx.input(|i| i.pointer.hover_pos()).filter(|p| viewer.is_some_and(|v| v.contains(*p))).and_then(|p| crate::panels::viewer::screen_to_comp(&ctx, p))
         } else {
             None
@@ -101,7 +116,7 @@ pub fn dropped_files(app: &mut EffectcraftApp, ui: &egui::Ui, bounds: Rect) {
         let mut params = json!({
             "paths": rest,
             "drag": true,
-            "addToComp": at.is_some(),
+            "addToComp": at.is_some() || over_timeline,
             "position": at,
             "background": true
         });
diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rs
index 1e2f57204..6abe76b2f 100644
--- a/crates/ui-egui/src/state.rs
+++ b/crates/ui-egui/src/state.rs
@@ -4,7 +4,7 @@ use std::collections::{BTreeMap, BTreeSet};
 
 use serde::{Deserialize, Serialize};
 
-use crate::dock::{DockNode, PanelKind};
+use crate::dock::PanelKind;
 use crate::icons::Icon;
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -229,6 +229,7 @@ impl Tool {
     }
 }
 
+use super::*;
 /// The viewer's Resolution: each composition keeps its own in the project
 /// ([`effectcraft_engine::project::Comp::resolution`], `EffectcraftApp::viewer_res`).
 pub use effectcraft_engine::project::Resolution;
@@ -306,6 +307,31 @@ impl Default for ViewerState {
 }
 
 impl TimelineState {
+    /// Whether property `uid`'s chain link (Constrain Proportions) is on. One that starts linked
+    /// (Scale, Mask Feather) records a click in `unlinked`; one that starts unlinked (shape Size,
+    /// Audio Levels) records it in `linked`.
+    pub fn is_linked(&self, uid: u64, linked_by_default: bool) -> bool {
+        if linked_by_default { !self.unlinked.contains(&uid) } else { self.linked.contains(&uid) }
+    }
+
+    /// Turn property `uid`'s chain link on or off (see [`Self::is_linked`]).
+    pub fn toggle_link(&mut self, uid: u64, linked_by_default: bool) {
+        let set = if linked_by_default { &mut self.unlinked } else { &mut self.linked };
+        if !set.remove(&uid) {
+            set.insert(uid);
+        }
+    }
+
+    /// Forget the chain links when the project was replaced (new or opened): they are keyed by
+    /// property uid, which the next project reuses, so a link turned on must not carry into it.
+    pub fn scope_links(&mut self, project_epoch: u64) {
+        if self.link_epoch != project_epoch {
+            self.link_epoch = project_epoch;
+            self.unlinked.clear();
+            self.linked.clear();
+        }
+    }
+
     /// Show `kinds` on `layers` (twirled open; empty: twirled closed) and remember it as the last
     /// reveal. Other layers keep theirs.
     pub fn apply_reveal(&mut self, layers: &[u64], kinds: Vec<String>) {
@@ -413,6 +439,13 @@ pub struct TimelineState {
     /// was turned off.
     #[serde(default)]
     pub unlinked: BTreeSet<u64>,
+    /// Shape Rectangle and Ellipse Path Size (#2489) and Audio Levels (#2485) properties whose
+    /// chain link (off by default) was turned on.
+    #[serde(default)]
+    pub linked: BTreeSet<u64>,
+    /// The project (its epoch) `unlinked` and `linked` belong to.
+    #[serde(skip)]
+    pub link_epoch: u64,
     /// Visible optional columns (column header right-click ▸ Columns): `av`, `keys`, `label`,
     /// `num`, `comment`, `switches`, `parent`, `in`, `out`, `duration`, `stretch`. The name
     /// column is always shown; Modes follows `show_modes` (F4).
@@ -465,6 +498,8 @@ impl Default for TimelineState {
             expr_closed: BTreeSet::new(),
             expr_lines: BTreeMap::new(),
             unlinked: BTreeSet::new(),
+            linked: BTreeSet::new(),
+            link_epoch: 0,
             columns: default_tl_columns(),
             source_name: false,
             scroll_to: None,
@@ -568,23 +603,20 @@ pub struct UiState {
     /// Tool shown in each toolbar slot.
     pub slot_tools: Vec<Tool>,
     pub workspace: String,
-    pub dock: DockNode,
+    /// The current layout: docked frames, floating windows (one can be recorded as its own
+    /// native window, Move Panel to New Window) and the places of closed panels.
+    pub dock: crate::dock::Workspace,
     /// Saved workspace layouts (Save Changes to this Workspace / Save as New Workspace).
     #[serde(default)]
-    pub saved_workspaces: std::collections::BTreeMap<String, DockNode>,
-    /// Undocked (floating) panel groups.
-    #[serde(default)]
-    pub floating: Vec<crate::dock::Floating>,
-    /// Floating panels of the saved workspaces.
-    #[serde(default)]
-    pub saved_floating: std::collections::BTreeMap<String, Vec<crate::dock::Floating>>,
-    /// Floating groups shown in their own native window instead of over the dock (Move Panel
-    /// to New Window), so they can be placed on another monitor.
-    #[serde(default)]
-    pub panel_windows: Vec<crate::dock::PanelWindow>,
+    pub saved_workspaces: std::collections::BTreeMap<String, crate::dock::Workspace>,
     /// The panel maximized to fill the dock area (`~`), if any.
     #[serde(default)]
     pub maximized: Option<PanelKind>,
+    /// Floating windows of [`Self::dock`] whose native rect holds the OS window's outer
+    /// position, from a workspace file of an earlier version (see
+    /// `crate::dock_ui::native_outer_to_content`). Workspaces are not saved while any remain.
+    #[serde(skip)]
+    pub native_outer: Vec<u64>,
     /// Locked Composition / Timeline tabs (panel ids): opening another composition does not
     /// bring a locked panel forward (the tab's lock icon, as After Effects' viewer lock).
     #[serde(default)]
@@ -700,11 +732,9 @@ impl Default for UiState {
             script_console: Default::default(),
             slot_tools: Tool::SLOTS.iter().map(|s| s[0]).collect(),
             workspace: "Default".into(),
-            dock: crate::dock::workspace("Default"),
+            dock: crate::dock::Workspace::new(crate::dock::workspace("Default")),
             saved_workspaces: Default::default(),
-            floating: vec![],
-            saved_floating: Default::default(),
-            panel_windows: vec![],
+            native_outer: Vec::new(),
             maximized: None,
             locked_tabs: BTreeSet::new(),
             viewers: Default::default(),
@@ -751,3 +781,48 @@ impl Default for UiState {
         }
     }
 }
+
+/// What a `ui.screenshot` captures.
+///
+/// A panel or element is an identity, not a rectangle: it is resolved again when the capture is
+/// issued, after the settle passes, so a panel that moved or resized while the UI settled is
+/// captured where it is now (never with the rectangle from request admission).
+#[derive(Clone, Debug, PartialEq)]
+pub enum ShotTarget {
+    /// The whole root surface.
+    Window,
+    /// A fixed rectangle in logical points, relative to the root surface's top-left corner.
+    Rect([f32; 4]),
+    /// One dock panel's automation rectangle (`panel.<id>`).
+    Panel(PanelKind),
+    /// One automation element id's rectangle.
+    Id(String),
+}
+
+/// The comp frames a playback pass covers (`first..=last`).
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct FrameWindow {
+    pub(crate) first: i64,
+    pub(crate) last: i64,
+}
+
+/// The inputs of one playback pass: the viewer series it renders, the preview plan and
+/// position, and the frame range and clock settings its steps share. `queued` is a snapshot of
+/// the in-flight render count that each step copies. Built once in `advance_playback`.
+#[derive(Clone, Copy)]
+pub(crate) struct PlaybackPass<'a> {
+    pub(crate) ctx: &'a egui::Context,
+    pub(crate) comp: &'a effectcraft_engine::project::Comp,
+    pub(crate) cid: ItemId,
+    pub(crate) scale: f64,
+    pub(crate) now: f64,
+    pub(crate) frame_rate: effectcraft_engine::time::FrameRate,
+    pub(crate) series: FrameKey,
+    pub(crate) plan: Option<effectcraft_engine::preview::PreviewPlan>,
+    pub(crate) window: FrameWindow,
+    pub(crate) cur: i64,
+    pub(crate) video: bool,
+    pub(crate) looping: bool,
+    pub(crate) ahead: i64,
+    pub(crate) queued: usize,
+}
diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rs
index ebe910b56..aa1b30350 100644
--- a/crates/ui-egui/src/theme.rs
+++ b/crates/ui-egui/src/theme.rs
@@ -6,6 +6,10 @@
 
 use std::sync::Arc;
 
+#[cfg(not(target_arch = "wasm32"))]
+use egui::FontTweak;
+#[cfg(not(target_arch = "wasm32"))]
+use egui::emath::GuiRounding as _;
 use egui::{Color32, FontData, FontDefinitions, FontFamily, FontId, Stroke, TextStyle, Visuals};
 use serde::{Deserialize, Serialize};
 
@@ -125,6 +129,16 @@ impl Tokens {
     pub fn grad_top(&self, c: Color32) -> Color32 {
         if self.gradients { c.lerp_to_gamma(Color32::WHITE, 0.06) } else { c }
     }
+
+    /// The tokens a property's value fields use (#1306): with an expression driving the property
+    /// (`expression`, [`Property::has_expression`]) its values show in the expression colour, red
+    /// as in After Effects, hovered and dragged too; otherwise these tokens. For the values only:
+    /// the name, stopwatch and swatches keep the ordinary tokens.
+    ///
+    /// [`Property::has_expression`]: effectcraft_engine::project::Property::has_expression
+    pub fn for_value(self, expression: bool) -> Tokens {
+        if expression { Tokens { hot_text: self.expr_text, accent_hover: self.expr_text, ..self } } else { self }
+    }
 }
 
 impl Tokens {
@@ -311,6 +325,8 @@ impl Tokens {
     }
 }
 
+/// The default label colours, one RGB colour per [`effectcraft_color::Label`] in
+/// `Label::ALL` order.
 fn default_labels() -> [Color32; 17] {
     effectcraft_color::Label::ALL.map(|l| {
         let [r, g, b] = l.rgb();
@@ -328,7 +344,7 @@ static JETBRAINS_MONO: &[u8] = include_bytes!("../../../assets/fonts/JetBrainsMo
 static NOTO_SYMBOLS2: &[u8] = include_bytes!("../../../assets/fonts/NotoSansSymbols2-Regular.ttf");
 
 /// Install fonts (Inter, Inter Medium/SemiBold, JetBrains Mono) and egui visuals. `language` is the
-/// resolved interface language from [`crate::i18n::language`] (`en`, `ja`, `zh-hans` or `zh-hant`),
+/// resolved interface language from `crate::i18n::language` (`en`, `ja`, `zh-hans` or `zh-hant`),
 /// not the stored `general.language` preference: `system` is already resolved there, so a Chinese
 /// system draws Chinese with the default setting. The CJK fallback that draws the interface's own
 /// script is registered first, so a Chinese interface is drawn by a Chinese face and a Japanese one
@@ -381,6 +397,47 @@ const SCRIPT_PROBES: &[(char, &str)] = &[
     ('ა', "georgian-system"),
 ];
 
+/// The size the fallback baseline correction is derived at. The correction is an em fraction, so the
+/// value holds at every interface size; any size in the interface's range gives the same answer.
+#[cfg(not(target_arch = "wasm32"))]
+const BASELINE_METRICS_PX: f32 = 12.0;
+
+/// A face's ascent and row height at `px`, rounded the way epaint rounds them: ascent, descent and
+/// line gap separately to 1/32, then `ascent + descent + line_gap` (epaint's descent is negative,
+/// this one is positive).
+#[cfg(not(target_arch = "wasm32"))]
+fn ascent_and_height(m: &effectcraft_text::fonts::VMetrics) -> (f32, f32) {
+    let ascent = m.ascent.round_ui();
+    let descent = m.descent.round_ui();
+    let line_gap = m.line_gap.round_ui();
+    (ascent, ascent + descent + line_gap)
+}
+
+/// The `FontTweak` that puts a fallback face's glyphs on the row font's baseline.
+///
+/// epaint draws a glyph at `A_face + 0.5·(H_row − H_face)` (`galley_from_rows` in epaint's
+/// `text_layout.rs`), where `A` and `H` are the ascent and the row height of the face that draws the
+/// glyph and of the row's own font, both from `styled_metrics` in epaint's `font.rs`. Shifting the
+/// face by `(A_row − A_face) − 0.5·(H_row − H_face)` cancels the offset; as an em fraction one
+/// number serves every size, because `FontTweak` applies `size · y_offset_factor`.
+///
+/// The same expression also carries `valign · (max_row_height − line_height)`, which cancels here:
+/// every glyph of a row takes the section font's row height, so it is the same term for the Latin
+/// and the fallback glyph. The remaining `snap_to_pixel` difference is likewise shared and cancels.
+/// (#1309)
+///
+/// The UI families do not share a row font — Proportional uses Inter, Monospace JetBrains Mono —
+/// and their factors differ by 0.0026 em, which is 0.03 px at 12 pt: inside the 1/32 that is already
+/// rounded away above, so one factor per face is enough. The test
+/// `fallback_glyphs_sit_on_the_row_baseline` pins the result.
+#[cfg(not(target_arch = "wasm32"))]
+fn baseline_tweak(row: &effectcraft_text::fonts::Face, face: &effectcraft_text::fonts::Face) -> FontTweak {
+    let px = BASELINE_METRICS_PX;
+    let (a_row, h_row) = ascent_and_height(&row.metrics(px));
+    let (a_face, h_face) = ascent_and_height(&face.metrics(px));
+    FontTweak { y_offset_factor: ((a_row - a_face) - 0.5 * (h_row - h_face)) / px, ..Default::default() }
+}
+
 /// Register the system fallbacks for scripts the bundled fonts lack in every font family, and
 /// return their names in registration order (empty when nothing installed covers a probe, so a
 /// machine without those fonts simply keeps the bundled ones). A face that covers several probes
@@ -413,6 +470,7 @@ fn install_script_fallbacks(family_fonts: &mut FontDefinitions, language: &str)
         // Han text follows the interface language, not the operating system's locale.
         fonts::set_cjk_locale(cjk_locale(language));
         let base = fonts::resolve("Inter", "Regular").face;
+        let base_face = fonts::face(base);
         let han = (han_probe(language), "chinese-system");
         let cjk = if is_chinese(language) { [han, KANA] } else { [KANA, han] };
         let mut names = Vec::new();
@@ -456,6 +514,7 @@ fn install_script_fallbacks(family_fonts: &mut FontDefinitions, language: &str)
             let mut data = FontData::from_owned(font.data().as_bytes().to_vec());
             data.index = face.info.index;
             let name = if name == "catalog-system" { format!("{name}-{:x}", probe as u32) } else { name.to_string() };
+            data.tweak = baseline_tweak(&base_face, &face);
             family_fonts.font_data.insert(name.clone(), Arc::new(data));
             for family in family_fonts.families.values_mut() {
                 family.push(name.to_string());
@@ -737,6 +796,64 @@ mod script_font_tests {
             assert_ne!((meem.uv_rect.min, meem.uv_rect.max), (isolated.min, isolated.max), "the meem takes its initial form");
         });
     }
+
+    /// A fallback face's glyphs sit on the row font's baseline, in every UI family and at every
+    /// interface size. (#1309)
+    ///
+    /// `A` stands in for the row's baseline: epaint exposes none, but a capital without a descender
+    /// has its ink bottom on the baseline, so its ink bottom *is* the row's baseline. A glyph with a
+    /// descender (`g`) or a round one with an overshoot (`O`) would quietly stop holding, so keep `A`
+    /// as the Latin half of this pair.
+    ///
+    /// Both glyphs of `Aあ` end on the baseline, so their ink bottoms agree up to the difference
+    /// between the two outlines themselves - the kana reaches a little below the Latin letter in the
+    /// Japanese faces. Without the correction the kana sits 3 pt high at 12 pt (measured), so the
+    /// tolerance below separates "the correction is applied" from "it is missing"; it is not a claim
+    /// about the outlines. Two pixels per point, because epaint truncates a glyph's box height to
+    /// whole pixels, which would otherwise put up to a point of noise on the measurement.
+    #[test]
+    fn fallback_glyphs_sit_on_the_row_baseline() {
+        if !installed('\u{3042}') {
+            eprintln!("no Japanese system font installed; skipping the baseline check");
+            return;
+        }
+        let ctx = egui::Context::default();
+        ctx.set_pixels_per_point(2.0);
+        super::install(&ctx, &super::Tokens::for_kind(super::ThemeKind::Dark), "ja");
+        let mut out = ctx.run_ui(egui::RawInput::default(), |_| {});
+        out.textures_delta.clear();
+        let bottom = |g: &egui::epaint::text::Glyph| g.pos.y + g.uv_rect.offset.y + g.uv_rect.size.y;
+        ctx.fonts_mut(|fonts| {
+            for family in [
+                egui::FontFamily::Proportional,
+                egui::FontFamily::Monospace,
+                egui::FontFamily::Name("medium".into()),
+                egui::FontFamily::Name("semibold".into()),
+            ] {
+                for size in [12.0_f32, 15.0, 18.0] {
+                    let font = egui::FontId::new(size, family.clone());
+                    let galley = fonts.layout_no_wrap("A\u{3042}".into(), font, egui::Color32::WHITE);
+                    let row = &galley.rows[0].glyphs;
+                    assert_eq!(row.len(), 2, "A\u{3042} should shape to two glyphs");
+                    let (latin, kana) = (bottom(&row[0]), bottom(&row[1]));
+                    let drift = kana - latin;
+                    // Without the correction the kana sits 3-5 pt *above* the Latin ink, so the sign is
+                    // what tells the two apart. With it, the kana reaches a little *below* the Latin
+                    // one, by however far the face's kana overshoot past the baseline - measured at
+                    // 1.94 pt for Noto Sans CJK JP against Yu Gothic's 0.4 - plus up to half a point of
+                    // whole-point rounding in `pos.y` for each glyph.
+                    assert!(
+                        drift > -0.5,
+                        "the kana sits {drift:.2} pt above the Latin baseline at {size} pt in {family:?} (latin {latin}, kana {kana}); the fallback tweak is missing or wrong"
+                    );
+                    assert!(
+                        drift < 2.5,
+                        "the kana sits {drift:.2} pt below the Latin baseline at {size} pt in {family:?} (latin {latin}, kana {kana}); the fallback tweak is too large"
+                    );
+                }
+            }
+        });
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/ui-egui/src/updates_ui.rs b/crates/ui-egui/src/updates_ui.rs
index 0101e16ae..bb8187f56 100644
--- a/crates/ui-egui/src/updates_ui.rs
+++ b/crates/ui-egui/src/updates_ui.rs
@@ -2,6 +2,8 @@
 
 use crate::EffectcraftApp;
 
+#[cfg(not(target_arch = "wasm32"))]
+use craft_update::dialog::{CheckResultDialog, CheckResultResponse};
 #[cfg(not(target_arch = "wasm32"))]
 use craft_update::updater::{Action, Status, Updater};
 
@@ -14,6 +16,7 @@ pub(crate) struct Runtime {
     #[cfg(not(target_arch = "wasm32"))]
     check_requested: bool,
     pub(crate) manual_window_open: bool,
+    #[cfg(target_arch = "wasm32")]
     pub(crate) status_message: Option<String>,
 }
 
@@ -21,12 +24,13 @@ impl Default for Runtime {
     fn default() -> Self {
         Self {
             #[cfg(not(target_arch = "wasm32"))]
-            updater: Updater::new(&craft_update::suite::EFFECTCRAFT, env!("CARGO_PKG_VERSION")),
+            updater: Updater::new(&crate::UPDATE_APP, env!("CARGO_PKG_VERSION")),
             #[cfg(not(target_arch = "wasm32"))]
             startup_check: false,
             #[cfg(not(target_arch = "wasm32"))]
             check_requested: false,
             manual_window_open: false,
+            #[cfg(target_arch = "wasm32")]
             status_message: None,
         }
     }
@@ -44,6 +48,7 @@ pub(crate) fn check(app: &mut EffectcraftApp) {
     #[cfg(not(target_arch = "wasm32"))]
     {
         app.updates_rt.check_requested = true;
+        app.updates_rt.manual_window_open = true;
     }
     #[cfg(target_arch = "wasm32")]
     {
@@ -77,19 +82,24 @@ pub(crate) fn show(app: &mut EffectcraftApp, ctx: &egui::Context) {
             Action::Close => ctx.send_viewport_cmd(egui::ViewportCommand::Close),
             Action::None => {}
         }
-        // The window answers Help ▸ Check for Updates, so it follows the updater's status.
         let rt = &mut app.updates_rt;
-        (rt.manual_window_open, rt.status_message) = match rt.updater.status() {
-            Status::Idle => (false, None),
-            Status::Checking => (true, None),
-            Status::UpToDate => (
-                true,
-                Some(crate::i18n::tr("EffectCraft {version} is currently the newest version available.").replace("{version}", env!("CARGO_PKG_VERSION"))),
-            ),
-            Status::Failed(e) => (true, Some(crate::i18n::tr("Could not check for updates:\n{error}").replace("{error}", e))),
-        };
+        if rt.manual_window_open {
+            match CheckResultDialog::new(&crate::UPDATE_APP, env!("CARGO_PKG_VERSION")).show(ctx, rt.updater.status()) {
+                CheckResultResponse::None => {}
+                CheckResultResponse::Close => {
+                    rt.manual_window_open = false;
+                    rt.updater.dismiss_status();
+                }
+                CheckResultResponse::CheckAgain => rt.updater.check_now(ctx),
+            }
+            // A check that found a release leaves the status idle and the startup prompt takes over.
+            if matches!(rt.updater.status(), Status::Idle) && !rt.check_requested {
+                rt.manual_window_open = false;
+            }
+        }
     }
 
+    #[cfg(target_arch = "wasm32")]
     if app.updates_rt.manual_window_open {
         let mut open = true;
         let mut close = false;
@@ -101,8 +111,6 @@ pub(crate) fn show(app: &mut EffectcraftApp, ctx: &egui::Context) {
             .show(ctx, |ui| {
                 if let Some(msg) = &app.updates_rt.status_message {
                     ui.label(msg);
-                } else {
-                    ui.label(crate::i18n::tr("Checking for updates…"));
                 }
                 ui.add_space(8.0);
                 ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
@@ -116,10 +124,4 @@ pub(crate) fn show(app: &mut EffectcraftApp, ctx: &egui::Context) {
             app.updates_rt.status_message = None;
         }
     }
-
-    // Closing the window dismisses the outcome it showed.
-    #[cfg(not(target_arch = "wasm32"))]
-    if !app.updates_rt.manual_window_open {
-        app.updates_rt.updater.dismiss_status();
-    }
 }
diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rs
index e54fe87c1..344cee0cd 100644
--- a/crates/ui-egui/src/widgets.rs
+++ b/crates/ui-egui/src/widgets.rs
@@ -22,6 +22,8 @@ struct TabOrder {
     pending: Option<(egui::Id, bool, u64)>,
 }
 
+/// The temp-data id of the [`TabOrder`] for the panel containing `ui` (unique per panel scope;
+/// `Id::NULL` outside a tagged panel).
 fn tab_order_id(ui: &Ui) -> egui::Id {
     let panel = ui.stack().iter().find(|s| s.tags().contains(PANEL_TAG)).map_or(egui::Id::NULL, |s| s.scope_id);
     egui::Id::unique(("hot-tab-order", panel))
@@ -49,20 +51,21 @@ fn tab_stop(ui: &Ui, id: egui::Id) -> bool {
     })
 }
 
+/// How a hot-text field scrubs and prints: `speed` value units per pointer pixel, clamped to
+/// `range`, shown with `decimals` places followed by `suffix`.
+#[derive(Clone, Copy)]
+pub struct HotSpec<'a> {
+    pub speed: f64,
+    pub range: (f64, f64),
+    pub decimals: usize,
+    pub suffix: &'a str,
+}
+
 /// "Hot text": a blue number you drag horizontally to scrub, click to type. Tab / Shift+Tab
 /// while typing commits and types in the panel's next / previous one, as in After Effects.
 /// Returns (response, Some(new value) when changed, drag finished).
-pub fn hot_number_at(
-    ui: &mut Ui,
-    rect_min: egui::Pos2,
-    id: egui::Id,
-    value: f64,
-    speed: f64,
-    range: (f64, f64),
-    decimals: usize,
-    suffix: &str,
-    t: &Tokens,
-) -> (Rect, Option<f64>, bool) {
+pub fn hot_number_at(ui: &mut Ui, rect_min: egui::Pos2, id: egui::Id, value: f64, spec: &HotSpec, t: &Tokens) -> (Rect, Option<f64>, bool) {
+    let HotSpec { speed, range, decimals, suffix } = *spec;
     let editing_id = id.with("editing");
     let mut editing: Option<String> = ui.data(|d| d.get_temp(editing_id));
     if tab_stop(ui, id) && editing.is_none() {
@@ -161,7 +164,7 @@ pub fn slider_scrub_speed(ui: &ParamUi) -> f64 {
 /// `1 / speed` pixels however slowly the pointer moves (the fractions add up between frames),
 /// and a typed value is truncated. Returns (rect, Some(new value) when changed, drag finished).
 pub fn hot_int_at(ui: &mut Ui, rect_min: egui::Pos2, id: egui::Id, value: i64, speed: f64, suffix: &str, t: &Tokens) -> (Rect, Option<i64>, bool) {
-    let (rect, nv, done) = hot_number_at(ui, rect_min, id, value as f64, speed, (-1e6, 1e6), 0, suffix, t);
+    let (rect, nv, done) = hot_number_at(ui, rect_min, id, value as f64, &HotSpec { speed, range: (-1e6, 1e6), decimals: 0, suffix }, t);
     let acc_id = id.with("acc");
     let acc = ui.data(|d| d.get_temp::<f64>(acc_id)).unwrap_or(0.0) + nv.map_or(0.0, |n| n - value as f64);
     // (Ten 0.1 steps add up to just under 1.)
@@ -257,6 +260,7 @@ pub fn twirl(ui: &mut Ui, rect: Rect, open: bool, id: egui::Id, t: &Tokens) -> R
         vec![c + vec2(-0.8 * k, -1.6 * k), c + vec2(0.8 * k, 0.0), c + vec2(-0.8 * k, 1.6 * k)]
     };
     ui.painter().add(egui::Shape::line(pts, Stroke::new(1.4, col)));
+    focus_outline(ui, &resp, t);
     resp
 }
 
@@ -270,6 +274,7 @@ pub fn icon_toggle(ui: &mut Ui, rect: Rect, icon: Icon, on: bool, t: &Tokens, id
     if on || resp.hovered() {
         icons::paint(ui.painter(), rect.shrink(rect.width() * 0.18), icon, if on { t.icon } else { t.text_faint });
     }
+    focus_outline(ui, &resp, t);
     resp
 }
 
@@ -294,6 +299,8 @@ pub fn icon_button(ui: &mut Ui, rect: Rect, icon: Icon, active: bool, t: &Tokens
         t.icon
     };
     icons::paint(ui.painter(), rect.shrink(rect.width() * 0.22), icon, col);
+    // An icon has no text: the caller names the button.
+    crate::a11y::role(&resp, egui::accesskit::Role::Button);
     focus_outline(ui, &resp, t);
     resp
 }
@@ -326,6 +333,9 @@ pub fn text_field(ui: &mut Ui, rect: Rect, text: &mut String, hint: &str, t: &To
     field(ui, rect, text, hint, t, false)
 }
 
+/// The shared body of [`text_field`] and [`search_field`]: paints the rounded field (and, for
+/// `search`, a magnifier), places a single-line `TextEdit` on `text` filling the inner rect,
+/// and returns its response.
 fn field(ui: &mut Ui, rect: Rect, text: &mut String, hint: &str, t: &Tokens, search: bool) -> Response {
     let h = rect.height();
     ui.painter().rect_filled(rect, h / 2.0, t.field_bg);
@@ -335,7 +345,7 @@ fn field(ui: &mut Ui, rect: Rect, text: &mut String, hint: &str, t: &Tokens, sea
     }
     let inner = Rect::from_min_max(pos2(rect.min.x + if search { 22.0 } else { 9.0 }, rect.min.y + 1.0), pos2(rect.max.x - 8.0, rect.max.y - 1.0));
     let mut child = ui.new_child(egui::UiBuilder::new().max_rect(inner));
-    child.add(
+    let resp = child.add(
         egui::TextEdit::singleline(text)
             .hint_text(hint)
             .frame(egui::Frame::NONE)
@@ -344,7 +354,10 @@ fn field(ui: &mut Ui, rect: Rect, text: &mut String, hint: &str, t: &Tokens, sea
             .min_size(inner.size())
             .font(Tokens::ui(12.0))
             .align(egui::Align2::LEFT_CENTER),
-    )
+    );
+    // The hint is the field's visible name (the caller can give it a better one).
+    crate::a11y::name(&resp, hint);
+    resp
 }
 
 /// Dropdown-looking control ("Full ▾").
@@ -384,6 +397,10 @@ pub fn dropdown_tip(ui: &mut Ui, rect: Rect, text: &str, tip: Option<&str>, t: &
     };
     ui.painter().text(pos2(rect.min.x + 7.0, rect.center().y), Align2::LEFT_CENTER, shown, Tokens::ui(11.5), t.text);
     icons::paint(ui.painter(), Rect::from_center_size(pos2(rect.max.x - 9.0, rect.center().y), vec2(8.0, 8.0)), Icon::ChevronDown, t.text_dim);
+    // A drop-down showing `text`; the caller names what it sets.
+    crate::a11y::role(&resp, egui::accesskit::Role::ComboBox);
+    crate::a11y::value(&resp, text);
+    focus_outline(ui, &resp, t);
     if let Some(tip) = tip {
         return resp.on_hover_text(tip.to_string());
     }
@@ -406,12 +423,178 @@ pub fn text_button(ui: &mut Ui, rect: Rect, text: &str, primary: bool, t: &Token
     };
     ui.painter().rect_filled(rect, rect.height() / 2.0, bg);
     ui.painter().text(rect.center(), Align2::CENTER_CENTER, text, Tokens::medium(12.0), if primary { Color32::WHITE } else { t.text });
+    crate::a11y::role_name(&resp, egui::accesskit::Role::Button, text);
+    focus_outline(ui, &resp, t);
     resp
 }
 
-/// Checkbox in the AE look (small square).
+/// A primary-button gesture shared by custom and labelled checkboxes in this context.
+#[derive(Clone, Default)]
+struct CheckboxDrag {
+    press_frame: u64,
+    target: Option<bool>,
+    visited: std::collections::HashSet<egui::Id>,
+    /// Checkboxes the pointer crossed in the frame of the press, before the checkbox it pressed on
+    /// had been drawn (so the value to set was not known): they take it in the next frame.
+    pending: std::collections::HashSet<egui::Id>,
+}
+
+/// A primary-button event of the frame, in the order it happened.
+#[derive(Clone, Copy, PartialEq)]
+enum Step {
+    Press,
+    Move,
+    Release,
+}
+
+/// The frame's primary-button events in order, each with its position. egui hit-tests the whole
+/// frame at the last pointer position, so a press followed by a move in one frame would otherwise
+/// be taken for a press where the pointer ended.
+fn pointer_steps(ui: &Ui) -> Vec<(Step, egui::Pos2)> {
+    ui.input(|i| {
+        i.events
+            .iter()
+            .filter_map(|e| match e {
+                egui::Event::PointerMoved(pos) => Some((Step::Move, *pos)),
+                egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, .. } => {
+                    Some((if *pressed { Step::Press } else { Step::Release }, *pos))
+                }
+                _ => None,
+            })
+            .collect()
+    })
+}
+
+/// Returns the requested value. Mixed checkboxes (`None`) and disabled controls are
+/// skipped. Each checkbox is visited once, so crossing it again cannot toggle it back. The
+/// checkbox a press lands on, and the ones the pointer passes over after it, are found from the
+/// frame's ordered pointer events, not from where the pointer ended.
+fn drag_toggle(ui: &Ui, response: &Response, value: Option<bool>) -> Option<bool> {
+    let (pressed, down, released) = ui.input(|i| (i.pointer.primary_pressed(), i.pointer.primary_down(), i.pointer.primary_released()));
+    let frame = ui.ctx().cumulative_frame_nr();
+    // clicked() reads Context input; do not call it while Context data is locked.
+    let clicked = response.clicked();
+    // Whether the pointer at `pos` is over this checkbox itself (not a window above it).
+    let over = |pos: egui::Pos2| response.rect.contains(pos) && ui.clip_rect().contains(pos) && ui.ctx().layer_id_at(pos) == Some(response.layer_id);
+    // Resolved before the data lock below: layer_id_at reads the Context.
+    let steps: Vec<(Step, bool)> = pointer_steps(ui).into_iter().map(|(step, pos)| (step, over(pos))).collect();
+    ui.data_mut(|data| {
+        let drag = data.get_temp_mut_or_default::<CheckboxDrag>(egui::Id::unique("checkbox-drag"));
+        // A release in the press frame leaves crossings pending: keep them for the next frame.
+        let flushing = !drag.pending.is_empty() && drag.target.is_some() && frame <= drag.press_frame.saturating_add(1);
+        if (!down && !released && !flushing) || (pressed && drag.press_frame != frame) {
+            *drag = CheckboxDrag { press_frame: frame, ..Default::default() };
+        }
+        let on = value?;
+        if !response.enabled() {
+            return None;
+        }
+        // Crossed in the frame of the press before the value was known: take it now.
+        if drag.pending.remove(&response.id)
+            && let Some(target) = drag.target
+            && drag.visited.insert(response.id)
+            && on != target
+        {
+            return Some(target);
+        }
+        // Whether the button is held, tracked in event order: a move after a release in the same frame is no drag.
+        // Before the first button event it is held exactly when that event is a release (or, with none, when it is down).
+        let mut held = match steps.iter().find(|(step, _)| *step != Step::Move) {
+            Some((step, _)) => *step == Step::Release,
+            None => down,
+        };
+        let mut press_seen = false;
+        for (step, over) in steps {
+            match step {
+                Step::Press => {
+                    press_seen = true;
+                    held = true;
+                    if drag.target.is_none() && over {
+                        drag.target = Some(!on);
+                        drag.visited.insert(response.id);
+                        return Some(!on);
+                    }
+                }
+                Step::Release => held = false,
+                Step::Move if held => match drag.target {
+                    Some(target) if over => {
+                        if drag.visited.insert(response.id) && on != target {
+                            return Some(target);
+                        }
+                    }
+                    None if press_seen && over => {
+                        drag.pending.insert(response.id);
+                    }
+                    _ => {}
+                },
+                _ => {}
+            }
+        }
+        // The pointer held still over this checkbox in a later frame of the gesture.
+        if down
+            && !pressed
+            && response.contains_pointer()
+            && let Some(target) = drag.target
+        {
+            if drag.visited.insert(response.id) && on != target {
+                return Some(target);
+            }
+            return None;
+        }
+        // The source already changed on press. Suppress its ordinary release click.
+        if released && drag.target.is_some() {
+            return None;
+        }
+        clicked.then_some(!on)
+    })
+}
+
+/// A labelled checkbox with the same drag behavior as the custom panel checkbox.
+/// Use through `ui.add`, `ui.put`, or `ui.add_enabled` like `egui::Checkbox`.
+pub struct DragCheckbox<'a> {
+    value: &'a mut bool,
+    text: egui::WidgetText,
+}
+
+impl<'a> DragCheckbox<'a> {
+    pub fn new(value: &'a mut bool, text: impl Into<egui::WidgetText>) -> Self {
+        Self { value, text: text.into() }
+    }
+}
+
+impl egui::Widget for DragCheckbox<'_> {
+    fn ui(self, ui: &mut Ui) -> Response {
+        let before = *self.value;
+        let mut response = ui.add(egui::Checkbox::new(self.value, self.text));
+        // egui changes on release; our shared gesture changes on press and entry.
+        *self.value = before;
+        response.flags.remove(egui::response::Flags::CHANGED);
+        if response.clicked() {
+            ui.ctx().request_repaint();
+        }
+        if let Some(value) = drag_toggle(ui, &response, Some(before)) {
+            *self.value = value;
+            response.mark_changed();
+            ui.ctx().request_repaint();
+        }
+        response
+    }
+}
+
+/// A labelled checkbox that allocates its own rectangle.
+pub fn labelled_checkbox(ui: &mut Ui, value: &mut bool, text: impl Into<egui::WidgetText>) -> Response {
+    ui.add(DragCheckbox::new(value, text))
+}
+
+/// Checkbox in the AE look (small square). `changed()` requests a toggle, including
+/// keyboard activation and entry during a drag begun on another checkbox.
 pub fn checkbox(ui: &mut Ui, rect: Rect, on: bool, t: &Tokens, id: egui::Id) -> Response {
-    let resp = ui.interact(rect, id, Sense::click());
+    let mut resp = ui.interact(rect, id, Sense::click());
+    let next = drag_toggle(ui, &resp, Some(on));
+    if next.is_some() {
+        resp.mark_changed();
+    }
+    let on = next.unwrap_or(on);
     let b = Rect::from_center_size(rect.center(), vec2(12.0, 12.0));
     ui.painter().rect_filled(b, 2.0, if on { t.accent } else { t.field_bg });
     ui.painter().rect_stroke(b, 2.0, Stroke::new(1.0, if on { t.accent } else { t.field_border }), StrokeKind::Inside);
@@ -419,6 +602,7 @@ pub fn checkbox(ui: &mut Ui, rect: Rect, on: bool, t: &Tokens, id: egui::Id) ->
         let p = |x: f32, y: f32| pos2(b.min.x + x * b.width(), b.min.y + y * b.height());
         ui.painter().line(vec![p(0.2, 0.52), p(0.42, 0.74), p(0.8, 0.28)], Stroke::new(1.6, Color32::WHITE));
     }
+    focus_outline(ui, &resp, t);
     resp
 }
 
@@ -438,7 +622,9 @@ pub fn scroll_bar(ui: &mut Ui, auto: &mut Registry, key: &str, track: Rect, scro
     let thumb_len = (len * len / (len + max.max(0.0)).max(1.0)).max(16.0).min(len).max(0.0);
     let travel = (len - thumb_len).max(1.0);
     let thumb_at = |s: f32| track.min[a] + (len - thumb_len) * if max > 0.0 { (s / max).clamp(0.0, 1.0) } else { 0.0 };
-    let resp = ui.interact(track.expand2(if vertical { vec2(3.0, 0.0) } else { vec2(0.0, 3.0) }), egui::Id::unique(key), Sense::drag());
+    // Dragged with the mouse only: a Tab stop that no key could move would be a trap. The panels
+    // scroll with their own keys (the arrows, Page Up / Page Down) and the wheel.
+    let resp = ui.interact(track.expand2(if vertical { vec2(3.0, 0.0) } else { vec2(0.0, 3.0) }), egui::Id::unique(key), Sense::DRAG);
     let pressed = resp.is_pointer_button_down_on() && ui.input(|i| i.pointer.any_pressed());
     let mut s = scroll;
     if let Some(p) = resp.interact_pointer_pos().filter(|p| pressed && !(thumb_at(scroll)..=thumb_at(scroll) + thumb_len).contains(&p[a])) {
@@ -482,6 +668,22 @@ impl PanelScroll {
         Self { id, area, offset: offset.clamp(0.0, max.max(0.0)) }
     }
 
+    /// Scroll the panel `id` (a [`PanelScroll`] kept under that id) so the content from `top` to
+    /// `bottom` is in view of a `view` tall list, from the next pass.
+    pub fn reveal(ctx: &egui::Context, id: egui::Id, top: f32, bottom: f32, view: f32) {
+        let (offset, max): (f32, f32) = ctx.data(|d| d.get_temp(id)).unwrap_or_default();
+        let wanted = if top < offset {
+            top
+        } else if bottom > offset + view {
+            bottom - view
+        } else {
+            offset
+        }
+        .max(0.0);
+        // (`max` is last frame's overflow; the next `end` measures it again.)
+        ctx.data_mut(|d| d.insert_temp(id, (wanted, max.max(wanted))));
+    }
+
     /// The rows were `content` points tall: keep the offset, with the scroll bar registered for
     /// automation as `key`.
     pub fn end(self, ui: &mut Ui, auto: &mut Registry, key: &str, content: f32, t: &Tokens) {
@@ -509,6 +711,8 @@ pub fn check_label(on: bool, label: &str) -> String {
     if on { format!("✓ {label}") } else { format!("   {label}") }
 }
 
+/// The atom id of [`label_swatch`]'s slot inside a button, which [`paint_label_swatch`] looks
+/// up on the laid-out button.
 fn label_swatch_id() -> egui::IdSalt {
     egui::IdSalt::new("label-swatch")
 }
@@ -564,6 +768,30 @@ pub fn label_popup(
     })
 }
 
+/// This pass's input has no mouse press or release: whatever just happened (a control activated,
+/// a list opened, an entry chosen) came from the keyboard or an assistive technology.
+pub fn by_keyboard(ui: &Ui) -> bool {
+    !ui.input(|i| i.pointer.any_pressed() || i.pointer.any_released())
+}
+
+/// Put the keyboard on `entry` of the popup list `id` the pass the list opens, so Up / Down and
+/// Enter work it and Escape closes it. (The pass count tells a fresh opening from a list that has
+/// been open for some passes.)
+pub fn focus_when_opened(ui: &Ui, id: egui::Id, entry: &Response) {
+    let key = id.with("focus-pass");
+    let pass = ui.ctx().cumulative_pass_nr();
+    let previous = ui.data_mut(|d| {
+        let previous = d.get_temp::<u64>(key);
+        d.insert_temp(key, pass);
+        previous
+    });
+    // A list opened with the mouse keeps the keyboard where it was: a widget with the focus
+    // pauses the application's shortcuts (Space, Ctrl+Z) until the focus is lost.
+    if previous.is_none_or(|p| p.saturating_add(1) < pass) && by_keyboard(ui) {
+        entry.request_focus();
+    }
+}
+
 /// Show a popup menu anchored at `pos` with string options; returns the chosen index.
 pub fn popup_menu(ui: &mut Ui, id: egui::Id, pos: egui::Pos2, options: &[String], current: Option<usize>) -> Option<usize> {
     if !popup_is_open(ui, id) {
@@ -573,11 +801,20 @@ pub fn popup_menu(ui: &mut Ui, id: egui::Id, pos: egui::Pos2, options: &[String]
     popup_list(ui, id, pos, Rect::NOTHING, options.len().saturating_sub(seps), seps, |ui| {
         ui.set_min_width(160.0);
         let mut chosen = None;
+        let mut first = true;
         for (i, o) in options.iter().enumerate() {
             if o == "-" {
                 ui.separator();
-            } else if ui.selectable_label(current == Some(i), o).clicked() {
-                chosen = Some(i);
+            } else {
+                let r = ui.selectable_label(current == Some(i), o);
+                // The keyboard starts on the current entry (the first one, with none current).
+                if current == Some(i) || (current.is_none() && first) {
+                    focus_when_opened(ui, id, &r);
+                }
+                first = false;
+                if r.clicked() {
+                    chosen = Some(i);
+                }
             }
         }
         chosen
@@ -594,7 +831,7 @@ pub fn popup_menu(ui: &mut Ui, id: egui::Id, pos: egui::Pos2, options: &[String]
 pub fn layer_picker(
     ui: &mut Ui,
     rect: Rect,
-    layers: &[effectcraft_engine::project::Layer],
+    layers: &effectcraft_engine::project::Layers,
     current: Option<u64>,
     t: &Tokens,
     id: egui::Id,
@@ -812,10 +1049,208 @@ pub(crate) fn constrained(c: &[f64], d: usize, v: f64) -> Vec<f64> {
         .collect()
 }
 
+/// Linked values after component `d` of `c` became `v`: the others move by the same amount, so
+/// linked Audio Levels keep their stereo balance in dB (#2485).
+pub(crate) fn shifted(c: &[f64], d: usize, v: f64) -> Vec<f64> {
+    let Some(&old) = c.get(d) else { return c.to_vec() };
+    c.iter().enumerate().map(|(e, &x)| if e == d { v } else { x + (v - old) }).collect()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    fn checkbox_frame(ctx: &egui::Context, values: &mut [Option<bool>; 5], events: Vec<egui::Event>) {
+        let t = Tokens::for_kind(Default::default());
+        let input = egui::RawInput { events, ..Default::default() };
+        let mut output = ctx.run_ui(input, |ui| {
+            for (index, value) in values.iter_mut().enumerate() {
+                let rect = Rect::from_min_size(pos2(20.0, 20.0 + index as f32 * 30.0), vec2(120.0, 20.0));
+                ui.add_enabled_ui(index != 3, |ui| {
+                    if index == 4 {
+                        if let Some(on) = value {
+                            ui.put(rect, DragCheckbox::new(on, crate::i18n::tr("Grid")));
+                        }
+                    } else if let Some(on) = value {
+                        if checkbox(ui, rect, *on, &t, egui::Id::unique(index)).changed() {
+                            *on = !*on;
+                        }
+                    } else {
+                        let response = ui.interact(rect, egui::Id::unique(index), Sense::click());
+                        assert_eq!(drag_toggle(ui, &response, None), None);
+                    }
+                });
+            }
+        });
+        output.textures_delta.clear();
+    }
+
+    fn checkbox_pointer(y: f32, pressed: Option<bool>) -> Vec<egui::Event> {
+        let pos = pos2(28.0, y);
+        let mut events = vec![egui::Event::PointerMoved(pos)];
+        if let Some(pressed) = pressed {
+            events.push(egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() });
+        }
+        events
+    }
+
+    #[test]
+    fn checkbox_drag_sets_one_state_skips_mixed_and_disabled_and_ends_on_release() {
+        let ctx = egui::Context::default();
+        let mut values = [Some(false), Some(true), None, Some(false), Some(false)];
+        checkbox_frame(&ctx, &mut values, vec![]);
+        checkbox_frame(&ctx, &mut values, checkbox_pointer(28.0, Some(true)));
+        assert_eq!(values[0], Some(true));
+        // An already-matching neighbour must not invert, even after revisiting.
+        for y in [58.0, 88.0, 118.0, 148.0, 58.0, 28.0] {
+            checkbox_frame(&ctx, &mut values, checkbox_pointer(y, None));
+        }
+        assert_eq!(values, [Some(true), Some(true), None, Some(false), Some(true)]);
+        checkbox_frame(&ctx, &mut values, checkbox_pointer(28.0, Some(false)));
+        assert_eq!(values[0], Some(true), "release must not toggle the source again");
+        // Begin on the labelled wrapper and drag back into custom checkboxes.
+        checkbox_frame(&ctx, &mut values, checkbox_pointer(148.0, Some(true)));
+        assert_eq!(values[4], Some(false));
+        for y in [58.0, 28.0] {
+            checkbox_frame(&ctx, &mut values, checkbox_pointer(y, None));
+        }
+        checkbox_frame(&ctx, &mut values, checkbox_pointer(28.0, Some(false)));
+        assert_eq!(values, [Some(false), Some(false), None, Some(false), Some(false)]);
+        checkbox_frame(&ctx, &mut values, checkbox_pointer(58.0, None));
+        assert_eq!(values[1], Some(false), "hover after release must not paint");
+    }
+
+    fn button(y: f32, pressed: bool) -> Vec<egui::Event> {
+        let pos = pos2(28.0, y);
+        vec![egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }]
+    }
+
+    fn moved(y: f32) -> egui::Event {
+        egui::Event::PointerMoved(pos2(28.0, y))
+    }
+
+    /// A press and the moves after it can arrive in one frame (a quick flick): the press belongs to
+    /// the checkbox it landed on, not to the one the pointer ended over, and the ones passed over
+    /// follow the pressed one's new state, whether they are drawn before it or after it.
+    #[test]
+    fn a_press_and_a_move_in_one_frame_start_on_the_checkbox_pressed() {
+        // Rows are 30 apart, from y = 28; index 3 is disabled.
+        let (a, b) = (28.0, 58.0);
+        // Pressed on the first, moved to the second (drawn after it).
+        let ctx = egui::Context::default();
+        let mut values = [Some(false); 5];
+        values[2] = None;
+        checkbox_frame(&ctx, &mut values, vec![]);
+        let mut events = vec![moved(a)];
+        events.extend(button(a, true));
+        events.push(moved(b));
+        checkbox_frame(&ctx, &mut values, events);
+        assert_eq!((values[0], values[1]), (Some(true), Some(true)), "the pressed one is the source, the one passed over follows");
+        let mut events = vec![moved(b)];
+        events.extend(button(b, false));
+        checkbox_frame(&ctx, &mut values, events);
+        assert_eq!((values[0], values[1]), (Some(true), Some(true)), "release changes nothing");
+        // Pressed on the second, moved to the first (drawn before it): the first takes the state in
+        // the next frame, while the button is still down.
+        let ctx = egui::Context::default();
+        let mut values = [Some(false); 5];
+        values[2] = None;
+        checkbox_frame(&ctx, &mut values, vec![]);
+        let mut events = vec![moved(b)];
+        events.extend(button(b, true));
+        events.push(moved(a));
+        checkbox_frame(&ctx, &mut values, events);
+        assert_eq!(values[1], Some(true), "the pressed one is the source");
+        checkbox_frame(&ctx, &mut values, vec![]);
+        assert_eq!(values[0], Some(true), "the one passed over takes the state");
+        let mut events = vec![moved(a)];
+        events.extend(button(a, false));
+        checkbox_frame(&ctx, &mut values, events);
+        assert_eq!((values[0], values[1]), (Some(true), Some(true)));
+        // Pressed outside every checkbox, then moved onto one in the same frame: nothing starts.
+        let ctx = egui::Context::default();
+        let mut values = [Some(false); 5];
+        values[2] = None;
+        checkbox_frame(&ctx, &mut values, vec![]);
+        let mut events = vec![moved(200.0)];
+        events.extend(button(200.0, true));
+        events.push(moved(a));
+        checkbox_frame(&ctx, &mut values, events);
+        checkbox_frame(&ctx, &mut values, vec![]);
+        assert_eq!(values, [Some(false), Some(false), None, Some(false), Some(false)], "a press outside starts no gesture");
+        // Pressed on the second, moved to the first (drawn before it) and released, all in one
+        // frame: the first still takes the state in the next frame.
+        let ctx = egui::Context::default();
+        let mut values = [Some(false); 5];
+        values[2] = None;
+        checkbox_frame(&ctx, &mut values, vec![]);
+        let mut events = vec![moved(b)];
+        events.extend(button(b, true));
+        events.push(moved(a));
+        events.extend(button(a, false));
+        checkbox_frame(&ctx, &mut values, events);
+        checkbox_frame(&ctx, &mut values, vec![]);
+        assert_eq!((values[0], values[1]), (Some(true), Some(true)), "a crossing before the release still takes the state");
+    }
+
+    /// A move that arrives after the release, in the frame of the click, is the pointer travelling without the button:
+    /// it must not carry the gesture onto the checkbox it ends over.
+    #[test]
+    fn a_move_after_the_release_in_the_same_frame_paints_nothing() {
+        let (a, b) = (28.0, 58.0);
+        let ctx = egui::Context::default();
+        let mut values = [Some(false); 5];
+        values[2] = None;
+        checkbox_frame(&ctx, &mut values, vec![]);
+        let mut events = vec![moved(a)];
+        events.extend(button(a, true));
+        events.extend(button(a, false));
+        events.push(moved(b));
+        checkbox_frame(&ctx, &mut values, events);
+        checkbox_frame(&ctx, &mut values, vec![]);
+        assert_eq!((values[0], values[1]), (Some(true), Some(false)), "the clicked one changes, the one moved onto afterwards does not");
+    }
+
+    #[test]
+    fn checkbox_click_and_keyboard_toggle_once_and_drag_must_start_on_a_checkbox() {
+        let ctx = egui::Context::default();
+        let mut values = [Some(false), Some(false), None, Some(false), Some(false)];
+        checkbox_frame(&ctx, &mut values, vec![]);
+        // Pressing outside the checkboxes must not start a gesture on entry.
+        checkbox_frame(&ctx, &mut values, checkbox_pointer(200.0, Some(true)));
+        checkbox_frame(&ctx, &mut values, checkbox_pointer(28.0, None));
+        checkbox_frame(&ctx, &mut values, checkbox_pointer(28.0, Some(false)));
+        assert_eq!(values[0], Some(false));
+        for source_y in [88.0, 118.0] {
+            checkbox_frame(&ctx, &mut values, checkbox_pointer(source_y, Some(true)));
+            checkbox_frame(&ctx, &mut values, checkbox_pointer(28.0, None));
+            checkbox_frame(&ctx, &mut values, checkbox_pointer(28.0, Some(false)));
+            assert_eq!(values[0], Some(false), "mixed and disabled sources cannot begin a drag");
+        }
+        for y in [28.0, 148.0] {
+            checkbox_frame(&ctx, &mut values, checkbox_pointer(y, Some(true)));
+            checkbox_frame(&ctx, &mut values, checkbox_pointer(y, Some(false)));
+        }
+        assert_eq!(values[0], Some(true));
+        assert_eq!(values[4], Some(true));
+        ctx.memory_mut(|m| m.request_focus(egui::Id::unique(0usize)));
+        checkbox_frame(
+            &ctx,
+            &mut values,
+            vec![egui::Event::Key { key: egui::Key::Space, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }],
+        );
+        assert_eq!(values[0], Some(false), "keyboard activation still works");
+        // Fast clicks may deliver press and release together in one input frame.
+        // This also exercises clicked() without an active drag (outside the data lock).
+        for (index, y) in [(0, 28.0), (4, 148.0)] {
+            let before = values[index];
+            let mut events = checkbox_pointer(y, Some(true));
+            events.extend(checkbox_pointer(y, Some(false)));
+            checkbox_frame(&ctx, &mut values, events);
+            assert_eq!(values[index], before.map(|on| !on));
+        }
+    }
+
     /// #2097: the drag speed comes from the slider range, not a much wider hard range.
     #[test]
     fn slider_scrub_speed_uses_the_slider_range() {
diff --git a/crates/ui-egui/src/workspace_state.rs b/crates/ui-egui/src/workspace_state.rs
index c2ac9e373..de2e99ce7 100644
--- a/crates/ui-egui/src/workspace_state.rs
+++ b/crates/ui-egui/src/workspace_state.rs
@@ -5,93 +5,72 @@ use std::collections::BTreeMap;
 use effectcraft_engine::config::ConfigStore;
 use serde::{Deserialize, Serialize};
 
-use crate::dock::{DockNode, Floating, PanelKind, PanelWindow, SplitSize};
+use crate::dock::{PanelKind, Workspace};
 use crate::state::UiState;
 
+mod legacy;
+
 const FILE: &str = "workspaces.json";
+/// An earlier version's file, kept when it is first rewritten in the current format.
+const BACKUP: &str = "workspaces.old.json";
 const MAX_BYTES: usize = 1024 * 1024;
 const MAX_WORKSPACES: usize = 64;
-const MAX_NODES: usize = 4096;
-const MAX_DEPTH: usize = 32;
-const MAX_PANELS: usize = 128;
 /// Leave room for new viewers without approaching the u32 allocator limit.
 const MAX_VIEWER_ID: u32 = 65_535;
-const MAX_COORD: f32 = 1_000_000.0;
+/// The snapshot version: 2 holds craft-ui docking workspaces.
+const VERSION: u32 = 2;
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 struct Snapshot {
     version: u32,
     workspace: String,
-    dock: DockNode,
-    floating: Vec<Floating>,
+    dock: Workspace,
     focused: PanelKind,
     maximized: Option<PanelKind>,
-    saved_workspaces: BTreeMap<String, DockNode>,
-    saved_floating: BTreeMap<String, Vec<Floating>>,
-    /// Floating groups in their own native window (absent from files of earlier versions).
-    #[serde(default)]
-    panel_windows: Vec<PanelWindow>,
+    saved_workspaces: BTreeMap<String, Workspace>,
 }
 
 impl Snapshot {
     fn capture(ui: &UiState) -> Self {
         Self {
-            version: 1,
+            version: VERSION,
             workspace: ui.workspace.clone(),
             dock: ui.dock.clone(),
-            floating: ui.floating.clone(),
             focused: ui.focused,
             maximized: ui.maximized,
             saved_workspaces: ui.saved_workspaces.clone(),
-            saved_floating: ui.saved_floating.clone(),
-            panel_windows: ui.panel_windows.clone(),
         }
     }
 
     fn apply(self, ui: &mut UiState) {
         ui.workspace = self.workspace;
         ui.dock = self.dock;
-        ui.floating = self.floating;
         ui.focused = self.focused;
         ui.maximized = self.maximized;
         ui.saved_workspaces = self.saved_workspaces;
-        ui.saved_floating = self.saved_floating;
-        // A window is only kept for a panel that still floats, and only where a window can be.
-        let floating = |panel: PanelKind| ui.floating.iter().any(|group| group.panels.contains(&panel));
-        ui.panel_windows = self
-            .panel_windows
-            .into_iter()
-            .filter(|window| floating(window.panel))
-            .map(|window| PanelWindow { panel: window.panel, rect: PanelWindow::sanitized(window.rect) })
-            .collect();
-        // Reserve restored viewer slots without restoring any project-specific composition
-        // links. New Viewer allocates from this map, including after switching named layouts.
-        let mut panels = Vec::new();
-        for root in std::iter::once(&ui.dock).chain(ui.saved_workspaces.values()) {
-            root.panels(&mut panels);
-        }
-        for groups in std::iter::once(&ui.floating).chain(ui.saved_floating.values()) {
-            for group in groups {
-                panels.extend(group.panels.iter().copied());
+        // A native window's place is made safe to hand to the windowing system.
+        for workspace in std::iter::once(&mut ui.dock).chain(ui.saved_workspaces.values_mut()) {
+            for window in &mut workspace.layout.floating {
+                window.native = window.native.map(crate::dock_ui::sanitized_window_rect);
             }
         }
-        for panel in panels {
-            if let PanelKind::Viewer(id) = panel {
-                ui.viewers.entry(id).or_insert(None);
+        // Reserve restored viewer slots without restoring any project-specific composition
+        // links. New Viewer allocates from this map, including after switching named layouts.
+        for workspace in std::iter::once(&ui.dock).chain(ui.saved_workspaces.values()) {
+            for panel in crate::dock::referenced_panels(workspace) {
+                if let PanelKind::Viewer(id) = panel {
+                    ui.viewers.entry(id).or_insert(None);
+                }
             }
         }
     }
 
     fn validate(&self) -> Result<(), String> {
-        if self.version != 1 {
+        if self.version != VERSION {
             return Err(format!("unsupported workspace version {}", self.version));
         }
         let name_ok = |name: &str| !name.trim().is_empty() && name.len() <= 256;
-        if !name_ok(&self.workspace)
-            || self.saved_workspaces.len() > MAX_WORKSPACES
-            || self.saved_floating.len() > MAX_WORKSPACES
-            || self.saved_workspaces.keys().chain(self.saved_floating.keys()).any(|name| !name_ok(name))
-        {
+        if !name_ok(&self.workspace) || self.saved_workspaces.len() > MAX_WORKSPACES || self.saved_workspaces.keys().any(|name| !name_ok(name)) {
             return Err("workspace names or count exceed supported limits".into());
         }
         if !crate::dock::WORKSPACES.contains(&self.workspace.as_str()) && !self.saved_workspaces.contains_key(&self.workspace) {
@@ -101,79 +80,16 @@ impl Snapshot {
             PanelKind::Viewer(id) => (1..=MAX_VIEWER_ID).contains(&id),
             _ => true,
         };
-        if !panel_ok(self.focused) || self.maximized.is_some_and(|panel| !panel_ok(panel)) || self.panel_windows.iter().any(|w| !panel_ok(w.panel)) {
+        if !panel_ok(self.focused) || self.maximized.is_some_and(|panel| !panel_ok(panel)) {
             return Err("workspace viewer ID is outside the supported range 1–65535".into());
         }
-        let mut nodes = 0usize;
-        for root in std::iter::once(&self.dock).chain(self.saved_workspaces.values()) {
-            let mut pending = vec![(root, 0usize)];
-            while let Some((node, depth)) = pending.pop() {
-                nodes = nodes.saturating_add(1);
-                if depth > MAX_DEPTH || nodes > MAX_NODES {
-                    return Err("workspace dock tree exceeds supported limits".into());
-                }
-                match node {
-                    DockNode::Split { size, a, b, .. } => {
-                        let valid = match *size {
-                            SplitSize::Ratio(v) => v.is_finite() && (0.0..=1.0).contains(&v),
-                            SplitSize::FixedA(v) | SplitSize::FixedB(v) => v.is_finite() && (0.0..=MAX_COORD).contains(&v),
-                        };
-                        if !valid {
-                            return Err("invalid workspace split size".into());
-                        }
-                        pending.push((a, depth.saturating_add(1)));
-                        pending.push((b, depth.saturating_add(1)));
-                    }
-                    DockNode::Tabs { panels, active } => {
-                        // Closing the last docked panel leaves an empty group with active=0.
-                        if panels.len() > MAX_PANELS || *active >= panels.len().max(1) || panels.iter().any(|panel| !panel_ok(*panel)) {
-                            return Err("invalid workspace tab group".into());
-                        }
-                    }
-                    DockNode::Stack { entries } => {
-                        if entries.len() > MAX_PANELS
-                            || entries.iter().any(|e| {
-                                e.panels.is_empty()
-                                    || e.panels.len() > MAX_PANELS
-                                    || e.active >= e.panels.len()
-                                    || e.panels.iter().any(|p| !panel_ok(*p))
-                                    || e.height.is_some_and(|v| !v.is_finite() || !(0.0..=MAX_COORD).contains(&v))
-                            })
-                        {
-                            return Err("invalid workspace panel stack".into());
-                        }
-                    }
-                }
+        for workspace in std::iter::once(&self.dock).chain(self.saved_workspaces.values()) {
+            // craft-ui checks the trees, selections, sizes, rects and limits.
+            workspace.validate().map_err(|error| error.to_string())?;
+            if crate::dock::referenced_panels(workspace).into_iter().any(|panel| !panel_ok(panel)) {
+                return Err("workspace viewer ID is outside the supported range 1–65535".into());
             }
         }
-        if self.panel_windows.len() > MAX_PANELS || self.panel_windows.iter().any(|w| !w.rect.iter().all(|v| v.is_finite())) {
-            return Err("invalid workspace panel windows".into());
-        }
-        for groups in std::iter::once(&self.floating).chain(self.saved_floating.values()) {
-            if groups.len() > MAX_PANELS {
-                return Err("too many floating workspace groups".into());
-            }
-            for group in groups {
-                let [x, y, width, height] = group.rect;
-                if group.panels.is_empty()
-                    || group.panels.len() > MAX_PANELS
-                    || group.panels.iter().any(|panel| !panel_ok(*panel))
-                    || group.active >= group.panels.len()
-                    || !group.rect.iter().all(|v| v.is_finite())
-                    || x.abs() > MAX_COORD
-                    || y.abs() > MAX_COORD
-                    || !(1.0..=MAX_COORD).contains(&width)
-                    || !(1.0..=MAX_COORD).contains(&height)
-                {
-                    return Err("invalid floating workspace group".into());
-                }
-            }
-        }
-        crate::dock_shared::encode(&self.dock, &self.floating)?.validate().map_err(|error| error.to_string())?;
-        for (name, root) in &self.saved_workspaces {
-            let floating = self.saved_floating.get(name).map(Vec::as_slice).unwrap_or(&[]);
-            crate::dock_shared::encode(root, floating)?.validate().map_err(|error| error.to_string())?;
-        }
         Ok(())
     }
 }
@@ -182,24 +98,26 @@ pub(crate) struct WorkspaceStore {
     saved: Snapshot,
     last_attempt: f64,
     writable: bool,
+    /// The text of an earlier version's file that loaded: the first save copies it to
+    /// [`BACKUP`] and writes the file in the current format.
+    migrated_from: Option<String>,
     pub(crate) error: Option<String>,
 }
 
 impl WorkspaceStore {
     pub(crate) fn load(config: Option<&dyn ConfigStore>, ui: &mut UiState) -> Self {
+        let mut original = None;
+        let mut outer = Vec::new();
         let loaded = config.map_or(Ok(None), |c| c.read_bounded(FILE, MAX_BYTES)).map_err(|e| e.to_string()).and_then(|text| {
             text.map(|text| {
                 let value: serde_json::Value = serde_json::from_str(&text).map_err(|e| e.to_string())?;
-                // Only an explicitly legacy-shaped record can migrate. A versioned future
-                // snapshot must never deserialize as an empty defaulted legacy record.
-                let snapshot = if value.get("version").is_none()
-                    && value.as_object().is_some_and(|fields| fields.contains_key("workspaces") || fields.contains_key("floating"))
-                {
-                    let legacy: crate::SavedWorkspaces = serde_json::from_value(value).map_err(|e| e.to_string())?;
-                    let mut snapshot = Snapshot::capture(ui);
-                    snapshot.saved_workspaces = legacy.workspaces;
-                    snapshot.saved_floating = legacy.floating;
+                let snapshot = if legacy::is_legacy(&value) {
+                    let (snapshot, windows) = legacy::migrate(value, ui)?;
+                    original = Some(text);
+                    outer = windows;
                     snapshot
+                } else if value.get("version").is_none() {
+                    return Err("not a workspace file".to_string());
                 } else {
                     serde_json::from_value::<Snapshot>(value).map_err(|e| e.to_string())?
                 };
@@ -211,6 +129,7 @@ impl WorkspaceStore {
         let error = match loaded {
             Ok(Some(snapshot)) => {
                 snapshot.apply(ui);
+                ui.native_outer = outer;
                 None
             }
             Ok(None) => None,
@@ -219,10 +138,11 @@ impl WorkspaceStore {
         if let Some(error) = &error {
             log::warn!("{error}");
             ui.status = error.clone();
+            original = None;
         }
         // An unreadable or newer file is never replaced by this session, even after a later
         // layout edit. Ordinary failed writes remain dirty and retryable.
-        Self { saved: Snapshot::capture(ui), last_attempt: f64::NEG_INFINITY, writable: error.is_none(), error }
+        Self { saved: Snapshot::capture(ui), last_attempt: f64::NEG_INFINITY, writable: error.is_none(), migrated_from: original, error }
     }
 
     pub(crate) fn due(&mut self, now: f64) -> bool {
@@ -237,19 +157,18 @@ impl WorkspaceStore {
         if !self.writable {
             return false;
         }
-        self.saved.workspace != ui.workspace
+        self.migrated_from.is_some()
+            || self.saved.workspace != ui.workspace
             || self.saved.dock != ui.dock
-            || self.saved.floating != ui.floating
             || self.saved.focused != ui.focused
             || self.saved.maximized != ui.maximized
             || self.saved.saved_workspaces != ui.saved_workspaces
-            || self.saved.saved_floating != ui.saved_floating
-            || self.saved.panel_windows != ui.panel_windows
     }
 
     pub(crate) fn save(&mut self, config: Option<&dyn ConfigStore>, ui: &UiState) -> Result<bool, String> {
         let Some(config) = config else { return Ok(false) };
-        if !self.has_changes(ui) {
+        // A window still at its outer position would be saved as if that were its content's.
+        if !self.has_changes(ui) || !ui.native_outer.is_empty() {
             return Ok(false);
         }
         let snapshot = Snapshot::capture(ui);
@@ -258,7 +177,11 @@ impl WorkspaceStore {
         if text.len() > MAX_BYTES {
             return Err("workspace file exceeds 1 MiB".into());
         }
+        if let Some(original) = &self.migrated_from {
+            config.write(BACKUP, original).map_err(|e| format!("keep the earlier workspace file: {e}"))?;
+        }
         config.write(FILE, &text).map_err(|e| format!("save workspaces: {e}"))?;
+        self.migrated_from = None;
         self.saved = snapshot;
         self.error = None;
         Ok(true)
@@ -274,187 +197,20 @@ impl WorkspaceStore {
             let path = config.dir().map_or_else(|| FILE.to_string(), |dir| dir.join(FILE).display().to_string());
             return Err(format!("{path} couldn't be loaded at startup, so it is left untouched; fix or move it and restart"));
         }
+        ensure_positions_ready(ui)?;
         self.save(Some(config), ui).map(|_| ())
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use effectcraft_engine::config::MemoryConfig;
-
-    #[test]
-    fn corrupt_or_future_workspace_keeps_defaults_and_original_file() {
-        let valid = Snapshot::capture(&UiState::default());
-        for text in ["{".into(), serde_json::to_string(&Snapshot { version: 2, ..valid }).unwrap(), " ".repeat(MAX_BYTES + 1)] {
-            let config = MemoryConfig::default();
-            config.write(FILE, &text).unwrap();
-            let mut ui = UiState::default();
-            let mut store = WorkspaceStore::load(Some(&config), &mut ui);
-            assert!(store.error.is_some());
-            assert_eq!(ui.workspace, "Default");
-            ui.focused = PanelKind::Project;
-            ui.dock = crate::dock::workspace("Minimal");
-            assert!(!store.save(Some(&config), &ui).unwrap());
-            assert!(store.save_now(Some(&config), &ui).unwrap_err().contains("couldn't be loaded"));
-            assert_eq!(config.read(FILE).as_deref(), Some(text.as_str()));
-        }
-    }
-
-    #[test]
-    fn explicit_save_without_a_settings_folder_is_an_error() {
-        let mut ui = UiState::default();
-        let mut store = WorkspaceStore::load(None, &mut ui);
-        ui.focused = PanelKind::Project;
-        assert!(!store.save(None, &ui).unwrap());
-        assert!(store.save_now(None, &ui).is_err());
-    }
-
-    #[test]
-    fn explicit_save_with_nothing_new_succeeds() {
-        let config = MemoryConfig::default();
-        let mut ui = UiState::default();
-        let mut store = WorkspaceStore::load(Some(&config), &mut ui);
-        ui.focused = PanelKind::Project;
-        store.save_now(Some(&config), &ui).unwrap();
-        store.save_now(Some(&config), &ui).unwrap();
-        assert!(config.read(FILE).is_some());
-    }
-
-    #[test]
-    fn invalid_tabs_split_and_deep_tree_are_rejected() {
-        let mut snapshot = Snapshot::capture(&UiState::default());
-        snapshot.dock = DockNode::Tabs { panels: vec![], active: usize::MAX };
-        assert!(snapshot.validate().is_err());
-        snapshot.dock = DockNode::Split {
-            vertical: false,
-            size: SplitSize::FixedA(f32::NAN),
-            a: Box::new(crate::dock::workspace("Minimal")),
-            b: Box::new(crate::dock::workspace("Minimal")),
-        };
-        assert!(snapshot.validate().is_err());
-        snapshot.dock = crate::dock::workspace("Minimal");
-        for _ in 0..=MAX_DEPTH {
-            snapshot.dock = DockNode::Split {
-                vertical: false,
-                size: SplitSize::Ratio(0.5),
-                a: Box::new(snapshot.dock),
-                b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project], active: 0 }),
-            };
-        }
-        assert!(snapshot.validate().is_err());
-    }
-
-    #[test]
-    fn closing_all_docked_panels_remains_a_persistable_layout() {
-        let config = MemoryConfig::default();
-        let mut ui = UiState::default();
-        let mut store = WorkspaceStore::load(Some(&config), &mut ui);
-        let mut panels = Vec::new();
-        ui.dock.panels(&mut panels);
-        for panel in panels {
-            ui.dock.close(panel);
-        }
-        assert!(store.save(Some(&config), &ui).unwrap());
-        let mut restored = UiState::default();
-        let loaded = WorkspaceStore::load(Some(&config), &mut restored);
-        assert!(loaded.error.is_none());
-        assert_eq!(restored.dock, ui.dock);
-    }
-
-    #[test]
-    fn floating_groups_and_named_snapshots_roundtrip_without_document_state() {
-        let config = MemoryConfig::default();
-        let mut ui = UiState::default();
-        let mut store = WorkspaceStore::load(Some(&config), &mut ui);
-        ui.workspace = "Floating".into();
-        ui.dock.close(PanelKind::Preview);
-        ui.floating = vec![Floating { panels: vec![PanelKind::Preview], active: 0, rect: [50.0, 80.0, 200.0, 160.0] }];
-        ui.saved_workspaces.insert(ui.workspace.clone(), ui.dock.clone());
-        ui.saved_floating.insert(ui.workspace.clone(), ui.floating.clone());
-        ui.maximized = Some(PanelKind::Composition);
-        ui.project_search = "do not persist".into();
-        assert!(store.save(Some(&config), &ui).unwrap());
-        let mut restored = UiState::default();
-        WorkspaceStore::load(Some(&config), &mut restored);
-        assert_eq!(Snapshot::capture(&restored), Snapshot::capture(&ui));
-        assert!(restored.project_search.is_empty());
-    }
-
-    #[test]
-    fn restored_viewer_slots_do_not_reuse_ids_or_restore_document_links() {
-        let config = MemoryConfig::default();
-        let mut ui = UiState::default();
-        let mut store = WorkspaceStore::load(Some(&config), &mut ui);
-        ui.dock = DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Viewer(2)], active: 0 };
-        ui.saved_workspaces.insert("Two views".into(), DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Viewer(5)], active: 0 });
-        ui.viewers.insert(2, Some(42));
-        assert!(store.save(Some(&config), &ui).unwrap());
-        let mut app = crate::EffectcraftApp::new(effectcraft_engine::Session::default());
-        WorkspaceStore::load(Some(&config), &mut app.ui);
-        assert_eq!(app.ui.viewers.get(&2), Some(&None));
-        assert_eq!(app.ui.viewers.get(&5), Some(&None));
-        assert_eq!(crate::panels::viewers::new_viewer(&mut app), 6);
-        assert!(app.ui.dock.contains(PanelKind::Viewer(2)));
-    }
-
-    #[test]
-    fn invalid_viewer_ids_are_rejected_in_every_workspace_reference() {
-        for id in [0, MAX_VIEWER_ID + 1, u32::MAX] {
-            for location in 0..8 {
-                let mut snapshot = Snapshot::capture(&UiState::default());
-                let panel = PanelKind::Viewer(id);
-                let dock = DockNode::Tabs { panels: vec![panel], active: 0 };
-                let stack = DockNode::Stack { entries: vec![crate::dock::StackEntry::new(panel, true, None)] };
-                let floating = vec![Floating { panels: vec![panel], active: 0, rect: [0.0, 0.0, 200.0, 100.0] }];
-                match location {
-                    0 => snapshot.focused = panel,
-                    1 => snapshot.maximized = Some(panel),
-                    2 => snapshot.dock = dock,
-                    3 => snapshot.dock = stack,
-                    4 => snapshot.floating = floating,
-                    5 => {
-                        snapshot.saved_workspaces.insert("Saved".into(), dock);
-                    }
-                    6 => {
-                        snapshot.saved_workspaces.insert("Saved".into(), stack);
-                    }
-                    _ => {
-                        snapshot.saved_floating.insert("Saved".into(), floating);
-                    }
-                }
-                assert!(snapshot.validate().is_err(), "viewer {id} at location {location} must be rejected");
-            }
-        }
-    }
-
-    #[test]
-    fn failed_write_keeps_previous_snapshot_and_retries() {
-        struct Fails<'a>(&'a MemoryConfig);
-        impl ConfigStore for Fails<'_> {
-            fn read(&self, name: &str) -> Option<String> {
-                self.0.read(name)
-            }
-            fn write(&self, _name: &str, _data: &str) -> std::io::Result<()> {
-                Err(std::io::Error::other("synthetic full disk"))
-            }
-            fn remove(&self, _name: &str) -> std::io::Result<()> {
-                Err(std::io::Error::other("unused"))
-            }
-        }
-        let config = MemoryConfig::default();
-        let mut ui = UiState::default();
-        let mut store = WorkspaceStore::load(Some(&config), &mut ui);
-        ui.focused = PanelKind::Project;
-        assert!(store.save(Some(&config), &ui).unwrap());
-        let previous = config.read(FILE).unwrap();
-        ui.focused = PanelKind::Timeline;
-        assert!(store.save(Some(&Fails(&config)), &ui).unwrap_err().contains("synthetic full disk"));
-        assert_eq!(config.read(FILE).as_deref(), Some(previous.as_str()));
-        assert!(store.has_changes(&ui));
-        assert!(store.save(Some(&config), &ui).unwrap());
-        let mut restored = UiState::default();
-        WorkspaceStore::load(Some(&config), &mut restored);
-        assert_eq!(restored.focused, PanelKind::Timeline);
+/// Explicit saves must wait until migrated native-window positions refer to their content.
+/// Check before capturing a named layout too, so a later background save cannot persist
+/// a snapshot made with the old outer-window positions.
+pub(crate) fn ensure_positions_ready(ui: &UiState) -> Result<(), String> {
+    if !ui.native_outer.is_empty() {
+        return Err("workspace window positions are still being restored; try saving again in a moment".into());
     }
+    Ok(())
 }
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/ui-egui/src/workspace_state/legacy.rs b/crates/ui-egui/src/workspace_state/legacy.rs
new file mode 100644
index 000000000..bcb5a9691
--- /dev/null
+++ b/crates/ui-egui/src/workspace_state/legacy.rs
@@ -0,0 +1,251 @@
+//! Workspace files of earlier versions: EffectCraft's own dock tree (craft-libs 5c874d51 and
+//! before), read into private copies of its types and turned into craft-ui workspaces.
+//!
+//! - Version 1 (`{version: 1, workspace, dock, floating, …, panel_windows}`) keeps the current
+//!   arrangement, the named workspaces, focus and the maximized panel.
+//! - The unversioned record (`{workspaces, floating}`) holds only named workspaces; the
+//!   current arrangement stays the default.
+//! - A column of stacked frames becomes tab groups split top to bottom. Each open frame is a
+//!   group with all its tabs; a frame with a height keeps it as a fixed size (its tab strip
+//!   added), and the others share the rest. A closed frame's tabs join the open frame above it
+//!   (below it, at the top of the column), as a split has no collapsed frames.
+//! - A floating group in its own native window (`panel_windows`) keeps that place as the
+//!   window's native rect. The earlier version stored the OS window's outer position, so the
+//!   window's id is returned for [`crate::dock_ui::native_outer_to_content`] to move it to its
+//!   content position once the main window reports its frame.
+//! - Closed panels had no recorded place: they stay closed and reopen at their default place.
+
+use std::collections::BTreeMap;
+
+use craft_ui::docking::{Floating, Node};
+use craft_ui::layout::{SplitAxis, SplitSize};
+use serde::Deserialize;
+
+use super::{Snapshot, VERSION};
+use crate::dock::{Layout, PanelKind, Workspace};
+use crate::state::UiState;
+
+#[cfg(test)]
+mod tests;
+
+#[derive(Deserialize)]
+enum OldSplitSize {
+    Ratio(f32),
+    FixedA(f32),
+    FixedB(f32),
+}
+
+/// A stacked frame; files from before stacked frames held tabs name one `panel`.
+#[derive(Deserialize)]
+struct OldStackEntry {
+    #[serde(default)]
+    panel: Option<PanelKind>,
+    #[serde(default)]
+    panels: Vec<PanelKind>,
+    #[serde(default)]
+    active: usize,
+    open: bool,
+    #[serde(default)]
+    height: Option<f32>,
+}
+
+#[derive(Deserialize)]
+enum OldNode {
+    Split { vertical: bool, size: OldSplitSize, a: Box<OldNode>, b: Box<OldNode> },
+    Tabs { panels: Vec<PanelKind>, active: usize },
+    Stack { entries: Vec<OldStackEntry> },
+}
+
+#[derive(Deserialize)]
+struct OldFloating {
+    panels: Vec<PanelKind>,
+    active: usize,
+    rect: [f32; 4],
+}
+
+/// The floating group holding `panel` shows in its own native window at `rect`.
+#[derive(Deserialize)]
+struct OldPanelWindow {
+    panel: PanelKind,
+    rect: [f32; 4],
+}
+
+#[derive(Deserialize)]
+struct OldSnapshot {
+    workspace: String,
+    dock: OldNode,
+    floating: Vec<OldFloating>,
+    focused: PanelKind,
+    maximized: Option<PanelKind>,
+    saved_workspaces: BTreeMap<String, OldNode>,
+    saved_floating: BTreeMap<String, Vec<OldFloating>>,
+    #[serde(default)]
+    panel_windows: Vec<OldPanelWindow>,
+}
+
+#[derive(Deserialize)]
+struct OldRecord {
+    #[serde(default)]
+    workspaces: BTreeMap<String, OldNode>,
+    #[serde(default)]
+    floating: BTreeMap<String, Vec<OldFloating>>,
+}
+
+/// Whether `value` is a file of an earlier version that [`migrate`] reads.
+pub(super) fn is_legacy(value: &serde_json::Value) -> bool {
+    match value.get("version") {
+        Some(version) => version.as_u64() == Some(1),
+        None => value.as_object().is_some_and(|fields| fields.contains_key("workspaces") || fields.contains_key("floating")),
+    }
+}
+
+/// The snapshot an earlier version's file describes, and the ids of its floating windows whose
+/// native rect holds the OS window's outer position. `ui` supplies what an unversioned record
+/// leaves out (the current arrangement). The caller validates the result.
+pub(super) fn migrate(value: serde_json::Value, ui: &UiState) -> Result<(Snapshot, Vec<u64>), String> {
+    if value.get("version").is_none() {
+        let record: OldRecord = serde_json::from_value(value).map_err(|e| e.to_string())?;
+        let mut snapshot = Snapshot::capture(ui);
+        snapshot.saved_workspaces = named(record.workspaces, record.floating)?;
+        return Ok((snapshot, Vec::new()));
+    }
+    let old: OldSnapshot = serde_json::from_value(value).map_err(|e| e.to_string())?;
+    let dock = workspace(old.dock, old.floating, &old.panel_windows)?;
+    let outer = dock.layout.floating.iter().filter(|window| window.native.is_some()).map(|window| window.id).collect();
+    let snapshot = Snapshot {
+        version: VERSION,
+        workspace: old.workspace,
+        dock,
+        focused: old.focused,
+        maximized: old.maximized,
+        saved_workspaces: named(old.saved_workspaces, old.saved_floating)?,
+    };
+    Ok((snapshot, outer))
+}
+
+/// Named workspaces with their floating groups; floating groups of no named workspace are
+/// dropped, as the earlier version never showed them.
+fn named(roots: BTreeMap<String, OldNode>, mut floating: BTreeMap<String, Vec<OldFloating>>) -> Result<BTreeMap<String, Workspace>, String> {
+    roots
+        .into_iter()
+        .map(|(name, root)| {
+            let groups = floating.remove(&name).unwrap_or_default();
+            workspace(root, groups, &[]).map(|workspace| (name, workspace))
+        })
+        .collect()
+}
+
+fn workspace(root: OldNode, floating: Vec<OldFloating>, windows: &[OldPanelWindow]) -> Result<Workspace, String> {
+    // Closing the last docked panel left an empty tab group as the root.
+    let root = match root {
+        OldNode::Tabs { panels, .. } if panels.is_empty() => None,
+        root => Some(node(root, 0)?),
+    };
+    let floating = floating
+        .into_iter()
+        .map(|group| {
+            let native = windows.iter().find(|window| group.panels.contains(&window.panel)).map(|window| window.rect);
+            let mut window = Floating::single(group.panels, group.active, group.rect);
+            window.native = native.map(crate::dock_ui::sanitized_window_rect);
+            window
+        })
+        .collect();
+    Ok(Workspace::new(Layout { root, floating }))
+}
+
+fn node(old: OldNode, depth: usize) -> Result<Node<PanelKind>, String> {
+    if depth > craft_ui::docking::MAX_DEPTH {
+        return Err("workspace dock tree exceeds supported limits".into());
+    }
+    Ok(match old {
+        OldNode::Tabs { panels, active } => Node::Tabs { panels, active },
+        OldNode::Split { vertical, size, a, b } => Node::Split {
+            axis: if vertical { SplitAxis::Vertical } else { SplitAxis::Horizontal },
+            size: match size {
+                OldSplitSize::Ratio(value) => SplitSize::Ratio(value),
+                OldSplitSize::FixedA(value) => SplitSize::FixedFirst(value),
+                OldSplitSize::FixedB(value) => SplitSize::FixedSecond(value),
+            },
+            first: Box::new(node(*a, depth.saturating_add(1))?),
+            second: Box::new(node(*b, depth.saturating_add(1))?),
+        },
+        OldNode::Stack { entries } => column(entries, depth)?,
+    })
+}
+
+/// The space between two frames of a column, in points ([`crate::theme::Tokens::gap`]).
+const FRAME_GAP: f32 = 4.0;
+/// The largest frame height a migrated column keeps, in points.
+const MAX_FRAME: f32 = 10_000.0;
+
+/// A tab group of a column: its panels, shown tab, and body height when it has one.
+struct Frame {
+    panels: Vec<PanelKind>,
+    active: usize,
+    height: Option<f32>,
+}
+
+/// A column of stacked frames as tab groups split top to bottom (see the module docs).
+fn column(entries: Vec<OldStackEntry>, depth: usize) -> Result<Node<PanelKind>, String> {
+    let mut frames: Vec<Frame> = Vec::new();
+    // Tabs of closed frames above the first open one.
+    let mut waiting: Vec<PanelKind> = Vec::new();
+    for entry in entries {
+        let mut panels = entry.panels;
+        if let Some(panel) = entry.panel
+            && !panels.contains(&panel)
+        {
+            panels.insert(0, panel);
+        }
+        if panels.is_empty() {
+            continue;
+        }
+        let active = entry.active.min(panels.len().saturating_sub(1));
+        if entry.open {
+            if depth.saturating_add(frames.len()) > craft_ui::docking::MAX_DEPTH {
+                return Err("workspace dock tree exceeds supported limits".into());
+            }
+            let height = entry.height.filter(|h| h.is_finite() && *h > 0.0).map(|h| h.min(MAX_FRAME));
+            frames.push(Frame { panels, active, height });
+        } else if let Some(above) = frames.last_mut() {
+            above.panels.extend(panels);
+        } else {
+            waiting.extend(panels);
+        }
+    }
+    match frames.first_mut() {
+        Some(top) => top.panels.extend(waiting),
+        None if !waiting.is_empty() => frames.push(Frame { panels: waiting, active: 0, height: None }),
+        None => return Err("a stacked frame holds no panels".into()),
+    }
+    let frame_size = |frame: &Frame| frame.height.map(|h| h + crate::dock::TAB_STRIP);
+    let mut node: Option<Node<PanelKind>> = None;
+    // Below the frame being added: the frames' fixed sizes and gaps, or None when one shares.
+    let mut below_fixed = Some(0.0_f32);
+    let mut below_flexible = 0_usize;
+    for frame in frames.into_iter().rev() {
+        let own = frame_size(&frame);
+        let gap = if node.is_some() { FRAME_GAP } else { 0.0 };
+        let tabs = Node::Tabs { panels: frame.panels, active: frame.active };
+        node = Some(match node {
+            None => tabs,
+            Some(rest) => {
+                let size = match (own, below_fixed) {
+                    (Some(own), _) => SplitSize::FixedFirst(own),
+                    (None, Some(below)) => SplitSize::FixedSecond(below),
+                    // Shares the rest with the flexible frames below.
+                    (None, None) => SplitSize::Ratio(1.0 / (below_flexible as f32 + 1.0)),
+                };
+                Node::Split { axis: SplitAxis::Vertical, size, first: Box::new(tabs), second: Box::new(rest) }
+            }
+        });
+        below_fixed = match (own, below_fixed) {
+            (Some(own), Some(below)) => Some(below + gap + own),
+            _ => None,
+        };
+        if own.is_none() {
+            below_flexible = below_flexible.saturating_add(1);
+        }
+    }
+    node.ok_or_else(|| "a stacked frame holds no panels".into())
+}
diff --git a/crates/ui-egui/src/workspace_state/legacy/tests.rs b/crates/ui-egui/src/workspace_state/legacy/tests.rs
new file mode 100644
index 000000000..a3d182f4f
--- /dev/null
+++ b/crates/ui-egui/src/workspace_state/legacy/tests.rs
@@ -0,0 +1,35 @@
+use super::*;
+
+fn stack(count: usize) -> OldNode {
+    OldNode::Stack {
+        entries: (0..count).map(|_| OldStackEntry { panel: Some(PanelKind::Info), panels: Vec::new(), active: 0, open: true, height: None }).collect(),
+    }
+}
+
+#[test]
+fn stacked_frames_respect_the_remaining_tree_depth() {
+    let limit = craft_ui::docking::MAX_DEPTH;
+    assert!(node(stack(limit + 1), 0).is_ok());
+    assert!(node(stack(limit + 2), 0).is_err());
+    assert!(node(stack(1), limit).is_ok());
+    assert!(node(stack(2), limit).is_err());
+    assert!(node(stack(limit), 2).is_err());
+}
+
+#[test]
+fn oversized_legacy_stack_load_does_not_abort() {
+    const CHILD: &str = "EFFECTCRAFT_TEST_LEGACY_STACK_CHILD";
+    if std::env::var_os(CHILD).is_some() {
+        let entry = serde_json::json!({"panel": "Info", "open": true});
+        let value = serde_json::json!({"workspaces": {"Oversized": {"Stack": {"entries": vec![entry; 20_000]}}}});
+        assert!(serde_json::to_vec(&value).unwrap().len() < super::super::MAX_BYTES);
+        assert!(migrate(value, &UiState::default()).is_err());
+        return;
+    }
+    let output = std::process::Command::new(std::env::current_exe().unwrap())
+        .args(["--exact", "workspace_state::legacy::tests::oversized_legacy_stack_load_does_not_abort", "--nocapture"])
+        .env(CHILD, "1")
+        .output()
+        .unwrap();
+    assert!(output.status.success(), "{}\n{}", String::from_utf8_lossy(&output.stdout), String::from_utf8_lossy(&output.stderr));
+}
diff --git a/crates/ui-egui/src/workspace_state/tests.rs b/crates/ui-egui/src/workspace_state/tests.rs
new file mode 100644
index 000000000..aab2814ba
--- /dev/null
+++ b/crates/ui-egui/src/workspace_state/tests.rs
@@ -0,0 +1,369 @@
+use super::*;
+use crate::dock::{Floating, Layout, Node, StackEntry, WorkspaceExt as _};
+use craft_ui::docking::Action;
+use craft_ui::layout::{SplitAxis, SplitSize};
+use effectcraft_engine::config::MemoryConfig;
+
+fn minimal() -> Workspace {
+    Workspace::new(crate::dock::workspace("Minimal"))
+}
+
+fn tabs(panels: &[PanelKind]) -> Node<PanelKind> {
+    Node::Tabs { panels: panels.to_vec(), active: 0 }
+}
+
+#[test]
+fn corrupt_future_or_unknown_workspace_keeps_defaults_and_original_file() {
+    let valid = Snapshot::capture(&UiState::default());
+    // Damaged files of the earlier version: a panel in two places, a bad split, an unknown
+    // panel, a tree deeper than craft-ui allows, a missing field.
+    let earlier = |dock: &str| {
+        format!(
+            r#"{{"version":1,"workspace":"Default","dock":{dock},"floating":[],"focused":"Composition","maximized":null,"saved_workspaces":{{}},"saved_floating":{{}}}}"#
+        )
+    };
+    let mut deep = r#"{"Tabs":{"panels":["Composition"],"active":0}}"#.to_string();
+    for _ in 0..=craft_ui::docking::MAX_DEPTH {
+        deep = format!(r#"{{"Split":{{"vertical":true,"size":{{"Ratio":0.5}},"a":{deep},"b":{{"Tabs":{{"panels":[],"active":0}}}}}}}}"#);
+    }
+    let twice =
+        r#"{"Split":{"vertical":true,"size":{"Ratio":0.5},"a":{"Tabs":{"panels":["Project"],"active":0}},"b":{"Tabs":{"panels":["Project"],"active":0}}}}"#;
+    let bad_split =
+        r#"{"Split":{"vertical":true,"size":{"Ratio":7.0},"a":{"Tabs":{"panels":["Project"],"active":0}},"b":{"Tabs":{"panels":["Timeline"],"active":0}}}}"#;
+    for text in [
+        "{".into(),
+        "{}".into(),
+        "[1, 2]".into(),
+        serde_json::to_string(&Snapshot { version: VERSION + 1, ..valid }).unwrap(),
+        " ".repeat(MAX_BYTES + 1),
+        earlier(twice),
+        earlier(bad_split),
+        earlier(r#"{"Tabs":{"panels":["NoSuchPanel"],"active":0}}"#),
+        earlier(&deep),
+        r#"{"version":1,"workspace":"Default"}"#.into(),
+        r#"{"workspaces":{"Mine":{"Tabs":{"panels":["Composition"],"active":3}}}}"#.into(),
+    ] {
+        let config = MemoryConfig::default();
+        config.write(FILE, &text).unwrap();
+        let mut ui = UiState::default();
+        let mut store = WorkspaceStore::load(Some(&config), &mut ui);
+        assert!(store.error.is_some());
+        assert_eq!(ui.workspace, "Default");
+        assert_eq!(ui.dock, UiState::default().dock);
+        ui.focused = PanelKind::Project;
+        ui.dock = minimal();
+        assert!(!store.save(Some(&config), &ui).unwrap());
+        assert!(store.save_now(Some(&config), &ui).unwrap_err().contains("couldn't be loaded"));
+        assert_eq!(config.read(FILE).as_deref(), Some(text.as_str()));
+        assert_eq!(config.read(BACKUP), None);
+    }
+}
+
+/// A file written by EffectCraft 0.10 (craft-libs 5c874d51): the Default workspace with
+/// Preview floating, Render Queue floating in its own native window, Align closed,
+/// Effects & Presets moved into the Project group and Audio split beside the Timeline,
+/// saved as "My Layout"; then Layer closed.
+const V1: &str = include_str!("../../tests/fixtures/workspaces-v1.json");
+
+#[test]
+fn explicit_save_reports_pending_migration_and_can_be_retried() {
+    let config = MemoryConfig::default();
+    config.write(FILE, V1).unwrap();
+    let mut ui = UiState::default();
+    let mut store = WorkspaceStore::load(Some(&config), &mut ui);
+    assert!(!ui.native_outer.is_empty());
+    assert!(!store.save(Some(&config), &ui).unwrap(), "background saves defer quietly");
+    let error = store.save_now(Some(&config), &ui).unwrap_err();
+    assert!(error.contains("positions") && error.contains("try saving again"), "{error}");
+    assert_eq!(config.read(FILE).as_deref(), Some(V1));
+    assert_eq!(config.read(BACKUP), None);
+    assert!(store.has_changes(&ui));
+
+    crate::dock_ui::native_outer_to_content(&mut ui, None, None, 3.0);
+    store.save_now(Some(&config), &ui).unwrap();
+    assert_eq!(config.read(BACKUP).as_deref(), Some(V1));
+    let mut restored = UiState::default();
+    let loaded = WorkspaceStore::load(Some(&config), &mut restored);
+    assert_eq!(loaded.error, None);
+    assert_eq!(Snapshot::capture(&restored), Snapshot::capture(&ui));
+}
+
+#[test]
+fn version_one_file_loads_with_every_panel_in_place() {
+    let config = MemoryConfig::default();
+    config.write(FILE, V1).unwrap();
+    let mut ui = UiState::default();
+    let store = WorkspaceStore::load(Some(&config), &mut ui);
+    assert_eq!(store.error, None);
+    assert_eq!(ui.workspace, "My Layout");
+    assert_eq!(ui.focused, PanelKind::Composition);
+    use PanelKind::*;
+    let root = crate::dock::hsplit(
+        SplitSize::FixedSecond(300.0),
+        crate::dock::vsplit(
+            SplitSize::Ratio(0.56),
+            crate::dock::hsplit(SplitSize::FixedFirst(300.0), crate::dock::tabs(&[Project, EffectControls, EffectsPresets], 2), tabs(&[Composition])),
+            crate::dock::hsplit(SplitSize::Ratio(0.5), tabs(&[Timeline]), tabs(&[Audio])),
+        ),
+        tabs(&[Properties]),
+    );
+    assert_eq!(ui.dock.layout.root, Some(root));
+    let floating: Vec<_> = ui.dock.layout.floating.iter().map(|w| (w.panels().copied().collect::<Vec<_>>(), w.rect, w.native)).collect();
+    assert_eq!(
+        floating,
+        [
+            (vec![Preview], [900.0, 120.0, 300.0, 260.0], None),
+            (vec![RenderQueue], [200.0, 500.0, 520.0, 240.0], Some(crate::dock_ui::sanitized_window_rect([200.0, 500.0, 520.0, 240.0]))),
+        ]
+    );
+    // Closed panels stay closed.
+    for panel in [Align, Layer] {
+        assert!(!ui.dock.is_open(panel), "{panel:?}");
+    }
+    // The native window's place is its outer position until the main window reports its
+    // frame (here a 28-point title bar); the file is not rewritten before.
+    let id = ui.dock.layout.floating[1].id;
+    assert_eq!(ui.native_outer, [id]);
+    let mut store = store;
+    assert!(!store.save(Some(&config), &ui).unwrap());
+    let outer = egui::Rect::from_min_size(egui::pos2(10.0, 20.0), egui::vec2(1600.0, 1000.0));
+    crate::dock_ui::native_outer_to_content(&mut ui, Some(outer), Some(outer.translate(egui::vec2(0.0, 28.0))), 0.1);
+    assert_eq!(ui.dock.layout.floating[1].native, Some([200.0, 528.0, 520.0, 240.0]));
+    assert!(ui.native_outer.is_empty());
+    assert!(store.save(Some(&config), &ui).unwrap());
+    // The named workspace still has Layer, closed only after it was saved.
+    let saved = ui.saved_workspaces.get("My Layout").unwrap();
+    assert!(saved.is_docked(Layer) && saved.is_floating(Preview) && !saved.is_open(Align));
+    assert_eq!(saved.layout.floating.iter().filter_map(|w| w.native).count(), 0);
+}
+
+#[test]
+fn version_one_file_is_rewritten_once_in_the_current_format_and_kept_as_a_backup() {
+    let config = MemoryConfig::default();
+    config.write(FILE, V1).unwrap();
+    let mut ui = UiState::default();
+    let mut store = WorkspaceStore::load(Some(&config), &mut ui);
+    // A backend that reports no window positions: the native place stays as it was.
+    let native = ui.dock.layout.floating[1].native;
+    crate::dock_ui::native_outer_to_content(&mut ui, None, None, 1.0);
+    assert!(!ui.native_outer.is_empty(), "waits for a report");
+    crate::dock_ui::native_outer_to_content(&mut ui, None, None, 5.0);
+    assert!(ui.native_outer.is_empty());
+    assert_eq!(ui.dock.layout.floating[1].native, native);
+    let migrated = Snapshot::capture(&ui);
+    assert!(store.has_changes(&ui), "the migrated layout is written without waiting for an edit");
+    assert!(store.save(Some(&config), &ui).unwrap());
+    assert_eq!(config.read(BACKUP).as_deref(), Some(V1));
+    let text = config.read(FILE).unwrap();
+    assert_eq!(serde_json::from_str::<serde_json::Value>(&text).unwrap()["version"], VERSION);
+    assert!(!store.has_changes(&ui));
+    let mut restored = UiState::default();
+    let reloaded = WorkspaceStore::load(Some(&config), &mut restored);
+    assert_eq!(reloaded.error, None);
+    assert!(!reloaded.has_changes(&restored));
+    assert_eq!(Snapshot::capture(&restored), migrated);
+}
+
+#[test]
+fn stacked_frames_with_tabs_and_an_empty_root_migrate() {
+    let text = r#"{"version":1,"workspace":"Mine","dock":{"Tabs":{"panels":[],"active":0}},
+            "floating":[{"panels":["Project"],"active":0,"rect":[10.0,10.0,300.0,200.0]}],
+            "focused":"Project","maximized":null,
+            "saved_workspaces":{"Mine":{"Stack":{"entries":[{"panel":"Info","open":true},{"panels":["Audio","Preview"],"active":1,"open":true,"height":80.0}]}},
+                "Column":{"Stack":{"entries":[{"panel":"Align","open":false},{"panel":"Preview","open":true,"height":46.0},{"panels":["Properties","Paint"],"active":1,"open":false,"height":300.0},{"panel":"Info","open":true}]}}},
+            "saved_floating":{"Gone":[{"panels":["Align"],"active":0,"rect":[0.0,0.0,100.0,100.0]}]}}"#;
+    let config = MemoryConfig::default();
+    config.write(FILE, text).unwrap();
+    let mut ui = UiState::default();
+    let store = WorkspaceStore::load(Some(&config), &mut ui);
+    assert_eq!(store.error, None);
+    assert_eq!(ui.dock.layout.root, None);
+    assert!(ui.dock.is_floating(PanelKind::Project));
+    use PanelKind::*;
+    // Each open frame is a tab group with all its tabs; a frame's height is a fixed size
+    // (with its tab strip), and the frame without one takes the rest.
+    let column = crate::dock::vsplit(SplitSize::FixedSecond(80.0 + crate::dock::TAB_STRIP), tabs(&[Info]), crate::dock::tabs(&[Audio, Preview], 1));
+    assert_eq!(ui.saved_workspaces.get("Mine").and_then(|w| w.layout.root.clone()), Some(column));
+    // Closed frames' tabs join the open frame above them, or below at the top.
+    let column = crate::dock::vsplit(SplitSize::FixedFirst(46.0 + crate::dock::TAB_STRIP), tabs(&[Preview, Properties, Paint, Align]), tabs(&[Info]));
+    assert_eq!(ui.saved_workspaces.get("Column").and_then(|w| w.layout.root.clone()), Some(column));
+    assert_eq!(ui.saved_workspaces.len(), 2, "floating groups of no named workspace are dropped");
+}
+
+#[test]
+fn explicit_save_without_a_settings_folder_is_an_error() {
+    let mut ui = UiState::default();
+    let mut store = WorkspaceStore::load(None, &mut ui);
+    ui.focused = PanelKind::Project;
+    assert!(!store.save(None, &ui).unwrap());
+    assert!(store.save_now(None, &ui).is_err());
+}
+
+#[test]
+fn explicit_save_with_nothing_new_succeeds() {
+    let config = MemoryConfig::default();
+    let mut ui = UiState::default();
+    let mut store = WorkspaceStore::load(Some(&config), &mut ui);
+    ui.focused = PanelKind::Project;
+    store.save_now(Some(&config), &ui).unwrap();
+    store.save_now(Some(&config), &ui).unwrap();
+    assert!(config.read(FILE).is_some());
+}
+
+#[test]
+fn invalid_tabs_split_and_deep_tree_are_rejected() {
+    let mut snapshot = Snapshot::capture(&UiState::default());
+    snapshot.dock = Workspace::new(Layout { root: Some(Node::Tabs { panels: vec![PanelKind::Project], active: usize::MAX }), floating: vec![] });
+    assert!(snapshot.validate().is_err());
+    let split = |size, first, second| Node::Split { axis: SplitAxis::Horizontal, size, first: Box::new(first), second: Box::new(second) };
+    snapshot.dock = Workspace::new(Layout {
+        root: Some(split(SplitSize::FixedFirst(f32::NAN), tabs(&[PanelKind::Project]), tabs(&[PanelKind::Timeline]))),
+        floating: vec![],
+    });
+    assert!(snapshot.validate().is_err());
+    let mut root = tabs(&[PanelKind::Composition]);
+    for _ in 0..=craft_ui::docking::MAX_DEPTH {
+        root = split(SplitSize::Ratio(0.5), root, tabs(&[]));
+    }
+    snapshot.dock = Workspace::new(Layout { root: Some(root), floating: vec![] });
+    assert!(snapshot.validate().is_err());
+    // A panel in two places.
+    snapshot.dock = Workspace::new(Layout {
+        root: Some(tabs(&[PanelKind::Project])),
+        floating: vec![Floating::single(vec![PanelKind::Project], 0, [0.0, 0.0, 200.0, 100.0])],
+    });
+    assert!(snapshot.validate().is_err());
+}
+
+#[test]
+fn closing_all_docked_panels_remains_a_persistable_layout() {
+    let config = MemoryConfig::default();
+    let mut ui = UiState::default();
+    let mut store = WorkspaceStore::load(Some(&config), &mut ui);
+    for panel in ui.dock.panels() {
+        ui.dock.apply(Action::Close { panel }, crate::dock::permissions).unwrap();
+    }
+    assert!(ui.dock.layout.root.is_none());
+    assert!(store.save(Some(&config), &ui).unwrap());
+    let mut restored = UiState::default();
+    let loaded = WorkspaceStore::load(Some(&config), &mut restored);
+    assert!(loaded.error.is_none());
+    assert_eq!(restored.dock, ui.dock);
+}
+
+#[test]
+fn floating_groups_and_named_snapshots_roundtrip_without_document_state() {
+    let config = MemoryConfig::default();
+    let mut ui = UiState::default();
+    let mut store = WorkspaceStore::load(Some(&config), &mut ui);
+    ui.workspace = "Floating".into();
+    ui.dock.apply(Action::Float { panel: PanelKind::Preview, rect: [50.0, 80.0, 200.0, 160.0] }, crate::dock::permissions).unwrap();
+    ui.dock.apply(Action::Close { panel: PanelKind::Align }, crate::dock::permissions).unwrap();
+    ui.saved_workspaces.insert(ui.workspace.clone(), ui.dock.clone());
+    ui.maximized = Some(PanelKind::Composition);
+    ui.project_search = "do not persist".into();
+    assert!(store.save(Some(&config), &ui).unwrap());
+    let mut restored = UiState::default();
+    WorkspaceStore::load(Some(&config), &mut restored);
+    assert_eq!(Snapshot::capture(&restored), Snapshot::capture(&ui));
+    // The closed panel's place comes back with it.
+    assert!(restored.dock.hidden.iter().any(|(p, _)| *p == PanelKind::Align));
+    assert!(restored.project_search.is_empty());
+}
+
+#[test]
+fn restored_viewer_slots_do_not_reuse_ids_or_restore_document_links() {
+    let config = MemoryConfig::default();
+    let mut ui = UiState::default();
+    let mut store = WorkspaceStore::load(Some(&config), &mut ui);
+    let two = |viewer| Workspace::new(Layout { root: Some(tabs(&[PanelKind::Composition, PanelKind::Viewer(viewer)])), floating: vec![] });
+    ui.dock = two(2);
+    ui.saved_workspaces.insert("Two views".into(), two(5));
+    ui.viewers.insert(2, Some(42));
+    assert!(store.save(Some(&config), &ui).unwrap());
+    let mut app = crate::EffectcraftApp::new(effectcraft_engine::Session::default());
+    WorkspaceStore::load(Some(&config), &mut app.ui);
+    assert_eq!(app.ui.viewers.get(&2), Some(&None));
+    assert_eq!(app.ui.viewers.get(&5), Some(&None));
+    assert_eq!(crate::panels::viewers::new_viewer(&mut app), 6);
+    assert!(app.ui.dock.is_docked(PanelKind::Viewer(2)));
+}
+
+#[test]
+fn invalid_viewer_ids_are_rejected_in_every_workspace_reference() {
+    for id in [0, MAX_VIEWER_ID + 1, u32::MAX] {
+        for location in 0..8 {
+            let mut snapshot = Snapshot::capture(&UiState::default());
+            let panel = PanelKind::Viewer(id);
+            let docked = Workspace::new(Layout { root: Some(tabs(&[panel])), floating: vec![] });
+            let stacked =
+                Workspace::new(Layout { root: Some(Node::Stack { entries: vec![StackEntry { panel, open: true, height: None }] }), floating: vec![] });
+            let floating = Workspace::new(Layout {
+                root: Some(tabs(&[PanelKind::Composition])),
+                floating: vec![Floating::single(vec![panel], 0, [0.0, 0.0, 200.0, 100.0])],
+            });
+            let mut hidden = Workspace::new(Layout { root: Some(tabs(&[PanelKind::Composition, panel])), floating: vec![] });
+            hidden.apply(Action::Close { panel }, crate::dock::permissions).unwrap();
+            match location {
+                0 => snapshot.focused = panel,
+                1 => snapshot.maximized = Some(panel),
+                2 => snapshot.dock = docked,
+                3 => snapshot.dock = stacked,
+                4 => snapshot.dock = floating,
+                5 => snapshot.dock = hidden,
+                6 => {
+                    snapshot.saved_workspaces.insert("Saved".into(), stacked);
+                }
+                _ => {
+                    snapshot.saved_workspaces.insert("Saved".into(), floating);
+                }
+            }
+            assert!(snapshot.validate().is_err(), "viewer {id} at location {location} must be rejected");
+        }
+    }
+}
+
+#[test]
+fn hostile_native_window_places_are_made_safe_on_load() {
+    let config = MemoryConfig::default();
+    let mut ui = UiState::default();
+    let mut store = WorkspaceStore::load(Some(&config), &mut ui);
+    ui.dock.apply(Action::Float { panel: PanelKind::Project, rect: [10.0, 10.0, 300.0, 200.0] }, crate::dock::permissions).unwrap();
+    ui.dock.apply(Action::SetNative { panel: PanelKind::Project, rect: Some([90_000.0, -90_000.0, 1.0e5, 0.5]) }, crate::dock::permissions).unwrap();
+    assert!(store.save(Some(&config), &ui).unwrap());
+    let mut restored = UiState::default();
+    WorkspaceStore::load(Some(&config), &mut restored);
+    let native = restored.dock.layout.floating.iter().find(|w| w.contains(&PanelKind::Project)).and_then(|w| w.native).unwrap();
+    assert_eq!(native, crate::dock_ui::sanitized_window_rect(native));
+    assert!(native[2] <= crate::dock_ui::PANEL_WINDOW_MAX && native[3] >= crate::dock_ui::PANEL_WINDOW_MIN[1]);
+}
+
+#[test]
+fn failed_write_keeps_previous_snapshot_and_retries() {
+    struct Fails<'a>(&'a MemoryConfig);
+    impl ConfigStore for Fails<'_> {
+        fn read(&self, name: &str) -> Option<String> {
+            self.0.read(name)
+        }
+        fn write(&self, _name: &str, _data: &str) -> std::io::Result<()> {
+            Err(std::io::Error::other("synthetic full disk"))
+        }
+        fn remove(&self, _name: &str) -> std::io::Result<()> {
+            Err(std::io::Error::other("unused"))
+        }
+    }
+    let config = MemoryConfig::default();
+    let mut ui = UiState::default();
+    let mut store = WorkspaceStore::load(Some(&config), &mut ui);
+    ui.focused = PanelKind::Project;
+    assert!(store.save(Some(&config), &ui).unwrap());
+    let previous = config.read(FILE).unwrap();
+    ui.focused = PanelKind::Timeline;
+    assert!(store.save(Some(&Fails(&config)), &ui).unwrap_err().contains("synthetic full disk"));
+    assert_eq!(config.read(FILE).as_deref(), Some(previous.as_str()));
+    assert!(store.has_changes(&ui));
+    assert!(store.save(Some(&config), &ui).unwrap());
+    let mut restored = UiState::default();
+    WorkspaceStore::load(Some(&config), &mut restored);
+    assert_eq!(restored.focused, PanelKind::Timeline);
+}
diff --git a/crates/ui-egui/tests/fixtures/workspaces-v1.json b/crates/ui-egui/tests/fixtures/workspaces-v1.json
new file mode 100644
index 000000000..164bf37f0
--- /dev/null
+++ b/crates/ui-egui/tests/fixtures/workspaces-v1.json
@@ -0,0 +1,234 @@
+{
+  "version": 1,
+  "workspace": "My Layout",
+  "dock": {
+    "Split": {
+      "vertical": false,
+      "size": {
+        "FixedB": 300.0
+      },
+      "a": {
+        "Split": {
+          "vertical": true,
+          "size": {
+            "Ratio": 0.56
+          },
+          "a": {
+            "Split": {
+              "vertical": false,
+              "size": {
+                "FixedA": 300.0
+              },
+              "a": {
+                "Tabs": {
+                  "panels": [
+                    "Project",
+                    "EffectControls",
+                    "EffectsPresets"
+                  ],
+                  "active": 2
+                }
+              },
+              "b": {
+                "Tabs": {
+                  "panels": [
+                    "Composition"
+                  ],
+                  "active": 0
+                }
+              }
+            }
+          },
+          "b": {
+            "Split": {
+              "vertical": false,
+              "size": {
+                "Ratio": 0.5
+              },
+              "a": {
+                "Tabs": {
+                  "panels": [
+                    "Timeline"
+                  ],
+                  "active": 0
+                }
+              },
+              "b": {
+                "Tabs": {
+                  "panels": [
+                    "Audio"
+                  ],
+                  "active": 0
+                }
+              }
+            }
+          }
+        }
+      },
+      "b": {
+        "Stack": {
+          "entries": [
+            {
+              "panels": [
+                "Properties"
+              ],
+              "active": 0,
+              "open": true,
+              "height": null
+            }
+          ]
+        }
+      }
+    }
+  },
+  "floating": [
+    {
+      "panels": [
+        "Preview"
+      ],
+      "active": 0,
+      "rect": [
+        900.0,
+        120.0,
+        300.0,
+        260.0
+      ]
+    },
+    {
+      "panels": [
+        "RenderQueue"
+      ],
+      "active": 0,
+      "rect": [
+        200.0,
+        500.0,
+        520.0,
+        240.0
+      ]
+    }
+  ],
+  "focused": "Composition",
+  "maximized": null,
+  "saved_workspaces": {
+    "My Layout": {
+      "Split": {
+        "vertical": false,
+        "size": {
+          "FixedB": 300.0
+        },
+        "a": {
+          "Split": {
+            "vertical": true,
+            "size": {
+              "Ratio": 0.56
+            },
+            "a": {
+              "Split": {
+                "vertical": false,
+                "size": {
+                  "FixedA": 300.0
+                },
+                "a": {
+                  "Tabs": {
+                    "panels": [
+                      "Project",
+                      "EffectControls",
+                      "EffectsPresets"
+                    ],
+                    "active": 2
+                  }
+                },
+                "b": {
+                  "Tabs": {
+                    "panels": [
+                      "Composition",
+                      "Layer"
+                    ],
+                    "active": 0
+                  }
+                }
+              }
+            },
+            "b": {
+              "Split": {
+                "vertical": false,
+                "size": {
+                  "Ratio": 0.5
+                },
+                "a": {
+                  "Tabs": {
+                    "panels": [
+                      "Timeline"
+                    ],
+                    "active": 0
+                  }
+                },
+                "b": {
+                  "Tabs": {
+                    "panels": [
+                      "Audio"
+                    ],
+                    "active": 0
+                  }
+                }
+              }
+            }
+          }
+        },
+        "b": {
+          "Stack": {
+            "entries": [
+              {
+                "panels": [
+                  "Properties"
+                ],
+                "active": 0,
+                "open": true,
+                "height": null
+              }
+            ]
+          }
+        }
+      }
+    }
+  },
+  "saved_floating": {
+    "My Layout": [
+      {
+        "panels": [
+          "Preview"
+        ],
+        "active": 0,
+        "rect": [
+          900.0,
+          120.0,
+          300.0,
+          260.0
+        ]
+      },
+      {
+        "panels": [
+          "RenderQueue"
+        ],
+        "active": 0,
+        "rect": [
+          200.0,
+          500.0,
+          520.0,
+          240.0
+        ]
+      }
+    ]
+  },
+  "panel_windows": [
+    {
+      "panel": "RenderQueue",
+      "rect": [
+        200.0,
+        500.0,
+        520.0,
+        240.0
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/crates/ui-egui/tests/it/gpu_test.rs b/crates/ui-egui/tests/it/gpu_test.rs
new file mode 100644
index 000000000..0156fbb4d
--- /dev/null
+++ b/crates/ui-egui/tests/it/gpu_test.rs
@@ -0,0 +1,43 @@
+//! Shared device-creation gate for the integration-test executable.
+
+static GPU_TEST_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
+thread_local! {
+    static HELD: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
+}
+
+pub(crate) struct Guard {
+    held: Option<std::sync::MutexGuard<'static, ()>>,
+}
+
+impl Drop for Guard {
+    fn drop(&mut self) {
+        if self.held.is_some() {
+            HELD.with(|held| held.set(false));
+        }
+    }
+}
+
+/// GPU-backed harnesses hold this for their whole test; screenshots may enter it again.
+pub(crate) fn lock() -> Guard {
+    let held = if HELD.with(std::cell::Cell::get) {
+        None
+    } else {
+        let guard = GPU_TEST_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+        HELD.with(|held| held.set(true));
+        Some(guard)
+    };
+    Guard { held }
+}
+
+/// Plain harnesses create their GPU renderer lazily on the first screenshot.
+pub(crate) trait RenderSerial {
+    fn render_serialized(&mut self) -> Result<image::RgbaImage, String>;
+}
+
+impl<State> RenderSerial for egui_kittest::Harness<'_, State> {
+    fn render_serialized(&mut self) -> Result<image::RgbaImage, String> {
+        let _device = lock();
+        self.render().map_err(|error| format!("{error:?}"))
+    }
+}
diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs
index b5492c1b5..2de7ebee7 100644
--- a/crates/ui-egui/tests/it/main.rs
+++ b/crates/ui-egui/tests/it/main.rs
@@ -1,24 +1,38 @@
 //! The crate's integration tests, one binary (each module is a former `tests/<name>.rs`).
 
+mod gpu_test;
+mod native_menu_text_keys;
 mod render_queue_snapshot;
+mod roto_model_guard;
 mod shared_docking_ui;
 mod ui_3d;
+mod ui_accessibility;
+mod ui_accessibility_audit;
 mod ui_agent_audit;
 mod ui_angles;
 mod ui_audio_scrub;
 mod ui_azerty_shortcuts;
+mod ui_batch_links;
 mod ui_batch_switches;
 mod ui_blank_context_menus;
 mod ui_camera_tracker;
 mod ui_character_eyedropper;
+mod ui_character_stroke_order;
+mod ui_checkbox_drag;
 mod ui_color_hex;
 mod ui_comp_presets;
+mod ui_contrast;
 mod ui_control_modifiers;
+mod ui_dialog_preview;
 mod ui_dock_resize;
 mod ui_drag_drop;
 mod ui_effect_controls;
 mod ui_effect_drop_highlight;
 mod ui_effect_names;
+mod ui_effects_presets_keyboard;
+mod ui_env_light_gpu;
+mod ui_export_overwrite;
+mod ui_expression_values;
 mod ui_font_search;
 mod ui_form_fit;
 mod ui_frame_step;
@@ -38,6 +52,7 @@ mod ui_layer_source_picker;
 mod ui_light_settings;
 mod ui_live_preview;
 mod ui_locked_color;
+mod ui_marker_names;
 mod ui_media_browser_cache;
 mod ui_media_browser_copy_path;
 mod ui_menus;
@@ -57,17 +72,25 @@ mod ui_project_rows;
 mod ui_quick_offset;
 mod ui_ram_preview;
 mod ui_render_queue;
+mod ui_render_queue_keyboard;
+mod ui_roto_objects;
+mod ui_roto_span_confidence;
 mod ui_script_console;
 mod ui_scriptui;
 mod ui_scrolling;
+mod ui_self_drop;
 mod ui_settings_info;
+mod ui_settings_keyboard;
+mod ui_shortcut_scopes;
 mod ui_tabs;
 mod ui_tail;
 mod ui_text_edit;
 mod ui_text_range_handles;
 mod ui_theme_favorites;
 mod ui_time_zoom_controls;
+mod ui_timeline_audio_levels;
 mod ui_timeline_effect_label;
+mod ui_timeline_group_select;
 mod ui_timeline_pan;
 mod ui_timeline_shapes;
 mod ui_timeline_switches;
@@ -78,11 +101,13 @@ mod ui_tracker;
 mod ui_unreadable_footage;
 mod ui_video_preview_off;
 mod ui_viewer;
+mod ui_viewer_trackpad;
 mod ui_viewers;
 mod ui_visual_review;
 mod ui_web_gpu_storage;
 mod ui_web_job_gpu;
 mod ui_web_offload;
+mod ui_window_title;
 mod ui_workflow_selection;
 mod ui_workspace_focus;
 mod viewer_geometry;
diff --git a/crates/ui-egui/tests/it/native_menu_text_keys.rs b/crates/ui-egui/tests/it/native_menu_text_keys.rs
new file mode 100644
index 000000000..d740c6b46
--- /dev/null
+++ b/crates/ui-egui/tests/it/native_menu_text_keys.rs
@@ -0,0 +1,191 @@
+//! The macOS menu bar takes the Edit menu's key equivalents before any window sees them: while a
+//! text field has the keyboard, in a docked panel or a floating panel's own OS window, they edit
+//! the field and leave the project alone, and the items stay enabled.
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::{menus, native_menu};
+use egui::{Event, Modifiers, PointerButton, Pos2, ViewportCommand, ViewportId, ViewportInfo, pos2, vec2};
+use egui_kittest::Harness;
+use serde_json::json;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+fn app() -> EffectcraftApp {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Solid", "color": "#406080"})).unwrap();
+    let mut app = EffectcraftApp::new(s);
+    app.ui.start_screen = false;
+    app.hooks.clipboard_text = Some(Box::new(|| Some("pasted".into())));
+    app
+}
+
+/// What the Edit commands would change in the project.
+fn project(app: &EffectcraftApp) -> (u64, usize, usize, usize) {
+    let s = &app.session;
+    (s.revision, s.state.clipboard.len(), s.history.undo.len(), s.history.redo.len())
+}
+
+/// Choose the native menu item that runs `command`, then deliver what it queued for the main
+/// window (kittest does not call `raw_input_hook`).
+fn menu(h: &mut Harness<'_, EffectcraftApp>, command: &str) {
+    let spec = native_menu::build(h.state());
+    let id = spec.items().into_iter().find(|i| i.command == command).unwrap().id.clone();
+    let ctx = h.ctx.clone();
+    native_menu::activate(h.state_mut(), &ctx, &spec, &id).unwrap();
+    for _ in 0..3 {
+        let mut raw = egui::RawInput::default();
+        eframe::App::raw_input_hook(h.state_mut(), &ctx, &mut raw);
+        h.input_mut().events.extend(raw.events);
+        h.step();
+        h.state_mut().mark_synthetic_applied();
+    }
+    h.run_steps(2);
+}
+
+/// Whether the menu bar shows `command`'s item enabled now, and whether the project alone would.
+fn enabled(h: &Harness<'_, EffectcraftApp>, command: &str) -> (bool, bool) {
+    let find = |menu: native_menu::NativeMenu| menu.items().into_iter().find(|i| i.command == command).unwrap().enabled;
+    (find(native_menu::build_now(h.state(), &h.ctx)), find(native_menu::build(h.state())))
+}
+
+fn center(h: &Harness<'_, EffectcraftApp>, id: &str) -> Pos2 {
+    let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}")).clone();
+    pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0)
+}
+
+fn click(h: &mut Harness<'_, EffectcraftApp>, at: Pos2, window: Option<&Host>) {
+    let send = |h: &mut Harness<'_, EffectcraftApp>, event: Event| match window {
+        Some(host) => to_window(host, event),
+        None => h.input_mut().events.push(event),
+    };
+    send(h, Event::PointerMoved(at));
+    h.step();
+    for pressed in [true, false] {
+        send(h, Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+        h.step();
+    }
+}
+
+/// Stand-in OS windows for floating panels: each runs its own pass with its own input, and
+/// asking one for the clipboard text gives it "pasted".
+#[derive(Default)]
+struct Windows {
+    window: Option<ViewportId>,
+    events: HashMap<ViewportId, Vec<Event>>,
+}
+
+type Host = Rc<RefCell<Windows>>;
+
+fn to_window(host: &Host, event: Event) {
+    let mut host = host.borrow_mut();
+    let Some(window) = host.window else { panic!("no floating panel window") };
+    host.events.entry(window).or_default().push(event);
+}
+
+fn native_windows(h: &mut Harness<'_, EffectcraftApp>) -> Host {
+    let host = Host::default();
+    let shared = host.clone();
+    egui::Context::set_immediate_viewport_renderer(move |ctx, mut viewport| {
+        let id = viewport.ids.this;
+        let size = viewport.builder.inner_size.unwrap_or(vec2(400.0, 300.0));
+        let time = ctx.input(|i| i.time);
+        let events = {
+            let mut host = shared.borrow_mut();
+            host.window = Some(id);
+            host.events.remove(&id).unwrap_or_default()
+        };
+        let viewports = [(ViewportId::ROOT, false), (id, true)]
+            .into_iter()
+            .map(|(id, focused)| (id, ViewportInfo { focused: Some(focused), native_pixels_per_point: Some(1.0), ..Default::default() }))
+            .collect();
+        let input = egui::RawInput {
+            viewport_id: id,
+            viewports,
+            screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, size)),
+            events,
+            focused: true,
+            time: Some(time),
+            ..Default::default()
+        };
+        let mut full = ctx.run_ui(input, |ui| (viewport.viewport_ui_cb)(ui));
+        full.textures_delta.clear();
+        if full.viewport_output.get(&id).is_some_and(|out| out.commands.contains(&ViewportCommand::RequestPaste)) {
+            shared.borrow_mut().events.entry(id).or_default().push(Event::Paste("pasted".into()));
+        }
+    });
+    h.ctx.set_embed_viewports(false);
+    // A main window that reports its place: not Wayland, where floating panels stay in it.
+    let screen = h.ctx.content_rect();
+    h.input_mut().viewports.entry(ViewportId::ROOT).or_default().outer_rect = Some(screen);
+    h.run_steps(3);
+    let window = host.borrow().window.expect("the floating panel opens in an OS window of its own");
+    // That window has the keyboard.
+    let input = h.input_mut();
+    input.focused = false;
+    for (id, focused) in [(ViewportId::ROOT, false), (window, true)] {
+        input.viewports.entry(id).or_default().focused = Some(focused);
+    }
+    h.run_steps(2);
+    host
+}
+
+#[test]
+fn edit_menu_keys_edit_a_text_field_in_a_panel_window() {
+    let mut app = app();
+    menus::invoke(&mut app, &egui::Context::default(), "window.panelWindow", json!({"panel": "Project", "window": true})).unwrap();
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| app);
+    h.ctx.set_os(egui::os::OperatingSystem::Mac);
+    let host = native_windows(&mut h);
+    let at = center(&h, "project.search");
+    click(&mut h, at, Some(&host));
+    to_window(&host, Event::Text("abc".into()));
+    h.run_steps(3);
+    let window = host.borrow().window.unwrap();
+    assert_eq!(h.state().ui.project_search, "abc");
+    assert!(!h.ctx.egui_wants_keyboard_input(), "the main window has no focused widget");
+    assert_eq!(native_menu::text_field_window(&h.ctx), Some(window));
+    assert_eq!(enabled(&h, "edit.paste"), (true, false), "Paste stays enabled with nothing copied in the project");
+    let before = project(h.state());
+    menu(&mut h, "edit.selectAll");
+    menu(&mut h, "edit.cut");
+    assert_eq!(h.state().ui.project_search, "", "Select All and Cut act on the field");
+    menu(&mut h, "edit.paste");
+    assert_eq!(h.state().ui.project_search, "pasted");
+    menu(&mut h, "edit.undo");
+    assert_eq!(h.state().ui.project_search, "", "Undo undoes the paste");
+    menu(&mut h, "edit.copy");
+    assert_eq!(project(h.state()), before, "the project is untouched");
+    assert_eq!(h.state().ui.project_search, "");
+}
+
+#[test]
+fn edit_menu_keys_edit_a_docked_text_field() {
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| app());
+    h.ctx.set_os(egui::os::OperatingSystem::Mac);
+    h.run_steps(3);
+    let at = center(&h, "project.search");
+    h.input_mut().events.push(Event::PointerMoved(at));
+    h.step();
+    for pressed in [true, false] {
+        h.input_mut().events.push(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+        h.step();
+    }
+    h.input_mut().events.push(Event::Text("abc".into()));
+    h.run_steps(3);
+    assert_eq!(h.state().ui.project_search, "abc");
+    assert_eq!(native_menu::text_field_window(&h.ctx), Some(ViewportId::ROOT));
+    assert_eq!(enabled(&h, "edit.paste"), (true, false), "Paste stays enabled with nothing copied in the project");
+    let before = project(h.state());
+    menu(&mut h, "edit.selectAll");
+    menu(&mut h, "edit.cut");
+    assert_eq!(h.state().ui.project_search, "", "Select All and Cut act on the field");
+    menu(&mut h, "edit.paste");
+    assert_eq!(h.state().ui.project_search, "pasted");
+    menu(&mut h, "edit.undo");
+    assert_eq!(h.state().ui.project_search, "", "Undo undoes the paste");
+    menu(&mut h, "edit.copy");
+    assert_eq!(project(h.state()), before, "the project is untouched");
+}
diff --git a/crates/ui-egui/tests/it/render_queue_snapshot.rs b/crates/ui-egui/tests/it/render_queue_snapshot.rs
index d054511af..27054119d 100644
--- a/crates/ui-egui/tests/it/render_queue_snapshot.rs
+++ b/crates/ui-egui/tests/it/render_queue_snapshot.rs
@@ -2,6 +2,7 @@
 //! adapter); run with
 //! `RQ_SNAPSHOT=/abs/out.png cargo test -p effectcraft-ui-egui --test it render_queue_snapshot:: -- --ignored`.
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_engine::project::render_queue::RenderStatus;
 use effectcraft_ui_egui::EffectcraftApp;
@@ -34,7 +35,7 @@ fn render_queue_panel_snapshot() {
     h.ctx.data_mut(|d| d.insert_temp(egui::Id::unique("rq-ui"), (ids, None::<u64>)));
     h.state_mut().show_panel(effectcraft_ui_egui::dock::PanelKind::RenderQueue);
     h.run_steps(4);
-    let img = h.render().expect("render");
+    let img = h.render_serialized().expect("render");
     let out = std::env::var("RQ_SNAPSHOT").unwrap_or_else(|_| concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/test-out/render_queue.png").into());
     if let Some(d) = std::path::Path::new(&out).parent() {
         std::fs::create_dir_all(d).unwrap();
@@ -57,7 +58,7 @@ fn templates_dialog_snapshot() {
     let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).build_eframe(|_| app.take().expect("app"));
     h.run_steps(4);
     assert!(h.state().dialog.is_some(), "the Templates dialog is open");
-    let img = h.render().expect("render");
+    let img = h.render_serialized().expect("render");
     let out = std::env::var("RQ_TEMPLATES_SNAPSHOT").unwrap_or_else(|_| concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/test-out/rq_templates.png").into());
     if let Some(d) = std::path::Path::new(&out).parent() {
         std::fs::create_dir_all(d).unwrap();
diff --git a/crates/ui-egui/tests/it/roto_model_guard.rs b/crates/ui-egui/tests/it/roto_model_guard.rs
new file mode 100644
index 000000000..a65805b55
--- /dev/null
+++ b/crates/ui-egui/tests/it/roto_model_guard.rs
@@ -0,0 +1,26 @@
+//! The Roto Brush model is process-global (`effects::roto::set_model`), and every test in this binary shares the
+//! process: a test that installs a scripted model holds this guard, so another cannot swap or clear the model
+//! mid-run, and the model is cleared again even when the test panics.
+
+use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
+
+use effectcraft_segment::MaskModel;
+
+static LOCK: Mutex<()> = Mutex::new(());
+
+pub struct InstalledModel {
+    _exclusive: MutexGuard<'static, ()>,
+}
+
+/// Install `model` for the roto effect until the returned guard drops.
+pub fn install(model: Arc<dyn MaskModel>) -> InstalledModel {
+    let guard = LOCK.lock().unwrap_or_else(PoisonError::into_inner);
+    effectcraft_engine::effects::roto::set_model(Some(model));
+    InstalledModel { _exclusive: guard }
+}
+
+impl Drop for InstalledModel {
+    fn drop(&mut self) {
+        effectcraft_engine::effects::roto::set_model(None);
+    }
+}
diff --git a/crates/ui-egui/tests/it/shared_docking_ui.rs b/crates/ui-egui/tests/it/shared_docking_ui.rs
index 29d591a1d..48e8b8283 100644
--- a/crates/ui-egui/tests/it/shared_docking_ui.rs
+++ b/crates/ui-egui/tests/it/shared_docking_ui.rs
@@ -1,92 +1,86 @@
-//! Existing EffectCraft workspaces use shared transactions without changing their saved schema.
-use craft_ui::docking::{Action, Placement, Zone};
+//! EffectCraft's workspaces in craft-ui's shared docking: transactions, the command path, pointer
+//! gestures and persistence.
+use craft_ui::docking::{Action, Node, Placement, StackEntry, Zone};
 use effectcraft_engine::Session;
 use effectcraft_ui_egui::{
     EffectcraftApp,
-    dock::{self, DockNode, Layout, PanelKind, SplitSize, StackEntry},
+    dock::{self, Layout, PanelKind, SplitSize, Workspace, WorkspaceExt as _},
 };
 use egui::{Event, Modifiers, PointerButton, Rect, pos2, vec2};
 use egui_kittest::Harness;
 use egui_kittest::kittest::{NodeT, Queryable};
 use serde_json::json;
 
-#[test]
-fn shared_move_preserves_accordion_metadata_and_unrelated_active_tabs() {
-    let mut layout = Layout {
-        root: DockNode::Split {
-            vertical: false,
-            size: SplitSize::FixedB(300.0),
-            a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project, PanelKind::Composition, PanelKind::Layer], active: 1 }),
-            b: Box::new(DockNode::Stack {
-                entries: vec![
-                    StackEntry::new(PanelKind::Preview, false, Some(73.0)),
-                    StackEntry::new(PanelKind::Properties, true, Some(211.0)),
-                    StackEntry::new(PanelKind::Align, false, None),
-                ],
-            }),
-        },
-        floating: vec![],
-    };
-    layout.apply(Action::Close { panel: PanelKind::Project }).unwrap();
-    assert!(layout.root.is_visible(PanelKind::Composition));
-    layout.apply(Action::Move { panel: PanelKind::Preview, anchor: PanelKind::Align, placement: Placement::Tab { before: None } }).unwrap();
-    let DockNode::Split { b, size, .. } = &layout.root else { panic!("split was lost") };
-    assert_eq!(*size, SplitSize::FixedB(300.0));
-    let DockNode::Stack { entries } = b.as_ref() else { panic!("stack was lost") };
-    // Upstream now makes a tab drop join the anchor's accordion frame. Its height belongs
-    // to the destination frame; the unrelated Properties frame keeps its exact metadata.
-    let joined = entries.iter().find(|entry| entry.contains(PanelKind::Preview)).unwrap();
-    assert_eq!(joined.panels, vec![PanelKind::Align, PanelKind::Preview]);
-    assert_eq!(joined.shown(), Some(PanelKind::Preview));
-    assert!(joined.open);
-    assert_eq!(joined.height, None);
-    assert_eq!(entries.iter().find(|entry| entry.contains(PanelKind::Properties)).unwrap(), &StackEntry::new(PanelKind::Properties, true, Some(211.0)));
-    let before = layout.clone();
-    assert!(layout.apply(Action::Move { panel: PanelKind::Preview, anchor: PanelKind::Audio, placement: Placement::Split(Zone::Left) }).is_err());
-    assert_eq!(layout, before);
-    assert!(layout.apply(Action::Float { panel: PanelKind::Preview, rect: [0.0, 0.0, f32::INFINITY, 200.0] }).is_err());
-    assert_eq!(layout, before);
+fn invoke(app: &mut EffectcraftApp, id: &str, params: serde_json::Value) -> Result<serde_json::Value, String> {
+    effectcraft_ui_egui::menus::invoke(app, &egui::Context::default(), id, params)
+}
+
+fn floating(app: &EffectcraftApp) -> &[dock::Floating<PanelKind>] {
+    &app.ui.dock.layout.floating
 }
 
 #[test]
-fn every_builtin_workspace_and_dynamic_identity_roundtrips() {
+fn shared_move_preserves_accordion_metadata_and_unrelated_active_tabs() {
+    let mut workspace = dock::docked(dock::hsplit(
+        SplitSize::FixedSecond(300.0),
+        dock::tabs(&[PanelKind::Project, PanelKind::Composition, PanelKind::Layer], 1),
+        dock::stack(&[(PanelKind::Preview, false, Some(73.0)), (PanelKind::Properties, true, Some(211.0)), (PanelKind::Align, false, None)]),
+    ));
+    workspace.apply(Action::Close { panel: PanelKind::Project }, dock::permissions).unwrap();
+    assert!(workspace.is_visible(PanelKind::Composition));
+    workspace
+        .apply(Action::Move { panel: PanelKind::Preview, anchor: PanelKind::Layer, placement: Placement::Tab { before: None } }, dock::permissions)
+        .unwrap();
+    let Some(Node::Split { second, size, .. }) = &workspace.layout.root else { panic!("split was lost") };
+    assert_eq!(*size, SplitSize::FixedSecond(300.0));
+    let Node::Stack { entries } = second.as_ref() else { panic!("stack was lost") };
+    // The unrelated stacked panels keep their exact state.
+    assert_eq!(
+        entries,
+        &vec![StackEntry { panel: PanelKind::Properties, open: true, height: Some(211.0) }, StackEntry { panel: PanelKind::Align, open: false, height: None }]
+    );
+    assert_eq!(workspace.group_of(PanelKind::Preview), vec![PanelKind::Composition, PanelKind::Layer, PanelKind::Preview]);
+    // Rejected moves and geometry change nothing.
+    let before = workspace.clone();
+    assert!(
+        workspace
+            .apply(Action::Move { panel: PanelKind::Preview, anchor: PanelKind::Audio, placement: Placement::Split(Zone::Left) }, dock::permissions)
+            .is_err()
+    );
+    assert!(workspace.apply(Action::Float { panel: PanelKind::Preview, rect: [0.0, 0.0, f32::INFINITY, 200.0] }, dock::permissions).is_err());
+    assert_eq!(workspace, before);
+}
+
+#[test]
+fn every_builtin_workspace_validates_and_roundtrips_with_dynamic_identities() {
     for name in dock::WORKSPACES {
-        let mut layout = Layout { root: dock::workspace(name), floating: dock::workspace_floating(name) };
-        let before = serde_json::to_value(&layout).unwrap();
-        // A structural no-op still crosses both adapters and shared validation. The complete
-        // persisted shape must remain byte-equivalent, including accordion state and heights.
-        let action = match &layout.root {
-            DockNode::Split { size, .. } => Action::ResizeSplit {
-                path: vec![],
-                size: match *size {
-                    SplitSize::Ratio(v) => craft_ui::layout::SplitSize::Ratio(v),
-                    SplitSize::FixedA(v) => craft_ui::layout::SplitSize::FixedFirst(v),
-                    SplitSize::FixedB(v) => craft_ui::layout::SplitSize::FixedSecond(v),
-                },
-            },
-            DockNode::Tabs { panels, .. } => Action::Move { panel: panels[0], anchor: panels[1], placement: Placement::Tab { before: Some(panels[0]) } },
-            DockNode::Stack { entries } => Action::SetStackOpen { panel: entries[0].shown().unwrap(), open: entries[0].open },
-        };
-        layout.apply(action).unwrap();
-        assert_eq!(before, serde_json::to_value(&layout).unwrap());
-        let back: Layout = serde_json::from_value(before).unwrap();
-        assert_eq!(layout, back);
+        let workspace = Workspace::new(dock::workspace(name));
+        workspace.validate().unwrap_or_else(|e| panic!("{name}: {e}"));
+        assert!(workspace.is_open(PanelKind::Composition), "{name} lacks the Composition panel");
+        let text = serde_json::to_string(&workspace).unwrap();
+        assert_eq!(serde_json::from_str::<Workspace>(&text).unwrap(), workspace, "{name}");
     }
-    let mut layout = Layout {
-        root: DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Viewer(42), PanelKind::ScriptPanel(77)], active: 1 },
-        floating: vec![],
-    };
-    layout.apply(Action::Float { panel: PanelKind::ScriptPanel(77), rect: [20.0, 30.0, 400.0, 300.0] }).unwrap();
-    layout.apply(Action::Move { panel: PanelKind::ScriptPanel(77), anchor: PanelKind::Viewer(42), placement: Placement::Tab { before: None } }).unwrap();
-    assert!(layout.floating.is_empty());
-    assert!(layout.contains(PanelKind::Viewer(42)));
-    assert!(layout.root.is_visible(PanelKind::ScriptPanel(77)));
+    assert_eq!(dock::workspace("Undocked Panels").floating.len(), 4);
+    // Built again, a built-in layout has the same windows (ids included).
+    let ids = |layout: &Layout| layout.floating.iter().map(|w| w.id).collect::<Vec<_>>();
+    assert_eq!(ids(&dock::workspace("Undocked Panels")), ids(&dock::workspace("Undocked Panels")));
+    let mut workspace = dock::docked(dock::tabs(&[PanelKind::Composition, PanelKind::Viewer(42), PanelKind::ScriptPanel(77)], 1));
+    workspace.apply(Action::Float { panel: PanelKind::ScriptPanel(77), rect: [20.0, 30.0, 400.0, 300.0] }, dock::permissions).unwrap();
+    let text = serde_json::to_string(&workspace).unwrap();
+    assert!(text.contains("\"ScriptPanel\":77") && text.contains("\"Viewer\":42"), "{text}");
+    assert_eq!(serde_json::from_str::<Workspace>(&text).unwrap(), workspace);
+    workspace
+        .apply(Action::Move { panel: PanelKind::ScriptPanel(77), anchor: PanelKind::Viewer(42), placement: Placement::Tab { before: None } }, dock::permissions)
+        .unwrap();
+    assert!(workspace.layout.floating.is_empty());
+    assert!(workspace.is_visible(PanelKind::ScriptPanel(77)));
 }
 
 fn rect(h: &Harness<'_, EffectcraftApp>, id: &str) -> Rect {
     let element = h.state().auto.find(id).unwrap_or_else(|| panic!("missing {id}"));
     Rect::from_min_size(pos2(element.rect[0], element.rect[1]), vec2(element.rect[2], element.rect[3]))
 }
+
 fn drag(h: &mut Harness<'_, EffectcraftApp>, from: egui::Pos2, to: egui::Pos2, modifiers: Modifiers) {
     h.event(Event::ModifiersChanged(modifiers));
     h.event(Event::PointerMoved(from));
@@ -108,126 +102,52 @@ fn pointer_drop_merges_floats_and_redocks_without_project_changes() {
     let mut session = Session::default();
     session.execute("comp.new", json!({"name": "Docking composition", "width": 320, "height": 180, "duration": 4})).unwrap();
     session.execute("layer.newSolid", json!({"name": "Teal plate", "width": 320, "height": 180, "color": "#245b68"})).unwrap();
-    session.execute("layer.newSolid", json!({"name": "Coral tile", "width": 110, "height": 70, "color": "#ee7859"})).unwrap();
     let mut app = EffectcraftApp::new(session);
     app.ui.start_screen = false;
-    app.ui.dock = DockNode::Split {
-        vertical: false,
-        size: SplitSize::FixedA(400.0),
-        a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project, PanelKind::Info, PanelKind::Audio], active: 1 }),
-        b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Layer], active: 0 }),
-    };
-    app.ui.dock = DockNode::Split {
-        vertical: true,
-        size: SplitSize::Ratio(0.62),
-        a: Box::new(app.ui.dock),
-        b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Timeline], active: 0 }),
-    };
-    let snapshots = std::env::var_os("CRAFT_UI_DOCKING_SNAPSHOT_DIR").map(std::path::PathBuf::from);
-    let mut builder = Harness::builder().with_size(vec2(1200.0, 760.0));
-    if snapshots.is_some() {
-        builder = builder.wgpu();
-    }
-    let mut h = builder.build_eframe(move |_| app);
+    app.ui.dock = dock::docked(dock::vsplit(
+        SplitSize::Ratio(0.62),
+        dock::hsplit(
+            SplitSize::FixedFirst(400.0),
+            dock::tabs(&[PanelKind::Project, PanelKind::Info, PanelKind::Audio], 1),
+            dock::tabs(&[PanelKind::Composition, PanelKind::Layer], 0),
+        ),
+        dock::tabs(&[PanelKind::Timeline], 0),
+    ));
+    let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app);
     h.run_steps(4);
-    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
-    while h.state().frames.urgent_pending() && std::time::Instant::now() < deadline {
-        std::thread::sleep(std::time::Duration::from_millis(1));
-    }
-    assert!(!h.state().frames.urgent_pending());
-    h.run_steps(3);
     let project = h.state().session.project.clone();
     let times = h.state().session.state.times.clone();
-    let mut action_log = vec![action_state(&h, "start")];
+    // A tab dropped on another group's tab strip joins it.
     let from = rect(&h, "panel.tab.Info").center();
-    let to = rect(&h, "panel.Composition").center();
+    let to = rect(&h, "panel.tab.Layer").center() + vec2(20.0, 0.0);
     drag(&mut h, from, to, Modifiers::NONE);
     assert!(h.state().ui.dock.is_visible(PanelKind::Info));
-    assert!(same_group(&h.state().ui.dock, PanelKind::Info, PanelKind::Composition));
-    action_log.push(action_state(&h, "merged"));
-    let from = rect(&h, "panel.tab.Info").center();
-    let before = rect(&h, "panel.tab.Composition");
-    drag(&mut h, from, pos2(before.left() + 2.0, before.center().y), Modifiers::NONE);
-    assert_eq!(tabs_containing(&h.state().ui.dock, PanelKind::Info).first(), Some(&PanelKind::Info));
-    action_log.push(action_state(&h, "reordered"));
-
+    assert!(h.state().ui.dock.group_of(PanelKind::Info).contains(&PanelKind::Composition));
+    // Cmd/Ctrl at the release floats it.
     let from = rect(&h, "panel.tab.Info").center();
     drag(&mut h, from, pos2(700.0, 400.0), Modifiers::COMMAND);
-    assert_eq!(h.state().ui.floating.len(), 1);
-    // The grip is a resize handle: the migration's role mapping (`ResizeHandle → Splitter`) applies
-    // to floating panels too, and the widget reports it (`dock_ui.rs`).
-    assert_eq!(h.get_by_label("Resize floating panel").accesskit_node().role(), egui::accesskit::Role::Splitter);
-    action_log.push(action_state(&h, "floated"));
-    let original = h.state().ui.floating[0].rect;
+    assert_eq!(floating(h.state()).len(), 1);
+    assert!(h.state().ui.dock.is_floating(PanelKind::Info));
+    let grips: Vec<_> = h.query_all_by_label("Resize panel window").collect();
+    assert!(!grips.is_empty() && grips.iter().all(|grip| grip.accesskit_node().role() == egui::accesskit::Role::Button));
+    // Its corner resizes it and its title bar moves it.
+    let original = floating(h.state())[0].rect;
     let grip = rect(&h, "panel.float.0.resize").center();
-    drag(&mut h, grip, grip + vec2(36.0, 24.0), Modifiers::NONE);
-    assert!(h.state().ui.floating[0].rect[2] > original[2] + 25.0);
-    assert!(h.state().ui.floating[0].rect[3] > original[3] + 15.0);
-    action_log.push(action_state(&h, "resized"));
-    let grip_id = egui::Id::unique(("floating-panel", PanelKind::Info.id())).with("resize");
-    assert_eq!(h.ctx.memory(|memory| memory.focused()), Some(grip_id));
-    let before_keys = h.state().ui.floating[0].rect;
-    for key in [egui::Key::ArrowRight, egui::Key::ArrowDown] {
-        for pressed in [true, false] {
-            h.event(Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE });
-            h.step();
-        }
-    }
-    assert_eq!(h.state().ui.floating[0].rect[2], before_keys[2] + 8.0);
-    assert_eq!(h.state().ui.floating[0].rect[3], before_keys[3] + 8.0);
-    h.event(Event::Key { key: egui::Key::Tab, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
-    h.step();
-    h.event(Event::Key { key: egui::Key::Tab, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE });
-    h.run_steps(3);
-    assert_ne!(h.ctx.memory(|memory| memory.focused()), Some(grip_id));
-    action_log.push(action_state(&h, "keyboard-resized"));
-    let resized = h.state().ui.floating[0].rect;
-    let header = rect(&h, "panel.float.0.move");
-    let from = pos2(header.right() - 24.0, header.center().y);
-    drag(&mut h, from, from - vec2(24.0, 18.0), Modifiers::NONE);
-    assert!(h.state().ui.floating[0].rect[0] < resized[0] - 15.0);
-    assert!(h.state().ui.floating[0].rect[1] < resized[1] - 10.0);
-    action_log.push(action_state(&h, "moved"));
-
-    if let Some(directory) = &snapshots {
-        std::fs::create_dir_all(directory).unwrap();
-        h.render().unwrap().save(directory.join("effectcraft-floating.png")).unwrap();
-    }
+    drag(&mut h, grip, grip - vec2(36.0, 24.0), Modifiers::NONE);
+    let resized = floating(h.state())[0].rect;
+    assert!(resized[2] < original[2] - 25.0 && resized[3] < original[3] - 15.0, "{original:?} -> {resized:?}");
+    let bar = rect(&h, "panel.float.0.move");
+    drag(&mut h, bar.center(), bar.center() - vec2(24.0, 18.0), Modifiers::NONE);
+    let moved = floating(h.state())[0].rect;
+    assert!(moved[0] < resized[0] - 15.0 && moved[1] < resized[1] - 10.0, "{resized:?} -> {moved:?}");
+    // Its tab dropped on a docked tab strip docks it again.
     let from = rect(&h, "panel.tab.Info").center();
-    let to = rect(&h, "panel.Audio").center();
+    let to = rect(&h, "panel.tab.Project").center() + vec2(20.0, 0.0);
     drag(&mut h, from, to, Modifiers::NONE);
-    assert!(h.state().ui.floating.is_empty());
-    action_log.push(action_state(&h, "redocked"));
+    assert!(floating(h.state()).is_empty());
+    assert!(h.state().ui.dock.group_of(PanelKind::Info).contains(&PanelKind::Project));
     assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));
     assert_eq!(times, h.state().session.state.times);
-    assert!(h.state().auto.elements.iter().any(|element| element.id.starts_with("timeline.layer.")));
-    h.state_mut().session.execute("view.exposure", json!({"stops": 2.0})).unwrap();
-    h.run_steps(3);
-    let pos = rect(&h, "viewer.resetExposure").center();
-    h.event(Event::PointerMoved(pos));
-    h.step();
-    for pressed in [true, false] {
-        h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
-        h.step();
-    }
-    h.run_steps(3);
-    assert_eq!(h.state().session.state.viewer.exposure, 0.0);
-    action_log.push(action_state(&h, "viewer-reset-exposure"));
-    if let Some(directory) = &snapshots {
-        std::fs::write(directory.join("effectcraft-actions.json"), serde_json::to_vec_pretty(&action_log).unwrap()).unwrap();
-    }
-    if let Some(directory) = &snapshots {
-        h.render().unwrap().save(directory.join("effectcraft-redocked.png")).unwrap();
-    }
-    assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));
-}
-
-fn same_group(root: &DockNode, first: PanelKind, second: PanelKind) -> bool {
-    match root {
-        DockNode::Tabs { panels, .. } => panels.contains(&first) && panels.contains(&second),
-        DockNode::Split { a, b, .. } => same_group(a, first, second) || same_group(b, first, second),
-        DockNode::Stack { .. } => false,
-    }
 }
 
 #[test]
@@ -236,186 +156,200 @@ fn current_and_named_floating_layouts_survive_restart() {
     use std::sync::Arc;
     let store = Arc::new(MemoryConfig::default());
     let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });
-    assert!(app.edit_layout(|layout| layout.apply(Action::Float { panel: PanelKind::Project, rect: [45.0, 65.0, 430.0, 310.0] }).is_ok()));
-    let ctx = egui::Context::default();
-    effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.saveWorkspaceAs", json!({"name": "Shared float"})).unwrap();
-    let saved = app.ui.floating.clone();
-    assert!(app.edit_layout(|layout| layout.apply(Action::MoveFloating { panel: PanelKind::Project, rect: [75.0, 95.0, 480.0, 360.0] }).is_ok()));
-    let current = app.ui.floating.clone();
+    app.apply_dock(Action::Float { panel: PanelKind::Project, rect: [45.0, 65.0, 430.0, 310.0] }).unwrap();
+    invoke(&mut app, "window.saveWorkspaceAs", json!({"name": "Shared float"})).unwrap();
+    let saved = app.ui.dock.clone();
+    app.apply_dock(Action::MoveFloating { panel: PanelKind::Project, rect: [75.0, 95.0, 480.0, 360.0] }).unwrap();
+    let current = app.ui.dock.clone();
     eframe::App::on_exit(&mut app);
     let mut restarted = EffectcraftApp::new(Session { config: Some(store), ..Default::default() });
-    assert_eq!(restarted.ui.floating, current);
+    assert_eq!(restarted.ui.dock, current);
     restarted.set_workspace("Default");
     restarted.set_workspace("Shared float");
-    assert_eq!(restarted.ui.floating, saved);
-}
-
-fn tabs_containing(root: &DockNode, panel: PanelKind) -> Vec<PanelKind> {
-    match root {
-        DockNode::Tabs { panels, .. } if panels.contains(&panel) => panels.clone(),
-        DockNode::Split { a, b, .. } => {
-            let first = tabs_containing(a, panel);
-            if first.is_empty() { tabs_containing(b, panel) } else { first }
-        }
-        _ => vec![],
-    }
+    assert_eq!(restarted.ui.dock, saved);
 }
 
 #[test]
-fn float_command_rejects_malformed_rectangles_atomically() {
+fn float_command_rejects_malformed_rectangles_and_keeps_one_docked_panel() {
     let mut app = EffectcraftApp::new(Session::default());
     let before = app.ui.dock.clone();
-    let ctx = egui::Context::default();
     for rect in [json!([1, 2, 300]), json!([1, 2, 300, 200, 7]), json!([1, 2, 1e100, 200]), json!("rectangle")] {
-        assert!(effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.floatPanel", json!({"panel": "Project", "rect": rect})).is_err());
+        assert!(invoke(&mut app, "window.floatPanel", json!({"panel": "Project", "rect": rect})).is_err());
         assert_eq!(app.ui.dock, before);
-        assert!(app.ui.floating.is_empty());
     }
-    app.ui.dock = DockNode::Tabs { panels: vec![PanelKind::Project], active: 0 };
-    assert!(!app.edit_layout(|layout| layout.apply(Action::Float { panel: PanelKind::Project, rect: [1.0, 2.0, 300.0, 200.0] }).is_ok()));
+    // The last docked panel stays docked, whether it moves alone, with its group or by command.
+    app.ui.dock = dock::docked(dock::tabs(&[PanelKind::Project], 0));
+    let before = app.ui.dock.clone();
+    assert!(app.apply_dock(Action::Float { panel: PanelKind::Project, rect: [1.0, 2.0, 300.0, 200.0] }).is_err());
+    assert!(invoke(&mut app, "window.panel.float", json!({"panel": "Project", "group": true})).is_err());
+    assert_eq!(app.ui.dock, before);
+    // Closing it is allowed.
+    invoke(&mut app, "window.closePanel", json!({"panel": "Project"})).unwrap();
+    assert!(app.ui.dock.layout.root.is_none());
 }
 
-/// A floating panel dragged past the window's bottom edge is drawn where its rect says: it was
-/// shifted back into the window while its rect kept moving, and its strip then clashed with the
-/// floating area's own widget ("Double use of widget ID").
+/// A floating panel dragged towards the window's bottom edge moves there, and its title bar
+/// still moves it from there.
 #[test]
-fn floating_panel_dragged_past_the_window_edge_is_drawn_at_its_rect() {
-    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(Session::default()));
+fn floating_panel_dragged_towards_the_window_edge_keeps_moving() {
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| {
+        let mut app = EffectcraftApp::new(Session::default());
+        app.ui.start_screen = false;
+        app
+    });
     h.run_steps(3);
     let ctx = h.ctx.clone();
     effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "window.floatPanel", json!({"panel": "Preview", "rect": [600.0, 400.0, 360.0, 300.0]})).unwrap();
     h.run_steps(3);
-    let strip = rect(&h, "panel.float.0.move");
-    let from = pos2(strip.right() - 24.0, strip.center().y);
-    drag(&mut h, from, from + vec2(40.0, 420.0), Modifiers::NONE);
-    let moved = h.state().ui.floating[0].rect;
-    assert!(moved[1] + moved[3] > 1000.0, "the panel hangs past the bottom edge: {moved:?}");
-    let strip = rect(&h, "panel.float.0.move");
-    assert_eq!([strip.min.x, strip.min.y], [moved[0], moved[1]]);
-    // The strip still moves it from there.
-    let from = pos2(strip.right() - 24.0, strip.center().y);
-    drag(&mut h, from, from - vec2(30.0, 200.0), Modifiers::NONE);
-    assert_eq!(h.state().ui.floating[0].rect[1], moved[1] - 200.0);
-}
-
-fn action_state(h: &Harness<'_, EffectcraftApp>, action: &str) -> serde_json::Value {
-    json!({"action": action, "dock": h.state().ui.dock, "floating": h.state().ui.floating, "focused": h.state().ui.focused})
+    let bar = rect(&h, "panel.float.0.move");
+    drag(&mut h, bar.center(), bar.center() + vec2(40.0, 420.0), Modifiers::NONE);
+    let moved = floating(h.state())[0].rect;
+    assert!(moved[1] > 550.0, "the panel moved down: {moved:?}");
+    let bar = rect(&h, "panel.float.0.move");
+    drag(&mut h, bar.center(), bar.center() - vec2(30.0, 200.0), Modifiers::NONE);
+    let back = floating(h.state())[0].rect;
+    assert!(back[1] < moved[1] - 150.0, "{moved:?} -> {back:?}");
 }
 
 #[test]
 fn catalog_docking_action_supports_resize_reorder_and_floating_geometry() {
     let mut app = EffectcraftApp::new(Session::default());
-    app.ui.dock = DockNode::Split {
-        vertical: false,
-        size: SplitSize::FixedA(300.0),
-        a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project, PanelKind::Info], active: 1 }),
-        b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Composition], active: 0 }),
-    };
-    let ctx = egui::Context::default();
+    app.ui.dock = dock::docked(dock::hsplit(
+        SplitSize::FixedFirst(300.0),
+        dock::tabs(&[PanelKind::Project, PanelKind::Info], 1),
+        dock::tabs(&[PanelKind::Composition], 0),
+    ));
     for action in [
-        Action::ResizeSplit { path: vec![], size: craft_ui::layout::SplitSize::FixedFirst(360.0) },
+        Action::ResizeSplit { path: vec![], size: SplitSize::FixedFirst(360.0) },
         Action::Move { panel: PanelKind::Info, anchor: PanelKind::Project, placement: Placement::Tab { before: Some(PanelKind::Project) } },
         Action::Float { panel: PanelKind::Info, rect: [20.0, 40.0, 300.0, 200.0] },
         Action::MoveFloating { panel: PanelKind::Info, rect: [45.0, 65.0, 330.0, 240.0] },
     ] {
-        effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.dockAction", json!({"action": action})).unwrap();
+        invoke(&mut app, "window.dockAction", json!({"action": action})).unwrap();
     }
-    assert_eq!(app.ui.floating[0].rect, [45.0, 65.0, 330.0, 240.0]);
-    let DockNode::Split { size, .. } = &app.ui.dock else { panic!("split lost") };
-    assert_eq!(*size, SplitSize::FixedA(360.0));
-    let before = json!({"dock": app.ui.dock, "floating": app.ui.floating});
-    assert!(
-        effectcraft_ui_egui::menus::invoke(
-            &mut app,
-            &ctx,
-            "window.dockAction",
-            json!({"action": {
-                "ResizeSplit": {"path": [true, true], "size": {"Ratio": 0.5}}
-            }})
-        )
-        .is_err()
-    );
-    assert_eq!(json!({"dock": app.ui.dock, "floating": app.ui.floating}), before);
+    assert_eq!(floating(&app)[0].rect, [45.0, 65.0, 330.0, 240.0]);
+    let Some(Node::Split { size, .. }) = &app.ui.dock.layout.root else { panic!("split lost") };
+    assert_eq!(*size, SplitSize::FixedFirst(360.0));
+    let before = app.ui.dock.clone();
+    assert!(invoke(&mut app, "window.dockAction", json!({"action": {"ResizeSplit": {"path": [true, true], "size": {"Ratio": 0.5}}}})).is_err());
+    assert!(invoke(&mut app, "window.dockAction", json!({"action": {"Open": {"panel": "Align", "anchor": null}}})).is_err());
+    assert_eq!(app.ui.dock, before);
 }
 
 #[test]
-fn catalog_close_keeps_dynamic_panel_identity() {
+fn ui_dock_and_window_panel_commands_parse_craft_ui_commands() {
     let mut app = EffectcraftApp::new(Session::default());
-    app.ui.dock = DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Viewer(42), PanelKind::ScriptPanel(77)], active: 1 };
-    let ctx = egui::Context::default();
-    for panel in [PanelKind::Viewer(42), PanelKind::ScriptPanel(77)] {
-        effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.dockAction", json!({"action": Action::Close { panel }})).unwrap();
-        assert!(!app.ui.dock.contains(panel));
+    app.ui.dock = dock::docked(dock::hsplit(
+        SplitSize::FixedFirst(300.0),
+        dock::tabs(&[PanelKind::Project, PanelKind::Info], 0),
+        dock::tabs(&[PanelKind::Composition, PanelKind::Layer], 0),
+    ));
+    // `ui.dock` operations and actions return the workspace.
+    let reply = invoke(&mut app, "ui.dock", json!({"operation": "move", "panel": "Info", "target": "Composition", "zone": "center"})).unwrap();
+    assert!(reply["docking"]["layout"].is_object(), "{reply}");
+    assert!(app.ui.dock.group_of(PanelKind::Info).contains(&PanelKind::Composition));
+    invoke(&mut app, "ui.dock", json!({"action": {"Activate": {"panel": "Layer"}}})).unwrap();
+    assert!(app.ui.dock.is_visible(PanelKind::Layer));
+    invoke(&mut app, "ui.dock", json!({"operation": "float", "panel": "Info", "rect": [100, 100, 300, 200]})).unwrap();
+    assert_eq!(floating(&app)[0].rect, [100.0, 100.0, 300.0, 200.0]);
+    // `window.panel.*` takes EffectCraft's panel names too.
+    invoke(&mut app, "window.panel.dock", json!({"panel": "Info", "anchor": "Project", "zone": "right"})).unwrap();
+    assert!(floating(&app).is_empty() && app.ui.dock.is_docked(PanelKind::Info));
+    invoke(&mut app, "window.panel.close", json!({"panel": "Info"})).unwrap();
+    assert!(!app.ui.dock.is_open(PanelKind::Info));
+    // A closed panel reopens where it was.
+    invoke(&mut app, "window.panel.activate", json!({"panel": "Info"})).unwrap();
+    assert!(app.ui.dock.is_docked(PanelKind::Info));
+    // The per-panel ids still open a panel.
+    invoke(&mut app, "window.panel.Align", json!({})).unwrap();
+    assert!(app.ui.dock.is_open(PanelKind::Align));
+    // Bad commands change nothing; Reset returns to the workspace's layout.
+    let before = app.ui.dock.clone();
+    for (id, params) in [
+        ("ui.dock", json!({"operation": "move", "panel": "Info", "target": "Nope"})),
+        ("ui.dock", json!({"operation": "teleport", "panel": "Info"})),
+        ("window.panel.move", json!({"panel": "Info"})),
+        ("window.panel.dock", json!({"panel": "Nope", "anchor": "Project"})),
+    ] {
+        assert!(invoke(&mut app, id, params.clone()).is_err(), "{id} {params}");
+        assert_eq!(app.ui.dock, before);
     }
-    assert!(app.ui.dock.contains(PanelKind::Composition));
+    invoke(&mut app, "ui.dock.reset", json!({})).unwrap();
+    assert_eq!(app.ui.dock, Workspace::new(dock::workspace("Default")));
 }
 
 #[test]
-fn accordion_resize_routes_pointer_and_keyboard_without_changing_closed_entries() {
+fn raw_open_actions_are_rejected_through_every_docking_route() {
+    let mut app = EffectcraftApp::new(Session::default());
+    let before = app.ui.dock.clone();
+    for panel in [PanelKind::ScriptPanel(77), PanelKind::Viewer(42)] {
+        for action in [
+            Action::Open { panel, anchor: Some(PanelKind::Project) },
+            Action::OpenAt { panel, anchor: PanelKind::Project, placement: Placement::Tab { before: None } },
+        ] {
+            for id in ["ui.dock", "window.panel.layout", "window.dockAction"] {
+                let error = invoke(&mut app, id, json!({"action": action})).unwrap_err();
+                assert!(error.contains("panel open commands"), "{id}: {error}");
+                assert_eq!(app.ui.dock, before, "{id} must leave the layout unchanged");
+                assert!(app.session.script_ui.window(77).is_none());
+                assert!(!app.ui.viewers.contains_key(&42));
+            }
+        }
+    }
+    // The normal operation still opens a panel and the raw form still activates one.
+    invoke(&mut app, "ui.dock", json!({"operation": "open", "panel": "Align"})).unwrap();
+    assert!(app.ui.dock.is_open(PanelKind::Align));
+    invoke(&mut app, "window.panel.layout", json!({"action": {"Activate": {"panel": "Project"}}})).unwrap();
+    assert!(app.ui.dock.is_visible(PanelKind::Project));
+}
+
+#[test]
+fn catalog_close_keeps_dynamic_panel_identity_and_releases_viewers() {
+    let mut app = EffectcraftApp::new(Session::default());
+    app.ui.dock = dock::docked(dock::tabs(&[PanelKind::Composition, PanelKind::Viewer(42), PanelKind::ScriptPanel(77)], 1));
+    app.ui.viewers.insert(42, Some(7));
+    app.ui.maximized = Some(PanelKind::Viewer(42));
+    for panel in [PanelKind::Viewer(42), PanelKind::ScriptPanel(77)] {
+        invoke(&mut app, "window.dockAction", json!({"action": Action::Close { panel }})).unwrap();
+        assert!(!app.ui.dock.is_open(panel));
+        assert!(app.ui.dock.hidden.iter().any(|(p, _)| *p == panel), "{panel:?} keeps its place");
+    }
+    assert!(app.ui.dock.is_docked(PanelKind::Composition));
+    assert_eq!(app.ui.maximized, None);
+    assert!(!app.ui.viewers.get(&42).is_some_and(Option::is_some), "the closed viewer forgets its comp");
+}
+
+#[test]
+fn stacked_panels_resize_by_pointer_without_changing_closed_entries() {
     let mut session = Session::default();
     session.execute("comp.new", json!({"width": 160, "height": 90, "duration": 1})).unwrap();
     let mut app = EffectcraftApp::new(session);
     app.ui.start_screen = false;
     let mut h = Harness::builder().with_size(vec2(1000.0, 720.0)).build_eframe(move |_| app);
     h.run_steps(4);
-    h.state_mut().ui.dock = DockNode::Stack {
-        entries: vec![
-            StackEntry::new(PanelKind::Preview, true, Some(100.0)),
-            StackEntry::new(PanelKind::Properties, true, None),
-            StackEntry::new(PanelKind::Align, false, Some(77.0)),
-        ],
-    };
+    h.state_mut().ui.dock =
+        dock::docked(dock::stack(&[(PanelKind::Preview, true, Some(100.0)), (PanelKind::Properties, true, None), (PanelKind::Align, false, Some(77.0))]));
     h.run_steps(3);
     let project = h.state().session.project.clone();
-    let id = egui::Id::unique(("dock-gutter", "s0".to_string()));
-    h.ctx.memory_mut(|memory| memory.request_focus(id));
-    h.run_steps(2);
-    for pressed in [true, false] {
-        h.event(Event::Key { key: egui::Key::ArrowDown, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE });
-        h.step();
-    }
-    let DockNode::Stack { entries } = &h.state().ui.dock else { panic!("stack lost") };
-    assert_eq!(entries[0].height, Some(108.0));
+    let before = rect(&h, "panel.Preview").height();
     let from = rect(&h, "dock.gutter.s0").center();
     drag(&mut h, from, from + vec2(0.0, 16.0), Modifiers::NONE);
-    let DockNode::Stack { entries } = &h.state().ui.dock else { panic!("stack lost") };
-    assert_eq!(entries[0].height, Some(124.0));
-    assert_eq!(entries[1].height, None);
-    assert_eq!(entries[2], StackEntry::new(PanelKind::Align, false, Some(77.0)));
+    let after = rect(&h, "panel.Preview").height();
+    assert!((after - before - 16.0).abs() < 2.0, "{before} -> {after}");
+    let Some(Node::Stack { entries }) = &h.state().ui.dock.layout.root else { panic!("stack lost") };
+    assert!(entries[0].height.unwrap_or_default() > 100.0, "{entries:?}");
+    assert_eq!(entries[2], StackEntry { panel: PanelKind::Align, open: false, height: Some(77.0) });
     assert!(std::sync::Arc::ptr_eq(&project, &h.state().session.project));
 }
 
-#[test]
-fn legacy_close_repairs_selection_but_transactions_remain_strict() {
-    use effectcraft_ui_egui::dock::Floating;
-    let mut root = DockNode::Tabs { panels: vec![PanelKind::Properties, PanelKind::Align, PanelKind::EffectsPresets], active: usize::MAX };
-    root.close(PanelKind::History);
-    assert!(root.is_visible(PanelKind::EffectsPresets));
-    let mut layout = Layout {
-        root: DockNode::Tabs { panels: vec![PanelKind::Composition], active: 0 },
-        floating: vec![Floating {
-            panels: vec![PanelKind::Properties, PanelKind::Align, PanelKind::EffectsPresets],
-            active: usize::MAX,
-            rect: [0.0, 0.0, 300.0, 200.0],
-        }],
-    };
-    let before = layout.clone();
-    assert!(layout.apply(Action::Close { panel: PanelKind::Properties }).is_err());
-    assert_eq!(layout, before);
-    assert!(layout.unfloat(PanelKind::Properties));
-    assert_eq!(layout.floating[0].panels.get(layout.floating[0].active), Some(&PanelKind::EffectsPresets));
-    layout.floating[0].rect = [0.0; 4];
-    let before = layout.clone();
-    assert!(!layout.unfloat(PanelKind::Align));
-    assert_eq!(layout, before);
-}
-
 #[test]
 fn failed_close_preserves_viewer_lifecycle_and_maximize_state() {
     let mut app = EffectcraftApp::new(Session::default());
-    app.ui.dock = DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Viewer(42)], active: usize::MAX };
+    // A locked workspace refuses the close.
+    app.ui.dock = dock::docked(dock::tabs(&[PanelKind::Composition, PanelKind::Viewer(42)], 1));
+    app.ui.dock.locked = true;
     app.ui.maximized = Some(PanelKind::Viewer(42));
-    app.ui.viewers.insert(42, None);
+    app.ui.viewers.insert(42, Some(3));
     app.ui.active_viewer = 42;
     app.ui.locked_tabs.insert(PanelKind::Viewer(42).id());
     let before = app.ui.clone();
@@ -426,3 +360,21 @@ fn failed_close_preserves_viewer_lifecycle_and_maximize_state() {
     assert_eq!(app.ui.active_viewer, before.active_viewer);
     assert_eq!(app.ui.locked_tabs, before.locked_tabs);
 }
+
+/// A panel never laid out opens at EffectCraft's default place for it (History beside the
+/// Project panel, Render Queue with the Timeline), not where craft-ui's fallback puts it; a panel
+/// the user closed comes back where it was.
+#[test]
+fn never_placed_panels_open_at_their_default_place() {
+    let mut app = EffectcraftApp::new(Session::default());
+    assert!(!app.ui.dock.is_open(PanelKind::History));
+    invoke(&mut app, "window.panel", json!({"panel": "History"})).unwrap();
+    assert!(app.ui.dock.group_of(PanelKind::History).contains(&PanelKind::Project), "{:?}", app.ui.dock.group_of(PanelKind::History));
+    invoke(&mut app, "window.panel.activate", json!({"panel": "Tracker"})).unwrap();
+    assert!(app.ui.dock.group_of(PanelKind::Tracker).contains(&PanelKind::EffectsPresets) || app.ui.dock.is_open(PanelKind::Tracker));
+    // Closed by the user, it reopens at its recorded place.
+    invoke(&mut app, "window.dockPanel", json!({"panel": "History", "anchor": "Timeline"})).unwrap();
+    invoke(&mut app, "window.closePanel", json!({"panel": "History"})).unwrap();
+    invoke(&mut app, "window.panel", json!({"panel": "History"})).unwrap();
+    assert!(app.ui.dock.group_of(PanelKind::History).contains(&PanelKind::Timeline));
+}
diff --git a/crates/ui-egui/tests/it/ui_3d.rs b/crates/ui-egui/tests/it/ui_3d.rs
index a654f745c..0f7a10b7e 100644
--- a/crates/ui-egui/tests/it/ui_3d.rs
+++ b/crates/ui-egui/tests/it/ui_3d.rs
@@ -2,6 +2,7 @@
 //! with wgpu and writes PNGs when `EC_SNAPSHOT_DIR` is set (`cargo test -p effectcraft-ui-egui
 //! --test it ui_3d:: -- --ignored`); the other test only runs the UI logic.
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_engine::render::three_d::View3D;
 use effectcraft_ui_egui::EffectcraftApp;
@@ -109,6 +110,7 @@ fn camera_and_light_dialogs_create_layers() {
 #[test]
 #[ignore = "renders with wgpu; run with --ignored (set EC_SNAPSHOT_DIR to keep PNGs)"]
 fn snapshot() {
+    let _device = crate::gpu_test::lock();
     let dir = std::env::var("EC_SNAPSHOT_DIR").ok();
     let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).with_pixels_per_point(1.0).wgpu().build_eframe(|_| app());
     let shots: [(&str, Option<&str>); 4] =
@@ -118,7 +120,7 @@ fn snapshot() {
             h.state_mut().session.execute(c, json!({})).unwrap();
         }
         settle(&mut h);
-        let img = h.render().expect("render");
+        let img = h.render_serialized().expect("render");
         if let Some(d) = &dir {
             img.save(format!("{d}/ui3d_{name}.png")).unwrap();
         }
@@ -126,14 +128,14 @@ fn snapshot() {
     let ctx = h.ctx.clone();
     effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "layer.newCamera", json!({})).unwrap();
     h.run_steps(3);
-    let img = h.render().expect("render");
+    let img = h.render_serialized().expect("render");
     if let Some(d) = &dir {
         img.save(format!("{d}/ui3d_camera_dialog.png")).unwrap();
     }
     h.state_mut().dialog = None;
     effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "layer.newLight", json!({})).unwrap();
     h.run_steps(3);
-    let img = h.render().expect("render");
+    let img = h.render_serialized().expect("render");
     if let Some(d) = &dir {
         img.save(format!("{d}/ui3d_light_dialog.png")).unwrap();
     }
@@ -143,7 +145,7 @@ fn snapshot() {
     h.state_mut().session.execute("layer.select", json!({"layers": ["Card Blue"]})).unwrap();
     effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "timeline.reveal.rotation", json!({})).unwrap();
     settle(&mut h);
-    let img = h.render().expect("render");
+    let img = h.render_serialized().expect("render");
     if let Some(d) = &dir {
         img.save(format!("{d}/ui3d_reveal_rotation.png")).unwrap();
     }
diff --git a/crates/ui-egui/tests/ui_accessibility.rs b/crates/ui-egui/tests/it/ui_accessibility.rs
similarity index 100%
rename from crates/ui-egui/tests/ui_accessibility.rs
rename to crates/ui-egui/tests/it/ui_accessibility.rs
diff --git a/crates/ui-egui/tests/it/ui_accessibility_audit.rs b/crates/ui-egui/tests/it/ui_accessibility_audit.rs
new file mode 100644
index 000000000..8f2f9cc4b
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_accessibility_audit.rs
@@ -0,0 +1,396 @@
+//! Accessibility audit (docs/gaps.md gap 25): renders panels headless and walks the AccessKit
+//! tree of the frame. Every interactive node (button, check box, text input, combo box, slider,
+//! spin button, tree or list item, tab, link, ...) must have a non-empty name, a role that says
+//! what it is, and the state that role needs (checked, selected, a value).
+//!
+//! * The panels that had their pass (`FIXED`: Effects & Presets, Settings, Render Queue with its
+//!   Templates dialog) must have **zero** findings.
+//! * Every other panel is counted and printed (run with `--nocapture`), and checked against
+//!   [`BASELINE`], a ratchet that can only shrink: fixing a panel lowers its number, and a number
+//!   must never go up. When a panel's count falls, the test fails until its entry is lowered.
+//!
+//! What this does not measure: how a real screen reader speaks the tree (none was run), colour
+//! contrast, focus order or keyboard operation (the `ui_*_keyboard.rs` tests cover those), or
+//! widgets that are scrolled out of view and not drawn.
+
+use std::collections::HashSet;
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use egui::accesskit::{Action, Role, Toggled};
+use egui::{Rect, pos2};
+use egui_kittest::Harness;
+use egui_kittest::kittest::NodeT;
+use serde_json::json;
+
+/// Groups that must be clean. A group is the first part of a scenario name (before the `:`).
+const FIXED: &[&str] = &["EffectsPresets", "Settings", "RenderQueue", "Project"];
+
+/// Scenarios whose content is the machine's own folder listing (the Media Browser opens on the
+/// home folder), so a runner with fewer files finds fewer controls. They are held to the upper bound
+/// only: the "improved, lower the entry" check would fail on any machine with a different home.
+const MACHINE_DEPENDENT: &[&str] = &["MediaBrowser:default"];
+
+/// (scenario, findings, of them unnamed controls) per not-yet-fixed scenario, as measured in the
+/// shared docking layout (Effect Controls with one Gaussian Blur on the layer, every other panel
+/// as it opens). A ratchet: a number may only go down, never up; when a pass over a panel lowers
+/// it, lower its entry in the same change, and remove the entry (and add the panel to `FIXED`)
+/// when it reaches zero. A scenario that is not listed is held to zero.
+const BASELINE: &[(&str, usize, usize)] = &[
+    ("EffectControls:default", 28, 14),
+    ("Composition:default", 4, 2),
+    ("Layer:default", 2, 1),
+    ("Timeline:default", 89, 42),
+    ("Audio:default", 4, 2),
+    ("Properties:default", 31, 15),
+    ("Character:default", 46, 22),
+    ("Paragraph:default", 26, 13),
+    ("Align:default", 12, 0),
+    ("Tracker:default", 11, 3),
+    ("Wiggler:default", 4, 2),
+    ("Smoother:default", 2, 1),
+    ("MotionSketch:default", 8, 4),
+    ("Paint:default", 38, 18),
+    ("Brushes:default", 34, 6),
+    ("Flowchart:default", 5, 1),
+    ("History:default", 10, 5),
+    ("MaskInterpolation:default", 16, 8),
+    ("ScriptConsole:default", 5, 3),
+    ("EssentialGraphics:default", 1, 1),
+    ("LumetriScopes:default", 2, 1),
+    ("MediaBrowser:default", 20, 10),
+    ("Metadata:default", 2, 2),
+    ("ContentAwareFill:default", 2, 1),
+];
+
+/// How many controls the fixed scenarios must at least show, so that "zero findings" is never
+/// the result of looking at nothing. Any scenario not listed needs 2.
+const MIN_CONTROLS: &[(&str, usize)] = &[
+    ("EffectsPresets:default", 10),
+    ("EffectsPresets:open", 10),
+    ("EffectsPresets:search", 5),
+    ("EffectsPresets:menu", 8),
+    ("Settings:general", 12),
+    ("Settings:appearance", 15),
+    ("Settings:labels", 30),
+    ("RenderQueue:queued", 8),
+    ("RenderQueue:expanded", 12),
+    ("RenderQueue:menu", 20),
+    ("RenderQueue:templates:renderSettings", 8),
+    ("RenderQueue:templates:outputModule", 8),
+];
+
+/// The roles that are controls: anything with one of these (or with a click or focus action) is
+/// held to the rules below.
+const CONTROL_ROLES: &[Role] = &[
+    Role::Button,
+    Role::CheckBox,
+    Role::ColorWell,
+    Role::ComboBox,
+    Role::Link,
+    Role::ListBoxOption,
+    Role::ListItem,
+    Role::MenuItem,
+    Role::MenuItemCheckBox,
+    Role::MenuItemRadio,
+    Role::MultilineTextInput,
+    Role::RadioButton,
+    Role::SearchInput,
+    Role::Slider,
+    Role::SpinButton,
+    Role::Switch,
+    Role::Tab,
+    Role::TextInput,
+    Role::TreeItem,
+];
+
+#[derive(Debug, Clone)]
+struct Finding {
+    scenario: String,
+    problem: &'static str,
+    role: Role,
+    name: String,
+    rect: [i32; 4],
+}
+
+impl std::fmt::Display for Finding {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "[{}] {}: {:?} {:?} at {:?}", self.scenario, self.problem, self.role, self.name, self.rect)
+    }
+}
+
+fn app_session() -> Session {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Red", "color": "#c04040"})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Blue", "color": "#4040c0"})).unwrap();
+    s.execute("effect.apply", json!({"effect": "Gaussian Blur"})).ok();
+    s
+}
+
+fn harness() -> Harness<'static, EffectcraftApp> {
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(app_session()));
+    // The default workspace gives Preview a short frame at the top of the right column; its
+    // controls below that frame stay in the tree and would be counted against the panel under it.
+    // The per-panel pass opens Preview again for its own scenario.
+    h.state_mut().close_panel(PanelKind::Preview);
+    h.run_steps(4);
+    h
+}
+
+fn invoke(h: &mut Harness<'_, EffectcraftApp>, id: &str, params: serde_json::Value) {
+    let ctx = h.ctx.clone();
+    effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, id, params).unwrap();
+    h.run_steps(4);
+}
+
+fn panel_rect(h: &Harness<'_, EffectcraftApp>, p: PanelKind) -> Option<Rect> {
+    let e = h.state().auto.find(&format!("panel.{}", p.id()))?;
+    Some(Rect::from_min_size(pos2(e.rect[0], e.rect[1]), egui::vec2(e.rect[2], e.rect[3])))
+}
+
+fn dialog_rect(h: &Harness<'_, EffectcraftApp>, title: &str) -> Option<Rect> {
+    h.ctx.memory(|m| m.area_rect(egui::Id::unique(("modal", title))))
+}
+
+/// The ids of every node now, so a later audit can look at what appeared since (a popup).
+fn node_ids(h: &Harness<'_, EffectcraftApp>) -> HashSet<String> {
+    h.root().children_recursive().map(|n| format!("{:?}", n.accesskit_node().id())).collect()
+}
+
+/// Walk the tree and check every control whose centre is inside `scope` (and, when `since` is
+/// given, that was not in the tree before).
+fn audit(h: &Harness<'_, EffectcraftApp>, scenario: &str, scope: Rect, since: Option<&HashSet<String>>) -> (Vec<Finding>, usize) {
+    let mut out = Vec::new();
+    let mut controls = 0;
+    for n in h.root().children_recursive() {
+        let a = n.accesskit_node();
+        if a.is_hidden() {
+            continue;
+        }
+        let Some(b) = a.bounding_box() else {
+            // No bounds: assistive technology cannot place it. Only a control is a finding (and
+            // it is one wherever it is: there is no position to scope it by).
+            if CONTROL_ROLES.contains(&a.role()) {
+                out.push(Finding { scenario: scenario.to_string(), problem: "no bounds", role: a.role(), name: a.label().unwrap_or_default(), rect: [0; 4] });
+            }
+            continue;
+        };
+        if !scope.contains(pos2(((b.x0 + b.x1) / 2.0) as f32, ((b.y0 + b.y1) / 2.0) as f32)) {
+            continue;
+        }
+        if since.is_some_and(|s| s.contains(&format!("{:?}", a.id()))) {
+            continue;
+        }
+        let role = a.role();
+        let actionable = a.data().supports_action(Action::Click) || a.data().supports_action(Action::Focus);
+        let control = CONTROL_ROLES.contains(&role);
+        if !(control || (actionable && matches!(role, Role::Unknown | Role::GenericContainer))) {
+            continue;
+        }
+        let name = a.label().unwrap_or_default();
+        controls += 1;
+        let finding = |problem: &'static str| Finding {
+            scenario: scenario.to_string(),
+            problem,
+            role,
+            name: name.clone(),
+            rect: [b.x0 as i32, b.y0 as i32, b.x1 as i32, b.y1 as i32],
+        };
+        if !control && matches!(role, Role::Unknown | Role::GenericContainer) {
+            // Something you can click or focus, that no role describes.
+            out.push(finding("clickable or focusable without a control role"));
+        }
+        if name.trim().is_empty() {
+            out.push(finding("no name"));
+        }
+        let state_missing = match role {
+            Role::CheckBox | Role::RadioButton | Role::Switch | Role::MenuItemCheckBox | Role::MenuItemRadio => {
+                a.toggled().is_none() || a.toggled() == Some(Toggled::Mixed)
+            }
+            Role::Slider | Role::SpinButton => a.numeric_value().is_none(),
+            Role::ComboBox => a.value().is_none_or(|v| v.trim().is_empty()),
+            Role::TreeItem | Role::ListItem | Role::ListBoxOption | Role::Tab => a.is_selected().is_none(),
+            _ => false,
+        };
+        if state_missing {
+            out.push(finding("no state or value"));
+        }
+    }
+    (out, controls)
+}
+
+fn count_unnamed(f: &[Finding]) -> usize {
+    f.iter().filter(|f| f.problem == "no name").count()
+}
+
+struct Report {
+    findings: Vec<Finding>,
+    /// (scenario, findings, of them unnamed, controls looked at)
+    rows: Vec<(String, usize, usize, usize)>,
+}
+
+impl Report {
+    fn add(&mut self, scenario: &str, (f, controls): (Vec<Finding>, usize)) {
+        self.rows.push((scenario.to_string(), f.len(), count_unnamed(&f), controls));
+        self.findings.extend(f);
+    }
+}
+
+fn group(scenario: &str) -> &str {
+    scenario.split(':').next().unwrap_or(scenario)
+}
+
+fn collect() -> Report {
+    let mut r = Report { findings: vec![], rows: vec![] };
+
+    // ---- Effects & Presets: closed, everything open, searching, the contents menu.
+    let mut h = harness();
+    h.state_mut().show_panel(PanelKind::EffectsPresets);
+    h.run_steps(4);
+    let rect = panel_rect(&h, PanelKind::EffectsPresets).expect("Effects & Presets is drawn");
+    r.add("EffectsPresets:default", audit(&h, "EffectsPresets:default", rect, None));
+    {
+        let s = h.state_mut();
+        s.session.prefs.toggle_effect_favorite("ec.blur.gaussian");
+        s.ui.effects_open.insert("favorites".into());
+        s.ui.effects_open.insert("presets".into());
+        s.ui.effects_open.insert("presets/Text".into());
+        s.ui.effects_open.insert("Blur & Sharpen".into());
+    }
+    h.run_steps(4);
+    r.add("EffectsPresets:open", audit(&h, "EffectsPresets:open", rect, None));
+    h.state_mut().ui.effects_search = "blur".into();
+    h.run_steps(4);
+    r.add("EffectsPresets:search", audit(&h, "EffectsPresets:search", rect, None));
+    let before = node_ids(&h);
+    h.ctx.data_mut(|d| d.insert_temp(egui::Id::unique("fx-contents-menu").with("open"), true));
+    h.run_steps(4);
+    let screen = Rect::from_min_size(pos2(0.0, 0.0), egui::vec2(1600.0, 1000.0));
+    r.add("EffectsPresets:menu", audit(&h, "EffectsPresets:menu", screen, Some(&before)));
+
+    // ---- Settings: every page.
+    let mut h = harness();
+    let before = node_ids(&h);
+    for page in effectcraft_engine::prefs::pages() {
+        invoke(&mut h, "app.settings", json!({"page": page.id}));
+        let name = format!("Settings:{}", page.id);
+        let rect = dialog_rect(&h, "Settings").expect("the Settings dialog is open");
+        r.add(&name, audit(&h, &name, rect, Some(&before)));
+    }
+
+    // ---- Render Queue: empty, queued and expanded, a menu open, the Templates dialogs.
+    let mut h = harness();
+    h.state_mut().show_panel(PanelKind::RenderQueue);
+    h.run_steps(4);
+    let rect = panel_rect(&h, PanelKind::RenderQueue).expect("the Render Queue is drawn");
+    r.add("RenderQueue:empty", audit(&h, "RenderQueue:empty", rect, None));
+    let comp = h.state().session.active_comp_id().expect("a comp").0;
+    let mut items = vec![];
+    for _ in 0..2 {
+        let out = h.state_mut().session.execute("renderQueue.add", json!({"comp": comp})).unwrap();
+        items.push(out["item"].as_u64().or_else(|| out["items"][0].as_u64()).unwrap_or(0));
+    }
+    h.run_steps(4);
+    r.add("RenderQueue:queued", audit(&h, "RenderQueue:queued", rect, None));
+    let first = h.state().session.project.render_queue.first().map(|i| i.id).expect("a queue item");
+    h.ctx.data_mut(|d| d.insert_temp(egui::Id::unique("rq-ui"), (vec![first], Some(first))));
+    h.run_steps(4);
+    r.add("RenderQueue:expanded", audit(&h, "RenderQueue:expanded", rect, None));
+    let before = node_ids(&h);
+    h.ctx.data_mut(|d| d.insert_temp(egui::Id::unique(("rq-dd", first, 0)).with("open"), true));
+    h.run_steps(4);
+    r.add("RenderQueue:menu", audit(&h, "RenderQueue:menu", screen, Some(&before)));
+    h.ctx.data_mut(|d| d.insert_temp(egui::Id::unique(("rq-dd", first, 0)).with("open"), false));
+    let before = node_ids(&h);
+    for (kind, title) in [("renderSettings", "Render Settings Templates"), ("outputModule", "Output Module Templates")] {
+        invoke(&mut h, "app.templates", json!({"kind": kind}));
+        let name = format!("RenderQueue:templates:{kind}");
+        let rect = dialog_rect(&h, title).expect("the Templates dialog is open");
+        r.add(&name, audit(&h, &name, rect, Some(&before)));
+    }
+    let _ = items;
+
+    // ---- Everything else, informational: each panel on its own.
+    let mut h = harness();
+    for p in PanelKind::ALL {
+        if matches!(p, PanelKind::EffectsPresets | PanelKind::RenderQueue) {
+            continue;
+        }
+        h.state_mut().show_panel(p);
+        h.run_steps(3);
+        let name = format!("{}:default", p.id());
+        let Some(rect) = panel_rect(&h, p) else {
+            // A panel with a baseline entry must be looked at, or its allowance would pass unchecked.
+            assert!(!BASELINE.iter().any(|(k, ..)| *k == name), "{name} has a BASELINE entry but was not drawn");
+            r.rows.push((format!("{name} (not drawn)"), 0, 0, 0));
+            continue;
+        };
+        r.add(&name, audit(&h, &name, rect, None));
+        if p == PanelKind::Preview {
+            // Closed again so it is not counted against the panels after it (see `harness`).
+            h.state_mut().close_panel(PanelKind::Preview);
+            h.run_steps(3);
+        }
+    }
+    r
+}
+
+#[test]
+fn fixed_panels_have_no_unnamed_or_roleless_controls_and_the_others_do_not_get_worse() {
+    let report = collect();
+    println!("\nAccessibility audit: findings per scenario (unnamed in brackets)");
+    let mut by_group: Vec<(String, usize, usize, usize)> = vec![];
+    for (name, n, unnamed, controls) in &report.rows {
+        println!("  {name:<44} {n:>4} findings ({unnamed} unnamed) of {controls} controls");
+        let g = group(name).to_string();
+        match by_group.iter_mut().find(|(k, ..)| *k == g) {
+            Some(e) => {
+                e.1 += n;
+                e.2 += unnamed;
+                e.3 += controls;
+            }
+            None => by_group.push((g, *n, *unnamed, *controls)),
+        }
+    }
+    println!("\nBy panel (findings, unnamed controls, controls looked at):");
+    for (g, n, unnamed, controls) in &by_group {
+        let state = if FIXED.contains(&g.as_str()) { "fixed: must be 0" } else { "not yet audited" };
+        println!("  {g:<28} {n:>4} findings, {unnamed:>3} unnamed, {controls:>4} controls  {state}");
+    }
+    let total_unnamed: usize = by_group.iter().map(|(_, _, u, _)| u).sum();
+    println!("  all panels: {total_unnamed} unnamed controls\n");
+
+    let mut failures = vec![];
+    for f in &report.findings {
+        if FIXED.contains(&group(&f.scenario)) {
+            failures.push(f.to_string());
+        }
+    }
+    assert!(failures.is_empty(), "{} accessibility findings in the fixed panels:\n{}", failures.len(), failures.join("\n"));
+
+    // A clean panel must not be clean because nothing was looked at.
+    for (name, _, _, controls) in &report.rows {
+        if FIXED.contains(&group(name)) {
+            let min = MIN_CONTROLS.iter().find(|(k, _)| k == name).map_or(2, |(_, v)| *v);
+            assert!(*controls >= min, "{name}: only {controls} controls found in the tree (expected {min}); the scenario is not showing the panel");
+        }
+    }
+
+    // The ratchet: a count above its entry is a regression, a count below it must be written back
+    // (else the old, higher allowance would let a later regression through).
+    let mut off = vec![];
+    for (name, n, unnamed, _) in &report.rows {
+        if FIXED.contains(&group(name)) {
+            continue;
+        }
+        let (allowed, allowed_unnamed) = BASELINE.iter().find(|(k, ..)| k == name).map_or((0, 0), |(_, v, u)| (*v, *u));
+        if *n > allowed || *unnamed > allowed_unnamed {
+            off.push(format!("{name}: {n} findings ({unnamed} unnamed), the baseline allows {allowed} ({allowed_unnamed}); a panel must not get worse"));
+        } else if (*n < allowed || *unnamed < allowed_unnamed) && !MACHINE_DEPENDENT.contains(&name.as_str()) {
+            off.push(format!("{name}: improved to {n} findings ({unnamed} unnamed); lower its BASELINE entry to ({n}, {unnamed})"));
+        }
+    }
+    assert!(off.is_empty(), "{} scenarios do not match BASELINE:\n{}", off.len(), off.join("\n"));
+}
diff --git a/crates/ui-egui/tests/it/ui_audio_scrub.rs b/crates/ui-egui/tests/it/ui_audio_scrub.rs
index c748afe8e..81e55817e 100644
--- a/crates/ui-egui/tests/it/ui_audio_scrub.rs
+++ b/crates/ui-egui/tests/it/ui_audio_scrub.rs
@@ -166,96 +166,90 @@ fn cmd_dragging_the_current_time_scrubs_and_an_idle_scrub_closes() {
     assert!(h.state().scrub.is_none() && fake.0.lock().unwrap().1, "closed and stopped");
 }
 
-/// A preview with audio waits for frames like a silent one (#103): while the frames ahead aren't
-/// cached, every frame shows as it renders, silently; the sound starts once the rest of the
-/// preview is cached, and a frame that isn't cached stops it instead of being skipped.
+/// The comp's frame at the current time.
+fn frame(h: &Harness<'_, EffectcraftApp>, cid: ItemId) -> i64 {
+    let app = h.state();
+    app.session.project.comp(cid).unwrap().frame_rate.frame_at(app.session.time())
+}
+
+/// The frame under the preview audio's first sample (its clock before the device pulls any).
+fn audio_frame(h: &Harness<'_, EffectcraftApp>, cid: ItemId) -> Option<i64> {
+    let app = h.state();
+    let a = app.audio.as_ref()?;
+    Some(effectcraft_ui_egui::audio::frame_of_sample(a.clock(), a.rate, app.session.project.comp(cid).unwrap().frame_rate))
+}
+
+/// Step until the preview's sound starts (or 60 s pass, for a loaded machine), checking the
+/// playhead holds `first` meanwhile. Returns whether the sound started.
+fn until_sound(h: &mut Harness<'_, EffectcraftApp>, cid: ItemId, first: i64) -> bool {
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
+    while std::time::Instant::now() < deadline {
+        step(h);
+        if h.state().audio.is_some() {
+            return true;
+        }
+        assert_eq!(frame(h, cid), first, "the playhead holds the first frame until the sound can start");
+        assert!(h.state().playback.starting && h.state().playback.playing);
+        std::thread::sleep(std::time::Duration::from_millis(1));
+    }
+    false
+}
+
+/// One step with the app clock, which playback runs on, a step (1/30 s) further on: these tests
+/// count time in steps, however long a step takes on a loaded machine.
+fn step(h: &mut Harness<'_, EffectcraftApp>) {
+    h.state_mut().clock_mut().advance(1.0 / 30.0);
+    h.step();
+}
+
+/// Starting a preview with sound before its frames are cached (#947): the playhead holds the
+/// first frame while the frames ahead render, then sound and picture start together from it (the
+/// sound used to start at a later frame, losing the opening). A frame that isn't cached later on
+/// still stops the sound rather than being skipped (#103).
 #[test]
-fn preview_with_audio_shows_every_frame_and_sounds_once_cached() {
+fn preview_with_audio_holds_the_first_frame_and_sounds_from_it() {
     let fake = Fake::default();
     let (mut app, cid) = setup(true, &fake);
-    // Hold rendering in the test: the cache cannot fill ahead of what the test releases, so the
-    // silently shown frames and the moment the sound starts do not depend on the host's threads.
+    // Release only the frames this test chooses, and drive the app clock: rendering cannot race
+    // the clock on a slow or loaded test host.
     let gate = GatedFrames::default();
     let renderer: Arc<dyn RemoteFrames> = Arc::new(gate.clone());
     app.frames.set_remote(Some(renderer));
-    let ahead = (app.frames.parallelism() * 2).max(4);
+    let ahead = (app.frames.parallelism() * 2).max(4) as i64;
     app.session.execute("comp.settings", json!({"comp": cid.0, "duration": (4 * ahead) as f64 / 30.0})).unwrap();
     let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 30.0).build_eframe(|_| app);
-    // Playback measures time on the app clock, never `ctx.input(|i| i.time)`; drive that clock
-    // explicitly at one frame per step.
     h.state_mut().use_manual_clock();
     h.run_steps(2);
     gate.discard(&mut h);
-    let frame = |h: &Harness<'_, EffectcraftApp>| {
-        let app = h.state();
-        app.session.project.comp(cid).unwrap().frame_rate.frame_at(app.session.time())
-    };
     let now = h.state().now();
     h.state_mut().play(now);
-    assert!(h.state().playback.audio_held && h.state().audio.is_none(), "nothing is cached: no sound yet");
-    let mut last = frame(&h);
-    let mut shown = 0;
-    // Show frames while only those frames are cached: they play silently first.
-    for _ in 0..4 {
-        let target = last + 1;
-        gate.render(&mut h, cid, &[target]);
-        h.state_mut().clock_mut().advance(1.0 / 30.0);
-        h.step();
-        let f = frame(&h);
-        // Accumulating 1/30 in f64 can leave the same frame up for one more step; it must never
-        // jump over a frame.
-        assert!(f == last || f == last + 1, "{last} → {f}: a frame was skipped");
-        shown += usize::from(f != last);
-        last = f;
-    }
-    // A frame that has not rendered holds the clock at the frame on screen; once it renders it is
-    // shown, never jumped over. This exercises the production hold path, not a test-only shortcut.
-    let waiting = last;
-    h.state_mut().clock_mut().advance(1.0 / 30.0);
-    h.step();
-    assert_eq!(frame(&h), waiting, "an uncached frame holds the preview instead of being skipped");
-    gate.render(&mut h, cid, &[waiting + 1]);
-    // f64 clock accumulation need not put the next step exactly on the next frame boundary;
-    // keep stepping until the held frame appears, and never allow it to jump past that frame.
-    let mut showed_waiting = false;
-    for _ in 0..4 {
-        h.state_mut().clock_mut().advance(1.0 / 30.0);
-        h.step();
-        let f = frame(&h);
-        assert!(f == waiting || f == waiting + 1, "{waiting} → {f}: the held frame was skipped");
-        if f == waiting + 1 {
-            showed_waiting = true;
-            break;
-        }
-    }
-    assert!(showed_waiting, "the waiting frame is shown once it renders");
-    shown += 1;
-    last = waiting + 1;
-    assert!(shown > 0, "frames played silently first");
-    assert!(h.state().audio.is_none() && h.state().playback.audio_held, "the rest of the range is not cached: the sound waits");
-    // Cache everything ahead; only then may the sound start.
-    let end = h.state().playback.plan.expect("a preview plan").end;
-    let rest: Vec<i64> = ((last + 1)..=end).collect();
-    gate.render(&mut h, cid, &rest);
-    h.step();
+    assert!(h.state().playback.starting && h.state().audio.is_none(), "nothing is cached: no sound yet");
+    // Half the frames ahead cached: the playhead holds the first frame, silently.
+    let half: Vec<i64> = (0..ahead / 2).collect();
+    gate.render(&mut h, cid, &half);
+    step(&mut h);
+    assert!(h.state().playback.starting && h.state().audio.is_none(), "{} of {ahead} frames ahead cached: no sound yet", half.len());
+    assert_eq!(frame(&h, cid), 0, "the playhead holds the first frame");
+    // All of them: the sound starts, from that frame.
+    let all: Vec<i64> = (0..ahead).collect();
+    gate.render(&mut h, cid, &all);
+    step(&mut h);
     assert!(h.state().audio.is_some() && fake.0.lock().unwrap().0.is_some(), "the sound started once the frames ahead were cached");
+    assert_eq!(audio_frame(&h, cid), Some(0), "from the first frame, not a later one");
+    assert!(!h.state().playback.starting);
     // A frame that isn't cached stops the sound rather than being skipped.
     gate.discard(&mut h);
-    h.state().frames.set_budget(0);
     h.state().frames.clear();
     h.step();
     assert!(h.state().audio.is_none() && h.state().playback.audio_held && h.state().playback.playing);
 }
 
-/// A preview whose frames render in real time sounds without waiting for the whole work area to
-/// be cached (#208): once the silent preview has kept up for a moment with the frames ahead
-/// cached, the sound starts, still without skipping a frame before it.
+/// A long (30 s) preview sounds once the frames ahead of its first frame are cached, not the
+/// whole work area (#208), and from that first frame (#947).
 #[test]
-fn preview_with_audio_sounds_once_rendering_keeps_up() {
+fn preview_with_audio_sounds_without_caching_the_work_area() {
     let fake = Fake::default();
     let (mut app, cid) = setup_long(true, &fake, 30.0);
-    // Release only the frames this test chooses, and drive the app clock: rendering cannot race
-    // the clock, so a frame is never skipped by a slow or loaded test host.
     let gate = GatedFrames::default();
     let renderer: Arc<dyn RemoteFrames> = Arc::new(gate.clone());
     app.frames.set_remote(Some(renderer));
@@ -264,36 +258,432 @@ fn preview_with_audio_sounds_once_rendering_keeps_up() {
     h.run_steps(2);
     gate.discard(&mut h);
     let ahead = (h.state().frames.parallelism() * 2).max(4) as i64;
-    let frame = |h: &Harness<'_, EffectcraftApp>| {
-        let app = h.state();
-        app.session.project.comp(cid).unwrap().frame_rate.frame_at(app.session.time())
+    let now = h.state().now();
+    h.state_mut().play(now);
+    let frames: Vec<i64> = (0..ahead).collect();
+    gate.render(&mut h, cid, &frames);
+    step(&mut h);
+    assert!(h.state().audio.is_some(), "the sound started");
+    assert_eq!(audio_frame(&h, cid), Some(0), "from the first frame");
+    let cached = h.state().frames.cached_frames(&h.state().shown_series(cid)).len();
+    assert!((1..900).contains(&cached), "it started with {cached} of the 900 frames cached, not the whole work area");
+}
+
+/// Pull `frames` stereo frames from the output, waiting for the feeder thread to mix them.
+fn pull(feed: &AudioFeed, frames: usize) -> Vec<f32> {
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
+    while feed.queued_frames() < frames && std::time::Instant::now() < deadline {
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    let mut out = vec![0.0f32; frames * 2];
+    feed.pull(&mut out);
+    out
+}
+
+/// The opening of the preview is heard (#947): a sound that lasts only the first 100 ms after the
+/// start, from the beginning of the comp or from the middle, reaches the output device.
+#[test]
+fn a_sound_in_the_first_100_ms_is_heard() {
+    for start in [0.0, 1.0] {
+        let fake = Fake::default();
+        let (mut app, cid) = setup_long(false, &fake, 4.0);
+        // A tone only from `start` to `start` + 0.1 s.
+        let l = app.session.execute("layer.newSolid", json!({"color": "#808080"})).unwrap()["layer"].as_u64().unwrap();
+        app.session.execute("effect.apply", json!({"layers": [l], "effect": "ec.audio.tone"})).unwrap();
+        app.session.execute("layer.setSwitch", json!({"layers": [l], "switch": "audio", "value": true})).unwrap();
+        app.session.execute("layer.timing", json!({"layers": [l], "in": start, "out": start + 0.1})).unwrap();
+        app.session.execute("time.set", json!({"time": start})).unwrap();
+        let first = (start * 30.0) as i64;
+        let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 30.0).build_eframe(|_| app);
+        h.state_mut().use_manual_clock();
+        h.run_steps(2);
+        let now = h.state().now();
+        h.state_mut().play(now);
+        assert!(until_sound(&mut h, cid, first), "{start}: the sound started");
+        assert_eq!(audio_frame(&h, cid), Some(first), "{start}: from the first frame");
+        let feed = fake.0.lock().unwrap().0.clone().expect("the output opened");
+        // The first 100 ms at 48 kHz.
+        let out = pull(&feed, 4800);
+        assert!(out.iter().any(|v| v.abs() > 0.01), "{start}: the opening tone reached the output");
+    }
+}
+
+/// A preview without video starts its sound at once, from the first frame (unchanged), and so
+/// does one whose frames are already cached.
+#[test]
+fn audio_only_previews_start_at_once() {
+    let fake = Fake::default();
+    let (app, cid) = setup(true, &fake);
+    let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).build_eframe(|_| app);
+    h.state_mut().use_manual_clock();
+    h.run_steps(2);
+    let now = h.state().now();
+    h.state_mut().play_with(now, effectcraft_engine::preview::PreviewShortcut::AltNumpad0);
+    assert!(h.state().audio.is_some() && !h.state().playback.starting, "Video off: the sound starts at once");
+    assert_eq!(audio_frame(&h, cid), Some(0));
+}
+
+/// Without an output device the preview still plays, from the first frame, once the frames ahead
+/// are cached; Stop while it prepares leaves nothing playing.
+#[test]
+fn no_device_plays_the_picture_and_stop_ends_the_wait() {
+    let fake = Fake::default();
+    let (mut app, cid) = setup_long(true, &fake, 10.0);
+    app.hooks.audio_device = Some(Box::new(|_| None));
+    let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 30.0).build_eframe(|_| app);
+    h.state_mut().use_manual_clock();
+    h.run_steps(2);
+    let now = h.state().now();
+    h.state_mut().play(now);
+    assert!(h.state().playback.starting);
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
+    while h.state().playback.starting && std::time::Instant::now() < deadline {
+        step(&mut h);
+        std::thread::sleep(std::time::Duration::from_millis(1));
+    }
+    assert!(!h.state().playback.starting && h.state().audio.is_none() && h.state().playback.playing, "no device: the picture plays alone");
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    while frame(&h, cid) == 0 && std::time::Instant::now() < deadline {
+        step(&mut h);
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    assert!(frame(&h, cid) > 0, "from the first frame on");
+    // Stop while preparing.
+    h.state_mut().stop();
+    let now = h.state().now();
+    let device = fake.clone();
+    h.state_mut().hooks.audio_device = Some(Box::new(move |_| Some(Box::new(device.clone()) as Box<dyn AudioDevice>)));
+    h.state().frames.clear();
+    h.state_mut().play(now);
+    // One step into preparing: the frames ahead are requested and it waits for them.
+    step(&mut h);
+    assert!(h.state().playback.starting && h.state().playback.waiting && h.state().audio.is_none(), "preparing");
+    h.state_mut().stop();
+    // The renders it queued finish after Stop: they must not start the sound.
+    for _ in 0..30 {
+        step(&mut h);
+        std::thread::sleep(std::time::Duration::from_millis(10));
+    }
+    assert!(!h.state().playback.playing && !h.state().playback.starting && h.state().audio.is_none(), "Stop while preparing: nothing plays");
+    assert!(fake.0.lock().unwrap().0.is_none(), "the output never opened");
+}
+
+/// Start a preview and step until it leaves its startup (or 60 s pass). Returns whether it did.
+fn until_started(h: &mut Harness<'_, EffectcraftApp>) -> bool {
+    let now = h.state().now();
+    h.state_mut().play(now);
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
+    while h.state().playback.starting && std::time::Instant::now() < deadline {
+        step(h);
+        std::thread::sleep(std::time::Duration::from_millis(1));
+    }
+    !h.state().playback.starting
+}
+
+/// RAM preview budgets just below, at and above the prefetch's frames ahead, and small ones, from
+/// a cold cache, with and without an output device: the start never waits for a frame the
+/// prefetch doesn't request (with a budget of 4 frames it asks for 3 ahead of the playhead).
+#[test]
+fn startup_finishes_at_any_ram_preview_budget() {
+    let probe = Fake::default();
+    let (app, _) = setup(true, &probe);
+    let ahead = (app.frames.parallelism() * 2).max(4) as i64;
+    // A 64×36 frame is 9216 bytes; `fit` frames fit in (fit + ½) frames' worth / 0.9.
+    let mut fits = vec![2, 3, 4, ahead - 1, ahead, ahead + 1];
+    fits.sort();
+    fits.dedup();
+    for fit in fits {
+        for device in [true, false] {
+            let fake = Fake::default();
+            let (mut app, cid) = setup_long(true, &fake, 8.0);
+            if !device {
+                app.hooks.audio_device = Some(Box::new(|_| None));
+            }
+            let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 30.0).build_eframe(|_| app);
+            h.state_mut().use_manual_clock();
+            h.run_steps(2);
+            let budget = ((fit as f64 + 0.5) * 9216.0 / 0.9) as usize;
+            h.state().frames.set_budget(budget);
+            h.state().frames.clear();
+            assert!(until_started(&mut h), "fit {fit} (ahead {ahead}), device {device}: the preview left its startup");
+            assert_eq!(h.state().audio.is_some(), device, "fit {fit}, device {device}");
+            if device {
+                assert_eq!(audio_frame(&h, cid), Some(0), "fit {fit}: from the first frame");
+            }
+        }
+    }
+}
+
+/// An audible 160×120 comp with a 3D layer and Draft 3D, Extended Viewer on: its viewer frames
+/// render the pasteboard too, larger than the comp. Returns the harness once the first frame has
+/// rendered, the comp, and that frame's size.
+fn extended_viewer(fake: &Fake) -> (Harness<'static, EffectcraftApp>, ItemId, [usize; 2]) {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "E", "width": 160, "height": 120, "frameRate": 30, "duration": 8})).unwrap();
+    let cid = s.active_comp_id().unwrap();
+    let l = s.execute("layer.newSolid", json!({"color": "#4060a0"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("effect.apply", json!({"layers": [l], "effect": "ec.audio.tone"})).unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [l], "switch": "audio", "value": true})).unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [l], "switch": "threeD", "value": true})).unwrap();
+    s.execute("comp.setSwitch", json!({"switch": "draft3d", "value": true})).unwrap();
+    s.prefs.three_d.extended_viewer = true;
+    let mut app = EffectcraftApp::new(s);
+    let f = fake.clone();
+    app.hooks.audio_device = Some(Box::new(move |_| Some(Box::new(f.clone()) as Box<dyn AudioDevice>)));
+    let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 30.0).build_eframe(|_| app);
+    h.state_mut().use_manual_clock();
+    // The viewer shows the pasteboard: frames render the extended region.
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    let size = loop {
+        step(&mut h);
+        let series = h.state().shown_series(cid);
+        if let Some(img) = h.state().frames.get(&series) {
+            break img.size();
+        }
+        assert!(std::time::Instant::now() < deadline, "the first frame rendered");
+        std::thread::sleep(std::time::Duration::from_millis(5));
     };
+    assert!(h.state().ui.viewer.extended.is_some(), "Extended Viewer is on");
+    (h, cid, size)
+}
+
+/// Extended Viewer frames render larger than the comp: a budget that would hold `ahead` comp-sized
+/// frames holds fewer of them, and the start waits only for as many as really fit (#947).
+#[test]
+fn startup_finishes_when_extended_viewer_frames_are_larger() {
+    let fake = Fake::default();
+    let (mut h, cid, size) = extended_viewer(&fake);
+    let ahead = (h.state().frames.parallelism() * 2).max(4);
+    let (comp_bytes, real_bytes) = (160 * 120 * 4, size[0] * size[1] * 4);
+    // Room for `ahead` comp-sized frames (and a half), which is fewer real ones.
+    let budget = ((ahead as f64 + 0.5) * comp_bytes as f64 / 0.9) as usize;
+    assert!((budget as f64 * 0.9 / real_bytes as f64) < ahead as f64, "real frames ({size:?}) fit fewer than {ahead}");
+    h.state().frames.set_budget(budget);
+    h.state().frames.clear();
+    let now = h.state().now();
+    h.state_mut().play(now);
+    step(&mut h);
+    // The first frame renders before the harness clock moves on: each step is 1/30 s however long
+    // it takes, so on a busy machine the first frame could take longer than STARTUP_LIMIT of that
+    // clock, and this test is about the wait for the frames ahead.
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
+    while !h.state().frames.is_cached(&h.state().shown_series(cid)) && std::time::Instant::now() < deadline {
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    while h.state().playback.starting && std::time::Instant::now() < deadline {
+        step(&mut h);
+        std::thread::sleep(std::time::Duration::from_millis(1));
+    }
+    assert!(!h.state().playback.starting, "the preview left its startup");
+    assert!(h.state().audio.is_some(), "with its sound");
+    assert_eq!(audio_frame(&h, cid), Some(0), "from the first frame");
+    let (started, stopped) = {
+        let d = fake.0.lock().unwrap();
+        (d.0.is_some(), d.1)
+    };
+    assert!(started && !stopped, "the device started and kept playing");
+}
+
+/// A first frame that takes longer than STARTUP_WAIT to be cached (a heavy comp, a busy machine;
+/// here it can't be cached until the RAM preview grows): the start keeps holding it, then the
+/// sound starts from it and keeps playing. It used to give up two seconds after Play, start the
+/// sound on the uncached frame and stop it at once, so the opening played silently.
+#[test]
+fn a_slow_first_frame_keeps_its_opening_sound() {
+    let fake = Fake::default();
+    let (mut h, cid, size) = extended_viewer(&fake);
+    let (comp_bytes, real_bytes) = (160 * 120 * 4, size[0] * size[1] * 4);
+    assert!(real_bytes > comp_bytes * 2, "Extended Viewer frames ({size:?}) are larger than the comp");
+    h.state().frames.set_budget((comp_bytes + real_bytes) / 2);
+    h.state().frames.clear();
     let start = h.state().now();
     h.state_mut().play(start);
-    assert!(h.state().playback.audio_held && h.state().audio.is_none(), "nothing is cached: no sound yet");
-    let mut last = frame(&h);
-    let mut shown = 0;
-    // Two seconds of playback at one frame per clock step: keep the prefetch window cached, but
-    // not the rest of the 30 s comp, so the sound has to start by the real-time rule.
-    for step in 1..=60 {
-        let target = last + 1;
-        let window: Vec<i64> = (target..target + ahead).collect();
-        gate.render(&mut h, cid, &window);
-        // Set the clock to this step's exact time rather than adding 1/30 repeatedly: accumulated
-        // f64 error can put one step just below a frame boundary and the next just above it, so
-        // `floor(elapsed × fps)` would otherwise jump from frame N to N + 2 for a one-frame step.
-        let now = h.state().now();
-        let tick_time = start + step as f64 / 30.0;
-        h.state_mut().clock_mut().advance(tick_time - now);
-        h.step();
-        if h.state().audio.is_some() {
-            break;
-        }
-        let f = frame(&h);
-        assert!(f == last || f == last + 1, "{last} → {f}: a frame was skipped");
-        shown += usize::from(f != last);
-        last = f;
+    while h.state().now() - start < 3.0 {
+        step(&mut h);
+        assert!(h.state().playback.starting, "it still holds the first frame");
+        assert_eq!(frame(&h, cid), 0);
     }
-    assert!(h.state().audio.is_some() && fake.0.lock().unwrap().0.is_some(), "the sound started within 2 s, at frame {last} of 900");
-    assert!(shown >= 3, "the sound starts only after the silent preview kept up for a moment");
+    assert!(fake.0.lock().unwrap().0.is_none(), "no sound yet");
+    h.state().frames.set_budget(1 << 30);
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
+    while h.state().playback.starting && std::time::Instant::now() < deadline {
+        step(&mut h);
+        std::thread::sleep(std::time::Duration::from_millis(1));
+    }
+    assert!(!h.state().playback.starting, "the preview left its startup");
+    assert_eq!(audio_frame(&h, cid), Some(0), "with its sound from the first frame");
+    let (started, stopped) = {
+        let d = fake.0.lock().unwrap();
+        (d.0.is_some(), d.1)
+    };
+    assert!(started && !stopped, "the device started and kept playing");
+}
+
+/// An output device whose start fails.
+#[derive(Clone, Default)]
+struct Broken;
+
+impl AudioDevice for Broken {
+    fn sample_rate(&self) -> u32 {
+        48000
+    }
+    fn start(&mut self, _feed: Arc<AudioFeed>) -> Result<(), String> {
+        Err("device unavailable".into())
+    }
+    fn stop(&mut self) {}
+}
+
+/// A device that fails to start: the picture plays on its own from the first frame.
+#[test]
+fn a_device_that_fails_to_start_plays_the_picture() {
+    let fake = Fake::default();
+    let (mut app, cid) = setup_long(true, &fake, 8.0);
+    app.hooks.audio_device = Some(Box::new(|_| Some(Box::new(Broken) as Box<dyn AudioDevice>)));
+    let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 30.0).build_eframe(|_| app);
+    h.state_mut().use_manual_clock();
+    h.run_steps(2);
+    assert!(until_started(&mut h), "it left its startup");
+    assert!(h.state().audio.is_none() && h.state().playback.playing);
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    while frame(&h, cid) == 0 && std::time::Instant::now() < deadline {
+        step(&mut h);
+        std::thread::sleep(std::time::Duration::from_millis(5));
+    }
+    assert!(frame(&h, cid) > 0, "the picture plays");
+}
+
+/// An output that plays: a thread takes the feed's samples in real time, as a sound card would.
+/// It holds off pulling until `.1` is set, so a test can read the clock before any sample is
+/// taken however loaded the machine is (the thread otherwise races the test's first check).
+#[derive(Clone, Default)]
+struct Playing(Arc<Mutex<bool>>, Arc<std::sync::atomic::AtomicBool>);
+
+impl AudioDevice for Playing {
+    fn sample_rate(&self) -> u32 {
+        48000
+    }
+    fn start(&mut self, feed: Arc<AudioFeed>) -> Result<(), String> {
+        let stop = self.0.clone();
+        let go = self.1.clone();
+        std::thread::spawn(move || {
+            let mut buf = vec![0.0f32; 480 * 2];
+            while !*stop.lock().unwrap() {
+                if !go.load(std::sync::atomic::Ordering::Acquire) {
+                    std::thread::sleep(std::time::Duration::from_millis(1));
+                    continue;
+                }
+                feed.pull(&mut buf);
+                std::thread::sleep(std::time::Duration::from_millis(10));
+            }
+        });
+        Ok(())
+    }
+    fn stop(&mut self) {
+        *self.0.lock().unwrap() = true;
+    }
+}
+
+/// Once started, the sound's clock moves the picture on from the first frame, and a frame that
+/// isn't cached still stops the sound rather than being skipped.
+#[test]
+fn a_started_preview_follows_its_sound() {
+    let fake = Fake::default();
+    let (mut app, cid) = setup_long(true, &fake, 8.0);
+    let device = Playing::default();
+    let d = device.clone();
+    app.hooks.audio_device = Some(Box::new(move |_| Some(Box::new(d.clone()) as Box<dyn AudioDevice>)));
+    let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 30.0).build_eframe(|_| app);
+    h.state_mut().use_manual_clock();
+    h.run_steps(2);
+    assert!(until_started(&mut h) && h.state().audio.is_some(), "the sound started");
+    assert_eq!(audio_frame(&h, cid), Some(0), "from the first frame");
+    device.1.store(true, std::sync::atomic::Ordering::Release);
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
+    while frame(&h, cid) < 5 && std::time::Instant::now() < deadline && h.state().audio.is_some() {
+        step(&mut h);
+        std::thread::sleep(std::time::Duration::from_millis(10));
+    }
+    assert!(frame(&h, cid) >= 5, "the picture follows the sound's clock (at frame {})", frame(&h, cid));
+    h.state().frames.set_budget(0);
+    h.state().frames.clear();
+    step(&mut h);
+    assert!(h.state().audio.is_none() && h.state().playback.audio_held && h.state().playback.playing, "a stall stops the sound");
+    *device.0.lock().unwrap() = true;
+}
+
+/// A RAM preview that can't hold even one frame (none, or half of one): the start doesn't wait
+/// for frames that can never be cached. The sound isn't started on a frame that can't be shown
+/// (a stall would stop it at once): the preview goes on as a stalled one does.
+#[test]
+fn startup_does_not_wait_when_the_ram_preview_holds_no_frame() {
+    for budget in [0, 9216 / 2] {
+        let fake = Fake::default();
+        let (app, _) = setup_long(true, &fake, 8.0);
+        let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 30.0).build_eframe(|_| app);
+        h.state_mut().use_manual_clock();
+        h.run_steps(2);
+        h.state().frames.set_budget(budget);
+        h.state().frames.clear();
+        let now = h.state().now();
+        h.state_mut().play(now);
+        step(&mut h);
+        assert!(!h.state().playback.starting, "budget {budget}: no wait");
+        assert!(fake.0.lock().unwrap().0.is_none(), "budget {budget}: no sound started and dropped");
+        assert!(h.state().playback.playing && h.state().playback.audio_held, "budget {budget}: it goes on as a stalled preview");
+    }
+}
+
+/// A frame that never gets cached although the estimate says one fits (an Extended Viewer frame
+/// larger than the whole budget): the start gives up after STARTUP_LIMIT instead of holding the
+/// first frame for ever, without starting the sound on a frame it can't show.
+#[test]
+fn startup_gives_up_on_a_first_frame_that_never_caches() {
+    let fake = Fake::default();
+    let (mut h, cid, size) = extended_viewer(&fake);
+    let (comp_bytes, real_bytes) = (160 * 120 * 4, size[0] * size[1] * 4);
+    assert!(real_bytes > comp_bytes * 2, "Extended Viewer frames ({size:?}) are larger than the comp");
+    // Room for a comp-sized frame but not a real one: the current frame can never be cached.
+    let budget = (comp_bytes + real_bytes) / 2;
+    h.state().frames.set_budget(budget);
+    h.state().frames.clear();
+    let start = h.state().now();
+    h.state_mut().play(start);
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
+    while h.state().playback.starting && std::time::Instant::now() < deadline {
+        assert_eq!(frame(&h, cid), 0, "it holds the first frame while it waits");
+        step(&mut h);
+    }
+    let waited = h.state().now() - start;
+    assert!(!h.state().playback.starting, "it gave up waiting");
+    assert!((9.9..12.0).contains(&waited), "after about ten seconds ({waited:.2} s)");
+    assert!(fake.0.lock().unwrap().0.is_none(), "no sound started and dropped");
+    assert!(h.state().playback.playing && h.state().playback.audio_held, "it goes on as a stalled preview");
+}
+
+/// Adding markers while a preview sounds (Num*, one per beat) keeps the sound going (#1083): a
+/// marker changes no pixels, so no cached frame is dropped and no frame has to be rendered again
+/// (which would stop the sound until the frames ahead are cached).
+#[test]
+fn adding_markers_does_not_stop_the_sound() {
+    let fake = Fake::default();
+    let (app, cid) = setup(true, &fake);
+    // Everything is cached before the preview starts, so the sound starts at once.
+    let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 31.0).build_eframe(|_| app);
+    h.run_steps(2);
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
+    let now = h.ctx.input(|i| i.time);
+    h.state_mut().play(now);
+    while h.state().audio.is_none() && std::time::Instant::now() < deadline {
+        h.step();
+        std::thread::sleep(std::time::Duration::from_millis(1));
+    }
+    assert!(h.state().audio.is_some(), "the sound started");
+    for beat in 0..6 {
+        let t = 0.1 + 0.05 * beat as f64;
+        h.state_mut().session.execute("comp.addMarker", json!({"comp": cid.0, "time": t, "comment": "beat"})).unwrap();
+        h.step();
+        let app = h.state();
+        assert!(app.playback.playing && app.audio.is_some() && !app.playback.audio_held, "marker {beat}: still playing with sound");
+    }
+    assert_eq!(h.state().session.project.comp(cid).unwrap().markers.len(), 6);
 }
diff --git a/crates/ui-egui/tests/it/ui_batch_links.rs b/crates/ui-egui/tests/it/ui_batch_links.rs
new file mode 100644
index 000000000..5b2cea090
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_batch_links.rs
@@ -0,0 +1,209 @@
+//! Parent and Track Matte for several layers at once (#1260): on a selected layer's row, the
+//! Timeline's Parent and Track Matte menus and pick whips set every selected layer; on an
+//! unselected row, that layer alone. One undo step each; each layer keeps its own matte mode.
+
+use effectcraft_engine::Session;
+use effectcraft_engine::project::{LayerId, MatteKind};
+use effectcraft_ui_egui::EffectcraftApp;
+use egui::{Event, Modifiers, PointerButton, Pos2, Rect, pos2, vec2};
+use egui_kittest::Harness;
+use egui_kittest::kittest::Queryable as _;
+use serde_json::json;
+
+/// Solids A, B, C, P (moved and scaled, a parent) and the mattes X and Y; stacked Y, X, P, C, B, A
+/// from the top. The Track Matte column is shown.
+fn harness() -> (Harness<'static, EffectcraftApp>, [u64; 6]) {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Links", "width": 320, "height": 180, "duration": 4})).unwrap();
+    let ids = ["A", "B", "C", "P", "X", "Y"]
+        .map(|n| s.execute("layer.newSolid", json!({"name": n, "color": "#406080", "width": 40, "height": 40})).unwrap()["layer"].as_u64().unwrap());
+    s.execute("prop.set", json!({"layer": ids[3], "path": "transform/position", "value": [60, 40]})).unwrap();
+    s.execute("prop.set", json!({"layer": ids[3], "path": "transform/scale", "value": [50, 50]})).unwrap();
+    s.history.undo.clear();
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
+    h.state_mut().ui.timeline.show_modes = true;
+    h.state_mut().ui.timeline.columns_w = 900.0;
+    h.run_steps(3);
+    (h, ids)
+}
+
+fn rect(h: &Harness<'_, EffectcraftApp>, id: &str) -> Rect {
+    let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}"));
+    Rect::from_min_size(pos2(e.rect[0], e.rect[1]), vec2(e.rect[2], e.rect[3]))
+}
+
+fn press(h: &mut Harness<'_, EffectcraftApp>, at: Pos2, pressed: bool) {
+    h.event(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+}
+
+fn click(h: &mut Harness<'_, EffectcraftApp>, at: Pos2) {
+    h.event(Event::PointerMoved(at));
+    h.step();
+    press(h, at, true);
+    h.step();
+    press(h, at, false);
+    h.run_steps(3);
+}
+
+/// Open the menu at automation id `dropdown` and choose `item` in it.
+fn choose(h: &mut Harness<'_, EffectcraftApp>, dropdown: &str, item: &str) {
+    let menu = rect(h, dropdown);
+    // Other rows' menus show their choice as well ("No Track Matte"): the entry is a node the
+    // opened menu added.
+    let shown: Vec<Rect> = h.query_all_by_label(item).map(|n| n.rect()).collect();
+    click(h, menu.center());
+    // (The menu may open above it to fit the window: the entry nearest to it.)
+    let off = |r: &Rect| (r.center().y - menu.center().y).abs();
+    let at = h.query_all_by_label(item).map(|n| n.rect()).filter(|r| !shown.contains(r)).min_by(|a, b| off(a).total_cmp(&off(b)));
+    let at = at.unwrap_or_else(|| panic!("no {item} in the {dropdown} menu")).center();
+    click(h, at);
+}
+
+/// Drag the pick whip `whip` onto layer `onto`'s row.
+fn whip(h: &mut Harness<'_, EffectcraftApp>, whip: &str, onto: u64) {
+    let (from, to) = (rect(h, whip).center(), rect(h, &format!("timeline.layer.{onto}.row")).center());
+    h.event(Event::PointerMoved(from));
+    h.step();
+    press(h, from, true);
+    h.step();
+    for i in 1..=10 {
+        h.event(Event::PointerMoved(from + (to - from) * (i as f32 / 10.0)));
+        h.step();
+    }
+    press(h, to, false);
+    h.run_steps(3);
+}
+
+fn select(h: &mut Harness<'_, EffectcraftApp>, ids: &[u64]) {
+    h.state_mut().session.execute("layer.select", json!({"layers": ids})).unwrap();
+    h.run_steps(2);
+}
+
+fn parent(h: &Harness<'_, EffectcraftApp>, id: u64) -> Option<u64> {
+    h.state().session.active_comp().unwrap().layer(LayerId(id)).unwrap().parent.map(|p| p.0)
+}
+
+fn position(h: &Harness<'_, EffectcraftApp>, id: u64) -> [f64; 3] {
+    h.state().session.active_comp().unwrap().layer(LayerId(id)).unwrap().props.prop("transform/position").unwrap().value.as_vec3()
+}
+
+fn matte(h: &Harness<'_, EffectcraftApp>, id: u64) -> Option<(u64, MatteKind)> {
+    h.state().session.active_comp().unwrap().layer(LayerId(id)).unwrap().track_matte.map(|m| (m.layer.0, m.kind))
+}
+
+/// The project and its undo steps as they are now, to compare with after an undo or a refusal.
+fn mark(h: &Harness<'_, EffectcraftApp>) -> (std::sync::Arc<effectcraft_engine::project::Project>, usize) {
+    (h.state().session.project.clone(), h.state().session.history.undo.len())
+}
+
+fn unchanged(h: &Harness<'_, EffectcraftApp>, m: &(std::sync::Arc<effectcraft_engine::project::Project>, usize)) -> bool {
+    h.state().session.project.same_content(&m.0) && h.state().session.history.undo.len() == m.1
+}
+
+#[test]
+fn parent_menu_and_pick_whip_parent_the_selected_layers() {
+    let (mut h, [a, b, c, p, ..]) = harness();
+    let start = position(&h, a);
+    select(&mut h, &[a, b]);
+    let before = mark(&h);
+    // The Parent menu on A's (selected) row parents A and B, kept where they are.
+    choose(&mut h, &format!("timeline.layer.{a}.parent"), "3. P");
+    assert_eq!([parent(&h, a), parent(&h, b), parent(&h, c)], [Some(p), Some(p), None]);
+    assert!(position(&h, a) != start && position(&h, a) == position(&h, b), "both re-expressed in P's space");
+    assert_eq!(h.state().session.history.undo.len(), before.1 + 1, "one undo step");
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    h.run_steps(2);
+    assert!(unchanged(&h, &before), "one undo puts both back");
+    // The pick whip of an unselected row parents that layer alone.
+    whip(&mut h, &format!("timeline.layer.{c}.pickWhip"), p);
+    assert_eq!([parent(&h, a), parent(&h, b), parent(&h, c)], [None, None, Some(p)]);
+    // A selected row's whip parents the selection, less the parent itself if selected.
+    select(&mut h, &[a, b, p]);
+    whip(&mut h, &format!("timeline.layer.{a}.pickWhip"), p);
+    assert_eq!([parent(&h, a), parent(&h, b), parent(&h, p)], [Some(p), Some(p), None]);
+    // A cycle (P under A, while A is under P) is refused as a whole.
+    select(&mut h, &[p, c]);
+    let before = mark(&h);
+    choose(&mut h, &format!("timeline.layer.{p}.parent"), "6. A");
+    assert!(unchanged(&h, &before), "the refused parenting changed nothing");
+    assert_eq!([parent(&h, p), parent(&h, c)], [None, Some(p)]);
+}
+
+#[test]
+fn track_matte_menu_and_pick_whip_set_the_selected_layers_mattes() {
+    let (mut h, [a, b, c, _, x, y]) = harness();
+    h.state_mut().session.execute("layer.setTrackMatte", json!({"layer": a, "matte": x, "kind": "luma"})).unwrap();
+    h.state_mut().session.execute("layer.setTrackMatte", json!({"layer": b, "matte": x, "kind": "alpha"})).unwrap();
+    select(&mut h, &[a, b]);
+    let before = mark(&h);
+    // A new matte layer for both; each keeps its mode; C (not selected) keeps none.
+    choose(&mut h, &format!("timeline.layer.{a}.trackMatte"), "1. Y");
+    assert_eq!([matte(&h, a), matte(&h, b), matte(&h, c)], [Some((y, MatteKind::Luma)), Some((y, MatteKind::Alpha)), None]);
+    assert!(!h.state().session.active_comp().unwrap().layer(LayerId(y)).unwrap().switches.video, "Y is hidden as a matte");
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    h.run_steps(2);
+    assert!(unchanged(&h, &before), "one undo puts both mattes and Y's visibility back");
+    // A mode for both, then No Track Matte for both.
+    choose(&mut h, &format!("timeline.layer.{b}.trackMatte"), "Luma Inverted Matte");
+    assert_eq!([matte(&h, a), matte(&h, b)], [Some((x, MatteKind::LumaInverted)), Some((x, MatteKind::LumaInverted))]);
+    choose(&mut h, &format!("timeline.layer.{a}.trackMatte"), "No Track Matte");
+    assert_eq!([matte(&h, a), matte(&h, b)], [None, None]);
+    // The track matte pick whip: a selected row's sets the selection's, an unselected row's
+    // its own.
+    whip(&mut h, &format!("timeline.layer.{a}.trackMattePickWhip"), y);
+    assert_eq!([matte(&h, a), matte(&h, b), matte(&h, c)], [Some((y, MatteKind::Alpha)), Some((y, MatteKind::Alpha)), None]);
+    whip(&mut h, &format!("timeline.layer.{c}.trackMattePickWhip"), x);
+    assert_eq!([matte(&h, a), matte(&h, c)], [Some((y, MatteKind::Alpha)), Some((x, MatteKind::Alpha))]);
+}
+
+fn video(h: &Harness<'_, EffectcraftApp>, id: u64) -> bool {
+    h.state().session.active_comp().unwrap().layer(LayerId(id)).unwrap().switches.video
+}
+
+/// A locked layer in the selection stays selected, and keeps its parent, its transform and its
+/// matte while another selected row's menus and pick whips change the rest.
+#[test]
+fn locked_selected_layers_keep_their_parent_and_matte() {
+    let (mut h, [a, b, c, _, x, _]) = harness();
+    select(&mut h, &[a, b]);
+    // B alone (a click on its Lock switch locks the whole selection).
+    h.state_mut().session.execute("layer.setSwitch", json!({"layers": [b], "switch": "lock", "value": true})).unwrap();
+    h.run_steps(2);
+    let selected: Vec<u64> = h.state().session.state.selected_layers.iter().map(|l| l.0).collect();
+    assert!(h.state().session.active_comp().unwrap().layer(LayerId(b)).unwrap().switches.locked && selected == vec![a, b], "{selected:?}");
+    let b_position = position(&h, b);
+    choose(&mut h, &format!("timeline.layer.{a}.parent"), "3. P");
+    whip(&mut h, &format!("timeline.layer.{a}.pickWhip"), c);
+    choose(&mut h, &format!("timeline.layer.{a}.trackMatte"), "1. Y");
+    whip(&mut h, &format!("timeline.layer.{a}.trackMattePickWhip"), x);
+    assert_eq!((parent(&h, a), matte(&h, a)), (Some(c), Some((x, MatteKind::Alpha))), "A changed each time");
+    assert_eq!((parent(&h, b), matte(&h, b), position(&h, b)), (None, None, b_position), "locked B didn't");
+}
+
+/// Selected nulls (no Track Matte on their rows) get no matte from another row's menu or pick
+/// whip: at the top of the comp one used to refuse the whole mode change (nothing above it to
+/// take as a matte), at the bottom it took the layer above as its matte and hid it.
+#[test]
+fn selected_nulls_get_no_matte() {
+    let (mut h, [a, b, _, _, x, y]) = harness();
+    h.state_mut().session.execute("layer.setTrackMatte", json!({"layers": [a, b], "matte": x, "kind": "alpha"})).unwrap();
+    let n = h.state_mut().session.execute("layer.newNull", json!({"name": "N"})).unwrap()["layer"].as_u64().unwrap();
+    select(&mut h, &[a, b, n]);
+    choose(&mut h, &format!("timeline.layer.{a}.trackMatte"), "Luma Matte");
+    assert_eq!([matte(&h, a), matte(&h, b), matte(&h, n)], [Some((x, MatteKind::Luma)), Some((x, MatteKind::Luma)), None], "a null on top");
+    h.state_mut().session.execute("layer.arrange", json!({"layers": [n], "to": "back"})).unwrap();
+    select(&mut h, &[a, b, n]);
+    choose(&mut h, &format!("timeline.layer.{a}.trackMatte"), "Alpha Inverted Matte");
+    assert_eq!(
+        [matte(&h, a), matte(&h, b), matte(&h, n)],
+        [Some((x, MatteKind::AlphaInverted)), Some((x, MatteKind::AlphaInverted)), None],
+        "a null at the bottom"
+    );
+    assert!(video(&h, a), "A wasn't hidden as the null's matte");
+    whip(&mut h, &format!("timeline.layer.{a}.trackMattePickWhip"), y);
+    assert_eq!(
+        [matte(&h, a), matte(&h, b), matte(&h, n)],
+        [Some((y, MatteKind::AlphaInverted)), Some((y, MatteKind::AlphaInverted)), None],
+        "the pick whip too"
+    );
+}
diff --git a/crates/ui-egui/tests/it/ui_blank_context_menus.rs b/crates/ui-egui/tests/it/ui_blank_context_menus.rs
index a604ef2c2..84080be08 100644
--- a/crates/ui-egui/tests/it/ui_blank_context_menus.rs
+++ b/crates/ui-egui/tests/it/ui_blank_context_menus.rs
@@ -1,6 +1,8 @@
 //! Right-click actions in the blank Project and Timeline areas, and on Timeline property names.
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_engine::project::ItemKind;
+use effectcraft_ui_egui::dock::WorkspaceExt as _;
 use effectcraft_ui_egui::{Dialog, EffectcraftApp, dock::PanelKind};
 use egui::{Event, Modifiers, PointerButton, Pos2, Rect, pos2, vec2};
 use egui_kittest::{Harness, kittest::Queryable as _};
@@ -19,7 +21,7 @@ fn rect(h: &Harness<'_, EffectcraftApp>, id: &str) -> Rect {
 }
 fn snapshot(h: &mut Harness<'_, EffectcraftApp>, name: &str) {
     if let Ok(dir) = std::env::var("BLANK_CONTEXT_MENU_SNAPSHOTS") {
-        h.render().unwrap().save(format!("{dir}/{name}.png")).unwrap();
+        h.render_serialized().unwrap().save(format!("{dir}/{name}.png")).unwrap();
     }
 }
 fn right_click(h: &mut Harness<'_, EffectcraftApp>, p: Pos2) {
@@ -160,7 +162,7 @@ fn timeline_blank_menu_opens_current_comp_in_essential_graphics() {
         h.get_by_label("Open in Essential Graphics").click();
         h.run_steps(3);
         assert_eq!(h.state().session.state.essential_primary, Some(comp));
-        assert!(h.state().ui.dock.contains(PanelKind::EssentialGraphics));
+        assert!(h.state().ui.dock.is_docked(PanelKind::EssentialGraphics));
     }
 }
 
diff --git a/crates/ui-egui/tests/it/ui_camera_tracker.rs b/crates/ui-egui/tests/it/ui_camera_tracker.rs
index 2ab27fd6e..619d7c7c5 100644
--- a/crates/ui-egui/tests/it/ui_camera_tracker.rs
+++ b/crates/ui-egui/tests/it/ui_camera_tracker.rs
@@ -3,6 +3,7 @@
 //! The solve is a synthetic one written into the effect (the analysis itself is tested in the
 //! engine and track crates).
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_engine::effects::camera_tracker as ct;
 use effectcraft_engine::track::camtrack::{CameraSolve, ShotType, SolveMethod, SolvedFrame, SolvedPoint};
@@ -16,8 +17,9 @@ const H: f64 = 360.0;
 
 fn app() -> (EffectcraftApp, u64, u64) {
     let mut s = Session::default();
-    s.execute("comp.new", json!({"name": "Shot", "width": W, "height": H, "duration": 2})).unwrap();
-    let plate = s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("comp.new", json!({"name": "Shot", "width": W as u32, "height": H as u32, "duration": 2, "frameRate": 30})).unwrap();
+    let plate =
+        s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080", "width": W as u32, "height": H as u32})).unwrap()["layer"].as_u64().unwrap();
     let r = s.execute("effect.apply", json!({"effect": ct::ID, "layers": [plate]})).unwrap();
     let uid = r["effects"][0].as_u64().unwrap();
     // A synthetic solve: a static camera (focal 600) looking at a 6 × 4 grid of points on z = 1.
@@ -135,7 +137,11 @@ fn viewer_points_selection_and_effect_controls() {
     h.state_mut().show_panel(PanelKind::EffectControls);
     h.run_steps(4);
     let all = ids(&h);
-    for want in [format!("effectControls.cameraTracker.{uid}.analyze"), format!("effectControls.cameraTracker.{uid}.createCamera")] {
+    for want in [
+        format!("effectControls.cameraTracker.{uid}.analyze"),
+        format!("effectControls.cameraTracker.{uid}.createCamera"),
+        format!("effectControls.cameraTracker.{uid}.exportBlender"),
+    ] {
         assert!(all.contains(&want), "missing {want}");
     }
     // Tracker panel: Track Camera is available for the selected layer.
@@ -145,6 +151,57 @@ fn viewer_points_selection_and_effect_controls() {
     assert!(h.state().session.is_enabled("track.camera"));
 }
 
+#[test]
+fn blender_export_button_opens_python_dialog_and_writes_scene() {
+    use effectcraft_engine::project::{Footage, FootageKind, ItemKind, LayerId, LayerSource};
+    let (mut a, plate, uid) = app();
+    let cid = a.session.active_comp_id().unwrap();
+    a.session
+        .edit("video fixture", None, |p, _| {
+            let item = p.add_item(
+                "Video",
+                Default::default(),
+                None,
+                ItemKind::Footage(Footage {
+                    path: "/tmp/effectcraft-ui-synthetic.mp4".into(),
+                    kind: FootageKind::Video,
+                    width: W as u32,
+                    height: H as u32,
+                    has_video: true,
+                    duration: effectcraft_engine::time::Tick::from_seconds_f64(2.0),
+                    ..Default::default()
+                }),
+            );
+            p.comp_mut(cid).unwrap().layer_mut(LayerId(plate)).unwrap().source = LayerSource::Footage { item };
+            Ok(())
+        })
+        .unwrap();
+    a.session.camera_pending.clear();
+    let output = std::env::temp_dir().join(format!("effectcraft-ui-blender-{}.py", std::process::id()));
+    let selected_path = output.clone();
+    a.hooks.pick_save_file = Some(Box::new(move |name, ext| {
+        assert!(name.ends_with(".py"));
+        assert_eq!(ext, "py");
+        Some(selected_path.to_string_lossy().into_owned())
+    }));
+    let shot = std::env::var("EFFECTCRAFT_BLENDER_UI_SNAPSHOT").ok();
+    let builder = Harness::builder().with_size(egui::vec2(1600.0, 1000.0));
+    let builder = if shot.is_some() { builder.wgpu() } else { builder };
+    let _device = shot.is_some().then(crate::gpu_test::lock);
+    let mut h = builder.build_eframe(|_| a);
+    h.state_mut().show_panel(PanelKind::EffectControls);
+    h.run_steps(5);
+    let button = rect(&h, &format!("effectControls.cameraTracker.{uid}.exportBlender"));
+    if let Some(path) = shot {
+        h.render().expect("render export button").save(path).unwrap();
+    }
+    click(&mut h, button.center(), Default::default());
+    assert!(output.exists(), "UI export failed: {}", h.state().ui.status);
+    let script = std::fs::read_to_string(output).expect("clicking the export button saves a Python scene");
+    assert!(script.contains("def import_scene():"));
+    assert_eq!(h.state().session.active_comp().unwrap().layers.len(), 1, "export does not create a camera in the source project");
+}
+
 /// Drag with `button` from `from` to `to` in steps, then release.
 fn drag_with(h: &mut Harness<'_, EffectcraftApp>, button: egui::PointerButton, from: egui::Pos2, to: egui::Pos2) {
     h.input_mut().events.push(egui::Event::PointerMoved(from));
@@ -171,8 +228,8 @@ fn viewer_zooms_and_pans_over_the_track_points() {
     let zoom = h.state().ui.viewer.zoom;
     h.input_mut().events.push(egui::Event::PointerMoved(at));
     h.input_mut().events.push(egui::Event::MouseWheel {
-        unit: egui::MouseWheelUnit::Point,
-        delta: egui::vec2(0.0, 120.0),
+        unit: egui::MouseWheelUnit::Line,
+        delta: egui::vec2(0.0, 3.0),
         modifiers: Default::default(),
         phase: egui::TouchPhase::Move,
         source: egui::MouseWheelSource::Wheel,
@@ -217,6 +274,7 @@ fn settle(h: &mut Harness<'_, EffectcraftApp>) {
 #[test]
 #[ignore = "analyses the demo's 3D Showcase and renders with wgpu; run with --ignored (set EC_SNAPSHOT_DIR to keep PNGs)"]
 fn snapshot_showcase_track() {
+    let _device = crate::gpu_test::lock();
     let dir = std::env::var("EC_SNAPSHOT_DIR").ok();
     let mut s = Session::default();
     s.execute("file.openDemoProject", json!({})).unwrap();
@@ -235,7 +293,7 @@ fn snapshot_showcase_track() {
     h.input_mut().events.push(egui::Event::PointerMoved(r.center() + egui::vec2(12.0, 12.0)));
     h.run_steps(2);
     if let Some(d) = &dir {
-        h.render().expect("render").save(format!("{d}/camera_tracker_hover.png")).unwrap();
+        h.render_serialized().expect("render").save(format!("{d}/camera_tracker_hover.png")).unwrap();
     }
     let sel: Vec<u64> = pts.iter().take(5).filter_map(|i| i.rsplit('.').next()?.parse().ok()).collect();
     h.state_mut().session.execute("camera.selectPoints", json!({"points": sel})).unwrap();
@@ -243,6 +301,6 @@ fn snapshot_showcase_track() {
     h.state_mut().session.execute("layer.select", json!({"layers": ["#3"]})).unwrap();
     settle(&mut h);
     if let Some(d) = &dir {
-        h.render().expect("render").save(format!("{d}/camera_tracker_solid.png")).unwrap();
+        h.render_serialized().expect("render").save(format!("{d}/camera_tracker_solid.png")).unwrap();
     }
 }
diff --git a/crates/ui-egui/tests/it/ui_character_eyedropper.rs b/crates/ui-egui/tests/it/ui_character_eyedropper.rs
index a2c4c6d1f..ea4eecd99 100644
--- a/crates/ui-egui/tests/it/ui_character_eyedropper.rs
+++ b/crates/ui-egui/tests/it/ui_character_eyedropper.rs
@@ -1,8 +1,9 @@
 //! Character Fill and Stroke can sample a displayed Composition pixel.
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::{Session, commands::text_edit::layer_doc, project::LayerId};
 use effectcraft_ui_egui::{
     EffectcraftApp,
-    dock::{DockNode, PanelKind, SplitSize},
+    dock::{self, PanelKind, SplitSize},
     panels::viewer::comp_to_screen,
 };
 use egui::{Event, Modifiers, PointerButton, Pos2, pos2, vec2};
@@ -37,6 +38,7 @@ fn settle(h: &mut Harness<'_, EffectcraftApp>) {
 
 #[test]
 fn character_fill_eyedropper_samples_viewer_and_keeps_text_selection() {
+    let _device = crate::gpu_test::lock();
     let mut s = Session::default();
     s.execute("comp.new", json!({"width": 320, "height": 180, "duration": 2})).unwrap();
     s.execute("layer.newSolid", json!({"name": "Background", "color": "#20c040"})).unwrap();
@@ -64,6 +66,7 @@ fn character_fill_eyedropper_samples_viewer_and_keeps_text_selection() {
 
 #[test]
 fn character_stroke_eyedropper_samples_viewer() {
+    let _device = crate::gpu_test::lock();
     let mut s = Session::default();
     s.execute("comp.new", json!({"width": 320, "height": 180, "duration": 2})).unwrap();
     s.execute("layer.newSolid", json!({"name": "brat green", "color": "#8ACE00"})).unwrap();
@@ -71,12 +74,7 @@ fn character_stroke_eyedropper_samples_viewer() {
     s.execute("layer.setText", json!({"layer": text, "fill": [0.0, 0.0, 0.0], "size": 32.0})).unwrap();
     let mut app = EffectcraftApp::new(s);
     app.ui.viewer.show_layer_controls = false;
-    app.ui.dock = DockNode::Split {
-        vertical: false,
-        size: SplitSize::FixedB(360.0),
-        a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Composition], active: 0 }),
-        b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Character], active: 0 }),
-    };
+    app.ui.dock = dock::docked(dock::hsplit(SplitSize::FixedSecond(360.0), dock::tabs(&[PanelKind::Composition], 0), dock::tabs(&[PanelKind::Character], 0)));
     let builder = Harness::builder().with_size(vec2(1200.0, 760.0));
     let mut h = if std::env::var_os("EC_SNAPSHOT_DIR").is_some() { builder.wgpu().build_eframe(|_| app) } else { builder.build_eframe(|_| app) };
     h.state_mut().show_panel(PanelKind::Character);
@@ -84,7 +82,7 @@ fn character_stroke_eyedropper_samples_viewer() {
     settle(&mut h);
     click_auto(&mut h, "character.stroke.eyedropper");
     if let Ok(dir) = std::env::var("EC_SNAPSHOT_DIR") {
-        h.render().unwrap().save(format!("{dir}/character-eyedropper.png")).unwrap();
+        h.render_serialized().unwrap().save(format!("{dir}/character-eyedropper.png")).unwrap();
     }
     let sample = comp_to_screen(&h.ctx, [20.0, 20.0]).unwrap();
     click(&mut h, sample);
diff --git a/crates/ui-egui/tests/it/ui_character_stroke_order.rs b/crates/ui-egui/tests/it/ui_character_stroke_order.rs
new file mode 100644
index 000000000..db89f7c1a
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_character_stroke_order.rs
@@ -0,0 +1,77 @@
+//! The Character panel's stroke order menu: the two per-character orders and the two layer-wide
+//! ones (All Fills Over All Strokes, All Strokes Over All Fills), which set the text layer's
+//! More Options ▸ Fill & Stroke.
+use effectcraft_engine::{Session, commands::text_edit::layer_doc, project::LayerId};
+use effectcraft_ui_egui::{EffectcraftApp, dock::PanelKind};
+use egui::{
+    Event, Modifiers, PointerButton, Pos2,
+    accesskit::{Role, Toggled},
+    pos2, vec2,
+};
+use egui_kittest::{
+    Harness,
+    kittest::{NodeT, Queryable},
+};
+use serde_json::json;
+
+fn click(h: &mut Harness<'_, EffectcraftApp>, pos: Pos2) {
+    h.event(Event::PointerMoved(pos));
+    h.step();
+    for pressed in [true, false] {
+        h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+        h.step();
+    }
+    h.run_steps(2);
+}
+
+fn open_menu(h: &mut Harness<'_, EffectcraftApp>) {
+    let e = h.state().auto.find("character.strokeOverFill").unwrap_or_else(|| panic!("missing character.strokeOverFill")).clone();
+    click(h, pos2(e.rect[0] + e.rect[2] * 0.5, e.rect[1] + e.rect[3] * 0.5));
+}
+
+fn pick(h: &mut Harness<'_, EffectcraftApp>, label: &str) {
+    open_menu(h);
+    // A menu row: the dropdown shows the current order under the same label.
+    h.get_by_role_and_label(Role::Button, label).click();
+    h.run_steps(3);
+}
+
+fn fill_stroke(s: &mut Session, layer: u64) -> serde_json::Value {
+    s.execute("prop.get", json!({"layer": layer, "path": "text/moreOptions/fillStroke"})).unwrap()["value"].clone()
+}
+
+#[test]
+fn character_stroke_order_menu_sets_layer_fill_and_stroke() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 320, "height": 180, "duration": 2})).unwrap();
+    let text = s.execute("layer.newText", json!({"text": "Caption", "font": "Inter"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setText", json!({"layer": text, "applyStroke": true, "strokeWidth": 8.0, "strokeOverFill": false})).unwrap();
+    let mut app = EffectcraftApp::new(s);
+    app.set_workspace("Text");
+    let builder = Harness::builder().with_size(vec2(1600.0, 1400.0));
+    let mut h = if std::env::var_os("EC_SNAPSHOT_DIR").is_some() { builder.wgpu().build_eframe(|_| app) } else { builder.build_eframe(|_| app) };
+    h.state_mut().show_panel(PanelKind::Character);
+    h.run_steps(4);
+
+    pick(&mut h, "All Fills Over All Strokes");
+    assert_eq!(fill_stroke(&mut h.state_mut().session, text), json!(1));
+    pick(&mut h, "All Strokes Over All Fills");
+    assert_eq!(fill_stroke(&mut h.state_mut().session, text), json!(2));
+    // The menu shows the layer's order as the current one.
+    open_menu(&mut h);
+    assert_eq!(h.get_by_role_and_label(Role::Button, "All Strokes Over All Fills").accesskit_node().toggled(), Some(Toggled::True));
+    assert_eq!(h.get_by_role_and_label(Role::Button, "Fill Over Stroke").accesskit_node().toggled(), Some(Toggled::False));
+    if let Ok(dir) = std::env::var("EC_SNAPSHOT_DIR") {
+        h.render().unwrap().save(format!("{dir}/character-stroke-order.png")).unwrap();
+    }
+    h.key_press(egui::Key::Escape);
+    h.run_steps(2);
+
+    // A per-character order goes back to the Per Character Palette, in one undo step.
+    pick(&mut h, "Stroke Over Fill");
+    assert_eq!(fill_stroke(&mut h.state_mut().session, text), json!(0));
+    assert!(layer_doc(&h.state().session, LayerId(text)).unwrap().stroke_over_fill);
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(fill_stroke(&mut h.state_mut().session, text), json!(2));
+    assert!(!layer_doc(&h.state().session, LayerId(text)).unwrap().stroke_over_fill);
+}
diff --git a/crates/ui-egui/tests/it/ui_checkbox_drag.rs b/crates/ui-egui/tests/it/ui_checkbox_drag.rs
new file mode 100644
index 000000000..ba65e54dc
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_checkbox_drag.rs
@@ -0,0 +1,54 @@
+//! #1190: the shared drag gesture also reaches real dialog controls.
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::{EffectcraftApp, menus};
+use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
+use egui_kittest::{Harness, kittest::Queryable as _};
+use serde_json::json;
+
+fn pointer(h: &mut Harness<'_, EffectcraftApp>, at: Pos2, pressed: Option<bool>) {
+    h.event(Event::PointerMoved(at));
+    h.step();
+    if let Some(pressed) = pressed {
+        h.event(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+        h.step();
+    }
+    h.run_steps(2);
+}
+
+#[test]
+fn view_options_drag_checks_and_unchecks_neighbours() {
+    let mut session = Session::default();
+    session.prefs.disk.disk_cache_enabled = false;
+    session.execute("comp.new", json!({"width":32,"height":32,"duration":1})).unwrap();
+    let mut h = Harness::builder().with_size(vec2(1200.0, 900.0)).build_eframe(|_| EffectcraftApp::new(session));
+    h.state_mut().ui.viewer.rulers = false;
+    h.state_mut().ui.viewer.guides = true;
+    h.state_mut().ui.viewer.grid = false;
+    h.run_steps(3);
+    let ctx = h.ctx.clone();
+    menus::invoke(h.state_mut(), &ctx, "view.options", json!({})).unwrap();
+    h.run_steps(3);
+    let rulers = h.get_by_label("Rulers").rect().center();
+    let guides = h.get_by_label("Guides").rect().center();
+    let grid = h.get_by_label("Grid").rect().center();
+    pointer(&mut h, rulers, Some(true));
+    assert!(h.state().ui.viewer.rulers);
+    pointer(&mut h, guides, None);
+    assert!(h.state().ui.viewer.guides, "an already-checked neighbour stays checked");
+    pointer(&mut h, grid, None);
+    assert!(h.state().ui.viewer.grid);
+    pointer(&mut h, rulers, None);
+    pointer(&mut h, rulers, Some(false));
+    assert!(h.state().ui.viewer.rulers, "revisiting and releasing does not undo the change");
+    if let Ok(path) = std::env::var("CHECKBOX_REVIEW_PNG") {
+        h.render().unwrap().save(path).unwrap();
+    }
+    pointer(&mut h, grid, Some(true));
+    pointer(&mut h, guides, None);
+    pointer(&mut h, rulers, None);
+    pointer(&mut h, rulers, Some(false));
+    let viewer = &h.state().ui.viewer;
+    assert!(!viewer.rulers && !viewer.guides && !viewer.grid);
+    pointer(&mut h, guides, None);
+    assert!(!h.state().ui.viewer.guides, "hover after release does not change a checkbox");
+}
diff --git a/crates/ui-egui/tests/it/ui_comp_presets.rs b/crates/ui-egui/tests/it/ui_comp_presets.rs
index 0b0b30720..9e71f8fd7 100644
--- a/crates/ui-egui/tests/it/ui_comp_presets.rs
+++ b/crates/ui-egui/tests/it/ui_comp_presets.rs
@@ -83,3 +83,23 @@ fn a_preset_name_cannot_be_a_built_in_one() {
     assert!(h.state().auto.find("dialog.comp.presetName").is_none());
     assert!(preset_names(&h).is_empty());
 }
+
+/// Cancel and OK stay where they are when switching between Basic, Advanced and 3D Renderer,
+/// at any interface scale: the tabs' heights are measured, not assumed.
+#[test]
+fn composition_settings_buttons_stay_put_between_tabs() {
+    for zoom in [1.0, 1.3] {
+        let mut h = harness();
+        h.ctx.set_zoom_factor(zoom);
+        h.run_steps(3);
+        open_settings(&mut h);
+        let rects = |h: &Harness<'_, EffectcraftApp>| {
+            ["dialog.comp.ok", "dialog.comp.cancel", "dialog.comp.name"].map(|id| h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}")).rect)
+        };
+        let basic = rects(&h);
+        for tab in ["advanced", "renderer", "basic"] {
+            click(&mut h, &format!("dialog.comp.tab.{tab}"));
+            assert_eq!(rects(&h), basic, "{tab} at {zoom}x");
+        }
+    }
+}
diff --git a/crates/ui-egui/tests/it/ui_contrast.rs b/crates/ui-egui/tests/it/ui_contrast.rs
new file mode 100644
index 000000000..34352b5e5
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_contrast.rs
@@ -0,0 +1,92 @@
+//! Colour contrast of the theme tokens (docs/gaps.md gap 25), separate from the AccessKit audit:
+//! the WCAG 2 contrast ratio of the text, accent and focus colours against the backgrounds they
+//! are drawn on, for every theme. Text needs 4.5:1, the focus ring and control borders 3:1.
+//!
+//! Pairs that fall short today are listed in [`KNOWN_BELOW`] with the ratio measured when this was
+//! written. The list is a ratchet: a pair must not get worse, and a pair that reaches its target
+//! must leave the list. This checks the tokens, not what a panel really draws with them (text on
+//! a label colour, an image, a disabled control) and not colour-blindness.
+
+use effectcraft_ui_egui::theme::{ThemeKind, Tokens};
+use egui::Color32;
+
+/// WCAG 2 relative luminance of an sRGB colour.
+fn luminance(c: Color32) -> f64 {
+    let lin = |v: u8| {
+        let v = f64::from(v) / 255.0;
+        if v <= 0.039_28 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }
+    };
+    0.2126 * lin(c.r()) + 0.7152 * lin(c.g()) + 0.0722 * lin(c.b())
+}
+
+/// WCAG 2 contrast ratio of two opaque colours.
+fn ratio(a: Color32, b: Color32) -> f64 {
+    let (la, lb) = (luminance(a), luminance(b));
+    (la.max(lb) + 0.05) / (la.min(lb) + 0.05)
+}
+
+/// (name, foreground, background, minimum ratio)
+fn pairs(t: &Tokens) -> Vec<(&'static str, Color32, Color32, f64)> {
+    vec![
+        ("text on panel", t.text, t.panel_bg, 4.5),
+        ("text on field", t.text, t.field_bg, 4.5),
+        ("text on selected row", t.text, t.row_selected, 4.5),
+        ("text on row", t.text, t.row, 4.5),
+        ("dim text on panel", t.text_dim, t.panel_bg, 4.5),
+        ("faint text on panel", t.text_faint, t.panel_bg, 4.5),
+        ("active tab text on panel", t.tab_text_active, t.panel_bg, 4.5),
+        ("tab text on header", t.tab_text, t.header_bg, 4.5),
+        ("hot text on panel", t.hot_text, t.panel_bg, 4.5),
+        ("white on accent (primary button)", Color32::WHITE, t.accent, 4.5),
+        ("danger text on panel", t.danger, t.panel_bg, 4.5),
+        ("warning text on panel", t.warning, t.panel_bg, 4.5),
+        ("accent (focus ring) on panel", t.accent, t.panel_bg, 3.0),
+        ("focus colour on panel", t.focus, t.panel_bg, 3.0),
+        ("field border on panel", t.field_border, t.panel_bg, 3.0),
+        ("icon on panel", t.icon, t.panel_bg, 3.0),
+    ]
+}
+
+/// (theme, pair, ratio measured when written). Ratchet: never below the number; remove the entry
+/// when the pair reaches its target.
+const KNOWN_BELOW: &[(&str, &str, f64)] = &[
+    ("dark", "white on accent (primary button)", 3.46),
+    ("dark", "danger text on panel", 3.90),
+    ("dark", "field border on panel", 1.38),
+    ("darker", "white on accent (primary button)", 3.46),
+    ("darker", "danger text on panel", 4.37),
+    ("darker", "field border on panel", 1.55),
+    ("light", "faint text on panel", 4.46),
+    ("light", "white on accent (primary button)", 3.46),
+    ("light", "danger text on panel", 3.23),
+    ("light", "warning text on panel", 1.85),
+    ("light", "accent (focus ring) on panel", 2.78),
+    ("light", "focus colour on panel", 2.78),
+    ("light", "field border on panel", 1.86),
+];
+
+#[test]
+fn print_and_hold_the_theme_contrast() {
+    let mut failures = vec![];
+    for kind in [ThemeKind::Dark, ThemeKind::Darker, ThemeKind::Light] {
+        let t = Tokens::for_kind(kind);
+        for (name, fg, bg, min) in pairs(&t) {
+            let r = ratio(fg, bg);
+            let known = KNOWN_BELOW.iter().find(|(k, n, _)| *k == kind.name() && *n == name);
+            println!("{:<7} {name:<36} {r:>5.2}:1 (needs {min})", kind.name());
+            match known {
+                Some((_, _, floor)) => {
+                    if r + 0.005 < *floor {
+                        failures.push(format!("{} / {name}: {r:.2}:1 is worse than the known {floor:.2}:1", kind.name()));
+                    }
+                    if r >= min {
+                        failures.push(format!("{} / {name}: {r:.2}:1 now reaches {min}:1; remove it from KNOWN_BELOW", kind.name()));
+                    }
+                }
+                None if r < min => failures.push(format!("{} / {name}: {r:.2}:1 is below {min}:1", kind.name())),
+                None => {}
+            }
+        }
+    }
+    assert!(failures.is_empty(), "{}", failures.join("\n"));
+}
diff --git a/crates/ui-egui/tests/it/ui_dialog_preview.rs b/crates/ui-egui/tests/it/ui_dialog_preview.rs
new file mode 100644
index 000000000..ce5f2803e
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_dialog_preview.rs
@@ -0,0 +1,303 @@
+//! Preview in the settings dialogs that edit something that exists (After Effects' Preview
+//! checkbox): Solid Settings on a solid layer, Camera Settings, Light Settings and Composition
+//! Settings. A change of the draft reaches the project at once, so the canvas shows it while it is
+//! made; OK keeps it in one undo step, Cancel and Escape take it back, and with Preview off nothing
+//! is applied until OK. The window behind a previewing dialog is not dimmed, and the dialog opens
+//! at the lower right; the same dialogs creating something new keep the middle.
+
+use effectcraft_engine::Session;
+use effectcraft_engine::project::{ItemKind, LayerId, Resolution};
+use effectcraft_ui_egui::{Dialog, EffectcraftApp, menus};
+use egui::{Event, Key, Modifiers, PointerButton, Pos2, pos2};
+use egui_kittest::Harness;
+use egui_kittest::kittest::Queryable;
+use serde_json::{Value, json};
+
+fn harness(setup: impl FnOnce(&mut Session)) -> Harness<'static, EffectcraftApp> {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "duration": 10})).unwrap();
+    setup(&mut s);
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
+    h.run_steps(3);
+    h
+}
+
+fn open(h: &mut Harness<'_, EffectcraftApp>, id: &str, params: Value) {
+    let ctx = h.ctx.clone();
+    menus::invoke(h.state_mut(), &ctx, id, params).unwrap();
+    h.run_steps(3);
+}
+
+fn center(h: &Harness<'_, EffectcraftApp>, id: &str) -> Pos2 {
+    let r = h.state().auto.find(id).unwrap_or_else(|| panic!("no automation id {id}")).rect;
+    pos2(r[0] + r[2] / 2.0, r[1] + r[3] / 2.0)
+}
+
+fn click(h: &mut Harness<'_, EffectcraftApp>, id: &str) {
+    let p = center(h, id);
+    h.input_mut().events.push(Event::PointerMoved(p));
+    h.step();
+    h.input_mut().events.push(Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+    h.step();
+    h.input_mut().events.push(Event::PointerButton { pos: p, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+    h.run_steps(3);
+}
+
+fn escape(h: &mut Harness<'_, EffectcraftApp>) {
+    h.input_mut().events.push(Event::Key { key: Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
+    h.input_mut().events.push(Event::Key { key: Key::Escape, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE });
+    h.run_steps(3);
+}
+
+fn undo_len(h: &Harness<'_, EffectcraftApp>) -> usize {
+    h.state().session.history.undo.len()
+}
+
+fn solid_size(h: &Harness<'_, EffectcraftApp>, layer: u64) -> [u32; 2] {
+    let s = &h.state().session;
+    let l = s.active_comp().unwrap().layer(LayerId(layer)).unwrap();
+    let effectcraft_engine::project::LayerSource::Solid { item } = l.source else { panic!("not a solid") };
+    match &s.project.item(item).unwrap().kind {
+        ItemKind::Solid(so) => [so.width, so.height],
+        k => panic!("{k:?}"),
+    }
+}
+
+fn scalar(h: &Harness<'_, EffectcraftApp>, layer: u64, path: &str) -> f64 {
+    let s = &h.state().session;
+    let l = s.active_comp().unwrap().layer(LayerId(layer)).unwrap();
+    l.props.prop(path).unwrap().value_at(l.layer_time(s.time())).as_f64()
+}
+
+fn comp_width(h: &Harness<'_, EffectcraftApp>) -> u32 {
+    h.state().session.active_comp().unwrap().width
+}
+
+fn solid_setup(s: &mut Session) {
+    s.execute("layer.newSolid", json!({"name": "Box", "color": "#ff0000", "width": 100, "height": 100})).unwrap();
+}
+
+fn solid_layer(h: &Harness<'_, EffectcraftApp>) -> u64 {
+    h.state().session.active_comp().unwrap().layers[0].id.0
+}
+
+#[test]
+fn solid_settings_previews_live_and_cancel_and_escape_take_it_back() {
+    let mut h = harness(solid_setup);
+    let l = solid_layer(&h);
+    let undo = undo_len(&h);
+    open(&mut h, "layer.settings", json!({"layer": l}));
+    assert_eq!(h.state().dialog, Some(Dialog::SolidSettings));
+    assert!(h.state().auto.find("dialog.solid.preview").is_some(), "a Preview checkbox");
+    h.state_mut().dialog_state_mut().solid_size = [200, 150];
+    h.run_steps(3);
+    assert_eq!(solid_size(&h, l), [200, 150], "the canvas shows the new size before OK");
+    h.state_mut().dialog_state_mut().solid_size = [240, 120];
+    h.run_steps(3);
+    assert_eq!(solid_size(&h, l), [240, 120]);
+    assert_eq!(undo_len(&h), undo + 1, "however much was tried, the project is the original plus one command");
+    click(&mut h, "dialog.solid.cancel");
+    assert_eq!(h.state().dialog, None);
+    assert_eq!(solid_size(&h, l), [100, 100], "Cancel puts it back");
+    assert_eq!(undo_len(&h), undo, "and leaves no undo step");
+    // Escape does the same.
+    open(&mut h, "layer.settings", json!({"layer": l}));
+    h.state_mut().dialog_state_mut().solid_size = [200, 150];
+    h.run_steps(3);
+    assert_eq!(solid_size(&h, l), [200, 150]);
+    escape(&mut h);
+    assert_eq!(h.state().dialog, None);
+    assert_eq!(solid_size(&h, l), [100, 100]);
+    assert_eq!(undo_len(&h), undo);
+}
+
+#[test]
+fn solid_settings_ok_keeps_the_preview_as_one_undo_step() {
+    let mut h = harness(solid_setup);
+    let l = solid_layer(&h);
+    let undo = undo_len(&h);
+    open(&mut h, "layer.settings", json!({"layer": l}));
+    h.state_mut().dialog_state_mut().solid_size = [200, 150];
+    h.run_steps(3);
+    h.state_mut().dialog_state_mut().solid_size = [220, 130];
+    h.run_steps(3);
+    click(&mut h, "dialog.solid.ok");
+    assert_eq!(h.state().dialog, None);
+    assert_eq!(solid_size(&h, l), [220, 130]);
+    assert_eq!(undo_len(&h), undo + 1, "one undo step");
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(solid_size(&h, l), [100, 100], "undone in one go");
+}
+
+#[test]
+fn with_preview_off_nothing_is_applied_until_ok() {
+    let mut h = harness(solid_setup);
+    let l = solid_layer(&h);
+    let undo = undo_len(&h);
+    open(&mut h, "layer.settings", json!({"layer": l}));
+    h.state_mut().dialog_state_mut().solid_size = [200, 150];
+    h.run_steps(3);
+    assert_eq!(solid_size(&h, l), [200, 150]);
+    click(&mut h, "dialog.solid.preview");
+    assert!(!h.state().dialog_state().live.on);
+    assert_eq!(solid_size(&h, l), [100, 100], "switching Preview off takes the preview back");
+    assert_eq!(undo_len(&h), undo);
+    h.state_mut().dialog_state_mut().solid_size = [260, 140];
+    h.run_steps(3);
+    assert_eq!(solid_size(&h, l), [100, 100], "nothing is applied while editing");
+    click(&mut h, "dialog.solid.ok");
+    assert_eq!(solid_size(&h, l), [260, 140], "OK applies the draft");
+    assert_eq!(undo_len(&h), undo + 1);
+}
+
+#[test]
+fn camera_settings_preview() {
+    let mut h = harness(|s| {
+        s.execute("layer.newCamera", json!({})).unwrap();
+    });
+    let l = solid_layer(&h);
+    let before = scalar(&h, l, "cameraOptions/zoom");
+    let undo = undo_len(&h);
+    open(&mut h, "layer.cameraSettings", json!({"layer": l}));
+    assert_eq!(h.state().dialog, Some(Dialog::CameraSettings));
+    assert!(h.state().auto.find("dialog.camera.preview").is_some());
+    h.state_mut().dialog_state_mut().camera.zoom = before + 500.0;
+    h.run_steps(3);
+    assert!((scalar(&h, l, "cameraOptions/zoom") - (before + 500.0)).abs() < 1e-6, "the zoom changes live");
+    assert_eq!(undo_len(&h), undo + 1);
+    click(&mut h, "dialog.camera.cancel");
+    assert!((scalar(&h, l, "cameraOptions/zoom") - before).abs() < 1e-6, "Cancel puts the zoom back");
+    assert_eq!(undo_len(&h), undo);
+    open(&mut h, "layer.cameraSettings", json!({"layer": l}));
+    h.state_mut().dialog_state_mut().camera.zoom = before + 300.0;
+    h.run_steps(3);
+    click(&mut h, "dialog.camera.ok");
+    assert!((scalar(&h, l, "cameraOptions/zoom") - (before + 300.0)).abs() < 1e-6, "OK keeps it");
+    assert_eq!(undo_len(&h), undo + 1);
+}
+
+#[test]
+fn light_settings_preview() {
+    let mut h = harness(|s| {
+        s.execute("layer.newLight", json!({"kind": "Point"})).unwrap();
+    });
+    let l = solid_layer(&h);
+    let before = scalar(&h, l, "lightOptions/intensity");
+    let undo = undo_len(&h);
+    open(&mut h, "layer.lightSettings", json!({"layer": l}));
+    assert_eq!(h.state().dialog, Some(Dialog::LightSettings));
+    assert!(h.state().auto.find("dialog.light.preview").is_some());
+    h.state_mut().dialog_state_mut().light.intensity = before + 37.0;
+    h.run_steps(3);
+    assert!((scalar(&h, l, "lightOptions/intensity") - (before + 37.0)).abs() < 1e-6, "the intensity changes live");
+    escape(&mut h);
+    assert_eq!(h.state().dialog, None);
+    assert!((scalar(&h, l, "lightOptions/intensity") - before).abs() < 1e-6, "Escape puts it back");
+    assert_eq!(undo_len(&h), undo);
+}
+
+#[test]
+fn composition_settings_preview() {
+    let mut h = harness(|_| {});
+    let before = comp_width(&h);
+    let undo = undo_len(&h);
+    open(&mut h, "comp.settings", json!({}));
+    assert_eq!(h.state().dialog, Some(Dialog::CompSettings));
+    assert!(h.state().auto.find("dialog.comp.preview").is_some());
+    h.state_mut().dialog_state_mut().comp.width = before + 80;
+    h.run_steps(3);
+    assert_eq!(comp_width(&h), before + 80, "the comp is resized live");
+    click(&mut h, "dialog.comp.cancel");
+    assert_eq!(comp_width(&h), before, "Cancel puts the size back");
+    assert_eq!(undo_len(&h), undo);
+    open(&mut h, "comp.settings", json!({}));
+    h.state_mut().dialog_state_mut().comp.width = before + 40;
+    h.run_steps(3);
+    click(&mut h, "dialog.comp.ok");
+    assert_eq!(comp_width(&h), before + 40, "OK keeps it");
+    assert_eq!(undo_len(&h), undo + 1, "in one undo step");
+}
+
+/// The Resolution is no part of the Composition Settings command, so a preview never applies it:
+/// OK has to, also when it keeps a preview of another field.
+#[test]
+fn composition_settings_ok_after_a_preview_still_applies_the_resolution() {
+    let mut h = harness(|_| {});
+    let before = comp_width(&h);
+    open(&mut h, "comp.settings", json!({}));
+    h.state_mut().dialog_state_mut().comp.width = before + 80;
+    h.run_steps(3);
+    assert_eq!(comp_width(&h), before + 80, "the preview applied the width");
+    h.state_mut().dialog_state_mut().comp.resolution = Resolution::Half;
+    h.run_steps(3);
+    click(&mut h, "dialog.comp.ok");
+    assert_eq!(comp_width(&h), before + 80);
+    assert_eq!(h.state().session.active_comp().unwrap().resolution, Resolution::Half, "OK applied the Resolution");
+}
+
+/// An edit made in the same frame as OK (Enter) is not in the last preview yet: OK brings the
+/// project up to the draft it finds instead of keeping the older preview.
+#[test]
+fn ok_in_the_frame_of_an_edit_keeps_the_edit_not_the_older_preview() {
+    let mut h = harness(solid_setup);
+    let l = solid_layer(&h);
+    open(&mut h, "layer.settings", json!({"layer": l}));
+    h.state_mut().dialog_state_mut().solid_size = [200, 150];
+    h.run_steps(3);
+    assert_eq!(solid_size(&h, l), [200, 150]);
+    h.state_mut().dialog_state_mut().solid_size = [240, 120];
+    h.input_mut().events.push(Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
+    h.step();
+    h.run_steps(2);
+    assert_eq!(h.state().dialog, None);
+    assert_eq!(solid_size(&h, l), [240, 120], "OK kept the draft it found, not the earlier preview");
+}
+
+/// A previewing dialog opens at the lower right so the canvas stays in view; the same dialogs
+/// creating something new keep the middle and have no Preview.
+#[test]
+fn previewing_dialogs_open_at_the_lower_right_and_new_ones_in_the_middle() {
+    let mut h = harness(solid_setup);
+    let l = solid_layer(&h);
+    open(&mut h, "layer.settings", json!({"layer": l}));
+    let ok = center(&h, "dialog.solid.ok");
+    assert!(ok.x > 800.0 && ok.y > 500.0, "Solid Settings on a layer is in the lower right: {ok:?}");
+    click(&mut h, "dialog.solid.cancel");
+    open(&mut h, "layer.newSolid", json!({}));
+    assert_eq!(h.state().dialog, Some(Dialog::SolidSettings));
+    assert!(h.state().auto.find("dialog.solid.preview").is_none(), "a new solid has no Preview");
+    let ok = center(&h, "dialog.solid.ok");
+    assert!(ok.x < 1000.0, "New Solid stays in the middle: {ok:?}");
+}
+
+fn drag(h: &mut Harness<'_, EffectcraftApp>, from: Pos2, to: Pos2) {
+    h.input_mut().events.push(Event::PointerMoved(from));
+    h.step();
+    h.input_mut().events.push(Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+    h.step();
+    for k in 1..=6 {
+        h.input_mut().events.push(Event::PointerMoved(from + (to - from) * (k as f32 / 6.0)));
+        h.step();
+    }
+    h.input_mut().events.push(Event::PointerButton { pos: to, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+    h.run_steps(3);
+}
+
+/// A previewing dialog opens at the lower right, but it can be dragged by its title to wherever
+/// the canvas needs to be seen, and the preview keeps working from there.
+#[test]
+fn a_previewing_dialog_can_be_dragged_by_its_title() {
+    let mut h = harness(solid_setup);
+    let l = solid_layer(&h);
+    open(&mut h, "layer.settings", json!({"layer": l}));
+    let ok = center(&h, "dialog.solid.ok");
+    let title = h.get_by_label("Solid Settings").rect().center();
+    drag(&mut h, title, title + egui::vec2(-500.0, -300.0));
+    let moved = center(&h, "dialog.solid.ok");
+    assert!(moved.x < ok.x - 300.0 && moved.y < ok.y - 150.0, "the dialog followed the drag: {ok:?} -> {moved:?}");
+    // Still previewing, and the position is kept from frame to frame.
+    h.state_mut().dialog_state_mut().solid_size = [200, 150];
+    h.run_steps(3);
+    assert_eq!(solid_size(&h, l), [200, 150]);
+    assert_eq!(center(&h, "dialog.solid.ok"), moved, "it stays where it was put");
+}
diff --git a/crates/ui-egui/tests/it/ui_dock_resize.rs b/crates/ui-egui/tests/it/ui_dock_resize.rs
index 3dc44b708..11ca740cb 100644
--- a/crates/ui-egui/tests/it/ui_dock_resize.rs
+++ b/crates/ui-egui/tests/it/ui_dock_resize.rs
@@ -1,10 +1,12 @@
 //! Shared pane resizing in the full application, including application shortcut ownership.
 
+use crate::gpu_test::RenderSerial;
+use craft_ui::docking::{Divider, DockArea, Hit};
 use effectcraft_engine::Session;
 use effectcraft_ui_egui::EffectcraftApp;
-use effectcraft_ui_egui::dock::{DockNode, PanelKind, SplitSize};
+use effectcraft_ui_egui::dock::{self, Node, PanelKind, SplitSize};
 use effectcraft_ui_egui::theme::ThemeKind;
-use egui::{Event, Id, Key, Modifiers, PointerButton, Rect, pos2, vec2};
+use egui::{Event, Key, Modifiers, PointerButton, Rect, pos2, vec2};
 use egui_kittest::Harness;
 use serde_json::json;
 
@@ -15,7 +17,7 @@ fn snapshots(h: &mut Harness<'_, EffectcraftApp>, directory: Option<&std::path::
         let ctx = h.ctx.clone();
         h.state_mut().set_theme(&ctx, theme);
         h.run_steps(3);
-        h.render().unwrap().save(directory.join(format!("effectcraft-{phase}-{name}.png"))).unwrap();
+        h.render_serialized().unwrap().save(directory.join(format!("effectcraft-{phase}-{name}.png"))).unwrap();
     }
     let ctx = h.ctx.clone();
     h.state_mut().set_theme(&ctx, ThemeKind::Dark);
@@ -23,14 +25,15 @@ fn snapshots(h: &mut Harness<'_, EffectcraftApp>, directory: Option<&std::path::
 }
 
 fn first_size(h: &Harness<'_, EffectcraftApp>) -> f32 {
-    match h.state().ui.dock {
-        DockNode::Split { size: SplitSize::FixedA(value), .. } => value,
+    match &h.state().ui.dock.layout.root {
+        Some(Node::Split { size: SplitSize::FixedFirst(value), .. }) => *value,
         ref other => panic!("fixed-size mode changed: {other:?}"),
     }
 }
 
 #[test]
 fn focused_dock_resize_owns_arrows_and_keeps_pointer_dragging() {
+    let _device = crate::gpu_test::lock();
     let mut session = Session::default();
     session.execute("comp.new", json!({"name": "Split test", "width": 160, "height": 90, "duration": 1})).unwrap();
     session.execute("layer.newSolid", json!({"name": "Selected", "color": [1.0, 0.0, 0.0, 1.0]})).unwrap();
@@ -45,16 +48,12 @@ fn focused_dock_resize_owns_arrows_and_keeps_pointer_dragging() {
     h.run_steps(4);
     snapshots(&mut h, directory.as_deref(), "workspace");
     h.state_mut().ui.focused = PanelKind::Composition;
-    h.state_mut().ui.dock = DockNode::Split {
-        vertical: false,
-        size: SplitSize::FixedA(400.0),
-        a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project], active: 0 }),
-        b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Composition], active: 0 }),
-    };
+    h.state_mut().ui.dock =
+        dock::docked(dock::hsplit(SplitSize::FixedFirst(400.0), dock::tabs(&[PanelKind::Project], 0), dock::tabs(&[PanelKind::Composition], 0)));
     h.run_steps(3);
     let before_project = h.state().session.project.clone();
     let before_times = h.state().session.state.times.clone();
-    let id = Id::unique(("dock-gutter", String::new()));
+    let id = DockArea::<PanelKind>::hit_id(effectcraft_ui_egui::dock_ui::area_id(), &Hit::Divider(Divider::Split(Vec::new())));
     h.ctx.memory_mut(|memory| memory.request_focus(id));
     h.run_steps(2);
     assert_eq!(h.ctx.memory(|memory| memory.focused()), Some(id));
diff --git a/crates/ui-egui/tests/it/ui_drag_drop.rs b/crates/ui-egui/tests/it/ui_drag_drop.rs
index e405bf777..42d0273f8 100644
--- a/crates/ui-egui/tests/it/ui_drag_drop.rs
+++ b/crates/ui-egui/tests/it/ui_drag_drop.rs
@@ -124,6 +124,44 @@ fn alt_dragging_a_project_item_replaces_the_layer_source() {
     assert_eq!(layer.name, "Top", "the layer keeps its name");
 }
 
+/// Alt/Option-dropping a Project item on the Composition viewer replaces the source of the layer
+/// under the pointer, as in the Timeline, instead of adding a layer (#2173).
+#[test]
+fn alt_dropping_a_project_item_on_the_viewer_replaces_the_layer_source() {
+    use effectcraft_engine::project::{ItemId, LayerId, LayerSource};
+    let (mut h, clip) = harness();
+    let item = rect(&h, &format!("project.item.{clip}.name")).center();
+    let to = comp_to_screen(&h.ctx, [160.0, 90.0]).unwrap();
+    // The three solids overlap completely, so the topmost one is under the pointer.
+    let (top, middle, bottom) = (layer_id(&h, "Top"), layer_id(&h, "Middle"), layer_id(&h, "Bottom"));
+    let source = |h: &Harness<'_, EffectcraftApp>, id: u64| h.state().session.active_comp().unwrap().layer(LayerId(id)).unwrap().source.clone();
+    let (middle_before, bottom_before) = (source(&h, middle), source(&h, bottom));
+    let before = stack(&h);
+    drag(&mut h, item, to, Modifiers::ALT);
+    assert_eq!(stack(&h), before, "no layer is added");
+    assert_eq!(source(&h, top), LayerSource::Comp { item: ItemId(clip) }, "the layer under the pointer takes the new source");
+    assert_eq!(source(&h, middle), middle_before, "the layer below it keeps its source");
+    assert_eq!(source(&h, bottom), bottom_before, "the bottom layer keeps its source");
+}
+
+/// A locked layer under the pointer refuses the Alt-drop; the layer behind it is not replaced
+/// instead (#2173).
+#[test]
+fn alt_dropping_on_a_locked_layer_in_the_viewer_replaces_nothing() {
+    use effectcraft_engine::project::LayerId;
+    let (mut h, clip) = harness();
+    let item = rect(&h, &format!("project.item.{clip}.name")).center();
+    let to = comp_to_screen(&h.ctx, [160.0, 90.0]).unwrap();
+    let top = layer_id(&h, "Top");
+    h.state_mut().session.execute("layer.setSwitch", json!({"layers": [top], "switch": "locked", "value": true})).unwrap();
+    h.run_steps(3);
+    let sources = |h: &Harness<'_, EffectcraftApp>| h.state().session.active_comp().unwrap().layers.iter().map(|l| l.source.clone()).collect::<Vec<_>>();
+    let before = sources(&h);
+    drag(&mut h, item, to, Modifiers::ALT);
+    assert_eq!(sources(&h), before, "no layer takes the new source");
+    assert!(h.state().session.active_comp().unwrap().layer(LayerId(top)).unwrap().switches.locked);
+}
+
 /// Ctrl+Alt+/ (Cmd+Opt+/ on macOS) replaces every selected layer's source with the Project panel
 /// selection (#991).
 #[test]
@@ -198,7 +236,7 @@ fn dragging_selected_project_items_adds_every_item_to_the_viewer() {
     let to = comp_to_screen(&h.ctx, [80.0, 45.0]).unwrap();
     drag(&mut h, from, to, Modifiers::NONE);
     assert_eq!(stack(&h), ["Clip", "Other", "Top", "Middle", "Bottom"]);
-    for layer in &h.state().session.active_comp().unwrap().layers[..2] {
+    for layer in h.state().session.active_comp().unwrap().layers.iter().take(2) {
         let Some(KV::Vec3(p)) = layer.props.prop("transform/position").map(|p| p.value.clone()) else { panic!("no position") };
         let tol = 1.0 / last_fit(&h.ctx) as f64 + 1e-6;
         assert!((p[0] - 80.0).abs() <= tol && (p[1] - 45.0).abs() <= tol, "{p:?}");
@@ -463,6 +501,19 @@ fn dropped_file_on_viewer_imports_and_adds_layer_at_pointer() {
     assert!((p[0] - 80.0).abs() <= tol && (p[1] - 45.0).abs() <= tol, "{p:?}");
 }
 
+/// #2588: a file dropped on the Timeline joins the composition the panel shows, as it does on the
+/// viewer; the import places the layer.
+#[test]
+fn dropped_file_on_the_timeline_becomes_a_layer() {
+    let (mut h, _) = harness();
+    h.state_mut().session.importer = Some(Arc::new(Gated { started: AtomicUsize::new(0), allow: Arc::new(AtomicUsize::new(usize::MAX)) }));
+    h.event(Event::PointerMoved(rect(&h, "panel.Timeline").center()));
+    h.step();
+    h.input_mut().dropped_files.push(Arc::new(Dropped(std::env::temp_dir().join("timeline-drop.mp4"))));
+    h.run_steps(2);
+    step_until(&mut h, |h| h.state().session.active_comp().is_some_and(|c| c.layers.iter().any(|l| l.name == "timeline-drop.mp4")));
+}
+
 /// #678: a dropped Photoshop file asks how to import it, as File ▸ Import ▸ File… does; the
 /// Import Kind starts at Settings ▸ Import ▸ Default Drag Import As, and OK imports the drop.
 #[test]
@@ -594,6 +645,27 @@ fn import_dialog_offers_the_image_sequence_option() {
     let _ = std::fs::remove_dir_all(&dir);
 }
 
+/// #2573: the empty Composition viewer's New Composition From Footage imports the picked file
+/// (through the Import Image Sequence question a numbered still asks) and makes a composition
+/// of it, as in After Effects.
+#[test]
+fn new_composition_from_footage_makes_a_comp_of_the_picked_file() {
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(Session::default()));
+    h.run_steps(3);
+    let dir = frames("fromfootage", 2);
+    let pick = dir.join("frame_0002.png").to_string_lossy().to_string();
+    h.state_mut().session.importer = Some(Arc::new(Stills));
+    h.state_mut().hooks.pick_files = Some(Box::new(move |_: &[&str]| vec![pick.clone()]));
+    click_id(&mut h, "viewer.empty.import");
+    assert_eq!(h.state().dialog, Some(effectcraft_ui_egui::Dialog::Form));
+    click_id(&mut h, "form.ok");
+    step_until(&mut h, |h| h.state().session.active_comp().is_some());
+    let comp = h.state().session.active_comp().unwrap();
+    assert_eq!((comp.width, comp.height), (64, 32));
+    assert_eq!(comp.layers.iter().map(|l| l.name.as_str()).collect::<Vec<_>>(), ["frame_0002.png"]);
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
 /// #297: a folder of frames dropped on the window arrives as one image sequence, and Interpret
 /// Footage shows its frames and Start Timecode (missing frames always show colour bars, as in
 /// After Effects: there is no Missing Frames choice). #431: dropped files import as stills, one
diff --git a/crates/ui-egui/tests/it/ui_effects_presets_keyboard.rs b/crates/ui-egui/tests/it/ui_effects_presets_keyboard.rs
new file mode 100644
index 000000000..bf354ac00
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_effects_presets_keyboard.rs
@@ -0,0 +1,279 @@
+//! Effects & Presets keyboard operation and accessible names (docs/gaps.md gap 25): the list is one
+//! Tab stop; the arrow keys, Home / End, Right / Left, Enter and Space work it; the focus follows
+//! the cursor; rows are tree items with a name, a selected state, a depth and (folders) an open
+//! state; the favourite star is a named button.
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use egui::accesskit::Role;
+use egui::{Event, Key, Modifiers, Pos2, pos2};
+use egui_kittest::Harness;
+use egui_kittest::kittest::{NodeT, Queryable};
+use serde_json::json;
+
+fn harness() -> Harness<'static, EffectcraftApp> {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Red", "color": "#c04040"})).unwrap();
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
+    h.state_mut().show_panel(PanelKind::EffectsPresets);
+    h.run_steps(4);
+    h
+}
+
+fn center(h: &Harness<'_, EffectcraftApp>, id: &str) -> Pos2 {
+    let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}")).clone();
+    pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0)
+}
+
+fn click(h: &mut Harness<'_, EffectcraftApp>, id: &str) {
+    let p = center(h, id);
+    h.input_mut().events.push(Event::PointerMoved(p));
+    h.step();
+    for pressed in [true, false] {
+        h.input_mut().events.push(Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+        h.step();
+    }
+    h.run_steps(3);
+}
+
+fn key(h: &mut Harness<'_, EffectcraftApp>, key: Key, modifiers: Modifiers) {
+    for pressed in [true, false] {
+        h.input_mut().events.push(Event::Key { key, physical_key: None, pressed, repeat: false, modifiers });
+        h.step();
+    }
+    h.run_steps(3);
+}
+
+/// The role and name of the node that has the keyboard focus.
+fn focused(h: &Harness<'_, EffectcraftApp>) -> Option<(Role, String)> {
+    h.root().children_recursive().find(|n| n.is_focused()).map(|n| (n.accesskit_node().role(), n.accesskit_node().label().unwrap_or_default()))
+}
+
+fn selected_rows(h: &Harness<'_, EffectcraftApp>) -> Vec<String> {
+    let panel = h.state().auto.find("panel.EffectsPresets").expect("the panel is drawn").rect;
+    let panel = egui::Rect::from_min_size(pos2(panel[0], panel[1]), egui::vec2(panel[2], panel[3]));
+    h.root()
+        .children_recursive()
+        .filter(|n| n.accesskit_node().role() == Role::TreeItem && n.accesskit_node().is_selected() == Some(true))
+        .filter(|n| n.accesskit_node().bounding_box().is_some_and(|b| panel.contains(pos2(b.x0 as f32 + 1.0, b.y0 as f32 + 1.0))))
+        .map(|n| n.accesskit_node().label().unwrap_or_default())
+        .collect()
+}
+
+/// Put the keyboard on the first row the way Tab does: from the search field, the menu button,
+/// then the list.
+fn tab_into_list(h: &mut Harness<'_, EffectcraftApp>) {
+    h.get_by_label("Search effects and presets").focus();
+    h.run_steps(3);
+    key(h, Key::Tab, Modifiers::NONE);
+    assert_eq!(focused(h).map(|f| f.1), Some("Effects & Presets options".to_string()), "Tab leaves the search field for the options button");
+    key(h, Key::Tab, Modifiers::NONE);
+}
+
+#[test]
+fn tab_reaches_the_list_once_and_leaves_it() {
+    let mut h = harness();
+    tab_into_list(&mut h);
+    let (role, name) = focused(&h).expect("a row has the focus");
+    assert_eq!(role, Role::TreeItem);
+    assert!(!name.is_empty());
+    // The first row is a folder: no star. The next Tab leaves the list instead of walking the
+    // hundreds of effects.
+    key(&mut h, Key::Tab, Modifiers::NONE);
+    let after = focused(&h);
+    assert!(after.as_ref().is_none_or(|(r, _)| *r != Role::TreeItem), "the second Tab is past the list: {after:?}");
+}
+
+#[test]
+fn arrows_home_end_move_the_cursor_and_the_focus() {
+    let mut h = harness();
+    tab_into_list(&mut h);
+    let first = focused(&h).unwrap().1;
+    assert_eq!(selected_rows(&h), Vec::<String>::new(), "Tab alone selects nothing");
+    key(&mut h, Key::ArrowDown, Modifiers::NONE);
+    let second = focused(&h).unwrap().1;
+    assert_ne!(first, second, "Down Arrow moves to the next row");
+    assert_eq!(selected_rows(&h), vec![second.clone()], "the row the cursor is on is selected");
+    key(&mut h, Key::ArrowUp, Modifiers::NONE);
+    assert_eq!(focused(&h).unwrap().1, first);
+    key(&mut h, Key::End, Modifiers::NONE);
+    let last = focused(&h).unwrap().1;
+    assert_ne!(last, first, "End goes to the last row");
+    key(&mut h, Key::ArrowDown, Modifiers::NONE);
+    assert_eq!(focused(&h).unwrap().1, last, "Down Arrow stays on the last row");
+    key(&mut h, Key::Home, Modifiers::NONE);
+    assert_eq!(focused(&h).unwrap().1, first, "Home goes to the first row");
+    key(&mut h, Key::PageDown, Modifiers::NONE);
+    assert_ne!(focused(&h).unwrap().1, first, "Page Down moves a page");
+    // The cursor row is scrolled into view: its node is on screen.
+    let name = focused(&h).unwrap().1;
+    let r = h.get_by_label(&name).rect();
+    assert!(r.min.y >= 0.0 && r.max.y <= 1000.0, "the focused row is on screen: {r:?}");
+}
+
+#[test]
+fn right_and_left_open_and_close_folders_and_step_through_the_tree() {
+    let mut h = harness();
+    h.state_mut().ui.effects_search.clear();
+    tab_into_list(&mut h);
+    // Walk to a category folder (not the presets folder).
+    let mut guard = 0;
+    loop {
+        let n = focused(&h).unwrap().1;
+        if n == "Blur & Sharpen" {
+            break;
+        }
+        key(&mut h, Key::ArrowDown, Modifiers::NONE);
+        guard += 1;
+        assert!(guard < 40, "no Blur & Sharpen folder reached");
+    }
+    let folder = h.get_by_label("Blur & Sharpen");
+    assert_eq!(folder.accesskit_node().data().is_expanded(), Some(false));
+    assert_eq!(folder.accesskit_node().data().level(), Some(1));
+    key(&mut h, Key::ArrowRight, Modifiers::NONE);
+    assert!(h.state().ui.effects_open.contains("Blur & Sharpen"), "Right Arrow opens the folder");
+    assert_eq!(h.get_by_label("Blur & Sharpen").accesskit_node().data().is_expanded(), Some(true));
+    key(&mut h, Key::ArrowRight, Modifiers::NONE);
+    let child = focused(&h).unwrap();
+    assert_eq!(child.0, Role::TreeItem);
+    assert_ne!(child.1, "Blur & Sharpen", "Right Arrow on an open folder steps into it");
+    assert_eq!(h.get_by_label(&child.1).accesskit_node().data().level(), Some(2));
+    key(&mut h, Key::ArrowLeft, Modifiers::NONE);
+    assert_eq!(focused(&h).unwrap().1, "Blur & Sharpen", "Left Arrow on an effect steps out to its folder");
+    key(&mut h, Key::ArrowLeft, Modifiers::NONE);
+    assert!(!h.state().ui.effects_open.contains("Blur & Sharpen"), "Left Arrow closes the folder");
+    key(&mut h, Key::Enter, Modifiers::NONE);
+    assert!(h.state().ui.effects_open.contains("Blur & Sharpen"), "Enter opens a closed folder");
+    key(&mut h, Key::Space, Modifiers::NONE);
+    assert!(!h.state().ui.effects_open.contains("Blur & Sharpen"), "Space closes it again");
+}
+
+#[test]
+fn enter_and_space_apply_an_effect_to_the_selected_layer() {
+    for apply_key in [Key::Enter, Key::Space] {
+        let mut h = harness();
+        tab_into_list(&mut h);
+        h.state_mut().ui.effects_open.insert("Blur & Sharpen".into());
+        h.run_steps(3);
+        let mut guard = 0;
+        while focused(&h).map(|f| f.1) != Some("Blur & Sharpen".to_string()) {
+            key(&mut h, Key::ArrowDown, Modifiers::NONE);
+            guard += 1;
+            assert!(guard < 40);
+        }
+        key(&mut h, Key::ArrowDown, Modifiers::NONE);
+        let effect = focused(&h).unwrap().1;
+        assert!(h.state().session.state.last_effect.is_none());
+        key(&mut h, apply_key, Modifiers::NONE);
+        let applied = h.state().session.state.last_effect.clone();
+        assert!(applied.is_some(), "{apply_key:?} on `{effect}` applies it to the selected layer");
+        let pb = &h.state().playback;
+        assert!(!pb.playing && !pb.caching && pb.plan.is_none(), "{apply_key:?} on a focused row is the row's, it does not start a preview");
+    }
+}
+
+#[test]
+fn the_star_is_a_named_button_on_the_cursor_row_and_enter_toggles_it() {
+    let mut h = harness();
+    tab_into_list(&mut h);
+    h.state_mut().ui.effects_open.insert("Blur & Sharpen".into());
+    h.run_steps(3);
+    let mut guard = 0;
+    while focused(&h).map(|f| f.1) != Some("Blur & Sharpen".to_string()) {
+        key(&mut h, Key::ArrowDown, Modifiers::NONE);
+        guard += 1;
+        assert!(guard < 40, "no Blur & Sharpen folder reached");
+    }
+    key(&mut h, Key::ArrowDown, Modifiers::NONE);
+    let effect = focused(&h).unwrap().1;
+    key(&mut h, Key::Tab, Modifiers::NONE);
+    let (role, name) = focused(&h).expect("the star has the focus");
+    assert_eq!(role, Role::Button);
+    assert_eq!(name, format!("Add to favorites: {effect}"));
+    key(&mut h, Key::Enter, Modifiers::NONE);
+    assert_eq!(h.state().session.prefs.effects_favorites.len(), 1, "Enter on the star adds the favourite");
+    let (_, name) = focused(&h).expect("the star keeps the focus");
+    assert_eq!(name, format!("Remove from favorites: {effect}"));
+}
+
+#[test]
+fn the_search_field_keeps_its_arrows_and_the_layer_does_not_nudge() {
+    let mut h = harness();
+    h.get_by_label("Search effects and presets").focus();
+    h.run_steps(3);
+    h.get_by_label("Search effects and presets").type_text("blur");
+    h.run_steps(3);
+    assert_eq!(h.state().ui.effects_search, "blur");
+    key(&mut h, Key::ArrowDown, Modifiers::NONE);
+    assert!(selected_rows(&h).is_empty(), "arrows in the search field belong to the field");
+    // A click on a row, then the arrows: the list moves, the selected layer stays where it is.
+    let layer_before = layer_position(&h);
+    h.state_mut().ui.effects_search.clear();
+    h.run_steps(3);
+    click(&mut h, "effects.category.presets");
+    assert_eq!(h.state().ui.focused, PanelKind::EffectsPresets);
+    key(&mut h, Key::ArrowDown, Modifiers::NONE);
+    assert_eq!(selected_rows(&h).len(), 1, "the arrows work after a click, without keyboard focus on a row");
+    key(&mut h, Key::ArrowRight, Modifiers::NONE);
+    assert_eq!(layer_position(&h), layer_before, "the arrow keys did not nudge the selected layer");
+}
+
+fn layer_position(h: &Harness<'_, EffectcraftApp>) -> String {
+    let s = &h.state().session;
+    let comp = s.active_comp().expect("a comp");
+    let layer = comp.layers.first().expect("a layer");
+    format!("{:?}", layer.transform())
+}
+
+#[test]
+fn rows_and_controls_have_names_roles_and_states() {
+    let mut h = harness();
+    h.state_mut().ui.effects_open.insert("Blur & Sharpen".into());
+    h.state_mut().session.prefs.toggle_effect_favorite("ec.blur.gaussian");
+    h.run_steps(4);
+    assert_eq!(h.get_by_label("Search effects and presets").accesskit_node().role(), Role::TextInput);
+    let menu = h.get_by_label("Effects & Presets options");
+    assert_eq!(menu.accesskit_node().role(), Role::Button);
+    assert_eq!(menu.accesskit_node().data().is_expanded(), Some(false), "the options button says its menu is closed");
+    let folder = h.get_by_label("Blur & Sharpen");
+    assert_eq!(folder.accesskit_node().role(), Role::TreeItem);
+    assert_eq!(folder.accesskit_node().data().is_expanded(), Some(true));
+    assert_eq!(folder.accesskit_node().is_selected(), Some(false));
+    let favorites = h.get_by_label("Favorites");
+    assert_eq!(favorites.accesskit_node().data().is_expanded(), Some(false));
+    // Every effect row in an open category is a leaf at depth 2.
+    let leaves: Vec<_> =
+        h.root().children_recursive().filter(|n| n.accesskit_node().role() == Role::TreeItem && n.accesskit_node().data().level() == Some(2)).collect();
+    assert!(!leaves.is_empty());
+    assert!(leaves.iter().all(|n| n.accesskit_node().data().is_expanded().is_none()), "effects are leaves: they have no open state");
+    let gaussian_rows = h
+        .root()
+        .children_recursive()
+        .filter(|n| n.accesskit_node().role() == Role::TreeItem && n.accesskit_node().label().as_deref() == Some("Gaussian Blur"))
+        .count();
+    assert!(gaussian_rows <= 1, "a favourite hidden in a closed Favorites folder draws no rows");
+    assert!(h.query_all_by_label_contains("Add to favorites: ").count() > 1, "the effects' stars are named");
+}
+
+/// A pick from the options menu with the mouse leaves no widget with the keyboard focus, and Enter
+/// after a click in the panel is the panel's: it opens or applies the row and does not start the
+/// layer rename the Timeline binds to Enter.
+#[test]
+fn mouse_picks_leave_no_focus_and_enter_after_a_click_is_the_panels() {
+    let mut h = harness();
+    click(&mut h, "effects.menu");
+    assert!(h.ctx.memory(|m| m.focused()).is_none(), "opening the menu with the mouse takes no keyboard focus");
+    h.get_by_label_contains("Alphabetical").click();
+    h.run_steps(4);
+    assert!(h.ctx.memory(|m| m.focused()).is_none(), "choosing an entry with the mouse leaves no keyboard focus");
+    assert!(h.state().ui.effects_view.alphabetical);
+    h.state_mut().ui.effects_view.alphabetical = false;
+    h.run_steps(3);
+    click(&mut h, "effects.category.presets");
+    let open = h.state().ui.effects_open.contains("presets");
+    key(&mut h, Key::Enter, Modifiers::NONE);
+    assert_ne!(h.state().ui.effects_open.contains("presets"), open, "Enter toggles the clicked folder");
+    assert!(h.state().auto.query("timeline.layer.").iter().all(|e| !e.id.ends_with(".nameEdit")), "no layer rename started");
+}
diff --git a/crates/ui-egui/tests/it/ui_env_light_gpu.rs b/crates/ui-egui/tests/it/ui_env_light_gpu.rs
new file mode 100644
index 000000000..185980fb6
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_env_light_gpu.rs
@@ -0,0 +1,85 @@
+//! The Environment light through the app's GPU compositor (egui_kittest with wgpu): adding one
+//! visibly changes the viewer's GPU frames (#2436). Skips without a GPU adapter (CI).
+
+use effectcraft_engine::Session;
+use effectcraft_engine::project::Renderer;
+use effectcraft_ui_egui::EffectcraftApp;
+use egui_kittest::Harness;
+use serde_json::json;
+
+use crate::ui_gpu::wait_for_compositor;
+
+fn settle(h: &mut Harness<'_, EffectcraftApp>) {
+    for _ in 0..600 {
+        h.step();
+        if h.state().frames.inflight() == 0 && h.state().frames.last_ms.lock().map(|v| *v > 0.0).unwrap_or(false) {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(20));
+    }
+    for _ in 0..4 {
+        h.step();
+    }
+}
+
+/// egui_kittest's wgpu setup on the adapter the headless compositor picked, so the viewer's GPU
+/// compositor attaches (see ui_gpu.rs).
+fn same_adapter(name: String) -> eframe::egui_wgpu::WgpuSetup {
+    let mut setup = egui_kittest::wgpu::default_wgpu_setup();
+    if let eframe::egui_wgpu::WgpuSetup::CreateNew(c) = &mut setup {
+        let fallback = c.native_adapter_selector.take();
+        c.native_adapter_selector = Some(std::sync::Arc::new(move |adapters, surface| {
+            let named = |a: &&eframe::wgpu::Adapter| format!("{} ({:?})", a.get_info().name, a.get_info().backend) == name;
+            match (adapters.iter().find(named), &fallback) {
+                (Some(a), _) => Ok(a.clone()),
+                (None, Some(f)) => f(adapters, surface),
+                (None, None) => adapters.first().cloned().ok_or_else(|| "No adapter found".to_owned()),
+            }
+        }));
+    }
+    setup
+}
+
+/// A red Environment light at full intensity lights the scene on the GPU compositor too: the
+/// viewer's GPU frames change when the light is added.
+#[test]
+fn environment_light_lights_the_scene_on_the_gpu() {
+    let _device = crate::gpu_test::lock();
+    let Some(probe) = effectcraft_gpu::Gpu::headless() else {
+        eprintln!("no GPU adapter: skipping");
+        return;
+    };
+    let adapter = effectcraft_engine::render::Accelerator::name(&probe);
+    eprintln!("headless compositor adapter: {adapter}");
+    let gl = adapter.ends_with("(Gl)");
+    drop(probe);
+    let mut h = Harness::builder()
+        .with_size(egui::vec2(1400.0, 900.0))
+        .with_pixels_per_point(1.0)
+        .wgpu_setup(same_adapter(adapter))
+        .build_eframe(|_| EffectcraftApp::new(Session::default()));
+    // The project opens once the compositor (built on a worker thread) is attached, so the
+    // frames compared below are GPU frames, not ones the CPU composited meanwhile (see ui_gpu.rs).
+    wait_for_compositor(&mut h);
+    if gl && h.state().gpu_adapter().is_none() {
+        eprintln!("egui-wgpu's GL device has WebGL2 limits: the viewer stays on the CPU, skipping");
+        return;
+    }
+    assert!(h.state().gpu_adapter().is_some(), "GPU compositor on egui-wgpu's device");
+    let s = &mut h.state_mut().session;
+    s.execute("file.openDemoProject", json!({})).unwrap();
+    s.execute("comp.open", json!({"comp": "3D Showcase"})).unwrap();
+    s.execute("time.set", json!({"time": 5.0})).unwrap();
+    s.execute("comp.settings", json!({"renderer": "classic3D"})).unwrap();
+    settle(&mut h);
+    let before = h.state_mut().viewer_pixels().expect("GPU frame before adding the light").pixels.clone();
+
+    h.state_mut().session.execute("layer.newLight", json!({"kind": "Environment", "color": [1.0, 0.0, 0.0], "intensity": 100.0})).unwrap();
+    assert_eq!(h.state().session.active_comp().unwrap().renderer, Renderer::Advanced3D);
+    settle(&mut h);
+    let after = h.state_mut().viewer_pixels().expect("GPU frame after adding the light").pixels.clone();
+
+    assert_eq!(before.len(), after.len());
+    let diff = before.iter().zip(&after).filter(|(a, b)| a != b).count();
+    assert!(diff > 500, "a red Environment light at 100 % changed only {diff} GPU pixels");
+}
diff --git a/crates/ui-egui/tests/it/ui_export_overwrite.rs b/crates/ui-egui/tests/it/ui_export_overwrite.rs
new file mode 100644
index 000000000..997359479
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_export_overwrite.rs
@@ -0,0 +1,110 @@
+//! The control channel's `render.frame` and `ui.screenshot` write a PNG to the `path` they are
+//! given, and never over a file the project reads (#1743): footage, a proxy or the project file.
+
+use std::path::PathBuf;
+
+use effectcraft_engine::Session;
+use effectcraft_engine::color::Label;
+use effectcraft_engine::project::{Footage, FootageKind, ItemKind};
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::control::{self, ControlRequest, Outcome};
+use egui_kittest::Harness;
+use serde_json::{Value, json};
+
+const SOURCE: &[u8] = b"SOURCE FOOTAGE";
+
+struct Rig {
+    h: Harness<'static, EffectcraftApp>,
+    dir: PathBuf,
+}
+
+impl Rig {
+    /// A project saved as `Project.ecproj` in a fresh folder, reading `clip.png` beside it.
+    fn new(name: &str) -> Rig {
+        let dir = std::env::temp_dir().join("effectcraft-ui-export-overwrite").join(format!("{}-{name}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        std::fs::write(dir.join("clip.png"), SOURCE).unwrap();
+        let mut s = Session::default();
+        s.execute("comp.new", json!({"name": "Main", "width": 16, "height": 16, "frameRate": 10, "duration": 0.5})).unwrap();
+        s.execute("file.saveAs", json!({"path": dir.join("Project.ecproj").to_string_lossy()})).unwrap();
+        let clip = Footage {
+            path: dir.join("clip.png").to_string_lossy().into_owned(),
+            kind: FootageKind::Still,
+            width: 16,
+            height: 16,
+            has_video: true,
+            ..Default::default()
+        };
+        std::sync::Arc::make_mut(&mut s.project).add_item("clip.png", Label::Aqua, None, ItemKind::Footage(clip));
+        let mut app = Some(EffectcraftApp::new(s));
+        let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| app.take().expect("app"));
+        h.run_steps(2);
+        Rig { h, dir }
+    }
+
+    fn text(&self, file: &str) -> String {
+        self.dir.join(file).to_string_lossy().into_owned()
+    }
+
+    fn read(&self, file: &str) -> Vec<u8> {
+        std::fs::read(self.dir.join(file)).unwrap()
+    }
+
+    /// A control-channel request, answered at once or not.
+    fn send(&mut self, method: &str, params: Value) -> Outcome {
+        let ctx = self.h.ctx.clone();
+        let (req, _rx) = ControlRequest::new(method, params);
+        let now = self.h.state().now();
+        control::handle(self.h.state_mut(), &ctx, &req, now)
+    }
+
+    /// The reply of a request that is answered at once.
+    fn reply(&mut self, method: &str, params: Value) -> Value {
+        match self.send(method, params) {
+            Outcome::Done(v) => v,
+            _ => panic!("{method}: no immediate reply"),
+        }
+    }
+}
+
+impl Drop for Rig {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.dir);
+    }
+}
+
+#[test]
+fn render_frame_never_writes_over_a_file_the_project_reads() {
+    let mut r = Rig::new("render-frame");
+    let project = r.read("Project.ecproj");
+    for (file, what) in [("clip.png", "footage"), ("Project.ecproj", "project")] {
+        let v = r.reply("render.frame", json!({"path": r.text(file)}));
+        let error = v["error"].as_str().unwrap_or_default();
+        assert!(v["ok"] == false && error.contains(file) && error.contains(what), "{file}: {v}");
+    }
+    assert_eq!(r.read("clip.png"), SOURCE, "the footage is as it was");
+    assert_eq!(r.read("Project.ecproj"), project, "the project file is as it was");
+    // Anywhere else it writes the PNG.
+    let v = r.reply("render.frame", json!({"path": r.text("frame.png")}));
+    assert_eq!(v["ok"], true, "{v}");
+    assert_eq!(&r.read("frame.png")[..8], b"\x89PNG\r\n\x1a\n");
+    let v = r.reply("render.frame", json!({"path": r.text("inline.png"), "base64": true, "write": true}));
+    assert_eq!(v["ok"], true, "{v}");
+    assert_eq!(v["result"]["png"].as_str(), Some(control::base64(&r.read("inline.png")).as_str()));
+}
+
+#[test]
+fn screenshot_never_writes_over_a_file_the_project_reads() {
+    let mut r = Rig::new("screenshot");
+    let project = r.read("Project.ecproj");
+    for (file, what) in [("clip.png", "footage"), ("Project.ecproj", "project")] {
+        let Outcome::Done(v) = r.send("ui.screenshot", json!({"path": r.text(file)})) else { panic!("{file}: the screenshot was taken for it") };
+        let error = v["error"].as_str().unwrap_or_default();
+        assert!(v["ok"] == false && error.contains(file) && error.contains(what), "{file}: {v}");
+    }
+    assert_eq!(r.read("clip.png"), SOURCE, "the footage is as it was");
+    assert_eq!(r.read("Project.ecproj"), project, "the project file is as it was");
+    // Anywhere else it is taken (the frame that carries it comes later).
+    assert!(matches!(r.send("ui.screenshot", json!({"path": r.text("shot.png")})), Outcome::Screenshot { .. }));
+}
diff --git a/crates/ui-egui/tests/it/ui_expression_values.rs b/crates/ui-egui/tests/it/ui_expression_values.rs
new file mode 100644
index 000000000..b797e6cf6
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_expression_values.rs
@@ -0,0 +1,296 @@
+//! #1306 (from #1072): a property driven by an expression shows its value in red, the expression
+//! colour, in the Timeline, Effect Controls and the Properties panel, as in After Effects: scalars,
+//! every part of a vector (with its separator) and both parts of an angle (with its sign), hovered
+//! and dragged too, in dark and light themes. A disabled, removed or empty expression shows the
+//! ordinary colour again. The tests read the colour the value text is painted with (the frame's
+//! text shapes: the numbers are painted with an override colour, the separator and sign as plain
+//! text), and require every expected part to be there.
+
+use effectcraft_engine::Session;
+use effectcraft_engine::project::{LayerId, PropGroup};
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use effectcraft_ui_egui::theme::ThemeKind;
+use egui::epaint::Shape;
+use egui::{Color32, Event, Modifiers, PointerButton, Pos2, Rect, pos2, vec2};
+use egui_kittest::Harness;
+use serde_json::json;
+
+const TIMELINE: &str = "timeline.prop";
+const EFFECT_CONTROLS: &str = "effectControls.prop";
+const PROPERTIES: &str = "properties.prop";
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Kind {
+    /// Two components (X, Y).
+    Vector,
+    /// Revolutions, sign and degrees.
+    Angle,
+    Scalar,
+}
+
+/// A property whose value the tests check, and the panels that must show it.
+#[derive(Clone, Copy, Debug)]
+struct Checked {
+    uid: u64,
+    kind: Kind,
+    panels: &'static [&'static str],
+}
+
+/// A comp with one solid and the Transform effect on it.
+struct Ids {
+    layer: u64,
+    /// Transform Position, Rotation and Opacity (Timeline and Properties panel), and the Transform
+    /// effect's Position, Rotation and Opacity (Effect Controls).
+    driven: [Checked; 6],
+    /// Transform Scale: no expression.
+    scale: Checked,
+}
+
+fn setup() -> (Harness<'static, EffectcraftApp>, Ids) {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "E", "width": 320, "height": 180, "duration": 4})).unwrap();
+    let l = s.execute("layer.newSolid", json!({"color": "#406080"})).unwrap()["layer"].as_u64().unwrap();
+    let fx = s.execute("effect.apply", json!({"layers": [l], "effect": "Transform"})).unwrap()["effects"][0].as_u64().unwrap();
+    let layer = s.active_comp().unwrap().layer(LayerId(l)).unwrap().clone();
+    let uid = |path: &str| layer.props.prop(path).unwrap_or_else(|| panic!("no {path}")).uid;
+    let g: &PropGroup = layer.props.find_group(fx).unwrap();
+    let fuid = |m: &str| g.get(m).unwrap_or_else(|| panic!("no effect {m}")).uid;
+    const LAYER: &[&str] = &[TIMELINE, PROPERTIES];
+    const EFFECT: &[&str] = &[EFFECT_CONTROLS];
+    let c = |uid, kind, panels| Checked { uid, kind, panels };
+    let ids = Ids {
+        layer: l,
+        driven: [
+            c(uid("transform/position"), Kind::Vector, LAYER),
+            c(uid("transform/rotation"), Kind::Angle, LAYER),
+            c(uid("transform/opacity"), Kind::Scalar, LAYER),
+            c(fuid("position"), Kind::Vector, EFFECT),
+            c(fuid("rotation"), Kind::Angle, EFFECT),
+            c(fuid("opacity"), Kind::Scalar, EFFECT),
+        ],
+        scale: c(uid("transform/scale"), Kind::Vector, LAYER),
+    };
+    let transform = layer.props.sub("transform").unwrap().uid;
+    s.state.selected_layers = vec![LayerId(l)];
+    let mut app = EffectcraftApp::new(s);
+    app.show_panel(PanelKind::EffectControls);
+    app.ui.timeline.open_layers.insert(l);
+    app.ui.timeline.open_groups.insert(transform);
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| app);
+    h.run_steps(4);
+    (h, ids)
+}
+
+fn set_expression(h: &mut Harness<'_, EffectcraftApp>, ids: &Ids, prop: u64, p: &serde_json::Value) {
+    let mut p = p.clone();
+    p["layer"] = json!(ids.layer);
+    p["prop"] = json!(prop);
+    h.state_mut().session.execute("prop.setExpression", p).unwrap();
+}
+
+fn set_theme(h: &mut Harness<'_, EffectcraftApp>, theme: ThemeKind) {
+    let ctx = h.ctx.clone();
+    h.state_mut().set_theme(&ctx, theme);
+    h.run_steps(3);
+}
+
+fn rect_of(h: &Harness<'_, EffectcraftApp>, id: &str) -> Rect {
+    let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}: the part isn't shown"));
+    Rect::from_min_size(pos2(e.rect[0], e.rect[1]), vec2(e.rect[2], e.rect[3]))
+}
+
+/// The area of `c`'s value in `panel`, every expected part required: both components of a vector,
+/// the revolutions and degrees of an angle (the separator and sign lie between them).
+fn value_area(h: &Harness<'_, EffectcraftApp>, panel: &str, c: Checked) -> Rect {
+    let uid = c.uid;
+    match c.kind {
+        Kind::Vector => rect_of(h, &format!("{panel}.{uid}.value.0")).union(rect_of(h, &format!("{panel}.{uid}.value.1"))),
+        Kind::Angle => rect_of(h, &format!("{panel}.{uid}.revolutions")).union(rect_of(h, &format!("{panel}.{uid}.value"))),
+        Kind::Scalar => rect_of(h, &format!("{panel}.{uid}.value")),
+    }
+}
+
+/// The text painted inside `area` in the last frame, with its colour.
+fn texts(h: &Harness<'_, EffectcraftApp>, area: Rect) -> Vec<(String, Color32)> {
+    fn walk(s: &Shape, area: Rect, out: &mut Vec<(String, Color32)>) {
+        match s {
+            Shape::Vec(v) => v.iter().for_each(|s| walk(s, area, out)),
+            Shape::Text(t) if area.expand(1.0).contains_rect(t.visual_bounding_rect()) && !t.galley.text().trim().is_empty() => {
+                out.push((t.galley.text().trim().to_string(), t.override_text_color.unwrap_or(t.fallback_color)));
+            }
+            _ => {}
+        }
+    }
+    let mut out = vec![];
+    for c in &h.output().shapes {
+        walk(&c.shape, area, &mut out);
+    }
+    out
+}
+
+/// `c`'s value in `panel` shows every part, all in `want`: two numbers and (in the Timeline) the
+/// `,` of a vector, the revolutions, sign and degrees of an angle, the number of a scalar.
+fn assert_value(h: &Harness<'_, EffectcraftApp>, panel: &str, c: Checked, want: Color32, what: &str) {
+    let shown = texts(h, value_area(h, panel, c));
+    let numbers = shown.iter().filter(|(s, _)| s.chars().any(|ch| ch.is_ascii_digit())).count();
+    let has = |text: &str| shown.iter().any(|(s, _)| s == text);
+    let ctx = format!("{what}: {:?} @{} in {panel}: {shown:?}", c.kind, c.uid);
+    match c.kind {
+        Kind::Vector => {
+            assert!(numbers >= 2, "{ctx}: both components");
+            if panel == TIMELINE {
+                assert!(has(","), "{ctx}: the separator");
+            }
+        }
+        Kind::Angle => {
+            assert!(numbers >= 2, "{ctx}: revolutions and degrees");
+            assert!(has("+") || has("-"), "{ctx}: the sign");
+        }
+        Kind::Scalar => assert!(numbers >= 1, "{ctx}: the number"),
+    }
+    assert!(shown.iter().all(|(_, col)| *col == want), "{ctx}: want {want:?}");
+}
+
+/// Every checked property in every panel it belongs to.
+fn assert_all(h: &Harness<'_, EffectcraftApp>, checked: &[Checked], want: Color32, what: &str) {
+    for c in checked {
+        for panel in c.panels {
+            assert_value(h, panel, *c, want, what);
+        }
+    }
+}
+
+/// Expression-driven values are red in every panel, in both themes; Scale (none) stays blue.
+#[test]
+fn expression_driven_values_are_red_in_every_panel() {
+    let (mut h, ids) = setup();
+    for c in ids.driven {
+        set_expression(&mut h, &ids, c.uid, &json!({"expression": "value"}));
+    }
+    for theme in [ThemeKind::Dark, ThemeKind::Light] {
+        set_theme(&mut h, theme);
+        let t = h.state().tokens;
+        assert_ne!(t.expr_text, t.hot_text);
+        assert_all(&h, &ids.driven, t.expr_text, &format!("{theme:?} expression"));
+        assert_all(&h, &[ids.scale], t.hot_text, &format!("{theme:?} no expression"));
+    }
+}
+
+/// Disabled, removed or whitespace-only: the ordinary colour; enabled again: red. Every part of
+/// every value is checked again after each change, in both themes.
+#[test]
+fn expression_state_changes_switch_the_colour() {
+    let (mut h, ids) = setup();
+    let states = [
+        (json!({"expression": "value"}), true, "enabled"),
+        (json!({"enabled": false}), false, "disabled"),
+        (json!({"enabled": true}), true, "enabled again"),
+        (json!({"expression": ""}), false, "removed"),
+        (json!({"expression": "value"}), true, "set again"),
+        (json!({"expression": "   "}), false, "whitespace only"),
+    ];
+    for theme in [ThemeKind::Dark, ThemeKind::Light] {
+        set_theme(&mut h, theme);
+        let t = h.state().tokens;
+        for (p, red, what) in &states {
+            for c in ids.driven {
+                set_expression(&mut h, &ids, c.uid, p);
+            }
+            h.run_steps(3);
+            let want = if *red { t.expr_text } else { t.hot_text };
+            assert_all(&h, &ids.driven, want, &format!("{theme:?} {what}"));
+            assert_all(&h, &[ids.scale], t.hot_text, &format!("{theme:?} {what}: Scale"));
+        }
+    }
+}
+
+fn hover(h: &mut Harness<'_, EffectcraftApp>, at: Pos2) {
+    h.input_mut().events.push(Event::PointerMoved(at));
+    h.run_steps(2);
+}
+
+/// Hovering a value (an ordinary one takes the hover accent) keeps an expression-driven one red,
+/// in every panel and both themes.
+#[test]
+fn a_hovered_expression_value_stays_red() {
+    let (mut h, ids) = setup();
+    let opacity = ids.driven.iter().filter(|c| c.kind == Kind::Scalar).copied().collect::<Vec<_>>();
+    for c in &opacity {
+        set_expression(&mut h, &ids, c.uid, &json!({"expression": "value"}));
+    }
+    h.run_steps(3);
+    for theme in [ThemeKind::Dark, ThemeKind::Light] {
+        set_theme(&mut h, theme);
+        let t = h.state().tokens;
+        for c in &opacity {
+            for panel in c.panels {
+                let area = value_area(&h, panel, *c);
+                hover(&mut h, area.center());
+                let at = h.ctx.input(|i| i.pointer.hover_pos());
+                assert!(at.is_some_and(|p| area.contains(p)), "{theme:?} {panel}: the pointer is over the value");
+                assert_value(&h, panel, *c, t.expr_text, &format!("{theme:?} hovered"));
+            }
+        }
+        // An ordinary value does take the hover accent.
+        let area = value_area(&h, TIMELINE, ids.scale);
+        let x = rect_of(&h, &format!("{TIMELINE}.{}.value.0", ids.scale.uid)).center();
+        hover(&mut h, x);
+        let shown = texts(&h, area);
+        assert!(shown.iter().any(|(_, c)| *c == t.accent_hover), "{theme:?} an ordinary hovered value: {shown:?}");
+        hover(&mut h, pos2(5.0, 5.0));
+    }
+}
+
+/// Dragging (scrubbing) an expression-driven value keeps it red while the drag is on, in the
+/// Timeline and Effect Controls.
+#[test]
+fn a_dragged_expression_value_stays_red() {
+    let (mut h, ids) = setup();
+    let opacity = ids.driven.iter().filter(|c| c.kind == Kind::Scalar).copied().collect::<Vec<_>>();
+    for c in &opacity {
+        set_expression(&mut h, &ids, c.uid, &json!({"expression": "value"}));
+    }
+    h.run_steps(3);
+    let t = h.state().tokens;
+    for (c, panel) in [(opacity[0], TIMELINE), (opacity[1], EFFECT_CONTROLS)] {
+        let at = value_area(&h, panel, c).center();
+        h.input_mut().events.push(Event::PointerMoved(at));
+        h.step();
+        h.input_mut().events.push(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+        h.step();
+        for k in 1..=4 {
+            h.input_mut().events.push(Event::PointerMoved(at + vec2(3.0 * k as f32, 0.0)));
+            h.step();
+        }
+        assert!(h.ctx.dragged_id().is_some(), "{panel}: a drag is on");
+        assert_value(&h, panel, c, t.expr_text, &format!("{panel} dragged"));
+        let end = at + vec2(12.0, 0.0);
+        h.input_mut().events.push(Event::PointerButton { pos: end, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+        h.run_steps(3);
+        hover(&mut h, pos2(5.0, 5.0));
+    }
+}
+
+/// Separate Dimensions: X Position and Y Position are separate scalars, so an expression on X Position
+/// turns only X red, in the Timeline and Properties panel and both themes; Y Position stays blue.
+#[test]
+fn separated_position_colours_each_dimension_on_its_own() {
+    let (mut h, ids) = setup();
+    h.state_mut().session.execute("prop.separateDimensions", json!({"layer": ids.layer, "value": true})).unwrap();
+    let uid = |h: &Harness<'_, EffectcraftApp>, path: &str| {
+        let s = &h.state().session;
+        s.active_comp().unwrap().layer(LayerId(ids.layer)).unwrap().props.prop(path).unwrap_or_else(|| panic!("no {path}")).uid
+    };
+    const LAYER: &[&str] = &[TIMELINE, PROPERTIES];
+    let x = Checked { uid: uid(&h, "transform/positionX"), kind: Kind::Scalar, panels: LAYER };
+    let y = Checked { uid: uid(&h, "transform/positionY"), kind: Kind::Scalar, panels: LAYER };
+    set_expression(&mut h, &ids, x.uid, &json!({"expression": "value"}));
+    h.run_steps(3);
+    for theme in [ThemeKind::Dark, ThemeKind::Light] {
+        set_theme(&mut h, theme);
+        let t = h.state().tokens;
+        assert_all(&h, &[x], t.expr_text, &format!("{theme:?} X Position (expression)"));
+        assert_all(&h, &[y], t.hot_text, &format!("{theme:?} Y Position (none)"));
+    }
+}
diff --git a/crates/ui-egui/tests/it/ui_font_search.rs b/crates/ui-egui/tests/it/ui_font_search.rs
index 6be69cb7a..44b650be4 100644
--- a/crates/ui-egui/tests/it/ui_font_search.rs
+++ b/crates/ui-egui/tests/it/ui_font_search.rs
@@ -1,4 +1,5 @@
 //! Real keyboard/pointer coverage for the font menus in both text panels.
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::{Session, commands::text_edit::layer_doc, project::LayerId};
 use effectcraft_ui_egui::{EffectcraftApp, dock::PanelKind};
 use egui::{Event, Key, Modifiers, PointerButton};
@@ -29,6 +30,7 @@ fn type_text(h: &mut Harness<'_, EffectcraftApp>, text: &str) {
 
 #[test]
 fn font_search_filters_selects_and_undoes_in_both_panels() {
+    let _device = crate::gpu_test::lock();
     for (panel, prefix) in [(PanelKind::Character, "character.font"), (PanelKind::Properties, "properties.text.font")] {
         let mut s = Session::default();
         s.execute("comp.new", json!({"width": 320, "height": 180})).unwrap();
@@ -56,7 +58,7 @@ fn font_search_filters_selects_and_undoes_in_both_panels() {
         assert!(!rows.is_empty());
         assert!(rows.iter().all(|r| r.label.to_lowercase().contains("jetbrains")));
         if let Ok(dir) = std::env::var("EC_SNAPSHOT_DIR") {
-            h.render().unwrap().save(format!("{dir}/{prefix}-search.png")).unwrap();
+            h.render_serialized().unwrap().save(format!("{dir}/{prefix}-search.png")).unwrap();
         }
         assert_eq!(layer_doc(&h.state().session, LayerId(lid)).unwrap().font, "Inter", "typing only filters");
         key(&mut h, Key::Enter);
@@ -76,7 +78,7 @@ fn font_search_filters_selects_and_undoes_in_both_panels() {
         // Reopening clears the previous query, and mouse selection still works.
         h.run_steps(2);
         if let Ok(dir) = std::env::var("EC_SNAPSHOT_DIR") {
-            h.render().unwrap().save(format!("{dir}/{prefix}-reopened.png")).unwrap();
+            h.render_serialized().unwrap().save(format!("{dir}/{prefix}-reopened.png")).unwrap();
         }
         assert!(h.state().auto.query(&format!("{prefix}.option.")).len() > 1);
         type_text(&mut h, "JetBrains");
@@ -106,6 +108,52 @@ fn font_search_preserves_edited_text_and_applies_only_to_selected_characters() {
     assert_eq!(doc.style_at(8).font, "Inter");
 }
 
+/// A font file of just `name`: the family and Regular in English, and the family again in
+/// Simplified Chinese (language 0x804).
+fn font_with_native_name(family: &str, native: &str) -> Vec<u8> {
+    let u16s = |v: &[u16]| -> Vec<u8> { v.iter().flat_map(|x| x.to_be_bytes()).collect() };
+    let records = [(0x409, 1, family), (0x409, 2, "Regular"), (0x804, 1, native)];
+    let strings: Vec<Vec<u8>> = records.iter().map(|(_, _, s)| s.encode_utf16().flat_map(|u| u.to_be_bytes()).collect()).collect();
+    let mut name = u16s(&[0, records.len() as u16, 6 + 12 * records.len() as u16]);
+    let mut off = 0;
+    for ((lang, id, _), st) in records.iter().zip(&strings) {
+        name.extend(u16s(&[3, 1, *lang, *id, st.len() as u16, off]));
+        off += st.len() as u16;
+    }
+    strings.iter().for_each(|st| name.extend(st));
+    let mut out = u16s(&[1, 0, 1, 0, 0, 0]);
+    out.extend(b"name");
+    out.extend([0u8; 4]);
+    out.extend(28u32.to_be_bytes());
+    out.extend((name.len() as u32).to_be_bytes());
+    out.extend(name);
+    out
+}
+
+/// A family whose own-language name has a character no interface font has is listed under its
+/// English name: the harness fails on a missing glyph, and the app would draw boxes. Picking the
+/// row still applies the family.
+#[test]
+fn font_menu_lists_a_name_the_interface_fonts_lack_in_english() {
+    const FAMILY: &str = "Native Name Menu Test";
+    // U+F1234 is in a private use plane that no interface font maps.
+    const NATIVE: &str = "中文\u{F1234}字体";
+    assert_eq!(effectcraft_engine::text::fonts::add_font_data(font_with_native_name(FAMILY, NATIVE)).len(), 1);
+    assert_eq!(effectcraft_engine::text::fonts::native_families().get(FAMILY).map(String::as_str), Some(NATIVE));
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 320, "height": 180})).unwrap();
+    let lid = s.execute("layer.newText", json!({"text": "Native", "font": "Inter"})).unwrap()["layer"].as_u64().unwrap();
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(move |_| EffectcraftApp::new(s));
+    h.state_mut().show_panel(PanelKind::Character);
+    h.run_steps(3);
+    click(&mut h, "character.font");
+    type_text(&mut h, "native name menu");
+    let shown: Vec<String> = h.state().auto.query("character.font.option.").iter().map(|e| e.id.clone()).collect();
+    assert_eq!(shown, vec![format!("character.font.option.{FAMILY}")]);
+    click(&mut h, &format!("character.font.option.{FAMILY}"));
+    assert_eq!(layer_doc(&h.state().session, LayerId(lid)).unwrap().font, FAMILY);
+}
+
 /// A font file of just `name` (the family, Regular) and an `fvar` table with one axis pinned at
 /// 400: a variable font as far as the font menu's filter is concerned.
 fn pinned_variable_font(family: &str) -> Vec<u8> {
@@ -176,3 +224,58 @@ fn font_menu_filters_variable_fonts() {
     key(&mut h, Key::Escape);
     assert_eq!(layer_doc(&h.state().session, LayerId(lid)).unwrap().font, "Inter", "filtering changes nothing");
 }
+
+/// The font menu grows back when a query that matched nothing is cleared, while the search
+/// field keeps its place and the keyboard; a click on a row then picks that font.
+#[test]
+fn font_menu_grows_back_after_an_empty_search() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 320, "height": 180})).unwrap();
+    let lid = s.execute("layer.newText", json!({"text": "Grow", "font": "Inter"})).unwrap()["layer"].as_u64().unwrap();
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(move |_| EffectcraftApp::new(s));
+    h.state_mut().show_panel(PanelKind::Character);
+    h.run_steps(3);
+    let rows = |h: &Harness<'_, EffectcraftApp>| h.state().auto.query("character.font.option.").len();
+    let search = |h: &Harness<'_, EffectcraftApp>| h.state().auto.find("character.font.search").map(|e| e.rect);
+    click(&mut h, "character.font");
+    h.run_steps(2);
+    let (full, field) = (rows(&h), search(&h));
+    assert!(full > 3, "the open menu shows the fonts: {full} rows");
+    let query = "no_such_font_123456789";
+    type_text(&mut h, query);
+    assert_eq!(rows(&h), 0);
+    assert!(h.state().auto.find("character.font.empty").is_some());
+    for pressed in query.chars().flat_map(|_| [true, false]) {
+        h.input_mut().events.push(Event::Key { key: Key::Backspace, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE });
+    }
+    h.run_steps(3);
+    // (Within a row: the list scrolls to the current font on opening and to the top when cleared.)
+    assert!(rows(&h) + 1 >= full, "cleared, the menu shows as many fonts as when it opened: {} of {full}", rows(&h));
+    assert_eq!(search(&h), field, "the search field stays put");
+    // The field still has the keyboard: typing filters again.
+    type_text(&mut h, "JetBrains");
+    assert!(rows(&h) > 0 && h.state().auto.query("character.font.option.").iter().all(|r| r.label.contains("JetBrains")));
+    click(&mut h, "character.font.option.JetBrains Mono");
+    assert_eq!(layer_doc(&h.state().session, LayerId(lid)).unwrap().font, "JetBrains Mono", "a click on a row picks the font");
+}
+
+/// #1089: the font menu can re-run the system scan without restarting the app, and the press
+/// does not also flip the "Variable fonts only" filter.
+#[test]
+fn font_menu_rescan_button_adds_fonts_installed_later() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 320, "height": 180})).unwrap();
+    s.execute("layer.newText", json!({"text": "Keep this text", "font": "Inter"})).unwrap();
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(move |_| EffectcraftApp::new(s));
+    h.state_mut().show_panel(PanelKind::Character);
+    h.run_steps(3);
+    click(&mut h, "character.font");
+    h.run_steps(3);
+    assert!(h.state().auto.find("character.font.rescan").is_some(), "the filter row offers a rescan");
+    click(&mut h, "character.font.rescan");
+    assert!(h.state().ui.status.contains("Rescan Fonts"), "the status reports the rescan: {}", h.state().ui.status);
+    // The popup stays open, the variable filter did not flip, and the list still has the bundled families.
+    assert!(h.state().auto.find("character.font.search").is_some(), "the popup stays open");
+    let rows = h.state().auto.query("character.font.option.");
+    assert!(rows.iter().any(|r| r.label == "Inter"), "{:?}", rows.iter().map(|r| &r.label).collect::<Vec<_>>());
+}
diff --git a/crates/ui-egui/tests/it/ui_fx_editors.rs b/crates/ui-egui/tests/it/ui_fx_editors.rs
index 90a5af15d..b9530fdf4 100644
--- a/crates/ui-egui/tests/it/ui_fx_editors.rs
+++ b/crates/ui-egui/tests/it/ui_fx_editors.rs
@@ -8,6 +8,7 @@ use effectcraft_engine::keyframe::Value as KV;
 use effectcraft_engine::project::{LayerId, Node, PropGroup};
 use effectcraft_ui_egui::EffectcraftApp;
 use effectcraft_ui_egui::dock::PanelKind;
+use effectcraft_ui_egui::dock::WorkspaceExt as _;
 use egui::{Event, Pos2, pos2};
 use egui_kittest::Harness;
 use serde_json::json;
@@ -298,5 +299,5 @@ fn composition_tabs_and_scrolling_preview() {
     let shown = h.state().session.state.active_comp.unwrap();
     click_id(&mut h, "panel.tab.Timeline.close");
     assert!(!h.state().session.state.open_comps.contains(&shown));
-    assert!(h.state().ui.dock.contains(PanelKind::Timeline));
+    assert!(h.state().ui.dock.is_docked(PanelKind::Timeline));
 }
diff --git a/crates/ui-egui/tests/it/ui_gpu.rs b/crates/ui-egui/tests/it/ui_gpu.rs
index 906ac0cd1..d5d432db3 100644
--- a/crates/ui-egui/tests/it/ui_gpu.rs
+++ b/crates/ui-egui/tests/it/ui_gpu.rs
@@ -6,10 +6,11 @@ use effectcraft_ui_egui::EffectcraftApp;
 use egui_kittest::Harness;
 use serde_json::json;
 
+/// Step until the GPU compositor's worker is done and a frame has landed in the viewer.
 fn settle(h: &mut Harness<'_, EffectcraftApp>) {
-    for _ in 0..600 {
+    for _ in 0..3000 {
         h.step();
-        if h.state().frames.inflight() == 0 && h.state().frames.last_ms.lock().map(|v| *v > 0.0).unwrap_or(false) {
+        if !h.state().gpu_initializing() && h.state().frames.inflight() == 0 && h.state().frames.last_ms.lock().map(|v| *v > 0.0).unwrap_or(false) {
             break;
         }
         std::thread::sleep(std::time::Duration::from_millis(20));
@@ -19,6 +20,119 @@ fn settle(h: &mut Harness<'_, EffectcraftApp>) {
     }
 }
 
+/// Step until the GPU compositor's worker has handed its result over (attached, or why not).
+/// The first step starts the build.
+pub(crate) fn wait_for_compositor(h: &mut Harness<'_, EffectcraftApp>) {
+    h.step();
+    for _ in 0..3000 {
+        if !h.state().gpu_initializing() {
+            return;
+        }
+        h.step();
+        std::thread::sleep(std::time::Duration::from_millis(20));
+    }
+    panic!("the GPU compositor's worker gave no result within a minute");
+}
+
+/// Whether wgpu finds any adapter at all (egui_kittest's wgpu harness needs one; CI runners
+/// without a GPU skip).
+fn any_adapter() -> bool {
+    let instance = eframe::wgpu::Instance::new(eframe::wgpu::InstanceDescriptor::new_without_display_handle());
+    !pollster::block_on(instance.enumerate_adapters(eframe::wgpu::Backends::all())).is_empty()
+}
+
+fn small_session() -> Session {
+    let mut s = Session::default();
+    let comp = s.execute("comp.new", json!({"name": "First", "width": 64, "height": 64, "duration": 1})).unwrap()["comp"].as_u64().unwrap();
+    s.execute("layer.newSolid", json!({"comp": comp, "color": "#ff0000"})).unwrap();
+    s
+}
+
+/// The window opens before the GPU compositor exists: its pipelines compile on a worker thread
+/// (tens of seconds on a cold shader cache), and until then the interface draws, says so, and
+/// composites on the CPU. The worker is held on a gate so the "preparing" state is observable.
+#[test]
+fn the_interface_draws_and_composites_on_the_cpu_while_the_gpu_compositor_is_built() {
+    let _device = crate::gpu_test::lock();
+    if !any_adapter() {
+        eprintln!("no wgpu adapter: skipping");
+        return;
+    }
+    let (release, gate) = std::sync::mpsc::channel::<()>();
+    let s = small_session();
+    let mut h = Harness::builder().with_size(egui::vec2(1200.0, 800.0)).wgpu().build_eframe(move |_| {
+        let mut app = EffectcraftApp::new(s);
+        // The status line's 5 s expiry reads the app clock: a manual one makes the steps below
+        // stand for a known span of time.
+        app.use_manual_clock();
+        app.hooks.before_gpu_build = Some(Box::new(move || {
+            let _ = gate.recv();
+        }));
+        app
+    });
+    // The first frames paint, and a CPU frame reaches the viewer, while the worker still waits.
+    for _ in 0..600 {
+        h.step();
+        if h.state().is_ready() && !h.output().shapes.is_empty() && h.state().frames.last_ms.lock().map(|v| *v > 0.0).unwrap_or(false) {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(10));
+    }
+    assert!(h.state().gpu_initializing(), "the compositor is still being built");
+    assert!(!h.output().shapes.is_empty(), "the interface draws before the compositor exists");
+    assert!(h.state().session.accel.is_none(), "nothing renders on a compositor that doesn't exist yet");
+    assert_eq!(h.state().ui.status, effectcraft_ui_egui::GPU_PREPARING, "the status line is honest about it");
+    assert_eq!(h.state().session.accel_note.as_deref(), Some(effectcraft_ui_egui::GPU_PREPARING));
+    assert!(h.state().frames.last_ms.lock().map(|v| *v > 0.0).unwrap_or(false), "a frame was composited on the CPU meanwhile");
+    assert!(h.state_mut().viewer_pixels().is_some(), "the viewer shows that frame");
+    // Other statuses clear after 5 s; this one stays for as long as the build takes (each step
+    // is a quarter of a second).
+    for _ in 0..30 {
+        h.state_mut().clock_mut().advance(0.25);
+        h.step();
+    }
+    assert!(h.state().gpu_initializing());
+    assert_eq!(h.state().ui.status, effectcraft_ui_egui::GPU_PREPARING, "the status line still says so 7.5 s later");
+    release.send(()).unwrap();
+    settle(&mut h);
+    assert!(!h.state().gpu_initializing());
+    assert_ne!(h.state().ui.status, effectcraft_ui_egui::GPU_PREPARING, "the preparing status goes away");
+    match h.state().gpu_adapter() {
+        Some(adapter) => {
+            eprintln!("compositor attached after the first frames: {adapter}");
+            assert!(h.state().session.accel.is_some());
+            assert!(h.state().session.accel_note.is_none());
+        }
+        // An adapter that can't run the compositor (software GL): the reason is recorded.
+        None => assert!(h.state().session.accel_note.as_deref().is_some_and(|n| n != effectcraft_ui_egui::GPU_PREPARING)),
+    }
+}
+
+/// A graphics backend that panics while the compositor's pipelines compile panics on the worker
+/// thread, not under the UI: the window keeps drawing on the CPU and says why.
+#[test]
+fn a_compositor_build_that_panics_leaves_the_viewer_on_the_cpu() {
+    let _device = crate::gpu_test::lock();
+    if !any_adapter() {
+        eprintln!("no wgpu adapter: skipping");
+        return;
+    }
+    let s = small_session();
+    let mut h = Harness::builder().with_size(egui::vec2(1200.0, 800.0)).wgpu().build_eframe(move |_| {
+        let mut app = EffectcraftApp::new(s);
+        app.hooks.before_gpu_build = Some(Box::new(|| panic!("synthetic shader compiler panic")));
+        app
+    });
+    settle(&mut h);
+    assert!(!h.state().gpu_initializing());
+    assert!(h.state().gpu_adapter().is_none());
+    assert!(h.state().session.accel.is_none());
+    let note = h.state().session.accel_note.clone().unwrap_or_default();
+    assert!(note.contains("synthetic shader compiler panic"), "{note}");
+    assert!(!h.output().shapes.is_empty(), "the interface still draws");
+    assert!(h.state_mut().viewer_pixels().is_some(), "the viewer shows a CPU frame");
+}
+
 /// egui_kittest's wgpu setup on the adapter the headless compositor picked (`name (Backend)`),
 /// like the desktop app's window. Left alone, egui_kittest prefers a CPU adapter, which on
 /// Windows is WARP on DirectX 12, where FXC fails to compile the compositor's kernels: the
@@ -41,6 +155,7 @@ fn same_adapter(name: String) -> eframe::egui_wgpu::WgpuSetup {
 
 #[test]
 fn viewer_draws_gpu_frames_that_match_the_cpu() {
+    let _device = crate::gpu_test::lock();
     let Some(probe) = effectcraft_gpu::Gpu::headless() else {
         eprintln!("no GPU adapter: skipping");
         return;
@@ -50,21 +165,24 @@ fn viewer_draws_gpu_frames_that_match_the_cpu() {
     // egui-wgpu creates its GL device with WebGL2's limits, which the compositor declines.
     let gl = adapter.ends_with("(Gl)");
     drop(probe);
-    let mut s = Session::default();
-    s.execute("file.openDemoProject", json!({})).unwrap();
-    s.execute("time.set", json!({"time": 2.0})).unwrap();
     let mut h = Harness::builder()
         .with_size(egui::vec2(1400.0, 900.0))
         .with_pixels_per_point(1.0)
         .wgpu_setup(same_adapter(adapter))
-        .build_eframe(|_| EffectcraftApp::new(s));
-    settle(&mut h);
+        .build_eframe(|_| EffectcraftApp::new(Session::default()));
+    // The project opens once the compositor (built on a worker thread) is attached. A frame the
+    // CPU composited while it was being built has the GPU frame's key, so the viewer would keep
+    // showing it, and the comparison below would be the CPU against itself.
+    wait_for_compositor(&mut h);
     if gl && h.state().gpu_adapter().is_none() {
         eprintln!("egui-wgpu's GL device has WebGL2 limits: the viewer stays on the CPU, skipping");
         return;
     }
     assert!(h.state().gpu_adapter().is_some(), "GPU compositor on egui-wgpu's device");
     eprintln!("viewer compositor adapter: {:?}", h.state().gpu_adapter());
+    h.state_mut().session.execute("file.openDemoProject", json!({})).unwrap();
+    h.state_mut().session.execute("time.set", json!({"time": 2.0})).unwrap();
+    settle(&mut h);
     let gpu_px = h.state_mut().viewer_pixels().expect("read back the GPU frame");
     let gpu_shot = h.render().expect("render");
     // Mercury Software Only: the same frame from the CPU.
@@ -115,5 +233,12 @@ fn a_lost_device_draws_nothing_autosaves_and_closes() {
     let saved = h.state().session.autosave.last_path.clone().expect("unsaved changes auto-saved");
     assert!(std::path::Path::new(&saved).is_file(), "{saved}");
     assert_eq!(*told.borrow(), vec![Some(Ok(saved))], "the user is told once, with the recovery copy");
+    // The close arrives: on macOS the app quits through `-[NSApplication terminate:]` instead of
+    // closing the window while AppKit's run loop is running (#341).
+    h.input_mut().viewports.entry(egui::ViewportId::ROOT).or_default().events.push(egui::ViewportEvent::Close);
+    h.step();
+    let kept = h.output().viewport_output.get(&egui::ViewportId::ROOT).is_some_and(|v| v.commands.contains(&egui::ViewportCommand::CancelClose));
+    assert_eq!(kept, cfg!(target_os = "macos"), "the platform quit closes the window on macOS");
+    assert_eq!(told.borrow().len(), 1);
     let _ = std::fs::remove_dir_all(&dir);
 }
diff --git a/crates/ui-egui/tests/it/ui_gradient_editor.rs b/crates/ui-egui/tests/it/ui_gradient_editor.rs
index fa8c7b73f..f5ee8634b 100644
--- a/crates/ui-egui/tests/it/ui_gradient_editor.rs
+++ b/crates/ui-egui/tests/it/ui_gradient_editor.rs
@@ -197,7 +197,8 @@ fn stop_edits_ok_sets_the_gradient_in_one_undo_step() {
     let from = center(&h, "dialog.gradient.opacityStop.1");
     let to = along(&h, "dialog.gradient.opacityStop.1", 0.5);
     drag(&mut h, from, to);
-    assert_eq!(undo_len(&h), undo, "nothing is set while editing");
+    assert_eq!(undo_len(&h), undo + 1, "the live preview is one merged undo step while editing");
+    assert_eq!(gradient(&colors_prop(&h, l, colors).value).colors.len(), 3, "the property shows the edit before OK");
     click(&mut h, "dialog.gradient.ok");
     assert_eq!(h.state().dialog, None);
     let g = gradient(&colors_prop(&h, l, colors).value);
@@ -403,11 +404,13 @@ fn location_moves_past_a_neighbour_and_the_fields_follow_the_stop() {
     assert!(!shown.iter().any(|v| (v - 70.0).abs() < 1.0), "{shown:?}");
 }
 
-/// A layer deleted while the editor is open: OK reports it, without a crash.
+/// A layer deleted while the editor is open, Preview off: OK reports the failed set, without a
+/// crash.
 #[test]
 fn a_layer_deleted_while_editing_is_reported() {
     let (mut h, l, colors) = setup(&[]);
     open_editor(&mut h, colors);
+    click(&mut h, "dialog.gradient.preview");
     let p = along(&h, "dialog.gradient.addColor", 0.5);
     click_at(&mut h, p);
     h.state_mut().session.execute("edit.clear", json!({"layers": [l]})).unwrap();
@@ -417,6 +420,98 @@ fn a_layer_deleted_while_editing_is_reported() {
     assert!(!h.state().ui.status.is_empty(), "the failed set is reported");
 }
 
+/// The same with Preview on: the preview's set fails at the next edit and says so, and OK closes
+/// the editor without a crash.
+#[test]
+fn a_layer_deleted_during_the_preview_is_reported_at_the_next_edit() {
+    let (mut h, l, colors) = setup(&[]);
+    open_editor(&mut h, colors);
+    h.state_mut().session.execute("edit.clear", json!({"layers": [l]})).unwrap();
+    h.run_steps(2);
+    let p = along(&h, "dialog.gradient.addColor", 0.5);
+    click_at(&mut h, p);
+    assert!(!h.state().ui.status.is_empty(), "the failed preview set is reported");
+    click(&mut h, "dialog.gradient.ok");
+    assert_eq!(h.state().dialog, None);
+}
+
+/// Preview (on by default, as in After Effects): edits reach the property as they are made, in one
+/// undo step, and Cancel and Escape roll them back to how the editor opened.
+#[test]
+fn the_preview_applies_edits_live_and_cancel_rolls_them_back() {
+    let (mut h, l, colors) = setup(&[]);
+    let before = colors_prop(&h, l, colors).value.clone();
+    let undo = undo_len(&h);
+    open_editor(&mut h, colors);
+    assert!(h.state().gradient_draft().preview, "Preview starts on");
+    let p = along(&h, "dialog.gradient.addColor", 0.25);
+    click_at(&mut h, p);
+    assert_eq!(gradient(&colors_prop(&h, l, colors).value).colors.len(), 3, "the new stop shows at once");
+    let p = along(&h, "dialog.gradient.addColor", 0.75);
+    click_at(&mut h, p);
+    assert_eq!(gradient(&colors_prop(&h, l, colors).value).colors.len(), 4);
+    assert_eq!(undo_len(&h), undo + 1, "both edits are one undo step");
+    click(&mut h, "dialog.gradient.cancel");
+    assert_eq!(h.state().dialog, None);
+    assert_eq!(colors_prop(&h, l, colors).value, before, "Cancel puts the gradient back");
+    assert_eq!(undo_len(&h), undo, "and leaves no undo step");
+    // Escape does the same.
+    open_editor(&mut h, colors);
+    let p = along(&h, "dialog.gradient.addColor", 0.5);
+    click_at(&mut h, p);
+    assert_eq!(gradient(&colors_prop(&h, l, colors).value).colors.len(), 3);
+    key(&mut h, Key::Escape);
+    assert_eq!(h.state().dialog, None);
+    assert_eq!(colors_prop(&h, l, colors).value, before);
+    assert_eq!(undo_len(&h), undo);
+}
+
+/// An edit made in the same frame as OK is not in the last preview: OK sets the draft it finds.
+#[test]
+fn ok_in_the_frame_of_an_edit_sets_the_draft_not_the_older_preview() {
+    let (mut h, l, colors) = setup(&[]);
+    open_editor(&mut h, colors);
+    let p = along(&h, "dialog.gradient.addColor", 0.25);
+    click_at(&mut h, p);
+    assert_eq!(gradient(&colors_prop(&h, l, colors).value).colors.len(), 3, "the preview has three stops");
+    h.state_mut().gradient_draft_mut().add(Track::Color, 0.75);
+    let ctx = h.ctx.clone();
+    effectcraft_ui_egui::panels::gradient_editor::finish(h.state_mut(), true, &ctx);
+    assert_eq!(h.state().dialog, None);
+    assert_eq!(gradient(&colors_prop(&h, l, colors).value).colors.len(), 4, "OK sets the draft it found");
+}
+
+/// With Preview off nothing is set until OK, and switching it off takes back what it applied.
+#[test]
+fn with_preview_off_nothing_is_set_until_ok() {
+    let (mut h, l, colors) = setup(&[]);
+    let before = colors_prop(&h, l, colors).value.clone();
+    let undo = undo_len(&h);
+    open_editor(&mut h, colors);
+    let p = along(&h, "dialog.gradient.addColor", 0.25);
+    click_at(&mut h, p);
+    assert_eq!(gradient(&colors_prop(&h, l, colors).value).colors.len(), 3, "previewed");
+    click(&mut h, "dialog.gradient.preview");
+    assert!(!h.state().gradient_draft().preview);
+    assert_eq!(colors_prop(&h, l, colors).value, before, "switching Preview off takes the preview back");
+    assert_eq!(undo_len(&h), undo);
+    let p = along(&h, "dialog.gradient.addColor", 0.75);
+    click_at(&mut h, p);
+    assert_eq!(colors_prop(&h, l, colors).value, before, "nothing is set while editing");
+    click(&mut h, "dialog.gradient.ok");
+    assert_eq!(gradient(&colors_prop(&h, l, colors).value).colors.len(), 4, "OK sets the draft");
+    assert_eq!(undo_len(&h), undo + 1, "in one undo step");
+}
+
+/// The editor opens at the lower right of the window, so the canvas it edits stays in view.
+#[test]
+fn the_editor_opens_at_the_lower_right() {
+    let (mut h, _, colors) = setup(&[]);
+    open_editor(&mut h, colors);
+    let ok = center(&h, "dialog.gradient.ok");
+    assert!(ok.x > 800.0 && ok.y > 500.0, "the editor's OK button is in the lower right of the 1600 × 1000 window: {ok:?}");
+}
+
 /// `prop.editGradient` by id (agents, MCP, the control channel) is an error for a target that
 /// isn't a gradient property, from the engine and through the UI, and opens nothing.
 #[test]
diff --git a/crates/ui-egui/tests/it/ui_graph_fit.rs b/crates/ui-egui/tests/it/ui_graph_fit.rs
index c161dfef6..d80ae315e 100644
--- a/crates/ui-egui/tests/it/ui_graph_fit.rs
+++ b/crates/ui-egui/tests/it/ui_graph_fit.rs
@@ -77,3 +77,75 @@ fn open_graph_toggle_twice(h: &mut Harness<'_, EffectcraftApp>) {
     assert!(!h.state().ui.timeline.graph_editor);
     open_graph(h);
 }
+
+#[test]
+fn locked_graph_keys_preserve_the_existing_selection_and_keyframes() {
+    use egui::{Event, Modifiers, PointerButton, pos2, vec2};
+    for (button, modifiers, drag) in [
+        (PointerButton::Primary, Modifiers::NONE, false),
+        (PointerButton::Primary, Modifiers::SHIFT, false),
+        (PointerButton::Primary, Modifiers::COMMAND, false),
+        (PointerButton::Secondary, Modifiers::NONE, false),
+        (PointerButton::Primary, Modifiers::NONE, true),
+    ] {
+        let (mut h, layer, uid) = harness(true);
+        let s = &mut h.state_mut().session;
+        let locked = s.execute("layer.newSolid", json!({"name": "Locked", "color": "#fff"})).unwrap()["layer"].as_u64().unwrap();
+        for (time, value) in [(9.0, 100.0), (11.0, 200.0)] {
+            s.execute("prop.addKey", json!({"layer": locked, "path": "transform/rotation", "time": time, "value": value})).unwrap();
+        }
+        let locked_id = effectcraft_engine::project::LayerId(locked);
+        let locked_uid = s.active_comp().unwrap().layer(locked_id).unwrap().props.prop("transform/rotation").unwrap().uid;
+        s.execute("layer.setSwitch", json!({"layers": [locked], "switch": "locked", "value": true})).unwrap();
+        s.execute("keys.select", json!({"keys": [{"layer": layer, "prop": uid, "time": 12.0}]})).unwrap();
+        s.state.selected_props = vec![(effectcraft_engine::project::LayerId(layer), uid), (locked_id, locked_uid)];
+        let selection = s.state.selected_keys.clone();
+        let before = s.project.clone();
+        open_graph(&mut h);
+        h.state_mut().ui.timeline.graph_auto_zoom = false;
+        h.state_mut().ui.timeline.graph_range = Some((0.0, 800.0));
+        h.run_steps(3);
+        let [x, y, w, height] = h.state().auto.find(&format!("timeline.graph.key.{locked_uid}.0.0")).expect("locked key drawn").rect;
+        let point = pos2(x + w / 2.0, y + height / 2.0);
+        h.input_mut().events.push(Event::ModifiersChanged(modifiers));
+        h.input_mut().events.push(Event::PointerMoved(point));
+        h.input_mut().events.push(Event::PointerButton { pos: point, button, pressed: true, modifiers });
+        h.step();
+        let end = if drag { point + vec2(30.0, -20.0) } else { point };
+        h.input_mut().events.push(Event::PointerMoved(end));
+        h.step();
+        h.input_mut().events.push(Event::PointerButton { pos: end, button, pressed: false, modifiers });
+        h.run_steps(3);
+        assert_eq!(h.state().session.state.selected_keys, selection, "{button:?}, {modifiers:?}, drag={drag}");
+        assert_eq!(
+            serde_json::to_value(&h.state().session.project).unwrap(),
+            serde_json::to_value(&before).unwrap(),
+            "locked gestures must not edit another key"
+        );
+    }
+}
+
+#[test]
+fn an_unlocked_graph_keys_menu_edits_the_clicked_key() {
+    use egui::{Event, Modifiers, PointerButton, pos2};
+    use egui_kittest::kittest::Queryable;
+    let (mut h, layer, uid) = harness(true);
+    h.state_mut().session.execute("keys.select", json!({"keys": [{"layer": layer, "prop": uid, "time": 12.0}]})).unwrap();
+    open_graph(&mut h);
+    let [x, y, w, height] = h.state().auto.find(&format!("timeline.graph.key.{uid}.0.0")).unwrap().rect;
+    let at = pos2(x + w / 2.0, y + height / 2.0);
+    for pressed in [true, false] {
+        h.input_mut().events.push(Event::PointerMoved(at));
+        h.input_mut().events.push(Event::PointerButton { pos: at, button: PointerButton::Secondary, pressed, modifiers: Modifiers::NONE });
+        h.step();
+    }
+    h.run_steps(3);
+    let selected = &h.state().session.state.selected_keys;
+    assert_eq!(selected.len(), 1);
+    assert_eq!(selected[0].time.seconds(), 8.0);
+    h.get_by_label("Easy Ease").click();
+    h.run_steps(3);
+    let prop = h.state().session.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(layer)).unwrap().props.find(uid).unwrap();
+    assert_eq!(prop.keys[0].out_interp, effectcraft_engine::keyframe::Interp::Bezier);
+    assert_eq!(prop.keys[1].out_interp, effectcraft_engine::keyframe::Interp::Linear);
+}
diff --git a/crates/ui-egui/tests/it/ui_guide_layers.rs b/crates/ui-egui/tests/it/ui_guide_layers.rs
index 37158658f..92196f5f1 100644
--- a/crates/ui-egui/tests/it/ui_guide_layers.rs
+++ b/crates/ui-egui/tests/it/ui_guide_layers.rs
@@ -1,6 +1,7 @@
 //! Guide Layer in the layer context menus (Timeline rows and the Composition viewer), a plain item
 //! (no check mark) that toggles the switch on the selection, and the guide mark by a guide layer's
 //! name.
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_engine::project::LayerId;
 use effectcraft_ui_egui::EffectcraftApp;
@@ -45,7 +46,7 @@ fn guide(h: &Harness<'_, EffectcraftApp>, id: LayerId) -> bool {
 
 fn snapshot(h: &mut Harness<'_, EffectcraftApp>, name: &str) {
     if let Ok(dir) = std::env::var("GUIDE_LAYER_SNAPSHOTS") {
-        h.render().unwrap().save(format!("{dir}/{name}.png")).unwrap();
+        h.render_serialized().unwrap().save(format!("{dir}/{name}.png")).unwrap();
     }
 }
 
diff --git a/crates/ui-egui/tests/it/ui_inline_edit.rs b/crates/ui-egui/tests/it/ui_inline_edit.rs
index c9cf4693e..6c29045bb 100644
--- a/crates/ui-egui/tests/it/ui_inline_edit.rs
+++ b/crates/ui-egui/tests/it/ui_inline_edit.rs
@@ -634,6 +634,74 @@ fn an_expression_added_at_the_bottom_of_the_timeline_comes_into_view() {
     assert_eq!(expression(&h, layer, opacity).as_deref(), Some("25"));
 }
 
+/// A primary-button drag from `from` to `to` with `modifiers` held from the press to the release.
+fn drag_with(h: &mut Harness<'_, EffectcraftApp>, from: Pos2, to: Pos2, modifiers: Modifiers) {
+    h.input_mut().events.push(Event::PointerMoved(from));
+    h.input_mut().events.push(Event::ModifiersChanged(modifiers));
+    h.step();
+    h.input_mut().events.push(Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers });
+    h.step();
+    for k in 1..=8 {
+        h.input_mut().events.push(Event::PointerMoved(from + (to - from) * (k as f32 / 8.0)));
+        h.step();
+    }
+    h.input_mut().events.push(Event::PointerButton { pos: to, button: PointerButton::Primary, pressed: false, modifiers });
+    h.step();
+    h.input_mut().events.push(Event::ModifiersChanged(Modifiers::NONE));
+    h.run_steps(3);
+}
+
+/// #1072: with Alt held as it drops, a pick whip refers to an effect's property by its index,
+/// `effect("Slider Control")(1)`, as in After Effects; without Alt, by its name. Onto Effect
+/// Controls or the Timeline, and into the expression being edited (with a dimension).
+#[test]
+fn an_alt_pick_whip_refers_to_an_effect_property_by_index() {
+    let (mut h, _) = harness();
+    let (layer, opacity, transform, effects) = {
+        let s = &mut h.state_mut().session;
+        let l = s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080"})).unwrap()["layer"].as_u64().unwrap();
+        s.execute("layer.select", json!({"layers": [l]})).unwrap();
+        for fx in ["Slider Control", "Point Control"] {
+            s.execute("effect.apply", json!({"layers": [l], "effect": fx})).unwrap();
+        }
+        let props = s.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(l)).unwrap().props.clone();
+        let effects: Vec<u64> = std::iter::once(props.sub("effects").unwrap().uid).chain(props.sub("effects").unwrap().groups().map(|g| g.uid)).collect();
+        (l, props.sub("transform").unwrap().get("opacity").unwrap().uid, props.sub("transform").unwrap().uid, effects)
+    };
+    h.state_mut().ui.timeline.open_layers.insert(layer);
+    h.state_mut().ui.timeline.open_groups.insert(transform);
+    h.state_mut().ui.timeline.open_groups.extend(effects);
+    h.state_mut().show_panel(effectcraft_ui_egui::dock::PanelKind::EffectControls);
+    h.run_steps(3);
+    let props =
+        |h: &Harness<'_, EffectcraftApp>| h.state().session.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(layer)).unwrap().props.clone();
+    let (slider, point) = (props(&h).prop("effects/#1/slider").unwrap().uid, props(&h).prop("effects/#2/point").unwrap().uid);
+    let expr = |h: &Harness<'_, EffectcraftApp>| props(h).find(opacity).unwrap().expr.clone().map(|e| e.text);
+    let alt = Modifiers { alt: true, ..Modifiers::NONE };
+    let whip = |h: &mut Harness<'_, EffectcraftApp>, target: &str, modifiers: Modifiers| {
+        let (from, to) = (center(h, &format!("timeline.prop.{opacity}.propertyPickWhip")), center(h, target));
+        drag_with(h, from, to, modifiers);
+    };
+    whip(&mut h, &format!("effectControls.prop.{slider}.value"), alt);
+    assert_eq!(expr(&h).as_deref(), Some("effect(\"Slider Control\")(1)"), "Alt onto Effect Controls");
+    let undo = h.state().session.history.undo.len();
+    whip(&mut h, &format!("effectControls.prop.{slider}.value"), Modifiers::NONE);
+    assert_eq!(expr(&h).as_deref(), Some("effect(\"Slider Control\")(\"Slider\")"), "without Alt, by name");
+    assert_eq!(h.state().session.history.undo.len(), undo + 1, "one undo step");
+    whip(&mut h, &format!("timeline.prop.{slider}.name"), alt);
+    assert_eq!(expr(&h).as_deref(), Some("effect(\"Slider Control\")(1)"), "Alt onto the Timeline");
+    // Into the expression being edited, at the cursor, with the value it was dropped on.
+    let p = center(&h, &format!("timeline.prop.{opacity}.expression"));
+    click(&mut h, p, 1);
+    key(&mut h, Key::End);
+    type_text(&mut h, " + ");
+    let (from, to) = (center(&h, &format!("timeline.prop.{opacity}.pickWhip")), center(&h, &format!("effectControls.prop.{point}.value.1")));
+    drag_with(&mut h, from, to, alt);
+    assert_eq!(expr(&h).as_deref(), Some("effect(\"Slider Control\")(1) + effect(\"Point Control\")(1)[1]"));
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(expr(&h).as_deref(), Some("effect(\"Slider Control\")(1)"), "undone in one step");
+}
+
 /// #1434: with several 3D layers selected, typing a Z Position sets Z on each of them; their X
 /// and Y stay their own. Every selected layer used to take the typed layer's whole Position, so
 /// they stacked on top of it and seemed to disappear.
diff --git a/crates/ui-egui/tests/it/ui_keyframes.rs b/crates/ui-egui/tests/it/ui_keyframes.rs
index b47963d85..b137a06fc 100644
--- a/crates/ui-egui/tests/it/ui_keyframes.rs
+++ b/crates/ui-egui/tests/it/ui_keyframes.rs
@@ -105,11 +105,15 @@ fn ctrl_c_and_ctrl_v_copy_and_paste_keys_at_the_current_time() {
             _ => None,
         })
         .collect();
-    assert_eq!(copied, ["EffectCraft: 1 keyframe"], "the system clipboard is filled, so Ctrl+V sends a paste event");
+    // The system clipboard has the key as After Effects keyframe text (for other applications),
+    // so it isn't empty and Ctrl+V sends a paste event.
+    let [text] = copied.as_slice() else { panic!("one copy: {copied:?}") };
+    assert!(text.starts_with("Adobe After Effects 9.0 Keyframe Data\n"), "{text}");
+    assert!(text.contains("Transform\tOpacity\n\tFrame\tpercent\t\n\t30\t100\t\n"), "{text}");
     assert!(h.state().session.state.clip_is_keys);
     // Move to 3 s, Ctrl+V: the key lands there.
     h.state_mut().session.set_time(effectcraft_engine::time::Tick::from_seconds_f64(3.0));
-    h.input_mut().events.push(Event::Paste("EffectCraft: 1 keyframe".into()));
+    h.input_mut().events.push(Event::Paste(text.clone()));
     h.run_steps(2);
     assert_eq!(key_times(&h, id), vec![0.0, 1.0, 3.0]);
 }
@@ -190,8 +194,18 @@ fn copy_and_paste_key_subsets_across_position_rotation_and_scale() {
             assert_eq!(h.state().session.state.selected_props.len(), 3);
             h.input_mut().events.push(Event::Copy);
             h.step();
-            let note = format!("EffectCraft: {count} keyframes");
-            assert!(h.output().platform_output.commands.iter().any(|command| matches!(command, egui::OutputCommand::CopyText(text) if text == &note)));
+            let note = h
+                .output()
+                .platform_output
+                .commands
+                .iter()
+                .find_map(|command| match command {
+                    egui::OutputCommand::CopyText(text) => Some(text.clone()),
+                    _ => None,
+                })
+                .unwrap();
+            let rows = note.lines().filter(|line| line.strip_prefix('\t').is_some_and(|row| row.starts_with(|c: char| c.is_ascii_digit()))).count();
+            assert_eq!(rows, count, "one row per copied key: {note}");
             h.state_mut().session.set_time(effectcraft_engine::time::Tick::from_seconds_f64(2.0));
             let undo_steps = h.state().session.history.undo.len();
             h.input_mut().events.push(Event::Paste(note));
diff --git a/crates/ui-egui/tests/it/ui_layer_panel_zoom.rs b/crates/ui-egui/tests/it/ui_layer_panel_zoom.rs
index 1aabdd2bc..73ed95cbd 100644
--- a/crates/ui-egui/tests/it/ui_layer_panel_zoom.rs
+++ b/crates/ui-egui/tests/it/ui_layer_panel_zoom.rs
@@ -107,8 +107,8 @@ fn wheel_zooms_around_the_pointer_and_hand_tool_pans() {
     let at = canvas.min + canvas.size() * 0.25;
     h.input_mut().events.push(Event::PointerMoved(at));
     h.input_mut().events.push(Event::MouseWheel {
-        unit: egui::MouseWheelUnit::Point,
-        delta: vec2(0.0, 120.0),
+        unit: egui::MouseWheelUnit::Line,
+        delta: vec2(0.0, 3.0),
         modifiers: Default::default(),
         phase: egui::TouchPhase::Move,
         source: egui::MouseWheelSource::Wheel,
@@ -176,3 +176,33 @@ fn roto_brush_in_the_composition_panel_says_where_it_works() {
     assert_eq!(h.state().ui.layer_panel, Some(box_id(&h)));
     assert_eq!(h.state().ui.focused, PanelKind::Layer);
 }
+
+/// A two-finger trackpad scroll pans the layer with any tool and a pinch zooms around the pointer.
+#[test]
+fn trackpad_scroll_pans_and_pinch_zooms_around_the_pointer() {
+    let mut h = harness();
+    let canvas = rect(&h, "layerPanel.canvas");
+    let at = canvas.min + canvas.size() * 0.25;
+    h.input_mut().events.push(Event::PointerMoved(at));
+    h.input_mut().events.push(Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Point,
+        delta: vec2(60.0, -30.0),
+        modifiers: Default::default(),
+        phase: egui::TouchPhase::Move,
+        source: egui::MouseWheelSource::Unknown,
+    });
+    h.run_steps(30);
+    let panned = rect(&h, "layerPanel.canvas");
+    let moved = panned.min - canvas.min;
+    assert!((moved.x - 60.0).abs() < 1.5 && (moved.y + 30.0).abs() < 1.5, "the scroll pans: {moved:?}");
+    assert!((panned.width() - canvas.width()).abs() < 0.5, "a scroll doesn't zoom: {} → {}", canvas.width(), panned.width());
+    // Pinch: zooms, keeping the point under the pointer.
+    let at = panned.min + panned.size() * 0.25;
+    h.input_mut().events.push(Event::PointerMoved(at));
+    h.input_mut().events.push(Event::Zoom(1.5));
+    h.run_steps(3);
+    let zoomed = rect(&h, "layerPanel.canvas");
+    assert!((zoomed.width() / panned.width() - 1.5).abs() < 0.01, "the pinch zooms: {} → {}", panned.width(), zoomed.width());
+    let still = zoomed.min + zoomed.size() * 0.25;
+    assert!(still.distance(at) < 2.0, "the point under the pointer stays put: {at:?} vs {still:?}");
+}
diff --git a/crates/ui-egui/tests/it/ui_layer_source_picker.rs b/crates/ui-egui/tests/it/ui_layer_source_picker.rs
index 78a0f8821..2daa450c4 100644
--- a/crates/ui-egui/tests/it/ui_layer_source_picker.rs
+++ b/crates/ui-egui/tests/it/ui_layer_source_picker.rs
@@ -3,6 +3,7 @@
 //! Effect Controls' layer parameters (a Displacement Map's layer) pick through the same widget,
 //! and both write an undoable `prop.set`.
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_engine::keyframe::Value;
 use effectcraft_engine::project::LayerId;
@@ -52,8 +53,7 @@ fn entry_for(h: &Harness<'_, EffectcraftApp>, layer: u64) -> String {
     format!("{}. {}", i + 1, comp.layers[i].name)
 }
 
-/// Puts the layer-valued `prop` of `layer` back to `value` with a direct `prop.set` (no merge key,
-/// so the pick below records its own step instead of folding into a picker write), picks `none`
+/// Puts the layer-valued `prop` of `layer` back to `value` with a direct `prop.set`, picks `none`
 /// from the drop-down at `value_id`, and checks the clear takes one undo step that restores `value`.
 #[track_caller]
 fn none_pick_clears(h: &mut Harness<'_, EffectcraftApp>, value_id: &str, none: &str, layer: u64, prop: u64, value: u64) {
@@ -72,6 +72,24 @@ fn none_pick_clears(h: &mut Harness<'_, EffectcraftApp>, value_id: &str, none: &
     assert_eq!(layer_value(h, layer, prop), Some(value), "undo restores the selected layer");
 }
 
+/// #2152: two picks in a row from the drop-down at `value_id` (`first`, the layer `value`, then
+/// `none`) are two undo steps: one Undo goes back to the first pick, not past it.
+#[track_caller]
+fn picks_are_separate_steps(h: &mut Harness<'_, EffectcraftApp>, value_id: &str, first: &str, none: &str, layer: u64, prop: u64, value: u64) {
+    let steps = h.state().session.history.undo.len();
+    for entry in [first, none] {
+        let at = rect_of(h, value_id).center();
+        click(h, at);
+        h.get_by_role_and_label(egui::accesskit::Role::Button, entry).click();
+        h.run_steps(3);
+    }
+    assert_eq!(layer_value(h, layer, prop), None);
+    assert_eq!(h.state().session.history.undo.len(), steps + 2, "each pick is its own undo step");
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    h.run_steps(2);
+    assert_eq!(layer_value(h, layer, prop), Some(value), "one undo goes back to the first pick");
+}
+
 /// A light's Source (a layer-valued Light Options property) picks a comp layer from the
 /// Timeline and undo restores None.
 #[test]
@@ -137,6 +155,9 @@ fn timeline_source_drop_down_picks_the_layer_and_undo_restores_none() {
     assert_eq!(layer_value(&h, light, source), None, "undo restores None");
 
     none_pick_clears(&mut h, &value_id, "None", light, source, sky);
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    h.run_steps(2);
+    picks_are_separate_steps(&mut h, &value_id, &entry, "None", light, source, sky);
 }
 
 /// The shared widget is the one Effect Controls already used: a Displacement Map's layer
@@ -175,6 +196,9 @@ fn effect_controls_layer_param_picks_through_the_shared_widget() {
     assert_eq!(layer_value(&h, base, prop), None, "undo restores None");
 
     none_pick_clears(&mut h, &value_id, "None", base, prop, map);
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    h.run_steps(2);
+    picks_are_separate_steps(&mut h, &value_id, &entry, "None", base, prop, map);
 }
 
 /// The visual record (the `ui_3d` ignored-snapshot convention): the Source drop-down open over
@@ -183,6 +207,7 @@ fn effect_controls_layer_param_picks_through_the_shared_widget() {
 #[test]
 #[ignore = "renders with wgpu; run with --ignored (set EC_SNAPSHOT_DIR to keep PNGs)"]
 fn snapshot_source_dropdown_open_and_chosen() {
+    let _device = crate::gpu_test::lock();
     let mut s = Session::default();
     s.execute("comp.new", json!({"name": "Main", "width": 1280, "height": 720, "frameRate": 30, "duration": 5})).unwrap();
     s.execute("comp.settings", json!({"renderer": "advanced3D"})).unwrap();
@@ -200,7 +225,7 @@ fn snapshot_source_dropdown_open_and_chosen() {
     h.run_steps(4);
     let save = |h: &mut Harness<'_, EffectcraftApp>, name: &str| {
         if let Ok(dir) = std::env::var("EC_SNAPSHOT_DIR") {
-            h.render().expect("render").save(format!("{dir}/{name}")).expect("save");
+            h.render_serialized().expect("render").save(format!("{dir}/{name}")).expect("save");
         }
     };
     save(&mut h, "source_unset.png");
diff --git a/crates/ui-egui/tests/it/ui_light_settings.rs b/crates/ui-egui/tests/it/ui_light_settings.rs
index fe1392be1..aac090802 100644
--- a/crates/ui-egui/tests/it/ui_light_settings.rs
+++ b/crates/ui-egui/tests/it/ui_light_settings.rs
@@ -177,13 +177,33 @@ fn falloff_and_shadow_options_show_only_for_lights_that_have_them() {
     invoke(&mut h, "layer.newLight", json!({}));
     for k in LightKind::ALL {
         choose(&mut h, k);
-        let shown = !matches!(k, LightKind::Ambient | LightKind::Environment);
-        for label in ["Falloff", "Casts Shadows", "Shadow Darkness"] {
-            assert_eq!(h.query_by_label(label).is_some(), shown, "{label} for {}", k.label());
+        // Falloff is distance attenuation: image-based Environment lights and Ambient have none.
+        let falloff = !matches!(k, LightKind::Ambient | LightKind::Environment);
+        assert_eq!(h.query_by_label("Falloff").is_some(), falloff, "Falloff for {}", k.label());
+        // Cast Shadows shows for every light but Ambient, Environment included (#2436).
+        let shadows = k != LightKind::Ambient;
+        for label in ["Casts Shadows", "Shadow Darkness"] {
+            assert_eq!(h.query_by_label(label).is_some(), shadows, "{label} for {}", k.label());
         }
     }
 }
 
+/// #2436: an Environment light created through the dialog keeps its Cast Shadows, which the
+/// engine stores on the layer.
+#[test]
+fn an_environment_light_takes_cast_shadows_from_the_dialog() {
+    let mut h = harness();
+    invoke(&mut h, "layer.newLight", json!({}));
+    choose(&mut h, LightKind::Environment);
+    click_id(&mut h, "dialog.light.casts");
+    ok(&mut h);
+    let id = last_layer(&h);
+    assert_eq!(kind(&h, id), LightKind::Environment);
+    let l = layer(&h, id);
+    assert!(l.props.prop("lightOptions/castsShadows").unwrap().value.as_bool(), "the dialog's checkbox reached the layer");
+    assert!(l.props.prop("lightOptions/shadowDarkness").is_some() && l.props.prop("lightOptions/falloff").is_none());
+}
+
 #[test]
 fn changing_an_environment_light_to_spot_undoes_to_its_source_and_rotation() {
     let mut h = harness();
diff --git a/crates/ui-egui/tests/it/ui_marker_names.rs b/crates/ui-egui/tests/it/ui_marker_names.rs
new file mode 100644
index 000000000..190bd77bb
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_marker_names.rs
@@ -0,0 +1,120 @@
+//! A marker's name is drawn in a small outlined box beside its flag, in the theme's own field colours (egui_kittest, a real
+//! render): the fill and the outline follow Dark and Light, and the two themes differ. `MARKER_NAMES_SNAPSHOT=/abs/dir`
+//! also saves the rendered panel for each theme.
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::theme::ThemeKind;
+use egui_kittest::Harness;
+use serde_json::json;
+
+fn close(got: [u8; 4], want: egui::Color32) -> bool {
+    got[..3].iter().zip(want.to_array()).all(|(a, b)| a.abs_diff(b) <= 3)
+}
+
+#[test]
+fn the_name_box_follows_the_theme() {
+    let _one_at_a_time = crate::gpu_test::lock();
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Song", "width": 640, "height": 360, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Bed", "color": "#204060", "width": 640, "height": 360})).unwrap();
+    s.execute("markers.set", json!({"new": true, "time": 1.0, "comment": "Verse"})).unwrap();
+
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(move |_| EffectcraftApp::new(s));
+    h.run_steps(4);
+    let ctx = h.ctx.clone();
+
+    let mut seen = vec![];
+    for (kind, name) in [(ThemeKind::Dark, "dark"), (ThemeKind::Light, "light")] {
+        h.state_mut().set_theme(&ctx, kind);
+        h.run_steps(4);
+        let tokens = h.state().tokens;
+        assert_eq!(tokens.kind, kind);
+        // the flag's hit area is 10 wide, centred on the marker; the box starts 6 points right of the centre
+        let hit = h.state().auto.find("timeline.marker.0").unwrap_or_else(|| panic!("the marker is on screen ({name})")).rect;
+        let (x, y0) = (hit[0] + hit[2] / 2.0, hit[1] + 1.0);
+        let h_flag = (hit[3] - 1.0).min(10.0);
+        let image = h.render().expect("the panel renders");
+        if let Some(dir) = std::env::var_os("MARKER_NAMES_SNAPSHOT") {
+            image.save(std::path::Path::new(&dir).join(format!("marker-name-{name}.png"))).unwrap();
+        }
+        let scale = image.width() as f32 / 1600.0;
+        let at = |px: f32, py: f32| image.get_pixel((px * scale) as u32, (py * scale) as u32).0;
+        let mid = y0 + h_flag / 2.0;
+        // inside the box, left of the text: the field fill; on its left edge: the field outline
+        let fill = at(x + 6.0 + 2.5, mid);
+        let edge = at(x + 6.0 + 0.5, mid);
+        assert!(close(fill, tokens.field_bg), "{name}: box fill {fill:?}, the theme's field_bg is {:?}", tokens.field_bg);
+        assert!(close(edge, tokens.field_border), "{name}: box outline {edge:?}, the theme's field_border is {:?}", tokens.field_border);
+        seen.push((fill, edge));
+    }
+    assert_ne!(seen[0], seen[1], "the box looks different in Dark and in Light, so it is not a fixed grey");
+}
+
+/// A duration shorter than the name box ends where the box would sit. The box steps past the end cap, so the duration
+/// stays visible: the cap is drawn, the bar shows left of it, and the box starts after it.
+#[test]
+fn a_short_duration_stays_visible_beside_the_name_box() {
+    let _one_at_a_time = crate::gpu_test::lock();
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Song", "width": 640, "height": 360, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Bed", "color": "#204060", "width": 640, "height": 360})).unwrap();
+    s.execute("markers.set", json!({"new": true, "time": 1.0, "comment": "Verse", "duration": 0.1})).unwrap();
+    // a second marker half a second later gives the timeline's scale (points per second)
+    s.execute("markers.set", json!({"new": true, "time": 1.5})).unwrap();
+
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(move |_| EffectcraftApp::new(s));
+    h.run_steps(5);
+    let tokens = h.state().tokens;
+    let centre = |id: &str| {
+        let r = h.state().auto.find(id).unwrap_or_else(|| panic!("{id} is on screen")).rect;
+        (r[0] + r[2] / 2.0, r[1] + 1.0, (r[3] - 1.0).min(10.0))
+    };
+    let ((xa, y0, flag_h), (xb, _, _)) = (centre("timeline.marker.0"), centre("timeline.marker.1"));
+    let per_second = (xb - xa) / 0.5;
+    let xe = xa + 0.1 * per_second;
+    assert!(xe - xa < 30.0, "the duration is shorter than the name box: {} points", xe - xa);
+    let image = h.render().expect("the panel renders");
+    if let Some(dir) = std::env::var_os("MARKER_NAMES_SNAPSHOT") {
+        image.save(std::path::Path::new(&dir).join("marker-short-duration.png")).unwrap();
+    }
+    let scale = image.width() as f32 / 1600.0;
+    let at = |px: f32, py: f32| image.get_pixel((px * scale) as u32, (py * scale) as u32).0;
+    let mid = y0 + flag_h / 2.0;
+    // the end cap: a pixel in the marker's colour (new markers are red; the theme's field fill is neutral) within a point
+    // of where the duration ends, which the box would otherwise cover
+    let cap = (-1..=1).map(|d| at(xe + d as f32, mid)).max_by_key(|p| i32::from(p[0]) - i32::from(p[1])).unwrap();
+    assert!(i32::from(cap[0]) - i32::from(cap[1]) > 40, "the end cap is drawn: {cap:?}");
+    // the bar shows left of the cap, not the box's fill
+    let bar = at(xe - 4.0, mid);
+    assert!(i32::from(bar[0]) - i32::from(bar[1]) > 20, "the bar shows left of the end cap, not the box: {bar:?}");
+    // the box starts after the cap
+    let fill = at(xe + 3.0 + 2.5, mid);
+    assert!(close(fill, tokens.field_bg), "the box begins after the end cap: {fill:?}, field_bg {:?}", tokens.field_bg);
+}
+
+#[test]
+fn a_later_name_box_does_not_hide_an_earlier_duration_cap() {
+    let _one_at_a_time = crate::gpu_test::lock();
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"width": 640, "height": 360, "duration": 4})).unwrap();
+    s.execute("markers.set", json!({"new": true, "time": 1.0, "duration": 0.5, "label": "Red"})).unwrap();
+    s.execute("markers.set", json!({"new": true, "time": 1.3, "comment": "This name overlaps the earlier endpoint", "label": "Blue"})).unwrap();
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(move |_| EffectcraftApp::new(s));
+    h.run_steps(5);
+    let a = h.state().auto.find("timeline.marker.0").unwrap().rect;
+    let b = h.state().auto.find("timeline.marker.1").unwrap().rect;
+    let x = |r: [f32; 4]| r[0] + r[2] / 2.0;
+    let end = x(a) + (x(b) - x(a)) * 0.5 / 0.3;
+    let y = a[1] + 1.0 + (a[3] - 1.0).min(10.0) / 2.0;
+    let image = h.render().unwrap();
+    if let Some(dir) = std::env::var_os("MARKER_NAMES_SNAPSHOT") {
+        image.save(std::path::Path::new(&dir).join("marker-overlapping-cap.png")).unwrap();
+    }
+    let scale = image.width() as f32 / 1600.0;
+    let cap = (-1..=1)
+        .map(|offset| image.get_pixel(((end + offset as f32) * scale) as u32, (y * scale) as u32).0)
+        .max_by_key(|pixel| i32::from(pixel[0]) - i32::from(pixel[1]))
+        .unwrap();
+    assert!(i32::from(cap[0]) - i32::from(cap[1]) > 40, "the earlier red duration cap stays above the later name: {cap:?}");
+}
diff --git a/crates/ui-egui/tests/it/ui_media_browser_cache.rs b/crates/ui-egui/tests/it/ui_media_browser_cache.rs
index ddfc53e22..44ca9dd81 100644
--- a/crates/ui-egui/tests/it/ui_media_browser_cache.rs
+++ b/crates/ui-egui/tests/it/ui_media_browser_cache.rs
@@ -1,3 +1,4 @@
+use crate::gpu_test::RenderSerial;
 use std::sync::{
     Arc, Mutex,
     atomic::{AtomicBool, Ordering},
@@ -140,6 +141,6 @@ fn browser_cache_refreshes_filters_navigates_and_recovers_from_errors() {
     assert_eq!(names(&listing(&h, false).1), ["Sub", "Added.csv", "Clip.csv", "From action.csv"]);
     assert!(h.state().auto.find("mediaBrowser.entry.Clip.csv").is_some());
     if let Ok(path) = std::env::var("MEDIA_BROWSER_SNAPSHOT") {
-        h.render().unwrap().save(path).unwrap();
+        h.render_serialized().unwrap().save(path).unwrap();
     }
 }
diff --git a/crates/ui-egui/tests/it/ui_media_browser_copy_path.rs b/crates/ui-egui/tests/it/ui_media_browser_copy_path.rs
index dff60ddd0..8372b2be5 100644
--- a/crates/ui-egui/tests/it/ui_media_browser_copy_path.rs
+++ b/crates/ui-egui/tests/it/ui_media_browser_copy_path.rs
@@ -1,3 +1,4 @@
+use crate::gpu_test::RenderSerial;
 use std::sync::Arc;
 
 use effectcraft_engine::{
@@ -74,7 +75,7 @@ fn file_folder_and_virtual_paths_copy_from_the_context_menu_without_document_cha
         if name == "作品 clip.csv"
             && let Ok(file) = std::env::var("MEDIA_BROWSER_COPY_SNAPSHOT")
         {
-            h.render().unwrap().save(file).unwrap();
+            h.render_serialized().unwrap().save(file).unwrap();
         }
         assert_eq!(click(&mut h, &id, PointerButton::Primary), [path]);
         h.run_steps(3);
diff --git a/crates/ui-egui/tests/it/ui_menus.rs b/crates/ui-egui/tests/it/ui_menus.rs
index 90207b52d..512f1f376 100644
--- a/crates/ui-egui/tests/it/ui_menus.rs
+++ b/crates/ui-egui/tests/it/ui_menus.rs
@@ -1,6 +1,7 @@
 //! The menu bar from the keyboard, and the app's shortcuts waiting while a menu is open (#279)
 //! (egui_kittest, UI logic only).
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_ui_egui::EffectcraftApp;
 use egui::{Event, Key, Modifiers, Pos2, Rect, pos2, vec2};
@@ -65,6 +66,47 @@ fn shown(h: &Harness<'_, EffectcraftApp>, label: &str) -> bool {
     h.query_by_label_contains(label).is_some()
 }
 
+#[test]
+fn browse_presets_clears_search_and_scrolls_to_the_visible_presets_list() {
+    use effectcraft_ui_egui::dock::PanelKind;
+
+    let mut h = harness();
+    let ctx = h.ctx.clone();
+    let favorites: Vec<String> = effectcraft_engine::effects::all().iter().map(|effect| effect.id.to_string()).collect();
+    assert!(!favorites.is_empty(), "the test needs registered effects");
+    let recent: Vec<String> = favorites.iter().take(8).cloned().collect();
+
+    h.state_mut().session.prefs.effects_favorites = favorites;
+    h.state_mut().ui.effects_recent = recent;
+    h.state_mut().ui.effects_open.extend(["favorites".into(), "recent".into()]);
+    h.state_mut().ui.effects_search = "no matching animation preset".into();
+    h.state_mut().ui.effects_view.presets = true;
+
+    let managed = effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "effect.manage", json!({}));
+    assert!(managed.is_ok(), "{managed:?}");
+    assert_eq!(h.state().ui.focused, PanelKind::EffectsPresets);
+    assert_eq!(h.state().ui.effects_search, "no matching animation preset", "Manage Effects keeps its existing search behavior");
+    assert!(h.state().ui.effects_view.presets, "Manage Effects keeps the existing presets setting");
+
+    h.run_steps(3);
+    assert!(h.state().auto.find("effects.category.presets").is_none(), "the unmatched search hides Animation Presets");
+    h.state_mut().ui.effects_view.presets = false;
+
+    let result = effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "anim.browsePresets", json!({}));
+
+    assert!(result.is_ok(), "{result:?}");
+    assert_eq!(h.state().ui.focused, PanelKind::EffectsPresets);
+    assert!(h.state().ui.effects_search.is_empty());
+    assert!(h.state().ui.effects_view.presets);
+    assert!(h.state().ui.effects_open.contains("presets"));
+
+    h.run_steps(3);
+    assert!(
+        h.state().auto.find("effects.category.presets").is_some(),
+        "Animation Presets must be visible after Browse Presets, even below expanded Favorites and Recently Used"
+    );
+}
+
 /// Space (or any shortcut) while a menu is open goes to the menu, not the app: it started the
 /// preview behind the open menu.
 #[test]
@@ -185,7 +227,7 @@ fn relink_is_reachable_through_the_dependencies_menu() {
     h.run_steps(8);
     let relink = h.query_by_label_contains("Relink Missing Footage").unwrap().rect();
     if let Some(path) = std::env::var_os("EFFECTCRAFT_RELINK_MENU_SNAPSHOT") {
-        h.render().unwrap().save(path).unwrap();
+        h.render_serialized().unwrap().save(path).unwrap();
     }
     click_at(&mut h, relink.center());
     assert!(picked.get());
@@ -224,10 +266,10 @@ fn relink_restores_decoded_pixels_and_invalidates_viewer_content() {
     std::fs::remove_dir_all(dir).unwrap();
 }
 
-/// #767: File ▸ Import ▸ File… offers MXF footage (OP1a / OP-Atom from broadcast cameras and
-/// Avid), which the Media Browser lists and the importer reads.
+/// #767, #1701: File ▸ Import ▸ File… and the proxy dialog offer every movie type the importer
+/// reads (MXF from broadcast cameras and Avid, AVI, …), the list the Media Browser goes by too.
 #[test]
-fn import_dialog_offers_mxf() {
+fn import_and_proxy_dialogs_offer_every_movie_type() {
     use std::cell::RefCell;
     use std::rc::Rc;
 
@@ -238,11 +280,15 @@ fn import_dialog_offers_mxf() {
         *seen.borrow_mut() = exts.iter().map(|e| e.to_string()).collect();
         Vec::new()
     }));
-    let result = effectcraft_ui_egui::menus::invoke(&mut app, &egui::Context::default(), "file.import", json!({})).unwrap();
-    assert!(result.is_null(), "cancelled: nothing imported");
-    let offered = offered.borrow();
-    assert!(offered.iter().any(|e| e == "mxf"), "offered {offered:?}");
-    assert!(offered.iter().any(|e| e == "mov"));
+    for (command, still) in [("file.import", "psd"), ("file.setProxy", "png")] {
+        let result = effectcraft_ui_egui::menus::invoke(&mut app, &egui::Context::default(), command, json!({})).unwrap();
+        assert!(result.is_null(), "{command} cancelled: nothing done");
+        let offered = offered.borrow();
+        for ext in effectcraft_project::VIDEO_EXTENSIONS.iter().chain([&still]) {
+            assert!(offered.iter().any(|e| e == ext), "{command} offers {ext}: {offered:?}");
+        }
+        assert!(offered.iter().any(|e| e == "avi"), "{command}: {offered:?}");
+    }
 }
 
 /// #1059: opening the demo from the start screen and immediately pressing Spacebar previews
@@ -318,7 +364,8 @@ fn hold_browse_opens_a_submenu_and_the_release_inside_picks_an_entry() {
     h.state_mut().session.state.selected_layers = vec![first];
     let effect = rect(&h, "menu.Effect");
     press(&mut h, effect.center());
-    assert!(shown(&h, "Effect Controls"), "the Effect menu opens on the press");
+    // (Effect ▸ Remove All: "Effect Controls" also names the panel's tab.)
+    assert!(shown(&h, "Remove All"), "the Effect menu opens on the press");
     // The categories come from the effect registry; the first alphabetically is "3D Channel".
     let cat = h.query_by_label_contains("3D Channel").expect("the category row is shown").rect();
     move_to(&mut h, cat.center());
@@ -326,7 +373,7 @@ fn hold_browse_opens_a_submenu_and_the_release_inside_picks_an_entry() {
     let entry = h.query_by_label_contains("Cryptomatte").expect("the submenu is open").rect();
     move_to(&mut h, entry.center());
     release(&mut h, entry.center());
-    assert!(!shown(&h, "Effect Controls"), "the release closed the menus");
+    assert!(!shown(&h, "Remove All"), "the release closed the menus");
     assert!(h.state().session.state.last_effect.is_some(), "and the release chose the entry: it applied its effect");
 }
 
@@ -372,3 +419,63 @@ fn outside_presses_and_focus_loss_close_the_menus() {
     h.run_steps(2);
     assert!(!shown(&h, "Open Project"), "losing focus closes the menus");
 }
+
+/// From an open submenu, the pointer reaching another title switches menus too (#1290).
+#[test]
+fn hovering_a_title_from_an_open_submenu_switches_menus() {
+    let mut h = harness();
+    let (file, edit) = (rect(&h, "menu.File"), rect(&h, "menu.Edit"));
+    click_at(&mut h, file.center());
+    let new = h.query_by(|n| n.label().is_some_and(|l| l.trim_end_matches('\u{23f5}').trim() == "New")).expect("File ▸ New").rect();
+    move_to(&mut h, new.center());
+    h.run_steps(5);
+    assert!(shown(&h, "New Project from Template"), "the New submenu is open");
+    move_to(&mut h, edit.center());
+    assert!(shown(&h, "Keyboard Shortcuts"), "hovering Edit opened it");
+    assert!(!shown(&h, "New Project from Template") && !shown(&h, "Open Project"), "and closed File and its submenu");
+}
+
+/// A title the pointer can't reach (the app is disabled under a dialog) doesn't switch menus
+/// (#1290).
+#[test]
+fn a_disabled_title_does_not_switch_menus() {
+    let mut h = harness();
+    let (file, edit) = (rect(&h, "menu.File"), rect(&h, "menu.Edit"));
+    click_at(&mut h, file.center());
+    h.state_mut().dialog = Some(effectcraft_ui_egui::Dialog::About);
+    h.run_steps(2);
+    move_to(&mut h, edit.center());
+    assert!(!shown(&h, "Keyboard Shortcuts"), "Edit didn't open");
+}
+
+/// A pointer resting on a title doesn't undo Left / Right: only a moving pointer switches
+/// (#1290).
+#[test]
+fn a_resting_pointer_does_not_override_the_arrow_keys() {
+    if cfg!(target_os = "macos") {
+        // (Right / Left between menus are tested where the in-window bar is the app's menu.)
+        return;
+    }
+    let mut h = harness();
+    let file = rect(&h, "menu.File");
+    click_at(&mut h, file.center());
+    key(&mut h, Key::ArrowRight);
+    h.run_steps(3);
+    assert!(shown(&h, "Keyboard Shortcuts"), "Right opened Edit with the pointer still on File");
+    assert!(!shown(&h, "Open Project"));
+}
+
+/// Leaving the window keeps the menu open, and coming back in over another title switches to it
+/// (#1290): egui reports no pointer movement for that first position.
+#[test]
+fn pointer_reentering_over_another_title_switches_menus() {
+    let mut h = harness();
+    let (file, edit) = (rect(&h, "menu.File"), rect(&h, "menu.Edit"));
+    click_at(&mut h, file.center());
+    h.input_mut().events.push(Event::PointerGone);
+    h.run_steps(2);
+    assert!(shown(&h, "Open Project"), "leaving the window kept File open");
+    move_to(&mut h, edit.center());
+    assert!(shown(&h, "Keyboard Shortcuts"), "coming back over Edit opened it");
+    assert!(!shown(&h, "Open Project"), "and closed File");
+}
diff --git a/crates/ui-egui/tests/it/ui_new_primitive.rs b/crates/ui-egui/tests/it/ui_new_primitive.rs
index fbb3a34e5..c40aa23ed 100644
--- a/crates/ui-egui/tests/it/ui_new_primitive.rs
+++ b/crates/ui-egui/tests/it/ui_new_primitive.rs
@@ -70,7 +70,7 @@ fn choose(h: &mut Harness<'_, EffectcraftApp>, kind: PrimitiveKind) {
 }
 
 fn layers(h: &Harness<'_, EffectcraftApp>) -> Vec<Layer> {
-    h.state().session.active_comp().unwrap().layers.clone()
+    h.state().session.active_comp().unwrap().layers.to_vec()
 }
 
 fn renderer(h: &Harness<'_, EffectcraftApp>) -> Renderer {
diff --git a/crates/ui-egui/tests/it/ui_panel_focus.rs b/crates/ui-egui/tests/it/ui_panel_focus.rs
index 8fe2c881f..0d436f702 100644
--- a/crates/ui-egui/tests/it/ui_panel_focus.rs
+++ b/crates/ui-egui/tests/it/ui_panel_focus.rs
@@ -5,7 +5,8 @@
 use effectcraft_engine::Session;
 use effectcraft_engine::project::ItemId;
 use effectcraft_ui_egui::EffectcraftApp;
-use effectcraft_ui_egui::dock::{DockNode, PanelKind};
+use effectcraft_ui_egui::dock::WorkspaceExt as _;
+use effectcraft_ui_egui::dock::{Node, PanelKind, Workspace};
 use egui::{Event, Pos2, pos2};
 use egui_kittest::Harness;
 use serde_json::json;
@@ -42,15 +43,6 @@ fn click_n(h: &mut Harness<'_, EffectcraftApp>, p: Pos2, n: u32) {
     h.run_steps(2);
 }
 
-/// The tabs of the docked group holding `p`, in order.
-fn group_of(n: &DockNode, p: PanelKind) -> Option<Vec<PanelKind>> {
-    match n {
-        DockNode::Split { a, b, .. } => group_of(a, p).or_else(|| group_of(b, p)),
-        DockNode::Tabs { panels, .. } => panels.contains(&p).then(|| panels.clone()),
-        DockNode::Stack { entries } => entries.iter().find(|e| e.contains(p)).map(|e| e.panels.clone()),
-    }
-}
-
 fn invoke(h: &mut Harness<'_, EffectcraftApp>, id: &str, params: serde_json::Value) {
     let ctx = h.ctx.clone();
     effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, id, params).unwrap();
@@ -66,7 +58,7 @@ fn opening_a_comp_brings_up_a_closed_composition_panel() {
     let (mut h, other, main) = harness();
     assert_eq!(group_of(&h.state().ui.dock, PanelKind::Composition), Some(vec![PanelKind::Composition, PanelKind::Layer]));
     invoke(&mut h, "window.closePanel", json!({"panel": "Composition"}));
-    assert!(!h.state().ui.dock.contains(PanelKind::Composition));
+    assert!(!h.state().ui.dock.is_docked(PanelKind::Composition));
     assert!(h.state().ui.dock.is_visible(PanelKind::Layer), "the centre shows the Layer panel");
 
     // Double-click "Other" in the Project panel.
@@ -75,7 +67,7 @@ fn opening_a_comp_brings_up_a_closed_composition_panel() {
     assert_eq!(h.state().session.active_comp_id(), Some(ItemId(other)));
     let dock = &h.state().ui.dock;
     assert!(dock.is_visible(PanelKind::Composition), "the Composition panel is back and in front");
-    assert_eq!(group_of(dock, PanelKind::Composition), Some(vec![PanelKind::Layer, PanelKind::Composition]), "back in the centre");
+    assert_eq!(group_of(dock, PanelKind::Composition), Some(vec![PanelKind::Composition, PanelKind::Layer]), "back in the centre");
     assert!(h.state().auto.elements.iter().any(|e| e.id == "panel.Composition"), "the Composition panel is drawn");
 
     // Open Composition (the Project panel's context menu) with the panel closed again.
@@ -83,12 +75,12 @@ fn opening_a_comp_brings_up_a_closed_composition_panel() {
     invoke(&mut h, "comp.open", json!({"comp": main}));
     assert_eq!(h.state().session.active_comp_id(), Some(ItemId(main)));
     assert!(h.state().ui.dock.is_visible(PanelKind::Composition));
-    assert_eq!(group_of(&h.state().ui.dock, PanelKind::Composition), Some(vec![PanelKind::Layer, PanelKind::Composition]));
+    assert_eq!(group_of(&h.state().ui.dock, PanelKind::Composition), Some(vec![PanelKind::Composition, PanelKind::Layer]));
 
     // Window ▸ Composition reopens it in the centre too (not beside Effects & Presets).
     invoke(&mut h, "window.closePanel", json!({"panel": "Composition"}));
     invoke(&mut h, "window.panel", json!({"panel": "Composition"}));
-    assert_eq!(group_of(&h.state().ui.dock, PanelKind::Composition), Some(vec![PanelKind::Layer, PanelKind::Composition]));
+    assert_eq!(group_of(&h.state().ui.dock, PanelKind::Composition), Some(vec![PanelKind::Composition, PanelKind::Layer]));
     assert!(h.state().ui.dock.is_visible(PanelKind::Composition));
 }
 
@@ -99,12 +91,12 @@ fn opening_a_comp_in_the_minimal_workspace_docks_the_viewer_above_the_timeline()
     let (mut h, other, _) = harness();
     invoke(&mut h, "window.workspace", json!({"name": "Minimal"}));
     invoke(&mut h, "window.closePanel", json!({"panel": "Composition"}));
-    assert!(!h.state().ui.dock.contains(PanelKind::Composition));
+    assert!(!h.state().ui.dock.is_docked(PanelKind::Composition));
     invoke(&mut h, "comp.open", json!({"comp": other}));
-    match &h.state().ui.dock {
-        DockNode::Split { vertical: true, a, b, .. } => {
-            assert_eq!(group_of(a, PanelKind::Composition), Some(vec![PanelKind::Composition]), "the viewer is on top");
-            assert!(b.contains(PanelKind::Timeline));
+    match &h.state().ui.dock.layout.root {
+        Some(Node::Split { axis: effectcraft_ui_egui::dock::SplitAxis::Vertical, first, second, .. }) => {
+            assert_eq!(**first, Node::Tabs { panels: vec![PanelKind::Composition], active: 0 }, "the viewer is on top");
+            assert!(matches!(&**second, Node::Tabs { panels, .. } if panels.contains(&PanelKind::Timeline)));
         }
         other => panic!("expected the viewer above the Timeline, got {other:?}"),
     }
@@ -147,7 +139,7 @@ fn applying_an_effect_brings_up_effect_controls_on_that_layer() {
 
     // Closed: Effect ▸ Last Effect reopens it.
     invoke(&mut h, "window.closePanel", json!({"panel": "EffectControls"}));
-    assert!(!h.state().ui.dock.contains(PanelKind::EffectControls));
+    assert!(!h.state().ui.dock.is_docked(PanelKind::EffectControls));
     try_invoke(&mut h, "effect.applyLast", json!({}));
     assert!(ec_up(&h), "Effect Controls reopened");
 
@@ -177,7 +169,7 @@ fn double_clicking_an_effect_in_the_timeline_opens_effect_controls() {
     invoke(&mut h, "window.closePanel", json!({"panel": "EffectControls"}));
     let blue = layer_id(&h, "Blue");
     invoke(&mut h, "layer.select", json!({"layers": [blue]}));
-    assert!(!h.state().ui.dock.contains(PanelKind::EffectControls));
+    assert!(!h.state().ui.dock.is_docked(PanelKind::EffectControls));
 
     let name = rect(&h, &format!("timeline.group.{uid}.name"));
     click_n(&mut h, name.center(), 2);
@@ -231,3 +223,8 @@ fn focused_panel_outline_is_painted_over_the_panel_bodies() {
         }
     }
 }
+
+/// The tabs of the group holding `p`, in order.
+fn group_of(w: &Workspace, p: PanelKind) -> Option<Vec<PanelKind>> {
+    Some(w.group_of(p)).filter(|g| !g.is_empty())
+}
diff --git a/crates/ui-egui/tests/it/ui_panel_windows.rs b/crates/ui-egui/tests/it/ui_panel_windows.rs
index 76a9a31c0..d2750bb05 100644
--- a/crates/ui-egui/tests/it/ui_panel_windows.rs
+++ b/crates/ui-egui/tests/it/ui_panel_windows.rs
@@ -1,67 +1,52 @@
-//! Multiple monitors (#486): a panel moves out of the main window into a native window of its
-//! own (Move Panel to New Window), which can be placed on another screen, and back.
+//! Multiple monitors (#486): Move Panel to New Window puts a panel in a floating window of its
+//! own, which on desktop is an OS window that can go on another screen, and Move Panel to Main
+//! Window docks it again. The test harness embeds viewports, so these windows draw in the main
+//! window here, as on the web.
 use effectcraft_engine::Session;
 use effectcraft_ui_egui::EffectcraftApp;
-use effectcraft_ui_egui::dock::{PanelKind, PanelWindow};
-use egui::vec2;
-use egui_kittest::Harness;
+use effectcraft_ui_egui::dock::{PanelKind, WorkspaceExt as _};
+use effectcraft_ui_egui::dock_ui::sanitized_window_rect;
 use serde_json::json;
 
 fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, params: serde_json::Value) -> Result<serde_json::Value, String> {
     effectcraft_ui_egui::menus::invoke(app, ctx, "window.panelWindow", params)
 }
 
+fn native(app: &EffectcraftApp, panel: PanelKind) -> Option<[f32; 4]> {
+    app.ui.dock.layout.floating.iter().find(|w| w.contains(&panel)).and_then(|w| w.native)
+}
+
 #[test]
 fn panel_window_command_moves_a_docked_panel_into_its_own_window_and_back() {
     let mut app = EffectcraftApp::new(Session::default());
     let ctx = egui::Context::default();
-    assert!(app.ui.dock.contains(PanelKind::Project));
+    assert!(app.ui.dock.is_docked(PanelKind::Project));
     assert_eq!(invoke(&mut app, &ctx, json!({"panel": "Project", "window": true})).unwrap(), json!({"window": true}));
     // Undocked first, then given a window of its own.
-    assert!(!app.ui.dock.contains(PanelKind::Project));
-    assert!(app.ui.floating.iter().any(|group| group.panels == [PanelKind::Project]));
+    assert!(!app.ui.dock.is_docked(PanelKind::Project));
+    assert!(app.ui.dock.layout.floating.iter().any(|w| w.panels().copied().collect::<Vec<_>>() == [PanelKind::Project]));
     assert!(app.in_panel_window(PanelKind::Project));
-    let window = app.ui.panel_windows.iter().find(|w| w.panel == PanelKind::Project).copied().unwrap();
-    assert_eq!(window.rect, PanelWindow::sanitized(window.rect));
+    let rect = native(&app, PanelKind::Project).unwrap();
+    assert_eq!(rect, sanitized_window_rect(rect));
     // Asking again changes nothing; no `window` toggles.
     assert_eq!(invoke(&mut app, &ctx, json!({"panel": "Project", "window": true})).unwrap(), json!({"window": true}));
-    assert_eq!(app.ui.panel_windows.len(), 1);
     assert_eq!(invoke(&mut app, &ctx, json!({"panel": "Project"})).unwrap(), json!({"window": false}));
-    // Back in the main window, still floating where it was.
+    // Back in the main window: docked in the first docked group.
     assert!(!app.in_panel_window(PanelKind::Project));
-    assert!(app.ui.panel_windows.is_empty());
-    assert!(app.ui.floating.iter().any(|group| group.panels == [PanelKind::Project]));
+    assert!(!app.ui.dock.is_floating(PanelKind::Project));
+    assert!(app.ui.dock.is_docked(PanelKind::Project));
     // The serialized panel form works too.
     assert_eq!(invoke(&mut app, &ctx, json!({"panel": PanelKind::Project})).unwrap(), json!({"window": true}));
     // Bad requests are errors and change nothing.
-    let before = app.ui.panel_windows.clone();
+    let before = app.ui.dock.clone();
     for params in [json!({}), json!({"panel": "Nope"}), json!({"panel": 7}), json!({"panel": "Project", "window": "yes"}), json!({"panel": {"Viewer": 9}})] {
         assert!(invoke(&mut app, &ctx, params.clone()).is_err(), "{params} must be rejected");
     }
-    assert_eq!(app.ui.panel_windows, before);
-}
-
-#[test]
-fn a_panel_in_its_own_window_leaves_the_main_window() {
-    let mut app = EffectcraftApp::new(Session::default());
-    app.ui.start_screen = false;
-    let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app);
-    h.run_steps(3);
-    let ctx = h.ctx.clone();
-    invoke(h.state_mut(), &ctx, json!({"panel": "Project", "window": true})).unwrap();
-    h.run_steps(3);
-    // No in-window floating group is drawn for it (no move strip, no floating area)...
-    assert!(!h.state().auto.elements.iter().any(|e| e.id.starts_with("panel.float.")));
-    let area = egui::Id::unique(("floating-panel", PanelKind::Project.id()));
-    assert!(!h.ctx.memory(|m| m.layer_ids().any(|layer| layer.id == area && m.areas().is_visible(&layer))));
-    // ...the window draws it (here embedded: the test harness has no native windows).
-    assert!(h.state().auto.elements.iter().any(|e| e.id == "panel.Project"));
-    // Docking it back into the main window closes the window entry.
-    let ctx = h.ctx.clone();
-    effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "window.dockPanel", json!({"panel": "Project", "anchor": "Timeline"})).unwrap();
-    h.run_steps(2);
-    assert!(h.state().ui.panel_windows.is_empty());
-    assert!(!h.state().in_panel_window(PanelKind::Project));
+    assert_eq!(app.ui.dock, before);
+    // Docking it back into the main window ends its window.
+    effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.dockPanel", json!({"panel": "Project", "anchor": "Timeline"})).unwrap();
+    assert!(!app.in_panel_window(PanelKind::Project));
+    assert!(app.ui.dock.is_docked(PanelKind::Project));
 }
 
 #[test]
@@ -72,16 +57,50 @@ fn panel_windows_survive_restart_with_hostile_places_made_safe() {
     let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });
     let ctx = egui::Context::default();
     invoke(&mut app, &ctx, json!({"panel": "Project", "window": true})).unwrap();
-    let hostile = [1.0e9, -3.0e12, 1.0e9, 0.5];
-    if let Some(w) = app.ui.panel_windows.first_mut() {
-        w.rect = hostile;
-    }
-    // A window for a panel that doesn't float is dropped on load.
-    app.ui.panel_windows.push(PanelWindow { panel: PanelKind::Timeline, rect: [10.0, 10.0, 300.0, 200.0] });
+    let hostile = [90_000.0, -99_000.0, 99_000.0, 0.5];
+    app.apply_dock(craft_ui::docking::Action::SetNative { panel: PanelKind::Project, rect: Some(hostile) }).unwrap();
     eframe::App::on_exit(&mut app);
     let restarted = EffectcraftApp::new(Session { config: Some(store), ..Default::default() });
-    assert_eq!(restarted.ui.panel_windows, vec![PanelWindow { panel: PanelKind::Project, rect: PanelWindow::sanitized(hostile) }]);
-    let [x, y, w, h] = PanelWindow::sanitized(hostile);
+    assert_eq!(native(&restarted, PanelKind::Project), Some(sanitized_window_rect(hostile)));
+    let [x, y, w, h] = sanitized_window_rect(hostile);
     assert!(x <= 100_000.0 && y >= -100_000.0 && (160.0..=16_384.0).contains(&w) && (100.0..=16_384.0).contains(&h));
-    assert!(PanelWindow::sanitized([f32::NAN, f32::INFINITY, f32::NAN, f32::NEG_INFINITY]).iter().all(|v| v.is_finite()));
+    assert!(sanitized_window_rect([f32::NAN, f32::INFINITY, f32::NAN, f32::NEG_INFINITY]).iter().all(|v| v.is_finite()));
+}
+
+#[test]
+fn a_click_on_a_floating_panel_does_nothing_while_a_dialog_is_open() {
+    use egui::{Event, Modifiers, PointerButton, pos2, vec2};
+    use egui_kittest::Harness;
+    let mut app = EffectcraftApp::new(Session::default());
+    app.ui.start_screen = false;
+    app.apply_dock(craft_ui::docking::Action::Float { panel: PanelKind::Project, rect: [80.0, 120.0, 320.0, 240.0] }).unwrap();
+    let mut h = Harness::builder().with_size(vec2(1400.0, 900.0)).build_eframe(move |_| app);
+    h.run_steps(3);
+    let close = |h: &Harness<'_, EffectcraftApp>| {
+        let e = h.state().auto.elements.iter().find(|e| e.id.starts_with("panel.float.") && e.id.ends_with(".close")).expect("the floating window's ×");
+        pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0)
+    };
+    let click = |h: &mut Harness<'_, EffectcraftApp>, pos| {
+        h.event(Event::PointerMoved(pos));
+        h.step();
+        for pressed in [true, false] {
+            h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+            h.step();
+        }
+        h.run_steps(2);
+    };
+    let at = close(&h);
+    let ctx = h.ctx.clone();
+    effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "app.settings", json!({"page": "general"})).unwrap();
+    h.run_steps(3);
+    let before = h.state().ui.dock.clone();
+    click(&mut h, at);
+    assert_eq!(h.state().ui.dock, before, "the floating panel takes no click while Settings is open");
+    assert!(h.state().ui.dock.is_floating(PanelKind::Project));
+    // The same click closes the window once the dialog is gone.
+    h.state_mut().dialog = None;
+    h.run_steps(3);
+    let at = close(&h);
+    click(&mut h, at);
+    assert!(!h.state().ui.dock.is_open(PanelKind::Project));
 }
diff --git a/crates/ui-egui/tests/it/ui_panels.rs b/crates/ui-egui/tests/it/ui_panels.rs
index f4c11ba0b..2c2d650e9 100644
--- a/crates/ui-egui/tests/it/ui_panels.rs
+++ b/crates/ui-egui/tests/it/ui_panels.rs
@@ -2,6 +2,8 @@
 //! registers its automation ids; the Footage panel's buttons edit into the comp; the Progress
 //! panel lists and cancels a job; Lumetri Scopes switch scope through their dropdown.
 
+use crate::gpu_test::RenderSerial;
+use effectcraft_ui_egui::dock::WorkspaceExt as _;
 use std::sync::Arc;
 
 use effectcraft_engine::{Session, config::MemoryConfig};
@@ -60,7 +62,7 @@ fn window_menu_opens_the_new_panels() {
         ("contentAwareFill", PanelKind::ContentAwareFill, "contentFill.method"),
     ] {
         open(&mut h, name);
-        assert!(h.state().ui.dock.contains(kind) || h.state().ui.floating.iter().any(|f| f.panels.contains(&kind)), "{name} shown");
+        assert!(h.state().ui.dock.is_open(kind), "{name} shown");
         if !auto.is_empty() {
             assert!(h.state().auto.find(auto).is_some(), "{name}: {auto}");
         }
@@ -72,9 +74,7 @@ fn window_menu_opens_the_new_panels() {
 #[test]
 fn window_menu_closes_a_checked_panel() {
     let mut h = harness();
-    let shown = |h: &Harness<'_, EffectcraftApp>| {
-        h.state().ui.dock.contains(PanelKind::Align) || h.state().ui.floating.iter().any(|f| f.panels.contains(&PanelKind::Align))
-    };
+    let shown = |h: &Harness<'_, EffectcraftApp>| h.state().ui.dock.is_open(PanelKind::Align);
     open(&mut h, "align");
     assert!(shown(&h));
     click(&mut h, "menu.Window");
@@ -106,7 +106,7 @@ fn footage_panel_buttons_edit_into_the_comp() {
     let item = h.state().session.project.items.values().find(|i| matches!(i.kind, effectcraft_engine::project::ItemKind::Solid(_))).unwrap().id.0;
     h.state_mut().session.execute("footage.open", json!({"item": item})).unwrap();
     h.run_steps(4);
-    assert!(h.state().ui.dock.contains(PanelKind::Footage) || h.state().ui.floating.iter().any(|f| f.panels.contains(&PanelKind::Footage)));
+    assert!(h.state().ui.dock.is_open(PanelKind::Footage));
     assert!(h.state().auto.find("footage.overlayEdit").is_some());
     let before = h.state().session.active_comp().unwrap().layers.len();
     click(&mut h, "footage.overlayEdit");
@@ -449,7 +449,7 @@ fn panels_snapshot() {
         }
         open(&mut h, panel);
         h.run_steps(3);
-        let img = h.render().expect("render");
+        let img = h.render_serialized().expect("render");
         img.save(format!("{dir}/{panel}{scope}.png")).unwrap();
     }
 }
@@ -665,3 +665,33 @@ fn transition_presets_apply_from_effects_and_presets() {
     assert_eq!(fx.name, "Radial Wipe");
     assert_eq!(fx.prop("completion").unwrap().keys.len(), 2);
 }
+
+/// #2582: dragging Settings' UI Scale doesn't resize the interface under the pointer; the value
+/// applies once the button is released.
+#[test]
+fn ui_scale_applies_when_the_drag_ends() {
+    let mut h = harness();
+    open_settings(&mut h);
+    let e = h.state().auto.find("settings.appearance.uiScale").expect("the UI Scale field");
+    let from = pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0);
+    h.input_mut().events.push(Event::PointerMoved(from));
+    h.input_mut().events.push(Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
+    h.step();
+    for k in 1..=8 {
+        h.input_mut().events.push(Event::PointerMoved(from + egui::vec2(10.0 * k as f32, 0.0)));
+        h.step();
+        assert_eq!(scale(&h), (100, 1.0), "nothing applies mid-drag");
+    }
+    h.input_mut().events.push(Event::PointerButton {
+        pos: from + egui::vec2(80.0, 0.0),
+        button: egui::PointerButton::Primary,
+        pressed: false,
+        modifiers: Default::default(),
+    });
+    h.run_steps(4);
+    let (pct, zoom) = scale(&h);
+    assert!(pct > 100 && (zoom - pct as f32 / 100.0).abs() < 1e-6, "applied on release: {pct} {zoom}");
+    click(&mut h, "settings.cancel");
+    h.run_steps(2);
+    assert_eq!(scale(&h), (100, 1.0));
+}
diff --git a/crates/ui-egui/tests/it/ui_presets_folder.rs b/crates/ui-egui/tests/it/ui_presets_folder.rs
index e11efe944..1bcd9189c 100644
--- a/crates/ui-egui/tests/it/ui_presets_folder.rs
+++ b/crates/ui-egui/tests/it/ui_presets_folder.rs
@@ -1,5 +1,6 @@
 //! Effects & Presets: copy the configured folder path through the contents menu.
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_ui_egui::panels::effects_presets::PresetFile;
 use effectcraft_ui_egui::{ControlRequest, EffectcraftApp, control, dock::PanelKind};
@@ -52,7 +53,7 @@ fn presets_menu_copies_the_configured_folder_without_editing_the_project() {
         click(&mut h, "effects.menu");
         h.run_steps(3);
         if let Ok(path) = std::env::var("PRESETS_FOLDER_SNAPSHOT") {
-            h.render().unwrap().save(path).unwrap();
+            h.render_serialized().unwrap().save(path).unwrap();
         }
         assert_eq!(click(&mut h, "effects.copyPresetsFolderPath"), [expected.as_str()]);
         h.run_steps(2);
@@ -156,7 +157,7 @@ fn shared_preset_rows_search_apply_and_undo_the_selected_definition() {
         assert_eq!(h.state().session.active_comp().unwrap().layers[0].props.prop("transform/opacity").unwrap().value.as_f64(), expected);
         assert_eq!(h.state().session.history.undo.len(), history + 1);
         if let Ok(dir) = std::env::var("PRESET_CACHE_SNAPSHOTS") {
-            h.render().unwrap().save(format!("{dir}/{name}.png")).unwrap();
+            h.render_serialized().unwrap().save(format!("{dir}/{name}.png")).unwrap();
         }
         h.state_mut().session.execute("edit.undo", json!({})).unwrap();
         h.run_steps(2);
diff --git a/crates/ui-egui/tests/it/ui_preview_align.rs b/crates/ui-egui/tests/it/ui_preview_align.rs
index 2b2ba1b44..1469a5e9e 100644
--- a/crates/ui-egui/tests/it/ui_preview_align.rs
+++ b/crates/ui-egui/tests/it/ui_preview_align.rs
@@ -279,21 +279,25 @@ fn playback_prefetches_past_the_cached_frames_ahead() {
         std::thread::sleep(std::time::Duration::from_millis(2));
     }
     assert_eq!(h.state().frames.cached_frames(&series), (0..120).collect::<Vec<_>>());
+    // Rendering/instrumentation time must not move the playhead near the end of the
+    // cached run. Exercise real prefetch workers while holding playback in its first second.
+    h.state_mut().use_manual_clock();
     h.state_mut().session.set_time(Tick::ZERO);
     invoke(&mut h, "playback.toggle", json!({}));
+    h.state_mut().clock_mut().advance(0.25);
     h.run_steps(2);
     assert!(h.state().playback.playing);
     let cur = h.state().session.time();
+    assert!(cur > Tick::ZERO, "playback advances with the manual clock");
     assert!(cur < Tick::from_seconds_f64(1.0), "{cur:?}");
-    for _ in 0..4000 {
+    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(60);
+    while std::time::Instant::now() < deadline {
         if h.state().frames.cached_frames(&series).iter().any(|&f| f >= 120) {
             break;
         }
         h.step();
         std::thread::sleep(std::time::Duration::from_millis(1));
-        if h.state().session.time() >= Tick::from_seconds_f64(1.0) {
-            break;
-        }
+        assert_eq!(h.state().session.time(), cur, "worker waits do not advance playback");
     }
     assert!(h.state().frames.cached_frames(&series).iter().any(|&f| f >= 120), "frames past the cached run render while it plays the first second");
 }
diff --git a/crates/ui-egui/tests/it/ui_project_delete.rs b/crates/ui-egui/tests/it/ui_project_delete.rs
index f217c29db..2a395cf4b 100644
--- a/crates/ui-egui/tests/it/ui_project_delete.rs
+++ b/crates/ui-egui/tests/it/ui_project_delete.rs
@@ -364,3 +364,29 @@ fn a_cut_is_read_with_the_modifiers_where_it_is_in_the_frame() {
         assert_eq!(h.state().session.project.item(solid).is_none(), deletes, "case {n}: {events:?} after {before:?}");
     }
 }
+
+/// An open text edit stands down the Project-panel Clear redirect: the composition being typed
+/// into must not be deleted out from under it, with no confirmation when nothing uses it (#2227).
+#[test]
+fn clear_with_the_project_focused_stands_down_during_a_text_edit() {
+    let (mut h, _, _) = harness();
+    let working = h.state().session.active_comp_id().unwrap();
+    // the composition being typed into is also the Project panel's selection, as when it was opened
+    click(&mut h, &format!("project.item.{}.name", working.0), Modifiers::NONE);
+    let text = h.state_mut().session.execute("layer.newText", json!({"text": "Title", "size": 80})).unwrap()["layer"].as_u64().unwrap();
+    h.state_mut().session.execute("text.edit", json!({"layer": text, "created": true})).unwrap();
+    h.state_mut().ui.focused = PanelKind::Project;
+    h.run_steps(2);
+    assert!(h.state().session.state.project_selection.contains(&working), "the comp is the project selection");
+    let project = h.state().session.project.clone();
+
+    // Edit > Clear (the menu, or the control channel) dispatches through `invoke`
+    let ctx = h.ctx.clone();
+    let cleared = effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "edit.clear", json!({}));
+    h.run_steps(3);
+
+    cleared.expect("Clear stands down during a text edit");
+    assert!(h.state().session.project.item(working).is_some(), "the composition being typed into survives");
+    assert_eq!(h.state().session.project, project, "nothing was deleted");
+    assert!(h.state().session.state.text_edit.is_some(), "the text edit stays open");
+}
diff --git a/crates/ui-egui/tests/it/ui_project_rows.rs b/crates/ui-egui/tests/it/ui_project_rows.rs
index 27ce5e693..b8638bbd1 100644
--- a/crates/ui-egui/tests/it/ui_project_rows.rs
+++ b/crates/ui-egui/tests/it/ui_project_rows.rs
@@ -274,12 +274,13 @@ fn comp_context_menu_opens_that_comps_settings() {
     assert_eq!(h.state().dialog, Some(Dialog::CompSettings));
     assert_eq!(h.state().session.active_comp_id(), Some(main), "the viewer keeps its comp");
     // A new name, then OK: Side's own size goes back to Side under it. Main's values in the
-    // dialog, or OK writing to the viewer's comp, would resize or rename the wrong one.
+    // dialog, or OK writing to the viewer's comp, would resize or rename the wrong one. The
+    // dialog previews the name as it is typed; OK keeps that as one undo step.
+    let undo = h.state().session.history.undo.len();
     click(&mut h, "dialog.comp.name");
     h.input_mut().events.push(Event::Key { key: egui::Key::A, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::COMMAND });
     h.input_mut().events.push(Event::Text("Side 2".into()));
     h.run_steps(2);
-    let undo = h.state().session.history.undo.len();
     h.input_mut().events.push(Event::Key { key: egui::Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
     h.run_steps(2);
     assert_eq!(h.state().dialog, None, "OK closed the dialog");
diff --git a/crates/ui-egui/tests/it/ui_render_queue_keyboard.rs b/crates/ui-egui/tests/it/ui_render_queue_keyboard.rs
new file mode 100644
index 000000000..3f954b7b6
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_render_queue_keyboard.rs
@@ -0,0 +1,226 @@
+//! Render Queue keyboard operation and accessible names (docs/gaps.md gap 25): queue items are
+//! tree items (named by number, comp and status; selected; open or closed); the arrow keys, Home /
+//! End, Right / Left, Enter and Delete work them; the buttons, the check boxes, the twirls and the
+//! drop-downs have names and states; a drop-down opens from the keyboard and closes with the focus
+//! back on it; the Templates dialog is named.
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use egui::accesskit::Role;
+use egui::{Event, Key, Modifiers, Pos2, pos2};
+use egui_kittest::Harness;
+use egui_kittest::kittest::{NodeT, Queryable};
+use serde_json::json;
+
+fn harness() -> Harness<'static, EffectcraftApp> {
+    let mut s = Session::default();
+    for name in ["Alpha", "Beta", "Gamma"] {
+        let comp = s.execute("comp.new", json!({"name": name, "width": 320, "height": 180, "duration": 4})).unwrap()["comp"].as_u64().unwrap();
+        s.execute("renderQueue.add", json!({"comp": comp})).unwrap();
+    }
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
+    h.state_mut().show_panel(PanelKind::RenderQueue);
+    h.run_steps(4);
+    h
+}
+
+fn key(h: &mut Harness<'_, EffectcraftApp>, key: Key, modifiers: Modifiers) {
+    for pressed in [true, false] {
+        h.input_mut().events.push(Event::Key { key, physical_key: None, pressed, repeat: false, modifiers });
+        h.step();
+    }
+    h.run_steps(3);
+}
+
+fn center(h: &Harness<'_, EffectcraftApp>, id: &str) -> Pos2 {
+    let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}")).clone();
+    pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0)
+}
+
+fn click(h: &mut Harness<'_, EffectcraftApp>, id: &str) {
+    let p = center(h, id);
+    h.input_mut().events.push(Event::PointerMoved(p));
+    h.step();
+    for pressed in [true, false] {
+        h.input_mut().events.push(Event::PointerButton { pos: p, button: egui::PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
+        h.step();
+    }
+    h.run_steps(3);
+}
+
+fn focused(h: &Harness<'_, EffectcraftApp>) -> Option<(Role, String)> {
+    h.root().children_recursive().find(|n| n.is_focused()).map(|n| (n.accesskit_node().role(), n.accesskit_node().label().unwrap_or_default()))
+}
+
+fn queue_len(h: &Harness<'_, EffectcraftApp>) -> usize {
+    h.state().session.project.render_queue.len()
+}
+
+fn row_name(h: &Harness<'_, EffectcraftApp>, n: usize) -> String {
+    h.query_all_by_role(Role::TreeItem).map(|r| r.accesskit_node().label().unwrap_or_default()).find(|l| l.starts_with(&format!("{n}. "))).unwrap_or_default()
+}
+
+#[test]
+fn rows_are_named_tree_items_with_selected_and_open_state() {
+    let mut h = harness();
+    let first = row_name(&h, 1);
+    assert!(first.starts_with("1. Alpha, "), "number, comp and status: {first}");
+    let node = h.get_by_role_and_label(Role::TreeItem, &first);
+    assert_eq!(node.accesskit_node().is_selected(), Some(false));
+    assert_eq!(node.accesskit_node().data().is_expanded(), Some(false));
+    assert_eq!(node.accesskit_node().data().level(), Some(1));
+    click(&mut h, "renderQueue.item.1.twirl");
+    let node = h.get_by_role_and_label(Role::TreeItem, &first);
+    assert_eq!(node.accesskit_node().data().is_expanded(), Some(true), "the open item says so");
+    let twirl = h.get_by_label("Hide details of Alpha");
+    assert_eq!(twirl.accesskit_node().role(), Role::Button);
+    assert_eq!(twirl.accesskit_node().data().is_expanded(), Some(true));
+    // The settings drop-downs of the open item: what they set and what they are set to.
+    let settings = h.get_by_role_and_label(Role::ComboBox, "Render Settings");
+    assert!(settings.accesskit_node().value().is_some_and(|v| !v.is_empty()));
+    assert!(h.query_by_role_and_label(Role::ComboBox, "Output Module").is_some());
+    assert!(h.query_by_role_and_label(Role::ComboBox, "Log").is_some());
+    assert!(h.query_by_role_and_label(Role::ComboBox, "Output To").is_some());
+    assert!(h.query_by_role_and_label(Role::Button, "Render").is_some());
+    let notify = h.get_by_role_and_label(Role::CheckBox, "Notify");
+    assert!(notify.accesskit_node().toggled().is_some());
+    let render = h.get_by_role_and_label(Role::CheckBox, "Render: Alpha");
+    assert_eq!(render.accesskit_node().toggled(), Some(egui::accesskit::Toggled::True));
+    assert_eq!(h.get_by_role(Role::ProgressIndicator).accesskit_node().data().numeric_value(), Some(0.0));
+}
+
+#[test]
+fn arrows_home_end_right_left_enter_and_delete_work_the_rows() {
+    let mut h = harness();
+    h.get_by_role_and_label(Role::TreeItem, &row_name(&h, 1)).focus();
+    h.run_steps(3);
+    assert_eq!(focused(&h).map(|f| f.1), Some(row_name(&h, 1)));
+    let selected = |h: &Harness<'_, EffectcraftApp>| {
+        h.query_all_by_role(Role::TreeItem)
+            .filter(|n| n.accesskit_node().is_selected() == Some(true))
+            .map(|n| n.accesskit_node().label().unwrap_or_default())
+            .filter(|l| l.starts_with(|c: char| c.is_ascii_digit()))
+            .collect::<Vec<_>>()
+    };
+    assert_eq!(selected(&h), vec![row_name(&h, 1)], "a focused row is selected");
+    key(&mut h, Key::ArrowDown, Modifiers::NONE);
+    assert_eq!(focused(&h).map(|f| f.1), Some(row_name(&h, 2)), "Down Arrow moves to the next item and the focus goes with it");
+    assert_eq!(h.get_by_role_and_label(Role::TreeItem, &row_name(&h, 2)).accesskit_node().is_selected(), Some(true));
+    key(&mut h, Key::End, Modifiers::NONE);
+    assert_eq!(focused(&h).map(|f| f.1), Some(row_name(&h, 3)));
+    key(&mut h, Key::ArrowDown, Modifiers::NONE);
+    assert_eq!(focused(&h).map(|f| f.1), Some(row_name(&h, 3)), "Down Arrow stays on the last item");
+    key(&mut h, Key::Home, Modifiers::NONE);
+    assert_eq!(focused(&h).map(|f| f.1), Some(row_name(&h, 1)));
+    key(&mut h, Key::ArrowRight, Modifiers::NONE);
+    assert_eq!(h.get_by_role_and_label(Role::TreeItem, &row_name(&h, 1)).accesskit_node().data().is_expanded(), Some(true), "Right Arrow opens the item");
+    key(&mut h, Key::ArrowLeft, Modifiers::NONE);
+    assert_eq!(h.get_by_role_and_label(Role::TreeItem, &row_name(&h, 1)).accesskit_node().data().is_expanded(), Some(false), "Left Arrow closes it");
+    key(&mut h, Key::Enter, Modifiers::NONE);
+    assert_eq!(h.get_by_role_and_label(Role::TreeItem, &row_name(&h, 1)).accesskit_node().data().is_expanded(), Some(true), "Enter toggles it");
+    key(&mut h, Key::Space, Modifiers::NONE);
+    assert_eq!(h.get_by_role_and_label(Role::TreeItem, &row_name(&h, 1)).accesskit_node().data().is_expanded(), Some(false), "Space toggles it back");
+    assert!(!h.state().playback.playing && !h.state().playback.caching && h.state().playback.plan.is_none(), "Space on a row does not start a preview");
+    // Delete removes the selected item, as it does with the mouse's selection.
+    key(&mut h, Key::ArrowDown, Modifiers::NONE);
+    assert_eq!(queue_len(&h), 3);
+    key(&mut h, Key::Delete, Modifiers::NONE);
+    assert_eq!(queue_len(&h), 2, "Delete removes the selected item");
+}
+
+#[test]
+fn tab_reaches_every_control_of_a_row() {
+    let mut h = harness();
+    h.get_by_role_and_label(Role::TreeItem, &row_name(&h, 1)).focus();
+    h.run_steps(3);
+    let mut seen = vec![focused(&h).unwrap()];
+    for _ in 0..40 {
+        key(&mut h, Key::Tab, Modifiers::NONE);
+        match focused(&h) {
+            Some(f) if !seen.contains(&f) => seen.push(f),
+            _ => {}
+        }
+    }
+    let names: Vec<&str> = seen.iter().map(|s| s.1.as_str()).collect();
+    for want in ["Show details of Alpha", "Render: Alpha", "Show details of Beta", "Render: Beta"] {
+        assert!(names.contains(&want), "Tab reaches `{want}`; reached {names:?}");
+    }
+}
+
+#[test]
+fn a_drop_down_opens_from_the_keyboard_and_gives_the_focus_back() {
+    let mut h = harness();
+    click(&mut h, "renderQueue.item.1.twirl");
+    h.get_by_role_and_label(Role::ComboBox, "Render Settings").focus();
+    h.run_steps(3);
+    key(&mut h, Key::Enter, Modifiers::NONE);
+    let (role, first_entry) = focused(&h).expect("the first entry has the focus");
+    assert_ne!(role, Role::ComboBox, "the keyboard is in the menu: {first_entry}");
+    key(&mut h, Key::ArrowDown, Modifiers::NONE);
+    let second = focused(&h).expect("Down Arrow moves to the next entry").1;
+    assert_ne!(second, first_entry);
+    key(&mut h, Key::ArrowUp, Modifiers::NONE);
+    assert_eq!(focused(&h).map(|f| f.1), Some(first_entry), "Up Arrow moves back");
+    key(&mut h, Key::Enter, Modifiers::NONE);
+    assert_eq!(focused(&h).map(|f| f.0), Some(Role::ComboBox), "choosing an entry gives the focus back to the drop-down");
+}
+
+#[test]
+fn the_check_box_and_the_buttons_work_from_the_keyboard() {
+    let mut h = harness();
+    let before = h.state().session.project.render_queue.first().map(|i| i.render);
+    h.get_by_role_and_label(Role::CheckBox, "Render: Alpha").focus();
+    h.run_steps(3);
+    key(&mut h, Key::Space, Modifiers::NONE);
+    assert_ne!(h.state().session.project.render_queue.first().map(|i| i.render), before, "Space toggles the Render check box");
+    let notify = h.state().session.project.render_prefs.notify;
+    h.get_by_role_and_label(Role::CheckBox, "Notify").focus();
+    h.run_steps(3);
+    key(&mut h, Key::Enter, Modifiers::NONE);
+    assert_ne!(h.state().session.project.render_prefs.notify, notify, "Enter toggles Notify");
+}
+
+#[test]
+fn the_templates_dialog_is_named() {
+    let mut h = harness();
+    let ctx = h.ctx.clone();
+    effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "app.templates", json!({"kind": "renderSettings"})).unwrap();
+    h.run_steps(4);
+    assert!(h.query_by_role_and_label(Role::ComboBox, "Settings Name").is_some());
+    assert!(h.query_by_role_and_label(Role::TextInput, "template name").is_some());
+    for name in ["Duplicate", "Delete", "   OK   "] {
+        assert_eq!(h.get_by_role_and_label(Role::Button, name).accesskit_node().role(), Role::Button, "{name}");
+    }
+    let defaults = h.query_all_by_role(Role::ComboBox).count();
+    assert!(defaults >= 4, "the default slots are drop-downs: {defaults}");
+}
+
+/// A pick with the mouse leaves no widget with the keyboard focus: egui pauses the application's
+/// shortcuts (Space, Ctrl+Z) while one has it (#776's rule for the Project panel).
+#[test]
+fn a_pick_with_the_mouse_leaves_no_keyboard_focus() {
+    let mut h = harness();
+    click(&mut h, "renderQueue.item.1.twirl");
+    click(&mut h, "renderQueue.item.1.renderSettings");
+    assert!(h.ctx.memory(|m| m.focused()).is_none(), "opening a drop-down with the mouse takes no keyboard focus");
+    let template = h.state().session.project.render_templates.render_settings_list()[0].name.clone();
+    h.get_by_label_contains(&template).click();
+    h.run_steps(4);
+    assert!(h.ctx.memory(|m| m.focused()).is_none(), "choosing an entry with the mouse leaves no keyboard focus");
+    // The Effects & Presets options menu the same.
+}
+
+/// Enter after a click in the panel belongs to the panel (it opens or applies the row), not to
+/// the layer rename the Timeline binds to it.
+#[test]
+fn enter_after_a_click_opens_the_item_and_does_not_rename_a_layer() {
+    let mut h = harness();
+    h.state_mut().session.execute("layer.newSolid", json!({"name": "Red", "color": "#c04040"})).unwrap();
+    h.run_steps(3);
+    click(&mut h, "renderQueue.item.1.row");
+    assert_eq!(h.state().ui.focused, PanelKind::RenderQueue);
+    key(&mut h, Key::Enter, Modifiers::NONE);
+    assert_eq!(h.get_by_role_and_label(Role::TreeItem, &row_name(&h, 1)).accesskit_node().data().is_expanded(), Some(true), "Enter opens the clicked item");
+    assert!(h.state().auto.query("timeline.layer.").iter().all(|e| !e.id.ends_with(".nameEdit")), "no layer rename started");
+}
diff --git a/crates/ui-egui/tests/it/ui_roto_objects.rs b/crates/ui-egui/tests/it/ui_roto_objects.rs
new file mode 100644
index 000000000..cbf52d07d
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_roto_objects.rs
@@ -0,0 +1,100 @@
+//! A Roto Brush instance with two objects: the Layer panel's boundary view outlines each in its own colour, and
+//! Show Object limits the matte to one (egui_kittest, a real render). A stand-in tracker follows two regions, so no
+//! weights are needed. `ROTO_OBJECTS_SNAPSHOT=/abs/out.png` also saves the rendered panel.
+
+use std::sync::Arc;
+
+use effectcraft_engine::Session;
+use effectcraft_segment::{ClipFrame, MaskModel, ModelInfo, ObjectTracker, Prompt, TrackRequest, TrackedFrame};
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use egui_kittest::Harness;
+use serde_json::json;
+
+/// Follows two fixed regions of the layer: object 0 on the left, object 1 on the right.
+struct TwoRegions;
+
+impl MaskModel for TwoRegions {
+    fn info(&self) -> &'static ModelInfo {
+        &effectcraft_segment::SAM2_TINY
+    }
+    fn segment(&self, _: &[[f32; 3]], _: usize, _: usize, _: &Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+        Err("no weights".into())
+    }
+    fn tracker(&self) -> Option<&dyn ObjectTracker> {
+        Some(self)
+    }
+}
+
+impl ObjectTracker for TwoRegions {
+    fn track(
+        &self,
+        req: &TrackRequest,
+        frame: &mut dyn FnMut(i64) -> Option<Arc<ClipFrame>>,
+        _: &dyn Fn() -> bool,
+        out: &mut dyn FnMut(usize, i64, TrackedFrame),
+    ) -> effectcraft_segment::Result<()> {
+        for g in req.first..req.first + req.count as i64 {
+            let img = frame(g).ok_or("no frame")?;
+            for o in 0..req.objects.len() {
+                let (x0, x1) = if o == 0 { (img.w / 8, img.w * 3 / 8) } else { (img.w * 5 / 8, img.w * 7 / 8) };
+                let prob = (0..img.w * img.h)
+                    .map(|i| {
+                        let (x, y) = (i % img.w, i / img.w);
+                        f32::from(x >= x0 && x < x1 && y > img.h / 4 && y < img.h * 3 / 4)
+                    })
+                    .collect();
+                out(o, g, TrackedFrame { prob, w: img.w, h: img.h, confidence: 0.99, occluded: false });
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Pixels of the viewer (above the panel's bar, whose object swatch has the same colour) within a few levels of `want`.
+fn count(image: &image::RgbaImage, want: [u8; 3]) -> usize {
+    let limit = image.height() * 54 / 100;
+    image.enumerate_pixels().filter(|(_, y, p)| *y < limit && p.0[..3].iter().zip(want).all(|(a, b)| a.abs_diff(b) <= 12)).count()
+}
+
+#[test]
+fn the_boundary_view_outlines_each_object_and_show_object_picks_one() {
+    let _gpu = crate::gpu_test::lock();
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "View", "width": 640, "height": 360, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Box", "color": "#e04020", "width": 80, "height": 80})).unwrap();
+    let id = s.active_comp().unwrap().layers.iter().find(|l| l.name == "Box").unwrap().id.0;
+    for (object, x) in [(0, 22.0), (1, 58.0)] {
+        s.execute("roto.stroke", json!({"layer": id, "object": object, "points": [[x, 38.0], [x, 42.0]], "radius": 4})).unwrap();
+    }
+    let _model = crate::roto_model_guard::install(Arc::new(TwoRegions));
+    s.execute("roto.propagate", json!({"layer": id, "direction": "both", "wait": true})).unwrap();
+    let st = s.execute("roto.status", json!({"layer": id})).unwrap();
+    assert_eq!(st["objects"], json!([{"id": 0, "strokes": 1}, {"id": 1, "strokes": 1}]), "{st}");
+
+    // object 0 keeps the boundary colour (pink by default), object 1 is the first palette colour (blue-green)
+    let (pink, cyan) = ([255, 64, 191], [60, 200, 255]);
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(move |_| EffectcraftApp::new(s));
+    h.run_steps(3);
+    h.state_mut().session.execute("layer.select", json!({"layers": [id]})).unwrap();
+    let ctx = h.ctx.clone();
+    effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "layer.openLayer", json!({"layer": id})).unwrap();
+    h.run_steps(4);
+    assert_eq!(h.state().ui.focused, PanelKind::Layer);
+    let both = h.render().expect("the panel renders");
+    if let Some(path) = std::env::var_os("ROTO_OBJECTS_SNAPSHOT") {
+        both.save(path).unwrap();
+    }
+    // the bar offers to remove the current object's strokes, and says how many it has
+    assert!(h.state().auto.find("layerPanel.roto.clearObject").is_some(), "the remove button is on screen");
+    assert!(h.state().auto.find("layerPanel.roto.object").is_some_and(|e| e.label.contains("(1)")), "the object's stroke count is on the button");
+    let (a, b) = (count(&both, pink), count(&both, cyan));
+    assert!(a > 50 && b > 50, "both objects are outlined: {a} pink, {b} cyan pixels");
+
+    // Show Object 2 (object id 1): only its outline remains
+    h.state_mut().session.execute("prop.set", json!({"layer": id, "path": "effects/#1/rotoBrushMatte/object", "value": 2})).unwrap();
+    h.run_steps(4);
+    let one = h.render().expect("the panel renders");
+    let (a, b) = (count(&one, pink), count(&one, cyan));
+    assert!(a < 10 && b > 50, "only object 1 is shown: {a} pink, {b} cyan pixels");
+}
diff --git a/crates/ui-egui/tests/it/ui_roto_span_confidence.rs b/crates/ui-egui/tests/it/ui_roto_span_confidence.rs
new file mode 100644
index 000000000..d9730b778
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_roto_span_confidence.rs
@@ -0,0 +1,119 @@
+//! The Roto Brush span bar colours the frames a tracker followed by its confidence: green when it is sure,
+//! amber when it is doubtful, red when it is not, slate where the object was absent (egui_kittest, UI logic
+//! and a real render). A stand-in tracker supplies the confidences, so no weights are needed.
+//! `ROTO_SPAN_SNAPSHOT=/abs/out.png` also saves the rendered panel.
+
+use std::sync::Arc;
+
+use effectcraft_engine::Session;
+use effectcraft_segment::{ClipFrame, MaskModel, ModelInfo, ObjectTracker, Prompt, TrackRequest, TrackedFrame};
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use egui_kittest::Harness;
+use serde_json::json;
+
+/// Follows a fixed disc; its confidence per frame is scripted.
+struct Scripted;
+
+impl MaskModel for Scripted {
+    fn info(&self) -> &'static ModelInfo {
+        &effectcraft_segment::SAM2_TINY
+    }
+    fn segment(&self, _: &[[f32; 3]], _: usize, _: usize, _: &Prompt) -> effectcraft_segment::Result<Vec<f32>> {
+        Err("no weights".into())
+    }
+    fn tracker(&self) -> Option<&dyn ObjectTracker> {
+        Some(self)
+    }
+}
+
+/// (confidence, occluded) of layer frame `f`: sure, doubtful, unsure, absent, sure again.
+fn script(f: i64) -> (f32, bool) {
+    match f {
+        0..=5 => (0.99, false),
+        6..=9 => (0.6, false),
+        10..=12 => (0.2, false),
+        13..=15 => (0.0, true),
+        _ => (0.99, false),
+    }
+}
+
+impl ObjectTracker for Scripted {
+    fn track(
+        &self,
+        req: &TrackRequest,
+        frame: &mut dyn FnMut(i64) -> Option<Arc<ClipFrame>>,
+        _: &dyn Fn() -> bool,
+        out: &mut dyn FnMut(usize, i64, TrackedFrame),
+    ) -> effectcraft_segment::Result<()> {
+        for g in req.first..req.first + req.count as i64 {
+            let img = frame(g).ok_or("no frame")?;
+            let (confidence, occluded) = script(g);
+            let prob = (0..img.w * img.h)
+                .map(|i| if !occluded && (i % img.w).abs_diff(img.w / 2) < img.w / 4 && (i / img.w).abs_diff(img.h / 2) < img.h / 4 { 1.0 } else { 0.0 })
+                .collect();
+            out(0, g, TrackedFrame { prob, w: img.w, h: img.h, confidence, occluded });
+        }
+        Ok(())
+    }
+}
+
+fn close(got: [u8; 4], want: [u8; 3]) -> bool {
+    got.iter().zip(want).all(|(a, b)| a.abs_diff(b) <= 24)
+}
+
+#[test]
+fn the_span_bar_shows_the_trackers_confidence() {
+    let _gpu = crate::gpu_test::lock();
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "View", "width": 640, "height": 360, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"name": "Box", "color": "#e04020", "width": 80, "height": 80})).unwrap();
+    let id = s.active_comp().unwrap().layers.iter().find(|l| l.name == "Box").unwrap().id.0;
+    s.execute("roto.stroke", json!({"layer": id, "points": [[20.0, 40.0], [60.0, 40.0]], "radius": 6})).unwrap();
+    s.execute("roto.stroke", json!({"layer": id, "kind": "bg", "points": [[5.0, 5.0], [75.0, 5.0]], "radius": 4})).unwrap();
+    let _model = crate::roto_model_guard::install(Arc::new(Scripted));
+    // the model stays loaded while the panel draws (its id is part of the cache keys)
+    s.execute("roto.propagate", json!({"layer": id, "direction": "both", "wait": true})).unwrap();
+
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(move |_| EffectcraftApp::new(s));
+    h.run_steps(3);
+    h.state_mut().session.execute("layer.select", json!({"layers": [id]})).unwrap();
+    let ctx = h.ctx.clone();
+    effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "layer.openLayer", json!({"layer": id})).unwrap();
+    h.run_steps(4);
+    assert_eq!(h.state().ui.focused, PanelKind::Layer);
+
+    // the object picker is in the bar; "+" starts a new object, which the next stroke would belong to
+    assert!(h.state().auto.find("layerPanel.roto.object").is_some(), "the object picker is on screen");
+    assert!(h.state().auto.find("layerPanel.roto.newObject").is_some());
+    assert_eq!(h.state().session.state.roto.object, 0);
+    h.state_mut().session.execute("roto.options", json!({"object": 1})).unwrap();
+    h.run_steps(2);
+    assert_eq!(h.state().session.state.roto.object, 1);
+    h.state_mut().session.execute("roto.options", json!({"object": 0})).unwrap();
+    h.run_steps(2);
+    let track = h.state().auto.find("layerPanel.rotoSpan").expect("the span bar is on screen").rect;
+    let (comp, layer) = {
+        let comp = h.state().session.active_comp().unwrap().clone();
+        let layer = comp.layer(effectcraft_project::LayerId(id)).unwrap().clone();
+        (comp, layer)
+    };
+    let lim = effectcraft_engine::roto::frame_limits(&comp, &layer);
+    let n = (lim[1] - lim[0] + 1) as f32;
+    let image = h.render().expect("the panel renders");
+    if let Some(path) = std::env::var_os("ROTO_SPAN_SNAPSHOT") {
+        image.save(path).unwrap();
+    }
+    let scale = image.width() as f32 / 1600.0;
+    let sample = |f: i64| -> [u8; 4] {
+        let x = (track[0] + ((f - lim[0]) as f32 + 0.5) / n * track[2]) * scale;
+        let y = (track[1] + track[3] - 2.0) * scale;
+        image.get_pixel(x as u32, y as u32).0
+    };
+    // the colours the bar uses (see `trust_color`)
+    let (green, amber, red, slate) = ([70, 200, 90], [230, 180, 50], [220, 70, 60], [110, 118, 150]);
+    for (f, want, what) in [(2, green, "sure"), (7, amber, "doubtful"), (11, red, "unsure"), (14, slate, "absent"), (18, green, "sure again")] {
+        let got = sample(f);
+        assert!(close(got, want), "frame {f} ({what}): drew {got:?}, wanted about {want:?}");
+    }
+}
diff --git a/crates/ui-egui/tests/it/ui_script_console.rs b/crates/ui-egui/tests/it/ui_script_console.rs
index e705a20b7..9430bc7a2 100644
--- a/crates/ui-egui/tests/it/ui_script_console.rs
+++ b/crates/ui-egui/tests/it/ui_script_console.rs
@@ -1,6 +1,7 @@
 //! Window ▸ Script Console: the panel shows, runs JavaScript through `script.run` (persistent
 //! context) and logs output, results and errors (egui_kittest, UI logic only).
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_ui_egui::EffectcraftApp;
 use effectcraft_ui_egui::dock::PanelKind;
 use egui_kittest::Harness;
@@ -59,7 +60,7 @@ fn script_console_snapshot() {
     }
     h.state_mut().ui.script_console.input = "app.project.numItems".into();
     h.run_steps(3);
-    let img = h.render().expect("render");
+    let img = h.render_serialized().expect("render");
     let out = std::env::var("SC_SNAPSHOT").unwrap_or_else(|_| concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/test-out/script_console.png").into());
     if let Some(d) = std::path::Path::new(&out).parent() {
         std::fs::create_dir_all(d).unwrap();
diff --git a/crates/ui-egui/tests/it/ui_scriptui.rs b/crates/ui-egui/tests/it/ui_scriptui.rs
index 31fb555d3..a905ebc5a 100644
--- a/crates/ui-egui/tests/it/ui_scriptui.rs
+++ b/crates/ui-egui/tests/it/ui_scriptui.rs
@@ -2,8 +2,10 @@
 //! windows (clicks reach the script's handlers), the branching History panel, and the Window /
 //! File ▸ Scripts menus listing scripts (egui_kittest, UI logic only).
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_ui_egui::EffectcraftApp;
 use effectcraft_ui_egui::dock::PanelKind;
+use effectcraft_ui_egui::dock::WorkspaceExt as _;
 use egui::{Event, Rect, pos2, vec2};
 use egui_kittest::Harness;
 use serde_json::json;
@@ -75,7 +77,7 @@ fn script_windows_are_drawn_and_clickable() {
     h.state_mut().session.execute("window.scriptPanel", json!({"name": "Layer Tools.jsx"})).unwrap();
     h.run_steps(3);
     let panel = h.state().session.script_ui.windows.iter().find(|w| w.script == "Layer Tools.jsx").unwrap().id;
-    assert!(h.state().ui.dock.contains(PanelKind::ScriptPanel(panel)), "the panel docks");
+    assert!(h.state().ui.dock.is_docked(PanelKind::ScriptPanel(panel)), "the panel docks");
     assert!(h.state().auto.find(&format!("scriptui.{panel}")).is_some());
     // The menus list scripts and panels.
     let cx = effectcraft_engine::menus::DynCtx::default();
@@ -104,7 +106,7 @@ fn panels_open_at_quit_dock_again_at_launch() {
     let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).build_eframe(|_| EffectcraftApp::new(s));
     h.run_steps(3);
     let panel = h.state().session.script_ui.windows.iter().find(|w| w.script == "Hello Panel.jsx").expect("the panel's window").id;
-    assert!(h.state().ui.dock.contains(PanelKind::ScriptPanel(panel)), "the panel docks");
+    assert!(h.state().ui.dock.is_docked(PanelKind::ScriptPanel(panel)), "the panel docks");
     assert!(h.state().auto.find(&format!("scriptui.{panel}.hi")).is_some(), "its controls are drawn");
     // Closing its tab forgets it for the next launch.
     h.state_mut().close_panel(PanelKind::ScriptPanel(panel));
@@ -112,6 +114,42 @@ fn panels_open_at_quit_dock_again_at_launch() {
     assert_eq!(store.read(effectcraft_engine::commands::scripts::OPEN_PANELS_FILE).as_deref(), Some(r#"{"open":[]}"#));
 }
 
+/// A script copied into the Scripts folder while the app runs is listed in Edit ▸ Keyboard
+/// Shortcuts and takes a key there: File ▸ Scripts shows the key next to the script, and
+/// pressing it runs the script as its menu entry does.
+#[test]
+fn a_key_given_to_a_script_runs_it() {
+    use effectcraft_engine::config::{ConfigStore, MemoryConfig};
+    let store = std::sync::Arc::new(MemoryConfig::default());
+    let mut s = effectcraft_host::session();
+    s.config = Some(store.clone());
+    let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).build_eframe(|_| EffectcraftApp::new(s));
+    h.run_steps(3);
+    assert!(h.state().session.shortcuts().find(r#"file.runScript {"name":"Rename Layers.jsx"}"#).is_some(), "the shortcut table is built");
+    store.write("Scripts/Add Comp.jsx", "app.project.items.addComp('From Key', 64, 64, 1, 1, 25);").unwrap();
+    effectcraft_ui_egui::panels::shortcut_editor::open(h.state_mut());
+    let script = json!({"name": "Add Comp.jsx"});
+    let r = h.state_mut().session.execute("shortcuts.set", json!({"command": "file.runScript", "params": script, "keys": "Cmd+Alt+Shift+F7"})).unwrap();
+    assert_eq!(r["command"], r#"file.runScript {"name":"Add Comp.jsx"}"#, "{r}");
+    assert_eq!(r["keys"], json!(["Cmd+Alt+Shift+F7"]), "{r}");
+    assert_eq!(r["conflicts"], json!([]), "{r}");
+    h.state_mut().dialog = None;
+    let spec = effectcraft_ui_egui::native_menu::build(h.state());
+    let entry = spec.items().into_iter().find(|i| i.command == "file.runScript" && i.params == script).expect("the File ▸ Scripts entry");
+    assert_eq!(entry.shortcut.as_deref(), Some("Cmd+Alt+Shift+F7"));
+    let (m, k, ..) = effectcraft_ui_egui::menus::bindings(&h.state().session)
+        .into_iter()
+        .find(|b| b.2 == "file.runScript" && b.3 == script)
+        .expect("the key is bound to the script");
+    let made = |h: &Harness<'_, EffectcraftApp>| h.state().session.project.items.values().filter(|i| i.name == "From Key").count();
+    assert_eq!(made(&h), 0);
+    for pressed in [true, false] {
+        h.event(Event::Key { key: k, physical_key: Some(k), pressed, repeat: false, modifiers: m });
+        h.step();
+    }
+    assert_eq!(made(&h), 1, "the key runs the script");
+}
+
 /// The bundled Ease Presets ScriptUI panel (Window ▸ Ease Presets.jsx) docks, and clicking a
 /// preset in its list eases the selected keyframes in one undo step.
 #[test]
@@ -131,7 +169,7 @@ fn ease_presets_panel_eases_the_selected_keys_from_its_list() {
     s.execute("window.scriptPanel", json!({"name": "Ease Presets.jsx"})).unwrap();
     h.run_steps(3);
     let panel = h.state().session.script_ui.windows.iter().find(|w| w.script == "Ease Presets.jsx").unwrap().id;
-    assert!(h.state().ui.dock.contains(PanelKind::ScriptPanel(panel)), "the panel docks");
+    assert!(h.state().ui.dock.is_docked(PanelKind::ScriptPanel(panel)), "the panel docks");
     h.state_mut().ui.maximized = Some(PanelKind::ScriptPanel(panel));
     h.run_steps(3);
     let steps = h.state().session.history.undo.len();
@@ -173,6 +211,7 @@ fn history_panel_jumps_between_branches() {
 /// onDraw fills of concave paths and real images (drawImage, image controls), rendered.
 #[test]
 fn on_draw_concave_fills_and_images_render() {
+    let _device = crate::gpu_test::lock();
     let dir = std::env::temp_dir().join(format!("effectcraft-scriptui-img-{}", std::process::id()));
     std::fs::create_dir_all(&dir).unwrap();
     let png = dir.join("green.png");
@@ -207,7 +246,7 @@ fn on_draw_concave_fills_and_images_render() {
     let g = &win.root.children[0];
     assert!(matches!(&g.draw[1], effectcraft_engine::scriptui::DrawOp::Image { image: Some(i), .. } if i.src.as_deref() == Some(png.as_str())));
     assert_eq!(win.root.children[1].image.as_ref().and_then(|i| i.src.clone()).as_deref(), Some(png.as_str()));
-    let img = h.render().expect("render");
+    let img = h.render_serialized().expect("render");
     if let Ok(d) = std::env::var("EC_SNAPSHOT_DIR") {
         img.save(format!("{d}/scriptui_paint.png")).unwrap();
     }
@@ -263,6 +302,79 @@ fn script_windows_send_mouse_events_to_listeners() {
     h.state_mut().session.execute("scriptui.close", json!({})).unwrap();
 }
 
+/// #2584: a drag that starts on a control keeps reaching it outside the script window (moves and
+/// the release), and `MouseEvent.buttons` tells a drag from a hover.
+#[test]
+fn a_drag_keeps_its_control_past_the_window_edge() {
+    let mut h = harness();
+    let code = r#"
+      var w = new Window("palette", "Drag");
+      var pad = w.add("group", undefined, undefined, { name: "pad" });
+      pad.preferredSize = [120, 80];
+      var log = w.add("statictext", undefined, "", { name: "log" });
+      log.preferredSize = [400, 20];
+      var seen = [];
+      var rec = function (e) { seen.push(e.type + (e.clientX < 0 ? " out" : " in") + " B" + e.buttons); log.text = seen.join("|"); };
+      pad.addEventListener("mousedown", rec);
+      pad.addEventListener("mousemove", rec);
+      pad.addEventListener("mouseup", rec);
+      w.show();
+    "#;
+    let r = h.state_mut().session.execute("script.run", json!({"code": code, "name": "drag.jsx"})).unwrap();
+    assert_eq!(r["ok"], true, "{r}");
+    h.run_steps(3);
+    let win = h.state().session.script_ui.windows[0].id;
+    let pad = rect(&h, &format!("scriptui.{win}.pad"));
+    let (from, to) = (pad.min + vec2(10.0, 20.0), pad.min + vec2(-300.0, 20.0));
+    h.input_mut().events.push(Event::PointerMoved(from));
+    h.run_steps(1);
+    h.input_mut().events.push(Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
+    h.run_steps(1);
+    for k in 1..=4 {
+        h.input_mut().events.push(Event::PointerMoved(from + (to - from) * (k as f32 / 4.0)));
+        h.run_steps(1);
+    }
+    h.input_mut().events.push(Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
+    h.run_steps(3);
+    let log = h.state().session.script_ui.windows[0].root.lookup(&json!("log")).cloned().unwrap().text;
+    assert!(log.starts_with("mousemove in B0|mousedown in B1|"), "a hover move has no button held: {log}");
+    assert!(log.contains("mousedown in B1|mousemove out B1"), "moves outside the window still arrive, with the button held: {log}");
+    assert!(log.ends_with("|mouseup out B0"), "the release outside reaches the control: {log}");
+    h.state_mut().session.execute("scriptui.close", json!({})).unwrap();
+}
+
+/// #2585: a window the host resizes takes the size, lays out again and runs onResize; a docked
+/// ScriptUI panel gets its dock's size that way.
+#[test]
+fn script_windows_learn_the_size_they_are_given() {
+    let mut h = harness();
+    let code = r#"
+      var w = new Window("palette", "Sized");
+      var log = w.add("statictext", undefined, "", { name: "log" });
+      log.preferredSize = [200, 20];
+      w.onResize = function () { log.text = "resized " + w.size.width + "x" + w.size.height; };
+      w.show();
+    "#;
+    let r = h.state_mut().session.execute("script.run", json!({"code": code, "name": "sized.jsx"})).unwrap();
+    assert_eq!(r["ok"], true, "{r}");
+    h.run_steps(2);
+    h.state_mut().session.execute("scriptui.resize", json!({"window": "Sized", "size": [300, 180]})).unwrap();
+    let win = h.state().session.script_ui.windows[0].clone();
+    assert_eq!(win.root.lookup(&json!("log")).unwrap().text, "resized 300x180");
+    let list = h.state_mut().session.execute("scriptui.list", json!({})).unwrap();
+    assert_eq!(list[0]["size"], json!([300.0, 180.0]), "{list}");
+    assert!(h.state_mut().session.execute("scriptui.resize", json!({"window": "Sized", "size": ["wide", 1]})).is_err());
+    h.state_mut().session.execute("scriptui.close", json!({})).unwrap();
+    // A docked panel: its window is its dock's size, not its preferred size.
+    h.state_mut().session.execute("window.scriptPanel", json!({"name": "Layer Tools.jsx"})).unwrap();
+    h.run_steps(4);
+    let panel = h.state().session.script_ui.windows.iter().find(|w| w.script == "Layer Tools.jsx").unwrap().clone();
+    let dock = rect(&h, &format!("scriptui.{}", panel.id));
+    assert_eq!([panel.root.bounds[2].round(), panel.root.bounds[3].round()], [dock.width().round() as f64, dock.height().round() as f64]);
+    h.state_mut().close_panel(PanelKind::ScriptPanel(panel.id));
+    h.run_steps(2);
+}
+
 fn click_at(h: &mut Harness<'_, EffectcraftApp>, c: egui::Pos2) {
     h.input_mut().events.push(Event::PointerMoved(c));
     h.run_steps(1);
diff --git a/crates/ui-egui/tests/it/ui_scrolling.rs b/crates/ui-egui/tests/it/ui_scrolling.rs
index bba415d60..2e0f32ac8 100644
--- a/crates/ui-egui/tests/it/ui_scrolling.rs
+++ b/crates/ui-egui/tests/it/ui_scrolling.rs
@@ -314,7 +314,8 @@ fn panels_taller_than_their_space_have_a_scroll_bar_to_drag() {
         click_at(&mut h, pos2(bar.center().x, bar.min.y + 2.0));
         assert_eq!(scrolled(&h, id).0, 0.0, "{id}: at the top");
         drag(&mut h, pos2(bar.center().x, bar.min.y + 6.0), pos2(bar.center().x, bar.max.y + 40.0));
-        assert_eq!(scrolled(&h, id).0, max, "{id}: dragged to the end");
+        let end = scrolled(&h, id).0;
+        assert!((end - max).abs() < 0.01, "{id}: dragged to the end: {end} of {max}");
     }
 }
 
@@ -332,7 +333,7 @@ fn effect_values_stay_clear_of_the_keyframe_navigator() {
     app.session.execute("prop.toggleAnimation", json!({"layer": lid, "path": path})).unwrap();
     app.session.execute("prop.set", json!({"layer": lid, "path": path, "value": [123456.7, 123456.7]})).unwrap();
     let uid = app.session.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(lid)).unwrap().props.prop(path).unwrap().uid;
-    assert!(app.edit_layout(|l| l.float(PanelKind::EffectControls, [300.0, 150.0, 330.0, 500.0])));
+    app.apply_dock(craft_ui::docking::Action::Float { panel: PanelKind::EffectControls, rect: [300.0, 150.0, 330.0, 500.0] }).unwrap();
     h.run_steps(3);
     let value = rect(&h, &format!("effectControls.prop.{uid}.value.1"));
     let nav = rect(&h, &format!("effectControls.prop.{uid}.prevKey"));
diff --git a/crates/ui-egui/tests/it/ui_self_drop.rs b/crates/ui-egui/tests/it/ui_self_drop.rs
new file mode 100644
index 000000000..f8a44de83
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_self_drop.rs
@@ -0,0 +1,88 @@
+//! #2589: a Project selection that contains the composition being dropped into must not fail the
+//! whole drop. Rendering writes a file named after the composition, so the Project panel holds
+//! both and selects both; the composition itself is not a layer it can hold.
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use egui::{Event, Modifiers, Pos2, Rect, pos2, vec2};
+use egui_kittest::Harness;
+use serde_json::json;
+
+/// Compositions "Main" (active, 4 s at 30 fps, one solid) and "Clip".
+fn harness() -> (Harness<'static, EffectcraftApp>, u64, u64) {
+    let mut s = Session::default();
+    let clip = s.execute("comp.new", json!({"name": "Clip", "width": 160, "height": 90, "frameRate": 30, "duration": 1})).unwrap()["comp"].as_u64().unwrap();
+    let main = s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "frameRate": 30, "duration": 4})).unwrap()["comp"].as_u64().unwrap();
+    s.execute("layer.newSolid", json!({"name": "Bottom", "color": "#406080"})).unwrap();
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
+    h.run_steps(3);
+    (h, main, clip)
+}
+
+fn rect(h: &Harness<'_, EffectcraftApp>, id: &str) -> Rect {
+    let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}")).clone();
+    Rect::from_min_size(pos2(e.rect[0], e.rect[1]), vec2(e.rect[2], e.rect[3]))
+}
+
+/// Press on `from`, move to `to` in steps, release there.
+fn drag(h: &mut Harness<'_, EffectcraftApp>, from: Pos2, to: Pos2) {
+    h.event(Event::PointerMoved(from));
+    h.step();
+    h.event(Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+    h.step();
+    for k in 1..=10 {
+        h.event(Event::PointerMoved(from + (to - from) * (k as f32 / 10.0)));
+        h.step();
+    }
+    h.event(Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+    h.run_steps(3);
+}
+
+fn stack(h: &Harness<'_, EffectcraftApp>) -> Vec<String> {
+    h.state().session.active_comp().unwrap().layers.iter().map(|l| l.name.clone()).collect()
+}
+
+fn layer_id(h: &Harness<'_, EffectcraftApp>, name: &str) -> u64 {
+    h.state().session.active_comp().unwrap().layers.iter().find(|l| l.name == name).unwrap().id.0
+}
+
+/// Both the composition and the render output are selected: dragging the file onto the Timeline
+/// still lands the file, and the composition is not carried along into itself.
+#[test]
+fn a_selection_holding_the_drop_target_does_not_fail_the_drop() {
+    let (mut h, main, clip) = harness();
+    h.state_mut().session.execute("project.select", json!({"items": [main, clip]})).unwrap();
+    h.run_steps(2);
+    let from = rect(&h, &format!("project.item.{clip}.name")).center();
+    let row = rect(&h, &format!("timeline.layer.{}.row", layer_id(&h, "Bottom")));
+    drag(&mut h, from, row.center());
+    assert_eq!(stack(&h), ["Bottom", "Clip"], "the composition the drop lands in is left out");
+    assert!(!h.state().ui.status.contains("contain itself"), "the drop did not fail: {}", h.state().ui.status);
+}
+
+/// Dragging the composition's own row onto its Timeline adds nothing and reports nothing, whether
+/// the row was selected first or the drag started on an unselected row (#2589).
+#[test]
+fn the_composition_dropped_on_itself_adds_nothing() {
+    let (mut h, main, _clip) = harness();
+    h.state_mut().session.execute("project.select", json!({"items": [main]})).unwrap();
+    h.run_steps(2);
+    let before = stack(&h);
+    let from = rect(&h, &format!("project.item.{main}.name")).center();
+    let row = rect(&h, &format!("timeline.layer.{}.row", layer_id(&h, "Bottom")));
+    drag(&mut h, from, row.center());
+    assert_eq!(stack(&h), before, "nothing is added");
+    assert!(!h.state().ui.status.contains("contain itself"), "no error: {}", h.state().ui.status);
+
+    // The same row dragged while something else is selected: the early return for a single
+    // unselected item must not hand the composition to the engine either.
+    let (mut h, main, clip) = harness();
+    h.state_mut().session.execute("project.select", json!({"items": [clip]})).unwrap();
+    h.run_steps(2);
+    let before = stack(&h);
+    let from = rect(&h, &format!("project.item.{main}.name")).center();
+    let row = rect(&h, &format!("timeline.layer.{}.row", layer_id(&h, "Bottom")));
+    drag(&mut h, from, row.center());
+    assert_eq!(stack(&h), before, "nothing is added from an unselected row either");
+    assert!(!h.state().ui.status.contains("contain itself"), "no error: {}", h.state().ui.status);
+}
diff --git a/crates/ui-egui/tests/it/ui_settings_keyboard.rs b/crates/ui-egui/tests/it/ui_settings_keyboard.rs
new file mode 100644
index 000000000..e74ccfd94
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_settings_keyboard.rs
@@ -0,0 +1,113 @@
+//! Settings keyboard operation and accessible names (docs/gaps.md gap 25): the page list is one
+//! Tab stop worked with the arrow keys, Home and End; every control on a page has the name its
+//! label shows, with its value; Escape still cancels.
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use egui::accesskit::{Role, Toggled};
+use egui::{Event, Key, Modifiers};
+use egui_kittest::Harness;
+use egui_kittest::kittest::{NodeT, Queryable};
+use serde_json::json;
+
+fn harness(page: &str) -> Harness<'static, EffectcraftApp> {
+    let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(Session::default()));
+    h.run_steps(3);
+    let ctx = h.ctx.clone();
+    effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "app.settings", json!({"page": page})).unwrap();
+    h.run_steps(4);
+    h
+}
+
+fn key(h: &mut Harness<'_, EffectcraftApp>, key: Key, modifiers: Modifiers) {
+    for pressed in [true, false] {
+        h.input_mut().events.push(Event::Key { key, physical_key: None, pressed, repeat: false, modifiers });
+        h.step();
+    }
+    h.run_steps(3);
+}
+
+fn focused(h: &Harness<'_, EffectcraftApp>) -> Option<(Role, String)> {
+    h.root().children_recursive().find(|n| n.is_focused()).map(|n| (n.accesskit_node().role(), n.accesskit_node().label().unwrap_or_default()))
+}
+
+fn titles() -> Vec<&'static str> {
+    effectcraft_engine::prefs::pages().iter().map(|p| p.title).collect()
+}
+
+#[test]
+fn the_page_list_is_one_tab_stop_worked_with_the_arrows() {
+    let mut h = harness("general");
+    let titles = titles();
+    let n = titles.len();
+    // Every page is a list item: its place in the list, and the open page selected.
+    for (i, title) in titles.iter().enumerate() {
+        let item = h.get_by_role_and_label(Role::ListItem, title);
+        assert_eq!(item.accesskit_node().role(), Role::ListItem, "{title}");
+        assert_eq!(item.accesskit_node().data().position_in_set(), Some(i + 1));
+        assert_eq!(item.accesskit_node().data().size_of_set(), Some(n));
+        assert_eq!(item.accesskit_node().is_selected(), Some(i == 0), "{title}");
+    }
+    h.get_by_role_and_label(Role::ListItem, titles[0]).focus();
+    h.run_steps(3);
+    assert_eq!(focused(&h), Some((Role::ListItem, titles[0].to_string())));
+    key(&mut h, Key::ArrowDown, Modifiers::NONE);
+    assert_eq!(focused(&h), Some((Role::ListItem, titles[1].to_string())), "Down Arrow opens the next page and the focus goes with it");
+    assert_eq!(h.get_by_role_and_label(Role::ListItem, titles[1]).accesskit_node().is_selected(), Some(true));
+    assert_eq!(h.get_by_role_and_label(Role::ListItem, titles[0]).accesskit_node().is_selected(), Some(false));
+    key(&mut h, Key::ArrowUp, Modifiers::NONE);
+    assert_eq!(focused(&h).map(|f| f.1), Some(titles[0].to_string()));
+    key(&mut h, Key::ArrowUp, Modifiers::NONE);
+    assert_eq!(focused(&h).map(|f| f.1), Some(titles[0].to_string()), "Up Arrow stops at the first page");
+    key(&mut h, Key::End, Modifiers::NONE);
+    assert_eq!(focused(&h).map(|f| f.1), Some(titles[n - 1].to_string()), "End goes to the last page");
+    key(&mut h, Key::Home, Modifiers::NONE);
+    assert_eq!(focused(&h).map(|f| f.1), Some(titles[0].to_string()), "Home goes to the first page");
+    // Only the open page is a Tab stop: Tab leaves the list for the page's first control.
+    key(&mut h, Key::Tab, Modifiers::NONE);
+    let (role, _) = focused(&h).expect("Tab moves the focus on");
+    assert_ne!(role, Role::ListItem, "Tab leaves the page list");
+}
+
+#[test]
+fn controls_have_the_name_their_label_shows_and_their_value() {
+    let h = harness("general");
+    let undo = h.get_by_label("Levels of Undo");
+    assert_eq!(undo.accesskit_node().role(), Role::SpinButton);
+    assert!(undo.accesskit_node().numeric_value().is_some(), "a spin button carries its number");
+    let language = h.get_by_label("Language");
+    assert_eq!(language.accesskit_node().role(), Role::ComboBox);
+    assert!(language.accesskit_node().value().is_some_and(|v| !v.is_empty()), "a drop-down carries what it is set to");
+    let tips = h.get_by_label("Show Tool Tips");
+    assert_eq!(tips.accesskit_node().role(), Role::CheckBox);
+    assert!(matches!(tips.accesskit_node().toggled(), Some(Toggled::True | Toggled::False)));
+    for name in ["   OK   ", "Cancel", "Previous", "Next"] {
+        assert_eq!(h.get_by_label(name).accesskit_node().role(), Role::Button, "{name}");
+    }
+    // Previous is disabled on the first page.
+    assert!(h.get_by_label("Previous").accesskit_node().is_disabled());
+}
+
+#[test]
+fn text_fields_colour_buttons_and_theme_cards_are_named() {
+    let h = harness("labels");
+    let name = h.get_by_label("Label 1 name");
+    assert_eq!(name.accesskit_node().role(), Role::TextInput);
+    assert!(name.accesskit_node().value().is_some_and(|v| !v.is_empty()), "the field carries its text");
+    let color = h.get_by_label("Label 1 color");
+    assert_eq!(color.accesskit_node().role(), Role::ColorWell);
+    assert!(color.accesskit_node().value().is_some_and(|v| v.starts_with('#')), "a colour carries its hex value");
+    let h = harness("appearance");
+    assert_eq!(h.get_by_label("Appearance Mode").accesskit_node().role(), Role::ComboBox);
+    assert!(h.query_all_by_role(Role::RadioButton).count() >= 2, "the themes are radio buttons");
+}
+
+#[test]
+fn escape_still_cancels_with_the_keyboard_on_the_page_list() {
+    let mut h = harness("general");
+    let first = titles()[0];
+    h.get_by_role_and_label(Role::ListItem, first).focus();
+    h.run_steps(3);
+    key(&mut h, Key::Escape, Modifiers::NONE);
+    assert!(h.state().dialog.is_none(), "Escape closes the dialog");
+}
diff --git a/crates/ui-egui/tests/it/ui_shortcut_scopes.rs b/crates/ui-egui/tests/it/ui_shortcut_scopes.rs
new file mode 100644
index 000000000..6c79fe72a
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_shortcut_scopes.rs
@@ -0,0 +1,86 @@
+//! Shortcut scopes: one chord can run a different command in a panel than in the rest of the
+//! application, and the Timeline's keys work with the Composition panel focused.
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use egui::{Key, Modifiers};
+use serde_json::json;
+
+/// A comp with one solid selected at 1 s, and one render item.
+fn app() -> EffectcraftApp {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Main", "width": 160, "height": 90, "frameRate": 30, "duration": 4})).unwrap();
+    s.execute("layer.newSolid", json!({"color": "#406080"})).unwrap();
+    s.execute("renderQueue.add", json!({"output": "/out/main.mov"})).unwrap();
+    s.execute("time.set", json!({"time": 1.0})).unwrap();
+    EffectcraftApp::new(s)
+}
+
+/// Press `key` with `modifiers` and run the shortcut dispatcher on it.
+fn press(app: &mut EffectcraftApp, key: Key, modifiers: Modifiers) {
+    let ctx = egui::Context::default();
+    let raw = egui::RawInput { events: vec![egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }], ..Default::default() };
+    let mut output = ctx.run_ui(raw, |ui| effectcraft_ui_egui::menus::handle_shortcuts(app, ui.ctx()));
+    output.textures_delta.clear();
+}
+
+fn layers(app: &EffectcraftApp) -> usize {
+    app.session.active_comp().map_or(0, |c| c.layers.len())
+}
+
+fn render_items(app: &EffectcraftApp) -> usize {
+    app.session.project.render_queue.len()
+}
+
+#[test]
+fn a_panels_shortcut_wins_in_its_panel_and_the_applications_everywhere_else() {
+    let mut app = app();
+    // Duplicate Render Item (Render Queue) on Split Layer's chord.
+    app.session.execute("shortcuts.set", json!({"command": "renderQueue.duplicate", "keys": "Cmd+Shift+D"})).unwrap();
+    let chord = Modifiers::COMMAND | Modifiers::SHIFT;
+
+    app.ui.focused = PanelKind::Timeline;
+    press(&mut app, Key::D, chord);
+    assert_eq!((layers(&app), render_items(&app)), (2, 1), "in the Timeline the chord splits the layer");
+
+    app.ui.focused = PanelKind::RenderQueue;
+    press(&mut app, Key::D, chord);
+    assert_eq!((layers(&app), render_items(&app)), (2, 2), "in the Render Queue it duplicates the render item");
+
+    app.ui.focused = PanelKind::Project;
+    app.session.execute("edit.selectAll", json!({})).unwrap();
+    app.session.execute("time.set", json!({"time": 2.0})).unwrap();
+    press(&mut app, Key::D, chord);
+    assert_eq!((layers(&app), render_items(&app)), (3, 2), "and in any other panel it is Split Layer again");
+}
+
+#[test]
+fn a_panels_shortcut_that_nothing_else_claims_runs_from_any_panel() {
+    let mut app = app();
+    let unclaimed = "Cmd+Alt+Shift+F12";
+    assert!(app.session.shortcuts().bindings().iter().all(|(sc, _)| *sc != unclaimed), "{unclaimed} has a default now; pick a free chord");
+    app.session.execute("shortcuts.set", json!({"command": "renderQueue.duplicate", "keys": unclaimed})).unwrap();
+    app.ui.focused = PanelKind::Timeline;
+    press(&mut app, Key::F12, Modifiers::COMMAND | Modifiers::ALT | Modifiers::SHIFT);
+    assert_eq!(render_items(&app), 2);
+}
+
+#[test]
+fn the_timelines_keys_work_with_the_composition_panel_focused() {
+    for focused in [PanelKind::Timeline, PanelKind::Composition] {
+        let mut app = app();
+        app.ui.focused = focused;
+        // B: the work area begins at the current time (a Timeline shortcut).
+        press(&mut app, Key::B, Modifiers::NONE);
+        let start = app.session.active_comp().map(|c| c.work_area.0.seconds());
+        assert_eq!(start, Some(1.0), "{focused:?}");
+    }
+}
+
+#[test]
+fn the_default_preset_has_no_two_commands_on_one_chord_in_one_scope() {
+    let app = app();
+    let c = app.session.shortcuts().all_conflicts();
+    assert!(c.is_empty(), "{c:?}");
+}
diff --git a/crates/ui-egui/tests/it/ui_tabs.rs b/crates/ui-egui/tests/it/ui_tabs.rs
index fe69d56f9..cc9e56041 100644
--- a/crates/ui-egui/tests/it/ui_tabs.rs
+++ b/crates/ui-egui/tests/it/ui_tabs.rs
@@ -2,10 +2,12 @@
 //! as its own Timeline tab (not a rename, and not in place of the comp shown), the tabs switch and
 //! close comps, and a dragged tab lands where its insertion mark shows.
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_engine::project::ItemId;
 use effectcraft_ui_egui::EffectcraftApp;
-use effectcraft_ui_egui::dock::{DockNode, PanelKind};
+use effectcraft_ui_egui::dock::WorkspaceExt as _;
+use effectcraft_ui_egui::dock::{Node, PanelKind, SplitSize, Workspace};
 use egui::{Event, Pos2, pos2};
 use egui_kittest::Harness;
 use serde_json::json;
@@ -59,15 +61,6 @@ fn drag(h: &mut Harness<'_, EffectcraftApp>, from: Pos2, to: Pos2) {
     h.run_steps(2);
 }
 
-/// The tabs of the docked group holding `p`, in order.
-fn group_of(n: &DockNode, p: PanelKind) -> Option<Vec<PanelKind>> {
-    match n {
-        DockNode::Split { a, b, .. } => group_of(a, p).or_else(|| group_of(b, p)),
-        DockNode::Tabs { panels, .. } => panels.contains(&p).then(|| panels.clone()),
-        DockNode::Stack { entries } => entries.iter().find(|e| e.contains(p)).map(|e| e.panels.clone()),
-    }
-}
-
 fn open_comps(h: &Harness<'_, EffectcraftApp>) -> Vec<u64> {
     h.state().session.state.open_comps.iter().map(|c| c.0).collect()
 }
@@ -81,10 +74,11 @@ fn project_double_click_opens_a_comp_as_its_own_timeline_tab() {
     assert_eq!(open_comps(&h), vec![main, pre]);
     assert_eq!(h.state().session.state.active_comp, Some(ItemId(pre)));
     assert_eq!(h.state().session.project.item(ItemId(pre)).map(|i| i.name.clone()), Some("Pre".into()));
-    // One Timeline tab per comp, the newest last; the shown one answers to the panel's id.
+    // One comp tab per comp in the Timeline's tab strip, the newest last.
     let (tm, tp) = (rect(&h, &format!("panel.tab.Timeline.{main}")), rect(&h, &format!("panel.tab.Timeline.{pre}")));
-    assert!(tp.min.x > tm.max.x, "{tm:?} {tp:?}");
-    assert_eq!(rect(&h, "panel.tab.Timeline"), tp);
+    assert!(tp.min.x >= tm.max.x - 0.5, "{tm:?} {tp:?}");
+    let strip = rect(&h, "panel.tab.Timeline");
+    assert!(strip.y_range().contains(tp.center().y) && tp.min.x > strip.max.x, "{strip:?} {tp:?}");
     // Clicking Main's tab shows Main again; both stay open.
     click_n(&mut h, tm.center(), 1);
     assert_eq!(h.state().session.state.active_comp, Some(ItemId(main)));
@@ -94,7 +88,7 @@ fn project_double_click_opens_a_comp_as_its_own_timeline_tab() {
     click_n(&mut h, close.center(), 1);
     assert_eq!(open_comps(&h), vec![pre]);
     assert_eq!(h.state().session.state.active_comp, Some(ItemId(pre)));
-    assert!(h.state().ui.dock.contains(PanelKind::Timeline));
+    assert!(h.state().ui.dock.is_docked(PanelKind::Timeline));
     // Double-clicking an open comp again adds no second tab.
     let name = rect(&h, &format!("project.item.{pre}.name"));
     click_n(&mut h, name.center(), 2);
@@ -142,7 +136,7 @@ fn tab_drag_snapshot() {
     }
     let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/test-out");
     std::fs::create_dir_all(dir).unwrap();
-    h.render().expect("render").save(format!("{dir}/tab-drag.png")).unwrap();
+    h.render_serialized().expect("render").save(format!("{dir}/tab-drag.png")).unwrap();
 }
 
 /// A precomp layer's bar shows its comp's markers; a double-click opens that comp at the marker.
@@ -179,18 +173,17 @@ fn double_clicking_a_precomp_bar_opens_its_comp() {
     assert_eq!(h.state().session.active_comp_id(), Some(ItemId(pre)));
 }
 
-/// Issue #46: a panel dragged by its panel-menu (hamburger) button onto the left edge of another
-/// group docks there as its own group; dragging the gap between panels resizes them.
+/// Issue #46: a panel dragged onto the left edge of another group docks there as its own group;
+/// dragging the gap between panels resizes them.
 #[test]
 fn panels_dock_beside_others_and_gutters_resize_them() {
     let (mut h, _, _) = harness();
     let dock = |h: &Harness<'_, EffectcraftApp>| h.state().ui.dock.clone();
-    // Show Effect Controls in its group so its menu button is on screen, then drag by it.
     let tab = rect(&h, "panel.tab.EffectControls");
-    click_n(&mut h, tab.center(), 1);
-    let grip = rect(&h, "panel.menu.EffectControls").center();
     let tl = rect(&h, "panel.Timeline");
-    drag(&mut h, grip, pos2(tl.min.x + tl.width() * 0.08, tl.center().y));
+    // Inside the Timeline body's left drop zone.
+    let depth = craft_ui::docking::SIDE_EDGE_ZONE_DEPTH.min(tl.width().min(tl.height()) / 4.0);
+    drag(&mut h, tab.center(), pos2(tl.min.x + depth / 2.0, tl.center().y));
     assert_eq!(group_of(&dock(&h), PanelKind::EffectControls), Some(vec![PanelKind::EffectControls]));
     assert!(!group_of(&dock(&h), PanelKind::Timeline).unwrap().contains(&PanelKind::EffectControls));
     let (fx, tl) = (rect(&h, "panel.EffectControls"), rect(&h, "panel.Timeline"));
@@ -212,41 +205,83 @@ fn panels_dock_beside_others_and_gutters_resize_them() {
     assert!((wider.width() - project.width() - 60.0).abs() < 2.0, "{} → {}", project.width(), wider.width());
 }
 
-/// Issue #171: the gaps between the right column's stacked panels drag to resize them (Preview
-/// was stuck at its default height), not below a minimum; the heights stay in the layout.
+/// The divider below the Preview frame: the horizontal gutter between it and the Properties
+/// frame.
+fn preview_divider(h: &Harness<'_, EffectcraftApp>) -> egui::Rect {
+    let (preview, props) = (rect(h, "panel.Preview"), rect(h, "panel.Properties"));
+    h.state()
+        .auto
+        .previous
+        .iter()
+        .filter(|e| e.id.starts_with("dock.gutter.") && e.rect[2] > e.rect[3])
+        .map(|e| egui::Rect::from_min_size(pos2(e.rect[0], e.rect[1]), egui::vec2(e.rect[2], e.rect[3])))
+        .find(|g| g.x_range().contains(preview.center().x) && g.center().y >= preview.max.y - 1.0 && g.center().y <= props.min.y + 1.0)
+        .expect("a gutter between Preview and Properties")
+}
+
+/// Default's right column: a short Preview frame (46 points of body) and the Properties frame
+/// below it taking the rest of the column, at any window height.
 #[test]
-fn stacked_panel_gaps_resize_the_panels() {
+fn the_default_preview_frame_is_short_and_properties_takes_the_rest() {
     let (mut h, _, _) = harness();
-    fn height(n: &DockNode, p: PanelKind) -> Option<Option<f32>> {
-        match n {
-            DockNode::Split { a, b, .. } => height(a, p).or_else(|| height(b, p)),
-            DockNode::Tabs { .. } => None,
-            DockNode::Stack { entries } => entries.iter().find(|e| e.contains(p)).map(|e| e.height),
+    let body = |h: &Harness<'_, EffectcraftApp>| rect(h, "panel.Preview").height();
+    assert!((body(&h) - 46.0).abs() < 1.5, "Preview {}", body(&h));
+    let props = rect(&h, "panel.Properties");
+    assert!(props.height() > 300.0, "Properties {props:?}");
+    // A taller window gives the room to Properties.
+    let size = h.ctx.content_rect().size();
+    h.set_size(size + egui::vec2(0.0, 200.0));
+    h.run_steps(3);
+    assert!((body(&h) - 46.0).abs() < 1.5, "Preview {}", body(&h));
+    assert!((rect(&h, "panel.Properties").height() - props.height() - 200.0).abs() < 2.0);
+}
+
+/// Issue #171: the divider below the Preview frame drags to resize it (Preview was stuck at its
+/// default height), not below a minimum; the new height stays in the layout.
+#[test]
+fn the_preview_frame_divider_resizes_it() {
+    let (mut h, _, _) = harness();
+    fn preview_size(w: &Workspace) -> Option<SplitSize> {
+        fn rec(n: &Node<PanelKind>) -> Option<SplitSize> {
+            match n {
+                Node::Split { first, second, size, .. } => match first.as_ref() {
+                    Node::Tabs { panels, .. } if panels.contains(&PanelKind::Preview) => Some(*size),
+                    _ => rec(first).or_else(|| rec(second)),
+                },
+                _ => None,
+            }
         }
+        rec(w.layout.root.as_ref()?)
     }
     let (preview, props) = (rect(&h, "panel.Preview"), rect(&h, "panel.Properties"));
-    let gap = rect(&h, "dock.gutter.bs0");
-    assert!(gap.center().y > preview.max.y && gap.center().y < props.min.y, "the gap below Preview: {gap:?}");
+    let gap = preview_divider(&h);
     drag(&mut h, gap.center(), gap.center() + egui::vec2(0.0, 150.0));
     let (p2, q2) = (rect(&h, "panel.Preview"), rect(&h, "panel.Properties"));
     assert!((p2.height() - preview.height() - 150.0).abs() < 2.0, "Preview {} → {}", preview.height(), p2.height());
     assert!((props.height() - q2.height() - 150.0).abs() < 2.0, "Properties {} → {}", props.height(), q2.height());
     assert!((q2.max.y - props.max.y).abs() < 1.0, "the column stays filled");
-    let saved = height(&h.state().ui.dock, PanelKind::Preview).flatten().expect("Preview's height is in the layout");
-    assert!((saved - p2.height()).abs() < 2.0, "{saved} vs {}", p2.height());
-    assert_eq!(height(&h.state().ui.dock, PanelKind::Properties), Some(None), "Properties still takes the rest");
-    // Collapsing and expanding Preview keeps its height.
-    let tab = rect(&h, "panel.tab.Preview");
-    click_n(&mut h, tab.center(), 1);
-    assert!(!h.state().ui.dock.is_visible(PanelKind::Preview));
-    click_n(&mut h, tab.center(), 1);
-    assert!((rect(&h, "panel.Preview").height() - p2.height()).abs() < 1.0);
-    // Not below the minimum.
-    let gap = rect(&h, "dock.gutter.bs0");
-    drag(&mut h, gap.center(), gap.center() - egui::vec2(0.0, 400.0));
+    // The frame keeps a fixed height, 150 points more.
+    let Some(SplitSize::FixedFirst(size)) = preview_size(&h.state().ui.dock) else { panic!("{:?}", preview_size(&h.state().ui.dock)) };
+    assert!((size - effectcraft_ui_egui::dock::PREVIEW_FRAME - 150.0).abs() < 2.0, "{size}");
+    // Dragged up to Preview's top, it stops at its minimum.
+    let gap = preview_divider(&h);
+    let top = rect(&h, "panel.Preview").min.y;
+    drag(&mut h, gap.center(), pos2(gap.center().x, top));
     assert!((rect(&h, "panel.Preview").height() - 40.0).abs() < 1.0, "{}", rect(&h, "panel.Preview").height());
 }
 
+/// Maximize acts on one frame: the Preview frame fills the dock area, Properties hides.
+#[test]
+fn maximizing_preview_maximizes_its_frame_alone() {
+    let (mut h, _, _) = harness();
+    let preview = rect(&h, "panel.Preview");
+    h.state_mut().ui.maximized = Some(PanelKind::Preview);
+    h.run_steps(3);
+    let big = rect(&h, "panel.Preview");
+    assert!(big.height() > preview.height() + 300.0 && big.width() > preview.width() + 300.0, "{preview:?} → {big:?}");
+    assert!(h.state().auto.find("panel.Properties").is_none(), "the Properties frame is not shown");
+}
+
 /// Issue #45: the Project panel's details (name, size, duration) stay inside the panel with a
 /// margin, cut short with "…" when they don't fit; so does the hint shown with nothing selected.
 #[test]
@@ -338,42 +373,125 @@ fn dragging_the_viewer_timeline_divider_far_up_does_not_crash() {
     h.run_steps(2);
 }
 
-/// Issue #301: clicking anywhere on a stacked panel's header bar expands/collapses it, not only
-/// its name; the panel menu button keeps its own click.
+/// Issue #301: a stacked panel's header bar opens it with a click anywhere on it, and its −/+
+/// button at the bar's right end collapses and expands it.
 #[test]
 fn a_stacked_panels_whole_header_bar_toggles_it() {
     let (mut h, _, _) = harness();
+    use effectcraft_ui_egui::dock;
+    let stack = dock::stack(&[(PanelKind::Preview, true, Some(46.0)), (PanelKind::Properties, true, None)]);
+    h.state_mut().ui.dock = dock::docked(dock::hsplit(SplitSize::FixedSecond(300.0), dock::tabs(&[PanelKind::Composition], 0), stack));
+    h.run_steps(3);
     let open = |h: &Harness<'_, EffectcraftApp>| h.state().ui.dock.is_visible(PanelKind::Preview);
     assert!(open(&h));
-    let bar = rect(&h, "panel.header.Preview");
-    let tab = rect(&h, "panel.tab.Preview");
-    assert!(bar.min.x >= tab.max.x - 1.0 && bar.width() > 40.0, "{bar:?} {tab:?}");
-    click_n(&mut h, pos2(bar.max.x - 6.0, bar.center().y), 1);
-    assert!(!open(&h), "a click at the bar's right end collapses Preview");
-    let bar = rect(&h, "panel.header.Preview");
-    click_n(&mut h, bar.center(), 1);
+    let toggle = rect(&h, "panel.header.Preview");
+    let bar = rect(&h, "panel.tab.Preview");
+    assert!(toggle.max.x <= bar.max.x + 1.0 && toggle.min.x > bar.center().x, "{toggle:?} {bar:?}");
+    click_n(&mut h, toggle.center(), 1);
+    assert!(!open(&h), "the button collapses Preview");
+    let toggle = rect(&h, "panel.header.Preview");
+    click_n(&mut h, toggle.center(), 1);
     assert!(open(&h), "and expands it again");
-    let menu = rect(&h, "panel.menu.Preview");
-    click_n(&mut h, menu.center(), 1);
-    assert!(open(&h), "the panel menu button doesn't toggle the panel");
+    let toggle = rect(&h, "panel.header.Preview");
+    click_n(&mut h, toggle.center(), 1);
+    assert!(!open(&h));
+    click_n(&mut h, pos2(bar.min.x + bar.width() * 0.25, bar.center().y), 1);
+    assert!(open(&h), "a click on the bar away from the button opens it");
 }
 
-/// #302: a panel dropped onto a stacked panel becomes a tab in that panel's frame (it was
-/// inserted as a stacked panel of its own below it); its tabs switch the frame's panel.
+/// #302: a panel dropped onto the Properties frame becomes a tab in that frame; its tabs switch
+/// the frame's panel, and the Preview frame above keeps showing.
 #[test]
-fn a_tab_dropped_on_a_stacked_panel_joins_its_frame() {
+fn a_tab_dropped_on_a_frame_joins_it() {
     let (mut h, _, _) = harness();
     let dock = |h: &Harness<'_, EffectcraftApp>| h.state().ui.dock.clone();
     let fx = rect(&h, "panel.tab.EffectControls");
     let props = rect(&h, "panel.Properties");
     drag(&mut h, fx.center(), props.center());
-    assert_eq!(group_of(&dock(&h), PanelKind::Properties), Some(vec![PanelKind::Properties, PanelKind::EffectControls]));
+    let group = group_of(&dock(&h), PanelKind::Properties).unwrap();
+    assert!(group.starts_with(&[PanelKind::Properties]) && group.contains(&PanelKind::EffectControls), "{group:?}");
     assert!(dock(&h).is_visible(PanelKind::EffectControls) && !dock(&h).is_visible(PanelKind::Properties));
+    assert!(dock(&h).is_visible(PanelKind::Preview));
     // The frame's other tab shows Properties again, the frame stays open.
     let tab = rect(&h, "panel.tab.Properties");
     click_n(&mut h, tab.center(), 1);
     assert!(dock(&h).is_visible(PanelKind::Properties) && !dock(&h).is_visible(PanelKind::EffectControls));
     // The layout (saved workspaces) round-trips.
     let s = serde_json::to_string(&dock(&h)).unwrap();
-    assert_eq!(serde_json::from_str::<DockNode>(&s).unwrap(), dock(&h));
+    assert_eq!(serde_json::from_str::<Workspace>(&s).unwrap(), dock(&h));
+}
+
+/// The tabs of the group holding `p`, in order.
+fn group_of(w: &Workspace, p: PanelKind) -> Option<Vec<PanelKind>> {
+    Some(w.group_of(p)).filter(|g| !g.is_empty())
+}
+
+fn has(h: &Harness<'_, EffectcraftApp>, id: &str) -> bool {
+    h.state().auto.previous.iter().chain(h.state().auto.elements.iter()).any(|e| e.id == id)
+}
+
+#[test]
+fn open_comps_are_tabs_in_the_timeline_row_and_the_rest_are_in_its_overflow_menu() {
+    let mut s = Session::default();
+    let names = ["Opening Titles", "Lower Third Left", "Lower Third Right", "Product Shot", "End Card Wide", "Logo Sting Short"];
+    let comps: Vec<u64> = names
+        .iter()
+        .map(|name| s.execute("comp.new", json!({"name": name, "width": 320, "height": 180, "duration": 4})).unwrap()["comp"].as_u64().unwrap())
+        .collect();
+    s.state.open_comps = vec![ItemId(comps[0])];
+    s.state.active_comp = Some(ItemId(comps[0]));
+    let mut h = Harness::builder().with_size(egui::vec2(1000.0, 800.0)).build_eframe(|_| EffectcraftApp::new(s));
+    h.run_steps(3);
+    let alone = rect(&h, "panel.tab.RenderQueue");
+    h.state_mut().session.state.open_comps = comps.iter().map(|c| ItemId(*c)).collect();
+    h.run_steps(3);
+    // The panel tabs keep their width; the comp tabs follow them in the same row, in order.
+    let (tl, rq) = (rect(&h, "panel.tab.Timeline"), rect(&h, "panel.tab.RenderQueue"));
+    assert!((rq.width() - alone.width()).abs() < 0.5, "Render Queue {rq:?} was {alone:?}");
+    let shown: Vec<u64> = comps.iter().copied().filter(|c| has(&h, &format!("panel.tab.Timeline.{c}"))).collect();
+    assert!(shown.contains(&comps[0]) && shown.len() < comps.len(), "{shown:?}");
+    let mut x = rq.max.x;
+    for c in &shown {
+        let tab = rect(&h, &format!("panel.tab.Timeline.{c}"));
+        assert!(tl.y_range().contains(tab.center().y) && tab.min.x >= x - 0.5, "comp {c} at {tab:?} after x {x}");
+        x = tab.max.x;
+    }
+    // A comp with no room is in the » menu; picking it shows it, and its tab joins the row.
+    let hidden = comps.iter().copied().find(|c| !shown.contains(c)).unwrap();
+    let more = rect(&h, "panel.tab.Timeline.more");
+    assert!(more.min.x >= x - 0.5 && tl.y_range().contains(more.center().y), "{more:?}");
+    click_n(&mut h, more.center(), 1);
+    let item = rect(&h, &format!("panel.tab.Timeline.more.{hidden}"));
+    click_n(&mut h, item.center(), 1);
+    assert_eq!(h.state().session.state.active_comp, Some(ItemId(hidden)));
+    assert_eq!(open_comps(&h), comps);
+    assert!(has(&h, &format!("panel.tab.Timeline.{hidden}")));
+}
+
+/// Whether `id` was registered in the last frame (not the one before).
+fn drawn(h: &Harness<'_, EffectcraftApp>, id: &str) -> bool {
+    h.state().auto.elements.iter().any(|e| e.id == id)
+}
+
+#[test]
+fn an_inactive_comp_tab_shows_its_close_button_on_hover_and_closes_without_showing_its_comp() {
+    let (mut h, pre, main) = harness();
+    h.state_mut().session.state.open_comps = vec![ItemId(main), ItemId(pre)];
+    h.run_steps(3);
+    let (tm, tp) = (rect(&h, &format!("panel.tab.Timeline.{main}")), rect(&h, &format!("panel.tab.Timeline.{pre}")));
+    // The shown comp's × is always there; Pre's only while the pointer is over its tab.
+    h.event(Event::PointerMoved(pos2(800.0, 900.0)));
+    h.run_steps(2);
+    assert!(drawn(&h, "panel.tab.Timeline.close") && drawn(&h, &format!("panel.tab.Timeline.{main}.close")));
+    assert!(!drawn(&h, &format!("panel.tab.Timeline.{pre}.close")), "no × on an inactive tab the pointer is not over");
+    h.event(Event::PointerMoved(tp.center()));
+    h.run_steps(2);
+    let close = rect(&h, &format!("panel.tab.Timeline.{pre}.close"));
+    assert!(tp.contains_rect(close), "{close:?} inside {tp:?}");
+    // Every comp tab keeps the ×'s room: hovering changes no width.
+    assert_eq!((rect(&h, &format!("panel.tab.Timeline.{main}")), rect(&h, &format!("panel.tab.Timeline.{pre}"))), (tm, tp));
+    // Its × closes Pre's Timeline; Main stays shown.
+    click_n(&mut h, close.center(), 1);
+    assert_eq!(open_comps(&h), vec![main]);
+    assert_eq!(h.state().session.state.active_comp, Some(ItemId(main)));
 }
diff --git a/crates/ui-egui/tests/it/ui_tail.rs b/crates/ui-egui/tests/it/ui_tail.rs
index ca9026623..a824e065c 100644
--- a/crates/ui-egui/tests/it/ui_tail.rs
+++ b/crates/ui-egui/tests/it/ui_tail.rs
@@ -175,6 +175,30 @@ fn layer_style_buttons_stay_in_view() {
     }
 }
 
+/// #2057: Gradient Overlay's gradient has an Edit Gradient… button in the Layer Style dialog. It
+/// opens the Gradient Editor on that property, and closing the editor goes back to the dialog.
+#[test]
+fn layer_style_gradient_opens_the_gradient_editor() {
+    for ok in [true, false] {
+        let mut h = harness(1400.0);
+        let lid = h.state().session.active_comp().unwrap().layers[0].id.0;
+        h.state_mut().session.execute("layer.select", json!({"layers": [lid]})).unwrap();
+        let ctx = h.ctx.clone();
+        effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "layer.style.gradientOverlay", json!({})).unwrap();
+        h.run_steps(5);
+        let edit = in_view(&h, "dialog.layerStyle.value.gradientOverlay/colors");
+        click(&mut h, edit);
+        assert_eq!(h.state().dialog, Some(effectcraft_ui_egui::Dialog::GradientEditor), "Edit Gradient… opened the editor");
+        effectcraft_ui_egui::panels::gradient_editor::finish(h.state_mut(), ok, &ctx);
+        h.run_steps(2);
+        assert_eq!(h.state().dialog, Some(effectcraft_ui_egui::Dialog::LayerStyles), "closing the editor (OK {ok}) went back to the dialog");
+        // The dialog closes as before once the editor is gone.
+        effectcraft_ui_egui::panels::layer_styles_dialog::finish(h.state_mut(), true);
+        h.run_steps(2);
+        assert_eq!(h.state().dialog, None);
+    }
+}
+
 /// #1062: with the buttons kept at the bottom, the style's controls still scroll both ways, so
 /// every one of them can be reached in the smallest window (960×600) at 200 % UI Scale, and in a
 /// dialog opened in a large window that then narrows: here Noise, near the end of Drop Shadow,
@@ -208,6 +232,38 @@ fn layer_style_controls_stay_reachable_in_a_small_window() {
     }
 }
 
+/// #1389: on a layer with no styles, Blending Options shows its controls instead of an empty
+/// page. Opening the dialog adds nothing; the first change creates the Layer Styles group, and
+/// the group and the whole drag are one undo step.
+#[test]
+fn layer_style_blending_options_edit_a_layer_without_styles() {
+    let mut h = harness(1400.0);
+    let lid = h.state().session.active_comp().unwrap().layers[0].id.0;
+    h.state_mut().session.execute("layer.select", json!({"layers": [lid]})).unwrap();
+    let ctx = h.ctx.clone();
+    effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "layer.style.options", json!({})).unwrap();
+    h.run_steps(5);
+    let has_group = |h: &Harness<'_, EffectcraftApp>| h.state().session.active_comp().unwrap().layers[0].layer_styles().is_some();
+    let undo = h.state().session.history.undo.len();
+    assert_eq!(h.state().auto.find("dialog.layerStyle.page").unwrap().label, "blendingOptions");
+    let fill = "dialog.layerStyle.value.blendingOptions/advancedBlending/fillOpacity";
+    assert!(h.state().auto.find("dialog.layerStyle.value.blendingOptions/globalLightAngle").is_some(), "Global Light is shown");
+    let at = in_view(&h, fill);
+    assert!(!has_group(&h), "opening the page adds nothing");
+    drag(&mut h, at, at - vec2(40.0, 0.0));
+    let v =
+        h.state_mut().session.execute("prop.get", json!({"layer": lid, "path": "layerStyles/blendingOptions/advancedBlending/fillOpacity"})).unwrap()["value"]
+            .as_f64()
+            .unwrap();
+    assert!(v < 100.0, "Fill Opacity was dragged: {v}");
+    assert!(styles(&mut h).is_empty(), "no style was added");
+    assert_eq!(h.state().session.history.undo.len(), undo + 1, "the group and the drag are one undo step");
+    assert_eq!(h.state().dialog, Some(effectcraft_ui_egui::Dialog::LayerStyles));
+    effectcraft_ui_egui::panels::layer_styles_dialog::finish(h.state_mut(), true);
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    assert!(!has_group(&h), "one undo removes the group");
+}
+
 #[test]
 fn layer_style_dialog_moves_by_its_title() {
     let mut h = harness(1400.0);
diff --git a/crates/ui-egui/tests/it/ui_text_edit.rs b/crates/ui-egui/tests/it/ui_text_edit.rs
index 84a218466..6b68028de 100644
--- a/crates/ui-egui/tests/it/ui_text_edit.rs
+++ b/crates/ui-egui/tests/it/ui_text_edit.rs
@@ -8,6 +8,7 @@ use effectcraft_ui_egui::EffectcraftApp;
 use effectcraft_ui_egui::dock::PanelKind;
 use egui::{Event, Key, Modifiers, PointerButton, Pos2};
 use egui_kittest::Harness;
+use egui_kittest::kittest::Queryable;
 use serde_json::json;
 
 fn app() -> EffectcraftApp {
@@ -171,7 +172,7 @@ fn type_tool_click_type_edit_and_commit() {
 /// #831: clicking another panel (a solid's row in the Timeline) ends text editing and gives the
 /// keyboard back, whether the edit began with the Type tool (which stays selected) or by command:
 /// typed characters change no text and Space plays. The Character panel keeps the edit, and a
-/// text layer clicked into being and left empty goes away.
+/// text layer clicked into being and left empty stays, as it does in After Effects.
 #[test]
 fn clicking_another_panel_stops_typing_into_text() {
     for type_tool in [false, true] {
@@ -194,7 +195,7 @@ fn clicking_another_panel_stops_typing_into_text() {
             assert_eq!(layers(&h), 3, "the Type tool started a text layer");
             let at_row = row(&h);
             click(&mut h, at_row, Modifiers::NONE);
-            assert_eq!(layers(&h), 2, "left empty, it is removed");
+            assert_eq!(layers(&h), 3, "left empty, it stays, as in After Effects");
             click(&mut h, at, Modifiers::NONE);
         } else {
             h.state_mut().session.execute("text.edit", json!({"layer": title})).unwrap();
@@ -580,7 +581,7 @@ fn type_tool_selected_text_preference_skips_ineligible_layers_and_falls_back_to_
 }
 
 /// Opens a fresh Type-tool edit holding `text` and returns the harness with the new layer id,
-/// so the Deselect All tests start from the same state.
+/// so the Deselect All and Duplicate tests start from the same state.
 fn type_tool_edit(a: EffectcraftApp, text: &str) -> (Harness<'static, EffectcraftApp>, u64) {
     let mut h = harness(a);
     h.run_steps(3);
@@ -728,6 +729,110 @@ fn deselect_all_menu_item_follows_the_edit_while_the_project_panel_is_focused()
     assert!(!enabled(&h), "Deselect All follows the empty Project selection once the edit is over");
 }
 
+/// Layer ids of the active comp, bottom to top.
+fn layer_ids(h: &Harness<'_, EffectcraftApp>) -> Vec<u64> {
+    h.state().session.active_comp().map_or(vec![], |c| c.layers.iter().map(|l| l.id.0).collect())
+}
+
+#[test]
+fn duplicate_chord_ends_a_type_tool_edit_and_selects_the_copy() {
+    let (mut h, lid) = type_tool_edit(app(), "Hello");
+    key(&mut h, Key::D, Modifiers::COMMAND);
+    let s = &h.state().session;
+    assert!(s.state.text_edit.is_none(), "Duplicate ends the open edit, as Deselect All does");
+    let copy = *s.state.selected_layers.first().expect("the copy is selected");
+    assert_ne!(copy.0, lid, "the copy (not the edited original) holds the selection");
+    assert_eq!(layer_doc(s, LayerId(lid)).unwrap().text, "Hello", "the original keeps its text");
+    assert_eq!(layer_doc(s, copy).unwrap().text, "Hello", "the copy carries it too");
+}
+
+#[test]
+fn duplicate_chord_ends_an_edit_started_while_the_project_panel_is_focused() {
+    let (mut h, lid) = project_focused_text_edit("Hi");
+    key(&mut h, Key::D, Modifiers::COMMAND);
+    let s = &h.state().session;
+    assert!(s.state.text_edit.is_none(), "Cmd+D ends the edit even with Project focused");
+    let copy = s.state.selected_layers.first().expect("the copy is selected");
+    assert_eq!(layer_doc(s, LayerId(lid)).unwrap().text, "Hi", "the typed text is kept");
+    assert_eq!(layer_doc(s, *copy).unwrap().text, "Hi", "on the copy as well");
+}
+
+#[test]
+fn rebound_duplicate_chord_forwards_from_inside_the_edit() {
+    let mut a = app();
+    a.session.execute("shortcuts.set", json!({"command": "edit.duplicate", "keys": ["Cmd+Alt+D"]})).unwrap();
+    let (mut h, lid) = type_tool_edit(a, "Hello");
+    // The default key no longer belongs to Duplicate: while the editor holds the keyboard a
+    // chord that matches no command does nothing, and the current binding is what forwards.
+    let n = layer_ids(&h).len();
+    key(&mut h, Key::D, Modifiers::COMMAND);
+    assert!(h.state().session.state.text_edit.is_some(), "Cmd+D was rebound away: the edit stays open");
+    assert_eq!(layer_ids(&h).len(), n, "and nothing was duplicated");
+    key(&mut h, Key::D, Modifiers { alt: true, ..Modifiers::COMMAND });
+    let s = &h.state().session;
+    assert!(s.state.text_edit.is_none(), "the rebound chord ends the edit");
+    assert_eq!(layer_doc(s, LayerId(lid)).unwrap().text, "Hello", "the text is kept");
+    assert_eq!(layer_ids(&h).len(), n + 1, "and the copy exists");
+}
+
+#[test]
+fn duplicate_rebound_onto_a_bare_letter_stays_typing() {
+    let mut a = app();
+    a.session.execute("shortcuts.set", json!({"command": "edit.duplicate", "keys": ["D"]})).unwrap();
+    let (mut h, lid) = type_tool_edit(a, "Hello");
+    let n = layer_ids(&h).len();
+    // A binding without a command modifier is text as far as the editor is concerned: the editor
+    // must not surrender a key that types (same invariant as the app-wide dispatcher).
+    key(&mut h, Key::D, Modifiers::NONE);
+    assert!(h.state().session.state.text_edit.is_some(), "a bare-letter Duplicate binding does not end the edit");
+    assert_eq!(layer_ids(&h).len(), n, "and does not duplicate");
+    type_text(&mut h, "D");
+    let (lid2, text, _, _) = edited(&h);
+    assert_eq!(lid2, lid, "the same edit on the same layer continues");
+    assert_eq!(text, "HelloD", "and the letter typed into the text");
+}
+
+#[test]
+fn duplicate_chord_copies_the_edited_layer_not_an_effect_still_selected() {
+    let mut a = app();
+    let lid = a.session.execute("layer.newText", json!({"text": "alpha beta", "size": 40, "box": [40, 60, 250, 100]})).unwrap()["layer"].as_u64().unwrap();
+    // Applying the blur selects it, as clicking it in Effect Controls does.
+    a.session.execute("effect.apply", json!({"layers": [lid], "effect": "Gaussian Blur"})).unwrap();
+    a.ui.tool = effectcraft_ui_egui::state::Tool::Type;
+    let mut h = harness(a);
+    h.run_steps(3);
+    let comp = rect(&h, "viewer.comp");
+    click(&mut h, comp.min + egui::vec2(80.0, 85.0) * (comp.width() / 640.0), Modifiers::NONE);
+    assert_eq!(edited(&h).0, lid, "the Type tool's click opens the text layer for editing");
+    assert!(!h.state().session.state.selected_props.is_empty(), "and the blur stays selected");
+    let n = layer_ids(&h).len();
+    key(&mut h, Key::D, Modifiers::COMMAND);
+    let s = &h.state().session;
+    assert!(s.state.text_edit.is_none(), "Duplicate ends the edit");
+    assert_eq!(layer_ids(&h).len(), n + 1, "and copies the edited layer");
+    let blurs = s.active_comp().unwrap().layer(LayerId(lid)).unwrap().effects().map_or(0, |fx| fx.groups().count());
+    assert_eq!(blurs, 1, "not the blur");
+}
+
+#[test]
+fn a_chord_bound_to_both_forwarded_commands_resolves_in_list_order() {
+    let mut a = app();
+    // Shortcuts may hold one chord for several commands (the conflict is a toast, not a
+    // refusal), so the editor's forwarding resolves a shared chord in list order — Deselect
+    // All before Duplicate. This pins that documented contract: the shared chord must end the
+    // edit like Deselect All, without running Duplicate behind it.
+    a.session.execute("shortcuts.set", json!({"command": "edit.deselectAll", "keys": ["Cmd+Alt+G"]})).unwrap();
+    a.session.execute("shortcuts.set", json!({"command": "edit.duplicate", "keys": ["Cmd+Alt+G"]})).unwrap();
+    let (mut h, lid) = type_tool_edit(a, "Hello");
+    let n = layer_ids(&h).len();
+    key(&mut h, Key::G, Modifiers { alt: true, ..Modifiers::COMMAND });
+    let s = &h.state().session;
+    assert!(s.state.text_edit.is_none(), "the shared chord still ends the edit");
+    assert!(s.state.selected_layers.is_empty(), "Deselect All wins the shared chord: nothing is selected");
+    assert_eq!(layer_ids(&h).len(), n, "so the chord did not duplicate");
+    assert_eq!(layer_doc(s, LayerId(lid)).unwrap().text, "Hello", "and the text is kept");
+}
+
 /// The on-canvas editor's outgoing IME producer: the descriptor carries the edited layer's
 /// committed text, the real owner, a stable generation and an explicit change cause. A normal
 /// typed character is application work; an accepted input-method commit is not.
@@ -1734,3 +1839,35 @@ fn same_caret_application_text_replacement_rejects_the_previous_context_fence()
     h.run_steps(1);
     assert_eq!(edited(&h).1, "Aがbcd");
 }
+
+/// #2077: the Character panel's Line Join buttons set the stroke's corner style (Miter for new text).
+#[test]
+fn character_panel_line_join_buttons_set_the_join() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Type", "width": 640, "height": 360, "duration": 2})).unwrap();
+    let lid = s.execute("layer.newText", json!({"text": "Join", "size": 80, "applyStroke": true, "strokeWidth": 8})).unwrap()["layer"].as_u64().unwrap();
+    let mut h = harness(EffectcraftApp::new(s));
+    h.state_mut().show_panel(PanelKind::Character);
+    h.run_steps(3);
+    let join = |h: &Harness<'_, EffectcraftApp>| layer_doc(&h.state().session, LayerId(lid)).unwrap().line_join;
+    assert_eq!(join(&h), effectcraft_engine::keyframe::LineJoin::Miter);
+    let bevel = rect(&h, "character.lineJoin.bevel").center();
+    click(&mut h, bevel, Modifiers::NONE);
+    assert_eq!(join(&h), effectcraft_engine::keyframe::LineJoin::Bevel);
+}
+
+/// #2075: the Character panel's stroke width has a presets menu (0.25 … 100 px) beside its value.
+#[test]
+fn character_panel_stroke_width_presets_set_the_width() {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Type", "width": 640, "height": 360, "duration": 2})).unwrap();
+    let lid = s.execute("layer.newText", json!({"text": "Stroke", "size": 80, "applyStroke": true, "strokeWidth": 8})).unwrap()["layer"].as_u64().unwrap();
+    let mut h = harness(EffectcraftApp::new(s));
+    h.state_mut().show_panel(PanelKind::Character);
+    h.run_steps(3);
+    let arrow = rect(&h, "character.strokeWidth.presets").center();
+    click(&mut h, arrow, Modifiers::NONE);
+    let entry = h.get_by_label("0.5 px").rect().center();
+    click(&mut h, entry, Modifiers::NONE);
+    assert_eq!(layer_doc(&h.state().session, LayerId(lid)).unwrap().stroke_width, 0.5);
+}
diff --git a/crates/ui-egui/tests/it/ui_theme_favorites.rs b/crates/ui-egui/tests/it/ui_theme_favorites.rs
index 1b700f51f..424b28c49 100644
--- a/crates/ui-egui/tests/it/ui_theme_favorites.rs
+++ b/crates/ui-egui/tests/it/ui_theme_favorites.rs
@@ -1,3 +1,4 @@
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::{Session, config::MemoryConfig, prefs::Prefs};
 use effectcraft_ui_egui::{EffectcraftApp, menus};
 use egui::{Event, Modifiers, PointerButton, Pos2, pos2, vec2};
@@ -49,7 +50,7 @@ fn star_controls_save_and_favorite_menu_selects_the_family() {
     assert_eq!(h.state().session.prefs.appearance.favorite_themes, vec!["light"]);
     if let Some(path) = std::env::var_os("FAVORITES_SCREENSHOT_DIR") {
         std::fs::create_dir_all(&path).unwrap();
-        h.render().unwrap().save(std::path::Path::new(&path).join("effectcraft-favorites.png")).unwrap();
+        h.render_serialized().unwrap().save(std::path::Path::new(&path).join("effectcraft-favorites.png")).unwrap();
     }
     assert_eq!(h.state().session.prefs.appearance.appearance_mode, "dark");
     let p = at(&h, "settings.ok");
diff --git a/crates/ui-egui/tests/it/ui_timeline_audio_levels.rs b/crates/ui-egui/tests/it/ui_timeline_audio_levels.rs
new file mode 100644
index 000000000..bc0b9a7f9
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_timeline_audio_levels.rs
@@ -0,0 +1,166 @@
+//! Audio Levels' channel link in the Timeline (#2485): off by default; linked, an edit to one
+//! channel moves the other by the same dB, so the stereo balance stays, typed or scrubbed, on a
+//! static or animated property, and one Undo takes it back.
+
+use effectcraft_engine::Session;
+use effectcraft_engine::project::LayerId;
+use effectcraft_ui_egui::EffectcraftApp;
+use egui::{Event, Key, Modifiers, PointerButton, Pos2, pos2, vec2};
+use egui_kittest::Harness;
+use serde_json::json;
+
+fn center(h: &Harness<'_, EffectcraftApp>, id: &str) -> Pos2 {
+    let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}"));
+    pos2(e.rect[0] + e.rect[2] / 2.0, e.rect[1] + e.rect[3] / 2.0)
+}
+
+/// Press on `from`, move to `to` in `steps`, release there.
+fn drag(h: &mut Harness<'_, EffectcraftApp>, from: Pos2, to: Pos2, steps: u32) {
+    h.input_mut().events.push(Event::PointerMoved(from));
+    h.step();
+    h.input_mut().events.push(Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+    h.step();
+    for k in 1..=steps {
+        h.input_mut().events.push(Event::PointerMoved(from + (to - from) * (k as f32 / steps as f32)));
+        h.step();
+    }
+    h.input_mut().events.push(Event::PointerButton { pos: to, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+    h.run_steps(3);
+}
+
+fn click(h: &mut Harness<'_, EffectcraftApp>, id: &str) {
+    let p = center(h, id);
+    drag(h, p, p, 1);
+}
+
+fn type_value(h: &mut Harness<'_, EffectcraftApp>, id: &str, v: &str) {
+    click(h, id);
+    h.input_mut().events.push(Event::Text(v.into()));
+    h.step();
+    h.input_mut().events.push(Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
+    h.run_steps(3);
+}
+
+/// A precomp layer (which has Audio Levels) in comp Main at `levels`; its layer id and the
+/// property's uid.
+fn add_sound_layer(s: &mut Session, levels: [f64; 2]) -> (u64, u64) {
+    let l = s.execute("layer.addItem", json!({"item": "Sound"})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": l, "path": "audio/levels", "value": levels})).unwrap();
+    (l, s.active_comp().unwrap().layer(LayerId(l)).unwrap().props.prop("audio/levels").unwrap().uid)
+}
+
+/// Comps Sound and Main.
+fn comps(s: &mut Session) {
+    s.execute("comp.new", json!({"name": "Sound", "width": 64, "height": 36, "duration": 4})).unwrap();
+    s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "duration": 4})).unwrap();
+}
+
+/// Twirl layer `l` open to its property `uid`.
+fn reveal(h: &mut Harness<'_, EffectcraftApp>, l: u64, uid: u64) {
+    h.state_mut().ui.timeline.open_layers.insert(l);
+    h.state_mut().ui.timeline.layer_reveal.insert(l, vec!["props".into()]);
+    h.state_mut().ui.timeline.reveal_props.insert(uid);
+    h.run_steps(3);
+}
+
+fn levels_of(h: &Harness<'_, EffectcraftApp>, l: u64) -> Vec<f64> {
+    h.state().session.active_comp().unwrap().layer(LayerId(l)).unwrap().props.prop("audio/levels").unwrap().value.components()
+}
+
+#[test]
+fn linked_audio_levels_move_both_channels_by_the_same_db() {
+    let mut s = Session::default();
+    comps(&mut s);
+    let (l, uid) = add_sound_layer(&mut s, [-6.0, -12.0]);
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
+    reveal(&mut h, l, uid);
+    let levels =
+        |h: &Harness<'_, EffectcraftApp>| h.state().session.active_comp().unwrap().layer(LayerId(l)).unwrap().props.prop("audio/levels").unwrap().clone();
+    let set = |h: &mut Harness<'_, EffectcraftApp>, v: [f64; 2]| {
+        h.state_mut().session.execute("prop.set", json!({"layer": l, "path": "audio/levels", "value": v})).unwrap();
+        h.run_steps(2);
+    };
+    let undo = |h: &mut Harness<'_, EffectcraftApp>| {
+        h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+        h.run_steps(2);
+    };
+    let (left, right, link) = (format!("timeline.prop.{uid}.value.0"), format!("timeline.prop.{uid}.value.1"), format!("timeline.prop.{uid}.link"));
+    assert_eq!(h.state().auto.find(&link).unwrap().label, "Link Channels");
+
+    type_value(&mut h, &left, "-3");
+    assert_eq!(levels(&h).value.components(), vec![-3.0, -12.0], "unlinked by default, one channel moves alone");
+    set(&mut h, [-6.0, -12.0]);
+
+    click(&mut h, &link);
+    type_value(&mut h, &left, "-3");
+    assert_eq!(levels(&h).value.components(), vec![-3.0, -9.0], "linked, both rise 3 dB and keep their 6 dB balance");
+    undo(&mut h);
+    assert_eq!(levels(&h).value.components(), vec![-6.0, -12.0], "one Undo takes back both channels");
+
+    type_value(&mut h, &right, "0");
+    assert_eq!(levels(&h).value.components(), vec![6.0, 0.0], "the right channel leads just the same");
+    set(&mut h, [0.0, 0.0]);
+    type_value(&mut h, &left, "-6");
+    assert_eq!(levels(&h).value.components(), vec![-6.0, -6.0], "equal channels at 0 dB stay equal");
+
+    set(&mut h, [-6.0, -12.0]);
+    let from = center(&h, &left);
+    drag(&mut h, from, from + vec2(30.0, 0.0), 6);
+    let c = levels(&h).value.components();
+    assert!(c[0] > -6.0, "the scrub raised the left channel: {c:?}");
+    assert!((c[0] - c[1] - 6.0).abs() < 1e-9, "a linked scrub keeps the balance: {c:?}");
+    undo(&mut h);
+    assert_eq!(levels(&h).value.components(), vec![-6.0, -12.0], "one Undo takes back the whole scrub");
+
+    // Animated: the edit at the current time changes that key's two channels together.
+    h.state_mut().session.execute("prop.addKey", json!({"layer": l, "path": "audio/levels", "time": 0.0, "value": [-6.0, -12.0]})).unwrap();
+    h.state_mut().session.execute("prop.addKey", json!({"layer": l, "path": "audio/levels", "time": 1.0, "value": [0.0, 0.0]})).unwrap();
+    h.run_steps(2);
+    type_value(&mut h, &left, "-10");
+    let keys: Vec<Vec<f64>> = levels(&h).keys.iter().map(|k| k.value.components()).collect();
+    assert_eq!(keys, vec![vec![-10.0, -16.0], vec![0.0, 0.0]], "the key at the current time moves both channels");
+
+    click(&mut h, &link);
+    type_value(&mut h, &left, "-4");
+    let keys: Vec<Vec<f64>> = levels(&h).keys.iter().map(|k| k.value.components()).collect();
+    assert_eq!(keys[0], vec![-4.0, -16.0], "unlinked again, the right channel stays");
+}
+
+/// With several layers selected, a linked typed Left sets each layer's Left and moves its Right
+/// by that layer's own change: every layer keeps its own balance.
+#[test]
+fn linked_typing_keeps_each_selected_layers_own_balance() {
+    let mut s = Session::default();
+    comps(&mut s);
+    let (a, uid) = add_sound_layer(&mut s, [-6.0, -12.0]);
+    let (b, other) = add_sound_layer(&mut s, [-20.0, -30.0]);
+    s.execute("layer.select", json!({"layers": [a, b]})).unwrap();
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
+    reveal(&mut h, a, uid);
+    reveal(&mut h, b, other);
+    click(&mut h, &format!("timeline.prop.{uid}.link"));
+    type_value(&mut h, &format!("timeline.prop.{uid}.value.0"), "-3");
+    assert_eq!(levels_of(&h, a), vec![-3.0, -9.0]);
+    assert_eq!(levels_of(&h, b), vec![-3.0, -13.0], "B rises 17 dB on both channels, keeping its 10 dB balance");
+}
+
+/// A link turned on does not carry into a new project whose Audio Levels reuse the property uid.
+#[test]
+fn a_new_project_starts_with_its_audio_levels_unlinked() {
+    let mut s = Session::default();
+    comps(&mut s);
+    let (l, uid) = add_sound_layer(&mut s, [0.0, 0.0]);
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
+    reveal(&mut h, l, uid);
+    click(&mut h, &format!("timeline.prop.{uid}.link"));
+    assert!(h.state().ui.timeline.is_linked(uid, false));
+
+    h.state_mut().session.execute("file.newProject", json!({})).unwrap();
+    comps(&mut h.state_mut().session);
+    let (l, again) = add_sound_layer(&mut h.state_mut().session, [0.0, 0.0]);
+    assert_eq!(again, uid, "the new project reuses the property uid");
+    reveal(&mut h, l, again);
+    assert!(!h.state().ui.timeline.is_linked(again, false), "the new project's levels start unlinked");
+    type_value(&mut h, &format!("timeline.prop.{again}.value.0"), "-3");
+    assert_eq!(levels_of(&h, l), vec![-3.0, 0.0]);
+}
diff --git a/crates/ui-egui/tests/it/ui_timeline_group_select.rs b/crates/ui-egui/tests/it/ui_timeline_group_select.rs
new file mode 100644
index 000000000..0a553976b
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_timeline_group_select.rs
@@ -0,0 +1,83 @@
+//! Shift-clicking a group row in the Timeline adds it to the selection, as on a property row, so
+//! several Puppet pins can be selected and deleted together (#1751).
+
+use effectcraft_engine::Session;
+use effectcraft_engine::project::{LayerId, PropGroup};
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use egui::{Modifiers, Pos2, vec2};
+use egui_kittest::Harness;
+use serde_json::json;
+
+fn harness() -> (Harness<'static, EffectcraftApp>, u64, [u64; 3]) {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "Main", "width": 200, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
+    let layer = s.execute("layer.newSolid", json!({"width": 100, "height": 60, "color": [0, 0, 1]})).unwrap()["layer"].as_u64().unwrap();
+    let pin = |s: &mut Session, x: i64| s.execute("puppet.addPin", json!({"layer": layer, "position": [x, 30]})).unwrap()["pin"].as_u64().unwrap();
+    let pins = [pin(&mut s, 10), pin(&mut s, 50), pin(&mut s, 90)];
+    let mut app = EffectcraftApp::new(s);
+    app.show_panel(PanelKind::Timeline);
+    app.ui.timeline.open_layers.insert(layer);
+    // Twirl open every group down to the pins.
+    fn all(g: &PropGroup, out: &mut Vec<u64>) {
+        for c in g.groups() {
+            out.push(c.uid);
+            all(c, out);
+        }
+    }
+    let mut open = vec![];
+    if let Some(l) = app.session.active_comp().and_then(|c| c.layer(LayerId(layer))) {
+        all(&l.props, &mut open);
+    }
+    app.ui.timeline.open_groups.extend(open);
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1100.0)).build_eframe(|_| app);
+    h.run_steps(4);
+    (h, layer, pins)
+}
+
+fn row(h: &Harness<'_, EffectcraftApp>, uid: u64) -> Pos2 {
+    let id = format!("timeline.group.{uid}.name");
+    let e = h.state().auto.find(&id).unwrap_or_else(|| panic!("no {id}"));
+    egui::pos2(e.rect[0] + e.rect[2].min(40.0) / 2.0, e.rect[1] + e.rect[3] / 2.0)
+}
+
+fn click(h: &mut Harness<'_, EffectcraftApp>, uid: u64, modifiers: Modifiers) {
+    let at = row(h, uid);
+    h.input_mut().events.push(egui::Event::ModifiersChanged(modifiers));
+    h.input_mut().events.push(egui::Event::PointerMoved(at));
+    h.input_mut().events.push(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: true, modifiers });
+    h.input_mut().events.push(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers });
+    h.run_steps(3);
+    h.input_mut().events.push(egui::Event::ModifiersChanged(Modifiers::NONE));
+    h.step();
+}
+
+fn selected(h: &Harness<'_, EffectcraftApp>, pins: [u64; 3]) -> Vec<u64> {
+    h.state().session.state.selected_props.iter().map(|(_, u)| *u).filter(|u| pins.contains(u)).collect()
+}
+
+fn pin_count(h: &Harness<'_, EffectcraftApp>, layer: u64) -> usize {
+    let l = h.state().session.active_comp().unwrap().layer(LayerId(layer)).unwrap();
+    l.effects().unwrap().groups().map(effectcraft_engine::effects::puppet::pin_count).sum()
+}
+
+#[test]
+fn shift_click_adds_puppet_pins_and_delete_removes_them_together() {
+    let (mut h, layer, pins) = harness();
+    let [a, b, c] = pins;
+    click(&mut h, a, Modifiers::NONE);
+    assert_eq!(selected(&h, pins), [a]);
+    click(&mut h, b, Modifiers::SHIFT);
+    assert_eq!(selected(&h, pins), [a, b], "Shift-click keeps the first pin");
+    click(&mut h, c, Modifiers::NONE);
+    assert_eq!(selected(&h, pins), [c], "a plain click selects only the clicked pin");
+
+    click(&mut h, a, Modifiers::NONE);
+    click(&mut h, b, Modifiers::SHIFT);
+    h.state_mut().session.execute("edit.clear", json!({})).unwrap();
+    h.run_steps(3);
+    assert_eq!(pin_count(&h, layer), 1, "Delete removes both selected pins");
+    assert!(h.state().session.active_comp().unwrap().layer(LayerId(layer)).is_some(), "the layer stays");
+    h.state_mut().session.undo();
+    assert_eq!(pin_count(&h, layer), 3, "one Undo restores both pins");
+}
diff --git a/crates/ui-egui/tests/it/ui_timeline_shapes.rs b/crates/ui-egui/tests/it/ui_timeline_shapes.rs
index bc42b4461..c98b4af19 100644
--- a/crates/ui-egui/tests/it/ui_timeline_shapes.rs
+++ b/crates/ui-egui/tests/it/ui_timeline_shapes.rs
@@ -1,7 +1,8 @@
 //! Timeline rows for shape layers, masks and keyframing: the Contents "Add:" menu and the Classic
 //! 3D "Change Renderer…" row (#206), Alt+Shift+P revealing the key it adds and clicks below the
-//! layers deselecting them (#205), Mask Feather's linked values (#203), and copying shape items
-//! between shape layers (#227), and Ctrl+V of SVG markup making a shape layer (#738).
+//! layers deselecting them (#205), Mask Feather's linked values (#203) and shape Size's chain link
+//! (#2489), copying shape items between shape layers (#227), and Ctrl+V of SVG markup making a shape
+//! layer (#738).
 
 use effectcraft_engine::Session;
 use effectcraft_engine::project::LayerId;
@@ -75,6 +76,22 @@ fn shape_contents_add_menu_adds_path_operations() {
     assert_eq!(items, ["group", "trim"]);
 }
 
+#[test]
+fn shape_contents_add_menu_adds_wiggle_transform() {
+    let mut s = session();
+    let l = s.execute("layer.newShape", json!({"kind": "ellipse"})).unwrap()["layer"].as_u64().unwrap();
+    let contents = s.active_comp().unwrap().layer(LayerId(l)).unwrap().props.sub("contents").unwrap().uid;
+    let mut h = harness(s);
+    open_layer(&mut h, l);
+    click(&mut h, &format!("timeline.group.{contents}.add"));
+    assert!(h.get_by_label("Zig Zag").rect().max.y <= 1000.0, "the whole menu fits in the window");
+    let entry = h.get_by_label("Wiggle Transform").rect();
+    click_at(&mut h, entry.center());
+    let layer = h.state().session.active_comp().unwrap().layer(LayerId(l)).unwrap().clone();
+    let items: Vec<&str> = layer.props.sub("contents").unwrap().groups().map(|g| g.match_id.as_str()).collect();
+    assert_eq!(items, ["group", "wiggler"]);
+}
+
 /// A shape group's inner Contents is elided in After Effects: opening the group lists its items
 /// (here the path) directly, with no "Contents" row between them.
 #[test]
@@ -172,6 +189,52 @@ fn mask_feather_values_are_linked_and_not_negative() {
     assert_eq!(feather(&h).1, vec![0.0, 7.0], "unlinked");
 }
 
+/// #2489: Rectangle and Ellipse Path Size get the Constrain Proportions chain, off by default:
+/// unlinked, W moves alone; linked, H follows W in proportion. Scale on the same layer still starts
+/// linked.
+#[test]
+fn shape_size_chain_starts_unlinked_and_keeps_the_ratio_when_linked() {
+    let mut s = session();
+    let l = s.execute("layer.newShape", json!({"kind": "rect", "size": [100, 50]})).unwrap()["layer"].as_u64().unwrap();
+    let o = s.execute("layer.newShape", json!({"kind": "ellipse", "size": [60, 30]})).unwrap()["layer"].as_u64().unwrap();
+    let uid = |s: &Session, l: u64, path: &str| s.active_comp().unwrap().layer(LayerId(l)).unwrap().props.prop(path).unwrap().uid;
+    let (size, oval, scale) =
+        (uid(&s, l, "contents/group/contents/rect/size"), uid(&s, o, "contents/group/contents/ellipse/size"), uid(&s, l, "transform/scale"));
+    let mut h = harness(s);
+    for (layer, props) in [(l, vec![size, scale]), (o, vec![oval])] {
+        h.state_mut().ui.timeline.open_layers.insert(layer);
+        h.state_mut().ui.timeline.layer_reveal.insert(layer, vec!["props".into()]);
+        h.state_mut().ui.timeline.reveal_props.extend(props);
+    }
+    h.run_steps(2);
+    let value = |h: &Harness<'_, EffectcraftApp>, l: u64, uid: u64| {
+        h.state().session.active_comp().unwrap().layer(LayerId(l)).unwrap().props.prop(&format!("@{uid}")).unwrap().value.components()
+    };
+    let type_value = |h: &mut Harness<'_, EffectcraftApp>, uid: u64, d: usize, v: &str| {
+        click(h, &format!("timeline.prop.{uid}.value.{d}"));
+        h.input_mut().events.push(Event::Text(v.into()));
+        h.step();
+        h.input_mut().events.push(Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
+        h.run_steps(3);
+    };
+    type_value(&mut h, size, 0, "80");
+    assert_eq!(value(&h, l, size), vec![80.0, 50.0], "a new rectangle's Size starts unlinked");
+    type_value(&mut h, oval, 1, "40");
+    assert_eq!(value(&h, o, oval), vec![60.0, 40.0], "a new ellipse's Size starts unlinked");
+    click(&mut h, &format!("timeline.prop.{size}.link"));
+    type_value(&mut h, size, 0, "160");
+    assert_eq!(value(&h, l, size), vec![160.0, 100.0], "linked, H follows W in proportion");
+    click(&mut h, &format!("timeline.prop.{size}.link"));
+    type_value(&mut h, size, 0, "40");
+    assert_eq!(value(&h, l, size), vec![40.0, 100.0], "unlinked again, H stays");
+    // The ellipse's Size links the same way: 60x40 linked, W to 90 makes H 60.
+    click(&mut h, &format!("timeline.prop.{oval}.link"));
+    type_value(&mut h, oval, 0, "90");
+    assert_eq!(value(&h, o, oval), vec![90.0, 60.0], "linked, the ellipse keeps its ratio too");
+    type_value(&mut h, scale, 0, "50");
+    assert_eq!(value(&h, l, scale)[..2], [50.0, 50.0], "Scale still starts linked");
+}
+
 /// Two shape layers, "Rect" (Rectangle 1) and "Oval" (Ellipse 1, selected): (harness with Rect's
 /// Contents open, Rect, Oval, Rectangle 1's uid).
 fn two_shape_layers() -> (Harness<'static, EffectcraftApp>, u64, u64, u64) {
@@ -190,6 +253,33 @@ fn contents_names(h: &Harness<'_, EffectcraftApp>, l: u64) -> Vec<String> {
     h.state().session.active_comp().unwrap().layer(LayerId(l)).unwrap().props.sub("contents").unwrap().groups().map(|g| g.name.clone()).collect()
 }
 
+/// #959: every item in a shape layer's Contents has an eye switch, as in After Effects; it turns
+/// the item off (the renderer skips it), undoably. The group's Transform has none.
+#[test]
+fn shape_contents_items_have_eye_switches() {
+    let (mut h, a, _, rect) = two_shape_layers();
+    let enabled = |h: &Harness<'_, EffectcraftApp>| {
+        h.state().session.active_comp().unwrap().layer(LayerId(a)).unwrap().props.sub("contents").unwrap().find_group(rect).unwrap().enabled
+    };
+    let eye = format!("timeline.group.{rect}.eye");
+    assert!(enabled(&h));
+    click(&mut h, &eye);
+    assert!(!enabled(&h), "the eye turns Rectangle 1 off");
+    click(&mut h, &eye);
+    assert!(enabled(&h), "and on again");
+    click(&mut h, &eye);
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    assert!(enabled(&h), "one undo step");
+    // Inside the group: its path and fill have eyes, its Transform doesn't.
+    h.state_mut().ui.timeline.open_groups.insert(rect);
+    h.run_steps(3);
+    let group = h.state().session.active_comp().unwrap().layer(LayerId(a)).unwrap().props.find_group(rect).unwrap().clone();
+    let transform = group.sub("transform").expect("a shape group has a Transform").uid;
+    assert!(h.state().auto.find(&format!("timeline.group.{transform}.eye")).is_none(), "no eye on Transform");
+    let items = group.sub("contents").expect("the group's items").groups().map(|g| g.uid).collect::<Vec<_>>();
+    assert!(!items.is_empty() && items.iter().all(|u| h.state().auto.find(&format!("timeline.group.{u}.eye")).is_some()), "every item has an eye");
+}
+
 #[test]
 fn ctrl_c_and_ctrl_v_copy_a_shape_group_into_another_shape_layer() {
     let (mut h, a, b, rect) = two_shape_layers();
@@ -250,6 +340,11 @@ fn timeline_colour_eyedropper_samples_the_comp() {
     let fill = fill.expect("a fill colour");
     fn groups(g: &effectcraft_engine::project::PropGroup, out: &mut Vec<u64>) {
         for c in g.groups() {
+            // The rectangle's path rows would push Fill below the rows the Timeline fits; the
+            // eyedropper only needs Fill, so leave that group collapsed.
+            if c.name == "Rectangle Path 1" {
+                continue;
+            }
             out.push(c.uid);
             groups(c, out);
         }
@@ -306,3 +401,128 @@ fn ctrl_v_pastes_svg_markup_as_a_shape_layer() {
     assert_eq!(c.layers.len(), 4);
     assert_eq!(c.layers[0].name, "Oval 2");
 }
+
+fn drag(h: &mut Harness<'_, EffectcraftApp>, from: Pos2, to: Pos2, cancel: bool) {
+    h.input_mut().events.push(Event::PointerMoved(from));
+    h.step();
+    h.input_mut().events.push(Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE });
+    h.step();
+    for k in 1..=8 {
+        h.input_mut().events.push(Event::PointerMoved(from + (to - from) * (k as f32 / 8.0)));
+        h.step();
+    }
+    if cancel {
+        h.input_mut().events.push(Event::Key { key: Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE });
+        h.step();
+    }
+    h.input_mut().events.push(Event::PointerButton { pos: to, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE });
+    h.run_steps(3);
+}
+
+/// #2210: an effect's row drags to a new place in the layer's effect stack, as in After Effects
+/// (not a marquee); Escape cancels the drag.
+#[test]
+fn effects_drag_to_a_new_place_in_the_timeline() {
+    let mut s = session();
+    let l = s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080"})).unwrap()["layer"].as_u64().unwrap();
+    for fx in ["Gaussian Blur", "Invert", "Tint"] {
+        s.execute("effect.apply", json!({"layers": [l], "effect": fx})).unwrap();
+    }
+    let effects = s.active_comp().unwrap().layer(LayerId(l)).unwrap().props.sub("effects").unwrap().clone();
+    let uids: Vec<u64> = effects.groups().map(|g| g.uid).collect();
+    let mut h = harness(s);
+    h.state_mut().ui.timeline.open_groups.insert(effects.uid);
+    open_layer(&mut h, l);
+    let names = |h: &Harness<'_, EffectcraftApp>| -> Vec<String> {
+        h.state().session.active_comp().unwrap().layer(LayerId(l)).unwrap().props.sub("effects").unwrap().groups().map(|g| g.name.clone()).collect()
+    };
+    let row = |h: &Harness<'_, EffectcraftApp>, uid: u64| {
+        let e = h.state().auto.find(&format!("timeline.group.{uid}.name")).unwrap_or_else(|| panic!("no row for {uid}"));
+        egui::Rect::from_min_size(pos2(e.rect[0], e.rect[1]), egui::vec2(e.rect[2], e.rect[3]))
+    };
+    // Tint above Gaussian Blur.
+    let (tint, blur) = (row(&h, uids[2]), row(&h, uids[0]));
+    drag(&mut h, tint.center(), pos2(blur.center().x, blur.min.y + 2.0), true);
+    assert_eq!(names(&h), ["Gaussian Blur", "Invert", "Tint"], "Escape cancels");
+    drag(&mut h, tint.center(), pos2(blur.center().x, blur.min.y + 2.0), false);
+    assert_eq!(names(&h), ["Tint", "Gaussian Blur", "Invert"]);
+    // Gaussian Blur (now second) below Invert, the last.
+    let (blur, invert) = (row(&h, uids[0]), row(&h, uids[1]));
+    drag(&mut h, blur.center(), pos2(invert.center().x, invert.max.y - 2.0), false);
+    assert_eq!(names(&h), ["Tint", "Invert", "Gaussian Blur"]);
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(names(&h), ["Tint", "Gaussian Blur", "Invert"], "one undo step per drop");
+}
+
+/// #2552: Shift-clicking effect rows in the Timeline adds them to the selection (and a second
+/// Shift-click takes one out), so one animation preset can hold several effects.
+#[test]
+fn shift_click_selects_several_effects_for_a_preset() {
+    let mut s = session();
+    let l = s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080"})).unwrap()["layer"].as_u64().unwrap();
+    for fx in ["Gaussian Blur", "Invert"] {
+        s.execute("effect.apply", json!({"layers": [l], "effect": fx})).unwrap();
+    }
+    let effects = s.active_comp().unwrap().layer(LayerId(l)).unwrap().props.sub("effects").unwrap().clone();
+    let uids: Vec<u64> = effects.groups().map(|g| g.uid).collect();
+    let mut h = harness(s);
+    h.state_mut().ui.timeline.open_groups.insert(effects.uid);
+    open_layer(&mut h, l);
+    let shift_click = |h: &mut Harness<'_, EffectcraftApp>, uid: u64| {
+        let p = center(h, &format!("timeline.group.{uid}.name"));
+        h.input_mut().events.push(Event::ModifiersChanged(Modifiers::SHIFT));
+        h.input_mut().events.push(Event::PointerMoved(p));
+        h.step();
+        for pressed in [true, false] {
+            h.input_mut().events.push(Event::PointerButton { pos: p, button: PointerButton::Primary, pressed, modifiers: Modifiers::SHIFT });
+            h.step();
+        }
+        h.input_mut().events.push(Event::ModifiersChanged(Modifiers::NONE));
+        h.run_steps(2);
+    };
+    let selected = |h: &Harness<'_, EffectcraftApp>| h.state().session.state.selected_props.iter().map(|(_, u)| *u).collect::<Vec<_>>();
+    click(&mut h, &format!("timeline.group.{}.name", uids[0]));
+    assert_eq!(selected(&h), [uids[0]]);
+    shift_click(&mut h, uids[1]);
+    assert_eq!(selected(&h), [uids[0], uids[1]], "Shift adds the second effect");
+    let path = std::env::temp_dir().join(format!("ec-2552-{}.ffx", std::process::id()));
+    let r = h.state_mut().session.execute("anim.savePreset", json!({"path": path.to_string_lossy()})).unwrap();
+    assert_eq!(r["effects"], 2, "{r}");
+    let _ = std::fs::remove_file(&path);
+    shift_click(&mut h, uids[1]);
+    assert_eq!(selected(&h), [uids[0]], "a second Shift-click takes it out");
+}
+
+/// #2513: the Text group's Animate menu adds Animator 1 with the chosen property (and a Range
+/// Selector), and the animator's Add menu adds another property to it.
+#[test]
+fn text_animate_menu_adds_an_animator_with_the_property() {
+    let mut s = session();
+    let l = s.execute("layer.newText", json!({"text": "Hello"})).unwrap()["layer"].as_u64().unwrap();
+    let text = s.active_comp().unwrap().layer(LayerId(l)).unwrap().props.sub("text").unwrap().uid;
+    let mut h = harness(s);
+    h.state_mut().ui.timeline.open_groups.insert(text);
+    open_layer(&mut h, l);
+    // The Properties panel's Position row has the same accessible name: take the menu's new entry.
+    let shown: Vec<_> = h.query_all_by_label("Position").map(|n| n.rect()).collect();
+    click(&mut h, &format!("timeline.group.{text}.animate"));
+    let entry = h.query_all_by_label("Position").map(|n| n.rect()).find(|r| !shown.contains(r)).expect("the Animate menu's Position entry");
+    click_at(&mut h, entry.center());
+    let animators = |h: &Harness<'_, EffectcraftApp>| {
+        h.state().session.active_comp().unwrap().layer(LayerId(l)).unwrap().props.sub("text").unwrap().sub("animators").cloned()
+    };
+    let anims = animators(&h).expect("an Animators group");
+    let a = anims.groups().next().expect("Animator 1");
+    let has = |a: &effectcraft_engine::project::PropGroup, m: &str| a.sub("properties").is_some_and(|p| p.children.iter().any(|c| c.match_id() == m));
+    assert!(has(a, "position"), "Position was added: {:?}", a.sub("properties"));
+    assert!(a.sub("selectors").is_some_and(|s| !s.children.is_empty()), "with a Range Selector");
+    // The animator's Add menu adds a property to it.
+    h.state_mut().ui.timeline.open_groups.insert(anims.uid);
+    h.state_mut().ui.timeline.open_groups.insert(a.uid);
+    h.run_steps(2);
+    click(&mut h, &format!("timeline.group.{}.add", a.uid));
+    let entry = h.get_by_label("Property: Opacity").rect();
+    click_at(&mut h, entry.center());
+    let a = animators(&h).unwrap().groups().next().unwrap().clone();
+    assert!(has(&a, "opacity"), "Opacity was added: {:?}", a.sub("properties"));
+}
diff --git a/crates/ui-egui/tests/it/ui_unreadable_footage.rs b/crates/ui-egui/tests/it/ui_unreadable_footage.rs
index 9b48b9531..a62884f43 100644
--- a/crates/ui-egui/tests/it/ui_unreadable_footage.rs
+++ b/crates/ui-egui/tests/it/ui_unreadable_footage.rs
@@ -1,10 +1,11 @@
-//! Footage whose codec the decoders lack says so: a warning marker in the Project panel and a
-//! notice on the layer in the Composition viewer, instead of a black picture with no reason.
+//! Footage (or the proxy in use for it) whose codec the decoders lack says so: a warning marker in
+//! the Project panel and a notice on the layer in the Composition viewer, instead of a black
+//! picture with no reason.
 
 use std::sync::Arc;
 
 use effectcraft_engine::Session;
-use effectcraft_engine::project::{Footage, FootageKind, ItemId, ItemKind};
+use effectcraft_engine::project::{Footage, FootageKind, ItemId, ItemKind, Proxy};
 use effectcraft_engine::render::FootageSource;
 use effectcraft_render::Image;
 use effectcraft_time::Tick;
@@ -14,19 +15,19 @@ use serde_json::json;
 
 const WHY: &str = "H.264 (High 4:2:2) isn't supported by the built-in decoder: chroma_format_idc 2 (only 4:2:0 is implemented)";
 
-/// A source that decodes nothing and, for `broken` movies, says why.
-struct Stub(bool);
+/// A source that decodes nothing and says why for the files `broken` picks.
+struct Stub(fn(&Footage) -> bool);
 
 impl FootageSource for Stub {
     fn frame(&self, _: ItemId, _: &Footage, _: Tick) -> Option<Arc<Image>> {
         None
     }
-    fn problem(&self, _: &Footage) -> Option<String> {
-        self.0.then(|| WHY.to_string())
+    fn problem(&self, f: &Footage) -> Option<String> {
+        (self.0)(f).then(|| WHY.to_string())
     }
 }
 
-fn harness(broken: bool) -> (Harness<'static, EffectcraftApp>, ItemId) {
+fn harness(broken: fn(&Footage) -> bool, proxy: Option<Footage>) -> (Harness<'static, EffectcraftApp>, ItemId) {
     let mut s = Session { footage: Arc::new(Stub(broken)), ..Default::default() };
     s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "duration": 4})).unwrap();
     let footage = Footage {
@@ -38,17 +39,25 @@ fn harness(broken: bool) -> (Harness<'static, EffectcraftApp>, ItemId) {
         duration: Tick::from_seconds_f64(2.0),
         ..Default::default()
     };
-    let clip = std::sync::Arc::make_mut(&mut s.project).add_item("Clip", Default::default(), None, ItemKind::Footage(footage));
+    let p = std::sync::Arc::make_mut(&mut s.project);
+    let clip = p.add_item("Clip", Default::default(), None, ItemKind::Footage(footage));
+    if let (Some(item), Some(footage)) = (p.items.get_mut(&clip), proxy) {
+        item.proxy = Some(Box::new(Proxy { footage, enabled: true }));
+    }
     s.execute("layer.addItem", json!({"item": clip.0})).unwrap();
+    (open(s), clip)
+}
+
+fn open(mut s: Session) -> Harness<'static, EffectcraftApp> {
     s.execute("project.select", json!({"items": []})).unwrap();
     let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
     h.run_steps(4);
-    (h, clip)
+    h
 }
 
 #[test]
 fn undecodable_footage_is_marked_in_the_project_panel_and_the_viewer() {
-    let (h, clip) = harness(true);
+    let (h, clip) = harness(|_| true, None);
     let marker = h.state().auto.find(&format!("project.item.{}.problem", clip.0)).expect("a warning on the footage item").clone();
     assert!(marker.label.contains("4:2:2"), "{marker:?}");
     let notice = h.state().auto.query("viewer.footageProblem.").first().copied().expect("a notice in the viewer").clone();
@@ -57,7 +66,39 @@ fn undecodable_footage_is_marked_in_the_project_panel_and_the_viewer() {
 
 #[test]
 fn readable_footage_has_no_notice() {
-    let (h, clip) = harness(false);
+    let (h, clip) = harness(|_| false, None);
     assert!(h.state().auto.find(&format!("project.item.{}.problem", clip.0)).is_none());
     assert!(h.state().auto.query("viewer.footageProblem.").is_empty());
 }
+
+/// The clip's own file is fine, but the proxy in use for it can't be decoded: the item and the
+/// layer say why, and that it is the proxy.
+#[test]
+fn an_undecodable_proxy_in_use_is_marked_as_the_proxy() {
+    let proxy = Footage { kind: FootageKind::Video, path: "clip_proxy.avi".into(), width: 32, height: 18, has_video: true, ..Default::default() };
+    let (h, clip) = harness(|f| f.path.ends_with(".avi"), Some(proxy));
+    let marker = h.state().auto.find(&format!("project.item.{}.problem", clip.0)).expect("a warning on the footage item").clone();
+    assert!(marker.label.starts_with("Proxy: ") && marker.label.contains("4:2:2"), "{marker:?}");
+    let notice = h.state().auto.query("viewer.footageProblem.").first().copied().expect("a notice in the viewer").clone();
+    assert!(notice.label.contains(&format!("Proxy: {WHY}")), "{notice:?}");
+}
+
+/// A precomp whose proxy can't be decoded: the layer says so with Collapse Transformations off
+/// or on, since a proxy in use keeps the precomp on the flattened path that draws the proxy.
+#[test]
+fn a_precomp_with_an_undecodable_proxy_has_a_notice_collapsed_or_not() {
+    for collapse in [false, true] {
+        let mut s = Session { footage: Arc::new(Stub(|f| f.path.ends_with(".avi"))), ..Default::default() };
+        s.execute("comp.new", json!({"name": "Inner", "width": 64, "height": 36, "duration": 4})).unwrap();
+        s.execute("comp.new", json!({"name": "Main", "width": 320, "height": 180, "duration": 4})).unwrap();
+        let p = Arc::make_mut(&mut s.project);
+        let inner = p.items.values_mut().find(|i| i.name == "Inner").unwrap();
+        let proxy = Footage { kind: FootageKind::Video, path: "inner_proxy.avi".into(), width: 64, height: 36, has_video: true, ..Default::default() };
+        inner.proxy = Some(Box::new(Proxy { footage: proxy, enabled: true }));
+        let inner = inner.id;
+        s.execute("layer.addItem", json!({"item": inner.0})).unwrap();
+        s.execute("layer.setSwitch", json!({"layers": ["#1"], "switch": "collapse", "value": collapse})).unwrap();
+        let h = open(s);
+        assert!(!h.state().auto.query("viewer.footageProblem.").is_empty(), "collapse {collapse}");
+    }
+}
diff --git a/crates/ui-egui/tests/it/ui_viewer.rs b/crates/ui-egui/tests/it/ui_viewer.rs
index 993925b59..f0086d28a 100644
--- a/crates/ui-egui/tests/it/ui_viewer.rs
+++ b/crates/ui-egui/tests/it/ui_viewer.rs
@@ -2,6 +2,7 @@
 //! interest drawing, rulers and guides, snapping, the shape Pen and motion-path key drags
 //! (egui_kittest, UI logic only).
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_engine::commands::shape_tool::PaintKind;
 use effectcraft_engine::project::LayerId;
@@ -53,6 +54,65 @@ fn drag(h: &mut Harness<'_, EffectcraftApp>, from: Pos2, to: Pos2) {
     h.run_steps(2);
 }
 
+/// #1218: frame stepping is optional, and consumes the whole wheel gesture including its
+/// smoothed tail. Ctrl/Cmd+wheel still zooms.
+#[test]
+fn mouse_wheel_over_the_monitor_scrubs_frames() {
+    let mut h = harness();
+    h.state_mut().session.execute("prefs.set", json!({"key": "general.viewerWheelScrubbing", "value": true})).unwrap();
+    let p = rect(&h, "viewer.area").center();
+    h.input_mut().events.push(Event::PointerMoved(p));
+    h.step();
+    let t0 = h.state().session.time();
+    let line = |dy: f32, modifiers: egui::Modifiers| Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Line,
+        delta: vec2(0.0, dy),
+        modifiers,
+        phase: egui::TouchPhase::Move,
+        source: egui::MouseWheelSource::Wheel,
+    };
+    let z0 = h.state().ui.viewer.zoom;
+    h.input_mut().events.push(line(1.0, egui::Modifiers::NONE));
+    h.step();
+    let t1 = h.state().session.time();
+    for _ in 0..20 {
+        assert_eq!(h.state().ui.viewer.zoom, z0, "frame wheel must never zoom");
+        h.step();
+    }
+    assert!(t1 > t0, "wheel up advanced the playhead ({t0:?} -> {t1:?})");
+    h.input_mut().events.push(line(-2.0, egui::Modifiers::NONE));
+    h.step();
+    assert!(h.state().session.time() < t1, "two lines back moves before the single line forward");
+    let z0 = h.state().ui.viewer.zoom;
+    let t2 = h.state().session.time();
+    let mods = egui::Modifiers { ctrl: true, command: true, ..Default::default() };
+    h.input_mut().events.push(line(3.0, mods));
+    h.step();
+    assert_eq!(h.state().session.time(), t2, "Ctrl+wheel must not scrub");
+    assert_ne!(h.state().ui.viewer.zoom, z0, "Ctrl+wheel still zooms");
+}
+
+#[test]
+fn mouse_wheel_zooms_by_default_without_stepping_frames() {
+    let mut h = harness();
+    assert!(!h.state().session.prefs.general.viewer_wheel_scrubbing);
+    let p = rect(&h, "viewer.area").center();
+    h.input_mut().events.push(Event::PointerMoved(p));
+    h.step();
+    let t0 = h.state().session.time();
+    let z0 = h.state().ui.viewer.zoom;
+    h.input_mut().events.push(Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Line,
+        delta: vec2(0.0, 1.0),
+        modifiers: egui::Modifiers::NONE,
+        phase: egui::TouchPhase::Move,
+        source: egui::MouseWheelSource::Wheel,
+    });
+    h.run_steps(20);
+    assert_eq!(h.state().session.time(), t0);
+    assert_ne!(h.state().ui.viewer.zoom, z0);
+}
+
 /// Comp pixel → screen point.
 fn screen(h: &Harness<'_, EffectcraftApp>, p: [f32; 2]) -> Pos2 {
     let c = rect(h, "viewer.comp");
@@ -221,6 +281,7 @@ fn bottom_bar_in_after_effects_order() {
     let order = [
         "viewer.magnification",
         "viewer.resolution",
+        "viewer.fastPreviews",
         "viewer.transparency",
         "viewer.masks",
         "viewer.roi",
@@ -230,7 +291,6 @@ fn bottom_bar_in_after_effects_order() {
         "viewer.exposure",
         "viewer.snapshot",
         "viewer.showSnapshot",
-        "viewer.fastPreviews",
         "viewer.timecode",
     ];
     let xs: Vec<f32> = order.iter().map(|id| rect(&h, id).min.x).collect();
@@ -448,7 +508,7 @@ fn mid_drag(h: &mut Harness<'_, EffectcraftApp>, from: Pos2, to: Pos2, mods: egu
         h.input_mut().events.push(Event::PointerMoved(from + (to - from) * (i as f32 / 8.0)));
         h.step();
     }
-    h.render().expect("the mid-drag frame")
+    h.render_serialized().expect("the mid-drag frame")
 }
 
 /// Release the button where the drag left it.
@@ -482,14 +542,15 @@ fn fill_rgb(h: &Harness<'_, EffectcraftApp>) -> [u8; 3] {
 fn shape_drag_ghost_shows_the_tools_own_shape_while_dragging() {
     let (from, to) = ([140.0, 100.0], [400.0, 300.0]);
     let centre = [270.0, 200.0];
-    // 6 comp px inside the box's top-left corner: inside a rectangle, outside every other kind.
-    let corner = [146.0, 106.0];
+    // 4 comp px inside the box's top-left corner: inside a rectangle, outside every other kind
+    // (a rounded corner of 20 px arcs past this point).
+    let corner = [144.0, 104.0];
     for (tool, fills_corner) in [(Tool::Rectangle, true), (Tool::RoundedRect, false), (Tool::Ellipse, false), (Tool::Polygon, false), (Tool::Star, false)] {
         let mut h = harness();
         h.state_mut().ui.tool = tool;
         settle_viewer(&mut h);
         let (a, b) = (screen(&h, from), screen(&h, to));
-        let before = h.render().expect("the frame before the drag");
+        let before = h.render_serialized().expect("the frame before the drag");
         let mid = mid_drag(&mut h, a, b, egui::Modifiers::default());
         let fill = fill_rgb(&h);
 
@@ -525,7 +586,7 @@ fn shape_drag_ghost_normalises_the_same_way_as_the_release() {
         h.state_mut().ui.tool = Tool::Ellipse;
         settle_viewer(&mut h);
         let (a, b) = (screen(&h, from.map(|v| v as f32)), screen(&h, to.map(|v| v as f32)));
-        let before = h.render().expect("the frame before the drag");
+        let before = h.render_serialized().expect("the frame before the drag");
         // Measured with the button down, so this is the ghost and not the committed shape.
         let mid = mid_drag(&mut h, a, b, mods);
         let on = [centre[0] as f32 + size[0] as f32 / 4.0, centre[1] as f32 + size[1] as f32 / 4.0];
@@ -594,7 +655,7 @@ fn a_layer_drag_moves_the_picture_while_the_button_is_down() {
     h.input_mut().events.push(Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
     h.step();
     // Where the layer is not (yet): the plate behind it.
-    let plate = px_at(&h.render().unwrap(), &h, [440.0, 200.0]);
+    let plate = px_at(&h.render_serialized().unwrap(), &h, [440.0, 200.0]);
 
     // Drag in small steps, still holding the button, and give the renders a chance to land.
     let mut moved = false;
@@ -605,7 +666,7 @@ fn a_layer_drag_moves_the_picture_while_the_button_is_down() {
         std::thread::sleep(std::time::Duration::from_millis(15));
         // 30 comp px behind the pointer: inside the layer, well away from its outline, its anchor
         // icon and where it started.
-        let at = px_at(&h.render().expect("mid-drag frame"), &h, [320.0 + 200.0 * (i as f32 / 40.0) - 30.0, 200.0]);
+        let at = px_at(&h.render_serialized().expect("mid-drag frame"), &h, [320.0 + 200.0 * (i as f32 / 40.0) - 30.0, 200.0]);
         if i >= 30 && delta(at, plate) > 30 {
             moved = true;
             break;
@@ -802,6 +863,76 @@ fn hidden_shape_layer_keeps_its_controls_and_can_still_scale() {
     assert_ne!(scale(&h), before, "a hidden layer's handle still scales it");
 }
 
+/// #1964: Shift-dragging a selected mask vertex keeps it to the axis it moves along most, as a
+/// Shift-dragged layer does; without Shift it moves freely.
+#[test]
+fn shift_drag_keeps_a_mask_vertex_to_one_axis() {
+    let mut h = harness();
+    let plate = layer_id(&h, "Plate");
+    let corners = [[100.0, 60.0], [500.0, 60.0], [500.0, 300.0], [100.0, 300.0]];
+    let mask = {
+        let s = &mut h.state_mut().session;
+        s.execute("layer.select", json!({"layers": [plate]})).unwrap();
+        let m = s.execute("mask.new", json!({"layer": plate, "vertices": corners, "closed": true})).unwrap()["mask"].as_u64().unwrap();
+        s.execute("mask.selectVertices", json!({"vertices": [{"layer": plate, "mask": m, "index": 0}]})).unwrap();
+        m
+    };
+    h.run_steps(2);
+    let vertex = format!("viewer.mask.{mask}.vertex.0");
+    let before = mask_path(&h, "Plate").vertices[0];
+    let from = rect(&h, &vertex).center();
+    drag_path(&mut h, &[from, from + vec2(30.0, 8.0)], egui::Modifiers::SHIFT);
+    let shifted = mask_path(&h, "Plate").vertices[0];
+    assert!(shifted[0] > before[0], "it moved along x: {before:?} -> {shifted:?}");
+    assert_eq!(shifted[1], before[1], "and not along y");
+    let from = rect(&h, &vertex).center();
+    drag_path(&mut h, &[from, from + vec2(30.0, 8.0)], egui::Modifiers::NONE);
+    let free = mask_path(&h, "Plate").vertices[0];
+    assert!(free[0] > shifted[0] && free[1] > shifted[1], "without Shift both axes move: {shifted:?} -> {free:?}");
+}
+
+/// #999: a mask vertex dragged against the edge of the Composition panel pans the view, and the
+/// vertex keeps moving while the pointer is held there, as in After Effects.
+#[test]
+fn a_vertex_held_at_the_viewer_edge_pans_the_view() {
+    let mut h = harness();
+    let plate = layer_id(&h, "Plate");
+    let corners = [[100.0, 60.0], [500.0, 60.0], [500.0, 300.0], [100.0, 300.0]];
+    let mask = {
+        let s = &mut h.state_mut().session;
+        s.execute("layer.select", json!({"layers": [plate]})).unwrap();
+        let m = s.execute("mask.new", json!({"layer": plate, "vertices": corners, "closed": true})).unwrap()["mask"].as_u64().unwrap();
+        s.execute("mask.selectVertices", json!({"vertices": [{"layer": plate, "mask": m, "index": 0}]})).unwrap();
+        m
+    };
+    h.run_steps(2);
+    let pan0 = h.state().ui.viewer.pan;
+    let from = rect(&h, &format!("viewer.mask.{mask}.vertex.0")).center();
+    let edge = pos2(2.0, from.y);
+    h.input_mut().events.push(Event::PointerMoved(from));
+    h.input_mut().events.push(Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
+    h.step();
+    for i in 1..=6 {
+        h.input_mut().events.push(Event::PointerMoved(from + (edge - from) * (i as f32 / 6.0)));
+        h.step();
+    }
+    let reached = mask_path(&h, "Plate").vertices[0];
+    for _ in 0..20 {
+        h.step();
+    }
+    h.input_mut().events.push(Event::PointerButton { pos: edge, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
+    h.run_steps(2);
+    let pan = h.state().ui.viewer.pan;
+    assert!(pan[0] > pan0[0] && pan[1] == pan0[1], "the view panned right to show more on the left: {pan0:?} -> {pan:?}");
+    let after = mask_path(&h, "Plate").vertices[0];
+    assert!(after[0] < reached[0], "the vertex kept moving left with the view: {reached:?} -> {after:?}");
+    // Back inside the view, nothing pans.
+    let still = h.state().ui.viewer.pan;
+    let mid = rect(&h, "viewer.comp").center();
+    drag(&mut h, mid, mid + vec2(5.0, 0.0));
+    assert_eq!(h.state().ui.viewer.pan, still);
+}
+
 /// #1769: a hidden masked layer keeps its mask path and vertices, and they remain editable.
 #[test]
 fn hidden_masked_layer_keeps_its_mask_path_editable() {
@@ -1718,7 +1849,7 @@ fn timeline_rows_drag_to_reorder_layers() {
     assert_eq!(h.state().session.history.undo.len(), steps + 1);
     // Dropping a layer where it already is changes nothing.
     let b = row(&h, "Box").center();
-    drag(&mut h, b, b + vec2(0.0, 3.0));
+    drag(&mut h, b, b + vec2(20.0, 0.0));
     assert_eq!(names(&h), ["Plate", "Box"]);
     assert_eq!(h.state().session.history.undo.len(), steps + 1);
     // And back to the top.
@@ -1727,6 +1858,335 @@ fn timeline_rows_drag_to_reorder_layers() {
     assert_eq!(names(&h), ["Box", "Plate"]);
 }
 
+fn timeline_layer_order(h: &Harness<'_, EffectcraftApp>) -> Vec<u64> {
+    h.state().session.active_comp().unwrap().layers.iter().map(|l| l.id.0).collect()
+}
+
+fn timeline_layer_row(h: &Harness<'_, EffectcraftApp>, layer: u64) -> Rect {
+    rect(h, &format!("timeline.layer.{layer}.row"))
+}
+
+fn start_timeline_row_drag(h: &mut Harness<'_, EffectcraftApp>, from: Pos2) {
+    h.input_mut().events.push(Event::PointerMoved(from));
+    h.input_mut().events.push(Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
+    h.step();
+    h.input_mut().events.push(Event::PointerMoved(from + vec2(20.0, 0.0)));
+    h.step();
+    assert_eq!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing, "the row drag started");
+}
+
+fn release_timeline_row_drag(h: &mut Harness<'_, EffectcraftApp>, at: Pos2) {
+    h.input_mut().events.push(Event::PointerMoved(at));
+    h.step();
+    h.input_mut().events.push(Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
+    h.run_steps(2);
+}
+
+fn scroll_timeline(h: &mut Harness<'_, EffectcraftApp>, dy: f32) {
+    let at = rect(h, "timeline.layerMarquee").center();
+    h.input_mut().events.push(Event::PointerMoved(at));
+    h.input_mut().events.push(Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Point,
+        delta: vec2(0.0, dy),
+        modifiers: Default::default(),
+        phase: egui::TouchPhase::Move,
+        source: egui::MouseWheelSource::Wheel,
+    });
+    h.run_steps(20);
+}
+
+/// Wheel-scroll far enough to stop drawing the row that owns the held drag, then drop at
+/// the other end of the stack. The release must work without that row's Response (#2492).
+fn timeline_reorder_after_scroll(down: bool, multiple: bool) {
+    let mut h = harness();
+    for i in 0..38 {
+        h.state_mut().session.execute("layer.newSolid", json!({"name": format!("Layer {i}"), "color": "#406080", "width": 80, "height": 80})).unwrap();
+    }
+    h.state_mut().session.execute("edit.deselectAll", json!({})).unwrap();
+    h.run_steps(3);
+    let before = timeline_layer_order(&h);
+    let count = if multiple { 2 } else { 1 };
+    let moving = if down { before[..count].to_vec() } else { before[before.len() - count..].to_vec() };
+    if multiple {
+        h.state_mut().session.execute("layer.select", json!({"layers": moving})).unwrap();
+        h.run_steps(2);
+    }
+    if !down {
+        scroll_timeline(&mut h, -10_000.0);
+    }
+    let origin = if down { before[0] } else { *before.last().unwrap() };
+    let from = timeline_layer_row(&h, origin).center();
+    // Setup fills the bounded Undo history; reserve room to count this gesture's steps.
+    h.state_mut().session.history.clear();
+    let steps = h.state().session.history.undo.len();
+    start_timeline_row_drag(&mut h, from);
+    scroll_timeline(&mut h, if down { -10_000.0 } else { 10_000.0 });
+    assert!(h.state().auto.find(&format!("timeline.layer.{origin}.row")).is_none(), "the origin row was culled");
+    assert_eq!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing, "scrolling keeps the held drag active");
+    let target = if down { *before.last().unwrap() } else { before[0] };
+    let row = timeline_layer_row(&h, target);
+    let to = row.center() + vec2(0.0, row.height() * if down { 0.4 } else { -0.4 });
+    release_timeline_row_drag(&mut h, to);
+
+    let mut expected: Vec<u64> = before.iter().copied().filter(|id| !moving.contains(id)).collect();
+    let at = if down { expected.len() } else { 0 };
+    expected.splice(at..at, moving);
+    assert_eq!(timeline_layer_order(&h), expected, "the offscreen origin still completes its drop");
+    assert_eq!(h.state().session.history.undo.len(), steps + 1, "one reorder, including a selected group, is one undo step");
+    assert_ne!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing, "release clears the drag feedback");
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(timeline_layer_order(&h), before);
+    h.state_mut().session.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(timeline_layer_order(&h), expected);
+    h.state_mut().session.execute("edit.deselectAll", json!({})).unwrap();
+    h.run_steps(3);
+
+    // A later, independent drag must not reuse the old gesture or selected group.
+    let i = if down { expected.len() - 1 } else { 0 };
+    let j = if down { i - 1 } else { 1 };
+    let from = timeline_layer_row(&h, expected[i]).center();
+    let row = timeline_layer_row(&h, expected[j]);
+    drag(&mut h, from, row.center() + vec2(0.0, row.height() * if down { -0.4 } else { 0.4 }));
+    expected.swap(i, j);
+    assert_eq!(timeline_layer_order(&h), expected, "the next drag is independent");
+    assert_eq!(h.state().session.history.undo.len(), steps + 2);
+}
+
+#[test]
+fn timeline_rows_drag_to_bottom_after_scrolling() {
+    for multiple in [false, true] {
+        timeline_reorder_after_scroll(true, multiple);
+    }
+}
+
+#[test]
+fn timeline_rows_drag_to_top_after_scrolling() {
+    for multiple in [false, true] {
+        timeline_reorder_after_scroll(false, multiple);
+    }
+}
+
+/// An intermediate scroll must not turn the viewport's lower edge into the stack's end.
+fn timeline_reorder_at_viewport_edge(below: bool, multiple: bool) {
+    let mut h = harness();
+    for i in 0..38 {
+        h.state_mut().session.execute("layer.newSolid", json!({"name": format!("Layer {i}"), "color": "#406080", "width": 80, "height": 80})).unwrap();
+    }
+    h.state_mut().session.execute("edit.deselectAll", json!({})).unwrap();
+    h.run_steps(3);
+    let before = timeline_layer_order(&h);
+    let moving = before[..if multiple { 2 } else { 1 }].to_vec();
+    h.state_mut().session.execute("layer.select", json!({"layers": moving})).unwrap();
+    h.run_steps(2);
+    h.state_mut().session.history.clear();
+    let from = timeline_layer_row(&h, moving[0]).center();
+    start_timeline_row_drag(&mut h, from);
+    scroll_timeline(&mut h, -200.0);
+    let visible = |h: &Harness<'_, EffectcraftApp>| {
+        before.iter().copied().filter(|id| h.state().auto.find(&format!("timeline.layer.{id}.row")).is_some()).collect::<Vec<_>>()
+    };
+    // Leave space inside the viewport below the last rendered layer's midpoint.
+    for _ in 0..20 {
+        let last = timeline_layer_row(&h, *visible(&h).last().unwrap());
+        if last.center().y < rect(&h, "timeline.layerMarquee").max.y - 3.0 {
+            break;
+        }
+        scroll_timeline(&mut h, -10.0);
+    }
+    let shown = visible(&h);
+    assert!(!shown.contains(&moving[0]), "the drag owner is culled");
+    let last = *shown.last().unwrap();
+    assert_ne!(last, *before.last().unwrap(), "layers remain below the viewport");
+    let row = timeline_layer_row(&h, last);
+    let viewport = rect(&h, "timeline.layerMarquee");
+    let y = if below { (row.center().y + row.height() * 0.4).min(viewport.max.y - 1.0) } else { row.min.y + row.height() * 0.2 };
+    let to = pos2(row.center().x, y);
+    assert!(viewport.contains(to));
+    assert_eq!(to.y > row.center().y, below);
+    let mut expected: Vec<u64> = before.iter().copied().filter(|id| !moving.contains(id)).collect();
+    let at = expected.iter().position(|id| *id == last).unwrap() + usize::from(below);
+    expected.splice(at..at, moving);
+    release_timeline_row_drag(&mut h, to);
+    assert_eq!(timeline_layer_order(&h), expected, "the drop follows the indicated row boundary");
+    assert_eq!(h.state().session.history.undo.len(), 1);
+    assert_ne!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing);
+    h.state_mut().session.execute("edit.undo", json!({})).unwrap();
+    assert_eq!(timeline_layer_order(&h), before);
+    h.state_mut().session.execute("edit.redo", json!({})).unwrap();
+    assert_eq!(timeline_layer_order(&h), expected);
+}
+
+#[test]
+fn timeline_rows_drag_after_last_visible_row() {
+    for multiple in [false, true] {
+        timeline_reorder_at_viewport_edge(true, multiple);
+    }
+}
+
+#[test]
+fn timeline_rows_drag_before_last_visible_row() {
+    for multiple in [false, true] {
+        timeline_reorder_at_viewport_edge(false, multiple);
+    }
+}
+
+/// A removed ID must not be reinterpreted as a one-based index by layer.arrange.
+fn timeline_reorder_after_deletion(delete_owner: bool) {
+    let mut h = harness();
+    for i in 0..6 {
+        h.state_mut().session.execute("layer.newSolid", json!({"name": format!("Layer {i}"), "color": "#406080", "width": 80, "height": 80})).unwrap();
+    }
+    let before = timeline_layer_order(&h);
+    let removed = *before.last().unwrap();
+    assert!(removed > 0 && removed < before.len() as u64, "the missing ID would also resolve as a surviving layer index");
+    let owner = if delete_owner { removed } else { before[0] };
+    let moving = if delete_owner { vec![removed] } else { vec![owner, removed] };
+    h.state_mut().session.execute("layer.select", json!({"layers": moving})).unwrap();
+    h.run_steps(3);
+    h.state_mut().session.history.clear();
+    let from = timeline_layer_row(&h, owner).center();
+    start_timeline_row_drag(&mut h, from);
+    if !delete_owner {
+        // Changing the selection does not change the group captured by the held drag.
+        h.state_mut().session.execute("layer.select", json!({"layers": [removed]})).unwrap();
+        h.run_steps(2);
+    }
+    key(&mut h, egui::Key::Delete, Default::default());
+    assert!(h.ctx.input(|i| i.pointer.primary_down()), "Delete happened during the held drag");
+    let survivors: Vec<u64> = before.iter().copied().filter(|id| *id != removed).collect();
+    assert_eq!(timeline_layer_order(&h), survivors, "Delete removed only the selected layer");
+    let steps = h.state().session.history.undo.len();
+    let row = timeline_layer_row(&h, survivors[0]);
+    release_timeline_row_drag(&mut h, row.center() - vec2(0.0, row.height() * 0.4));
+    assert_eq!(timeline_layer_order(&h), survivors, "a stale drag cannot move any surviving layer");
+    assert_eq!(h.state().session.history.undo.len(), steps, "release adds no undo step");
+    assert_ne!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing);
+    let from = timeline_layer_row(&h, survivors[0]).center();
+    let row = timeline_layer_row(&h, survivors[1]);
+    drag(&mut h, from, row.center() + vec2(0.0, row.height() * 0.4));
+    let mut expected = survivors;
+    expected.swap(0, 1);
+    assert_eq!(timeline_layer_order(&h), expected, "a later independent drag still works");
+    assert_eq!(h.state().session.history.undo.len(), steps + 1);
+}
+
+#[test]
+fn timeline_rows_drag_cancels_when_the_owner_is_deleted() {
+    timeline_reorder_after_deletion(true);
+}
+
+#[test]
+fn timeline_rows_drag_cancels_when_a_group_member_is_deleted() {
+    timeline_reorder_after_deletion(false);
+}
+
+#[test]
+fn timeline_rows_drag_cancels_without_a_primary_release() {
+    for escape in [false, true] {
+        let mut h = harness();
+        let before = timeline_layer_order(&h);
+        let from = timeline_layer_row(&h, before[0]).center();
+        let row = timeline_layer_row(&h, before[1]);
+        let to = row.center() + vec2(0.0, row.height() * 0.4);
+        let steps = h.state().session.history.undo.len();
+        start_timeline_row_drag(&mut h, from);
+        h.input_mut().events.push(Event::PointerMoved(to));
+        h.step();
+        if escape {
+            key(&mut h, egui::Key::Escape, Default::default());
+        } else {
+            // egui stops its drag on another button's release too. It isn't a layer drop.
+            for pressed in [true, false] {
+                h.input_mut().events.push(Event::PointerButton { pos: to, button: egui::PointerButton::Secondary, pressed, modifiers: Default::default() });
+                h.step();
+            }
+        }
+        assert_eq!(timeline_layer_order(&h), before, "cancellation must not arrange layers");
+        assert_ne!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing);
+        release_timeline_row_drag(&mut h, to);
+        assert_eq!(timeline_layer_order(&h), before, "a later release must not replay a cancelled drag");
+        assert_eq!(h.state().session.history.undo.len(), steps);
+    }
+}
+
+#[test]
+fn timeline_rows_drag_cancels_when_a_modal_opens() {
+    let mut h = harness();
+    let before = timeline_layer_order(&h);
+    let from = timeline_layer_row(&h, before[0]).center();
+    let row = timeline_layer_row(&h, before[1]);
+    let to = row.center() + vec2(0.0, row.height() * 0.4);
+    let steps = h.state().session.history.undo.len();
+    start_timeline_row_drag(&mut h, from);
+    let (modifiers, shortcut) = effectcraft_ui_egui::menus::parse_shortcut("Cmd+Alt+;").unwrap();
+    key(&mut h, shortcut, modifiers);
+    assert_eq!(h.state().dialog, Some(effectcraft_ui_egui::Dialog::Settings));
+    assert!(!h.ctx.read_response(egui::Id::unique(("row", before[0]))).unwrap().enabled(), "the modal disables the Timeline row");
+    assert!(h.ctx.input(|i| i.pointer.primary_down()), "the modal opened during the held drag");
+    release_timeline_row_drag(&mut h, to);
+    assert_eq!(timeline_layer_order(&h), before, "a release behind the modal must not arrange layers");
+    assert_eq!(h.state().session.history.undo.len(), steps);
+    key(&mut h, egui::Key::Escape, Default::default());
+    assert!(h.state().dialog.is_none());
+    assert_eq!(timeline_layer_order(&h), before, "closing the modal must not replay the drag");
+    assert_ne!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing);
+    let from = timeline_layer_row(&h, before[0]).center();
+    let row = timeline_layer_row(&h, before[1]);
+    drag(&mut h, from, row.center() + vec2(0.0, row.height() * 0.4));
+    assert_eq!(timeline_layer_order(&h), [before[1], before[0]]);
+    assert_eq!(h.state().session.history.undo.len(), steps + 1);
+}
+
+#[test]
+fn timeline_rows_drag_does_not_replay_a_release_while_hidden() {
+    use effectcraft_ui_egui::dock::PanelKind;
+    let mut h = harness();
+    let before = timeline_layer_order(&h);
+    let from = timeline_layer_row(&h, before[0]).center();
+    let steps = h.state().session.history.undo.len();
+    start_timeline_row_drag(&mut h, from);
+    h.state_mut().close_panel(PanelKind::Timeline);
+    h.run_steps(2);
+    assert!(h.state().auto.find("timeline.layerMarquee").is_none());
+    release_timeline_row_drag(&mut h, from);
+    h.state_mut().show_panel(PanelKind::Timeline);
+    h.run_steps(3);
+    assert_eq!(timeline_layer_order(&h), before);
+    assert_eq!(h.state().session.history.undo.len(), steps);
+    assert_ne!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing);
+    let from = timeline_layer_row(&h, before[0]).center();
+    let row = timeline_layer_row(&h, before[1]);
+    drag(&mut h, from, row.center() + vec2(0.0, row.height() * 0.4));
+    assert_eq!(timeline_layer_order(&h), [before[1], before[0]]);
+    assert_eq!(h.state().session.history.undo.len(), steps + 1);
+}
+
+#[test]
+fn timeline_rows_drag_cancels_when_the_composition_changes() {
+    let mut h = harness();
+    let original = h.state().session.active_comp_id().unwrap();
+    let before = timeline_layer_order(&h);
+    h.state_mut().session.execute("comp.new", json!({"name": "Other", "width": 640, "height": 360, "duration": 4})).unwrap();
+    h.state_mut().session.execute("layer.newSolid", json!({"name": "Other layer", "color": "#406080", "width": 80, "height": 80})).unwrap();
+    let other = h.state().session.active_comp_id().unwrap();
+    let other_before = timeline_layer_order(&h);
+    h.state_mut().session.execute("comp.open", json!({"comp": original.0})).unwrap();
+    h.run_steps(3);
+    let from = timeline_layer_row(&h, before[0]).center();
+    let steps = h.state().session.history.undo.len();
+    start_timeline_row_drag(&mut h, from);
+    h.state_mut().session.execute("comp.open", json!({"comp": other.0})).unwrap();
+    h.run_steps(2);
+    assert_ne!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing);
+    release_timeline_row_drag(&mut h, from);
+    assert_eq!(timeline_layer_order(&h), other_before);
+    h.state_mut().session.execute("comp.open", json!({"comp": original.0})).unwrap();
+    h.run_steps(3);
+    assert_eq!(timeline_layer_order(&h), before);
+    assert_eq!(h.state().session.history.undo.len(), steps);
+    assert_ne!(h.output().platform_output.cursor_icon, egui::CursorIcon::Grabbing);
+}
+
 fn layer_id(h: &Harness<'_, EffectcraftApp>, name: &str) -> u64 {
     h.state().session.active_comp().unwrap().layers.iter().find(|l| l.name == name).unwrap().id.0
 }
diff --git a/crates/ui-egui/tests/it/ui_viewer_trackpad.rs b/crates/ui-egui/tests/it/ui_viewer_trackpad.rs
new file mode 100644
index 000000000..55466371a
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_viewer_trackpad.rs
@@ -0,0 +1,156 @@
+//! Trackpad gestures in the Composition viewer: a two-finger scroll pans, a pinch (and the mouse
+//! wheel, also one that scrolls in pixels) zooms around the pointer (egui_kittest, UI logic only).
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use effectcraft_ui_egui::dock::PanelKind;
+use egui::{Event, Rect, pos2, vec2};
+use egui_kittest::Harness;
+use serde_json::json;
+
+fn harness() -> Harness<'static, EffectcraftApp> {
+    let mut s = Session::default();
+    s.execute("comp.new", json!({"name": "View", "width": 640, "height": 360, "duration": 4})).unwrap();
+    let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
+    h.state_mut().show_panel(PanelKind::Composition);
+    h.run_steps(4);
+    h
+}
+
+fn rect(h: &Harness<'_, EffectcraftApp>, id: &str) -> Rect {
+    let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}"));
+    Rect::from_min_size(pos2(e.rect[0], e.rect[1]), vec2(e.rect[2], e.rect[3]))
+}
+
+fn wheel(h: &mut Harness<'_, EffectcraftApp>, unit: egui::MouseWheelUnit, delta: egui::Vec2, modifiers: egui::Modifiers) {
+    h.input_mut().events.push(Event::MouseWheel { unit, delta, modifiers, phase: egui::TouchPhase::Move, source: egui::MouseWheelSource::Unknown });
+    h.run_steps(30);
+}
+
+#[test]
+fn trackpad_scroll_pans_the_composition() {
+    let mut h = harness();
+    let comp = rect(&h, "viewer.comp");
+    h.input_mut().events.push(Event::PointerMoved(comp.center()));
+    wheel(&mut h, egui::MouseWheelUnit::Point, vec2(80.0, -40.0), Default::default());
+    let after = rect(&h, "viewer.comp");
+    let moved = after.min - comp.min;
+    assert!((moved.x - 80.0).abs() < 1.5 && (moved.y + 40.0).abs() < 1.5, "the scroll pans: {moved:?}");
+    assert!((after.width() - comp.width()).abs() < 0.5, "a scroll doesn't zoom: {} → {}", comp.width(), after.width());
+}
+
+#[test]
+fn pinch_and_mouse_wheel_zoom_around_the_pointer() {
+    let mut h = harness();
+    let comp = rect(&h, "viewer.comp");
+    let at = comp.min + comp.size() * 0.25;
+    h.input_mut().events.push(Event::PointerMoved(at));
+    h.input_mut().events.push(Event::Zoom(1.5));
+    h.run_steps(3);
+    let zoomed = rect(&h, "viewer.comp");
+    assert!((zoomed.width() / comp.width() - 1.5).abs() < 0.01, "the pinch zooms: {} → {}", comp.width(), zoomed.width());
+    let still = zoomed.min + zoomed.size() * 0.25;
+    assert!(still.distance(at) < 2.0, "the point under the pointer stays put: {at:?} vs {still:?}");
+    // A mouse wheel (it scrolls in lines) zooms too, and so does Alt + a trackpad scroll.
+    wheel(&mut h, egui::MouseWheelUnit::Line, vec2(0.0, 3.0), Default::default());
+    let wheeled = rect(&h, "viewer.comp");
+    assert!(wheeled.width() > zoomed.width() * 1.1, "the wheel zooms in: {} → {}", zoomed.width(), wheeled.width());
+    h.input_mut().events.push(Event::ModifiersChanged(egui::Modifiers::ALT));
+    wheel(&mut h, egui::MouseWheelUnit::Point, vec2(0.0, -120.0), egui::Modifiers::ALT);
+    let out = rect(&h, "viewer.comp");
+    assert!(out.width() < wheeled.width() * 0.9, "Alt + scroll zooms out: {} → {}", wheeled.width(), out.width());
+}
+
+/// Browsers and some high-resolution wheels report a mouse wheel in pixels, as a trackpad does:
+/// it still zooms.
+#[test]
+fn a_pixel_unit_mouse_wheel_zooms() {
+    let mut h = harness();
+    let comp = rect(&h, "viewer.comp");
+    let at = comp.min + comp.size() * 0.25;
+    h.input_mut().events.push(Event::PointerMoved(at));
+    wheel(&mut h, egui::MouseWheelUnit::Point, vec2(0.0, 120.0), Default::default());
+    let zoomed = rect(&h, "viewer.comp");
+    assert!(zoomed.width() > comp.width() * 1.1, "a pixel wheel zooms in: {} → {}", comp.width(), zoomed.width());
+    let still = zoomed.min + zoomed.size() * 0.25;
+    assert!(still.distance(at) < 2.0, "the point under the pointer stays put: {at:?} vs {still:?}");
+    // Shift turns the wheel's scroll sideways: still a wheel, and the next notch zooms.
+    h.input_mut().events.push(Event::ModifiersChanged(egui::Modifiers::SHIFT));
+    wheel(&mut h, egui::MouseWheelUnit::Point, vec2(0.0, 120.0), egui::Modifiers::SHIFT);
+    h.input_mut().events.push(Event::ModifiersChanged(egui::Modifiers::NONE));
+    let before = rect(&h, "viewer.comp");
+    wheel(&mut h, egui::MouseWheelUnit::Point, vec2(0.0, -120.0), Default::default());
+    let out = rect(&h, "viewer.comp");
+    assert!(out.width() < before.width() * 0.9, "the wheel still zooms: {} → {}", before.width(), out.width());
+}
+
+/// A straight vertical trackpad scroll pans when the touch phase says it is a trackpad,
+/// and after any diagonal scroll; a mouse wheel in lines takes the zoom back.
+#[test]
+fn a_vertical_trackpad_scroll_pans_once_the_trackpad_is_known() {
+    let mut h = harness();
+    let comp = rect(&h, "viewer.comp");
+    h.input_mut().events.push(Event::PointerMoved(comp.center()));
+    h.input_mut().events.push(Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Point,
+        delta: egui::Vec2::ZERO,
+        modifiers: Default::default(),
+        source: egui::MouseWheelSource::Unknown,
+        phase: egui::TouchPhase::Start,
+    });
+    h.input_mut().events.push(Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Point,
+        delta: vec2(0.0, 50.0),
+        modifiers: Default::default(),
+        source: egui::MouseWheelSource::Unknown,
+        phase: egui::TouchPhase::Move,
+    });
+    h.step();
+    h.input_mut().events.push(Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Point,
+        delta: egui::Vec2::ZERO,
+        modifiers: Default::default(),
+        source: egui::MouseWheelSource::Unknown,
+        phase: egui::TouchPhase::End,
+    });
+    h.run_steps(30);
+    let panned = rect(&h, "viewer.comp");
+    assert!((panned.min.y - comp.min.y - 50.0).abs() < 1.5, "the scroll pans: {:?}", panned.min - comp.min);
+    assert!((panned.width() - comp.width()).abs() < 0.5, "a trackpad scroll doesn't zoom");
+    // Without phases (Windows, Linux, the web) it stays a trackpad.
+    wheel(&mut h, egui::MouseWheelUnit::Point, vec2(0.0, 30.0), Default::default());
+    let again = rect(&h, "viewer.comp");
+    assert!((again.min.y - panned.min.y - 30.0).abs() < 1.5 && (again.width() - comp.width()).abs() < 0.5, "{again:?}");
+    // A wheel that scrolls in lines is a mouse: it zooms, and so does a pixel wheel after it.
+    wheel(&mut h, egui::MouseWheelUnit::Line, vec2(0.0, 3.0), Default::default());
+    let zoomed = rect(&h, "viewer.comp");
+    assert!(zoomed.width() > again.width() * 1.1, "the wheel zooms: {} → {}", again.width(), zoomed.width());
+    wheel(&mut h, egui::MouseWheelUnit::Point, vec2(0.0, 120.0), Default::default());
+    assert!(rect(&h, "viewer.comp").width() > zoomed.width() * 1.1, "a pixel wheel zooms again");
+}
+
+/// Where the platform names the device (macOS), a straight vertical trackpad scroll pans at once
+/// and a wheel in points zooms.
+#[test]
+fn the_wheel_source_decides_where_the_platform_reports_it() {
+    let mut h = harness();
+    let comp = rect(&h, "viewer.comp");
+    let at = comp.min + comp.size() * 0.25;
+    h.input_mut().events.push(Event::PointerMoved(at));
+    let scroll = |h: &mut Harness<'_, EffectcraftApp>, source, dy| {
+        h.input_mut().events.push(Event::MouseWheel {
+            unit: egui::MouseWheelUnit::Point,
+            delta: vec2(0.0, dy),
+            modifiers: Default::default(),
+            phase: egui::TouchPhase::Move,
+            source,
+        });
+        h.run_steps(30);
+    };
+    scroll(&mut h, egui::MouseWheelSource::Trackpad, 40.0);
+    let panned = rect(&h, "viewer.comp");
+    assert!((panned.min.y - comp.min.y - 40.0).abs() < 1.5, "the trackpad pans: {:?}", panned.min - comp.min);
+    assert!((panned.width() - comp.width()).abs() < 0.5, "a trackpad scroll doesn't zoom");
+    scroll(&mut h, egui::MouseWheelSource::Wheel, 120.0);
+    assert!(rect(&h, "viewer.comp").width() > panned.width() * 1.1, "the wheel zooms");
+}
diff --git a/crates/ui-egui/tests/it/ui_viewers.rs b/crates/ui-egui/tests/it/ui_viewers.rs
index 0019cc9c8..bfbcad51e 100644
--- a/crates/ui-egui/tests/it/ui_viewers.rs
+++ b/crates/ui-egui/tests/it/ui_viewers.rs
@@ -2,10 +2,12 @@
 //! comp goes to an unlocked viewer (a new one when every viewer is locked); a click on another
 //! viewer makes it the active one; closing a viewer forgets it.
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_engine::project::ItemId;
 use effectcraft_ui_egui::EffectcraftApp;
-use effectcraft_ui_egui::dock::{PanelKind, Zone};
+use effectcraft_ui_egui::dock::PanelKind;
+use effectcraft_ui_egui::dock::WorkspaceExt as _;
 use effectcraft_ui_egui::panels::viewers;
 use egui::{Event, pos2};
 use egui_kittest::Harness;
@@ -67,12 +69,18 @@ fn new_viewers_lock_route_comps_and_activate_on_click() {
     h.run_steps(3);
     // View ▸ New Viewer: viewer 1 shows A too, viewer 0 (the Composition panel) is locked.
     invoke(&mut h, "view.newViewer", json!({}));
-    assert!(h.state().ui.dock.contains(PanelKind::Viewer(1)));
+    assert!(h.state().ui.dock.is_docked(PanelKind::Viewer(1)));
     assert!(viewers::locked(h.state(), 0) && !viewers::locked(h.state(), 1));
     assert_eq!((h.state().ui.active_viewer, shows(&h, 0), shows(&h, 1)), (1, Some(a), Some(a)));
     // Side by side, so both draw.
-    assert!(h.state_mut().edit_layout(|l| l.dock(PanelKind::Viewer(1), PanelKind::Composition, Zone::Right)));
-    h.state_mut().ui.dock.activate(PanelKind::Composition);
+    h.state_mut()
+        .apply_dock(craft_ui::docking::Action::Move {
+            panel: PanelKind::Viewer(1),
+            anchor: PanelKind::Composition,
+            placement: craft_ui::docking::Placement::Split(craft_ui::docking::Zone::Right),
+        })
+        .unwrap();
+    h.state_mut().apply_dock(craft_ui::docking::Action::Activate { panel: PanelKind::Composition }).unwrap();
     h.run_steps(3);
     // Opening B shows it in the active (unlocked) viewer; the locked one keeps A.
     invoke(&mut h, "comp.open", json!({"comp": b}));
@@ -90,7 +98,7 @@ fn new_viewers_lock_route_comps_and_activate_on_click() {
     h.state_mut().ui.locked_tabs.insert(PanelKind::Viewer(1).id());
     invoke(&mut h, "comp.open", json!({"comp": b}));
     assert_eq!(h.state().ui.active_viewer, 2);
-    assert!(h.state().ui.dock.contains(PanelKind::Viewer(2)));
+    assert!(h.state().ui.dock.is_docked(PanelKind::Viewer(2)));
     assert_eq!((shows(&h, 0), shows(&h, 1), shows(&h, 2)), (Some(a), Some(c), Some(b)));
     // Closing the active viewer forgets it; another open viewer takes over.
     h.state_mut().close_panel(PanelKind::Viewer(2));
@@ -145,8 +153,14 @@ fn viewers_snapshot() {
     let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| EffectcraftApp::new(s));
     h.run_steps(3);
     invoke(&mut h, "view.newViewer", json!({}));
-    assert!(h.state_mut().edit_layout(|l| l.dock(PanelKind::Viewer(1), PanelKind::Composition, Zone::Right)));
-    h.state_mut().ui.dock.activate(PanelKind::Composition);
+    h.state_mut()
+        .apply_dock(craft_ui::docking::Action::Move {
+            panel: PanelKind::Viewer(1),
+            anchor: PanelKind::Composition,
+            placement: craft_ui::docking::Placement::Split(craft_ui::docking::Zone::Right),
+        })
+        .unwrap();
+    h.state_mut().apply_dock(craft_ui::docking::Action::Activate { panel: PanelKind::Composition }).unwrap();
     invoke(&mut h, "comp.open", json!({"comp": other.0}));
     for _ in 0..300 {
         h.step();
@@ -158,5 +172,5 @@ fn viewers_snapshot() {
     h.run_steps(4);
     let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../target/test-out");
     std::fs::create_dir_all(dir).unwrap();
-    h.render().unwrap().save(format!("{dir}/viewers.png")).unwrap();
+    h.render_serialized().unwrap().save(format!("{dir}/viewers.png")).unwrap();
 }
diff --git a/crates/ui-egui/tests/it/ui_visual_review.rs b/crates/ui-egui/tests/it/ui_visual_review.rs
index 70cc5ed84..6d079f1f5 100644
--- a/crates/ui-egui/tests/it/ui_visual_review.rs
+++ b/crates/ui-egui/tests/it/ui_visual_review.rs
@@ -1,5 +1,6 @@
 //! Opt-in visual review of every built-in panel, workspaces and common dialogs.
 //! Original fixture; captures are review outputs, not shipped assets.
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_ui_egui::{Dialog, EffectcraftApp, dock::PanelKind};
 use egui_kittest::Harness;
@@ -19,18 +20,18 @@ fn all_ui_review_captures() {
         std::sync::Arc::make_mut(&mut s.project).settings.gpu_acceleration = false;
         let mut h = Harness::builder().with_size(size).build_eframe(|_| EffectcraftApp::new(s));
         h.run_steps(4);
-        h.render().unwrap().save(out.join(format!("{label}-workspace.png"))).unwrap();
+        h.render_serialized().unwrap().save(out.join(format!("{label}-workspace.png"))).unwrap();
         let ctx = h.ctx.clone();
         h.state_mut().set_theme(&ctx, effectcraft_ui_egui::theme::ThemeKind::Light);
         h.run_steps(4);
-        h.render().unwrap().save(out.join(format!("{label}-workspace-light.png"))).unwrap();
+        h.render_serialized().unwrap().save(out.join(format!("{label}-workspace-light.png"))).unwrap();
         h.state_mut().set_theme(&ctx, effectcraft_ui_egui::theme::ThemeKind::Dark);
         for p in PanelKind::ALL {
             h.state_mut().show_panel(p);
             h.state_mut().ui.maximized = Some(p);
             h.run_steps(4);
             assert!(h.state().auto.find(&format!("panel.{}", p.id())).is_some(), "{} opens", p.title());
-            h.render().unwrap().save(out.join(format!("{label}-{}.png", p.id()))).unwrap();
+            h.render_serialized().unwrap().save(out.join(format!("{label}-{}.png", p.id()))).unwrap();
         }
         h.state_mut().ui.maximized = None;
         for (name, dialog) in [
@@ -42,7 +43,7 @@ fn all_ui_review_captures() {
         ] {
             h.state_mut().dialog = Some(dialog);
             h.run_steps(4);
-            h.render().unwrap().save(out.join(format!("{label}-dialog-{name}.png"))).unwrap();
+            h.render_serialized().unwrap().save(out.join(format!("{label}-dialog-{name}.png"))).unwrap();
             h.state_mut().dialog = None;
             h.run_steps(2);
         }
diff --git a/crates/ui-egui/tests/it/ui_web_gpu_storage.rs b/crates/ui-egui/tests/it/ui_web_gpu_storage.rs
index a742226de..024bd1cd0 100644
--- a/crates/ui-egui/tests/it/ui_web_gpu_storage.rs
+++ b/crates/ui-egui/tests/it/ui_web_gpu_storage.rs
@@ -122,6 +122,7 @@ fn cpu_pixels(f: &FrameImage) -> Vec<egui::Color32> {
 
 #[test]
 fn gpu_worker_renders_effect_frames_and_the_disk_cache_survives_a_reload() {
+    let _device = crate::gpu_test::lock();
     let (Some(page_gpu), Some(worker_gpu)) = (Gpu::headless(), Gpu::headless_deferred()) else {
         eprintln!("no GPU adapter: skipped");
         return;
diff --git a/crates/ui-egui/tests/it/ui_web_job_gpu.rs b/crates/ui-egui/tests/it/ui_web_job_gpu.rs
index 9060e1067..8b8914abc 100644
--- a/crates/ui-egui/tests/it/ui_web_job_gpu.rs
+++ b/crates/ui-egui/tests/it/ui_web_job_gpu.rs
@@ -10,10 +10,6 @@ use effectcraft_engine::offload::{Inbox, Offload, Post, WorkerReply, WorkerReque
 use effectcraft_gpu::Gpu;
 use serde_json::json;
 
-/// One device at a time in this test binary: wgpu's OpenGL backend (Mesa llvmpipe on FreeBSD,
-/// Linux without Vulkan) panics or crashes when tests create and drive devices concurrently.
-static GPU_LOCK: Mutex<()> = Mutex::new(());
-
 /// Holds offloaded jobs until the test runs them.
 #[derive(Default)]
 struct Manual(Mutex<Vec<(WorkerRequest, Arc<Inbox>)>>);
@@ -63,7 +59,7 @@ fn page() -> (Session, Arc<Manual>) {
 
 #[test]
 fn render_queue_jobs_render_on_the_worker_gpu() {
-    let _gpu = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let _gpu = crate::gpu_test::lock();
     let Some(g) = Gpu::headless_deferred() else {
         eprintln!("no GPU adapter: skipped");
         return;
@@ -102,7 +98,7 @@ fn render_queue_jobs_render_on_the_worker_gpu() {
 
 #[test]
 fn analyses_render_their_input_on_the_worker_gpu() {
-    let _gpu = GPU_LOCK.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
+    let _gpu = crate::gpu_test::lock();
     let Some(g) = Gpu::headless_deferred() else {
         eprintln!("no GPU adapter: skipped");
         return;
diff --git a/crates/ui-egui/tests/it/ui_window_title.rs b/crates/ui-egui/tests/it/ui_window_title.rs
new file mode 100644
index 000000000..66ef62235
--- /dev/null
+++ b/crates/ui-egui/tests/it/ui_window_title.rs
@@ -0,0 +1,21 @@
+//! The window title the shared app reports (project name, ` *` while modified), which hosts that
+//! cannot use `ViewportCommand::Title` (the browser tab) read through `window_title`.
+
+use effectcraft_engine::Session;
+use effectcraft_ui_egui::EffectcraftApp;
+use egui::vec2;
+use egui_kittest::Harness;
+use serde_json::json;
+
+#[test]
+fn the_reported_title_follows_the_open_document() {
+    let mut h = Harness::builder().with_size(vec2(800.0, 600.0)).build_eframe(|_| EffectcraftApp::new(Session::default()));
+    h.run_steps(3);
+    let clean = h.state().window_title().to_owned();
+    assert!(clean.starts_with("EffectCraft - ") && !clean.ends_with(" *"), "{clean}");
+
+    h.state_mut().session.execute("comp.new", json!({"name": "Edited", "width": 64, "height": 64, "duration": 1})).unwrap();
+    h.run_steps(3);
+    let dirty = h.state().window_title().to_owned();
+    assert!(dirty.starts_with("EffectCraft - ") && dirty.ends_with(" *"), "{dirty}");
+}
diff --git a/crates/ui-egui/tests/it/ui_workflow_selection.rs b/crates/ui-egui/tests/it/ui_workflow_selection.rs
index 121c2b888..e7bcedb60 100644
--- a/crates/ui-egui/tests/it/ui_workflow_selection.rs
+++ b/crates/ui-egui/tests/it/ui_workflow_selection.rs
@@ -1,4 +1,5 @@
 //! User-reported selection, Project deletion, and render-queue drop regressions.
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::{Session, project::LayerId};
 use effectcraft_ui_egui::{Dialog, EffectcraftApp, dock::PanelKind};
 use egui::{Event, Modifiers, PointerButton, Pos2, Rect, pos2, vec2};
@@ -273,7 +274,7 @@ fn viewer_right_click_targets_hit_and_duplicate_preserves_group() {
         }
         assert!(h.state().frames.is_cached(&key));
         h.run_steps(3);
-        h.render().expect("offscreen context menu render").save(out).unwrap();
+        h.render_serialized().expect("offscreen context menu render").save(out).unwrap();
     }
     h.get_by_label("Duplicate").click();
     h.run_steps(3);
@@ -433,7 +434,7 @@ fn workflow_snapshot() {
     }
     assert!(h.state().frames.is_cached(&key), "current composition rendered before capture");
     h.run_steps(3);
-    h.render().expect("offscreen UI render").save(out).unwrap();
+    h.render_serialized().expect("offscreen UI render").save(out).unwrap();
 }
 
 /// Filled rects painted this frame (flattening nested shape lists).
diff --git a/crates/ui-egui/tests/it/ui_workspace_focus.rs b/crates/ui-egui/tests/it/ui_workspace_focus.rs
index fbadb964d..af8ecd9ad 100644
--- a/crates/ui-egui/tests/it/ui_workspace_focus.rs
+++ b/crates/ui-egui/tests/it/ui_workspace_focus.rs
@@ -5,27 +5,54 @@ use std::sync::Arc;
 use effectcraft_engine::Session;
 use effectcraft_engine::config::{ConfigStore, DirConfig, MemoryConfig};
 use effectcraft_ui_egui::EffectcraftApp;
-use effectcraft_ui_egui::dock::{DockNode, PanelKind, SplitSize};
+use effectcraft_ui_egui::dock::{self, Node, PanelKind, SplitSize};
 use effectcraft_ui_egui::state::Tool;
 use egui::{Event, Id, Key, Modifiers, vec2};
 use egui_kittest::Harness;
 use serde_json::json;
 
+/// The egui id of panel `p`'s dock tab.
+fn tab_id(p: PanelKind) -> Id {
+    craft_ui::docking::DockArea::<PanelKind>::hit_id(effectcraft_ui_egui::dock_ui::area_id(), &craft_ui::docking::Hit::Tab(p))
+}
+
+#[test]
+fn workspace_commands_wait_for_migration_without_changing_named_layouts() {
+    let store = Arc::new(MemoryConfig::default());
+    let original = include_str!("../fixtures/workspaces-v1.json");
+    store.write("workspaces.json", original).unwrap();
+    let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });
+    assert!(!app.ui.native_outer.is_empty());
+    let ctx = egui::Context::default();
+    let before = (app.ui.workspace.clone(), app.ui.saved_workspaces.clone(), app.ui.dock.clone());
+    for (id, params) in [
+        ("window.saveWorkspace", json!({})),
+        ("window.saveWorkspaceAs", json!({"name": "Too soon"})),
+        ("window.editWorkspaces", json!({"name": "My Layout", "delete": true})),
+        ("window.editWorkspaces", json!({"name": "My Layout", "rename": "Too soon"})),
+    ] {
+        let error = effectcraft_ui_egui::menus::invoke(&mut app, &ctx, id, params).unwrap_err();
+        assert!(error.contains("positions"), "{id}: {error}");
+        assert_eq!((app.ui.workspace.clone(), app.ui.saved_workspaces.clone(), app.ui.dock.clone()), before);
+        assert_eq!(store.read("workspaces.json").as_deref(), Some(original));
+        assert_eq!(store.read("workspaces.old.json"), None);
+    }
+}
+
 #[test]
 fn named_and_current_workspaces_survive_frontend_restart() {
     let store = Arc::new(MemoryConfig::default());
     let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });
-    app.ui.dock = DockNode::Split {
-        vertical: false,
-        size: SplitSize::FixedA(345.0),
-        a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project], active: 0 }),
-        b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Layer], active: 1 }),
-    };
+    app.ui.dock = dock::docked(dock::hsplit(
+        SplitSize::FixedFirst(345.0),
+        dock::tabs(&[PanelKind::Project], 0),
+        dock::tabs(&[PanelKind::Composition, PanelKind::Layer], 1),
+    ));
     let ctx = egui::Context::default();
     effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.saveWorkspaceAs", json!({"name": "Restart layout"})).unwrap();
     let saved = app.ui.dock.clone();
-    if let DockNode::Split { size, .. } = &mut app.ui.dock {
-        *size = SplitSize::FixedA(390.0);
+    if let Some(Node::Split { size, .. }) = &mut app.ui.dock.layout.root {
+        *size = SplitSize::FixedFirst(390.0);
     }
     app.ui.focused = PanelKind::Layer;
     let current = app.ui.dock.clone();
@@ -100,15 +127,18 @@ fn unreadable_native_workspace_is_preserved_after_later_layout_changes() {
 #[test]
 fn legacy_named_workspaces_migrate_once_and_survive_actual_app_restart() {
     let store = Arc::new(MemoryConfig::default());
-    let saved = effectcraft_ui_egui::dock::workspace("Minimal");
-    store.write("workspaces.json", &json!({"workspaces":{"Legacy":saved},"floating":{}}).to_string()).unwrap();
+    // An unversioned record from an earlier EffectCraft: its Minimal layout saved as "Legacy".
+    let legacy = r#"{"floating":{},"workspaces":{"Legacy":{"Split":{"a":{"Tabs":{"active":0,"panels":["Composition"]}},"b":{"Tabs":{"active":0,"panels":["Timeline"]}},"size":{"Ratio":0.6000000238418579},"vertical":true}}}}"#;
+    store.write("workspaces.json", legacy).unwrap();
+    let saved = effectcraft_ui_egui::dock::Workspace::new(effectcraft_ui_egui::dock::workspace("Minimal"));
     let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });
     assert_eq!(app.ui.saved_workspaces.get("Legacy"), Some(&saved));
     app.set_workspace("Legacy");
     let ctx = egui::Context::default();
     effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.saveWorkspaceAs", json!({"name":"Migrated"})).unwrap();
     let text = store.read("workspaces.json").unwrap();
-    assert_eq!(serde_json::from_str::<serde_json::Value>(&text).unwrap()["version"], 1);
+    assert_eq!(serde_json::from_str::<serde_json::Value>(&text).unwrap()["version"], 2);
+    assert_eq!(store.read("workspaces.old.json").as_deref(), Some(legacy));
     let restarted = EffectcraftApp::new(Session { config: Some(store), ..Default::default() });
     assert_eq!(restarted.ui.saved_workspaces.get("Legacy"), Some(&saved));
     assert_eq!(restarted.ui.saved_workspaces.get("Migrated"), Some(&saved));
@@ -166,19 +196,19 @@ fn tab_traversal_activates_an_inactive_dock_tab_without_editing_the_project() {
     app.ui.start_screen = false;
     app.ui.show_menu_bar = false;
     // Leave the inactive, layer-named tab visible instead of behind the overflow control.
-    if let DockNode::Split { a, .. } = &mut app.ui.dock
-        && let DockNode::Split { a, .. } = a.as_mut()
-        && let DockNode::Split { size, .. } = a.as_mut()
+    if let Some(Node::Split { first, .. }) = &mut app.ui.dock.layout.root
+        && let Node::Split { first, .. } = first.as_mut()
+        && let Node::Split { size, .. } = first.as_mut()
     {
-        *size = SplitSize::FixedA(420.0);
+        *size = SplitSize::FixedFirst(420.0);
     }
     let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app);
     h.run_steps(3);
     assert!(h.state().auto.find("panel.tab.EffectControls").is_some(), "the inactive tab must be visible in this fixture");
     let before = h.state().ui.dock.clone();
-    let target = Id::unique(("tab", "aaa".to_string(), 1usize));
+    let target = tab_id(PanelKind::EffectControls);
     let mut tabs = 0;
-    for _ in 0..80 {
+    for _ in 0..200 {
         key(&mut h, Key::Tab, Modifiers::NONE);
         tabs += 1;
         if h.ctx.memory(|m| m.focused()) == Some(target) {
@@ -188,24 +218,26 @@ fn tab_traversal_activates_an_inactive_dock_tab_without_editing_the_project() {
     assert_eq!(h.ctx.memory(|m| m.focused()), Some(target));
     println!("Tab presses from no focus to Effect Controls: {tabs}");
     assert_eq!(h.state().ui.dock, before, "traversal alone must not activate a tab");
+    // craft-ui outlines the keyboard-focused tab, inset 2 pt, in the dock's accent (EffectCraft's
+    // focus colour).
+    let response = h.ctx.read_response(target).unwrap();
+    assert!(
+        h.output().shapes.iter().any(|shape| {
+            matches!(&shape.shape, egui::Shape::Rect(r) if r.rect == response.rect.shrink(2.0) && r.stroke.color == h.state().tokens.focus && r.stroke.width > 0.0)
+        }),
+        "the dock tab must visibly show keyboard focus"
+    );
     key(&mut h, Key::Space, Modifiers::NONE);
     let mut activated = before;
-    assert!(activated.activate(PanelKind::EffectControls));
+    activated.apply(craft_ui::docking::Action::Activate { panel: PanelKind::EffectControls }, dock::permissions).unwrap();
     assert_eq!(h.state().ui.dock, activated);
     assert_eq!(h.state().ui.focused, PanelKind::EffectControls);
     assert!(!h.state().playback.playing);
     assert!(Arc::ptr_eq(&h.state().session.project, &project));
-    let response = h.ctx.read_response(target).unwrap();
-    assert!(
-        h.output().shapes.iter().any(|shape| {
-            matches!(&shape.shape, egui::Shape::Rect(r) if r.rect == response.rect.shrink(1.0) && r.stroke.color == h.state().tokens.text && r.stroke.width > 0.0)
-        }),
-        "the active dock tab must visibly retain keyboard focus"
-    );
     let inspected = effectcraft_ui_egui::control::inspect(h.state(), &h.ctx);
     assert_eq!(inspected["keyboardFocus"]["automationId"], "panel.tab.EffectControls");
     key(&mut h, Key::Tab, Modifiers::SHIFT);
-    assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::unique(("tab", "aaa".to_string(), 0usize))));
+    assert_eq!(h.ctx.memory(|m| m.focused()), Some(tab_id(PanelKind::Project)));
     key(&mut h, Key::Enter, Modifiers::NONE);
     assert_eq!(h.state().ui.focused, PanelKind::Project);
     assert!(!h.state().playback.playing);
@@ -284,8 +316,8 @@ fn control_root_divider_drag_after_toolbar_and_dock_tab_keyboard_activation() {
     d.ok("ui.click", json!({"id":"tools.Selection"}), true);
     // The toolbar can grow as upstream adds controls. Traverse to the actual response
     // identity rather than assuming a fixed number of focus stops.
-    let target = Id::unique(("tab", "aaa".to_string(), 1usize));
-    for tabs in 1..=100 {
+    let target = tab_id(PanelKind::EffectControls);
+    for tabs in 1..=200 {
         d.ok("ui.key", json!({"key":"Tab"}), true);
         assert!(d.h.state().ui.mini_flowchart.is_none(), "dock-tab traversal must not open a foreground popup");
         if d.h.ctx.memory(|memory| memory.focused()) == Some(target) {
@@ -480,7 +512,7 @@ fn failed_save_or_delete_of_a_saved_workspace_keeps_the_file() {
     let saved = app.ui.dock.clone();
     let before = store.read("workspaces.json").unwrap();
     store.full.store(true, std::sync::atomic::Ordering::Relaxed);
-    app.ui.dock.close(PanelKind::Timeline);
+    app.close_panel(PanelKind::Timeline);
     let error = invoke(&mut app, "window.saveWorkspace", json!({})).unwrap_err();
     assert!(error.contains("synthetic full disk") && error.contains("may be lost after a restart"), "{error}");
     assert!(invoke(&mut app, "window.editWorkspaces", json!({"name": "Kept", "delete": true})).is_err());
diff --git a/crates/ui-egui/tests/it/viewer_geometry.rs b/crates/ui-egui/tests/it/viewer_geometry.rs
index e3e4128e8..8a212cc35 100644
--- a/crates/ui-egui/tests/it/viewer_geometry.rs
+++ b/crates/ui-egui/tests/it/viewer_geometry.rs
@@ -1,5 +1,6 @@
 //! Inspect the actual viewer's painted colors and pointer-driven control geometry.
 
+use crate::gpu_test::RenderSerial;
 use effectcraft_engine::Session;
 use effectcraft_ui_egui::{
     EffectcraftApp,
@@ -142,6 +143,16 @@ fn compact_control_row_scrolls_and_preserves_interactions() {
     h.run_steps(3);
     assert!(!h.state().session.state.viewer.show_snapshot, "releasing the snapshot control must return to the current frame");
 
+    // Fast Previews sits beside the resolution control, so the row that scrolled to the timecode has
+    // to scroll back before its menu is reachable.
+    h.event(Event::MouseWheel {
+        unit: egui::MouseWheelUnit::Point,
+        delta: vec2(1500.0, 0.0),
+        modifiers: Default::default(),
+        phase: egui::TouchPhase::Move,
+        source: egui::MouseWheelSource::Wheel,
+    });
+    h.run_steps(30);
     click_control(&mut h, "viewer.fastPreviews");
     click_control(&mut h, "viewer.fastPreviewsItem.1");
     assert_eq!(h.state().session.state.viewer.fast_previews.id(), "adaptive", "a scrolled dropdown must retain its menu command");
@@ -269,10 +280,10 @@ fn viewer_theme_and_width_visual_matrix() {
 }
 
 fn save_stable_snapshot(h: &mut Harness<'_, EffectcraftApp>, path: &str, width: f32) {
-    let image = h.render().unwrap();
+    let image = h.render_serialized().unwrap();
     image.save(path).unwrap();
     h.run_steps(3);
-    let repeated = h.render().unwrap();
+    let repeated = h.render_serialized().unwrap();
     assert!(image == repeated, "settled synthetic viewer pixels must repeat exactly: {path}");
     if width == 900.0 {
         let times: Vec<_> = h
diff --git a/crates/vp9enc/src/bool.rs b/crates/vp9enc/src/bool.rs
index 0cd91b0e1..9eda40541 100644
--- a/crates/vp9enc/src/bool.rs
+++ b/crates/vp9enc/src/bool.rs
@@ -7,6 +7,9 @@ pub struct BoolEncoder {
     range: u32,
     bottom: u32,
     bit_count: i32,
+    /// Start of the run of 0xFF bytes at the end of `out` (`out.len()` when it ends in another
+    /// byte). A carry only touches that run and the byte before it.
+    ff_start: usize,
 }
 
 impl Default for BoolEncoder {
@@ -17,18 +20,37 @@ impl Default for BoolEncoder {
 
 impl BoolEncoder {
     pub fn new() -> Self {
-        BoolEncoder { out: Vec::new(), range: 255, bottom: 0, bit_count: 24 }
+        BoolEncoder { out: Vec::new(), range: 255, bottom: 0, bit_count: 24, ff_start: 0 }
     }
 
+    fn push_byte(&mut self, b: u8) {
+        if b != 255 {
+            self.ff_start = self.out.len() + 1;
+        }
+        self.out.push(b);
+    }
+
+    /// Carry into the bytes written so far: the trailing 0xFF run becomes 0x00 and the byte
+    /// before it grows by one (a carry out of the first byte is dropped). Each 0xFF byte is
+    /// cleared once, so a long run costs O(1) per byte instead of a rescan for every carry.
     fn add_one(&mut self) {
-        let mut i = self.out.len();
-        while i > 0 {
-            i -= 1;
-            if self.out[i] == 255 {
-                self.out[i] = 0;
-            } else {
-                self.out[i] += 1;
-                return;
+        let end = self.out.len();
+        let start = self.ff_start.min(end);
+        if let Some(run) = self.out.get_mut(start..) {
+            run.fill(0);
+        }
+        self.ff_start = end;
+        if let Some(i) = start.checked_sub(1)
+            && let Some(b) = self.out.get_mut(i)
+        {
+            *b = b.wrapping_add(1);
+            if *b == 255 {
+                // The grown byte joins the 0xFF bytes before it.
+                let mut s = i;
+                while s > 0 && self.out.get(s - 1) == Some(&255) {
+                    s -= 1;
+                }
+                self.ff_start = s;
             }
         }
     }
@@ -51,7 +73,7 @@ impl BoolEncoder {
             self.bottom <<= 1;
             self.bit_count -= 1;
             if self.bit_count == 0 {
-                self.out.push((self.bottom >> 24) as u8);
+                self.push_byte((self.bottom >> 24) as u8);
                 self.bottom &= (1 << 24) - 1;
                 self.bit_count = 8;
             }
@@ -80,7 +102,7 @@ impl BoolEncoder {
             v <<= 8;
         }
         for _ in 0..4 {
-            self.out.push((v >> 24) as u8);
+            self.push_byte((v >> 24) as u8);
             v <<= 8;
         }
         self.out
@@ -165,4 +187,73 @@ mod tests {
             assert!(dec.read(1));
         }
     }
+
+    /// The encoder as it was before the carry run was tracked: a carry rescans the bytes.
+    struct Scan {
+        out: Vec<u8>,
+        range: u32,
+        bottom: u32,
+        bit_count: i32,
+    }
+    impl Scan {
+        fn add_one(&mut self) {
+            let mut i = self.out.len();
+            while i > 0 {
+                i -= 1;
+                if self.out[i] == 255 {
+                    self.out[i] = 0;
+                } else {
+                    self.out[i] += 1;
+                    return;
+                }
+            }
+        }
+        fn write(&mut self, bit: bool, prob: u8) {
+            let split = 1 + (((self.range - 1) * prob as u32) >> 8);
+            if bit {
+                self.bottom = self.bottom.wrapping_add(split);
+                self.range -= split;
+            } else {
+                self.range = split;
+            }
+            while self.range < 128 {
+                self.range <<= 1;
+                if self.bottom & (1 << 31) != 0 {
+                    self.add_one();
+                }
+                self.bottom <<= 1;
+                self.bit_count -= 1;
+                if self.bit_count == 0 {
+                    self.out.push((self.bottom >> 24) as u8);
+                    self.bottom &= (1 << 24) - 1;
+                    self.bit_count = 8;
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn carry_run_tracking_matches_the_rescan() {
+        let mut seed = 99u32;
+        for case in 0..300 {
+            let mut fast = BoolEncoder::new();
+            let mut slow = Scan { out: vec![], range: 255, bottom: 0, bit_count: 24 };
+            // Skewed probabilities make long 0xFF runs and carries likely.
+            let extreme = case % 3;
+            for _ in 0..4000 {
+                seed ^= seed << 13;
+                seed ^= seed >> 17;
+                seed ^= seed << 5;
+                let p = match extreme {
+                    0 => (seed >> 8) as u8 | 1,
+                    1 => 1 + (seed >> 8) as u8 % 4,
+                    _ => 255 - (seed >> 8) as u8 % 4,
+                };
+                let bit = (seed >> 24) % 256 >= p as u32 || (seed >> 3).is_multiple_of(11);
+                fast.write(bit, p);
+                slow.write(bit, p);
+                assert_eq!(fast.out, slow.out, "case {case}");
+            }
+        }
+    }
 }
diff --git a/crates/vp9enc/src/lf.rs b/crates/vp9enc/src/lf.rs
index d781144fe..d48c57db5 100644
--- a/crates/vp9enc/src/lf.rs
+++ b/crates/vp9enc/src/lf.rs
@@ -13,6 +13,14 @@ struct Limits {
     thresh: i32,
 }
 
+/// Mode-info grid and thresholds shared by every superblock of this frame.
+struct FrameFilter<'a> {
+    mi: &'a [Mi],
+    mi_rows: usize,
+    mi_cols: usize,
+    limits: Limits,
+}
+
 /// Filter the reconstructed planes (Y, U, V, or a prefix of them) in place at `level` (0 = off;
 /// sharpness 0).
 pub fn filter_frame(planes: &mut [Plane], mi: &[Mi], mi_rows: usize, mi_cols: usize, level: u8) {
@@ -22,61 +30,182 @@ pub fn filter_frame(planes: &mut [Plane], mi: &[Mi], mi_rows: usize, mi_cols: us
     let l = level as i32;
     let limit = l.max(1);
     let lim = Limits { limit, blimit: 2 * (l + 2) + limit, thresh: l >> 4 };
+    let filter = FrameFilter { mi, mi_rows, mi_cols, limits: lim };
     for sbr in 0..mi_rows.div_ceil(8) {
         for sbc in 0..mi_cols.div_ceil(8) {
             for (plane, p) in planes.iter_mut().enumerate() {
                 for pass in 0..2 {
-                    sb_plane(p, mi, mi_rows, mi_cols, plane, pass, sbr * 8, sbc * 8, lim);
+                    filter.sb_plane(p, plane, pass, sbr * 8, sbc * 8);
                 }
             }
         }
     }
 }
 
-#[allow(clippy::too_many_arguments)]
-fn sb_plane(p: &mut Plane, mi: &[Mi], mi_rows: usize, mi_cols: usize, plane: usize, pass: usize, row: usize, col: usize, lim: Limits) {
-    let (sx, sy) = if plane > 0 { (1, 1) } else { (0, 0) };
-    let (sub, edge_len) = if pass == 0 { (sx, 64 >> sy) } else { (sy, 64 >> sx) };
-    let stride = p.w;
-    for edge in 0..(16usize >> sub) {
-        let mut i = 0;
-        while i < edge_len {
-            let (x, y) = if pass == 0 { (col * 8 + edge * (4 << sx), row * 8 + (i << sy)) } else { (col * 8 + (i << sx), row * 8 + edge * (4 << sy)) };
-            if x >= 8 * mi_cols || y >= 8 * mi_rows || (pass == 0 && x == 0) || (pass == 1 && y == 0) {
-                i += 8;
-                continue;
-            }
-            let lc = ((x >> 3) >> sx) << sx;
-            let lr = ((y >> 3) >> sy) << sy;
-            let m = mi[lr * mi_cols + lc];
-            let size = if sub == 0 { m.size } else { m.size.max(BLOCK_16X16) };
-            let n8 = if size >= BLOCK_16X16 { 2 } else { 1 };
-            let is_block_edge = if pass == 0 { x & (8 * n8 - 1) == 0 } else { y & (8 * n8 - 1) == 0 };
-            let tx_ok = !m.inter || !m.skip;
-            if !is_block_edge && !tx_ok {
-                i += 8;
-                continue;
-            }
-            let wide = edge % 8 == 0;
-            let n = if pass == 0 { (8 * mi_rows - y).div_ceil(1 << sy) } else { (8 * mi_cols - x).div_ceil(1 << sx) }.min(8).min(edge_len - i);
-            // A transform edge is not filtered in the last odd chroma column.
-            let odd_last = pass == 1 && sx == 1 && mi_cols & 1 == 1 && edge & 1 == 1;
-            let (px, py) = (x >> sx, y >> sy);
-            for l in 0..n {
-                let is_tx_edge = tx_ok && !(odd_last && x + (l << sx) + 8 >= mi_cols * 8);
-                if !(is_block_edge || is_tx_edge) {
+impl FrameFilter<'_> {
+    fn sb_plane(&self, p: &mut Plane, plane: usize, pass: usize, row: usize, col: usize) {
+        let Self { mi, mi_rows, mi_cols, limits: lim } = *self;
+        let (sx, sy) = if plane > 0 { (1, 1) } else { (0, 0) };
+        let (sub, edge_len) = if pass == 0 { (sx, 64 >> sy) } else { (sy, 64 >> sx) };
+        let stride = p.w;
+        for edge in 0..(16usize >> sub) {
+            let mut i = 0;
+            while i < edge_len {
+                let (x, y) = if pass == 0 { (col * 8 + edge * (4 << sx), row * 8 + (i << sy)) } else { (col * 8 + (i << sx), row * 8 + edge * (4 << sy)) };
+                if x >= 8 * mi_cols || y >= 8 * mi_rows || (pass == 0 && x == 0) || (pass == 1 && y == 0) {
+                    i += 8;
                     continue;
                 }
-                let (pos, step) = if pass == 0 { ((py + l) * stride + px, 1) } else { (py * stride + px + l, stride) };
-                filter_lane(&mut p.rec, pos, step, wide, lim);
+                let lc = ((x >> 3) >> sx) << sx;
+                let lr = ((y >> 3) >> sy) << sy;
+                let m = mi[lr * mi_cols + lc];
+                let size = if sub == 0 { m.size } else { m.size.max(BLOCK_16X16) };
+                let n8 = if size >= BLOCK_16X16 { 2 } else { 1 };
+                let is_block_edge = if pass == 0 { x & (8 * n8 - 1) == 0 } else { y & (8 * n8 - 1) == 0 };
+                let tx_ok = !m.inter || !m.skip;
+                if !is_block_edge && !tx_ok {
+                    i += 8;
+                    continue;
+                }
+                let wide = edge % 8 == 0;
+                let n = if pass == 0 { (8 * mi_rows - y).div_ceil(1 << sy) } else { (8 * mi_cols - x).div_ceil(1 << sx) }.min(8).min(edge_len - i);
+                // A transform edge is not filtered in the last odd chroma column.
+                let odd_last = pass == 1 && sx == 1 && mi_cols & 1 == 1 && edge & 1 == 1;
+                let (px, py) = (x >> sx, y >> sy);
+                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 << sx) + 8 >= mi_cols * 8);
+                    *a = is_block_edge || is_tx_edge;
+                }
+                if apply.iter().any(|&a| a) {
+                    let pos = py * stride + px;
+                    if pass == 0 {
+                        filter_group::<false>(&mut p.rec, pos, stride, 1, apply, wide, lim);
+                    } else {
+                        filter_group::<true>(&mut p.rec, pos, 1, stride, apply, wide, lim);
+                    }
+                }
+                i += 8;
+            }
+        }
+    }
+}
+
+const LANES: usize = 8;
+
+/// [`filter_lane`] on the 8 lanes of a group at once (lane `l` has its q0 at `pos + l * along`;
+/// samples across the edge are `step` apart; `ROWS`: `along` is 1), for lanes whose `apply` is
+/// set. Every lane is computed with both filters and the result selected per lane (0 / -1
+/// masks), so the arithmetic vectorizes; lanes left alone are written back unchanged.
+#[inline(always)]
+fn filter_group<const ROWS: bool>(d: &mut [u8], pos: usize, along: usize, step: usize, apply: [bool; LANES], wide: bool, lim: Limits) {
+    type T = i16;
+    let mut v = [[0 as T; LANES]; 8];
+    let start = pos - 4 * step;
+    if ROWS {
+        for (k, vk) in v.iter_mut().enumerate() {
+            let Some(row) = d.get(start + k * step..).and_then(|r| r.first_chunk::<LANES>()) else { return };
+            *vk = row.map(|s| s as T);
+        }
+    } else {
+        for l in 0..LANES {
+            let Some(line) = d.get(start + l * along..).and_then(|r| r.first_chunk::<8>()) else { return };
+            for k in 0..8 {
+                v[k][l] = line[k] as T;
+            }
+        }
+    }
+    let (limit, blimit, thresh) = (lim.limit as T, lim.blimit as T, lim.thresh as T);
+    let le = |a: T, b: T| -((a <= b) as T);
+    let sel = |m: T, a: T, b: T| (a & m) | (b & !m);
+    let (p3, p2, p1, p0, q0, q1, q2, q3) = (&v[0], &v[1], &v[2], &v[3], &v[4], &v[5], &v[6], &v[7]);
+    let apply: [T; LANES] = apply.map(|a| -(a as T));
+    let can_flat = -(wide as T);
+    let mut mask = [0 as T; LANES];
+    let mut hev = [0 as T; LANES];
+    let mut flat = [0 as T; LANES];
+    for l in 0..LANES {
+        let d10 = (p1[l] - p0[l]).abs();
+        let e10 = (q1[l] - q0[l]).abs();
+        mask[l] = apply[l]
+            & le((p3[l] - p2[l]).abs(), limit)
+            & le((p2[l] - p1[l]).abs(), limit)
+            & le(d10, limit)
+            & le(e10, limit)
+            & le((q2[l] - q1[l]).abs(), limit)
+            & le((q3[l] - q2[l]).abs(), limit)
+            & le((p0[l] - q0[l]).abs() * 2 + (p1[l] - q1[l]).abs() / 2, blimit);
+        hev[l] = !(le(d10, thresh) & le(e10, thresh));
+        flat[l] = can_flat
+            & mask[l]
+            & le(d10, 1)
+            & le(e10, 1)
+            & le((p2[l] - p0[l]).abs(), 1)
+            & le((q2[l] - q0[l]).abs(), 1)
+            & le((p3[l] - p0[l]).abs(), 1)
+            & le((q3[l] - q0[l]).abs(), 1);
+    }
+    if mask.iter().fold(0, |a, &m| a | m) == 0 {
+        return;
+    }
+    let mut out = v;
+    let c = |x: T| x.clamp(-128, 127);
+    for l in 0..LANES {
+        let (ps1, ps0, qs0, qs1) = (p1[l] - 128, p0[l] - 128, q0[l] - 128, q1[l] - 128);
+        let filter = c((c(ps1 - qs1) & hev[l]) + 3 * (qs0 - ps0));
+        let f1 = c(filter + 4) >> 3;
+        let f2 = c(filter + 3) >> 3;
+        let f = (f1 + 1) >> 1;
+        let narrow = mask[l] & !flat[l];
+        let outer = narrow & !hev[l];
+        out[4][l] = sel(narrow, c(qs0 - f1) + 128, out[4][l]);
+        out[3][l] = sel(narrow, c(ps0 + f2) + 128, out[3][l]);
+        out[5][l] = sel(outer, c(qs1 - f) + 128, out[5][l]);
+        out[2][l] = sel(outer, c(ps1 + f) + 128, out[2][l]);
+    }
+    if flat.iter().fold(0, |a, &f| a | f) != 0 {
+        // 8-tap: positions p2..q2 (indices 1..7), each the rounded mean of a 7-wide window
+        // (indices clamped to 0..8) plus itself, as a sliding sum.
+        let s = |k: isize| &v[k.clamp(0, 7) as usize];
+        let mut sum = [0 as T; LANES];
+        for j in -2isize..=4 {
+            let a = s(j);
+            for l in 0..LANES {
+                sum[l] += a[l];
+            }
+        }
+        for k in 1usize..7 {
+            let ki = k as isize;
+            let (cur, add, sub) = (s(ki), s(ki + 4), s(ki - 3));
+            for l in 0..LANES {
+                let w8 = (sum[l] + cur[l] + 4) >> 3;
+                out[k][l] = sel(flat[l], w8, out[k][l]);
+                sum[l] += add[l] - sub[l];
+            }
+        }
+    }
+    if ROWS {
+        for (k, ok) in out.iter().enumerate().take(7).skip(1) {
+            if let Some(row) = d.get_mut(start + k * step..).and_then(|r| r.first_chunk_mut::<LANES>()) {
+                for l in 0..LANES {
+                    row[l] = ok[l] as u8;
+                }
+            }
+        }
+    } else {
+        for l in 0..LANES {
+            if let Some(line) = d.get_mut(start + l * along..).and_then(|r| r.first_chunk_mut::<8>()) {
+                for k in 1..7 {
+                    line[k] = out[k][l] as u8;
+                }
             }
-            i += 8;
         }
     }
 }
 
 /// Filter mask, narrow (4-tap) and 8-tap flat filters of spec 8.8.5 across one edge position;
 /// `pos` is q0, samples across the edge are `step` apart.
+#[cfg(test)]
 fn filter_lane(d: &mut [u8], pos: usize, step: usize, wide: bool, lim: Limits) {
     let at = |k: isize| d[(pos as isize + k * step as isize) as usize] as i32;
     let (p3, p2, p1, p0) = (at(-4), at(-3), at(-2), at(-1));
@@ -122,3 +251,49 @@ fn filter_lane(d: &mut [u8], pos: usize, step: usize, wide: bool, lim: Limits) {
         set(-2, c(ps1 + f) + 128);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn group_matches_per_lane_filter() {
+        let mut seed = 0x1234_5678u32;
+        let mut rnd = || {
+            seed ^= seed << 13;
+            seed ^= seed >> 17;
+            seed ^= seed << 5;
+            seed
+        };
+        for case in 0..20000 {
+            let stride = 24;
+            let base: Vec<u8> = {
+                let flatish = case % 3 == 0;
+                let c = (rnd() % 256) as i32;
+                (0..stride * 24)
+                    .map(|_| if flatish { (c + (rnd() % 3) as i32 - 1).clamp(0, 255) as u8 } else { (c + (rnd() % 40) as i32 - 20).clamp(0, 255) as u8 })
+                    .collect()
+            };
+            let l = (rnd() % 64) as i32;
+            let lim = Limits { limit: l.max(1), blimit: 2 * (l + 2) + l.max(1), thresh: l >> 4 };
+            let wide = rnd() & 1 == 1;
+            let apply: [bool; LANES] = std::array::from_fn(|_| rnd() % 4 != 0);
+            for pass in 0..2 {
+                let (mut a, mut b) = (base.clone(), base.clone());
+                let pos = 8 * stride + 8;
+                for (l, &ap) in apply.iter().enumerate() {
+                    if ap {
+                        let (p, st) = if pass == 0 { (pos + l * stride, 1) } else { (pos + l, stride) };
+                        filter_lane(&mut a, p, st, wide, lim);
+                    }
+                }
+                if pass == 0 {
+                    filter_group::<false>(&mut b, pos, stride, 1, apply, wide, lim);
+                } else {
+                    filter_group::<true>(&mut b, pos, 1, stride, apply, wide, lim);
+                }
+                assert_eq!(a, b, "case {case} pass {pass}");
+            }
+        }
+    }
+}
diff --git a/crates/vp9enc/src/lib.rs b/crates/vp9enc/src/lib.rs
index 9364dfaa1..12ad77ae7 100644
--- a/crates/vp9enc/src/lib.rs
+++ b/crates/vp9enc/src/lib.rs
@@ -33,12 +33,17 @@ use probs::Probs;
 use tables::{AC_QLOOKUP, DC_QLOOKUP};
 use transform::Quant;
 
+/// Largest width or height the 16-bit frame size fields can hold.
+const MAX_DIMENSION: u32 = 1 << 16;
+
 pub(crate) const BLOCK_8X8: u8 = 3;
 pub(crate) const BLOCK_16X16: u8 = 6;
 
 /// Encoder settings.
 #[derive(Clone, Debug, PartialEq)]
 pub struct EncoderConfig {
+    /// Frame size in samples; the stream stores size - 1 in 16 bits, so values above 65536 are
+    /// clamped to 65536 by [`Vp9Encoder::new`].
     pub width: u32,
     pub height: u32,
     /// 1..=100; 100 is lossless. With a target bitrate: the quality of the first frame.
@@ -85,7 +90,6 @@ pub(crate) struct Plane {
 }
 
 impl Plane {
-    #[allow(clippy::too_many_arguments)]
     fn new(data: &[u8], vw: usize, vh: usize, w: usize, h: usize, max_x: usize, max_y: usize) -> Plane {
         let mut src = vec![0u8; w * h];
         for y in 0..h {
@@ -140,7 +144,10 @@ fn quality_to_qidx(q: u8) -> u8 {
 }
 
 impl Vp9Encoder {
-    pub fn new(cfg: EncoderConfig) -> Self {
+    pub fn new(mut cfg: EncoderConfig) -> Self {
+        // The frame header stores width - 1 and height - 1 in 16 bits.
+        cfg.width = cfg.width.min(MAX_DIMENSION);
+        cfg.height = cfg.height.min(MAX_DIMENSION);
         let q = cfg.quality.clamp(1, 100);
         let lossless = q >= 100 && cfg.target_kbps.is_none();
         let base_qidx = if lossless { 0 } else { quality_to_qidx(q) };
@@ -461,3 +468,16 @@ pub fn alpha_to_yuv420(rgba: &[u8], w: u32, h: u32) -> (Vec<u8>, Vec<u8>, Vec<u8
     let y: Vec<u8> = rgba.as_chunks::<4>().0.iter().take(w * h).map(|p| p[3]).collect();
     (y, vec![128; cw * ch], vec![128; cw * ch])
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sizes_beyond_the_16_bit_header_fields_are_clamped() {
+        let enc = Vp9Encoder::new(EncoderConfig { width: 70_000, height: u32::MAX, ..Default::default() });
+        assert_eq!((enc.cfg.width, enc.cfg.height), (65_536, 65_536));
+        let enc = Vp9Encoder::new(EncoderConfig { width: 65_536, height: 1, ..Default::default() });
+        assert_eq!((enc.cfg.width, enc.cfg.height), (65_536, 1));
+    }
+}
diff --git a/crates/vp9enc/src/mc.rs b/crates/vp9enc/src/mc.rs
index 779a1ea5f..5d897f854 100644
--- a/crates/vp9enc/src/mc.rs
+++ b/crates/vp9enc/src/mc.rs
@@ -56,6 +56,26 @@ pub fn predict(r: &RefPlane, x16: i32, y16: i32, w: usize, h: usize, out: &mut [
     };
     let fh = &SUBPEL_REGULAR[fx];
     let fv = &SUBPEL_REGULAR[fy];
+    if inside && w <= 16 && h <= 16 {
+        // Rows straight from the reference (no edge clamping needed).
+        let (xs, ys) = ((x0 - 3) as usize, (y0 - 3) as usize);
+        let row = |i: usize| &r.data[(ys + i) * r.stride + xs..];
+        if fx == 0 && fy == 0 {
+            for i in 0..h {
+                out[i * w..i * w + w].copy_from_slice(&row(i + 3)[3..3 + w]);
+            }
+            return;
+        }
+        let mut tmp = [0u8; 23 * 16];
+        for i in 0..h + 7 {
+            let s = row(i);
+            filt8(std::array::from_fn(|t| &s[t..]), fh, &mut tmp[i * w..i * w + w]);
+        }
+        for i in 0..h {
+            filt8(std::array::from_fn(|t| &tmp[(i + t) * w..]), fv, &mut out[i * w..i * w + w]);
+        }
+        return;
+    }
     if fx == 0 && fy == 0 {
         for i in 0..h {
             for j in 0..w {
@@ -108,24 +128,23 @@ impl PhasePlanes {
         let rh = ph + 2 * M;
         let off = (border + M) as i32;
         let mut raw = vec![0u8; rs * rh];
-        for y in 0..rh {
+        let o = off as usize;
+        for (y, row) in raw.chunks_exact_mut(rs).enumerate() {
             let sy = (y as i32 - off).clamp(0, r.h as i32 - 1) as usize;
             let src = &r.data[sy * r.stride..sy * r.stride + r.w];
-            for x in 0..rs {
-                raw[y * rs + x] = src[(x as i32 - off).clamp(0, r.w as i32 - 1) as usize];
-            }
+            // Edge replication: src[clamp(x - off, 0, w - 1)].
+            let (left, rest) = row.split_at_mut(o.min(rs));
+            left.fill(src[0]);
+            let n = r.w.min(rest.len());
+            rest[..n].copy_from_slice(&src[..n]);
+            rest[n..].fill(src[r.w - 1]);
         }
         // Horizontal phases over every raw row (inner columns).
         let hpass = |fx: usize| -> Vec<u8> {
             let f = &SUBPEL_REGULAR[fx];
             let mut out = vec![0u8; pw * rh];
-            for y in 0..rh {
-                let row = &raw[y * rs..y * rs + rs];
-                for x in 0..pw {
-                    let s = &row[x + M - 3..x + M + 5];
-                    let acc: i32 = 64 + (0..8).map(|t| f[t] * s[t] as i32).sum::<i32>();
-                    out[y * pw + x] = (acc >> 7).clamp(0, 255) as u8;
-                }
+            for (row, o) in raw.chunks_exact(rs).zip(out.chunks_exact_mut(pw)) {
+                filt8(std::array::from_fn(|t| &row[M - 3 + t..]), f, o);
             }
             out
         };
@@ -140,14 +159,8 @@ impl PhasePlanes {
                 }
                 let f = &SUBPEL_REGULAR[fy * 4];
                 let mut out = vec![0u8; pw * ph];
-                for y in 0..ph {
-                    for x in 0..pw {
-                        let mut acc = 64;
-                        for t in 0..8 {
-                            acc += f[t] * hp[(y + M + t - 3) * pw + x] as i32;
-                        }
-                        out[y * pw + x] = (acc >> 7).clamp(0, 255) as u8;
-                    }
+                for (y, o) in out.chunks_exact_mut(pw).enumerate() {
+                    filt8(std::array::from_fn(|t| &hp[(y + M + t - 3) * pw..]), f, o);
                 }
                 planes.push(out);
             }
@@ -167,6 +180,51 @@ impl PhasePlanes {
     }
 }
 
+/// `out[x] = clip(Round2(sum_t f[t] * s[t][x], 7))` for 8-bit samples. Lanes are 16-bit sums
+/// kept modulo 2^16: with the regular filter every sum plus the rounding term lies in
+/// [-13706, 46474], so wrapped non-negative sums stay below 0xC000 and negative ones (clipped
+/// to 0) land above it (the decoder's `narrow8`).
+#[inline]
+fn filt8(s: [&[u8]; 8], f: &[i32; 8], out: &mut [u8]) {
+    let n = out.len();
+    let mut x = 0;
+    while x + 32 <= n {
+        filt_chunk::<32>(&s, f, out, x);
+        x += 32;
+    }
+    for w in [16, 8, 4] {
+        if x + w <= n {
+            match w {
+                16 => filt_chunk::<16>(&s, f, out, x),
+                8 => filt_chunk::<8>(&s, f, out, x),
+                _ => filt_chunk::<4>(&s, f, out, x),
+            }
+            x += w;
+        }
+    }
+    for j in x..n {
+        let acc: i32 = 64 + (0..8).map(|t| f[t] * s[t][j] as i32).sum::<i32>();
+        out[j] = (acc >> 7).clamp(0, 255) as u8;
+    }
+}
+
+#[inline(always)]
+fn filt_chunk<const W: usize>(s: &[&[u8]; 8], f: &[i32; 8], out: &mut [u8], x: usize) {
+    let mut acc = [64u16; W];
+    for t in 0..8 {
+        let c = f[t] as u16;
+        let Some(p) = s[t].get(x..).and_then(|p| p.first_chunk::<W>()) else { return };
+        for j in 0..W {
+            acc[j] = acc[j].wrapping_add(c.wrapping_mul(p[j] as u16));
+        }
+    }
+    if let Some(o) = out.get_mut(x..).and_then(|o| o.first_chunk_mut::<W>()) {
+        for j in 0..W {
+            o[j] = if acc[j] < 0xC000 { (acc[j] >> 7).min(255) as u8 } else { 0 };
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #[test]
diff --git a/crates/vp9enc/src/probs.rs b/crates/vp9enc/src/probs.rs
index 8f55bbba3..c089cb96f 100644
--- a/crates/vp9enc/src/probs.rs
+++ b/crates/vp9enc/src/probs.rs
@@ -9,7 +9,11 @@
 //! entropy codes the recorded symbols with the updated probabilities.
 
 use crate::bool::BoolEncoder;
-use crate::tables::*;
+use crate::tables::{
+    DEFAULT_COEF_PROBS, DEFAULT_INTER_MODE_PROBS, DEFAULT_IS_INTER_PROB, DEFAULT_MV_BITS_PROB, DEFAULT_MV_CLASS_PROBS, DEFAULT_MV_CLASS0_BIT_PROB,
+    DEFAULT_MV_CLASS0_FR_PROBS, DEFAULT_MV_FR_PROBS, DEFAULT_MV_JOINT_PROBS, DEFAULT_MV_SIGN_PROB, DEFAULT_PARTITION_PROBS, DEFAULT_SINGLE_REF_PROB,
+    DEFAULT_SKIP_PROB, PARETO_TABLE, inv_map_table,
+};
 
 /// Coefficient probabilities `[ptype][ref][band][ctx][3]` for 4×4 transforms (band 0 uses
 /// contexts 0..3 only).
@@ -212,7 +216,32 @@ fn inv_remap_prob(delta: usize, prob: u8) -> u8 {
 
 /// The `decode_term_subexp` value that moves `old` to `new`.
 fn delta_for(old: u8, new: u8) -> Option<usize> {
-    (0..255).find(|&d| inv_remap_prob(d, old) == new)
+    match delta_table().get(old as usize * 256 + new as usize) {
+        Some(&d) if d != NO_DELTA => Some(d as usize),
+        _ => None,
+    }
+}
+
+/// Marks "no delta reaches this probability" in [`delta_table`].
+const NO_DELTA: u8 = 255;
+
+/// `delta_for` for every (old, new) pair, indexed `old * 256 + new`: the smallest delta that
+/// moves `old` to `new`. Filled from the largest delta down so the smallest one wins.
+fn delta_table() -> &'static [u8] {
+    use std::sync::OnceLock;
+    static T: OnceLock<Vec<u8>> = OnceLock::new();
+    T.get_or_init(|| {
+        let mut t = vec![NO_DELTA; 256 * 256];
+        for old in 0..=255u8 {
+            for d in (0..255usize).rev() {
+                let new = inv_remap_prob(d, old);
+                if let Some(e) = t.get_mut(old as usize * 256 + new as usize) {
+                    *e = d as u8;
+                }
+            }
+        }
+        t
+    })
 }
 
 /// Bits of `decode_term_subexp` for `d`.
@@ -415,6 +444,16 @@ mod tests {
         }
     }
 
+    #[test]
+    fn delta_table_matches_the_linear_search() {
+        for old in 0..=255u8 {
+            for new in 0..=255u8 {
+                let slow = (0..255).find(|&d| inv_remap_prob(d, old) == new);
+                assert_eq!(delta_for(old, new), slow, "{old} -> {new}");
+            }
+        }
+    }
+
     #[test]
     fn inv_map_table_shape() {
         let t = inv_map_table();
diff --git a/crates/vp9enc/src/tables.rs b/crates/vp9enc/src/tables.rs
index ffb266419..c70d7d8c2 100644
--- a/crates/vp9enc/src/tables.rs
+++ b/crates/vp9enc/src/tables.rs
@@ -2,8 +2,6 @@
 //! transcribed in FilmCraft's first-party decoder `filmcraft-vp9` (MIT OR Apache-2.0, the same
 //! licence as this crate).
 
-#![allow(clippy::unreadable_literal)]
-
 pub const DC_QLOOKUP: [i32; 256] = [
     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,
diff --git a/crates/vp9enc/src/tile.rs b/crates/vp9enc/src/tile.rs
index d7f6cb64f..082d0bd83 100644
--- a/crates/vp9enc/src/tile.rs
+++ b/crates/vp9enc/src/tile.rs
@@ -8,7 +8,10 @@
 
 use crate::mc::{Mv, PhasePlanes, RefPlane, clamp_for_plane, predict};
 use crate::probs::{self, P, Writer, cost, tree_cost};
-use crate::tables::*;
+use crate::tables::{
+    COEFBAND_4X4, COL_SCAN_4X4, COUNTER_TO_CONTEXT, DEFAULT_SCAN_4X4, ENERGY_CLASS, KF_PARTITION_PROBS, KF_UV_MODE_PROBS, KF_Y_MODE_PROBS, MODE_2_COUNTER,
+    MV_REF_8X8, MV_REF_16X16, ROW_SCAN_4X4,
+};
 use crate::transform::{ADST_ADST, ADST_DCT, DCT_ADST, DCT_DCT, Quant};
 use crate::{BLOCK_8X8, BLOCK_16X16, Mi, Plane};
 
@@ -22,6 +25,13 @@ pub const NEARMV: u8 = 11;
 pub const ZEROMV: u8 = 12;
 pub const NEWMV: u8 = 13;
 
+/// Which reconstructed neighbours are available for intra prediction.
+#[derive(Clone, Copy)]
+struct IntraEdges {
+    left: bool,
+    above: bool,
+}
+
 const PARTITION_TREE: [i8; 6] = [0, 2, -1, 4, -2, -3];
 const INTRA_MODE_TREE: [i8; 18] = [0, 2, -9, 4, -1, 6, 8, 12, -2, 10, -4, -5, -3, 14, -8, 16, -6, -7];
 /// Leaves are `mode - NEARESTMV`.
@@ -104,7 +114,8 @@ fn levels_cost(levels: &[i32; 16], eob: usize) -> u32 {
 }
 
 /// Intra prediction (8.5.1) of a square block for DC / V / H / TM.
-fn predict_intra(p: &Plane, x: usize, y: usize, log2: usize, mode: u8, have_left: bool, have_above: bool) -> [i32; 64] {
+fn predict_intra(p: &Plane, x: usize, y: usize, log2: usize, mode: u8, edges: IntraEdges) -> [i32; 64] {
+    let IntraEdges { left: have_left, above: have_above } = edges;
     let size = 1usize << log2;
     let base = 128i32;
     let buf = &p.rec;
@@ -211,6 +222,21 @@ fn probs_defaults() -> &'static probs::Probs {
     D.get_or_init(probs::Probs::defaults)
 }
 
+/// SAD of two N×N blocks: per-column 16-bit sums (at most 16 · 255), summed once.
+#[inline(always)]
+fn sad_n<const N: usize>(a: &[u8], sa: usize, b: &[u8], sb: usize) -> u32 {
+    let mut acc = [0u16; N];
+    for i in 0..N {
+        let (Some(ra), Some(rb)) = (a.get(i * sa..).and_then(|r| r.first_chunk::<N>()), b.get(i * sb..).and_then(|r| r.first_chunk::<N>())) else {
+            return u32::MAX / 4;
+        };
+        for j in 0..N {
+            acc[j] += ra[j].abs_diff(rb[j]) as u16;
+        }
+    }
+    acc.iter().map(|&v| v as u32).sum()
+}
+
 // ---------------------------------------------------------------- the tile
 
 /// Per-frame coding parameters shared by the tiles.
@@ -356,11 +382,11 @@ impl<'a> Tile<'a> {
     fn intra_block(&mut self, r: usize, c: usize) {
         let avail_u = r > 0;
         let avail_l = c > self.col_start;
-        let y_mode = self.choose_intra(0, c * 8, r * 8, 3, avail_l, avail_u);
+        let y_mode = self.choose_intra(0, c * 8, r * 8, 3, IntraEdges { left: avail_l, above: avail_u });
         let uv_mode = {
             let mut best = (i64::MAX, DC_PRED);
             for m in MODES {
-                let cost: i64 = (1..3).map(|p| self.intra_cost(p, c * 4, r * 4, 2, m, avail_l, avail_u)).sum();
+                let cost: i64 = (1..3).map(|p| self.intra_cost(p, c * 4, r * 4, 2, m, IntraEdges { left: avail_l, above: avail_u })).sum();
                 if cost < best.0 {
                     best = (cost, m);
                 }
@@ -379,17 +405,16 @@ impl<'a> Tile<'a> {
         // Residual: luma 2×2 transform blocks, then one 4×4 block per chroma plane.
         for (dy, dx) in [(0, 0), (0, 1), (1, 0), (1, 1)] {
             let tx = if self.f.quant.lossless { DCT_DCT } else { mode_tx_type(y_mode) };
-            self.intra_tx(0, c * 8 + dx * 4, r * 8 + dy * 4, y_mode, tx, avail_l || dx > 0, avail_u || dy > 0);
+            self.intra_tx(0, c * 8 + dx * 4, r * 8 + dy * 4, y_mode, tx, IntraEdges { left: avail_l || dx > 0, above: avail_u || dy > 0 });
         }
         for p in 1..3 {
-            self.intra_tx(p, c * 4, r * 4, uv_mode, DCT_DCT, avail_l, avail_u);
+            self.intra_tx(p, c * 4, r * 4, uv_mode, DCT_DCT, IntraEdges { left: avail_l, above: avail_u });
         }
     }
 
-    #[allow(clippy::too_many_arguments)]
-    fn intra_cost(&self, plane: usize, x: usize, y: usize, log2: usize, mode: u8, have_left: bool, have_above: bool) -> i64 {
+    fn intra_cost(&self, plane: usize, x: usize, y: usize, log2: usize, mode: u8, edges: IntraEdges) -> i64 {
         let p = &self.planes[plane];
-        let pred = predict_intra(p, x, y, log2, mode, have_left, have_above);
+        let pred = predict_intra(p, x, y, log2, mode, edges);
         let size = 1 << log2;
         let mut s = 0i64;
         for i in 0..size {
@@ -400,10 +425,10 @@ impl<'a> Tile<'a> {
         s
     }
 
-    fn choose_intra(&self, plane: usize, x: usize, y: usize, log2: usize, have_left: bool, have_above: bool) -> u8 {
+    fn choose_intra(&self, plane: usize, x: usize, y: usize, log2: usize, edges: IntraEdges) -> u8 {
         let mut best = (i64::MAX, DC_PRED);
         for m in MODES {
-            let cost = self.intra_cost(plane, x, y, log2, m, have_left, have_above);
+            let cost = self.intra_cost(plane, x, y, log2, m, edges);
             if cost < best.0 {
                 best = (cost, m);
             }
@@ -411,8 +436,7 @@ impl<'a> Tile<'a> {
         best.1
     }
 
-    #[allow(clippy::too_many_arguments)]
-    fn intra_tx(&mut self, plane: usize, x: usize, y: usize, mode: u8, tx_type: u8, have_left: bool, have_above: bool) {
+    fn intra_tx(&mut self, plane: usize, x: usize, y: usize, mode: u8, tx_type: u8, edges: IntraEdges) {
         let ss = (plane > 0) as usize;
         let max_x = (self.f.mi_cols * 8) >> ss;
         let max_y = (self.f.mi_rows * 8) >> ss;
@@ -424,7 +448,7 @@ impl<'a> Tile<'a> {
             return;
         }
         let p = &self.planes[plane];
-        let pred = predict_intra(p, x, y, 2, mode, have_left, have_above);
+        let pred = predict_intra(p, x, y, 2, mode, edges);
         let mut res = [0i32; 16];
         for i in 0..4 {
             for j in 0..4 {
@@ -592,12 +616,18 @@ impl<'a> Tile<'a> {
         let (x16, y16) = (((c * 8) << 4) as i32 + 2 * mv.col, ((r * 8) << 4) as i32 + 2 * mv.row);
         let mut s = 0u32;
         if let Some((pl, o, st)) = self.f.phases.as_ref().and_then(|ph| ph.block(x16, y16, n)) {
-            for i in 0..n {
-                let a = &p.src[(r * 8 + i) * p.w + c * 8..][..n];
-                let b = &pl[o + i * st..o + i * st + n];
-                s += a.iter().zip(b).map(|(a, b)| (*a as i32 - *b as i32).unsigned_abs()).sum::<u32>();
-            }
-            return s;
+            let a = &p.src[(r * 8) * p.w + c * 8..];
+            let b = &pl[o..];
+            return match n {
+                8 => sad_n::<8>(a, p.w, b, st),
+                16 => sad_n::<16>(a, p.w, b, st),
+                _ => {
+                    for i in 0..n {
+                        s += a[i * p.w..][..n].iter().zip(&b[i * st..][..n]).map(|(a, b)| a.abs_diff(*b) as u32).sum::<u32>();
+                    }
+                    s
+                }
+            };
         }
         // Inter search only runs on frames with a reference.
         let Some(refs) = self.f.refs.as_ref() else { return u32::MAX / 4 };
@@ -621,7 +651,7 @@ impl<'a> Tile<'a> {
         let d = &probs_defaults().0;
         let mb: [u32; 4] = std::array::from_fn(|m| tree_cost(&INTER_MODE_TREE, &d[probs::INTER_MODE + mctx * 3..], m as u8));
         let mode_bits = |m: u8| mb[(m - NEARESTMV) as usize];
-        let cost = |mv: Mv| -> f64 {
+        let cost_raw = |mv: Mv| -> f64 {
             let bits = if mv == nearest {
                 mode_bits(NEARESTMV)
             } else if mv == Mv::ZERO {
@@ -633,6 +663,21 @@ impl<'a> Tile<'a> {
             };
             self.sad(r, c, n, mv) as f64 + lambda * bits as f64
         };
+        // The cost is a pure function of the vector: points the search revisits (the centre it
+        // came from, candidates on the diamond) are looked up instead of predicted again.
+        let mut seen = [(Mv::ZERO, 0.0f64); 64];
+        let mut nseen = 0usize;
+        let mut cost = |mv: Mv| -> f64 {
+            if let Some(&(_, j)) = seen[..nseen].iter().find(|e| e.0 == mv) {
+                return j;
+            }
+            let j = cost_raw(mv);
+            if nseen < seen.len() {
+                seen[nseen] = (mv, j);
+                nseen += 1;
+            }
+            j
+        };
         let mut best = (Mv::ZERO, cost(Mv::ZERO));
         let prev = self.f.prev_mvs.map(|p| p[r * self.f.mi_cols + c]);
         for cand in [Some(nearest), Some(near), prev].into_iter().flatten() {
diff --git a/crates/vp9enc/src/transform.rs b/crates/vp9enc/src/transform.rs
index e6a685d5a..20996d60b 100644
--- a/crates/vp9enc/src/transform.rs
+++ b/crates/vp9enc/src/transform.rs
@@ -144,6 +144,16 @@ pub fn forward_matrices() -> &'static [[[f64; 16]; 16]; 4] {
     })
 }
 
+/// [`forward_matrices`] transposed: `[type][q][k]`.
+fn forward_matrices_t() -> &'static [[[f64; 16]; 16]; 4] {
+    use std::sync::OnceLock;
+    static M: OnceLock<[[[f64; 16]; 16]; 4]> = OnceLock::new();
+    M.get_or_init(|| {
+        let f = forward_matrices();
+        std::array::from_fn(|t| std::array::from_fn(|q| std::array::from_fn(|k| f[t][k][q])))
+    })
+}
+
 fn invert16(m: [[f64; 16]; 16]) -> [[f64; 16]; 16] {
     let mut a = m;
     let mut inv = [[0.0; 16]; 16];
@@ -191,12 +201,23 @@ impl Quant {
         if self.lossless {
             return forward_wht(res);
         }
-        let f = &forward_matrices()[tx_type as usize];
+        let ft = &forward_matrices_t()[tx_type as usize];
+        // Every output accumulates its 16 products in the same order (q ascending) as a
+        // per-output sum, but the 16 outputs advance together: 16 independent chains that
+        // vectorize instead of one serial chain per output.
+        let mut acc = [-0.0f64; 16];
+        for (q, col) in ft.iter().enumerate() {
+            let r = res[q] as f64;
+            for k in 0..16 {
+                acc[k] += col[k] * r;
+            }
+        }
         let mut lv = [0i32; 16];
         for k in 0..16 {
-            let coef: f64 = (0..16).map(|q| f[k][q] * res[q] as f64).sum();
+            let coef = acc[k];
             let (qs, rnd) = if k == 0 { (self.dcq, self.round_dc) } else { (self.acq, self.round_ac) };
-            let l = (coef.abs() / qs as f64 + rnd).floor() as i32;
+            // Non-negative: truncation is floor.
+            let l = (coef.abs() / qs as f64 + rnd) as i32;
             lv[k] = if coef < 0.0 { -l } else { l };
         }
         lv
diff --git a/docs/adr/0002-sam2-roto-tracker.md b/docs/adr/0002-sam2-roto-tracker.md
new file mode 100644
index 000000000..3807d84a2
--- /dev/null
+++ b/docs/adr/0002-sam2-roto-tracker.md
@@ -0,0 +1,19 @@
+# ADR 0002: SAM 2 video tracker for the Roto Brush
+
+Status: accepted (maintainer answers, 2026-10-15). Plan: `plan/roto-sam2.md` (maintainer-local).
+
+## Context
+The Roto Brush's classical engine loses an object that is occluded or leaves and re-enters the frame
+(`effectcraft-cli bench --roto`: IoU 0.49 on the occlusion clip, 0.62 on re-entry, 0 after the object returns).
+Meta's SAM 2.1 (Apache-2.0 code and checkpoints) has streaming memory built for this.
+
+## Decisions
+- **D1** A native-only `candle` dependency may enter the workspace, in its own crate (`effectcraft-sam2`), excluded from wasm32.
+- **D2** `effectcraft-sam2` is licensed Apache-2.0 only (it derives from Apache-2.0 Hugging Face `transformers` code); `effectcraft-segment` stays MIT OR Apache-2.0.
+- **D3** Shared candle helpers are vendored with a NOTICE for now; a shared crate with LightCraft can follow.
+- **D4** Weights are never hosted or bundled by us: direct from Hugging Face, a mirror, or a user folder, with the SHA-256 pinned in the registry.
+- **D5** SAM 2 is opt-in at first; it becomes the default for tracking only after the benchmark shows it should.
+- **D6** Hand-written kernels (the MobileSAM way) remain the Phase 6 route for AMD GPUs if candle cannot get there.
+
+## Consequences
+Without the model installed nothing changes. Every ported file carries Apache-2.0 §4(b) modified-work headers.
diff --git a/docs/agents.md b/docs/agents.md
index aae8be12c..34162aacd 100644
--- a/docs/agents.md
+++ b/docs/agents.md
@@ -4,6 +4,10 @@ Everything in EffectCraft is an engine command with a stable id and JSON params.
 panel gestures, the CLI, the control channel and MCP all go through the same commands, so anything a
 user can do, an agent can do too. There are three ways in:
 
+Render-queue outputs cannot replace footage, proxies or the project file. See
+[render source protection](file-format-parity.md#render-source-protection) for aliases, default names and sequence
+limits. This guard does not change ordinary-file overwrite defaults or add another confirmation API.
+
 | Interface | Best for | Needs a window |
 |---|---|---|
 | **MCP** (`effectcraft-cli mcp`) | Claude Code and other MCP clients | no (headless), or yes with `--bridge` |
@@ -54,13 +58,13 @@ The release packages ship `effectcraft-cli` alongside the desktop app, so no bui
 
 | Install | CLI |
 |---|---|
-| Windows (MSI) | `C:\Program Files\EffectCraft\effectcraft-cli.exe` by default (wherever you installed it otherwise), not on `PATH` |
+| Windows (MSI) | `%LOCALAPPDATA%\Programs\ArtCraft\EffectCraft\effectcraft-cli.exe` by default (`C:\Program Files\ArtCraft\EffectCraft\effectcraft-cli.exe` for an all-users install, under `Program Files (x86)` instead for the 32-bit build, or wherever you installed it otherwise), not on `PATH` |
 | Linux (deb, rpm) | `/usr/bin/effectcraft-cli` |
 | macOS | the separate `effectcraft-cli-<version>-macos-<arch>.zip` release asset (the `.app` holds only the desktop app) |
 
 ```sh
-# Windows, default install folder
-claude mcp add effectcraft -- "C:\Program Files\EffectCraft\effectcraft-cli.exe" mcp
+# Windows (PowerShell), default install folder
+claude mcp add effectcraft -- "$env:LOCALAPPDATA\Programs\ArtCraft\EffectCraft\effectcraft-cli.exe" mcp
 # Linux, or macOS with the CLI unzipped onto PATH
 claude mcp add effectcraft -- effectcraft-cli mcp
 ```
@@ -101,17 +105,17 @@ See [MCP conventions](mcp.md) for core tools, resources, strict arguments, and r
 
 | Tool | What it does |
 |---|---|
-| `list_commands {filter?, enabled_only?, schemas?}` | Discover command ids, their param docs (and, with `schemas`, a JSON Schema each), and whether each can run now. |
+| `list_commands {filter?, enabled_only?, schemas?, compact?}` | Discover command ids, their param docs (and, with `schemas`, a JSON Schema each), and whether each can run now; `compact` lists only ids and labels (and overrides `schemas`). |
 | `describe_command {command \| id}` | One command in full: label, menu, shortcut, params doc, JSON `schema`, enabled / `why`. |
 | `execute_command {command \| id, params?}` | Run any command (undoable). Unknown parameter keys are rejected with the accepted list. |
 | `get_state` | Editor state (active comp, time, selections, tool) plus `app`: version, command and effect counts, export formats, parity summary. |
 | `run_script {code, name?}` | Run JavaScript with the After Effects-style scripting object model (`app.project`, `comp.layers.addText(…)`, `layer.property("ADBE Transform Group").property("ADBE Position").setValueAtTime(…)`…). Returns `{ok, result, output, error: {message, line, column}}`; edits are undoable. |
 | `get_project` / `get_comp {comp?}` | Project items, comp settings and layers. |
 | `get_layer {layer, comp?, time?, depth?, flat?}` | A layer's property tree (`depth` limits how many group levels expand). Every node has a `path`. |
-| `get_property {layer, path, comp?, time?}` | A leaf property's value at a time, keyframes and expression. Group paths (for example `geometryOptions`) contain children: inspect them with `get_layer`, then query a leaf such as `geometryOptions/extrusionDepth`. |
+| `get_property {layer, path, comp?, time?}` | A leaf property's value at a time, keyframes and expression; a popup (enum) property adds `options` (`[{value, label}]`, zero-based values, also in `get_layer`). Group paths (for example `geometryOptions`) contain children: inspect them with `get_layer`, then query a leaf such as `geometryOptions/extrusionDepth`. |
 | `set_property {layer, path, value?, time?, timeBase?, expression?, comp?}` | Sets a static value. With `time` it sets a keyframe (`timeBase: "comp"` for comp seconds); with `expression` it sets an expression. |
 | `add_keyframe {layer, path, time+value \| keys:[...], timeBase?, interpolation?, comp?}` | Adds keys (layer seconds, or comp seconds with `timeBase: "comp"`), then optionally applies linear/bezier/hold/easyEase. |
-| `list_effects {filter?}` | Effect ids, names, categories, GPU / 32-bpc support and parameters. |
+| `list_effects {filter?, compact?}` | Effect ids, names, categories, GPU / 32-bpc support and parameters; `compact` lists only ids, names and categories. |
 | `list_fonts {query?, variable?, rescan?}` | Font families text layers can use, bundled and installed, with their styles, origin, whether each is a variable font and own-language name; `variable` lists only variable fonts; `rescan` picks up fonts installed since launch. |
 | `add_effect {layer, effect, values?, comp?}` | Apply an effect and set its parameters in one call and one undo step (a failing value leaves nothing applied); returns the instance path (`effects/#n`) and its parameter paths. |
 | `render_frame {comp?, time?, max_side?, path?, inline?, transparent?}` | Returns a PNG image of a frame; `transparent: true` keeps the alpha (as an RGB + Alpha render writes it) instead of compositing over the comp background. |
@@ -212,8 +216,25 @@ Things that tripped up a long agent-driven session (a multi-scene 3D piece built
   or call `save_project {"path": …}` after each milestone.
 - **Environment light.** `layer.newLight` also accepts `"kind":"Environment"`: an equirectangular
   image that metallic surfaces reflect. Set its `lightOptions/source` to a footage, comp or solid
-  layer by layer id; with no source it uses the comp's Environment Layer (`layer.environment`)
-  ([#261](https://github.com/storytold/effectcraft/issues/261)).
+  layer by layer id; with no source it uses the comp's Environment Layer (`layer.environment`),
+  or a default studio environment — bright above and toward the initial camera, dark below and
+  behind, at a dim 0.3 mean level — of the light's colour × intensity when there is none; either
+  way the light brightens the scene. A selected Source or Environment Layer that fails to
+  render — a deleted layer, missing footage — lights nothing instead: the light never silently
+  falls back to the studio default. It has `castsShadows`/`shadowDarkness`/`shadowDiffusion`
+  like the other lights: Cast Shadows shades the scene from the image's dominant bright region
+  (the default environment's key, or a source image's brightest area; an image without a
+  sufficiently strong dominant direction has none — a uniform one, or opposing bright regions
+  that cancel — so it casts no shadow) — the region weighted by the light's colour, so a
+  coloured light shadows from the regions it actually lights (opposing red and blue regions
+  cancel to a white light, but a red light's shadow comes from the red one) — occluding only
+  that key's share of the light, so the
+  shadow stays partial like After Effects' area-light shadows, and soft by default (a penumbra
+  of at least 8 pixels or four map texels, plus Shadow Diffusion). It only lights
+  Advanced 3D comps, so creating one (or changing a light's type to Environment) switches a
+  Classic 3D comp to Advanced 3D
+  ([#261](https://github.com/storytold/effectcraft/issues/261),
+  [#2436](https://github.com/storytold/effectcraft/issues/2436)).
 
 ### Cookbook (from end-to-end QA)
 
@@ -272,10 +293,10 @@ build real projects through these interfaces; they are worked examples of everyt
   then `keys.velocity {"outSpeed":0,"outInfluence":33.33}`.
 * **Gradients**: `set_property {"path":"contents/gfill/colors","value":["#0080ff","#ffff00"]}` or
   `{"colors":[[0,"#0080ff"],[1,[1,1,0]]],"opacities":[[0,1],[1,0.5]]}`.
-* **Image sequences**: `file.import {"paths":["/r/shot_0001.png"]}` imports the file's whole
-  numbered run as one item (several picked frames: that range; a folder: each run in it;
-  `"sequence": false`: one still; dropped files, `"drag": true`, import as stills unless
-  `"sequence": true`, as in After Effects; `"alphabetical": true`: Force Alphabetical Order, the files
+* **Image sequences**: `file.import {"paths":["/r/shot_0001.png"], "sequence": true}` imports the
+  file's whole numbered run as one item (several picked frames: that range; a folder: each run in
+  it, also without `sequence`). Without `"sequence": true` a picked or dropped numbered file imports
+  as one still, as in After Effects; `"alphabetical": true`: Force Alphabetical Order, the files
   play one after another) at `frameRate` or 30 fps (Settings ▸ Import). Missing frames show
   colour bars, as in After Effects. `file.interpretFootage {"items":[id], "frameRate":12,
   "startTimecode":1001}` conforms them and sets Override Start (the item and layers that ran to its end get the new
@@ -298,6 +319,28 @@ build real projects through these interfaces; they are worked examples of everyt
   proresProfile: 4444, output}` then `renderQueue.render {"wait": true}`. Check a render by
   importing it (`file.import`, `file.newCompFromSelection`) and `render_frame {transparent: true}`
   for its alpha (ProRes 4444 and WebM VP9 alpha both read back as straight alpha).
+  **A render never writes one file twice either:** when two outputs of the job (two items, a
+  `renderQueue.duplicate` copy, output modules, segments) name the same file, the whole render is
+  refused before anything is written, naming both items. Sequences clash only on frames both
+  write. A later item with Skip Existing Files leaves the earlier one's frames alone only when
+  the exporter can check the final destination. Browser/memory sinks and storage-overflow renders still report collisions.
+  Preflight compares every configured overflow destination, since available space can change during a render. Default
+  names are numbered like footage collisions when another queue item writes them
+  (`renderQueue.add`, `render.preRender`, `comp.saveFrameAs {queue}`, `file.createProxy`: a second
+  `Main` renders to `Main_1.mp4`); a name you give is kept, and `renderQueue.duplicate` copies the
+  output as it is, so change one with `renderQueue.setOutput` or turn it off.
+* **Other files written to a path you give** follow the same footage rule, with no flag and no
+  prompt: `comp.saveFrameAs` (also `…Psd`, `…Exr`), `file.exportLottie`, `file.saveCopy`,
+  `file.saveCopyAsXml`, `file.collectFiles` (every copy and the collected project; nothing is
+  written if one would land on a file the project reads), `file.exportTimeline` (and the movies it
+  pre-renders), `essential.exportTemplate`, `anim.savePreset`, `view.exportGuides`,
+  `shortcuts.export`, the control channel's `render.frame` / `ui.screenshot` with a `path`, the
+  MCP `render_frame` tool and `effectcraft-cli render-frame --out`. Footage (every frame of a
+  sequence), a proxy and the project file are refused with the reason and left untouched.
+  `file.checkOutput {path}` says beforehand (`{blocked, source, reason}`). Not covered: Save /
+  Save As / Increment and Save / auto-save (they write the project's own file), script `File`
+  writes (a script may rewrite a data file it also imports), and files the app extracts for
+  itself (template media, vector images).
 * **Essential Graphics**: controls can be addressed by name (`essential.set {"layer":"#1",
   "control":"Title","value":"John Smith"}`); a command that targets an explicit `comp` runs even
   when the active comp would disable it (`essential.exportTemplate {"comp":"Lower Third", …}`).
@@ -374,8 +417,9 @@ Face tracking's trained model works like Roto Brush's (below): `face.models` lis
 tracker and MediaPipe Face Landmarker with its authors and licence; `face.model.download {id}` /
 `face.model.install {path, id?}` install it (verified); `face.model.select {id:
 classical|mediapipe-face}` chooses it; `face.model.remove {id}` deletes it. Downloads and loading
-run in the background; `"wait": true` on download, install or select returns once the model is in
-use (or with its error), which scripts need before tracking. `track.mask` with a
+run in the background; `"wait": true` waits for the requested operation (or returns its error).
+Download/install do not change the selected model. After installing, use
+`face.model.select {id, wait:true}` to select and load it before tracking. `track.mask` with a
 face method returns `faceModel`, the engine it tries first (the classical one when the model finds
 no face in the mask).
 
@@ -446,7 +490,12 @@ and Origin), `camera.createFromSolve {kind: text|solid|null|shadowCatcher, point
 {center, normal, size?}, multiple?}` (Create Text / Solid / Null / Shadow Catcher, Camera and Light,
 Create Multiple …), `camera.deletePoints {points?, wait?}` (re-solves; with Auto-delete Points
 Across Time the same feature's other tracks go too) and `camera.create` (the Create Camera button).
-Each is one undo step; the first create adds the one-node "3D Tracker Camera" keyed on every frame.
+Each edit is one undo step; the first create adds the one-node "3D Tracker Camera" keyed on every frame.
+
+`camera.exportBlender {path: ".py", layer?, effect?, sensorWidth?: 36, unitScale?: 0.01,
+startFrame?: 1, includePoints?: true}` exports the solve as an executable Blender scene script:
+baked camera/lens/focus, synced video background, points and ground. See
+[Blender camera export](blender-camera-export.md) for framing, assumptions and limitations.
 Changing the layer's frames clears the analysis; changing `effects/#1/shotType`,
 `effects/#1/horizontalAngleOfView`, `effects/#1/advanced/solveMethod` re-solves the stored tracks.
 
@@ -477,11 +526,22 @@ reference. Matte settings are ordinary properties (`effects/#1/rotoBrushMatte/se
 
 Trained model (Roto Brush 2.0 / 3.0):
 - `roto.models` lists the built-in engine and every registered model, with its authors,
-  licence, size, URL, SHA-256 and whether it is installed, selected and active.
-- `roto.model.download {id}` fetches and verifies the official weights in the background;
-  `roto.model.install {path, id?}` installs a file you already have.
-- `roto.model.select {id: classical|mobilesam}` chooses which one Roto Brush uses. Loading runs
-  in the background; `"wait": true` (also on download and install) returns once it is in use.
+  licence, size, app download URL (empty for install-only models), checkpoint `source` and `sourceFile`,
+  SHA-256 and whether it is installed, selected and active.
+- `roto.model.download {id}` fetches and verifies weights when the registry provides an app download URL;
+  `roto.model.install {path, id?}` installs a file you already have. SAM 2 is Install from File only until
+  a storytold-controlled mirror is available; its size and SHA-256 are verified before installation.
+- `roto.model.select {id: classical|mobilesam|sam2.1-hiera-tiny|sam2.1-hiera-small|sam2.1-hiera-base-plus|sam2.1-hiera-large}` chooses which one Roto Brush uses (SAM 2 also tracks the object through the clip, see [roto-brush-sam2.md](roto-brush-sam2.md); `roto.status` then reports `source` and per-frame `tracker.frames` with `confidence` and `occluded`). Loading runs
+  in the background. `"wait": true` waits for the requested operation; download/install load the model
+  only if it is already selected. They do not activate an unselected model: after installation, use
+  `roto.model.select {id, wait:true}` to select and load it. Unrelated model work can return a retryable
+  busy error rather than reporting that a waiting selection has finished.
+- `roto.propagate` never falls back to the classic engine silently: a chosen model that is not installed, or failed
+  to load, is an error, and without `"wait": true` so is a model still loading. `roto.status` reports `model`
+  (`selected`, `installed`, `active`, `loading`, `error`) and a `notice` while the chosen model is not the one in use.
+  Tracked frames are saved in the project with the instance (`tracker.saved` names their model): they apply while the
+  strokes and span are unchanged, whichever model Settings choose (`notice` says when that differs), and a new
+  Propagate replaces them.
 - `roto.model.remove {id}` deletes the installed weights.
 - The `version` property (`effects/#1/version`: 0 = 1.0, 1 = 2.0, 2 = 3.0) picks between the
   classic engine (1.0) and the chosen model (2.0, 3.0).
@@ -540,7 +600,7 @@ indices): character attributes
 3. `layer.setText {"range":[6,11], "size":40, "fill":"#ff5500"}` styles the selection (the
    Character panel does the same); with an empty range it sets the style the next typed text takes.
 4. `edit.copy`, `edit.paste`, `edit.pasteTextMatchFormatting` and `edit.pasteTextFormattingOnly`
-   work on the selected text; `text.endEdit` commits (an empty Type-tool layer is removed).
+   work on the selected text; `text.endEdit` commits (an empty Type-tool layer is kept, as After Effects does).
 
 Fonts: `text.fonts` (MCP `list_fonts`) lists every family a text layer can use, bundled and installed, with its
 styles, origin (`bundled`, `system`, `user`), `variable` (it has variation axes) and own-language name
@@ -583,7 +643,9 @@ A dialog's `show()` waits for the user: the `script.run` / `file.runScript` repl
 `"waiting": true`, and the script continues (its final output arrives in the reply of the click
 that closes the dialog). File ▸ Scripts: `file.scripts.list`, `file.runScript {"name": …}`,
 `file.installScript` / `file.installScriptUIPanel {"path": …}`, `window.scriptPanel {"name": …}`,
-`window.restoreScriptPanels` (the panels open when the app last quit). Scripts' `app.settings`:
+`window.restoreScriptPanels` (the panels open when the app last quit), `file.runStartupScripts` and
+`file.runShutdownScripts` (the scripts in `Scripts/Startup` and `Scripts/Shutdown`; the second closes
+the project first). Scripts' `app.settings`:
 `script.settings.get {"section": …, "key": …}` and `script.settings.save {…, "value": …}`.
 Extension points and the bundled extensions: [plugins.md](plugins.md).
 
@@ -614,12 +676,21 @@ Extension points and the bundled extensions: [plugins.md](plugins.md).
   Display Style between Timecode and Frames: `file.projectSettings {"timeDisplay": "frames"}`.
 * `prop.pickWhip {layer, prop, target: {layer, prop, dimension?}}` links a property as its
   expression pick whip does; `dimension` picks one of the target's values (`position[0]`), as a
-  drop on that value field does.
+  drop on that value field does. `byIndex: true` (an Alt pick whip: Alt held as it drops) refers
+  to an effect's properties by their index, `effect("Color Control")(1)`: it still reads a
+  renamed property, but another one if properties are reordered.
 * Every property row has a property pick whip in the Parent & Link column
   (`timeline.prop.<uid>.propertyPickWhip`; the expression row's is `timeline.prop.<uid>.pickWhip`).
   Dragged onto another property's name or value, in the Timeline or Effect Controls
   (`effectControls.prop.<uid>.value[.<d>]`), it runs `prop.pickWhip`: the reference replaces the
   property's expression, or is added as one, and the expression is enabled.
+* Parent and Track Matte for several layers: on a selected layer's row, the Timeline's Parent
+  menu and pick whip (`timeline.layer.<id>.parent`, `timeline.layer.<id>.pickWhip`) and its Track
+  Matte menu and pick whip (`timeline.layer.<id>.trackMatte`,
+  `timeline.layer.<id>.trackMattePickWhip`) set every selected layer's (on an unselected row,
+  that layer's), in one undo step. Directly: `layer.setParent {layers, parent}` and
+  `layer.setTrackMatte {layers, matte, kind}`, where `kind: "preserve"` keeps each layer's
+  own matte mode.
 * A property's menu (right-click its name; entries `timeline.prop.<uid>.menu.<entry>`): Reset
   (`prop.reset`: no expression, and the property's default value, an effect parameter's or a
   Transform property's; an animated property keeps its keyframes and gets the default as a
@@ -680,6 +751,19 @@ effectcraft-cli exec file.importLottie '{"path":"anim.json"}' main.ecproj --save
 effectcraft-cli render main.ecproj --comp Main --out main.mov --format prores --progress   # progress lines on stderr for a program that reads them
 ```
 
+A long `run` doesn't fit on a command line (Windows caps it at 32 767 characters, Linux one
+argument at 128 KiB). `run --args-file F` reads the same `<id> <json>` arguments one per line;
+`run --commands FILE` reads steps as a JSON array of `{"command": ID, "params": {…}}` objects, or one
+such object per line (JSON Lines), and `--commands -` reads them from standard input. `--commands`
+may be repeated; its steps run after the positional pairs and `--args-file`. A malformed step is a
+usage error naming its index (from 0, as in the results) before anything runs, and the error of a step
+that fails ends with `(step N)`:
+
+```sh
+effectcraft-cli run --commands steps.json --empty --save-as main.ecproj
+generate-steps | effectcraft-cli run main.ecproj --commands - --save --json
+```
+
 Scripts written against After Effects' documented scripting API run with `script`:
 
 ```sh
diff --git a/docs/architecture.md b/docs/architecture.md
index d3dd4db69..c4bebd9ed 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -1,6 +1,6 @@
 # Architecture
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-10 · **Change:** minor (crate table checked against `crates/`: effect count 306, VP9 inter frames) · **Target:** Adobe After Effects 2026
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-29 · **Change:** minor (SAM 2 crate added to the layer table) · **Target:** Adobe After Effects 2026
 
 EffectCraft is a stack of small Rust crates. The engine knows nothing about the user interface;
 the egui frontend, the command-line tool and the MCP server all sit on top of the same `Session`
@@ -37,8 +37,9 @@ cpal or muda. Everything in L0 to L4, the egui UI and the web app also build for
 | L3 | `render` | Evaluation and compositing: sources, masks, effects, transforms, 3D, motion blur, mattes, blending, layer cache, audio mixdown |
 | L3 | `media` | Footage decoding (FilmCraft's pure-Rust codecs), image sequences, Photoshop and SVG stills, frame cache |
 | L3 | `expr` | The expression engine (JavaScript via boa) with the After Effects object model |
-| L3 | `export` | Render queue encoding: H.264, HEVC and AV1 MP4, ProRes, WebM (VP9 + alpha or AV1, Opus), PNG/JPEG/TIFF/EXR sequences, GIF, WAV/AIFF |
+| L3 | `export` | Render queue encoding: H.264, HEVC and AV1 MP4, ProRes, WebM (VP9 + alpha or AV1, Opus), PNG/JPEG/TIFF/EXR/Targa sequences, GIF, WAV/AIFF |
 | L3 | `gpu` | The GPU compositor and GPU effects on wgpu compute shaders (Metal, Vulkan, Direct3D 12, WebGPU), checked against the CPU renderer |
+| L3 | `sam2` | SAM 2.1 image segmentation and video object tracking for Roto Brush, with candle CPU inference and optional wgpu acceleration; native only, empty on wasm32, with user-installed weights |
 | L3 | `interchange` | Premiere Pro interop through timeline interchange (FCP7 XML, FCPXML, OTIO, EDL, AAF, OMF via FilmCraft's `filmcraft-interchange`): sequences ↔ compositions (§6a) |
 | L3 | `lottie` | Lottie JSON / dotLottie import and export (layers, precomps, eased and spatial keyframes, shapes, masks, mattes) with a warnings list for what Lottie cannot express |
 | L3 | `plugin` | Effect plug-ins: loads sandboxed WebAssembly effect modules (plug-in API v1; the wasmi interpreter behind the `wasm` feature, on for native hosts) into the effect registry ([plugins.md](plugins.md)) |
@@ -158,9 +159,22 @@ comp to Advanced 3D in the same undo step, as in After Effects. Shading is physi
 GGX specular, Smith–Schlick geometry, Schlick Fresnel, Lambert diffuse, after Karis 2013):
 parallel, spot and point lights with After Effects' falloffs, ambient lights, image-based
 light from an Environment light whose Source (or the comp's Environment Layer, Layer ▸
-Environment Layer) is an equirectangular image (cosine irradiance map; roughness-indexed mip
-chain with the split-sum environment BRDF fit), and percentage-closer-filtered shadow maps
-(spot: perspective, parallel: orthographic over the scene, point: six cube faces). Cards keep
+Environment Layer, or a default studio environment — bright above and toward the initial
+camera, dark below and behind, at a dim 0.3 mean level — of the light's colour × intensity
+when there is neither) is an equirectangular image (cosine irradiance map; roughness-indexed
+mip chain with the split-sum environment BRDF fit), and percentage-closer-filtered shadow maps
+(spot: perspective, parallel: orthographic over the scene, point: six cube faces, environment:
+one orthographic from the image's dominant bright region — none only when the image lacks a
+sufficiently strong dominant direction (a uniform one, or opposing bright regions that
+cancel) — the region weighted by the light's colour, so a coloured light shadows from the
+regions it actually lights (opposing red and blue regions cancel to a white light, but a red
+light's shadow comes from the red one) — occluding only the image's directional key fraction of
+the light, so the shadow stays partial like After Effects' area-light shadows, with a soft
+default penumbra of at least eight pixels or four map texels). A Source or Environment Layer
+that fails to render — a deleted layer, missing footage — lights nothing: no silent fallback
+to the default studio environment. An Environment light only lights Advanced 3D comps,
+so adding one (or changing a light's type to it) switches a Classic 3D comp to Advanced 3D,
+as model layers do. Cards keep
 Material Options (Accepts Lights/Shadows, Casts Shadows On/Only, Ambient, Diffuse, Specular);
 models and primitives add Base Color, Metallic, Roughness, Emissive. Rasterisation runs at 2×2
 supersampling with a reversed-Z depth buffer; opaque triangles resolve visibility first, the
@@ -243,7 +257,10 @@ the layer body. Interior styles are clipped to the layer: they blend onto its co
 shape and keep its alpha, so an anti-aliased edge mixes the style and the background only. Layer
 opacity fades the whole stack; Knockout and the R/G/B channel switches apply at composite time. Styled pixels are cached separately from the layer content, so editing a style
 reuses the cached source/masks/effects. Global Light is one setting per comp, mirrored into every
-layer's Blending Options and kept in step after each edit.
+layer's Blending Options and kept in step after each edit. Blending Options can be edited in the Layer Style dialog
+before any style is added: the first change creates the Layer Styles group with Blending Options
+only (`layer.style.add` with `blendingOptions`), in the same undo step as the change. Removing
+the last style keeps the group when its Advanced Blending is not at the defaults.
 
 **Paint and Puppet** are effects whose instances carry nested groups. Paint (`effects::paint`)
 holds Brush / Clone / Eraser strokes (Path, Stroke Options, Transform, hidden Duration span);
@@ -345,7 +362,10 @@ as NaNs (a kernel that skips pixels fails the oracle) and validation errors pani
 (`ui-egui::frames`); headless renders, the CLI (unless `--gpu`) and CI use the CPU. Outside
 tests, device errors are logged rather than fatal. A viewer frame that runs out of video memory
 (`Gpu::within_memory`) renders on the CPU, the uploaded layers and pooled textures are freed, and
-the RAM preview keeps half as many GPU frames from then on. A frame whose render panics is
+the RAM preview keeps half as many GPU frames from then on. The same guard catches a frame's
+validation errors (an invalid texture, often left by a failed allocation): that frame renders on
+the CPU and the kept textures are freed, but the compositor stays on and, with no allocation
+failure before it, the RAM preview keeps its GPU frames (#1319). A frame whose render panics is
 rendered again on the CPU or released, never left in progress. Native readbacks and timing waits
 share a finite deadline; failure retires pending readbacks exactly once, and late results are
 discarded. The desktop executable and browser page own their shared device's error/loss handlers and forward
@@ -368,6 +388,13 @@ Playground cannons without interacting forces evolve every particle independentl
 backend (reached through `EffectHost::particles` when the GPU compositor is active) simulates one
 particle per invocation from the CPU's birth schedule and keeps per-key state checkpoints on the
 GPU, like `SimCache`; the CPU simulation stays the oracle (tests compare ids and positions).
+CC Particle World, CC Particle Systems II and CC Mr. Mercury sample their Birth Rate at every
+step (`EffectHost::param_at`, #1373), so a keyed rate only decides the births of its own time;
+the rate is left out of the simulation key, and a checkpoint is resumed only with the same rate history (the CPU state's `hist`, the GPU
+checkpoint's births). The rate's keyframes are read at the step's exact layer time
+(`EvalCtx::value_at_layer_time`; mapping it to comp time and back rounds under a fractional
+stretch), a rate without keyframes or an expression isn't sampled, and a layer of one of them with
+expressions isn't layer cached (its key can't see what an expression returned at earlier times).
 `effectcraft-cli bench --gpu` reports CPU vs GPU ms/frame, speed-up, Auto's ms/frame, pixel
 agreement and the steady-state upload / readback MB per frame for every comp plus an
 adjustment-layer comp.
@@ -391,7 +418,10 @@ hierarchical block-matching optical flow and a bidirectional warp (Pixel Motion,
 its nested layers straight into the parent with concatenated transforms (one resample), so
 nested blend modes and adjustment layers act on the parent's layers; nested 3D layers use the
 parent's camera and lights and, when the precomp layer is 3D, are depth-sorted with the parent's
-3D run. Masks, effects or styles force a flattened render. Text layers are always rasterised at
+3D run. Essential Properties overrides (properties, Font and Media Replacement) travel with the
+collapsed context and are applied while the nested layers are evaluated, so they do not force a
+flattened render or clip at the precomp's frame. Masks, effects or styles force a flattened
+render. Text layers are always rasterised at
 their on-screen scale, as text is vector in After Effects; on shape layers and vector footage the
 switch is Continuously Rasterize and does the same. Quality: Draft samples
 nearest-neighbour, Wireframe draws the layer bounds. Slip edit (`layer.slip`, Alt+PageUp/Down,
@@ -458,8 +488,10 @@ effects crate, hence the `effects → track` edge.
 `essential` field lists its exposed controls (properties, Media Replacement, groups, comments).
 Every precomp layer of such a comp gets an Essential Properties group (`GroupKind::Essential`,
 children `eg<control id>`), kept in step by `Session::edit`; editing a child overrides it for
-that instance. The renderer draws an instance with overrides from a copy of the project with the
-overridden source properties set (`essential::with_overrides`). Templates are `.ectemplate`
+that instance. A collapsed instance carries its property, Font and Media Replacement overrides
+into the nested render context (`Collapsed`, `EvalCtx::{property_overrides, media_overrides}`);
+other instances are drawn from a copy of the project with the overridden source properties set
+(`essential::with_overrides`). Templates are `.ectemplate`
 ZIPs: `manifest.json` (controls), `project.ecproj` (the comp and its dependencies), `media/…` and
 `poster.png`; importing offsets every id past the project's (`essential::offset_ids`).
 **Responsive Design — Time**: a time-stretched precomp maps time piecewise so its protected
diff --git a/docs/blender-camera-export.md b/docs/blender-camera-export.md
new file mode 100644
index 000000000..d102eef4f
--- /dev/null
+++ b/docs/blender-camera-export.md
@@ -0,0 +1,101 @@
+# Exporting a tracked camera to Blender
+
+After the **3D Camera Tracker** finishes solving, click **Export Scene to Blender...** in its
+Effect Controls and save the `.py` file. In Blender 4.0 or newer, open it in the Scripting
+workspace's Text Editor and choose **Run Script**. The script creates and activates a new scene;
+it preserves existing scenes and objects. Save the resulting `.blend` normally.
+
+The script uses Blender's public Python API, with no add-on or Python dependencies beyond
+Blender itself. For unattended use: `blender --background --python "Tracked Scene.py"`.
+That imports the scene in memory; it does not automatically save a `.blend`.
+
+## Transferred data
+
+- Camera position and quaternion rotation baked on every analyzed frame, with consistent
+  quaternion signs and linear interpolation; zoom/lens animation, including Variable Zoom.
+- Tracking input/video resolution, horizontal sensor fit, exact rational composition FPS,
+  frame range and composition markers within the analyzed interval. The first analyzed frame
+  becomes Blender frame 1 by default; the original composition timestamps remain in metadata.
+- The original video or still as the camera's background image, at full opacity, refreshed on
+  frame changes. Source-frame offsets are baked too, accounting for trim, stretch, source FPS
+  and Time Remap. This is a viewport background, not a render/compositor background.
+- Focus distance, DOF switch, f-stop, iris blade count, rotation and aspect sampled from the
+  tracker's linked **3D Tracker Camera**, including keyframes and expressions. Create that
+  camera and adjust its Camera Options before exporting to transfer custom focus settings.
+- Solved 3D points as a non-rendering vertex mesh, with point attributes for track ID,
+  reprojection error and first/last visible frame. A chosen ground plane becomes Blender's XY
+  plane, with its origin preserved and a non-rendering wire plane as a placement guide.
+- Shutter duration (not automatically enabled), plus the original shutter phase in metadata.
+- A Blender Text datablock named `EffectCraft Tracking Metadata.json` containing the complete
+  solve, optional original 2D tracks, per-frame timings, source interpretation, diagnostics and
+  export warnings. Radial distortion coefficients are also camera custom properties.
+
+Coordinates are converted from EffectCraft's right/down/forward world to Blender's
+right/forward/up world, including the camera's local up and negative-Z viewing direction.
+Export uses the tracking input's framing, not the footage layer's final 2D placement in the
+composition. Camera pose and lens always come from the solve; subsequent manual pose/lens edits
+on the linked camera are not substituted for the tracked motion.
+
+## What cannot be inferred
+
+Monocular tracking cannot recover absolute scene scale, physical sensor size, optical focus,
+f-stop or exposure from feature tracks. The default sensor width is an assumption of **36 mm**;
+the focal length in millimeters is derived from it while preserving the solved field of view.
+The default scale is **0.01 Blender units per composition-world pixel**, not a measurement.
+Without a linked camera, DOF is disabled and focus distance uses the default solved scene depth.
+Blender's physical DOF approximates EffectCraft's blur model: Blur Level and Iris Roundness are
+retained in metadata, but have no direct Blender equivalent.
+
+Brown-model radial `k1`/`k2` coefficients use radius normalized to half the image diagonal.
+They are preserved, **not** assigned to Blender's different lens-distortion model. For a precise
+match when distortion is nonzero, use an undistorted plate; the script prints a warning.
+The tracker assumes square pixels, so Blender renders square pixels; any non-square source
+interpretation is retained in metadata and flagged.
+
+The `.py` references the video; it does not contain a copy of the video's bytes. When moving it,
+keep the video next to the script (same filename), or relink the background image in Blender.
+Missing/unsupported media produces a warning while retaining the imported camera and geometry.
+Masks and effects applied before the tracker are not baked into the original media. Export
+requires a direct video/still footage layer at the analyzed size; render precomps, sequences or
+size-changing preprocessing to a video and track that video first.
+
+## Agent / control-channel command
+
+```json
+{
+  "command": "camera.exportBlender",
+  "params": {
+    "layer": "#1",
+    "path": "/output/Tracked Scene.py",
+    "sensorWidth": 36,
+    "unitScale": 0.01,
+    "startFrame": 1,
+    "includePoints": true
+  }
+}
+```
+
+`comp`, `layer` and `effect` select the tracker as with `camera.analyze`. Without explicit
+selection, the selected tracker (or first tracker in the composition) is used. `sensorWidth`,
+`unitScale`, `startFrame` and `includePoints` are optional. The reply contains file size,
+exported frame/point counts and warnings. Writing uses the host's atomic file service.
+Calls issued by scripts require **Allow Scripts to Write Files and Access Network** in
+Settings ▸ Scripting & Expressions. Export from the UI or control channel remains available
+with that preference off.
+
+Export is limited to 100,000 analyzed frames, 100,000 points and 64 MiB of serialized scene data;
+invalid, stale or incomplete solves return an actionable error without modifying the document.
+
+## Verification
+
+Engine tests check argument validation, escaped/Unicode paths, fractional FPS, trim/stretch,
+focus/f-stop, zoom, ground placement, malformed solves and write failures. To additionally run
+the generated artifact against an installed Blender's public API:
+
+```sh
+EFFECTCRAFT_BLENDER=/path/to/blender cargo test -p effectcraft-engine tests::blender -- --nocapture
+```
+
+Optionally set `EFFECTCRAFT_BLENDER_PLATE` to a local synthetic 640×360 video to exercise media
+loading and source-frame offsets. The oracle checks every synthetic point's projection through
+the imported camera on every frame, as well as animation, DOF, timing and scene preservation.
diff --git a/docs/contributors.md b/docs/contributors.md
index 6b8a81e01..c6746dc17 100644
--- a/docs/contributors.md
+++ b/docs/contributors.md
@@ -1,16 +1,14 @@
 # Contributors in the About window
 
 **About ▸ Contributors** credits everyone who contributed to EffectCraft, and **About ▸ Models** credits
-the AI models named in `Co-Authored-By` trailers. This follows the shared craftrules standard
-[`standards/contributors.md`](https://github.com/storytold/craftrules/blob/main/standards/contributors.md);
-this page is the local copy of the decision.
+the AI models named in `Co-Authored-By` trailers.
 
 ## Decision
 
 - Two files, both **compiled into the binary** by the UI crate's `build.rs` (nothing is read from
   disk or the network at run time; the web build has them too):
   - [`contributors/contributors.json`](../contributors/contributors.json): commit stats per GitHub
-    username. **Generated** by `craftrules/scripts/contributors.py`; never hand-edit.
+    username. Never hand-edit.
   - [`contributors/people.toml`](../contributors/people.toml): the names people chose for
     themselves. **Each contributor adds only their own entry**, in their own PR.
 - Each contributor gets one line: GitHub username (always), display name (opt-in, or their synced
@@ -36,20 +34,5 @@ display_name = "Nickname"
 sync_github_name = true   # use the name on your public GitHub profile as display name
 ```
 
-or, with craftrules checked out next to `craft-apps/`:
-
-```sh
-python3 ../../craftrules/scripts/contributors.py --add-me . --real-name "Your Name" --sync-github-name
-```
-
-Names show after the next refresh: the script checks that each entry was committed by its own
-user (or by a maintainer with a `consent_source`). Delete your entry to remove your names.
-
-## Refreshing (maintainers)
-
-```sh
-python3 ../../craftrules/scripts/contributors.py .           # regenerate + verify; needs git, Python 3.11+, gh
-python3 ../../craftrules/scripts/contributors.py --check .   # verify people.toml only
-```
-
-Commit the updated `contributors/contributors.json`. Git author names and emails are never recorded.
+Names show for entries committed by their own user (or by a maintainer with a `consent_source`).
+Delete your entry to remove your names. Git author names and emails are never recorded.
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index aa5b22f8b..60328099e 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -41,11 +41,11 @@ printf '{"id":1,"method":"engine.execute","params":{"command":"comp.new","params
 | UI commands (via either) | | `timeline.column {column, visible?}` (av, keys, label, num, comment, switches, modes, parent, in, out, duration, stretch), `timeline.sourceName {value?}`, `timeline.search {query}`, `timeline.reveal.<kind>` / `timeline.revealAdd.<kind>` (the property shortcuts and Shift+shortcut: position, scale, rotation, opacity, anchor, effects, masks, feather, levels, animated, and the double-press sets maskPath, maskOpacity, timeRemap, expressions, material, paint, selected, missingEffects, waveform), `timeline.keyAt.<anchor\|position\|scale\|rotation\|opacity>` (Alt+Shift+A/P/S/R/T), `timeline.twirlSelected` ``(Ctrl/Cmd+`)``, `timeline.collapseAll`, `flowchart.options {layers?, effects?, solids?, direction?: lr\|tb, comp?}`, `flowchart.graph {comp?}` → `{nodes, edges}`, `window.workspace {name}` (all After Effects workspaces). |
 | `engine.commands` | `{filter?, enabledOnly?}` | `[{id, label, menu, shortcut, params, enabled, why}]` |
 | `ui.menu.list` | `{}` | The menu tree with enablement. |
-| `render.frame` | `{comp?, time?, max_side?, path?, base64?}` | Renders a comp frame through the session, independent of the viewer zoom or resolution. `comp` is an id or name (default: the active comp), `time` is in comp seconds (default: the CTI), `max_side` caps the longest side (0 = full size). Writes a PNG to `path` (default: a temp file) and returns `{comp, time, width, height, path}`. With `base64: true` it returns `{…, png: "<base64>"}` and writes no file. |
+| `render.frame` | `{comp?, time?, max_side?, path?, base64?, write?}` | Renders a comp frame through the session, independent of the viewer zoom or resolution. `comp` is an id or name (default: the active comp), `time` is in comp seconds (default: the CTI), `max_side` caps the longest side (0 = full size). Writes a PNG to `path` (default: a temp file) and returns `{comp, time, width, height, path}`. With `base64: true` it returns `{…, png: "<base64>"}` and writes no file unless `write: true` also requests a guarded write in the same app operation. |
 
 Useful query commands for `engine.execute` (they aren't journaled or undoable): `project.summary`,
 `comp.info {comp?}`, `layer.tree {layer, comp?, depth?, time?}` (every node has a `path`),
-`prop.get {layer, path, comp?, time?}`, `editor.state`, `command.list {filter?, enabledOnly?, schemas?}`,
+`prop.get {layer, path, comp?, time?}` (a popup (enum) property also lists its `options`, `[{value, label}]`, as `layer.tree` does), `editor.state`, `command.list {filter?, enabledOnly?, schemas?}`,
 `command.describe {command}` (params doc and JSON Schema), `app.capabilities` (version, counts,
 export formats, parity summary), `jobs.list` (Progress panel jobs, e.g. the background
 `footage.check` after File ▸ Open).
@@ -103,7 +103,7 @@ Points are logical window coordinates. A target is `{id}` (the element's centre;
 | `ui.click` | `{id \| x,y, button?: left\|right\|middle, count?, modifiers?}` |
 | `ui.move` | `{id \| x,y}` |
 | `ui.drag` | `{from: target, to: target, steps? (12), modifiers?}`: press, move, release |
-| `ui.scroll` | `{id \| x,y, dx, dy}` |
+| `ui.scroll` | `{id \| x,y, dx?, dy?, unit?: point\|line, source?: wheel\|trackpad, pinch?, modifiers?}`: `line` is a mouse wheel (zooms the viewers); `point` (default) is a pixel-precise scroll; `source: trackpad` pans the viewers (as on macOS); with no `source` the viewers take a scroll in points as a wheel until one moves on both axes (a trackpad: from then on it pans); `pinch` is a trackpad pinch's zoom factor |
 | `ui.key` | `{key}`, for example `Space`, `F9`, `Cmd+Z`, `Cmd+Shift+Z`, `PageDown`, `Escape` |
 | `ui.type` | `{text}`: text input into the focused field |
 
@@ -186,20 +186,65 @@ including outside the layer's `[in, out)` range. Timing metadata carries outside
 `prop.get.time` is comp seconds. For these commands, `path` or `prop` identifies a property, not a group.
 Set a layer's offset with `layer.timing {layer, start}` (comp seconds).
 
-Panel moves, tab ordering, edge splits and floating geometry use shared docking transactions.
-`window.floatPanel` requires exactly four finite numbers when `rect` is supplied. Invalid
-geometry or missing source/anchor panels leaves the layout unchanged. The persisted workspace
-shape is unchanged: accordion open states and explicit heights, floating groups, and dynamic
-viewer/ScriptUI identities remain app data. Pointer drops use the same shared placement rules
-as commands, with floating groups resolved in their actual window stacking order.
+Panels dock in craft-ui's shared docking (`craft_ui::docking`): split frames, tab groups,
+stacked panels and floating windows. Every change, by pointer, menu or command, is one
+transaction that checks the whole result; an invalid one returns an error and leaves the layout
+unchanged. No move or float may leave the docked area empty; closing its last panel is allowed.
+Panels name themselves by id (`"EffectControls"`), by title (`"Effect Controls"`) where a command
+takes a name, or as `{"Viewer":42}` and `{"ScriptPanel":77}` for viewers and ScriptUI panels.
 
-`window.dockAction` accepts `{action}` using the shared docking action's JSON form. It
-covers tab moves and ordering, split and floating geometry, activation, and closing.
-For example, `{"action":{"ResizeSplit":{"path":[],"size":{"FixedFirst":360}}}}`
-resizes the root split; path entries use `false` for the first child and `true` for
-the second. `{"action":{"MoveFloating":{"panel":"Info","rect":[45,65,420,320]}}}`
-repositions and resizes the floating group containing Info. Invalid actions leave the
-layout unchanged. Pointer gestures dispatch through this same catalog command.
-EffectCraft also supports `SetStackOpen` and `ResizeStack`. Dynamic panel identities use
-`{"Viewer":42}` or `{"ScriptPanel":77}` in the action. Closing runs the existing viewer
-and ScriptUI lifecycle callbacks; opening uses the existing panel creation commands.
+- `window.dockAction {action}` applies one craft-ui `Action` in its JSON form. For example,
+  `{"action":{"ResizeSplit":{"path":[],"size":{"FixedFirst":360}}}}` resizes the root split
+  (path entries are `false` for the first child and `true` for the second), and
+  `{"action":{"MoveFloating":{"panel":"Info","rect":[45,65,420,320]}}}` moves and resizes the
+  floating window holding Info. `Open` and `OpenAt` are refused: panels open through the panel
+  commands (`window.panel`, `ui.panel.show`), which run the viewer and ScriptUI lifecycles.
+  Closing runs them too. Pointer gestures dispatch through this command.
+- craft-ui's commands: `window.panel.move`, `.float`, `.dock`, `.activate`, `.close`,
+  `.closeGroup`, `.closeOthers`, `.minimize`, `.iconic`, `.window` and `.layout`, with the params
+  of craft-ui's `DockCommand` (`docs/ui-docking.md` in craft-libs). `window.panel.<Panel>`
+  (`window.panel.Align`) opens and shows that panel. `window.panel.activate` on a closed panel
+  reopens it where it was.
+- `ui.dock {operation, panel, …}` or `ui.dock {action}`: craft-ui's `ui.dock` operations
+  (`open`, `close`, `activate`, `float {rect}`, `moveFloating {rect}`,
+  `move {target, zone?, before?}`, `setStackOpen {open}`, `resizeStack {height}`,
+  `resizeSplit {path, size}`; `rect` is `[x, y, width, height]`). It returns
+  `{"docking": workspace}`. `ui.dock.reset` returns the current workspace to its saved or
+  built-in layout and returns the same. Raw `Open` and `OpenAt` actions are refused in both
+  `ui.dock {action}` and `window.panel.layout {action}`, as in `window.dockAction`; use the
+  panel open commands instead.
+- `window.dockPanel {panel, anchor?, zone?, before?}` docks as `window.panel.dock`: `zone` is
+  `center`, `tab`, `left`, `right`, `top`, `bottom`, `above` or `below`; without an anchor a
+  side zone docks along that edge of the whole workspace. `window.floatPanel {panel, rect?}`
+  requires exactly four finite numbers when `rect` is given and otherwise floats a 420x320
+  window in the middle of the app window. `window.closePanel {panel}` closes it.
+- `window.panelWindow {panel, window?}` puts a panel in a floating window of its own with a
+  desktop place over the panel's place in the main window, and returns `{"window": bool}`. A
+  docked panel floats first. `window` false docks it again, as a tab of the first docked group;
+  without `window` it toggles.
+
+On desktop every floating window is an OS window of its own (craft-ui's `native-windows`), which
+can go on another monitor; on Wayland, on the web and where egui embeds viewports, floating
+windows stay in the main window. Keys pressed in a floating window that none of its widgets uses
+run the main window's shortcuts, and files dropped on one import as on the main window. While a
+modal dialog is open, floating windows take no input.
+
+The automation ids of the docking chrome are `panel.tab.<Panel>`, `panel.drag.<Panel>` (a
+group's drag bar), `panel.tabs.more.<Panel>`, `panel.menu.<Panel>` (≡), `panel.header.<Panel>`
+(a stacked panel's open and close button), `panel.tab.<Panel>.lock` (viewer lock),
+`panel.tab.Timeline.<comp>` and `panel.tab.Timeline.close` (the Timeline's comp tabs),
+`panel.float.<n>.move`, `.close`, `.resize` and `.resize.<Edge>` for floating window `n`,
+`dock.gutter.<path>` for dividers (`a`/`b` per split level; a stack's gap below entry `i` adds
+`s<i>`) and `dock.corner.<outer>.<inner>` where two dividers meet.
+
+Saved workspaces (`workspaces.json`, version 2) hold craft-ui `Workspace`s: the layout, the
+closed panels with where each goes back, the lock, and each floating window's desktop place. A
+version 1 file (EffectCraft 0.10 and earlier) and the older unversioned record of
+named workspaces load with every panel in place: the current layout, the named workspaces,
+floating windows and their native window places. A column of stacked frames becomes tab groups
+split top to bottom: each open frame keeps all its tabs and its height (as a fixed size), and a
+closed frame's tabs join the open frame above it. A native window's place moves from the OS
+window's outer position to its content's, by the main window's title bar, before the first save.
+Panels that were closed stay closed and reopen at their default place. The first save writes version 2 and keeps
+the earlier file as `workspaces.old.json`. A damaged, unknown or newer file loads as the default
+layout and is left unchanged.
diff --git a/docs/effects-parity.md b/docs/effects-parity.md
index 6defcba8e..bd81a09df 100644
--- a/docs/effects-parity.md
+++ b/docs/effects-parity.md
@@ -15,8 +15,8 @@ After Effects', and does the preset library exist. The per-effect catalogue is t
 | Parameter names, order, popups, units, defaults | aligned in M9.12 | Agent-checked against After Effects' documentation, not against a live dump |
 | On the GPU | **280** (92%) | Measured: registry flags; GPU vs CPU agreement tested per effect |
 | 32-bit float, no clamping | 306 | Measured: registry flags |
-| **Rendered output matches After Effects** | **partly measured** | Some colour effects are checked against After Effects 2026 renders of our own test projects: Tint, Tritone, Black & White, Exposure, Levels, Curves, Luma Key, Extract, 4-Color Gradient and Fill within 1–3/255, Brightness & Contrast up to 6.2/255 (Color Correction, Generate and Keying rows below); every other effect is unmeasured. `effectcraft_effects::fidelity::compare_frames` exists for the corpus ([fidelity/README.md](fidelity/README.md)); simulation effects are pinned by golden hashes of our own output (M13.27) |
-| Animation presets | **54** original presets (8 text-animator, 23 Transitions, 23 Backgrounds) against After Effects' **621** `.ffx` presets | Measured: `crates/engine/presets/text_animators.json`, `crates/engine/presets/transitions.json`, `crates/engine/presets/backgrounds.json`; the After Effects `Presets` folder |
+| **Rendered output matches After Effects** | **partly measured** | Some colour effects are checked against After Effects 2026 renders of our own test projects: Tint, Tritone, Black & White, Exposure, Levels, Curves, Luma Key, Extract, 4-Color Gradient and Fill within 1–3/255, Brightness & Contrast up to 6.2/255 (Color Correction, Generate and Keying rows below); Radial Blur, Glow, Venetian Blinds, Radial Wipe, Fractal / Turbulent Noise and Transform are checked the same way (rows below); every other effect is unmeasured. `effectcraft_effects::fidelity::compare_frames` exists for the corpus ([fidelity/README.md](fidelity/README.md)); simulation effects are pinned by golden hashes of our own output (M13.27) |
+| Animation presets | **76** original presets (8 text-animator, 23 Transitions, 23 Backgrounds, 22 Behaviors) against After Effects' **621** `.ffx` presets | Measured: `crates/engine/presets/text_animators.json`, `crates/engine/presets/transitions.json`, `crates/engine/presets/backgrounds.json`, `crates/engine/presets/behaviors.json`; the After Effects `Presets` folder |
 | 26.x additions | Curl Noise (26.3) present (#463 open); effect colour labels (26.5) present in Effect Controls only, not in the Timeline; the rebuilt Effect Controls (26.5) missing | Release notes |
 
 **Breadth ≈ 85%** (presets weigh in; the effects themselves are ≈ 100%). **Ready ≈ 40%**: until a
@@ -28,24 +28,24 @@ corpus compares renders, each effect is assumed to differ somewhere, and users k
 |---|---:|---:|---|
 | 3D Channel | 8 | 8 | Cryptomatte selection can't be set in the UI and the GPU path is slow (#473; quoted names with commas fixed); multi-layer EXR decode shared (#474 open: f16 storage and cache sizing remain) |
 | Audio | 13 | 0 | CPU by design (applied in the mixdown) |
-| Blur & Sharpen | 16 | 15 | Gaussian Blur interaction and output to be measured first ([fidelity/ae-2026-acceptance.md](fidelity/ae-2026-acceptance.md)) |
+| Blur & Sharpen | 16 | 15 | Radial Blur keeps the layer edges as After Effects 2026 (713 now pixel-identical); Gaussian Blur interaction and output to be measured first ([fidelity/ae-2026-acceptance.md](fidelity/ae-2026-acceptance.md)) |
 | Channel | 13 | 13 | — |
 | Color Correction | 40 | 40 | Tint, Tritone and Black & White (sliders and Tint) match After Effects 2026 renders (Rec. 601 luminance); Levels (Individual Controls) matches After Effects 2026 in 32 bpc (channel controls before RGB, "Off for 32 bpc Color" unclipped; plain Levels' channel order not measured); Brightness & Contrast (non-legacy) close to After Effects 2026 ramps, not identical (up to 6.2/255 off; the test allows 7/255) (negative settings invert the positive curves); Curves interpolates a natural cubic spline through its points, as After Effects 2026 (exact on its grey steps); Tint has Swap Colors (#963); ACES 2.0 / OCIO 2.5 (26.5); Apply Color LUT (#514) and 32-bpc blending (#494) are closed |
-| Distort | 39 | 35 | Liquify has no viewer brush; #303 (Mesh Warp drag) and #534 (CC Power Pin Unstretch) are closed |
+| Distort | 39 | 35 | Transform matches After Effects 2026 renders (skew after rotation, drawn outside the layer); Liquify has no viewer brush; #303 (Mesh Warp drag) and #534 (CC Power Pin Unstretch) are closed |
 | Expression Controls | 9 | 9 | — |
 | Generate | 26 | 25 | 4-Color Gradient's Blend matches After Effects 2026 (weights 1 / (d² + Blend²)); Fill's Opacity is the filled layer's opacity, as After Effects 2026 renders it (with a Fill Mask it still mixes with the original, not measured); Fractal on the CPU (needs f64); #526 (Reset) and #536 (Write-on marks) are closed |
 | Immersive Video | 12 | 12 | — |
 | Keying | 12 | 12 | Luma Key and Extract key on Rec. 601 luminance, as After Effects 2026; Key Cleaner approximated; #533 (wire-removal Frame Offset) is closed |
 | Matte | 6 | 4 | Mocha shape reads our documented JSON, not Mocha's format |
-| Noise & Grain | 13 | 12 | Curl Noise (#463); Match Grain on the CPU |
+| Noise & Grain | 13 | 12 | Fractal / Turbulent Noise lattice matches After Effects 2026 (Scale 100 = 66.7 px cells); the noise values themselves differ (seeds) and Soft Linear contrast is about 20 % lower than AE's; Curl Noise (#463); Match Grain on the CPU |
 | Obsolete | 9 | 9 | Luma Key matches After Effects 2026 on a grey ramp (hard cut, Tolerance only for Similar / Dissimilar) |
 | Paint | 1 | 0 | Tablet pressure not read ([hardware-parity.md](hardware-parity.md)) |
 | Perspective | 10 | 9 | Chromatic Aberrations pan/tilt crash (#580) |
 | Simulation | 18 | 18 | Particle Playground lacks Particle Exploder, text particles, ephemeral mapper; CC Particle World camera fixed (#397) |
-| Stylize | 25 | 25 | Motion Tile output size (#369) |
+| Stylize | 25 | 25 | Glow's halo (coverage of a dim layer's edge) and blur width match After Effects 2026 renders; glows above the threshold match too (each channel 8 × (value − threshold + 0.061), measured at three thresholds and two radii); Composite Original's labels are swapped against After Effects (EffectCraft's On Top adds the glow over the original, which After Effects calls Behind); Motion Tile output size (#369) |
 | Text | 2 | 2 | — |
 | Time | 8 | 8 | #535 (Pixel Motion Blur, Vector Detail) is closed |
-| Transition | 17 | 17 | — |
+| Transition | 17 | 17 | Venetian Blinds matches After Effects 2026 renders (band phase from the layer centre, Gaussian feather on both edges) except within ~6 px of the layer edge (up to 48/255); Radial Wipe's Feather matches After Effects 2026 (a Gaussian of σ = 0.4 × Feather pixels on both edges of the wedge) |
 | Utility | 9 | 7 | — |
 
 Third-party bundles in After Effects (Cineware, Mocha AE) are out of scope; Keylight is
@@ -56,7 +56,7 @@ implemented under a generic name ("Key Light").
 **≈ 70–130 h**: a fidelity corpus case per effect at default and one non-default setting, compared
 with After Effects renders, and the fixes they turn up (40–80 h, most of it parallel, but every
 reference render needs After Effects on the owner's Mac); an original preset library covering
-After Effects' preset categories (Behaviors, Shapes, Synthetics, Text, Image effects remain; Backgrounds and
+After Effects' preset categories (Shapes, Synthetics, Text, Image effects remain; Backgrounds, Behaviors and
 Transitions exist) 15–35 h; the open effect bugs 10–20 h. Moving Fractal and the analysis effects to
 the GPU is performance, not parity.
 
@@ -64,6 +64,13 @@ the GPU is performance, not parity.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-19 | minor | Glow (original colours): bright pass per channel, 8 × (value − threshold + 0.061), measured against After Effects 2026 (CPU and GPU) |
+| 2026-10-19 | minor | Glow (colour channels): the glow covers the layer's blurred alpha, blur σ = 0.384 × radius, measured against After Effects 2026 renders (CPU and GPU) |
+| 2026-10-19 | minor | Radial Blur repeats the edge instead of sampling transparency outside the layer, measured against After Effects 2026 renders (CPU; Radial Blur has no GPU path) |
+| 2026-10-19 | minor | Venetian Blinds: stripes measured from the layer centre, both band edges Gaussian (σ = Feather / 2), measured against After Effects 2026 (CPU and GPU) |
+| 2026-10-19 | minor | Radial Wipe: Feather is in pixels on both edges of the wiped wedge (was degrees on the moving edge only), measured against After Effects 2026 (CPU and GPU) |
+| 2026-10-19 | minor | Fractal / Turbulent Noise: lattice cell = Scale × 2/3 px (Block noise every 66.7 px at Scale 100, as After Effects 2026), CPU and GPU |
+| 2026-10-19 | minor | Transform: After Effects' skew order and output beyond the layer bounds, measured against After Effects 2026 renders of three cases (CPU and GPU) |
 | 2026-10-19 | minor | Tritone uses Rec. 601 luminance, measured against After Effects 2026 renders of a red solid and a grey ramp (CPU and GPU) |
 | 2026-10-19 | minor | Black & White's Tint keeps the gray's luminosity (Color blend), measured against After Effects 2026 renders (CPU and GPU) |
 | 2026-10-19 | minor | Levels: "Off for 32 bpc Color" no longer clips in 32 bpc projects, unclipped values extrapolate below Output Black; Levels (Individual Controls) applies the channel controls before the RGB ones, measured against After Effects 2026 (CPU and GPU) |
diff --git a/docs/effects.md b/docs/effects.md
index b8214e438..3490af5a2 100644
--- a/docs/effects.md
+++ b/docs/effects.md
@@ -3,11 +3,11 @@
 <!-- Generated from the effect registry (crates/effects/src/catalog.rs); do not edit by hand.
      Regenerate: UPDATE_DOCS=1 cargo test -p effectcraft-effects --lib effects_doc_is_current -->
 
-EffectCraft ships 307 effects with 3032 parameters in total, grouped into the same categories as the Effects & Presets panel. Every effect is our own implementation, written from public behaviour descriptions and standard image-processing literature. Parameter names, order, popup options, units, defaults and ranges follow the reference application so that projects, expressions and muscle memory carry over.
+EffectCraft ships 308 effects with 2987 parameters in total, grouped into the same categories as the Effects & Presets panel. Every effect is our own implementation, written from public behaviour descriptions and standard image-processing literature. Parameter names, order, popup options, units, defaults and ranges follow the reference application so that projects, expressions and muscle memory carry over.
 
 - **GPU**: 280 effects also run on the GPU compositor with identical results.
-- **32**: 307 effects process 32-bit float (HDR, overbright) pixels without clamping.
-- **Status**: 307 implemented in full, 0 partial (what is missing is listed).
+- **32**: 308 effects process 32-bit float (HDR, overbright) pixels without clamping.
+- **Status**: 308 implemented in full, 0 partial (what is missing is listed).
 
 Effects are addressed by id (`ec.<category>.<name>`) or display name in commands, scripts and the control channel, and every parameter by its id (`effects/#1/blurriness`).
 
@@ -16,6 +16,7 @@ Effects are addressed by id (`ec.<category>.<name>`) or display name in commands
 | Effect | Id | Params | GPU | 32 | Status |
 |---|---|---:|:-:|:-:|---|
 | 3D Channel Extract | `ec.3d.channelextract` | 6 | GPU | 32 | Implemented |
+| 3D Layer Instance | `ec.3d.instance3d` | 1 |  | 32 | Implemented |
 | Cryptomatte | `ec.3d.cryptomatte` | 4 | GPU | 32 | Implemented |
 | Depth Matte | `ec.3d.depthmatte` | 3 | GPU | 32 | Implemented |
 | Depth of Field | `ec.3d.depthoffield` | 4 | GPU | 32 | Implemented |
@@ -258,7 +259,7 @@ Effects are addressed by id (`ec.<category>.<name>`) or display name in commands
 | Object Matte | `ec.matte.objectmatte` | 13 |  | 32 | Implemented |
 | Refine Hard Matte | `ec.matte.refinehard` | 16 | GPU | 32 | Implemented |
 | Refine Soft Matte | `ec.matte.refinesoft` | 18 | GPU | 32 | Implemented |
-| Roto Brush & Refine Edge | `ec.matte.rotobrush` | 24 |  | 32 | Implemented |
+| Roto Brush & Refine Edge | `ec.matte.rotobrush` | 25 |  | 32 | Implemented |
 | Simple Choker | `ec.matte.simplechoker` | 2 | GPU | 32 | Implemented |
 
 ## Noise & Grain
@@ -324,7 +325,7 @@ Effects are addressed by id (`ec.<category>.<name>`) or display name in commands
 | CC Hair | `ec.sim.cchair` | 20 | GPU | 32 | Implemented |
 | CC Mr. Mercury | `ec.sim.ccmrmercury` | 23 | GPU | 32 | Implemented |
 | CC Particle Systems II | `ec.sim.ccparticlesystems2` | 21 | GPU | 32 | Implemented |
-| CC Particle World | `ec.sim.ccparticleworld` | 35 | GPU | 32 | Implemented |
+| CC Particle World | `ec.sim.ccparticleworld` | 36 | GPU | 32 | Implemented |
 | CC Pixel Polly | `ec.sim.ccpixelpolly` | 10 | GPU | 32 | Implemented |
 | CC Rainfall | `ec.sim.ccrainfall` | 14 | GPU | 32 | Implemented |
 | CC Scatterize | `ec.sim.ccscatterize` | 4 | GPU | 32 | Implemented |
diff --git a/docs/fidelity/README.md b/docs/fidelity/README.md
index 5afafee41..0398118c5 100644
--- a/docs/fidelity/README.md
+++ b/docs/fidelity/README.md
@@ -71,6 +71,55 @@ After the fix, all ten tangents equal AE's to the printed 0.001 px, and the two
 test `spatial_auto_bezier_tangents_follow_after_effects` checks the rule on other original keys,
 including a timing change. AE's output stays local; only the script and these scores are tracked.
 
+## Justify All with the every-line composer
+
+Measured on 19 October 2026 with After Effects 2026 (26.2) on box text (EXPORTER read-back t6):
+with Justify All, AE stretches the paragraph's last line too and breaks the lines so that it is not
+a lone word (4 / 4 / 4 words where the other justifications break 6 / 6 / 1). EffectCraft's
+every-line composer ignored the last line's slack and left "twelve" alone on a stretched line; it now
+counts that slack for Justify All, and every word starts within 1 px of AE's. Regression test:
+`justify_all_balances_the_lines_with_the_every_line_composer`.
+
+## Right-to-left point text with a justified paragraph
+
+Measured on 19 October 2026 with After Effects 2026 (26.2) (EXPORTER read-back t7): right-to-left
+point text whose paragraph has a justified code (justify last left / centre / right, justify all)
+sits flush right at its anchor, like right-aligned text. EffectCraft placed it by the last-line
+side (left / centre / left). Now flush right; left-to-right point text is unchanged (not measured).
+Regression test: `rtl_point_text_with_a_justified_paragraph_is_flush_at_its_start`. Still open:
+AE wraps right-to-left box text slightly wider (its word gaps are 1–2 px narrower than in
+left-to-right text with the same font), so a 300 px box fits a word more per line.
+
+## Text animator tracking
+
+Measured on 19 October 2026 with After Effects 2026 (26.2): a text animator's Tracking Amount is in
+pixels, not 1/1000 em like the Character panel's tracking (Amount 30 adds 30 px between neighbouring
+characters at 80 px and at 40 px, half before and half after each), and a Subtract range selector
+over characters the first selector leaves out keeps them at 0 instead of tracking them negatively.
+With both, the EXPORTER's t8 layer D (Tracking 30 on characters 2–4 by index, a Subtract selector
+over the last 20 %) puts every glyph where AE does (it ended 88 px short). The "Tracking In" text
+preset now animates 40 → 0 px (was 400 → 0 thousandths of an em). Lottie export is unchanged (not
+checked against a player). Regression tests: `animator_tracking_is_in_pixels_as_in_after_effects`,
+`modes_combine`.
+
+## Per-character 3D rotation order
+
+Measured on 19 October 2026 with After Effects 2026 (26.2) (case 931: "H" at 400 px, per-character
+3D, animator X / Y / Z Rotation 40 / 30 / 20): a character turns as a 3D layer does, Rx · Ry · Rz
+(Z first). EffectCraft composed Rz · Ry · Rx, so the glyph faced another way (23 of 5184 grid points
+off, max 255); now 3 at the anti-aliased edge (mean 0.015). Regression test:
+`per_character_rotation_turns_z_first_as_a_3d_layer`.
+
+## Rectangle path start point
+
+Measured on 19 October 2026 with After Effects 2026 (26.2) on 400 × 300 shape rectangles with Trim
+Paths: a plain rectangle starts at its top-right corner and runs clockwise (0–25 % covers the right
+edge and 50 px of the bottom); with Roundness 40 it starts where the top-right arc meets the right
+edge. Start 70 / End 30 draws 30–70 %. EffectCraft started at the top-left corner (and the rounded
+rectangle elsewhere), so trimmed rectangles drew the wrong segment (86 of 5184 grid points off,
+now 5 at stroke edges). `effectcraft_path::rect` now draws AE's order, which also gives Convert to
+Bezier AE's vertex order. Regression test: `rectangles_start_where_after_effects_starts_them`.
+
 ## Still unmeasured
 
 Rendered frame comparisons now have a deterministic `effectcraft_effects::fidelity::compare_frames`
diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md
index 9e2249e9b..6eeef1719 100644
--- a/docs/file-format-parity.md
+++ b/docs/file-format-parity.md
@@ -48,8 +48,8 @@ trips and renders, checked by tests, not against After Effects), **partial** (na
 | GIF | R/W | yes | yes (animated) | good |
 | BMP | R | yes | — | good |
 | WebP | — | yes (still; animated WebP as footage with its frames, timing and alpha, #762) | — | beyond After Effects |
-| Targa `.tga` | R/W | yes (still and sequence; alpha interpreted on import) | none | good for import (#745); no Targa output |
-| DPX / Cineon `.dpx` `.cin` | R/W | yes (still and sequence; 8/10/12/16-bit luma, RGB, RGBA, both byte orders; log code values shown as stored) | none | partial: import (#756); no Interpret Footage ▸ Cineon Settings (log to linear), no DPX output; common in film VFX |
+| Targa `.tga` | R/W | yes (still and sequence; alpha interpreted on import) | yes (sequence; uncompressed 24-bit RGB or 32-bit RGB + Alpha, straight or premultiplied) | good: import (#745); output reads back through it unchanged; the alpha is not labelled in the file (no TGA 2.0 extension area), so it is interpreted on import |
+| DPX / Cineon `.dpx` `.cin` | R/W | yes (still and sequence; 8/10/12/16-bit luma, RGB, RGBA, both byte orders; log code values shown as stored, or converted by Interpret Footage ▸ Cineon Settings ▸ Logarithmic Conversion) | none | partial: import (#756) and Cineon Settings; no DPX output; common in film VFX |
 | Radiance `.hdr` | R/W | yes (still and sequence, 32-bit linear float like OpenEXR) | none | good for import (#745); no Radiance output |
 | SGI, PICT, ElectricImage, RLA/RPF images | R | none | none | Legacy; RPF camera data import exists (`keys.rpfCameraImport`) |
 | Camera Raw (DNG, CR3, NEF…) | R (Camera Raw) | none | none | LightCraft has decoders that could be shared |
@@ -65,7 +65,7 @@ trips and renders, checked by tests, not against After Effects), **partial** (na
 | Apple ProRes (422 family, 4444) | R/W | yes | yes | good; 4444 colour tag wrong (#340); no ProRes RAW |
 | WebM / Matroska (VP9, AV1, Opus) | R (limited) | yes, incl. VP9 alpha | yes | beyond After Effects |
 | MXF (OP1a / OP-Atom) | R/W | yes (FilmCraft's demuxer: AVC, MPEG-2 incl. XDCAM / D-10, VC-3 / DNxHD, ProRes; PCM audio) | none | partial: import (#767), checked against ffmpeg; no MXF output |
-| AVI | R | none | none | Media Browser lists it |
+| AVI | R | yes (FilmCraft's demuxer: AVI 1.0 / OpenDML; Motion JPEG, H.264, HEVC, uncompressed; PCM, MP3, MP2, AC-3 audio) | none | partial: import (#1701), checked against ffmpeg; H.264 needs its parameter sets in the chunks (global headers and copies with an `avcC` record don't decode until storytold/filmcraft#2303), and a damaged video index loses the video (storytold/filmcraft#2302); DV, MPEG-4 Part 2 (DivX / Xvid) and other legacy codecs import but show why they have no picture; no AVI output |
 | DNxHD / DNxHR | R/W | unverified (FilmCraft decodes it; reachable only inside `.mov`) | none | — |
 | BRAW, R3D, ARRIRAW | R (plug-ins / SDKs) | none | none | proprietary SDKs |
 | Variable-frame-rate phone video | R | unverified | — | needs a real-media corpus |
@@ -96,24 +96,56 @@ trips and renders, checked by tests, not against After Effects), **partial** (na
 | Mocha shapes | R (Mocha AE) | own documented JSON | — | Mocha's format is not public |
 | Vanishing Point `.vpe` | R | none | — | no public specification; the menu entry explains why |
 
-## Render queue outputs (`OutputFormat::ALL`, 13)
+## Render queue outputs (`OutputFormat::ALL`, 14)
 
 H.264 MP4, HEVC MP4, AV1 MP4, ProRes MOV, uncompressed 8-bit RGB / RGB + Alpha MOV (`raw `, + PCM;
-#372), WebM (VP9 or AV1 + Opus), PNG / JPEG / TIFF / OpenEXR sequences, animated GIF, WAV, AIFF.
+#372), WebM (VP9 or AV1 + Opus), PNG / JPEG / TIFF / OpenEXR / Targa sequences, animated GIF, WAV, AIFF.
 Missing against After Effects + Media Encoder: 16-bpc uncompressed, AVI and lossless-compressed
-single-file video (Animation / PNG codecs), DPX / Targa / Photoshop sequences, MXF, DNxHR, hardware
+single-file video (Animation / PNG codecs), DPX / Photoshop sequences, MXF, DNxHR, hardware
 encoders ([hardware-parity.md](hardware-parity.md)), and rendering safely over an existing file
 (#325).
 
+### Render source protection
+
+The render queue refuses an output that would replace footage, an attached proxy, or the
+project file. It checks every output module and segment before dispatching the item. A refused
+item is marked Failed with its reason; other valid queued items can still render. Render logs
+are checked too. No render parameter overrides this protection.
+
+Checks compare normalized paths and native file identities, so an existing symbolic link,
+hard link, junction or Windows short name cannot disguise a source as another output file.
+Source identities are indexed once per check and matching identities are verified. The index
+does not keep file handles open for the lifetime of a long sequence.
+
+Default output names move aside when they would replace a protected file. This also applies to
+Create Proxy: recreating a proxy chooses a new default name and attaches the new proxy, leaving
+the previous proxy file intact. An explicit output path is kept as entered and refused if it
+would replace a protected file.
+
+After Pre-render imports its result, that file is footage too. Re-queueing the same item
+with the same output is refused; run Pre-render again for a fresh default output, or choose
+another Output To. An item's `last_output` is not permission to replace imported footage.
+
+Image-sequence checks inspect existing frames in the requested range. Skip Existing Files leaves
+existing frames alone. If a frame number appears in a folder name, the checker probes each
+frame separately and refuses ranges over 100,000 frames instead of silently checking a prefix.
+Choose a fixed output folder or a shorter range for those exports.
+
+This guard does not introduce an overwrite flag, confirmation dialog, or changed replacement
+defaults for the CLI, scripts or MCP. Replacement consent and staging ordinary output files
+belong to the exporter. The source check runs before export; filesystem changes between that
+check and a write still require exporter-side revalidation.
+
 ## Estimate
 
 **≈ 130–230 h**: `.aep` / `.aepx` import 80–160 h (after the owner decision), wiring TGA / DPX /
-HDR / MXF / AVI / DNx import and DPX/TGA output 10–20 h, FBX animation and skinning, USD and Substance 20–40 h,
+HDR / MXF / AVI / DNx import and DPX output 10–20 h, FBX animation and skinning, USD and Substance 20–40 h,
 relinking 6–12 h, `.mogrt`-compatible templates 15–30 h (partly parallel with the rest).
 
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-30 | minor | Render-queue source-protection behavior and limits consolidated here from the standalone page |
 | 2026-10-12 | minor | #324 and #514 marked closed; open `.aep` PRs #251 and #860 noted |
 | 2026-10-10 | major | First file format parity document, from the After Effects 26.5 bundle and this repository's import/export registries |
diff --git a/docs/footage.md b/docs/footage.md
index bd99cbeb2..f7f1df21b 100644
--- a/docs/footage.md
+++ b/docs/footage.md
@@ -94,16 +94,21 @@ used, and layers that ran to the end of the footage keep doing so.
 | Fields, pixel aspect, loop | As in After Effects. |
 | **Assign Profile**, **Interpret As Linear Light** | The colour profile the file's values are in (the working space converts from it), and whether they are linear light. |
 | **Preserve RGB** | The file's values enter the composition unconverted: no colour profile, linear light or working-space conversion, and float files (OpenEXR, float TIFF) keep their linear values instead of being sRGB-encoded. Use it to convert chosen layers yourself with an OCIO effect, or to read data passes (depth, mist, normals) as numbers. |
+| **Cineon Settings** (DPX and Cineon files) | With *Logarithmic Conversion* on, the file's log code values are converted to the *Current Gamma* (1.7 by default; 1 gives linear light): the *10 Bit Black Point* (95) becomes the *Converted Black Point* (0), and with *Highlight Rolloff* at 0 the *10 Bit White Point* (685) becomes the *Converted White Point* (1023). *Highlight Rolloff* (20) bends the top 20% of the converted range into a curve, as the Cineon Converter effect does: the white point then converts to a level below the Converted White Point, and brighter code values stay below it. At 0, a 32 bpc project keeps over-range values. *Units* shows the converted points as 10-bit, 8-bit or float values. With Logarithmic Conversion off (the default), the code values are shown as stored. |
 
 Settings ▸ Import ▸ **Report Missing Frames** (on by default) lists the missing frame numbers
 when a sequence imports; Interpret Footage lists them too.
 
 **File ▸ Interpret Footage ▸ Remember Interpretation / Apply Interpretation** copy the alpha,
-fields, pixel aspect, loop and colour settings (Preserve RGB too) to other footage.
+fields, pixel aspect, loop and colour settings (Preserve RGB too, and Cineon Settings between
+DPX and Cineon files) to other footage.
 
 Agents: `file.interpretFootage {"items": [id], "frameRate": 24, "alpha": "premultiplied",
 "startTimecode": 1001, "preserveRgb": true}` (timecode or a frame number; `"overrideStart":
-false` goes back to Use Source File Timecode).
+false` goes back to Use Source File Timecode). Cineon Settings: `{"logConversion": true,
+"tenBitBlack": 95, "tenBitWhite": 685, "currentGamma": 1.7, "highlightRolloff": 20,
+"cineonUnits": "8bit", "convertedBlack": 0, "convertedWhite": 255}` (converted points in
+`cineonUnits`, else the footage's Units).
 
 ## Multi-layer OpenEXR
 
@@ -129,9 +134,10 @@ including files overwritten at the same path and byte size.
   and 3D models are not sources, and a composition can't be nested in itself. Alt-dragging onto a
   layer is one layer at a time, as in After Effects.
   Agents: `layer.replaceSource {"item": id, "layers": [ids]}`.
-- **File ▸ Replace Footage ▸ File…** (Ctrl+H) points the item at another file. Pick a numbered
-  file to replace it with that file's whole sequence (`file.replaceFootage {"path": …,
-  "sequence": false}` for one frame).
+- **File ▸ Replace Footage ▸ File…** (Ctrl+H) points the item at another file. A still stays a
+  still, and a sequence item keeps bringing the new numbered file's run; pass
+  `sequence: true` to bring a numbered still's whole run (`file.replaceFootage {"path": …,
+  "sequence": true}`), or `sequence: false` for one frame.
 - **Replace with Precomposition (used N times)**, right-clicking a footage item or solid in the
   Project panel, puts the item in a new composition of its size,
   pixel aspect and frame rate, in the same folder, and switches every layer in every composition
diff --git a/docs/gaps.md b/docs/gaps.md
index f8fcd64c2..016aeff22 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Where EffectCraft falls short
 
-> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-13 · **Change:** minor (path-editing layer bounds, #1220; issue, PR and catalog references gap 21: percentage guides and effect colour labels in; earlier change: re-audited against `upstream/main` 470ea7a3; ranked gap list from the 10 October re-measure otherwise unchanged) · **Target:** Adobe After Effects 2026 (26.5.0.89)
+> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-30 · **Change:** minor (gap 4 closed: every pull request and push to `main` runs `cargo xtask ci` in CI, #2204; earlier change: gap 25: an AccessKit audit test and a theme contrast test, Effects & Presets, Settings and Render Queue named and keyboard-operable, #1335; earlier change: path-editing layer bounds, #1220; issue, PR and catalog references gap 21: percentage guides and effect colour labels in; earlier change: re-audited against `upstream/main` 470ea7a3; ranked gap list from the 10 October re-measure otherwise unchanged) · **Target:** Adobe After Effects 2026 (26.5.0.89)
 
 An honest assessment of how far EffectCraft is from being a real replacement for After Effects,
 and the work that closes the gap. This document is meant for contributors and agents choosing
@@ -37,8 +37,8 @@ because 179 issues were closed with regression tests between 5 and 10 October.
 | UI/UX fidelity | ≈ 65% | 60–120 | [ui-parity.md](ui-parity.md) |
 | File formats | ≈ 50% | 130–230 | [file-format-parity.md](file-format-parity.md) |
 | Hardware | ≈ 40% | 60–120 | [hardware-parity.md](hardware-parity.md) |
-| Localization | ≈ 18% | 60–110 + review | [localization-parity.md](localization-parity.md) |
-| Stability | ≈ 45% | 40–80 | 23 never-crash PRs landed on 4 October and the "Never crash" rules bind every crate, but crash reports are open (#580 Chromatic Aberrations pan/tilt, #501 crash on startup, #426 timeline drag while playing, #341 quit on Intel Mac, #234 macOS 27 exit, #879 `--gpu` export aborts on a failed allocation; #591, #306 and #511 are closed), and no CI workflow runs `cargo xtask ci` on pull requests |
+| Localization | ≈ 24% | 60–110 + review | [localization-parity.md](localization-parity.md) |
+| Stability | ≈ 45% | 40–80 | 23 never-crash PRs landed on 4 October and the "Never crash" rules bind every crate, but crash reports are open (#580 Chromatic Aberrations pan/tilt, #501 crash on startup, #426 timeline drag while playing, #341 quit on Intel Mac, #234 macOS 27 exit, #879 `--gpu` export aborts on a failed allocation; #591, #306 and #511 are closed); `cargo xtask ci` runs on every pull request and push to `main` (#2204) |
 | Real-user experience | ≈ 60%, uneven by platform | (in G2) | 179 issues closed 5–10 October (as counted on 10 October), nearly all with regression tests ([log below](#real-user-report-log-510-october)); 216 open and 328 closed on 12 October, many from Linux and Windows. Most checking still happens on macOS |
 | Performance | unknown against After Effects, ≈ 35% | 50–100 | Internal numbers only (e.g. Advanced 3D 290 ms/frame at 1080p on the GPU on an M4 Pro). Users report stutter on cached frames (#595, #304; the RAM preview now prefetches nearest the playhead, 271000b2), late audio (#504, #335); slow scrubbing (#329, closed by #784) and #554 are closed. No 4K / hundreds-of-layers project tested |
 | Media formats | ≈ 75% | (in file formats) | H.264, ProRes, HEVC, AV1, VP9, image sequences and audio exist. The HEVC / AV1 encoders have no B-frames, multi-reference or SAO / CDEF, so files are larger than from mature encoders. Camera formats (BRAW, R3D, ProRes RAW, variable-frame-rate phone video) are unverified |
@@ -60,28 +60,28 @@ are grouped by area; the issue tracker has the rest.
 | 1 | **`.aep` / `.aepx` projects can't be opened** | No reader; candidate route py-aep (#248, closed as a duplicate of #190; MIT, external converter) awaits an owner decision on clean-room scope; #190; open PRs #251 (native decoder) and #860 (external py-aep converter) | The biggest barrier to switching: existing work, templates and client projects stay in After Effects | 80–160 h | G4 · [file-format-parity.md](file-format-parity.md) |
 | 2 | **Fidelity unmeasured** beyond scalar ease | [fidelity/](fidelity/README.md): 168 samples, one property type; `compare_frames` helper exists, no corpus | Every "done" feature may still differ; users find the differences | 60–100 h harness + P0/P1 corpus; more per feature | G1 · [target-app-parity.md](target-app-parity.md) |
 | 3 | **Open crash reports** | Open: #580, #501, #426, #341, #234, #879. Now closed: #591, #306, #511 | A crash loses work; outranks features ([AGENTS.md](../AGENTS.md)) | 10–25 h | G3 · this file |
-| 4 | **No CI gate on pull requests** | `.github/workflows` has release, packaging-lint, FreeBSD and Windows ARM64 jobs only; `cargo xtask ci` runs locally | Regressions reach main unseen; 49 community PRs landed in one batch (#598) | 4–8 h | G3 · this file |
+| 4 | ~~**No CI gate on pull requests**~~ closed | `.github/workflows/ci.yml` runs `cargo xtask ci` (fmt, clippy, tests, layers, assets, wasm) on every pull request and push to `main` through craft-common-actions' shared `gate.yml` (#2204) | — | done | G3 · this file |
 | 5 | **Playback and scrubbing feel** | #595 stutter on cached frames (partly addressed: nearest-first RAM preview prefetch, cache bars at 1/3 resolution), #304, #504 / #335 audio late or crackling, #586 puppet lag (maintainers asked for details); #329 slow scrubbing (#784) and #554 closed | Preview is where motion designers spend their day | 25–50 h | G5 · [hardware-parity.md](hardware-parity.md) |
 | 6 | **Linux and Windows interaction bugs** | Open: #488 rename arrows (hardening landed, reporter asked for details), #492 anchor drag, #268 file drops on Wayland (winit), #613 Direct3D 12 compositor. Now closed: #491, #493, #467, #320, #302, #596 | Many reports come from Linux; some Windows GPUs fail to start the compositor | 25–45 h | G2 · [ui-parity.md](ui-parity.md) |
-| 7 | **Animation presets: 54 against 621** | After Effects ships 621 `.ffx` presets (Behaviors, Backgrounds, Shapes, Synthetics, Text, Transitions…); we ship 54 original presets (8 text-animator; 23 Transitions: wipes, clock and fan reveals, blinds, dissolves, card flips, CC wipes, fades, #757; 23 Backgrounds: drifting gradients, fog, cloud and smoke, plasma and magma, cells, hexagons, scrolling grids and checks, pulse rings, bokeh, light sweep, #1096, driven by expressions so they keep moving, not seamless loops) and read only our `.ecpreset`. Missing: Behaviors, Shapes, Synthetics, Image and more Text | Presets are how many designers start; tutorials assume them | 15–35 h (original presets; `.ffx` reading is out of clean-room scope) | G8 · [effects-parity.md](effects-parity.md) |
+| 7 | **Animation presets: 76 against 621** | After Effects ships 621 `.ffx` presets (Behaviors, Backgrounds, Shapes, Synthetics, Text, Transitions…); we ship 76 original presets (8 text-animator; 23 Transitions: wipes, clock and fan reveals, blinds, dissolves, card flips, CC wipes, fades, #757; 23 Backgrounds: drifting gradients, fog, cloud and smoke, plasma and magma, cells, hexagons, scrolling grids and checks, pulse rings, bokeh, light sweep, #1096, driven by expressions so they keep moving, not seamless loops; 22 Behaviors: wiggle, shake, float, orbit, bounce, drift, pendulum, spin, pulse, heartbeat, blink, strobe, flicker on transform and opacity, #1510) and read only our `.ecpreset`. Missing: Shapes, Synthetics, Image and more Text | Presets are how many designers start; tutorials assume them | 15–35 h (original presets; `.ffx` reading is out of clean-room scope) | G8 · [effects-parity.md](effects-parity.md) |
 | 8 | **Mask and shape bugs** | Open: #1004 mask vertex multi-select, #999 auto-pan, #1042 / #1033 vertex nodes under the bounding box, #959 / #960 shape group toggles and operators. Now closed: #510, #513, #527, #509, #303, #553, #932 (Convert To Bezier Path on a shape layer's parametric path) | Masks are core compositing | 10–20 h | G2 · [target-app-parity.md](target-app-parity.md) |
 | 9 | **Effect behaviour bugs** | #580, #463 Curl Noise, #369 Motion Tile output size, #943 Turbulent Displace Evolution, #473 Cryptomatte selection (quoted names with commas fixed, 3b7f1ace; UI and GPU time open), #474 multi-layer EXR (decode shared, faffad3a; f16 storage and cache sizing open). Closed: #526, #514, #533–#536 | Each one breaks a look someone built | 10–20 h | G1/G2 · [effects-parity.md](effects-parity.md) |
 | 10 | **Colour pipeline differences** | #340 ProRes 4444 tagged bt709 but sRGB-encoded (open); ACES 2.0 / OCIO 2.5 configs (26.5) missing; now closed: #494 32-bpc blend modes, #495 and #750 Working Gamma 2.4, #546 / #547 viewer colour | Wrong colour in delivery is a client-visible failure | 15–30 h | G1 · [file-format-parity.md](file-format-parity.md) |
-| 11 | **Text rendering and layout** | Open: #453 CJK text in comps, #316 paragraph alignment inverted (maintainers' tests show Left/Right correct; asked for a project), #417 soft at Fit (mostly fixed by #444), #550 toolbar font options. Closed: #483, #583 | Text is in almost every motion graphic | 10–20 h | G2 · [ui-parity.md](ui-parity.md) |
+| 11 | **Text rendering and layout** | #453 CJK text in comps: the Han fallback now reaches the installed Chinese faces; open: #316 paragraph alignment inverted (maintainers' tests show Left/Right correct; asked for a project), #417 soft at Fit (mostly fixed by #444), #550 toolbar font options. Closed: #483, #583 | Text is in almost every motion graphic | 10–20 h | G2 · [ui-parity.md](ui-parity.md) |
 | 12 | **3D interaction and depth** | No 3D transform gizmos (#392, #347); camera aperture (#260); reflections (#261); extruded surface materials beyond Front / Bevel / Side / Back Color (fb5a5e9a; #315 closed); #307 reopened (the viewer's renderer button now shows and switches the renderer, #645); Z position (#489) closed | Advanced 3D is After Effects' growth area since 2023 | 20–35 h | G2 · [ui-parity.md](ui-parity.md) |
 | 13 | **3D model formats and materials** | After Effects 26 imports FBX, USD/USDZ, STL besides glTF and OBJ (`usd_plugins`), and Substance 3D materials with mesh displacement (26.0–26.2); we read glTF, OBJ, STL (binary and ASCII, with facet colours) and FBX 7.x (binary and ASCII: meshes, hierarchy, Lambert/Phong materials and textures; no FBX animation or skinning yet) | Product shots and 3D scenes come as FBX/USDZ | 25–45 h | — · [file-format-parity.md](file-format-parity.md) |
 | 14 | **Object Matte** (26.2, disk cache in 26.5) | First slice (#783): the Object Matte effect (Effect ▸ Matte) and `objectMatte.apply` turn a point (and optional box) on a reference frame into a matte and follow the object up to 600 frames each way, or segment every frame on its own; Roto Brush's engine, cache and model (MobileSAM from Settings ▸ Roto Brush, classical graph cut without it). Since then: the Object Matte tool in the viewer (click / drag a box, hover crosshair), the box as the model's box prompt, background tracking with progress and cancel, Freeze, and segmentations kept in the disk cache (26.5). Missing: a comparison with After Effects ([plan](fidelity/object-matte.md)) | The new one-click roto | 10–20 h | G7 · [target-app-parity.md](target-app-parity.md) |
 | 15 | **Hardware video decode and encode** | No VideoToolbox, NVENC, Quick Sync or VA-API; #498 asks for it (answered: CUDA / NVENC need Nvidia's proprietary SDK through FFI, which the no-`unsafe` rule forbids); open PR #819 adds hardware decoding via `filmcraft-platform`; FilmCraft has VideoToolbox / NVENC / VA-API paths to borrow | 4K playback and export speed | 25–45 h | G5/G6 · [hardware-parity.md](hardware-parity.md) |
-| 16 | **Localization depth** | Menus in 11 languages (ja, zh-hans, zh-hant, uk, es, pt-br, ru, fr, de, cs, ka: 628 rows each); panels in 7 (ja, zh-hans, zh-hant, uk, pt-br, cs, ka); effect names translated in Simplified Chinese and Georgian (307, plus the generated Effect menu), their ~1,650 parameter names untranslated; Korean and Italian (After Effects ships them) absent; Hangul probe added (#599 closed) | After Effects is used heavily in Japan, China, Korea, Brazil, Europe | 60–110 h + native review | G9 · [localization-parity.md](localization-parity.md) |
-| 17 | **Media Browser lists files import refuses** | `media_browser.rs` lists AVI; `media::is_importable` has none of them (Targa and Radiance HDR import since #745; DPX and Cineon since #756, log shown as stored: no Cineon Settings conversion yet; MXF OP1a / OP-Atom since #767; FilmCraft has no AVI demuxer); #431 and #324 closed | Confusing failures on common VFX formats | 15–30 h | G6 · [file-format-parity.md](file-format-parity.md) |
+| 16 | **Localization depth** | Menus in 11 languages (ja, zh-hans, zh-hant, uk, es, pt-br, ru, fr, de, cs, ka: 630 rows each, 629 in Georgian); panels in 7 (ja 996 rows, zh-hans 998, zh-hant 951, uk 524, pt-br 695, cs 518, ka 885); effect names translated in Simplified Chinese (307), Japanese (297) and Georgian (307, plus the generated Effect menu), their ~1,650 parameter names untranslated; Korean and Italian (After Effects ships them) absent; Hangul probe added (#599 closed) | After Effects is used heavily in Japan, China, Korea, Brazil, Europe | 60–110 h + native review | G9 · [localization-parity.md](localization-parity.md) |
+| 17 | **Media Browser lists files import refuses** | The Media Browser, the import and proxy dialogs and `media::is_importable` share one movie list since #1701, AVI included (Targa and Radiance HDR import since #745; DPX and Cineon since #756, log shown as stored unless Interpret Footage ▸ Cineon Settings converts it; MXF OP1a / OP-Atom since #767; AVI since #1701, without DV, MPEG-4 Part 2 or other legacy codecs yet); #431 and #324 closed | Confusing failures on common VFX formats | 15–30 h | G6 · [file-format-parity.md](file-format-parity.md) |
 | 18 | **Relative paths and relinking** | Projects store absolute footage paths; no relink when a project moves | Moving or sharing a project breaks it | 6–12 h | G4 · [file-format-parity.md](file-format-parity.md) |
 | 19 | **Plug-in ecosystem** | No After Effects SDK hosting (#600, #327 OpenFX, #334, #376 plug-in manager); our WebAssembly API has no third-party plug-ins | Many pro projects depend on Trapcode, Element, Saber… | 40–80 h for API growth; SDK hosting needs an owner decision | G8 · [scripting-parity.md](scripting-parity.md) |
-| 20 | **Multi-monitor and video output** | #486: any panel can move into a native window of its own (panel menu ▸ Move Panel to New Window, `window.panelWindow`) and so onto another screen, restored with the workspace; still missing: dragging tabs between those windows, app shortcuts while one has the focus, named workspaces remembering them, Mercury Transmit to video hardware (we have a second preview window only) | Two-screen setups are standard for professionals | 10–20 h | G2 · [hardware-parity.md](hardware-parity.md) |
+| 20 | **Multi-monitor and video output** | #486: on Windows, macOS and X11 every floating panel is an OS window of its own (Undock Panel, a drag out of the main window, panel menu ▸ Move Panel to New Window, `window.panelWindow`) and so can go onto another screen (on Wayland, the web and in embedded viewports floating panels stay in the app window, since Wayland reports no window positions); tabs and groups drag between windows, shortcuts work in them, and the current and named workspaces restore their places; still missing: Mercury Transmit to video hardware (we have a second preview window only) | Two-screen setups are standard for professionals | 10–20 h | G2 · [hardware-parity.md](hardware-parity.md) |
 | 21 | **Small 26.x features** | Proportional Scrubbing (26.2), pasting Illustrator's own clipboard data as shapes (26.3; SVG markup on the clipboard pastes as a shape layer, #738), variable-font filter (26.3), the rebuilt Effect Controls (26.5). Percentage guides (View ▸ Add Percentage Guide, Convert Guides to Percentage / Pixels) and effect colour labels (Effect Controls header bar and right-click Label menu, `effect.setLabel`) are in (#1095), built from the release notes' one-line descriptions and never compared with After Effects: the Timeline's effect rows wear the label as a colour bar on the left edge (#1509), but After Effects' exact UI there is unknown | Users of the current version expect them | 10–20 h left | — · [ui-parity.md](ui-parity.md) |
 | 22 | **Encoder efficiency** | HEVC / AV1 have no B-frames, multi-reference or SAO / CDEF; Opus no FEC / DTX; single-file intermediates are 8-bit uncompressed QuickTime only (#372 closed by #778: no 16-bpc, AVI or lossless-compressed codec); #325 render over existing file | Larger files than After Effects + Media Encoder | 20–40 h | G6 · [file-format-parity.md](file-format-parity.md) |
 | 23 | **Essential Graphics interchange** | Templates are `.ectemplate`, not `.mogrt`; #338 and #611 closed | Premiere editors can't use our templates | 15–30 h | — · [file-format-parity.md](file-format-parity.md) |
 | 24 | **Timeline depth requests** | #601 expand precomps in place, #602 reorderable render stack, #604 guide-only effects, #425 keyframe confusion (#355 and #428 closed) | Power-user speed | 15–30 h | G2 · [ui-parity.md](ui-parity.md) |
-| 25 | **Accessibility** | AccessKit is enabled in eframe and tests read focus labels; the Project panel has After Effects' arrow-key navigation and named, stateful AccessKit nodes (#776), but the other panels have had no screen-reader pass or keyboard navigation audit, and there is no contrast check | Excludes users; After Effects supports screen readers poorly too | 15–30 h | G9 · [ui-parity.md](ui-parity.md) |
+| 25 | **Accessibility** | AccessKit is enabled in eframe. `ui_accessibility_audit` walks the AccessKit tree and counts unnamed or roleless controls per panel; Project (#776), Effects & Presets, Settings (every page) and the Render Queue with its Templates dialog are at zero and held there, with named, stateful nodes and arrow-key, Home / End, Enter and Space operation of their lists (#1335). The other 30 or so panels are counted but not fixed (the Timeline alone has about 55 unnamed controls; the baseline in the test shows each). `ui_contrast` checks the theme tokens against WCAG 2: 13 of 48 pairs fall short (primary-button text, error text, control borders, the whole Light theme's warning colour). **No screen reader has been run on any panel**: the tree is checked, not how NVDA, VoiceOver or Orca speak it. Not covered: keyboard-only operation of the other panels, focus order across panels, colour-blindness, text size, reduced motion. App shortcuts pause while any widget has keyboard focus (egui), so Ctrl+Z does nothing with a list row focused | Excludes users; After Effects supports screen readers poorly too | 12–25 h (first slice, about 3 h, done) | G9 · [ui-parity.md](ui-parity.md) |
 
 ## Where we're going: workstreams in priority order
 
@@ -133,6 +133,12 @@ The most important missing piece: it turns every other estimate here into a meas
   the prompt, with their layers, in one undo step, for single items, multiple selections and
   folder contents. Nothing happens with an empty selection, in other panels, while typing or with
   a dialog open, and the next Delete still asks.
+- Regression evidence for [#947](https://github.com/storytold/effectcraft/issues/947): the
+  preview startup tests in `ui_audio_scrub`, checked headlessly on Windows with a fake output
+  device, start an audible preview on an uncached comp. The playhead holds the first frame until
+  the frames ahead are cached, the sound starts at that frame (from 0 s and from 1 s, also for a
+  30 s work area), and a tone lasting only the first 100 ms reaches the output. Video off still
+  starts at once, no device plays the picture, and Stop while preparing leaves nothing playing.
 - Regression evidence for [#612](https://github.com/storytold/effectcraft/issues/612): the
   `ui_gradient_value` and `ui_gradient_editor` input tests, checked headlessly on Windows, open
   the Gradient Editor from the Timeline's "Edit Gradient…" on a shape layer's Gradient Fill. They
@@ -163,6 +169,11 @@ The most important missing piece: it turns every other estimate here into a meas
   a Radial Stroke swatch on a selected shape layer and get the Gradient Editor on its Gradient Fill
   / Gradient Stroke Colors (OK saves); without such a gradient the swatch still opens the options,
   and the words, Solid swatches and Alt-click are unchanged.
+- Regression evidence for [#1306](https://github.com/storytold/effectcraft/issues/1306) (from
+  #1072): the `ui_expression_values` tests, checked headlessly on Windows, read the colour the
+  values are painted in. Expression-driven vectors, angles and scalars are red in the Timeline,
+  Effect Controls and Properties panel, in dark and light themes, hovered too; disabled, removed
+  and empty expressions show the ordinary colour.
 - Regression evidence for the reports of 6 October, checked headlessly on Windows: real pointer
   drags in `ui_drag_drop` (Project items into the Timeline between layers and at a time, and onto
   the viewer; an effect onto a layer in the viewer: #85, #88, #89), `ui_render_queue` (a template
@@ -224,7 +235,7 @@ The most important missing piece: it turns every other estimate here into a meas
 
 Kept from the 5 October assessment's "Real-user experience" row, as evidence of what users hit and what was fixed:
 
-Issues #41–#47 (all from the Linux AppImage 0.1.1, 5 October): panning the viewer snaps back, panels can't be resized or rearranged, drag-and-drop and double-click import don't work, layer rename gets stuck, the Layer Settings arrow does nothing, the Project panel clips, the Wayland window icon is generic. Issues #63–#68 (macOS, 5 October): scaling a layer by its handles goes wrong and can stick at 0, two 3D compasses, the viewer lags while a layer is dragged (a frame renders in 20 ms but showed after ≈ 100 ms, behind RAM preview prefetch), the Discord and other links do nothing, Delete doesn't delete in the Project panel, hidden layers can be selected in the viewer. All but the last two were fixed or confirmed fixed with a test on 5–6 October (those two have community PRs); file drops still can't work on Wayland (winit has no support). The panning, rename and arrow bugs had been fixed in v0.2.0 already; nobody had told the reporter. A Windows user (6 October, on Discord) found the font menus listed only the three bundled fonts: installed fonts were read only when a project asked for one, on every platform. Fixed with a regression test on 6 October; the menus now list every installed family and its own styles, and agents get `text.fonts` / `list_fonts`. Seven reports of 6 October (Linux .deb and Windows): Project items and files couldn't be dropped on the viewer (#85), nor effects on a layer there (#88); drops in the Timeline ignored where they landed (#89); an angle's revolutions couldn't be edited (#93); toggling Audio, Lock or Shy threw away the RAM preview and playback with audio skipped frames (#103); running out of video memory panicked every frame thread and left frames stuck (#106); choosing a Render Settings template in the Render Queue did nothing (#117: any popup menu moved up to fit the window closed on the press). All seven were fixed with regression tests on 7 October. Reports of 7 October (Linux, macOS, Windows): the app opened the demo project on every launch, so a new comp landed in it (#204); a comp wider than the GPU's texture limit (11000 × 2200) at Full resolution stopped the window drawing (#201); an Intel HD Graphics 5500 couldn't start the app (#198: most likely the window's device asked for limits that GPU doesn't have, and the failure was silent); Audio Spectrum / Waveform stood still in the viewer (#209) and preview sound waited for the whole work area to cache (#208); a layer couldn't be deselected from the time graph, a shape layer's Fill and Stroke showed only with a shape tool and a drawn shape had no stroke to change, Alt+Shift+P didn't reveal Position (#205); a mask selected in the Timeline wasn't selected in the viewer, Mask Feather had no link and took negative values, the Project panel had no selection box (#203); shape layers had no Add menu for Trim Paths and the other operations, and Classic 3D comps hid Geometry Options (#206); dragging Puppet pins re-rendered the layer under the Puppet at every move (#212). All were fixed with regression tests the same day (#219–#222); the #198 fix couldn't be checked on that GPU. Reports of 8 October (browser, Windows, macOS): an empty project at 1280 × 800 with device pixel ratio 2 crashed on its first frame, because the Project panel's scroll bar clamped its thumb to a track shorter than the thumb (#231, any short panel on every platform); Media Browser ▸ Add Files… dropped a file it couldn't read without a word (#226); after the page's WebGPU device was lost, the browser editor froze on its last frame while edits went on (#225); a press in the viewer always took the topmost layer, so a selected layer behind others couldn't be dragged (#230); the language didn't follow the system's (#229); and a list of missing After Effects behaviour (#227): drawing into, copying, pasting and duplicating shape contents, Tool Creates Shape / Mask and Fill / Stroke Options, Turbulent Displace, Wave Warp and Bulge pinning all but a shape layer's bottom-right quadrant, a Spacebar hold that previewed instead of being the Hand tool, the Effect menu in Effect Controls, dropping items on New Composition and dragging over layer switches. All were fixed with regression tests the same day (#235, #237–#241); multi-monitor support and the Project panel's empty-area menu (community PR #210) remain from #227, and effect points on shape and text layers still sit half a comp off. A list of tweaks from an Intel iMac (#290): the layer bar didn't show where extended footage runs past its source, and Enable Time Remapping then ended at the extended out point; footage items had no Interpret Footage in their menu and the work area bar no menu; Label menus named the labels without their colours; the arrow keys didn't nudge layers; a straight motion path had no Bezier handles; Delete on Time Remap deleted the layer; a mask being drawn with the Pen blacked out its layer until it was closed; a double-click on a mask point didn't select the whole mask. All were fixed with regression tests the same day; the rest of #290 had been fixed already (#221, #238, #255) or came with community PRs #210 (the Timeline's empty-area menu) and #213 (tool flyouts on a long press). A report of 9 October (#397): CC Particle World ignored the comp camera and looked flat. It now sees its particles through an active camera layer, as After Effects does, and through its own Extras ▸ Effect Camera (Distance, Rotation X / Y / Z, FOV, added) otherwise; the layer cache also missed camera and light moves for the effects that read them (Card Dance, Shatter, Card Wipe, Caustics). Fixed with regression tests the same day. Most checking happens on macOS. Localisation covers the menus in Japanese, Simplified and Traditional Chinese, and Ukrainian, and since 9 October the cataloged panels, dialogs and tooltips too (Simplified and Traditional Chinese, and Ukrainian; the Japanese rows of the panel catalog are still open); no accessibility work
+Issues #41–#47 (all from the Linux AppImage 0.1.1, 5 October): panning the viewer snaps back, panels can't be resized or rearranged, drag-and-drop and double-click import don't work, layer rename gets stuck, the Layer Settings arrow does nothing, the Project panel clips, the Wayland window icon is generic. Issues #63–#68 (macOS, 5 October): scaling a layer by its handles goes wrong and can stick at 0, two 3D compasses, the viewer lags while a layer is dragged (a frame renders in 20 ms but showed after ≈ 100 ms, behind RAM preview prefetch), the Discord and other links do nothing, Delete doesn't delete in the Project panel, hidden layers can be selected in the viewer. All but the last two were fixed or confirmed fixed with a test on 5–6 October (those two have community PRs); file drops still can't work on Wayland (winit has no support). The panning, rename and arrow bugs had been fixed in v0.2.0 already; nobody had told the reporter. A Windows user (6 October, on Discord) found the font menus listed only the three bundled fonts: installed fonts were read only when a project asked for one, on every platform. Fixed with a regression test on 6 October; the menus now list every installed family and its own styles, and agents get `text.fonts` / `list_fonts`. Seven reports of 6 October (Linux .deb and Windows): Project items and files couldn't be dropped on the viewer (#85), nor effects on a layer there (#88); drops in the Timeline ignored where they landed (#89); an angle's revolutions couldn't be edited (#93); toggling Audio, Lock or Shy threw away the RAM preview and playback with audio skipped frames (#103); running out of video memory panicked every frame thread and left frames stuck (#106); choosing a Render Settings template in the Render Queue did nothing (#117: any popup menu moved up to fit the window closed on the press). All seven were fixed with regression tests on 7 October. Reports of 7 October (Linux, macOS, Windows): the app opened the demo project on every launch, so a new comp landed in it (#204); a comp wider than the GPU's texture limit (11000 × 2200) at Full resolution stopped the window drawing (#201); an Intel HD Graphics 5500 couldn't start the app (#198: most likely the window's device asked for limits that GPU doesn't have, and the failure was silent); Audio Spectrum / Waveform stood still in the viewer (#209) and preview sound waited for the whole work area to cache (#208); a layer couldn't be deselected from the time graph, a shape layer's Fill and Stroke showed only with a shape tool and a drawn shape had no stroke to change, Alt+Shift+P didn't reveal Position (#205); a mask selected in the Timeline wasn't selected in the viewer, Mask Feather had no link and took negative values, the Project panel had no selection box (#203); shape layers had no Add menu for Trim Paths and the other operations, and Classic 3D comps hid Geometry Options (#206); dragging Puppet pins re-rendered the layer under the Puppet at every move (#212). All were fixed with regression tests the same day (#219–#222); the #198 fix couldn't be checked on that GPU. Reports of 8 October (browser, Windows, macOS): an empty project at 1280 × 800 with device pixel ratio 2 crashed on its first frame, because the Project panel's scroll bar clamped its thumb to a track shorter than the thumb (#231, any short panel on every platform); Media Browser ▸ Add Files… dropped a file it couldn't read without a word (#226); after the page's WebGPU device was lost, the browser editor froze on its last frame while edits went on (#225); a press in the viewer always took the topmost layer, so a selected layer behind others couldn't be dragged (#230); the language didn't follow the system's (#229); and a list of missing After Effects behaviour (#227): drawing into, copying, pasting and duplicating shape contents, Tool Creates Shape / Mask and Fill / Stroke Options, Turbulent Displace, Wave Warp and Bulge pinning all but a shape layer's bottom-right quadrant, a Spacebar hold that previewed instead of being the Hand tool, the Effect menu in Effect Controls, dropping items on New Composition and dragging over layer switches. All were fixed with regression tests the same day (#235, #237–#241); multi-monitor support and the Project panel's empty-area menu (community PR #210) remain from #227, and effect points on shape and text layers still sit half a comp off. A list of tweaks from an Intel iMac (#290): the layer bar didn't show where extended footage runs past its source, and Enable Time Remapping then ended at the extended out point; footage items had no Interpret Footage in their menu and the work area bar no menu; Label menus named the labels without their colours; the arrow keys didn't nudge layers; a straight motion path had no Bezier handles; Delete on Time Remap deleted the layer; a mask being drawn with the Pen blacked out its layer until it was closed; a double-click on a mask point didn't select the whole mask. All were fixed with regression tests the same day; the rest of #290 had been fixed already (#221, #238, #255) or came with community PRs #210 (the Timeline's empty-area menu) and #213 (tool flyouts on a long press). A report of 9 October (#397): CC Particle World ignored the comp camera and looked flat. It now sees its particles through an active camera layer, as After Effects does, and through its own Extras ▸ Effect Camera (Distance, Rotation X / Y / Z, FOV, added) otherwise; the layer cache also missed camera and light moves for the effects that read them (Card Dance, Shatter, Card Wipe, Caustics). Fixed with regression tests the same day. Most checking happens on macOS. Localisation covers the menus in Japanese, Simplified and Traditional Chinese, and Ukrainian, and since 9 October the cataloged panels, dialogs and tooltips too (Simplified and Traditional Chinese, and Ukrainian; the Japanese rows of the panel catalog are still open); accessibility is gap 25
 
 ### G3. Stability and a green main
 
@@ -238,7 +249,7 @@ Issues #41–#47 (all from the Linux AppImage 0.1.1, 5 October): panning the vie
   runs via `EFFECTCRAFT_FUZZ_ITERS` / `EFFECTCRAFT_FUZZ_SECS`). It found one crash, deeply nested
   XML overflowing the stack, now refused. Imported media and documents, expressions, scripts and
   control-channel / MCP requests are still to do.
-- Run the gate on every pull request in CI (gap 4): today no workflow runs the tests on PRs.
+- Keep the CI gate (gap 4, #2204) the same as `cargo xtask ci`: it runs on every pull request and push to `main`.
 - Fix the open crash reports first (gap 3). Further fuzzing and crash fixes are open in PR #855.
 - Done when: the gate is green on stable, runs on every pull request, and the fuzzers run
   regularly without new crashes.
@@ -299,8 +310,11 @@ Issues #41–#47 (all from the Linux AppImage 0.1.1, 5 October): panning the vie
   on the same extension points as After Effects: scripts, ScriptUI panels and effect plug-ins
   ([plugins.md](plugins.md#extension-points-compared-with-after-effects) compares them). ScriptUI
   panels in the user's ScriptUI Panels folder are listed in the Window menu, dock like any panel
-  and open again at the next launch. Missing: the Startup and Shutdown script folders, keyboard
-  shortcuts for scripts and `.jsxbin`; `#include` / `#target` directives landed (#759,
+  and open again at the next launch. The scripts in the Startup folder run at launch, and the desktop
+  app runs the Shutdown folder's scripts as it quits. Each File ▸ Scripts entry can be given a key in
+  Edit ▸ Keyboard Shortcuts. Missing: a global scope that scripts share for the session (a Startup
+  script's variables and functions are not available to later scripts) and `.jsxbin`;
+  `#include` / `#target` directives landed (#759,
   [scripting-parity.md](scripting-parity.md)).
 - Done so far: ease presets (#254) cover what ease-curve plug-ins are used for: easing curves kept
   by name and applied to pairs of keyframes. Modelled on a third-party panel, they are not core: a
@@ -313,8 +327,8 @@ Issues #41–#47 (all from the Linux AppImage 0.1.1, 5 October): panning the vie
 
 - Localisation of the interface ([localization-parity.md](localization-parity.md)): since 6–12
   October the menus are translated into Japanese, Simplified and Traditional Chinese, Ukrainian,
-  Spanish, Brazilian Portuguese, Russian, French, German, Czech and Georgian, and the panel catalog covers
-  Japanese, both Chinese, Ukrainian, Brazilian Portuguese, Czech and Georgian. Next: effect and parameter
+  Spanish, Brazilian Portuguese, Russian, French, German, Czech, Georgian and Swedish, and the panel catalog covers
+  Japanese, both Chinese, Ukrainian, Brazilian Portuguese, Czech, Georgian and Swedish. Next: effect and parameter
   names, the remaining panel strings (Spanish, Russian, French, German), Korean and Italian, and
   native-speaker review of all of them.
 - Accessibility (keyboard navigation, screen readers, contrast), user documentation and
@@ -336,6 +350,7 @@ Issues #41–#47 (all from the Linux AppImage 0.1.1, 5 October): panning the vie
 | Date | Change | Summary |
 |---|---|---|
 | 2026-10-16 | minor | Gap 8: #932 closed (Convert To Bezier Path converts a shape layer's parametric path, not only mask RotoBezier) |
+| 2026-10-13 | minor | Gap 25: an AccessKit audit test (per-panel counts, a ratchet for the unfixed panels) and a theme contrast test; Effects & Presets, Settings and Render Queue named and keyboard-operable (#1335); no screen reader tested |
 | 2026-10-13 | patch | G2: layer bounds no longer compete with editable shape/mask path points (#1220) |
 | 2026-10-12 | minor | Audited against `upstream/main` 470ea7a3: open-issue count and crash list, closed issues removed from rows 1, 3, 5, 6, 8–12, 15–17, 22–24, G8 and G9 (#759 `#include`), localization catalogs recounted (≈ 12% to ≈ 18%); rows 7, 14 and 21 left to open PRs #1102, #792 and #1098 |
 | 2026-10-10 | minor | Alpha gate checked: no alpha blockers |
diff --git a/docs/hardware-parity.md b/docs/hardware-parity.md
index 0a0a85a97..c25da4928 100644
--- a/docs/hardware-parity.md
+++ b/docs/hardware-parity.md
@@ -23,7 +23,7 @@ monitors are missing, and two GPU start-up failures are open.
 | HDR display | HDR monitoring on EDR / HDR displays | tone-mapped SDR view; no EDR output | no HDR output | no | no | Colour engine handles HDR maths (Rec. 2100 PQ/HLG output files) |
 | Pen tablets (pressure, tilt) | yes, for Paint and Roto | Brushes panel has pressure options, but no tablet pressure is read | same | same | same | Paint strokes store pressure per vertex; input never fills it |
 | Multiple monitors | panels and windows across screens | panels move into their own native windows on any screen (Move Panel to New Window; desktop builds) | same | same (#486) | — | gap 20 |
-| Touch / trackpad gestures | pinch zoom in viewers | egui pointer and scroll; no pinch-to-zoom audited | — | — | — | — |
+| Touch / trackpad gestures | pinch zoom in viewers | Composition and Layer viewers: two-finger scroll pans, pinch zooms around the pointer (Alt + scroll and the mouse wheel zoom too); Timeline pinch zooms time | two-finger scroll pans once it moves diagonally (a pixel-precise wheel keeps zooming); pinch arrives as Ctrl + scroll and zooms | same | same | No rotate or swipe gestures; tested in `ui_viewer_trackpad.rs` (UI logic, not on hardware) |
 | Audio hardware | Core Audio / ASIO / WASAPI, device choice, latency | cpal output; preview sound late after a start offset (#504 open; #554 closed) | cpal | cpal (ALSA) | Web Audio | No input or device latency settings |
 | Machine learning acceleration | Apple Neural Engine / GPU for Object Matte, Roto Brush 3 | CPU inference (pure Rust, rayon) | CPU | CPU | CPU | No GPU inference for MobileSAM or MediaPipe |
 | Memory management | RAM reserve, disk cache | RAM Reserved, Reduce Cache When Low on Memory, disk cache | same | same | OPFS disk cache | good |
diff --git a/docs/localization-parity.md b/docs/localization-parity.md
index d642af43c..d535f78d3 100644
--- a/docs/localization-parity.md
+++ b/docs/localization-parity.md
@@ -1,6 +1,6 @@
 # Localization parity
 
-> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-23 · **Change:** minor (Georgian: menus, panels and effect names; missing strings show in English; `missing_translations_report` lists them) · **Target:** Adobe After Effects 2026
+> **Last reviewed:** 2026-10-14 · **Last updated:** 2026-10-30 · **Change:** minor (Polish (`pl`): menus 630, panels 695; recounted at this tree after #1774: Japanese 1,923 of ≈ 4,200 interface strings (46%, with 297 effect names), Simplified Chinese 1,935 (46%, with 307 effect names), Traditional Chinese 1,581 (38%, its panel catalog 951 rows after #2244); overall ≈ 24%; previously: minor, the panel/dialog catalogs grow by 303 rows in Japanese, Simplified Chinese and Traditional Chinese: panel tabs, form and dialog labels, context menus, tracker/graph/text-panel labels, credits and File-panel footers; previously: minor, catalogs recounted at `upstream/main` 470ea7a3: menus in 10 languages, panels in 6, Hangul probe (#599)) · **Target:** Adobe After Effects 2026
 
 How much of EffectCraft's interface is translated, language by language, compared with After
 Effects. [gaps.md](gaps.md) gap 16 and workstream G9 hold the work;
@@ -17,28 +17,31 @@ interface; Arabic and Hebrew text *in layers* is supported through its Middle Ea
 ## How EffectCraft translates
 
 - **Menus:** `crates/ui-egui/src/i18n.rs`, one catalog per language keyed by
-  `(command, English label)` (624 catalog rows each at 470ea7a3, counted). A test
-  (`menu_catalogs_have_no_stale_or_duplicate_rows`) fails on a row whose entry left the menu tree
-  or on a repeated row. The generated Effect menu is not part of that fixed tree: its entries
-  and category submenus take their labels from the effect catalog below.
+  `(command, English label)`. A test (`menu_catalogs_have_no_stale_or_duplicate_rows`) fails on a
+  row whose entry left the menu tree or on a repeated row, so every catalog covers all fixed
+  entries (630 catalog rows each at this tree, counted; 629 in Georgian). The generated Effect menu is not part of
+  that fixed tree: its entries and category submenus take their labels from the effect catalog
+  below.
 - **Panels, dialogs, buttons, tooltips:** `crates/ui-egui/src/i18n/ui.rs`, keyed by the English
-  source string, with English fallback. Catalogs exist for Japanese (410 rows), Simplified and
-  Traditional Chinese (506 each), Ukrainian (505), Brazilian Portuguese (400) and Czech (501);
-  counted at 470ea7a3. Georgian has every row the Chinese catalogs have at this revision (695, as
-  both Chinese catalogs now have), plus 191 for panels converted to the catalog.
+  source string, with English fallback. Catalogs exist for Japanese (996 rows), Simplified
+  Chinese (998), Traditional Chinese (951, after #2244 pruned the table), Ukrainian (524),
+  Brazilian Portuguese (695), Czech (518) and Spanish (513); counted at this tree. Georgian has
+  the Simplified Chinese catalog's 694 rows, plus 191 for panels converted to the catalog since
+  (885 in all). Swedish (added later) also has one.
 - **Effect names:** `crates/ui-egui/src/i18n/effects.rs`, keyed by **effect id**, in Simplified
-  Chinese and Georgian (307 rows, one per effect in the registry, plus its 21 categories). The registry's
+  Chinese (307 rows, one per effect in the registry), Japanese (297 of the 307 ids), Georgian
+  (307 rows, plus its 21 categories) and Swedish (307 rows, plus its 21 categories). The registry's
   English name stays the effect's identity: `effect.list`, `effect.apply {"effect": …}`, scripts
   and expressions match on it, and the property tree stores it as the effect group's name. Only
   the drawing — the Effect menu, Effect Controls, the Timeline and Effects & Presets — goes
   through the catalog, so a project file is identical whichever interface language opens it.
   A repeat (`Gaussian Blur 2`) keeps the index the engine appends, and a group the user renamed
   in Effect Controls stays verbatim. Adding a language there is two tables and one arm, and no
-  panel changes: Traditional Chinese and Japanese have their tables in place and empty, so those
-  languages draw English until a translator fills them (the Japanese set for #821 is what that
-  slot is for). Each language decides for itself which names stay English — Adobe's Japanese
-  interface leaves the `CC`, `VR` and `OCIO` sets in English while its Chinese one translates
-  them — so a row repeating the English name is a choice, not a missing row.
+  panel changes: Traditional Chinese has its table in place and empty, and Japanese fills 297 of
+  the 307 ids, so the rest draw English until a translator completes them. Each language decides
+  for itself which names stay English — Adobe's Japanese interface leaves the `CC`, `VR` and
+  `OCIO` sets in English while its Chinese one translates them — so a row repeating the English
+  name is a choice, not a missing row.
 - **Missing strings:** a string with no row in the interface language shows in English, and no
   test, build or release fails on a missing translation. The `missing_translations_report` test
   (`crates/ui-egui/src/i18n.rs`) prints, per language, the fixed menu entries, panel strings, effect
@@ -60,49 +63,54 @@ interface; Arabic and Hebrew text *in layers* is supported through its Middle Ea
 
 ## Measurement
 
-Measured 10 October 2026 at `origin/main` 1446e27 and recounted on 12 October at `upstream/main`
-470ea7a3 by counting catalog rows (`const` tables in `crates/ui-egui/src/i18n.rs` and
-`i18n/ui.rs`; menu rows 624 per language, so the share is computed from 624 rather than 618). The
-denominator, **≈ 3,900 user-visible strings**, was estimated on 10 October and is kept: 618 fixed menu entries + ≈ 1,320 capitalised UI
-literals in `crates/ui-egui/src` outside tests and catalogs (a regex count, so an upper bound) +
-≈ 1,650 distinct effect parameter names + 306 effect names. Engine messages are not counted, so
-the true percentages are slightly lower.
+Measured 10 October 2026 at `origin/main` 1446e27, recounted on 22 October 2026 at `ad8b6acb`,
+and recounted again at this tree after #1774 by counting catalog rows (`const` tables in
+`crates/ui-egui/src/i18n.rs`, `i18n/ui.rs` and `i18n/effects.rs`: 630 menu rows, 998
+panel/dialog sources in Simplified Chinese, 951 in Traditional Chinese and 996 in Japanese). The
+denominator, **≈ 4,200 user-visible strings**, is a rounded estimate: the 630 fixed menu entries,
+the 998 panel/dialog sources, 307 effect names, ≈ 1,650 distinct effect parameter names and
+≈ 620 other unwrapped interface strings (Home screen literals, engine-built tooltips, error and
+status messages). It counts distinct strings, not catalog rows; engine messages are only partly
+counted, so the true percentages are slightly lower.
 
 | Language | Code | UI strings translated | Dialogs / tooltips / help | Script support | Native review | Status | To `full` |
 |---|---|---|---|---|---|---|---|
-| English | `en` | ≈ 3,900 (100%, source) | All; docs in English | — | yes | full | — |
-| Simplified Chinese | `zh-hans` | 1,130 (≈ 29%): menus 624 rows, panels 506 | Panels and dialogs partly; no help, effect names translated (306) and their parameter names not; Home screen literals unwrapped (#574, closed) | System CJK fallback; Han follows the UI language; CJK text in comps renders wrongly (#453); IME in text layers | no | partial | 6–9 h + review |
-| Spanish | `es` | 624 (≈ 16%) | Menus only (panel catalog in open PR #996) | Latin, fine | no | menus only | 7–10 h + review |
+| English | `en` | ≈ 4,200 (100%, source) | All; docs in English | — | yes | full | — |
+| Simplified Chinese | `zh-hans` | 1,935 (≈ 46%): menus 630 rows, panels 998, effect names 307 | Panels and dialogs partly; no help, effect names translated and their parameter names not; Home screen literals unwrapped (#574, closed) | System CJK fallback; Han follows the UI language; CJK text in comps renders wrongly (#453); IME in text layers | no | partial | 6–9 h + review |
+| Spanish | `es` | 1,142 (≈ 29%): menus 629 rows, panels 513 | Menus only; the panel catalog from #996 | Latin, fine | no | partial | 9–12 h + review |
 | Hindi | `hi` | 0 | — | UI: Devanagari fallback font but no shaping; text layers shape Devanagari | no | none (After Effects: none) | 9–13 h + shaping in the UI |
 | Arabic | `ar` | 0 | — | UI: Arabic fallback font but no shaping and no RTL layout; text layers: bidi + shaping | no | none (After Effects: none) | 9–13 h + 15–25 h RTL UI |
-| French | `fr` | 624 (≈ 16%) | Menus only | Latin, fine | no | menus only | 7–10 h + review |
-| Portuguese (Brazil) | `pt-br` | 1,024 (≈ 26%): menus 624 rows, panels 400 | Panels and dialogs partly | Latin, fine | no | partial | 6–9 h + review |
+| French | `fr` | 2,124 (≈ 51%): menus 632 rows, panels 1,184, effect names 308 | Panels and dialogs at the source list of the other panel catalogs; effect names and their 21 categories; no help; machine-translated from the English, not yet native-speaker proofread | Latin, fine | no | partial | 2–4 h + review |
+| Portuguese (Brazil) | `pt-br` | 1,324 (≈ 34%): menus 629 rows, panels 695 | Panels and dialogs at the Chinese catalogs' source list; the six keys main added after that count are translated too; AI-assisted, not yet native-speaker proofread | Latin, fine | no | partial | independent native review |
 | Indonesian | `id` | 0 | — | Latin, fine | no | none (After Effects: none) | 8–12 h + review |
-| Japanese | `ja` | 1,034 (≈ 27%): menus 624 rows, panels 410 | Panels and dialogs partly | Japanese system fallback; vertical text and Tate-Chu-Yoko in text layers; IME | no | partial | 6–9 h + review |
+| Japanese | `ja` | 1,923 (≈ 46%): menus 630 rows, panels 996, effect names 297 | Panels and dialogs partly; no help, effect names translated for 297 of the 307 ids and their parameter names not; Home screen literals unwrapped (#574, closed) | Japanese system fallback; vertical text and Tate-Chu-Yoko in text layers; IME | no | partial | 6–9 h + review |
 | German | `de` | 624 (≈ 16%) | Menus only (open PR #666 adds interface translations) | Latin, fine | no | menus only | 7–10 h + review |
 | Korean | `ko` | 0 | — | Hangul fallback probe added (#599, closed); not checked on macOS here | no | none | 9–13 h + review |
 | Vietnamese | `vi` | 0 | — | Latin with stacked diacritics; untested | no | none (After Effects: none) | 8–12 h + review |
 
-Other languages EffectCraft ships (4):
+Other languages EffectCraft ships (6):
 
 | Language | Code | UI strings translated | Status | To `full` |
 |---|---|---|---|---|
-| Traditional Chinese | `zh-hant` | 1,130 (≈ 29%): menus 624 rows, panels 506 | partial | 6–9 h + review |
-| Ukrainian | `uk` | 1,129 (≈ 29%): menus 624 rows, panels 505 | partial | 6–9 h + review |
-| Czech | `cs` | 1,125 (≈ 29%): menus 624 rows, panels 501 | Existing catalog entries covered; unwrapped UI, effects and engine text still in English; AI-assisted, not yet native-speaker proofread | Remaining strings + independent native review |
-| Georgian | `ka` | 1,514 (≈ 39%): menus 628 rows, panels 886 (the Chinese catalogs' 695 plus 191 Georgian-only rows: form dialogs, context menus, column headers), effect names 307 + 21 categories; native-speaker reviewed | partial | 5–8 h |
+| Traditional Chinese | `zh-hant` | 1,581 (≈ 38%): menus 630 rows, panels 951 | partial | 6–9 h + review |
+| Ukrainian | `uk` | 1,153 (≈ 29%): menus 629 rows, panels 524 | partial | 6–9 h + review |
+| Polish | `pl` | 1,325 (≈ 34%): menus 630 rows, panels 695 | partial; unwrapped UI, effects and engine text still in English; AI-drafted, native review welcome | Remaining strings + native review |
+| Czech | `cs` | 1,147 (≈ 29%): menus 629 rows, panels 518 | Existing catalog entries covered; unwrapped UI, effects and engine text still in English; AI-assisted, not yet native-speaker proofread | Remaining strings + independent native review |
+| Georgian | `ka` | 1,514 (≈ 39%): menus 629 rows, panels 885 (the Simplified Chinese catalog's 694 plus 191 Georgian-only rows: form dialogs, context menus, column headers), effect names 307 + 21 categories; native-speaker reviewed | partial | 5–8 h |
+| Swedish | `sv` | menus 630 rows, panels 723, effect names 307 and categories 21; added after the measurement above | Settings, Edit menu and Match System (`sv-*` locales) offer it; parameter and engine text still in English; not yet native-speaker reviewed | Remaining strings + native review |
 
-Russian (`ru`) has a menu catalog (624 rows, ≈ 16%); After Effects also ships Italian, which EffectCraft does not (8–12 h).
+Russian (`ru`) has a menu catalog (630 rows, ≈ 15%); After Effects also ships Italian, which EffectCraft does not (8–12 h).
 
-**Overall: ≈ 18%**, the average coverage of After Effects' 10 non-English languages
-(Simplified and Traditional Chinese 29%, Japanese 27%, Brazilian Portuguese 26%, Spanish, French,
-German and Russian 16%, Korean and Italian 0%; 175 / 10, was ≈ 12% on 10 October). This is the localization row in
-[target-app-parity.md](target-app-parity.md#by-dimension).
+**Overall: ≈ 24%**, the average coverage of After Effects' 10 non-English languages
+(Simplified Chinese 46%, Traditional Chinese 38%, Japanese 46%, Brazilian Portuguese 34%,
+Spanish 29%, French, German and Russian 16%, Korean and Italian 0%; 241 / 10, was ≈ 21% on
+22 October; Ukrainian (≈ 29%) and Czech (≈ 29%) are EffectCraft-only and stay out of that
+average). This is the localization row in [target-app-parity.md](target-app-parity.md#by-dimension).
 
 **Effort.** One-time work first: route parameter names and engine messages through
 a catalog, wrap the remaining panel literals, and add a Hangul probe (10–20 h). Then each language
-needs ≈ 2,900 more strings (≈ 5–9 h per language at the pace of #398 and #401). Parity with After
-Effects' 10 non-English languages: **≈ 60–110 h**; the four extra languages of the standard list
+needs ≈ 2,600 more strings (≈ 5–9 h per language at the pace of #398 and #401). Parity with After
+Effects' 10 non-English languages: **≈ 60–110 h**; the four extra languages
 (Hindi, Arabic, Indonesian, Vietnamese) add ≈ 50–80 h, most of it right-to-left layout and
 complex shaping in the interface. Every language needs native-speaker review, which only a human
 can give; only Georgian, contributed by a native speaker (#1843), has had it.
@@ -111,8 +119,12 @@ can give; only Georgian, contributed by a native speaker (#1843), has had it.
 
 | Date | Change | Summary |
 |---|---|---|
-| 2026-10-12 | minor | Recounted: Russian, French, German and Czech menus (#873, #987), Brazilian Portuguese and Czech panels (#830, #987), Hangul probe (#599); overall ≈ 12% to ≈ 18%; Korean and Italian still absent |
+| 2026-10-30 | minor | Recounted on the merged tree after #1774: Japanese 1,923 (46%, 297 effect names), Simplified Chinese 1,935 (46%, 307 effect names), Traditional Chinese 1,581 (38%, 951 panel rows after #2244's prune); overall ≈ 24% |
+| 2026-10-22 | minor | Panel/dialog second step: 300 more catalog rows in Japanese, Simplified Chinese and Traditional Chinese, plus the three rows the review found missing (Basic, Advanced and Play/Stop) — panel tabs, form and dialog labels, panel context menus, the tracker and graph controls, text-panel options, File-panel footers and credits; the panel tables are now 996 Japanese and 998 Simplified Chinese rows, all drawn through `tr`/`tr_args`, with the tests keeping the three catalogs listing the same sources; the 30 October recount above carries the share |
+| 2026-10-18 | minor | Brazilian Portuguese completes its panel catalog (278 new rows, 417 → 695, the Chinese catalogs' source list); the doc recount closes the drift the batch merges left in every language's panel count; AI-assisted, not yet native-speaker proofread |
 | 2026-10-14 | minor | Georgian (`ka`): menus 628, panels 886 (191 Georgian-only, in `GEORGIAN_PANELS`), effect names and categories in `effects.rs` |
-| 2026-10-10 | major | First localization parity document: catalog rows counted for all six languages, the twelve-language table, After Effects' 11 shipped languages from its bundle |
-| 2026-10-11 | minor | Ukrainian panel catalog brought level with the Chinese ones (495 of 496 rows, counted at this commit); its share rises to ≈ 29%. The other languages' panel counts are the 10 October measurement |
+| 2026-10-29 | minor | Polish (`pl`): menus 630, panels 695 |
 | 2026-10-13 | minor | Effect names and the generated Effect menu leave English: `i18n/effects.rs` adds 306 rows keyed by effect id (Simplified Chinese, from After Effects 2026's interface and Adobe's Chinese documentation for the `CC` series) and the 21 category names. Parameter names are still English; no other language has rows |
+| 2026-10-12 | minor | Recounted: Russian, French, German and Czech menus (#873, #987), Brazilian Portuguese and Czech panels (#830, #987), Hangul probe (#599); overall ≈ 12% to ≈ 18%; Korean and Italian still absent |
+| 2026-10-11 | minor | Ukrainian panel catalog brought level with the Chinese ones (495 of 496 rows, counted at this commit); its share rises to ≈ 29%. The other languages' panel counts are the 10 October measurement |
+| 2026-10-10 | major | First localization parity document: catalog rows counted for all six languages, the twelve-language table, After Effects' 11 shipped languages from its bundle |
diff --git a/docs/mcp.md b/docs/mcp.md
index 1104927ac..ccca7d2ba 100644
--- a/docs/mcp.md
+++ b/docs/mcp.md
@@ -11,7 +11,11 @@ written only under a write root; with no write root nothing is written. Every en
 (`execute_command`, `command_run`, each `batch` step) is checked before it runs: its file
 parameters must be absolute paths inside the roots (symbolic links resolved, no `..`), and so must
 any other absolute path in its parameters. Save, Increment and Save and rendering the Render
-Queue are checked against the files they write (the open project's, the queued outputs). Scripts
+Queue are checked against the files they write (the open project's, the queued outputs);
+`renderQueue.add`, `render.preRender` and `file.createProxy` without an output file need a saved
+project, since an unsaved one's default output would go to the home folder (#2479). In a headless
+session the footage a project names, and what an imported file pulls in, is read only inside the
+roots too: footage outside them shows as missing (#2131). Scripts
 (`run_script`, `file.runScript`…), Execute File, Reveal in Finder, `$N` references to file paths
 in a batch, and the bridge's UI-driving tools (`ui_click`, `ui_key`, `ui_type`, `ui_drag`,
 `ui_set`, `script_ui`, `control`) are refused while confined. Without the flags nothing changes.
@@ -20,7 +24,7 @@ The server provides the same core conventions as FilmCraft #28:
 
 | Tool | Arguments | Result |
 | --- | --- | --- |
-| `command_list` | `filter?`, `enabled_only?`, `schemas?` | Command catalog |
+| `command_list` | `filter?`, `enabled_only?`, `schemas?`, `compact?` | Command catalog |
 | `command_run` | `id`, `params?` | Engine command result |
 | `command_batch` | `steps: [{id, params?}]`, `stop_on_error?` | `completed`, `failed`, per-step `results` |
 | `doc_inspect` | none | Project overview and active composition |
@@ -51,6 +55,17 @@ receive `resultType: complete` and list/read cache hints; document reads are nev
 {"jsonrpc":"2.0","id":2,"method":"resources/read","params":{"uri":"effectcraft://document"}}
 ```
 
+## Two outputs on one file
+
+Two outputs of one job that write the same file (two items with one Output To, a duplicated item,
+output modules or segments that meet) refuse the whole `renderQueue.render` before anything is
+written: the reply is `isError: true`, naming both items, and the queue is left as it was.
+Sequences clash only on the frames both write. Skip Existing Files leaves earlier frames alone
+only when the exporter can check the final destination; browser/memory sinks and storage-overflow
+renders still report collisions. Preflight checks every configured overflow destination, since free
+space can change during a render. A new item's default output name is numbered (`Main.mp4`,
+`Main_1.mp4`) when another item of the queue writes it.
+
 ## Progress and cancellation
 
 Headless `command_run` / `execute_command` calls to `renderQueue.render` (unless `wait: false`)
diff --git a/docs/plugins.md b/docs/plugins.md
index a688a89b0..3b9182a60 100644
--- a/docs/plugins.md
+++ b/docs/plugins.md
@@ -12,12 +12,13 @@ Guide):
 | After Effects | EffectCraft | |
 |---|---|---|
 | Effect plug-ins (C/C++ SDK, `.aex` / `.plugin`) | [Effect plug-ins](#effect-plug-ins): WebAssembly modules (plug-in API v1) or Rust; the `Plug-ins` folder next to the settings loads at start-up | Different ABI: After Effects SDK plug-ins can't run (G8) |
-| Scripts folder: its scripts are listed in File ▸ Scripts | `Scripts/` in the settings folder (File ▸ Scripts ▸ Install Script File… copies a script there), listed in File ▸ Scripts with the bundled samples | Same |
+| Scripts folder: its scripts are listed in File ▸ Scripts | `Scripts/` in the settings folder (File ▸ Scripts ▸ Install Script File… copies a script there), listed in File ▸ Scripts with the bundled samples; a subfolder (one level) is a submenu named after it | Same |
 | File ▸ Scripts ▸ Run Script File… (`.jsx`, `.jsxbin`) | `.jsx` / `.js` | Gap: `.jsxbin` (an undocumented binary encoding) |
+| File ▸ Scripts ▸ Recent Script Files: the 10 most recently run scripts; Cmd+Option+Shift+D (Ctrl+Alt+Shift+D on Windows) reruns one | File ▸ Scripts ▸ Recent Script Files lists the 10 scripts run last (script files and File ▸ Scripts entries, newest first, kept in the settings); Cmd+Alt+Shift+D runs the most recent one again (`file.runScript {"recent": 0}`, a key that can be changed in Edit ▸ Keyboard Shortcuts) | Same |
 | ExtendScript preprocessor directives (`#include`, `#target`, `#targetengine`) | `#include` / `//@include` / `#includepath` inline files relative to the script (once each, depth-limited, file gate applies); `#target`, `#targetengine`, `#strict` are ignored | Same |
-| `Scripts/Startup` and `Scripts/Shutdown`: run in alphabetical order when the app starts and quits | Not run | Gap |
-| `Scripts/ScriptUI Panels`: listed at the bottom of the Window menu, dockable like the app's own panels, `this` is the panel | `Scripts/ScriptUI Panels/` in the settings folder (File ▸ Scripts ▸ Install ScriptUI Panel… copies one there), listed at the bottom of the Window menu, docked like any panel, `this` is the panel; the panels open when the app quits open again at the next launch | Same. Where a panel was docked isn't kept: workspace layouts aren't saved between launches |
-| Keyboard shortcuts for scripts (the Keyboard Shortcuts editor lists the scripts of the Scripts folder) | Shortcuts bind to commands and menu entries; the File ▸ Scripts and Window menu entries of scripts aren't offered | Gap |
+| `Scripts/Startup` and `Scripts/Shutdown`: run in alphabetical order when the app starts and quits | `Scripts/Startup/` and `Scripts/Shutdown/` in the settings folder, in alphabetical order (case ignored): the Startup scripts run at launch before a project opens, and the Shutdown scripts run as the desktop app quits, after the project is closed. A Startup script that fails is reported in a toast and in the log, a Shutdown script that fails is reported in the log, and the next script still runs | Partial: each script runs in its own global scope, so variables and functions a Startup script defines are not available to later scripts; a Startup script's modal dialog stays open while the next scripts run and the app starts; a Shutdown script's modal dialogs close as if canceled; the web app runs no Shutdown scripts |
+| `Scripts/ScriptUI Panels`: listed at the bottom of the Window menu, dockable like the app's own panels, `this` is the panel | `Scripts/ScriptUI Panels/` in the settings folder (File ▸ Scripts ▸ Install ScriptUI Panel… copies one there), listed at the bottom of the Window menu (a subfolder, one level, is a submenu named after it), docked like any panel, `this` is the panel; the panels open when the app quits open again at the next launch | Same. Where a panel was docked isn't kept: workspace layouts aren't saved between launches |
+| Keyboard shortcuts for scripts (the Keyboard Shortcuts editor lists the scripts of the Scripts folder) | Edit ▸ Keyboard Shortcuts lists the scripts of File ▸ Scripts under File ▸ Scripts (`file.runScript {"name": "<file name>"}`); a key given to one is saved with the preset, File ▸ Scripts shows it, and pressing it runs the script as its menu entry does | Same. After Effects binds a key to a script's place in the alphabetical list (`ExecuteScriptMenuItem01`…), and EffectCraft binds it to the script's file name. The Window menu entries of ScriptUI panels aren't offered |
 | Running a script from the command line (`afterfx -r script.jsx`) | `effectcraft-cli script`, the control channel's and MCP's `script.run` | Same purpose, other entry points |
 | `app.settings` (kept in the preferences between sessions) | Kept in `script_settings.json` in the settings folder (`script.settings.get` / `script.settings.save`) | Same |
 | Allow Scripts to Write Files and Access Network | Settings ▸ Scripting & Expressions | Same |
@@ -38,8 +39,17 @@ journaled and the same as the UI's action. The `effectcraft-script` crate's docs
   file.jsx`, or `script.run {code, name}` over the control channel and MCP.
 * Install one: File ▸ Scripts ▸ Install Script File… (or copy it into `Scripts/` in the settings
   folder). It is listed in File ▸ Scripts at once (After Effects asks for a restart).
+* Run one at every launch or quit: copy it into `Scripts/Startup/` or `Scripts/Shutdown/` in the
+  settings folder. These scripts are not listed in File ▸ Scripts. `file.runStartupScripts` and
+  `file.runShutdownScripts` run them and return `{ran, waiting, failed}`; the desktop app calls them at
+  launch and quit, and the web app calls `file.runStartupScripts` at launch.
 * `file.scripts.list` lists installed and bundled scripts and panels; `file.runScript {name}` runs
   one; `file.uninstallScript {name}` removes an installed one.
+* A subfolder of `Scripts/` is a submenu of File ▸ Scripts named after the folder, and its scripts
+  are named `Folder/File.jsx` in `file.scripts.list` and `file.runScript`. One level of folders is
+  listed; deeper folders are not. `file.uninstallScript` removes only scripts at the top of the
+  Scripts folders: delete a script in a subfolder yourself. A subfolder may be a link to another
+  folder (an extension's own), and uninstall never deletes a file through it.
 
 ## ScriptUI panels
 
@@ -51,6 +61,13 @@ other panel. Closing the tab closes the panel (its `onClose` runs). Panels open
 quits open again at the next launch (`window.restoreScriptPanels`, which the desktop and web apps
 run at start-up; the list is `scriptui_panels.json` in the settings folder).
 
+To group panels, for example the several panels of one extension, make a subfolder of
+`Scripts/ScriptUI Panels/` and put them in it: `Scripts/ScriptUI Panels/My Tools/Animate.jsx` is
+listed as Window ▸ My Tools ▸ Animate.jsx, its tab is titled Animate, and commands name it
+`My Tools/Animate.jsx` (`window.scriptPanel {name}`). One level of folders is listed. Install
+ScriptUI Panel… copies a panel to the top of the folder; make the subfolder and move panels into it
+yourself, and delete them from it yourself too.
+
 Run from File ▸ Scripts instead, the same script gets no panel, so it should make a floating
 palette itself. A minimal panel:
 
diff --git a/docs/preferences.md b/docs/preferences.md
index ce96da0bf..68f9defb7 100644
--- a/docs/preferences.md
+++ b/docs/preferences.md
@@ -30,11 +30,12 @@ Commands (CLI, MCP, control channel):
 
 ### Settings that change behaviour
 
-- `general.language`: interface language (`system` / `en` / `ja` / `zh-hans` / `zh-hant` / `uk` / `es` / `pt-br` / `ka`), Settings ▸ General ▸ Language; menu labels change immediately. `system` (Match System, the default) follows the operating system's interface language where EffectCraft has a translation and is English otherwise: a Simplified Chinese locale (`zh`, `zh-CN`, `zh_CN.UTF-8`, `zh-Hans-CN`, `zh-SG`) selects `zh-hans`, a Traditional one (`zh-TW`, `zh-HK`, `zh-Hant`, `zh_MO`) selects `zh-hant`, a Ukrainian one (`uk`, `uk-UA`, `uk_UA.UTF-8`) selects `uk`, a Spanish one (`es`, `es-ES`, `es_MX.UTF-8`) selects `es`, a Portuguese one (`pt`, `pt-BR`, `pt_PT.UTF-8`) selects `pt-br`, a Georgian one (`ka`, `ka-GE`, `ka_GE.UTF-8`) selects `ka`; the browser build follows `?lang=` in the address, then the browser's languages (`navigator.languages`). Choose **Español** or **Português (Brasil)** for Spanish or Brazilian Portuguese menus (panels stay in English for now); choose **Українська** for Ukrainian menus and cataloged panel, dialog, button and tooltip text; Ukrainian uses the bundled UI fonts. Native Japanese, Simplified and Traditional Chinese UI uses installed system fonts; the web host must supply a Japanese font. The same setting picks the CJK fallback for the interface *and* the Han preference of the text engine, so the composition's own text is drawn with the same language's glyph forms (the text engine's preference is process-global); swapping the language reinstalls the fonts, so it applies without a restart. Two catalogs back the text: the menus are keyed by `(command, English label)` (`crates/ui-egui/src/i18n.rs`), and the rest of the interface - panels, dialogs, buttons, tooltips - is keyed by its English source string (`crates/ui-egui/src/i18n/ui.rs`, with rows for Japanese, Simplified and Traditional Chinese and Ukrainian), where a panel writes `tr("Rename")`, or `tr_args("Proxy Use: {}", &[&quality])` when the row carries a value. A row that is missing falls back to English, so a new string shows up untranslated rather than empty; the `missing_translations_report` test lists what each language lacks, and the tests in `ui.rs` fail on an unused row.
+- `general.language`: interface language (`system` / `en` / `ja` / `zh-hans` / `zh-hant` / `uk` / `es` / `pt-br` / `ka` / `sv`), Settings ▸ General ▸ Language; menu labels change immediately. `system` (Match System, the default) follows the operating system's interface language where EffectCraft has a translation and is English otherwise: a Simplified Chinese locale (`zh`, `zh-CN`, `zh_CN.UTF-8`, `zh-Hans-CN`, `zh-SG`) selects `zh-hans`, a Traditional one (`zh-TW`, `zh-HK`, `zh-Hant`, `zh_MO`) selects `zh-hant`, a Ukrainian one (`uk`, `uk-UA`, `uk_UA.UTF-8`) selects `uk`, a Spanish one (`es`, `es-ES`, `es_MX.UTF-8`) selects `es`, a Portuguese one (`pt`, `pt-BR`, `pt_PT.UTF-8`) selects `pt-br`, a Georgian one (`ka`, `ka-GE`, `ka_GE.UTF-8`) selects `ka`, a Swedish one (`sv`, `sv-SE`, `sv_SE.UTF-8`) selects `sv`; the browser build follows `?lang=` in the address, then the browser's languages (`navigator.languages`). Choose **Español** or **Português (Brasil)** for Spanish or Brazilian Portuguese menus (panels stay in English for now); choose **Українська** for Ukrainian menus and cataloged panel, dialog, button and tooltip text; Ukrainian uses the bundled UI fonts. Choose **Svenska** for Swedish menus, panels and effect names. Native Japanese, Simplified and Traditional Chinese UI uses installed system fonts; the web host must supply a Japanese font. The same setting picks the CJK fallback for the interface *and* the Han preference of the text engine, so the composition's own text is drawn with the same language's glyph forms (the text engine's preference is process-global); swapping the language reinstalls the fonts, so it applies without a restart. Two catalogs back the text: the menus are keyed by `(command, English label)` (`crates/ui-egui/src/i18n.rs`), and the rest of the interface - panels, dialogs, buttons, tooltips - is keyed by its English source string (`crates/ui-egui/src/i18n/ui.rs`, with rows for Japanese, Simplified and Traditional Chinese and Ukrainian), where a panel writes `tr("Rename")`, or `tr_args("Proxy Use: {}", &[&quality])` when the row carries a value. A row that is missing falls back to English, so a new string shows up untranslated rather than empty; the `missing_translations_report` test lists what each language lacks, and the tests in `ui.rs` fail on an unused row.
 - `general.undoLevels`: Levels of Undo
 - `general.pathPointSize`: Path Point and Handle Size
 - `general.recentItems`: Recent Projects Shown
 - `general.showToolTips`: Show Tool Tips
+- `general.viewerWheelScrubbing`: Scrub Composition Frames with Mouse Wheel (off by default). On: an unmodified mouse wheel over the Composition viewer steps frames, and the smoothed tail of that notch does not zoom or pan. Ctrl/Cmd+wheel and a trackpad still zoom and pan.
 - `general.createLayersAtCompStart`: Create Layers at Composition Start Time
 - `general.defaultSpatialLinear`: Default Spatial Interpolation to Linear
 - `startup.showHomeOnLaunch`: Show Home Screen When Launching
@@ -42,6 +43,7 @@ Commands (CLI, MCP, control channel):
 - `startup.windowGraphics`: Window Graphics (`auto` / `gl`), what the desktop window draws with from the next launch. `auto` lets the platform pick (DirectX 12, Vulkan or Metal); `gl` uses OpenGL, with CPU compositing, for graphics drivers that crash with the others. A launch leaves a `launch-pending` marker in the settings folder until its window has been drawing for a few seconds (or the app quits normally before that); a launch that stops earlier (a graphics driver crashing as the window opens or as its surface is re-created) leaves the marker behind, and the next launch switches to `gl` and says so (not on macOS, which has no OpenGL backend). `WGPU_BACKEND` overrides both.
 - `project.useTemplate`: New Project Loads Template
 - `project.templatePath`: Template Project
+- `project.compactProjectFiles`: Save Compact Project Files (default off). Off: File ▸ Save writes `.ecproj` files as indented JSON, one value per line, easy to read and diff in version control. On: compact JSON on one line, smaller and faster to save and open. Either opens the same; auto-saves, XML copies and template packages are not affected.
 - `autoSave.enabled`: Automatically Save Projects
 - `autoSave.intervalMinutes`: Save Every
 - `autoSave.maxVersions`: Maximum Project Versions
@@ -119,9 +121,11 @@ Commands (CLI, MCP, control channel):
 - `import.reportMissingFrames`: gaps in an image sequence's numbering are reported on import
   (they show as colour-bar placeholders, as in After Effects; see [footage.md](footage.md))
 - `import.autoReloadFootage`: Automatically Reload Footage, `off`, `nonSequence` (the default, as
-  in After Effects) or `all` (image sequences too). Every two seconds,
-  and as soon as the window comes back to the front, the desktop app compares each footage file's
-  size and modification time with what they were, and reloads what another app saved: a
+  in After Effects) or `all` (image sequences too). Every two seconds while its window is in
+  front (every ten seconds while another app has the front), and as soon as the window comes back
+  to the front, the desktop app compares each footage file's size and modification time with what
+  they were, on a worker thread that only wakes the interface when something changed, and reloads
+  what another app saved: a
   Photoshop file edited in PhotoCraft or Photoshop shows its new pixels without File ▸ Reload
   Footage. It is not an undo step and doesn't modify the project; a layer item stays on its layer
   (found again by name), and a file that can't be read yet (still being written) is tried again once it changes again.
@@ -189,7 +193,8 @@ Effect Controls uses compact, fixed 20 pt parameter rows, as After Effects does:
 Edit ▸ Keyboard Shortcuts (`Cmd+Alt+'`) opens the shortcut editor: an on-screen keyboard showing
 which keys are assigned for the held modifiers (purple: application-wide, green: panel-specific,
 both: split), modifier toggles, a searchable list of every command (all engine commands, menu
-entries with bound parameters and the frontend's tool / panel commands), and a preset menu.
+entries with bound parameters, the scripts File ▸ Scripts lists and the frontend's tool / panel
+commands), and a preset menu.
 
 - **Presets.** "EffectCraft Default" is After Effects' default layout and is read-only; editing
   it creates a "Custom" copy. Custom presets store only their differences from the default and
@@ -198,8 +203,15 @@ entries with bound parameters and the frontend's tool / panel commands), and a p
 - **Assigning.** Select a command, then press keys in the shortcut field (or type them), or
   click a key on the keyboard with the modifiers toggled. Conflicts with other commands in an
   overlapping scope are listed before you assign.
-- **Scope.** Menu and engine commands are application-wide; timeline commands work in the
-  Timeline and viewer commands in the Composition panel.
+- **Scope.** A shortcut belongs to the application, to a panel (Project, Timeline, Composition,
+  Render Queue…) or to a context (editing text, a paint tool or a camera tool active, a mask
+  selected). One chord can be bound once per scope, and the narrowest active scope runs it: an
+  active context, then the panel with the keyboard, then the application. The Timeline and the
+  Composition panel share their shortcuts. A context's shortcuts work only while it is active;
+  a panel's shortcut that nothing nearer claims still works from the other panels.
+- **Conflicts.** Two commands of one scope on one chord are a conflict (`shortcuts.conflicts`
+  lists them; the default preset has none). The same chord in two scopes is an override: both
+  keep working, and `shortcuts.set` reports it with `overrides: true`.
 
 Commands: `shortcuts.list {query?, keys?, assigned?}`, `shortcuts.set {command, params?, keys}`,
 `shortcuts.reset {command?}`, `shortcuts.preset {op: select|new|duplicate|delete|rename, name?,
diff --git a/docs/releasing.md b/docs/releasing.md
index bd28d8ec3..07d988b5c 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -71,7 +71,7 @@ The MSI's setup wizard ([`installer-ui.wxs`](../packaging/windows/installer-ui.w
 choose the install folder; upgrades and repairs reuse it, and `INSTALLFOLDER="..."` picks it for a
 silent (`/qn`) install. [`packaging-lint.yml`](../.github/workflows/packaging-lint.yml) install-tests
 that with stub binaries ([`test-msi.ps1`](../packaging/windows/test-msi.ps1)): a custom folder,
-an upgrade that keeps it, a repair, uninstall, and the Program Files default. The wizard pages
+an upgrade that keeps it, a repair, uninstall, and the all-users default folder (`Program Files\ArtCraft\EffectCraft`). The wizard pages
 themselves are checked by hand.
 
 The portable zip ships [`portable.txt`](../packaging/windows/portable.txt) beside `effectcraft.exe`.
diff --git a/docs/roadmap.md b/docs/roadmap.md
index 73fdfd235..5c71645e7 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -23,7 +23,7 @@ In this order (gap numbers from [gaps.md](gaps.md)):
 
 The core workflows of a motion designer in After Effects, checked on EffectCraft's main platform
 (macOS) from the scripted UI tests, the live After Effects ease oracle and the open issues
-(standard: craftrules `standards/progress-docs.md`, "Stages"). **All six pass, so EffectCraft is
+**All six pass, so EffectCraft is
 alpha**: each works end to end and the work saves and reopens; what's rough in them is listed, but
 none blocks the workflow.
 
diff --git a/docs/roto-brush-sam2.md b/docs/roto-brush-sam2.md
new file mode 100644
index 000000000..0204058d5
--- /dev/null
+++ b/docs/roto-brush-sam2.md
@@ -0,0 +1,209 @@
+# Roto Brush with SAM 2
+
+Roto Brush can follow an object through a clip with Meta's **SAM 2.1 Tiny** (Hiera-Tiny, 39M parameters,
+Apache-2.0). It is optional: nothing changes until you install the model and choose it.
+
+## Using it
+1. Settings ▸ Roto Brush ▸ SAM 2.1 Tiny ▸ **Install from File…** with the published `model.safetensors`
+   (155.9 MB). The file's size and SHA-256 are checked and the licence notice is kept next to it.
+   Agents: `roto.model.install {id: "sam2.1-hiera-tiny", path: "model.safetensors"}`.
+   SAM 2 has no in-app download until the weights are mirrored under storytold control.
+   Each model card links its pinned Hugging Face `model.safetensors` checkpoint, rather than the
+   project's different `.pt` files. Its checkpoint source and SHA-256 are retained in the notice.
+2. Choose it (`roto.model.select {id: "sam2.1-hiera-tiny", wait: true}` for agents). Installing an
+   unselected model does not activate it, even with `wait: true` on installation.
+3. Paint strokes on the base frame as usual, then **Propagate**. One tracking pass follows the object through the
+   whole span in both directions, using SAM 2's streaming memory, so it keeps tracking through occlusion and when the
+   object leaves the frame and returns. Each frame's probability map is then refined by the same graph cut as every other
+   Roto Brush frame: your strokes stay hard constraints and edges snap to colour.
+4. `roto.status {frame}` reports `source` (`tracker`, `model` for a frame the model segmented on its own, or
+   `classical`) and, for tracked frames, `tracker.frames[f]`: `confidence` (0–1, the model's object score times its
+   predicted mask quality) and `occluded` (the object is not in the frame: an empty matte). `model` says what Settings
+   chose and whether it is installed, loaded and loading; `notice` says when it is not the one in use for the layer.
+   `tracker.saved` names the model the saved frames came from.
+
+With SAM 2 chosen but not installed, or failing to load, Propagate refuses with the reason. A tracker failure during
+propagation can fall back to classic; its warning is live progress only, as described under [Memory and limits](#memory-and-limits).
+While it is still loading, `wait: true` (agents) loads it first; without `wait` it
+refuses, and the load goes on in the background. Deselecting SAM 2 (choosing Classic) runs Propagate exactly as before,
+and Roto Brush 1.0 never uses a model.
+
+Tracked frames are saved in the project with the instance, as Freeze's are, so a saved project renders the same when it
+reopens, in the app or with `effectcraft-cli`, without the model being loaded or chosen there. They apply while the
+strokes and span they came from are unchanged. Changing a stroke or the span makes them stale until the next Propagate.
+Choosing another model, or the classic engine, leaves them in place and `roto.status` says so. They retain the original
+model tag and per-object cache keys when rendered or re-saved; the next Propagate replaces them using the selected
+model (or classic engine). Object Matte saves nothing.
+
+## Several objects in one instance
+A Roto Brush instance can hold several objects. The **Object N** button in the Layer panel's bar picks the object new
+strokes belong to (it cycles through the objects that have strokes), and **+** starts a new one. Agents: `roto.options
+{object}` sets the current object, `roto.stroke` takes `object` (0–31; default the current one), `roto.clearStrokes`
+takes `object` to remove one object's strokes, and `roto.status` lists `objects` (`{id, strokes}`) and `currentObject`.
+
+With SAM 2, Propagate follows every object in **one pass** (the frame is encoded once, whatever the number of objects), each
+from its own foreground and background strokes, and the mattes are united into the instance's one matte. Each object keeps
+its own occlusion: the frame counts as absent only when every object is, and otherwise the least sure object sets the
+frame's confidence on the span bar. A background stroke belongs to its object, so it separates that object from what
+lies under it without cutting a hole in the others. Refine Edge strokes belong to the whole matte. The classic engine has
+no objects: all foreground strokes make one object, and background strokes apply to it as before. Saved projects are
+unchanged (strokes without an object are object 0, and nothing is written for object 0).
+
+**Seeing and choosing objects.** The Layer panel's boundary view outlines each object in its own colour (object 1 in the
+chosen boundary colour, the others from a palette), and the picker button carries the current object's colour. **Show
+Object** (Roto Brush Matte, a slider: 0 shows all objects together, N shows object N alone) limits the instance's matte to
+one object, so an effect after it can treat the pieces separately; an object the instance does not have shows nothing, and
+with one object, or on frames the classic engine made, the setting changes nothing. Each object's matte is kept next to
+the united one, in the session and in the saved tracking (`tracked` stores them only when there are several objects), so
+Show Object renders the same after the project is reopened. Freeze records the Show Object that was set.
+
+This is not several Roto Brush instances sharing a pass: each instance reads the layer after the effects above it, so
+instances can see different pixels. Objects inside one instance always see the same ones.
+
+## Sizes
+Four checkpoints are in the registry (Settings ▸ Roto Brush); the size is detected from the file, and each is
+pinned to a Hugging Face commit with its SHA-256. All run the same tracker; a bigger backbone costs time and memory.
+
+| Model | File size | GPU encode (RX 7900 GRE) | Agreement with PyTorch |
+|---|---|---|---|
+| SAM 2.1 Tiny (`sam2.1-hiera-tiny`) | 155.9 MB | 0.24 s | encoder 6.8e-6 |
+| SAM 2.1 Small (`sam2.1-hiera-small`) | 184.3 MB | 0.20 s | encoder 1.0e-5 |
+| SAM 2.1 Base+ (`sam2.1-hiera-base-plus`) | 323.5 MB | 0.37 s | encoder 2.3e-5 |
+| SAM 2.1 Large (`sam2.1-hiera-large`) | 897.9 MB | 0.72 s | encoder 5.2e-4 |
+
+### How the sizes compare on the benchmark clips
+`effectcraft-cli bench --roto --frames 24 --fixes --sam2 FILE`, release build, SAM 2 on the GPU (RX 7900 GRE), one run each.
+Mean IoU (after the object returns, in brackets) and seconds per tracked frame:
+
+| Clip | Tiny | Small | Base+ | Large |
+|---|---|---|---|---|
+| move | 0.992 | 0.988 | 0.986 | 0.994 |
+| light | 0.990 | 0.985 | 0.987 | 0.993 |
+| occlusion | 0.989 (0.987) | 0.988 (0.984) | 0.987 (0.984) | 0.989 (0.987) |
+| reenter | 0.982 (0.975) | 0.981 (0.970) | 0.978 (0.966) | **0.694 (0.110)** |
+| s / tracked frame | 0.69 | 0.70 | 0.79 | 1.17 |
+
+The classic engine scores 0.98 / 0.98 / 0.49 / 0.62 on the same clips. Peak tracker state is 88 MB for every size (the
+weights are not counted). The clips are synthetic and easy, so they cannot tell the sizes apart on accuracy: **no larger
+size tracked better here, and Large lost the object after it left and came back** (IoU 0.11 after the return, where
+Tiny, Small and Base+ found it again). That is the model's behaviour on this clip, not the port:
+Large matches PyTorch stage by stage. Whether a larger size helps on real footage is not measured.
+
+Settings therefore marks **Tiny** as recommended (the smallest download, and nothing larger did better), and says what was
+measured for the others; Base+ and Large also warn when no GPU was found (they take several seconds a frame on a CPU).
+The list carries `recommended` and `hint` per model (`roto.models`).
+
+### Half-precision weights (optional)
+`EFFECTCRAFT_SAM2_F16=1` keeps the weight matrices on the GPU as half precision, halving their memory (Large: about
+900 MB to 450 MB). It is off by default: the video logit error against PyTorch grows from about 0.003 to 0.06 (Tiny)
+and 0.12 (Large) with the same masks, and the speed gain is under 10% (Large encode 0.72 s to 0.66 s).
+
+### What stays on the CPU
+The mask decoder takes about 110 ms of a tracked frame (attention layers 42 ms, the two upscaling convolutions 50 ms).
+Rewriting the upscaling convolutions as a matrix product and a pixel shuffle did not make them faster, and a GPU port
+would save under 0.1 s of a 0.7 s frame, so it stays on the CPU.
+
+Every size was checked stage by stage against PyTorch (patch embedding, each Hiera block, neck, prompt encoder,
+decoder, memory encoder, memory attention) and on a whole clip forward and backward, on the CPU and the GPU: the video
+logit error is at most 0.005 with the same masks. Large carries much larger activations (peaks near 300 in the third
+stage), so its f32 rounding error is larger in absolute terms; its tests use a bound relative to the peak. Large needs
+the GPU to run per block (the encode submits once per block so intermediates are freed); a GPU error of any kind falls
+back to the CPU.
+
+## Corrections re-track only what they change
+A correction stroke changes the keys of the frames from it on (in both directions from the base), so Propagate tracks
+only those again: the window starts at the nearest prompted frame at or before the first frame it needs (the corrected
+frame, which restarts the object with its own prompt) and runs to the last frame it needs. Frames before the correction
+keep their tracked results, and a Propagate with nothing changed does no tracking. The older non-conditioning memory
+frames before the corrected frame are not rebuilt, so frames just after it can differ slightly from a from-scratch pass.
+Tracked frames of a session are in memory; a project reopened in a new process re-tracks the whole span after a stroke
+change (its saved tracking is stale as a whole).
+
+## Memory and limits
+The weights take about 156 MB. A model idle for 10 minutes is unloaded (a toast says so; the choice stays) and loads
+again when a Propagate or a stroke needs it. The tracker holds the memory banks of the objects it follows (about 2 MB per
+stored frame, pruned to the frames later ones can still look at) and refuses to grow past 2 GiB, or past a time limit when
+one is set, with a clear error instead of running out of memory. Two runs of the same prompts give bit-identical masks on
+the CPU.
+
+Pending per-object probability maps have a separate 256 MiB budget, including their allocated capacity and frame
+slots. This bounds the full-resolution results waiting to be united when objects first prompted on different frames
+report in separate passes. Reaching the budget cancels tracking and falls back to the classic engine. The reason is
+available as `trackerNote` in live job progress only. Completion removes that progress and shows a success toast, so
+`wait: true` callers can miss the fallback reason; the completion toast alone does not confirm the tracker was used.
+A single object's results need no pending buffer.
+
+## How it works
+`crates/sam2` is a Rust port (on [candle](https://github.com/huggingface/candle), native only) of the Hugging Face
+`transformers` SAM 2 implementation, Apache-2.0 (see its `NOTICE`). Every stage is checked against PyTorch by
+`crates/sam2/tests/it/reference.rs` (they skip without the weights; reference tensors come from
+`tools/sam2_reference.py` and `tools/sam2_video_reference.py`):
+
+| Stage | Max abs error vs PyTorch |
+|---|---|
+| Hiera backbone, 12 blocks | 2.6e-5 |
+| Neck features / position encodings | 9.7e-6 / 6e-8 |
+| Prompt embeddings | 1.2e-7 |
+| Mask decoder (logits up to 11.6) | 1.1e-4 |
+| Memory encoder | 3.5e-6 |
+| Memory attention (rotary) | 2.6e-5 |
+| 7-frame clip, forwards and backwards (9 frame results) | logits 0.0038, IoU 1.0000 |
+
+SAM 2 is prompted with at most three foreground and three background points per frame: it was trained on a handful
+of clicks, and measured confidence collapses with many (0.99 with 1–7 points, 0.25 with 16, 0.00 with 32).
+
+## Speed (this PC: AMD RX 7900 GRE and a 16-thread CPU, release build)
+SAM 2 runs on the GPU when there is one (wgpu compute kernels, so AMD, NVIDIA and Intel alike; candle itself has no AMD
+backend) and on the CPU otherwise. The model loads on the GPU automatically; `EFFECTCRAFT_SAM2_DEVICE=cpu` (or `gpu`)
+overrides it. A GPU that fails (no adapter, out of memory, a lost device) makes the CPU take over for the rest of the
+session, and `roto.status` reports `tracker.device` (the GPU's name, or `CPU`).
+
+| Step | CPU | GPU |
+|---|---|---|
+| Encode one 1024 × 1024 frame | 2.05 s | **0.24 s** |
+| Memory attention (full bank of 7 memory frames) | 2.3 s | **0.29 s** |
+| Memory encoder | 0.24 s | 0.05 s |
+| Decoder (CPU on both) | 0.11 s | 0.11 s |
+| **A tracked frame in all** | **4.3 s** | **0.7 s** |
+| A click on an encoded frame | 0.10 s | 0.10 s |
+
+A 300-frame clip takes about 21 minutes on the CPU and about 3.5 minutes on this GPU; the decoder, still on the CPU, is the
+next 16 % of a GPU frame. The CPU numbers came down from 3.4 s per encode at the start of the speed
+work (parallel GELU and bias add, cached position encodings, pooling without permutes); chunking the attention queries was
+tried and did not help. The GPU kernels (`crates/sam2/src/gpu`) are tested against CPU definitions and PyTorch: the
+encoder's 64 × 64 level matches PyTorch to 7e-6, the memory attention to 1.8e-5, and a clip tracked on the GPU matches
+`Sam2VideoModel` as the CPU does (worst logit error 0.0032). `cargo run --release -p effectcraft-sam2 --example sam2_bench`
+times the pieces on both devices (`EFFECTCRAFT_SAM2_PROFILE=1` prints a frame's breakdown).
+
+## Benchmark
+`effectcraft-cli bench --roto [--frames N] [--sam2 model.safetensors (any size; default: the first installed)] [--mobilesam mobile_sam.pt]` runs synthetic clips with
+known mattes through all three. 24 frames, debug build, SAM 2 on the GPU; mean IoU (mean IoU after the object returns), seconds
+per frame:
+
+| Clip | Classical | MobileSAM | SAM 2.1 Tiny |
+|---|---|---|---|
+| move | 0.980 | 0.989 | 0.992 |
+| light | 0.979 | 0.990 | 0.992 |
+| occlusion (a bar hides the disk, then clears it) | 0.491 (0.000) | 0.494 (0.000) | 0.989 (0.988) |
+| reenter (the disk leaves and comes back) | 0.618 (0.000) | 0.620 (0.000) | 0.982 (0.976) |
+| s/frame | 0.01 | 0.5–1.3 | 0.8 |
+
+MobileSAM prompts every frame independently from the flow-warped matte, so it follows the object while the flow does and
+loses it when it is hidden; SAM 2's streaming memory is what lets it re-acquire the object. The synthetic clips are easy (one
+textured disc), so the "move" and "light" rows mostly show all three working; the last two rows are the difference.
+
+### Corrections needed (`--fixes`)
+`bench --roto --fixes` also counts the correction rounds each tracker needs before every frame reaches IoU 0.9: after each
+run it paints on the first frame under the target, up to 6 rounds. A round can add a short foreground stroke through the
+true object's centre and a background stroke at the centroid of all false-positive pixels. With separate false-positive
+blobs, that centroid can fall between them. The counts below are rounds, not individual strokes. 16 frames, debug build:
+
+| Clip | Classical | MobileSAM | SAM 2.1 Tiny |
+|---|---|---|---|
+| move | 0 | 0 | 0 |
+| light | 0 | 0 | 0 |
+| occlusion | more than 6 | more than 6 | 0 |
+| reenter | more than 6 | more than 6 | 0 |
+
+The simulated user is simple (one stroke pair per round, always on the first bad frame), so "more than 6" means this
+correction model never recovers the flow-based engines on those clips, not that no human could. Peak memory is not measured.
diff --git a/docs/scripting-parity.md b/docs/scripting-parity.md
index 7ef7e9080..9aa6ca626 100644
--- a/docs/scripting-parity.md
+++ b/docs/scripting-parity.md
@@ -18,15 +18,16 @@ our own scripts; no real-world script library has been run against both apps.
 | Expression object model | `thisComp`, `thisLayer`, `wiggle`, `loopOut`, `valueAtTime`, `sampleImage`, `footage()`, text style API… | Same members, from the reference, including `propertyGroup(countUp)` and a group's `propertyIndex` for name-independent rigs (#1619) | good | `crates/expr/src/tests.rs`, `tests/property_group.rs`; behaviour of edge cases unmeasured (G1) |
 | Expression editing | Inline field, error bar, pick whip, Expression Language menu, external editors | Inline field that grows, error bar, pick whips (property and value), language menu | partial | External editor support (#364) |
 | Expression performance | Cached, multi-frame | Per-thread boa contexts | unknown | No benchmark |
-| Scripting object model | `app`, `Project`, items, layers, properties, keys, eases, render queue, `TextDocument`, `Shape`, markers, `File`/`Folder`, `Socket`, `app.settings` | Same classes, edits run through undoable engine commands; match names table; layers, groups and properties are callable (`layer("Effects")(1)` is `.property(...)`) | good | `crates/script` tests (≈ 10 test files) |
+| Scripting object model | `app`, `Project`, items, layers, properties, keys, eases, render queue, `TextDocument`, `Shape`, markers, `File`/`Folder`, `Socket`, `app.settings` | Same classes, edits run through undoable engine commands; match names table, the properties of Offset Paths and Zig Zag included; layers, groups and properties are callable (`layer("Effects")(1)` is `.property(...)`) | good | `crates/script` tests (≈ 10 test files) |
 | `$.evalFile`, `BridgeTalk` | Evaluate another script file; identify the host application and message other Adobe applications | `$.evalFile` evaluates a file relative to the calling file (nested at most 32 deep, under the scripts' file gate) and returns its last value; `BridgeTalk` names the host honestly (`appName` `effectcraft`, its version); messaging other applications throws "not supported" | partial | `tests_evalfile.rs` (#760); no inter-application messaging |
-| ScriptUI | Dialogs, palettes, dockable panels, resource strings, `onDraw` / ScriptUIGraphics, mouse events | Same, dockable panels reopen at launch | good | `ui_scriptui`, `tests_ui*` |
-| `app.scheduleTask` / `cancelTask` | One-shot and repeating tasks (polling, panel refresh) until `cancelTask` | Same: repeating tasks run every `delay` ms (at least 50 ms, at most 64 pending per script) until `cancelTask`, until they throw (reported once, then cancelled), or until their owner goes: a script's last window closing, or the project closing for scripts without windows; frontends tick them every frame, agents with `script.runTasks` | good | `tests_tasks.rs` (#773); one-shot tasks of a script file still run right after it, not after their delay |
-| Scripts menu, ScriptUI Panels folder | yes | yes | same | [plugins.md](plugins.md) |
-| Startup / Shutdown folders | yes | not run | missing | plugins.md |
+| ScriptUI | Dialogs, palettes, dockable panels, resource strings, `onDraw` / ScriptUIGraphics, mouse events | Same, dockable panels reopen at launch; a docked panel gets its dock's size and `onResize` (`scriptui.resize`, #2585); a drag keeps reaching the control it started on past the window edge, and `MouseEvent.buttons` reports the held buttons (#2584) | good | `ui_scriptui`, `tests_ui*` |
+| `app.scheduleTask` / `cancelTask` | One-shot and repeating tasks (polling, panel refresh) until `cancelTask` | Same: repeating tasks run every `delay` ms (at least 50 ms, at most 64 pending per script) until `cancelTask`, until they throw (reported once, then cancelled), or until their owner goes: a script's last window closing, or the project closing for scripts without windows (a Startup script's tasks go on until EffectCraft quits); frontends tick them every frame, agents with `script.runTasks` | good | `tests_tasks.rs` (#773); one-shot tasks of a script file still run right after it, not after their delay |
+| Scripts menu, ScriptUI Panels folder | yes | yes; a subfolder (one level) of either folder is a submenu named after it | same | [plugins.md](plugins.md) |
+| Startup / Shutdown folders | yes | `Scripts/Startup` runs at launch and `Scripts/Shutdown` runs as the desktop app quits, after the project is closed, each in alphabetical order | partial | `crates/script/src/tests/startup.rs`; each script has its own global scope, so a Startup script's variables and functions are not available to later scripts ([plugins.md](plugins.md)) |
 | `#include`, `#target` directives | yes | `#include` / `//@include` / `#includepath` inline files relative to the including script (once each, nested at most 32 deep, under the scripts' file gate; errors name the included file and line); `#target`, `#targetengine`, `#strict` are ignored | good | `tests_include.rs` (#759); installed scripts and panels have no folder of their own, so they include from the project's folder or absolute paths |
 | `.jsxbin` | yes | no | out of scope | No public specification |
-| Keyboard shortcuts for scripts | yes | no | missing | plugins.md |
+| Keyboard shortcuts for scripts | yes: the scripts of the Scripts folder take keys, by their place in the alphabetical list | Edit ▸ Keyboard Shortcuts lists the scripts of File ▸ Scripts; a key stays with the script's file name | same | `file_scripts_entries_take_keyboard_shortcuts`, `a_key_given_to_a_script_runs_it` ([plugins.md](plugins.md)); ScriptUI panels in the Window menu take no key |
+| Recent Script Files | File ▸ Scripts ▸ Recent Script Files (10 scripts), a key to rerun | Same list, kept in the settings; Cmd+Alt+Shift+D reruns the most recent script | same | `recent_script_files_run_again` ([plugins.md](plugins.md)) |
 | Command-line rendering `aerender` | yes | `effectcraft-cli render`, `script`, `exec` | same purpose | `apps/effectcraft-cli` |
 | Essential Graphics scripting hooks | `addToMotionGraphicsTemplate…` | yes (M13.7) | good | — |
 | Agent control (MCP, control channel, every command) | none | yes | beyond | [agents.md](agents.md), [control-protocol.md](control-protocol.md); `list_effects` omits parameter types and ranges (#441) |
@@ -34,7 +35,7 @@ our own scripts; no real-world script library has been run against both apps.
 
 ## Estimate
 
-**≈ 20–40 h**: `#include` / `#target` (landed, #759) and Startup / Shutdown folders 4–8 h as first estimated (Startup / Shutdown remain), script shortcuts 2–4 h,
+**≈ 20–40 h**: `#include` / `#target` (landed, #759) and Startup / Shutdown folders 4–8 h as first estimated (Startup / Shutdown landed; a global scope shared between scripts remains), script shortcuts 2–4 h,
 a corpus of public scripts and expressions with the fixes it finds 10–20 h, an expression
 performance benchmark 4–8 h.
 
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index ff7cc3ef9..247887345 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -114,13 +114,13 @@ compositing and effects dominate; audio is light). Hours are to full parity for
 
 | Area | Weight | Breadth | Ready | Hours | Biggest gaps (details in [gaps.md](gaps.md)) |
 |---|---:|---:|---:|---:|---|
-| Project, footage and import | 8% | 92% | 55% | 25–45 | No relative paths or relinking when a project moves; Media Browser lists AVI, which it can't import (TGA/HDR/DPX/MXF import since #745, #756, #767); #431, #324, #552 and #351 are closed |
+| Project, footage and import | 8% | 92% | 55% | 25–45 | No relative paths or relinking when a project moves; TGA/HDR/DPX/MXF/AVI import since #745, #756, #767, #1701 (no DV or MPEG-4 Part 2 AVI yet); #431, #324, #552 and #351 are closed |
 | Compositions, layers and compositing | 13% | 98% | 60% | 30–55 | 32-bpc blend modes differed from After Effects (#494, closed); expand precomps in place (#601); #527, #510, #513, #539 and #540 are closed |
 | Animation: keyframes, graph editor, motion paths, puppet | 15% | 97% | 55% | 35–60 | Only scalar ease is measured against After Effects (168 samples); puppet lag (#586); #456, #457, #355, #553 and #318 are closed; Proportional Scrubbing (26.2) |
-| Expressions and scripting | 7% | 93% | 65% | 20–40 | `.jsxbin`, Startup/Shutdown folders, script shortcuts (`#include` landed, #759); external editor (#364); see [scripting-parity.md](scripting-parity.md) |
+| Expressions and scripting | 7% | 93% | 65% | 20–40 | `.jsxbin`, a global scope shared between scripts, script shortcuts (`#include` landed, #759; Startup/Shutdown folders run); external editor (#364); see [scripting-parity.md](scripting-parity.md) |
 | Shapes, masks and roto | 9% | 93% | 45% | 30–50 | Open mask and shape issues (#1004, #999, #1042, #932); #510, #513, #527, #509 and #303 are closed; paste SVG/AI as shape layers (26.3; SVG markup pastes since #738) |
 | Text and typography | 7% | 94% | 50% | 20–35 | CJK text in comps renders wrongly (#453); paragraph alignment inverted (#316); soft text at Fit (#417, mostly fixed by #444); toolbar font options (#550); #483 and #583 are closed; variable-font filter landed (#741) |
-| Effects and animation presets | 14% | 85% | 40% | 70–130 | All 306 effects exist, but rendered output is unmeasured against After Effects; 54 built-in presets (text, Transitions, Backgrounds) against After Effects' 621 ([effects-parity.md](effects-parity.md)); open effect bugs (#580 crash, #463, #369, #473, #474; #514 and #526 are closed); effect colour labels (26.5); see [effects-parity.md](effects-parity.md) |
+| Effects and animation presets | 14% | 85% | 40% | 70–130 | All 306 effects exist, but rendered output is unmeasured against After Effects; 76 built-in presets (text, Transitions, Backgrounds, Behaviors) against After Effects' 621 ([effects-parity.md](effects-parity.md)); open effect bugs (#580 crash, #463, #369, #473, #474; #514 and #526 are closed); effect colour labels (26.5); see [effects-parity.md](effects-parity.md) |
 | 3D (Classic and Advanced) | 6% | 82% | 35% | 35–65 | No FBX/USD/STL models, no Substance materials, mesh displacement unverified; no 3D transform gizmos (#392, #347); reflections (#261); camera aperture (#260); #489 and #315 are closed |
 | Tracking and AI-assisted tools | 5% | 80% | 35% | 35–70 | Object Matte (26.2) has the effect, the viewer tool (click / box), background tracking, Freeze and the 26.5 disk cache, not yet compared with After Effects; Roto Brush (MobileSAM) and face tracking (MediaPipe) unmeasured against After Effects; camera-tracker view (#505) |
 | Preview and cache | 7% | 92% | 40% | 25–50 | Playback stutters on cached frames (#595, #304); late audio (#504, #335); #329 and #554 are closed; no benchmark against After Effects |
@@ -139,7 +139,7 @@ Feature depth (≈ 50%) feeds the overall *ready* number with the other dimensio
 | UI/UX fidelity | 65% | 60–120 | After Effects-shaped menus (587 entries), panels, workspaces, shortcuts; many interaction issues still open; multi-monitor only as separate panel windows (#486 open); Effect Controls not yet like 26.5's | [ui-parity.md](ui-parity.md) |
 | File formats | 50% | 130–230 | `.aep` / `.aepx` / `.mogrt` / `.ffx` can't be read; strong modern codecs (H.264, HEVC, AV1, VP9, ProRes) | [file-format-parity.md](file-format-parity.md) |
 | Hardware | 40% | 60–120 | wgpu GPU on Metal/Vulkan/Direct3D 12/WebGPU with CPU fallback; no hardware decode/encode; Direct3D 12 compositor fails (#613); no video-out hardware | [hardware-parity.md](hardware-parity.md) |
-| Localization | 18% | 60–110 + review | Average coverage of After Effects' 10 non-English languages (measured catalog rows over ≈ 3,900 strings): menus in 10 languages, panels in 6, effects in none; After Effects ships 11 languages fully | [localization-parity.md](localization-parity.md) |
+| Localization | 24% | 60–110 + review | Average coverage of After Effects' 10 non-English languages (measured catalog rows over ≈ 4,200 strings): menus in 10 languages, panels in 7, effects in Simplified Chinese and Japanese; After Effects ships 11 languages fully | [localization-parity.md](localization-parity.md) |
 | Performance | 35% | 50–100 | Internal numbers only; users report stutter and slow scrubbing | [gaps.md](gaps.md#g5-performance-at-real-world-scale) |
 | Stability | 45% | 40–80 | Open crash reports #580, #501, #426, #341, #234, #879 (#591, #306 and #511 are closed); no CI runs the tests on pull requests | [gaps.md](gaps.md#g3-stability-and-a-green-main) |
 | Platforms | 65% | 30–60 | Releases for macOS, Windows x64/x86/ARM64, Linux, FreeBSD and the web (more than After Effects), but Linux and Windows users hit basic bugs | [gaps.md](gaps.md#g2-real-user-reliability-on-every-platform) |
@@ -171,8 +171,7 @@ Checked on 10 October 2026 when the mainstream and essentials numbers were added
 
 ## Mainstream practitioner and essentials user
 
-Two narrower questions, computed the same way in every craft app (craftrules
-`standards/progress-docs.md`, "Numbers"). The stage still follows the full-target number and the
+Two narrower questions, computed the same way in every craft app. The stage still follows the full-target number and the
 [alpha gate](roadmap.md#alpha-gate).
 
 ### Mainstream practitioner
@@ -429,7 +428,7 @@ the disk cache in the formats wave; the 3D Camera Tracker in M12.6.)
 | Import | 97% | 0.5 | JPX / JBIG2 images and predefined non-Identity CJK CMaps inside PDF/AI files, Illustrator EPS relying on Adobe procsets, PSD 3D layers (M13.12: mesh shadings — free-form / lattice Gouraud triangles, Coons and tensor patches — and function-based shadings, CCITT G3 / G4 images, knockout / isolated transparency groups with group alpha and soft masks on the group's result, `/W2` vertical metrics, EPS text with embedded Type 1 / CFF or bundled fonts, and Create Shapes from Vector Layer keeping images as parented footage layers in paint order; M13.6: PDF/AI text with embedded TrueType / CFF / Type 1 / Type 3 fonts and standard-14 fallback to the bundled fonts, Flate / DCT / inline / stencil images with soft masks, Indexed and ICC alternates, luminosity / alpha soft masks, the 16 blend modes, tiling patterns, calculator functions, any page via `file.import page` and the Import dialog, clip groups kept by Create Shapes from Vector Layer as layer masks / Merge Paths; PSD smart-object perspective quads and placed-layer warps — named styles and custom quilt meshes — baked as placed; PDF / PDF-compatible AI / EPS vector footage with Continuously Rasterize, layered composition import and Create Shapes from Vector Layer, and PSD smart objects with embedded files landed in M13.2; PSD as footage/composition/retain layer sizes, SVG footage earlier; PDF / AI Composition - Retain Layer Sizes crops each layer to its artwork in place, #1536) |
 | Automation | ≈ 99% | 0.1 | `.jsxbin` (AUT-2: concave / self-intersecting `onDraw` fills, real images in `drawImage`, image controls and icon buttons landed in M13.11; ScriptUI resource strings, `onDraw`/ScriptUIGraphics, live `onChanging`, `Socket`, Essential Graphics hooks — `addToMotionGraphicsTemplate(As)`, `canAddToMotionGraphicsTemplate`, `exportAsMotionGraphicsTemplate`, `motionGraphicsTemplateName`, controller count/names — and Watch Folder landed in M13.7; the core object model landed in M14.4; ScriptUI windows/dialogs/dockable panels with `scriptui.*` agent commands, File ▸ Scripts install + sample scripts, and the effect plug-in API (EFF-6, WebAssembly) landed in M13.1) |
 | Shapes | ≈ 80% | 1.5 | Lottie can't carry stroke taper/wave (stroke Taper and Wave, Dash 2/Gap 2/Dash 3/Gap 3 and radial-gradient Highlight Length/Angle landed in M13.5; pen tool for shape paths and vertex editing in M6.5) |
-| Compositions | ≈ 81% | 3.3 | Mocha-style planar tracks for templates; nested comp markers on the precomp layer bar (Preserve frame rate / resolution when nested and nested comps showing nothing past their end landed in M4.9–M4.10; Pre-compose keeping the comp's settings and New Comp from Selection's dialog in M3.12; CMP-7: Essential Graphics mirrored and linked properties landed in M13.11; Font and uniform Scale controls, Composition ▸ Open in Essential Graphics, Save Frame As ▸ Photoshop Layers / ProEXR and the VR Comp Editor landed in M13.7; the marker dialog, Composition Flowchart, Essential Graphics with master properties, `.ectemplate` templates and Responsive Design — Time landed: CMP-6, CMP-7) |
+| Compositions | ≈ 81% | 3.3 | Mocha-style planar tracks for templates; nested comp markers on the precomp layer bar; a dialog for Scale Composition (After Effects' File ▸ Scripts ▸ Scale Composition.jsx), which runs headless as `comp.scale {factor \| width \| height}` (#2208: the comp, every unparented layer's Position and Scale with all keys, camera Zoom and guides; nested precomps and expressions stay as they are) (Preserve frame rate / resolution when nested and nested comps showing nothing past their end landed in M4.9–M4.10; Pre-compose keeping the comp's settings and New Comp from Selection's dialog in M3.12; CMP-7: Essential Graphics mirrored and linked properties landed in M13.11; Font and uniform Scale controls, Composition ▸ Open in Essential Graphics, Save Frame As ▸ Photoshop Layers / ProEXR and the VR Comp Editor landed in M13.7; the marker dialog, Composition Flowchart, Essential Graphics with master properties, `.ectemplate` templates and Responsive Design — Time landed: CMP-6, CMP-7) |
 | Animation | 70% | 9.0 | puppet depth beyond pins, recording, rigging and follow-through (G2: the expression pick whip scrolls the Timeline when held at its top or bottom, #362; dropped on one of a property's values it picks that dimension (`position[0]`), #363; every property has a property pick whip in the Parent & Link column, which adds the reference as its expression or replaces the one it has, and pick whips drop on Effect Controls properties too, #363; the inline expression field grows while typing and its bottom edge drags it taller or shorter, #371; an angle's revolutions scrub and take typing in Effect Controls, the Timeline and Properties, #93; puppet pin recording with Record Options landed in M13.1; pin selection, rotate/scale handles, nulls for pins and Follow-Through in M13.14–M13.16), Wiggler/Smoother/Motion Sketch (motion-path handles and the graph editor transform box landed in M5.8; keyframe colour labels and Select Keyframe Label Group, Graph Editor snapping to markers / layer ends in M13.5) |
 | Text | ≈ 96% | 0.3 | no extruded strokes (G2: the font menus list every installed family with its own styles — before, only a project asking for a font read the system fonts — and `text.fonts` / MCP `list_fonts` list them for agents; M13.12: the Variable Font Axes animator re-spaces the text — advances follow the animated axes; M13.6: variable font axes in the character style — `layer.setText variations`, the Character panel's Variable Font Axes fields — shape with HVAR / gvar advances and draw at that design-space position; OpenType features — stylistic sets, discretionary ligatures, contextual / stylistic alternates, swash, titling, ordinals, fractions, figure styles, true small caps / all small caps and superior / inferior glyphs with faux fallback — per character with the Character panel's OpenType popup and `text.fontFeatures` landed in M13.2; vertical Roman / Tate-Chu-Yoko, forced LTR paragraphs, caret on animated and path text, Variable Font Axes and Lottie style runs landed in M13.5; extruded, bevelled text in M7.6; per-character styles, paragraph settings, on-canvas editing and the `sourceText` style API in M9.9–M9.10) |
 | Web | 98% | 0.1 | No shared-memory threads inside one engine instance (the decided design is one engine instance per worker; a threaded build needs nightly `build-std`) (M13.30: Render Queue, analyses and Content-Aware Fill render on each job worker's own WebGPU device in passes, particles and Advanced 3D read back under keys, layer buffers in the browser's disk cache; browser storage, Web Audio, Web Worker renders/analyses, WebGPU viewer and offline install landed in M15.2; viewer frames in frame workers fed by project diffs, Roto Brush propagation in a worker, non-blocking `wait: true` jobs and a browser Media Browser (File System Access folders, browser storage) in M13.10; WEB-1 in M13.24: GPU effects and the GPU compositor in the frame workers on their own WebGPU devices with deferred readbacks (frames render in passes; Backend Auto per comp), the disk cache in the Origin Private File System (written by the workers with sync access handles, LRU under the settings' limit, served after a reload), the storage manager (Settings ▸ Disk ▸ Browser Storage, `storage.info` / `storage.persist` / `storage.clear`), and a WGSL constant Chrome rejected (it disabled every GPU kernel in Chrome) fixed) |
diff --git a/docs/testing.md b/docs/testing.md
index 67d622fd9..d556fdc4f 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -5,6 +5,10 @@ cargo test --workspace     # everything
 cargo xtask ci             # fmt, clippy -D warnings, tests, layers, assets, wasm
 ```
 
+The `dev` profile keeps debug info to line tables (fast builds, readable backtraces). To debug
+interactively — local variables, parameters, column breakpoints — build with the `dev-full`
+profile: `cargo run --profile dev-full -p effectcraft -- --demo` (see `CONTRIBUTING.md`).
+
 `cargo xtask ci` builds in the dev profile and runs the tests with `cargo nextest run` (plus
 `cargo test --doc`) when `cargo-nextest` is installed, and with `cargo test` otherwise. It then
 runs `missing_translations_report` with `--nocapture`, which prints the interface strings each
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index df4c5e0ea..cbb936271 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -1,6 +1,6 @@
 # UI parity
 
-> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-18 · **Change:** minor (shape group Contents row elided; path-editing layer bounds #1220; closed issue references re-audited against `upstream/main` 470ea7a3) · **Target:** Adobe After Effects 2026
+> **Last reviewed:** 2026-10-12 · **Last updated:** 2026-10-18 · **Change:** minor (accessibility row: an AccessKit audit and a contrast test, three more panels named and keyboard-operable, #1335; earlier changes: shape group Contents row elided; path-editing layer bounds #1220; closed issue references re-audited against `upstream/main` 470ea7a3) · **Target:** Adobe After Effects 2026
 
 How closely EffectCraft's interaction matches After Effects: tools, handles, snapping, nudging,
 modifier keys, shortcuts, drag behaviour, numeric entry, panels, context menus and feel. Evidence
@@ -16,7 +16,7 @@ feel and platform differences, and the 26.x interface changes are not in yet.
 | Area | Status | % | Evidence and gaps |
 |---|---|---:|---|
 | Menu bar | After Effects' menus, order, submenus and labels; native on macOS; keyboard-operable in-window bar | 95% | 587 entries in `crates/engine/src/menus.rs`; Adobe-service entries omitted by design; `ui_menus` tests (#279) |
-| Panels and workspaces | Every After Effects panel; all standard workspaces; drag-to-dock, tabs, floating panels, maximise | 75% | `ui_tabs`, `ui_panels`; panels move into their own native windows on any screen (#486 open: no dragging tabs between those windows); #302, #301 and #320 (docking, stacked-panel headers, workspace persistence) are closed |
+| Panels and workspaces | Every After Effects panel; all standard workspaces; drag-to-dock, tabs, floating panels, maximise | 75% | `ui_tabs`, `ui_panels`; on Windows, macOS and X11 floating panels are OS windows of their own on any screen (on Wayland, the web and in embedded viewports they stay in the app window), with tabs and groups dragging between windows and shortcuts working in them (#486); #302, #301 and #320 (docking, stacked-panel headers, workspace persistence) are closed |
 | Timeline | Switches, modes, parent & link, twirl-downs, reveal shortcuts (U, UU, P, S, R, T, A, E, M, F, Alt+Shift…), pick whips, graph editor, work area, markers | 75% | `ui_keyframes`, `ui_timeline_*`; expand precomps in place (#601); #456, #457, #569 and #355 (Graph Editor jitter and buttons, negative rotation, bulk keyframing) are closed; Proportional Scrubbing (26.2: Ctrl+Alt / Cmd+Opt scrub of hot text spreads the change over the selected layers by selection order, #770) matched for layers selected as a whole, not yet for individually selected properties; every layer has the Video switch, nulls, cameras and lights included (a hidden null, camera or light has no box or handles in the viewer and isn't picked there; other selected hidden layers keep their layer controls and paths, #1769); a row control (a switch, the label swatch, a Modes cell) clicked on one of several selected layers acts on the whole selection, with the layers the switch doesn't apply to left out (#1849); a shape group's inner Contents (After Effects' elided Vectors group) draws no row — the group's path, fill/stroke and Transform list directly under it |
 | Composition viewer | Selection, handles with direction-aware cursors, rulers, guides, grids, snapping, channels, exposure, region of interest, snapshots, 3D views, Spacebar hand | 70% | `ui_viewer`, `ui_viewers`; Cmd/Ctrl +/− doesn't zoom (#570); anchor point grab on Linux (#492); #352 (snapping) is closed; no 3D transform gizmos (#392, #347); percentage guides (26.5) exist as View ▸ Add Percentage Guide and Convert Guides to Percentage / Pixels (a guide stores a percent of the comp, so it follows comp-size changes; behaviour inferred from the release note, not compared with After Effects); Copy Frame to Clipboard (26.3) is in the Composition menu and the viewer's context menu |
 | Tools panel | All After Effects tools; long-press flyouts; Tool Creates Shape / Mask; Fill / Stroke options | 80% | #213, #227 fixed; #553 (pen and vertex tools on motion paths) is closed |
@@ -30,7 +30,7 @@ feel and platform differences, and the 26.x interface changes are not in yet.
 | Preview feel | Spacebar / Numpad 0 previews, RAM preview, cache bars, adaptive resolution | 55% | `ui_ram_preview`, `ui_live_preview`; stutter (#595, #304); scrubbing lag (#329, closed by #784) |
 | Home screen, Learn, templates | Home with recent projects, template gallery, interactive Learn tutorials | 70% | Layout nitpicks (#581); Home literals untranslated (#574) |
 | Quick Apply (26.2) | Search to apply effects, presets or commands | partial | A command palette exists; not After Effects' Quick Apply |
-| Accessibility | AccessKit enabled; focus labels tested; Project panel keyboard navigation and accessible names (#776) | 20% | No screen-reader pass or keyboard-navigation audit of the other panels; no contrast check |
+| Accessibility | AccessKit enabled; `ui_accessibility_audit` counts unnamed or roleless controls per panel: Project (#776), Effects & Presets, Settings (all pages) and Render Queue with Templates are at zero, with names, roles, selected / open / checked state and arrow-key, Home / End, Enter, Space operation (#1335); `ui_contrast` checks theme tokens against WCAG 2 | 20% | No screen reader has been run on anything; the other panels are counted, not fixed (Timeline ≈ 55 unnamed controls); 13 of 48 token pairs are below WCAG 2 (primary button text, error text, control borders, Light theme warning colour); focus order across panels, colour-blindness and reduced motion are unchecked; app shortcuts pause while a widget has keyboard focus |
 | UI scale | Settings ▸ Appearance ▸ UI Scale 75–200% | beyond | After Effects follows the system's scaling (#284) |
 
 Path editing (#1220): the Composition viewer suppresses a selected layer’s transform box while
@@ -41,9 +41,8 @@ cover shape paths and masks, corner-vertex dragging and undo, and layers without
 
 ## Estimate
 
-**≈ 60–120 h**: the open interaction issues above (25–45 h, about 0.2–0.5 h each with a scripted
-test), 3D gizmos 8–15 h, multi-monitor panels 10–20 h, the 26.x interface changes 10–20 h, an
-accessibility pass 15–30 h. Checking feel against After Effects needs the owner's Mac with After
+**≈ 60–110 h**: the open interaction issues above (25–45 h, about 0.2–0.5 h each with a scripted
+test), 3D gizmos 8–15 h, the 26.x interface changes 10–20 h, an accessibility pass 12–25 h (the first slice, three panels and the audit, is done). Checking feel against After Effects needs the owner's Mac with After
 Effects running; most of the rest parallelises.
 
 ## Revision history
@@ -51,6 +50,7 @@ Effects running; most of the rest parallelises.
 | Date | Change | Summary |
 |---|---|---|
 | 2026-10-18 | minor | A shape group's inner Contents (After Effects' elided Vectors group) draws no row: the group's path, fill/stroke and Transform list directly under the group |
+| 2026-10-13 | minor | Accessibility row: AccessKit audit and contrast tests, Effects & Presets, Settings and Render Queue named and keyboard-operable (#1335); no screen reader tested |
 | 2026-10-13 | patch | Layer bounds are suppressed during path-point editing (#1220); shape/mask interaction regressions |
 | 2026-10-12 | minor | Closed issues (#302, #320, #491, #511, #553 and others) marked as closed instead of open; panels in their own windows (#486) |
 | 2026-10-12 | minor | Percentage guides and effect colour labels (26.5) added; rows updated |
diff --git a/docs/user/AGENTS.md b/docs/user/AGENTS.md
new file mode 100644
index 000000000..2c3add101
--- /dev/null
+++ b/docs/user/AGENTS.md
@@ -0,0 +1,64 @@
+# User docs: rules for agents and contributors
+
+Everything in this folder (except this file, CLAUDE.md and README.md) is published at
+https://getartcraft.com/docs/effectcraft. The file path is the URL:
+`troubleshooting/gpu-not-used.md` → `/docs/effectcraft/troubleshooting/gpu-not-used`.
+Renaming a file breaks links, so add the old path to `redirect_from` when you rename.
+
+## Who reads this
+
+Artists using EffectCraft, Discord mods answering them, and AI assistants looking things up for
+either. Write for an artist, not a developer.
+
+## Page rules
+
+- One question or problem per page. Lead with the answer or the fix in the first two lines.
+- Plain words, short sentences, numbered steps for anything the reader does.
+- Start the body at `##`. The page title comes from frontmatter.
+- Link to other pages instead of repeating them. Use relative links to the `.md` file:
+  `[Install EffectCraft](../getting-started/install.md)`.
+- No marketing copy, no "simply", no claims you have not checked in the code, a release or an issue.
+- Call the product "EffectCraft", as the app, its downloads and getartcraft.com do.
+- Name UI labels exactly as the app shows them, in **bold**. Menu paths use the menu text from
+  `crates/engine/src/menus.rs`.
+- Shortcuts: the code writes `Cmd`, which is Ctrl on Windows and Linux. Write Ctrl for Windows.
+- Windows 11 is the only Windows version to name.
+- Troubleshooting pages: `## Symptoms`, `## Fix`, `## Why this happens` (optional),
+  `## Still stuck?` (link the issue tracker or Discord).
+
+## Frontmatter
+
+    ---
+    title: EffectCraft does not use my graphics card
+    description: One sentence for search results, link previews and AI summaries.
+    order: 10                 # optional, sorts within the folder (lower first)
+    verified: 0.8.0           # optional, app version you last checked this page against
+    redirect_from: [old/path] # optional, old URLs (relative to /docs/effectcraft)
+    ---
+
+Only `key: value` and `key: [a, b]` lines work. Quote values that start with a quote or contain ` #`.
+
+Set `verified` to the latest release (the newest release tag) after checking the page against that tag with `git show <tag>:<path>`. Pages describe the latest release users download, not unreleased code on main.
+
+## Folders
+
+- `getting-started/` install and first run
+- `guides/` how to do one thing
+- `troubleshooting/` symptom → fix
+- `faq/` short answers
+- `reference/` lists and settings
+
+A folder's `index.md` names the folder in the sidebar. Files or folders starting with `_` are
+drafts and are not published.
+
+## Check before you push
+
+    node <path to your artcraft-services checkout>/frontend/apps/artcraft-website-next/scripts/docs/core.mjs docs/user
+
+The checker lives in storytold/artcraft-services. A CI check will be added once it is on that repo's main branch.
+
+## Support PRs
+
+Pages written to answer a user question come in as PRs titled `docs(support): <page title>`.
+Review them like code: check every claim against the source. Problems and bug reports go in the
+[issue tracker](https://github.com/storytold/effectcraft/issues).
diff --git a/docs/user/CLAUDE.md b/docs/user/CLAUDE.md
new file mode 100644
index 000000000..e7bcfb70e
--- /dev/null
+++ b/docs/user/CLAUDE.md
@@ -0,0 +1 @@
+Read `AGENTS.md` in this folder: it has the rules for the user docs.
diff --git a/docs/user/faq/after-effects-projects.md b/docs/user/faq/after-effects-projects.md
new file mode 100644
index 000000000..792aa7cc1
--- /dev/null
+++ b/docs/user/faq/after-effects-projects.md
@@ -0,0 +1,22 @@
+---
+title: Can EffectCraft open After Effects projects?
+description: EffectCraft cannot open .aep or .aepx files, and After Effects plug-ins do not run. It saves .ecproj files and imports Lottie.
+order: 10
+verified: 0.9.2
+---
+
+No. EffectCraft cannot open After Effects projects (`.aep` or `.aepx`), and After Effects plug-ins do not run in it.
+
+## What it opens instead
+
+- Its own projects, saved as `.ecproj`. These are readable, versioned JSON files.
+- Lottie animations, with **File ▸ Import ▸ Lottie...**. Each opens as a new composition.
+- Photoshop and PDF or Illustrator files, imported as footage or as a composition. See [Import footage and image sequences](../guides/import-footage.md).
+
+## What carries over
+
+Expressions are JavaScript with the After Effects object model, such as `wiggle`, `loopOut` and `thisComp.layer("...")`. The panels, shortcuts and effect parameter names follow After Effects, so the skills carry over.
+
+## Status
+
+Reading `.aep` files is the largest known gap between EffectCraft and After Effects. It is listed in the project's [gap list](https://github.com/storytold/effectcraft/blob/main/docs/gaps.md), and the maintainers have not yet decided how to approach it.
diff --git a/docs/user/faq/index.md b/docs/user/faq/index.md
new file mode 100644
index 000000000..75b27177f
--- /dev/null
+++ b/docs/user/faq/index.md
@@ -0,0 +1,8 @@
+---
+title: FAQ
+description: Short answers about EffectCraft.
+order: 40
+---
+
+- [Can EffectCraft open After Effects projects?](after-effects-projects.md)
+- [Is EffectCraft free, and where does it run?](price-and-platforms.md)
diff --git a/docs/user/faq/price-and-platforms.md b/docs/user/faq/price-and-platforms.md
new file mode 100644
index 000000000..40f93c60d
--- /dev/null
+++ b/docs/user/faq/price-and-platforms.md
@@ -0,0 +1,24 @@
+---
+title: Is EffectCraft free, and where does it run?
+description: EffectCraft is free and open source under MIT or Apache-2.0, and runs on Windows, macOS, Linux and in the browser.
+order: 20
+verified: 0.9.2
+---
+
+Yes, EffectCraft is free. It is open source, dual-licensed under MIT or Apache-2.0, at your option. It has no telemetry, and it uses no network access unless you ask for it.
+
+## Where it runs
+
+| Platform | Builds                                                                                 |
+|----------|----------------------------------------------------------------------------------------|
+| Windows  | x64, arm64 and 32-bit x86, as MSI installers and portable zips                         |
+| macOS    | One universal app for Apple silicon and Intel                                          |
+| Linux    | x86_64 and aarch64 as AppImage, Flatpak, deb, rpm and tar.gz; riscv64 deb, rpm, tar.gz |
+| FreeBSD  | x86_64 tar.gz                                                                          |
+| Browser  | A web build that runs the full app                                                     |
+
+See [Install EffectCraft](../getting-started/install.md) for the files.
+
+## How mature is it?
+
+EffectCraft is in alpha. The README calls macOS the most tested platform, and says Linux and Windows users have hit basic interaction bugs that are being fixed first. Bug reports in the [issue tracker](https://github.com/storytold/effectcraft/issues) are the most useful thing you can send.
diff --git a/docs/user/getting-started/index.md b/docs/user/getting-started/index.md
new file mode 100644
index 000000000..6a3cad148
--- /dev/null
+++ b/docs/user/getting-started/index.md
@@ -0,0 +1,8 @@
+---
+title: Getting started
+description: Install EffectCraft and make your first composition.
+order: 10
+---
+
+- [Install EffectCraft](install.md)
+- [Make your first composition](../guides/make-a-composition.md)
diff --git a/docs/user/getting-started/install.md b/docs/user/getting-started/install.md
new file mode 100644
index 000000000..b2e77a5d9
--- /dev/null
+++ b/docs/user/getting-started/install.md
@@ -0,0 +1,58 @@
+---
+title: Install EffectCraft
+description: Download EffectCraft for Windows 11, macOS or Linux, install it, or install it through ArtCraft Launcher.
+order: 10
+verified: 0.9.2
+---
+
+The easiest way is the [EffectCraft page on getartcraft.com](https://getartcraft.com/apps/effectcraft). For a specific file, use the [latest release](https://github.com/storytold/effectcraft/releases/latest) on GitHub. In the file names, `<version>` stands for the version number, for example `0.9.2`.
+
+## Windows 11
+
+1. Open the [latest release](https://github.com/storytold/effectcraft/releases/latest).
+2. Download `effectcraft-<version>-windows-x64.msi`. It fits most PCs (Intel and AMD, 64-bit).
+3. Run the file and follow the installer. It asks where to install EffectCraft and offers a **Create a desktop shortcut** box.
+4. Start **EffectCraft** from the Start menu.
+
+The release also has an `arm64` installer for Snapdragon and other ARM PCs. The installers are code-signed and install for all users. Later versions install into the same folder.
+
+To run it without installing, download `effectcraft-<version>-windows-x64-portable.zip` instead. It contains `effectcraft.exe` and the command-line tool `effectcraft-cli.exe`. The `arm64` build has a portable zip too.
+
+There are also 32-bit `x86` builds, as an installer and a portable zip.
+
+## macOS
+
+1. Download `effectcraft-<version>-macos-universal.dmg`. It works on Apple silicon and Intel Macs and is signed and notarized.
+2. Open it and drag EffectCraft to Applications.
+
+The command-line tool is a separate download for macOS: `effectcraft-cli-<version>-macos-universal.zip`.
+
+## Linux
+
+Pick one file from the release. Replace `x86_64` with `aarch64` on ARM.
+
+| File                                          | How to use it                            |
+|-----------------------------------------------|------------------------------------------|
+| `effectcraft-<version>-linux-x86_64.AppImage` | Run `chmod +x` on the file, then run it. |
+| `effectcraft-<version>-linux-x86_64.deb`      | For Debian and Ubuntu.                   |
+| `effectcraft-<version>-linux-x86_64.rpm`      | For Fedora, RHEL and openSUSE.           |
+| `effectcraft-<version>-linux-x86_64.flatpak`  | `flatpak install --user <file>`          |
+| `effectcraft-<version>-linux-x86_64.tar.gz`   | Unpack it anywhere.                      |
+
+For RISC-V 64-bit there is a `.deb`, an `.rpm` and a `.tar.gz` (`riscv64` in the file name). They need glibc 2.39 or newer. There is also a FreeBSD x86_64 `.tar.gz`.
+
+## In the browser
+
+`effectcraft-web-<version>.zip` is the web build. It is a static site that runs in a modern browser and needs to be hosted on a web server. Projects, media and settings stay in the browser's private storage and on your computer.
+
+## Install through ArtCraft Launcher
+
+ArtCraft Launcher lists EffectCraft. Click **Install** on its card. See [Install and update Craft apps](https://getartcraft.com/docs/craft-launcher/guides/install-and-update-apps).
+
+## Check the download
+
+`SHA256SUMS.txt` on the release page lists a checksum for every file.
+
+## Next
+
+Open EffectCraft and make something: [Make your first composition](../guides/make-a-composition.md). If you only want to look around, choose **Open Demo Project** on the Home screen.
diff --git a/docs/user/guides/add-an-effect.md b/docs/user/guides/add-an-effect.md
new file mode 100644
index 000000000..5459b21d9
--- /dev/null
+++ b/docs/user/guides/add-an-effect.md
@@ -0,0 +1,35 @@
+---
+title: Add an effect
+description: Apply an effect such as Gaussian Blur to a layer and change its settings in Effect Controls.
+order: 30
+verified: 0.9.2
+---
+
+Select a layer, then choose the effect from the **Effect** menu, or double-click it in the **Effects & Presets** panel. Change its settings in **Effect Controls** (F3).
+
+Shortcuts on this page use Ctrl. On macOS, use Cmd instead of Ctrl.
+
+## Steps
+
+1. Select a layer in the Timeline.
+2. Apply an effect in one of two ways:
+   - Choose it from the **Effect** menu. Effects are grouped by category, for example **Effect ▸ Blur & Sharpen ▸ Gaussian Blur**.
+   - Open **Window ▸ Effects & Presets** (Ctrl+5). Type in the search field, then double-click the effect. Dragging it onto a layer works too.
+3. Open **Window ▸ Effect Controls** (F3), or choose **Effect ▸ Effect Controls**. The effect's settings are listed there. **Gaussian Blur** has **Blurriness**, **Blur Dimensions** and **Repeat Edge Pixels**.
+4. Change a value. Click the stopwatch beside it to animate it, as in [Animate with keyframes](animate-with-keyframes.md).
+
+If no layer is selected when you double-click an effect, EffectCraft shows **Select a layer to apply to**. Select a layer and try again.
+
+## Remove or reuse effects
+
+- **Effect ▸ Last Effect** applies the effect you used last.
+- **Effect ▸ Remove All** takes every effect off the selected layers.
+- In **Effects & Presets**, click the star on an effect to add it to Favorites. Recently used effects are listed too.
+
+## Layer styles
+
+For drop shadows, glows and bevels, use **Layer ▸ Layer Styles**. It lists **Drop Shadow**, **Inner Shadow**, **Outer Glow**, **Inner Glow**, **Bevel and Emboss** and **Satin**, among others.
+
+## Next
+
+[Render a video](render-a-video.md).
diff --git a/docs/user/guides/animate-with-keyframes.md b/docs/user/guides/animate-with-keyframes.md
new file mode 100644
index 000000000..53ef7882e
--- /dev/null
+++ b/docs/user/guides/animate-with-keyframes.md
@@ -0,0 +1,35 @@
+---
+title: Animate with keyframes
+description: Fly a layer in with two Position keyframes and smooth the motion with Easy Ease.
+order: 20
+verified: 0.9.2
+---
+
+Click the stopwatch beside a property to start animating it, move the current-time indicator, then change the value. The second keyframe appears by itself. Select both keyframes and press F9 to ease the motion.
+
+You need a composition with a layer. See [Make your first composition](make-a-composition.md).
+
+Shortcuts on this page use Ctrl. On macOS, use Cmd instead of Ctrl and Option instead of Alt.
+
+## Steps
+
+1. In the Timeline, twirl the layer open, then open **Transform**.
+2. Set the starting value. For a layer that flies in from the left, scrub or type a **Position** that is outside the frame.
+3. Click the stopwatch beside **Position**. It turns blue and records a keyframe at the current time.
+4. Drag the blue current-time indicator to about 0:00:01:00, or click in the time ruler.
+5. Drag the layer to its final place in the Composition viewer, or scrub the **Position** value. Because the stopwatch is on, a second keyframe appears by itself.
+6. Select both keyframes (drag a box around them, or click the **Position** name) and press F9. This is **Animation ▸ Keyframe Assistant ▸ Easy Ease**. The layer now glides in and settles.
+7. Press the Spacebar, or use Play in the Preview panel, to watch it. Press it again to stop.
+
+## Other things you can do
+
+- Click the keyframe button in the layer's property row to add or remove a keyframe at the current time. Its tooltip reads **Add or remove keyframe**.
+- Choose **Animation ▸ Keyframe Assistant ▸ Easy Ease In** (Shift+F9) or **Easy Ease Out** to ease one side only.
+- Choose **Animation ▸ Toggle Hold Keyframe** for a keyframe that jumps instead of moving.
+- Choose **Animation ▸ Keyframe Interpolation...** or **Keyframe Velocity...** to set the curve exactly.
+- Hold Alt and click a stopwatch to add an expression.
+- The Graph Editor shows value and speed graphs with draggable handles.
+
+## Next
+
+[Add an effect](add-an-effect.md).
diff --git a/docs/user/guides/import-footage.md b/docs/user/guides/import-footage.md
new file mode 100644
index 000000000..2cd754bd2
--- /dev/null
+++ b/docs/user/guides/import-footage.md
@@ -0,0 +1,49 @@
+---
+title: Import footage and image sequences
+description: Bring video, images and numbered image sequences into an EffectCraft project, and change how footage is read.
+order: 50
+verified: 0.9.2
+---
+
+Choose **File ▸ Import ▸ File...** (Ctrl+I) and pick your files, or drop files on the EffectCraft window. Numbered stills such as `shot_0001.png` can import as one sequence that plays like a movie.
+
+Shortcuts on this page use Ctrl. On macOS, use Cmd instead of Ctrl and Option instead of Alt.
+
+## Import files
+
+1. Choose **File ▸ Import ▸ File...** to pick one file. Use **File ▸ Import ▸ Multiple Files...** to pick several.
+2. Photoshop and PDF or Illustrator files first ask whether to import them as footage or as a composition.
+3. The footage appears in the Project panel. Drag it onto the Composition viewer to make a layer where you drop it, or into the Timeline. If no composition is open, dropping it on the empty viewer makes a new composition from it.
+
+You can also drop files or folders on the window. Files dropped on the Composition viewer become layers there. A dropped Photoshop file asks how to import it, as **File ▸ Import ▸ File...** does. The **Media Browser** (**Window ▸ Media Browser**) browses folders and imports what you pick.
+
+## Import an image sequence
+
+1. Choose **File ▸ Import ▸ File...** and pick any one numbered file of the run.
+2. In the **Import Image Sequence** dialog, check the run it found. It also lists missing frames.
+3. Tick the sequence option, which is named after the file type, for example **PNG Sequence**. When it is off, the files import as separate stills. It is off by default.
+4. Set **Frame rate (fps)**. The default comes from **Sequence Footage** on the Import page of the preferences (**Edit ▸ Preferences ▸ Import...**; on macOS: **EffectCraft ▸ Settings... ▸ Import...**), which is 30 fps.
+5. Confirm. The run arrives as one footage item named like `shot_[0001-0250].png`.
+
+**Force alphabetical order** imports every image of that type in the folder in name order, whatever the numbering. Use it for files that are not numbered consistently.
+
+Stills in PNG, JPEG, TIFF, OpenEXR, BMP, WebP, Targa (`.tga`), Radiance HDR (`.hdr`), DPX and Cineon (`.cin`) can form a sequence. PSD, SVG and PDF files import one by one.
+
+If the numbering skips a frame, EffectCraft shows colour bars for it. Put the missing files in the folder and choose **File ▸ Reload Footage** to fill the gap.
+
+## Change how footage is read
+
+Select the footage in the Project panel and choose **File ▸ Interpret Footage ▸ Main...** (Ctrl+Alt+G). The dialog has **Alpha**, **Assume this frame rate** and **Start Timecode**, among others. A change applies everywhere the footage is used.
+
+For example, a 250-frame sequence at 25 fps lasts 10 seconds. At 24 fps it lasts 10.4 seconds.
+
+## Replace or reload footage
+
+- **File ▸ Replace Footage ▸ File...** (Ctrl+H) points the item at another file.
+- **File ▸ Reload Footage** (Ctrl+Alt+L) reads the files again. A sequence picks up frames added to its folder.
+
+If footage shows as missing, see [Footage is missing or offline](../troubleshooting/footage-missing.md).
+
+## Linux with Wayland
+
+Dragging files onto the window does not work on native Wayland sessions. Use **File ▸ Import ▸ File...** instead.
diff --git a/docs/user/guides/index.md b/docs/user/guides/index.md
new file mode 100644
index 000000000..d8182d069
--- /dev/null
+++ b/docs/user/guides/index.md
@@ -0,0 +1,11 @@
+---
+title: Guides
+description: Step-by-step guides for the main tasks in EffectCraft.
+order: 20
+---
+
+- [Make your first composition](make-a-composition.md)
+- [Animate with keyframes](animate-with-keyframes.md)
+- [Add an effect](add-an-effect.md)
+- [Render a video](render-a-video.md)
+- [Import footage and image sequences](import-footage.md)
diff --git a/docs/user/guides/make-a-composition.md b/docs/user/guides/make-a-composition.md
new file mode 100644
index 000000000..5dcd8702b
--- /dev/null
+++ b/docs/user/guides/make-a-composition.md
@@ -0,0 +1,34 @@
+---
+title: Make your first composition
+description: Create a composition, add a text layer and save the project as an .ecproj file.
+order: 10
+verified: 0.9.2
+---
+
+Choose **Composition ▸ New Composition...**, set the size, frame rate and duration, click **OK**, then add layers from the **Layer ▸ New** menu. Shortcuts below use Ctrl on Windows and Linux. On macOS, use Cmd.
+
+## Steps
+
+1. Choose **Composition ▸ New Composition...** (Ctrl+N). On the Home screen, click **New Composition** instead.
+2. In the dialog, type a **Composition Name**. The default is `Comp 1`.
+3. Pick a **Preset**, or set **Width**, **Height**, **Frame Rate** and **Duration**. The presets include `HDTV 1080 24`, `UHD 4K 25` and `Social Media Square · 1080x1080 · 30 fps`.
+4. Click **OK**. The composition opens in the Composition panel and the Timeline.
+5. Choose **Layer ▸ New ▸ Text** and type your text. A text layer appears at the top of the Timeline, and its name follows what you type.
+6. Add more layers from **Layer ▸ New**: **Solid...**, **Shape Layer**, **Null Object**, **Adjustment Layer**, **Light...** and **Camera...**.
+7. Choose **File ▸ Save** to save the project.
+
+Projects are saved as `.ecproj` files. An `.ecproj` file is readable JSON, so it also works with version control.
+
+## Change the settings later
+
+Choose **Composition ▸ Composition Settings...** to change the name, size, frame rate or duration. The dialog has **Basic**, **Advanced** and **3D Renderer** tabs.
+
+To keep a size and frame rate for later, click the **+** button next to **Preset** (**Save Preset…**) and name it. Your presets are listed above the built-in ones, in this dialog and in **New Composition...**. To remove one, select it and click the bin button (**Delete Preset**).
+
+## Learn in the app
+
+The in-app tutorial **Animate a title** walks through a similar title animation. To open it, choose **Help ▸ In-App Tutorials...**.
+
+## Next
+
+[Animate with keyframes](animate-with-keyframes.md).
diff --git a/docs/user/guides/render-a-video.md b/docs/user/guides/render-a-video.md
new file mode 100644
index 000000000..42fa5d0a5
--- /dev/null
+++ b/docs/user/guides/render-a-video.md
@@ -0,0 +1,52 @@
+---
+title: Render a video
+description: Add a composition to the Render Queue, choose a format such as H.264, pick where to save and click Render.
+order: 40
+verified: 0.9.2
+---
+
+Select the composition, choose **Composition ▸ Add to Render Queue** (Ctrl+M), set the output file, then click **Render** in the Render Queue panel. The default format is H.264, saved as an `.mp4` file named after the composition.
+
+Shortcuts on this page use Ctrl. On macOS, use Cmd instead of Ctrl and Option instead of Alt.
+
+## Steps
+
+1. Select the composition in the Project panel or open it.
+2. Choose **Composition ▸ Add to Render Queue** (Ctrl+M). You can also drag compositions onto the Render Queue panel. Open the panel with **Window ▸ Render Queue** (Ctrl+Alt+0).
+3. The queue lists the item with its **Comp Name**, **Status**, **Started** and **Render Time**. Twirl the item open to see **Render Settings:**, **Output Module:** and **Output To**.
+4. Click **Output Module:** and choose a format. The menu entries read **Format: H.264**, **Format: QuickTime (ProRes)** and so on.
+5. Click the file name next to **Output To** to choose where to save. Alt-click it to edit the name template instead.
+6. Check that the **Render** tick box at the left of the item is on. It is on by default, and only ticked items render.
+7. Click **Render**. The status changes to **Rendering** with a percentage. Click **Stop** to cancel.
+
+Tick **Notify** to get a sound and a notification when the queue finishes.
+
+## Formats
+
+The **Output Module:** menu lists the formats your build can export:
+
+| Menu entry               | File type                   |
+|--------------------------|-----------------------------|
+| H.264                    | `.mp4`                      |
+| QuickTime (ProRes)       | `.mov`                      |
+| QuickTime (Uncompressed) | `.mov`                      |
+| HEVC (H.265)             | `.mp4`                      |
+| AV1                      | `.mp4`                      |
+| WebM (VP9 + Opus)        | `.webm`                     |
+| PNG Sequence             | `.png`, one file per frame  |
+| JPEG Sequence            | `.jpg`, one file per frame  |
+| TIFF Sequence            | `.tif`, one file per frame  |
+| OpenEXR Sequence         | `.exr`, one file per frame  |
+| Animated GIF             | `.gif`                      |
+| WAV                      | `.wav`, audio only          |
+| AIFF                     | `.aif`, audio only          |
+
+To keep transparency, choose **Channels: RGB + Alpha** in the **Output Module:** menu. It appears for formats that can store alpha, such as QuickTime (ProRes), QuickTime (Uncompressed) and PNG Sequence. H.264, HEVC, AV1 and JPEG Sequence cannot.
+
+## Render only part of a composition
+
+Click **Render Settings:** and choose **Time Span: Work Area Only** or **Time Span: Length of Comp**. The same menu sets **Quality: Best** or **Quality: Draft** and the resolution (**Resolution: Full**, **Half**, **Third** or **Quarter**).
+
+## Export a Lottie animation instead
+
+Choose **File ▸ Export ▸ Lottie JSON...** to write a composition as `.json` or `.lottie`. EffectCraft lists anything Lottie cannot express. To open one, choose **File ▸ Import ▸ Lottie...**.
diff --git a/docs/user/index.md b/docs/user/index.md
new file mode 100644
index 000000000..05ed4993c
--- /dev/null
+++ b/docs/user/index.md
@@ -0,0 +1,36 @@
+---
+title: EffectCraft
+description: EffectCraft is a free, open-source app for motion graphics and visual effects, an alternative to Adobe After Effects.
+verified: 0.9.2
+---
+
+EffectCraft is a free, open-source app for animated titles, motion graphics and compositing. It is an alternative to Adobe After Effects.
+
+You build a composition from layers (solids, shapes, text, footage, other compositions), animate their properties with keyframes, add effects and render the result. The panels and shortcuts follow After Effects: Project, Composition, Timeline, Effect Controls, Effects & Presets and the Render Queue. It runs on macOS, Windows and Linux, and in the browser.
+
+EffectCraft is young and in alpha. It cannot open After Effects projects (`.aep`), and some things still behave differently from After Effects. See [Can EffectCraft open After Effects projects?](faq/after-effects-projects.md).
+
+## Start here
+
+- [Install EffectCraft](getting-started/install.md)
+- [Make your first composition](guides/make-a-composition.md)
+- [Animate with keyframes](guides/animate-with-keyframes.md)
+- [Add an effect](guides/add-an-effect.md)
+- [Render a video](guides/render-a-video.md)
+- [Import footage and image sequences](guides/import-footage.md)
+
+## When something is wrong
+
+- [EffectCraft does not use my graphics card](troubleshooting/gpu-not-used.md)
+- [Footage is missing or offline](troubleshooting/footage-missing.md)
+
+## Sections
+
+- [Getting started](getting-started/index.md)
+- [Guides](guides/index.md)
+- [Troubleshooting](troubleshooting/index.md)
+- [FAQ](faq/index.md)
+
+## Get help
+
+Ask in [Discord](https://discord.gg/artcraft) or open an issue in the [issue tracker](https://github.com/storytold/effectcraft/issues). Say which version and which system you use.
diff --git a/docs/user/troubleshooting/footage-missing.md b/docs/user/troubleshooting/footage-missing.md
new file mode 100644
index 000000000..7507a2ad0
--- /dev/null
+++ b/docs/user/troubleshooting/footage-missing.md
@@ -0,0 +1,35 @@
+---
+title: Footage is missing or offline
+description: Find missing footage in an EffectCraft project, relink it to a folder or replace it with another file.
+order: 20
+verified: 0.9.2
+---
+
+Choose **File ▸ Dependencies ▸ Relink Missing Footage...** and pick the folder where your files are now. For files that stay missing, choose **File ▸ Replace Footage ▸ File...**.
+
+Shortcuts on this page use Ctrl. On macOS, use Cmd instead of Ctrl and Option instead of Alt.
+
+## Symptoms
+
+- A footage item in the Project panel is flagged as missing after you open a project.
+- EffectCraft shows a message that footage items are missing.
+
+## Fix
+
+1. Choose **File ▸ Dependencies ▸ Find Missing Footage**. EffectCraft selects every missing item in the Project panel and shows how many it found.
+2. Choose **File ▸ Dependencies ▸ Relink Missing Footage...** and pick the folder that holds your files. EffectCraft searches that folder and its subfolders.
+3. It relinks files whose names are unique and whose type, dimensions and codec match what the project saved. The whole relink is one undo step.
+4. For anything left over, select the item and choose **File ▸ Replace Footage ▸ File...** (Ctrl+H), then pick the file yourself. This also covers files with duplicate names in the folder, which Relink leaves alone.
+5. After you copy or render files into a folder, choose **File ▸ Reload Footage** (Ctrl+Alt+L) to read them again.
+
+Relinking keeps item names, interpretation and layer timing. It does not change your files. For image sequences, every saved frame must be in the new folder. Relink Missing Footage is not available in the browser version.
+
+## Why this happens
+
+A project stores where each footage file is. If you move or rename the files, or open the project on another computer, the project cannot find them.
+
+Projects built with the command-line tool or an agent can use relative paths such as `bg.mp4`. Before 0.8.0, the app looked for those in its own working directory instead of next to the project file. Since 0.8.0 it also looks next to the project file ([pull request #676](https://github.com/storytold/effectcraft/pull/676)). The reporter on macOS has not confirmed the fix yet ([issue #652](https://github.com/storytold/effectcraft/issues/652)).
+
+## Still stuck?
+
+Ask in [Discord](https://discord.gg/artcraft) or open an issue in the [issue tracker](https://github.com/storytold/effectcraft/issues). Say which system you use, whether the project came from another computer or from the command-line tool, and where the footage is stored.
diff --git a/docs/user/troubleshooting/gpu-not-used.md b/docs/user/troubleshooting/gpu-not-used.md
new file mode 100644
index 000000000..7c4fb29e0
--- /dev/null
+++ b/docs/user/troubleshooting/gpu-not-used.md
@@ -0,0 +1,42 @@
+---
+title: EffectCraft does not use my graphics card
+description: What to do when the report says GPU none (CPU compositing), the window picked another adapter, or GPU effects fail on Windows 11 with DirectX 12.
+order: 10
+verified: 0.9.2
+---
+
+Open **Help ▸ System Compatibility Report...** and read the **GPU:** and **Window graphics:** lines. If the window runs on the wrong adapter, set **Window Graphics** to **Automatic** in the preferences (**Edit ▸ Preferences ▸ Startup & Repair...**; on macOS: **EffectCraft ▸ Settings... ▸ Startup & Repair...**) and restart EffectCraft.
+
+## Symptoms
+
+- The report says `GPU: none (CPU compositing)` followed by a reason.
+- The `Window graphics:` line names an adapter or backend you did not expect, for example an integrated or OpenGL adapter instead of your graphics card.
+
+## Fix
+
+1. Choose **Help ▸ System Compatibility Report...**. Copy the text.
+2. Look at the `Window graphics:` line. If it shows the wrong adapter, continue. If it shows your card, go to **Still stuck?** below.
+3. Choose **Edit ▸ Preferences ▸ Startup & Repair...**. On macOS, choose **EffectCraft ▸ Settings... ▸ Startup & Repair...**.
+4. Set **Window Graphics** to **Automatic**. The other choice is **OpenGL (compatibility)**.
+5. Close EffectCraft and start it again. The change applies from the next launch.
+6. Open the report again and check that `Window graphics:` now names your card.
+
+One user whose GPU was not detected on 0.8.0 fixed it this way: they set the window graphics to Automatic, and EffectCraft started through Vulkan ([issue #596](https://github.com/storytold/effectcraft/issues/596)).
+
+If the window runs on your card but the report still says `GPU: none (CPU compositing)`, the reason after it says why the GPU compositor did not start. With **OpenGL (compatibility)**, compositing always runs on the CPU, because the GPU compositor needs DirectX 12, Vulkan, Metal or WebGPU.
+
+## Why this happens
+
+When the graphics driver stops EffectCraft as its window opens, the next launch switches to OpenGL by itself. That keeps the app usable. Setting **Window Graphics** to **Automatic** lets EffectCraft choose the graphics backend again.
+
+The **GPU Information...** button on the Previews page of the preferences names the adapter the GPU compositor runs on. When compositing runs on the CPU, it says why after `GPU compositing is off:`. It also shows the `Window graphics:` line. For a bug report, still send the whole System Compatibility Report.
+
+## Windows 11 with DirectX 12
+
+On some Windows 11 PCs with NVIDIA GPUs, the GPU compositor fails to start on DirectX 12 because the FXC shader compiler rejects some of EffectCraft's GPU kernels. Two users reproduced this with an RTX 4060 laptop GPU and an RTX 3060. In their tests EffectCraft fell back to CPU compositing, and the same build started on Vulkan. This is still open in 0.9.2 as [issue #613](https://github.com/storytold/effectcraft/issues/613). Check the issue for updates.
+
+The window can also take a long time to appear. On 0.8.0 with an RTX 5060 Ti, one user measured 69 seconds before the window showed on DirectX 12 without a working DXC shader compiler, against 3 seconds on Vulkan, which is what Automatic picked on that PC. If you close EffectCraft during that wait, the next launch uses OpenGL and has no GPU compositor until you set **Window Graphics** back to **Automatic** (steps above). So wait for the window on the first launch.
+
+## Still stuck?
+
+Ask in [Discord](https://discord.gg/artcraft) or open an issue in the [issue tracker](https://github.com/storytold/effectcraft/issues). Include the whole System Compatibility Report, your graphics card and driver version, and whether you also have an integrated GPU.
diff --git a/docs/user/troubleshooting/index.md b/docs/user/troubleshooting/index.md
new file mode 100644
index 000000000..0cf140136
--- /dev/null
+++ b/docs/user/troubleshooting/index.md
@@ -0,0 +1,10 @@
+---
+title: Troubleshooting
+description: Fixes for common EffectCraft problems.
+order: 30
+---
+
+- [EffectCraft does not use my graphics card](gpu-not-used.md)
+- [Footage is missing or offline](footage-missing.md)
+
+Not listed? Open an issue in the [issue tracker](https://github.com/storytold/effectcraft/issues) or ask in [Discord](https://discord.gg/artcraft). Include the text from **Help ▸ System Compatibility Report...**.
diff --git a/docs/web.md b/docs/web.md
index c18f7e869..1cdecab00 100644
--- a/docs/web.md
+++ b/docs/web.md
@@ -242,6 +242,25 @@ Window ▸ Media Browser browses a virtual tree (`src/browse.rs`):
 
 `mediaBrowser.list` reports the places and these actions; `mediaBrowser.action {action}` runs one.
 
+### Startup project
+
+By default the page opens the last visit's project, and the demo project on a first visit. A
+`startup` key in `effectcraft-config.json` (next to `index.html`) changes that:
+
+```json
+{"startup":"empty"}
+```
+
+| Value | On load |
+|---|---|
+| `"last"` (or no key) | the last visit's project; the demo project on a first visit |
+| `"empty"` | the last visit's project; a blank project on a first visit, never the demo |
+| `"demo"` | the demo project, whatever the last visit left; the session is not saved, so the last visit's project stays as it was |
+
+The `?empty` and `?demo` URL flags still win. A missing, invalid or non-JSON file, or an unknown
+value, is the default. The file is fetched once per page load; serve it with
+`Cache-Control: no-cache` (the service worker never caches it).
+
 ### Audio
 
 Audio preview goes through **Web Audio**: an AudioWorklet (`audio-worklet.js`; a
diff --git a/extensions/scriptui-panels/Ease Presets.jsx b/extensions/scriptui-panels/Ease Presets.jsx
index 6f6eadae5..9f4ea2185 100644
--- a/extensions/scriptui-panels/Ease Presets.jsx	
+++ b/extensions/scriptui-panels/Ease Presets.jsx	
@@ -18,6 +18,8 @@
 // segment on that side. So a selected pair gets the whole curve, and a single key works too.
 // Roving keys are skipped: they pass speed straight through (their sides stay linear), so an ease
 // set on them wouldn't play.
+// The built-in Linear preset uses Linear interpolation, including on unused endpoint sides
+// so a fully linear key has a diamond icon; the other presets use Bezier.
 //
 // User presets are kept with app.settings (section "Ease Presets", key "userPresets") as JSON:
 // {"version": 1, "presets": [{"name": …, "curve": {"outInfluence", "outSpeed", "inInfluence",
@@ -29,6 +31,7 @@
   var MAX_NAME = 64;
   var MIN_INFLUENCE = 0.1;
   var MAX_SPEED = 100;
+  var LINEAR = KeyframeInterpolationType.LINEAR;
   var BEZIER = KeyframeInterpolationType.BEZIER;
   var HOLD = KeyframeInterpolationType.HOLD;
 
@@ -178,16 +181,16 @@
 
   // Ease one side of key `k` with `eases`, leaving its other side as it plays (auto-Bezier and
   // linear sides keep their shape; a continuous key stops being continuous, its sides now differ).
-  function easeSide(p, k, out, eases) {
+  function easeSide(p, k, out, eases, interpolation) {
     var inType = p.keyInInterpolationType(k), outType = p.keyOutInterpolationType(k);
     var inEase = p.keyInTemporalEase(k), outEase = p.keyOutTemporalEase(k);
     if (p.keyTemporalContinuous(k)) p.setTemporalContinuousAtKey(k, false);
     if (out) {
       p.setTemporalEaseAtKey(k, inEase, eases);
-      p.setInterpolationTypeAtKey(k, inType, BEZIER);
+      p.setInterpolationTypeAtKey(k, inType, interpolation);
     } else {
       p.setTemporalEaseAtKey(k, eases, outEase);
-      p.setInterpolationTypeAtKey(k, BEZIER, outType);
+      p.setInterpolationTypeAtKey(k, interpolation, outType);
     }
   }
 
@@ -201,7 +204,7 @@
   // Ease the sides `mode` names ("In", "Out" or "In-Out") of every selected keyframe with `c`, in
   // one undo step: a side with a neighbouring key, scaled to the segment on that side. Returns
   // {eased, roving}: the number of keyframes eased, and of selected roving keyframes skipped.
-  function applyCurve(c, mode) {
+  function applyCurve(c, mode, interpolation) {
     var keyed = selectedKeyed(), sides = [], keys = 0, roving = 0;
     var doIn = mode !== "Out", doOut = mode !== "In";
     // Every side and its eases first: the segments are measured before any key changes.
@@ -214,16 +217,16 @@
           continue;
         }
         var s = doIn && k > 1 ? slopes(p, k - 1) : null;
-        if (s) sides.push({ prop: p, key: k, out: false, eases: eases(s, c.inSpeed, c.inInfluence) });
+        if (s || (doIn && interpolation === LINEAR)) sides.push({ prop: p, key: k, out: false, eases: s ? eases(s, c.inSpeed, c.inInfluence) : p.keyInTemporalEase(k) });
         s = doOut && k < p.numKeys ? slopes(p, k) : null;
-        if (s) sides.push({ prop: p, key: k, out: true, eases: eases(s, c.outSpeed, c.outInfluence) });
+        if (s || (doOut && interpolation === LINEAR)) sides.push({ prop: p, key: k, out: true, eases: s ? eases(s, c.outSpeed, c.outInfluence) : p.keyOutTemporalEase(k) });
         if (sides.length > before) keys++;
       }
     }
     if (!sides.length) return { eased: 0, roving: roving };
     app.beginUndoGroup("Apply Ease Preset");
     try {
-      for (var e = 0; e < sides.length; e++) easeSide(sides[e].prop, sides[e].key, sides[e].out, sides[e].eases);
+      for (var e = 0; e < sides.length; e++) easeSide(sides[e].prop, sides[e].key, sides[e].out, sides[e].eases, interpolation);
     } finally {
       app.endUndoGroup();
     }
@@ -384,7 +387,10 @@
 
   function apply(c, what) {
     var m = mode.selection ? mode.selection.text : "In-Out";
-    var r = applyCurve(c, m), n = r.eased;
+    // Linear is an interpolation type too, so its keys get diamond icons. Edited speeds
+    // make a custom Bezier curve even while Linear remains selected in the list.
+    var interpolation = list.selection && list.selection.text === "Linear" && c.outSpeed === 1 && c.inSpeed === 1 ? LINEAR : BEZIER;
+    var r = applyCurve(c, m, interpolation), n = r.eased;
     var side = m === "In" ? "before it" : m === "Out" ? "after it" : "next to it";
     var skipped = r.roving > 0 ? "skipped " + r.roving + " roving keyframe(s); turn off Roving to ease them" : "";
     if (n > 0) status.text = "Eased " + n + " keyframe(s) (" + m + ") with " + what + (skipped ? "; " + skipped : "");
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 000000000..915f6ef3e
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1791594108,
+        "narHash": "sha256-XK4KceonkwD8LuMAt/vNrz982mXJM5jeHAxMwsUXXAQ=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "6510408d147d8c5e6d76043e899e9251756f6a75",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 000000000..38d8aa87c
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,106 @@
+{
+  description = "EffectCraft — motion graphics and visual effects, a free alternative to After Effects, in pure Rust";
+
+  inputs = {
+    # EffectCraft needs edition 2024 and rustc ≥ 1.95, so the flake tracks unstable. Consumers on a
+    # release channel can retarget it: `inputs.effectcraft.inputs.nixpkgs.follows = "nixpkgs";`
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  };
+
+  outputs =
+    {
+      self,
+      nixpkgs,
+    }:
+    let
+      inherit (nixpkgs) lib;
+
+      systems = [
+        "x86_64-linux"
+        "aarch64-linux"
+        "aarch64-darwin"
+      ];
+
+      # The AppStream metadata carries a release date. The flake source's own commit date is
+      # reproducible, unlike "now"; a tarball or dirty tree without one falls back to the epoch.
+      buildDate =
+        let
+          d = self.lastModifiedDate or "";
+        in
+        if builtins.stringLength d >= 8 then
+          "${builtins.substring 0 4 d}-${builtins.substring 4 2 d}-${builtins.substring 6 2 d}"
+        else
+          "1970-01-01";
+
+      packageArgs = {
+        inherit buildDate;
+      };
+
+      forAllSystems = f: lib.genAttrs systems (system: f (import nixpkgs { inherit system; }) system);
+    in
+    {
+      packages = forAllSystems (
+        pkgs: _:
+        let
+          effectcraft = pkgs.callPackage ./nix/package.nix packageArgs;
+        in
+        {
+          inherit effectcraft;
+          default = effectcraft;
+        }
+      );
+
+      # `nixpkgs.overlays = [ inputs.effectcraft.overlays.default ]` → `pkgs.effectcraft` everywhere.
+      overlays.default = final: _prev: {
+        effectcraft = final.callPackage ./nix/package.nix packageArgs;
+      };
+
+      apps = forAllSystems (
+        _: system: {
+          default = {
+            type = "app";
+            program = lib.getExe self.packages.${system}.effectcraft;
+          };
+        }
+      );
+
+      devShells = forAllSystems (
+        pkgs: system:
+        let
+          effectcraft = self.packages.${system}.effectcraft;
+        in
+        {
+          default = pkgs.mkShell ({
+            # The package's own native inputs, so `cargo build` in the shell needs no extra setup.
+            inputsFrom = [ effectcraft ];
+            packages = with pkgs; [
+              cargo
+              rustc
+              clippy
+              rustfmt
+              rust-analyzer
+            ];
+            # `cargo run` dlopens the Vulkan loader, libwayland and libxkbcommon like the packaged binary.
+            LD_LIBRARY_PATH = lib.makeLibraryPath effectcraft.passthru.runtimeLibs;
+            RUST_BACKTRACE = "1";
+          });
+        }
+      );
+
+      checks = forAllSystems (
+        pkgs: system: {
+          effectcraft = self.packages.${system}.effectcraft;
+
+          # `nix fmt` formats the flake; this keeps it formatted.
+          formatting =
+            pkgs.runCommand "effectcraft-nix-formatting" { nativeBuildInputs = [ pkgs.nixfmt ]; }
+              ''
+                nixfmt --check ${./flake.nix} ${./nix}
+                touch $out
+              '';
+        }
+      );
+
+      formatter = forAllSystems (pkgs: _: pkgs.nixfmt);
+    };
+}
diff --git a/nix/package.nix b/nix/package.nix
new file mode 100644
index 000000000..51b636c60
--- /dev/null
+++ b/nix/package.nix
@@ -0,0 +1,200 @@
+# EffectCraft — the desktop app (`effectcraft`) and the CLI/MCP server (`effectcraft-cli`), built from this
+# repository:
+#
+#   nix build          # → ./result/bin/effectcraft, ./result/bin/effectcraft-cli
+#
+# Kept in step with the release workflow (.github/workflows/release.yml) and packaging/:
+#   * `Cargo.lock` drives the dependencies (`cargoLock`), so there is no vendorHash to bump. The
+#     git sources (storytold/craft-libs, storytold/filmcraft) are fetched at the revision the lock file pins;
+#   * the desktop file, hicolor icons, MIME types and AppStream metadata are the same files the
+#     .deb/.rpm ship (packaging/linux/), so `apt` and NixOS users see one identical EffectCraft;
+#   * `doCheck` is off: the test suite needs corpora and a GPU the Nix sandbox cannot provide
+#     (`cargo xtask ci` is the gate). `pkgs.effectcraft.overrideAttrs { doCheck = true; }` runs it.
+#
+# Everything in the product is pure Rust, so this needs no build system beyond cargo plus the
+# libraries winit/wgpu `dlopen` at run time (see `runtimeLibs`).
+#
+# Desktop sessions: the window opens natively on Wayland (GNOME/Mutter, Hyprland and other
+# wlroots-style compositors) and falls back to X11/XWayland. File dialogs go through
+# xdg-desktop-portal, so the session needs a portal backend: GNOME ships one
+# (`xdg-desktop-portal-gnome`); on Hyprland enable
+#   xdg.portal = { enable = true; extraPortals = [ pkgs.xdg-desktop-portal-gtk ]; };
+# next to `programs.hyprland.enable = true;`.
+{
+  lib,
+  stdenv,
+  rustPlatform,
+  pkg-config,
+  makeWrapper,
+  # Windowing/GPU libraries: needed at build time by the crates that link them, at run time by the
+  # ones that open them with dlopen() (see `runtimeLibs`), and by the dev shell (flake.nix).
+  wayland,
+  wayland-scanner,
+  libxkbcommon,
+  libx11,
+  libxcb,
+  libxcursor,
+  libxi,
+  libxrandr,
+  vulkan-loader,
+  libglvnd,
+  # rfd opens libdbus-1 at run time to reach the xdg-desktop-portal file chooser (Open/Save dialogs).
+  dbus,
+  # Audio: cpal links ALSA, which reaches PipeWire/PulseAudio through the ALSA plug-ins.
+  alsa-lib,
+  # Validates the desktop file and the AppStream metadata we install (as CI does).
+  desktop-file-utils,
+  appstream,
+  # Adds the driver search path (/run/opengl-driver/lib) to the binaries' RPATH so wgpu finds the
+  # installed Vulkan/GL driver on NixOS. Optional: harmless on nixpkgs without it.
+  autoAddDriverRunpath ? null,
+  # Release date for the AppStream metadata (YYYY-MM-DD); the flake derives it from its own commit.
+  buildDate ? "1970-01-01",
+}:
+
+let
+  root = ../.;
+
+  # The version lives in exactly one place: `[workspace.package] version` in the root Cargo.toml.
+  version = (builtins.fromTOML (builtins.readFile (root + "/Cargo.toml"))).workspace.package.version;
+
+  isLinux = stdenv.hostPlatform.isLinux;
+
+  # AppStream id: also the desktop file name, and the icon name in share/icons/hicolor.
+  appId = "ai.storyteller.effectcraft";
+
+  # Libraries the binaries open at run time with dlopen(): nothing links them, so no RPATH points at
+  # them. winit loads libwayland-client, libxkbcommon(-x11) and the X11 libraries; wgpu loads the
+  # Vulkan loader or libEGL (libglvnd); rfd loads libdbus-1 for the file chooser portal. NixOS patches the loader to find the drivers in
+  # /run/opengl-driver. The wrapper below points LD_LIBRARY_PATH here.
+  runtimeLibs = lib.optionals isLinux [
+    libxkbcommon
+    wayland
+    libx11
+    libxcb
+    libxcursor
+    libxi
+    libxrandr
+    vulkan-loader
+    libglvnd
+    dbus
+  ];
+
+  # The two native binaries. The wasm app (apps/effectcraft-web) is built by `cargo xtask`, not here.
+  binaries = [
+    "effectcraft"
+    "effectcraft-cli"
+  ];
+
+in
+rustPlatform.buildRustPackage {
+  pname = "effectcraft";
+  inherit version;
+
+  src = lib.cleanSourceWith {
+    src = lib.cleanSource root;
+    # The Nix files are not part of the build: editing them must not rebuild any Rust.
+    filter =
+      path: _type:
+      !(builtins.elem (baseNameOf path) [
+        "flake.nix"
+        "flake.lock"
+        "nix"
+      ]);
+  };
+
+  cargoLock = {
+    lockFile = root + "/Cargo.lock";
+    # The git dependencies are pinned by revision in Cargo.lock.
+    allowBuiltinFetchGit = true;
+  };
+
+  # Both binaries, as the .deb/.rpm install them (`packaging/linux/package.sh`).
+  cargoBuildFlags = [
+    "--locked"
+    "-p"
+    "effectcraft"
+    "-p"
+    "effectcraft-cli"
+  ];
+
+  doCheck = false;
+
+  strictDeps = true;
+
+  nativeBuildInputs = [
+    pkg-config
+  ]
+  ++ lib.optionals isLinux [
+    makeWrapper
+    wayland-scanner
+    desktop-file-utils
+    appstream
+  ]
+  ++ lib.optionals (isLinux && autoAddDriverRunpath != null) [ autoAddDriverRunpath ];
+
+  buildInputs = lib.optionals isLinux [
+    wayland
+    libxkbcommon
+    libx11
+    libxcb
+    libxcursor
+    libxi
+    libxrandr
+    alsa-lib
+  ];
+
+  postInstall = ''
+    # Desktop integration: byte-for-byte the files the .deb/.rpm/.AppImage install.
+    install -Dm644 packaging/linux/${appId}.desktop $out/share/applications/${appId}.desktop
+    install -Dm644 packaging/linux/${appId}.mime.xml $out/share/mime/packages/${appId}.xml
+    cp -r assets/app-icon/hicolor $out/share/icons/
+    install -d $out/share/metainfo
+    substitute packaging/linux/${appId}.metainfo.xml.in \
+      $out/share/metainfo/${appId}.metainfo.xml \
+      --subst-var-by VERSION ${version} \
+      --subst-var-by DATE ${buildDate}
+
+    # Licences for everything embedded in the binaries.
+    doc=$out/share/doc/effectcraft
+    for f in README.md LICENSE-MIT LICENSE-APACHE NOTICE ATTRIBUTION.md assets/ATTRIBUTION.md; do
+      if [ -f "$f" ]; then install -Dm644 "$f" "$doc/$(basename "$f")"; fi
+    done
+    for f in assets/fonts/OFL-*.txt; do
+      if [ -f "$f" ]; then install -Dm644 "$f" "$doc/$(basename "$f")"; fi
+    done
+  ''
+  + lib.optionalString isLinux ''
+    desktop-file-validate $out/share/applications/${appId}.desktop
+    XDG_CACHE_HOME=$TMPDIR/.cache appstreamcli validate --no-net \
+      $out/share/metainfo/${appId}.metainfo.xml
+
+    # makeWrapper keeps the binaries working when the libs above are only dlopen'd.
+    for bin in ${lib.concatStringsSep " " (map (b: "$out/bin/" + b) binaries)}; do
+      wrapProgram "$bin" --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath runtimeLibs}"
+    done
+  '';
+
+  passthru = {
+    # Shared with the dev shell so `cargo run` inside `nix develop` finds the same dlopen'd libs.
+    inherit runtimeLibs;
+  };
+
+  meta = {
+    description = "Motion graphics and visual effects application";
+    longDescription = ''
+      EffectCraft is a motion graphics and visual effects application: compositions, keyframes,
+      effects and rendering. It ships with effectcraft-cli, a headless renderer, command runner and
+      MCP server for AI agents.
+    '';
+    homepage = "https://getartcraft.com/apps/effectcraft";
+    license = with lib.licenses; [
+      mit
+      asl20
+    ];
+    sourceProvenance = with lib.sourceTypes; [ fromSource ];
+    platforms = lib.platforms.linux ++ lib.platforms.darwin;
+    # `nix run` and the desktop entry both start the GUI.
+    mainProgram = "effectcraft";
+  };
+}
diff --git a/packaging/freebsd/package.sh b/packaging/freebsd/package.sh
index b5d1dc447..053f8185c 100755
--- a/packaging/freebsd/package.sh
+++ b/packaging/freebsd/package.sh
@@ -1,12 +1,12 @@
 #!/usr/bin/env bash
 # Build and package EffectCraft for FreeBSD:
 #
-#   $DIST/effectcraft-<version>-freebsd-x86_64.tar.gz   a /usr/local-style tree:
-#       effectcraft-<version>-freebsd-x86_64/{bin, share/applications, share/icons, share/mime,
+#   $DIST/effectcraft-<version>-freebsd-<arch>.tar.gz   a /usr/local-style tree (<arch> is x86_64 or aarch64):
+#       effectcraft-<version>-freebsd-<arch>/{bin, share/applications, share/icons, share/mime,
 #       share/metainfo, share/doc/effectcraft}
 #
 # Install by copying the tree's contents into /usr/local:
-#   tar -xzf effectcraft-<version>-freebsd-x86_64.tar.gz --strip-components 1 -C /usr/local
+#   tar -xzf effectcraft-<version>-freebsd-<arch>.tar.gz --strip-components 1 -C /usr/local
 #
 # Usage: packaging/freebsd/package.sh [--skip-build] [--dry-run]
 #   --dry-run   stage the tree from stub binaries and list it, without building (works on any OS)
@@ -29,13 +29,22 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
-# FreeBSD's uname says amd64; release file names use x86_64 like the Linux and Windows ones.
-MACHINE="$(uname -m)"
-case "$MACHINE" in
-  amd64 | x86_64) ARCH=x86_64 ;;
-  arm64 | aarch64) ARCH=aarch64 ;;
-  *) echo "unsupported architecture $MACHINE" >&2; exit 2 ;;
-esac
+# A cross build runs on the x86_64 VM, so the target names the arch, not uname.
+if [[ -n "${CARGO_BUILD_TARGET:-}" ]]; then
+  case "$CARGO_BUILD_TARGET" in
+    aarch64-unknown-freebsd) ARCH=aarch64 ;;
+    x86_64-unknown-freebsd) ARCH=x86_64 ;;
+    *) echo "unsupported CARGO_BUILD_TARGET $CARGO_BUILD_TARGET (use x86_64- or aarch64-unknown-freebsd)" >&2; exit 2 ;;
+  esac
+else
+  # FreeBSD's uname says amd64; release file names use x86_64 like the Linux and Windows ones.
+  MACHINE="$(uname -m)"
+  case "$MACHINE" in
+    amd64 | x86_64) ARCH=x86_64 ;;
+    arm64 | aarch64) ARCH=aarch64 ;;
+    *) echo "unsupported architecture $MACHINE" >&2; exit 2 ;;
+  esac
+fi
 if [[ "$DRY_RUN" = 0 ]] && [[ "$(uname -s)" != FreeBSD ]]; then
   echo "error: build on FreeBSD (or pass --dry-run to check the tree layout)" >&2
   exit 2
@@ -46,16 +55,15 @@ echo "==> EffectCraft $VERSION for FreeBSD $ARCH"
 
 # The release VM has 12 GB; full parallelism on the biggest crates runs it out of memory.
 export CARGO_BUILD_JOBS="${CARGO_BUILD_JOBS:-4}"
-# The aarch64 release VM is emulated (no rustup toolchain for this tier-3 target, so it builds
-# natively under QEMU). With one codegen unit and thin LTO the largest crates each optimize on a
-# single emulated core and the job runs past its 5-hour limit, so trade a little runtime speed for
-# parallel codegen there. x86_64 keeps the workspace's release profile.
+# The aarch64 build once ran in an emulated VM: with one codegen unit and thin LTO the largest
+# crates each optimized on a single emulated core and the job ran past its 5-hour limit, so trade
+# a little runtime speed for parallel codegen there. x86_64 keeps the workspace's release profile.
 if [[ "$ARCH" = aarch64 ]]; then
   export CARGO_PROFILE_RELEASE_CODEGEN_UNITS="${CARGO_PROFILE_RELEASE_CODEGEN_UNITS:-16}"
   export CARGO_PROFILE_RELEASE_LTO="${CARGO_PROFILE_RELEASE_LTO:-off}"
 fi
 if [[ "$SKIP_BUILD" = 0 ]]; then
-  (cd "$ROOT" && cargo build --release --locked -p effectcraft -p effectcraft-cli)
+  (cd "$ROOT" && cargo build --release --locked ${CARGO_BUILD_TARGET:+--target "$CARGO_BUILD_TARGET"} -p effectcraft -p effectcraft-cli)
 fi
 WORK="$CARGO_TARGET_DIR/freebsd-package"
 STAGE="$WORK/$BASENAME"
@@ -63,6 +71,7 @@ rm -rf "$WORK"
 mkdir -p "$WORK"
 
 BIN="$CARGO_TARGET_DIR/release"
+if [[ -n "${CARGO_BUILD_TARGET:-}" ]]; then BIN="$CARGO_TARGET_DIR/$CARGO_BUILD_TARGET/release"; fi
 OUT_DIR="$DIST"
 if [[ "$DRY_RUN" = 1 ]]; then
   # Stub binaries, and the tarball stays in the work dir so dist/ only ever holds real builds.
@@ -103,7 +112,15 @@ mkdir -p "$OUT_DIR"
 tar -C "$WORK" -czf "$OUT_DIR/$BASENAME.tar.gz" "$BASENAME"
 echo "wrote $OUT_DIR/$BASENAME.tar.gz"
 
-"$STAGE/bin/effectcraft-cli" --version
+# Run the smoke test only when the binary's target is this host's (a cross build can't run here).
+case "$(uname -m)" in
+  amd64 | x86_64) HOST_TRIPLE=x86_64-unknown-freebsd ;;
+  arm64 | aarch64) HOST_TRIPLE=aarch64-unknown-freebsd ;;
+  *) HOST_TRIPLE= ;;
+esac
+if [[ -z "${CARGO_BUILD_TARGET:-}" || "$CARGO_BUILD_TARGET" = "$HOST_TRIPLE" ]]; then
+  "$STAGE/bin/effectcraft-cli" --version
+fi
 if [[ "$DRY_RUN" = 1 ]]; then
   echo "==> dry run: tarball contents"
   tar -tzvf "$OUT_DIR/$BASENAME.tar.gz"
diff --git a/packaging/icons.sh b/packaging/icons.sh
index 770cda91d..9ae9af213 100755
--- a/packaging/icons.sh
+++ b/packaging/icons.sh
@@ -5,9 +5,6 @@
 # .icns. The outputs are committed, so builds and packaging never need these tools.
 #
 #   packaging/icons.sh
-#
-# effectcraft.svg and effectcraft-small.svg (the lighter 1024 px trace) come from craftrules
-# (assets/app-icons/effectcraft/, which also keeps the source drawing) and are copied in by hand.
 set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 DIR="$ROOT/assets/app-icon"
diff --git a/packaging/linux/flatpak-bundle.sh b/packaging/linux/flatpak-bundle.sh
index eddc6da26..a171582bb 100755
--- a/packaging/linux/flatpak-bundle.sh
+++ b/packaging/linux/flatpak-bundle.sh
@@ -20,10 +20,12 @@ APP_ID=ai.storyteller.effectcraft
 FLATHUB=https://dl.flathub.org/repo/flathub.flatpakrepo
 
 TEST=1
+OCI=0
 TARBALL=""
 while [[ $# -gt 0 ]]; do
   case "$1" in
     --no-test) TEST=0; shift ;;
+    --oci) OCI=1; shift ;;
     -h | --help) sed -n '2,14p' "$0"; exit 0 ;;
     -*) echo "unknown argument: $1" >&2; exit 2 ;;
     *) TARBALL="$1"; shift ;;
@@ -61,6 +63,12 @@ OUT="$DIST/$BASENAME.flatpak"
 # --runtime-repo lets `flatpak install` fetch the freedesktop runtime from Flathub if missing.
 flatpak build-bundle --runtime-repo="$FLATHUB" "$WORK/repo" "$OUT" "$APP_ID" stable
 echo "wrote $OUT"
+if [[ "$OCI" = 1 ]]; then
+  OUT_OCI="$DIST/$BASENAME-oci"
+  rm -rf "$OUT_OCI"
+  flatpak build-bundle --oci "$WORK/repo" "$OUT_OCI" "$APP_ID" stable
+  echo "wrote OCI layout to $OUT_OCI"
+fi
 
 if [[ "$TEST" = 1 ]]; then
   flatpak install --user -y --noninteractive --reinstall "$OUT"
diff --git a/packaging/linux/flatpak-oci.sh b/packaging/linux/flatpak-oci.sh
new file mode 100755
index 000000000..6a40bb991
--- /dev/null
+++ b/packaging/linux/flatpak-oci.sh
@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# Build effectcraft as an OCI container layout and push it to GitHub Container Registry (GHCR)
+# for consumption by Flatpak OCI clients (flatpak-oci-specs).
+#
+# Usage:
+#   packaging/linux/flatpak-oci.sh [--push] [TARBALL]
+#
+# Environment variables:
+#   REGISTRY       Target registry image (default: ghcr.io/storytold/effectcraft)
+#   TAG            Target image tag (default: $VERSION-$ARCH, also tags stable-$ARCH)
+#   GITHUB_TOKEN   Token for GHCR authentication when --push is used
+set -euo pipefail
+# shellcheck source=../env.sh
+. "$(dirname "${BASH_SOURCE[0]}")/../env.sh"
+HERE="$ROOT/packaging/linux"
+
+PUSH=0
+TARBALL=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --push) PUSH=1; shift ;;
+    -h | --help) sed -n '2,12p' "$0"; exit 0 ;;
+    -*) echo "unknown argument: $1" >&2; exit 2 ;;
+    *) TARBALL="$1"; shift ;;
+  esac
+done
+
+ARCH="$(uname -m)"
+case "$ARCH" in
+  x86_64) ;;
+  aarch64 | arm64) ARCH=aarch64 ;;
+  *) echo "unsupported architecture $ARCH" >&2; exit 2 ;;
+esac
+
+BASENAME="effectcraft-$VERSION-linux-$ARCH"
+OUT_OCI="$DIST/$BASENAME-oci"
+
+echo "==> Building Flatpak OCI layout for $BASENAME"
+"$HERE/flatpak-bundle.sh" --oci --no-test "${TARBALL:-}"
+
+[[ -d "$OUT_OCI" ]] || { echo "error: $OUT_OCI layout not generated" >&2; exit 1; }
+
+REGISTRY="${REGISTRY:-ghcr.io/storytold/effectcraft}"
+TAG="${TAG:-$VERSION-$ARCH}"
+
+echo "==> OCI layout ready at $OUT_OCI (Target: $REGISTRY:$TAG)"
+
+if [[ "$PUSH" = 1 ]]; then
+  command -v skopeo >/dev/null || { echo "error: skopeo is required to push OCI images (apt install skopeo)" >&2; exit 1; }
+
+  AUTH_ARGS=()
+  if [[ -n "${GITHUB_TOKEN:-}" ]]; then
+    AUTH_ARGS=(--dest-creds "${GITHUB_ACTOR:-storytold}:$GITHUB_TOKEN")
+  fi
+
+  echo "==> Pushing to $REGISTRY:$TAG"
+  skopeo copy --format oci "${AUTH_ARGS[@]}" "oci:$OUT_OCI" "docker://$REGISTRY:$TAG"
+
+  # Also update architecture-specific stable tag
+  echo "==> Pushing to $REGISTRY:stable-$ARCH"
+  skopeo copy --format oci "${AUTH_ARGS[@]}" "oci:$OUT_OCI" "docker://$REGISTRY:stable-$ARCH"
+
+  echo "==> Push complete"
+fi
diff --git a/packaging/linux/flatpak/ai.storyteller.effectcraft.bundle.yml b/packaging/linux/flatpak/ai.storyteller.effectcraft.bundle.yml
index f1074cdb2..03c4ee08f 100644
--- a/packaging/linux/flatpak/ai.storyteller.effectcraft.bundle.yml
+++ b/packaging/linux/flatpak/ai.storyteller.effectcraft.bundle.yml
@@ -17,6 +17,7 @@ runtime-version: '25.08'
 sdk: org.freedesktop.Sdk
 command: effectcraft
 finish-args:
+  - --filesystem=xdg-data/ArtCraft/versions:ro
   # Display: Wayland first; X11 only when no Wayland compositor is running.
   - --socket=wayland
   - --socket=fallback-x11
diff --git a/packaging/linux/flatpak/ai.storyteller.effectcraft.yml b/packaging/linux/flatpak/ai.storyteller.effectcraft.yml
index 7dd7a8d68..0797c5ea2 100644
--- a/packaging/linux/flatpak/ai.storyteller.effectcraft.yml
+++ b/packaging/linux/flatpak/ai.storyteller.effectcraft.yml
@@ -20,6 +20,7 @@ sdk-extensions:
   - org.freedesktop.Sdk.Extension.rust-stable
 command: effectcraft
 finish-args:
+  - --filesystem=xdg-data/ArtCraft/versions:ro
   # Display: Wayland first; X11 only when no Wayland compositor is running.
   - --socket=wayland
   - --socket=fallback-x11
diff --git a/packaging/linux/package.sh b/packaging/linux/package.sh
index 49d44c7d3..12016f6cd 100755
--- a/packaging/linux/package.sh
+++ b/packaging/linux/package.sh
@@ -84,6 +84,11 @@ has() {
   case " $FORMATS " in *" $format "*) return 0 ;; *) return 1 ;; esac
 }
 
+# Fails unless FILE ($2) has SHA-256 digest $1.
+verify_sha256() {
+  printf '%s  %s\n' "$1" "$2" | sha256sum -c -
+}
+
 # ---- .tar.gz ------------------------------------------------------------------------------------
 if has tar; then
   mkdir -p "$WORK/tar"
@@ -143,21 +148,21 @@ if has appimage; then
       download="$TOOL.download"
       curl --proto '=https' -fsSL -o "$download" \
         "https://github.com/AppImage/appimagetool/releases/download/$APPIMAGETOOL_VERSION/appimagetool-$ARCH.AppImage"
-      printf '%s  %s\n' "$APPIMAGETOOL_SHA256" "$download" | sha256sum -c -
+      verify_sha256 "$APPIMAGETOOL_SHA256" "$download"
       chmod 755 "$download"
       mv "$download" "$TOOL"
     fi
-    printf '%s  %s\n' "$APPIMAGETOOL_SHA256" "$TOOL" | sha256sum -c -
+    verify_sha256 "$APPIMAGETOOL_SHA256" "$TOOL"
   fi
   RUNTIME="$CARGO_TARGET_DIR/appimage-runtime-$APPIMAGE_RUNTIME_VERSION-$ARCH"
   if [[ ! -f "$RUNTIME" ]]; then
     download="$RUNTIME.download"
     curl --proto '=https' -fsSL -o "$download" \
       "https://github.com/AppImage/type2-runtime/releases/download/$APPIMAGE_RUNTIME_VERSION/runtime-$ARCH"
-    printf '%s  %s\n' "$APPIMAGE_RUNTIME_SHA256" "$download" | sha256sum -c -
+    verify_sha256 "$APPIMAGE_RUNTIME_SHA256" "$download"
     mv "$download" "$RUNTIME"
   fi
-  printf '%s  %s\n' "$APPIMAGE_RUNTIME_SHA256" "$RUNTIME" | sha256sum -c -
+  verify_sha256 "$APPIMAGE_RUNTIME_SHA256" "$RUNTIME"
   # Absolute, because appimagetool runs in $DIST below (CARGO_TARGET_DIR or APPIMAGETOOL may be
   # relative).
   OUT="$(cd "$DIST" && pwd)/$BASENAME.AppImage"
diff --git a/packaging/macos/Info.plist.in b/packaging/macos/Info.plist.in
index 3e3b88948..99d8c0444 100644
--- a/packaging/macos/Info.plist.in
+++ b/packaging/macos/Info.plist.in
@@ -6,6 +6,23 @@
 <dict>
   <key>CFBundleDevelopmentRegion</key>
   <string>en</string>
+  <!-- UI translations are embedded in Rust; declare them for AppKit's system dialogs (open and
+       save panels, overwrite confirmation). Keep in sync with the interface languages. -->
+  <key>CFBundleLocalizations</key>
+  <array>
+    <string>en</string>
+    <string>cs</string>
+    <string>de</string>
+    <string>es</string>
+    <string>fr</string>
+    <string>pt-BR</string>
+    <string>ru</string>
+    <string>uk</string>
+    <string>ka</string>
+    <string>ja</string>
+    <string>zh-Hans</string>
+    <string>zh-Hant</string>
+  </array>
   <key>CFBundleDisplayName</key>
   <string>EffectCraft</string>
   <key>CFBundleName</key>
diff --git a/packaging/macos/package.sh b/packaging/macos/package.sh
index 6afc9a328..be0c03aae 100755
--- a/packaging/macos/package.sh
+++ b/packaging/macos/package.sh
@@ -80,6 +80,21 @@ sign() {
   codesign --force --sign "$IDENTITY" ${kc[@]+"${kc[@]}"} "${ts[@]}" "$@"
 }
 
+# `stapler staple` and `stapler validate` both fetch the ticket from Apple's CloudKit, and a dropped
+# connection there (NSURLErrorDomain -1005, "Error 68") fails them although notarization worked.
+# Both are idempotent, so retry with a pause; a missing or bad ticket still fails every try.
+stapler_retry() {
+  local try
+  for try in 1 2 3 4; do
+    xcrun stapler "$1" "$2" && return 0
+    [[ "$try" = 4 ]] && break
+    echo "stapler $1 failed (try $try of 4); retrying in $((try * 20)) s" >&2
+    sleep $((try * 20))
+  done
+  echo "error: stapler $1 $(basename "$2") failed 4 times" >&2
+  exit 1
+}
+
 notarize() {
   local file="$1" out id status
   echo "==> notarizing $(basename "$file") (this can take a few minutes)"
@@ -120,8 +135,8 @@ codesign --verify --strict --deep --verbose=2 "$APP"
 if [[ "$NOTARIZE" = 1 ]]; then
   ditto -c -k --keepParent "$APP" "$WORK/EffectCraft-notarize.zip"
   notarize "$WORK/EffectCraft-notarize.zip"
-  xcrun stapler staple "$APP"
-  xcrun stapler validate "$APP"
+  stapler_retry staple "$APP"
+  stapler_retry validate "$APP"
   spctl --assess --type execute -vvv "$APP"
 fi
 
@@ -182,8 +197,8 @@ fi
 hdiutil_retry detach detach "$MOUNT" >/dev/null
 if [[ "$NOTARIZE" = 1 ]]; then
   notarize "$DMG"
-  xcrun stapler staple "$DMG"
-  xcrun stapler validate "$DMG"
+  stapler_retry staple "$DMG"
+  stapler_retry validate "$DMG"
   spctl --assess --type open --context context:primary-signature -vvv "$DMG"
 fi
 
diff --git a/packaging/web/README.md b/packaging/web/README.md
index 0a1f56fe8..672d9ad67 100644
--- a/packaging/web/README.md
+++ b/packaging/web/README.md
@@ -58,6 +58,19 @@ location /effectcraft/ {
 
 Local test: `python3 -m http.server 8765` inside the folder, then open http://localhost:8765/.
 
+## Startup project (optional)
+
+To choose what the page opens on load, add an `effectcraft-config.json` next to `index.html`:
+
+```json
+{"startup":"empty"}
+```
+
+`"empty"` restores the last visit's project and otherwise starts blank (never the demo); `"demo"`
+always opens the demo project without saving the session (the last visit's project stays); `"last"` (the default) restores the last visit's project and shows
+the demo on a first visit. Serve the file with `Cache-Control: no-cache`. Details:
+[docs/web.md](https://github.com/storytold/effectcraft/blob/main/docs/web.md#startup-project).
+
 ## Embedding in a page (iframe)
 
 ```html
diff --git a/packaging/web/_headers b/packaging/web/_headers
index 013e1cf8a..e59592fb1 100644
--- a/packaging/web/_headers
+++ b/packaging/web/_headers
@@ -12,3 +12,6 @@
 
 /index.html
   Cache-Control: no-cache
+
+/effectcraft-config.json
+  Cache-Control: no-cache
diff --git a/packaging/windows/INSTALLATION.md b/packaging/windows/INSTALLATION.md
new file mode 100644
index 000000000..982a5b420
--- /dev/null
+++ b/packaging/windows/INSTALLATION.md
@@ -0,0 +1,35 @@
+# Windows installation policy checks
+
+New installations default to the current account under `Programs\ArtCraft\<App>`.
+The first setup page offers installation for everyone. Scope is selected before duplicate
+checks and directory costing. An update uses the existing context's remembered exact folder;
+`INSTALLFOLDER` supplied explicitly is never replaced. It is a secure MSI property so the
+chosen folder reaches the elevated installer. Silent machine updates pass `ALLUSERS=1`.
+A cross-context copy is refused; changing context means uninstalling the old copy first.
+
+App registration follows the selected context. Existing optional shortcuts and file-handler
+choices stay app-owned. No new cleanup operation or model/settings migration is introduced.
+Packaged resources remain package-owned; separately downloaded shared models are not caches
+and are outside this installer's ownership.
+
+## Repeatable metadata tests
+
+On Windows with WiX 5.0.2 and its matching UI/Util extensions:
+
+```powershell
+./packaging/windows/test-install-policy.ps1 -OutputDirectory ./target/install-policy-tests
+```
+
+The script builds x64, x86 and arm64 packages with deliberately non-executable payloads. It
+uses the actual package source and compiled database. A safe Windows Installer session checks
+24 scope/registration/maintenance cases, remembered and explicit custom folders, sequencing,
+upgrade identity and the original registration inventory recorded in `install-policy.json`.
+The release packaging script runs the compiled checker before signing. Packaging CI runs the
+small fixture builds without compiling the Rust application.
+
+Never install or distribute the `NOT-INSTALLABLE.msi` fixtures as an app. Passing these checks
+does not prove real installation, elevation, legacy-version upgrades, registry writes, optional
+shortcut/menu behaviour, cancellation, rollback or uninstall. Those still require the real
+payload in an authorised clean Windows test environment. Cross-architecture metadata is not
+execution evidence on those architectures. Existing open installer/association PRs must be
+reconciled before publication. Nothing here changes macOS/Linux native packaging conventions.
diff --git a/packaging/windows/check-install-policy.ps1 b/packaging/windows/check-install-policy.ps1
new file mode 100644
index 000000000..5463c0083
--- /dev/null
+++ b/packaging/windows/check-install-policy.ps1
@@ -0,0 +1,370 @@
+<#
+.SYNOPSIS
+  Check the compiled installation policy without installing any product.
+.DESCRIPTION
+  Uses Windows Installer's safe session (OpenPackage option 1). Only property-setting custom
+  actions are exercised. No AppSearch, install, repair, removal or file-writing action runs.
+#>
+param([Parameter(Mandatory = $true)] [string] $MsiPath)
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version Latest
+$policy = Get-Content -Raw -LiteralPath (Join-Path $PSScriptRoot 'install-policy.json') | ConvertFrom-Json
+function Read-Rows($Database, [string] $Sql, [int] $Columns) {
+  $view = $Database.OpenView($Sql)
+  try {
+    [void]$view.Execute()
+    while ($null -ne ($record = $view.Fetch())) {
+      try {
+        $values = @(for ($i = 1; $i -le $Columns; $i++) {
+          $record.GetType().InvokeMember('StringData', 'GetProperty', $null, $record, @($i))
+        })
+        ,$values
+      } finally { [void][Runtime.InteropServices.Marshal]::FinalReleaseComObject($record) }
+    }
+  } finally {
+    [void]$view.Close()
+    [void][Runtime.InteropServices.Marshal]::FinalReleaseComObject($view)
+  }
+}
+function Set-SessionProperty($Session, [string] $Name, [string] $Value) {
+  [void]$Session.GetType().InvokeMember('Property', 'SetProperty', $null, $Session, @($Name, $Value))
+}
+function Get-SessionProperty($Session, [string] $Name) {
+  $Session.GetType().InvokeMember('Property', 'GetProperty', $null, $Session, @($Name))
+}
+function Get-PackageTemplate($Database) {
+  # Summary information property 7 is the platform: "Intel;1033", "x64;1033" or "Arm64;1033".
+  $summary = $Database.GetType().InvokeMember('SummaryInformation', 'GetProperty', $null, $Database, @(0))
+  try { [string]$summary.GetType().InvokeMember('Property', 'GetProperty', $null, $summary, @(7)) }
+  finally { [void][Runtime.InteropServices.Marshal]::FinalReleaseComObject($summary) }
+}
+$installer = $null; $database = $null; $session = $null
+try {
+  $installer = New-Object -ComObject WindowsInstaller.Installer
+  $file = (Resolve-Path -LiteralPath $MsiPath).Path
+  $database = $installer.OpenDatabase($file, 0)
+  $session = $installer.OpenPackage($file, 1)
+  $properties = @{}
+  foreach ($row in (Read-Rows $database 'SELECT `Property`, `Value` FROM `Property`' 2)) { $properties[$row[0]] = $row[1] }
+  $secureProperties = @($properties['SecureCustomProperties'] -split ';')
+  if ('INSTALLFOLDER' -notin $secureProperties) {
+    throw 'The selected installation folder must survive elevation (secure INSTALLFOLDER).'
+  }
+  if ($policy.mode -eq 'perUser') {
+    if ($properties.ContainsKey('ALLUSERS')) { throw 'Launcher must remain per-user; machine self-update is not part of this change.' }
+    if ($properties['UpgradeCode'].Trim('{}') -ne $policy.upgradeCode) { throw 'Launcher upgrade identity changed.' }
+    $dirs = @{}
+    foreach ($row in (Read-Rows $database 'SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`' 3)) { $dirs[$row[0]] = @($row[1],$row[2]) }
+    if ($dirs['INSTALLFOLDER'][0] -ne 'CraftSuiteFolder' -or $dirs['CraftSuiteFolder'][1] -ne 'ArtCraft' -or
+        $dirs['CraftSuiteFolder'][0] -ne 'LocalProgramsFolder' -or $dirs['LocalProgramsFolder'][0] -ne 'LocalAppDataFolder') {
+      throw 'Launcher new-install folder must be under the per-user ArtCraft suite root.'
+    }
+    foreach ($explicit in @('', 'F:\Chosen exact launcher')) {
+      Set-SessionProperty $session 'PREVIOUSINSTALLFOLDER' 'E:\Existing exact launcher'
+      Set-SessionProperty $session 'INSTALLFOLDER' $explicit
+      $row = @(Read-Rows $database 'SELECT `Condition` FROM `InstallUISequence` WHERE `Action` = ''CraftRestoreLauncherFolder''' 1)[0]
+      if ($session.EvaluateCondition($row[0]) -eq 1) {
+        if ($session.DoAction('CraftRestoreLauncherFolder') -ne 1) { throw 'Launcher restore action failed.' }
+      }
+      $expected = if ($explicit) { $explicit } else { 'E:\Existing exact launcher' }
+      if ((Get-SessionProperty $session 'INSTALLFOLDER') -ne $expected) { throw 'Launcher custom or existing path was lost.' }
+    }
+    $rows = @(Read-Rows $database 'SELECT `Root`, `Key`, `Name`, `Value` FROM `Registry`' 4)
+    if (@($rows | Where-Object { $_[0] -ne '1' }).Count) { throw 'Launcher registration must stay under the current account.' }
+    foreach ($entry in $policy.registry) {
+      if (@($rows | Where-Object { $_[0] -eq $entry[0] -and $_[1] -eq $entry[1] -and $_[2] -eq $entry[2] -and $_[3] -eq $entry[3] }).Count -ne 1) {
+        throw 'Launcher registration or shortcut preference changed unexpectedly.'
+      }
+    }
+    Write-Output 'PASS ArtCraft Launcher: per-user scope, suite folder, remembered/custom paths and existing registration. No installation performed.'
+    return
+  }
+  if ($properties['ALLUSERS'] -ne '2' -or $properties['MSIINSTALLPERUSER'] -ne '1') {
+    throw 'Policy regression: new packages must default to the per-user dual-scope context.'
+  }
+  if ($properties['UpgradeCode'].Trim('{}') -ne $policy.upgradeCode) { throw 'The existing upgrade identity must not change.' }
+  $directories = @{}
+  foreach ($row in (Read-Rows $database 'SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`' 3)) {
+    $directories[$row[0]] = @($row[1], $row[2])
+  }
+  if ($directories['INSTALLFOLDER'][0] -ne 'CraftSuiteFolder' -or
+      $directories['CraftSuiteFolder'][1] -ne 'ArtCraft') { throw 'Expected the app under the ArtCraft suite folder.' }
+  $programs = $directories['CraftSuiteFolder'][0]
+  if ($programs -eq 'ProgramFiles6432Folder') { $programs = $directories[$programs][0] }
+  if ($programs -notin 'ProgramFilesFolder', 'ProgramFiles64Folder') {
+    throw 'Use Windows Installer native folder redirection, not a hard-coded profile path.'
+  }
+  $guards = @(Read-Rows $database 'SELECT `Condition`, `Description` FROM `LaunchCondition`' 2 |
+    Where-Object { $_[0] -match 'CRAFT_(USER|MACHINE)_DIR' })
+  if ($guards.Count -ne 2) { throw 'Expected both duplicate-installation guards.' }
+  $cases = 0
+  foreach ($scope in @('', '2', '1')) {
+    foreach ($user in @('', 'D:\Existing user app')) {
+      foreach ($machine in @('', 'E:\Existing machine app')) {
+        foreach ($installed in @('', '1')) {
+          Set-SessionProperty $session 'ALLUSERS' $scope
+          Set-SessionProperty $session 'Installed' $installed
+          Set-SessionProperty $session 'CRAFT_USER_DIR' $user
+          Set-SessionProperty $session 'CRAFT_MACHINE_DIR' $machine
+          $allowed = $true
+          foreach ($guard in $guards) {
+            $value = $session.EvaluateCondition($guard[0])
+            if ($value -notin 0, 1) { throw 'Invalid duplicate guard.' }
+            if ($value -eq 0) { $allowed = $false }
+          }
+          $opposite = if ($scope -eq '1') { $user } else { $machine }
+          $expected = [bool]$installed -or -not [bool]$opposite
+          if ($allowed -ne $expected) { throw "Scope regression: ALLUSERS='$scope', user=$([bool]$user), machine=$([bool]$machine), maintenance=$([bool]$installed)." }
+          $cases++
+        }
+      }
+    }
+  }
+  # Execute the actual authored type-51 actions in a safe session, not copied resolver logic.
+  foreach ($scope in @('', '2', '1')) {
+    foreach ($explicit in @('', 'F:\Chosen exact app')) {
+      Set-SessionProperty $session 'ALLUSERS' $scope
+      Set-SessionProperty $session 'INSTALLFOLDER' $explicit
+      Set-SessionProperty $session 'CRAFT_USER_DIR' 'D:\Existing user app'
+      Set-SessionProperty $session 'CRAFT_MACHINE_DIR' 'E:\Existing machine app'
+      $action = if ($scope -eq '1') { 'CraftRestoreMachineFolder' } else { 'CraftRestoreUserFolder' }
+      # Evaluate the compiled condition, so the test exercises it instead of calling the action directly.
+      $restore = @(Read-Rows $database ('SELECT `Condition` FROM `InstallExecuteSequence` WHERE `Action` = ''{0}''' -f $action) 1)[0]
+      $selected = $session.EvaluateCondition($restore[0]) -eq 1
+      if ($selected -eq [bool]$explicit) { throw "$action must run only when no folder was supplied (condition: $($restore[0]))." }
+      if ($selected -and $session.DoAction($action) -ne 1) { throw 'Remembered-folder property action failed.' }
+      $expected = if ($explicit) { $explicit } elseif ($scope -eq '1') { 'E:\Existing machine app' } else { 'D:\Existing user app' }
+      if ((Get-SessionProperty $session 'INSTALLFOLDER') -ne $expected) { throw 'Custom or remembered folder was not preserved.' }
+    }
+  }
+  $ui = @{}
+  foreach ($row in (Read-Rows $database 'SELECT `Action`, `Sequence` FROM `InstallUISequence`' 2)) { $ui[$row[0]] = [int]$row[1] }
+  if (-not ($ui['AppSearch'] -lt $ui['CraftPreferMachineScope'] -and
+      $ui['CraftPreferMachineScope'] -lt $ui['CraftScopeDlg'] -and
+      $ui['CraftScopeDlg'] -lt $ui['FindRelatedProducts'] -and
+      $ui['FindRelatedProducts'] -lt $ui['LaunchConditions'] -and
+      $ui['CraftScopeDlg'] -lt $ui['CraftRestoreUserFolder'] -and $ui['CraftRestoreUserFolder'] -lt $ui['CostInitialize'] -and
+      $ui['CraftScopeDlg'] -lt $ui['CraftRestoreMachineFolder'] -and $ui['CraftRestoreMachineFolder'] -lt $ui['CostInitialize'])) {
+    throw 'Scope must be chosen after AppSearch and before FindRelatedProducts, launch checks and costing.'
+  }
+  # Windows Installer resolves Program Files for the context it started in, before the wizard's scope choice.
+  # The wizard therefore sets the new-install folder itself, and only in the wizard.
+  $defaults = @(Read-Rows $database 'SELECT `Action`, `Sequence`, `Condition` FROM `InstallUISequence`' 3 | Where-Object { $_[0] -like 'CraftDefault*' })
+  if ($defaults.Count -lt 2) { throw 'The wizard must set the new-install folder after the scope page; Program Files is resolved before the choice.' }
+  foreach ($row in $defaults) {
+    if (-not ($ui['CraftScopeDlg'] -lt [int]$row[1] -and [int]$row[1] -lt $ui['CostInitialize'])) { throw "$($row[0]) must run after the scope page and before costing." }
+  }
+  if (@(Read-Rows $database 'SELECT `Action` FROM `InstallExecuteSequence`' 1 | Where-Object { $_[0] -like 'CraftDefault*' }).Count) {
+    throw 'Silent installs must not use the wizard-only default folder actions.'
+  }
+  # The machine default comes from the environment of the package architecture, not from a folder name.
+  # x86 packages use Program Files (x86) on 64-bit Windows; x64 and Arm64 packages use the 64-bit root.
+  $machineRoot = if ((Get-PackageTemplate $database) -match '^Intel') {
+    if (Get-SessionProperty $session 'VersionNT64') { ${env:ProgramFiles(x86)} } else { $env:ProgramFiles }
+  } elseif ($env:ProgramW6432) { $env:ProgramW6432 } else { $env:ProgramFiles }
+  $machineFolder = (Join-Path $machineRoot "ArtCraft\$($policy.name)") + '\'
+  foreach ($scope in @('1', '')) {
+    Set-SessionProperty $session 'ALLUSERS' $scope
+    Set-SessionProperty $session 'INSTALLFOLDER' ''
+    Set-SessionProperty $session 'CRAFT_MACHINE_DIR' ''
+    Set-SessionProperty $session 'CRAFT_USER_DIR' ''
+    foreach ($row in @($defaults | Sort-Object { [int]$_[1] })) {
+      if ($session.EvaluateCondition($row[2]) -eq 1 -and $session.DoAction($row[0]) -ne 1) { throw "$($row[0]) failed." }
+    }
+    $folder = Get-SessionProperty $session 'INSTALLFOLDER'
+    $wanted = if ($scope -eq '1') { $machineFolder } else { (Join-Path $env:LOCALAPPDATA "Programs\ArtCraft\$($policy.name)") + '\' }
+    if ($folder -ine $wanted) { throw "Wizard default folder for ALLUSERS='$scope' is '$folder', expected '$wanted'." }
+  }
+  # Replay the wizard's compiled folder actions in sequence order, as the full UI runs them. A remembered
+  # folder must win over the new-install default, and a folder the user typed must survive both.
+  $uiFolderActions = @(Read-Rows $database 'SELECT `Action`, `Sequence`, `Condition` FROM `InstallUISequence`' 3 |
+    Where-Object { $_[0] -match '^Craft(Restore|Default)' } | Sort-Object { [int]$_[1] })
+  $userDefault = (Join-Path $env:LOCALAPPDATA "Programs\ArtCraft\$($policy.name)") + '\'
+  foreach ($case in @(
+      @('1', 'D:\Remembered user app', 'E:\Remembered machine app', '', 'E:\Remembered machine app'),
+      @('', 'D:\Remembered user app', 'E:\Remembered machine app', '', 'D:\Remembered user app'),
+      @('1', '', '', '', $machineFolder),
+      @('', '', '', '', $userDefault),
+      @('1', 'D:\Remembered user app', 'E:\Remembered machine app', 'F:\Chosen exact app', 'F:\Chosen exact app'))) {
+    Set-SessionProperty $session 'Installed' ''
+    Set-SessionProperty $session 'ALLUSERS' $case[0]
+    Set-SessionProperty $session 'CRAFT_USER_DIR' $case[1]
+    Set-SessionProperty $session 'CRAFT_MACHINE_DIR' $case[2]
+    Set-SessionProperty $session 'INSTALLFOLDER' $case[3]
+    foreach ($row in $uiFolderActions) {
+      if ($session.EvaluateCondition($row[2]) -eq 1 -and $session.DoAction($row[0]) -ne 1) { throw "$($row[0]) failed." }
+    }
+    $folder = Get-SessionProperty $session 'INSTALLFOLDER'
+    if ($folder -ine $case[4]) { throw "Full-UI folder for ALLUSERS='$($case[0])' is '$folder', expected '$($case[4])'." }
+  }
+  $execute = @{}
+  foreach ($row in (Read-Rows $database 'SELECT `Action`, `Sequence` FROM `InstallExecuteSequence`' 2)) { $execute[$row[0]] = [int]$row[1] }
+  foreach ($action in @('CraftRestoreUserFolder','CraftRestoreMachineFolder')) {
+    if (-not ($execute['AppSearch'] -lt $execute[$action] -and $execute[$action] -lt $execute['CostInitialize'])) {
+      throw 'Silent updates must restore the folder before directory costing.'
+    }
+  }
+  foreach ($resolver in @('CraftUFromLegacyExe','CraftMFromLegacyExe')) {
+    if (-not ($execute['AppSearch'] -lt $execute[$resolver] -and $execute[$resolver] -lt $execute['LaunchConditions'])) {
+      throw 'Both legacy folder resolvers must run after AppSearch and before the launch checks.'
+    }
+  }
+  # AppSearch itself never runs in this safe session, so check the compiled searches and then run the
+  # property actions that turn the search results into the remembered folder, once per scope.
+  $appSearch = @{}
+  foreach ($row in (Read-Rows $database 'SELECT `Property`, `Signature_` FROM `AppSearch`' 2)) { $appSearch[$row[0]] = $row[1] }
+  $locators = @{}
+  foreach ($row in (Read-Rows $database 'SELECT `Signature_`, `Root`, `Key`, `Name`, `Type` FROM `RegLocator`' 5)) { $locators[$row[0]] = $row }
+  $appPaths = '^Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\[^\\]+\.exe$'
+  # Suffix, how to match the key, key, value name, locator type (2 = raw value, 1 = file; the 64-bit flag is masked off).
+  $searchContract = @(
+    @('DIR',       'exact', "Software\$($policy.name)", 'InstallDir',    '2'),
+    @('FOLDER',    'exact', "Software\$($policy.name)", 'InstallFolder', '2'),
+    @('PATH',      'regex', $appPaths,                  'Path',          '2'),
+    @('EXEFOLDER', 'regex', $appPaths,                  '',              '1'),
+    @('EXE',       'regex', $appPaths,                  '',              '1'))
+  $resolverCases = @(
+    @{ name = 'every record, DIR wins';        dir = 'D:\Dir\'; folder = 'D:\Folder\'; path = 'D:\Path\'; exeFolder = 'D:\Exe\'; exe = 'D:\Exe\app.exe'; existing = '';            expected = 'D:\Dir\' },
+    @{ name = 'FOLDER wins without DIR';       dir = '';        folder = 'D:\Folder\'; path = 'D:\Path\'; exeFolder = 'D:\Exe\'; exe = 'D:\Exe\app.exe'; existing = '';            expected = 'D:\Folder\' },
+    @{ name = 'PATH wins without DIR, FOLDER'; dir = '';        folder = '';           path = 'D:\Path\'; exeFolder = 'D:\Exe\'; exe = 'D:\Exe\app.exe'; existing = '';            expected = 'D:\Path\' },
+    @{ name = 'legacy exe folder is last';     dir = '';        folder = '';           path = '';         exeFolder = 'D:\Exe\'; exe = 'D:\Exe\app.exe'; existing = '';            expected = 'D:\Exe\' },
+    @{ name = 'legacy folder needs the exe';   dir = '';        folder = '';           path = '';         exeFolder = 'D:\Exe\'; exe = '';               existing = '';            expected = '' },
+    @{ name = 'a preset folder is kept';       dir = 'D:\Dir\'; folder = 'D:\Folder\'; path = 'D:\Path\'; exeFolder = 'D:\Exe\'; exe = 'D:\Exe\app.exe'; existing = 'P:\Preset\'; expected = 'P:\Preset\' })
+  foreach ($scopeSpec in @(@('U', '1', 'CRAFT_USER_DIR'), @('M', '2', 'CRAFT_MACHINE_DIR'))) {
+    $letter = $scopeSpec[0]; $target = $scopeSpec[2]
+    foreach ($item in $searchContract) {
+      $property = "CRAFT_${letter}_$($item[0])"
+      $locator = if ($appSearch.ContainsKey($property)) { $locators[$appSearch[$property]] } else { $null }
+      $keyOk = $null -ne $locator -and $(if ($item[1] -eq 'exact') { $locator[2] -eq $item[2] } else { $locator[2] -match $item[2] })
+      if (-not $keyOk -or $locator[1] -ne $scopeSpec[1] -or $locator[3] -ne $item[3] -or ([int]$locator[4] -band 3) -ne [int]$item[4]) {
+        throw "Compiled search for $property is missing or points at the wrong registry location."
+      }
+    }
+    $chain = @(Read-Rows $database 'SELECT `Action`, `Sequence`, `Condition` FROM `InstallExecuteSequence`' 3 |
+      Where-Object { $_[0] -match "^Craft${letter}From" } | Sort-Object { [int]$_[1] })
+    $order = @($chain | ForEach-Object { $_[0] }) -join ','
+    if ($order -ne "Craft${letter}FromDIR,Craft${letter}FromFOLDER,Craft${letter}FromPATH,Craft${letter}FromLegacyExe") {
+      throw "Remembered-folder resolvers for scope $letter run in the wrong order: $order"
+    }
+    foreach ($case in $resolverCases) {
+      Set-SessionProperty $session $target $case.existing
+      Set-SessionProperty $session "CRAFT_${letter}_DIR" $case.dir
+      Set-SessionProperty $session "CRAFT_${letter}_FOLDER" $case.folder
+      Set-SessionProperty $session "CRAFT_${letter}_PATH" $case.path
+      Set-SessionProperty $session "CRAFT_${letter}_EXEFOLDER" $case.exeFolder
+      Set-SessionProperty $session "CRAFT_${letter}_EXE" $case.exe
+      foreach ($row in $chain) {
+        if ($session.EvaluateCondition($row[2]) -eq 1 -and $session.DoAction($row[0]) -ne 1) { throw "$($row[0]) failed." }
+      }
+      $got = Get-SessionProperty $session $target
+      if ($got -ne $case.expected) { throw "Resolver chain for scope $letter, case '$($case.name)': got '$got', expected '$($case.expected)'." }
+    }
+  }
+  # Switching the first-page choice must reset BOTH properties, including a back-and-forth change.
+  $events = @(Read-Rows $database 'SELECT `Event`, `Argument`, `Condition`, `Ordering` FROM `ControlEvent` WHERE `Dialog_` = ''CraftScopeDlg'' AND `Control_` = ''Next'' ORDER BY `Ordering`' 4)
+  # Model the full-UI upgrade entry with an existing machine-wide copy. Run
+  # the actual preference action, then the compiled Next events before discovery.
+  Set-SessionProperty $session 'ALLUSERS' '2'
+  Set-SessionProperty $session 'CRAFT_SCOPE' 'user'
+  Set-SessionProperty $session 'CRAFT_USER_DIR' ''
+  Set-SessionProperty $session 'CRAFT_MACHINE_DIR' 'E:\Existing machine app'
+  $preference = @(Read-Rows $database 'SELECT `Condition` FROM `InstallUISequence` WHERE `Action` = ''CraftPreferMachineScope''' 1)[0]
+  if ($session.EvaluateCondition($preference[0]) -ne 1 -or $session.DoAction('CraftPreferMachineScope') -ne 1 -or
+      (Get-SessionProperty $session 'CRAFT_SCOPE') -ne 'machine') {
+    throw 'Full-UI machine upgrades must initially select the existing machine context.'
+  }
+  foreach ($choice in @('machine','user','machine','user')) {
+    Set-SessionProperty $session 'CRAFT_SCOPE' $choice
+    foreach ($event in $events) {
+      if ($event[0] -notmatch '^\[([^\]]+)\]$') { continue }
+      $property = $Matches[1]
+      if ($session.EvaluateCondition($event[2]) -eq 1) {
+        Set-SessionProperty $session $property $(if ($event[1] -eq '{}') { '' } else { $event[1] })
+      }
+    }
+    $allUsers = Get-SessionProperty $session 'ALLUSERS'
+    $perUser = Get-SessionProperty $session 'MSIINSTALLPERUSER'
+    if (($choice -eq 'machine' -and ($allUsers -ne '1' -or $perUser)) -or
+        ($choice -eq 'user' -and ($allUsers -or $perUser -ne '1'))) {
+      throw 'Scope selector does not reset the requested installation context.'
+    }
+  }
+  $actions = @(Read-Rows $database 'SELECT `Action`, `Source`, `Target`, `Type` FROM `CustomAction`' 4)
+  $savedOptions = @($actions | Where-Object { $_[0] -match '^CraftLoadOption[0-9]+M$' })
+  foreach ($option in $savedOptions) {
+    if ([int]$option[3] -ne 51) { throw 'Saved-option test may run only property-setting actions.' }
+    $number = [regex]::Match($option[0], '[0-9]+').Value
+    foreach ($scope in @('2','1')) {
+      Set-SessionProperty $session 'ALLUSERS' $scope
+      Set-SessionProperty $session "CRAFT_OPTION_${number}_M" 'saved-machine-choice'
+      Set-SessionProperty $session "CRAFT_OPTION_${number}_U" 'saved-user-choice'
+      Set-SessionProperty $session $option[1] ''
+      $action = "CraftLoadOption$number" + $(if ($scope -eq '1') { 'M' } else { 'U' })
+      if ($session.DoAction($action) -ne 1) { throw 'Saved-option property action failed.' }
+      $expected = if ($scope -eq '1') { 'saved-machine-choice' } else { 'saved-user-choice' }
+      if ((Get-SessionProperty $session $option[1]) -ne $expected) { throw 'Saved installer choices leaked across contexts.' }
+    }
+  }
+  # Follow the compiled control conditions, not the source's intended appearance.
+  $controls = @(Read-Rows $database 'SELECT `Dialog_`, `Control`, `Type`, `Attributes`, `Text` FROM `Control`' 5)
+  $conditions = @()
+  if (@(Read-Rows $database 'SELECT `Name` FROM `_Tables` WHERE `Name` = ''ControlCondition''' 1).Count) {
+    $conditions = @(Read-Rows $database 'SELECT `Dialog_`, `Control_`, `Action`, `Condition` FROM `ControlCondition`' 4)
+  }
+  function Test-ControlVisible($Control) {
+    $visible = ([int]$Control[3] -band 1) -ne 0
+    foreach ($condition in $conditions) {
+      if ($condition[0] -eq $Control[0] -and $condition[1] -eq $Control[1] -and $session.EvaluateCondition($condition[3]) -eq 1) {
+        if ($condition[2] -eq 'Show') { $visible = $true }
+        if ($condition[2] -eq 'Hide') { $visible = $false }
+      }
+    }
+    return $visible
+  }
+  foreach ($button in @($controls | Where-Object { $_[0] -in 'InstallWelcome','InstallMaintenance','DesktopShortcutDlg' -and ([int]$_[3] -band 8388608) -ne 0 })) {
+    $plain = @($controls | Where-Object { $_[0] -eq $button[0] -and $_[1] -eq ($button[1] + 'User') })
+    if ($plain.Count -ne 1 -or ([int]$plain[0][3] -band 8388608)) { throw 'Scope-aware buttons need an unshielded per-user counterpart.' }
+    foreach ($scope in @('', '2', '1')) {
+      Set-SessionProperty $session 'ALLUSERS' $scope
+      if ((Test-ControlVisible $button) -ne ($scope -eq '1') -or (Test-ControlVisible $plain[0]) -ne ($scope -ne '1')) {
+        throw 'The elevation shield must follow the selected scope.'
+      }
+    }
+    $dialog = $button[0]; $shieldId = $button[1]; $plainId = $plain[0][1]
+    $shieldEvents = @(Read-Rows $database "SELECT ``Event``, ``Argument``, ``Condition``, ``Ordering`` FROM ``ControlEvent`` WHERE ``Dialog_`` = '$dialog' AND ``Control_`` = '$shieldId' ORDER BY ``Ordering``" 4 | ForEach-Object { $_ -join '|' })
+    $plainEvents = @(Read-Rows $database "SELECT ``Event``, ``Argument``, ``Condition``, ``Ordering`` FROM ``ControlEvent`` WHERE ``Dialog_`` = '$dialog' AND ``Control_`` = '$plainId' ORDER BY ``Ordering``" 4 | ForEach-Object { $_ -join '|' })
+    if (($shieldEvents -join "`n") -ne ($plainEvents -join "`n")) { throw 'Per-user and machine buttons must perform the same operation.' }
+  }
+  foreach ($scope in @('', '2', '1')) {
+    Set-SessionProperty $session 'ALLUSERS' $scope
+    foreach ($text in @($controls | Where-Object { $_[4] -like '*for all users*' })) {
+      if ((Test-ControlVisible $text) -ne ($scope -eq '1')) { throw 'The welcome-page scope text must follow the selected scope.' }
+    }
+  }
+  if ($policy.id -in 'deckcraft','filmcraft','soundcraft') {
+    foreach ($route in @(@('WelcomeDlg','Next','InstallDirDlg'),@('InstallDirDlg','Back','WelcomeDlg'))) {
+      $dialog = $route[0]; $control = $route[1]
+      $routes = @(Read-Rows $database "SELECT ``Argument``, ``Condition`` FROM ``ControlEvent`` WHERE ``Dialog_`` = '$dialog' AND ``Control_`` = '$control' AND ``Event`` = 'NewDialog' ORDER BY ``Ordering``" 2)
+      Set-SessionProperty $session 'Installed' ''
+      $destination = ''
+      foreach ($event in $routes) { if ($session.EvaluateCondition($event[1]) -eq 1) { $destination = $event[0] } }
+      if ($destination -ne $route[2]) { throw 'Skipping the licence page must work in both navigation directions.' }
+    }
+  }
+  $registry = @(Read-Rows $database 'SELECT `Root`, `Key`, `Name`, `Value` FROM `Registry`' 4)
+  if (@($registry | Where-Object { $_[0] -in '1', '2' }).Count) { throw 'Registration must follow the selected context, not force HKCU or HKLM.' }
+  if (@($registry | Where-Object { $_[0] -eq '0' -and $_[1] -match '^Software\\Classes(\\|$)' }).Count) {
+    throw 'HKCR keys must be relative to Classes.'
+  }
+  foreach ($entry in $policy.registry) {
+    $found = @($registry | Where-Object { $_[0] -eq $entry[0] -and $_[1] -eq $entry[1] -and $_[2] -eq $entry[2] -and $_[3] -eq $entry[3] })
+    if ($found.Count -ne 1) { throw "Lost or changed registration: $($entry[1]) / $($entry[2])" }
+  }
+  $installDir = @($registry | Where-Object { $_[0] -eq '-1' -and $_[1] -eq "Software\$($policy.name)" -and $_[2] -eq 'InstallDir' -and $_[3] -eq '[INSTALLFOLDER]' })
+  if ($installDir.Count -ne 1) { throw 'A context-sensitive installation-folder record is required.' }
+  Write-Output "PASS $($policy.name): $cases scope cases, folder preservation, action sequencing and registry contract. No installation performed."
+} finally {
+  foreach ($com in @($session, $database, $installer)) {
+    if ($null -ne $com) { [void][Runtime.InteropServices.Marshal]::FinalReleaseComObject($com) }
+  }
+}
diff --git a/packaging/windows/effectcraft.wxs b/packaging/windows/effectcraft.wxs
index cc1df639b..f330ca061 100644
--- a/packaging/windows/effectcraft.wxs
+++ b/packaging/windows/effectcraft.wxs
@@ -1,26 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-  EffectCraft MSI (WiX Toolset v5: `dotnet tool install -g wix`). Built by package.ps1:
-
-    wix build effectcraft.wxs installer-ui.wxs -arch x64 -d Version=1.2.3 -d BinDir=... -d IconPath=... -o out.msi
-
-  Per-machine install into Program Files (or a folder the user picks), a Start Menu shortcut and,
-  unless DESKTOPSHORTCUT=0 (the wizard's "Create a desktop shortcut" box), a desktop shortcut.
--->
 <Wix xmlns="http://wixtoolset.org/schemas/v4/wxs">
-  <Package
-      Name="EffectCraft"
-      Manufacturer="Learning Machines LLC"
-      Version="$(var.Version)"
-      UpgradeCode="AACA8593-C6ED-40A8-BA6C-CB325D8529F9"
-      Scope="perMachine"
-      Compressed="yes"
-      Language="1033">
+  <Package Name="EffectCraft" Manufacturer="Learning Machines LLC" Version="$(var.Version)" UpgradeCode="AACA8593-C6ED-40A8-BA6C-CB325D8529F9" Scope="perUserOrMachine" Compressed="yes" Language="1033">
     <SummaryInformation Description="EffectCraft motion graphics and visual effects" Manufacturer="Learning Machines LLC" />
+    <?include $(sys.SOURCEFILEDIR)install-policy.wxi?>
     <!-- Same-version upgrades let successive pre-releases of one X.Y.Z replace each other
          (MSI versions are numeric, so 1.2.3-rc.1 and 1.2.3-rc.2 are both 1.2.3). -->
-    <MajorUpgrade AllowSameVersionUpgrades="yes"
-        DowngradeErrorMessage="A newer version of EffectCraft is already installed." />
+    <MajorUpgrade AllowSameVersionUpgrades="yes" DowngradeErrorMessage="A newer version of EffectCraft is already installed." />
     <MediaTemplate EmbedCab="yes" CompressionLevel="high" />
     <!-- The setup wizard (installer-ui.wxs): pick the folder on a fresh install. -->
     <UIRef Id="EffectcraftUI" />
@@ -36,32 +21,24 @@
          could be put elsewhere with INSTALLFOLDER=...) the folder of the effectcraft.exe that App Paths names. A
          "file" search with no FileSearch inside yields that file's folder. A folder passed on the
          command line (INSTALLFOLDER=...) wins. -->
-    <Property Id="INSTALLFOLDER" Secure="yes" />
     <Property Id="PREVIOUSINSTALLFOLDER" Secure="yes">
-      <RegistrySearch Id="PreviousInstallFolder" Root="HKLM" Type="directory"
-          Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Name="Path" />
+      <RegistrySearch Id="PreviousInstallFolder" Root="HKLM" Type="directory" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Name="Path" />
     </Property>
     <Property Id="PREVIOUSEXEFOLDER" Secure="yes">
-      <RegistrySearch Id="PreviousExeFolder" Root="HKLM" Type="file"
-          Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" />
+      <RegistrySearch Id="PreviousExeFolder" Root="HKLM" Type="file" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" />
     </Property>
-    <SetProperty Id="INSTALLFOLDER" Value="[PREVIOUSINSTALLFOLDER]" After="AppSearch" Sequence="both"
-        Condition="PREVIOUSINSTALLFOLDER AND NOT INSTALLFOLDER" />
-    <SetProperty Id="INSTALLFOLDER" Action="SetINSTALLFOLDERFromExe" Value="[PREVIOUSEXEFOLDER]"
-        After="SetINSTALLFOLDER" Sequence="both" Condition="PREVIOUSEXEFOLDER AND NOT INSTALLFOLDER" />
-
     <!-- The desktop shortcut: on by default for a fresh install (a box in the wizard, or
          DESKTOPSHORTCUT=0 silently); an upgrade keeps what the installed copy chose, and adds none
          to an install from before this option. -->
     <Property Id="DESKTOPSHORTCUT" Value="1" Secure="yes" />
     <Property Id="PREVIOUSDESKTOPSHORTCUT" Secure="yes">
-      <RegistrySearch Id="PreviousDesktopShortcut" Root="HKLM" Type="raw" Key="Software\EffectCraft" Name="DesktopShortcut" />
-    </Property>
-    <SetProperty Id="DESKTOPSHORTCUT" Value="[PREVIOUSDESKTOPSHORTCUT]" After="SetINSTALLFOLDERFromExe" Sequence="both"
-        Condition="WIX_UPGRADE_DETECTED" />
+      </Property>
+    <SetProperty Id="DESKTOPSHORTCUT" Value="[PREVIOUSDESKTOPSHORTCUT]" After="CraftLoadOption1U" Sequence="both" Condition="WIX_UPGRADE_DETECTED" />
 
     <StandardDirectory Id="ProgramFiles6432Folder">
-      <Directory Id="INSTALLFOLDER" Name="EffectCraft" />
+      <Directory Id="CraftSuiteFolder" Name="ArtCraft">
+        <Directory Id="INSTALLFOLDER" Name="EffectCraft" />
+      </Directory>
     </StandardDirectory>
     <StandardDirectory Id="ProgramMenuFolder" />
     <StandardDirectory Id="DesktopFolder" />
@@ -69,7 +46,9 @@
     <Feature Id="Main" Title="EffectCraft" Level="1">
       <ComponentGroupRef Id="EffectcraftFiles" />
     </Feature>
-  </Package>
+  <Property Id="CRAFT_OPTION_1_M" Secure="yes"><RegistrySearch Id="CRAFT_OPTION_1_MSearch" Root="HKLM" Type="raw" Key="Software\EffectCraft" Name="DesktopShortcut" />
+    </Property><SetProperty Id="PREVIOUSDESKTOPSHORTCUT" Action="CraftLoadOption1M" Value="[CRAFT_OPTION_1_M]" After="LaunchConditions" Sequence="both" Condition="ALLUSERS = 1" /><Property Id="CRAFT_OPTION_1_U" Secure="yes"><RegistrySearch Id="CRAFT_OPTION_1_USearch" Root="HKCU" Type="raw" Key="Software\EffectCraft" Name="DesktopShortcut" />
+    </Property><SetProperty Id="PREVIOUSDESKTOPSHORTCUT" Action="CraftLoadOption1U" Value="[CRAFT_OPTION_1_U]" After="CraftLoadOption1M" Sequence="both" Condition="ALLUSERS &lt;&gt; 1" /></Package>
 
   <Fragment>
     <ComponentGroup Id="EffectcraftFiles" Directory="INSTALLFOLDER">
@@ -78,15 +57,14 @@
       </Component>
       <Component Id="EffectcraftApp" Guid="BA719860-95FE-4154-B265-47006B8E9083">
         <File Id="EffectcraftExe" Source="$(var.BinDir)\effectcraft.exe" KeyPath="yes">
-          <Shortcut Id="StartMenuShortcut" Directory="ProgramMenuFolder" Name="EffectCraft"
-              Description="EffectCraft motion graphics and visual effects" WorkingDirectory="INSTALLFOLDER" Advertise="yes"
-              Icon="EffectcraftIcon.ico" IconIndex="0" />
+          <Shortcut Id="StartMenuShortcut" Directory="ProgramMenuFolder" Name="EffectCraft" Description="EffectCraft motion graphics and visual effects" WorkingDirectory="INSTALLFOLDER" Advertise="yes" Icon="EffectcraftIcon.ico" IconIndex="0" />
         </File>
 
-        <RegistryValue Root="HKLM" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Value="[#EffectcraftExe]" Type="string" />
-        <RegistryValue Root="HKLM" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Name="Path" Value="[INSTALLFOLDER]" Type="string" />
+        <RegistryValue Root="HKMU" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Value="[#EffectcraftExe]" Type="string" />
+        <RegistryValue Root="HKMU" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Name="Path" Value="[INSTALLFOLDER]" Type="string" />
         <!-- The desktop shortcut choice, for the next upgrade (empty: none). -->
-        <RegistryValue Root="HKLM" Key="Software\EffectCraft" Name="DesktopShortcut" Value="[DESKTOPSHORTCUT]" Type="string" />
+        <RegistryValue Root="HKMU" Key="Software\EffectCraft" Name="DesktopShortcut" Value="[DESKTOPSHORTCUT]" Type="string" />
+      <RegistryValue Root="HKMU" Key="Software\EffectCraft" Name="InstallDir" Value="[INSTALLFOLDER]" Type="string" />
       </Component>
 
       <Component Id="EffectcraftCli">
@@ -95,9 +73,8 @@
 
       <!-- A component under the user's profile folders needs an HKCU key path (ICE38, ICE43). -->
       <Component Id="DesktopShortcut" Directory="DesktopFolder" Condition="DESKTOPSHORTCUT = &quot;1&quot;">
-        <Shortcut Id="DesktopShortcut" Name="EffectCraft" Description="EffectCraft motion graphics and visual effects"
-            Target="[#EffectcraftExe]" WorkingDirectory="INSTALLFOLDER" Icon="EffectcraftIcon.ico" IconIndex="0" />
-        <RegistryValue Root="HKCU" Key="Software\EffectCraft" Name="DesktopShortcut" Value="1" Type="string" KeyPath="yes" />
+        <Shortcut Id="DesktopShortcut" Name="EffectCraft" Description="EffectCraft motion graphics and visual effects" Target="[#EffectcraftExe]" WorkingDirectory="INSTALLFOLDER" Icon="EffectcraftIcon.ico" IconIndex="0" />
+        <RegistryValue Root="HKMU" Key="Software\EffectCraft" Name="DesktopShortcut" Value="1" Type="string" KeyPath="yes" />
       </Component>
     </ComponentGroup>
   </Fragment>
diff --git a/packaging/windows/install-policy.json b/packaging/windows/install-policy.json
new file mode 100644
index 000000000..6553d217b
--- /dev/null
+++ b/packaging/windows/install-policy.json
@@ -0,0 +1,44 @@
+{
+  "id": "effectcraft",
+  "name": "EffectCraft",
+  "upgradeCode": "AACA8593-C6ED-40A8-BA6C-CB325D8529F9",
+  "sources": [
+    "effectcraft.wxs",
+    "installer-ui.wxs"
+  ],
+  "icon": "assets/app-icon/effectcraft.ico",
+  "localization": [],
+  "extensions": [],
+  "payloads": [
+    "NOTICE",
+    "effectcraft-cli.exe",
+    "effectcraft.exe"
+  ],
+  "registry": [
+    [
+      "-1",
+      "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\effectcraft.exe",
+      "",
+      "[#EffectcraftExe]"
+    ],
+    [
+      "-1",
+      "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\effectcraft.exe",
+      "Path",
+      "[INSTALLFOLDER]"
+    ],
+    [
+      "-1",
+      "Software\\EffectCraft",
+      "DesktopShortcut",
+      "[DESKTOPSHORTCUT]"
+    ],
+    [
+      "-1",
+      "Software\\EffectCraft",
+      "DesktopShortcut",
+      "1"
+    ]
+  ],
+  "mode": "dualScope"
+}
diff --git a/packaging/windows/install-policy.wxi b/packaging/windows/install-policy.wxi
new file mode 100644
index 000000000..669c08126
--- /dev/null
+++ b/packaging/windows/install-policy.wxi
@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Include xmlns="http://wixtoolset.org/schemas/v4/wxs">
+  <!-- Choose scope before launch checks and directory costing. Never move an existing copy. -->
+  <!-- Only for me leaves ALLUSERS unset. Publishing ALLUSERS=2 here makes FindRelatedProducts treat the run as
+       per-machine and skip the existing per-user copy, so an interactive upgrade installs beside it
+       (two registered products, and uninstall leaves files behind). Checked with real msiexec runs. -->
+  <Property Id="INSTALLFOLDER" Secure="yes" />
+  <Property Id="CRAFT_SCOPE" Value="user" Secure="yes" />
+  <Property Id="CRAFT_U_DIR" Secure="yes"><RegistrySearch Id="CRAFT_U_DIRSearch" Root="HKCU" Key="Software\EffectCraft" Name="InstallDir" Type="raw" /></Property>
+  <SetProperty Id="CRAFT_USER_DIR" Action="CraftUFromDIR" Value="[CRAFT_U_DIR]" After="AppSearch" Sequence="both" Condition="NOT CRAFT_USER_DIR AND CRAFT_U_DIR" />
+  <Property Id="CRAFT_U_FOLDER" Secure="yes"><RegistrySearch Id="CRAFT_U_FOLDERSearch" Root="HKCU" Key="Software\EffectCraft" Name="InstallFolder" Type="raw" /></Property>
+  <SetProperty Id="CRAFT_USER_DIR" Action="CraftUFromFOLDER" Value="[CRAFT_U_FOLDER]" After="CraftUFromDIR" Sequence="both" Condition="NOT CRAFT_USER_DIR AND CRAFT_U_FOLDER" />
+  <Property Id="CRAFT_U_PATH" Secure="yes"><RegistrySearch Id="CRAFT_U_PATHSearch" Root="HKCU" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Name="Path" Type="raw" /></Property>
+  <SetProperty Id="CRAFT_USER_DIR" Action="CraftUFromPATH" Value="[CRAFT_U_PATH]" After="CraftUFromFOLDER" Sequence="both" Condition="NOT CRAFT_USER_DIR AND CRAFT_U_PATH" />
+  <Property Id="CRAFT_U_EXEFOLDER" Secure="yes"><RegistrySearch Id="CRAFT_ULegacyFolder" Root="HKCU" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Type="file" /></Property>
+  <Property Id="CRAFT_U_EXE" Secure="yes"><RegistrySearch Id="CRAFT_ULegacyExe" Root="HKCU" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Type="file"><FileSearch Id="CRAFT_ULegacyFile" Name="effectcraft.exe" /></RegistrySearch></Property>
+  <SetProperty Id="CRAFT_USER_DIR" Action="CraftUFromLegacyExe" Value="[CRAFT_U_EXEFOLDER]" After="CraftUFromPATH" Sequence="both" Condition="NOT CRAFT_USER_DIR AND CRAFT_U_EXEFOLDER AND CRAFT_U_EXE" />
+  <Property Id="CRAFT_USER_DIR" Secure="yes" />
+  <Property Id="CRAFT_M_DIR" Secure="yes"><RegistrySearch Id="CRAFT_M_DIRSearch" Root="HKLM" Key="Software\EffectCraft" Name="InstallDir" Type="raw" /></Property>
+  <SetProperty Id="CRAFT_MACHINE_DIR" Action="CraftMFromDIR" Value="[CRAFT_M_DIR]" After="CraftUFromLegacyExe" Sequence="both" Condition="NOT CRAFT_MACHINE_DIR AND CRAFT_M_DIR" />
+  <Property Id="CRAFT_M_FOLDER" Secure="yes"><RegistrySearch Id="CRAFT_M_FOLDERSearch" Root="HKLM" Key="Software\EffectCraft" Name="InstallFolder" Type="raw" /></Property>
+  <SetProperty Id="CRAFT_MACHINE_DIR" Action="CraftMFromFOLDER" Value="[CRAFT_M_FOLDER]" After="CraftMFromDIR" Sequence="both" Condition="NOT CRAFT_MACHINE_DIR AND CRAFT_M_FOLDER" />
+  <Property Id="CRAFT_M_PATH" Secure="yes"><RegistrySearch Id="CRAFT_M_PATHSearch" Root="HKLM" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Name="Path" Type="raw" /></Property>
+  <SetProperty Id="CRAFT_MACHINE_DIR" Action="CraftMFromPATH" Value="[CRAFT_M_PATH]" After="CraftMFromFOLDER" Sequence="both" Condition="NOT CRAFT_MACHINE_DIR AND CRAFT_M_PATH" />
+  <Property Id="CRAFT_M_EXEFOLDER" Secure="yes"><RegistrySearch Id="CRAFT_MLegacyFolder" Root="HKLM" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Type="file" /></Property>
+  <Property Id="CRAFT_M_EXE" Secure="yes"><RegistrySearch Id="CRAFT_MLegacyExe" Root="HKLM" Key="Software\Microsoft\Windows\CurrentVersion\App Paths\effectcraft.exe" Type="file"><FileSearch Id="CRAFT_MLegacyFile" Name="effectcraft.exe" /></RegistrySearch></Property>
+  <SetProperty Id="CRAFT_MACHINE_DIR" Action="CraftMFromLegacyExe" Value="[CRAFT_M_EXEFOLDER]" After="CraftMFromPATH" Sequence="both" Condition="NOT CRAFT_MACHINE_DIR AND CRAFT_M_EXEFOLDER AND CRAFT_M_EXE" />
+  <Property Id="CRAFT_MACHINE_DIR" Secure="yes" />
+  <SetProperty Id="CRAFT_SCOPE" Action="CraftPreferMachineScope" Value="machine" After="CraftMFromLegacyExe" Sequence="ui" Condition="ALLUSERS = 1 OR (CRAFT_MACHINE_DIR AND NOT CRAFT_USER_DIR)" />
+  <SetProperty Id="INSTALLFOLDER" Action="CraftRestoreUserFolder" Value="[CRAFT_USER_DIR]" Before="CostInitialize" Sequence="both" Condition="NOT INSTALLFOLDER AND ALLUSERS &lt;&gt; 1 AND CRAFT_USER_DIR" />
+  <!-- The wizard can change the context after Windows Installer has already resolved Program Files for the first one.
+       Give the new-install folder explicitly so Everyone never lands in the profile and Only for me never lands in Program Files. -->
+  <?if $(sys.BUILDARCH) = x86 ?>
+  <SetProperty Id="INSTALLFOLDER" Action="CraftDefaultMachineFolder" Value="[%ProgramFiles(x86)]\ArtCraft\EffectCraft\" After="CraftRestoreUserFolder" Sequence="ui" Condition="NOT INSTALLFOLDER AND ALLUSERS = 1 AND VersionNT64" />
+  <SetProperty Id="INSTALLFOLDER" Action="CraftDefaultMachineFolder32" Value="[%ProgramFiles]\ArtCraft\EffectCraft\" After="CraftDefaultMachineFolder" Sequence="ui" Condition="NOT INSTALLFOLDER AND ALLUSERS = 1 AND NOT VersionNT64" />
+  <SetProperty Id="INSTALLFOLDER" Action="CraftDefaultUserFolder" Value="[LocalAppDataFolder]Programs\ArtCraft\EffectCraft\" After="CraftDefaultMachineFolder32" Sequence="ui" Condition="NOT INSTALLFOLDER AND ALLUSERS &lt;&gt; 1" />
+  <?else?>
+  <SetProperty Id="INSTALLFOLDER" Action="CraftDefaultMachineFolder" Value="[%ProgramW6432]\ArtCraft\EffectCraft\" After="CraftRestoreUserFolder" Sequence="ui" Condition="NOT INSTALLFOLDER AND ALLUSERS = 1" />
+  <SetProperty Id="INSTALLFOLDER" Action="CraftDefaultUserFolder" Value="[LocalAppDataFolder]Programs\ArtCraft\EffectCraft\" After="CraftDefaultMachineFolder" Sequence="ui" Condition="NOT INSTALLFOLDER AND ALLUSERS &lt;&gt; 1" />
+  <?endif?>
+  <SetProperty Id="INSTALLFOLDER" Action="CraftRestoreMachineFolder" Value="[CRAFT_MACHINE_DIR]" Before="CraftRestoreUserFolder" Sequence="both" Condition="NOT INSTALLFOLDER AND ALLUSERS = 1 AND CRAFT_MACHINE_DIR" />
+  <Launch Condition="Installed OR ALLUSERS &lt;&gt; 1 OR NOT CRAFT_USER_DIR" Message="This app is already installed for your account. Choose Only for me to update it, or uninstall that copy before changing who it is installed for." />
+  <Launch Condition="Installed OR ALLUSERS = 1 OR NOT CRAFT_MACHINE_DIR" Message="This app is already installed for everyone. Choose Everyone to update it, or pass ALLUSERS=1 to msiexec. Uninstall that copy before changing who it is installed for." />
+  <UI>
+    <TextStyle Id="CraftScopeText" FaceName="Segoe UI" Size="9" />
+    <TextStyle Id="CraftScopeTitle" FaceName="Segoe UI" Size="12" Bold="yes" />
+    <Dialog Id="CraftScopeDlg" Width="370" Height="220" Title="[ProductName] Setup" NoMinimize="yes">
+      <Control Id="Title" Type="Text" X="20" Y="15" Width="330" Height="30" Text="{\CraftScopeTitle}Who should use [ProductName]?" />
+      <Control Id="Info" Type="Text" X="20" Y="50" Width="330" Height="30" Text="{\CraftScopeText}An update keeps the existing folder. New copies use the ArtCraft folder under Programs." />
+      <Control Id="Scope" Type="RadioButtonGroup" X="20" Y="88" Width="330" Height="60" Property="CRAFT_SCOPE">
+        <RadioButtonGroup Property="CRAFT_SCOPE">
+          <RadioButton Value="user" X="0" Y="0" Width="330" Height="20" Text="Only for me (no administrator permission needed)" />
+          <RadioButton Value="machine" X="0" Y="30" Width="330" Height="20" Text="Everyone on this computer (asks an administrator)" />
+        </RadioButtonGroup>
+      </Control>
+      <Control Id="Next" Type="PushButton" X="214" Y="182" Width="66" Height="20" Default="yes" Text="Next">
+        <Publish Property="ALLUSERS" Value="1" Order="1" Condition="CRAFT_SCOPE = &quot;machine&quot;" />
+        <Publish Property="ALLUSERS" Value="{}" Order="2" Condition="CRAFT_SCOPE = &quot;user&quot;" />
+        <Publish Property="MSIINSTALLPERUSER" Value="{}" Order="3" Condition="CRAFT_SCOPE = &quot;machine&quot;" />
+        <Publish Property="MSIINSTALLPERUSER" Value="1" Order="4" Condition="CRAFT_SCOPE = &quot;user&quot;" />
+        <Publish Event="EndDialog" Value="Return" Order="5" />
+      </Control>
+      <Control Id="Cancel" Type="PushButton" X="290" Y="182" Width="60" Height="20" Cancel="yes" Text="Cancel"><Publish Event="EndDialog" Value="Exit" /></Control>
+    </Dialog>
+  </UI>
+  <InstallUISequence>
+    <Show Dialog="CraftScopeDlg" After="CraftPreferMachineScope" Condition="NOT Installed AND NOT REMOVE AND UILevel = 5" />
+    <!-- Related-product discovery runs once, so full UI must choose its context first. -->
+    <FindRelatedProducts After="CraftScopeDlg" />
+  </InstallUISequence>
+</Include>
diff --git a/packaging/windows/installer-ui.wxs b/packaging/windows/installer-ui.wxs
index 16ab58d7f..17c7efd0b 100644
--- a/packaging/windows/installer-ui.wxs
+++ b/packaging/windows/installer-ui.wxs
@@ -1,16 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-  EffectCraft installer wizard: original dialogs built from Windows Installer's own controls and
-  events (no WixUI library), included by effectcraft.wxs with <UIRef Id="EffectcraftUI" />.
-
-    fresh install:  DestDlg (folder, Change... opens BrowseDlg, desktop shortcut) -> ReadyDlg -> ProgressDlg -> ExitDlg
-    upgrade:        ReadyDlg (the installed copy's folder, not editable) -> ProgressDlg -> ExitDlg
-    already there:  MaintDlg (Repair or Remove) -> ProgressDlg -> ExitDlg
-
-  Silent installs (/qn) skip all of this; pass INSTALLFOLDER="..." to choose the folder there.
-  Folder controls edit INSTALLFOLDER indirectly through _BrowseProperty; SetTargetPath checks the
-  path and applies it, and Windows Installer reports a bad path itself.
--->
 <Wix xmlns="http://wixtoolset.org/schemas/v4/wxs">
   <Fragment>
     <UI Id="EffectcraftUI">
@@ -78,7 +66,10 @@
         <Control Id="Back" Type="PushButton" X="180" Y="243" Width="56" Height="17" Text="&amp;Back" DisableCondition="WIX_UPGRADE_DETECTED">
           <Publish Event="NewDialog" Value="DestDlg" />
         </Control>
-        <Control Id="Install" Type="PushButton" X="236" Y="243" Width="56" Height="17" Default="yes" ElevationShield="yes" Text="&amp;Install">
+        <Control Id="Install" Type="PushButton" X="236" Y="243" Width="56" Height="17" Default="yes" DefaultCondition="ALLUSERS = 1" ElevationShield="yes" HideCondition="ALLUSERS &lt;&gt; 1" ShowCondition="ALLUSERS = 1" Text="&amp;Install">
+          <Publish Event="EndDialog" Value="Return" />
+        </Control>
+        <Control Id="InstallUser" Type="PushButton" DefaultCondition="ALLUSERS &lt;&gt; 1" HideCondition="ALLUSERS = 1" ShowCondition="ALLUSERS &lt;&gt; 1" X="236" Y="243" Width="56" Height="17" Text="&amp;Install">
           <Publish Event="EndDialog" Value="Return" />
         </Control>
         <Control Id="Cancel" Type="PushButton" X="304" Y="243" Width="56" Height="17" Cancel="yes" Text="Cancel">
@@ -90,7 +81,7 @@
       <Dialog Id="MaintDlg" Width="370" Height="270" Title="[ProductName] Setup">
         <Control Id="Title" Type="Text" X="20" Y="15" Width="330" Height="20" Transparent="yes" NoPrefix="yes" Text="{\EcTitle}[ProductName] is already installed" />
         <Control Id="Description" Type="Text" X="20" Y="45" Width="330" Height="24" NoPrefix="yes" Text="Repair puts back missing or damaged files in its folder. Remove uninstalls it; your projects are not touched." />
-        <Control Id="Repair" Type="PushButton" X="20" Y="80" Width="80" Height="20" Default="yes" ElevationShield="yes" Text="&amp;Repair">
+        <Control Id="Repair" Type="PushButton" X="20" Y="80" Width="80" Height="20" Default="yes" DefaultCondition="ALLUSERS = 1" ElevationShield="yes" HideCondition="ALLUSERS &lt;&gt; 1" ShowCondition="ALLUSERS = 1" Text="&amp;Repair">
           <!-- "a": put back every file, whatever its version or date. With "e"/"o" a changed
                unversioned file (effectcraft-cli.exe has no version resource) counts as a user edit
                and is kept, and "c" only checks files that carry an MSI checksum. -->
@@ -98,7 +89,19 @@
           <Publish Event="Reinstall" Value="ALL" Order="2" />
           <Publish Event="EndDialog" Value="Return" Order="3" />
         </Control>
-        <Control Id="Remove" Type="PushButton" X="20" Y="108" Width="80" Height="20" ElevationShield="yes" Text="Re&amp;move">
+        <Control Id="RepairUser" Type="PushButton" DefaultCondition="ALLUSERS &lt;&gt; 1" HideCondition="ALLUSERS = 1" ShowCondition="ALLUSERS &lt;&gt; 1" X="20" Y="80" Width="80" Height="20" Text="&amp;Repair">
+          <!-- "a": put back every file, whatever its version or date. With "e"/"o" a changed
+               unversioned file (effectcraft-cli.exe has no version resource) counts as a user edit
+               and is kept, and "c" only checks files that carry an MSI checksum. -->
+          <Publish Event="ReinstallMode" Value="amus" Order="1" />
+          <Publish Event="Reinstall" Value="ALL" Order="2" />
+          <Publish Event="EndDialog" Value="Return" Order="3" />
+        </Control>
+        <Control Id="Remove" Type="PushButton" X="20" Y="108" Width="80" Height="20" ElevationShield="yes" HideCondition="ALLUSERS &lt;&gt; 1" ShowCondition="ALLUSERS = 1" Text="Re&amp;move">
+          <Publish Event="Remove" Value="ALL" Order="1" />
+          <Publish Event="EndDialog" Value="Return" Order="2" />
+        </Control>
+        <Control Id="RemoveUser" Type="PushButton" HideCondition="ALLUSERS = 1" ShowCondition="ALLUSERS &lt;&gt; 1" X="20" Y="108" Width="80" Height="20" Text="Re&amp;move">
           <Publish Event="Remove" Value="ALL" Order="1" />
           <Publish Event="EndDialog" Value="Return" Order="2" />
         </Control>
diff --git a/packaging/windows/package.ps1 b/packaging/windows/package.ps1
index edbb163c0..e49fde52c 100644
--- a/packaging/windows/package.ps1
+++ b/packaging/windows/package.ps1
@@ -100,6 +100,8 @@ Invoke-Native 'wix build' {
     -d "Version=$MsiVersion" -d "BinDir=$Stage" -d "IconPath=$(Join-Path $Root 'assets\app-icon\effectcraft.ico')" `
     -o $Msi
 }
+# Check the compiled scope, path and registration contract before signing.
+& (Join-Path $PSScriptRoot 'check-install-policy.ps1') -MsiPath $Msi
 # wix writes its debug symbols (.wixpdb) next to the MSI; keep them out of the release assets.
 Remove-Item -Force -ErrorAction SilentlyContinue ([IO.Path]::ChangeExtension($Msi, '.wixpdb'))
 & (Join-Path $PSScriptRoot 'sign.ps1') $Msi
diff --git a/packaging/windows/test-install-policy.ps1 b/packaging/windows/test-install-policy.ps1
new file mode 100644
index 000000000..c28fe3950
--- /dev/null
+++ b/packaging/windows/test-install-policy.ps1
@@ -0,0 +1,55 @@
+<#
+.SYNOPSIS
+  Build non-executable installer metadata fixtures; never install them.
+#>
+param(
+  [Parameter(Mandatory = $true)] [string] $OutputDirectory,
+  [ValidateSet('x64','x86','arm64')] [string[]] $Architectures = @('x64','x86','arm64')
+)
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version Latest
+$root = (Resolve-Path (Join-Path $PSScriptRoot '..\..')).Path
+$policy = Get-Content -Raw -LiteralPath (Join-Path $PSScriptRoot 'install-policy.json') | ConvertFrom-Json
+[void](New-Item -ItemType Directory -Force -Path $OutputDirectory)
+$output = (Resolve-Path -LiteralPath $OutputDirectory).Path
+& (Join-Path $PSScriptRoot 'test-legacy-fixture.ps1') -Work (Join-Path $output 'legacy-source')
+Add-Type -AssemblyName System.Drawing
+foreach ($arch in $Architectures) {
+  $stage = Join-Path $output $arch
+  [void](New-Item -ItemType Directory -Force -Path $stage)
+  foreach ($name in $policy.payloads) {
+    $destination = Join-Path $stage $name
+    [void](New-Item -ItemType Directory -Force -Path ([IO.Path]::GetDirectoryName($destination)))
+    Set-Content -LiteralPath $destination -Encoding Ascii -Value 'NON-EXECUTABLE MSI METADATA TEST FIXTURE'
+  }
+  foreach ($folder in @('docs','models','notices')) {
+    $path = Join-Path $stage $folder
+    [void](New-Item -ItemType Directory -Force -Path $path)
+    Set-Content -LiteralPath (Join-Path $path "$folder-fixture.txt") -Value 'Metadata test fixture, not a user file or model.'
+  }
+  foreach ($model in @('metadata-one.rten','metadata-two.rten')) {
+    Set-Content -LiteralPath (Join-Path (Join-Path $stage 'models') $model) -Encoding Ascii -Value 'NON-EXECUTABLE MODEL METADATA FIXTURE'
+  }
+  foreach ($spec in @(@('banner.bmp',493,58),@('dialog.bmp',493,312))) {
+    $bitmap = [Drawing.Bitmap]::new($spec[1],$spec[2],[Drawing.Imaging.PixelFormat]::Format24bppRgb)
+    try { $bitmap.Save((Join-Path $stage $spec[0]),[Drawing.Imaging.ImageFormat]::Bmp) }
+    finally { $bitmap.Dispose() }
+  }
+  Set-Content -LiteralPath (Join-Path $stage 'licence.rtf') -Encoding Ascii -Value '{\rtf1 Metadata test fixture.}'
+  $sources = @($policy.sources | ForEach-Object { Join-Path $PSScriptRoot $_ })
+  $msi = Join-Path $stage "$($policy.id)-NOT-INSTALLABLE.msi"
+  $extensions = @($policy.extensions | ForEach-Object { '-ext'; "WixToolset.$_.wixext" })
+  & wix build @sources -arch $arch @extensions `
+    -culture en-US -d 'Version=0.0.1' -d 'DisplayVersion=0.0.1-metadata-test' `
+    -d "BinDir=$stage" -d "IconPath=$(Join-Path $root $policy.icon)" `
+    -d "DocsDir=$(Join-Path $stage 'docs')" -d "ModelsDir=$(Join-Path $stage 'models')" `
+    -d "AppNoticesDir=$(Join-Path $stage 'notices')" -d 'HasCraftFontLicences=1' -d 'HasCli=1' `
+    -d "BannerBmp=$(Join-Path $stage 'banner.bmp')" -d "DialogBmp=$(Join-Path $stage 'dialog.bmp')" `
+    -d "UiBannerBmp=$(Join-Path $stage 'banner.bmp')" -d "UiDialogBmp=$(Join-Path $stage 'dialog.bmp')" `
+    -d "LicenseRtf=$(Join-Path $stage 'licence.rtf')" -o $msi @($policy.localization | ForEach-Object { '-loc'; Join-Path $PSScriptRoot $_ })
+  if ($LASTEXITCODE -ne 0) { throw "WiX validation failed for $arch (exit $LASTEXITCODE)." }
+  $shell = (Get-Process -Id $PID).Path
+  & $shell -NoProfile -ExecutionPolicy Bypass -File (Join-Path $PSScriptRoot 'check-install-policy.ps1') -MsiPath $msi
+  if ($LASTEXITCODE -ne 0) { throw "Compiled installer policy failed for $arch (exit $LASTEXITCODE)." }
+  Write-Output "PASS $arch metadata-only package. This is not an executable installer."
+}
diff --git a/packaging/windows/test-legacy-fixture.ps1 b/packaging/windows/test-legacy-fixture.ps1
new file mode 100644
index 000000000..44336dca9
--- /dev/null
+++ b/packaging/windows/test-legacy-fixture.ps1
@@ -0,0 +1,21 @@
+<# Exercise the legacy source transformation without building or installing. #>
+param([Parameter(Mandatory = $true)] [string] $Work)
+$ErrorActionPreference = 'Stop'
+[void](New-Item -ItemType Directory -Force -Path $Work)
+$source = Get-Content -Raw (Join-Path $PSScriptRoot 'test-msi.ps1')
+$start = $source.IndexOf('$Wxs =')
+$end = $source.IndexOf('$Msi = @{}', $start)
+if ($start -lt 0 -or $end -le $start) { throw 'Could not locate the legacy source transformation.' }
+# Run the test harness's exact source-producing block, with only scratch outputs.
+$block = $source.Substring($start, $end - $start).Replace('$PSScriptRoot', ("'" + $PSScriptRoot.Replace("'", "''") + "'"))
+Invoke-Expression $block
+[xml]$legacy = Get-Content -Raw $LegacyWxs
+$ns = New-Object Xml.XmlNamespaceManager($legacy.NameTable)
+$ns.AddNamespace('w', 'http://wixtoolset.org/schemas/v4/wxs')
+if ($legacy.SelectNodes('//w:RegistryValue[@Name="Path" or @Name="InstallDir" or @Name="InstallFolder"]', $ns).Count) {
+  throw 'Legacy fixture must omit every modern folder record so discovery uses the executable fallback.'
+}
+if (-not $legacy.SelectNodes('//w:RegistryValue[contains(@Value,"EffectcraftExe")]', $ns).Count) {
+  throw 'Legacy fixture must retain its executable registration.'
+}
+Write-Output 'PASS legacy fixture exposes only the executable-path fallback.'
diff --git a/packaging/windows/test-msi.ps1 b/packaging/windows/test-msi.ps1
index 5868c77b3..fbc463e4b 100644
--- a/packaging/windows/test-msi.ps1
+++ b/packaging/windows/test-msi.ps1
@@ -11,7 +11,7 @@
     3. upgrades to 0.0.3 the same way (found from the Path value 0.0.2 wrote),
     4. repairs a damaged (unversioned) CLI there with the wizard's Repair mode,
     5. uninstalls: files, the App Paths registration and the desktop shortcut go,
-    6. installs 0.0.3 with no folder and DESKTOPSHORTCUT=0: it must land in Program Files with no
+    6. installs 0.0.3 with no folder and DESKTOPSHORTCUT=0: it must land in Program Files\ArtCraft\EffectCraft (ALLUSERS=1) with no
        desktop shortcut, then uninstalls.
   The installs before step 6 take the default desktop shortcut, which upgrades keep.
   The wizard itself needs a person (or the snapshot steps in the PR); this covers what msiexec /qn
@@ -36,7 +36,9 @@ function Invoke-Native([string] $What, [scriptblock] $Block) {
 }
 function Invoke-Msiexec([string] $What, [string[]] $Arguments) {
   $log = Join-Path $Work "$($What -replace '\W', '-').log"
-  $p = Start-Process msiexec.exe -ArgumentList ($Arguments + '/qn', '/l*v', "`"$log`"") -Wait -PassThru
+  # This existing VM regression deliberately covers the all-users upgrade route.
+  $p = Start-Process msiexec.exe -ArgumentList ($Arguments + 'ALLUSERS=1', '/qn', '/norestart', '/l*v', "`"$log`"") -PassThru
+  if (-not $p.WaitForExit(300000)) { $p.Kill(); throw "msiexec ($What) exceeded five minutes; see $log" }
   if ($p.ExitCode -ne 0) { Get-Content $log -Tail 60; throw "msiexec ($What) exited $($p.ExitCode)" }
   Write-Output "ok $What"
 }
@@ -65,17 +67,20 @@ New-Item -ItemType Directory -Force -Path $Bin | Out-Null
 # The MSI only copies these. The app is versioned (it embeds VERSIONINFO); the real CLI has no
 # version resource, so its stand-in is an unversioned file too: Windows Installer keeps a changed
 # unversioned file on repair unless the repair mode forces it.
-Copy-Item (Join-Path $env:SystemRoot 'System32\notepad.exe') (Join-Path $Bin 'effectcraft.exe')
+Copy-Item (Join-Path $env:SystemRoot 'System32\cmd.exe') (Join-Path $Bin 'effectcraft.exe')
 [IO.File]::WriteAllText((Join-Path $Bin 'effectcraft-cli.exe'), 'effectcraft-cli stand-in')
+[IO.File]::WriteAllText((Join-Path $Bin 'NOTICE'), 'Test fixture notice')
 
 # 0.0.1 stands in for releases before this installer change: the same package without the App
-# Paths "Path" value.
+# Paths "Path" value or modern InstallDir/InstallFolder records.
 $Wxs = Join-Path $PSScriptRoot 'effectcraft.wxs'
 $LegacyWxs = Join-Path $Work 'effectcraft-legacy.wxs'
-$pathValue = '(?m)^.*<RegistryValue [^>]*Name="Path"[^>]*/>\r?\n'
+$pathValue = '(?m)^.*<RegistryValue [^>]*Name="(?:Path|InstallDir|InstallFolder)"[^>]*/>\r?\n'
 $text = Get-Content -Raw $Wxs
 if ($text -notmatch $pathValue) { throw "no App Paths Path value in $Wxs to leave out" }
 [IO.File]::WriteAllText($LegacyWxs, ($text -replace $pathValue, ''))
+# The legacy source lives in the scratch folder, so its local include must travel with it.
+Copy-Item (Join-Path $PSScriptRoot 'install-policy.wxi') (Join-Path $Work 'install-policy.wxi')
 
 $Msi = @{}
 foreach ($v in '0.0.1', '0.0.2', '0.0.3') {
@@ -90,7 +95,7 @@ foreach ($v in '0.0.1', '0.0.2', '0.0.3') {
 
 # Spaces and a non-ASCII letter (written as a char so the script's own encoding doesn't matter).
 $Custom = Join-Path $env:SystemDrive "EffectCraft Test $([char]0x00DC)nicode\My Apps"
-$Default = Join-Path $env:ProgramFiles 'EffectCraft'
+$Default = Join-Path $env:ProgramFiles 'ArtCraft\EffectCraft'
 if (Test-Path -LiteralPath $AppPaths) { throw 'EffectCraft is already installed here; run this on a clean machine' }
 
 Invoke-Msiexec 'install the legacy package to a custom folder' @('/i', "`"$($Msi['0.0.1'])`"", "INSTALLFOLDER=`"$Custom`"")
diff --git a/tools/requirements-sam2-reference.txt b/tools/requirements-sam2-reference.txt
new file mode 100644
index 000000000..8fab732ff
--- /dev/null
+++ b/tools/requirements-sam2-reference.txt
@@ -0,0 +1,4 @@
+# Pinned versions the SAM 2 reference fixtures were generated with (CPU).
+torch==2.7.0
+transformers==5.19.0
+safetensors==0.8.0
diff --git a/tools/sam2_reference.py b/tools/sam2_reference.py
new file mode 100644
index 000000000..2cfd03fde
--- /dev/null
+++ b/tools/sam2_reference.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+"""Dump per-stage SAM 2 reference tensors (CPU, float32) for the Rust port's reference tests.
+
+Usage: python -I tools/sam2_reference.py MODEL_DIR OUT.safetensors
+MODEL_DIR holds the facebook/sam2.1-hiera-tiny files (config.json, model.safetensors, ...).
+Versions are pinned in tools/requirements-sam2-reference.txt. The input is synthetic, so no
+media is committed; the weights are never copied into the repo.
+"""
+import sys
+
+import numpy as np
+import torch
+from safetensors.torch import save_file
+import torch.nn.functional as F
+from transformers import Sam2Model
+
+
+def synthetic_image(size=256):
+    """A textured disc over a textured background (deterministic)."""
+    rng = np.random.default_rng(7)
+    yy, xx = np.mgrid[0:size, 0:size].astype(np.float32)
+    bg = 0.3 + 0.2 * np.sin(xx / 9.0) * np.cos(yy / 7.0)
+    disc = np.hypot(xx - size * 0.45, yy - size * 0.5) < size * 0.22
+    img = np.stack([bg, bg * 0.8 + 0.1, bg * 0.6 + 0.3], -1)
+    img[disc] = np.stack([0.85 + 0.1 * np.sin(xx / 5), 0.4 + 0.1 * np.cos(yy / 5), 0.15 + 0 * xx], -1)[disc]
+    img += rng.normal(0, 0.01, img.shape).astype(np.float32)
+    return (img.clip(0, 1) * 255).astype(np.uint8)
+
+
+def main(model_dir, out):
+    torch.manual_seed(0)
+    torch.set_num_threads(1)
+    model = Sam2Model.from_pretrained(model_dir).eval()
+    image = synthetic_image()
+    # Preprocess by hand (no torchvision needed): resize to 1024x1024, ImageNet mean/std.
+    x = torch.from_numpy(image).permute(2, 0, 1)[None].float() / 255.0
+    x = F.interpolate(x, size=(1024, 1024), mode="bilinear", align_corners=False)
+    mean = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)
+    std = torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)
+    scale = 1024.0 / image.shape[0]
+    inputs = {
+        "pixel_values": (x - mean) / std,
+        "input_points": torch.tensor([[[[115.0 * scale, 128.0 * scale]]]]),
+        "input_labels": torch.tensor([[[1]]], dtype=torch.int32),
+    }
+    taps = {}
+
+    def tap(name):
+        def hook(_m, _i, o):
+            def flat(x):
+                if isinstance(x, torch.Tensor):
+                    yield x
+                elif isinstance(x, (tuple, list)):
+                    for y in x:
+                        yield from flat(y)
+                elif hasattr(x, "to_tuple"):  # a ModelOutput (the neck)
+                    yield from flat(x.to_tuple())
+
+            for k, t in enumerate(flat(o)):
+                taps[f"{name}.{k}"] = t.detach().float().clone().contiguous()
+        return hook
+
+    # Stage taps by module path: patch embed, each Hiera block, the neck, prompt encoder, decoder.
+    for name, mod in model.named_modules():
+        parts = name.split(".")
+        if name in ("vision_encoder.backbone.patch_embed", "vision_encoder.neck", "prompt_encoder", "mask_decoder") or (
+            len(parts) == 4 and parts[:3] == ["vision_encoder", "backbone", "blocks"]
+        ):
+            mod.register_forward_hook(tap(name))
+    import time
+    with torch.no_grad():
+        t0 = time.perf_counter()
+        res = model(**inputs, multimask_output=True)
+        print(f"forward (1 thread, first run): {time.perf_counter() - t0:.2f} s")
+    taps["input.pixel_values"] = inputs["pixel_values"].float()
+    taps["out.iou_scores"] = res.iou_scores.float()
+    taps["out.pred_masks"] = res.pred_masks.float()
+    save_file({k: v.clone().contiguous() for k, v in taps.items()}, out)
+    print(f"wrote {len(taps)} tensors to {out}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        sys.exit(__doc__)
+    main(sys.argv[1], sys.argv[2])
diff --git a/tools/sam2_video_reference.py b/tools/sam2_video_reference.py
new file mode 100644
index 000000000..a05223be9
--- /dev/null
+++ b/tools/sam2_video_reference.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+"""Dump SAM 2 video reference tensors (CPU, float32) for the Rust port's reference tests.
+
+Usage: python -I tools/sam2_video_reference.py MODEL_DIR OUT.safetensors
+Runs `Sam2VideoModel` on a 7-frame synthetic clip (a textured disc moving right, hidden behind a bar on
+frames 4 and 5), prompted with one click on frame 2, then tracks forward (2..6) and backward (2..0).
+Saves the preprocessed frames, every frame's low-resolution mask and object score, the stored memory
+features and object pointers, and the inputs/outputs of the memory encoder and memory attention.
+"""
+import sys
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from safetensors.torch import save_file
+from transformers import Sam2VideoModel
+from transformers.models.sam2_video.modeling_sam2_video import Sam2VideoInferenceSession
+
+T, SIZE, PROMPT_FRAME = 7, 256, 2
+
+
+def clip():
+    rng = np.random.default_rng(3)
+    yy, xx = np.mgrid[0:SIZE, 0:SIZE].astype(np.float32)
+    bg = 0.3 + 0.2 * np.sin(xx / 9.0) * np.cos(yy / 7.0)
+    frames = []
+    for t in range(T):
+        cx, cy = 80 + 12 * t, 128
+        disc = np.hypot(xx - cx, yy - cy) < 34
+        img = np.stack([bg, bg * 0.8 + 0.1, bg * 0.6 + 0.3], -1)
+        tex = 0.85 + 0.1 * np.sin((xx - cx) / 5)
+        img[disc] = np.stack([tex, 0.4 + 0.1 * np.cos((yy - cy) / 5), 0.15 + 0 * xx], -1)[disc]
+        if t in (4, 5):  # a bar hides the disc
+            img[:, int(cx) - 50 : int(cx) + 50] = 0.2
+        img += rng.normal(0, 0.01, img.shape).astype(np.float32)
+        frames.append((img.clip(0, 1) * 255).astype(np.uint8))
+    return frames, (80 + 12 * PROMPT_FRAME, 128)
+
+
+def main(model_dir, out):
+    torch.manual_seed(0)
+    torch.set_num_threads(4)
+    model = Sam2VideoModel.from_pretrained(model_dir).eval()
+    frames, click = clip()
+    mean = torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)
+    std = torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1)
+    x = torch.from_numpy(np.stack(frames)).permute(0, 3, 1, 2).float() / 255.0
+    x = F.interpolate(x, size=(1024, 1024), mode="bilinear", align_corners=False)
+    pixels = (x - mean) / std
+
+    taps = {"clip.pixel_values": pixels}
+    first = {"enc": True, "attn": True}
+
+    def enc_hook(_m, args, kwargs, out):
+        if first["enc"]:
+            first["enc"] = False
+            vf = args[0] if args else kwargs["vision_features"]
+            masks = args[1] if len(args) > 1 else kwargs["masks"]
+            taps["mem.enc.vision_features"] = vf.detach().float().clone()
+            taps["mem.enc.masks"] = masks.detach().float().clone()
+            taps["mem.enc.out_features"] = out[0].detach().float().clone()
+            taps["mem.enc.out_pos"] = out[1].detach().float().clone()
+
+    def attn_hook(_m, args, kwargs, out):
+        if first["attn"]:
+            first["attn"] = False
+            for k in ("current_vision_features", "memory", "current_vision_position_embeddings", "memory_posision_embeddings"):
+                taps[f"mem.attn.{k}"] = kwargs[k].detach().float().clone()
+            taps["mem.attn.num_pointers"] = torch.tensor([float(kwargs["num_object_pointer_tokens"])])
+            taps["mem.attn.out"] = out.detach().float().clone()
+
+    model.memory_encoder.register_forward_hook(enc_hook, with_kwargs=True)
+    model.memory_attention.register_forward_hook(attn_hook, with_kwargs=True)
+
+    sess = Sam2VideoInferenceSession(video=pixels, video_height=SIZE, video_width=SIZE, dtype=torch.float32)
+    obj_idx = sess.obj_id_to_idx(1)
+    scale = 1024.0 / SIZE
+    sess.add_point_inputs(
+        obj_idx,
+        PROMPT_FRAME,
+        {
+            "point_coords": torch.tensor([[[[click[0] * scale, click[1] * scale]]]], dtype=torch.float32),
+            "point_labels": torch.tensor([[[1]]], dtype=torch.int32),
+        },
+    )
+    sess.obj_with_new_inputs = [1]
+
+    def record(tag, o):
+        taps[f"video.{tag}.{o.frame_idx}.pred_masks"] = o.pred_masks.detach().float().clone()
+        taps[f"video.{tag}.{o.frame_idx}.score"] = o.object_score_logits.detach().float().clone()
+
+    with torch.no_grad():
+        record("prompt", model(sess, frame_idx=PROMPT_FRAME))
+        for o in model.propagate_in_video_iterator(sess, start_frame_idx=PROMPT_FRAME):
+            record("fwd", o)
+        for o in model.propagate_in_video_iterator(sess, start_frame_idx=PROMPT_FRAME, reverse=True):
+            record("rev", o)
+
+    # The same object prompted with a mask instead of a click (binary, at the model's 1024 x 1024).
+    msess = Sam2VideoInferenceSession(video=pixels, video_height=SIZE, video_width=SIZE, dtype=torch.float32)
+    mobj = msess.obj_id_to_idx(1)
+    yy, xx = np.mgrid[0:1024, 0:1024].astype(np.float32)
+    cx, cy = (80 + 12 * PROMPT_FRAME) * scale, 128 * scale
+    disc = torch.from_numpy((np.hypot(xx + 0.5 - cx, yy + 0.5 - cy) < 34 * scale).astype(np.float32))[None, None]
+    taps["maskprompt.input"] = disc.clone()
+    msess.add_mask_inputs(mobj, PROMPT_FRAME, disc)
+    msess.obj_with_new_inputs = [1]
+    with torch.no_grad():
+        o = model(msess, frame_idx=PROMPT_FRAME)
+        taps[f"maskprompt.prompt.{o.frame_idx}.pred_masks"] = o.pred_masks.detach().float().clone()
+        taps[f"maskprompt.prompt.{o.frame_idx}.score"] = o.object_score_logits.detach().float().clone()
+        for o in model.propagate_in_video_iterator(msess, start_frame_idx=PROMPT_FRAME):
+            taps[f"maskprompt.fwd.{o.frame_idx}.pred_masks"] = o.pred_masks.detach().float().clone()
+            taps[f"maskprompt.fwd.{o.frame_idx}.score"] = o.object_score_logits.detach().float().clone()
+        for o in model.propagate_in_video_iterator(msess, start_frame_idx=PROMPT_FRAME, reverse=True):
+            taps[f"maskprompt.rev.{o.frame_idx}.pred_masks"] = o.pred_masks.detach().float().clone()
+            taps[f"maskprompt.rev.{o.frame_idx}.score"] = o.object_score_logits.detach().float().clone()
+    md = msess.output_dict_per_obj[mobj]
+    for kind in ("cond_frame_outputs", "non_cond_frame_outputs"):
+        for f, oo in md[kind].items():
+            taps[f"maskstate.{f}.object_pointer"] = oo["object_pointer"].detach().float().clone()
+
+    d = sess.output_dict_per_obj[obj_idx]
+    for kind in ("cond_frame_outputs", "non_cond_frame_outputs"):
+        for f, o in d[kind].items():
+            taps[f"state.{f}.maskmem_features"] = o["maskmem_features"].detach().float().clone()
+            taps[f"state.{f}.maskmem_pos_enc"] = o["maskmem_pos_enc"].detach().float().clone()
+            taps[f"state.{f}.object_pointer"] = o["object_pointer"].detach().float().clone()
+    save_file({k: v.contiguous() for k, v in taps.items()}, out)
+    print(f"wrote {len(taps)} tensors to {out}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        sys.exit(__doc__)
+    main(sys.argv[1], sys.argv[2])
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index b9c781bce..0f8072840 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -5,8 +5,12 @@ edition.workspace = true
 license.workspace = true
 publish = false
 
+[lints]
+workspace = true
+
 [dependencies]
 serde_json = { workspace = true }
 
 chrono = { workspace = true }
 tempfile = "3"
+pkg-config = "0.3"
diff --git a/xtask/src/bench.rs b/xtask/src/bench.rs
index 55bf4ee40..96d171d2f 100644
--- a/xtask/src/bench.rs
+++ b/xtask/src/bench.rs
@@ -155,7 +155,7 @@ pub fn run(root: &Path, args: &[String]) -> Result<(), String> {
                 } else {
                     eprintln!("bench: {} {kind}", sc.name);
                 }
-                let row = measure(&bin, &dir, sc, kind, frames, &o.format, timer, &ctx)?;
+                let row = measure(&bin, &dir, sc, &Measurement { kind, frames, format: &o.format }, timer, &ctx)?;
                 append_line(&results_path, &row)?;
                 rows.push(row);
             }
@@ -679,8 +679,14 @@ fn utc(t: u64) -> String {
     format!("{y:04}-{}", dt.format("%m-%d %H:%M UTC"))
 }
 
-#[allow(clippy::too_many_arguments)]
-fn measure(bin: &Path, dir: &Path, sc: &Scenario, kind: &str, frames: u32, format: &str, timer: TimeTool, ctx: &RunContext) -> Result<Value, String> {
+struct Measurement<'a> {
+    kind: &'a str,
+    frames: u32,
+    format: &'a str,
+}
+
+fn measure(bin: &Path, dir: &Path, sc: &Scenario, measurement: &Measurement<'_>, timer: TimeTool, ctx: &RunContext) -> Result<Value, String> {
+    let Measurement { kind, frames, format } = *measurement;
     let out_dir = dir.join("out").join(format!("{}-{kind}", sc.name.replace(['/', '\\', ' '], "_")));
     let _ = std::fs::remove_dir_all(&out_dir);
     std::fs::create_dir_all(&out_dir).map_err(|e| format!("{}: {e}", out_dir.display()))?;
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index da8026d78..266f5acc3 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -50,6 +50,7 @@ const LAYERS: &[(&str, u8)] = &[
     ("expr", 3),
     ("export", 3),
     ("gpu", 3),
+    ("sam2", 3),
     ("lottie", 3),
     ("format", 3),
     ("plugin", 3),
@@ -407,6 +408,62 @@ fn serve_dir(dir: &std::path::Path, port: u16) -> Result<(), String> {
     Ok(())
 }
 
+/// The guidance printed when the ALSA pkg-config package is missing. Split out so the tests can
+/// check the package names without needing a machine that is actually missing them.
+#[cfg(target_os = "linux")]
+fn audio_backend_missing_hint(pkg_config_stderr: Option<&str>) -> String {
+    let mut hint = String::from(
+        "Linux audio needs the ALSA development package, and pkg-config cannot find it.\n\
+         The desktop app plays preview sound through cpal, whose alsa-sys dependency asks\n\
+         pkg-config for `alsa`; without the package the build dies minutes later with an\n\
+         unrelated-looking linker error.\n\
+         \n\
+         Fedora:         sudo dnf install alsa-lib-devel\n\
+         Debian/Ubuntu:  sudo apt install libasound2-dev\n\
+         Arch:           sudo pacman -S alsa-lib\n\
+         \n\
+         Install one of those and run `cargo xtask ci` again. If you cannot install it, point\n\
+         PKG_CONFIG_PATH at a directory holding an `alsa.pc` whose Libs line names your system's\n\
+         libasound (usually `libasound.so.2`); every CI run will need that variable set.",
+    );
+    if let Some(stderr) = pkg_config_stderr {
+        hint.push_str("\n\npkg-config said: ");
+        hint.push_str(stderr);
+    }
+    hint
+}
+
+/// `cargo xtask ci` builds the desktop app on the host, so on Linux it needs a usable ALSA
+/// pkg-config package before the build dies minutes later at link time. The probe goes through
+/// the same `pkg-config` crate alsa-sys's build script uses, so the executable and search-path
+/// lookup match by construction: `PKG_CONFIG` and its target-scoped variants, then `pkg-config`
+/// on `PATH` with a `pkgconf` fallback, plus the scoped `PKG_CONFIG_PATH`/`LIBDIR`/`SYSROOT_DIR`.
+/// A probe that ran and said no is "ALSA missing"; one that could not run is reported separately,
+/// so a machine with only `pkgconf` does not fail a build that would succeed.
+#[cfg(target_os = "linux")]
+fn audio_backend() -> Result<(), String> {
+    // cargo_metadata off: xtask is not a build script, so the crate's rerun-if-env lines would
+    // only clutter the ci log.
+    match pkg_config::Config::new().cargo_metadata(false).probe("alsa") {
+        Ok(_) => Ok(()),
+        Err(pkg_config::Error::ProbeFailure { output, .. }) | Err(pkg_config::Error::Failure { output, .. }) => {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            let stderr = stderr.trim();
+            Err(audio_backend_missing_hint((!stderr.is_empty()).then_some(stderr)))
+        }
+        Err(e) => Err(format!(
+            "The pkg-config probe for `alsa` could not be run: {e}. Install pkg-config (or pkgconf), \
+             or point PKG_CONFIG at a working one — it is the same lookup alsa-sys's pkg-config \
+             dependency performs."
+        )),
+    }
+}
+
+#[cfg(not(target_os = "linux"))]
+fn audio_backend() -> Result<(), String> {
+    Ok(())
+}
+
 /// Lib, bin and integration tests (examples aren't linked; clippy checked them), then doctests,
 /// which nextest doesn't run.
 ///
@@ -422,23 +479,58 @@ fn tests() -> Result<(), String> {
     let mut runs = Vec::new();
     if nextest {
         runs.push(run(Command::new(cargo).args(["nextest", "run"]).args(targets).args(["-E", "not package(effectcraft-gpu)"])));
-        runs.push(run(Command::new(cargo).args(["test", "-p", "effectcraft-gpu", "--lib", "--no-fail-fast"])));
+        // effectcraft-gpu's tests share one device, so they run in one libtest process: the
+        // binary nextest just built (`cargo test -p effectcraft-gpu` would rebuild ~2 minutes).
+        runs.push(lib_test_binary("effectcraft-gpu").and_then(|mut c| run(&mut c)));
     } else {
         println!("cargo-nextest not found, running cargo test (install: cargo install cargo-nextest --locked)");
         runs.push(run(Command::new(cargo).arg("test").args(targets)));
     }
-    // The test runs above hide a passing test's output, so the always-passing report runs again with --nocapture.
-    runs.push(run(Command::new(cargo).args(["test", "-p", "effectcraft-ui-egui", "--lib", "missing_translations_report", "--", "--nocapture"])));
+    // The test runs above hide a passing test's output, so the always-passing report runs again
+    // with --nocapture, from the binary already built.
+    runs.push(lib_test_binary("effectcraft-ui-egui").and_then(|mut c| run(c.args(["missing_translations_report", "--nocapture"]))));
     runs.push(run(Command::new(cargo).args(["test", "--workspace", "--doc", "--no-fail-fast"])));
     let failed: Vec<String> = runs.into_iter().filter_map(Result::err).collect();
     if failed.is_empty() { Ok(()) } else { Err(failed.join("; ")) }
 }
 
+/// A command running `package`'s lib test binary from the test build above, the way `cargo test`
+/// runs it (from the package directory), found with `--no-run` and the same workspace selection
+/// so nothing rebuilds: `cargo test -p <package>` resolves features for that package alone and
+/// recompiles much of the workspace.
+fn lib_test_binary(package: &str) -> Result<Command, String> {
+    let out = Command::new(env!("CARGO"))
+        .args(["test", "--workspace", "--lib", "--bins", "--tests", "--no-run", "--message-format=json-render-diagnostics"])
+        .stderr(std::process::Stdio::inherit())
+        .output()
+        .map_err(|e| format!("cargo test --no-run: {e}"))?;
+    if !out.status.success() {
+        return Err(format!("cargo test --no-run: exited with {}", out.status));
+    }
+    let lib = package.replace('-', "_");
+    String::from_utf8_lossy(&out.stdout)
+        .lines()
+        .filter_map(|line| serde_json::from_str::<Value>(line).ok())
+        .find(|m| {
+            m["reason"] == "compiler-artifact"
+                && m["profile"]["test"] == true
+                && m["target"]["name"] == lib.as_str()
+                && m["target"]["kind"].as_array().is_some_and(|k| k.iter().any(|k| k == "lib"))
+        })
+        .and_then(|m| {
+            let mut c = Command::new(m["executable"].as_str()?);
+            c.current_dir(std::path::Path::new(m["manifest_path"].as_str()?).parent()?);
+            Some(c)
+        })
+        .ok_or_else(|| format!("no {package} lib test binary in the test build"))
+}
+
 type Stage = fn() -> Result<(), String>;
 
 /// Every stage runs even when an earlier one fails, so one run reports all the problems.
 fn ci() -> Result<(), String> {
-    let stages: [(&str, Stage); 7] = [
+    let stages: [(&str, Stage); 8] = [
+        ("audio backend", audio_backend),
         ("fmt", || run(Command::new(env!("CARGO")).args(["fmt", "--check"]))),
         ("clippy", || run(Command::new(env!("CARGO")).args(["clippy", "--workspace", "--all-targets", "--", "-D", "warnings"]))),
         ("tests", tests),
@@ -459,6 +551,7 @@ fn main() -> ExitCode {
         "assets" => assets(),
         "pdf-deps" => pdf_deps::run(&root()),
         "ci" => ci(),
+        "audio-backend" => audio_backend(),
         "web" => web(&std::env::args().skip(2).collect::<Vec<_>>()),
         "bench" => bench::run(&root(), &std::env::args().skip(2).collect::<Vec<_>>()),
         "ico" => {
@@ -469,7 +562,7 @@ fn main() -> ExitCode {
             let rest: Vec<String> = std::env::args().skip(2).collect();
             version::run(&root(), &rest.iter().map(String::as_str).collect::<Vec<_>>())
         }
-        _ => Err("usage: cargo xtask <layers|assets|pdf-deps|wasm|web [--dev] [--serve PORT]|ico OUT.ico IN.png…|version [set X.Y.Z]|ci|bench [--bin CLI] [--quick] [--project F --comp C] [--compare OLD.jsonl] (--help)>".into()),
+        _ => Err("usage: cargo xtask <layers|assets|pdf-deps|wasm|web [--dev] [--serve PORT]|ico OUT.ico IN.png…|version [set X.Y.Z]|ci|audio-backend|bench [--bin CLI] [--quick] [--project F --comp C] [--compare OLD.jsonl] (--help)>".into()),
     };
     match r {
         Ok(()) => ExitCode::SUCCESS,
@@ -484,3 +577,22 @@ fn main() -> ExitCode {
 pub fn root() -> std::path::PathBuf {
     std::path::Path::new(env!("CARGO_MANIFEST_DIR")).parent().expect("xtask has a parent dir").to_path_buf()
 }
+
+#[cfg(all(test, target_os = "linux"))]
+mod tests {
+    use super::audio_backend_missing_hint;
+
+    #[test]
+    fn alsa_missing_names_the_package_for_each_distro() {
+        let e = audio_backend_missing_hint(None);
+        for want in ["alsa-lib-devel", "libasound2-dev", "alsa-lib", "pkg-config", "PKG_CONFIG_PATH"] {
+            assert!(e.contains(want), "hint lost `{want}`:\n{e}");
+        }
+    }
+
+    #[test]
+    fn alsa_missing_appends_pkg_config_s_own_detail() {
+        let e = audio_backend_missing_hint(Some("Package 'alsa' not found"));
+        assert!(e.contains("pkg-config said: Package 'alsa' not found"), "detail lost:\n{e}");
+    }
+}
diff --git a/xtask/src/pdf_deps.rs b/xtask/src/pdf_deps.rs
index d0efd830c..78694c7a6 100644
--- a/xtask/src/pdf_deps.rs
+++ b/xtask/src/pdf_deps.rs
@@ -5,7 +5,7 @@ use std::process::Command;
 
 use serde_json::Value;
 
-const REV: &str = "9f75d3dc19b4b514c4f3d4847ed1ec1b0e86b4ef";
+const REV: &str = "92d392cff132eaf53e13afff77f38b5c11b73aa0";
 const PACKAGES: &[(&str, &str)] = &[("craft-pdf", "0.1.0"), ("hayro-syntax", "0.7.2"), ("hayro-jbig2", "0.3.0")];
 
 pub fn run(root: &Path) -> Result<(), String> {
diff --git a/xtask/tests/bench.rs b/xtask/tests/bench.rs
index 641b0d56b..3b2ad5722 100644
--- a/xtask/tests/bench.rs
+++ b/xtask/tests/bench.rs
@@ -2,6 +2,11 @@
 use serde_json::{Value, json};
 use std::process::{Command, Output};
 
+/// Nextest archives relocate binaries; plain Cargo keeps the compile-time path valid.
+fn binary() -> std::ffi::OsString {
+    std::env::var_os("NEXTEST_BIN_EXE_xtask").unwrap_or_else(|| env!("CARGO_BIN_EXE_xtask").into())
+}
+
 struct ResultsDir(tempfile::TempDir);
 impl ResultsDir {
     fn new() -> Self {
@@ -12,7 +17,7 @@ impl ResultsDir {
         let candidate = self.0.path().join("candidate.jsonl");
         std::fs::write(&baseline, old).unwrap();
         std::fs::write(&candidate, new).unwrap();
-        let mut command = Command::new(env!("CARGO_BIN_EXE_xtask"));
+        let mut command = Command::new(binary());
         command.args(["bench", "--compare"]).arg(baseline).arg("--with").arg(candidate);
         if gate {
             command.args(["--fail-over", "5"]);
diff --git a/xtask/tests/it/audio_probe.rs b/xtask/tests/it/audio_probe.rs
new file mode 100644
index 000000000..d984c7637
--- /dev/null
+++ b/xtask/tests/it/audio_probe.rs
@@ -0,0 +1,126 @@
+//! The Linux audio-backend preflight against fake pkg-config tools.
+//!
+//! The probe resolves its executable through the pkg-config crate, which reads the environment,
+//! so the fake-tool scenarios run the real `xtask audio-backend` binary in a child process with a
+//! controlled environment: `Command::env` changes only the child's environment, so the tests need
+//! no global env mutation and stay parallel-safe.
+
+use std::ffi::OsStr;
+use std::path::PathBuf;
+use std::process::{Command, Output};
+
+/// A scratch directory holding the fake tools for one scenario: `dir` is the child's `PATH`,
+/// `off_path` holds executables reachable only by an explicit `*_PKG_CONFIG` override.
+struct FakeTools {
+    dir: PathBuf,
+    off_path: PathBuf,
+}
+
+impl FakeTools {
+    fn new(tag: &str) -> Self {
+        let base = std::env::temp_dir().join(format!("effectcraft-xtask-audio-{tag}-{}", std::process::id()));
+        let dir = base.join("bin");
+        let off_path = base.join("off-path");
+        std::fs::create_dir_all(&dir).expect("create PATH dir");
+        std::fs::create_dir_all(&off_path).expect("create off-PATH dir");
+        Self { dir, off_path }
+    }
+
+    /// Write a plain (not executable) file.
+    fn file(&self, on_path: bool, name: &str, body: &str) -> PathBuf {
+        let path = if on_path { self.dir.clone() } else { self.off_path.clone() }.join(name);
+        std::fs::write(&path, body).expect("write fake tool");
+        path
+    }
+
+    /// Write an executable shell script.
+    fn script(&self, on_path: bool, name: &str, body: &str) -> PathBuf {
+        use std::os::unix::fs::PermissionsExt;
+        let path = self.file(on_path, name, body);
+        std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).expect("chmod fake tool");
+        path
+    }
+
+    /// A fake `pkgconf` that answers as alsa 1.2.11 linking -lasound.
+    fn working_pkgconf(&self, on_path: bool) -> PathBuf {
+        self.script(on_path, "pkgconf", "#!/bin/sh\ncase \" $* \" in\n  *\" --modversion \"*) echo 1.2.11 ;;\n  *) echo -lasound ;;\nesac\n")
+    }
+}
+
+impl Drop for FakeTools {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.dir);
+        let _ = std::fs::remove_dir_all(&self.off_path);
+    }
+}
+
+/// Run the built `xtask audio-backend` with `dir` as the only `PATH`, the given variables set,
+/// and every variable the probe reads otherwise cleared, so a developer's own environment
+/// cannot leak into the scenario.
+fn run_audio_backend(tools: &FakeTools, set: &[(&str, &OsStr)]) -> Output {
+    Command::new(env!("CARGO_BIN_EXE_xtask"))
+        .arg("audio-backend")
+        .env("PATH", &tools.dir)
+        .env_remove("PKG_CONFIG")
+        .env_remove("PKG_CONFIG_PATH")
+        .env_remove("PKG_CONFIG_LIBDIR")
+        .env_remove("PKG_CONFIG_SYSROOT_DIR")
+        .env_remove("PKG_CONFIG_ALLOW_CROSS")
+        .env_remove("ALSA_NO_PKG_CONFIG")
+        .env_remove("HOST_PKG_CONFIG")
+        .env_remove("TARGET_PKG_CONFIG")
+        .env_remove("HOST")
+        .env_remove("TARGET")
+        .envs(set.iter().copied())
+        .output()
+        .expect("run xtask audio-backend")
+}
+
+#[test]
+fn a_host_with_only_pkgconf_still_finds_alsa() {
+    // The reviewed case: PKG_CONFIG unset, no pkg-config on PATH, only pkgconf. The pkg-config
+    // crate alsa-sys uses falls back to pkgconf, so the stage must stay green.
+    let tools = FakeTools::new("pkgconf-only");
+    tools.working_pkgconf(true);
+    let out = run_audio_backend(&tools, &[]);
+    assert!(out.status.success(), "pkgconf-only host must pass:\n{}", String::from_utf8_lossy(&out.stderr));
+}
+
+#[test]
+fn a_probe_that_runs_and_says_no_names_the_package() {
+    let tools = FakeTools::new("says-no");
+    tools.script(true, "pkg-config", "#!/bin/sh\necho 'Package alsa was not found' >&2\nexit 1\n");
+    let out = run_audio_backend(&tools, &[]);
+    assert!(!out.status.success());
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    for want in ["alsa-lib-devel", "libasound2-dev", "alsa-lib", "pkg-config"] {
+        assert!(stderr.contains(want), "hint lost `{want}`:\n{stderr}");
+    }
+    assert!(stderr.contains("not found"), "pkg-config's own detail should be appended:\n{stderr}");
+}
+
+#[test]
+fn a_probe_that_cannot_run_is_not_alsa_missing() {
+    // PKG_CONFIG names a file that is not an executable; with PKG_CONFIG set the crate does not
+    // fall back to pkgconf, so the lookup fails to launch — reported separately from "missing".
+    let tools = FakeTools::new("cannot-run");
+    let broken = tools.file(true, "not-an-executable", "this is not a program\n");
+    let out = run_audio_backend(&tools, &[("PKG_CONFIG", broken.as_os_str())]);
+    assert!(!out.status.success());
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    assert!(stderr.contains("could not"), "expected the launch-failure error:\n{stderr}");
+    assert!(!stderr.contains("alsa-lib-devel"), "must not read as ALSA missing:\n{stderr}");
+}
+
+#[test]
+fn a_host_scoped_override_selects_that_executable() {
+    // With TARGET and HOST set (build-script style), HOST_PKG_CONFIG wins over the PATH lookup,
+    // and here it is the only working tool — so success proves the override was used.
+    let tools = FakeTools::new("scoped");
+    let good = tools.working_pkgconf(false);
+    let out = run_audio_backend(
+        &tools,
+        &[("HOST", OsStr::new("x86_64-unknown-linux-gnu")), ("TARGET", OsStr::new("x86_64-unknown-linux-gnu")), ("HOST_PKG_CONFIG", good.as_os_str())],
+    );
+    assert!(out.status.success(), "HOST_PKG_CONFIG override must be honored:\n{}", String::from_utf8_lossy(&out.stderr));
+}
diff --git a/xtask/tests/it/main.rs b/xtask/tests/it/main.rs
new file mode 100644
index 000000000..f2c41c738
--- /dev/null
+++ b/xtask/tests/it/main.rs
@@ -0,0 +1,4 @@
+//! xtask's integration tests: one binary, modules in `tests/it/`.
+
+#[cfg(target_os = "linux")]
+mod audio_probe;